diff --git a/substrate/.cargo/config.toml b/substrate/.cargo/config.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4796a2c26965c1021d14c6acc854bca1aea76941
--- /dev/null
+++ b/substrate/.cargo/config.toml
@@ -0,0 +1,33 @@
+#
+# An auto defined `clippy` feature was introduced,
+# but it was found to clash with user defined features,
+# so was renamed to `cargo-clippy`.
+#
+# If you want standard clippy run:
+# RUSTFLAGS= cargo clippy
+[target.'cfg(feature = "cargo-clippy")']
+rustflags = [
+  "-Aclippy::all",
+  "-Dclippy::correctness",
+  "-Aclippy::if-same-then-else",
+  "-Aclippy::clone-double-ref",
+  "-Dclippy::complexity",
+  "-Aclippy::zero-prefixed-literal",     # 00_1000_000
+  "-Aclippy::type_complexity",           # raison d'etre
+  "-Aclippy::nonminimal-bool",           # maybe
+  "-Aclippy::borrowed-box",              # Reasonable to fix this one
+  "-Aclippy::too-many-arguments",        # (Turning this on would lead to)
+  "-Aclippy::unnecessary_cast",          # Types may change
+  "-Aclippy::identity-op",               # One case where we do 0 +
+  "-Aclippy::useless_conversion",        # Types may change
+  "-Aclippy::unit_arg",                  # styalistic.
+  "-Aclippy::option-map-unit-fn",        # styalistic
+  "-Aclippy::bind_instead_of_map",       # styalistic
+  "-Aclippy::erasing_op",                # E.g. 0 * DOLLARS
+  "-Aclippy::eq_op",                     # In tests we test equality.
+  "-Aclippy::while_immutable_condition", # false positives
+  "-Aclippy::needless_option_as_deref",  # false positives
+  "-Aclippy::derivable_impls",           # false positives
+  "-Aclippy::stable_sort_primitive",     # prefer stable sort
+  "-Aclippy::extra-unused-type-parameters", # stylistic
+]
diff --git a/substrate/.config/nextest.toml b/substrate/.config/nextest.toml
new file mode 100644
index 0000000000000000000000000000000000000000..eb0ed09cad92ba0286a64e7c65d5b24e39f191f3
--- /dev/null
+++ b/substrate/.config/nextest.toml
@@ -0,0 +1,124 @@
+# This is the default config used by nextest. It is embedded in the binary at
+# build time. It may be used as a template for .config/nextest.toml.
+
+[store]
+# The directory under the workspace root at which nextest-related files are
+# written. Profile-specific storage is currently written to dir/<profile-name>.
+dir = "target/nextest"
+
+# This section defines the default nextest profile. Custom profiles are layered
+# on top of the default profile.
+[profile.default]
+# "retries" defines the number of times a test should be retried. If set to a
+# non-zero value, tests that succeed on a subsequent attempt will be marked as
+# non-flaky. Can be overridden through the `--retries` option.
+# Examples
+# * retries = 3
+# * retries = { backoff = "fixed", count = 2, delay = "1s" }
+# * retries = { backoff = "exponential", count = 10, delay = "1s", jitter = true, max-delay = "10s" }
+retries = 5
+
+# The number of threads to run tests with. Supported values are either an integer or
+# the string "num-cpus". Can be overridden through the `--test-threads` option.
+test-threads = "num-cpus"
+
+# The number of threads required for each test. This is generally used in overrides to
+# mark certain tests as heavier than others. However, it can also be set as a global parameter.
+threads-required = 1
+
+# Show these test statuses in the output.
+#
+# The possible values this can take are:
+# * none: no output
+# * fail: show failed (including exec-failed) tests
+# * retry: show flaky and retried tests
+# * slow: show slow tests
+# * pass: show passed tests
+# * skip: show skipped tests (most useful for CI)
+# * all: all of the above
+#
+# Each value includes all the values above it; for example, "slow" includes
+# failed and retried tests.
+#
+# Can be overridden through the `--status-level` flag.
+status-level = "pass"
+
+# Similar to status-level, show these test statuses at the end of the run.
+final-status-level = "flaky"
+
+# "failure-output" defines when standard output and standard error for failing tests are produced.
+# Accepted values are
+# * "immediate": output failures as soon as they happen
+# * "final": output failures at the end of the test run
+# * "immediate-final": output failures as soon as they happen and at the end of
+#   the test run; combination of "immediate" and "final"
+# * "never": don't output failures at all
+#
+# For large test suites and CI it is generally useful to use "immediate-final".
+#
+# Can be overridden through the `--failure-output` option.
+failure-output = "immediate"
+
+# "success-output" controls production of standard output and standard error on success. This should
+# generally be set to "never".
+success-output = "never"
+
+# Cancel the test run on the first failure. For CI runs, consider setting this
+# to false.
+fail-fast = true
+
+# Treat a test that takes longer than the configured 'period' as slow, and print a message.
+# See <https://nexte.st/book/slow-tests> for more information.
+#
+# Optional: specify the parameter 'terminate-after' with a non-zero integer,
+# which will cause slow tests to be terminated after the specified number of
+# periods have passed.
+# Example: slow-timeout = { period = "60s", terminate-after = 2 }
+slow-timeout = { period = "60s" }
+
+# Treat a test as leaky if after the process is shut down, standard output and standard error
+# aren't closed within this duration.
+#
+# This usually happens in case of a test that creates a child process and lets it inherit those
+# handles, but doesn't clean the child process up (especially when it fails).
+#
+# See <https://nexte.st/book/leaky-tests> for more information.
+leak-timeout = "100ms"
+
+[profile.default.junit]
+# Output a JUnit report into the given file inside 'store.dir/<profile-name>'.
+# If unspecified, JUnit is not written out.
+
+path = "junit.xml"
+
+# The name of the top-level "report" element in JUnit report. If aggregating
+# reports across different test runs, it may be useful to provide separate names
+# for each report.
+report-name = "substrate"
+
+# Whether standard output and standard error for passing tests should be stored in the JUnit report.
+# Output is stored in the <system-out> and <system-err> elements of the <testcase> element.
+store-success-output = false
+
+# Whether standard output and standard error for failing tests should be stored in the JUnit report.
+# Output is stored in the <system-out> and <system-err> elements of the <testcase> element.
+#
+# Note that if a description can be extracted from the output, it is always stored in the
+# <description> element.
+store-failure-output = true
+
+# This profile is activated if MIRI_SYSROOT is set.
+[profile.default-miri]
+# Miri tests take up a lot of memory, so only run 1 test at a time by default.
+test-threads = 1
+
+# Mutual exclusion of tests with `cargo build` invocation as a lock to avoid multiple
+# simultaneous invocations clobbering each other.
+[test-groups]
+serial-integration = { max-threads = 1 }
+
+# Running UI tests sequentially
+# More info can be found here: https://github.com/paritytech/ci_cd/issues/754
+[[profile.default.overrides]]
+filter = 'test(/(^ui$|_ui|ui_)/)'
+test-group = 'serial-integration'
diff --git a/substrate/.dockerignore b/substrate/.dockerignore
new file mode 100644
index 0000000000000000000000000000000000000000..c58599e3fb72be03556abb220f8421f51e8d49df
--- /dev/null
+++ b/substrate/.dockerignore
@@ -0,0 +1,7 @@
+doc
+**target*
+.idea/
+Dockerfile
+.dockerignore
+.local
+.env*
diff --git a/substrate/.editorconfig b/substrate/.editorconfig
new file mode 100644
index 0000000000000000000000000000000000000000..50cc9dacd7e42215d1f3cf8745fbcb59905ecff0
--- /dev/null
+++ b/substrate/.editorconfig
@@ -0,0 +1,27 @@
+root = true
+[*]
+indent_style=tab
+indent_size=tab
+tab_width=4
+end_of_line=lf
+charset=utf-8
+trim_trailing_whitespace=true
+max_line_length=100
+insert_final_newline=true
+
+[*.md]
+max_line_length=80
+indent_style=space
+indent_size=2
+
+[*.yml]
+indent_style=space
+indent_size=2
+tab_width=8
+end_of_line=lf
+
+[*.sh]
+indent_style=space
+indent_size=2
+tab_width=8
+end_of_line=lf
diff --git a/substrate/.git-blame-ignore-revs b/substrate/.git-blame-ignore-revs
new file mode 100644
index 0000000000000000000000000000000000000000..c99a3070231d8e3ec6ed1365fdd1221c162779b8
--- /dev/null
+++ b/substrate/.git-blame-ignore-revs
@@ -0,0 +1,15 @@
+# You can easily exclude big automated code changes by running
+#
+#     git config blame.ignoreRevsFile .git-blame-ignore-revs
+#
+# in your local repository. It will work also in IDE integrations.
+#
+# On versions of Git 2.20 and later comments (#), empty lines, and any leading and
+# trailing whitespace is ignored. Everything but a SHA-1 per line will error out on
+# older versions.
+#
+# You should add new commit hashes to this file when you create or find such big
+# automated refactorings while reading code history. If you only know the short hash,
+# use `git rev-parse 1d5abf01` to expand it to the full SHA1 hash needed in this file.
+
+1d5abf01abafdb6c15bcd0172f5de09fd87c5fbf # Run cargo fmt on the whole code base (#9394)
diff --git a/substrate/.gitattributes b/substrate/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..a77c52fccdb778ebfd76020760d45bcb4da922ab
--- /dev/null
+++ b/substrate/.gitattributes
@@ -0,0 +1,4 @@
+Cargo.lock linguist-generated=true
+/.gitlab-ci.yml filter=ci-prettier
+/scripts/ci/gitlab/pipeline/*.yml filter=ci-prettier
+frame/**/src/weights.rs linguist-generated=true
diff --git a/substrate/.github/ISSUE_TEMPLATE/bug.yaml b/substrate/.github/ISSUE_TEMPLATE/bug.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ae40df08eca761dc75a4a66cd3912666ba457912
--- /dev/null
+++ b/substrate/.github/ISSUE_TEMPLATE/bug.yaml
@@ -0,0 +1,34 @@
+name: Bug Report
+description: Let us know about an issue you experienced with this software
+# labels: ["some existing label","another one"]
+body:
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue?
+      description: Please search to see if an issue already exists and leave a comment that you also experienced this issue or add your specifics that are related to an existing issue.
+      options:
+        - label: I have searched the existing issues
+          required: true
+  - type: checkboxes
+    attributes:
+      label: Experiencing problems? Have you tried our Stack Exchange first?
+      description: Please search <https://substrate.stackexchange.com> to see if an post already exists, and ask if not. Please do not file support issues here.
+      options:
+        - label: This is not a support question.
+          required: true
+  - type: textarea
+    id: bug
+    attributes:
+      label: Description of bug
+      # description: What seems to be the problem?
+      # placeholder: Describe the problem.
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: Provide the steps that led to the discovery of the issue.
+      # placeholder: Describe what you were doing so we can reproduce the problem.
+    validations:
+      required: false
diff --git a/substrate/.github/ISSUE_TEMPLATE/config.yml b/substrate/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e422e317411f3d801b8c1c3b1c1e5a238dcb5a9f
--- /dev/null
+++ b/substrate/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,7 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Support & Troubleshooting with the Substrate Stack Exchange Community
+    url: https://substrate.stackexchange.com
+    about: |
+      For general problems with Substrate or related technologies, please search here first
+      for solutions, by keyword and tags. If you discover no solution, please then ask and questions in our community! We highly encourage everyone also share their understanding by answering questions for others.
diff --git a/substrate/.github/ISSUE_TEMPLATE/feature.yaml b/substrate/.github/ISSUE_TEMPLATE/feature.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6a59522ab4b4829fae056fcadf006393cbd58a1a
--- /dev/null
+++ b/substrate/.github/ISSUE_TEMPLATE/feature.yaml
@@ -0,0 +1,55 @@
+name: Feature Request
+description: Submit your requests and suggestions to improve!
+labels: ["J0-enhancement"]
+body:
+  - type: checkboxes
+    id: existing
+    attributes:
+      label: Is there an existing issue?
+      description: Please search to see if an issue already exists and leave a comment that you also experienced this issue or add your specifics that are related to an existing issue.
+      options:
+        - label: I have searched the existing issues
+          required: true
+  - type: checkboxes
+    id: stackexchange
+    attributes:
+      label: Experiencing problems? Have you tried our Stack Exchange first?
+      description: Please search <https://substrate.stackexchange.com> to see if an post already exists, and ask if not. Please do not file support issues here.
+      options:
+        - label: This is not a support question.
+          required: true
+  - type: textarea
+    id: motivation
+    attributes:
+      label: Motivation
+      description: Please give precedence as to what lead you to file this issue.
+      # placeholder: Describe ...
+    validations:
+      required: false
+  - type: textarea
+    id: request
+    attributes:
+      label: Request
+      description: Please describe what is needed.
+      # placeholder: Describe what you would like to see added or changed.
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: Solution
+      description: If possible, please describe what a solution could be.
+      # placeholder: Describe what you would like to see added or changed.
+    validations:
+      required: false
+  - type: dropdown
+    id: help
+    attributes:
+      label: Are you willing to help with this request?
+      multiple: true
+      options:
+        - Yes!
+        - No.
+        - Maybe (please elaborate above)
+    validations:
+      required: true
diff --git a/substrate/.github/dependabot.yml b/substrate/.github/dependabot.yml
new file mode 100644
index 0000000000000000000000000000000000000000..04cf0d1e1a5a4fa5bcdfeaa3e3ec378b0cc20de4
--- /dev/null
+++ b/substrate/.github/dependabot.yml
@@ -0,0 +1,12 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    labels: ["A2-insubstantial", "B0-silent", "C1-low", "E2-dependencies"]
+    schedule:
+      interval: "daily"
+  - package-ecosystem: github-actions
+    directory: '/'
+    labels: ["A2-insubstantial", "B0-silent", "C1-low", "E2-dependencies"]
+    schedule:
+      interval: daily
diff --git a/substrate/.github/pr-custom-review.yml b/substrate/.github/pr-custom-review.yml
new file mode 100644
index 0000000000000000000000000000000000000000..059f4a283af075c2e23c6d65be8803a6b8898ec9
--- /dev/null
+++ b/substrate/.github/pr-custom-review.yml
@@ -0,0 +1,39 @@
+# 🔒 PROTECTED: Changes to locks-review-team should be approved by the current locks-review-team
+locks-review-team: locks-review
+team-leads-team: polkadot-review
+action-review-team: ci
+
+rules:
+  - name: Core developers
+    check_type: changed_files
+    condition:
+      include: .*
+      # excluding files from 'CI team' and 'FRAME coders' rules
+      exclude: ^\.gitlab-ci\.yml|^scripts/ci/.*|^\.github/.*|^\.config/nextest.toml|^frame/(?!.*(nfts/.*|uniques/.*|babe/.*|grandpa/.*|beefy|merkle-mountain-range/.*|contracts/.*|election|nomination-pools/.*|staking/.*|aura/.*))
+    min_approvals: 2
+    teams:
+      - core-devs
+
+  - name: FRAME coders
+    check_type: changed_files
+    condition:
+      include: ^frame/(?!.*(nfts/.*|uniques/.*|babe/.*|grandpa/.*|beefy|merkle-mountain-range/.*|contracts/.*|election|nomination-pools/.*|staking/.*|aura/.*))
+    all:
+      - min_approvals: 2
+        teams:
+          - core-devs
+      - min_approvals: 1
+        teams:
+          - frame-coders
+
+  - name: CI team
+    check_type: changed_files
+    condition:
+      include: ^\.gitlab-ci\.yml|^scripts/ci/.*|^\.github/.*|^\.config/nextest.toml
+    min_approvals: 2
+    teams:
+      - ci
+
+prevent-review-request:
+  teams:
+    - core-devs
diff --git a/substrate/.github/stale.yml b/substrate/.github/stale.yml
new file mode 100644
index 0000000000000000000000000000000000000000..61d0fd0228d97afaee6e9a9d30d0440d7fb1f670
--- /dev/null
+++ b/substrate/.github/stale.yml
@@ -0,0 +1,18 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 30
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 14
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - "D9-needsaudit 👮"
+# Label to use when marking an issue as stale
+staleLabel: "A3-stale"
+# we only bother with pull requests
+only: pulls
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  Hey, is anyone still working on this? Due to the inactivity this issue has
+  been automatically marked as stale. It will be closed if no further activity
+  occurs. Thank you for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false
diff --git a/substrate/.github/workflows/auto-label-issues.yml b/substrate/.github/workflows/auto-label-issues.yml
new file mode 100644
index 0000000000000000000000000000000000000000..629966ed3961835f1d987b09a8a4419366b1e9b7
--- /dev/null
+++ b/substrate/.github/workflows/auto-label-issues.yml
@@ -0,0 +1,17 @@
+# If the author of the issues is not a contributor to the project, label
+# the issue with 'Z0-unconfirmed'
+
+name: Label New Issues
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  label-new-issues:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Label drafts
+        uses: andymckay/labeler@e6c4322d0397f3240f0e7e30a33b5c5df2d39e90 # 1.0.4
+        if: github.event.issue.author_association == 'NONE'
+        with:
+          add-labels: "J2-unconfirmed"
diff --git a/substrate/.github/workflows/burnin-label-notification.yml b/substrate/.github/workflows/burnin-label-notification.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f45455d31db1e2dcd9ed34708630304312a3168a
--- /dev/null
+++ b/substrate/.github/workflows/burnin-label-notification.yml
@@ -0,0 +1,24 @@
+name: Notify devops when burn-in label applied
+on:
+  pull_request:
+    types: [labeled]
+
+jobs:
+  notify-devops:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        channel:
+          - name: 'Team: DevOps'
+            room: '!lUslSijLMgNcEKcAiE:parity.io'
+
+    steps:
+      - name: Notify devops
+        if: startsWith(github.event.label.name, 'A1-')
+        uses: s3krit/matrix-message-action@70ad3fb812ee0e45ff8999d6af11cafad11a6ecf # v0.0.3
+        with:
+          room_id: ${{ matrix.channel.room }}
+          access_token: ${{ secrets.RELEASENOTES_MATRIX_V2_ACCESS_TOKEN }}
+          server: "m.parity.io"
+          message: |
+            @room Burn-in request received for [${{ github.event.pull_request.title }}](${{ github.event.pull_request.html_url }})
diff --git a/substrate/.github/workflows/check-D-labels.yml b/substrate/.github/workflows/check-D-labels.yml
new file mode 100644
index 0000000000000000000000000000000000000000..7bb358ce1182e4b4bae1dc94bd986567cee1b599
--- /dev/null
+++ b/substrate/.github/workflows/check-D-labels.yml
@@ -0,0 +1,48 @@
+name: Check D labels
+
+on:
+  pull_request:
+    types: [labeled, opened, synchronize, unlabeled]
+    paths:
+      - frame/**
+      - primitives/**
+
+env:
+  IMAGE: paritytech/ruled_labels:0.4.0
+
+jobs:
+  check-labels:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Pull image
+        run: docker pull $IMAGE
+
+      - name: Check labels
+        env:
+          MOUNT: /work
+          GITHUB_PR: ${{ github.event.pull_request.number }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          API_BASE: https://api.github.com/repos
+          REPO: ${{ github.repository }}
+          RULES_PATH: labels/ruled_labels
+          CHECK_SPECS: specs_substrate.yaml
+        run: |
+          echo "REPO: ${REPO}"
+          echo "GITHUB_PR: ${GITHUB_PR}"
+          # Clone repo with labels specs
+          git clone https://github.com/paritytech/labels
+          # Fetch the labels for the PR under test
+          labels=$( curl -H "Authorization: token ${GITHUB_TOKEN}" -s "$API_BASE/${REPO}/pulls/${GITHUB_PR}" | jq '.labels | .[] | .name' | tr "\n" ",")
+
+          if [ -z "${labels}" ]; then
+            docker run --rm -i -v $PWD/${RULES_PATH}/:$MOUNT $IMAGE check $MOUNT/$CHECK_SPECS --tags audit --no-label
+          fi
+
+          labels_args=${labels: :-1}
+          printf "Checking labels: %s\n" "${labels_args}"
+
+          # Prevent the shell from splitting labels with spaces
+          IFS=","
+
+          # --dev is more useful to debug mode to debug
+          docker run --rm -i -v $PWD/${RULES_PATH}/:$MOUNT $IMAGE check $MOUNT/$CHECK_SPECS --labels ${labels_args} --dev --tags audit
diff --git a/substrate/.github/workflows/check-labels.yml b/substrate/.github/workflows/check-labels.yml
new file mode 100644
index 0000000000000000000000000000000000000000..55b8f7389fa7f128b7134549b8517c9677bd9562
--- /dev/null
+++ b/substrate/.github/workflows/check-labels.yml
@@ -0,0 +1,45 @@
+name: Check labels
+
+on:
+  pull_request:
+    types: [labeled, opened, synchronize, unlabeled]
+
+env:
+  IMAGE: paritytech/ruled_labels:0.4.0
+
+jobs:
+  check-labels:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Pull image
+        run: docker pull $IMAGE
+
+      - name: Check labels
+        env:
+          MOUNT: /work
+          GITHUB_PR: ${{ github.event.pull_request.number }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          API_BASE: https://api.github.com/repos
+          REPO: ${{ github.repository }}
+          RULES_PATH: labels/ruled_labels
+          CHECK_SPECS: specs_substrate.yaml
+        run: |
+          echo "REPO: ${REPO}"
+          echo "GITHUB_PR: ${GITHUB_PR}"
+          # Clone repo with labels specs
+          git clone https://github.com/paritytech/labels
+          # Fetch the labels for the PR under test
+          labels=$( curl -H "Authorization: token ${GITHUB_TOKEN}" -s "$API_BASE/${REPO}/pulls/${GITHUB_PR}" | jq '.labels | .[] | .name' | tr "\n" ",")
+
+          if [ -z "${labels}" ]; then
+            docker run --rm -i -v $PWD/${RULES_PATH}/:$MOUNT $IMAGE check $MOUNT/$CHECK_SPECS --tags PR --no-label
+          fi
+
+          labels_args=${labels: :-1}
+          printf "Checking labels: %s\n" "${labels_args}"
+
+          # Prevent the shell from splitting labels with spaces
+          IFS=","
+
+          # --dev is more useful to debug mode to debug
+          docker run --rm -i -v $PWD/${RULES_PATH}/:$MOUNT $IMAGE check $MOUNT/$CHECK_SPECS --labels ${labels_args} --dev --tags PR
diff --git a/substrate/.github/workflows/md-link-check.yml b/substrate/.github/workflows/md-link-check.yml
new file mode 100644
index 0000000000000000000000000000000000000000..e1387f6da13f71396cdd761f0967a2c35c7169eb
--- /dev/null
+++ b/substrate/.github/workflows/md-link-check.yml
@@ -0,0 +1,19 @@
+name: Check Links
+
+on:
+  pull_request:
+    branches:
+    - master
+  push:
+    branches:
+    - master
+
+jobs:
+  markdown-link-check:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: gaurav-nelson/github-action-markdown-link-check@0a51127e9955b855a9bbfa1ff5577f1d1338c9a5 # 1.0.14
+      with:
+        use-quiet-mode: 'yes'
+        config-file: '.github/workflows/mlc_config.json'
diff --git a/substrate/.github/workflows/mlc_config.json b/substrate/.github/workflows/mlc_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..e7e620b39e0a9b2dd60eb57498ba99c1b6635443
--- /dev/null
+++ b/substrate/.github/workflows/mlc_config.json
@@ -0,0 +1,7 @@
+{
+    "ignorePatterns": [
+        {
+            "pattern": "^https://crates.io",
+        }
+    ]
+}
diff --git a/substrate/.github/workflows/monthly-tag.yml b/substrate/.github/workflows/monthly-tag.yml
new file mode 100644
index 0000000000000000000000000000000000000000..055207d85a4dd22b65097a0c3b41f1896c358954
--- /dev/null
+++ b/substrate/.github/workflows/monthly-tag.yml
@@ -0,0 +1,43 @@
+name: Monthly Snapshot Tag
+
+on:
+  schedule:
+    - cron: "0 1 1 * *"
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Take Snapshot
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get the tags by date
+        id: tags
+        run: |
+          echo "new=$(date +'monthly-%Y-%m')" >> $GITHUB_OUTPUT
+          echo "old=$(date -d'1 month ago' +'monthly-%Y-%m')" >> $GITHUB_OUTPUT
+      - name: Checkout branch "master"
+        uses: actions/checkout@v3
+        with:
+          ref: 'master'
+          fetch-depth: 0
+      - name: Generate changelog
+        id: changelog
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          echo "# Automatic snapshot pre-release ${{ steps.tags.outputs.new }}" > Changelog.md
+          echo "" >> Changelog.md
+          echo "## Changes since last snapshot (${{ steps.tags.outputs.old }})" >> Changelog.md
+          echo "" >> Changelog.md
+          ./scripts/ci/github/generate_changelog.sh ${{ steps.tags.outputs.old }} >>  Changelog.md
+      - name: Release snapshot
+        id: release-snapshot
+        uses: actions/create-release@0cb9c9b65d5d1901c1f53e5e66eaf4afd303e70e # v1.1.4 latest version, repo archived
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ steps.tags.outputs.new }}
+          release_name: ${{ steps.tags.outputs.new }}
+          draft: false
+          prerelease: true
+          body_path: Changelog.md
diff --git a/substrate/.github/workflows/pr-custom-review.yml b/substrate/.github/workflows/pr-custom-review.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8e40c9ee72989d9ef244247456aa578d3836f8c6
--- /dev/null
+++ b/substrate/.github/workflows/pr-custom-review.yml
@@ -0,0 +1,42 @@
+name: Assign reviewers
+
+on:
+  pull_request:
+    branches:
+      - master
+      - main
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - review_requested
+      - review_request_removed
+      - ready_for_review
+      - converted_to_draft
+  pull_request_review:
+
+jobs:
+  pr-custom-review:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Skip if pull request is in Draft
+        # `if: github.event.pull_request.draft == true` should be kept here, at
+        # the step level, rather than at the job level. The latter is not
+        # recommended because when the PR is moved from "Draft" to "Ready to
+        # review" the workflow will immediately be passing (since it was skipped),
+        # even though it hasn't actually ran, since it takes a few seconds for
+        # the workflow to start. This is also disclosed in:
+        # https://github.community/t/dont-run-actions-on-draft-pull-requests/16817/17
+        # That scenario would open an opportunity for the check to be bypassed:
+        # 1. Get your PR approved
+        # 2. Move it to Draft
+        # 3. Push whatever commits you want
+        # 4. Move it to "Ready for review"; now the workflow is passing (it was
+        #    skipped) and "Check reviews" is also passing (it won't be updated
+        #    until the workflow is finished)
+        if: github.event.pull_request.draft == true
+        run: exit 1
+      - name: pr-custom-review
+        uses: paritytech/pr-custom-review@action-v3
+        with:
+          checks-reviews-api: http://pcr.parity-prod.parity.io/api/v1/check_reviews
diff --git a/substrate/.github/workflows/release-bot.yml b/substrate/.github/workflows/release-bot.yml
new file mode 100644
index 0000000000000000000000000000000000000000..05bea32abc697e4f0aa5ce42f30f7cc475cfa63a
--- /dev/null
+++ b/substrate/.github/workflows/release-bot.yml
@@ -0,0 +1,31 @@
+name: Pushes release updates to a pre-defined Matrix room
+on:
+  release:
+    types:
+      - edited
+      - prereleased
+      - published
+jobs:
+  ping_matrix:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        channel:
+          - name: 'General: Rust, Polkadot, Substrate'
+            room: '!aJymqQYtCjjqImFLSb:parity.io'
+            pre-release: false
+
+    steps:
+      - name: send message
+        uses: s3krit/matrix-message-action@70ad3fb812ee0e45ff8999d6af11cafad11a6ecf # v0.0.3
+        with:
+          room_id: ${{ matrix.channel.room }}
+          access_token: ${{ secrets.RELEASENOTES_MATRIX_V2_ACCESS_TOKEN }}
+          server: "m.parity.io"
+          message: |
+            ***${{github.event.repository.full_name}}:*** A release has been ${{github.event.action}}<br/>
+            Release version [${{github.event.release.tag_name}}](${{github.event.release.html_url}})
+
+            -----
+
+            ${{github.event.release.body}}<br/>
diff --git a/substrate/.github/workflows/release-tagging.yml b/substrate/.github/workflows/release-tagging.yml
new file mode 100644
index 0000000000000000000000000000000000000000..1862582f40eba2f33a5d94fd356870d4f4c49cce
--- /dev/null
+++ b/substrate/.github/workflows/release-tagging.yml
@@ -0,0 +1,20 @@
+# Github action to ensure the `release` tag always tracks latest release
+
+name: Retag release
+
+on:
+  release:
+    types: [ published ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Set Git tag
+        uses: s3krit/walking-tag-action@d04f7a53b72ceda4e20283736ce3627011275178 # latest version from master
+        with:
+          tag-name: release
+          tag-message: Latest release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/substrate/.gitignore b/substrate/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..65059279f3a551802b43962c88b1f0b6e8c2a142
--- /dev/null
+++ b/substrate/.gitignore
@@ -0,0 +1,30 @@
+**/target/
+**/*.rs.bk
+*.swp
+.wasm-binaries
+pwasm-alloc/target/
+pwasm-libc/target/
+pwasm-alloc/Cargo.lock
+pwasm-libc/Cargo.lock
+bin/node/runtime/wasm/target/
+**/._*
+**/.criterion/
+.vscode
+polkadot.*
+.DS_Store
+.idea/
+nohup.out
+rls*.log
+*.orig
+*.rej
+**/wip/*.stderr
+.local
+**/hfuzz_target/
+**/hfuzz_workspace/
+.cargo-remote.toml
+*.bin
+*.iml
+bin/node-template/Cargo.lock
+substrate.code-workspace
+.direnv/
+/.envrc
diff --git a/substrate/.gitlab-ci.yml b/substrate/.gitlab-ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f00836528973ecb068f8075d647d94236e293904
--- /dev/null
+++ b/substrate/.gitlab-ci.yml
@@ -0,0 +1,412 @@
+# .gitlab-ci.yml
+#
+# substrate
+#
+# pipelines can be triggered manually in the web
+#
+# Currently the file is divided into subfiles. Each stage has a different file which
+# can be found here: scripts/ci/gitlab/pipeline/<stage_name>.yml
+#
+# Instead of YAML anchors "extends" is used.
+# Useful links:
+#    https://docs.gitlab.com/ee/ci/yaml/index.html#extends
+#    https://docs.gitlab.com/ee/ci/yaml/yaml_optimization.html#reference-tags
+#
+# SAMPLE JOB TEMPLATE - This is not a complete example but is enough to build a
+# simple CI job. For full documentation, visit https://docs.gitlab.com/ee/ci/yaml/
+#
+# my-example-job:
+#   stage:                           test # One of the stages listed below this job (required)
+#   image:                           paritytech/tools:latest # Any docker image (required)
+#   allow_failure:                   true # Allow the pipeline to continue if this job fails (default: false)
+#   needs:
+#     - job:                         test-linux # Any jobs that are required to run before this job (optional)
+#   variables:
+#     MY_ENVIRONMENT_VARIABLE:       "some useful value" # Environment variables passed to the job (optional)
+#   script:
+#     - echo "List of shell commands to run in your job"
+#     - echo "You can also just specify a script here, like so:"
+#     - ./scripts/ci/gitlab/my_amazing_script.sh
+
+stages:
+  - check
+  - test
+  - build
+  - publish
+  - notify
+  - zombienet
+  - deploy
+
+workflow:
+  rules:
+    - if: $CI_COMMIT_TAG
+    - if: $CI_COMMIT_BRANCH
+
+variables:
+  GIT_STRATEGY: fetch
+  GIT_DEPTH: 100
+  CARGO_INCREMENTAL: 0
+  DOCKER_OS: "debian:bullseye"
+  ARCH: "x86_64"
+  CI_IMAGE: !reference [.ci-unified, variables, CI_IMAGE]
+  BUILDAH_IMAGE: "quay.io/buildah/stable:v1.29"
+  BUILDAH_COMMAND: "buildah --storage-driver overlay2"
+  RELENG_SCRIPTS_BRANCH: "master"
+
+  RUSTY_CACHIER_SINGLE_BRANCH: master
+  RUSTY_CACHIER_DONT_OPERATE_ON_MAIN_BRANCH: "true"
+  RUSTY_CACHIER_MINIO_ALIAS: rustycachier_gcs
+  RUSTY_CACHIER_MINIO_BUCKET: parity-build-rusty-cachier
+  RUSTY_CACHIER_COMPRESSION_METHOD: zstd
+
+  NEXTEST_FAILURE_OUTPUT: immediate-final
+  NEXTEST_SUCCESS_OUTPUT: final
+  ZOMBIENET_IMAGE: "docker.io/paritytech/zombienet:v1.3.55"
+
+default:
+  retry:
+    max: 2
+    when:
+      - runner_system_failure
+      - unknown_failure
+      - api_failure
+  cache: {}
+  interruptible: true
+
+.collect-artifacts:
+  artifacts:
+    name: "${CI_JOB_NAME}_${CI_COMMIT_REF_NAME}"
+    when: on_success
+    expire_in: 7 days
+    paths:
+      - artifacts/
+
+.collect-artifacts-short:
+  artifacts:
+    name: "${CI_JOB_NAME}_${CI_COMMIT_REF_NAME}"
+    when: on_success
+    expire_in: 3 hours
+    paths:
+      - artifacts/
+
+.prepare-env:
+  before_script:
+    # TODO: remove unset invocation when we'll be free from 'ENV RUSTC_WRAPPER=sccache' & sccache
+    # itself in all images
+    - unset RUSTC_WRAPPER
+    # $WASM_BUILD_WORKSPACE_HINT enables wasm-builder to find the Cargo.lock from within generated
+    # packages
+    - export WASM_BUILD_WORKSPACE_HINT="$PWD"
+    # ensure that RUSTFLAGS are set correctly
+    - echo $RUSTFLAGS
+
+.job-switcher:
+  before_script:
+    - if echo "$CI_DISABLED_JOBS" | grep -xF "$CI_JOB_NAME"; then echo "The job has been cancelled in CI settings"; exit 0; fi
+
+.kubernetes-env:
+  image: "${CI_IMAGE}"
+  before_script:
+    - !reference [.timestamp, before_script]
+    - !reference [.job-switcher, before_script]
+    - !reference [.prepare-env, before_script]
+  tags:
+    - kubernetes-parity-build
+
+.rust-info-script:
+  script:
+    - rustup show
+    - cargo --version
+    - rustup +nightly show
+    - cargo +nightly --version
+
+.pipeline-stopper-vars:
+  script:
+    - !reference [.job-switcher, before_script]
+    - echo "Collecting env variables for the cancel-pipeline job"
+    - echo "FAILED_JOB_URL=${CI_JOB_URL}" > pipeline-stopper.env
+    - echo "FAILED_JOB_NAME=${CI_JOB_NAME}" >> pipeline-stopper.env
+    - echo "PR_NUM=${CI_COMMIT_REF_NAME}" >> pipeline-stopper.env
+
+.pipeline-stopper-artifacts:
+  artifacts:
+    reports:
+      dotenv: pipeline-stopper.env
+
+.docker-env:
+  image: "${CI_IMAGE}"
+  before_script:
+    - !reference [.timestamp, before_script]
+    - !reference [.job-switcher, before_script]
+    - !reference [.prepare-env, before_script]
+    - !reference [.rust-info-script, script]
+    - !reference [.rusty-cachier, before_script]
+    - !reference [.pipeline-stopper-vars, script]
+  after_script:
+    - !reference [.rusty-cachier, after_script]
+  tags:
+    - linux-docker-vm-c2
+
+# rusty-cachier's hidden job. Parts of this job are used to instrument the pipeline's other real jobs with rusty-cachier
+# Description of the commands is available here - https://gitlab.parity.io/parity/infrastructure/ci_cd/rusty-cachier/client#description
+.rusty-cachier:
+  before_script:
+    - curl -s https://gitlab-ci-token:${CI_JOB_TOKEN}@gitlab.parity.io/parity/infrastructure/ci_cd/rusty-cachier/client/-/raw/release/util/install.sh | bash
+    - rusty-cachier environment check --gracefully
+    - $(rusty-cachier environment inject)
+    - rusty-cachier project mtime
+  after_script:
+    - env RUSTY_CACHIER_SUPRESS_OUTPUT=true rusty-cachier snapshot destroy
+
+.test-refs:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_COMMIT_REF_NAME == "master"
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ # PRs
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+
+# handle the specific case where benches could store incorrect bench data because of the downstream staging runs
+# exclude cargo-check-benches from such runs
+.test-refs-check-benches:
+  rules:
+    - if: $CI_COMMIT_REF_NAME == "master" && $CI_PIPELINE_SOURCE == "pipeline"  && $CI_IMAGE =~ /staging$/
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_COMMIT_REF_NAME == "master"
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ # PRs
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+
+.test-refs-no-trigger:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_COMMIT_REF_NAME == "master"
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ # PRs
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+    - if: $CI_COMMIT_REF_NAME =~ /^ci-release-.*$/
+
+.test-refs-no-trigger-prs-only:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ # PRs
+
+.publish-refs:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_COMMIT_REF_NAME == "master"
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+
+.build-refs:
+  # publish-refs + PRs
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_COMMIT_REF_NAME == "master"
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ # PRs
+
+.zombienet-refs:
+  extends: .build-refs
+
+.crates-publishing-variables:
+  variables:
+    CRATESIO_CRATES_OWNER: parity-crate-owner
+    REPO: substrate
+    REPO_OWNER: paritytech
+
+.crates-publishing-pipeline:
+  extends: .crates-publishing-variables
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule" && $CI_COMMIT_REF_NAME == "master" && $PIPELINE == "automatic-crate-publishing"
+
+.crates-publishing-template:
+  extends:
+    - .docker-env
+    - .crates-publishing-variables
+  # collect artifacts even on failure so that we know how the crates were generated (they'll be
+  # generated to the artifacts folder according to SPUB_TMP further down)
+  artifacts:
+    name: "${CI_JOB_NAME}_${CI_COMMIT_REF_NAME}"
+    when: always
+    expire_in: 7 days
+    paths:
+      - artifacts/
+  variables:
+    SPUB_TMP: artifacts
+    # disable timestamping for the crate publishing jobs, they leave stray child processes behind
+    # which don't interact well with the timestamping script
+    CI_DISABLE_TIMESTAMP: 1
+
+#### stage:                       .pre
+
+check-crates-publishing-pipeline:
+  stage: .pre
+  extends:
+    - .kubernetes-env
+    - .crates-publishing-pipeline
+  script:
+    - git clone
+      --depth 1
+      --branch "$RELENG_SCRIPTS_BRANCH"
+      https://github.com/paritytech/releng-scripts.git
+    - ONLY_CHECK_PIPELINE=true ./releng-scripts/publish-crates
+
+# By default our pipelines are interruptible, but some special pipelines shouldn't be interrupted:
+# * multi-project pipelines such as the ones triggered by the scripts repo
+# * the scheduled automatic-crate-publishing pipeline
+#
+# In those cases, we add an uninterruptible .pre job; once that one has started,
+# the entire pipeline becomes uninterruptible
+uninterruptible-pipeline:
+  extends: .kubernetes-env
+  variables:
+    CI_IMAGE: "paritytech/tools:latest"
+  stage: .pre
+  interruptible: false
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+    - if: $CI_PIPELINE_SOURCE == "schedule" && $PIPELINE == "automatic-crate-publishing"
+  script: "true"
+
+include:
+  # check jobs
+  - scripts/ci/gitlab/pipeline/check.yml
+  # tests jobs
+  - scripts/ci/gitlab/pipeline/test.yml
+  # build jobs
+  - scripts/ci/gitlab/pipeline/build.yml
+  # publish jobs
+  - scripts/ci/gitlab/pipeline/publish.yml
+  # zombienet jobs
+  - scripts/ci/gitlab/pipeline/zombienet.yml
+  # The crate-publishing pipeline requires a customized `interruptible` configuration. Unfortunately
+  # `interruptible` can't currently be dynamically set based on variables as per:
+  # - https://gitlab.com/gitlab-org/gitlab/-/issues/38349
+  # - https://gitlab.com/gitlab-org/gitlab/-/issues/194023
+  # Thus we work around that limitation by using conditional includes.
+  # For crate-publishing pipelines: run it with defaults + `interruptible: false`. The WHOLE
+  # pipeline is made uninterruptible to ensure that test jobs also get a chance to run to
+  # completion, because the publishing jobs depends on them AS INTENDED: crates should not be
+  # published before their source code is checked.
+  - project: parity/infrastructure/ci_cd/shared
+    ref: main
+    file: /common/timestamp.yml
+  - project: parity/infrastructure/ci_cd/shared
+    ref: main
+    file: /common/ci-unified.yml
+
+
+#### stage:                        notify
+
+# This job notifies rusty-cachier about the latest commit with the cache.
+# This info is later used for the cache distribution and an overlay creation.
+# Note that we don't use any .rusty-cachier references as we assume that a pipeline has reached this stage with working rusty-cachier.
+rusty-cachier-notify:
+  stage: notify
+  extends: .kubernetes-env
+  variables:
+    CI_IMAGE: paritytech/rusty-cachier-env:latest
+    GIT_STRATEGY: none
+  dependencies: []
+  script:
+    - curl -s https://gitlab-ci-token:${CI_JOB_TOKEN}@gitlab.parity.io/parity/infrastructure/ci_cd/rusty-cachier/client/-/raw/release/util/install.sh | bash
+    - rusty-cachier cache notify
+
+#### stage:                        .post
+
+# This job cancels the whole pipeline if any of provided jobs fail.
+# In a DAG, every jobs chain is executed independently of others. The `fail_fast` principle suggests
+# to fail the pipeline as soon as possible to shorten the feedback loop.
+.cancel-pipeline-template:
+  stage: .post
+  rules:
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ # PRs
+      when: on_failure
+  variables:
+    PROJECT_ID: "${CI_PROJECT_ID}"
+    PROJECT_NAME: "${CI_PROJECT_NAME}"
+    PIPELINE_ID: "${CI_PIPELINE_ID}"
+    FAILED_JOB_URL: "${FAILED_JOB_URL}"
+    FAILED_JOB_NAME: "${FAILED_JOB_NAME}"
+    PR_NUM: "${PR_NUM}"
+  trigger:
+    project: "parity/infrastructure/ci_cd/pipeline-stopper"
+
+remove-cancel-pipeline-message:
+  stage: .post
+  rules:
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ # PRs
+  variables:
+    PROJECT_ID: "${CI_PROJECT_ID}"
+    PROJECT_NAME: "${CI_PROJECT_NAME}"
+    PIPELINE_ID: "${CI_PIPELINE_ID}"
+    FAILED_JOB_URL: "https://gitlab.com"
+    FAILED_JOB_NAME: "nope"
+    PR_NUM: "${CI_COMMIT_REF_NAME}"
+  trigger:
+    project: "parity/infrastructure/ci_cd/pipeline-stopper"
+    branch: "as-improve"
+
+# need to copy jobs this way because otherwise gitlab will wait
+# for all 3 jobs to finish instead of cancelling if one fails
+cancel-pipeline-test-linux-stable1:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: "test-linux-stable 1/3"
+
+cancel-pipeline-test-linux-stable2:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: "test-linux-stable 2/3"
+
+cancel-pipeline-test-linux-stable3:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: "test-linux-stable 3/3"
+
+cancel-pipeline-cargo-check-benches1:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: "cargo-check-benches 1/2"
+
+cancel-pipeline-cargo-check-benches2:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: "cargo-check-benches 2/2"
+
+cancel-pipeline-test-linux-stable-int:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: test-linux-stable-int
+
+cancel-pipeline-cargo-check-each-crate-1:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: "cargo-check-each-crate 1/2"
+
+cancel-pipeline-cargo-check-each-crate-2:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: "cargo-check-each-crate 2/2"
+
+cancel-pipeline-cargo-check-each-crate-macos:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: cargo-check-each-crate-macos
+
+cancel-pipeline-check-tracing:
+  extends: .cancel-pipeline-template
+  needs:
+    - job: check-tracing
diff --git a/substrate/.maintain/build-only-wasm.sh b/substrate/.maintain/build-only-wasm.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b6da3319c8214aeca3ca54b76fda87d83077eec5
--- /dev/null
+++ b/substrate/.maintain/build-only-wasm.sh
@@ -0,0 +1,29 @@
+#!/usr/bin/env sh
+
+# Script for building only the WASM binary of the given project.
+
+set -e
+
+PROJECT_ROOT=`git rev-parse --show-toplevel`
+
+if [ "$#" -lt 1 ]; then
+  echo "You need to pass the name of the crate you want to compile!"
+  exit 1
+fi
+
+WASM_BUILDER_RUNNER="$PROJECT_ROOT/target/release/wbuild-runner/$1"
+
+if [ -z "$2" ]; then
+  export WASM_TARGET_DIRECTORY=$(pwd)
+else
+  export WASM_TARGET_DIRECTORY=$2
+fi
+
+if [ -d $WASM_BUILDER_RUNNER ]; then
+  export DEBUG=false
+  export OUT_DIR="$PROJECT_ROOT/target/release/build"
+  cargo run --release --manifest-path="$WASM_BUILDER_RUNNER/Cargo.toml" \
+    | grep -vE "cargo:rerun-if-|Executing build command"
+else
+  cargo build --release -p $1
+fi
diff --git a/substrate/.maintain/docs-index-tpl.ejs b/substrate/.maintain/docs-index-tpl.ejs
new file mode 100644
index 0000000000000000000000000000000000000000..81c619a926b2bd413e9dd1edba016853c2ab46fd
--- /dev/null
+++ b/substrate/.maintain/docs-index-tpl.ejs
@@ -0,0 +1,55 @@
+<%
+  const capFirst = s => (s && s[0].toUpperCase() + s.slice(1)) || "";
+%>
+
+<!DOCTYPE html>
+<html lang="en">
+
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title><%= capFirst(repo_name) %> Rustdocs</title>
+    <meta name="description" content="Nothing here." />
+    <meta name="robots" content="noindex">
+    <style>
+      body {
+        font-family: Helvetica, Arial, Sans Serif;
+        margin: 0;
+      }
+      .center-me {
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        height: 100vh;
+      }
+      .content {
+        display: block;
+      }
+      .content li {
+        font-size: 1em;
+        line-height: .4em;
+        padding: .8em 0;
+      }
+    </style>
+  </head>
+
+  <body>
+    <div class="center-me">
+      <div class="content">
+        <h1><%= capFirst(repo_name) %> Rustdocs</h1>
+        <section>
+          <ul>
+          <%_ deploy_refs.split(/\s+/).forEach(ref => { _%>
+            <li>
+              <a href="/<%= repo_name _%>/<%= ref _%>"><%- ref -%></a>
+              <%_ if (latest && latest.trim() !== '' && latest === ref) { _%>
+                (<a href="/<%= repo_name _%>/latest">latest</a>)
+              <%_ } _%>
+            </li>
+          <%_ }) _%>
+          </ul>
+        </section>
+      </div>
+    </div>
+  </body>
+</html>
diff --git a/substrate/.maintain/frame-weight-template.hbs b/substrate/.maintain/frame-weight-template.hbs
new file mode 100644
index 0000000000000000000000000000000000000000..ecd384a514563cfb4ecb0e9f364cdf473f5b5cec
--- /dev/null
+++ b/substrate/.maintain/frame-weight-template.hbs
@@ -0,0 +1,121 @@
+{{header}}
+//! Autogenerated weights for `{{pallet}}`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION {{version}}
+//! DATE: {{date}}, STEPS: `{{cmd.steps}}`, REPEAT: `{{cmd.repeat}}`, LOW RANGE: `{{cmd.lowest_range_values}}`, HIGH RANGE: `{{cmd.highest_range_values}}`
+//! WORST CASE MAP SIZE: `{{cmd.worst_case_map_values}}`
+//! HOSTNAME: `{{hostname}}`, CPU: `{{cpuname}}`
+//! WASM-EXECUTION: `{{cmd.wasm_execution}}`, CHAIN: `{{cmd.chain}}`, DB CACHE: `{{cmd.db_cache}}`
+
+// Executed Command:
+{{#each args as |arg|}}
+// {{arg}}
+{{/each}}
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `{{pallet}}`.
+pub trait WeightInfo {
+	{{#each benchmarks as |benchmark|}}
+	fn {{benchmark.name~}}
+	(
+		{{~#each benchmark.components as |c| ~}}
+		{{c.name}}: u32, {{/each~}}
+	) -> Weight;
+	{{/each}}
+}
+
+/// Weights for `{{pallet}}` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+{{#if (eq pallet "frame_system")}}
+impl<T: crate::Config> WeightInfo for SubstrateWeight<T> {
+{{else}}
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+{{/if}}
+	{{#each benchmarks as |benchmark|}}
+	{{#each benchmark.comments as |comment|}}
+	/// {{comment}}
+	{{/each}}
+	{{#each benchmark.component_ranges as |range|}}
+	/// The range of component `{{range.name}}` is `[{{range.min}}, {{range.max}}]`.
+	{{/each}}
+	fn {{benchmark.name~}}
+	(
+		{{~#each benchmark.components as |c| ~}}
+		{{~#if (not c.is_used)}}_{{/if}}{{c.name}}: u32, {{/each~}}
+	) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `{{benchmark.base_recorded_proof_size}}{{#each benchmark.component_recorded_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		//  Estimated: `{{benchmark.base_calculated_proof_size}}{{#each benchmark.component_calculated_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		// Minimum execution time: {{underscore benchmark.min_execution_time}}_000 picoseconds.
+		Weight::from_parts({{underscore benchmark.base_weight}}, {{benchmark.base_calculated_proof_size}})
+			{{#each benchmark.component_weight as |cw|}}
+			// Standard Error: {{underscore cw.error}}
+			.saturating_add(Weight::from_parts({{underscore cw.slope}}, 0).saturating_mul({{cw.name}}.into()))
+			{{/each}}
+			{{#if (ne benchmark.base_reads "0")}}
+			.saturating_add(T::DbWeight::get().reads({{benchmark.base_reads}}_u64))
+			{{/if}}
+			{{#each benchmark.component_reads as |cr|}}
+			.saturating_add(T::DbWeight::get().reads(({{cr.slope}}_u64).saturating_mul({{cr.name}}.into())))
+			{{/each}}
+			{{#if (ne benchmark.base_writes "0")}}
+			.saturating_add(T::DbWeight::get().writes({{benchmark.base_writes}}_u64))
+			{{/if}}
+			{{#each benchmark.component_writes as |cw|}}
+			.saturating_add(T::DbWeight::get().writes(({{cw.slope}}_u64).saturating_mul({{cw.name}}.into())))
+			{{/each}}
+			{{#each benchmark.component_calculated_proof_size as |cp|}}
+			.saturating_add(Weight::from_parts(0, {{cp.slope}}).saturating_mul({{cp.name}}.into()))
+			{{/each}}
+	}
+	{{/each}}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	{{#each benchmarks as |benchmark|}}
+	{{#each benchmark.comments as |comment|}}
+	/// {{comment}}
+	{{/each}}
+	{{#each benchmark.component_ranges as |range|}}
+	/// The range of component `{{range.name}}` is `[{{range.min}}, {{range.max}}]`.
+	{{/each}}
+	fn {{benchmark.name~}}
+	(
+		{{~#each benchmark.components as |c| ~}}
+		{{~#if (not c.is_used)}}_{{/if}}{{c.name}}: u32, {{/each~}}
+	) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `{{benchmark.base_recorded_proof_size}}{{#each benchmark.component_recorded_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		//  Estimated: `{{benchmark.base_calculated_proof_size}}{{#each benchmark.component_calculated_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		// Minimum execution time: {{underscore benchmark.min_execution_time}}_000 picoseconds.
+		Weight::from_parts({{underscore benchmark.base_weight}}, {{benchmark.base_calculated_proof_size}})
+			{{#each benchmark.component_weight as |cw|}}
+			// Standard Error: {{underscore cw.error}}
+			.saturating_add(Weight::from_parts({{underscore cw.slope}}, 0).saturating_mul({{cw.name}}.into()))
+			{{/each}}
+			{{#if (ne benchmark.base_reads "0")}}
+			.saturating_add(RocksDbWeight::get().reads({{benchmark.base_reads}}_u64))
+			{{/if}}
+			{{#each benchmark.component_reads as |cr|}}
+			.saturating_add(RocksDbWeight::get().reads(({{cr.slope}}_u64).saturating_mul({{cr.name}}.into())))
+			{{/each}}
+			{{#if (ne benchmark.base_writes "0")}}
+			.saturating_add(RocksDbWeight::get().writes({{benchmark.base_writes}}_u64))
+			{{/if}}
+			{{#each benchmark.component_writes as |cw|}}
+			.saturating_add(RocksDbWeight::get().writes(({{cw.slope}}_u64).saturating_mul({{cw.name}}.into())))
+			{{/each}}
+			{{#each benchmark.component_calculated_proof_size as |cp|}}
+			.saturating_add(Weight::from_parts(0, {{cp.slope}}).saturating_mul({{cp.name}}.into()))
+			{{/each}}
+	}
+	{{/each}}
+}
diff --git a/substrate/.maintain/getgoing.sh b/substrate/.maintain/getgoing.sh
new file mode 100644
index 0000000000000000000000000000000000000000..98f360837d04aca82569eeb04dc2147803b69641
--- /dev/null
+++ b/substrate/.maintain/getgoing.sh
@@ -0,0 +1,6 @@
+/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+brew install openssl cmake
+curl https://sh.rustup.rs -sSf | sh
+source ~/.cargo/env
+cargo install --git https://github.com/paritytech/substrate subkey
+cargo install --git https://github.com/paritytech/substrate substrate
diff --git a/substrate/.maintain/init.sh b/substrate/.maintain/init.sh
new file mode 100755
index 0000000000000000000000000000000000000000..1405a41ef333e6af863080d83f854d3edb5fb4fa
--- /dev/null
+++ b/substrate/.maintain/init.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -e
+
+echo "*** Initializing WASM build environment"
+
+if [ -z $CI_PROJECT_NAME ] ; then
+   rustup update nightly
+   rustup update stable
+fi
+
+rustup target add wasm32-unknown-unknown --toolchain nightly
diff --git a/substrate/.maintain/local-docker-test-network/docker-compose.yml b/substrate/.maintain/local-docker-test-network/docker-compose.yml
new file mode 100644
index 0000000000000000000000000000000000000000..53e2a2913f38b8d15003543a6a9668aa63f29c86
--- /dev/null
+++ b/substrate/.maintain/local-docker-test-network/docker-compose.yml
@@ -0,0 +1,153 @@
+# Docker compose file to start a multi node local test network.
+#
+# # Nodes
+#
+# - Validator node A
+# - Validator node B
+# - Light client C
+#
+# # Auxiliary nodes
+#
+# - Prometheus monitoring each node.
+# - Grafana pointed at the Prometheus node, configured with all dashboards.
+#
+# # Usage
+#
+# 1. Build `target/release/substrate` binary: `cargo build --release`
+# 2. Start networks and containers:
+#    `sudo docker-compose -f .maintain/sentry-node/docker-compose.yml up`
+# 3. Connect to nodes:
+#   - validator-a: localhost:9944
+#   - validator-b: localhost:9945
+#   - light-c: localhost:9946
+#   - via polkadot.js/apps: https://polkadot.js.org/apps/?rpc=ws%3A%2F%2Flocalhost%3A<NODE_PORT>#/explorer
+#   - grafana: localhost:3001
+#   - prometheus: localhost:9090
+
+
+version: "3.7"
+services:
+
+  validator-a:
+    ports:
+      - "9944:9944"
+      - "9615:9615"
+    volumes:
+      - ../../target/release/substrate:/usr/local/bin/substrate
+    image: parity/substrate
+    networks:
+      - internet
+    command:
+      - "--node-key"
+      - "0000000000000000000000000000000000000000000000000000000000000001"
+      - "--base-path"
+      - "/tmp/alice"
+      - "--chain=local"
+      - "--port"
+      - "30333"
+      - "--validator"
+      - "--alice"
+      - "--bootnodes"
+      - "/dns/validator-b/tcp/30333/p2p/12D3KooWHdiAxVd8uMQR1hGWXccidmfCwLqcMpGwR6QcTP6QRMuD"
+      # Not only bind to localhost.
+      - "--unsafe-ws-external"
+      - "--unsafe-rpc-external"
+      - "--log"
+      - "sub-libp2p=trace"
+      - "--no-telemetry"
+      - "--rpc-cors"
+      - "all"
+      - "--prometheus-external"
+
+  validator-b:
+    image: parity/substrate
+    ports:
+      - "9945:9944"
+    volumes:
+      - ../../target/release/substrate:/usr/local/bin/substrate
+    networks:
+      - internet
+    command:
+      - "--node-key"
+      - "0000000000000000000000000000000000000000000000000000000000000002"
+      - "--base-path"
+      - "/tmp/bob"
+      - "--chain=local"
+      - "--port"
+      - "30333"
+      - "--validator"
+      - "--bob"
+      - "--bootnodes"
+      - "/dns/validator-a/tcp/30333/p2p/12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp"
+      - "--no-telemetry"
+      - "--rpc-cors"
+      - "all"
+      # Not only bind to localhost.
+      - "--unsafe-ws-external"
+      - "--unsafe-rpc-external"
+      - "--log"
+      - "sub-libp2p=trace"
+      - "--prometheus-external"
+
+  light-c:
+    image: parity/substrate
+    ports:
+      - "9946:9944"
+    volumes:
+      - ../../target/release/substrate:/usr/local/bin/substrate
+    networks:
+      - internet
+    command:
+      - "--node-key"
+      - "0000000000000000000000000000000000000000000000000000000000000003"
+      - "--base-path"
+      - "/tmp/light"
+      - "--chain=local"
+      - "--port"
+      - "30333"
+      - "--light"
+      - "--bootnodes"
+      - "/dns/validator-a/tcp/30333/p2p/12D3KooWEyoppNCUx8Yx66oV9fJnriXwCcXwDDUA2kj6vnc6iDEp"
+      - "--bootnodes"
+      - "/dns/validator-b/tcp/30333/p2p/12D3KooWHdiAxVd8uMQR1hGWXccidmfCwLqcMpGwR6QcTP6QRMuD"
+      - "--no-telemetry"
+      - "--rpc-cors"
+      - "all"
+      # Not only bind to localhost.
+      - "--unsafe-ws-external"
+      - "--unsafe-rpc-external"
+      - "--log"
+      - "sub-libp2p=trace"
+      - "--prometheus-external"
+
+  prometheus:
+    image: prom/prometheus
+    networks:
+      - internet
+    ports:
+      - "9090:9090"
+    links:
+      - validator-a:validator-a
+      - validator-b:validator-b
+      - light-c:light-c
+    volumes:
+      - ./prometheus/:/etc/prometheus/
+    restart: always
+
+  grafana:
+    image: grafana/grafana
+    user: "104"
+    depends_on:
+      - prometheus
+    networks:
+      - internet
+    ports:
+      - 3001:3000
+    volumes:
+      - ./grafana/provisioning/:/etc/grafana/provisioning
+      - ../monitoring/grafana-dashboards/:/etc/grafana/provisioning/dashboard-definitions
+    restart: always
+
+networks:
+  network-a:
+  internet:
diff --git a/substrate/.maintain/local-docker-test-network/grafana/provisioning/dashboards/dashboards.yml b/substrate/.maintain/local-docker-test-network/grafana/provisioning/dashboards/dashboards.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ad9164fd8ea01023a2b5736fdea9bfc0259f1eed
--- /dev/null
+++ b/substrate/.maintain/local-docker-test-network/grafana/provisioning/dashboards/dashboards.yml
@@ -0,0 +1,11 @@
+apiVersion: 1
+
+providers:
+- name: 'Prometheus'
+  orgId: 1
+  folder: ''
+  type: file
+  disableDeletion: false
+  editable: false
+  options:
+    path: /etc/grafana/provisioning/dashboard-definitions
diff --git a/substrate/.maintain/local-docker-test-network/grafana/provisioning/datasources/datasource.yml b/substrate/.maintain/local-docker-test-network/grafana/provisioning/datasources/datasource.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c02bb38b3d378112480b0772855e79b0f02cb02f
--- /dev/null
+++ b/substrate/.maintain/local-docker-test-network/grafana/provisioning/datasources/datasource.yml
@@ -0,0 +1,50 @@
+# config file version
+apiVersion: 1
+
+# list of datasources that should be deleted from the database
+deleteDatasources:
+  - name: Prometheus
+    orgId: 1
+
+# list of datasources to insert/update depending
+# whats available in the database
+datasources:
+  # <string, required> name of the datasource. Required
+- name: Prometheus
+  # <string, required> datasource type. Required
+  type: prometheus
+  # <string, required> access mode. direct or proxy. Required
+  access: proxy
+  # <int> org id. will default to orgId 1 if not specified
+  orgId: 1
+  # <string> url
+  url: http://prometheus:9090
+  # <string> database password, if used
+  password:
+  # <string> database user, if used
+  user:
+  # <string> database name, if used
+  database:
+  # <bool> enable/disable basic auth
+  basicAuth: false
+  # <string> basic auth username, if used
+  basicAuthUser:
+  # <string> basic auth password, if used
+  basicAuthPassword:
+  # <bool> enable/disable with credentials headers
+  withCredentials:
+  # <bool> mark as default datasource. Max one per org
+  isDefault: true
+  # <map> fields that will be converted to json and stored in json_data
+  jsonData:
+     graphiteVersion: "1.1"
+     tlsAuth: false
+     tlsAuthWithCACert: false
+  # <string> json object of data that will be encrypted.
+  secureJsonData:
+    tlsCACert: "..."
+    tlsClientCert: "..."
+    tlsClientKey: "..."
+  version: 1
+  # <bool> allow users to edit datasources from the UI.
+  editable: true
diff --git a/substrate/.maintain/local-docker-test-network/prometheus/prometheus.yml b/substrate/.maintain/local-docker-test-network/prometheus/prometheus.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f8acb7c0b8ccd228ee437601366e8301e3c2c3ea
--- /dev/null
+++ b/substrate/.maintain/local-docker-test-network/prometheus/prometheus.yml
@@ -0,0 +1,15 @@
+global:
+  scrape_interval: 15s
+
+scrape_configs:
+  - job_name: 'substrate-nodes'
+    static_configs:
+      - targets: ['validator-a:9615']
+        labels:
+          network: dev
+      - targets: ['validator-b:9615']
+        labels:
+          network: dev
+      - targets: ['light-c:9615']
+        labels:
+          network: dev
diff --git a/substrate/.maintain/rename-crates-for-2.0.sh b/substrate/.maintain/rename-crates-for-2.0.sh
new file mode 100755
index 0000000000000000000000000000000000000000..01d559448438b3cb857d1b46af2f8bc544232066
--- /dev/null
+++ b/substrate/.maintain/rename-crates-for-2.0.sh
@@ -0,0 +1,126 @@
+#!/bin/bash
+
+function rust_rename() {
+    sed -i "s/$1/$2/g" `grep -Rl --include="*.rs" --include="*.stderr" "$1" *` > /dev/null
+}
+
+function cargo_rename() {
+    find . -name "Cargo.toml" -exec sed -i "s/\(^\|[^\/]\)$1/\1$2/g" {} \;
+}
+
+function rename_gitlabci() {
+    sed -i "s/$1/$2/g" .gitlab-ci.yml
+}
+
+function rename() {
+    old=$(echo $1 | cut -f1 -d\ );
+    new=$(echo $1 | cut -f2 -d\ );
+
+    echo "Renaming $old to $new"
+    # rename in Cargo.tomls
+    cargo_rename $old $new
+    rename_gitlabci $old $new
+    # and it appears, we have the same syntax in rust files
+    rust_rename $old $new
+
+    # but generally we have the snail case syntax in rust files
+    old=$(echo $old | sed s/-/_/g );
+    new=$(echo $new | sed s/-/_/g );
+
+    echo " > $old to $new"
+    rust_rename $old $new
+}
+
+TO_RENAME=(
+    # OLD-CRATE-NAME NEW-CRATE-NAME
+
+    # post initial rename fixes
+    "sc-application-crypto sp-application-crypto"
+    "sp-transaction-pool-api sp-transaction-pool"
+    "sp-transaction-pool-runtime-api sp-transaction-pool"
+    "sp-core-storage sp-storage"
+    "transaction-factory node-transaction-factory"
+    "sp-finality-granpda sp-finality-grandpa"
+    "sp-sesssion sp-session"
+    "sp-tracing-pool sp-transaction-pool"
+    "sc-basic-authority sc-basic-authorship"
+    "sc-api sc-client-api"
+    "sc-database sc-client-db"
+
+    # PRIMITIVES
+    "substrate-application-crypto sp-application-crypto"
+    "substrate-authority-discovery-primitives sp-authority-discovery"
+    "substrate-block-builder-runtime-api sp-block-builder"
+    "substrate-consensus-aura-primitives sp-consensus-aura"
+    "substrate-consensus-babe-primitives sp-consensus-babe"
+    "substrate-consensus-common sp-consensus"
+    "substrate-consensus-pow-primitives sp-consensus-pow"
+    "substrate-primitives sp-core"
+    "substrate-debug-derive sp-debug-derive"
+    "substrate-primitives-storage sp-storage"
+    "substrate-externalities sp-externalities"
+    "substrate-finality-grandpa-primitives sp-finality-grandpa"
+    "substrate-inherents sp-inherents"
+    "substrate-keyring sp-keyring"
+    "substrate-offchain-primitives sp-offchain"
+    "substrate-panic-handler sp-panic-handler"
+    "substrate-phragmen sp-npos-elections"
+    "substrate-rpc-primitives sp-rpc"
+    "substrate-runtime-interface sp-runtime-interface"
+    "substrate-runtime-interface-proc-macro sp-runtime-interface-proc-macro"
+    "substrate-runtime-interface-test-wasm sp-runtime-interface-test-wasm"
+    "substrate-serializer sp-serializer"
+    "substrate-session sp-session"
+    "sr-api sp-api"
+    "sr-api-proc-macro sp-api-proc-macro"
+    "sr-api-test sp-api-test"
+    "sr-arithmetic sp-arithmetic"
+    "sr-arithmetic-fuzzer sp-arithmetic-fuzzer"
+    "sr-io sp-io"
+    "sr-primitives sp-runtime"
+    "sr-sandbox sp-sandbox"
+    "sr-staking-primitives sp-staking"
+    "sr-std sp-std"
+    "sr-version sp-version"
+    "substrate-state-machine sp-state-machine"
+    "substrate-transaction-pool-runtime-api sp-transaction-pool"
+    "substrate-trie sp-trie"
+    "substrate-wasm-interface sp-wasm-interface"
+
+    # # CLIENT
+    "substrate-client sc-client"
+    "substrate-client-api sc-client-api"
+    "substrate-authority-discovery sc-authority-discovery"
+    "substrate-basic-authorship sc-basic-authorship"
+    "substrate-block-builder sc-block-builder"
+    "substrate-chain-spec sc-chain-spec"
+    "substrate-chain-spec-derive sc-chain-spec-derive"
+    "substrate-cli sc-cli"
+    "substrate-consensus-aura sc-consensus-aura"
+    "substrate-consensus-babe sc-consensus-babe"
+    "substrate-consensus-pow sc-consensus-pow"
+    "substrate-consensus-slots sc-consensus-slots"
+    "substrate-consensus-uncles sc-consensus-uncles"
+    "substrate-client-db sc-client-db"
+    "substrate-executor sc-executor"
+    "substrate-runtime-test sc-runtime-test"
+    "substrate-finality-grandpa sc-finality-grandpa"
+    "substrate-keystore sc-keystore"
+    "substrate-network sc-network"
+    "substrate-offchain sc-offchain"
+    "substrate-peerset sc-peerset"
+    "substrate-rpc-servers sc-rpc-server"
+    "substrate-rpc sc-rpc"
+    "substrate-service sc-service"
+    "substrate-service-test sc-service-test"
+    "substrate-state-db sc-state-db"
+    "substrate-telemetry sc-telemetry"
+    "substrate-test-primitives sp-test-primitives"
+    "substrate-tracing sc-tracing"
+
+);
+
+for rule in "${TO_RENAME[@]}"
+do
+	rename "$rule";
+done
diff --git a/substrate/.maintain/runtime-dep.py b/substrate/.maintain/runtime-dep.py
new file mode 100755
index 0000000000000000000000000000000000000000..3198bb3e2669e9bcc41e0c26e534028747d377e9
--- /dev/null
+++ b/substrate/.maintain/runtime-dep.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+# To run this script, you need to install the 'toml' python package and install the 'graphviz' package:
+# pip install toml
+# sudo apt-get install graphviz
+# the first parameter is the runtime folder
+# python ./.maintain/runtime-dep.py ./substrate/runtime | dot -Tpng -o output.png
+import sys
+import os
+import toml
+
+if len(sys.argv) != 2:
+    print("needs the runtime folder.")
+    sys.exit(-1)
+
+runtime_dir = sys.argv[1]
+
+files = [os.path.join(runtime_dir, f, 'Cargo.toml') for f in os.listdir(runtime_dir) if os.path.isfile(os.path.join(runtime_dir, f, 'Cargo.toml')) and f != 'example']
+
+print("digraph G {")
+
+
+PREFIX = "substrate-runtime-"
+
+for f in files:
+    manifest = toml.load(f)
+
+    package_name = manifest['package']['name']
+    deps = [d for d in manifest['dependencies'].keys() if d.startswith(PREFIX)]
+
+    for d in deps:
+        print("    \"{}\" -> \"{}\";".format(package_name, d))
+
+print("}")
diff --git a/substrate/.maintain/rustdocs-release.sh b/substrate/.maintain/rustdocs-release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..2a1e141e63ad21c35e4b904764f64141ce838da1
--- /dev/null
+++ b/substrate/.maintain/rustdocs-release.sh
@@ -0,0 +1,244 @@
+#!/usr/bin/env bash
+# set -x
+
+# This script manages the deployment of Substrate rustdocs to https://paritytech.github.io/substrate/.
+# - With `deploy` sub-command, it will checkout the passed-in branch/tag ref, build the rustdocs
+#   locally (this takes some time), update the `index.html` index page, and push it to remote
+#   `gh-pages` branch. So users running this command need to have write access to the remote
+#   `gh-pages` branch. This sub-command depends on [@substrate/index-tpl-crud](https://www.npmjs.com/package/@substrate/index-tpl-crud)
+#   to update the DOM of index.html page.
+# - With `remove` sub-command, it will remove the deployed rustdocs from `gh-pages`, and update the
+#   index.html page as necessary. It may remove the `latest` symbolic link.
+#
+# Examples:
+#   # Showing help text
+#   rustdocs-release.sh -h
+#
+#   # Deploy rustdocs of `monthly-2021-10` tag
+#   rustdocs-release.sh deploy monthly-2021-10
+#
+#   # In addition to the above, the `latest` symlink will point to this version of rustdocs
+#   rustdocs-release.sh deploy -l monthly-2021-10
+#
+#   # Remove the rustdocs of `monthly-2021-10` from `gh-pages`.
+#   rustdocs-release.sh remove monthly-2021-10
+#
+# Dependencies:
+#   - @substrate/index-tpl-crud - https://www.npmjs.com/package/@substrate/index-tpl-crud
+#
+
+# Script setting
+# The git repo http URL
+REMOTE_REPO="https://github.com/paritytech/substrate.git"
+TMP_PREFIX="/tmp"                             # tmp location that the built doc is copied to.
+DOC_INDEX_PAGE="sc_service/index.html"
+
+# Set to `true` if using cargo `nightly` toolchain to build the doc.
+# Set to `false` to use the default cargo toolchain. This is preferred if you want to build
+# the rustdocs with a pinned nightly version set to your default toolchain.
+CARGO_NIGHTLY=false
+
+# Set the git remote name. Most of the time the default is `origin`.
+GIT_REMOTE="origin"
+LATEST=false
+
+# Setting the help text
+declare -A HELP_TXT
+HELP_TXT["deploy"]=$(cat <<-EOH
+Build and deploy the rustdocs of the specified branch/tag to \`gh-pages\` branch.
+
+  usage:      $0 deploy [-l] <git_branch_ref>
+  example:    $0 deploy -l monthly-2021-10
+
+  options:
+    -l        The \`latest\` path will be sym'linked to this rustdocs version
+EOH
+)
+
+HELP_TXT["remove"]=$(cat <<-EOH
+Remove the rustdocs of the specified version from \`gh-pages\` branch.
+
+  usage:      $0 remove <git_branch_ref>
+  example:    $0 remove monthly-2021-10
+EOH
+)
+
+set_and_check_rustdoc_ref() {
+  [[ -z "$1" ]] && {
+    echo -e "git branch_ref is not specified.\n"
+    echo "${HELP_TXT[$2]}"
+    exit 1
+  }
+  BUILD_RUSTDOC_REF=$1
+}
+
+check_local_change() {
+  # Check there is no local changes before proceeding
+  [[ -n $(git status --porcelain) ]] \
+    && echo "Local changes exist, please either discard or commit them as this command will change the current checkout branch." \
+    && exit 1
+}
+
+build_rustdocs() {
+  # Build the docs
+  time cargo $($CARGO_NIGHTLY && echo "+nightly") doc --workspace --all-features --verbose \
+    || { echo "Generate $1 rustdocs failed" && exit 1; }
+  rm -f target/doc/.lock
+
+  # Moving the built doc to the tmp location
+  mv target/doc "${2}"
+  [[ -n "${DOC_INDEX_PAGE}" ]] \
+    && echo "<meta http-equiv=refresh content=0;url=${DOC_INDEX_PAGE}>" > "${2}/index.html"
+}
+
+upsert_index_page() {
+  # Check if `index-tpl-crud` exists
+  which index-tpl-crud &> /dev/null || yarn global add @substrate/index-tpl-crud
+  index-tpl-crud upsert $($1 && echo "-l") ./index.html "$2"
+}
+
+rm_index_page() {
+  which index-tpl-crud &> /dev/null || yarn global add @substrate/index-tpl-crud
+  index-tpl-crud rm ./index.html "$1"
+}
+
+git_add_commit_push() {
+  git add --all
+  git commit -m "$1" || echo "Nothing to commit"
+  git push "${GIT_REMOTE}" gh-pages --force
+}
+
+import_gh_key() {
+  [[ -n $GITHUB_SSH_PRIV_KEY ]] && {
+    eval $(ssh-agent)
+    ssh-add - <<< $GITHUB_SSH_PRIV_KEY
+  }
+
+  # Adding github.com as known_hosts
+  ssh-keygen -F github.com &>/dev/null || {
+    [[ -e ~/.ssh ]] || mkdir ~/.ssh
+    [[ -e ~/.ssh/known_hosts ]] || touch ~/.ssh/known_hosts
+    ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
+  }
+}
+
+deploy_main() {
+  check_local_change
+  import_gh_key
+
+  CURRENT_GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+  TMP_PROJECT_PATH="${TMP_PREFIX}/${PROJECT_NAME}"
+  DOC_PATH="${TMP_PROJECT_PATH}/${BUILD_RUSTDOC_REF}"
+
+  # Build the tmp project path
+  rm -rf "${TMP_PROJECT_PATH}" && mkdir "${TMP_PROJECT_PATH}"
+
+  # Copy .gitignore file to tmp
+  [[ -e "${PROJECT_PATH}/.gitignore" ]] && cp "${PROJECT_PATH}/.gitignore" "${TMP_PROJECT_PATH}"
+
+  git fetch --all
+  git checkout -f ${BUILD_RUSTDOC_REF} || { echo "Checkout \`${BUILD_RUSTDOC_REF}\` error." && exit 1; }
+  build_rustdocs "${BUILD_RUSTDOC_REF}" "${DOC_PATH}"
+
+  # git checkout `gh-pages` branch
+  git fetch "${GIT_REMOTE}" gh-pages
+  git checkout gh-pages
+  # Move the built back
+  [[ -e "${TMP_PROJECT_PATH}/.gitignore" ]] && cp -f "${TMP_PROJECT_PATH}/.gitignore" .
+  # Ensure the destination dir doesn't exist under current path.
+  rm -rf "${BUILD_RUSTDOC_REF}"
+  mv -f "${DOC_PATH}" "${BUILD_RUSTDOC_REF}"
+
+  upsert_index_page $LATEST "${BUILD_RUSTDOC_REF}"
+  # Add the latest symlink
+  $LATEST && rm -rf latest && ln -sf "${BUILD_RUSTDOC_REF}" latest
+
+  git_add_commit_push "___Deployed rustdocs of ${BUILD_RUSTDOC_REF}___"
+  # Clean up
+  # Remove the tmp asset created
+  rm -rf "${TMP_PROJECT_PATH}"
+  # Resume back previous checkout branch.
+  git checkout -f "$CURRENT_GIT_BRANCH"
+}
+
+remove_main() {
+  check_local_change
+  import_gh_key
+
+  CURRENT_GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
+
+  # git checkout `gh-pages` branch
+  git fetch "${GIT_REMOTE}" gh-pages
+  git checkout gh-pages
+
+  rm -rf "${BUILD_RUSTDOC_REF}"
+  rm_index_page "${BUILD_RUSTDOC_REF}"
+  # check if the destination of `latest` exists and rmove if not.
+  [[ -e "latest" ]] || rm latest
+
+  git_add_commit_push "___Removed rustdocs of ${BUILD_RUSTDOC_REF}___"
+
+  # Resume back previous checkout branch.
+  git checkout -f "$CURRENT_GIT_BRANCH"
+}
+
+# ---- The script execution entry point starts here ----
+
+# Arguments handling
+SUBCMD=$1
+[[ $SUBCMD == "deploy" || $SUBCMD == "remove" ]] \
+  || { echo "Please specify a subcommand of \`deploy\` or \`remove\`" && exit 1 ;}
+shift
+
+# After removing the subcommand, there could only be 1 or 2 parameters afterward
+[[ $# -lt 1 || $# -gt 2 ]] && {
+  echo "${HELP_TXT[${SUBCMD}]}"
+  exit 1
+}
+
+# Parsing options and argument for `deploy` subcommand
+[[ $SUBCMD == "deploy" ]] && {
+  while getopts :lh opt; do
+    case $opt in
+      l)
+        LATEST=true
+        ;;
+      h)
+        echo "${HELP_TXT[$SUBCMD]}"
+        exit 0
+        ;;
+      \?)
+        echo "Invalid option: -$OPTARG" >&2
+        exit 1
+        ;;
+    esac
+  done
+}
+# Parsing options and argument for `remove` subcommand
+[[ $SUBCMD == "remove" ]] && {
+  while getopts :h opt; do
+    case $opt in
+      h)
+        echo "${HELP_TXT[$SUBCMD]}"
+        exit 0
+        ;;
+      \?)
+        echo "Invalid option: -$OPTARG" >&2
+        exit 1
+        ;;
+    esac
+  done
+}
+
+shift $(($OPTIND - 1))
+set_and_check_rustdoc_ref ${1:-''} $SUBCMD
+
+SCRIPT=$(realpath $0)
+SCRIPT_PATH=$(dirname $SCRIPT)
+PROJECT_PATH=$(dirname ${SCRIPT_PATH})
+PROJECT_NAME=$(basename "$PROJECT_PATH")
+
+pushd "${PROJECT_PATH}" &>/dev/null
+[[ $SUBCMD == "deploy" ]] && deploy_main
+[[ $SUBCMD == "remove" ]] && remove_main
+popd &>/dev/null
diff --git a/substrate/.maintain/update-deps.sh b/substrate/.maintain/update-deps.sh
new file mode 100755
index 0000000000000000000000000000000000000000..cd6b7c853825ed42a0b55d32018b81207a3d1642
--- /dev/null
+++ b/substrate/.maintain/update-deps.sh
@@ -0,0 +1,9 @@
+#!/bin/sh --
+set -eu
+case $0 in
+   (/*) dir=${0%/*}/;;
+   (*/*) dir=./${0%/*};;
+   (*) dir=.;;
+esac
+
+find "$dir/.." -name Cargo.lock -execdir cargo update \;
diff --git a/substrate/.maintain/update-rust-stable.sh b/substrate/.maintain/update-rust-stable.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b253bb4105313c6663948e55ee826dff3059d22d
--- /dev/null
+++ b/substrate/.maintain/update-rust-stable.sh
@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+#
+# Script for updating the UI tests for a new rust stable version.
+#
+# It needs to be called like this:
+#
+# update-rust-stable.sh 1.61
+#
+# This will run all UI tests with the rust stable 1.61. The script
+# requires that rustup is installed.
+set -e
+
+if [ "$#" -ne 1 ]; then
+	echo "Please specify the rust version to use. E.g. update-rust-stable.sh 1.61"
+	exit
+fi
+
+RUST_VERSION=$1
+
+if ! command -v rustup &> /dev/null
+then
+	echo "rustup needs to be installed"
+	exit
+fi
+
+rustup install $RUST_VERSION
+rustup component add rust-src --toolchain $RUST_VERSION
+
+# Ensure we run the ui tests
+export RUN_UI_TESTS=1
+# We don't need any wasm files for ui tests
+export SKIP_WASM_BUILD=1
+# Let trybuild overwrite the .stderr files
+export TRYBUILD=overwrite
+
+# Run all the relevant UI tests
+#
+# Any new UI tests in different crates need to be added here as well.
+rustup run $RUST_VERSION cargo test -p sp-runtime-interface ui
+rustup run $RUST_VERSION cargo test -p sp-api-test ui
+rustup run $RUST_VERSION cargo test -p frame-election-provider-solution-type ui
+rustup run $RUST_VERSION cargo test -p frame-support-test ui
diff --git a/substrate/Cargo.lock b/substrate/Cargo.lock
new file mode 100644
index 0000000000000000000000000000000000000000..3d51a0fb1ffa42c9cc2e08eac4341e03c84dd60f
--- /dev/null
+++ b/substrate/Cargo.lock
@@ -0,0 +1,14549 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "Inflector"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
+dependencies = [
+ "lazy_static",
+ "regex",
+]
+
+[[package]]
+name = "addr2line"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a76fd60b23679b7d19bd066031410fb7e458ccc5e958eb5c325888ce4baedc97"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "aead"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fc95d1bdb8e6666b2b217308eeeb09f2d6728d104be3e31916cc74d15420331"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "aead"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b613b8e1e3cf911a086f53f03bf286f52fd7a7258e4fa606f0ef220d39d8877"
+dependencies = [
+ "generic-array 0.14.7",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "aes"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884391ef1066acaa41e766ba8f596341b96e93ce34f9a43e7d24bf0a0eaf0561"
+dependencies = [
+ "aes-soft",
+ "aesni",
+ "cipher 0.2.5",
+]
+
+[[package]]
+name = "aes"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
+dependencies = [
+ "cfg-if",
+ "cipher 0.3.0",
+ "cpufeatures",
+ "opaque-debug 0.3.0",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "433cfd6710c9986c576a25ca913c39d66a6474107b406f34f91d4a8923395241"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df5f85a83a7d8b0442b6aa7b504b8212c1733da07b98aae43d4bc21b2cb3cdf6"
+dependencies = [
+ "aead 0.4.3",
+ "aes 0.7.5",
+ "cipher 0.3.0",
+ "ctr 0.8.0",
+ "ghash 0.4.4",
+ "subtle",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "209b47e8954a928e1d72e86eca7000ebb6655fe1436d33eefc2201cad027e237"
+dependencies = [
+ "aead 0.5.2",
+ "aes 0.8.2",
+ "cipher 0.4.4",
+ "ctr 0.9.2",
+ "ghash 0.5.0",
+ "subtle",
+]
+
+[[package]]
+name = "aes-soft"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be14c7498ea50828a38d0e24a765ed2effe92a705885b57d029cd67d45744072"
+dependencies = [
+ "cipher 0.2.5",
+ "opaque-debug 0.3.0",
+]
+
+[[package]]
+name = "aesni"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea2e11f5e94c2f7d386164cc2aa1f97823fed6f259e486940a71c174dd01b0ce"
+dependencies = [
+ "cipher 0.2.5",
+ "opaque-debug 0.3.0",
+]
+
+[[package]]
+name = "ahash"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+dependencies = [
+ "getrandom 0.2.9",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+dependencies = [
+ "cfg-if",
+ "getrandom 0.2.9",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "0.7.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "ansi_term"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "anstream"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ca84f3628370c59db74ee214b3263d58f9aadd9b4fe7e711fd87dc452b7f163"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is-terminal",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41ed9a86bf92ae6580e0a31281f65a1b1d867c0cc68d5346e2ae128dddfa6a7d"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e765fd216e48e067936442276d1d57399e37bce53c264d6fefbe298080cb57ee"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180abfa45703aebe0093f79badacc01b8fd4ea2e35118747e5811127f926e188"
+dependencies = [
+ "anstyle",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "approx"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "aquamarine"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df752953c49ce90719c7bf1fc587bc8227aed04732ea0c0f85e5397d7fdbd1a1"
+dependencies = [
+ "include_dir",
+ "itertools",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "arbitrary"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2d098ff73c1ca148721f37baad5ea6a465a13f9573aba8641fbbbae8164a54e"
+
+[[package]]
+name = "arc-swap"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6"
+
+[[package]]
+name = "ark-algebra-test-templates"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "400bd3a79c741b1832f1416d4373ae077ef82ca14a8b4cee1248a2f11c8b9172"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+ "hex",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "sha2 0.10.7",
+]
+
+[[package]]
+name = "ark-bls12-377"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb00293ba84f51ce3bd026bd0de55899c4e68f0a39a5728cebae3a73ffdc0a4f"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-std",
+]
+
+[[package]]
+name = "ark-bls12-381"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c775f0d12169cba7aae4caeb547bb6a50781c7449a8aa53793827c9ec4abf488"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+]
+
+[[package]]
+name = "ark-bw6-761"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e0605daf0cc5aa2034b78d008aaf159f56901d92a52ee4f6ecdfdac4f426700"
+dependencies = [
+ "ark-bls12-377",
+ "ark-ec",
+ "ark-ff",
+ "ark-std",
+]
+
+[[package]]
+name = "ark-ec"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defd9a439d56ac24968cca0571f598a61bc8c55f71d50a89cda591cb750670ba"
+dependencies = [
+ "ark-ff",
+ "ark-poly",
+ "ark-serialize",
+ "ark-std",
+ "derivative",
+ "hashbrown 0.13.2",
+ "itertools",
+ "num-traits",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ed-on-bls12-377"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b10d901b9ac4b38f9c32beacedfadcdd64e46f8d7f8e88c1ae1060022cf6f6c6"
+dependencies = [
+ "ark-bls12-377",
+ "ark-ec",
+ "ark-ff",
+ "ark-std",
+]
+
+[[package]]
+name = "ark-ed-on-bls12-381-bandersnatch"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9cde0f2aa063a2a5c28d39b47761aa102bda7c13c84fc118a61b87c7b2f785c"
+dependencies = [
+ "ark-bls12-381",
+ "ark-ec",
+ "ark-ff",
+ "ark-std",
+]
+
+[[package]]
+name = "ark-ff"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
+dependencies = [
+ "ark-ff-asm",
+ "ark-ff-macros",
+ "ark-serialize",
+ "ark-std",
+ "derivative",
+ "digest 0.10.7",
+ "itertools",
+ "num-bigint",
+ "num-traits",
+ "paste",
+ "rustc_version 0.4.0",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-ff-asm"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-ff-macros"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-poly"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d320bfc44ee185d899ccbadfa8bc31aab923ce1558716e1997a1e74057fe86bf"
+dependencies = [
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+ "derivative",
+ "hashbrown 0.13.2",
+]
+
+[[package]]
+name = "ark-r1cs-std"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de1d1472e5cb020cb3405ce2567c91c8d43f21b674aef37b0202f5c3304761db"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-relations",
+ "ark-std",
+ "derivative",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "tracing",
+]
+
+[[package]]
+name = "ark-relations"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00796b6efc05a3f48225e59cb6a2cda78881e7c390872d5786aaf112f31fb4f0"
+dependencies = [
+ "ark-ff",
+ "ark-std",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "ark-scale"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d028cd1025d002fa88c10cd644d29028a7b40806579b608c6ba843b937bbb23"
+dependencies = [
+ "ark-ec",
+ "ark-serialize",
+ "ark-std",
+ "parity-scale-codec",
+]
+
+[[package]]
+name = "ark-secret-scalar"
+version = "0.0.2"
+source = "git+https://github.com/w3f/ring-vrf?rev=c86ebd4#c86ebd4114d3165d05f9ce28c1d9e8d7a9a4e801"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+ "ark-transcript",
+ "digest 0.10.7",
+ "rand_core 0.6.4",
+ "zeroize",
+]
+
+[[package]]
+name = "ark-serialize"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
+dependencies = [
+ "ark-serialize-derive",
+ "ark-std",
+ "digest 0.10.7",
+ "num-bigint",
+]
+
+[[package]]
+name = "ark-serialize-derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae3281bc6d0fd7e549af32b52511e1302185bd688fd3359fa36423346ff682ea"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ark-std"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
+dependencies = [
+ "num-traits",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "ark-transcript"
+version = "0.0.2"
+source = "git+https://github.com/w3f/ring-vrf?rev=c86ebd4#c86ebd4114d3165d05f9ce28c1d9e8d7a9a4e801"
+dependencies = [
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+ "digest 0.10.7",
+ "rand_core 0.6.4",
+ "sha3",
+]
+
+[[package]]
+name = "array-bytes"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b1c5a481ec30a5abd8dfbd94ab5cf1bb4e9a66be7f1b3b322f2f1170c200fd"
+
+[[package]]
+name = "arrayref"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+
+[[package]]
+name = "arrayvec"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+
+[[package]]
+name = "asn1-rs"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30ff05a702273012438132f449575dbc804e27b2f3cbe3069aa237d26c98fa33"
+dependencies = [
+ "asn1-rs-derive 0.1.0",
+ "asn1-rs-impl",
+ "displaydoc",
+ "nom",
+ "num-traits",
+ "rusticata-macros",
+ "thiserror",
+ "time 0.3.21",
+]
+
+[[package]]
+name = "asn1-rs"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f6fd5ddaf0351dff5b8da21b2fb4ff8e08ddd02857f0bf69c47639106c0fff0"
+dependencies = [
+ "asn1-rs-derive 0.4.0",
+ "asn1-rs-impl",
+ "displaydoc",
+ "nom",
+ "num-traits",
+ "rusticata-macros",
+ "thiserror",
+ "time 0.3.21",
+]
+
+[[package]]
+name = "asn1-rs-derive"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db8b7511298d5b7784b40b092d9e9dcd3a627a5707e4b5e507931ab0d44eeebf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "synstructure",
+]
+
+[[package]]
+name = "asn1-rs-derive"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "726535892e8eae7e70657b4c8ea93d26b8553afb1ce617caee529ef96d7dee6c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "synstructure",
+]
+
+[[package]]
+name = "asn1-rs-impl"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2777730b2039ac0f95f093556e61b6d26cebed5393ca6f152717777cec3a42ed"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "assert_cmd"
+version = "2.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86d6b683edf8d1119fe420a94f8a7e389239666aa72e65495d91c00462510151"
+dependencies = [
+ "anstyle",
+ "bstr",
+ "doc-comment",
+ "predicates 3.0.3",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "assert_matches"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
+
+[[package]]
+name = "async-channel"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf46fee83e5ccffc220104713af3292ff9bc7c64c7de289f66dae8e38d826833"
+dependencies = [
+ "concurrent-queue",
+ "event-listener",
+ "futures-core",
+]
+
+[[package]]
+name = "async-io"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fc5b45d93ef0529756f812ca52e44c221b35341892d3dcc34132ac02f3dd2af"
+dependencies = [
+ "async-lock",
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-lite",
+ "log",
+ "parking",
+ "polling",
+ "rustix 0.37.19",
+ "slab",
+ "socket2",
+ "waker-fn",
+]
+
+[[package]]
+name = "async-lock"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa24f727524730b077666307f2734b4a1a1c57acb79193127dcc8914d5242dd7"
+dependencies = [
+ "event-listener",
+]
+
+[[package]]
+name = "async-recursion"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e97ce7de6cf12de5d7226c73f5ba9811622f4db3a5b91b55c53e987e5f91cba"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd56dd203fef61ac097dd65721a419ddccb106b2d2b70ba60a6b529f03961a51"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite 0.2.9",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "asynchronous-codec"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06a0daa378f5fd10634e44b0a29b2a87b890657658e072a30d6f26e57ddee182"
+dependencies = [
+ "bytes",
+ "futures-sink",
+ "futures-util",
+ "memchr",
+ "pin-project-lite 0.2.9",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1181e1e0d1fce796a03db1ae795d67167da795f9cf4a39c37589e85ef57f26d3"
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi 0.1.19",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "backtrace"
+version = "0.3.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233d376d6d185f2a3093e58f283f60f880315b6c60075b01f36b3b85154564ca"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide 0.6.2",
+ "object",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "bandersnatch_vrfs"
+version = "0.0.1"
+source = "git+https://github.com/w3f/ring-vrf?rev=c86ebd4#c86ebd4114d3165d05f9ce28c1d9e8d7a9a4e801"
+dependencies = [
+ "ark-bls12-381",
+ "ark-ec",
+ "ark-ed-on-bls12-381-bandersnatch",
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+ "dleq_vrf",
+ "fflonk",
+ "merlin 3.0.0",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+ "ring 0.1.0",
+ "sha2 0.10.7",
+ "zeroize",
+]
+
+[[package]]
+name = "base-x"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270"
+
+[[package]]
+name = "base16ct"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "349a06037c7bf932dd7e7d1f653678b2038b9ad46a74102f1fc7bd7872678cce"
+
+[[package]]
+name = "base16ct"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "base64"
+version = "0.21.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "604178f6c5c21f02dc555784810edfb88d34ac2c73b2eae109655649ee73ce3d"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "basic-toml"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c0de75129aa8d0cceaf750b89013f0e08804d6ec61416da787b35ad0d7cddf1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "beef"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "binary-merkle-tree"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "env_logger 0.9.3",
+ "hash-db",
+ "log",
+ "sp-core",
+ "sp-runtime",
+]
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.65.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfdf7b466f9a4903edc73f95d6d2bcd5baf8ae620638762244d3f60143643cc5"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "lazy_static",
+ "lazycell",
+ "peeking_take_while",
+ "prettyplease 0.2.6",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "blake2b_simd"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c2f0dc9a68c6317d884f97cc36cf5a3d20ba14ce404227df55e1af708ab04bc"
+dependencies = [
+ "arrayref",
+ "arrayvec 0.7.2",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "blake2s_simd"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6637f448b9e61dfadbdcbae9a885fadee1f3eaffb1f8d3c1965d3ade8bdfd44f"
+dependencies = [
+ "arrayref",
+ "arrayvec 0.7.2",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "blake3"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
+dependencies = [
+ "arrayref",
+ "arrayvec 0.7.2",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
+dependencies = [
+ "block-padding 0.1.5",
+ "byte-tools",
+ "byteorder",
+ "generic-array 0.12.4",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "block-modes"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57a0e8073e8baa88212fb5823574c02ebccb395136ba9a164ab89379ec6072f0"
+dependencies = [
+ "block-padding 0.2.1",
+ "cipher 0.2.5",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
+dependencies = [
+ "byte-tools",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"
+
+[[package]]
+name = "bounded-collections"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb5b05133427c07c4776906f673ccf36c21b102c9829c641a5b56bd151d44fd6"
+dependencies = [
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+]
+
+[[package]]
+name = "bs58"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
+
+[[package]]
+name = "bstr"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a246e68bb43f6cd9db24bea052a53e40405417c5fb372e3d1a8a7f770a564ef5"
+dependencies = [
+ "memchr",
+ "once_cell",
+ "regex-automata",
+ "serde",
+]
+
+[[package]]
+name = "build-helper"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdce191bf3fa4995ce948c8c83b4640a1745457a149e73c6db75b4ffe36aad5f"
+dependencies = [
+ "semver 0.6.0",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
+
+[[package]]
+name = "byte-slice-cast"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
+
+[[package]]
+name = "byte-tools"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
+
+[[package]]
+name = "bytemuck"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17febce684fd15d89027105661fec94afb475cb995fbc59d2865198446ba2eea"
+
+[[package]]
+name = "byteorder"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+
+[[package]]
+name = "bytes"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.11+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "camino"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c530edf18f37068ac2d977409ed5cd50d53d73bc653c7647b48eb78976ac9ae2"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbdb825da8a5df079a43676dbe042702f1707b1109f713a01420fbb4cc71fa27"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver 1.0.17",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cc"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+dependencies = [
+ "jobserver",
+]
+
+[[package]]
+name = "ccm"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aca1a8fbc20b50ac9673ff014abfb2b5f4085ee1a850d408f14a159c5853ac7"
+dependencies = [
+ "aead 0.3.2",
+ "cipher 0.2.5",
+ "subtle",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b40ccee03b5175c18cde8f37e7d2a33bcef6f8ec8f7cc0d81090d1bb380949c9"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
+[[package]]
+name = "chacha20"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c80e5460aa66fe3b91d40bcbdab953a597b60053e34d684ac6903f863b680a6"
+dependencies = [
+ "cfg-if",
+ "cipher 0.3.0",
+ "cpufeatures",
+ "zeroize",
+]
+
+[[package]]
+name = "chacha20poly1305"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a18446b09be63d457bbec447509e85f662f32952b035ce892290396bc0b0cff5"
+dependencies = [
+ "aead 0.4.3",
+ "chacha20",
+ "cipher 0.3.0",
+ "poly1305",
+ "zeroize",
+]
+
+[[package]]
+name = "chain-spec-builder"
+version = "2.0.0"
+dependencies = [
+ "ansi_term",
+ "clap 4.3.2",
+ "node-cli",
+ "rand 0.8.5",
+ "sc-chain-spec",
+ "sc-keystore",
+ "sp-core",
+ "sp-keystore",
+]
+
+[[package]]
+name = "chrono"
+version = "0.4.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec837a71355b28f6556dbd569b37b3f363091c0bd4b2e735674521b4c5fd9bc5"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "time 0.1.45",
+ "wasm-bindgen",
+ "winapi",
+]
+
+[[package]]
+name = "ciborium"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "effd91f6c78e5a4ace8a5d3c0b6bfaec9e2baaef55f3efc00e45fb2e477ee926"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdf919175532b369853f5d5e20b26b43112613fd6fe7aee757e35f7a44642656"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "defaa24ecc093c77630e6c15e17c51f5e187bf35ee514f4e2d67baaa96dae22b"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "cid"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9b68e3193982cd54187d71afdb2a271ad4cf8af157858e9cb911b91321de143"
+dependencies = [
+ "core2",
+ "multibase",
+ "multihash",
+ "serde",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "cipher"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12f8e7987cbd042a63249497f41aed09f8e65add917ea6566effbc56578d6801"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "cipher"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "ckb-merkle-mountain-range"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56ccb671c5921be8a84686e6212ca184cb1d7c51cadcdbfcbd1cc3f042f5dfb8"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "clang-sys"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c688fc74432808e3eb684cae8830a86be1d66a2bd58e1f248ed0960a590baf6f"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "clap"
+version = "3.2.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea181bf566f71cb9a5d17a59e1871af638180a18fb0035c92ae62b705207123"
+dependencies = [
+ "bitflags",
+ "clap_lex 0.2.4",
+ "indexmap",
+ "textwrap",
+]
+
+[[package]]
+name = "clap"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "401a4694d2bf92537b6867d94de48c4842089645fdcdf6c71865b175d836e9c2"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+ "once_cell",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72394f3339a76daf211e57d4bcb374410f3965dcc606dd0e03738c7888766980"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "bitflags",
+ "clap_lex 0.5.0",
+ "strsim",
+]
+
+[[package]]
+name = "clap_complete"
+version = "4.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f6b5c519bab3ea61843a7923d074b04245624bb84a64a8c150f5deb014e388b"
+dependencies = [
+ "clap 4.3.2",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8cd2b2a819ad6eec39e8f1d6b53001af1e5469f8c177579cdaeb313115b825f"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2850f2f5a82cbf437dd5af4d49848fbdfc27c157c3d010345776f952765261c5"
+dependencies = [
+ "os_str_bytes",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2da6da31387c7e4ef160ffab6d5e7f00c42626fe39aea70a7b0f1773f7dd6c1b"
+
+[[package]]
+name = "codespan-reporting"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
+
+[[package]]
+name = "comfy-table"
+version = "7.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab77dbd8adecaf3f0db40581631b995f312a8a5ae3aa9993188bb8f23d83a5b"
+dependencies = [
+ "strum",
+ "strum_macros",
+ "unicode-width",
+]
+
+[[package]]
+name = "common"
+version = "0.1.0"
+source = "git+https://github.com/w3f/ring-proof#0e948f3c28cbacecdd3020403c4841c0eb339213"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-poly",
+ "ark-serialize",
+ "ark-std",
+ "fflonk",
+ "merlin 3.0.0",
+]
+
+[[package]]
+name = "common-path"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2382f75942f4b3be3690fe4f86365e9c853c1587d6ee58212cebf6e2a9ccd101"
+
+[[package]]
+name = "concurrent-queue"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62ec6771ecfa0762d24683ee5a32ad78487a3d3afdc0fb8cae19d2c5deb50b7c"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "console"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c926e00cc70edefdc64d3a5ff31cc65bb97a3460097762bd23afb4d8145fccf8"
+dependencies = [
+ "encode_unicode",
+ "lazy_static",
+ "libc",
+ "unicode-width",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "520fbf3c07483f94e3e3ca9d0cfd913d7718ef2483d2cfd91c0d9e91474ab913"
+
+[[package]]
+name = "const-random"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368a7a772ead6ce7e1de82bfb04c485f3db8ec744f72925af5735e29a22cc18e"
+dependencies = [
+ "const-random-macro",
+ "proc-macro-hack",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d7d6ab3c3a2282db210df5f02c4dab6e0a7057af0fb7ebd4070f30fe05c0ddb"
+dependencies = [
+ "getrandom 0.2.9",
+ "once_cell",
+ "proc-macro-hack",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
+
+[[package]]
+name = "constcat"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f272d0c4cf831b4fa80ee529c7707f76585986e910e1fbce1d7921970bc1a241"
+
+[[package]]
+name = "core-foundation"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
+
+[[package]]
+name = "core2"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "cpp_demangle"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eeaa953eaad386a53111e47172c2fedba671e5684c8dd601a5f474f4f118710f"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e4c1eaa2012c47becbbad2ab175484c2a84d1185b566fb2cc5b8707343dfe58"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cranelift-bforest"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1277fbfa94bc82c8ec4af2ded3e639d49ca5f7f3c7eeab2c66accd135ece4e70"
+dependencies = [
+ "cranelift-entity",
+]
+
+[[package]]
+name = "cranelift-codegen"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6e8c31ad3b2270e9aeec38723888fe1b0ace3bea2b06b3f749ccf46661d3220"
+dependencies = [
+ "bumpalo",
+ "cranelift-bforest",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-entity",
+ "cranelift-isle",
+ "gimli",
+ "hashbrown 0.13.2",
+ "log",
+ "regalloc2",
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-codegen-meta"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ac5ac30d62b2d66f12651f6b606dbdfd9c2cfd0908de6b387560a277c5c9da"
+dependencies = [
+ "cranelift-codegen-shared",
+]
+
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd82b8b376247834b59ed9bdc0ddeb50f517452827d4a11bccf5937b213748b8"
+
+[[package]]
+name = "cranelift-entity"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40099d38061b37e505e63f89bab52199037a72b931ad4868d9089ff7268660b0"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cranelift-frontend"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64a25d9d0a0ae3079c463c34115ec59507b4707175454f0eee0891e83e30e82d"
+dependencies = [
+ "cranelift-codegen",
+ "log",
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-isle"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80de6a7d0486e4acbd5f9f87ec49912bf4c8fb6aea00087b989685460d4469ba"
+
+[[package]]
+name = "cranelift-native"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb6b03e0e03801c4b3fd8ce0758a94750c07a44e7944cc0ffbf0d3f2e7c79b00"
+dependencies = [
+ "cranelift-codegen",
+ "libc",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cranelift-wasm"
+version = "0.95.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff3220489a3d928ad91e59dd7aeaa8b3de18afb554a6211213673a71c90737ac"
+dependencies = [
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "itertools",
+ "log",
+ "smallvec",
+ "wasmparser",
+ "wasmtime-types",
+]
+
+[[package]]
+name = "crc"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86ec7a15cbe22e59248fc7eadb1907dab5ba09372595da4d73dd805ed4417dfe"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cace84e55f07e7301bae1c519df89cdad8cc3cd868413d3fdbdeca9ff3db484"
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "criterion"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c76e09c1aae2bc52b3d2f29e13c6572553b30c4aa1b8a49fd70de6412654cb"
+dependencies = [
+ "anes",
+ "atty",
+ "cast",
+ "ciborium",
+ "clap 3.2.25",
+ "criterion-plot",
+ "futures",
+ "itertools",
+ "lazy_static",
+ "num-traits",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "tokio",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+dependencies = [
+ "cfg-if",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "crossbeam-utils",
+ "memoffset 0.8.0",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef2b4b23cddf68b89b8f8069890e8c270d54e2d5fe1b143820234805e4cb17ef"
+dependencies = [
+ "generic-array 0.14.7",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-bigint"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4c2f4e1afd912bc40bfd6fed5d9dc1f288e0ba01bfcc835cc5bc3eb13efe15"
+dependencies = [
+ "generic-array 0.14.7",
+ "rand_core 0.6.4",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array 0.14.7",
+ "rand_core 0.6.4",
+ "typenum",
+]
+
+[[package]]
+name = "crypto-mac"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
+dependencies = [
+ "generic-array 0.14.7",
+ "subtle",
+]
+
+[[package]]
+name = "crypto-mac"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
+dependencies = [
+ "generic-array 0.14.7",
+ "subtle",
+]
+
+[[package]]
+name = "ctor"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ctr"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
+dependencies = [
+ "cipher 0.3.0",
+]
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a9b85542f99a2dfa2a1b8e192662741c9859a846b296bef1c92ef9b58b5a216"
+dependencies = [
+ "byteorder",
+ "digest 0.8.1",
+ "rand_core 0.5.1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"
+dependencies = [
+ "byteorder",
+ "digest 0.9.0",
+ "rand_core 0.5.1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f711ade317dd348950a9910f81c5947e3d8907ebd2b83f76203ff1807e6a2bc2"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest 0.10.7",
+ "fiat-crypto",
+ "platforms",
+ "rustc_version 0.4.0",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fdaf97f4804dcebfa5862639bc9ce4121e82140bec2a987ac5140294865b5b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "cxx"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "109308c20e8445959c2792e81871054c6a17e6976489a93d2769641a2ba5839c"
+dependencies = [
+ "cc",
+ "cxxbridge-flags",
+ "cxxbridge-macro",
+ "link-cplusplus",
+]
+
+[[package]]
+name = "cxx-build"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf4c6755cdf10798b97510e0e2b3edb9573032bd9379de8fffa59d68165494f"
+dependencies = [
+ "cc",
+ "codespan-reporting",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "scratch",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "cxxbridge-flags"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "882074421238e84fe3b4c65d0081de34e5b323bf64555d3e61991f76eb64a7bb"
+
+[[package]]
+name = "cxxbridge-macro"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a076022ece33e7686fb76513518e219cca4fce5750a8ae6d1ce6c0f48fd1af9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "darling"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"
+
+[[package]]
+name = "data-encoding-macro"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c904b33cc60130e1aeea4956ab803d08a3f4a0ca82d64ed757afac3891f2bb99"
+dependencies = [
+ "data-encoding",
+ "data-encoding-macro-internal",
+]
+
+[[package]]
+name = "data-encoding-macro-internal"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fdf3fce3ce863539ec1d7fd1b6dcc3c645663376b43ed376bbf887733e4f772"
+dependencies = [
+ "data-encoding",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "der"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1a467a65c5e759bce6e65eaf91cc29f466cdc57cb65777bd646872a8a1fd4de"
+dependencies = [
+ "const-oid",
+ "pem-rfc7468",
+ "zeroize",
+]
+
+[[package]]
+name = "der"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56acb310e15652100da43d130af8d97b509e95af61aab1c5a7939ef24337ee17"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
+[[package]]
+name = "der-parser"
+version = "7.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe398ac75057914d7d07307bf67dc7f3f574a26783b4fc7805a20ffa9f506e82"
+dependencies = [
+ "asn1-rs 0.3.1",
+ "displaydoc",
+ "nom",
+ "num-bigint",
+ "num-traits",
+ "rusticata-macros",
+]
+
+[[package]]
+name = "der-parser"
+version = "8.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbd676fbbab537128ef0278adb5576cf363cff6aa22a7b24effe97347cfab61e"
+dependencies = [
+ "asn1-rs 0.5.2",
+ "displaydoc",
+ "nom",
+ "num-bigint",
+ "num-traits",
+ "rusticata-macros",
+]
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive-syn-parse"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e79116f119dd1dba1abf1f3405f03b9b0e79a27a3883864bfebded8a3dc768cd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_builder"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07adf7be193b71cc36b193d0f5fe60b918a3a9db4dad0449f57bcfd519704a3"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f91d4cfa921f1c05904dc3c57b4a32c38aed3340cce209f3a6fd1478babafc4"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f0314b72bed045f3a68671b3c86328386762c93f82d98c65c3cb5e5f573dd68"
+dependencies = [
+ "derive_builder_core",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_more"
+version = "0.99.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "digest"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
+dependencies = [
+ "generic-array 0.12.4",
+]
+
+[[package]]
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "const-oid",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "directories"
+version = "4.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f51c5d4ddabd36886dd3e1438cb358cdcb0d7c499cb99cb4ac2e38e18b5cb210"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "directories-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc"
+dependencies = [
+ "cfg-if",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "dissimilar"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "210ec60ae7d710bed8683e333e9d2855a8a56a3e9892b38bad3bb0d4d29b0d5e"
+
+[[package]]
+name = "dleq_vrf"
+version = "0.0.2"
+source = "git+https://github.com/w3f/ring-vrf?rev=c86ebd4#c86ebd4114d3165d05f9ce28c1d9e8d7a9a4e801"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-secret-scalar",
+ "ark-serialize",
+ "ark-std",
+ "ark-transcript",
+ "arrayvec 0.7.2",
+ "rand_core 0.6.4",
+ "zeroize",
+]
+
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
+[[package]]
+name = "docify"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "029de870d175d11969524d91a3fb2cbf6d488b853bff99d41cf65e533ac7d9d2"
+dependencies = [
+ "docify_macros",
+]
+
+[[package]]
+name = "docify_macros"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cac43324656a1b05eb0186deb51f27d2d891c704c37f34de281ef6297ba193e5"
+dependencies = [
+ "common-path",
+ "derive-syn-parse",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "syn 2.0.18",
+ "termcolor",
+ "toml 0.7.4",
+ "walkdir",
+]
+
+[[package]]
+name = "downcast"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1435fa1053d8b2fbbe9be7e97eca7f33d37b28409959813daefc1446a14247f1"
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
+
+[[package]]
+name = "dtoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65d09067bfacaa79114679b279d7f5885b53295b1e2cfb4e79c8e4bd3d633169"
+
+[[package]]
+name = "dyn-clonable"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e9232f0e607a262ceb9bd5141a3dfb3e4db6994b31989bbfd845878cba59fd4"
+dependencies = [
+ "dyn-clonable-impl",
+ "dyn-clone",
+]
+
+[[package]]
+name = "dyn-clonable-impl"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "558e40ea573c374cf53507fd240b7ee2f5477df7cfebdb97323ec61c719399c5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68b0cf012f1230e43cd00ebb729c6bb58707ecfa8ad08b52ef3a4ccd2697fc30"
+
+[[package]]
+name = "ecdsa"
+version = "0.14.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413301934810f597c1d19ca71c8710e99a3f1ba28a0d2ebc01551a2daeea3c5c"
+dependencies = [
+ "der 0.6.1",
+ "elliptic-curve 0.12.3",
+ "rfc6979 0.3.1",
+ "signature 1.6.4",
+]
+
+[[package]]
+name = "ecdsa"
+version = "0.16.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0997c976637b606099b9985693efa3581e84e41f5c11ba5255f88711058ad428"
+dependencies = [
+ "der 0.7.6",
+ "digest 0.10.7",
+ "elliptic-curve 0.13.5",
+ "rfc6979 0.4.0",
+ "signature 2.1.0",
+ "spki 0.7.2",
+]
+
+[[package]]
+name = "ed25519"
+version = "1.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91cff35c70bba8a626e3185d8cd48cc11b5437e1a5bcd15b9b5fa3c64b6dfee7"
+dependencies = [
+ "signature 1.6.4",
+]
+
+[[package]]
+name = "ed25519"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60f6d271ca33075c88028be6f04d502853d63a5ece419d269c15315d4fc1cf1d"
+dependencies = [
+ "pkcs8 0.10.2",
+ "signature 2.1.0",
+]
+
+[[package]]
+name = "ed25519-dalek"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d"
+dependencies = [
+ "curve25519-dalek 3.2.0",
+ "ed25519 1.5.3",
+ "rand 0.7.3",
+ "serde",
+ "sha2 0.9.9",
+ "zeroize",
+]
+
+[[package]]
+name = "ed25519-dalek"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7277392b266383ef8396db7fdeb1e77b6c52fed775f5df15bb24f35b72156980"
+dependencies = [
+ "curve25519-dalek 4.0.0",
+ "ed25519 2.2.2",
+ "serde",
+ "sha2 0.10.7",
+ "zeroize",
+]
+
+[[package]]
+name = "ed25519-zebra"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c24f403d068ad0b359e577a77f92392118be3f3c927538f2bb544a5ecd828c6"
+dependencies = [
+ "curve25519-dalek 3.2.0",
+ "hashbrown 0.12.3",
+ "hex",
+ "rand_core 0.6.4",
+ "sha2 0.9.9",
+ "zeroize",
+]
+
+[[package]]
+name = "either"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+
+[[package]]
+name = "elliptic-curve"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7bb888ab5300a19b8e5bceef25ac745ad065f3c9f7efc6de1b91958110891d3"
+dependencies = [
+ "base16ct 0.1.1",
+ "crypto-bigint 0.4.9",
+ "der 0.6.1",
+ "digest 0.10.7",
+ "ff 0.12.1",
+ "generic-array 0.14.7",
+ "group 0.12.1",
+ "hkdf",
+ "pem-rfc7468",
+ "pkcs8 0.9.0",
+ "rand_core 0.6.4",
+ "sec1 0.3.0",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "968405c8fdc9b3bf4df0a6638858cc0b52462836ab6b1c87377785dd09cf1c0b"
+dependencies = [
+ "base16ct 0.2.0",
+ "crypto-bigint 0.5.2",
+ "digest 0.10.7",
+ "ff 0.13.0",
+ "generic-array 0.14.7",
+ "group 0.13.0",
+ "pkcs8 0.10.2",
+ "rand_core 0.6.4",
+ "sec1 0.7.2",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "encode_unicode"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+
+[[package]]
+name = "enum-as-inner"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "enumflags2"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c041f5090df68b32bcd905365fd51769c8b9d553fe87fde0b683534f10c01bd2"
+dependencies = [
+ "enumflags2_derive",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e9a1f9f7d83e59740248a6e14ecf93929ade55027844dfcea78beafccc15745"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0"
+dependencies = [
+ "humantime",
+ "is-terminal",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "environmental"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48c92028aaa870e83d51c64e5d4e0b6981b360c522198c23959f219a4e1b15b"
+
+[[package]]
+name = "errno"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
+dependencies = [
+ "errno-dragonfly",
+ "libc",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "errno-dragonfly"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "event-listener"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
+[[package]]
+name = "exit-future"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e43f2f1833d64e33f15592464d6fdd70f349dda7b1a53088eb83cd94014008c5"
+dependencies = [
+ "futures",
+]
+
+[[package]]
+name = "expander"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f86a749cf851891866c10515ef6c299b5c69661465e9c3bbe7e07a2b77fb0f7"
+dependencies = [
+ "blake2",
+ "fs-err",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "fake-simd"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
+
+[[package]]
+name = "fallible-iterator"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+
+[[package]]
+name = "fastrand"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
+dependencies = [
+ "instant",
+]
+
+[[package]]
+name = "fdlimit"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c4c9e43643f5a3be4ca5b67d26b98031ff9db6806c3440ae32e02e3ceac3f1b"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "ff"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d013fc25338cc558c5c2cfbad646908fb23591e2404481826742b651c9af7160"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "ff"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
+dependencies = [
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "fflonk"
+version = "0.1.0"
+source = "git+https://github.com/w3f/fflonk#26a5045b24e169cffc1f9328ca83d71061145c40"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-poly",
+ "ark-serialize",
+ "ark-std",
+ "merlin 3.0.0",
+]
+
+[[package]]
+name = "fiat-crypto"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e825f6987101665dea6ec934c09ec6d721de7bc1bf92248e1d5810c8cd636b77"
+
+[[package]]
+name = "file-per-thread-logger"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84f2e425d9790201ba4af4630191feac6dcc98765b118d4d18e91d23c2353866"
+dependencies = [
+ "env_logger 0.10.0",
+ "log",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cbc844cecaee9d4443931972e1289c8ff485cb4cc2767cb03ca139ed6885153"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.2.16",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "finality-grandpa"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36530797b9bf31cd4ff126dcfee8170f86b00cfdcea3269d73133cc0415945c3"
+dependencies = [
+ "either",
+ "futures",
+ "futures-timer",
+ "log",
+ "num-traits",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "scale-info",
+]
+
+[[package]]
+name = "fixed-hash"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534"
+dependencies = [
+ "byteorder",
+ "rand 0.8.5",
+ "rustc-hex",
+ "static_assertions",
+]
+
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
+[[package]]
+name = "flate2"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743"
+dependencies = [
+ "crc32fast",
+ "libz-sys",
+ "miniz_oxide 0.7.1",
+]
+
+[[package]]
+name = "float-cmp"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "fork-tree"
+version = "3.0.0"
+dependencies = [
+ "parity-scale-codec",
+]
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fraction"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3027ae1df8d41b4bed2241c8fdad4acc1e7af60c8e17743534b545e77182d678"
+dependencies = [
+ "lazy_static",
+ "num",
+]
+
+[[package]]
+name = "fragile"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa"
+
+[[package]]
+name = "frame-benchmarking"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "frame-support",
+ "frame-support-procedural",
+ "frame-system",
+ "linregress",
+ "log",
+ "parity-scale-codec",
+ "paste",
+ "rusty-fork",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-io",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-runtime-interface",
+ "sp-std",
+ "sp-storage",
+ "static_assertions",
+]
+
+[[package]]
+name = "frame-benchmarking-cli"
+version = "4.0.0-dev"
+dependencies = [
+ "Inflector",
+ "array-bytes",
+ "chrono",
+ "clap 4.3.2",
+ "comfy-table",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "gethostname",
+ "handlebars",
+ "itertools",
+ "lazy_static",
+ "linked-hash-map",
+ "log",
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "rand_pcg",
+ "sc-block-builder",
+ "sc-cli",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-executor",
+ "sc-service",
+ "sc-sysinfo",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-blockchain",
+ "sp-core",
+ "sp-database",
+ "sp-externalities",
+ "sp-inherents",
+ "sp-io",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-storage",
+ "sp-trie",
+ "sp-wasm-interface",
+ "thiserror",
+ "thousands",
+]
+
+[[package]]
+name = "frame-benchmarking-pallet-pov"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "frame-election-provider-solution-type"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-support",
+ "parity-scale-codec",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "scale-info",
+ "sp-arithmetic",
+ "syn 2.0.18",
+ "trybuild",
+]
+
+[[package]]
+name = "frame-election-provider-support"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-election-provider-solution-type",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-npos-elections",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "frame-election-solution-type-fuzzer"
+version = "2.0.0-alpha.5"
+dependencies = [
+ "clap 4.3.2",
+ "frame-election-provider-solution-type",
+ "frame-election-provider-support",
+ "frame-support",
+ "honggfuzz",
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-npos-elections",
+ "sp-runtime",
+]
+
+[[package]]
+name = "frame-executive"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "frame-support",
+ "frame-system",
+ "frame-try-runtime",
+ "log",
+ "pallet-balances",
+ "pallet-transaction-payment",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-tracing",
+ "sp-version",
+]
+
+[[package]]
+name = "frame-metadata"
+version = "16.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cf1549fba25a6fcac22785b61698317d958e96cac72a59102ea45b9ae64692"
+dependencies = [
+ "cfg-if",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+]
+
+[[package]]
+name = "frame-remote-externalities"
+version = "0.10.0-dev"
+dependencies = [
+ "async-recursion",
+ "futures",
+ "indicatif",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-tracing",
+ "spinners",
+ "substrate-rpc-client",
+ "tokio",
+ "tokio-retry",
+]
+
+[[package]]
+name = "frame-support"
+version = "4.0.0-dev"
+dependencies = [
+ "aquamarine",
+ "array-bytes",
+ "assert_matches",
+ "bitflags",
+ "docify",
+ "environmental",
+ "frame-metadata",
+ "frame-support-procedural",
+ "frame-system",
+ "impl-trait-for-tuples",
+ "k256",
+ "log",
+ "macro_magic",
+ "parity-scale-codec",
+ "paste",
+ "pretty_assertions",
+ "scale-info",
+ "serde",
+ "serde_json",
+ "smallvec",
+ "sp-api",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-core-hashing-proc-macro",
+ "sp-debug-derive",
+ "sp-genesis-builder",
+ "sp-inherents",
+ "sp-io",
+ "sp-metadata-ir",
+ "sp-runtime",
+ "sp-staking",
+ "sp-state-machine",
+ "sp-std",
+ "sp-tracing",
+ "sp-weights",
+ "static_assertions",
+ "tt-call",
+]
+
+[[package]]
+name = "frame-support-procedural"
+version = "4.0.0-dev"
+dependencies = [
+ "Inflector",
+ "cfg-expr",
+ "derive-syn-parse",
+ "expander",
+ "frame-support-procedural-tools",
+ "itertools",
+ "macro_magic",
+ "proc-macro-warning",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "frame-support-procedural-tools"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support-procedural-tools-derive",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "frame-support-procedural-tools-derive"
+version = "3.0.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "frame-support-test"
+version = "3.0.0"
+dependencies = [
+ "frame-benchmarking",
+ "frame-executive",
+ "frame-metadata",
+ "frame-support",
+ "frame-support-test-pallet",
+ "frame-system",
+ "parity-scale-codec",
+ "pretty_assertions",
+ "rustversion",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-metadata-ir",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-std",
+ "sp-version",
+ "static_assertions",
+ "trybuild",
+]
+
+[[package]]
+name = "frame-support-test-compile-pass"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-runtime",
+ "sp-version",
+]
+
+[[package]]
+name = "frame-support-test-pallet"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-runtime",
+]
+
+[[package]]
+name = "frame-system"
+version = "4.0.0-dev"
+dependencies = [
+ "cfg-if",
+ "criterion",
+ "frame-support",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-externalities",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-version",
+ "sp-weights",
+ "substrate-test-runtime-client",
+]
+
+[[package]]
+name = "frame-system-benchmarking"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-externalities",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-version",
+]
+
+[[package]]
+name = "frame-system-rpc-runtime-api"
+version = "4.0.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "sp-api",
+]
+
+[[package]]
+name = "frame-try-runtime"
+version = "0.10.0-dev"
+dependencies = [
+ "frame-support",
+ "parity-scale-codec",
+ "sp-api",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "fs-err"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0845fa252299212f0389d64ba26f34fa32cfe41588355f21ed507c59a0f64541"
+
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "fs4"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7672706608ecb74ab2e055c68327ffc25ae4cac1e12349204fd5fb0f3487cce2"
+dependencies = [
+ "rustix 0.37.19",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+ "num_cpus",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+
+[[package]]
+name = "futures-lite"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49a9d51ce47660b1e808d3c990b4709f2f415d928835a17dfd16991515c46bce"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "memchr",
+ "parking",
+ "pin-project-lite 0.2.9",
+ "waker-fn",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "futures-rustls"
+version = "0.22.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2411eed028cdf8c8034eaf21f9915f956b6c3abec4d4c7949ee67f0721127bd"
+dependencies = [
+ "futures-io",
+ "rustls 0.20.8",
+ "webpki 0.22.0",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+
+[[package]]
+name = "futures-task"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+
+[[package]]
+name = "futures-timer"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
+
+[[package]]
+name = "futures-util"
+version = "0.3.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite 0.2.9",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "generate-bags"
+version = "4.0.0-dev"
+dependencies = [
+ "chrono",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "num-format",
+ "pallet-staking",
+ "sp-staking",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "gethostname"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1ebd34e35c46e00bb73e81363248d627782724609fe1b6396f553f68fe3862e"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.9.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ghash"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1583cc1656d7839fd3732b80cf4f38850336cdb9b8ded1cd399ca62958de3c99"
+dependencies = [
+ "opaque-debug 0.3.0",
+ "polyval 0.5.3",
+]
+
+[[package]]
+name = "ghash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d930750de5717d2dd0b8c0d42c076c0e884c81a73e6cab859bbd2339c71e3e40"
+dependencies = [
+ "opaque-debug 0.3.0",
+ "polyval 0.6.0",
+]
+
+[[package]]
+name = "gimli"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0a93d233ebf96623465aad4046a8d3aa4da22d4f4beba5388838c8a434bbb4"
+dependencies = [
+ "fallible-iterator",
+ "indexmap",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "globset"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "029d74589adefde59de1a0c4f4732695c32805624aec7b68d91503d4dba79afc"
+dependencies = [
+ "aho-corasick 0.7.20",
+ "bstr",
+ "fnv",
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "group"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfbfb3a6cfbd390d5c9564ab283a0349b9b9fcd46a706c1eb10e0db70bfbac7"
+dependencies = [
+ "ff 0.12.1",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "group"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
+dependencies = [
+ "ff 0.13.0",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "h2"
+version = "0.3.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d357c7ae988e7d2182f7d7871d0b963962420b0678b0997ce7de72001aeab782"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
+
+[[package]]
+name = "handlebars"
+version = "4.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83c3372087601b532857d332f5957cbae686da52bb7810bf038c3e3c3cc2fa0d"
+dependencies = [
+ "log",
+ "pest",
+ "pest_derive",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "hash-db"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e7d7786361d7425ae2fe4f9e407eb0efaa0840f5212d109cc018c40c35c6ab4"
+
+[[package]]
+name = "hash256-std-hasher"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92c171d55b98633f4ed3860808f004099b36c1cc29c42cfc53aa8591b21efcf2"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.6",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
+dependencies = [
+ "ahash 0.8.3",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hkdf"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437"
+dependencies = [
+ "hmac 0.12.1",
+]
+
+[[package]]
+name = "hmac"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "126888268dcc288495a26bf004b38c5fdbb31682f992c84ceb046a1f0fe38840"
+dependencies = [
+ "crypto-mac 0.8.0",
+ "digest 0.9.0",
+]
+
+[[package]]
+name = "hmac"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
+dependencies = [
+ "crypto-mac 0.11.1",
+ "digest 0.9.0",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "hmac-drbg"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17ea0a1394df5b6574da6e0c1ade9e78868c9fb0a4e5ef4428e32da4676b85b1"
+dependencies = [
+ "digest 0.9.0",
+ "generic-array 0.14.7",
+ "hmac 0.8.1",
+]
+
+[[package]]
+name = "honggfuzz"
+version = "0.5.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "848e9c511092e0daa0a35a63e8e6e475a3e8f870741448b9f6028d69b142f18e"
+dependencies = [
+ "arbitrary",
+ "lazy_static",
+ "memmap2",
+ "rustc_version 0.4.0",
+]
+
+[[package]]
+name = "hostname"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
+dependencies = [
+ "libc",
+ "match_cfg",
+ "winapi",
+]
+
+[[package]]
+name = "http"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
+dependencies = [
+ "bytes",
+ "http",
+ "pin-project-lite 0.2.9",
+]
+
+[[package]]
+name = "http-range-header"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bfe8eed0a9285ef776bb792479ea3834e8b94e13d615c2f66d03dd50a435a29"
+
+[[package]]
+name = "httparse"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
+
+[[package]]
+name = "httpdate"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "hyper"
+version = "0.14.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab302d72a6f11a3b910431ff93aae7e773078c769f0a3ef15fb9ec692ed147d4"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite 0.2.9",
+ "socket2",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
+dependencies = [
+ "futures-util",
+ "http",
+ "hyper",
+ "log",
+ "rustls 0.21.6",
+ "rustls-native-certs",
+ "tokio",
+ "tokio-rustls",
+ "webpki-roots 0.23.1",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0722cd7114b7de04316e7ea5456a0bbb20e4adb46fd27a3697adb812cff0f37c"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows 0.48.0",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+dependencies = [
+ "matches",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "idna"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "if-addrs"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbc0fa01ffc752e9dbc72818cdb072cd028b86be5e09dd04c5a643704fe101a9"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "if-watch"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9465340214b296cd17a0009acdb890d6160010b8adf8f78a00d0d7ab270f79f"
+dependencies = [
+ "async-io",
+ "core-foundation",
+ "fnv",
+ "futures",
+ "if-addrs",
+ "ipnet",
+ "log",
+ "rtnetlink",
+ "system-configuration",
+ "tokio",
+ "windows 0.34.0",
+]
+
+[[package]]
+name = "impl-codec"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f"
+dependencies = [
+ "parity-scale-codec",
+]
+
+[[package]]
+name = "impl-num-traits"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "951641f13f873bff03d4bf19ae8bec531935ac0ac2cc775f84d7edfdcfed3f17"
+dependencies = [
+ "integer-sqrt",
+ "num-traits",
+ "uint",
+]
+
+[[package]]
+name = "impl-serde"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc88fc67028ae3db0c853baa36269d398d5f45b6982f95549ff5def78c935cd"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "impl-trait-for-tuples"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "include_dir"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18762faeff7122e89e0857b02f7ce6fcc0d101d5e9ad2ad7846cc01d61b7f19e"
+dependencies = [
+ "include_dir_macros",
+]
+
+[[package]]
+name = "include_dir_macros"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b139284b5cf57ecfa712bcc66950bb635b31aff41c188e8a4cfc758eca374a3f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap-nostd"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e04e2fd2b8188ea827b32ef11de88377086d690286ab35747ef7f9bf3ccb590"
+
+[[package]]
+name = "indicatif"
+version = "0.17.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ff8cc23a7393a397ed1d7f56e6365cba772aba9f9912ab968b03043c395d057"
+dependencies = [
+ "console",
+ "instant",
+ "number_prefix",
+ "portable-atomic",
+ "unicode-width",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "integer-sqrt"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "276ec31bcb4a9ee45f58bec6f9ec700ae4cf4f4f8f2fa7e06cb406bd5ffdd770"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "interceptor"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e8a11ae2da61704edada656798b61c94b35ecac2c58eb955156987d5e6be90b"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "log",
+ "rand 0.8.5",
+ "rtcp",
+ "rtp",
+ "thiserror",
+ "tokio",
+ "waitgroup",
+ "webrtc-srtp",
+ "webrtc-util",
+]
+
+[[package]]
+name = "intx"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f38a50a899dc47a6d0ed5508e7f601a2e34c3a85303514b5d137f3c10a0c75"
+
+[[package]]
+name = "io-lifetimes"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
+dependencies = [
+ "hermit-abi 0.3.1",
+ "libc",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "ip_network"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2f047c0a98b2f299aa5d6d7088443570faae494e9ae1305e48be000c9e0eb1"
+
+[[package]]
+name = "ipconfig"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd302af1b90f2463a98fa5ad469fc212c8e3175a41c3068601bfa2727591c5be"
+dependencies = [
+ "socket2",
+ "widestring",
+ "winapi",
+ "winreg",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12b6ee2129af8d4fb011108c73d99a1b83a85977f23b82460c0ae2e25bb4b57f"
+
+[[package]]
+name = "is-terminal"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adcf93614601c8129ddf72e2d5633df827ba6551541c6d8c59520a371475be1f"
+dependencies = [
+ "hermit-abi 0.3.1",
+ "io-lifetimes",
+ "rustix 0.37.19",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "jobserver"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f37a4a5928311ac501dee68b3c7613a1037d0edb30c8e5427bd832d55d1b790"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-patch"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f54898088ccb91df1b492cc80029a6fdf1c48ca0db7c6822a8babad69c94658"
+dependencies = [
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "jsonrpsee"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "367a292944c07385839818bb71c8d76611138e2dedb0677d035b8da21d29c78b"
+dependencies = [
+ "jsonrpsee-core",
+ "jsonrpsee-http-client",
+ "jsonrpsee-proc-macros",
+ "jsonrpsee-server",
+ "jsonrpsee-types",
+ "jsonrpsee-ws-client",
+ "tracing",
+]
+
+[[package]]
+name = "jsonrpsee-client-transport"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8b3815d9f5d5de348e5f162b316dc9cdf4548305ebb15b4eb9328e66cf27d7a"
+dependencies = [
+ "futures-util",
+ "http",
+ "jsonrpsee-core",
+ "jsonrpsee-types",
+ "pin-project",
+ "rustls-native-certs",
+ "soketto",
+ "thiserror",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "tracing",
+ "webpki-roots 0.25.2",
+]
+
+[[package]]
+name = "jsonrpsee-core"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b5dde66c53d6dcdc8caea1874a45632ec0fcf5b437789f1e45766a1512ce803"
+dependencies = [
+ "anyhow",
+ "arrayvec 0.7.2",
+ "async-lock",
+ "async-trait",
+ "beef",
+ "futures-channel",
+ "futures-timer",
+ "futures-util",
+ "globset",
+ "hyper",
+ "jsonrpsee-types",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "rustc-hash",
+ "serde",
+ "serde_json",
+ "soketto",
+ "thiserror",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "jsonrpsee-http-client"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e5f9fabdd5d79344728521bb65e3106b49ec405a78b66fbff073b72b389fa43"
+dependencies = [
+ "async-trait",
+ "hyper",
+ "hyper-rustls",
+ "jsonrpsee-core",
+ "jsonrpsee-types",
+ "rustc-hash",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "jsonrpsee-proc-macros"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44e8ab85614a08792b9bff6c8feee23be78c98d0182d4c622c05256ab553892a"
+dependencies = [
+ "heck",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "jsonrpsee-server"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4d945a6008c9b03db3354fb3c83ee02d2faa9f2e755ec1dfb69c3551b8f4ba"
+dependencies = [
+ "futures-channel",
+ "futures-util",
+ "http",
+ "hyper",
+ "jsonrpsee-core",
+ "jsonrpsee-types",
+ "serde",
+ "serde_json",
+ "soketto",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tower",
+ "tracing",
+]
+
+[[package]]
+name = "jsonrpsee-types"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "245ba8e5aa633dd1c1e4fae72bce06e71f42d34c14a2767c6b4d173b57bee5e5"
+dependencies = [
+ "anyhow",
+ "beef",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "tracing",
+]
+
+[[package]]
+name = "jsonrpsee-ws-client"
+version = "0.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e1b3975ed5d73f456478681a417128597acd6a2487855fdb7b4a3d4d195bf5e"
+dependencies = [
+ "http",
+ "jsonrpsee-client-transport",
+ "jsonrpsee-core",
+ "jsonrpsee-types",
+]
+
+[[package]]
+name = "k256"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cadb76004ed8e97623117f3df85b17aaa6626ab0b0831e6573f104df16cd1bcc"
+dependencies = [
+ "cfg-if",
+ "ecdsa 0.16.7",
+ "elliptic-curve 0.13.5",
+ "once_cell",
+ "sha2 0.10.7",
+]
+
+[[package]]
+name = "keccak"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "keccak-hasher"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ea4653859ca2266a86419d3f592d3f22e7a854b482f99180d2498507902048"
+dependencies = [
+ "hash-db",
+ "hash256-std-hasher",
+ "tiny-keccak",
+]
+
+[[package]]
+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-tx-payment",
+ "pallet-asset-rate",
+ "pallet-asset-tx-payment",
+ "pallet-assets",
+ "pallet-authority-discovery",
+ "pallet-authorship",
+ "pallet-babe",
+ "pallet-bags-list",
+ "pallet-balances",
+ "pallet-bounties",
+ "pallet-broker",
+ "pallet-child-bounties",
+ "pallet-collective",
+ "pallet-contracts",
+ "pallet-contracts-primitives",
+ "pallet-conviction-voting",
+ "pallet-core-fellowship",
+ "pallet-democracy",
+ "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-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-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-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",
+ "primitive-types",
+ "scale-info",
+ "sp-api",
+ "sp-authority-discovery",
+ "sp-block-builder",
+ "sp-consensus-babe",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-offchain",
+ "sp-runtime",
+ "sp-session",
+ "sp-staking",
+ "sp-statement-store",
+ "sp-std",
+ "sp-storage",
+ "sp-transaction-pool",
+ "sp-version",
+ "static_assertions",
+ "substrate-wasm-builder",
+]
+
+[[package]]
+name = "kvdb"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7d770dcb02bf6835887c3a979b5107a04ff4bbde97a5f0928d27404a155add9"
+dependencies = [
+ "smallvec",
+]
+
+[[package]]
+name = "kvdb-memorydb"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf7a85fe66f9ff9cd74e169fdd2c94c6e1e74c412c99a73b4df3200b5d3760b2"
+dependencies = [
+ "kvdb",
+ "parking_lot 0.12.1",
+]
+
+[[package]]
+name = "kvdb-rocksdb"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b644c70b92285f66bfc2032922a79000ea30af7bc2ab31902992a5dcb9b434f6"
+dependencies = [
+ "kvdb",
+ "num_cpus",
+ "parking_lot 0.12.1",
+ "regex",
+ "rocksdb",
+ "smallvec",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "leb128"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+
+[[package]]
+name = "libc"
+version = "0.2.147"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+
+[[package]]
+name = "libp2p"
+version = "0.51.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f210d259724eae82005b5c48078619b7745edb7b76de370b03f8ba59ea103097"
+dependencies = [
+ "bytes",
+ "futures",
+ "futures-timer",
+ "getrandom 0.2.9",
+ "instant",
+ "libp2p-allow-block-list",
+ "libp2p-connection-limits",
+ "libp2p-core",
+ "libp2p-dns",
+ "libp2p-identify",
+ "libp2p-identity",
+ "libp2p-kad",
+ "libp2p-mdns",
+ "libp2p-metrics",
+ "libp2p-noise",
+ "libp2p-ping",
+ "libp2p-quic",
+ "libp2p-request-response",
+ "libp2p-swarm",
+ "libp2p-tcp",
+ "libp2p-wasm-ext",
+ "libp2p-webrtc",
+ "libp2p-websocket",
+ "libp2p-yamux",
+ "multiaddr",
+ "pin-project",
+]
+
+[[package]]
+name = "libp2p-allow-block-list"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "510daa05efbc25184458db837f6f9a5143888f1caa742426d92e1833ddd38a50"
+dependencies = [
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-swarm",
+ "void",
+]
+
+[[package]]
+name = "libp2p-connection-limits"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4caa33f1d26ed664c4fe2cca81a08c8e07d4c1c04f2f4ac7655c2dd85467fda0"
+dependencies = [
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-swarm",
+ "void",
+]
+
+[[package]]
+name = "libp2p-core"
+version = "0.39.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c1df63c0b582aa434fb09b2d86897fa2b419ffeccf934b36f87fcedc8e835c2"
+dependencies = [
+ "either",
+ "fnv",
+ "futures",
+ "futures-timer",
+ "instant",
+ "libp2p-identity",
+ "log",
+ "multiaddr",
+ "multihash",
+ "multistream-select",
+ "once_cell",
+ "parking_lot 0.12.1",
+ "pin-project",
+ "quick-protobuf",
+ "rand 0.8.5",
+ "rw-stream-sink",
+ "smallvec",
+ "thiserror",
+ "unsigned-varint",
+ "void",
+]
+
+[[package]]
+name = "libp2p-dns"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146ff7034daae62077c415c2376b8057368042df6ab95f5432ad5e88568b1554"
+dependencies = [
+ "futures",
+ "libp2p-core",
+ "log",
+ "parking_lot 0.12.1",
+ "smallvec",
+ "trust-dns-resolver",
+]
+
+[[package]]
+name = "libp2p-identify"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5455f472243e63b9c497ff320ded0314254a9eb751799a39c283c6f20b793f3c"
+dependencies = [
+ "asynchronous-codec",
+ "either",
+ "futures",
+ "futures-timer",
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-swarm",
+ "log",
+ "lru",
+ "quick-protobuf",
+ "quick-protobuf-codec",
+ "smallvec",
+ "thiserror",
+ "void",
+]
+
+[[package]]
+name = "libp2p-identity"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e2d584751cecb2aabaa56106be6be91338a60a0f4e420cf2af639204f596fc1"
+dependencies = [
+ "bs58",
+ "ed25519-dalek 1.0.1",
+ "log",
+ "multiaddr",
+ "multihash",
+ "quick-protobuf",
+ "rand 0.8.5",
+ "sha2 0.10.7",
+ "thiserror",
+ "zeroize",
+]
+
+[[package]]
+name = "libp2p-kad"
+version = "0.43.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39d5ef876a2b2323d63c258e63c2f8e36f205fe5a11f0b3095d59635650790ff"
+dependencies = [
+ "arrayvec 0.7.2",
+ "asynchronous-codec",
+ "bytes",
+ "either",
+ "fnv",
+ "futures",
+ "futures-timer",
+ "instant",
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-swarm",
+ "log",
+ "quick-protobuf",
+ "rand 0.8.5",
+ "sha2 0.10.7",
+ "smallvec",
+ "thiserror",
+ "uint",
+ "unsigned-varint",
+ "void",
+]
+
+[[package]]
+name = "libp2p-mdns"
+version = "0.43.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19983e1f949f979a928f2c603de1cf180cc0dc23e4ac93a62651ccb18341460b"
+dependencies = [
+ "data-encoding",
+ "futures",
+ "if-watch",
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-swarm",
+ "log",
+ "rand 0.8.5",
+ "smallvec",
+ "socket2",
+ "tokio",
+ "trust-dns-proto",
+ "void",
+]
+
+[[package]]
+name = "libp2p-metrics"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a42ec91e227d7d0dafa4ce88b333cdf5f277253873ab087555c92798db2ddd46"
+dependencies = [
+ "libp2p-core",
+ "libp2p-identify",
+ "libp2p-kad",
+ "libp2p-ping",
+ "libp2p-swarm",
+ "prometheus-client",
+]
+
+[[package]]
+name = "libp2p-noise"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3673da89d29936bc6435bafc638e2f184180d554ce844db65915113f86ec5e"
+dependencies = [
+ "bytes",
+ "curve25519-dalek 3.2.0",
+ "futures",
+ "libp2p-core",
+ "libp2p-identity",
+ "log",
+ "once_cell",
+ "quick-protobuf",
+ "rand 0.8.5",
+ "sha2 0.10.7",
+ "snow",
+ "static_assertions",
+ "thiserror",
+ "x25519-dalek 1.1.1",
+ "zeroize",
+]
+
+[[package]]
+name = "libp2p-ping"
+version = "0.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e57759c19c28a73ef1eb3585ca410cefb72c1a709fcf6de1612a378e4219202"
+dependencies = [
+ "either",
+ "futures",
+ "futures-timer",
+ "instant",
+ "libp2p-core",
+ "libp2p-swarm",
+ "log",
+ "rand 0.8.5",
+ "void",
+]
+
+[[package]]
+name = "libp2p-quic"
+version = "0.7.0-alpha.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6b26abd81cd2398382a1edfe739b539775be8a90fa6914f39b2ab49571ec735"
+dependencies = [
+ "bytes",
+ "futures",
+ "futures-timer",
+ "if-watch",
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-tls",
+ "log",
+ "parking_lot 0.12.1",
+ "quinn-proto",
+ "rand 0.8.5",
+ "rustls 0.20.8",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "libp2p-request-response"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ffdb374267d42dc5ed5bc53f6e601d4a64ac5964779c6e40bb9e4f14c1e30d5"
+dependencies = [
+ "async-trait",
+ "futures",
+ "instant",
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-swarm",
+ "rand 0.8.5",
+ "smallvec",
+]
+
+[[package]]
+name = "libp2p-swarm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "903b3d592d7694e56204d211f29d31bc004be99386644ba8731fc3e3ef27b296"
+dependencies = [
+ "either",
+ "fnv",
+ "futures",
+ "futures-timer",
+ "instant",
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-swarm-derive",
+ "log",
+ "rand 0.8.5",
+ "smallvec",
+ "tokio",
+ "void",
+]
+
+[[package]]
+name = "libp2p-swarm-derive"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fba456131824ab6acd4c7bf61e9c0f0a3014b5fc9868ccb8e10d344594cdc4f"
+dependencies = [
+ "heck",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "libp2p-tcp"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33d33698596d7722d85d3ab0c86c2c322254fce1241e91208e3679b4eb3026cf"
+dependencies = [
+ "futures",
+ "futures-timer",
+ "if-watch",
+ "libc",
+ "libp2p-core",
+ "log",
+ "socket2",
+ "tokio",
+]
+
+[[package]]
+name = "libp2p-tls"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff08d13d0dc66e5e9ba6279c1de417b84fa0d0adc3b03e5732928c180ec02781"
+dependencies = [
+ "futures",
+ "futures-rustls",
+ "libp2p-core",
+ "libp2p-identity",
+ "rcgen 0.10.0",
+ "ring 0.16.20",
+ "rustls 0.20.8",
+ "thiserror",
+ "webpki 0.22.0",
+ "x509-parser 0.14.0",
+ "yasna",
+]
+
+[[package]]
+name = "libp2p-wasm-ext"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77dff9d32353a5887adb86c8afc1de1a94d9e8c3bc6df8b2201d7cdf5c848f43"
+dependencies = [
+ "futures",
+ "js-sys",
+ "libp2p-core",
+ "parity-send-wrapper",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "libp2p-webrtc"
+version = "0.4.0-alpha.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dba48592edbc2f60b4bc7c10d65445b0c3964c07df26fdf493b6880d33be36f8"
+dependencies = [
+ "async-trait",
+ "asynchronous-codec",
+ "bytes",
+ "futures",
+ "futures-timer",
+ "hex",
+ "if-watch",
+ "libp2p-core",
+ "libp2p-identity",
+ "libp2p-noise",
+ "log",
+ "multihash",
+ "quick-protobuf",
+ "quick-protobuf-codec",
+ "rand 0.8.5",
+ "rcgen 0.9.3",
+ "serde",
+ "stun",
+ "thiserror",
+ "tinytemplate",
+ "tokio",
+ "tokio-util",
+ "webrtc",
+]
+
+[[package]]
+name = "libp2p-websocket"
+version = "0.41.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "111273f7b3d3510524c752e8b7a5314b7f7a1fee7e68161c01a7d72cbb06db9f"
+dependencies = [
+ "either",
+ "futures",
+ "futures-rustls",
+ "libp2p-core",
+ "log",
+ "parking_lot 0.12.1",
+ "quicksink",
+ "rw-stream-sink",
+ "soketto",
+ "url",
+ "webpki-roots 0.22.6",
+]
+
+[[package]]
+name = "libp2p-yamux"
+version = "0.43.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dcd21d950662700a385d4c6d68e2f5f54d778e97068cdd718522222ef513bda"
+dependencies = [
+ "futures",
+ "libp2p-core",
+ "log",
+ "thiserror",
+ "yamux",
+]
+
+[[package]]
+name = "librocksdb-sys"
+version = "0.11.0+8.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3386f101bcb4bd252d8e9d2fb41ec3b0862a15a62b478c355b2982efa469e3e"
+dependencies = [
+ "bindgen",
+ "bzip2-sys",
+ "cc",
+ "glob",
+ "libc",
+ "libz-sys",
+ "tikv-jemalloc-sys",
+]
+
+[[package]]
+name = "libsecp256k1"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95b09eff1b35ed3b33b877ced3a691fc7a481919c7e29c53c906226fcf55e2a1"
+dependencies = [
+ "arrayref",
+ "base64 0.13.1",
+ "digest 0.9.0",
+ "hmac-drbg",
+ "libsecp256k1-core",
+ "libsecp256k1-gen-ecmult",
+ "libsecp256k1-gen-genmult",
+ "rand 0.8.5",
+ "serde",
+ "sha2 0.9.9",
+ "typenum",
+]
+
+[[package]]
+name = "libsecp256k1-core"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5be9b9bb642d8522a44d533eab56c16c738301965504753b03ad1de3425d5451"
+dependencies = [
+ "crunchy",
+ "digest 0.9.0",
+ "subtle",
+]
+
+[[package]]
+name = "libsecp256k1-gen-ecmult"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3038c808c55c87e8a172643a7d87187fc6c4174468159cb3090659d55bcb4809"
+dependencies = [
+ "libsecp256k1-core",
+]
+
+[[package]]
+name = "libsecp256k1-gen-genmult"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db8d6ba2cec9eacc40e6e8ccc98931840301f1006e95647ceb2dd5c3aa06f7c"
+dependencies = [
+ "libsecp256k1-core",
+]
+
+[[package]]
+name = "libz-sys"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56ee889ecc9568871456d42f603d6a0ce59ff328d291063a45cbdf0036baf6db"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "link-cplusplus"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "linked_hash_set"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47186c6da4d81ca383c7c47c1bfc80f4b95f4720514d860a5407aaf4233f9588"
+dependencies = [
+ "linked-hash-map",
+]
+
+[[package]]
+name = "linregress"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "475015a7f8f017edb28d2e69813be23500ad4b32cfe3421c4148efc97324ee52"
+dependencies = [
+ "nalgebra",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
+
+[[package]]
+name = "lite-json"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0e787ffe1153141a0f6f6d759fdf1cc34b1226e088444523812fd412a5cca2"
+dependencies = [
+ "lite-parser",
+]
+
+[[package]]
+name = "lite-parser"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d5f9dc37c52d889a21fd701983d02bb6a84f852c5140a6c80ef4557f7dc29e"
+dependencies = [
+ "paste",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "518ef76f2f87365916b142844c16d8fefd85039bc5699050210a7778ee1cd1de"
+
+[[package]]
+name = "lru"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03f1160296536f10c833a82dca22267d5486734230d47bf00bf435885814ba1e"
+dependencies = [
+ "hashbrown 0.13.2",
+]
+
+[[package]]
+name = "lru-cache"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
+dependencies = [
+ "linked-hash-map",
+]
+
+[[package]]
+name = "lz4"
+version = "1.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e9e2dd86df36ce760a60f6ff6ad526f7ba1f14ba0356f8254fb6905e6494df1"
+dependencies = [
+ "libc",
+ "lz4-sys",
+]
+
+[[package]]
+name = "lz4-sys"
+version = "1.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57d27b317e207b10f69f5e75494119e391a96f48861ae870d1da6edac98ca900"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "mach"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "macro_magic"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aee866bfee30d2d7e83835a4574aad5b45adba4cc807f2a3bbba974e5d4383c9"
+dependencies = [
+ "macro_magic_core",
+ "macro_magic_macros",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "macro_magic_core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e766a20fd9c72bab3e1e64ed63f36bd08410e75803813df210d1ce297d7ad00"
+dependencies = [
+ "const-random",
+ "derive-syn-parse",
+ "macro_magic_core_macros",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "macro_magic_core_macros"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c12469fc165526520dff2807c2975310ab47cf7190a45b99b49a7dc8befab17b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "macro_magic_macros"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fb85ec1620619edf2984a7693497d4ec88a9665d8b87e942856884c92dbf2a"
+dependencies = [
+ "macro_magic_core",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "maplit"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
+
+[[package]]
+name = "match_cfg"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
+
+[[package]]
+name = "matchers"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f099785f7595cc4b4553a174ce30dd7589ef93391ff414dbb67f62392b9e0ce1"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "matches"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "090126dc04f95dc0d1c1c91f61bdd474b3930ca064c1edc8a849da2c6cbe1e77"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "md-5"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6365506850d44bff6e2fbcb5176cf63650e48bd45ef2fe2665ae1570e0f4b9ca"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "memfd"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffc89ccdc6e10d6907450f753537ebc5c5d3460d2e4e62ea74bd571db62c0f9e"
+dependencies = [
+ "rustix 0.37.19",
+]
+
+[[package]]
+name = "memmap2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memory-db"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "808b50db46293432a45e63bc15ea51e0ab4c0a1647b8eb114e31a3e698dd6fbe"
+dependencies = [
+ "hash-db",
+]
+
+[[package]]
+name = "merlin"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e261cf0f8b3c42ded9f7d2bb59dea03aa52bc8a1cbc7482f9fc3fd1229d3b42"
+dependencies = [
+ "byteorder",
+ "keccak",
+ "rand_core 0.5.1",
+ "zeroize",
+]
+
+[[package]]
+name = "merlin"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58c38e2799fc0978b65dfff8023ec7843e2330bb462f19198840b34b6582397d"
+dependencies = [
+ "byteorder",
+ "keccak",
+ "rand_core 0.6.4",
+ "zeroize",
+]
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "mio"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2"
+dependencies = [
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "mmr-gadget"
+version = "4.0.0-dev"
+dependencies = [
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-offchain",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-beefy",
+ "sp-core",
+ "sp-mmr-primitives",
+ "sp-runtime",
+ "sp-tracing",
+ "substrate-test-runtime-client",
+ "tokio",
+]
+
+[[package]]
+name = "mmr-rpc"
+version = "4.0.0-dev"
+dependencies = [
+ "anyhow",
+ "jsonrpsee",
+ "parity-scale-codec",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-blockchain",
+ "sp-core",
+ "sp-mmr-primitives",
+ "sp-runtime",
+]
+
+[[package]]
+name = "mockall"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c84490118f2ee2d74570d114f3d0493cbf02790df303d2707606c3e14e07c96"
+dependencies = [
+ "cfg-if",
+ "downcast",
+ "fragile",
+ "lazy_static",
+ "mockall_derive",
+ "predicates 2.1.5",
+ "predicates-tree",
+]
+
+[[package]]
+name = "mockall_derive"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22ce75669015c4f47b289fd4d4f56e894e4c96003ffdf3ac51313126f94c6cbb"
+dependencies = [
+ "cfg-if",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "multiaddr"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b36f567c7099511fa8612bbbb52dda2419ce0bdbacf31714e3a5ffdb766d3bd"
+dependencies = [
+ "arrayref",
+ "byteorder",
+ "data-encoding",
+ "log",
+ "multibase",
+ "multihash",
+ "percent-encoding",
+ "serde",
+ "static_assertions",
+ "unsigned-varint",
+ "url",
+]
+
+[[package]]
+name = "multibase"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b3539ec3c1f04ac9748a260728e855f261b4977f5c3406612c884564f329404"
+dependencies = [
+ "base-x",
+ "data-encoding",
+ "data-encoding-macro",
+]
+
+[[package]]
+name = "multihash"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "835d6ff01d610179fbce3de1694d007e500bf33a7f29689838941d6bf783ae40"
+dependencies = [
+ "blake2b_simd",
+ "blake2s_simd",
+ "blake3",
+ "core2",
+ "digest 0.10.7",
+ "multihash-derive",
+ "sha2 0.10.7",
+ "sha3",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "multihash-derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d6d4752e6230d8ef7adf7bd5d8c4b1f6561c1014c5ba9a37445ccefe18aa1db"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "synstructure",
+]
+
+[[package]]
+name = "multimap"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
+
+[[package]]
+name = "multistream-select"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8552ab875c1313b97b8d20cb857b9fd63e2d1d6a0a1b53ce9821e575405f27a"
+dependencies = [
+ "bytes",
+ "futures",
+ "log",
+ "pin-project",
+ "smallvec",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "nalgebra"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d68d47bba83f9e2006d117a9a33af1524e655516b8919caac694427a6fb1e511"
+dependencies = [
+ "approx",
+ "matrixmultiply",
+ "nalgebra-macros",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "simba",
+ "typenum",
+]
+
+[[package]]
+name = "nalgebra-macros"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d232c68884c0c99810a5a4d333ef7e47689cfd0edc85efc9e54e1e6bf5212766"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "names"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7d66043b25d4a6cccb23619d10c19c25304b355a7dccd4a8e11423dd2382146"
+dependencies = [
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "netlink-packet-core"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "345b8ab5bd4e71a2986663e88c56856699d060e78e152e6e9d7966fcd5491297"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "libc",
+ "netlink-packet-utils",
+]
+
+[[package]]
+name = "netlink-packet-route"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9ea4302b9759a7a88242299225ea3688e63c85ea136371bb6cf94fd674efaab"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "byteorder",
+ "libc",
+ "netlink-packet-core",
+ "netlink-packet-utils",
+]
+
+[[package]]
+name = "netlink-packet-utils"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ede8a08c71ad5a95cdd0e4e52facd37190977039a4704eb82a283f713747d34"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "paste",
+ "thiserror",
+]
+
+[[package]]
+name = "netlink-proto"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65b4b14489ab424703c092062176d52ba55485a89c076b4f9db05092b7223aa6"
+dependencies = [
+ "bytes",
+ "futures",
+ "log",
+ "netlink-packet-core",
+ "netlink-sys",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "netlink-sys"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6471bf08e7ac0135876a9581bf3217ef0333c191c128d34878079f42ee150411"
+dependencies = [
+ "bytes",
+ "futures",
+ "libc",
+ "log",
+ "tokio",
+]
+
+[[package]]
+name = "nix"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+ "memoffset 0.6.5",
+]
+
+[[package]]
+name = "nix"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfdda3d196821d6af13126e40375cdf7da646a96114af134d5f417a9a1dc8e1a"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+ "memoffset 0.7.1",
+ "pin-utils",
+ "static_assertions",
+]
+
+[[package]]
+name = "node-bench"
+version = "0.9.0-dev"
+dependencies = [
+ "array-bytes",
+ "clap 4.3.2",
+ "derive_more",
+ "fs_extra",
+ "futures",
+ "hash-db",
+ "kitchensink-runtime",
+ "kvdb",
+ "kvdb-rocksdb",
+ "lazy_static",
+ "log",
+ "node-primitives",
+ "node-testing",
+ "parity-db",
+ "rand 0.8.5",
+ "sc-basic-authorship",
+ "sc-client-api",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "serde",
+ "serde_json",
+ "sp-consensus",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-timestamp",
+ "sp-tracing",
+ "sp-trie",
+ "tempfile",
+]
+
+[[package]]
+name = "node-cli"
+version = "3.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "assert_cmd",
+ "clap 4.3.2",
+ "clap_complete",
+ "criterion",
+ "frame-benchmarking-cli",
+ "frame-system",
+ "frame-system-rpc-runtime-api",
+ "futures",
+ "jsonrpsee",
+ "kitchensink-runtime",
+ "log",
+ "nix 0.26.2",
+ "node-executor",
+ "node-inspect",
+ "node-primitives",
+ "node-rpc",
+ "pallet-asset-conversion-tx-payment",
+ "pallet-asset-tx-payment",
+ "pallet-assets",
+ "pallet-balances",
+ "pallet-im-online",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "platforms",
+ "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-epochs",
+ "sc-consensus-grandpa",
+ "sc-consensus-slots",
+ "sc-executor",
+ "sc-keystore",
+ "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",
+ "serde",
+ "serde_json",
+ "soketto",
+ "sp-api",
+ "sp-authority-discovery",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-babe",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-statement-store",
+ "sp-timestamp",
+ "sp-tracing",
+ "sp-transaction-storage-proof",
+ "substrate-build-script-utils",
+ "substrate-cli-test-utils",
+ "substrate-frame-cli",
+ "substrate-rpc-client",
+ "tempfile",
+ "tokio",
+ "tokio-util",
+ "try-runtime-cli",
+ "wait-timeout",
+]
+
+[[package]]
+name = "node-executor"
+version = "3.0.0-dev"
+dependencies = [
+ "criterion",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "futures",
+ "kitchensink-runtime",
+ "node-primitives",
+ "node-testing",
+ "pallet-balances",
+ "pallet-contracts",
+ "pallet-glutton",
+ "pallet-im-online",
+ "pallet-root-testing",
+ "pallet-sudo",
+ "pallet-timestamp",
+ "pallet-transaction-payment",
+ "pallet-treasury",
+ "parity-scale-codec",
+ "sc-executor",
+ "scale-info",
+ "sp-application-crypto",
+ "sp-consensus-babe",
+ "sp-core",
+ "sp-externalities",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-statement-store",
+ "sp-tracing",
+ "sp-trie",
+ "wat",
+]
+
+[[package]]
+name = "node-inspect"
+version = "0.9.0-dev"
+dependencies = [
+ "clap 4.3.2",
+ "parity-scale-codec",
+ "sc-cli",
+ "sc-client-api",
+ "sc-service",
+ "sp-blockchain",
+ "sp-core",
+ "sp-runtime",
+ "thiserror",
+]
+
+[[package]]
+name = "node-primitives"
+version = "2.0.0"
+dependencies = [
+ "sp-core",
+ "sp-runtime",
+]
+
+[[package]]
+name = "node-rpc"
+version = "3.0.0-dev"
+dependencies = [
+ "jsonrpsee",
+ "mmr-rpc",
+ "node-primitives",
+ "pallet-transaction-payment-rpc",
+ "sc-chain-spec",
+ "sc-client-api",
+ "sc-consensus-babe",
+ "sc-consensus-babe-rpc",
+ "sc-consensus-grandpa",
+ "sc-consensus-grandpa-rpc",
+ "sc-rpc",
+ "sc-rpc-api",
+ "sc-rpc-spec-v2",
+ "sc-sync-state-rpc",
+ "sc-transaction-pool-api",
+ "sp-api",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-babe",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-statement-store",
+ "substrate-frame-rpc-system",
+ "substrate-state-trie-migration-rpc",
+]
+
+[[package]]
+name = "node-runtime-generate-bags"
+version = "3.0.0"
+dependencies = [
+ "clap 4.3.2",
+ "generate-bags",
+ "kitchensink-runtime",
+]
+
+[[package]]
+name = "node-template"
+version = "4.0.0-dev"
+dependencies = [
+ "clap 4.3.2",
+ "frame-benchmarking",
+ "frame-benchmarking-cli",
+ "frame-system",
+ "futures",
+ "jsonrpsee",
+ "node-template-runtime",
+ "pallet-transaction-payment",
+ "pallet-transaction-payment-rpc",
+ "sc-basic-authorship",
+ "sc-cli",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-consensus-aura",
+ "sc-consensus-grandpa",
+ "sc-executor",
+ "sc-network",
+ "sc-offchain",
+ "sc-rpc-api",
+ "sc-service",
+ "sc-telemetry",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sp-api",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-consensus-aura",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-keyring",
+ "sp-runtime",
+ "sp-timestamp",
+ "substrate-build-script-utils",
+ "substrate-frame-rpc-system",
+ "try-runtime-cli",
+]
+
+[[package]]
+name = "node-template-release"
+version = "3.0.0"
+dependencies = [
+ "clap 4.3.2",
+ "flate2",
+ "fs_extra",
+ "glob",
+ "itertools",
+ "tar",
+ "tempfile",
+ "toml_edit",
+]
+
+[[package]]
+name = "node-template-runtime"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-executive",
+ "frame-support",
+ "frame-system",
+ "frame-system-benchmarking",
+ "frame-system-rpc-runtime-api",
+ "frame-try-runtime",
+ "pallet-aura",
+ "pallet-balances",
+ "pallet-grandpa",
+ "pallet-sudo",
+ "pallet-template",
+ "pallet-timestamp",
+ "pallet-transaction-payment",
+ "pallet-transaction-payment-rpc-runtime-api",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-block-builder",
+ "sp-consensus-aura",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-inherents",
+ "sp-offchain",
+ "sp-runtime",
+ "sp-session",
+ "sp-std",
+ "sp-storage",
+ "sp-transaction-pool",
+ "sp-version",
+ "substrate-wasm-builder",
+]
+
+[[package]]
+name = "node-testing"
+version = "3.0.0-dev"
+dependencies = [
+ "frame-system",
+ "fs_extra",
+ "futures",
+ "kitchensink-runtime",
+ "log",
+ "node-executor",
+ "node-primitives",
+ "pallet-asset-conversion",
+ "pallet-asset-conversion-tx-payment",
+ "pallet-asset-tx-payment",
+ "pallet-assets",
+ "parity-scale-codec",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-consensus",
+ "sc-executor",
+ "sc-service",
+ "sp-api",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-keyring",
+ "sp-runtime",
+ "sp-timestamp",
+ "substrate-test-client",
+ "tempfile",
+]
+
+[[package]]
+name = "nohash-hasher"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "normalize-line-endings"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
+
+[[package]]
+name = "num"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43db66d1170d347f9a065114077f7dccb00c1b9478c89384490a3425279a4606"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02e0d21255c828d6f128a1e41534206671e8c3ea0c62f32291e808dc82cff17d"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-format"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3"
+dependencies = [
+ "arrayvec 0.7.2",
+ "itoa",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
+dependencies = [
+ "autocfg",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+dependencies = [
+ "hermit-abi 0.2.6",
+ "libc",
+]
+
+[[package]]
+name = "number_prefix"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
+
+[[package]]
+name = "object"
+version = "0.30.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b4680b86d9cfafba8fc491dc9b6df26b68cf40e9e6cd73909194759a63c385"
+dependencies = [
+ "crc32fast",
+ "hashbrown 0.13.2",
+ "indexmap",
+ "memchr",
+]
+
+[[package]]
+name = "oid-registry"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38e20717fa0541f39bd146692035c37bedfa532b3e5071b35761082407546b2a"
+dependencies = [
+ "asn1-rs 0.3.1",
+]
+
+[[package]]
+name = "oid-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bedf36ffb6ba96c2eb7144ef6270557b52e54b20c0a8e1eb2ff99a6c6959bff"
+dependencies = [
+ "asn1-rs 0.5.2",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
+[[package]]
+name = "opaque-debug"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+
+[[package]]
+name = "os_str_bytes"
+version = "6.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ceedf44fb00f2d1984b0bc98102627ce622e083e49a5bacdb3e514fa4238e267"
+
+[[package]]
+name = "output_vt100"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "628223faebab4e3e40667ee0b2336d34a5b960ff60ea743ddfdbcf7770bcfb66"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "p256"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51f44edd08f51e2ade572f141051021c5af22677e42b7dd28a88155151c33594"
+dependencies = [
+ "ecdsa 0.14.8",
+ "elliptic-curve 0.12.3",
+ "sha2 0.10.7",
+]
+
+[[package]]
+name = "p384"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfc8c5bf642dde52bb9e87c0ecd8ca5a76faac2eeed98dedb7c717997e1080aa"
+dependencies = [
+ "ecdsa 0.14.8",
+ "elliptic-curve 0.12.3",
+ "sha2 0.10.7",
+]
+
+[[package]]
+name = "pallet-alliance"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-collective",
+ "pallet-identity",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-core-hashing",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-asset-conversion"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-assets",
+ "pallet-balances",
+ "parity-scale-codec",
+ "primitive-types",
+ "scale-info",
+ "sp-api",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-asset-conversion-tx-payment"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "pallet-asset-conversion",
+ "pallet-assets",
+ "pallet-balances",
+ "pallet-transaction-payment",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-storage",
+]
+
+[[package]]
+name = "pallet-asset-rate"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-asset-tx-payment"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-assets",
+ "pallet-authorship",
+ "pallet-balances",
+ "pallet-transaction-payment",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "serde_json",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-storage",
+]
+
+[[package]]
+name = "pallet-assets"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-atomic-swap"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-aura"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-application-crypto",
+ "sp-consensus-aura",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-authority-discovery"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "pallet-session",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-application-crypto",
+ "sp-authority-discovery",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-authorship"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "impl-trait-for-tuples",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-babe"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-authorship",
+ "pallet-balances",
+ "pallet-offences",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-application-crypto",
+ "sp-consensus-babe",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-session",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-bags-list"
+version = "4.0.0-dev"
+dependencies = [
+ "aquamarine",
+ "docify",
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-tracing",
+]
+
+[[package]]
+name = "pallet-bags-list-fuzzer"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-election-provider-support",
+ "honggfuzz",
+ "pallet-bags-list",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "pallet-bags-list-remote-tests"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-remote-externalities",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-bags-list",
+ "pallet-staking",
+ "sp-core",
+ "sp-runtime",
+ "sp-std",
+ "sp-storage",
+ "sp-tracing",
+]
+
+[[package]]
+name = "pallet-balances"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-transaction-payment",
+ "parity-scale-codec",
+ "paste",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-beefy"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-authorship",
+ "pallet-balances",
+ "pallet-offences",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-consensus-beefy",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-session",
+ "sp-staking",
+ "sp-state-machine",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-beefy-mmr"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "binary-merkle-tree",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-beefy",
+ "pallet-mmr",
+ "pallet-session",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-consensus-beefy",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-state-machine",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-bounties"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-treasury",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-broker"
+version = "0.1.0"
+dependencies = [
+ "bitvec",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-child-bounties"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-bounties",
+ "pallet-treasury",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-collective"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-contracts"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "assert_matches",
+ "bitflags",
+ "env_logger 0.9.3",
+ "environmental",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "impl-trait-for-tuples",
+ "log",
+ "pallet-balances",
+ "pallet-contracts-primitives",
+ "pallet-contracts-proc-macro",
+ "pallet-insecure-randomness-collective-flip",
+ "pallet-proxy",
+ "pallet-timestamp",
+ "pallet-utility",
+ "parity-scale-codec",
+ "pretty_assertions",
+ "rand 0.8.5",
+ "rand_pcg",
+ "scale-info",
+ "serde",
+ "smallvec",
+ "sp-api",
+ "sp-core",
+ "sp-io",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-std",
+ "wasm-instrument 0.4.0",
+ "wasmi",
+ "wat",
+]
+
+[[package]]
+name = "pallet-contracts-primitives"
+version = "24.0.0"
+dependencies = [
+ "bitflags",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-runtime",
+ "sp-std",
+ "sp-weights",
+]
+
+[[package]]
+name = "pallet-contracts-proc-macro"
+version = "4.0.0-dev"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "pallet-conviction-voting"
+version = "4.0.0-dev"
+dependencies = [
+ "assert_matches",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-scheduler",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-core-fellowship"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-default-config-example"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-democracy"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-preimage",
+ "pallet-scheduler",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-dev-mode"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-election-provider-e2e-test"
+version = "1.0.0"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-bags-list",
+ "pallet-balances",
+ "pallet-election-provider-multi-phase",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-npos-elections",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+ "sp-tracing",
+]
+
+[[package]]
+name = "pallet-election-provider-multi-phase"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-election-provider-support-benchmarking",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-npos-elections",
+ "sp-runtime",
+ "sp-std",
+ "sp-tracing",
+ "strum",
+]
+
+[[package]]
+name = "pallet-election-provider-support-benchmarking"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-system",
+ "parity-scale-codec",
+ "sp-npos-elections",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-elections-phragmen"
+version = "5.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-npos-elections",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+ "sp-tracing",
+ "substrate-test-utils",
+]
+
+[[package]]
+name = "pallet-example-basic"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-example-kitchensink"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-example-offchain-worker"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "lite-json",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-example-split"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-examples"
+version = "4.0.0-dev"
+dependencies = [
+ "pallet-default-config-example",
+ "pallet-dev-mode",
+ "pallet-example-basic",
+ "pallet-example-kitchensink",
+ "pallet-example-offchain-worker",
+ "pallet-example-split",
+]
+
+[[package]]
+name = "pallet-fast-unstake"
+version = "4.0.0-dev"
+dependencies = [
+ "docify",
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+ "sp-tracing",
+ "substrate-test-utils",
+]
+
+[[package]]
+name = "pallet-glutton"
+version = "4.0.0-dev"
+dependencies = [
+ "blake2",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-grandpa"
+version = "4.0.0-dev"
+dependencies = [
+ "finality-grandpa",
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-authorship",
+ "pallet-balances",
+ "pallet-offences",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-application-crypto",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-io",
+ "sp-keyring",
+ "sp-runtime",
+ "sp-session",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-identity"
+version = "4.0.0-dev"
+dependencies = [
+ "enumflags2",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-im-online"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-authorship",
+ "pallet-session",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-indices"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-keyring",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-insecure-randomness-collective-flip"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "safe-mix",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-lottery"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-support-test",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-membership"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-message-queue"
+version = "7.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "rand_distr",
+ "scale-info",
+ "serde",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-tracing",
+ "sp-weights",
+]
+
+[[package]]
+name = "pallet-mmr"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "env_logger 0.9.3",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "itertools",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-mmr-primitives",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-multisig"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-nft-fractionalization"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-assets",
+ "pallet-balances",
+ "pallet-nfts",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-nfts"
+version = "4.0.0-dev"
+dependencies = [
+ "enumflags2",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-nfts-runtime-api"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "pallet-nfts",
+ "parity-scale-codec",
+ "sp-api",
+]
+
+[[package]]
+name = "pallet-nicks"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-nis"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-node-authorization"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-nomination-pools"
+version = "1.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+ "sp-tracing",
+]
+
+[[package]]
+name = "pallet-nomination-pools-benchmarking"
+version = "1.0.0"
+dependencies = [
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "pallet-bags-list",
+ "pallet-balances",
+ "pallet-nomination-pools",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-runtime-interface",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-nomination-pools-fuzzer"
+version = "2.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "honggfuzz",
+ "log",
+ "pallet-nomination-pools",
+ "rand 0.8.5",
+ "sp-io",
+ "sp-runtime",
+ "sp-tracing",
+]
+
+[[package]]
+name = "pallet-nomination-pools-runtime-api"
+version = "1.0.0-dev"
+dependencies = [
+ "pallet-nomination-pools",
+ "parity-scale-codec",
+ "sp-api",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-nomination-pools-test-staking"
+version = "1.0.0"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-bags-list",
+ "pallet-balances",
+ "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",
+ "sp-tracing",
+]
+
+[[package]]
+name = "pallet-offences"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-offences-benchmarking"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-babe",
+ "pallet-balances",
+ "pallet-grandpa",
+ "pallet-im-online",
+ "pallet-offences",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-paged-list"
+version = "0.1.0"
+dependencies = [
+ "docify",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-metadata-ir",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-paged-list-fuzzer"
+version = "0.1.0"
+dependencies = [
+ "arbitrary",
+ "frame-support",
+ "honggfuzz",
+ "pallet-paged-list",
+ "sp-io",
+]
+
+[[package]]
+name = "pallet-preimage"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-proxy"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-utility",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-ranked-collective"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-recovery"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-referenda"
+version = "4.0.0-dev"
+dependencies = [
+ "assert_matches",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-preimage",
+ "pallet-scheduler",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-remark"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-root-offences"
+version = "1.0.0-dev"
+dependencies = [
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-root-testing"
+version = "1.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-safe-mode"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-proxy",
+ "pallet-utility",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-salary"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-scheduler"
+version = "4.0.0-dev"
+dependencies = [
+ "docify",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-preimage",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-weights",
+ "substrate-test-utils",
+]
+
+[[package]]
+name = "pallet-scored-pool"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-session"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "impl-trait-for-tuples",
+ "log",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-session",
+ "sp-staking",
+ "sp-state-machine",
+ "sp-std",
+ "sp-trie",
+]
+
+[[package]]
+name = "pallet-session-benchmarking"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-session",
+ "pallet-staking",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-session",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-society"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-support-test",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "rand_chacha 0.2.2",
+ "scale-info",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-staking"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-election-provider-support",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-authorship",
+ "pallet-bags-list",
+ "pallet-balances",
+ "pallet-session",
+ "pallet-staking-reward-curve",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "rand_chacha 0.2.2",
+ "scale-info",
+ "serde",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-io",
+ "sp-npos-elections",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+ "sp-tracing",
+ "substrate-test-utils",
+]
+
+[[package]]
+name = "pallet-staking-reward-curve"
+version = "4.0.0-dev"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "sp-runtime",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "pallet-staking-reward-fn"
+version = "4.0.0-dev"
+dependencies = [
+ "log",
+ "sp-arithmetic",
+]
+
+[[package]]
+name = "pallet-staking-runtime-api"
+version = "4.0.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "sp-api",
+]
+
+[[package]]
+name = "pallet-state-trie-migration"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-remote-externalities",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-tracing",
+ "substrate-state-trie-migration-rpc",
+ "thousands",
+ "tokio",
+ "zstd 0.12.3+zstd.1.5.2",
+]
+
+[[package]]
+name = "pallet-statement"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-statement-store",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-sudo"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-template"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-timestamp"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-storage",
+ "sp-timestamp",
+]
+
+[[package]]
+name = "pallet-tips"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "pallet-treasury",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-storage",
+]
+
+[[package]]
+name = "pallet-transaction-payment"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "serde_json",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-transaction-payment-rpc"
+version = "4.0.0-dev"
+dependencies = [
+ "jsonrpsee",
+ "pallet-transaction-payment-rpc-runtime-api",
+ "parity-scale-codec",
+ "sp-api",
+ "sp-blockchain",
+ "sp-core",
+ "sp-rpc",
+ "sp-runtime",
+ "sp-weights",
+]
+
+[[package]]
+name = "pallet-transaction-payment-rpc-runtime-api"
+version = "4.0.0-dev"
+dependencies = [
+ "pallet-transaction-payment",
+ "parity-scale-codec",
+ "sp-api",
+ "sp-runtime",
+ "sp-weights",
+]
+
+[[package]]
+name = "pallet-transaction-storage"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-inherents",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+ "sp-transaction-storage-proof",
+]
+
+[[package]]
+name = "pallet-treasury"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "impl-trait-for-tuples",
+ "pallet-balances",
+ "pallet-utility",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-tx-pause"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-proxy",
+ "pallet-utility",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-uniques"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-utility"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-collective",
+ "pallet-root-testing",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-vesting"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "log",
+ "pallet-balances",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "pallet-whitelist"
+version = "4.0.0-dev"
+dependencies = [
+ "frame-benchmarking",
+ "frame-support",
+ "frame-system",
+ "pallet-balances",
+ "pallet-preimage",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "parity-db"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4890dcb9556136a4ec2b0c51fa4a08c8b733b829506af8fff2e853f3a065985b"
+dependencies = [
+ "blake2",
+ "crc32fast",
+ "fs2",
+ "hex",
+ "libc",
+ "log",
+ "lz4",
+ "memmap2",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "siphasher",
+ "snap",
+]
+
+[[package]]
+name = "parity-scale-codec"
+version = "3.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2287753623c76f953acd29d15d8100bcab84d29db78fb6f352adb3c53e83b967"
+dependencies = [
+ "arrayvec 0.7.2",
+ "bitvec",
+ "byte-slice-cast",
+ "bytes",
+ "impl-trait-for-tuples",
+ "parity-scale-codec-derive",
+ "serde",
+]
+
+[[package]]
+name = "parity-scale-codec-derive"
+version = "3.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b6937b5e67bfba3351b87b040d48352a2fcb6ad72f81855412ce97b45c8f110"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "parity-send-wrapper"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9777aa91b8ad9dd5aaa04a9b6bcb02c7f1deb952fca5a66034d5e63afc5c6f"
+
+[[package]]
+name = "parity-wasm"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304"
+
+[[package]]
+name = "parking"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14f2252c834a40ed9bb5422029649578e63aa341ac401f74e719dd1afda8394e"
+
+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core 0.8.6",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api",
+ "parking_lot_core 0.9.8",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall 0.2.16",
+ "smallvec",
+ "winapi",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.3.5",
+ "smallvec",
+ "windows-targets 0.48.0",
+]
+
+[[package]]
+name = "partial_sort"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7924d1d0ad836f665c9065e26d016c673ece3993f30d340068b16f282afc1156"
+
+[[package]]
+name = "paste"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f746c4065a8fa3fe23974dd82f15431cc8d40779821001404d10d2e79ca7d79"
+
+[[package]]
+name = "pbkdf2"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d95f5254224e617595d2cc3cc73ff0a5eaf2637519e25f03388154e9378b6ffa"
+dependencies = [
+ "crypto-mac 0.11.1",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "peeking_take_while"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
+
+[[package]]
+name = "pem"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8835c273a76a90455d7344889b0964598e3316e2a79ede8e36f16bdcf2228b8"
+dependencies = [
+ "base64 0.13.1",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d159833a9105500e0398934e205e0773f0b27529557134ecfc51c27646adac"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
+
+[[package]]
+name = "pest"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e68e84bfb01f0507134eac1e9b410a12ba379d064eab48c50ba4ce329a527b70"
+dependencies = [
+ "thiserror",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b79d4c71c865a25a4322296122e3924d30bc8ee0834c8bfc8b95f7f054afbfb"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c435bf1076437b851ebc8edc3a18442796b30f1728ffea6262d59bbe28b077e"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "745a452f8eb71e39ffd8ee32b3c5f51d03845f99786fa9b68db6ff509c505411"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2 0.10.7",
+]
+
+[[package]]
+name = "petgraph"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dd7d28ee937e54fe3080c91faa1c3a46c06de6252988a7f4592ba2310ef22a4"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c95a7476719eab1e366eaf73d0260af3021184f18177925b07f54b30089ceead"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39407670928234ebc5e6e580247dd567ad73a3578460c5990f9503df207e8f07"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "257b64915a082f7811703966789728173279bdebb956b143dbcd23f6f970a777"
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkcs8"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9eca2c590a5f85da82668fa685c09ce2888b9430e83299debf1f34b65fd4a4ba"
+dependencies = [
+ "der 0.6.1",
+ "spki 0.6.0",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der 0.7.6",
+ "spki 0.7.2",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
+
+[[package]]
+name = "platforms"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d7ddaed09e0eb771a79ab0fd64609ba0afb0a8366421957936ad14cbd13630"
+
+[[package]]
+name = "plotters"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "polling"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b2d323e8ca7996b3e23126511a523f7e62924d93ecd5ae73b333815b0eb3dce"
+dependencies = [
+ "autocfg",
+ "bitflags",
+ "cfg-if",
+ "concurrent-queue",
+ "libc",
+ "log",
+ "pin-project-lite 0.2.9",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "poly1305"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "048aeb476be11a4b6ca432ca569e375810de9294ae78f4774e78ea98a9246ede"
+dependencies = [
+ "cpufeatures",
+ "opaque-debug 0.3.0",
+ "universal-hash 0.4.1",
+]
+
+[[package]]
+name = "polyval"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8419d2b623c7c0896ff2d5d96e2cb4ede590fed28fcc34934f4c33c036e620a1"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "opaque-debug 0.3.0",
+ "universal-hash 0.4.1",
+]
+
+[[package]]
+name = "polyval"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ef234e08c11dfcb2e56f79fd70f6f2eb7f025c0ce2333e82f4f0518ecad30c6"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "opaque-debug 0.3.0",
+ "universal-hash 0.5.1",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "767eb9f07d4a5ebcb39bbf2d452058a93c011373abf6832e24194a1c3f004794"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "predicates"
+version = "2.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
+dependencies = [
+ "difflib",
+ "float-cmp",
+ "itertools",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09963355b9f467184c04017ced4a2ba2d75cbcb4e7462690d388233253d4b1a9"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "itertools",
+ "predicates-core",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "pretty_assertions"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a25e9bcb20aa780fd0bb16b72403a9064d6b3f22f026946029acb941a50af755"
+dependencies = [
+ "ctor",
+ "diff",
+ "output_vt100",
+ "yansi",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86"
+dependencies = [
+ "proc-macro2",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b69d39aab54d069e7f2fe8cb970493e7834601ca2d8c65fd7bbd183578080d1"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "primitive-types"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f3486ccba82358b11a77516035647c34ba167dfa53312630de83b12bd4f3d66"
+dependencies = [
+ "fixed-hash",
+ "impl-codec",
+ "impl-num-traits",
+ "impl-serde",
+ "scale-info",
+ "uint",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e17d47ce914bf4de440332250b0edd23ce48c005f59fab39d3335866b114f11a"
+dependencies = [
+ "thiserror",
+ "toml 0.5.11",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.20+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
+
+[[package]]
+name = "proc-macro-warning"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70550716265d1ec349c41f70dd4f964b4fd88394efe4405f0c1da679c4799a07"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dec2b086b7a862cf4de201096214fa870344cf922b2b30c167badb3af3195406"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prometheus"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "449811d15fbdf5ceb5c1144416066429cf82316e2ec8ce0c1f6f8a02e7bbcf8c"
+dependencies = [
+ "cfg-if",
+ "fnv",
+ "lazy_static",
+ "memchr",
+ "parking_lot 0.12.1",
+ "thiserror",
+]
+
+[[package]]
+name = "prometheus-client"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d6fa99d535dd930d1249e6c79cb3c2915f9172a540fe2b02a4c8f9ca954721e"
+dependencies = [
+ "dtoa",
+ "itoa",
+ "parking_lot 0.12.1",
+ "prometheus-client-derive-encode",
+]
+
+[[package]]
+name = "prometheus-client-derive-encode"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b6a5217beb0ad503ee7fa752d451c905113d70721b937126158f3106a48cc1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "prost"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
+dependencies = [
+ "bytes",
+ "prost-derive",
+]
+
+[[package]]
+name = "prost-build"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "119533552c9a7ffacc21e099c24a0ac8bb19c2a2a3f363de84cd9b844feab270"
+dependencies = [
+ "bytes",
+ "heck",
+ "itertools",
+ "lazy_static",
+ "log",
+ "multimap",
+ "petgraph",
+ "prettyplease 0.1.25",
+ "prost",
+ "prost-types",
+ "regex",
+ "syn 1.0.109",
+ "tempfile",
+ "which",
+]
+
+[[package]]
+name = "prost-derive"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4"
+dependencies = [
+ "anyhow",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13"
+dependencies = [
+ "prost",
+]
+
+[[package]]
+name = "psm"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quick-protobuf"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d6da84cc204722a989e01ba2f6e1e276e190f22263d0cb6ce8526fcdb0d2e1f"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "quick-protobuf-codec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1693116345026436eb2f10b677806169c1a1260c1c60eaaffe3fb5a29ae23d8b"
+dependencies = [
+ "asynchronous-codec",
+ "bytes",
+ "quick-protobuf",
+ "thiserror",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "quickcheck"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
+dependencies = [
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "quicksink"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77de3c815e5a160b1539c6592796801df2043ae35e123b46d73380cfa57af858"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite 0.1.12",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c10f662eee9c94ddd7135043e544f3c82fa839a1e7b865911331961b53186c"
+dependencies = [
+ "bytes",
+ "rand 0.8.5",
+ "ring 0.16.20",
+ "rustc-hash",
+ "rustls 0.20.8",
+ "slab",
+ "thiserror",
+ "tinyvec",
+ "tracing",
+ "webpki 0.22.0",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ab9c7eadfd8df19006f1cf1a4aed13540ed5cbc047010ece5826e10825488"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom 0.1.16",
+ "libc",
+ "rand_chacha 0.2.2",
+ "rand_core 0.5.1",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom 0.1.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.9",
+]
+
+[[package]]
+name = "rand_distr"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31"
+dependencies = [
+ "num-traits",
+ "rand 0.8.5",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rand_pcg"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "rayon"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-deque",
+ "crossbeam-utils",
+ "num_cpus",
+]
+
+[[package]]
+name = "rcgen"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6413f3de1edee53342e6138e75b56d32e7bc6e332b3bd62d497b1929d4cfbcdd"
+dependencies = [
+ "pem",
+ "ring 0.16.20",
+ "time 0.3.21",
+ "x509-parser 0.13.2",
+ "yasna",
+]
+
+[[package]]
+name = "rcgen"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffbe84efe2f38dea12e9bfc1f65377fdf03e53a18cb3b995faedf7934c7e785b"
+dependencies = [
+ "pem",
+ "ring 0.16.20",
+ "time 0.3.21",
+ "yasna",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
+dependencies = [
+ "getrandom 0.2.9",
+ "redox_syscall 0.2.16",
+ "thiserror",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f43faa91b1c8b36841ee70e97188a869d37ae21759da6846d4be66de5bf7b12c"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d2275aab483050ab2a7364c1a46604865ee7d6906684e08db0f090acf74f9e7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "regalloc2"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80535183cae11b149d618fbd3c37e38d7cda589d82d7769e196ca9a9042d7621"
+dependencies = [
+ "fxhash",
+ "log",
+ "slice-group-by",
+ "smallvec",
+]
+
+[[package]]
+name = "regex"
+version = "1.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0ab3ca65655bb1e41f2a8c8cd662eb4fb035e67c3f78da1d61dffe89d07300f"
+dependencies = [
+ "aho-corasick 1.0.2",
+ "memchr",
+ "regex-syntax 0.7.2",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "regex-syntax"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436b050e76ed2903236f032a59761c1eb99e1b0aead2c257922771dab1fc8c78"
+
+[[package]]
+name = "resolv-conf"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52e44394d2086d010551b14b53b1f24e31647570cd1deb0379e2c21b329aba00"
+dependencies = [
+ "hostname",
+ "quick-error",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7743f17af12fa0b03b803ba12cd6a8d9483a587e89c69445e3909655c0b9fabb"
+dependencies = [
+ "crypto-bigint 0.4.9",
+ "hmac 0.12.1",
+ "zeroize",
+]
+
+[[package]]
+name = "rfc6979"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
+dependencies = [
+ "hmac 0.12.1",
+ "subtle",
+]
+
+[[package]]
+name = "ring"
+version = "0.1.0"
+source = "git+https://github.com/w3f/ring-proof#0e948f3c28cbacecdd3020403c4841c0eb339213"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-poly",
+ "ark-serialize",
+ "ark-std",
+ "common",
+ "fflonk",
+ "merlin 3.0.0",
+]
+
+[[package]]
+name = "ring"
+version = "0.16.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+dependencies = [
+ "cc",
+ "libc",
+ "once_cell",
+ "spin 0.5.2",
+ "untrusted",
+ "web-sys",
+ "winapi",
+]
+
+[[package]]
+name = "rocksdb"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb6f170a4041d50a0ce04b0d2e14916d6ca863ea2e422689a5b694395d299ffe"
+dependencies = [
+ "libc",
+ "librocksdb-sys",
+]
+
+[[package]]
+name = "rpassword"
+version = "7.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6678cf63ab3491898c0d021b493c94c9b221d91295294a2a5746eacbe5928322"
+dependencies = [
+ "libc",
+ "rtoolbox",
+ "winapi",
+]
+
+[[package]]
+name = "rtcp"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1919efd6d4a6a85d13388f9487549bb8e359f17198cc03ffd72f79b553873691"
+dependencies = [
+ "bytes",
+ "thiserror",
+ "webrtc-util",
+]
+
+[[package]]
+name = "rtnetlink"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "322c53fd76a18698f1c27381d58091de3a043d356aa5bd0d510608b565f469a0"
+dependencies = [
+ "futures",
+ "log",
+ "netlink-packet-route",
+ "netlink-proto",
+ "nix 0.24.3",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "rtoolbox"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "034e22c514f5c0cb8a10ff341b9b048b5ceb21591f31c8f44c43b960f9b3524a"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "rtp"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2a095411ff00eed7b12e4c6a118ba984d113e1079582570d56a5ee723f11f80"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "rand 0.8.5",
+ "serde",
+ "thiserror",
+ "webrtc-util",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "rustc-hex"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
+
+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+dependencies = [
+ "semver 0.9.0",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver 1.0.17",
+]
+
+[[package]]
+name = "rusticata-macros"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "rustix"
+version = "0.36.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14e4d67015953998ad0eb82887a0eb0129e18a7e2f3b7b0f6c422fddcd503d62"
+dependencies = [
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys 0.1.4",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "rustix"
+version = "0.37.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acf8729d8542766f1b2cf77eb034d52f40d375bb8b615d0b147089946e16613d"
+dependencies = [
+ "bitflags",
+ "errno",
+ "io-lifetimes",
+ "libc",
+ "linux-raw-sys 0.3.8",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "rustls"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35edb675feee39aec9c99fa5ff985081995a06d594114ae14cbe797ad7b7a6d7"
+dependencies = [
+ "base64 0.13.1",
+ "log",
+ "ring 0.16.20",
+ "sct 0.6.1",
+ "webpki 0.21.4",
+]
+
+[[package]]
+name = "rustls"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f"
+dependencies = [
+ "log",
+ "ring 0.16.20",
+ "sct 0.7.0",
+ "webpki 0.22.0",
+]
+
+[[package]]
+name = "rustls"
+version = "0.21.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1feddffcfcc0b33f5c6ce9a29e341e4cd59c3f78e7ee45f4a40c038b1d6cbb"
+dependencies = [
+ "log",
+ "ring 0.16.20",
+ "rustls-webpki 0.101.4",
+ "sct 0.7.0",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0167bac7a9f490495f3c33013e7722b53cb087ecbe082fb0c6387c96f634ea50"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d194b56d58803a43635bdc398cd17e383d6f71f9182b9a192c127ca42494a59b"
+dependencies = [
+ "base64 0.21.2",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.100.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e98ff011474fa39949b7e5c0428f9b4937eda7da7848bbb947786b7be0b27dab"
+dependencies = [
+ "ring 0.16.20",
+ "untrusted",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d93931baf2d282fff8d3a532bbfd7653f734643161b87e3e01e59a04439bf0d"
+dependencies = [
+ "ring 0.16.20",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f3208ce4d8448b3f3e7d168a73f5e0c43a61e32930de3bceeccedb388b6bf06"
+
+[[package]]
+name = "rusty-fork"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+]
+
+[[package]]
+name = "rw-stream-sink"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26338f5e09bb721b85b135ea05af7767c90b52f6de4f087d4f4a3a9d64e7dc04"
+dependencies = [
+ "futures",
+ "pin-project",
+ "static_assertions",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "safe-mix"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d3d055a2582e6b00ed7a31c1524040aa391092bf636328350813f3a0605215c"
+dependencies = [
+ "rustc_version 0.2.3",
+]
+
+[[package]]
+name = "safe_arch"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "794821e4ccb0d9f979512f9c1973480123f9bd62a90d74ab0f9426fcf8f4a529"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "sc-allocator"
+version = "4.1.0-dev"
+dependencies = [
+ "log",
+ "sp-core",
+ "sp-wasm-interface",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-authority-discovery"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "ip_network",
+ "libp2p",
+ "log",
+ "multihash",
+ "parity-scale-codec",
+ "prost",
+ "prost-build",
+ "quickcheck",
+ "rand 0.8.5",
+ "sc-client-api",
+ "sc-network",
+ "sp-api",
+ "sp-authority-discovery",
+ "sp-blockchain",
+ "sp-core",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-tracing",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-basic-authorship"
+version = "0.10.0-dev"
+dependencies = [
+ "futures",
+ "futures-timer",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-proposer-metrics",
+ "sc-telemetry",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+]
+
+[[package]]
+name = "sc-block-builder"
+version = "0.10.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "sc-client-api",
+ "sp-api",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-state-machine",
+ "substrate-test-runtime-client",
+]
+
+[[package]]
+name = "sc-chain-spec"
+version = "4.0.0-dev"
+dependencies = [
+ "memmap2",
+ "sc-chain-spec-derive",
+ "sc-client-api",
+ "sc-executor",
+ "sc-network",
+ "sc-telemetry",
+ "serde",
+ "serde_json",
+ "sp-blockchain",
+ "sp-core",
+ "sp-runtime",
+ "sp-state-machine",
+]
+
+[[package]]
+name = "sc-chain-spec-derive"
+version = "4.0.0-dev"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "sc-cli"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "chrono",
+ "clap 4.3.2",
+ "fdlimit",
+ "futures",
+ "futures-timer",
+ "libp2p-identity",
+ "log",
+ "names",
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "regex",
+ "rpassword",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-keystore",
+ "sc-network",
+ "sc-service",
+ "sc-telemetry",
+ "sc-tracing",
+ "sc-utils",
+ "serde",
+ "serde_json",
+ "sp-blockchain",
+ "sp-core",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-panic-handler",
+ "sp-runtime",
+ "sp-tracing",
+ "sp-version",
+ "tempfile",
+ "thiserror",
+ "tiny-bip39",
+ "tokio",
+]
+
+[[package]]
+name = "sc-client-api"
+version = "4.0.0-dev"
+dependencies = [
+ "fnv",
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-executor",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-database",
+ "sp-externalities",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-statement-store",
+ "sp-storage",
+ "sp-test-primitives",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-client-db"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "criterion",
+ "hash-db",
+ "kitchensink-runtime",
+ "kvdb",
+ "kvdb-memorydb",
+ "kvdb-rocksdb",
+ "linked-hash-map",
+ "log",
+ "parity-db",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "quickcheck",
+ "rand 0.8.5",
+ "sc-client-api",
+ "sc-state-db",
+ "schnellru",
+ "sp-arithmetic",
+ "sp-blockchain",
+ "sp-core",
+ "sp-database",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-tracing",
+ "sp-trie",
+ "substrate-test-runtime-client",
+ "tempfile",
+]
+
+[[package]]
+name = "sc-consensus"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "libp2p-identity",
+ "log",
+ "mockall",
+ "parking_lot 0.12.1",
+ "sc-client-api",
+ "sc-utils",
+ "serde",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-test-primitives",
+ "substrate-prometheus-endpoint",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-consensus-aura"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-consensus-slots",
+ "sc-keystore",
+ "sc-network",
+ "sc-network-test",
+ "sc-telemetry",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-aura",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-inherents",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-timestamp",
+ "sp-tracing",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "tempfile",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-consensus-babe"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "fork-tree",
+ "futures",
+ "log",
+ "num-bigint",
+ "num-rational",
+ "num-traits",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "rand_chacha 0.2.2",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-consensus-epochs",
+ "sc-consensus-slots",
+ "sc-network",
+ "sc-network-test",
+ "sc-telemetry",
+ "sc-transaction-pool-api",
+ "scale-info",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-babe",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-inherents",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-timestamp",
+ "sp-tracing",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-consensus-babe-rpc"
+version = "0.10.0-dev"
+dependencies = [
+ "futures",
+ "jsonrpsee",
+ "sc-consensus",
+ "sc-consensus-babe",
+ "sc-consensus-epochs",
+ "sc-keystore",
+ "sc-rpc-api",
+ "sc-transaction-pool-api",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-babe",
+ "sp-core",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-runtime",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-consensus-beefy"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "async-channel",
+ "async-trait",
+ "fnv",
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-network",
+ "sc-network-gossip",
+ "sc-network-sync",
+ "sc-network-test",
+ "sc-utils",
+ "serde",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-arithmetic",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-beefy",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-mmr-primitives",
+ "sp-runtime",
+ "sp-tracing",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "tempfile",
+ "thiserror",
+ "tokio",
+ "wasm-timer",
+]
+
+[[package]]
+name = "sc-consensus-beefy-rpc"
+version = "4.0.0-dev"
+dependencies = [
+ "futures",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-consensus-beefy",
+ "sc-rpc",
+ "serde",
+ "serde_json",
+ "sp-consensus-beefy",
+ "sp-core",
+ "sp-runtime",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-consensus-epochs"
+version = "0.10.0-dev"
+dependencies = [
+ "fork-tree",
+ "parity-scale-codec",
+ "sc-client-api",
+ "sc-consensus",
+ "sp-blockchain",
+ "sp-runtime",
+]
+
+[[package]]
+name = "sc-consensus-grandpa"
+version = "0.10.0-dev"
+dependencies = [
+ "ahash 0.8.3",
+ "array-bytes",
+ "assert_matches",
+ "async-trait",
+ "dyn-clone",
+ "finality-grandpa",
+ "fork-tree",
+ "futures",
+ "futures-timer",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "sc-block-builder",
+ "sc-chain-spec",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-network",
+ "sc-network-common",
+ "sc-network-gossip",
+ "sc-network-test",
+ "sc-telemetry",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-arithmetic",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-tracing",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-consensus-grandpa-rpc"
+version = "0.10.0-dev"
+dependencies = [
+ "finality-grandpa",
+ "futures",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus-grandpa",
+ "sc-rpc",
+ "serde",
+ "sp-blockchain",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-keyring",
+ "sp-runtime",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-consensus-manual-seal"
+version = "0.10.0-dev"
+dependencies = [
+ "assert_matches",
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "sc-basic-authorship",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-consensus-aura",
+ "sc-consensus-babe",
+ "sc-consensus-epochs",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "serde",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-aura",
+ "sp-consensus-babe",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-inherents",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-timestamp",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "substrate-test-runtime-transaction-pool",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-consensus-pow"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-client-api",
+ "sc-consensus",
+ "sp-api",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-pow",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "substrate-prometheus-endpoint",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-consensus-slots"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "log",
+ "parity-scale-codec",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-telemetry",
+ "sp-arithmetic",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-state-machine",
+ "substrate-test-runtime-client",
+]
+
+[[package]]
+name = "sc-executor"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "assert_matches",
+ "criterion",
+ "env_logger 0.9.3",
+ "num_cpus",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "paste",
+ "regex",
+ "sc-executor-common",
+ "sc-executor-wasmtime",
+ "sc-runtime-test",
+ "sc-tracing",
+ "schnellru",
+ "sp-api",
+ "sp-core",
+ "sp-externalities",
+ "sp-io",
+ "sp-maybe-compressed-blob",
+ "sp-panic-handler",
+ "sp-runtime",
+ "sp-runtime-interface",
+ "sp-state-machine",
+ "sp-tracing",
+ "sp-trie",
+ "sp-version",
+ "sp-wasm-interface",
+ "substrate-test-runtime",
+ "tempfile",
+ "tracing",
+ "tracing-subscriber",
+ "wat",
+]
+
+[[package]]
+name = "sc-executor-common"
+version = "0.10.0-dev"
+dependencies = [
+ "sc-allocator",
+ "sp-maybe-compressed-blob",
+ "sp-wasm-interface",
+ "thiserror",
+ "wasm-instrument 0.3.0",
+]
+
+[[package]]
+name = "sc-executor-wasmtime"
+version = "0.10.0-dev"
+dependencies = [
+ "anyhow",
+ "cargo_metadata",
+ "cfg-if",
+ "libc",
+ "log",
+ "parity-scale-codec",
+ "paste",
+ "rustix 0.36.14",
+ "sc-allocator",
+ "sc-executor-common",
+ "sc-runtime-test",
+ "sp-io",
+ "sp-runtime-interface",
+ "sp-wasm-interface",
+ "tempfile",
+ "wasmtime",
+ "wat",
+]
+
+[[package]]
+name = "sc-informant"
+version = "0.10.0-dev"
+dependencies = [
+ "ansi_term",
+ "futures",
+ "futures-timer",
+ "log",
+ "sc-client-api",
+ "sc-network",
+ "sc-network-common",
+ "sp-blockchain",
+ "sp-runtime",
+]
+
+[[package]]
+name = "sc-keystore"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "parking_lot 0.12.1",
+ "serde_json",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-keystore",
+ "tempfile",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-network"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "assert_matches",
+ "async-channel",
+ "async-trait",
+ "asynchronous-codec",
+ "bytes",
+ "either",
+ "fnv",
+ "futures",
+ "futures-timer",
+ "ip_network",
+ "libp2p",
+ "linked_hash_set",
+ "log",
+ "mockall",
+ "multistream-select",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "partial_sort",
+ "pin-project",
+ "rand 0.8.5",
+ "sc-client-api",
+ "sc-network-common",
+ "sc-network-light",
+ "sc-network-sync",
+ "sc-utils",
+ "serde",
+ "serde_json",
+ "smallvec",
+ "sp-arithmetic",
+ "sp-blockchain",
+ "sp-core",
+ "sp-runtime",
+ "sp-test-primitives",
+ "sp-tracing",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime",
+ "substrate-test-runtime-client",
+ "tempfile",
+ "thiserror",
+ "tokio",
+ "tokio-test",
+ "tokio-util",
+ "unsigned-varint",
+ "wasm-timer",
+ "zeroize",
+]
+
+[[package]]
+name = "sc-network-bitswap"
+version = "0.10.0-dev"
+dependencies = [
+ "async-channel",
+ "cid",
+ "futures",
+ "libp2p-identity",
+ "log",
+ "prost",
+ "prost-build",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-network",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-runtime",
+ "substrate-test-runtime",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+ "unsigned-varint",
+]
+
+[[package]]
+name = "sc-network-common"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "bitflags",
+ "futures",
+ "libp2p-identity",
+ "parity-scale-codec",
+ "prost-build",
+ "sc-consensus",
+ "sp-consensus",
+ "sp-consensus-grandpa",
+ "sp-runtime",
+ "tempfile",
+]
+
+[[package]]
+name = "sc-network-gossip"
+version = "0.10.0-dev"
+dependencies = [
+ "ahash 0.8.3",
+ "futures",
+ "futures-timer",
+ "libp2p",
+ "log",
+ "quickcheck",
+ "sc-network",
+ "sc-network-common",
+ "schnellru",
+ "sp-runtime",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "sc-network-light"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "async-channel",
+ "futures",
+ "libp2p-identity",
+ "log",
+ "parity-scale-codec",
+ "prost",
+ "prost-build",
+ "sc-client-api",
+ "sc-network",
+ "sp-blockchain",
+ "sp-core",
+ "sp-runtime",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-network-statement"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "async-channel",
+ "futures",
+ "libp2p",
+ "log",
+ "parity-scale-codec",
+ "sc-network",
+ "sc-network-common",
+ "sp-consensus",
+ "sp-statement-store",
+ "substrate-prometheus-endpoint",
+]
+
+[[package]]
+name = "sc-network-sync"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "async-channel",
+ "async-trait",
+ "fork-tree",
+ "futures",
+ "futures-timer",
+ "libp2p",
+ "log",
+ "mockall",
+ "parity-scale-codec",
+ "prost",
+ "prost-build",
+ "quickcheck",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-network",
+ "sc-network-common",
+ "sc-utils",
+ "schnellru",
+ "smallvec",
+ "sp-arithmetic",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-runtime",
+ "sp-test-primitives",
+ "sp-tracing",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-network-test"
+version = "0.8.0"
+dependencies = [
+ "async-trait",
+ "futures",
+ "futures-timer",
+ "libp2p",
+ "log",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus",
+ "sc-network",
+ "sc-network-common",
+ "sc-network-light",
+ "sc-network-sync",
+ "sc-service",
+ "sc-utils",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-runtime",
+ "sp-tracing",
+ "substrate-test-runtime",
+ "substrate-test-runtime-client",
+ "tokio",
+]
+
+[[package]]
+name = "sc-network-transactions"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "futures",
+ "libp2p",
+ "log",
+ "parity-scale-codec",
+ "sc-network",
+ "sc-network-common",
+ "sc-utils",
+ "sp-consensus",
+ "sp-runtime",
+ "substrate-prometheus-endpoint",
+]
+
+[[package]]
+name = "sc-offchain"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "bytes",
+ "fnv",
+ "futures",
+ "futures-timer",
+ "hyper",
+ "hyper-rustls",
+ "lazy_static",
+ "libp2p",
+ "log",
+ "num_cpus",
+ "once_cell",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-network",
+ "sc-network-common",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "sp-api",
+ "sp-consensus",
+ "sp-core",
+ "sp-externalities",
+ "sp-keystore",
+ "sp-offchain",
+ "sp-runtime",
+ "sp-tracing",
+ "substrate-test-runtime-client",
+ "threadpool",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "sc-proposer-metrics"
+version = "0.10.0-dev"
+dependencies = [
+ "log",
+ "substrate-prometheus-endpoint",
+]
+
+[[package]]
+name = "sc-rpc"
+version = "4.0.0-dev"
+dependencies = [
+ "assert_matches",
+ "env_logger 0.9.3",
+ "futures",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "pretty_assertions",
+ "sc-block-builder",
+ "sc-chain-spec",
+ "sc-client-api",
+ "sc-network",
+ "sc-network-common",
+ "sc-rpc-api",
+ "sc-tracing",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "serde_json",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-io",
+ "sp-keystore",
+ "sp-offchain",
+ "sp-rpc",
+ "sp-runtime",
+ "sp-session",
+ "sp-statement-store",
+ "sp-version",
+ "substrate-test-runtime-client",
+ "tokio",
+]
+
+[[package]]
+name = "sc-rpc-api"
+version = "0.10.0-dev"
+dependencies = [
+ "jsonrpsee",
+ "parity-scale-codec",
+ "sc-chain-spec",
+ "sc-transaction-pool-api",
+ "scale-info",
+ "serde",
+ "serde_json",
+ "sp-core",
+ "sp-rpc",
+ "sp-runtime",
+ "sp-version",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-rpc-server"
+version = "4.0.0-dev"
+dependencies = [
+ "http",
+ "jsonrpsee",
+ "log",
+ "serde_json",
+ "substrate-prometheus-endpoint",
+ "tokio",
+ "tower",
+ "tower-http",
+]
+
+[[package]]
+name = "sc-rpc-spec-v2"
+version = "0.10.0-dev"
+dependencies = [
+ "array-bytes",
+ "assert_matches",
+ "futures",
+ "futures-util",
+ "hex",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "pretty_assertions",
+ "sc-block-builder",
+ "sc-chain-spec",
+ "sc-client-api",
+ "sc-service",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-maybe-compressed-blob",
+ "sp-runtime",
+ "sp-version",
+ "substrate-test-runtime",
+ "substrate-test-runtime-client",
+ "thiserror",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "sc-runtime-test"
+version = "2.0.0"
+dependencies = [
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-runtime-interface",
+ "sp-std",
+ "substrate-wasm-builder",
+]
+
+[[package]]
+name = "sc-service"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "directories",
+ "exit-future",
+ "futures",
+ "futures-timer",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "pin-project",
+ "rand 0.8.5",
+ "sc-block-builder",
+ "sc-chain-spec",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-consensus",
+ "sc-executor",
+ "sc-informant",
+ "sc-keystore",
+ "sc-network",
+ "sc-network-bitswap",
+ "sc-network-common",
+ "sc-network-light",
+ "sc-network-sync",
+ "sc-network-transactions",
+ "sc-rpc",
+ "sc-rpc-server",
+ "sc-rpc-spec-v2",
+ "sc-sysinfo",
+ "sc-telemetry",
+ "sc-tracing",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-externalities",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-session",
+ "sp-state-machine",
+ "sp-storage",
+ "sp-transaction-pool",
+ "sp-transaction-storage-proof",
+ "sp-trie",
+ "sp-version",
+ "static_init",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime",
+ "substrate-test-runtime-client",
+ "tempfile",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "tracing-futures",
+]
+
+[[package]]
+name = "sc-service-test"
+version = "2.0.0"
+dependencies = [
+ "array-bytes",
+ "async-channel",
+ "fdlimit",
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-consensus",
+ "sc-executor",
+ "sc-network",
+ "sc-network-sync",
+ "sc-service",
+ "sc-transaction-pool-api",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-storage",
+ "sp-tracing",
+ "sp-trie",
+ "substrate-test-runtime",
+ "substrate-test-runtime-client",
+ "tempfile",
+ "tokio",
+]
+
+[[package]]
+name = "sc-state-db"
+version = "0.10.0-dev"
+dependencies = [
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sp-core",
+]
+
+[[package]]
+name = "sc-statement-store"
+version = "4.0.0-dev"
+dependencies = [
+ "env_logger 0.9.3",
+ "log",
+ "parity-db",
+ "parking_lot 0.12.1",
+ "sc-client-api",
+ "sc-keystore",
+ "sp-api",
+ "sp-blockchain",
+ "sp-core",
+ "sp-runtime",
+ "sp-statement-store",
+ "substrate-prometheus-endpoint",
+ "tempfile",
+ "tokio",
+]
+
+[[package]]
+name = "sc-storage-monitor"
+version = "0.1.0"
+dependencies = [
+ "clap 4.3.2",
+ "fs4",
+ "log",
+ "sc-client-db",
+ "sp-core",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "sc-sync-state-rpc"
+version = "0.10.0-dev"
+dependencies = [
+ "jsonrpsee",
+ "parity-scale-codec",
+ "sc-chain-spec",
+ "sc-client-api",
+ "sc-consensus-babe",
+ "sc-consensus-epochs",
+ "sc-consensus-grandpa",
+ "serde",
+ "serde_json",
+ "sp-blockchain",
+ "sp-runtime",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-sysinfo"
+version = "6.0.0-dev"
+dependencies = [
+ "futures",
+ "libc",
+ "log",
+ "rand 0.8.5",
+ "rand_pcg",
+ "regex",
+ "sc-telemetry",
+ "serde",
+ "serde_json",
+ "sp-core",
+ "sp-io",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sc-telemetry"
+version = "4.0.0-dev"
+dependencies = [
+ "chrono",
+ "futures",
+ "libp2p",
+ "log",
+ "parking_lot 0.12.1",
+ "pin-project",
+ "rand 0.8.5",
+ "sc-utils",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "wasm-timer",
+]
+
+[[package]]
+name = "sc-tracing"
+version = "4.0.0-dev"
+dependencies = [
+ "ansi_term",
+ "atty",
+ "chrono",
+ "criterion",
+ "lazy_static",
+ "libc",
+ "log",
+ "parking_lot 0.12.1",
+ "regex",
+ "rustc-hash",
+ "sc-client-api",
+ "sc-tracing-proc-macro",
+ "serde",
+ "sp-api",
+ "sp-blockchain",
+ "sp-core",
+ "sp-rpc",
+ "sp-runtime",
+ "sp-tracing",
+ "thiserror",
+ "tracing",
+ "tracing-log",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "sc-tracing-proc-macro"
+version = "4.0.0-dev"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "sc-transaction-pool"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "assert_matches",
+ "async-trait",
+ "criterion",
+ "futures",
+ "futures-timer",
+ "linked-hash-map",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-transaction-pool-api",
+ "sc-utils",
+ "serde",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-runtime",
+ "sp-tracing",
+ "sp-transaction-pool",
+ "substrate-prometheus-endpoint",
+ "substrate-test-runtime",
+ "substrate-test-runtime-client",
+ "substrate-test-runtime-transaction-pool",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-transaction-pool-api"
+version = "4.0.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "serde",
+ "serde_json",
+ "sp-blockchain",
+ "sp-core",
+ "sp-runtime",
+ "thiserror",
+]
+
+[[package]]
+name = "sc-utils"
+version = "4.0.0-dev"
+dependencies = [
+ "async-channel",
+ "futures",
+ "futures-timer",
+ "lazy_static",
+ "log",
+ "parking_lot 0.12.1",
+ "prometheus",
+ "sp-arithmetic",
+ "tokio-test",
+]
+
+[[package]]
+name = "scale-info"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b569c32c806ec3abdf3b5869fb8bf1e0d275a7c1c9b0b05603d9464632649edf"
+dependencies = [
+ "bitvec",
+ "cfg-if",
+ "derive_more",
+ "parity-scale-codec",
+ "scale-info-derive",
+ "serde",
+]
+
+[[package]]
+name = "scale-info-derive"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53012eae69e5aa5c14671942a5dd47de59d4cdcff8532a6dd0e081faf1119482"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "schnellru"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "772575a524feeb803e5b0fcbc6dd9f367e579488197c94c6e4023aad2305774d"
+dependencies = [
+ "ahash 0.8.3",
+ "cfg-if",
+ "hashbrown 0.13.2",
+]
+
+[[package]]
+name = "schnorrkel"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "021b403afe70d81eea68f6ea12f6b3c9588e5d536a94c3bf80f15e7faa267862"
+dependencies = [
+ "arrayref",
+ "arrayvec 0.5.2",
+ "curve25519-dalek 2.1.3",
+ "getrandom 0.1.16",
+ "merlin 2.0.1",
+ "rand 0.7.3",
+ "rand_core 0.5.1",
+ "sha2 0.8.2",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+
+[[package]]
+name = "scratch"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1"
+
+[[package]]
+name = "sct"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b362b83898e0e69f38515b82ee15aa80636befe47c3b6d3d89a911e78fc228ce"
+dependencies = [
+ "ring 0.16.20",
+ "untrusted",
+]
+
+[[package]]
+name = "sct"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+dependencies = [
+ "ring 0.16.20",
+ "untrusted",
+]
+
+[[package]]
+name = "sdp"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d22a5ef407871893fd72b4562ee15e4742269b173959db4b8df6f538c414e13"
+dependencies = [
+ "rand 0.8.5",
+ "substring",
+ "thiserror",
+ "url",
+]
+
+[[package]]
+name = "sec1"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be24c1842290c45df0a7bf069e0c268a747ad05a192f2fd7dcfdbc1cba40928"
+dependencies = [
+ "base16ct 0.1.1",
+ "der 0.6.1",
+ "generic-array 0.14.7",
+ "pkcs8 0.9.0",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "sec1"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0aec48e813d6b90b15f0b8948af3c63483992dee44c03e9930b3eebdabe046e"
+dependencies = [
+ "base16ct 0.2.0",
+ "der 0.7.6",
+ "generic-array 0.14.7",
+ "pkcs8 0.10.2",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "secp256k1"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1629c9c557ef9b293568b338dddfc8208c98a18c59d722a9d53f859d9c9b62"
+dependencies = [
+ "secp256k1-sys",
+]
+
+[[package]]
+name = "secp256k1-sys"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83080e2c2fc1006e625be82e5d1eb6a43b7fd9578b617fcc55814daf286bba4b"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "secrecy"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bd1c54ea06cfd2f6b63219704de0b9b4f72dcc2b8fdef820be6cd799780e91e"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "security-framework"
+version = "2.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fc758eb7bffce5b308734e9b0c1468893cae9ff70ebf13e7090be8dcbcc83a8"
+dependencies = [
+ "bitflags",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f51d0c0d83bec45f16480d0ce0058397a69e48fcdc52d1dc8855fb68acbd31a7"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a3186ec9e65071a2095434b1f5bb24838d4e8e130f584c790f6033c79943537"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+dependencies = [
+ "semver-parser",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+
+[[package]]
+name = "serde"
+version = "1.0.164"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e8c8cf938e98f769bc164923b06dce91cea1751522f46f8466461af04c9027d"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.164"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9735b638ccc51c28bf6914d90a2e9725b377144fc612c49a611fddd1b631d68"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.96"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "057d394a50403bcac12672b2b18fb387ab6d289d957dab67dd201875391e52f1"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93107647184f6027e3b7dcb2e11034cf95ffa1e3a682c67951963ac69c1c007d"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "sha-1"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99cd6713db3cf16b6c84e06321e049a9b9f699826e16096d23bbcc44d15d51a6"
+dependencies = [
+ "block-buffer 0.9.0",
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.9.0",
+ "opaque-debug 0.3.0",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
+dependencies = [
+ "block-buffer 0.7.3",
+ "digest 0.8.1",
+ "fake-simd",
+ "opaque-debug 0.2.3",
+]
+
+[[package]]
+name = "sha2"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
+dependencies = [
+ "block-buffer 0.9.0",
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.9.0",
+ "opaque-debug 0.3.0",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479fb9d862239e610720565ca91403019f2f00410f1864c5aa7479b950a76ed8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest 0.10.7",
+ "keccak",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shlex"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "1.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c"
+dependencies = [
+ "digest 0.10.7",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "signature"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e1788eed21689f9cf370582dfc467ef36ed9c707f073528ddafa8d83e3b8500"
+dependencies = [
+ "digest 0.10.7",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "simba"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "061507c94fc6ab4ba1c9a0305018408e312e17c041eb63bef8aa726fa33aceae"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "wide",
+]
+
+[[package]]
+name = "siphasher"
+version = "0.3.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+
+[[package]]
+name = "slab"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "slice-group-by"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
+
+[[package]]
+name = "smallvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
+
+[[package]]
+name = "snap"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e9f0ab6ef7eb7353d9119c170a436d1bf248eea575ac42d19d12f4e34130831"
+
+[[package]]
+name = "snow"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c9d1425eb528a21de2755c75af4c9b5d57f50a0d4c3b7f1828a4cd03f8ba155"
+dependencies = [
+ "aes-gcm 0.9.4",
+ "blake2",
+ "chacha20poly1305",
+ "curve25519-dalek 4.0.0",
+ "rand_core 0.6.4",
+ "ring 0.16.20",
+ "rustc_version 0.4.0",
+ "sha2 0.10.7",
+ "subtle",
+]
+
+[[package]]
+name = "socket2"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "soketto"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d1c5305e39e09653383c2c7244f2f78b3bcae37cf50c64cb4789c9f5096ec2"
+dependencies = [
+ "base64 0.13.1",
+ "bytes",
+ "flate2",
+ "futures",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.8.5",
+ "sha-1",
+]
+
+[[package]]
+name = "sp-api"
+version = "4.0.0-dev"
+dependencies = [
+ "hash-db",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api-proc-macro",
+ "sp-core",
+ "sp-externalities",
+ "sp-metadata-ir",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-std",
+ "sp-test-primitives",
+ "sp-trie",
+ "sp-version",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-api-proc-macro"
+version = "4.0.0-dev"
+dependencies = [
+ "Inflector",
+ "assert_matches",
+ "blake2",
+ "expander",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "sp-api-test"
+version = "2.0.1"
+dependencies = [
+ "criterion",
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "rustversion",
+ "sc-block-builder",
+ "scale-info",
+ "sp-api",
+ "sp-consensus",
+ "sp-core",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-tracing",
+ "sp-version",
+ "static_assertions",
+ "substrate-test-runtime-client",
+ "trybuild",
+]
+
+[[package]]
+name = "sp-application-crypto"
+version = "23.0.0"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-io",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-application-crypto-test"
+version = "2.0.0"
+dependencies = [
+ "sp-api",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-keystore",
+ "substrate-test-runtime-client",
+]
+
+[[package]]
+name = "sp-arithmetic"
+version = "16.0.0"
+dependencies = [
+ "criterion",
+ "integer-sqrt",
+ "num-traits",
+ "parity-scale-codec",
+ "primitive-types",
+ "rand 0.8.5",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-std",
+ "static_assertions",
+]
+
+[[package]]
+name = "sp-arithmetic-fuzzer"
+version = "2.0.0"
+dependencies = [
+ "arbitrary",
+ "fraction",
+ "honggfuzz",
+ "num-bigint",
+ "sp-arithmetic",
+]
+
+[[package]]
+name = "sp-ark-bls12-377"
+version = "0.4.0-beta"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b8e61a06f286f4e8565a67865ef52e83edabf447881898c94527ffc7b839177"
+dependencies = [
+ "ark-bls12-377",
+ "ark-ff",
+ "ark-r1cs-std",
+ "ark-scale",
+ "ark-std",
+ "parity-scale-codec",
+ "sp-ark-models",
+]
+
+[[package]]
+name = "sp-ark-bls12-381"
+version = "0.4.0-beta"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3352feef6c9c34022fa766a0c9a86a88a83d280a3e5b34781a1a9af98377a130"
+dependencies = [
+ "ark-bls12-381",
+ "ark-ff",
+ "ark-scale",
+ "ark-serialize",
+ "ark-std",
+ "parity-scale-codec",
+ "sp-ark-models",
+]
+
+[[package]]
+name = "sp-ark-bw6-761"
+version = "0.4.0-beta"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf069165e230aef3c4680edea2d8ab3caa89c039e0b61fad2b8e061fb393668"
+dependencies = [
+ "ark-bw6-761",
+ "ark-ff",
+ "ark-scale",
+ "ark-std",
+ "parity-scale-codec",
+ "sp-ark-models",
+]
+
+[[package]]
+name = "sp-ark-ed-on-bls12-377"
+version = "0.4.0-beta"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e63f1fe8e7e87cb0258d61212b019d4d0fd230293ec42a564eb671c83d437497"
+dependencies = [
+ "ark-ed-on-bls12-377",
+ "ark-ff",
+ "ark-r1cs-std",
+ "ark-scale",
+ "ark-serialize",
+ "ark-std",
+ "parity-scale-codec",
+ "sp-ark-models",
+]
+
+[[package]]
+name = "sp-ark-ed-on-bls12-381-bandersnatch"
+version = "0.4.0-beta"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "838ddc5508aff3e89f930e7e7f3565d0786ac27868cfd61587afe681011e1140"
+dependencies = [
+ "ark-ec",
+ "ark-ed-on-bls12-381-bandersnatch",
+ "ark-ff",
+ "ark-r1cs-std",
+ "ark-scale",
+ "ark-std",
+ "parity-scale-codec",
+ "sp-ark-bls12-381",
+ "sp-ark-models",
+]
+
+[[package]]
+name = "sp-ark-models"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28fa906b809d7a346b2aa32a4bd0c884a75f9f588f9a4a07272f63eaf8a10765"
+dependencies = [
+ "ark-ec",
+ "ark-ff",
+ "ark-serialize",
+ "ark-std",
+ "derivative",
+ "getrandom 0.2.9",
+ "itertools",
+ "num-traits",
+ "zeroize",
+]
+
+[[package]]
+name = "sp-authority-discovery"
+version = "4.0.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-block-builder"
+version = "4.0.0-dev"
+dependencies = [
+ "sp-api",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-blockchain"
+version = "4.0.0-dev"
+dependencies = [
+ "futures",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "schnellru",
+ "sp-api",
+ "sp-consensus",
+ "sp-database",
+ "sp-runtime",
+ "sp-state-machine",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-consensus"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "log",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-test-primitives",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-consensus-aura"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-consensus-slots",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-std",
+ "sp-timestamp",
+]
+
+[[package]]
+name = "sp-consensus-babe"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-consensus-slots",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-std",
+ "sp-timestamp",
+]
+
+[[package]]
+name = "sp-consensus-beefy"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "lazy_static",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-io",
+ "sp-mmr-primitives",
+ "sp-runtime",
+ "sp-std",
+ "strum",
+ "w3f-bls",
+]
+
+[[package]]
+name = "sp-consensus-grandpa"
+version = "4.0.0-dev"
+dependencies = [
+ "finality-grandpa",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-consensus-pow"
+version = "0.10.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "sp-api",
+ "sp-core",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-consensus-slots"
+version = "0.10.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-std",
+ "sp-timestamp",
+]
+
+[[package]]
+name = "sp-core"
+version = "21.0.0"
+dependencies = [
+ "array-bytes",
+ "arrayvec 0.7.2",
+ "bandersnatch_vrfs",
+ "bitflags",
+ "blake2",
+ "bounded-collections",
+ "bs58",
+ "criterion",
+ "dyn-clonable",
+ "ed25519-zebra",
+ "futures",
+ "hash-db",
+ "hash256-std-hasher",
+ "impl-serde",
+ "lazy_static",
+ "libsecp256k1",
+ "log",
+ "merlin 2.0.1",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "paste",
+ "primitive-types",
+ "rand 0.8.5",
+ "regex",
+ "scale-info",
+ "schnorrkel",
+ "secp256k1",
+ "secrecy",
+ "serde",
+ "serde_json",
+ "sp-core-hashing",
+ "sp-core-hashing-proc-macro",
+ "sp-debug-derive",
+ "sp-externalities",
+ "sp-runtime-interface",
+ "sp-std",
+ "sp-storage",
+ "ss58-registry",
+ "substrate-bip39",
+ "thiserror",
+ "tiny-bip39",
+ "tracing",
+ "w3f-bls",
+ "zeroize",
+]
+
+[[package]]
+name = "sp-core-hashing"
+version = "9.0.0"
+dependencies = [
+ "blake2b_simd",
+ "byteorder",
+ "digest 0.10.7",
+ "sha2 0.10.7",
+ "sha3",
+ "twox-hash",
+]
+
+[[package]]
+name = "sp-core-hashing-proc-macro"
+version = "9.0.0"
+dependencies = [
+ "quote",
+ "sp-core-hashing",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "sp-crypto-ec-utils"
+version = "0.4.0"
+dependencies = [
+ "ark-algebra-test-templates",
+ "ark-bls12-377",
+ "ark-bls12-381",
+ "ark-bw6-761",
+ "ark-ec",
+ "ark-ed-on-bls12-377",
+ "ark-ed-on-bls12-381-bandersnatch",
+ "ark-ff",
+ "ark-scale",
+ "ark-serialize",
+ "ark-std",
+ "parity-scale-codec",
+ "sp-ark-bls12-377",
+ "sp-ark-bls12-381",
+ "sp-ark-bw6-761",
+ "sp-ark-ed-on-bls12-377",
+ "sp-ark-ed-on-bls12-381-bandersnatch",
+ "sp-ark-models",
+ "sp-io",
+ "sp-runtime-interface",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-database"
+version = "4.0.0-dev"
+dependencies = [
+ "kvdb",
+ "parking_lot 0.12.1",
+]
+
+[[package]]
+name = "sp-debug-derive"
+version = "8.0.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "sp-externalities"
+version = "0.19.0"
+dependencies = [
+ "environmental",
+ "parity-scale-codec",
+ "sp-std",
+ "sp-storage",
+]
+
+[[package]]
+name = "sp-genesis-builder"
+version = "0.1.0"
+dependencies = [
+ "serde_json",
+ "sp-api",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-inherents"
+version = "4.0.0-dev"
+dependencies = [
+ "async-trait",
+ "futures",
+ "impl-trait-for-tuples",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-runtime",
+ "sp-std",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-io"
+version = "23.0.0"
+dependencies = [
+ "bytes",
+ "ed25519-dalek 2.0.0",
+ "libsecp256k1",
+ "log",
+ "parity-scale-codec",
+ "rustversion",
+ "secp256k1",
+ "sp-core",
+ "sp-externalities",
+ "sp-keystore",
+ "sp-runtime-interface",
+ "sp-state-machine",
+ "sp-std",
+ "sp-tracing",
+ "sp-trie",
+ "tracing",
+ "tracing-core",
+]
+
+[[package]]
+name = "sp-keyring"
+version = "24.0.0"
+dependencies = [
+ "lazy_static",
+ "sp-core",
+ "sp-runtime",
+ "strum",
+]
+
+[[package]]
+name = "sp-keystore"
+version = "0.27.0"
+dependencies = [
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "rand 0.7.3",
+ "rand_chacha 0.2.2",
+ "sp-core",
+ "sp-externalities",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-maybe-compressed-blob"
+version = "4.1.0-dev"
+dependencies = [
+ "thiserror",
+ "zstd 0.12.3+zstd.1.5.2",
+]
+
+[[package]]
+name = "sp-metadata-ir"
+version = "0.1.0"
+dependencies = [
+ "frame-metadata",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-mmr-primitives"
+version = "4.0.0-dev"
+dependencies = [
+ "array-bytes",
+ "ckb-merkle-mountain-range",
+ "log",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-api",
+ "sp-core",
+ "sp-debug-derive",
+ "sp-runtime",
+ "sp-std",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-npos-elections"
+version = "4.0.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "scale-info",
+ "serde",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-runtime",
+ "sp-std",
+ "substrate-test-utils",
+]
+
+[[package]]
+name = "sp-npos-elections-fuzzer"
+version = "2.0.0-alpha.5"
+dependencies = [
+ "clap 4.3.2",
+ "honggfuzz",
+ "rand 0.8.5",
+ "sp-npos-elections",
+ "sp-runtime",
+]
+
+[[package]]
+name = "sp-offchain"
+version = "4.0.0-dev"
+dependencies = [
+ "sp-api",
+ "sp-core",
+ "sp-runtime",
+]
+
+[[package]]
+name = "sp-panic-handler"
+version = "8.0.0"
+dependencies = [
+ "backtrace",
+ "lazy_static",
+ "regex",
+]
+
+[[package]]
+name = "sp-rpc"
+version = "6.0.0"
+dependencies = [
+ "rustc-hash",
+ "serde",
+ "serde_json",
+ "sp-core",
+]
+
+[[package]]
+name = "sp-runtime"
+version = "24.0.0"
+dependencies = [
+ "either",
+ "hash256-std-hasher",
+ "impl-trait-for-tuples",
+ "log",
+ "parity-scale-codec",
+ "paste",
+ "rand 0.8.5",
+ "scale-info",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-io",
+ "sp-state-machine",
+ "sp-std",
+ "sp-tracing",
+ "sp-weights",
+ "substrate-test-runtime-client",
+ "zstd 0.12.3+zstd.1.5.2",
+]
+
+[[package]]
+name = "sp-runtime-interface"
+version = "17.0.0"
+dependencies = [
+ "bytes",
+ "impl-trait-for-tuples",
+ "parity-scale-codec",
+ "primitive-types",
+ "rustversion",
+ "sp-core",
+ "sp-externalities",
+ "sp-io",
+ "sp-runtime-interface-proc-macro",
+ "sp-runtime-interface-test-wasm",
+ "sp-state-machine",
+ "sp-std",
+ "sp-storage",
+ "sp-tracing",
+ "sp-wasm-interface",
+ "static_assertions",
+ "trybuild",
+]
+
+[[package]]
+name = "sp-runtime-interface-proc-macro"
+version = "11.0.0"
+dependencies = [
+ "Inflector",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "sp-runtime-interface-test"
+version = "2.0.0"
+dependencies = [
+ "sc-executor",
+ "sc-executor-common",
+ "sp-io",
+ "sp-runtime",
+ "sp-runtime-interface",
+ "sp-runtime-interface-test-wasm",
+ "sp-runtime-interface-test-wasm-deprecated",
+ "sp-state-machine",
+ "tracing",
+ "tracing-core",
+]
+
+[[package]]
+name = "sp-runtime-interface-test-wasm"
+version = "2.0.0"
+dependencies = [
+ "bytes",
+ "sp-core",
+ "sp-io",
+ "sp-runtime-interface",
+ "sp-std",
+ "substrate-wasm-builder",
+]
+
+[[package]]
+name = "sp-runtime-interface-test-wasm-deprecated"
+version = "2.0.0"
+dependencies = [
+ "sp-core",
+ "sp-io",
+ "sp-runtime-interface",
+ "substrate-wasm-builder",
+]
+
+[[package]]
+name = "sp-session"
+version = "4.0.0-dev"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "sp-api",
+ "sp-core",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-staking",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-staking"
+version = "4.0.0-dev"
+dependencies = [
+ "impl-trait-for-tuples",
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-state-machine"
+version = "0.28.0"
+dependencies = [
+ "array-bytes",
+ "assert_matches",
+ "hash-db",
+ "log",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "pretty_assertions",
+ "rand 0.8.5",
+ "smallvec",
+ "sp-core",
+ "sp-externalities",
+ "sp-panic-handler",
+ "sp-runtime",
+ "sp-std",
+ "sp-trie",
+ "thiserror",
+ "tracing",
+ "trie-db",
+]
+
+[[package]]
+name = "sp-statement-store"
+version = "4.0.0-dev"
+dependencies = [
+ "aes-gcm 0.10.2",
+ "curve25519-dalek 4.0.0",
+ "ed25519-dalek 2.0.0",
+ "hkdf",
+ "parity-scale-codec",
+ "rand 0.8.5",
+ "scale-info",
+ "sha2 0.10.7",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-externalities",
+ "sp-runtime",
+ "sp-runtime-interface",
+ "sp-std",
+ "thiserror",
+ "x25519-dalek 2.0.0",
+]
+
+[[package]]
+name = "sp-std"
+version = "8.0.0"
+
+[[package]]
+name = "sp-storage"
+version = "13.0.0"
+dependencies = [
+ "impl-serde",
+ "parity-scale-codec",
+ "ref-cast",
+ "serde",
+ "sp-debug-derive",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-test-primitives"
+version = "2.0.0"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "sp-application-crypto",
+ "sp-core",
+ "sp-runtime",
+ "sp-std",
+]
+
+[[package]]
+name = "sp-timestamp"
+version = "4.0.0-dev"
+dependencies = [
+ "async-trait",
+ "parity-scale-codec",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-std",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-tracing"
+version = "10.0.0"
+dependencies = [
+ "parity-scale-codec",
+ "sp-std",
+ "tracing",
+ "tracing-core",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "sp-transaction-pool"
+version = "4.0.0-dev"
+dependencies = [
+ "sp-api",
+ "sp-runtime",
+]
+
+[[package]]
+name = "sp-transaction-storage-proof"
+version = "4.0.0-dev"
+dependencies = [
+ "async-trait",
+ "parity-scale-codec",
+ "scale-info",
+ "sp-core",
+ "sp-inherents",
+ "sp-runtime",
+ "sp-std",
+ "sp-trie",
+]
+
+[[package]]
+name = "sp-trie"
+version = "22.0.0"
+dependencies = [
+ "ahash 0.8.3",
+ "array-bytes",
+ "criterion",
+ "hash-db",
+ "hashbrown 0.13.2",
+ "lazy_static",
+ "memory-db",
+ "nohash-hasher",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "scale-info",
+ "schnellru",
+ "sp-core",
+ "sp-runtime",
+ "sp-std",
+ "thiserror",
+ "tracing",
+ "trie-bench",
+ "trie-db",
+ "trie-root",
+ "trie-standardmap",
+]
+
+[[package]]
+name = "sp-version"
+version = "22.0.0"
+dependencies = [
+ "impl-serde",
+ "parity-scale-codec",
+ "parity-wasm",
+ "scale-info",
+ "serde",
+ "sp-core-hashing-proc-macro",
+ "sp-runtime",
+ "sp-std",
+ "sp-version-proc-macro",
+ "thiserror",
+]
+
+[[package]]
+name = "sp-version-proc-macro"
+version = "8.0.0"
+dependencies = [
+ "parity-scale-codec",
+ "proc-macro2",
+ "quote",
+ "sp-version",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "sp-wasm-interface"
+version = "14.0.0"
+dependencies = [
+ "anyhow",
+ "impl-trait-for-tuples",
+ "log",
+ "parity-scale-codec",
+ "sp-std",
+ "wasmtime",
+]
+
+[[package]]
+name = "sp-weights"
+version = "20.0.0"
+dependencies = [
+ "parity-scale-codec",
+ "scale-info",
+ "serde",
+ "smallvec",
+ "sp-arithmetic",
+ "sp-core",
+ "sp-debug-derive",
+ "sp-std",
+]
+
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "spinners"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08615eea740067d9899969bc2891c68a19c315cb1f66640af9a9ecb91b13bcab"
+dependencies = [
+ "lazy_static",
+ "maplit",
+ "strum",
+]
+
+[[package]]
+name = "spki"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67cf02bbac7a337dc36e4f5a693db6c21e7863f45070f7064577eb4367a3212b"
+dependencies = [
+ "base64ct",
+ "der 0.6.1",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1e996ef02c474957d681f1b05213dfb0abab947b446a62d37770b23500184a"
+dependencies = [
+ "base64ct",
+ "der 0.7.6",
+]
+
+[[package]]
+name = "ss58-registry"
+version = "1.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb47a8ad42e5fc72d5b1eb104a5546937eaf39843499948bb666d6e93c62423b"
+dependencies = [
+ "Inflector",
+ "num-format",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "unicode-xid",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "static_init"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a2a1c578e98c1c16fc3b8ec1328f7659a500737d7a0c6d625e73e830ff9c1f6"
+dependencies = [
+ "bitflags",
+ "cfg_aliases",
+ "libc",
+ "parking_lot 0.11.2",
+ "parking_lot_core 0.8.6",
+ "static_init_macro",
+ "winapi",
+]
+
+[[package]]
+name = "static_init_macro"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70a2595fc3aa78f2d0e45dd425b22282dd863273761cc77780914b2cf3003acf"
+dependencies = [
+ "cfg_aliases",
+ "memchr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "strum"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "stun"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7e94b1ec00bad60e6410e058b52f1c66de3dc5fe4d62d09b3e52bb7d3b73e25"
+dependencies = [
+ "base64 0.13.1",
+ "crc",
+ "lazy_static",
+ "md-5",
+ "rand 0.8.5",
+ "ring 0.16.20",
+ "subtle",
+ "thiserror",
+ "tokio",
+ "url",
+ "webrtc-util",
+]
+
+[[package]]
+name = "subkey"
+version = "3.0.0"
+dependencies = [
+ "clap 4.3.2",
+ "sc-cli",
+]
+
+[[package]]
+name = "substrate"
+version = "0.0.0"
+dependencies = [
+ "aquamarine",
+ "chain-spec-builder",
+ "frame-support",
+ "node-cli",
+ "sc-cli",
+ "sc-consensus-aura",
+ "sc-consensus-babe",
+ "sc-consensus-beefy",
+ "sc-consensus-grandpa",
+ "sc-consensus-manual-seal",
+ "sc-consensus-pow",
+ "sc-service",
+ "sp-runtime",
+ "subkey",
+]
+
+[[package]]
+name = "substrate-bip39"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49eee6965196b32f882dd2ee85a92b1dbead41b04e53907f269de3b0dc04733c"
+dependencies = [
+ "hmac 0.11.0",
+ "pbkdf2 0.8.0",
+ "schnorrkel",
+ "sha2 0.9.9",
+ "zeroize",
+]
+
+[[package]]
+name = "substrate-build-script-utils"
+version = "3.0.0"
+
+[[package]]
+name = "substrate-cli-test-utils"
+version = "0.1.0"
+dependencies = [
+ "assert_cmd",
+ "futures",
+ "nix 0.26.2",
+ "node-cli",
+ "node-primitives",
+ "regex",
+ "sc-cli",
+ "sc-service",
+ "sp-rpc",
+ "substrate-rpc-client",
+ "tokio",
+]
+
+[[package]]
+name = "substrate-frame-cli"
+version = "4.0.0-dev"
+dependencies = [
+ "clap 4.3.2",
+ "frame-support",
+ "frame-system",
+ "sc-cli",
+ "sp-core",
+ "sp-runtime",
+]
+
+[[package]]
+name = "substrate-frame-rpc-support"
+version = "3.0.0"
+dependencies = [
+ "frame-support",
+ "frame-system",
+ "jsonrpsee",
+ "parity-scale-codec",
+ "sc-rpc-api",
+ "scale-info",
+ "serde",
+ "sp-core",
+ "sp-runtime",
+ "sp-storage",
+ "tokio",
+]
+
+[[package]]
+name = "substrate-frame-rpc-system"
+version = "4.0.0-dev"
+dependencies = [
+ "assert_matches",
+ "frame-system-rpc-runtime-api",
+ "futures",
+ "jsonrpsee",
+ "log",
+ "parity-scale-codec",
+ "sc-rpc-api",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sp-api",
+ "sp-block-builder",
+ "sp-blockchain",
+ "sp-core",
+ "sp-runtime",
+ "sp-tracing",
+ "substrate-test-runtime-client",
+ "tokio",
+]
+
+[[package]]
+name = "substrate-prometheus-endpoint"
+version = "0.10.0-dev"
+dependencies = [
+ "hyper",
+ "log",
+ "prometheus",
+ "thiserror",
+ "tokio",
+]
+
+[[package]]
+name = "substrate-rpc-client"
+version = "0.10.0-dev"
+dependencies = [
+ "async-trait",
+ "jsonrpsee",
+ "log",
+ "sc-rpc-api",
+ "serde",
+ "sp-core",
+ "sp-runtime",
+ "tokio",
+]
+
+[[package]]
+name = "substrate-state-trie-migration-rpc"
+version = "4.0.0-dev"
+dependencies = [
+ "jsonrpsee",
+ "parity-scale-codec",
+ "sc-client-api",
+ "sc-rpc-api",
+ "serde",
+ "serde_json",
+ "sp-core",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-trie",
+ "trie-db",
+]
+
+[[package]]
+name = "substrate-test-client"
+version = "2.0.1"
+dependencies = [
+ "array-bytes",
+ "async-trait",
+ "futures",
+ "parity-scale-codec",
+ "sc-client-api",
+ "sc-client-db",
+ "sc-consensus",
+ "sc-executor",
+ "sc-offchain",
+ "sc-service",
+ "serde",
+ "serde_json",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-keyring",
+ "sp-keystore",
+ "sp-runtime",
+ "sp-state-machine",
+]
+
+[[package]]
+name = "substrate-test-runtime"
+version = "2.0.0"
+dependencies = [
+ "array-bytes",
+ "frame-executive",
+ "frame-support",
+ "frame-system",
+ "frame-system-rpc-runtime-api",
+ "futures",
+ "json-patch",
+ "log",
+ "pallet-babe",
+ "pallet-balances",
+ "pallet-timestamp",
+ "parity-scale-codec",
+ "sc-block-builder",
+ "sc-executor",
+ "sc-executor-common",
+ "sc-service",
+ "scale-info",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-application-crypto",
+ "sp-block-builder",
+ "sp-consensus",
+ "sp-consensus-aura",
+ "sp-consensus-babe",
+ "sp-consensus-grandpa",
+ "sp-core",
+ "sp-externalities",
+ "sp-genesis-builder",
+ "sp-inherents",
+ "sp-io",
+ "sp-keyring",
+ "sp-offchain",
+ "sp-runtime",
+ "sp-session",
+ "sp-state-machine",
+ "sp-std",
+ "sp-tracing",
+ "sp-transaction-pool",
+ "sp-trie",
+ "sp-version",
+ "substrate-test-runtime-client",
+ "substrate-wasm-builder",
+ "trie-db",
+]
+
+[[package]]
+name = "substrate-test-runtime-client"
+version = "2.0.0"
+dependencies = [
+ "futures",
+ "sc-block-builder",
+ "sc-client-api",
+ "sc-consensus",
+ "sp-api",
+ "sp-blockchain",
+ "sp-consensus",
+ "sp-core",
+ "sp-runtime",
+ "substrate-test-client",
+ "substrate-test-runtime",
+]
+
+[[package]]
+name = "substrate-test-runtime-transaction-pool"
+version = "2.0.0"
+dependencies = [
+ "futures",
+ "parity-scale-codec",
+ "parking_lot 0.12.1",
+ "sc-transaction-pool",
+ "sc-transaction-pool-api",
+ "sp-blockchain",
+ "sp-runtime",
+ "substrate-test-runtime-client",
+ "thiserror",
+]
+
+[[package]]
+name = "substrate-test-utils"
+version = "4.0.0-dev"
+dependencies = [
+ "futures",
+ "sc-service",
+ "substrate-test-utils-derive",
+ "tokio",
+ "trybuild",
+]
+
+[[package]]
+name = "substrate-test-utils-derive"
+version = "0.10.0-dev"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "substrate-test-utils-test-crate"
+version = "0.1.0"
+dependencies = [
+ "sc-service",
+ "substrate-test-utils",
+ "tokio",
+]
+
+[[package]]
+name = "substrate-wasm-builder"
+version = "5.0.0-dev"
+dependencies = [
+ "ansi_term",
+ "build-helper",
+ "cargo_metadata",
+ "filetime",
+ "parity-wasm",
+ "sp-maybe-compressed-blob",
+ "strum",
+ "tempfile",
+ "toml 0.7.4",
+ "walkdir",
+ "wasm-opt",
+]
+
+[[package]]
+name = "substring"
+version = "1.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ee6433ecef213b2e72f587ef64a2f5943e7cd16fbd82dbe8bc07486c534c86"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "subtle"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32d41677bcbe24c20c52e7c70b0d8db04134c5d1066bf98662e2871ad200ea3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.12.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "unicode-xid",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags",
+ "core-foundation",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "tar"
+version = "0.4.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd1ba337640d60c3e96bc6f0638a939b9c9a7f2c316a1598c279828b3d1dc8c5"
+
+[[package]]
+name = "tempfile"
+version = "3.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31c0432476357e58790aaa47a8efb0c5138f137343f3b5f23bd36a27e3b0a6d6"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "fastrand",
+ "redox_syscall 0.3.5",
+ "rustix 0.37.19",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "termtree"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
+
+[[package]]
+name = "textwrap"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+
+[[package]]
+name = "thiserror"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978c9a314bd8dc99be594bc3c175faaa9794be04a5a5e153caba6915336cebac"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "thousands"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bf63baf9f5039dadc247375c29eb13706706cfde997d0330d05aa63a77d8820"
+
+[[package]]
+name = "thread_local"
+version = "1.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+]
+
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
+[[package]]
+name = "tikv-jemalloc-sys"
+version = "0.5.3+5.3.0-patched"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a678df20055b43e57ef8cddde41cdfda9a3c1a060b67f4c5836dfb1d78543ba8"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi",
+]
+
+[[package]]
+name = "time"
+version = "0.3.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f3403384eaacbca9923fa06940178ac13e4edb725486d70e8e15881d0c836cc"
+dependencies = [
+ "itoa",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
+
+[[package]]
+name = "time-macros"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "372950940a5f07bf38dbe211d7283c9e6d7327df53794992d293e534c733d09b"
+dependencies = [
+ "time-core",
+]
+
+[[package]]
+name = "tiny-bip39"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62cc94d358b5a1e84a5cb9109f559aa3c4d634d2b1b4de3d0fa4adc7c78e2861"
+dependencies = [
+ "anyhow",
+ "hmac 0.12.1",
+ "once_cell",
+ "pbkdf2 0.11.0",
+ "rand 0.8.5",
+ "rustc-hash",
+ "sha2 0.10.7",
+ "thiserror",
+ "unicode-normalization",
+ "wasm-bindgen",
+ "zeroize",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94d7b1cfd2aa4011f2de74c2c4c63665e27a71006b0a192dcd2710272e73dfa2"
+dependencies = [
+ "autocfg",
+ "bytes",
+ "libc",
+ "mio",
+ "num_cpus",
+ "parking_lot 0.12.1",
+ "pin-project-lite 0.2.9",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "tokio-retry"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f57eb36ecbe0fc510036adff84824dd3c24bb781e21bfa67b69d556aa85214f"
+dependencies = [
+ "pin-project",
+ "rand 0.8.5",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.6",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
+dependencies = [
+ "futures-core",
+ "pin-project-lite 0.2.9",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "tokio-test"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "pin-project-lite 0.2.9",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6135d499e69981f9ff0ef2167955a5333c35e36f6937d382974566b3d5b94ec"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a76a9312f5ba4c2dec6b9161fdf25d87ad8a09256ccea5a556fef03c706a10f"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2380d56e8670370eee6566b0bfd4265f65b3f432e8c6d85623f728d4fa31f739"
+dependencies = [
+ "indexmap",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow",
+]
+
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d1d42a9b3f3ec46ba828e8d376aec14592ea199f70a06a548587ecd1c4ab658"
+dependencies = [
+ "bitflags",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-range-header",
+ "pin-project-lite 0.2.9",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+
+[[package]]
+name = "tower-service"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+
+[[package]]
+name = "tracing"
+version = "0.1.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
+dependencies = [
+ "cfg-if",
+ "log",
+ "pin-project-lite 0.2.9",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f57e3ca2a01450b1a921183a9c9cbfda207fd822cef4ccb00a65402cbba7a74"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-futures"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
+dependencies = [
+ "pin-project",
+ "tracing",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
+dependencies = [
+ "lazy_static",
+ "log",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-serde"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc6b213177105856957181934e4920de57730fc69bf42c37ee5bb664d406d9e1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.2.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e0d2eaa99c3c2e41547cfa109e910a68ea03823cccad4a0525dcbc9b01e8c71"
+dependencies = [
+ "ansi_term",
+ "chrono",
+ "lazy_static",
+ "matchers",
+ "parking_lot 0.11.2",
+ "regex",
+ "serde",
+ "serde_json",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+ "tracing-serde",
+]
+
+[[package]]
+name = "trie-bench"
+version = "0.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f54b4f9d51d368e62cf7e0730c7c1e18fc658cc84333656bab5b328f44aa964"
+dependencies = [
+ "criterion",
+ "hash-db",
+ "keccak-hasher",
+ "memory-db",
+ "parity-scale-codec",
+ "trie-db",
+ "trie-root",
+ "trie-standardmap",
+]
+
+[[package]]
+name = "trie-db"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "767abe6ffed88a1889671a102c2861ae742726f52e0a5a425b92c9fbfa7e9c85"
+dependencies = [
+ "hash-db",
+ "hashbrown 0.13.2",
+ "log",
+ "rustc-hex",
+ "smallvec",
+]
+
+[[package]]
+name = "trie-root"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4ed310ef5ab98f5fa467900ed906cb9232dd5376597e00fd4cba2a449d06c0b"
+dependencies = [
+ "hash-db",
+]
+
+[[package]]
+name = "trie-standardmap"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "684aafb332fae6f83d7fe10b3fbfdbe39a1b3234c4e2a618f030815838519516"
+dependencies = [
+ "hash-db",
+ "keccak-hasher",
+]
+
+[[package]]
+name = "trust-dns-proto"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f7f83d1e4a0e4358ac54c5c3681e5d7da5efc5a7a632c90bb6d6669ddd9bc26"
+dependencies = [
+ "async-trait",
+ "cfg-if",
+ "data-encoding",
+ "enum-as-inner",
+ "futures-channel",
+ "futures-io",
+ "futures-util",
+ "idna 0.2.3",
+ "ipnet",
+ "lazy_static",
+ "rand 0.8.5",
+ "smallvec",
+ "socket2",
+ "thiserror",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "trust-dns-resolver"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aff21aa4dcefb0a1afbfac26deb0adc93888c7d295fb63ab273ef276ba2b7cfe"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "ipconfig",
+ "lazy_static",
+ "lru-cache",
+ "parking_lot 0.12.1",
+ "resolv-conf",
+ "smallvec",
+ "thiserror",
+ "tokio",
+ "tracing",
+ "trust-dns-proto",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
+
+[[package]]
+name = "try-runtime-cli"
+version = "0.10.0-dev"
+dependencies = [
+ "assert_cmd",
+ "async-trait",
+ "clap 4.3.2",
+ "frame-remote-externalities",
+ "frame-try-runtime",
+ "hex",
+ "log",
+ "node-primitives",
+ "parity-scale-codec",
+ "regex",
+ "sc-cli",
+ "sc-executor",
+ "serde",
+ "serde_json",
+ "sp-api",
+ "sp-consensus-aura",
+ "sp-consensus-babe",
+ "sp-core",
+ "sp-debug-derive",
+ "sp-externalities",
+ "sp-inherents",
+ "sp-io",
+ "sp-keystore",
+ "sp-rpc",
+ "sp-runtime",
+ "sp-state-machine",
+ "sp-timestamp",
+ "sp-transaction-storage-proof",
+ "sp-version",
+ "sp-weights",
+ "substrate-cli-test-utils",
+ "substrate-rpc-client",
+ "tempfile",
+ "tokio",
+ "zstd 0.12.3+zstd.1.5.2",
+]
+
+[[package]]
+name = "trybuild"
+version = "1.0.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501dbdbb99861e4ab6b60eb6a7493956a9defb644fd034bc4a5ef27c693c8a3a"
+dependencies = [
+ "basic-toml",
+ "dissimilar",
+ "glob",
+ "once_cell",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "termcolor",
+]
+
+[[package]]
+name = "tt-call"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f195fd851901624eee5a58c4bb2b4f06399148fcd0ed336e6f1cb60a9881df"
+
+[[package]]
+name = "turn"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4712ee30d123ec7ae26d1e1b218395a16c87cdbaf4b3925d170d684af62ea5e8"
+dependencies = [
+ "async-trait",
+ "base64 0.13.1",
+ "futures",
+ "log",
+ "md-5",
+ "rand 0.8.5",
+ "ring 0.16.20",
+ "stun",
+ "thiserror",
+ "tokio",
+ "webrtc-util",
+]
+
+[[package]]
+name = "twox-hash"
+version = "1.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+dependencies = [
+ "cfg-if",
+ "digest 0.10.7",
+ "rand 0.8.5",
+ "static_assertions",
+]
+
+[[package]]
+name = "typenum"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
+
+[[package]]
+name = "uint"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52"
+dependencies = [
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
+]
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15811caf2415fb889178633e7724bad2509101cde276048e013b9def5e51fa0"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-width"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
+[[package]]
+name = "universal-hash"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f214e8f697e925001e66ec2c6e37a4ef93f0f78c2eed7814394e10c62025b05"
+dependencies = [
+ "generic-array 0.14.7",
+ "subtle",
+]
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "unsigned-varint"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d86a8dc7f45e4c1b0d30e43038c38f274e77af056aa5f74b93c2cf9eb3c1c836"
+dependencies = [
+ "asynchronous-codec",
+ "bytes",
+ "futures-io",
+ "futures-util",
+]
+
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
+[[package]]
+name = "url"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50bff7831e19200a85b17131d085c25d7811bc4e186efdaf54bbd132994a88cb"
+dependencies = [
+ "form_urlencoded",
+ "idna 0.4.0",
+ "percent-encoding",
+]
+
+[[package]]
+name = "utf8parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+
+[[package]]
+name = "uuid"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "345444e32442451b267fc254ae85a209c64be56d2890e601a0c37ff0c3c5ecd2"
+dependencies = [
+ "getrandom 0.2.9",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+
+[[package]]
+name = "w3f-bls"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7335e4c132c28cc43caef6adb339789e599e39adbe78da0c4d547fad48cbc331"
+dependencies = [
+ "ark-bls12-377",
+ "ark-bls12-381",
+ "ark-ec",
+ "ark-ff",
+ "ark-serialize",
+ "ark-serialize-derive",
+ "arrayref",
+ "constcat",
+ "digest 0.10.7",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+ "sha2 0.10.7",
+ "sha3",
+ "thiserror",
+ "zeroize",
+]
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "waitgroup"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1f50000a783467e6c0200f9d10642f4bc424e39efc1b770203e88b488f79292"
+dependencies = [
+ "atomic-waker",
+]
+
+[[package]]
+name = "waker-fn"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+
+[[package]]
+name = "walkdir"
+version = "2.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36df944cda56c7d8d8b7496af378e6b16de9284591917d307c9b4d313c44e698"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+dependencies = [
+ "log",
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bba0e8cb82ba49ff4e229459ff22a191bbe9a1cb3a341610c9c33efc27ddf73"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b04bc93f9d6bdee709f6bd2118f57dd6679cf1176a1af464fca3ab0d66d8fb"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d1985d03709c53167ce907ff394f5316aa22cb4e12761295c5dc57dacb6297e"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14d6b024f1a526bb0234f52840389927257beb670610081360e5a03c5df9c258"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e128beba882dd1eb6200e1dc92ae6c5dbaa4311aa7bb211ca035779e5efc39f8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed9d5b4305409d1fc9482fee2d7f9bcbf24b3972bf59817ef757e23982242a93"
+
+[[package]]
+name = "wasm-encoder"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18c41dbd92eaebf3612a39be316540b8377c871cb9bde6b064af962984912881"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-instrument"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa1dafb3e60065305741e83db35c6c2584bb3725b692b5b66148a38d72ace6cd"
+dependencies = [
+ "parity-wasm",
+]
+
+[[package]]
+name = "wasm-instrument"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a47ecb37b9734d1085eaa5ae1a81e60801fd8c28d4cabdd8aedb982021918bc"
+dependencies = [
+ "parity-wasm",
+]
+
+[[package]]
+name = "wasm-opt"
+version = "0.114.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d984c9ca0fd8dc99c85920c73d1707d0c2104b5cb8f368fce73b3dbf4424b22b"
+dependencies = [
+ "anyhow",
+ "libc",
+ "strum",
+ "strum_macros",
+ "tempfile",
+ "thiserror",
+ "wasm-opt-cxx-sys",
+ "wasm-opt-sys",
+]
+
+[[package]]
+name = "wasm-opt-cxx-sys"
+version = "0.114.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e754ce2f058a43fa604c588d111cfdc963131ad66d9f96c061d76a4f1a4a4eb0"
+dependencies = [
+ "anyhow",
+ "cxx",
+ "cxx-build",
+ "wasm-opt-sys",
+]
+
+[[package]]
+name = "wasm-opt-sys"
+version = "0.114.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7283687ca12943aa186bba3d2ec43e87039098450c4701420eabd0a770e9b69"
+dependencies = [
+ "anyhow",
+ "cc",
+ "cxx",
+ "cxx-build",
+]
+
+[[package]]
+name = "wasm-timer"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be0ecb0db480561e9a7642b5d3e4187c128914e58aa84330b9493e3eb68c5e7f"
+dependencies = [
+ "futures",
+ "js-sys",
+ "parking_lot 0.11.2",
+ "pin-utils",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmi"
+version = "0.30.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51fb5c61993e71158abf5bb863df2674ca3ec39ed6471c64f07aeaf751d67b4"
+dependencies = [
+ "intx",
+ "smallvec",
+ "spin 0.9.8",
+ "wasmi_arena",
+ "wasmi_core",
+ "wasmparser-nostd",
+]
+
+[[package]]
+name = "wasmi_arena"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "401c1f35e413fac1846d4843745589d9ec678977ab35a384db8ae7830525d468"
+
+[[package]]
+name = "wasmi_core"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "624e6333e861ef49095d2d678b76ebf30b06bf37effca845be7e5b87c90071b7"
+dependencies = [
+ "downcast-rs",
+ "libm",
+ "num-traits",
+ "paste",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.102.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48134de3d7598219ab9eaf6b91b15d8e50d31da76b8519fe4ecfcec2cf35104b"
+dependencies = [
+ "indexmap",
+ "url",
+]
+
+[[package]]
+name = "wasmparser-nostd"
+version = "0.100.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9157cab83003221bfd385833ab587a039f5d6fa7304854042ba358a3b09e0724"
+dependencies = [
+ "indexmap-nostd",
+]
+
+[[package]]
+name = "wasmtime"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f907fdead3153cb9bfb7a93bbd5b62629472dc06dee83605358c64c52ed3dda9"
+dependencies = [
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "indexmap",
+ "libc",
+ "log",
+ "object",
+ "once_cell",
+ "paste",
+ "psm",
+ "rayon",
+ "serde",
+ "target-lexicon",
+ "wasmparser",
+ "wasmtime-cache",
+ "wasmtime-cranelift",
+ "wasmtime-environ",
+ "wasmtime-jit",
+ "wasmtime-runtime",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "wasmtime-asm-macros"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3b9daa7c14cd4fa3edbf69de994408d5f4b7b0959ac13fa69d465f6597f810d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "wasmtime-cache"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c86437fa68626fe896e5afc69234bb2b5894949083586535f200385adfd71213"
+dependencies = [
+ "anyhow",
+ "base64 0.21.2",
+ "bincode",
+ "directories-next",
+ "file-per-thread-logger",
+ "log",
+ "rustix 0.36.14",
+ "serde",
+ "sha2 0.10.7",
+ "toml 0.5.11",
+ "windows-sys 0.45.0",
+ "zstd 0.11.2+zstd.1.5.2",
+]
+
+[[package]]
+name = "wasmtime-cranelift"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1cefde0cce8cb700b1b21b6298a3837dba46521affd7b8c38a9ee2c869eee04"
+dependencies = [
+ "anyhow",
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "cranelift-native",
+ "cranelift-wasm",
+ "gimli",
+ "log",
+ "object",
+ "target-lexicon",
+ "thiserror",
+ "wasmparser",
+ "wasmtime-cranelift-shared",
+ "wasmtime-environ",
+]
+
+[[package]]
+name = "wasmtime-cranelift-shared"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd041e382ef5aea1b9fc78442394f1a4f6d676ce457e7076ca4cb3f397882f8b"
+dependencies = [
+ "anyhow",
+ "cranelift-codegen",
+ "cranelift-native",
+ "gimli",
+ "object",
+ "target-lexicon",
+ "wasmtime-environ",
+]
+
+[[package]]
+name = "wasmtime-environ"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a990198cee4197423045235bf89d3359e69bd2ea031005f4c2d901125955c949"
+dependencies = [
+ "anyhow",
+ "cranelift-entity",
+ "gimli",
+ "indexmap",
+ "log",
+ "object",
+ "serde",
+ "target-lexicon",
+ "thiserror",
+ "wasmparser",
+ "wasmtime-types",
+]
+
+[[package]]
+name = "wasmtime-jit"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de48df552cfca1c9b750002d3e07b45772dd033b0b206d5c0968496abf31244"
+dependencies = [
+ "addr2line",
+ "anyhow",
+ "bincode",
+ "cfg-if",
+ "cpp_demangle",
+ "gimli",
+ "log",
+ "object",
+ "rustc-demangle",
+ "serde",
+ "target-lexicon",
+ "wasmtime-environ",
+ "wasmtime-jit-debug",
+ "wasmtime-jit-icache-coherence",
+ "wasmtime-runtime",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "wasmtime-jit-debug"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e0554b84c15a27d76281d06838aed94e13a77d7bf604bbbaf548aa20eb93846"
+dependencies = [
+ "object",
+ "once_cell",
+ "rustix 0.36.14",
+]
+
+[[package]]
+name = "wasmtime-jit-icache-coherence"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aecae978b13f7f67efb23bd827373ace4578f2137ec110bbf6a4a7cde4121bbd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "wasmtime-runtime"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658cf6f325232b6760e202e5255d823da5e348fdea827eff0a2a22319000b441"
+dependencies = [
+ "anyhow",
+ "cc",
+ "cfg-if",
+ "indexmap",
+ "libc",
+ "log",
+ "mach",
+ "memfd",
+ "memoffset 0.8.0",
+ "paste",
+ "rand 0.8.5",
+ "rustix 0.36.14",
+ "wasmtime-asm-macros",
+ "wasmtime-environ",
+ "wasmtime-jit-debug",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "wasmtime-types"
+version = "8.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4f6fffd2a1011887d57f07654dd112791e872e3ff4a2e626aee8059ee17f06f"
+dependencies = [
+ "cranelift-entity",
+ "serde",
+ "thiserror",
+ "wasmparser",
+]
+
+[[package]]
+name = "wast"
+version = "60.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd06cc744b536e30387e72a48fdd492105b9c938bb4f415c39c616a7a0a697ad"
+dependencies = [
+ "leb128",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder",
+]
+
+[[package]]
+name = "wat"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5abe520f0ab205366e9ac7d3e6b2fc71de44e32a2b58f2ec871b6b575bdcea3b"
+dependencies = [
+ "wast",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bdd9ef4e984da1187bf8110c5cf5b845fbc87a23602cdf912386a76fcd3a7c2"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki"
+version = "0.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e38c0608262c46d4a56202ebabdeb094cef7e560ca7a226c6bf055188aa4ea"
+dependencies = [
+ "ring 0.16.20",
+ "untrusted",
+]
+
+[[package]]
+name = "webpki"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
+dependencies = [
+ "ring 0.16.20",
+ "untrusted",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87"
+dependencies = [
+ "webpki 0.22.0",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b03058f88386e5ff5310d9111d53f48b17d732b401aeb83a8d5190f2ac459338"
+dependencies = [
+ "rustls-webpki 0.100.2",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
+
+[[package]]
+name = "webrtc"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d3bc9049bdb2cea52f5fd4f6f728184225bdb867ed0dc2410eab6df5bdd67bb"
+dependencies = [
+ "arc-swap",
+ "async-trait",
+ "bytes",
+ "hex",
+ "interceptor",
+ "lazy_static",
+ "log",
+ "rand 0.8.5",
+ "rcgen 0.9.3",
+ "regex",
+ "ring 0.16.20",
+ "rtcp",
+ "rtp",
+ "rustls 0.19.1",
+ "sdp",
+ "serde",
+ "serde_json",
+ "sha2 0.10.7",
+ "stun",
+ "thiserror",
+ "time 0.3.21",
+ "tokio",
+ "turn",
+ "url",
+ "waitgroup",
+ "webrtc-data",
+ "webrtc-dtls",
+ "webrtc-ice",
+ "webrtc-mdns",
+ "webrtc-media",
+ "webrtc-sctp",
+ "webrtc-srtp",
+ "webrtc-util",
+]
+
+[[package]]
+name = "webrtc-data"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ef36a4d12baa6e842582fe9ec16a57184ba35e1a09308307b67d43ec8883100"
+dependencies = [
+ "bytes",
+ "derive_builder",
+ "log",
+ "thiserror",
+ "tokio",
+ "webrtc-sctp",
+ "webrtc-util",
+]
+
+[[package]]
+name = "webrtc-dtls"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "942be5bd85f072c3128396f6e5a9bfb93ca8c1939ded735d177b7bcba9a13d05"
+dependencies = [
+ "aes 0.6.0",
+ "aes-gcm 0.10.2",
+ "async-trait",
+ "bincode",
+ "block-modes",
+ "byteorder",
+ "ccm",
+ "curve25519-dalek 3.2.0",
+ "der-parser 8.2.0",
+ "elliptic-curve 0.12.3",
+ "hkdf",
+ "hmac 0.12.1",
+ "log",
+ "oid-registry 0.6.1",
+ "p256",
+ "p384",
+ "rand 0.8.5",
+ "rand_core 0.6.4",
+ "rcgen 0.9.3",
+ "ring 0.16.20",
+ "rustls 0.19.1",
+ "sec1 0.3.0",
+ "serde",
+ "sha1",
+ "sha2 0.10.7",
+ "signature 1.6.4",
+ "subtle",
+ "thiserror",
+ "tokio",
+ "webpki 0.21.4",
+ "webrtc-util",
+ "x25519-dalek 2.0.0",
+ "x509-parser 0.13.2",
+]
+
+[[package]]
+name = "webrtc-ice"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465a03cc11e9a7d7b4f9f99870558fe37a102b65b93f8045392fef7c67b39e80"
+dependencies = [
+ "arc-swap",
+ "async-trait",
+ "crc",
+ "log",
+ "rand 0.8.5",
+ "serde",
+ "serde_json",
+ "stun",
+ "thiserror",
+ "tokio",
+ "turn",
+ "url",
+ "uuid",
+ "waitgroup",
+ "webrtc-mdns",
+ "webrtc-util",
+]
+
+[[package]]
+name = "webrtc-mdns"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f08dfd7a6e3987e255c4dbe710dde5d94d0f0574f8a21afa95d171376c143106"
+dependencies = [
+ "log",
+ "socket2",
+ "thiserror",
+ "tokio",
+ "webrtc-util",
+]
+
+[[package]]
+name = "webrtc-media"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f72e1650a8ae006017d1a5280efb49e2610c19ccc3c0905b03b648aee9554991"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "rand 0.8.5",
+ "rtp",
+ "thiserror",
+]
+
+[[package]]
+name = "webrtc-sctp"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d47adcd9427eb3ede33d5a7f3424038f63c965491beafcc20bc650a2f6679c0"
+dependencies = [
+ "arc-swap",
+ "async-trait",
+ "bytes",
+ "crc",
+ "log",
+ "rand 0.8.5",
+ "thiserror",
+ "tokio",
+ "webrtc-util",
+]
+
+[[package]]
+name = "webrtc-srtp"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6183edc4c1c6c0175f8812eefdce84dfa0aea9c3ece71c2bf6ddd3c964de3da5"
+dependencies = [
+ "aead 0.4.3",
+ "aes 0.7.5",
+ "aes-gcm 0.9.4",
+ "async-trait",
+ "byteorder",
+ "bytes",
+ "ctr 0.8.0",
+ "hmac 0.11.0",
+ "log",
+ "rtcp",
+ "rtp",
+ "sha-1",
+ "subtle",
+ "thiserror",
+ "tokio",
+ "webrtc-util",
+]
+
+[[package]]
+name = "webrtc-util"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93f1db1727772c05cf7a2cfece52c3aca8045ca1e176cd517d323489aa3c6d87"
+dependencies = [
+ "async-trait",
+ "bitflags",
+ "bytes",
+ "cc",
+ "ipnet",
+ "lazy_static",
+ "libc",
+ "log",
+ "nix 0.24.3",
+ "rand 0.8.5",
+ "thiserror",
+ "tokio",
+ "winapi",
+]
+
+[[package]]
+name = "which"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
+dependencies = [
+ "either",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "wide"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cd0496a71f3cc6bc4bf0ed91346426a5099e93d89807e663162dc5a1069ff65"
+dependencies = [
+ "bytemuck",
+ "safe_arch",
+]
+
+[[package]]
+name = "widestring"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17882f045410753661207383517a6f62ec3dbeb6a4ed2acce01f0728238d1983"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45296b64204227616fdbf2614cefa4c236b98ee64dfaaaa435207ed99fe7829f"
+dependencies = [
+ "windows_aarch64_msvc 0.34.0",
+ "windows_i686_gnu 0.34.0",
+ "windows_i686_msvc 0.34.0",
+ "windows_x86_64_gnu 0.34.0",
+ "windows_x86_64_msvc 0.34.0",
+]
+
+[[package]]
+name = "windows"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
+dependencies = [
+ "windows-targets 0.48.0",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.0",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.0",
+ "windows_aarch64_msvc 0.48.0",
+ "windows_i686_gnu 0.48.0",
+ "windows_i686_msvc 0.48.0",
+ "windows_x86_64_gnu 0.48.0",
+ "windows_x86_64_gnullvm 0.48.0",
+ "windows_x86_64_msvc 0.48.0",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17cffbe740121affb56fad0fc0e421804adf0ae00891205213b5cecd30db881d"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2564fde759adb79129d9b4f54be42b32c89970c18ebf93124ca8870a498688ed"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cd9d32ba70453522332c14d38814bceeb747d80b3958676007acadd7e166956"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfce6deae227ee8d356d19effc141a509cc503dfd1f850622ec4b0f84428e1f4"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d19538ccc21819d01deaf88d6a17eae6596a12e9aafdbb97916fb49896d89de9"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
+[[package]]
+name = "winnow"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61de7bac303dc551fe038e2b3cef0f571087a47571ea6e79a87692ac99b99699"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "x25519-dalek"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a0c105152107e3b96f6a00a65e86ce82d9b125230e1c4302940eca58ff71f4f"
+dependencies = [
+ "curve25519-dalek 3.2.0",
+ "rand_core 0.5.1",
+ "zeroize",
+]
+
+[[package]]
+name = "x25519-dalek"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb66477291e7e8d2b0ff1bcb900bf29489a9692816d79874bea351e7a8b6de96"
+dependencies = [
+ "curve25519-dalek 4.0.0",
+ "rand_core 0.6.4",
+ "serde",
+ "zeroize",
+]
+
+[[package]]
+name = "x509-parser"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb9bace5b5589ffead1afb76e43e34cff39cd0f3ce7e170ae0c29e53b88eb1c"
+dependencies = [
+ "asn1-rs 0.3.1",
+ "base64 0.13.1",
+ "data-encoding",
+ "der-parser 7.0.0",
+ "lazy_static",
+ "nom",
+ "oid-registry 0.4.0",
+ "ring 0.16.20",
+ "rusticata-macros",
+ "thiserror",
+ "time 0.3.21",
+]
+
+[[package]]
+name = "x509-parser"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0ecbeb7b67ce215e40e3cc7f2ff902f94a223acf44995934763467e7b1febc8"
+dependencies = [
+ "asn1-rs 0.5.2",
+ "base64 0.13.1",
+ "data-encoding",
+ "der-parser 8.2.0",
+ "lazy_static",
+ "nom",
+ "oid-registry 0.6.1",
+ "rusticata-macros",
+ "thiserror",
+ "time 0.3.21",
+]
+
+[[package]]
+name = "xattr"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4686009f71ff3e5c4dbcf1a282d0a44db3f021ba69350cd42086b3e5f1c6985"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "yamux"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d9ba232399af1783a58d8eb26f6b5006fbefe2dc9ef36bd283324792d03ea5"
+dependencies = [
+ "futures",
+ "log",
+ "nohash-hasher",
+ "parking_lot 0.12.1",
+ "rand 0.8.5",
+ "static_assertions",
+]
+
+[[package]]
+name = "yansi"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
+
+[[package]]
+name = "yasna"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd"
+dependencies = [
+ "time 0.3.21",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.18",
+]
+
+[[package]]
+name = "zstd"
+version = "0.11.2+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4"
+dependencies = [
+ "zstd-safe 5.0.2+zstd.1.5.2",
+]
+
+[[package]]
+name = "zstd"
+version = "0.12.3+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76eea132fb024e0e13fd9c2f5d5d595d8a967aa72382ac2f9d39fcc95afd0806"
+dependencies = [
+ "zstd-safe 6.0.5+zstd.1.5.4",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "5.0.2+zstd.1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db"
+dependencies = [
+ "libc",
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "6.0.5+zstd.1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56d9e60b4b1758206c238a10165fbcae3ca37b01744e394c463463f6529d23b"
+dependencies = [
+ "libc",
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.8+zstd.1.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5556e6ee25d32df2586c098bbfa278803692a20d0ab9565e049480d52707ec8c"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
diff --git a/substrate/Cargo.toml b/substrate/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3585a5ecd3572c9d3ad54603a7dd841a32cd5173
--- /dev/null
+++ b/substrate/Cargo.toml
@@ -0,0 +1,390 @@
+[package]
+name = "substrate"
+description = "Next-generation framework for blockchain innovation"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+version = "0.0.0"
+
+# This list of dependencies is for documentation purposes only.
+[dependencies]
+aquamarine = "0.3.2"
+
+subkey = { path = "bin/utils/subkey" }
+chain-spec-builder = { path = "bin/utils/chain-spec-builder" }
+
+sc-service = { path = "client/service" }
+sc-cli = { path = "client/cli" }
+sc-consensus-aura = { path = "client/consensus/aura" }
+sc-consensus-babe = { path = "client/consensus/babe" }
+sc-consensus-grandpa = { path = "client/consensus/grandpa" }
+sc-consensus-beefy = { path = "client/consensus/beefy" }
+sc-consensus-manual-seal = { path = "client/consensus/manual-seal" }
+sc-consensus-pow = { path = "client/consensus/pow" }
+
+sp-runtime = { path = "primitives/runtime" }
+frame-support = { path = "frame/support" }
+
+node-cli = { path = "bin/node/cli" }
+
+# Exists here to be backwards compatible and to support `cargo run` in the workspace.
+#
+# Just uses the `node-cli` main binary. `node-cli` itself also again exposes the node as
+# `substrate-node`.
+
+# `cargo run` on its own doesn't support features. To use features you must explicitly use
+# `node-cli` in your command, e.g. `cargo run -p node-cli --features try-runtime ...`.
+[[bin]]
+name = "substrate"
+path = "bin/node/cli/bin/main.rs"
+
+[workspace]
+resolver = "2"
+
+members = [
+	"bin/node-template/node",
+	"bin/node-template/pallets/template",
+	"bin/node-template/runtime",
+	"bin/node/bench",
+	"bin/node/cli",
+	"bin/node/executor",
+	"bin/node/inspect",
+	"bin/node/primitives",
+	"bin/node/rpc",
+	"bin/node/runtime",
+	"bin/node/testing",
+	"bin/utils/chain-spec-builder",
+	"bin/utils/subkey",
+	"client/api",
+	"client/authority-discovery",
+	"client/basic-authorship",
+	"client/block-builder",
+	"client/chain-spec",
+	"client/chain-spec/derive",
+	"client/cli",
+	"client/consensus/aura",
+	"client/consensus/babe",
+	"client/consensus/babe/rpc",
+	"client/consensus/beefy",
+	"client/consensus/beefy/rpc",
+	"client/consensus/common",
+	"client/consensus/epochs",
+	"client/consensus/grandpa",
+	"client/consensus/grandpa/rpc",
+	"client/consensus/manual-seal",
+	"client/consensus/pow",
+	"client/consensus/slots",
+	"client/db",
+	"client/executor",
+	"client/executor/common",
+	"client/executor/runtime-test",
+	"client/executor/wasmtime",
+	"client/informant",
+	"client/keystore",
+	"client/merkle-mountain-range",
+	"client/merkle-mountain-range/rpc",
+	"client/network",
+	"client/network/transactions",
+	"client/network/statement",
+	"client/network-gossip",
+	"client/network/bitswap",
+	"client/network/common",
+	"client/network/light",
+	"client/network/sync",
+	"client/network/test",
+	"client/offchain",
+	"client/allocator",
+	"client/proposer-metrics",
+	"client/rpc",
+	"client/rpc-api",
+	"client/rpc-servers",
+	"client/rpc-spec-v2",
+	"client/service",
+	"client/service/test",
+	"client/state-db",
+	"client/statement-store",
+	"client/storage-monitor",
+	"client/sysinfo",
+	"client/sync-state-rpc",
+	"client/telemetry",
+	"client/tracing",
+	"client/tracing/proc-macro",
+	"client/transaction-pool",
+	"client/transaction-pool/api",
+	"client/utils",
+	"frame/alliance",
+	"frame/asset-conversion",
+	"frame/assets",
+	"frame/atomic-swap",
+	"frame/aura",
+	"frame/authority-discovery",
+	"frame/authorship",
+	"frame/babe",
+	"frame/bags-list",
+	"frame/bags-list/fuzzer",
+	"frame/bags-list/remote-tests",
+	"frame/balances",
+	"frame/beefy",
+	"frame/beefy-mmr",
+	"frame/benchmarking",
+	"frame/benchmarking/pov",
+	"frame/bounties",
+	"frame/broker",
+	"frame/child-bounties",
+	"frame/collective",
+	"frame/contracts",
+	"frame/contracts/proc-macro",
+	"frame/contracts/primitives",
+	"frame/conviction-voting",
+	"frame/core-fellowship",
+	"frame/democracy",
+	"frame/fast-unstake",
+	"frame/try-runtime",
+	"frame/elections-phragmen",
+	"frame/election-provider-multi-phase",
+	"frame/election-provider-multi-phase/test-staking-e2e",
+	"frame/election-provider-support",
+	"frame/election-provider-support/benchmarking",
+	"frame/election-provider-support/solution-type",
+	"frame/election-provider-support/solution-type/fuzzer",
+	"frame/examples",
+	"frame/examples/basic",
+	"frame/examples/offchain-worker",
+	"frame/examples/kitchensink",
+	"frame/examples/dev-mode",
+	"frame/examples/split",
+	"frame/examples/default-config",
+	"frame/executive",
+	"frame/nis",
+	"frame/grandpa",
+	"frame/identity",
+	"frame/im-online",
+	"frame/indices",
+	"frame/lottery",
+	"frame/membership",
+	"frame/merkle-mountain-range",
+	"frame/multisig",
+	"frame/nicks",
+	"frame/node-authorization",
+	"frame/offences",
+	"frame/offences/benchmarking",
+	"frame/preimage",
+	"frame/proxy",
+	"frame/message-queue",
+	"frame/nfts",
+	"frame/nfts/runtime-api",
+	"frame/nft-fractionalization",
+	"frame/nomination-pools",
+	"frame/nomination-pools/fuzzer",
+	"frame/nomination-pools/benchmarking",
+	"frame/nomination-pools/test-staking",
+	"frame/nomination-pools/runtime-api",
+	"frame/paged-list",
+	"frame/paged-list/fuzzer",
+	"frame/insecure-randomness-collective-flip",
+	"frame/ranked-collective",
+	"frame/recovery",
+	"frame/referenda",
+	"frame/remark",
+	"frame/tx-pause",
+	"frame/safe-mode",
+	"frame/salary",
+	"frame/scheduler",
+	"frame/scored-pool",
+	"frame/session",
+	"frame/session/benchmarking",
+	"frame/society",
+	"frame/staking",
+	"frame/staking/reward-curve",
+	"frame/staking/reward-fn",
+	"frame/staking/runtime-api",
+	"frame/state-trie-migration",
+	"frame/sudo",
+	"frame/root-offences",
+	"frame/root-testing",
+	"frame/statement",
+	"frame/support",
+	"frame/support/procedural",
+	"frame/support/procedural/tools",
+	"frame/support/procedural/tools/derive",
+	"frame/support/test",
+	"frame/support/test/compile_pass",
+	"frame/support/test/pallet",
+	"frame/system",
+	"frame/system/benchmarking",
+	"frame/system/rpc/runtime-api",
+	"frame/timestamp",
+	"frame/transaction-payment",
+	"frame/transaction-payment/asset-conversion-tx-payment",
+	"frame/transaction-payment/asset-tx-payment",
+	"frame/transaction-payment/rpc",
+	"frame/transaction-payment/rpc/runtime-api",
+	"frame/transaction-storage",
+	"frame/treasury",
+	"frame/asset-rate",
+	"frame/tips",
+	"frame/uniques",
+	"frame/utility",
+	"frame/vesting",
+	"frame/glutton",
+	"frame/whitelist",
+	"primitives/api",
+	"primitives/api/proc-macro",
+	"primitives/api/test",
+	"primitives/application-crypto",
+	"primitives/application-crypto/test",
+	"primitives/arithmetic",
+	"primitives/arithmetic/fuzzer",
+	"primitives/authority-discovery",
+	"primitives/block-builder",
+	"primitives/blockchain",
+	"primitives/consensus/aura",
+	"primitives/consensus/babe",
+	"primitives/consensus/beefy",
+	"primitives/consensus/common",
+	"primitives/consensus/grandpa",
+	"primitives/consensus/pow",
+	"primitives/consensus/slots",
+	"primitives/core",
+	"primitives/core/hashing",
+	"primitives/core/hashing/proc-macro",
+	"primitives/crypto/ec-utils",
+	"primitives/database",
+	"primitives/debug-derive",
+	"primitives/externalities",
+	"primitives/genesis-builder",
+	"primitives/inherents",
+	"primitives/io",
+	"primitives/keyring",
+	"primitives/keystore",
+	"primitives/maybe-compressed-blob",
+	"primitives/merkle-mountain-range",
+	"primitives/metadata-ir",
+	"primitives/npos-elections",
+	"primitives/npos-elections/fuzzer",
+	"primitives/offchain",
+	"primitives/panic-handler",
+	"primitives/rpc",
+	"primitives/runtime",
+	"primitives/runtime-interface",
+	"primitives/runtime-interface/proc-macro",
+	"primitives/runtime-interface/test",
+	"primitives/runtime-interface/test-wasm",
+	"primitives/runtime-interface/test-wasm-deprecated",
+	"primitives/session",
+	"primitives/staking",
+	"primitives/state-machine",
+	"primitives/statement-store",
+	"primitives/std",
+	"primitives/storage",
+	"primitives/test-primitives",
+	"primitives/timestamp",
+	"primitives/tracing",
+	"primitives/transaction-pool",
+	"primitives/transaction-storage-proof",
+	"primitives/trie",
+	"primitives/version",
+	"primitives/version/proc-macro",
+	"primitives/wasm-interface",
+	"primitives/weights",
+	"scripts/ci/node-template-release",
+	"test-utils",
+	"test-utils/cli",
+	"test-utils/client",
+	"test-utils/derive",
+	"test-utils/runtime",
+	"test-utils/runtime/client",
+	"test-utils/runtime/transaction-pool",
+	"test-utils/test-crate",
+	"utils/build-script-utils",
+	"utils/fork-tree",
+	"utils/frame/benchmarking-cli",
+	"utils/frame/remote-externalities",
+	"utils/frame/frame-utilities-cli",
+	"utils/frame/try-runtime/cli",
+	"utils/frame/rpc/state-trie-migration-rpc",
+	"utils/frame/rpc/support",
+	"utils/frame/rpc/system",
+	"utils/frame/generate-bags",
+	"utils/frame/generate-bags/node-runtime",
+	"utils/frame/rpc/client",
+	"utils/prometheus",
+	"utils/wasm-builder",
+	"utils/binary-merkle-tree",
+]
+
+# The list of dependencies below (which can be both direct and indirect dependencies) are crates
+# that are suspected to be CPU-intensive, and that are unlikely to require debugging (as some of
+# their debug info might be missing) or to require to be frequently recompiled. We compile these
+# dependencies with `opt-level=3` even in "dev" mode in order to make "dev" mode more usable.
+# The majority of these crates are cryptographic libraries.
+#
+# Note that this does **not** affect crates that depend on Substrate. In other words, if you add
+# a dependency on Substrate, you have to copy-paste this list in your own `Cargo.toml` (assuming
+# that you want the same list). This list is only relevant when running `cargo build` from within
+# the Substrate workspace.
+#
+# If you see an error mentioning "profile package spec ... did not match any packages", it
+# probably concerns this list.
+#
+# This list is ordered alphabetically.
+[profile.dev.package]
+blake2 = { opt-level = 3 }
+blake2b_simd = { opt-level = 3 }
+chacha20poly1305 = { opt-level = 3 }
+cranelift-codegen = { opt-level = 3 }
+cranelift-wasm = { opt-level = 3 }
+crc32fast = { opt-level = 3 }
+crossbeam-deque = { opt-level = 3 }
+crypto-mac = { opt-level = 3 }
+curve25519-dalek = { opt-level = 3 }
+ed25519-zebra = { opt-level = 3 }
+flate2 = { opt-level = 3 }
+futures-channel = { opt-level = 3 }
+hashbrown = { opt-level = 3 }
+hash-db = { opt-level = 3 }
+hmac = { opt-level = 3 }
+httparse = { opt-level = 3 }
+integer-sqrt = { opt-level = 3 }
+k256 = { opt-level = 3 }
+keccak = { opt-level = 3 }
+libm = { opt-level = 3 }
+librocksdb-sys = { opt-level = 3 }
+libsecp256k1 = { opt-level = 3 }
+libz-sys = { opt-level = 3 }
+mio = { opt-level = 3 }
+nalgebra = { opt-level = 3 }
+num-bigint = { opt-level = 3 }
+parking_lot = { opt-level = 3 }
+parking_lot_core = { opt-level = 3 }
+percent-encoding = { opt-level = 3 }
+primitive-types = { opt-level = 3 }
+ring = { opt-level = 3 }
+rustls = { opt-level = 3 }
+secp256k1 = { opt-level = 3 }
+sha2 = { opt-level = 3 }
+sha3 = { opt-level = 3 }
+smallvec = { opt-level = 3 }
+snow = { opt-level = 3 }
+twox-hash = { opt-level = 3 }
+uint = { opt-level = 3 }
+wasmi = { opt-level = 3 }
+x25519-dalek = { opt-level = 3 }
+yamux = { opt-level = 3 }
+zeroize = { opt-level = 3 }
+
+[profile.release]
+# Substrate runtime requires unwinding.
+panic = "unwind"
+
+[profile.production]
+inherits = "release"
+
+# Sacrifice compile speed for execution speed by using optimization flags:
+
+# https://doc.rust-lang.org/rustc/linker-plugin-lto.html
+lto = "fat"
+# https://doc.rust-lang.org/rustc/codegen-options/index.html#codegen-units
+codegen-units = 1
diff --git a/substrate/HEADER-APACHE2 b/substrate/HEADER-APACHE2
new file mode 100644
index 0000000000000000000000000000000000000000..ecd364a6d62e04426dfacd66558d067295f37caf
--- /dev/null
+++ b/substrate/HEADER-APACHE2
@@ -0,0 +1,16 @@
+// 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.
diff --git a/substrate/HEADER-GPL3 b/substrate/HEADER-GPL3
new file mode 100644
index 0000000000000000000000000000000000000000..b46a8f75295fe8e76fd344fd47f7a62e51783529
--- /dev/null
+++ b/substrate/HEADER-GPL3
@@ -0,0 +1,17 @@
+// 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/>.
diff --git a/substrate/LICENSE-APACHE2 b/substrate/LICENSE-APACHE2
new file mode 100644
index 0000000000000000000000000000000000000000..fbb0616d18b261c461b5a004f6bba6dda702ec09
--- /dev/null
+++ b/substrate/LICENSE-APACHE2
@@ -0,0 +1,211 @@
+                                Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+        Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+        stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+        that You distribute, all copyright, patent, trademark, and
+        attribution notices from the Source form of the Work,
+        excluding those notices that do not pertain to any part of
+        the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+        distribution, then any Derivative Works that You distribute must
+        include a readable copy of the attribution notices contained
+        within such NOTICE file, excluding those notices that do not
+        pertain to any part of the Derivative Works, in at least one
+        of the following places: within a NOTICE text file distributed
+        as part of the Derivative Works; within the Source form or
+        documentation, if provided along with the Derivative Works; or,
+        within a display generated by the Derivative Works, if and
+        wherever such third-party notices normally appear. The contents
+        of the NOTICE file are for informational purposes only and
+        do not modify the License. You may add Your own attribution
+        notices within Derivative Works that You distribute, alongside
+        or as an addendum to the NOTICE text from the Work, provided
+        that such additional attribution notices cannot be construed
+        as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+    To apply the Apache License to your work, attach the following
+    boilerplate notice, with the fields enclosed by brackets "[]"
+    replaced with your own identifying information. (Don't include
+    the brackets!)  The text should be enclosed in the appropriate
+    comment syntax for the file format. We also recommend that a
+    file or class name and description of purpose be included on the
+    same "printed page" as the copyright notice for easier
+    identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.
+
+                                    NOTE
+                            
+Individual files contain the following tag instead of the full license
+text.
+
+    SPDX-License-Identifier:  Apache-2.0
+
+This enables machine processing of license information based on the SPDX
+License Identifiers that are here available: http://spdx.org/licenses/
\ No newline at end of file
diff --git a/substrate/LICENSE-GPL3 b/substrate/LICENSE-GPL3
new file mode 100644
index 0000000000000000000000000000000000000000..2ba7526ee695722852efd2c162ea57f87e4fd54c
--- /dev/null
+++ b/substrate/LICENSE-GPL3
@@ -0,0 +1,700 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {one line to give the program's name and a brief idea of what it does.}
+    Copyright (C) {year}  {name of author}
+
+    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 <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    {project}  Copyright (C) {year}  {fullname}
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+
+                     "CLASSPATH" EXCEPTION TO THE GPL
+
+  Linking this library statically or dynamically with other modules is making 
+a combined work based on this library. Thus, the terms and conditions of the
+GNU General Public License cover the whole combination.
+
+  As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent modules,
+and to copy and distribute the resulting executable under terms of your
+choice, provided that you also meet, for each linked independent module,
+the terms and conditions of the license of that module. An independent
+module is a module which is not derived from or based on this library.
+If you modify this library, you may extend this exception to your version
+of the library, but you are not obligated to do so. If you do not wish to
+do so, delete this exception statement from your version.
+
+                                NOTE
+                                
+  Individual files contain the following tag instead of the full license text.
+
+    SPDX-License-Identifier:  GPL-3.0-or-later WITH Classpath-exception-2.0
+
+  This enables machine processing of license information based on the SPDX
+License Identifiers that are here available: http://spdx.org/licenses/
\ No newline at end of file
diff --git a/substrate/README.md b/substrate/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..59e0cff015d39c5d3bdbdb83668b81ab019a4112
--- /dev/null
+++ b/substrate/README.md
@@ -0,0 +1,13 @@
+Dear contributors and users,
+
+We would like to inform you that 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 a single new repository: [the Polkadot SDK](https://github.com/paritytech/polkadot-sdk). Go ahead and make sure to support us by giving a star �� to the new repo.
+
+By consolidating our codebase, we aim to enhance collaboration and provide a more efficient platform for future development.
+
+If you currently have an open pull request in any of the merged repositories, we kindly request that you resubmit your PR in the new repository. This will ensure that your contributions are considered within the updated context and enable us to review and merge them more effectively.
+
+We appreciate your understanding and ongoing support throughout this transition. Should you have any questions or require further assistance, please don't hesitate to [reach out to us](https://forum.polkadot.network/t/psa-parity-is-currently-working-on-merging-the-polkadot-stack-repositories-into-one-single-repository/2883).
+
+Best Regards,
+
+Parity Technologies
\ No newline at end of file
diff --git a/substrate/bin/node-template/.editorconfig b/substrate/bin/node-template/.editorconfig
new file mode 100644
index 0000000000000000000000000000000000000000..5adac74ca24b3422222b2cb886b2a50cd22b6d1b
--- /dev/null
+++ b/substrate/bin/node-template/.editorconfig
@@ -0,0 +1,16 @@
+root = true
+
+[*]
+indent_style=space
+indent_size=2
+tab_width=2
+end_of_line=lf
+charset=utf-8
+trim_trailing_whitespace=true
+insert_final_newline = true
+
+[*.{rs,toml}]
+indent_style=tab
+indent_size=tab
+tab_width=4
+max_line_length=100
diff --git a/substrate/bin/node-template/.envrc b/substrate/bin/node-template/.envrc
new file mode 100644
index 0000000000000000000000000000000000000000..3550a30f2de389e537ee40ca5e64a77dc185c79b
--- /dev/null
+++ b/substrate/bin/node-template/.envrc
@@ -0,0 +1 @@
+use flake
diff --git a/substrate/bin/node-template/LICENSE b/substrate/bin/node-template/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..ffa0b3f2df035abdd789f1f205357f7318bc5498
--- /dev/null
+++ b/substrate/bin/node-template/LICENSE
@@ -0,0 +1,16 @@
+MIT No Attribution
+
+Copyright Parity Technologies (UK) Ltd.
+
+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.
+
+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
diff --git a/substrate/bin/node-template/README.md b/substrate/bin/node-template/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..337facaaf089864b1eec753be19836ed97224540
--- /dev/null
+++ b/substrate/bin/node-template/README.md
@@ -0,0 +1,164 @@
+# Substrate Node Template
+
+A fresh [Substrate](https://substrate.io/) node, ready for hacking :rocket:
+
+A standalone version of this template is available for each release of Polkadot in the [Substrate Developer Hub Parachain Template](https://github.com/substrate-developer-hub/substrate-parachain-template/) repository.
+The parachain template is generated directly at each Polkadot release branch from the [Node Template in Substrate](https://github.com/paritytech/substrate/tree/master/bin/node-template) upstream
+
+It is usually best to use the stand-alone version to start a new project.
+All bugs, suggestions, and feature requests should be made upstream in the [Substrate](https://github.com/paritytech/substrate/tree/master/bin/node-template) repository.
+
+## Getting Started
+
+Depending on your operating system and Rust version, there might be additional packages required to compile this template.
+Check the [Install](https://docs.substrate.io/install/) instructions for your platform for the most common dependencies.
+Alternatively, you can use one of the [alternative installation](#alternatives-installations) options.
+
+### Build
+
+Use the following command to build the node without launching it:
+
+```sh
+cargo build --release
+```
+
+### Embedded Docs
+
+After you build the project, you can use the following command to explore its parameters and subcommands:
+
+```sh
+./target/release/node-template -h
+```
+
+You can generate and view the [Rust Docs](https://doc.rust-lang.org/cargo/commands/cargo-doc.html) for this template with this command:
+
+```sh
+cargo +nightly doc --open
+```
+
+### Single-Node Development Chain
+
+The following command starts a single-node development chain that doesn't persist state:
+
+```sh
+./target/release/node-template --dev
+```
+
+To purge the development chain's state, run the following command:
+
+```sh
+./target/release/node-template purge-chain --dev
+```
+
+To start the development chain with detailed logging, run the following command:
+
+```sh
+RUST_BACKTRACE=1 ./target/release/node-template -ldebug --dev
+```
+
+Development chains:
+
+- Maintain state in a `tmp` folder while the node is running.
+- Use the **Alice** and **Bob** accounts as default validator authorities.
+- Use the **Alice** account as the default `sudo` account.
+- Are preconfigured with a genesis state (`/node/src/chain_spec.rs`) that includes several prefunded development accounts.
+
+
+To persist chain state between runs, specify a base path by running a command similar to the following:
+
+```sh
+// Create a folder to use as the db base path
+$ mkdir my-chain-state
+
+// Use of that folder to store the chain state
+$ ./target/release/node-template --dev --base-path ./my-chain-state/
+
+// Check the folder structure created inside the base path after running the chain
+$ ls ./my-chain-state
+chains
+$ ls ./my-chain-state/chains/
+dev
+$ ls ./my-chain-state/chains/dev
+db keystore network
+```
+
+### Connect with Polkadot-JS Apps Front-End
+
+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 [polkadot-js/apps](https://github.com/polkadot-js/apps) repository.
+
+### Multi-Node Local Testnet
+
+If you want to see the multi-node consensus algorithm in action, see [Simulate a network](https://docs.substrate.io/tutorials/build-a-blockchain/simulate-network/).
+
+## Template Structure
+
+A Substrate project such as this consists of a number of components that are spread across a few directories.
+
+### Node
+
+A blockchain node is an application that allows users to participate in a blockchain network.
+Substrate-based blockchain nodes expose a number of capabilities:
+
+- Networking: Substrate nodes use the [`libp2p`](https://libp2p.io/) networking stack to allow the
+  nodes in the network to communicate with one another.
+- Consensus: Blockchains must have a way to come to [consensus](https://docs.substrate.io/fundamentals/consensus/) on the state of 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).
+- RPC Server: A remote procedure call (RPC) server is used to interact with Substrate nodes.
+
+There are several files in the `node` directory.
+Take special note of the following:
+
+- [`chain_spec.rs`](./node/src/chain_spec.rs): A [chain specification](https://docs.substrate.io/build/chain-spec/) is a source code file that defines a Substrate chain's initial (genesis) state.
+  Chain specifications are useful for development and testing, and critical when architecting the launch of a production chain.
+  Take note of the `development_config` and `testnet_genesis` functions,.
+  These functions are used to define the genesis state for the local development chain configuration.
+  These functions identify some [well-known accounts](https://docs.substrate.io/reference/command-line-tools/subkey/) and use them to configure the blockchain's initial state.
+- [`service.rs`](./node/src/service.rs): This file defines the node implementation.
+  Take note of the libraries that this file imports and the names of the functions it invokes.
+  In particular, there are references to consensus-related topics, such as the [block finalization and forks](https://docs.substrate.io/fundamentals/consensus/#finalization-and-forks) and other [consensus mechanisms](https://docs.substrate.io/fundamentals/consensus/#default-consensus-models) such as Aura for block authoring and GRANDPA for finality.
+
+
+
+### Runtime
+
+In Substrate, the terms "runtime" and "state transition function" are analogous.
+Both terms refer to the core logic of the blockchain that is responsible for validating blocks and executing the state changes they define.
+The Substrate project in this repository uses [FRAME](https://docs.substrate.io/learn/runtime-development/#frame) to construct a blockchain runtime.
+FRAME allows runtime developers to declare domain-specific logic in modules called "pallets".
+At the heart of FRAME is a helpful [macro language](https://docs.substrate.io/reference/frame-macros/) that makes it easy to create pallets and flexibly compose them to create blockchains that can address [a variety of needs](https://substrate.io/ecosystem/projects/).
+
+Review the [FRAME runtime implementation](./runtime/src/lib.rs) included in this template and note the following:
+
+- This file configures several pallets to include in the runtime.
+  Each pallet configuration is defined by a code block that begins with `impl $PALLET_NAME::Config for Runtime`.
+- The pallets are composed into a single runtime by way of the [`construct_runtime!`](https://paritytech.github.io/substrate/master/frame_support/macro.construct_runtime.html) macro, which is part of the [core FRAME pallet library](https://docs.substrate.io/reference/frame-pallets/#system-pallets).
+
+### Pallets
+
+The runtime in this project is constructed using many FRAME pallets that ship with [the Substrate repository](https://github.com/paritytech/substrate/tree/master/frame) and a template pallet that is [defined in the `pallets`](./pallets/template/src/lib.rs) directory.
+
+A FRAME pallet is comprised of a number of blockchain primitives, including:
+
+- Storage: FRAME defines a rich set of powerful [storage abstractions](https://docs.substrate.io/build/runtime-storage/) that makes it easy to use Substrate's efficient key-value database to manage the evolving state of a blockchain.
+- Dispatchables: FRAME pallets define special types of functions that can be invoked (dispatched) from outside of the runtime in order to update its state.
+- Events: Substrate uses [events](https://docs.substrate.io/build/events-and-errors/) to notify users of significant state changes.
+- Errors: When a dispatchable fails, it returns an error.
+
+Each pallet has its own `Config` trait which serves as a configuration interface to generically define the types and parameters it depends on.
+
+## Alternatives Installations
+
+Instead of installing dependencies and building this source directly, consider the following alternatives.
+
+### Nix
+
+Install [nix](https://nixos.org/) and
+[nix-direnv](https://github.com/nix-community/nix-direnv) for a fully plug-and-play
+experience for setting up the development environment.
+To get all the correct dependencies, activate direnv `direnv allow`.
+
+### Docker
+
+Please follow the [Substrate Docker instructions here](https://github.com/paritytech/substrate/blob/master/docker/README.md) to build the Docker container with the Substrate Node Template binary.
diff --git a/substrate/bin/node-template/docs/rust-setup.md b/substrate/bin/node-template/docs/rust-setup.md
new file mode 100644
index 0000000000000000000000000000000000000000..2755966e3ae0f8b6099314efc0da9ec03ae08508
--- /dev/null
+++ b/substrate/bin/node-template/docs/rust-setup.md
@@ -0,0 +1,225 @@
+---
+title: Installation
+---
+
+This guide is for reference only, please check the latest information on getting starting with Substrate 
+[here](https://docs.substrate.io/main-docs/install/).
+
+This page will guide you through the **2 steps** needed to prepare a computer for **Substrate** development.
+Since Substrate is built with [the Rust programming language](https://www.rust-lang.org/), the first
+thing you will need to do is prepare the computer for Rust development - these steps will vary based
+on the computer's operating system. Once Rust is configured, you will use its toolchains to interact
+with Rust projects; the commands for Rust's toolchains will be the same for all supported,
+Unix-based operating systems.
+
+## Build dependencies
+
+Substrate development is easiest on Unix-based operating systems like macOS or Linux. The examples
+in the [Substrate Docs](https://docs.substrate.io) use Unix-style terminals to demonstrate how to
+interact with Substrate from the command line.
+
+### Ubuntu/Debian
+
+Use a terminal shell to execute the following commands:
+
+```bash
+sudo apt update
+# May prompt for location information
+sudo apt install -y git clang curl libssl-dev llvm libudev-dev
+```
+
+### Arch Linux
+
+Run these commands from a terminal:
+
+```bash
+pacman -Syu --needed --noconfirm curl git clang
+```
+
+### Fedora
+
+Run these commands from a terminal:
+
+```bash
+sudo dnf update
+sudo dnf install clang curl git openssl-devel
+```
+
+### OpenSUSE
+
+Run these commands from a terminal:
+
+```bash
+sudo zypper install clang curl git openssl-devel llvm-devel libudev-devel
+```
+
+### macOS
+
+> **Apple M1 ARM**
+> If you have an Apple M1 ARM system on a chip, make sure that you have Apple Rosetta 2
+> installed through `softwareupdate --install-rosetta`. This is only needed to run the
+> `protoc` tool during the build. The build itself and the target binaries would remain native.
+
+Open the Terminal application and execute the following commands:
+
+```bash
+# Install Homebrew if necessary https://brew.sh/
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
+
+# Make sure Homebrew is up-to-date, install openssl
+brew update
+brew install openssl
+```
+
+### Windows
+
+**_PLEASE NOTE:_** Native Windows development of Substrate is _not_ very well supported! It is _highly_
+recommend to use [Windows Subsystem Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10)
+(WSL) and follow the instructions for [Ubuntu/Debian](#ubuntudebian).
+Please refer to the separate
+[guide for native Windows development](https://docs.substrate.io/main-docs/install/windows/).
+
+## Rust developer environment
+
+This guide uses <https://rustup.rs> installer and the `rustup` tool to manage the Rust toolchain.
+First install and configure `rustup`:
+
+```bash
+# Install
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+# Configure
+source ~/.cargo/env
+```
+
+Configure the Rust toolchain to default to the latest stable version, add nightly and the nightly wasm target:
+
+```bash
+rustup default stable
+rustup update
+rustup update nightly
+rustup target add wasm32-unknown-unknown --toolchain nightly
+```
+
+## Test your set-up
+
+Now the best way to ensure that you have successfully prepared a computer for Substrate
+development is to follow the steps in [our first Substrate tutorial](https://docs.substrate.io/tutorials/v3/create-your-first-substrate-chain/).
+
+## Troubleshooting Substrate builds
+
+Sometimes you can't get the Substrate node template
+to compile out of the box. Here are some tips to help you work through that.
+
+### Rust configuration check
+
+To see what Rust toolchain you are presently using, run:
+
+```bash
+rustup show
+```
+
+This will show something like this (Ubuntu example) output:
+
+```text
+Default host: x86_64-unknown-linux-gnu
+rustup home:  /home/user/.rustup
+
+installed toolchains
+--------------------
+
+stable-x86_64-unknown-linux-gnu (default)
+nightly-2020-10-06-x86_64-unknown-linux-gnu
+nightly-x86_64-unknown-linux-gnu
+
+installed targets for active toolchain
+--------------------------------------
+
+wasm32-unknown-unknown
+x86_64-unknown-linux-gnu
+
+active toolchain
+----------------
+
+stable-x86_64-unknown-linux-gnu (default)
+rustc 1.50.0 (cb75ad5db 2021-02-10)
+```
+
+As you can see above, the default toolchain is stable, and the
+`nightly-x86_64-unknown-linux-gnu` toolchain as well as its `wasm32-unknown-unknown` target is installed.
+You also see that `nightly-2020-10-06-x86_64-unknown-linux-gnu` is installed, but is not used unless explicitly defined as illustrated in the [specify your nightly version](#specifying-nightly-version)
+section.
+
+### WebAssembly compilation
+
+Substrate uses [WebAssembly](https://webassembly.org) (Wasm) to produce portable blockchain
+runtimes. You will need to configure your Rust compiler to use
+[`nightly` builds](https://doc.rust-lang.org/book/appendix-07-nightly-rust.html) to allow you to
+compile Substrate runtime code to the Wasm target.
+
+> There are upstream issues in Rust that need to be resolved before all of Substrate can use the stable Rust toolchain.
+> [This is our tracking issue](https://github.com/paritytech/substrate/issues/1252) if you're curious as to why and how this will be resolved.
+
+#### Latest nightly for Substrate `master`
+
+Developers who are building Substrate _itself_ should always use the latest bug-free versions of
+Rust stable and nightly. This is because the Substrate codebase follows the tip of Rust nightly,
+which means that changes in Substrate often depend on upstream changes in the Rust nightly compiler.
+To ensure your Rust compiler is always up to date, you should run:
+
+```bash
+rustup update
+rustup update nightly
+rustup target add wasm32-unknown-unknown --toolchain nightly
+```
+
+> NOTE: It may be necessary to occasionally rerun `rustup update` if a change in the upstream Substrate
+> codebase depends on a new feature of the Rust compiler. When you do this, both your nightly
+> and stable toolchains will be pulled to the most recent release, and for nightly, it is
+> generally _not_ expected to compile WASM without error (although it very often does).
+> Be sure to [specify your nightly version](#specifying-nightly-version) if you get WASM build errors
+> from `rustup` and [downgrade nightly as needed](#downgrading-rust-nightly).
+
+#### Rust nightly toolchain
+
+If you want to guarantee that your build works on your computer as you update Rust and other
+dependencies, you should use a specific Rust nightly version that is known to be
+compatible with the version of Substrate they are using; this version will vary from project to
+project and different projects may use different mechanisms to communicate this version to
+developers. For instance, the Polkadot client specifies this information in its
+[release notes](https://github.com/paritytech/polkadot/releases).
+
+```bash
+# Specify the specific nightly toolchain in the date below:
+rustup install nightly-<yyyy-MM-dd>
+```
+
+#### Wasm toolchain
+
+Now, configure the nightly version to work with the Wasm compilation target:
+
+```bash
+rustup target add wasm32-unknown-unknown --toolchain nightly-<yyyy-MM-dd>
+```
+
+### Specifying nightly version
+
+Use the `WASM_BUILD_TOOLCHAIN` environment variable to specify the Rust nightly version a Substrate
+project should use for Wasm compilation:
+
+```bash
+WASM_BUILD_TOOLCHAIN=nightly-<yyyy-MM-dd> cargo build --release
+```
+
+> Note that this only builds _the runtime_ with the specified nightly. The rest of project will be
+> compiled with **your default toolchain**, i.e. the latest installed stable toolchain.
+
+### Downgrading Rust nightly
+
+If your computer is configured to use the latest Rust nightly and you would like to downgrade to a
+specific nightly version, follow these steps:
+
+```bash
+rustup uninstall nightly
+rustup install nightly-<yyyy-MM-dd>
+rustup target add wasm32-unknown-unknown --toolchain nightly-<yyyy-MM-dd>
+```
diff --git a/substrate/bin/node-template/flake.lock b/substrate/bin/node-template/flake.lock
new file mode 100644
index 0000000000000000000000000000000000000000..60819f675d21bc9e90a3b4ddf213957fe7a9e5d6
--- /dev/null
+++ b/substrate/bin/node-template/flake.lock
@@ -0,0 +1,43 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "locked": {
+        "lastModified": 1678901627,
+        "narHash": "sha256-U02riOqrKKzwjsxc/400XnElV+UtPUQWpANPlyazjH0=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "93a2b84fc4b70d9e089d029deacc3583435c2ed6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1679262748,
+        "narHash": "sha256-DQCrrAFrkxijC6haUzOC5ZoFqpcv/tg2WxnyW3np1Cc=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "60c1d71f2ba4c80178ec84523c2ca0801522e0a6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/substrate/bin/node-template/flake.nix b/substrate/bin/node-template/flake.nix
new file mode 100644
index 0000000000000000000000000000000000000000..428efd09484ddec3905fef01f41569428a141714
--- /dev/null
+++ b/substrate/bin/node-template/flake.nix
@@ -0,0 +1,22 @@
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils, ... }: flake-utils.lib.eachDefaultSystem (system:
+    let
+      pkgs = import nixpkgs { inherit system; };
+    in
+    {
+      devShells.default = pkgs.mkShell {
+        packages = with pkgs; [
+          rustup
+          clang
+          protobuf
+        ];
+
+        LIBCLANG_PATH = "${pkgs.libclang.lib}/lib";
+      };
+    });
+}
diff --git a/substrate/bin/node-template/node/Cargo.toml b/substrate/bin/node-template/node/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6eb5b4df9c536d3a35b22e376233053ada9677d3
--- /dev/null
+++ b/substrate/bin/node-template/node/Cargo.toml
@@ -0,0 +1,88 @@
+[package]
+name = "node-template"
+version = "4.0.0-dev"
+description = "A fresh FRAME-based Substrate node, ready for hacking."
+authors = ["Substrate DevHub <https://github.com/substrate-developer-hub>"]
+homepage = "https://substrate.io/"
+edition = "2021"
+license = "MIT-0"
+publish = false
+repository = "https://github.com/substrate-developer-hub/substrate-node-template/"
+build = "build.rs"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[[bin]]
+name = "node-template"
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive"] }
+futures = { version = "0.3.21", features = ["thread-pool"]}
+
+sc-cli = { version = "0.10.0-dev", path = "../../../client/cli" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sc-executor = { version = "0.10.0-dev", path = "../../../client/executor" }
+sc-network = { version = "0.10.0-dev", path = "../../../client/network" }
+sc-service = { version = "0.10.0-dev", path = "../../../client/service" }
+sc-telemetry = { version = "4.0.0-dev", path = "../../../client/telemetry" }
+sc-transaction-pool = { version = "4.0.0-dev", path = "../../../client/transaction-pool" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../client/transaction-pool/api" }
+sc-offchain = { version = "4.0.0-dev", path = "../../../client/offchain" }
+sc-consensus-aura = { version = "0.10.0-dev", path = "../../../client/consensus/aura" }
+sp-consensus-aura = { version = "0.10.0-dev", path = "../../../primitives/consensus/aura" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-consensus-grandpa = { version = "0.10.0-dev", path = "../../../client/consensus/grandpa" }
+sp-consensus-grandpa = { version = "4.0.0-dev", path = "../../../primitives/consensus/grandpa" }
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+sp-timestamp = { version = "4.0.0-dev", path = "../../../primitives/timestamp" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
+pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-payment" }
+
+# These dependencies are used for the node template's RPCs
+jsonrpsee = { version = "0.16.2", features = ["server"] }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sc-rpc-api = { version = "0.10.0-dev", path = "../../../client/rpc-api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../../primitives/block-builder" }
+sc-basic-authorship = { version = "0.10.0-dev", path = "../../../client/basic-authorship" }
+substrate-frame-rpc-system = { version = "4.0.0-dev", path = "../../../utils/frame/rpc/system" }
+pallet-transaction-payment-rpc = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/rpc/" }
+
+# These dependencies are used for runtime benchmarking
+frame-benchmarking = { version = "4.0.0-dev", path = "../../../frame/benchmarking" }
+frame-benchmarking-cli = { version = "4.0.0-dev", path = "../../../utils/frame/benchmarking-cli" }
+
+# Local Dependencies
+node-template-runtime = { version = "4.0.0-dev", path = "../runtime" }
+
+# CLI-specific dependencies
+try-runtime-cli = { version = "0.10.0-dev", optional = true, path = "../../../utils/frame/try-runtime/cli" }
+
+[build-dependencies]
+substrate-build-script-utils = { version = "3.0.0", path = "../../../utils/build-script-utils" }
+
+[features]
+default = []
+# Dependencies that are only required if runtime benchmarking should be build.
+runtime-benchmarks = [
+	"frame-benchmarking-cli/runtime-benchmarks",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"node-template-runtime/runtime-benchmarks",
+	"sc-service/runtime-benchmarks",
+	"sp-runtime/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-system/try-runtime",
+	"node-template-runtime/try-runtime",
+	"pallet-transaction-payment/try-runtime",
+	"sp-runtime/try-runtime",
+	"try-runtime-cli/try-runtime",
+]
diff --git a/substrate/bin/node-template/node/build.rs b/substrate/bin/node-template/node/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e3bfe3116bf28dba1872f7d0b64c2ee0c9c71c3c
--- /dev/null
+++ b/substrate/bin/node-template/node/build.rs
@@ -0,0 +1,7 @@
+use substrate_build_script_utils::{generate_cargo_keys, rerun_if_git_head_changed};
+
+fn main() {
+	generate_cargo_keys();
+
+	rerun_if_git_head_changed();
+}
diff --git a/substrate/bin/node-template/node/src/benchmarking.rs b/substrate/bin/node-template/node/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6e29ad1a123118d953c1fad654bad9343fd8ca53
--- /dev/null
+++ b/substrate/bin/node-template/node/src/benchmarking.rs
@@ -0,0 +1,161 @@
+//! Setup code for [`super::command`] which would otherwise bloat that module.
+//!
+//! Should only be used for benchmarking as it may break in other contexts.
+
+use crate::service::FullClient;
+
+use node_template_runtime as runtime;
+use runtime::{AccountId, Balance, BalancesCall, SystemCall};
+use sc_cli::Result;
+use sc_client_api::BlockBackend;
+use sp_core::{Encode, Pair};
+use sp_inherents::{InherentData, InherentDataProvider};
+use sp_keyring::Sr25519Keyring;
+use sp_runtime::{OpaqueExtrinsic, SaturatedConversion};
+
+use std::{sync::Arc, time::Duration};
+
+/// Generates extrinsics for the `benchmark overhead` command.
+///
+/// Note: Should only be used for benchmarking.
+pub struct RemarkBuilder {
+	client: Arc<FullClient>,
+}
+
+impl RemarkBuilder {
+	/// Creates a new [`Self`] from the given client.
+	pub fn new(client: Arc<FullClient>) -> Self {
+		Self { client }
+	}
+}
+
+impl frame_benchmarking_cli::ExtrinsicBuilder for RemarkBuilder {
+	fn pallet(&self) -> &str {
+		"system"
+	}
+
+	fn extrinsic(&self) -> &str {
+		"remark"
+	}
+
+	fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
+		let acc = Sr25519Keyring::Bob.pair();
+		let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
+			self.client.as_ref(),
+			acc,
+			SystemCall::remark { remark: vec![] }.into(),
+			nonce,
+		)
+		.into();
+
+		Ok(extrinsic)
+	}
+}
+
+/// Generates `Balances::TransferKeepAlive` extrinsics for the benchmarks.
+///
+/// Note: Should only be used for benchmarking.
+pub struct TransferKeepAliveBuilder {
+	client: Arc<FullClient>,
+	dest: AccountId,
+	value: Balance,
+}
+
+impl TransferKeepAliveBuilder {
+	/// Creates a new [`Self`] from the given client.
+	pub fn new(client: Arc<FullClient>, dest: AccountId, value: Balance) -> Self {
+		Self { client, dest, value }
+	}
+}
+
+impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder {
+	fn pallet(&self) -> &str {
+		"balances"
+	}
+
+	fn extrinsic(&self) -> &str {
+		"transfer_keep_alive"
+	}
+
+	fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
+		let acc = Sr25519Keyring::Bob.pair();
+		let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic(
+			self.client.as_ref(),
+			acc,
+			BalancesCall::transfer_keep_alive { dest: self.dest.clone().into(), value: self.value }
+				.into(),
+			nonce,
+		)
+		.into();
+
+		Ok(extrinsic)
+	}
+}
+
+/// Create a transaction using the given `call`.
+///
+/// Note: Should only be used for benchmarking.
+pub fn create_benchmark_extrinsic(
+	client: &FullClient,
+	sender: sp_core::sr25519::Pair,
+	call: runtime::RuntimeCall,
+	nonce: u32,
+) -> runtime::UncheckedExtrinsic {
+	let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
+	let best_hash = client.chain_info().best_hash;
+	let best_block = client.chain_info().best_number;
+
+	let period = runtime::BlockHashCount::get()
+		.checked_next_power_of_two()
+		.map(|c| c / 2)
+		.unwrap_or(2) as u64;
+	let extra: runtime::SignedExtra = (
+		frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
+		frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
+		frame_system::CheckTxVersion::<runtime::Runtime>::new(),
+		frame_system::CheckGenesis::<runtime::Runtime>::new(),
+		frame_system::CheckEra::<runtime::Runtime>::from(sp_runtime::generic::Era::mortal(
+			period,
+			best_block.saturated_into(),
+		)),
+		frame_system::CheckNonce::<runtime::Runtime>::from(nonce),
+		frame_system::CheckWeight::<runtime::Runtime>::new(),
+		pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
+	);
+
+	let raw_payload = runtime::SignedPayload::from_raw(
+		call.clone(),
+		extra.clone(),
+		(
+			(),
+			runtime::VERSION.spec_version,
+			runtime::VERSION.transaction_version,
+			genesis_hash,
+			best_hash,
+			(),
+			(),
+			(),
+		),
+	);
+	let signature = raw_payload.using_encoded(|e| sender.sign(e));
+
+	runtime::UncheckedExtrinsic::new_signed(
+		call,
+		sp_runtime::AccountId32::from(sender.public()).into(),
+		runtime::Signature::Sr25519(signature),
+		extra,
+	)
+}
+
+/// Generates inherent data for the `benchmark overhead` command.
+///
+/// Note: Should only be used for benchmarking.
+pub fn inherent_benchmark_data() -> Result<InherentData> {
+	let mut inherent_data = InherentData::new();
+	let d = Duration::from_millis(0);
+	let timestamp = sp_timestamp::InherentDataProvider::new(d.into());
+
+	futures::executor::block_on(timestamp.provide_inherent_data(&mut inherent_data))
+		.map_err(|e| format!("creating inherent data: {:?}", e))?;
+	Ok(inherent_data)
+}
diff --git a/substrate/bin/node-template/node/src/chain_spec.rs b/substrate/bin/node-template/node/src/chain_spec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2cd2d0729302631699b895609538cb148fc41de4
--- /dev/null
+++ b/substrate/bin/node-template/node/src/chain_spec.rs
@@ -0,0 +1,158 @@
+use node_template_runtime::{
+	AccountId, AuraConfig, BalancesConfig, GrandpaConfig, RuntimeGenesisConfig, Signature,
+	SudoConfig, SystemConfig, WASM_BINARY,
+};
+use sc_service::ChainType;
+use sp_consensus_aura::sr25519::AuthorityId as AuraId;
+use sp_consensus_grandpa::AuthorityId as GrandpaId;
+use sp_core::{sr25519, Pair, Public};
+use sp_runtime::traits::{IdentifyAccount, Verify};
+
+// The URL for the telemetry server.
+// 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>;
+
+/// Generate a crypto pair from seed.
+pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+	TPublic::Pair::from_string(&format!("//{}", seed), None)
+		.expect("static values are valid; qed")
+		.public()
+}
+
+type AccountPublic = <Signature as Verify>::Signer;
+
+/// Generate an account ID from seed.
+pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
+where
+	AccountPublic: From<<TPublic::Pair as Pair>::Public>,
+{
+	AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
+}
+
+/// Generate an Aura authority key.
+pub fn authority_keys_from_seed(s: &str) -> (AuraId, GrandpaId) {
+	(get_from_seed::<AuraId>(s), get_from_seed::<GrandpaId>(s))
+}
+
+pub fn development_config() -> Result<ChainSpec, String> {
+	let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?;
+
+	Ok(ChainSpec::from_genesis(
+		// Name
+		"Development",
+		// ID
+		"dev",
+		ChainType::Development,
+		move || {
+			testnet_genesis(
+				wasm_binary,
+				// Initial PoA authorities
+				vec![authority_keys_from_seed("Alice")],
+				// Sudo account
+				get_account_id_from_seed::<sr25519::Public>("Alice"),
+				// Pre-funded accounts
+				vec![
+					get_account_id_from_seed::<sr25519::Public>("Alice"),
+					get_account_id_from_seed::<sr25519::Public>("Bob"),
+					get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
+					get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
+				],
+				true,
+			)
+		},
+		// Bootnodes
+		vec![],
+		// Telemetry
+		None,
+		// Protocol ID
+		None,
+		None,
+		// Properties
+		None,
+		// Extensions
+		None,
+	))
+}
+
+pub fn local_testnet_config() -> Result<ChainSpec, String> {
+	let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?;
+
+	Ok(ChainSpec::from_genesis(
+		// Name
+		"Local Testnet",
+		// ID
+		"local_testnet",
+		ChainType::Local,
+		move || {
+			testnet_genesis(
+				wasm_binary,
+				// Initial PoA authorities
+				vec![authority_keys_from_seed("Alice"), authority_keys_from_seed("Bob")],
+				// Sudo account
+				get_account_id_from_seed::<sr25519::Public>("Alice"),
+				// Pre-funded accounts
+				vec![
+					get_account_id_from_seed::<sr25519::Public>("Alice"),
+					get_account_id_from_seed::<sr25519::Public>("Bob"),
+					get_account_id_from_seed::<sr25519::Public>("Charlie"),
+					get_account_id_from_seed::<sr25519::Public>("Dave"),
+					get_account_id_from_seed::<sr25519::Public>("Eve"),
+					get_account_id_from_seed::<sr25519::Public>("Ferdie"),
+					get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
+					get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
+					get_account_id_from_seed::<sr25519::Public>("Charlie//stash"),
+					get_account_id_from_seed::<sr25519::Public>("Dave//stash"),
+					get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
+					get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
+				],
+				true,
+			)
+		},
+		// Bootnodes
+		vec![],
+		// Telemetry
+		None,
+		// Protocol ID
+		None,
+		// Properties
+		None,
+		None,
+		// Extensions
+		None,
+	))
+}
+
+/// Configure initial storage state for FRAME modules.
+fn testnet_genesis(
+	wasm_binary: &[u8],
+	initial_authorities: Vec<(AuraId, GrandpaId)>,
+	root_key: AccountId,
+	endowed_accounts: Vec<AccountId>,
+	_enable_println: bool,
+) -> RuntimeGenesisConfig {
+	RuntimeGenesisConfig {
+		system: SystemConfig {
+			// Add Wasm runtime to storage.
+			code: wasm_binary.to_vec(),
+			..Default::default()
+		},
+		balances: BalancesConfig {
+			// Configure endowed accounts with initial balance of 1 << 60.
+			balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 60)).collect(),
+		},
+		aura: AuraConfig {
+			authorities: initial_authorities.iter().map(|x| (x.0.clone())).collect(),
+		},
+		grandpa: GrandpaConfig {
+			authorities: initial_authorities.iter().map(|x| (x.1.clone(), 1)).collect(),
+			..Default::default()
+		},
+		sudo: SudoConfig {
+			// Assign network admin rights.
+			key: Some(root_key),
+		},
+		transaction_payment: Default::default(),
+	}
+}
diff --git a/substrate/bin/node-template/node/src/cli.rs b/substrate/bin/node-template/node/src/cli.rs
new file mode 100644
index 0000000000000000000000000000000000000000..98037eb886a8ec04ee78bc8f0b21b2269872d0fc
--- /dev/null
+++ b/substrate/bin/node-template/node/src/cli.rs
@@ -0,0 +1,51 @@
+use sc_cli::RunCmd;
+
+#[derive(Debug, clap::Parser)]
+pub struct Cli {
+	#[command(subcommand)]
+	pub subcommand: Option<Subcommand>,
+
+	#[clap(flatten)]
+	pub run: RunCmd,
+}
+
+#[derive(Debug, clap::Subcommand)]
+#[allow(clippy::large_enum_variant)]
+pub enum Subcommand {
+	/// Key management cli utilities
+	#[command(subcommand)]
+	Key(sc_cli::KeySubcommand),
+
+	/// Build a chain specification.
+	BuildSpec(sc_cli::BuildSpecCmd),
+
+	/// Validate blocks.
+	CheckBlock(sc_cli::CheckBlockCmd),
+
+	/// Export blocks.
+	ExportBlocks(sc_cli::ExportBlocksCmd),
+
+	/// Export the state of a given block into a chain spec.
+	ExportState(sc_cli::ExportStateCmd),
+
+	/// Import blocks.
+	ImportBlocks(sc_cli::ImportBlocksCmd),
+
+	/// Remove the whole chain.
+	PurgeChain(sc_cli::PurgeChainCmd),
+
+	/// Revert the chain to a previous state.
+	Revert(sc_cli::RevertCmd),
+
+	/// Sub-commands concerned with benchmarking.
+	#[command(subcommand)]
+	Benchmark(frame_benchmarking_cli::BenchmarkCmd),
+
+	/// Try-runtime has migrated to a standalone CLI
+	/// (<https://github.com/paritytech/try-runtime-cli>). The subcommand exists as a stub and
+	/// deprecation notice. It will be removed entirely some time after Janurary 2024.
+	TryRuntime,
+
+	/// Db meta columns information.
+	ChainInfo(sc_cli::ChainInfoCmd),
+}
diff --git a/substrate/bin/node-template/node/src/command.rs b/substrate/bin/node-template/node/src/command.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a25157693cd4392072703c28b14310f16dc01030
--- /dev/null
+++ b/substrate/bin/node-template/node/src/command.rs
@@ -0,0 +1,188 @@
+use crate::{
+	benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder},
+	chain_spec,
+	cli::{Cli, Subcommand},
+	service,
+};
+use frame_benchmarking_cli::{BenchmarkCmd, ExtrinsicFactory, SUBSTRATE_REFERENCE_HARDWARE};
+use node_template_runtime::{Block, EXISTENTIAL_DEPOSIT};
+use sc_cli::SubstrateCli;
+use sc_service::PartialComponents;
+use sp_keyring::Sr25519Keyring;
+
+impl SubstrateCli for Cli {
+	fn impl_name() -> String {
+		"Substrate Node".into()
+	}
+
+	fn impl_version() -> String {
+		env!("SUBSTRATE_CLI_IMPL_VERSION").into()
+	}
+
+	fn description() -> String {
+		env!("CARGO_PKG_DESCRIPTION").into()
+	}
+
+	fn author() -> String {
+		env!("CARGO_PKG_AUTHORS").into()
+	}
+
+	fn support_url() -> String {
+		"support.anonymous.an".into()
+	}
+
+	fn copyright_start_year() -> i32 {
+		2017
+	}
+
+	fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
+		Ok(match id {
+			"dev" => Box::new(chain_spec::development_config()?),
+			"" | "local" => Box::new(chain_spec::local_testnet_config()?),
+			path =>
+				Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?),
+		})
+	}
+}
+
+/// Parse and run command line arguments
+pub fn run() -> sc_cli::Result<()> {
+	let cli = Cli::from_args();
+
+	match &cli.subcommand {
+		Some(Subcommand::Key(cmd)) => cmd.run(&cli),
+		Some(Subcommand::BuildSpec(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
+		},
+		Some(Subcommand::CheckBlock(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, import_queue, .. } =
+					service::new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::ExportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
+				Ok((cmd.run(client, config.database), task_manager))
+			})
+		},
+		Some(Subcommand::ExportState(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?;
+				Ok((cmd.run(client, config.chain_spec), task_manager))
+			})
+		},
+		Some(Subcommand::ImportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, import_queue, .. } =
+					service::new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::PurgeChain(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.database))
+		},
+		Some(Subcommand::Revert(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, backend, .. } =
+					service::new_partial(&config)?;
+				let aux_revert = Box::new(|client, _, blocks| {
+					sc_consensus_grandpa::revert(client, blocks)?;
+					Ok(())
+				});
+				Ok((cmd.run(client, backend, Some(aux_revert)), task_manager))
+			})
+		},
+		Some(Subcommand::Benchmark(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+
+			runner.sync_run(|config| {
+				// This switch needs to be in the client, since the client decides
+				// which sub-commands it wants to support.
+				match cmd {
+					BenchmarkCmd::Pallet(cmd) => {
+						if !cfg!(feature = "runtime-benchmarks") {
+							return Err(
+								"Runtime benchmarking wasn't enabled when building the node. \
+							You can enable it with `--features runtime-benchmarks`."
+									.into(),
+							)
+						}
+
+						cmd.run::<Block, ()>(config)
+					},
+					BenchmarkCmd::Block(cmd) => {
+						let PartialComponents { client, .. } = service::new_partial(&config)?;
+						cmd.run(client)
+					},
+					#[cfg(not(feature = "runtime-benchmarks"))]
+					BenchmarkCmd::Storage(_) => Err(
+						"Storage benchmarking can be enabled with `--features runtime-benchmarks`."
+							.into(),
+					),
+					#[cfg(feature = "runtime-benchmarks")]
+					BenchmarkCmd::Storage(cmd) => {
+						let PartialComponents { client, backend, .. } =
+							service::new_partial(&config)?;
+						let db = backend.expose_db();
+						let storage = backend.expose_storage();
+
+						cmd.run(config, client, db, storage)
+					},
+					BenchmarkCmd::Overhead(cmd) => {
+						let PartialComponents { client, .. } = service::new_partial(&config)?;
+						let ext_builder = RemarkBuilder::new(client.clone());
+
+						cmd.run(
+							config,
+							client,
+							inherent_benchmark_data()?,
+							Vec::new(),
+							&ext_builder,
+						)
+					},
+					BenchmarkCmd::Extrinsic(cmd) => {
+						let PartialComponents { client, .. } = service::new_partial(&config)?;
+						// Register the *Remark* and *TKA* builders.
+						let ext_factory = ExtrinsicFactory(vec![
+							Box::new(RemarkBuilder::new(client.clone())),
+							Box::new(TransferKeepAliveBuilder::new(
+								client.clone(),
+								Sr25519Keyring::Alice.to_account_id(),
+								EXISTENTIAL_DEPOSIT,
+							)),
+						]);
+
+						cmd.run(client, inherent_benchmark_data()?, Vec::new(), &ext_factory)
+					},
+					BenchmarkCmd::Machine(cmd) =>
+						cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone()),
+				}
+			})
+		},
+		#[cfg(feature = "try-runtime")]
+		Some(Subcommand::TryRuntime) => Err(try_runtime_cli::DEPRECATION_NOTICE.into()),
+		#[cfg(not(feature = "try-runtime"))]
+		Some(Subcommand::TryRuntime) => Err("TryRuntime wasn't enabled when building the node. \
+				You can enable it with `--features try-runtime`."
+			.into()),
+		Some(Subcommand::ChainInfo(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run::<Block>(&config))
+		},
+		None => {
+			let runner = cli.create_runner(&cli.run)?;
+			runner.run_node_until_exit(|config| async move {
+				service::new_full(config).map_err(sc_cli::Error::Service)
+			})
+		},
+	}
+}
diff --git a/substrate/bin/node-template/node/src/main.rs b/substrate/bin/node-template/node/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..426cbabb6fbf7dc960f48736e092e0072984f23a
--- /dev/null
+++ b/substrate/bin/node-template/node/src/main.rs
@@ -0,0 +1,14 @@
+//! Substrate Node Template CLI library.
+#![warn(missing_docs)]
+
+mod chain_spec;
+#[macro_use]
+mod service;
+mod benchmarking;
+mod cli;
+mod command;
+mod rpc;
+
+fn main() -> sc_cli::Result<()> {
+	command::run()
+}
diff --git a/substrate/bin/node-template/node/src/rpc.rs b/substrate/bin/node-template/node/src/rpc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f4f1540f732f784317c3c657d170805a5f55c20e
--- /dev/null
+++ b/substrate/bin/node-template/node/src/rpc.rs
@@ -0,0 +1,57 @@
+//! A collection of node-specific RPC methods.
+//! Substrate provides the `sc-rpc` crate, which defines the core RPC layer
+//! used by Substrate nodes. This file extends those RPC definitions with
+//! capabilities that are specific to this project's runtime configuration.
+
+#![warn(missing_docs)]
+
+use std::sync::Arc;
+
+use jsonrpsee::RpcModule;
+use node_template_runtime::{opaque::Block, AccountId, Balance, Nonce};
+use sc_transaction_pool_api::TransactionPool;
+use sp_api::ProvideRuntimeApi;
+use sp_block_builder::BlockBuilder;
+use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
+
+pub use sc_rpc_api::DenyUnsafe;
+
+/// Full client dependencies.
+pub struct FullDeps<C, P> {
+	/// The client instance to use.
+	pub client: Arc<C>,
+	/// Transaction pool instance.
+	pub pool: Arc<P>,
+	/// Whether to deny unsafe calls
+	pub deny_unsafe: DenyUnsafe,
+}
+
+/// Instantiate all full RPC extensions.
+pub fn create_full<C, P>(
+	deps: FullDeps<C, P>,
+) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
+where
+	C: ProvideRuntimeApi<Block>,
+	C: HeaderBackend<Block> + HeaderMetadata<Block, Error = BlockChainError> + 'static,
+	C: Send + Sync + 'static,
+	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 + 'static,
+{
+	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
+	use substrate_frame_rpc_system::{System, SystemApiServer};
+
+	let mut module = RpcModule::new(());
+	let FullDeps { client, pool, deny_unsafe } = deps;
+
+	module.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?;
+	module.merge(TransactionPayment::new(client).into_rpc())?;
+
+	// Extend this RPC with a custom API by using the following syntax.
+	// `YourRpcStruct` should have a reference to a client, which is needed
+	// to call into the runtime.
+	// `module.merge(YourRpcTrait::into_rpc(YourRpcStruct::new(ReferenceToClient, ...)))?;`
+
+	Ok(module)
+}
diff --git a/substrate/bin/node-template/node/src/service.rs b/substrate/bin/node-template/node/src/service.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7303f5cd6dd6d2eb23131fb102ef11ae955f4806
--- /dev/null
+++ b/substrate/bin/node-template/node/src/service.rs
@@ -0,0 +1,336 @@
+//! Service and ServiceFactory implementation. Specialized wrapper over substrate service.
+
+use futures::FutureExt;
+use node_template_runtime::{self, opaque::Block, RuntimeApi};
+use sc_client_api::{Backend, BlockBackend};
+use sc_consensus_aura::{ImportQueueParams, SlotProportion, StartAuraParams};
+use sc_consensus_grandpa::SharedVoterState;
+pub use sc_executor::NativeElseWasmExecutor;
+use sc_service::{error::Error as ServiceError, Configuration, TaskManager, WarpSyncParams};
+use sc_telemetry::{Telemetry, TelemetryWorker};
+use sc_transaction_pool_api::OffchainTransactionPoolFactory;
+use sp_consensus_aura::sr25519::AuthorityPair as AuraPair;
+use std::{sync::Arc, time::Duration};
+
+// Our native executor instance.
+pub struct ExecutorDispatch;
+
+impl sc_executor::NativeExecutionDispatch for ExecutorDispatch {
+	/// Only enable the benchmarking host functions when we actually want to benchmark.
+	#[cfg(feature = "runtime-benchmarks")]
+	type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions;
+	/// Otherwise we only use the default Substrate host functions.
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	type ExtendHostFunctions = ();
+
+	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
+		node_template_runtime::api::dispatch(method, data)
+	}
+
+	fn native_version() -> sc_executor::NativeVersion {
+		node_template_runtime::native_version()
+	}
+}
+
+pub(crate) type FullClient =
+	sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<ExecutorDispatch>>;
+type FullBackend = sc_service::TFullBackend<Block>;
+type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
+
+/// The minimum period of blocks on which justifications will be
+/// imported and generated.
+const GRANDPA_JUSTIFICATION_PERIOD: u32 = 512;
+
+#[allow(clippy::type_complexity)]
+pub fn new_partial(
+	config: &Configuration,
+) -> Result<
+	sc_service::PartialComponents<
+		FullClient,
+		FullBackend,
+		FullSelectChain,
+		sc_consensus::DefaultImportQueue<Block>,
+		sc_transaction_pool::FullPool<Block, FullClient>,
+		(
+			sc_consensus_grandpa::GrandpaBlockImport<
+				FullBackend,
+				Block,
+				FullClient,
+				FullSelectChain,
+			>,
+			sc_consensus_grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+			Option<Telemetry>,
+		),
+	>,
+	ServiceError,
+> {
+	let telemetry = config
+		.telemetry_endpoints
+		.clone()
+		.filter(|x| !x.is_empty())
+		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+			let worker = TelemetryWorker::new(16)?;
+			let telemetry = worker.handle().new_telemetry(endpoints);
+			Ok((worker, telemetry))
+		})
+		.transpose()?;
+
+	let executor = sc_service::new_native_or_wasm_executor(config);
+	let (client, backend, keystore_container, task_manager) =
+		sc_service::new_full_parts::<Block, RuntimeApi, _>(
+			config,
+			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
+			executor,
+		)?;
+	let client = Arc::new(client);
+
+	let telemetry = telemetry.map(|(worker, telemetry)| {
+		task_manager.spawn_handle().spawn("telemetry", None, worker.run());
+		telemetry
+	});
+
+	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+	let transaction_pool = sc_transaction_pool::BasicPool::new_full(
+		config.transaction_pool.clone(),
+		config.role.is_authority().into(),
+		config.prometheus_registry(),
+		task_manager.spawn_essential_handle(),
+		client.clone(),
+	);
+
+	let (grandpa_block_import, grandpa_link) = sc_consensus_grandpa::block_import(
+		client.clone(),
+		GRANDPA_JUSTIFICATION_PERIOD,
+		&client,
+		select_chain.clone(),
+		telemetry.as_ref().map(|x| x.handle()),
+	)?;
+
+	let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
+
+	let import_queue =
+		sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(ImportQueueParams {
+			block_import: grandpa_block_import.clone(),
+			justification_import: Some(Box::new(grandpa_block_import.clone())),
+			client: client.clone(),
+			create_inherent_data_providers: move |_, ()| async move {
+				let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
+
+				let slot =
+					sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
+						*timestamp,
+						slot_duration,
+					);
+
+				Ok((slot, timestamp))
+			},
+			spawner: &task_manager.spawn_essential_handle(),
+			registry: config.prometheus_registry(),
+			check_for_equivocation: Default::default(),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+			compatibility_mode: Default::default(),
+		})?;
+
+	Ok(sc_service::PartialComponents {
+		client,
+		backend,
+		task_manager,
+		import_queue,
+		keystore_container,
+		select_chain,
+		transaction_pool,
+		other: (grandpa_block_import, grandpa_link, telemetry),
+	})
+}
+
+/// Builds a new service for a full client.
+pub fn new_full(config: Configuration) -> Result<TaskManager, ServiceError> {
+	let sc_service::PartialComponents {
+		client,
+		backend,
+		mut task_manager,
+		import_queue,
+		keystore_container,
+		select_chain,
+		transaction_pool,
+		other: (block_import, grandpa_link, mut telemetry),
+	} = new_partial(&config)?;
+
+	let mut net_config = sc_network::config::FullNetworkConfiguration::new(&config.network);
+
+	let grandpa_protocol_name = sc_consensus_grandpa::protocol_standard_name(
+		&client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"),
+		&config.chain_spec,
+	);
+	net_config.add_notification_protocol(sc_consensus_grandpa::grandpa_peers_set_config(
+		grandpa_protocol_name.clone(),
+	));
+
+	let warp_sync = Arc::new(sc_consensus_grandpa::warp_proof::NetworkProvider::new(
+		backend.clone(),
+		grandpa_link.shared_authority_set().clone(),
+		Vec::default(),
+	));
+
+	let (network, system_rpc_tx, tx_handler_controller, network_starter, sync_service) =
+		sc_service::build_network(sc_service::BuildNetworkParams {
+			config: &config,
+			net_config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			block_announce_validator_builder: None,
+			warp_sync_params: Some(WarpSyncParams::WithProvider(warp_sync)),
+		})?;
+
+	if config.offchain_worker.enabled {
+		task_manager.spawn_handle().spawn(
+			"offchain-workers-runner",
+			"offchain-worker",
+			sc_offchain::OffchainWorkers::new(sc_offchain::OffchainWorkerOptions {
+				runtime_api_provider: client.clone(),
+				is_validator: config.role.is_authority(),
+				keystore: Some(keystore_container.keystore()),
+				offchain_db: backend.offchain_storage(),
+				transaction_pool: Some(OffchainTransactionPoolFactory::new(
+					transaction_pool.clone(),
+				)),
+				network_provider: network.clone(),
+				enable_http_requests: true,
+				custom_extensions: |_| vec![],
+			})
+			.run(client.clone(), task_manager.spawn_handle())
+			.boxed(),
+		);
+	}
+
+	let role = config.role.clone();
+	let force_authoring = config.force_authoring;
+	let backoff_authoring_blocks: Option<()> = None;
+	let name = config.network.node_name.clone();
+	let enable_grandpa = !config.disable_grandpa;
+	let prometheus_registry = config.prometheus_registry().cloned();
+
+	let rpc_extensions_builder = {
+		let client = client.clone();
+		let pool = transaction_pool.clone();
+
+		Box::new(move |deny_unsafe, _| {
+			let deps =
+				crate::rpc::FullDeps { client: client.clone(), pool: pool.clone(), deny_unsafe };
+			crate::rpc::create_full(deps).map_err(Into::into)
+		})
+	};
+
+	let _rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+		network: network.clone(),
+		client: client.clone(),
+		keystore: keystore_container.keystore(),
+		task_manager: &mut task_manager,
+		transaction_pool: transaction_pool.clone(),
+		rpc_builder: rpc_extensions_builder,
+		backend,
+		system_rpc_tx,
+		tx_handler_controller,
+		sync_service: sync_service.clone(),
+		config,
+		telemetry: telemetry.as_mut(),
+	})?;
+
+	if role.is_authority() {
+		let proposer_factory = sc_basic_authorship::ProposerFactory::new(
+			task_manager.spawn_handle(),
+			client.clone(),
+			transaction_pool.clone(),
+			prometheus_registry.as_ref(),
+			telemetry.as_ref().map(|x| x.handle()),
+		);
+
+		let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
+
+		let aura = sc_consensus_aura::start_aura::<AuraPair, _, _, _, _, _, _, _, _, _, _>(
+			StartAuraParams {
+				slot_duration,
+				client,
+				select_chain,
+				block_import,
+				proposer_factory,
+				create_inherent_data_providers: move |_, ()| async move {
+					let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
+
+					let slot =
+						sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
+							*timestamp,
+							slot_duration,
+						);
+
+					Ok((slot, timestamp))
+				},
+				force_authoring,
+				backoff_authoring_blocks,
+				keystore: keystore_container.keystore(),
+				sync_oracle: sync_service.clone(),
+				justification_sync_link: sync_service.clone(),
+				block_proposal_slot_portion: SlotProportion::new(2f32 / 3f32),
+				max_block_proposal_slot_portion: None,
+				telemetry: telemetry.as_ref().map(|x| x.handle()),
+				compatibility_mode: Default::default(),
+			},
+		)?;
+
+		// the AURA authoring task is considered essential, i.e. if it
+		// fails we take down the service with it.
+		task_manager
+			.spawn_essential_handle()
+			.spawn_blocking("aura", Some("block-authoring"), aura);
+	}
+
+	if enable_grandpa {
+		// if the node isn't actively participating in consensus then it doesn't
+		// need a keystore, regardless of which protocol we use below.
+		let keystore = if role.is_authority() { Some(keystore_container.keystore()) } else { None };
+
+		let grandpa_config = sc_consensus_grandpa::Config {
+			// FIXME #1578 make this available through chainspec
+			gossip_duration: Duration::from_millis(333),
+			justification_generation_period: GRANDPA_JUSTIFICATION_PERIOD,
+			name: Some(name),
+			observer_enabled: false,
+			keystore,
+			local_role: role,
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+			protocol_name: grandpa_protocol_name,
+		};
+
+		// start the full GRANDPA voter
+		// NOTE: non-authorities could run the GRANDPA observer protocol, but at
+		// this point the full voter should provide better guarantees of block
+		// and vote data availability than the observer. The observer has not
+		// been tested extensively yet and having most nodes in a network run it
+		// could lead to finality stalls.
+		let grandpa_config = sc_consensus_grandpa::GrandpaParams {
+			config: grandpa_config,
+			link: grandpa_link,
+			network,
+			sync: Arc::new(sync_service),
+			voting_rule: sc_consensus_grandpa::VotingRulesBuilder::default().build(),
+			prometheus_registry,
+			shared_voter_state: SharedVoterState::empty(),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool),
+		};
+
+		// the GRANDPA voter task is considered infallible, i.e.
+		// if it fails we take down the service with it.
+		task_manager.spawn_essential_handle().spawn_blocking(
+			"grandpa-voter",
+			None,
+			sc_consensus_grandpa::run_grandpa_voter(grandpa_config)?,
+		);
+	}
+
+	network_starter.start_network();
+	Ok(task_manager)
+}
diff --git a/substrate/bin/node-template/pallets/template/Cargo.toml b/substrate/bin/node-template/pallets/template/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ba108cd0052fe8adc1d04bcd6f0914d6c26e74e8
--- /dev/null
+++ b/substrate/bin/node-template/pallets/template/Cargo.toml
@@ -0,0 +1,53 @@
+[package]
+name = "pallet-template"
+version = "4.0.0-dev"
+description = "FRAME pallet template for defining custom runtime logic."
+authors = ["Substrate DevHub <https://github.com/substrate-developer-hub>"]
+homepage = "https://substrate.io"
+edition = "2021"
+license = "MIT-0"
+publish = false
+repository = "https://github.com/substrate-developer-hub/substrate-node-template/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../../../../frame/benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../../../frame/support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../../../frame/system" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../../../primitives/io" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/bin/node-template/pallets/template/README.md b/substrate/bin/node-template/pallets/template/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d0d59537c12d7ef6490562eb4560d67506082a41
--- /dev/null
+++ b/substrate/bin/node-template/pallets/template/README.md
@@ -0,0 +1 @@
+License: MIT-0
\ No newline at end of file
diff --git a/substrate/bin/node-template/pallets/template/src/benchmarking.rs b/substrate/bin/node-template/pallets/template/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c3cae6066b41982af15a56098bcec62080c4e47
--- /dev/null
+++ b/substrate/bin/node-template/pallets/template/src/benchmarking.rs
@@ -0,0 +1,36 @@
+//! Benchmarking setup for pallet-template
+#![cfg(feature = "runtime-benchmarks")]
+use super::*;
+use sp_std::vec;
+
+#[allow(unused)]
+use crate::Pallet as Template;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn do_something() {
+		let value = 100u32.into();
+		let caller: T::AccountId = whitelisted_caller();
+		#[extrinsic_call]
+		do_something(RawOrigin::Signed(caller), value);
+
+		assert_eq!(Something::<T>::get(), Some(value));
+	}
+
+	#[benchmark]
+	fn cause_error() {
+		Something::<T>::put(100u32);
+		let caller: T::AccountId = whitelisted_caller();
+		#[extrinsic_call]
+		cause_error(RawOrigin::Signed(caller));
+
+		assert_eq!(Something::<T>::get(), Some(101u32));
+	}
+
+	impl_benchmark_test_suite!(Template, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/bin/node-template/pallets/template/src/lib.rs b/substrate/bin/node-template/pallets/template/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..edf7769bab7d3e852256b2d338c565b28117a600
--- /dev/null
+++ b/substrate/bin/node-template/pallets/template/src/lib.rs
@@ -0,0 +1,108 @@
+#![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/reference/frame-pallets/>
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Configure the pallet by specifying the parameters and types on which it depends.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Because this pallet emits events, it depends on the runtime's definition of an event.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// Type representing the weight of this pallet
+		type WeightInfo: WeightInfo;
+	}
+
+	// The pallet's runtime storage items.
+	// https://docs.substrate.io/main-docs/build/runtime-storage/
+	#[pallet::storage]
+	#[pallet::getter(fn something)]
+	// Learn more about declaring storage items:
+	// https://docs.substrate.io/main-docs/build/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/main-docs/build/events-errors/
+	#[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 { something: u32, who: T::AccountId },
+	}
+
+	// Errors inform users that something went wrong.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Error names should be descriptive.
+		NoneValue,
+		/// Errors should have helpful documentation associated with them.
+		StorageOverflow,
+	}
+
+	// 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.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// An example dispatchable that takes a singles value as a parameter, writes the value to
+		/// storage and emits an event. This function must be dispatched by a signed extrinsic.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::do_something())]
+		pub fn do_something(origin: OriginFor<T>, something: u32) -> DispatchResult {
+			// 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/main-docs/build/origins/
+			let who = ensure_signed(origin)?;
+
+			// Update storage.
+			<Something<T>>::put(something);
+
+			// Emit an event.
+			Self::deposit_event(Event::SomethingStored { something, who });
+			// Return a successful DispatchResultWithPostInfo
+			Ok(())
+		}
+
+		/// An example dispatchable that may throw a custom error.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::cause_error())]
+		pub fn cause_error(origin: OriginFor<T>) -> DispatchResult {
+			let _who = ensure_signed(origin)?;
+
+			// Read a value from storage.
+			match <Something<T>>::get() {
+				// Return an error if the value has not been set.
+				None => Err(Error::<T>::NoneValue.into()),
+				Some(old) => {
+					// Increment the value read from storage; will error in the event of overflow.
+					let new = old.checked_add(1).ok_or(Error::<T>::StorageOverflow)?;
+					// Update the value in storage with the incremented result.
+					<Something<T>>::put(new);
+					Ok(())
+				},
+			}
+		}
+	}
+}
diff --git a/substrate/bin/node-template/pallets/template/src/mock.rs b/substrate/bin/node-template/pallets/template/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..244ae1b37859ba4405221459d66c4b1298eeca89
--- /dev/null
+++ b/substrate/bin/node-template/pallets/template/src/mock.rs
@@ -0,0 +1,54 @@
+use crate as pallet_template;
+use frame_support::traits::{ConstU16, ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// Configure a mock runtime to test the pallet.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		TemplateModule: pallet_template,
+	}
+);
+
+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 {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+}
+
+// Build genesis storage according to the mock runtime.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
diff --git a/substrate/bin/node-template/pallets/template/src/tests.rs b/substrate/bin/node-template/pallets/template/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c2b853ee4dc56fdf526a17557fe37281a50e803
--- /dev/null
+++ b/substrate/bin/node-template/pallets/template/src/tests.rs
@@ -0,0 +1,27 @@
+use crate::{mock::*, Error, Event};
+use frame_support::{assert_noop, assert_ok};
+
+#[test]
+fn it_works_for_default_value() {
+	new_test_ext().execute_with(|| {
+		// Go past genesis block so events get deposited
+		System::set_block_number(1);
+		// Dispatch a signed extrinsic.
+		assert_ok!(TemplateModule::do_something(RuntimeOrigin::signed(1), 42));
+		// Read pallet storage and assert an expected result.
+		assert_eq!(TemplateModule::something(), Some(42));
+		// Assert that the correct event was deposited
+		System::assert_last_event(Event::SomethingStored { something: 42, who: 1 }.into());
+	});
+}
+
+#[test]
+fn correct_error_for_none_value() {
+	new_test_ext().execute_with(|| {
+		// Ensure the expected error is thrown when no value is present.
+		assert_noop!(
+			TemplateModule::cause_error(RuntimeOrigin::signed(1)),
+			Error::<Test>::NoneValue
+		);
+	});
+}
diff --git a/substrate/bin/node-template/pallets/template/src/weights.rs b/substrate/bin/node-template/pallets/template/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c42936e09f292de831d28460a3bc39436c3323f
--- /dev/null
+++ b/substrate/bin/node-template/pallets/template/src/weights.rs
@@ -0,0 +1,90 @@
+
+//! Autogenerated weights for pallet_template
+//!
+//! 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>`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ../../target/release/node-template
+// benchmark
+// pallet
+// --chain
+// dev
+// --pallet
+// pallet_template
+// --extrinsic
+// *
+// --steps=50
+// --repeat=20
+// --wasm-execution=compiled
+// --output
+// pallets/template/src/weights.rs
+// --template
+// ../../.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_template.
+pub trait WeightInfo {
+	fn do_something() -> Weight;
+	fn cause_error() -> Weight;
+}
+
+/// Weights for pallet_template using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: TemplateModule Something (r:0 w:1)
+	/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn do_something() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_000_000 picoseconds.
+		Weight::from_parts(9_000_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: TemplateModule Something (r:1 w:1)
+	/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn cause_error() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32`
+		//  Estimated: `1489`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(6_000_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: TemplateModule Something (r:0 w:1)
+	/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn do_something() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_000_000 picoseconds.
+		Weight::from_parts(9_000_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: TemplateModule Something (r:1 w:1)
+	/// Proof: TemplateModule Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn cause_error() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32`
+		//  Estimated: `1489`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(6_000_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/bin/node-template/runtime/Cargo.toml b/substrate/bin/node-template/runtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5f4411df5411004bfb4e908ec2784ecc7f07770e
--- /dev/null
+++ b/substrate/bin/node-template/runtime/Cargo.toml
@@ -0,0 +1,119 @@
+[package]
+name = "node-template-runtime"
+version = "4.0.0-dev"
+description = "A fresh FRAME-based Substrate node, ready for hacking."
+authors = ["Substrate DevHub <https://github.com/substrate-developer-hub>"]
+homepage = "https://substrate.io/"
+edition = "2021"
+license = "MIT-0"
+publish = false
+repository = "https://github.com/substrate-developer-hub/substrate-node-template/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+pallet-aura = { version = "4.0.0-dev", default-features = false, path = "../../../frame/aura" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../../frame/balances" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../../frame/support" }
+pallet-grandpa = { version = "4.0.0-dev", default-features = false, path = "../../../frame/grandpa" }
+pallet-sudo = { version = "4.0.0-dev", default-features = false, path = "../../../frame/sudo" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../../frame/system" }
+frame-try-runtime = { version = "0.10.0-dev", default-features = false, path = "../../../frame/try-runtime", optional = true }
+pallet-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../../frame/timestamp" }
+pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-payment" }
+frame-executive = { version = "4.0.0-dev", default-features = false, path = "../../../frame/executive" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/api" }
+sp-block-builder = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/block-builder"}
+sp-consensus-aura = { version = "0.10.0-dev", default-features = false, path = "../../../primitives/consensus/aura" }
+sp-consensus-grandpa = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/consensus/grandpa" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/inherents"}
+sp-offchain = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/offchain" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/session" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+sp-storage = { version = "13.0.0", default-features = false, path = "../../../primitives/storage" }
+sp-transaction-pool = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/transaction-pool" }
+sp-version = { version = "22.0.0", default-features = false, path = "../../../primitives/version" }
+
+# Used for the node template's RPCs
+frame-system-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/system/rpc/runtime-api/" }
+pallet-transaction-payment-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-payment/rpc/runtime-api/" }
+
+# Used for runtime benchmarking
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../../frame/benchmarking", optional = true }
+frame-system-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../../frame/system/benchmarking", optional = true }
+
+# Local Dependencies
+pallet-template = { version = "4.0.0-dev", default-features = false, path = "../pallets/template" }
+
+[build-dependencies]
+substrate-wasm-builder = { version = "5.0.0-dev", path = "../../../utils/wasm-builder", optional = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-executive/std",
+	"frame-support/std",
+	"frame-system-benchmarking?/std",
+	"frame-system-rpc-runtime-api/std",
+	"frame-system/std",
+	"frame-try-runtime/std",
+	"frame-try-runtime?/std",
+	"pallet-aura/std",
+	"pallet-balances/std",
+	"pallet-grandpa/std",
+	"pallet-sudo/std",
+	"pallet-template/std",
+	"pallet-timestamp/std",
+	"pallet-transaction-payment-rpc-runtime-api/std",
+	"pallet-transaction-payment/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-block-builder/std",
+	"sp-consensus-aura/std",
+	"sp-consensus-grandpa/std",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-offchain/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-std/std",
+	"sp-storage/std",
+	"sp-transaction-pool/std",
+	"sp-version/std",
+	"substrate-wasm-builder",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system-benchmarking/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-grandpa/runtime-benchmarks",
+	"pallet-sudo/runtime-benchmarks",
+	"pallet-template/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-executive/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"frame-try-runtime/try-runtime",
+	"pallet-aura/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-grandpa/try-runtime",
+	"pallet-sudo/try-runtime",
+	"pallet-template/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"pallet-transaction-payment/try-runtime",
+	"sp-runtime/try-runtime",
+]
+experimental = [ "pallet-aura/experimental" ]
diff --git a/substrate/bin/node-template/runtime/build.rs b/substrate/bin/node-template/runtime/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c03d618535be03e94d4d48aacfedb674847e4646
--- /dev/null
+++ b/substrate/bin/node-template/runtime/build.rs
@@ -0,0 +1,10 @@
+fn main() {
+	#[cfg(feature = "std")]
+	{
+		substrate_wasm_builder::WasmBuilder::new()
+			.with_current_project()
+			.export_heap_base()
+			.import_memory()
+			.build();
+	}
+}
diff --git a/substrate/bin/node-template/runtime/src/lib.rs b/substrate/bin/node-template/runtime/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..216be9588bca1ad936a4a5941a24c100b79e22e6
--- /dev/null
+++ b/substrate/bin/node-template/runtime/src/lib.rs
@@ -0,0 +1,574 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256.
+#![recursion_limit = "256"]
+
+// Make the WASM binary available.
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+use pallet_grandpa::AuthorityId as GrandpaId;
+use sp_api::impl_runtime_apis;
+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, IdentifyAccount, NumberFor, One, Verify,
+	},
+	transaction_validity::{TransactionSource, TransactionValidity},
+	ApplyExtrinsicResult, MultiSignature,
+};
+use sp_std::prelude::*;
+#[cfg(feature = "std")]
+use sp_version::NativeVersion;
+use sp_version::RuntimeVersion;
+
+// A few exports that help ease life for downstream crates.
+pub use frame_support::{
+	construct_runtime, parameter_types,
+	traits::{
+		ConstBool, ConstU128, ConstU32, ConstU64, ConstU8, KeyOwnerProofSystem, Randomness,
+		StorageInfo,
+	},
+	weights::{
+		constants::{
+			BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_REF_TIME_PER_SECOND,
+		},
+		IdentityFee, Weight,
+	},
+	StorageValue,
+};
+pub use frame_system::Call as SystemCall;
+pub use pallet_balances::Call as BalancesCall;
+pub use pallet_timestamp::Call as TimestampCall;
+use pallet_transaction_payment::{ConstFeeMultiplier, CurrencyAdapter, Multiplier};
+#[cfg(any(feature = "std", test))]
+pub use sp_runtime::BuildStorage;
+pub use sp_runtime::{Perbill, Permill};
+
+/// Import the template pallet.
+pub use pallet_template;
+
+/// An index to a block.
+pub type BlockNumber = u32;
+
+/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
+pub type Signature = MultiSignature;
+
+/// Some way of identifying an account on the chain. We intentionally make it equivalent
+/// to the public key of our transaction signing scheme.
+pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
+
+/// Balance of an account.
+pub type Balance = u128;
+
+/// Index of a transaction in the chain.
+pub type Nonce = u32;
+
+/// A hash of some data used by the chain.
+pub type Hash = sp_core::H256;
+
+/// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
+/// the specifics of the runtime. They can then be made to be agnostic over specific formats
+/// of data like extrinsics, allowing for them to continue syncing the network through upgrades
+/// to even the core data structures.
+pub mod opaque {
+	use super::*;
+
+	pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
+
+	/// Opaque block header type.
+	pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+	/// Opaque block type.
+	pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+	/// Opaque block identifier type.
+	pub type BlockId = generic::BlockId<Block>;
+
+	impl_opaque_keys! {
+		pub struct SessionKeys {
+			pub aura: Aura,
+			pub grandpa: Grandpa,
+		}
+	}
+}
+
+// To learn more about runtime versioning, see:
+// https://docs.substrate.io/main-docs/build/upgrade#runtime-versioning
+#[sp_version::runtime_version]
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: create_runtime_str!("node-template"),
+	impl_name: create_runtime_str!("node-template"),
+	authoring_version: 1,
+	// The version of the runtime specification. A full node will not attempt to use its native
+	//   runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`,
+	//   `spec_version`, and `authoring_version` are the same between Wasm and native.
+	// This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use
+	//   the compatible custom types.
+	spec_version: 100,
+	impl_version: 1,
+	apis: RUNTIME_API_VERSIONS,
+	transaction_version: 1,
+	state_version: 1,
+};
+
+/// This determines the average expected block time that we are targeting.
+/// Blocks will be produced at a minimum duration defined by `SLOT_DURATION`.
+/// `SLOT_DURATION` is picked up by `pallet_timestamp` which is in turn picked
+/// up by `pallet_aura` to implement `fn slot_duration()`.
+///
+/// Change this to adjust the block time.
+pub const MILLISECS_PER_BLOCK: u64 = 6000;
+
+// NOTE: Currently it is not possible to change the slot duration after the chain has started.
+//       Attempting to do so will brick block production.
+pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;
+
+// Time is measured by number of blocks.
+pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
+pub const HOURS: BlockNumber = MINUTES * 60;
+pub const DAYS: BlockNumber = HOURS * 24;
+
+/// The version information used to identify this runtime when compiled natively.
+#[cfg(feature = "std")]
+pub fn native_version() -> NativeVersion {
+	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
+}
+
+const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
+
+parameter_types! {
+	pub const BlockHashCount: BlockNumber = 2400;
+	pub const Version: RuntimeVersion = VERSION;
+	/// We allow for 2 seconds of compute with a 6 second average block time.
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::with_sensible_defaults(
+			Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
+			NORMAL_DISPATCH_RATIO,
+		);
+	pub BlockLength: frame_system::limits::BlockLength = frame_system::limits::BlockLength
+		::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
+	pub const SS58Prefix: u8 = 42;
+}
+
+// Configure FRAME pallets to include in runtime.
+
+impl frame_system::Config for Runtime {
+	/// The basic call filter to use in dispatchable.
+	type BaseCallFilter = frame_support::traits::Everything;
+	/// The block type for the runtime.
+	type Block = Block;
+	/// Block & extrinsics weights: base values and limits.
+	type BlockWeights = BlockWeights;
+	/// The maximum length of a block (in bytes).
+	type BlockLength = BlockLength;
+	/// The identifier used to distinguish between accounts.
+	type AccountId = AccountId;
+	/// The aggregated dispatch type that is available for extrinsics.
+	type RuntimeCall = RuntimeCall;
+	/// The lookup mechanism to get account ID from whatever is passed in dispatchers.
+	type Lookup = AccountIdLookup<AccountId, ()>;
+	/// The type for storing how many extrinsics an account has signed.
+	type Nonce = Nonce;
+	/// The type for hashing blocks and tries.
+	type Hash = Hash;
+	/// The hashing algorithm used.
+	type Hashing = BlakeTwo256;
+	/// The ubiquitous event type.
+	type RuntimeEvent = RuntimeEvent;
+	/// The ubiquitous origin type.
+	type RuntimeOrigin = RuntimeOrigin;
+	/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
+	type BlockHashCount = BlockHashCount;
+	/// The weight of database operations that the runtime can invoke.
+	type DbWeight = RocksDbWeight;
+	/// Version of the runtime.
+	type Version = Version;
+	/// Converts a module to the index of the module in `construct_runtime!`.
+	///
+	/// This type is being generated by `construct_runtime!`.
+	type PalletInfo = PalletInfo;
+	/// What to do if a new account is created.
+	type OnNewAccount = ();
+	/// What to do if an account is fully reaped from the system.
+	type OnKilledAccount = ();
+	/// The data to be stored in an account.
+	type AccountData = pallet_balances::AccountData<Balance>;
+	/// Weight information for the extrinsics of this pallet.
+	type SystemWeightInfo = ();
+	/// This is used as an identifier of the chain. 42 is the generic substrate prefix.
+	type SS58Prefix = SS58Prefix;
+	/// The set code logic, just the default since we're not a parachain.
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_aura::Config for Runtime {
+	type AuthorityId = AuraId;
+	type DisabledValidators = ();
+	type MaxAuthorities = ConstU32<32>;
+	type AllowMultipleBlocksPerSlot = ConstBool<false>;
+
+	#[cfg(feature = "experimental")]
+	type SlotDuration = pallet_aura::MinimumPeriodTimesTwo<Runtime>;
+}
+
+impl pallet_grandpa::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+
+	type WeightInfo = ();
+	type MaxAuthorities = ConstU32<32>;
+	type MaxNominators = ConstU32<0>;
+	type MaxSetIdSessionEntries = ConstU64<0>;
+
+	type KeyOwnerProof = sp_core::Void;
+	type EquivocationReportSystem = ();
+}
+
+impl pallet_timestamp::Config for Runtime {
+	/// A timestamp: milliseconds since the unix epoch.
+	type Moment = u64;
+	type OnTimestampSet = Aura;
+	type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>;
+	type WeightInfo = ();
+}
+
+/// Existential deposit.
+pub const EXISTENTIAL_DEPOSIT: u128 = 500;
+
+impl pallet_balances::Config for Runtime {
+	type MaxLocks = ConstU32<50>;
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
+	/// The type for recording an account's balance.
+	type Balance = Balance;
+	/// The ubiquitous event type.
+	type RuntimeEvent = RuntimeEvent;
+	type DustRemoval = ();
+	type ExistentialDeposit = ConstU128<EXISTENTIAL_DEPOSIT>;
+	type AccountStore = System;
+	type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+
+parameter_types! {
+	pub FeeMultiplier: Multiplier = Multiplier::one();
+}
+
+impl pallet_transaction_payment::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
+	type OperationalFeeMultiplier = ConstU8<5>;
+	type WeightToFee = IdentityFee<Balance>;
+	type LengthToFee = IdentityFee<Balance>;
+	type FeeMultiplierUpdate = ConstFeeMultiplier<FeeMultiplier>;
+}
+
+impl pallet_sudo::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type WeightInfo = pallet_sudo::weights::SubstrateWeight<Runtime>;
+}
+
+/// Configure the pallet-template in pallets/template.
+impl pallet_template::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = pallet_template::weights::SubstrateWeight<Runtime>;
+}
+
+// Create the runtime by composing the FRAME pallets that were previously configured.
+construct_runtime!(
+	pub struct Runtime {
+		System: frame_system,
+		Timestamp: pallet_timestamp,
+		Aura: pallet_aura,
+		Grandpa: pallet_grandpa,
+		Balances: pallet_balances,
+		TransactionPayment: pallet_transaction_payment,
+		Sudo: pallet_sudo,
+		// Include the custom logic from the pallet-template in the runtime.
+		TemplateModule: pallet_template,
+	}
+);
+
+/// The address format for describing accounts.
+pub type Address = sp_runtime::MultiAddress<AccountId, ()>;
+/// Block header type as expected by this runtime.
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+/// Block type as expected by this runtime.
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+/// 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::CheckEra<Runtime>,
+	frame_system::CheckNonce<Runtime>,
+	frame_system::CheckWeight<Runtime>,
+	pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+);
+
+/// Unchecked extrinsic type as expected by this runtime.
+pub type UncheckedExtrinsic =
+	generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
+/// The payload being signed in transactions.
+pub type SignedPayload = generic::SignedPayload<RuntimeCall, SignedExtra>;
+/// Executive: handles dispatch to the various modules.
+pub type Executive = frame_executive::Executive<
+	Runtime,
+	Block,
+	frame_system::ChainContext<Runtime>,
+	Runtime,
+	AllPalletsWithSystem,
+>;
+
+#[cfg(feature = "runtime-benchmarks")]
+#[macro_use]
+extern crate frame_benchmarking;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benches {
+	define_benchmarks!(
+		[frame_benchmarking, BaselineBench::<Runtime>]
+		[frame_system, SystemBench::<Runtime>]
+		[pallet_balances, Balances]
+		[pallet_timestamp, Timestamp]
+		[pallet_sudo, Sudo]
+		[pallet_template, TemplateModule]
+	);
+}
+
+impl_runtime_apis! {
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> RuntimeVersion {
+			VERSION
+		}
+
+		fn execute_block(block: Block) {
+			Executive::execute_block(block);
+		}
+
+		fn initialize_block(header: &<Block as BlockT>::Header) {
+			Executive::initialize_block(header)
+		}
+	}
+
+	impl sp_api::Metadata<Block> for Runtime {
+		fn metadata() -> OpaqueMetadata {
+			OpaqueMetadata::new(Runtime::metadata().into())
+		}
+
+		fn metadata_at_version(version: u32) -> Option<OpaqueMetadata> {
+			Runtime::metadata_at_version(version)
+		}
+
+		fn metadata_versions() -> sp_std::vec::Vec<u32> {
+			Runtime::metadata_versions()
+		}
+	}
+
+	impl sp_block_builder::BlockBuilder<Block> for Runtime {
+		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
+			Executive::apply_extrinsic(extrinsic)
+		}
+
+		fn finalize_block() -> <Block as BlockT>::Header {
+			Executive::finalize_block()
+		}
+
+		fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+			data.create_extrinsics()
+		}
+
+		fn check_inherents(
+			block: Block,
+			data: sp_inherents::InherentData,
+		) -> sp_inherents::CheckInherentsResult {
+			data.check_extrinsics(&block)
+		}
+	}
+
+	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+		fn validate_transaction(
+			source: TransactionSource,
+			tx: <Block as BlockT>::Extrinsic,
+			block_hash: <Block as BlockT>::Hash,
+		) -> TransactionValidity {
+			Executive::validate_transaction(source, tx, block_hash)
+		}
+	}
+
+	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
+		fn offchain_worker(header: &<Block as BlockT>::Header) {
+			Executive::offchain_worker(header)
+		}
+	}
+
+	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
+		fn slot_duration() -> sp_consensus_aura::SlotDuration {
+			sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration())
+		}
+
+		fn authorities() -> Vec<AuraId> {
+			Aura::authorities().into_inner()
+		}
+	}
+
+	impl sp_session::SessionKeys<Block> for Runtime {
+		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
+			opaque::SessionKeys::generate(seed)
+		}
+
+		fn decode_session_keys(
+			encoded: Vec<u8>,
+		) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {
+			opaque::SessionKeys::decode_into_raw_public_keys(&encoded)
+		}
+	}
+
+	impl sp_consensus_grandpa::GrandpaApi<Block> for Runtime {
+		fn grandpa_authorities() -> sp_consensus_grandpa::AuthorityList {
+			Grandpa::grandpa_authorities()
+		}
+
+		fn current_set_id() -> sp_consensus_grandpa::SetId {
+			Grandpa::current_set_id()
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			_equivocation_proof: sp_consensus_grandpa::EquivocationProof<
+				<Block as BlockT>::Hash,
+				NumberFor<Block>,
+			>,
+			_key_owner_proof: sp_consensus_grandpa::OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			None
+		}
+
+		fn generate_key_ownership_proof(
+			_set_id: sp_consensus_grandpa::SetId,
+			_authority_id: GrandpaId,
+		) -> Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof> {
+			// NOTE: this is the only implementation possible since we've
+			// defined our key owner proof type as a bottom type (i.e. a type
+			// with no values).
+			None
+		}
+	}
+
+	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
+		fn account_nonce(account: AccountId) -> Nonce {
+			System::account_nonce(account)
+		}
+	}
+
+	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<Block, Balance> for Runtime {
+		fn query_info(
+			uxt: <Block as BlockT>::Extrinsic,
+			len: u32,
+		) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance> {
+			TransactionPayment::query_info(uxt, len)
+		}
+		fn query_fee_details(
+			uxt: <Block as BlockT>::Extrinsic,
+			len: u32,
+		) -> pallet_transaction_payment::FeeDetails<Balance> {
+			TransactionPayment::query_fee_details(uxt, len)
+		}
+		fn query_weight_to_fee(weight: Weight) -> Balance {
+			TransactionPayment::weight_to_fee(weight)
+		}
+		fn query_length_to_fee(length: u32) -> Balance {
+			TransactionPayment::length_to_fee(length)
+		}
+	}
+
+	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentCallApi<Block, Balance, RuntimeCall>
+		for Runtime
+	{
+		fn query_call_info(
+			call: RuntimeCall,
+			len: u32,
+		) -> pallet_transaction_payment::RuntimeDispatchInfo<Balance> {
+			TransactionPayment::query_call_info(call, len)
+		}
+		fn query_call_fee_details(
+			call: RuntimeCall,
+			len: u32,
+		) -> pallet_transaction_payment::FeeDetails<Balance> {
+			TransactionPayment::query_call_fee_details(call, len)
+		}
+		fn query_weight_to_fee(weight: Weight) -> Balance {
+			TransactionPayment::weight_to_fee(weight)
+		}
+		fn query_length_to_fee(length: u32) -> Balance {
+			TransactionPayment::length_to_fee(length)
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	impl frame_benchmarking::Benchmark<Block> for Runtime {
+		fn benchmark_metadata(extra: bool) -> (
+			Vec<frame_benchmarking::BenchmarkList>,
+			Vec<frame_support::traits::StorageInfo>,
+		) {
+			use frame_benchmarking::{baseline, Benchmarking, BenchmarkList};
+			use frame_support::traits::StorageInfoTrait;
+			use frame_system_benchmarking::Pallet as SystemBench;
+			use baseline::Pallet as BaselineBench;
+
+			let mut list = Vec::<BenchmarkList>::new();
+			list_benchmarks!(list, extra);
+
+			let storage_info = AllPalletsWithSystem::storage_info();
+
+			(list, storage_info)
+		}
+
+		fn dispatch_benchmark(
+			config: frame_benchmarking::BenchmarkConfig
+		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {
+			use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch};
+			use sp_storage::TrackedStorageKey;
+			use frame_system_benchmarking::Pallet as SystemBench;
+			use baseline::Pallet as BaselineBench;
+
+			impl frame_system_benchmarking::Config for Runtime {}
+			impl baseline::Config for Runtime {}
+
+			use frame_support::traits::WhitelistedStorageKeys;
+			let whitelist: Vec<TrackedStorageKey> = AllPalletsWithSystem::whitelisted_storage_keys();
+
+			let mut batches = Vec::<BenchmarkBatch>::new();
+			let params = (&config, &whitelist);
+			add_benchmarks!(params, batches);
+
+			Ok(batches)
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	impl frame_try_runtime::TryRuntime<Block> for Runtime {
+		fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) {
+			// NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
+			// have a backtrace here. If any of the pre/post migration checks fail, we shall stop
+			// right here and right now.
+			let weight = Executive::try_runtime_upgrade(checks).unwrap();
+			(weight, BlockWeights::get().max_block)
+		}
+
+		fn execute_block(
+			block: Block,
+			state_root_check: bool,
+			signature_check: bool,
+			select: frame_try_runtime::TryStateSelect
+		) -> Weight {
+			// NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
+			// have a backtrace here.
+			Executive::try_execute_block(block, state_root_check, signature_check, select).expect("execute-block failed")
+		}
+	}
+}
diff --git a/substrate/bin/node-template/rust-toolchain.toml b/substrate/bin/node-template/rust-toolchain.toml
new file mode 100644
index 0000000000000000000000000000000000000000..64daeff68360a3a1cc51d0d8c181bcd6f8f087d7
--- /dev/null
+++ b/substrate/bin/node-template/rust-toolchain.toml
@@ -0,0 +1,14 @@
+[toolchain]
+channel = "nightly"
+components = [
+	"cargo",
+	"clippy",
+	"rust-analyzer",
+	"rust-src",
+	"rust-std",
+	"rustc-dev",
+	"rustc",
+	"rustfmt",
+]
+targets = [ "wasm32-unknown-unknown" ]
+profile = "minimal"
diff --git a/substrate/bin/node-template/scripts/init.sh b/substrate/bin/node-template/scripts/init.sh
new file mode 100755
index 0000000000000000000000000000000000000000..f976f7235d700c8f2e5064bd638ff9fb4d7ff48b
--- /dev/null
+++ b/substrate/bin/node-template/scripts/init.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+# This script is meant to be run on Unix/Linux based systems
+set -e
+
+echo "*** Initializing WASM build environment"
+
+if [ -z $CI_PROJECT_NAME ] ; then
+   rustup update nightly
+   rustup update stable
+fi
+
+rustup target add wasm32-unknown-unknown --toolchain nightly
diff --git a/substrate/bin/node/bench/Cargo.toml b/substrate/bin/node/bench/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7703f8ed2e4e098379a3d3439ae91121732f316f
--- /dev/null
+++ b/substrate/bin/node/bench/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "node-bench"
+version = "0.9.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node integration benchmarks."
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+array-bytes = "6.1"
+clap = { version = "4.2.5", features = ["derive"] }
+log = "0.4.17"
+node-primitives = { version = "2.0.0", path = "../primitives" }
+node-testing = { version = "3.0.0-dev", path = "../testing" }
+kitchensink-runtime = { version = "3.0.0-dev", path = "../runtime" }
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api/" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../../primitives/state-machine" }
+serde = "1.0.163"
+serde_json = "1.0.85"
+derive_more = { version = "0.99.17", default-features = false, features = ["display"] }
+kvdb = "0.13.0"
+kvdb-rocksdb = "0.19.0"
+sp-trie = { version = "22.0.0", path = "../../../primitives/trie" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sc-basic-authorship = { version = "0.10.0-dev", path = "../../../client/basic-authorship" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/timestamp" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+hash-db = "0.16.0"
+tempfile = "3.1.0"
+fs_extra = "1"
+rand = { version = "0.8.5", features = ["small_rng"] }
+lazy_static = "1.4.0"
+parity-db = "0.4.8"
+sc-transaction-pool = { version = "4.0.0-dev", path = "../../../client/transaction-pool" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../client/transaction-pool/api" }
+futures = { version = "0.3.21", features = ["thread-pool"] }
diff --git a/substrate/bin/node/bench/src/common.rs b/substrate/bin/node/bench/src/common.rs
new file mode 100644
index 0000000000000000000000000000000000000000..46c9d0417fece57fb6dfc38bc06a267df416c9dd
--- /dev/null
+++ b/substrate/bin/node/bench/src/common.rs
@@ -0,0 +1,47 @@
+// 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/>.
+
+#[derive(Clone, Copy, Debug, derive_more::Display)]
+pub enum SizeType {
+	#[display(fmt = "empty")]
+	Empty,
+	#[display(fmt = "small")]
+	Small,
+	#[display(fmt = "medium")]
+	Medium,
+	#[display(fmt = "large")]
+	Large,
+	#[display(fmt = "full")]
+	Full,
+	#[display(fmt = "custom")]
+	Custom(usize),
+}
+
+impl SizeType {
+	pub fn transactions(&self) -> Option<usize> {
+		match self {
+			SizeType::Empty => Some(0),
+			SizeType::Small => Some(10),
+			SizeType::Medium => Some(100),
+			SizeType::Large => Some(500),
+			SizeType::Full => None,
+			// Custom SizeType will use the `--transactions` input parameter
+			SizeType::Custom(val) => Some(*val),
+		}
+	}
+}
diff --git a/substrate/bin/node/bench/src/construct.rs b/substrate/bin/node/bench/src/construct.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4f3ca07f86b9d2c8e50d170ae92dfa9738ca2c85
--- /dev/null
+++ b/substrate/bin/node/bench/src/construct.rs
@@ -0,0 +1,304 @@
+// 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/>.
+
+//! Block construction benchmark.
+//!
+//! This benchmark is expected to measure block construction.
+//! We want to protect against cold-cache attacks, and so this
+//! benchmark should not rely on any caching (except those entries that
+//! DO NOT depend on user input). Thus transaction generation should be
+//! based on randomized data.
+
+use futures::Future;
+use std::{borrow::Cow, collections::HashMap, pin::Pin, sync::Arc};
+
+use node_primitives::Block;
+use node_testing::bench::{BenchDb, BlockType, DatabaseType, KeyTypes};
+use sc_transaction_pool_api::{
+	ImportNotificationStream, PoolFuture, PoolStatus, ReadyTransactions, TransactionFor,
+	TransactionSource, TransactionStatusStreamFor, TxHash,
+};
+use sp_consensus::{Environment, Proposer};
+use sp_inherents::InherentDataProvider;
+use sp_runtime::{generic::BlockId, traits::NumberFor, OpaqueExtrinsic};
+
+use crate::{
+	common::SizeType,
+	core::{self, Mode, Path},
+};
+
+pub struct ConstructionBenchmarkDescription {
+	pub key_types: KeyTypes,
+	pub block_type: BlockType,
+	pub size: SizeType,
+	pub database_type: DatabaseType,
+}
+
+pub struct ConstructionBenchmark {
+	database: BenchDb,
+	transactions: Transactions,
+}
+
+impl core::BenchmarkDescription for ConstructionBenchmarkDescription {
+	fn path(&self) -> Path {
+		let mut path = Path::new(&["node", "proposer"]);
+
+		match self.key_types {
+			KeyTypes::Sr25519 => path.push("sr25519"),
+			KeyTypes::Ed25519 => path.push("ed25519"),
+		}
+
+		match self.block_type {
+			BlockType::RandomTransfersKeepAlive => path.push("transfer"),
+			BlockType::RandomTransfersReaping => path.push("transfer_reaping"),
+			BlockType::Noop => path.push("noop"),
+		}
+
+		match self.database_type {
+			DatabaseType::RocksDb => path.push("rocksdb"),
+			DatabaseType::ParityDb => path.push("paritydb"),
+		}
+
+		path.push(&format!("{}", self.size));
+
+		path
+	}
+
+	fn setup(self: Box<Self>) -> Box<dyn core::Benchmark> {
+		let mut extrinsics: Vec<Arc<PoolTransaction>> = Vec::new();
+
+		let mut bench_db = BenchDb::with_key_types(self.database_type, 50_000, self.key_types);
+
+		let client = bench_db.client();
+
+		let content_type = self.block_type.to_content(self.size.transactions());
+		for transaction in bench_db.block_content(content_type, &client) {
+			extrinsics.push(Arc::new(transaction.into()));
+		}
+
+		Box::new(ConstructionBenchmark {
+			database: bench_db,
+			transactions: Transactions(extrinsics),
+		})
+	}
+
+	fn name(&self) -> Cow<'static, str> {
+		format!(
+			"Block construction ({:?}/{}, {:?} backend)",
+			self.block_type, self.size, self.database_type,
+		)
+		.into()
+	}
+}
+
+impl core::Benchmark for ConstructionBenchmark {
+	fn run(&mut self, mode: Mode) -> std::time::Duration {
+		let context = self.database.create_context();
+
+		let _ = context
+			.client
+			.runtime_version_at(context.client.chain_info().genesis_hash)
+			.expect("Failed to get runtime version")
+			.spec_version;
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(3));
+		}
+
+		let mut proposer_factory = sc_basic_authorship::ProposerFactory::new(
+			context.spawn_handle.clone(),
+			context.client.clone(),
+			self.transactions.clone().into(),
+			None,
+			None,
+		);
+		let timestamp_provider = sp_timestamp::InherentDataProvider::from_system_time();
+
+		let start = std::time::Instant::now();
+
+		let proposer = futures::executor::block_on(
+			proposer_factory.init(
+				&context
+					.client
+					.header(context.client.chain_info().genesis_hash)
+					.expect("Database error querying block #0")
+					.expect("Block #0 should exist"),
+			),
+		)
+		.expect("Proposer initialization failed");
+
+		let inherent_data = futures::executor::block_on(timestamp_provider.create_inherent_data())
+			.expect("Create inherent data failed");
+		let _block = futures::executor::block_on(proposer.propose(
+			inherent_data,
+			Default::default(),
+			std::time::Duration::from_secs(20),
+			None,
+		))
+		.map(|r| r.block)
+		.expect("Proposing failed");
+
+		let elapsed = start.elapsed();
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(1));
+		}
+
+		elapsed
+	}
+}
+
+#[derive(Clone, Debug)]
+pub struct PoolTransaction {
+	data: OpaqueExtrinsic,
+	hash: node_primitives::Hash,
+}
+
+impl From<OpaqueExtrinsic> for PoolTransaction {
+	fn from(e: OpaqueExtrinsic) -> Self {
+		PoolTransaction { data: e, hash: node_primitives::Hash::zero() }
+	}
+}
+
+impl sc_transaction_pool_api::InPoolTransaction for PoolTransaction {
+	type Transaction = OpaqueExtrinsic;
+	type Hash = node_primitives::Hash;
+
+	fn data(&self) -> &Self::Transaction {
+		&self.data
+	}
+
+	fn hash(&self) -> &Self::Hash {
+		&self.hash
+	}
+
+	fn priority(&self) -> &u64 {
+		unimplemented!()
+	}
+
+	fn longevity(&self) -> &u64 {
+		unimplemented!()
+	}
+
+	fn requires(&self) -> &[Vec<u8>] {
+		unimplemented!()
+	}
+
+	fn provides(&self) -> &[Vec<u8>] {
+		unimplemented!()
+	}
+
+	fn is_propagable(&self) -> bool {
+		unimplemented!()
+	}
+}
+
+#[derive(Clone, Debug)]
+pub struct Transactions(Vec<Arc<PoolTransaction>>);
+pub struct TransactionsIterator(std::vec::IntoIter<Arc<PoolTransaction>>);
+
+impl Iterator for TransactionsIterator {
+	type Item = Arc<PoolTransaction>;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.0.next()
+	}
+}
+
+impl ReadyTransactions for TransactionsIterator {
+	fn report_invalid(&mut self, _tx: &Self::Item) {}
+}
+
+impl sc_transaction_pool_api::TransactionPool for Transactions {
+	type Block = Block;
+	type Hash = node_primitives::Hash;
+	type InPoolTransaction = PoolTransaction;
+	type Error = sc_transaction_pool_api::error::Error;
+
+	/// Returns a future that imports a bunch of unverified transactions to the pool.
+	fn submit_at(
+		&self,
+		_at: &BlockId<Self::Block>,
+		_source: TransactionSource,
+		_xts: Vec<TransactionFor<Self>>,
+	) -> PoolFuture<Vec<Result<node_primitives::Hash, Self::Error>>, Self::Error> {
+		unimplemented!()
+	}
+
+	/// Returns a future that imports one unverified transaction to the pool.
+	fn submit_one(
+		&self,
+		_at: &BlockId<Self::Block>,
+		_source: TransactionSource,
+		_xt: TransactionFor<Self>,
+	) -> PoolFuture<TxHash<Self>, Self::Error> {
+		unimplemented!()
+	}
+
+	fn submit_and_watch(
+		&self,
+		_at: &BlockId<Self::Block>,
+		_source: TransactionSource,
+		_xt: TransactionFor<Self>,
+	) -> PoolFuture<Pin<Box<TransactionStatusStreamFor<Self>>>, Self::Error> {
+		unimplemented!()
+	}
+
+	fn ready_at(
+		&self,
+		_at: NumberFor<Self::Block>,
+	) -> Pin<
+		Box<
+			dyn Future<
+					Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>,
+				> + Send,
+		>,
+	> {
+		let iter: Box<dyn ReadyTransactions<Item = Arc<PoolTransaction>> + Send> =
+			Box::new(TransactionsIterator(self.0.clone().into_iter()));
+		Box::pin(futures::future::ready(iter))
+	}
+
+	fn ready(&self) -> Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send> {
+		unimplemented!()
+	}
+
+	fn remove_invalid(&self, _hashes: &[TxHash<Self>]) -> Vec<Arc<Self::InPoolTransaction>> {
+		Default::default()
+	}
+
+	fn status(&self) -> PoolStatus {
+		unimplemented!()
+	}
+
+	fn import_notification_stream(&self) -> ImportNotificationStream<TxHash<Self>> {
+		unimplemented!()
+	}
+
+	fn on_broadcasted(&self, _propagations: HashMap<TxHash<Self>, Vec<String>>) {
+		unimplemented!()
+	}
+
+	fn hash_of(&self, _xt: &TransactionFor<Self>) -> TxHash<Self> {
+		unimplemented!()
+	}
+
+	fn ready_transaction(&self, _hash: &TxHash<Self>) -> Option<Arc<Self::InPoolTransaction>> {
+		unimplemented!()
+	}
+}
diff --git a/substrate/bin/node/bench/src/core.rs b/substrate/bin/node/bench/src/core.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f22d3db69261025fda11dd7934b54326ed023b3
--- /dev/null
+++ b/substrate/bin/node/bench/src/core.rs
@@ -0,0 +1,151 @@
+// 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 serde::Serialize;
+use std::{
+	borrow::{Cow, ToOwned},
+	fmt,
+};
+
+pub struct Path(Vec<String>);
+
+impl Path {
+	pub fn new(initial: &'static [&'static str]) -> Self {
+		Path(initial.iter().map(|x| x.to_string()).collect())
+	}
+}
+
+impl Path {
+	pub fn push(&mut self, item: &str) {
+		self.0.push(item.to_string());
+	}
+
+	pub fn full(&self) -> String {
+		self.0.iter().fold(String::new(), |mut val, next| {
+			val.push_str("::");
+			val.push_str(next);
+			val
+		})
+	}
+
+	pub fn has(&self, path: &str) -> bool {
+		self.full().contains(path)
+	}
+}
+
+pub trait BenchmarkDescription {
+	fn path(&self) -> Path;
+
+	fn setup(self: Box<Self>) -> Box<dyn Benchmark>;
+
+	fn name(&self) -> Cow<'static, str>;
+}
+
+pub trait Benchmark {
+	fn run(&mut self, mode: Mode) -> std::time::Duration;
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct BenchmarkOutput {
+	name: String,
+	raw_average: u64,
+	average: u64,
+}
+
+pub struct NsFormatter(pub u64);
+
+impl fmt::Display for NsFormatter {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		let v = self.0;
+		match v {
+			v if v < 100 => write!(f, "{} ns", v),
+			v if v < 100_000 => write!(f, "{:.1} µs", v as f64 / 1000.0),
+			v if v < 1_000_000 => write!(f, "{:.4} ms", v as f64 / 1_000_000.0),
+			v if v < 100_000_000 => write!(f, "{:.1} ms", v as f64 / 1_000_000.0),
+			_ => write!(f, "{:.4} s", v as f64 / 1_000_000_000.0),
+		}
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Mode {
+	Regular,
+	Profile,
+}
+
+impl std::str::FromStr for Mode {
+	type Err = &'static str;
+	fn from_str(day: &str) -> Result<Self, Self::Err> {
+		match day {
+			"regular" => Ok(Mode::Regular),
+			"profile" => Ok(Mode::Profile),
+			_ => Err("Could not parse mode"),
+		}
+	}
+}
+
+impl fmt::Display for BenchmarkOutput {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(
+			f,
+			"{}: avg {}, w_avg {}",
+			self.name,
+			NsFormatter(self.raw_average),
+			NsFormatter(self.average),
+		)
+	}
+}
+
+pub fn run_benchmark(benchmark: Box<dyn BenchmarkDescription>, mode: Mode) -> BenchmarkOutput {
+	let name = benchmark.name().to_owned();
+	let mut benchmark = benchmark.setup();
+
+	let mut durations: Vec<u128> = vec![];
+	for _ in 0..50 {
+		let duration = benchmark.run(mode);
+		durations.push(duration.as_nanos());
+	}
+
+	durations.sort();
+
+	let raw_average = (durations.iter().sum::<u128>() / (durations.len() as u128)) as u64;
+	let average = (durations.iter().skip(10).take(30).sum::<u128>() / 30) as u64;
+
+	BenchmarkOutput { name: name.into(), raw_average, average }
+}
+
+macro_rules! matrix(
+	( $var:tt in $over:expr => $tt:expr,  $( $rest:tt )* ) => {
+		{
+			let mut res = Vec::<Box<dyn crate::core::BenchmarkDescription>>::new();
+			for $var in $over {
+				res.push(Box::new($tt));
+			}
+			res.extend(matrix!( $($rest)* ));
+			res
+		}
+	};
+	( $var:expr, $( $rest:tt )*) => {
+		{
+			let mut res = vec![Box::new($var) as Box<dyn crate::core::BenchmarkDescription>];
+			res.extend(matrix!( $($rest)* ));
+			res
+		}
+	};
+	() => { vec![] }
+);
diff --git a/substrate/bin/node/bench/src/generator.rs b/substrate/bin/node/bench/src/generator.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0fe0826028f5f3077cf859558856e9394d19ac06
--- /dev/null
+++ b/substrate/bin/node/bench/src/generator.rs
@@ -0,0 +1,69 @@
+// 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 std::{collections::HashMap, sync::Arc};
+
+use kvdb::KeyValueDB;
+use node_primitives::Hash;
+use sp_trie::{trie_types::TrieDBMutBuilderV1, TrieMut};
+
+use crate::simple_trie::SimpleTrie;
+
+/// Generate trie from given `key_values`.
+///
+/// Will fill your database `db` with trie data from `key_values` and
+/// return root.
+pub fn generate_trie(
+	db: Arc<dyn KeyValueDB>,
+	key_values: impl IntoIterator<Item = (Vec<u8>, Vec<u8>)>,
+) -> Hash {
+	let mut root = Hash::default();
+
+	let (db, overlay) = {
+		let mut overlay = HashMap::new();
+		overlay.insert(
+			array_bytes::hex2bytes(
+				"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314",
+			)
+			.expect("null key is valid"),
+			Some(vec![0]),
+		);
+		let mut trie = SimpleTrie { db, overlay: &mut overlay };
+		{
+			let mut trie_db =
+				TrieDBMutBuilderV1::<crate::simple_trie::Hasher>::new(&mut trie, &mut root).build();
+			for (key, value) in key_values {
+				trie_db.insert(&key, &value).expect("trie insertion failed");
+			}
+
+			trie_db.commit();
+		}
+		(trie.db, overlay)
+	};
+
+	let mut transaction = db.transaction();
+	for (key, value) in overlay.into_iter() {
+		match value {
+			Some(value) => transaction.put(0, &key[..], &value[..]),
+			None => transaction.delete(0, &key[..]),
+		}
+	}
+	db.write(transaction).expect("Failed to write transaction");
+
+	root
+}
diff --git a/substrate/bin/node/bench/src/import.rs b/substrate/bin/node/bench/src/import.rs
new file mode 100644
index 0000000000000000000000000000000000000000..78b280076e0bd625f2c6fa76beb76a9439a7187a
--- /dev/null
+++ b/substrate/bin/node/bench/src/import.rs
@@ -0,0 +1,176 @@
+// 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/>.
+
+//! Block import benchmark.
+//!
+//! This benchmark is expected to measure block import operation of
+//! some more or less full block.
+//!
+//! As we also want to protect against cold-cache attacks, this
+//! benchmark should not rely on any caching (except those that
+//! DO NOT depend on user input). Thus block generation should be
+//! based on randomized operation.
+//!
+//! This is supposed to be very simple benchmark and is not subject
+//! to much configuring - just block full of randomized transactions.
+//! It is not supposed to measure runtime modules weight correctness
+
+use std::borrow::Cow;
+
+use node_primitives::Block;
+use node_testing::bench::{BenchDb, BlockType, DatabaseType, KeyTypes};
+use sc_client_api::backend::Backend;
+use sp_state_machine::InspectState;
+
+use crate::{
+	common::SizeType,
+	core::{self, Mode, Path},
+};
+
+pub struct ImportBenchmarkDescription {
+	pub key_types: KeyTypes,
+	pub block_type: BlockType,
+	pub size: SizeType,
+	pub database_type: DatabaseType,
+}
+
+pub struct ImportBenchmark {
+	database: BenchDb,
+	block: Block,
+	block_type: BlockType,
+}
+
+impl core::BenchmarkDescription for ImportBenchmarkDescription {
+	fn path(&self) -> Path {
+		let mut path = Path::new(&["node", "import"]);
+
+		match self.key_types {
+			KeyTypes::Sr25519 => path.push("sr25519"),
+			KeyTypes::Ed25519 => path.push("ed25519"),
+		}
+
+		match self.block_type {
+			BlockType::RandomTransfersKeepAlive => path.push("transfer_keep_alive"),
+			BlockType::RandomTransfersReaping => path.push("transfer_reaping"),
+			BlockType::Noop => path.push("noop"),
+		}
+
+		match self.database_type {
+			DatabaseType::RocksDb => path.push("rocksdb"),
+			DatabaseType::ParityDb => path.push("paritydb"),
+		}
+
+		path.push(&format!("{}", self.size));
+
+		path
+	}
+
+	fn setup(self: Box<Self>) -> Box<dyn core::Benchmark> {
+		let mut bench_db = BenchDb::with_key_types(self.database_type, 50_000, self.key_types);
+		let block = bench_db.generate_block(self.block_type.to_content(self.size.transactions()));
+		Box::new(ImportBenchmark { database: bench_db, block_type: self.block_type, block })
+	}
+
+	fn name(&self) -> Cow<'static, str> {
+		format!(
+			"Block import ({:?}/{}, {:?} backend)",
+			self.block_type, self.size, self.database_type,
+		)
+		.into()
+	}
+}
+
+impl core::Benchmark for ImportBenchmark {
+	fn run(&mut self, mode: Mode) -> std::time::Duration {
+		let mut context = self.database.create_context();
+
+		let _ = context
+			.client
+			.runtime_version_at(context.client.chain_info().genesis_hash)
+			.expect("Failed to get runtime version")
+			.spec_version;
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(3));
+		}
+
+		let start = std::time::Instant::now();
+		context.import_block(self.block.clone());
+		let elapsed = start.elapsed();
+
+		// Sanity checks.
+		context
+			.client
+			.state_at(self.block.header.hash())
+			.expect("state_at failed for block#1")
+			.inspect_state(|| {
+				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
+						// those 8 events per signed are:
+						//    - transaction paid for the transaction payment
+						//    - withdraw (Balances::Withdraw) for charging the transaction fee
+						//    - new account (System::NewAccount) as we always transfer fund to
+						//      non-existent account
+						//    - endowed (Balances::Endowed) for this new account
+						//    - successful transfer (Event::Transfer) for this transfer operation
+						//    - 2x deposit (Balances::Deposit and Treasury::Deposit) for depositing
+						//      the transaction fee into the treasury
+						//    - extrinsic success
+						assert_eq!(
+							kitchensink_runtime::System::events().len(),
+							(self.block.extrinsics.len() - 1) * 8 + 1,
+						);
+					},
+					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
+							// those 2 events per signed are:
+							//    - deposit event for charging transaction fee
+							//    - extrinsic success
+							(self.block.extrinsics.len() - 1) * 2 + 1,
+						);
+					},
+					_ => {},
+				}
+			});
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(1));
+		}
+
+		log::info!(
+			target: "bench-logistics",
+			"imported block with {} tx, took: {:#?}",
+			self.block.extrinsics.len(),
+			elapsed,
+		);
+
+		log::info!(
+			target: "bench-logistics",
+			"usage info: {}",
+			context.backend.usage_info()
+				.expect("RocksDB backend always provides usage info!"),
+		);
+
+		elapsed
+	}
+}
diff --git a/substrate/bin/node/bench/src/main.rs b/substrate/bin/node/bench/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f69c976958019dd320bdd0ddde4b4432752e3f6
--- /dev/null
+++ b/substrate/bin/node/bench/src/main.rs
@@ -0,0 +1,186 @@
+// 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/>.
+
+mod common;
+mod construct;
+#[macro_use]
+mod core;
+mod generator;
+mod import;
+mod simple_trie;
+mod state_sizes;
+mod tempdb;
+mod trie;
+mod txpool;
+
+use clap::Parser;
+
+use node_testing::bench::{BlockType, DatabaseType as BenchDataBaseType, KeyTypes};
+
+use crate::{
+	common::SizeType,
+	construct::ConstructionBenchmarkDescription,
+	core::{run_benchmark, Mode as BenchmarkMode},
+	import::ImportBenchmarkDescription,
+	tempdb::DatabaseType,
+	trie::{DatabaseSize, TrieReadBenchmarkDescription, TrieWriteBenchmarkDescription},
+	txpool::PoolBenchmarkDescription,
+};
+
+#[derive(Debug, Parser)]
+#[command(name = "node-bench", about = "Node integration benchmarks")]
+struct Opt {
+	/// Show list of all available benchmarks.
+	///
+	/// Will output ("name", "path"). Benchmarks can then be filtered by path.
+	#[arg(short, long)]
+	list: bool,
+
+	/// Machine readable json output.
+	///
+	/// This also suppresses all regular output (except to stderr)
+	#[arg(short, long)]
+	json: bool,
+
+	/// Filter benchmarks.
+	///
+	/// Run with `--list` for the hint of what to filter.
+	filter: Option<String>,
+
+	/// Number of transactions for block import with `custom` size.
+	#[arg(long)]
+	transactions: Option<usize>,
+
+	/// Mode
+	///
+	/// "regular" for regular benchmark
+	///
+	/// "profile" mode adds pauses between measurable runs,
+	/// so that actual interval can be selected in the profiler of choice.
+	#[arg(short, long, default_value = "regular")]
+	mode: BenchmarkMode,
+}
+
+fn main() {
+	let opt = Opt::parse();
+
+	if !opt.json {
+		sp_tracing::try_init_simple();
+	}
+
+	let mut import_benchmarks = Vec::new();
+
+	for size in [
+		SizeType::Empty,
+		SizeType::Small,
+		SizeType::Medium,
+		SizeType::Large,
+		SizeType::Full,
+		SizeType::Custom(opt.transactions.unwrap_or(0)),
+	] {
+		for block_type in [
+			BlockType::RandomTransfersKeepAlive,
+			BlockType::RandomTransfersReaping,
+			BlockType::Noop,
+		] {
+			for database_type in [BenchDataBaseType::RocksDb, BenchDataBaseType::ParityDb] {
+				import_benchmarks.push((size, block_type, database_type));
+			}
+		}
+	}
+
+	let benchmarks = matrix!(
+		(size, block_type, database_type) in import_benchmarks.into_iter() =>
+			ImportBenchmarkDescription {
+				key_types: KeyTypes::Sr25519,
+				size,
+				block_type,
+				database_type,
+			},
+		(size, db_type) in
+			[
+				DatabaseSize::Empty, DatabaseSize::Smallest, DatabaseSize::Small,
+				DatabaseSize::Medium, DatabaseSize::Large, DatabaseSize::Huge,
+			]
+			.iter().flat_map(|size|
+			[
+				DatabaseType::RocksDb, DatabaseType::ParityDb
+			]
+			.iter().map(move |db_type| (size, db_type)))
+			=> TrieReadBenchmarkDescription { database_size: *size, database_type: *db_type },
+		(size, db_type) in
+			[
+				DatabaseSize::Empty, DatabaseSize::Smallest, DatabaseSize::Small,
+				DatabaseSize::Medium, DatabaseSize::Large, DatabaseSize::Huge,
+			]
+			.iter().flat_map(|size|
+			[
+				DatabaseType::RocksDb, DatabaseType::ParityDb
+			]
+			.iter().map(move |db_type| (size, db_type)))
+			=> TrieWriteBenchmarkDescription { database_size: *size, database_type: *db_type },
+		ConstructionBenchmarkDescription {
+			key_types: KeyTypes::Sr25519,
+			block_type: BlockType::RandomTransfersKeepAlive,
+			size: SizeType::Medium,
+			database_type: BenchDataBaseType::RocksDb,
+		},
+		ConstructionBenchmarkDescription {
+			key_types: KeyTypes::Sr25519,
+			block_type: BlockType::RandomTransfersKeepAlive,
+			size: SizeType::Large,
+			database_type: BenchDataBaseType::RocksDb,
+		},
+		PoolBenchmarkDescription { database_type: BenchDataBaseType::RocksDb },
+	);
+
+	if opt.list {
+		println!("Available benchmarks:");
+		if let Some(filter) = opt.filter.as_ref() {
+			println!("\t(filtered by \"{}\")", filter);
+		}
+		for benchmark in benchmarks.iter() {
+			if opt.filter.as_ref().map(|f| benchmark.path().has(f)).unwrap_or(true) {
+				println!("{}: {}", benchmark.name(), benchmark.path().full())
+			}
+		}
+		return
+	}
+
+	let mut results = Vec::new();
+	for benchmark in benchmarks {
+		if opt.filter.as_ref().map(|f| benchmark.path().has(f)).unwrap_or(true) {
+			log::info!("Starting {}", benchmark.name());
+			let result = run_benchmark(benchmark, opt.mode);
+			log::info!("{}", result);
+
+			results.push(result);
+		}
+	}
+
+	if results.is_empty() {
+		eprintln!("No benchmark was found for query");
+		std::process::exit(1);
+	}
+
+	if opt.json {
+		let json_result: String =
+			serde_json::to_string(&results).expect("Failed to construct json");
+		println!("{}", json_result);
+	}
+}
diff --git a/substrate/bin/node/bench/src/simple_trie.rs b/substrate/bin/node/bench/src/simple_trie.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6d5072358d2392038429f2f259de717440f96a97
--- /dev/null
+++ b/substrate/bin/node/bench/src/simple_trie.rs
@@ -0,0 +1,72 @@
+// 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 std::{collections::HashMap, sync::Arc};
+
+use hash_db::{AsHashDB, HashDB, Hasher as _, Prefix};
+use kvdb::KeyValueDB;
+use node_primitives::Hash;
+use sp_trie::DBValue;
+
+pub type Hasher = sp_core::Blake2Hasher;
+
+/// Immutable generated trie database with root.
+pub struct SimpleTrie<'a> {
+	pub db: Arc<dyn KeyValueDB>,
+	pub overlay: &'a mut HashMap<Vec<u8>, Option<Vec<u8>>>,
+}
+
+impl<'a> AsHashDB<Hasher, DBValue> for SimpleTrie<'a> {
+	fn as_hash_db(&self) -> &dyn hash_db::HashDB<Hasher, DBValue> {
+		self
+	}
+
+	fn as_hash_db_mut<'b>(&'b mut self) -> &'b mut (dyn HashDB<Hasher, DBValue> + 'b) {
+		&mut *self
+	}
+}
+
+impl<'a> HashDB<Hasher, DBValue> for SimpleTrie<'a> {
+	fn get(&self, key: &Hash, prefix: Prefix) -> Option<DBValue> {
+		let key = sp_trie::prefixed_key::<Hasher>(key, prefix);
+		if let Some(value) = self.overlay.get(&key) {
+			return value.clone()
+		}
+		self.db.get(0, &key).expect("Database backend error")
+	}
+
+	fn contains(&self, hash: &Hash, prefix: Prefix) -> bool {
+		self.get(hash, prefix).is_some()
+	}
+
+	fn insert(&mut self, prefix: Prefix, value: &[u8]) -> Hash {
+		let key = Hasher::hash(value);
+		self.emplace(key, prefix, value.to_vec());
+		key
+	}
+
+	fn emplace(&mut self, key: Hash, prefix: Prefix, value: DBValue) {
+		let key = sp_trie::prefixed_key::<Hasher>(&key, prefix);
+		self.overlay.insert(key, Some(value));
+	}
+
+	fn remove(&mut self, key: &Hash, prefix: Prefix) {
+		let key = sp_trie::prefixed_key::<Hasher>(key, prefix);
+		self.overlay.insert(key, None);
+	}
+}
diff --git a/substrate/bin/node/bench/src/state_sizes.rs b/substrate/bin/node/bench/src/state_sizes.rs
new file mode 100644
index 0000000000000000000000000000000000000000..12e0f6eae1916f4bbe534f571c765ad27d4b1734
--- /dev/null
+++ b/substrate/bin/node/bench/src/state_sizes.rs
@@ -0,0 +1,4758 @@
+// 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/>.
+
+/// Kusama value size distribution
+pub const KUSAMA_STATE_DISTRIBUTION: &[(u32, u32)] = &[
+	(32, 35),
+	(33, 20035),
+	(34, 5369),
+	(35, 184),
+	(36, 54599),
+	(37, 1515056),
+	(38, 885),
+	(39, 69965),
+	(41, 210754),
+	(42, 467),
+	(43, 3241),
+	(44, 32660),
+	(45, 231141),
+	(46, 220016),
+	(47, 248931),
+	(48, 157232),
+	(49, 143236),
+	(50, 2428),
+	(51, 1476159),
+	(52, 31),
+	(53, 112),
+	(54, 711),
+	(55, 1934),
+	(56, 39),
+	(57, 407),
+	(58, 6929),
+	(59, 6568),
+	(60, 26),
+	(61, 268673),
+	(62, 118137),
+	(63, 84640),
+	(64, 193232),
+	(65, 2584210),
+	(66, 1002),
+	(67, 2993),
+	(68, 4266),
+	(69, 5633381),
+	(70, 277369),
+	(71, 5106),
+	(72, 722),
+	(73, 1882),
+	(74, 8178),
+	(75, 4045),
+	(76, 1596),
+	(77, 5335),
+	(78, 14591),
+	(79, 9645),
+	(80, 44171),
+	(81, 13474),
+	(82, 51090),
+	(83, 2595),
+	(84, 6276),
+	(85, 382195),
+	(86, 1062),
+	(87, 3846),
+	(88, 5663),
+	(89, 3811),
+	(90, 1580),
+	(91, 5729),
+	(92, 19144),
+	(93, 197),
+	(94, 235),
+	(95, 545),
+	(96, 54914),
+	(97, 3858),
+	(98, 1610),
+	(99, 635),
+	(100, 2481),
+	(101, 6457),
+	(102, 3753951),
+	(103, 11821),
+	(104, 11114),
+	(105, 2601),
+	(106, 2518),
+	(107, 521925),
+	(108, 297),
+	(109, 411),
+	(110, 668),
+	(111, 4500),
+	(112, 704),
+	(113, 316),
+	(114, 59),
+	(115, 291),
+	(116, 1727),
+	(117, 6010),
+	(118, 51874),
+	(119, 13969),
+	(120, 9496),
+	(121, 274),
+	(122, 810),
+	(123, 643),
+	(124, 69),
+	(125, 41),
+	(126, 329),
+	(127, 175435),
+	(128, 2641),
+	(129, 2658),
+	(130, 415277),
+	(131, 2705),
+	(132, 2314),
+	(133, 4290),
+	(134, 693),
+	(135, 1957478),
+	(136, 1111),
+	(137, 1474503),
+	(138, 3656),
+	(139, 940),
+	(140, 1755692),
+	(141, 61),
+	(142, 4140),
+	(143, 47),
+	(144, 6725),
+	(145, 610),
+	(146, 250),
+	(147, 48),
+	(148, 28),
+	(149, 132),
+	(150, 123489),
+	(151, 7476),
+	(152, 55),
+	(153, 68),
+	(154, 170),
+	(155, 566),
+	(156, 8110),
+	(157, 1243),
+	(158, 1445),
+	(159, 2569),
+	(160, 1096),
+	(161, 865),
+	(162, 634),
+	(163, 372411),
+	(164, 685),
+	(165, 3481),
+	(166, 1467),
+	(167, 2146),
+	(168, 556539),
+	(169, 566),
+	(170, 5080),
+	(171, 202),
+	(172, 123),
+	(173, 100750),
+	(174, 667),
+	(175, 433),
+	(176, 737),
+	(177, 315),
+	(178, 317),
+	(179, 656),
+	(180, 2522),
+	(181, 315),
+	(182, 406),
+	(183, 4680),
+	(184, 4941),
+	(185, 828),
+	(186, 782),
+	(187, 565),
+	(188, 584),
+	(189, 376),
+	(190, 321),
+	(191, 418),
+	(192, 167),
+	(193, 362),
+	(194, 2198),
+	(195, 180),
+	(196, 787),
+	(197, 2680),
+	(198, 501),
+	(199, 843),
+	(200, 287),
+	(201, 608362),
+	(202, 1157),
+	(203, 959),
+	(204, 1683623),
+	(205, 440),
+	(206, 756),
+	(207, 812),
+	(208, 1147),
+	(209, 723),
+	(210, 856),
+	(211, 496),
+	(212, 916),
+	(213, 615),
+	(214, 488),
+	(215, 522),
+	(216, 8265),
+	(217, 32574),
+	(218, 417),
+	(219, 247),
+	(220, 579),
+	(221, 68),
+	(222, 126),
+	(223, 306),
+	(224, 310),
+	(225, 24),
+	(226, 37),
+	(227, 160),
+	(228, 11),
+	(229, 3288),
+	(230, 349),
+	(231, 23),
+	(232, 14),
+	(233, 45),
+	(234, 452840),
+	(235, 118),
+	(236, 741),
+	(237, 390),
+	(238, 517),
+	(239, 694),
+	(240, 765),
+	(241, 542),
+	(242, 417),
+	(243, 617),
+	(244, 1307),
+	(245, 583),
+	(246, 1640),
+	(247, 735),
+	(248, 478),
+	(249, 4312),
+	(250, 5426),
+	(251, 1067),
+	(252, 435),
+	(253, 202),
+	(254, 122),
+	(255, 486),
+	(256, 180),
+	(257, 279),
+	(258, 406),
+	(259, 160),
+	(260, 2759),
+	(261, 2600),
+	(262, 686),
+	(263, 95),
+	(264, 164),
+	(265, 150),
+	(266, 1013),
+	(267, 552618),
+	(268, 217),
+	(269, 188),
+	(270, 284),
+	(271, 416),
+	(272, 453),
+	(273, 95),
+	(274, 42),
+	(275, 68),
+	(276, 90),
+	(277, 123),
+	(278, 340),
+	(279, 98),
+	(280, 2795),
+	(281, 261),
+	(282, 7370),
+	(283, 5768),
+	(284, 3285),
+	(285, 461),
+	(286, 363),
+	(287, 456),
+	(288, 1475),
+	(289, 211),
+	(290, 153),
+	(291, 282),
+	(292, 241),
+	(293, 2924),
+	(294, 261),
+	(295, 1070),
+	(296, 1301),
+	(297, 688),
+	(298, 592),
+	(299, 95),
+	(300, 686447),
+	(301, 42),
+	(302, 385),
+	(303, 24),
+	(304, 931),
+	(305, 49),
+	(306, 23),
+	(307, 67),
+	(308, 32),
+	(309, 38),
+	(310, 2),
+	(311, 7),
+	(312, 198),
+	(313, 11),
+	(314, 38),
+	(315, 3704),
+	(316, 7406),
+	(317, 116),
+	(318, 229),
+	(319, 100),
+	(320, 437),
+	(321, 244),
+	(322, 285),
+	(323, 433),
+	(324, 382),
+	(325, 3171),
+	(326, 761),
+	(327, 324),
+	(328, 2264),
+	(329, 340),
+	(330, 353),
+	(331, 110),
+	(332, 403),
+	(333, 731366),
+	(334, 223),
+	(335, 350),
+	(336, 600),
+	(337, 219),
+	(338, 112),
+	(339, 10),
+	(340, 761),
+	(341, 35),
+	(342, 99),
+	(343, 83),
+	(344, 136),
+	(345, 7),
+	(346, 836),
+	(347, 11),
+	(348, 10832),
+	(349, 8931),
+	(350, 33),
+	(351, 64),
+	(352, 66),
+	(353, 54),
+	(354, 78),
+	(355, 198),
+	(356, 722),
+	(357, 2647),
+	(358, 64),
+	(359, 71),
+	(360, 2242),
+	(361, 1462),
+	(362, 505),
+	(363, 444),
+	(364, 597),
+	(365, 372),
+	(366, 664852),
+	(367, 464),
+	(368, 605),
+	(369, 123),
+	(370, 64),
+	(371, 117),
+	(372, 328),
+	(373, 123),
+	(374, 227),
+	(375, 151),
+	(376, 881),
+	(377, 111),
+	(378, 30),
+	(379, 73),
+	(380, 2126),
+	(381, 3662),
+	(382, 9107),
+	(383, 18),
+	(384, 294),
+	(385, 12),
+	(386, 262),
+	(387, 127),
+	(388, 269),
+	(389, 2566),
+	(390, 14),
+	(391, 17),
+	(392, 80),
+	(393, 67),
+	(394, 1470),
+	(395, 25),
+	(396, 220),
+	(397, 131),
+	(398, 225),
+	(399, 484755),
+	(400, 597),
+	(401, 300),
+	(402, 253),
+	(403, 359),
+	(404, 523),
+	(405, 311),
+	(406, 238),
+	(407, 999),
+	(408, 424),
+	(409, 165),
+	(410, 96),
+	(411, 248),
+	(412, 1771),
+	(413, 139),
+	(414, 7374),
+	(415, 11186),
+	(416, 1355),
+	(417, 1283666),
+	(418, 9),
+	(419, 116),
+	(420, 3897),
+	(421, 2554),
+	(422, 1),
+	(423, 1),
+	(424, 16878),
+	(425, 3198212),
+	(426, 335),
+	(427, 1676),
+	(428, 80),
+	(429, 19),
+	(430, 47),
+	(431, 495),
+	(432, 421946),
+	(433, 73),
+	(434, 95),
+	(435, 105),
+	(436, 184),
+	(437, 56903),
+	(438, 132),
+	(439, 87),
+	(440, 207411),
+	(441, 230),
+	(442, 372),
+	(443, 361),
+	(444, 387),
+	(445, 299),
+	(446, 175),
+	(447, 7487),
+	(448, 16346),
+	(449, 37),
+	(450, 98313),
+	(451, 307),
+	(452, 304),
+	(453, 2675),
+	(454, 229),
+	(455, 130),
+	(456, 134),
+	(457, 50),
+	(458, 238),
+	(459, 2),
+	(460, 2267),
+	(461, 7),
+	(462, 1),
+	(463, 8),
+	(464, 395),
+	(465, 1279781),
+	(466, 9),
+	(467, 12),
+	(468, 633),
+	(469, 37),
+	(470, 13),
+	(471, 54),
+	(472, 247),
+	(473, 82),
+	(474, 119),
+	(475, 114),
+	(476, 332),
+	(477, 79),
+	(478, 116),
+	(479, 128),
+	(480, 4206),
+	(481, 20732),
+	(482, 311),
+	(483, 343),
+	(484, 527),
+	(485, 2750),
+	(486, 76),
+	(487, 152),
+	(488, 510),
+	(489, 63),
+	(490, 257),
+	(491, 79),
+	(492, 825),
+	(493, 4198),
+	(494, 389),
+	(495, 72),
+	(496, 1547),
+	(497, 34),
+	(498, 631996),
+	(499, 5),
+	(500, 2334),
+	(501, 34),
+	(502, 7),
+	(503, 7),
+	(504, 7682),
+	(505, 6),
+	(506, 26),
+	(507, 22),
+	(508, 461),
+	(509, 95),
+	(510, 36),
+	(511, 46),
+	(512, 2741),
+	(513, 38455),
+	(514, 29678),
+	(515, 179),
+	(516, 1637),
+	(517, 2597),
+	(518, 166),
+	(519, 230),
+	(520, 2736),
+	(521, 187),
+	(522, 361),
+	(523, 310),
+	(524, 3327),
+	(525, 76),
+	(526, 8070),
+	(527, 35),
+	(528, 3310),
+	(529, 118),
+	(530, 167),
+	(531, 214180),
+	(532, 4597),
+	(533, 153),
+	(534, 126),
+	(535, 23),
+	(536, 13920),
+	(537, 10),
+	(538, 11),
+	(539, 50),
+	(540, 50739),
+	(541, 8),
+	(542, 347),
+	(543, 77),
+	(544, 451575),
+	(545, 16),
+	(546, 218814),
+	(547, 1859026),
+	(548, 303),
+	(549, 2511),
+	(550, 27),
+	(551, 28),
+	(552, 188),
+	(553, 46),
+	(554, 216),
+	(555, 63),
+	(556, 202),
+	(557, 192),
+	(558, 257),
+	(559, 170377),
+	(560, 902),
+	(561, 424),
+	(562, 186),
+	(563, 145),
+	(564, 342),
+	(565, 76),
+	(566, 41),
+	(567, 26),
+	(568, 136),
+	(569, 1336),
+	(570, 988),
+	(571, 131),
+	(572, 766),
+	(573, 95),
+	(574, 57),
+	(575, 16),
+	(576, 47),
+	(577, 63),
+	(578, 5),
+	(579, 140),
+	(580, 1263808),
+	(581, 2498),
+	(583, 2),
+	(584, 706),
+	(585, 49),
+	(586, 502),
+	(587, 16),
+	(588, 115),
+	(589, 25),
+	(590, 31),
+	(591, 34),
+	(592, 818),
+	(593, 60),
+	(594, 84),
+	(595, 116),
+	(596, 446),
+	(597, 111),
+	(598, 151),
+	(599, 153),
+	(600, 1408),
+	(601, 165),
+	(602, 575),
+	(603, 163),
+	(604, 309),
+	(605, 52),
+	(606, 40),
+	(607, 116),
+	(608, 749),
+	(609, 231),
+	(610, 171),
+	(611, 218),
+	(612, 1145),
+	(613, 2572),
+	(614, 27),
+	(615, 26),
+	(616, 2060),
+	(617, 173),
+	(618, 1094),
+	(619, 66),
+	(620, 14235),
+	(622, 294),
+	(623, 2),
+	(624, 79374),
+	(625, 1),
+	(626, 3),
+	(627, 7),
+	(628, 335),
+	(629, 27),
+	(630, 47),
+	(631, 113),
+	(632, 589),
+	(633, 56),
+	(634, 75),
+	(635, 85),
+	(636, 740),
+	(637, 118),
+	(638, 180),
+	(639, 149),
+	(640, 1169),
+	(641, 135),
+	(642, 169),
+	(643, 170),
+	(644, 1802),
+	(645, 2481),
+	(646, 28),
+	(647, 78),
+	(648, 5585),
+	(649, 173),
+	(650, 135),
+	(651, 177),
+	(652, 6553),
+	(653, 129),
+	(654, 55),
+	(655, 6),
+	(656, 13250),
+	(657, 5),
+	(658, 15),
+	(659, 3),
+	(660, 39892),
+	(661, 28),
+	(663, 1),
+	(664, 575061),
+	(665, 1),
+	(666, 5),
+	(667, 73),
+	(668, 39),
+	(669, 62),
+	(670, 50),
+	(671, 27),
+	(672, 33),
+	(673, 48),
+	(674, 44),
+	(675, 151),
+	(676, 70),
+	(677, 2540),
+	(678, 150),
+	(679, 109),
+	(680, 117),
+	(681, 95),
+	(682, 80),
+	(683, 44),
+	(684, 34),
+	(685, 31),
+	(686, 125),
+	(687, 146),
+	(688, 423),
+	(689, 142),
+	(690, 154),
+	(691, 135),
+	(692, 194),
+	(693, 48),
+	(694, 6),
+	(695, 141),
+	(696, 47),
+	(697, 9),
+	(699, 1),
+	(701, 1),
+	(702, 2),
+	(703, 81),
+	(704, 3),
+	(705, 4),
+	(706, 23),
+	(707, 131),
+	(708, 31),
+	(709, 2458),
+	(710, 346),
+	(711, 43),
+	(712, 46),
+	(713, 48),
+	(714, 85),
+	(715, 119),
+	(716, 89),
+	(717, 97),
+	(718, 95),
+	(719, 137),
+	(720, 437),
+	(721, 64),
+	(722, 28),
+	(723, 29),
+	(724, 121),
+	(725, 162),
+	(726, 241),
+	(727, 219),
+	(728, 143),
+	(729, 92),
+	(730, 100),
+	(731, 42),
+	(732, 38),
+	(733, 60),
+	(734, 2),
+	(735, 71),
+	(736, 12),
+	(737, 9),
+	(738, 7),
+	(739, 193),
+	(740, 2),
+	(741, 2404),
+	(742, 3),
+	(743, 11),
+	(744, 5),
+	(745, 5),
+	(746, 9),
+	(747, 16),
+	(748, 27),
+	(749, 32),
+	(750, 57),
+	(751, 54),
+	(752, 383),
+	(753, 61),
+	(754, 48),
+	(755, 84),
+	(756, 108),
+	(757, 134),
+	(758, 121),
+	(759, 160),
+	(760, 80),
+	(761, 68),
+	(762, 192),
+	(763, 107),
+	(764, 270),
+	(765, 58),
+	(766, 125),
+	(767, 151),
+	(768, 75),
+	(769, 94),
+	(770, 91),
+	(771, 187),
+	(772, 57),
+	(773, 2371),
+	(774, 8),
+	(775, 93),
+	(776, 107),
+	(777, 20),
+	(779, 1),
+	(780, 22),
+	(781, 1),
+	(783, 6),
+	(784, 318),
+	(785, 25),
+	(786, 31),
+	(787, 23),
+	(788, 28),
+	(789, 62),
+	(790, 53),
+	(791, 41),
+	(792, 68),
+	(793, 60),
+	(794, 88),
+	(795, 108),
+	(796, 63),
+	(797, 100),
+	(798, 68),
+	(799, 72),
+	(800, 83),
+	(801, 46),
+	(802, 36),
+	(803, 157),
+	(804, 139),
+	(805, 2439),
+	(806, 73),
+	(807, 81),
+	(808, 99),
+	(809, 66),
+	(810, 45),
+	(811, 98),
+	(812, 1),
+	(814, 31),
+	(815, 1),
+	(816, 312),
+	(818, 155),
+	(819, 2),
+	(820, 12),
+	(821, 27),
+	(822, 97),
+	(823, 23),
+	(824, 7),
+	(825, 15),
+	(826, 37),
+	(827, 39),
+	(828, 28),
+	(829, 33),
+	(830, 53),
+	(831, 101),
+	(832, 189),
+	(833, 94),
+	(834, 66),
+	(835, 173),
+	(836, 74),
+	(837, 2402),
+	(838, 64),
+	(839, 28),
+	(840, 20),
+	(841, 13),
+	(842, 32),
+	(843, 72),
+	(844, 68),
+	(845, 50),
+	(846, 41),
+	(847, 114),
+	(848, 345),
+	(849, 33),
+	(850, 17),
+	(851, 6),
+	(852, 61),
+	(853, 101),
+	(854, 123),
+	(855, 28),
+	(856, 3),
+	(857, 3),
+	(858, 30),
+	(859, 12),
+	(860, 28),
+	(861, 16),
+	(862, 20),
+	(863, 7),
+	(864, 23),
+	(865, 28),
+	(866, 40),
+	(867, 159),
+	(868, 40),
+	(869, 2361),
+	(870, 92),
+	(871, 88),
+	(872, 193),
+	(873, 61),
+	(874, 58),
+	(875, 67),
+	(876, 65),
+	(877, 46),
+	(878, 55),
+	(879, 30),
+	(880, 334),
+	(881, 74),
+	(882, 121),
+	(883, 107),
+	(884, 36),
+	(885, 66),
+	(886, 22),
+	(887, 25),
+	(888, 24),
+	(889, 10),
+	(890, 44),
+	(891, 5),
+	(892, 84),
+	(893, 4),
+	(894, 1),
+	(895, 7),
+	(896, 3),
+	(897, 8),
+	(898, 3),
+	(899, 126),
+	(900, 13),
+	(901, 2280),
+	(902, 74),
+	(903, 36),
+	(904, 46),
+	(905, 52),
+	(906, 24),
+	(907, 23),
+	(908, 43),
+	(909, 31),
+	(910, 66),
+	(911, 65),
+	(912, 376),
+	(913, 77),
+	(914, 85),
+	(915, 60),
+	(916, 29),
+	(917, 64),
+	(918, 48),
+	(919, 135),
+	(920, 21),
+	(921, 34),
+	(922, 26),
+	(923, 22),
+	(924, 52),
+	(925, 28),
+	(926, 142),
+	(927, 18),
+	(928, 14),
+	(929, 30),
+	(930, 56),
+	(931, 113),
+	(933, 2264),
+	(934, 14),
+	(935, 4),
+	(936, 10),
+	(937, 18),
+	(938, 2),
+	(939, 30),
+	(940, 9),
+	(941, 29),
+	(942, 10),
+	(943, 17),
+	(944, 296),
+	(945, 31),
+	(946, 40),
+	(947, 26),
+	(948, 70),
+	(949, 66),
+	(950, 44),
+	(951, 57),
+	(952, 55),
+	(953, 56),
+	(954, 51),
+	(955, 133),
+	(956, 39),
+	(957, 49),
+	(958, 45),
+	(959, 26),
+	(960, 30),
+	(961, 35),
+	(962, 40),
+	(963, 148),
+	(964, 34),
+	(965, 2264),
+	(966, 50),
+	(967, 21),
+	(968, 2),
+	(970, 24),
+	(972, 45),
+	(973, 8),
+	(974, 11),
+	(975, 20),
+	(976, 287),
+	(977, 20),
+	(978, 6),
+	(979, 9),
+	(980, 99),
+	(981, 32),
+	(982, 10),
+	(983, 13),
+	(984, 26),
+	(985, 30),
+	(986, 31),
+	(987, 38),
+	(988, 25),
+	(989, 32),
+	(990, 44),
+	(991, 125),
+	(992, 58),
+	(993, 44),
+	(994, 25),
+	(995, 140),
+	(996, 25),
+	(997, 2222),
+	(998, 16),
+	(999, 25),
+	(1000, 38),
+	(1001, 66),
+	(1002, 31),
+	(1003, 38),
+	(1004, 38),
+	(1005, 10),
+	(1006, 7),
+	(1008, 283),
+	(1009, 3),
+	(1010, 1),
+	(1011, 17),
+	(1012, 4),
+	(1013, 51),
+	(1014, 1),
+	(1015, 1),
+	(1016, 3),
+	(1017, 12),
+	(1018, 11),
+	(1019, 21),
+	(1020, 31),
+	(1021, 14),
+	(1022, 14),
+	(1023, 23),
+	(1024, 25),
+	(1025, 42),
+	(1026, 39),
+	(1027, 220),
+	(1028, 33),
+	(1029, 2206),
+	(1030, 24),
+	(1031, 64),
+	(1032, 36),
+	(1033, 61),
+	(1034, 123),
+	(1035, 32),
+	(1036, 20),
+	(1037, 15),
+	(1038, 11),
+	(1039, 33),
+	(1040, 311),
+	(1041, 58),
+	(1042, 80),
+	(1043, 29),
+	(1044, 10),
+	(1045, 48),
+	(1046, 18),
+	(1047, 22),
+	(1048, 3),
+	(1049, 17),
+	(1050, 1),
+	(1051, 2),
+	(1052, 5),
+	(1053, 4),
+	(1054, 4),
+	(1055, 1),
+	(1056, 4),
+	(1057, 15),
+	(1058, 11),
+	(1059, 135),
+	(1060, 59),
+	(1061, 2132),
+	(1062, 32),
+	(1063, 116),
+	(1064, 37),
+	(1065, 44),
+	(1066, 42),
+	(1067, 28),
+	(1068, 10),
+	(1069, 36),
+	(1070, 59),
+	(1071, 48),
+	(1072, 332),
+	(1073, 59),
+	(1074, 43),
+	(1075, 19),
+	(1076, 19),
+	(1077, 31),
+	(1078, 31),
+	(1079, 20),
+	(1080, 38),
+	(1081, 58),
+	(1082, 37),
+	(1083, 47),
+	(1084, 19),
+	(1085, 24),
+	(1086, 12),
+	(1087, 26),
+	(1088, 89),
+	(1089, 3),
+	(1091, 108),
+	(1093, 2112),
+	(1094, 13),
+	(1095, 4),
+	(1096, 4),
+	(1097, 17),
+	(1098, 7),
+	(1099, 105),
+	(1100, 12),
+	(1101, 10),
+	(1102, 17),
+	(1103, 19),
+	(1104, 329),
+	(1105, 28),
+	(1106, 58),
+	(1107, 21),
+	(1108, 22),
+	(1109, 63),
+	(1110, 29),
+	(1111, 53),
+	(1112, 84),
+	(1113, 28),
+	(1114, 30),
+	(1115, 22),
+	(1116, 40),
+	(1117, 16),
+	(1118, 20),
+	(1119, 75),
+	(1120, 43),
+	(1121, 49),
+	(1122, 25),
+	(1123, 118),
+	(1124, 8),
+	(1125, 2083),
+	(1126, 21),
+	(1127, 3),
+	(1128, 43),
+	(1129, 1),
+	(1130, 1),
+	(1132, 3),
+	(1133, 1),
+	(1134, 3),
+	(1135, 83),
+	(1136, 266),
+	(1137, 7),
+	(1138, 22),
+	(1139, 14),
+	(1140, 30),
+	(1141, 54),
+	(1142, 125),
+	(1143, 44),
+	(1144, 34),
+	(1145, 19),
+	(1146, 21),
+	(1147, 19),
+	(1148, 46),
+	(1149, 45),
+	(1150, 54),
+	(1151, 22),
+	(1152, 30),
+	(1153, 20),
+	(1154, 7),
+	(1155, 143),
+	(1156, 23),
+	(1157, 2078),
+	(1158, 30),
+	(1159, 23),
+	(1160, 12),
+	(1161, 18),
+	(1162, 6),
+	(1164, 5),
+	(1165, 1),
+	(1168, 254),
+	(1169, 1),
+	(1170, 3),
+	(1171, 95),
+	(1172, 37),
+	(1173, 23),
+	(1174, 7),
+	(1175, 11),
+	(1176, 5),
+	(1177, 14),
+	(1178, 15),
+	(1179, 19),
+	(1180, 10),
+	(1181, 28),
+	(1182, 87),
+	(1183, 35),
+	(1184, 30),
+	(1185, 30),
+	(1186, 38),
+	(1187, 148),
+	(1188, 49),
+	(1189, 2056),
+	(1190, 42),
+	(1191, 41),
+	(1192, 14),
+	(1193, 36),
+	(1194, 37),
+	(1195, 22),
+	(1196, 108),
+	(1197, 62),
+	(1198, 55),
+	(1199, 43),
+	(1200, 261),
+	(1201, 16),
+	(1202, 1),
+	(1203, 9),
+	(1204, 3),
+	(1205, 32),
+	(1207, 81),
+	(1208, 3),
+	(1210, 3),
+	(1212, 4),
+	(1213, 9),
+	(1214, 5),
+	(1215, 6),
+	(1216, 4),
+	(1217, 8),
+	(1218, 13),
+	(1219, 120),
+	(1220, 11),
+	(1221, 1989),
+	(1222, 11),
+	(1223, 20),
+	(1224, 15),
+	(1225, 21),
+	(1226, 23),
+	(1227, 50),
+	(1228, 37),
+	(1229, 51),
+	(1230, 37),
+	(1231, 21),
+	(1232, 256),
+	(1233, 26),
+	(1234, 25),
+	(1235, 21),
+	(1236, 79),
+	(1237, 50),
+	(1238, 21),
+	(1239, 2),
+	(1240, 6),
+	(1241, 8),
+	(1243, 95),
+	(1244, 1),
+	(1247, 1),
+	(1248, 1),
+	(1249, 1),
+	(1250, 96),
+	(1251, 112),
+	(1252, 43),
+	(1253, 1960),
+	(1254, 7),
+	(1255, 13),
+	(1256, 16),
+	(1257, 20),
+	(1258, 19),
+	(1259, 17),
+	(1260, 12),
+	(1261, 5),
+	(1262, 12),
+	(1263, 29),
+	(1264, 272),
+	(1265, 63),
+	(1266, 37),
+	(1267, 36),
+	(1268, 25),
+	(1269, 55),
+	(1270, 38),
+	(1271, 7),
+	(1272, 37),
+	(1273, 10),
+	(1274, 16),
+	(1275, 28),
+	(1276, 18),
+	(1277, 11),
+	(1278, 8),
+	(1279, 91),
+	(1280, 1),
+	(1282, 1),
+	(1283, 110),
+	(1284, 20),
+	(1285, 1923),
+	(1287, 3),
+	(1288, 1),
+	(1290, 23),
+	(1291, 4),
+	(1292, 4),
+	(1293, 12),
+	(1294, 19),
+	(1295, 8),
+	(1296, 248),
+	(1297, 21),
+	(1298, 12),
+	(1299, 31),
+	(1300, 10),
+	(1301, 60),
+	(1302, 1),
+	(1303, 8),
+	(1304, 99),
+	(1305, 29),
+	(1306, 29),
+	(1307, 28),
+	(1308, 33),
+	(1309, 19),
+	(1310, 8),
+	(1311, 1),
+	(1313, 11),
+	(1314, 12),
+	(1315, 236),
+	(1316, 18),
+	(1317, 1891),
+	(1318, 2),
+	(1322, 21),
+	(1324, 1),
+	(1326, 8),
+	(1327, 3),
+	(1328, 235),
+	(1329, 4),
+	(1330, 1),
+	(1331, 2),
+	(1332, 5),
+	(1333, 38),
+	(1334, 2),
+	(1335, 30),
+	(1336, 18),
+	(1337, 31),
+	(1338, 8),
+	(1339, 5),
+	(1340, 11),
+	(1341, 9),
+	(1342, 12),
+	(1343, 11),
+	(1344, 79),
+	(1345, 37),
+	(1346, 19),
+	(1347, 136),
+	(1348, 9),
+	(1349, 1861),
+	(1350, 8),
+	(1351, 112),
+	(1352, 10),
+	(1353, 3),
+	(1354, 16),
+	(1355, 4),
+	(1356, 12),
+	(1357, 18),
+	(1358, 67),
+	(1359, 6),
+	(1360, 229),
+	(1361, 1),
+	(1362, 1),
+	(1364, 1),
+	(1365, 27),
+	(1366, 6),
+	(1368, 14),
+	(1370, 8),
+	(1371, 29),
+	(1372, 3),
+	(1373, 21),
+	(1374, 8),
+	(1375, 6),
+	(1376, 3),
+	(1377, 9),
+	(1378, 9),
+	(1379, 120),
+	(1380, 5),
+	(1381, 1833),
+	(1382, 45),
+	(1383, 35),
+	(1384, 23),
+	(1385, 25),
+	(1386, 26),
+	(1387, 159),
+	(1388, 24),
+	(1389, 16),
+	(1390, 16),
+	(1391, 14),
+	(1392, 273),
+	(1393, 17),
+	(1394, 9),
+	(1395, 5),
+	(1396, 14),
+	(1397, 24),
+	(1398, 27),
+	(1400, 2),
+	(1404, 5),
+	(1405, 8),
+	(1406, 3),
+	(1407, 25),
+	(1408, 2),
+	(1409, 22),
+	(1410, 10),
+	(1411, 111),
+	(1412, 89),
+	(1413, 1793),
+	(1414, 4),
+	(1415, 9),
+	(1416, 16),
+	(1417, 13),
+	(1418, 13),
+	(1419, 13),
+	(1420, 15),
+	(1421, 19),
+	(1422, 26),
+	(1423, 110),
+	(1424, 229),
+	(1425, 11),
+	(1426, 10),
+	(1427, 7),
+	(1428, 7),
+	(1429, 28),
+	(1430, 12),
+	(1431, 11),
+	(1432, 14),
+	(1433, 2),
+	(1434, 2),
+	(1436, 1),
+	(1437, 1),
+	(1438, 13),
+	(1439, 1),
+	(1440, 1),
+	(1441, 1),
+	(1442, 2),
+	(1443, 132),
+	(1444, 5),
+	(1445, 1795),
+	(1448, 11),
+	(1449, 10),
+	(1450, 11),
+	(1451, 8),
+	(1452, 47),
+	(1453, 6),
+	(1454, 8),
+	(1455, 12),
+	(1456, 229),
+	(1457, 15),
+	(1458, 12),
+	(1459, 121),
+	(1460, 15),
+	(1461, 48),
+	(1462, 49),
+	(1463, 22),
+	(1464, 11),
+	(1465, 9),
+	(1466, 81),
+	(1467, 1),
+	(1468, 1),
+	(1469, 6),
+	(1470, 6),
+	(1471, 6),
+	(1472, 9),
+	(1473, 12),
+	(1474, 2),
+	(1475, 109),
+	(1476, 5),
+	(1477, 1721),
+	(1478, 1),
+	(1479, 28),
+	(1480, 7),
+	(1481, 23),
+	(1482, 2),
+	(1483, 12),
+	(1484, 5),
+	(1485, 3),
+	(1486, 2),
+	(1487, 4),
+	(1488, 219),
+	(1489, 7),
+	(1490, 8),
+	(1491, 10),
+	(1492, 16),
+	(1493, 32),
+	(1494, 25),
+	(1495, 96),
+	(1496, 13),
+	(1497, 15),
+	(1498, 16),
+	(1499, 12),
+	(1500, 14),
+	(1501, 19),
+	(1502, 7),
+	(1503, 11),
+	(1504, 3),
+	(1505, 8),
+	(1506, 41),
+	(1507, 108),
+	(1508, 25),
+	(1509, 1719),
+	(1510, 8),
+	(1511, 10),
+	(1514, 2),
+	(1515, 25),
+	(1516, 2),
+	(1517, 32),
+	(1518, 6),
+	(1519, 7),
+	(1520, 273),
+	(1521, 2),
+	(1522, 6),
+	(1523, 5),
+	(1524, 6),
+	(1525, 36),
+	(1526, 3),
+	(1527, 12),
+	(1528, 7),
+	(1529, 9),
+	(1530, 12),
+	(1531, 107),
+	(1532, 44),
+	(1533, 17),
+	(1534, 12),
+	(1535, 18),
+	(1536, 12),
+	(1537, 26),
+	(1538, 35),
+	(1539, 131),
+	(1540, 15),
+	(1541, 1693),
+	(1542, 11),
+	(1543, 7),
+	(1544, 2),
+	(1545, 6),
+	(1546, 14),
+	(1547, 6),
+	(1548, 2),
+	(1549, 24),
+	(1550, 2),
+	(1551, 33),
+	(1552, 206),
+	(1553, 18),
+	(1555, 1),
+	(1556, 7),
+	(1557, 38),
+	(1558, 6),
+	(1559, 3),
+	(1560, 21),
+	(1562, 2),
+	(1563, 5),
+	(1564, 7),
+	(1565, 5),
+	(1566, 6),
+	(1567, 110),
+	(1568, 9),
+	(1569, 16),
+	(1570, 13),
+	(1571, 109),
+	(1572, 6),
+	(1573, 1664),
+	(1574, 53),
+	(1575, 14),
+	(1576, 21),
+	(1577, 31),
+	(1578, 42),
+	(1579, 13),
+	(1580, 10),
+	(1581, 12),
+	(1582, 11),
+	(1583, 85),
+	(1584, 202),
+	(1585, 7),
+	(1586, 6),
+	(1587, 25),
+	(1588, 5),
+	(1589, 41),
+	(1590, 4),
+	(1591, 5),
+	(1593, 1),
+	(1595, 5),
+	(1596, 11),
+	(1598, 1),
+	(1599, 1),
+	(1600, 1),
+	(1601, 4),
+	(1602, 19),
+	(1603, 200),
+	(1604, 10),
+	(1605, 1640),
+	(1606, 15),
+	(1607, 14),
+	(1608, 7),
+	(1609, 12),
+	(1610, 5),
+	(1611, 2),
+	(1612, 3),
+	(1613, 7),
+	(1614, 37),
+	(1615, 4),
+	(1616, 203),
+	(1617, 13),
+	(1618, 3),
+	(1619, 12),
+	(1620, 38),
+	(1621, 22),
+	(1622, 12),
+	(1623, 43),
+	(1624, 19),
+	(1625, 35),
+	(1626, 15),
+	(1627, 26),
+	(1628, 43),
+	(1629, 2),
+	(1630, 10),
+	(1631, 1),
+	(1633, 1),
+	(1634, 1),
+	(1635, 110),
+	(1637, 1612),
+	(1638, 1),
+	(1639, 107),
+	(1640, 1),
+	(1641, 2),
+	(1643, 7),
+	(1644, 9),
+	(1645, 8),
+	(1646, 3),
+	(1647, 19),
+	(1648, 206),
+	(1649, 2),
+	(1650, 9),
+	(1651, 8),
+	(1652, 19),
+	(1653, 22),
+	(1654, 4),
+	(1655, 13),
+	(1656, 3),
+	(1657, 5),
+	(1658, 5),
+	(1659, 35),
+	(1660, 10),
+	(1661, 26),
+	(1662, 8),
+	(1663, 10),
+	(1664, 7),
+	(1665, 4),
+	(1666, 2),
+	(1667, 110),
+	(1668, 12),
+	(1669, 1594),
+	(1670, 1),
+	(1671, 2),
+	(1672, 15),
+	(1673, 4),
+	(1674, 2),
+	(1675, 303),
+	(1676, 12),
+	(1678, 1),
+	(1680, 194),
+	(1681, 1),
+	(1682, 40),
+	(1683, 2),
+	(1684, 2),
+	(1685, 19),
+	(1686, 16),
+	(1687, 2),
+	(1688, 6),
+	(1689, 9),
+	(1690, 18),
+	(1691, 15),
+	(1692, 5),
+	(1693, 7),
+	(1694, 6),
+	(1695, 32),
+	(1696, 4),
+	(1697, 34),
+	(1698, 1),
+	(1699, 117),
+	(1700, 5),
+	(1701, 1590),
+	(1702, 20),
+	(1703, 4),
+	(1704, 6),
+	(1705, 20),
+	(1707, 2),
+	(1710, 3),
+	(1711, 89),
+	(1712, 195),
+	(1713, 4),
+	(1714, 2),
+	(1715, 1),
+	(1716, 3),
+	(1717, 16),
+	(1718, 9),
+	(1719, 2),
+	(1720, 3),
+	(1723, 18),
+	(1724, 1),
+	(1725, 2),
+	(1726, 3),
+	(1727, 3),
+	(1728, 9),
+	(1729, 5),
+	(1730, 7),
+	(1731, 132),
+	(1732, 28),
+	(1733, 1585),
+	(1734, 5),
+	(1735, 3),
+	(1736, 5),
+	(1737, 27),
+	(1738, 4),
+	(1739, 19),
+	(1740, 15),
+	(1741, 4),
+	(1742, 15),
+	(1743, 9),
+	(1744, 183),
+	(1745, 12),
+	(1747, 119),
+	(1748, 1),
+	(1749, 15),
+	(1750, 5),
+	(1754, 1),
+	(1757, 2),
+	(1758, 8),
+	(1759, 7),
+	(1760, 7),
+	(1761, 2),
+	(1762, 13),
+	(1763, 113),
+	(1764, 8),
+	(1765, 1547),
+	(1766, 7),
+	(1767, 21),
+	(1768, 3),
+	(1769, 34),
+	(1770, 5),
+	(1772, 6),
+	(1773, 7),
+	(1774, 12),
+	(1775, 9),
+	(1776, 189),
+	(1777, 25),
+	(1778, 10),
+	(1779, 4),
+	(1780, 1),
+	(1781, 21),
+	(1782, 3),
+	(1783, 186),
+	(1784, 2),
+	(1787, 1),
+	(1788, 10),
+	(1789, 8),
+	(1790, 1),
+	(1791, 34),
+	(1792, 1),
+	(1793, 1),
+	(1794, 1),
+	(1795, 108),
+	(1796, 4),
+	(1797, 1519),
+	(1798, 9),
+	(1799, 9),
+	(1800, 3),
+	(1801, 6),
+	(1802, 4),
+	(1803, 35),
+	(1804, 15),
+	(1805, 30),
+	(1806, 5),
+	(1807, 7),
+	(1808, 192),
+	(1809, 8),
+	(1811, 4),
+	(1812, 24),
+	(1813, 36),
+	(1814, 4),
+	(1815, 14),
+	(1816, 2),
+	(1817, 2),
+	(1818, 4),
+	(1819, 72),
+	(1820, 3),
+	(1822, 1),
+	(1823, 4),
+	(1825, 1),
+	(1826, 5),
+	(1827, 104),
+	(1828, 1),
+	(1829, 1494),
+	(1830, 11),
+	(1831, 5),
+	(1832, 2),
+	(1833, 2),
+	(1834, 2),
+	(1835, 4),
+	(1836, 9),
+	(1837, 1),
+	(1838, 14),
+	(1839, 33),
+	(1840, 188),
+	(1841, 27),
+	(1842, 13),
+	(1843, 10),
+	(1844, 28),
+	(1845, 52),
+	(1846, 17),
+	(1847, 40),
+	(1848, 35),
+	(1849, 6),
+	(1850, 6),
+	(1851, 2),
+	(1853, 4),
+	(1854, 6),
+	(1855, 77),
+	(1856, 1),
+	(1859, 106),
+	(1860, 2),
+	(1861, 1466),
+	(1863, 2),
+	(1866, 1),
+	(1869, 1),
+	(1870, 2),
+	(1872, 179),
+	(1873, 1),
+	(1874, 9),
+	(1875, 29),
+	(1876, 15),
+	(1877, 43),
+	(1878, 2),
+	(1880, 8),
+	(1881, 13),
+	(1882, 18),
+	(1883, 12),
+	(1884, 14),
+	(1885, 18),
+	(1886, 16),
+	(1887, 6),
+	(1888, 2),
+	(1889, 3),
+	(1890, 9),
+	(1891, 196),
+	(1892, 13),
+	(1893, 1456),
+	(1894, 14),
+	(1895, 8),
+	(1896, 2),
+	(1898, 1),
+	(1899, 17),
+	(1900, 5),
+	(1901, 1),
+	(1904, 175),
+	(1905, 1),
+	(1906, 2),
+	(1907, 3),
+	(1908, 6),
+	(1909, 10),
+	(1910, 3),
+	(1911, 22),
+	(1912, 6),
+	(1913, 22),
+	(1914, 6),
+	(1915, 10),
+	(1916, 5),
+	(1917, 2),
+	(1918, 6),
+	(1919, 4),
+	(1920, 7),
+	(1921, 14),
+	(1922, 4),
+	(1923, 107),
+	(1924, 10),
+	(1925, 1434),
+	(1926, 7),
+	(1927, 76),
+	(1928, 4),
+	(1929, 7),
+	(1930, 10),
+	(1931, 14),
+	(1932, 6),
+	(1933, 15),
+	(1934, 4),
+	(1935, 2),
+	(1936, 182),
+	(1937, 2),
+	(1939, 11),
+	(1940, 1),
+	(1941, 4),
+	(1942, 2),
+	(1943, 9),
+	(1944, 1),
+	(1947, 24),
+	(1949, 22),
+	(1952, 15),
+	(1953, 14),
+	(1954, 5),
+	(1955, 111),
+	(1956, 11),
+	(1957, 1435),
+	(1958, 5),
+	(1959, 5),
+	(1960, 10),
+	(1961, 6),
+	(1962, 11),
+	(1963, 95),
+	(1964, 11),
+	(1965, 7),
+	(1966, 7),
+	(1967, 2),
+	(1968, 182),
+	(1969, 6),
+	(1970, 15),
+	(1972, 7),
+	(1973, 11),
+	(1974, 6),
+	(1975, 2),
+	(1976, 6),
+	(1977, 3),
+	(1978, 2),
+	(1983, 24),
+	(1985, 26),
+	(1986, 3),
+	(1987, 109),
+	(1988, 3),
+	(1989, 1421),
+	(1990, 1),
+	(1991, 3),
+	(1992, 8),
+	(1993, 4),
+	(1994, 6),
+	(1995, 5),
+	(1996, 13),
+	(1997, 6),
+	(1998, 10),
+	(1999, 92),
+	(2000, 181),
+	(2001, 5),
+	(2002, 5),
+	(2003, 1),
+	(2004, 1),
+	(2005, 14),
+	(2006, 12),
+	(2007, 10),
+	(2008, 7),
+	(2009, 9),
+	(2010, 6),
+	(2011, 8),
+	(2012, 13),
+	(2013, 2),
+	(2014, 2),
+	(2018, 1),
+	(2019, 128),
+	(2021, 1429),
+	(2022, 4),
+	(2026, 2),
+	(2027, 2),
+	(2030, 7),
+	(2032, 175),
+	(2033, 1),
+	(2035, 90),
+	(2036, 3),
+	(2037, 11),
+	(2038, 2),
+	(2039, 4),
+	(2040, 3),
+	(2041, 2),
+	(2042, 1),
+	(2043, 2),
+	(2044, 5),
+	(2045, 1),
+	(2046, 3),
+	(2047, 21),
+	(2048, 5),
+	(2050, 16),
+	(2051, 120),
+	(2053, 1403),
+	(2054, 4),
+	(2055, 29),
+	(2057, 26),
+	(2058, 3),
+	(2059, 4),
+	(2060, 4),
+	(2061, 7),
+	(2063, 1),
+	(2065, 170),
+	(2066, 3),
+	(2067, 2),
+	(2068, 7),
+	(2069, 13),
+	(2071, 77),
+	(2072, 1),
+	(2075, 4),
+	(2077, 1),
+	(2078, 2),
+	(2079, 5),
+	(2080, 4),
+	(2081, 3),
+	(2082, 3),
+	(2083, 2),
+	(2084, 293),
+	(2085, 6),
+	(2086, 1395),
+	(2087, 2),
+	(2089, 4),
+	(2090, 10),
+	(2091, 26),
+	(2092, 14),
+	(2093, 25),
+	(2097, 170),
+	(2099, 2),
+	(2100, 1),
+	(2101, 8),
+	(2102, 5),
+	(2104, 2),
+	(2105, 2),
+	(2107, 90),
+	(2108, 1),
+	(2110, 15),
+	(2112, 1),
+	(2113, 1),
+	(2114, 3),
+	(2115, 8),
+	(2116, 3),
+	(2117, 5),
+	(2118, 1380),
+	(2119, 4),
+	(2120, 1),
+	(2121, 3),
+	(2122, 1),
+	(2123, 6),
+	(2124, 24),
+	(2125, 1),
+	(2127, 33),
+	(2128, 4),
+	(2129, 197),
+	(2132, 1),
+	(2133, 3),
+	(2134, 8),
+	(2141, 1),
+	(2143, 95),
+	(2144, 6),
+	(2146, 1),
+	(2147, 1),
+	(2148, 3),
+	(2150, 1369),
+	(2152, 1),
+	(2153, 1),
+	(2155, 5),
+	(2156, 7),
+	(2157, 12),
+	(2158, 2),
+	(2159, 6),
+	(2160, 7),
+	(2161, 174),
+	(2162, 22),
+	(2163, 27),
+	(2164, 5),
+	(2165, 24),
+	(2166, 6),
+	(2169, 8),
+	(2170, 2),
+	(2171, 1),
+	(2172, 1),
+	(2174, 8),
+	(2175, 10),
+	(2176, 2),
+	(2177, 3),
+	(2179, 72),
+	(2180, 4),
+	(2181, 1),
+	(2182, 1366),
+	(2183, 2),
+	(2184, 5),
+	(2185, 4),
+	(2188, 3),
+	(2191, 1),
+	(2192, 2),
+	(2193, 169),
+	(2198, 7),
+	(2199, 27),
+	(2201, 28),
+	(2205, 2),
+	(2206, 2),
+	(2209, 9),
+	(2213, 8),
+	(2214, 1364),
+	(2215, 95),
+	(2216, 1),
+	(2217, 2),
+	(2218, 1),
+	(2219, 1),
+	(2220, 3),
+	(2221, 2),
+	(2222, 3),
+	(2223, 41),
+	(2225, 168),
+	(2228, 1),
+	(2229, 6),
+	(2230, 8),
+	(2231, 1),
+	(2232, 2),
+	(2233, 6),
+	(2234, 1),
+	(2235, 41),
+	(2236, 2),
+	(2237, 17),
+	(2240, 7),
+	(2242, 6),
+	(2244, 1),
+	(2246, 1350),
+	(2249, 2),
+	(2250, 4),
+	(2251, 89),
+	(2252, 1),
+	(2257, 167),
+	(2260, 4),
+	(2261, 3),
+	(2262, 6),
+	(2265, 1),
+	(2269, 2),
+	(2270, 4),
+	(2271, 32),
+	(2273, 21),
+	(2274, 1),
+	(2275, 3),
+	(2276, 1),
+	(2277, 2),
+	(2278, 1344),
+	(2279, 2),
+	(2280, 1),
+	(2281, 1),
+	(2284, 1),
+	(2287, 98),
+	(2288, 2),
+	(2289, 168),
+	(2292, 3),
+	(2293, 3),
+	(2294, 4),
+	(2298, 3),
+	(2303, 9),
+	(2307, 26),
+	(2308, 1),
+	(2309, 30),
+	(2310, 1344),
+	(2314, 1),
+	(2318, 1),
+	(2321, 164),
+	(2323, 1),
+	(2324, 82),
+	(2325, 1),
+	(2326, 5),
+	(2327, 1),
+	(2334, 6),
+	(2338, 1),
+	(2339, 1),
+	(2340, 1),
+	(2342, 1337),
+	(2343, 55),
+	(2344, 27),
+	(2345, 6),
+	(2346, 25),
+	(2347, 1),
+	(2348, 18),
+	(2350, 1),
+	(2351, 3),
+	(2352, 2),
+	(2353, 166),
+	(2358, 6),
+	(2360, 87),
+	(2361, 3),
+	(2362, 1),
+	(2373, 9),
+	(2374, 1330),
+	(2376, 1),
+	(2377, 1),
+	(2378, 11),
+	(2379, 4),
+	(2380, 28),
+	(2382, 29),
+	(2383, 2),
+	(2384, 8),
+	(2385, 169),
+	(2386, 4),
+	(2387, 9),
+	(2388, 8),
+	(2389, 4),
+	(2390, 15),
+	(2392, 1),
+	(2396, 117),
+	(2397, 4),
+	(2399, 1),
+	(2406, 1330),
+	(2410, 1),
+	(2414, 1),
+	(2415, 4),
+	(2416, 26),
+	(2417, 164),
+	(2418, 31),
+	(2421, 3),
+	(2422, 4),
+	(2424, 6),
+	(2425, 3),
+	(2426, 3),
+	(2427, 5),
+	(2428, 1),
+	(2429, 2),
+	(2432, 100),
+	(2433, 1),
+	(2435, 1),
+	(2436, 1),
+	(2438, 1328),
+	(2441, 10),
+	(2443, 11),
+	(2448, 2),
+	(2449, 163),
+	(2451, 1),
+	(2452, 27),
+	(2453, 8),
+	(2454, 24),
+	(2455, 1),
+	(2456, 2),
+	(2457, 2),
+	(2460, 4),
+	(2465, 5),
+	(2466, 3),
+	(2468, 95),
+	(2469, 6),
+	(2470, 1324),
+	(2471, 1),
+	(2472, 1),
+	(2476, 2),
+	(2477, 2),
+	(2478, 2),
+	(2479, 4),
+	(2481, 163),
+	(2484, 2),
+	(2485, 6),
+	(2486, 2),
+	(2488, 23),
+	(2489, 1),
+	(2490, 26),
+	(2491, 1),
+	(2493, 1),
+	(2494, 1),
+	(2495, 3),
+	(2496, 1),
+	(2500, 3),
+	(2502, 1327),
+	(2503, 1),
+	(2504, 93),
+	(2505, 2),
+	(2506, 1),
+	(2511, 4),
+	(2513, 166),
+	(2516, 3),
+	(2517, 5),
+	(2518, 8),
+	(2519, 2),
+	(2521, 1),
+	(2524, 27),
+	(2526, 20),
+	(2532, 1),
+	(2534, 1320),
+	(2535, 1),
+	(2540, 114),
+	(2541, 1),
+	(2543, 1),
+	(2545, 163),
+	(2550, 3),
+	(2555, 3),
+	(2557, 4),
+	(2558, 3),
+	(2559, 2),
+	(2560, 26),
+	(2561, 6),
+	(2562, 26),
+	(2564, 5),
+	(2565, 1),
+	(2566, 1325),
+	(2567, 5),
+	(2568, 9),
+	(2569, 10),
+	(2570, 2),
+	(2571, 1),
+	(2576, 97),
+	(2577, 165),
+	(2582, 3),
+	(2583, 5),
+	(2593, 2),
+	(2596, 42),
+	(2597, 1),
+	(2598, 1336),
+	(2602, 1),
+	(2609, 163),
+	(2612, 97),
+	(2613, 1),
+	(2614, 2),
+	(2619, 1),
+	(2621, 2),
+	(2624, 2),
+	(2628, 2),
+	(2630, 1684946),
+	(2632, 27),
+	(2633, 2),
+	(2634, 25),
+	(2635, 1),
+	(2637, 4),
+	(2639, 1),
+	(2640, 1),
+	(2641, 163),
+	(2644, 1),
+	(2645, 3),
+	(2646, 2),
+	(2648, 112),
+	(2649, 1),
+	(2653, 5),
+	(2659, 3),
+	(2660, 1),
+	(2661, 1),
+	(2662, 1315),
+	(2664, 1),
+	(2668, 30),
+	(2669, 1),
+	(2670, 26),
+	(2673, 163),
+	(2674, 2),
+	(2675, 1),
+	(2678, 7),
+	(2679, 1),
+	(2680, 1),
+	(2684, 90),
+	(2685, 1),
+	(2686, 1),
+	(2694, 1315),
+	(2699, 1),
+	(2701, 1),
+	(2704, 30),
+	(2705, 163),
+	(2706, 27),
+	(2710, 2),
+	(2712, 1),
+	(2720, 112),
+	(2721, 2),
+	(2723, 5),
+	(2726, 1316),
+	(2736, 1),
+	(2737, 165),
+	(2738, 2),
+	(2740, 25),
+	(2742, 33),
+	(2745, 1),
+	(2756, 97),
+	(2757, 1),
+	(2758, 1315),
+	(2769, 163),
+	(2774, 3),
+	(2776, 32),
+	(2778, 34),
+	(2781, 1),
+	(2782, 1),
+	(2784, 1),
+	(2790, 1313),
+	(2792, 94),
+	(2793, 12),
+	(2796, 1),
+	(2800, 1),
+	(2801, 163),
+	(2804, 2),
+	(2805, 6),
+	(2806, 2),
+	(2807, 2),
+	(2809, 1),
+	(2810, 1),
+	(2812, 23),
+	(2814, 33),
+	(2815, 3),
+	(2816, 1),
+	(2820, 2),
+	(2821, 1),
+	(2822, 1314),
+	(2824, 1),
+	(2828, 104),
+	(2829, 1),
+	(2833, 163),
+	(2837, 6),
+	(2838, 4),
+	(2839, 1),
+	(2848, 32),
+	(2849, 4),
+	(2850, 32),
+	(2852, 4),
+	(2853, 1),
+	(2854, 1312),
+	(2861, 1),
+	(2863, 52),
+	(2864, 111),
+	(2865, 164),
+	(2868, 2),
+	(2869, 15),
+	(2870, 2),
+	(2871, 1),
+	(2884, 30),
+	(2886, 1333),
+	(2890, 2),
+	(2891, 2),
+	(2892, 3),
+	(2893, 4),
+	(2894, 2),
+	(2897, 163),
+	(2899, 3),
+	(2900, 230),
+	(2901, 1),
+	(2902, 2),
+	(2908, 2),
+	(2911, 1),
+	(2918, 1312),
+	(2920, 42),
+	(2922, 25),
+	(2923, 1),
+	(2925, 1),
+	(2929, 165),
+	(2930, 2),
+	(2931, 5),
+	(2932, 4),
+	(2933, 8),
+	(2934, 2),
+	(2936, 110),
+	(2937, 1),
+	(2938, 1),
+	(2939, 1),
+	(2948, 1),
+	(2950, 1313),
+	(2956, 38),
+	(2958, 32),
+	(2961, 163),
+	(2964, 1),
+	(2966, 4),
+	(2967, 2),
+	(2969, 1),
+	(2971, 1),
+	(2972, 151),
+	(2973, 1),
+	(2975, 3),
+	(2976, 4),
+	(2977, 3),
+	(2978, 1),
+	(2979, 1),
+	(2980, 1),
+	(2982, 1312),
+	(2992, 28),
+	(2993, 163),
+	(2994, 29),
+	(2998, 2),
+	(3006, 1),
+	(3007, 2),
+	(3008, 188),
+	(3009, 2),
+	(3014, 1311),
+	(3015, 5),
+	(3016, 9),
+	(3017, 1),
+	(3020, 1),
+	(3025, 164),
+	(3028, 27),
+	(3030, 31),
+	(3044, 223),
+	(3045, 1),
+	(3046, 1311),
+	(3048, 1),
+	(3057, 163),
+	(3061, 2),
+	(3062, 4),
+	(3064, 41),
+	(3066, 35),
+	(3076, 2),
+	(3078, 1310),
+	(3080, 151),
+	(3081, 2),
+	(3089, 163),
+	(3094, 2),
+	(3100, 35),
+	(3101, 2),
+	(3102, 38),
+	(3104, 2),
+	(3110, 1310),
+	(3116, 106),
+	(3117, 2),
+	(3121, 163),
+	(3125, 5),
+	(3126, 2),
+	(3132, 2),
+	(3136, 36),
+	(3138, 39),
+	(3140, 2),
+	(3141, 1),
+	(3142, 1309),
+	(3143, 1),
+	(3144, 1),
+	(3152, 120),
+	(3153, 164),
+	(3155, 1),
+	(3157, 1),
+	(3158, 2),
+	(3163, 1),
+	(3164, 1),
+	(3172, 34),
+	(3174, 1343),
+	(3185, 163),
+	(3188, 136),
+	(3189, 1),
+	(3190, 2),
+	(3203, 1),
+	(3204, 1),
+	(3206, 1308),
+	(3208, 53),
+	(3210, 52),
+	(3217, 163),
+	(3220, 38),
+	(3221, 114),
+	(3222, 2),
+	(3224, 141),
+	(3225, 5),
+	(3230, 1),
+	(3236, 38),
+	(3238, 1308),
+	(3244, 35),
+	(3246, 46),
+	(3249, 163),
+	(3254, 2),
+	(3260, 105),
+	(3261, 4),
+	(3263, 1),
+	(3270, 1308),
+	(3280, 38),
+	(3281, 163),
+	(3282, 28),
+	(3286, 3),
+	(3292, 1),
+	(3296, 138),
+	(3297, 1),
+	(3301, 1),
+	(3302, 1308),
+	(3304, 1),
+	(3313, 163),
+	(3316, 33),
+	(3318, 34),
+	(3329, 1),
+	(3331, 1),
+	(3332, 120),
+	(3333, 1),
+	(3334, 1309),
+	(3345, 163),
+	(3350, 3),
+	(3352, 34),
+	(3354, 31),
+	(3357, 1),
+	(3366, 1307),
+	(3368, 230),
+	(3369, 6),
+	(3377, 163),
+	(3382, 2),
+	(3388, 37),
+	(3390, 45),
+	(3398, 1307),
+	(3404, 3128),
+	(3405, 2),
+	(3409, 163),
+	(3414, 2),
+	(3424, 40),
+	(3426, 23),
+	(3430, 1307),
+	(3440, 117),
+	(3441, 164),
+	(3446, 2),
+	(3460, 30),
+	(3462, 1344),
+	(3469, 1),
+	(3473, 163),
+	(3476, 116),
+	(3477, 1),
+	(3478, 3),
+	(3494, 1305),
+	(3496, 36),
+	(3498, 38),
+	(3501, 2),
+	(3504, 2),
+	(3505, 163),
+	(3510, 2),
+	(3512, 124),
+	(3513, 4),
+	(3515, 1),
+	(3525, 1),
+	(3526, 1305),
+	(3532, 27),
+	(3534, 33),
+	(3537, 165),
+	(3541, 2),
+	(3542, 2),
+	(3544, 2),
+	(3548, 119),
+	(3549, 1),
+	(3558, 1305),
+	(3568, 29),
+	(3569, 163),
+	(3570, 53),
+	(3574, 2),
+	(3581, 6),
+	(3584, 115),
+	(3585, 2),
+	(3590, 1306),
+	(3601, 163),
+	(3604, 39),
+	(3606, 45),
+	(3620, 107),
+	(3621, 1),
+	(3622, 1304),
+	(3633, 163),
+	(3634, 1),
+	(3637, 1),
+	(3638, 2),
+	(3640, 43),
+	(3642, 35),
+	(3654, 1305),
+	(3656, 126),
+	(3657, 2),
+	(3661, 1),
+	(3664, 1),
+	(3665, 163),
+	(3670, 3),
+	(3676, 32),
+	(3678, 48),
+	(3679, 1),
+	(3686, 1303),
+	(3692, 128),
+	(3693, 2),
+	(3697, 163),
+	(3702, 3),
+	(3712, 33),
+	(3714, 28),
+	(3718, 1302),
+	(3728, 137),
+	(3729, 165),
+	(3734, 2),
+	(3748, 54),
+	(3749, 1),
+	(3750, 1333),
+	(3758, 1),
+	(3761, 163),
+	(3764, 125),
+	(3765, 2),
+	(3766, 3),
+	(3782, 1301),
+	(3784, 32),
+	(3786, 50),
+	(3793, 163),
+	(3798, 2),
+	(3800, 123),
+	(3801, 3),
+	(3805, 1),
+	(3814, 1301),
+	(3820, 53),
+	(3822, 30),
+	(3825, 163),
+	(3830, 2),
+	(3833, 1),
+	(3836, 109),
+	(3837, 3),
+	(3846, 1301),
+	(3856, 35),
+	(3857, 163),
+	(3858, 54),
+	(3860, 20),
+	(3861, 51),
+	(3862, 2),
+	(3872, 124),
+	(3873, 2),
+	(3876, 17),
+	(3878, 1302),
+	(3882, 1),
+	(3889, 163),
+	(3892, 45),
+	(3894, 47),
+	(3901, 2),
+	(3903, 1),
+	(3904, 2),
+	(3908, 138),
+	(3909, 2),
+	(3910, 1300),
+	(3917, 2),
+	(3921, 163),
+	(3926, 2),
+	(3928, 38),
+	(3930, 37),
+	(3942, 1300),
+	(3944, 137),
+	(3945, 2),
+	(3953, 163),
+	(3958, 2),
+	(3964, 66),
+	(3966, 37),
+	(3971, 1),
+	(3974, 1300),
+	(3980, 166),
+	(3981, 1),
+	(3985, 163),
+	(3990, 2),
+	(4000, 35),
+	(4002, 54),
+	(4006, 1300),
+	(4016, 150),
+	(4017, 164),
+	(4021, 38),
+	(4022, 2),
+	(4024, 38),
+	(4036, 47),
+	(4038, 1347),
+	(4049, 163),
+	(4052, 134),
+	(4053, 10),
+	(4054, 2),
+	(4068, 1),
+	(4070, 1300),
+	(4072, 52),
+	(4074, 40),
+	(4075, 1),
+	(4081, 163),
+	(4085, 7),
+	(4086, 2),
+	(4088, 123),
+	(4089, 4),
+	(4100, 2),
+	(4102, 1300),
+	(4108, 38),
+	(4110, 43),
+	(4113, 163),
+	(4118, 2),
+	(4119, 2),
+	(4124, 159),
+	(4125, 3),
+	(4128, 1),
+	(4134, 1299),
+	(4141, 1),
+	(4144, 51),
+	(4145, 163),
+	(4146, 41),
+	(4150, 2),
+	(4152, 30),
+	(4160, 153),
+	(4161, 1),
+	(4164, 2),
+	(4166, 1299),
+	(4177, 163),
+	(4180, 225),
+	(4181, 596),
+	(4182, 50),
+	(4187, 1),
+	(4196, 373),
+	(4197, 3),
+	(4198, 1299),
+	(4209, 163),
+	(4214, 2),
+	(4216, 66),
+	(4217, 3),
+	(4218, 69),
+	(4221, 1),
+	(4230, 1299),
+	(4232, 158),
+	(4233, 2),
+	(4241, 163),
+	(4246, 2),
+	(4252, 45),
+	(4253, 1),
+	(4254, 48),
+	(4262, 1300),
+	(4267, 2),
+	(4268, 145),
+	(4269, 3),
+	(4270, 1),
+	(4271, 1),
+	(4273, 163),
+	(4278, 3),
+	(4288, 75),
+	(4290, 36),
+	(4294, 1298),
+	(4301, 1),
+	(4304, 173),
+	(4305, 166),
+	(4309, 2),
+	(4310, 2),
+	(4324, 52),
+	(4326, 1359),
+	(4337, 163),
+	(4340, 195),
+	(4341, 2),
+	(4342, 3),
+	(4358, 1297),
+	(4360, 76),
+	(4362, 56),
+	(4365, 2),
+	(4369, 163),
+	(4374, 2),
+	(4376, 171),
+	(4377, 1),
+	(4390, 1298),
+	(4396, 52),
+	(4398, 49),
+	(4401, 163),
+	(4406, 3),
+	(4407, 2),
+	(4412, 170),
+	(4413, 2),
+	(4421, 1),
+	(4422, 1296),
+	(4432, 57),
+	(4433, 163),
+	(4434, 51),
+	(4436, 1),
+	(4438, 2),
+	(4448, 481),
+	(4449, 2),
+	(4451, 1),
+	(4454, 1295),
+	(4463, 1),
+	(4465, 163),
+	(4468, 74),
+	(4470, 92),
+	(4484, 448),
+	(4485, 3),
+	(4486, 1295),
+	(4487, 1),
+	(4497, 163),
+	(4502, 2),
+	(4504, 52),
+	(4506, 65),
+	(4518, 1295),
+	(4519, 2),
+	(4520, 631),
+	(4521, 3),
+	(4529, 164),
+	(4530, 1),
+	(4532, 1),
+	(4533, 3),
+	(4534, 2),
+	(4540, 55),
+	(4542, 48),
+	(4550, 1294),
+	(4556, 2358),
+	(4557, 3),
+	(4561, 163),
+	(4562, 1),
+	(4566, 2),
+	(4576, 58),
+	(4578, 74),
+	(4582, 1294),
+	(4592, 193),
+	(4593, 167),
+	(4598, 2),
+	(4612, 66),
+	(4614, 1363),
+	(4621, 2),
+	(4625, 163),
+	(4628, 218),
+	(4629, 3),
+	(4630, 2),
+	(4635, 3),
+	(4640, 1),
+	(4645, 1),
+	(4646, 1295),
+	(4648, 57),
+	(4650, 90),
+	(4657, 163),
+	(4662, 3),
+	(4664, 194),
+	(4665, 1),
+	(4678, 1295),
+	(4684, 49),
+	(4685, 1),
+	(4686, 85),
+	(4689, 163),
+	(4694, 4),
+	(4700, 183),
+	(4701, 3),
+	(4710, 1291),
+	(4720, 61),
+	(4721, 163),
+	(4722, 75),
+	(4726, 3),
+	(4736, 175),
+	(4737, 4),
+	(4742, 1291),
+	(4753, 163),
+	(4756, 84),
+	(4758, 53),
+	(4772, 210),
+	(4773, 4),
+	(4774, 1291),
+	(4785, 163),
+	(4790, 2),
+	(4792, 54),
+	(4794, 66),
+	(4799, 2),
+	(4806, 1292),
+	(4808, 180),
+	(4809, 6),
+	(4817, 164),
+	(4820, 32),
+	(4821, 132),
+	(4822, 3),
+	(4824, 17),
+	(4828, 70),
+	(4830, 62),
+	(4836, 42),
+	(4838, 1290),
+	(4844, 199),
+	(4845, 3),
+	(4849, 163),
+	(4854, 2),
+	(4864, 104),
+	(4866, 98),
+	(4870, 1290),
+	(4873, 1),
+	(4880, 184),
+	(4881, 164),
+	(4886, 2),
+	(4900, 88),
+	(4902, 1387),
+	(4909, 1),
+	(4913, 163),
+	(4916, 187),
+	(4917, 6),
+	(4918, 2),
+	(4934, 1290),
+	(4936, 65),
+	(4938, 59),
+	(4945, 163),
+	(4948, 1),
+	(4950, 2),
+	(4952, 198),
+	(4953, 3),
+	(4966, 1290),
+	(4972, 64),
+	(4974, 108),
+	(4977, 163),
+	(4982, 2),
+	(4988, 199),
+	(4989, 8),
+	(4998, 1290),
+	(5008, 82),
+	(5009, 163),
+	(5010, 113),
+	(5012, 3),
+	(5013, 9),
+	(5014, 2),
+	(5017, 1),
+	(5024, 228),
+	(5025, 2),
+	(5028, 4),
+	(5030, 1290),
+	(5041, 162),
+	(5044, 96),
+	(5046, 71),
+	(5060, 275),
+	(5061, 6),
+	(5062, 1291),
+	(5064, 1),
+	(5070, 1),
+	(5073, 162),
+	(5078, 3),
+	(5080, 66),
+	(5082, 153),
+	(5094, 1289),
+	(5096, 272),
+	(5097, 10),
+	(5101, 2),
+	(5104, 2),
+	(5105, 162),
+	(5110, 2),
+	(5116, 87),
+	(5118, 80),
+	(5126, 1289),
+	(5132, 266),
+	(5133, 5),
+	(5135, 1),
+	(5137, 162),
+	(5140, 190),
+	(5141, 681),
+	(5142, 2),
+	(5152, 104),
+	(5154, 184),
+	(5156, 238),
+	(5158, 1289),
+	(5168, 257),
+	(5169, 165),
+	(5174, 2),
+	(5188, 99),
+	(5190, 1435),
+	(5201, 162),
+	(5204, 228),
+	(5205, 6),
+	(5206, 2),
+	(5221, 206),
+	(5222, 1289),
+	(5224, 312),
+	(5226, 110),
+	(5231, 1),
+	(5233, 162),
+	(5238, 2),
+	(5240, 266),
+	(5241, 7),
+	(5254, 1289),
+	(5260, 87),
+	(5262, 243),
+	(5265, 162),
+	(5270, 2),
+	(5274, 8),
+	(5276, 318),
+	(5277, 7),
+	(5286, 1289),
+	(5288, 86),
+	(5296, 88),
+	(5297, 162),
+	(5298, 123),
+	(5302, 3),
+	(5312, 351),
+	(5313, 1),
+	(5318, 1289),
+	(5329, 162),
+	(5332, 115),
+	(5334, 173),
+	(5339, 6),
+	(5344, 1),
+	(5348, 313),
+	(5349, 3),
+	(5350, 1289),
+	(5352, 24),
+	(5353, 14),
+	(5361, 162),
+	(5366, 3),
+	(5368, 157),
+	(5370, 107),
+	(5374, 1),
+	(5382, 1289),
+	(5384, 293),
+	(5385, 4),
+	(5388, 4),
+	(5393, 162),
+	(5396, 1),
+	(5398, 2),
+	(5404, 142),
+	(5406, 201),
+	(5407, 1),
+	(5414, 1289),
+	(5417, 3),
+	(5420, 285),
+	(5421, 5),
+	(5423, 1),
+	(5425, 162),
+	(5430, 2),
+	(5436, 1),
+	(5440, 142),
+	(5442, 210),
+	(5444, 1),
+	(5446, 1294),
+	(5456, 318),
+	(5457, 166),
+	(5462, 3),
+	(5476, 123),
+	(5478, 1608),
+	(5482, 2),
+	(5489, 162),
+	(5492, 329),
+	(5493, 2),
+	(5494, 2),
+	(5504, 1),
+	(5506, 1),
+	(5510, 1289),
+	(5511, 1),
+	(5512, 165),
+	(5514, 167),
+	(5521, 163),
+	(5522, 1),
+	(5526, 2),
+	(5528, 367),
+	(5529, 8),
+	(5542, 1289),
+	(5548, 192),
+	(5550, 291),
+	(5553, 162),
+	(5558, 2),
+	(5564, 399),
+	(5565, 13),
+	(5574, 1289),
+	(5584, 188),
+	(5585, 163),
+	(5586, 356),
+	(5590, 2),
+	(5592, 1),
+	(5599, 1),
+	(5600, 375),
+	(5601, 3),
+	(5606, 1290),
+	(5608, 1),
+	(5617, 162),
+	(5618, 1),
+	(5620, 261),
+	(5622, 667),
+	(5623, 1),
+	(5626, 1),
+	(5633, 1),
+	(5636, 406),
+	(5637, 4),
+	(5638, 1289),
+	(5639, 1),
+	(5649, 162),
+	(5654, 2),
+	(5656, 468),
+	(5658, 1159),
+	(5662, 1),
+	(5670, 1289),
+	(5671, 1),
+	(5672, 349),
+	(5673, 8),
+	(5675, 1),
+	(5681, 162),
+	(5686, 2),
+	(5692, 321),
+	(5694, 3067),
+	(5702, 1289),
+	(5706, 1),
+	(5708, 443),
+	(5709, 7),
+	(5713, 162),
+	(5718, 2),
+	(5728, 496),
+	(5730, 4577),
+	(5734, 1289),
+	(5744, 383),
+	(5745, 165),
+	(5750, 3),
+	(5756, 1),
+	(5758, 1),
+	(5764, 5847),
+	(5766, 8966),
+	(5775, 1),
+	(5777, 162),
+	(5780, 616),
+	(5781, 240),
+	(5782, 2),
+	(5784, 1),
+	(5788, 1),
+	(5796, 81),
+	(5798, 1289),
+	(5799, 1),
+	(5800, 5543),
+	(5802, 13287),
+	(5809, 162),
+	(5814, 2),
+	(5816, 409),
+	(5817, 3),
+	(5830, 1289),
+	(5833, 1),
+	(5836, 123),
+	(5838, 59),
+	(5841, 162),
+	(5846, 2),
+	(5852, 480),
+	(5853, 10),
+	(5862, 1289),
+	(5872, 191),
+	(5873, 162),
+	(5874, 38),
+	(5878, 2),
+	(5888, 616),
+	(5889, 12),
+	(5894, 1289),
+	(5905, 162),
+	(5908, 139),
+	(5910, 54),
+	(5922, 1),
+	(5924, 675),
+	(5925, 9),
+	(5926, 1289),
+	(5937, 162),
+	(5942, 2),
+	(5944, 153),
+	(5946, 48),
+	(5958, 1289),
+	(5960, 614),
+	(5961, 33),
+	(5969, 162),
+	(5974, 2),
+	(5980, 140),
+	(5982, 95),
+	(5990, 1289),
+	(5996, 628),
+	(5997, 10),
+	(6001, 162),
+	(6006, 2),
+	(6016, 155),
+	(6018, 67),
+	(6021, 42),
+	(6022, 1289),
+	(6024, 42),
+	(6032, 772),
+	(6033, 177),
+	(6038, 2),
+	(6049, 1),
+	(6052, 109),
+	(6054, 1340),
+	(6065, 162),
+	(6068, 749),
+	(6069, 11),
+	(6070, 2),
+	(6086, 1289),
+	(6088, 364),
+	(6090, 49),
+	(6096, 1),
+	(6097, 162),
+	(6102, 2),
+	(6104, 975),
+	(6105, 4),
+	(6106, 1),
+	(6118, 1289),
+	(6124, 273),
+	(6126, 58),
+	(6129, 162),
+	(6134, 2),
+	(6138, 1),
+	(6140, 1053),
+	(6141, 13),
+	(6150, 1289),
+	(6152, 1),
+	(6153, 2),
+	(6160, 372),
+	(6161, 162),
+	(6162, 70),
+	(6164, 1),
+	(6166, 2),
+	(6172, 1),
+	(6176, 1088),
+	(6177, 96),
+	(6178, 1),
+	(6182, 1290),
+	(6188, 4),
+	(6193, 162),
+	(6194, 1),
+	(6196, 346),
+	(6198, 101),
+	(6206, 1),
+	(6212, 1352),
+	(6213, 4),
+	(6214, 1290),
+	(6219, 2),
+	(6223, 1),
+	(6225, 162),
+	(6230, 1),
+	(6232, 321),
+	(6234, 170),
+	(6246, 1290),
+	(6248, 1755),
+	(6249, 4),
+	(6257, 162),
+	(6261, 4),
+	(6262, 1),
+	(6264, 4),
+	(6268, 616),
+	(6270, 141),
+	(6275, 1),
+	(6278, 1289),
+	(6280, 1),
+	(6281, 1),
+	(6284, 2516),
+	(6285, 73),
+	(6289, 162),
+	(6294, 1),
+	(6304, 409),
+	(6306, 163),
+	(6310, 1289),
+	(6314, 2),
+	(6320, 2276),
+	(6321, 210),
+	(6326, 1),
+	(6340, 445),
+	(6342, 1437),
+	(6353, 162),
+	(6356, 4090),
+	(6357, 55),
+	(6358, 1),
+	(6364, 1),
+	(6374, 1290),
+	(6376, 929),
+	(6378, 270),
+	(6385, 162),
+	(6390, 1),
+	(6392, 6135),
+	(6393, 16),
+	(6400, 1),
+	(6406, 1289),
+	(6412, 607),
+	(6414, 386),
+	(6417, 162),
+	(6420, 1),
+	(6421, 238),
+	(6422, 1),
+	(6424, 238),
+	(6428, 15189),
+	(6429, 227),
+	(6438, 1289),
+	(6443, 1),
+	(6448, 1211),
+	(6449, 162),
+	(6450, 1135),
+	(6453, 2),
+	(6454, 1),
+	(6464, 66588),
+	(6465, 77),
+	(6470, 1289),
+	(6474, 31),
+	(6481, 162),
+	(6484, 21001),
+	(6486, 9926),
+	(6488, 95),
+	(6498, 1),
+	(6500, 51017),
+	(6501, 2547),
+	(6502, 1289),
+	(6513, 162),
+	(6518, 1),
+	(6520, 11978),
+	(6522, 2546),
+	(6534, 1289),
+	(6536, 1),
+	(6537, 4),
+	(6539, 7),
+	(6545, 162),
+	(6546, 1),
+	(6550, 1),
+	(6553, 27),
+	(6566, 1289),
+	(6572, 1),
+	(6573, 2),
+	(6574, 1),
+	(6577, 163),
+	(6582, 2),
+	(6587, 1),
+	(6588, 17),
+	(6598, 1289),
+	(6600, 1),
+	(6603, 1),
+	(6605, 1),
+	(6606, 2),
+	(6608, 1),
+	(6609, 163),
+	(6610, 1),
+	(6614, 1),
+	(6623, 4),
+	(6630, 1289),
+	(6631, 1),
+	(6633, 1),
+	(6635, 1),
+	(6640, 1),
+	(6641, 162),
+	(6644, 1),
+	(6645, 2),
+	(6646, 2),
+	(6662, 1289),
+	(6666, 1),
+	(6670, 1),
+	(6673, 162),
+	(6678, 1),
+	(6679, 1),
+	(6680, 1),
+	(6681, 5),
+	(6686, 1),
+	(6694, 1289),
+	(6705, 162),
+	(6710, 1),
+	(6711, 1),
+	(6714, 1),
+	(6716, 1),
+	(6717, 10),
+	(6726, 1289),
+	(6734, 1),
+	(6737, 163),
+	(6738, 1),
+	(6740, 2),
+	(6742, 1),
+	(6752, 1),
+	(6753, 1),
+	(6757, 1),
+	(6758, 1289),
+	(6769, 162),
+	(6770, 1),
+	(6774, 1),
+	(6775, 1),
+	(6788, 1),
+	(6789, 3),
+	(6790, 1289),
+	(6797, 1),
+	(6801, 162),
+	(6802, 1),
+	(6803, 1),
+	(6806, 1),
+	(6818, 1),
+	(6819, 1),
+	(6822, 1289),
+	(6824, 1),
+	(6825, 5),
+	(6833, 162),
+	(6834, 1),
+	(6837, 1),
+	(6838, 1),
+	(6844, 2),
+	(6854, 1289),
+	(6860, 1),
+	(6861, 5),
+	(6865, 163),
+	(6869, 1),
+	(6870, 1),
+	(6872, 1),
+	(6875, 1),
+	(6881, 3),
+	(6886, 1289),
+	(6896, 1),
+	(6897, 166),
+	(6902, 1),
+	(6915, 1),
+	(6918, 1289),
+	(6929, 162),
+	(6932, 2),
+	(6933, 1),
+	(6934, 1),
+	(6947, 1),
+	(6950, 1290),
+	(6961, 162),
+	(6966, 1),
+	(6969, 2),
+	(6982, 1289),
+	(6993, 162),
+	(6998, 1),
+	(7004, 1),
+	(7005, 1),
+	(7014, 1289),
+	(7025, 162),
+	(7030, 1),
+	(7032, 1),
+	(7034, 1),
+	(7040, 1),
+	(7041, 1),
+	(7046, 1289),
+	(7057, 162),
+	(7058, 1),
+	(7059, 1),
+	(7062, 1),
+	(7070, 1),
+	(7076, 1),
+	(7077, 3),
+	(7078, 1289),
+	(7084, 1),
+	(7089, 162),
+	(7094, 1),
+	(7110, 1289),
+	(7112, 1),
+	(7113, 5),
+	(7121, 162),
+	(7124, 1),
+	(7126, 1),
+	(7133, 1),
+	(7142, 1289),
+	(7148, 1),
+	(7149, 12),
+	(7153, 162),
+	(7158, 1),
+	(7174, 1289),
+	(7184, 1),
+	(7185, 170),
+	(7190, 1),
+	(7206, 1289),
+	(7217, 162),
+	(7220, 1),
+	(7221, 82),
+	(7222, 1),
+	(7224, 81),
+	(7229, 1),
+	(7237, 1),
+	(7238, 1289),
+	(7242, 1),
+	(7243, 1),
+	(7248, 1),
+	(7249, 162),
+	(7254, 1),
+	(7256, 1),
+	(7257, 1),
+	(7266, 4),
+	(7270, 1289),
+	(7274, 13),
+	(7280, 20),
+	(7281, 162),
+	(7286, 1),
+	(7288, 12),
+	(7292, 1),
+	(7293, 5),
+	(7296, 1),
+	(7302, 1289),
+	(7308, 1),
+	(7313, 162),
+	(7315, 1),
+	(7318, 1),
+	(7328, 1),
+	(7329, 1),
+	(7334, 1290),
+	(7345, 162),
+	(7349, 1),
+	(7350, 1),
+	(7353, 1),
+	(7364, 1),
+	(7365, 1),
+	(7366, 1290),
+	(7377, 162),
+	(7382, 1),
+	(7392, 1),
+	(7398, 1289),
+	(7400, 1),
+	(7401, 4),
+	(7406, 1),
+	(7409, 162),
+	(7411, 1),
+	(7414, 1),
+	(7430, 1289),
+	(7431, 3),
+	(7436, 1),
+	(7437, 2),
+	(7441, 162),
+	(7445, 5),
+	(7446, 1),
+	(7448, 1),
+	(7460, 1),
+	(7462, 1289),
+	(7472, 1),
+	(7473, 166),
+	(7474, 1),
+	(7478, 1),
+	(7494, 1289),
+	(7505, 162),
+	(7508, 3),
+	(7509, 2),
+	(7510, 2),
+	(7525, 1),
+	(7526, 1289),
+	(7532, 1),
+	(7537, 162),
+	(7542, 1),
+	(7544, 1),
+	(7545, 9),
+	(7546, 1),
+	(7558, 1289),
+	(7569, 162),
+	(7574, 1),
+	(7580, 1),
+	(7581, 6),
+	(7590, 1289),
+	(7601, 162),
+	(7606, 1),
+	(7616, 1),
+	(7617, 6),
+	(7622, 1289),
+	(7623, 1),
+	(7625, 1),
+	(7633, 162),
+	(7638, 1),
+	(7652, 1),
+	(7653, 11),
+	(7654, 1289),
+	(7657, 1),
+	(7665, 162),
+	(7670, 1),
+	(7686, 1289),
+	(7688, 1),
+	(7689, 1),
+	(7697, 162),
+	(7702, 1),
+	(7708, 1),
+	(7715, 1),
+	(7717, 2),
+	(7718, 1289),
+	(7724, 1),
+	(7725, 3),
+	(7729, 162),
+	(7734, 1),
+	(7746, 1),
+	(7750, 1289),
+	(7760, 1),
+	(7761, 167),
+	(7766, 1),
+	(7782, 1289),
+	(7793, 162),
+	(7794, 1),
+	(7796, 1),
+	(7797, 1),
+	(7798, 1),
+	(7814, 1289),
+	(7820, 1),
+	(7825, 162),
+	(7826, 1),
+	(7830, 1),
+	(7832, 1),
+	(7833, 14),
+	(7842, 1),
+	(7846, 1289),
+	(7857, 162),
+	(7862, 1),
+	(7863, 1),
+	(7868, 1),
+	(7869, 4),
+	(7878, 1289),
+	(7885, 1),
+	(7889, 162),
+	(7894, 1),
+	(7904, 1),
+	(7905, 2),
+	(7910, 1289),
+	(7921, 162),
+	(7926, 1),
+	(7929, 1),
+	(7940, 1),
+	(7941, 2),
+	(7942, 1289),
+	(7953, 162),
+	(7958, 1),
+	(7963, 1),
+	(7973, 1),
+	(7974, 1289),
+	(7976, 1),
+	(7977, 16),
+	(7985, 162),
+	(7989, 1),
+	(7990, 1),
+	(7991, 1),
+	(7997, 1),
+	(8000, 1),
+	(8006, 1289),
+	(8012, 1),
+	(8013, 14),
+	(8017, 162),
+	(8022, 1),
+	(8038, 1289),
+	(8048, 1),
+	(8049, 185),
+	(8054, 2),
+	(8070, 1289),
+	(8081, 162),
+	(8084, 1),
+	(8085, 24),
+	(8086, 1),
+	(8102, 1289),
+	(8113, 162),
+	(8118, 1),
+	(8119, 1),
+	(8120, 1),
+	(8121, 1),
+	(8126, 1),
+	(8134, 1289),
+	(8140, 1),
+	(8145, 162),
+	(8150, 1),
+	(8157, 20),
+	(8166, 1289),
+	(8177, 162),
+	(8182, 1),
+	(8192, 1),
+	(8193, 1),
+	(8198, 1289),
+	(8209, 162),
+	(8214, 1),
+	(8228, 1),
+	(8229, 32),
+	(8230, 1290),
+	(8246, 1),
+	(8264, 1),
+	(8265, 27),
+	(8269, 1),
+	(8276, 1),
+	(8282, 1),
+	(8300, 1),
+	(8301, 133),
+	(8336, 2),
+	(8337, 60),
+	(8348, 3),
+	(8356, 1),
+	(8358, 1),
+	(8372, 1),
+	(8373, 196),
+	(8408, 1),
+	(8444, 1),
+	(8468, 1),
+	(8480, 1),
+	(8499, 1),
+	(8516, 1),
+	(8552, 1),
+	(8555, 1),
+	(8588, 1),
+	(8624, 1),
+	(8660, 3),
+	(8675, 1),
+	(8696, 1),
+	(8704, 1),
+	(8724, 1),
+	(8732, 1),
+	(8768, 1),
+	(8779, 1),
+	(8804, 1),
+	(8840, 1),
+	(8852, 2),
+	(8876, 1),
+	(8912, 1),
+	(8948, 1),
+	(8984, 1),
+	(9020, 1),
+	(9128, 1),
+	(9164, 1),
+	(9192, 1),
+	(9200, 2),
+	(9236, 1),
+	(9272, 1),
+	(9308, 1),
+	(9344, 1),
+	(9380, 1),
+	(9416, 1),
+	(9452, 1),
+	(9524, 1),
+	(9560, 1),
+	(9589, 1),
+	(9632, 1),
+	(9642, 1),
+	(9704, 1),
+	(9776, 1),
+	(9848, 1),
+	(9992, 1),
+	(10064, 1),
+	(10100, 1),
+	(10136, 1),
+	(10172, 1),
+	(10208, 1),
+	(10244, 1),
+	(10280, 1),
+	(10316, 1),
+	(10388, 1),
+	(10532, 1),
+	(10572, 1),
+	(10620, 1),
+	(10640, 1),
+	(10669, 1),
+	(10748, 1),
+	(10856, 1),
+	(10964, 1),
+	(11067, 1),
+	(11072, 1),
+	(11180, 1),
+	(11216, 1),
+	(11252, 1),
+	(11288, 1),
+	(11324, 1),
+	(11348, 2),
+	(11360, 1),
+	(11396, 1),
+	(11432, 1),
+	(11468, 1),
+	(11504, 1),
+	(11540, 1),
+	(11576, 1),
+	(11612, 1),
+	(11648, 1),
+	(11756, 1),
+	(11792, 1),
+	(11828, 1),
+	(11864, 1),
+	(11936, 1),
+	(12008, 1),
+	(12080, 1),
+	(12152, 1),
+	(12188, 1),
+	(12224, 1),
+	(12260, 1),
+	(12296, 1),
+	(12332, 1),
+	(12360, 1),
+	(12368, 1),
+	(12404, 1),
+	(12440, 1),
+	(12476, 1),
+	(12501, 2),
+	(12512, 1),
+	(12548, 1),
+	(12584, 1),
+	(12620, 1),
+	(12656, 1),
+	(12693, 1),
+	(12728, 1),
+	(12885, 1),
+	(13123, 1),
+	(13269, 1),
+	(13461, 1),
+	(13653, 1),
+	(13664, 1),
+	(13740, 1),
+	(13872, 1),
+	(13946, 1),
+	(14109, 1),
+	(14613, 2),
+	(14805, 2),
+	(14945, 1),
+	(14997, 1),
+	(15176, 1),
+	(15276, 1),
+	(15384, 1),
+	(15492, 1),
+	(15600, 1),
+	(15708, 1),
+	(15716, 1),
+	(15765, 1),
+	(15816, 1),
+	(15924, 1),
+	(16068, 1),
+	(16104, 1),
+	(16140, 1),
+	(16176, 1),
+	(16212, 1),
+	(16248, 1),
+	(16284, 1),
+	(16320, 1),
+	(16356, 1),
+	(16392, 1),
+	(16430, 1),
+	(16468, 1),
+	(16504, 1),
+	(16540, 1),
+	(16727, 2),
+	(16728, 1),
+	(16919, 2),
+	(16921, 1),
+	(16938, 1),
+	(17111, 6),
+	(17413, 1),
+	(17430, 1),
+	(17495, 1),
+	(17880, 1),
+	(18647, 2),
+	(18672, 1),
+	(19223, 38),
+	(19680, 1),
+	(20436, 1),
+	(21156, 1),
+	(21732, 1),
+	(22380, 1),
+	(22992, 1),
+	(23063, 17),
+	(23244, 1),
+	(23532, 1),
+	(23892, 1),
+	(24108, 1),
+	(24215, 1),
+	(24324, 1),
+	(24407, 2),
+	(24504, 1),
+	(24720, 1),
+	(24900, 1),
+	(24983, 205),
+	(25440, 1),
+	(25620, 1),
+	(26088, 1),
+	(26268, 1),
+	(26448, 1),
+	(26664, 1),
+	(26988, 1),
+	(27276, 1),
+	(27492, 1),
+	(27744, 1),
+	(28032, 1),
+	(28284, 1),
+	(28536, 1),
+	(28823, 42),
+	(28896, 1),
+	(29184, 1),
+	(29292, 1),
+	(29400, 1),
+	(29796, 1),
+	(29975, 4),
+	(30156, 1),
+	(30228, 1),
+	(30743, 238),
+	(30768, 1),
+	(31056, 1),
+	(31092, 1),
+	(31416, 1),
+	(32100, 1),
+	(32712, 1),
+	(33144, 1),
+	(33324, 1),
+	(33792, 1),
+	(34008, 1),
+	(34440, 1),
+	(34583, 81),
+	(34656, 1),
+	(34872, 1),
+	(34944, 1),
+	(35160, 1),
+	(35304, 1),
+	(35376, 1),
+	(35412, 1),
+	(35556, 1),
+	(35628, 1),
+	(35664, 1),
+	(35808, 1),
+	(36204, 1),
+	(36744, 1),
+	(37788, 1),
+	(39372, 1),
+	(40956, 1),
+	(41640, 1),
+	(41892, 1),
+	(42144, 1),
+	(42576, 1),
+	(42936, 1),
+	(43476, 1),
+	(45096, 1),
+	(47256, 1),
+	(47760, 1),
+	(47796, 1),
+	(47868, 1),
+	(48228, 1),
+	(48948, 1),
+	(49128, 1),
+	(49452, 1),
+	(49560, 1),
+	(49668, 1),
+	(49776, 1),
+	(50352, 1),
+	(50964, 1),
+	(52008, 1),
+	(53880, 1),
+	(55284, 1),
+	(55860, 1),
+	(56040, 1),
+	(56400, 1),
+	(56904, 1),
+	(57444, 1),
+	(59424, 1),
+	(60156, 1),
+	(60626, 1),
+	(60641, 1),
+	(61260, 1),
+	(62520, 1),
+	(64392, 1),
+	(65976, 1),
+	(67308, 1),
+	(68064, 1),
+	(68748, 1),
+	(69216, 1),
+	(69504, 1),
+	(69648, 1),
+	(69684, 1),
+	(69720, 1),
+	(69756, 1),
+	(69792, 1),
+	(69828, 1),
+	(70224, 1),
+	(70620, 1),
+	(71016, 1),
+	(71412, 1),
+	(71772, 1),
+	(71952, 1),
+	(72024, 1),
+	(72096, 1),
+	(72168, 1),
+	(72240, 1),
+	(72312, 1),
+	(72348, 1),
+	(72420, 1),
+	(72492, 1),
+	(72600, 1),
+	(72672, 1),
+	(72780, 1),
+	(72996, 1),
+	(73320, 1),
+	(73356, 1),
+	(73500, 1),
+	(73536, 1),
+	(73572, 1),
+	(73608, 1),
+	(73680, 1),
+	(73716, 1),
+	(73788, 1),
+	(73896, 1),
+	(74040, 1),
+	(74112, 1),
+	(74170, 1),
+	(74184, 1),
+	(74185, 1),
+	(74220, 1),
+	(74256, 1),
+	(74292, 1),
+	(74328, 1),
+	(74364, 1),
+	(74400, 1),
+	(74436, 1),
+	(74472, 1),
+	(74616, 1),
+	(74976, 1),
+	(75156, 1),
+	(75228, 1),
+	(75336, 1),
+	(75408, 1),
+	(75588, 1),
+	(75696, 1),
+	(75804, 1),
+	(75984, 1),
+	(76056, 1),
+	(76164, 1),
+	(76308, 1),
+	(76452, 1),
+	(76560, 1),
+	(76776, 1),
+	(76920, 1),
+	(77064, 1),
+	(77208, 1),
+	(77316, 1),
+	(77532, 1),
+	(77676, 1),
+	(77748, 1),
+	(77820, 1),
+	(77928, 1),
+	(78000, 1),
+	(78036, 1),
+	(78072, 1),
+	(78108, 1),
+	(78180, 1),
+	(78324, 1),
+	(78396, 1),
+	(78576, 1),
+	(78684, 1),
+	(78828, 1),
+	(78864, 1),
+	(78900, 1),
+	(78972, 1),
+	(79080, 1),
+	(79116, 1),
+	(79152, 1),
+	(79512, 1),
+	(79872, 1),
+	(80268, 1),
+	(80592, 1),
+	(80700, 1),
+	(80916, 1),
+	(81168, 1),
+	(81276, 1),
+	(81528, 1),
+	(81708, 1),
+	(81816, 1),
+	(81888, 1),
+	(82068, 1),
+	(82176, 1),
+	(82284, 1),
+	(82356, 1),
+	(82716, 1),
+	(83004, 1),
+	(83312, 1),
+	(83436, 1),
+	(83688, 1),
+	(83904, 1),
+	(84012, 1),
+	(84408, 1),
+	(84660, 1),
+	(85056, 1),
+	(85488, 1),
+	(85776, 1),
+	(85992, 1),
+	(86172, 1),
+	(86424, 1),
+	(86615, 1),
+	(86640, 1),
+	(86928, 1),
+	(87072, 1),
+	(87288, 1),
+	(87576, 1),
+	(87684, 1),
+	(87756, 1),
+	(87972, 1),
+	(88044, 1),
+	(88152, 1),
+	(88368, 1),
+	(88728, 1),
+	(88836, 1),
+	(88944, 1),
+	(89088, 1),
+	(89448, 1),
+	(89592, 1),
+	(89700, 1),
+	(89808, 1),
+	(89952, 1),
+	(90060, 1),
+	(90204, 1),
+	(90348, 1),
+	(90528, 1),
+	(90636, 1),
+	(90744, 1),
+	(90816, 1),
+	(91032, 1),
+	(91068, 1),
+	(91140, 1),
+	(91212, 1),
+	(91284, 1),
+	(91860, 1),
+	(92112, 1),
+	(92292, 1),
+	(92400, 1),
+	(92544, 1),
+	(92652, 1),
+	(92796, 1),
+	(92904, 1),
+	(92976, 1),
+	(93192, 1),
+	(93300, 1),
+	(93444, 1),
+	(93516, 1),
+	(93624, 1),
+	(93696, 1),
+	(93840, 1),
+	(93984, 1),
+	(94056, 1),
+	(94128, 1),
+	(94164, 1),
+	(94200, 1),
+	(94236, 1),
+	(94272, 1),
+	(94344, 1),
+	(94452, 1),
+	(94524, 1),
+	(94596, 1),
+	(94704, 1),
+	(94776, 1),
+	(94884, 1),
+	(94956, 1),
+	(95172, 1),
+	(95244, 1),
+	(95280, 1),
+	(95316, 1),
+	(95352, 1),
+	(95388, 1),
+	(95424, 1),
+	(95460, 1),
+	(95496, 1),
+	(95604, 1),
+	(95676, 1),
+	(95784, 1),
+	(95856, 1),
+	(95928, 1),
+	(96000, 1),
+	(96036, 1),
+	(96072, 1),
+	(96108, 1),
+	(96144, 1),
+	(96180, 1),
+	(96216, 1),
+	(96288, 1),
+	(96576, 1),
+	(98029, 1),
+	(98304, 1),
+	(98527, 1),
+	(98628, 1),
+	(99276, 1),
+	(99528, 1),
+	(99780, 1),
+	(99996, 1),
+	(100212, 1),
+	(100428, 1),
+	(100680, 1),
+	(100752, 1),
+	(100788, 1),
+	(100860, 1),
+	(100932, 1),
+	(101004, 1),
+	(101076, 1),
+	(101148, 1),
+	(101220, 1),
+	(101256, 1),
+	(101328, 1),
+	(101364, 1),
+	(101400, 1),
+	(101436, 1),
+	(101472, 1),
+	(101508, 1),
+	(101544, 1),
+	(101616, 1),
+	(101652, 1),
+	(101724, 1),
+	(101832, 1),
+	(101904, 1),
+	(101940, 1),
+	(101976, 1),
+	(102012, 1),
+	(102048, 1),
+	(102084, 1),
+	(102120, 1),
+	(102264, 1),
+	(102516, 1),
+	(102588, 1),
+	(102624, 1),
+	(102660, 1),
+	(102696, 1),
+	(102732, 1),
+	(102768, 1),
+	(102804, 1),
+	(102840, 1),
+	(102876, 1),
+	(102912, 1),
+	(102948, 1),
+	(102984, 1),
+	(103056, 1),
+	(103092, 1),
+	(103128, 1),
+	(103164, 1),
+	(103200, 1),
+	(103236, 1),
+	(103272, 1),
+	(103308, 1),
+	(103344, 1),
+	(103380, 1),
+	(103452, 1),
+	(103560, 1),
+	(103596, 1),
+	(103632, 1),
+	(103668, 1),
+	(103704, 1),
+	(103740, 1),
+	(103776, 1),
+	(103848, 1),
+	(103920, 1),
+	(103956, 1),
+	(104028, 1),
+	(104100, 1),
+	(104136, 1),
+	(104208, 1),
+	(104244, 1),
+	(104316, 1),
+	(104352, 1),
+	(104388, 1),
+	(104424, 1),
+	(104460, 1),
+	(104496, 1),
+	(104532, 1),
+	(104568, 1),
+	(104604, 1),
+	(104676, 1),
+	(104712, 1),
+	(104748, 1),
+	(104784, 1),
+	(104820, 1),
+	(104856, 1),
+	(104892, 1),
+	(104928, 1),
+	(104964, 1),
+	(105000, 1),
+	(105036, 1),
+	(105072, 1),
+	(105108, 1),
+	(105216, 1),
+	(105324, 1),
+	(105360, 1),
+	(105396, 1),
+	(105432, 1),
+	(105468, 1),
+	(105504, 1),
+	(105540, 1),
+	(105576, 1),
+	(105612, 1),
+	(105648, 1),
+	(105684, 1),
+	(105720, 1),
+	(105756, 1),
+	(105792, 1),
+	(105828, 1),
+	(105864, 1),
+	(105900, 1),
+	(105936, 1),
+	(110580, 1),
+	(115224, 1),
+	(118788, 1),
+	(121056, 1),
+	(121452, 1),
+	(121848, 1),
+	(122244, 1),
+	(122604, 1),
+	(122928, 1),
+	(123252, 1),
+	(123288, 1),
+	(123360, 1),
+	(123432, 1),
+	(123468, 1),
+	(123504, 1),
+	(123540, 1),
+	(123612, 1),
+	(123684, 1),
+	(123756, 1),
+	(123828, 1),
+	(123900, 1),
+	(123972, 1),
+	(124080, 1),
+	(124188, 1),
+	(124296, 1),
+	(124404, 1),
+	(124548, 1),
+	(124764, 1),
+	(124872, 1),
+	(124980, 1),
+	(125088, 1),
+	(125196, 1),
+	(125304, 1),
+	(125412, 1),
+	(125448, 1),
+	(125520, 1),
+	(125628, 1),
+	(125700, 1),
+	(125772, 1),
+	(125844, 1),
+	(125880, 1),
+	(125916, 1),
+	(125952, 1),
+	(125988, 1),
+	(126024, 1),
+	(126060, 1),
+	(126096, 1),
+	(126168, 1),
+	(126276, 1),
+	(126312, 1),
+	(126348, 1),
+	(126420, 1),
+	(126492, 1),
+	(126564, 1),
+	(126636, 1),
+	(126708, 1),
+	(126780, 1),
+	(126852, 1),
+	(126960, 1),
+	(127068, 1),
+	(127176, 1),
+	(127212, 1),
+	(127248, 1),
+	(127284, 1),
+	(127320, 1),
+	(127356, 1),
+	(127392, 1),
+	(127464, 1),
+	(127536, 1),
+	(127608, 1),
+	(127644, 1),
+	(127680, 1),
+	(127716, 1),
+	(127788, 1),
+	(127860, 1),
+	(127932, 1),
+	(128004, 1),
+	(128076, 1),
+	(128148, 1),
+	(128220, 1),
+	(128256, 1),
+	(128292, 1),
+	(128328, 1),
+	(128364, 1),
+	(128400, 1),
+	(128436, 1),
+	(128472, 1),
+	(128508, 1),
+	(128544, 1),
+	(128580, 1),
+	(128616, 1),
+	(128652, 1),
+	(128688, 1),
+	(128724, 1),
+	(128760, 1),
+	(128832, 1),
+	(128904, 1),
+	(128976, 1),
+	(129048, 1),
+	(129120, 1),
+	(129192, 1),
+	(129228, 1),
+	(129264, 1),
+	(129300, 1),
+	(129372, 1),
+	(129408, 1),
+	(129444, 1),
+	(129480, 1),
+	(129516, 1),
+	(129552, 1),
+	(129588, 1),
+	(129660, 1),
+	(129732, 1),
+	(129768, 1),
+	(129804, 1),
+	(129840, 1),
+	(129876, 1),
+	(129912, 1),
+	(129948, 1),
+	(129984, 1),
+	(130020, 1),
+	(130056, 1),
+	(130128, 1),
+	(130200, 1),
+	(130236, 1),
+	(130272, 1),
+	(130308, 1),
+	(130380, 1),
+	(130452, 1),
+	(130524, 1),
+	(130560, 1),
+	(130596, 1),
+	(130632, 1),
+	(130668, 1),
+	(130704, 1),
+	(130776, 1),
+	(130812, 1),
+	(130848, 1),
+	(130920, 1),
+	(130992, 1),
+	(131064, 1),
+	(131136, 1),
+	(131172, 1),
+	(131208, 1),
+	(131244, 1),
+	(131316, 1),
+	(131388, 1),
+	(131424, 1),
+	(131532, 1),
+	(131640, 1),
+	(131784, 1),
+	(131892, 1),
+	(131964, 1),
+	(132036, 1),
+	(132108, 1),
+	(132180, 1),
+	(132252, 1),
+	(132324, 1),
+	(132360, 1),
+	(132432, 1),
+	(132504, 1),
+	(132576, 1),
+	(132684, 1),
+	(132792, 1),
+	(132900, 1),
+	(132972, 1),
+	(133044, 1),
+	(133116, 1),
+	(133188, 1),
+	(133260, 1),
+	(133332, 1),
+	(133368, 1),
+	(133404, 1),
+	(133440, 1),
+	(133476, 1),
+	(133512, 1),
+	(133548, 1),
+	(133620, 1),
+	(133692, 1),
+	(133764, 1),
+	(133836, 1),
+	(133908, 1),
+	(133980, 1),
+	(134016, 1),
+	(134052, 1),
+	(134088, 1),
+	(134124, 1),
+	(134160, 1),
+	(134196, 1),
+	(134232, 1),
+	(134268, 1),
+	(134304, 1),
+	(134340, 1),
+	(134376, 1),
+	(134412, 1),
+	(134484, 1),
+	(134592, 1),
+	(134700, 1),
+	(134808, 1),
+	(134916, 1),
+	(134988, 1),
+	(135024, 1),
+	(135060, 1),
+	(135096, 1),
+	(135132, 1),
+	(135168, 1),
+	(135204, 1),
+	(135240, 1),
+	(135276, 1),
+	(135312, 1),
+	(135348, 1),
+	(135384, 1),
+	(135456, 1),
+	(135492, 1),
+	(135528, 1),
+	(135564, 1),
+	(135600, 1),
+	(135636, 1),
+	(135672, 1),
+	(135708, 1),
+	(135744, 1),
+	(135780, 1),
+	(135816, 1),
+	(135852, 1),
+	(135888, 1),
+	(135924, 1),
+	(135960, 1),
+	(135996, 1),
+	(136032, 1),
+	(136068, 1),
+	(136140, 1),
+	(136212, 1),
+	(136284, 1),
+	(136356, 1),
+	(136428, 1),
+	(136500, 1),
+	(136572, 1),
+	(136608, 1),
+	(136644, 1),
+	(136680, 1),
+	(136716, 1),
+	(136752, 1),
+	(136788, 1),
+	(136824, 1),
+	(136860, 1),
+	(136896, 1),
+	(136932, 1),
+	(136968, 1),
+	(137004, 1),
+	(137040, 1),
+	(137076, 1),
+	(137112, 1),
+	(137148, 1),
+	(137184, 1),
+	(137256, 1),
+	(137328, 1),
+	(137400, 1),
+	(137472, 1),
+	(137544, 1),
+	(137580, 1),
+	(137616, 1),
+	(137652, 1),
+	(137688, 1),
+	(137724, 1),
+	(137796, 1),
+	(137832, 1),
+	(137868, 1),
+	(137904, 1),
+	(137940, 1),
+	(137976, 1),
+	(138012, 1),
+	(138048, 1),
+	(138084, 1),
+	(138120, 1),
+	(138228, 1),
+	(138300, 1),
+	(138336, 1),
+	(138372, 1),
+	(138408, 1),
+	(138444, 1),
+	(138480, 1),
+	(138516, 1),
+	(138552, 1),
+	(138588, 1),
+	(138624, 1),
+	(138696, 1),
+	(138768, 1),
+	(138840, 1),
+	(138912, 1),
+	(138948, 1),
+	(138984, 1),
+	(139020, 1),
+	(139056, 1),
+	(139092, 1),
+	(139128, 1),
+	(139164, 1),
+	(139200, 1),
+	(139272, 1),
+	(139308, 1),
+	(139380, 1),
+	(139452, 1),
+	(139488, 1),
+	(139524, 1),
+	(139596, 1),
+	(139632, 1),
+	(139668, 1),
+	(139704, 1),
+	(139740, 1),
+	(139776, 1),
+	(139848, 1),
+	(139884, 1),
+	(139920, 1),
+	(139956, 1),
+	(139992, 1),
+	(140028, 1),
+	(140064, 1),
+	(140136, 1),
+	(140172, 1),
+	(140208, 1),
+	(140244, 1),
+	(140280, 1),
+	(140316, 1),
+	(140352, 1),
+	(140424, 1),
+	(140460, 1),
+	(140496, 1),
+	(140532, 1),
+	(140604, 1),
+	(140640, 1),
+	(140676, 1),
+	(140712, 1),
+	(140748, 1),
+	(140784, 1),
+	(140820, 1),
+	(140856, 1),
+	(140928, 1),
+	(141036, 1),
+	(141072, 1),
+	(141108, 1),
+	(141144, 1),
+	(141180, 1),
+	(141216, 1),
+	(141252, 1),
+	(141324, 1),
+	(141396, 1),
+	(141432, 1),
+	(141468, 1),
+	(141504, 1),
+	(141612, 1),
+	(142152, 1),
+	(142188, 1),
+	(142260, 1),
+	(142296, 1),
+	(142800, 1),
+	(143304, 1),
+	(143376, 1),
+	(143448, 1),
+	(143520, 1),
+	(143592, 1),
+	(143664, 1),
+	(143700, 1),
+	(143736, 1),
+	(143772, 1),
+	(143808, 1),
+	(143844, 1),
+	(143880, 1),
+	(143952, 1),
+	(144096, 1),
+	(144240, 1),
+	(144348, 1),
+	(144456, 1),
+	(144564, 1),
+	(144672, 1),
+	(144708, 1),
+	(144744, 1),
+	(144780, 1),
+	(144816, 1),
+	(144852, 1),
+	(144888, 1),
+	(144924, 1),
+	(144960, 1),
+	(144996, 1),
+	(145032, 1),
+	(145068, 1),
+	(145104, 1),
+	(145140, 1),
+	(145176, 1),
+	(145212, 1),
+	(145248, 1),
+	(145284, 1),
+	(145320, 1),
+	(145356, 1),
+	(145392, 1),
+	(145464, 1),
+	(145500, 1),
+	(145536, 1),
+	(145572, 1),
+	(145644, 1),
+	(145716, 1),
+	(145752, 1),
+	(145788, 1),
+	(145824, 1),
+	(145860, 1),
+	(145896, 1),
+	(145932, 1),
+	(145968, 1),
+	(146004, 1),
+	(146040, 1),
+	(146076, 1),
+	(146112, 1),
+	(146148, 1),
+	(146184, 1),
+	(146220, 1),
+	(146256, 1),
+	(146292, 1),
+	(146328, 1),
+	(146364, 1),
+	(146400, 1),
+	(146436, 1),
+	(146472, 1),
+	(146508, 1),
+	(146544, 1),
+	(146580, 1),
+	(146616, 1),
+	(146652, 1),
+	(146688, 1),
+	(146724, 1),
+	(146760, 1),
+	(146796, 1),
+	(146832, 1),
+	(146868, 1),
+	(146940, 1),
+	(146976, 1),
+	(147012, 1),
+	(147048, 1),
+	(147084, 1),
+	(147120, 1),
+	(147156, 1),
+	(147192, 1),
+	(147228, 1),
+	(147264, 1),
+	(147300, 1),
+	(147336, 1),
+	(147372, 1),
+	(147408, 1),
+	(147444, 1),
+	(147480, 1),
+	(147516, 1),
+	(147552, 1),
+	(147588, 1),
+	(147624, 1),
+	(147660, 1),
+	(147732, 1),
+	(147768, 1),
+	(147804, 1),
+	(147840, 1),
+	(147876, 1),
+	(147912, 1),
+	(147948, 1),
+	(147984, 1),
+	(148020, 1),
+	(148056, 1),
+	(148092, 1),
+	(148128, 1),
+	(148164, 1),
+	(148200, 1),
+	(148236, 1),
+	(148272, 1),
+	(1070556, 1),
+	(1079378, 1),
+	(1085421, 1),
+	(1086835, 1),
+	(1121118, 1),
+	(1121208, 1),
+	(1124515, 1),
+	(1128287, 1),
+	(1128379, 1),
+	(1153308, 1),
+	(1153342, 4),
+	(1153344, 5),
+	(1153398, 1),
+	(1153571, 1),
+	(1153663, 1),
+	(1153670, 1),
+	(1153672, 3),
+	(1153688, 3),
+	(1154504, 1),
+	(1154538, 5),
+	(1154540, 6),
+	(1154596, 1),
+	(1164963, 1),
+	(1165053, 1),
+	(1166494, 1),
+	(1166586, 1),
+	(1175528, 1),
+	(1175636, 1),
+	(1177016, 1),
+	(1193653, 1),
+	(1193743, 1),
+	(1205060, 1),
+	(1205152, 1),
+	(1323322, 1),
+	(1323414, 1),
+	(1336354, 1),
+	(1336444, 1),
+	(1348925, 1),
+	(1349015, 1),
+	(1353326, 1),
+	(1353418, 1),
+	(1426757, 1),
+	(1426845, 1),
+	(1426847, 1),
+	(1426937, 1),
+	(1476463, 1),
+	(1476553, 1),
+	(1516580, 1),
+	(1516670, 1),
+	(1605731, 1),
+	(1605821, 1),
+];
diff --git a/substrate/bin/node/bench/src/tempdb.rs b/substrate/bin/node/bench/src/tempdb.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f3fd693d21fe107a1a5671a9819d5b1e98270703
--- /dev/null
+++ b/substrate/bin/node/bench/src/tempdb.rs
@@ -0,0 +1,123 @@
+// 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 kvdb::{DBKeyValue, DBTransaction, KeyValueDB};
+use kvdb_rocksdb::{Database, DatabaseConfig};
+use std::{io, path::PathBuf, sync::Arc};
+
+#[derive(Clone, Copy, Debug)]
+pub enum DatabaseType {
+	RocksDb,
+	ParityDb,
+}
+
+pub struct TempDatabase(tempfile::TempDir);
+
+struct ParityDbWrapper(parity_db::Db);
+
+impl KeyValueDB for ParityDbWrapper {
+	/// Get a value by key.
+	fn get(&self, col: u32, key: &[u8]) -> io::Result<Option<Vec<u8>>> {
+		Ok(self.0.get(col as u8, &key[key.len() - 32..]).expect("db error"))
+	}
+
+	/// Get a value by partial key. Only works for flushed data.
+	fn get_by_prefix(&self, _col: u32, _prefix: &[u8]) -> io::Result<Option<Vec<u8>>> {
+		unimplemented!()
+	}
+
+	/// Write a transaction of changes to the buffer.
+	fn write(&self, transaction: DBTransaction) -> io::Result<()> {
+		self.0
+			.commit(transaction.ops.iter().map(|op| match op {
+				kvdb::DBOp::Insert { col, key, value } =>
+					(*col as u8, &key[key.len() - 32..], Some(value.to_vec())),
+				kvdb::DBOp::Delete { col, key } => (*col as u8, &key[key.len() - 32..], None),
+				kvdb::DBOp::DeletePrefix { col: _, prefix: _ } => unimplemented!(),
+			}))
+			.expect("db error");
+		Ok(())
+	}
+
+	/// Iterate over flushed data for a given column.
+	fn iter<'a>(&'a self, _col: u32) -> Box<dyn Iterator<Item = io::Result<DBKeyValue>> + 'a> {
+		unimplemented!()
+	}
+
+	/// Iterate over flushed data for a given column, starting from a given prefix.
+	fn iter_with_prefix<'a>(
+		&'a self,
+		_col: u32,
+		_prefix: &'a [u8],
+	) -> Box<dyn Iterator<Item = io::Result<DBKeyValue>> + 'a> {
+		unimplemented!()
+	}
+}
+
+impl TempDatabase {
+	pub fn new() -> Self {
+		let dir = tempfile::tempdir().expect("temp dir creation failed");
+		log::trace!(
+			target: "bench-logistics",
+			"Created temp db at {}",
+			dir.path().to_string_lossy(),
+		);
+
+		TempDatabase(dir)
+	}
+
+	pub fn open(&mut self, db_type: DatabaseType) -> Arc<dyn KeyValueDB> {
+		match db_type {
+			DatabaseType::RocksDb => {
+				let db_cfg = DatabaseConfig::with_columns(1);
+				let db = Database::open(&db_cfg, &self.0.path()).expect("Database backend error");
+				Arc::new(db)
+			},
+			DatabaseType::ParityDb => Arc::new(ParityDbWrapper({
+				let mut options = parity_db::Options::with_columns(self.0.path(), 1);
+				let column_options = &mut options.columns[0];
+				column_options.ref_counted = true;
+				column_options.preimage = true;
+				column_options.uniform = true;
+				parity_db::Db::open_or_create(&options).expect("db open error")
+			})),
+		}
+	}
+}
+
+impl Clone for TempDatabase {
+	fn clone(&self) -> Self {
+		let new_dir = tempfile::tempdir().expect("temp dir creation failed");
+		let self_dir = self.0.path();
+
+		log::trace!(
+			target: "bench-logistics",
+			"Cloning db ({}) to {}",
+			self_dir.to_string_lossy(),
+			new_dir.path().to_string_lossy(),
+		);
+		let self_db_files = std::fs::read_dir(self_dir)
+			.expect("failed to list file in seed dir")
+			.map(|f_result| f_result.expect("failed to read file in seed db").path())
+			.collect::<Vec<PathBuf>>();
+		fs_extra::copy_items(&self_db_files, new_dir.path(), &fs_extra::dir::CopyOptions::new())
+			.expect("Copy of seed database is ok");
+
+		TempDatabase(new_dir)
+	}
+}
diff --git a/substrate/bin/node/bench/src/trie.rs b/substrate/bin/node/bench/src/trie.rs
new file mode 100644
index 0000000000000000000000000000000000000000..09ab405c03b23baed9217e50e8fb19e50fb18baf
--- /dev/null
+++ b/substrate/bin/node/bench/src/trie.rs
@@ -0,0 +1,370 @@
+// 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/>.
+
+//! Trie benchmark (integrated).
+
+use hash_db::Prefix;
+use kvdb::KeyValueDB;
+use lazy_static::lazy_static;
+use rand::Rng;
+use sp_state_machine::Backend as _;
+use sp_trie::{trie_types::TrieDBMutBuilderV1, TrieMut as _};
+use std::{borrow::Cow, collections::HashMap, sync::Arc};
+
+use node_primitives::Hash;
+
+use crate::{
+	core::{self, Mode, Path},
+	generator::generate_trie,
+	simple_trie::SimpleTrie,
+	tempdb::{DatabaseType, TempDatabase},
+};
+
+pub const SAMPLE_SIZE: usize = 100;
+pub const TEST_WRITE_SIZE: usize = 128;
+
+pub type KeyValue = (Vec<u8>, Vec<u8>);
+pub type KeyValues = Vec<KeyValue>;
+
+#[derive(Clone, Copy, Debug, derive_more::Display)]
+pub enum DatabaseSize {
+	#[display(fmt = "empty")]
+	Empty,
+	#[display(fmt = "smallest")]
+	Smallest,
+	#[display(fmt = "small")]
+	Small,
+	#[display(fmt = "medium")]
+	Medium,
+	#[display(fmt = "large")]
+	Large,
+	#[display(fmt = "huge")]
+	Huge,
+}
+
+lazy_static! {
+	static ref KUSAMA_STATE_DISTRIBUTION: SizePool =
+		SizePool::from_histogram(crate::state_sizes::KUSAMA_STATE_DISTRIBUTION);
+}
+
+impl DatabaseSize {
+	/// Should be multiple of SAMPLE_SIZE!
+	fn keys(&self) -> usize {
+		let val = match *self {
+			Self::Empty => 200, // still need some keys to query
+			Self::Smallest => 1_000,
+			Self::Small => 10_000,
+			Self::Medium => 100_000,
+			Self::Large => 200_000,
+			Self::Huge => 1_000_000,
+		};
+
+		assert_eq!(val % SAMPLE_SIZE, 0);
+
+		val
+	}
+}
+
+fn pretty_print(v: usize) -> String {
+	let mut print = String::new();
+	for (idx, val) in v.to_string().chars().rev().enumerate() {
+		if idx != 0 && idx % 3 == 0 {
+			print.insert(0, ',');
+		}
+		print.insert(0, val);
+	}
+	print
+}
+
+pub struct TrieReadBenchmarkDescription {
+	pub database_size: DatabaseSize,
+	pub database_type: DatabaseType,
+}
+
+pub struct TrieReadBenchmark {
+	database: TempDatabase,
+	root: Hash,
+	warmup_keys: KeyValues,
+	query_keys: KeyValues,
+	database_type: DatabaseType,
+}
+
+impl core::BenchmarkDescription for TrieReadBenchmarkDescription {
+	fn path(&self) -> Path {
+		let mut path = Path::new(&["trie", "read"]);
+		path.push(&format!("{}", self.database_size));
+		path
+	}
+
+	fn setup(self: Box<Self>) -> Box<dyn core::Benchmark> {
+		let mut database = TempDatabase::new();
+
+		let mut rng = rand::thread_rng();
+		let warmup_prefix = KUSAMA_STATE_DISTRIBUTION.key(&mut rng);
+
+		let mut key_values = KeyValues::new();
+		let mut warmup_keys = KeyValues::new();
+		let mut query_keys = KeyValues::new();
+		let every_x_key = self.database_size.keys() / SAMPLE_SIZE;
+		for idx in 0..self.database_size.keys() {
+			let kv = (
+				KUSAMA_STATE_DISTRIBUTION.key(&mut rng).to_vec(),
+				KUSAMA_STATE_DISTRIBUTION.value(&mut rng),
+			);
+			if idx % every_x_key == 0 {
+				// warmup keys go to separate tree with high prob
+				let mut actual_warmup_key = warmup_prefix.clone();
+				actual_warmup_key[16..].copy_from_slice(&kv.0[16..]);
+				warmup_keys.push((actual_warmup_key.clone(), kv.1.clone()));
+				key_values.push((actual_warmup_key.clone(), kv.1.clone()));
+			} else if idx % every_x_key == 1 {
+				query_keys.push(kv.clone());
+			}
+
+			key_values.push(kv)
+		}
+
+		assert_eq!(warmup_keys.len(), SAMPLE_SIZE);
+		assert_eq!(query_keys.len(), SAMPLE_SIZE);
+
+		let root = generate_trie(database.open(self.database_type), key_values);
+
+		Box::new(TrieReadBenchmark {
+			database,
+			root,
+			warmup_keys,
+			query_keys,
+			database_type: self.database_type,
+		})
+	}
+
+	fn name(&self) -> Cow<'static, str> {
+		format!(
+			"Trie read benchmark({:?} database ({} keys), db_type: {:?})",
+			self.database_size,
+			pretty_print(self.database_size.keys()),
+			self.database_type,
+		)
+		.into()
+	}
+}
+
+struct Storage(Arc<dyn KeyValueDB>);
+
+impl sp_state_machine::Storage<sp_core::Blake2Hasher> for Storage {
+	fn get(&self, key: &Hash, prefix: Prefix) -> Result<Option<Vec<u8>>, String> {
+		let key = sp_trie::prefixed_key::<sp_core::Blake2Hasher>(key, prefix);
+		self.0.get(0, &key).map_err(|e| format!("Database backend error: {:?}", e))
+	}
+}
+
+impl core::Benchmark for TrieReadBenchmark {
+	fn run(&mut self, mode: Mode) -> std::time::Duration {
+		let mut db = self.database.clone();
+
+		let storage: Arc<dyn sp_state_machine::Storage<sp_core::Blake2Hasher>> =
+			Arc::new(Storage(db.open(self.database_type)));
+
+		let trie_backend = sp_state_machine::TrieBackendBuilder::new(storage, self.root).build();
+		for (warmup_key, warmup_value) in self.warmup_keys.iter() {
+			let value = trie_backend
+				.storage(&warmup_key[..])
+				.expect("Failed to get key: db error")
+				.expect("Warmup key should exist");
+
+			// sanity for warmup keys
+			assert_eq!(&value, warmup_value);
+		}
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(3));
+		}
+
+		let started = std::time::Instant::now();
+		for (key, _) in self.query_keys.iter() {
+			let _ = trie_backend.storage(&key[..]);
+		}
+		let elapsed = started.elapsed();
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(1));
+		}
+
+		elapsed / (SAMPLE_SIZE as u32)
+	}
+}
+
+pub struct TrieWriteBenchmarkDescription {
+	pub database_size: DatabaseSize,
+	pub database_type: DatabaseType,
+}
+
+impl core::BenchmarkDescription for TrieWriteBenchmarkDescription {
+	fn path(&self) -> Path {
+		let mut path = Path::new(&["trie", "write"]);
+		path.push(&format!("{}", self.database_size));
+		path
+	}
+
+	fn setup(self: Box<Self>) -> Box<dyn core::Benchmark> {
+		let mut database = TempDatabase::new();
+
+		let mut rng = rand::thread_rng();
+		let warmup_prefix = KUSAMA_STATE_DISTRIBUTION.key(&mut rng);
+
+		let mut key_values = KeyValues::new();
+		let mut warmup_keys = KeyValues::new();
+		let every_x_key = self.database_size.keys() / SAMPLE_SIZE;
+		for idx in 0..self.database_size.keys() {
+			let kv = (
+				KUSAMA_STATE_DISTRIBUTION.key(&mut rng).to_vec(),
+				KUSAMA_STATE_DISTRIBUTION.value(&mut rng),
+			);
+			if idx % every_x_key == 0 {
+				// warmup keys go to separate tree with high prob
+				let mut actual_warmup_key = warmup_prefix.clone();
+				actual_warmup_key[16..].copy_from_slice(&kv.0[16..]);
+				warmup_keys.push((actual_warmup_key.clone(), kv.1.clone()));
+				key_values.push((actual_warmup_key.clone(), kv.1.clone()));
+			}
+
+			key_values.push(kv)
+		}
+
+		assert_eq!(warmup_keys.len(), SAMPLE_SIZE);
+
+		let root = generate_trie(database.open(self.database_type), key_values);
+
+		Box::new(TrieWriteBenchmark {
+			database,
+			root,
+			warmup_keys,
+			database_type: self.database_type,
+		})
+	}
+
+	fn name(&self) -> Cow<'static, str> {
+		format!(
+			"Trie write benchmark({:?} database ({} keys), db_type = {:?})",
+			self.database_size,
+			pretty_print(self.database_size.keys()),
+			self.database_type,
+		)
+		.into()
+	}
+}
+
+struct TrieWriteBenchmark {
+	database: TempDatabase,
+	root: Hash,
+	warmup_keys: KeyValues,
+	database_type: DatabaseType,
+}
+
+impl core::Benchmark for TrieWriteBenchmark {
+	fn run(&mut self, mode: Mode) -> std::time::Duration {
+		let mut rng = rand::thread_rng();
+		let mut db = self.database.clone();
+		let kvdb = db.open(self.database_type);
+
+		let mut new_root = self.root;
+
+		let mut overlay = HashMap::new();
+		let mut trie = SimpleTrie { db: kvdb.clone(), overlay: &mut overlay };
+		let mut trie_db_mut = TrieDBMutBuilderV1::from_existing(&mut trie, &mut new_root).build();
+
+		for (warmup_key, warmup_value) in self.warmup_keys.iter() {
+			let value = trie_db_mut
+				.get(&warmup_key[..])
+				.expect("Failed to get key: db error")
+				.expect("Warmup key should exist");
+
+			// sanity for warmup keys
+			assert_eq!(&value, warmup_value);
+		}
+
+		let test_key = random_vec(&mut rng, 32);
+		let test_val = random_vec(&mut rng, TEST_WRITE_SIZE);
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(3));
+		}
+
+		let started = std::time::Instant::now();
+
+		trie_db_mut.insert(&test_key, &test_val).expect("Should be inserted ok");
+		trie_db_mut.commit();
+		drop(trie_db_mut);
+
+		let mut transaction = kvdb.transaction();
+		for (key, value) in overlay.into_iter() {
+			match value {
+				Some(value) => transaction.put(0, &key[..], &value[..]),
+				None => transaction.delete(0, &key[..]),
+			}
+		}
+		kvdb.write(transaction).expect("Failed to write transaction");
+
+		let elapsed = started.elapsed();
+
+		// sanity check
+		assert!(new_root != self.root);
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(1));
+		}
+
+		elapsed
+	}
+}
+
+fn random_vec<R: Rng>(rng: &mut R, len: usize) -> Vec<u8> {
+	let mut val = vec![0u8; len];
+	rng.fill_bytes(&mut val[..]);
+	val
+}
+
+struct SizePool {
+	distribution: std::collections::BTreeMap<u32, u32>,
+	total: u32,
+}
+
+impl SizePool {
+	fn from_histogram(h: &[(u32, u32)]) -> SizePool {
+		let mut distribution = std::collections::BTreeMap::default();
+		let mut total = 0;
+		for (size, count) in h {
+			total += count;
+			distribution.insert(total, *size);
+		}
+		SizePool { distribution, total }
+	}
+
+	fn value<R: Rng>(&self, rng: &mut R) -> Vec<u8> {
+		let sr = (rng.next_u64() % self.total as u64) as u32;
+		let mut range = self
+			.distribution
+			.range((std::ops::Bound::Included(sr), std::ops::Bound::Unbounded));
+		let size = *range.next().unwrap().1 as usize;
+		random_vec(rng, size)
+	}
+
+	fn key<R: Rng>(&self, rng: &mut R) -> Vec<u8> {
+		random_vec(rng, 32)
+	}
+}
diff --git a/substrate/bin/node/bench/src/txpool.rs b/substrate/bin/node/bench/src/txpool.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a3524ac5bc8901be636e23c2cc666feb7cfb460d
--- /dev/null
+++ b/substrate/bin/node/bench/src/txpool.rs
@@ -0,0 +1,102 @@
+// 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/>.
+
+//! Transaction pool integrated benchmarks.
+//!
+//! The goal of this benchmark is to figure out time needed to fill
+//! the transaction pool for the next block.
+
+use std::borrow::Cow;
+
+use node_testing::bench::{BenchDb, BlockType, DatabaseType, KeyTypes};
+
+use sc_transaction_pool::BasicPool;
+use sc_transaction_pool_api::{TransactionPool, TransactionSource};
+use sp_runtime::generic::BlockId;
+
+use crate::core::{self, Mode, Path};
+
+pub struct PoolBenchmarkDescription {
+	pub database_type: DatabaseType,
+}
+
+pub struct PoolBenchmark {
+	database: BenchDb,
+}
+
+impl core::BenchmarkDescription for PoolBenchmarkDescription {
+	fn path(&self) -> Path {
+		Path::new(&["node", "txpool"])
+	}
+
+	fn setup(self: Box<Self>) -> Box<dyn core::Benchmark> {
+		Box::new(PoolBenchmark {
+			database: BenchDb::with_key_types(self.database_type, 50_000, KeyTypes::Sr25519),
+		})
+	}
+
+	fn name(&self) -> Cow<'static, str> {
+		"Transaction pool benchmark".into()
+	}
+}
+
+impl core::Benchmark for PoolBenchmark {
+	fn run(&mut self, mode: Mode) -> std::time::Duration {
+		let context = self.database.create_context();
+
+		let _ = context
+			.client
+			.runtime_version_at(context.client.chain_info().genesis_hash)
+			.expect("Failed to get runtime version")
+			.spec_version;
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(3));
+		}
+
+		let executor = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			executor,
+			context.client.clone(),
+		);
+
+		let generated_transactions = self
+			.database
+			.block_content(
+				BlockType::RandomTransfersKeepAlive.to_content(Some(100)),
+				&context.client,
+			)
+			.into_iter()
+			.collect::<Vec<_>>();
+
+		let start = std::time::Instant::now();
+		let submissions = generated_transactions
+			.into_iter()
+			.map(|tx| txpool.submit_one(&BlockId::Number(0), TransactionSource::External, tx));
+		futures::executor::block_on(futures::future::join_all(submissions));
+		let elapsed = start.elapsed();
+
+		if mode == Mode::Profile {
+			std::thread::park_timeout(std::time::Duration::from_secs(1));
+		}
+		elapsed
+	}
+}
diff --git a/substrate/bin/node/cli/Cargo.toml b/substrate/bin/node/cli/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fcab4cc6517a9b2f7cbc1a407488cef7abf46758
--- /dev/null
+++ b/substrate/bin/node/cli/Cargo.toml
@@ -0,0 +1,197 @@
+[package]
+name = "node-cli"
+version = "3.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Generic Substrate node implementation in Rust."
+build = "build.rs"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+default-run = "substrate-node"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.wasm-pack.profile.release]
+# `wasm-opt` has some problems on linux, see
+# https://github.com/rustwasm/wasm-pack/issues/781 etc.
+wasm-opt = false
+
+[package.metadata.docs.rs]
+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" }
+
+# 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"
+required-features = ["cli"]
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+# third-party dependencies
+array-bytes = "6.1"
+clap = { version = "4.2.5", features = ["derive"], optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+serde = { version = "1.0.163", features = ["derive"] }
+jsonrpsee = { version = "0.16.2", features = ["server"] }
+futures = "0.3.21"
+log = "0.4.17"
+rand = "0.8"
+
+# primitives
+sp-authority-discovery = { version = "4.0.0-dev", path = "../../../primitives/authority-discovery" }
+sp-consensus-babe = { version = "0.10.0-dev", path = "../../../primitives/consensus/babe" }
+grandpa-primitives = { version = "4.0.0-dev", package = "sp-consensus-grandpa", path = "../../../primitives/consensus/grandpa" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-timestamp = { version = "4.0.0-dev", path = "../../../primitives/timestamp" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-transaction-storage-proof = { version = "4.0.0-dev", path = "../../../primitives/transaction-storage-proof" }
+sp-io = { path = "../../../primitives/io" }
+sp-statement-store = { path = "../../../primitives/statement-store" }
+
+# client dependencies
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api" }
+sc-chain-spec = { version = "4.0.0-dev", path = "../../../client/chain-spec" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-transaction-pool = { version = "4.0.0-dev", path = "../../../client/transaction-pool" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../client/transaction-pool/api" }
+sc-statement-store = { version = "4.0.0-dev", path = "../../../client/statement-store" }
+sc-network = { version = "0.10.0-dev", path = "../../../client/network" }
+sc-network-common = { version = "0.10.0-dev", path = "../../../client/network/common" }
+sc-network-sync = { version = "0.10.0-dev", path = "../../../client/network/sync" }
+sc-network-statement = { version = "0.10.0-dev", path = "../../../client/network/statement" }
+sc-consensus-slots = { version = "0.10.0-dev", path = "../../../client/consensus/slots" }
+sc-consensus-babe = { version = "0.10.0-dev", path = "../../../client/consensus/babe" }
+grandpa = { version = "0.10.0-dev", package = "sc-consensus-grandpa", path = "../../../client/consensus/grandpa" }
+sc-rpc = { version = "4.0.0-dev", path = "../../../client/rpc" }
+sc-basic-authorship = { version = "0.10.0-dev", path = "../../../client/basic-authorship" }
+sc-service = { version = "0.10.0-dev", default-features = false, path = "../../../client/service" }
+sc-telemetry = { version = "4.0.0-dev", path = "../../../client/telemetry" }
+sc-executor = { version = "0.10.0-dev", path = "../../../client/executor" }
+sc-authority-discovery = { version = "0.10.0-dev", path = "../../../client/authority-discovery" }
+sc-sync-state-rpc = { version = "0.10.0-dev", path = "../../../client/sync-state-rpc" }
+sc-sysinfo = { version = "6.0.0-dev", path = "../../../client/sysinfo" }
+sc-storage-monitor = { version = "0.1.0", path = "../../../client/storage-monitor" }
+sc-offchain = { version = "4.0.0-dev", path = "../../../client/offchain" }
+
+# frame dependencies
+frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
+frame-system-rpc-runtime-api = { version = "4.0.0-dev", path = "../../../frame/system/rpc/runtime-api" }
+pallet-assets = { version = "4.0.0-dev", path = "../../../frame/assets/" }
+pallet-asset-conversion-tx-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/asset-conversion-tx-payment" }
+pallet-asset-tx-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/asset-tx-payment" }
+pallet-im-online = { version = "4.0.0-dev", default-features = false, path = "../../../frame/im-online" }
+
+# node-specific dependencies
+kitchensink-runtime = { version = "3.0.0-dev", path = "../runtime" }
+node-rpc = { version = "3.0.0-dev", path = "../rpc" }
+node-primitives = { version = "2.0.0", path = "../primitives" }
+node-executor = { version = "3.0.0-dev", path = "../executor" }
+
+# CLI-specific dependencies
+sc-cli = { version = "0.10.0-dev", optional = true, path = "../../../client/cli" }
+frame-benchmarking-cli = { version = "4.0.0-dev", optional = true, path = "../../../utils/frame/benchmarking-cli" }
+node-inspect = { version = "0.9.0-dev", optional = true, path = "../inspect" }
+try-runtime-cli = { version = "0.10.0-dev", optional = true, path = "../../../utils/frame/try-runtime/cli" }
+serde_json = "1.0.85"
+
+[dev-dependencies]
+sc-keystore = { version = "4.0.0-dev", path = "../../../client/keystore" }
+sc-client-db = { version = "0.10.0-dev", path = "../../../client/db" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-consensus-babe = { version = "0.10.0-dev", path = "../../../client/consensus/babe" }
+sc-consensus-epochs = { version = "0.10.0-dev", path = "../../../client/consensus/epochs" }
+sc-service-test = { version = "2.0.0", path = "../../../client/service/test" }
+sc-block-builder = { version = "0.10.0-dev", path = "../../../client/block-builder" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+futures = "0.3.21"
+tempfile = "3.1.0"
+assert_cmd = "2.0.2"
+nix = { version = "0.26.1", features = ["signal"] }
+serde_json = "1.0"
+regex = "1.6.0"
+platforms = "3.0"
+soketto = "0.7.1"
+criterion = { version = "0.4.0", features = ["async_tokio"] }
+tokio = { version = "1.22.0", features = ["macros", "time", "parking_lot"] }
+tokio-util = { version = "0.7.4", features = ["compat"] }
+wait-timeout = "0.2"
+substrate-rpc-client = { path = "../../../utils/frame/rpc/client" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../../../frame/timestamp" }
+substrate-cli-test-utils = { path = "../../../test-utils/cli" }
+
+[build-dependencies]
+clap = { version = "4.2.5", optional = true }
+clap_complete = { version = "4.0.2", optional = true }
+node-inspect = { version = "0.9.0-dev", optional = true, path = "../inspect" }
+frame-benchmarking-cli = { version = "4.0.0-dev", optional = true, path = "../../../utils/frame/benchmarking-cli" }
+substrate-build-script-utils = { version = "3.0.0", optional = true, path = "../../../utils/build-script-utils" }
+substrate-frame-cli = { version = "4.0.0-dev", optional = true, path = "../../../utils/frame/frame-utilities-cli" }
+try-runtime-cli = { version = "0.10.0-dev", optional = true, path = "../../../utils/frame/try-runtime/cli" }
+sc-cli = { version = "0.10.0-dev", path = "../../../client/cli", optional = true }
+pallet-balances = { version = "4.0.0-dev", path = "../../../frame/balances" }
+sc-storage-monitor = { version = "0.1.0", path = "../../../client/storage-monitor" }
+
+[features]
+default = [ "cli" ]
+cli = [
+	"clap",
+	"clap_complete",
+	"frame-benchmarking-cli",
+	"node-inspect",
+	"sc-cli",
+	"sc-service/rocksdb",
+	"substrate-build-script-utils",
+	"substrate-frame-cli",
+	"try-runtime-cli",
+]
+runtime-benchmarks = [
+	"frame-benchmarking-cli/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"kitchensink-runtime/runtime-benchmarks",
+	"pallet-asset-tx-payment/runtime-benchmarks",
+	"pallet-assets/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-im-online/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sc-client-db/runtime-benchmarks",
+	"sc-service/runtime-benchmarks",
+	"sp-runtime/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-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-im-online/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+	"substrate-cli-test-utils/try-runtime",
+	"try-runtime-cli/try-runtime",
+]
+
+[[bench]]
+name = "transaction_pool"
+harness = false
+
+[[bench]]
+name = "block_production"
+harness = false
diff --git a/substrate/bin/node/cli/benches/block_production.rs b/substrate/bin/node/cli/benches/block_production.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b877aa7350228ca7b0d2a766ba9aba0e8b96b71c
--- /dev/null
+++ b/substrate/bin/node/cli/benches/block_production.rs
@@ -0,0 +1,222 @@
+// 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 criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
+
+use kitchensink_runtime::{constants::currency::*, BalancesCall};
+use node_cli::service::{create_extrinsic, FullClient};
+use sc_block_builder::{BlockBuilderProvider, BuiltBlock, RecordProof};
+use sc_consensus::{
+	block_import::{BlockImportParams, ForkChoiceStrategy},
+	BlockImport, StateAction,
+};
+use sc_service::{
+	config::{
+		BlocksPruning, DatabaseSource, KeystoreConfig, NetworkConfiguration, OffchainWorkerConfig,
+		PruningMode, WasmExecutionMethod, WasmtimeInstantiationStrategy,
+	},
+	BasePath, Configuration, Role,
+};
+use sp_blockchain::{ApplyExtrinsicFailed::Validity, Error::ApplyExtrinsicFailed};
+use sp_consensus::BlockOrigin;
+use sp_keyring::Sr25519Keyring;
+use sp_runtime::{
+	transaction_validity::{InvalidTransaction, TransactionValidityError},
+	AccountId32, MultiAddress, OpaqueExtrinsic,
+};
+use tokio::runtime::Handle;
+
+fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
+	let base_path = BasePath::new_temp_dir()
+		.expect("getting the base path of a temporary path doesn't fail; qed");
+	let root = base_path.path().to_path_buf();
+
+	let network_config = NetworkConfiguration::new(
+		Sr25519Keyring::Alice.to_seed(),
+		"network/test/0.1",
+		Default::default(),
+		None,
+	);
+
+	let spec = Box::new(node_cli::chain_spec::development_config());
+
+	let config = Configuration {
+		impl_name: "BenchmarkImpl".into(),
+		impl_version: "1.0".into(),
+		// We don't use the authority role since that would start producing blocks
+		// in the background which would mess with our benchmark.
+		role: Role::Full,
+		tokio_handle,
+		transaction_pool: Default::default(),
+		network: network_config,
+		keystore: KeystoreConfig::InMemory,
+		database: DatabaseSource::RocksDb { path: root.join("db"), cache_size: 128 },
+		trie_cache_maximum_size: Some(64 * 1024 * 1024),
+		state_pruning: Some(PruningMode::ArchiveAll),
+		blocks_pruning: BlocksPruning::KeepAll,
+		chain_spec: spec,
+		wasm_method: WasmExecutionMethod::Compiled {
+			instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
+		},
+		rpc_addr: None,
+		rpc_max_connections: Default::default(),
+		rpc_cors: None,
+		rpc_methods: Default::default(),
+		rpc_max_request_size: Default::default(),
+		rpc_max_response_size: Default::default(),
+		rpc_id_provider: Default::default(),
+		rpc_max_subs_per_conn: Default::default(),
+		rpc_port: 9944,
+		prometheus_config: None,
+		telemetry_endpoints: None,
+		default_heap_pages: None,
+		offchain_worker: OffchainWorkerConfig { enabled: true, indexing_enabled: false },
+		force_authoring: false,
+		disable_grandpa: false,
+		dev_key_seed: Some(Sr25519Keyring::Alice.to_seed()),
+		tracing_targets: None,
+		tracing_receiver: Default::default(),
+		max_runtime_instances: 8,
+		runtime_cache_size: 2,
+		announce_block: true,
+		data_path: base_path.path().into(),
+		base_path,
+		informant_output_format: Default::default(),
+		wasm_runtime_overrides: None,
+	};
+
+	node_cli::service::new_full_base(config, false, |_, _| ())
+		.expect("creating a full node doesn't fail")
+}
+
+fn extrinsic_set_time(now: u64) -> OpaqueExtrinsic {
+	kitchensink_runtime::UncheckedExtrinsic {
+		signature: None,
+		function: kitchensink_runtime::RuntimeCall::Timestamp(pallet_timestamp::Call::set { now }),
+	}
+	.into()
+}
+
+fn import_block(mut client: &FullClient, built: BuiltBlock<node_primitives::Block>) {
+	let mut params = BlockImportParams::new(BlockOrigin::File, built.block.header);
+	params.state_action =
+		StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(built.storage_changes));
+	params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+	futures::executor::block_on(client.import_block(params))
+		.expect("importing a block doesn't fail");
+}
+
+fn prepare_benchmark(client: &FullClient) -> (usize, Vec<OpaqueExtrinsic>) {
+	const MINIMUM_PERIOD_FOR_BLOCKS: u64 = 1500;
+
+	let mut max_transfer_count = 0;
+	let mut extrinsics = Vec::new();
+	let mut block_builder = client.new_block(Default::default()).unwrap();
+
+	// Every block needs one timestamp extrinsic.
+	let extrinsic_set_time = extrinsic_set_time(1 + MINIMUM_PERIOD_FOR_BLOCKS);
+	block_builder.push(extrinsic_set_time.clone()).unwrap();
+	extrinsics.push(extrinsic_set_time);
+
+	// Creating those is surprisingly costly, so let's only do it once and later just `clone` them.
+	let src = Sr25519Keyring::Alice.pair();
+	let dst: MultiAddress<AccountId32, u32> = Sr25519Keyring::Bob.to_account_id().into();
+
+	// Add as many tranfer extrinsics as possible into a single block.
+	for nonce in 0.. {
+		let extrinsic: OpaqueExtrinsic = create_extrinsic(
+			client,
+			src.clone(),
+			BalancesCall::transfer_allow_death { dest: dst.clone(), value: 1 * DOLLARS },
+			Some(nonce),
+		)
+		.into();
+
+		match block_builder.push(extrinsic.clone()) {
+			Ok(_) => {},
+			Err(ApplyExtrinsicFailed(Validity(TransactionValidityError::Invalid(
+				InvalidTransaction::ExhaustsResources,
+			)))) => break,
+			Err(error) => panic!("{}", error),
+		}
+
+		extrinsics.push(extrinsic);
+		max_transfer_count += 1;
+	}
+
+	(max_transfer_count, extrinsics)
+}
+
+fn block_production(c: &mut Criterion) {
+	sp_tracing::try_init_simple();
+
+	let runtime = tokio::runtime::Runtime::new().expect("creating tokio runtime doesn't fail; qed");
+	let tokio_handle = runtime.handle().clone();
+
+	let node = new_node(tokio_handle.clone());
+	let client = &*node.client;
+
+	// Buliding the very first block is around ~30x slower than any subsequent one,
+	// so let's make sure it's built and imported before we benchmark anything.
+	let mut block_builder = client.new_block(Default::default()).unwrap();
+	block_builder.push(extrinsic_set_time(1)).unwrap();
+	import_block(client, block_builder.build().unwrap());
+
+	let (max_transfer_count, extrinsics) = prepare_benchmark(&client);
+	log::info!("Maximum transfer count: {}", max_transfer_count);
+
+	let mut group = c.benchmark_group("Block production");
+
+	group.sample_size(10);
+	group.throughput(Throughput::Elements(max_transfer_count as u64));
+
+	let best_hash = client.chain_info().best_hash;
+
+	group.bench_function(format!("{} transfers (no proof)", max_transfer_count), |b| {
+		b.iter_batched(
+			|| extrinsics.clone(),
+			|extrinsics| {
+				let mut block_builder =
+					client.new_block_at(best_hash, Default::default(), RecordProof::No).unwrap();
+				for extrinsic in extrinsics {
+					block_builder.push(extrinsic).unwrap();
+				}
+				block_builder.build().unwrap()
+			},
+			BatchSize::SmallInput,
+		)
+	});
+
+	group.bench_function(format!("{} transfers (with proof)", max_transfer_count), |b| {
+		b.iter_batched(
+			|| extrinsics.clone(),
+			|extrinsics| {
+				let mut block_builder =
+					client.new_block_at(best_hash, Default::default(), RecordProof::Yes).unwrap();
+				for extrinsic in extrinsics {
+					block_builder.push(extrinsic).unwrap();
+				}
+				block_builder.build().unwrap()
+			},
+			BatchSize::SmallInput,
+		)
+	});
+}
+
+criterion_group!(benches, block_production);
+criterion_main!(benches);
diff --git a/substrate/bin/node/cli/benches/transaction_pool.rs b/substrate/bin/node/cli/benches/transaction_pool.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d3e8c02a958f7e3379c199c64653d53fe3230429
--- /dev/null
+++ b/substrate/bin/node/cli/benches/transaction_pool.rs
@@ -0,0 +1,264 @@
+// 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 std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
+use futures::{future, StreamExt};
+use kitchensink_runtime::{constants::currency::*, BalancesCall, SudoCall};
+use node_cli::service::{create_extrinsic, fetch_nonce, FullClient, TransactionPool};
+use node_primitives::AccountId;
+use sc_service::{
+	config::{
+		BlocksPruning, DatabaseSource, KeystoreConfig, NetworkConfiguration, OffchainWorkerConfig,
+		PruningMode, TransactionPoolOptions,
+	},
+	BasePath, Configuration, Role,
+};
+use sc_transaction_pool::PoolLimit;
+use sc_transaction_pool_api::{TransactionPool as _, TransactionSource, TransactionStatus};
+use sp_core::{crypto::Pair, sr25519};
+use sp_keyring::Sr25519Keyring;
+use sp_runtime::{generic::BlockId, OpaqueExtrinsic};
+use tokio::runtime::Handle;
+
+fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
+	let base_path = BasePath::new_temp_dir().expect("Creates base path");
+	let root = base_path.path().to_path_buf();
+
+	let network_config = NetworkConfiguration::new(
+		Sr25519Keyring::Alice.to_seed(),
+		"network/test/0.1",
+		Default::default(),
+		None,
+	);
+
+	let spec = Box::new(node_cli::chain_spec::development_config());
+
+	let config = Configuration {
+		impl_name: "BenchmarkImpl".into(),
+		impl_version: "1.0".into(),
+		role: Role::Authority,
+		tokio_handle,
+		transaction_pool: TransactionPoolOptions {
+			ready: PoolLimit { count: 100_000, total_bytes: 100 * 1024 * 1024 },
+			future: PoolLimit { count: 100_000, total_bytes: 100 * 1024 * 1024 },
+			reject_future_transactions: false,
+			ban_time: Duration::from_secs(30 * 60),
+		},
+		network: network_config,
+		keystore: KeystoreConfig::InMemory,
+		database: DatabaseSource::RocksDb { path: root.join("db"), cache_size: 128 },
+		trie_cache_maximum_size: Some(64 * 1024 * 1024),
+		state_pruning: Some(PruningMode::ArchiveAll),
+		blocks_pruning: BlocksPruning::KeepAll,
+		chain_spec: spec,
+		wasm_method: Default::default(),
+		rpc_addr: None,
+		rpc_max_connections: Default::default(),
+		rpc_cors: None,
+		rpc_methods: Default::default(),
+		rpc_max_request_size: Default::default(),
+		rpc_max_response_size: Default::default(),
+		rpc_id_provider: Default::default(),
+		rpc_max_subs_per_conn: Default::default(),
+		rpc_port: 9944,
+		prometheus_config: None,
+		telemetry_endpoints: None,
+		default_heap_pages: None,
+		offchain_worker: OffchainWorkerConfig { enabled: true, indexing_enabled: false },
+		force_authoring: false,
+		disable_grandpa: false,
+		dev_key_seed: Some(Sr25519Keyring::Alice.to_seed()),
+		tracing_targets: None,
+		tracing_receiver: Default::default(),
+		max_runtime_instances: 8,
+		runtime_cache_size: 2,
+		announce_block: true,
+		data_path: base_path.path().into(),
+		base_path,
+		informant_output_format: Default::default(),
+		wasm_runtime_overrides: None,
+	};
+
+	node_cli::service::new_full_base(config, false, |_, _| ()).expect("Creates node")
+}
+
+fn create_accounts(num: usize) -> Vec<sr25519::Pair> {
+	(0..num)
+		.map(|i| {
+			Pair::from_string(&format!("{}/{}", Sr25519Keyring::Alice.to_seed(), i), None)
+				.expect("Creates account pair")
+		})
+		.collect()
+}
+
+/// Create the extrinsics that will initialize the accounts from the sudo account (Alice).
+///
+/// `start_nonce` is the current nonce of Alice.
+fn create_account_extrinsics(
+	client: &FullClient,
+	accounts: &[sr25519::Pair],
+) -> Vec<OpaqueExtrinsic> {
+	let start_nonce = fetch_nonce(client, Sr25519Keyring::Alice.pair());
+
+	accounts
+		.iter()
+		.enumerate()
+		.flat_map(|(i, a)| {
+			vec![
+				// Reset the nonce by removing any funds
+				create_extrinsic(
+					client,
+					Sr25519Keyring::Alice.pair(),
+					SudoCall::sudo {
+						call: Box::new(
+							BalancesCall::force_set_balance {
+								who: AccountId::from(a.public()).into(),
+								new_free: 0,
+							}
+							.into(),
+						),
+					},
+					Some(start_nonce + (i as u32) * 2),
+				),
+				// Give back funds
+				create_extrinsic(
+					client,
+					Sr25519Keyring::Alice.pair(),
+					SudoCall::sudo {
+						call: Box::new(
+							BalancesCall::force_set_balance {
+								who: AccountId::from(a.public()).into(),
+								new_free: 1_000_000 * DOLLARS,
+							}
+							.into(),
+						),
+					},
+					Some(start_nonce + (i as u32) * 2 + 1),
+				),
+			]
+		})
+		.map(OpaqueExtrinsic::from)
+		.collect()
+}
+
+fn create_benchmark_extrinsics(
+	client: &FullClient,
+	accounts: &[sr25519::Pair],
+	extrinsics_per_account: usize,
+) -> Vec<OpaqueExtrinsic> {
+	accounts
+		.iter()
+		.flat_map(|account| {
+			(0..extrinsics_per_account).map(move |nonce| {
+				create_extrinsic(
+					client,
+					account.clone(),
+					BalancesCall::transfer_allow_death {
+						dest: Sr25519Keyring::Bob.to_account_id().into(),
+						value: 1 * DOLLARS,
+					},
+					Some(nonce as u32),
+				)
+			})
+		})
+		.map(OpaqueExtrinsic::from)
+		.collect()
+}
+
+async fn submit_tx_and_wait_for_inclusion(
+	tx_pool: &TransactionPool,
+	tx: OpaqueExtrinsic,
+	client: &FullClient,
+	wait_for_finalized: bool,
+) {
+	let best_hash = client.chain_info().best_hash;
+
+	let mut watch = tx_pool
+		.submit_and_watch(&BlockId::Hash(best_hash), TransactionSource::External, tx.clone())
+		.await
+		.expect("Submits tx to pool")
+		.fuse();
+
+	loop {
+		match watch.select_next_some().await {
+			TransactionStatus::Finalized(_) => break,
+			TransactionStatus::InBlock(_) if !wait_for_finalized => break,
+			_ => {},
+		}
+	}
+}
+
+fn transaction_pool_benchmarks(c: &mut Criterion) {
+	sp_tracing::try_init_simple();
+
+	let runtime = tokio::runtime::Runtime::new().expect("Creates tokio runtime");
+	let tokio_handle = runtime.handle().clone();
+
+	let node = new_node(tokio_handle.clone());
+
+	let account_num = 10;
+	let extrinsics_per_account = 2000;
+	let accounts = create_accounts(account_num);
+
+	let mut group = c.benchmark_group("Transaction pool");
+
+	group.sample_size(10);
+	group.throughput(Throughput::Elements(account_num as u64 * extrinsics_per_account as u64));
+
+	let mut counter = 1;
+	group.bench_function(
+		format!("{} transfers from {} accounts", account_num * extrinsics_per_account, account_num),
+		move |b| {
+			b.iter_batched(
+				|| {
+					let prepare_extrinsics = create_account_extrinsics(&node.client, &accounts);
+
+					runtime.block_on(future::join_all(prepare_extrinsics.into_iter().map(|tx| {
+						submit_tx_and_wait_for_inclusion(
+							&node.transaction_pool,
+							tx,
+							&node.client,
+							true,
+						)
+					})));
+
+					create_benchmark_extrinsics(&node.client, &accounts, extrinsics_per_account)
+				},
+				|extrinsics| {
+					runtime.block_on(future::join_all(extrinsics.into_iter().map(|tx| {
+						submit_tx_and_wait_for_inclusion(
+							&node.transaction_pool,
+							tx,
+							&node.client,
+							false,
+						)
+					})));
+
+					println!("Finished {}", counter);
+					counter += 1;
+				},
+				BatchSize::SmallInput,
+			)
+		},
+	);
+}
+
+criterion_group!(benches, transaction_pool_benchmarks);
+criterion_main!(benches);
diff --git a/substrate/bin/node/cli/bin/main.rs b/substrate/bin/node/cli/bin/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b434a3e6dad53f6bbbb47eed4702d57bf1ed405
--- /dev/null
+++ b/substrate/bin/node/cli/bin/main.rs
@@ -0,0 +1,25 @@
+// 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/>.
+
+//! Substrate Node CLI
+
+#![warn(missing_docs)]
+
+fn main() -> sc_cli::Result<()> {
+	node_cli::run()
+}
diff --git a/substrate/bin/node/cli/build.rs b/substrate/bin/node/cli/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..033f1e3349e6fae1f062f9a075dcb66295aab22d
--- /dev/null
+++ b/substrate/bin/node/cli/build.rs
@@ -0,0 +1,66 @@
+// 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/>.
+
+fn main() {
+	#[cfg(feature = "cli")]
+	cli::main();
+}
+
+#[cfg(feature = "cli")]
+mod cli {
+	include!("src/cli.rs");
+
+	use clap::{CommandFactory, ValueEnum};
+	use clap_complete::{generate_to, Shell};
+	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();
+		generate_cargo_keys();
+
+		rerun_if_git_head_changed();
+	}
+
+	/// Build shell completion scripts for all known shells.
+	fn build_shell_completion() {
+		for shell in Shell::value_variants() {
+			build_completion(shell);
+		}
+	}
+
+	/// Build the shell auto-completion for a given Shell.
+	fn build_completion(shell: &Shell) {
+		let outdir = match env::var_os("OUT_DIR") {
+			None => return,
+			Some(dir) => dir,
+		};
+		let path = Path::new(&outdir)
+			.parent()
+			.unwrap()
+			.parent()
+			.unwrap()
+			.parent()
+			.unwrap()
+			.join("completion-scripts");
+
+		fs::create_dir(&path).ok();
+
+		let _ = generate_to(*shell, &mut Cli::command(), "substrate-node", &path);
+	}
+}
diff --git a/substrate/bin/node/cli/doc/shell-completion.adoc b/substrate/bin/node/cli/doc/shell-completion.adoc
new file mode 100644
index 0000000000000000000000000000000000000000..168f00994fb2de175266447965576c6de6876591
--- /dev/null
+++ b/substrate/bin/node/cli/doc/shell-completion.adoc
@@ -0,0 +1,41 @@
+
+== Shell completion
+
+The Substrate cli command supports shell auto-completion. For this to work, you will need to run the completion script matching your build and system.
+
+Assuming you built a release version using `cargo build --release` and use `bash` run the following:
+
+[source, shell]
+source target/release/completion-scripts/substrate.bash
+
+You can find completion scripts for:
+- bash
+- fish
+- zsh
+- elvish
+- powershell
+
+To make this change persistent, you can proceed as follows:
+
+.First install
+
+[source, shell]
+----
+COMPL_DIR=$HOME/.completion
+mkdir -p $COMPL_DIR
+cp -f target/release/completion-scripts/substrate.bash $COMPL_DIR/
+echo "source $COMPL_DIR/substrate.bash" >> $HOME/.bash_profile
+source $HOME/.bash_profile
+----
+
+.Update
+
+When you build a new version of Substrate, the following will ensure your auto-completion script matches the current binary:
+
+[source, shell]
+----
+COMPL_DIR=$HOME/.completion
+mkdir -p $COMPL_DIR
+cp -f target/release/completion-scripts/substrate.bash $COMPL_DIR/
+source $HOME/.bash_profile
+----
diff --git a/substrate/bin/node/cli/res/flaming-fir.json b/substrate/bin/node/cli/res/flaming-fir.json
new file mode 100644
index 0000000000000000000000000000000000000000..5281b44790b2a25c9c8bf64781c3df6a22d51c60
--- /dev/null
+++ b/substrate/bin/node/cli/res/flaming-fir.json
@@ -0,0 +1,139 @@
+{
+  "name": "Flaming Fir",
+  "id": "flamingfir9",
+  "chainType": "Live",
+  "bootNodes": [
+    "/dns/0.flamingfir.paritytech.net/tcp/30333/p2p/12D3KooWLK2gMLhWsYJzjW3q35zAs9FDDVqfqVfVuskiGZGRSMvR",
+    "/dns/0.flamingfir.paritytech.net/tcp/30334/ws/p2p/12D3KooWLK2gMLhWsYJzjW3q35zAs9FDDVqfqVfVuskiGZGRSMvR",
+    "/dns/1.flamingfir.paritytech.net/tcp/30333/p2p/12D3KooWHyUSQkoL1WtnhLUYHuKbowZEZW1NNJe7TePKYZf9ucBY",
+    "/dns/1.flamingfir.paritytech.net/tcp/30334/ws/p2p/12D3KooWHyUSQkoL1WtnhLUYHuKbowZEZW1NNJe7TePKYZf9ucBY",
+    "/dns/2.flamingfir.paritytech.net/tcp/30333/p2p/12D3KooWFcry65ShtPT6roTTEPXD9H89A1iA2wPKgJCgXW1yZwyy",
+    "/dns/2.flamingfir.paritytech.net/tcp/30334/ws/p2p/12D3KooWFcry65ShtPT6roTTEPXD9H89A1iA2wPKgJCgXW1yZwyy",
+    "/dns/3.flamingfir.paritytech.net/tcp/30333/p2p/12D3KooWDfFapccu3KgvWyVMdXhMGPPpKiJ1yEhSMEupBZppfi9U",
+    "/dns/3.flamingfir.paritytech.net/tcp/30334/ws/p2p/12D3KooWDfFapccu3KgvWyVMdXhMGPPpKiJ1yEhSMEupBZppfi9U"
+  ],
+  "telemetryEndpoints": [
+    [
+      "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F",
+      0
+    ]
+  ],
+  "protocolId": "fir9",
+  "properties": {
+    "tokenDecimals": 15,
+    "tokenSymbol": "FIR"
+  },
+  "forkBlocks": null,
+  "badBlocks": null,
+  "consensusEngine": null,
+  "genesis": {
+    "raw": {
+      "top": {
+        "0xcec5070d609dd3497f72bde07fc96ba0e0cdd062e6eaf24295ad4ccfc41d4609": "0x109c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d129becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe96993326e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f91066e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f91066e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c26633919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f437800299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f437800299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d655633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce440482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde787932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195003e77b7332307fb461756469806e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106": "0x9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12",
+        "0x1cb6f36e027abb2091cfb5110ab5087f5e0621c4869aa60c02be9adcc98a0d1d": "0x106e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106010000000000000000299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f43780100000000000000482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a0100000000000000482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e0100000000000000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950279056c0dd3fd147696d6f6e806e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106": "0x9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12",
+        "0x5f3e4907f716ac89b6347d15ececedcaea07de2b8f010516dca3f7ef52f7ac5a": "0x040000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a00000000c90f9b6dd26886b468655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0x426e15054d267946093858132eb537f1ba7fb8745735dc3be2a2c61a72c39e78": "0x049ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade9879091c57296b2634547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe70c90f9b6dd26886b468655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0xc8dc79e36b29395413399edaec3e20fcca7205fb19776ed8ddb25d6f427ec40e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950a7c05e469443baab617564698000299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378": "0xf26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc49c1d737e05234a5ad3f96cf385e1f17b781ead1e2fa9ccb74b44c19d29cb2a7a4b5be3972927ae98cd3877523976a276": "0x9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d120f0000c16ff286230f0000c16ff286230000",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a00000000c90f9b6dd26886b468655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x00401eae822458363600000000000000",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb37441588f5c9a91b3f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x3919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f437800299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f437800299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378",
+        "0x5f3e4907f716ac89b6347d15ececedcaad811cd65a470ddc5f1d628ff0550982b4def25cfda6ef3a00000000": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a0000000054352b71083d945a9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195018823a93d5cac7d062616265806e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106": "0x9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a0000000054352b71083d945a9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc6a8d6d78917f3d243ed0a3d1dfb3878099c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x047374616b696e67200000c16ff2862300000000000000000002",
+        "0x2371e21684d2fae99bcb4d579242f74a8a2d09463effcc78a22d75b9cb87dffc": "0x0000000000000000",
+        "0x8985776095addd4789fccbce8ca77b23ba7fb8745735dc3be2a2c61a72c39e78": "0x049ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195081918b9c078ba64f696d6f6e8000299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378": "0xf26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195090ae3b675fd0a89f6175646980482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e": "0x68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95ecffd7b6c0f78751baa9d281e0bfa3a6d6f646c70792f74727372790000000000000000000000000000000000000000": "0x000000000000407a10f35a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca308ce9615de0775a82f8a94dc3d285a1": "0x02",
+        "0x5f3e4907f716ac89b6347d15ececedcac29a0310e1bb45d20cace77ccb62c97d": "0x00e1f505",
+        "0x426e15054d267946093858132eb537f195999521c6c89cd80b677e53ce20f98c": "0x9ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+        "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0x9ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+        "0x1cb6f36e027abb2091cfb5110ab5087f66e8f035c8adbe7f1547b43c51e6f8a4": "0x00000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9a831cc69a96025a90c389ecb19a25ff29ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809": "0x000000000100405f2954c5c535360000000000000000c040b571e8030000000000000000000000c16ff2862300000000000000000000000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a0000000079091c57296b2634547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb354352b71083d945a9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x9becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe96993326e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f91066e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f91066e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc6bed2903186223711a06d85784e730efd547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x047374616b696e67200000c16ff2862300000000000000000002",
+        "0x2099d7f109d6e535fb000bba623fd4409f99a2ce711f3a31b2fc05604c93f179": "0x106e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f910600299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc65018afb0daf0c8654bf248b8e9f3ca3cf26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x047374616b696e67200000c16ff2862300000000000000000002",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb379091c57296b2634547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x5633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce440482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe7054352b71083d945a9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x781ead1e2fa9ccb74b44c19d29cb2a7a4b5be3972927ae98cd3877523976a276",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a0000000079091c57296b2634547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0xd503106e6f6465",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9a8d6d78917f3d243ed0a3d1dfb3878099c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x00000000030000c16ff28623000000000000000000000000000000000000000000000000000000c16ff286230000000000000000000000c16ff28623000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e1690354352b71083d945a9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x00",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc6b2a4e124620611833d1b252494468c2a68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x047374616b696e67200000c16ff2862300000000000000000002",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950f05c8ba6ac2a99ca6175646980482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a": "0x547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a000000007441588f5c9a91b3f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9bed2903186223711a06d85784e730efd547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x00000000030000c16ff28623000000000000000000000000000000000000000000000000000000c16ff286230000000000000000000000c16ff28623000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a0000000079091c57296b2634547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedcab49a2738eeb30896aacb8b3fb46471bd": "0x04000000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195050b3bd0c839f9eac6772616e807932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f": "0x68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a00000000c90f9b6dd26886b468655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe7079091c57296b2634547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x9e42241d7cd91d001773b0b616d523dd80e13c6c2cab860b1234ef1b9ffc1526",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe707441588f5c9a91b3f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x66bc1e5d275da50b72b15de072a2468a5ad414919ca9054d2695767cf650012f",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc47bd1e6299d2e71c4c848a957ae243d7b9e42241d7cd91d001773b0b616d523dd80e13c6c2cab860b1234ef1b9ffc1526": "0x547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d650f0000c16ff286230f0000c16ff286230000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195082c7c7fe191a6e68696d6f6e80482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a": "0x547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade98c90f9b6dd26886b468655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x00",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950414ee903f38cbde66772616e805633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce440": "0x547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc40a81aa5d99517e5635e7865ccd909c4066bc1e5d275da50b72b15de072a2468a5ad414919ca9054d2695767cf650012f": "0xf26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c26630f0000c16ff286230f0000c16ff286230000",
+        "0x3a6772616e6470615f617574686f726974696573": "0x01109becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe969933201000000000000003919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef01000000000000005633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce44001000000000000007932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f0100000000000000",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc6a831cc69a96025a90c389ecb19a25ff29ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809": "0x04706872656c6563740000c16ff2862300000000000000000001",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b2a4e124620611833d1b252494468c2a68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x00000000030000c16ff28623000000000000000000000000000000000000000000000000000000c16ff286230000000000000000000000c16ff28623000000000000000000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195057479bdad16c7a386261626580482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e": "0x68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78",
+        "0xf2794c22e353e9a839f12faab03a911be2f6cb0456905c189bcb0458f9440f13": "0x00000000",
+        "0x3a636f6465": "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",
+        "0x3a65787472696e7369635f696e646578": "0x00000000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950d49dd691c4fe7bf66772616e803919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef": "0xf26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950606e9687c0a4d75f696d6f6e80482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e": "0x68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950dd81945454d561f36261626580482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a": "0x547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65",
+        "0x5f3e4907f716ac89b6347d15ececedcae1791577e4efcb083fdc3cb21e85b2e4": "0x00",
+        "0xe2e62dd81c48a88f73b6f6463555fd8eba7fb8745735dc3be2a2c61a72c39e78": "0x049ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e3180973474718090000c16ff28623000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaa141c4fe67c2d11f4a10c6aca7a79a04b4def25cfda6ef3a00000000": "0xd8ff03bfc91b8e000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95018afb0daf0c8654bf248b8e9f3ca3cf26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x00000000030000c16ff28623000000000000000000000000000000000000000000000000000000c16ff286230000000000000000000000c16ff28623000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a0000000054352b71083d945a9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x00",
+        "0x426e15054d267946093858132eb537f1d0b4a3f7631f0c0e761898fe198211de": "0xe7030000",
+        "0x5f3e4907f716ac89b6347d15ececedca0b6a45321efae92aea15e0740ec7afe7": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade987441588f5c9a91b3f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x00",
+        "0x2b06af9719ac64d755623cda8ddd9b949f99a2ce711f3a31b2fc05604c93f179": "0x106e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f910600299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e",
+        "0x426e15054d267946093858132eb537f1a47a9ff5cd5bf4d848a80a0b1a947dc3": "0x00000000000000000000000000000000",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3c90f9b6dd26886b468655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x7932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e16903c90f9b6dd26886b468655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78": "0x00",
+        "0xe2e62dd81c48a88f73b6f6463555fd8e71cd3068e6118bfb392b798317f63a89d28ebd9aad2de6179ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809": "0x0000c16ff28623000000000000000000049ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195088c3e18f0a370f936772616e809becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe9699332": "0x9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a000000007441588f5c9a91b3f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x00",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195082216e38506cc6f7626162658000299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378": "0xf26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663",
+        "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0x4342193e496fab7ec59d615ed0dc5530d2d505c0e6f76fd7ce0796ebe187401c": "0x0000000020a107000000000020a107000000000020a107000000000020a107000000000020a107000000000020a107000000000020a1070000000000e0f7050400000000e024370500000000e0f705040000000020a107000000000020a107000000000080f0fa020000000000e1f50500000000040000000000010010000000004000000020000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaf7dad0317324aecae8744b87fc95f2f3": "0x00",
+        "0x11f3ba2e1cdd6d62f2ff9b5589e7ff81ba7fb8745735dc3be2a2c61a72c39e78": "0x049ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+        "0x5f3e4907f716ac89b6347d15ececedca5579297f4dfb9609e7e4c2ebab9ce40a": "0x109c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d1268655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663",
+        "0x5f3e4907f716ac89b6347d15ececedca138e71612491192d68deab7e6f563fe1": "0x08000000",
+        "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0xcec5070d609dd3497f72bde07fc96ba088dcde934c658227ee1dfafcd6e16903": "0x109c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d6568655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e1690379091c57296b2634547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a000000007441588f5c9a91b3f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x0ff6ffc06ff286230ff6ffc06ff2862300",
+        "0x5f3e4907f716ac89b6347d15ececedca28dccb559b95c40168a1b2696581b5a7": "0x00000000000000000000000000000000",
+        "0xf2794c22e353e9a839f12faab03a911bbdcb0c5143a8617ed38ae3810dd45bc6": "0x00000000",
+        "0xf2794c22e353e9a839f12faab03a911b7f17cdfbfa73331856cca0acddd7842e": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaac0a2cbf8e355f5ea6cb2de8727bfb0c": "0x54000000",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade9854352b71083d945a9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc469a5ec1b3cb6032ce536e31d5679de28c8dc79e36b29395413399edaec3e20fcca7205fb19776ed8ddb25d6f427ec40e": "0x68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde780f0000c16ff286230f0000c16ff286230000",
+        "0x426e15054d267946093858132eb537f105fe52c2045750c3c492ccdcf62e2b9c": "0x9ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+        "0x5f3e4907f716ac89b6347d15ececedca487df464e44a534ba6b0cbb32407b587": "0x0000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e169037441588f5c9a91b3f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663": "0x00",
+        "0x492a52699edf49c972c21db794cfcf57ba7fb8745735dc3be2a2c61a72c39e78": "0x00"
+      },
+      "childrenDefault": {}
+    }
+  }
+}
diff --git a/substrate/bin/node/cli/src/benchmarking.rs b/substrate/bin/node/cli/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..333f855f2d7bb876d7768784b60dfa21e1d8d708
--- /dev/null
+++ b/substrate/bin/node/cli/src/benchmarking.rs
@@ -0,0 +1,122 @@
+// 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/>.
+
+//! Setup code for [`super::command`] which would otherwise bloat that module.
+//!
+//! Should only be used for benchmarking as it may break in other contexts.
+
+use crate::service::{create_extrinsic, FullClient};
+
+use kitchensink_runtime::{BalancesCall, SystemCall};
+use node_primitives::{AccountId, Balance};
+use sc_cli::Result;
+use sp_inherents::{InherentData, InherentDataProvider};
+use sp_keyring::Sr25519Keyring;
+use sp_runtime::OpaqueExtrinsic;
+
+use std::{sync::Arc, time::Duration};
+
+/// Generates `System::Remark` extrinsics for the benchmarks.
+///
+/// Note: Should only be used for benchmarking.
+pub struct RemarkBuilder {
+	client: Arc<FullClient>,
+}
+
+impl RemarkBuilder {
+	/// Creates a new [`Self`] from the given client.
+	pub fn new(client: Arc<FullClient>) -> Self {
+		Self { client }
+	}
+}
+
+impl frame_benchmarking_cli::ExtrinsicBuilder for RemarkBuilder {
+	fn pallet(&self) -> &str {
+		"system"
+	}
+
+	fn extrinsic(&self) -> &str {
+		"remark"
+	}
+
+	fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
+		let acc = Sr25519Keyring::Bob.pair();
+		let extrinsic: OpaqueExtrinsic = create_extrinsic(
+			self.client.as_ref(),
+			acc,
+			SystemCall::remark { remark: vec![] },
+			Some(nonce),
+		)
+		.into();
+
+		Ok(extrinsic)
+	}
+}
+
+/// Generates `Balances::TransferKeepAlive` extrinsics for the benchmarks.
+///
+/// Note: Should only be used for benchmarking.
+pub struct TransferKeepAliveBuilder {
+	client: Arc<FullClient>,
+	dest: AccountId,
+	value: Balance,
+}
+
+impl TransferKeepAliveBuilder {
+	/// Creates a new [`Self`] from the given client.
+	pub fn new(client: Arc<FullClient>, dest: AccountId, value: Balance) -> Self {
+		Self { client, dest, value }
+	}
+}
+
+impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder {
+	fn pallet(&self) -> &str {
+		"balances"
+	}
+
+	fn extrinsic(&self) -> &str {
+		"transfer_keep_alive"
+	}
+
+	fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str> {
+		let acc = Sr25519Keyring::Bob.pair();
+		let extrinsic: OpaqueExtrinsic = create_extrinsic(
+			self.client.as_ref(),
+			acc,
+			BalancesCall::transfer_keep_alive {
+				dest: self.dest.clone().into(),
+				value: self.value.into(),
+			},
+			Some(nonce),
+		)
+		.into();
+
+		Ok(extrinsic)
+	}
+}
+
+/// Generates inherent data for the `benchmark overhead` command.
+pub fn inherent_benchmark_data() -> Result<InherentData> {
+	let mut inherent_data = InherentData::new();
+	let d = Duration::from_millis(0);
+	let timestamp = sp_timestamp::InherentDataProvider::new(d.into());
+
+	futures::executor::block_on(timestamp.provide_inherent_data(&mut inherent_data))
+		.map_err(|e| format!("creating inherent data: {:?}", e))?;
+	Ok(inherent_data)
+}
diff --git a/substrate/bin/node/cli/src/chain_spec.rs b/substrate/bin/node/cli/src/chain_spec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51beaad03688a7db72830094b821ad4f27276078
--- /dev/null
+++ b/substrate/bin/node/cli/src/chain_spec.rs
@@ -0,0 +1,503 @@
+// 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/>.
+
+//! Substrate chain configurations.
+
+use grandpa_primitives::AuthorityId as GrandpaId;
+use kitchensink_runtime::{
+	constants::currency::*, wasm_binary_unwrap, BabeConfig, BalancesConfig, Block, CouncilConfig,
+	DemocracyConfig, ElectionsConfig, ImOnlineConfig, IndicesConfig, MaxNominations,
+	NominationPoolsConfig, SessionConfig, SessionKeys, SocietyConfig, StakerStatus, StakingConfig,
+	SudoConfig, SystemConfig, TechnicalCommitteeConfig,
+};
+use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
+use sc_chain_spec::ChainSpecExtension;
+use sc_service::ChainType;
+use sc_telemetry::TelemetryEndpoints;
+use serde::{Deserialize, Serialize};
+use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
+use sp_consensus_babe::AuthorityId as BabeId;
+use sp_core::{crypto::UncheckedInto, sr25519, Pair, Public};
+use sp_runtime::{
+	traits::{IdentifyAccount, Verify},
+	Perbill,
+};
+
+pub use kitchensink_runtime::RuntimeGenesisConfig;
+pub use node_primitives::{AccountId, Balance, Signature};
+
+type AccountPublic = <Signature as Verify>::Signer;
+
+const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/";
+
+/// Node `ChainSpec` extensions.
+///
+/// Additional parameters for some Substrate core modules,
+/// customizable from the chain spec.
+#[derive(Default, Clone, Serialize, Deserialize, ChainSpecExtension)]
+#[serde(rename_all = "camelCase")]
+pub struct Extensions {
+	/// Block numbers with known hashes.
+	pub fork_blocks: sc_client_api::ForkBlocks<Block>,
+	/// Known bad block hashes.
+	pub bad_blocks: sc_client_api::BadBlocks<Block>,
+	/// The light sync state extension used by the sync-state rpc.
+	pub light_sync_state: sc_sync_state_rpc::LightSyncStateExtension,
+}
+
+/// Specialized `ChainSpec`.
+pub type ChainSpec = sc_service::GenericChainSpec<RuntimeGenesisConfig, Extensions>;
+/// Flaming Fir testnet generator
+pub fn flaming_fir_config() -> Result<ChainSpec, String> {
+	ChainSpec::from_json_bytes(&include_bytes!("../res/flaming-fir.json")[..])
+}
+
+fn session_keys(
+	grandpa: GrandpaId,
+	babe: BabeId,
+	im_online: ImOnlineId,
+	authority_discovery: AuthorityDiscoveryId,
+) -> SessionKeys {
+	SessionKeys { grandpa, babe, im_online, authority_discovery }
+}
+
+fn staging_testnet_config_genesis() -> RuntimeGenesisConfig {
+	#[rustfmt::skip]
+	// stash, controller, session-key
+	// generated with secret:
+	// for i in 1 2 3 4 ; do for j in stash controller; do subkey inspect "$secret"/fir/$j/$i; done; done
+	//
+	// and
+	//
+	// for i in 1 2 3 4 ; do for j in session; do subkey --ed25519 inspect "$secret"//fir//$j//$i; done; done
+
+	let initial_authorities: Vec<(
+		AccountId,
+		AccountId,
+		GrandpaId,
+		BabeId,
+		ImOnlineId,
+		AuthorityDiscoveryId,
+	)> = vec![
+		(
+			// 5Fbsd6WXDGiLTxunqeK5BATNiocfCqu9bS1yArVjCgeBLkVy
+			array_bytes::hex_n_into_unchecked("9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12"),
+			// 5EnCiV7wSHeNhjW3FSUwiJNkcc2SBkPLn5Nj93FmbLtBjQUq
+			array_bytes::hex_n_into_unchecked("781ead1e2fa9ccb74b44c19d29cb2a7a4b5be3972927ae98cd3877523976a276"),
+			// 5Fb9ayurnxnaXj56CjmyQLBiadfRCqUbL2VWNbbe1nZU6wiC
+			array_bytes::hex2array_unchecked("9becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe9699332")
+				.unchecked_into(),
+			// 5EZaeQ8djPcq9pheJUhgerXQZt9YaHnMJpiHMRhwQeinqUW8
+			array_bytes::hex2array_unchecked("6e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106")
+				.unchecked_into(),
+			// 5EZaeQ8djPcq9pheJUhgerXQZt9YaHnMJpiHMRhwQeinqUW8
+			array_bytes::hex2array_unchecked("6e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106")
+				.unchecked_into(),
+			// 5EZaeQ8djPcq9pheJUhgerXQZt9YaHnMJpiHMRhwQeinqUW8
+			array_bytes::hex2array_unchecked("6e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106")
+				.unchecked_into(),
+		),
+		(
+			// 5ERawXCzCWkjVq3xz1W5KGNtVx2VdefvZ62Bw1FEuZW4Vny2
+			array_bytes::hex_n_into_unchecked("68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78"),
+			// 5Gc4vr42hH1uDZc93Nayk5G7i687bAQdHHc9unLuyeawHipF
+			array_bytes::hex_n_into_unchecked("c8dc79e36b29395413399edaec3e20fcca7205fb19776ed8ddb25d6f427ec40e"),
+			// 5EockCXN6YkiNCDjpqqnbcqd4ad35nU4RmA1ikM4YeRN4WcE
+			array_bytes::hex2array_unchecked("7932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f")
+				.unchecked_into(),
+			// 5DhLtiaQd1L1LU9jaNeeu9HJkP6eyg3BwXA7iNMzKm7qqruQ
+			array_bytes::hex2array_unchecked("482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e")
+				.unchecked_into(),
+			// 5DhLtiaQd1L1LU9jaNeeu9HJkP6eyg3BwXA7iNMzKm7qqruQ
+			array_bytes::hex2array_unchecked("482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e")
+				.unchecked_into(),
+			// 5DhLtiaQd1L1LU9jaNeeu9HJkP6eyg3BwXA7iNMzKm7qqruQ
+			array_bytes::hex2array_unchecked("482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e")
+				.unchecked_into(),
+		),
+		(
+			// 5DyVtKWPidondEu8iHZgi6Ffv9yrJJ1NDNLom3X9cTDi98qp
+			array_bytes::hex_n_into_unchecked("547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65"),
+			// 5FeD54vGVNpFX3PndHPXJ2MDakc462vBCD5mgtWRnWYCpZU9
+			array_bytes::hex_n_into_unchecked("9e42241d7cd91d001773b0b616d523dd80e13c6c2cab860b1234ef1b9ffc1526"),
+			// 5E1jLYfLdUQKrFrtqoKgFrRvxM3oQPMbf6DfcsrugZZ5Bn8d
+			array_bytes::hex2array_unchecked("5633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce440")
+				.unchecked_into(),
+			// 5DhKqkHRkndJu8vq7pi2Q5S3DfftWJHGxbEUNH43b46qNspH
+			array_bytes::hex2array_unchecked("482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a")
+				.unchecked_into(),
+			// 5DhKqkHRkndJu8vq7pi2Q5S3DfftWJHGxbEUNH43b46qNspH
+			array_bytes::hex2array_unchecked("482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a")
+				.unchecked_into(),
+			// 5DhKqkHRkndJu8vq7pi2Q5S3DfftWJHGxbEUNH43b46qNspH
+			array_bytes::hex2array_unchecked("482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a")
+				.unchecked_into(),
+		),
+		(
+			// 5HYZnKWe5FVZQ33ZRJK1rG3WaLMztxWrrNDb1JRwaHHVWyP9
+			array_bytes::hex_n_into_unchecked("f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663"),
+			// 5EPQdAQ39WQNLCRjWsCk5jErsCitHiY5ZmjfWzzbXDoAoYbn
+			array_bytes::hex_n_into_unchecked("66bc1e5d275da50b72b15de072a2468a5ad414919ca9054d2695767cf650012f"),
+			// 5DMa31Hd5u1dwoRKgC4uvqyrdK45RHv3CpwvpUC1EzuwDit4
+			array_bytes::hex2array_unchecked("3919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef")
+				.unchecked_into(),
+			// 5C4vDQxA8LTck2xJEy4Yg1hM9qjDt4LvTQaMo4Y8ne43aU6x
+			array_bytes::hex2array_unchecked("00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378")
+				.unchecked_into(),
+			// 5C4vDQxA8LTck2xJEy4Yg1hM9qjDt4LvTQaMo4Y8ne43aU6x
+			array_bytes::hex2array_unchecked("00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378")
+				.unchecked_into(),
+			// 5C4vDQxA8LTck2xJEy4Yg1hM9qjDt4LvTQaMo4Y8ne43aU6x
+			array_bytes::hex2array_unchecked("00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378")
+				.unchecked_into(),
+		),
+	];
+
+	// generated with secret: subkey inspect "$secret"/fir
+	let root_key: AccountId = array_bytes::hex_n_into_unchecked(
+		// 5Ff3iXP75ruzroPWRP2FYBHWnmGGBSb63857BgnzCoXNxfPo
+		"9ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809",
+	);
+
+	let endowed_accounts: Vec<AccountId> = vec![root_key.clone()];
+
+	testnet_genesis(initial_authorities, vec![], root_key, Some(endowed_accounts))
+}
+
+/// Staging testnet config.
+pub fn staging_testnet_config() -> ChainSpec {
+	let boot_nodes = vec![];
+	ChainSpec::from_genesis(
+		"Staging Testnet",
+		"staging_testnet",
+		ChainType::Live,
+		staging_testnet_config_genesis,
+		boot_nodes,
+		Some(
+			TelemetryEndpoints::new(vec![(STAGING_TELEMETRY_URL.to_string(), 0)])
+				.expect("Staging telemetry url is valid; qed"),
+		),
+		None,
+		None,
+		None,
+		Default::default(),
+	)
+}
+
+/// Helper function to generate a crypto pair from seed.
+pub fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+	TPublic::Pair::from_string(&format!("//{}", seed), None)
+		.expect("static values are valid; qed")
+		.public()
+}
+
+/// Helper function to generate an account ID from seed.
+pub fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
+where
+	AccountPublic: From<<TPublic::Pair as Pair>::Public>,
+{
+	AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
+}
+
+/// Helper function to generate stash, controller and session key from seed.
+pub fn authority_keys_from_seed(
+	seed: &str,
+) -> (AccountId, AccountId, GrandpaId, BabeId, ImOnlineId, AuthorityDiscoveryId) {
+	(
+		get_account_id_from_seed::<sr25519::Public>(&format!("{}//stash", seed)),
+		get_account_id_from_seed::<sr25519::Public>(seed),
+		get_from_seed::<GrandpaId>(seed),
+		get_from_seed::<BabeId>(seed),
+		get_from_seed::<ImOnlineId>(seed),
+		get_from_seed::<AuthorityDiscoveryId>(seed),
+	)
+}
+
+/// Helper function to create RuntimeGenesisConfig for testing.
+pub fn testnet_genesis(
+	initial_authorities: Vec<(
+		AccountId,
+		AccountId,
+		GrandpaId,
+		BabeId,
+		ImOnlineId,
+		AuthorityDiscoveryId,
+	)>,
+	initial_nominators: Vec<AccountId>,
+	root_key: AccountId,
+	endowed_accounts: Option<Vec<AccountId>>,
+) -> RuntimeGenesisConfig {
+	let mut endowed_accounts: Vec<AccountId> = endowed_accounts.unwrap_or_else(|| {
+		vec![
+			get_account_id_from_seed::<sr25519::Public>("Alice"),
+			get_account_id_from_seed::<sr25519::Public>("Bob"),
+			get_account_id_from_seed::<sr25519::Public>("Charlie"),
+			get_account_id_from_seed::<sr25519::Public>("Dave"),
+			get_account_id_from_seed::<sr25519::Public>("Eve"),
+			get_account_id_from_seed::<sr25519::Public>("Ferdie"),
+			get_account_id_from_seed::<sr25519::Public>("Alice//stash"),
+			get_account_id_from_seed::<sr25519::Public>("Bob//stash"),
+			get_account_id_from_seed::<sr25519::Public>("Charlie//stash"),
+			get_account_id_from_seed::<sr25519::Public>("Dave//stash"),
+			get_account_id_from_seed::<sr25519::Public>("Eve//stash"),
+			get_account_id_from_seed::<sr25519::Public>("Ferdie//stash"),
+		]
+	});
+	// endow all authorities and nominators.
+	initial_authorities
+		.iter()
+		.map(|x| &x.0)
+		.chain(initial_nominators.iter())
+		.for_each(|x| {
+			if !endowed_accounts.contains(x) {
+				endowed_accounts.push(x.clone())
+			}
+		});
+
+	// stakers: all validators and nominators.
+	let mut rng = rand::thread_rng();
+	let stakers = initial_authorities
+		.iter()
+		.map(|x| (x.0.clone(), x.0.clone(), STASH, StakerStatus::Validator))
+		.chain(initial_nominators.iter().map(|x| {
+			use rand::{seq::SliceRandom, Rng};
+			let limit = (MaxNominations::get() as usize).min(initial_authorities.len());
+			let count = rng.gen::<usize>() % limit;
+			let nominations = initial_authorities
+				.as_slice()
+				.choose_multiple(&mut rng, count)
+				.into_iter()
+				.map(|choice| choice.0.clone())
+				.collect::<Vec<_>>();
+			(x.clone(), x.clone(), STASH, StakerStatus::Nominator(nominations))
+		}))
+		.collect::<Vec<_>>();
+
+	let num_endowed_accounts = endowed_accounts.len();
+
+	const ENDOWMENT: Balance = 10_000_000 * DOLLARS;
+	const STASH: Balance = ENDOWMENT / 1000;
+
+	RuntimeGenesisConfig {
+		system: SystemConfig { code: wasm_binary_unwrap().to_vec(), ..Default::default() },
+		balances: BalancesConfig {
+			balances: endowed_accounts.iter().cloned().map(|x| (x, ENDOWMENT)).collect(),
+		},
+		indices: IndicesConfig { indices: vec![] },
+		session: SessionConfig {
+			keys: initial_authorities
+				.iter()
+				.map(|x| {
+					(
+						x.0.clone(),
+						x.0.clone(),
+						session_keys(x.2.clone(), x.3.clone(), x.4.clone(), x.5.clone()),
+					)
+				})
+				.collect::<Vec<_>>(),
+		},
+		staking: StakingConfig {
+			validator_count: initial_authorities.len() as u32,
+			minimum_validator_count: initial_authorities.len() as u32,
+			invulnerables: initial_authorities.iter().map(|x| x.0.clone()).collect(),
+			slash_reward_fraction: Perbill::from_percent(10),
+			stakers,
+			..Default::default()
+		},
+		democracy: DemocracyConfig::default(),
+		elections: ElectionsConfig {
+			members: endowed_accounts
+				.iter()
+				.take((num_endowed_accounts + 1) / 2)
+				.cloned()
+				.map(|member| (member, STASH))
+				.collect(),
+		},
+		council: CouncilConfig::default(),
+		technical_committee: TechnicalCommitteeConfig {
+			members: endowed_accounts
+				.iter()
+				.take((num_endowed_accounts + 1) / 2)
+				.cloned()
+				.collect(),
+			phantom: Default::default(),
+		},
+		sudo: SudoConfig { key: Some(root_key) },
+		babe: BabeConfig {
+			epoch_config: Some(kitchensink_runtime::BABE_GENESIS_EPOCH_CONFIG),
+			..Default::default()
+		},
+		im_online: ImOnlineConfig { keys: vec![] },
+		authority_discovery: Default::default(),
+		grandpa: Default::default(),
+		technical_membership: Default::default(),
+		treasury: Default::default(),
+		society: SocietyConfig { pot: 0 },
+		vesting: Default::default(),
+		assets: pallet_assets::GenesisConfig {
+			// This asset is used by the NIS pallet as counterpart currency.
+			assets: vec![(9, get_account_id_from_seed::<sr25519::Public>("Alice"), true, 1)],
+			..Default::default()
+		},
+		pool_assets: Default::default(),
+		transaction_storage: Default::default(),
+		transaction_payment: Default::default(),
+		alliance: Default::default(),
+		safe_mode: Default::default(),
+		tx_pause: Default::default(),
+		alliance_motion: Default::default(),
+		nomination_pools: NominationPoolsConfig {
+			min_create_bond: 10 * DOLLARS,
+			min_join_bond: 1 * DOLLARS,
+			..Default::default()
+		},
+		glutton: Default::default(),
+	}
+}
+
+fn development_config_genesis() -> RuntimeGenesisConfig {
+	testnet_genesis(
+		vec![authority_keys_from_seed("Alice")],
+		vec![],
+		get_account_id_from_seed::<sr25519::Public>("Alice"),
+		None,
+	)
+}
+
+/// Development config (single validator Alice).
+pub fn development_config() -> ChainSpec {
+	ChainSpec::from_genesis(
+		"Development",
+		"dev",
+		ChainType::Development,
+		development_config_genesis,
+		vec![],
+		None,
+		None,
+		None,
+		None,
+		Default::default(),
+	)
+}
+
+fn local_testnet_genesis() -> RuntimeGenesisConfig {
+	testnet_genesis(
+		vec![authority_keys_from_seed("Alice"), authority_keys_from_seed("Bob")],
+		vec![],
+		get_account_id_from_seed::<sr25519::Public>("Alice"),
+		None,
+	)
+}
+
+/// Local testnet config (multivalidator Alice + Bob).
+pub fn local_testnet_config() -> ChainSpec {
+	ChainSpec::from_genesis(
+		"Local Testnet",
+		"local_testnet",
+		ChainType::Local,
+		local_testnet_genesis,
+		vec![],
+		None,
+		None,
+		None,
+		None,
+		Default::default(),
+	)
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+	use crate::service::{new_full_base, NewFullBase};
+	use sc_service_test;
+	use sp_runtime::BuildStorage;
+
+	fn local_testnet_genesis_instant_single() -> RuntimeGenesisConfig {
+		testnet_genesis(
+			vec![authority_keys_from_seed("Alice")],
+			vec![],
+			get_account_id_from_seed::<sr25519::Public>("Alice"),
+			None,
+		)
+	}
+
+	/// Local testnet config (single validator - Alice).
+	pub fn integration_test_config_with_single_authority() -> ChainSpec {
+		ChainSpec::from_genesis(
+			"Integration Test",
+			"test",
+			ChainType::Development,
+			local_testnet_genesis_instant_single,
+			vec![],
+			None,
+			None,
+			None,
+			None,
+			Default::default(),
+		)
+	}
+
+	/// Local testnet config (multivalidator Alice + Bob).
+	pub fn integration_test_config_with_two_authorities() -> ChainSpec {
+		ChainSpec::from_genesis(
+			"Integration Test",
+			"test",
+			ChainType::Development,
+			local_testnet_genesis,
+			vec![],
+			None,
+			None,
+			None,
+			None,
+			Default::default(),
+		)
+	}
+
+	#[test]
+	#[ignore]
+	fn test_connectivity() {
+		sp_tracing::try_init_simple();
+
+		sc_service_test::connectivity(integration_test_config_with_two_authorities(), |config| {
+			let NewFullBase { task_manager, client, network, sync, transaction_pool, .. } =
+				new_full_base(config, false, |_, _| ())?;
+			Ok(sc_service_test::TestNetComponents::new(
+				task_manager,
+				client,
+				network,
+				sync,
+				transaction_pool,
+			))
+		});
+	}
+
+	#[test]
+	fn test_create_development_chain_spec() {
+		development_config().build_storage().unwrap();
+	}
+
+	#[test]
+	fn test_create_local_testnet_chain_spec() {
+		local_testnet_config().build_storage().unwrap();
+	}
+
+	#[test]
+	fn test_staging_test_net_chain_spec() {
+		staging_testnet_config().build_storage().unwrap();
+	}
+}
diff --git a/substrate/bin/node/cli/src/cli.rs b/substrate/bin/node/cli/src/cli.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e0d6303870cba960ee42f77ed105c1021cbb380
--- /dev/null
+++ b/substrate/bin/node/cli/src/cli.rs
@@ -0,0 +1,101 @@
+// 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/>.
+
+/// An overarching CLI command definition.
+#[derive(Debug, clap::Parser)]
+pub struct Cli {
+	/// Possible subcommand with parameters.
+	#[command(subcommand)]
+	pub subcommand: Option<Subcommand>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub run: sc_cli::RunCmd,
+
+	/// Disable automatic hardware benchmarks.
+	///
+	/// By default these benchmarks are automatically ran at startup and measure
+	/// the CPU speed, the memory bandwidth and the disk speed.
+	///
+	/// The results are then printed out in the logs, and also sent as part of
+	/// telemetry, if telemetry is enabled.
+	#[arg(long)]
+	pub no_hardware_benchmarks: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub storage_monitor: sc_storage_monitor::StorageMonitorParams,
+}
+
+/// Possible subcommands of the main binary.
+#[derive(Debug, clap::Subcommand)]
+pub enum Subcommand {
+	/// The custom inspect subcommmand for decoding blocks and extrinsics.
+	#[command(
+		name = "inspect",
+		about = "Decode given block or extrinsic using current native runtime."
+	)]
+	Inspect(node_inspect::cli::InspectCmd),
+
+	/// Sub-commands concerned with benchmarking.
+	/// The pallet benchmarking moved to the `pallet` sub-command.
+	#[command(subcommand)]
+	Benchmark(frame_benchmarking_cli::BenchmarkCmd),
+
+	/// Try-runtime has migrated to a standalone CLI
+	/// (<https://github.com/paritytech/try-runtime-cli>). The subcommand exists as a stub and
+	/// deprecation notice. It will be removed entirely some time after Janurary 2024.
+	TryRuntime,
+
+	/// Key management cli utilities
+	#[command(subcommand)]
+	Key(sc_cli::KeySubcommand),
+
+	/// Verify a signature for a message, provided on STDIN, with a given (public or secret) key.
+	Verify(sc_cli::VerifyCmd),
+
+	/// Generate a seed that provides a vanity address.
+	Vanity(sc_cli::VanityCmd),
+
+	/// Sign a message, with a given (secret) key.
+	Sign(sc_cli::SignCmd),
+
+	/// Build a chain specification.
+	BuildSpec(sc_cli::BuildSpecCmd),
+
+	/// Validate blocks.
+	CheckBlock(sc_cli::CheckBlockCmd),
+
+	/// Export blocks.
+	ExportBlocks(sc_cli::ExportBlocksCmd),
+
+	/// Export the state of a given block into a chain spec.
+	ExportState(sc_cli::ExportStateCmd),
+
+	/// Import blocks.
+	ImportBlocks(sc_cli::ImportBlocksCmd),
+
+	/// Remove the whole chain.
+	PurgeChain(sc_cli::PurgeChainCmd),
+
+	/// Revert the chain to a previous state.
+	Revert(sc_cli::RevertCmd),
+
+	/// Db meta columns information.
+	ChainInfo(sc_cli::ChainInfoCmd),
+}
diff --git a/substrate/bin/node/cli/src/command.rs b/substrate/bin/node/cli/src/command.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8fb413dba17780fd17a07bc47bc722ab833d98c2
--- /dev/null
+++ b/substrate/bin/node/cli/src/command.rs
@@ -0,0 +1,234 @@
+// 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::benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder};
+use crate::{
+	chain_spec, service,
+	service::{new_partial, FullClient},
+	Cli, Subcommand,
+};
+use frame_benchmarking_cli::*;
+use kitchensink_runtime::{ExistentialDeposit, RuntimeApi};
+use node_executor::ExecutorDispatch;
+use node_primitives::Block;
+use sc_cli::{Result, SubstrateCli};
+use sc_service::PartialComponents;
+use sp_keyring::Sr25519Keyring;
+
+use std::sync::Arc;
+
+impl SubstrateCli for Cli {
+	fn impl_name() -> String {
+		"Substrate Node".into()
+	}
+
+	fn impl_version() -> String {
+		env!("SUBSTRATE_CLI_IMPL_VERSION").into()
+	}
+
+	fn description() -> String {
+		env!("CARGO_PKG_DESCRIPTION").into()
+	}
+
+	fn author() -> String {
+		env!("CARGO_PKG_AUTHORS").into()
+	}
+
+	fn support_url() -> String {
+		"https://github.com/paritytech/substrate/issues/new".into()
+	}
+
+	fn copyright_start_year() -> i32 {
+		2017
+	}
+
+	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
+		let spec = match id {
+			"" =>
+				return Err(
+					"Please specify which chain you want to run, e.g. --dev or --chain=local"
+						.into(),
+				),
+			"dev" => Box::new(chain_spec::development_config()),
+			"local" => Box::new(chain_spec::local_testnet_config()),
+			"fir" | "flaming-fir" => Box::new(chain_spec::flaming_fir_config()?),
+			"staging" => Box::new(chain_spec::staging_testnet_config()),
+			path =>
+				Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?),
+		};
+		Ok(spec)
+	}
+}
+
+/// Parse command line arguments into service configuration.
+pub fn run() -> Result<()> {
+	let cli = Cli::from_args();
+
+	match &cli.subcommand {
+		None => {
+			let runner = cli.create_runner(&cli.run)?;
+			runner.run_node_until_exit(|config| async move {
+				service::new_full(config, cli).map_err(sc_cli::Error::Service)
+			})
+		},
+		Some(Subcommand::Inspect(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+
+			runner.sync_run(|config| cmd.run::<Block, RuntimeApi, ExecutorDispatch>(config))
+		},
+		Some(Subcommand::Benchmark(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+
+			runner.sync_run(|config| {
+				// This switch needs to be in the client, since the client decides
+				// which sub-commands it wants to support.
+				match cmd {
+					BenchmarkCmd::Pallet(cmd) => {
+						if !cfg!(feature = "runtime-benchmarks") {
+							return Err(
+								"Runtime benchmarking wasn't enabled when building the node. \
+							You can enable it with `--features runtime-benchmarks`."
+									.into(),
+							)
+						}
+
+						cmd.run::<Block, sp_statement_store::runtime_api::HostFunctions>(config)
+					},
+					BenchmarkCmd::Block(cmd) => {
+						// ensure that we keep the task manager alive
+						let partial = new_partial(&config)?;
+						cmd.run(partial.client)
+					},
+					#[cfg(not(feature = "runtime-benchmarks"))]
+					BenchmarkCmd::Storage(_) => Err(
+						"Storage benchmarking can be enabled with `--features runtime-benchmarks`."
+							.into(),
+					),
+					#[cfg(feature = "runtime-benchmarks")]
+					BenchmarkCmd::Storage(cmd) => {
+						// ensure that we keep the task manager alive
+						let partial = new_partial(&config)?;
+						let db = partial.backend.expose_db();
+						let storage = partial.backend.expose_storage();
+
+						cmd.run(config, partial.client, db, storage)
+					},
+					BenchmarkCmd::Overhead(cmd) => {
+						// ensure that we keep the task manager alive
+						let partial = new_partial(&config)?;
+						let ext_builder = RemarkBuilder::new(partial.client.clone());
+
+						cmd.run(
+							config,
+							partial.client,
+							inherent_benchmark_data()?,
+							Vec::new(),
+							&ext_builder,
+						)
+					},
+					BenchmarkCmd::Extrinsic(cmd) => {
+						// ensure that we keep the task manager alive
+						let partial = service::new_partial(&config)?;
+						// Register the *Remark* and *TKA* builders.
+						let ext_factory = ExtrinsicFactory(vec![
+							Box::new(RemarkBuilder::new(partial.client.clone())),
+							Box::new(TransferKeepAliveBuilder::new(
+								partial.client.clone(),
+								Sr25519Keyring::Alice.to_account_id(),
+								ExistentialDeposit::get(),
+							)),
+						]);
+
+						cmd.run(
+							partial.client,
+							inherent_benchmark_data()?,
+							Vec::new(),
+							&ext_factory,
+						)
+					},
+					BenchmarkCmd::Machine(cmd) =>
+						cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone()),
+				}
+			})
+		},
+		Some(Subcommand::Key(cmd)) => cmd.run(&cli),
+		Some(Subcommand::Sign(cmd)) => cmd.run(),
+		Some(Subcommand::Verify(cmd)) => cmd.run(),
+		Some(Subcommand::Vanity(cmd)) => cmd.run(),
+		Some(Subcommand::BuildSpec(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
+		},
+		Some(Subcommand::CheckBlock(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, import_queue, .. } =
+					new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::ExportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, .. } = new_partial(&config)?;
+				Ok((cmd.run(client, config.database), task_manager))
+			})
+		},
+		Some(Subcommand::ExportState(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, .. } = new_partial(&config)?;
+				Ok((cmd.run(client, config.chain_spec), task_manager))
+			})
+		},
+		Some(Subcommand::ImportBlocks(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, import_queue, .. } =
+					new_partial(&config)?;
+				Ok((cmd.run(client, import_queue), task_manager))
+			})
+		},
+		Some(Subcommand::PurgeChain(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run(config.database))
+		},
+		Some(Subcommand::Revert(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.async_run(|config| {
+				let PartialComponents { client, task_manager, backend, .. } = new_partial(&config)?;
+				let aux_revert = Box::new(|client: Arc<FullClient>, backend, blocks| {
+					sc_consensus_babe::revert(client.clone(), backend, blocks)?;
+					grandpa::revert(client, blocks)?;
+					Ok(())
+				});
+				Ok((cmd.run(client, backend, Some(aux_revert)), task_manager))
+			})
+		},
+		#[cfg(feature = "try-runtime")]
+		Some(Subcommand::TryRuntime) => Err(try_runtime_cli::DEPRECATION_NOTICE.into()),
+		#[cfg(not(feature = "try-runtime"))]
+		Some(Subcommand::TryRuntime) => Err("TryRuntime wasn't enabled when building the node. \
+				You can enable it with `--features try-runtime`."
+			.into()),
+		Some(Subcommand::ChainInfo(cmd)) => {
+			let runner = cli.create_runner(cmd)?;
+			runner.sync_run(|config| cmd.run::<Block>(&config))
+		},
+	}
+}
diff --git a/substrate/bin/node/cli/src/lib.rs b/substrate/bin/node/cli/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2fe238ef316e60a7544b0f828e53b228503df7e6
--- /dev/null
+++ b/substrate/bin/node/cli/src/lib.rs
@@ -0,0 +1,47 @@
+// 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/>.
+
+//! Substrate CLI library.
+//!
+//! This package has two Cargo features:
+//!
+//! - `cli` (default): exposes functions that parse command-line options, then start and run the
+//! node as a CLI application.
+//!
+//! - `browser`: exposes the content of the `browser` module, which consists of exported symbols
+//! that are meant to be passed through the `wasm-bindgen` utility and called from JavaScript.
+//! Despite its name the produced WASM can theoretically also be used from NodeJS, although this
+//! hasn't been tested.
+
+#![warn(missing_docs)]
+
+pub mod chain_spec;
+
+#[macro_use]
+pub mod service;
+#[cfg(feature = "cli")]
+mod benchmarking;
+#[cfg(feature = "cli")]
+mod cli;
+#[cfg(feature = "cli")]
+mod command;
+
+#[cfg(feature = "cli")]
+pub use cli::*;
+#[cfg(feature = "cli")]
+pub use command::*;
diff --git a/substrate/bin/node/cli/src/service.rs b/substrate/bin/node/cli/src/service.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ecca5c60db5156bbda32e012ed607db74e2d9fec
--- /dev/null
+++ b/substrate/bin/node/cli/src/service.rs
@@ -0,0 +1,891 @@
+// 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/>.
+
+#![warn(unused_extern_crates)]
+
+//! Service implementation. Specialized wrapper over substrate service.
+
+use crate::Cli;
+use codec::Encode;
+use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE;
+use frame_system_rpc_runtime_api::AccountNonceApi;
+use futures::prelude::*;
+use kitchensink_runtime::RuntimeApi;
+use node_executor::ExecutorDispatch;
+use node_primitives::Block;
+use sc_client_api::{Backend, BlockBackend};
+use sc_consensus_babe::{self, SlotProportion};
+use sc_executor::NativeElseWasmExecutor;
+use sc_network::{event::Event, NetworkEventStream, NetworkService};
+use sc_network_common::sync::warp::WarpSyncParams;
+use sc_network_sync::SyncingService;
+use sc_service::{config::Configuration, error::Error as ServiceError, RpcHandlers, TaskManager};
+use sc_statement_store::Store as StatementStore;
+use sc_telemetry::{Telemetry, TelemetryWorker};
+use sc_transaction_pool_api::OffchainTransactionPoolFactory;
+use sp_api::ProvideRuntimeApi;
+use sp_core::crypto::Pair;
+use sp_runtime::{generic, traits::Block as BlockT, SaturatedConversion};
+use std::sync::Arc;
+
+/// The full client type definition.
+pub type FullClient =
+	sc_service::TFullClient<Block, RuntimeApi, NativeElseWasmExecutor<ExecutorDispatch>>;
+type FullBackend = sc_service::TFullBackend<Block>;
+type FullSelectChain = sc_consensus::LongestChain<FullBackend, Block>;
+type FullGrandpaBlockImport =
+	grandpa::GrandpaBlockImport<FullBackend, Block, FullClient, FullSelectChain>;
+
+/// The transaction pool type definition.
+pub type TransactionPool = sc_transaction_pool::FullPool<Block, FullClient>;
+
+/// The minimum period of blocks on which justifications will be
+/// imported and generated.
+const GRANDPA_JUSTIFICATION_PERIOD: u32 = 512;
+
+/// Fetch the nonce of the given `account` from the chain state.
+///
+/// Note: Should only be used for tests.
+pub fn fetch_nonce(client: &FullClient, account: sp_core::sr25519::Pair) -> u32 {
+	let best_hash = client.chain_info().best_hash;
+	client
+		.runtime_api()
+		.account_nonce(best_hash, account.public().into())
+		.expect("Fetching account nonce works; qed")
+}
+
+/// Create a transaction using the given `call`.
+///
+/// The transaction will be signed by `sender`. If `nonce` is `None` it will be fetched from the
+/// state of the best block.
+///
+/// Note: Should only be used for tests.
+pub fn create_extrinsic(
+	client: &FullClient,
+	sender: sp_core::sr25519::Pair,
+	function: impl Into<kitchensink_runtime::RuntimeCall>,
+	nonce: Option<u32>,
+) -> kitchensink_runtime::UncheckedExtrinsic {
+	let function = function.into();
+	let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
+	let best_hash = client.chain_info().best_hash;
+	let best_block = client.chain_info().best_number;
+	let nonce = nonce.unwrap_or_else(|| fetch_nonce(client, sender.clone()));
+
+	let period = kitchensink_runtime::BlockHashCount::get()
+		.checked_next_power_of_two()
+		.map(|c| c / 2)
+		.unwrap_or(2) as u64;
+	let tip = 0;
+	let extra: kitchensink_runtime::SignedExtra = (
+		frame_system::CheckNonZeroSender::<kitchensink_runtime::Runtime>::new(),
+		frame_system::CheckSpecVersion::<kitchensink_runtime::Runtime>::new(),
+		frame_system::CheckTxVersion::<kitchensink_runtime::Runtime>::new(),
+		frame_system::CheckGenesis::<kitchensink_runtime::Runtime>::new(),
+		frame_system::CheckEra::<kitchensink_runtime::Runtime>::from(generic::Era::mortal(
+			period,
+			best_block.saturated_into(),
+		)),
+		frame_system::CheckNonce::<kitchensink_runtime::Runtime>::from(nonce),
+		frame_system::CheckWeight::<kitchensink_runtime::Runtime>::new(),
+		pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::<kitchensink_runtime::Runtime>::from(
+			tip, None,
+		),
+	);
+
+	let raw_payload = kitchensink_runtime::SignedPayload::from_raw(
+		function.clone(),
+		extra.clone(),
+		(
+			(),
+			kitchensink_runtime::VERSION.spec_version,
+			kitchensink_runtime::VERSION.transaction_version,
+			genesis_hash,
+			best_hash,
+			(),
+			(),
+			(),
+		),
+	);
+	let signature = raw_payload.using_encoded(|e| sender.sign(e));
+
+	kitchensink_runtime::UncheckedExtrinsic::new_signed(
+		function,
+		sp_runtime::AccountId32::from(sender.public()).into(),
+		kitchensink_runtime::Signature::Sr25519(signature),
+		extra,
+	)
+}
+
+/// Creates a new partial node.
+pub fn new_partial(
+	config: &Configuration,
+) -> Result<
+	sc_service::PartialComponents<
+		FullClient,
+		FullBackend,
+		FullSelectChain,
+		sc_consensus::DefaultImportQueue<Block>,
+		sc_transaction_pool::FullPool<Block, FullClient>,
+		(
+			impl Fn(
+				node_rpc::DenyUnsafe,
+				sc_rpc::SubscriptionTaskExecutor,
+			) -> Result<jsonrpsee::RpcModule<()>, sc_service::Error>,
+			(
+				sc_consensus_babe::BabeBlockImport<Block, FullClient, FullGrandpaBlockImport>,
+				grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+				sc_consensus_babe::BabeLink<Block>,
+			),
+			grandpa::SharedVoterState,
+			Option<Telemetry>,
+			Arc<StatementStore>,
+		),
+	>,
+	ServiceError,
+> {
+	let telemetry = config
+		.telemetry_endpoints
+		.clone()
+		.filter(|x| !x.is_empty())
+		.map(|endpoints| -> Result<_, sc_telemetry::Error> {
+			let worker = TelemetryWorker::new(16)?;
+			let telemetry = worker.handle().new_telemetry(endpoints);
+			Ok((worker, telemetry))
+		})
+		.transpose()?;
+
+	let executor = sc_service::new_native_or_wasm_executor(&config);
+
+	let (client, backend, keystore_container, task_manager) =
+		sc_service::new_full_parts::<Block, RuntimeApi, _>(
+			config,
+			telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
+			executor,
+		)?;
+	let client = Arc::new(client);
+
+	let telemetry = telemetry.map(|(worker, telemetry)| {
+		task_manager.spawn_handle().spawn("telemetry", None, worker.run());
+		telemetry
+	});
+
+	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+	let transaction_pool = sc_transaction_pool::BasicPool::new_full(
+		config.transaction_pool.clone(),
+		config.role.is_authority().into(),
+		config.prometheus_registry(),
+		task_manager.spawn_essential_handle(),
+		client.clone(),
+	);
+
+	let (grandpa_block_import, grandpa_link) = grandpa::block_import(
+		client.clone(),
+		GRANDPA_JUSTIFICATION_PERIOD,
+		&(client.clone() as Arc<_>),
+		select_chain.clone(),
+		telemetry.as_ref().map(|x| x.handle()),
+	)?;
+	let justification_import = grandpa_block_import.clone();
+
+	let (block_import, babe_link) = sc_consensus_babe::block_import(
+		sc_consensus_babe::configuration(&*client)?,
+		grandpa_block_import,
+		client.clone(),
+	)?;
+
+	let slot_duration = babe_link.config().slot_duration();
+	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 =
+				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()),
+		})?;
+
+	let import_setup = (block_import, grandpa_link, babe_link);
+
+	let statement_store = sc_statement_store::Store::new_shared(
+		&config.data_path,
+		Default::default(),
+		client.clone(),
+		keystore_container.local_keystore(),
+		config.prometheus_registry(),
+		&task_manager.spawn_handle(),
+	)
+	.map_err(|e| ServiceError::Other(format!("Statement store error: {:?}", e)))?;
+
+	let (rpc_extensions_builder, rpc_setup) = {
+		let (_, grandpa_link, _) = &import_setup;
+
+		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_state2 = shared_voter_state.clone();
+
+		let finality_proof_provider = grandpa::FinalityProofProvider::new_for_service(
+			backend.clone(),
+			Some(shared_authority_set.clone()),
+		);
+
+		let client = client.clone();
+		let pool = transaction_pool.clone();
+		let select_chain = select_chain.clone();
+		let keystore = keystore_container.keystore();
+		let chain_spec = config.chain_spec.cloned_box();
+
+		let rpc_backend = backend.clone();
+		let rpc_statement_store = statement_store.clone();
+		let rpc_extensions_builder = move |deny_unsafe, subscription_executor| {
+			let deps = node_rpc::FullDeps {
+				client: client.clone(),
+				pool: pool.clone(),
+				select_chain: select_chain.clone(),
+				chain_spec: chain_spec.cloned_box(),
+				deny_unsafe,
+				babe: node_rpc::BabeDeps {
+					keystore: keystore.clone(),
+					babe_worker_handle: babe_worker_handle.clone(),
+				},
+				grandpa: node_rpc::GrandpaDeps {
+					shared_voter_state: shared_voter_state.clone(),
+					shared_authority_set: shared_authority_set.clone(),
+					justification_stream: justification_stream.clone(),
+					subscription_executor,
+					finality_provider: finality_proof_provider.clone(),
+				},
+				statement_store: rpc_statement_store.clone(),
+				backend: rpc_backend.clone(),
+			};
+
+			node_rpc::create_full(deps).map_err(Into::into)
+		};
+
+		(rpc_extensions_builder, shared_voter_state2)
+	};
+
+	Ok(sc_service::PartialComponents {
+		client,
+		backend,
+		task_manager,
+		keystore_container,
+		select_chain,
+		import_queue,
+		transaction_pool,
+		other: (rpc_extensions_builder, import_setup, rpc_setup, telemetry, statement_store),
+	})
+}
+
+/// Result of [`new_full_base`].
+pub struct NewFullBase {
+	/// The task manager of the node.
+	pub task_manager: TaskManager,
+	/// The client instance of the node.
+	pub client: Arc<FullClient>,
+	/// The networking service of the node.
+	pub network: Arc<NetworkService<Block, <Block as BlockT>::Hash>>,
+	/// The syncing service of the node.
+	pub sync: Arc<SyncingService<Block>>,
+	/// The transaction pool of the node.
+	pub transaction_pool: Arc<TransactionPool>,
+	/// The rpc handlers of the node.
+	pub rpc_handlers: RpcHandlers,
+}
+
+/// Creates a full service from the configuration.
+pub fn new_full_base(
+	config: Configuration,
+	disable_hardware_benchmarks: bool,
+	with_startup_data: impl FnOnce(
+		&sc_consensus_babe::BabeBlockImport<Block, FullClient, FullGrandpaBlockImport>,
+		&sc_consensus_babe::BabeLink<Block>,
+	),
+) -> Result<NewFullBase, ServiceError> {
+	let hwbench = (!disable_hardware_benchmarks)
+		.then_some(config.database.path().map(|database_path| {
+			let _ = std::fs::create_dir_all(&database_path);
+			sc_sysinfo::gather_hwbench(Some(database_path))
+		}))
+		.flatten();
+
+	let sc_service::PartialComponents {
+		client,
+		backend,
+		mut task_manager,
+		import_queue,
+		keystore_container,
+		select_chain,
+		transaction_pool,
+		other: (rpc_builder, import_setup, rpc_setup, mut telemetry, statement_store),
+	} = new_partial(&config)?;
+
+	let shared_voter_state = rpc_setup;
+	let auth_disc_publish_non_global_ips = config.network.allow_non_globals_in_dht;
+	let mut net_config = sc_network::config::FullNetworkConfiguration::new(&config.network);
+
+	let grandpa_protocol_name = grandpa::protocol_standard_name(
+		&client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"),
+		&config.chain_spec,
+	);
+	net_config.add_notification_protocol(grandpa::grandpa_peers_set_config(
+		grandpa_protocol_name.clone(),
+	));
+
+	let statement_handler_proto = sc_network_statement::StatementHandlerPrototype::new(
+		client
+			.block_hash(0u32.into())
+			.ok()
+			.flatten()
+			.expect("Genesis block exists; qed"),
+		config.chain_spec.fork_id(),
+	);
+	net_config.add_notification_protocol(statement_handler_proto.set_config());
+
+	let warp_sync = Arc::new(grandpa::warp_proof::NetworkProvider::new(
+		backend.clone(),
+		import_setup.1.shared_authority_set().clone(),
+		Vec::default(),
+	));
+
+	let (network, system_rpc_tx, tx_handler_controller, network_starter, sync_service) =
+		sc_service::build_network(sc_service::BuildNetworkParams {
+			config: &config,
+			net_config,
+			client: client.clone(),
+			transaction_pool: transaction_pool.clone(),
+			spawn_handle: task_manager.spawn_handle(),
+			import_queue,
+			block_announce_validator_builder: None,
+			warp_sync_params: Some(WarpSyncParams::WithProvider(warp_sync)),
+		})?;
+
+	let role = config.role.clone();
+	let force_authoring = config.force_authoring;
+	let backoff_authoring_blocks =
+		Some(sc_consensus_slots::BackoffAuthoringOnFinalizedHeadLagging::default());
+	let name = config.network.node_name.clone();
+	let enable_grandpa = !config.disable_grandpa;
+	let prometheus_registry = config.prometheus_registry().cloned();
+	let enable_offchain_worker = config.offchain_worker.enabled;
+
+	let rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+		config,
+		backend: backend.clone(),
+		client: client.clone(),
+		keystore: keystore_container.keystore(),
+		network: network.clone(),
+		rpc_builder: Box::new(rpc_builder),
+		transaction_pool: transaction_pool.clone(),
+		task_manager: &mut task_manager,
+		system_rpc_tx,
+		tx_handler_controller,
+		sync_service: sync_service.clone(),
+		telemetry: telemetry.as_mut(),
+	})?;
+
+	if let Some(hwbench) = hwbench {
+		sc_sysinfo::print_hwbench(&hwbench);
+		if !SUBSTRATE_REFERENCE_HARDWARE.check_hardware(&hwbench) && role.is_authority() {
+			log::warn!(
+				"⚠�  The hardware does not meet the minimal requirements for role 'Authority'."
+			);
+		}
+
+		if let Some(ref mut telemetry) = telemetry {
+			let telemetry_handle = telemetry.handle();
+			task_manager.spawn_handle().spawn(
+				"telemetry_hwbench",
+				None,
+				sc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench),
+			);
+		}
+	}
+
+	let (block_import, grandpa_link, babe_link) = import_setup;
+
+	(with_startup_data)(&block_import, &babe_link);
+
+	if let sc_service::config::Role::Authority { .. } = &role {
+		let proposer = sc_basic_authorship::ProposerFactory::new(
+			task_manager.spawn_handle(),
+			client.clone(),
+			transaction_pool.clone(),
+			prometheus_registry.as_ref(),
+			telemetry.as_ref().map(|x| x.handle()),
+		);
+
+		let client_clone = client.clone();
+		let slot_duration = babe_link.config().slot_duration();
+		let babe_config = sc_consensus_babe::BabeParams {
+			keystore: keystore_container.keystore(),
+			client: client.clone(),
+			select_chain,
+			env: proposer,
+			block_import,
+			sync_oracle: sync_service.clone(),
+			justification_sync_link: sync_service.clone(),
+			create_inherent_data_providers: move |parent, ()| {
+				let client_clone = client_clone.clone();
+				async move {
+					let timestamp = sp_timestamp::InherentDataProvider::from_system_time();
+
+					let slot =
+						sp_consensus_babe::inherents::InherentDataProvider::from_timestamp_and_slot_duration(
+							*timestamp,
+							slot_duration,
+						);
+
+					let storage_proof =
+						sp_transaction_storage_proof::registration::new_data_provider(
+							&*client_clone,
+							&parent,
+						)?;
+
+					Ok((slot, timestamp, storage_proof))
+				}
+			},
+			force_authoring,
+			backoff_authoring_blocks,
+			babe_link,
+			block_proposal_slot_portion: SlotProportion::new(0.5),
+			max_block_proposal_slot_portion: None,
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+		};
+
+		let babe = sc_consensus_babe::start_babe(babe_config)?;
+		task_manager.spawn_essential_handle().spawn_blocking(
+			"babe-proposer",
+			Some("block-authoring"),
+			babe,
+		);
+	}
+
+	// Spawn authority discovery module.
+	if role.is_authority() {
+		let authority_discovery_role =
+			sc_authority_discovery::Role::PublishAndDiscover(keystore_container.keystore());
+		let dht_event_stream =
+			network.event_stream("authority-discovery").filter_map(|e| async move {
+				match e {
+					Event::Dht(e) => Some(e),
+					_ => None,
+				}
+			});
+		let (authority_discovery_worker, _service) =
+			sc_authority_discovery::new_worker_and_service_with_config(
+				sc_authority_discovery::WorkerConfig {
+					publish_non_global_ips: auth_disc_publish_non_global_ips,
+					..Default::default()
+				},
+				client.clone(),
+				network.clone(),
+				Box::pin(dht_event_stream),
+				authority_discovery_role,
+				prometheus_registry.clone(),
+			);
+
+		task_manager.spawn_handle().spawn(
+			"authority-discovery-worker",
+			Some("networking"),
+			authority_discovery_worker.run(),
+		);
+	}
+
+	// if the node isn't actively participating in consensus then it doesn't
+	// need a keystore, regardless of which protocol we use below.
+	let keystore = if role.is_authority() { Some(keystore_container.keystore()) } else { None };
+
+	let grandpa_config = grandpa::Config {
+		// FIXME #1578 make this available through chainspec
+		gossip_duration: std::time::Duration::from_millis(333),
+		justification_generation_period: GRANDPA_JUSTIFICATION_PERIOD,
+		name: Some(name),
+		observer_enabled: false,
+		keystore,
+		local_role: role.clone(),
+		telemetry: telemetry.as_ref().map(|x| x.handle()),
+		protocol_name: grandpa_protocol_name,
+	};
+
+	if enable_grandpa {
+		// start the full GRANDPA voter
+		// NOTE: non-authorities could run the GRANDPA observer protocol, but at
+		// this point the full voter should provide better guarantees of block
+		// and vote data availability than the observer. The observer has not
+		// been tested extensively yet and having most nodes in a network run it
+		// could lead to finality stalls.
+		let grandpa_config = grandpa::GrandpaParams {
+			config: grandpa_config,
+			link: grandpa_link,
+			network: network.clone(),
+			sync: Arc::new(sync_service.clone()),
+			telemetry: telemetry.as_ref().map(|x| x.handle()),
+			voting_rule: grandpa::VotingRulesBuilder::default().build(),
+			prometheus_registry: prometheus_registry.clone(),
+			shared_voter_state,
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool.clone()),
+		};
+
+		// the GRANDPA voter task is considered infallible, i.e.
+		// if it fails we take down the service with it.
+		task_manager.spawn_essential_handle().spawn_blocking(
+			"grandpa-voter",
+			None,
+			grandpa::run_grandpa_voter(grandpa_config)?,
+		);
+	}
+
+	// Spawn statement protocol worker
+	let statement_protocol_executor = {
+		let spawn_handle = task_manager.spawn_handle();
+		Box::new(move |fut| {
+			spawn_handle.spawn("network-statement-validator", Some("networking"), fut);
+		})
+	};
+	let statement_handler = statement_handler_proto.build(
+		network.clone(),
+		sync_service.clone(),
+		statement_store.clone(),
+		prometheus_registry.as_ref(),
+		statement_protocol_executor,
+	)?;
+	task_manager.spawn_handle().spawn(
+		"network-statement-handler",
+		Some("networking"),
+		statement_handler.run(),
+	);
+
+	if enable_offchain_worker {
+		task_manager.spawn_handle().spawn(
+			"offchain-workers-runner",
+			"offchain-work",
+			sc_offchain::OffchainWorkers::new(sc_offchain::OffchainWorkerOptions {
+				runtime_api_provider: client.clone(),
+				keystore: Some(keystore_container.keystore()),
+				offchain_db: backend.offchain_storage(),
+				transaction_pool: Some(OffchainTransactionPoolFactory::new(
+					transaction_pool.clone(),
+				)),
+				network_provider: network.clone(),
+				is_validator: role.is_authority(),
+				enable_http_requests: true,
+				custom_extensions: move |_| {
+					vec![Box::new(statement_store.clone().as_statement_store_ext()) as Box<_>]
+				},
+			})
+			.run(client.clone(), task_manager.spawn_handle())
+			.boxed(),
+		);
+	}
+
+	network_starter.start_network();
+	Ok(NewFullBase {
+		task_manager,
+		client,
+		network,
+		sync: sync_service,
+		transaction_pool,
+		rpc_handlers,
+	})
+}
+
+/// Builds a new service for a full client.
+pub fn new_full(config: Configuration, cli: Cli) -> Result<TaskManager, ServiceError> {
+	let database_source = config.database.clone();
+	let task_manager = new_full_base(config, cli.no_hardware_benchmarks, |_, _| ())
+		.map(|NewFullBase { task_manager, .. }| task_manager)?;
+
+	sc_storage_monitor::StorageMonitorService::try_spawn(
+		cli.storage_monitor,
+		database_source,
+		&task_manager.spawn_essential_handle(),
+	)
+	.map_err(|e| ServiceError::Application(e.into()))?;
+
+	Ok(task_manager)
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::service::{new_full_base, NewFullBase};
+	use codec::Encode;
+	use kitchensink_runtime::{
+		constants::{currency::CENTS, time::SLOT_DURATION},
+		Address, BalancesCall, RuntimeCall, UncheckedExtrinsic,
+	};
+	use node_primitives::{Block, DigestItem, Signature};
+	use sc_client_api::BlockBackend;
+	use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy};
+	use sc_consensus_babe::{BabeIntermediate, CompatibleDigestItem, INTERMEDIATE_KEY};
+	use sc_consensus_epochs::descendent_query;
+	use sc_keystore::LocalKeystore;
+	use sc_service_test::TestNetNode;
+	use sc_transaction_pool_api::{ChainEvent, MaintainedTransactionPool};
+	use sp_consensus::{BlockOrigin, Environment, Proposer};
+	use sp_core::crypto::Pair;
+	use sp_inherents::InherentDataProvider;
+	use sp_keyring::AccountKeyring;
+	use sp_keystore::KeystorePtr;
+	use sp_runtime::{
+		generic::{Digest, Era, SignedPayload},
+		key_types::BABE,
+		traits::{Block as BlockT, Header as HeaderT, IdentifyAccount, Verify},
+		RuntimeAppPublic,
+	};
+	use sp_timestamp;
+	use std::sync::Arc;
+
+	type AccountPublic = <Signature as Verify>::Signer;
+
+	#[test]
+	// It is "ignored", but the node-cli ignored tests are running on the CI.
+	// This can be run locally with `cargo test --release -p node-cli test_sync -- --ignored`.
+	#[ignore]
+	fn test_sync() {
+		sp_tracing::try_init_simple();
+
+		let keystore_path = tempfile::tempdir().expect("Creates keystore path");
+		let keystore: KeystorePtr = LocalKeystore::open(keystore_path.path(), None)
+			.expect("Creates keystore")
+			.into();
+		let alice: sp_consensus_babe::AuthorityId = keystore
+			.sr25519_generate_new(BABE, Some("//Alice"))
+			.expect("Creates authority pair")
+			.into();
+
+		let chain_spec = crate::chain_spec::tests::integration_test_config_with_single_authority();
+
+		// For the block factory
+		let mut slot = 1u64;
+
+		// For the extrinsics factory
+		let bob = Arc::new(AccountKeyring::Bob.pair());
+		let charlie = Arc::new(AccountKeyring::Charlie.pair());
+		let mut index = 0;
+
+		sc_service_test::sync(
+			chain_spec,
+			|config| {
+				let mut setup_handles = None;
+				let NewFullBase { task_manager, client, network, sync, transaction_pool, .. } =
+					new_full_base(
+						config,
+						false,
+						|block_import: &sc_consensus_babe::BabeBlockImport<Block, _, _>,
+						 babe_link: &sc_consensus_babe::BabeLink<Block>| {
+							setup_handles = Some((block_import.clone(), babe_link.clone()));
+						},
+					)?;
+
+				let node = sc_service_test::TestNetComponents::new(
+					task_manager,
+					client,
+					network,
+					sync,
+					transaction_pool,
+				);
+				Ok((node, setup_handles.unwrap()))
+			},
+			|service, &mut (ref mut block_import, ref babe_link)| {
+				let parent_hash = service.client().chain_info().best_hash;
+				let parent_header = service.client().header(parent_hash).unwrap().unwrap();
+				let parent_number = *parent_header.number();
+
+				futures::executor::block_on(service.transaction_pool().maintain(
+					ChainEvent::NewBestBlock { hash: parent_header.hash(), tree_route: None },
+				));
+
+				let mut proposer_factory = sc_basic_authorship::ProposerFactory::new(
+					service.spawn_handle(),
+					service.client(),
+					service.transaction_pool(),
+					None,
+					None,
+				);
+
+				let mut digest = Digest::default();
+
+				// even though there's only one authority some slots might be empty,
+				// so we must keep trying the next slots until we can claim one.
+				let (babe_pre_digest, epoch_descriptor) = loop {
+					let epoch_descriptor = babe_link
+						.epoch_changes()
+						.shared_data()
+						.epoch_descriptor_for_child_of(
+							descendent_query(&*service.client()),
+							&parent_hash,
+							parent_number,
+							slot.into(),
+						)
+						.unwrap()
+						.unwrap();
+
+					let epoch = babe_link
+						.epoch_changes()
+						.shared_data()
+						.epoch_data(&epoch_descriptor, |slot| {
+							sc_consensus_babe::Epoch::genesis(babe_link.config(), slot)
+						})
+						.unwrap();
+
+					if let Some(babe_pre_digest) =
+						sc_consensus_babe::authorship::claim_slot(slot.into(), &epoch, &keystore)
+							.map(|(digest, _)| digest)
+					{
+						break (babe_pre_digest, epoch_descriptor)
+					}
+
+					slot += 1;
+				};
+
+				let inherent_data = futures::executor::block_on(
+					(
+						sp_timestamp::InherentDataProvider::new(
+							std::time::Duration::from_millis(SLOT_DURATION * slot).into(),
+						),
+						sp_consensus_babe::inherents::InherentDataProvider::new(slot.into()),
+					)
+						.create_inherent_data(),
+				)
+				.expect("Creates inherent data");
+
+				digest.push(<DigestItem as CompatibleDigestItem>::babe_pre_digest(babe_pre_digest));
+
+				let new_block = futures::executor::block_on(async move {
+					let proposer = proposer_factory.init(&parent_header).await;
+					proposer
+						.unwrap()
+						.propose(inherent_data, digest, std::time::Duration::from_secs(1), None)
+						.await
+				})
+				.expect("Error making test block")
+				.block;
+
+				let (new_header, new_body) = new_block.deconstruct();
+				let pre_hash = new_header.hash();
+				// sign the pre-sealed hash of the block and then
+				// add it to a digest item.
+				let to_sign = pre_hash.encode();
+				let signature = keystore
+					.sr25519_sign(sp_consensus_babe::AuthorityId::ID, alice.as_ref(), &to_sign)
+					.unwrap()
+					.unwrap();
+				let item = <DigestItem as CompatibleDigestItem>::babe_seal(signature.into());
+				slot += 1;
+
+				let mut params = BlockImportParams::new(BlockOrigin::File, new_header);
+				params.post_digests.push(item);
+				params.body = Some(new_body);
+				params.insert_intermediate(
+					INTERMEDIATE_KEY,
+					BabeIntermediate::<Block> { epoch_descriptor },
+				);
+				params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+				futures::executor::block_on(block_import.import_block(params))
+					.expect("error importing test block");
+			},
+			|service, _| {
+				let amount = 5 * CENTS;
+				let to: Address = AccountPublic::from(bob.public()).into_account().into();
+				let from: Address = AccountPublic::from(charlie.public()).into_account().into();
+				let genesis_hash = service.client().block_hash(0).unwrap().unwrap();
+				let best_hash = service.client().chain_info().best_hash;
+				let (spec_version, transaction_version) = {
+					let version = service.client().runtime_version_at(best_hash).unwrap();
+					(version.spec_version, version.transaction_version)
+				};
+				let signer = charlie.clone();
+
+				let function = RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+					dest: to.into(),
+					value: amount,
+				});
+
+				let check_non_zero_sender = frame_system::CheckNonZeroSender::new();
+				let check_spec_version = frame_system::CheckSpecVersion::new();
+				let check_tx_version = frame_system::CheckTxVersion::new();
+				let check_genesis = frame_system::CheckGenesis::new();
+				let check_era = frame_system::CheckEra::from(Era::Immortal);
+				let check_nonce = frame_system::CheckNonce::from(index);
+				let check_weight = frame_system::CheckWeight::new();
+				let tx_payment =
+					pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::from(0, None);
+				let extra = (
+					check_non_zero_sender,
+					check_spec_version,
+					check_tx_version,
+					check_genesis,
+					check_era,
+					check_nonce,
+					check_weight,
+					tx_payment,
+				);
+				let raw_payload = SignedPayload::from_raw(
+					function,
+					extra,
+					((), spec_version, transaction_version, genesis_hash, genesis_hash, (), (), ()),
+				);
+				let signature = raw_payload.using_encoded(|payload| signer.sign(payload));
+				let (function, extra, _) = raw_payload.deconstruct();
+				index += 1;
+				UncheckedExtrinsic::new_signed(function, from.into(), signature.into(), extra)
+					.into()
+			},
+		);
+	}
+
+	#[test]
+	#[ignore]
+	fn test_consensus() {
+		sp_tracing::try_init_simple();
+
+		sc_service_test::consensus(
+			crate::chain_spec::tests::integration_test_config_with_two_authorities(),
+			|config| {
+				let NewFullBase { task_manager, client, network, sync, transaction_pool, .. } =
+					new_full_base(config, false, |_, _| ())?;
+				Ok(sc_service_test::TestNetComponents::new(
+					task_manager,
+					client,
+					network,
+					sync,
+					transaction_pool,
+				))
+			},
+			vec!["//Alice".into(), "//Bob".into()],
+		)
+	}
+}
diff --git a/substrate/bin/node/cli/tests/benchmark_block_works.rs b/substrate/bin/node/cli/tests/benchmark_block_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..11a1c57a713f0fe2882b947f93071d1c5e46b72f
--- /dev/null
+++ b/substrate/bin/node/cli/tests/benchmark_block_works.rs
@@ -0,0 +1,47 @@
+// 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/>.
+
+// Unix only since it uses signals from [`common::run_node_for_a_while`].
+#![cfg(unix)]
+
+use assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use tempfile::tempdir;
+
+use substrate_cli_test_utils as common;
+
+/// `benchmark block` works for the dev runtime using the wasm executor.
+#[tokio::test]
+async fn benchmark_block_works() {
+	let base_dir = tempdir().expect("could not create a temp dir");
+
+	common::run_node_for_a_while(base_dir.path(), &["--dev", "--no-hardware-benchmarks"]).await;
+
+	// Invoke `benchmark block` with all options to make sure that they are valid.
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(["benchmark", "block", "--dev"])
+		.arg("-d")
+		.arg(base_dir.path())
+		.args(["--from", "1", "--to", "1"])
+		.args(["--repeat", "1"])
+		.args(["--wasm-execution=compiled"])
+		.status()
+		.unwrap();
+
+	assert!(status.success())
+}
diff --git a/substrate/bin/node/cli/tests/benchmark_extrinsic_works.rs b/substrate/bin/node/cli/tests/benchmark_extrinsic_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f7addd883b41ffdbf81292c16d1e827bc1b3cc36
--- /dev/null
+++ b/substrate/bin/node/cli/tests/benchmark_extrinsic_works.rs
@@ -0,0 +1,47 @@
+// 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 assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use tempfile::tempdir;
+
+/// Tests that the `benchmark extrinsic` command works for
+/// remark and transfer_keep_alive within the substrate dev runtime.
+#[test]
+fn benchmark_extrinsic_works() {
+	benchmark_extrinsic("system", "remark");
+	benchmark_extrinsic("balances", "transfer_keep_alive");
+}
+
+/// Checks that the `benchmark extrinsic` command works for the given pallet and extrinsic.
+fn benchmark_extrinsic(pallet: &str, extrinsic: &str) {
+	let base_dir = tempdir().expect("could not create a temp dir");
+
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(&["benchmark", "extrinsic", "--dev"])
+		.arg("-d")
+		.arg(base_dir.path())
+		.args(&["--pallet", pallet, "--extrinsic", extrinsic])
+		// Run with low repeats for faster execution.
+		.args(["--warmup=10", "--repeat=10", "--max-ext-per-block=10"])
+		.args(["--wasm-execution=compiled"])
+		.status()
+		.unwrap();
+
+	assert!(status.success());
+}
diff --git a/substrate/bin/node/cli/tests/benchmark_machine_works.rs b/substrate/bin/node/cli/tests/benchmark_machine_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b3e3f9c78dea5314b5d8db53ef7ac16a5d6debb5
--- /dev/null
+++ b/substrate/bin/node/cli/tests/benchmark_machine_works.rs
@@ -0,0 +1,73 @@
+// 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 assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+
+/// Tests that the `benchmark machine` command works for the substrate dev runtime.
+#[test]
+fn benchmark_machine_works() {
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(["benchmark", "machine", "--dev"])
+		.args([
+			"--verify-duration",
+			"0.1",
+			"--disk-duration",
+			"0.1",
+			"--memory-duration",
+			"0.1",
+			"--hash-duration",
+			"0.1",
+		])
+		// Make it succeed.
+		.args(["--allow-fail"])
+		.status()
+		.unwrap();
+
+	assert!(status.success());
+}
+
+/// Test that the hardware does not meet the requirements.
+///
+/// This is most likely to succeed since it uses a test profile.
+#[test]
+#[cfg(debug_assertions)]
+fn benchmark_machine_fails_with_slow_hardware() {
+	let output = Command::new(cargo_bin("substrate-node"))
+		.args(["benchmark", "machine", "--dev"])
+		.args([
+			"--verify-duration",
+			"1.0",
+			"--disk-duration",
+			"2",
+			"--hash-duration",
+			"1.0",
+			"--memory-duration",
+			"1.0",
+			"--tolerance",
+			"0",
+		])
+		.output()
+		.unwrap();
+
+	// Command should have failed.
+	assert!(!output.status.success());
+	// An `UnmetRequirement` error should have been printed.
+	let log = String::from_utf8_lossy(&output.stderr).to_string();
+	assert!(log.contains("UnmetRequirement"));
+}
diff --git a/substrate/bin/node/cli/tests/benchmark_overhead_works.rs b/substrate/bin/node/cli/tests/benchmark_overhead_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b246167f2c447d66979950b132df74a7efad8c91
--- /dev/null
+++ b/substrate/bin/node/cli/tests/benchmark_overhead_works.rs
@@ -0,0 +1,47 @@
+// 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 assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use tempfile::tempdir;
+
+/// Tests that the `benchmark overhead` command works for the substrate dev runtime.
+#[test]
+fn benchmark_overhead_works() {
+	let tmp_dir = tempdir().expect("could not create a temp dir");
+	let base_path = tmp_dir.path();
+
+	// Only put 10 extrinsics into the block otherwise it takes forever to build it
+	// especially for a non-release build.
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(&["benchmark", "overhead", "--dev", "-d"])
+		.arg(base_path)
+		.arg("--weight-path")
+		.arg(base_path)
+		.args(["--warmup", "10", "--repeat", "10"])
+		.args(["--add", "100", "--mul", "1.2", "--metric", "p75"])
+		.args(["--max-ext-per-block", "10"])
+		.args(["--wasm-execution=compiled"])
+		.status()
+		.unwrap();
+	assert!(status.success());
+
+	// Weight files have been created.
+	assert!(base_path.join("block_weights.rs").exists());
+	assert!(base_path.join("extrinsic_weights.rs").exists());
+}
diff --git a/substrate/bin/node/cli/tests/benchmark_pallet_works.rs b/substrate/bin/node/cli/tests/benchmark_pallet_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8441333429bea6ed3cee7d33a6edac9ccb8d4586
--- /dev/null
+++ b/substrate/bin/node/cli/tests/benchmark_pallet_works.rs
@@ -0,0 +1,53 @@
+// 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/>.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+
+/// `benchmark pallet` works for the different combinations of `steps` and `repeat`.
+#[test]
+fn benchmark_pallet_works() {
+	// Some invalid combinations:
+	benchmark_pallet(0, 10, false);
+	benchmark_pallet(1, 10, false);
+	// ... and some valid:
+	benchmark_pallet(2, 1, true);
+	benchmark_pallet(50, 20, true);
+	benchmark_pallet(20, 50, true);
+}
+
+fn benchmark_pallet(steps: u32, repeat: u32, should_work: bool) {
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(["benchmark", "pallet", "--dev"])
+		// Use the `addition` benchmark since is the fastest.
+		.args(["--pallet", "frame-benchmarking", "--extrinsic", "addition"])
+		.args(["--steps", &format!("{}", steps), "--repeat", &format!("{}", repeat)])
+		.args([
+			"--wasm-execution=compiled",
+			"--no-storage-info",
+			"--no-median-slopes",
+			"--no-min-squares",
+			"--heap-pages=4096",
+		])
+		.status()
+		.unwrap();
+
+	assert_eq!(status.success(), should_work);
+}
diff --git a/substrate/bin/node/cli/tests/benchmark_storage_works.rs b/substrate/bin/node/cli/tests/benchmark_storage_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e4566f4f9b18d808d8203c29eb6914f54a24a9f1
--- /dev/null
+++ b/substrate/bin/node/cli/tests/benchmark_storage_works.rs
@@ -0,0 +1,55 @@
+// 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/>.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use assert_cmd::cargo::cargo_bin;
+use std::{
+	path::Path,
+	process::{Command, ExitStatus},
+};
+use tempfile::tempdir;
+
+/// Tests that the `benchmark storage` command works for the dev runtime.
+#[test]
+fn benchmark_storage_works() {
+	let tmp_dir = tempdir().expect("could not create a temp dir");
+	let base_path = tmp_dir.path();
+
+	// Benchmarking the storage works and creates the correct weight file.
+	assert!(benchmark_storage("rocksdb", base_path).success());
+	assert!(base_path.join("rocksdb_weights.rs").exists());
+
+	assert!(benchmark_storage("paritydb", base_path).success());
+	assert!(base_path.join("paritydb_weights.rs").exists());
+}
+
+fn benchmark_storage(db: &str, base_path: &Path) -> ExitStatus {
+	Command::new(cargo_bin("substrate-node"))
+		.args(&["benchmark", "storage", "--dev"])
+		.arg("--db")
+		.arg(db)
+		.arg("--weight-path")
+		.arg(base_path)
+		.args(["--state-version", "1"])
+		.args(["--warmups", "0"])
+		.args(["--add", "100", "--mul", "1.2", "--metric", "p75"])
+		.arg("--include-child-trees")
+		.status()
+		.unwrap()
+}
diff --git a/substrate/bin/node/cli/tests/build_spec_works.rs b/substrate/bin/node/cli/tests/build_spec_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ce97dea6f6c84cde18ef3941a2250ff881647c07
--- /dev/null
+++ b/substrate/bin/node/cli/tests/build_spec_works.rs
@@ -0,0 +1,39 @@
+// 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 assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use tempfile::tempdir;
+
+#[test]
+fn build_spec_works() {
+	let base_path = tempdir().expect("could not create a temp dir");
+
+	let output = Command::new(cargo_bin("substrate-node"))
+		.args(&["build-spec", "--dev", "-d"])
+		.arg(base_path.path())
+		.output()
+		.unwrap();
+	assert!(output.status.success());
+
+	// Make sure that the `dev` chain folder exists, but the `db` doesn't
+	assert!(base_path.path().join("chains/dev/").exists());
+	assert!(!base_path.path().join("chains/dev/db").exists());
+
+	let _value: serde_json::Value = serde_json::from_slice(output.stdout.as_slice()).unwrap();
+}
diff --git a/substrate/bin/node/cli/tests/check_block_works.rs b/substrate/bin/node/cli/tests/check_block_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..083a79c477bab44eb27cd7aac1f5e6c497672e97
--- /dev/null
+++ b/substrate/bin/node/cli/tests/check_block_works.rs
@@ -0,0 +1,40 @@
+// 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/>.
+
+#![cfg(unix)]
+
+use assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use tempfile::tempdir;
+
+use substrate_cli_test_utils as common;
+
+#[tokio::test]
+async fn check_block_works() {
+	let base_path = tempdir().expect("could not create a temp dir");
+
+	common::run_node_for_a_while(base_path.path(), &["--dev", "--no-hardware-benchmarks"]).await;
+
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(&["check-block", "--dev", "-d"])
+		.arg(base_path.path())
+		.arg("1")
+		.status()
+		.unwrap();
+	assert!(status.success());
+}
diff --git a/substrate/bin/node/cli/tests/export_import_flow.rs b/substrate/bin/node/cli/tests/export_import_flow.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0dc001ac43011d725fc25a4ad1be84935c45ae5d
--- /dev/null
+++ b/substrate/bin/node/cli/tests/export_import_flow.rs
@@ -0,0 +1,203 @@
+// 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/>.
+
+#![cfg(unix)]
+
+use assert_cmd::cargo::cargo_bin;
+use regex::Regex;
+use std::{fs, path::PathBuf, process::Command};
+use tempfile::{tempdir, TempDir};
+
+use substrate_cli_test_utils as common;
+
+fn contains_error(logged_output: &str) -> bool {
+	logged_output.contains("Error")
+}
+
+/// Helper struct to execute the export/import/revert tests.
+/// The fields are paths to a temporary directory
+struct ExportImportRevertExecutor<'a> {
+	base_path: &'a TempDir,
+	exported_blocks_file: &'a PathBuf,
+	db_path: &'a PathBuf,
+	num_exported_blocks: Option<u64>,
+}
+
+/// Format options for export / import commands.
+enum FormatOpt {
+	Json,
+	Binary,
+}
+
+/// Command corresponding to the different commands we would like to run.
+enum SubCommand {
+	ExportBlocks,
+	ImportBlocks,
+}
+
+impl ToString for SubCommand {
+	fn to_string(&self) -> String {
+		match self {
+			SubCommand::ExportBlocks => String::from("export-blocks"),
+			SubCommand::ImportBlocks => String::from("import-blocks"),
+		}
+	}
+}
+
+impl<'a> ExportImportRevertExecutor<'a> {
+	fn new(
+		base_path: &'a TempDir,
+		exported_blocks_file: &'a PathBuf,
+		db_path: &'a PathBuf,
+	) -> Self {
+		Self { base_path, exported_blocks_file, db_path, num_exported_blocks: None }
+	}
+
+	/// Helper method to run a command. Returns a string corresponding to what has been logged.
+	fn run_block_command(
+		&self,
+		sub_command: SubCommand,
+		format_opt: FormatOpt,
+		expected_to_fail: bool,
+	) -> String {
+		let sub_command_str = sub_command.to_string();
+		// Adding "--binary" if need be.
+		let arguments: Vec<&str> = match format_opt {
+			FormatOpt::Binary => {
+				vec![&sub_command_str, "--dev", "--binary", "-d"]
+			},
+			FormatOpt::Json => vec![&sub_command_str, "--dev", "-d"],
+		};
+
+		let tmp: TempDir;
+		// Setting base_path to be a temporary folder if we are importing blocks.
+		// This allows us to make sure we are importing from scratch.
+		let base_path = match sub_command {
+			SubCommand::ExportBlocks => &self.base_path.path(),
+			SubCommand::ImportBlocks => {
+				tmp = tempdir().unwrap();
+				tmp.path()
+			},
+		};
+
+		// Running the command and capturing the output.
+		let output = Command::new(cargo_bin("substrate-node"))
+			.args(&arguments)
+			.arg(&base_path)
+			.arg(&self.exported_blocks_file)
+			.output()
+			.unwrap();
+
+		let logged_output = String::from_utf8_lossy(&output.stderr).to_string();
+
+		if expected_to_fail {
+			// Checking that we did indeed find an error.
+			assert!(contains_error(&logged_output), "expected to error but did not error!");
+			assert!(!output.status.success());
+		} else {
+			// Making sure no error were logged.
+			assert!(!contains_error(&logged_output), "expected not to error but error'd!");
+			assert!(output.status.success());
+		}
+
+		logged_output
+	}
+
+	/// Runs the `export-blocks` command.
+	fn run_export(&mut self, fmt_opt: FormatOpt) {
+		let log = self.run_block_command(SubCommand::ExportBlocks, fmt_opt, false);
+
+		// Using regex to find out how many block we exported.
+		let re = Regex::new(r"Exporting blocks from #\d* to #(?P<exported_blocks>\d*)").unwrap();
+		let caps = re.captures(&log).unwrap();
+		// Saving the number of blocks we've exported for further use.
+		self.num_exported_blocks = Some(caps["exported_blocks"].parse::<u64>().unwrap());
+
+		let metadata = fs::metadata(&self.exported_blocks_file).unwrap();
+		assert!(metadata.len() > 0, "file exported_blocks should not be empty");
+
+		let _ = fs::remove_dir_all(&self.db_path);
+	}
+
+	/// Runs the `import-blocks` command, asserting that an error was found or
+	/// not depending on `expected_to_fail`.
+	fn run_import(&mut self, fmt_opt: FormatOpt, expected_to_fail: bool) {
+		let log = self.run_block_command(SubCommand::ImportBlocks, fmt_opt, expected_to_fail);
+
+		if !expected_to_fail {
+			// Using regex to find out how much block we imported,
+			// and what's the best current block.
+			let re =
+				Regex::new(r"Imported (?P<imported>\d*) blocks. Best: #(?P<best>\d*)").unwrap();
+			let caps = re.captures(&log).expect("capture should have succeeded");
+			let imported = caps["imported"].parse::<u64>().unwrap();
+			let best = caps["best"].parse::<u64>().unwrap();
+
+			assert_eq!(imported, best, "numbers of blocks imported and best number differs");
+			assert_eq!(
+				best,
+				self.num_exported_blocks.expect("number of exported blocks cannot be None; qed"),
+				"best block number and number of expected blocks should not differ"
+			);
+		}
+		self.num_exported_blocks = None;
+	}
+
+	/// Runs the `revert` command.
+	fn run_revert(&self) {
+		let output = Command::new(cargo_bin("substrate-node"))
+			.args(&["revert", "--dev", "-d"])
+			.arg(&self.base_path.path())
+			.output()
+			.unwrap();
+
+		let logged_output = String::from_utf8_lossy(&output.stderr).to_string();
+
+		// Reverting should not log any error.
+		assert!(!contains_error(&logged_output));
+		// Command should never fail.
+		assert!(output.status.success());
+	}
+
+	/// Helper function that runs the whole export / import / revert flow and checks for errors.
+	fn run(&mut self, export_fmt: FormatOpt, import_fmt: FormatOpt, expected_to_fail: bool) {
+		self.run_export(export_fmt);
+		self.run_import(import_fmt, expected_to_fail);
+		self.run_revert();
+	}
+}
+
+#[tokio::test]
+async fn export_import_revert() {
+	let base_path = tempdir().expect("could not create a temp dir");
+	let exported_blocks_file = base_path.path().join("exported_blocks");
+	let db_path = base_path.path().join("db");
+
+	common::run_node_for_a_while(base_path.path(), &["--dev", "--no-hardware-benchmarks"]).await;
+
+	let mut executor = ExportImportRevertExecutor::new(&base_path, &exported_blocks_file, &db_path);
+
+	// Binary and binary should work.
+	executor.run(FormatOpt::Binary, FormatOpt::Binary, false);
+	// Binary and JSON should fail.
+	executor.run(FormatOpt::Binary, FormatOpt::Json, true);
+	// JSON and JSON should work.
+	executor.run(FormatOpt::Json, FormatOpt::Json, false);
+	// JSON and binary should fail.
+	executor.run(FormatOpt::Json, FormatOpt::Binary, true);
+}
diff --git a/substrate/bin/node/cli/tests/inspect_works.rs b/substrate/bin/node/cli/tests/inspect_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..10b0e518e9e87332496c7f8ea966b7421fe0bbe8
--- /dev/null
+++ b/substrate/bin/node/cli/tests/inspect_works.rs
@@ -0,0 +1,40 @@
+// 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/>.
+
+#![cfg(unix)]
+
+use assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use tempfile::tempdir;
+
+use substrate_cli_test_utils as common;
+
+#[tokio::test]
+async fn inspect_works() {
+	let base_path = tempdir().expect("could not create a temp dir");
+
+	common::run_node_for_a_while(base_path.path(), &["--dev", "--no-hardware-benchmarks"]).await;
+
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(&["inspect", "--dev", "-d"])
+		.arg(base_path.path())
+		.args(&["block", "1"])
+		.status()
+		.unwrap();
+	assert!(status.success());
+}
diff --git a/substrate/bin/node/cli/tests/purge_chain_works.rs b/substrate/bin/node/cli/tests/purge_chain_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..58c4f474521f4d5b5c3048d6246bfac33aa9592c
--- /dev/null
+++ b/substrate/bin/node/cli/tests/purge_chain_works.rs
@@ -0,0 +1,43 @@
+// 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 assert_cmd::cargo::cargo_bin;
+use std::process::Command;
+use tempfile::tempdir;
+
+use substrate_cli_test_utils as common;
+
+#[tokio::test]
+#[cfg(unix)]
+async fn purge_chain_works() {
+	let base_path = tempdir().expect("could not create a temp dir");
+
+	common::run_node_for_a_while(base_path.path(), &["--dev", "--no-hardware-benchmarks"]).await;
+
+	let status = Command::new(cargo_bin("substrate-node"))
+		.args(&["purge-chain", "--dev", "-d"])
+		.arg(base_path.path())
+		.arg("-y")
+		.status()
+		.unwrap();
+	assert!(status.success());
+
+	// Make sure that the `dev` chain folder exists, but the `db` is deleted.
+	assert!(base_path.path().join("chains/dev/").exists());
+	assert!(!base_path.path().join("chains/dev/db/full").exists());
+}
diff --git a/substrate/bin/node/cli/tests/remember_state_pruning_works.rs b/substrate/bin/node/cli/tests/remember_state_pruning_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e28b2ef55ef6c9de5b99301222f6e1df9b4bafea
--- /dev/null
+++ b/substrate/bin/node/cli/tests/remember_state_pruning_works.rs
@@ -0,0 +1,38 @@
+// 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 tempfile::tempdir;
+
+use substrate_cli_test_utils as common;
+
+#[tokio::test]
+#[cfg(unix)]
+async fn remember_state_pruning_works() {
+	let base_path = tempdir().expect("could not create a temp dir");
+
+	// First run with `--state-pruning=archive`.
+	common::run_node_for_a_while(
+		base_path.path(),
+		&["--dev", "--state-pruning=archive", "--no-hardware-benchmarks"],
+	)
+	.await;
+
+	// Then run again without specifying the state pruning.
+	// This should load state pruning settings from the db.
+	common::run_node_for_a_while(base_path.path(), &["--dev", "--no-hardware-benchmarks"]).await;
+}
diff --git a/substrate/bin/node/cli/tests/running_the_node_and_interrupt.rs b/substrate/bin/node/cli/tests/running_the_node_and_interrupt.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f10ea6a055b49790c28064f18b43292ce9f5a064
--- /dev/null
+++ b/substrate/bin/node/cli/tests/running_the_node_and_interrupt.rs
@@ -0,0 +1,89 @@
+// 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/>.
+
+#![cfg(unix)]
+use assert_cmd::cargo::cargo_bin;
+use nix::sys::signal::Signal::{self, SIGINT, SIGTERM};
+use std::{
+	process::{self, Command},
+	time::Duration,
+};
+use tempfile::tempdir;
+
+use substrate_cli_test_utils as common;
+
+#[tokio::test]
+async fn running_the_node_works_and_can_be_interrupted() {
+	common::run_with_timeout(Duration::from_secs(60 * 10), async move {
+		async fn run_command_and_kill(signal: Signal) {
+			let base_path = tempdir().expect("could not create a temp dir");
+			let mut cmd = common::KillChildOnDrop(
+				Command::new(cargo_bin("substrate-node"))
+					.stdout(process::Stdio::piped())
+					.stderr(process::Stdio::piped())
+					.args(&["--dev", "-d"])
+					.arg(base_path.path())
+					.arg("--db=paritydb")
+					.arg("--no-hardware-benchmarks")
+					.spawn()
+					.unwrap(),
+			);
+
+			let stderr = cmd.stderr.take().unwrap();
+
+			let ws_url = common::extract_info_from_output(stderr).0.ws_url;
+
+			common::wait_n_finalized_blocks(3, &ws_url).await;
+
+			cmd.assert_still_running();
+
+			cmd.stop_with_signal(signal);
+
+			// Check if the database was closed gracefully. If it was not,
+			// there may exist a ref cycle that prevents the Client from being dropped properly.
+			//
+			// parity-db only writes the stats file on clean shutdown.
+			let stats_file = base_path.path().join("chains/dev/paritydb/full/stats.txt");
+			assert!(std::path::Path::exists(&stats_file));
+		}
+
+		run_command_and_kill(SIGINT).await;
+		run_command_and_kill(SIGTERM).await;
+	})
+	.await;
+}
+
+#[tokio::test]
+async fn running_two_nodes_with_the_same_ws_port_should_work() {
+	common::run_with_timeout(Duration::from_secs(60 * 10), async move {
+		let mut first_node = common::KillChildOnDrop(common::start_node());
+		let mut second_node = common::KillChildOnDrop(common::start_node());
+
+		let stderr = first_node.stderr.take().unwrap();
+		let ws_url = common::extract_info_from_output(stderr).0.ws_url;
+
+		common::wait_n_finalized_blocks(3, &ws_url).await;
+
+		first_node.assert_still_running();
+		second_node.assert_still_running();
+
+		first_node.stop();
+		second_node.stop();
+	})
+	.await;
+}
diff --git a/substrate/bin/node/cli/tests/telemetry.rs b/substrate/bin/node/cli/tests/telemetry.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2321f56c473d68ad44a9a92c393c09599f0ec951
--- /dev/null
+++ b/substrate/bin/node/cli/tests/telemetry.rs
@@ -0,0 +1,92 @@
+// 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 assert_cmd::cargo::cargo_bin;
+use std::{process, time::Duration};
+
+use crate::common::KillChildOnDrop;
+
+use substrate_cli_test_utils as common;
+pub mod websocket_server;
+
+#[tokio::test]
+async fn telemetry_works() {
+	common::run_with_timeout(Duration::from_secs(60 * 10), async move {
+		let config = websocket_server::Config {
+			capacity: 1,
+			max_frame_size: 1048 * 1024,
+			send_buffer_len: 32,
+			bind_address: "127.0.0.1:0".parse().unwrap(),
+		};
+		let mut server = websocket_server::WsServer::new(config).await.unwrap();
+
+		let addr = server.local_addr().unwrap();
+
+		let server_task = tokio::spawn(async move {
+			loop {
+				use websocket_server::Event;
+				match server.next_event().await {
+					// New connection on the listener.
+					Event::ConnectionOpen { address } => {
+						println!("New connection from {:?}", address);
+						server.accept();
+					},
+
+					// Received a message from a connection.
+					Event::BinaryFrame { message, .. } => {
+						let json: serde_json::Value = serde_json::from_slice(&message).unwrap();
+						let object =
+							json.as_object().unwrap().get("payload").unwrap().as_object().unwrap();
+						if matches!(object.get("best"), Some(serde_json::Value::String(_))) {
+							break
+						}
+					},
+
+					Event::TextFrame { .. } => {
+						panic!("Got a TextFrame over the socket, this is a bug")
+					},
+
+					// Connection has been closed.
+					Event::ConnectionError { .. } => {},
+				}
+			}
+		});
+
+		let mut substrate = process::Command::new(cargo_bin("substrate-node"));
+
+		let mut substrate = KillChildOnDrop(
+			substrate
+				.args(&["--dev", "--tmp", "--telemetry-url"])
+				.arg(format!("ws://{} 10", addr))
+				.arg("--no-hardware-benchmarks")
+				.stdout(process::Stdio::piped())
+				.stderr(process::Stdio::piped())
+				.stdin(process::Stdio::null())
+				.spawn()
+				.unwrap(),
+		);
+
+		server_task.await.expect("server task panicked");
+
+		substrate.assert_still_running();
+
+		// Stop the process
+		substrate.stop();
+	})
+	.await;
+}
diff --git a/substrate/bin/node/cli/tests/temp_base_path_works.rs b/substrate/bin/node/cli/tests/temp_base_path_works.rs
new file mode 100644
index 0000000000000000000000000000000000000000..42f493afad256db724f745bcaf53bfdab79d32d7
--- /dev/null
+++ b/substrate/bin/node/cli/tests/temp_base_path_works.rs
@@ -0,0 +1,62 @@
+// 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/>.
+
+#![cfg(unix)]
+
+use assert_cmd::cargo::cargo_bin;
+use std::{
+	process::{Command, Stdio},
+	time::Duration,
+};
+
+use substrate_cli_test_utils as common;
+
+#[allow(dead_code)]
+// Apparently `#[ignore]` doesn't actually work to disable this one.
+//#[tokio::test]
+async fn temp_base_path_works() {
+	common::run_with_timeout(Duration::from_secs(60 * 10), async move {
+		let mut cmd = Command::new(cargo_bin("substrate-node"));
+		let mut child = common::KillChildOnDrop(
+			cmd.args(&["--dev", "--tmp", "--no-hardware-benchmarks"])
+				.stdout(Stdio::piped())
+				.stderr(Stdio::piped())
+				.spawn()
+				.unwrap(),
+		);
+
+		let mut stderr = child.stderr.take().unwrap();
+		let node_info = common::extract_info_from_output(&mut stderr).0;
+
+		// Let it produce some blocks.
+		common::wait_n_finalized_blocks(3, &node_info.ws_url).await;
+
+		// Ensure the db path exists while the node is running
+		assert!(node_info.db_path.exists());
+
+		child.assert_still_running();
+
+		// Stop the process
+		child.stop();
+
+		if node_info.db_path.exists() {
+			panic!("Database path `{}` wasn't deleted!", node_info.db_path.display());
+		}
+	})
+	.await;
+}
diff --git a/substrate/bin/node/cli/tests/version.rs b/substrate/bin/node/cli/tests/version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ac1a6b79682eccb29594135a20f5f867f14cf665
--- /dev/null
+++ b/substrate/bin/node/cli/tests/version.rs
@@ -0,0 +1,51 @@
+// 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 assert_cmd::cargo::cargo_bin;
+use regex::Regex;
+use std::process::Command;
+
+fn expected_regex() -> Regex {
+	Regex::new(r"^substrate-node (.+)-([a-f\d]+)$").unwrap()
+}
+
+#[test]
+fn version_is_full() {
+	let expected = expected_regex();
+	let output = Command::new(cargo_bin("substrate-node")).args(&["--version"]).output().unwrap();
+
+	assert!(output.status.success(), "command returned with non-success exit code");
+
+	let output = dbg!(String::from_utf8_lossy(&output.stdout).trim().to_owned());
+	let captures = expected.captures(output.as_str()).expect("could not parse version in output");
+
+	assert_eq!(&captures[1], env!("CARGO_PKG_VERSION"));
+}
+
+#[test]
+fn test_regex_matches_properly() {
+	let expected = expected_regex();
+
+	let captures = expected.captures("substrate-node 2.0.0-da487d19d").unwrap();
+	assert_eq!(&captures[1], "2.0.0");
+	assert_eq!(&captures[2], "da487d19d");
+
+	let captures = expected.captures("substrate-node 2.0.0-alpha.5-da487d19d").unwrap();
+	assert_eq!(&captures[1], "2.0.0-alpha.5");
+	assert_eq!(&captures[2], "da487d19d");
+}
diff --git a/substrate/bin/node/cli/tests/websocket_server.rs b/substrate/bin/node/cli/tests/websocket_server.rs
new file mode 100644
index 0000000000000000000000000000000000000000..432a4871cd3785a171dcd6f8d20135dd8072a33c
--- /dev/null
+++ b/substrate/bin/node/cli/tests/websocket_server.rs
@@ -0,0 +1,279 @@
+// 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 core::pin::Pin;
+use futures::prelude::*;
+use soketto::handshake::{server::Response, Server};
+use std::{io, net::SocketAddr};
+use tokio::net::{TcpListener, TcpStream};
+use tokio_util::compat::{Compat, TokioAsyncReadCompatExt};
+
+/// Configuration for a [`WsServer`].
+pub struct Config {
+	/// IP address to try to bind to.
+	pub bind_address: SocketAddr,
+
+	/// Maximum size, in bytes, of a frame sent by the remote.
+	///
+	/// Since the messages are entirely buffered before being returned, a maximum value is
+	/// necessary in order to prevent malicious clients from sending huge frames that would
+	/// occupy a lot of memory.
+	pub max_frame_size: usize,
+
+	/// Number of pending messages to buffer up for sending before the socket is considered
+	/// unresponsive.
+	pub send_buffer_len: usize,
+
+	/// Pre-allocated capacity for the list of connections.
+	pub capacity: usize,
+}
+
+/// Identifier for a connection with regard to a [`WsServer`].
+///
+/// After a connection has been closed, its [`ConnectionId`] might be reused.
+#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+pub struct ConnectionId(u64);
+
+/// A WebSocket message.
+pub enum Message {
+	Text(String),
+	Binary(Vec<u8>),
+}
+
+/// WebSockets listening socket and list of open connections.
+pub struct WsServer {
+	/// Value passed through [`Config::max_frame_size`].
+	max_frame_size: usize,
+
+	/// Endpoint for incoming TCP sockets.
+	listener: TcpListener,
+
+	/// Pending incoming connection to accept. Accepted by calling [`WsServer::accept`].
+	pending_incoming: Option<TcpStream>,
+
+	/// List of TCP connections that are currently negotiating the WebSocket handshake.
+	///
+	/// The output can be an error if the handshake fails.
+	negotiating: stream::FuturesUnordered<
+		Pin<
+			Box<
+				dyn Future<
+						Output = Result<
+							Server<'static, Compat<TcpStream>>,
+							Box<dyn std::error::Error>,
+						>,
+					> + Send,
+			>,
+		>,
+	>,
+
+	/// List of streams of incoming messages for all connections.
+	incoming_messages: stream::SelectAll<
+		Pin<Box<dyn Stream<Item = Result<Message, Box<dyn std::error::Error>>> + Send>>,
+	>,
+
+	/// Tasks dedicated to closing sockets that have been rejected.
+	rejected_sockets: stream::FuturesUnordered<Pin<Box<dyn Future<Output = ()> + Send>>>,
+}
+
+impl WsServer {
+	/// Try opening a TCP listening socket.
+	///
+	/// Returns an error if the listening socket fails to open.
+	pub async fn new(config: Config) -> Result<Self, io::Error> {
+		let listener = TcpListener::bind(config.bind_address).await?;
+
+		Ok(WsServer {
+			max_frame_size: config.max_frame_size,
+			listener,
+			pending_incoming: None,
+			negotiating: stream::FuturesUnordered::new(),
+			incoming_messages: stream::SelectAll::new(),
+			rejected_sockets: stream::FuturesUnordered::new(),
+		})
+	}
+
+	/// Address of the local TCP listening socket, as provided by the operating system.
+	pub fn local_addr(&self) -> Result<SocketAddr, io::Error> {
+		self.listener.local_addr()
+	}
+
+	/// Accepts the pending connection.
+	///
+	/// Either [`WsServer::accept`] or [`WsServer::reject`] must be called after a
+	/// [`Event::ConnectionOpen`] event is returned.
+	///
+	/// # Panic
+	///
+	/// Panics if no connection is pending.
+	pub fn accept(&mut self) {
+		let pending_incoming = self.pending_incoming.take().expect("no pending socket");
+
+		self.negotiating.push(Box::pin(async move {
+			let mut server = Server::new(pending_incoming.compat());
+
+			let websocket_key = match server.receive_request().await {
+				Ok(req) => req.key(),
+				Err(err) => return Err(Box::new(err) as Box<_>),
+			};
+
+			match server
+				.send_response(&{ Response::Accept { key: websocket_key, protocol: None } })
+				.await
+			{
+				Ok(()) => {},
+				Err(err) => return Err(Box::new(err) as Box<_>),
+			};
+
+			Ok(server)
+		}));
+	}
+
+	/// Reject the pending connection.
+	///
+	/// Either [`WsServer::accept`] or [`WsServer::reject`] must be called after a
+	/// [`Event::ConnectionOpen`] event is returned.
+	///
+	/// # Panic
+	///
+	/// Panics if no connection is pending.
+	pub fn reject(&mut self) {
+		let _ = self.pending_incoming.take().expect("no pending socket");
+	}
+
+	/// Returns the next event happening on the server.
+	pub async fn next_event(&mut self) -> Event {
+		loop {
+			futures::select! {
+				// Only try to fetch a new incoming connection if none is pending.
+				socket = {
+					let listener = &self.listener;
+					let has_pending = self.pending_incoming.is_some();
+					async move {
+						if !has_pending {
+							listener.accept().await
+						} else {
+							loop { futures::pending!() }
+						}
+					}
+				}.fuse() => {
+					let (socket, address) = match socket {
+						Ok(s) => s,
+						Err(_) => continue,
+					};
+					debug_assert!(self.pending_incoming.is_none());
+					self.pending_incoming = Some(socket);
+					return Event::ConnectionOpen { address };
+				},
+
+				result = self.negotiating.select_next_some() => {
+					let server = match result {
+						Ok(s) => s,
+						Err(error) => return Event::ConnectionError {
+							error,
+						},
+					};
+
+					let (mut _sender, receiver) = {
+						let mut builder = server.into_builder();
+						builder.set_max_frame_size(self.max_frame_size);
+						builder.set_max_message_size(self.max_frame_size);
+						builder.finish()
+					};
+
+					// Spawn a task dedicated to receiving messages from the socket.
+					self.incoming_messages.push({
+						// Turn `receiver` into a stream of received packets.
+						let socket_packets = stream::unfold((receiver, Vec::new()), move |(mut receiver, mut buf)| async {
+							buf.clear();
+							let ret = match receiver.receive_data(&mut buf).await {
+								Ok(soketto::Data::Text(len)) => String::from_utf8(buf[..len].to_vec())
+									.map(Message::Text)
+									.map_err(|err| Box::new(err) as Box<_>),
+								Ok(soketto::Data::Binary(len)) => Ok(buf[..len].to_vec())
+									.map(Message::Binary),
+								Err(err) => Err(Box::new(err) as Box<_>),
+							};
+							Some((ret, (receiver, buf)))
+						});
+
+						Box::pin(socket_packets.map(move |msg| (msg)))
+					});
+				},
+
+				result = self.incoming_messages.select_next_some() => {
+					let message = match result {
+						Ok(m) => m,
+						Err(error) => return Event::ConnectionError {
+							error,
+						},
+					};
+
+					match message {
+						Message::Text(message) => {
+							return Event::TextFrame {
+								message,
+							}
+						}
+						Message::Binary(message) => {
+							return Event::BinaryFrame {
+								message,
+							}
+						}
+					}
+				},
+
+				_ = self.rejected_sockets.select_next_some() => {
+				}
+			}
+		}
+	}
+}
+
+/// Event that has happened on a [`WsServer`].
+#[derive(Debug)]
+pub enum Event {
+	/// A new TCP connection has arrived on the listening socket.
+	///
+	/// The connection *must* be accepted or rejected using [`WsServer::accept`] or
+	/// [`WsServer::reject`].
+	/// No other [`Event::ConnectionOpen`] event will be generated until the current pending
+	/// connection has been either accepted or rejected.
+	ConnectionOpen {
+		/// Address of the remote, as provided by the operating system.
+		address: SocketAddr,
+	},
+
+	/// An error has happened on a connection. The connection is now closed and its
+	/// [`ConnectionId`] is now invalid.
+	ConnectionError { error: Box<dyn std::error::Error> },
+
+	/// A text frame has been received on a connection.
+	TextFrame {
+		/// Message sent by the remote. Its content is entirely decided by the client, and
+		/// nothing must be assumed about the validity of this message.
+		message: String,
+	},
+
+	/// A text frame has been received on a connection.
+	BinaryFrame {
+		/// Message sent by the remote. Its content is entirely decided by the client, and
+		/// nothing must be assumed about the validity of this message.
+		message: Vec<u8>,
+	},
+}
diff --git a/substrate/bin/node/executor/Cargo.toml b/substrate/bin/node/executor/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b24414482952c14a1f676733ba149888511236cf
--- /dev/null
+++ b/substrate/bin/node/executor/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "node-executor"
+version = "3.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node implementation in Rust."
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+scale-info = { version = "2.5.0", features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", path = "../../../frame/benchmarking" }
+node-primitives = { version = "2.0.0", path = "../primitives" }
+kitchensink-runtime = { version = "3.0.0-dev", path = "../runtime" }
+sc-executor = { version = "0.10.0-dev", path = "../../../client/executor" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-state-machine = { version = "0.28.0", path = "../../../primitives/state-machine" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+sp-trie = { version = "22.0.0", path = "../../../primitives/trie" }
+sp-statement-store = { version = "4.0.0-dev", path = "../../../primitives/statement-store" }
+
+[dev-dependencies]
+criterion = "0.4.0"
+futures = "0.3.21"
+wat = "1.0"
+frame-support = { version = "4.0.0-dev", path = "../../../frame/support" }
+frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
+node-testing = { version = "3.0.0-dev", path = "../testing" }
+pallet-balances = { version = "4.0.0-dev", path = "../../../frame/balances" }
+pallet-contracts = { version = "4.0.0-dev", path = "../../../frame/contracts" }
+pallet-im-online = { version = "4.0.0-dev", path = "../../../frame/im-online" }
+pallet-glutton = { version = "4.0.0-dev", path = "../../../frame/glutton" }
+pallet-sudo = { version = "4.0.0-dev", path = "../../../frame/sudo" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../../../frame/timestamp" }
+pallet-treasury = { version = "4.0.0-dev", path = "../../../frame/treasury" }
+pallet-transaction-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment" }
+sp-application-crypto = { version = "23.0.0", path = "../../../primitives/application-crypto" }
+pallet-root-testing = { version = "1.0.0-dev", path = "../../../frame/root-testing" }
+sp-consensus-babe = { version = "0.10.0-dev", path = "../../../primitives/consensus/babe" }
+sp-externalities = { version = "0.19.0", path = "../../../primitives/externalities" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[features]
+stress-test = []
+
+[[bench]]
+name = "bench"
+harness = false
diff --git a/substrate/bin/node/executor/benches/bench.rs b/substrate/bin/node/executor/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1c9c002492cf5c2bffef3e017fb6a7a4cf5f05c7
--- /dev/null
+++ b/substrate/bin/node/executor/benches/bench.rs
@@ -0,0 +1,235 @@
+// 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 codec::{Decode, Encode};
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use frame_support::Hashable;
+use kitchensink_runtime::{
+	constants::currency::*, Block, BuildStorage, CheckedExtrinsic, Header, RuntimeCall,
+	RuntimeGenesisConfig, UncheckedExtrinsic,
+};
+use node_executor::ExecutorDispatch;
+use node_primitives::{BlockNumber, Hash};
+use node_testing::keyring::*;
+use sc_executor::{
+	Externalities, NativeElseWasmExecutor, RuntimeVersionOf, WasmExecutionMethod, WasmExecutor,
+	WasmtimeInstantiationStrategy,
+};
+use sp_core::{
+	storage::well_known_keys,
+	traits::{CallContext, CodeExecutor, RuntimeCode},
+};
+use sp_runtime::traits::BlakeTwo256;
+use sp_state_machine::TestExternalities as CoreTestExternalities;
+
+criterion_group!(benches, bench_execute_block);
+criterion_main!(benches);
+
+/// The wasm runtime code.
+pub fn compact_code_unwrap() -> &'static [u8] {
+	kitchensink_runtime::WASM_BINARY.expect(
+		"Development wasm binary is not available. Testing is only supported with the flag \
+		 disabled.",
+	)
+}
+
+const GENESIS_HASH: [u8; 32] = [69u8; 32];
+
+const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_version;
+
+const SPEC_VERSION: u32 = kitchensink_runtime::VERSION.spec_version;
+
+const HEAP_PAGES: u64 = 20;
+
+type TestExternalities<H> = CoreTestExternalities<H>;
+
+#[derive(Debug)]
+enum ExecutionMethod {
+	Native,
+	Wasm(WasmExecutionMethod),
+}
+
+fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
+	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH)
+}
+
+fn new_test_ext(genesis_config: &RuntimeGenesisConfig) -> TestExternalities<BlakeTwo256> {
+	let mut test_ext = TestExternalities::new_with_code(
+		compact_code_unwrap(),
+		genesis_config.build_storage().unwrap(),
+	);
+	test_ext
+		.ext()
+		.place_storage(well_known_keys::HEAP_PAGES.to_vec(), Some(HEAP_PAGES.encode()));
+	test_ext
+}
+
+fn construct_block<E: Externalities>(
+	executor: &NativeElseWasmExecutor<ExecutorDispatch>,
+	ext: &mut E,
+	number: BlockNumber,
+	parent_hash: Hash,
+	extrinsics: Vec<CheckedExtrinsic>,
+) -> (Vec<u8>, Hash) {
+	use sp_trie::{LayoutV0, TrieConfiguration};
+
+	// sign extrinsics.
+	let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
+
+	// calculate the header fields that we can.
+	let extrinsics_root =
+		LayoutV0::<BlakeTwo256>::ordered_trie_root(extrinsics.iter().map(Encode::encode))
+			.to_fixed_bytes()
+			.into();
+
+	let header = Header {
+		parent_hash,
+		number,
+		extrinsics_root,
+		state_root: Default::default(),
+		digest: Default::default(),
+	};
+
+	let runtime_code = RuntimeCode {
+		code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
+		hash: vec![1, 2, 3],
+		heap_pages: None,
+	};
+
+	// execute the block to get the real header.
+	executor
+		.call(
+			ext,
+			&runtime_code,
+			"Core_initialize_block",
+			&header.encode(),
+			true,
+			CallContext::Offchain,
+		)
+		.0
+		.unwrap();
+
+	for i in extrinsics.iter() {
+		executor
+			.call(
+				ext,
+				&runtime_code,
+				"BlockBuilder_apply_extrinsic",
+				&i.encode(),
+				true,
+				CallContext::Offchain,
+			)
+			.0
+			.unwrap();
+	}
+
+	let header = Header::decode(
+		&mut &executor
+			.call(
+				ext,
+				&runtime_code,
+				"BlockBuilder_finalize_block",
+				&[0u8; 0],
+				true,
+				CallContext::Offchain,
+			)
+			.0
+			.unwrap()[..],
+	)
+	.unwrap();
+
+	let hash = header.blake2_256();
+	(Block { header, extrinsics }.encode(), hash.into())
+}
+
+fn test_blocks(
+	genesis_config: &RuntimeGenesisConfig,
+	executor: &NativeElseWasmExecutor<ExecutorDispatch>,
+) -> Vec<(Vec<u8>, Hash)> {
+	let mut test_ext = new_test_ext(genesis_config);
+	let mut block1_extrinsics = vec![CheckedExtrinsic {
+		signed: None,
+		function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: 0 }),
+	}];
+	block1_extrinsics.extend((0..20).map(|i| CheckedExtrinsic {
+		signed: Some((alice(), signed_extra(i, 0))),
+		function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+			dest: bob().into(),
+			value: 1 * DOLLARS,
+		}),
+	}));
+	let block1 =
+		construct_block(executor, &mut test_ext.ext(), 1, GENESIS_HASH.into(), block1_extrinsics);
+
+	vec![block1]
+}
+
+fn bench_execute_block(c: &mut Criterion) {
+	let mut group = c.benchmark_group("execute blocks");
+	let execution_methods = vec![
+		ExecutionMethod::Native,
+		ExecutionMethod::Wasm(WasmExecutionMethod::Compiled {
+			instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
+		}),
+	];
+
+	for strategy in execution_methods {
+		group.bench_function(format!("{:?}", strategy), |b| {
+			let genesis_config = node_testing::genesis::config(Some(compact_code_unwrap()));
+			let use_native = match strategy {
+				ExecutionMethod::Native => true,
+				ExecutionMethod::Wasm(..) => false,
+			};
+
+			let executor =
+				NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build());
+			let runtime_code = RuntimeCode {
+				code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
+				hash: vec![1, 2, 3],
+				heap_pages: None,
+			};
+
+			// Get the runtime version to initialize the runtimes cache.
+			{
+				let mut test_ext = new_test_ext(&genesis_config);
+				executor.runtime_version(&mut test_ext.ext(), &runtime_code).unwrap();
+			}
+
+			let blocks = test_blocks(&genesis_config, &executor);
+
+			b.iter_batched_ref(
+				|| new_test_ext(&genesis_config),
+				|test_ext| {
+					for block in blocks.iter() {
+						executor
+							.call(
+								&mut test_ext.ext(),
+								&runtime_code,
+								"Core_execute_block",
+								&block.0,
+								use_native,
+								CallContext::Offchain,
+							)
+							.0
+							.unwrap();
+					}
+				},
+				BatchSize::LargeInput,
+			);
+		});
+	}
+}
diff --git a/substrate/bin/node/executor/src/lib.rs b/substrate/bin/node/executor/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3557a16740b8a6407d485a74dc422985805e063b
--- /dev/null
+++ b/substrate/bin/node/executor/src/lib.rs
@@ -0,0 +1,40 @@
+// 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 `CodeExecutor` specialization which uses natively compiled runtime when the wasm to be
+//! executed is equivalent to the natively compiled code.
+
+pub use sc_executor::NativeElseWasmExecutor;
+
+// Declare an instance of the native executor named `ExecutorDispatch`. Include the wasm binary as
+// the equivalent wasm code.
+pub struct ExecutorDispatch;
+
+impl sc_executor::NativeExecutionDispatch for ExecutorDispatch {
+	type ExtendHostFunctions = (
+		frame_benchmarking::benchmarking::HostFunctions,
+		sp_statement_store::runtime_api::HostFunctions,
+	);
+
+	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
+		kitchensink_runtime::api::dispatch(method, data)
+	}
+
+	fn native_version() -> sc_executor::NativeVersion {
+		kitchensink_runtime::native_version()
+	}
+}
diff --git a/substrate/bin/node/executor/tests/basic.rs b/substrate/bin/node/executor/tests/basic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a2f46e9fdbe997cd71e2817f95f894bec74002de
--- /dev/null
+++ b/substrate/bin/node/executor/tests/basic.rs
@@ -0,0 +1,859 @@
+// 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 codec::{Decode, Encode, Joiner};
+use frame_support::{
+	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo},
+	traits::Currency,
+	weights::Weight,
+};
+use frame_system::{self, AccountInfo, EventRecord, Phase};
+use sp_core::{storage::well_known_keys, traits::Externalities};
+use sp_runtime::{
+	traits::Hash as HashT, transaction_validity::InvalidTransaction, ApplyExtrinsicResult,
+};
+
+use kitchensink_runtime::{
+	constants::{currency::*, time::SLOT_DURATION},
+	Balances, CheckedExtrinsic, Header, Runtime, RuntimeCall, RuntimeEvent, System,
+	TransactionPayment, Treasury, UncheckedExtrinsic,
+};
+use node_primitives::{Balance, Hash};
+use node_testing::keyring::*;
+use wat;
+
+pub mod common;
+use self::common::{sign, *};
+
+/// The wasm runtime binary which hasn't undergone the compacting process.
+///
+/// The idea here is to pass it as the current runtime code to the executor so the executor will
+/// have to execute provided wasm code instead of the native equivalent. This trick is used to
+/// test code paths that differ between native and wasm versions.
+pub fn bloaty_code_unwrap() -> &'static [u8] {
+	kitchensink_runtime::WASM_BINARY_BLOATY.expect(
+		"Development wasm binary is not available. \
+											 Testing is only supported with the flag disabled.",
+	)
+}
+
+/// Default transfer fee. This will use the same logic that is implemented in transaction-payment
+/// module.
+///
+/// Note that reads the multiplier from storage directly, hence to get the fee of `extrinsic`
+/// at block `n`, it must be called prior to executing block `n` to do the calculation with the
+/// correct multiplier.
+fn transfer_fee<E: Encode>(extrinsic: &E) -> Balance {
+	TransactionPayment::compute_fee(
+		extrinsic.encode().len() as u32,
+		&default_transfer_call().get_dispatch_info(),
+		0,
+	)
+}
+
+fn xt() -> UncheckedExtrinsic {
+	sign(CheckedExtrinsic {
+		signed: Some((alice(), signed_extra(0, 0))),
+		function: RuntimeCall::Balances(default_transfer_call()),
+	})
+}
+
+fn set_heap_pages<E: Externalities>(ext: &mut E, heap_pages: u64) {
+	ext.place_storage(well_known_keys::HEAP_PAGES.to_vec(), Some(heap_pages.encode()));
+}
+
+fn changes_trie_block() -> (Vec<u8>, Hash) {
+	let time = 42 * 1000;
+	construct_block(
+		&mut new_test_ext(compact_code_unwrap()),
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time }),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(0, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 69 * DOLLARS,
+				}),
+			},
+		],
+		(time / SLOT_DURATION).into(),
+	)
+}
+
+/// block 1 and 2 must be created together to ensure transactions are only signed once (since they
+/// are not guaranteed to be deterministic) and to ensure that the correct state is propagated
+/// from block1's execution to block2 to derive the correct storage_root.
+fn blocks() -> ((Vec<u8>, Hash), (Vec<u8>, Hash)) {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let time1 = 42 * 1000;
+	let block1 = construct_block(
+		&mut t,
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time1 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(0, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 69 * DOLLARS,
+				}),
+			},
+		],
+		(time1 / SLOT_DURATION).into(),
+	);
+	let time2 = 52 * 1000;
+	let block2 = construct_block(
+		&mut t,
+		2,
+		block1.1,
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time2 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((bob(), signed_extra(0, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: alice().into(),
+					value: 5 * DOLLARS,
+				}),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(1, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 15 * DOLLARS,
+				}),
+			},
+		],
+		(time2 / SLOT_DURATION).into(),
+	);
+
+	// session change => consensus authorities change => authorities change digest item appears
+	let digest = Header::decode(&mut &block2.0[..]).unwrap().digest;
+	assert_eq!(digest.logs().len(), 1 /* Just babe slot */);
+
+	(block1, block2)
+}
+
+fn block_with_size(time: u64, nonce: u32, size: usize) -> (Vec<u8>, Hash) {
+	construct_block(
+		&mut new_test_ext(compact_code_unwrap()),
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time * 1000 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((alice(), signed_extra(nonce, 0))),
+				function: RuntimeCall::System(frame_system::Call::remark { remark: vec![0; size] }),
+			},
+		],
+		(time * 1000 / SLOT_DURATION).into(),
+	)
+}
+
+#[test]
+fn panic_execution_with_foreign_code_gives_error() {
+	let mut t = new_test_ext(bloaty_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (69u128, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(), 69_u128.encode());
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+	let v = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true)
+		.0
+		.unwrap();
+	let r = ApplyExtrinsicResult::decode(&mut &v[..]).unwrap();
+	assert_eq!(r, Err(InvalidTransaction::Payment.into()));
+}
+
+#[test]
+fn bad_extrinsic_with_native_equivalent_code_gives_error() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (69u128, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(), 69u128.encode());
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+	let v = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true)
+		.0
+		.unwrap();
+	let r = ApplyExtrinsicResult::decode(&mut &v[..]).unwrap();
+	assert_eq!(r, Err(InvalidTransaction::Payment.into()));
+}
+
+#[test]
+fn successful_execution_with_native_equivalent_code_gives_ok() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (111 * DOLLARS, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(bob()),
+		AccountInfo::<
+			<Runtime as frame_system::Config>::Nonce,
+			<Runtime as frame_system::Config>::AccountData,
+		>::default()
+		.encode(),
+	);
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(111 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+
+	let fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true).0;
+	assert!(r.is_ok());
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
+	});
+}
+
+#[test]
+fn successful_execution_with_foreign_code_gives_ok() {
+	let mut t = new_test_ext(bloaty_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (111 * DOLLARS, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(bob()),
+		AccountInfo::<
+			<Runtime as frame_system::Config>::Nonce,
+			<Runtime as frame_system::Config>::AccountData,
+		>::default()
+		.encode(),
+	);
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(111 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+	assert!(r.is_ok());
+
+	let fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), true).0;
+	assert!(r.is_ok());
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
+	});
+}
+
+#[test]
+fn full_native_block_import_works() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	let (block1, block2) = blocks();
+
+	let mut alice_last_known_balance: Balance = Default::default();
+	let mut fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let transfer_weight = default_transfer_call().get_dispatch_info().weight.saturating_add(
+		<Runtime as frame_system::Config>::BlockWeights::get()
+			.get(DispatchClass::Normal)
+			.base_extrinsic,
+	);
+	let timestamp_weight = pallet_timestamp::Call::set::<Runtime> { now: Default::default() }
+		.get_dispatch_info()
+		.weight
+		.saturating_add(
+			<Runtime as frame_system::Config>::BlockWeights::get()
+				.get(DispatchClass::Mandatory)
+				.base_extrinsic,
+		);
+
+	executor_call(&mut t, "Core_execute_block", &block1.0, true).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 169 * DOLLARS);
+		alice_last_known_balance = Balances::total_balance(&alice());
+		let events = vec![
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(0),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: timestamp_weight,
+						class: DispatchClass::Mandatory,
+						..Default::default()
+					},
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Withdraw {
+					who: alice().into(),
+					amount: fees,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+					from: alice().into(),
+					to: bob().into(),
+					amount: 69 * DOLLARS,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Deposit {
+					who: pallet_treasury::Pallet::<Runtime>::account_id(),
+					amount: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::Deposit {
+					value: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::TransactionPayment(
+					pallet_transaction_payment::Event::TransactionFeePaid {
+						who: alice().into(),
+						actual_fee: fees,
+						tip: 0,
+					},
+				),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo { weight: transfer_weight, ..Default::default() },
+				}),
+				topics: vec![],
+			},
+		];
+		assert_eq!(System::events(), events);
+	});
+
+	fees = t.execute_with(|| transfer_fee(&xt()));
+	let pot = t.execute_with(|| Treasury::pot());
+
+	executor_call(&mut t, "Core_execute_block", &block2.0, true).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(
+			Balances::total_balance(&alice()),
+			alice_last_known_balance - 10 * DOLLARS - fees,
+		);
+		assert_eq!(Balances::total_balance(&bob()), 179 * DOLLARS - fees);
+		let events = vec![
+			EventRecord {
+				phase: Phase::Initialization,
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::UpdatedInactive {
+					reactivated: 0,
+					deactivated: pot,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(0),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: timestamp_weight,
+						class: DispatchClass::Mandatory,
+						..Default::default()
+					},
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Withdraw {
+					who: bob().into(),
+					amount: fees,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+					from: bob().into(),
+					to: alice().into(),
+					amount: 5 * DOLLARS,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Deposit {
+					who: pallet_treasury::Pallet::<Runtime>::account_id(),
+					amount: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::Deposit {
+					value: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::TransactionPayment(
+					pallet_transaction_payment::Event::TransactionFeePaid {
+						who: bob().into(),
+						actual_fee: fees,
+						tip: 0,
+					},
+				),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo { weight: transfer_weight, ..Default::default() },
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Withdraw {
+					who: alice().into(),
+					amount: fees,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+					from: alice().into(),
+					to: bob().into(),
+					amount: 15 * DOLLARS,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Balances(pallet_balances::Event::Deposit {
+					who: pallet_treasury::Pallet::<Runtime>::account_id(),
+					amount: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::Treasury(pallet_treasury::Event::Deposit {
+					value: fees * 8 / 10,
+				}),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::TransactionPayment(
+					pallet_transaction_payment::Event::TransactionFeePaid {
+						who: alice().into(),
+						actual_fee: fees,
+						tip: 0,
+					},
+				),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo { weight: transfer_weight, ..Default::default() },
+				}),
+				topics: vec![],
+			},
+		];
+		assert_eq!(System::events(), events);
+	});
+}
+
+#[test]
+fn full_wasm_block_import_works() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	let (block1, block2) = blocks();
+
+	let mut alice_last_known_balance: Balance = Default::default();
+	let mut fees = t.execute_with(|| transfer_fee(&xt()));
+
+	executor_call(&mut t, "Core_execute_block", &block1.0, false).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 169 * DOLLARS);
+		alice_last_known_balance = Balances::total_balance(&alice());
+	});
+
+	fees = t.execute_with(|| transfer_fee(&xt()));
+
+	executor_call(&mut t, "Core_execute_block", &block2.0, false).0.unwrap();
+
+	t.execute_with(|| {
+		assert_eq!(
+			Balances::total_balance(&alice()),
+			alice_last_known_balance - 10 * DOLLARS - fees,
+		);
+		assert_eq!(Balances::total_balance(&bob()), 179 * DOLLARS - 1 * fees);
+	});
+}
+
+const CODE_TRANSFER: &str = r#"
+(module
+;; seal_call(
+;;    callee_ptr: u32,
+;;    callee_len: u32,
+;;    gas: u64,
+;;    value_ptr: u32,
+;;    value_len: u32,
+;;    input_data_ptr: u32,
+;;    input_data_len: u32,
+;;    output_ptr: u32,
+;;    output_len_ptr: u32
+;; ) -> u32
+(import "seal0" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+(import "env" "memory" (memory 1 1))
+(func (export "deploy")
+)
+(func (export "call")
+	(block $fail
+		;; Load input data to contract memory
+		(call $seal_input
+			(i32.const 0)
+			(i32.const 52)
+		)
+
+		;; fail if the input size is not != 4
+		(br_if $fail
+			(i32.ne
+				(i32.const 4)
+				(i32.load (i32.const 52))
+			)
+		)
+
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 0))
+				(i32.const 0)
+			)
+		)
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 1))
+				(i32.const 1)
+			)
+		)
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 2))
+				(i32.const 2)
+			)
+		)
+		(br_if $fail
+			(i32.ne
+				(i32.load8_u (i32.const 3))
+				(i32.const 3)
+			)
+		)
+
+		(drop
+			(call $seal_call
+				(i32.const 4)  ;; Pointer to "callee" address.
+				(i32.const 32)  ;; Length of "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 36)  ;; Pointer to the buffer with value to transfer
+				(i32.const 16)   ;; Length of the buffer with value to transfer.
+				(i32.const 0)   ;; Pointer to input data buffer address
+				(i32.const 0)   ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		)
+
+		(return)
+	)
+	unreachable
+)
+;; Destination AccountId to transfer the funds.
+;; Represented by H256 (32 bytes long) in little endian.
+(data (i32.const 4)
+	"\09\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	"\00\00\00\00"
+)
+;; Amount of value to transfer.
+;; Represented by u128 (16 bytes long) in little endian.
+(data (i32.const 36)
+	"\06\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	"\00\00"
+)
+;; Length of the input buffer
+(data (i32.const 52) "\04")
+)
+"#;
+
+#[test]
+fn deploying_wasm_contract_should_work() {
+	let transfer_code = wat::parse_str(CODE_TRANSFER).unwrap();
+	let transfer_ch = <Runtime as frame_system::Config>::Hashing::hash(&transfer_code);
+
+	let addr =
+		pallet_contracts::Pallet::<Runtime>::contract_address(&charlie(), &transfer_ch, &[], &[]);
+
+	let time = 42 * 1000;
+	let b = construct_block(
+		&mut new_test_ext(compact_code_unwrap()),
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time }),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(0, 0))),
+				function: RuntimeCall::Contracts(pallet_contracts::Call::instantiate_with_code::<
+					Runtime,
+				> {
+					value: 0,
+					gas_limit: Weight::from_parts(500_000_000, 0),
+					storage_deposit_limit: None,
+					code: transfer_code,
+					data: Vec::new(),
+					salt: Vec::new(),
+				}),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(1, 0))),
+				function: RuntimeCall::Contracts(pallet_contracts::Call::call::<Runtime> {
+					dest: sp_runtime::MultiAddress::Id(addr.clone()),
+					value: 10,
+					gas_limit: Weight::from_parts(500_000_000, 0),
+					storage_deposit_limit: None,
+					data: vec![0x00, 0x01, 0x02, 0x03],
+				}),
+			},
+		],
+		(time / SLOT_DURATION).into(),
+	);
+
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	executor_call(&mut t, "Core_execute_block", &b.0, false).0.unwrap();
+
+	t.execute_with(|| {
+		// Verify that the contract does exist by querying some of its storage items
+		// It does not matter that the storage item itself does not exist.
+		assert!(&pallet_contracts::Pallet::<Runtime>::get_storage(addr, vec![]).is_ok());
+	});
+}
+
+#[test]
+fn wasm_big_block_import_fails() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	set_heap_pages(&mut t.ext(), 4);
+
+	let result =
+		executor_call(&mut t, "Core_execute_block", &block_with_size(42, 0, 120_000).0, false).0;
+	assert!(result.is_err()); // Err(Wasmi(Trap(Trap { kind: Host(AllocatorOutOfSpace) })))
+}
+
+#[test]
+fn native_big_block_import_succeeds() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	executor_call(&mut t, "Core_execute_block", &block_with_size(42, 0, 120_000).0, true)
+		.0
+		.unwrap();
+}
+
+#[test]
+fn native_big_block_import_fails_on_fallback() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	// We set the heap pages to 8 because we know that should give an OOM in WASM with the given
+	// block.
+	set_heap_pages(&mut t.ext(), 8);
+
+	assert!(
+		executor_call(&mut t, "Core_execute_block", &block_with_size(42, 0, 120_000).0, false,)
+			.0
+			.is_err()
+	);
+}
+
+#[test]
+fn panic_execution_gives_error() {
+	let mut t = new_test_ext(bloaty_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			data: (0 * DOLLARS, 0u128, 0u128, 0u128),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(), 0_u128.encode());
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r = executor_call(
+		&mut t,
+		"Core_initialize_block",
+		&vec![].and(&from_block_number(1u32)),
+		false,
+	)
+	.0;
+	assert!(r.is_ok());
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), false)
+		.0
+		.unwrap();
+	let r = ApplyExtrinsicResult::decode(&mut &r[..]).unwrap();
+	assert_eq!(r, Err(InvalidTransaction::Payment.into()));
+}
+
+#[test]
+fn successful_execution_gives_ok() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(alice()),
+		AccountInfo::<<Runtime as frame_system::Config>::Nonce, _> {
+			providers: 1,
+			data: (111 * DOLLARS, 0u128, 0u128, 1u128 << 127),
+			..Default::default()
+		}
+		.encode(),
+	);
+	t.insert(
+		<frame_system::Account<Runtime>>::hashed_key_for(bob()),
+		AccountInfo::<
+			<Runtime as frame_system::Config>::Nonce,
+			<Runtime as frame_system::Config>::AccountData,
+		>::default()
+		.encode(),
+	);
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(111 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let r = executor_call(
+		&mut t,
+		"Core_initialize_block",
+		&vec![].and(&from_block_number(1u32)),
+		false,
+	)
+	.0;
+	assert!(r.is_ok());
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 111 * DOLLARS);
+	});
+
+	let fees = t.execute_with(|| transfer_fee(&xt()));
+
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt()), false)
+		.0
+		.unwrap();
+	ApplyExtrinsicResult::decode(&mut &r[..])
+		.unwrap()
+		.expect("Extrinsic could not be applied")
+		.expect("Extrinsic failed");
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&alice()), 42 * DOLLARS - fees);
+		assert_eq!(Balances::total_balance(&bob()), 69 * DOLLARS);
+	});
+}
+
+#[test]
+fn should_import_block_with_test_client() {
+	use node_testing::client::{
+		sp_consensus::BlockOrigin, ClientBlockImportExt, TestClientBuilder, TestClientBuilderExt,
+	};
+
+	let mut client = TestClientBuilder::new().build();
+	let block1 = changes_trie_block();
+	let block_data = block1.0;
+	let block = node_primitives::Block::decode(&mut &block_data[..]).unwrap();
+
+	futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+}
diff --git a/substrate/bin/node/executor/tests/common.rs b/substrate/bin/node/executor/tests/common.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6ce9ea3a010909209834b071a710ce52a9cfe584
--- /dev/null
+++ b/substrate/bin/node/executor/tests/common.rs
@@ -0,0 +1,195 @@
+// 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 codec::{Decode, Encode};
+use frame_support::Hashable;
+use frame_system::offchain::AppCrypto;
+use sc_executor::{error::Result, NativeElseWasmExecutor, WasmExecutor};
+use sp_consensus_babe::{
+	digests::{PreDigest, SecondaryPlainPreDigest},
+	Slot, BABE_ENGINE_ID,
+};
+use sp_core::{
+	crypto::KeyTypeId,
+	sr25519::Signature,
+	traits::{CallContext, CodeExecutor, RuntimeCode},
+};
+use sp_runtime::{
+	traits::{BlakeTwo256, Header as HeaderT},
+	ApplyExtrinsicResult, Digest, DigestItem, MultiSignature, MultiSigner,
+};
+use sp_state_machine::TestExternalities as CoreTestExternalities;
+
+use kitchensink_runtime::{
+	constants::currency::*, Block, BuildStorage, CheckedExtrinsic, Header, Runtime,
+	UncheckedExtrinsic,
+};
+use node_executor::ExecutorDispatch;
+use node_primitives::{BlockNumber, Hash};
+use node_testing::keyring::*;
+use sp_externalities::Externalities;
+
+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};
+		app_crypto!(sr25519, TEST_KEY_TYPE_ID);
+	}
+
+	pub type AuthorityId = app_sr25519::Public;
+}
+
+pub struct TestAuthorityId;
+impl AppCrypto<MultiSigner, MultiSignature> for TestAuthorityId {
+	type RuntimeAppPublic = sr25519::AuthorityId;
+	type GenericSignature = Signature;
+	type GenericPublic = sp_core::sr25519::Public;
+}
+
+/// The wasm runtime code.
+///
+/// `compact` since it is after post-processing with wasm-gc which performs tree-shaking thus
+/// making the binary slimmer. There is a convention to use compact version of the runtime
+/// as canonical.
+pub fn compact_code_unwrap() -> &'static [u8] {
+	kitchensink_runtime::WASM_BINARY.expect(
+		"Development wasm binary is not available. Testing is only supported with the flag \
+		 disabled.",
+	)
+}
+
+pub const GENESIS_HASH: [u8; 32] = [69u8; 32];
+
+pub const SPEC_VERSION: u32 = kitchensink_runtime::VERSION.spec_version;
+
+pub const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_version;
+
+pub type TestExternalities<H> = CoreTestExternalities<H>;
+
+pub fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
+	node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH)
+}
+
+pub fn default_transfer_call() -> pallet_balances::Call<Runtime> {
+	pallet_balances::Call::<Runtime>::transfer_allow_death {
+		dest: bob().into(),
+		value: 69 * DOLLARS,
+	}
+}
+
+pub fn from_block_number(n: u32) -> Header {
+	Header::new(n, Default::default(), Default::default(), [69; 32].into(), Default::default())
+}
+
+pub fn executor() -> NativeElseWasmExecutor<ExecutorDispatch> {
+	NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build())
+}
+
+pub fn executor_call(
+	t: &mut TestExternalities<BlakeTwo256>,
+	method: &str,
+	data: &[u8],
+	use_native: bool,
+) -> (Result<Vec<u8>>, bool) {
+	let mut t = t.ext();
+
+	let code = t.storage(sp_core::storage::well_known_keys::CODE).unwrap();
+	let heap_pages = t.storage(sp_core::storage::well_known_keys::HEAP_PAGES);
+	let runtime_code = RuntimeCode {
+		code_fetcher: &sp_core::traits::WrappedRuntimeCode(code.as_slice().into()),
+		hash: sp_core::blake2_256(&code).to_vec(),
+		heap_pages: heap_pages.and_then(|hp| Decode::decode(&mut &hp[..]).ok()),
+	};
+	sp_tracing::try_init_simple();
+	executor().call(&mut t, &runtime_code, method, data, use_native, CallContext::Onchain)
+}
+
+pub fn new_test_ext(code: &[u8]) -> TestExternalities<BlakeTwo256> {
+	let ext = TestExternalities::new_with_code(
+		code,
+		node_testing::genesis::config(Some(code)).build_storage().unwrap(),
+	);
+	ext
+}
+
+/// Construct a fake block.
+///
+/// `extrinsics` must be a list of valid extrinsics, i.e. none of the extrinsics for example
+/// can report `ExhaustResources`. Otherwise, this function panics.
+pub fn construct_block(
+	env: &mut TestExternalities<BlakeTwo256>,
+	number: BlockNumber,
+	parent_hash: Hash,
+	extrinsics: Vec<CheckedExtrinsic>,
+	babe_slot: Slot,
+) -> (Vec<u8>, Hash) {
+	use sp_trie::{LayoutV1 as Layout, TrieConfiguration};
+
+	// sign extrinsics.
+	let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
+
+	// calculate the header fields that we can.
+	let extrinsics_root =
+		Layout::<BlakeTwo256>::ordered_trie_root(extrinsics.iter().map(Encode::encode))
+			.to_fixed_bytes()
+			.into();
+
+	let header = Header {
+		parent_hash,
+		number,
+		extrinsics_root,
+		state_root: Default::default(),
+		digest: Digest {
+			logs: vec![DigestItem::PreRuntime(
+				BABE_ENGINE_ID,
+				PreDigest::SecondaryPlain(SecondaryPlainPreDigest {
+					slot: babe_slot,
+					authority_index: 42,
+				})
+				.encode(),
+			)],
+		},
+	};
+
+	// execute the block to get the real header.
+	executor_call(env, "Core_initialize_block", &header.encode(), true).0.unwrap();
+
+	for extrinsic in extrinsics.iter() {
+		// Try to apply the `extrinsic`. It should be valid, in the sense that it passes
+		// all pre-inclusion checks.
+		let r = executor_call(env, "BlockBuilder_apply_extrinsic", &extrinsic.encode(), true)
+			.0
+			.expect("application of an extrinsic failed");
+
+		match ApplyExtrinsicResult::decode(&mut &r[..])
+			.expect("apply result deserialization failed")
+		{
+			Ok(_) => {},
+			Err(e) => panic!("Applying extrinsic failed: {:?}", e),
+		}
+	}
+
+	let header = Header::decode(
+		&mut &executor_call(env, "BlockBuilder_finalize_block", &[0u8; 0], true).0.unwrap()[..],
+	)
+	.unwrap();
+
+	let hash = header.blake2_256();
+	(Block { header, extrinsics }.encode(), hash.into())
+}
diff --git a/substrate/bin/node/executor/tests/fees.rs b/substrate/bin/node/executor/tests/fees.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7519ce6e8b1b47b9cfc6eee9d87c52ef8ae25cc3
--- /dev/null
+++ b/substrate/bin/node/executor/tests/fees.rs
@@ -0,0 +1,323 @@
+// 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 codec::{Encode, Joiner};
+use frame_support::{
+	dispatch::GetDispatchInfo,
+	traits::Currency,
+	weights::{constants::ExtrinsicBaseWeight, IdentityFee, WeightToFee},
+};
+use kitchensink_runtime::{
+	constants::{currency::*, time::SLOT_DURATION},
+	Balances, CheckedExtrinsic, Multiplier, Runtime, RuntimeCall, TransactionByteFee,
+	TransactionPayment,
+};
+use node_primitives::Balance;
+use node_testing::keyring::*;
+use sp_runtime::{traits::One, Perbill};
+
+pub mod common;
+use self::common::{sign, *};
+
+#[test]
+fn fee_multiplier_increases_and_decreases_on_big_weight() {
+	let mut t = new_test_ext(compact_code_unwrap());
+
+	// initial fee multiplier must be one.
+	let mut prev_multiplier = Multiplier::one();
+
+	t.execute_with(|| {
+		assert_eq!(TransactionPayment::next_fee_multiplier(), prev_multiplier);
+	});
+
+	let mut tt = new_test_ext(compact_code_unwrap());
+
+	let time1 = 42 * 1000;
+	// big one in terms of weight.
+	let block1 = construct_block(
+		&mut tt,
+		1,
+		GENESIS_HASH.into(),
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time1 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(0, 0))),
+				function: RuntimeCall::Sudo(pallet_sudo::Call::sudo {
+					call: Box::new(RuntimeCall::RootTesting(
+						pallet_root_testing::Call::fill_block { ratio: Perbill::from_percent(60) },
+					)),
+				}),
+			},
+		],
+		(time1 / SLOT_DURATION).into(),
+	);
+
+	let time2 = 52 * 1000;
+	// small one in terms of weight.
+	let block2 = construct_block(
+		&mut tt,
+		2,
+		block1.1,
+		vec![
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time2 }),
+			},
+			CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(1, 0))),
+				function: RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 1] }),
+			},
+		],
+		(time2 / SLOT_DURATION).into(),
+	);
+
+	println!(
+		"++ Block 1 size: {} / Block 2 size {}",
+		block1.0.encode().len(),
+		block2.0.encode().len(),
+	);
+
+	// execute a big block.
+	executor_call(&mut t, "Core_execute_block", &block1.0, true).0.unwrap();
+
+	// weight multiplier is increased for next block.
+	t.execute_with(|| {
+		let fm = TransactionPayment::next_fee_multiplier();
+		println!("After a big block: {:?} -> {:?}", prev_multiplier, fm);
+		assert!(fm > prev_multiplier);
+		prev_multiplier = fm;
+	});
+
+	// execute a big block.
+	executor_call(&mut t, "Core_execute_block", &block2.0, true).0.unwrap();
+
+	// weight multiplier is increased for next block.
+	t.execute_with(|| {
+		let fm = TransactionPayment::next_fee_multiplier();
+		println!("After a small block: {:?} -> {:?}", prev_multiplier, fm);
+		assert!(fm < prev_multiplier);
+	});
+}
+
+fn new_account_info(free_dollars: u128) -> Vec<u8> {
+	frame_system::AccountInfo {
+		nonce: 0u32,
+		consumers: 0,
+		providers: 1,
+		sufficients: 0,
+		data: (free_dollars * DOLLARS, 0 * DOLLARS, 0 * DOLLARS, 1u128 << 127),
+	}
+	.encode()
+}
+
+#[test]
+fn transaction_fee_is_correct() {
+	// This uses the exact values of substrate-node.
+	//
+	// weight of transfer call as of now: 1_000_000
+	// if weight of the cheapest weight would be 10^7, this would be 10^9, which is:
+	//   - 1 MILLICENTS in substrate node.
+	//   - 1 milli-dot based on current polkadot runtime.
+	// (this baed on assigning 0.1 CENT to the cheapest tx with `weight = 100`)
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.insert(<frame_system::Account<Runtime>>::hashed_key_for(alice()), new_account_info(100));
+	t.insert(<frame_system::Account<Runtime>>::hashed_key_for(bob()), new_account_info(10));
+	t.insert(
+		<pallet_balances::TotalIssuance<Runtime>>::hashed_key().to_vec(),
+		(110 * DOLLARS).encode(),
+	);
+	t.insert(<frame_system::BlockHash<Runtime>>::hashed_key_for(0), vec![0u8; 32]);
+
+	let tip = 1_000_000;
+	let xt = sign(CheckedExtrinsic {
+		signed: Some((alice(), signed_extra(0, tip))),
+		function: RuntimeCall::Balances(default_transfer_call()),
+	});
+
+	let r =
+		executor_call(&mut t, "Core_initialize_block", &vec![].and(&from_block_number(1u32)), true)
+			.0;
+
+	assert!(r.is_ok());
+	let r = executor_call(&mut t, "BlockBuilder_apply_extrinsic", &vec![].and(&xt.clone()), true).0;
+	assert!(r.is_ok());
+
+	t.execute_with(|| {
+		assert_eq!(Balances::total_balance(&bob()), (10 + 69) * DOLLARS);
+		// Components deducted from alice's balances:
+		// - Base fee
+		// - Weight fee
+		// - Length fee
+		// - Tip
+		// - Creation-fee of bob's account.
+		let mut balance_alice = (100 - 69) * DOLLARS;
+
+		let base_weight = ExtrinsicBaseWeight::get();
+		let base_fee = IdentityFee::<Balance>::weight_to_fee(&base_weight);
+
+		let length_fee = TransactionByteFee::get() * (xt.clone().encode().len() as Balance);
+		balance_alice -= length_fee;
+
+		let weight = default_transfer_call().get_dispatch_info().weight;
+		let weight_fee = IdentityFee::<Balance>::weight_to_fee(&weight);
+
+		// we know that weight to fee multiplier is effect-less in block 1.
+		// current weight of transfer = 200_000_000
+		// Linear weight to fee is 1:1 right now (1 weight = 1 unit of balance)
+		assert_eq!(weight_fee, weight.ref_time() as Balance);
+		balance_alice -= base_fee;
+		balance_alice -= weight_fee;
+		balance_alice -= tip;
+
+		assert_eq!(Balances::total_balance(&alice()), balance_alice);
+	});
+}
+
+#[test]
+#[should_panic]
+#[cfg(feature = "stress-test")]
+fn block_weight_capacity_report() {
+	// Just report how many transfer calls you could fit into a block. The number should at least
+	// be a few hundred (250 at the time of writing but can change over time). Runs until panic.
+	use node_primitives::Nonce;
+
+	// execution ext.
+	let mut t = new_test_ext(compact_code_unwrap());
+	// setup ext.
+	let mut tt = new_test_ext(compact_code_unwrap());
+
+	let factor = 50;
+	let mut time = 10;
+	let mut nonce: Nonce = 0;
+	let mut block_number = 1;
+	let mut previous_hash: node_primitives::Hash = GENESIS_HASH.into();
+
+	loop {
+		let num_transfers = block_number * factor;
+		let mut xts = (0..num_transfers)
+			.map(|i| CheckedExtrinsic {
+				signed: Some((charlie(), signed_extra(nonce + i as Nonce, 0))),
+				function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: bob().into(),
+					value: 0,
+				}),
+			})
+			.collect::<Vec<CheckedExtrinsic>>();
+
+		xts.insert(
+			0,
+			CheckedExtrinsic {
+				signed: None,
+				function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: time * 1000 }),
+			},
+		);
+
+		// NOTE: this is super slow. Can probably be improved.
+		let block = construct_block(
+			&mut tt,
+			block_number,
+			previous_hash,
+			xts,
+			(time * 1000 / SLOT_DURATION).into(),
+		);
+
+		let len = block.0.len();
+		print!(
+			"++ Executing block with {} transfers. Block size = {} bytes / {} kb / {} mb",
+			num_transfers,
+			len,
+			len / 1024,
+			len / 1024 / 1024,
+		);
+
+		let r = executor_call(&mut t, "Core_execute_block", &block.0, true).0;
+
+		println!(" || Result = {:?}", r);
+		assert!(r.is_ok());
+
+		previous_hash = block.1;
+		nonce += num_transfers;
+		time += 10;
+		block_number += 1;
+	}
+}
+
+#[test]
+#[should_panic]
+#[cfg(feature = "stress-test")]
+fn block_length_capacity_report() {
+	// Just report how big a block can get. Executes until panic. Should be ignored unless if
+	// manually inspected. The number should at least be a few megabytes (5 at the time of
+	// writing but can change over time).
+	use node_primitives::Nonce;
+
+	// execution ext.
+	let mut t = new_test_ext(compact_code_unwrap());
+	// setup ext.
+	let mut tt = new_test_ext(compact_code_unwrap());
+
+	let factor = 256 * 1024;
+	let mut time = 10;
+	let mut nonce: Nonce = 0;
+	let mut block_number = 1;
+	let mut previous_hash: node_primitives::Hash = GENESIS_HASH.into();
+
+	loop {
+		// NOTE: this is super slow. Can probably be improved.
+		let block = construct_block(
+			&mut tt,
+			block_number,
+			previous_hash,
+			vec![
+				CheckedExtrinsic {
+					signed: None,
+					function: RuntimeCall::Timestamp(pallet_timestamp::Call::set {
+						now: time * 1000,
+					}),
+				},
+				CheckedExtrinsic {
+					signed: Some((charlie(), signed_extra(nonce, 0))),
+					function: RuntimeCall::System(frame_system::Call::remark {
+						remark: vec![0u8; (block_number * factor) as usize],
+					}),
+				},
+			],
+			(time * 1000 / SLOT_DURATION).into(),
+		);
+
+		let len = block.0.len();
+		print!(
+			"++ Executing block with big remark. Block size = {} bytes / {} kb / {} mb",
+			len,
+			len / 1024,
+			len / 1024 / 1024,
+		);
+
+		let r = executor_call(&mut t, "Core_execute_block", &block.0, true).0;
+
+		println!(" || Result = {:?}", r);
+		assert!(r.is_ok());
+
+		previous_hash = block.1;
+		nonce += 1;
+		time += 10;
+		block_number += 1;
+	}
+}
diff --git a/substrate/bin/node/executor/tests/submit_transaction.rs b/substrate/bin/node/executor/tests/submit_transaction.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7678a3c6e5a9fc9e7d0060bd57a5de0239fc3129
--- /dev/null
+++ b/substrate/bin/node/executor/tests/submit_transaction.rs
@@ -0,0 +1,259 @@
+// 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 codec::Decode;
+use frame_system::offchain::{SendSignedTransaction, Signer, SubmitTransaction};
+use kitchensink_runtime::{Executive, Indices, Runtime, UncheckedExtrinsic};
+use sp_application_crypto::AppCrypto;
+use sp_core::offchain::{testing::TestTransactionPoolExt, TransactionPoolExt};
+use sp_keyring::sr25519::Keyring::Alice;
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+
+pub mod common;
+use self::common::*;
+
+#[test]
+fn should_submit_unsigned_transaction() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	t.execute_with(|| {
+		let signature =
+			pallet_im_online::sr25519::AuthoritySignature::try_from(vec![0; 64]).unwrap();
+		let heartbeat_data = pallet_im_online::Heartbeat {
+			block_number: 1,
+			session_index: 1,
+			authority_index: 0,
+			validators_len: 0,
+		};
+
+		let call = pallet_im_online::Call::heartbeat { heartbeat: heartbeat_data, signature };
+		SubmitTransaction::<Runtime, pallet_im_online::Call<Runtime>>::submit_unsigned_transaction(
+			call.into(),
+		)
+		.unwrap();
+
+		assert_eq!(state.read().transactions.len(), 1)
+	});
+}
+
+const PHRASE: &str = "news slush supreme milk chapter athlete soap sausage put clutch what kitten";
+
+#[test]
+fn should_submit_signed_transaction() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter2", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter3", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let results =
+			Signer::<Runtime, TestAuthorityId>::all_accounts().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+
+		let len = results.len();
+		assert_eq!(len, 3);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+		assert_eq!(state.read().transactions.len(), len);
+	});
+}
+
+#[test]
+fn should_submit_signed_twice_from_the_same_account() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter2", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let result =
+			Signer::<Runtime, TestAuthorityId>::any_account().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+
+		assert!(result.is_some());
+		assert_eq!(state.read().transactions.len(), 1);
+
+		// submit another one from the same account. The nonce should be incremented.
+		let result =
+			Signer::<Runtime, TestAuthorityId>::any_account().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+
+		assert!(result.is_some());
+		assert_eq!(state.read().transactions.len(), 2);
+
+		// now check that the transaction nonces are not equal
+		let s = state.read();
+		fn nonce(tx: UncheckedExtrinsic) -> frame_system::CheckNonce<Runtime> {
+			let extra = tx.signature.unwrap().2;
+			extra.5
+		}
+		let nonce1 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[0]).unwrap());
+		let nonce2 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[1]).unwrap());
+		assert!(nonce1 != nonce2, "Transactions should have different nonces. Got: {:?}", nonce1);
+	});
+}
+
+#[test]
+fn should_submit_signed_twice_from_all_accounts() {
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter2", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let results = Signer::<Runtime, TestAuthorityId>::all_accounts()
+			.send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death { dest: Alice.to_account_id().into(), value: Default::default() }
+			});
+
+		let len = results.len();
+		assert_eq!(len, 2);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+		assert_eq!(state.read().transactions.len(), 2);
+
+		// submit another one from the same account. The nonce should be incremented.
+		let results = Signer::<Runtime, TestAuthorityId>::all_accounts()
+			.send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death { dest: Alice.to_account_id().into(), value: Default::default() }
+			});
+
+		let len = results.len();
+		assert_eq!(len, 2);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+		assert_eq!(state.read().transactions.len(), 4);
+
+		// now check that the transaction nonces are not equal
+		let s = state.read();
+		fn nonce(tx: UncheckedExtrinsic) -> frame_system::CheckNonce<Runtime> {
+			let extra = tx.signature.unwrap().2;
+			extra.5
+		}
+		let nonce1 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[0]).unwrap());
+		let nonce2 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[1]).unwrap());
+		let nonce3 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[2]).unwrap());
+		let nonce4 = nonce(UncheckedExtrinsic::decode(&mut &*s.transactions[3]).unwrap());
+		assert!(
+			nonce1 != nonce3,
+			"Transactions should have different nonces. Got: 1st tx nonce: {:?}, 2nd nonce: {:?}", nonce1, nonce3
+		);
+		assert!(
+			nonce2 != nonce4,
+			"Transactions should have different nonces. Got: 1st tx nonce: {:?}, 2nd tx nonce: {:?}", nonce2, nonce4
+		);
+	});
+}
+
+#[test]
+fn submitted_transaction_should_be_valid() {
+	use codec::Encode;
+	use sp_runtime::{
+		traits::StaticLookup,
+		transaction_validity::{TransactionSource, TransactionTag},
+	};
+
+	let mut t = new_test_ext(compact_code_unwrap());
+	let (pool, state) = TestTransactionPoolExt::new();
+	t.register_extension(TransactionPoolExt::new(pool));
+
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(sr25519::AuthorityId::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+	t.register_extension(KeystoreExt::new(keystore));
+
+	t.execute_with(|| {
+		let results =
+			Signer::<Runtime, TestAuthorityId>::all_accounts().send_signed_transaction(|_| {
+				pallet_balances::Call::transfer_allow_death {
+					dest: Alice.to_account_id().into(),
+					value: Default::default(),
+				}
+			});
+		let len = results.len();
+		assert_eq!(len, 1);
+		assert_eq!(results.into_iter().filter_map(|x| x.1.ok()).count(), len);
+	});
+
+	// check that transaction is valid, but reset environment storage,
+	// since CreateTransaction increments the nonce
+	let tx0 = state.read().transactions[0].clone();
+	let mut t = new_test_ext(compact_code_unwrap());
+	t.execute_with(|| {
+		let source = TransactionSource::External;
+		let extrinsic = UncheckedExtrinsic::decode(&mut &*tx0).unwrap();
+		// add balance to the account
+		let author = extrinsic.signature.clone().unwrap().0;
+		let address = Indices::lookup(author).unwrap();
+		let data = pallet_balances::AccountData { free: 5_000_000_000_000, ..Default::default() };
+		let account = frame_system::AccountInfo { data, ..Default::default() };
+		<frame_system::Account<Runtime>>::insert(&address, account);
+
+		// check validity
+		let res = Executive::validate_transaction(
+			source,
+			extrinsic,
+			frame_system::BlockHash::<Runtime>::get(0),
+		)
+		.unwrap();
+
+		// We ignore res.priority since this number can change based on updates to weights and such.
+		assert_eq!(res.requires, Vec::<TransactionTag>::new());
+		assert_eq!(res.provides, vec![(address, 0).encode()]);
+		assert_eq!(res.longevity, 2047);
+		assert_eq!(res.propagate, true);
+	});
+}
diff --git a/substrate/bin/node/inspect/Cargo.toml b/substrate/bin/node/inspect/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..41894fb60e8102e58e1dee4c33b7ab30cc09813a
--- /dev/null
+++ b/substrate/bin/node/inspect/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "node-inspect"
+version = "0.9.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node block inspection tool."
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+thiserror = "1.0"
+sc-cli = { version = "0.10.0-dev", path = "../../../client/cli" }
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api" }
+sc-service = { version = "0.10.0-dev", default-features = false, path = "../../../client/service" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
diff --git a/substrate/bin/node/inspect/src/cli.rs b/substrate/bin/node/inspect/src/cli.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c02a9c61d1ef6f6530be750d2f65ef8edcec7cf9
--- /dev/null
+++ b/substrate/bin/node/inspect/src/cli.rs
@@ -0,0 +1,62 @@
+// 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/>.
+
+//! Structs to easily compose inspect sub-command for CLI.
+
+use sc_cli::{ImportParams, SharedParams};
+
+/// The `inspect` command used to print decoded chain data.
+#[derive(Debug, clap::Parser)]
+pub struct InspectCmd {
+	#[allow(missing_docs)]
+	#[clap(subcommand)]
+	pub command: InspectSubCmd,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+}
+
+/// A possible inspect sub-commands.
+#[derive(Debug, clap::Subcommand)]
+pub enum InspectSubCmd {
+	/// Decode block with native version of runtime and print out the details.
+	Block {
+		/// Address of the block to print out.
+		///
+		/// Can be either a block hash (no 0x prefix) or a number to retrieve existing block,
+		/// or a 0x-prefixed bytes hex string, representing SCALE encoding of
+		/// a block.
+		#[arg(value_name = "HASH or NUMBER or BYTES")]
+		input: String,
+	},
+	/// Decode extrinsic with native version of runtime and print out the details.
+	Extrinsic {
+		/// Address of an extrinsic to print out.
+		///
+		/// Can be either a block hash (no 0x prefix) or number and the index, in the form
+		/// of `{block}:{index}` or a 0x-prefixed bytes hex string,
+		/// representing SCALE encoding of an extrinsic.
+		#[arg(value_name = "BLOCK:INDEX or BYTES")]
+		input: String,
+	},
+}
diff --git a/substrate/bin/node/inspect/src/command.rs b/substrate/bin/node/inspect/src/command.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dcecfd788264466b408e4ec466d675cb97781905
--- /dev/null
+++ b/substrate/bin/node/inspect/src/command.rs
@@ -0,0 +1,66 @@
+// 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/>.
+
+//! Command ran by the CLI
+
+use crate::{
+	cli::{InspectCmd, InspectSubCmd},
+	Inspector,
+};
+use sc_cli::{CliConfiguration, ImportParams, Result, SharedParams};
+use sc_service::{Configuration, NativeExecutionDispatch};
+use sp_runtime::traits::Block;
+
+impl InspectCmd {
+	/// Run the inspect command, passing the inspector.
+	pub fn run<B, RA, D>(&self, config: Configuration) -> Result<()>
+	where
+		B: Block,
+		RA: Send + Sync + 'static,
+		D: NativeExecutionDispatch + 'static,
+	{
+		let executor = sc_service::new_native_or_wasm_executor::<D>(&config);
+		let client = sc_service::new_full_client::<B, RA, _>(&config, None, executor)?;
+		let inspect = Inspector::<B>::new(client);
+
+		match &self.command {
+			InspectSubCmd::Block { input } => {
+				let input = input.parse()?;
+				let res = inspect.block(input).map_err(|e| e.to_string())?;
+				println!("{res}");
+				Ok(())
+			},
+			InspectSubCmd::Extrinsic { input } => {
+				let input = input.parse()?;
+				let res = inspect.extrinsic(input).map_err(|e| e.to_string())?;
+				println!("{res}");
+				Ok(())
+			},
+		}
+	}
+}
+
+impl CliConfiguration for InspectCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+}
diff --git a/substrate/bin/node/inspect/src/lib.rs b/substrate/bin/node/inspect/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..65dfecdf77a2d620276b8b15a12f9a3f4623c5b0
--- /dev/null
+++ b/substrate/bin/node/inspect/src/lib.rs
@@ -0,0 +1,311 @@
+// 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/>.
+
+//! A CLI extension for substrate node, adding sub-command to pretty print debug info
+//! about blocks and extrinsics.
+//!
+//! The blocks and extrinsics can either be retrieved from the database (on-chain),
+//! or a raw SCALE-encoding can be provided.
+
+#![warn(missing_docs)]
+
+pub mod cli;
+pub mod command;
+
+use codec::{Decode, Encode};
+use sc_client_api::BlockBackend;
+use sp_blockchain::HeaderBackend;
+use sp_core::hexdisplay::HexDisplay;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block, Hash, HashingFor, NumberFor},
+};
+use std::{fmt, fmt::Debug, marker::PhantomData, str::FromStr};
+
+/// A helper type for a generic block input.
+pub type BlockAddressFor<TBlock> =
+	BlockAddress<<HashingFor<TBlock> as Hash>::Output, NumberFor<TBlock>>;
+
+/// A Pretty formatter implementation.
+pub trait PrettyPrinter<TBlock: Block> {
+	/// Nicely format block.
+	fn fmt_block(&self, fmt: &mut fmt::Formatter, block: &TBlock) -> fmt::Result;
+	/// Nicely format extrinsic.
+	fn fmt_extrinsic(&self, fmt: &mut fmt::Formatter, extrinsic: &TBlock::Extrinsic)
+		-> fmt::Result;
+}
+
+/// Default dummy debug printer.
+#[derive(Default)]
+pub struct DebugPrinter;
+impl<TBlock: Block> PrettyPrinter<TBlock> for DebugPrinter {
+	fn fmt_block(&self, fmt: &mut fmt::Formatter, block: &TBlock) -> fmt::Result {
+		writeln!(fmt, "Header:")?;
+		writeln!(fmt, "{:?}", block.header())?;
+		writeln!(fmt, "Block bytes: {:?}", HexDisplay::from(&block.encode()))?;
+		writeln!(fmt, "Extrinsics ({})", block.extrinsics().len())?;
+		for (idx, ex) in block.extrinsics().iter().enumerate() {
+			writeln!(fmt, "- {}:", idx)?;
+			<DebugPrinter as PrettyPrinter<TBlock>>::fmt_extrinsic(self, fmt, ex)?;
+		}
+		Ok(())
+	}
+
+	fn fmt_extrinsic(
+		&self,
+		fmt: &mut fmt::Formatter,
+		extrinsic: &TBlock::Extrinsic,
+	) -> fmt::Result {
+		writeln!(fmt, " {:#?}", extrinsic)?;
+		writeln!(fmt, " Bytes: {:?}", HexDisplay::from(&extrinsic.encode()))?;
+		Ok(())
+	}
+}
+
+/// Aggregated error for `Inspector` operations.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Could not decode Block or Extrinsic.
+	#[error(transparent)]
+	Codec(#[from] codec::Error),
+	/// Error accessing blockchain DB.
+	#[error(transparent)]
+	Blockchain(#[from] sp_blockchain::Error),
+	/// Given block has not been found.
+	#[error("{0}")]
+	NotFound(String),
+}
+
+/// A helper trait to access block headers and bodies.
+pub trait ChainAccess<TBlock: Block>: HeaderBackend<TBlock> + BlockBackend<TBlock> {}
+
+impl<T, TBlock> ChainAccess<TBlock> for T
+where
+	TBlock: Block,
+	T: sp_blockchain::HeaderBackend<TBlock> + sc_client_api::BlockBackend<TBlock>,
+{
+}
+
+/// Blockchain inspector.
+pub struct Inspector<TBlock: Block, TPrinter: PrettyPrinter<TBlock> = DebugPrinter> {
+	printer: TPrinter,
+	chain: Box<dyn ChainAccess<TBlock>>,
+	_block: PhantomData<TBlock>,
+}
+
+impl<TBlock: Block, TPrinter: PrettyPrinter<TBlock>> Inspector<TBlock, TPrinter> {
+	/// Create new instance of the inspector with default printer.
+	pub fn new(chain: impl ChainAccess<TBlock> + 'static) -> Self
+	where
+		TPrinter: Default,
+	{
+		Self::with_printer(chain, Default::default())
+	}
+
+	/// Customize pretty-printing of the data.
+	pub fn with_printer(chain: impl ChainAccess<TBlock> + 'static, printer: TPrinter) -> Self {
+		Inspector { chain: Box::new(chain) as _, printer, _block: Default::default() }
+	}
+
+	/// Get a pretty-printed block.
+	pub fn block(&self, input: BlockAddressFor<TBlock>) -> Result<String, Error> {
+		struct BlockPrinter<'a, A, B>(A, &'a B);
+		impl<'a, A: Block, B: PrettyPrinter<A>> fmt::Display for BlockPrinter<'a, A, B> {
+			fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+				self.1.fmt_block(fmt, &self.0)
+			}
+		}
+
+		let block = self.get_block(input)?;
+		Ok(format!("{}", BlockPrinter(block, &self.printer)))
+	}
+
+	fn get_block(&self, input: BlockAddressFor<TBlock>) -> Result<TBlock, Error> {
+		Ok(match input {
+			BlockAddress::Bytes(bytes) => TBlock::decode(&mut &*bytes)?,
+			BlockAddress::Number(number) => {
+				let id = BlockId::number(number);
+				let hash = self.chain.expect_block_hash_from_id(&id)?;
+				let not_found = format!("Could not find block {:?}", id);
+				let body = self
+					.chain
+					.block_body(hash)?
+					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				let header =
+					self.chain.header(hash)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				TBlock::new(header, body)
+			},
+			BlockAddress::Hash(hash) => {
+				let not_found = format!("Could not find block {:?}", BlockId::<TBlock>::Hash(hash));
+				let body = self
+					.chain
+					.block_body(hash)?
+					.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				let header =
+					self.chain.header(hash)?.ok_or_else(|| Error::NotFound(not_found.clone()))?;
+				TBlock::new(header, body)
+			},
+		})
+	}
+
+	/// Get a pretty-printed extrinsic.
+	pub fn extrinsic(
+		&self,
+		input: ExtrinsicAddress<<HashingFor<TBlock> as Hash>::Output, NumberFor<TBlock>>,
+	) -> Result<String, Error> {
+		struct ExtrinsicPrinter<'a, A: Block, B>(A::Extrinsic, &'a B);
+		impl<'a, A: Block, B: PrettyPrinter<A>> fmt::Display for ExtrinsicPrinter<'a, A, B> {
+			fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+				self.1.fmt_extrinsic(fmt, &self.0)
+			}
+		}
+
+		let ext = match input {
+			ExtrinsicAddress::Block(block, index) => {
+				let block = self.get_block(block)?;
+				block.extrinsics().get(index).cloned().ok_or_else(|| {
+					Error::NotFound(format!(
+						"Could not find extrinsic {} in block {:?}",
+						index, block
+					))
+				})?
+			},
+			ExtrinsicAddress::Bytes(bytes) => TBlock::Extrinsic::decode(&mut &*bytes)?,
+		};
+
+		Ok(format!("{}", ExtrinsicPrinter(ext, &self.printer)))
+	}
+}
+
+/// A block to retrieve.
+#[derive(Debug, Clone, PartialEq)]
+pub enum BlockAddress<Hash, Number> {
+	/// Get block by hash.
+	Hash(Hash),
+	/// Get block by number.
+	Number(Number),
+	/// Raw SCALE-encoded bytes.
+	Bytes(Vec<u8>),
+}
+
+impl<Hash: FromStr, Number: FromStr> FromStr for BlockAddress<Hash, Number> {
+	type Err = String;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		// try to parse hash first
+		if let Ok(hash) = s.parse() {
+			return Ok(Self::Hash(hash))
+		}
+
+		// then number
+		if let Ok(number) = s.parse() {
+			return Ok(Self::Number(number))
+		}
+
+		// then assume it's bytes (hex-encoded)
+		sp_core::bytes::from_hex(s).map(Self::Bytes).map_err(|e| {
+			format!(
+				"Given string does not look like hash or number. It could not be parsed as bytes either: {}",
+				e
+			)
+		})
+	}
+}
+
+/// An extrinsic address to decode and print out.
+#[derive(Debug, Clone, PartialEq)]
+pub enum ExtrinsicAddress<Hash, Number> {
+	/// Extrinsic as part of existing block.
+	Block(BlockAddress<Hash, Number>, usize),
+	/// Raw SCALE-encoded extrinsic bytes.
+	Bytes(Vec<u8>),
+}
+
+impl<Hash: FromStr + Debug, Number: FromStr + Debug> FromStr for ExtrinsicAddress<Hash, Number> {
+	type Err = String;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		// first try raw bytes
+		if let Ok(bytes) = sp_core::bytes::from_hex(s).map(Self::Bytes) {
+			return Ok(bytes)
+		}
+
+		// split by a bunch of different characters
+		let mut it = s.split(|c| c == '.' || c == ':' || c == ' ');
+		let block = it
+			.next()
+			.expect("First element of split iterator is never empty; qed")
+			.parse()?;
+
+		let index = it
+			.next()
+			.ok_or("Extrinsic index missing: example \"5:0\"")?
+			.parse()
+			.map_err(|e| format!("Invalid index format: {}", e))?;
+
+		Ok(Self::Block(block, index))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::hash::H160 as Hash;
+
+	#[test]
+	fn should_parse_block_strings() {
+		type BlockAddress = super::BlockAddress<Hash, u64>;
+
+		let b0 = BlockAddress::from_str("3BfC20f0B9aFcAcE800D73D2191166FF16540258");
+		let b1 = BlockAddress::from_str("1234");
+		let b2 = BlockAddress::from_str("0");
+		let b3 = BlockAddress::from_str("0x0012345f");
+
+		assert_eq!(
+			b0,
+			Ok(BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()))
+		);
+		assert_eq!(b1, Ok(BlockAddress::Number(1234)));
+		assert_eq!(b2, Ok(BlockAddress::Number(0)));
+		assert_eq!(b3, Ok(BlockAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
+	}
+
+	#[test]
+	fn should_parse_extrinsic_address() {
+		type BlockAddress = super::BlockAddress<Hash, u64>;
+		type ExtrinsicAddress = super::ExtrinsicAddress<Hash, u64>;
+
+		let e0 = ExtrinsicAddress::from_str("1234");
+		let b0 = ExtrinsicAddress::from_str("3BfC20f0B9aFcAcE800D73D2191166FF16540258:5");
+		let b1 = ExtrinsicAddress::from_str("1234:0");
+		let b2 = ExtrinsicAddress::from_str("0 0");
+		let b3 = ExtrinsicAddress::from_str("0x0012345f");
+
+		assert_eq!(e0, Ok(ExtrinsicAddress::Bytes(vec![0x12, 0x34])));
+		assert_eq!(
+			b0,
+			Ok(ExtrinsicAddress::Block(
+				BlockAddress::Hash("3BfC20f0B9aFcAcE800D73D2191166FF16540258".parse().unwrap()),
+				5
+			))
+		);
+		assert_eq!(b1, Ok(ExtrinsicAddress::Block(BlockAddress::Number(1234), 0)));
+		assert_eq!(b2, Ok(ExtrinsicAddress::Bytes(vec![0, 0])));
+		assert_eq!(b3, Ok(ExtrinsicAddress::Bytes(vec![0, 0x12, 0x34, 0x5f])));
+	}
+}
diff --git a/substrate/bin/node/primitives/Cargo.toml b/substrate/bin/node/primitives/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..586d0bce2dbbcbdd36938b223a5ebacf0c1b235d
--- /dev/null
+++ b/substrate/bin/node/primitives/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "node-primitives"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node low-level primitives."
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+
+[features]
+default = [ "std" ]
+std = [ "sp-core/std", "sp-runtime/std" ]
diff --git a/substrate/bin/node/primitives/src/lib.rs b/substrate/bin/node/primitives/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..24a67cbdd8f78657e2df53d7b33eed6466a0fda8
--- /dev/null
+++ b/substrate/bin/node/primitives/src/lib.rs
@@ -0,0 +1,66 @@
+// 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.
+
+//! Low-level types used throughout the Substrate code.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, IdentifyAccount, Verify},
+	MultiSignature, OpaqueExtrinsic,
+};
+
+/// An index to a block.
+pub type BlockNumber = u32;
+
+/// Alias to 512-bit hash when used in the context of a transaction signature on the chain.
+pub type Signature = MultiSignature;
+
+/// Some way of identifying an account on the chain. We intentionally make it equivalent
+/// to the public key of our transaction signing scheme.
+pub type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
+
+/// The type for looking up accounts. We don't expect more than 4 billion of them.
+pub type AccountIndex = u32;
+
+/// Balance of an account.
+pub type Balance = u128;
+
+/// Type used for expressing timestamp.
+pub type Moment = u64;
+
+/// Index of a transaction in the chain.
+pub type Nonce = u32;
+
+/// A hash of some data used by the chain.
+pub type Hash = sp_core::H256;
+
+/// A timestamp: milliseconds since the unix epoch.
+/// `u64` is enough to represent a duration of half a billion years, when the
+/// time scale is milliseconds.
+pub type Timestamp = u64;
+
+/// Digest item type.
+pub type DigestItem = generic::DigestItem;
+/// Header type.
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+/// Block type.
+pub type Block = generic::Block<Header, OpaqueExtrinsic>;
+/// Block ID.
+pub type BlockId = generic::BlockId<Block>;
diff --git a/substrate/bin/node/rpc/Cargo.toml b/substrate/bin/node/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9f5d12e22d372aab6537688ef112a607d501aa2f
--- /dev/null
+++ b/substrate/bin/node/rpc/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "node-rpc"
+version = "3.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node rpc methods."
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["server"] }
+node-primitives = { version = "2.0.0", path = "../primitives" }
+pallet-transaction-payment-rpc = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/rpc/" }
+mmr-rpc = { version = "4.0.0-dev", path = "../../../client/merkle-mountain-range/rpc/" }
+sc-chain-spec = { version = "4.0.0-dev", path = "../../../client/chain-spec" }
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api" }
+sc-consensus-babe = { version = "0.10.0-dev", path = "../../../client/consensus/babe" }
+sc-consensus-babe-rpc = { version = "0.10.0-dev", path = "../../../client/consensus/babe/rpc" }
+sc-consensus-grandpa = { version = "0.10.0-dev", path = "../../../client/consensus/grandpa" }
+sc-consensus-grandpa-rpc = { version = "0.10.0-dev", path = "../../../client/consensus/grandpa/rpc" }
+sc-rpc = { version = "4.0.0-dev", path = "../../../client/rpc" }
+sc-rpc-api = { version = "0.10.0-dev", path = "../../../client/rpc-api" }
+sc-rpc-spec-v2 = { version = "0.10.0-dev", path = "../../../client/rpc-spec-v2" }
+sc-sync-state-rpc = { version = "0.10.0-dev", path = "../../../client/sync-state-rpc" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../client/transaction-pool/api" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../../primitives/block-builder" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-babe = { version = "0.10.0-dev", path = "../../../primitives/consensus/babe" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-statement-store = { version = "4.0.0-dev", path = "../../../primitives/statement-store" }
+substrate-frame-rpc-system = { version = "4.0.0-dev", path = "../../../utils/frame/rpc/system" }
+substrate-state-trie-migration-rpc = { version = "4.0.0-dev", 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
new file mode 100644
index 0000000000000000000000000000000000000000..6d8aa5ff0a9da9f33c2ac3123d108ccffe98571b
--- /dev/null
+++ b/substrate/bin/node/rpc/src/lib.rs
@@ -0,0 +1,200 @@
+// 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 collection of node-specific RPC methods.
+//!
+//! Since `substrate` core functionality makes no assumptions
+//! about the modules used inside the runtime, so do
+//! RPC methods defined in `sc-rpc` crate.
+//! It means that `client/rpc` can't have any methods that
+//! need some strong assumptions about the particular runtime.
+//!
+//! The RPCs available in this crate however can make some assumptions
+//! about how the runtime is constructed and what FRAME pallets
+//! are part of it. Therefore all node-runtime-specific RPCs can
+//! be placed here or imported from corresponding FRAME RPC definitions.
+
+#![warn(missing_docs)]
+#![warn(unused_crate_dependencies)]
+
+use std::sync::Arc;
+
+use jsonrpsee::RpcModule;
+use node_primitives::{AccountId, Balance, Block, BlockNumber, Hash, Nonce};
+use sc_client_api::AuxStore;
+use sc_consensus_babe::BabeWorkerHandle;
+use sc_consensus_grandpa::{
+	FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState,
+};
+use sc_rpc::SubscriptionTaskExecutor;
+pub use sc_rpc_api::DenyUnsafe;
+use sc_transaction_pool_api::TransactionPool;
+use sp_api::ProvideRuntimeApi;
+use sp_block_builder::BlockBuilder;
+use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
+use sp_consensus::SelectChain;
+use sp_consensus_babe::BabeApi;
+use sp_keystore::KeystorePtr;
+
+/// Extra dependencies for BABE.
+pub struct BabeDeps {
+	/// A handle to the BABE worker for issuing requests.
+	pub babe_worker_handle: BabeWorkerHandle<Block>,
+	/// The keystore that manages the keys of the node.
+	pub keystore: KeystorePtr,
+}
+
+/// Extra dependencies for GRANDPA
+pub struct GrandpaDeps<B> {
+	/// Voting round info.
+	pub shared_voter_state: SharedVoterState,
+	/// Authority set info.
+	pub shared_authority_set: SharedAuthoritySet<Hash, BlockNumber>,
+	/// Receives notifications about justification events from Grandpa.
+	pub justification_stream: GrandpaJustificationStream<Block>,
+	/// Executor to drive the subscription manager in the Grandpa RPC handler.
+	pub subscription_executor: SubscriptionTaskExecutor,
+	/// Finality proof provider.
+	pub finality_provider: Arc<FinalityProofProvider<B, Block>>,
+}
+
+/// Full client dependencies.
+pub struct FullDeps<C, P, SC, B> {
+	/// The client instance to use.
+	pub client: Arc<C>,
+	/// Transaction pool instance.
+	pub pool: Arc<P>,
+	/// The SelectChain Strategy
+	pub select_chain: SC,
+	/// A copy of the chain spec.
+	pub chain_spec: Box<dyn sc_chain_spec::ChainSpec>,
+	/// Whether to deny unsafe calls
+	pub deny_unsafe: DenyUnsafe,
+	/// BABE specific dependencies.
+	pub babe: BabeDeps,
+	/// GRANDPA specific dependencies.
+	pub grandpa: GrandpaDeps<B>,
+	/// Shared statement store reference.
+	pub statement_store: Arc<dyn sp_statement_store::StatementStore>,
+	/// The backend used by the node.
+	pub backend: Arc<B>,
+}
+
+/// Instantiate all Full RPC extensions.
+pub fn create_full<C, P, SC, B>(
+	FullDeps {
+		client,
+		pool,
+		select_chain,
+		chain_spec,
+		deny_unsafe,
+		babe,
+		grandpa,
+		statement_store,
+		backend,
+	}: FullDeps<C, P, SC, B>,
+) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
+where
+	C: ProvideRuntimeApi<Block>
+		+ sc_client_api::BlockBackend<Block>
+		+ HeaderBackend<Block>
+		+ AuxStore
+		+ HeaderMetadata<Block, Error = BlockChainError>
+		+ Sync
+		+ Send
+		+ 'static,
+	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>,
+	C::Api: BlockBuilder<Block>,
+	P: TransactionPool + 'static,
+	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>>,
+{
+	use mmr_rpc::{Mmr, MmrApiServer};
+	use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
+	use sc_consensus_babe_rpc::{Babe, BabeApiServer};
+	use sc_consensus_grandpa_rpc::{Grandpa, GrandpaApiServer};
+	use sc_rpc::{
+		dev::{Dev, DevApiServer},
+		statement::StatementApiServer,
+	};
+	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(());
+
+	let BabeDeps { keystore, babe_worker_handle } = babe;
+	let GrandpaDeps {
+		shared_voter_state,
+		shared_authority_set,
+		justification_stream,
+		subscription_executor,
+		finality_provider,
+	} = grandpa;
+
+	let chain_name = chain_spec.name().to_string();
+	let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed");
+	let properties = chain_spec.properties();
+	io.merge(ChainSpec::new(chain_name, genesis_hash, properties).into_rpc())?;
+
+	io.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?;
+	// Making synchronous calls in light client freezes the browser currently,
+	// more context: https://github.com/paritytech/substrate/pull/3480
+	// These RPCs should use an asynchronous caller instead.
+	io.merge(
+		Mmr::new(
+			client.clone(),
+			backend
+				.offchain_storage()
+				.ok_or_else(|| "Backend doesn't provide an offchain storage")?,
+		)
+		.into_rpc(),
+	)?;
+	io.merge(TransactionPayment::new(client.clone()).into_rpc())?;
+	io.merge(
+		Babe::new(client.clone(), babe_worker_handle.clone(), keystore, select_chain, deny_unsafe)
+			.into_rpc(),
+	)?;
+	io.merge(
+		Grandpa::new(
+			subscription_executor,
+			shared_authority_set.clone(),
+			shared_voter_state,
+			justification_stream,
+			finality_provider,
+		)
+		.into_rpc(),
+	)?;
+
+	io.merge(
+		SyncState::new(chain_spec, client.clone(), shared_authority_set, babe_worker_handle)?
+			.into_rpc(),
+	)?;
+
+	io.merge(StateMigration::new(client.clone(), backend, deny_unsafe).into_rpc())?;
+	io.merge(Dev::new(client, deny_unsafe).into_rpc())?;
+	let statement_store =
+		sc_rpc::statement::StatementStore::new(statement_store, deny_unsafe).into_rpc();
+	io.merge(statement_store)?;
+
+	Ok(io)
+}
diff --git a/substrate/bin/node/runtime/Cargo.toml b/substrate/bin/node/runtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4aa048efcf60ae9ca7ca94885a76956123a75da1
--- /dev/null
+++ b/substrate/bin/node/runtime/Cargo.toml
@@ -0,0 +1,389 @@
+[package]
+name = "kitchensink-runtime"
+version = "3.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate node kitchensink runtime."
+edition = "2021"
+build = "build.rs"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+
+# third-party dependencies
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+	"max-encoded-len",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+static_assertions = "1.1.0"
+log = { version = "0.4.17", default-features = false }
+
+# pallet-asset-conversion: turn on "num-traits" feature
+primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "scale-info", "num-traits"] }
+
+# primitives
+sp-authority-discovery = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/authority-discovery" }
+sp-consensus-babe = { version = "0.10.0-dev", default-features = false, path = "../../../primitives/consensus/babe" }
+sp-consensus-grandpa = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/consensus/grandpa" }
+sp-block-builder = { path = "../../../primitives/block-builder", default-features = false, version = "4.0.0-dev" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/inherents" }
+node-primitives = { version = "2.0.0", default-features = false, path = "../primitives" }
+sp-offchain = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/offchain" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/staking" }
+sp-storage = { version = "13.0.0", default-features = false, path = "../../../primitives/storage" }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/session" }
+sp-transaction-pool = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/transaction-pool" }
+sp-statement-store = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/statement-store" }
+sp-version = { version = "22.0.0", default-features = false, path = "../../../primitives/version" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+
+# frame dependencies
+frame-executive = { version = "4.0.0-dev", default-features = false, path = "../../../frame/executive" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../../frame/benchmarking" }
+frame-benchmarking-pallet-pov = { version = "4.0.0-dev", default-features = false, path = "../../../frame/benchmarking/pov" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../../frame/support", features = ["tuples-96"] }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../../frame/system" }
+frame-system-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../../frame/system/benchmarking", optional = true }
+frame-election-provider-support = { version = "4.0.0-dev", default-features = false, path = "../../../frame/election-provider-support" }
+frame-system-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/system/rpc/runtime-api/" }
+frame-try-runtime = { version = "0.10.0-dev", default-features = false, path = "../../../frame/try-runtime", optional = true }
+pallet-alliance = { version = "4.0.0-dev", default-features = false, path = "../../../frame/alliance" }
+pallet-asset-conversion = { version = "4.0.0-dev", default-features = false, path = "../../../frame/asset-conversion" }
+pallet-asset-rate = { version = "4.0.0-dev", default-features = false, path = "../../../frame/asset-rate" }
+pallet-assets = { version = "4.0.0-dev", default-features = false, path = "../../../frame/assets" }
+pallet-authority-discovery = { version = "4.0.0-dev", default-features = false, path = "../../../frame/authority-discovery" }
+pallet-authorship = { version = "4.0.0-dev", default-features = false, path = "../../../frame/authorship" }
+pallet-babe = { version = "4.0.0-dev", default-features = false, path = "../../../frame/babe" }
+pallet-bags-list = { version = "4.0.0-dev", default-features = false, path = "../../../frame/bags-list" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../../frame/balances" }
+pallet-bounties = { version = "4.0.0-dev", default-features = false, path = "../../../frame/bounties" }
+pallet-broker = { version = "0.1.0", default-features = false, path = "../../../frame/broker" }
+pallet-child-bounties = { version = "4.0.0-dev", default-features = false, path = "../../../frame/child-bounties" }
+pallet-collective = { version = "4.0.0-dev", default-features = false, path = "../../../frame/collective" }
+pallet-contracts = { version = "4.0.0-dev", default-features = false, path = "../../../frame/contracts" }
+pallet-contracts-primitives = { version = "24.0.0", default-features = false, path = "../../../frame/contracts/primitives/" }
+pallet-conviction-voting = { version = "4.0.0-dev", default-features = false, path = "../../../frame/conviction-voting" }
+pallet-core-fellowship = { version = "4.0.0-dev", default-features = false, path = "../../../frame/core-fellowship" }
+pallet-democracy = { version = "4.0.0-dev", default-features = false, path = "../../../frame/democracy" }
+pallet-election-provider-multi-phase = { version = "4.0.0-dev", default-features = false, path = "../../../frame/election-provider-multi-phase" }
+pallet-election-provider-support-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../../frame/election-provider-support/benchmarking", optional = true }
+pallet-elections-phragmen = { version = "5.0.0-dev", default-features = false, path = "../../../frame/elections-phragmen" }
+pallet-fast-unstake = { version = "4.0.0-dev", default-features = false, path = "../../../frame/fast-unstake" }
+pallet-nis = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nis" }
+pallet-grandpa = { version = "4.0.0-dev", default-features = false, path = "../../../frame/grandpa" }
+pallet-im-online = { version = "4.0.0-dev", default-features = false, path = "../../../frame/im-online" }
+pallet-indices = { version = "4.0.0-dev", default-features = false, path = "../../../frame/indices" }
+pallet-identity = { version = "4.0.0-dev", default-features = false, path = "../../../frame/identity" }
+pallet-lottery = { version = "4.0.0-dev", default-features = false, path = "../../../frame/lottery" }
+pallet-membership = { version = "4.0.0-dev", default-features = false, path = "../../../frame/membership" }
+pallet-message-queue = { version = "7.0.0-dev", default-features = false, path = "../../../frame/message-queue" }
+pallet-mmr = { version = "4.0.0-dev", default-features = false, path = "../../../frame/merkle-mountain-range" }
+pallet-multisig = { version = "4.0.0-dev", default-features = false, path = "../../../frame/multisig" }
+pallet-nfts = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nfts" }
+pallet-nfts-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nfts/runtime-api" }
+pallet-nft-fractionalization = { version = "4.0.0-dev", default-features = false, path = "../../../frame/nft-fractionalization" }
+pallet-nomination-pools = { version = "1.0.0", default-features = false, path = "../../../frame/nomination-pools"}
+pallet-nomination-pools-benchmarking = { version = "1.0.0", default-features = false, optional = true, path = "../../../frame/nomination-pools/benchmarking" }
+pallet-nomination-pools-runtime-api = { version = "1.0.0-dev", default-features = false, path = "../../../frame/nomination-pools/runtime-api" }
+pallet-offences = { version = "4.0.0-dev", default-features = false, path = "../../../frame/offences" }
+pallet-offences-benchmarking = { version = "4.0.0-dev", path = "../../../frame/offences/benchmarking", default-features = false, optional = true }
+pallet-glutton = { version = "4.0.0-dev", default-features = false, path = "../../../frame/glutton" }
+pallet-preimage = { version = "4.0.0-dev", default-features = false, path = "../../../frame/preimage" }
+pallet-proxy = { version = "4.0.0-dev", default-features = false, path = "../../../frame/proxy" }
+pallet-insecure-randomness-collective-flip = { version = "4.0.0-dev", default-features = false, path = "../../../frame/insecure-randomness-collective-flip" }
+pallet-ranked-collective = { version = "4.0.0-dev", default-features = false, path = "../../../frame/ranked-collective" }
+pallet-recovery = { version = "4.0.0-dev", default-features = false, path = "../../../frame/recovery" }
+pallet-referenda = { version = "4.0.0-dev", default-features = false, path = "../../../frame/referenda" }
+pallet-remark = { version = "4.0.0-dev", default-features = false, path = "../../../frame/remark" }
+pallet-root-testing = { version = "1.0.0-dev", default-features = false, path = "../../../frame/root-testing" }
+pallet-salary = { version = "4.0.0-dev", default-features = false, path = "../../../frame/salary" }
+pallet-session = { version = "4.0.0-dev", features = [ "historical" ], path = "../../../frame/session", default-features = false }
+pallet-session-benchmarking = { version = "4.0.0-dev", path = "../../../frame/session/benchmarking", default-features = false, optional = true }
+pallet-staking = { version = "4.0.0-dev", default-features = false, path = "../../../frame/staking" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", default-features = false, path = "../../../frame/staking/reward-curve" }
+pallet-staking-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/staking/runtime-api" }
+pallet-state-trie-migration = { version = "4.0.0-dev", default-features = false, path = "../../../frame/state-trie-migration" }
+pallet-statement = { version = "4.0.0-dev", default-features = false, path = "../../../frame/statement" }
+pallet-scheduler = { version = "4.0.0-dev", default-features = false, path = "../../../frame/scheduler" }
+pallet-society = { version = "4.0.0-dev", default-features = false, path = "../../../frame/society" }
+pallet-sudo = { version = "4.0.0-dev", default-features = false, path = "../../../frame/sudo" }
+pallet-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../../frame/timestamp" }
+pallet-tips = { version = "4.0.0-dev", default-features = false, path = "../../../frame/tips" }
+pallet-treasury = { version = "4.0.0-dev", default-features = false, path = "../../../frame/treasury" }
+pallet-utility = { version = "4.0.0-dev", default-features = false, path = "../../../frame/utility" }
+pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-payment" }
+pallet-transaction-payment-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-payment/rpc/runtime-api/" }
+pallet-asset-conversion-tx-payment = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-payment/asset-conversion-tx-payment" }
+pallet-asset-tx-payment = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-payment/asset-tx-payment" }
+pallet-transaction-storage = { version = "4.0.0-dev", default-features = false, path = "../../../frame/transaction-storage" }
+pallet-uniques = { version = "4.0.0-dev", default-features = false, path = "../../../frame/uniques" }
+pallet-vesting = { version = "4.0.0-dev", default-features = false, path = "../../../frame/vesting" }
+pallet-whitelist = { version = "4.0.0-dev", default-features = false, path = "../../../frame/whitelist" }
+pallet-tx-pause = { version = "4.0.0-dev", default-features = false, path = "../../../frame/tx-pause" }
+pallet-safe-mode = { version = "4.0.0-dev", default-features = false, path = "../../../frame/safe-mode" }
+
+[build-dependencies]
+substrate-wasm-builder = { version = "5.0.0-dev", path = "../../../utils/wasm-builder", optional = true }
+
+[features]
+default = [ "std" ]
+with-tracing = [ "frame-executive/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-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-bounties/std",
+	"pallet-broker/std",
+	"pallet-child-bounties/std",
+	"pallet-collective/std",
+	"pallet-contracts-primitives/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-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-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-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-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",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-authority-discovery/std",
+	"sp-block-builder/std",
+	"sp-consensus-babe/std",
+	"sp-consensus-grandpa/std",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-io/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/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-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-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-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-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",
+]
+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-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-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-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-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-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-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",
+]
diff --git a/substrate/bin/node/runtime/build.rs b/substrate/bin/node/runtime/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b7676a70dfe843e2cd47fc600ef599bbe7bff591
--- /dev/null
+++ b/substrate/bin/node/runtime/build.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.
+
+fn main() {
+	#[cfg(feature = "std")]
+	{
+		substrate_wasm_builder::WasmBuilder::new()
+			.with_current_project()
+			.export_heap_base()
+			.import_memory()
+			.build();
+	}
+}
diff --git a/substrate/bin/node/runtime/src/assets_api.rs b/substrate/bin/node/runtime/src/assets_api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cf1a663d70300aa6a4427d3998112c84056e68d2
--- /dev/null
+++ b/substrate/bin/node/runtime/src/assets_api.rs
@@ -0,0 +1,34 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2018-2022 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/>.
+
+//! Runtime API definition for assets.
+
+use codec::Codec;
+use sp_std::vec::Vec;
+
+sp_api::decl_runtime_apis! {
+	pub trait AssetsApi<AccountId, AssetBalance, AssetId>
+	where
+		AccountId: Codec,
+		AssetBalance: Codec,
+		AssetId: Codec,
+	{
+		/// Returns the list of `AssetId`s and corresponding balance that an `AccountId` has.
+		fn account_balances(account: AccountId) -> Vec<(AssetId, AssetBalance)>;
+	}
+}
diff --git a/substrate/bin/node/runtime/src/constants.rs b/substrate/bin/node/runtime/src/constants.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e4fafbf0fa4790121787788cef8aa2547b226cf3
--- /dev/null
+++ b/substrate/bin/node/runtime/src/constants.rs
@@ -0,0 +1,77 @@
+// 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 set of constant values used in substrate runtime.
+
+/// Money matters.
+pub mod currency {
+	use node_primitives::Balance;
+
+	pub const MILLICENTS: Balance = 1_000_000_000;
+	pub const CENTS: Balance = 1_000 * MILLICENTS; // assume this is worth about a cent.
+	pub const DOLLARS: Balance = 100 * CENTS;
+
+	pub const fn deposit(items: u32, bytes: u32) -> Balance {
+		items as Balance * 15 * CENTS + (bytes as Balance) * 6 * CENTS
+	}
+}
+
+/// Time.
+pub mod time {
+	use node_primitives::{BlockNumber, Moment};
+
+	/// Since BABE is probabilistic this is the average expected block time that
+	/// we are targeting. Blocks will be produced at a minimum duration defined
+	/// by `SLOT_DURATION`, but some slots will not be allocated to any
+	/// authority and hence no block will be produced. We expect to have this
+	/// block time on average following the defined slot duration and the value
+	/// of `c` configured for BABE (where `1 - c` represents the probability of
+	/// a slot being empty).
+	/// This value is only used indirectly to define the unit constants below
+	/// that are expressed in blocks. The rest of the code should use
+	/// `SLOT_DURATION` instead (like the Timestamp pallet for calculating the
+	/// minimum period).
+	///
+	/// If using BABE with secondary slots (default) then all of the slots will
+	/// always be assigned, in which case `MILLISECS_PER_BLOCK` and
+	/// `SLOT_DURATION` should have the same value.
+	///
+	/// <https://research.web3.foundation/en/latest/polkadot/block-production/Babe.html#-6.-practical-results>
+	pub const MILLISECS_PER_BLOCK: Moment = 3000;
+	pub const SECS_PER_BLOCK: Moment = MILLISECS_PER_BLOCK / 1000;
+
+	// NOTE: Currently it is not possible to change the slot duration after the chain has started.
+	//       Attempting to do so will brick block production.
+	pub const SLOT_DURATION: Moment = MILLISECS_PER_BLOCK;
+
+	// 1 in 4 blocks (on average, not counting collisions) will be primary BABE blocks.
+	pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4);
+
+	// NOTE: Currently it is not possible to change the epoch duration after the chain has started.
+	//       Attempting to do so will brick block production.
+	pub const EPOCH_DURATION_IN_BLOCKS: BlockNumber = 10 * MINUTES;
+	pub const EPOCH_DURATION_IN_SLOTS: u64 = {
+		const SLOT_FILL_RATE: f64 = MILLISECS_PER_BLOCK as f64 / SLOT_DURATION as f64;
+
+		(EPOCH_DURATION_IN_BLOCKS as f64 * SLOT_FILL_RATE) as u64
+	};
+
+	// These time units are defined in number of blocks.
+	pub const MINUTES: BlockNumber = 60 / (SECS_PER_BLOCK as BlockNumber);
+	pub const HOURS: BlockNumber = MINUTES * 60;
+	pub const DAYS: BlockNumber = HOURS * 24;
+}
diff --git a/substrate/bin/node/runtime/src/impls.rs b/substrate/bin/node/runtime/src/impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..430a1ac2824b806acf7d95715c72cf5448d2a5a6
--- /dev/null
+++ b/substrate/bin/node/runtime/src/impls.rs
@@ -0,0 +1,489 @@
+// 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.
+
+//! Some configurable implementations as associated type for the substrate runtime.
+
+use frame_support::{
+	pallet_prelude::*,
+	traits::{
+		fungibles::{Balanced, Credit},
+		Currency, OnUnbalanced,
+	},
+};
+use pallet_alliance::{IdentityVerifier, ProposalIndex, ProposalProvider};
+use pallet_asset_tx_payment::HandleCredit;
+use sp_std::prelude::*;
+
+use crate::{
+	AccountId, AllianceMotion, Assets, Authorship, Balances, Hash, NegativeImbalance, Runtime,
+	RuntimeCall,
+};
+
+pub struct Author;
+impl OnUnbalanced<NegativeImbalance> for Author {
+	fn on_nonzero_unbalanced(amount: NegativeImbalance) {
+		if let Some(author) = Authorship::author() {
+			Balances::resolve_creating(&author, amount);
+		}
+	}
+}
+
+/// A `HandleCredit` implementation that naively transfers the fees to the block author.
+/// Will drop and burn the assets in case the transfer fails.
+pub struct CreditToBlockAuthor;
+impl HandleCredit<AccountId, Assets> for CreditToBlockAuthor {
+	fn handle_credit(credit: Credit<AccountId, Assets>) {
+		if let Some(author) = pallet_authorship::Pallet::<Runtime>::author() {
+			// Drop the result which will trigger the `OnDrop` of the imbalance in case of error.
+			let _ = Assets::resolve(&author, credit);
+		}
+	}
+}
+
+pub struct AllianceIdentityVerifier;
+impl IdentityVerifier<AccountId> for AllianceIdentityVerifier {
+	fn has_identity(who: &AccountId, fields: u64) -> bool {
+		crate::Identity::has_identity(who, fields)
+	}
+
+	fn has_good_judgement(who: &AccountId) -> bool {
+		use pallet_identity::Judgement;
+		crate::Identity::identity(who)
+			.map(|registration| registration.judgements)
+			.map_or(false, |judgements| {
+				judgements
+					.iter()
+					.any(|(_, j)| matches!(j, Judgement::KnownGood | Judgement::Reasonable))
+			})
+	}
+
+	fn super_account_id(who: &AccountId) -> Option<AccountId> {
+		crate::Identity::super_of(who).map(|parent| parent.0)
+	}
+}
+
+pub struct AllianceProposalProvider;
+impl ProposalProvider<AccountId, Hash, RuntimeCall> for AllianceProposalProvider {
+	fn propose_proposal(
+		who: AccountId,
+		threshold: u32,
+		proposal: Box<RuntimeCall>,
+		length_bound: u32,
+	) -> Result<(u32, u32), DispatchError> {
+		AllianceMotion::do_propose_proposed(who, threshold, proposal, length_bound)
+	}
+
+	fn vote_proposal(
+		who: AccountId,
+		proposal: Hash,
+		index: ProposalIndex,
+		approve: bool,
+	) -> Result<bool, DispatchError> {
+		AllianceMotion::do_vote(who, proposal, index, approve)
+	}
+
+	fn close_proposal(
+		proposal_hash: Hash,
+		proposal_index: ProposalIndex,
+		proposal_weight_bound: Weight,
+		length_bound: u32,
+	) -> DispatchResultWithPostInfo {
+		AllianceMotion::do_close(proposal_hash, proposal_index, proposal_weight_bound, length_bound)
+	}
+
+	fn proposal_of(proposal_hash: Hash) -> Option<RuntimeCall> {
+		AllianceMotion::proposal_of(proposal_hash)
+	}
+}
+
+#[cfg(test)]
+mod multiplier_tests {
+	use frame_support::{
+		dispatch::DispatchClass,
+		weights::{Weight, WeightToFee},
+	};
+	use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment};
+	use sp_runtime::{
+		assert_eq_error_rate,
+		traits::{Convert, One, Zero},
+		BuildStorage, FixedPointNumber,
+	};
+
+	use crate::{
+		constants::{currency::*, time::*},
+		AdjustmentVariable, MaximumMultiplier, MinimumMultiplier, Runtime,
+		RuntimeBlockWeights as BlockWeights, System, TargetBlockFullness, TransactionPayment,
+	};
+
+	fn max_normal() -> Weight {
+		BlockWeights::get()
+			.get(DispatchClass::Normal)
+			.max_total
+			.unwrap_or_else(|| BlockWeights::get().max_block)
+	}
+
+	fn min_multiplier() -> Multiplier {
+		MinimumMultiplier::get()
+	}
+
+	fn target() -> Weight {
+		TargetBlockFullness::get() * max_normal()
+	}
+
+	// update based on runtime impl.
+	fn runtime_multiplier_update(fm: Multiplier) -> Multiplier {
+		TargetedFeeAdjustment::<
+			Runtime,
+			TargetBlockFullness,
+			AdjustmentVariable,
+			MinimumMultiplier,
+			MaximumMultiplier,
+		>::convert(fm)
+	}
+
+	// update based on reference impl.
+	fn truth_value_update(block_weight: Weight, previous: Multiplier) -> Multiplier {
+		let accuracy = Multiplier::accuracy() as f64;
+		let previous_float = previous.into_inner() as f64 / accuracy;
+		// bump if it is zero.
+		let previous_float = previous_float.max(min_multiplier().into_inner() as f64 / accuracy);
+
+		let max_normal = max_normal();
+		let target_weight = target();
+		let normalized_weight_dimensions = (
+			block_weight.ref_time() as f64 / max_normal.ref_time() as f64,
+			block_weight.proof_size() as f64 / max_normal.proof_size() as f64,
+		);
+
+		let (normal, max, target) =
+			if normalized_weight_dimensions.0 < normalized_weight_dimensions.1 {
+				(block_weight.proof_size(), max_normal.proof_size(), target_weight.proof_size())
+			} else {
+				(block_weight.ref_time(), max_normal.ref_time(), target_weight.ref_time())
+			};
+
+		// maximum tx weight
+		let m = max as f64;
+		// block weight always truncated to max weight
+		let block_weight = (normal as f64).min(m);
+		let v: f64 = AdjustmentVariable::get().to_float();
+
+		// Ideal saturation in terms of weight
+		let ss = target as f64;
+		// Current saturation in terms of weight
+		let s = block_weight;
+
+		let t1 = v * (s / m - ss / m);
+		let t2 = v.powi(2) * (s / m - ss / m).powi(2) / 2.0;
+		let next_float = previous_float * (1.0 + t1 + t2);
+		Multiplier::from_float(next_float)
+	}
+
+	fn run_with_system_weight<F>(w: Weight, assertions: F)
+	where
+		F: Fn() -> (),
+	{
+		let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::<Runtime>::default()
+			.build_storage()
+			.unwrap()
+			.into();
+		t.execute_with(|| {
+			System::set_block_consumed_resources(w, 0);
+			assertions()
+		});
+	}
+
+	#[test]
+	fn truth_value_update_poc_works() {
+		let fm = Multiplier::saturating_from_rational(1, 2);
+		let test_set = vec![
+			(Weight::zero(), fm),
+			(Weight::from_parts(100, 0), fm),
+			(Weight::from_parts(1000, 0), fm),
+			(target(), fm),
+			(max_normal() / 2, fm),
+			(max_normal(), fm),
+		];
+		test_set.into_iter().for_each(|(w, fm)| {
+			run_with_system_weight(w, || {
+				assert_eq_error_rate!(
+					truth_value_update(w, fm),
+					runtime_multiplier_update(fm),
+					// Error is only 1 in 100^18
+					Multiplier::from_inner(100),
+				);
+			})
+		})
+	}
+
+	#[test]
+	fn multiplier_can_grow_from_zero() {
+		// if the min is too small, then this will not change, and we are doomed forever.
+		// the block ref time is 1/100th bigger than target.
+		run_with_system_weight(target().set_ref_time(target().ref_time() * 101 / 100), || {
+			let next = runtime_multiplier_update(min_multiplier());
+			assert!(next > min_multiplier(), "{:?} !> {:?}", next, min_multiplier());
+		});
+
+		// the block proof size is 1/100th bigger than target.
+		run_with_system_weight(target().set_proof_size((target().proof_size() / 100) * 101), || {
+			let next = runtime_multiplier_update(min_multiplier());
+			assert!(next > min_multiplier(), "{:?} !> {:?}", next, min_multiplier());
+		})
+	}
+
+	#[test]
+	fn multiplier_cannot_go_below_limit() {
+		// will not go any further below even if block is empty.
+		run_with_system_weight(Weight::zero(), || {
+			let next = runtime_multiplier_update(min_multiplier());
+			assert_eq!(next, min_multiplier());
+		})
+	}
+
+	#[test]
+	fn time_to_reach_zero() {
+		// blocks per 24h in substrate-node: 28,800 (k)
+		// s* = 0.1875
+		// The bound from the research in an empty chain is:
+		// v <~ (p / k(0 - s*))
+		// p > v * k * -0.1875
+		// to get p == -1 we'd need
+		// -1 > 0.00001 * k * -0.1875
+		// 1 < 0.00001 * k * 0.1875
+		// 10^9 / 1875 < k
+		// k > 533_333 ~ 18,5 days.
+		run_with_system_weight(Weight::zero(), || {
+			// start from 1, the default.
+			let mut fm = Multiplier::one();
+			let mut iterations: u64 = 0;
+			loop {
+				let next = runtime_multiplier_update(fm);
+				fm = next;
+				if fm == min_multiplier() {
+					break
+				}
+				iterations += 1;
+			}
+			assert!(iterations > 533_333);
+		})
+	}
+
+	#[test]
+	fn min_change_per_day() {
+		run_with_system_weight(max_normal(), || {
+			let mut fm = Multiplier::one();
+			// See the example in the doc of `TargetedFeeAdjustment`. are at least 0.234, hence
+			// `fm > 1.234`.
+			for _ in 0..DAYS {
+				let next = runtime_multiplier_update(fm);
+				fm = next;
+			}
+			assert!(fm > Multiplier::saturating_from_rational(1234, 1000));
+		})
+	}
+
+	#[test]
+	#[ignore]
+	fn congested_chain_simulation() {
+		// `cargo test congested_chain_simulation -- --nocapture` to get some insight.
+
+		// almost full. The entire quota of normal transactions is taken.
+		let block_weight = BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap() -
+			Weight::from_parts(100, 0);
+
+		// Default substrate weight.
+		let tx_weight = frame_support::weights::constants::ExtrinsicBaseWeight::get();
+
+		run_with_system_weight(block_weight, || {
+			// initial value configured on module
+			let mut fm = Multiplier::one();
+			assert_eq!(fm, TransactionPayment::next_fee_multiplier());
+
+			let mut iterations: u64 = 0;
+			loop {
+				let next = runtime_multiplier_update(fm);
+				// if no change, panic. This should never happen in this case.
+				if fm == next {
+					panic!("The fee should ever increase");
+				}
+				fm = next;
+				iterations += 1;
+				let fee =
+					<Runtime as pallet_transaction_payment::Config>::WeightToFee::weight_to_fee(
+						&tx_weight,
+					);
+				let adjusted_fee = fm.saturating_mul_acc_int(fee);
+				println!(
+					"iteration {}, new fm = {:?}. Fee at this point is: {} units / {} millicents, \
+					{} cents, {} dollars",
+					iterations,
+					fm,
+					adjusted_fee,
+					adjusted_fee / MILLICENTS,
+					adjusted_fee / CENTS,
+					adjusted_fee / DOLLARS,
+				);
+			}
+		});
+	}
+
+	#[test]
+	fn stateless_weight_mul() {
+		let fm = Multiplier::saturating_from_rational(1, 2);
+		run_with_system_weight(target() / 4, || {
+			let next = runtime_multiplier_update(fm);
+			assert_eq_error_rate!(
+				next,
+				truth_value_update(target() / 4, fm),
+				Multiplier::from_inner(100),
+			);
+
+			// Light block. Multiplier is reduced a little.
+			assert!(next < fm);
+		});
+
+		run_with_system_weight(target() / 2, || {
+			let next = runtime_multiplier_update(fm);
+			assert_eq_error_rate!(
+				next,
+				truth_value_update(target() / 2, fm),
+				Multiplier::from_inner(100),
+			);
+			// Light block. Multiplier is reduced a little.
+			assert!(next < fm);
+		});
+		run_with_system_weight(target(), || {
+			let next = runtime_multiplier_update(fm);
+			assert_eq_error_rate!(
+				next,
+				truth_value_update(target(), fm),
+				Multiplier::from_inner(100),
+			);
+			// ideal. No changes.
+			assert_eq!(next, fm)
+		});
+		run_with_system_weight(target() * 2, || {
+			// More than ideal. Fee is increased.
+			let next = runtime_multiplier_update(fm);
+			assert_eq_error_rate!(
+				next,
+				truth_value_update(target() * 2, fm),
+				Multiplier::from_inner(100),
+			);
+
+			// Heavy block. Fee is increased a little.
+			assert!(next > fm);
+		});
+	}
+
+	#[test]
+	fn weight_mul_grow_on_big_block() {
+		run_with_system_weight(target() * 2, || {
+			let mut original = Multiplier::zero();
+			let mut next = Multiplier::default();
+
+			(0..1_000).for_each(|_| {
+				next = runtime_multiplier_update(original);
+				assert_eq_error_rate!(
+					next,
+					truth_value_update(target() * 2, original),
+					Multiplier::from_inner(100),
+				);
+				// must always increase
+				assert!(next > original, "{:?} !>= {:?}", next, original);
+				original = next;
+			});
+		});
+	}
+
+	#[test]
+	fn weight_mul_decrease_on_small_block() {
+		run_with_system_weight(target() / 2, || {
+			let mut original = Multiplier::saturating_from_rational(1, 2);
+			let mut next;
+
+			for _ in 0..100 {
+				// decreases
+				next = runtime_multiplier_update(original);
+				assert!(next < original, "{:?} !<= {:?}", next, original);
+				original = next;
+			}
+		})
+	}
+
+	#[test]
+	fn weight_to_fee_should_not_overflow_on_large_weights() {
+		let kb_time = Weight::from_parts(1024, 0);
+		let kb_size = Weight::from_parts(0, 1024);
+		let mb_time = 1024u64 * kb_time;
+		let max_fm = Multiplier::saturating_from_integer(i128::MAX);
+
+		// check that for all values it can compute, correctly.
+		vec![
+			Weight::zero(),
+			// testcases ignoring proof size part of the weight.
+			Weight::from_parts(1, 0),
+			Weight::from_parts(10, 0),
+			Weight::from_parts(1000, 0),
+			kb_time,
+			10u64 * kb_time,
+			100u64 * kb_time,
+			mb_time,
+			10u64 * mb_time,
+			Weight::from_parts(2147483647, 0),
+			Weight::from_parts(4294967295, 0),
+			// testcases ignoring ref time part of the weight.
+			Weight::from_parts(0, 100000000000),
+			1000000u64 * kb_size,
+			1000000000u64 * kb_size,
+			Weight::from_parts(0, 18014398509481983),
+			Weight::from_parts(0, 9223372036854775807),
+			// test cases with both parts of the weight.
+			BlockWeights::get().max_block / 1024,
+			BlockWeights::get().max_block / 2,
+			BlockWeights::get().max_block,
+			Weight::MAX / 2,
+			Weight::MAX,
+		]
+		.into_iter()
+		.for_each(|i| {
+			run_with_system_weight(i, || {
+				let next = runtime_multiplier_update(Multiplier::one());
+				let truth = truth_value_update(i, Multiplier::one());
+				assert_eq_error_rate!(truth, next, Multiplier::from_inner(50_000_000));
+			});
+		});
+
+		// Some values that are all above the target and will cause an increase.
+		let t = target();
+		vec![
+			t + Weight::from_parts(100, 0),
+			t + Weight::from_parts(0, t.proof_size() * 2),
+			t * 2,
+			t * 4,
+		]
+		.into_iter()
+		.for_each(|i| {
+			run_with_system_weight(i, || {
+				let fm = runtime_multiplier_update(max_fm);
+				// won't grow. The convert saturates everything.
+				assert_eq!(fm, max_fm);
+			})
+		});
+	}
+}
diff --git a/substrate/bin/node/runtime/src/lib.rs b/substrate/bin/node/runtime/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4f34e4ecd812221102c01e839df96472f5b8de99
--- /dev/null
+++ b/substrate/bin/node/runtime/src/lib.rs
@@ -0,0 +1,2788 @@
+// 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/>.
+
+//! The Substrate runtime. This can be compiled with `#[no_std]`, ready for Wasm.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+// `construct_runtime!` does a lot of recursion and requires us to increase the limits.
+#![recursion_limit = "1024"]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, BalancingConfig, ElectionDataProvider, SequentialPhragmen, VoteWeight,
+};
+use frame_support::{
+	construct_runtime,
+	dispatch::DispatchClass,
+	instances::{Instance1, Instance2},
+	ord_parameter_types,
+	pallet_prelude::Get,
+	parameter_types,
+	traits::{
+		fungible::{Balanced, Credit, ItemOf},
+		tokens::{nonfungibles_v2::Inspect, GetSalary, PayFromAccount},
+		AsEnsureOriginWithArg, ConstBool, ConstU128, ConstU16, ConstU32, Contains, Currency,
+		EitherOfDiverse, EqualPrivilegeOnly, Imbalance, InsideBoth, InstanceFilter,
+		KeyOwnerProofSystem, LockIdentifier, Nothing, OnUnbalanced, WithdrawReasons,
+	},
+	weights::{
+		constants::{
+			BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_REF_TIME_PER_SECOND,
+		},
+		ConstantMultiplier, IdentityFee, Weight,
+	},
+	BoundedVec, PalletId,
+};
+use frame_system::{
+	limits::{BlockLength, BlockWeights},
+	EnsureRoot, EnsureRootWithSuccess, EnsureSigned, EnsureSignedBy, EnsureWithSuccess,
+};
+pub use node_primitives::{AccountId, Signature};
+use node_primitives::{AccountIndex, Balance, BlockNumber, Hash, Moment, Nonce};
+use pallet_asset_conversion::{NativeOrAssetId, NativeOrAssetIdConverter};
+use pallet_broker::{CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600};
+use pallet_election_provider_multi_phase::SolutionAccuracyOf;
+use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
+use pallet_nfts::PalletFeatures;
+use pallet_nis::WithMaximumOf;
+use pallet_session::historical as pallet_session_historical;
+pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustment};
+use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo};
+use pallet_tx_pause::RuntimeCallNameOf;
+use sp_api::impl_runtime_apis;
+use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
+use sp_consensus_grandpa::AuthorityId as GrandpaId;
+use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
+use sp_inherents::{CheckInherentsResult, InherentData};
+use sp_runtime::{
+	create_runtime_str,
+	curve::PiecewiseLinear,
+	generic, impl_opaque_keys,
+	traits::{
+		self, AccountIdConversion, BlakeTwo256, Block as BlockT, Bounded, ConvertInto, NumberFor,
+		OpaqueKeys, SaturatedConversion, StaticLookup,
+	},
+	transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
+	ApplyExtrinsicResult, FixedPointNumber, FixedU128, Perbill, Percent, Permill, Perquintill,
+	RuntimeDebug,
+};
+use sp_std::prelude::*;
+#[cfg(any(feature = "std", test))]
+use sp_version::NativeVersion;
+use sp_version::RuntimeVersion;
+use static_assertions::const_assert;
+
+#[cfg(any(feature = "std", test))]
+pub use frame_system::Call as SystemCall;
+#[cfg(any(feature = "std", test))]
+pub use pallet_balances::Call as BalancesCall;
+#[cfg(any(feature = "std", test))]
+pub use pallet_staking::StakerStatus;
+#[cfg(any(feature = "std", test))]
+pub use pallet_sudo::Call as SudoCall;
+#[cfg(any(feature = "std", test))]
+pub use sp_runtime::BuildStorage;
+
+/// Implementations of some helper traits passed into runtime modules as associated types.
+pub mod impls;
+#[cfg(not(feature = "runtime-benchmarks"))]
+use impls::AllianceIdentityVerifier;
+use impls::{AllianceProposalProvider, Author, CreditToBlockAuthor};
+
+/// Constant values used within the runtime.
+pub mod constants;
+use constants::{currency::*, time::*};
+use sp_runtime::generic::Era;
+
+/// Generated voter bag information.
+mod voter_bags;
+
+/// Runtime API definition for assets.
+pub mod assets_api;
+
+// Make the WASM binary available.
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+/// Max size for serialized extrinsic params for this testing runtime.
+/// This is a quite arbitrary but empirically battle tested value.
+#[cfg(test)]
+pub const CALL_PARAMS_MAX_SIZE: usize = 208;
+
+/// Wasm binary unwrapped. If built with `SKIP_WASM_BUILD`, the function panics.
+#[cfg(feature = "std")]
+pub fn wasm_binary_unwrap() -> &'static [u8] {
+	WASM_BINARY.expect(
+		"Development wasm binary is not available. This means the client is built with \
+		 `SKIP_WASM_BUILD` flag and it is only usable for production chains. Please rebuild with \
+		 the flag disabled.",
+	)
+}
+
+/// Runtime version.
+#[sp_version::runtime_version]
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: create_runtime_str!("node"),
+	impl_name: create_runtime_str!("substrate-node"),
+	authoring_version: 10,
+	// Per convention: if the runtime behavior changes, increment spec_version
+	// and set impl_version to 0. If only runtime
+	// implementation changes and behavior does not, then leave spec_version as
+	// is and increment impl_version.
+	spec_version: 268,
+	impl_version: 0,
+	apis: RUNTIME_API_VERSIONS,
+	transaction_version: 2,
+	state_version: 1,
+};
+
+/// The BABE epoch configuration at genesis.
+pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration =
+	sp_consensus_babe::BabeEpochConfiguration {
+		c: PRIMARY_PROBABILITY,
+		allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryPlainSlots,
+	};
+
+/// Native version.
+#[cfg(any(feature = "std", test))]
+pub fn native_version() -> NativeVersion {
+	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
+}
+
+type NegativeImbalance = <Balances as Currency<AccountId>>::NegativeImbalance;
+
+pub struct DealWithFees;
+impl OnUnbalanced<NegativeImbalance> for DealWithFees {
+	fn on_unbalanceds<B>(mut fees_then_tips: impl Iterator<Item = NegativeImbalance>) {
+		if let Some(fees) = fees_then_tips.next() {
+			// for fees, 80% to treasury, 20% to author
+			let mut split = fees.ration(80, 20);
+			if let Some(tips) = fees_then_tips.next() {
+				// for tips, if any, 80% to treasury, 20% to author (though this can be anything)
+				tips.ration_merge_into(80, 20, &mut split);
+			}
+			Treasury::on_unbalanced(split.0);
+			Author::on_unbalanced(split.1);
+		}
+	}
+}
+
+/// We assume that ~10% of the block weight is consumed by `on_initialize` handlers.
+/// This is used to limit the maximal weight of a single extrinsic.
+const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);
+/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used
+/// by  Operational  extrinsics.
+const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
+/// We allow for 2 seconds of compute with a 6 second average block time, with maximum proof size.
+const MAXIMUM_BLOCK_WEIGHT: Weight =
+	Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2), u64::MAX);
+
+parameter_types! {
+	pub const BlockHashCount: BlockNumber = 2400;
+	pub const Version: RuntimeVersion = VERSION;
+	pub RuntimeBlockLength: BlockLength =
+		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
+	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()
+		.base_block(BlockExecutionWeight::get())
+		.for_class(DispatchClass::all(), |weights| {
+			weights.base_extrinsic = ExtrinsicBaseWeight::get();
+		})
+		.for_class(DispatchClass::Normal, |weights| {
+			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
+		})
+		.for_class(DispatchClass::Operational, |weights| {
+			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);
+			// Operational transactions have some extra reserved space, so that they
+			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.
+			weights.reserved = Some(
+				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT
+			);
+		})
+		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)
+		.build_or_panic();
+	pub MaxCollectivesProposalWeight: Weight = Perbill::from_percent(50) * RuntimeBlockWeights::get().max_block;
+}
+
+const_assert!(NORMAL_DISPATCH_RATIO.deconstruct() >= AVERAGE_ON_INITIALIZE_RATIO.deconstruct());
+
+/// Calls that can bypass the safe-mode pallet.
+pub struct SafeModeWhitelistedCalls;
+impl Contains<RuntimeCall> for SafeModeWhitelistedCalls {
+	fn contains(call: &RuntimeCall) -> bool {
+		match call {
+			RuntimeCall::System(_) | RuntimeCall::SafeMode(_) | RuntimeCall::TxPause(_) => true,
+			_ => false,
+		}
+	}
+}
+
+/// Calls that cannot be paused by the tx-pause pallet.
+pub struct TxPauseWhitelistedCalls;
+/// Whitelist `Balances::transfer_keep_alive`, all others are pauseable.
+impl Contains<RuntimeCallNameOf<Runtime>> for TxPauseWhitelistedCalls {
+	fn contains(full_name: &RuntimeCallNameOf<Runtime>) -> bool {
+		match (full_name.0.as_slice(), full_name.1.as_slice()) {
+			(b"Balances", b"transfer_keep_alive") => true,
+			_ => false,
+		}
+	}
+}
+
+impl pallet_tx_pause::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PauseOrigin = EnsureRoot<AccountId>;
+	type UnpauseOrigin = EnsureRoot<AccountId>;
+	type WhitelistedCalls = TxPauseWhitelistedCalls;
+	type MaxNameLen = ConstU32<256>;
+	type WeightInfo = pallet_tx_pause::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const EnterDuration: BlockNumber = 4 * HOURS;
+	pub const EnterDepositAmount: Balance = 2_000_000 * DOLLARS;
+	pub const ExtendDuration: BlockNumber = 2 * HOURS;
+	pub const ExtendDepositAmount: Balance = 1_000_000 * DOLLARS;
+	pub const ReleaseDelay: u32 = 2 * DAYS;
+}
+
+impl pallet_safe_mode::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type WhitelistedCalls = SafeModeWhitelistedCalls;
+	type EnterDuration = EnterDuration;
+	type EnterDepositAmount = EnterDepositAmount;
+	type ExtendDuration = ExtendDuration;
+	type ExtendDepositAmount = ExtendDepositAmount;
+	type ForceEnterOrigin = EnsureRootWithSuccess<AccountId, ConstU32<9>>;
+	type ForceExtendOrigin = EnsureRootWithSuccess<AccountId, ConstU32<11>>;
+	type ForceExitOrigin = EnsureRoot<AccountId>;
+	type ForceDepositOrigin = EnsureRoot<AccountId>;
+	type ReleaseDelay = ReleaseDelay;
+	type Notify = ();
+	type WeightInfo = pallet_safe_mode::weights::SubstrateWeight<Runtime>;
+}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = InsideBoth<SafeMode, TxPause>;
+	type BlockWeights = RuntimeBlockWeights;
+	type BlockLength = RuntimeBlockLength;
+	type DbWeight = RocksDbWeight;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = Nonce;
+	type Hash = Hash;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = Indices;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = BlockHashCount;
+	type Version = Version;
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<Balance>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Runtime>;
+	type SS58Prefix = ConstU16<42>;
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl pallet_insecure_randomness_collective_flip::Config for Runtime {}
+
+impl pallet_utility::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = pallet_utility::weights::SubstrateWeight<Runtime>;
+}
+
+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);
+	// Additional storage item size of 32 bytes.
+	pub const DepositFactor: Balance = deposit(0, 32);
+}
+
+impl pallet_multisig::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type DepositBase = DepositBase;
+	type DepositFactor = DepositFactor;
+	type MaxSignatories = ConstU32<100>;
+	type WeightInfo = pallet_multisig::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	// One storage item; key size 32, value size 8; .
+	pub const ProxyDepositBase: Balance = deposit(1, 8);
+	// Additional storage item size of 33 bytes.
+	pub const ProxyDepositFactor: Balance = deposit(0, 33);
+	pub const AnnouncementDepositBase: Balance = deposit(1, 8);
+	pub const AnnouncementDepositFactor: Balance = deposit(0, 66);
+}
+
+/// The type used to represent the kinds of proxying allowed.
+#[derive(
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	Encode,
+	Decode,
+	RuntimeDebug,
+	MaxEncodedLen,
+	scale_info::TypeInfo,
+)]
+pub enum ProxyType {
+	Any,
+	NonTransfer,
+	Governance,
+	Staking,
+}
+impl Default for ProxyType {
+	fn default() -> Self {
+		Self::Any
+	}
+}
+impl InstanceFilter<RuntimeCall> for ProxyType {
+	fn filter(&self, c: &RuntimeCall) -> bool {
+		match self {
+			ProxyType::Any => true,
+			ProxyType::NonTransfer => !matches!(
+				c,
+				RuntimeCall::Balances(..) |
+					RuntimeCall::Assets(..) |
+					RuntimeCall::Uniques(..) |
+					RuntimeCall::Nfts(..) |
+					RuntimeCall::Vesting(pallet_vesting::Call::vested_transfer { .. }) |
+					RuntimeCall::Indices(pallet_indices::Call::transfer { .. })
+			),
+			ProxyType::Governance => matches!(
+				c,
+				RuntimeCall::Democracy(..) |
+					RuntimeCall::Council(..) |
+					RuntimeCall::Society(..) |
+					RuntimeCall::TechnicalCommittee(..) |
+					RuntimeCall::Elections(..) |
+					RuntimeCall::Treasury(..)
+			),
+			ProxyType::Staking => {
+				matches!(c, RuntimeCall::Staking(..) | RuntimeCall::FastUnstake(..))
+			},
+		}
+	}
+	fn is_superset(&self, o: &Self) -> bool {
+		match (self, o) {
+			(x, y) if x == y => true,
+			(ProxyType::Any, _) => true,
+			(_, ProxyType::Any) => false,
+			(ProxyType::NonTransfer, _) => true,
+			_ => false,
+		}
+	}
+}
+
+impl pallet_proxy::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type ProxyType = ProxyType;
+	type ProxyDepositBase = ProxyDepositBase;
+	type ProxyDepositFactor = ProxyDepositFactor;
+	type MaxProxies = ConstU32<32>;
+	type WeightInfo = pallet_proxy::weights::SubstrateWeight<Runtime>;
+	type MaxPending = ConstU32<32>;
+	type CallHasher = BlakeTwo256;
+	type AnnouncementDepositBase = AnnouncementDepositBase;
+	type AnnouncementDepositFactor = AnnouncementDepositFactor;
+}
+
+parameter_types! {
+	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
+		RuntimeBlockWeights::get().max_block;
+}
+
+impl pallet_scheduler::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type PalletsOrigin = OriginCaller;
+	type RuntimeCall = RuntimeCall;
+	type MaximumWeight = MaximumSchedulerWeight;
+	type ScheduleOrigin = EnsureRoot<AccountId>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type MaxScheduledPerBlock = ConstU32<512>;
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	type MaxScheduledPerBlock = ConstU32<50>;
+	type WeightInfo = pallet_scheduler::weights::SubstrateWeight<Runtime>;
+	type OriginPrivilegeCmp = EqualPrivilegeOnly;
+	type Preimages = Preimage;
+}
+
+impl pallet_glutton::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type AdminOrigin = EnsureRoot<AccountId>;
+	type WeightInfo = pallet_glutton::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const PreimageMaxSize: u32 = 4096 * 1024;
+	pub const PreimageBaseDeposit: Balance = 1 * DOLLARS;
+	// One cent: $10,000 / MB
+	pub const PreimageByteDeposit: Balance = 1 * CENTS;
+}
+
+impl pallet_preimage::Config for Runtime {
+	type WeightInfo = pallet_preimage::weights::SubstrateWeight<Runtime>;
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type ManagerOrigin = EnsureRoot<AccountId>;
+	type BaseDeposit = PreimageBaseDeposit;
+	type ByteDeposit = PreimageByteDeposit;
+}
+
+parameter_types! {
+	// NOTE: Currently it is not possible to change the epoch duration after the chain has started.
+	//       Attempting to do so will brick block production.
+	pub const EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS;
+	pub const ExpectedBlockTime: Moment = MILLISECS_PER_BLOCK;
+	pub const ReportLongevity: u64 =
+		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();
+}
+
+impl pallet_babe::Config for Runtime {
+	type EpochDuration = EpochDuration;
+	type ExpectedBlockTime = ExpectedBlockTime;
+	type EpochChangeTrigger = pallet_babe::ExternalTrigger;
+	type DisabledValidators = Session;
+	type WeightInfo = ();
+	type MaxAuthorities = MaxAuthorities;
+	type MaxNominators = MaxNominatorRewardedPerValidator;
+	type KeyOwnerProof =
+		<Historical as KeyOwnerProofSystem<(KeyTypeId, pallet_babe::AuthorityId)>>::Proof;
+	type EquivocationReportSystem =
+		pallet_babe::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
+}
+
+parameter_types! {
+	pub const IndexDeposit: Balance = 1 * DOLLARS;
+}
+
+impl pallet_indices::Config for Runtime {
+	type AccountIndex = AccountIndex;
+	type Currency = Balances;
+	type Deposit = IndexDeposit;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = pallet_indices::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const ExistentialDeposit: Balance = 1 * DOLLARS;
+	// For weight estimation, we assume that the most locks on an individual account will be 50.
+	// This number may need to be adjusted in the future if this assumption no longer holds true.
+	pub const MaxLocks: u32 = 50;
+	pub const MaxReserves: u32 = 50;
+}
+
+impl pallet_balances::Config for Runtime {
+	type MaxLocks = MaxLocks;
+	type MaxReserves = MaxReserves;
+	type ReserveIdentifier = [u8; 8];
+	type Balance = Balance;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = frame_system::Pallet<Runtime>;
+	type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type MaxHolds = ConstU32<2>;
+}
+
+parameter_types! {
+	pub const TransactionByteFee: Balance = 10 * MILLICENTS;
+	pub const OperationalFeeMultiplier: u8 = 5;
+	pub const TargetBlockFullness: Perquintill = Perquintill::from_percent(25);
+	pub AdjustmentVariable: Multiplier = Multiplier::saturating_from_rational(1, 100_000);
+	pub MinimumMultiplier: Multiplier = Multiplier::saturating_from_rational(1, 1_000_000_000u128);
+	pub MaximumMultiplier: Multiplier = Bounded::max_value();
+}
+
+impl pallet_transaction_payment::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type OnChargeTransaction = CurrencyAdapter<Balances, DealWithFees>;
+	type OperationalFeeMultiplier = OperationalFeeMultiplier;
+	type WeightToFee = IdentityFee<Balance>;
+	type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;
+	type FeeMultiplierUpdate = TargetedFeeAdjustment<
+		Self,
+		TargetBlockFullness,
+		AdjustmentVariable,
+		MinimumMultiplier,
+		MaximumMultiplier,
+	>;
+}
+
+impl pallet_asset_tx_payment::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Fungibles = Assets;
+	type OnChargeAssetTransaction = pallet_asset_tx_payment::FungiblesAdapter<
+		pallet_assets::BalanceToAssetBalance<Balances, Runtime, ConvertInto, Instance1>,
+		CreditToBlockAuthor,
+	>;
+}
+
+impl pallet_asset_conversion_tx_payment::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Fungibles = Assets;
+	type OnChargeAssetTransaction =
+		pallet_asset_conversion_tx_payment::AssetConversionAdapter<Balances, AssetConversion>;
+}
+
+parameter_types! {
+	pub const MinimumPeriod: Moment = SLOT_DURATION / 2;
+}
+
+impl pallet_timestamp::Config for Runtime {
+	type Moment = Moment;
+	type OnTimestampSet = Babe;
+	type MinimumPeriod = MinimumPeriod;
+	type WeightInfo = pallet_timestamp::weights::SubstrateWeight<Runtime>;
+}
+
+impl pallet_authorship::Config for Runtime {
+	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
+	type EventHandler = (Staking, ImOnline);
+}
+
+impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub grandpa: Grandpa,
+		pub babe: Babe,
+		pub im_online: ImOnline,
+		pub authority_discovery: AuthorityDiscovery,
+	}
+}
+
+impl pallet_session::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = <Self as frame_system::Config>::AccountId;
+	type ValidatorIdOf = pallet_staking::StashOf<Self>;
+	type ShouldEndSession = Babe;
+	type NextSessionRotation = Babe;
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
+	type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
+	type Keys = SessionKeys;
+	type WeightInfo = pallet_session::weights::SubstrateWeight<Runtime>;
+}
+
+impl pallet_session::historical::Config for Runtime {
+	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
+}
+
+pallet_staking_reward_curve::build! {
+	const REWARD_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 SessionsPerEra: sp_staking::SessionIndex = 6;
+	pub const BondingDuration: sp_staking::EraIndex = 24 * 28;
+	pub const SlashDeferDuration: sp_staking::EraIndex = 24 * 7; // 1/4 the bonding duration.
+	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+	pub const MaxNominatorRewardedPerValidator: u32 = 256;
+	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
+	pub OffchainRepeat: BlockNumber = 5;
+	pub HistoryDepth: u32 = 84;
+}
+
+/// Upper limit on the number of NPOS nominations.
+const MAX_QUOTA_NOMINATIONS: u32 = 16;
+
+pub struct StakingBenchmarkingConfig;
+impl pallet_staking::BenchmarkingConfig for StakingBenchmarkingConfig {
+	type MaxNominators = ConstU32<1000>;
+	type MaxValidators = ConstU32<1000>;
+}
+
+impl pallet_staking::Config for Runtime {
+	type Currency = Balances;
+	type CurrencyBalance = Balance;
+	type UnixTime = Timestamp;
+	type CurrencyToVote = sp_staking::currency_to_vote::U128CurrencyToVote;
+	type RewardRemainder = Treasury;
+	type RuntimeEvent = RuntimeEvent;
+	type Slash = Treasury; // send the slashed funds to the treasury.
+	type Reward = (); // rewards are minted from the void
+	type SessionsPerEra = SessionsPerEra;
+	type BondingDuration = BondingDuration;
+	type SlashDeferDuration = SlashDeferDuration;
+	/// A super-majority of the council can cancel the slash.
+	type AdminOrigin = EitherOfDiverse<
+		EnsureRoot<AccountId>,
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 3, 4>,
+	>;
+	type SessionInterface = Self;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
+	type NextNewSession = Session;
+	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
+	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+	type ElectionProvider = ElectionProviderMultiPhase;
+	type GenesisElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type VoterList = VoterList;
+	type NominationsQuota = pallet_staking::FixedNominationsQuota<MAX_QUOTA_NOMINATIONS>;
+	// This a placeholder, to be introduced in the next PR as an instance of bags-list
+	type TargetList = pallet_staking::UseValidatorsMap<Self>;
+	type MaxUnlockingChunks = ConstU32<32>;
+	type HistoryDepth = HistoryDepth;
+	type EventListeners = NominationPools;
+	type WeightInfo = pallet_staking::weights::SubstrateWeight<Runtime>;
+	type BenchmarkingConfig = StakingBenchmarkingConfig;
+}
+
+impl pallet_fast_unstake::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type ControlOrigin = frame_system::EnsureRoot<AccountId>;
+	type BatchSize = ConstU32<64>;
+	type Deposit = ConstU128<{ DOLLARS }>;
+	type Currency = Balances;
+	type Staking = Staking;
+	type MaxErasToCheckPerBlock = ConstU32<1>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type MaxBackersPerValidator = MaxNominatorRewardedPerValidator;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	// phase durations. 1/4 of the last session for each.
+	pub const SignedPhase: u32 = EPOCH_DURATION_IN_BLOCKS / 4;
+	pub const UnsignedPhase: u32 = EPOCH_DURATION_IN_BLOCKS / 4;
+
+	// signed config
+	pub const SignedRewardBase: Balance = 1 * DOLLARS;
+	pub const SignedDepositBase: Balance = 1 * DOLLARS;
+	pub const SignedDepositByte: Balance = 1 * CENTS;
+
+	pub BetterUnsignedThreshold: Perbill = Perbill::from_rational(1u32, 10_000);
+
+	// miner configs
+	pub const MultiPhaseUnsignedPriority: TransactionPriority = StakingUnsignedPriority::get() - 1u64;
+	pub MinerMaxWeight: Weight = RuntimeBlockWeights::get()
+		.get(DispatchClass::Normal)
+		.max_extrinsic.expect("Normal extrinsics have a weight limit configured; qed")
+		.saturating_sub(BlockExecutionWeight::get());
+	// Solution can occupy 90% of normal block size
+	pub MinerMaxLength: u32 = Perbill::from_rational(9u32, 10) *
+		*RuntimeBlockLength::get()
+		.max
+		.get(DispatchClass::Normal);
+}
+
+frame_election_provider_support::generate_solution_type!(
+	#[compact]
+	pub struct NposSolution16::<
+		VoterIndex = u32,
+		TargetIndex = u16,
+		Accuracy = sp_runtime::PerU16,
+		MaxVoters = MaxElectingVotersSolution,
+	>(16)
+);
+
+parameter_types! {
+	// Note: the EPM in this runtime runs the election on-chain. The election bounds must be
+	// carefully set so that an election round fits in one block.
+	pub ElectionBoundsMultiPhase: ElectionBounds = ElectionBoundsBuilder::default()
+		.voters_count(10_000.into()).targets_count(1_500.into()).build();
+	pub ElectionBoundsOnChain: ElectionBounds = ElectionBoundsBuilder::default()
+		.voters_count(5_000.into()).targets_count(1_250.into()).build();
+
+	pub MaxNominations: u32 = <NposSolution16 as frame_election_provider_support::NposSolution>::LIMIT as u32;
+	pub MaxElectingVotersSolution: u32 = 40_000;
+	// The maximum winners that can be elected by the Election pallet which is equivalent to the
+	// maximum active validators the staking pallet can have.
+	pub MaxActiveValidators: u32 = 1000;
+}
+
+/// The numbers configured here could always be more than the the maximum limits of staking pallet
+/// to ensure election snapshot will not run out of memory. For now, we set them to smaller values
+/// since the staking is bounded and the weight pipeline takes hours for this single pallet.
+pub struct ElectionProviderBenchmarkConfig;
+impl pallet_election_provider_multi_phase::BenchmarkingConfig for ElectionProviderBenchmarkConfig {
+	const VOTERS: [u32; 2] = [1000, 2000];
+	const TARGETS: [u32; 2] = [500, 1000];
+	const ACTIVE_VOTERS: [u32; 2] = [500, 800];
+	const DESIRED_TARGETS: [u32; 2] = [200, 400];
+	const SNAPSHOT_MAXIMUM_VOTERS: u32 = 1000;
+	const MINER_MAXIMUM_VOTERS: u32 = 1000;
+	const MAXIMUM_TARGETS: u32 = 300;
+}
+
+/// Maximum number of iterations for balancing that will be executed in the embedded OCW
+/// miner of election provider multi phase.
+pub const MINER_MAX_ITERATIONS: u32 = 10;
+
+/// A source of random balance for NposSolver, which is meant to be run by the OCW election miner.
+pub struct OffchainRandomBalancing;
+impl Get<Option<BalancingConfig>> for OffchainRandomBalancing {
+	fn get() -> Option<BalancingConfig> {
+		use sp_runtime::traits::TrailingZeroInput;
+		let iterations = match MINER_MAX_ITERATIONS {
+			0 => 0,
+			max => {
+				let seed = sp_io::offchain::random_seed();
+				let random = <u32>::decode(&mut TrailingZeroInput::new(&seed))
+					.expect("input is padded with zeroes; qed") %
+					max.saturating_add(1);
+				random as usize
+			},
+		};
+
+		let config = BalancingConfig { iterations, tolerance: 0 };
+		Some(config)
+	}
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Runtime;
+	type Solver = SequentialPhragmen<
+		AccountId,
+		pallet_election_provider_multi_phase::SolutionAccuracyOf<Runtime>,
+	>;
+	type DataProvider = <Runtime as pallet_election_provider_multi_phase::Config>::DataProvider;
+	type WeightInfo = frame_election_provider_support::weights::SubstrateWeight<Runtime>;
+	type MaxWinners = <Runtime as pallet_election_provider_multi_phase::Config>::MaxWinners;
+	type Bounds = ElectionBoundsOnChain;
+}
+
+impl pallet_election_provider_multi_phase::MinerConfig for Runtime {
+	type AccountId = AccountId;
+	type MaxLength = MinerMaxLength;
+	type MaxWeight = MinerMaxWeight;
+	type Solution = NposSolution16;
+	type MaxVotesPerVoter =
+	<<Self as pallet_election_provider_multi_phase::Config>::DataProvider as ElectionDataProvider>::MaxVotesPerVoter;
+	type MaxWinners = MaxActiveValidators;
+
+	// The unsigned submissions have to respect the weight of the submit_unsigned call, thus their
+	// weight estimate function is wired to this call's weight.
+	fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight {
+		<
+			<Self as pallet_election_provider_multi_phase::Config>::WeightInfo
+			as
+			pallet_election_provider_multi_phase::WeightInfo
+		>::submit_unsigned(v, t, a, d)
+	}
+}
+
+impl pallet_election_provider_multi_phase::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type EstimateCallFee = TransactionPayment;
+	type SignedPhase = SignedPhase;
+	type UnsignedPhase = UnsignedPhase;
+	type BetterUnsignedThreshold = BetterUnsignedThreshold;
+	type BetterSignedThreshold = ();
+	type OffchainRepeat = OffchainRepeat;
+	type MinerTxPriority = MultiPhaseUnsignedPriority;
+	type MinerConfig = Self;
+	type SignedMaxSubmissions = ConstU32<10>;
+	type SignedRewardBase = SignedRewardBase;
+	type SignedDepositBase = SignedDepositBase;
+	type SignedDepositByte = SignedDepositByte;
+	type SignedMaxRefunds = ConstU32<3>;
+	type SignedDepositWeight = ();
+	type SignedMaxWeight = MinerMaxWeight;
+	type SlashHandler = (); // burn slashes
+	type RewardHandler = (); // nothing to do upon rewards
+	type DataProvider = Staking;
+	type Fallback = onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type GovernanceFallback = onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type Solver = SequentialPhragmen<AccountId, SolutionAccuracyOf<Self>, OffchainRandomBalancing>;
+	type ForceOrigin = EnsureRootOrHalfCouncil;
+	type MaxWinners = MaxActiveValidators;
+	type ElectionBounds = ElectionBoundsMultiPhase;
+	type BenchmarkingConfig = ElectionProviderBenchmarkConfig;
+	type WeightInfo = pallet_election_provider_multi_phase::weights::SubstrateWeight<Self>;
+}
+
+parameter_types! {
+	pub const BagThresholds: &'static [u64] = &voter_bags::THRESHOLDS;
+}
+
+type VoterBagsListInstance = pallet_bags_list::Instance1;
+impl pallet_bags_list::Config<VoterBagsListInstance> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	/// The voter bags-list is loosely kept up to date, and the real source of truth for the score
+	/// of each node is the staking pallet.
+	type ScoreProvider = Staking;
+	type BagThresholds = BagThresholds;
+	type Score = VoteWeight;
+	type WeightInfo = pallet_bags_list::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const PostUnbondPoolsWindow: u32 = 4;
+	pub const NominationPoolsPalletId: PalletId = PalletId(*b"py/nopls");
+	pub const MaxPointsToBalance: u8 = 10;
+}
+
+use sp_runtime::traits::Convert;
+pub struct BalanceToU256;
+impl Convert<Balance, sp_core::U256> for BalanceToU256 {
+	fn convert(balance: Balance) -> sp_core::U256 {
+		sp_core::U256::from(balance)
+	}
+}
+pub struct U256ToBalance;
+impl Convert<sp_core::U256, Balance> for U256ToBalance {
+	fn convert(n: sp_core::U256) -> Balance {
+		n.try_into().unwrap_or(Balance::max_value())
+	}
+}
+
+impl pallet_nomination_pools::Config for Runtime {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type RewardCounter = FixedU128;
+	type BalanceToU256 = BalanceToU256;
+	type U256ToBalance = U256ToBalance;
+	type Staking = Staking;
+	type PostUnbondingPoolsWindow = PostUnbondPoolsWindow;
+	type MaxMetadataLen = ConstU32<256>;
+	type MaxUnbonding = ConstU32<8>;
+	type PalletId = NominationPoolsPalletId;
+	type MaxPointsToBalance = MaxPointsToBalance;
+}
+
+parameter_types! {
+	pub const VoteLockingPeriod: BlockNumber = 30 * DAYS;
+}
+
+impl pallet_conviction_voting::Config for Runtime {
+	type WeightInfo = pallet_conviction_voting::weights::SubstrateWeight<Self>;
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type VoteLockingPeriod = VoteLockingPeriod;
+	type MaxVotes = ConstU32<512>;
+	type MaxTurnout = frame_support::traits::TotalIssuanceOf<Balances, Self::AccountId>;
+	type Polls = Referenda;
+}
+
+parameter_types! {
+	pub const AlarmInterval: BlockNumber = 1;
+	pub const SubmissionDeposit: Balance = 100 * DOLLARS;
+	pub const UndecidingTimeout: BlockNumber = 28 * DAYS;
+}
+
+pub struct TracksInfo;
+impl pallet_referenda::TracksInfo<Balance, BlockNumber> for TracksInfo {
+	type Id = u16;
+	type RuntimeOrigin = <RuntimeOrigin as frame_support::traits::OriginTrait>::PalletsOrigin;
+	fn tracks() -> &'static [(Self::Id, pallet_referenda::TrackInfo<Balance, BlockNumber>)] {
+		static DATA: [(u16, pallet_referenda::TrackInfo<Balance, BlockNumber>); 1] = [(
+			0u16,
+			pallet_referenda::TrackInfo {
+				name: "root",
+				max_deciding: 1,
+				decision_deposit: 10,
+				prepare_period: 4,
+				decision_period: 4,
+				confirm_period: 2,
+				min_enactment_period: 4,
+				min_approval: pallet_referenda::Curve::LinearDecreasing {
+					length: Perbill::from_percent(100),
+					floor: Perbill::from_percent(50),
+					ceil: Perbill::from_percent(100),
+				},
+				min_support: pallet_referenda::Curve::LinearDecreasing {
+					length: Perbill::from_percent(100),
+					floor: Perbill::from_percent(0),
+					ceil: Perbill::from_percent(100),
+				},
+			},
+		)];
+		&DATA[..]
+	}
+	fn track_for(id: &Self::RuntimeOrigin) -> Result<Self::Id, ()> {
+		if let Ok(system_origin) = frame_system::RawOrigin::try_from(id.clone()) {
+			match system_origin {
+				frame_system::RawOrigin::Root => Ok(0),
+				_ => Err(()),
+			}
+		} else {
+			Err(())
+		}
+	}
+}
+pallet_referenda::impl_tracksinfo_get!(TracksInfo, Balance, BlockNumber);
+
+impl pallet_referenda::Config for Runtime {
+	type WeightInfo = pallet_referenda::weights::SubstrateWeight<Self>;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type Scheduler = Scheduler;
+	type Currency = pallet_balances::Pallet<Self>;
+	type SubmitOrigin = EnsureSigned<AccountId>;
+	type CancelOrigin = EnsureRoot<AccountId>;
+	type KillOrigin = EnsureRoot<AccountId>;
+	type Slash = ();
+	type Votes = pallet_conviction_voting::VotesOf<Runtime>;
+	type Tally = pallet_conviction_voting::TallyOf<Runtime>;
+	type SubmissionDeposit = SubmissionDeposit;
+	type MaxQueued = ConstU32<100>;
+	type UndecidingTimeout = UndecidingTimeout;
+	type AlarmInterval = AlarmInterval;
+	type Tracks = TracksInfo;
+	type Preimages = Preimage;
+}
+
+impl pallet_referenda::Config<pallet_referenda::Instance2> for Runtime {
+	type WeightInfo = pallet_referenda::weights::SubstrateWeight<Self>;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type Scheduler = Scheduler;
+	type Currency = pallet_balances::Pallet<Self>;
+	type SubmitOrigin = EnsureSigned<AccountId>;
+	type CancelOrigin = EnsureRoot<AccountId>;
+	type KillOrigin = EnsureRoot<AccountId>;
+	type Slash = ();
+	type Votes = pallet_ranked_collective::Votes;
+	type Tally = pallet_ranked_collective::TallyOf<Runtime>;
+	type SubmissionDeposit = SubmissionDeposit;
+	type MaxQueued = ConstU32<100>;
+	type UndecidingTimeout = UndecidingTimeout;
+	type AlarmInterval = AlarmInterval;
+	type Tracks = TracksInfo;
+	type Preimages = Preimage;
+}
+
+impl pallet_ranked_collective::Config for Runtime {
+	type WeightInfo = pallet_ranked_collective::weights::SubstrateWeight<Self>;
+	type RuntimeEvent = RuntimeEvent;
+	type PromoteOrigin = EnsureRootWithSuccess<AccountId, ConstU16<65535>>;
+	type DemoteOrigin = EnsureRootWithSuccess<AccountId, ConstU16<65535>>;
+	type Polls = RankedPolls;
+	type MinRankOfClass = traits::Identity;
+	type VoteWeight = pallet_ranked_collective::Geometric;
+}
+
+impl pallet_remark::Config for Runtime {
+	type WeightInfo = pallet_remark::weights::SubstrateWeight<Self>;
+	type RuntimeEvent = RuntimeEvent;
+}
+
+impl pallet_root_testing::Config for Runtime {}
+
+parameter_types! {
+	pub const LaunchPeriod: BlockNumber = 28 * 24 * 60 * MINUTES;
+	pub const VotingPeriod: BlockNumber = 28 * 24 * 60 * MINUTES;
+	pub const FastTrackVotingPeriod: BlockNumber = 3 * 24 * 60 * MINUTES;
+	pub const MinimumDeposit: Balance = 100 * DOLLARS;
+	pub const EnactmentPeriod: BlockNumber = 30 * 24 * 60 * MINUTES;
+	pub const CooloffPeriod: BlockNumber = 28 * 24 * 60 * MINUTES;
+	pub const MaxProposals: u32 = 100;
+}
+
+impl pallet_democracy::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type EnactmentPeriod = EnactmentPeriod;
+	type LaunchPeriod = LaunchPeriod;
+	type VotingPeriod = VotingPeriod;
+	type VoteLockingPeriod = EnactmentPeriod; // Same as EnactmentPeriod
+	type MinimumDeposit = MinimumDeposit;
+	/// A straight majority of the council can decide what their next motion is.
+	type ExternalOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 1, 2>;
+	/// A super-majority can have the next scheduled referendum be a straight majority-carries vote.
+	type ExternalMajorityOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 3, 4>;
+	/// A unanimous council can have the next scheduled referendum be a straight default-carries
+	/// (NTB) vote.
+	type ExternalDefaultOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 1, 1>;
+	type SubmitOrigin = EnsureSigned<AccountId>;
+	/// Two thirds of the technical committee can have an ExternalMajority/ExternalDefault vote
+	/// be tabled immediately and with a shorter voting/enactment period.
+	type FastTrackOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, TechnicalCollective, 2, 3>;
+	type InstantOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, TechnicalCollective, 1, 1>;
+	type InstantAllowed = frame_support::traits::ConstBool<true>;
+	type FastTrackVotingPeriod = FastTrackVotingPeriod;
+	// To cancel a proposal which has been passed, 2/3 of the council must agree to it.
+	type CancellationOrigin =
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 2, 3>;
+	// To cancel a proposal before it has been passed, the technical committee must be unanimous or
+	// Root must agree.
+	type CancelProposalOrigin = EitherOfDiverse<
+		EnsureRoot<AccountId>,
+		pallet_collective::EnsureProportionAtLeast<AccountId, TechnicalCollective, 1, 1>,
+	>;
+	type BlacklistOrigin = EnsureRoot<AccountId>;
+	// Any single technical committee member may veto a coming council proposal, however they can
+	// only do it once and it lasts only for the cool-off period.
+	type VetoOrigin = pallet_collective::EnsureMember<AccountId, TechnicalCollective>;
+	type CooloffPeriod = CooloffPeriod;
+	type Slash = Treasury;
+	type Scheduler = Scheduler;
+	type PalletsOrigin = OriginCaller;
+	type MaxVotes = ConstU32<100>;
+	type WeightInfo = pallet_democracy::weights::SubstrateWeight<Runtime>;
+	type MaxProposals = MaxProposals;
+	type Preimages = Preimage;
+	type MaxDeposits = ConstU32<100>;
+	type MaxBlacklisted = ConstU32<100>;
+}
+
+parameter_types! {
+	pub const CouncilMotionDuration: BlockNumber = 5 * DAYS;
+	pub const CouncilMaxProposals: u32 = 100;
+	pub const CouncilMaxMembers: u32 = 100;
+}
+
+type CouncilCollective = pallet_collective::Instance1;
+impl pallet_collective::Config<CouncilCollective> for Runtime {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = CouncilMotionDuration;
+	type MaxProposals = CouncilMaxProposals;
+	type MaxMembers = CouncilMaxMembers;
+	type DefaultVote = pallet_collective::PrimeDefaultVote;
+	type WeightInfo = pallet_collective::weights::SubstrateWeight<Runtime>;
+	type SetMembersOrigin = EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxCollectivesProposalWeight;
+}
+
+parameter_types! {
+	pub const CandidacyBond: Balance = 10 * DOLLARS;
+	// 1 storage item created, key size is 32 bytes, value size is 16+16.
+	pub const VotingBondBase: Balance = deposit(1, 64);
+	// additional data per vote is 32 bytes (account id).
+	pub const VotingBondFactor: Balance = deposit(0, 32);
+	pub const TermDuration: BlockNumber = 7 * DAYS;
+	pub const DesiredMembers: u32 = 13;
+	pub const DesiredRunnersUp: u32 = 7;
+	pub const MaxVotesPerVoter: u32 = 16;
+	pub const MaxVoters: u32 = 512;
+	pub const MaxCandidates: u32 = 64;
+	pub const ElectionsPhragmenPalletId: LockIdentifier = *b"phrelect";
+}
+
+// Make sure that there are no more than `MaxMembers` members elected via elections-phragmen.
+const_assert!(DesiredMembers::get() <= CouncilMaxMembers::get());
+
+impl pallet_elections_phragmen::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = ElectionsPhragmenPalletId;
+	type Currency = Balances;
+	type ChangeMembers = Council;
+	// NOTE: this implies that council's genesis members cannot be set directly and must come from
+	// this module.
+	type InitializeMembers = Council;
+	type CurrencyToVote = sp_staking::currency_to_vote::U128CurrencyToVote;
+	type CandidacyBond = CandidacyBond;
+	type VotingBondBase = VotingBondBase;
+	type VotingBondFactor = VotingBondFactor;
+	type LoserCandidate = ();
+	type KickedMember = ();
+	type DesiredMembers = DesiredMembers;
+	type DesiredRunnersUp = DesiredRunnersUp;
+	type TermDuration = TermDuration;
+	type MaxVoters = MaxVoters;
+	type MaxVotesPerVoter = MaxVotesPerVoter;
+	type MaxCandidates = MaxCandidates;
+	type WeightInfo = pallet_elections_phragmen::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const TechnicalMotionDuration: BlockNumber = 5 * DAYS;
+	pub const TechnicalMaxProposals: u32 = 100;
+	pub const TechnicalMaxMembers: u32 = 100;
+}
+
+type TechnicalCollective = pallet_collective::Instance2;
+impl pallet_collective::Config<TechnicalCollective> for Runtime {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = TechnicalMotionDuration;
+	type MaxProposals = TechnicalMaxProposals;
+	type MaxMembers = TechnicalMaxMembers;
+	type DefaultVote = pallet_collective::PrimeDefaultVote;
+	type WeightInfo = pallet_collective::weights::SubstrateWeight<Runtime>;
+	type SetMembersOrigin = EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxCollectivesProposalWeight;
+}
+
+type EnsureRootOrHalfCouncil = EitherOfDiverse<
+	EnsureRoot<AccountId>,
+	pallet_collective::EnsureProportionMoreThan<AccountId, CouncilCollective, 1, 2>,
+>;
+impl pallet_membership::Config<pallet_membership::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type AddOrigin = EnsureRootOrHalfCouncil;
+	type RemoveOrigin = EnsureRootOrHalfCouncil;
+	type SwapOrigin = EnsureRootOrHalfCouncil;
+	type ResetOrigin = EnsureRootOrHalfCouncil;
+	type PrimeOrigin = EnsureRootOrHalfCouncil;
+	type MembershipInitialized = TechnicalCommittee;
+	type MembershipChanged = TechnicalCommittee;
+	type MaxMembers = TechnicalMaxMembers;
+	type WeightInfo = pallet_membership::weights::SubstrateWeight<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;
+	pub const TipFindersFee: Percent = Percent::from_percent(20);
+	pub const TipReportDepositBase: Balance = 1 * DOLLARS;
+	pub const DataDepositPerByte: Balance = 1 * CENTS;
+	pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry");
+	pub const MaximumReasonLength: u32 = 300;
+	pub const MaxApprovals: u32 = 100;
+	pub const MaxBalance: Balance = Balance::max_value();
+}
+
+impl pallet_treasury::Config for Runtime {
+	type PalletId = TreasuryPalletId;
+	type Currency = Balances;
+	type ApproveOrigin = EitherOfDiverse<
+		EnsureRoot<AccountId>,
+		pallet_collective::EnsureProportionAtLeast<AccountId, CouncilCollective, 3, 5>,
+	>;
+	type RejectOrigin = EitherOfDiverse<
+		EnsureRoot<AccountId>,
+		pallet_collective::EnsureProportionMoreThan<AccountId, CouncilCollective, 1, 2>,
+	>;
+	type RuntimeEvent = RuntimeEvent;
+	type OnSlash = ();
+	type ProposalBond = ProposalBond;
+	type ProposalBondMinimum = ProposalBondMinimum;
+	type ProposalBondMaximum = ();
+	type SpendPeriod = SpendPeriod;
+	type Burn = Burn;
+	type BurnDestination = ();
+	type SpendFunds = Bounties;
+	type WeightInfo = pallet_treasury::weights::SubstrateWeight<Runtime>;
+	type MaxApprovals = MaxApprovals;
+	type SpendOrigin = EnsureWithSuccess<EnsureRoot<AccountId>, AccountId, MaxBalance>;
+}
+
+impl pallet_asset_rate::Config for Runtime {
+	type CreateOrigin = EnsureRoot<AccountId>;
+	type RemoveOrigin = EnsureRoot<AccountId>;
+	type UpdateOrigin = EnsureRoot<AccountId>;
+	type Currency = Balances;
+	type AssetKind = u32;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = pallet_asset_rate::weights::SubstrateWeight<Runtime>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+parameter_types! {
+	pub const BountyCuratorDeposit: Permill = Permill::from_percent(50);
+	pub const BountyValueMinimum: Balance = 5 * DOLLARS;
+	pub const BountyDepositBase: Balance = 1 * DOLLARS;
+	pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);
+	pub const CuratorDepositMin: Balance = 1 * DOLLARS;
+	pub const CuratorDepositMax: Balance = 100 * DOLLARS;
+	pub const BountyDepositPayoutDelay: BlockNumber = 1 * DAYS;
+	pub const BountyUpdatePeriod: BlockNumber = 14 * DAYS;
+}
+
+impl pallet_bounties::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type BountyDepositBase = BountyDepositBase;
+	type BountyDepositPayoutDelay = BountyDepositPayoutDelay;
+	type BountyUpdatePeriod = BountyUpdatePeriod;
+	type CuratorDepositMultiplier = CuratorDepositMultiplier;
+	type CuratorDepositMin = CuratorDepositMin;
+	type CuratorDepositMax = CuratorDepositMax;
+	type BountyValueMinimum = BountyValueMinimum;
+	type DataDepositPerByte = DataDepositPerByte;
+	type MaximumReasonLength = MaximumReasonLength;
+	type WeightInfo = pallet_bounties::weights::SubstrateWeight<Runtime>;
+	type ChildBountyManager = ChildBounties;
+}
+
+parameter_types! {
+	/// Allocate at most 20% of each block for message processing.
+	///
+	/// Is set to 20% since the scheduler can already consume a maximum of 80%.
+	pub MessageQueueServiceWeight: Option<Weight> = Some(Perbill::from_percent(20) * RuntimeBlockWeights::get().max_block);
+}
+
+impl pallet_message_queue::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	/// NOTE: Always set this to `NoopMessageProcessor` for benchmarking.
+	type MessageProcessor = pallet_message_queue::mock_helpers::NoopMessageProcessor<u32>;
+	type Size = u32;
+	type QueueChangeHandler = ();
+	type QueuePausedQuery = ();
+	type HeapSize = ConstU32<{ 64 * 1024 }>;
+	type MaxStale = ConstU32<128>;
+	type ServiceWeight = MessageQueueServiceWeight;
+}
+
+parameter_types! {
+	pub const ChildBountyValueMinimum: Balance = 1 * DOLLARS;
+}
+
+impl pallet_child_bounties::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type MaxActiveChildBountyCount = ConstU32<5>;
+	type ChildBountyValueMinimum = ChildBountyValueMinimum;
+	type WeightInfo = pallet_child_bounties::weights::SubstrateWeight<Runtime>;
+}
+
+impl pallet_tips::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type DataDepositPerByte = DataDepositPerByte;
+	type MaximumReasonLength = MaximumReasonLength;
+	type Tippers = Elections;
+	type TipCountdown = TipCountdown;
+	type TipFindersFee = TipFindersFee;
+	type TipReportDepositBase = TipReportDepositBase;
+	type WeightInfo = pallet_tips::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const DepositPerItem: Balance = deposit(1, 0);
+	pub const DepositPerByte: Balance = deposit(0, 1);
+	pub const DefaultDepositLimit: Balance = deposit(1024, 1024 * 1024);
+	pub Schedule: pallet_contracts::Schedule<Runtime> = Default::default();
+	pub CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(30);
+}
+
+impl pallet_contracts::Config for Runtime {
+	type Time = Timestamp;
+	type Randomness = RandomnessCollectiveFlip;
+	type Currency = Balances;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	/// The safest default is to allow no calls at all.
+	///
+	/// Runtimes should whitelist dispatchables that are allowed to be called from contracts
+	/// and make sure they are stable. Dispatchables exposed to contracts are not allowed to
+	/// change because that would break already deployed contracts. The `Call` structure itself
+	/// is not allowed to change the indices of existing pallets, too.
+	type CallFilter = Nothing;
+	type DepositPerItem = DepositPerItem;
+	type DepositPerByte = DepositPerByte;
+	type DefaultDepositLimit = DefaultDepositLimit;
+	type CallStack = [pallet_contracts::Frame<Self>; 5];
+	type WeightPrice = pallet_transaction_payment::Pallet<Self>;
+	type WeightInfo = pallet_contracts::weights::SubstrateWeight<Self>;
+	type ChainExtension = ();
+	type Schedule = Schedule;
+	type AddressGenerator = pallet_contracts::DefaultAddressGenerator;
+	type MaxCodeLen = ConstU32<{ 123 * 1024 }>;
+	type MaxStorageKeyLen = ConstU32<128>;
+	type UnsafeUnstableInterface = ConstBool<false>;
+	type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	type Migrations = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type Migrations = pallet_contracts::migration::codegen::BenchMigrations;
+	type MaxDelegateDependencies = ConstU32<32>;
+	type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
+	type Debug = ();
+	type Environment = ();
+}
+
+impl pallet_sudo::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type WeightInfo = pallet_sudo::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const ImOnlineUnsignedPriority: TransactionPriority = TransactionPriority::max_value();
+	/// We prioritize im-online heartbeats over election solution submission.
+	pub const StakingUnsignedPriority: TransactionPriority = TransactionPriority::max_value() / 2;
+	pub const MaxAuthorities: u32 = 100;
+	pub const MaxKeys: u32 = 10_000;
+	pub const MaxPeerInHeartbeats: u32 = 10_000;
+}
+
+impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Runtime
+where
+	RuntimeCall: From<LocalCall>,
+{
+	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
+		call: RuntimeCall,
+		public: <Signature as traits::Verify>::Signer,
+		account: AccountId,
+		nonce: Nonce,
+	) -> Option<(RuntimeCall, <UncheckedExtrinsic as traits::Extrinsic>::SignaturePayload)> {
+		let tip = 0;
+		// take the biggest period possible.
+		let period =
+			BlockHashCount::get().checked_next_power_of_two().map(|c| c / 2).unwrap_or(2) as u64;
+		let current_block = System::block_number()
+			.saturated_into::<u64>()
+			// The `System::block_number` is initialized with `n+1`,
+			// so the actual block number is `n`.
+			.saturating_sub(1);
+		let era = Era::mortal(period, current_block);
+		let extra = (
+			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(era),
+			frame_system::CheckNonce::<Runtime>::from(nonce),
+			frame_system::CheckWeight::<Runtime>::new(),
+			pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::<Runtime>::from(tip, None),
+		);
+		let raw_payload = SignedPayload::new(call, extra)
+			.map_err(|e| {
+				log::warn!("Unable to create signed payload: {:?}", e);
+			})
+			.ok()?;
+		let signature = raw_payload.using_encoded(|payload| C::sign(payload, public))?;
+		let address = Indices::unlookup(account);
+		let (call, extra, _) = raw_payload.deconstruct();
+		Some((call, (address, signature, extra)))
+	}
+}
+
+impl frame_system::offchain::SigningTypes for Runtime {
+	type Public = <Signature as traits::Verify>::Signer;
+	type Signature = Signature;
+}
+
+impl<C> frame_system::offchain::SendTransactionTypes<C> for Runtime
+where
+	RuntimeCall: From<C>,
+{
+	type Extrinsic = UncheckedExtrinsic;
+	type OverarchingCall = RuntimeCall;
+}
+
+impl pallet_im_online::Config for Runtime {
+	type AuthorityId = ImOnlineId;
+	type RuntimeEvent = RuntimeEvent;
+	type NextSessionRotation = Babe;
+	type ValidatorSet = Historical;
+	type ReportUnresponsiveness = Offences;
+	type UnsignedPriority = ImOnlineUnsignedPriority;
+	type WeightInfo = pallet_im_online::weights::SubstrateWeight<Runtime>;
+	type MaxKeys = MaxKeys;
+	type MaxPeerInHeartbeats = MaxPeerInHeartbeats;
+}
+
+impl pallet_offences::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
+	type OnOffenceHandler = Staking;
+}
+
+impl pallet_authority_discovery::Config for Runtime {
+	type MaxAuthorities = MaxAuthorities;
+}
+
+parameter_types! {
+	pub const MaxSetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();
+}
+
+impl pallet_grandpa::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type MaxAuthorities = MaxAuthorities;
+	type MaxNominators = MaxNominatorRewardedPerValidator;
+	type MaxSetIdSessionEntries = MaxSetIdSessionEntries;
+	type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, GrandpaId)>>::Proof;
+	type EquivocationReportSystem =
+		pallet_grandpa::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
+}
+
+parameter_types! {
+	pub const BasicDeposit: Balance = 10 * DOLLARS;       // 258 bytes on-chain
+	pub const FieldDeposit: Balance = 250 * CENTS;        // 66 bytes on-chain
+	pub const SubAccountDeposit: Balance = 2 * DOLLARS;   // 53 bytes on-chain
+	pub const MaxSubAccounts: u32 = 100;
+	pub const MaxAdditionalFields: u32 = 100;
+	pub const MaxRegistrars: u32 = 20;
+}
+
+impl pallet_identity::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type BasicDeposit = BasicDeposit;
+	type FieldDeposit = FieldDeposit;
+	type SubAccountDeposit = SubAccountDeposit;
+	type MaxSubAccounts = MaxSubAccounts;
+	type MaxAdditionalFields = MaxAdditionalFields;
+	type MaxRegistrars = MaxRegistrars;
+	type Slashed = Treasury;
+	type ForceOrigin = EnsureRootOrHalfCouncil;
+	type RegistrarOrigin = EnsureRootOrHalfCouncil;
+	type WeightInfo = pallet_identity::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const ConfigDepositBase: Balance = 5 * DOLLARS;
+	pub const FriendDepositFactor: Balance = 50 * CENTS;
+	pub const MaxFriends: u16 = 9;
+	pub const RecoveryDeposit: Balance = 5 * DOLLARS;
+}
+
+impl pallet_recovery::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = pallet_recovery::weights::SubstrateWeight<Runtime>;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type ConfigDepositBase = ConfigDepositBase;
+	type FriendDepositFactor = FriendDepositFactor;
+	type MaxFriends = MaxFriends;
+	type RecoveryDeposit = RecoveryDeposit;
+}
+
+parameter_types! {
+	pub const GraceStrikes: u32 = 10;
+	pub const SocietyVotingPeriod: BlockNumber = 80 * HOURS;
+	pub const ClaimPeriod: BlockNumber = 80 * HOURS;
+	pub const PeriodSpend: Balance = 500 * DOLLARS;
+	pub const MaxLockDuration: BlockNumber = 36 * 30 * DAYS;
+	pub const ChallengePeriod: BlockNumber = 7 * DAYS;
+	pub const MaxPayouts: u32 = 10;
+	pub const MaxBids: u32 = 10;
+	pub const SocietyPalletId: PalletId = PalletId(*b"py/socie");
+}
+
+impl pallet_society::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = SocietyPalletId;
+	type Currency = Balances;
+	type Randomness = RandomnessCollectiveFlip;
+	type GraceStrikes = GraceStrikes;
+	type PeriodSpend = PeriodSpend;
+	type VotingPeriod = SocietyVotingPeriod;
+	type ClaimPeriod = ClaimPeriod;
+	type MaxLockDuration = MaxLockDuration;
+	type FounderSetOrigin =
+		pallet_collective::EnsureProportionMoreThan<AccountId, CouncilCollective, 1, 2>;
+	type ChallengePeriod = ChallengePeriod;
+	type MaxPayouts = MaxPayouts;
+	type MaxBids = MaxBids;
+	type WeightInfo = pallet_society::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const MinVestedTransfer: Balance = 100 * DOLLARS;
+	pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =
+		WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);
+}
+
+impl pallet_vesting::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type BlockNumberToBalance = ConvertInto;
+	type MinVestedTransfer = MinVestedTransfer;
+	type WeightInfo = pallet_vesting::weights::SubstrateWeight<Runtime>;
+	type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;
+	// `VestingInfo` encode length is 36bytes. 28 schedules gets encoded as 1009 bytes, which is the
+	// highest number of schedules that encodes less than 2^10.
+	const MAX_VESTING_SCHEDULES: u32 = 28;
+}
+
+impl pallet_mmr::Config for Runtime {
+	const INDEXING_PREFIX: &'static [u8] = b"mmr";
+	type Hashing = <Runtime as frame_system::Config>::Hashing;
+	type LeafData = pallet_mmr::ParentNumberAndHash<Self>;
+	type OnNewRoot = ();
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub const LotteryPalletId: PalletId = PalletId(*b"py/lotto");
+	pub const MaxCalls: u32 = 10;
+	pub const MaxGenerateRandom: u32 = 10;
+}
+
+impl pallet_lottery::Config for Runtime {
+	type PalletId = LotteryPalletId;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type Randomness = RandomnessCollectiveFlip;
+	type RuntimeEvent = RuntimeEvent;
+	type ManagerOrigin = EnsureRoot<AccountId>;
+	type MaxCalls = MaxCalls;
+	type ValidateCall = Lottery;
+	type MaxGenerateRandom = MaxGenerateRandom;
+	type WeightInfo = pallet_lottery::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const AssetDeposit: Balance = 100 * DOLLARS;
+	pub const ApprovalDeposit: Balance = 1 * DOLLARS;
+	pub const StringLimit: u32 = 50;
+	pub const MetadataDepositBase: Balance = 10 * DOLLARS;
+	pub const MetadataDepositPerByte: Balance = 1 * DOLLARS;
+}
+
+impl pallet_assets::Config<Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u128;
+	type AssetId = u32;
+	type AssetIdParameter = codec::Compact<u32>;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<AccountId>>;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type AssetDeposit = AssetDeposit;
+	type AssetAccountDeposit = ConstU128<DOLLARS>;
+	type MetadataDepositBase = MetadataDepositBase;
+	type MetadataDepositPerByte = MetadataDepositPerByte;
+	type ApprovalDeposit = ApprovalDeposit;
+	type StringLimit = StringLimit;
+	type Freezer = ();
+	type Extra = ();
+	type CallbackHandle = ();
+	type WeightInfo = pallet_assets::weights::SubstrateWeight<Runtime>;
+	type RemoveItemsLimit = ConstU32<1000>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+ord_parameter_types! {
+	pub const AssetConversionOrigin: AccountId = AccountIdConversion::<AccountId>::into_account_truncating(&AssetConversionPalletId::get());
+}
+
+impl pallet_assets::Config<Instance2> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u128;
+	type AssetId = u32;
+	type AssetIdParameter = codec::Compact<u32>;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSignedBy<AssetConversionOrigin, AccountId>>;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type AssetDeposit = AssetDeposit;
+	type AssetAccountDeposit = ConstU128<DOLLARS>;
+	type MetadataDepositBase = MetadataDepositBase;
+	type MetadataDepositPerByte = MetadataDepositPerByte;
+	type ApprovalDeposit = ApprovalDeposit;
+	type StringLimit = StringLimit;
+	type Freezer = ();
+	type Extra = ();
+	type WeightInfo = pallet_assets::weights::SubstrateWeight<Runtime>;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type CallbackHandle = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+parameter_types! {
+	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
+	pub AllowMultiAssetPools: bool = true;
+	pub const PoolSetupFee: Balance = 1 * DOLLARS; // should be more or equal to the existential deposit
+	pub const MintMinLiquidity: Balance = 100;  // 100 is good enough when the main currency has 10-12 decimals.
+	pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0);  // should be non-zero if AllowMultiAssetPools is true, otherwise can be zero.
+}
+
+impl pallet_asset_conversion::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type AssetBalance = <Self as pallet_balances::Config>::Balance;
+	type HigherPrecisionBalance = sp_core::U256;
+	type Assets = Assets;
+	type Balance = u128;
+	type PoolAssets = PoolAssets;
+	type AssetId = <Self as pallet_assets::Config<Instance1>>::AssetId;
+	type MultiAssetId = NativeOrAssetId<u32>;
+	type PoolAssetId = <Self as pallet_assets::Config<Instance2>>::AssetId;
+	type PalletId = AssetConversionPalletId;
+	type LPFee = ConstU32<3>; // means 0.3%
+	type PoolSetupFee = PoolSetupFee;
+	type PoolSetupFeeReceiver = AssetConversionOrigin;
+	type LiquidityWithdrawalFee = LiquidityWithdrawalFee;
+	type WeightInfo = pallet_asset_conversion::weights::SubstrateWeight<Runtime>;
+	type AllowMultiAssetPools = AllowMultiAssetPools;
+	type MaxSwapPathLength = ConstU32<4>;
+	type MintMinLiquidity = MintMinLiquidity;
+	type MultiAssetIdConverter = NativeOrAssetIdConverter<u32>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+parameter_types! {
+	pub const QueueCount: u32 = 300;
+	pub const MaxQueueLen: u32 = 1000;
+	pub const FifoQueueLen: u32 = 500;
+	pub const NisBasePeriod: BlockNumber = 30 * DAYS;
+	pub const MinBid: Balance = 100 * DOLLARS;
+	pub const MinReceipt: Perquintill = Perquintill::from_percent(1);
+	pub const IntakePeriod: BlockNumber = 10;
+	pub MaxIntakeWeight: Weight = MAXIMUM_BLOCK_WEIGHT / 10;
+	pub const ThawThrottle: (Perquintill, BlockNumber) = (Perquintill::from_percent(25), 5);
+	pub Target: Perquintill = Perquintill::zero();
+	pub const NisPalletId: PalletId = PalletId(*b"py/nis  ");
+}
+
+impl pallet_nis::Config for Runtime {
+	type WeightInfo = pallet_nis::weights::SubstrateWeight<Runtime>;
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type CurrencyBalance = Balance;
+	type FundOrigin = frame_system::EnsureSigned<AccountId>;
+	type Counterpart = ItemOf<Assets, ConstU32<9u32>, AccountId>;
+	type CounterpartAmount = WithMaximumOf<ConstU128<21_000_000_000_000_000_000u128>>;
+	type Deficit = ();
+	type IgnoredIssuance = ();
+	type Target = Target;
+	type PalletId = NisPalletId;
+	type QueueCount = QueueCount;
+	type MaxQueueLen = MaxQueueLen;
+	type FifoQueueLen = FifoQueueLen;
+	type BasePeriod = NisBasePeriod;
+	type MinBid = MinBid;
+	type MinReceipt = MinReceipt;
+	type IntakePeriod = IntakePeriod;
+	type MaxIntakeWeight = MaxIntakeWeight;
+	type ThawThrottle = ThawThrottle;
+	type RuntimeHoldReason = RuntimeHoldReason;
+}
+
+parameter_types! {
+	pub const CollectionDeposit: Balance = 100 * DOLLARS;
+	pub const ItemDeposit: Balance = 1 * DOLLARS;
+	pub const ApprovalsLimit: u32 = 20;
+	pub const ItemAttributesApprovalsLimit: u32 = 20;
+	pub const MaxTips: u32 = 10;
+	pub const MaxDeadlineDuration: BlockNumber = 12 * 30 * DAYS;
+}
+
+impl pallet_uniques::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
+	type CollectionDeposit = CollectionDeposit;
+	type ItemDeposit = ItemDeposit;
+	type MetadataDepositBase = MetadataDepositBase;
+	type AttributeDepositBase = MetadataDepositBase;
+	type DepositPerByte = MetadataDepositPerByte;
+	type StringLimit = ConstU32<128>;
+	type KeyLimit = ConstU32<32>;
+	type ValueLimit = ConstU32<64>;
+	type WeightInfo = pallet_uniques::weights::SubstrateWeight<Runtime>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type Helper = ();
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<AccountId>>;
+	type Locker = ();
+}
+
+parameter_types! {
+	pub const Budget: Balance = 10_000 * DOLLARS;
+	pub TreasuryAccount: AccountId = Treasury::account_id();
+}
+
+pub struct SalaryForRank;
+impl GetSalary<u16, AccountId, Balance> for SalaryForRank {
+	fn get_salary(a: u16, _: &AccountId) -> Balance {
+		Balance::from(a) * 1000 * DOLLARS
+	}
+}
+
+impl pallet_salary::Config for Runtime {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Paymaster = PayFromAccount<Balances, TreasuryAccount>;
+	type Members = RankedCollective;
+	type Salary = SalaryForRank;
+	type RegistrationPeriod = ConstU32<200>;
+	type PayoutPeriod = ConstU32<200>;
+	type Budget = Budget;
+}
+
+impl pallet_core_fellowship::Config for Runtime {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Members = RankedCollective;
+	type Balance = Balance;
+	type ParamsOrigin = frame_system::EnsureRoot<AccountId>;
+	type InductOrigin = pallet_core_fellowship::EnsureInducted<Runtime, (), 1>;
+	type ApproveOrigin = EnsureRootWithSuccess<AccountId, ConstU16<9>>;
+	type PromoteOrigin = EnsureRootWithSuccess<AccountId, ConstU16<9>>;
+	type EvidenceSize = ConstU32<16_384>;
+}
+
+parameter_types! {
+	pub const NftFractionalizationPalletId: PalletId = PalletId(*b"fraction");
+	pub NewAssetSymbol: BoundedVec<u8, StringLimit> = (*b"FRAC").to_vec().try_into().unwrap();
+	pub NewAssetName: BoundedVec<u8, StringLimit> = (*b"Frac").to_vec().try_into().unwrap();
+}
+
+impl pallet_nft_fractionalization::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Deposit = AssetDeposit;
+	type Currency = Balances;
+	type NewAssetSymbol = NewAssetSymbol;
+	type NewAssetName = NewAssetName;
+	type StringLimit = StringLimit;
+	type NftCollectionId = <Self as pallet_nfts::Config>::CollectionId;
+	type NftId = <Self as pallet_nfts::Config>::ItemId;
+	type AssetBalance = <Self as pallet_balances::Config>::Balance;
+	type AssetId = <Self as pallet_assets::Config<Instance1>>::AssetId;
+	type Assets = Assets;
+	type Nfts = Nfts;
+	type PalletId = NftFractionalizationPalletId;
+	type WeightInfo = pallet_nft_fractionalization::weights::SubstrateWeight<Runtime>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+parameter_types! {
+	pub Features: PalletFeatures = PalletFeatures::all_enabled();
+	pub const MaxAttributesPerCall: u32 = 10;
+}
+
+impl pallet_nfts::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
+	type CollectionDeposit = CollectionDeposit;
+	type ItemDeposit = ItemDeposit;
+	type MetadataDepositBase = MetadataDepositBase;
+	type AttributeDepositBase = MetadataDepositBase;
+	type DepositPerByte = MetadataDepositPerByte;
+	type StringLimit = ConstU32<256>;
+	type KeyLimit = ConstU32<64>;
+	type ValueLimit = ConstU32<256>;
+	type ApprovalsLimit = ApprovalsLimit;
+	type ItemAttributesApprovalsLimit = ItemAttributesApprovalsLimit;
+	type MaxTips = MaxTips;
+	type MaxDeadlineDuration = MaxDeadlineDuration;
+	type MaxAttributesPerCall = MaxAttributesPerCall;
+	type Features = Features;
+	type OffchainSignature = Signature;
+	type OffchainPublic = <Signature as traits::Verify>::Signer;
+	type WeightInfo = pallet_nfts::weights::SubstrateWeight<Runtime>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type Helper = ();
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<AccountId>>;
+	type Locker = ();
+}
+
+impl pallet_transaction_storage::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type RuntimeCall = RuntimeCall;
+	type FeeDestination = ();
+	type WeightInfo = pallet_transaction_storage::weights::SubstrateWeight<Runtime>;
+	type MaxBlockTransactions =
+		ConstU32<{ pallet_transaction_storage::DEFAULT_MAX_BLOCK_TRANSACTIONS }>;
+	type MaxTransactionSize =
+		ConstU32<{ pallet_transaction_storage::DEFAULT_MAX_TRANSACTION_SIZE }>;
+}
+
+impl pallet_whitelist::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type WhitelistOrigin = EnsureRoot<AccountId>;
+	type DispatchWhitelistedOrigin = EnsureRoot<AccountId>;
+	type Preimages = Preimage;
+	type WeightInfo = pallet_whitelist::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const MigrationSignedDepositPerItem: Balance = 1 * CENTS;
+	pub const MigrationSignedDepositBase: Balance = 20 * DOLLARS;
+	pub const MigrationMaxKeyLen: u32 = 512;
+}
+
+impl pallet_state_trie_migration::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type ControlOrigin = EnsureRoot<AccountId>;
+	type Currency = Balances;
+	type MaxKeyLen = MigrationMaxKeyLen;
+	type SignedDepositPerItem = MigrationSignedDepositPerItem;
+	type SignedDepositBase = MigrationSignedDepositBase;
+	// Warning: this is not advised, as it might allow the chain to be temporarily DOS-ed.
+	// Preferably, if the chain's governance/maintenance team is planning on using a specific
+	// account for the migration, put it here to make sure only that account can trigger the signed
+	// migrations.
+	type SignedFilter = EnsureSigned<Self::AccountId>;
+	type WeightInfo = ();
+}
+
+const ALLIANCE_MOTION_DURATION_IN_BLOCKS: BlockNumber = 5 * DAYS;
+
+parameter_types! {
+	pub const AllianceMotionDuration: BlockNumber = ALLIANCE_MOTION_DURATION_IN_BLOCKS;
+	pub const AllianceMaxProposals: u32 = 100;
+	pub const AllianceMaxMembers: u32 = 100;
+}
+
+type AllianceCollective = pallet_collective::Instance3;
+impl pallet_collective::Config<AllianceCollective> for Runtime {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = AllianceMotionDuration;
+	type MaxProposals = AllianceMaxProposals;
+	type MaxMembers = AllianceMaxMembers;
+	type DefaultVote = pallet_collective::PrimeDefaultVote;
+	type WeightInfo = pallet_collective::weights::SubstrateWeight<Runtime>;
+	type SetMembersOrigin = EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxCollectivesProposalWeight;
+}
+
+parameter_types! {
+	pub const MaxFellows: u32 = AllianceMaxMembers::get();
+	pub const MaxAllies: u32 = 100;
+	pub const AllyDeposit: Balance = 10 * DOLLARS;
+	pub const RetirementPeriod: BlockNumber = ALLIANCE_MOTION_DURATION_IN_BLOCKS + (1 * DAYS);
+}
+
+impl pallet_alliance::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Proposal = RuntimeCall;
+	type AdminOrigin = EitherOfDiverse<
+		EnsureRoot<AccountId>,
+		pallet_collective::EnsureProportionMoreThan<AccountId, AllianceCollective, 2, 3>,
+	>;
+	type MembershipManager = EitherOfDiverse<
+		EnsureRoot<AccountId>,
+		pallet_collective::EnsureProportionMoreThan<AccountId, AllianceCollective, 2, 3>,
+	>;
+	type AnnouncementOrigin = EitherOfDiverse<
+		EnsureRoot<AccountId>,
+		pallet_collective::EnsureProportionMoreThan<AccountId, AllianceCollective, 2, 3>,
+	>;
+	type Currency = Balances;
+	type Slashed = Treasury;
+	type InitializeMembers = AllianceMotion;
+	type MembershipChanged = AllianceMotion;
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	type IdentityVerifier = AllianceIdentityVerifier;
+	#[cfg(feature = "runtime-benchmarks")]
+	type IdentityVerifier = ();
+	type ProposalProvider = AllianceProposalProvider;
+	type MaxProposals = AllianceMaxProposals;
+	type MaxFellows = MaxFellows;
+	type MaxAllies = MaxAllies;
+	type MaxUnscrupulousItems = ConstU32<100>;
+	type MaxWebsiteUrlLength = ConstU32<255>;
+	type MaxAnnouncementsCount = ConstU32<100>;
+	type MaxMembersCount = AllianceMaxMembers;
+	type AllyDeposit = AllyDeposit;
+	type WeightInfo = pallet_alliance::weights::SubstrateWeight<Runtime>;
+	type RetirementPeriod = RetirementPeriod;
+}
+
+impl frame_benchmarking_pallet_pov::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+parameter_types! {
+	pub StatementCost: Balance = 1 * DOLLARS;
+	pub StatementByteCost: Balance = 100 * MILLICENTS;
+	pub const MinAllowedStatements: u32 = 4;
+	pub const MaxAllowedStatements: u32 = 10;
+	pub const MinAllowedBytes: u32 = 1024;
+	pub const MaxAllowedBytes: u32 = 4096;
+}
+
+impl pallet_statement::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type StatementCost = StatementCost;
+	type ByteCost = StatementByteCost;
+	type MinAllowedStatements = MinAllowedStatements;
+	type MaxAllowedStatements = MaxAllowedStatements;
+	type MinAllowedBytes = MinAllowedBytes;
+	type MaxAllowedBytes = MaxAllowedBytes;
+}
+
+parameter_types! {
+	pub const BrokerPalletId: PalletId = PalletId(*b"py/broke");
+}
+
+pub struct IntoAuthor;
+impl OnUnbalanced<Credit<AccountId, Balances>> for IntoAuthor {
+	fn on_nonzero_unbalanced(credit: Credit<AccountId, Balances>) {
+		if let Some(author) = Authorship::author() {
+			let _ = <Balances as Balanced<_>>::resolve(&author, credit);
+		}
+	}
+}
+
+parameter_types! {
+	pub storage CoreCount: Option<CoreIndex> = None;
+	pub storage CoretimeRevenue: Option<(BlockNumber, Balance)> = None;
+}
+
+pub struct CoretimeProvider;
+impl CoretimeInterface for CoretimeProvider {
+	type AccountId = AccountId;
+	type Balance = Balance;
+	type BlockNumber = BlockNumber;
+	fn latest() -> Self::BlockNumber {
+		System::block_number()
+	}
+	fn request_core_count(_count: CoreIndex) {}
+	fn request_revenue_info_at(_when: Self::BlockNumber) {}
+	fn credit_account(_who: Self::AccountId, _amount: Self::Balance) {}
+	fn assign_core(
+		_core: CoreIndex,
+		_begin: Self::BlockNumber,
+		_assignment: Vec<(CoreAssignment, PartsOf57600)>,
+		_end_hint: Option<Self::BlockNumber>,
+	) {
+	}
+	fn check_notify_core_count() -> Option<u16> {
+		let count = CoreCount::get();
+		CoreCount::set(&None);
+		count
+	}
+	fn check_notify_revenue_info() -> Option<(Self::BlockNumber, Self::Balance)> {
+		let revenue = CoretimeRevenue::get();
+		CoretimeRevenue::set(&None);
+		revenue
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_core_count(count: u16) {
+		CoreCount::set(&Some(count));
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_revenue_info(when: Self::BlockNumber, revenue: Self::Balance) {
+		CoretimeRevenue::set(&Some((when, revenue)));
+	}
+}
+
+impl pallet_broker::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type OnRevenue = IntoAuthor;
+	type TimeslicePeriod = ConstU32<2>;
+	type MaxLeasedCores = ConstU32<5>;
+	type MaxReservedCores = ConstU32<5>;
+	type Coretime = CoretimeProvider;
+	type ConvertBalance = traits::Identity;
+	type WeightInfo = ();
+	type PalletId = BrokerPalletId;
+	type AdminOrigin = EnsureRoot<AccountId>;
+	type PriceAdapter = pallet_broker::Linear;
+}
+
+construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system,
+		Utility: pallet_utility,
+		Babe: pallet_babe,
+		Timestamp: pallet_timestamp,
+		// Authorship must be before session in order to note author in the correct session and era
+		// for im-online and staking.
+		Authorship: pallet_authorship,
+		Indices: pallet_indices,
+		Balances: pallet_balances,
+		TransactionPayment: pallet_transaction_payment,
+		AssetTxPayment: pallet_asset_tx_payment,
+		AssetConversionTxPayment: pallet_asset_conversion_tx_payment,
+		ElectionProviderMultiPhase: pallet_election_provider_multi_phase,
+		Staking: pallet_staking,
+		Session: pallet_session,
+		Democracy: pallet_democracy,
+		Council: pallet_collective::<Instance1>,
+		TechnicalCommittee: pallet_collective::<Instance2>,
+		Elections: pallet_elections_phragmen,
+		TechnicalMembership: pallet_membership::<Instance1>,
+		Grandpa: pallet_grandpa,
+		Treasury: pallet_treasury,
+		AssetRate: pallet_asset_rate,
+		Contracts: pallet_contracts,
+		Sudo: pallet_sudo,
+		ImOnline: pallet_im_online,
+		AuthorityDiscovery: pallet_authority_discovery,
+		Offences: pallet_offences,
+		Historical: pallet_session_historical::{Pallet},
+		RandomnessCollectiveFlip: pallet_insecure_randomness_collective_flip,
+		Identity: pallet_identity,
+		Society: pallet_society,
+		Recovery: pallet_recovery,
+		Vesting: pallet_vesting,
+		Scheduler: pallet_scheduler,
+		Glutton: pallet_glutton,
+		Preimage: pallet_preimage,
+		Proxy: pallet_proxy,
+		Multisig: pallet_multisig,
+		Bounties: pallet_bounties,
+		Tips: pallet_tips,
+		Assets: pallet_assets::<Instance1>,
+		PoolAssets: pallet_assets::<Instance2>,
+		Mmr: pallet_mmr,
+		Lottery: pallet_lottery,
+		Nis: pallet_nis,
+		Uniques: pallet_uniques,
+		Nfts: pallet_nfts,
+		NftFractionalization: pallet_nft_fractionalization,
+		Salary: pallet_salary,
+		CoreFellowship: pallet_core_fellowship,
+		TransactionStorage: pallet_transaction_storage,
+		VoterList: pallet_bags_list::<Instance1>,
+		StateTrieMigration: pallet_state_trie_migration,
+		ChildBounties: pallet_child_bounties,
+		Referenda: pallet_referenda,
+		Remark: pallet_remark,
+		RootTesting: pallet_root_testing,
+		ConvictionVoting: pallet_conviction_voting,
+		Whitelist: pallet_whitelist,
+		AllianceMotion: pallet_collective::<Instance3>,
+		Alliance: pallet_alliance,
+		NominationPools: pallet_nomination_pools,
+		RankedPolls: pallet_referenda::<Instance2>,
+		RankedCollective: pallet_ranked_collective,
+		AssetConversion: pallet_asset_conversion,
+		FastUnstake: pallet_fast_unstake,
+		MessageQueue: pallet_message_queue,
+		Pov: frame_benchmarking_pallet_pov,
+		TxPause: pallet_tx_pause,
+		SafeMode: pallet_safe_mode,
+		Statement: pallet_statement,
+		Broker: pallet_broker,
+	}
+);
+
+/// The address format for describing accounts.
+pub type Address = sp_runtime::MultiAddress<AccountId, AccountIndex>;
+/// Block header type as expected by this runtime.
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+/// Block type as expected by this runtime.
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+/// A Block signed with a Justification
+pub type SignedBlock = generic::SignedBlock<Block>;
+/// BlockId type as expected by this runtime.
+pub type BlockId = generic::BlockId<Block>;
+/// The SignedExtension to the basic transaction logic.
+///
+/// When you change this, you **MUST** modify [`sign`] in `bin/node/testing/src/keyring.rs`!
+///
+/// [`sign`]: <../../testing/src/keyring.rs.html>
+pub type SignedExtra = (
+	frame_system::CheckNonZeroSender<Runtime>,
+	frame_system::CheckSpecVersion<Runtime>,
+	frame_system::CheckTxVersion<Runtime>,
+	frame_system::CheckGenesis<Runtime>,
+	frame_system::CheckEra<Runtime>,
+	frame_system::CheckNonce<Runtime>,
+	frame_system::CheckWeight<Runtime>,
+	pallet_asset_conversion_tx_payment::ChargeAssetTxPayment<Runtime>,
+);
+
+/// Unchecked extrinsic type as expected by this runtime.
+pub type UncheckedExtrinsic =
+	generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
+/// The payload being signed in transactions.
+pub type SignedPayload = generic::SignedPayload<RuntimeCall, SignedExtra>;
+/// Extrinsic type that has already been checked.
+pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, RuntimeCall, SignedExtra>;
+/// Executive: handles dispatch to the various modules.
+pub type Executive = frame_executive::Executive<
+	Runtime,
+	Block,
+	frame_system::ChainContext<Runtime>,
+	Runtime,
+	AllPalletsWithSystem,
+	Migrations,
+>;
+
+// All migrations executed on runtime upgrade as a nested tuple of types implementing
+// `OnRuntimeUpgrade`.
+type Migrations = (
+	pallet_nomination_pools::migration::v2::MigrateToV2<Runtime>,
+	pallet_alliance::migration::Migration<Runtime>,
+	pallet_contracts::Migration<Runtime>,
+);
+
+type EventRecord = frame_system::EventRecord<
+	<Runtime as frame_system::Config>::RuntimeEvent,
+	<Runtime as frame_system::Config>::Hash,
+>;
+
+/// MMR helper types.
+mod mmr {
+	use super::Runtime;
+	pub use pallet_mmr::primitives::*;
+
+	pub type Leaf = <<Runtime as pallet_mmr::Config>::LeafData as LeafDataProvider>::LeafData;
+	pub type Hash = <Hashing as sp_runtime::traits::Hash>::Output;
+	pub type Hashing = <Runtime as pallet_mmr::Config>::Hashing;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benches {
+	frame_benchmarking::define_benchmarks!(
+		[frame_benchmarking, BaselineBench::<Runtime>]
+		[frame_benchmarking_pallet_pov, Pov]
+		[pallet_alliance, Alliance]
+		[pallet_assets, Assets]
+		[pallet_babe, Babe]
+		[pallet_bags_list, VoterList]
+		[pallet_balances, Balances]
+		[pallet_bounties, Bounties]
+		[pallet_broker, Broker]
+		[pallet_child_bounties, ChildBounties]
+		[pallet_collective, Council]
+		[pallet_conviction_voting, ConvictionVoting]
+		[pallet_contracts, Contracts]
+		[pallet_core_fellowship, CoreFellowship]
+		[pallet_democracy, Democracy]
+		[pallet_asset_conversion, AssetConversion]
+		[pallet_election_provider_multi_phase, ElectionProviderMultiPhase]
+		[pallet_election_provider_support_benchmarking, EPSBench::<Runtime>]
+		[pallet_elections_phragmen, Elections]
+		[pallet_fast_unstake, FastUnstake]
+		[pallet_nis, Nis]
+		[pallet_grandpa, Grandpa]
+		[pallet_identity, Identity]
+		[pallet_im_online, ImOnline]
+		[pallet_indices, Indices]
+		[pallet_lottery, Lottery]
+		[pallet_membership, TechnicalMembership]
+		[pallet_message_queue, MessageQueue]
+		[pallet_mmr, Mmr]
+		[pallet_multisig, Multisig]
+		[pallet_nomination_pools, NominationPoolsBench::<Runtime>]
+		[pallet_offences, OffencesBench::<Runtime>]
+		[pallet_preimage, Preimage]
+		[pallet_proxy, Proxy]
+		[pallet_ranked_collective, RankedCollective]
+		[pallet_referenda, Referenda]
+		[pallet_recovery, Recovery]
+		[pallet_remark, Remark]
+		[pallet_salary, Salary]
+		[pallet_scheduler, Scheduler]
+		[pallet_glutton, Glutton]
+		[pallet_session, SessionBench::<Runtime>]
+		[pallet_society, Society]
+		[pallet_staking, Staking]
+		[pallet_state_trie_migration, StateTrieMigration]
+		[pallet_sudo, Sudo]
+		[frame_system, SystemBench::<Runtime>]
+		[pallet_timestamp, Timestamp]
+		[pallet_tips, Tips]
+		[pallet_transaction_storage, TransactionStorage]
+		[pallet_treasury, Treasury]
+		[pallet_asset_rate, AssetRate]
+		[pallet_uniques, Uniques]
+		[pallet_nfts, Nfts]
+		[pallet_nft_fractionalization, NftFractionalization]
+		[pallet_utility, Utility]
+		[pallet_vesting, Vesting]
+		[pallet_whitelist, Whitelist]
+		[pallet_tx_pause, TxPause]
+		[pallet_safe_mode, SafeMode]
+	);
+}
+
+impl_runtime_apis! {
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> RuntimeVersion {
+			VERSION
+		}
+
+		fn execute_block(block: Block) {
+			Executive::execute_block(block);
+		}
+
+		fn initialize_block(header: &<Block as BlockT>::Header) {
+			Executive::initialize_block(header)
+		}
+	}
+
+	impl sp_api::Metadata<Block> for Runtime {
+		fn metadata() -> OpaqueMetadata {
+			OpaqueMetadata::new(Runtime::metadata().into())
+		}
+
+		fn metadata_at_version(version: u32) -> Option<OpaqueMetadata> {
+			Runtime::metadata_at_version(version)
+		}
+
+		fn metadata_versions() -> sp_std::vec::Vec<u32> {
+			Runtime::metadata_versions()
+		}
+	}
+
+	impl sp_block_builder::BlockBuilder<Block> for Runtime {
+		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
+			Executive::apply_extrinsic(extrinsic)
+		}
+
+		fn finalize_block() -> <Block as BlockT>::Header {
+			Executive::finalize_block()
+		}
+
+		fn inherent_extrinsics(data: InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+			data.create_extrinsics()
+		}
+
+		fn check_inherents(block: Block, data: InherentData) -> CheckInherentsResult {
+			data.check_extrinsics(&block)
+		}
+	}
+
+	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+		fn validate_transaction(
+			source: TransactionSource,
+			tx: <Block as BlockT>::Extrinsic,
+			block_hash: <Block as BlockT>::Hash,
+		) -> TransactionValidity {
+			Executive::validate_transaction(source, tx, block_hash)
+		}
+	}
+
+	impl sp_statement_store::runtime_api::ValidateStatement<Block> for Runtime {
+		fn validate_statement(
+			source: sp_statement_store::runtime_api::StatementSource,
+			statement: sp_statement_store::Statement,
+		) -> Result<sp_statement_store::runtime_api::ValidStatement, sp_statement_store::runtime_api::InvalidStatement> {
+			Statement::validate_statement(source, statement)
+		}
+	}
+
+	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
+		fn offchain_worker(header: &<Block as BlockT>::Header) {
+			Executive::offchain_worker(header)
+		}
+	}
+
+	impl sp_consensus_grandpa::GrandpaApi<Block> for Runtime {
+		fn grandpa_authorities() -> sp_consensus_grandpa::AuthorityList {
+			Grandpa::grandpa_authorities()
+		}
+
+		fn current_set_id() -> sp_consensus_grandpa::SetId {
+			Grandpa::current_set_id()
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			equivocation_proof: sp_consensus_grandpa::EquivocationProof<
+				<Block as BlockT>::Hash,
+				NumberFor<Block>,
+			>,
+			key_owner_proof: sp_consensus_grandpa::OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			let key_owner_proof = key_owner_proof.decode()?;
+
+			Grandpa::submit_unsigned_equivocation_report(
+				equivocation_proof,
+				key_owner_proof,
+			)
+		}
+
+		fn generate_key_ownership_proof(
+			_set_id: sp_consensus_grandpa::SetId,
+			authority_id: GrandpaId,
+		) -> Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof> {
+			use codec::Encode;
+
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, authority_id))
+				.map(|p| p.encode())
+				.map(sp_consensus_grandpa::OpaqueKeyOwnershipProof::new)
+		}
+	}
+
+	impl pallet_nomination_pools_runtime_api::NominationPoolsApi<Block, AccountId, Balance> for Runtime {
+		fn pending_rewards(who: AccountId) -> Balance {
+			NominationPools::api_pending_rewards(who).unwrap_or_default()
+		}
+
+		fn points_to_balance(pool_id: pallet_nomination_pools::PoolId, points: Balance) -> Balance {
+			NominationPools::api_points_to_balance(pool_id, points)
+		}
+
+		fn balance_to_points(pool_id: pallet_nomination_pools::PoolId, new_funds: Balance) -> Balance {
+			NominationPools::api_balance_to_points(pool_id, new_funds)
+		}
+	}
+
+	impl pallet_staking_runtime_api::StakingApi<Block, Balance> for Runtime {
+		fn nominations_quota(balance: Balance) -> u32 {
+			Staking::api_nominations_quota(balance)
+		}
+	}
+
+	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);
+			sp_consensus_babe::BabeConfiguration {
+				slot_duration: Babe::slot_duration(),
+				epoch_length: EpochDuration::get(),
+				c: epoch_config.c,
+				authorities: Babe::authorities().to_vec(),
+				randomness: Babe::randomness(),
+				allowed_slots: epoch_config.allowed_slots,
+			}
+		}
+
+		fn current_epoch_start() -> sp_consensus_babe::Slot {
+			Babe::current_epoch_start()
+		}
+
+		fn current_epoch() -> sp_consensus_babe::Epoch {
+			Babe::current_epoch()
+		}
+
+		fn next_epoch() -> sp_consensus_babe::Epoch {
+			Babe::next_epoch()
+		}
+
+		fn generate_key_ownership_proof(
+			_slot: sp_consensus_babe::Slot,
+			authority_id: sp_consensus_babe::AuthorityId,
+		) -> Option<sp_consensus_babe::OpaqueKeyOwnershipProof> {
+			use codec::Encode;
+
+			Historical::prove((sp_consensus_babe::KEY_TYPE, authority_id))
+				.map(|p| p.encode())
+				.map(sp_consensus_babe::OpaqueKeyOwnershipProof::new)
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			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()?;
+
+			Babe::submit_unsigned_equivocation_report(
+				equivocation_proof,
+				key_owner_proof,
+			)
+		}
+	}
+
+	impl sp_authority_discovery::AuthorityDiscoveryApi<Block> for Runtime {
+		fn authorities() -> Vec<AuthorityDiscoveryId> {
+			AuthorityDiscovery::authorities()
+		}
+	}
+
+	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
+		fn account_nonce(account: AccountId) -> Nonce {
+			System::account_nonce(account)
+		}
+	}
+
+	impl assets_api::AssetsApi<
+		Block,
+		AccountId,
+		Balance,
+		u32,
+	> for Runtime
+	{
+		fn account_balances(account: AccountId) -> Vec<(u32, Balance)> {
+			Assets::account_balances(account)
+		}
+	}
+
+	impl pallet_contracts::ContractsApi<Block, AccountId, Balance, BlockNumber, Hash, EventRecord> for Runtime
+	{
+		fn call(
+			origin: AccountId,
+			dest: AccountId,
+			value: Balance,
+			gas_limit: Option<Weight>,
+			storage_deposit_limit: Option<Balance>,
+			input_data: Vec<u8>,
+		) -> pallet_contracts_primitives::ContractExecResult<Balance, EventRecord> {
+			let gas_limit = gas_limit.unwrap_or(RuntimeBlockWeights::get().max_block);
+			Contracts::bare_call(
+				origin,
+				dest,
+				value,
+				gas_limit,
+				storage_deposit_limit,
+				input_data,
+				pallet_contracts::DebugInfo::UnsafeDebug,
+				pallet_contracts::CollectEvents::UnsafeCollect,
+				pallet_contracts::Determinism::Enforced,
+			)
+		}
+
+		fn instantiate(
+			origin: AccountId,
+			value: Balance,
+			gas_limit: Option<Weight>,
+			storage_deposit_limit: Option<Balance>,
+			code: pallet_contracts_primitives::Code<Hash>,
+			data: Vec<u8>,
+			salt: Vec<u8>,
+		) -> pallet_contracts_primitives::ContractInstantiateResult<AccountId, Balance, EventRecord>
+		{
+			let gas_limit = gas_limit.unwrap_or(RuntimeBlockWeights::get().max_block);
+			Contracts::bare_instantiate(
+				origin,
+				value,
+				gas_limit,
+				storage_deposit_limit,
+				code,
+				data,
+				salt,
+				pallet_contracts::DebugInfo::UnsafeDebug,
+				pallet_contracts::CollectEvents::UnsafeCollect,
+			)
+		}
+
+		fn upload_code(
+			origin: AccountId,
+			code: Vec<u8>,
+			storage_deposit_limit: Option<Balance>,
+			determinism: pallet_contracts::Determinism,
+		) -> pallet_contracts_primitives::CodeUploadResult<Hash, Balance>
+		{
+			Contracts::bare_upload_code(
+				origin,
+				code,
+				storage_deposit_limit,
+				determinism,
+			)
+		}
+
+		fn get_storage(
+			address: AccountId,
+			key: Vec<u8>,
+		) -> pallet_contracts_primitives::GetStorageResult {
+			Contracts::get_storage(
+				address,
+				key
+			)
+		}
+	}
+
+	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi<
+		Block,
+		Balance,
+	> for Runtime {
+		fn query_info(uxt: <Block as BlockT>::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance> {
+			TransactionPayment::query_info(uxt, len)
+		}
+		fn query_fee_details(uxt: <Block as BlockT>::Extrinsic, len: u32) -> FeeDetails<Balance> {
+			TransactionPayment::query_fee_details(uxt, len)
+		}
+		fn query_weight_to_fee(weight: Weight) -> Balance {
+			TransactionPayment::weight_to_fee(weight)
+		}
+		fn query_length_to_fee(length: u32) -> Balance {
+			TransactionPayment::length_to_fee(length)
+		}
+	}
+
+	impl pallet_asset_conversion::AssetConversionApi<
+		Block,
+		Balance,
+		u128,
+		NativeOrAssetId<u32>
+	> for Runtime
+	{
+		fn quote_price_exact_tokens_for_tokens(asset1: NativeOrAssetId<u32>, asset2: NativeOrAssetId<u32>, amount: u128, include_fee: bool) -> Option<Balance> {
+			AssetConversion::quote_price_exact_tokens_for_tokens(asset1, asset2, amount, include_fee)
+		}
+
+		fn quote_price_tokens_for_exact_tokens(asset1: NativeOrAssetId<u32>, asset2: NativeOrAssetId<u32>, amount: u128, include_fee: bool) -> Option<Balance> {
+			AssetConversion::quote_price_tokens_for_exact_tokens(asset1, asset2, amount, include_fee)
+		}
+
+		fn get_reserves(asset1: NativeOrAssetId<u32>, asset2: NativeOrAssetId<u32>) -> Option<(Balance, Balance)> {
+			AssetConversion::get_reserves(&asset1, &asset2).ok()
+		}
+	}
+
+	impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentCallApi<Block, Balance, RuntimeCall>
+		for Runtime
+	{
+		fn query_call_info(call: RuntimeCall, len: u32) -> RuntimeDispatchInfo<Balance> {
+			TransactionPayment::query_call_info(call, len)
+		}
+		fn query_call_fee_details(call: RuntimeCall, len: u32) -> FeeDetails<Balance> {
+			TransactionPayment::query_call_fee_details(call, len)
+		}
+		fn query_weight_to_fee(weight: Weight) -> Balance {
+			TransactionPayment::weight_to_fee(weight)
+		}
+		fn query_length_to_fee(length: u32) -> Balance {
+			TransactionPayment::length_to_fee(length)
+		}
+	}
+
+	impl pallet_nfts_runtime_api::NftsApi<Block, AccountId, u32, u32> for Runtime {
+		fn owner(collection: u32, item: u32) -> Option<AccountId> {
+			<Nfts as Inspect<AccountId>>::owner(&collection, &item)
+		}
+
+		fn collection_owner(collection: u32) -> Option<AccountId> {
+			<Nfts as Inspect<AccountId>>::collection_owner(&collection)
+		}
+
+		fn attribute(
+			collection: u32,
+			item: u32,
+			key: Vec<u8>,
+		) -> Option<Vec<u8>> {
+			<Nfts as Inspect<AccountId>>::attribute(&collection, &item, &key)
+		}
+
+		fn custom_attribute(
+			account: AccountId,
+			collection: u32,
+			item: u32,
+			key: Vec<u8>,
+		) -> Option<Vec<u8>> {
+			<Nfts as Inspect<AccountId>>::custom_attribute(
+				&account,
+				&collection,
+				&item,
+				&key,
+			)
+		}
+
+		fn system_attribute(
+			collection: u32,
+			item: u32,
+			key: Vec<u8>,
+		) -> Option<Vec<u8>> {
+			<Nfts as Inspect<AccountId>>::system_attribute(&collection, &item, &key)
+		}
+
+		fn collection_attribute(collection: u32, key: Vec<u8>) -> Option<Vec<u8>> {
+			<Nfts as Inspect<AccountId>>::collection_attribute(&collection, &key)
+		}
+	}
+
+	impl pallet_mmr::primitives::MmrApi<
+		Block,
+		mmr::Hash,
+		BlockNumber,
+	> for Runtime {
+		fn mmr_root() -> Result<mmr::Hash, mmr::Error> {
+			Ok(Mmr::mmr_root())
+		}
+
+		fn mmr_leaf_count() -> Result<mmr::LeafIndex, mmr::Error> {
+			Ok(Mmr::mmr_leaves())
+		}
+
+		fn generate_proof(
+			block_numbers: Vec<BlockNumber>,
+			best_known_block_number: Option<BlockNumber>,
+		) -> Result<(Vec<mmr::EncodableOpaqueLeaf>, mmr::Proof<mmr::Hash>), mmr::Error> {
+			Mmr::generate_proof(block_numbers, best_known_block_number).map(
+				|(leaves, proof)| {
+					(
+						leaves
+							.into_iter()
+							.map(|leaf| mmr::EncodableOpaqueLeaf::from_leaf(&leaf))
+							.collect(),
+						proof,
+					)
+				},
+			)
+		}
+
+		fn verify_proof(leaves: Vec<mmr::EncodableOpaqueLeaf>, proof: mmr::Proof<mmr::Hash>)
+			-> Result<(), mmr::Error>
+		{
+			let leaves = leaves.into_iter().map(|leaf|
+				leaf.into_opaque_leaf()
+				.try_decode()
+				.ok_or(mmr::Error::Verify)).collect::<Result<Vec<mmr::Leaf>, mmr::Error>>()?;
+			Mmr::verify_leaves(leaves, proof)
+		}
+
+		fn verify_proof_stateless(
+			root: mmr::Hash,
+			leaves: Vec<mmr::EncodableOpaqueLeaf>,
+			proof: mmr::Proof<mmr::Hash>
+		) -> Result<(), mmr::Error> {
+			let nodes = leaves.into_iter().map(|leaf|mmr::DataOrHash::Data(leaf.into_opaque_leaf())).collect();
+			pallet_mmr::verify_leaves_proof::<mmr::Hashing, _>(root, nodes, proof)
+		}
+	}
+
+	impl sp_session::SessionKeys<Block> for Runtime {
+		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
+			SessionKeys::generate(seed)
+		}
+
+		fn decode_session_keys(
+			encoded: Vec<u8>,
+		) -> Option<Vec<(Vec<u8>, KeyTypeId)>> {
+			SessionKeys::decode_into_raw_public_keys(&encoded)
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	impl frame_try_runtime::TryRuntime<Block> for Runtime {
+		fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) {
+			// NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
+			// have a backtrace here. If any of the pre/post migration checks fail, we shall stop
+			// right here and right now.
+			let weight = Executive::try_runtime_upgrade(checks).unwrap();
+			(weight, RuntimeBlockWeights::get().max_block)
+		}
+
+		fn execute_block(
+			block: Block,
+			state_root_check: bool,
+			signature_check: bool,
+			select: frame_try_runtime::TryStateSelect
+		) -> Weight {
+			// NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to
+			// have a backtrace here.
+			Executive::try_execute_block(block, state_root_check, signature_check, select).unwrap()
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	impl frame_benchmarking::Benchmark<Block> for Runtime {
+		fn benchmark_metadata(extra: bool) -> (
+			Vec<frame_benchmarking::BenchmarkList>,
+			Vec<frame_support::traits::StorageInfo>,
+		) {
+			use frame_benchmarking::{baseline, Benchmarking, BenchmarkList};
+			use frame_support::traits::StorageInfoTrait;
+
+			// Trying to add benchmarks directly to the Session Pallet caused cyclic dependency
+			// issues. To get around that, we separated the Session benchmarks into its own crate,
+			// which is why we need these two lines below.
+			use pallet_session_benchmarking::Pallet as SessionBench;
+			use pallet_offences_benchmarking::Pallet as OffencesBench;
+			use pallet_election_provider_support_benchmarking::Pallet as EPSBench;
+			use frame_system_benchmarking::Pallet as SystemBench;
+			use baseline::Pallet as BaselineBench;
+			use pallet_nomination_pools_benchmarking::Pallet as NominationPoolsBench;
+
+			let mut list = Vec::<BenchmarkList>::new();
+			list_benchmarks!(list, extra);
+
+			let storage_info = AllPalletsWithSystem::storage_info();
+
+			(list, storage_info)
+		}
+
+		fn dispatch_benchmark(
+			config: frame_benchmarking::BenchmarkConfig
+		) -> Result<Vec<frame_benchmarking::BenchmarkBatch>, sp_runtime::RuntimeString> {
+			use frame_benchmarking::{baseline, Benchmarking, BenchmarkBatch};
+			use sp_storage::TrackedStorageKey;
+
+			// Trying to add benchmarks directly to the Session Pallet caused cyclic dependency
+			// issues. To get around that, we separated the Session benchmarks into its own crate,
+			// which is why we need these two lines below.
+			use pallet_session_benchmarking::Pallet as SessionBench;
+			use pallet_offences_benchmarking::Pallet as OffencesBench;
+			use pallet_election_provider_support_benchmarking::Pallet as EPSBench;
+			use frame_system_benchmarking::Pallet as SystemBench;
+			use baseline::Pallet as BaselineBench;
+			use pallet_nomination_pools_benchmarking::Pallet as NominationPoolsBench;
+
+			impl pallet_session_benchmarking::Config for Runtime {}
+			impl pallet_offences_benchmarking::Config for Runtime {}
+			impl pallet_election_provider_support_benchmarking::Config for Runtime {}
+			impl frame_system_benchmarking::Config for Runtime {}
+			impl baseline::Config for Runtime {}
+			impl pallet_nomination_pools_benchmarking::Config for Runtime {}
+
+			use frame_support::traits::WhitelistedStorageKeys;
+			let mut whitelist: Vec<TrackedStorageKey> = AllPalletsWithSystem::whitelisted_storage_keys();
+
+			// Treasury Account
+			// TODO: this is manual for now, someday we might be able to use a
+			// macro for this particular key
+			let treasury_key = frame_system::Account::<Runtime>::hashed_key_for(Treasury::account_id());
+			whitelist.push(treasury_key.to_vec().into());
+
+			let mut batches = Vec::<BenchmarkBatch>::new();
+			let params = (&config, &whitelist);
+			add_benchmarks!(params, batches);
+			Ok(batches)
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use frame_election_provider_support::NposSolution;
+	use frame_system::offchain::CreateSignedTransaction;
+	use sp_runtime::UpperOf;
+
+	#[test]
+	fn validate_transaction_submitter_bounds() {
+		fn is_submit_signed_transaction<T>()
+		where
+			T: CreateSignedTransaction<RuntimeCall>,
+		{
+		}
+
+		is_submit_signed_transaction::<Runtime>();
+	}
+
+	#[test]
+	fn perbill_as_onchain_accuracy() {
+		type OnChainAccuracy =
+			<<Runtime as pallet_election_provider_multi_phase::MinerConfig>::Solution as NposSolution>::Accuracy;
+		let maximum_chain_accuracy: Vec<UpperOf<OnChainAccuracy>> = (0..MaxNominations::get())
+			.map(|_| <UpperOf<OnChainAccuracy>>::from(OnChainAccuracy::one().deconstruct()))
+			.collect();
+		let _: UpperOf<OnChainAccuracy> =
+			maximum_chain_accuracy.iter().fold(0, |acc, x| acc.checked_add(*x).unwrap());
+	}
+
+	#[test]
+	fn call_size() {
+		let size = core::mem::size_of::<RuntimeCall>();
+		assert!(
+			size <= CALL_PARAMS_MAX_SIZE,
+			"size of RuntimeCall {} is more than {CALL_PARAMS_MAX_SIZE} bytes.
+			 Some calls have too big arguments, use Box to reduce the size of RuntimeCall.
+			 If the limit is too strong, maybe consider increase the limit.",
+			size,
+		);
+	}
+}
diff --git a/substrate/bin/node/runtime/src/voter_bags.rs b/substrate/bin/node/runtime/src/voter_bags.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bf18097ddf53b723bbfd1e14fe948b51733d5858
--- /dev/null
+++ b/substrate/bin/node/runtime/src/voter_bags.rs
@@ -0,0 +1,238 @@
+// 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.
+
+//! Autogenerated bag thresholds.
+//!
+//! Generated on 2022-08-15T19:26:59.939787+00:00
+//! Arguments
+//! Total issuance: 100000000000000
+//! Minimum balance: 100000000000000
+//! for the node runtime.
+
+/// Existential weight for this runtime.
+#[cfg(any(test, feature = "std"))]
+#[allow(unused)]
+pub const EXISTENTIAL_WEIGHT: u64 = 100_000_000_000_000;
+
+/// Constant ratio between bags for this runtime.
+#[cfg(any(test, feature = "std"))]
+#[allow(unused)]
+pub const CONSTANT_RATIO: f64 = 1.0628253590743408;
+
+/// Upper thresholds delimiting the bag list.
+pub const THRESHOLDS: [u64; 200] = [
+	100_000_000_000_000,
+	106_282_535_907_434,
+	112_959_774_389_150,
+	120_056_512_776_105,
+	127_599_106_300_477,
+	135_615_565_971_369,
+	144_135_662_599_590,
+	153_191_037_357_827,
+	162_815_319_286_803,
+	173_044_250_183_800,
+	183_915_817_337_347,
+	195_470_394_601_017,
+	207_750_892_330_229,
+	220_802_916_738_890,
+	234_674_939_267_673,
+	249_418_476_592_914,
+	265_088_281_944_639,
+	281_742_548_444_211,
+	299_443_125_216_738,
+	318_255_747_080_822,
+	338_250_278_668_647,
+	359_500_973_883_001,
+	382_086_751_654_776,
+	406_091_489_025_036,
+	431_604_332_640_068,
+	458_720_029_816_222,
+	487_539_280_404_019,
+	518_169_110_758_247,
+	550_723_271_202_866,
+	585_322_658_466_782,
+	622_095_764_659_305,
+	661_179_154_452_653,
+	702_717_972_243_610,
+	746_866_481_177_808,
+	793_788_636_038_393,
+	843_658_692_126_636,
+	896_661_852_395_681,
+	952_994_955_240_703,
+	1_012_867_205_499_736,
+	1_076_500_951_379_881,
+	1_144_132_510_194_192,
+	1_216_013_045_975_769,
+	1_292_409_502_228_280,
+	1_373_605_593_276_862,
+	1_459_902_857_901_004,
+	1_551_621_779_162_291,
+	1_649_102_974_585_730,
+	1_752_708_461_114_642,
+	1_862_822_999_536_805,
+	1_979_855_523_374_646,
+	2_104_240_657_545_975,
+	2_236_440_332_435_128,
+	2_376_945_499_368_703,
+	2_526_277_953_866_680,
+	2_684_992_273_439_945,
+	2_853_677_877_130_641,
+	3_032_961_214_443_876,
+	3_223_508_091_799_862,
+	3_426_026_145_146_232,
+	3_641_267_467_913_124,
+	3_870_031_404_070_482,
+	4_113_167_516_660_186,
+	4_371_578_742_827_277,
+	4_646_224_747_067_156,
+	4_938_125_485_141_739,
+	5_248_364_991_899_922,
+	5_578_095_407_069_235,
+	5_928_541_253_969_291,
+	6_301_003_987_036_955,
+	6_696_866_825_051_405,
+	7_117_599_888_008_300,
+	7_564_765_656_719_910,
+	8_040_024_775_416_580,
+	8_545_142_218_898_723,
+	9_081_993_847_142_344,
+	9_652_573_371_700_016,
+	10_258_999_759_768_490,
+	10_903_525_103_419_522,
+	11_588_542_983_217_942,
+	12_316_597_357_287_042,
+	13_090_392_008_832_678,
+	13_912_800_587_211_472,
+	14_786_877_279_832_732,
+	15_715_868_154_526_436,
+	16_703_223_214_499_558,
+	17_752_609_210_649_358,
+	18_867_923_258_814_856,
+	20_053_307_312_537_008,
+	21_313_163_545_075_252,
+	22_652_170_697_804_756,
+	24_075_301_455_707_600,
+	25_587_840_914_485_432,
+	27_195_406_207_875_088,
+	28_903_967_368_057_400,
+	30_719_869_496_628_636,
+	32_649_856_328_471_220,
+	34_701_095_276_033_064,
+	36_881_204_047_022_752,
+	39_198_278_934_370_992,
+	41_660_924_883_519_016,
+	44_278_287_448_695_240,
+	47_060_086_756_856_400,
+	50_016_653_605_425_536,
+	53_158_967_827_883_320,
+	56_498_699_069_691_424,
+	60_048_250_125_977_912,
+	63_820_803_001_928_304,
+	67_830_367_866_937_216,
+	72_091_835_084_322_176,
+	76_621_030_509_822_880,
+	81_434_774_264_248_528,
+	86_550_943_198_537_824,
+	91_988_537_283_208_848,
+	97_767_750_168_749_840,
+	103_910_044_178_992_000,
+	110_438_230_015_967_792,
+	117_376_551_472_255_616,
+	124_750_775_465_407_920,
+	132_588_287_728_824_640,
+	140_918_194_514_440_064,
+	149_771_430_684_917_568,
+	159_180_874_596_775_264,
+	169_181_470_201_085_280,
+	179_810_356_815_193_344,
+	191_107_007_047_393_216,
+	203_113_373_386_768_288,
+	215_874_044_002_592_672,
+	229_436_408_331_885_600,
+	243_850_833_070_063_392,
+	259_170_849_218_267_264,
+	275_453_350_882_006_752,
+	292_758_806_559_399_232,
+	311_151_483_703_668_992,
+	330_699_687_393_865_920,
+	351_476_014_000_157_824,
+	373_557_620_785_735_808,
+	397_026_512_446_556_096,
+	421_969_845_653_044_224,
+	448_480_252_724_740_928,
+	476_656_185_639_923_904,
+	506_602_281_657_757_760,
+	538_429_751_910_786_752,
+	572_256_794_410_890_176,
+	608_209_033_002_485_632,
+	646_419_983_893_124_352,
+	687_031_551_494_039_552,
+	730_194_555_412_054_016,
+	776_069_290_549_944_960,
+	824_826_122_395_314_176,
+	876_646_119_708_695_936,
+	931_721_726_960_522_368,
+	990_257_479_014_182_144,
+	1_052_470_760_709_299_712,
+	1_118_592_614_166_106_112,
+	1_188_868_596_808_997_376,
+	1_263_559_693_295_730_432,
+	1_342_943_284_738_898_688,
+	1_427_314_178_819_094_784,
+	1_516_985_704_615_302_400,
+	1_612_290_876_218_400_768,
+	1_713_583_629_449_105_408,
+	1_821_240_136_273_157_632,
+	1_935_660_201_795_120_128,
+	2_057_268_749_018_809_600,
+	2_186_517_396_888_336_384,
+	2_323_886_137_470_138_880,
+	2_469_885_118_504_583_168,
+	2_625_056_537_947_004_416,
+	2_789_976_657_533_970_944,
+	2_965_257_942_852_572_160,
+	3_151_551_337_860_326_400,
+	3_349_548_682_302_620_672,
+	3_559_985_281_005_267_968,
+	3_783_642_634_583_792_128,
+	4_021_351_341_710_503_936,
+	4_273_994_183_717_548_544,
+	4_542_509_402_991_247_872,
+	4_827_894_187_332_742_144,
+	5_131_208_373_224_844_288,
+	5_453_578_381_757_959_168,
+	5_796_201_401_831_965_696,
+	6_160_349_836_169_256_960,
+	6_547_376_026_650_146_816,
+	6_958_717_276_519_173_120,
+	7_395_901_188_113_309_696,
+	7_860_551_335_934_872_576,
+	8_354_393_296_137_270_272,
+	8_879_261_054_815_360_000,
+	9_437_103_818_898_946_048,
+	10_029_993_254_943_105_024,
+	10_660_131_182_698_121_216,
+	11_329_857_752_030_707_712,
+	12_041_660_133_563_240_448,
+	12_798_181_755_305_525_248,
+	13_602_232_119_581_272_064,
+	14_456_797_236_706_498_560,
+	15_365_050_714_167_523_328,
+	16_330_365_542_480_556_032,
+	17_356_326_621_502_140_416,
+	18_446_744_073_709_551_615,
+];
diff --git a/substrate/bin/node/testing/Cargo.toml b/substrate/bin/node/testing/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..711c48c34329de39216414811204c25f87cb5251
--- /dev/null
+++ b/substrate/bin/node/testing/Cargo.toml
@@ -0,0 +1,48 @@
+[package]
+name = "node-testing"
+version = "3.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Test utilities for Substrate node."
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+fs_extra = "1"
+futures = "0.3.21"
+log = "0.4.17"
+tempfile = "3.1.0"
+frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
+node-executor = { version = "3.0.0-dev", path = "../executor" }
+node-primitives = { version = "2.0.0", path = "../primitives" }
+kitchensink-runtime = { version = "3.0.0-dev", path = "../runtime" }
+pallet-asset-conversion = { version = "4.0.0-dev", path = "../../../frame/asset-conversion" }
+pallet-assets = { version = "4.0.0-dev", path = "../../../frame/assets" }
+pallet-asset-conversion-tx-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/asset-conversion-tx-payment" }
+pallet-asset-tx-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/asset-tx-payment" }
+sc-block-builder = { version = "0.10.0-dev", path = "../../../client/block-builder" }
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api" }
+sc-client-db = { version = "0.10.0-dev", features = ["rocksdb"], path = "../../../client/db" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-executor = { version = "0.10.0-dev", path = "../../../client/executor" }
+sc-service = { version = "0.10.0-dev", features = [
+	"test-helpers",
+	"rocksdb",
+], path = "../../../client/service" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../../primitives/block-builder" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/timestamp" }
+substrate-test-client = { version = "2.0.0", path = "../../../test-utils/client" }
diff --git a/substrate/bin/node/testing/src/bench.rs b/substrate/bin/node/testing/src/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f1ab2212239b1937361af8941c89e254c6485a84
--- /dev/null
+++ b/substrate/bin/node/testing/src/bench.rs
@@ -0,0 +1,661 @@
+// 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/>.
+
+//! Benchmarking module.
+//!
+//! Utilities to do full-scale benchmarks involving database. With `BenchDb` you
+//! can pregenerate seed database and `clone` it for every iteration of your benchmarks
+//! or tests to get consistent, smooth benchmark experience!
+
+use std::{
+	collections::BTreeMap,
+	path::{Path, PathBuf},
+	sync::Arc,
+};
+
+use crate::{
+	client::{Backend, Client},
+	keyring::*,
+};
+use codec::{Decode, Encode};
+use futures::executor;
+use kitchensink_runtime::{
+	constants::currency::DOLLARS, AccountId, BalancesCall, CheckedExtrinsic, MinimumPeriod,
+	RuntimeCall, Signature, SystemCall, UncheckedExtrinsic,
+};
+use node_primitives::Block;
+use sc_block_builder::BlockBuilderProvider;
+use sc_client_api::execution_extensions::ExecutionExtensions;
+use sc_client_db::PruningMode;
+use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy, ImportResult, ImportedAux};
+use sc_executor::{NativeElseWasmExecutor, WasmExecutionMethod, WasmtimeInstantiationStrategy};
+use sp_api::ProvideRuntimeApi;
+use sp_block_builder::BlockBuilder;
+use sp_consensus::BlockOrigin;
+use sp_core::{blake2_256, ed25519, sr25519, traits::SpawnNamed, Pair, Public};
+use sp_inherents::InherentData;
+use sp_runtime::{
+	traits::{Block as BlockT, IdentifyAccount, Verify},
+	OpaqueExtrinsic,
+};
+
+/// Keyring full of accounts for benching.
+///
+/// Accounts are ordered:
+///     //endowed-user//00
+///     //endowed-user//01
+///      ...
+///     //endowed-user//N
+#[derive(Clone)]
+pub struct BenchKeyring {
+	accounts: BTreeMap<AccountId, BenchPair>,
+}
+
+#[derive(Clone)]
+enum BenchPair {
+	Sr25519(sr25519::Pair),
+	Ed25519(ed25519::Pair),
+}
+
+impl BenchPair {
+	fn sign(&self, payload: &[u8]) -> Signature {
+		match self {
+			Self::Sr25519(pair) => pair.sign(payload).into(),
+			Self::Ed25519(pair) => pair.sign(payload).into(),
+		}
+	}
+}
+
+/// Drop system cache.
+///
+/// Will panic if cache drop is impossbile.
+pub fn drop_system_cache() {
+	#[cfg(target_os = "windows")]
+	{
+		log::warn!(
+			target: "bench-logistics",
+			"Clearing system cache on windows is not supported. Benchmark might totally be wrong.",
+		);
+		return
+	}
+
+	std::process::Command::new("sync")
+		.output()
+		.expect("Failed to execute system cache clear");
+
+	#[cfg(target_os = "linux")]
+	{
+		log::trace!(target: "bench-logistics", "Clearing system cache...");
+		std::process::Command::new("echo")
+			.args(&["3", ">", "/proc/sys/vm/drop_caches", "2>", "/dev/null"])
+			.output()
+			.expect("Failed to execute system cache clear");
+
+		let temp = tempfile::tempdir().expect("Failed to spawn tempdir");
+		let temp_file_path = format!("of={}/buf", temp.path().to_string_lossy());
+
+		// this should refill write cache with 2GB of garbage
+		std::process::Command::new("dd")
+			.args(&["if=/dev/urandom", &temp_file_path, "bs=64M", "count=32"])
+			.output()
+			.expect("Failed to execute dd for cache clear");
+
+		// remove tempfile of previous command
+		std::process::Command::new("rm")
+			.arg(&temp_file_path)
+			.output()
+			.expect("Failed to remove temp file");
+
+		std::process::Command::new("sync")
+			.output()
+			.expect("Failed to execute system cache clear");
+
+		log::trace!(target: "bench-logistics", "Clearing system cache done!");
+	}
+
+	#[cfg(target_os = "macos")]
+	{
+		log::trace!(target: "bench-logistics", "Clearing system cache...");
+		if let Err(err) = std::process::Command::new("purge").output() {
+			log::error!("purge error {:?}: ", err);
+			panic!("Could not clear system cache. Run under sudo?");
+		}
+		log::trace!(target: "bench-logistics", "Clearing system cache done!");
+	}
+}
+
+/// Pre-initialized benchmarking database.
+///
+/// This is prepared database with genesis and keyring
+/// that can be cloned and then used for any benchmarking.
+pub struct BenchDb {
+	keyring: BenchKeyring,
+	directory_guard: Guard,
+	database_type: DatabaseType,
+}
+
+impl Clone for BenchDb {
+	fn clone(&self) -> Self {
+		let keyring = self.keyring.clone();
+		let database_type = self.database_type;
+		let dir = tempfile::tempdir().expect("temp dir creation failed");
+
+		let seed_dir = self.directory_guard.0.path();
+
+		log::trace!(
+			target: "bench-logistics",
+			"Copying seed db from {} to {}",
+			seed_dir.to_string_lossy(),
+			dir.path().to_string_lossy(),
+		);
+		let seed_db_files = std::fs::read_dir(seed_dir)
+			.expect("failed to list file in seed dir")
+			.map(|f_result| f_result.expect("failed to read file in seed db").path())
+			.collect::<Vec<PathBuf>>();
+		fs_extra::copy_items(&seed_db_files, dir.path(), &fs_extra::dir::CopyOptions::new())
+			.expect("Copy of seed database is ok");
+
+		// We clear system cache after db clone but before any warmups.
+		// This populates system cache with some data unrelated to actual
+		// data we will be quering further under benchmark (like what
+		// would have happened in real system that queries random entries
+		// from database).
+		drop_system_cache();
+
+		BenchDb { keyring, directory_guard: Guard(dir), database_type }
+	}
+}
+
+/// Type of block for generation
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum BlockType {
+	/// Bunch of random transfers.
+	RandomTransfersKeepAlive,
+	/// Bunch of random transfers that drain all of the source balance.
+	RandomTransfersReaping,
+	/// Bunch of "no-op" calls.
+	Noop,
+}
+
+impl BlockType {
+	/// Create block content description with specified number of transactions.
+	pub fn to_content(self, size: Option<usize>) -> BlockContent {
+		BlockContent { block_type: self, size }
+	}
+}
+
+/// Content of the generated block.
+#[derive(Clone, Debug)]
+pub struct BlockContent {
+	block_type: BlockType,
+	size: Option<usize>,
+}
+
+/// Type of backend database.
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum DatabaseType {
+	/// RocksDb backend.
+	RocksDb,
+	/// Parity DB backend.
+	ParityDb,
+}
+
+impl DatabaseType {
+	fn into_settings(self, path: PathBuf) -> sc_client_db::DatabaseSource {
+		match self {
+			Self::RocksDb => sc_client_db::DatabaseSource::RocksDb { path, cache_size: 512 },
+			Self::ParityDb => sc_client_db::DatabaseSource::ParityDb { path },
+		}
+	}
+}
+
+/// Benchmarking task executor.
+///
+/// Uses multiple threads as the regular executable.
+#[derive(Debug, Clone)]
+pub struct TaskExecutor {
+	pool: executor::ThreadPool,
+}
+
+impl TaskExecutor {
+	fn new() -> Self {
+		Self { pool: executor::ThreadPool::new().expect("Failed to create task executor") }
+	}
+}
+
+impl SpawnNamed for TaskExecutor {
+	fn spawn(
+		&self,
+		_: &'static str,
+		_: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		self.pool.spawn_ok(future);
+	}
+
+	fn spawn_blocking(
+		&self,
+		_: &'static str,
+		_: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		self.pool.spawn_ok(future);
+	}
+}
+
+/// Iterator for block content.
+pub struct BlockContentIterator<'a> {
+	iteration: usize,
+	content: BlockContent,
+	runtime_version: sc_executor::RuntimeVersion,
+	genesis_hash: node_primitives::Hash,
+	keyring: &'a BenchKeyring,
+}
+
+impl<'a> BlockContentIterator<'a> {
+	fn new(content: BlockContent, keyring: &'a BenchKeyring, client: &Client) -> Self {
+		let genesis_hash = client.chain_info().genesis_hash;
+		let runtime_version = client
+			.runtime_version_at(genesis_hash)
+			.expect("There should be runtime version at 0");
+
+		BlockContentIterator { iteration: 0, content, keyring, runtime_version, genesis_hash }
+	}
+}
+
+impl<'a> Iterator for BlockContentIterator<'a> {
+	type Item = OpaqueExtrinsic;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.content.size.map(|size| size <= self.iteration).unwrap_or(false) {
+			return None
+		}
+
+		let sender = self.keyring.at(self.iteration);
+		let receiver = get_account_id_from_seed::<sr25519::Public>(&format!(
+			"random-user//{}",
+			self.iteration
+		));
+
+		let signed = self.keyring.sign(
+			CheckedExtrinsic {
+				signed: Some((
+					sender,
+					signed_extra(0, kitchensink_runtime::ExistentialDeposit::get() + 1),
+				)),
+				function: match self.content.block_type {
+					BlockType::RandomTransfersKeepAlive =>
+						RuntimeCall::Balances(BalancesCall::transfer_keep_alive {
+							dest: sp_runtime::MultiAddress::Id(receiver),
+							value: kitchensink_runtime::ExistentialDeposit::get() + 1,
+						}),
+					BlockType::RandomTransfersReaping => {
+						RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+							dest: sp_runtime::MultiAddress::Id(receiver),
+							// Transfer so that ending balance would be 1 less than existential
+							// deposit so that we kill the sender account.
+							value: 100 * DOLLARS -
+								(kitchensink_runtime::ExistentialDeposit::get() - 1),
+						})
+					},
+					BlockType::Noop =>
+						RuntimeCall::System(SystemCall::remark { remark: Vec::new() }),
+				},
+			},
+			self.runtime_version.spec_version,
+			self.runtime_version.transaction_version,
+			self.genesis_hash.into(),
+		);
+
+		let encoded = Encode::encode(&signed);
+
+		let opaque = OpaqueExtrinsic::decode(&mut &encoded[..]).expect("Failed  to decode opaque");
+
+		self.iteration += 1;
+
+		Some(opaque)
+	}
+}
+
+impl BenchDb {
+	/// New immutable benchmarking database.
+	///
+	/// See [`BenchDb::new`] method documentation for more information about the purpose
+	/// of this structure.
+	pub fn with_key_types(
+		database_type: DatabaseType,
+		keyring_length: usize,
+		key_types: KeyTypes,
+	) -> Self {
+		let keyring = BenchKeyring::new(keyring_length, key_types);
+
+		let dir = tempfile::tempdir().expect("temp dir creation failed");
+		log::trace!(
+			target: "bench-logistics",
+			"Created seed db at {}",
+			dir.path().to_string_lossy(),
+		);
+		let (_client, _backend, _task_executor) =
+			Self::bench_client(database_type, dir.path(), &keyring);
+		let directory_guard = Guard(dir);
+
+		BenchDb { keyring, directory_guard, database_type }
+	}
+
+	/// New immutable benchmarking database.
+	///
+	/// This will generate database files in random temporary directory
+	/// and keep it there until struct is dropped.
+	///
+	/// You can `clone` this database or you can `create_context` from it
+	/// (which also does `clone`) to run actual operation against new database
+	/// which will be identical to the original.
+	pub fn new(database_type: DatabaseType, keyring_length: usize) -> Self {
+		Self::with_key_types(database_type, keyring_length, KeyTypes::Sr25519)
+	}
+
+	// This should return client that is doing everything that full node
+	// is doing.
+	//
+	// - This client should use best wasm execution method.
+	// - This client should work with real database only.
+	fn bench_client(
+		database_type: DatabaseType,
+		dir: &std::path::Path,
+		keyring: &BenchKeyring,
+	) -> (Client, std::sync::Arc<Backend>, TaskExecutor) {
+		let db_config = sc_client_db::DatabaseSettings {
+			trie_cache_maximum_size: Some(16 * 1024 * 1024),
+			state_pruning: Some(PruningMode::ArchiveAll),
+			source: database_type.into_settings(dir.into()),
+			blocks_pruning: sc_client_db::BlocksPruning::KeepAll,
+		};
+		let task_executor = TaskExecutor::new();
+
+		let backend = sc_service::new_db_backend(db_config).expect("Should not fail");
+		let executor = NativeElseWasmExecutor::new_with_wasm_executor(
+			sc_executor::WasmExecutor::builder()
+				.with_execution_method(WasmExecutionMethod::Compiled {
+					instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
+				})
+				.build(),
+		);
+
+		let client_config = sc_service::ClientConfig::default();
+		let genesis_block_builder = sc_service::GenesisBlockBuilder::new(
+			&keyring.generate_genesis(),
+			!client_config.no_genesis,
+			backend.clone(),
+			executor.clone(),
+		)
+		.expect("Failed to create genesis block builder");
+
+		let client = sc_service::new_client(
+			backend.clone(),
+			executor.clone(),
+			genesis_block_builder,
+			None,
+			None,
+			ExecutionExtensions::new(None, Arc::new(executor)),
+			Box::new(task_executor.clone()),
+			None,
+			None,
+			client_config,
+		)
+		.expect("Should not fail");
+
+		(client, backend, task_executor)
+	}
+
+	/// Generate list of required inherents.
+	///
+	/// Uses already instantiated Client.
+	pub fn generate_inherents(&mut self, client: &Client) -> Vec<OpaqueExtrinsic> {
+		let mut inherent_data = InherentData::new();
+		let timestamp = 1 * MinimumPeriod::get();
+
+		inherent_data
+			.put_data(sp_timestamp::INHERENT_IDENTIFIER, &timestamp)
+			.expect("Put timestamp failed");
+
+		client
+			.runtime_api()
+			.inherent_extrinsics(client.chain_info().genesis_hash, inherent_data)
+			.expect("Get inherents failed")
+	}
+
+	/// Iterate over some block content with transaction signed using this database keyring.
+	pub fn block_content(&self, content: BlockContent, client: &Client) -> BlockContentIterator {
+		BlockContentIterator::new(content, &self.keyring, client)
+	}
+
+	/// Get cliet for this database operations.
+	pub fn client(&mut self) -> Client {
+		let (client, _backend, _task_executor) =
+			Self::bench_client(self.database_type, self.directory_guard.path(), &self.keyring);
+
+		client
+	}
+
+	/// Generate new block using this database.
+	pub fn generate_block(&mut self, content: BlockContent) -> Block {
+		let client = self.client();
+
+		let mut block = client.new_block(Default::default()).expect("Block creation failed");
+
+		for extrinsic in self.generate_inherents(&client) {
+			block.push(extrinsic).expect("Push inherent failed");
+		}
+
+		let start = std::time::Instant::now();
+		for opaque in self.block_content(content, &client) {
+			match block.push(opaque) {
+				Err(sp_blockchain::Error::ApplyExtrinsicFailed(
+					sp_blockchain::ApplyExtrinsicFailed::Validity(e),
+				)) if e.exhausted_resources() => break,
+				Err(err) => panic!("Error pushing transaction: {:?}", err),
+				Ok(_) => {},
+			}
+		}
+
+		let block = block.build().expect("Block build failed").block;
+
+		log::info!(
+			target: "bench-logistics",
+			"Block construction: {:#?} ({} tx)",
+			start.elapsed(), block.extrinsics.len()
+		);
+
+		block
+	}
+
+	/// Database path.
+	pub fn path(&self) -> &Path {
+		self.directory_guard.path()
+	}
+
+	/// Clone this database and create context for testing/benchmarking.
+	pub fn create_context(&self) -> BenchContext {
+		let BenchDb { directory_guard, keyring, database_type } = self.clone();
+		let (client, backend, task_executor) =
+			Self::bench_client(database_type, directory_guard.path(), &keyring);
+
+		BenchContext {
+			client: Arc::new(client),
+			db_guard: directory_guard,
+			backend,
+			spawn_handle: Box::new(task_executor),
+		}
+	}
+}
+
+/// Key types to be used in benching keyring
+pub enum KeyTypes {
+	/// sr25519 signing keys
+	Sr25519,
+	/// ed25519 signing keys
+	Ed25519,
+}
+
+impl BenchKeyring {
+	/// New keyring.
+	///
+	/// `length` is the number of accounts generated.
+	pub fn new(length: usize, key_types: KeyTypes) -> Self {
+		let mut accounts = BTreeMap::new();
+
+		for n in 0..length {
+			let seed = format!("//endowed-user/{}", n);
+			let (account_id, pair) = match key_types {
+				KeyTypes::Sr25519 => {
+					let pair =
+						sr25519::Pair::from_string(&seed, None).expect("failed to generate pair");
+					let account_id = AccountPublic::from(pair.public()).into_account();
+					(account_id, BenchPair::Sr25519(pair))
+				},
+				KeyTypes::Ed25519 => {
+					let pair = ed25519::Pair::from_seed(&blake2_256(seed.as_bytes()));
+					let account_id = AccountPublic::from(pair.public()).into_account();
+					(account_id, BenchPair::Ed25519(pair))
+				},
+			};
+			accounts.insert(account_id, pair);
+		}
+
+		Self { accounts }
+	}
+
+	/// Generated account id-s from keyring keypairs.
+	pub fn collect_account_ids(&self) -> Vec<AccountId> {
+		self.accounts.keys().cloned().collect()
+	}
+
+	/// Get account id at position `index`
+	pub fn at(&self, index: usize) -> AccountId {
+		self.accounts.keys().nth(index).expect("Failed to get account").clone()
+	}
+
+	/// Sign transaction with keypair from this keyring.
+	pub fn sign(
+		&self,
+		xt: CheckedExtrinsic,
+		spec_version: u32,
+		tx_version: u32,
+		genesis_hash: [u8; 32],
+	) -> UncheckedExtrinsic {
+		match xt.signed {
+			Some((signed, extra)) => {
+				let payload = (
+					xt.function,
+					extra.clone(),
+					spec_version,
+					tx_version,
+					genesis_hash,
+					genesis_hash,
+				);
+				let key = self.accounts.get(&signed).expect("Account id not found in keyring");
+				let signature = payload.using_encoded(|b| {
+					if b.len() > 256 {
+						key.sign(&sp_io::hashing::blake2_256(b))
+					} else {
+						key.sign(b)
+					}
+				});
+				UncheckedExtrinsic {
+					signature: Some((sp_runtime::MultiAddress::Id(signed), signature, extra)),
+					function: payload.0,
+				}
+			},
+			None => UncheckedExtrinsic { signature: None, function: xt.function },
+		}
+	}
+
+	/// Generate genesis with accounts from this keyring endowed with some balance.
+	pub fn generate_genesis(&self) -> kitchensink_runtime::RuntimeGenesisConfig {
+		crate::genesis::config_endowed(
+			Some(kitchensink_runtime::wasm_binary_unwrap()),
+			self.collect_account_ids(),
+		)
+	}
+}
+
+struct Guard(tempfile::TempDir);
+
+impl Guard {
+	fn path(&self) -> &Path {
+		self.0.path()
+	}
+}
+
+/// Benchmarking/test context holding instantiated client and backend references.
+pub struct BenchContext {
+	/// Node client.
+	pub client: Arc<Client>,
+	/// Node backend.
+	pub backend: Arc<Backend>,
+	/// Spawn handle.
+	pub spawn_handle: Box<dyn SpawnNamed>,
+
+	db_guard: Guard,
+}
+
+type AccountPublic = <Signature as Verify>::Signer;
+
+fn get_from_seed<TPublic: Public>(seed: &str) -> <TPublic::Pair as Pair>::Public {
+	TPublic::Pair::from_string(&format!("//{}", seed), None)
+		.expect("static values are valid; qed")
+		.public()
+}
+
+fn get_account_id_from_seed<TPublic: Public>(seed: &str) -> AccountId
+where
+	AccountPublic: From<<TPublic::Pair as Pair>::Public>,
+{
+	AccountPublic::from(get_from_seed::<TPublic>(seed)).into_account()
+}
+
+impl BenchContext {
+	/// Import some block.
+	pub fn import_block(&mut self, block: Block) {
+		let mut import_params =
+			BlockImportParams::new(BlockOrigin::NetworkBroadcast, block.header.clone());
+		import_params.body = Some(block.extrinsics().to_vec());
+		import_params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		assert_eq!(self.client.chain_info().best_number, 0);
+
+		assert_eq!(
+			futures::executor::block_on(self.client.import_block(import_params))
+				.expect("Failed to import block"),
+			ImportResult::Imported(ImportedAux {
+				header_only: false,
+				clear_justification_requests: false,
+				needs_justification: false,
+				bad_justification: false,
+				is_new_best: true,
+			})
+		);
+
+		assert_eq!(self.client.chain_info().best_number, 1);
+	}
+
+	/// Database path for the current context.
+	pub fn path(&self) -> &Path {
+		self.db_guard.path()
+	}
+}
diff --git a/substrate/bin/node/testing/src/client.rs b/substrate/bin/node/testing/src/client.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c55867360bd62c7e225f6fcddfb333f259bdb19f
--- /dev/null
+++ b/substrate/bin/node/testing/src/client.rs
@@ -0,0 +1,73 @@
+// 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/>.
+
+//! Utilities to build a `TestClient` for `kitchensink-runtime`.
+
+use sp_runtime::BuildStorage;
+/// Re-export test-client utilities.
+pub use substrate_test_client::*;
+
+/// Call executor for `kitchensink-runtime` `TestClient`.
+pub type ExecutorDispatch = sc_executor::NativeElseWasmExecutor<node_executor::ExecutorDispatch>;
+
+/// Default backend type.
+pub type Backend = sc_client_db::Backend<node_primitives::Block>;
+
+/// Test client type.
+pub type Client = client::Client<
+	Backend,
+	client::LocalCallExecutor<node_primitives::Block, Backend, ExecutorDispatch>,
+	node_primitives::Block,
+	kitchensink_runtime::RuntimeApi,
+>;
+
+/// Genesis configuration parameters for `TestClient`.
+#[derive(Default)]
+pub struct GenesisParameters;
+
+impl substrate_test_client::GenesisInit for GenesisParameters {
+	fn genesis_storage(&self) -> Storage {
+		crate::genesis::config(None).build_storage().unwrap()
+	}
+}
+
+/// A `test-runtime` extensions to `TestClientBuilder`.
+pub trait TestClientBuilderExt: Sized {
+	/// Create test client builder.
+	fn new() -> Self;
+
+	/// Build the test client.
+	fn build(self) -> Client;
+}
+
+impl TestClientBuilderExt
+	for substrate_test_client::TestClientBuilder<
+		node_primitives::Block,
+		client::LocalCallExecutor<node_primitives::Block, Backend, ExecutorDispatch>,
+		Backend,
+		GenesisParameters,
+	>
+{
+	fn new() -> Self {
+		Self::default()
+	}
+
+	fn build(self) -> Client {
+		self.build_with_native_executor(None).0
+	}
+}
diff --git a/substrate/bin/node/testing/src/genesis.rs b/substrate/bin/node/testing/src/genesis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6e7bcebfc00d180d855479dcb6154ef83dd3d44a
--- /dev/null
+++ b/substrate/bin/node/testing/src/genesis.rs
@@ -0,0 +1,113 @@
+// 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/>.
+
+//! Genesis Configuration.
+
+use crate::keyring::*;
+use kitchensink_runtime::{
+	constants::currency::*, wasm_binary_unwrap, AccountId, AssetsConfig, BabeConfig,
+	BalancesConfig, GluttonConfig, GrandpaConfig, IndicesConfig, RuntimeGenesisConfig,
+	SessionConfig, SocietyConfig, StakerStatus, StakingConfig, SystemConfig,
+	BABE_GENESIS_EPOCH_CONFIG,
+};
+use sp_keyring::{Ed25519Keyring, Sr25519Keyring};
+use sp_runtime::Perbill;
+
+/// Create genesis runtime configuration for tests.
+pub fn config(code: Option<&[u8]>) -> RuntimeGenesisConfig {
+	config_endowed(code, Default::default())
+}
+
+/// Create genesis runtime configuration for tests with some extra
+/// endowed accounts.
+pub fn config_endowed(code: Option<&[u8]>, extra_endowed: Vec<AccountId>) -> RuntimeGenesisConfig {
+	let mut endowed = vec![
+		(alice(), 111 * DOLLARS),
+		(bob(), 100 * DOLLARS),
+		(charlie(), 100_000_000 * DOLLARS),
+		(dave(), 111 * DOLLARS),
+		(eve(), 101 * DOLLARS),
+		(ferdie(), 100 * DOLLARS),
+	];
+
+	endowed.extend(extra_endowed.into_iter().map(|endowed| (endowed, 100 * DOLLARS)));
+
+	RuntimeGenesisConfig {
+		system: SystemConfig {
+			code: code.map(|x| x.to_vec()).unwrap_or_else(|| wasm_binary_unwrap().to_vec()),
+			..Default::default()
+		},
+		indices: IndicesConfig { indices: vec![] },
+		balances: BalancesConfig { balances: endowed },
+		session: SessionConfig {
+			keys: vec![
+				(alice(), dave(), to_session_keys(&Ed25519Keyring::Alice, &Sr25519Keyring::Alice)),
+				(bob(), eve(), to_session_keys(&Ed25519Keyring::Bob, &Sr25519Keyring::Bob)),
+				(
+					charlie(),
+					ferdie(),
+					to_session_keys(&Ed25519Keyring::Charlie, &Sr25519Keyring::Charlie),
+				),
+			],
+		},
+		staking: StakingConfig {
+			stakers: vec![
+				(dave(), dave(), 111 * DOLLARS, StakerStatus::Validator),
+				(eve(), eve(), 100 * DOLLARS, StakerStatus::Validator),
+				(ferdie(), ferdie(), 100 * DOLLARS, StakerStatus::Validator),
+			],
+			validator_count: 3,
+			minimum_validator_count: 0,
+			slash_reward_fraction: Perbill::from_percent(10),
+			invulnerables: vec![alice(), bob(), charlie()],
+			..Default::default()
+		},
+		babe: BabeConfig {
+			authorities: vec![],
+			epoch_config: Some(BABE_GENESIS_EPOCH_CONFIG),
+			..Default::default()
+		},
+		grandpa: GrandpaConfig { authorities: vec![], _config: Default::default() },
+		im_online: Default::default(),
+		authority_discovery: Default::default(),
+		democracy: Default::default(),
+		council: Default::default(),
+		technical_committee: Default::default(),
+		technical_membership: Default::default(),
+		elections: Default::default(),
+		sudo: Default::default(),
+		treasury: Default::default(),
+		society: SocietyConfig { pot: 0 },
+		vesting: Default::default(),
+		assets: AssetsConfig { assets: vec![(9, alice(), true, 1)], ..Default::default() },
+		pool_assets: Default::default(),
+		transaction_storage: Default::default(),
+		transaction_payment: Default::default(),
+		alliance: Default::default(),
+		alliance_motion: Default::default(),
+		nomination_pools: Default::default(),
+		safe_mode: Default::default(),
+		tx_pause: Default::default(),
+		glutton: GluttonConfig {
+			compute: Default::default(),
+			storage: Default::default(),
+			trash_data_count: Default::default(),
+			..Default::default()
+		},
+	}
+}
diff --git a/substrate/bin/node/testing/src/keyring.rs b/substrate/bin/node/testing/src/keyring.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b4b714d9083d60ef5c13688f2c00179216f5a33d
--- /dev/null
+++ b/substrate/bin/node/testing/src/keyring.rs
@@ -0,0 +1,112 @@
+// 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/>.
+
+//! Test accounts.
+
+use codec::Encode;
+use kitchensink_runtime::{CheckedExtrinsic, SessionKeys, SignedExtra, UncheckedExtrinsic};
+use node_primitives::{AccountId, Balance, Nonce};
+use sp_keyring::{AccountKeyring, Ed25519Keyring, Sr25519Keyring};
+use sp_runtime::generic::Era;
+
+/// Alice's account id.
+pub fn alice() -> AccountId {
+	AccountKeyring::Alice.into()
+}
+
+/// Bob's account id.
+pub fn bob() -> AccountId {
+	AccountKeyring::Bob.into()
+}
+
+/// Charlie's account id.
+pub fn charlie() -> AccountId {
+	AccountKeyring::Charlie.into()
+}
+
+/// Dave's account id.
+pub fn dave() -> AccountId {
+	AccountKeyring::Dave.into()
+}
+
+/// Eve's account id.
+pub fn eve() -> AccountId {
+	AccountKeyring::Eve.into()
+}
+
+/// Ferdie's account id.
+pub fn ferdie() -> AccountId {
+	AccountKeyring::Ferdie.into()
+}
+
+/// Convert keyrings into `SessionKeys`.
+pub fn to_session_keys(
+	ed25519_keyring: &Ed25519Keyring,
+	sr25519_keyring: &Sr25519Keyring,
+) -> SessionKeys {
+	SessionKeys {
+		grandpa: ed25519_keyring.to_owned().public().into(),
+		babe: sr25519_keyring.to_owned().public().into(),
+		im_online: sr25519_keyring.to_owned().public().into(),
+		authority_discovery: sr25519_keyring.to_owned().public().into(),
+	}
+}
+
+/// Returns transaction extra.
+pub fn signed_extra(nonce: Nonce, extra_fee: Balance) -> SignedExtra {
+	(
+		frame_system::CheckNonZeroSender::new(),
+		frame_system::CheckSpecVersion::new(),
+		frame_system::CheckTxVersion::new(),
+		frame_system::CheckGenesis::new(),
+		frame_system::CheckEra::from(Era::mortal(256, 0)),
+		frame_system::CheckNonce::from(nonce),
+		frame_system::CheckWeight::new(),
+		pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::from(extra_fee, None),
+	)
+}
+
+/// Sign given `CheckedExtrinsic`.
+pub fn sign(
+	xt: CheckedExtrinsic,
+	spec_version: u32,
+	tx_version: u32,
+	genesis_hash: [u8; 32],
+) -> UncheckedExtrinsic {
+	match xt.signed {
+		Some((signed, extra)) => {
+			let payload =
+				(xt.function, extra.clone(), spec_version, tx_version, genesis_hash, genesis_hash);
+			let key = AccountKeyring::from_account_id(&signed).unwrap();
+			let signature = payload
+				.using_encoded(|b| {
+					if b.len() > 256 {
+						key.sign(&sp_io::hashing::blake2_256(b))
+					} else {
+						key.sign(b)
+					}
+				})
+				.into();
+			UncheckedExtrinsic {
+				signature: Some((sp_runtime::MultiAddress::Id(signed), signature, extra)),
+				function: payload.0,
+			}
+		},
+		None => UncheckedExtrinsic { signature: None, function: xt.function },
+	}
+}
diff --git a/substrate/bin/node/testing/src/lib.rs b/substrate/bin/node/testing/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..14e540906fc9140136bd47c4e8848d30c23498bb
--- /dev/null
+++ b/substrate/bin/node/testing/src/lib.rs
@@ -0,0 +1,26 @@
+// 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/>.
+
+//! A set of testing utilities for Substrate Node.
+
+#![warn(missing_docs)]
+
+pub mod bench;
+pub mod client;
+pub mod genesis;
+pub mod keyring;
diff --git a/substrate/bin/utils/chain-spec-builder/Cargo.toml b/substrate/bin/utils/chain-spec-builder/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c592f8ac226c3351c9286a5f45f39f3fcb84b5e7
--- /dev/null
+++ b/substrate/bin/utils/chain-spec-builder/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "chain-spec-builder"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+build = "build.rs"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[[bin]]
+path = "bin/main.rs"
+name = "chain-spec-builder"
+
+[lib]
+crate-type = ["rlib"]
+
+[dependencies]
+ansi_term = "0.12.1"
+clap = { version = "4.2.5", features = ["derive"] }
+rand = "0.8"
+node-cli = { version = "3.0.0-dev", path = "../../node/cli" }
+sc-chain-spec = { version = "4.0.0-dev", path = "../../../client/chain-spec" }
+sc-keystore = { version = "4.0.0-dev", path = "../../../client/keystore" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
diff --git a/substrate/bin/utils/chain-spec-builder/bin/main.rs b/substrate/bin/utils/chain-spec-builder/bin/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..53e11abbf628206a78590696f6d376416b9d9ddf
--- /dev/null
+++ b/substrate/bin/utils/chain-spec-builder/bin/main.rs
@@ -0,0 +1,89 @@
+// 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 chain_spec_builder::{
+	generate_authority_keys_and_store, generate_chain_spec, print_seeds, ChainSpecBuilder,
+};
+use clap::Parser;
+use node_cli::chain_spec;
+use rand::{distributions::Alphanumeric, rngs::OsRng, Rng};
+use sp_core::{crypto::Ss58Codec, sr25519};
+use std::fs;
+
+fn main() -> Result<(), String> {
+	#[cfg(build_type = "debug")]
+	println!(
+		"The chain spec builder builds a chain specification that includes a Substrate runtime \
+		 compiled as WASM. To ensure proper functioning of the included runtime compile (or run) \
+		 the chain spec builder binary in `--release` mode.\n",
+	);
+
+	let builder = ChainSpecBuilder::parse();
+	let chain_spec_path = builder.chain_spec_path().to_path_buf();
+
+	let (authority_seeds, nominator_accounts, endowed_accounts, sudo_account) = match builder {
+		ChainSpecBuilder::Generate { authorities, nominators, endowed, keystore_path, .. } => {
+			let authorities = authorities.max(1);
+			let rand_str = || -> String {
+				OsRng.sample_iter(&Alphanumeric).take(32).map(char::from).collect()
+			};
+
+			let authority_seeds = (0..authorities).map(|_| rand_str()).collect::<Vec<_>>();
+			let nominator_seeds = (0..nominators).map(|_| rand_str()).collect::<Vec<_>>();
+			let endowed_seeds = (0..endowed).map(|_| rand_str()).collect::<Vec<_>>();
+			let sudo_seed = rand_str();
+
+			print_seeds(&authority_seeds, &nominator_seeds, &endowed_seeds, &sudo_seed);
+
+			if let Some(keystore_path) = keystore_path {
+				generate_authority_keys_and_store(&authority_seeds, &keystore_path)?;
+			}
+
+			let nominator_accounts = nominator_seeds
+				.into_iter()
+				.map(|seed| {
+					chain_spec::get_account_id_from_seed::<sr25519::Public>(&seed).to_ss58check()
+				})
+				.collect();
+
+			let endowed_accounts = endowed_seeds
+				.into_iter()
+				.map(|seed| {
+					chain_spec::get_account_id_from_seed::<sr25519::Public>(&seed).to_ss58check()
+				})
+				.collect();
+
+			let sudo_account =
+				chain_spec::get_account_id_from_seed::<sr25519::Public>(&sudo_seed).to_ss58check();
+
+			(authority_seeds, nominator_accounts, endowed_accounts, sudo_account)
+		},
+		ChainSpecBuilder::New {
+			authority_seeds,
+			nominator_accounts,
+			endowed_accounts,
+			sudo_account,
+			..
+		} => (authority_seeds, nominator_accounts, endowed_accounts, sudo_account),
+	};
+
+	let json =
+		generate_chain_spec(authority_seeds, nominator_accounts, endowed_accounts, sudo_account)?;
+
+	fs::write(chain_spec_path, json).map_err(|err| err.to_string())
+}
diff --git a/substrate/bin/utils/chain-spec-builder/build.rs b/substrate/bin/utils/chain-spec-builder/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a68cb706e8fbdc2526aa18730f0e7ddb9719f838
--- /dev/null
+++ b/substrate/bin/utils/chain-spec-builder/build.rs
@@ -0,0 +1,25 @@
+// 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 std::env;
+
+fn main() {
+	if let Ok(profile) = env::var("PROFILE") {
+		println!("cargo:rustc-cfg=build_type=\"{}\"", profile);
+	}
+}
diff --git a/substrate/bin/utils/chain-spec-builder/src/lib.rs b/substrate/bin/utils/chain-spec-builder/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..528b6b70115a07c3225d52c0bf30a727bf1eebd7
--- /dev/null
+++ b/substrate/bin/utils/chain-spec-builder/src/lib.rs
@@ -0,0 +1,241 @@
+// 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/>.
+
+//! Substrate's chain spec builder utility.
+//!
+//! A chain-spec is short for `chain-configuration`. See the [`sc-chain-spec`] for more information.
+//!
+//! Note that this binary is analogous to the `build-spec` subcommand, contained in typical
+//! substrate-based nodes. This particular binary is capable of building a more sophisticated chain
+//! specification that can be used with the substrate-node, ie. [`node-cli`].
+//!
+//! See [`ChainSpecBuilder`] for a list of available commands.
+//!
+//! [`sc-chain-spec`]: ../sc_chain_spec/index.html
+//! [`node-cli`]: ../node_cli/index.html
+
+use std::path::{Path, PathBuf};
+
+use ansi_term::Style;
+use clap::Parser;
+
+use node_cli::chain_spec::{self, AccountId};
+use sc_keystore::LocalKeystore;
+use sp_core::crypto::{ByteArray, Ss58Codec};
+use sp_keystore::KeystorePtr;
+
+/// A utility to easily create a testnet chain spec definition with a given set
+/// of authorities and endowed accounts and/or generate random accounts.
+#[derive(Parser)]
+#[command(rename_all = "kebab-case")]
+pub enum ChainSpecBuilder {
+	/// Create a new chain spec with the given authorities, endowed and sudo
+	/// accounts.
+	New {
+		/// Authority key seed.
+		#[arg(long, short, required = true)]
+		authority_seeds: Vec<String>,
+		/// Active nominators (SS58 format), each backing a random subset of the aforementioned
+		/// authorities.
+		#[arg(long, short, default_value = "0")]
+		nominator_accounts: Vec<String>,
+		/// Endowed account address (SS58 format).
+		#[arg(long, short)]
+		endowed_accounts: Vec<String>,
+		/// Sudo account address (SS58 format).
+		#[arg(long, short)]
+		sudo_account: String,
+		/// The path where the chain spec should be saved.
+		#[arg(long, short, default_value = "./chain_spec.json")]
+		chain_spec_path: PathBuf,
+	},
+	/// Create a new chain spec with the given number of authorities and endowed
+	/// accounts. Random keys will be generated as required.
+	Generate {
+		/// The number of authorities.
+		#[arg(long, short)]
+		authorities: usize,
+		/// The number of nominators backing the aforementioned authorities.
+		///
+		/// Will nominate a random subset of `authorities`.
+		#[arg(long, short, default_value_t = 0)]
+		nominators: usize,
+		/// The number of endowed accounts.
+		#[arg(long, short, default_value_t = 0)]
+		endowed: usize,
+		/// The path where the chain spec should be saved.
+		#[arg(long, short, default_value = "./chain_spec.json")]
+		chain_spec_path: PathBuf,
+		/// Path to use when saving generated keystores for each authority.
+		///
+		/// At this path, a new folder will be created for each authority's
+		/// keystore named `auth-$i` where `i` is the authority index, i.e.
+		/// `auth-0`, `auth-1`, etc.
+		#[arg(long, short)]
+		keystore_path: Option<PathBuf>,
+	},
+}
+
+impl ChainSpecBuilder {
+	/// Returns the path where the chain spec should be saved.
+	pub fn chain_spec_path(&self) -> &Path {
+		match self {
+			ChainSpecBuilder::New { chain_spec_path, .. } => chain_spec_path.as_path(),
+			ChainSpecBuilder::Generate { chain_spec_path, .. } => chain_spec_path.as_path(),
+		}
+	}
+}
+
+fn genesis_constructor(
+	authority_seeds: &[String],
+	nominator_accounts: &[AccountId],
+	endowed_accounts: &[AccountId],
+	sudo_account: &AccountId,
+) -> chain_spec::RuntimeGenesisConfig {
+	let authorities = authority_seeds
+		.iter()
+		.map(AsRef::as_ref)
+		.map(chain_spec::authority_keys_from_seed)
+		.collect::<Vec<_>>();
+
+	chain_spec::testnet_genesis(
+		authorities,
+		nominator_accounts.to_vec(),
+		sudo_account.clone(),
+		Some(endowed_accounts.to_vec()),
+	)
+}
+
+/// Generate the chain spec using the given seeds and accounts.
+pub fn generate_chain_spec(
+	authority_seeds: Vec<String>,
+	nominator_accounts: Vec<String>,
+	endowed_accounts: Vec<String>,
+	sudo_account: String,
+) -> Result<String, String> {
+	let parse_account = |address: String| {
+		AccountId::from_string(&address)
+			.map_err(|err| format!("Failed to parse account address: {:?}", err))
+	};
+
+	let nominator_accounts = nominator_accounts
+		.into_iter()
+		.map(parse_account)
+		.collect::<Result<Vec<_>, String>>()?;
+
+	let endowed_accounts = endowed_accounts
+		.into_iter()
+		.map(parse_account)
+		.collect::<Result<Vec<_>, String>>()?;
+
+	let sudo_account = parse_account(sudo_account)?;
+
+	let chain_spec = chain_spec::ChainSpec::from_genesis(
+		"Custom",
+		"custom",
+		sc_chain_spec::ChainType::Live,
+		move || {
+			genesis_constructor(
+				&authority_seeds,
+				&nominator_accounts,
+				&endowed_accounts,
+				&sudo_account,
+			)
+		},
+		vec![],
+		None,
+		None,
+		None,
+		None,
+		Default::default(),
+	);
+
+	chain_spec.as_json(false)
+}
+
+/// Generate the authority keys and store them in the given `keystore_path`.
+pub fn generate_authority_keys_and_store(
+	seeds: &[String],
+	keystore_path: &Path,
+) -> Result<(), String> {
+	for (n, seed) in seeds.iter().enumerate() {
+		let keystore: KeystorePtr =
+			LocalKeystore::open(keystore_path.join(format!("auth-{}", n)), None)
+				.map_err(|err| err.to_string())?
+				.into();
+
+		let (_, _, grandpa, babe, im_online, authority_discovery) =
+			chain_spec::authority_keys_from_seed(seed);
+
+		let insert_key = |key_type, public| {
+			keystore
+				.insert(key_type, &format!("//{}", seed), public)
+				.map_err(|_| format!("Failed to insert key: {}", grandpa))
+		};
+
+		insert_key(sp_core::crypto::key_types::BABE, babe.as_slice())?;
+
+		insert_key(sp_core::crypto::key_types::GRANDPA, grandpa.as_slice())?;
+
+		insert_key(sp_core::crypto::key_types::IM_ONLINE, im_online.as_slice())?;
+
+		insert_key(
+			sp_core::crypto::key_types::AUTHORITY_DISCOVERY,
+			authority_discovery.as_slice(),
+		)?;
+	}
+
+	Ok(())
+}
+
+/// Print the given seeds
+pub fn print_seeds(
+	authority_seeds: &[String],
+	nominator_seeds: &[String],
+	endowed_seeds: &[String],
+	sudo_seed: &str,
+) {
+	let header = Style::new().bold().underline();
+	let entry = Style::new().bold();
+
+	println!("{}", header.paint("Authority seeds"));
+
+	for (n, seed) in authority_seeds.iter().enumerate() {
+		println!("{} //{}", entry.paint(format!("auth-{}:", n)), seed);
+	}
+
+	println!("{}", header.paint("Nominator seeds"));
+
+	for (n, seed) in nominator_seeds.iter().enumerate() {
+		println!("{} //{}", entry.paint(format!("nom-{}:", n)), seed);
+	}
+
+	println!();
+
+	if !endowed_seeds.is_empty() {
+		println!("{}", header.paint("Endowed seeds"));
+		for (n, seed) in endowed_seeds.iter().enumerate() {
+			println!("{} //{}", entry.paint(format!("endowed-{}:", n)), seed);
+		}
+
+		println!();
+	}
+
+	println!("{}", header.paint("Sudo seed"));
+	println!("//{}", sudo_seed);
+}
diff --git a/substrate/bin/utils/subkey/Cargo.toml b/substrate/bin/utils/subkey/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5ef0da81a09d5fcdf1fc056d15d7d9ed05e9e03b
--- /dev/null
+++ b/substrate/bin/utils/subkey/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "subkey"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Generate and restore keys for Substrate based chains such as Polkadot, Kusama and a growing number of parachains and Substrate based projects."
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[[bin]]
+path = "src/main.rs"
+name = "subkey"
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive"] }
+sc-cli = { version = "0.10.0-dev", path = "../../../client/cli" }
diff --git a/substrate/bin/utils/subkey/README.md b/substrate/bin/utils/subkey/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d19ccefb59aae8efc581d848ce466bce23bf1825
--- /dev/null
+++ b/substrate/bin/utils/subkey/README.md
@@ -0,0 +1,263 @@
+# Subkey
+
+Subkey is a commandline utility included with Substrate. It allows generating and restoring keys for Substrate based chains such as Polkadot, Kusama and a growing number of parachains and Substrate based projects.
+
+`subkey` provides a few sub-commands to generate keys, check keys, sign messages, verify messages, etc...
+
+You can see the full list of commands with `subkey --help`. Most commands have additional help available with for instance `subkey generate --help` for the `generate` command.
+
+## Safety first
+
+`subkey` does not need an internet connection to work. Indeed, for the best security, you should be using `subkey` on a machine that is **not connected** to the internet.
+
+`subkey` deals with **seeds** and **private keys**. Make sure to use `subkey` in a safe environment (ie. no one looking over your shoulder) and on a safe computer (ie. no one able to check your command history).
+
+If you save any output of `subkey` into a file, make sure to apply proper permissions and/or delete the file as soon as possible.
+
+## Usage
+
+The following guide explains *some* of the `subkey` commands. For the full list and the most up to date documentation, make sure to check the integrated help with `subkey --help`.
+
+### Install with Cargo
+
+You will need to have the Substrate build dependencies to install Subkey. Use the following two commands to install the dependencies and Subkey, respectively:
+
+Command:
+
+```bash
+# Install only `subkey`, at a specific version of the subkey crate
+cargo install --force subkey --git https://github.com/paritytech/substrate --version <SET VERSION> --locked
+# If you run into issues building, you likely are missing deps defined in https://docs.substrate.io/install/
+```
+
+### Run in a container
+
+```bash
+# Use `--pull=always` with the `latest` tag, or specify a version in a tag
+docker run -it --pull=always docker.io/parity/subkey:latest <command to subkey>
+```
+
+### Generate a random account
+
+Generating a new key is as simple as running:
+
+```bash
+subkey generate
+```
+
+The output looks similar to:
+
+```text
+Secret phrase `hotel forest jar hover kite book view eight stuff angle legend defense` is account:
+  Secret seed:      0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+  Public key (hex): 0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+  Account ID:       0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+  SS58 Address:     5Hpm9fq3W3dQgwWpAwDS2ZHKAdnk86QRCu7iX4GnmDxycrte
+```
+
+---
+☠� DO NT RE-USE ANY OF THE SEEDS AND SECRETS FROM THIS PAGE ☠�.
+
+You can read more about security and risks in [SECURITY.md](./SECURITY.md) and in the [Polkadot Wiki](https://wiki.polkadot.network/docs/learn-account-generation).
+
+---
+
+The output above shows a **secret phrase** (also called **mnemonic phrase**) and the **secret seed** (also called **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 independant from the network where you will use the key.
+
+The **SS58 address** (or **Public Address**) of a new account is a reprensentation of the public keys of an account for a given network (for instance Kusama or Polkadot).
+
+You can read more about the [SS58 format in the Substrate Docs](https://docs.substrate.io/reference/address-formats/) and see the list of reserved prefixes in the [SS58 Registry](https://github.com/paritytech/ss58-registry).
+
+For instance, considering the previous seed `0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d` the SS58 addresses are:
+
+- Polkadot: `16m4J167Mptt8UXL8aGSAi7U2FnPpPxZHPrCgMG9KJzVoFqM`
+- Kusama: `JLNozAv8QeLSbLFwe2UvWeKKE4yvmDbfGxTuiYkF2BUMx4M`
+
+### Json output
+
+`subkey` can calso generate the output as *json*. This is useful for automation.
+
+command:
+
+```bash
+subkey generate --output-type json
+```
+
+output:
+
+```json
+{
+  "accountId": "0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515",
+  "publicKey": "0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515",
+  "secretPhrase": "hotel forest jar hover kite book view eight stuff angle legend defense",
+  "secretSeed": "0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d",
+  "ss58Address": "5Hpm9fq3W3dQgwWpAwDS2ZHKAdnk86QRCu7iX4GnmDxycrte"
+}
+```
+
+So if you only want to get the `secretSeed` for instance, you can use:
+
+command:
+
+```bash
+subkey generate --output-type json | jq -r .secretSeed
+```
+
+output:
+
+```text
+0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+```
+
+### Additional user-defined password
+
+`subkey` supports an additional user-defined secret that will be appended to the seed. Let's see the following example:
+
+```bash
+subkey generate --password extra_secret
+```
+
+output:
+
+```text
+Secret phrase `soup lyrics media market way crouch elevator put moon useful question wide` is account:
+  Secret seed:      0xe7cfd179d6537a676cb94bac3b5c5c9cb1550e846ac4541040d077dfbac2e7fd
+  Public key (hex): 0xf6a233c3e1de1a2ae0486100b460b3ce3d7231ddfe9dadabbd35ab968c70905d
+  Account ID:       0xf6a233c3e1de1a2ae0486100b460b3ce3d7231ddfe9dadabbd35ab968c70905d
+  SS58 Address:     5He5pZpc7AJ8evPuab37vJF6KkFDqq9uDq2WXh877Qw6iaVC
+```
+
+Using the `inspect` command (see more details below), we see that knowning only the **secret seed** is no longer sufficient to recover the account:
+
+```bash
+subkey inspect "soup lyrics media market way crouch elevator put moon useful question wide"
+```
+
+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, this time passing also the required `password` as shown below:
+
+```bash
+subkey inspect --password extra_secret "soup lyrics media market way crouch elevator put moon useful question wide"
+```
+
+This time, we properly recovered `5He5pZpc7AJ8evPuab37vJF6KkFDqq9uDq2WXh877Qw6iaVC`.
+
+### Inspecting a key
+
+If you have *some data* about a key, `subkey inpsect` will help you discover more information about it.
+
+If you have **secrets** that you would like to verify for instance, you can use:
+
+```bash
+subkey inspect < mnemonic | seed >
+```
+
+If you have only **public data**, you can see a subset of the information:
+
+```bash
+subkey inspect --public < pubkey | address >
+```
+
+**NOTE**: While you will be able to recover the secret seed from the mnemonic, the opposite is not possible.
+
+**NOTE**: For obvious reasons, the **secrets** cannot be recovered from passing **public data** such as `pubkey` or `address` as input.
+
+command:
+
+```bash
+subkey inspect 0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+```
+
+output:
+
+```text
+Secret Key URI `0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d` is account:
+  Secret seed:      0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+  Public key (hex): 0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+  Account ID:       0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+  SS58 Address:     5Hpm9fq3W3dQgwWpAwDS2ZHKAdnk86QRCu7iX4GnmDxycrte
+```
+
+### Signing
+
+`subkey` allows using a **secret key** to sign a random message. The signature can then be verified by anyone using your **public key**:
+
+```bash
+echo -n <msg> | subkey sign --suri <seed|mnemonic>
+```
+
+example:
+
+```text
+MESSAGE=hello
+SURI=0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+echo -n $MESSAGE | subkey sign --suri $SURI
+```
+
+output:
+
+```text
+9201af3788ad4f986b800853c79da47155f2e08fde2070d866be4c27ab060466fea0623dc2b51f4392f4c61f25381a62848dd66c5d8217fae3858e469ebd668c
+```
+
+**NOTE**: Each run of the `sign` command will yield a different output. While each signature is different, they are all valid.
+
+### Verifying a signature
+
+Given a message, a signature and an address, `subkey` can verify whether the **message** has been digitally signed by the holder (or one of the holders) of the **private key** for the given **address**:
+
+```bash
+echo -n <msg> | subkey verify <sig> <address>
+```
+
+example:
+
+```bash
+MESSAGE=hello
+URI=0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+SIGNATURE=9201af3788ad4f986b800853c79da47155f2e08fde2070d866be4c27ab060466fea0623dc2b51f4392f4c61f25381a62848dd66c5d8217fae3858e469ebd668c
+echo -n $MESSAGE | subkey verify $SIGNATURE $URI
+```
+
+output:
+
+```text
+Signature verifies correctly.
+```
+
+A failure looks like:
+
+```text
+Error: SignatureInvalid
+```
+
+### Using the vanity generator
+
+You can use the included vanity generator to find a seed that provides an address which includes the desired pattern. Be warned, depending on your hardware this may take a while.
+
+command:
+
+```bash
+subkey vanity --network polkadot --pattern bob
+```
+
+output:
+
+```text
+Generating key containing pattern 'bob'
+best: 190 == top: 189
+Secret Key URI `0x8c9a73097f235b84021a446bc2826a00c690ea0be3e0d81a84931cb4146d6691` is account:
+  Secret seed:      0x8c9a73097f235b84021a446bc2826a00c690ea0be3e0d81a84931cb4146d6691
+  Public key (hex): 0x1a8b32e95c1f571118ea0b84801264c3c70f823e320d099e5de31b9b1f18f843
+  Account ID:       0x1a8b32e95c1f571118ea0b84801264c3c70f823e320d099e5de31b9b1f18f843
+  SS58 Address:     1bobYxBPjZWRPbVo35aSwci1u5Zmq8P6J2jpa4kkudBZMqE
+```
+
+`Bob` now got a nice address starting with their name: 1**bob**YxBPjZWRPbVo35aSwci1u5Zmq8P6J2jpa4kkudBZMqE.
+
+**Note**: While `Bob`, having a short name (3 chars), got a result rather quickly, it will take much longer for `Alice` who has a much longer name, thus the chances to generate a random address that contains the chain `alice` will be much smaller.
+
+## License
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
diff --git a/substrate/bin/utils/subkey/SECURITY.md b/substrate/bin/utils/subkey/SECURITY.md
new file mode 100644
index 0000000000000000000000000000000000000000..672d2965c7eae62b56a1ab6def39aea63bce4c00
--- /dev/null
+++ b/substrate/bin/utils/subkey/SECURITY.md
@@ -0,0 +1,25 @@
+# Keys and Security
+
+The following information is not exhaustive but meant to prevent the most common mistakes.
+You can read more about security and risks in the [Polkadot Wiki](https://wiki.polkadot.network/docs/learn-account-generation).
+The Polkadot network has a few **test networks**, e.g. **Westend**. Test networks are a great way to experiment and learn safely as you can lose tokens on those networks without any financial consequences.
+
+`subkey` generates and provides 2 pieces of **secret** information:
+- **secret phrase**: a bunch of words, exactly 12 by default (can be 12, 15, 18, 21 or 24)
+- **secret seed**: a big hexadecimal value
+
+There are 2 risks related to private keys:
+- loss of keys: this can happen if you don't have a proper backup
+- leak of the keys: this can unfortunately happen in many ways, including malware, phishing, key logger, backups on system that are online and not properly secured
+
+You want to ensure that:
+- you **do not lose** those secrets
+- **no one but you can access** those secrets
+
+☠� **DO NOT SHARE** your mnemonic phrase or secret seed with ANYONE under **ANY** circumstances. Doing so would give them access to your funds and to send transactions on your behalf.
+
+☠� If someone is asking for your **secret** phrase or **secret** seed, you can be **SURE** they are attempting to steal your funds.
+
+✅ It is however fine to share your **SS58 Address** as this is meant to be public information and is needed by anyone you want to be able to make transfer to or otherwise interact with your account. They will only ever need your **Public Address**.
+
+⚠� While using the same key on multiple networks is possible, it is usually **not** recommended unless you have good motivations for doing so and understand the associated risks and drawbacks.
diff --git a/substrate/bin/utils/subkey/src/lib.rs b/substrate/bin/utils/subkey/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f3023acde4047a715c0756f26ef2e3944c8206da
--- /dev/null
+++ b/substrate/bin/utils/subkey/src/lib.rs
@@ -0,0 +1,359 @@
+// 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/>.
+
+//! # Subkey
+//!
+//! Subkey is a commandline utility included with Substrate. It allows generating and restoring keys
+//! for Substrate based chains such as Polkadot, Kusama and a growing number of parachains and
+//! Substrate based projects.
+
+//! `subkey` provides a few sub-commands to generate keys, check keys, sign messages, verify
+//! messages, etc...
+//!
+//! You can see the full list of commands with `subkey --help`. Most commands have additional help
+//! available with for instance `subkey generate --help` for the `generate` command.
+//!
+//! ## Safety first
+//!
+//! `subkey` does not need an internet connection to work. Indeed, for the best security, you should
+//! be using `subkey` on a machine that is **not connected** to the internet.
+//!
+//! `subkey` deals with **seeds** and **private keys**. Make sure to use `subkey` in a safe
+//! environment (ie. no one looking over your shoulder) and on a safe computer (ie. no one able to
+//! check your command history).
+//!
+//! If you save any output of `subkey` into a file, make sure to apply proper permissions and/or
+//! delete the file as soon as possible.
+//!
+//! ## Usage
+//!
+//! The following guide explains *some* of the `subkey` commands. For the full list and the most up
+//! to date documentation, make sure to check the integrated help with `subkey --help`.
+//!
+//! ### Install with Cargo
+//!
+//! You will need to have the Substrate build dependencies to install Subkey. Use the following two
+//! commands to install the dependencies and Subkey, respectively:
+//!
+//! Command:
+//!
+//! ```bash
+//! # Install only `subkey`, at a specific version of the subkey crate
+//! cargo install --force subkey --git https://github.com/paritytech/substrate --version <SET VERSION> --locked
+//! # If you run into issues building, you likely are missing deps defined in https://docs.substrate.io/install/
+//! ```
+//!
+//! ### Run in a container
+//!
+//! ```bash
+//! # Use `--pull=always` with the `latest` tag, or specify a version in a tag
+//! docker run -it --pull=always docker.io/parity/subkey:latest <command to subkey>
+//! ```
+//!
+//! ### Generate a random account
+//!
+//! Generating a new key is as simple as running:
+//!
+//! ```bash
+//! subkey generate
+//! ```
+//!
+//! The output looks similar to:
+//!
+//! ```text
+//! Secret phrase `hotel forest jar hover kite book view eight stuff angle legend defense` is account:
+//!   Secret seed:      0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+//!   Public key (hex): 0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+//!   Account ID:       0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+//!   SS58 Address:     5Hpm9fq3W3dQgwWpAwDS2ZHKAdnk86QRCu7iX4GnmDxycrte
+//! ```
+//!
+//! ---
+//! ☠� DO NT RE-USE ANY OF THE SEEDS AND SECRETS FROM THIS PAGE ☠�.
+//!
+//! You can read more about security and risks in [SECURITY.md](./SECURITY.md) and in the [Polkadot Wiki](https://wiki.polkadot.network/docs/learn-account-generation).
+//!
+//! ---
+//!
+//! The output above shows a **secret phrase** (also called **mnemonic phrase**) and the **secret
+//! seed** (also called **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 independant
+//! from the network where you will use the key.
+//!
+//! The **SS58 address** (or **Public Address**) of a new account is a reprensentation of the public
+//! keys of an account for a given network (for instance Kusama or Polkadot).
+//!
+//! You can read more about the [SS58 format in the Substrate Docs](https://docs.substrate.io/reference/address-formats/) and see the list of reserved prefixes in the [SS58 Registry](https://github.com/paritytech/ss58-registry).
+//!
+//! For instance, considering the previous seed
+//! `0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d` the SS58 addresses are:
+//!
+//! - Polkadot: `16m4J167Mptt8UXL8aGSAi7U2FnPpPxZHPrCgMG9KJzVoFqM`
+//! - Kusama: `JLNozAv8QeLSbLFwe2UvWeKKE4yvmDbfGxTuiYkF2BUMx4M`
+//!
+//! ### Json output
+//!
+//! `subkey` can calso generate the output as *json*. This is useful for automation.
+//!
+//! command:
+//!
+//! ```bash
+//! subkey generate --output-type json
+//! ```
+//!
+//! output:
+//!
+//! ```json
+//! {
+//!   "accountId": "0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515",
+//!   "publicKey": "0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515",
+//!   "secretPhrase": "hotel forest jar hover kite book view eight stuff angle legend defense",
+//!   "secretSeed": "0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d",
+//!   "ss58Address": "5Hpm9fq3W3dQgwWpAwDS2ZHKAdnk86QRCu7iX4GnmDxycrte"
+//! }
+//! ```
+//!
+//! So if you only want to get the `secretSeed` for instance, you can use:
+//!
+//! command:
+//!
+//! ```bash
+//! subkey generate --output-type json | jq -r .secretSeed
+//! ```
+//!
+//! output:
+//!
+//! ```text
+//! 0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+//! ```
+//!
+//! ### Additional user-defined password
+//!
+//! `subkey` supports an additional user-defined secret that will be appended to the seed. Let's see
+//! the following example:
+//!
+//! ```bash
+//! subkey generate --password extra_secret
+//! ```
+//!
+//! output:
+//!
+//! ```text
+//! Secret phrase `soup lyrics media market way crouch elevator put moon useful question wide` is account:
+//!   Secret seed:      0xe7cfd179d6537a676cb94bac3b5c5c9cb1550e846ac4541040d077dfbac2e7fd
+//!   Public key (hex): 0xf6a233c3e1de1a2ae0486100b460b3ce3d7231ddfe9dadabbd35ab968c70905d
+//!   Account ID:       0xf6a233c3e1de1a2ae0486100b460b3ce3d7231ddfe9dadabbd35ab968c70905d
+//!   SS58 Address:     5He5pZpc7AJ8evPuab37vJF6KkFDqq9uDq2WXh877Qw6iaVC
+//! ```
+//!
+//! Using the `inspect` command (see more details below), we see that knowning only the **secret
+//! seed** is no longer sufficient to recover the account:
+//!
+//! ```bash
+//! subkey inspect "soup lyrics media market way crouch elevator put moon useful question wide"
+//! ```
+//!
+//! 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, this time passing also the required `password` as shown
+//! below:
+//!
+//! ```bash
+//! subkey inspect --password extra_secret "soup lyrics media market way crouch elevator put moon useful question wide"
+//! ```
+//!
+//! This time, we properly recovered `5He5pZpc7AJ8evPuab37vJF6KkFDqq9uDq2WXh877Qw6iaVC`.
+//!
+//! ### Inspecting a key
+//!
+//! If you have *some data* about a key, `subkey inpsect` will help you discover more information
+//! about it.
+//!
+//! If you have **secrets** that you would like to verify for instance, you can use:
+//!
+//! ```bash
+//! subkey inspect < mnemonic | seed >
+//! ```
+//!
+//! If you have only **public data**, you can see a subset of the information:
+//!
+//! ```bash
+//! subkey inspect --public < pubkey | address >
+//! ```
+//!
+//! **NOTE**: While you will be able to recover the secret seed from the mnemonic, the opposite is
+//! not possible.
+//!
+//! **NOTE**: For obvious reasons, the **secrets** cannot be recovered from passing **public data**
+//! such as `pubkey` or `address` as input.
+//!
+//! command:
+//!
+//! ```bash
+//! subkey inspect 0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+//! ```
+//!
+//! output:
+//!
+//! ```text
+//! Secret Key URI `0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d` is account:
+//!   Secret seed:      0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+//!   Public key (hex): 0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+//!   Account ID:       0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+//!   SS58 Address:     5Hpm9fq3W3dQgwWpAwDS2ZHKAdnk86QRCu7iX4GnmDxycrte
+//! ```
+//!
+//! ### Signing
+//!
+//! `subkey` allows using a **secret key** to sign a random message. The signature can then be
+//! verified by anyone using your **public key**:
+//!
+//! ```bash
+//! echo -n <msg> | subkey sign --suri <seed|mnemonic>
+//! ```
+//!
+//! example:
+//!
+//! ```text
+//! MESSAGE=hello
+//! SURI=0xa05c75731970cc7868a2fb7cb577353cd5b31f62dccced92c441acd8fee0c92d
+//! echo -n $MESSAGE | subkey sign --suri $SURI
+//! ```
+//!
+//! output:
+//!
+//! ```text
+//! 9201af3788ad4f986b800853c79da47155f2e08fde2070d866be4c27ab060466fea0623dc2b51f4392f4c61f25381a62848dd66c5d8217fae3858e469ebd668c
+//! ```
+//!
+//! **NOTE**: Each run of the `sign` command will yield a different output. While each signature is
+//! different, they are all valid.
+//!
+//! ### Verifying a signature
+//!
+//! Given a message, a signature and an address, `subkey` can verify whether the **message** has
+//! been digitally signed by the holder (or one of the holders) of the **private key** for the given
+//! **address**:
+//!
+//! ```bash
+//! echo -n <msg> | subkey verify <sig> <address>
+//! ```
+//!
+//! example:
+//!
+//! ```bash
+//! MESSAGE=hello
+//! URI=0xfec70cfbf1977c6965b5af10a4534a6a35d548eb14580594d0bc543286892515
+//! SIGNATURE=9201af3788ad4f986b800853c79da47155f2e08fde2070d866be4c27ab060466fea0623dc2b51f4392f4c61f25381a62848dd66c5d8217fae3858e469ebd668c
+//! echo -n $MESSAGE | subkey verify $SIGNATURE $URI
+//! ```
+//!
+//! output:
+//!
+//! ```text
+//! Signature verifies correctly.
+//! ```
+//!
+//! A failure looks like:
+//!
+//! ```text
+//! Error: SignatureInvalid
+//! ```
+//!
+//! ### Using the vanity generator
+//!
+//! You can use the included vanity generator to find a seed that provides an address which includes
+//! the desired pattern. Be warned, depending on your hardware this may take a while.
+//!
+//! command:
+//!
+//! ```bash
+//! subkey vanity --network polkadot --pattern bob
+//! ```
+//!
+//! output:
+//!
+//! ```text
+//! Generating key containing pattern 'bob'
+//! best: 190 == top: 189
+//! Secret Key URI `0x8c9a73097f235b84021a446bc2826a00c690ea0be3e0d81a84931cb4146d6691` is account:
+//!   Secret seed:      0x8c9a73097f235b84021a446bc2826a00c690ea0be3e0d81a84931cb4146d6691
+//!   Public key (hex): 0x1a8b32e95c1f571118ea0b84801264c3c70f823e320d099e5de31b9b1f18f843
+//!   Account ID:       0x1a8b32e95c1f571118ea0b84801264c3c70f823e320d099e5de31b9b1f18f843
+//!   SS58 Address:     1bobYxBPjZWRPbVo35aSwci1u5Zmq8P6J2jpa4kkudBZMqE
+//! ```
+//!
+//! `Bob` now got a nice address starting with their name:
+//! 1**bob**YxBPjZWRPbVo35aSwci1u5Zmq8P6J2jpa4kkudBZMqE.
+//!
+//! **Note**: While `Bob`, having a short name (3 chars), got a result rather quickly, it will take
+//! much longer for `Alice` who has a much longer name, thus the chances to generate a random
+//! address that contains the chain `alice` will be much smaller.
+
+use clap::Parser;
+use sc_cli::{
+	Error, GenerateCmd, GenerateNodeKeyCmd, InspectKeyCmd, InspectNodeKeyCmd, SignCmd, VanityCmd,
+	VerifyCmd,
+};
+
+#[derive(Debug, Parser)]
+#[command(
+	name = "subkey",
+	author = "Parity Team <admin@parity.io>",
+	about = "Utility for generating and restoring with Substrate keys",
+	version
+)]
+pub enum Subkey {
+	/// Generate a random node key, write it to a file or stdout and write the
+	/// corresponding peer-id to stderr
+	GenerateNodeKey(GenerateNodeKeyCmd),
+
+	/// Generate a random account
+	Generate(GenerateCmd),
+
+	/// Gets a public key and a SS58 address from the provided Secret URI
+	Inspect(InspectKeyCmd),
+
+	/// Load a node key from a file or stdin and print the corresponding peer-id
+	InspectNodeKey(InspectNodeKeyCmd),
+
+	/// Sign a message, with a given (secret) key.
+	Sign(SignCmd),
+
+	/// Generate a seed that provides a vanity address.
+	Vanity(VanityCmd),
+
+	/// Verify a signature for a message, provided on STDIN, with a given (public or secret) key.
+	Verify(VerifyCmd),
+}
+
+/// Run the subkey command, given the appropriate runtime.
+pub fn run() -> Result<(), Error> {
+	match Subkey::parse() {
+		Subkey::GenerateNodeKey(cmd) => cmd.run(),
+		Subkey::Generate(cmd) => cmd.run(),
+		Subkey::Inspect(cmd) => cmd.run(),
+		Subkey::InspectNodeKey(cmd) => cmd.run(),
+		Subkey::Vanity(cmd) => cmd.run(),
+		Subkey::Verify(cmd) => cmd.run(),
+		Subkey::Sign(cmd) => cmd.run(),
+	}
+}
diff --git a/substrate/bin/utils/subkey/src/main.rs b/substrate/bin/utils/subkey/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d836a9b8f8cc48af75cb732d9debf8dd44c83a66
--- /dev/null
+++ b/substrate/bin/utils/subkey/src/main.rs
@@ -0,0 +1,23 @@
+// 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/>.
+
+//! Subkey utility, based on kitchensink_runtime.
+
+fn main() -> Result<(), sc_cli::Error> {
+	subkey::run()
+}
diff --git a/substrate/client/allocator/Cargo.toml b/substrate/client/allocator/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d7e1f5198255c3ece4bef544889a30c080585f11
--- /dev/null
+++ b/substrate/client/allocator/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "sc-allocator"
+version = "4.1.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Collection of allocator implementations."
+documentation = "https://docs.rs/sc-allocator"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+log = "0.4.17"
+thiserror = "1.0.30"
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-wasm-interface = { version = "14.0.0", path = "../../primitives/wasm-interface" }
diff --git a/substrate/client/allocator/README.md b/substrate/client/allocator/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b89348b4c6950b4375c15f53ab4eef2031171150
--- /dev/null
+++ b/substrate/client/allocator/README.md
@@ -0,0 +1,6 @@
+Collection of allocator implementations.
+
+This crate provides the following allocator implementations:
+- A freeing-bump allocator: [`FreeingBumpHeapAllocator`](https://docs.rs/sc-allocator/latest/sc_allocator/struct.FreeingBumpHeapAllocator.html)
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/client/allocator/src/error.rs b/substrate/client/allocator/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..08d84317b650324642d2d215e681ecf89565ca42
--- /dev/null
+++ b/substrate/client/allocator/src/error.rs
@@ -0,0 +1,33 @@
+// 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.
+
+/// The error type used by the allocators.
+#[derive(thiserror::Error, Debug, PartialEq)]
+pub enum Error {
+	/// Someone tried to allocate more memory than the allowed maximum per allocation.
+	#[error("Requested allocation size is too large")]
+	RequestedAllocationTooLarge,
+	/// Allocator run out of space.
+	#[error("Allocator ran out of space")]
+	AllocatorOutOfSpace,
+	/// The client passed a memory instance which is smaller than previously observed.
+	#[error("Shrinking of the underlying memory is observed")]
+	MemoryShrinked,
+	/// Some other error occurred.
+	#[error("Other: {0}")]
+	Other(&'static str),
+}
diff --git a/substrate/client/allocator/src/freeing_bump.rs b/substrate/client/allocator/src/freeing_bump.rs
new file mode 100644
index 0000000000000000000000000000000000000000..144c0764540db3f14f6f9bea5b113506f92879d9
--- /dev/null
+++ b/substrate/client/allocator/src/freeing_bump.rs
@@ -0,0 +1,1130 @@
+// 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 module implements a freeing-bump allocator.
+//!
+//! The heap is a continuous linear memory and chunks are allocated using a bump allocator.
+//!
+//! ```ignore
+//! +-------------+-------------------------------------------------+
+//! | <allocated> | <unallocated>                                   |
+//! +-------------+-------------------------------------------------+
+//!               ^
+//!               |_ bumper
+//! ```
+//!
+//! Only allocations with sizes of power of two can be allocated. If the incoming request has a non
+//! power of two size it is increased to the nearest power of two. The power of two of size is
+//! referred as **an order**.
+//!
+//! Each allocation has a header immediately preceding to it. The header is always 8 bytes and can
+//! be of two types: free and occupied.
+//!
+//! For implementing freeing we maintain a linked lists for each order. The maximum supported
+//! allocation size is capped, therefore the number of orders and thus the linked lists is as well
+//! limited. Currently, the maximum size of an allocation is 32 MiB.
+//!
+//! When the allocator serves an allocation request it first checks the linked list for the
+//! respective order. If it doesn't have any free chunks, the allocator requests memory from the
+//! bump allocator. In any case the order is stored in the header of the allocation.
+//!
+//! Upon deallocation we get the order of the allocation from its header and then add that
+//! allocation to the linked list for the respective order.
+//!
+//! # Caveats
+//!
+//! This is a fast allocator but it is also dumb. There are specifically two main shortcomings
+//! that the user should keep in mind:
+//!
+//! - Once the bump allocator space is exhausted, there is no way to reclaim the memory. This means
+//!   that it's possible to end up in a situation where there are no live allocations yet a new
+//!   allocation will fail.
+//!
+//!   Let's look into an example. Given a heap of 32 MiB. The user makes a 32 MiB allocation that we
+//!   call `X` . Now the heap is full. Then user deallocates `X`. Since all the space in the bump
+//!   allocator was consumed by the 32 MiB allocation, allocations of all sizes except 32 MiB will
+//!   fail.
+//!
+//! - Sizes of allocations are rounded up to the nearest order. That is, an allocation of 2,00001
+//!   MiB will be put into the bucket of 4 MiB. Therefore, any allocation of size `(N, 2N]` will
+//!   take up to `2N`, thus assuming a uniform distribution of allocation sizes, the average amount
+//!   in use of a `2N` space on the heap will be `(3N + ε) / 2`. So average utilization is going to
+//!   be around 75% (`(3N + ε) / 2 / 2N`) meaning that around 25% of the space in allocation will be
+//!   wasted. This is more pronounced (in terms of absolute heap amounts) with larger allocation
+//!   sizes.
+
+use crate::{Error, Memory, MAX_WASM_PAGES, PAGE_SIZE};
+pub use sp_core::MAX_POSSIBLE_ALLOCATION;
+use sp_wasm_interface::{Pointer, WordSize};
+use std::{
+	cmp::{max, min},
+	mem,
+	ops::{Index, IndexMut, Range},
+};
+
+/// The minimal alignment guaranteed by this allocator.
+///
+/// The alignment of 8 is chosen because it is the maximum size of a primitive type supported by the
+/// target version of wasm32: i64's natural alignment is 8.
+const ALIGNMENT: u32 = 8;
+
+// Each pointer is prefixed with 8 bytes, which identify the list index
+// to which it belongs.
+const HEADER_SIZE: u32 = 8;
+
+/// Create an allocator error.
+fn error(msg: &'static str) -> Error {
+	Error::Other(msg)
+}
+
+const LOG_TARGET: &str = "wasm-heap";
+
+// The minimum possible allocation size is chosen to be 8 bytes because in that case we would have
+// easier time to provide the guaranteed alignment of 8.
+//
+// The maximum possible allocation size is set in the primitives to 32MiB.
+//
+// N_ORDERS - represents the number of orders supported.
+//
+// This number corresponds to the number of powers between the minimum possible allocation and
+// maximum possible allocation, or: 2^3...2^25 (both ends inclusive, hence 23).
+const N_ORDERS: usize = 23;
+const MIN_POSSIBLE_ALLOCATION: u32 = 8; // 2^3 bytes, 8 bytes
+
+/// The exponent for the power of two sized block adjusted to the minimum size.
+///
+/// This way, if `MIN_POSSIBLE_ALLOCATION == 8`, we would get:
+///
+/// power_of_two_size | order
+/// 8                 | 0
+/// 16                | 1
+/// 32                | 2
+/// 64                | 3
+/// ...
+/// 16777216          | 21
+/// 33554432          | 22
+///
+/// and so on.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+struct Order(u32);
+
+impl Order {
+	/// Create `Order` object from a raw order.
+	///
+	/// Returns `Err` if it is greater than the maximum supported order.
+	fn from_raw(order: u32) -> Result<Self, Error> {
+		if order < N_ORDERS as u32 {
+			Ok(Self(order))
+		} else {
+			Err(error("invalid order"))
+		}
+	}
+
+	/// Compute the order by the given size
+	///
+	/// The size is clamped, so that the following holds:
+	///
+	/// `MIN_POSSIBLE_ALLOCATION <= size <= MAX_POSSIBLE_ALLOCATION`
+	fn from_size(size: u32) -> Result<Self, Error> {
+		let clamped_size = if size > MAX_POSSIBLE_ALLOCATION {
+			log::warn!(target: LOG_TARGET, "going to fail due to allocating {:?}", size);
+			return Err(Error::RequestedAllocationTooLarge)
+		} else if size < MIN_POSSIBLE_ALLOCATION {
+			MIN_POSSIBLE_ALLOCATION
+		} else {
+			size
+		};
+
+		// Round the clamped size to the next power of two.
+		//
+		// It returns the unchanged value if the value is already a power of two.
+		let power_of_two_size = clamped_size.next_power_of_two();
+
+		// Compute the number of trailing zeroes to get the order. We adjust it by the number of
+		// trailing zeroes in the minimum possible allocation.
+		let order = power_of_two_size.trailing_zeros() - MIN_POSSIBLE_ALLOCATION.trailing_zeros();
+
+		Ok(Self(order))
+	}
+
+	/// Returns the corresponding size in bytes for this order.
+	///
+	/// Note that it is always a power of two.
+	fn size(&self) -> u32 {
+		MIN_POSSIBLE_ALLOCATION << self.0
+	}
+
+	/// Extract the order as `u32`.
+	fn into_raw(self) -> u32 {
+		self.0
+	}
+}
+
+/// A special magic value for a pointer in a link that denotes the end of the linked list.
+const NIL_MARKER: u32 = u32::MAX;
+
+/// A link between headers in the free list.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Link {
+	/// Nil, denotes that there is no next element.
+	Nil,
+	/// Link to the next element represented as a pointer to the a header.
+	Ptr(u32),
+}
+
+impl Link {
+	/// Creates a link from raw value.
+	fn from_raw(raw: u32) -> Self {
+		if raw != NIL_MARKER {
+			Self::Ptr(raw)
+		} else {
+			Self::Nil
+		}
+	}
+
+	/// Converts this link into a raw u32.
+	fn into_raw(self) -> u32 {
+		match self {
+			Self::Nil => NIL_MARKER,
+			Self::Ptr(ptr) => ptr,
+		}
+	}
+}
+
+/// A header of an allocation.
+///
+/// The header is encoded in memory as follows.
+///
+/// ## Free header
+///
+/// ```ignore
+/// 64             32                  0
+//  +--------------+-------------------+
+/// |            0 | next element link |
+/// +--------------+-------------------+
+/// ```
+/// ## Occupied header
+/// ```ignore
+/// 64             32                  0
+//  +--------------+-------------------+
+/// |            1 |             order |
+/// +--------------+-------------------+
+/// ```
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum Header {
+	/// A free header contains a link to the next element to form a free linked list.
+	Free(Link),
+	/// An occupied header has attached order to know in which free list we should put the
+	/// allocation upon deallocation.
+	Occupied(Order),
+}
+
+impl Header {
+	/// Reads a header from memory.
+	///
+	/// Returns an error if the `header_ptr` is out of bounds of the linear memory or if the read
+	/// header is corrupted (e.g. the order is incorrect).
+	fn read_from(memory: &impl Memory, header_ptr: u32) -> Result<Self, Error> {
+		let raw_header = memory.read_le_u64(header_ptr)?;
+
+		// Check if the header represents an occupied or free allocation and extract the header data
+		// by trimming (and discarding) the high bits.
+		let occupied = raw_header & 0x00000001_00000000 != 0;
+		let header_data = raw_header as u32;
+
+		Ok(if occupied {
+			Self::Occupied(Order::from_raw(header_data)?)
+		} else {
+			Self::Free(Link::from_raw(header_data))
+		})
+	}
+
+	/// Write out this header to memory.
+	///
+	/// Returns an error if the `header_ptr` is out of bounds of the linear memory.
+	fn write_into(&self, memory: &mut impl Memory, header_ptr: u32) -> Result<(), Error> {
+		let (header_data, occupied_mask) = match *self {
+			Self::Occupied(order) => (order.into_raw(), 0x00000001_00000000),
+			Self::Free(link) => (link.into_raw(), 0x00000000_00000000),
+		};
+		let raw_header = header_data as u64 | occupied_mask;
+		memory.write_le_u64(header_ptr, raw_header)?;
+		Ok(())
+	}
+
+	/// Returns the order of the allocation if this is an occupied header.
+	fn into_occupied(self) -> Option<Order> {
+		match self {
+			Self::Occupied(order) => Some(order),
+			_ => None,
+		}
+	}
+
+	/// Returns the link to the next element in the free list if this is a free header.
+	fn into_free(self) -> Option<Link> {
+		match self {
+			Self::Free(link) => Some(link),
+			_ => None,
+		}
+	}
+}
+
+/// This struct represents a collection of intrusive linked lists for each order.
+struct FreeLists {
+	heads: [Link; N_ORDERS],
+}
+
+impl FreeLists {
+	/// Creates the free empty lists.
+	fn new() -> Self {
+		Self { heads: [Link::Nil; N_ORDERS] }
+	}
+
+	/// Replaces a given link for the specified order and returns the old one.
+	fn replace(&mut self, order: Order, new: Link) -> Link {
+		let prev = self[order];
+		self[order] = new;
+		prev
+	}
+}
+
+impl Index<Order> for FreeLists {
+	type Output = Link;
+	fn index(&self, index: Order) -> &Link {
+		&self.heads[index.0 as usize]
+	}
+}
+
+impl IndexMut<Order> for FreeLists {
+	fn index_mut(&mut self, index: Order) -> &mut Link {
+		&mut self.heads[index.0 as usize]
+	}
+}
+
+/// Memory allocation stats gathered during the lifetime of the allocator.
+#[derive(Clone, Debug, Default)]
+#[non_exhaustive]
+pub struct AllocationStats {
+	/// The current number of bytes allocated.
+	///
+	/// This represents how many bytes are allocated *right now*.
+	pub bytes_allocated: u32,
+
+	/// The peak number of bytes ever allocated.
+	///
+	/// This is the maximum the `bytes_allocated` ever reached.
+	pub bytes_allocated_peak: u32,
+
+	/// The sum of every allocation ever made.
+	///
+	/// This increases every time a new allocation is made.
+	pub bytes_allocated_sum: u128,
+
+	/// The amount of address space (in bytes) used by the allocator.
+	///
+	/// This is calculated as the difference between the allocator's bumper
+	/// and the heap base.
+	///
+	/// Currently the bumper's only ever incremented, so this is simultaneously
+	/// the current value as well as the peak value.
+	pub address_space_used: u32,
+}
+
+/// Convert the given `size` in bytes into the number of pages.
+///
+/// The returned number of pages is ensured to be big enough to hold memory with the given `size`.
+///
+/// Returns `None` if the number of pages to not fit into `u32`.
+fn pages_from_size(size: u64) -> Option<u32> {
+	u32::try_from((size + PAGE_SIZE as u64 - 1) / PAGE_SIZE as u64).ok()
+}
+
+/// An implementation of freeing bump allocator.
+///
+/// Refer to the module-level documentation for further details.
+pub struct FreeingBumpHeapAllocator {
+	original_heap_base: u32,
+	bumper: u32,
+	free_lists: FreeLists,
+	poisoned: bool,
+	last_observed_memory_size: u64,
+	stats: AllocationStats,
+}
+
+impl Drop for FreeingBumpHeapAllocator {
+	fn drop(&mut self) {
+		log::debug!(target: LOG_TARGET, "allocator dropped: {:?}", self.stats)
+	}
+}
+
+impl FreeingBumpHeapAllocator {
+	/// Creates a new allocation heap which follows a freeing-bump strategy.
+	///
+	/// # Arguments
+	///
+	/// - `heap_base` - the offset from the beginning of the linear memory where the heap starts.
+	pub fn new(heap_base: u32) -> Self {
+		let aligned_heap_base = (heap_base + ALIGNMENT - 1) / ALIGNMENT * ALIGNMENT;
+
+		FreeingBumpHeapAllocator {
+			original_heap_base: aligned_heap_base,
+			bumper: aligned_heap_base,
+			free_lists: FreeLists::new(),
+			poisoned: false,
+			last_observed_memory_size: 0,
+			stats: AllocationStats::default(),
+		}
+	}
+
+	/// Gets requested number of bytes to allocate and returns a pointer.
+	/// The maximum size which can be allocated at once is 32 MiB.
+	/// There is no minimum size, but whatever size is passed into
+	/// this function is rounded to the next power of two. If the requested
+	/// size is below 8 bytes it will be rounded up to 8 bytes.
+	///
+	/// The identity or the type of the passed memory object does not matter. However, the size of
+	/// memory cannot shrink compared to the memory passed in previous invocations.
+	///
+	/// NOTE: Once the allocator has returned an error all subsequent requests will return an error.
+	///
+	/// # Arguments
+	///
+	/// - `mem` - a slice representing the linear memory on which this allocator operates.
+	/// - `size` - size in bytes of the allocation request
+	pub fn allocate(
+		&mut self,
+		mem: &mut impl Memory,
+		size: WordSize,
+	) -> Result<Pointer<u8>, Error> {
+		if self.poisoned {
+			return Err(error("the allocator has been poisoned"))
+		}
+
+		let bomb = PoisonBomb { poisoned: &mut self.poisoned };
+
+		Self::observe_memory_size(&mut self.last_observed_memory_size, mem)?;
+		let order = Order::from_size(size)?;
+
+		let header_ptr: u32 = match self.free_lists[order] {
+			Link::Ptr(header_ptr) => {
+				if (u64::from(header_ptr) + u64::from(order.size()) + u64::from(HEADER_SIZE)) >
+					mem.size()
+				{
+					return Err(error("Invalid header pointer detected"))
+				}
+
+				// Remove this header from the free list.
+				let next_free = Header::read_from(mem, header_ptr)?
+					.into_free()
+					.ok_or_else(|| error("free list points to a occupied header"))?;
+				self.free_lists[order] = next_free;
+
+				header_ptr
+			},
+			Link::Nil => {
+				// Corresponding free list is empty. Allocate a new item.
+				Self::bump(&mut self.bumper, order.size() + HEADER_SIZE, mem)?
+			},
+		};
+
+		// Write the order in the occupied header.
+		Header::Occupied(order).write_into(mem, header_ptr)?;
+
+		self.stats.bytes_allocated += order.size() + HEADER_SIZE;
+		self.stats.bytes_allocated_sum += u128::from(order.size() + HEADER_SIZE);
+		self.stats.bytes_allocated_peak =
+			max(self.stats.bytes_allocated_peak, self.stats.bytes_allocated);
+		self.stats.address_space_used = self.bumper - self.original_heap_base;
+
+		log::trace!(target: LOG_TARGET, "after allocation: {:?}", self.stats);
+
+		bomb.disarm();
+		Ok(Pointer::new(header_ptr + HEADER_SIZE))
+	}
+
+	/// Deallocates the space which was allocated for a pointer.
+	///
+	/// The identity or the type of the passed memory object does not matter. However, the size of
+	/// memory cannot shrink compared to the memory passed in previous invocations.
+	///
+	/// NOTE: Once the allocator has returned an error all subsequent requests will return an error.
+	///
+	/// # Arguments
+	///
+	/// - `mem` - a slice representing the linear memory on which this allocator operates.
+	/// - `ptr` - pointer to the allocated chunk
+	pub fn deallocate(&mut self, mem: &mut impl Memory, ptr: Pointer<u8>) -> Result<(), Error> {
+		if self.poisoned {
+			return Err(error("the allocator has been poisoned"))
+		}
+
+		let bomb = PoisonBomb { poisoned: &mut self.poisoned };
+
+		Self::observe_memory_size(&mut self.last_observed_memory_size, mem)?;
+
+		let header_ptr = u32::from(ptr)
+			.checked_sub(HEADER_SIZE)
+			.ok_or_else(|| error("Invalid pointer for deallocation"))?;
+
+		let order = Header::read_from(mem, header_ptr)?
+			.into_occupied()
+			.ok_or_else(|| error("the allocation points to an empty header"))?;
+
+		// Update the just freed header and knit it back to the free list.
+		let prev_head = self.free_lists.replace(order, Link::Ptr(header_ptr));
+		Header::Free(prev_head).write_into(mem, header_ptr)?;
+
+		self.stats.bytes_allocated = self
+			.stats
+			.bytes_allocated
+			.checked_sub(order.size() + HEADER_SIZE)
+			.ok_or_else(|| error("underflow of the currently allocated bytes count"))?;
+
+		log::trace!("after deallocation: {:?}", self.stats);
+
+		bomb.disarm();
+		Ok(())
+	}
+
+	/// Returns the allocation stats for this allocator.
+	pub fn stats(&self) -> AllocationStats {
+		self.stats.clone()
+	}
+
+	/// Increases the `bumper` by `size`.
+	///
+	/// Returns the `bumper` from before the increase. Returns an `Error::AllocatorOutOfSpace` if
+	/// the operation would exhaust the heap.
+	fn bump(bumper: &mut u32, size: u32, memory: &mut impl Memory) -> Result<u32, Error> {
+		let required_size = u64::from(*bumper) + u64::from(size);
+
+		if required_size > memory.size() {
+			let required_pages =
+				pages_from_size(required_size).ok_or_else(|| Error::AllocatorOutOfSpace)?;
+
+			let current_pages = memory.pages();
+			let max_pages = memory.max_pages().unwrap_or(MAX_WASM_PAGES);
+			debug_assert!(
+				current_pages < required_pages,
+				"current pages {current_pages} < required pages {required_pages}"
+			);
+
+			if current_pages >= max_pages {
+				log::debug!(
+					target: LOG_TARGET,
+					"Wasm pages ({current_pages}) are already at the maximum.",
+				);
+
+				return Err(Error::AllocatorOutOfSpace)
+			} else if required_pages > max_pages {
+				log::debug!(
+					target: LOG_TARGET,
+					"Failed to grow memory from {current_pages} pages to at least {required_pages}\
+						 pages due to the maximum limit of {max_pages} pages",
+				);
+				return Err(Error::AllocatorOutOfSpace)
+			}
+
+			// Ideally we want to double our current number of pages,
+			// as long as it's less than the absolute maximum we can have.
+			let next_pages = min(current_pages * 2, max_pages);
+			// ...but if even more pages are required then try to allocate that many.
+			let next_pages = max(next_pages, required_pages);
+
+			if memory.grow(next_pages - current_pages).is_err() {
+				log::error!(
+					target: LOG_TARGET,
+					"Failed to grow memory from {current_pages} pages to {next_pages} pages",
+				);
+
+				return Err(Error::AllocatorOutOfSpace)
+			}
+
+			debug_assert_eq!(memory.pages(), next_pages, "Number of pages should have increased!");
+		}
+
+		let res = *bumper;
+		*bumper += size;
+		Ok(res)
+	}
+
+	fn observe_memory_size(
+		last_observed_memory_size: &mut u64,
+		mem: &mut impl Memory,
+	) -> Result<(), Error> {
+		if mem.size() < *last_observed_memory_size {
+			return Err(Error::MemoryShrinked)
+		}
+		*last_observed_memory_size = mem.size();
+		Ok(())
+	}
+}
+
+/// A trait for abstraction of accesses to a wasm linear memory. Used to read or modify the
+/// allocation prefixes.
+///
+/// A wasm linear memory behaves similarly to a vector. The address space doesn't have holes and is
+/// accessible up to the reported size.
+///
+/// The linear memory can grow in size with the wasm page granularity (64KiB), but it cannot shrink.
+trait MemoryExt: Memory {
+	/// Read a u64 from the heap in LE form. Returns an error if any of the bytes read are out of
+	/// bounds.
+	fn read_le_u64(&self, ptr: u32) -> Result<u64, Error> {
+		self.with_access(|memory| {
+			let range =
+				heap_range(ptr, 8, memory.len()).ok_or_else(|| error("read out of heap bounds"))?;
+			let bytes = memory[range]
+				.try_into()
+				.expect("[u8] slice of length 8 must be convertible to [u8; 8]");
+			Ok(u64::from_le_bytes(bytes))
+		})
+	}
+
+	/// Write a u64 to the heap in LE form. Returns an error if any of the bytes written are out of
+	/// bounds.
+	fn write_le_u64(&mut self, ptr: u32, val: u64) -> Result<(), Error> {
+		self.with_access_mut(|memory| {
+			let range = heap_range(ptr, 8, memory.len())
+				.ok_or_else(|| error("write out of heap bounds"))?;
+			let bytes = val.to_le_bytes();
+			memory[range].copy_from_slice(&bytes[..]);
+			Ok(())
+		})
+	}
+
+	/// Returns the full size of the memory in bytes.
+	fn size(&self) -> u64 {
+		debug_assert!(self.pages() <= MAX_WASM_PAGES);
+
+		self.pages() as u64 * PAGE_SIZE as u64
+	}
+}
+
+impl<T: Memory> MemoryExt for T {}
+
+fn heap_range(offset: u32, length: u32, heap_len: usize) -> Option<Range<usize>> {
+	let start = offset as usize;
+	let end = offset.checked_add(length)? as usize;
+	if end <= heap_len {
+		Some(start..end)
+	} else {
+		None
+	}
+}
+
+/// A guard that will raise the poisoned flag on drop unless disarmed.
+struct PoisonBomb<'a> {
+	poisoned: &'a mut bool,
+}
+
+impl<'a> PoisonBomb<'a> {
+	fn disarm(self) {
+		mem::forget(self)
+	}
+}
+
+impl<'a> Drop for PoisonBomb<'a> {
+	fn drop(&mut self) {
+		*self.poisoned = true;
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	/// Makes a pointer out of the given address.
+	fn to_pointer(address: u32) -> Pointer<u8> {
+		Pointer::new(address)
+	}
+
+	#[derive(Debug)]
+	struct MemoryInstance {
+		data: Vec<u8>,
+		max_wasm_pages: u32,
+	}
+
+	impl MemoryInstance {
+		fn with_pages(pages: u32) -> Self {
+			Self { data: vec![0; (pages * PAGE_SIZE) as usize], max_wasm_pages: MAX_WASM_PAGES }
+		}
+
+		fn set_max_wasm_pages(&mut self, max_pages: u32) {
+			self.max_wasm_pages = max_pages;
+		}
+	}
+
+	impl Memory for MemoryInstance {
+		fn with_access<R>(&self, run: impl FnOnce(&[u8]) -> R) -> R {
+			run(&self.data)
+		}
+
+		fn with_access_mut<R>(&mut self, run: impl FnOnce(&mut [u8]) -> R) -> R {
+			run(&mut self.data)
+		}
+
+		fn pages(&self) -> u32 {
+			pages_from_size(self.data.len() as u64).unwrap()
+		}
+
+		fn max_pages(&self) -> Option<u32> {
+			Some(self.max_wasm_pages)
+		}
+
+		fn grow(&mut self, pages: u32) -> Result<(), ()> {
+			if self.pages() + pages > self.max_wasm_pages {
+				Err(())
+			} else {
+				self.data.resize(((self.pages() + pages) * PAGE_SIZE) as usize, 0);
+				Ok(())
+			}
+		}
+	}
+
+	#[test]
+	fn test_pages_from_size() {
+		assert_eq!(pages_from_size(0).unwrap(), 0);
+		assert_eq!(pages_from_size(1).unwrap(), 1);
+		assert_eq!(pages_from_size(65536).unwrap(), 1);
+		assert_eq!(pages_from_size(65536 + 1).unwrap(), 2);
+		assert_eq!(pages_from_size(2 * 65536).unwrap(), 2);
+		assert_eq!(pages_from_size(2 * 65536 + 1).unwrap(), 3);
+	}
+
+	#[test]
+	fn should_allocate_properly() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		// when
+		let ptr = heap.allocate(&mut mem, 1).unwrap();
+
+		// then
+		// returned pointer must start right after `HEADER_SIZE`
+		assert_eq!(ptr, to_pointer(HEADER_SIZE));
+	}
+
+	#[test]
+	fn should_always_align_pointers_to_multiples_of_8() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(13);
+
+		// when
+		let ptr = heap.allocate(&mut mem, 1).unwrap();
+
+		// then
+		// the pointer must start at the next multiple of 8 from 13
+		// + the prefix of 8 bytes.
+		assert_eq!(ptr, to_pointer(24));
+	}
+
+	#[test]
+	fn should_increment_pointers_properly() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		// when
+		let ptr1 = heap.allocate(&mut mem, 1).unwrap();
+		let ptr2 = heap.allocate(&mut mem, 9).unwrap();
+		let ptr3 = heap.allocate(&mut mem, 1).unwrap();
+
+		// then
+		// a prefix of 8 bytes is prepended to each pointer
+		assert_eq!(ptr1, to_pointer(HEADER_SIZE));
+
+		// the prefix of 8 bytes + the content of ptr1 padded to the lowest possible
+		// item size of 8 bytes + the prefix of ptr1
+		assert_eq!(ptr2, to_pointer(24));
+
+		// ptr2 + its content of 16 bytes + the prefix of 8 bytes
+		assert_eq!(ptr3, to_pointer(24 + 16 + HEADER_SIZE));
+	}
+
+	#[test]
+	fn should_free_properly() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+		let ptr1 = heap.allocate(&mut mem, 1).unwrap();
+		// the prefix of 8 bytes is prepended to the pointer
+		assert_eq!(ptr1, to_pointer(HEADER_SIZE));
+
+		let ptr2 = heap.allocate(&mut mem, 1).unwrap();
+		// the prefix of 8 bytes + the content of ptr 1 is prepended to the pointer
+		assert_eq!(ptr2, to_pointer(24));
+
+		// when
+		heap.deallocate(&mut mem, ptr2).unwrap();
+
+		// then
+		// then the heads table should contain a pointer to the
+		// prefix of ptr2 in the leftmost entry
+		assert_eq!(heap.free_lists.heads[0], Link::Ptr(u32::from(ptr2) - HEADER_SIZE));
+	}
+
+	#[test]
+	fn should_deallocate_and_reallocate_properly() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let padded_offset = 16;
+		let mut heap = FreeingBumpHeapAllocator::new(13);
+
+		let ptr1 = heap.allocate(&mut mem, 1).unwrap();
+		// the prefix of 8 bytes is prepended to the pointer
+		assert_eq!(ptr1, to_pointer(padded_offset + HEADER_SIZE));
+
+		let ptr2 = heap.allocate(&mut mem, 9).unwrap();
+		// the padded_offset + the previously allocated ptr (8 bytes prefix +
+		// 8 bytes content) + the prefix of 8 bytes which is prepended to the
+		// current pointer
+		assert_eq!(ptr2, to_pointer(padded_offset + 16 + HEADER_SIZE));
+
+		// when
+		heap.deallocate(&mut mem, ptr2).unwrap();
+		let ptr3 = heap.allocate(&mut mem, 9).unwrap();
+
+		// then
+		// should have re-allocated
+		assert_eq!(ptr3, to_pointer(padded_offset + 16 + HEADER_SIZE));
+		assert_eq!(heap.free_lists.heads, [Link::Nil; N_ORDERS]);
+	}
+
+	#[test]
+	fn should_build_linked_list_of_free_areas_properly() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		let ptr1 = heap.allocate(&mut mem, 8).unwrap();
+		let ptr2 = heap.allocate(&mut mem, 8).unwrap();
+		let ptr3 = heap.allocate(&mut mem, 8).unwrap();
+
+		// when
+		heap.deallocate(&mut mem, ptr1).unwrap();
+		heap.deallocate(&mut mem, ptr2).unwrap();
+		heap.deallocate(&mut mem, ptr3).unwrap();
+
+		// then
+		assert_eq!(heap.free_lists.heads[0], Link::Ptr(u32::from(ptr3) - HEADER_SIZE));
+
+		let ptr4 = heap.allocate(&mut mem, 8).unwrap();
+		assert_eq!(ptr4, ptr3);
+
+		assert_eq!(heap.free_lists.heads[0], Link::Ptr(u32::from(ptr2) - HEADER_SIZE));
+	}
+
+	#[test]
+	fn should_not_allocate_if_too_large() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		mem.set_max_wasm_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(13);
+
+		// when
+		let ptr = heap.allocate(&mut mem, PAGE_SIZE - 13);
+
+		// then
+		assert_eq!(Error::AllocatorOutOfSpace, ptr.unwrap_err());
+	}
+
+	#[test]
+	fn should_not_allocate_if_full() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		mem.set_max_wasm_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+		let ptr1 = heap.allocate(&mut mem, (PAGE_SIZE / 2) - HEADER_SIZE).unwrap();
+		assert_eq!(ptr1, to_pointer(HEADER_SIZE));
+
+		// when
+		let ptr2 = heap.allocate(&mut mem, PAGE_SIZE / 2);
+
+		// then
+		// there is no room for another half page incl. its 8 byte prefix
+		match ptr2.unwrap_err() {
+			Error::AllocatorOutOfSpace => {},
+			e => panic!("Expected allocator out of space error, got: {:?}", e),
+		}
+	}
+
+	#[test]
+	fn should_allocate_max_possible_allocation_size() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		// when
+		let ptr = heap.allocate(&mut mem, MAX_POSSIBLE_ALLOCATION).unwrap();
+
+		// then
+		assert_eq!(ptr, to_pointer(HEADER_SIZE));
+	}
+
+	#[test]
+	fn should_not_allocate_if_requested_size_too_large() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		// when
+		let ptr = heap.allocate(&mut mem, MAX_POSSIBLE_ALLOCATION + 1);
+
+		// then
+		assert_eq!(Error::RequestedAllocationTooLarge, ptr.unwrap_err());
+	}
+
+	#[test]
+	fn should_return_error_when_bumper_greater_than_heap_size() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		mem.set_max_wasm_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		let mut ptrs = Vec::new();
+		for _ in 0..(PAGE_SIZE as usize / 40) {
+			ptrs.push(heap.allocate(&mut mem, 32).expect("Allocate 32 byte"));
+		}
+
+		assert_eq!(heap.stats.bytes_allocated, PAGE_SIZE - 16);
+		assert_eq!(heap.bumper, PAGE_SIZE - 16);
+
+		ptrs.into_iter()
+			.for_each(|ptr| heap.deallocate(&mut mem, ptr).expect("Deallocate 32 byte"));
+
+		assert_eq!(heap.stats.bytes_allocated, 0);
+		assert_eq!(heap.stats.bytes_allocated_peak, PAGE_SIZE - 16);
+		assert_eq!(heap.bumper, PAGE_SIZE - 16);
+
+		// Allocate another 8 byte to use the full heap.
+		heap.allocate(&mut mem, 8).expect("Allocate 8 byte");
+
+		// when
+		// the `bumper` value is equal to `size` here and any
+		// further allocation which would increment the bumper must fail.
+		// we try to allocate 8 bytes here, which will increment the
+		// bumper since no 8 byte item has been freed before.
+		assert_eq!(heap.bumper as u64, mem.size());
+		let ptr = heap.allocate(&mut mem, 8);
+
+		// then
+		assert_eq!(Error::AllocatorOutOfSpace, ptr.unwrap_err());
+	}
+
+	#[test]
+	fn should_include_prefixes_in_total_heap_size() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(1);
+
+		// when
+		// an item size of 16 must be used then
+		heap.allocate(&mut mem, 9).unwrap();
+
+		// then
+		assert_eq!(heap.stats.bytes_allocated, HEADER_SIZE + 16);
+	}
+
+	#[test]
+	fn should_calculate_total_heap_size_to_zero() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(13);
+
+		// when
+		let ptr = heap.allocate(&mut mem, 42).unwrap();
+		assert_eq!(ptr, to_pointer(16 + HEADER_SIZE));
+		heap.deallocate(&mut mem, ptr).unwrap();
+
+		// then
+		assert_eq!(heap.stats.bytes_allocated, 0);
+	}
+
+	#[test]
+	fn should_calculate_total_size_of_zero() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(19);
+
+		// when
+		for _ in 1..10 {
+			let ptr = heap.allocate(&mut mem, 42).unwrap();
+			heap.deallocate(&mut mem, ptr).unwrap();
+		}
+
+		// then
+		assert_eq!(heap.stats.bytes_allocated, 0);
+	}
+
+	#[test]
+	fn should_read_and_write_u64_correctly() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+
+		// when
+		mem.write_le_u64(40, 4480113).unwrap();
+
+		// then
+		let value = MemoryExt::read_le_u64(&mut mem, 40).unwrap();
+		assert_eq!(value, 4480113);
+	}
+
+	#[test]
+	fn should_get_item_size_from_order() {
+		// given
+		let raw_order = 0;
+
+		// when
+		let item_size = Order::from_raw(raw_order).unwrap().size();
+
+		// then
+		assert_eq!(item_size, 8);
+	}
+
+	#[test]
+	fn should_get_max_item_size_from_index() {
+		// given
+		let raw_order = 22;
+
+		// when
+		let item_size = Order::from_raw(raw_order).unwrap().size();
+
+		// then
+		assert_eq!(item_size as u32, MAX_POSSIBLE_ALLOCATION);
+	}
+
+	#[test]
+	fn deallocate_needs_to_maintain_linked_list() {
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		// Allocate and free some pointers
+		let ptrs = (0..4).map(|_| heap.allocate(&mut mem, 8).unwrap()).collect::<Vec<_>>();
+		ptrs.iter().rev().for_each(|ptr| heap.deallocate(&mut mem, *ptr).unwrap());
+
+		// Second time we should be able to allocate all of them again and get the same pointers!
+		let new_ptrs = (0..4).map(|_| heap.allocate(&mut mem, 8).unwrap()).collect::<Vec<_>>();
+		assert_eq!(ptrs, new_ptrs);
+	}
+
+	#[test]
+	fn header_read_write() {
+		let roundtrip = |header: Header| {
+			let mut memory = MemoryInstance::with_pages(1);
+			header.write_into(&mut memory, 0).unwrap();
+
+			let read_header = Header::read_from(&memory, 0).unwrap();
+			assert_eq!(header, read_header);
+		};
+
+		roundtrip(Header::Occupied(Order(0)));
+		roundtrip(Header::Occupied(Order(1)));
+		roundtrip(Header::Free(Link::Nil));
+		roundtrip(Header::Free(Link::Ptr(0)));
+		roundtrip(Header::Free(Link::Ptr(4)));
+	}
+
+	#[test]
+	fn poison_oom() {
+		// given
+		let mut mem = MemoryInstance::with_pages(1);
+		mem.set_max_wasm_pages(1);
+
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		// when
+		let alloc_ptr = heap.allocate(&mut mem, PAGE_SIZE / 2).unwrap();
+		assert_eq!(Error::AllocatorOutOfSpace, heap.allocate(&mut mem, PAGE_SIZE).unwrap_err());
+
+		// then
+		assert!(heap.poisoned);
+		assert!(heap.deallocate(&mut mem, alloc_ptr).is_err());
+	}
+
+	#[test]
+	fn test_n_orders() {
+		// Test that N_ORDERS is consistent with min and max possible allocation.
+		assert_eq!(
+			MIN_POSSIBLE_ALLOCATION * 2u32.pow(N_ORDERS as u32 - 1),
+			MAX_POSSIBLE_ALLOCATION
+		);
+	}
+
+	#[test]
+	fn accepts_growing_memory() {
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		heap.allocate(&mut mem, PAGE_SIZE / 2).unwrap();
+		heap.allocate(&mut mem, PAGE_SIZE / 2).unwrap();
+
+		mem.grow(1).unwrap();
+
+		heap.allocate(&mut mem, PAGE_SIZE / 2).unwrap();
+	}
+
+	#[test]
+	fn doesnt_accept_shrinking_memory() {
+		let mut mem = MemoryInstance::with_pages(2);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		heap.allocate(&mut mem, PAGE_SIZE / 2).unwrap();
+
+		mem.data.truncate(PAGE_SIZE as usize);
+
+		match heap.allocate(&mut mem, PAGE_SIZE / 2).unwrap_err() {
+			Error::MemoryShrinked => (),
+			_ => panic!(),
+		}
+	}
+
+	#[test]
+	fn should_grow_memory_when_running_out_of_memory() {
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		assert_eq!(1, mem.pages());
+
+		heap.allocate(&mut mem, PAGE_SIZE * 2).unwrap();
+
+		assert_eq!(3, mem.pages());
+	}
+
+	#[test]
+	fn modifying_the_header_leads_to_an_error() {
+		let mut mem = MemoryInstance::with_pages(1);
+		let mut heap = FreeingBumpHeapAllocator::new(0);
+
+		let ptr = heap.allocate(&mut mem, 5).unwrap();
+
+		heap.deallocate(&mut mem, ptr).unwrap();
+
+		Header::Free(Link::Ptr(u32::MAX - 1))
+			.write_into(&mut mem, u32::from(ptr) - HEADER_SIZE)
+			.unwrap();
+
+		heap.allocate(&mut mem, 5).unwrap();
+		assert!(heap
+			.allocate(&mut mem, 5)
+			.unwrap_err()
+			.to_string()
+			.contains("Invalid header pointer"));
+	}
+}
diff --git a/substrate/client/allocator/src/lib.rs b/substrate/client/allocator/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e50d7d54c8e97659a60a391d40561f58d13d4d13
--- /dev/null
+++ b/substrate/client/allocator/src/lib.rs
@@ -0,0 +1,61 @@
+// 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.
+
+//! Collection of allocator implementations.
+//!
+//! This crate provides the following allocator implementations:
+//! - A freeing-bump allocator: [`FreeingBumpHeapAllocator`](freeing_bump::FreeingBumpHeapAllocator)
+
+#![warn(missing_docs)]
+
+mod error;
+mod freeing_bump;
+
+pub use error::Error;
+pub use freeing_bump::{AllocationStats, FreeingBumpHeapAllocator};
+
+/// The size of one wasm page in bytes.
+///
+/// The wasm memory is divided into pages, meaning the minimum size of a memory is one page.
+const PAGE_SIZE: u32 = 65536;
+
+/// The maximum number of wasm pages that can be allocated.
+///
+/// 4GiB / [`PAGE_SIZE`].
+const MAX_WASM_PAGES: u32 = (4u64 * 1024 * 1024 * 1024 / PAGE_SIZE as u64) as u32;
+
+/// Grants access to the memory for the allocator.
+///
+/// Memory of wasm is allocated in pages. A page has a constant size of 64KiB. The maximum allowed
+/// memory size as defined in the wasm specification is 4GiB (65536 pages).
+pub trait Memory {
+	/// Run the given closure `run` and grant it write access to the raw memory.
+	fn with_access_mut<R>(&mut self, run: impl FnOnce(&mut [u8]) -> R) -> R;
+	/// Run the given closure `run` and grant it read access to the raw memory.
+	fn with_access<R>(&self, run: impl FnOnce(&[u8]) -> R) -> R;
+	/// Grow the memory by `additional` pages.
+	fn grow(&mut self, additional: u32) -> Result<(), ()>;
+	/// Returns the current number of pages this memory has allocated.
+	fn pages(&self) -> u32;
+	/// Returns the maximum number of pages this memory is allowed to allocate.
+	///
+	/// The returned number needs to be smaller or equal to `65536`. The returned number needs to be
+	/// bigger or equal to [`Self::pages`].
+	///
+	/// If `None` is returned, there is no maximum (besides the maximum defined in the wasm spec).
+	fn max_pages(&self) -> Option<u32>;
+}
diff --git a/substrate/client/api/Cargo.toml b/substrate/client/api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..17f9747c39bc1abd11d211b8679a030a9a24900d
--- /dev/null
+++ b/substrate/client/api/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "sc-client-api"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate client interfaces."
+documentation = "https://docs.rs/sc-client-api"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+fnv = "1.0.6"
+futures = "0.3.21"
+log = "0.4.17"
+parking_lot = "0.12.1"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+sc-executor = { version = "0.10.0-dev", path = "../executor" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../transaction-pool/api" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-database = { version = "4.0.0-dev", path = "../../primitives/database" }
+sp-externalities = { version = "0.19.0", path = "../../primitives/externalities" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../primitives/state-machine" }
+sp-statement-store = { version = "4.0.0-dev", path = "../../primitives/statement-store" }
+sp-storage = { version = "13.0.0", path = "../../primitives/storage" }
+
+[dev-dependencies]
+thiserror = "1.0.30"
+sp-test-primitives = { version = "2.0.0", path = "../../primitives/test-primitives" }
+substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime" }
diff --git a/substrate/client/api/README.md b/substrate/client/api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..142f5b32dd9a8de7c083aac5260ac6677042c3ad
--- /dev/null
+++ b/substrate/client/api/README.md
@@ -0,0 +1,3 @@
+Substrate client interfaces.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/api/src/backend.rs b/substrate/client/api/src/backend.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2d8fdef77cdb9064076c3d38188d72bccedfdf9e
--- /dev/null
+++ b/substrate/client/api/src/backend.rs
@@ -0,0 +1,621 @@
+// 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/>.
+
+//! Substrate Client data backend
+
+use std::collections::HashSet;
+
+use parking_lot::RwLock;
+
+use sp_consensus::BlockOrigin;
+use sp_core::offchain::OffchainStorage;
+use sp_runtime::{
+	traits::{Block as BlockT, HashingFor, NumberFor},
+	Justification, Justifications, StateVersion, Storage,
+};
+use sp_state_machine::{
+	backend::AsTrieBackend, ChildStorageCollection, IndexOperation, IterArgs,
+	OffchainChangesCollection, StorageCollection, StorageIterator,
+};
+use sp_storage::{ChildInfo, StorageData, StorageKey};
+
+use crate::{blockchain::Backend as BlockchainBackend, UsageInfo};
+
+pub use sp_state_machine::{Backend as StateBackend, BackendTransaction, KeyValueStates};
+
+/// Extracts the state backend type for the given backend.
+pub type StateBackendFor<B, Block> = <B as Backend<Block>>::State;
+
+/// Describes which block import notification stream should be notified.
+#[derive(Debug, Clone, Copy)]
+pub enum ImportNotificationAction {
+	/// Notify only when the node has synced to the tip or there is a re-org.
+	RecentBlock,
+	/// Notify for every single block no matter what the sync state is.
+	EveryBlock,
+	/// Both block import notifications above should be fired.
+	Both,
+	/// No block import notification should be fired.
+	None,
+}
+
+/// Import operation summary.
+///
+/// Contains information about the block that just got imported,
+/// including storage changes, reorged blocks, etc.
+pub struct ImportSummary<Block: BlockT> {
+	/// Block hash of the imported block.
+	pub hash: Block::Hash,
+	/// Import origin.
+	pub origin: BlockOrigin,
+	/// Header of the imported block.
+	pub header: Block::Header,
+	/// Is this block a new best block.
+	pub is_new_best: bool,
+	/// Optional storage changes.
+	pub storage_changes: Option<(StorageCollection, ChildStorageCollection)>,
+	/// Tree route from old best to new best.
+	///
+	/// If `None`, there was no re-org while importing.
+	pub tree_route: Option<sp_blockchain::TreeRoute<Block>>,
+	/// What notify action to take for this import.
+	pub import_notification_action: ImportNotificationAction,
+}
+
+/// Finalization operation summary.
+///
+/// Contains information about the block that just got finalized,
+/// including tree heads that became stale at the moment of finalization.
+pub struct FinalizeSummary<Block: BlockT> {
+	/// Last finalized block header.
+	pub header: Block::Header,
+	/// Blocks that were finalized.
+	/// The last entry is the one that has been explicitly finalized.
+	pub finalized: Vec<Block::Hash>,
+	/// Heads that became stale during this finalization operation.
+	pub stale_heads: Vec<Block::Hash>,
+}
+
+/// Import operation wrapper.
+pub struct ClientImportOperation<Block: BlockT, B: Backend<Block>> {
+	/// DB Operation.
+	pub op: B::BlockImportOperation,
+	/// Summary of imported block.
+	pub notify_imported: Option<ImportSummary<Block>>,
+	/// Summary of finalized block.
+	pub notify_finalized: Option<FinalizeSummary<Block>>,
+}
+
+/// Helper function to apply auxiliary data insertion into an operation.
+pub fn apply_aux<'a, 'b: 'a, 'c: 'a, B, Block, D, I>(
+	operation: &mut ClientImportOperation<Block, B>,
+	insert: I,
+	delete: D,
+) -> sp_blockchain::Result<()>
+where
+	Block: BlockT,
+	B: Backend<Block>,
+	I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+	D: IntoIterator<Item = &'a &'b [u8]>,
+{
+	operation.op.insert_aux(
+		insert
+			.into_iter()
+			.map(|(k, v)| (k.to_vec(), Some(v.to_vec())))
+			.chain(delete.into_iter().map(|k| (k.to_vec(), None))),
+	)
+}
+
+/// State of a new block.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NewBlockState {
+	/// Normal block.
+	Normal,
+	/// New best block.
+	Best,
+	/// Newly finalized block (implicitly best).
+	Final,
+}
+
+impl NewBlockState {
+	/// Whether this block is the new best block.
+	pub fn is_best(self) -> bool {
+		match self {
+			NewBlockState::Best | NewBlockState::Final => true,
+			NewBlockState::Normal => false,
+		}
+	}
+
+	/// Whether this block is considered final.
+	pub fn is_final(self) -> bool {
+		match self {
+			NewBlockState::Final => true,
+			NewBlockState::Best | NewBlockState::Normal => false,
+		}
+	}
+}
+
+/// Block insertion operation.
+///
+/// Keeps hold if the inserted block state and data.
+pub trait BlockImportOperation<Block: BlockT> {
+	/// Associated state backend type.
+	type State: StateBackend<HashingFor<Block>>;
+
+	/// Returns pending state.
+	///
+	/// Returns None for backends with locally-unavailable state data.
+	fn state(&self) -> sp_blockchain::Result<Option<&Self::State>>;
+
+	/// Append block data to the transaction.
+	fn set_block_data(
+		&mut self,
+		header: Block::Header,
+		body: Option<Vec<Block::Extrinsic>>,
+		indexed_body: Option<Vec<Vec<u8>>>,
+		justifications: Option<Justifications>,
+		state: NewBlockState,
+	) -> sp_blockchain::Result<()>;
+
+	/// Inject storage data into the database.
+	fn update_db_storage(
+		&mut self,
+		update: BackendTransaction<HashingFor<Block>>,
+	) -> sp_blockchain::Result<()>;
+
+	/// Set genesis state. If `commit` is `false` the state is saved in memory, but is not written
+	/// to the database.
+	fn set_genesis_state(
+		&mut self,
+		storage: Storage,
+		commit: bool,
+		state_version: StateVersion,
+	) -> sp_blockchain::Result<Block::Hash>;
+
+	/// Inject storage data into the database replacing any existing data.
+	fn reset_storage(
+		&mut self,
+		storage: Storage,
+		state_version: StateVersion,
+	) -> sp_blockchain::Result<Block::Hash>;
+
+	/// Set storage changes.
+	fn update_storage(
+		&mut self,
+		update: StorageCollection,
+		child_update: ChildStorageCollection,
+	) -> sp_blockchain::Result<()>;
+
+	/// Write offchain storage changes to the database.
+	fn update_offchain_storage(
+		&mut self,
+		_offchain_update: OffchainChangesCollection,
+	) -> sp_blockchain::Result<()> {
+		Ok(())
+	}
+
+	/// Insert auxiliary keys.
+	///
+	/// Values are `None` if should be deleted.
+	fn insert_aux<I>(&mut self, ops: I) -> sp_blockchain::Result<()>
+	where
+		I: IntoIterator<Item = (Vec<u8>, Option<Vec<u8>>)>;
+
+	/// Mark a block as finalized.
+	fn mark_finalized(
+		&mut self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+	) -> sp_blockchain::Result<()>;
+
+	/// Mark a block as new head. If both block import and set head are specified, set head
+	/// overrides block import's best block rule.
+	fn mark_head(&mut self, hash: Block::Hash) -> sp_blockchain::Result<()>;
+
+	/// Add a transaction index operation.
+	fn update_transaction_index(&mut self, index: Vec<IndexOperation>)
+		-> sp_blockchain::Result<()>;
+}
+
+/// Interface for performing operations on the backend.
+pub trait LockImportRun<Block: BlockT, B: Backend<Block>> {
+	/// Lock the import lock, and run operations inside.
+	fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err>
+	where
+		F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>,
+		Err: From<sp_blockchain::Error>;
+}
+
+/// Finalize Facilities
+pub trait Finalizer<Block: BlockT, B: Backend<Block>> {
+	/// Mark all blocks up to given as finalized in operation.
+	///
+	/// If `justification` is provided it is stored with the given finalized
+	/// block (any other finalized blocks are left unjustified).
+	///
+	/// If the block being finalized is on a different fork from the current
+	/// best block the finalized block is set as best, this might be slightly
+	/// inaccurate (i.e. outdated). Usages that require determining an accurate
+	/// best block should use `SelectChain` instead of the client.
+	fn apply_finality(
+		&self,
+		operation: &mut ClientImportOperation<Block, B>,
+		block: Block::Hash,
+		justification: Option<Justification>,
+		notify: bool,
+	) -> sp_blockchain::Result<()>;
+
+	/// Finalize a block.
+	///
+	/// This will implicitly finalize all blocks up to it and
+	/// fire finality notifications.
+	///
+	/// If the block being finalized is on a different fork from the current
+	/// best block, the finalized block is set as best. This might be slightly
+	/// inaccurate (i.e. outdated). Usages that require determining an accurate
+	/// best block should use `SelectChain` instead of the client.
+	///
+	/// Pass a flag to indicate whether finality notifications should be propagated.
+	/// This is usually tied to some synchronization state, where we don't send notifications
+	/// while performing major synchronization work.
+	fn finalize_block(
+		&self,
+		block: Block::Hash,
+		justification: Option<Justification>,
+		notify: bool,
+	) -> sp_blockchain::Result<()>;
+}
+
+/// Provides access to an auxiliary database.
+///
+/// This is a simple global database not aware of forks. Can be used for storing auxiliary
+/// information like total block weight/difficulty for fork resolution purposes as a common use
+/// case.
+pub trait AuxStore {
+	/// Insert auxiliary data into key-value store.
+	///
+	/// Deletions occur after insertions.
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item = &'a &'b [u8]>,
+	>(
+		&self,
+		insert: I,
+		delete: D,
+	) -> sp_blockchain::Result<()>;
+
+	/// Query auxiliary data from key-value store.
+	fn get_aux(&self, key: &[u8]) -> sp_blockchain::Result<Option<Vec<u8>>>;
+}
+
+/// An `Iterator` that iterates keys in a given block under a prefix.
+pub struct KeysIter<State, Block>
+where
+	State: StateBackend<HashingFor<Block>>,
+	Block: BlockT,
+{
+	inner: <State as StateBackend<HashingFor<Block>>>::RawIter,
+	state: State,
+}
+
+impl<State, Block> KeysIter<State, Block>
+where
+	State: StateBackend<HashingFor<Block>>,
+	Block: BlockT,
+{
+	/// Create a new iterator over storage keys.
+	pub fn new(
+		state: State,
+		prefix: Option<&StorageKey>,
+		start_at: Option<&StorageKey>,
+	) -> Result<Self, State::Error> {
+		let mut args = IterArgs::default();
+		args.prefix = prefix.as_ref().map(|prefix| prefix.0.as_slice());
+		args.start_at = start_at.as_ref().map(|start_at| start_at.0.as_slice());
+		args.start_at_exclusive = true;
+
+		Ok(Self { inner: state.raw_iter(args)?, state })
+	}
+
+	/// Create a new iterator over a child storage's keys.
+	pub fn new_child(
+		state: State,
+		child_info: ChildInfo,
+		prefix: Option<&StorageKey>,
+		start_at: Option<&StorageKey>,
+	) -> Result<Self, State::Error> {
+		let mut args = IterArgs::default();
+		args.prefix = prefix.as_ref().map(|prefix| prefix.0.as_slice());
+		args.start_at = start_at.as_ref().map(|start_at| start_at.0.as_slice());
+		args.child_info = Some(child_info);
+		args.start_at_exclusive = true;
+
+		Ok(Self { inner: state.raw_iter(args)?, state })
+	}
+}
+
+impl<State, Block> Iterator for KeysIter<State, Block>
+where
+	Block: BlockT,
+	State: StateBackend<HashingFor<Block>>,
+{
+	type Item = StorageKey;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.inner.next_key(&self.state)?.ok().map(StorageKey)
+	}
+}
+
+/// An `Iterator` that iterates keys and values in a given block under a prefix.
+pub struct PairsIter<State, Block>
+where
+	State: StateBackend<HashingFor<Block>>,
+	Block: BlockT,
+{
+	inner: <State as StateBackend<HashingFor<Block>>>::RawIter,
+	state: State,
+}
+
+impl<State, Block> Iterator for PairsIter<State, Block>
+where
+	Block: BlockT,
+	State: StateBackend<HashingFor<Block>>,
+{
+	type Item = (StorageKey, StorageData);
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.inner
+			.next_pair(&self.state)?
+			.ok()
+			.map(|(key, value)| (StorageKey(key), StorageData(value)))
+	}
+}
+
+impl<State, Block> PairsIter<State, Block>
+where
+	State: StateBackend<HashingFor<Block>>,
+	Block: BlockT,
+{
+	/// Create a new iterator over storage key and value pairs.
+	pub fn new(
+		state: State,
+		prefix: Option<&StorageKey>,
+		start_at: Option<&StorageKey>,
+	) -> Result<Self, State::Error> {
+		let mut args = IterArgs::default();
+		args.prefix = prefix.as_ref().map(|prefix| prefix.0.as_slice());
+		args.start_at = start_at.as_ref().map(|start_at| start_at.0.as_slice());
+		args.start_at_exclusive = true;
+
+		Ok(Self { inner: state.raw_iter(args)?, state })
+	}
+}
+
+/// Provides access to storage primitives
+pub trait StorageProvider<Block: BlockT, B: Backend<Block>> {
+	/// Given a block's `Hash` and a key, return the value under the key in that block.
+	fn storage(
+		&self,
+		hash: Block::Hash,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<StorageData>>;
+
+	/// Given a block's `Hash` and a key, return the value under the hash in that block.
+	fn storage_hash(
+		&self,
+		hash: Block::Hash,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<Block::Hash>>;
+
+	/// Given a block's `Hash` and a key prefix, returns a `KeysIter` iterates matching storage
+	/// keys in that block.
+	fn storage_keys(
+		&self,
+		hash: Block::Hash,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<KeysIter<B::State, Block>>;
+
+	/// Given a block's `Hash` and a key prefix, returns an iterator over the storage keys and
+	/// values in that block.
+	fn storage_pairs(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<PairsIter<B::State, Block>>;
+
+	/// Given a block's `Hash`, a key and a child storage key, return the value under the key in
+	/// that block.
+	fn child_storage(
+		&self,
+		hash: Block::Hash,
+		child_info: &ChildInfo,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<StorageData>>;
+
+	/// Given a block's `Hash` and a key `prefix` and a child storage key,
+	/// returns a `KeysIter` that iterates matching storage keys in that block.
+	fn child_storage_keys(
+		&self,
+		hash: Block::Hash,
+		child_info: ChildInfo,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<KeysIter<B::State, Block>>;
+
+	/// Given a block's `Hash`, a key and a child storage key, return the hash under the key in that
+	/// block.
+	fn child_storage_hash(
+		&self,
+		hash: Block::Hash,
+		child_info: &ChildInfo,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<Block::Hash>>;
+}
+
+/// Client backend.
+///
+/// Manages the data layer.
+///
+/// # State Pruning
+///
+/// While an object from `state_at` is alive, the state
+/// should not be pruned. The backend should internally reference-count
+/// its state objects.
+///
+/// The same applies for live `BlockImportOperation`s: while an import operation building on a
+/// parent `P` is alive, the state for `P` should not be pruned.
+///
+/// # Block Pruning
+///
+/// Users can pin blocks in memory by calling `pin_block`. When
+/// a block would be pruned, its value is kept in an in-memory cache
+/// until it is unpinned via `unpin_block`.
+///
+/// While a block is pinned, its state is also preserved.
+///
+/// The backend should internally reference count the number of pin / unpin calls.
+pub trait Backend<Block: BlockT>: AuxStore + Send + Sync {
+	/// Associated block insertion operation type.
+	type BlockImportOperation: BlockImportOperation<Block, State = Self::State>;
+	/// Associated blockchain backend type.
+	type Blockchain: BlockchainBackend<Block>;
+	/// Associated state backend type.
+	type State: StateBackend<HashingFor<Block>>
+		+ Send
+		+ AsTrieBackend<
+			HashingFor<Block>,
+			TrieBackendStorage = <Self::State as StateBackend<HashingFor<Block>>>::TrieBackendStorage,
+		>;
+	/// Offchain workers local storage.
+	type OffchainStorage: OffchainStorage;
+
+	/// Begin a new block insertion transaction with given parent block id.
+	///
+	/// When constructing the genesis, this is called with all-zero hash.
+	fn begin_operation(&self) -> sp_blockchain::Result<Self::BlockImportOperation>;
+
+	/// Note an operation to contain state transition.
+	fn begin_state_operation(
+		&self,
+		operation: &mut Self::BlockImportOperation,
+		block: Block::Hash,
+	) -> sp_blockchain::Result<()>;
+
+	/// Commit block insertion.
+	fn commit_operation(
+		&self,
+		transaction: Self::BlockImportOperation,
+	) -> sp_blockchain::Result<()>;
+
+	/// Finalize block with given `hash`.
+	///
+	/// This should only be called if the parent of the given block has been finalized.
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+	) -> sp_blockchain::Result<()>;
+
+	/// Append justification to the block with the given `hash`.
+	///
+	/// This should only be called for blocks that are already finalized.
+	fn append_justification(
+		&self,
+		hash: Block::Hash,
+		justification: Justification,
+	) -> sp_blockchain::Result<()>;
+
+	/// Returns reference to blockchain backend.
+	fn blockchain(&self) -> &Self::Blockchain;
+
+	/// Returns current usage statistics.
+	fn usage_info(&self) -> Option<UsageInfo>;
+
+	/// Returns a handle to offchain storage.
+	fn offchain_storage(&self) -> Option<Self::OffchainStorage>;
+
+	/// Pin the block to keep body, justification and state available after pruning.
+	/// Number of pins are reference counted. Users need to make sure to perform
+	/// one call to [`Self::unpin_block`] per call to [`Self::pin_block`].
+	fn pin_block(&self, hash: Block::Hash) -> sp_blockchain::Result<()>;
+
+	/// Unpin the block to allow pruning.
+	fn unpin_block(&self, hash: Block::Hash);
+
+	/// Returns true if state for given block is available.
+	fn have_state_at(&self, hash: Block::Hash, _number: NumberFor<Block>) -> bool {
+		self.state_at(hash).is_ok()
+	}
+
+	/// Returns state backend with post-state of given block.
+	fn state_at(&self, hash: Block::Hash) -> sp_blockchain::Result<Self::State>;
+
+	/// Attempts to revert the chain by `n` blocks. If `revert_finalized` is set it will attempt to
+	/// revert past any finalized block, this is unsafe and can potentially leave the node in an
+	/// inconsistent state. All blocks higher than the best block are also reverted and not counting
+	/// towards `n`.
+	///
+	/// Returns the number of blocks that were successfully reverted and the list of finalized
+	/// blocks that has been reverted.
+	fn revert(
+		&self,
+		n: NumberFor<Block>,
+		revert_finalized: bool,
+	) -> sp_blockchain::Result<(NumberFor<Block>, HashSet<Block::Hash>)>;
+
+	/// Discard non-best, unfinalized leaf block.
+	fn remove_leaf_block(&self, hash: Block::Hash) -> sp_blockchain::Result<()>;
+
+	/// Insert auxiliary data into key-value store.
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item = &'a &'b [u8]>,
+	>(
+		&self,
+		insert: I,
+		delete: D,
+	) -> sp_blockchain::Result<()> {
+		AuxStore::insert_aux(self, insert, delete)
+	}
+	/// Query auxiliary data from key-value store.
+	fn get_aux(&self, key: &[u8]) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		AuxStore::get_aux(self, key)
+	}
+
+	/// Gain access to the import lock around this backend.
+	///
+	/// _Note_ Backend isn't expected to acquire the lock by itself ever. Rather
+	/// the using components should acquire and hold the lock whenever they do
+	/// something that the import of a block would interfere with, e.g. importing
+	/// a new block or calculating the best head.
+	fn get_import_lock(&self) -> &RwLock<()>;
+
+	/// Tells whether the backend requires full-sync mode.
+	fn requires_full_sync(&self) -> bool;
+}
+
+/// Mark for all Backend implementations, that are making use of state data, stored locally.
+pub trait LocalBackend<Block: BlockT>: Backend<Block> {}
diff --git a/substrate/client/api/src/call_executor.rs b/substrate/client/api/src/call_executor.rs
new file mode 100644
index 0000000000000000000000000000000000000000..49b51ccc943edab005390a0726426f106e55b458
--- /dev/null
+++ b/substrate/client/api/src/call_executor.rs
@@ -0,0 +1,95 @@
+// 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/>.
+
+//! A method call executor interface.
+
+use sc_executor::{RuntimeVersion, RuntimeVersionOf};
+use sp_core::traits::CallContext;
+use sp_externalities::Extensions;
+use sp_runtime::traits::Block as BlockT;
+use sp_state_machine::{OverlayedChanges, StorageProof};
+use std::cell::RefCell;
+
+use crate::execution_extensions::ExecutionExtensions;
+use sp_api::{HashingFor, ProofRecorder};
+
+/// Executor Provider
+pub trait ExecutorProvider<Block: BlockT> {
+	/// executor instance
+	type Executor: CallExecutor<Block>;
+
+	/// Get call executor reference.
+	fn executor(&self) -> &Self::Executor;
+
+	/// Get a reference to the execution extensions.
+	fn execution_extensions(&self) -> &ExecutionExtensions<Block>;
+}
+
+/// Method call executor.
+pub trait CallExecutor<B: BlockT>: RuntimeVersionOf {
+	/// Externalities error type.
+	type Error: sp_state_machine::Error;
+
+	/// The backend used by the node.
+	type Backend: crate::backend::Backend<B>;
+
+	/// Returns the [`ExecutionExtensions`].
+	fn execution_extensions(&self) -> &ExecutionExtensions<B>;
+
+	/// Execute a call to a contract on top of state in a block of given hash.
+	///
+	/// No changes are made.
+	fn call(
+		&self,
+		at_hash: B::Hash,
+		method: &str,
+		call_data: &[u8],
+		context: CallContext,
+	) -> Result<Vec<u8>, sp_blockchain::Error>;
+
+	/// Execute a contextual call on top of state in a block of a given hash.
+	///
+	/// No changes are made.
+	/// Before executing the method, passed header is installed as the current header
+	/// of the execution context.
+	fn contextual_call(
+		&self,
+		at_hash: B::Hash,
+		method: &str,
+		call_data: &[u8],
+		changes: &RefCell<OverlayedChanges<HashingFor<B>>>,
+		proof_recorder: &Option<ProofRecorder<B>>,
+		call_context: CallContext,
+		extensions: &RefCell<Extensions>,
+	) -> sp_blockchain::Result<Vec<u8>>;
+
+	/// Extract RuntimeVersion of given block
+	///
+	/// No changes are made.
+	fn runtime_version(&self, at_hash: B::Hash) -> Result<RuntimeVersion, sp_blockchain::Error>;
+
+	/// Prove the execution of the given `method`.
+	///
+	/// No changes are made.
+	fn prove_execution(
+		&self,
+		at_hash: B::Hash,
+		method: &str,
+		call_data: &[u8],
+	) -> Result<(Vec<u8>, StorageProof), sp_blockchain::Error>;
+}
diff --git a/substrate/client/api/src/client.rs b/substrate/client/api/src/client.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e334f2f9fb4f68aa55cb7ebcd7440f9462342fb9
--- /dev/null
+++ b/substrate/client/api/src/client.rs
@@ -0,0 +1,442 @@
+// 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/>.
+
+//! A set of APIs supported by the client along with their primitives.
+
+use sp_consensus::BlockOrigin;
+use sp_core::storage::StorageKey;
+use sp_runtime::{
+	generic::SignedBlock,
+	traits::{Block as BlockT, NumberFor},
+	Justifications,
+};
+use std::{collections::HashSet, fmt, sync::Arc};
+
+use crate::{blockchain::Info, notifications::StorageEventStream, FinalizeSummary, ImportSummary};
+
+use sc_transaction_pool_api::ChainEvent;
+use sc_utils::mpsc::{TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_blockchain;
+
+/// Type that implements `futures::Stream` of block import events.
+pub type ImportNotifications<Block> = TracingUnboundedReceiver<BlockImportNotification<Block>>;
+
+/// A stream of block finality notifications.
+pub type FinalityNotifications<Block> = TracingUnboundedReceiver<FinalityNotification<Block>>;
+
+/// Expected hashes of blocks at given heights.
+///
+/// This may be used as chain spec extension to set trusted checkpoints, i.e.
+/// the client will refuse to import a block with a different hash at the given
+/// height.
+pub type ForkBlocks<Block> = Option<Vec<(NumberFor<Block>, <Block as BlockT>::Hash)>>;
+
+/// Known bad block hashes.
+///
+/// This may be used as chain spec extension to filter out known, unwanted forks.
+pub type BadBlocks<Block> = Option<HashSet<<Block as BlockT>::Hash>>;
+
+/// Figure out the block type for a given type (for now, just a `Client`).
+pub trait BlockOf {
+	/// The type of the block.
+	type Type: BlockT;
+}
+
+/// A source of blockchain events.
+pub trait BlockchainEvents<Block: BlockT> {
+	/// Get block import event stream.
+	///
+	/// Not guaranteed to be fired for every imported block, only fired when the node
+	/// has synced to the tip or there is a re-org. Use `every_import_notification_stream()`
+	/// if you want a notification of every imported block regardless.
+	fn import_notification_stream(&self) -> ImportNotifications<Block>;
+
+	/// Get a stream of every imported block.
+	fn every_import_notification_stream(&self) -> ImportNotifications<Block>;
+
+	/// Get a stream of finality notifications. Not guaranteed to be fired for every
+	/// finalized block.
+	fn finality_notification_stream(&self) -> FinalityNotifications<Block>;
+
+	/// Get storage changes event stream.
+	///
+	/// Passing `None` as `filter_keys` subscribes to all storage changes.
+	fn storage_changes_notification_stream(
+		&self,
+		filter_keys: Option<&[StorageKey]>,
+		child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+	) -> sp_blockchain::Result<StorageEventStream<Block::Hash>>;
+}
+
+/// List of operations to be performed on storage aux data.
+/// First tuple element is the encoded data key.
+/// Second tuple element is the encoded optional data to write.
+/// If `None`, the key and the associated data are deleted from storage.
+pub type AuxDataOperations = Vec<(Vec<u8>, Option<Vec<u8>>)>;
+
+/// Callback invoked before committing the operations created during block import.
+/// This gives the opportunity to perform auxiliary pre-commit actions and optionally
+/// enqueue further storage write operations to be atomically performed on commit.
+pub type OnImportAction<Block> =
+	Box<dyn (Fn(&BlockImportNotification<Block>) -> AuxDataOperations) + Send>;
+
+/// Callback invoked before committing the operations created during block finalization.
+/// This gives the opportunity to perform auxiliary pre-commit actions and optionally
+/// enqueue further storage write operations to be atomically performed on commit.
+pub type OnFinalityAction<Block> =
+	Box<dyn (Fn(&FinalityNotification<Block>) -> AuxDataOperations) + Send>;
+
+/// Interface to perform auxiliary actions before committing a block import or
+/// finality operation.
+pub trait PreCommitActions<Block: BlockT> {
+	/// Actions to be performed on block import.
+	fn register_import_action(&self, op: OnImportAction<Block>);
+
+	/// Actions to be performed on block finalization.
+	fn register_finality_action(&self, op: OnFinalityAction<Block>);
+}
+
+/// Interface for fetching block data.
+pub trait BlockBackend<Block: BlockT> {
+	/// Get block body by ID. Returns `None` if the body is not stored.
+	fn block_body(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>>;
+
+	/// Get all indexed transactions for a block,
+	/// including renewed transactions.
+	///
+	/// Note that this will only fetch transactions
+	/// that are indexed by the runtime with `storage_index_transaction`.
+	fn block_indexed_body(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>>;
+
+	/// Get full block by hash.
+	fn block(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<SignedBlock<Block>>>;
+
+	/// Get block status by block hash.
+	fn block_status(&self, hash: Block::Hash) -> sp_blockchain::Result<sp_consensus::BlockStatus>;
+
+	/// Get block justifications for the block with the given hash.
+	fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Justifications>>;
+
+	/// Get block hash by number.
+	fn block_hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>>;
+
+	/// Get single indexed transaction by content hash.
+	///
+	/// Note that this will only fetch transactions
+	/// that are indexed by the runtime with `storage_index_transaction`.
+	fn indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>>;
+
+	/// Check if transaction index exists.
+	fn has_indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<bool> {
+		Ok(self.indexed_transaction(hash)?.is_some())
+	}
+
+	/// Tells whether the current client configuration requires full-sync mode.
+	fn requires_full_sync(&self) -> bool;
+}
+
+/// Provide a list of potential uncle headers for a given block.
+pub trait ProvideUncles<Block: BlockT> {
+	/// Gets the uncles of the block with `target_hash` going back `max_generation` ancestors.
+	fn uncles(
+		&self,
+		target_hash: Block::Hash,
+		max_generation: NumberFor<Block>,
+	) -> sp_blockchain::Result<Vec<Block::Header>>;
+}
+
+/// Client info
+#[derive(Debug)]
+pub struct ClientInfo<Block: BlockT> {
+	/// Best block hash.
+	pub chain: Info<Block>,
+	/// Usage info, if backend supports this.
+	pub usage: Option<UsageInfo>,
+}
+
+/// A wrapper to store the size of some memory.
+#[derive(Default, Clone, Debug, Copy)]
+pub struct MemorySize(usize);
+
+impl MemorySize {
+	/// Creates `Self` from the given `bytes` size.
+	pub fn from_bytes(bytes: usize) -> Self {
+		Self(bytes)
+	}
+
+	/// Returns the memory size as bytes.
+	pub fn as_bytes(self) -> usize {
+		self.0
+	}
+}
+
+impl fmt::Display for MemorySize {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		if self.0 < 1024 {
+			write!(f, "{} bytes", self.0)
+		} else if self.0 < 1024 * 1024 {
+			write!(f, "{:.2} KiB", self.0 as f64 / 1024f64)
+		} else if self.0 < 1024 * 1024 * 1024 {
+			write!(f, "{:.2} MiB", self.0 as f64 / (1024f64 * 1024f64))
+		} else {
+			write!(f, "{:.2} GiB", self.0 as f64 / (1024f64 * 1024f64 * 1024f64))
+		}
+	}
+}
+
+/// Memory statistics for client instance.
+#[derive(Default, Clone, Debug)]
+pub struct MemoryInfo {
+	/// Size of state cache.
+	pub state_cache: MemorySize,
+	/// Size of backend database cache.
+	pub database_cache: MemorySize,
+}
+
+/// I/O statistics for client instance.
+#[derive(Default, Clone, Debug)]
+pub struct IoInfo {
+	/// Number of transactions.
+	pub transactions: u64,
+	/// Total bytes read from disk.
+	pub bytes_read: u64,
+	/// Total bytes written to disk.
+	pub bytes_written: u64,
+	/// Total key writes to disk.
+	pub writes: u64,
+	/// Total key reads from disk.
+	pub reads: u64,
+	/// Average size of the transaction.
+	pub average_transaction_size: u64,
+	/// State reads (keys)
+	pub state_reads: u64,
+	/// State reads (keys) from cache.
+	pub state_reads_cache: u64,
+	/// State reads (keys)
+	pub state_writes: u64,
+	/// State write (keys) already cached.
+	pub state_writes_cache: u64,
+	/// State write (trie nodes) to backend db.
+	pub state_writes_nodes: u64,
+}
+
+/// Usage statistics for running client instance.
+///
+/// Returning backend determines the scope of these stats,
+/// but usually it is either from service start or from previous
+/// gathering of the statistics.
+#[derive(Default, Clone, Debug)]
+pub struct UsageInfo {
+	/// Memory statistics.
+	pub memory: MemoryInfo,
+	/// I/O statistics.
+	pub io: IoInfo,
+}
+
+impl fmt::Display for UsageInfo {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(
+			f,
+			"caches: ({} state, {} db overlay), \
+			 i/o: ({} tx, {} write, {} read, {} avg tx, {}/{} key cache reads/total, {} trie nodes writes)",
+			self.memory.state_cache,
+			self.memory.database_cache,
+			self.io.transactions,
+			self.io.bytes_written,
+			self.io.bytes_read,
+			self.io.average_transaction_size,
+			self.io.state_reads_cache,
+			self.io.state_reads,
+			self.io.state_writes_nodes,
+		)
+	}
+}
+
+/// Sends a message to the pinning-worker once dropped to unpin a block in the backend.
+#[derive(Debug)]
+pub struct UnpinHandleInner<Block: BlockT> {
+	/// Hash of the block pinned by this handle
+	hash: Block::Hash,
+	unpin_worker_sender: TracingUnboundedSender<Block::Hash>,
+}
+
+impl<Block: BlockT> UnpinHandleInner<Block> {
+	/// Create a new [`UnpinHandleInner`]
+	pub fn new(
+		hash: Block::Hash,
+		unpin_worker_sender: TracingUnboundedSender<Block::Hash>,
+	) -> Self {
+		Self { hash, unpin_worker_sender }
+	}
+}
+
+impl<Block: BlockT> Drop for UnpinHandleInner<Block> {
+	fn drop(&mut self) {
+		if let Err(err) = self.unpin_worker_sender.unbounded_send(self.hash) {
+			log::debug!(target: "db", "Unable to unpin block with hash: {}, error: {:?}", self.hash, err);
+		};
+	}
+}
+
+/// Keeps a specific block pinned while the handle is alive.
+/// Once the last handle instance for a given block is dropped, the
+/// block is unpinned in the [`Backend`](crate::backend::Backend::unpin_block).
+#[derive(Debug, Clone)]
+pub struct UnpinHandle<Block: BlockT>(Arc<UnpinHandleInner<Block>>);
+
+impl<Block: BlockT> UnpinHandle<Block> {
+	/// Create a new [`UnpinHandle`]
+	pub fn new(
+		hash: Block::Hash,
+		unpin_worker_sender: TracingUnboundedSender<Block::Hash>,
+	) -> UnpinHandle<Block> {
+		UnpinHandle(Arc::new(UnpinHandleInner::new(hash, unpin_worker_sender)))
+	}
+
+	/// Hash of the block this handle is unpinning on drop
+	pub fn hash(&self) -> Block::Hash {
+		self.0.hash
+	}
+}
+
+/// Summary of an imported block
+#[derive(Clone, Debug)]
+pub struct BlockImportNotification<Block: BlockT> {
+	/// Imported block header hash.
+	pub hash: Block::Hash,
+	/// Imported block origin.
+	pub origin: BlockOrigin,
+	/// Imported block header.
+	pub header: Block::Header,
+	/// Is this the new best block.
+	pub is_new_best: bool,
+	/// Tree route from old best to new best parent.
+	///
+	/// If `None`, there was no re-org while importing.
+	pub tree_route: Option<Arc<sp_blockchain::TreeRoute<Block>>>,
+	/// Handle to unpin the block this notification is for
+	unpin_handle: UnpinHandle<Block>,
+}
+
+impl<Block: BlockT> BlockImportNotification<Block> {
+	/// Create new notification
+	pub fn new(
+		hash: Block::Hash,
+		origin: BlockOrigin,
+		header: Block::Header,
+		is_new_best: bool,
+		tree_route: Option<Arc<sp_blockchain::TreeRoute<Block>>>,
+		unpin_worker_sender: TracingUnboundedSender<Block::Hash>,
+	) -> Self {
+		Self {
+			hash,
+			origin,
+			header,
+			is_new_best,
+			tree_route,
+			unpin_handle: UnpinHandle::new(hash, unpin_worker_sender),
+		}
+	}
+
+	/// Consume this notification and extract the unpin handle.
+	///
+	/// Note: Only use this if you want to keep the block pinned in the backend.
+	pub fn into_unpin_handle(self) -> UnpinHandle<Block> {
+		self.unpin_handle
+	}
+}
+
+/// Summary of a finalized block.
+#[derive(Clone, Debug)]
+pub struct FinalityNotification<Block: BlockT> {
+	/// Finalized block header hash.
+	pub hash: Block::Hash,
+	/// Finalized block header.
+	pub header: Block::Header,
+	/// Path from the old finalized to new finalized parent (implicitly finalized blocks).
+	///
+	/// This maps to the range `(old_finalized, new_finalized)`.
+	pub tree_route: Arc<[Block::Hash]>,
+	/// Stale branches heads.
+	pub stale_heads: Arc<[Block::Hash]>,
+	/// Handle to unpin the block this notification is for
+	unpin_handle: UnpinHandle<Block>,
+}
+
+impl<B: BlockT> TryFrom<BlockImportNotification<B>> for ChainEvent<B> {
+	type Error = ();
+
+	fn try_from(n: BlockImportNotification<B>) -> Result<Self, ()> {
+		if n.is_new_best {
+			Ok(Self::NewBestBlock { hash: n.hash, tree_route: n.tree_route })
+		} else {
+			Err(())
+		}
+	}
+}
+
+impl<B: BlockT> From<FinalityNotification<B>> for ChainEvent<B> {
+	fn from(n: FinalityNotification<B>) -> Self {
+		Self::Finalized { hash: n.hash, tree_route: n.tree_route }
+	}
+}
+
+impl<Block: BlockT> FinalityNotification<Block> {
+	/// Create finality notification from finality summary.
+	pub fn from_summary(
+		mut summary: FinalizeSummary<Block>,
+		unpin_worker_sender: TracingUnboundedSender<Block::Hash>,
+	) -> FinalityNotification<Block> {
+		let hash = summary.finalized.pop().unwrap_or_default();
+		FinalityNotification {
+			hash,
+			header: summary.header,
+			tree_route: Arc::from(summary.finalized),
+			stale_heads: Arc::from(summary.stale_heads),
+			unpin_handle: UnpinHandle::new(hash, unpin_worker_sender),
+		}
+	}
+
+	/// Consume this notification and extract the unpin handle.
+	///
+	/// Note: Only use this if you want to keep the block pinned in the backend.
+	pub fn into_unpin_handle(self) -> UnpinHandle<Block> {
+		self.unpin_handle
+	}
+}
+
+impl<Block: BlockT> BlockImportNotification<Block> {
+	/// Create finality notification from finality summary.
+	pub fn from_summary(
+		summary: ImportSummary<Block>,
+		unpin_worker_sender: TracingUnboundedSender<Block::Hash>,
+	) -> BlockImportNotification<Block> {
+		let hash = summary.hash;
+		BlockImportNotification {
+			hash,
+			origin: summary.origin,
+			header: summary.header,
+			is_new_best: summary.is_new_best,
+			tree_route: summary.tree_route.map(Arc::new),
+			unpin_handle: UnpinHandle::new(hash, unpin_worker_sender),
+		}
+	}
+}
diff --git a/substrate/client/api/src/execution_extensions.rs b/substrate/client/api/src/execution_extensions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f927105df0bf46927356e4b897c72c4d5e0e19b
--- /dev/null
+++ b/substrate/client/api/src/execution_extensions.rs
@@ -0,0 +1,133 @@
+// 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/>.
+
+//! Execution extensions for runtime calls.
+//!
+//! This module is responsible for defining the execution
+//! strategy for the runtime calls and provide the right `Externalities`
+//! extensions to support APIs for particular execution context & capabilities.
+
+use parking_lot::RwLock;
+use sp_core::traits::{ReadRuntimeVersion, ReadRuntimeVersionExt};
+use sp_externalities::{Extension, Extensions};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::{marker::PhantomData, sync::Arc};
+
+/// Generate the starting set of [`Extensions`].
+///
+/// These [`Extensions`] are passed to the environment a runtime is executed in.
+pub trait ExtensionsFactory<Block: BlockT>: Send + Sync {
+	/// Create [`Extensions`] for the given input.
+	///
+	/// - `block_hash`: The hash of the block in the context that extensions will be used.
+	/// - `block_number`: The number of the block in the context that extensions will be used.
+	fn extensions_for(&self, block_hash: Block::Hash, block_number: NumberFor<Block>)
+		-> Extensions;
+}
+
+impl<Block: BlockT> ExtensionsFactory<Block> for () {
+	fn extensions_for(&self, _: Block::Hash, _: NumberFor<Block>) -> Extensions {
+		Extensions::new()
+	}
+}
+
+impl<Block: BlockT, T: ExtensionsFactory<Block>> ExtensionsFactory<Block> for Vec<T> {
+	fn extensions_for(
+		&self,
+		block_hash: Block::Hash,
+		block_number: NumberFor<Block>,
+	) -> Extensions {
+		let mut exts = Extensions::new();
+		exts.extend(self.iter().map(|e| e.extensions_for(block_hash, block_number)));
+		exts
+	}
+}
+
+/// An [`ExtensionsFactory`] that registers an [`Extension`] before a certain block.
+pub struct ExtensionBeforeBlock<Block: BlockT, Ext> {
+	before: NumberFor<Block>,
+	_marker: PhantomData<fn(Ext) -> Ext>,
+}
+
+impl<Block: BlockT, Ext> ExtensionBeforeBlock<Block, Ext> {
+	/// Create the extension factory.
+	///
+	/// - `before`: The block number until the extension should be registered.
+	pub fn new(before: NumberFor<Block>) -> Self {
+		Self { before, _marker: PhantomData }
+	}
+}
+
+impl<Block: BlockT, Ext: Default + Extension> ExtensionsFactory<Block>
+	for ExtensionBeforeBlock<Block, Ext>
+{
+	fn extensions_for(&self, _: Block::Hash, block_number: NumberFor<Block>) -> Extensions {
+		let mut exts = Extensions::new();
+
+		if block_number < self.before {
+			exts.register(Ext::default());
+		}
+
+		exts
+	}
+}
+
+/// A producer of execution extensions for offchain calls.
+///
+/// This crate aggregates extensions available for the offchain calls
+/// and is responsible for producing a correct `Extensions` object.
+/// for each call, based on required `Capabilities`.
+pub struct ExecutionExtensions<Block: BlockT> {
+	extensions_factory: RwLock<Box<dyn ExtensionsFactory<Block>>>,
+	read_runtime_version: Arc<dyn ReadRuntimeVersion>,
+}
+
+impl<Block: BlockT> ExecutionExtensions<Block> {
+	/// Create new `ExecutionExtensions` given an `extensions_factory`.
+	pub fn new(
+		extensions_factory: Option<Box<dyn ExtensionsFactory<Block>>>,
+		read_runtime_version: Arc<dyn ReadRuntimeVersion>,
+	) -> Self {
+		Self {
+			extensions_factory: extensions_factory
+				.map(RwLock::new)
+				.unwrap_or_else(|| RwLock::new(Box::new(()))),
+			read_runtime_version,
+		}
+	}
+
+	/// Set the new extensions_factory
+	pub fn set_extensions_factory(&self, maker: impl ExtensionsFactory<Block> + 'static) {
+		*self.extensions_factory.write() = Box::new(maker);
+	}
+
+	/// Based on the execution context and capabilities it produces
+	/// the extensions object to support desired set of APIs.
+	pub fn extensions(
+		&self,
+		block_hash: Block::Hash,
+		block_number: NumberFor<Block>,
+	) -> Extensions {
+		let mut extensions =
+			self.extensions_factory.read().extensions_for(block_hash, block_number);
+
+		extensions.register(ReadRuntimeVersionExt::new(self.read_runtime_version.clone()));
+
+		extensions
+	}
+}
diff --git a/substrate/client/api/src/in_mem.rs b/substrate/client/api/src/in_mem.rs
new file mode 100644
index 0000000000000000000000000000000000000000..807bdf0e334725eba64d99eb4edb88215436c073
--- /dev/null
+++ b/substrate/client/api/src/in_mem.rs
@@ -0,0 +1,883 @@
+// 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/>.
+
+//! In memory client backend
+
+use parking_lot::RwLock;
+use sp_blockchain::{CachedHeaderMetadata, HeaderMetadata};
+use sp_core::{
+	offchain::storage::InMemOffchainStorage as OffchainStorage, storage::well_known_keys,
+};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, HashingFor, Header as HeaderT, NumberFor, Zero},
+	Justification, Justifications, StateVersion, Storage,
+};
+use sp_state_machine::{
+	Backend as StateBackend, BackendTransaction, ChildStorageCollection, InMemoryBackend,
+	IndexOperation, StorageCollection,
+};
+use std::{
+	collections::{HashMap, HashSet},
+	ptr,
+	sync::Arc,
+};
+
+use crate::{
+	backend::{self, NewBlockState},
+	blockchain::{self, BlockStatus, HeaderBackend},
+	leaves::LeafSet,
+	UsageInfo,
+};
+
+struct PendingBlock<B: BlockT> {
+	block: StoredBlock<B>,
+	state: NewBlockState,
+}
+
+#[derive(PartialEq, Eq, Clone)]
+enum StoredBlock<B: BlockT> {
+	Header(B::Header, Option<Justifications>),
+	Full(B, Option<Justifications>),
+}
+
+impl<B: BlockT> StoredBlock<B> {
+	fn new(
+		header: B::Header,
+		body: Option<Vec<B::Extrinsic>>,
+		just: Option<Justifications>,
+	) -> Self {
+		match body {
+			Some(body) => StoredBlock::Full(B::new(header, body), just),
+			None => StoredBlock::Header(header, just),
+		}
+	}
+
+	fn header(&self) -> &B::Header {
+		match *self {
+			StoredBlock::Header(ref h, _) => h,
+			StoredBlock::Full(ref b, _) => b.header(),
+		}
+	}
+
+	fn justifications(&self) -> Option<&Justifications> {
+		match *self {
+			StoredBlock::Header(_, ref j) | StoredBlock::Full(_, ref j) => j.as_ref(),
+		}
+	}
+
+	fn extrinsics(&self) -> Option<&[B::Extrinsic]> {
+		match *self {
+			StoredBlock::Header(_, _) => None,
+			StoredBlock::Full(ref b, _) => Some(b.extrinsics()),
+		}
+	}
+
+	fn into_inner(self) -> (B::Header, Option<Vec<B::Extrinsic>>, Option<Justifications>) {
+		match self {
+			StoredBlock::Header(header, just) => (header, None, just),
+			StoredBlock::Full(block, just) => {
+				let (header, body) = block.deconstruct();
+				(header, Some(body), just)
+			},
+		}
+	}
+}
+
+#[derive(Clone)]
+struct BlockchainStorage<Block: BlockT> {
+	blocks: HashMap<Block::Hash, StoredBlock<Block>>,
+	hashes: HashMap<NumberFor<Block>, Block::Hash>,
+	best_hash: Block::Hash,
+	best_number: NumberFor<Block>,
+	finalized_hash: Block::Hash,
+	finalized_number: NumberFor<Block>,
+	genesis_hash: Block::Hash,
+	header_cht_roots: HashMap<NumberFor<Block>, Block::Hash>,
+	leaves: LeafSet<Block::Hash, NumberFor<Block>>,
+	aux: HashMap<Vec<u8>, Vec<u8>>,
+}
+
+/// In-memory blockchain. Supports concurrent reads.
+#[derive(Clone)]
+pub struct Blockchain<Block: BlockT> {
+	storage: Arc<RwLock<BlockchainStorage<Block>>>,
+}
+
+impl<Block: BlockT> Default for Blockchain<Block> {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+impl<Block: BlockT> Blockchain<Block> {
+	/// Get header hash of given block.
+	pub fn id(&self, id: BlockId<Block>) -> Option<Block::Hash> {
+		match id {
+			BlockId::Hash(h) => Some(h),
+			BlockId::Number(n) => self.storage.read().hashes.get(&n).cloned(),
+		}
+	}
+
+	/// Create new in-memory blockchain storage.
+	pub fn new() -> Blockchain<Block> {
+		let storage = Arc::new(RwLock::new(BlockchainStorage {
+			blocks: HashMap::new(),
+			hashes: HashMap::new(),
+			best_hash: Default::default(),
+			best_number: Zero::zero(),
+			finalized_hash: Default::default(),
+			finalized_number: Zero::zero(),
+			genesis_hash: Default::default(),
+			header_cht_roots: HashMap::new(),
+			leaves: LeafSet::new(),
+			aux: HashMap::new(),
+		}));
+		Blockchain { storage }
+	}
+
+	/// Insert a block header and associated data.
+	pub fn insert(
+		&self,
+		hash: Block::Hash,
+		header: <Block as BlockT>::Header,
+		justifications: Option<Justifications>,
+		body: Option<Vec<<Block as BlockT>::Extrinsic>>,
+		new_state: NewBlockState,
+	) -> sp_blockchain::Result<()> {
+		let number = *header.number();
+		if new_state.is_best() {
+			self.apply_head(&header)?;
+		}
+
+		{
+			let mut storage = self.storage.write();
+			storage.leaves.import(hash, number, *header.parent_hash());
+			storage.blocks.insert(hash, StoredBlock::new(header, body, justifications));
+
+			if let NewBlockState::Final = new_state {
+				storage.finalized_hash = hash;
+				storage.finalized_number = number;
+			}
+
+			if number == Zero::zero() {
+				storage.genesis_hash = hash;
+			}
+		}
+
+		Ok(())
+	}
+
+	/// Get total number of blocks.
+	pub fn blocks_count(&self) -> usize {
+		self.storage.read().blocks.len()
+	}
+
+	/// Compare this blockchain with another in-mem blockchain
+	pub fn equals_to(&self, other: &Self) -> bool {
+		// Check ptr equality first to avoid double read locks.
+		if ptr::eq(self, other) {
+			return true
+		}
+		self.canon_equals_to(other) && self.storage.read().blocks == other.storage.read().blocks
+	}
+
+	/// Compare canonical chain to other canonical chain.
+	pub fn canon_equals_to(&self, other: &Self) -> bool {
+		// Check ptr equality first to avoid double read locks.
+		if ptr::eq(self, other) {
+			return true
+		}
+		let this = self.storage.read();
+		let other = other.storage.read();
+		this.hashes == other.hashes &&
+			this.best_hash == other.best_hash &&
+			this.best_number == other.best_number &&
+			this.genesis_hash == other.genesis_hash
+	}
+
+	/// Insert header CHT root.
+	pub fn insert_cht_root(&self, block: NumberFor<Block>, cht_root: Block::Hash) {
+		self.storage.write().header_cht_roots.insert(block, cht_root);
+	}
+
+	/// Set an existing block as head.
+	pub fn set_head(&self, hash: Block::Hash) -> sp_blockchain::Result<()> {
+		let header = self
+			.header(hash)?
+			.ok_or_else(|| sp_blockchain::Error::UnknownBlock(format!("{}", hash)))?;
+
+		self.apply_head(&header)
+	}
+
+	fn apply_head(&self, header: &<Block as BlockT>::Header) -> sp_blockchain::Result<()> {
+		let hash = header.hash();
+		let number = header.number();
+
+		// Note: this may lock storage, so it must happen before obtaining storage
+		// write lock.
+		let best_tree_route = {
+			let best_hash = self.storage.read().best_hash;
+			if &best_hash == header.parent_hash() {
+				None
+			} else {
+				let route = sp_blockchain::tree_route(self, best_hash, *header.parent_hash())?;
+				Some(route)
+			}
+		};
+
+		let mut storage = self.storage.write();
+
+		if let Some(tree_route) = best_tree_route {
+			// apply retraction and enaction when reorganizing up to parent hash
+			let enacted = tree_route.enacted();
+
+			for entry in enacted {
+				storage.hashes.insert(entry.number, entry.hash);
+			}
+
+			for entry in tree_route.retracted().iter().skip(enacted.len()) {
+				storage.hashes.remove(&entry.number);
+			}
+		}
+
+		storage.best_hash = hash;
+		storage.best_number = *number;
+		storage.hashes.insert(*number, hash);
+
+		Ok(())
+	}
+
+	fn finalize_header(
+		&self,
+		block: Block::Hash,
+		justification: Option<Justification>,
+	) -> sp_blockchain::Result<()> {
+		let mut storage = self.storage.write();
+		storage.finalized_hash = block;
+
+		if justification.is_some() {
+			let block = storage
+				.blocks
+				.get_mut(&block)
+				.expect("hash was fetched from a block in the db; qed");
+
+			let block_justifications = match block {
+				StoredBlock::Header(_, ref mut j) | StoredBlock::Full(_, ref mut j) => j,
+			};
+
+			*block_justifications = justification.map(Justifications::from);
+		}
+
+		Ok(())
+	}
+
+	fn append_justification(
+		&self,
+		hash: Block::Hash,
+		justification: Justification,
+	) -> sp_blockchain::Result<()> {
+		let mut storage = self.storage.write();
+
+		let block = storage
+			.blocks
+			.get_mut(&hash)
+			.expect("hash was fetched from a block in the db; qed");
+
+		let block_justifications = match block {
+			StoredBlock::Header(_, ref mut j) | StoredBlock::Full(_, ref mut j) => j,
+		};
+
+		if let Some(stored_justifications) = block_justifications {
+			if !stored_justifications.append(justification) {
+				return Err(sp_blockchain::Error::BadJustification(
+					"Duplicate consensus engine ID".into(),
+				))
+			}
+		} else {
+			*block_justifications = Some(Justifications::from(justification));
+		};
+
+		Ok(())
+	}
+
+	fn write_aux(&self, ops: Vec<(Vec<u8>, Option<Vec<u8>>)>) {
+		let mut storage = self.storage.write();
+		for (k, v) in ops {
+			match v {
+				Some(v) => storage.aux.insert(k, v),
+				None => storage.aux.remove(&k),
+			};
+		}
+	}
+}
+
+impl<Block: BlockT> HeaderBackend<Block> for Blockchain<Block> {
+	fn header(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<<Block as BlockT>::Header>> {
+		Ok(self.storage.read().blocks.get(&hash).map(|b| b.header().clone()))
+	}
+
+	fn info(&self) -> blockchain::Info<Block> {
+		let storage = self.storage.read();
+		blockchain::Info {
+			best_hash: storage.best_hash,
+			best_number: storage.best_number,
+			genesis_hash: storage.genesis_hash,
+			finalized_hash: storage.finalized_hash,
+			finalized_number: storage.finalized_number,
+			finalized_state: if storage.finalized_hash != Default::default() {
+				Some((storage.finalized_hash, storage.finalized_number))
+			} else {
+				None
+			},
+			number_leaves: storage.leaves.count(),
+			block_gap: None,
+		}
+	}
+
+	fn status(&self, hash: Block::Hash) -> sp_blockchain::Result<BlockStatus> {
+		match self.storage.read().blocks.contains_key(&hash) {
+			true => Ok(BlockStatus::InChain),
+			false => Ok(BlockStatus::Unknown),
+		}
+	}
+
+	fn number(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<NumberFor<Block>>> {
+		Ok(self.storage.read().blocks.get(&hash).map(|b| *b.header().number()))
+	}
+
+	fn hash(
+		&self,
+		number: <<Block as BlockT>::Header as HeaderT>::Number,
+	) -> sp_blockchain::Result<Option<Block::Hash>> {
+		Ok(self.id(BlockId::Number(number)))
+	}
+}
+
+impl<Block: BlockT> HeaderMetadata<Block> for Blockchain<Block> {
+	type Error = sp_blockchain::Error;
+
+	fn header_metadata(
+		&self,
+		hash: Block::Hash,
+	) -> Result<CachedHeaderMetadata<Block>, Self::Error> {
+		self.header(hash)?
+			.map(|header| CachedHeaderMetadata::from(&header))
+			.ok_or_else(|| {
+				sp_blockchain::Error::UnknownBlock(format!("header not found: {}", hash))
+			})
+	}
+
+	fn insert_header_metadata(&self, _hash: Block::Hash, _metadata: CachedHeaderMetadata<Block>) {
+		// No need to implement.
+	}
+	fn remove_header_metadata(&self, _hash: Block::Hash) {
+		// No need to implement.
+	}
+}
+
+impl<Block: BlockT> blockchain::Backend<Block> for Blockchain<Block> {
+	fn body(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
+		Ok(self
+			.storage
+			.read()
+			.blocks
+			.get(&hash)
+			.and_then(|b| b.extrinsics().map(|x| x.to_vec())))
+	}
+
+	fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
+		Ok(self.storage.read().blocks.get(&hash).and_then(|b| b.justifications().cloned()))
+	}
+
+	fn last_finalized(&self) -> sp_blockchain::Result<Block::Hash> {
+		Ok(self.storage.read().finalized_hash)
+	}
+
+	fn leaves(&self) -> sp_blockchain::Result<Vec<Block::Hash>> {
+		Ok(self.storage.read().leaves.hashes())
+	}
+
+	fn displaced_leaves_after_finalizing(
+		&self,
+		block_number: NumberFor<Block>,
+	) -> sp_blockchain::Result<Vec<Block::Hash>> {
+		Ok(self
+			.storage
+			.read()
+			.leaves
+			.displaced_by_finalize_height(block_number)
+			.leaves()
+			.cloned()
+			.collect::<Vec<_>>())
+	}
+
+	fn children(&self, _parent_hash: Block::Hash) -> sp_blockchain::Result<Vec<Block::Hash>> {
+		unimplemented!()
+	}
+
+	fn indexed_transaction(&self, _hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		unimplemented!("Not supported by the in-mem backend.")
+	}
+
+	fn block_indexed_body(
+		&self,
+		_hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>> {
+		unimplemented!("Not supported by the in-mem backend.")
+	}
+}
+
+impl<Block: BlockT> backend::AuxStore for Blockchain<Block> {
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item = &'a &'b [u8]>,
+	>(
+		&self,
+		insert: I,
+		delete: D,
+	) -> sp_blockchain::Result<()> {
+		let mut storage = self.storage.write();
+		for (k, v) in insert {
+			storage.aux.insert(k.to_vec(), v.to_vec());
+		}
+		for k in delete {
+			storage.aux.remove(*k);
+		}
+		Ok(())
+	}
+
+	fn get_aux(&self, key: &[u8]) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		Ok(self.storage.read().aux.get(key).cloned())
+	}
+}
+
+/// In-memory operation.
+pub struct BlockImportOperation<Block: BlockT> {
+	pending_block: Option<PendingBlock<Block>>,
+	old_state: InMemoryBackend<HashingFor<Block>>,
+	new_state: Option<BackendTransaction<HashingFor<Block>>>,
+	aux: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+	finalized_blocks: Vec<(Block::Hash, Option<Justification>)>,
+	set_head: Option<Block::Hash>,
+}
+
+impl<Block: BlockT> BlockImportOperation<Block> {
+	fn apply_storage(
+		&mut self,
+		storage: Storage,
+		commit: bool,
+		state_version: StateVersion,
+	) -> sp_blockchain::Result<Block::Hash> {
+		check_genesis_storage(&storage)?;
+
+		let child_delta = storage.children_default.values().map(|child_content| {
+			(
+				&child_content.child_info,
+				child_content.data.iter().map(|(k, v)| (k.as_ref(), Some(v.as_ref()))),
+			)
+		});
+
+		let (root, transaction) = self.old_state.full_storage_root(
+			storage.top.iter().map(|(k, v)| (k.as_ref(), Some(v.as_ref()))),
+			child_delta,
+			state_version,
+		);
+
+		if commit {
+			self.new_state = Some(transaction);
+		}
+		Ok(root)
+	}
+}
+
+impl<Block: BlockT> backend::BlockImportOperation<Block> for BlockImportOperation<Block> {
+	type State = InMemoryBackend<HashingFor<Block>>;
+
+	fn state(&self) -> sp_blockchain::Result<Option<&Self::State>> {
+		Ok(Some(&self.old_state))
+	}
+
+	fn set_block_data(
+		&mut self,
+		header: <Block as BlockT>::Header,
+		body: Option<Vec<<Block as BlockT>::Extrinsic>>,
+		_indexed_body: Option<Vec<Vec<u8>>>,
+		justifications: Option<Justifications>,
+		state: NewBlockState,
+	) -> sp_blockchain::Result<()> {
+		assert!(self.pending_block.is_none(), "Only one block per operation is allowed");
+		self.pending_block =
+			Some(PendingBlock { block: StoredBlock::new(header, body, justifications), state });
+		Ok(())
+	}
+
+	fn update_db_storage(
+		&mut self,
+		update: BackendTransaction<HashingFor<Block>>,
+	) -> sp_blockchain::Result<()> {
+		self.new_state = Some(update);
+		Ok(())
+	}
+
+	fn set_genesis_state(
+		&mut self,
+		storage: Storage,
+		commit: bool,
+		state_version: StateVersion,
+	) -> sp_blockchain::Result<Block::Hash> {
+		self.apply_storage(storage, commit, state_version)
+	}
+
+	fn reset_storage(
+		&mut self,
+		storage: Storage,
+		state_version: StateVersion,
+	) -> sp_blockchain::Result<Block::Hash> {
+		self.apply_storage(storage, true, state_version)
+	}
+
+	fn insert_aux<I>(&mut self, ops: I) -> sp_blockchain::Result<()>
+	where
+		I: IntoIterator<Item = (Vec<u8>, Option<Vec<u8>>)>,
+	{
+		self.aux.append(&mut ops.into_iter().collect());
+		Ok(())
+	}
+
+	fn update_storage(
+		&mut self,
+		_update: StorageCollection,
+		_child_update: ChildStorageCollection,
+	) -> sp_blockchain::Result<()> {
+		Ok(())
+	}
+
+	fn mark_finalized(
+		&mut self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+	) -> sp_blockchain::Result<()> {
+		self.finalized_blocks.push((hash, justification));
+		Ok(())
+	}
+
+	fn mark_head(&mut self, hash: Block::Hash) -> sp_blockchain::Result<()> {
+		assert!(self.pending_block.is_none(), "Only one set block per operation is allowed");
+		self.set_head = Some(hash);
+		Ok(())
+	}
+
+	fn update_transaction_index(
+		&mut self,
+		_index: Vec<IndexOperation>,
+	) -> sp_blockchain::Result<()> {
+		Ok(())
+	}
+}
+
+/// In-memory backend. Keeps all states and blocks in memory.
+///
+/// > **Warning**: Doesn't support all the features necessary for a proper database. Only use this
+/// > struct for testing purposes. Do **NOT** use in production.
+pub struct Backend<Block: BlockT> {
+	states: RwLock<HashMap<Block::Hash, InMemoryBackend<HashingFor<Block>>>>,
+	blockchain: Blockchain<Block>,
+	import_lock: RwLock<()>,
+	pinned_blocks: RwLock<HashMap<Block::Hash, i64>>,
+}
+
+impl<Block: BlockT> Backend<Block> {
+	/// Create a new instance of in-mem backend.
+	///
+	/// # Warning
+	///
+	/// For testing purposes only!
+	pub fn new() -> Self {
+		Backend {
+			states: RwLock::new(HashMap::new()),
+			blockchain: Blockchain::new(),
+			import_lock: Default::default(),
+			pinned_blocks: Default::default(),
+		}
+	}
+
+	/// Return the number of references active for a pinned block.
+	///
+	/// # Warning
+	///
+	/// For testing purposes only!
+	pub fn pin_refs(&self, hash: &<Block as BlockT>::Hash) -> Option<i64> {
+		let blocks = self.pinned_blocks.read();
+		blocks.get(hash).map(|value| *value)
+	}
+}
+
+impl<Block: BlockT> backend::AuxStore for Backend<Block> {
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item = &'a &'b [u8]>,
+	>(
+		&self,
+		insert: I,
+		delete: D,
+	) -> sp_blockchain::Result<()> {
+		self.blockchain.insert_aux(insert, delete)
+	}
+
+	fn get_aux(&self, key: &[u8]) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		self.blockchain.get_aux(key)
+	}
+}
+
+impl<Block: BlockT> backend::Backend<Block> for Backend<Block> {
+	type BlockImportOperation = BlockImportOperation<Block>;
+	type Blockchain = Blockchain<Block>;
+	type State = InMemoryBackend<HashingFor<Block>>;
+	type OffchainStorage = OffchainStorage;
+
+	fn begin_operation(&self) -> sp_blockchain::Result<Self::BlockImportOperation> {
+		let old_state = self.state_at(Default::default())?;
+		Ok(BlockImportOperation {
+			pending_block: None,
+			old_state,
+			new_state: None,
+			aux: Default::default(),
+			finalized_blocks: Default::default(),
+			set_head: None,
+		})
+	}
+
+	fn begin_state_operation(
+		&self,
+		operation: &mut Self::BlockImportOperation,
+		block: Block::Hash,
+	) -> sp_blockchain::Result<()> {
+		operation.old_state = self.state_at(block)?;
+		Ok(())
+	}
+
+	fn commit_operation(&self, operation: Self::BlockImportOperation) -> sp_blockchain::Result<()> {
+		if !operation.finalized_blocks.is_empty() {
+			for (block, justification) in operation.finalized_blocks {
+				self.blockchain.finalize_header(block, justification)?;
+			}
+		}
+
+		if let Some(pending_block) = operation.pending_block {
+			let old_state = &operation.old_state;
+			let (header, body, justification) = pending_block.block.into_inner();
+
+			let hash = header.hash();
+
+			let new_state = match operation.new_state {
+				Some(state) => old_state.update_backend(*header.state_root(), state),
+				None => old_state.clone(),
+			};
+
+			self.states.write().insert(hash, new_state);
+
+			self.blockchain.insert(hash, header, justification, body, pending_block.state)?;
+		}
+
+		if !operation.aux.is_empty() {
+			self.blockchain.write_aux(operation.aux);
+		}
+
+		if let Some(set_head) = operation.set_head {
+			self.blockchain.set_head(set_head)?;
+		}
+
+		Ok(())
+	}
+
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+	) -> sp_blockchain::Result<()> {
+		self.blockchain.finalize_header(hash, justification)
+	}
+
+	fn append_justification(
+		&self,
+		hash: Block::Hash,
+		justification: Justification,
+	) -> sp_blockchain::Result<()> {
+		self.blockchain.append_justification(hash, justification)
+	}
+
+	fn blockchain(&self) -> &Self::Blockchain {
+		&self.blockchain
+	}
+
+	fn usage_info(&self) -> Option<UsageInfo> {
+		None
+	}
+
+	fn offchain_storage(&self) -> Option<Self::OffchainStorage> {
+		None
+	}
+
+	fn state_at(&self, hash: Block::Hash) -> sp_blockchain::Result<Self::State> {
+		if hash == Default::default() {
+			return Ok(Self::State::default())
+		}
+
+		self.states
+			.read()
+			.get(&hash)
+			.cloned()
+			.ok_or_else(|| sp_blockchain::Error::UnknownBlock(format!("{}", hash)))
+	}
+
+	fn revert(
+		&self,
+		_n: NumberFor<Block>,
+		_revert_finalized: bool,
+	) -> sp_blockchain::Result<(NumberFor<Block>, HashSet<Block::Hash>)> {
+		Ok((Zero::zero(), HashSet::new()))
+	}
+
+	fn remove_leaf_block(&self, _hash: Block::Hash) -> sp_blockchain::Result<()> {
+		Ok(())
+	}
+
+	fn get_import_lock(&self) -> &RwLock<()> {
+		&self.import_lock
+	}
+
+	fn requires_full_sync(&self) -> bool {
+		false
+	}
+
+	fn pin_block(&self, hash: <Block as BlockT>::Hash) -> blockchain::Result<()> {
+		let mut blocks = self.pinned_blocks.write();
+		*blocks.entry(hash).or_default() += 1;
+		Ok(())
+	}
+
+	fn unpin_block(&self, hash: <Block as BlockT>::Hash) {
+		let mut blocks = self.pinned_blocks.write();
+		blocks.entry(hash).and_modify(|counter| *counter -= 1).or_insert(-1);
+	}
+}
+
+impl<Block: BlockT> backend::LocalBackend<Block> for Backend<Block> {}
+
+/// Check that genesis storage is valid.
+pub fn check_genesis_storage(storage: &Storage) -> sp_blockchain::Result<()> {
+	if storage.top.iter().any(|(k, _)| well_known_keys::is_child_storage_key(k)) {
+		return Err(sp_blockchain::Error::InvalidState)
+	}
+
+	if storage
+		.children_default
+		.keys()
+		.any(|child_key| !well_known_keys::is_child_storage_key(child_key))
+	{
+		return Err(sp_blockchain::Error::InvalidState)
+	}
+
+	Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::{in_mem::Blockchain, NewBlockState};
+	use sp_api::HeaderT;
+	use sp_blockchain::Backend;
+	use sp_runtime::{ConsensusEngineId, Justifications};
+	use substrate_test_runtime::{Block, Header, H256};
+
+	pub const ID1: ConsensusEngineId = *b"TST1";
+	pub const ID2: ConsensusEngineId = *b"TST2";
+
+	fn header(number: u64) -> Header {
+		let parent_hash = match number {
+			0 => Default::default(),
+			_ => header(number - 1).hash(),
+		};
+		Header::new(
+			number,
+			H256::from_low_u64_be(0),
+			H256::from_low_u64_be(0),
+			parent_hash,
+			Default::default(),
+		)
+	}
+
+	fn test_blockchain() -> Blockchain<Block> {
+		let blockchain = Blockchain::<Block>::new();
+		let just0 = Some(Justifications::from((ID1, vec![0])));
+		let just1 = Some(Justifications::from((ID1, vec![1])));
+		let just2 = None;
+		let just3 = Some(Justifications::from((ID1, vec![3])));
+		blockchain
+			.insert(header(0).hash(), header(0), just0, None, NewBlockState::Final)
+			.unwrap();
+		blockchain
+			.insert(header(1).hash(), header(1), just1, None, NewBlockState::Final)
+			.unwrap();
+		blockchain
+			.insert(header(2).hash(), header(2), just2, None, NewBlockState::Best)
+			.unwrap();
+		blockchain
+			.insert(header(3).hash(), header(3), just3, None, NewBlockState::Final)
+			.unwrap();
+		blockchain
+	}
+
+	#[test]
+	fn append_and_retrieve_justifications() {
+		let blockchain = test_blockchain();
+		let last_finalized = blockchain.last_finalized().unwrap();
+
+		blockchain.append_justification(last_finalized, (ID2, vec![4])).unwrap();
+		let justifications = {
+			let mut just = Justifications::from((ID1, vec![3]));
+			just.append((ID2, vec![4]));
+			just
+		};
+		assert_eq!(blockchain.justifications(last_finalized).unwrap(), Some(justifications));
+	}
+
+	#[test]
+	fn store_duplicate_justifications_is_forbidden() {
+		let blockchain = test_blockchain();
+		let last_finalized = blockchain.last_finalized().unwrap();
+
+		blockchain.append_justification(last_finalized, (ID2, vec![0])).unwrap();
+		assert!(matches!(
+			blockchain.append_justification(last_finalized, (ID2, vec![1])),
+			Err(sp_blockchain::Error::BadJustification(_)),
+		));
+	}
+}
diff --git a/substrate/client/api/src/leaves.rs b/substrate/client/api/src/leaves.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a8a988771e2fdf346dd0c50983d0e8b32c74bafc
--- /dev/null
+++ b/substrate/client/api/src/leaves.rs
@@ -0,0 +1,513 @@
+// 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/>.
+
+//! Helper for managing the set of available leaves in the chain for DB implementations.
+
+use codec::{Decode, Encode};
+use sp_blockchain::{Error, Result};
+use sp_database::{Database, Transaction};
+use sp_runtime::traits::AtLeast32Bit;
+use std::{cmp::Reverse, collections::BTreeMap};
+
+type DbHash = sp_core::H256;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct LeafSetItem<H, N> {
+	hash: H,
+	number: Reverse<N>,
+}
+
+/// Inserted and removed leaves after an import action.
+pub struct ImportOutcome<H, N> {
+	inserted: LeafSetItem<H, N>,
+	removed: Option<H>,
+}
+
+/// Inserted and removed leaves after a remove action.
+pub struct RemoveOutcome<H, N> {
+	inserted: Option<H>,
+	removed: LeafSetItem<H, N>,
+}
+
+/// Removed leaves after a finalization action.
+pub struct FinalizationOutcome<H, N> {
+	removed: BTreeMap<Reverse<N>, Vec<H>>,
+}
+
+impl<H, N: Ord> FinalizationOutcome<H, N> {
+	/// Merge with another. This should only be used for displaced items that
+	/// are produced within one transaction of each other.
+	pub fn merge(&mut self, mut other: Self) {
+		// this will ignore keys that are in duplicate, however
+		// if these are actually produced correctly via the leaf-set within
+		// one transaction, then there will be no overlap in the keys.
+		self.removed.append(&mut other.removed);
+	}
+
+	/// Iterate over all displaced leaves.
+	pub fn leaves(&self) -> impl Iterator<Item = &H> {
+		self.removed.values().flatten()
+	}
+}
+
+/// list of leaf hashes ordered by number (descending).
+/// stored in memory for fast access.
+/// this allows very fast checking and modification of active leaves.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct LeafSet<H, N> {
+	storage: BTreeMap<Reverse<N>, Vec<H>>,
+}
+
+impl<H, N> LeafSet<H, N>
+where
+	H: Clone + PartialEq + Decode + Encode,
+	N: std::fmt::Debug + Clone + AtLeast32Bit + Decode + Encode,
+{
+	/// Construct a new, blank leaf set.
+	pub fn new() -> Self {
+		Self { storage: BTreeMap::new() }
+	}
+
+	/// Read the leaf list from the DB, using given prefix for keys.
+	pub fn read_from_db(db: &dyn Database<DbHash>, column: u32, prefix: &[u8]) -> Result<Self> {
+		let mut storage = BTreeMap::new();
+
+		match db.get(column, prefix) {
+			Some(leaves) => {
+				let vals: Vec<_> = match Decode::decode(&mut leaves.as_ref()) {
+					Ok(vals) => vals,
+					Err(_) => return Err(Error::Backend("Error decoding leaves".into())),
+				};
+				for (number, hashes) in vals.into_iter() {
+					storage.insert(Reverse(number), hashes);
+				}
+			},
+			None => {},
+		}
+		Ok(Self { storage })
+	}
+
+	/// Update the leaf list on import.
+	pub fn import(&mut self, hash: H, number: N, parent_hash: H) -> ImportOutcome<H, N> {
+		let number = Reverse(number);
+
+		let removed = if number.0 != N::zero() {
+			let parent_number = Reverse(number.0.clone() - N::one());
+			self.remove_leaf(&parent_number, &parent_hash).then(|| parent_hash)
+		} else {
+			None
+		};
+
+		self.insert_leaf(number.clone(), hash.clone());
+
+		ImportOutcome { inserted: LeafSetItem { hash, number }, removed }
+	}
+
+	/// Update the leaf list on removal.
+	///
+	/// Note that the leaves set structure doesn't have the information to decide if the
+	/// leaf we're removing is the last children of the parent. Follows that this method requires
+	/// the caller to check this condition and optionally pass the `parent_hash` if `hash` is
+	/// its last child.
+	///
+	/// Returns `None` if no modifications are applied.
+	pub fn remove(
+		&mut self,
+		hash: H,
+		number: N,
+		parent_hash: Option<H>,
+	) -> Option<RemoveOutcome<H, N>> {
+		let number = Reverse(number);
+
+		if !self.remove_leaf(&number, &hash) {
+			return None
+		}
+
+		let inserted = parent_hash.and_then(|parent_hash| {
+			if number.0 != N::zero() {
+				let parent_number = Reverse(number.0.clone() - N::one());
+				self.insert_leaf(parent_number, parent_hash.clone());
+				Some(parent_hash)
+			} else {
+				None
+			}
+		});
+
+		Some(RemoveOutcome { inserted, removed: LeafSetItem { hash, number } })
+	}
+
+	/// Note a block height finalized, displacing all leaves with number less than the finalized
+	/// block's.
+	///
+	/// Although it would be more technically correct to also prune out leaves at the
+	/// same number as the finalized block, but with different hashes, the current behavior
+	/// is simpler and our assumptions about how finalization works means that those leaves
+	/// will be pruned soon afterwards anyway.
+	pub fn finalize_height(&mut self, number: N) -> FinalizationOutcome<H, N> {
+		let boundary = if number == N::zero() {
+			return FinalizationOutcome { removed: BTreeMap::new() }
+		} else {
+			number - N::one()
+		};
+
+		let below_boundary = self.storage.split_off(&Reverse(boundary));
+		FinalizationOutcome { removed: below_boundary }
+	}
+
+	/// The same as [`Self::finalize_height`], but it only simulates the operation.
+	///
+	/// This means that no changes are done.
+	///
+	/// Returns the leaves that would be displaced by finalizing the given block.
+	pub fn displaced_by_finalize_height(&self, number: N) -> FinalizationOutcome<H, N> {
+		let boundary = if number == N::zero() {
+			return FinalizationOutcome { removed: BTreeMap::new() }
+		} else {
+			number - N::one()
+		};
+
+		let below_boundary = self.storage.range(&Reverse(boundary)..);
+		FinalizationOutcome {
+			removed: below_boundary.map(|(k, v)| (k.clone(), v.clone())).collect(),
+		}
+	}
+
+	/// Undo all pending operations.
+	///
+	/// This returns an `Undo` struct, where any
+	/// `Displaced` objects that have returned by previous method calls
+	/// should be passed to via the appropriate methods. Otherwise,
+	/// the on-disk state may get out of sync with in-memory state.
+	pub fn undo(&mut self) -> Undo<H, N> {
+		Undo { inner: self }
+	}
+
+	/// Revert to the given block height by dropping all leaves in the leaf set
+	/// with a block number higher than the target.
+	pub fn revert(&mut self, best_hash: H, best_number: N) {
+		let items = self
+			.storage
+			.iter()
+			.flat_map(|(number, hashes)| hashes.iter().map(move |h| (h.clone(), number.clone())))
+			.collect::<Vec<_>>();
+
+		for (hash, number) in &items {
+			if number.0 > best_number {
+				assert!(
+					self.remove_leaf(number, hash),
+					"item comes from an iterator over storage; qed",
+				);
+			}
+		}
+
+		let best_number = Reverse(best_number);
+		let leaves_contains_best = self
+			.storage
+			.get(&best_number)
+			.map_or(false, |hashes| hashes.contains(&best_hash));
+
+		// we need to make sure that the best block exists in the leaf set as
+		// this is an invariant of regular block import.
+		if !leaves_contains_best {
+			self.insert_leaf(best_number.clone(), best_hash.clone());
+		}
+	}
+
+	/// returns an iterator over all hashes in the leaf set
+	/// ordered by their block number descending.
+	pub fn hashes(&self) -> Vec<H> {
+		self.storage.iter().flat_map(|(_, hashes)| hashes.iter()).cloned().collect()
+	}
+
+	/// Number of known leaves.
+	pub fn count(&self) -> usize {
+		self.storage.values().map(|level| level.len()).sum()
+	}
+
+	/// Write the leaf list to the database transaction.
+	pub fn prepare_transaction(
+		&mut self,
+		tx: &mut Transaction<DbHash>,
+		column: u32,
+		prefix: &[u8],
+	) {
+		let leaves: Vec<_> = self.storage.iter().map(|(n, h)| (n.0.clone(), h.clone())).collect();
+		tx.set_from_vec(column, prefix, leaves.encode());
+	}
+
+	/// Check if given block is a leaf.
+	pub fn contains(&self, number: N, hash: H) -> bool {
+		self.storage
+			.get(&Reverse(number))
+			.map_or(false, |hashes| hashes.contains(&hash))
+	}
+
+	fn insert_leaf(&mut self, number: Reverse<N>, hash: H) {
+		self.storage.entry(number).or_insert_with(Vec::new).push(hash);
+	}
+
+	// Returns true if this leaf was contained, false otherwise.
+	fn remove_leaf(&mut self, number: &Reverse<N>, hash: &H) -> bool {
+		let mut empty = false;
+		let removed = self.storage.get_mut(number).map_or(false, |leaves| {
+			let mut found = false;
+			leaves.retain(|h| {
+				if h == hash {
+					found = true;
+					false
+				} else {
+					true
+				}
+			});
+
+			if leaves.is_empty() {
+				empty = true
+			}
+
+			found
+		});
+
+		if removed && empty {
+			self.storage.remove(number);
+		}
+
+		removed
+	}
+
+	/// Returns the highest leaf and all hashes associated to it.
+	pub fn highest_leaf(&self) -> Option<(N, &[H])> {
+		self.storage.iter().next().map(|(k, v)| (k.0.clone(), &v[..]))
+	}
+}
+
+/// Helper for undoing operations.
+pub struct Undo<'a, H: 'a, N: 'a> {
+	inner: &'a mut LeafSet<H, N>,
+}
+
+impl<'a, H: 'a, N: 'a> Undo<'a, H, N>
+where
+	H: Clone + PartialEq + Decode + Encode,
+	N: std::fmt::Debug + Clone + AtLeast32Bit + Decode + Encode,
+{
+	/// Undo an imported block by providing the import operation outcome.
+	/// No additional operations should be performed between import and undo.
+	pub fn undo_import(&mut self, outcome: ImportOutcome<H, N>) {
+		if let Some(removed_hash) = outcome.removed {
+			let removed_number = Reverse(outcome.inserted.number.0.clone() - N::one());
+			self.inner.insert_leaf(removed_number, removed_hash);
+		}
+		self.inner.remove_leaf(&outcome.inserted.number, &outcome.inserted.hash);
+	}
+
+	/// Undo a removed block by providing the displaced leaf.
+	/// No additional operations should be performed between remove and undo.
+	pub fn undo_remove(&mut self, outcome: RemoveOutcome<H, N>) {
+		if let Some(inserted_hash) = outcome.inserted {
+			let inserted_number = Reverse(outcome.removed.number.0.clone() - N::one());
+			self.inner.remove_leaf(&inserted_number, &inserted_hash);
+		}
+		self.inner.insert_leaf(outcome.removed.number, outcome.removed.hash);
+	}
+
+	/// Undo a finalization operation by providing the displaced leaves.
+	/// No additional operations should be performed between finalization and undo.
+	pub fn undo_finalization(&mut self, mut outcome: FinalizationOutcome<H, N>) {
+		self.inner.storage.append(&mut outcome.removed);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::sync::Arc;
+
+	#[test]
+	fn import_works() {
+		let mut set = LeafSet::new();
+		set.import(0u32, 0u32, 0u32);
+
+		set.import(1_1, 1, 0);
+		set.import(2_1, 2, 1_1);
+		set.import(3_1, 3, 2_1);
+
+		assert_eq!(set.count(), 1);
+		assert!(set.contains(3, 3_1));
+		assert!(!set.contains(2, 2_1));
+		assert!(!set.contains(1, 1_1));
+		assert!(!set.contains(0, 0));
+
+		set.import(2_2, 2, 1_1);
+		set.import(1_2, 1, 0);
+		set.import(2_3, 2, 1_2);
+
+		assert_eq!(set.count(), 3);
+		assert!(set.contains(3, 3_1));
+		assert!(set.contains(2, 2_2));
+		assert!(set.contains(2, 2_3));
+
+		// Finally test the undo feature
+
+		let outcome = set.import(2_4, 2, 1_1);
+		assert_eq!(outcome.inserted.hash, 2_4);
+		assert_eq!(outcome.removed, None);
+		assert_eq!(set.count(), 4);
+		assert!(set.contains(2, 2_4));
+
+		set.undo().undo_import(outcome);
+		assert_eq!(set.count(), 3);
+		assert!(set.contains(3, 3_1));
+		assert!(set.contains(2, 2_2));
+		assert!(set.contains(2, 2_3));
+
+		let outcome = set.import(3_2, 3, 2_3);
+		assert_eq!(outcome.inserted.hash, 3_2);
+		assert_eq!(outcome.removed, Some(2_3));
+		assert_eq!(set.count(), 3);
+		assert!(set.contains(3, 3_2));
+
+		set.undo().undo_import(outcome);
+		assert_eq!(set.count(), 3);
+		assert!(set.contains(3, 3_1));
+		assert!(set.contains(2, 2_2));
+		assert!(set.contains(2, 2_3));
+	}
+
+	#[test]
+	fn removal_works() {
+		let mut set = LeafSet::new();
+		set.import(10_1u32, 10u32, 0u32);
+		set.import(11_1, 11, 10_1);
+		set.import(11_2, 11, 10_1);
+		set.import(12_1, 12, 11_1);
+
+		let outcome = set.remove(12_1, 12, Some(11_1)).unwrap();
+		assert_eq!(outcome.removed.hash, 12_1);
+		assert_eq!(outcome.inserted, Some(11_1));
+		assert_eq!(set.count(), 2);
+		assert!(set.contains(11, 11_1));
+		assert!(set.contains(11, 11_2));
+
+		let outcome = set.remove(11_1, 11, None).unwrap();
+		assert_eq!(outcome.removed.hash, 11_1);
+		assert_eq!(outcome.inserted, None);
+		assert_eq!(set.count(), 1);
+		assert!(set.contains(11, 11_2));
+
+		let outcome = set.remove(11_2, 11, Some(10_1)).unwrap();
+		assert_eq!(outcome.removed.hash, 11_2);
+		assert_eq!(outcome.inserted, Some(10_1));
+		assert_eq!(set.count(), 1);
+		assert!(set.contains(10, 10_1));
+
+		set.undo().undo_remove(outcome);
+		assert_eq!(set.count(), 1);
+		assert!(set.contains(11, 11_2));
+	}
+
+	#[test]
+	fn finalization_works() {
+		let mut set = LeafSet::new();
+		set.import(9_1u32, 9u32, 0u32);
+		set.import(10_1, 10, 9_1);
+		set.import(10_2, 10, 9_1);
+		set.import(11_1, 11, 10_1);
+		set.import(11_2, 11, 10_1);
+		set.import(12_1, 12, 11_2);
+
+		let outcome = set.finalize_height(11);
+		assert_eq!(set.count(), 2);
+		assert!(set.contains(11, 11_1));
+		assert!(set.contains(12, 12_1));
+		assert_eq!(
+			outcome.removed,
+			[(Reverse(10), vec![10_2])].into_iter().collect::<BTreeMap<_, _>>(),
+		);
+
+		set.undo().undo_finalization(outcome);
+		assert_eq!(set.count(), 3);
+		assert!(set.contains(11, 11_1));
+		assert!(set.contains(12, 12_1));
+		assert!(set.contains(10, 10_2));
+	}
+
+	#[test]
+	fn flush_to_disk() {
+		const PREFIX: &[u8] = b"abcdefg";
+		let db = Arc::new(sp_database::MemDb::default());
+
+		let mut set = LeafSet::new();
+		set.import(0u32, 0u32, 0u32);
+
+		set.import(1_1, 1, 0);
+		set.import(2_1, 2, 1_1);
+		set.import(3_1, 3, 2_1);
+
+		let mut tx = Transaction::new();
+
+		set.prepare_transaction(&mut tx, 0, PREFIX);
+		db.commit(tx).unwrap();
+
+		let set2 = LeafSet::read_from_db(&*db, 0, PREFIX).unwrap();
+		assert_eq!(set, set2);
+	}
+
+	#[test]
+	fn two_leaves_same_height_can_be_included() {
+		let mut set = LeafSet::new();
+
+		set.import(1_1u32, 10u32, 0u32);
+		set.import(1_2, 10, 0);
+
+		assert!(set.storage.contains_key(&Reverse(10)));
+		assert!(set.contains(10, 1_1));
+		assert!(set.contains(10, 1_2));
+		assert!(!set.contains(10, 1_3));
+	}
+
+	#[test]
+	fn finalization_consistent_with_disk() {
+		const PREFIX: &[u8] = b"prefix";
+		let db = Arc::new(sp_database::MemDb::default());
+
+		let mut set = LeafSet::new();
+		set.import(10_1u32, 10u32, 0u32);
+		set.import(11_1, 11, 10_2);
+		set.import(11_2, 11, 10_2);
+		set.import(12_1, 12, 11_123);
+
+		assert!(set.contains(10, 10_1));
+
+		let mut tx = Transaction::new();
+		set.prepare_transaction(&mut tx, 0, PREFIX);
+		db.commit(tx).unwrap();
+
+		let _ = set.finalize_height(11);
+		let mut tx = Transaction::new();
+		set.prepare_transaction(&mut tx, 0, PREFIX);
+		db.commit(tx).unwrap();
+
+		assert!(set.contains(11, 11_1));
+		assert!(set.contains(11, 11_2));
+		assert!(set.contains(12, 12_1));
+		assert!(!set.contains(10, 10_1));
+
+		let set2 = LeafSet::read_from_db(&*db, 0, PREFIX).unwrap();
+		assert_eq!(set, set2);
+	}
+}
diff --git a/substrate/client/api/src/lib.rs b/substrate/client/api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..faadf3663a59d88871eb371c472826ddbec6f12f
--- /dev/null
+++ b/substrate/client/api/src/lib.rs
@@ -0,0 +1,93 @@
+// 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/>.
+
+//! Substrate client interfaces.
+#![warn(missing_docs)]
+
+pub mod backend;
+pub mod call_executor;
+pub mod client;
+pub mod execution_extensions;
+pub mod in_mem;
+pub mod leaves;
+pub mod notifications;
+pub mod proof_provider;
+
+pub use backend::*;
+pub use call_executor::*;
+pub use client::*;
+pub use notifications::*;
+pub use proof_provider::*;
+pub use sp_blockchain as blockchain;
+pub use sp_blockchain::HeaderBackend;
+
+pub use sp_state_machine::{CompactProof, StorageProof};
+pub use sp_storage::{ChildInfo, PrefixedStorageKey, StorageData, StorageKey};
+
+/// Usage Information Provider interface
+pub trait UsageProvider<Block: sp_runtime::traits::Block> {
+	/// Get usage info about current client.
+	fn usage_info(&self) -> ClientInfo<Block>;
+}
+
+/// Utility methods for the client.
+pub mod utils {
+	use sp_blockchain::{Error, HeaderBackend, HeaderMetadata};
+	use sp_runtime::traits::Block as BlockT;
+	use std::borrow::Borrow;
+
+	/// Returns a function for checking block ancestry, the returned function will
+	/// return `true` if the given hash (second parameter) is a descendent of the
+	/// base (first parameter). If the `current` parameter is defined, it should
+	/// represent the current block `hash` and its `parent hash`, if given the
+	/// function that's returned will assume that `hash` isn't part of the local DB
+	/// yet, and all searches in the DB will instead reference the parent.
+	pub fn is_descendent_of<Block: BlockT, T>(
+		client: &T,
+		current: Option<(Block::Hash, Block::Hash)>,
+	) -> impl Fn(&Block::Hash, &Block::Hash) -> Result<bool, Error> + '_
+	where
+		T: HeaderBackend<Block> + HeaderMetadata<Block, Error = Error>,
+	{
+		move |base, hash| {
+			if base == hash {
+				return Ok(false)
+			}
+
+			let current = current.as_ref().map(|(c, p)| (c.borrow(), p.borrow()));
+
+			let mut hash = hash;
+			if let Some((current_hash, current_parent_hash)) = current {
+				if base == current_hash {
+					return Ok(false)
+				}
+				if hash == current_hash {
+					if base == current_parent_hash {
+						return Ok(true)
+					} else {
+						hash = current_parent_hash;
+					}
+				}
+			}
+
+			let ancestor = sp_blockchain::lowest_common_ancestor(client, *hash, *base)?;
+
+			Ok(ancestor.hash == *base)
+		}
+	}
+}
diff --git a/substrate/client/api/src/notifications.rs b/substrate/client/api/src/notifications.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c16cefe21da0213bef1dde0c95d37c9920ce5096
--- /dev/null
+++ b/substrate/client/api/src/notifications.rs
@@ -0,0 +1,153 @@
+// 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/>.
+
+//! Storage notifications
+
+use std::{
+	collections::{HashMap, HashSet},
+	pin::Pin,
+	sync::Arc,
+	task::Poll,
+};
+
+use futures::Stream;
+
+use prometheus_endpoint::Registry as PrometheusRegistry;
+
+use sc_utils::pubsub::{Hub, Receiver};
+use sp_core::storage::{StorageData, StorageKey};
+use sp_runtime::traits::Block as BlockT;
+
+mod registry;
+
+use registry::Registry;
+
+#[cfg(test)]
+mod tests;
+
+/// A type of a message delivered to the subscribers
+#[derive(Debug)]
+pub struct StorageNotification<Hash> {
+	/// The hash of the block
+	pub block: Hash,
+
+	/// The set of changes
+	pub changes: StorageChangeSet,
+}
+
+/// Storage change set
+#[derive(Debug)]
+pub struct StorageChangeSet {
+	changes: Arc<[(StorageKey, Option<StorageData>)]>,
+	child_changes: Arc<[(StorageKey, Vec<(StorageKey, Option<StorageData>)>)]>,
+	filter: Keys,
+	child_filters: ChildKeys,
+}
+
+/// Manages storage listeners.
+#[derive(Debug)]
+pub struct StorageNotifications<Block: BlockT>(Hub<StorageNotification<Block::Hash>, Registry>);
+
+/// Type that implements `futures::Stream` of storage change events.
+pub struct StorageEventStream<H>(Receiver<StorageNotification<H>, Registry>);
+
+type Keys = Option<HashSet<StorageKey>>;
+type ChildKeys = Option<HashMap<StorageKey, Option<HashSet<StorageKey>>>>;
+
+impl StorageChangeSet {
+	/// Convert the change set into iterator over storage items.
+	pub fn iter(
+		&self,
+	) -> impl Iterator<Item = (Option<&StorageKey>, &StorageKey, Option<&StorageData>)> + '_ {
+		let top = self
+			.changes
+			.iter()
+			.filter(move |&(key, _)| match self.filter {
+				Some(ref filter) => filter.contains(key),
+				None => true,
+			})
+			.map(move |(k, v)| (None, k, v.as_ref()));
+		let children = self
+			.child_changes
+			.iter()
+			.filter_map(move |(sk, changes)| {
+				self.child_filters.as_ref().and_then(|cf| {
+					cf.get(sk).map(|filter| {
+						changes
+							.iter()
+							.filter(move |&(key, _)| match filter {
+								Some(ref filter) => filter.contains(key),
+								None => true,
+							})
+							.map(move |(k, v)| (Some(sk), k, v.as_ref()))
+					})
+				})
+			})
+			.flatten();
+		top.chain(children)
+	}
+}
+
+impl<H> Stream for StorageEventStream<H> {
+	type Item = StorageNotification<H>;
+	fn poll_next(
+		self: Pin<&mut Self>,
+		cx: &mut std::task::Context<'_>,
+	) -> Poll<Option<Self::Item>> {
+		Stream::poll_next(Pin::new(&mut self.get_mut().0), cx)
+	}
+}
+
+impl<Block: BlockT> StorageNotifications<Block> {
+	/// Initialize a new StorageNotifications
+	/// optionally pass a prometheus registry to send subscriber metrics to
+	pub fn new(prometheus_registry: Option<PrometheusRegistry>) -> Self {
+		let registry = Registry::new(prometheus_registry);
+		let hub = Hub::new_with_registry("mpsc_storage_notification_items", registry);
+
+		StorageNotifications(hub)
+	}
+
+	/// Trigger notification to all listeners.
+	///
+	/// Note the changes are going to be filtered by listener's filter key.
+	/// In fact no event might be sent if clients are not interested in the changes.
+	pub fn trigger(
+		&self,
+		hash: &Block::Hash,
+		changeset: impl Iterator<Item = (Vec<u8>, Option<Vec<u8>>)>,
+		child_changeset: impl Iterator<
+			Item = (Vec<u8>, impl Iterator<Item = (Vec<u8>, Option<Vec<u8>>)>),
+		>,
+	) {
+		self.0.send((hash, changeset, child_changeset))
+	}
+
+	/// Start listening for particular storage keys.
+	pub fn listen(
+		&self,
+		filter_keys: Option<&[StorageKey]>,
+		filter_child_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+	) -> StorageEventStream<Block::Hash> {
+		let receiver = self
+			.0
+			.subscribe(registry::SubscribeOp { filter_keys, filter_child_keys }, 100_000);
+
+		StorageEventStream(receiver)
+	}
+}
diff --git a/substrate/client/api/src/notifications/registry.rs b/substrate/client/api/src/notifications/registry.rs
new file mode 100644
index 0000000000000000000000000000000000000000..10c6673110ad46723a6af9838752e6a24501f14a
--- /dev/null
+++ b/substrate/client/api/src/notifications/registry.rs
@@ -0,0 +1,365 @@
+// 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::*;
+
+use sp_core::hexdisplay::HexDisplay;
+
+use fnv::{FnvHashMap, FnvHashSet};
+use prometheus_endpoint::{register, CounterVec, Opts, U64};
+
+use sc_utils::{
+	id_sequence::SeqID as SubscriberId,
+	pubsub::{Dispatch, Subscribe, Unsubscribe},
+};
+
+type SubscribersGauge = CounterVec<U64>;
+
+/// A command to subscribe with the specified filters.
+///
+/// Used by the implementation of [`Subscribe<Op>`] trait for [`Registry].
+pub(super) struct SubscribeOp<'a> {
+	pub filter_keys: Option<&'a [StorageKey]>,
+	pub filter_child_keys: Option<&'a [(StorageKey, Option<Vec<StorageKey>>)]>,
+}
+
+#[derive(Debug, Default)]
+pub(super) struct Registry {
+	pub(super) metrics: Option<SubscribersGauge>,
+	pub(super) wildcard_listeners: FnvHashSet<SubscriberId>,
+	pub(super) listeners: HashMap<StorageKey, FnvHashSet<SubscriberId>>,
+	pub(super) child_listeners: HashMap<
+		StorageKey,
+		(HashMap<StorageKey, FnvHashSet<SubscriberId>>, FnvHashSet<SubscriberId>),
+	>,
+	pub(super) sinks: FnvHashMap<SubscriberId, SubscriberSink>,
+}
+
+#[derive(Debug)]
+pub(super) struct SubscriberSink {
+	subs_id: SubscriberId,
+	keys: Keys,
+	child_keys: ChildKeys,
+	was_triggered: bool,
+}
+
+impl Drop for SubscriberSink {
+	fn drop(&mut self) {
+		if !self.was_triggered {
+			log::trace!(
+				target: "storage_notifications",
+				"Listener was never triggered: id={}, keys={:?}, child_keys={:?}",
+				self.subs_id,
+				PrintKeys(&self.keys),
+				PrintChildKeys(&self.child_keys),
+			);
+		}
+	}
+}
+
+impl SubscriberSink {
+	fn new(subs_id: SubscriberId, keys: Keys, child_keys: ChildKeys) -> Self {
+		Self { subs_id, keys, child_keys, was_triggered: false }
+	}
+}
+
+impl Registry {
+	pub(super) fn new(prometheus_registry: Option<PrometheusRegistry>) -> Self {
+		let metrics = prometheus_registry.and_then(|r| {
+			CounterVec::new(
+				Opts::new(
+					"substrate_storage_notification_subscribers",
+					"Number of subscribers in storage notification sytem",
+				),
+				&["action"], // added | removed
+			)
+			.and_then(|g| register(g, &r))
+			.ok()
+		});
+
+		Registry { metrics, ..Default::default() }
+	}
+}
+
+impl Unsubscribe for Registry {
+	fn unsubscribe(&mut self, subs_id: SubscriberId) {
+		self.remove_subscriber(subs_id);
+	}
+}
+
+impl<'a> Subscribe<SubscribeOp<'a>> for Registry {
+	fn subscribe(&mut self, subs_op: SubscribeOp<'a>, subs_id: SubscriberId) {
+		let SubscribeOp { filter_keys, filter_child_keys } = subs_op;
+
+		let keys = Self::listen_from(
+			subs_id,
+			filter_keys.as_ref(),
+			&mut self.listeners,
+			&mut self.wildcard_listeners,
+		);
+
+		let child_keys = filter_child_keys.map(|filter_child_keys| {
+			filter_child_keys
+				.iter()
+				.map(|(c_key, o_keys)| {
+					let (c_listeners, c_wildcards) =
+						self.child_listeners.entry(c_key.clone()).or_default();
+
+					(
+						c_key.clone(),
+						Self::listen_from(
+							subs_id,
+							o_keys.as_ref(),
+							&mut *c_listeners,
+							&mut *c_wildcards,
+						),
+					)
+				})
+				.collect()
+		});
+
+		if let Some(m) = self.metrics.as_ref() {
+			m.with_label_values(&["added"]).inc();
+		}
+
+		if self
+			.sinks
+			.insert(subs_id, SubscriberSink::new(subs_id, keys, child_keys))
+			.is_some()
+		{
+			log::warn!("The `subscribe`-method has been passed a non-unique subs_id (in `sc-client-api::notifications`)");
+		}
+	}
+}
+
+impl<'a, Hash, CS, CCS, CCSI> Dispatch<(&'a Hash, CS, CCS)> for Registry
+where
+	Hash: Clone,
+	CS: Iterator<Item = (Vec<u8>, Option<Vec<u8>>)>,
+	CCS: Iterator<Item = (Vec<u8>, CCSI)>,
+	CCSI: Iterator<Item = (Vec<u8>, Option<Vec<u8>>)>,
+{
+	type Item = StorageNotification<Hash>;
+	type Ret = ();
+
+	fn dispatch<F>(&mut self, message: (&'a Hash, CS, CCS), dispatch: F) -> Self::Ret
+	where
+		F: FnMut(&SubscriberId, Self::Item),
+	{
+		let (hash, changeset, child_changeset) = message;
+		self.trigger(hash, changeset, child_changeset, dispatch);
+	}
+}
+
+impl Registry {
+	pub(super) fn trigger<Hash, F>(
+		&mut self,
+		hash: &Hash,
+		changeset: impl Iterator<Item = (Vec<u8>, Option<Vec<u8>>)>,
+		child_changeset: impl Iterator<
+			Item = (Vec<u8>, impl Iterator<Item = (Vec<u8>, Option<Vec<u8>>)>),
+		>,
+		mut dispatch: F,
+	) where
+		Hash: Clone,
+		F: FnMut(&SubscriberId, StorageNotification<Hash>),
+	{
+		let has_wildcard = !self.wildcard_listeners.is_empty();
+
+		// early exit if no listeners
+		if !has_wildcard && self.listeners.is_empty() && self.child_listeners.is_empty() {
+			return
+		}
+
+		let mut subscribers = self.wildcard_listeners.clone();
+		let mut changes = Vec::new();
+		let mut child_changes = Vec::new();
+
+		// Collect subscribers and changes
+		for (k, v) in changeset {
+			let k = StorageKey(k);
+			let listeners = self.listeners.get(&k);
+
+			if let Some(listeners) = listeners {
+				subscribers.extend(listeners.iter());
+			}
+
+			if has_wildcard || listeners.is_some() {
+				changes.push((k, v.map(StorageData)));
+			}
+		}
+		for (sk, changeset) in child_changeset {
+			let sk = StorageKey(sk);
+			if let Some((cl, cw)) = self.child_listeners.get(&sk) {
+				let mut changes = Vec::new();
+				for (k, v) in changeset {
+					let k = StorageKey(k);
+					let listeners = cl.get(&k);
+
+					if let Some(listeners) = listeners {
+						subscribers.extend(listeners.iter());
+					}
+
+					subscribers.extend(cw.iter());
+
+					if !cw.is_empty() || listeners.is_some() {
+						changes.push((k, v.map(StorageData)));
+					}
+				}
+				if !changes.is_empty() {
+					child_changes.push((sk, changes));
+				}
+			}
+		}
+
+		// Don't send empty notifications
+		if changes.is_empty() && child_changes.is_empty() {
+			return
+		}
+
+		let changes = Arc::<[_]>::from(changes);
+		let child_changes = Arc::<[_]>::from(child_changes);
+
+		// Trigger the events
+		self.sinks.iter_mut().for_each(|(subs_id, sink)| {
+			if subscribers.contains(subs_id) {
+				sink.was_triggered = true;
+
+				let storage_change_set = StorageChangeSet {
+					changes: changes.clone(),
+					child_changes: child_changes.clone(),
+					filter: sink.keys.clone(),
+					child_filters: sink.child_keys.clone(),
+				};
+
+				let notification =
+					StorageNotification { block: hash.clone(), changes: storage_change_set };
+
+				dispatch(subs_id, notification);
+			}
+		});
+	}
+}
+
+impl Registry {
+	fn remove_subscriber(&mut self, subscriber: SubscriberId) -> Option<(Keys, ChildKeys)> {
+		let sink = self.sinks.remove(&subscriber)?;
+
+		Self::remove_subscriber_from(
+			subscriber,
+			&sink.keys,
+			&mut self.listeners,
+			&mut self.wildcard_listeners,
+		);
+		if let Some(child_filters) = &sink.child_keys {
+			for (c_key, filters) in child_filters {
+				if let Some((listeners, wildcards)) = self.child_listeners.get_mut(c_key) {
+					Self::remove_subscriber_from(
+						subscriber,
+						filters,
+						&mut *listeners,
+						&mut *wildcards,
+					);
+
+					if listeners.is_empty() && wildcards.is_empty() {
+						self.child_listeners.remove(c_key);
+					}
+				}
+			}
+		}
+		if let Some(m) = self.metrics.as_ref() {
+			m.with_label_values(&["removed"]).inc();
+		}
+
+		Some((sink.keys.clone(), sink.child_keys.clone()))
+	}
+
+	fn remove_subscriber_from(
+		subscriber: SubscriberId,
+		filters: &Keys,
+		listeners: &mut HashMap<StorageKey, FnvHashSet<SubscriberId>>,
+		wildcards: &mut FnvHashSet<SubscriberId>,
+	) {
+		match filters {
+			None => {
+				wildcards.remove(&subscriber);
+			},
+			Some(filters) =>
+				for key in filters.iter() {
+					let remove_key = match listeners.get_mut(key) {
+						Some(ref mut set) => {
+							set.remove(&subscriber);
+							set.is_empty()
+						},
+						None => false,
+					};
+
+					if remove_key {
+						listeners.remove(key);
+					}
+				},
+		}
+	}
+
+	fn listen_from(
+		current_id: SubscriberId,
+		filter_keys: Option<impl AsRef<[StorageKey]>>,
+		listeners: &mut HashMap<StorageKey, FnvHashSet<SubscriberId>>,
+		wildcards: &mut FnvHashSet<SubscriberId>,
+	) -> Keys {
+		match filter_keys {
+			None => {
+				wildcards.insert(current_id);
+				None
+			},
+			Some(keys) => Some(
+				keys.as_ref()
+					.iter()
+					.map(|key| {
+						listeners.entry(key.clone()).or_default().insert(current_id);
+						key.clone()
+					})
+					.collect(),
+			),
+		}
+	}
+}
+
+pub(super) struct PrintKeys<'a>(pub &'a Keys);
+impl<'a> std::fmt::Debug for PrintKeys<'a> {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		if let Some(keys) = self.0 {
+			fmt.debug_list().entries(keys.iter().map(HexDisplay::from)).finish()
+		} else {
+			write!(fmt, "None")
+		}
+	}
+}
+
+pub(super) struct PrintChildKeys<'a>(pub &'a ChildKeys);
+impl<'a> std::fmt::Debug for PrintChildKeys<'a> {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		if let Some(map) = self.0 {
+			fmt.debug_map()
+				.entries(map.iter().map(|(key, values)| (HexDisplay::from(key), PrintKeys(values))))
+				.finish()
+		} else {
+			write!(fmt, "None")
+		}
+	}
+}
diff --git a/substrate/client/api/src/notifications/tests.rs b/substrate/client/api/src/notifications/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fba829b1cf9020034529b034f52015fb423608d8
--- /dev/null
+++ b/substrate/client/api/src/notifications/tests.rs
@@ -0,0 +1,221 @@
+// 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::*;
+
+use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper, H256 as Hash};
+use std::iter::{empty, Empty};
+
+type TestChangeSet = (
+	Vec<(StorageKey, Option<StorageData>)>,
+	Vec<(StorageKey, Vec<(StorageKey, Option<StorageData>)>)>,
+);
+
+impl From<TestChangeSet> for StorageChangeSet {
+	fn from(changes: TestChangeSet) -> Self {
+		// warning hardcoded child trie wildcard to test upon
+		let child_filters = Some(
+			[(StorageKey(vec![4]), None), (StorageKey(vec![5]), None)]
+				.iter()
+				.cloned()
+				.collect(),
+		);
+		StorageChangeSet {
+			changes: From::from(changes.0),
+			child_changes: From::from(changes.1),
+			filter: None,
+			child_filters,
+		}
+	}
+}
+
+impl PartialEq for StorageChangeSet {
+	fn eq(&self, other: &Self) -> bool {
+		self.iter().eq(other.iter())
+	}
+}
+
+type Block = RawBlock<ExtrinsicWrapper<Hash>>;
+
+#[test]
+fn triggering_change_should_notify_wildcard_listeners() {
+	// given
+	let notifications = StorageNotifications::<Block>::new(None);
+	let child_filter = [(StorageKey(vec![4]), None)];
+	let mut recv =
+		futures::executor::block_on_stream(notifications.listen(None, Some(&child_filter[..])));
+
+	// when
+	let changeset = vec![(vec![2], Some(vec![3])), (vec![3], None)];
+	let c_changeset_1 = vec![(vec![5], Some(vec![4])), (vec![6], None)];
+	let c_changeset = vec![(vec![4], c_changeset_1)];
+	notifications.trigger(
+		&Hash::from_low_u64_be(1),
+		changeset.into_iter(),
+		c_changeset.into_iter().map(|(a, b)| (a, b.into_iter())),
+	);
+
+	// then
+	assert_eq!(
+		recv.next().map(StorageNotification::into_fields).unwrap(),
+		(
+			Hash::from_low_u64_be(1),
+			(
+				vec![
+					(StorageKey(vec![2]), Some(StorageData(vec![3]))),
+					(StorageKey(vec![3]), None),
+				],
+				vec![(
+					StorageKey(vec![4]),
+					vec![
+						(StorageKey(vec![5]), Some(StorageData(vec![4]))),
+						(StorageKey(vec![6]), None),
+					]
+				)]
+			)
+				.into()
+		)
+	);
+}
+
+#[test]
+fn should_only_notify_interested_listeners() {
+	// given
+	let notifications = StorageNotifications::<Block>::new(None);
+	let child_filter = [(StorageKey(vec![4]), Some(vec![StorageKey(vec![5])]))];
+	let mut recv1 = futures::executor::block_on_stream(
+		notifications.listen(Some(&[StorageKey(vec![1])]), None),
+	);
+	let mut recv2 = futures::executor::block_on_stream(
+		notifications.listen(Some(&[StorageKey(vec![2])]), None),
+	);
+	let mut recv3 =
+		futures::executor::block_on_stream(notifications.listen(Some(&[]), Some(&child_filter)));
+
+	// when
+	let changeset = vec![(vec![2], Some(vec![3])), (vec![1], None)];
+	let c_changeset_1 = vec![(vec![5], Some(vec![4])), (vec![6], None)];
+
+	let c_changeset = vec![(vec![4], c_changeset_1)];
+	notifications.trigger(
+		&Hash::from_low_u64_be(1),
+		changeset.into_iter(),
+		c_changeset.into_iter().map(|(a, b)| (a, b.into_iter())),
+	);
+
+	// then
+	assert_eq!(
+		recv1.next().map(StorageNotification::into_fields).unwrap(),
+		(Hash::from_low_u64_be(1), (vec![(StorageKey(vec![1]), None),], vec![]).into())
+	);
+	assert_eq!(
+		recv2.next().map(StorageNotification::into_fields).unwrap(),
+		(
+			Hash::from_low_u64_be(1),
+			(vec![(StorageKey(vec![2]), Some(StorageData(vec![3]))),], vec![]).into()
+		)
+	);
+	assert_eq!(
+		recv3.next().map(StorageNotification::into_fields).unwrap(),
+		(
+			Hash::from_low_u64_be(1),
+			(
+				vec![],
+				vec![(
+					StorageKey(vec![4]),
+					vec![(StorageKey(vec![5]), Some(StorageData(vec![4])))]
+				),]
+			)
+				.into()
+		)
+	);
+}
+
+#[test]
+fn should_cleanup_subscribers_if_dropped() {
+	// given
+	let notifications = StorageNotifications::<Block>::new(None);
+	{
+		let child_filter = [(StorageKey(vec![4]), Some(vec![StorageKey(vec![5])]))];
+		let _recv1 = futures::executor::block_on_stream(
+			notifications.listen(Some(&[StorageKey(vec![1])]), None),
+		);
+		let _recv2 = futures::executor::block_on_stream(
+			notifications.listen(Some(&[StorageKey(vec![2])]), None),
+		);
+		let _recv3 = futures::executor::block_on_stream(notifications.listen(None, None));
+		let _recv4 =
+			futures::executor::block_on_stream(notifications.listen(None, Some(&child_filter)));
+		assert_eq!(notifications.map_registry(|r| r.listeners.len()), 2);
+		assert_eq!(notifications.map_registry(|r| r.wildcard_listeners.len()), 2);
+		assert_eq!(notifications.map_registry(|r| r.child_listeners.len()), 1);
+	}
+
+	// when
+	let changeset = vec![(vec![2], Some(vec![3])), (vec![1], None)];
+	let c_changeset = empty::<(_, Empty<_>)>();
+	notifications.trigger(&Hash::from_low_u64_be(1), changeset.into_iter(), c_changeset);
+
+	// then
+	assert_eq!(notifications.map_registry(|r| r.listeners.len()), 0);
+	assert_eq!(notifications.map_registry(|r| r.wildcard_listeners.len()), 0);
+	assert_eq!(notifications.map_registry(|r| r.child_listeners.len()), 0);
+}
+
+#[test]
+fn should_cleanup_subscriber_if_stream_is_dropped() {
+	let notifications = StorageNotifications::<Block>::new(None);
+	let stream = notifications.listen(None, None);
+	assert_eq!(notifications.map_registry(|r| r.sinks.len()), 1);
+	std::mem::drop(stream);
+	assert_eq!(notifications.map_registry(|r| r.sinks.len()), 0);
+}
+
+#[test]
+fn should_not_send_empty_notifications() {
+	// given
+	let mut recv = {
+		let notifications = StorageNotifications::<Block>::new(None);
+		let recv = futures::executor::block_on_stream(notifications.listen(None, None));
+
+		// when
+		let changeset = vec![];
+		let c_changeset = empty::<(_, Empty<_>)>();
+		notifications.trigger(&Hash::from_low_u64_be(1), changeset.into_iter(), c_changeset);
+		recv
+	};
+
+	// then
+	assert_eq!(recv.next().map(StorageNotification::into_fields), None);
+}
+
+impl<B: BlockT> StorageNotifications<B> {
+	fn map_registry<MapF, Ret>(&self, map: MapF) -> Ret
+	where
+		MapF: FnOnce(&Registry) -> Ret,
+	{
+		self.0.map_registry_for_tests(map)
+	}
+}
+
+impl<H> StorageNotification<H> {
+	fn into_fields(self) -> (H, StorageChangeSet) {
+		let Self { block, changes } = self;
+		(block, changes)
+	}
+}
diff --git a/substrate/client/api/src/proof_provider.rs b/substrate/client/api/src/proof_provider.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7f60f856ae8095b9d8f9e445f479cbb549473074
--- /dev/null
+++ b/substrate/client/api/src/proof_provider.rs
@@ -0,0 +1,93 @@
+// 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/>.
+
+//! Proof utilities
+use crate::{CompactProof, StorageProof};
+use sp_runtime::traits::Block as BlockT;
+use sp_state_machine::{KeyValueStates, KeyValueStorageLevel};
+use sp_storage::ChildInfo;
+
+/// Interface for providing block proving utilities.
+pub trait ProofProvider<Block: BlockT> {
+	/// Reads storage value at a given block + key, returning read proof.
+	fn read_proof(
+		&self,
+		hash: Block::Hash,
+		keys: &mut dyn Iterator<Item = &[u8]>,
+	) -> sp_blockchain::Result<StorageProof>;
+
+	/// Reads child storage value at a given block + storage_key + key, returning
+	/// read proof.
+	fn read_child_proof(
+		&self,
+		hash: Block::Hash,
+		child_info: &ChildInfo,
+		keys: &mut dyn Iterator<Item = &[u8]>,
+	) -> sp_blockchain::Result<StorageProof>;
+
+	/// Execute a call to a contract on top of state in a block of given hash
+	/// AND returning execution proof.
+	///
+	/// No changes are made.
+	fn execution_proof(
+		&self,
+		hash: Block::Hash,
+		method: &str,
+		call_data: &[u8],
+	) -> sp_blockchain::Result<(Vec<u8>, StorageProof)>;
+
+	/// Given a `Hash` iterate over all storage values starting at `start_keys`.
+	/// Last `start_keys` element contains last accessed key value.
+	/// With multiple `start_keys`, first `start_keys` element is
+	/// the current storage key of of the last accessed child trie.
+	/// at last level the value to start at exclusively.
+	/// Proofs is build until size limit is reached and always include at
+	/// least one key following `start_keys`.
+	/// Returns combined proof and the numbers of collected keys.
+	fn read_proof_collection(
+		&self,
+		hash: Block::Hash,
+		start_keys: &[Vec<u8>],
+		size_limit: usize,
+	) -> sp_blockchain::Result<(CompactProof, u32)>;
+
+	/// Given a `Hash` iterate over all storage values starting at `start_key`.
+	/// Returns collected keys and values.
+	/// Returns the collected keys values content of the top trie followed by the
+	/// collected keys values of child tries.
+	/// Only child tries with their root part of the collected content or
+	/// related to `start_key` are attached.
+	/// For each collected state a boolean indicates if state reach
+	/// end.
+	fn storage_collection(
+		&self,
+		hash: Block::Hash,
+		start_key: &[Vec<u8>],
+		size_limit: usize,
+	) -> sp_blockchain::Result<Vec<(KeyValueStorageLevel, bool)>>;
+
+	/// Verify read storage proof for a set of keys.
+	/// Returns collected key-value pairs and a the nested state
+	/// depth of current iteration or 0 if completed.
+	fn verify_range_proof(
+		&self,
+		root: Block::Hash,
+		proof: CompactProof,
+		start_keys: &[Vec<u8>],
+	) -> sp_blockchain::Result<(KeyValueStates, usize)>;
+}
diff --git a/substrate/client/authority-discovery/Cargo.toml b/substrate/client/authority-discovery/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0324cac4669124c2a1239365549ba116a625f3fd
--- /dev/null
+++ b/substrate/client/authority-discovery/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "sc-authority-discovery"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+build = "build.rs"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate authority discovery."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[build-dependencies]
+prost-build = "0.11"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+futures = "0.3.21"
+futures-timer = "3.0.1"
+ip_network = "0.4.1"
+libp2p = { version = "0.51.3", features = ["kad", "ed25519"] }
+multihash = { version = "0.17.0", default-features = false, features = ["std", "sha2"] }
+log = "0.4.17"
+prost = "0.11"
+rand = "0.8.5"
+thiserror = "1.0"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-network = { version = "0.10.0-dev", path = "../network/" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-authority-discovery = { version = "4.0.0-dev", path = "../../primitives/authority-discovery" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+async-trait = "0.1.56"
+
+[dev-dependencies]
+quickcheck = { version = "1.0.3", default-features = false }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
diff --git a/substrate/client/authority-discovery/README.md b/substrate/client/authority-discovery/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..042e8f5982cd0ee05538274de1fa7ab0f366c346
--- /dev/null
+++ b/substrate/client/authority-discovery/README.md
@@ -0,0 +1,9 @@
+# Substrate authority discovery
+
+This crate enables Substrate authorities to discover and directly connect to
+other authorities. It is split into two components the [`Worker`] and the
+[`Service`].
+
+See [`Worker`] and [`Service`] for more documentation.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
diff --git a/substrate/client/authority-discovery/build.rs b/substrate/client/authority-discovery/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..00d45f07ae159c3f15d6ea822d02f6dcd75ef2e0
--- /dev/null
+++ b/substrate/client/authority-discovery/build.rs
@@ -0,0 +1,7 @@
+fn main() {
+	prost_build::compile_protos(
+		&["src/worker/schema/dht-v1.proto", "src/worker/schema/dht-v2.proto"],
+		&["src/worker/schema"],
+	)
+	.unwrap();
+}
diff --git a/substrate/client/authority-discovery/src/error.rs b/substrate/client/authority-discovery/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ca685115d49754d400afb2676db110549b53c73b
--- /dev/null
+++ b/substrate/client/authority-discovery/src/error.rs
@@ -0,0 +1,78 @@
+// 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/>.
+
+//! Authority discovery errors.
+
+/// AuthorityDiscovery Result.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Error type for the authority discovery module.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+	#[error("Received dht value found event with records with different keys.")]
+	ReceivingDhtValueFoundEventWithDifferentKeys,
+
+	#[error("Received dht value found event with no records.")]
+	ReceivingDhtValueFoundEventWithNoRecords,
+
+	#[error("Failed to verify a dht payload with the given signature.")]
+	VerifyingDhtPayload,
+
+	#[error("Failed to hash the authority id to be used as a dht key.")]
+	HashingAuthorityId(#[from] libp2p::core::multiaddr::multihash::Error),
+
+	#[error("Failed calling into the Substrate runtime: {0}")]
+	CallingRuntime(#[from] sp_blockchain::Error),
+
+	#[error("Received a dht record with a key that does not match any in-flight awaited keys.")]
+	ReceivingUnexpectedRecord,
+
+	#[error("Failed to encode a protobuf payload.")]
+	EncodingProto(#[from] prost::EncodeError),
+
+	#[error("Failed to decode a protobuf payload.")]
+	DecodingProto(#[from] prost::DecodeError),
+
+	#[error("Failed to encode or decode scale payload.")]
+	EncodingDecodingScale(#[from] codec::Error),
+
+	#[error("Failed to parse a libp2p multi address.")]
+	ParsingMultiaddress(#[from] libp2p::core::multiaddr::Error),
+
+	#[error("Failed to parse a libp2p key.")]
+	ParsingLibp2pIdentity(#[from] libp2p::identity::DecodingError),
+
+	#[error("Failed to sign: {0}.")]
+	CannotSign(String),
+
+	#[error("Failed to register Prometheus metric.")]
+	Prometheus(#[from] prometheus_endpoint::PrometheusError),
+
+	#[error("Received authority record that contains addresses with multiple peer ids")]
+	ReceivingDhtValueFoundEventWithDifferentPeerIds,
+
+	#[error("Received authority record without any addresses having a peer id")]
+	ReceivingDhtValueFoundEventWithNoPeerIds,
+
+	#[error("Received authority record without a valid signature for the remote peer id.")]
+	MissingPeerIdSignature,
+
+	#[error("Unable to fetch best block.")]
+	BestBlockFetchingError,
+}
diff --git a/substrate/client/authority-discovery/src/interval.rs b/substrate/client/authority-discovery/src/interval.rs
new file mode 100644
index 0000000000000000000000000000000000000000..23c7ce266e3bf8c13485f78dac6d4bb848ef4612
--- /dev/null
+++ b/substrate/client/authority-discovery/src/interval.rs
@@ -0,0 +1,60 @@
+// 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 futures::{future::FutureExt, ready, stream::Stream};
+use futures_timer::Delay;
+use std::{
+	pin::Pin,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+/// Exponentially increasing interval
+///
+/// Doubles interval duration on each tick until the configured maximum is reached.
+pub struct ExpIncInterval {
+	max: Duration,
+	next: Duration,
+	delay: Delay,
+}
+
+impl ExpIncInterval {
+	/// Create a new [`ExpIncInterval`].
+	pub fn new(start: Duration, max: Duration) -> Self {
+		let delay = Delay::new(start);
+		Self { max, next: start * 2, delay }
+	}
+
+	/// Fast forward the exponentially increasing interval to the configured maximum.
+	pub fn set_to_max(&mut self) {
+		self.next = self.max;
+		self.delay = Delay::new(self.next);
+	}
+}
+
+impl Stream for ExpIncInterval {
+	type Item = ();
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		ready!(self.delay.poll_unpin(cx));
+		self.delay = Delay::new(self.next);
+		self.next = std::cmp::min(self.max, self.next * 2);
+
+		Poll::Ready(Some(()))
+	}
+}
diff --git a/substrate/client/authority-discovery/src/lib.rs b/substrate/client/authority-discovery/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6bb12804cada34d1b3f87b4249fc466fcf253a9a
--- /dev/null
+++ b/substrate/client/authority-discovery/src/lib.rs
@@ -0,0 +1,170 @@
+// 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/>.
+
+#![warn(missing_docs)]
+#![recursion_limit = "1024"]
+
+//! Substrate authority discovery.
+//!
+//! This crate enables Substrate authorities to discover and directly connect to
+//! other authorities. It is split into two components the [`Worker`] and the
+//! [`Service`].
+//!
+//! See [`Worker`] and [`Service`] for more documentation.
+
+pub use crate::{
+	error::Error,
+	service::Service,
+	worker::{AuthorityDiscovery, NetworkProvider, Role, Worker},
+};
+
+use std::{collections::HashSet, sync::Arc, time::Duration};
+
+use futures::{
+	channel::{mpsc, oneshot},
+	Stream,
+};
+
+use libp2p::{Multiaddr, PeerId};
+use sc_network::event::DhtEvent;
+use sp_authority_discovery::AuthorityId;
+use sp_blockchain::HeaderBackend;
+use sp_runtime::traits::Block as BlockT;
+
+mod error;
+mod interval;
+mod service;
+mod worker;
+
+#[cfg(test)]
+mod tests;
+
+/// Configuration of [`Worker`].
+pub struct WorkerConfig {
+	/// The maximum interval in which the node will publish its own address on the DHT.
+	///
+	/// By default this is set to 1 hour.
+	pub max_publish_interval: Duration,
+
+	/// Interval at which the keystore is queried. If the keys have changed, unconditionally
+	/// re-publish its addresses on the DHT.
+	///
+	/// By default this is set to 1 minute.
+	pub keystore_refresh_interval: Duration,
+
+	/// The maximum interval in which the node will query the DHT for new entries.
+	///
+	/// By default this is set to 10 minutes.
+	pub max_query_interval: Duration,
+
+	/// If `false`, the node won't publish on the DHT multiaddresses that contain non-global
+	/// IP addresses (such as 10.0.0.1).
+	///
+	/// Recommended: `false` for live chains, and `true` for local chains or for testing.
+	///
+	/// Defaults to `true` to avoid the surprise factor.
+	pub publish_non_global_ips: bool,
+
+	/// Reject authority discovery records that are not signed by their network identity (PeerId)
+	///
+	/// Defaults to `false` to provide compatibility with old versions
+	pub strict_record_validation: bool,
+}
+
+impl Default for WorkerConfig {
+	fn default() -> Self {
+		Self {
+			// Kademlia's default time-to-live for Dht records is 36h, republishing records every
+			// 24h through libp2p-kad. Given that a node could restart at any point in time, one can
+			// not depend on the republishing process, thus publishing own external addresses should
+			// happen on an interval < 36h.
+			max_publish_interval: Duration::from_secs(1 * 60 * 60),
+			keystore_refresh_interval: Duration::from_secs(60),
+			// External addresses of remote authorities can change at any given point in time. The
+			// interval on which to trigger new queries for the current and next authorities is a
+			// trade off between efficiency and performance.
+			//
+			// Querying 700 [`AuthorityId`]s takes ~8m on the Kusama DHT (16th Nov 2020) when
+			// comparing `authority_discovery_authority_addresses_requested_total` and
+			// `authority_discovery_dht_event_received`.
+			max_query_interval: Duration::from_secs(10 * 60),
+			publish_non_global_ips: true,
+			strict_record_validation: false,
+		}
+	}
+}
+
+/// Create a new authority discovery [`Worker`] and [`Service`].
+///
+/// See the struct documentation of each for more details.
+pub fn new_worker_and_service<Client, Network, Block, DhtEventStream>(
+	client: Arc<Client>,
+	network: Arc<Network>,
+	dht_event_rx: DhtEventStream,
+	role: Role,
+	prometheus_registry: Option<prometheus_endpoint::Registry>,
+) -> (Worker<Client, Network, Block, DhtEventStream>, Service)
+where
+	Block: BlockT + Unpin + 'static,
+	Network: NetworkProvider,
+	Client: AuthorityDiscovery<Block> + Send + Sync + 'static + HeaderBackend<Block>,
+	DhtEventStream: Stream<Item = DhtEvent> + Unpin,
+{
+	new_worker_and_service_with_config(
+		Default::default(),
+		client,
+		network,
+		dht_event_rx,
+		role,
+		prometheus_registry,
+	)
+}
+
+/// Same as [`new_worker_and_service`] but with support for providing the `config`.
+///
+/// When in doubt use [`new_worker_and_service`] as it will use the default configuration.
+pub fn new_worker_and_service_with_config<Client, Network, Block, DhtEventStream>(
+	config: WorkerConfig,
+	client: Arc<Client>,
+	network: Arc<Network>,
+	dht_event_rx: DhtEventStream,
+	role: Role,
+	prometheus_registry: Option<prometheus_endpoint::Registry>,
+) -> (Worker<Client, Network, Block, DhtEventStream>, Service)
+where
+	Block: BlockT + Unpin + 'static,
+	Network: NetworkProvider,
+	Client: AuthorityDiscovery<Block> + 'static,
+	DhtEventStream: Stream<Item = DhtEvent> + Unpin,
+{
+	let (to_worker, from_service) = mpsc::channel(0);
+
+	let worker =
+		Worker::new(from_service, client, network, dht_event_rx, role, prometheus_registry, config);
+	let service = Service::new(to_worker);
+
+	(worker, service)
+}
+
+/// Message send from the [`Service`] to the [`Worker`].
+pub(crate) enum ServicetoWorkerMsg {
+	/// See [`Service::get_addresses_by_authority_id`].
+	GetAddressesByAuthorityId(AuthorityId, oneshot::Sender<Option<HashSet<Multiaddr>>>),
+	/// See [`Service::get_authority_ids_by_peer_id`].
+	GetAuthorityIdsByPeerId(PeerId, oneshot::Sender<Option<HashSet<AuthorityId>>>),
+}
diff --git a/substrate/client/authority-discovery/src/service.rs b/substrate/client/authority-discovery/src/service.rs
new file mode 100644
index 0000000000000000000000000000000000000000..89ae058d17f7adeac08c2faeec959694061a3ff0
--- /dev/null
+++ b/substrate/client/authority-discovery/src/service.rs
@@ -0,0 +1,94 @@
+// 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 std::{collections::HashSet, fmt::Debug};
+
+use crate::ServicetoWorkerMsg;
+
+use futures::{
+	channel::{mpsc, oneshot},
+	SinkExt,
+};
+
+use libp2p::{Multiaddr, PeerId};
+use sp_authority_discovery::AuthorityId;
+
+/// Service to interact with the [`crate::Worker`].
+#[derive(Clone)]
+pub struct Service {
+	to_worker: mpsc::Sender<ServicetoWorkerMsg>,
+}
+
+impl Debug for Service {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		f.debug_tuple("AuthorityDiscoveryService").finish()
+	}
+}
+
+/// A [`Service`] allows to interact with a [`crate::Worker`], e.g. by querying the
+/// [`crate::Worker`]'s local address cache for a given [`AuthorityId`].
+impl Service {
+	pub(crate) fn new(to_worker: mpsc::Sender<ServicetoWorkerMsg>) -> Self {
+		Self { to_worker }
+	}
+
+	/// Get the addresses for the given [`AuthorityId`] from the local address
+	/// cache.
+	///
+	/// Returns `None` if no entry was present or connection to the
+	/// [`crate::Worker`] failed.
+	///
+	/// Note: [`Multiaddr`]s returned always include a [`PeerId`] via a
+	/// [`libp2p::core::multiaddr::Protocol::P2p`] component. Equality of
+	/// [`PeerId`]s across [`Multiaddr`]s returned by a single call is not
+	/// enforced today, given that there are still authorities out there
+	/// publishing the addresses of their sentry nodes on the DHT. In the future
+	/// this guarantee can be provided.
+	pub async fn get_addresses_by_authority_id(
+		&mut self,
+		authority: AuthorityId,
+	) -> Option<HashSet<Multiaddr>> {
+		let (tx, rx) = oneshot::channel();
+
+		self.to_worker
+			.send(ServicetoWorkerMsg::GetAddressesByAuthorityId(authority, tx))
+			.await
+			.ok()?;
+
+		rx.await.ok().flatten()
+	}
+
+	/// Get the [`AuthorityId`] for the given [`PeerId`] from the local address
+	/// cache.
+	///
+	/// Returns `None` if no entry was present or connection to the
+	/// [`crate::Worker`] failed.
+	pub async fn get_authority_ids_by_peer_id(
+		&mut self,
+		peer_id: PeerId,
+	) -> Option<HashSet<AuthorityId>> {
+		let (tx, rx) = oneshot::channel();
+
+		self.to_worker
+			.send(ServicetoWorkerMsg::GetAuthorityIdsByPeerId(peer_id, tx))
+			.await
+			.ok()?;
+
+		rx.await.ok().flatten()
+	}
+}
diff --git a/substrate/client/authority-discovery/src/tests.rs b/substrate/client/authority-discovery/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4fbc196c5ecd1bb4c4eafd3850a8e2754de91963
--- /dev/null
+++ b/substrate/client/authority-discovery/src/tests.rs
@@ -0,0 +1,108 @@
+// 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::{
+	new_worker_and_service,
+	worker::{
+		tests::{TestApi, TestNetwork},
+		Role,
+	},
+};
+
+use futures::{channel::mpsc::channel, executor::LocalPool, task::LocalSpawn};
+use libp2p::{
+	core::multiaddr::{Multiaddr, Protocol},
+	identity::ed25519,
+	PeerId,
+};
+use std::{collections::HashSet, sync::Arc};
+
+use sp_authority_discovery::AuthorityId;
+use sp_core::crypto::key_types;
+use sp_keystore::{testing::MemoryKeystore, Keystore};
+
+#[test]
+fn get_addresses_and_authority_id() {
+	let (_dht_event_tx, dht_event_rx) = channel(0);
+	let network: Arc<TestNetwork> = Arc::new(Default::default());
+
+	let mut pool = LocalPool::new();
+
+	let key_store = MemoryKeystore::new();
+
+	let remote_authority_id: AuthorityId = pool.run_until(async {
+		key_store
+			.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
+			.unwrap()
+			.into()
+	});
+
+	let remote_peer_id = PeerId::random();
+	let remote_addr = "/ip6/2001:db8:0:0:0:0:0:2/tcp/30333"
+		.parse::<Multiaddr>()
+		.unwrap()
+		.with(Protocol::P2p(remote_peer_id.into()));
+
+	let test_api = Arc::new(TestApi { authorities: vec![] });
+
+	let (mut worker, mut service) = new_worker_and_service(
+		test_api,
+		network.clone(),
+		Box::pin(dht_event_rx),
+		Role::PublishAndDiscover(key_store.into()),
+		None,
+	);
+	worker.inject_addresses(remote_authority_id.clone(), vec![remote_addr.clone()]);
+
+	pool.spawner().spawn_local_obj(Box::pin(worker.run()).into()).unwrap();
+
+	pool.run_until(async {
+		assert_eq!(
+			Some(HashSet::from([remote_addr])),
+			service.get_addresses_by_authority_id(remote_authority_id.clone()).await,
+		);
+		assert_eq!(
+			Some(HashSet::from([remote_authority_id])),
+			service.get_authority_ids_by_peer_id(remote_peer_id).await,
+		);
+	});
+}
+
+#[test]
+fn cryptos_are_compatible() {
+	use sp_core::crypto::Pair;
+
+	let libp2p_keypair = ed25519::Keypair::generate();
+	let libp2p_public = libp2p_keypair.public();
+
+	let sp_core_secret =
+		{ sp_core::ed25519::Pair::from_seed_slice(&libp2p_keypair.secret().as_ref()).unwrap() };
+	let sp_core_public = sp_core_secret.public();
+
+	let message = b"we are more powerful than not to be better";
+
+	let libp2p_signature = libp2p_keypair.sign(message);
+	let sp_core_signature = sp_core_secret.sign(message); // no error expected...
+
+	assert!(sp_core::ed25519::Pair::verify(
+		&sp_core::ed25519::Signature::from_slice(&libp2p_signature).unwrap(),
+		message,
+		&sp_core_public
+	));
+	assert!(libp2p_public.verify(message, sp_core_signature.as_ref()));
+}
diff --git a/substrate/client/authority-discovery/src/worker.rs b/substrate/client/authority-discovery/src/worker.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a29e74df9accc98c50bdf1608612543299936efa
--- /dev/null
+++ b/substrate/client/authority-discovery/src/worker.rs
@@ -0,0 +1,777 @@
+// 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::{
+	error::{Error, Result},
+	interval::ExpIncInterval,
+	ServicetoWorkerMsg, WorkerConfig,
+};
+
+use std::{
+	collections::{HashMap, HashSet},
+	marker::PhantomData,
+	sync::Arc,
+	time::Duration,
+};
+
+use futures::{channel::mpsc, future, stream::Fuse, FutureExt, Stream, StreamExt};
+
+use addr_cache::AddrCache;
+use codec::{Decode, Encode};
+use ip_network::IpNetwork;
+use libp2p::{core::multiaddr, identity::PublicKey, multihash::Multihash, Multiaddr, PeerId};
+use multihash::{Code, MultihashDigest};
+
+use log::{debug, error, log_enabled};
+use prometheus_endpoint::{register, Counter, CounterVec, Gauge, Opts, U64};
+use prost::Message;
+use rand::{seq::SliceRandom, thread_rng};
+
+use sc_network::{
+	event::DhtEvent, KademliaKey, NetworkDHTProvider, NetworkSigner, NetworkStateInfo, Signature,
+};
+use sp_api::{ApiError, ProvideRuntimeApi};
+use sp_authority_discovery::{
+	AuthorityDiscoveryApi, AuthorityId, AuthorityPair, AuthoritySignature,
+};
+use sp_blockchain::HeaderBackend;
+use sp_core::crypto::{key_types, ByteArray, Pair};
+use sp_keystore::{Keystore, KeystorePtr};
+use sp_runtime::traits::Block as BlockT;
+
+mod addr_cache;
+/// Dht payload schemas generated from Protobuf definitions via Prost crate in build.rs.
+mod schema {
+	#[cfg(test)]
+	mod tests;
+
+	include!(concat!(env!("OUT_DIR"), "/authority_discovery_v2.rs"));
+}
+#[cfg(test)]
+pub mod tests;
+
+const LOG_TARGET: &str = "sub-authority-discovery";
+
+/// Maximum number of addresses cached per authority. Additional addresses are discarded.
+const MAX_ADDRESSES_PER_AUTHORITY: usize = 10;
+
+/// Maximum number of in-flight DHT lookups at any given point in time.
+const MAX_IN_FLIGHT_LOOKUPS: usize = 8;
+
+/// Role an authority discovery [`Worker`] can run as.
+pub enum Role {
+	/// Publish own addresses and discover addresses of others.
+	PublishAndDiscover(KeystorePtr),
+	/// Discover addresses of others.
+	Discover,
+}
+
+/// An authority discovery [`Worker`] can publish the local node's addresses as well as discover
+/// those of other nodes via a Kademlia DHT.
+///
+/// When constructed with [`Role::PublishAndDiscover`] a [`Worker`] will
+///
+///    1. Retrieve its external addresses (including peer id).
+///
+///    2. Get the list of keys owned by the local node participating in the current authority set.
+///
+///    3. Sign the addresses with the keys.
+///
+///    4. Put addresses and signature as a record with the authority id as a key on a Kademlia DHT.
+///
+/// When constructed with either [`Role::PublishAndDiscover`] or [`Role::Discover`] a [`Worker`]
+/// will
+///
+///    1. Retrieve the current and next set of authorities.
+///
+///    2. Start DHT queries for the ids of the authorities.
+///
+///    3. Validate the signatures of the retrieved key value pairs.
+///
+///    4. Add the retrieved external addresses as priority nodes to the
+///    network peerset.
+///
+///    5. Allow querying of the collected addresses via the [`crate::Service`].
+pub struct Worker<Client, Network, Block, DhtEventStream> {
+	/// Channel receiver for messages send by a [`crate::Service`].
+	from_service: Fuse<mpsc::Receiver<ServicetoWorkerMsg>>,
+
+	client: Arc<Client>,
+
+	network: Arc<Network>,
+
+	/// Channel we receive Dht events on.
+	dht_event_rx: DhtEventStream,
+
+	/// Interval to be proactive, publishing own addresses.
+	publish_interval: ExpIncInterval,
+	/// Pro-actively publish our own addresses at this interval, if the keys in the keystore
+	/// have changed.
+	publish_if_changed_interval: ExpIncInterval,
+	/// List of keys onto which addresses have been published at the latest publication.
+	/// Used to check whether they have changed.
+	latest_published_keys: HashSet<AuthorityId>,
+	/// Same value as in the configuration.
+	publish_non_global_ips: bool,
+	/// Same value as in the configuration.
+	strict_record_validation: bool,
+
+	/// Interval at which to request addresses of authorities, refilling the pending lookups queue.
+	query_interval: ExpIncInterval,
+
+	/// Queue of throttled lookups pending to be passed to the network.
+	pending_lookups: Vec<AuthorityId>,
+	/// Set of in-flight lookups.
+	in_flight_lookups: HashMap<KademliaKey, AuthorityId>,
+
+	addr_cache: addr_cache::AddrCache,
+
+	metrics: Option<Metrics>,
+
+	role: Role,
+
+	phantom: PhantomData<Block>,
+}
+
+/// Wrapper for [`AuthorityDiscoveryApi`](sp_authority_discovery::AuthorityDiscoveryApi). Can be
+/// be implemented by any struct without dependency on the runtime.
+#[async_trait::async_trait]
+pub trait AuthorityDiscovery<Block: BlockT> {
+	/// Retrieve authority identifiers of the current and next authority set.
+	async fn authorities(&self, at: Block::Hash)
+		-> std::result::Result<Vec<AuthorityId>, ApiError>;
+
+	/// Retrieve best block hash
+	async fn best_hash(&self) -> std::result::Result<Block::Hash, Error>;
+}
+
+#[async_trait::async_trait]
+impl<Block, T> AuthorityDiscovery<Block> for T
+where
+	T: ProvideRuntimeApi<Block> + HeaderBackend<Block> + Send + Sync,
+	T::Api: AuthorityDiscoveryApi<Block>,
+	Block: BlockT,
+{
+	async fn authorities(
+		&self,
+		at: Block::Hash,
+	) -> std::result::Result<Vec<AuthorityId>, ApiError> {
+		self.runtime_api().authorities(at)
+	}
+
+	async fn best_hash(&self) -> std::result::Result<Block::Hash, Error> {
+		Ok(self.info().best_hash)
+	}
+}
+
+impl<Client, Network, Block, DhtEventStream> Worker<Client, Network, Block, DhtEventStream>
+where
+	Block: BlockT + Unpin + 'static,
+	Network: NetworkProvider,
+	Client: AuthorityDiscovery<Block> + 'static,
+	DhtEventStream: Stream<Item = DhtEvent> + Unpin,
+{
+	/// Construct a [`Worker`].
+	pub(crate) fn new(
+		from_service: mpsc::Receiver<ServicetoWorkerMsg>,
+		client: Arc<Client>,
+		network: Arc<Network>,
+		dht_event_rx: DhtEventStream,
+		role: Role,
+		prometheus_registry: Option<prometheus_endpoint::Registry>,
+		config: WorkerConfig,
+	) -> Self {
+		// When a node starts up publishing and querying might fail due to various reasons, for
+		// example due to being not yet fully bootstrapped on the DHT. Thus one should retry rather
+		// sooner than later. On the other hand, a long running node is likely well connected and
+		// thus timely retries are not needed. For this reasoning use an exponentially increasing
+		// interval for `publish_interval`, `query_interval` and `priority_group_set_interval`
+		// instead of a constant interval.
+		let publish_interval =
+			ExpIncInterval::new(Duration::from_secs(2), config.max_publish_interval);
+		let query_interval = ExpIncInterval::new(Duration::from_secs(2), config.max_query_interval);
+
+		// An `ExpIncInterval` is overkill here because the interval is constant, but consistency
+		// is more simple.
+		let publish_if_changed_interval =
+			ExpIncInterval::new(config.keystore_refresh_interval, config.keystore_refresh_interval);
+
+		let addr_cache = AddrCache::new();
+
+		let metrics = match prometheus_registry {
+			Some(registry) => match Metrics::register(&registry) {
+				Ok(metrics) => Some(metrics),
+				Err(e) => {
+					error!(target: LOG_TARGET, "Failed to register metrics: {}", e);
+					None
+				},
+			},
+			None => None,
+		};
+
+		Worker {
+			from_service: from_service.fuse(),
+			client,
+			network,
+			dht_event_rx,
+			publish_interval,
+			publish_if_changed_interval,
+			latest_published_keys: HashSet::new(),
+			publish_non_global_ips: config.publish_non_global_ips,
+			strict_record_validation: config.strict_record_validation,
+			query_interval,
+			pending_lookups: Vec::new(),
+			in_flight_lookups: HashMap::new(),
+			addr_cache,
+			role,
+			metrics,
+			phantom: PhantomData,
+		}
+	}
+
+	/// Start the worker
+	pub async fn run(mut self) {
+		loop {
+			self.start_new_lookups();
+
+			futures::select! {
+				// Process incoming events.
+				event = self.dht_event_rx.next().fuse() => {
+					if let Some(event) = event {
+						self.handle_dht_event(event).await;
+					} else {
+						// This point is reached if the network has shut down, at which point there is not
+						// much else to do than to shut down the authority discovery as well.
+						return;
+					}
+				},
+				// Handle messages from [`Service`]. Ignore if sender side is closed.
+				msg = self.from_service.select_next_some() => {
+					self.process_message_from_service(msg);
+				},
+				// Publish own addresses.
+				only_if_changed = future::select(
+					self.publish_interval.next().map(|_| false),
+					self.publish_if_changed_interval.next().map(|_| true)
+				).map(|e| e.factor_first().0).fuse() => {
+					if let Err(e) = self.publish_ext_addresses(only_if_changed).await {
+						error!(
+							target: LOG_TARGET,
+							"Failed to publish external addresses: {}", e,
+						);
+					}
+				},
+				// Request addresses of authorities.
+				_ = self.query_interval.next().fuse() => {
+					if let Err(e) = self.refill_pending_lookups_queue().await {
+						error!(
+							target: LOG_TARGET,
+							"Failed to request addresses of authorities: {}", e,
+						);
+					}
+				},
+			}
+		}
+	}
+
+	fn process_message_from_service(&self, msg: ServicetoWorkerMsg) {
+		match msg {
+			ServicetoWorkerMsg::GetAddressesByAuthorityId(authority, sender) => {
+				let _ = sender.send(
+					self.addr_cache.get_addresses_by_authority_id(&authority).map(Clone::clone),
+				);
+			},
+			ServicetoWorkerMsg::GetAuthorityIdsByPeerId(peer_id, sender) => {
+				let _ = sender
+					.send(self.addr_cache.get_authority_ids_by_peer_id(&peer_id).map(Clone::clone));
+			},
+		}
+	}
+
+	fn addresses_to_publish(&self) -> impl Iterator<Item = Multiaddr> {
+		let peer_id: Multihash = self.network.local_peer_id().into();
+		let publish_non_global_ips = self.publish_non_global_ips;
+		self.network
+			.external_addresses()
+			.into_iter()
+			.filter(move |a| {
+				if publish_non_global_ips {
+					return true
+				}
+
+				a.iter().all(|p| match p {
+					// The `ip_network` library is used because its `is_global()` method is stable,
+					// while `is_global()` in the standard library currently isn't.
+					multiaddr::Protocol::Ip4(ip) if !IpNetwork::from(ip).is_global() => false,
+					multiaddr::Protocol::Ip6(ip) if !IpNetwork::from(ip).is_global() => false,
+					_ => true,
+				})
+			})
+			.map(move |a| {
+				if a.iter().any(|p| matches!(p, multiaddr::Protocol::P2p(_))) {
+					a
+				} else {
+					a.with(multiaddr::Protocol::P2p(peer_id))
+				}
+			})
+	}
+
+	/// Publish own public addresses.
+	///
+	/// If `only_if_changed` is true, the function has no effect if the list of keys to publish
+	/// is equal to `self.latest_published_keys`.
+	async fn publish_ext_addresses(&mut self, only_if_changed: bool) -> Result<()> {
+		let key_store = match &self.role {
+			Role::PublishAndDiscover(key_store) => key_store,
+			Role::Discover => return Ok(()),
+		};
+
+		let keys = Worker::<Client, Network, Block, DhtEventStream>::get_own_public_keys_within_authority_set(
+			key_store.clone(),
+			self.client.as_ref(),
+		).await?.into_iter().collect::<HashSet<_>>();
+
+		if only_if_changed && keys == self.latest_published_keys {
+			return Ok(())
+		}
+
+		let addresses = serialize_addresses(self.addresses_to_publish());
+
+		if let Some(metrics) = &self.metrics {
+			metrics.publish.inc();
+			metrics
+				.amount_addresses_last_published
+				.set(addresses.len().try_into().unwrap_or(std::u64::MAX));
+		}
+
+		let serialized_record = serialize_authority_record(addresses)?;
+		let peer_signature = sign_record_with_peer_id(&serialized_record, self.network.as_ref())?;
+
+		let keys_vec = keys.iter().cloned().collect::<Vec<_>>();
+
+		let kv_pairs = sign_record_with_authority_ids(
+			serialized_record,
+			Some(peer_signature),
+			key_store.as_ref(),
+			keys_vec,
+		)?;
+
+		for (key, value) in kv_pairs.into_iter() {
+			self.network.put_value(key, value);
+		}
+
+		self.latest_published_keys = keys;
+
+		Ok(())
+	}
+
+	async fn refill_pending_lookups_queue(&mut self) -> Result<()> {
+		let best_hash = self.client.best_hash().await?;
+
+		let local_keys = match &self.role {
+			Role::PublishAndDiscover(key_store) => key_store
+				.sr25519_public_keys(key_types::AUTHORITY_DISCOVERY)
+				.into_iter()
+				.collect::<HashSet<_>>(),
+			Role::Discover => HashSet::new(),
+		};
+
+		let mut authorities = self
+			.client
+			.authorities(best_hash)
+			.await
+			.map_err(|e| Error::CallingRuntime(e.into()))?
+			.into_iter()
+			.filter(|id| !local_keys.contains(id.as_ref()))
+			.collect::<Vec<_>>();
+
+		self.addr_cache.retain_ids(&authorities);
+
+		authorities.shuffle(&mut thread_rng());
+		self.pending_lookups = authorities;
+		// Ignore all still in-flight lookups. Those that are still in-flight are likely stalled as
+		// query interval ticks are far enough apart for all lookups to succeed.
+		self.in_flight_lookups.clear();
+
+		if let Some(metrics) = &self.metrics {
+			metrics
+				.requests_pending
+				.set(self.pending_lookups.len().try_into().unwrap_or(std::u64::MAX));
+		}
+
+		Ok(())
+	}
+
+	fn start_new_lookups(&mut self) {
+		while self.in_flight_lookups.len() < MAX_IN_FLIGHT_LOOKUPS {
+			let authority_id = match self.pending_lookups.pop() {
+				Some(authority) => authority,
+				None => return,
+			};
+			let hash = hash_authority_id(authority_id.as_ref());
+			self.network.get_value(&hash);
+			self.in_flight_lookups.insert(hash, authority_id);
+
+			if let Some(metrics) = &self.metrics {
+				metrics.requests.inc();
+				metrics
+					.requests_pending
+					.set(self.pending_lookups.len().try_into().unwrap_or(std::u64::MAX));
+			}
+		}
+	}
+
+	/// Handle incoming Dht events.
+	async fn handle_dht_event(&mut self, event: DhtEvent) {
+		match event {
+			DhtEvent::ValueFound(v) => {
+				if let Some(metrics) = &self.metrics {
+					metrics.dht_event_received.with_label_values(&["value_found"]).inc();
+				}
+
+				if log_enabled!(log::Level::Debug) {
+					let hashes: Vec<_> = v.iter().map(|(hash, _value)| hash.clone()).collect();
+					debug!(target: LOG_TARGET, "Value for hash '{:?}' found on Dht.", hashes);
+				}
+
+				if let Err(e) = self.handle_dht_value_found_event(v) {
+					if let Some(metrics) = &self.metrics {
+						metrics.handle_value_found_event_failure.inc();
+					}
+
+					debug!(target: LOG_TARGET, "Failed to handle Dht value found event: {}", e);
+				}
+			},
+			DhtEvent::ValueNotFound(hash) => {
+				if let Some(metrics) = &self.metrics {
+					metrics.dht_event_received.with_label_values(&["value_not_found"]).inc();
+				}
+
+				if self.in_flight_lookups.remove(&hash).is_some() {
+					debug!(target: LOG_TARGET, "Value for hash '{:?}' not found on Dht.", hash)
+				} else {
+					debug!(
+						target: LOG_TARGET,
+						"Received 'ValueNotFound' for unexpected hash '{:?}'.", hash
+					)
+				}
+			},
+			DhtEvent::ValuePut(hash) => {
+				// Fast forward the exponentially increasing interval to the configured maximum. In
+				// case this was the first successful address publishing there is no need for a
+				// timely retry.
+				self.publish_interval.set_to_max();
+
+				if let Some(metrics) = &self.metrics {
+					metrics.dht_event_received.with_label_values(&["value_put"]).inc();
+				}
+
+				debug!(target: LOG_TARGET, "Successfully put hash '{:?}' on Dht.", hash)
+			},
+			DhtEvent::ValuePutFailed(hash) => {
+				if let Some(metrics) = &self.metrics {
+					metrics.dht_event_received.with_label_values(&["value_put_failed"]).inc();
+				}
+
+				debug!(target: LOG_TARGET, "Failed to put hash '{:?}' on Dht.", hash)
+			},
+		}
+	}
+
+	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()))
+			.map_err(|_| Error::ReceivingDhtValueFoundEventWithDifferentKeys)?
+			.ok_or(Error::ReceivingDhtValueFoundEventWithNoRecords)?;
+
+		let authority_id: AuthorityId = self
+			.in_flight_lookups
+			.remove(&remote_key)
+			.ok_or(Error::ReceivingUnexpectedRecord)?;
+
+		let local_peer_id = self.network.local_peer_id();
+
+		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 addresses: Vec<Multiaddr> = schema::AuthorityRecord::decode(record.as_slice())
+					.map(|a| a.addresses)
+					.map_err(Error::DecodingProto)?
+					.into_iter()
+					.map(|a| a.try_into())
+					.collect::<std::result::Result<_, _>>()
+					.map_err(Error::ParsingMultiaddress)?;
+
+				let get_peer_id = |a: &Multiaddr| match a.iter().last() {
+					Some(multiaddr::Protocol::P2p(key)) => PeerId::from_multihash(key).ok(),
+					_ => None,
+				};
+
+				// Ignore [`Multiaddr`]s without [`PeerId`] or with own addresses.
+				let addresses: Vec<Multiaddr> = addresses
+					.into_iter()
+					.filter(|a| get_peer_id(a).filter(|p| *p != local_peer_id).is_some())
+					.collect();
+
+				let remote_peer_id = single(addresses.iter().map(get_peer_id))
+					.map_err(|_| Error::ReceivingDhtValueFoundEventWithDifferentPeerIds)? // different peer_id in records
+					.flatten()
+					.ok_or(Error::ReceivingDhtValueFoundEventWithNoPeerIds)?; // no records with peer_id in them
+
+				// 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 {
+					let public_key = PublicKey::try_decode_protobuf(&peer_signature.public_key)
+						.map_err(Error::ParsingLibp2pIdentity)?;
+					let signature = Signature { public_key, bytes: peer_signature.signature };
+
+					if !signature.verify(record, &remote_peer_id) {
+						return Err(Error::VerifyingDhtPayload)
+					}
+				} else if self.strict_record_validation {
+					return Err(Error::MissingPeerIdSignature)
+				} else {
+					debug!(
+						target: LOG_TARGET,
+						"Received unsigned authority discovery record from {}", authority_id
+					);
+				}
+				Ok(addresses)
+			})
+			.collect::<Result<Vec<Vec<Multiaddr>>>>()?
+			.into_iter()
+			.flatten()
+			.take(MAX_ADDRESSES_PER_AUTHORITY)
+			.collect();
+
+		if !remote_addresses.is_empty() {
+			self.addr_cache.insert(authority_id, remote_addresses);
+			if let Some(metrics) = &self.metrics {
+				metrics
+					.known_authorities_count
+					.set(self.addr_cache.num_authority_ids().try_into().unwrap_or(std::u64::MAX));
+			}
+		}
+		Ok(())
+	}
+
+	/// Retrieve our public keys within the current and next authority set.
+	// A node might have multiple authority discovery keys within its keystore, e.g. an old one and
+	// one for the upcoming session. In addition it could be participating in the current and (/ or)
+	// next authority set with two keys. The function does not return all of the local authority
+	// discovery public keys, but only the ones intersecting with the current or next authority set.
+	async fn get_own_public_keys_within_authority_set(
+		key_store: KeystorePtr,
+		client: &Client,
+	) -> Result<HashSet<AuthorityId>> {
+		let local_pub_keys = key_store
+			.sr25519_public_keys(key_types::AUTHORITY_DISCOVERY)
+			.into_iter()
+			.collect::<HashSet<_>>();
+
+		let best_hash = client.best_hash().await?;
+		let authorities = client
+			.authorities(best_hash)
+			.await
+			.map_err(|e| Error::CallingRuntime(e.into()))?
+			.into_iter()
+			.map(Into::into)
+			.collect::<HashSet<_>>();
+
+		let intersection =
+			local_pub_keys.intersection(&authorities).cloned().map(Into::into).collect();
+
+		Ok(intersection)
+	}
+}
+
+/// NetworkProvider provides [`Worker`] with all necessary hooks into the
+/// underlying Substrate networking. Using this trait abstraction instead of
+/// `sc_network::NetworkService` directly is necessary to unit test [`Worker`].
+pub trait NetworkProvider: NetworkDHTProvider + NetworkStateInfo + NetworkSigner {}
+
+impl<T> NetworkProvider for T where T: NetworkDHTProvider + NetworkStateInfo + NetworkSigner {}
+
+fn hash_authority_id(id: &[u8]) -> KademliaKey {
+	KademliaKey::new(&Code::Sha2_256.digest(id).digest())
+}
+
+// Makes sure all values are the same and returns it
+//
+// Returns Err(_) if not all values are equal. Returns Ok(None) if there are
+// no values.
+fn single<T>(values: impl IntoIterator<Item = T>) -> std::result::Result<Option<T>, ()>
+where
+	T: PartialEq<T>,
+{
+	values.into_iter().try_fold(None, |acc, item| match acc {
+		None => Ok(Some(item)),
+		Some(ref prev) if *prev != item => Err(()),
+		Some(x) => Ok(Some(x)),
+	})
+}
+
+fn serialize_addresses(addresses: impl Iterator<Item = Multiaddr>) -> Vec<Vec<u8>> {
+	addresses.map(|a| a.to_vec()).collect()
+}
+
+fn serialize_authority_record(addresses: Vec<Vec<u8>>) -> Result<Vec<u8>> {
+	let mut serialized_record = vec![];
+	schema::AuthorityRecord { addresses }
+		.encode(&mut serialized_record)
+		.map_err(Error::EncodingProto)?;
+	Ok(serialized_record)
+}
+
+fn sign_record_with_peer_id(
+	serialized_record: &[u8],
+	network: &impl NetworkSigner,
+) -> Result<schema::PeerSignature> {
+	let signature = network
+		.sign_with_local_identity(serialized_record)
+		.map_err(|e| Error::CannotSign(format!("{} (network packet)", e)))?;
+	let public_key = signature.public_key.encode_protobuf();
+	let signature = signature.bytes;
+	Ok(schema::PeerSignature { signature, public_key })
+}
+
+fn sign_record_with_authority_ids(
+	serialized_record: Vec<u8>,
+	peer_signature: Option<schema::PeerSignature>,
+	key_store: &dyn Keystore,
+	keys: Vec<AuthorityId>,
+) -> Result<Vec<(KademliaKey, Vec<u8>)>> {
+	let mut result = Vec::with_capacity(keys.len());
+
+	for key in keys.iter() {
+		let auth_signature = key_store
+			.sr25519_sign(key_types::AUTHORITY_DISCOVERY, key.as_ref(), &serialized_record)
+			.map_err(|e| Error::CannotSign(format!("{}. Key: {:?}", e, key)))?
+			.ok_or_else(|| {
+				Error::CannotSign(format!("Could not find key in keystore. Key: {:?}", key))
+			})?;
+
+		// Scale encode
+		let auth_signature = auth_signature.encode();
+
+		let signed_record = schema::SignedAuthorityRecord {
+			record: serialized_record.clone(),
+			auth_signature,
+			peer_signature: peer_signature.clone(),
+		}
+		.encode_to_vec();
+
+		result.push((hash_authority_id(key.as_slice()), signed_record));
+	}
+
+	Ok(result)
+}
+
+/// Prometheus metrics for a [`Worker`].
+#[derive(Clone)]
+pub(crate) struct Metrics {
+	publish: Counter<U64>,
+	amount_addresses_last_published: Gauge<U64>,
+	requests: Counter<U64>,
+	requests_pending: Gauge<U64>,
+	dht_event_received: CounterVec<U64>,
+	handle_value_found_event_failure: Counter<U64>,
+	known_authorities_count: Gauge<U64>,
+}
+
+impl Metrics {
+	pub(crate) fn register(registry: &prometheus_endpoint::Registry) -> Result<Self> {
+		Ok(Self {
+			publish: register(
+				Counter::new(
+					"substrate_authority_discovery_times_published_total",
+					"Number of times authority discovery has published external addresses.",
+				)?,
+				registry,
+			)?,
+			amount_addresses_last_published: register(
+				Gauge::new(
+					"substrate_authority_discovery_amount_external_addresses_last_published",
+					"Number of external addresses published when authority discovery last \
+					 published addresses.",
+				)?,
+				registry,
+			)?,
+			requests: register(
+				Counter::new(
+					"substrate_authority_discovery_authority_addresses_requested_total",
+					"Number of times authority discovery has requested external addresses of a \
+					 single authority.",
+				)?,
+				registry,
+			)?,
+			requests_pending: register(
+				Gauge::new(
+					"substrate_authority_discovery_authority_address_requests_pending",
+					"Number of pending authority address requests.",
+				)?,
+				registry,
+			)?,
+			dht_event_received: register(
+				CounterVec::new(
+					Opts::new(
+						"substrate_authority_discovery_dht_event_received",
+						"Number of dht events received by authority discovery.",
+					),
+					&["name"],
+				)?,
+				registry,
+			)?,
+			handle_value_found_event_failure: register(
+				Counter::new(
+					"substrate_authority_discovery_handle_value_found_event_failure",
+					"Number of times handling a dht value found event failed.",
+				)?,
+				registry,
+			)?,
+			known_authorities_count: register(
+				Gauge::new(
+					"substrate_authority_discovery_known_authorities_count",
+					"Number of authorities known by authority discovery.",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+// Helper functions for unit testing.
+#[cfg(test)]
+impl<Block, Client, Network, DhtEventStream> Worker<Client, Network, 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
new file mode 100644
index 0000000000000000000000000000000000000000..8084b7f0a6dff04edb525db0034c01ae2398219c
--- /dev/null
+++ b/substrate/client/authority-discovery/src/worker/addr_cache.rs
@@ -0,0 +1,388 @@
+// 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 libp2p::{
+	core::multiaddr::{Multiaddr, Protocol},
+	PeerId,
+};
+use sp_authority_discovery::AuthorityId;
+use std::collections::{hash_map::Entry, HashMap, HashSet};
+
+/// Cache for [`AuthorityId`] -> [`HashSet<Multiaddr>`] and [`PeerId`] -> [`HashSet<AuthorityId>`]
+/// mappings.
+pub(super) struct AddrCache {
+	/// The addresses found in `authority_id_to_addresses` are guaranteed to always match
+	/// the peerids found in `peer_id_to_authority_ids`. In other words, these two hashmaps
+	/// are similar to a bi-directional map.
+	///
+	/// Since we may store the mapping across several sessions, a single
+	/// `PeerId` might correspond to multiple `AuthorityId`s. However,
+	/// it's not expected that a single `AuthorityId` can have multiple `PeerId`s.
+	authority_id_to_addresses: HashMap<AuthorityId, HashSet<Multiaddr>>,
+	peer_id_to_authority_ids: HashMap<PeerId, HashSet<AuthorityId>>,
+}
+
+impl AddrCache {
+	pub fn new() -> Self {
+		AddrCache {
+			authority_id_to_addresses: HashMap::new(),
+			peer_id_to_authority_ids: HashMap::new(),
+		}
+	}
+
+	/// Inserts the given [`AuthorityId`] and [`Vec<Multiaddr>`] pair for future lookups by
+	/// [`AuthorityId`] or [`PeerId`].
+	pub fn insert(&mut self, authority_id: AuthorityId, addresses: Vec<Multiaddr>) {
+		let addresses = addresses.into_iter().collect::<HashSet<_>>();
+		let peer_ids = addresses_to_peer_ids(&addresses);
+
+		if peer_ids.is_empty() {
+			log::debug!(
+				target: super::LOG_TARGET,
+				"Authority({:?}) provides no addresses or addresses without peer ids. Adresses: {:?}",
+				authority_id,
+				addresses,
+			);
+
+			return
+		} else if peer_ids.len() > 1 {
+			log::warn!(
+				target: super::LOG_TARGET,
+				"Authority({:?}) can be reached through multiple peer ids: {:?}",
+				authority_id,
+				peer_ids
+			);
+		}
+
+		log::debug!(
+			target: super::LOG_TARGET,
+			"Found addresses for authority {authority_id:?}: {addresses:?}",
+		);
+
+		let old_addresses = self.authority_id_to_addresses.insert(authority_id.clone(), addresses);
+		let old_peer_ids = addresses_to_peer_ids(&old_addresses.unwrap_or_default());
+
+		// Add the new peer ids
+		peer_ids.difference(&old_peer_ids).for_each(|new_peer_id| {
+			self.peer_id_to_authority_ids
+				.entry(*new_peer_id)
+				.or_default()
+				.insert(authority_id.clone());
+		});
+
+		// Remove the old peer ids
+		self.remove_authority_id_from_peer_ids(&authority_id, old_peer_ids.difference(&peer_ids));
+	}
+
+	/// Remove the given `authority_id` from the `peer_id` to `authority_ids` mapping.
+	///
+	/// If a `peer_id` doesn't have any `authority_id` assigned anymore, it is removed.
+	fn remove_authority_id_from_peer_ids<'a>(
+		&mut self,
+		authority_id: &AuthorityId,
+		peer_ids: impl Iterator<Item = &'a PeerId>,
+	) {
+		peer_ids.for_each(|peer_id| {
+			if let Entry::Occupied(mut e) = self.peer_id_to_authority_ids.entry(*peer_id) {
+				e.get_mut().remove(authority_id);
+
+				// If there are no more entries, remove the peer id.
+				if e.get().is_empty() {
+					e.remove();
+				}
+			}
+		})
+	}
+
+	/// Returns the number of authority IDs in the cache.
+	pub fn num_authority_ids(&self) -> usize {
+		self.authority_id_to_addresses.len()
+	}
+
+	/// Returns the addresses for the given [`AuthorityId`].
+	pub fn get_addresses_by_authority_id(
+		&self,
+		authority_id: &AuthorityId,
+	) -> Option<&HashSet<Multiaddr>> {
+		self.authority_id_to_addresses.get(authority_id)
+	}
+
+	/// Returns the [`AuthorityId`]s for the given [`PeerId`].
+	///
+	/// As the authority id can change between sessions, one [`PeerId`] can be mapped to
+	/// multiple authority ids.
+	pub fn get_authority_ids_by_peer_id(&self, peer_id: &PeerId) -> Option<&HashSet<AuthorityId>> {
+		self.peer_id_to_authority_ids.get(peer_id)
+	}
+
+	/// Removes all [`PeerId`]s and [`Multiaddr`]s from the cache that are not related to the given
+	/// [`AuthorityId`]s.
+	pub fn retain_ids(&mut self, authority_ids: &[AuthorityId]) {
+		// The below logic could be replaced by `BtreeMap::drain_filter` once it stabilized.
+		let authority_ids_to_remove = self
+			.authority_id_to_addresses
+			.iter()
+			.filter(|(id, _addresses)| !authority_ids.contains(id))
+			.map(|entry| entry.0)
+			.cloned()
+			.collect::<Vec<AuthorityId>>();
+
+		for authority_id_to_remove in authority_ids_to_remove {
+			// Remove other entries from `self.authority_id_to_addresses`.
+			let addresses = if let Some(addresses) =
+				self.authority_id_to_addresses.remove(&authority_id_to_remove)
+			{
+				addresses
+			} else {
+				continue
+			};
+
+			self.remove_authority_id_from_peer_ids(
+				&authority_id_to_remove,
+				addresses_to_peer_ids(&addresses).iter(),
+			);
+		}
+	}
+}
+
+fn peer_id_from_multiaddr(addr: &Multiaddr) -> Option<PeerId> {
+	addr.iter().last().and_then(|protocol| {
+		if let Protocol::P2p(multihash) = protocol {
+			PeerId::from_multihash(multihash).ok()
+		} else {
+			None
+		}
+	})
+}
+
+fn addresses_to_peer_ids(addresses: &HashSet<Multiaddr>) -> HashSet<PeerId> {
+	addresses.iter().filter_map(peer_id_from_multiaddr).collect::<HashSet<_>>()
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use libp2p::multihash::{self, Multihash};
+	use quickcheck::{Arbitrary, Gen, QuickCheck, TestResult};
+
+	use sp_authority_discovery::{AuthorityId, AuthorityPair};
+	use sp_core::crypto::Pair;
+
+	#[derive(Clone, Debug)]
+	struct TestAuthorityId(AuthorityId);
+
+	impl Arbitrary for TestAuthorityId {
+		fn arbitrary(g: &mut Gen) -> Self {
+			let seed = (0..32).map(|_| u8::arbitrary(g)).collect::<Vec<_>>();
+			TestAuthorityId(AuthorityPair::from_seed_slice(&seed).unwrap().public())
+		}
+	}
+
+	#[derive(Clone, Debug)]
+	struct TestMultiaddr(Multiaddr);
+
+	impl Arbitrary for TestMultiaddr {
+		fn arbitrary(g: &mut Gen) -> Self {
+			let seed = (0..32).map(|_| u8::arbitrary(g)).collect::<Vec<_>>();
+			let peer_id = PeerId::from_multihash(
+				Multihash::wrap(multihash::Code::Sha2_256.into(), &seed).unwrap(),
+			)
+			.unwrap();
+			let multiaddr = "/ip6/2001:db8:0:0:0:0:0:2/tcp/30333"
+				.parse::<Multiaddr>()
+				.unwrap()
+				.with(Protocol::P2p(peer_id.into()));
+
+			TestMultiaddr(multiaddr)
+		}
+	}
+
+	#[derive(Clone, Debug)]
+	struct TestMultiaddrsSamePeerCombo(Multiaddr, Multiaddr);
+
+	impl Arbitrary for TestMultiaddrsSamePeerCombo {
+		fn arbitrary(g: &mut Gen) -> Self {
+			let seed = (0..32).map(|_| u8::arbitrary(g)).collect::<Vec<_>>();
+			let peer_id = PeerId::from_multihash(
+				Multihash::wrap(multihash::Code::Sha2_256.into(), &seed).unwrap(),
+			)
+			.unwrap();
+			let multiaddr1 = "/ip6/2001:db8:0:0:0:0:0:2/tcp/30333"
+				.parse::<Multiaddr>()
+				.unwrap()
+				.with(Protocol::P2p(peer_id.into()));
+			let multiaddr2 = "/ip6/2002:db8:0:0:0:0:0:2/tcp/30133"
+				.parse::<Multiaddr>()
+				.unwrap()
+				.with(Protocol::P2p(peer_id.into()));
+			TestMultiaddrsSamePeerCombo(multiaddr1, multiaddr2)
+		}
+	}
+
+	#[test]
+	fn retains_only_entries_of_provided_authority_ids() {
+		fn property(
+			first: (TestAuthorityId, TestMultiaddr),
+			second: (TestAuthorityId, TestMultiaddr),
+			third: (TestAuthorityId, TestMultiaddr),
+		) -> TestResult {
+			let first: (AuthorityId, Multiaddr) = ((first.0).0, (first.1).0);
+			let second: (AuthorityId, Multiaddr) = ((second.0).0, (second.1).0);
+			let third: (AuthorityId, Multiaddr) = ((third.0).0, (third.1).0);
+
+			let mut cache = AddrCache::new();
+
+			cache.insert(first.0.clone(), vec![first.1.clone()]);
+			cache.insert(second.0.clone(), vec![second.1.clone()]);
+			cache.insert(third.0.clone(), vec![third.1.clone()]);
+
+			assert_eq!(
+				Some(&HashSet::from([third.1.clone()])),
+				cache.get_addresses_by_authority_id(&third.0),
+				"Expect `get_addresses_by_authority_id` to return addresses of third authority.",
+			);
+			assert_eq!(
+				Some(&HashSet::from([third.0.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&third.1).unwrap()),
+				"Expect `get_authority_id_by_peer_id` to return `AuthorityId` of third authority.",
+			);
+
+			cache.retain_ids(&vec![first.0.clone(), second.0]);
+
+			assert_eq!(
+				None,
+				cache.get_addresses_by_authority_id(&third.0),
+				"Expect `get_addresses_by_authority_id` to not return `None` for third authority.",
+			);
+			assert_eq!(
+				None,
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&third.1).unwrap()),
+				"Expect `get_authority_id_by_peer_id` to return `None` for third authority.",
+			);
+
+			TestResult::passed()
+		}
+
+		QuickCheck::new()
+			.max_tests(10)
+			.quickcheck(property as fn(_, _, _) -> TestResult)
+	}
+
+	#[test]
+	fn keeps_consistency_between_authority_id_and_peer_id() {
+		fn property(
+			authority1: TestAuthorityId,
+			authority2: TestAuthorityId,
+			multiaddr1: TestMultiaddr,
+			multiaddr2: TestMultiaddr,
+			multiaddr3: TestMultiaddrsSamePeerCombo,
+		) -> TestResult {
+			let authority1 = authority1.0;
+			let authority2 = authority2.0;
+			let multiaddr1 = multiaddr1.0;
+			let multiaddr2 = multiaddr2.0;
+			let TestMultiaddrsSamePeerCombo(multiaddr3, multiaddr4) = multiaddr3;
+
+			let mut cache = AddrCache::new();
+
+			cache.insert(authority1.clone(), vec![multiaddr1.clone()]);
+			cache.insert(
+				authority1.clone(),
+				vec![multiaddr2.clone(), multiaddr3.clone(), multiaddr4.clone()],
+			);
+
+			assert_eq!(
+				None,
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr1).unwrap())
+			);
+			assert_eq!(
+				Some(&HashSet::from([authority1.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr2).unwrap())
+			);
+			assert_eq!(
+				Some(&HashSet::from([authority1.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr3).unwrap())
+			);
+			assert_eq!(
+				Some(&HashSet::from([authority1.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr4).unwrap())
+			);
+
+			cache.insert(authority2.clone(), vec![multiaddr2.clone()]);
+
+			assert_eq!(
+				Some(&HashSet::from([authority2.clone(), authority1.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr2).unwrap())
+			);
+			assert_eq!(
+				Some(&HashSet::from([authority1.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr3).unwrap())
+			);
+			assert_eq!(cache.get_addresses_by_authority_id(&authority1).unwrap().len(), 3);
+
+			cache.insert(authority2.clone(), vec![multiaddr2.clone(), multiaddr3.clone()]);
+
+			assert_eq!(
+				Some(&HashSet::from([authority2.clone(), authority1.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr2).unwrap())
+			);
+			assert_eq!(
+				Some(&HashSet::from([authority2.clone(), authority1.clone()])),
+				cache.get_authority_ids_by_peer_id(&peer_id_from_multiaddr(&multiaddr3).unwrap())
+			);
+			assert_eq!(
+				&HashSet::from([multiaddr2.clone(), multiaddr3.clone(), multiaddr4.clone()]),
+				cache.get_addresses_by_authority_id(&authority1).unwrap(),
+			);
+
+			TestResult::passed()
+		}
+
+		QuickCheck::new()
+			.max_tests(10)
+			.quickcheck(property as fn(_, _, _, _, _) -> TestResult)
+	}
+
+	/// As the runtime gives us the current + next authority ids, it can happen that some
+	/// authority changed its session keys. Changing the sessions keys leads to having two
+	/// authority ids that map to the same `PeerId` & addresses.
+	#[test]
+	fn adding_two_authority_ids_for_the_same_peer_id() {
+		let mut addr_cache = AddrCache::new();
+
+		let peer_id = PeerId::random();
+		let addr = Multiaddr::empty().with(Protocol::P2p(peer_id.into()));
+
+		let authority_id0 = AuthorityPair::generate().0.public();
+		let authority_id1 = AuthorityPair::generate().0.public();
+
+		addr_cache.insert(authority_id0.clone(), vec![addr.clone()]);
+		addr_cache.insert(authority_id1.clone(), vec![addr.clone()]);
+
+		assert_eq!(2, addr_cache.num_authority_ids());
+		assert_eq!(
+			&HashSet::from([addr.clone()]),
+			addr_cache.get_addresses_by_authority_id(&authority_id0).unwrap()
+		);
+		assert_eq!(
+			&HashSet::from([addr]),
+			addr_cache.get_addresses_by_authority_id(&authority_id1).unwrap()
+		);
+	}
+}
diff --git a/substrate/client/authority-discovery/src/worker/schema/dht-v1.proto b/substrate/client/authority-discovery/src/worker/schema/dht-v1.proto
new file mode 100644
index 0000000000000000000000000000000000000000..0ef628888c0939706de5cccabbb8aeca4820c8b2
--- /dev/null
+++ b/substrate/client/authority-discovery/src/worker/schema/dht-v1.proto
@@ -0,0 +1,14 @@
+syntax = "proto3";
+
+package authority_discovery_v1;
+
+// First we need to serialize the addresses in order to be able to sign them.
+message AuthorityAddresses {
+	repeated bytes addresses = 1;
+}
+
+// Then we need to serialize addresses and signature to send them over the wire.
+message SignedAuthorityAddresses {
+	bytes addresses = 1;
+	bytes signature = 2;
+}
\ No newline at end of file
diff --git a/substrate/client/authority-discovery/src/worker/schema/dht-v2.proto b/substrate/client/authority-discovery/src/worker/schema/dht-v2.proto
new file mode 100644
index 0000000000000000000000000000000000000000..fdbadb4266306f869f52636e320011f9b4c039fe
--- /dev/null
+++ b/substrate/client/authority-discovery/src/worker/schema/dht-v2.proto
@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+package authority_discovery_v2;
+
+// First we need to serialize the addresses in order to be able to sign them.
+message AuthorityRecord {
+	// Possibly multiple `MultiAddress`es through which the node can be 
+	repeated bytes addresses = 1;
+}
+
+message PeerSignature {
+	bytes signature = 1;
+	bytes public_key = 2;
+}
+
+// Then we need to serialize the authority record and signature to send them over the wire.
+message SignedAuthorityRecord {
+	bytes record = 1;
+	bytes auth_signature = 2;
+	// Even if there are multiple `record.addresses`, all of them have the same peer id.
+    // Old versions are missing this field. It is optional in order to provide compatibility both ways.
+	PeerSignature peer_signature = 3;
+}
diff --git a/substrate/client/authority-discovery/src/worker/schema/tests.rs b/substrate/client/authority-discovery/src/worker/schema/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c765e4e5384db483cd2e9c94156ff487c8410456
--- /dev/null
+++ b/substrate/client/authority-discovery/src/worker/schema/tests.rs
@@ -0,0 +1,89 @@
+// 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/>.
+
+mod schema_v1 {
+	include!(concat!(env!("OUT_DIR"), "/authority_discovery_v1.rs"));
+}
+
+use super::*;
+use libp2p::{identity::Keypair, multiaddr::Multiaddr, PeerId};
+use prost::Message;
+
+#[test]
+fn v2_decodes_v1() {
+	let peer_id = PeerId::random();
+	let multiaddress: Multiaddr =
+		format!("/ip4/127.0.0.1/tcp/3003/p2p/{}", peer_id).parse().unwrap();
+	let vec_addresses = vec![multiaddress.to_vec()];
+	let vec_auth_signature = b"Totally valid signature, I promise!".to_vec();
+
+	let addresses_v1 = schema_v1::AuthorityAddresses { addresses: vec_addresses.clone() };
+	let mut vec_addresses_v1 = vec![];
+	addresses_v1.encode(&mut vec_addresses_v1).unwrap();
+	let signed_addresses_v1 = schema_v1::SignedAuthorityAddresses {
+		addresses: vec_addresses_v1.clone(),
+		signature: vec_auth_signature.clone(),
+	};
+	let mut vec_signed_addresses_v1 = vec![];
+	signed_addresses_v1.encode(&mut vec_signed_addresses_v1).unwrap();
+
+	let signed_record_v2_decoded =
+		SignedAuthorityRecord::decode(vec_signed_addresses_v1.as_slice()).unwrap();
+
+	assert_eq!(&signed_record_v2_decoded.record, &vec_addresses_v1);
+	assert_eq!(&signed_record_v2_decoded.auth_signature, &vec_auth_signature);
+	assert_eq!(&signed_record_v2_decoded.peer_signature, &None);
+
+	let record_v2_decoded = AuthorityRecord::decode(vec_addresses_v1.as_slice()).unwrap();
+	assert_eq!(&record_v2_decoded.addresses, &vec_addresses);
+}
+
+#[test]
+fn v1_decodes_v2() {
+	let peer_secret = Keypair::generate_ed25519();
+	let peer_public = peer_secret.public();
+	let peer_id = peer_public.to_peer_id();
+	let multiaddress: Multiaddr =
+		format!("/ip4/127.0.0.1/tcp/3003/p2p/{}", peer_id).parse().unwrap();
+	let vec_addresses = vec![multiaddress.to_vec()];
+	let vec_auth_signature = b"Totally valid signature, I promise!".to_vec();
+	let vec_peer_signature = b"Surprisingly hard to crack crypto".to_vec();
+
+	let record_v2 = AuthorityRecord { addresses: vec_addresses.clone() };
+	let mut vec_record_v2 = vec![];
+	record_v2.encode(&mut vec_record_v2).unwrap();
+	let vec_peer_public = peer_public.encode_protobuf();
+	let peer_signature_v2 =
+		PeerSignature { public_key: vec_peer_public, signature: vec_peer_signature };
+	let signed_record_v2 = SignedAuthorityRecord {
+		record: vec_record_v2.clone(),
+		auth_signature: vec_auth_signature.clone(),
+		peer_signature: Some(peer_signature_v2.clone()),
+	};
+	let mut vec_signed_record_v2 = vec![];
+	signed_record_v2.encode(&mut vec_signed_record_v2).unwrap();
+
+	let signed_addresses_v1_decoded =
+		schema_v1::SignedAuthorityAddresses::decode(vec_signed_record_v2.as_slice()).unwrap();
+
+	assert_eq!(&signed_addresses_v1_decoded.addresses, &vec_record_v2);
+	assert_eq!(&signed_addresses_v1_decoded.signature, &vec_auth_signature);
+
+	let addresses_v2_decoded = AuthorityRecord::decode(vec_record_v2.as_slice()).unwrap();
+	assert_eq!(&addresses_v2_decoded.addresses, &vec_addresses);
+}
diff --git a/substrate/client/authority-discovery/src/worker/tests.rs b/substrate/client/authority-discovery/src/worker/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c29120881940c1edac54b9e3ffc986f817e487ba
--- /dev/null
+++ b/substrate/client/authority-discovery/src/worker/tests.rs
@@ -0,0 +1,846 @@
+// 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 std::{
+	collections::HashSet,
+	sync::{Arc, Mutex},
+	task::Poll,
+};
+
+use futures::{
+	channel::mpsc::{self, channel},
+	executor::{block_on, LocalPool},
+	future::FutureExt,
+	sink::SinkExt,
+	task::LocalSpawn,
+};
+use libp2p::{
+	core::multiaddr,
+	identity::{Keypair, SigningError},
+	kad::record::Key as KademliaKey,
+	PeerId,
+};
+use prometheus_endpoint::prometheus::default_registry;
+
+use sc_client_api::HeaderBackend;
+use sc_network::Signature;
+use sp_api::{ApiRef, ProvideRuntimeApi};
+use sp_keystore::{testing::MemoryKeystore, Keystore};
+use sp_runtime::traits::{Block as BlockT, NumberFor, Zero};
+use substrate_test_runtime_client::runtime::Block;
+
+use super::*;
+
+#[derive(Clone)]
+pub(crate) struct TestApi {
+	pub(crate) authorities: Vec<AuthorityId>,
+}
+
+impl ProvideRuntimeApi<Block> for TestApi {
+	type Api = RuntimeApi;
+
+	fn runtime_api(&self) -> ApiRef<'_, Self::Api> {
+		RuntimeApi { authorities: self.authorities.clone() }.into()
+	}
+}
+
+/// Blockchain database header backend. Does not perform any validation.
+impl<Block: BlockT> HeaderBackend<Block> for TestApi {
+	fn header(
+		&self,
+		_hash: Block::Hash,
+	) -> std::result::Result<Option<Block::Header>, sp_blockchain::Error> {
+		Ok(None)
+	}
+
+	fn info(&self) -> sc_client_api::blockchain::Info<Block> {
+		sc_client_api::blockchain::Info {
+			best_hash: Default::default(),
+			best_number: Zero::zero(),
+			finalized_hash: Default::default(),
+			finalized_number: Zero::zero(),
+			genesis_hash: Default::default(),
+			number_leaves: Default::default(),
+			finalized_state: None,
+			block_gap: None,
+		}
+	}
+
+	fn status(
+		&self,
+		_hash: Block::Hash,
+	) -> std::result::Result<sc_client_api::blockchain::BlockStatus, sp_blockchain::Error> {
+		Ok(sc_client_api::blockchain::BlockStatus::Unknown)
+	}
+
+	fn number(
+		&self,
+		_hash: Block::Hash,
+	) -> std::result::Result<Option<NumberFor<Block>>, sp_blockchain::Error> {
+		Ok(None)
+	}
+
+	fn hash(
+		&self,
+		_number: NumberFor<Block>,
+	) -> std::result::Result<Option<Block::Hash>, sp_blockchain::Error> {
+		Ok(None)
+	}
+}
+
+pub(crate) struct RuntimeApi {
+	authorities: Vec<AuthorityId>,
+}
+
+sp_api::mock_impl_runtime_apis! {
+	impl AuthorityDiscoveryApi<Block> for RuntimeApi {
+		fn authorities(&self) -> Vec<AuthorityId> {
+			self.authorities.clone()
+		}
+	}
+}
+
+#[derive(Debug)]
+pub enum TestNetworkEvent {
+	GetCalled(KademliaKey),
+	PutCalled(KademliaKey, Vec<u8>),
+}
+
+pub struct TestNetwork {
+	peer_id: PeerId,
+	identity: Keypair,
+	external_addresses: Vec<Multiaddr>,
+	// Whenever functions on `TestNetwork` are called, the function arguments are added to the
+	// vectors below.
+	pub put_value_call: Arc<Mutex<Vec<(KademliaKey, Vec<u8>)>>>,
+	pub get_value_call: Arc<Mutex<Vec<KademliaKey>>>,
+	event_sender: mpsc::UnboundedSender<TestNetworkEvent>,
+	event_receiver: Option<mpsc::UnboundedReceiver<TestNetworkEvent>>,
+}
+
+impl TestNetwork {
+	fn get_event_receiver(&mut self) -> Option<mpsc::UnboundedReceiver<TestNetworkEvent>> {
+		self.event_receiver.take()
+	}
+}
+
+impl Default for TestNetwork {
+	fn default() -> Self {
+		let (tx, rx) = mpsc::unbounded();
+		let identity = Keypair::generate_ed25519();
+		TestNetwork {
+			peer_id: identity.public().to_peer_id(),
+			identity,
+			external_addresses: vec!["/ip6/2001:db8::/tcp/30333".parse().unwrap()],
+			put_value_call: Default::default(),
+			get_value_call: Default::default(),
+			event_sender: tx,
+			event_receiver: Some(rx),
+		}
+	}
+}
+
+impl NetworkSigner for TestNetwork {
+	fn sign_with_local_identity(
+		&self,
+		msg: impl AsRef<[u8]>,
+	) -> std::result::Result<Signature, SigningError> {
+		Signature::sign_message(msg, &self.identity)
+	}
+}
+
+impl NetworkDHTProvider for TestNetwork {
+	fn put_value(&self, key: KademliaKey, value: Vec<u8>) {
+		self.put_value_call.lock().unwrap().push((key.clone(), value.clone()));
+		self.event_sender
+			.clone()
+			.unbounded_send(TestNetworkEvent::PutCalled(key, value))
+			.unwrap();
+	}
+	fn get_value(&self, key: &KademliaKey) {
+		self.get_value_call.lock().unwrap().push(key.clone());
+		self.event_sender
+			.clone()
+			.unbounded_send(TestNetworkEvent::GetCalled(key.clone()))
+			.unwrap();
+	}
+}
+
+impl NetworkStateInfo for TestNetwork {
+	fn local_peer_id(&self) -> PeerId {
+		self.peer_id
+	}
+
+	fn external_addresses(&self) -> Vec<Multiaddr> {
+		self.external_addresses.clone()
+	}
+
+	fn listen_addresses(&self) -> Vec<Multiaddr> {
+		self.external_addresses.clone()
+	}
+}
+
+struct TestSigner<'a> {
+	keypair: &'a Keypair,
+}
+
+impl<'a> NetworkSigner for TestSigner<'a> {
+	fn sign_with_local_identity(
+		&self,
+		msg: impl AsRef<[u8]>,
+	) -> std::result::Result<Signature, SigningError> {
+		Signature::sign_message(msg, self.keypair)
+	}
+}
+
+fn build_dht_event<Signer: NetworkSigner>(
+	addresses: Vec<Multiaddr>,
+	public_key: AuthorityId,
+	key_store: &MemoryKeystore,
+	network: Option<&Signer>,
+) -> Vec<(KademliaKey, Vec<u8>)> {
+	let serialized_record =
+		serialize_authority_record(serialize_addresses(addresses.into_iter())).unwrap();
+
+	let peer_signature = network.map(|n| sign_record_with_peer_id(&serialized_record, n).unwrap());
+	let kv_pairs = sign_record_with_authority_ids(
+		serialized_record,
+		peer_signature,
+		key_store,
+		vec![public_key.into()],
+	)
+	.unwrap();
+	// There is always a single item in it, because we signed it with a single key
+	kv_pairs
+}
+
+#[test]
+fn new_registers_metrics() {
+	let (_dht_event_tx, dht_event_rx) = mpsc::channel(1000);
+	let network: Arc<TestNetwork> = Arc::new(Default::default());
+	let key_store = MemoryKeystore::new();
+	let test_api = Arc::new(TestApi { authorities: vec![] });
+
+	let registry = prometheus_endpoint::Registry::new();
+
+	let (_to_worker, from_service) = mpsc::channel(0);
+	Worker::new(
+		from_service,
+		test_api,
+		network.clone(),
+		Box::pin(dht_event_rx),
+		Role::PublishAndDiscover(key_store.into()),
+		Some(registry.clone()),
+		Default::default(),
+	);
+
+	assert!(registry.gather().len() > 0);
+}
+
+#[test]
+fn triggers_dht_get_query() {
+	sp_tracing::try_init_simple();
+	let (_dht_event_tx, dht_event_rx) = channel(1000);
+
+	// Generate authority keys
+	let authority_1_key_pair = AuthorityPair::from_seed_slice(&[1; 32]).unwrap();
+	let authority_2_key_pair = AuthorityPair::from_seed_slice(&[2; 32]).unwrap();
+	let authorities = vec![authority_1_key_pair.public(), authority_2_key_pair.public()];
+
+	let test_api = Arc::new(TestApi { authorities: authorities.clone() });
+
+	let network = Arc::new(TestNetwork::default());
+	let key_store = MemoryKeystore::new();
+
+	let (_to_worker, from_service) = mpsc::channel(0);
+	let mut worker = Worker::new(
+		from_service,
+		test_api,
+		network.clone(),
+		Box::pin(dht_event_rx),
+		Role::PublishAndDiscover(key_store.into()),
+		None,
+		Default::default(),
+	);
+
+	futures::executor::block_on(async {
+		worker.refill_pending_lookups_queue().await.unwrap();
+		worker.start_new_lookups();
+		assert_eq!(network.get_value_call.lock().unwrap().len(), authorities.len());
+	})
+}
+
+#[test]
+fn publish_discover_cycle() {
+	sp_tracing::try_init_simple();
+
+	let mut pool = LocalPool::new();
+
+	// Node A publishing its address.
+
+	let (_dht_event_tx, dht_event_rx) = channel(1000);
+
+	let network: Arc<TestNetwork> = Arc::new(Default::default());
+
+	let key_store = MemoryKeystore::new();
+
+	let _ = pool.spawner().spawn_local_obj(
+		async move {
+			let node_a_public =
+				key_store.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None).unwrap();
+			let test_api = Arc::new(TestApi { authorities: vec![node_a_public.into()] });
+
+			let (_to_worker, from_service) = mpsc::channel(0);
+			let mut worker = Worker::new(
+				from_service,
+				test_api,
+				network.clone(),
+				Box::pin(dht_event_rx),
+				Role::PublishAndDiscover(key_store.into()),
+				None,
+				Default::default(),
+			);
+
+			worker.publish_ext_addresses(false).await.unwrap();
+
+			// Expect authority discovery to put a new record onto the dht.
+			assert_eq!(network.put_value_call.lock().unwrap().len(), 1);
+
+			let dht_event = {
+				let (key, value) = network.put_value_call.lock().unwrap().pop().unwrap();
+				DhtEvent::ValueFound(vec![(key, value)])
+			};
+
+			// Node B discovering node A's address.
+
+			let (mut dht_event_tx, dht_event_rx) = channel(1000);
+			let test_api = Arc::new(TestApi {
+				// Make sure node B identifies node A as an authority.
+				authorities: vec![node_a_public.into()],
+			});
+			let network: Arc<TestNetwork> = Arc::new(Default::default());
+			let key_store = MemoryKeystore::new();
+
+			let (_to_worker, from_service) = mpsc::channel(0);
+			let mut worker = Worker::new(
+				from_service,
+				test_api,
+				network.clone(),
+				Box::pin(dht_event_rx),
+				Role::PublishAndDiscover(key_store.into()),
+				None,
+				Default::default(),
+			);
+
+			dht_event_tx.try_send(dht_event.clone()).unwrap();
+
+			worker.refill_pending_lookups_queue().await.unwrap();
+			worker.start_new_lookups();
+
+			// Make authority discovery handle the event.
+			worker.handle_dht_event(dht_event).await;
+		}
+		.boxed_local()
+		.into(),
+	);
+
+	pool.run();
+}
+
+/// Don't terminate when sender side of service channel is dropped. Terminate when network event
+/// stream terminates.
+#[test]
+fn terminate_when_event_stream_terminates() {
+	let (dht_event_tx, dht_event_rx) = channel(1000);
+	let network: Arc<TestNetwork> = Arc::new(Default::default());
+	let key_store = MemoryKeystore::new();
+	let test_api = Arc::new(TestApi { authorities: vec![] });
+
+	let (to_worker, from_service) = mpsc::channel(0);
+	let worker = Worker::new(
+		from_service,
+		test_api,
+		network.clone(),
+		Box::pin(dht_event_rx),
+		Role::PublishAndDiscover(key_store.into()),
+		None,
+		Default::default(),
+	)
+	.run();
+	futures::pin_mut!(worker);
+
+	block_on(async {
+		assert_eq!(Poll::Pending, futures::poll!(&mut worker));
+
+		// Drop sender side of service channel.
+		drop(to_worker);
+		assert_eq!(
+			Poll::Pending,
+			futures::poll!(&mut worker),
+			"Expect the authority discovery module not to terminate once the \
+			sender side of the service channel is closed.",
+		);
+
+		// Simulate termination of the network through dropping the sender side
+		// of the dht event channel.
+		drop(dht_event_tx);
+
+		assert_eq!(
+			Poll::Ready(()),
+			futures::poll!(&mut worker),
+			"Expect the authority discovery module to terminate once the \
+			 sending side of the dht event channel is closed.",
+		);
+	});
+}
+
+#[test]
+fn dont_stop_polling_dht_event_stream_after_bogus_event() {
+	let remote_multiaddr = {
+		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()))
+	};
+	let remote_key_store = MemoryKeystore::new();
+	let remote_public_key: AuthorityId = remote_key_store
+		.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
+		.unwrap()
+		.into();
+
+	let (mut dht_event_tx, dht_event_rx) = channel(1);
+	let (network, mut network_events) = {
+		let mut n = TestNetwork::default();
+		let r = n.get_event_receiver().unwrap();
+		(Arc::new(n), r)
+	};
+
+	let key_store = MemoryKeystore::new();
+	let test_api = Arc::new(TestApi { authorities: vec![remote_public_key.clone()] });
+	let mut pool = LocalPool::new();
+
+	let (mut to_worker, from_service) = mpsc::channel(1);
+	let mut worker = Worker::new(
+		from_service,
+		test_api,
+		network.clone(),
+		Box::pin(dht_event_rx),
+		Role::PublishAndDiscover(Arc::new(key_store)),
+		None,
+		Default::default(),
+	);
+
+	// Spawn the authority discovery to make sure it is polled independently.
+	//
+	// As this is a local pool, only one future at a time will have the CPU and
+	// can make progress until the future returns `Pending`.
+	let _ = pool.spawner().spawn_local_obj(
+		async move {
+			// Refilling `pending_lookups` only happens every X minutes. Fast
+			// forward by calling `refill_pending_lookups_queue` directly.
+			worker.refill_pending_lookups_queue().await.unwrap();
+			worker.run().await
+		}
+		.boxed_local()
+		.into(),
+	);
+
+	pool.run_until(async {
+		// Assert worker to trigger a lookup for the one and only authority.
+		assert!(matches!(network_events.next().await, Some(TestNetworkEvent::GetCalled(_))));
+
+		// Send an event that should generate an error
+		dht_event_tx
+			.send(DhtEvent::ValueFound(Default::default()))
+			.await
+			.expect("Channel has capacity of 1.");
+
+		// Make previously triggered lookup succeed.
+		let dht_event = {
+			let kv_pairs = build_dht_event::<TestNetwork>(
+				vec![remote_multiaddr.clone()],
+				remote_public_key.clone(),
+				&remote_key_store,
+				None,
+			);
+			DhtEvent::ValueFound(kv_pairs)
+		};
+		dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");
+
+		// Expect authority discovery to function normally, now knowing the
+		// address for the remote node.
+		let (sender, addresses) = futures::channel::oneshot::channel();
+		to_worker
+			.send(ServicetoWorkerMsg::GetAddressesByAuthorityId(remote_public_key, sender))
+			.await
+			.expect("Channel has capacity of 1.");
+		assert_eq!(Some(HashSet::from([remote_multiaddr])), addresses.await.unwrap());
+	});
+}
+
+struct DhtValueFoundTester {
+	pub remote_key_store: MemoryKeystore,
+	pub remote_authority_public: sp_core::sr25519::Public,
+	pub remote_node_key: Keypair,
+	pub local_worker: Option<
+		Worker<
+			TestApi,
+			TestNetwork,
+			sp_runtime::generic::Block<
+				sp_runtime::generic::Header<u64, sp_runtime::traits::BlakeTwo256>,
+				substrate_test_runtime_client::runtime::Extrinsic,
+			>,
+			std::pin::Pin<Box<futures::channel::mpsc::Receiver<DhtEvent>>>,
+		>,
+	>,
+}
+
+impl DhtValueFoundTester {
+	fn new() -> Self {
+		let remote_key_store = MemoryKeystore::new();
+		let remote_authority_public = remote_key_store
+			.sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None)
+			.unwrap();
+
+		let remote_node_key = Keypair::generate_ed25519();
+		Self { remote_key_store, remote_authority_public, remote_node_key, local_worker: None }
+	}
+
+	fn multiaddr_with_peer_id(&self, idx: u16) -> Multiaddr {
+		let peer_id = self.remote_node_key.public().to_peer_id();
+		let address: Multiaddr =
+			format!("/ip6/2001:db8:0:0:0:0:0:{:x}/tcp/30333", idx).parse().unwrap();
+
+		address.with(multiaddr::Protocol::P2p(peer_id.into()))
+	}
+
+	fn process_value_found(
+		&mut self,
+		strict_record_validation: bool,
+		values: Vec<(KademliaKey, Vec<u8>)>,
+	) -> Option<&HashSet<Multiaddr>> {
+		let (_dht_event_tx, dht_event_rx) = channel(1);
+		let local_test_api =
+			Arc::new(TestApi { authorities: vec![self.remote_authority_public.into()] });
+		let local_network: Arc<TestNetwork> = Arc::new(Default::default());
+		let local_key_store = MemoryKeystore::new();
+
+		let (_to_worker, from_service) = mpsc::channel(0);
+		let mut local_worker = Worker::new(
+			from_service,
+			local_test_api,
+			local_network.clone(),
+			Box::pin(dht_event_rx),
+			Role::PublishAndDiscover(Arc::new(local_key_store)),
+			None,
+			WorkerConfig { strict_record_validation, ..Default::default() },
+		);
+
+		block_on(local_worker.refill_pending_lookups_queue()).unwrap();
+		local_worker.start_new_lookups();
+
+		drop(local_worker.handle_dht_value_found_event(values));
+
+		self.local_worker = Some(local_worker);
+
+		self.local_worker
+			.as_ref()
+			.map(|w| {
+				w.addr_cache.get_addresses_by_authority_id(&self.remote_authority_public.into())
+			})
+			.unwrap()
+	}
+}
+
+#[test]
+fn limit_number_of_addresses_added_to_cache_per_authority() {
+	let mut tester = DhtValueFoundTester::new();
+	assert!(MAX_ADDRESSES_PER_AUTHORITY < 100);
+	let addresses = (1..100).map(|i| tester.multiaddr_with_peer_id(i)).collect();
+	let kv_pairs = build_dht_event::<TestNetwork>(
+		addresses,
+		tester.remote_authority_public.into(),
+		&tester.remote_key_store,
+		None,
+	);
+
+	let cached_remote_addresses = tester.process_value_found(false, kv_pairs);
+	assert_eq!(MAX_ADDRESSES_PER_AUTHORITY, cached_remote_addresses.unwrap().len());
+}
+
+#[test]
+fn strict_accept_address_with_peer_signature() {
+	let mut tester = DhtValueFoundTester::new();
+	let addr = tester.multiaddr_with_peer_id(1);
+	let kv_pairs = build_dht_event(
+		vec![addr.clone()],
+		tester.remote_authority_public.into(),
+		&tester.remote_key_store,
+		Some(&TestSigner { keypair: &tester.remote_node_key }),
+	);
+
+	let cached_remote_addresses = tester.process_value_found(true, kv_pairs);
+
+	assert_eq!(
+		Some(&HashSet::from([addr])),
+		cached_remote_addresses,
+		"Expect worker to only cache `Multiaddr`s with `PeerId`s.",
+	);
+}
+
+#[test]
+fn reject_address_with_rogue_peer_signature() {
+	let mut tester = DhtValueFoundTester::new();
+	let rogue_remote_node_key = Keypair::generate_ed25519();
+	let kv_pairs = build_dht_event(
+		vec![tester.multiaddr_with_peer_id(1)],
+		tester.remote_authority_public.into(),
+		&tester.remote_key_store,
+		Some(&TestSigner { keypair: &rogue_remote_node_key }),
+	);
+
+	let cached_remote_addresses = tester.process_value_found(false, kv_pairs);
+
+	assert!(
+		cached_remote_addresses.is_none(),
+		"Expected worker to ignore record signed by a different key.",
+	);
+}
+
+#[test]
+fn reject_address_with_invalid_peer_signature() {
+	let mut tester = DhtValueFoundTester::new();
+	let mut kv_pairs = build_dht_event(
+		vec![tester.multiaddr_with_peer_id(1)],
+		tester.remote_authority_public.into(),
+		&tester.remote_key_store,
+		Some(&TestSigner { keypair: &tester.remote_node_key }),
+	);
+	// tamper with the signature
+	let mut record = schema::SignedAuthorityRecord::decode(kv_pairs[0].1.as_slice()).unwrap();
+	record.peer_signature.as_mut().map(|p| p.signature[1] = !p.signature[1]);
+	record.encode(&mut kv_pairs[0].1).unwrap();
+
+	let cached_remote_addresses = tester.process_value_found(false, kv_pairs);
+
+	assert!(
+		cached_remote_addresses.is_none(),
+		"Expected worker to ignore record with tampered signature.",
+	);
+}
+
+#[test]
+fn reject_address_without_peer_signature() {
+	let mut tester = DhtValueFoundTester::new();
+	let kv_pairs = build_dht_event::<TestNetwork>(
+		vec![tester.multiaddr_with_peer_id(1)],
+		tester.remote_authority_public.into(),
+		&tester.remote_key_store,
+		None,
+	);
+
+	let cached_remote_addresses = tester.process_value_found(true, kv_pairs);
+
+	assert!(cached_remote_addresses.is_none(), "Expected worker to ignore unsigned record.",);
+}
+
+#[test]
+fn do_not_cache_addresses_without_peer_id() {
+	let mut tester = DhtValueFoundTester::new();
+	let multiaddr_with_peer_id = tester.multiaddr_with_peer_id(1);
+	let multiaddr_without_peer_id: Multiaddr =
+		"/ip6/2001:db8:0:0:0:0:0:2/tcp/30333".parse().unwrap();
+	let kv_pairs = build_dht_event::<TestNetwork>(
+		vec![multiaddr_with_peer_id.clone(), multiaddr_without_peer_id],
+		tester.remote_authority_public.into(),
+		&tester.remote_key_store,
+		None,
+	);
+
+	let cached_remote_addresses = tester.process_value_found(false, kv_pairs);
+
+	assert_eq!(
+		Some(&HashSet::from([multiaddr_with_peer_id])),
+		cached_remote_addresses,
+		"Expect worker to only cache `Multiaddr`s with `PeerId`s.",
+	);
+}
+
+#[test]
+fn addresses_to_publish_adds_p2p() {
+	let (_dht_event_tx, dht_event_rx) = channel(1000);
+	let network: Arc<TestNetwork> = Arc::new(Default::default());
+
+	assert!(!matches!(
+		network.external_addresses().pop().unwrap().pop().unwrap(),
+		multiaddr::Protocol::P2p(_)
+	));
+
+	let (_to_worker, from_service) = mpsc::channel(0);
+	let worker = Worker::new(
+		from_service,
+		Arc::new(TestApi { authorities: vec![] }),
+		network.clone(),
+		Box::pin(dht_event_rx),
+		Role::PublishAndDiscover(MemoryKeystore::new().into()),
+		Some(prometheus_endpoint::Registry::new()),
+		Default::default(),
+	);
+
+	assert!(
+		matches!(
+			worker.addresses_to_publish().next().unwrap().pop().unwrap(),
+			multiaddr::Protocol::P2p(_)
+		),
+		"Expect `addresses_to_publish` to append `p2p` protocol component.",
+	);
+}
+
+/// Ensure [`Worker::addresses_to_publish`] does not add an additional `p2p` protocol component in
+/// case one already exists.
+#[test]
+fn addresses_to_publish_respects_existing_p2p_protocol() {
+	let (_dht_event_tx, dht_event_rx) = channel(1000);
+	let network: Arc<TestNetwork> = Arc::new(TestNetwork {
+		external_addresses: vec![
+			"/ip6/2001:db8::/tcp/30333/p2p/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSupNKC"
+				.parse()
+				.unwrap(),
+		],
+		..Default::default()
+	});
+
+	let (_to_worker, from_service) = mpsc::channel(0);
+	let worker = Worker::new(
+		from_service,
+		Arc::new(TestApi { authorities: vec![] }),
+		network.clone(),
+		Box::pin(dht_event_rx),
+		Role::PublishAndDiscover(MemoryKeystore::new().into()),
+		Some(prometheus_endpoint::Registry::new()),
+		Default::default(),
+	);
+
+	assert_eq!(
+		network.external_addresses,
+		worker.addresses_to_publish().collect::<Vec<_>>(),
+		"Expected Multiaddr from `TestNetwork` to not be altered.",
+	);
+}
+
+#[test]
+fn lookup_throttling() {
+	let remote_multiaddr = {
+		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()))
+	};
+	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_hash_to_key = remote_public_keys
+		.iter()
+		.map(|k| (hash_authority_id(k.as_ref()), k.clone()))
+		.collect::<HashMap<_, _>>();
+
+	let (mut dht_event_tx, dht_event_rx) = channel(1);
+	let (_to_worker, from_service) = mpsc::channel(0);
+	let mut network = TestNetwork::default();
+	let mut receiver = network.get_event_receiver().unwrap();
+	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 metrics = worker.metrics.clone().unwrap();
+
+	let _ = pool.spawner().spawn_local_obj(
+		async move {
+			// Refilling `pending_lookups` only happens every X minutes. Fast
+			// forward by calling `refill_pending_lookups_queue` directly.
+			worker.refill_pending_lookups_queue().await.unwrap();
+			worker.run().await
+		}
+		.boxed_local()
+		.into(),
+	);
+
+	pool.run_until(
+		async {
+			// Assert worker to trigger MAX_IN_FLIGHT_LOOKUPS lookups.
+			for _ in 0..MAX_IN_FLIGHT_LOOKUPS {
+				assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
+			}
+			assert_eq!(
+				metrics.requests_pending.get(),
+				(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS) as u64
+			);
+			assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);
+
+			// Make first lookup succeed.
+			let remote_hash = network.get_value_call.lock().unwrap().pop().unwrap();
+			let remote_key: AuthorityId = remote_hash_to_key.get(&remote_hash).unwrap().clone();
+			let dht_event = {
+				let kv_pairs = build_dht_event::<TestNetwork>(
+					vec![remote_multiaddr.clone()],
+					remote_key,
+					&remote_key_store,
+					None,
+				);
+				DhtEvent::ValueFound(kv_pairs)
+			};
+			dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");
+
+			// Assert worker to trigger another lookup.
+			assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
+			assert_eq!(
+				metrics.requests_pending.get(),
+				(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS - 1) as u64
+			);
+			assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);
+
+			// Make second one fail.
+			let remote_hash = network.get_value_call.lock().unwrap().pop().unwrap();
+			let dht_event = DhtEvent::ValueNotFound(remote_hash);
+			dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1.");
+
+			// Assert worker to trigger another lookup.
+			assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_))));
+			assert_eq!(
+				metrics.requests_pending.get(),
+				(remote_public_keys.len() - MAX_IN_FLIGHT_LOOKUPS - 2) as u64
+			);
+			assert_eq!(network.get_value_call.lock().unwrap().len(), MAX_IN_FLIGHT_LOOKUPS);
+		}
+		.boxed_local(),
+	);
+}
diff --git a/substrate/client/basic-authorship/Cargo.toml b/substrate/client/basic-authorship/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dde2e15bd64745328baa1c4caceb7e02c37f8b42
--- /dev/null
+++ b/substrate/client/basic-authorship/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "sc-basic-authorship"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Basic implementation of block-authoring logic."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+futures-timer = "3.0.1"
+log = "0.4.17"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-proposer-metrics = { version = "0.10.0-dev", path = "../proposer-metrics" }
+sc-telemetry = { version = "4.0.0-dev", path = "../telemetry" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../client/transaction-pool/api" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../primitives/inherents" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+
+[dev-dependencies]
+parking_lot = "0.12.1"
+sc-transaction-pool = { version = "4.0.0-dev", path = "../transaction-pool" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
diff --git a/substrate/client/basic-authorship/README.md b/substrate/client/basic-authorship/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f2f160b6e2a977eeae2b7d2221732337c2b7f9eb
--- /dev/null
+++ b/substrate/client/basic-authorship/README.md
@@ -0,0 +1,31 @@
+Basic implementation of block-authoring logic.
+
+# Example
+
+```rust
+// The first step is to create a `ProposerFactory`.
+let mut proposer_factory = ProposerFactory::new(client.clone(), txpool.clone(), None);
+
+// From this factory, we create a `Proposer`.
+let proposer = proposer_factory.init(
+	&client.header(client.chain_info().genesis_hash).unwrap().unwrap(),
+);
+
+// The proposer is created asynchronously.
+let proposer = futures::executor::block_on(proposer).unwrap();
+
+// This `Proposer` allows us to create a block proposition.
+// The proposer will grab transactions from the transaction pool, and put them into the block.
+let future = proposer.propose(
+	Default::default(),
+	Default::default(),
+	Duration::from_secs(2),
+);
+
+// We wait until the proposition is performed.
+let block = futures::executor::block_on(future).unwrap();
+println!("Generated block: {:?}", block.block);
+```
+
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
diff --git a/substrate/client/basic-authorship/src/basic_authorship.rs b/substrate/client/basic-authorship/src/basic_authorship.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b3a8f0d8970b6148a68abe9abbfa98080a84e4d3
--- /dev/null
+++ b/substrate/client/basic-authorship/src/basic_authorship.rs
@@ -0,0 +1,1151 @@
+// 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/>.
+
+//! A consensus proposer for "basic" chains which use the primitive inherent-data.
+
+// FIXME #1021 move this into sp-consensus
+
+use codec::Encode;
+use futures::{
+	channel::oneshot,
+	future,
+	future::{Future, FutureExt},
+	select,
+};
+use log::{debug, error, info, trace, warn};
+use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
+use sc_client_api::backend;
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_INFO};
+use sc_transaction_pool_api::{InPoolTransaction, TransactionPool};
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_blockchain::{ApplyExtrinsicFailed::Validity, Error::ApplyExtrinsicFailed, HeaderBackend};
+use sp_consensus::{DisableProofRecording, EnableProofRecording, ProofRecording, Proposal};
+use sp_core::traits::SpawnNamed;
+use sp_inherents::InherentData;
+use sp_runtime::{
+	traits::{BlakeTwo256, Block as BlockT, Hash as HashT, Header as HeaderT},
+	Digest, Percent, SaturatedConversion,
+};
+use std::{marker::PhantomData, pin::Pin, sync::Arc, time};
+
+use prometheus_endpoint::Registry as PrometheusRegistry;
+use sc_proposer_metrics::{EndProposingReason, MetricsLink as PrometheusMetrics};
+
+/// Default block size limit in bytes used by [`Proposer`].
+///
+/// Can be overwritten by [`ProposerFactory::set_default_block_size_limit`].
+///
+/// Be aware that there is also an upper packet size on what the networking code
+/// will accept. If the block doesn't fit in such a package, it can not be
+/// transferred to other nodes.
+pub const DEFAULT_BLOCK_SIZE_LIMIT: usize = 4 * 1024 * 1024 + 512;
+
+const DEFAULT_SOFT_DEADLINE_PERCENT: Percent = Percent::from_percent(50);
+
+const LOG_TARGET: &'static str = "basic-authorship";
+
+/// [`Proposer`] factory.
+pub struct ProposerFactory<A, B, C, PR> {
+	spawn_handle: Box<dyn SpawnNamed>,
+	/// The client instance.
+	client: Arc<C>,
+	/// The transaction pool.
+	transaction_pool: Arc<A>,
+	/// Prometheus Link,
+	metrics: PrometheusMetrics,
+	/// The default block size limit.
+	///
+	/// If no `block_size_limit` is passed to [`sp_consensus::Proposer::propose`], this block size
+	/// limit will be used.
+	default_block_size_limit: usize,
+	/// Soft deadline percentage of hard deadline.
+	///
+	/// The value is used to compute soft deadline during block production.
+	/// The soft deadline indicates where we should stop attempting to add transactions
+	/// to the block, which exhaust resources. After soft deadline is reached,
+	/// we switch to a fixed-amount mode, in which after we see `MAX_SKIPPED_TRANSACTIONS`
+	/// transactions which exhaust resrouces, we will conclude that the block is full.
+	soft_deadline_percent: Percent,
+	telemetry: Option<TelemetryHandle>,
+	/// When estimating the block size, should the proof be included?
+	include_proof_in_block_size_estimation: bool,
+	/// phantom member to pin the `Backend`/`ProofRecording` type.
+	_phantom: PhantomData<(B, PR)>,
+}
+
+impl<A, B, C> ProposerFactory<A, B, C, DisableProofRecording> {
+	/// Create a new proposer factory.
+	///
+	/// Proof recording will be disabled when using proposers built by this instance to build
+	/// blocks.
+	pub fn new(
+		spawn_handle: impl SpawnNamed + 'static,
+		client: Arc<C>,
+		transaction_pool: Arc<A>,
+		prometheus: Option<&PrometheusRegistry>,
+		telemetry: Option<TelemetryHandle>,
+	) -> Self {
+		ProposerFactory {
+			spawn_handle: Box::new(spawn_handle),
+			transaction_pool,
+			metrics: PrometheusMetrics::new(prometheus),
+			default_block_size_limit: DEFAULT_BLOCK_SIZE_LIMIT,
+			soft_deadline_percent: DEFAULT_SOFT_DEADLINE_PERCENT,
+			telemetry,
+			client,
+			include_proof_in_block_size_estimation: false,
+			_phantom: PhantomData,
+		}
+	}
+}
+
+impl<A, B, C> ProposerFactory<A, B, C, EnableProofRecording> {
+	/// Create a new proposer factory with proof recording enabled.
+	///
+	/// Each proposer created by this instance will record a proof while building a block.
+	///
+	/// This will also include the proof into the estimation of the block size. This can be disabled
+	/// by calling [`ProposerFactory::disable_proof_in_block_size_estimation`].
+	pub fn with_proof_recording(
+		spawn_handle: impl SpawnNamed + 'static,
+		client: Arc<C>,
+		transaction_pool: Arc<A>,
+		prometheus: Option<&PrometheusRegistry>,
+		telemetry: Option<TelemetryHandle>,
+	) -> Self {
+		ProposerFactory {
+			client,
+			spawn_handle: Box::new(spawn_handle),
+			transaction_pool,
+			metrics: PrometheusMetrics::new(prometheus),
+			default_block_size_limit: DEFAULT_BLOCK_SIZE_LIMIT,
+			soft_deadline_percent: DEFAULT_SOFT_DEADLINE_PERCENT,
+			telemetry,
+			include_proof_in_block_size_estimation: true,
+			_phantom: PhantomData,
+		}
+	}
+
+	/// Disable the proof inclusion when estimating the block size.
+	pub fn disable_proof_in_block_size_estimation(&mut self) {
+		self.include_proof_in_block_size_estimation = false;
+	}
+}
+
+impl<A, B, C, PR> ProposerFactory<A, B, C, PR> {
+	/// Set the default block size limit in bytes.
+	///
+	/// The default value for the block size limit is:
+	/// [`DEFAULT_BLOCK_SIZE_LIMIT`].
+	///
+	/// If there is no block size limit passed to [`sp_consensus::Proposer::propose`], this value
+	/// will be used.
+	pub fn set_default_block_size_limit(&mut self, limit: usize) {
+		self.default_block_size_limit = limit;
+	}
+
+	/// Set soft deadline percentage.
+	///
+	/// The value is used to compute soft deadline during block production.
+	/// The soft deadline indicates where we should stop attempting to add transactions
+	/// to the block, which exhaust resources. After soft deadline is reached,
+	/// we switch to a fixed-amount mode, in which after we see `MAX_SKIPPED_TRANSACTIONS`
+	/// transactions which exhaust resrouces, we will conclude that the block is full.
+	///
+	/// Setting the value too low will significantly limit the amount of transactions
+	/// we try in case they exhaust resources. Setting the value too high can
+	/// potentially open a DoS vector, where many "exhaust resources" transactions
+	/// are being tried with no success, hence block producer ends up creating an empty block.
+	pub fn set_soft_deadline(&mut self, percent: Percent) {
+		self.soft_deadline_percent = percent;
+	}
+}
+
+impl<B, Block, C, A, PR> ProposerFactory<A, B, C, PR>
+where
+	A: TransactionPool<Block = Block> + 'static,
+	B: backend::Backend<Block> + Send + Sync + 'static,
+	Block: BlockT,
+	C: BlockBuilderProvider<B, Block, C>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+{
+	fn init_with_now(
+		&mut self,
+		parent_header: &<Block as BlockT>::Header,
+		now: Box<dyn Fn() -> time::Instant + Send + Sync>,
+	) -> Proposer<B, Block, C, A, PR> {
+		let parent_hash = parent_header.hash();
+
+		info!("🙌 Starting consensus session on top of parent {:?}", parent_hash);
+
+		let proposer = Proposer::<_, _, _, _, PR> {
+			spawn_handle: self.spawn_handle.clone(),
+			client: self.client.clone(),
+			parent_hash,
+			parent_number: *parent_header.number(),
+			transaction_pool: self.transaction_pool.clone(),
+			now,
+			metrics: self.metrics.clone(),
+			default_block_size_limit: self.default_block_size_limit,
+			soft_deadline_percent: self.soft_deadline_percent,
+			telemetry: self.telemetry.clone(),
+			_phantom: PhantomData,
+			include_proof_in_block_size_estimation: self.include_proof_in_block_size_estimation,
+		};
+
+		proposer
+	}
+}
+
+impl<A, B, Block, C, PR> sp_consensus::Environment<Block> for ProposerFactory<A, B, C, PR>
+where
+	A: TransactionPool<Block = Block> + 'static,
+	B: backend::Backend<Block> + Send + Sync + 'static,
+	Block: BlockT,
+	C: BlockBuilderProvider<B, Block, C>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+	PR: ProofRecording,
+{
+	type CreateProposer = future::Ready<Result<Self::Proposer, Self::Error>>;
+	type Proposer = Proposer<B, Block, C, A, PR>;
+	type Error = sp_blockchain::Error;
+
+	fn init(&mut self, parent_header: &<Block as BlockT>::Header) -> Self::CreateProposer {
+		future::ready(Ok(self.init_with_now(parent_header, Box::new(time::Instant::now))))
+	}
+}
+
+/// The proposer logic.
+pub struct Proposer<B, Block: BlockT, C, A: TransactionPool, PR> {
+	spawn_handle: Box<dyn SpawnNamed>,
+	client: Arc<C>,
+	parent_hash: Block::Hash,
+	parent_number: <<Block as BlockT>::Header as HeaderT>::Number,
+	transaction_pool: Arc<A>,
+	now: Box<dyn Fn() -> time::Instant + Send + Sync>,
+	metrics: PrometheusMetrics,
+	default_block_size_limit: usize,
+	include_proof_in_block_size_estimation: bool,
+	soft_deadline_percent: Percent,
+	telemetry: Option<TelemetryHandle>,
+	_phantom: PhantomData<(B, PR)>,
+}
+
+impl<A, B, Block, C, PR> sp_consensus::Proposer<Block> for Proposer<B, Block, C, A, PR>
+where
+	A: TransactionPool<Block = Block> + 'static,
+	B: backend::Backend<Block> + Send + Sync + 'static,
+	Block: BlockT,
+	C: BlockBuilderProvider<B, Block, C>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+	PR: ProofRecording,
+{
+	type Proposal =
+		Pin<Box<dyn Future<Output = Result<Proposal<Block, PR::Proof>, Self::Error>> + Send>>;
+	type Error = sp_blockchain::Error;
+	type ProofRecording = PR;
+	type Proof = PR::Proof;
+
+	fn propose(
+		self,
+		inherent_data: InherentData,
+		inherent_digests: Digest,
+		max_duration: time::Duration,
+		block_size_limit: Option<usize>,
+	) -> Self::Proposal {
+		let (tx, rx) = oneshot::channel();
+		let spawn_handle = self.spawn_handle.clone();
+
+		spawn_handle.spawn_blocking(
+			"basic-authorship-proposer",
+			None,
+			Box::pin(async move {
+				// leave some time for evaluation and block finalization (33%)
+				let deadline = (self.now)() + max_duration - max_duration / 3;
+				let res = self
+					.propose_with(inherent_data, inherent_digests, deadline, block_size_limit)
+					.await;
+				if tx.send(res).is_err() {
+					trace!(
+						target: LOG_TARGET,
+						"Could not send block production result to proposer!"
+					);
+				}
+			}),
+		);
+
+		async move { rx.await? }.boxed()
+	}
+}
+
+/// If the block is full we will attempt to push at most
+/// this number of transactions before quitting for real.
+/// It allows us to increase block utilization.
+const MAX_SKIPPED_TRANSACTIONS: usize = 8;
+
+impl<A, B, Block, C, PR> Proposer<B, Block, C, A, PR>
+where
+	A: TransactionPool<Block = Block>,
+	B: backend::Backend<Block> + Send + Sync + 'static,
+	Block: BlockT,
+	C: BlockBuilderProvider<B, Block, C>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+	PR: ProofRecording,
+{
+	async fn propose_with(
+		self,
+		inherent_data: InherentData,
+		inherent_digests: Digest,
+		deadline: time::Instant,
+		block_size_limit: Option<usize>,
+	) -> Result<Proposal<Block, PR::Proof>, sp_blockchain::Error> {
+		let propose_with_timer = time::Instant::now();
+		let mut block_builder =
+			self.client.new_block_at(self.parent_hash, inherent_digests, PR::ENABLED)?;
+
+		self.apply_inherents(&mut block_builder, inherent_data)?;
+
+		// TODO call `after_inherents` and check if we should apply extrinsincs here
+		// <https://github.com/paritytech/substrate/pull/14275/>
+
+		let block_timer = time::Instant::now();
+		let end_reason =
+			self.apply_extrinsics(&mut block_builder, deadline, block_size_limit).await?;
+		let (block, storage_changes, proof) = block_builder.build()?.into_inner();
+		let block_took = block_timer.elapsed();
+
+		let proof =
+			PR::into_proof(proof).map_err(|e| sp_blockchain::Error::Application(Box::new(e)))?;
+
+		self.print_summary(&block, end_reason, block_took, propose_with_timer.elapsed());
+		Ok(Proposal { block, proof, storage_changes })
+	}
+
+	/// Apply all inherents to the block.
+	fn apply_inherents(
+		&self,
+		block_builder: &mut sc_block_builder::BlockBuilder<'_, Block, C, B>,
+		inherent_data: InherentData,
+	) -> Result<(), sp_blockchain::Error> {
+		let create_inherents_start = time::Instant::now();
+		let inherents = block_builder.create_inherents(inherent_data)?;
+		let create_inherents_end = time::Instant::now();
+
+		self.metrics.report(|metrics| {
+			metrics.create_inherents_time.observe(
+				create_inherents_end
+					.saturating_duration_since(create_inherents_start)
+					.as_secs_f64(),
+			);
+		});
+
+		for inherent in inherents {
+			match block_builder.push(inherent) {
+				Err(ApplyExtrinsicFailed(Validity(e))) if e.exhausted_resources() => {
+					warn!(
+						target: LOG_TARGET,
+						"⚠�  Dropping non-mandatory inherent from overweight block."
+					)
+				},
+				Err(ApplyExtrinsicFailed(Validity(e))) if e.was_mandatory() => {
+					error!(
+						"�� Mandatory inherent extrinsic returned error. Block cannot be produced."
+					);
+					return Err(ApplyExtrinsicFailed(Validity(e)))
+				},
+				Err(e) => {
+					warn!(
+						target: LOG_TARGET,
+						"�� Inherent extrinsic returned unexpected error: {}. Dropping.", e
+					);
+				},
+				Ok(_) => {},
+			}
+		}
+		Ok(())
+	}
+
+	/// Apply as many extrinsics as possible to the block.
+	async fn apply_extrinsics(
+		&self,
+		block_builder: &mut sc_block_builder::BlockBuilder<'_, Block, C, B>,
+		deadline: time::Instant,
+		block_size_limit: Option<usize>,
+	) -> Result<EndProposingReason, sp_blockchain::Error> {
+		// proceed with transactions
+		// We calculate soft deadline used only in case we start skipping transactions.
+		let now = (self.now)();
+		let left = deadline.saturating_duration_since(now);
+		let left_micros: u64 = left.as_micros().saturated_into();
+		let soft_deadline =
+			now + time::Duration::from_micros(self.soft_deadline_percent.mul_floor(left_micros));
+		let mut skipped = 0;
+		let mut unqueue_invalid = Vec::new();
+
+		let mut t1 = self.transaction_pool.ready_at(self.parent_number).fuse();
+		let mut t2 =
+			futures_timer::Delay::new(deadline.saturating_duration_since((self.now)()) / 8).fuse();
+
+		let mut pending_iterator = select! {
+			res = t1 => res,
+			_ = t2 => {
+				warn!(target: LOG_TARGET,
+					"Timeout fired waiting for transaction pool at block #{}. \
+					Proceeding with production.",
+					self.parent_number,
+				);
+				self.transaction_pool.ready()
+			},
+		};
+
+		let block_size_limit = block_size_limit.unwrap_or(self.default_block_size_limit);
+
+		debug!(target: LOG_TARGET, "Attempting to push transactions from the pool.");
+		debug!(target: LOG_TARGET, "Pool status: {:?}", self.transaction_pool.status());
+		let mut transaction_pushed = false;
+
+		let end_reason = loop {
+			let pending_tx = if let Some(pending_tx) = pending_iterator.next() {
+				pending_tx
+			} else {
+				break EndProposingReason::NoMoreTransactions
+			};
+
+			let now = (self.now)();
+			if now > deadline {
+				debug!(
+					target: LOG_TARGET,
+					"Consensus deadline reached when pushing block transactions, \
+				proceeding with proposing."
+				);
+				break EndProposingReason::HitDeadline
+			}
+
+			let pending_tx_data = pending_tx.data().clone();
+			let pending_tx_hash = pending_tx.hash().clone();
+
+			let block_size =
+				block_builder.estimate_block_size(self.include_proof_in_block_size_estimation);
+			if block_size + pending_tx_data.encoded_size() > block_size_limit {
+				pending_iterator.report_invalid(&pending_tx);
+				if skipped < MAX_SKIPPED_TRANSACTIONS {
+					skipped += 1;
+					debug!(
+						target: LOG_TARGET,
+						"Transaction would overflow the block size limit, \
+					 but will try {} more transactions before quitting.",
+						MAX_SKIPPED_TRANSACTIONS - skipped,
+					);
+					continue
+				} else if now < soft_deadline {
+					debug!(
+						target: LOG_TARGET,
+						"Transaction would overflow the block size limit, \
+					 but we still have time before the soft deadline, so \
+					 we will try a bit more."
+					);
+					continue
+				} else {
+					debug!(
+						target: LOG_TARGET,
+						"Reached block size limit, proceeding with proposing."
+					);
+					break EndProposingReason::HitBlockSizeLimit
+				}
+			}
+
+			trace!(target: LOG_TARGET, "[{:?}] Pushing to the block.", pending_tx_hash);
+			match sc_block_builder::BlockBuilder::push(block_builder, pending_tx_data) {
+				Ok(()) => {
+					transaction_pushed = true;
+					debug!(target: LOG_TARGET, "[{:?}] Pushed to the block.", pending_tx_hash);
+				},
+				Err(ApplyExtrinsicFailed(Validity(e))) if e.exhausted_resources() => {
+					pending_iterator.report_invalid(&pending_tx);
+					if skipped < MAX_SKIPPED_TRANSACTIONS {
+						skipped += 1;
+						debug!(target: LOG_TARGET,
+							"Block seems full, but will try {} more transactions before quitting.",
+							MAX_SKIPPED_TRANSACTIONS - skipped,
+						);
+					} else if (self.now)() < soft_deadline {
+						debug!(target: LOG_TARGET,
+							"Block seems full, but we still have time before the soft deadline, \
+							 so we will try a bit more before quitting."
+						);
+					} else {
+						debug!(
+							target: LOG_TARGET,
+							"Reached block weight limit, proceeding with proposing."
+						);
+						break EndProposingReason::HitBlockWeightLimit
+					}
+				},
+				Err(e) => {
+					pending_iterator.report_invalid(&pending_tx);
+					debug!(
+						target: LOG_TARGET,
+						"[{:?}] Invalid transaction: {}", pending_tx_hash, e
+					);
+					unqueue_invalid.push(pending_tx_hash);
+				},
+			}
+		};
+
+		if matches!(end_reason, EndProposingReason::HitBlockSizeLimit) && !transaction_pushed {
+			warn!(
+				target: LOG_TARGET,
+				"Hit block size limit of `{}` without including any transaction!", block_size_limit,
+			);
+		}
+
+		self.transaction_pool.remove_invalid(&unqueue_invalid);
+		Ok(end_reason)
+	}
+
+	/// Prints a summary and does telemetry + metrics.
+	fn print_summary(
+		&self,
+		block: &Block,
+		end_reason: EndProposingReason,
+		block_took: time::Duration,
+		propose_with_took: time::Duration,
+	) {
+		let extrinsics = block.extrinsics();
+		self.metrics.report(|metrics| {
+			metrics.number_of_transactions.set(extrinsics.len() as u64);
+			metrics.block_constructed.observe(block_took.as_secs_f64());
+			metrics.report_end_proposing_reason(end_reason);
+			metrics.create_block_proposal_time.observe(propose_with_took.as_secs_f64());
+		});
+
+		let extrinsics_summary = if extrinsics.is_empty() {
+			"no extrinsics".to_string()
+		} else {
+			format!(
+				"extrinsics ({}): [{}]",
+				extrinsics.len(),
+				extrinsics
+					.iter()
+					.map(|xt| BlakeTwo256::hash_of(xt).to_string())
+					.collect::<Vec<_>>()
+					.join(", ")
+			)
+		};
+
+		info!(
+			"� Prepared block for proposing at {} ({} ms) [hash: {:?}; parent_hash: {}; {extrinsics_summary}",
+			block.header().number(),
+			block_took.as_millis(),
+			<Block as BlockT>::Hash::from(block.header().hash()),
+			block.header().parent_hash(),
+		);
+		telemetry!(
+			self.telemetry;
+			CONSENSUS_INFO;
+			"prepared_block_for_proposing";
+			"number" => ?block.header().number(),
+			"hash" => ?<Block as BlockT>::Hash::from(block.header().hash()),
+		);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use futures::executor::block_on;
+	use parking_lot::Mutex;
+	use sc_client_api::Backend;
+	use sc_transaction_pool::BasicPool;
+	use sc_transaction_pool_api::{ChainEvent, MaintainedTransactionPool, TransactionSource};
+	use sp_api::Core;
+	use sp_blockchain::HeaderBackend;
+	use sp_consensus::{BlockOrigin, Environment, Proposer};
+	use sp_runtime::{generic::BlockId, traits::NumberFor, Perbill};
+	use substrate_test_runtime_client::{
+		prelude::*,
+		runtime::{Block as TestBlock, Extrinsic, ExtrinsicBuilder, Transfer},
+		TestClientBuilder, TestClientBuilderExt,
+	};
+
+	const SOURCE: TransactionSource = TransactionSource::External;
+
+	// Note:
+	// Maximum normal extrinsic size for `substrate_test_runtime` is ~65% of max_block (refer to
+	// `substrate_test_runtime::RuntimeBlockWeights` for details).
+	// This extrinsic sizing allows for:
+	// - one huge xts + a lot of tiny dust
+	// - one huge, no medium,
+	// - two medium xts
+	// This is widely exploited in following tests.
+	const HUGE: u32 = 649000000;
+	const MEDIUM: u32 = 250000000;
+	const TINY: u32 = 1000;
+
+	fn extrinsic(nonce: u64) -> Extrinsic {
+		ExtrinsicBuilder::new_fill_block(Perbill::from_parts(TINY)).nonce(nonce).build()
+	}
+
+	fn chain_event<B: BlockT>(header: B::Header) -> ChainEvent<B>
+	where
+		NumberFor<B>: From<u64>,
+	{
+		ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None }
+	}
+
+	#[test]
+	fn should_cease_building_block_when_deadline_is_reached() {
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner.clone(),
+			client.clone(),
+		);
+
+		block_on(txpool.submit_at(&BlockId::number(0), SOURCE, vec![extrinsic(0), extrinsic(1)]))
+			.unwrap();
+
+		block_on(
+			txpool.maintain(chain_event(
+				client
+					.expect_header(client.info().genesis_hash)
+					.expect("there should be header"),
+			)),
+		);
+
+		let mut proposer_factory =
+			ProposerFactory::new(spawner.clone(), client.clone(), txpool.clone(), None, None);
+
+		let cell = Mutex::new((false, time::Instant::now()));
+		let proposer = proposer_factory.init_with_now(
+			&client.expect_header(client.info().genesis_hash).unwrap(),
+			Box::new(move || {
+				let mut value = cell.lock();
+				if !value.0 {
+					value.0 = true;
+					return value.1
+				}
+				let old = value.1;
+				let new = old + time::Duration::from_secs(1);
+				*value = (true, new);
+				old
+			}),
+		);
+
+		// when
+		let deadline = time::Duration::from_secs(3);
+		let block =
+			block_on(proposer.propose(Default::default(), Default::default(), deadline, None))
+				.map(|r| r.block)
+				.unwrap();
+
+		// then
+		// block should have some extrinsics although we have some more in the pool.
+		assert_eq!(block.extrinsics().len(), 1);
+		assert_eq!(txpool.ready().count(), 2);
+	}
+
+	#[test]
+	fn should_not_panic_when_deadline_is_reached() {
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner.clone(),
+			client.clone(),
+		);
+
+		let mut proposer_factory =
+			ProposerFactory::new(spawner.clone(), client.clone(), txpool.clone(), None, None);
+
+		let cell = Mutex::new((false, time::Instant::now()));
+		let proposer = proposer_factory.init_with_now(
+			&client.expect_header(client.info().genesis_hash).unwrap(),
+			Box::new(move || {
+				let mut value = cell.lock();
+				if !value.0 {
+					value.0 = true;
+					return value.1
+				}
+				let new = value.1 + time::Duration::from_secs(160);
+				*value = (true, new);
+				new
+			}),
+		);
+
+		let deadline = time::Duration::from_secs(1);
+		block_on(proposer.propose(Default::default(), Default::default(), deadline, None))
+			.map(|r| r.block)
+			.unwrap();
+	}
+
+	#[test]
+	fn proposed_storage_changes_should_match_execute_block_storage_changes() {
+		let (client, backend) = TestClientBuilder::new().build_with_backend();
+		let client = Arc::new(client);
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner.clone(),
+			client.clone(),
+		);
+
+		let genesis_hash = client.info().best_hash;
+
+		block_on(txpool.submit_at(&BlockId::number(0), SOURCE, vec![extrinsic(0)])).unwrap();
+
+		block_on(
+			txpool.maintain(chain_event(
+				client
+					.expect_header(client.info().genesis_hash)
+					.expect("there should be header"),
+			)),
+		);
+
+		let mut proposer_factory =
+			ProposerFactory::new(spawner.clone(), client.clone(), txpool.clone(), None, None);
+
+		let proposer = proposer_factory.init_with_now(
+			&client.header(genesis_hash).unwrap().unwrap(),
+			Box::new(move || time::Instant::now()),
+		);
+
+		let deadline = time::Duration::from_secs(9);
+		let proposal =
+			block_on(proposer.propose(Default::default(), Default::default(), deadline, None))
+				.unwrap();
+
+		assert_eq!(proposal.block.extrinsics().len(), 1);
+
+		let api = client.runtime_api();
+		api.execute_block(genesis_hash, proposal.block).unwrap();
+
+		let state = backend.state_at(genesis_hash).unwrap();
+
+		let storage_changes = api.into_storage_changes(&state, genesis_hash).unwrap();
+
+		assert_eq!(
+			proposal.storage_changes.transaction_storage_root,
+			storage_changes.transaction_storage_root,
+		);
+	}
+
+	// This test ensures that if one transaction of a user was rejected, because for example
+	// the weight limit was hit, we don't mark the other transactions of the user as invalid because
+	// the nonce is not matching.
+	#[test]
+	fn should_not_remove_invalid_transactions_from_the_same_sender_after_one_was_invalid() {
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner.clone(),
+			client.clone(),
+		);
+
+		let medium = |nonce| {
+			ExtrinsicBuilder::new_fill_block(Perbill::from_parts(MEDIUM))
+				.nonce(nonce)
+				.build()
+		};
+		let huge = |nonce| {
+			ExtrinsicBuilder::new_fill_block(Perbill::from_parts(HUGE)).nonce(nonce).build()
+		};
+
+		block_on(txpool.submit_at(
+			&BlockId::number(0),
+			SOURCE,
+			vec![medium(0), medium(1), huge(2), medium(3), huge(4), medium(5), medium(6)],
+		))
+		.unwrap();
+
+		let mut proposer_factory =
+			ProposerFactory::new(spawner.clone(), client.clone(), txpool.clone(), None, None);
+		let mut propose_block = |client: &TestClient,
+		                         parent_number,
+		                         expected_block_extrinsics,
+		                         expected_pool_transactions| {
+			let hash = client.expect_block_hash_from_id(&BlockId::Number(parent_number)).unwrap();
+			let proposer = proposer_factory.init_with_now(
+				&client.expect_header(hash).unwrap(),
+				Box::new(move || time::Instant::now()),
+			);
+
+			// when
+			let deadline = time::Duration::from_secs(900);
+			let block =
+				block_on(proposer.propose(Default::default(), Default::default(), deadline, None))
+					.map(|r| r.block)
+					.unwrap();
+
+			// then
+			// block should have some extrinsics although we have some more in the pool.
+			assert_eq!(
+				txpool.ready().count(),
+				expected_pool_transactions,
+				"at block: {}",
+				block.header.number
+			);
+			assert_eq!(
+				block.extrinsics().len(),
+				expected_block_extrinsics,
+				"at block: {}",
+				block.header.number
+			);
+
+			block
+		};
+
+		let import_and_maintain = |mut client: Arc<TestClient>, block: TestBlock| {
+			let hash = block.hash();
+			block_on(client.import(BlockOrigin::Own, block)).unwrap();
+			block_on(txpool.maintain(chain_event(
+				client.expect_header(hash).expect("there should be header"),
+			)));
+		};
+
+		block_on(
+			txpool.maintain(chain_event(
+				client
+					.expect_header(client.info().genesis_hash)
+					.expect("there should be header"),
+			)),
+		);
+		assert_eq!(txpool.ready().count(), 7);
+
+		// let's create one block and import it
+		let block = propose_block(&client, 0, 2, 7);
+		import_and_maintain(client.clone(), block);
+		assert_eq!(txpool.ready().count(), 5);
+
+		// now let's make sure that we can still make some progress
+		let block = propose_block(&client, 1, 1, 5);
+		import_and_maintain(client.clone(), block);
+		assert_eq!(txpool.ready().count(), 4);
+
+		// again let's make sure that we can still make some progress
+		let block = propose_block(&client, 2, 1, 4);
+		import_and_maintain(client.clone(), block);
+		assert_eq!(txpool.ready().count(), 3);
+
+		// again let's make sure that we can still make some progress
+		let block = propose_block(&client, 3, 1, 3);
+		import_and_maintain(client.clone(), block);
+		assert_eq!(txpool.ready().count(), 2);
+
+		// again let's make sure that we can still make some progress
+		let block = propose_block(&client, 4, 2, 2);
+		import_and_maintain(client.clone(), block);
+		assert_eq!(txpool.ready().count(), 0);
+	}
+
+	#[test]
+	fn should_cease_building_block_when_block_limit_is_reached() {
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner.clone(),
+			client.clone(),
+		);
+		let genesis_header = client
+			.expect_header(client.info().genesis_hash)
+			.expect("there should be header");
+
+		let extrinsics_num = 5;
+		let extrinsics = std::iter::once(
+			Transfer {
+				from: AccountKeyring::Alice.into(),
+				to: AccountKeyring::Bob.into(),
+				amount: 100,
+				nonce: 0,
+			}
+			.into_unchecked_extrinsic(),
+		)
+		.chain((1..extrinsics_num as u64).map(extrinsic))
+		.collect::<Vec<_>>();
+
+		let block_limit = genesis_header.encoded_size() +
+			extrinsics
+				.iter()
+				.take(extrinsics_num - 1)
+				.map(Encode::encoded_size)
+				.sum::<usize>() +
+			Vec::<Extrinsic>::new().encoded_size();
+
+		block_on(txpool.submit_at(&BlockId::number(0), SOURCE, extrinsics.clone())).unwrap();
+
+		block_on(txpool.maintain(chain_event(genesis_header.clone())));
+
+		let mut proposer_factory =
+			ProposerFactory::new(spawner.clone(), client.clone(), txpool.clone(), None, None);
+
+		let proposer = block_on(proposer_factory.init(&genesis_header)).unwrap();
+
+		// Give it enough time
+		let deadline = time::Duration::from_secs(300);
+		let block = block_on(proposer.propose(
+			Default::default(),
+			Default::default(),
+			deadline,
+			Some(block_limit),
+		))
+		.map(|r| r.block)
+		.unwrap();
+
+		// Based on the block limit, one transaction shouldn't be included.
+		assert_eq!(block.extrinsics().len(), extrinsics_num - 1);
+
+		let proposer = block_on(proposer_factory.init(&genesis_header)).unwrap();
+
+		let block =
+			block_on(proposer.propose(Default::default(), Default::default(), deadline, None))
+				.map(|r| r.block)
+				.unwrap();
+
+		// Without a block limit we should include all of them
+		assert_eq!(block.extrinsics().len(), extrinsics_num);
+
+		let mut proposer_factory = ProposerFactory::with_proof_recording(
+			spawner.clone(),
+			client.clone(),
+			txpool.clone(),
+			None,
+			None,
+		);
+
+		let proposer = block_on(proposer_factory.init(&genesis_header)).unwrap();
+
+		// Exact block_limit, which includes:
+		// 99 (header_size) + 718 (proof@initialize_block) + 246 (one Transfer extrinsic)
+		let block_limit = {
+			let builder =
+				client.new_block_at(genesis_header.hash(), Default::default(), true).unwrap();
+			builder.estimate_block_size(true) + extrinsics[0].encoded_size()
+		};
+		let block = block_on(proposer.propose(
+			Default::default(),
+			Default::default(),
+			deadline,
+			Some(block_limit),
+		))
+		.map(|r| r.block)
+		.unwrap();
+
+		// The block limit was increased, but we now include the proof in the estimation of the
+		// block size and thus, only the `Transfer` will fit into the block. It reads more data
+		// than we have reserved in the block limit.
+		assert_eq!(block.extrinsics().len(), 1);
+	}
+
+	#[test]
+	fn should_keep_adding_transactions_after_exhausts_resources_before_soft_deadline() {
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner.clone(),
+			client.clone(),
+		);
+
+		let tiny = |nonce| {
+			ExtrinsicBuilder::new_fill_block(Perbill::from_parts(TINY)).nonce(nonce).build()
+		};
+		let huge = |who| {
+			ExtrinsicBuilder::new_fill_block(Perbill::from_parts(HUGE))
+				.signer(AccountKeyring::numeric(who))
+				.build()
+		};
+
+		block_on(
+			txpool.submit_at(
+				&BlockId::number(0),
+				SOURCE,
+				// add 2 * MAX_SKIPPED_TRANSACTIONS that exhaust resources
+				(0..MAX_SKIPPED_TRANSACTIONS * 2)
+					.into_iter()
+					.map(huge)
+					// and some transactions that are okay.
+					.chain((0..MAX_SKIPPED_TRANSACTIONS as u64).into_iter().map(tiny))
+					.collect(),
+			),
+		)
+		.unwrap();
+
+		block_on(
+			txpool.maintain(chain_event(
+				client
+					.expect_header(client.info().genesis_hash)
+					.expect("there should be header"),
+			)),
+		);
+		assert_eq!(txpool.ready().count(), MAX_SKIPPED_TRANSACTIONS * 3);
+
+		let mut proposer_factory =
+			ProposerFactory::new(spawner.clone(), client.clone(), txpool.clone(), None, None);
+
+		let cell = Mutex::new(time::Instant::now());
+		let proposer = proposer_factory.init_with_now(
+			&client.expect_header(client.info().genesis_hash).unwrap(),
+			Box::new(move || {
+				let mut value = cell.lock();
+				let old = *value;
+				*value = old + time::Duration::from_secs(1);
+				old
+			}),
+		);
+
+		// when
+		// give it enough time so that deadline is never triggered.
+		let deadline = time::Duration::from_secs(900);
+		let block =
+			block_on(proposer.propose(Default::default(), Default::default(), deadline, None))
+				.map(|r| r.block)
+				.unwrap();
+
+		// then block should have all non-exhaust resources extrinsics (+ the first one).
+		assert_eq!(block.extrinsics().len(), MAX_SKIPPED_TRANSACTIONS + 1);
+	}
+
+	#[test]
+	fn should_only_skip_up_to_some_limit_after_soft_deadline() {
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let txpool = BasicPool::new_full(
+			Default::default(),
+			true.into(),
+			None,
+			spawner.clone(),
+			client.clone(),
+		);
+
+		let tiny = |who| {
+			ExtrinsicBuilder::new_fill_block(Perbill::from_parts(TINY))
+				.signer(AccountKeyring::numeric(who))
+				.nonce(1)
+				.build()
+		};
+		let huge = |who| {
+			ExtrinsicBuilder::new_fill_block(Perbill::from_parts(HUGE))
+				.signer(AccountKeyring::numeric(who))
+				.build()
+		};
+
+		block_on(
+			txpool.submit_at(
+				&BlockId::number(0),
+				SOURCE,
+				(0..MAX_SKIPPED_TRANSACTIONS + 2)
+					.into_iter()
+					.map(huge)
+					// and some transactions that are okay.
+					.chain((0..MAX_SKIPPED_TRANSACTIONS + 2).into_iter().map(tiny))
+					.collect(),
+			),
+		)
+		.unwrap();
+
+		block_on(
+			txpool.maintain(chain_event(
+				client
+					.expect_header(client.info().genesis_hash)
+					.expect("there should be header"),
+			)),
+		);
+		assert_eq!(txpool.ready().count(), MAX_SKIPPED_TRANSACTIONS * 2 + 4);
+
+		let mut proposer_factory =
+			ProposerFactory::new(spawner.clone(), client.clone(), txpool.clone(), None, None);
+
+		let deadline = time::Duration::from_secs(600);
+		let cell = Arc::new(Mutex::new((0, time::Instant::now())));
+		let cell2 = cell.clone();
+		let proposer = proposer_factory.init_with_now(
+			&client.expect_header(client.info().genesis_hash).unwrap(),
+			Box::new(move || {
+				let mut value = cell.lock();
+				let (called, old) = *value;
+				// add time after deadline is calculated internally (hence 1)
+				let increase = if called == 1 {
+					// we start after the soft_deadline should have already been reached.
+					deadline / 2
+				} else {
+					// but we make sure to never reach the actual deadline
+					time::Duration::from_millis(0)
+				};
+				*value = (called + 1, old + increase);
+				old
+			}),
+		);
+
+		let block =
+			block_on(proposer.propose(Default::default(), Default::default(), deadline, None))
+				.map(|r| r.block)
+				.unwrap();
+
+		// then the block should have one or two transactions. This maybe random as they are
+		// processed in parallel. The same signer and consecutive nonces for huge and tiny
+		// transactions guarantees that max two transactions will get to the block.
+		assert!(
+			(1..3).contains(&block.extrinsics().len()),
+			"Block shall contain one or two extrinsics."
+		);
+		assert!(
+			cell2.lock().0 > MAX_SKIPPED_TRANSACTIONS,
+			"Not enough calls to current time, which indicates the test might have ended because of deadline, not soft deadline"
+		);
+	}
+}
diff --git a/substrate/client/basic-authorship/src/lib.rs b/substrate/client/basic-authorship/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8f47c2ea00e6b3a9080d6d49c33cbb40c76bc958
--- /dev/null
+++ b/substrate/client/basic-authorship/src/lib.rs
@@ -0,0 +1,75 @@
+// 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/>.
+
+//! Basic implementation of block-authoring logic.
+//!
+//! # Example
+//!
+//! ```
+//! # use sc_basic_authorship::ProposerFactory;
+//! # use sp_consensus::{Environment, Proposer};
+//! # use sp_runtime::generic::BlockId;
+//! # use std::{sync::Arc, time::Duration};
+//! # use substrate_test_runtime_client::{
+//! #     runtime::Transfer, AccountKeyring,
+//! #     DefaultTestClientBuilderExt, TestClientBuilderExt,
+//! # };
+//! # use sc_transaction_pool::{BasicPool, FullChainApi};
+//! # let client = Arc::new(substrate_test_runtime_client::new());
+//! # let spawner = sp_core::testing::TaskExecutor::new();
+//! # let txpool = BasicPool::new_full(
+//! #     Default::default(),
+//! #     true.into(),
+//! #     None,
+//! #     spawner.clone(),
+//! #     client.clone(),
+//! # );
+//! // The first step is to create a `ProposerFactory`.
+//! let mut proposer_factory = ProposerFactory::new(
+//! 		spawner,
+//! 		client.clone(),
+//! 		txpool.clone(),
+//! 		None,
+//! 		None,
+//! 	);
+//!
+//! // From this factory, we create a `Proposer`.
+//! let proposer = proposer_factory.init(
+//! 	&client.header(client.chain_info().genesis_hash).unwrap().unwrap(),
+//! );
+//!
+//! // The proposer is created asynchronously.
+//! let proposer = futures::executor::block_on(proposer).unwrap();
+//!
+//! // This `Proposer` allows us to create a block proposition.
+//! // The proposer will grab transactions from the transaction pool, and put them into the block.
+//! let future = proposer.propose(
+//! 	Default::default(),
+//! 	Default::default(),
+//! 	Duration::from_secs(2),
+//! 	None,
+//! );
+//!
+//! // We wait until the proposition is performed.
+//! let block = futures::executor::block_on(future).unwrap();
+//! println!("Generated block: {:?}", block.block);
+//! ```
+
+mod basic_authorship;
+
+pub use crate::basic_authorship::{Proposer, ProposerFactory, DEFAULT_BLOCK_SIZE_LIMIT};
diff --git a/substrate/client/block-builder/Cargo.toml b/substrate/client/block-builder/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..18141b044188d0c7b496038ea31920b5e22316a6
--- /dev/null
+++ b/substrate/client/block-builder/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "sc-block-builder"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate block builder"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = [
+	"derive",
+] }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../primitives/block-builder" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../primitives/inherents" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+
+[dev-dependencies]
+sp-state-machine = { version = "0.28.0", path = "../../primitives/state-machine" }
+substrate-test-runtime-client = { path = "../../test-utils/runtime/client" }
diff --git a/substrate/client/block-builder/README.md b/substrate/client/block-builder/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b105d4203362f2bf373a665f083d2169a2cb9801
--- /dev/null
+++ b/substrate/client/block-builder/README.md
@@ -0,0 +1,9 @@
+Substrate block builder
+
+This crate provides the [`BlockBuilder`] utility and the corresponding runtime api
+[`BlockBuilder`](https://docs.rs/sc-block-builder/latest/sc_block_builder/struct.BlockBuilder.html).Error
+
+The block builder utility is used in the node as an abstraction over the runtime api to
+initialize a block, to push extrinsics and to finalize a block.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/block-builder/src/lib.rs b/substrate/client/block-builder/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1878e762748040c158fdbe7875af1eb205b6048b
--- /dev/null
+++ b/substrate/client/block-builder/src/lib.rs
@@ -0,0 +1,390 @@
+// 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/>.
+
+//! Substrate block builder
+//!
+//! This crate provides the [`BlockBuilder`] utility and the corresponding runtime api
+//! [`BlockBuilder`](sp_block_builder::BlockBuilder).
+//!
+//! The block builder utility is used in the node as an abstraction over the runtime api to
+//! initialize a block, to push extrinsics and to finalize a block.
+
+#![warn(missing_docs)]
+
+use codec::Encode;
+
+use sp_api::{
+	ApiExt, ApiRef, Core, ProvideRuntimeApi, StorageChanges, StorageProof, TransactionOutcome,
+};
+use sp_blockchain::{ApplyExtrinsicFailed, Error};
+use sp_core::traits::CallContext;
+use sp_runtime::{
+	legacy,
+	traits::{Block as BlockT, Hash, HashingFor, Header as HeaderT, NumberFor, One},
+	Digest,
+};
+
+use sc_client_api::backend;
+pub use sp_block_builder::BlockBuilder as BlockBuilderApi;
+
+/// Used as parameter to [`BlockBuilderProvider`] to express if proof recording should be enabled.
+///
+/// When `RecordProof::Yes` is given, all accessed trie nodes should be saved. These recorded
+/// trie nodes can be used by a third party to proof this proposal without having access to the
+/// full storage.
+#[derive(Copy, Clone, PartialEq)]
+pub enum RecordProof {
+	/// `Yes`, record a proof.
+	Yes,
+	/// `No`, don't record any proof.
+	No,
+}
+
+impl RecordProof {
+	/// Returns if `Self` == `Yes`.
+	pub fn yes(&self) -> bool {
+		matches!(self, Self::Yes)
+	}
+}
+
+/// Will return [`RecordProof::No`] as default value.
+impl Default for RecordProof {
+	fn default() -> Self {
+		Self::No
+	}
+}
+
+impl From<bool> for RecordProof {
+	fn from(val: bool) -> Self {
+		if val {
+			Self::Yes
+		} else {
+			Self::No
+		}
+	}
+}
+
+/// A block that was build by [`BlockBuilder`] plus some additional data.
+///
+/// This additional data includes the `storage_changes`, these changes can be applied to the
+/// backend to get the state of the block. Furthermore an optional `proof` is included which
+/// can be used to proof that the build block contains the expected data. The `proof` will
+/// only be set when proof recording was activated.
+pub struct BuiltBlock<Block: BlockT> {
+	/// The actual block that was build.
+	pub block: Block,
+	/// The changes that need to be applied to the backend to get the state of the build block.
+	pub storage_changes: StorageChanges<Block>,
+	/// An optional proof that was recorded while building the block.
+	pub proof: Option<StorageProof>,
+}
+
+impl<Block: BlockT> BuiltBlock<Block> {
+	/// Convert into the inner values.
+	pub fn into_inner(self) -> (Block, StorageChanges<Block>, Option<StorageProof>) {
+		(self.block, self.storage_changes, self.proof)
+	}
+}
+
+/// Block builder provider
+pub trait BlockBuilderProvider<B, Block, RA>
+where
+	Block: BlockT,
+	B: backend::Backend<Block>,
+	Self: Sized,
+	RA: ProvideRuntimeApi<Block>,
+{
+	/// Create a new block, built on top of `parent`.
+	///
+	/// When proof recording is enabled, all accessed trie nodes are saved.
+	/// These recorded trie nodes can be used by a third party to proof the
+	/// output of this block builder without having access to the full storage.
+	fn new_block_at<R: Into<RecordProof>>(
+		&self,
+		parent: Block::Hash,
+		inherent_digests: Digest,
+		record_proof: R,
+	) -> sp_blockchain::Result<BlockBuilder<Block, RA, B>>;
+
+	/// Create a new block, built on the head of the chain.
+	fn new_block(
+		&self,
+		inherent_digests: Digest,
+	) -> sp_blockchain::Result<BlockBuilder<Block, RA, B>>;
+}
+
+/// Utility for building new (valid) blocks from a stream of extrinsics.
+pub struct BlockBuilder<'a, Block: BlockT, A: ProvideRuntimeApi<Block>, B> {
+	extrinsics: Vec<Block::Extrinsic>,
+	api: ApiRef<'a, A::Api>,
+	version: u32,
+	parent_hash: Block::Hash,
+	backend: &'a B,
+	/// The estimated size of the block header.
+	estimated_header_size: usize,
+}
+
+impl<'a, Block, A, B> BlockBuilder<'a, Block, A, B>
+where
+	Block: BlockT,
+	A: ProvideRuntimeApi<Block> + 'a,
+	A::Api: BlockBuilderApi<Block> + ApiExt<Block>,
+	B: backend::Backend<Block>,
+{
+	/// Create a new instance of builder based on the given `parent_hash` and `parent_number`.
+	///
+	/// While proof recording is enabled, all accessed trie nodes are saved.
+	/// These recorded trie nodes can be used by a third party to prove the
+	/// output of this block builder without having access to the full storage.
+	pub fn new(
+		api: &'a A,
+		parent_hash: Block::Hash,
+		parent_number: NumberFor<Block>,
+		record_proof: RecordProof,
+		inherent_digests: Digest,
+		backend: &'a B,
+	) -> Result<Self, Error> {
+		let header = <<Block as BlockT>::Header as HeaderT>::new(
+			parent_number + One::one(),
+			Default::default(),
+			Default::default(),
+			parent_hash,
+			inherent_digests,
+		);
+
+		let estimated_header_size = header.encoded_size();
+
+		let mut api = api.runtime_api();
+
+		if record_proof.yes() {
+			api.record_proof();
+		}
+
+		api.set_call_context(CallContext::Onchain);
+
+		api.initialize_block(parent_hash, &header)?;
+
+		let version = api
+			.api_version::<dyn BlockBuilderApi<Block>>(parent_hash)?
+			.ok_or_else(|| Error::VersionInvalid("BlockBuilderApi".to_string()))?;
+
+		Ok(Self {
+			parent_hash,
+			extrinsics: Vec::new(),
+			api,
+			version,
+			backend,
+			estimated_header_size,
+		})
+	}
+
+	/// Push onto the block's list of extrinsics.
+	///
+	/// This will ensure the extrinsic can be validly executed (by executing it).
+	pub fn push(&mut self, xt: <Block as BlockT>::Extrinsic) -> Result<(), Error> {
+		let parent_hash = self.parent_hash;
+		let extrinsics = &mut self.extrinsics;
+		let version = self.version;
+
+		self.api.execute_in_transaction(|api| {
+			let res = if version < 6 {
+				#[allow(deprecated)]
+				api.apply_extrinsic_before_version_6(parent_hash, xt.clone())
+					.map(legacy::byte_sized_error::convert_to_latest)
+			} else {
+				api.apply_extrinsic(parent_hash, xt.clone())
+			};
+
+			match res {
+				Ok(Ok(_)) => {
+					extrinsics.push(xt);
+					TransactionOutcome::Commit(Ok(()))
+				},
+				Ok(Err(tx_validity)) => TransactionOutcome::Rollback(Err(
+					ApplyExtrinsicFailed::Validity(tx_validity).into(),
+				)),
+				Err(e) => TransactionOutcome::Rollback(Err(Error::from(e))),
+			}
+		})
+	}
+
+	/// Consume the builder to build a valid `Block` containing all pushed extrinsics.
+	///
+	/// Returns the build `Block`, the changes to the storage and an optional `StorageProof`
+	/// supplied by `self.api`, combined as [`BuiltBlock`].
+	/// The storage proof will be `Some(_)` when proof recording was enabled.
+	pub fn build(mut self) -> Result<BuiltBlock<Block>, Error> {
+		let header = self.api.finalize_block(self.parent_hash)?;
+
+		debug_assert_eq!(
+			header.extrinsics_root().clone(),
+			HashingFor::<Block>::ordered_trie_root(
+				self.extrinsics.iter().map(Encode::encode).collect(),
+				sp_runtime::StateVersion::V0,
+			),
+		);
+
+		let proof = self.api.extract_proof();
+
+		let state = self.backend.state_at(self.parent_hash)?;
+
+		let storage_changes = self
+			.api
+			.into_storage_changes(&state, self.parent_hash)
+			.map_err(sp_blockchain::Error::StorageChanges)?;
+
+		Ok(BuiltBlock {
+			block: <Block as BlockT>::new(header, self.extrinsics),
+			storage_changes,
+			proof,
+		})
+	}
+
+	/// Create the inherents for the block.
+	///
+	/// Returns the inherents created by the runtime or an error if something failed.
+	pub fn create_inherents(
+		&mut self,
+		inherent_data: sp_inherents::InherentData,
+	) -> Result<Vec<Block::Extrinsic>, Error> {
+		let parent_hash = self.parent_hash;
+		self.api
+			.execute_in_transaction(move |api| {
+				// `create_inherents` should not change any state, to ensure this we always rollback
+				// the transaction.
+				TransactionOutcome::Rollback(api.inherent_extrinsics(parent_hash, inherent_data))
+			})
+			.map_err(|e| Error::Application(Box::new(e)))
+	}
+
+	/// Estimate the size of the block in the current state.
+	///
+	/// If `include_proof` is `true`, the estimated size of the storage proof will be added
+	/// to the estimation.
+	pub fn estimate_block_size(&self, include_proof: bool) -> usize {
+		let size = self.estimated_header_size + self.extrinsics.encoded_size();
+
+		if include_proof {
+			size + self.api.proof_recorder().map(|pr| pr.estimate_encoded_size()).unwrap_or(0)
+		} else {
+			size
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_blockchain::HeaderBackend;
+	use sp_core::Blake2Hasher;
+	use sp_state_machine::Backend;
+	use substrate_test_runtime_client::{
+		runtime::ExtrinsicBuilder, DefaultTestClientBuilderExt, TestClientBuilderExt,
+	};
+
+	#[test]
+	fn block_building_storage_proof_does_not_include_runtime_by_default() {
+		let builder = substrate_test_runtime_client::TestClientBuilder::new();
+		let backend = builder.backend();
+		let client = builder.build();
+
+		let genesis_hash = client.info().best_hash;
+
+		let block = BlockBuilder::new(
+			&client,
+			genesis_hash,
+			client.info().best_number,
+			RecordProof::Yes,
+			Default::default(),
+			&*backend,
+		)
+		.unwrap()
+		.build()
+		.unwrap();
+
+		let proof = block.proof.expect("Proof is build on request");
+		let genesis_state_root = client.header(genesis_hash).unwrap().unwrap().state_root;
+
+		let backend =
+			sp_state_machine::create_proof_check_backend::<Blake2Hasher>(genesis_state_root, proof)
+				.unwrap();
+
+		assert!(backend
+			.storage(&sp_core::storage::well_known_keys::CODE)
+			.unwrap_err()
+			.contains("Database missing expected key"),);
+	}
+
+	#[test]
+	fn failing_extrinsic_rolls_back_changes_in_storage_proof() {
+		let builder = substrate_test_runtime_client::TestClientBuilder::new();
+		let backend = builder.backend();
+		let client = builder.build();
+
+		let mut block_builder = BlockBuilder::new(
+			&client,
+			client.info().best_hash,
+			client.info().best_number,
+			RecordProof::Yes,
+			Default::default(),
+			&*backend,
+		)
+		.unwrap();
+
+		block_builder.push(ExtrinsicBuilder::new_read_and_panic(8).build()).unwrap_err();
+
+		let block = block_builder.build().unwrap();
+
+		let proof_with_panic = block.proof.expect("Proof is build on request").encoded_size();
+
+		let mut block_builder = BlockBuilder::new(
+			&client,
+			client.info().best_hash,
+			client.info().best_number,
+			RecordProof::Yes,
+			Default::default(),
+			&*backend,
+		)
+		.unwrap();
+
+		block_builder.push(ExtrinsicBuilder::new_read(8).build()).unwrap();
+
+		let block = block_builder.build().unwrap();
+
+		let proof_without_panic = block.proof.expect("Proof is build on request").encoded_size();
+
+		let block = BlockBuilder::new(
+			&client,
+			client.info().best_hash,
+			client.info().best_number,
+			RecordProof::Yes,
+			Default::default(),
+			&*backend,
+		)
+		.unwrap()
+		.build()
+		.unwrap();
+
+		let proof_empty_block = block.proof.expect("Proof is build on request").encoded_size();
+
+		// Ensure that we rolled back the changes of the panicked transaction.
+		assert!(proof_without_panic > proof_with_panic);
+		assert!(proof_without_panic > proof_empty_block);
+		assert_eq!(proof_empty_block, proof_with_panic);
+	}
+}
diff --git a/substrate/client/chain-spec/Cargo.toml b/substrate/client/chain-spec/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1b4ce6e44605abf9cc806a413df5f5dddebb9d99
--- /dev/null
+++ b/substrate/client/chain-spec/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "sc-chain-spec"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate chain configurations."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+memmap2 = "0.5.0"
+serde = { version = "1.0.163", features = ["derive"] }
+serde_json = "1.0.85"
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-chain-spec-derive = { version = "4.0.0-dev", path = "./derive" }
+sc-executor = { version = "0.10.0-dev", path = "../executor" }
+sc-network = { version = "0.10.0-dev", path = "../network" }
+sc-telemetry = { version = "4.0.0-dev", path = "../telemetry" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../primitives/state-machine" }
diff --git a/substrate/client/chain-spec/README.md b/substrate/client/chain-spec/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5525affbed81ccf343af1496ac3e384b110a32c1
--- /dev/null
+++ b/substrate/client/chain-spec/README.md
@@ -0,0 +1,92 @@
+Substrate chain configurations.
+
+This crate contains structs and utilities to declare
+a runtime-specific configuration file (a.k.a chain spec).
+
+Basic chain spec type containing all required parameters is
+[`ChainSpec`](https://docs.rs/sc-chain-spec/latest/sc_chain_spec/struct.GenericChainSpec.html). It can be extended with
+additional options that contain configuration specific to your chain.
+Usually the extension is going to be an amalgamate of types exposed
+by Substrate core modules. To allow the core modules to retrieve
+their configuration from your extension you should use `ChainSpecExtension`
+macro exposed by this crate.
+
+```rust
+use std::collections::HashMap;
+use sc_chain_spec::{GenericChainSpec, ChainSpecExtension};
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecExtension)]
+pub struct MyExtension {
+		pub known_blocks: HashMap<u64, String>,
+}
+
+pub type MyChainSpec<G> = GenericChainSpec<G, MyExtension>;
+```
+
+Some parameters may require different values depending on the
+current blockchain height (a.k.a. forks). You can use `ChainSpecGroup`
+macro and provided [`Forks`](https://docs.rs/sc-chain-spec/latest/sc_chain_spec/struct.Forks.html) structure to put
+such parameters to your chain spec.
+This will allow to override a single parameter starting at specific
+block number.
+
+```rust
+use sc_chain_spec::{Forks, ChainSpecGroup, ChainSpecExtension, GenericChainSpec};
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecGroup)]
+pub struct ClientParams {
+		max_block_size: usize,
+		max_extrinsic_size: usize,
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecGroup)]
+pub struct PoolParams {
+		max_transaction_size: usize,
+}
+
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecGroup, ChainSpecExtension)]
+pub struct Extension {
+		pub client: ClientParams,
+		pub pool: PoolParams,
+}
+
+pub type BlockNumber = u64;
+
+/// A chain spec supporting forkable `ClientParams`.
+pub type MyChainSpec1<G> = GenericChainSpec<G, Forks<BlockNumber, ClientParams>>;
+
+/// A chain spec supporting forkable `Extension`.
+pub type MyChainSpec2<G> = GenericChainSpec<G, Forks<BlockNumber, Extension>>;
+```
+
+It's also possible to have a set of parameters that is allowed to change
+with block numbers (i.e. is forkable), and another set that is not subject to changes.
+This is also possible by declaring an extension that contains `Forks` within it.
+
+
+```rust
+use serde::{Serialize, Deserialize};
+use sc_chain_spec::{Forks, GenericChainSpec, ChainSpecGroup, ChainSpecExtension};
+
+#[derive(Clone, Debug, Serialize, Deserialize, ChainSpecGroup)]
+pub struct ClientParams {
+		max_block_size: usize,
+		max_extrinsic_size: usize,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ChainSpecGroup)]
+pub struct PoolParams {
+		max_transaction_size: usize,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ChainSpecExtension)]
+pub struct Extension {
+		pub client: ClientParams,
+		#[forks]
+		pub pool: Forks<u64, PoolParams>,
+}
+
+pub type MyChainSpec<G> = GenericChainSpec<G, Extension>;
+```
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/chain-spec/derive/Cargo.toml b/substrate/client/chain-spec/derive/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..537f8aee6ab600154557000ce4c857baf63fe76c
--- /dev/null
+++ b/substrate/client/chain-spec/derive/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "sc-chain-spec-derive"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Macros to derive chain spec extension traits implementation."
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro-crate = "1.1.3"
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = "2.0.16"
diff --git a/substrate/client/chain-spec/derive/src/impls.rs b/substrate/client/chain-spec/derive/src/impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c0624897c133e6ebd3ecda6556d628dccee3c53b
--- /dev/null
+++ b/substrate/client/chain-spec/derive/src/impls.rs
@@ -0,0 +1,222 @@
+// 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 proc_macro2::{Span, TokenStream};
+use proc_macro_crate::{crate_name, FoundCrate};
+use quote::quote;
+use syn::{DeriveInput, Error, Ident};
+
+const CRATE_NAME: &str = "sc-chain-spec";
+const ATTRIBUTE_NAME: &str = "forks";
+
+/// Implements `Extension's` `Group` accessor.
+///
+/// The struct that derives this implementation will be usable within the `ChainSpec` file.
+/// The derive implements a by-type accessor method.
+pub fn extension_derive(ast: &DeriveInput) -> proc_macro::TokenStream {
+	derive(ast, |crate_name, name, generics: &syn::Generics, field_names, field_types, fields| {
+		let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+		let forks = fields
+			.named
+			.iter()
+			.find_map(|f| {
+				if f.attrs.iter().any(|attr| attr.path().is_ident(ATTRIBUTE_NAME)) {
+					let typ = &f.ty;
+					Some(quote! { #typ })
+				} else {
+					None
+				}
+			})
+			.unwrap_or_else(|| quote! { #crate_name::NoExtension });
+
+		quote! {
+			impl #impl_generics #crate_name::Extension for #name #ty_generics #where_clause {
+				type Forks = #forks;
+
+				fn get<T: 'static>(&self) -> Option<&T> {
+					use std::any::{Any, TypeId};
+
+					match TypeId::of::<T>() {
+						#( x if x == TypeId::of::<#field_types>() => <dyn Any>::downcast_ref(&self.#field_names) ),*,
+						_ => None,
+					}
+				}
+
+				fn get_any(&self, t: std::any::TypeId) -> &dyn std::any::Any {
+					use std::any::{Any, TypeId};
+
+					match t {
+						#( x if x == TypeId::of::<#field_types>() => &self.#field_names ),*,
+						_ => self,
+					}
+				}
+
+				fn get_any_mut(&mut self, t: std::any::TypeId) -> &mut dyn std::any::Any {
+					use std::any::{Any, TypeId};
+
+					match t {
+						#( x if x == TypeId::of::<#field_types>() => &mut self.#field_names ),*,
+						_ => self,
+					}
+				}
+			}
+		}
+	})
+}
+
+/// Implements required traits and creates `Fork` structs for `ChainSpec` custom parameter group.
+pub fn group_derive(ast: &DeriveInput) -> proc_macro::TokenStream {
+	derive(ast, |crate_name, name, generics: &syn::Generics, field_names, field_types, _fields| {
+		let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+		let fork_name = Ident::new(&format!("{}Fork", name), Span::call_site());
+
+		let fork_fields = generate_fork_fields(crate_name, &field_names, &field_types);
+		let to_fork = generate_base_to_fork(&fork_name, &field_names);
+		let combine_with = generate_combine_with(&field_names);
+		let to_base = generate_fork_to_base(name, &field_names);
+		let serde_crate_name = match proc_macro_crate::crate_name("serde") {
+			Ok(FoundCrate::Itself) => Ident::new("serde", Span::call_site()),
+			Ok(FoundCrate::Name(name)) => Ident::new(&name, Span::call_site()),
+			Err(e) => {
+				let err =
+					Error::new(Span::call_site(), &format!("Could not find `serde` crate: {}", e))
+						.to_compile_error();
+
+				return quote!( #err )
+			},
+		};
+
+		quote! {
+			#[derive(
+				Debug,
+				Clone,
+				PartialEq,
+				#serde_crate_name::Serialize,
+				#serde_crate_name::Deserialize,
+				ChainSpecExtension,
+			)]
+			pub struct #fork_name #ty_generics #where_clause {
+				#fork_fields
+			}
+
+			impl #impl_generics #crate_name::Group for #name #ty_generics #where_clause {
+				type Fork = #fork_name #ty_generics;
+
+				fn to_fork(self) -> Self::Fork {
+					use #crate_name::Group;
+					#to_fork
+				}
+			}
+
+			impl #impl_generics #crate_name::Fork for #fork_name #ty_generics #where_clause {
+				type Base = #name #ty_generics;
+
+				fn combine_with(&mut self, other: Self) {
+					use #crate_name::Fork;
+					#combine_with
+				}
+
+				fn to_base(self) -> Option<Self::Base> {
+					use #crate_name::Fork;
+					#to_base
+				}
+			}
+		}
+	})
+}
+
+pub fn derive(
+	ast: &DeriveInput,
+	derive: impl Fn(
+		&Ident,
+		&Ident,
+		&syn::Generics,
+		Vec<&Ident>,
+		Vec<&syn::Type>,
+		&syn::FieldsNamed,
+	) -> TokenStream,
+) -> proc_macro::TokenStream {
+	let err = || {
+		let err = Error::new(
+			Span::call_site(),
+			"ChainSpecGroup is only available for structs with named fields.",
+		)
+		.to_compile_error();
+		quote!( #err ).into()
+	};
+
+	let data = match &ast.data {
+		syn::Data::Struct(ref data) => data,
+		_ => return err(),
+	};
+
+	let fields = match &data.fields {
+		syn::Fields::Named(ref named) => named,
+		_ => return err(),
+	};
+
+	let name = &ast.ident;
+	let crate_name = 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()
+		},
+	};
+	let crate_name = Ident::new(&crate_name, Span::call_site());
+	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()
+}
+
+fn generate_fork_fields(crate_name: &Ident, names: &[&Ident], types: &[&syn::Type]) -> TokenStream {
+	let crate_name = std::iter::repeat(crate_name);
+	quote! {
+		#( pub #names: Option<<#types as #crate_name::Group>::Fork>, )*
+	}
+}
+
+fn generate_base_to_fork(fork_name: &Ident, names: &[&Ident]) -> TokenStream {
+	let names2 = names.to_vec();
+
+	quote! {
+		#fork_name {
+			#( #names: Some(self.#names2.to_fork()), )*
+		}
+	}
+}
+
+fn generate_combine_with(names: &[&Ident]) -> TokenStream {
+	let names2 = names.to_vec();
+
+	quote! {
+		#( self.#names.combine_with(other.#names2); )*
+	}
+}
+
+fn generate_fork_to_base(fork: &Ident, names: &[&Ident]) -> TokenStream {
+	let names2 = names.to_vec();
+
+	quote! {
+		Some(#fork {
+			#( #names: self.#names2?.to_base()?, )*
+		})
+	}
+}
diff --git a/substrate/client/chain-spec/derive/src/lib.rs b/substrate/client/chain-spec/derive/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7607c6fdcff42b940e46a09099b0d08f3fc4b561
--- /dev/null
+++ b/substrate/client/chain-spec/derive/src/lib.rs
@@ -0,0 +1,39 @@
+// 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/>.
+
+//! Macros to derive chain spec extension traits implementation.
+
+mod impls;
+
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(ChainSpecGroup)]
+pub fn group_derive(input: TokenStream) -> TokenStream {
+	match syn::parse(input) {
+		Ok(ast) => impls::group_derive(&ast),
+		Err(e) => e.to_compile_error().into(),
+	}
+}
+
+#[proc_macro_derive(ChainSpecExtension, attributes(forks))]
+pub fn extensions_derive(input: TokenStream) -> TokenStream {
+	match syn::parse(input) {
+		Ok(ast) => impls::extension_derive(&ast),
+		Err(e) => e.to_compile_error().into(),
+	}
+}
diff --git a/substrate/client/chain-spec/res/chain_spec.json b/substrate/client/chain-spec/res/chain_spec.json
new file mode 100644
index 0000000000000000000000000000000000000000..c3365a9192f6e7717ef12d5469bd8f7bd1bd7f22
--- /dev/null
+++ b/substrate/client/chain-spec/res/chain_spec.json
@@ -0,0 +1,30 @@
+{
+	"name": "Flaming Fir",
+	"id": "flaming-fir",
+	"properties": {
+		"tokenDecimals": 15,
+		"tokenSymbol": "FIR"
+	},
+	"bootNodes": [
+		"/ip4/35.246.224.91/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV",
+		"/ip4/35.246.224.91/tcp/30334/ws/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV",
+		"/ip4/35.246.210.11/tcp/30333/p2p/QmWv9Ww7znzgLFyCzf21SR6tUKXrmHCZH9KhebeH4gyE9f",
+		"/ip4/35.246.210.11/tcp/30334/ws/p2p/QmWv9Ww7znzgLFyCzf21SR6tUKXrmHCZH9KhebeH4gyE9f",
+		"/ip4/35.198.110.45/tcp/30333/p2p/QmTtcYKJho9vFmqtMA548QBSmLbmwAkBSiEKK3kWKfb6bJ",
+		"/ip4/35.198.110.45/tcp/30334/ws/p2p/QmTtcYKJho9vFmqtMA548QBSmLbmwAkBSiEKK3kWKfb6bJ",
+		"/ip4/35.198.114.154/tcp/30333/p2p/QmQJmDorK9c8KjMF5PdWiH2WGUXyzJtgTeJ55S5gggdju6",
+		"/ip4/35.198.114.154/tcp/30334/ws/p2p/QmQJmDorK9c8KjMF5PdWiH2WGUXyzJtgTeJ55S5gggdju6"
+	],
+	"telemetryEndpoints": [
+		["wss://telemetry.polkadot.io/submit/", 0]
+	],
+	"protocolId": "fir",
+	"genesis": {
+		"raw": [
+			{
+				"0xb2029f8665aac509629f2d28cea790a3": "0x10f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c26633919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f437800299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d655633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce440482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde787932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d129becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe96993326e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f91066e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106"
+			},
+			{}
+		]
+	}
+}
diff --git a/substrate/client/chain-spec/res/chain_spec2.json b/substrate/client/chain-spec/res/chain_spec2.json
new file mode 100644
index 0000000000000000000000000000000000000000..00b9d603ae29e9d235e6f46c885790d0bac4910e
--- /dev/null
+++ b/substrate/client/chain-spec/res/chain_spec2.json
@@ -0,0 +1,31 @@
+{
+	"name": "Flaming Fir",
+	"id": "flaming-fir",
+	"properties": {
+		"tokenDecimals": 15,
+		"tokenSymbol": "FIR"
+	},
+	"bootNodes": [
+		"/ip4/35.246.224.91/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV",
+		"/ip4/35.246.224.91/tcp/30334/ws/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV",
+		"/ip4/35.246.210.11/tcp/30333/p2p/QmWv9Ww7znzgLFyCzf21SR6tUKXrmHCZH9KhebeH4gyE9f",
+		"/ip4/35.246.210.11/tcp/30334/ws/p2p/QmWv9Ww7znzgLFyCzf21SR6tUKXrmHCZH9KhebeH4gyE9f",
+		"/ip4/35.198.110.45/tcp/30333/p2p/QmTtcYKJho9vFmqtMA548QBSmLbmwAkBSiEKK3kWKfb6bJ",
+		"/ip4/35.198.110.45/tcp/30334/ws/p2p/QmTtcYKJho9vFmqtMA548QBSmLbmwAkBSiEKK3kWKfb6bJ",
+		"/ip4/35.198.114.154/tcp/30333/p2p/QmQJmDorK9c8KjMF5PdWiH2WGUXyzJtgTeJ55S5gggdju6",
+		"/ip4/35.198.114.154/tcp/30334/ws/p2p/QmQJmDorK9c8KjMF5PdWiH2WGUXyzJtgTeJ55S5gggdju6"
+	],
+	"telemetryEndpoints": [
+		["wss://telemetry.polkadot.io/submit/", 0]
+	],
+	"protocolId": "fir",
+	"myProperty": "Test Extension",
+	"genesis": {
+		"raw": [
+			{
+				"0xb2029f8665aac509629f2d28cea790a3": "0x10f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c26633919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f437800299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d655633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce440482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde787932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d129becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe96993326e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f91066e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106"
+			},
+			{}
+		]
+	}
+}
diff --git a/substrate/client/chain-spec/src/chain_spec.rs b/substrate/client/chain-spec/src/chain_spec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..96e36d8399ed5de6328553200d181c0a661c422d
--- /dev/null
+++ b/substrate/client/chain-spec/src/chain_spec.rs
@@ -0,0 +1,539 @@
+// 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/>.
+
+//! Substrate chain configurations.
+#![warn(missing_docs)]
+
+use crate::{extension::GetExtension, ChainType, Properties, RuntimeGenesis};
+use sc_network::config::MultiaddrWithPeerId;
+use sc_telemetry::TelemetryEndpoints;
+use serde::{Deserialize, Serialize};
+use serde_json as json;
+use sp_core::{
+	storage::{ChildInfo, Storage, StorageChild, StorageData, StorageKey},
+	Bytes,
+};
+use sp_runtime::BuildStorage;
+use std::{borrow::Cow, collections::BTreeMap, fs::File, path::PathBuf, sync::Arc};
+
+enum GenesisSource<G> {
+	File(PathBuf),
+	Binary(Cow<'static, [u8]>),
+	Factory(Arc<dyn Fn() -> G + Send + Sync>),
+	Storage(Storage),
+}
+
+impl<G> Clone for GenesisSource<G> {
+	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) => Self::Factory(f.clone()),
+			Self::Storage(ref s) => Self::Storage(s.clone()),
+		}
+	}
+}
+
+impl<G: RuntimeGenesis> GenesisSource<G> {
+	fn resolve(&self) -> Result<Genesis<G>, String> {
+		#[derive(Serialize, Deserialize)]
+		struct GenesisContainer<G> {
+			genesis: Genesis<G>,
+		}
+
+		match self {
+			Self::File(path) => {
+				let file = File::open(path).map_err(|e| {
+					format!("Error opening spec file at `{}`: {}", path.display(), e)
+				})?;
+				// SAFETY: `mmap` is fundamentally unsafe since technically the file can change
+				//         underneath us while it is mapped; in practice it's unlikely to be a
+				//         problem
+				let bytes = unsafe {
+					memmap2::Mmap::map(&file).map_err(|e| {
+						format!("Error mmaping spec file `{}`: {}", path.display(), e)
+					})?
+				};
+
+				let genesis: GenesisContainer<G> = 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())
+					.map_err(|e| format!("Error parsing embedded file: {}", e))?;
+				Ok(genesis.genesis)
+			},
+			Self::Factory(f) => Ok(Genesis::Runtime(f())),
+			Self::Storage(storage) => {
+				let top = storage
+					.top
+					.iter()
+					.map(|(k, v)| (StorageKey(k.clone()), StorageData(v.clone())))
+					.collect();
+
+				let children_default = storage
+					.children_default
+					.iter()
+					.map(|(k, child)| {
+						(
+							StorageKey(k.clone()),
+							child
+								.data
+								.iter()
+								.map(|(k, v)| (StorageKey(k.clone()), StorageData(v.clone())))
+								.collect(),
+						)
+					})
+					.collect();
+
+				Ok(Genesis::Raw(RawGenesis { top, children_default }))
+			},
+		}
+	}
+}
+
+impl<G: RuntimeGenesis, E> BuildStorage for ChainSpec<G, E> {
+	fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> {
+		match self.genesis.resolve()? {
+			Genesis::Runtime(gc) => gc.assimilate_storage(storage),
+			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)| {
+					let child_info = ChildInfo::new_default(k.0.as_slice());
+					storage
+						.children_default
+						.entry(k.0)
+						.or_insert_with(|| StorageChild { data: Default::default(), child_info })
+						.data
+						.extend(v.into_iter().map(|(k, v)| (k.0, v.0)));
+				});
+				Ok(())
+			},
+			// The `StateRootHash` variant exists as a way to keep note that other clients support
+			// it, but Substrate itself isn't capable of loading chain specs with just a hash at the
+			// moment.
+			Genesis::StateRootHash(_) => Err("Genesis storage in hash format not supported".into()),
+		}
+	}
+}
+
+pub type GenesisStorage = BTreeMap<StorageKey, StorageData>;
+
+/// Raw storage content for genesis block.
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
+pub struct RawGenesis {
+	pub top: GenesisStorage,
+	pub children_default: BTreeMap<StorageKey, GenesisStorage>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
+enum Genesis<G> {
+	Runtime(G),
+	Raw(RawGenesis),
+	/// State root hash of the genesis storage.
+	StateRootHash(StorageData),
+}
+
+/// A configuration of a client. Does not include runtime storage initialization.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
+struct ClientSpec<E> {
+	name: String,
+	id: String,
+	#[serde(default)]
+	chain_type: ChainType,
+	boot_nodes: Vec<MultiaddrWithPeerId>,
+	telemetry_endpoints: Option<TelemetryEndpoints>,
+	protocol_id: Option<String>,
+	/// Arbitrary string. Nodes will only synchronize with other nodes that have the same value
+	/// in their `fork_id`. This can be used in order to segregate nodes in cases when multiple
+	/// chains have the same genesis hash.
+	#[serde(default = "Default::default", skip_serializing_if = "Option::is_none")]
+	fork_id: Option<String>,
+	properties: Option<Properties>,
+	#[serde(flatten)]
+	extensions: E,
+	// Never used, left only for backward compatibility.
+	#[serde(default, skip_serializing)]
+	#[allow(unused)]
+	consensus_engine: (),
+	#[serde(skip_serializing)]
+	#[allow(unused)]
+	genesis: serde::de::IgnoredAny,
+	/// Mapping from `block_number` to `wasm_code`.
+	///
+	/// The given `wasm_code` will be used to substitute the on-chain wasm code starting with the
+	/// given block number until the `spec_version` on chain changes.
+	#[serde(default)]
+	code_substitutes: BTreeMap<String, Bytes>,
+}
+
+/// A type denoting empty extensions.
+///
+/// We use `Option` here since `()` is not flattenable by serde.
+pub type NoExtension = Option<()>;
+
+/// A configuration of a chain. Can be used to build a genesis block.
+pub struct ChainSpec<G, E = NoExtension> {
+	client_spec: ClientSpec<E>,
+	genesis: GenesisSource<G>,
+}
+
+impl<G, E: Clone> Clone for ChainSpec<G, E> {
+	fn clone(&self) -> Self {
+		ChainSpec { client_spec: self.client_spec.clone(), genesis: self.genesis.clone() }
+	}
+}
+
+impl<G, E> ChainSpec<G, E> {
+	/// A list of bootnode addresses.
+	pub fn boot_nodes(&self) -> &[MultiaddrWithPeerId] {
+		&self.client_spec.boot_nodes
+	}
+
+	/// Spec name.
+	pub fn name(&self) -> &str {
+		&self.client_spec.name
+	}
+
+	/// Spec id.
+	pub fn id(&self) -> &str {
+		&self.client_spec.id
+	}
+
+	/// Telemetry endpoints (if any)
+	pub fn telemetry_endpoints(&self) -> &Option<TelemetryEndpoints> {
+		&self.client_spec.telemetry_endpoints
+	}
+
+	/// Network protocol id.
+	pub fn protocol_id(&self) -> Option<&str> {
+		self.client_spec.protocol_id.as_deref()
+	}
+
+	/// Optional network fork identifier.
+	pub fn fork_id(&self) -> Option<&str> {
+		self.client_spec.fork_id.as_deref()
+	}
+
+	/// Additional loosly-typed properties of the chain.
+	///
+	/// Returns an empty JSON object if 'properties' not defined in config
+	pub fn properties(&self) -> Properties {
+		self.client_spec.properties.as_ref().unwrap_or(&json::map::Map::new()).clone()
+	}
+
+	/// Add a bootnode to the list.
+	pub fn add_boot_node(&mut self, addr: MultiaddrWithPeerId) {
+		self.client_spec.boot_nodes.push(addr)
+	}
+
+	/// Returns a reference to the defined chain spec extensions.
+	pub fn extensions(&self) -> &E {
+		&self.client_spec.extensions
+	}
+
+	/// Returns a mutable reference to the defined chain spec extensions.
+	pub fn extensions_mut(&mut self) -> &mut E {
+		&mut self.client_spec.extensions
+	}
+
+	/// Create hardcoded spec.
+	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,
+	) -> 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)) }
+	}
+
+	/// Type of the chain.
+	fn chain_type(&self) -> ChainType {
+		self.client_spec.chain_type.clone()
+	}
+}
+
+impl<G, E: serde::de::DeserializeOwned> ChainSpec<G, E> {
+	/// Parse json content into a `ChainSpec`
+	pub fn from_json_bytes(json: impl Into<Cow<'static, [u8]>>) -> Result<Self, String> {
+		let json = json.into();
+		let client_spec = json::from_slice(json.as_ref())
+			.map_err(|e| format!("Error parsing spec file: {}", e))?;
+		Ok(ChainSpec { client_spec, genesis: GenesisSource::Binary(json) })
+	}
+
+	/// Parse json file into a `ChainSpec`
+	pub fn from_json_file(path: PathBuf) -> Result<Self, String> {
+		// We mmap the file into memory first, as this is *a lot* faster than using
+		// `serde_json::from_reader`. See https://github.com/serde-rs/json/issues/160
+		let file = File::open(&path)
+			.map_err(|e| format!("Error opening spec file `{}`: {}", path.display(), e))?;
+
+		// SAFETY: `mmap` is fundamentally unsafe since technically the file can change
+		//         underneath us while it is mapped; in practice it's unlikely to be a problem
+		let bytes = unsafe {
+			memmap2::Mmap::map(&file)
+				.map_err(|e| format!("Error mmaping spec file `{}`: {}", path.display(), e))?
+		};
+
+		let client_spec =
+			json::from_slice(&bytes).map_err(|e| format!("Error parsing spec file: {}", e))?;
+		Ok(ChainSpec { client_spec, genesis: GenesisSource::File(path) })
+	}
+}
+
+#[derive(Serialize, Deserialize)]
+struct JsonContainer<G, E> {
+	#[serde(flatten)]
+	client_spec: ClientSpec<E>,
+	genesis: Genesis<G>,
+}
+
+impl<G: RuntimeGenesis, E: serde::Serialize + Clone + 'static> ChainSpec<G, E> {
+	fn json_container(&self, raw: bool) -> Result<JsonContainer<G, E>, String> {
+		let genesis = match (raw, self.genesis.resolve()?) {
+			(true, Genesis::Runtime(g)) => {
+				let storage = g.build_storage()?;
+				let top =
+					storage.top.into_iter().map(|(k, v)| (StorageKey(k), StorageData(v))).collect();
+				let children_default = storage
+					.children_default
+					.into_iter()
+					.map(|(sk, child)| {
+						(
+							StorageKey(sk),
+							child
+								.data
+								.into_iter()
+								.map(|(k, v)| (StorageKey(k), StorageData(v)))
+								.collect(),
+						)
+					})
+					.collect();
+
+				Genesis::Raw(RawGenesis { top, children_default })
+			},
+			(_, genesis) => genesis,
+		};
+		Ok(JsonContainer { client_spec: self.client_spec.clone(), genesis })
+	}
+
+	/// Dump to json string.
+	pub fn as_json(&self, raw: bool) -> Result<String, String> {
+		let container = self.json_container(raw)?;
+		json::to_string_pretty(&container).map_err(|e| format!("Error generating spec json: {}", e))
+	}
+}
+
+impl<G, E> crate::ChainSpec for ChainSpec<G, E>
+where
+	G: RuntimeGenesis + 'static,
+	E: GetExtension + serde::Serialize + Clone + Send + Sync + 'static,
+{
+	fn boot_nodes(&self) -> &[MultiaddrWithPeerId] {
+		ChainSpec::boot_nodes(self)
+	}
+
+	fn name(&self) -> &str {
+		ChainSpec::name(self)
+	}
+
+	fn id(&self) -> &str {
+		ChainSpec::id(self)
+	}
+
+	fn chain_type(&self) -> ChainType {
+		ChainSpec::chain_type(self)
+	}
+
+	fn telemetry_endpoints(&self) -> &Option<TelemetryEndpoints> {
+		ChainSpec::telemetry_endpoints(self)
+	}
+
+	fn protocol_id(&self) -> Option<&str> {
+		ChainSpec::protocol_id(self)
+	}
+
+	fn fork_id(&self) -> Option<&str> {
+		ChainSpec::fork_id(self)
+	}
+
+	fn properties(&self) -> Properties {
+		ChainSpec::properties(self)
+	}
+
+	fn add_boot_node(&mut self, addr: MultiaddrWithPeerId) {
+		ChainSpec::add_boot_node(self, addr)
+	}
+
+	fn extensions(&self) -> &dyn GetExtension {
+		ChainSpec::extensions(self) as &dyn GetExtension
+	}
+
+	fn extensions_mut(&mut self) -> &mut dyn GetExtension {
+		ChainSpec::extensions_mut(self) as &mut dyn GetExtension
+	}
+
+	fn as_json(&self, raw: bool) -> Result<String, String> {
+		ChainSpec::as_json(self, raw)
+	}
+
+	fn as_storage_builder(&self) -> &dyn BuildStorage {
+		self
+	}
+
+	fn cloned_box(&self) -> Box<dyn crate::ChainSpec> {
+		Box::new(self.clone())
+	}
+
+	fn set_storage(&mut self, storage: Storage) {
+		self.genesis = GenesisSource::Storage(storage);
+	}
+
+	fn code_substitutes(&self) -> std::collections::BTreeMap<String, Vec<u8>> {
+		self.client_spec
+			.code_substitutes
+			.iter()
+			.map(|(h, c)| (h.clone(), c.0.clone()))
+			.collect()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[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>;
+
+	#[test]
+	fn should_deserialize_example_chain_spec() {
+		let spec1 = TestSpec::from_json_bytes(Cow::Owned(
+			include_bytes!("../res/chain_spec.json").to_vec(),
+		))
+		.unwrap();
+		let spec2 = TestSpec::from_json_file(PathBuf::from("./res/chain_spec.json")).unwrap();
+
+		assert_eq!(spec1.as_json(false), spec2.as_json(false));
+		assert_eq!(spec2.chain_type(), ChainType::Live)
+	}
+
+	#[derive(Debug, Serialize, Deserialize, Clone)]
+	#[serde(rename_all = "camelCase")]
+	struct Extension1 {
+		my_property: String,
+	}
+
+	impl crate::Extension for Extension1 {
+		type Forks = Option<()>;
+
+		fn get<T: 'static>(&self) -> Option<&T> {
+			None
+		}
+
+		fn get_any(&self, _: std::any::TypeId) -> &dyn std::any::Any {
+			self
+		}
+
+		fn get_any_mut(&mut self, _: std::any::TypeId) -> &mut dyn std::any::Any {
+			self
+		}
+	}
+
+	type TestSpec2 = ChainSpec<Genesis, Extension1>;
+
+	#[test]
+	fn should_deserialize_chain_spec_with_extensions() {
+		let spec = TestSpec2::from_json_bytes(Cow::Owned(
+			include_bytes!("../res/chain_spec2.json").to_vec(),
+		))
+		.unwrap();
+
+		assert_eq!(spec.extensions().my_property, "Test Extension");
+	}
+
+	#[test]
+	fn chain_spec_raw_output_should_be_deterministic() {
+		let mut spec = TestSpec2::from_json_bytes(Cow::Owned(
+			include_bytes!("../res/chain_spec2.json").to_vec(),
+		))
+		.unwrap();
+
+		let mut storage = spec.build_storage().unwrap();
+
+		// Add some extra data, so that storage "sorting" is tested.
+		let extra_data = &[("random_key", "val"), ("r@nd0m_key", "val"), ("aaarandom_key", "val")];
+		storage
+			.top
+			.extend(extra_data.iter().map(|(k, v)| (k.as_bytes().to_vec(), v.as_bytes().to_vec())));
+		crate::ChainSpec::set_storage(&mut spec, storage);
+
+		let json = spec.as_json(true).unwrap();
+
+		// Check multiple times that decoding and encoding the chain spec leads always to the same
+		// output.
+		for _ in 0..10 {
+			assert_eq!(
+				json,
+				TestSpec2::from_json_bytes(json.as_bytes().to_vec())
+					.unwrap()
+					.as_json(true)
+					.unwrap()
+			);
+		}
+	}
+}
diff --git a/substrate/client/chain-spec/src/extension.rs b/substrate/client/chain-spec/src/extension.rs
new file mode 100644
index 0000000000000000000000000000000000000000..25ab011a05b323bf8874519b2f1efcb5533d4f91
--- /dev/null
+++ b/substrate/client/chain-spec/src/extension.rs
@@ -0,0 +1,433 @@
+// 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/>.
+
+//! Chain Spec extensions helpers.
+
+use std::{
+	any::{Any, TypeId},
+	fmt::Debug,
+};
+
+use std::collections::BTreeMap;
+
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+
+/// A `ChainSpec` extension.
+///
+/// This trait is implemented automatically by `ChainSpecGroup` macro.
+pub trait Group: Clone + Sized {
+	/// An associated type containing fork definition.
+	type Fork: Fork<Base = Self>;
+
+	/// Convert to fork type.
+	fn to_fork(self) -> Self::Fork;
+}
+
+/// A `ChainSpec` extension fork definition.
+///
+/// Basically should look the same as `Group`, but
+/// all parameters are optional. This allows changing
+/// only one parameter as part of the fork.
+/// The forks can be combined (summed up) to specify
+/// a complete set of parameters
+pub trait Fork: Serialize + DeserializeOwned + Clone + Sized {
+	/// A base `Group` type.
+	type Base: Group<Fork = Self>;
+
+	/// Combine with another struct.
+	///
+	/// All parameters set in `other` should override the
+	/// ones in the current struct.
+	fn combine_with(&mut self, other: Self);
+
+	/// Attempt to convert to the base type if all parameters are set.
+	fn to_base(self) -> Option<Self::Base>;
+}
+
+macro_rules! impl_trivial {
+	() => {};
+	($A : ty) => {
+		impl_trivial!($A ,);
+	};
+	($A : ty , $( $B : ty ),*) => {
+		impl_trivial!($( $B ),*);
+
+		impl Group for $A {
+			type Fork = $A;
+
+			fn to_fork(self) -> Self::Fork {
+				self
+			}
+		}
+
+		impl Fork for $A {
+			type Base = $A;
+
+			fn combine_with(&mut self, other: Self) {
+				*self = other;
+			}
+
+			fn to_base(self) -> Option<Self::Base> {
+				Some(self)
+			}
+		}
+	}
+}
+
+impl_trivial!((), u8, u16, u32, u64, usize, String, Vec<u8>);
+
+impl<T: Group> Group for Option<T> {
+	type Fork = Option<T::Fork>;
+
+	fn to_fork(self) -> Self::Fork {
+		self.map(|a| a.to_fork())
+	}
+}
+
+impl<T: Fork> Fork for Option<T> {
+	type Base = Option<T::Base>;
+
+	fn combine_with(&mut self, other: Self) {
+		*self = match (self.take(), other) {
+			(Some(mut a), Some(b)) => {
+				a.combine_with(b);
+				Some(a)
+			},
+			(a, b) => a.or(b),
+		};
+	}
+
+	fn to_base(self) -> Option<Self::Base> {
+		self.map(|x| x.to_base())
+	}
+}
+
+/// A collection of `ChainSpec` extensions.
+///
+/// This type can be passed around and allows the core
+/// modules to request a strongly-typed, but optional configuration.
+pub trait Extension: Serialize + DeserializeOwned + Clone {
+	type Forks: IsForks;
+
+	/// Get an extension of specific type.
+	fn get<T: 'static>(&self) -> Option<&T>;
+	/// Get an extension of specific type as reference to `Any`.
+	fn get_any(&self, t: TypeId) -> &dyn Any;
+	/// Get an extension of specific type as mutable reference to `Any`.
+	fn get_any_mut(&mut self, t: TypeId) -> &mut dyn Any;
+
+	/// Get forkable extensions of specific type.
+	fn forks<BlockNumber, T>(&self) -> Option<Forks<BlockNumber, T>>
+	where
+		BlockNumber: Ord + Clone + 'static,
+		T: Group + 'static,
+		<Self::Forks as IsForks>::Extension: Extension,
+		<<Self::Forks as IsForks>::Extension as Group>::Fork: Extension,
+	{
+		self.get::<Forks<BlockNumber, <Self::Forks as IsForks>::Extension>>()?
+			.for_type()
+	}
+}
+
+impl Extension for crate::NoExtension {
+	type Forks = Self;
+
+	fn get<T: 'static>(&self) -> Option<&T> {
+		None
+	}
+	fn get_any(&self, _t: TypeId) -> &dyn Any {
+		self
+	}
+	fn get_any_mut(&mut self, _: TypeId) -> &mut dyn Any {
+		self
+	}
+}
+
+pub trait IsForks {
+	type BlockNumber: Ord + 'static;
+	type Extension: Group + 'static;
+}
+
+impl IsForks for Option<()> {
+	type BlockNumber = u64;
+	type Extension = Self;
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct Forks<BlockNumber: Ord, T: Group> {
+	forks: BTreeMap<BlockNumber, T::Fork>,
+	#[serde(flatten)]
+	base: T,
+}
+
+impl<B: Ord, T: Group + Default> Default for Forks<B, T> {
+	fn default() -> Self {
+		Self { base: Default::default(), forks: Default::default() }
+	}
+}
+
+impl<B: Ord, T: Group> Forks<B, T>
+where
+	T::Fork: Debug,
+{
+	/// Create new fork definition given the base and the forks.
+	pub fn new(base: T, forks: BTreeMap<B, T::Fork>) -> Self {
+		Self { base, forks }
+	}
+
+	/// Return a set of parameters for `Group` including all forks up to `block` (inclusive).
+	pub fn at_block(&self, block: B) -> T {
+		let mut start = self.base.clone().to_fork();
+
+		for (_, fork) in self.forks.range(..=block) {
+			start.combine_with(fork.clone());
+		}
+
+		start
+			.to_base()
+			.expect("We start from the `base` object, so it's always fully initialized; qed")
+	}
+}
+
+impl<B, T> IsForks for Forks<B, T>
+where
+	B: Ord + 'static,
+	T: Group + 'static,
+{
+	type BlockNumber = B;
+	type Extension = T;
+}
+
+impl<B: Ord + Clone, T: Group + Extension> Forks<B, T>
+where
+	T::Fork: Extension,
+{
+	/// Get forks definition for a subset of this extension.
+	///
+	/// Returns the `Forks` struct, but limited to a particular type
+	/// within the extension.
+	pub fn for_type<X>(&self) -> Option<Forks<B, X>>
+	where
+		X: Group + 'static,
+	{
+		let base = self.base.get::<X>()?.clone();
+		let forks = self
+			.forks
+			.iter()
+			.filter_map(|(k, v)| Some((k.clone(), v.get::<Option<X::Fork>>()?.clone()?)))
+			.collect();
+
+		Some(Forks { base, forks })
+	}
+}
+
+impl<B, E> Extension for Forks<B, E>
+where
+	B: Serialize + DeserializeOwned + Ord + Clone + 'static,
+	E: Extension + Group + 'static,
+{
+	type Forks = Self;
+
+	fn get<T: 'static>(&self) -> Option<&T> {
+		if TypeId::of::<T>() == TypeId::of::<E>() {
+			<dyn Any>::downcast_ref(&self.base)
+		} else {
+			self.base.get()
+		}
+	}
+
+	fn get_any(&self, t: TypeId) -> &dyn Any {
+		if t == TypeId::of::<E>() {
+			&self.base
+		} else {
+			self.base.get_any(t)
+		}
+	}
+
+	fn get_any_mut(&mut self, t: TypeId) -> &mut dyn Any {
+		if t == TypeId::of::<E>() {
+			&mut self.base
+		} else {
+			self.base.get_any_mut(t)
+		}
+	}
+
+	fn forks<BlockNumber, T>(&self) -> Option<Forks<BlockNumber, T>>
+	where
+		BlockNumber: Ord + Clone + 'static,
+		T: Group + 'static,
+		<Self::Forks as IsForks>::Extension: Extension,
+		<<Self::Forks as IsForks>::Extension as Group>::Fork: Extension,
+	{
+		if TypeId::of::<BlockNumber>() == TypeId::of::<B>() {
+			<dyn Any>::downcast_ref(&self.for_type::<T>()?).cloned()
+		} else {
+			self.get::<Forks<BlockNumber, <Self::Forks as IsForks>::Extension>>()?
+				.for_type()
+		}
+	}
+}
+
+/// A subset if the `Extension` trait that only allows for quering extensions.
+pub trait GetExtension {
+	/// Get an extension of specific type.
+	fn get_any(&self, t: TypeId) -> &dyn Any;
+
+	/// Get an extension of specific type with mutable access.
+	fn get_any_mut(&mut self, t: TypeId) -> &mut dyn Any;
+}
+
+impl<E: Extension> GetExtension for E {
+	fn get_any(&self, t: TypeId) -> &dyn Any {
+		Extension::get_any(self, t)
+	}
+
+	fn get_any_mut(&mut self, t: TypeId) -> &mut dyn Any {
+		Extension::get_any_mut(self, t)
+	}
+}
+
+/// Helper function that queries an extension by type from `GetExtension` trait object.
+pub fn get_extension<T: 'static>(e: &dyn GetExtension) -> Option<&T> {
+	<dyn Any>::downcast_ref(GetExtension::get_any(e, TypeId::of::<T>()))
+}
+
+/// Helper function that queries an extension by type from `GetExtension` trait object.
+pub fn get_extension_mut<T: 'static>(e: &mut dyn GetExtension) -> Option<&mut T> {
+	<dyn Any>::downcast_mut(GetExtension::get_any_mut(e, TypeId::of::<T>()))
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_chain_spec_derive::{ChainSpecExtension, ChainSpecGroup};
+	// Make the proc macro work for tests and doc tests.
+	use crate as sc_chain_spec;
+
+	#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup)]
+	#[serde(deny_unknown_fields)]
+	pub struct Extension1 {
+		pub test: u64,
+	}
+
+	#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup)]
+	#[serde(deny_unknown_fields)]
+	pub struct Extension2 {
+		pub test: u8,
+	}
+
+	#[derive(
+		Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup, ChainSpecExtension,
+	)]
+	#[serde(deny_unknown_fields)]
+	pub struct Extensions {
+		pub ext1: Extension1,
+		pub ext2: Extension2,
+	}
+
+	#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecExtension)]
+	#[serde(deny_unknown_fields)]
+	pub struct Ext2 {
+		#[serde(flatten)]
+		ext1: Extension1,
+		#[forks]
+		forkable: Forks<u64, Extensions>,
+	}
+
+	#[test]
+	fn forks_should_work_correctly() {
+		use super::Extension as _;
+
+		// We first need to deserialize into a `Value` because of the following bug:
+		// https://github.com/serde-rs/json/issues/505
+		let ext_val: serde_json::Value = serde_json::from_str(
+			r#"
+{
+	"test": 11,
+	"forkable": {
+		"ext1": {
+			"test": 15
+		},
+		"ext2": {
+			"test": 123
+		},
+		"forks": {
+			"1": {
+				"ext1": { "test": 5 }
+			},
+			"2": {
+				"ext2": { "test": 5 }
+			},
+			"5": {
+				"ext2": { "test": 1 }
+			}
+		}
+	}
+}
+		"#,
+		)
+		.unwrap();
+
+		let ext: Ext2 = serde_json::from_value(ext_val).unwrap();
+
+		assert_eq!(ext.get::<Extension1>(), Some(&Extension1 { test: 11 }));
+
+		// get forks definition
+		let forks = ext.get::<Forks<u64, Extensions>>().unwrap();
+		assert_eq!(
+			forks.at_block(0),
+			Extensions { ext1: Extension1 { test: 15 }, ext2: Extension2 { test: 123 } }
+		);
+		assert_eq!(
+			forks.at_block(1),
+			Extensions { ext1: Extension1 { test: 5 }, ext2: Extension2 { test: 123 } }
+		);
+		assert_eq!(
+			forks.at_block(2),
+			Extensions { ext1: Extension1 { test: 5 }, ext2: Extension2 { test: 5 } }
+		);
+		assert_eq!(
+			forks.at_block(4),
+			Extensions { ext1: Extension1 { test: 5 }, ext2: Extension2 { test: 5 } }
+		);
+		assert_eq!(
+			forks.at_block(5),
+			Extensions { ext1: Extension1 { test: 5 }, ext2: Extension2 { test: 1 } }
+		);
+		assert_eq!(
+			forks.at_block(10),
+			Extensions { ext1: Extension1 { test: 5 }, ext2: Extension2 { test: 1 } }
+		);
+		assert!(forks.at_block(10).get::<Extension2>().is_some());
+
+		// filter forks for `Extension2`
+		let ext2 = forks.for_type::<Extension2>().unwrap();
+		assert_eq!(ext2.at_block(0), Extension2 { test: 123 });
+		assert_eq!(ext2.at_block(2), Extension2 { test: 5 });
+		assert_eq!(ext2.at_block(10), Extension2 { test: 1 });
+
+		// make sure that it can return forks correctly
+		let ext2_2 = forks.forks::<u64, Extension2>().unwrap();
+		assert_eq!(ext2, ext2_2);
+
+		// also ext should be able to return forks correctly:
+		let ext2_3 = ext.forks::<u64, Extension2>().unwrap();
+		assert_eq!(ext2_2, ext2_3);
+	}
+}
diff --git a/substrate/client/chain-spec/src/genesis.rs b/substrate/client/chain-spec/src/genesis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6aa156a620a7933034643f8a7bdbf8e0d617ad97
--- /dev/null
+++ b/substrate/client/chain-spec/src/genesis.rs
@@ -0,0 +1,140 @@
+// 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/>.
+
+//! Tool for creating the genesis block.
+
+use std::{collections::hash_map::DefaultHasher, marker::PhantomData, sync::Arc};
+
+use sc_client_api::{backend::Backend, BlockImportOperation};
+use sc_executor::RuntimeVersionOf;
+use sp_core::storage::{well_known_keys, StateVersion, Storage};
+use sp_runtime::{
+	traits::{Block as BlockT, Hash as HashT, Header as HeaderT, Zero},
+	BuildStorage,
+};
+
+/// Return the state version given the genesis storage and executor.
+pub fn resolve_state_version_from_wasm<E>(
+	storage: &Storage,
+	executor: &E,
+) -> sp_blockchain::Result<StateVersion>
+where
+	E: RuntimeVersionOf,
+{
+	if let Some(wasm) = storage.top.get(well_known_keys::CODE) {
+		let mut ext = sp_state_machine::BasicExternalities::new_empty(); // just to read runtime version.
+
+		let code_fetcher = sp_core::traits::WrappedRuntimeCode(wasm.as_slice().into());
+		let runtime_code = sp_core::traits::RuntimeCode {
+			code_fetcher: &code_fetcher,
+			heap_pages: None,
+			hash: {
+				use std::hash::{Hash, Hasher};
+				let mut state = DefaultHasher::new();
+				wasm.hash(&mut state);
+				state.finish().to_le_bytes().to_vec()
+			},
+		};
+		let runtime_version = RuntimeVersionOf::runtime_version(executor, &mut ext, &runtime_code)
+			.map_err(|e| sp_blockchain::Error::VersionInvalid(e.to_string()))?;
+		Ok(runtime_version.state_version())
+	} else {
+		Err(sp_blockchain::Error::VersionInvalid(
+			"Runtime missing from initial storage, could not read state version.".to_string(),
+		))
+	}
+}
+
+/// Create a genesis block, given the initial storage.
+pub fn construct_genesis_block<Block: BlockT>(
+	state_root: Block::Hash,
+	state_version: StateVersion,
+) -> Block {
+	let extrinsics_root = <<<Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
+		Vec::new(),
+		state_version,
+	);
+
+	Block::new(
+		<<Block as BlockT>::Header as HeaderT>::new(
+			Zero::zero(),
+			extrinsics_root,
+			state_root,
+			Default::default(),
+			Default::default(),
+		),
+		Default::default(),
+	)
+}
+
+/// Trait for building the genesis block.
+pub trait BuildGenesisBlock<Block: BlockT> {
+	/// The import operation used to import the genesis block into the backend.
+	type BlockImportOperation;
+
+	/// Returns the built genesis block along with the block import operation
+	/// after setting the genesis storage.
+	fn build_genesis_block(self) -> sp_blockchain::Result<(Block, Self::BlockImportOperation)>;
+}
+
+/// Default genesis block builder in Substrate.
+pub struct GenesisBlockBuilder<Block: BlockT, B, E> {
+	genesis_storage: Storage,
+	commit_genesis_state: bool,
+	backend: Arc<B>,
+	executor: E,
+	_phantom: PhantomData<Block>,
+}
+
+impl<Block: BlockT, B: Backend<Block>, E: RuntimeVersionOf> GenesisBlockBuilder<Block, B, E> {
+	/// Constructs a new instance of [`GenesisBlockBuilder`].
+	pub fn new(
+		build_genesis_storage: &dyn BuildStorage,
+		commit_genesis_state: bool,
+		backend: Arc<B>,
+		executor: E,
+	) -> sp_blockchain::Result<Self> {
+		let genesis_storage =
+			build_genesis_storage.build_storage().map_err(sp_blockchain::Error::Storage)?;
+		Ok(Self {
+			genesis_storage,
+			commit_genesis_state,
+			backend,
+			executor,
+			_phantom: PhantomData::<Block>,
+		})
+	}
+}
+
+impl<Block: BlockT, B: Backend<Block>, E: RuntimeVersionOf> BuildGenesisBlock<Block>
+	for GenesisBlockBuilder<Block, B, E>
+{
+	type BlockImportOperation = <B as Backend<Block>>::BlockImportOperation;
+
+	fn build_genesis_block(self) -> sp_blockchain::Result<(Block, Self::BlockImportOperation)> {
+		let Self { genesis_storage, commit_genesis_state, backend, executor, _phantom } = self;
+
+		let genesis_state_version = resolve_state_version_from_wasm(&genesis_storage, &executor)?;
+		let mut op = backend.begin_operation()?;
+		let state_root =
+			op.set_genesis_state(genesis_storage, commit_genesis_state, genesis_state_version)?;
+		let genesis_block = construct_genesis_block::<Block>(state_root, genesis_state_version);
+
+		Ok((genesis_block, op))
+	}
+}
diff --git a/substrate/client/chain-spec/src/lib.rs b/substrate/client/chain-spec/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..341c5f28e4a443129986042013366007346d7f58
--- /dev/null
+++ b/substrate/client/chain-spec/src/lib.rs
@@ -0,0 +1,283 @@
+// 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/>.
+
+//! Substrate chain configurations.
+//!
+//! This crate contains structs and utilities to declare
+//! a runtime-specific configuration file (a.k.a chain spec).
+//!
+//! Basic chain spec type containing all required parameters is
+//! [`GenericChainSpec`]. It can be extended with
+//! additional options that contain configuration specific to your chain.
+//! Usually the extension is going to be an amalgamate of types exposed
+//! by Substrate core modules. To allow the core modules to retrieve
+//! their configuration from your extension you should use `ChainSpecExtension`
+//! macro exposed by this crate.
+//!
+//! ```rust
+//! use std::collections::HashMap;
+//! use sc_chain_spec::{GenericChainSpec, ChainSpecExtension};
+//!
+//! #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecExtension)]
+//! pub struct MyExtension {
+//! 		pub known_blocks: HashMap<u64, String>,
+//! }
+//!
+//! pub type MyChainSpec<G> = GenericChainSpec<G, MyExtension>;
+//! ```
+//!
+//! Some parameters may require different values depending on the
+//! current blockchain height (a.k.a. forks). You can use `ChainSpecGroup`
+//! macro and provided [`Forks`](./struct.Forks.html) structure to put
+//! such parameters to your chain spec.
+//! This will allow to override a single parameter starting at specific
+//! block number.
+//!
+//! ```rust
+//! use sc_chain_spec::{Forks, ChainSpecGroup, ChainSpecExtension, GenericChainSpec};
+//!
+//! #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecGroup)]
+//! pub struct ClientParams {
+//! 	max_block_size: usize,
+//! 	max_extrinsic_size: usize,
+//! }
+//!
+//! #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecGroup)]
+//! pub struct PoolParams {
+//! 	max_transaction_size: usize,
+//! }
+//!
+//! #[derive(Clone, Debug, serde::Serialize, serde::Deserialize, ChainSpecGroup, ChainSpecExtension)]
+//! pub struct Extension {
+//! 	pub client: ClientParams,
+//! 	pub pool: PoolParams,
+//! }
+//!
+//! pub type BlockNumber = u64;
+//!
+//! /// A chain spec supporting forkable `ClientParams`.
+//! pub type MyChainSpec1<G> = GenericChainSpec<G, Forks<BlockNumber, ClientParams>>;
+//!
+//! /// A chain spec supporting forkable `Extension`.
+//! pub type MyChainSpec2<G> = GenericChainSpec<G, Forks<BlockNumber, Extension>>;
+//! ```
+//!
+//! It's also possible to have a set of parameters that is allowed to change
+//! with block numbers (i.e. is forkable), and another set that is not subject to changes.
+//! This is also possible by declaring an extension that contains `Forks` within it.
+//!
+//!
+//! ```rust
+//! use serde::{Serialize, Deserialize};
+//! use sc_chain_spec::{Forks, GenericChainSpec, ChainSpecGroup, ChainSpecExtension};
+//!
+//! #[derive(Clone, Debug, Serialize, Deserialize, ChainSpecGroup)]
+//! pub struct ClientParams {
+//! 	max_block_size: usize,
+//! 	max_extrinsic_size: usize,
+//! }
+//!
+//! #[derive(Clone, Debug, Serialize, Deserialize, ChainSpecGroup)]
+//! pub struct PoolParams {
+//! 	max_transaction_size: usize,
+//! }
+//!
+//! #[derive(Clone, Debug, Serialize, Deserialize, ChainSpecExtension)]
+//! pub struct Extension {
+//! 	pub client: ClientParams,
+//! 	#[forks]
+//! 	pub pool: Forks<u64, PoolParams>,
+//! }
+//!
+//! pub type MyChainSpec<G> = GenericChainSpec<G, Extension>;
+//! ```
+//!
+//! # Substrate chain specification format
+//!
+//! The Substrate chain specification is a `json` file that describes the basics of a chain. Most
+//! importantly it lays out the genesis storage which leads to the genesis hash. The default
+//! Substrate chain specification format is the following:
+//!
+//! ```json
+//! // The human readable name of the chain.
+//! "name": "Flaming Fir",
+//!
+//! // The id of the chain.
+//! "id": "flamingfir9",
+//!
+//! // The chain type of this chain.
+//! // Possible values are `Live`, `Development`, `Local`.
+//! "chainType": "Live",
+//!
+//! // A list of multi addresses that belong to boot nodes of the chain.
+//! "bootNodes": [
+//!   "/dns/0.flamingfir.paritytech.net/tcp/30333/p2p/12D3KooWLK2gMLhWsYJzjW3q35zAs9FDDVqfqVfVuskiGZGRSMvR",
+//! ],
+//!
+//! // Optional list of "multi address, verbosity" of telemetry endpoints.
+//! // The verbosity goes from `0` to `9`. With `0` being the mode with the lowest verbosity.
+//! "telemetryEndpoints": [
+//!   [
+//!     "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F",
+//!     0
+//!   ]
+//! ],
+//!
+//! // Optional networking protocol id that identifies the chain.
+//! "protocolId": "fir9",
+//!
+//! // Optional fork id. Should most likely be left empty.
+//! // Can be used to signal a fork on the network level when two chains have the
+//! // same genesis hash.
+//! "forkId": "random_fork",
+//!
+//! // Custom properties.
+//! "properties": {
+//!   "tokenDecimals": 15,
+//!   "tokenSymbol": "FIR"
+//! },
+//!
+//! // Deprecated field. Should be ignored.
+//! "consensusEngine": null,
+//!
+//! // The genesis declaration of the chain.
+//! //
+//! // `runtime`, `raw`, `stateRootHash` denote the type of the genesis declaration.
+//! //
+//! // These declarations are in the following formats:
+//! // - `runtime` is a `json` object that can be parsed by a compatible `GenesisConfig`. This
+//! //  `GenesisConfig` is declared by a runtime and opaque to the node.
+//! // - `raw` is a `json` object with two fields `top` and `children_default`. Each of these
+//! //   fields is a map of `key => value`. These key/value pairs represent the genesis storage.
+//! // - `stateRootHash` is a single hex encoded hash that represents the genesis hash. The hash
+//! //   type depends on the hash used by the chain.
+//! //
+//! "genesis": { "runtime": {} },
+//!
+//! /// Optional map of `block_number` to `wasm_code`.
+//! ///
+//! /// The given `wasm_code` will be used to substitute the on-chain wasm code starting with the
+//! /// given block number until the `spec_version` on-chain changes. The given `wasm_code` should
+//! /// be as close as possible to the on-chain wasm code. A substitute should be used to fix a bug
+//! /// that can not be fixed with a runtime upgrade, if for example the runtime is constantly
+//! /// panicking. Introducing new runtime apis isn't supported, because the node
+//! /// will read the runtime version from the on-chain wasm code. Use this functionality only when
+//! /// there is no other way around it and only patch the problematic bug, the rest should be done
+//! /// with a on-chain runtime upgrade.
+//! "codeSubstitutes": [],
+//! ```
+//!
+//! See [`ChainSpec`] for a trait representation of the above.
+//!
+//! 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.
+
+mod chain_spec;
+mod extension;
+mod genesis;
+
+pub use self::{
+	chain_spec::{ChainSpec as GenericChainSpec, NoExtension},
+	extension::{get_extension, get_extension_mut, Extension, Fork, Forks, GetExtension, Group},
+	genesis::{
+		construct_genesis_block, resolve_state_version_from_wasm, BuildGenesisBlock,
+		GenesisBlockBuilder,
+	},
+};
+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;
+
+/// The type of a chain.
+///
+/// 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)]
+pub enum ChainType {
+	/// A development chain that runs mainly on one node.
+	Development,
+	/// A local chain that runs locally on multiple nodes for testing purposes.
+	Local,
+	/// A live chain.
+	Live,
+	/// Some custom chain type.
+	Custom(String),
+}
+
+impl Default for ChainType {
+	fn default() -> Self {
+		Self::Live
+	}
+}
+
+/// 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.
+	fn name(&self) -> &str;
+	/// Spec id.
+	fn id(&self) -> &str;
+	/// Type of the chain.
+	fn chain_type(&self) -> ChainType;
+	/// A list of bootnode addresses.
+	fn boot_nodes(&self) -> &[MultiaddrWithPeerId];
+	/// Telemetry endpoints (if any)
+	fn telemetry_endpoints(&self) -> &Option<TelemetryEndpoints>;
+	/// Network protocol id.
+	fn protocol_id(&self) -> Option<&str>;
+	/// Optional network fork identifier. `None` by default.
+	fn fork_id(&self) -> Option<&str>;
+	/// Additional loosly-typed properties of the chain.
+	///
+	/// Returns an empty JSON object if 'properties' not defined in config
+	fn properties(&self) -> Properties;
+	/// Returns a reference to the defined chain spec extensions.
+	fn extensions(&self) -> &dyn GetExtension;
+	/// Returns a mutable reference to the defined chain spec extensions.
+	fn extensions_mut(&mut self) -> &mut dyn GetExtension;
+	/// Add a bootnode to the list.
+	fn add_boot_node(&mut self, addr: MultiaddrWithPeerId);
+	/// Return spec as JSON.
+	fn as_json(&self, raw: bool) -> Result<String, String>;
+	/// Return StorageBuilder for this spec.
+	fn as_storage_builder(&self) -> &dyn BuildStorage;
+	/// Returns a cloned `Box<dyn ChainSpec>`.
+	fn cloned_box(&self) -> Box<dyn ChainSpec>;
+	/// Set the storage that should be used by this chain spec.
+	///
+	/// This will be used as storage at genesis.
+	fn set_storage(&mut self, storage: Storage);
+	/// Returns code substitutes that should be used for the on chain wasm.
+	fn code_substitutes(&self) -> std::collections::BTreeMap<String, Vec<u8>>;
+}
+
+impl std::fmt::Debug for dyn ChainSpec {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "ChainSpec(name = {:?}, id = {:?})", self.name(), self.id())
+	}
+}
diff --git a/substrate/client/cli/Cargo.toml b/substrate/client/cli/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..92ddbe59fc5625c9d9d0498c194878d6b70531fb
--- /dev/null
+++ b/substrate/client/cli/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "sc-cli"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate CLI interface."
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+chrono = "0.4.10"
+clap = { version = "4.2.5", features = ["derive", "string"] }
+fdlimit = "0.2.1"
+futures = "0.3.21"
+libp2p-identity = { version = "0.1.2", features = ["peerid", "ed25519"]}
+log = "0.4.17"
+names = { version = "0.13.0", default-features = false }
+parity-scale-codec = "3.6.1"
+rand = "0.8.5"
+regex = "1.6.0"
+rpassword = "7.0.0"
+serde = "1.0.163"
+serde_json = "1.0.85"
+thiserror = "1.0.30"
+tiny-bip39 = "1.0.0"
+tokio = { version = "1.22.0", features = ["signal", "rt-multi-thread", "parking_lot"] }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-client-db = { version = "0.10.0-dev", default-features = false, path = "../db" }
+sc-keystore = { version = "4.0.0-dev", path = "../keystore" }
+sc-network = { version = "0.10.0-dev", path = "../network" }
+sc-service = { version = "0.10.0-dev", default-features = false, path = "../service" }
+sc-telemetry = { version = "4.0.0-dev", path = "../telemetry" }
+sc-tracing = { version = "4.0.0-dev", path = "../tracing" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-keyring = { version = "24.0.0", path = "../../primitives/keyring" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+sp-panic-handler = { version = "8.0.0", path = "../../primitives/panic-handler" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-version = { version = "22.0.0", path = "../../primitives/version" }
+
+[dev-dependencies]
+tempfile = "3.1.0"
+futures-timer = "3.0.1"
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+
+[features]
+default = [ "rocksdb" ]
+rocksdb = [ "sc-client-db/rocksdb" ]
diff --git a/substrate/client/cli/README.adoc b/substrate/client/cli/README.adoc
new file mode 100644
index 0000000000000000000000000000000000000000..fc58908fdf23d750409fc5ac8ce20fc40b3800e8
--- /dev/null
+++ b/substrate/client/cli/README.adoc
@@ -0,0 +1,6 @@
+
+= Substrate CLI
+
+Substrate CLI library
+
+include::doc/shell-completion.adoc[]
diff --git a/substrate/client/cli/README.md b/substrate/client/cli/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2504dbb0c03b5f9525c580622445ac431fe61d6f
--- /dev/null
+++ b/substrate/client/cli/README.md
@@ -0,0 +1,3 @@
+Substrate CLI library.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/cli/src/arg_enums.rs b/substrate/client/cli/src/arg_enums.rs
new file mode 100644
index 0000000000000000000000000000000000000000..40d86fd97988d23eaa209f6d067422af5ad89850
--- /dev/null
+++ b/substrate/client/cli/src/arg_enums.rs
@@ -0,0 +1,261 @@
+// 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/>.
+
+//! Definitions of [`ValueEnum`] types.
+
+use clap::ValueEnum;
+
+/// The instantiation strategy to use in compiled mode.
+#[derive(Debug, Clone, Copy, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum WasmtimeInstantiationStrategy {
+	/// Pool the instances to avoid initializing everything from scratch
+	/// on each instantiation. Use copy-on-write memory when possible.
+	PoolingCopyOnWrite,
+
+	/// Recreate the instance from scratch on every instantiation.
+	/// Use copy-on-write memory when possible.
+	RecreateInstanceCopyOnWrite,
+
+	/// Pool the instances to avoid initializing everything from scratch
+	/// on each instantiation.
+	Pooling,
+
+	/// Recreate the instance from scratch on every instantiation. Very slow.
+	RecreateInstance,
+
+	/// Legacy instance reuse mechanism. DEPRECATED. Will be removed in the future.
+	///
+	/// Should only be used in case of encountering any issues with the new default
+	/// instantiation strategy.
+	LegacyInstanceReuse,
+}
+
+/// The default [`WasmtimeInstantiationStrategy`].
+pub const DEFAULT_WASMTIME_INSTANTIATION_STRATEGY: WasmtimeInstantiationStrategy =
+	WasmtimeInstantiationStrategy::PoolingCopyOnWrite;
+
+/// How to execute Wasm runtime code.
+#[derive(Debug, Clone, Copy, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum WasmExecutionMethod {
+	/// Uses an interpreter which now is deprecated.
+	#[clap(name = "interpreted-i-know-what-i-do")]
+	Interpreted,
+	/// Uses a compiled runtime.
+	Compiled,
+}
+
+impl std::fmt::Display for WasmExecutionMethod {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::Interpreted => write!(f, "Interpreted"),
+			Self::Compiled => write!(f, "Compiled"),
+		}
+	}
+}
+
+/// Converts the execution method and instantiation strategy command line arguments
+/// into an execution method which can be used internally.
+pub fn execution_method_from_cli(
+	execution_method: WasmExecutionMethod,
+	instantiation_strategy: WasmtimeInstantiationStrategy,
+) -> sc_service::config::WasmExecutionMethod {
+	if let WasmExecutionMethod::Interpreted = execution_method {
+		log::warn!(
+			"`interpreted-i-know-what-i-do` is deprecated and will be removed in the future. Defaults to `compiled` execution mode."
+		);
+	}
+
+	sc_service::config::WasmExecutionMethod::Compiled {
+		instantiation_strategy: match instantiation_strategy {
+			WasmtimeInstantiationStrategy::PoolingCopyOnWrite =>
+				sc_service::config::WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
+			WasmtimeInstantiationStrategy::RecreateInstanceCopyOnWrite =>
+				sc_service::config::WasmtimeInstantiationStrategy::RecreateInstanceCopyOnWrite,
+			WasmtimeInstantiationStrategy::Pooling =>
+				sc_service::config::WasmtimeInstantiationStrategy::Pooling,
+			WasmtimeInstantiationStrategy::RecreateInstance =>
+				sc_service::config::WasmtimeInstantiationStrategy::RecreateInstance,
+			WasmtimeInstantiationStrategy::LegacyInstanceReuse =>
+				sc_service::config::WasmtimeInstantiationStrategy::LegacyInstanceReuse,
+		},
+	}
+}
+
+/// The default [`WasmExecutionMethod`].
+pub const DEFAULT_WASM_EXECUTION_METHOD: WasmExecutionMethod = WasmExecutionMethod::Compiled;
+
+#[allow(missing_docs)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum TracingReceiver {
+	/// Output the tracing records using the log.
+	Log,
+}
+
+impl Into<sc_tracing::TracingReceiver> for TracingReceiver {
+	fn into(self) -> sc_tracing::TracingReceiver {
+		match self {
+			TracingReceiver::Log => sc_tracing::TracingReceiver::Log,
+		}
+	}
+}
+
+/// The type of the node key.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum NodeKeyType {
+	/// Use ed25519.
+	Ed25519,
+}
+
+/// The crypto scheme to use.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum CryptoScheme {
+	/// Use ed25519.
+	Ed25519,
+	/// Use sr25519.
+	Sr25519,
+	/// Use
+	Ecdsa,
+}
+
+/// The type of the output format.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum OutputType {
+	/// Output as json.
+	Json,
+	/// Output as text.
+	Text,
+}
+
+/// How to execute blocks
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum ExecutionStrategy {
+	/// Execute with native build (if available, WebAssembly otherwise).
+	Native,
+	/// Only execute with the WebAssembly build.
+	Wasm,
+	/// Execute with both native (where available) and WebAssembly builds.
+	Both,
+	/// Execute with the native build if possible; if it fails, then execute with WebAssembly.
+	NativeElseWasm,
+}
+
+/// Available RPC methods.
+#[allow(missing_docs)]
+#[derive(Debug, Copy, Clone, PartialEq, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum RpcMethods {
+	/// Expose every RPC method only when RPC is listening on `localhost`,
+	/// otherwise serve only safe RPC methods.
+	Auto,
+	/// Allow only a safe subset of RPC methods.
+	Safe,
+	/// Expose every RPC method (even potentially unsafe ones).
+	Unsafe,
+}
+
+impl Into<sc_service::config::RpcMethods> for RpcMethods {
+	fn into(self) -> sc_service::config::RpcMethods {
+		match self {
+			RpcMethods::Auto => sc_service::config::RpcMethods::Auto,
+			RpcMethods::Safe => sc_service::config::RpcMethods::Safe,
+			RpcMethods::Unsafe => sc_service::config::RpcMethods::Unsafe,
+		}
+	}
+}
+
+/// Database backend
+#[derive(Debug, Clone, PartialEq, Copy, clap::ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum Database {
+	/// Facebooks RocksDB
+	#[cfg(feature = "rocksdb")]
+	RocksDb,
+	/// ParityDb. <https://github.com/paritytech/parity-db/>
+	ParityDb,
+	/// Detect whether there is an existing database. Use it, if there is, if not, create new
+	/// instance of ParityDb
+	Auto,
+	/// ParityDb. <https://github.com/paritytech/parity-db/>
+	#[value(name = "paritydb-experimental")]
+	ParityDbDeprecated,
+}
+
+impl Database {
+	/// Returns all the variants of this enum to be shown in the cli.
+	pub const fn variants() -> &'static [&'static str] {
+		&[
+			#[cfg(feature = "rocksdb")]
+			"rocksdb",
+			"paritydb",
+			"paritydb-experimental",
+			"auto",
+		]
+	}
+}
+
+/// Whether off-chain workers are enabled.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, ValueEnum)]
+#[value(rename_all = "kebab-case")]
+pub enum OffchainWorkerEnabled {
+	/// Always have offchain worker enabled.
+	Always,
+	/// Never enable the offchain worker.
+	Never,
+	/// Only enable the offchain worker when running as a validator (or collator, if this is a
+	/// parachain node).
+	WhenAuthority,
+}
+
+/// Syncing mode.
+#[derive(Debug, Clone, Copy, ValueEnum, PartialEq)]
+#[value(rename_all = "kebab-case")]
+pub enum SyncMode {
+	/// Full sync. Download end verify all blocks.
+	Full,
+	/// Download blocks without executing them. Download latest state with proofs.
+	Fast,
+	/// Download blocks without executing them. Download latest state without proofs.
+	FastUnsafe,
+	/// Prove finality and download the latest state.
+	Warp,
+}
+
+impl Into<sc_network::config::SyncMode> for SyncMode {
+	fn into(self) -> sc_network::config::SyncMode {
+		match self {
+			SyncMode::Full => sc_network::config::SyncMode::Full,
+			SyncMode::Fast => sc_network::config::SyncMode::LightState {
+				skip_proofs: false,
+				storage_chain_mode: false,
+			},
+			SyncMode::FastUnsafe => sc_network::config::SyncMode::LightState {
+				skip_proofs: true,
+				storage_chain_mode: false,
+			},
+			SyncMode::Warp => sc_network::config::SyncMode::Warp,
+		}
+	}
+}
diff --git a/substrate/client/cli/src/commands/build_spec_cmd.rs b/substrate/client/cli/src/commands/build_spec_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa5314f9cf5a4c244d9ca26f343f158e94d00908
--- /dev/null
+++ b/substrate/client/cli/src/commands/build_spec_cmd.rs
@@ -0,0 +1,91 @@
+// 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::{
+	error,
+	params::{NodeKeyParams, SharedParams},
+	CliConfiguration,
+};
+use clap::Parser;
+use log::info;
+use sc_network::config::build_multiaddr;
+use sc_service::{
+	config::{MultiaddrWithPeerId, NetworkConfiguration},
+	ChainSpec,
+};
+use std::io::Write;
+
+/// The `build-spec` command used to build a specification.
+#[derive(Debug, Clone, Parser)]
+pub struct BuildSpecCmd {
+	/// Force raw genesis storage output.
+	#[arg(long)]
+	pub raw: bool,
+
+	/// Disable adding the default bootnode to the specification.
+	/// By default the `/ip4/127.0.0.1/tcp/30333/p2p/NODE_PEER_ID` bootnode is added to the
+	/// specification when no bootnode exists.
+	#[arg(long)]
+	pub disable_default_bootnode: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub node_key_params: NodeKeyParams,
+}
+
+impl BuildSpecCmd {
+	/// Run the build-spec command
+	pub fn run(
+		&self,
+		mut spec: Box<dyn ChainSpec>,
+		network_config: NetworkConfiguration,
+	) -> error::Result<()> {
+		info!("Building chain spec");
+		let raw_output = self.raw;
+
+		if spec.boot_nodes().is_empty() && !self.disable_default_bootnode {
+			let keys = network_config.node_key.into_keypair()?;
+			let peer_id = keys.public().to_peer_id();
+			let addr = MultiaddrWithPeerId {
+				multiaddr: build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(30333u16)],
+				peer_id,
+			};
+			spec.add_boot_node(addr)
+		}
+
+		let json = sc_service::chain_ops::build_spec(&*spec, raw_output)?;
+		if std::io::stdout().write_all(json.as_bytes()).is_err() {
+			let _ = std::io::stderr().write_all(b"Error writing to stdout\n");
+		}
+		Ok(())
+	}
+}
+
+impl CliConfiguration for BuildSpecCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn node_key_params(&self) -> Option<&NodeKeyParams> {
+		Some(&self.node_key_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/chain_info_cmd.rs b/substrate/client/cli/src/commands/chain_info_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..002d7893d9f35b01f36078139f872694ef8ca848
--- /dev/null
+++ b/substrate/client/cli/src/commands/chain_info_cmd.rs
@@ -0,0 +1,102 @@
+// 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::{CliConfiguration, DatabaseParams, PruningParams, Result as CliResult, SharedParams};
+use parity_scale_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};
+use std::{fmt::Debug, io};
+
+/// The `chain-info` subcommand used to output db meta columns information.
+#[derive(Debug, Clone, clap::Parser)]
+pub struct ChainInfoCmd {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub pruning_params: PruningParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub database_params: DatabaseParams,
+}
+
+/// Serializable `chain-info` subcommand output.
+#[derive(Clone, Eq, PartialEq, Debug, Encode, Decode, serde::Serialize)]
+struct ChainInfo<B: BlockT> {
+	/// Best block hash.
+	best_hash: B::Hash,
+	/// Best block number.
+	best_number: <<B as BlockT>::Header as HeaderT>::Number,
+	/// Genesis block hash.
+	genesis_hash: B::Hash,
+	/// The head of the finalized chain.
+	finalized_hash: B::Hash,
+	/// Last finalized block number.
+	finalized_number: <<B as BlockT>::Header as HeaderT>::Number,
+}
+
+impl<B: BlockT> From<Info<B>> for ChainInfo<B> {
+	fn from(info: Info<B>) -> Self {
+		ChainInfo::<B> {
+			best_hash: info.best_hash,
+			best_number: info.best_number,
+			genesis_hash: info.genesis_hash,
+			finalized_hash: info.finalized_hash,
+			finalized_number: info.finalized_number,
+		}
+	}
+}
+
+impl ChainInfoCmd {
+	/// Run the `chain-info` subcommand
+	pub fn run<B>(&self, config: &sc_service::Configuration) -> CliResult<()>
+	where
+		B: BlockT,
+	{
+		let db_config = sc_client_db::DatabaseSettings {
+			trie_cache_maximum_size: config.trie_cache_maximum_size,
+			state_pruning: config.state_pruning.clone(),
+			source: config.database.clone(),
+			blocks_pruning: config.blocks_pruning,
+		};
+		let backend = sc_service::new_db_backend::<B>(db_config)?;
+		let info: ChainInfo<B> = backend.blockchain().info().into();
+		let mut out = io::stdout();
+		serde_json::to_writer_pretty(&mut out, &info)
+			.map_err(|e| format!("Error writing JSON: {}", e))?;
+		Ok(())
+	}
+}
+
+impl CliConfiguration for ChainInfoCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn pruning_params(&self) -> Option<&PruningParams> {
+		Some(&self.pruning_params)
+	}
+
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		Some(&self.database_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/check_block_cmd.rs b/substrate/client/cli/src/commands/check_block_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dc63d46bd19afd9d0f95a7b7e1647a4ce28bbd8f
--- /dev/null
+++ b/substrate/client/cli/src/commands/check_block_cmd.rs
@@ -0,0 +1,76 @@
+// 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::{
+	error,
+	params::{BlockNumberOrHash, ImportParams, SharedParams},
+	CliConfiguration,
+};
+use clap::Parser;
+use sc_client_api::{BlockBackend, HeaderBackend};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use std::{fmt::Debug, str::FromStr, sync::Arc};
+
+/// The `check-block` command used to validate blocks.
+#[derive(Debug, Clone, Parser)]
+pub struct CheckBlockCmd {
+	/// Block hash or number.
+	#[arg(value_name = "HASH or NUMBER")]
+	pub input: BlockNumberOrHash,
+
+	/// The default number of 64KB pages to ever allocate for Wasm execution.
+	/// Don't alter this unless you know what you're doing.
+	#[arg(long, value_name = "COUNT")]
+	pub default_heap_pages: Option<u32>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+}
+
+impl CheckBlockCmd {
+	/// Run the check-block command
+	pub async fn run<B, C, IQ>(&self, client: Arc<C>, import_queue: IQ) -> error::Result<()>
+	where
+		B: BlockT + for<'de> serde::Deserialize<'de>,
+		C: BlockBackend<B> + HeaderBackend<B> + Send + Sync + 'static,
+		IQ: sc_service::ImportQueue<B> + 'static,
+		<B::Hash as FromStr>::Err: Debug,
+		<<B::Header as HeaderT>::Number as FromStr>::Err: Debug,
+	{
+		let start = std::time::Instant::now();
+		sc_service::chain_ops::check_block(client, import_queue, self.input.parse()?).await?;
+		println!("Completed in {} ms.", start.elapsed().as_millis());
+
+		Ok(())
+	}
+}
+
+impl CliConfiguration for CheckBlockCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/export_blocks_cmd.rs b/substrate/client/cli/src/commands/export_blocks_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..120d7889878e5cf6bd2da97e6022cf9d4275917e
--- /dev/null
+++ b/substrate/client/cli/src/commands/export_blocks_cmd.rs
@@ -0,0 +1,107 @@
+// 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::{
+	error,
+	params::{DatabaseParams, GenericNumber, PruningParams, SharedParams},
+	CliConfiguration,
+};
+use clap::Parser;
+use log::info;
+use sc_client_api::{BlockBackend, HeaderBackend, UsageProvider};
+use sc_service::{chain_ops::export_blocks, config::DatabaseSource};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use std::{fmt::Debug, fs, io, path::PathBuf, str::FromStr, sync::Arc};
+
+/// The `export-blocks` command used to export blocks.
+#[derive(Debug, Clone, Parser)]
+pub struct ExportBlocksCmd {
+	/// Output file name or stdout if unspecified.
+	#[arg()]
+	pub output: Option<PathBuf>,
+
+	/// Specify starting block number.
+	/// Default is 1.
+	#[arg(long, value_name = "BLOCK")]
+	pub from: Option<GenericNumber>,
+
+	/// Specify last block number.
+	/// Default is best block.
+	#[arg(long, value_name = "BLOCK")]
+	pub to: Option<GenericNumber>,
+
+	/// Use binary output rather than JSON.
+	#[arg(long)]
+	pub binary: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub pruning_params: PruningParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub database_params: DatabaseParams,
+}
+
+impl ExportBlocksCmd {
+	/// Run the export-blocks command
+	pub async fn run<B, C>(
+		&self,
+		client: Arc<C>,
+		database_config: DatabaseSource,
+	) -> error::Result<()>
+	where
+		B: BlockT,
+		C: HeaderBackend<B> + BlockBackend<B> + UsageProvider<B> + 'static,
+		<<B::Header as HeaderT>::Number as FromStr>::Err: Debug,
+	{
+		if let Some(path) = database_config.path() {
+			info!("DB path: {}", path.display());
+		}
+
+		let from = self.from.as_ref().and_then(|f| f.parse().ok()).unwrap_or(1u32);
+		let to = self.to.as_ref().and_then(|t| t.parse().ok());
+
+		let binary = self.binary;
+
+		let file: Box<dyn io::Write> = match &self.output {
+			Some(filename) => Box::new(fs::File::create(filename)?),
+			None => Box::new(io::stdout()),
+		};
+
+		export_blocks(client, file, from.into(), to, binary).await.map_err(Into::into)
+	}
+}
+
+impl CliConfiguration for ExportBlocksCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn pruning_params(&self) -> Option<&PruningParams> {
+		Some(&self.pruning_params)
+	}
+
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		Some(&self.database_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/export_state_cmd.rs b/substrate/client/cli/src/commands/export_state_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4f9e625d702e651ea736c1807fb18129dd580e05
--- /dev/null
+++ b/substrate/client/cli/src/commands/export_state_cmd.rs
@@ -0,0 +1,95 @@
+// 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::{
+	error,
+	params::{BlockNumberOrHash, DatabaseParams, PruningParams, SharedParams},
+	CliConfiguration,
+};
+use clap::Parser;
+use log::info;
+use sc_client_api::{HeaderBackend, StorageProvider, UsageProvider};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use std::{fmt::Debug, io::Write, str::FromStr, sync::Arc};
+
+/// The `export-state` command used to export the state of a given block into
+/// a chain spec.
+#[derive(Debug, Clone, Parser)]
+pub struct ExportStateCmd {
+	/// Block hash or number.
+	#[arg(value_name = "HASH or NUMBER")]
+	pub input: Option<BlockNumberOrHash>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub pruning_params: PruningParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub database_params: DatabaseParams,
+}
+
+impl ExportStateCmd {
+	/// Run the `export-state` command
+	pub async fn run<B, BA, C>(
+		&self,
+		client: Arc<C>,
+		mut input_spec: Box<dyn sc_service::ChainSpec>,
+	) -> error::Result<()>
+	where
+		B: BlockT,
+		C: UsageProvider<B> + StorageProvider<B, BA> + HeaderBackend<B>,
+		BA: sc_client_api::backend::Backend<B>,
+		<B::Hash as FromStr>::Err: Debug,
+		<<B::Header as HeaderT>::Number as FromStr>::Err: Debug,
+	{
+		info!("Exporting raw state...");
+		let block_id = self.input.as_ref().map(|b| b.parse()).transpose()?;
+		let hash = match block_id {
+			Some(id) => client.expect_block_hash_from_id(&id)?,
+			None => client.usage_info().chain.best_hash,
+		};
+		let raw_state = sc_service::chain_ops::export_raw_state(client, hash)?;
+		input_spec.set_storage(raw_state);
+
+		info!("Generating new chain spec...");
+		let json = sc_service::chain_ops::build_spec(&*input_spec, true)?;
+		if std::io::stdout().write_all(json.as_bytes()).is_err() {
+			let _ = std::io::stderr().write_all(b"Error writing to stdout\n");
+		}
+		Ok(())
+	}
+}
+
+impl CliConfiguration for ExportStateCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn pruning_params(&self) -> Option<&PruningParams> {
+		Some(&self.pruning_params)
+	}
+
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		Some(&self.database_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/generate.rs b/substrate/client/cli/src/commands/generate.rs
new file mode 100644
index 0000000000000000000000000000000000000000..93b83fcbef51eefe44a6f4e66e3d46cca3ccd689
--- /dev/null
+++ b/substrate/client/cli/src/commands/generate.rs
@@ -0,0 +1,83 @@
+// 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.
+
+//! Implementation of the `generate` subcommand
+use crate::{
+	utils::print_from_uri, with_crypto_scheme, CryptoSchemeFlag, Error, KeystoreParams,
+	NetworkSchemeFlag, OutputTypeFlag,
+};
+use bip39::{Language, Mnemonic, MnemonicType};
+use clap::Parser;
+
+/// The `generate` command
+#[derive(Debug, Clone, Parser)]
+#[command(name = "generate", about = "Generate a random account")]
+pub struct GenerateCmd {
+	/// The number of words in the phrase to generate. One of 12 (default), 15, 18, 21 and 24.
+	#[arg(short = 'w', long, value_name = "WORDS")]
+	words: Option<usize>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub keystore_params: KeystoreParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub network_scheme: NetworkSchemeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub output_scheme: OutputTypeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub crypto_scheme: CryptoSchemeFlag,
+}
+
+impl GenerateCmd {
+	/// Run the command
+	pub fn run(&self) -> Result<(), Error> {
+		let words = match self.words {
+			Some(words) => MnemonicType::for_word_count(words).map_err(|_| {
+				Error::Input(
+					"Invalid number of words given for phrase: must be 12/15/18/21/24".into(),
+				)
+			})?,
+			None => MnemonicType::Words12,
+		};
+		let mnemonic = Mnemonic::new(words, Language::English);
+		let password = self.keystore_params.read_password()?;
+		let output = self.output_scheme.output_type;
+
+		with_crypto_scheme!(
+			self.crypto_scheme.scheme,
+			print_from_uri(mnemonic.phrase(), password, self.network_scheme.network, output)
+		);
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn generate() {
+		let generate = GenerateCmd::parse_from(&["generate", "--password", "12345"]);
+		assert!(generate.run().is_ok())
+	}
+}
diff --git a/substrate/client/cli/src/commands/generate_node_key.rs b/substrate/client/cli/src/commands/generate_node_key.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43851dc1af5ccf555668e2014ba6fe57c31e858c
--- /dev/null
+++ b/substrate/client/cli/src/commands/generate_node_key.rs
@@ -0,0 +1,88 @@
+// 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.
+
+//! Implementation of the `generate-node-key` subcommand
+
+use crate::Error;
+use clap::Parser;
+use libp2p_identity::{ed25519, Keypair};
+use std::{
+	fs,
+	io::{self, Write},
+	path::PathBuf,
+};
+
+/// The `generate-node-key` command
+#[derive(Debug, Parser)]
+#[command(
+	name = "generate-node-key",
+	about = "Generate a random node key, write it to a file or stdout \
+		 	and write the corresponding peer-id to stderr"
+)]
+pub struct GenerateNodeKeyCmd {
+	/// Name of file to save secret key to.
+	/// If not given, the secret key is printed to stdout.
+	#[arg(long)]
+	file: Option<PathBuf>,
+
+	/// The output is in raw binary format.
+	/// If not given, the output is written as an hex encoded string.
+	#[arg(long)]
+	bin: bool,
+}
+
+impl GenerateNodeKeyCmd {
+	/// Run the command
+	pub fn run(&self) -> Result<(), Error> {
+		let keypair = ed25519::Keypair::generate();
+
+		let secret = keypair.secret();
+
+		let file_data = if self.bin {
+			secret.as_ref().to_owned()
+		} else {
+			array_bytes::bytes2hex("", secret).into_bytes()
+		};
+
+		match &self.file {
+			Some(file) => fs::write(file, file_data)?,
+			None => io::stdout().lock().write_all(&file_data)?,
+		}
+
+		eprintln!("{}", Keypair::from(keypair).public().to_peer_id());
+
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::io::Read;
+	use tempfile::Builder;
+
+	#[test]
+	fn generate_node_key() {
+		let mut file = Builder::new().prefix("keyfile").tempfile().unwrap();
+		let file_path = file.path().display().to_string();
+		let generate = GenerateNodeKeyCmd::parse_from(&["generate-node-key", "--file", &file_path]);
+		assert!(generate.run().is_ok());
+		let mut buf = String::new();
+		assert!(file.read_to_string(&mut buf).is_ok());
+		assert!(array_bytes::hex2bytes(&buf).is_ok());
+	}
+}
diff --git a/substrate/client/cli/src/commands/import_blocks_cmd.rs b/substrate/client/cli/src/commands/import_blocks_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..815c6ab18aa6cdef0fd217b06333ec4e059912c4
--- /dev/null
+++ b/substrate/client/cli/src/commands/import_blocks_cmd.rs
@@ -0,0 +1,93 @@
+// 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::{
+	error,
+	params::{ImportParams, SharedParams},
+	CliConfiguration,
+};
+use clap::Parser;
+use sc_client_api::HeaderBackend;
+use sc_service::chain_ops::import_blocks;
+use sp_runtime::traits::Block as BlockT;
+use std::{
+	fmt::Debug,
+	fs,
+	io::{self, Read, Seek},
+	path::PathBuf,
+	sync::Arc,
+};
+
+/// The `import-blocks` command used to import blocks.
+#[derive(Debug, Parser)]
+pub struct ImportBlocksCmd {
+	/// Input file or stdin if unspecified.
+	#[arg()]
+	pub input: Option<PathBuf>,
+
+	/// The default number of 64KB pages to ever allocate for Wasm execution.
+	/// Don't alter this unless you know what you're doing.
+	#[arg(long, value_name = "COUNT")]
+	pub default_heap_pages: Option<u32>,
+
+	/// Try importing blocks from binary format rather than JSON.
+	#[arg(long)]
+	pub binary: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+}
+
+/// Internal trait used to cast to a dynamic type that implements Read and Seek.
+trait ReadPlusSeek: Read + Seek {}
+
+impl<T: Read + Seek> ReadPlusSeek for T {}
+
+impl ImportBlocksCmd {
+	/// Run the import-blocks command
+	pub async fn run<B, C, IQ>(&self, client: Arc<C>, import_queue: IQ) -> error::Result<()>
+	where
+		C: HeaderBackend<B> + Send + Sync + 'static,
+		B: BlockT + for<'de> serde::Deserialize<'de>,
+		IQ: sc_service::ImportQueue<B> + 'static,
+	{
+		let file: Box<dyn Read + Send> = match &self.input {
+			Some(filename) => Box::new(fs::File::open(filename)?),
+			None => Box::new(io::stdin()),
+		};
+
+		import_blocks(client, import_queue, file, false, self.binary)
+			.await
+			.map_err(Into::into)
+	}
+}
+
+impl CliConfiguration for ImportBlocksCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/insert_key.rs b/substrate/client/cli/src/commands/insert_key.rs
new file mode 100644
index 0000000000000000000000000000000000000000..732d874319a83e51477354e7ba8addbad3e1acb2
--- /dev/null
+++ b/substrate/client/cli/src/commands/insert_key.rs
@@ -0,0 +1,167 @@
+// 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.
+
+//! Implementation of the `insert` subcommand
+
+use crate::{
+	utils, with_crypto_scheme, CryptoScheme, Error, KeystoreParams, SharedParams, SubstrateCli,
+};
+use clap::Parser;
+use sc_keystore::LocalKeystore;
+use sc_service::config::{BasePath, KeystoreConfig};
+use sp_core::crypto::{KeyTypeId, SecretString};
+use sp_keystore::KeystorePtr;
+
+/// The `insert` command
+#[derive(Debug, Clone, Parser)]
+#[command(name = "insert", about = "Insert a key to the keystore of a node.")]
+pub struct InsertKeyCmd {
+	/// The secret key URI.
+	/// If the value is a file, the file content is used as URI.
+	/// If not given, you will be prompted for the URI.
+	#[arg(long)]
+	suri: Option<String>,
+
+	/// Key type, examples: "gran", or "imon".
+	#[arg(long)]
+	key_type: String,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub keystore_params: KeystoreParams,
+
+	/// The cryptography scheme that should be used to generate the key out of the given URI.
+	#[arg(long, value_name = "SCHEME", value_enum, ignore_case = true)]
+	pub scheme: CryptoScheme,
+}
+
+impl InsertKeyCmd {
+	/// Run the command
+	pub fn run<C: SubstrateCli>(&self, cli: &C) -> Result<(), Error> {
+		let suri = utils::read_uri(self.suri.as_ref())?;
+		let base_path = self
+			.shared_params
+			.base_path()?
+			.unwrap_or_else(|| BasePath::from_project("", "", &C::executable_name()));
+		let chain_id = self.shared_params.chain_id(self.shared_params.is_dev());
+		let chain_spec = cli.load_spec(&chain_id)?;
+		let config_dir = base_path.config_dir(chain_spec.id());
+
+		let (keystore, public) = match self.keystore_params.keystore_config(&config_dir)? {
+			KeystoreConfig::Path { path, password } => {
+				let public = with_crypto_scheme!(self.scheme, to_vec(&suri, password.clone()))?;
+				let keystore: KeystorePtr = LocalKeystore::open(path, password)?.into();
+				(keystore, public)
+			},
+			_ => unreachable!("keystore_config always returns path and password; qed"),
+		};
+
+		let key_type =
+			KeyTypeId::try_from(self.key_type.as_str()).map_err(|_| Error::KeyTypeInvalid)?;
+
+		keystore
+			.insert(key_type, &suri, &public[..])
+			.map_err(|_| Error::KeystoreOperation)?;
+
+		Ok(())
+	}
+}
+
+fn to_vec<P: sp_core::Pair>(uri: &str, pass: Option<SecretString>) -> Result<Vec<u8>, Error> {
+	let p = utils::pair_from_suri::<P>(uri, pass)?;
+	Ok(p.public().as_ref().to_vec())
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_service::{ChainSpec, ChainType, GenericChainSpec, NoExtension};
+	use sp_core::{sr25519::Pair, ByteArray, Pair as _};
+	use sp_keystore::Keystore;
+	use tempfile::TempDir;
+
+	struct Cli;
+
+	impl SubstrateCli for Cli {
+		fn impl_name() -> String {
+			"test".into()
+		}
+
+		fn impl_version() -> String {
+			"2.0".into()
+		}
+
+		fn description() -> String {
+			"test".into()
+		}
+
+		fn support_url() -> String {
+			"test.test".into()
+		}
+
+		fn copyright_start_year() -> i32 {
+			2021
+		}
+
+		fn author() -> String {
+			"test".into()
+		}
+
+		fn load_spec(&self, _: &str) -> std::result::Result<Box<dyn ChainSpec>, String> {
+			Ok(Box::new(GenericChainSpec::from_genesis(
+				"test",
+				"test_id",
+				ChainType::Development,
+				|| unimplemented!("Not required in tests"),
+				Vec::new(),
+				None,
+				None,
+				None,
+				None,
+				NoExtension::None,
+			)))
+		}
+	}
+
+	#[test]
+	fn insert_with_custom_base_path() {
+		let path = TempDir::new().unwrap();
+		let path_str = format!("{}", path.path().display());
+		let (key, uri, _) = Pair::generate_with_phrase(None);
+
+		let inspect = InsertKeyCmd::parse_from(&[
+			"insert-key",
+			"-d",
+			&path_str,
+			"--key-type",
+			"test",
+			"--suri",
+			&uri,
+			"--scheme=sr25519",
+		]);
+		assert!(inspect.run(&Cli).is_ok());
+
+		let keystore =
+			LocalKeystore::open(path.path().join("chains").join("test_id").join("keystore"), None)
+				.unwrap();
+		assert!(keystore.has_keys(&[(key.public().to_raw_vec(), KeyTypeId(*b"test"))]));
+	}
+}
diff --git a/substrate/client/cli/src/commands/inspect_key.rs b/substrate/client/cli/src/commands/inspect_key.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5aa8b0bdcaa607ca53f996380a40791a3483584c
--- /dev/null
+++ b/substrate/client/cli/src/commands/inspect_key.rs
@@ -0,0 +1,263 @@
+// 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.
+
+//! Implementation of the `inspect` subcommand
+
+use crate::{
+	utils::{self, print_from_public, print_from_uri},
+	with_crypto_scheme, CryptoSchemeFlag, Error, KeystoreParams, NetworkSchemeFlag, OutputTypeFlag,
+};
+use clap::Parser;
+use sp_core::crypto::{ExposeSecret, SecretString, SecretUri, Ss58Codec};
+use std::str::FromStr;
+
+/// The `inspect` command
+#[derive(Debug, Parser)]
+#[command(
+	name = "inspect",
+	about = "Gets a public key and a SS58 address from the provided Secret URI"
+)]
+pub struct InspectKeyCmd {
+	/// A Key URI to be inspected. May be a secret seed, secret URI
+	/// (with derivation paths and password), SS58, public URI or a hex encoded public key.
+	/// If it is a hex encoded public key, `--public` needs to be given as argument.
+	/// If the given value is a file, the file content will be used
+	/// as URI.
+	/// If omitted, you will be prompted for the URI.
+	uri: Option<String>,
+
+	/// Is the given `uri` a hex encoded public key?
+	#[arg(long)]
+	public: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub keystore_params: KeystoreParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub network_scheme: NetworkSchemeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub output_scheme: OutputTypeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub crypto_scheme: CryptoSchemeFlag,
+
+	/// Expect that `--uri` has the given public key/account-id.
+	/// If `--uri` has any derivations, the public key is checked against the base `uri`, i.e. the
+	/// `uri` without any derivation applied. However, if `uri` has a password or there is one
+	/// given by `--password`, it will be used to decrypt `uri` before comparing the public
+	/// key/account-id.
+	/// If there is no derivation in `--uri`, the public key will be checked against the public key
+	/// of `--uri` directly.
+	#[arg(long, conflicts_with = "public")]
+	pub expect_public: Option<String>,
+}
+
+impl InspectKeyCmd {
+	/// Run the command
+	pub fn run(&self) -> Result<(), Error> {
+		let uri = utils::read_uri(self.uri.as_ref())?;
+		let password = self.keystore_params.read_password()?;
+
+		if self.public {
+			with_crypto_scheme!(
+				self.crypto_scheme.scheme,
+				print_from_public(
+					&uri,
+					self.network_scheme.network,
+					self.output_scheme.output_type,
+				)
+			)?;
+		} else {
+			if let Some(ref expect_public) = self.expect_public {
+				with_crypto_scheme!(
+					self.crypto_scheme.scheme,
+					expect_public_from_phrase(expect_public, &uri, password.as_ref())
+				)?;
+			}
+
+			with_crypto_scheme!(
+				self.crypto_scheme.scheme,
+				print_from_uri(
+					&uri,
+					password,
+					self.network_scheme.network,
+					self.output_scheme.output_type,
+				)
+			);
+		}
+
+		Ok(())
+	}
+}
+
+/// Checks that `expect_public` is the public key of `suri`.
+///
+/// If `suri` has any derivations, `expect_public` is checked against the public key of the "bare"
+/// `suri`, i.e. without any derivations.
+///
+/// Returns an error if the public key does not match.
+fn expect_public_from_phrase<Pair: sp_core::Pair>(
+	expect_public: &str,
+	suri: &str,
+	password: Option<&SecretString>,
+) -> Result<(), Error> {
+	let secret_uri = SecretUri::from_str(suri).map_err(|e| format!("{:?}", e))?;
+	let expected_public = if let Some(public) = expect_public.strip_prefix("0x") {
+		let hex_public = array_bytes::hex2bytes(public)
+			.map_err(|_| format!("Invalid expected public key hex: `{}`", expect_public))?;
+		Pair::Public::try_from(&hex_public)
+			.map_err(|_| format!("Invalid expected public key: `{}`", expect_public))?
+	} else {
+		Pair::Public::from_string_with_version(expect_public)
+			.map_err(|_| format!("Invalid expected account id: `{}`", expect_public))?
+			.0
+	};
+
+	let pair = Pair::from_string_with_seed(
+		secret_uri.phrase.expose_secret().as_str(),
+		password
+			.or_else(|| secret_uri.password.as_ref())
+			.map(|p| p.expose_secret().as_str()),
+	)
+	.map_err(|_| format!("Invalid secret uri: {}", suri))?
+	.0;
+
+	if pair.public() == expected_public {
+		Ok(())
+	} else {
+		Err(format!("Expected public ({}) key does not match.", expect_public).into())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::crypto::{ByteArray, Pair};
+	use sp_runtime::traits::IdentifyAccount;
+
+	#[test]
+	fn inspect() {
+		let words =
+			"remember fiber forum demise paper uniform squirrel feel access exclude casual effort";
+		let seed = "0xad1fb77243b536b90cfe5f0d351ab1b1ac40e3890b41dc64f766ee56340cfca5";
+
+		let inspect = InspectKeyCmd::parse_from(&["inspect-key", words, "--password", "12345"]);
+		assert!(inspect.run().is_ok());
+
+		let inspect = InspectKeyCmd::parse_from(&["inspect-key", seed]);
+		assert!(inspect.run().is_ok());
+	}
+
+	#[test]
+	fn inspect_public_key() {
+		let public = "0x12e76e0ae8ce41b6516cce52b3f23a08dcb4cfeed53c6ee8f5eb9f7367341069";
+
+		let inspect = InspectKeyCmd::parse_from(&["inspect-key", "--public", public]);
+		assert!(inspect.run().is_ok());
+	}
+
+	#[test]
+	fn inspect_with_expected_public_key() {
+		let check_cmd = |seed, expected_public, success| {
+			let inspect = InspectKeyCmd::parse_from(&[
+				"inspect-key",
+				"--expect-public",
+				expected_public,
+				seed,
+			]);
+			let res = inspect.run();
+
+			if success {
+				assert!(res.is_ok());
+			} else {
+				assert!(res.unwrap_err().to_string().contains(&format!(
+					"Expected public ({}) key does not match.",
+					expected_public
+				)));
+			}
+		};
+
+		let seed =
+			"remember fiber forum demise paper uniform squirrel feel access exclude casual effort";
+		let invalid_public = "0x12e76e0ae8ce41b6516cce52b3f23a08dcb4cfeed53c6ee8f5eb9f7367341069";
+		let valid_public = sp_core::sr25519::Pair::from_string_with_seed(seed, None)
+			.expect("Valid")
+			.0
+			.public();
+		let valid_public_hex = array_bytes::bytes2hex("0x", valid_public.as_slice());
+		let valid_accountid = format!("{}", valid_public.into_account());
+
+		// It should fail with the invalid public key
+		check_cmd(seed, invalid_public, false);
+
+		// It should work with the valid public key & account id
+		check_cmd(seed, &valid_public_hex, true);
+		check_cmd(seed, &valid_accountid, true);
+
+		let password = "test12245";
+		let seed_with_password = format!("{}///{}", seed, password);
+		let valid_public_with_password =
+			sp_core::sr25519::Pair::from_string_with_seed(&seed_with_password, Some(password))
+				.expect("Valid")
+				.0
+				.public();
+		let valid_public_hex_with_password =
+			array_bytes::bytes2hex("0x", valid_public_with_password.as_slice());
+		let valid_accountid_with_password =
+			format!("{}", &valid_public_with_password.into_account());
+
+		// Only the public key that corresponds to the seed with password should be accepted.
+		check_cmd(&seed_with_password, &valid_public_hex, false);
+		check_cmd(&seed_with_password, &valid_accountid, false);
+
+		check_cmd(&seed_with_password, &valid_public_hex_with_password, true);
+		check_cmd(&seed_with_password, &valid_accountid_with_password, true);
+
+		let seed_with_password_and_derivation = format!("{}//test//account///{}", seed, password);
+
+		let valid_public_with_password_and_derivation =
+			sp_core::sr25519::Pair::from_string_with_seed(
+				&seed_with_password_and_derivation,
+				Some(password),
+			)
+			.expect("Valid")
+			.0
+			.public();
+		let valid_public_hex_with_password_and_derivation =
+			array_bytes::bytes2hex("0x", valid_public_with_password_and_derivation.as_slice());
+
+		// They should still be valid, because we check the base secret key.
+		check_cmd(&seed_with_password_and_derivation, &valid_public_hex_with_password, true);
+		check_cmd(&seed_with_password_and_derivation, &valid_accountid_with_password, true);
+
+		// And these should be invalid.
+		check_cmd(&seed_with_password_and_derivation, &valid_public_hex, false);
+		check_cmd(&seed_with_password_and_derivation, &valid_accountid, false);
+
+		// The public of the derived account should fail.
+		check_cmd(
+			&seed_with_password_and_derivation,
+			&valid_public_hex_with_password_and_derivation,
+			false,
+		);
+	}
+}
diff --git a/substrate/client/cli/src/commands/inspect_node_key.rs b/substrate/client/cli/src/commands/inspect_node_key.rs
new file mode 100644
index 0000000000000000000000000000000000000000..19b5a31ca12c046ae112e91d1669f796c29909f5
--- /dev/null
+++ b/substrate/client/cli/src/commands/inspect_node_key.rs
@@ -0,0 +1,95 @@
+// 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.
+
+//! Implementation of the `inspect-node-key` subcommand
+
+use crate::Error;
+use clap::Parser;
+use libp2p_identity::Keypair;
+use std::{
+	fs,
+	io::{self, Read},
+	path::PathBuf,
+};
+
+/// The `inspect-node-key` command
+#[derive(Debug, Parser)]
+#[command(
+	name = "inspect-node-key",
+	about = "Load a node key from a file or stdin and print the corresponding peer-id."
+)]
+pub struct InspectNodeKeyCmd {
+	/// Name of file to read the secret key from.
+	/// If not given, the secret key is read from stdin (up to EOF).
+	#[arg(long)]
+	file: Option<PathBuf>,
+
+	/// The input is in raw binary format.
+	/// If not given, the input is read as an hex encoded string.
+	#[arg(long)]
+	bin: bool,
+
+	/// This argument is deprecated and has no effect for this command.
+	#[deprecated(note = "Network identifier is not used for node-key inspection")]
+	#[arg(short = 'n', long = "network", value_name = "NETWORK", ignore_case = true)]
+	pub network_scheme: Option<String>,
+}
+
+impl InspectNodeKeyCmd {
+	/// runs the command
+	pub fn run(&self) -> Result<(), Error> {
+		let mut file_data = match &self.file {
+			Some(file) => fs::read(&file)?,
+			None => {
+				let mut buf = Vec::with_capacity(64);
+				io::stdin().lock().read_to_end(&mut buf)?;
+				buf
+			},
+		};
+
+		if !self.bin {
+			// With hex input, give to the user a bit of tolerance about whitespaces
+			let keyhex = String::from_utf8_lossy(&file_data);
+			file_data = array_bytes::hex2bytes(keyhex.trim())
+				.map_err(|_| "failed to decode secret as hex")?;
+		}
+
+		let keypair =
+			Keypair::ed25519_from_bytes(&mut file_data).map_err(|_| "Bad node key file")?;
+
+		println!("{}", keypair.public().to_peer_id());
+
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{super::GenerateNodeKeyCmd, *};
+
+	#[test]
+	fn inspect_node_key() {
+		let path = tempfile::tempdir().unwrap().into_path().join("node-id").into_os_string();
+		let path = path.to_str().unwrap();
+		let cmd = GenerateNodeKeyCmd::parse_from(&["generate-node-key", "--file", path.clone()]);
+
+		assert!(cmd.run().is_ok());
+
+		let cmd = InspectNodeKeyCmd::parse_from(&["inspect-node-key", "--file", path]);
+		assert!(cmd.run().is_ok());
+	}
+}
diff --git a/substrate/client/cli/src/commands/key.rs b/substrate/client/cli/src/commands/key.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d49b7e4072c8eb5453b0540117dacaf23e89f912
--- /dev/null
+++ b/substrate/client/cli/src/commands/key.rs
@@ -0,0 +1,57 @@
+// 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.
+
+//! Key related CLI utilities
+
+use super::{
+	generate::GenerateCmd, generate_node_key::GenerateNodeKeyCmd, insert_key::InsertKeyCmd,
+	inspect_key::InspectKeyCmd, inspect_node_key::InspectNodeKeyCmd,
+};
+use crate::{Error, SubstrateCli};
+
+/// Key utilities for the cli.
+#[derive(Debug, clap::Subcommand)]
+pub enum KeySubcommand {
+	/// Generate a random node key, write it to a file or stdout and write the
+	/// corresponding peer-id to stderr
+	GenerateNodeKey(GenerateNodeKeyCmd),
+
+	/// Generate a random account
+	Generate(GenerateCmd),
+
+	/// Gets a public key and a SS58 address from the provided Secret URI
+	Inspect(InspectKeyCmd),
+
+	/// Load a node key from a file or stdin and print the corresponding peer-id
+	InspectNodeKey(InspectNodeKeyCmd),
+
+	/// Insert a key to the keystore of a node.
+	Insert(InsertKeyCmd),
+}
+
+impl KeySubcommand {
+	/// run the key subcommands
+	pub fn run<C: SubstrateCli>(&self, cli: &C) -> Result<(), Error> {
+		match self {
+			KeySubcommand::GenerateNodeKey(cmd) => cmd.run(),
+			KeySubcommand::Generate(cmd) => cmd.run(),
+			KeySubcommand::Inspect(cmd) => cmd.run(),
+			KeySubcommand::Insert(cmd) => cmd.run(cli),
+			KeySubcommand::InspectNodeKey(cmd) => cmd.run(),
+		}
+	}
+}
diff --git a/substrate/client/cli/src/commands/mod.rs b/substrate/client/cli/src/commands/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9d48d2bdf644fdc2ec6417148f138aafaf04f063
--- /dev/null
+++ b/substrate/client/cli/src/commands/mod.rs
@@ -0,0 +1,49 @@
+// 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/>.
+
+//! Various subcommands that can be included in a substrate-based chain's CLI.
+
+mod build_spec_cmd;
+mod chain_info_cmd;
+mod check_block_cmd;
+mod export_blocks_cmd;
+mod export_state_cmd;
+mod generate;
+mod generate_node_key;
+mod import_blocks_cmd;
+mod insert_key;
+mod inspect_key;
+mod inspect_node_key;
+mod key;
+mod purge_chain_cmd;
+mod revert_cmd;
+mod run_cmd;
+mod sign;
+mod test;
+pub mod utils;
+mod vanity;
+mod verify;
+
+pub use self::{
+	build_spec_cmd::BuildSpecCmd, chain_info_cmd::ChainInfoCmd, check_block_cmd::CheckBlockCmd,
+	export_blocks_cmd::ExportBlocksCmd, export_state_cmd::ExportStateCmd, generate::GenerateCmd,
+	generate_node_key::GenerateNodeKeyCmd, import_blocks_cmd::ImportBlocksCmd,
+	insert_key::InsertKeyCmd, inspect_key::InspectKeyCmd, inspect_node_key::InspectNodeKeyCmd,
+	key::KeySubcommand, purge_chain_cmd::PurgeChainCmd, revert_cmd::RevertCmd, run_cmd::RunCmd,
+	sign::SignCmd, vanity::VanityCmd, verify::VerifyCmd,
+};
diff --git a/substrate/client/cli/src/commands/purge_chain_cmd.rs b/substrate/client/cli/src/commands/purge_chain_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2ff3d4b9a04c017095180625a1b3c299ab4bd8b8
--- /dev/null
+++ b/substrate/client/cli/src/commands/purge_chain_cmd.rs
@@ -0,0 +1,94 @@
+// 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::{
+	error,
+	params::{DatabaseParams, SharedParams},
+	CliConfiguration,
+};
+use clap::Parser;
+use sc_service::DatabaseSource;
+use std::{
+	fmt::Debug,
+	fs,
+	io::{self, Write},
+};
+
+/// The `purge-chain` command used to remove the whole chain.
+#[derive(Debug, Clone, Parser)]
+pub struct PurgeChainCmd {
+	/// Skip interactive prompt by answering yes automatically.
+	#[arg(short = 'y')]
+	pub yes: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub database_params: DatabaseParams,
+}
+
+impl PurgeChainCmd {
+	/// Run the purge command
+	pub fn run(&self, database_config: DatabaseSource) -> error::Result<()> {
+		let db_path = database_config.path().ok_or_else(|| {
+			error::Error::Input("Cannot purge custom database implementation".into())
+		})?;
+
+		if !self.yes {
+			print!("Are you sure to remove {:?}? [y/N]: ", &db_path);
+			io::stdout().flush().expect("failed to flush stdout");
+
+			let mut input = String::new();
+			io::stdin().read_line(&mut input)?;
+			let input = input.trim();
+
+			match input.chars().next() {
+				Some('y') | Some('Y') => {},
+				_ => {
+					println!("Aborted");
+					return Ok(())
+				},
+			}
+		}
+
+		match fs::remove_dir_all(&db_path) {
+			Ok(_) => {
+				println!("{:?} removed.", &db_path);
+				Ok(())
+			},
+			Err(ref err) if err.kind() == io::ErrorKind::NotFound => {
+				eprintln!("{:?} did not exist.", &db_path);
+				Ok(())
+			},
+			Err(err) => Result::Err(err.into()),
+		}
+	}
+}
+
+impl CliConfiguration for PurgeChainCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		Some(&self.database_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/revert_cmd.rs b/substrate/client/cli/src/commands/revert_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..34e8c1036c59fb24687145c19d8d17bd89b7a6ca
--- /dev/null
+++ b/substrate/client/cli/src/commands/revert_cmd.rs
@@ -0,0 +1,90 @@
+// 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::{
+	error,
+	params::{DatabaseParams, GenericNumber, PruningParams, SharedParams},
+	CliConfiguration,
+};
+use clap::Parser;
+use sc_client_api::{Backend, UsageProvider};
+use sc_service::chain_ops::revert_chain;
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
+use std::{fmt::Debug, str::FromStr, sync::Arc};
+
+/// The `revert` command used revert the chain to a previous state.
+#[derive(Debug, Parser)]
+pub struct RevertCmd {
+	/// Number of blocks to revert.
+	#[arg(default_value = "256")]
+	pub num: GenericNumber,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub pruning_params: PruningParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub database_params: DatabaseParams,
+}
+
+/// Revert handler for auxiliary data (e.g. consensus).
+type AuxRevertHandler<C, BA, B> =
+	Box<dyn FnOnce(Arc<C>, Arc<BA>, NumberFor<B>) -> error::Result<()>>;
+
+impl RevertCmd {
+	/// Run the revert command
+	pub async fn run<B, BA, C>(
+		&self,
+		client: Arc<C>,
+		backend: Arc<BA>,
+		aux_revert: Option<AuxRevertHandler<C, BA, B>>,
+	) -> error::Result<()>
+	where
+		B: BlockT,
+		BA: Backend<B>,
+		C: UsageProvider<B>,
+		<<<B as BlockT>::Header as HeaderT>::Number as FromStr>::Err: Debug,
+	{
+		let blocks = self.num.parse()?;
+		if let Some(aux_revert) = aux_revert {
+			aux_revert(client.clone(), backend.clone(), blocks)?;
+		}
+		revert_chain(client, backend, blocks)?;
+
+		Ok(())
+	}
+}
+
+impl CliConfiguration for RevertCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn pruning_params(&self) -> Option<&PruningParams> {
+		Some(&self.pruning_params)
+	}
+
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		Some(&self.database_params)
+	}
+}
diff --git a/substrate/client/cli/src/commands/run_cmd.rs b/substrate/client/cli/src/commands/run_cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5dda488b1333052078d104ddc8371719219784f6
--- /dev/null
+++ b/substrate/client/cli/src/commands/run_cmd.rs
@@ -0,0 +1,526 @@
+// 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::{
+	arg_enums::RpcMethods,
+	error::{Error, Result},
+	params::{
+		ImportParams, KeystoreParams, NetworkParams, OffchainWorkerParams, SharedParams,
+		TransactionPoolParams,
+	},
+	CliConfiguration, PrometheusParams, RuntimeParams, TelemetryParams,
+	RPC_DEFAULT_MAX_CONNECTIONS, RPC_DEFAULT_MAX_REQUEST_SIZE_MB, RPC_DEFAULT_MAX_RESPONSE_SIZE_MB,
+	RPC_DEFAULT_MAX_SUBS_PER_CONN,
+};
+use clap::Parser;
+use regex::Regex;
+use sc_service::{
+	config::{BasePath, PrometheusConfig, TransactionPoolOptions},
+	ChainSpec, Role,
+};
+use sc_telemetry::TelemetryEndpoints;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+
+/// The `run` command used to run a node.
+#[derive(Debug, Clone, Parser)]
+pub struct RunCmd {
+	/// Enable validator mode.
+	/// The node will be started with the authority role and actively
+	/// participate in any consensus task that it can (e.g. depending on
+	/// availability of local keys).
+	#[arg(long)]
+	pub validator: bool,
+
+	/// Disable GRANDPA voter when running in validator mode, otherwise disable the GRANDPA
+	/// observer.
+	#[arg(long)]
+	pub no_grandpa: bool,
+
+	/// Listen to all RPC interfaces.
+	/// Default is local. Note: not all RPC methods are safe to be exposed publicly. Use an RPC
+	/// proxy server to filter out dangerous methods. More details:
+	/// <https://docs.substrate.io/main-docs/build/custom-rpc/#public-rpcs>.
+	/// Use `--unsafe-rpc-external` to suppress the warning if you understand the risks.
+	#[arg(long)]
+	pub rpc_external: bool,
+
+	/// Listen to all RPC interfaces.
+	/// Same as `--rpc-external`.
+	#[arg(long)]
+	pub unsafe_rpc_external: bool,
+
+	/// RPC methods to expose.
+	/// - `unsafe`: Exposes every RPC method.
+	/// - `safe`: Exposes only a safe subset of RPC methods, denying unsafe RPC methods.
+	/// - `auto`: Acts as `safe` if RPC is served externally, e.g. when `--rpc--external` is
+	///   passed, otherwise acts as `unsafe`.
+	#[arg(
+		long,
+		value_name = "METHOD SET",
+		value_enum,
+		ignore_case = true,
+		default_value_t = RpcMethods::Auto,
+		verbatim_doc_comment
+	)]
+	pub rpc_methods: RpcMethods,
+
+	/// Set the the maximum RPC request payload size for both HTTP and WS in megabytes.
+	#[arg(long, default_value_t = RPC_DEFAULT_MAX_REQUEST_SIZE_MB)]
+	pub rpc_max_request_size: u32,
+
+	/// Set the the maximum RPC response payload size for both HTTP and WS in megabytes.
+	#[arg(long, default_value_t = RPC_DEFAULT_MAX_RESPONSE_SIZE_MB)]
+	pub rpc_max_response_size: u32,
+
+	/// Set the the maximum concurrent subscriptions per connection.
+	#[arg(long, default_value_t = RPC_DEFAULT_MAX_SUBS_PER_CONN)]
+	pub rpc_max_subscriptions_per_connection: u32,
+
+	/// Specify JSON-RPC server TCP port.
+	#[arg(long, value_name = "PORT")]
+	pub rpc_port: Option<u16>,
+
+	/// Maximum number of RPC server connections.
+	#[arg(long, value_name = "COUNT", default_value_t = RPC_DEFAULT_MAX_CONNECTIONS)]
+	pub rpc_max_connections: u32,
+
+	/// Specify browser Origins allowed to access the HTTP & WS RPC servers.
+	/// A comma-separated list of origins (protocol://domain or special `null`
+	/// value). Value of `all` will disable origin validation. Default is to
+	/// allow localhost and <https://polkadot.js.org> origins. When running in
+	/// --dev mode the default is to allow all origins.
+	#[arg(long, value_name = "ORIGINS", value_parser = parse_cors)]
+	pub rpc_cors: Option<Cors>,
+
+	/// The human-readable name for this node.
+	/// It's used as network node name.
+	#[arg(long, value_name = "NAME")]
+	pub name: Option<String>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub telemetry_params: TelemetryParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub prometheus_params: PrometheusParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub runtime_params: RuntimeParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub offchain_worker_params: OffchainWorkerParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub network_params: NetworkParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub pool_config: TransactionPoolParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub keystore_params: KeystoreParams,
+
+	/// Shortcut for `--name Alice --validator` with session keys for `Alice` added to keystore.
+	#[arg(long, conflicts_with_all = &["bob", "charlie", "dave", "eve", "ferdie", "one", "two"])]
+	pub alice: bool,
+
+	/// Shortcut for `--name Bob --validator` with session keys for `Bob` added to keystore.
+	#[arg(long, conflicts_with_all = &["alice", "charlie", "dave", "eve", "ferdie", "one", "two"])]
+	pub bob: bool,
+
+	/// Shortcut for `--name Charlie --validator` with session keys for `Charlie` added to
+	/// keystore.
+	#[arg(long, conflicts_with_all = &["alice", "bob", "dave", "eve", "ferdie", "one", "two"])]
+	pub charlie: bool,
+
+	/// Shortcut for `--name Dave --validator` with session keys for `Dave` added to keystore.
+	#[arg(long, conflicts_with_all = &["alice", "bob", "charlie", "eve", "ferdie", "one", "two"])]
+	pub dave: bool,
+
+	/// Shortcut for `--name Eve --validator` with session keys for `Eve` added to keystore.
+	#[arg(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "ferdie", "one", "two"])]
+	pub eve: bool,
+
+	/// Shortcut for `--name Ferdie --validator` with session keys for `Ferdie` added to keystore.
+	#[arg(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "eve", "one", "two"])]
+	pub ferdie: bool,
+
+	/// Shortcut for `--name One --validator` with session keys for `One` added to keystore.
+	#[arg(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "eve", "ferdie", "two"])]
+	pub one: bool,
+
+	/// Shortcut for `--name Two --validator` with session keys for `Two` added to keystore.
+	#[arg(long, conflicts_with_all = &["alice", "bob", "charlie", "dave", "eve", "ferdie", "one"])]
+	pub two: bool,
+
+	/// Enable authoring even when offline.
+	#[arg(long)]
+	pub force_authoring: bool,
+
+	/// Run a temporary node.
+	/// A temporary directory will be created to store the configuration and will be deleted
+	/// at the end of the process.
+	/// Note: the directory is random per process execution. This directory is used as base path
+	/// which includes: database, node key and keystore.
+	/// When `--dev` is given and no explicit `--base-path`, this option is implied.
+	#[arg(long, conflicts_with = "base_path")]
+	pub tmp: bool,
+}
+
+impl RunCmd {
+	/// Get the `Sr25519Keyring` matching one of the flag.
+	pub fn get_keyring(&self) -> Option<sp_keyring::Sr25519Keyring> {
+		use sp_keyring::Sr25519Keyring::*;
+
+		if self.alice {
+			Some(Alice)
+		} else if self.bob {
+			Some(Bob)
+		} else if self.charlie {
+			Some(Charlie)
+		} else if self.dave {
+			Some(Dave)
+		} else if self.eve {
+			Some(Eve)
+		} else if self.ferdie {
+			Some(Ferdie)
+		} else if self.one {
+			Some(One)
+		} else if self.two {
+			Some(Two)
+		} else {
+			None
+		}
+	}
+}
+
+impl CliConfiguration for RunCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+
+	fn network_params(&self) -> Option<&NetworkParams> {
+		Some(&self.network_params)
+	}
+
+	fn keystore_params(&self) -> Option<&KeystoreParams> {
+		Some(&self.keystore_params)
+	}
+
+	fn offchain_worker_params(&self) -> Option<&OffchainWorkerParams> {
+		Some(&self.offchain_worker_params)
+	}
+
+	fn node_name(&self) -> Result<String> {
+		let name: String = match (self.name.as_ref(), self.get_keyring()) {
+			(Some(name), _) => name.to_string(),
+			(_, Some(keyring)) => keyring.to_string(),
+			(None, None) => crate::generate_node_name(),
+		};
+
+		is_node_name_valid(&name).map_err(|msg| {
+			Error::Input(format!(
+				"Invalid node name '{}'. Reason: {}. If unsure, use none.",
+				name, msg
+			))
+		})?;
+
+		Ok(name)
+	}
+
+	fn dev_key_seed(&self, is_dev: bool) -> Result<Option<String>> {
+		Ok(self.get_keyring().map(|a| format!("//{}", a)).or_else(|| {
+			if is_dev {
+				Some("//Alice".into())
+			} else {
+				None
+			}
+		}))
+	}
+
+	fn telemetry_endpoints(
+		&self,
+		chain_spec: &Box<dyn ChainSpec>,
+	) -> Result<Option<TelemetryEndpoints>> {
+		let params = &self.telemetry_params;
+		Ok(if params.no_telemetry {
+			None
+		} else if !params.telemetry_endpoints.is_empty() {
+			Some(
+				TelemetryEndpoints::new(params.telemetry_endpoints.clone())
+					.map_err(|e| e.to_string())?,
+			)
+		} else {
+			chain_spec.telemetry_endpoints().clone()
+		})
+	}
+
+	fn role(&self, is_dev: bool) -> Result<Role> {
+		let keyring = self.get_keyring();
+		let is_authority = self.validator || is_dev || keyring.is_some();
+
+		Ok(if is_authority { Role::Authority } else { Role::Full })
+	}
+
+	fn force_authoring(&self) -> Result<bool> {
+		// Imply forced authoring on --dev
+		Ok(self.shared_params.dev || self.force_authoring)
+	}
+
+	fn prometheus_config(
+		&self,
+		default_listen_port: u16,
+		chain_spec: &Box<dyn ChainSpec>,
+	) -> Result<Option<PrometheusConfig>> {
+		Ok(self
+			.prometheus_params
+			.prometheus_config(default_listen_port, chain_spec.id().to_string()))
+	}
+
+	fn disable_grandpa(&self) -> Result<bool> {
+		Ok(self.no_grandpa)
+	}
+
+	fn rpc_max_connections(&self) -> Result<u32> {
+		Ok(self.rpc_max_connections)
+	}
+
+	fn rpc_cors(&self, is_dev: bool) -> Result<Option<Vec<String>>> {
+		Ok(self
+			.rpc_cors
+			.clone()
+			.unwrap_or_else(|| {
+				if is_dev {
+					log::warn!("Running in --dev mode, RPC CORS has been disabled.");
+					Cors::All
+				} else {
+					Cors::List(vec![
+						"http://localhost:*".into(),
+						"http://127.0.0.1:*".into(),
+						"https://localhost:*".into(),
+						"https://127.0.0.1:*".into(),
+						"https://polkadot.js.org".into(),
+					])
+				}
+			})
+			.into())
+	}
+
+	fn rpc_addr(&self, default_listen_port: u16) -> Result<Option<SocketAddr>> {
+		let interface = rpc_interface(
+			self.rpc_external,
+			self.unsafe_rpc_external,
+			self.rpc_methods,
+			self.validator,
+		)?;
+
+		Ok(Some(SocketAddr::new(interface, self.rpc_port.unwrap_or(default_listen_port))))
+	}
+
+	fn rpc_methods(&self) -> Result<sc_service::config::RpcMethods> {
+		Ok(self.rpc_methods.into())
+	}
+
+	fn rpc_max_request_size(&self) -> Result<u32> {
+		Ok(self.rpc_max_request_size)
+	}
+
+	fn rpc_max_response_size(&self) -> Result<u32> {
+		Ok(self.rpc_max_response_size)
+	}
+
+	fn rpc_max_subscriptions_per_connection(&self) -> Result<u32> {
+		Ok(self.rpc_max_subscriptions_per_connection)
+	}
+
+	fn transaction_pool(&self, is_dev: bool) -> Result<TransactionPoolOptions> {
+		Ok(self.pool_config.transaction_pool(is_dev))
+	}
+
+	fn max_runtime_instances(&self) -> Result<Option<usize>> {
+		Ok(Some(self.runtime_params.max_runtime_instances))
+	}
+
+	fn runtime_cache_size(&self) -> Result<u8> {
+		Ok(self.runtime_params.runtime_cache_size)
+	}
+
+	fn base_path(&self) -> Result<Option<BasePath>> {
+		Ok(if self.tmp {
+			Some(BasePath::new_temp_dir()?)
+		} else {
+			match self.shared_params().base_path()? {
+				Some(r) => Some(r),
+				// If `dev` is enabled, we use the temp base path.
+				None if self.shared_params().is_dev() => Some(BasePath::new_temp_dir()?),
+				None => None,
+			}
+		})
+	}
+}
+
+/// Check whether a node name is considered as valid.
+pub fn is_node_name_valid(_name: &str) -> std::result::Result<(), &str> {
+	let name = _name.to_string();
+
+	if name.is_empty() {
+		return Err("Node name cannot be empty")
+	}
+
+	if name.chars().count() >= crate::NODE_NAME_MAX_LENGTH {
+		return Err("Node name too long")
+	}
+
+	let invalid_chars = r"[\\.@]";
+	let re = Regex::new(invalid_chars).unwrap();
+	if re.is_match(&name) {
+		return Err("Node name should not contain invalid chars such as '.' and '@'")
+	}
+
+	let invalid_patterns = r"^https?:";
+	let re = Regex::new(invalid_patterns).unwrap();
+	if re.is_match(&name) {
+		return Err("Node name should not contain urls")
+	}
+
+	Ok(())
+}
+
+fn rpc_interface(
+	is_external: bool,
+	is_unsafe_external: bool,
+	rpc_methods: RpcMethods,
+	is_validator: bool,
+) -> Result<IpAddr> {
+	if is_external && is_validator && rpc_methods != RpcMethods::Unsafe {
+		return Err(Error::Input(
+			"--rpc-external option shouldn't be used if the node is running as \
+			 a validator. Use `--unsafe-rpc-external` or `--rpc-methods=unsafe` if you understand \
+			 the risks. See the options description for more information."
+				.to_owned(),
+		))
+	}
+
+	if is_external || is_unsafe_external {
+		if rpc_methods == RpcMethods::Unsafe {
+			log::warn!(
+				"It isn't safe to expose RPC publicly without a proxy server that filters \
+				 available set of RPC methods."
+			);
+		}
+
+		Ok(Ipv4Addr::UNSPECIFIED.into())
+	} else {
+		Ok(Ipv4Addr::LOCALHOST.into())
+	}
+}
+
+/// CORS setting
+///
+/// The type is introduced to overcome `Option<Option<T>>` handling of `clap`.
+#[derive(Clone, Debug)]
+pub enum Cors {
+	/// All hosts allowed.
+	All,
+	/// Only hosts on the list are allowed.
+	List(Vec<String>),
+}
+
+impl From<Cors> for Option<Vec<String>> {
+	fn from(cors: Cors) -> Self {
+		match cors {
+			Cors::All => None,
+			Cors::List(list) => Some(list),
+		}
+	}
+}
+
+/// Parse cors origins.
+fn parse_cors(s: &str) -> Result<Cors> {
+	let mut is_all = false;
+	let mut origins = Vec::new();
+	for part in s.split(',') {
+		match part {
+			"all" | "*" => {
+				is_all = true;
+				break
+			},
+			other => origins.push(other.to_owned()),
+		}
+	}
+
+	if is_all {
+		Ok(Cors::All)
+	} else {
+		Ok(Cors::List(origins))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn tests_node_name_good() {
+		assert!(is_node_name_valid("short name").is_ok());
+		assert!(is_node_name_valid("www").is_ok());
+		assert!(is_node_name_valid("aawww").is_ok());
+		assert!(is_node_name_valid("wwwaa").is_ok());
+		assert!(is_node_name_valid("www aa").is_ok());
+	}
+
+	#[test]
+	fn tests_node_name_bad() {
+		assert!(is_node_name_valid("").is_err());
+		assert!(is_node_name_valid(
+			"very very long names are really not very cool for the ui at all, really they're not"
+		)
+		.is_err());
+		assert!(is_node_name_valid("Dots.not.Ok").is_err());
+		// NOTE: the urls below don't include a domain otherwise
+		// they'd get filtered for including a `.`
+		assert!(is_node_name_valid("http://visitme").is_err());
+		assert!(is_node_name_valid("http:/visitme").is_err());
+		assert!(is_node_name_valid("http:visitme").is_err());
+		assert!(is_node_name_valid("https://visitme").is_err());
+		assert!(is_node_name_valid("https:/visitme").is_err());
+		assert!(is_node_name_valid("https:visitme").is_err());
+		assert!(is_node_name_valid("www.visit.me").is_err());
+		assert!(is_node_name_valid("www.visit").is_err());
+		assert!(is_node_name_valid("hello\\world").is_err());
+		assert!(is_node_name_valid("visit.www").is_err());
+		assert!(is_node_name_valid("email@domain").is_err());
+	}
+}
diff --git a/substrate/client/cli/src/commands/sign.rs b/substrate/client/cli/src/commands/sign.rs
new file mode 100644
index 0000000000000000000000000000000000000000..91b0651f0521f4acfcd696497e67562d359dab13
--- /dev/null
+++ b/substrate/client/cli/src/commands/sign.rs
@@ -0,0 +1,126 @@
+// 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/>.
+
+//! Implementation of the `sign` subcommand
+use crate::{
+	error, params::MessageParams, utils, with_crypto_scheme, CryptoSchemeFlag, KeystoreParams,
+};
+use array_bytes::bytes2hex;
+use clap::Parser;
+use sp_core::crypto::SecretString;
+use std::io::{BufRead, Write};
+
+/// The `sign` command
+#[derive(Debug, Clone, Parser)]
+#[command(name = "sign", about = "Sign a message, with a given (secret) key")]
+pub struct SignCmd {
+	/// The secret key URI.
+	/// If the value is a file, the file content is used as URI.
+	/// If not given, you will be prompted for the URI.
+	#[arg(long)]
+	suri: Option<String>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub message_params: MessageParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub keystore_params: KeystoreParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub crypto_scheme: CryptoSchemeFlag,
+}
+
+impl SignCmd {
+	/// Run the command
+	pub fn run(&self) -> error::Result<()> {
+		let sig = self.sign(|| std::io::stdin().lock())?;
+		std::io::stdout().lock().write_all(sig.as_bytes())?;
+		Ok(())
+	}
+
+	/// Sign a message.
+	///
+	/// The message can either be provided as immediate argument via CLI or otherwise read from the
+	/// reader created by `create_reader`. The reader will only be created in case that the message
+	/// is not passed as immediate.
+	pub(crate) fn sign<F, R>(&self, create_reader: F) -> error::Result<String>
+	where
+		R: BufRead,
+		F: FnOnce() -> R,
+	{
+		let message = self.message_params.message_from(create_reader)?;
+		let suri = utils::read_uri(self.suri.as_ref())?;
+		let password = self.keystore_params.read_password()?;
+
+		with_crypto_scheme!(self.crypto_scheme.scheme, sign(&suri, password, message))
+	}
+}
+
+fn sign<P: sp_core::Pair>(
+	suri: &str,
+	password: Option<SecretString>,
+	message: Vec<u8>,
+) -> error::Result<String> {
+	let pair = utils::pair_from_suri::<P>(suri, password)?;
+	Ok(bytes2hex("0x", pair.sign(&message).as_ref()))
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	const SEED: &str = "0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a";
+
+	#[test]
+	fn sign_arg() {
+		let cmd = SignCmd::parse_from(&[
+			"sign",
+			"--suri",
+			&SEED,
+			"--message",
+			&SEED,
+			"--password",
+			"12345",
+			"--hex",
+		]);
+		let sig = cmd.sign(|| std::io::stdin().lock()).expect("Must sign");
+
+		assert!(sig.starts_with("0x"), "Signature must start with 0x");
+		assert!(array_bytes::hex2bytes(&sig).is_ok(), "Signature is valid hex");
+	}
+
+	#[test]
+	fn sign_stdin() {
+		let cmd = SignCmd::parse_from(&[
+			"sign",
+			"--suri",
+			SEED,
+			"--message",
+			&SEED,
+			"--password",
+			"12345",
+		]);
+		let sig = cmd.sign(|| SEED.as_bytes()).expect("Must sign");
+
+		assert!(sig.starts_with("0x"), "Signature must start with 0x");
+		assert!(array_bytes::hex2bytes(&sig).is_ok(), "Signature is valid hex");
+	}
+}
diff --git a/substrate/client/cli/src/commands/test/mod.rs b/substrate/client/cli/src/commands/test/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9b5d0ee897a933b9b17592cc30cb610c0b85c993
--- /dev/null
+++ b/substrate/client/cli/src/commands/test/mod.rs
@@ -0,0 +1,21 @@
+// 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/>.
+
+//! Integration tests for subkey commands.
+
+mod sig_verify;
diff --git a/substrate/client/cli/src/commands/test/sig_verify.rs b/substrate/client/cli/src/commands/test/sig_verify.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bffd7dbc9fc03b2b2b13610c2bb5ca01f1664504
--- /dev/null
+++ b/substrate/client/cli/src/commands/test/sig_verify.rs
@@ -0,0 +1,152 @@
+// 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/>.
+
+#![cfg(test)]
+
+//! Integration test that the `sign` and `verify` sub-commands work together.
+
+use crate::*;
+use clap::Parser;
+
+const SEED: &str = "0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a";
+const ALICE: &str = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY";
+const BOB: &str = "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty";
+
+/// Sign a valid UFT-8 message which can be `hex` and passed either via `stdin` or as an argument.
+fn sign(msg: &str, hex: bool, stdin: bool) -> String {
+	sign_raw(msg.as_bytes(), hex, stdin)
+}
+
+/// Sign a raw message which can be `hex` and passed either via `stdin` or as an argument.
+fn sign_raw(msg: &[u8], hex: bool, stdin: bool) -> String {
+	let mut args = vec!["sign", "--suri", SEED];
+	if !stdin {
+		args.push("--message");
+		args.push(std::str::from_utf8(msg).expect("Can only pass valid UTF-8 as arg"));
+	}
+	if hex {
+		args.push("--hex");
+	}
+	let cmd = SignCmd::parse_from(&args);
+	cmd.sign(|| msg).expect("Static data is good; Must sign; qed")
+}
+
+/// Verify a valid UFT-8 message which can be `hex` and passed either via `stdin` or as an argument.
+fn verify(msg: &str, hex: bool, stdin: bool, who: &str, sig: &str) -> bool {
+	verify_raw(msg.as_bytes(), hex, stdin, who, sig)
+}
+
+/// Verify a raw message which can be `hex` and passed either via `stdin` or as an argument.
+fn verify_raw(msg: &[u8], hex: bool, stdin: bool, who: &str, sig: &str) -> bool {
+	let mut args = vec!["verify", sig, who];
+	if !stdin {
+		args.push("--message");
+		args.push(std::str::from_utf8(msg).expect("Can only pass valid UTF-8 as arg"));
+	}
+	if hex {
+		args.push("--hex");
+	}
+	let cmd = VerifyCmd::parse_from(&args);
+	cmd.verify(|| msg).is_ok()
+}
+
+/// Test that sig/verify works with UTF-8 bytes passed as arg.
+#[test]
+fn sig_verify_arg_utf8_work() {
+	let sig = sign("Something", false, false);
+
+	assert!(verify("Something", false, false, ALICE, &sig));
+	assert!(!verify("Something", false, false, BOB, &sig));
+
+	assert!(!verify("Wrong", false, false, ALICE, &sig));
+	assert!(!verify("Not hex", true, false, ALICE, &sig));
+	assert!(!verify("0x1234", true, false, ALICE, &sig));
+	assert!(!verify("Wrong", false, false, BOB, &sig));
+	assert!(!verify("Not hex", true, false, BOB, &sig));
+	assert!(!verify("0x1234", true, false, BOB, &sig));
+}
+
+/// Test that sig/verify works with UTF-8 bytes passed via stdin.
+#[test]
+fn sig_verify_stdin_utf8_work() {
+	let sig = sign("Something", false, true);
+
+	assert!(verify("Something", false, true, ALICE, &sig));
+	assert!(!verify("Something", false, true, BOB, &sig));
+
+	assert!(!verify("Wrong", false, true, ALICE, &sig));
+	assert!(!verify("Not hex", true, true, ALICE, &sig));
+	assert!(!verify("0x1234", true, true, ALICE, &sig));
+	assert!(!verify("Wrong", false, true, BOB, &sig));
+	assert!(!verify("Not hex", true, true, BOB, &sig));
+	assert!(!verify("0x1234", true, true, BOB, &sig));
+}
+
+/// Test that sig/verify works with hex bytes passed as arg.
+#[test]
+fn sig_verify_arg_hex_work() {
+	let sig = sign("0xaabbcc", true, false);
+
+	assert!(verify("0xaabbcc", true, false, ALICE, &sig));
+	assert!(verify("aabBcc", true, false, ALICE, &sig));
+	assert!(verify("0xaAbbCC", true, false, ALICE, &sig));
+	assert!(!verify("0xaabbcc", true, false, BOB, &sig));
+
+	assert!(!verify("0xaabbcc", false, false, ALICE, &sig));
+}
+
+/// Test that sig/verify works with hex bytes passed via stdin.
+#[test]
+fn sig_verify_stdin_hex_work() {
+	let sig = sign("0xaabbcc", true, true);
+
+	assert!(verify("0xaabbcc", true, true, ALICE, &sig));
+	assert!(verify("aabBcc", true, true, ALICE, &sig));
+	assert!(verify("0xaAbbCC", true, true, ALICE, &sig));
+	assert!(!verify("0xaabbcc", true, true, BOB, &sig));
+
+	assert!(!verify("0xaabbcc", false, true, ALICE, &sig));
+}
+
+/// Test that sig/verify works with random bytes.
+#[test]
+fn sig_verify_stdin_non_utf8_work() {
+	use rand::RngCore;
+	let mut rng = rand::thread_rng();
+
+	for _ in 0..100 {
+		let mut raw = [0u8; 32];
+		rng.fill_bytes(&mut raw);
+		let sig = sign_raw(&raw, false, true);
+
+		assert!(verify_raw(&raw, false, true, ALICE, &sig));
+		assert!(!verify_raw(&raw, false, true, BOB, &sig));
+	}
+}
+
+/// Test that sig/verify works with invalid UTF-8 bytes.
+#[test]
+fn sig_verify_stdin_invalid_utf8_work() {
+	let raw = vec![192u8, 193];
+	assert!(String::from_utf8(raw.clone()).is_err(), "Must be invalid UTF-8");
+
+	let sig = sign_raw(&raw, false, true);
+
+	assert!(verify_raw(&raw, false, true, ALICE, &sig));
+	assert!(!verify_raw(&raw, false, true, BOB, &sig));
+}
diff --git a/substrate/client/cli/src/commands/utils.rs b/substrate/client/cli/src/commands/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ff159909b879c18f6f081021c4e97ed4e8417fdb
--- /dev/null
+++ b/substrate/client/cli/src/commands/utils.rs
@@ -0,0 +1,301 @@
+// 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/>.
+
+//! subcommand utilities
+use crate::{
+	error::{self, Error},
+	OutputType,
+};
+use serde_json::json;
+use sp_core::{
+	crypto::{
+		unwrap_or_default_ss58_version, ExposeSecret, SecretString, Ss58AddressFormat, Ss58Codec,
+		Zeroize,
+	},
+	hexdisplay::HexDisplay,
+	Pair,
+};
+use sp_runtime::{traits::IdentifyAccount, MultiSigner};
+use std::path::PathBuf;
+
+/// Public key type for Runtime
+pub type PublicFor<P> = <P as sp_core::Pair>::Public;
+/// Seed type for Runtime
+pub type SeedFor<P> = <P as sp_core::Pair>::Seed;
+
+/// helper method to fetch uri from `Option<String>` either as a file or read from stdin
+pub fn read_uri(uri: Option<&String>) -> error::Result<String> {
+	let uri = if let Some(uri) = uri {
+		let file = PathBuf::from(&uri);
+		if file.is_file() {
+			std::fs::read_to_string(uri)?.trim_end().to_owned()
+		} else {
+			uri.into()
+		}
+	} else {
+		rpassword::prompt_password("URI: ")?
+	};
+
+	Ok(uri)
+}
+
+/// Try to parse given `uri` and print relevant information.
+///
+/// 1. Try to construct the `Pair` while using `uri` as input for [`sp_core::Pair::from_phrase`].
+///
+/// 2. Try to construct the `Pair` while using `uri` as input for
+/// [`sp_core::Pair::from_string_with_seed`].
+///
+/// 3. Try to construct the `Pair::Public` while using `uri` as input for
+///    [`sp_core::crypto::Ss58Codec::from_string_with_version`].
+pub fn print_from_uri<Pair>(
+	uri: &str,
+	password: Option<SecretString>,
+	network_override: Option<Ss58AddressFormat>,
+	output: OutputType,
+) where
+	Pair: sp_core::Pair,
+	Pair::Public: Into<MultiSigner>,
+{
+	let password = password.as_ref().map(|s| s.expose_secret().as_str());
+	let network_id = String::from(unwrap_or_default_ss58_version(network_override));
+	if let Ok((pair, seed)) = Pair::from_phrase(uri, password) {
+		let public_key = pair.public();
+		let network_override = unwrap_or_default_ss58_version(network_override);
+
+		match output {
+			OutputType::Json => {
+				let json = json!({
+					"secretPhrase": uri,
+					"networkId": network_id,
+					"secretSeed": format_seed::<Pair>(seed),
+					"publicKey": format_public_key::<Pair>(public_key.clone()),
+					"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+					"accountId": format_account_id::<Pair>(public_key),
+					"ss58Address": pair.public().into().into_account().to_ss58check_with_version(network_override),
+				});
+				println!(
+					"{}",
+					serde_json::to_string_pretty(&json).expect("Json pretty print failed")
+				);
+			},
+			OutputType::Text => {
+				println!(
+					"Secret phrase:       {}\n  \
+					Network ID:        {}\n  \
+					Secret seed:       {}\n  \
+					Public key (hex):  {}\n  \
+					Account ID:        {}\n  \
+					Public key (SS58): {}\n  \
+					SS58 Address:      {}",
+					uri,
+					network_id,
+					format_seed::<Pair>(seed),
+					format_public_key::<Pair>(public_key.clone()),
+					format_account_id::<Pair>(public_key.clone()),
+					public_key.to_ss58check_with_version(network_override),
+					pair.public().into().into_account().to_ss58check_with_version(network_override),
+				);
+			},
+		}
+	} else if let Ok((pair, seed)) = Pair::from_string_with_seed(uri, password) {
+		let public_key = pair.public();
+		let network_override = unwrap_or_default_ss58_version(network_override);
+
+		match output {
+			OutputType::Json => {
+				let json = json!({
+					"secretKeyUri": uri,
+					"networkId": network_id,
+					"secretSeed": if let Some(seed) = seed { format_seed::<Pair>(seed) } else { "n/a".into() },
+					"publicKey": format_public_key::<Pair>(public_key.clone()),
+					"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+					"accountId": format_account_id::<Pair>(public_key),
+					"ss58Address": pair.public().into().into_account().to_ss58check_with_version(network_override),
+				});
+				println!(
+					"{}",
+					serde_json::to_string_pretty(&json).expect("Json pretty print failed")
+				);
+			},
+			OutputType::Text => {
+				println!(
+					"Secret Key URI `{}` is account:\n  \
+					Network ID:        {} \n \
+					Secret seed:       {}\n  \
+					Public key (hex):  {}\n  \
+					Account ID:        {}\n  \
+					Public key (SS58): {}\n  \
+					SS58 Address:      {}",
+					uri,
+					network_id,
+					if let Some(seed) = seed { format_seed::<Pair>(seed) } else { "n/a".into() },
+					format_public_key::<Pair>(public_key.clone()),
+					format_account_id::<Pair>(public_key.clone()),
+					public_key.to_ss58check_with_version(network_override),
+					pair.public().into().into_account().to_ss58check_with_version(network_override),
+				);
+			},
+		}
+	} else if let Ok((public_key, network)) = Pair::Public::from_string_with_version(uri) {
+		let network_override = network_override.unwrap_or(network);
+
+		match output {
+			OutputType::Json => {
+				let json = json!({
+					"publicKeyUri": uri,
+					"networkId": String::from(network_override),
+					"publicKey": format_public_key::<Pair>(public_key.clone()),
+					"accountId": format_account_id::<Pair>(public_key.clone()),
+					"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+					"ss58Address": public_key.to_ss58check_with_version(network_override),
+				});
+
+				println!(
+					"{}",
+					serde_json::to_string_pretty(&json).expect("Json pretty print failed")
+				);
+			},
+			OutputType::Text => {
+				println!(
+					"Public Key URI `{}` is account:\n  \
+					 Network ID/Version: {}\n  \
+					 Public key (hex):   {}\n  \
+					 Account ID:         {}\n  \
+					 Public key (SS58):  {}\n  \
+					 SS58 Address:       {}",
+					uri,
+					String::from(network_override),
+					format_public_key::<Pair>(public_key.clone()),
+					format_account_id::<Pair>(public_key.clone()),
+					public_key.to_ss58check_with_version(network_override),
+					public_key.to_ss58check_with_version(network_override),
+				);
+			},
+		}
+	} else {
+		println!("Invalid phrase/URI given");
+	}
+}
+
+/// Try to parse given `public` as hex encoded public key and print relevant information.
+pub fn print_from_public<Pair>(
+	public_str: &str,
+	network_override: Option<Ss58AddressFormat>,
+	output: OutputType,
+) -> Result<(), Error>
+where
+	Pair: sp_core::Pair,
+	Pair::Public: Into<MultiSigner>,
+{
+	let public = array_bytes::hex2bytes(public_str)?;
+
+	let public_key = Pair::Public::try_from(&public)
+		.map_err(|_| "Failed to construct public key from given hex")?;
+
+	let network_override = unwrap_or_default_ss58_version(network_override);
+
+	match output {
+		OutputType::Json => {
+			let json = json!({
+				"networkId": String::from(network_override),
+				"publicKey": format_public_key::<Pair>(public_key.clone()),
+				"accountId": format_account_id::<Pair>(public_key.clone()),
+				"ss58PublicKey": public_key.to_ss58check_with_version(network_override),
+				"ss58Address": public_key.to_ss58check_with_version(network_override),
+			});
+
+			println!("{}", serde_json::to_string_pretty(&json).expect("Json pretty print failed"));
+		},
+		OutputType::Text => {
+			println!(
+				"Network ID/Version: {}\n  \
+				 Public key (hex):   {}\n  \
+				 Account ID:         {}\n  \
+				 Public key (SS58):  {}\n  \
+				 SS58 Address:       {}",
+				String::from(network_override),
+				format_public_key::<Pair>(public_key.clone()),
+				format_account_id::<Pair>(public_key.clone()),
+				public_key.to_ss58check_with_version(network_override),
+				public_key.to_ss58check_with_version(network_override),
+			);
+		},
+	}
+
+	Ok(())
+}
+
+/// generate a pair from suri
+pub fn pair_from_suri<P: Pair>(suri: &str, password: Option<SecretString>) -> Result<P, Error> {
+	let result = if let Some(pass) = password {
+		let mut pass_str = pass.expose_secret().clone();
+		let pair = P::from_string(suri, Some(&pass_str));
+		pass_str.zeroize();
+		pair
+	} else {
+		P::from_string(suri, None)
+	};
+
+	Ok(result.map_err(|err| format!("Invalid phrase {:?}", err))?)
+}
+
+/// formats seed as hex
+pub fn format_seed<P: sp_core::Pair>(seed: SeedFor<P>) -> String {
+	format!("0x{}", HexDisplay::from(&seed.as_ref()))
+}
+
+/// formats public key as hex
+fn format_public_key<P: sp_core::Pair>(public_key: PublicFor<P>) -> String {
+	format!("0x{}", HexDisplay::from(&public_key.as_ref()))
+}
+
+/// formats public key as accountId as hex
+fn format_account_id<P: sp_core::Pair>(public_key: PublicFor<P>) -> String
+where
+	PublicFor<P>: Into<MultiSigner>,
+{
+	format!("0x{}", HexDisplay::from(&public_key.into().into_account().as_ref()))
+}
+
+/// Allows for calling $method with appropriate crypto impl.
+#[macro_export]
+macro_rules! with_crypto_scheme {
+	(
+		$scheme:expr,
+		$method:ident ( $($params:expr),* $(,)?) $(,)?
+	) => {
+		$crate::with_crypto_scheme!($scheme, $method<>($($params),*))
+	};
+	(
+		$scheme:expr,
+		$method:ident<$($generics:ty),*>( $( $params:expr ),* $(,)?) $(,)?
+	) => {
+		match $scheme {
+			$crate::CryptoScheme::Ecdsa => {
+				$method::<sp_core::ecdsa::Pair, $($generics),*>($($params),*)
+			}
+			$crate::CryptoScheme::Sr25519 => {
+				$method::<sp_core::sr25519::Pair, $($generics),*>($($params),*)
+			}
+			$crate::CryptoScheme::Ed25519 => {
+				$method::<sp_core::ed25519::Pair, $($generics),*>($($params),*)
+			}
+		}
+	};
+}
diff --git a/substrate/client/cli/src/commands/vanity.rs b/substrate/client/cli/src/commands/vanity.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ce75161329893d281868c659bbc6656aa9ece194
--- /dev/null
+++ b/substrate/client/cli/src/commands/vanity.rs
@@ -0,0 +1,240 @@
+// 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/>.
+
+//! implementation of the `vanity` subcommand
+
+use crate::{
+	error, utils, with_crypto_scheme, CryptoSchemeFlag, NetworkSchemeFlag, OutputTypeFlag,
+};
+use clap::Parser;
+use rand::{rngs::OsRng, RngCore};
+use sp_core::crypto::{unwrap_or_default_ss58_version, Ss58AddressFormat, Ss58Codec};
+use sp_runtime::traits::IdentifyAccount;
+use utils::print_from_uri;
+
+/// The `vanity` command
+#[derive(Debug, Clone, Parser)]
+#[command(name = "vanity", about = "Generate a seed that provides a vanity address")]
+pub struct VanityCmd {
+	/// Desired pattern
+	#[arg(long, value_parser = assert_non_empty_string)]
+	pattern: String,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	network_scheme: NetworkSchemeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	output_scheme: OutputTypeFlag,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	crypto_scheme: CryptoSchemeFlag,
+}
+
+impl VanityCmd {
+	/// Run the command
+	pub fn run(&self) -> error::Result<()> {
+		let formated_seed = with_crypto_scheme!(
+			self.crypto_scheme.scheme,
+			generate_key(
+				&self.pattern,
+				unwrap_or_default_ss58_version(self.network_scheme.network)
+			),
+		)?;
+
+		with_crypto_scheme!(
+			self.crypto_scheme.scheme,
+			print_from_uri(
+				&formated_seed,
+				None,
+				self.network_scheme.network,
+				self.output_scheme.output_type,
+			),
+		);
+		Ok(())
+	}
+}
+
+/// genertae a key based on given pattern
+fn generate_key<Pair>(
+	desired: &str,
+	network_override: Ss58AddressFormat,
+) -> Result<String, &'static str>
+where
+	Pair: sp_core::Pair,
+	Pair::Public: IdentifyAccount,
+	<Pair::Public as IdentifyAccount>::AccountId: Ss58Codec,
+{
+	println!("Generating key containing pattern '{}'", desired);
+
+	let top = 45 + (desired.len() * 48);
+	let mut best = 0;
+	let mut seed = Pair::Seed::default();
+	let mut done = 0;
+
+	loop {
+		if done % 100000 == 0 {
+			OsRng.fill_bytes(seed.as_mut());
+		} else {
+			next_seed(seed.as_mut());
+		}
+
+		let p = Pair::from_seed(&seed);
+		let ss58 = p.public().into_account().to_ss58check_with_version(network_override);
+		let score = calculate_score(desired, &ss58);
+		if score > best || desired.len() < 2 {
+			best = score;
+			if best >= top {
+				println!("best: {} == top: {}", best, top);
+				return Ok(utils::format_seed::<Pair>(seed.clone()))
+			}
+		}
+		done += 1;
+
+		if done % good_waypoint(done) == 0 {
+			println!("{} keys searched; best is {}/{} complete", done, best, top);
+		}
+	}
+}
+
+fn good_waypoint(done: u64) -> u64 {
+	match done {
+		0..=1_000_000 => 100_000,
+		1_000_001..=10_000_000 => 1_000_000,
+		10_000_001..=100_000_000 => 10_000_000,
+		100_000_001.. => 100_000_000,
+	}
+}
+
+fn next_seed(seed: &mut [u8]) {
+	for s in seed {
+		match s {
+			255 => {
+				*s = 0;
+			},
+			_ => {
+				*s += 1;
+				break
+			},
+		}
+	}
+}
+
+/// Calculate the score of a key based on the desired
+/// input.
+fn calculate_score(_desired: &str, key: &str) -> usize {
+	for truncate in 0.._desired.len() {
+		let snip_size = _desired.len() - truncate;
+		let truncated = &_desired[0..snip_size];
+		if let Some(pos) = key.find(truncated) {
+			return (47 - pos) + (snip_size * 48)
+		}
+	}
+	0
+}
+
+/// checks that `pattern` is non-empty
+fn assert_non_empty_string(pattern: &str) -> Result<String, &'static str> {
+	if pattern.is_empty() {
+		Err("Pattern must not be empty")
+	} else {
+		Ok(pattern.to_string())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{
+		crypto::{default_ss58_version, Ss58AddressFormatRegistry, Ss58Codec},
+		sr25519, Pair,
+	};
+	#[cfg(feature = "bench")]
+	use test::Bencher;
+
+	#[test]
+	fn vanity() {
+		let vanity = VanityCmd::parse_from(&["vanity", "--pattern", "j"]);
+		assert!(vanity.run().is_ok());
+	}
+
+	#[test]
+	fn test_generation_with_single_char() {
+		let seed = generate_key::<sr25519::Pair>("ab", default_ss58_version()).unwrap();
+		assert!(sr25519::Pair::from_seed_slice(&array_bytes::hex2bytes_unchecked(&seed))
+			.unwrap()
+			.public()
+			.to_ss58check()
+			.contains("ab"));
+	}
+
+	#[test]
+	fn generate_key_respects_network_override() {
+		let seed =
+			generate_key::<sr25519::Pair>("ab", Ss58AddressFormatRegistry::PolkadotAccount.into())
+				.unwrap();
+		assert!(sr25519::Pair::from_seed_slice(&array_bytes::hex2bytes_unchecked(&seed))
+			.unwrap()
+			.public()
+			.to_ss58check_with_version(Ss58AddressFormatRegistry::PolkadotAccount.into())
+			.contains("ab"));
+	}
+
+	#[test]
+	fn test_score_1_char_100() {
+		let score = calculate_score("j", "5jolkadotwHY5k9GpdTgpqs9xjuNvtv8EcwCFpEeyEf3KHim");
+		assert_eq!(score, 94);
+	}
+
+	#[test]
+	fn test_score_100() {
+		let score = calculate_score("Polkadot", "5PolkadotwHY5k9GpdTgpqs9xjuNvtv8EcwCFpEeyEf3KHim");
+		assert_eq!(score, 430);
+	}
+
+	#[test]
+	fn test_score_50_2() {
+		// 50% for the position + 50% for the size
+		assert_eq!(
+			calculate_score("Polkadot", "5PolkXXXXwHY5k9GpdTgpqs9xjuNvtv8EcwCFpEeyEf3KHim"),
+			238
+		);
+	}
+
+	#[test]
+	fn test_score_0() {
+		assert_eq!(
+			calculate_score("Polkadot", "5GUWv4bLCchGUHJrzULXnh4JgXsMpTKRnjuXTY7Qo1Kh9uYK"),
+			0
+		);
+	}
+
+	#[cfg(feature = "bench")]
+	#[bench]
+	fn bench_paranoiac(b: &mut Bencher) {
+		b.iter(|| generate_key("polk"));
+	}
+
+	#[cfg(feature = "bench")]
+	#[bench]
+	fn bench_not_paranoiac(b: &mut Bencher) {
+		b.iter(|| generate_key("polk"));
+	}
+}
diff --git a/substrate/client/cli/src/commands/verify.rs b/substrate/client/cli/src/commands/verify.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c6d280de3fcfdc0226099066f4b3ef21af4612e4
--- /dev/null
+++ b/substrate/client/cli/src/commands/verify.rs
@@ -0,0 +1,137 @@
+// 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/>.
+
+//! implementation of the `verify` subcommand
+
+use crate::{error, params::MessageParams, utils, with_crypto_scheme, CryptoSchemeFlag};
+use clap::Parser;
+use sp_core::crypto::{ByteArray, Ss58Codec};
+use std::io::BufRead;
+
+/// The `verify` command
+#[derive(Debug, Clone, Parser)]
+#[command(
+	name = "verify",
+	about = "Verify a signature for a message, provided on STDIN, with a given (public or secret) key"
+)]
+pub struct VerifyCmd {
+	/// Signature, hex-encoded.
+	sig: String,
+
+	/// The public or secret key URI.
+	/// If the value is a file, the file content is used as URI.
+	/// If not given, you will be prompted for the URI.
+	uri: Option<String>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub message_params: MessageParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub crypto_scheme: CryptoSchemeFlag,
+}
+
+impl VerifyCmd {
+	/// Run the command
+	pub fn run(&self) -> error::Result<()> {
+		self.verify(|| std::io::stdin().lock())
+	}
+
+	/// Verify a signature for a message.
+	///
+	/// The message can either be provided as immediate argument via CLI or otherwise read from the
+	/// reader created by `create_reader`. The reader will only be created in case that the message
+	/// is not passed as immediate.
+	pub(crate) fn verify<F, R>(&self, create_reader: F) -> error::Result<()>
+	where
+		R: BufRead,
+		F: FnOnce() -> R,
+	{
+		let message = self.message_params.message_from(create_reader)?;
+		let sig_data = array_bytes::hex2bytes(&self.sig)?;
+		let uri = utils::read_uri(self.uri.as_ref())?;
+		let uri = if let Some(uri) = uri.strip_prefix("0x") { uri } else { &uri };
+
+		with_crypto_scheme!(self.crypto_scheme.scheme, verify(sig_data, message, uri))
+	}
+}
+
+fn verify<Pair>(sig_data: Vec<u8>, message: Vec<u8>, uri: &str) -> error::Result<()>
+where
+	Pair: sp_core::Pair,
+	Pair::Signature: for<'a> TryFrom<&'a [u8]>,
+{
+	let signature =
+		Pair::Signature::try_from(&sig_data).map_err(|_| error::Error::SignatureFormatInvalid)?;
+
+	let pubkey = if let Ok(pubkey_vec) = array_bytes::hex2bytes(uri) {
+		Pair::Public::from_slice(pubkey_vec.as_slice())
+			.map_err(|_| error::Error::KeyFormatInvalid)?
+	} else {
+		Pair::Public::from_string(uri)?
+	};
+
+	if Pair::verify(&signature, &message, &pubkey) {
+		println!("Signature verifies correctly.");
+	} else {
+		return Err(error::Error::SignatureInvalid)
+	}
+
+	Ok(())
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	const ALICE: &str = "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY";
+	const SIG1: &str = "0x4eb25a2285a82374888880af0024eb30c3a21ce086eae3862888d345af607f0ad6fb081312f11730932564f24a9f8ebcee2d46861413ae61307eca58db2c3e81";
+	const SIG2: &str = "0x026342225155056ea797118c1c8c8b3cc002aa2020c36f4217fa3c302783a572ad3dcd38c231cbaf86cadb93984d329c963ceac0685cc1ee4c1ed50fa443a68f";
+
+	// Verify work with `--message` argument.
+	#[test]
+	fn verify_immediate() {
+		let cmd = VerifyCmd::parse_from(&["verify", SIG1, ALICE, "--message", "test message"]);
+		assert!(cmd.run().is_ok(), "Alice' signature should verify");
+	}
+
+	// Verify work without `--message` argument.
+	#[test]
+	fn verify_stdin() {
+		let cmd = VerifyCmd::parse_from(&["verify", SIG1, ALICE]);
+		let message = "test message";
+		assert!(cmd.verify(|| message.as_bytes()).is_ok(), "Alice' signature should verify");
+	}
+
+	// Verify work with `--message` argument for hex message.
+	#[test]
+	fn verify_immediate_hex() {
+		let cmd = VerifyCmd::parse_from(&["verify", SIG2, ALICE, "--message", "0xaabbcc", "--hex"]);
+		assert!(cmd.run().is_ok(), "Alice' signature should verify");
+	}
+
+	// Verify work without `--message` argument for hex message.
+	#[test]
+	fn verify_stdin_hex() {
+		let cmd = VerifyCmd::parse_from(&["verify", SIG2, ALICE, "--hex"]);
+		assert!(cmd.verify(|| "0xaabbcc".as_bytes()).is_ok());
+		assert!(cmd.verify(|| "aabbcc".as_bytes()).is_ok());
+		assert!(cmd.verify(|| "0xaABBcC".as_bytes()).is_ok());
+	}
+}
diff --git a/substrate/client/cli/src/config.rs b/substrate/client/cli/src/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d218da6aa89891d3d51c28882978c0b232a8d53
--- /dev/null
+++ b/substrate/client/cli/src/config.rs
@@ -0,0 +1,634 @@
+// 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/>.
+
+//! Configuration trait for a CLI based on substrate
+
+use crate::{
+	arg_enums::Database, error::Result, DatabaseParams, ImportParams, KeystoreParams,
+	NetworkParams, NodeKeyParams, OffchainWorkerParams, PruningParams, SharedParams, SubstrateCli,
+};
+use log::warn;
+use names::{Generator, Name};
+use sc_service::{
+	config::{
+		BasePath, Configuration, DatabaseSource, KeystoreConfig, NetworkConfiguration,
+		NodeKeyConfig, OffchainWorkerConfig, PrometheusConfig, PruningMode, Role, RpcMethods,
+		TelemetryEndpoints, TransactionPoolOptions, WasmExecutionMethod,
+	},
+	BlocksPruning, ChainSpec, TracingReceiver,
+};
+use sc_tracing::logging::LoggerBuilder;
+use std::{net::SocketAddr, path::PathBuf};
+
+/// The maximum number of characters for a node name.
+pub(crate) const NODE_NAME_MAX_LENGTH: usize = 64;
+
+/// Default sub directory to store network config.
+pub(crate) const DEFAULT_NETWORK_CONFIG_PATH: &str = "network";
+
+/// The recommended open file descriptor limit to be configured for the process.
+const RECOMMENDED_OPEN_FILE_DESCRIPTOR_LIMIT: u64 = 10_000;
+
+/// The default port.
+pub const RPC_DEFAULT_PORT: u16 = 9944;
+/// The default max number of subscriptions per connection.
+pub const RPC_DEFAULT_MAX_SUBS_PER_CONN: u32 = 1024;
+/// The default max request size in MB.
+pub const RPC_DEFAULT_MAX_REQUEST_SIZE_MB: u32 = 15;
+/// The default max response size in MB.
+pub const RPC_DEFAULT_MAX_RESPONSE_SIZE_MB: u32 = 15;
+/// The default number of connection..
+pub const RPC_DEFAULT_MAX_CONNECTIONS: u32 = 100;
+
+/// Default configuration values used by Substrate
+///
+/// These values will be used by [`CliConfiguration`] to set
+/// default values for e.g. the listen port or the RPC port.
+pub trait DefaultConfigurationValues {
+	/// The port Substrate should listen on for p2p connections.
+	///
+	/// By default this is `30333`.
+	fn p2p_listen_port() -> u16 {
+		30333
+	}
+
+	/// The port Substrate should listen on for JSON-RPC connections.
+	///
+	/// By default this is `9944`.
+	fn rpc_listen_port() -> u16 {
+		RPC_DEFAULT_PORT
+	}
+
+	/// The port Substrate should listen on for prometheus connections.
+	///
+	/// By default this is `9615`.
+	fn prometheus_listen_port() -> u16 {
+		9615
+	}
+}
+
+impl DefaultConfigurationValues for () {}
+
+/// A trait that allows converting an object to a Configuration
+pub trait CliConfiguration<DCV: DefaultConfigurationValues = ()>: Sized {
+	/// Get the SharedParams for this object
+	fn shared_params(&self) -> &SharedParams;
+
+	/// Get the ImportParams for this object
+	fn import_params(&self) -> Option<&ImportParams> {
+		None
+	}
+
+	/// Get the PruningParams for this object
+	fn pruning_params(&self) -> Option<&PruningParams> {
+		self.import_params().map(|x| &x.pruning_params)
+	}
+
+	/// Get the KeystoreParams for this object
+	fn keystore_params(&self) -> Option<&KeystoreParams> {
+		None
+	}
+
+	/// Get the NetworkParams for this object
+	fn network_params(&self) -> Option<&NetworkParams> {
+		None
+	}
+
+	/// Get a reference to `OffchainWorkerParams` for this object.
+	fn offchain_worker_params(&self) -> Option<&OffchainWorkerParams> {
+		None
+	}
+
+	/// Get the NodeKeyParams for this object
+	fn node_key_params(&self) -> Option<&NodeKeyParams> {
+		self.network_params().map(|x| &x.node_key_params)
+	}
+
+	/// Get the DatabaseParams for this object
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		self.import_params().map(|x| &x.database_params)
+	}
+
+	/// Get the base path of the configuration (if any)
+	///
+	/// By default this is retrieved from `SharedParams`.
+	fn base_path(&self) -> Result<Option<BasePath>> {
+		self.shared_params().base_path()
+	}
+
+	/// Returns `true` if the node is for development or not
+	///
+	/// By default this is retrieved from `SharedParams`.
+	fn is_dev(&self) -> Result<bool> {
+		Ok(self.shared_params().is_dev())
+	}
+
+	/// Gets the role
+	///
+	/// By default this is `Role::Full`.
+	fn role(&self, _is_dev: bool) -> Result<Role> {
+		Ok(Role::Full)
+	}
+
+	/// Get the transaction pool options
+	///
+	/// By default this is `TransactionPoolOptions::default()`.
+	fn transaction_pool(&self, _is_dev: bool) -> Result<TransactionPoolOptions> {
+		Ok(Default::default())
+	}
+
+	/// Get the network configuration
+	///
+	/// By default this is retrieved from `NetworkParams` if it is available otherwise it creates
+	/// a default `NetworkConfiguration` based on `node_name`, `client_id`, `node_key` and
+	/// `net_config_dir`.
+	fn network_config(
+		&self,
+		chain_spec: &Box<dyn ChainSpec>,
+		is_dev: bool,
+		is_validator: bool,
+		net_config_dir: PathBuf,
+		client_id: &str,
+		node_name: &str,
+		node_key: NodeKeyConfig,
+		default_listen_port: u16,
+	) -> Result<NetworkConfiguration> {
+		Ok(if let Some(network_params) = self.network_params() {
+			network_params.network_config(
+				chain_spec,
+				is_dev,
+				is_validator,
+				Some(net_config_dir),
+				client_id,
+				node_name,
+				node_key,
+				default_listen_port,
+			)
+		} else {
+			NetworkConfiguration::new(node_name, client_id, node_key, Some(net_config_dir))
+		})
+	}
+
+	/// Get the keystore configuration.
+	///
+	/// By default this is retrieved from `KeystoreParams` if it is available. Otherwise it uses
+	/// `KeystoreConfig::InMemory`.
+	fn keystore_config(&self, config_dir: &PathBuf) -> Result<KeystoreConfig> {
+		self.keystore_params()
+			.map(|x| x.keystore_config(config_dir))
+			.unwrap_or_else(|| Ok(KeystoreConfig::InMemory))
+	}
+
+	/// Get the database cache size.
+	///
+	/// By default this is retrieved from `DatabaseParams` if it is available. Otherwise its `None`.
+	fn database_cache_size(&self) -> Result<Option<usize>> {
+		Ok(self.database_params().map(|x| x.database_cache_size()).unwrap_or_default())
+	}
+
+	/// Get the database backend variant.
+	///
+	/// By default this is retrieved from `DatabaseParams` if it is available. Otherwise its `None`.
+	fn database(&self) -> Result<Option<Database>> {
+		Ok(self.database_params().and_then(|x| x.database()))
+	}
+
+	/// Get the database configuration object for the parameters provided
+	fn database_config(
+		&self,
+		base_path: &PathBuf,
+		cache_size: usize,
+		database: Database,
+	) -> Result<DatabaseSource> {
+		let role_dir = "full";
+		let rocksdb_path = base_path.join("db").join(role_dir);
+		let paritydb_path = base_path.join("paritydb").join(role_dir);
+		Ok(match database {
+			#[cfg(feature = "rocksdb")]
+			Database::RocksDb => DatabaseSource::RocksDb { path: rocksdb_path, cache_size },
+			Database::ParityDb => DatabaseSource::ParityDb { path: paritydb_path },
+			Database::ParityDbDeprecated => {
+				eprintln!(
+					"WARNING: \"paritydb-experimental\" database setting is deprecated and will be removed in future releases. \
+				Please update your setup to use the new value: \"paritydb\"."
+				);
+				DatabaseSource::ParityDb { path: paritydb_path }
+			},
+			Database::Auto => DatabaseSource::Auto { paritydb_path, rocksdb_path, cache_size },
+		})
+	}
+
+	/// Get the trie cache maximum size.
+	///
+	/// By default this is retrieved from `ImportParams` if it is available. Otherwise its `0`.
+	/// If `None` is returned the trie cache is disabled.
+	fn trie_cache_maximum_size(&self) -> Result<Option<usize>> {
+		Ok(self.import_params().map(|x| x.trie_cache_maximum_size()).unwrap_or_default())
+	}
+
+	/// Get the state pruning mode.
+	///
+	/// By default this is retrieved from `PruningMode` if it is available. Otherwise its
+	/// `PruningMode::default()`.
+	fn state_pruning(&self) -> Result<Option<PruningMode>> {
+		self.pruning_params()
+			.map(|x| x.state_pruning())
+			.unwrap_or_else(|| Ok(Default::default()))
+	}
+
+	/// Get the block pruning mode.
+	///
+	/// By default this is retrieved from `block_pruning` if it is available. Otherwise its
+	/// `BlocksPruning::KeepFinalized`.
+	fn blocks_pruning(&self) -> Result<BlocksPruning> {
+		self.pruning_params()
+			.map(|x| x.blocks_pruning())
+			.unwrap_or_else(|| Ok(BlocksPruning::KeepFinalized))
+	}
+
+	/// Get the chain ID (string).
+	///
+	/// By default this is retrieved from `SharedParams`.
+	fn chain_id(&self, is_dev: bool) -> Result<String> {
+		Ok(self.shared_params().chain_id(is_dev))
+	}
+
+	/// Get the name of the node.
+	///
+	/// By default a random name is generated.
+	fn node_name(&self) -> Result<String> {
+		Ok(generate_node_name())
+	}
+
+	/// Get the WASM execution method.
+	///
+	/// By default this is retrieved from `ImportParams` if it is available. Otherwise its
+	/// `WasmExecutionMethod::default()`.
+	fn wasm_method(&self) -> Result<WasmExecutionMethod> {
+		Ok(self.import_params().map(|x| x.wasm_method()).unwrap_or_default())
+	}
+
+	/// Get the path where WASM overrides live.
+	///
+	/// By default this is `None`.
+	fn wasm_runtime_overrides(&self) -> Option<PathBuf> {
+		self.import_params().map(|x| x.wasm_runtime_overrides()).unwrap_or_default()
+	}
+
+	/// Get the RPC address.
+	fn rpc_addr(&self, _default_listen_port: u16) -> Result<Option<SocketAddr>> {
+		Ok(None)
+	}
+
+	/// Returns the RPC method set to expose.
+	///
+	/// By default this is `RpcMethods::Auto` (unsafe RPCs are denied iff
+	/// `rpc_external` returns true, respectively).
+	fn rpc_methods(&self) -> Result<RpcMethods> {
+		Ok(Default::default())
+	}
+
+	/// Get the maximum number of RPC server connections.
+	fn rpc_max_connections(&self) -> Result<u32> {
+		Ok(RPC_DEFAULT_MAX_CONNECTIONS)
+	}
+
+	/// Get the RPC cors (`None` if disabled)
+	///
+	/// By default this is `Some(Vec::new())`.
+	fn rpc_cors(&self, _is_dev: bool) -> Result<Option<Vec<String>>> {
+		Ok(Some(Vec::new()))
+	}
+
+	/// Get maximum RPC request payload size.
+	fn rpc_max_request_size(&self) -> Result<u32> {
+		Ok(RPC_DEFAULT_MAX_REQUEST_SIZE_MB)
+	}
+
+	/// Get maximum RPC response payload size.
+	fn rpc_max_response_size(&self) -> Result<u32> {
+		Ok(RPC_DEFAULT_MAX_RESPONSE_SIZE_MB)
+	}
+
+	/// Get maximum number of subscriptions per connection.
+	fn rpc_max_subscriptions_per_connection(&self) -> Result<u32> {
+		Ok(RPC_DEFAULT_MAX_SUBS_PER_CONN)
+	}
+
+	/// Get the prometheus configuration (`None` if disabled)
+	///
+	/// By default this is `None`.
+	fn prometheus_config(
+		&self,
+		_default_listen_port: u16,
+		_chain_spec: &Box<dyn ChainSpec>,
+	) -> Result<Option<PrometheusConfig>> {
+		Ok(None)
+	}
+
+	/// Get the telemetry endpoints (if any)
+	///
+	/// By default this is retrieved from the chain spec loaded by `load_spec`.
+	fn telemetry_endpoints(
+		&self,
+		chain_spec: &Box<dyn ChainSpec>,
+	) -> Result<Option<TelemetryEndpoints>> {
+		Ok(chain_spec.telemetry_endpoints().clone())
+	}
+
+	/// Get the default value for heap pages
+	///
+	/// By default this is `None`.
+	fn default_heap_pages(&self) -> Result<Option<u64>> {
+		Ok(None)
+	}
+
+	/// Returns an offchain worker config wrapped in `Ok(_)`
+	///
+	/// By default offchain workers are disabled.
+	fn offchain_worker(&self, role: &Role) -> Result<OffchainWorkerConfig> {
+		self.offchain_worker_params()
+			.map(|x| x.offchain_worker(role))
+			.unwrap_or_else(|| Ok(OffchainWorkerConfig::default()))
+	}
+
+	/// Returns `Ok(true)` if authoring should be forced
+	///
+	/// By default this is `false`.
+	fn force_authoring(&self) -> Result<bool> {
+		Ok(Default::default())
+	}
+
+	/// Returns `Ok(true)` if grandpa should be disabled
+	///
+	/// By default this is `false`.
+	fn disable_grandpa(&self) -> Result<bool> {
+		Ok(Default::default())
+	}
+
+	/// Get the development key seed from the current object
+	///
+	/// By default this is `None`.
+	fn dev_key_seed(&self, _is_dev: bool) -> Result<Option<String>> {
+		Ok(Default::default())
+	}
+
+	/// Get the tracing targets from the current object (if any)
+	///
+	/// By default this is retrieved from [`SharedParams`] if it is available. Otherwise its
+	/// `None`.
+	fn tracing_targets(&self) -> Result<Option<String>> {
+		Ok(self.shared_params().tracing_targets())
+	}
+
+	/// Get the TracingReceiver value from the current object
+	///
+	/// By default this is retrieved from [`SharedParams`] if it is available. Otherwise its
+	/// `TracingReceiver::default()`.
+	fn tracing_receiver(&self) -> Result<TracingReceiver> {
+		Ok(self.shared_params().tracing_receiver())
+	}
+
+	/// Get the node key from the current object
+	///
+	/// By default this is retrieved from `NodeKeyParams` if it is available. Otherwise its
+	/// `NodeKeyConfig::default()`.
+	fn node_key(&self, net_config_dir: &PathBuf) -> Result<NodeKeyConfig> {
+		self.node_key_params()
+			.map(|x| x.node_key(net_config_dir))
+			.unwrap_or_else(|| Ok(Default::default()))
+	}
+
+	/// Get maximum runtime instances
+	///
+	/// By default this is `None`.
+	fn max_runtime_instances(&self) -> Result<Option<usize>> {
+		Ok(Default::default())
+	}
+
+	/// Get maximum different runtimes in cache
+	///
+	/// By default this is `2`.
+	fn runtime_cache_size(&self) -> Result<u8> {
+		Ok(2)
+	}
+
+	/// Activate or not the automatic announcing of blocks after import
+	///
+	/// By default this is `false`.
+	fn announce_block(&self) -> Result<bool> {
+		Ok(true)
+	}
+
+	/// Create a Configuration object from the current object
+	fn create_configuration<C: SubstrateCli>(
+		&self,
+		cli: &C,
+		tokio_handle: tokio::runtime::Handle,
+	) -> Result<Configuration> {
+		let is_dev = self.is_dev()?;
+		let chain_id = self.chain_id(is_dev)?;
+		let chain_spec = cli.load_spec(&chain_id)?;
+		let base_path = self
+			.base_path()?
+			.unwrap_or_else(|| BasePath::from_project("", "", &C::executable_name()));
+		let config_dir = base_path.config_dir(chain_spec.id());
+		let net_config_dir = config_dir.join(DEFAULT_NETWORK_CONFIG_PATH);
+		let client_id = C::client_id();
+		let database_cache_size = self.database_cache_size()?.unwrap_or(1024);
+		let database = self.database()?.unwrap_or(
+			#[cfg(feature = "rocksdb")]
+			{
+				Database::RocksDb
+			},
+			#[cfg(not(feature = "rocksdb"))]
+			{
+				Database::ParityDb
+			},
+		);
+		let node_key = self.node_key(&net_config_dir)?;
+		let role = self.role(is_dev)?;
+		let max_runtime_instances = self.max_runtime_instances()?.unwrap_or(8);
+		let is_validator = role.is_authority();
+		let keystore = self.keystore_config(&config_dir)?;
+		let telemetry_endpoints = self.telemetry_endpoints(&chain_spec)?;
+		let runtime_cache_size = self.runtime_cache_size()?;
+
+		Ok(Configuration {
+			impl_name: C::impl_name(),
+			impl_version: C::impl_version(),
+			tokio_handle,
+			transaction_pool: self.transaction_pool(is_dev)?,
+			network: self.network_config(
+				&chain_spec,
+				is_dev,
+				is_validator,
+				net_config_dir,
+				client_id.as_str(),
+				self.node_name()?.as_str(),
+				node_key,
+				DCV::p2p_listen_port(),
+			)?,
+			keystore,
+			database: self.database_config(&config_dir, database_cache_size, database)?,
+			data_path: config_dir,
+			trie_cache_maximum_size: self.trie_cache_maximum_size()?,
+			state_pruning: self.state_pruning()?,
+			blocks_pruning: self.blocks_pruning()?,
+			wasm_method: self.wasm_method()?,
+			wasm_runtime_overrides: self.wasm_runtime_overrides(),
+			rpc_addr: self.rpc_addr(DCV::rpc_listen_port())?,
+			rpc_methods: self.rpc_methods()?,
+			rpc_max_connections: self.rpc_max_connections()?,
+			rpc_cors: self.rpc_cors(is_dev)?,
+			rpc_max_request_size: self.rpc_max_request_size()?,
+			rpc_max_response_size: self.rpc_max_response_size()?,
+			rpc_id_provider: None,
+			rpc_max_subs_per_conn: self.rpc_max_subscriptions_per_connection()?,
+			rpc_port: DCV::rpc_listen_port(),
+			prometheus_config: self
+				.prometheus_config(DCV::prometheus_listen_port(), &chain_spec)?,
+			telemetry_endpoints,
+			default_heap_pages: self.default_heap_pages()?,
+			offchain_worker: self.offchain_worker(&role)?,
+			force_authoring: self.force_authoring()?,
+			disable_grandpa: self.disable_grandpa()?,
+			dev_key_seed: self.dev_key_seed(is_dev)?,
+			tracing_targets: self.tracing_targets()?,
+			tracing_receiver: self.tracing_receiver()?,
+			chain_spec,
+			max_runtime_instances,
+			announce_block: self.announce_block()?,
+			role,
+			base_path,
+			informant_output_format: Default::default(),
+			runtime_cache_size,
+		})
+	}
+
+	/// Get the filters for the logging.
+	///
+	/// This should be a list of comma-separated values.
+	/// Example: `foo=trace,bar=debug,baz=info`
+	///
+	/// By default this is retrieved from `SharedParams`.
+	fn log_filters(&self) -> Result<String> {
+		Ok(self.shared_params().log_filters().join(","))
+	}
+
+	/// Should the detailed log output be enabled.
+	fn detailed_log_output(&self) -> Result<bool> {
+		Ok(self.shared_params().detailed_log_output())
+	}
+
+	/// Is log reloading enabled?
+	fn enable_log_reloading(&self) -> Result<bool> {
+		Ok(self.shared_params().enable_log_reloading())
+	}
+
+	/// Should the log color output be disabled?
+	fn disable_log_color(&self) -> Result<bool> {
+		Ok(self.shared_params().disable_log_color())
+	}
+
+	/// Initialize substrate. This must be done only once per process.
+	///
+	/// This method:
+	///
+	/// 1. Sets the panic handler
+	/// 2. Optionally customize logger/profiling
+	/// 2. Initializes the logger
+	/// 3. Raises the FD limit
+	///
+	/// The `logger_hook` closure is executed before the logger is constructed
+	/// and initialized. It is useful for setting up a custom profiler.
+	///
+	/// Example:
+	/// ```
+	/// use sc_tracing::{SpanDatum, TraceEvent};
+	/// struct TestProfiler;
+	///
+	/// impl sc_tracing::TraceHandler for TestProfiler {
+	///  	fn handle_span(&self, sd: &SpanDatum) {}
+	/// 		fn handle_event(&self, _event: &TraceEvent) {}
+	/// };
+	///
+	/// fn logger_hook() -> impl FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Configuration) -> () {
+	/// 	|logger_builder, config| {
+	/// 			logger_builder.with_custom_profiling(Box::new(TestProfiler{}));
+	/// 	}
+	/// }
+	/// ```
+	fn init<F>(
+		&self,
+		support_url: &String,
+		impl_version: &String,
+		logger_hook: F,
+		config: &Configuration,
+	) -> Result<()>
+	where
+		F: FnOnce(&mut LoggerBuilder, &Configuration),
+	{
+		sp_panic_handler::set(support_url, impl_version);
+
+		let mut logger = LoggerBuilder::new(self.log_filters()?);
+		logger
+			.with_log_reloading(self.enable_log_reloading()?)
+			.with_detailed_output(self.detailed_log_output()?);
+
+		if let Some(tracing_targets) = self.tracing_targets()? {
+			let tracing_receiver = self.tracing_receiver()?;
+			logger.with_profiling(tracing_receiver, tracing_targets);
+		}
+
+		if self.disable_log_color()? {
+			logger.with_colors(false);
+		}
+
+		// Call hook for custom profiling setup.
+		logger_hook(&mut logger, config);
+
+		logger.init()?;
+
+		if let Some(new_limit) = fdlimit::raise_fd_limit() {
+			if new_limit < RECOMMENDED_OPEN_FILE_DESCRIPTOR_LIMIT {
+				warn!(
+					"Low open file descriptor limit configured for the process. \
+					Current value: {:?}, recommended value: {:?}.",
+					new_limit, RECOMMENDED_OPEN_FILE_DESCRIPTOR_LIMIT,
+				);
+			}
+		}
+
+		Ok(())
+	}
+}
+
+/// Generate a valid random name for the node
+pub fn generate_node_name() -> String {
+	loop {
+		let node_name = Generator::with_naming(Name::Numbered)
+			.next()
+			.expect("RNG is available on all supported platforms; qed");
+		let count = node_name.chars().count();
+
+		if count < NODE_NAME_MAX_LENGTH {
+			return node_name
+		}
+	}
+}
diff --git a/substrate/client/cli/src/error.rs b/substrate/client/cli/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c0cfca4932efca53ff6f8d38e8ae4de004f8b91
--- /dev/null
+++ b/substrate/client/cli/src/error.rs
@@ -0,0 +1,105 @@
+// 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/>.
+
+//! Initialization errors.
+
+use sp_core::crypto;
+
+/// Result type alias for the CLI.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Error type for the CLI.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+	#[error(transparent)]
+	Io(#[from] std::io::Error),
+
+	#[error(transparent)]
+	Cli(#[from] clap::Error),
+
+	#[error(transparent)]
+	Service(#[from] sc_service::Error),
+
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+
+	#[error(transparent)]
+	Codec(#[from] parity_scale_codec::Error),
+
+	#[error("Invalid input: {0}")]
+	Input(String),
+
+	#[error("Invalid listen multiaddress")]
+	InvalidListenMultiaddress,
+
+	#[error("Invalid URI; expecting either a secret URI or a public URI.")]
+	InvalidUri(crypto::PublicError),
+
+	#[error("Signature is an invalid format.")]
+	SignatureFormatInvalid,
+
+	#[error("Key is an invalid format.")]
+	KeyFormatInvalid,
+
+	#[error("Unknown key type, must be a known 4-character sequence")]
+	KeyTypeInvalid,
+
+	#[error("Signature verification failed")]
+	SignatureInvalid,
+
+	#[error("Key store operation failed")]
+	KeystoreOperation,
+
+	#[error("Key storage issue encountered")]
+	KeyStorage(#[from] sc_keystore::Error),
+
+	#[error("Invalid hexadecimal string data, {0:?}")]
+	HexDataConversion(array_bytes::Error),
+
+	/// Application specific error chain sequence forwarder.
+	#[error(transparent)]
+	Application(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
+
+	#[error(transparent)]
+	GlobalLoggerError(#[from] sc_tracing::logging::Error),
+}
+
+impl From<&str> for Error {
+	fn from(s: &str) -> Error {
+		Error::Input(s.to_string())
+	}
+}
+
+impl From<String> for Error {
+	fn from(s: String) -> Error {
+		Error::Input(s)
+	}
+}
+
+impl From<crypto::PublicError> for Error {
+	fn from(e: crypto::PublicError) -> Error {
+		Error::InvalidUri(e)
+	}
+}
+
+impl From<array_bytes::Error> for Error {
+	fn from(e: array_bytes::Error) -> Error {
+		Error::HexDataConversion(e)
+	}
+}
diff --git a/substrate/client/cli/src/lib.rs b/substrate/client/cli/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..104e8ec8b798ee5b8eb6c9561c6ef0729d7a7b2a
--- /dev/null
+++ b/substrate/client/cli/src/lib.rs
@@ -0,0 +1,253 @@
+// 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/>.
+
+//! Substrate CLI library.
+//!
+//! To see a full list of commands available, see [`commands`].
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+#![warn(unused_imports)]
+
+use clap::{CommandFactory, FromArgMatches, Parser};
+use sc_service::Configuration;
+
+pub mod arg_enums;
+pub mod commands;
+mod config;
+mod error;
+mod params;
+mod runner;
+mod signals;
+
+pub use arg_enums::*;
+pub use clap;
+pub use commands::*;
+pub use config::*;
+pub use error::*;
+pub use params::*;
+pub use runner::*;
+pub use sc_service::{ChainSpec, Role};
+pub use sc_tracing::logging::LoggerBuilder;
+pub use signals::Signals;
+pub use sp_version::RuntimeVersion;
+
+/// Substrate client CLI
+///
+/// This trait needs to be implemented on the root CLI struct of the application. It will provide
+/// the implementation `name`, `version`, `executable name`, `description`, `author`, `support_url`,
+/// `copyright start year` and most importantly: how to load the chain spec.
+pub trait SubstrateCli: Sized {
+	/// Implementation name.
+	fn impl_name() -> String;
+
+	/// Implementation version.
+	///
+	/// By default this will look like this:
+	///
+	/// `2.0.0-b950f731c`
+	///
+	/// Where the hash is the short commit hash of the commit of in the Git repository.
+	fn impl_version() -> String;
+
+	/// Executable file name.
+	///
+	/// Extracts the file name from `std::env::current_exe()`.
+	/// Resorts to the env var `CARGO_PKG_NAME` in case of Error.
+	fn executable_name() -> String {
+		std::env::current_exe()
+			.ok()
+			.and_then(|e| e.file_name().map(|s| s.to_os_string()))
+			.and_then(|w| w.into_string().ok())
+			.unwrap_or_else(|| env!("CARGO_PKG_NAME").into())
+	}
+
+	/// Executable file description.
+	fn description() -> String;
+
+	/// Executable file author.
+	fn author() -> String;
+
+	/// Support URL.
+	fn support_url() -> String;
+
+	/// Copyright starting year (x-current year)
+	fn copyright_start_year() -> i32;
+
+	/// Chain spec factory
+	fn load_spec(&self, id: &str) -> std::result::Result<Box<dyn ChainSpec>, String>;
+
+	/// Helper function used to parse the command line arguments. This is the equivalent of
+	/// [`clap::Parser::parse()`].
+	///
+	/// To allow running the node without subcommand, it also sets a few more settings:
+	/// [`clap::Command::propagate_version`], [`clap::Command::args_conflicts_with_subcommands`],
+	/// [`clap::Command::subcommand_negates_reqs`].
+	///
+	/// Creates `Self` from the command line arguments. Print the
+	/// error message and quit the program in case of failure.
+	fn from_args() -> Self
+	where
+		Self: Parser + Sized,
+	{
+		<Self as SubstrateCli>::from_iter(&mut std::env::args_os())
+	}
+
+	/// Helper function used to parse the command line arguments. This is the equivalent of
+	/// [`clap::Parser::parse_from`].
+	///
+	/// To allow running the node without subcommand, it also sets a few more settings:
+	/// [`clap::Command::propagate_version`], [`clap::Command::args_conflicts_with_subcommands`],
+	/// [`clap::Command::subcommand_negates_reqs`].
+	///
+	/// Creates `Self` from any iterator over arguments.
+	/// Print the error message and quit the program in case of failure.
+	fn from_iter<I>(iter: I) -> Self
+	where
+		Self: Parser + Sized,
+		I: IntoIterator,
+		I::Item: Into<std::ffi::OsString> + Clone,
+	{
+		let app = <Self as CommandFactory>::command();
+
+		let mut full_version = Self::impl_version();
+		full_version.push('\n');
+
+		let name = Self::executable_name();
+		let author = Self::author();
+		let about = Self::description();
+		let app = app
+			.name(name)
+			.author(author)
+			.about(about)
+			.version(full_version)
+			.propagate_version(true)
+			.args_conflicts_with_subcommands(true)
+			.subcommand_negates_reqs(true);
+
+		let matches = app.try_get_matches_from(iter).unwrap_or_else(|e| e.exit());
+
+		<Self as FromArgMatches>::from_arg_matches(&matches).unwrap_or_else(|e| e.exit())
+	}
+
+	/// Helper function used to parse the command line arguments. This is the equivalent of
+	/// [`clap::Parser::try_parse_from`]
+	///
+	/// To allow running the node without subcommand, it also sets a few more settings:
+	/// [`clap::Command::propagate_version`], [`clap::Command::args_conflicts_with_subcommands`],
+	/// [`clap::Command::subcommand_negates_reqs`].
+	///
+	/// Creates `Self` from any iterator over arguments.
+	/// Print the error message and quit the program in case of failure.
+	///
+	/// **NOTE:** This method WILL NOT exit when `--help` or `--version` (or short versions) are
+	/// used. It will return a [`clap::Error`], where the [`clap::Error::kind`] is a
+	/// [`clap::error::ErrorKind::DisplayHelp`] or [`clap::error::ErrorKind::DisplayVersion`]
+	/// respectively. You must call [`clap::Error::exit`] or perform a [`std::process::exit`].
+	fn try_from_iter<I>(iter: I) -> clap::error::Result<Self>
+	where
+		Self: Parser + Sized,
+		I: IntoIterator,
+		I::Item: Into<std::ffi::OsString> + Clone,
+	{
+		let app = <Self as CommandFactory>::command();
+
+		let mut full_version = Self::impl_version();
+		full_version.push('\n');
+
+		let name = Self::executable_name();
+		let author = Self::author();
+		let about = Self::description();
+		let app = app.name(name).author(author).about(about).version(full_version);
+
+		let matches = app.try_get_matches_from(iter)?;
+
+		<Self as FromArgMatches>::from_arg_matches(&matches)
+	}
+
+	/// Returns the client ID: `{impl_name}/v{impl_version}`
+	fn client_id() -> String {
+		format!("{}/v{}", Self::impl_name(), Self::impl_version())
+	}
+
+	/// Only create a Configuration for the command provided in argument
+	fn create_configuration<T: CliConfiguration<DVC>, DVC: DefaultConfigurationValues>(
+		&self,
+		command: &T,
+		tokio_handle: tokio::runtime::Handle,
+	) -> error::Result<Configuration> {
+		command.create_configuration(self, tokio_handle)
+	}
+
+	/// Create a runner for the command provided in argument. This will create a Configuration and
+	/// a tokio runtime
+	fn create_runner<T: CliConfiguration<DVC>, DVC: DefaultConfigurationValues>(
+		&self,
+		command: &T,
+	) -> error::Result<Runner<Self>> {
+		let tokio_runtime = build_runtime()?;
+
+		// `capture` needs to be called in a tokio context.
+		// Also capture them as early as possible.
+		let signals = tokio_runtime.block_on(async { Signals::capture() })?;
+
+		let config = command.create_configuration(self, tokio_runtime.handle().clone())?;
+
+		command.init(&Self::support_url(), &Self::impl_version(), |_, _| {}, &config)?;
+		Runner::new(config, tokio_runtime, signals)
+	}
+
+	/// Create a runner for the command provided in argument. The `logger_hook` can be used to setup
+	/// a custom profiler or update the logger configuration before it is initialized.
+	///
+	/// Example:
+	/// ```
+	/// use sc_tracing::{SpanDatum, TraceEvent};
+	/// struct TestProfiler;
+	///
+	/// impl sc_tracing::TraceHandler for TestProfiler {
+	///  	fn handle_span(&self, sd: &SpanDatum) {}
+	/// 		fn handle_event(&self, _event: &TraceEvent) {}
+	/// };
+	///
+	/// fn logger_hook() -> impl FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Configuration) -> () {
+	/// 	|logger_builder, config| {
+	/// 			logger_builder.with_custom_profiling(Box::new(TestProfiler{}));
+	/// 	}
+	/// }
+	/// ```
+	fn create_runner_with_logger_hook<T: CliConfiguration, F>(
+		&self,
+		command: &T,
+		logger_hook: F,
+	) -> error::Result<Runner<Self>>
+	where
+		F: FnOnce(&mut LoggerBuilder, &Configuration),
+	{
+		let tokio_runtime = build_runtime()?;
+
+		// `capture` needs to be called in a tokio context.
+		// Also capture them as early as possible.
+		let signals = tokio_runtime.block_on(async { Signals::capture() })?;
+
+		let config = command.create_configuration(self, tokio_runtime.handle().clone())?;
+
+		command.init(&Self::support_url(), &Self::impl_version(), logger_hook, &config)?;
+		Runner::new(config, tokio_runtime, signals)
+	}
+}
diff --git a/substrate/client/cli/src/params/database_params.rs b/substrate/client/cli/src/params/database_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cbc602cb877b41891c232aa39ca5eb137a992485
--- /dev/null
+++ b/substrate/client/cli/src/params/database_params.rs
@@ -0,0 +1,44 @@
+// 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::arg_enums::Database;
+use clap::Args;
+
+/// Parameters for database
+#[derive(Debug, Clone, PartialEq, Args)]
+pub struct DatabaseParams {
+	/// Select database backend to use.
+	#[arg(long, alias = "db", value_name = "DB", ignore_case = true, value_enum)]
+	pub database: Option<Database>,
+
+	/// Limit the memory the database cache can use.
+	#[arg(long = "db-cache", value_name = "MiB")]
+	pub database_cache_size: Option<usize>,
+}
+
+impl DatabaseParams {
+	/// Database backend
+	pub fn database(&self) -> Option<Database> {
+		self.database
+	}
+
+	/// Limit the memory the database cache can use.
+	pub fn database_cache_size(&self) -> Option<usize> {
+		self.database_cache_size
+	}
+}
diff --git a/substrate/client/cli/src/params/import_params.rs b/substrate/client/cli/src/params/import_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bfa54a35058f6214fc3da604af15e5b32abf45a8
--- /dev/null
+++ b/substrate/client/cli/src/params/import_params.rs
@@ -0,0 +1,176 @@
+// 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::{
+	arg_enums::{
+		ExecutionStrategy, WasmExecutionMethod, WasmtimeInstantiationStrategy,
+		DEFAULT_WASMTIME_INSTANTIATION_STRATEGY, DEFAULT_WASM_EXECUTION_METHOD,
+	},
+	params::{DatabaseParams, PruningParams},
+};
+use clap::Args;
+use std::path::PathBuf;
+
+/// Parameters for block import.
+#[derive(Debug, Clone, Args)]
+pub struct ImportParams {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub pruning_params: PruningParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub database_params: DatabaseParams,
+
+	/// Method for executing Wasm runtime code.
+	#[arg(
+		long = "wasm-execution",
+		value_name = "METHOD",
+		value_enum,
+		ignore_case = true,
+		default_value_t = DEFAULT_WASM_EXECUTION_METHOD,
+	)]
+	pub wasm_method: WasmExecutionMethod,
+
+	/// The WASM instantiation method to use.
+	/// Only has an effect when `wasm-execution` is set to `compiled`.
+	/// The copy-on-write strategies are only supported on Linux.
+	/// If the copy-on-write variant of a strategy is unsupported
+	/// the executor will fall back to the non-CoW equivalent.
+	/// The fastest (and the default) strategy available is `pooling-copy-on-write`.
+	/// The `legacy-instance-reuse` strategy is deprecated and will
+	/// be removed in the future. It should only be used in case of
+	/// issues with the default instantiation strategy.
+	#[arg(
+		long,
+		value_name = "STRATEGY",
+		default_value_t = DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
+		value_enum,
+	)]
+	pub wasmtime_instantiation_strategy: WasmtimeInstantiationStrategy,
+
+	/// Specify the path where local WASM runtimes are stored.
+	/// These runtimes will override on-chain runtimes when the version matches.
+	#[arg(long, value_name = "PATH")]
+	pub wasm_runtime_overrides: Option<PathBuf>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub execution_strategies: ExecutionStrategiesParams,
+
+	/// Specify the state cache size.
+	/// Providing `0` will disable the cache.
+	#[arg(long, value_name = "Bytes", default_value_t = 67108864)]
+	pub trie_cache_size: usize,
+
+	/// DEPRECATED
+	/// Switch to `--trie-cache-size`.
+	#[arg(long)]
+	state_cache_size: Option<usize>,
+}
+
+impl ImportParams {
+	/// Specify the trie cache maximum size.
+	pub fn trie_cache_maximum_size(&self) -> Option<usize> {
+		if self.state_cache_size.is_some() {
+			eprintln!("`--state-cache-size` was deprecated. Please switch to `--trie-cache-size`.");
+		}
+
+		if self.trie_cache_size == 0 {
+			None
+		} else {
+			Some(self.trie_cache_size)
+		}
+	}
+
+	/// Get the WASM execution method from the parameters
+	pub fn wasm_method(&self) -> sc_service::config::WasmExecutionMethod {
+		self.execution_strategies.check_usage_and_print_deprecation_warning();
+
+		crate::execution_method_from_cli(self.wasm_method, self.wasmtime_instantiation_strategy)
+	}
+
+	/// Enable overriding on-chain WASM with locally-stored WASM
+	/// by specifying the path where local WASM is stored.
+	pub fn wasm_runtime_overrides(&self) -> Option<PathBuf> {
+		self.wasm_runtime_overrides.clone()
+	}
+}
+
+/// Execution strategies parameters.
+#[derive(Debug, Clone, Args)]
+pub struct ExecutionStrategiesParams {
+	/// The means of execution used when calling into the runtime for importing blocks as
+	/// part of an initial sync.
+	#[arg(long, value_name = "STRATEGY", value_enum, ignore_case = true)]
+	pub execution_syncing: Option<ExecutionStrategy>,
+
+	/// The means of execution used when calling into the runtime for general block import
+	/// (including locally authored blocks).
+	#[arg(long, value_name = "STRATEGY", value_enum, ignore_case = true)]
+	pub execution_import_block: Option<ExecutionStrategy>,
+
+	/// The means of execution used when calling into the runtime while constructing blocks.
+	#[arg(long, value_name = "STRATEGY", value_enum, ignore_case = true)]
+	pub execution_block_construction: Option<ExecutionStrategy>,
+
+	/// The means of execution used when calling into the runtime while using an off-chain worker.
+	#[arg(long, value_name = "STRATEGY", value_enum, ignore_case = true)]
+	pub execution_offchain_worker: Option<ExecutionStrategy>,
+
+	/// The means of execution used when calling into the runtime while not syncing, importing or
+	/// constructing blocks.
+	#[arg(long, value_name = "STRATEGY", value_enum, ignore_case = true)]
+	pub execution_other: Option<ExecutionStrategy>,
+
+	/// The execution strategy that should be used by all execution contexts.
+	#[arg(
+		long,
+		value_name = "STRATEGY",
+		value_enum,
+		ignore_case = true,
+		conflicts_with_all = &[
+			"execution_other",
+			"execution_offchain_worker",
+			"execution_block_construction",
+			"execution_import_block",
+			"execution_syncing",
+		]
+	)]
+	pub execution: Option<ExecutionStrategy>,
+}
+
+impl ExecutionStrategiesParams {
+	/// Check if one of the parameters is still passed and print a warning if so.
+	fn check_usage_and_print_deprecation_warning(&self) {
+		for (param, name) in [
+			(&self.execution_syncing, "execution-syncing"),
+			(&self.execution_import_block, "execution-import-block"),
+			(&self.execution_block_construction, "execution-block-construction"),
+			(&self.execution_offchain_worker, "execution-offchain-worker"),
+			(&self.execution_other, "execution-other"),
+			(&self.execution, "execution"),
+		] {
+			if param.is_some() {
+				eprintln!(
+					"CLI parameter `--{name}` has no effect anymore and will be removed in the future!"
+				);
+			}
+		}
+	}
+}
diff --git a/substrate/client/cli/src/params/keystore_params.rs b/substrate/client/cli/src/params/keystore_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a2fdd6b2218c4b2dcadb03a6ca179d00a59868e2
--- /dev/null
+++ b/substrate/client/cli/src/params/keystore_params.rs
@@ -0,0 +1,106 @@
+// 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::{error, error::Result};
+use clap::Args;
+use sc_service::config::KeystoreConfig;
+use sp_core::crypto::SecretString;
+use std::{
+	fs,
+	path::{Path, PathBuf},
+};
+
+/// default sub directory for the key store
+const DEFAULT_KEYSTORE_CONFIG_PATH: &str = "keystore";
+
+/// Parameters of the keystore
+#[derive(Debug, Clone, Args)]
+pub struct KeystoreParams {
+	/// Specify custom URIs to connect to for keystore-services
+	#[arg(long)]
+	pub keystore_uri: Option<String>,
+
+	/// Specify custom keystore path.
+	#[arg(long, value_name = "PATH")]
+	pub keystore_path: Option<PathBuf>,
+
+	/// Use interactive shell for entering the password used by the keystore.
+	#[arg(long, conflicts_with_all = &["password", "password_filename"])]
+	pub password_interactive: bool,
+
+	/// Password used by the keystore. This allows appending an extra user-defined secret to the
+	/// seed.
+	#[arg(
+		long,
+		value_parser = secret_string_from_str,
+		conflicts_with_all = &["password_interactive", "password_filename"]
+	)]
+	pub password: Option<SecretString>,
+
+	/// File that contains the password used by the keystore.
+	#[arg(
+		long,
+		value_name = "PATH",
+		conflicts_with_all = &["password_interactive", "password"]
+	)]
+	pub password_filename: Option<PathBuf>,
+}
+
+/// Parse a secret string, returning a displayable error.
+pub fn secret_string_from_str(s: &str) -> std::result::Result<SecretString, String> {
+	std::str::FromStr::from_str(s).map_err(|_| "Could not get SecretString".to_string())
+}
+
+impl KeystoreParams {
+	/// Get the keystore configuration for the parameters
+	pub fn keystore_config(&self, config_dir: &Path) -> Result<KeystoreConfig> {
+		let password = if self.password_interactive {
+			Some(SecretString::new(input_keystore_password()?))
+		} else if let Some(ref file) = self.password_filename {
+			let password = fs::read_to_string(file).map_err(|e| format!("{}", e))?;
+			Some(SecretString::new(password))
+		} else {
+			self.password.clone()
+		};
+
+		let path = self
+			.keystore_path
+			.clone()
+			.unwrap_or_else(|| config_dir.join(DEFAULT_KEYSTORE_CONFIG_PATH));
+
+		Ok(KeystoreConfig::Path { path, password })
+	}
+
+	/// helper method to fetch password from `KeyParams` or read from stdin
+	pub fn read_password(&self) -> error::Result<Option<SecretString>> {
+		let (password_interactive, password) = (self.password_interactive, self.password.clone());
+
+		let pass = if password_interactive {
+			let password = rpassword::prompt_password("Key password: ")?;
+			Some(SecretString::new(password))
+		} else {
+			password
+		};
+
+		Ok(pass)
+	}
+}
+
+fn input_keystore_password() -> Result<String> {
+	rpassword::prompt_password("Keystore password: ").map_err(|e| format!("{:?}", e).into())
+}
diff --git a/substrate/client/cli/src/params/message_params.rs b/substrate/client/cli/src/params/message_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3fcb6f2c6e8cc918236df7e812786ec9da93354d
--- /dev/null
+++ b/substrate/client/cli/src/params/message_params.rs
@@ -0,0 +1,120 @@
+// 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/>.
+
+//! Params to configure how a message should be passed into a command.
+
+use crate::error::Error;
+use array_bytes::{hex2bytes, hex_bytes2hex_str};
+use clap::Args;
+use std::io::BufRead;
+
+/// Params to configure how a message should be passed into a command.
+#[derive(Debug, Clone, Args)]
+pub struct MessageParams {
+	/// Message to process. Will be read from STDIN otherwise.
+	/// The message is assumed to be raw bytes per default. Use `--hex` for hex input. Can
+	/// optionally be prefixed with `0x` in the hex case.
+	#[arg(long)]
+	message: Option<String>,
+
+	/// The message is hex-encoded data.
+	#[arg(long)]
+	hex: bool,
+}
+
+impl MessageParams {
+	/// Produces the message by either using its immediate value or reading from stdin.
+	///
+	/// This function should only be called once and the result cached.
+	pub(crate) fn message_from<F, R>(&self, create_reader: F) -> Result<Vec<u8>, Error>
+	where
+		R: BufRead,
+		F: FnOnce() -> R,
+	{
+		let raw = match &self.message {
+			Some(raw) => raw.as_bytes().to_vec(),
+			None => {
+				let mut raw = vec![];
+				create_reader().read_to_end(&mut raw)?;
+				raw
+			},
+		};
+		if self.hex {
+			hex2bytes(hex_bytes2hex_str(&raw)?).map_err(Into::into)
+		} else {
+			Ok(raw)
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	/// Test that decoding an immediate message works.
+	#[test]
+	fn message_decode_immediate() {
+		for (name, input, hex, output) in test_closures() {
+			println!("Testing: immediate_{}", name);
+			let params = MessageParams { message: Some(input.into()), hex };
+			let message = params.message_from(|| std::io::stdin().lock());
+
+			match output {
+				Some(output) => {
+					let message = message.expect(&format!("{}: should decode but did not", name));
+					assert_eq!(message, output, "{}: decoded a wrong message", name);
+				},
+				None => {
+					message.err().expect(&format!("{}: should not decode but did", name));
+				},
+			}
+		}
+	}
+
+	/// Test that decoding a message from a stream works.
+	#[test]
+	fn message_decode_stream() {
+		for (name, input, hex, output) in test_closures() {
+			println!("Testing: stream_{}", name);
+			let params = MessageParams { message: None, hex };
+			let message = params.message_from(|| input.as_bytes());
+
+			match output {
+				Some(output) => {
+					let message = message.expect(&format!("{}: should decode but did not", name));
+					assert_eq!(message, output, "{}: decoded a wrong message", name);
+				},
+				None => {
+					message.err().expect(&format!("{}: should not decode but did", name));
+				},
+			}
+		}
+	}
+
+	/// Returns (test_name, input, hex, output).
+	fn test_closures() -> Vec<(&'static str, &'static str, bool, Option<&'static [u8]>)> {
+		vec![
+			("decode_no_hex_works", "Hello this is not hex", false, Some(b"Hello this is not hex")),
+			("decode_no_hex_with_hex_string_works", "0xffffffff", false, Some(b"0xffffffff")),
+			("decode_hex_works", "0x00112233", true, Some(&[0, 17, 34, 51])),
+			("decode_hex_without_prefix_works", "00112233", true, Some(&[0, 17, 34, 51])),
+			("decode_hex_uppercase_works", "0xaAbbCCDd", true, Some(&[170, 187, 204, 221])),
+			("decode_hex_wrong_len_errors", "0x0011223", true, None),
+		]
+	}
+}
diff --git a/substrate/client/cli/src/params/mod.rs b/substrate/client/cli/src/params/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a73bd8844fec4200e44fb8fb3cd42bf3d9f5eabf
--- /dev/null
+++ b/substrate/client/cli/src/params/mod.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/>.
+mod database_params;
+mod import_params;
+mod keystore_params;
+mod message_params;
+mod network_params;
+mod node_key_params;
+mod offchain_worker_params;
+mod prometheus_params;
+mod pruning_params;
+mod runtime_params;
+mod shared_params;
+mod telemetry_params;
+mod transaction_pool_params;
+
+use crate::arg_enums::{CryptoScheme, OutputType};
+use clap::Args;
+use sp_core::crypto::{Ss58AddressFormat, Ss58AddressFormatRegistry};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, NumberFor},
+};
+use std::{fmt::Debug, str::FromStr};
+
+pub use crate::params::{
+	database_params::*, import_params::*, keystore_params::*, message_params::*, network_params::*,
+	node_key_params::*, offchain_worker_params::*, prometheus_params::*, pruning_params::*,
+	runtime_params::*, shared_params::*, telemetry_params::*, transaction_pool_params::*,
+};
+
+/// Parse Ss58AddressFormat
+pub fn parse_ss58_address_format(x: &str) -> Result<Ss58AddressFormat, String> {
+	match Ss58AddressFormatRegistry::try_from(x) {
+		Ok(format_registry) => Ok(format_registry.into()),
+		Err(_) => Err(format!(
+			"Unable to parse variant. Known variants: {:?}",
+			Ss58AddressFormat::all_names()
+		)),
+	}
+}
+
+/// Wrapper type of `String` that holds an unsigned integer of arbitrary size, formatted as a
+/// decimal.
+#[derive(Debug, Clone)]
+pub struct GenericNumber(String);
+
+impl FromStr for GenericNumber {
+	type Err = String;
+
+	fn from_str(block_number: &str) -> Result<Self, Self::Err> {
+		if let Some(pos) = block_number.chars().position(|d| !d.is_digit(10)) {
+			Err(format!("Expected block number, found illegal digit at position: {}", pos))
+		} else {
+			Ok(Self(block_number.to_owned()))
+		}
+	}
+}
+
+impl GenericNumber {
+	/// Wrapper on top of `std::str::parse<N>` but with `Error` as a `String`
+	///
+	/// See `https://doc.rust-lang.org/std/primitive.str.html#method.parse` for more elaborate
+	/// documentation.
+	pub fn parse<N>(&self) -> Result<N, String>
+	where
+		N: FromStr,
+		N::Err: std::fmt::Debug,
+	{
+		FromStr::from_str(&self.0).map_err(|e| format!("Failed to parse block number: {:?}", e))
+	}
+}
+
+/// Wrapper type that is either a `Hash` or the number of a `Block`.
+#[derive(Debug, Clone)]
+pub struct BlockNumberOrHash(String);
+
+impl FromStr for BlockNumberOrHash {
+	type Err = String;
+
+	fn from_str(block_number: &str) -> Result<Self, Self::Err> {
+		if let Some(rest) = block_number.strip_prefix("0x") {
+			if let Some(pos) = rest.chars().position(|c| !c.is_ascii_hexdigit()) {
+				Err(format!(
+					"Expected block hash, found illegal hex character at position: {}",
+					2 + pos,
+				))
+			} else {
+				Ok(Self(block_number.into()))
+			}
+		} else {
+			GenericNumber::from_str(block_number).map(|v| Self(v.0))
+		}
+	}
+}
+
+impl BlockNumberOrHash {
+	/// Parse the inner value as `BlockId`.
+	pub fn parse<B: BlockT>(&self) -> Result<BlockId<B>, String>
+	where
+		<B::Hash as FromStr>::Err: std::fmt::Debug,
+		NumberFor<B>: FromStr,
+		<NumberFor<B> as FromStr>::Err: std::fmt::Debug,
+	{
+		if self.0.starts_with("0x") {
+			Ok(BlockId::Hash(
+				FromStr::from_str(&self.0[2..])
+					.map_err(|e| format!("Failed to parse block hash: {:?}", e))?,
+			))
+		} else {
+			GenericNumber(self.0.clone()).parse().map(BlockId::Number)
+		}
+	}
+}
+
+/// Optional flag for specifying crypto algorithm
+#[derive(Debug, Clone, Args)]
+pub struct CryptoSchemeFlag {
+	/// cryptography scheme
+	#[arg(long, value_name = "SCHEME", value_enum, ignore_case = true, default_value_t = CryptoScheme::Sr25519)]
+	pub scheme: CryptoScheme,
+}
+
+/// Optional flag for specifying output type
+#[derive(Debug, Clone, Args)]
+pub struct OutputTypeFlag {
+	/// output format
+	#[arg(long, value_name = "FORMAT", value_enum, ignore_case = true, default_value_t = OutputType::Text)]
+	pub output_type: OutputType,
+}
+
+/// Optional flag for specifying network scheme
+#[derive(Debug, Clone, Args)]
+pub struct NetworkSchemeFlag {
+	/// network address format
+	#[arg(
+		short = 'n',
+		long,
+		value_name = "NETWORK",
+		ignore_case = true,
+		value_parser = parse_ss58_address_format,
+	)]
+	pub network: Option<Ss58AddressFormat>,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
+	type Block = sp_runtime::generic::Block<Header, sp_runtime::OpaqueExtrinsic>;
+
+	#[test]
+	fn parse_block_number() {
+		let block_number_or_hash = BlockNumberOrHash::from_str("1234").unwrap();
+		let parsed = block_number_or_hash.parse::<Block>().unwrap();
+		assert_eq!(BlockId::Number(1234), parsed);
+	}
+
+	#[test]
+	fn parse_block_hash() {
+		let hash = sp_core::H256::default();
+		let hash_str = format!("{:?}", hash);
+		let block_number_or_hash = BlockNumberOrHash::from_str(&hash_str).unwrap();
+		let parsed = block_number_or_hash.parse::<Block>().unwrap();
+		assert_eq!(BlockId::Hash(hash), parsed);
+	}
+
+	#[test]
+	fn parse_block_hash_fails() {
+		assert_eq!(
+			"Expected block hash, found illegal hex character at position: 2",
+			BlockNumberOrHash::from_str("0xHello").unwrap_err(),
+		);
+	}
+
+	#[test]
+	fn parse_block_number_fails() {
+		assert_eq!(
+			"Expected block number, found illegal digit at position: 3",
+			BlockNumberOrHash::from_str("345Hello").unwrap_err(),
+		);
+	}
+}
diff --git a/substrate/client/cli/src/params/network_params.rs b/substrate/client/cli/src/params/network_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..84db218cc51da04fd382fa69c6e5c3bf6ad91ded
--- /dev/null
+++ b/substrate/client/cli/src/params/network_params.rs
@@ -0,0 +1,301 @@
+// 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::{arg_enums::SyncMode, params::node_key_params::NodeKeyParams};
+use clap::Args;
+use sc_network::{
+	config::{
+		NetworkConfiguration, NodeKeyConfig, NonReservedPeerMode, SetConfig, TransportConfig,
+	},
+	multiaddr::Protocol,
+};
+use sc_service::{
+	config::{Multiaddr, MultiaddrWithPeerId},
+	ChainSpec, ChainType,
+};
+use std::{borrow::Cow, num::NonZeroUsize, path::PathBuf};
+
+/// Parameters used to create the network configuration.
+#[derive(Debug, Clone, Args)]
+pub struct NetworkParams {
+	/// Specify a list of bootnodes.
+	#[arg(long, value_name = "ADDR", num_args = 1..)]
+	pub bootnodes: Vec<MultiaddrWithPeerId>,
+
+	/// Specify a list of reserved node addresses.
+	#[arg(long, value_name = "ADDR", num_args = 1..)]
+	pub reserved_nodes: Vec<MultiaddrWithPeerId>,
+
+	/// Whether to only synchronize the chain with reserved nodes.
+	/// Also disables automatic peer discovery.
+	/// TCP connections might still be established with non-reserved nodes.
+	/// In particular, if you are a validator your node might still connect to other
+	/// validator nodes and collator nodes regardless of whether they are defined as
+	/// reserved nodes.
+	#[arg(long)]
+	pub reserved_only: bool,
+
+	/// The public address that other nodes will use to connect to it.
+	/// This can be used if there's a proxy in front of this node.
+	#[arg(long, value_name = "PUBLIC_ADDR", num_args = 1..)]
+	pub public_addr: Vec<Multiaddr>,
+
+	/// Listen on this multiaddress.
+	///
+	/// By default:
+	/// If `--validator` is passed: `/ip4/0.0.0.0/tcp/<port>` and `/ip6/[::]/tcp/<port>`.
+	/// Otherwise: `/ip4/0.0.0.0/tcp/<port>/ws` and `/ip6/[::]/tcp/<port>/ws`.
+	#[arg(long, value_name = "LISTEN_ADDR", num_args = 1..)]
+	pub listen_addr: Vec<Multiaddr>,
+
+	/// Specify p2p protocol TCP port.
+	#[arg(long, value_name = "PORT", conflicts_with_all = &[ "listen_addr" ])]
+	pub port: Option<u16>,
+
+	/// Always forbid connecting to private IPv4/IPv6 addresses (as specified in
+	/// [RFC1918](https://tools.ietf.org/html/rfc1918)), unless the address was passed with
+	/// `--reserved-nodes` or `--bootnodes`. Enabled by default for chains marked as "live" in
+	/// their chain specifications.
+	#[arg(long, alias = "no-private-ipv4", conflicts_with_all = &["allow_private_ip"])]
+	pub no_private_ip: bool,
+
+	/// Always accept connecting to private IPv4/IPv6 addresses (as specified in
+	/// [RFC1918](https://tools.ietf.org/html/rfc1918)). Enabled by default for chains marked as
+	/// "local" in their chain specifications, or when `--dev` is passed.
+	#[arg(long, alias = "allow-private-ipv4", conflicts_with_all = &["no_private_ip"])]
+	pub allow_private_ip: bool,
+
+	/// Specify the number of outgoing connections we're trying to maintain.
+	#[arg(long, value_name = "COUNT", default_value_t = 8)]
+	pub out_peers: u32,
+
+	/// Maximum number of inbound full nodes peers.
+	#[arg(long, value_name = "COUNT", default_value_t = 32)]
+	pub in_peers: u32,
+
+	/// Maximum number of inbound light nodes peers.
+	#[arg(long, value_name = "COUNT", default_value_t = 100)]
+	pub in_peers_light: u32,
+
+	/// Disable mDNS discovery.
+	/// By default, the network will use mDNS to discover other nodes on the
+	/// local network. This disables it. Automatically implied when using --dev.
+	#[arg(long)]
+	pub no_mdns: bool,
+
+	/// Maximum number of peers from which to ask for the same blocks in parallel.
+	/// This allows downloading announced blocks from multiple peers. Decrease to save
+	/// traffic and risk increased latency.
+	#[arg(long, value_name = "COUNT", default_value_t = 5)]
+	pub max_parallel_downloads: u32,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub node_key_params: NodeKeyParams,
+
+	/// Enable peer discovery on local networks.
+	/// By default this option is `true` for `--dev` or when the chain type is
+	/// `Local`/`Development` and false otherwise.
+	#[arg(long)]
+	pub discover_local: bool,
+
+	/// Require iterative Kademlia DHT queries to use disjoint paths for increased resiliency in
+	/// the presence of potentially adversarial nodes.
+	/// See the S/Kademlia paper for more information on the high level design as well as its
+	/// security improvements.
+	#[arg(long)]
+	pub kademlia_disjoint_query_paths: bool,
+
+	/// Kademlia replication factor determines to how many closest peers a record is replicated to.
+	///
+	/// Discovery mechanism requires successful replication to all
+	/// `kademlia_replication_factor` peers to consider record successfully put.
+	#[arg(long, default_value = "20")]
+	pub kademlia_replication_factor: NonZeroUsize,
+
+	/// Join the IPFS network and serve transactions over bitswap protocol.
+	#[arg(long)]
+	pub ipfs_server: bool,
+
+	/// Blockchain syncing mode.
+	#[arg(
+		long,
+		value_enum,
+		value_name = "SYNC_MODE",
+		default_value_t = SyncMode::Full,
+		ignore_case = true,
+		verbatim_doc_comment
+	)]
+	pub sync: SyncMode,
+
+	/// Maximum number of blocks per request.
+	///
+	/// Try reducing this number from the default value if you have a slow network connection
+	/// and observe block requests timing out.
+	#[arg(long, value_name = "COUNT", default_value_t = 64)]
+	pub max_blocks_per_request: u32,
+}
+
+impl NetworkParams {
+	/// Fill the given `NetworkConfiguration` by looking at the cli parameters.
+	pub fn network_config(
+		&self,
+		chain_spec: &Box<dyn ChainSpec>,
+		is_dev: bool,
+		is_validator: bool,
+		net_config_path: Option<PathBuf>,
+		client_id: &str,
+		node_name: &str,
+		node_key: NodeKeyConfig,
+		default_listen_port: u16,
+	) -> NetworkConfiguration {
+		let port = self.port.unwrap_or(default_listen_port);
+
+		let listen_addresses = if self.listen_addr.is_empty() {
+			if is_validator || is_dev {
+				vec![
+					Multiaddr::empty()
+						.with(Protocol::Ip6([0, 0, 0, 0, 0, 0, 0, 0].into()))
+						.with(Protocol::Tcp(port)),
+					Multiaddr::empty()
+						.with(Protocol::Ip4([0, 0, 0, 0].into()))
+						.with(Protocol::Tcp(port)),
+				]
+			} else {
+				vec![
+					Multiaddr::empty()
+						.with(Protocol::Ip6([0, 0, 0, 0, 0, 0, 0, 0].into()))
+						.with(Protocol::Tcp(port))
+						.with(Protocol::Ws(Cow::Borrowed("/"))),
+					Multiaddr::empty()
+						.with(Protocol::Ip4([0, 0, 0, 0].into()))
+						.with(Protocol::Tcp(port))
+						.with(Protocol::Ws(Cow::Borrowed("/"))),
+				]
+			}
+		} else {
+			self.listen_addr.clone()
+		};
+
+		let public_addresses = self.public_addr.clone();
+
+		let mut boot_nodes = chain_spec.boot_nodes().to_vec();
+		boot_nodes.extend(self.bootnodes.clone());
+
+		let chain_type = chain_spec.chain_type();
+		// Activate if the user explicitly requested local discovery, `--dev` is given or the
+		// chain type is `Local`/`Development`
+		let allow_non_globals_in_dht =
+			self.discover_local ||
+				is_dev || matches!(chain_type, ChainType::Local | ChainType::Development);
+
+		let allow_private_ip = match (self.allow_private_ip, self.no_private_ip) {
+			(true, true) => unreachable!("`*_private_ip` flags are mutually exclusive; qed"),
+			(true, false) => true,
+			(false, true) => false,
+			(false, false) =>
+				is_dev || matches!(chain_type, ChainType::Local | ChainType::Development),
+		};
+
+		NetworkConfiguration {
+			boot_nodes,
+			net_config_path,
+			default_peers_set: SetConfig {
+				in_peers: self.in_peers + self.in_peers_light,
+				out_peers: self.out_peers,
+				reserved_nodes: self.reserved_nodes.clone(),
+				non_reserved_mode: if self.reserved_only {
+					NonReservedPeerMode::Deny
+				} else {
+					NonReservedPeerMode::Accept
+				},
+			},
+			default_peers_set_num_full: self.in_peers + self.out_peers,
+			listen_addresses,
+			public_addresses,
+			node_key,
+			node_name: node_name.to_string(),
+			client_version: client_id.to_string(),
+			transport: TransportConfig::Normal {
+				enable_mdns: !is_dev && !self.no_mdns,
+				allow_private_ip,
+			},
+			max_parallel_downloads: self.max_parallel_downloads,
+			max_blocks_per_request: self.max_blocks_per_request,
+			enable_dht_random_walk: !self.reserved_only,
+			allow_non_globals_in_dht,
+			kademlia_disjoint_query_paths: self.kademlia_disjoint_query_paths,
+			kademlia_replication_factor: self.kademlia_replication_factor,
+			yamux_window_size: None,
+			ipfs_server: self.ipfs_server,
+			sync_mode: self.sync.into(),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use clap::Parser;
+
+	#[derive(Parser)]
+	struct Cli {
+		#[clap(flatten)]
+		network_params: NetworkParams,
+	}
+
+	#[test]
+	fn reserved_nodes_multiple_values_and_occurrences() {
+		let params = Cli::try_parse_from([
+			"",
+			"--reserved-nodes",
+			"/ip4/0.0.0.0/tcp/501/p2p/12D3KooWEBo1HUPQJwiBmM5kSeg4XgiVxEArArQdDarYEsGxMfbS",
+			"/ip4/0.0.0.0/tcp/502/p2p/12D3KooWEBo1HUPQJwiBmM5kSeg4XgiVxEArArQdDarYEsGxMfbS",
+			"--reserved-nodes",
+			"/ip4/0.0.0.0/tcp/503/p2p/12D3KooWEBo1HUPQJwiBmM5kSeg4XgiVxEArArQdDarYEsGxMfbS",
+		])
+		.expect("Parses network params");
+
+		let expected = vec![
+			MultiaddrWithPeerId::try_from(
+				"/ip4/0.0.0.0/tcp/501/p2p/12D3KooWEBo1HUPQJwiBmM5kSeg4XgiVxEArArQdDarYEsGxMfbS"
+					.to_string(),
+			)
+			.unwrap(),
+			MultiaddrWithPeerId::try_from(
+				"/ip4/0.0.0.0/tcp/502/p2p/12D3KooWEBo1HUPQJwiBmM5kSeg4XgiVxEArArQdDarYEsGxMfbS"
+					.to_string(),
+			)
+			.unwrap(),
+			MultiaddrWithPeerId::try_from(
+				"/ip4/0.0.0.0/tcp/503/p2p/12D3KooWEBo1HUPQJwiBmM5kSeg4XgiVxEArArQdDarYEsGxMfbS"
+					.to_string(),
+			)
+			.unwrap(),
+		];
+
+		assert_eq!(expected, params.network_params.reserved_nodes);
+	}
+
+	#[test]
+	fn sync_ingores_case() {
+		let params = Cli::try_parse_from(["", "--sync", "wArP"]).expect("Parses network params");
+
+		assert_eq!(SyncMode::Warp, params.network_params.sync);
+	}
+}
diff --git a/substrate/client/cli/src/params/node_key_params.rs b/substrate/client/cli/src/params/node_key_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8c5579eaec4947d0ae18581e77b577186b3d7b9c
--- /dev/null
+++ b/substrate/client/cli/src/params/node_key_params.rs
@@ -0,0 +1,204 @@
+// 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 clap::Args;
+use sc_network::config::{identity::ed25519, NodeKeyConfig};
+use sp_core::H256;
+use std::{path::PathBuf, str::FromStr};
+
+use crate::{arg_enums::NodeKeyType, error};
+
+/// The file name of the node's Ed25519 secret key inside the chain-specific
+/// network config directory, if neither `--node-key` nor `--node-key-file`
+/// is specified in combination with `--node-key-type=ed25519`.
+const NODE_KEY_ED25519_FILE: &str = "secret_ed25519";
+
+/// Parameters used to create the `NodeKeyConfig`, which determines the keypair
+/// used for libp2p networking.
+#[derive(Debug, Clone, Args)]
+pub struct NodeKeyParams {
+	/// The secret key to use for libp2p networking.
+	/// The value is a string that is parsed according to the choice of
+	/// `--node-key-type` as follows:
+	///   `ed25519`:
+	///   The value is parsed as a hex-encoded Ed25519 32 byte secret key,
+	///   i.e. 64 hex characters.
+	/// The value of this option takes precedence over `--node-key-file`.
+	/// WARNING: Secrets provided as command-line arguments are easily exposed.
+	/// Use of this option should be limited to development and testing. To use
+	/// an externally managed secret key, use `--node-key-file` instead.
+	#[arg(long, value_name = "KEY")]
+	pub node_key: Option<String>,
+
+	/// The type of secret key to use for libp2p networking.
+	/// The secret key of the node is obtained as follows:
+	///   * If the `--node-key` option is given, the value is parsed as a secret key according to
+	///     the type. See the documentation for `--node-key`.
+	///   * If the `--node-key-file` option is given, the secret key is read from the specified
+	///     file. See the documentation for `--node-key-file`.
+	///   * Otherwise, the secret key is read from a file with a predetermined, type-specific name
+	///     from the chain-specific network config directory inside the base directory specified by
+	///     `--base-dir`. If this file does not exist, it is created with a newly generated secret
+	///     key of the chosen type.
+	/// The node's secret key determines the corresponding public key and hence the
+	/// node's peer ID in the context of libp2p.
+	#[arg(long, value_name = "TYPE", value_enum, ignore_case = true, default_value_t = NodeKeyType::Ed25519)]
+	pub node_key_type: NodeKeyType,
+
+	/// The file from which to read the node's secret key to use for libp2p networking.
+	/// The contents of the file are parsed according to the choice of `--node-key-type`
+	/// as follows:
+	///   `ed25519`:
+	///   The file must contain an unencoded 32 byte or hex encoded Ed25519 secret key.
+	/// If the file does not exist, it is created with a newly generated secret key of
+	/// the chosen type.
+	#[arg(long, value_name = "FILE")]
+	pub node_key_file: Option<PathBuf>,
+}
+
+impl NodeKeyParams {
+	/// Create a `NodeKeyConfig` from the given `NodeKeyParams` in the context
+	/// of an optional network config storage directory.
+	pub fn node_key(&self, net_config_dir: &PathBuf) -> error::Result<NodeKeyConfig> {
+		Ok(match self.node_key_type {
+			NodeKeyType::Ed25519 => {
+				let secret = if let Some(node_key) = self.node_key.as_ref() {
+					parse_ed25519_secret(node_key)?
+				} else {
+					sc_network::config::Secret::File(
+						self.node_key_file
+							.clone()
+							.unwrap_or_else(|| net_config_dir.join(NODE_KEY_ED25519_FILE)),
+					)
+				};
+
+				NodeKeyConfig::Ed25519(secret)
+			},
+		})
+	}
+}
+
+/// Create an error caused by an invalid node key argument.
+fn invalid_node_key(e: impl std::fmt::Display) -> error::Error {
+	error::Error::Input(format!("Invalid node key: {}", e))
+}
+
+/// Parse a Ed25519 secret key from a hex string into a `sc_network::Secret`.
+fn parse_ed25519_secret(hex: &str) -> error::Result<sc_network::config::Ed25519Secret> {
+	H256::from_str(hex).map_err(invalid_node_key).and_then(|bytes| {
+		ed25519::SecretKey::try_from_bytes(bytes)
+			.map(sc_network::config::Secret::Input)
+			.map_err(invalid_node_key)
+	})
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use clap::ValueEnum;
+	use libp2p_identity::ed25519;
+	use std::fs;
+
+	#[test]
+	fn test_node_key_config_input() {
+		fn secret_input(net_config_dir: &PathBuf) -> error::Result<()> {
+			NodeKeyType::value_variants().iter().try_for_each(|t| {
+				let node_key_type = *t;
+				let sk = match node_key_type {
+					NodeKeyType::Ed25519 => ed25519::SecretKey::generate().as_ref().to_vec(),
+				};
+				let params = NodeKeyParams {
+					node_key_type,
+					node_key: Some(format!("{:x}", H256::from_slice(sk.as_ref()))),
+					node_key_file: None,
+				};
+				params.node_key(net_config_dir).and_then(|c| match c {
+					NodeKeyConfig::Ed25519(sc_network::config::Secret::Input(ref ski))
+						if node_key_type == NodeKeyType::Ed25519 && &sk[..] == ski.as_ref() =>
+						Ok(()),
+					_ => Err(error::Error::Input("Unexpected node key config".into())),
+				})
+			})
+		}
+
+		assert!(secret_input(&PathBuf::from_str("x").unwrap()).is_ok());
+	}
+
+	#[test]
+	fn test_node_key_config_file() {
+		fn check_key(file: PathBuf, key: &ed25519::SecretKey) {
+			let params = NodeKeyParams {
+				node_key_type: NodeKeyType::Ed25519,
+				node_key: None,
+				node_key_file: Some(file),
+			};
+
+			let node_key = params
+				.node_key(&PathBuf::from("not-used"))
+				.expect("Creates node key config")
+				.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 {
+				panic!("Invalid key")
+			}
+		}
+
+		let tmp = tempfile::Builder::new().prefix("alice").tempdir().expect("Creates tempfile");
+		let file = tmp.path().join("mysecret").to_path_buf();
+		let key = ed25519::SecretKey::generate();
+
+		fs::write(&file, array_bytes::bytes2hex("", key.as_ref())).expect("Writes secret key");
+		check_key(file.clone(), &key);
+
+		fs::write(&file, &key).expect("Writes secret key");
+		check_key(file.clone(), &key);
+	}
+
+	#[test]
+	fn test_node_key_config_default() {
+		fn with_def_params<F>(f: F) -> error::Result<()>
+		where
+			F: Fn(NodeKeyParams) -> error::Result<()>,
+		{
+			NodeKeyType::value_variants().iter().try_for_each(|t| {
+				let node_key_type = *t;
+				f(NodeKeyParams { node_key_type, node_key: None, node_key_file: None })
+			})
+		}
+
+		fn some_config_dir(net_config_dir: &PathBuf) -> error::Result<()> {
+			with_def_params(|params| {
+				let dir = PathBuf::from(net_config_dir.clone());
+				let typ = params.node_key_type;
+				params.node_key(net_config_dir).and_then(move |c| match c {
+					NodeKeyConfig::Ed25519(sc_network::config::Secret::File(ref f))
+						if typ == NodeKeyType::Ed25519 && f == &dir.join(NODE_KEY_ED25519_FILE) =>
+						Ok(()),
+					_ => Err(error::Error::Input("Unexpected node key config".into())),
+				})
+			})
+		}
+
+		assert!(some_config_dir(&PathBuf::from_str("x").unwrap()).is_ok());
+	}
+}
diff --git a/substrate/client/cli/src/params/offchain_worker_params.rs b/substrate/client/cli/src/params/offchain_worker_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d1fedab4cb2eba46e8c56c2043224e90a1dc597b
--- /dev/null
+++ b/substrate/client/cli/src/params/offchain_worker_params.rs
@@ -0,0 +1,65 @@
+// 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/>.
+
+//! Offchain worker related configuration parameters.
+//!
+//! A subset of configuration parameters which are relevant to
+//! the inner working of offchain workers. The usage is solely
+//! targeted at handling input parameter parsing providing
+//! a reasonable abstraction.
+
+use clap::{ArgAction, Args};
+use sc_network::config::Role;
+use sc_service::config::OffchainWorkerConfig;
+
+use crate::{error, OffchainWorkerEnabled};
+
+/// Offchain worker related parameters.
+#[derive(Debug, Clone, Args)]
+pub struct OffchainWorkerParams {
+	/// Should execute offchain workers on every block.
+	/// By default it's only enabled for nodes that are authoring new blocks.
+	#[arg(
+		long = "offchain-worker",
+		value_name = "ENABLED",
+		value_enum,
+		ignore_case = true,
+		default_value_t = OffchainWorkerEnabled::WhenAuthority
+	)]
+	pub enabled: OffchainWorkerEnabled,
+
+	/// Enable Offchain Indexing API, which allows block import to write to Offchain DB.
+	/// Enables a runtime to write directly to a offchain workers DB during block import.
+	#[arg(long = "enable-offchain-indexing", value_name = "ENABLE_OFFCHAIN_INDEXING", default_value_t = false, action = ArgAction::Set)]
+	pub indexing_enabled: bool,
+}
+
+impl OffchainWorkerParams {
+	/// Load spec to `Configuration` from `OffchainWorkerParams` and spec factory.
+	pub fn offchain_worker(&self, role: &Role) -> error::Result<OffchainWorkerConfig> {
+		let enabled = match (&self.enabled, role) {
+			(OffchainWorkerEnabled::WhenAuthority, Role::Authority { .. }) => true,
+			(OffchainWorkerEnabled::Always, _) => true,
+			(OffchainWorkerEnabled::Never, _) => false,
+			(OffchainWorkerEnabled::WhenAuthority, _) => false,
+		};
+
+		let indexing_enabled = self.indexing_enabled;
+		Ok(OffchainWorkerConfig { enabled, indexing_enabled })
+	}
+}
diff --git a/substrate/client/cli/src/params/prometheus_params.rs b/substrate/client/cli/src/params/prometheus_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d234ea33c20d0a1ea523636474581638852c63d
--- /dev/null
+++ b/substrate/client/cli/src/params/prometheus_params.rs
@@ -0,0 +1,61 @@
+// 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 clap::Args;
+use sc_service::config::PrometheusConfig;
+use std::net::{Ipv4Addr, SocketAddr};
+
+/// Parameters used to config prometheus.
+#[derive(Debug, Clone, Args)]
+pub struct PrometheusParams {
+	/// Specify Prometheus exporter TCP Port.
+	#[arg(long, value_name = "PORT")]
+	pub prometheus_port: Option<u16>,
+	/// Expose Prometheus exporter on all interfaces.
+	/// Default is local.
+	#[arg(long)]
+	pub prometheus_external: bool,
+	/// Do not expose a Prometheus exporter endpoint.
+	/// Prometheus metric endpoint is enabled by default.
+	#[arg(long)]
+	pub no_prometheus: bool,
+}
+
+impl PrometheusParams {
+	/// Creates [`PrometheusConfig`].
+	pub fn prometheus_config(
+		&self,
+		default_listen_port: u16,
+		chain_id: String,
+	) -> Option<PrometheusConfig> {
+		if self.no_prometheus {
+			None
+		} else {
+			let interface =
+				if self.prometheus_external { Ipv4Addr::UNSPECIFIED } else { Ipv4Addr::LOCALHOST };
+
+			Some(PrometheusConfig::new_with_default_registry(
+				SocketAddr::new(
+					interface.into(),
+					self.prometheus_port.unwrap_or(default_listen_port),
+				),
+				chain_id,
+			))
+		}
+	}
+}
diff --git a/substrate/client/cli/src/params/pruning_params.rs b/substrate/client/cli/src/params/pruning_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1b5bf247d942e66fa521aa867aace58db53cca1e
--- /dev/null
+++ b/substrate/client/cli/src/params/pruning_params.rs
@@ -0,0 +1,117 @@
+// 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::error;
+use clap::Args;
+use sc_service::{BlocksPruning, PruningMode};
+
+/// Parameters to define the pruning mode
+#[derive(Debug, Clone, Args)]
+pub struct PruningParams {
+	/// Specify the state pruning mode.
+	/// This mode specifies when the block's state (ie, storage)
+	/// 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.
+	/// 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.
+	/// [default: 256]
+	#[arg(alias = "pruning", long, value_name = "PRUNING_MODE")]
+	pub state_pruning: Option<DatabasePruningMode>,
+
+	/// Specify the blocks pruning mode.
+	/// 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.
+	#[arg(
+		alias = "keep-blocks",
+		long,
+		value_name = "PRUNING_MODE",
+		default_value = "archive-canonical"
+	)]
+	pub blocks_pruning: DatabasePruningMode,
+}
+
+impl PruningParams {
+	/// Get the pruning value from the parameters
+	pub fn state_pruning(&self) -> error::Result<Option<PruningMode>> {
+		Ok(self.state_pruning.map(|v| v.into()))
+	}
+
+	/// Get the block pruning value from the parameters
+	pub fn blocks_pruning(&self) -> error::Result<BlocksPruning> {
+		Ok(self.blocks_pruning.into())
+	}
+}
+
+/// Specifies the pruning mode of the database.
+///
+/// This specifies when the block's data (either state via `--state-pruning`
+/// or body via `--blocks-pruning`) should be pruned (ie, removed) from
+/// the database.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum DatabasePruningMode {
+	/// Keep the data of all blocks.
+	Archive,
+	/// Keep only the data of finalized blocks.
+	ArchiveCanonical,
+	/// Keep the data of the last number of finalized blocks.
+	Custom(u32),
+}
+
+impl std::str::FromStr for DatabasePruningMode {
+	type Err = String;
+
+	fn from_str(input: &str) -> Result<Self, Self::Err> {
+		match input {
+			"archive" => Ok(Self::Archive),
+			"archive-canonical" => Ok(Self::ArchiveCanonical),
+			bc => bc
+				.parse()
+				.map_err(|_| "Invalid pruning mode specified".to_string())
+				.map(Self::Custom),
+		}
+	}
+}
+
+impl Into<PruningMode> for DatabasePruningMode {
+	fn into(self) -> PruningMode {
+		match self {
+			DatabasePruningMode::Archive => PruningMode::ArchiveAll,
+			DatabasePruningMode::ArchiveCanonical => PruningMode::ArchiveCanonical,
+			DatabasePruningMode::Custom(n) => PruningMode::blocks_pruning(n),
+		}
+	}
+}
+
+impl Into<BlocksPruning> for DatabasePruningMode {
+	fn into(self) -> BlocksPruning {
+		match self {
+			DatabasePruningMode::Archive => BlocksPruning::KeepAll,
+			DatabasePruningMode::ArchiveCanonical => BlocksPruning::KeepFinalized,
+			DatabasePruningMode::Custom(n) => BlocksPruning::Some(n),
+		}
+	}
+}
diff --git a/substrate/client/cli/src/params/runtime_params.rs b/substrate/client/cli/src/params/runtime_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..79035fc7d4c5d7cf082969a4d709b8181bb176eb
--- /dev/null
+++ b/substrate/client/cli/src/params/runtime_params.rs
@@ -0,0 +1,43 @@
+// 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 clap::Args;
+use std::str::FromStr;
+
+/// Parameters used to config runtime.
+#[derive(Debug, Clone, Args)]
+pub struct RuntimeParams {
+	/// The size of the instances cache for each runtime. The values higher than 256 are illegal.
+	#[arg(long, default_value_t = 8, value_parser = parse_max_runtime_instances)]
+	pub max_runtime_instances: usize,
+
+	/// Maximum number of different runtimes that can be cached.
+	#[arg(long, default_value_t = 2)]
+	pub runtime_cache_size: u8,
+}
+
+fn parse_max_runtime_instances(s: &str) -> Result<usize, String> {
+	let max_runtime_instances = usize::from_str(s)
+		.map_err(|_err| format!("Illegal `--max-runtime-instances` value: {s}"))?;
+
+	if max_runtime_instances > 256 {
+		Err(format!("Illegal `--max-runtime-instances` value: {max_runtime_instances} is more than the allowed maximum of `256` "))
+	} else {
+		Ok(max_runtime_instances)
+	}
+}
diff --git a/substrate/client/cli/src/params/shared_params.rs b/substrate/client/cli/src/params/shared_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3d20ca504a6915207f37bda71ac8116fba3dd025
--- /dev/null
+++ b/substrate/client/cli/src/params/shared_params.rs
@@ -0,0 +1,134 @@
+// 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::arg_enums::TracingReceiver;
+use clap::Args;
+use sc_service::config::BasePath;
+use std::path::PathBuf;
+
+/// Shared parameters used by all `CoreParams`.
+#[derive(Debug, Clone, Args)]
+pub struct SharedParams {
+	/// Specify the chain specification.
+	/// It can be one of the predefined ones (dev, local, or staging) or it can be a path to a file
+	/// with the chainspec (such as one exported by the `build-spec` subcommand).
+	#[arg(long, value_name = "CHAIN_SPEC")]
+	pub chain: Option<String>,
+
+	/// Specify the development chain.
+	/// This flag sets `--chain=dev`, `--force-authoring`, `--rpc-cors=all`,
+	/// `--alice`, and `--tmp` flags, unless explicitly overridden.
+	#[arg(long, conflicts_with_all = &["chain"])]
+	pub dev: bool,
+
+	/// Specify custom base path.
+	#[arg(long, short = 'd', value_name = "PATH")]
+	pub base_path: Option<PathBuf>,
+
+	/// Sets a custom logging filter. Syntax is `<target>=<level>`, e.g. -lsync=debug.
+	/// Log levels (least to most verbose) are error, warn, info, debug, and trace.
+	/// By default, all targets log `info`. The global log level can be set with `-l<level>`.
+	#[arg(short = 'l', long, value_name = "LOG_PATTERN", num_args = 1..)]
+	pub log: Vec<String>,
+
+	/// Enable detailed log output.
+	/// This includes displaying the log target, log level and thread name.
+	/// This is automatically enabled when something is logged with any higher level than `info`.
+	#[arg(long)]
+	pub detailed_log_output: bool,
+
+	/// Disable log color output.
+	#[arg(long)]
+	pub disable_log_color: bool,
+
+	/// Enable feature to dynamically update and reload the log filter.
+	/// Be aware that enabling this feature can lead to a performance decrease up to factor six or
+	/// more. Depending on the global logging level the performance decrease changes.
+	/// The `system_addLogFilter` and `system_resetLogFilter` RPCs will have no effect with this
+	/// option not being set.
+	#[arg(long)]
+	pub enable_log_reloading: bool,
+
+	/// Sets a custom profiling filter. Syntax is the same as for logging: `<target>=<level>`.
+	#[arg(long, value_name = "TARGETS")]
+	pub tracing_targets: Option<String>,
+
+	/// Receiver to process tracing messages.
+	#[arg(long, value_name = "RECEIVER", value_enum, ignore_case = true, default_value_t = TracingReceiver::Log)]
+	pub tracing_receiver: TracingReceiver,
+}
+
+impl SharedParams {
+	/// Specify custom base path.
+	pub fn base_path(&self) -> Result<Option<BasePath>, crate::Error> {
+		match &self.base_path {
+			Some(r) => Ok(Some(r.clone().into())),
+			// If `dev` is enabled, we use the temp base path.
+			None if self.is_dev() => Ok(Some(BasePath::new_temp_dir()?)),
+			None => Ok(None),
+		}
+	}
+
+	/// Specify the development chain.
+	pub fn is_dev(&self) -> bool {
+		self.dev
+	}
+
+	/// Get the chain spec for the parameters provided
+	pub fn chain_id(&self, is_dev: bool) -> String {
+		match self.chain {
+			Some(ref chain) => chain.clone(),
+			None =>
+				if is_dev {
+					"dev".into()
+				} else {
+					"".into()
+				},
+		}
+	}
+
+	/// Get the filters for the logging
+	pub fn log_filters(&self) -> &[String] {
+		&self.log
+	}
+
+	/// Should the detailed log output be enabled.
+	pub fn detailed_log_output(&self) -> bool {
+		self.detailed_log_output
+	}
+
+	/// Should the log color output be disabled?
+	pub fn disable_log_color(&self) -> bool {
+		self.disable_log_color
+	}
+
+	/// Is log reloading enabled
+	pub fn enable_log_reloading(&self) -> bool {
+		self.enable_log_reloading
+	}
+
+	/// Receiver to process tracing messages.
+	pub fn tracing_receiver(&self) -> sc_service::TracingReceiver {
+		self.tracing_receiver.into()
+	}
+
+	/// Comma separated list of targets for tracing.
+	pub fn tracing_targets(&self) -> Option<String> {
+		self.tracing_targets.clone()
+	}
+}
diff --git a/substrate/client/cli/src/params/telemetry_params.rs b/substrate/client/cli/src/params/telemetry_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..67f441071410cae7c6f78be6e18944d3201b8f0d
--- /dev/null
+++ b/substrate/client/cli/src/params/telemetry_params.rs
@@ -0,0 +1,66 @@
+// 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 clap::Args;
+
+/// Parameters used to config telemetry.
+#[derive(Debug, Clone, Args)]
+pub struct TelemetryParams {
+	/// Disable connecting to the Substrate telemetry server.
+	/// Telemetry is on by default on global chains.
+	#[arg(long)]
+	pub no_telemetry: bool,
+
+	/// The URL of the telemetry server to connect to.
+	/// This flag can be passed multiple times as a means to specify multiple
+	/// telemetry endpoints. Verbosity levels range from 0-9, with 0 denoting
+	/// the least verbosity.
+	/// Expected format is 'URL VERBOSITY', e.g. `--telemetry-url 'wss://foo/bar 0'`.
+	#[arg(long = "telemetry-url", value_name = "URL VERBOSITY", value_parser = parse_telemetry_endpoints)]
+	pub telemetry_endpoints: Vec<(String, u8)>,
+}
+
+#[derive(Debug)]
+enum TelemetryParsingError {
+	MissingVerbosity,
+	VerbosityParsingError(std::num::ParseIntError),
+}
+
+impl std::error::Error for TelemetryParsingError {}
+
+impl std::fmt::Display for TelemetryParsingError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			TelemetryParsingError::MissingVerbosity => write!(f, "Verbosity level missing"),
+			TelemetryParsingError::VerbosityParsingError(e) => write!(f, "{}", e),
+		}
+	}
+}
+
+fn parse_telemetry_endpoints(s: &str) -> Result<(String, u8), TelemetryParsingError> {
+	let pos = s.find(' ');
+	match pos {
+		None => Err(TelemetryParsingError::MissingVerbosity),
+		Some(pos_) => {
+			let url = s[..pos_].to_string();
+			let verbosity =
+				s[pos_ + 1..].parse().map_err(TelemetryParsingError::VerbosityParsingError)?;
+			Ok((url, verbosity))
+		},
+	}
+}
diff --git a/substrate/client/cli/src/params/transaction_pool_params.rs b/substrate/client/cli/src/params/transaction_pool_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b2bf0b9b364c801c12d6aee8ee1d28007b24cc4a
--- /dev/null
+++ b/substrate/client/cli/src/params/transaction_pool_params.rs
@@ -0,0 +1,62 @@
+// 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 clap::Args;
+use sc_service::config::TransactionPoolOptions;
+
+/// Parameters used to create the pool configuration.
+#[derive(Debug, Clone, Args)]
+pub struct TransactionPoolParams {
+	/// Maximum number of transactions in the transaction pool.
+	#[arg(long, value_name = "COUNT", default_value_t = 8192)]
+	pub pool_limit: usize,
+
+	/// Maximum number of kilobytes of all transactions stored in the pool.
+	#[arg(long, value_name = "COUNT", default_value_t = 20480)]
+	pub pool_kbytes: usize,
+
+	/// How long a transaction is banned for, if it is considered invalid. Defaults to 1800s.
+	#[arg(long, value_name = "SECONDS")]
+	pub tx_ban_seconds: Option<u64>,
+}
+
+impl TransactionPoolParams {
+	/// Fill the given `PoolConfiguration` by looking at the cli parameters.
+	pub fn transaction_pool(&self, is_dev: bool) -> TransactionPoolOptions {
+		let mut opts = TransactionPoolOptions::default();
+
+		// ready queue
+		opts.ready.count = self.pool_limit;
+		opts.ready.total_bytes = self.pool_kbytes * 1024;
+
+		// future queue
+		let factor = 10;
+		opts.future.count = self.pool_limit / factor;
+		opts.future.total_bytes = self.pool_kbytes * 1024 / factor;
+
+		opts.ban_time = if let Some(ban_seconds) = self.tx_ban_seconds {
+			std::time::Duration::from_secs(ban_seconds)
+		} else if is_dev {
+			std::time::Duration::from_secs(0)
+		} else {
+			std::time::Duration::from_secs(30 * 60)
+		};
+
+		opts
+	}
+}
diff --git a/substrate/client/cli/src/runner.rs b/substrate/client/cli/src/runner.rs
new file mode 100644
index 0000000000000000000000000000000000000000..59f53200a192bce80a0e5b151ce78db26f87c195
--- /dev/null
+++ b/substrate/client/cli/src/runner.rs
@@ -0,0 +1,413 @@
+// 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::{error::Error as CliError, Result, Signals, SubstrateCli};
+use chrono::prelude::*;
+use futures::{future::FutureExt, Future};
+use log::info;
+use sc_service::{Configuration, Error as ServiceError, TaskManager};
+use sc_utils::metrics::{TOKIO_THREADS_ALIVE, TOKIO_THREADS_TOTAL};
+use std::{marker::PhantomData, time::Duration};
+
+/// Build a tokio runtime with all features.
+pub fn build_runtime() -> std::result::Result<tokio::runtime::Runtime, std::io::Error> {
+	tokio::runtime::Builder::new_multi_thread()
+		.on_thread_start(|| {
+			TOKIO_THREADS_ALIVE.inc();
+			TOKIO_THREADS_TOTAL.inc();
+		})
+		.on_thread_stop(|| {
+			TOKIO_THREADS_ALIVE.dec();
+		})
+		.enable_all()
+		.build()
+}
+
+/// A Substrate CLI runtime that can be used to run a node or a command
+pub struct Runner<C: SubstrateCli> {
+	config: Configuration,
+	tokio_runtime: tokio::runtime::Runtime,
+	signals: Signals,
+	phantom: PhantomData<C>,
+}
+
+impl<C: SubstrateCli> Runner<C> {
+	/// Create a new runtime with the command provided in argument
+	pub fn new(
+		config: Configuration,
+		tokio_runtime: tokio::runtime::Runtime,
+		signals: Signals,
+	) -> Result<Runner<C>> {
+		Ok(Runner { config, tokio_runtime, signals, phantom: PhantomData })
+	}
+
+	/// Log information about the node itself.
+	///
+	/// # Example:
+	///
+	/// ```text
+	/// 2020-06-03 16:14:21 Substrate Node
+	/// 2020-06-03 16:14:21 ✌�  version 2.0.0-rc3-f4940588c-x86_64-linux-gnu
+	/// 2020-06-03 16:14:21 ��  by Parity Technologies <admin@parity.io>, 2017-2020
+	/// 2020-06-03 16:14:21 📋 Chain specification: Flaming Fir
+	/// 2020-06-03 16:14:21 �  Node name: jolly-rod-7462
+	/// 2020-06-03 16:14:21 👤 Role: FULL
+	/// 2020-06-03 16:14:21 💾 Database: RocksDb at /tmp/c/chains/flamingfir7/db
+	/// 2020-06-03 16:14:21 ⛓  Native runtime: node-251 (substrate-node-1.tx1.au10)
+	/// ```
+	fn print_node_infos(&self) {
+		print_node_infos::<C>(self.config())
+	}
+
+	/// A helper function that runs a node with tokio and stops if the process receives the signal
+	/// `SIGTERM` or `SIGINT`.
+	pub fn run_node_until_exit<F, E>(
+		self,
+		initialize: impl FnOnce(Configuration) -> F,
+	) -> std::result::Result<(), E>
+	where
+		F: Future<Output = std::result::Result<TaskManager, E>>,
+		E: std::error::Error + Send + Sync + 'static + From<ServiceError>,
+	{
+		self.print_node_infos();
+
+		let mut task_manager = self.tokio_runtime.block_on(initialize(self.config))?;
+
+		let res = self
+			.tokio_runtime
+			.block_on(self.signals.run_until_signal(task_manager.future().fuse()));
+		// We need to drop the task manager here to inform all tasks that they should shut down.
+		//
+		// This is important to be done before we instruct the tokio runtime to shutdown. Otherwise
+		// the tokio runtime will wait the full 60 seconds for all tasks to stop.
+		let task_registry = task_manager.into_task_registry();
+
+		// Give all futures 60 seconds to shutdown, before tokio "leaks" them.
+		let shutdown_timeout = Duration::from_secs(60);
+		self.tokio_runtime.shutdown_timeout(shutdown_timeout);
+
+		let running_tasks = task_registry.running_tasks();
+
+		if !running_tasks.is_empty() {
+			log::error!("Detected running(potentially stalled) tasks on shutdown:");
+			running_tasks.iter().for_each(|(task, count)| {
+				let instances_desc =
+					if *count > 1 { format!("with {} instances ", count) } else { "".to_string() };
+
+				if task.is_default_group() {
+					log::error!(
+						"Task \"{}\" was still running {}after waiting {} seconds to finish.",
+						task.name,
+						instances_desc,
+						shutdown_timeout.as_secs(),
+					);
+				} else {
+					log::error!(
+						"Task \"{}\" (Group: {}) was still running {}after waiting {} seconds to finish.",
+						task.name,
+						task.group,
+						instances_desc,
+						shutdown_timeout.as_secs(),
+					);
+				}
+			});
+		}
+
+		res.map_err(Into::into)
+	}
+
+	/// A helper function that runs a command with the configuration of this node.
+	pub fn sync_run<E>(
+		self,
+		runner: impl FnOnce(Configuration) -> std::result::Result<(), E>,
+	) -> std::result::Result<(), E>
+	where
+		E: std::error::Error + Send + Sync + 'static + From<ServiceError>,
+	{
+		runner(self.config)
+	}
+
+	/// A helper function that runs a future with tokio and stops if the process receives
+	/// the signal `SIGTERM` or `SIGINT`.
+	pub fn async_run<F, E>(
+		self,
+		runner: impl FnOnce(Configuration) -> std::result::Result<(F, TaskManager), E>,
+	) -> std::result::Result<(), E>
+	where
+		F: Future<Output = std::result::Result<(), E>>,
+		E: std::error::Error + Send + Sync + 'static + From<ServiceError> + From<CliError>,
+	{
+		let (future, task_manager) = runner(self.config)?;
+		self.tokio_runtime.block_on(self.signals.run_until_signal(future.fuse()))?;
+		// Drop the task manager before dropping the rest, to ensure that all futures were informed
+		// about the shut down.
+		drop(task_manager);
+		Ok(())
+	}
+
+	/// Get an immutable reference to the node Configuration
+	pub fn config(&self) -> &Configuration {
+		&self.config
+	}
+
+	/// Get a mutable reference to the node Configuration
+	pub fn config_mut(&mut self) -> &mut Configuration {
+		&mut self.config
+	}
+}
+
+/// Log information about the node itself.
+pub fn print_node_infos<C: SubstrateCli>(config: &Configuration) {
+	info!("{}", C::impl_name());
+	info!("✌�  version {}", C::impl_version());
+	info!("��  by {}, {}-{}", C::author(), C::copyright_start_year(), Local::now().year());
+	info!("📋 Chain specification: {}", config.chain_spec.name());
+	info!("�  Node name: {}", config.network.node_name);
+	info!("👤 Role: {}", config.display_role());
+	info!(
+		"💾 Database: {} at {}",
+		config.database,
+		config
+			.database
+			.path()
+			.map_or_else(|| "<unknown>".to_owned(), |p| p.display().to_string())
+	);
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_network::config::NetworkConfiguration;
+	use sc_service::{Arc, ChainType, GenericChainSpec, NoExtension};
+	use std::{
+		path::PathBuf,
+		sync::atomic::{AtomicU64, Ordering},
+	};
+
+	struct Cli;
+
+	impl SubstrateCli for Cli {
+		fn author() -> String {
+			"test".into()
+		}
+
+		fn impl_name() -> String {
+			"yep".into()
+		}
+
+		fn impl_version() -> String {
+			"version".into()
+		}
+
+		fn description() -> String {
+			"desc".into()
+		}
+
+		fn support_url() -> String {
+			"no.pe".into()
+		}
+
+		fn copyright_start_year() -> i32 {
+			2042
+		}
+
+		fn load_spec(
+			&self,
+			_: &str,
+		) -> std::result::Result<Box<dyn sc_service::ChainSpec>, String> {
+			Err("nope".into())
+		}
+	}
+
+	fn create_runner() -> Runner<Cli> {
+		let runtime = build_runtime().unwrap();
+
+		let root = PathBuf::from("db");
+		let runner = Runner::new(
+			Configuration {
+				impl_name: "spec".into(),
+				impl_version: "3".into(),
+				role: sc_service::Role::Authority,
+				tokio_handle: runtime.handle().clone(),
+				transaction_pool: Default::default(),
+				network: NetworkConfiguration::new_memory(),
+				keystore: sc_service::config::KeystoreConfig::InMemory,
+				database: sc_client_db::DatabaseSource::ParityDb { path: root.clone() },
+				trie_cache_maximum_size: None,
+				state_pruning: None,
+				blocks_pruning: sc_client_db::BlocksPruning::KeepAll,
+				chain_spec: Box::new(GenericChainSpec::from_genesis(
+					"test",
+					"test_id",
+					ChainType::Development,
+					|| unimplemented!("Not required in tests"),
+					Vec::new(),
+					None,
+					None,
+					None,
+					None,
+					NoExtension::None,
+				)),
+				wasm_method: Default::default(),
+				wasm_runtime_overrides: None,
+				rpc_addr: None,
+				rpc_max_connections: Default::default(),
+				rpc_cors: None,
+				rpc_methods: Default::default(),
+				rpc_max_request_size: Default::default(),
+				rpc_max_response_size: Default::default(),
+				rpc_id_provider: Default::default(),
+				rpc_max_subs_per_conn: Default::default(),
+				rpc_port: 9944,
+				prometheus_config: None,
+				telemetry_endpoints: None,
+				default_heap_pages: None,
+				offchain_worker: Default::default(),
+				force_authoring: false,
+				disable_grandpa: false,
+				dev_key_seed: None,
+				tracing_targets: None,
+				tracing_receiver: Default::default(),
+				max_runtime_instances: 8,
+				announce_block: true,
+				base_path: sc_service::BasePath::new(root.clone()),
+				data_path: root,
+				informant_output_format: Default::default(),
+				runtime_cache_size: 2,
+			},
+			runtime,
+			Signals::dummy(),
+		)
+		.unwrap();
+
+		runner
+	}
+
+	#[test]
+	fn ensure_run_until_exit_informs_tasks_to_end() {
+		let runner = create_runner();
+
+		let counter = Arc::new(AtomicU64::new(0));
+		let counter2 = counter.clone();
+
+		runner
+			.run_node_until_exit(move |cfg| async move {
+				let task_manager = TaskManager::new(cfg.tokio_handle.clone(), None).unwrap();
+				let (sender, receiver) = futures::channel::oneshot::channel();
+
+				// We need to use `spawn_blocking` here so that we get a dedicated thread for our
+				// future. This is important for this test, as otherwise tokio can just "drop" the
+				// future.
+				task_manager.spawn_handle().spawn_blocking("test", None, async move {
+					let _ = sender.send(());
+					loop {
+						counter2.fetch_add(1, Ordering::Relaxed);
+						futures_timer::Delay::new(Duration::from_millis(50)).await;
+					}
+				});
+
+				task_manager.spawn_essential_handle().spawn_blocking("test2", None, async {
+					// Let's stop this essential task directly when our other task started.
+					// It will signal that the task manager should end.
+					let _ = receiver.await;
+				});
+
+				Ok::<_, sc_service::Error>(task_manager)
+			})
+			.unwrap_err();
+
+		let count = counter.load(Ordering::Relaxed);
+
+		// Ensure that our counting task was running for less than 30 seconds.
+		// It should be directly killed, but for CI and whatever we are being a little bit more
+		// "relaxed".
+		assert!((count as u128) < (Duration::from_secs(30).as_millis() / 50));
+	}
+
+	fn run_test_in_another_process(
+		test_name: &str,
+		test_body: impl FnOnce(),
+	) -> Option<std::process::Output> {
+		if std::env::var("RUN_FORKED_TEST").is_ok() {
+			test_body();
+			None
+		} else {
+			let output = std::process::Command::new(std::env::current_exe().unwrap())
+				.arg(test_name)
+				.env("RUN_FORKED_TEST", "1")
+				.output()
+				.unwrap();
+
+			assert!(output.status.success());
+			Some(output)
+		}
+	}
+
+	/// This test ensures that `run_node_until_exit` aborts waiting for "stuck" tasks after 60
+	/// seconds, aka doesn't wait until they are finished (which may never happen).
+	#[test]
+	fn ensure_run_until_exit_is_not_blocking_indefinitely() {
+		let output = run_test_in_another_process(
+			"ensure_run_until_exit_is_not_blocking_indefinitely",
+			|| {
+				sp_tracing::try_init_simple();
+
+				let runner = create_runner();
+
+				runner
+					.run_node_until_exit(move |cfg| async move {
+						let task_manager =
+							TaskManager::new(cfg.tokio_handle.clone(), None).unwrap();
+						let (sender, receiver) = futures::channel::oneshot::channel();
+
+						// We need to use `spawn_blocking` here so that we get a dedicated thread
+						// for our future. This future is more blocking code that will never end.
+						task_manager.spawn_handle().spawn_blocking("test", None, async move {
+							let _ = sender.send(());
+							loop {
+								std::thread::sleep(Duration::from_secs(30));
+							}
+						});
+
+						task_manager.spawn_essential_handle().spawn_blocking(
+							"test2",
+							None,
+							async {
+								// Let's stop this essential task directly when our other task
+								// started. It will signal that the task manager should end.
+								let _ = receiver.await;
+							},
+						);
+
+						Ok::<_, sc_service::Error>(task_manager)
+					})
+					.unwrap_err();
+			},
+		);
+
+		let Some(output) = output else { return };
+
+		let stderr = dbg!(String::from_utf8(output.stderr).unwrap());
+
+		assert!(
+			stderr.contains("Task \"test\" was still running after waiting 60 seconds to finish.")
+		);
+		assert!(!stderr
+			.contains("Task \"test2\" was still running after waiting 60 seconds to finish."));
+	}
+}
diff --git a/substrate/client/cli/src/signals.rs b/substrate/client/cli/src/signals.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b6a6f957a766b83282b44b86c826fe16a6c4956
--- /dev/null
+++ b/substrate/client/cli/src/signals.rs
@@ -0,0 +1,92 @@
+// 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 futures::{
+	future::{self, BoxFuture, FutureExt},
+	pin_mut, select, Future,
+};
+
+use sc_service::Error as ServiceError;
+
+/// Abstraction over OS signals to handle the shutdown of the node smoothly.
+///
+/// On `unix` this represents `SigInt` and `SigTerm`.
+pub struct Signals(BoxFuture<'static, ()>);
+
+impl Signals {
+	/// Return the signals future.
+	pub fn future(self) -> BoxFuture<'static, ()> {
+		self.0
+	}
+
+	/// Capture the relevant signals to handle shutdown of the node smoothly.
+	///
+	/// Needs to be called in a Tokio context to have access to the tokio reactor.
+	#[cfg(target_family = "unix")]
+	pub fn capture() -> std::result::Result<Self, ServiceError> {
+		use tokio::signal::unix::{signal, SignalKind};
+
+		let mut stream_int = signal(SignalKind::interrupt()).map_err(ServiceError::Io)?;
+		let mut stream_term = signal(SignalKind::terminate()).map_err(ServiceError::Io)?;
+
+		Ok(Signals(
+			async move {
+				future::select(stream_int.recv().boxed(), stream_term.recv().boxed()).await;
+			}
+			.boxed(),
+		))
+	}
+
+	/// Capture the relevant signals to handle shutdown of the node smoothly.
+	///
+	/// Needs to be called in a Tokio context to have access to the tokio reactor.
+	#[cfg(not(unix))]
+	pub fn capture() -> Result<Self, ServiceError> {
+		use tokio::signal::ctrl_c;
+
+		Ok(Signals(
+			async move {
+				let _ = ctrl_c().await;
+			}
+			.boxed(),
+		))
+	}
+
+	/// A dummy signal that never returns.
+	pub fn dummy() -> Self {
+		Self(future::pending().boxed())
+	}
+
+	/// Run a future task until receive a signal.
+	pub async fn run_until_signal<F, E>(self, func: F) -> Result<(), E>
+	where
+		F: Future<Output = Result<(), E>> + future::FusedFuture,
+		E: std::error::Error + Send + Sync + 'static,
+	{
+		let signals = self.future().fuse();
+
+		pin_mut!(func, signals);
+
+		select! {
+			_ = signals => {},
+			res = func => res?,
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/client/consensus/aura/Cargo.toml b/substrate/client/consensus/aura/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..70581e8c80d5e74fe9c19de72134357cc12a7f24
--- /dev/null
+++ b/substrate/client/consensus/aura/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "sc-consensus-aura"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Aura consensus algorithm for substrate"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+log = "0.4.17"
+thiserror = "1.0"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-consensus-slots = { version = "0.10.0-dev", path = "../slots" }
+sc-telemetry = { version = "4.0.0-dev", path = "../../telemetry" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-application-crypto = { version = "23.0.0", path = "../../../primitives/application-crypto" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../../primitives/block-builder" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-aura = { version = "0.10.0-dev", path = "../../../primitives/consensus/aura" }
+sp-consensus-slots = { version = "0.10.0-dev", path = "../../../primitives/consensus/slots" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+parking_lot = "0.12.1"
+tempfile = "3.1.0"
+sc-keystore = { version = "4.0.0-dev", path = "../../keystore" }
+sc-network = { version = "0.10.0-dev", path = "../../network" }
+sc-network-test = { version = "0.8.0", path = "../../network/test" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+sp-timestamp = { version = "4.0.0-dev", path = "../../../primitives/timestamp" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
+tokio = { version = "1.22.0" }
diff --git a/substrate/client/consensus/aura/README.md b/substrate/client/consensus/aura/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..85d82cd7dfd3b4e392c8210c40a32a6e57508413
--- /dev/null
+++ b/substrate/client/consensus/aura/README.md
@@ -0,0 +1,15 @@
+Aura (Authority-round) consensus in substrate.
+
+Aura works by having a list of authorities A who are expected to roughly
+agree on the current time. Time is divided up into discrete slots of t
+seconds each. For each slot s, the author of that slot is A[s % |A|].
+
+The author is allowed to issue one block but not more during that slot,
+and it will be built upon the longest valid chain that has been seen.
+
+Blocks from future steps will be either deferred or rejected depending on how
+far in the future they are.
+
+NOTE: Aura itself is designed to be generic over the crypto used.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/aura/src/import_queue.rs b/substrate/client/consensus/aura/src/import_queue.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a8777ef8788cc3a247d6d09c146f61bf4cb23e62
--- /dev/null
+++ b/substrate/client/consensus/aura/src/import_queue.rs
@@ -0,0 +1,415 @@
+// 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/>.
+
+//! Module implementing the logic for verifying and importing AuRa blocks.
+
+use crate::{
+	authorities, standalone::SealVerificationError, AuthorityId, CompatibilityMode, Error,
+	LOG_TARGET,
+};
+use codec::Codec;
+use log::{debug, info, trace};
+use prometheus_endpoint::Registry;
+use sc_client_api::{backend::AuxStore, BlockOf, UsageProvider};
+use sc_consensus::{
+	block_import::{BlockImport, BlockImportParams, ForkChoiceStrategy},
+	import_queue::{BasicQueue, BoxJustificationImport, DefaultImportQueue, Verifier},
+};
+use sc_consensus_slots::{check_equivocation, CheckedHeader, InherentDataProviderExt};
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_TRACE};
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_block_builder::BlockBuilder as BlockBuilderApi;
+use sp_blockchain::HeaderBackend;
+use sp_consensus::Error as ConsensusError;
+use sp_consensus_aura::{inherents::AuraInherentData, AuraApi};
+use sp_consensus_slots::Slot;
+use sp_core::crypto::Pair;
+use sp_inherents::{CreateInherentDataProviders, InherentDataProvider as _};
+use sp_runtime::{
+	traits::{Block as BlockT, Header, NumberFor},
+	DigestItem,
+};
+use std::{fmt::Debug, marker::PhantomData, sync::Arc};
+
+/// check a header has been signed by the right key. If the slot is too far in the future, an error
+/// will be returned. If it's successful, returns the pre-header and the digest item
+/// containing the seal.
+///
+/// This digest item will always return `Some` when used with `as_aura_seal`.
+fn check_header<C, B: BlockT, P: Pair>(
+	client: &C,
+	slot_now: Slot,
+	header: B::Header,
+	hash: B::Hash,
+	authorities: &[AuthorityId<P>],
+	check_for_equivocation: CheckForEquivocation,
+) -> Result<CheckedHeader<B::Header, (Slot, DigestItem)>, Error<B>>
+where
+	P::Public: Codec,
+	P::Signature: Codec,
+	C: sc_client_api::backend::AuxStore,
+{
+	let check_result =
+		crate::standalone::check_header_slot_and_seal::<B, P>(slot_now, header, authorities);
+
+	match check_result {
+		Ok((header, slot, seal)) => {
+			let expected_author = crate::standalone::slot_author::<P>(slot, &authorities);
+			let should_equiv_check = check_for_equivocation.check_for_equivocation();
+			if let (true, Some(expected)) = (should_equiv_check, expected_author) {
+				if let Some(equivocation_proof) =
+					check_equivocation(client, slot_now, slot, &header, expected)
+						.map_err(Error::Client)?
+				{
+					info!(
+						target: LOG_TARGET,
+						"Slot author is equivocating at slot {} with headers {:?} and {:?}",
+						slot,
+						equivocation_proof.first_header.hash(),
+						equivocation_proof.second_header.hash(),
+					);
+				}
+			}
+
+			Ok(CheckedHeader::Checked(header, (slot, seal)))
+		},
+		Err(SealVerificationError::Deferred(header, slot)) =>
+			Ok(CheckedHeader::Deferred(header, slot)),
+		Err(SealVerificationError::Unsealed) => Err(Error::HeaderUnsealed(hash)),
+		Err(SealVerificationError::BadSeal) => Err(Error::HeaderBadSeal(hash)),
+		Err(SealVerificationError::BadSignature) => Err(Error::BadSignature(hash)),
+		Err(SealVerificationError::SlotAuthorNotFound) => Err(Error::SlotAuthorNotFound),
+		Err(SealVerificationError::InvalidPreDigest(e)) => Err(Error::from(e)),
+	}
+}
+
+/// A verifier for Aura blocks.
+pub struct AuraVerifier<C, P, CIDP, N> {
+	client: Arc<C>,
+	create_inherent_data_providers: CIDP,
+	check_for_equivocation: CheckForEquivocation,
+	telemetry: Option<TelemetryHandle>,
+	compatibility_mode: CompatibilityMode<N>,
+	_phantom: PhantomData<fn() -> P>,
+}
+
+impl<C, P, CIDP, N> AuraVerifier<C, P, CIDP, N> {
+	pub(crate) fn new(
+		client: Arc<C>,
+		create_inherent_data_providers: CIDP,
+		check_for_equivocation: CheckForEquivocation,
+		telemetry: Option<TelemetryHandle>,
+		compatibility_mode: CompatibilityMode<N>,
+	) -> Self {
+		Self {
+			client,
+			create_inherent_data_providers,
+			check_for_equivocation,
+			telemetry,
+			compatibility_mode,
+			_phantom: PhantomData,
+		}
+	}
+}
+
+impl<C, P, CIDP, N> AuraVerifier<C, P, CIDP, N>
+where
+	CIDP: Send,
+{
+	async fn check_inherents<B: BlockT>(
+		&self,
+		block: B,
+		at_hash: B::Hash,
+		inherent_data: sp_inherents::InherentData,
+		create_inherent_data_providers: CIDP::InherentDataProviders,
+	) -> Result<(), Error<B>>
+	where
+		C: ProvideRuntimeApi<B>,
+		C::Api: BlockBuilderApi<B>,
+		CIDP: CreateInherentDataProviders<B, ()>,
+	{
+		let inherent_res = self
+			.client
+			.runtime_api()
+			.check_inherents(at_hash, block, inherent_data)
+			.map_err(|e| Error::Client(e.into()))?;
+
+		if !inherent_res.ok() {
+			for (i, e) in inherent_res.into_errors() {
+				match create_inherent_data_providers.try_handle_error(&i, &e).await {
+					Some(res) => res.map_err(Error::Inherent)?,
+					None => return Err(Error::UnknownInherentError(i)),
+				}
+			}
+		}
+
+		Ok(())
+	}
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT, C, P, CIDP> Verifier<B> for AuraVerifier<C, P, CIDP, NumberFor<B>>
+where
+	C: ProvideRuntimeApi<B> + Send + Sync + sc_client_api::backend::AuxStore,
+	C::Api: BlockBuilderApi<B> + AuraApi<B, AuthorityId<P>> + ApiExt<B>,
+	P: Pair,
+	P::Public: Codec + Debug,
+	P::Signature: Codec,
+	CIDP: CreateInherentDataProviders<B, ()> + Send + Sync,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
+{
+	async fn verify(
+		&mut self,
+		mut block: BlockImportParams<B>,
+	) -> Result<BlockImportParams<B>, String> {
+		// Skip checks that include execution, if being told so or when importing only state.
+		//
+		// This is done for example when gap syncing and it is expected that the block after the gap
+		// was checked/chosen properly, e.g. by warp syncing to this block using a finality proof.
+		// Or when we are importing state only and can not verify the seal.
+		if block.with_state() || block.state_action.skip_execution_checks() {
+			// When we are importing only the state of a block, it will be the best block.
+			block.fork_choice = Some(ForkChoiceStrategy::Custom(block.with_state()));
+
+			return Ok(block)
+		}
+
+		let hash = block.header.hash();
+		let parent_hash = *block.header.parent_hash();
+		let authorities = authorities(
+			self.client.as_ref(),
+			parent_hash,
+			*block.header.number(),
+			&self.compatibility_mode,
+		)
+		.map_err(|e| format!("Could not fetch authorities at {:?}: {}", parent_hash, e))?;
+
+		let create_inherent_data_providers = self
+			.create_inherent_data_providers
+			.create_inherent_data_providers(parent_hash, ())
+			.await
+			.map_err(|e| Error::<B>::Client(sp_blockchain::Error::Application(e)))?;
+
+		let mut inherent_data = create_inherent_data_providers
+			.create_inherent_data()
+			.await
+			.map_err(Error::<B>::Inherent)?;
+
+		let slot_now = create_inherent_data_providers.slot();
+
+		// we add one to allow for some small drift.
+		// FIXME #1019 in the future, alter this queue to allow deferring of
+		// headers
+		let checked_header = check_header::<C, B, P>(
+			&self.client,
+			slot_now + 1,
+			block.header,
+			hash,
+			&authorities[..],
+			self.check_for_equivocation,
+		)
+		.map_err(|e| e.to_string())?;
+		match checked_header {
+			CheckedHeader::Checked(pre_header, (slot, seal)) => {
+				// if the body is passed through, we need to use the runtime
+				// to check that the internally-set timestamp in the inherents
+				// actually matches the slot set in the seal.
+				if let Some(inner_body) = block.body.take() {
+					let new_block = B::new(pre_header.clone(), inner_body);
+
+					inherent_data.aura_replace_inherent_data(slot);
+
+					// skip the inherents verification if the runtime API is old or not expected to
+					// exist.
+					if self
+						.client
+						.runtime_api()
+						.has_api_with::<dyn BlockBuilderApi<B>, _>(parent_hash, |v| v >= 2)
+						.map_err(|e| e.to_string())?
+					{
+						self.check_inherents(
+							new_block.clone(),
+							parent_hash,
+							inherent_data,
+							create_inherent_data_providers,
+						)
+						.await
+						.map_err(|e| e.to_string())?;
+					}
+
+					let (_, inner_body) = new_block.deconstruct();
+					block.body = Some(inner_body);
+				}
+
+				trace!(target: LOG_TARGET, "Checked {:?}; importing.", pre_header);
+				telemetry!(
+					self.telemetry;
+					CONSENSUS_TRACE;
+					"aura.checked_and_importing";
+					"pre_header" => ?pre_header,
+				);
+
+				block.header = pre_header;
+				block.post_digests.push(seal);
+				block.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+				block.post_hash = Some(hash);
+
+				Ok(block)
+			},
+			CheckedHeader::Deferred(a, b) => {
+				debug!(target: LOG_TARGET, "Checking {:?} failed; {:?}, {:?}.", hash, a, b);
+				telemetry!(
+					self.telemetry;
+					CONSENSUS_DEBUG;
+					"aura.header_too_far_in_future";
+					"hash" => ?hash,
+					"a" => ?a,
+					"b" => ?b,
+				);
+				Err(format!("Header {:?} rejected: too far in the future", hash))
+			},
+		}
+	}
+}
+
+/// Should we check for equivocation of a block author?
+#[derive(Debug, Clone, Copy)]
+pub enum CheckForEquivocation {
+	/// Yes, check for equivocation.
+	///
+	/// This is the default setting for this.
+	Yes,
+	/// No, don't check for equivocation.
+	No,
+}
+
+impl CheckForEquivocation {
+	/// Should we check for equivocation?
+	fn check_for_equivocation(self) -> bool {
+		matches!(self, Self::Yes)
+	}
+}
+
+impl Default for CheckForEquivocation {
+	fn default() -> Self {
+		Self::Yes
+	}
+}
+
+/// Parameters of [`import_queue`].
+pub struct ImportQueueParams<'a, Block: BlockT, I, C, S, CIDP> {
+	/// The block import to use.
+	pub block_import: I,
+	/// The justification import.
+	pub justification_import: Option<BoxJustificationImport<Block>>,
+	/// The client to interact with the chain.
+	pub client: Arc<C>,
+	/// Something that can create the inherent data providers.
+	pub create_inherent_data_providers: CIDP,
+	/// The spawner to spawn background tasks.
+	pub spawner: &'a S,
+	/// The prometheus registry.
+	pub registry: Option<&'a Registry>,
+	/// Should we check for equivocation?
+	pub check_for_equivocation: CheckForEquivocation,
+	/// Telemetry instance used to report telemetry metrics.
+	pub telemetry: Option<TelemetryHandle>,
+	/// Compatibility mode that should be used.
+	///
+	/// If in doubt, use `Default::default()`.
+	pub compatibility_mode: CompatibilityMode<NumberFor<Block>>,
+}
+
+/// Start an import queue for the Aura consensus algorithm.
+pub fn import_queue<P, Block, I, C, S, CIDP>(
+	ImportQueueParams {
+		block_import,
+		justification_import,
+		client,
+		create_inherent_data_providers,
+		spawner,
+		registry,
+		check_for_equivocation,
+		telemetry,
+		compatibility_mode,
+	}: ImportQueueParams<Block, I, C, S, CIDP>,
+) -> Result<DefaultImportQueue<Block>, sp_consensus::Error>
+where
+	Block: BlockT,
+	C::Api: BlockBuilderApi<Block> + AuraApi<Block, AuthorityId<P>> + ApiExt<Block>,
+	C: 'static
+		+ ProvideRuntimeApi<Block>
+		+ BlockOf
+		+ Send
+		+ Sync
+		+ AuxStore
+		+ UsageProvider<Block>
+		+ HeaderBackend<Block>,
+	I: BlockImport<Block, Error = ConsensusError> + Send + Sync + 'static,
+	P: Pair + 'static,
+	P::Public: Codec + Debug,
+	P::Signature: Codec,
+	S: sp_core::traits::SpawnEssentialNamed,
+	CIDP: CreateInherentDataProviders<Block, ()> + Sync + Send + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
+{
+	let verifier = build_verifier::<P, _, _, _>(BuildVerifierParams {
+		client,
+		create_inherent_data_providers,
+		check_for_equivocation,
+		telemetry,
+		compatibility_mode,
+	});
+
+	Ok(BasicQueue::new(verifier, Box::new(block_import), justification_import, spawner, registry))
+}
+
+/// Parameters of [`build_verifier`].
+pub struct BuildVerifierParams<C, CIDP, N> {
+	/// The client to interact with the chain.
+	pub client: Arc<C>,
+	/// Something that can create the inherent data providers.
+	pub create_inherent_data_providers: CIDP,
+	/// Should we check for equivocation?
+	pub check_for_equivocation: CheckForEquivocation,
+	/// Telemetry instance used to report telemetry metrics.
+	pub telemetry: Option<TelemetryHandle>,
+	/// Compatibility mode that should be used.
+	///
+	/// If in doubt, use `Default::default()`.
+	pub compatibility_mode: CompatibilityMode<N>,
+}
+
+/// Build the [`AuraVerifier`]
+pub fn build_verifier<P, C, CIDP, N>(
+	BuildVerifierParams {
+		client,
+		create_inherent_data_providers,
+		check_for_equivocation,
+		telemetry,
+		compatibility_mode,
+	}: BuildVerifierParams<C, CIDP, N>,
+) -> AuraVerifier<C, P, CIDP, N> {
+	AuraVerifier::<_, P, _, _>::new(
+		client,
+		create_inherent_data_providers,
+		check_for_equivocation,
+		telemetry,
+		compatibility_mode,
+	)
+}
diff --git a/substrate/client/consensus/aura/src/lib.rs b/substrate/client/consensus/aura/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a77f00d08d3e0ae663d7ab3dbdf61f821209f751
--- /dev/null
+++ b/substrate/client/consensus/aura/src/lib.rs
@@ -0,0 +1,876 @@
+// 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/>.
+
+//! Aura (Authority-round) consensus in substrate.
+//!
+//! Aura works by having a list of authorities A who are expected to roughly
+//! agree on the current time. Time is divided up into discrete slots of t
+//! seconds each. For each slot s, the author of that slot is A[s % |A|].
+//!
+//! The author is allowed to issue one block but not more during that slot,
+//! and it will be built upon the longest valid chain that has been seen.
+//!
+//! Blocks from future steps will be either deferred or rejected depending on how
+//! far in the future they are.
+//!
+//! NOTE: Aura itself is designed to be generic over the crypto used.
+#![forbid(missing_docs, unsafe_code)]
+use std::{fmt::Debug, marker::PhantomData, pin::Pin, sync::Arc};
+
+use codec::Codec;
+use futures::prelude::*;
+
+use sc_client_api::{backend::AuxStore, BlockOf};
+use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy, StateAction};
+use sc_consensus_slots::{
+	BackoffAuthoringBlocksStrategy, InherentDataProviderExt, SimpleSlotWorkerToSlotWorker,
+	SlotInfo, StorageChanges,
+};
+use sc_telemetry::TelemetryHandle;
+use sp_api::{Core, ProvideRuntimeApi};
+use sp_application_crypto::AppPublic;
+use sp_blockchain::HeaderBackend;
+use sp_consensus::{BlockOrigin, Environment, Error as ConsensusError, Proposer, SelectChain};
+use sp_consensus_slots::Slot;
+use sp_core::crypto::Pair;
+use sp_inherents::CreateInherentDataProviders;
+use sp_keystore::KeystorePtr;
+use sp_runtime::traits::{Block as BlockT, Header, Member, NumberFor};
+
+mod import_queue;
+pub mod standalone;
+
+pub use crate::standalone::{find_pre_digest, slot_duration};
+pub use import_queue::{
+	build_verifier, import_queue, AuraVerifier, BuildVerifierParams, CheckForEquivocation,
+	ImportQueueParams,
+};
+pub use sc_consensus_slots::SlotProportion;
+pub use sp_consensus::SyncOracle;
+pub use sp_consensus_aura::{
+	digests::CompatibleDigestItem,
+	inherents::{InherentDataProvider, InherentType as AuraInherent, INHERENT_IDENTIFIER},
+	AuraApi, ConsensusLog, SlotDuration, AURA_ENGINE_ID,
+};
+
+const LOG_TARGET: &str = "aura";
+
+type AuthorityId<P> = <P as Pair>::Public;
+
+/// Run `AURA` in a compatibility mode.
+///
+/// This is required for when the chain was launched and later there
+/// was a consensus breaking change.
+#[derive(Debug, Clone)]
+pub enum CompatibilityMode<N> {
+	/// Don't use any compatibility mode.
+	None,
+	/// Call `initialize_block` before doing any runtime calls.
+	///
+	/// Previously the node would execute `initialize_block` before fetchting the authorities
+	/// from the runtime. This behaviour changed in: <https://github.com/paritytech/substrate/pull/9132>
+	///
+	/// By calling `initialize_block` before fetching the authorities, on a block that
+	/// would enact a new validator set, the block would already be build/sealed by an
+	/// authority of the new set. With this mode disabled (the default) a block that enacts a new
+	/// set isn't sealed/built by an authority of the new set, however to make new nodes be able to
+	/// sync old chains this compatibility mode exists.
+	UseInitializeBlock {
+		/// The block number until this compatibility mode should be executed. The first runtime
+		/// call in the context of the `until` block (importing it/building it) will disable the
+		/// compatibility mode (i.e. at `until` the default rules will apply). When enabling this
+		/// compatibility mode the `until` block should be a future block on which all nodes will
+		/// have upgraded to a release that includes the updated compatibility mode configuration.
+		/// At `until` block there will be a hard fork when the authority set changes, between the
+		/// old nodes (running with `initialize_block`, i.e. without the compatibility mode
+		/// configuration) and the new nodes.
+		until: N,
+	},
+}
+
+impl<N> Default for CompatibilityMode<N> {
+	fn default() -> Self {
+		Self::None
+	}
+}
+
+/// Parameters of [`start_aura`].
+pub struct StartAuraParams<C, SC, I, PF, SO, L, CIDP, BS, N> {
+	/// The duration of a slot.
+	pub slot_duration: SlotDuration,
+	/// The client to interact with the chain.
+	pub client: Arc<C>,
+	/// A select chain implementation to select the best block.
+	pub select_chain: SC,
+	/// The block import.
+	pub block_import: I,
+	/// The proposer factory to build proposer instances.
+	pub proposer_factory: PF,
+	/// The sync oracle that can give us the current sync status.
+	pub sync_oracle: SO,
+	/// Hook into the sync module to control the justification sync process.
+	pub justification_sync_link: L,
+	/// Something that can create the inherent data providers.
+	pub create_inherent_data_providers: CIDP,
+	/// Should we force the authoring of blocks?
+	pub force_authoring: bool,
+	/// The backoff strategy when we miss slots.
+	pub backoff_authoring_blocks: Option<BS>,
+	/// The keystore used by the node.
+	pub keystore: KeystorePtr,
+	/// The proportion of the slot dedicated to proposing.
+	///
+	/// The block proposing will be limited to this proportion of the slot from the starting of the
+	/// slot. However, the proposing can still take longer when there is some lenience factor
+	/// applied, because there were no blocks produced for some slots.
+	pub block_proposal_slot_portion: SlotProportion,
+	/// The maximum proportion of the slot dedicated to proposing with any lenience factor applied
+	/// due to no blocks being produced.
+	pub max_block_proposal_slot_portion: Option<SlotProportion>,
+	/// Telemetry instance used to report telemetry metrics.
+	pub telemetry: Option<TelemetryHandle>,
+	/// Compatibility mode that should be used.
+	///
+	/// If in doubt, use `Default::default()`.
+	pub compatibility_mode: CompatibilityMode<N>,
+}
+
+/// Start the aura worker. The returned future should be run in a futures executor.
+pub fn start_aura<P, B, C, SC, I, PF, SO, L, CIDP, BS, Error>(
+	StartAuraParams {
+		slot_duration,
+		client,
+		select_chain,
+		block_import,
+		proposer_factory,
+		sync_oracle,
+		justification_sync_link,
+		create_inherent_data_providers,
+		force_authoring,
+		backoff_authoring_blocks,
+		keystore,
+		block_proposal_slot_portion,
+		max_block_proposal_slot_portion,
+		telemetry,
+		compatibility_mode,
+	}: StartAuraParams<C, SC, I, PF, SO, L, CIDP, BS, NumberFor<B>>,
+) -> Result<impl Future<Output = ()>, ConsensusError>
+where
+	P: Pair,
+	P::Public: AppPublic + Member,
+	P::Signature: TryFrom<Vec<u8>> + Member + Codec,
+	B: BlockT,
+	C: ProvideRuntimeApi<B> + BlockOf + AuxStore + HeaderBackend<B> + Send + Sync,
+	C::Api: AuraApi<B, AuthorityId<P>>,
+	SC: SelectChain<B>,
+	I: BlockImport<B> + Send + Sync + 'static,
+	PF: Environment<B, Error = Error> + Send + Sync + 'static,
+	PF::Proposer: Proposer<B, Error = Error>,
+	SO: SyncOracle + Send + Sync + Clone,
+	L: sc_consensus::JustificationSyncLink<B>,
+	CIDP: CreateInherentDataProviders<B, ()> + Send + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
+	BS: BackoffAuthoringBlocksStrategy<NumberFor<B>> + Send + Sync + 'static,
+	Error: std::error::Error + Send + From<ConsensusError> + 'static,
+{
+	let worker = build_aura_worker::<P, _, _, _, _, _, _, _, _>(BuildAuraWorkerParams {
+		client,
+		block_import,
+		proposer_factory,
+		keystore,
+		sync_oracle: sync_oracle.clone(),
+		justification_sync_link,
+		force_authoring,
+		backoff_authoring_blocks,
+		telemetry,
+		block_proposal_slot_portion,
+		max_block_proposal_slot_portion,
+		compatibility_mode,
+	});
+
+	Ok(sc_consensus_slots::start_slot_worker(
+		slot_duration,
+		select_chain,
+		SimpleSlotWorkerToSlotWorker(worker),
+		sync_oracle,
+		create_inherent_data_providers,
+	))
+}
+
+/// Parameters of [`build_aura_worker`].
+pub struct BuildAuraWorkerParams<C, I, PF, SO, L, BS, N> {
+	/// The client to interact with the chain.
+	pub client: Arc<C>,
+	/// The block import.
+	pub block_import: I,
+	/// The proposer factory to build proposer instances.
+	pub proposer_factory: PF,
+	/// The sync oracle that can give us the current sync status.
+	pub sync_oracle: SO,
+	/// Hook into the sync module to control the justification sync process.
+	pub justification_sync_link: L,
+	/// Should we force the authoring of blocks?
+	pub force_authoring: bool,
+	/// The backoff strategy when we miss slots.
+	pub backoff_authoring_blocks: Option<BS>,
+	/// The keystore used by the node.
+	pub keystore: KeystorePtr,
+	/// The proportion of the slot dedicated to proposing.
+	///
+	/// The block proposing will be limited to this proportion of the slot from the starting of the
+	/// slot. However, the proposing can still take longer when there is some lenience factor
+	/// applied, because there were no blocks produced for some slots.
+	pub block_proposal_slot_portion: SlotProportion,
+	/// The maximum proportion of the slot dedicated to proposing with any lenience factor applied
+	/// due to no blocks being produced.
+	pub max_block_proposal_slot_portion: Option<SlotProportion>,
+	/// Telemetry instance used to report telemetry metrics.
+	pub telemetry: Option<TelemetryHandle>,
+	/// Compatibility mode that should be used.
+	///
+	/// If in doubt, use `Default::default()`.
+	pub compatibility_mode: CompatibilityMode<N>,
+}
+
+/// Build the aura worker.
+///
+/// The caller is responsible for running this worker, otherwise it will do nothing.
+pub fn build_aura_worker<P, B, C, PF, I, SO, L, BS, Error>(
+	BuildAuraWorkerParams {
+		client,
+		block_import,
+		proposer_factory,
+		sync_oracle,
+		justification_sync_link,
+		backoff_authoring_blocks,
+		keystore,
+		block_proposal_slot_portion,
+		max_block_proposal_slot_portion,
+		telemetry,
+		force_authoring,
+		compatibility_mode,
+	}: BuildAuraWorkerParams<C, I, PF, SO, L, BS, NumberFor<B>>,
+) -> impl sc_consensus_slots::SimpleSlotWorker<
+	B,
+	Proposer = PF::Proposer,
+	BlockImport = I,
+	SyncOracle = SO,
+	JustificationSyncLink = L,
+	Claim = P::Public,
+	AuxData = Vec<AuthorityId<P>>,
+>
+where
+	B: BlockT,
+	C: ProvideRuntimeApi<B> + BlockOf + AuxStore + HeaderBackend<B> + Send + Sync,
+	C::Api: AuraApi<B, AuthorityId<P>>,
+	PF: Environment<B, Error = Error> + Send + Sync + 'static,
+	PF::Proposer: Proposer<B, Error = Error>,
+	P: Pair,
+	P::Public: AppPublic + Member,
+	P::Signature: TryFrom<Vec<u8>> + Member + Codec,
+	I: BlockImport<B> + Send + Sync + 'static,
+	Error: std::error::Error + Send + From<ConsensusError> + 'static,
+	SO: SyncOracle + Send + Sync + Clone,
+	L: sc_consensus::JustificationSyncLink<B>,
+	BS: BackoffAuthoringBlocksStrategy<NumberFor<B>> + Send + Sync + 'static,
+{
+	AuraWorker {
+		client,
+		block_import,
+		env: proposer_factory,
+		keystore,
+		sync_oracle,
+		justification_sync_link,
+		force_authoring,
+		backoff_authoring_blocks,
+		telemetry,
+		block_proposal_slot_portion,
+		max_block_proposal_slot_portion,
+		compatibility_mode,
+		_phantom: PhantomData::<fn() -> P>,
+	}
+}
+
+struct AuraWorker<C, E, I, P, SO, L, BS, N> {
+	client: Arc<C>,
+	block_import: I,
+	env: E,
+	keystore: KeystorePtr,
+	sync_oracle: SO,
+	justification_sync_link: L,
+	force_authoring: bool,
+	backoff_authoring_blocks: Option<BS>,
+	block_proposal_slot_portion: SlotProportion,
+	max_block_proposal_slot_portion: Option<SlotProportion>,
+	telemetry: Option<TelemetryHandle>,
+	compatibility_mode: CompatibilityMode<N>,
+	_phantom: PhantomData<fn() -> P>,
+}
+
+#[async_trait::async_trait]
+impl<B, C, E, I, P, Error, SO, L, BS> sc_consensus_slots::SimpleSlotWorker<B>
+	for AuraWorker<C, E, I, P, SO, L, BS, NumberFor<B>>
+where
+	B: BlockT,
+	C: ProvideRuntimeApi<B> + BlockOf + HeaderBackend<B> + Sync,
+	C::Api: AuraApi<B, AuthorityId<P>>,
+	E: Environment<B, Error = Error> + Send + Sync,
+	E::Proposer: Proposer<B, Error = Error>,
+	I: BlockImport<B> + Send + Sync + 'static,
+	P: Pair,
+	P::Public: AppPublic + Member,
+	P::Signature: TryFrom<Vec<u8>> + Member + Codec,
+	SO: SyncOracle + Send + Clone + Sync,
+	L: sc_consensus::JustificationSyncLink<B>,
+	BS: BackoffAuthoringBlocksStrategy<NumberFor<B>> + Send + Sync + 'static,
+	Error: std::error::Error + Send + From<ConsensusError> + 'static,
+{
+	type BlockImport = I;
+	type SyncOracle = SO;
+	type JustificationSyncLink = L;
+	type CreateProposer =
+		Pin<Box<dyn Future<Output = Result<E::Proposer, ConsensusError>> + Send + 'static>>;
+	type Proposer = E::Proposer;
+	type Claim = P::Public;
+	type AuxData = Vec<AuthorityId<P>>;
+
+	fn logging_target(&self) -> &'static str {
+		"aura"
+	}
+
+	fn block_import(&mut self) -> &mut Self::BlockImport {
+		&mut self.block_import
+	}
+
+	fn aux_data(&self, header: &B::Header, _slot: Slot) -> Result<Self::AuxData, ConsensusError> {
+		authorities(
+			self.client.as_ref(),
+			header.hash(),
+			*header.number() + 1u32.into(),
+			&self.compatibility_mode,
+		)
+	}
+
+	fn authorities_len(&self, authorities: &Self::AuxData) -> Option<usize> {
+		Some(authorities.len())
+	}
+
+	async fn claim_slot(
+		&self,
+		_header: &B::Header,
+		slot: Slot,
+		authorities: &Self::AuxData,
+	) -> Option<Self::Claim> {
+		crate::standalone::claim_slot::<P>(slot, authorities, &self.keystore).await
+	}
+
+	fn pre_digest_data(&self, slot: Slot, _claim: &Self::Claim) -> Vec<sp_runtime::DigestItem> {
+		vec![crate::standalone::pre_digest::<P>(slot)]
+	}
+
+	async fn block_import_params(
+		&self,
+		header: B::Header,
+		header_hash: &B::Hash,
+		body: Vec<B::Extrinsic>,
+		storage_changes: StorageChanges<B>,
+		public: Self::Claim,
+		_authorities: Self::AuxData,
+	) -> Result<sc_consensus::BlockImportParams<B>, ConsensusError> {
+		let signature_digest_item =
+			crate::standalone::seal::<_, P>(header_hash, &public, &self.keystore)?;
+
+		let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
+		import_block.post_digests.push(signature_digest_item);
+		import_block.body = Some(body);
+		import_block.state_action =
+			StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(storage_changes));
+		import_block.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		Ok(import_block)
+	}
+
+	fn force_authoring(&self) -> bool {
+		self.force_authoring
+	}
+
+	fn should_backoff(&self, slot: Slot, chain_head: &B::Header) -> bool {
+		if let Some(ref strategy) = self.backoff_authoring_blocks {
+			if let Ok(chain_head_slot) = find_pre_digest::<B, P::Signature>(chain_head) {
+				return strategy.should_backoff(
+					*chain_head.number(),
+					chain_head_slot,
+					self.client.info().finalized_number,
+					slot,
+					self.logging_target(),
+				)
+			}
+		}
+		false
+	}
+
+	fn sync_oracle(&mut self) -> &mut Self::SyncOracle {
+		&mut self.sync_oracle
+	}
+
+	fn justification_sync_link(&mut self) -> &mut Self::JustificationSyncLink {
+		&mut self.justification_sync_link
+	}
+
+	fn proposer(&mut self, block: &B::Header) -> Self::CreateProposer {
+		self.env
+			.init(block)
+			.map_err(|e| ConsensusError::ClientImport(format!("{:?}", e)))
+			.boxed()
+	}
+
+	fn telemetry(&self) -> Option<TelemetryHandle> {
+		self.telemetry.clone()
+	}
+
+	fn proposing_remaining_duration(&self, slot_info: &SlotInfo<B>) -> std::time::Duration {
+		let parent_slot = find_pre_digest::<B, P::Signature>(&slot_info.chain_head).ok();
+
+		sc_consensus_slots::proposing_remaining_duration(
+			parent_slot,
+			slot_info,
+			&self.block_proposal_slot_portion,
+			self.max_block_proposal_slot_portion.as_ref(),
+			sc_consensus_slots::SlotLenienceType::Exponential,
+			self.logging_target(),
+		)
+	}
+}
+
+/// Aura Errors
+#[derive(Debug, thiserror::Error)]
+pub enum Error<B: BlockT> {
+	/// Multiple Aura pre-runtime headers
+	#[error("Multiple Aura pre-runtime headers")]
+	MultipleHeaders,
+	/// No Aura pre-runtime digest found
+	#[error("No Aura pre-runtime digest found")]
+	NoDigestFound,
+	/// Header is unsealed
+	#[error("Header {0:?} is unsealed")]
+	HeaderUnsealed(B::Hash),
+	/// Header has a bad seal
+	#[error("Header {0:?} has a bad seal")]
+	HeaderBadSeal(B::Hash),
+	/// Slot Author not found
+	#[error("Slot Author not found")]
+	SlotAuthorNotFound,
+	/// Bad signature
+	#[error("Bad signature on {0:?}")]
+	BadSignature(B::Hash),
+	/// Client Error
+	#[error(transparent)]
+	Client(sp_blockchain::Error),
+	/// Unknown inherent error for identifier
+	#[error("Unknown inherent error for identifier: {}", String::from_utf8_lossy(.0))]
+	UnknownInherentError(sp_inherents::InherentIdentifier),
+	/// Inherents Error
+	#[error("Inherent error: {0}")]
+	Inherent(sp_inherents::Error),
+}
+
+impl<B: BlockT> From<Error<B>> for String {
+	fn from(error: Error<B>) -> String {
+		error.to_string()
+	}
+}
+
+impl<B: BlockT> From<crate::standalone::PreDigestLookupError> for Error<B> {
+	fn from(e: crate::standalone::PreDigestLookupError) -> Self {
+		match e {
+			crate::standalone::PreDigestLookupError::MultipleHeaders => Error::MultipleHeaders,
+			crate::standalone::PreDigestLookupError::NoDigestFound => Error::NoDigestFound,
+		}
+	}
+}
+
+fn authorities<A, B, C>(
+	client: &C,
+	parent_hash: B::Hash,
+	context_block_number: NumberFor<B>,
+	compatibility_mode: &CompatibilityMode<NumberFor<B>>,
+) -> Result<Vec<A>, ConsensusError>
+where
+	A: Codec + Debug,
+	B: BlockT,
+	C: ProvideRuntimeApi<B>,
+	C::Api: AuraApi<B, A>,
+{
+	let runtime_api = client.runtime_api();
+
+	match compatibility_mode {
+		CompatibilityMode::None => {},
+		// Use `initialize_block` until we hit the block that should disable the mode.
+		CompatibilityMode::UseInitializeBlock { until } =>
+			if *until > context_block_number {
+				runtime_api
+					.initialize_block(
+						parent_hash,
+						&B::Header::new(
+							context_block_number,
+							Default::default(),
+							Default::default(),
+							parent_hash,
+							Default::default(),
+						),
+					)
+					.map_err(|_| ConsensusError::InvalidAuthoritiesSet)?;
+			},
+	}
+
+	runtime_api
+		.authorities(parent_hash)
+		.ok()
+		.ok_or(ConsensusError::InvalidAuthoritiesSet)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use parking_lot::Mutex;
+	use sc_block_builder::BlockBuilderProvider;
+	use sc_client_api::BlockchainEvents;
+	use sc_consensus::BoxJustificationImport;
+	use sc_consensus_slots::{BackoffAuthoringOnFinalizedHeadLagging, SimpleSlotWorker};
+	use sc_keystore::LocalKeystore;
+	use sc_network_test::{Block as TestBlock, *};
+	use sp_application_crypto::{key_types::AURA, AppCrypto};
+	use sp_consensus::{DisableProofRecording, NoNetwork as DummyOracle, Proposal};
+	use sp_consensus_aura::sr25519::AuthorityPair;
+	use sp_inherents::InherentData;
+	use sp_keyring::sr25519::Keyring;
+	use sp_keystore::Keystore;
+	use sp_runtime::{
+		traits::{Block as BlockT, Header as _},
+		Digest,
+	};
+	use sp_timestamp::Timestamp;
+	use std::{
+		task::Poll,
+		time::{Duration, Instant},
+	};
+	use substrate_test_runtime_client::{
+		runtime::{Header, H256},
+		TestClient,
+	};
+
+	const SLOT_DURATION_MS: u64 = 1000;
+
+	type Error = sp_blockchain::Error;
+
+	struct DummyFactory(Arc<TestClient>);
+	struct DummyProposer(u64, Arc<TestClient>);
+
+	impl Environment<TestBlock> for DummyFactory {
+		type Proposer = DummyProposer;
+		type CreateProposer = futures::future::Ready<Result<DummyProposer, Error>>;
+		type Error = Error;
+
+		fn init(&mut self, parent_header: &<TestBlock as BlockT>::Header) -> Self::CreateProposer {
+			futures::future::ready(Ok(DummyProposer(parent_header.number + 1, self.0.clone())))
+		}
+	}
+
+	impl Proposer<TestBlock> for DummyProposer {
+		type Error = Error;
+		type Proposal = future::Ready<Result<Proposal<TestBlock, ()>, Error>>;
+		type ProofRecording = DisableProofRecording;
+		type Proof = ();
+
+		fn propose(
+			self,
+			_: InherentData,
+			digests: Digest,
+			_: Duration,
+			_: Option<usize>,
+		) -> Self::Proposal {
+			let r = self.1.new_block(digests).unwrap().build().map_err(|e| e.into());
+
+			future::ready(r.map(|b| Proposal {
+				block: b.block,
+				proof: (),
+				storage_changes: b.storage_changes,
+			}))
+		}
+	}
+
+	type AuraVerifier = import_queue::AuraVerifier<
+		PeersFullClient,
+		AuthorityPair,
+		Box<
+			dyn CreateInherentDataProviders<
+				TestBlock,
+				(),
+				InherentDataProviders = (InherentDataProvider,),
+			>,
+		>,
+		u64,
+	>;
+	type AuraPeer = Peer<(), PeersClient>;
+
+	#[derive(Default)]
+	pub struct AuraTestNet {
+		peers: Vec<AuraPeer>,
+	}
+
+	impl TestNetFactory for AuraTestNet {
+		type Verifier = AuraVerifier;
+		type PeerData = ();
+		type BlockImport = PeersClient;
+
+		fn make_verifier(&self, client: PeersClient, _peer_data: &()) -> Self::Verifier {
+			let client = client.as_client();
+			let slot_duration = slot_duration(&*client).expect("slot duration available");
+
+			assert_eq!(slot_duration.as_millis() as u64, SLOT_DURATION_MS);
+			import_queue::AuraVerifier::new(
+				client,
+				Box::new(|_, _| async {
+					let slot = InherentDataProvider::from_timestamp_and_slot_duration(
+						Timestamp::current(),
+						SlotDuration::from_millis(SLOT_DURATION_MS),
+					);
+					Ok((slot,))
+				}),
+				CheckForEquivocation::Yes,
+				None,
+				CompatibilityMode::None,
+			)
+		}
+
+		fn make_block_import(
+			&self,
+			client: PeersClient,
+		) -> (
+			BlockImportAdapter<Self::BlockImport>,
+			Option<BoxJustificationImport<Block>>,
+			Self::PeerData,
+		) {
+			(client.as_block_import(), None, ())
+		}
+
+		fn peer(&mut self, i: usize) -> &mut AuraPeer {
+			&mut self.peers[i]
+		}
+
+		fn peers(&self) -> &Vec<AuraPeer> {
+			&self.peers
+		}
+
+		fn peers_mut(&mut self) -> &mut Vec<AuraPeer> {
+			&mut self.peers
+		}
+
+		fn mut_peers<F: FnOnce(&mut Vec<AuraPeer>)>(&mut self, closure: F) {
+			closure(&mut self.peers);
+		}
+	}
+
+	#[tokio::test]
+	async fn authoring_blocks() {
+		sp_tracing::try_init_simple();
+		let net = AuraTestNet::new(3);
+
+		let peers = &[(0, Keyring::Alice), (1, Keyring::Bob), (2, Keyring::Charlie)];
+
+		let net = Arc::new(Mutex::new(net));
+		let mut import_notifications = Vec::new();
+		let mut aura_futures = Vec::new();
+
+		let mut keystore_paths = Vec::new();
+		for (peer_id, key) in peers {
+			let mut net = net.lock();
+			let peer = net.peer(*peer_id);
+			let client = peer.client().as_client();
+			let select_chain = peer.select_chain().expect("full client has a select chain");
+			let keystore_path = tempfile::tempdir().expect("Creates keystore path");
+			let keystore = Arc::new(
+				LocalKeystore::open(keystore_path.path(), None).expect("Creates keystore."),
+			);
+
+			keystore
+				.sr25519_generate_new(AURA, Some(&key.to_seed()))
+				.expect("Creates authority key");
+			keystore_paths.push(keystore_path);
+
+			let environ = DummyFactory(client.clone());
+			import_notifications.push(
+				client
+					.import_notification_stream()
+					.take_while(|n| {
+						future::ready(!(n.origin != BlockOrigin::Own && n.header.number() < &5))
+					})
+					.for_each(move |_| future::ready(())),
+			);
+
+			let slot_duration = slot_duration(&*client).expect("slot duration available");
+
+			aura_futures.push(
+				start_aura::<AuthorityPair, _, _, _, _, _, _, _, _, _, _>(StartAuraParams {
+					slot_duration,
+					block_import: client.clone(),
+					select_chain,
+					client,
+					proposer_factory: environ,
+					sync_oracle: DummyOracle,
+					justification_sync_link: (),
+					create_inherent_data_providers: |_, _| async {
+						let slot = InherentDataProvider::from_timestamp_and_slot_duration(
+							Timestamp::current(),
+							SlotDuration::from_millis(SLOT_DURATION_MS),
+						);
+
+						Ok((slot,))
+					},
+					force_authoring: false,
+					backoff_authoring_blocks: Some(
+						BackoffAuthoringOnFinalizedHeadLagging::default(),
+					),
+					keystore,
+					block_proposal_slot_portion: SlotProportion::new(0.5),
+					max_block_proposal_slot_portion: None,
+					telemetry: None,
+					compatibility_mode: CompatibilityMode::None,
+				})
+				.expect("Starts aura"),
+			);
+		}
+
+		future::select(
+			future::poll_fn(move |cx| {
+				net.lock().poll(cx);
+				Poll::<()>::Pending
+			}),
+			future::select(future::join_all(aura_futures), future::join_all(import_notifications)),
+		)
+		.await;
+	}
+
+	#[tokio::test]
+	async fn current_node_authority_should_claim_slot() {
+		let net = AuraTestNet::new(4);
+
+		let mut authorities = vec![
+			Keyring::Alice.public().into(),
+			Keyring::Bob.public().into(),
+			Keyring::Charlie.public().into(),
+		];
+
+		let keystore_path = tempfile::tempdir().expect("Creates keystore path");
+		let keystore = LocalKeystore::open(keystore_path.path(), None).expect("Creates keystore.");
+		let public = keystore
+			.sr25519_generate_new(AuthorityPair::ID, None)
+			.expect("Key should be created");
+		authorities.push(public.into());
+
+		let net = Arc::new(Mutex::new(net));
+
+		let mut net = net.lock();
+		let peer = net.peer(3);
+		let client = peer.client().as_client();
+		let environ = DummyFactory(client.clone());
+
+		let worker = AuraWorker {
+			client: client.clone(),
+			block_import: client,
+			env: environ,
+			keystore: keystore.into(),
+			sync_oracle: DummyOracle,
+			justification_sync_link: (),
+			force_authoring: false,
+			backoff_authoring_blocks: Some(BackoffAuthoringOnFinalizedHeadLagging::default()),
+			telemetry: None,
+			block_proposal_slot_portion: SlotProportion::new(0.5),
+			max_block_proposal_slot_portion: None,
+			compatibility_mode: Default::default(),
+			_phantom: PhantomData::<fn() -> AuthorityPair>,
+		};
+
+		let head = Header::new(
+			1,
+			H256::from_low_u64_be(0),
+			H256::from_low_u64_be(0),
+			Default::default(),
+			Default::default(),
+		);
+		assert!(worker.claim_slot(&head, 0.into(), &authorities).await.is_none());
+		assert!(worker.claim_slot(&head, 1.into(), &authorities).await.is_none());
+		assert!(worker.claim_slot(&head, 2.into(), &authorities).await.is_none());
+		assert!(worker.claim_slot(&head, 3.into(), &authorities).await.is_some());
+		assert!(worker.claim_slot(&head, 4.into(), &authorities).await.is_none());
+		assert!(worker.claim_slot(&head, 5.into(), &authorities).await.is_none());
+		assert!(worker.claim_slot(&head, 6.into(), &authorities).await.is_none());
+		assert!(worker.claim_slot(&head, 7.into(), &authorities).await.is_some());
+	}
+
+	#[tokio::test]
+	async fn on_slot_returns_correct_block() {
+		let net = AuraTestNet::new(4);
+
+		let keystore_path = tempfile::tempdir().expect("Creates keystore path");
+		let keystore = LocalKeystore::open(keystore_path.path(), None).expect("Creates keystore.");
+		keystore
+			.sr25519_generate_new(AuthorityPair::ID, Some(&Keyring::Alice.to_seed()))
+			.expect("Key should be created");
+
+		let net = Arc::new(Mutex::new(net));
+
+		let mut net = net.lock();
+		let peer = net.peer(3);
+		let client = peer.client().as_client();
+		let environ = DummyFactory(client.clone());
+
+		let mut worker = AuraWorker {
+			client: client.clone(),
+			block_import: client.clone(),
+			env: environ,
+			keystore: keystore.into(),
+			sync_oracle: DummyOracle,
+			justification_sync_link: (),
+			force_authoring: false,
+			backoff_authoring_blocks: Option::<()>::None,
+			telemetry: None,
+			block_proposal_slot_portion: SlotProportion::new(0.5),
+			max_block_proposal_slot_portion: None,
+			compatibility_mode: Default::default(),
+			_phantom: PhantomData::<fn() -> AuthorityPair>,
+		};
+
+		let head = client.expect_header(client.info().genesis_hash).unwrap();
+
+		let res = worker
+			.on_slot(SlotInfo {
+				slot: 0.into(),
+				ends_at: Instant::now() + Duration::from_secs(100),
+				create_inherent_data: Box::new(()),
+				duration: Duration::from_millis(1000),
+				chain_head: head,
+				block_size_limit: None,
+			})
+			.await
+			.unwrap();
+
+		// The returned block should be imported and we should be able to get its header by now.
+		assert!(client.header(res.block.hash()).unwrap().is_some());
+	}
+}
diff --git a/substrate/client/consensus/aura/src/standalone.rs b/substrate/client/consensus/aura/src/standalone.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0f9b8668d4478bfe4dedfc56e234b79acdf14674
--- /dev/null
+++ b/substrate/client/consensus/aura/src/standalone.rs
@@ -0,0 +1,357 @@
+// 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/>.
+
+//! Standalone functions used within the implementation of Aura.
+
+use std::fmt::Debug;
+
+use log::trace;
+
+use codec::Codec;
+
+use sc_client_api::{backend::AuxStore, UsageProvider};
+use sp_api::{Core, ProvideRuntimeApi};
+use sp_application_crypto::{AppCrypto, AppPublic};
+use sp_blockchain::Result as CResult;
+use sp_consensus::Error as ConsensusError;
+use sp_consensus_slots::Slot;
+use sp_core::crypto::{ByteArray, Pair};
+use sp_keystore::KeystorePtr;
+use sp_runtime::{
+	traits::{Block as BlockT, Header, NumberFor, Zero},
+	DigestItem,
+};
+
+pub use sc_consensus_slots::check_equivocation;
+
+use super::{
+	AuraApi, AuthorityId, CompatibilityMode, CompatibleDigestItem, SlotDuration, LOG_TARGET,
+};
+
+/// Get the slot duration for Aura by reading from a runtime API at the best block's state.
+pub fn slot_duration<A, B, C>(client: &C) -> CResult<SlotDuration>
+where
+	A: Codec,
+	B: BlockT,
+	C: AuxStore + ProvideRuntimeApi<B> + UsageProvider<B>,
+	C::Api: AuraApi<B, A>,
+{
+	slot_duration_at(client, client.usage_info().chain.best_hash)
+}
+
+/// Get the slot duration for Aura by reading from a runtime API at a given block's state.
+pub fn slot_duration_at<A, B, C>(client: &C, block_hash: B::Hash) -> CResult<SlotDuration>
+where
+	A: Codec,
+	B: BlockT,
+	C: AuxStore + ProvideRuntimeApi<B>,
+	C::Api: AuraApi<B, A>,
+{
+	client.runtime_api().slot_duration(block_hash).map_err(|err| err.into())
+}
+
+/// Get the slot author for given block along with authorities.
+pub fn slot_author<P: Pair>(slot: Slot, authorities: &[AuthorityId<P>]) -> Option<&AuthorityId<P>> {
+	if authorities.is_empty() {
+		return None
+	}
+
+	let idx = *slot % (authorities.len() as u64);
+	assert!(
+		idx <= usize::MAX as u64,
+		"It is impossible to have a vector with length beyond the address space; qed",
+	);
+
+	let current_author = authorities.get(idx as usize).expect(
+		"authorities not empty; index constrained to list length;this is a valid index; qed",
+	);
+
+	Some(current_author)
+}
+
+/// Attempt to claim a slot using a keystore.
+///
+/// This returns `None` if the slot author is not locally controlled, and `Some` if it is,
+/// with the public key of the slot author.
+pub async fn claim_slot<P: Pair>(
+	slot: Slot,
+	authorities: &[AuthorityId<P>],
+	keystore: &KeystorePtr,
+) -> Option<P::Public> {
+	let expected_author = slot_author::<P>(slot, authorities);
+	expected_author.and_then(|p| {
+		if keystore.has_keys(&[(p.to_raw_vec(), sp_application_crypto::key_types::AURA)]) {
+			Some(p.clone())
+		} else {
+			None
+		}
+	})
+}
+
+/// Produce the pre-runtime digest containing the slot info.
+///
+/// This is intended to be put into the block header prior to runtime execution,
+/// so the runtime can read the slot in this way.
+pub fn pre_digest<P: Pair>(slot: Slot) -> sp_runtime::DigestItem
+where
+	P::Signature: Codec,
+{
+	<DigestItem as CompatibleDigestItem<P::Signature>>::aura_pre_digest(slot)
+}
+
+/// Produce the seal digest item by signing the hash of a block.
+///
+/// Note that after this is added to a block header, the hash of the block will change.
+pub fn seal<Hash, P>(
+	header_hash: &Hash,
+	public: &P::Public,
+	keystore: &KeystorePtr,
+) -> Result<sp_runtime::DigestItem, ConsensusError>
+where
+	Hash: AsRef<[u8]>,
+	P: Pair,
+	P::Signature: Codec + TryFrom<Vec<u8>>,
+	P::Public: AppPublic,
+{
+	let signature = keystore
+		.sign_with(
+			<AuthorityId<P> as AppCrypto>::ID,
+			<AuthorityId<P> as AppCrypto>::CRYPTO_ID,
+			public.as_slice(),
+			header_hash.as_ref(),
+		)
+		.map_err(|e| ConsensusError::CannotSign(format!("{}. Key: {:?}", e, public)))?
+		.ok_or_else(|| {
+			ConsensusError::CannotSign(format!("Could not find key in keystore. Key: {:?}", public))
+		})?;
+
+	let signature = signature
+		.clone()
+		.try_into()
+		.map_err(|_| ConsensusError::InvalidSignature(signature, public.to_raw_vec()))?;
+
+	let signature_digest_item =
+		<DigestItem as CompatibleDigestItem<P::Signature>>::aura_seal(signature);
+
+	Ok(signature_digest_item)
+}
+
+/// Errors in pre-digest lookup.
+#[derive(Debug, thiserror::Error)]
+pub enum PreDigestLookupError {
+	/// Multiple Aura pre-runtime headers
+	#[error("Multiple Aura pre-runtime headers")]
+	MultipleHeaders,
+	/// No Aura pre-runtime digest found
+	#[error("No Aura pre-runtime digest found")]
+	NoDigestFound,
+}
+
+/// Extract a pre-digest from a block header.
+///
+/// This fails if there is no pre-digest or there are multiple.
+///
+/// Returns the `slot` stored in the pre-digest or an error if no pre-digest was found.
+pub fn find_pre_digest<B: BlockT, Signature: Codec>(
+	header: &B::Header,
+) -> Result<Slot, PreDigestLookupError> {
+	if header.number().is_zero() {
+		return Ok(0.into())
+	}
+
+	let mut pre_digest: Option<Slot> = None;
+	for log in header.digest().logs() {
+		trace!(target: LOG_TARGET, "Checking log {:?}", log);
+		match (CompatibleDigestItem::<Signature>::as_aura_pre_digest(log), pre_digest.is_some()) {
+			(Some(_), true) => return Err(PreDigestLookupError::MultipleHeaders),
+			(None, _) => trace!(target: LOG_TARGET, "Ignoring digest not meant for us"),
+			(s, false) => pre_digest = s,
+		}
+	}
+	pre_digest.ok_or_else(|| PreDigestLookupError::NoDigestFound)
+}
+
+/// Fetch the current set of authorities from the runtime at a specific block.
+///
+/// The compatibility mode and context block number informs this function whether
+/// to initialize the hypothetical block created by the runtime API as backwards compatibility
+/// for older chains.
+pub fn fetch_authorities_with_compatibility_mode<A, B, C>(
+	client: &C,
+	parent_hash: B::Hash,
+	context_block_number: NumberFor<B>,
+	compatibility_mode: &CompatibilityMode<NumberFor<B>>,
+) -> Result<Vec<A>, ConsensusError>
+where
+	A: Codec + Debug,
+	B: BlockT,
+	C: ProvideRuntimeApi<B>,
+	C::Api: AuraApi<B, A>,
+{
+	let runtime_api = client.runtime_api();
+
+	match compatibility_mode {
+		CompatibilityMode::None => {},
+		// Use `initialize_block` until we hit the block that should disable the mode.
+		CompatibilityMode::UseInitializeBlock { until } =>
+			if *until > context_block_number {
+				runtime_api
+					.initialize_block(
+						parent_hash,
+						&B::Header::new(
+							context_block_number,
+							Default::default(),
+							Default::default(),
+							parent_hash,
+							Default::default(),
+						),
+					)
+					.map_err(|_| ConsensusError::InvalidAuthoritiesSet)?;
+			},
+	}
+
+	runtime_api
+		.authorities(parent_hash)
+		.ok()
+		.ok_or(ConsensusError::InvalidAuthoritiesSet)
+}
+
+/// Load the current set of authorities from a runtime at a specific block.
+pub fn fetch_authorities<A, B, C>(
+	client: &C,
+	parent_hash: B::Hash,
+) -> Result<Vec<A>, ConsensusError>
+where
+	A: Codec + Debug,
+	B: BlockT,
+	C: ProvideRuntimeApi<B>,
+	C::Api: AuraApi<B, A>,
+{
+	client
+		.runtime_api()
+		.authorities(parent_hash)
+		.ok()
+		.ok_or(ConsensusError::InvalidAuthoritiesSet)
+}
+
+/// Errors in slot and seal verification.
+#[derive(Debug, thiserror::Error)]
+pub enum SealVerificationError<Header> {
+	/// Header is deferred to the future.
+	#[error("Header slot is in the future")]
+	Deferred(Header, Slot),
+
+	/// The header has no seal digest.
+	#[error("Header is unsealed.")]
+	Unsealed,
+
+	/// The header has a malformed seal.
+	#[error("Header has a malformed seal")]
+	BadSeal,
+
+	/// The header has a bad signature.
+	#[error("Header has a bad signature")]
+	BadSignature,
+
+	/// No slot author found.
+	#[error("No slot author for provided slot")]
+	SlotAuthorNotFound,
+
+	/// Header has no valid slot pre-digest.
+	#[error("Header has no valid slot pre-digest")]
+	InvalidPreDigest(PreDigestLookupError),
+}
+
+/// Check a header has been signed by the right key. If the slot is too far in the future, an error
+/// will be returned. If it's successful, returns the pre-header (i.e. without the seal),
+/// the slot, and the digest item containing the seal.
+///
+/// Note that this does not check for equivocations, and [`check_equivocation`] is recommended
+/// for that purpose.
+///
+/// This digest item will always return `Some` when used with `as_aura_seal`.
+pub fn check_header_slot_and_seal<B: BlockT, P: Pair>(
+	slot_now: Slot,
+	mut header: B::Header,
+	authorities: &[AuthorityId<P>],
+) -> Result<(B::Header, Slot, DigestItem), SealVerificationError<B::Header>>
+where
+	P::Signature: Codec,
+	P::Public: Codec + PartialEq + Clone,
+{
+	let seal = header.digest_mut().pop().ok_or(SealVerificationError::Unsealed)?;
+
+	let sig = seal.as_aura_seal().ok_or(SealVerificationError::BadSeal)?;
+
+	let slot = find_pre_digest::<B, P::Signature>(&header)
+		.map_err(SealVerificationError::InvalidPreDigest)?;
+
+	if slot > slot_now {
+		header.digest_mut().push(seal);
+		return Err(SealVerificationError::Deferred(header, slot))
+	} else {
+		// check the signature is valid under the expected authority and
+		// chain state.
+		let expected_author =
+			slot_author::<P>(slot, authorities).ok_or(SealVerificationError::SlotAuthorNotFound)?;
+
+		let pre_hash = header.hash();
+
+		if P::verify(&sig, pre_hash.as_ref(), expected_author) {
+			Ok((header, slot, seal))
+		} else {
+			Err(SealVerificationError::BadSignature)
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_keyring::sr25519::Keyring;
+
+	#[test]
+	fn authorities_call_works() {
+		let client = substrate_test_runtime_client::new();
+
+		assert_eq!(client.chain_info().best_number, 0);
+		assert_eq!(
+			fetch_authorities_with_compatibility_mode(
+				&client,
+				client.chain_info().best_hash,
+				1,
+				&CompatibilityMode::None
+			)
+			.unwrap(),
+			vec![
+				Keyring::Alice.public().into(),
+				Keyring::Bob.public().into(),
+				Keyring::Charlie.public().into()
+			]
+		);
+
+		assert_eq!(
+			fetch_authorities(&client, client.chain_info().best_hash).unwrap(),
+			vec![
+				Keyring::Alice.public().into(),
+				Keyring::Bob.public().into(),
+				Keyring::Charlie.public().into()
+			]
+		);
+	}
+}
diff --git a/substrate/client/consensus/babe/Cargo.toml b/substrate/client/consensus/babe/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e036ff1e64cd1534706c94d75013b0c2baf7e64e
--- /dev/null
+++ b/substrate/client/consensus/babe/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "sc-consensus-babe"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "BABE consensus algorithm for substrate"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-consensus-babe"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = "0.1.57"
+scale-info = { version = "2.5.0", features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+futures = "0.3.21"
+log = "0.4.17"
+num-bigint = "0.4.3"
+num-rational = "0.4.1"
+num-traits = "0.2.8"
+parking_lot = "0.12.1"
+thiserror = "1.0"
+fork-tree = { version = "3.0.0", path = "../../../utils/fork-tree" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-consensus-epochs = { version = "0.10.0-dev", path = "../epochs" }
+sc-consensus-slots = { version = "0.10.0-dev", path = "../slots" }
+sc-telemetry = { version = "4.0.0-dev", path = "../../telemetry" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../transaction-pool/api" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-application-crypto = { version = "23.0.0", path = "../../../primitives/application-crypto" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../../primitives/block-builder" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-babe = { version = "0.10.0-dev", path = "../../../primitives/consensus/babe" }
+sp-consensus-slots = { version = "0.10.0-dev", path = "../../../primitives/consensus/slots" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+rand_chacha = "0.2.2"
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+sc-network = { version = "0.10.0-dev", path = "../../network" }
+sc-network-test = { version = "0.8.0", path = "../../network/test" }
+sp-timestamp = { version = "4.0.0-dev", path = "../../../primitives/timestamp" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
+tokio = "1.22.0"
diff --git a/substrate/client/consensus/babe/README.md b/substrate/client/consensus/babe/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a404d2ea447064e083d05aac59752a8c41d97096
--- /dev/null
+++ b/substrate/client/consensus/babe/README.md
@@ -0,0 +1,48 @@
+# BABE (Blind Assignment for Blockchain Extension)
+
+BABE is a slot-based block production mechanism which uses a VRF PRNG to
+randomly perform the slot allocation. On every slot, all the authorities
+generate a new random number with the VRF function and if it is lower than a
+given threshold (which is proportional to their weight/stake) they have a
+right to produce a block. The proof of the VRF function execution will be
+used by other peer to validate the legitimacy of the slot claim.
+
+The engine is also responsible for collecting entropy on-chain which will be
+used to seed the given VRF PRNG. An epoch is a contiguous number of slots
+under which we will be using the same authority set. During an epoch all VRF
+outputs produced as a result of block production will be collected on an
+on-chain randomness pool. Epoch changes are announced one epoch in advance,
+i.e. when ending epoch N, we announce the parameters (randomness,
+authorities, etc.) for epoch N+2.
+
+Since the slot assignment is randomized, it is possible that a slot is
+assigned to multiple validators in which case we will have a temporary fork,
+or that a slot is assigned to no validator in which case no block is
+produced. Which means that block times are not deterministic.
+
+The protocol has a parameter `c` [0, 1] for which `1 - c` is the probability
+of a slot being empty. The choice of this parameter affects the security of
+the protocol relating to maximum tolerable network delays.
+
+In addition to the VRF-based slot assignment described above, which we will
+call primary slots, the engine also supports a deterministic secondary slot
+assignment. Primary slots take precedence over secondary slots, when
+authoring the node starts by trying to claim a primary slot and falls back
+to a secondary slot claim attempt. The secondary slot assignment is done
+by picking the authority at index:
+
+`blake2_256(epoch_randomness ++ slot_number) % authorities_len`.
+
+The secondary slots supports either a `SecondaryPlain` or `SecondaryVRF`
+variant. Comparing with `SecondaryPlain` variant, the `SecondaryVRF` variant
+generates an additional VRF output. The output is not included in beacon
+randomness, but can be consumed by parachains.
+
+The fork choice rule is weight-based, where weight equals the number of
+primary blocks in the chain. We will pick the heaviest chain (more primary
+blocks) and will go with the longest one in case of a tie.
+
+An in-depth description and analysis of the protocol can be found here:
+<https://research.web3.foundation/en/latest/polkadot/block-production/Babe.html>
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/babe/rpc/Cargo.toml b/substrate/client/consensus/babe/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7b16ea84c43665df00df3c5618f2094ae726d318
--- /dev/null
+++ b/substrate/client/consensus/babe/rpc/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "sc-consensus-babe-rpc"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "RPC extensions for the BABE consensus algorithm"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+futures = "0.3.21"
+serde = { version = "1.0.163", features = ["derive"] }
+thiserror = "1.0"
+sc-consensus-babe = { version = "0.10.0-dev", path = "../" }
+sc-consensus-epochs = { version = "0.10.0-dev", path = "../../epochs" }
+sc-rpc-api = { version = "0.10.0-dev", path = "../../../rpc-api" }
+sp-api = { version = "4.0.0-dev", path = "../../../../primitives/api" }
+sp-application-crypto = { version = "23.0.0", path = "../../../../primitives/application-crypto" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../../primitives/consensus/common" }
+sp-consensus-babe = { version = "0.10.0-dev", path = "../../../../primitives/consensus/babe" }
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+
+[dev-dependencies]
+serde_json = "1.0.85"
+tokio = "1.22.0"
+sc-consensus = { version = "0.10.0-dev", path = "../../../consensus/common" }
+sc-keystore = { version = "4.0.0-dev", path = "../../../keystore" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../transaction-pool/api" }
+sp-keyring = { version = "24.0.0", path = "../../../../primitives/keyring" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../../test-utils/runtime/client" }
diff --git a/substrate/client/consensus/babe/rpc/README.md b/substrate/client/consensus/babe/rpc/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e76dd3dc67f81d3b789e718acbb8cb8b0e755cec
--- /dev/null
+++ b/substrate/client/consensus/babe/rpc/README.md
@@ -0,0 +1,3 @@
+RPC api for babe.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/babe/rpc/src/lib.rs b/substrate/client/consensus/babe/rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bffe026ea6ef6bd9efa282dd71b587aaf03471b3
--- /dev/null
+++ b/substrate/client/consensus/babe/rpc/src/lib.rs
@@ -0,0 +1,271 @@
+// 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/>.
+
+//! RPC api for babe.
+
+use std::{collections::HashMap, sync::Arc};
+
+use futures::TryFutureExt;
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError, RpcResult},
+	proc_macros::rpc,
+	types::{error::CallError, ErrorObject},
+};
+use serde::{Deserialize, Serialize};
+
+use sc_consensus_babe::{authorship, BabeWorkerHandle};
+use sc_consensus_epochs::Epoch as EpochT;
+use sc_rpc_api::DenyUnsafe;
+use sp_api::ProvideRuntimeApi;
+use sp_application_crypto::AppCrypto;
+use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
+use sp_consensus::{Error as ConsensusError, SelectChain};
+use sp_consensus_babe::{digests::PreDigest, AuthorityId, BabeApi as BabeRuntimeApi};
+use sp_core::crypto::ByteArray;
+use sp_keystore::KeystorePtr;
+use sp_runtime::traits::{Block as BlockT, Header as _};
+
+const BABE_ERROR: i32 = 9000;
+
+/// Provides rpc methods for interacting with Babe.
+#[rpc(client, server)]
+pub trait BabeApi {
+	/// Returns data about which slots (primary or secondary) can be claimed in the current epoch
+	/// with the keys in the keystore.
+	#[method(name = "babe_epochAuthorship")]
+	async fn epoch_authorship(&self) -> RpcResult<HashMap<AuthorityId, EpochAuthorship>>;
+}
+
+/// Provides RPC methods for interacting with Babe.
+pub struct Babe<B: BlockT, C, SC> {
+	/// shared reference to the client.
+	client: Arc<C>,
+	/// A handle to the BABE worker for issuing requests.
+	babe_worker_handle: BabeWorkerHandle<B>,
+	/// shared reference to the Keystore
+	keystore: KeystorePtr,
+	/// The SelectChain strategy
+	select_chain: SC,
+	/// Whether to deny unsafe calls
+	deny_unsafe: DenyUnsafe,
+}
+
+impl<B: BlockT, C, SC> Babe<B, C, SC> {
+	/// Creates a new instance of the Babe Rpc handler.
+	pub fn new(
+		client: Arc<C>,
+		babe_worker_handle: BabeWorkerHandle<B>,
+		keystore: KeystorePtr,
+		select_chain: SC,
+		deny_unsafe: DenyUnsafe,
+	) -> Self {
+		Self { client, babe_worker_handle, keystore, select_chain, deny_unsafe }
+	}
+}
+
+#[async_trait]
+impl<B: BlockT, C, SC> BabeApiServer for Babe<B, C, SC>
+where
+	B: BlockT,
+	C: ProvideRuntimeApi<B>
+		+ HeaderBackend<B>
+		+ HeaderMetadata<B, Error = BlockChainError>
+		+ 'static,
+	C::Api: BabeRuntimeApi<B>,
+	SC: SelectChain<B> + Clone + 'static,
+{
+	async fn epoch_authorship(&self) -> RpcResult<HashMap<AuthorityId, EpochAuthorship>> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let best_header = self.select_chain.best_chain().map_err(Error::SelectChain).await?;
+
+		let epoch_start = self
+			.client
+			.runtime_api()
+			.current_epoch_start(best_header.hash())
+			.map_err(|_| Error::FetchEpoch)?;
+
+		let epoch = self
+			.babe_worker_handle
+			.epoch_data_for_child_of(best_header.hash(), *best_header.number(), epoch_start)
+			.await
+			.map_err(|_| Error::FetchEpoch)?;
+
+		let (epoch_start, epoch_end) = (epoch.start_slot(), epoch.end_slot());
+		let mut claims: HashMap<AuthorityId, EpochAuthorship> = HashMap::new();
+
+		let keys = {
+			epoch
+				.authorities
+				.iter()
+				.enumerate()
+				.filter_map(|(i, a)| {
+					if self.keystore.has_keys(&[(a.0.to_raw_vec(), AuthorityId::ID)]) {
+						Some((a.0.clone(), i))
+					} else {
+						None
+					}
+				})
+				.collect::<Vec<_>>()
+		};
+
+		for slot in *epoch_start..*epoch_end {
+			if let Some((claim, key)) =
+				authorship::claim_slot_using_keys(slot.into(), &epoch, &self.keystore, &keys)
+			{
+				match claim {
+					PreDigest::Primary { .. } => {
+						claims.entry(key).or_default().primary.push(slot);
+					},
+					PreDigest::SecondaryPlain { .. } => {
+						claims.entry(key).or_default().secondary.push(slot);
+					},
+					PreDigest::SecondaryVRF { .. } => {
+						claims.entry(key).or_default().secondary_vrf.push(slot.into());
+					},
+				};
+			}
+		}
+
+		Ok(claims)
+	}
+}
+
+/// Holds information about the `slot`'s that can be claimed by a given key.
+#[derive(Default, Debug, Deserialize, Serialize)]
+pub struct EpochAuthorship {
+	/// the array of primary slots that can be claimed
+	primary: Vec<u64>,
+	/// the array of secondary slots that can be claimed
+	secondary: Vec<u64>,
+	/// The array of secondary VRF slots that can be claimed.
+	secondary_vrf: Vec<u64>,
+}
+
+/// Top-level error type for the RPC handler.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Failed to fetch the current best header.
+	#[error("Failed to fetch the current best header: {0}")]
+	SelectChain(ConsensusError),
+	/// Failed to fetch epoch data.
+	#[error("Failed to fetch epoch data")]
+	FetchEpoch,
+}
+
+impl From<Error> for JsonRpseeError {
+	fn from(error: Error) -> Self {
+		let error_code = match error {
+			Error::SelectChain(_) => 1,
+			Error::FetchEpoch => 2,
+		};
+
+		JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+			BABE_ERROR + error_code,
+			error.to_string(),
+			Some(format!("{:?}", error)),
+		)))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_consensus_babe::ImportQueueParams;
+	use sc_transaction_pool_api::{OffchainTransactionPoolFactory, RejectAllTxPool};
+	use sp_consensus_babe::inherents::InherentDataProvider;
+	use sp_core::{crypto::key_types::BABE, testing::TaskExecutor};
+	use sp_keyring::Sr25519Keyring;
+	use sp_keystore::{testing::MemoryKeystore, Keystore};
+	use substrate_test_runtime_client::{
+		runtime::Block, Backend, DefaultTestClientBuilderExt, TestClient, TestClientBuilder,
+		TestClientBuilderExt,
+	};
+
+	fn create_keystore(authority: Sr25519Keyring) -> KeystorePtr {
+		let keystore = MemoryKeystore::new();
+		keystore
+			.sr25519_generate_new(BABE, Some(&authority.to_seed()))
+			.expect("Creates authority key");
+		keystore.into()
+	}
+
+	fn test_babe_rpc_module(
+		deny_unsafe: DenyUnsafe,
+	) -> Babe<Block, TestClient, sc_consensus::LongestChain<Backend, Block>> {
+		let builder = TestClientBuilder::new();
+		let (client, longest_chain) = builder.build_with_longest_chain();
+		let client = Arc::new(client);
+		let task_executor = TaskExecutor::new();
+		let keystore = create_keystore(Sr25519Keyring::Alice);
+
+		let config = sc_consensus_babe::configuration(&*client).expect("config available");
+		let slot_duration = config.slot_duration();
+
+		let (block_import, link) =
+			sc_consensus_babe::block_import(config.clone(), client.clone(), client.clone())
+				.expect("can initialize block-import");
+
+		let (_, babe_worker_handle) = sc_consensus_babe::import_queue(ImportQueueParams {
+			link: link.clone(),
+			block_import: block_import.clone(),
+			justification_import: None,
+			client: client.clone(),
+			select_chain: longest_chain.clone(),
+			create_inherent_data_providers: move |_, _| async move {
+				Ok((InherentDataProvider::from_timestamp_and_slot_duration(
+					0.into(),
+					slot_duration,
+				),))
+			},
+			spawner: &task_executor,
+			registry: None,
+			telemetry: None,
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+				RejectAllTxPool::default(),
+			),
+		})
+		.unwrap();
+
+		Babe::new(client.clone(), babe_worker_handle, keystore, longest_chain, deny_unsafe)
+	}
+
+	#[tokio::test]
+	async fn epoch_authorship_works() {
+		let babe_rpc = test_babe_rpc_module(DenyUnsafe::No);
+		let api = babe_rpc.into_rpc();
+
+		let request = r#"{"jsonrpc":"2.0","method":"babe_epochAuthorship","params": [],"id":1}"#;
+		let (response, _) = api.raw_json_request(request).await.unwrap();
+		let expected = r#"{"jsonrpc":"2.0","result":{"5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY":{"primary":[0],"secondary":[1,2,4],"secondary_vrf":[]}},"id":1}"#;
+
+		assert_eq!(&response.result, expected);
+	}
+
+	#[tokio::test]
+	async fn epoch_authorship_is_unsafe() {
+		let babe_rpc = test_babe_rpc_module(DenyUnsafe::Yes);
+		let api = babe_rpc.into_rpc();
+
+		let request = r#"{"jsonrpc":"2.0","method":"babe_epochAuthorship","params":[],"id":1}"#;
+		let (response, _) = api.raw_json_request(request).await.unwrap();
+		let expected = r#"{"jsonrpc":"2.0","error":{"code":-32601,"message":"RPC call is unsafe to be called externally"},"id":1}"#;
+
+		assert_eq!(&response.result, expected);
+	}
+}
diff --git a/substrate/client/consensus/babe/src/authorship.rs b/substrate/client/consensus/babe/src/authorship.rs
new file mode 100644
index 0000000000000000000000000000000000000000..758d5321a94c5b1c4cdaca6855a5739370ec012d
--- /dev/null
+++ b/substrate/client/consensus/babe/src/authorship.rs
@@ -0,0 +1,310 @@
+// 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/>.
+
+//! BABE authority selection and slot claiming.
+
+use super::{Epoch, AUTHORING_SCORE_LENGTH, AUTHORING_SCORE_VRF_CONTEXT};
+use codec::Encode;
+use sc_consensus_epochs::Epoch as EpochT;
+use sp_application_crypto::AppCrypto;
+use sp_consensus_babe::{
+	digests::{PreDigest, PrimaryPreDigest, SecondaryPlainPreDigest, SecondaryVRFPreDigest},
+	make_vrf_sign_data, AuthorityId, BabeAuthorityWeight, Randomness, Slot,
+};
+use sp_core::{
+	blake2_256,
+	crypto::{ByteArray, Wraps},
+	U256,
+};
+use sp_keystore::KeystorePtr;
+
+/// Calculates the primary selection threshold for a given authority, taking
+/// into account `c` (`1 - c` represents the probability of a slot being empty).
+pub(super) fn calculate_primary_threshold(
+	c: (u64, u64),
+	authorities: &[(AuthorityId, BabeAuthorityWeight)],
+	authority_index: usize,
+) -> u128 {
+	use num_bigint::BigUint;
+	use num_rational::BigRational;
+	use num_traits::{cast::ToPrimitive, identities::One};
+
+	// Prevent div by zero and out of bounds access.
+	// While Babe's pallet implementation that ships with FRAME performs a sanity check over
+	// configuration parameters, this is not sufficient to guarantee that `c.1` is non-zero
+	// (i.e. third party implementations are possible).
+	if c.1 == 0 || authority_index >= authorities.len() {
+		return 0
+	}
+
+	let c = c.0 as f64 / c.1 as f64;
+
+	let theta = authorities[authority_index].1 as f64 /
+		authorities.iter().map(|(_, weight)| weight).sum::<u64>() as f64;
+
+	assert!(theta > 0.0, "authority with weight 0.");
+
+	// NOTE: in the equation `p = 1 - (1 - c)^theta` the value of `p` is always
+	// capped by `c`. For all pratical purposes `c` should always be set to a
+	// value < 0.5, as such in the computations below we should never be near
+	// edge cases like `0.999999`.
+
+	let p = BigRational::from_float(1f64 - (1f64 - c).powf(theta)).expect(
+		"returns None when the given value is not finite; \
+		 c is a configuration parameter defined in (0, 1]; \
+		 theta must be > 0 if the given authority's weight is > 0; \
+		 theta represents the validator's relative weight defined in (0, 1]; \
+		 powf will always return values in (0, 1] given both the \
+		 base and exponent are in that domain; \
+		 qed.",
+	);
+
+	let numer = p.numer().to_biguint().expect(
+		"returns None when the given value is negative; \
+		 p is defined as `1 - n` where n is defined in (0, 1]; \
+		 p must be a value in [0, 1); \
+		 qed.",
+	);
+
+	let denom = p.denom().to_biguint().expect(
+		"returns None when the given value is negative; \
+		 p is defined as `1 - n` where n is defined in (0, 1]; \
+		 p must be a value in [0, 1); \
+		 qed.",
+	);
+
+	((BigUint::one() << 128usize) * numer / denom).to_u128().expect(
+		"returns None if the underlying value cannot be represented with 128 bits; \
+		 we start with 2^128 which is one more than can be represented with 128 bits; \
+		 we multiple by p which is defined in [0, 1); \
+		 the result must be lower than 2^128 by at least one and thus representable with 128 bits; \
+		 qed.",
+	)
+}
+
+/// Get the expected secondary author for the given slot and with given
+/// authorities. This should always assign the slot to some authority unless the
+/// authorities list is empty.
+pub(super) fn secondary_slot_author(
+	slot: Slot,
+	authorities: &[(AuthorityId, BabeAuthorityWeight)],
+	randomness: Randomness,
+) -> Option<&AuthorityId> {
+	if authorities.is_empty() {
+		return None
+	}
+
+	let rand = U256::from((randomness, slot).using_encoded(blake2_256));
+
+	let authorities_len = U256::from(authorities.len());
+	let idx = rand % authorities_len;
+
+	let expected_author = authorities.get(idx.as_u32() as usize).expect(
+		"authorities not empty; index constrained to list length; \
+				this is a valid index; qed",
+	);
+
+	Some(&expected_author.0)
+}
+
+/// Claim a secondary slot if it is our turn to propose, returning the
+/// pre-digest to use when authoring the block, or `None` if it is not our turn
+/// to propose.
+fn claim_secondary_slot(
+	slot: Slot,
+	epoch: &Epoch,
+	keys: &[(AuthorityId, usize)],
+	keystore: &KeystorePtr,
+	author_secondary_vrf: bool,
+) -> Option<(PreDigest, AuthorityId)> {
+	let Epoch { authorities, randomness, mut epoch_index, .. } = epoch;
+
+	if authorities.is_empty() {
+		return None
+	}
+
+	if epoch.end_slot() <= slot {
+		// Slot doesn't strictly belong to the epoch, create a clone with fixed values.
+		epoch_index = epoch.clone_for_slot(slot).epoch_index;
+	}
+
+	let expected_author = secondary_slot_author(slot, authorities, *randomness)?;
+
+	for (authority_id, authority_index) in keys {
+		if authority_id == expected_author {
+			let pre_digest = if author_secondary_vrf {
+				let data = make_vrf_sign_data(randomness, slot, epoch_index);
+				let result =
+					keystore.sr25519_vrf_sign(AuthorityId::ID, authority_id.as_ref(), &data);
+				if let Ok(Some(vrf_signature)) = result {
+					Some(PreDigest::SecondaryVRF(SecondaryVRFPreDigest {
+						slot,
+						authority_index: *authority_index as u32,
+						vrf_signature,
+					}))
+				} else {
+					None
+				}
+			} else if keystore.has_keys(&[(authority_id.to_raw_vec(), AuthorityId::ID)]) {
+				Some(PreDigest::SecondaryPlain(SecondaryPlainPreDigest {
+					slot,
+					authority_index: *authority_index as u32,
+				}))
+			} else {
+				None
+			};
+
+			if let Some(pre_digest) = pre_digest {
+				return Some((pre_digest, authority_id.clone()))
+			}
+		}
+	}
+
+	None
+}
+
+/// Tries to claim the given slot number. This method starts by trying to claim
+/// a primary VRF based slot. If we are not able to claim it, then if we have
+/// secondary slots enabled for the given epoch, we will fallback to trying to
+/// claim a secondary slot.
+pub fn claim_slot(
+	slot: Slot,
+	epoch: &Epoch,
+	keystore: &KeystorePtr,
+) -> Option<(PreDigest, AuthorityId)> {
+	let authorities = epoch
+		.authorities
+		.iter()
+		.enumerate()
+		.map(|(index, a)| (a.0.clone(), index))
+		.collect::<Vec<_>>();
+	claim_slot_using_keys(slot, epoch, keystore, &authorities)
+}
+
+/// Like `claim_slot`, but allows passing an explicit set of key pairs. Useful if we intend
+/// to make repeated calls for different slots using the same key pairs.
+pub fn claim_slot_using_keys(
+	slot: Slot,
+	epoch: &Epoch,
+	keystore: &KeystorePtr,
+	keys: &[(AuthorityId, usize)],
+) -> Option<(PreDigest, AuthorityId)> {
+	claim_primary_slot(slot, epoch, epoch.config.c, keystore, keys).or_else(|| {
+		if epoch.config.allowed_slots.is_secondary_plain_slots_allowed() ||
+			epoch.config.allowed_slots.is_secondary_vrf_slots_allowed()
+		{
+			claim_secondary_slot(
+				slot,
+				epoch,
+				keys,
+				keystore,
+				epoch.config.allowed_slots.is_secondary_vrf_slots_allowed(),
+			)
+		} else {
+			None
+		}
+	})
+}
+
+/// Claim a primary slot if it is our turn.  Returns `None` if it is not our turn.
+/// This hashes the slot number, epoch, genesis hash, and chain randomness into
+/// the VRF.  If the VRF produces a value less than `threshold`, it is our turn,
+/// so it returns `Some(_)`. Otherwise, it returns `None`.
+fn claim_primary_slot(
+	slot: Slot,
+	epoch: &Epoch,
+	c: (u64, u64),
+	keystore: &KeystorePtr,
+	keys: &[(AuthorityId, usize)],
+) -> Option<(PreDigest, AuthorityId)> {
+	let Epoch { authorities, randomness, mut epoch_index, .. } = epoch;
+
+	if epoch.end_slot() <= slot {
+		// Slot doesn't strictly belong to the epoch, create a clone with fixed values.
+		epoch_index = epoch.clone_for_slot(slot).epoch_index;
+	}
+
+	let data = make_vrf_sign_data(randomness, slot, epoch_index);
+
+	for (authority_id, authority_index) in keys {
+		let result = keystore.sr25519_vrf_sign(AuthorityId::ID, authority_id.as_ref(), &data);
+		if let Ok(Some(vrf_signature)) = result {
+			let threshold = calculate_primary_threshold(c, authorities, *authority_index);
+
+			let can_claim = authority_id
+				.as_inner_ref()
+				.make_bytes::<AUTHORING_SCORE_LENGTH>(
+					AUTHORING_SCORE_VRF_CONTEXT,
+					&data.as_ref(),
+					&vrf_signature.output,
+				)
+				.map(|bytes| u128::from_le_bytes(bytes) < threshold)
+				.unwrap_or_default();
+
+			if can_claim {
+				let pre_digest = PreDigest::Primary(PrimaryPreDigest {
+					slot,
+					authority_index: *authority_index as u32,
+					vrf_signature,
+				});
+
+				return Some((pre_digest, authority_id.clone()))
+			}
+		}
+	}
+
+	None
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_consensus_babe::{AllowedSlots, AuthorityId, BabeEpochConfiguration};
+	use sp_core::{crypto::Pair as _, sr25519::Pair};
+	use sp_keystore::testing::MemoryKeystore;
+
+	#[test]
+	fn claim_secondary_plain_slot_works() {
+		let keystore: KeystorePtr = MemoryKeystore::new().into();
+		let valid_public_key = keystore
+			.sr25519_generate_new(AuthorityId::ID, Some(sp_core::crypto::DEV_PHRASE))
+			.unwrap();
+
+		let authorities = vec![
+			(AuthorityId::from(Pair::generate().0.public()), 5),
+			(AuthorityId::from(Pair::generate().0.public()), 7),
+		];
+
+		let mut epoch = Epoch {
+			epoch_index: 10,
+			start_slot: 0.into(),
+			duration: 20,
+			authorities: authorities.clone(),
+			randomness: Default::default(),
+			config: BabeEpochConfiguration {
+				c: (3, 10),
+				allowed_slots: AllowedSlots::PrimaryAndSecondaryPlainSlots,
+			},
+		};
+
+		assert!(claim_slot(10.into(), &epoch, &keystore).is_none());
+
+		epoch.authorities.push((valid_public_key.into(), 10));
+		assert_eq!(claim_slot(10.into(), &epoch, &keystore).unwrap().1, valid_public_key.into());
+	}
+}
diff --git a/substrate/client/consensus/babe/src/aux_schema.rs b/substrate/client/consensus/babe/src/aux_schema.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a87b7c9a0d030a79212a8d6d4c698d23f415de1a
--- /dev/null
+++ b/substrate/client/consensus/babe/src/aux_schema.rs
@@ -0,0 +1,215 @@
+// 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/>.
+
+//! Schema for BABE epoch changes in the aux-db.
+
+use codec::{Decode, Encode};
+use log::info;
+
+use crate::{migration::EpochV0, Epoch, LOG_TARGET};
+use sc_client_api::backend::AuxStore;
+use sc_consensus_epochs::{
+	migration::{EpochChangesV0For, EpochChangesV1For},
+	EpochChangesFor, SharedEpochChanges,
+};
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
+use sp_consensus_babe::{BabeBlockWeight, BabeConfiguration};
+use sp_runtime::traits::Block as BlockT;
+
+const BABE_EPOCH_CHANGES_VERSION: &[u8] = b"babe_epoch_changes_version";
+const BABE_EPOCH_CHANGES_KEY: &[u8] = b"babe_epoch_changes";
+const BABE_EPOCH_CHANGES_CURRENT_VERSION: u32 = 3;
+
+/// The aux storage key used to store the block weight of the given block hash.
+pub fn block_weight_key<H: Encode>(block_hash: H) -> Vec<u8> {
+	(b"block_weight", block_hash).encode()
+}
+
+fn load_decode<B, T>(backend: &B, key: &[u8]) -> ClientResult<Option<T>>
+where
+	B: AuxStore,
+	T: Decode,
+{
+	let corrupt = |e: codec::Error| {
+		ClientError::Backend(format!("BABE DB is corrupted. Decode error: {}", e))
+	};
+	match backend.get_aux(key)? {
+		None => Ok(None),
+		Some(t) => T::decode(&mut &t[..]).map(Some).map_err(corrupt),
+	}
+}
+
+/// Load or initialize persistent epoch change data from backend.
+pub fn load_epoch_changes<Block: BlockT, B: AuxStore>(
+	backend: &B,
+	config: &BabeConfiguration,
+) -> ClientResult<SharedEpochChanges<Block, Epoch>> {
+	let version = load_decode::<_, u32>(backend, BABE_EPOCH_CHANGES_VERSION)?;
+
+	let maybe_epoch_changes = match version {
+		None =>
+			load_decode::<_, EpochChangesV0For<Block, EpochV0>>(backend, BABE_EPOCH_CHANGES_KEY)?
+				.map(|v0| v0.migrate().map(|_, _, epoch| epoch.migrate(config))),
+		Some(1) =>
+			load_decode::<_, EpochChangesV1For<Block, EpochV0>>(backend, BABE_EPOCH_CHANGES_KEY)?
+				.map(|v1| v1.migrate().map(|_, _, epoch| epoch.migrate(config))),
+		Some(2) => {
+			// v2 still uses `EpochChanges` v1 format but with a different `Epoch` type.
+			load_decode::<_, EpochChangesV1For<Block, Epoch>>(backend, BABE_EPOCH_CHANGES_KEY)?
+				.map(|v2| v2.migrate())
+		},
+		Some(BABE_EPOCH_CHANGES_CURRENT_VERSION) =>
+			load_decode::<_, EpochChangesFor<Block, Epoch>>(backend, BABE_EPOCH_CHANGES_KEY)?,
+		Some(other) =>
+			return Err(ClientError::Backend(format!("Unsupported BABE DB version: {:?}", other))),
+	};
+
+	let epoch_changes =
+		SharedEpochChanges::<Block, Epoch>::new(maybe_epoch_changes.unwrap_or_else(|| {
+			info!(
+				target: LOG_TARGET,
+				"👶 Creating empty BABE epoch changes on what appears to be first startup.",
+			);
+			EpochChangesFor::<Block, Epoch>::default()
+		}));
+
+	// rebalance the tree after deserialization. this isn't strictly necessary
+	// since the tree is now rebalanced on every update operation. but since the
+	// tree wasn't rebalanced initially it's useful to temporarily leave it here
+	// to avoid having to wait until an import for rebalancing.
+	epoch_changes.shared_data().rebalance();
+
+	Ok(epoch_changes)
+}
+
+/// Update the epoch changes on disk after a change.
+pub(crate) fn write_epoch_changes<Block: BlockT, F, R>(
+	epoch_changes: &EpochChangesFor<Block, Epoch>,
+	write_aux: F,
+) -> R
+where
+	F: FnOnce(&[(&'static [u8], &[u8])]) -> R,
+{
+	BABE_EPOCH_CHANGES_CURRENT_VERSION.using_encoded(|version| {
+		let encoded_epoch_changes = epoch_changes.encode();
+		write_aux(&[
+			(BABE_EPOCH_CHANGES_KEY, encoded_epoch_changes.as_slice()),
+			(BABE_EPOCH_CHANGES_VERSION, version),
+		])
+	})
+}
+
+/// Write the cumulative chain-weight of a block ot aux storage.
+pub(crate) fn write_block_weight<H: Encode, F, R>(
+	block_hash: H,
+	block_weight: BabeBlockWeight,
+	write_aux: F,
+) -> R
+where
+	F: FnOnce(&[(Vec<u8>, &[u8])]) -> R,
+{
+	let key = block_weight_key(block_hash);
+	block_weight.using_encoded(|s| write_aux(&[(key, s)]))
+}
+
+/// Load the cumulative chain-weight associated with a block.
+pub fn load_block_weight<H: Encode, B: AuxStore>(
+	backend: &B,
+	block_hash: H,
+) -> ClientResult<Option<BabeBlockWeight>> {
+	load_decode(backend, block_weight_key(block_hash).as_slice())
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::migration::EpochV0;
+	use fork_tree::ForkTree;
+	use sc_consensus_epochs::{EpochHeader, PersistedEpoch, PersistedEpochHeader};
+	use sc_network_test::Block as TestBlock;
+	use sp_consensus::Error as ConsensusError;
+	use sp_consensus_babe::AllowedSlots;
+	use sp_core::H256;
+	use sp_runtime::traits::NumberFor;
+	use substrate_test_runtime_client;
+
+	#[test]
+	fn load_decode_from_v0_epoch_changes() {
+		let epoch = EpochV0 {
+			start_slot: 0.into(),
+			authorities: vec![],
+			randomness: [0; 32],
+			epoch_index: 1,
+			duration: 100,
+		};
+		let client = substrate_test_runtime_client::new();
+		let mut v0_tree = ForkTree::<H256, NumberFor<TestBlock>, _>::new();
+		v0_tree
+			.import::<_, ConsensusError>(
+				Default::default(),
+				Default::default(),
+				PersistedEpoch::Regular(epoch),
+				&|_, _| Ok(false), // Test is single item only so this can be set to false.
+			)
+			.unwrap();
+
+		client
+			.insert_aux(
+				&[(
+					BABE_EPOCH_CHANGES_KEY,
+					&EpochChangesV0For::<TestBlock, EpochV0>::from_raw(v0_tree).encode()[..],
+				)],
+				&[],
+			)
+			.unwrap();
+
+		assert_eq!(load_decode::<_, u32>(&client, BABE_EPOCH_CHANGES_VERSION).unwrap(), None);
+
+		let epoch_changes = load_epoch_changes::<TestBlock, _>(
+			&client,
+			&BabeConfiguration {
+				slot_duration: 10,
+				epoch_length: 4,
+				c: (3, 10),
+				authorities: Vec::new(),
+				randomness: Default::default(),
+				allowed_slots: AllowedSlots::PrimaryAndSecondaryPlainSlots,
+			},
+		)
+		.unwrap();
+
+		assert!(
+			epoch_changes
+				.shared_data()
+				.tree()
+				.iter()
+				.map(|(_, _, epoch)| epoch.clone())
+				.collect::<Vec<_>>() ==
+				vec![PersistedEpochHeader::Regular(EpochHeader {
+					start_slot: 0.into(),
+					end_slot: 100.into(),
+				})],
+		); // PersistedEpochHeader does not implement Debug, so we use assert! directly.
+
+		write_epoch_changes::<TestBlock, _, _>(&epoch_changes.shared_data(), |values| {
+			client.insert_aux(values, &[]).unwrap();
+		});
+
+		assert_eq!(load_decode::<_, u32>(&client, BABE_EPOCH_CHANGES_VERSION).unwrap(), Some(3));
+	}
+}
diff --git a/substrate/client/consensus/babe/src/lib.rs b/substrate/client/consensus/babe/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b89fa8f5df65e02807c59fde7a5e899ba97f44f8
--- /dev/null
+++ b/substrate/client/consensus/babe/src/lib.rs
@@ -0,0 +1,1939 @@
+// 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/>.
+
+//! # BABE (Blind Assignment for Blockchain Extension)
+//!
+//! BABE is a slot-based block production mechanism which uses a VRF PRNG to
+//! randomly perform the slot allocation. On every slot, all the authorities
+//! generate a new random number with the VRF function and if it is lower than a
+//! given threshold (which is proportional to their weight/stake) they have a
+//! right to produce a block. The proof of the VRF function execution will be
+//! used by other peer to validate the legitimacy of the slot claim.
+//!
+//! The engine is also responsible for collecting entropy on-chain which will be
+//! used to seed the given VRF PRNG. An epoch is a contiguous number of slots
+//! under which we will be using the same authority set. During an epoch all VRF
+//! outputs produced as a result of block production will be collected on an
+//! on-chain randomness pool. Epoch changes are announced one epoch in advance,
+//! i.e. when ending epoch N, we announce the parameters (randomness,
+//! authorities, etc.) for epoch N+2.
+//!
+//! Since the slot assignment is randomized, it is possible that a slot is
+//! assigned to multiple validators in which case we will have a temporary fork,
+//! or that a slot is assigned to no validator in which case no block is
+//! produced. Which means that block times are not deterministic.
+//!
+//! The protocol has a parameter `c` [0, 1] for which `1 - c` is the probability
+//! of a slot being empty. The choice of this parameter affects the security of
+//! the protocol relating to maximum tolerable network delays.
+//!
+//! In addition to the VRF-based slot assignment described above, which we will
+//! call primary slots, the engine also supports a deterministic secondary slot
+//! assignment. Primary slots take precedence over secondary slots, when
+//! authoring the node starts by trying to claim a primary slot and falls back
+//! to a secondary slot claim attempt. The secondary slot assignment is done
+//! by picking the authority at index:
+//!
+//! `blake2_256(epoch_randomness ++ slot_number) % authorities_len`.
+//!
+//! The secondary slots supports either a `SecondaryPlain` or `SecondaryVRF`
+//! variant. Comparing with `SecondaryPlain` variant, the `SecondaryVRF` variant
+//! generates an additional VRF output. The output is not included in beacon
+//! randomness, but can be consumed by parachains.
+//!
+//! The fork choice rule is weight-based, where weight equals the number of
+//! primary blocks in the chain. We will pick the heaviest chain (more primary
+//! blocks) and will go with the longest one in case of a tie.
+//!
+//! An in-depth description and analysis of the protocol can be found here:
+//! <https://research.web3.foundation/en/latest/polkadot/block-production/Babe.html>
+
+#![forbid(unsafe_code)]
+#![warn(missing_docs)]
+
+use std::{
+	collections::HashSet,
+	future::Future,
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+use codec::{Decode, Encode};
+use futures::{
+	channel::{
+		mpsc::{channel, Receiver, Sender},
+		oneshot,
+	},
+	prelude::*,
+};
+use log::{debug, info, log, trace, warn};
+use parking_lot::Mutex;
+use prometheus_endpoint::Registry;
+
+use sc_client_api::{
+	backend::AuxStore, AuxDataOperations, Backend as BackendT, FinalityNotification,
+	PreCommitActions, UsageProvider,
+};
+use sc_consensus::{
+	block_import::{
+		BlockCheckParams, BlockImport, BlockImportParams, ForkChoiceStrategy, ImportResult,
+		StateAction,
+	},
+	import_queue::{BasicQueue, BoxJustificationImport, DefaultImportQueue, Verifier},
+};
+use sc_consensus_epochs::{
+	descendent_query, Epoch as EpochT, EpochChangesFor, SharedEpochChanges, ViableEpochDescriptor,
+};
+use sc_consensus_slots::{
+	check_equivocation, BackoffAuthoringBlocksStrategy, CheckedHeader, InherentDataProviderExt,
+	SlotInfo, StorageChanges,
+};
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_TRACE};
+use sc_transaction_pool_api::OffchainTransactionPoolFactory;
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::AppCrypto;
+use sp_block_builder::BlockBuilder as BlockBuilderApi;
+use sp_blockchain::{
+	Backend as _, BlockStatus, Error as ClientError, ForkBackend, HeaderBackend, HeaderMetadata,
+	Result as ClientResult,
+};
+use sp_consensus::{BlockOrigin, Environment, Error as ConsensusError, Proposer, SelectChain};
+use sp_consensus_babe::inherents::BabeInherentData;
+use sp_consensus_slots::Slot;
+use sp_core::traits::SpawnEssentialNamed;
+use sp_inherents::{CreateInherentDataProviders, InherentData, InherentDataProvider};
+use sp_keystore::KeystorePtr;
+use sp_runtime::{
+	generic::OpaqueDigestItemId,
+	traits::{Block as BlockT, Header, NumberFor, SaturatedConversion, Zero},
+	DigestItem,
+};
+
+pub use sc_consensus_slots::SlotProportion;
+pub use sp_consensus::SyncOracle;
+pub use sp_consensus_babe::{
+	digests::{
+		CompatibleDigestItem, NextConfigDescriptor, NextEpochDescriptor, PreDigest,
+		PrimaryPreDigest, SecondaryPlainPreDigest,
+	},
+	AuthorityId, AuthorityPair, AuthoritySignature, BabeApi, BabeAuthorityWeight, BabeBlockWeight,
+	BabeConfiguration, BabeEpochConfiguration, ConsensusLog, Randomness, BABE_ENGINE_ID,
+};
+
+pub use aux_schema::load_block_weight as block_weight;
+
+mod migration;
+mod verification;
+
+pub mod authorship;
+pub mod aux_schema;
+#[cfg(test)]
+mod tests;
+
+const LOG_TARGET: &str = "babe";
+
+/// VRF context used for slots claiming lottery.
+const AUTHORING_SCORE_VRF_CONTEXT: &[u8] = b"substrate-babe-vrf";
+
+/// VRF output length for slots claiming lottery.
+const AUTHORING_SCORE_LENGTH: usize = 16;
+
+/// BABE epoch information
+#[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, scale_info::TypeInfo)]
+pub struct Epoch {
+	/// The epoch index.
+	pub epoch_index: u64,
+	/// The starting slot of the epoch.
+	pub start_slot: Slot,
+	/// The duration of this epoch.
+	pub duration: u64,
+	/// The authorities and their weights.
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+	/// Randomness for this epoch.
+	pub randomness: Randomness,
+	/// Configuration of the epoch.
+	pub config: BabeEpochConfiguration,
+}
+
+impl EpochT for Epoch {
+	type NextEpochDescriptor = (NextEpochDescriptor, BabeEpochConfiguration);
+	type Slot = Slot;
+
+	fn increment(
+		&self,
+		(descriptor, config): (NextEpochDescriptor, BabeEpochConfiguration),
+	) -> Epoch {
+		Epoch {
+			epoch_index: self.epoch_index + 1,
+			start_slot: self.start_slot + self.duration,
+			duration: self.duration,
+			authorities: descriptor.authorities,
+			randomness: descriptor.randomness,
+			config,
+		}
+	}
+
+	fn start_slot(&self) -> Slot {
+		self.start_slot
+	}
+
+	fn end_slot(&self) -> Slot {
+		self.start_slot + self.duration
+	}
+}
+
+impl From<sp_consensus_babe::Epoch> for Epoch {
+	fn from(epoch: sp_consensus_babe::Epoch) -> Self {
+		Epoch {
+			epoch_index: epoch.epoch_index,
+			start_slot: epoch.start_slot,
+			duration: epoch.duration,
+			authorities: epoch.authorities,
+			randomness: epoch.randomness,
+			config: epoch.config,
+		}
+	}
+}
+
+impl Epoch {
+	/// Create the genesis epoch (epoch #0).
+	///
+	/// This is defined to start at the slot of the first block, so that has to be provided.
+	pub fn genesis(genesis_config: &BabeConfiguration, slot: Slot) -> Epoch {
+		Epoch {
+			epoch_index: 0,
+			start_slot: slot,
+			duration: genesis_config.epoch_length,
+			authorities: genesis_config.authorities.clone(),
+			randomness: genesis_config.randomness,
+			config: BabeEpochConfiguration {
+				c: genesis_config.c,
+				allowed_slots: genesis_config.allowed_slots,
+			},
+		}
+	}
+
+	/// Clone and tweak epoch information to refer to the specified slot.
+	///
+	/// All the information which depends on the slot value is recomputed and assigned
+	/// to the returned epoch instance.
+	///
+	/// The `slot` must be greater than or equal the original epoch start slot,
+	/// if is less this operation is equivalent to a simple clone.
+	pub fn clone_for_slot(&self, slot: Slot) -> Epoch {
+		let mut epoch = self.clone();
+
+		let skipped_epochs = *slot.saturating_sub(self.start_slot) / self.duration;
+
+		let epoch_index = epoch.epoch_index.checked_add(skipped_epochs).expect(
+			"epoch number is u64; it should be strictly smaller than number of slots; \
+				slots relate in some way to wall clock time; \
+				if u64 is not enough we should crash for safety; qed.",
+		);
+
+		let start_slot = skipped_epochs
+			.checked_mul(epoch.duration)
+			.and_then(|skipped_slots| epoch.start_slot.checked_add(skipped_slots))
+			.expect(
+				"slot number is u64; it should relate in some way to wall clock time; \
+				 if u64 is not enough we should crash for safety; qed.",
+			);
+
+		epoch.epoch_index = epoch_index;
+		epoch.start_slot = Slot::from(start_slot);
+
+		epoch
+	}
+}
+
+/// Errors encountered by the babe authorship task.
+#[derive(Debug, thiserror::Error)]
+pub enum Error<B: BlockT> {
+	/// Multiple BABE pre-runtime digests
+	#[error("Multiple BABE pre-runtime digests, rejecting!")]
+	MultiplePreRuntimeDigests,
+	/// No BABE pre-runtime digest found
+	#[error("No BABE pre-runtime digest found")]
+	NoPreRuntimeDigest,
+	/// Multiple BABE epoch change digests
+	#[error("Multiple BABE epoch change digests, rejecting!")]
+	MultipleEpochChangeDigests,
+	/// Multiple BABE config change digests
+	#[error("Multiple BABE config change digests, rejecting!")]
+	MultipleConfigChangeDigests,
+	/// Could not extract timestamp and slot
+	#[error("Could not extract timestamp and slot: {0}")]
+	Extraction(ConsensusError),
+	/// Could not fetch epoch
+	#[error("Could not fetch epoch at {0:?}")]
+	FetchEpoch(B::Hash),
+	/// Header rejected: too far in the future
+	#[error("Header {0:?} rejected: too far in the future")]
+	TooFarInFuture(B::Hash),
+	/// Parent unavailable. Cannot import
+	#[error("Parent ({0}) of {1} unavailable. Cannot import")]
+	ParentUnavailable(B::Hash, B::Hash),
+	/// Slot number must increase
+	#[error("Slot number must increase: parent slot: {0}, this slot: {1}")]
+	SlotMustIncrease(Slot, Slot),
+	/// Header has a bad seal
+	#[error("Header {0:?} has a bad seal")]
+	HeaderBadSeal(B::Hash),
+	/// Header is unsealed
+	#[error("Header {0:?} is unsealed")]
+	HeaderUnsealed(B::Hash),
+	/// Slot author not found
+	#[error("Slot author not found")]
+	SlotAuthorNotFound,
+	/// Secondary slot assignments are disabled for the current epoch.
+	#[error("Secondary slot assignments are disabled for the current epoch.")]
+	SecondarySlotAssignmentsDisabled,
+	/// Bad signature
+	#[error("Bad signature on {0:?}")]
+	BadSignature(B::Hash),
+	/// Invalid author: Expected secondary author
+	#[error("Invalid author: Expected secondary author: {0:?}, got: {1:?}.")]
+	InvalidAuthor(AuthorityId, AuthorityId),
+	/// No secondary author expected.
+	#[error("No secondary author expected.")]
+	NoSecondaryAuthorExpected,
+	/// VRF verification failed
+	#[error("VRF verification failed")]
+	VrfVerificationFailed,
+	/// Primary slot threshold too low
+	#[error("VRF output rejected, threshold {0} exceeded")]
+	VrfThresholdExceeded(u128),
+	/// Could not fetch parent header
+	#[error("Could not fetch parent header: {0}")]
+	FetchParentHeader(sp_blockchain::Error),
+	/// Expected epoch change to happen.
+	#[error("Expected epoch change to happen at {0:?}, s{1}")]
+	ExpectedEpochChange(B::Hash, Slot),
+	/// Unexpected config change.
+	#[error("Unexpected config change")]
+	UnexpectedConfigChange,
+	/// Unexpected epoch change
+	#[error("Unexpected epoch change")]
+	UnexpectedEpochChange,
+	/// Parent block has no associated weight
+	#[error("Parent block of {0} has no associated weight")]
+	ParentBlockNoAssociatedWeight(B::Hash),
+	/// Check inherents error
+	#[error("Checking inherents failed: {0}")]
+	CheckInherents(sp_inherents::Error),
+	/// Unhandled check inherents error
+	#[error("Checking inherents unhandled error: {}", String::from_utf8_lossy(.0))]
+	CheckInherentsUnhandled(sp_inherents::InherentIdentifier),
+	/// Create inherents error.
+	#[error("Creating inherents failed: {0}")]
+	CreateInherents(sp_inherents::Error),
+	/// Background worker is not running and therefore requests cannot be answered.
+	#[error("Background worker is not running")]
+	BackgroundWorkerTerminated,
+	/// Client error
+	#[error(transparent)]
+	Client(sp_blockchain::Error),
+	/// Runtime Api error.
+	#[error(transparent)]
+	RuntimeApi(sp_api::ApiError),
+	/// Fork tree error
+	#[error(transparent)]
+	ForkTree(Box<fork_tree::Error<sp_blockchain::Error>>),
+}
+
+impl<B: BlockT> From<Error<B>> for String {
+	fn from(error: Error<B>) -> String {
+		error.to_string()
+	}
+}
+
+fn babe_err<B: BlockT>(error: Error<B>) -> Error<B> {
+	debug!(target: LOG_TARGET, "{}", error);
+	error
+}
+
+/// Intermediate value passed to block importer.
+pub struct BabeIntermediate<B: BlockT> {
+	/// The epoch descriptor.
+	pub epoch_descriptor: ViableEpochDescriptor<B::Hash, NumberFor<B>, Epoch>,
+}
+
+/// Intermediate key for Babe engine.
+pub static INTERMEDIATE_KEY: &[u8] = b"babe1";
+
+/// Read configuration from the runtime state at current best block.
+pub fn configuration<B: BlockT, C>(client: &C) -> ClientResult<BabeConfiguration>
+where
+	C: AuxStore + ProvideRuntimeApi<B> + UsageProvider<B>,
+	C::Api: BabeApi<B>,
+{
+	let at_hash = if client.usage_info().chain.finalized_state.is_some() {
+		client.usage_info().chain.best_hash
+	} else {
+		debug!(target: LOG_TARGET, "No finalized state is available. Reading config from genesis");
+		client.usage_info().chain.genesis_hash
+	};
+
+	let runtime_api = client.runtime_api();
+	let version = runtime_api.api_version::<dyn BabeApi<B>>(at_hash)?;
+
+	let config = match version {
+		Some(1) => {
+			#[allow(deprecated)]
+			{
+				runtime_api.configuration_before_version_2(at_hash)?.into()
+			}
+		},
+		Some(2) => runtime_api.configuration(at_hash)?,
+		_ =>
+			return Err(sp_blockchain::Error::VersionInvalid(
+				"Unsupported or invalid BabeApi version".to_string(),
+			)),
+	};
+	Ok(config)
+}
+
+/// Parameters for BABE.
+pub struct BabeParams<B: BlockT, C, SC, E, I, SO, L, CIDP, BS> {
+	/// The keystore that manages the keys of the node.
+	pub keystore: KeystorePtr,
+
+	/// The client to use
+	pub client: Arc<C>,
+
+	/// The SelectChain Strategy
+	pub select_chain: SC,
+
+	/// The environment we are producing blocks for.
+	pub env: E,
+
+	/// The underlying block-import object to supply our produced blocks to.
+	/// This must be a `BabeBlockImport` or a wrapper of it, otherwise
+	/// critical consensus logic will be omitted.
+	pub block_import: I,
+
+	/// A sync oracle
+	pub sync_oracle: SO,
+
+	/// Hook into the sync module to control the justification sync process.
+	pub justification_sync_link: L,
+
+	/// Something that can create the inherent data providers.
+	pub create_inherent_data_providers: CIDP,
+
+	/// Force authoring of blocks even if we are offline
+	pub force_authoring: bool,
+
+	/// Strategy and parameters for backing off block production.
+	pub backoff_authoring_blocks: Option<BS>,
+
+	/// The source of timestamps for relative slots
+	pub babe_link: BabeLink<B>,
+
+	/// The proportion of the slot dedicated to proposing.
+	///
+	/// The block proposing will be limited to this proportion of the slot from the starting of the
+	/// slot. However, the proposing can still take longer when there is some lenience factor
+	/// applied, because there were no blocks produced for some slots.
+	pub block_proposal_slot_portion: SlotProportion,
+
+	/// The maximum proportion of the slot dedicated to proposing with any lenience factor applied
+	/// due to no blocks being produced.
+	pub max_block_proposal_slot_portion: Option<SlotProportion>,
+
+	/// Handle use to report telemetries.
+	pub telemetry: Option<TelemetryHandle>,
+}
+
+/// Start the babe worker.
+pub fn start_babe<B, C, SC, E, I, SO, CIDP, BS, L, Error>(
+	BabeParams {
+		keystore,
+		client,
+		select_chain,
+		env,
+		block_import,
+		sync_oracle,
+		justification_sync_link,
+		create_inherent_data_providers,
+		force_authoring,
+		backoff_authoring_blocks,
+		babe_link,
+		block_proposal_slot_portion,
+		max_block_proposal_slot_portion,
+		telemetry,
+	}: BabeParams<B, C, SC, E, I, SO, L, CIDP, BS>,
+) -> Result<BabeWorker<B>, ConsensusError>
+where
+	B: BlockT,
+	C: ProvideRuntimeApi<B>
+		+ HeaderBackend<B>
+		+ HeaderMetadata<B, Error = ClientError>
+		+ Send
+		+ Sync
+		+ 'static,
+	C::Api: BabeApi<B>,
+	SC: SelectChain<B> + 'static,
+	E: Environment<B, Error = Error> + Send + Sync + 'static,
+	E::Proposer: Proposer<B, Error = Error>,
+	I: BlockImport<B, Error = ConsensusError> + Send + Sync + 'static,
+	SO: SyncOracle + Send + Sync + Clone + 'static,
+	L: sc_consensus::JustificationSyncLink<B> + 'static,
+	CIDP: CreateInherentDataProviders<B, ()> + Send + Sync + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
+	BS: BackoffAuthoringBlocksStrategy<NumberFor<B>> + Send + Sync + 'static,
+	Error: std::error::Error + Send + From<ConsensusError> + From<I::Error> + 'static,
+{
+	let slot_notification_sinks = Arc::new(Mutex::new(Vec::new()));
+
+	let worker = BabeSlotWorker {
+		client: client.clone(),
+		block_import,
+		env,
+		sync_oracle: sync_oracle.clone(),
+		justification_sync_link,
+		force_authoring,
+		backoff_authoring_blocks,
+		keystore,
+		epoch_changes: babe_link.epoch_changes.clone(),
+		slot_notification_sinks: slot_notification_sinks.clone(),
+		config: babe_link.config.clone(),
+		block_proposal_slot_portion,
+		max_block_proposal_slot_portion,
+		telemetry,
+	};
+
+	info!(target: LOG_TARGET, "👶 Starting BABE Authorship worker");
+
+	let slot_worker = sc_consensus_slots::start_slot_worker(
+		babe_link.config.slot_duration(),
+		select_chain,
+		sc_consensus_slots::SimpleSlotWorkerToSlotWorker(worker),
+		sync_oracle,
+		create_inherent_data_providers,
+	);
+
+	Ok(BabeWorker { inner: Box::pin(slot_worker), slot_notification_sinks })
+}
+
+// Remove obsolete block's weight data by leveraging finality notifications.
+// This includes data for all finalized blocks (excluding the most recent one)
+// and all stale branches.
+fn aux_storage_cleanup<C: HeaderMetadata<Block> + HeaderBackend<Block>, Block: BlockT>(
+	client: &C,
+	notification: &FinalityNotification<Block>,
+) -> AuxDataOperations {
+	let mut hashes = HashSet::new();
+
+	let first = notification.tree_route.first().unwrap_or(&notification.hash);
+	match client.header_metadata(*first) {
+		Ok(meta) => {
+			hashes.insert(meta.parent);
+		},
+		Err(err) => {
+			warn!(target: LOG_TARGET, "Failed to lookup metadata for block `{:?}`: {}", first, err,)
+		},
+	}
+
+	// Cleans data for finalized block's ancestors
+	hashes.extend(
+		notification
+			.tree_route
+			.iter()
+			// Ensure we don't prune latest finalized block.
+			// This should not happen, but better be safe than sorry!
+			.filter(|h| **h != notification.hash),
+	);
+
+	// Cleans data for stale forks.
+	let stale_forks = match client.expand_forks(&notification.stale_heads) {
+		Ok(stale_forks) => stale_forks,
+		Err((stale_forks, e)) => {
+			warn!(target: LOG_TARGET, "{:?}", e);
+			stale_forks
+		},
+	};
+	hashes.extend(stale_forks.iter());
+
+	hashes
+		.into_iter()
+		.map(|val| (aux_schema::block_weight_key(val), None))
+		.collect()
+}
+
+async fn answer_requests<B: BlockT, C>(
+	mut request_rx: Receiver<BabeRequest<B>>,
+	config: BabeConfiguration,
+	client: Arc<C>,
+	epoch_changes: SharedEpochChanges<B, Epoch>,
+) where
+	C: HeaderBackend<B> + HeaderMetadata<B, Error = ClientError>,
+{
+	while let Some(request) = request_rx.next().await {
+		match request {
+			BabeRequest::EpochData(response) => {
+				let _ = response.send(epoch_changes.shared_data().clone());
+			},
+			BabeRequest::EpochDataForChildOf(parent_hash, parent_number, slot, response) => {
+				let lookup = || {
+					let epoch_changes = epoch_changes.shared_data();
+					epoch_changes
+						.epoch_data_for_child_of(
+							descendent_query(&*client),
+							&parent_hash,
+							parent_number,
+							slot,
+							|slot| Epoch::genesis(&config, slot),
+						)
+						.map_err(|e| Error::<B>::ForkTree(Box::new(e)))?
+						.ok_or(Error::<B>::FetchEpoch(parent_hash))
+				};
+
+				let _ = response.send(lookup());
+			},
+		}
+	}
+}
+
+/// Requests to the BABE service.
+enum BabeRequest<B: BlockT> {
+	/// Request all available epoch data.
+	EpochData(oneshot::Sender<EpochChangesFor<B, Epoch>>),
+	/// Request the epoch that a child of the given block, with the given slot number would have.
+	///
+	/// The parent block is identified by its hash and number.
+	EpochDataForChildOf(B::Hash, NumberFor<B>, Slot, oneshot::Sender<Result<Epoch, Error<B>>>),
+}
+
+/// A handle to the BABE worker for issuing requests.
+#[derive(Clone)]
+pub struct BabeWorkerHandle<B: BlockT>(Sender<BabeRequest<B>>);
+
+impl<B: BlockT> BabeWorkerHandle<B> {
+	async fn send_request(&self, request: BabeRequest<B>) -> Result<(), Error<B>> {
+		match self.0.clone().send(request).await {
+			Err(err) if err.is_disconnected() => return Err(Error::BackgroundWorkerTerminated),
+			Err(err) => warn!(
+				target: LOG_TARGET,
+				"Unhandled error when sending request to worker: {:?}", err
+			),
+			_ => {},
+		}
+
+		Ok(())
+	}
+
+	/// Fetch all available epoch data.
+	pub async fn epoch_data(&self) -> Result<EpochChangesFor<B, Epoch>, Error<B>> {
+		let (tx, rx) = oneshot::channel();
+		self.send_request(BabeRequest::EpochData(tx)).await?;
+
+		rx.await.or(Err(Error::BackgroundWorkerTerminated))
+	}
+
+	/// Fetch the epoch that a child of the given block, with the given slot number would have.
+	///
+	/// The parent block is identified by its hash and number.
+	pub async fn epoch_data_for_child_of(
+		&self,
+		parent_hash: B::Hash,
+		parent_number: NumberFor<B>,
+		slot: Slot,
+	) -> Result<Epoch, Error<B>> {
+		let (tx, rx) = oneshot::channel();
+		self.send_request(BabeRequest::EpochDataForChildOf(parent_hash, parent_number, slot, tx))
+			.await?;
+
+		rx.await.or(Err(Error::BackgroundWorkerTerminated))?
+	}
+}
+
+/// Worker for Babe which implements `Future<Output=()>`. This must be polled.
+#[must_use]
+pub struct BabeWorker<B: BlockT> {
+	inner: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+	slot_notification_sinks: SlotNotificationSinks<B>,
+}
+
+impl<B: BlockT> BabeWorker<B> {
+	/// Return an event stream of notifications for when new slot happens, and the corresponding
+	/// epoch descriptor.
+	pub fn slot_notification_stream(
+		&self,
+	) -> Receiver<(Slot, ViableEpochDescriptor<B::Hash, NumberFor<B>, Epoch>)> {
+		const CHANNEL_BUFFER_SIZE: usize = 1024;
+
+		let (sink, stream) = channel(CHANNEL_BUFFER_SIZE);
+		self.slot_notification_sinks.lock().push(sink);
+		stream
+	}
+}
+
+impl<B: BlockT> Future for BabeWorker<B> {
+	type Output = ();
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		self.inner.as_mut().poll(cx)
+	}
+}
+
+/// Slot notification sinks.
+type SlotNotificationSinks<B> = Arc<
+	Mutex<Vec<Sender<(Slot, ViableEpochDescriptor<<B as BlockT>::Hash, NumberFor<B>, Epoch>)>>>,
+>;
+
+struct BabeSlotWorker<B: BlockT, C, E, I, SO, L, BS> {
+	client: Arc<C>,
+	block_import: I,
+	env: E,
+	sync_oracle: SO,
+	justification_sync_link: L,
+	force_authoring: bool,
+	backoff_authoring_blocks: Option<BS>,
+	keystore: KeystorePtr,
+	epoch_changes: SharedEpochChanges<B, Epoch>,
+	slot_notification_sinks: SlotNotificationSinks<B>,
+	config: BabeConfiguration,
+	block_proposal_slot_portion: SlotProportion,
+	max_block_proposal_slot_portion: Option<SlotProportion>,
+	telemetry: Option<TelemetryHandle>,
+}
+
+#[async_trait::async_trait]
+impl<B, C, E, I, Error, SO, L, BS> sc_consensus_slots::SimpleSlotWorker<B>
+	for BabeSlotWorker<B, C, E, I, SO, L, BS>
+where
+	B: BlockT,
+	C: ProvideRuntimeApi<B> + HeaderBackend<B> + HeaderMetadata<B, Error = ClientError>,
+	C::Api: BabeApi<B>,
+	E: Environment<B, Error = Error> + Sync,
+	E::Proposer: Proposer<B, Error = Error>,
+	I: BlockImport<B> + Send + Sync + 'static,
+	SO: SyncOracle + Send + Clone + Sync,
+	L: sc_consensus::JustificationSyncLink<B>,
+	BS: BackoffAuthoringBlocksStrategy<NumberFor<B>> + Sync,
+	Error: std::error::Error + Send + From<ConsensusError> + From<I::Error> + 'static,
+{
+	type Claim = (PreDigest, AuthorityId);
+	type SyncOracle = SO;
+	type JustificationSyncLink = L;
+	type CreateProposer =
+		Pin<Box<dyn Future<Output = Result<E::Proposer, ConsensusError>> + Send + 'static>>;
+	type Proposer = E::Proposer;
+	type BlockImport = I;
+	type AuxData = ViableEpochDescriptor<B::Hash, NumberFor<B>, Epoch>;
+
+	fn logging_target(&self) -> &'static str {
+		LOG_TARGET
+	}
+
+	fn block_import(&mut self) -> &mut Self::BlockImport {
+		&mut self.block_import
+	}
+
+	fn aux_data(&self, parent: &B::Header, slot: Slot) -> Result<Self::AuxData, ConsensusError> {
+		self.epoch_changes
+			.shared_data()
+			.epoch_descriptor_for_child_of(
+				descendent_query(&*self.client),
+				&parent.hash(),
+				*parent.number(),
+				slot,
+			)
+			.map_err(|e| ConsensusError::ChainLookup(e.to_string()))?
+			.ok_or(ConsensusError::InvalidAuthoritiesSet)
+	}
+
+	fn authorities_len(&self, epoch_descriptor: &Self::AuxData) -> Option<usize> {
+		self.epoch_changes
+			.shared_data()
+			.viable_epoch(epoch_descriptor, |slot| Epoch::genesis(&self.config, slot))
+			.map(|epoch| epoch.as_ref().authorities.len())
+	}
+
+	async fn claim_slot(
+		&self,
+		_parent_header: &B::Header,
+		slot: Slot,
+		epoch_descriptor: &ViableEpochDescriptor<B::Hash, NumberFor<B>, Epoch>,
+	) -> Option<Self::Claim> {
+		debug!(target: LOG_TARGET, "Attempting to claim slot {}", slot);
+		let s = authorship::claim_slot(
+			slot,
+			self.epoch_changes
+				.shared_data()
+				.viable_epoch(epoch_descriptor, |slot| Epoch::genesis(&self.config, slot))?
+				.as_ref(),
+			&self.keystore,
+		);
+
+		if s.is_some() {
+			debug!(target: LOG_TARGET, "Claimed slot {}", slot);
+		}
+
+		s
+	}
+
+	fn notify_slot(
+		&self,
+		_parent_header: &B::Header,
+		slot: Slot,
+		epoch_descriptor: &ViableEpochDescriptor<B::Hash, NumberFor<B>, Epoch>,
+	) {
+		let sinks = &mut self.slot_notification_sinks.lock();
+		sinks.retain_mut(|sink| match sink.try_send((slot, epoch_descriptor.clone())) {
+			Ok(()) => true,
+			Err(e) =>
+				if e.is_full() {
+					warn!(target: LOG_TARGET, "Trying to notify a slot but the channel is full");
+					true
+				} else {
+					false
+				},
+		});
+	}
+
+	fn pre_digest_data(&self, _slot: Slot, claim: &Self::Claim) -> Vec<sp_runtime::DigestItem> {
+		vec![<DigestItem as CompatibleDigestItem>::babe_pre_digest(claim.0.clone())]
+	}
+
+	async fn block_import_params(
+		&self,
+		header: B::Header,
+		header_hash: &B::Hash,
+		body: Vec<B::Extrinsic>,
+		storage_changes: StorageChanges<B>,
+		(_, public): Self::Claim,
+		epoch_descriptor: Self::AuxData,
+	) -> Result<BlockImportParams<B>, ConsensusError> {
+		let signature = self
+			.keystore
+			.sr25519_sign(<AuthorityId as AppCrypto>::ID, public.as_ref(), header_hash.as_ref())
+			.map_err(|e| ConsensusError::CannotSign(format!("{}. Key: {:?}", e, public)))?
+			.ok_or_else(|| {
+				ConsensusError::CannotSign(format!(
+					"Could not find key in keystore. Key: {:?}",
+					public
+				))
+			})?;
+
+		let digest_item = <DigestItem as CompatibleDigestItem>::babe_seal(signature.into());
+
+		let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
+		import_block.post_digests.push(digest_item);
+		import_block.body = Some(body);
+		import_block.state_action =
+			StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(storage_changes));
+		import_block
+			.insert_intermediate(INTERMEDIATE_KEY, BabeIntermediate::<B> { epoch_descriptor });
+
+		Ok(import_block)
+	}
+
+	fn force_authoring(&self) -> bool {
+		self.force_authoring
+	}
+
+	fn should_backoff(&self, slot: Slot, chain_head: &B::Header) -> bool {
+		if let Some(ref strategy) = self.backoff_authoring_blocks {
+			if let Ok(chain_head_slot) =
+				find_pre_digest::<B>(chain_head).map(|digest| digest.slot())
+			{
+				return strategy.should_backoff(
+					*chain_head.number(),
+					chain_head_slot,
+					self.client.info().finalized_number,
+					slot,
+					self.logging_target(),
+				)
+			}
+		}
+		false
+	}
+
+	fn sync_oracle(&mut self) -> &mut Self::SyncOracle {
+		&mut self.sync_oracle
+	}
+
+	fn justification_sync_link(&mut self) -> &mut Self::JustificationSyncLink {
+		&mut self.justification_sync_link
+	}
+
+	fn proposer(&mut self, block: &B::Header) -> Self::CreateProposer {
+		Box::pin(self.env.init(block).map_err(|e| ConsensusError::ClientImport(e.to_string())))
+	}
+
+	fn telemetry(&self) -> Option<TelemetryHandle> {
+		self.telemetry.clone()
+	}
+
+	fn proposing_remaining_duration(&self, slot_info: &SlotInfo<B>) -> Duration {
+		let parent_slot = find_pre_digest::<B>(&slot_info.chain_head).ok().map(|d| d.slot());
+
+		sc_consensus_slots::proposing_remaining_duration(
+			parent_slot,
+			slot_info,
+			&self.block_proposal_slot_portion,
+			self.max_block_proposal_slot_portion.as_ref(),
+			sc_consensus_slots::SlotLenienceType::Exponential,
+			self.logging_target(),
+		)
+	}
+}
+
+/// Extract the BABE pre digest from the given header. Pre-runtime digests are
+/// mandatory, the function will return `Err` if none is found.
+pub fn find_pre_digest<B: BlockT>(header: &B::Header) -> Result<PreDigest, Error<B>> {
+	// genesis block doesn't contain a pre digest so let's generate a
+	// dummy one to not break any invariants in the rest of the code
+	if header.number().is_zero() {
+		return Ok(PreDigest::SecondaryPlain(SecondaryPlainPreDigest {
+			slot: 0.into(),
+			authority_index: 0,
+		}))
+	}
+
+	let mut pre_digest: Option<_> = None;
+	for log in header.digest().logs() {
+		trace!(target: LOG_TARGET, "Checking log {:?}, looking for pre runtime digest", log);
+		match (log.as_babe_pre_digest(), pre_digest.is_some()) {
+			(Some(_), true) => return Err(babe_err(Error::MultiplePreRuntimeDigests)),
+			(None, _) => trace!(target: LOG_TARGET, "Ignoring digest not meant for us"),
+			(s, false) => pre_digest = s,
+		}
+	}
+	pre_digest.ok_or_else(|| babe_err(Error::NoPreRuntimeDigest))
+}
+
+/// Extract the BABE epoch change digest from the given header, if it exists.
+fn find_next_epoch_digest<B: BlockT>(
+	header: &B::Header,
+) -> Result<Option<NextEpochDescriptor>, Error<B>> {
+	let mut epoch_digest: Option<_> = None;
+	for log in header.digest().logs() {
+		trace!(target: LOG_TARGET, "Checking log {:?}, looking for epoch change digest.", log);
+		let log = log.try_to::<ConsensusLog>(OpaqueDigestItemId::Consensus(&BABE_ENGINE_ID));
+		match (log, epoch_digest.is_some()) {
+			(Some(ConsensusLog::NextEpochData(_)), true) =>
+				return Err(babe_err(Error::MultipleEpochChangeDigests)),
+			(Some(ConsensusLog::NextEpochData(epoch)), false) => epoch_digest = Some(epoch),
+			_ => trace!(target: LOG_TARGET, "Ignoring digest not meant for us"),
+		}
+	}
+
+	Ok(epoch_digest)
+}
+
+/// Extract the BABE config change digest from the given header, if it exists.
+fn find_next_config_digest<B: BlockT>(
+	header: &B::Header,
+) -> Result<Option<NextConfigDescriptor>, Error<B>> {
+	let mut config_digest: Option<_> = None;
+	for log in header.digest().logs() {
+		trace!(target: LOG_TARGET, "Checking log {:?}, looking for epoch change digest.", log);
+		let log = log.try_to::<ConsensusLog>(OpaqueDigestItemId::Consensus(&BABE_ENGINE_ID));
+		match (log, config_digest.is_some()) {
+			(Some(ConsensusLog::NextConfigData(_)), true) =>
+				return Err(babe_err(Error::MultipleConfigChangeDigests)),
+			(Some(ConsensusLog::NextConfigData(config)), false) => config_digest = Some(config),
+			_ => trace!(target: LOG_TARGET, "Ignoring digest not meant for us"),
+		}
+	}
+
+	Ok(config_digest)
+}
+
+/// State that must be shared between the import queue and the authoring logic.
+#[derive(Clone)]
+pub struct BabeLink<Block: BlockT> {
+	epoch_changes: SharedEpochChanges<Block, Epoch>,
+	config: BabeConfiguration,
+}
+
+impl<Block: BlockT> BabeLink<Block> {
+	/// Get the epoch changes of this link.
+	pub fn epoch_changes(&self) -> &SharedEpochChanges<Block, Epoch> {
+		&self.epoch_changes
+	}
+
+	/// Get the config of this link.
+	pub fn config(&self) -> &BabeConfiguration {
+		&self.config
+	}
+}
+
+/// A verifier for Babe blocks.
+pub struct BabeVerifier<Block: BlockT, Client, SelectChain, CIDP> {
+	client: Arc<Client>,
+	select_chain: SelectChain,
+	create_inherent_data_providers: CIDP,
+	config: BabeConfiguration,
+	epoch_changes: SharedEpochChanges<Block, Epoch>,
+	telemetry: Option<TelemetryHandle>,
+	offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>,
+}
+
+impl<Block, Client, SelectChain, CIDP> BabeVerifier<Block, Client, SelectChain, CIDP>
+where
+	Block: BlockT,
+	Client: AuxStore + HeaderBackend<Block> + HeaderMetadata<Block> + ProvideRuntimeApi<Block>,
+	Client::Api: BlockBuilderApi<Block> + BabeApi<Block>,
+	SelectChain: sp_consensus::SelectChain<Block>,
+	CIDP: CreateInherentDataProviders<Block, ()>,
+{
+	async fn check_inherents(
+		&self,
+		block: Block,
+		at_hash: Block::Hash,
+		inherent_data: InherentData,
+		create_inherent_data_providers: CIDP::InherentDataProviders,
+	) -> Result<(), Error<Block>> {
+		let inherent_res = self
+			.client
+			.runtime_api()
+			.check_inherents(at_hash, block, inherent_data)
+			.map_err(Error::RuntimeApi)?;
+
+		if !inherent_res.ok() {
+			for (i, e) in inherent_res.into_errors() {
+				match create_inherent_data_providers.try_handle_error(&i, &e).await {
+					Some(res) => res.map_err(|e| Error::CheckInherents(e))?,
+					None => return Err(Error::CheckInherentsUnhandled(i)),
+				}
+			}
+		}
+
+		Ok(())
+	}
+
+	async fn check_and_report_equivocation(
+		&self,
+		slot_now: Slot,
+		slot: Slot,
+		header: &Block::Header,
+		author: &AuthorityId,
+		origin: &BlockOrigin,
+	) -> Result<(), Error<Block>> {
+		// don't report any equivocations during initial sync
+		// as they are most likely stale.
+		if *origin == BlockOrigin::NetworkInitialSync {
+			return Ok(())
+		}
+
+		// check if authorship of this header is an equivocation and return a proof if so.
+		let equivocation_proof =
+			match check_equivocation(&*self.client, slot_now, slot, header, author)
+				.map_err(Error::Client)?
+			{
+				Some(proof) => proof,
+				None => return Ok(()),
+			};
+
+		info!(
+			"Slot author {:?} is equivocating at slot {} with headers {:?} and {:?}",
+			author,
+			slot,
+			equivocation_proof.first_header.hash(),
+			equivocation_proof.second_header.hash(),
+		);
+
+		// get the best block on which we will build and send the equivocation report.
+		let best_hash = self
+			.select_chain
+			.best_chain()
+			.await
+			.map(|h| h.hash())
+			.map_err(|e| Error::Client(e.into()))?;
+
+		// generate a key ownership proof. we start by trying to generate the
+		// key ownership proof at the parent of the equivocating header, this
+		// will make sure that proof generation is successful since it happens
+		// during the on-going session (i.e. session keys are available in the
+		// state to be able to generate the proof). this might fail if the
+		// equivocation happens on the first block of the session, in which case
+		// its parent would be on the previous session. if generation on the
+		// parent header fails we try with best block as well.
+		let generate_key_owner_proof = |at_hash: Block::Hash| {
+			self.client
+				.runtime_api()
+				.generate_key_ownership_proof(at_hash, slot, equivocation_proof.offender.clone())
+				.map_err(Error::RuntimeApi)
+		};
+
+		let parent_hash = *header.parent_hash();
+		let key_owner_proof = match generate_key_owner_proof(parent_hash)? {
+			Some(proof) => proof,
+			None => match generate_key_owner_proof(best_hash)? {
+				Some(proof) => proof,
+				None => {
+					debug!(
+						target: LOG_TARGET,
+						"Equivocation offender is not part of the authority set."
+					);
+					return Ok(())
+				},
+			},
+		};
+
+		// submit equivocation report at best block.
+		let mut runtime_api = self.client.runtime_api();
+
+		// Register the offchain tx pool to be able to use it from the runtime.
+		runtime_api
+			.register_extension(self.offchain_tx_pool_factory.offchain_transaction_pool(best_hash));
+
+		runtime_api
+			.submit_report_equivocation_unsigned_extrinsic(
+				best_hash,
+				equivocation_proof,
+				key_owner_proof,
+			)
+			.map_err(Error::RuntimeApi)?;
+
+		info!(target: LOG_TARGET, "Submitted equivocation report for author {:?}", author);
+
+		Ok(())
+	}
+}
+
+#[async_trait::async_trait]
+impl<Block, Client, SelectChain, CIDP> Verifier<Block>
+	for BabeVerifier<Block, Client, SelectChain, CIDP>
+where
+	Block: BlockT,
+	Client: HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ AuxStore,
+	Client::Api: BlockBuilderApi<Block> + BabeApi<Block>,
+	SelectChain: sp_consensus::SelectChain<Block>,
+	CIDP: CreateInherentDataProviders<Block, ()> + Send + Sync,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
+{
+	async fn verify(
+		&mut self,
+		mut block: BlockImportParams<Block>,
+	) -> Result<BlockImportParams<Block>, String> {
+		trace!(
+			target: LOG_TARGET,
+			"Verifying origin: {:?} header: {:?} justification(s): {:?} body: {:?}",
+			block.origin,
+			block.header,
+			block.justifications,
+			block.body,
+		);
+
+		let hash = block.header.hash();
+		let parent_hash = *block.header.parent_hash();
+
+		let info = self.client.info();
+		let number = *block.header.number();
+
+		if info.block_gap.map_or(false, |(s, e)| s <= number && number <= e) || block.with_state() {
+			// Verification for imported blocks is skipped in two cases:
+			// 1. When importing blocks below the last finalized block during network initial
+			//    synchronization.
+			// 2. When importing whole state we don't calculate epoch descriptor, but rather read it
+			//    from the state after import. We also skip all verifications because there's no
+			//    parent state and we trust the sync module to verify that the state is correct and
+			//    finalized.
+			return Ok(block)
+		}
+
+		debug!(
+			target: LOG_TARGET,
+			"We have {:?} logs in this header",
+			block.header.digest().logs().len()
+		);
+
+		let create_inherent_data_providers = self
+			.create_inherent_data_providers
+			.create_inherent_data_providers(parent_hash, ())
+			.await
+			.map_err(|e| Error::<Block>::Client(ConsensusError::from(e).into()))?;
+
+		let slot_now = create_inherent_data_providers.slot();
+
+		let parent_header_metadata = self
+			.client
+			.header_metadata(parent_hash)
+			.map_err(Error::<Block>::FetchParentHeader)?;
+
+		let pre_digest = find_pre_digest::<Block>(&block.header)?;
+		let (check_header, epoch_descriptor) = {
+			let epoch_changes = self.epoch_changes.shared_data();
+			let epoch_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(
+					descendent_query(&*self.client),
+					&parent_hash,
+					parent_header_metadata.number,
+					pre_digest.slot(),
+				)
+				.map_err(|e| Error::<Block>::ForkTree(Box::new(e)))?
+				.ok_or(Error::<Block>::FetchEpoch(parent_hash))?;
+			let viable_epoch = epoch_changes
+				.viable_epoch(&epoch_descriptor, |slot| Epoch::genesis(&self.config, slot))
+				.ok_or(Error::<Block>::FetchEpoch(parent_hash))?;
+
+			// We add one to the current slot to allow for some small drift.
+			// FIXME #1019 in the future, alter this queue to allow deferring of headers
+			let v_params = verification::VerificationParams {
+				header: block.header.clone(),
+				pre_digest: Some(pre_digest),
+				slot_now: slot_now + 1,
+				epoch: viable_epoch.as_ref(),
+			};
+
+			(verification::check_header::<Block>(v_params)?, epoch_descriptor)
+		};
+
+		match check_header {
+			CheckedHeader::Checked(pre_header, verified_info) => {
+				let babe_pre_digest = verified_info
+					.pre_digest
+					.as_babe_pre_digest()
+					.expect("check_header always returns a pre-digest digest item; qed");
+				let slot = babe_pre_digest.slot();
+
+				// the header is valid but let's check if there was something else already
+				// proposed at the same slot by the given author. if there was, we will
+				// report the equivocation to the runtime.
+				if let Err(err) = self
+					.check_and_report_equivocation(
+						slot_now,
+						slot,
+						&block.header,
+						&verified_info.author,
+						&block.origin,
+					)
+					.await
+				{
+					warn!(
+						target: LOG_TARGET,
+						"Error checking/reporting BABE equivocation: {}", err
+					);
+				}
+
+				if let Some(inner_body) = block.body {
+					let new_block = Block::new(pre_header.clone(), inner_body);
+					if !block.state_action.skip_execution_checks() {
+						// if the body is passed through and the block was executed,
+						// we need to use the runtime to check that the internally-set
+						// timestamp in the inherents actually matches the slot set in the seal.
+						let mut inherent_data = create_inherent_data_providers
+							.create_inherent_data()
+							.await
+							.map_err(Error::<Block>::CreateInherents)?;
+						inherent_data.babe_replace_inherent_data(slot);
+
+						self.check_inherents(
+							new_block.clone(),
+							parent_hash,
+							inherent_data,
+							create_inherent_data_providers,
+						)
+						.await?;
+					}
+
+					let (_, inner_body) = new_block.deconstruct();
+					block.body = Some(inner_body);
+				}
+
+				trace!(target: LOG_TARGET, "Checked {:?}; importing.", pre_header);
+				telemetry!(
+					self.telemetry;
+					CONSENSUS_TRACE;
+					"babe.checked_and_importing";
+					"pre_header" => ?pre_header,
+				);
+
+				block.header = pre_header;
+				block.post_digests.push(verified_info.seal);
+				block.insert_intermediate(
+					INTERMEDIATE_KEY,
+					BabeIntermediate::<Block> { epoch_descriptor },
+				);
+				block.post_hash = Some(hash);
+
+				Ok(block)
+			},
+			CheckedHeader::Deferred(a, b) => {
+				debug!(target: LOG_TARGET, "Checking {:?} failed; {:?}, {:?}.", hash, a, b);
+				telemetry!(
+					self.telemetry;
+					CONSENSUS_DEBUG;
+					"babe.header_too_far_in_future";
+					"hash" => ?hash, "a" => ?a, "b" => ?b
+				);
+				Err(Error::<Block>::TooFarInFuture(hash).into())
+			},
+		}
+	}
+}
+
+/// A block-import handler for BABE.
+///
+/// This scans each imported block for epoch change signals. The signals are
+/// tracked in a tree (of all forks), and the import logic validates all epoch
+/// change transitions, i.e. whether a given epoch change is expected or whether
+/// it is missing.
+///
+/// The epoch change tree should be pruned as blocks are finalized.
+pub struct BabeBlockImport<Block: BlockT, Client, I> {
+	inner: I,
+	client: Arc<Client>,
+	epoch_changes: SharedEpochChanges<Block, Epoch>,
+	config: BabeConfiguration,
+}
+
+impl<Block: BlockT, I: Clone, Client> Clone for BabeBlockImport<Block, Client, I> {
+	fn clone(&self) -> Self {
+		BabeBlockImport {
+			inner: self.inner.clone(),
+			client: self.client.clone(),
+			epoch_changes: self.epoch_changes.clone(),
+			config: self.config.clone(),
+		}
+	}
+}
+
+impl<Block: BlockT, Client, I> BabeBlockImport<Block, Client, I> {
+	fn new(
+		client: Arc<Client>,
+		epoch_changes: SharedEpochChanges<Block, Epoch>,
+		block_import: I,
+		config: BabeConfiguration,
+	) -> Self {
+		BabeBlockImport { client, inner: block_import, epoch_changes, config }
+	}
+}
+
+impl<Block, Client, Inner> BabeBlockImport<Block, Client, Inner>
+where
+	Block: BlockT,
+	Inner: BlockImport<Block> + Send + Sync,
+	Inner::Error: Into<ConsensusError>,
+	Client: HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ AuxStore
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync,
+	Client::Api: BabeApi<Block> + ApiExt<Block>,
+{
+	/// Import whole state after warp sync.
+	// This function makes multiple transactions to the DB. If one of them fails we may
+	// end up in an inconsistent state and have to resync.
+	async fn import_state(
+		&mut self,
+		mut block: BlockImportParams<Block>,
+	) -> Result<ImportResult, ConsensusError> {
+		let hash = block.post_hash();
+		let parent_hash = *block.header.parent_hash();
+		let number = *block.header.number();
+
+		block.fork_choice = Some(ForkChoiceStrategy::Custom(true));
+		// Reset block weight.
+		aux_schema::write_block_weight(hash, 0, |values| {
+			block
+				.auxiliary
+				.extend(values.iter().map(|(k, v)| (k.to_vec(), Some(v.to_vec()))))
+		});
+
+		// First make the client import the state.
+		let import_result = self.inner.import_block(block).await;
+		let aux = match import_result {
+			Ok(ImportResult::Imported(aux)) => aux,
+			Ok(r) =>
+				return Err(ConsensusError::ClientImport(format!(
+					"Unexpected import result: {:?}",
+					r
+				))),
+			Err(r) => return Err(r.into()),
+		};
+
+		// Read epoch info from the imported state.
+		let current_epoch = self.client.runtime_api().current_epoch(hash).map_err(|e| {
+			ConsensusError::ClientImport(babe_err::<Block>(Error::RuntimeApi(e)).into())
+		})?;
+		let next_epoch = self.client.runtime_api().next_epoch(hash).map_err(|e| {
+			ConsensusError::ClientImport(babe_err::<Block>(Error::RuntimeApi(e)).into())
+		})?;
+
+		let mut epoch_changes = self.epoch_changes.shared_data_locked();
+		epoch_changes.reset(parent_hash, hash, number, current_epoch.into(), next_epoch.into());
+		aux_schema::write_epoch_changes::<Block, _, _>(&*epoch_changes, |insert| {
+			self.client.insert_aux(insert, [])
+		})
+		.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+
+		Ok(ImportResult::Imported(aux))
+	}
+}
+
+#[async_trait::async_trait]
+impl<Block, Client, Inner> BlockImport<Block> for BabeBlockImport<Block, Client, Inner>
+where
+	Block: BlockT,
+	Inner: BlockImport<Block> + Send + Sync,
+	Inner::Error: Into<ConsensusError>,
+	Client: HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ AuxStore
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync,
+	Client::Api: BabeApi<Block> + ApiExt<Block>,
+{
+	type Error = ConsensusError;
+
+	async fn import_block(
+		&mut self,
+		mut block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		let hash = block.post_hash();
+		let number = *block.header.number();
+		let info = self.client.info();
+
+		let block_status = self
+			.client
+			.status(hash)
+			.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+
+		// Skip babe logic if block already in chain or importing blocks during initial sync,
+		// otherwise the check for epoch changes will error because trying to re-import an
+		// epoch change or because of missing epoch data in the tree, respectivelly.
+		if info.block_gap.map_or(false, |(s, e)| s <= number && number <= e) ||
+			block_status == BlockStatus::InChain
+		{
+			// When re-importing existing block strip away intermediates.
+			// In case of initial sync intermediates should not be present...
+			let _ = block.remove_intermediate::<BabeIntermediate<Block>>(INTERMEDIATE_KEY);
+			block.fork_choice = Some(ForkChoiceStrategy::Custom(false));
+			return self.inner.import_block(block).await.map_err(Into::into)
+		}
+
+		if block.with_state() {
+			return self.import_state(block).await
+		}
+
+		let pre_digest = find_pre_digest::<Block>(&block.header).expect(
+			"valid babe headers must contain a predigest; header has been already verified; qed",
+		);
+		let slot = pre_digest.slot();
+
+		let parent_hash = *block.header.parent_hash();
+		let parent_header = self
+			.client
+			.header(parent_hash)
+			.map_err(|e| ConsensusError::ChainLookup(e.to_string()))?
+			.ok_or_else(|| {
+				ConsensusError::ChainLookup(
+					babe_err(Error::<Block>::ParentUnavailable(parent_hash, hash)).into(),
+				)
+			})?;
+
+		let parent_slot = find_pre_digest::<Block>(&parent_header).map(|d| d.slot()).expect(
+			"parent is non-genesis; valid BABE headers contain a pre-digest; header has already \
+			 been verified; qed",
+		);
+
+		// make sure that slot number is strictly increasing
+		if slot <= parent_slot {
+			return Err(ConsensusError::ClientImport(
+				babe_err(Error::<Block>::SlotMustIncrease(parent_slot, slot)).into(),
+			))
+		}
+
+		// if there's a pending epoch we'll save the previous epoch changes here
+		// this way we can revert it if there's any error
+		let mut old_epoch_changes = None;
+
+		// Use an extra scope to make the compiler happy, because otherwise it complains about the
+		// mutex, even if we dropped it...
+		let mut epoch_changes = {
+			let mut epoch_changes = self.epoch_changes.shared_data_locked();
+
+			// check if there's any epoch change expected to happen at this slot.
+			// `epoch` is the epoch to verify the block under, and `first_in_epoch` is true
+			// if this is the first block in its chain for that epoch.
+			//
+			// also provides the total weight of the chain, including the imported block.
+			let (epoch_descriptor, first_in_epoch, parent_weight) = {
+				let parent_weight = if *parent_header.number() == Zero::zero() {
+					0
+				} else {
+					aux_schema::load_block_weight(&*self.client, parent_hash)
+						.map_err(|e| ConsensusError::ClientImport(e.to_string()))?
+						.ok_or_else(|| {
+							ConsensusError::ClientImport(
+								babe_err(Error::<Block>::ParentBlockNoAssociatedWeight(hash))
+									.into(),
+							)
+						})?
+				};
+
+				let intermediate =
+					block.remove_intermediate::<BabeIntermediate<Block>>(INTERMEDIATE_KEY)?;
+
+				let epoch_descriptor = intermediate.epoch_descriptor;
+				let first_in_epoch = parent_slot < epoch_descriptor.start_slot();
+				(epoch_descriptor, first_in_epoch, parent_weight)
+			};
+
+			let total_weight = parent_weight + pre_digest.added_weight();
+
+			// search for this all the time so we can reject unexpected announcements.
+			let next_epoch_digest = find_next_epoch_digest::<Block>(&block.header)
+				.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+			let next_config_digest = find_next_config_digest::<Block>(&block.header)
+				.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+
+			match (first_in_epoch, next_epoch_digest.is_some(), next_config_digest.is_some()) {
+				(true, true, _) => {},
+				(false, false, false) => {},
+				(false, false, true) =>
+					return Err(ConsensusError::ClientImport(
+						babe_err(Error::<Block>::UnexpectedConfigChange).into(),
+					)),
+				(true, false, _) =>
+					return Err(ConsensusError::ClientImport(
+						babe_err(Error::<Block>::ExpectedEpochChange(hash, slot)).into(),
+					)),
+				(false, true, _) =>
+					return Err(ConsensusError::ClientImport(
+						babe_err(Error::<Block>::UnexpectedEpochChange).into(),
+					)),
+			}
+
+			if let Some(next_epoch_descriptor) = next_epoch_digest {
+				old_epoch_changes = Some((*epoch_changes).clone());
+
+				let mut viable_epoch = epoch_changes
+					.viable_epoch(&epoch_descriptor, |slot| Epoch::genesis(&self.config, slot))
+					.ok_or_else(|| {
+						ConsensusError::ClientImport(Error::<Block>::FetchEpoch(parent_hash).into())
+					})?
+					.into_cloned();
+
+				let epoch_config = next_config_digest
+					.map(Into::into)
+					.unwrap_or_else(|| viable_epoch.as_ref().config.clone());
+
+				// restrict info logging during initial sync to avoid spam
+				let log_level = if block.origin == BlockOrigin::NetworkInitialSync {
+					log::Level::Debug
+				} else {
+					log::Level::Info
+				};
+
+				if viable_epoch.as_ref().end_slot() <= slot {
+					// Some epochs must have been skipped as our current slot fits outside the
+					// current epoch. We will figure out which epoch it belongs to and we will
+					// re-use the same data for that epoch.
+					// Notice that we are only updating a local copy of the `Epoch`, this
+					// makes it so that when we insert the next epoch into `EpochChanges` below
+					// (after incrementing it), it will use the correct epoch index and start slot.
+					// We do not update the original epoch that will be re-used because there might
+					// be other forks (that we haven't imported) where the epoch isn't skipped, and
+					// to import those forks we want to keep the original epoch data. Not updating
+					// the original epoch works because when we search the tree for which epoch to
+					// use for a given slot, we will search in-depth with the predicate
+					// `epoch.start_slot <= slot` which will still match correctly without updating
+					// `start_slot` to the correct value as below.
+					let epoch = viable_epoch.as_mut();
+					let prev_index = epoch.epoch_index;
+					*epoch = epoch.clone_for_slot(slot);
+
+					warn!(
+						target: LOG_TARGET,
+						"👶 Epoch(s) skipped: from {} to {}", prev_index, epoch.epoch_index,
+					);
+				}
+
+				log!(
+					target: LOG_TARGET,
+					log_level,
+					"👶 New epoch {} launching at block {} (block slot {} >= start slot {}).",
+					viable_epoch.as_ref().epoch_index,
+					hash,
+					slot,
+					viable_epoch.as_ref().start_slot,
+				);
+
+				let next_epoch = viable_epoch.increment((next_epoch_descriptor, epoch_config));
+
+				log!(
+					target: LOG_TARGET,
+					log_level,
+					"👶 Next epoch starts at slot {}",
+					next_epoch.as_ref().start_slot,
+				);
+
+				// prune the tree of epochs not part of the finalized chain or
+				// that are not live anymore, and then track the given epoch change
+				// in the tree.
+				// NOTE: it is important that these operations are done in this
+				// order, otherwise if pruning after import the `is_descendent_of`
+				// used by pruning may not know about the block that is being
+				// imported.
+				let prune_and_import = || {
+					prune_finalized(self.client.clone(), &mut epoch_changes)?;
+
+					epoch_changes
+						.import(
+							descendent_query(&*self.client),
+							hash,
+							number,
+							*block.header.parent_hash(),
+							next_epoch,
+						)
+						.map_err(|e| {
+							ConsensusError::ClientImport(format!(
+								"Error importing epoch changes: {}",
+								e
+							))
+						})?;
+					Ok(())
+				};
+
+				if let Err(e) = prune_and_import() {
+					debug!(target: LOG_TARGET, "Failed to launch next epoch: {}", e);
+					*epoch_changes =
+						old_epoch_changes.expect("set `Some` above and not taken; qed");
+					return Err(e)
+				}
+
+				crate::aux_schema::write_epoch_changes::<Block, _, _>(&*epoch_changes, |insert| {
+					block
+						.auxiliary
+						.extend(insert.iter().map(|(k, v)| (k.to_vec(), Some(v.to_vec()))))
+				});
+			}
+
+			aux_schema::write_block_weight(hash, total_weight, |values| {
+				block
+					.auxiliary
+					.extend(values.iter().map(|(k, v)| (k.to_vec(), Some(v.to_vec()))))
+			});
+
+			// The fork choice rule is that we pick the heaviest chain (i.e.
+			// more primary blocks), if there's a tie we go with the longest
+			// chain.
+			block.fork_choice = {
+				let (last_best, last_best_number) = (info.best_hash, info.best_number);
+
+				let last_best_weight = if &last_best == block.header.parent_hash() {
+					// the parent=genesis case is already covered for loading parent weight,
+					// so we don't need to cover again here.
+					parent_weight
+				} else {
+					aux_schema::load_block_weight(&*self.client, last_best)
+						.map_err(|e| ConsensusError::ChainLookup(e.to_string()))?
+						.ok_or_else(|| {
+							ConsensusError::ChainLookup(
+								"No block weight for parent header.".to_string(),
+							)
+						})?
+				};
+
+				Some(ForkChoiceStrategy::Custom(if total_weight > last_best_weight {
+					true
+				} else if total_weight == last_best_weight {
+					number > last_best_number
+				} else {
+					false
+				}))
+			};
+
+			// Release the mutex, but it stays locked
+			epoch_changes.release_mutex()
+		};
+
+		let import_result = self.inner.import_block(block).await;
+
+		// revert to the original epoch changes in case there's an error
+		// importing the block
+		if import_result.is_err() {
+			if let Some(old_epoch_changes) = old_epoch_changes {
+				*epoch_changes.upgrade() = old_epoch_changes;
+			}
+		}
+
+		import_result.map_err(Into::into)
+	}
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.inner.check_block(block).await.map_err(Into::into)
+	}
+}
+
+/// Gets the best finalized block and its slot, and prunes the given epoch tree.
+fn prune_finalized<Block, Client>(
+	client: Arc<Client>,
+	epoch_changes: &mut EpochChangesFor<Block, Epoch>,
+) -> Result<(), ConsensusError>
+where
+	Block: BlockT,
+	Client: HeaderBackend<Block> + HeaderMetadata<Block, Error = sp_blockchain::Error>,
+{
+	let info = client.info();
+
+	let finalized_slot = {
+		let finalized_header = client
+			.header(info.finalized_hash)
+			.map_err(|e| ConsensusError::ClientImport(e.to_string()))?
+			.expect(
+				"best finalized hash was given by client; finalized headers must exist in db; qed",
+			);
+
+		find_pre_digest::<Block>(&finalized_header)
+			.expect("finalized header must be valid; valid blocks have a pre-digest; qed")
+			.slot()
+	};
+
+	epoch_changes
+		.prune_finalized(
+			descendent_query(&*client),
+			&info.finalized_hash,
+			info.finalized_number,
+			finalized_slot,
+		)
+		.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+
+	Ok(())
+}
+
+/// Produce a BABE block-import object to be used later on in the construction of
+/// an import-queue.
+///
+/// Also returns a link object used to correctly instantiate the import queue
+/// and background worker.
+pub fn block_import<Client, Block: BlockT, I>(
+	config: BabeConfiguration,
+	wrapped_block_import: I,
+	client: Arc<Client>,
+) -> ClientResult<(BabeBlockImport<Block, Client, I>, BabeLink<Block>)>
+where
+	Client: AuxStore
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ PreCommitActions<Block>
+		+ 'static,
+{
+	let epoch_changes = aux_schema::load_epoch_changes::<Block, _>(&*client, &config)?;
+	let link = BabeLink { epoch_changes: epoch_changes.clone(), config: config.clone() };
+
+	// NOTE: this isn't entirely necessary, but since we didn't use to prune the
+	// epoch tree it is useful as a migration, so that nodes prune long trees on
+	// startup rather than waiting until importing the next epoch change block.
+	prune_finalized(client.clone(), &mut epoch_changes.shared_data())?;
+
+	let client_weak = Arc::downgrade(&client);
+	let on_finality = move |summary: &FinalityNotification<Block>| {
+		if let Some(client) = client_weak.upgrade() {
+			aux_storage_cleanup(client.as_ref(), summary)
+		} else {
+			Default::default()
+		}
+	};
+	client.register_finality_action(Box::new(on_finality));
+
+	let import = BabeBlockImport::new(client, epoch_changes, wrapped_block_import, config);
+
+	Ok((import, link))
+}
+
+/// Parameters passed to [`import_queue`].
+pub struct ImportQueueParams<'a, Block: BlockT, BI, Client, CIDP, SelectChain, Spawn> {
+	/// The BABE link that is created by [`block_import`].
+	pub link: BabeLink<Block>,
+	/// The block import that should be wrapped.
+	pub block_import: BI,
+	/// Optional justification import.
+	pub justification_import: Option<BoxJustificationImport<Block>>,
+	/// The client to interact with the internals of the node.
+	pub client: Arc<Client>,
+	/// A [`SelectChain`] implementation.
+	///
+	/// Used to determine the best block that should be used as basis when sending an equivocation
+	/// report.
+	pub select_chain: SelectChain,
+	/// Used to crate the inherent data providers.
+	///
+	/// These inherent data providers are then used to create the inherent data that is
+	/// passed to the `check_inherents` runtime call.
+	pub create_inherent_data_providers: CIDP,
+	/// Spawner for spawning futures.
+	pub spawner: &'a Spawn,
+	/// Registry for prometheus metrics.
+	pub registry: Option<&'a Registry>,
+	/// Optional telemetry handle to report telemetry events.
+	pub telemetry: Option<TelemetryHandle>,
+	/// The offchain transaction pool factory.
+	///
+	/// Will be used when sending equivocation reports.
+	pub offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>,
+}
+
+/// Start an import queue for the BABE consensus algorithm.
+///
+/// This method returns the import queue, some data that needs to be passed to the block authoring
+/// logic (`BabeLink`), and a future that must be run to
+/// completion and is responsible for listening to finality notifications and
+/// pruning the epoch changes tree.
+///
+/// The block import object provided must be the `BabeBlockImport` or a wrapper
+/// of it, otherwise crucial import logic will be omitted.
+pub fn import_queue<Block: BlockT, Client, SelectChain, BI, CIDP, Spawn>(
+	ImportQueueParams {
+		link: babe_link,
+		block_import,
+		justification_import,
+		client,
+		select_chain,
+		create_inherent_data_providers,
+		spawner,
+		registry,
+		telemetry,
+		offchain_tx_pool_factory,
+	}: ImportQueueParams<'_, Block, BI, Client, CIDP, SelectChain, Spawn>,
+) -> ClientResult<(DefaultImportQueue<Block>, BabeWorkerHandle<Block>)>
+where
+	BI: BlockImport<Block, Error = ConsensusError> + Send + Sync + 'static,
+	Client: ProvideRuntimeApi<Block>
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ AuxStore
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: BlockBuilderApi<Block> + BabeApi<Block> + ApiExt<Block>,
+	SelectChain: sp_consensus::SelectChain<Block> + 'static,
+	CIDP: CreateInherentDataProviders<Block, ()> + Send + Sync + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync,
+	Spawn: SpawnEssentialNamed,
+{
+	const HANDLE_BUFFER_SIZE: usize = 1024;
+
+	let verifier = BabeVerifier {
+		select_chain,
+		create_inherent_data_providers,
+		config: babe_link.config.clone(),
+		epoch_changes: babe_link.epoch_changes.clone(),
+		telemetry,
+		client: client.clone(),
+		offchain_tx_pool_factory,
+	};
+
+	let (worker_tx, worker_rx) = channel(HANDLE_BUFFER_SIZE);
+
+	let answer_requests =
+		answer_requests(worker_rx, babe_link.config, client, babe_link.epoch_changes);
+
+	spawner.spawn_essential("babe-worker", Some("babe"), answer_requests.boxed());
+
+	Ok((
+		BasicQueue::new(verifier, Box::new(block_import), justification_import, spawner, registry),
+		BabeWorkerHandle(worker_tx),
+	))
+}
+
+/// Reverts protocol aux data to at most the last finalized block.
+/// In particular, epoch-changes and block weights announced after the revert
+/// point are removed.
+pub fn revert<Block, Client, Backend>(
+	client: Arc<Client>,
+	backend: Arc<Backend>,
+	blocks: NumberFor<Block>,
+) -> ClientResult<()>
+where
+	Block: BlockT,
+	Client: AuxStore
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ UsageProvider<Block>,
+	Client::Api: BabeApi<Block>,
+	Backend: BackendT<Block>,
+{
+	let best_number = client.info().best_number;
+	let finalized = client.info().finalized_number;
+
+	let revertible = blocks.min(best_number - finalized);
+	if revertible == Zero::zero() {
+		return Ok(())
+	}
+
+	let revert_up_to_number = best_number - revertible;
+	let revert_up_to_hash = client.hash(revert_up_to_number)?.ok_or(ClientError::Backend(
+		format!("Unexpected hash lookup failure for block number: {}", revert_up_to_number),
+	))?;
+
+	// Revert epoch changes tree.
+
+	// This config is only used on-genesis.
+	let config = configuration(&*client)?;
+	let epoch_changes = aux_schema::load_epoch_changes::<Block, Client>(&*client, &config)?;
+	let mut epoch_changes = epoch_changes.shared_data();
+
+	if revert_up_to_number == Zero::zero() {
+		// Special case, no epoch changes data were present on genesis.
+		*epoch_changes = EpochChangesFor::<Block, Epoch>::default();
+	} else {
+		epoch_changes.revert(descendent_query(&*client), revert_up_to_hash, revert_up_to_number);
+	}
+
+	// Remove block weights added after the revert point.
+
+	let mut weight_keys = HashSet::with_capacity(revertible.saturated_into());
+
+	let leaves = backend.blockchain().leaves()?.into_iter().filter(|&leaf| {
+		sp_blockchain::tree_route(&*client, revert_up_to_hash, leaf)
+			.map(|route| route.retracted().is_empty())
+			.unwrap_or_default()
+	});
+
+	for leaf in leaves {
+		let mut hash = leaf;
+		loop {
+			let meta = client.header_metadata(hash)?;
+			if meta.number <= revert_up_to_number ||
+				!weight_keys.insert(aux_schema::block_weight_key(hash))
+			{
+				// We've reached the revert point or an already processed branch, stop here.
+				break
+			}
+			hash = meta.parent;
+		}
+	}
+
+	let weight_keys: Vec<_> = weight_keys.iter().map(|val| val.as_slice()).collect();
+
+	// Write epoch changes and remove weights in one shot.
+	aux_schema::write_epoch_changes::<Block, _, _>(&epoch_changes, |values| {
+		client.insert_aux(values, weight_keys.iter())
+	})
+}
diff --git a/substrate/client/consensus/babe/src/migration.rs b/substrate/client/consensus/babe/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2b1396c41c268476c2dadc69c8051a04112b5d16
--- /dev/null
+++ b/substrate/client/consensus/babe/src/migration.rs
@@ -0,0 +1,77 @@
+// 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::{
+	AuthorityId, BabeAuthorityWeight, BabeConfiguration, BabeEpochConfiguration, Epoch,
+	NextEpochDescriptor, Randomness,
+};
+use codec::{Decode, Encode};
+use sc_consensus_epochs::Epoch as EpochT;
+use sp_consensus_slots::Slot;
+
+/// BABE epoch information, version 0.
+#[derive(Decode, Encode, PartialEq, Eq, Clone, Debug)]
+pub struct EpochV0 {
+	/// The epoch index.
+	pub epoch_index: u64,
+	/// The starting slot of the epoch.
+	pub start_slot: Slot,
+	/// The duration of this epoch.
+	pub duration: u64,
+	/// The authorities and their weights.
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+	/// Randomness for this epoch.
+	pub randomness: Randomness,
+}
+
+impl EpochT for EpochV0 {
+	type NextEpochDescriptor = NextEpochDescriptor;
+	type Slot = Slot;
+
+	fn increment(&self, descriptor: NextEpochDescriptor) -> EpochV0 {
+		EpochV0 {
+			epoch_index: self.epoch_index + 1,
+			start_slot: self.start_slot + self.duration,
+			duration: self.duration,
+			authorities: descriptor.authorities,
+			randomness: descriptor.randomness,
+		}
+	}
+
+	fn start_slot(&self) -> Slot {
+		self.start_slot
+	}
+
+	fn end_slot(&self) -> Slot {
+		self.start_slot + self.duration
+	}
+}
+
+impl EpochV0 {
+	/// Migrate the sturct to current epoch version.
+	pub fn migrate(self, config: &BabeConfiguration) -> Epoch {
+		Epoch {
+			epoch_index: self.epoch_index,
+			start_slot: self.start_slot,
+			duration: self.duration,
+			authorities: self.authorities,
+			randomness: self.randomness,
+			config: BabeEpochConfiguration { c: config.c, allowed_slots: config.allowed_slots },
+		}
+	}
+}
diff --git a/substrate/client/consensus/babe/src/tests.rs b/substrate/client/consensus/babe/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b3843f8acfa0a481ed456f13bdce5a7fb54173b4
--- /dev/null
+++ b/substrate/client/consensus/babe/src/tests.rs
@@ -0,0 +1,1350 @@
+// 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/>.
+
+//! BABE testsuite
+
+use super::*;
+use authorship::claim_slot;
+use sc_block_builder::{BlockBuilder, BlockBuilderProvider};
+use sc_client_api::{BlockchainEvents, Finalizer};
+use sc_consensus::{BoxBlockImport, BoxJustificationImport};
+use sc_consensus_epochs::{EpochIdentifier, EpochIdentifierPosition};
+use sc_consensus_slots::BackoffAuthoringOnFinalizedHeadLagging;
+use sc_network_test::{Block as TestBlock, *};
+use sc_transaction_pool_api::RejectAllTxPool;
+use sp_application_crypto::key_types::BABE;
+use sp_consensus::{DisableProofRecording, NoNetwork as DummyOracle, Proposal};
+use sp_consensus_babe::{
+	inherents::InherentDataProvider, make_vrf_sign_data, AllowedSlots, AuthorityId, AuthorityPair,
+	Slot,
+};
+use sp_consensus_slots::SlotDuration;
+use sp_core::crypto::Pair;
+use sp_keyring::Sr25519Keyring;
+use sp_keystore::{testing::MemoryKeystore, Keystore};
+use sp_runtime::{
+	generic::{Digest, DigestItem},
+	traits::Block as BlockT,
+};
+use sp_timestamp::Timestamp;
+use std::{cell::RefCell, task::Poll, time::Duration};
+
+type Item = DigestItem;
+
+type Error = sp_blockchain::Error;
+
+type TestClient = substrate_test_runtime_client::client::Client<
+	substrate_test_runtime_client::Backend,
+	substrate_test_runtime_client::ExecutorDispatch,
+	TestBlock,
+	substrate_test_runtime_client::runtime::RuntimeApi,
+>;
+
+#[derive(Copy, Clone, PartialEq)]
+enum Stage {
+	PreSeal,
+	PostSeal,
+}
+
+type Mutator = Arc<dyn Fn(&mut TestHeader, Stage) + Send + Sync>;
+
+type BabeBlockImport =
+	PanickingBlockImport<crate::BabeBlockImport<TestBlock, TestClient, Arc<TestClient>>>;
+
+const SLOT_DURATION_MS: u64 = 1000;
+
+#[derive(Clone)]
+struct DummyFactory {
+	client: Arc<TestClient>,
+	epoch_changes: SharedEpochChanges<TestBlock, Epoch>,
+	mutator: Mutator,
+}
+
+struct DummyProposer {
+	factory: DummyFactory,
+	parent_hash: Hash,
+}
+
+impl Environment<TestBlock> for DummyFactory {
+	type CreateProposer = future::Ready<Result<DummyProposer, Error>>;
+	type Proposer = DummyProposer;
+	type Error = Error;
+
+	fn init(&mut self, parent_header: &<TestBlock as BlockT>::Header) -> Self::CreateProposer {
+		future::ready(Ok(DummyProposer {
+			factory: self.clone(),
+			parent_hash: parent_header.hash(),
+		}))
+	}
+}
+
+impl DummyProposer {
+	fn propose_with(
+		&mut self,
+		pre_digests: Digest,
+	) -> future::Ready<Result<Proposal<TestBlock, ()>, Error>> {
+		let block_builder =
+			self.factory.client.new_block_at(self.parent_hash, pre_digests, false).unwrap();
+
+		let mut block = match block_builder.build().map_err(|e| e.into()) {
+			Ok(b) => b.block,
+			Err(e) => return future::ready(Err(e)),
+		};
+
+		// mutate the block header according to the mutator.
+		(self.factory.mutator)(&mut block.header, Stage::PreSeal);
+
+		future::ready(Ok(Proposal { block, proof: (), storage_changes: Default::default() }))
+	}
+}
+
+impl Proposer<TestBlock> for DummyProposer {
+	type Error = Error;
+	type Proposal = future::Ready<Result<Proposal<TestBlock, ()>, Error>>;
+	type ProofRecording = DisableProofRecording;
+	type Proof = ();
+
+	fn propose(
+		mut self,
+		_: InherentData,
+		pre_digests: Digest,
+		_: Duration,
+		_: Option<usize>,
+	) -> Self::Proposal {
+		self.propose_with(pre_digests)
+	}
+}
+
+thread_local! {
+	static MUTATOR: RefCell<Mutator> = RefCell::new(Arc::new(|_, _|()));
+}
+
+#[derive(Clone)]
+pub struct PanickingBlockImport<B>(B);
+
+#[async_trait::async_trait]
+impl<B: BlockImport<TestBlock>> BlockImport<TestBlock> for PanickingBlockImport<B>
+where
+	B: Send,
+{
+	type Error = B::Error;
+
+	async fn import_block(
+		&mut self,
+		block: BlockImportParams<TestBlock>,
+	) -> Result<ImportResult, Self::Error> {
+		Ok(self.0.import_block(block).await.expect("importing block failed"))
+	}
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<TestBlock>,
+	) -> Result<ImportResult, Self::Error> {
+		Ok(self.0.check_block(block).await.expect("checking block failed"))
+	}
+}
+
+type BabePeer = Peer<Option<PeerData>, BabeBlockImport>;
+
+#[derive(Default)]
+pub struct BabeTestNet {
+	peers: Vec<BabePeer>,
+}
+
+type TestHeader = <TestBlock as BlockT>::Header;
+
+type TestSelectChain =
+	substrate_test_runtime_client::LongestChain<substrate_test_runtime_client::Backend, TestBlock>;
+
+pub struct TestVerifier {
+	inner: BabeVerifier<
+		TestBlock,
+		PeersFullClient,
+		TestSelectChain,
+		Box<
+			dyn CreateInherentDataProviders<
+				TestBlock,
+				(),
+				InherentDataProviders = (InherentDataProvider,),
+			>,
+		>,
+	>,
+	mutator: Mutator,
+}
+
+#[async_trait::async_trait]
+impl Verifier<TestBlock> for TestVerifier {
+	/// Verify the given data and return the BlockImportParams and an optional
+	/// new set of validators to import. If not, err with an Error-Message
+	/// presented to the User in the logs.
+	async fn verify(
+		&mut self,
+		mut block: BlockImportParams<TestBlock>,
+	) -> Result<BlockImportParams<TestBlock>, String> {
+		// apply post-sealing mutations (i.e. stripping seal, if desired).
+		(self.mutator)(&mut block.header, Stage::PostSeal);
+		self.inner.verify(block).await
+	}
+}
+
+pub struct PeerData {
+	link: BabeLink<TestBlock>,
+	block_import: Mutex<Option<BoxBlockImport<TestBlock>>>,
+}
+
+impl TestNetFactory for BabeTestNet {
+	type Verifier = TestVerifier;
+	type PeerData = Option<PeerData>;
+	type BlockImport = BabeBlockImport;
+
+	fn make_block_import(
+		&self,
+		client: PeersClient,
+	) -> (
+		BlockImportAdapter<Self::BlockImport>,
+		Option<BoxJustificationImport<Block>>,
+		Option<PeerData>,
+	) {
+		let client = client.as_client();
+
+		let config = crate::configuration(&*client).expect("config available");
+		let (block_import, link) = crate::block_import(config, client.clone(), client.clone())
+			.expect("can initialize block-import");
+
+		let block_import = PanickingBlockImport(block_import);
+
+		let data_block_import =
+			Mutex::new(Some(Box::new(block_import.clone()) as BoxBlockImport<_>));
+		(
+			BlockImportAdapter::new(block_import),
+			None,
+			Some(PeerData { link, block_import: data_block_import }),
+		)
+	}
+
+	fn make_verifier(&self, client: PeersClient, maybe_link: &Option<PeerData>) -> Self::Verifier {
+		use substrate_test_runtime_client::DefaultTestClientBuilderExt;
+
+		let client = client.as_client();
+		trace!(target: LOG_TARGET, "Creating a verifier");
+
+		// ensure block import and verifier are linked correctly.
+		let data = maybe_link
+			.as_ref()
+			.expect("babe link always provided to verifier instantiation");
+
+		let (_, longest_chain) = TestClientBuilder::new().build_with_longest_chain();
+
+		TestVerifier {
+			inner: BabeVerifier {
+				client: client.clone(),
+				select_chain: longest_chain,
+				create_inherent_data_providers: Box::new(|_, _| async {
+					let slot = InherentDataProvider::from_timestamp_and_slot_duration(
+						Timestamp::current(),
+						SlotDuration::from_millis(SLOT_DURATION_MS),
+					);
+					Ok((slot,))
+				}),
+				config: data.link.config.clone(),
+				epoch_changes: data.link.epoch_changes.clone(),
+				telemetry: None,
+				offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+					RejectAllTxPool::default(),
+				),
+			},
+			mutator: MUTATOR.with(|m| m.borrow().clone()),
+		}
+	}
+
+	fn peer(&mut self, i: usize) -> &mut BabePeer {
+		trace!(target: LOG_TARGET, "Retrieving a peer");
+		&mut self.peers[i]
+	}
+
+	fn peers(&self) -> &Vec<BabePeer> {
+		trace!(target: LOG_TARGET, "Retrieving peers");
+		&self.peers
+	}
+
+	fn peers_mut(&mut self) -> &mut Vec<BabePeer> {
+		trace!(target: "babe", "Retrieving peers, mutable");
+		&mut self.peers
+	}
+
+	fn mut_peers<F: FnOnce(&mut Vec<BabePeer>)>(&mut self, closure: F) {
+		closure(&mut self.peers);
+	}
+}
+
+#[tokio::test]
+#[should_panic(expected = "No BABE pre-runtime digest found")]
+async fn rejects_empty_block() {
+	sp_tracing::try_init_simple();
+	let mut net = BabeTestNet::new(3);
+	let block_builder = |builder: BlockBuilder<_, _, _>| builder.build().unwrap().block;
+	net.mut_peers(|peer| {
+		peer[0].generate_blocks(1, BlockOrigin::NetworkInitialSync, block_builder);
+	})
+}
+
+fn create_keystore(authority: Sr25519Keyring) -> KeystorePtr {
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(BABE, Some(&authority.to_seed()))
+		.expect("Generates authority key");
+	keystore.into()
+}
+
+async fn run_one_test(mutator: impl Fn(&mut TestHeader, Stage) + Send + Sync + 'static) {
+	sp_tracing::try_init_simple();
+	let mutator = Arc::new(mutator) as Mutator;
+
+	MUTATOR.with(|m| *m.borrow_mut() = mutator.clone());
+
+	let net = BabeTestNet::new(3);
+
+	let peers = [Sr25519Keyring::Alice, Sr25519Keyring::Bob, Sr25519Keyring::Charlie];
+
+	let net = Arc::new(Mutex::new(net));
+	let mut import_notifications = Vec::new();
+	let mut babe_futures = Vec::new();
+
+	for (peer_id, auth_id) in peers.iter().enumerate() {
+		let mut net = net.lock();
+		let peer = net.peer(peer_id);
+		let client = peer.client().as_client();
+		let select_chain = peer.select_chain().expect("Full client has select_chain");
+
+		let keystore = create_keystore(*auth_id);
+
+		let mut got_own = false;
+		let mut got_other = false;
+
+		let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+		let environ = DummyFactory {
+			client: client.clone(),
+			epoch_changes: data.link.epoch_changes.clone(),
+			mutator: mutator.clone(),
+		};
+
+		import_notifications.push(
+			// run each future until we get one of our own blocks with number higher than 5
+			// that was produced locally.
+			client
+				.import_notification_stream()
+				.take_while(move |n| {
+					future::ready(
+						n.header.number() < &5 || {
+							if n.origin == BlockOrigin::Own {
+								got_own = true;
+							} else {
+								got_other = true;
+							}
+
+							// continue until we have at least one block of our own
+							// and one of another peer.
+							!(got_own && got_other)
+						},
+					)
+				})
+				.for_each(|_| future::ready(())),
+		);
+
+		let client_clone = client.clone();
+		babe_futures.push(
+			start_babe(BabeParams {
+				block_import: data.block_import.lock().take().expect("import set up during init"),
+				select_chain,
+				client,
+				env: environ,
+				sync_oracle: DummyOracle,
+				create_inherent_data_providers: Box::new(move |parent, _| {
+					// Get the slot of the parent header and just increase this slot.
+					//
+					// Below we will running everything in one big future. If we would use
+					// time based slot, it can happen that on babe instance imports a block from
+					// another babe instance and then tries to build a block in the same slot making
+					// this test fail.
+					let parent_header = client_clone.header(parent).ok().flatten().unwrap();
+					let slot = Slot::from(
+						find_pre_digest::<TestBlock>(&parent_header).unwrap().slot() + 1,
+					);
+
+					async move { Ok((InherentDataProvider::new(slot),)) }
+				}),
+				force_authoring: false,
+				backoff_authoring_blocks: Some(BackoffAuthoringOnFinalizedHeadLagging::default()),
+				babe_link: data.link.clone(),
+				keystore,
+				justification_sync_link: (),
+				block_proposal_slot_portion: SlotProportion::new(0.5),
+				max_block_proposal_slot_portion: None,
+				telemetry: None,
+			})
+			.expect("Starts babe"),
+		);
+	}
+	future::select(
+		futures::future::poll_fn(move |cx| {
+			let mut net = net.lock();
+			net.poll(cx);
+			for p in net.peers() {
+				for (h, e) in p.failed_verifications() {
+					panic!("Verification failed for {:?}: {}", h, e);
+				}
+			}
+
+			Poll::<()>::Pending
+		}),
+		future::select(future::join_all(import_notifications), future::join_all(babe_futures)),
+	)
+	.await;
+}
+
+#[tokio::test]
+async fn authoring_blocks() {
+	run_one_test(|_, _| ()).await;
+}
+
+#[tokio::test]
+#[should_panic(expected = "valid babe headers must contain a predigest")]
+async fn rejects_missing_inherent_digest() {
+	run_one_test(|header: &mut TestHeader, stage| {
+		let v = std::mem::take(&mut header.digest_mut().logs);
+		header.digest_mut().logs = v
+			.into_iter()
+			.filter(|v| stage == Stage::PostSeal || v.as_babe_pre_digest().is_none())
+			.collect()
+	})
+	.await;
+}
+
+#[tokio::test]
+#[should_panic(expected = "has a bad seal")]
+async fn rejects_missing_seals() {
+	run_one_test(|header: &mut TestHeader, stage| {
+		let v = std::mem::take(&mut header.digest_mut().logs);
+		header.digest_mut().logs = v
+			.into_iter()
+			.filter(|v| stage == Stage::PreSeal || v.as_babe_seal().is_none())
+			.collect()
+	})
+	.await;
+}
+
+#[tokio::test]
+#[should_panic(expected = "Expected epoch change to happen")]
+async fn rejects_missing_consensus_digests() {
+	run_one_test(|header: &mut TestHeader, stage| {
+		let v = std::mem::take(&mut header.digest_mut().logs);
+		header.digest_mut().logs = v
+			.into_iter()
+			.filter(|v| stage == Stage::PostSeal || v.as_next_epoch_descriptor().is_none())
+			.collect()
+	})
+	.await;
+}
+
+#[test]
+fn wrong_consensus_engine_id_rejected() {
+	sp_tracing::try_init_simple();
+	let sig = AuthorityPair::generate().0.sign(b"");
+	let bad_seal: Item = DigestItem::Seal([0; 4], sig.to_vec());
+	assert!(bad_seal.as_babe_pre_digest().is_none());
+	assert!(bad_seal.as_babe_seal().is_none())
+}
+
+#[test]
+fn malformed_pre_digest_rejected() {
+	sp_tracing::try_init_simple();
+	let bad_seal: Item = DigestItem::Seal(BABE_ENGINE_ID, [0; 64].to_vec());
+	assert!(bad_seal.as_babe_pre_digest().is_none());
+}
+
+#[test]
+fn sig_is_not_pre_digest() {
+	sp_tracing::try_init_simple();
+	let sig = AuthorityPair::generate().0.sign(b"");
+	let bad_seal: Item = DigestItem::Seal(BABE_ENGINE_ID, sig.to_vec());
+	assert!(bad_seal.as_babe_pre_digest().is_none());
+	assert!(bad_seal.as_babe_seal().is_some())
+}
+
+#[test]
+fn claim_epoch_slots() {
+	// We don't require the full claim information, thus as a shorter alias we're
+	// going to use a simple integer value. Generally not verbose enough, but good enough
+	// to be used within the narrow scope of a single test.
+	// 0 -> None (i.e. unable to claim the slot),
+	// 1 -> Primary
+	// 2 -> Secondary
+	// 3 -> Secondary with VRF
+	const EPOCH_DURATION: u64 = 10;
+
+	let authority = Sr25519Keyring::Alice;
+	let keystore = create_keystore(authority);
+
+	let mut epoch = Epoch {
+		start_slot: 0.into(),
+		authorities: vec![(authority.public().into(), 1)],
+		randomness: [0; 32],
+		epoch_index: 1,
+		duration: EPOCH_DURATION,
+		config: BabeEpochConfiguration {
+			c: (3, 10),
+			allowed_slots: AllowedSlots::PrimaryAndSecondaryPlainSlots,
+		},
+	};
+
+	let claim_slot_wrap = |s, e| match claim_slot(Slot::from(s as u64), &e, &keystore) {
+		None => 0,
+		Some((PreDigest::Primary(_), _)) => 1,
+		Some((PreDigest::SecondaryPlain(_), _)) => 2,
+		Some((PreDigest::SecondaryVRF(_), _)) => 3,
+	};
+
+	// With secondary mechanism we should be able to claim all slots.
+	let claims: Vec<_> = (0..EPOCH_DURATION)
+		.into_iter()
+		.map(|slot| claim_slot_wrap(slot, epoch.clone()))
+		.collect();
+	assert_eq!(claims, [1, 2, 2, 1, 2, 2, 2, 2, 2, 1]);
+
+	// With secondary with VRF mechanism we should be able to claim all the slots.
+	epoch.config.allowed_slots = AllowedSlots::PrimaryAndSecondaryVRFSlots;
+	let claims: Vec<_> = (0..EPOCH_DURATION)
+		.into_iter()
+		.map(|slot| claim_slot_wrap(slot, epoch.clone()))
+		.collect();
+	assert_eq!(claims, [1, 3, 3, 1, 3, 3, 3, 3, 3, 1]);
+
+	// Otherwise with only vrf-based primary slots we are able to claim a subset of the slots.
+	epoch.config.allowed_slots = AllowedSlots::PrimarySlots;
+	let claims: Vec<_> = (0..EPOCH_DURATION)
+		.into_iter()
+		.map(|slot| claim_slot_wrap(slot, epoch.clone()))
+		.collect();
+	assert_eq!(claims, [1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
+}
+
+#[test]
+fn claim_vrf_check() {
+	let authority = Sr25519Keyring::Alice;
+	let keystore = create_keystore(authority);
+
+	let public = authority.public();
+
+	let epoch = Epoch {
+		start_slot: 0.into(),
+		authorities: vec![(public.into(), 1)],
+		randomness: [0; 32],
+		epoch_index: 1,
+		duration: 10,
+		config: BabeEpochConfiguration {
+			c: (3, 10),
+			allowed_slots: AllowedSlots::PrimaryAndSecondaryVRFSlots,
+		},
+	};
+
+	// We leverage the predictability of claim types given a constant randomness.
+
+	// We expect a Primary claim for slot 0
+
+	let pre_digest = match claim_slot(0.into(), &epoch, &keystore).unwrap().0 {
+		PreDigest::Primary(d) => d,
+		v => panic!("Unexpected pre-digest variant {:?}", v),
+	};
+	let data = make_vrf_sign_data(&epoch.randomness.clone(), 0.into(), epoch.epoch_index);
+	let sign = keystore.sr25519_vrf_sign(AuthorityId::ID, &public, &data).unwrap().unwrap();
+	assert_eq!(pre_digest.vrf_signature.output, sign.output);
+
+	// We expect a SecondaryVRF claim for slot 1
+	let pre_digest = match claim_slot(1.into(), &epoch, &keystore).unwrap().0 {
+		PreDigest::SecondaryVRF(d) => d,
+		v => panic!("Unexpected pre-digest variant {:?}", v),
+	};
+	let data = make_vrf_sign_data(&epoch.randomness.clone(), 1.into(), epoch.epoch_index);
+	let sign = keystore.sr25519_vrf_sign(AuthorityId::ID, &public, &data).unwrap().unwrap();
+	assert_eq!(pre_digest.vrf_signature.output, sign.output);
+
+	// Check that correct epoch index has been used if epochs are skipped (primary VRF)
+	let slot = Slot::from(103);
+	let claim = match claim_slot(slot, &epoch, &keystore).unwrap().0 {
+		PreDigest::Primary(d) => d,
+		v => panic!("Unexpected claim variant {:?}", v),
+	};
+	let fixed_epoch = epoch.clone_for_slot(slot);
+	let data = make_vrf_sign_data(&epoch.randomness.clone(), slot, fixed_epoch.epoch_index);
+	let sign = keystore.sr25519_vrf_sign(AuthorityId::ID, &public, &data).unwrap().unwrap();
+	assert_eq!(fixed_epoch.epoch_index, 11);
+	assert_eq!(claim.vrf_signature.output, sign.output);
+
+	// Check that correct epoch index has been used if epochs are skipped (secondary VRF)
+	let slot = Slot::from(100);
+	let pre_digest = match claim_slot(slot, &epoch, &keystore).unwrap().0 {
+		PreDigest::SecondaryVRF(d) => d,
+		v => panic!("Unexpected claim variant {:?}", v),
+	};
+	let fixed_epoch = epoch.clone_for_slot(slot);
+	let data = make_vrf_sign_data(&epoch.randomness.clone(), slot, fixed_epoch.epoch_index);
+	let sign = keystore.sr25519_vrf_sign(AuthorityId::ID, &public, &data).unwrap().unwrap();
+	assert_eq!(fixed_epoch.epoch_index, 11);
+	assert_eq!(pre_digest.vrf_signature.output, sign.output);
+}
+
+// Propose and import a new BABE block on top of the given parent.
+async fn propose_and_import_block(
+	parent: &TestHeader,
+	slot: Option<Slot>,
+	proposer_factory: &mut DummyFactory,
+	block_import: &mut BoxBlockImport<TestBlock>,
+) -> Hash {
+	let mut proposer = proposer_factory.init(parent).await.unwrap();
+
+	let slot = slot.unwrap_or_else(|| {
+		let parent_pre_digest = find_pre_digest::<TestBlock>(parent).unwrap();
+		parent_pre_digest.slot() + 1
+	});
+
+	let pre_digest = sp_runtime::generic::Digest {
+		logs: vec![Item::babe_pre_digest(PreDigest::SecondaryPlain(SecondaryPlainPreDigest {
+			authority_index: 0,
+			slot,
+		}))],
+	};
+
+	let parent_hash = parent.hash();
+
+	let mut block = proposer.propose_with(pre_digest).await.unwrap().block;
+
+	let epoch_descriptor = proposer_factory
+		.epoch_changes
+		.shared_data()
+		.epoch_descriptor_for_child_of(
+			descendent_query(&*proposer_factory.client),
+			&parent_hash,
+			*parent.number(),
+			slot,
+		)
+		.unwrap()
+		.unwrap();
+
+	let seal = {
+		// sign the pre-sealed hash of the block and then
+		// add it to a digest item.
+		let pair = AuthorityPair::from_seed(&[1; 32]);
+		let pre_hash = block.header.hash();
+		let signature = pair.sign(pre_hash.as_ref());
+		Item::babe_seal(signature)
+	};
+
+	let post_hash = {
+		block.header.digest_mut().push(seal.clone());
+		let h = block.header.hash();
+		block.header.digest_mut().pop();
+		h
+	};
+
+	let mut import = BlockImportParams::new(BlockOrigin::Own, block.header);
+	import.post_digests.push(seal);
+	import.body = Some(block.extrinsics);
+	import
+		.insert_intermediate(INTERMEDIATE_KEY, BabeIntermediate::<TestBlock> { epoch_descriptor });
+	import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+	let import_result = block_import.import_block(import).await.unwrap();
+
+	match import_result {
+		ImportResult::Imported(_) => {},
+		_ => panic!("expected block to be imported"),
+	}
+
+	post_hash
+}
+
+// Propose and import n valid BABE blocks that are built on top of the given parent.
+// The proposer takes care of producing epoch change digests according to the epoch
+// duration (which is set to 6 slots in the test runtime).
+async fn propose_and_import_blocks(
+	client: &PeersFullClient,
+	proposer_factory: &mut DummyFactory,
+	block_import: &mut BoxBlockImport<TestBlock>,
+	parent_hash: Hash,
+	n: usize,
+) -> Vec<Hash> {
+	let mut hashes = Vec::with_capacity(n);
+	let mut parent_header = client.header(parent_hash).unwrap().unwrap();
+
+	for _ in 0..n {
+		let block_hash =
+			propose_and_import_block(&parent_header, None, proposer_factory, block_import).await;
+		hashes.push(block_hash);
+		parent_header = client.header(block_hash).unwrap().unwrap();
+	}
+
+	hashes
+}
+
+#[tokio::test]
+async fn importing_block_one_sets_genesis_epoch() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+	let client = peer.client().as_client();
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+	let genesis_header = client.header(client.chain_info().genesis_hash).unwrap().unwrap();
+
+	let block_hash = propose_and_import_block(
+		&genesis_header,
+		Some(999.into()),
+		&mut proposer_factory,
+		&mut block_import,
+	)
+	.await;
+
+	let genesis_epoch = Epoch::genesis(&data.link.config, 999.into());
+
+	let epoch_changes = data.link.epoch_changes.shared_data();
+	let epoch_for_second_block = epoch_changes
+		.epoch_data_for_child_of(descendent_query(&*client), &block_hash, 1, 1000.into(), |slot| {
+			Epoch::genesis(&data.link.config, slot)
+		})
+		.unwrap()
+		.unwrap();
+
+	assert_eq!(epoch_for_second_block, genesis_epoch);
+}
+
+#[tokio::test]
+async fn revert_prunes_epoch_changes_and_removes_weights() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+	let client = peer.client().as_client();
+	let backend = peer.client().as_backend();
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+	let epoch_changes = data.link.epoch_changes.clone();
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	// Test scenario.
+	// Information for epoch 19 is produced on three different forks at block #13.
+	// One branch starts before the revert point (epoch data should be maintained).
+	// One branch starts after the revert point (epoch data should be removed).
+	//
+	//                        *----------------- F(#13) --#18                  < fork #2
+	//                       /
+	// A(#1) ---- B(#7) ----#8----+-----#12----- C(#13) ---- D(#19) ------#21  < canon
+	//   \                        ^       \
+	//    \                    revert      *---- G(#13) ---- H(#19) ---#20     < fork #3
+	//     \                   to #10
+	//      *-----E(#7)---#11                                          < fork #1
+	let canon = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().genesis_hash,
+		21,
+	)
+	.await;
+	let fork1 =
+		propose_and_import_blocks(&client, &mut proposer_factory, &mut block_import, canon[0], 10)
+			.await;
+	let fork2 =
+		propose_and_import_blocks(&client, &mut proposer_factory, &mut block_import, canon[7], 10)
+			.await;
+	let fork3 =
+		propose_and_import_blocks(&client, &mut proposer_factory, &mut block_import, canon[11], 8)
+			.await;
+
+	// We should be tracking a total of 9 epochs in the fork tree
+	assert_eq!(epoch_changes.shared_data().tree().iter().count(), 8);
+	// And only one root
+	assert_eq!(epoch_changes.shared_data().tree().roots().count(), 1);
+
+	// Revert canon chain to block #10 (best(21) - 11)
+	revert(client.clone(), backend, 11).expect("revert should work for baked test scenario");
+
+	// Load and check epoch changes.
+
+	let actual_nodes =
+		aux_schema::load_epoch_changes::<Block, TestClient>(&*client, &data.link.config)
+			.expect("load epoch changes")
+			.shared_data()
+			.tree()
+			.iter()
+			.map(|(h, _, _)| *h)
+			.collect::<Vec<_>>();
+
+	let expected_nodes = vec![
+		canon[0], // A
+		canon[6], // B
+		fork2[4], // F
+		fork1[5], // E
+	];
+
+	assert_eq!(actual_nodes, expected_nodes);
+
+	let weight_data_check = |hashes: &[Hash], expected: bool| {
+		hashes.iter().all(|hash| {
+			aux_schema::load_block_weight(&*client, hash).unwrap().is_some() == expected
+		})
+	};
+	assert!(weight_data_check(&canon[..10], true));
+	assert!(weight_data_check(&canon[10..], false));
+	assert!(weight_data_check(&fork1, true));
+	assert!(weight_data_check(&fork2, true));
+	assert!(weight_data_check(&fork3, false));
+}
+
+#[tokio::test]
+async fn revert_not_allowed_for_finalized() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+	let client = peer.client().as_client();
+	let backend = peer.client().as_backend();
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	let canon = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().genesis_hash,
+		3,
+	)
+	.await;
+
+	// Finalize best block
+	client.finalize_block(canon[2], None, false).unwrap();
+
+	// Revert canon chain to last finalized block
+	revert(client.clone(), backend, 100).expect("revert should work for baked test scenario");
+
+	let weight_data_check = |hashes: &[Hash], expected: bool| {
+		hashes.iter().all(|hash| {
+			aux_schema::load_block_weight(&*client, hash).unwrap().is_some() == expected
+		})
+	};
+	assert!(weight_data_check(&canon, true));
+}
+
+#[tokio::test]
+async fn importing_epoch_change_block_prunes_tree() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+	let client = peer.client().as_client();
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+	let epoch_changes = data.link.epoch_changes.clone();
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	// This is the block tree that we're going to use in this test. Each node
+	// represents an epoch change block, the epoch duration is 6 slots.
+	//
+	//    *---- F (#7)
+	//   /                 *------ G (#19) - H (#25)
+	//  /                 /
+	// A (#1) - B (#7) - C (#13) - D (#19) - E (#25)
+	//                              \
+	//                               *------ I (#25)
+
+	// Create and import the canon chain and keep track of fork blocks (A, C, D)
+	// from the diagram above.
+	let canon = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().genesis_hash,
+		30,
+	)
+	.await;
+
+	// Create the forks
+	let fork_1 =
+		propose_and_import_blocks(&client, &mut proposer_factory, &mut block_import, canon[0], 10)
+			.await;
+	let fork_2 =
+		propose_and_import_blocks(&client, &mut proposer_factory, &mut block_import, canon[12], 15)
+			.await;
+	let fork_3 =
+		propose_and_import_blocks(&client, &mut proposer_factory, &mut block_import, canon[18], 10)
+			.await;
+
+	// We should be tracking a total of 9 epochs in the fork tree
+	assert_eq!(epoch_changes.shared_data().tree().iter().count(), 9);
+
+	// And only one root
+	assert_eq!(epoch_changes.shared_data().tree().roots().count(), 1);
+
+	// We finalize block #13 from the canon chain, so on the next epoch
+	// change the tree should be pruned, to not contain F (#7).
+	client.finalize_block(canon[12], None, false).unwrap();
+	propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().best_hash,
+		7,
+	)
+	.await;
+
+	let nodes: Vec<_> = epoch_changes.shared_data().tree().iter().map(|(h, _, _)| *h).collect();
+
+	// no hashes from the first fork must exist on the tree
+	assert!(!nodes.iter().any(|h| fork_1.contains(h)));
+
+	// but the epoch changes from the other forks must still exist
+	assert!(nodes.iter().any(|h| fork_2.contains(h)));
+	assert!(nodes.iter().any(|h| fork_3.contains(h)));
+
+	// finalizing block #25 from the canon chain should prune out the second fork
+	client.finalize_block(canon[24], None, false).unwrap();
+	propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().best_hash,
+		8,
+	)
+	.await;
+
+	let nodes: Vec<_> = epoch_changes.shared_data().tree().iter().map(|(h, _, _)| *h).collect();
+
+	// no hashes from the other forks must exist on the tree
+	assert!(!nodes.iter().any(|h| fork_2.contains(h)));
+	assert!(!nodes.iter().any(|h| fork_3.contains(h)));
+
+	// Check that we contain the nodes that we care about
+	assert!(nodes.iter().any(|h| *h == canon[18]));
+	assert!(nodes.iter().any(|h| *h == canon[24]));
+}
+
+#[tokio::test]
+#[should_panic(expected = "Slot number must increase: parent slot: 999, this slot: 999")]
+async fn verify_slots_are_strictly_increasing() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+	let client = peer.client().as_client();
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	let genesis_header = client.header(client.chain_info().genesis_hash).unwrap().unwrap();
+
+	// we should have no issue importing this block
+	let b1 = propose_and_import_block(
+		&genesis_header,
+		Some(999.into()),
+		&mut proposer_factory,
+		&mut block_import,
+	)
+	.await;
+
+	let b1 = client.header(b1).unwrap().unwrap();
+
+	// we should fail to import this block since the slot number didn't increase.
+	// we will panic due to the `PanickingBlockImport` defined above.
+	propose_and_import_block(&b1, Some(999.into()), &mut proposer_factory, &mut block_import).await;
+}
+
+#[tokio::test]
+async fn obsolete_blocks_aux_data_cleanup() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+	let client = peer.client().as_client();
+
+	// Register the handler (as done by `babe_start`)
+	let client_clone = client.clone();
+	let on_finality = move |summary: &FinalityNotification<TestBlock>| {
+		aux_storage_cleanup(client_clone.as_ref(), summary)
+	};
+	client.register_finality_action(Box::new(on_finality));
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+	let aux_data_check = |hashes: &[Hash], expected: bool| {
+		hashes.iter().all(|hash| {
+			aux_schema::load_block_weight(&*peer.client().as_backend(), hash)
+				.unwrap()
+				.is_some() == expected
+		})
+	};
+
+	// Create the following test scenario:
+	//
+	//  /--- --B3 --- B4                       ( < fork2 )
+	// G --- A1 --- A2 --- A3 --- A4           ( < fork1 )
+	//                      \-----C4 --- C5    ( < fork3 )
+
+	let fork1_hashes = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().genesis_hash,
+		4,
+	)
+	.await;
+	let fork2_hashes = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().genesis_hash,
+		2,
+	)
+	.await;
+	let fork3_hashes = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		fork1_hashes[2],
+		2,
+	)
+	.await;
+
+	// Check that aux data is present for all but the genesis block.
+	assert!(aux_data_check(&[client.chain_info().genesis_hash], false));
+	assert!(aux_data_check(&fork1_hashes, true));
+	assert!(aux_data_check(&fork2_hashes, true));
+	assert!(aux_data_check(&fork3_hashes, true));
+
+	// Finalize A3
+	client.finalize_block(fork1_hashes[2], None, true).unwrap();
+
+	// Wiped: A1, A2
+	assert!(aux_data_check(&fork1_hashes[..2], false));
+	// Present: A3, A4
+	assert!(aux_data_check(&fork1_hashes[2..], true));
+	// Wiped: B3, B4
+	assert!(aux_data_check(&fork2_hashes, false));
+	// Present C4, C5
+	assert!(aux_data_check(&fork3_hashes, true));
+
+	client.finalize_block(fork1_hashes[3], None, true).unwrap();
+
+	// Wiped: A3
+	assert!(aux_data_check(&fork1_hashes[2..3], false));
+	// Present: A4
+	assert!(aux_data_check(&fork1_hashes[3..], true));
+	// Present C4, C5
+	assert!(aux_data_check(&fork3_hashes, true));
+}
+
+#[tokio::test]
+async fn allows_skipping_epochs() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+	let client = peer.client().as_client();
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	let epoch_changes = data.link.epoch_changes.clone();
+	let epoch_length = data.link.config.epoch_length;
+
+	// we create all of the blocks in epoch 0 as well as a block in epoch 1
+	let blocks = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().genesis_hash,
+		epoch_length as usize + 1,
+	)
+	.await;
+
+	// the first block in epoch 0 (#1) announces both epoch 0 and 1 (this is a
+	// special genesis epoch)
+	let epoch0 = epoch_changes
+		.shared_data()
+		.epoch(&EpochIdentifier {
+			position: EpochIdentifierPosition::Genesis0,
+			hash: blocks[0],
+			number: 1,
+		})
+		.unwrap()
+		.clone();
+
+	assert_eq!(epoch0.epoch_index, 0);
+	assert_eq!(epoch0.start_slot, Slot::from(1));
+
+	let epoch1 = epoch_changes
+		.shared_data()
+		.epoch(&EpochIdentifier {
+			position: EpochIdentifierPosition::Genesis1,
+			hash: blocks[0],
+			number: 1,
+		})
+		.unwrap()
+		.clone();
+
+	assert_eq!(epoch1.epoch_index, 1);
+	assert_eq!(epoch1.start_slot, Slot::from(epoch_length + 1));
+
+	// the first block in epoch 1 (#7) announces epoch 2. we will be skipping
+	// this epoch and therefore re-using its data for epoch 3
+	let epoch2 = epoch_changes
+		.shared_data()
+		.epoch(&EpochIdentifier {
+			position: EpochIdentifierPosition::Regular,
+			hash: blocks[epoch_length as usize],
+			number: epoch_length + 1,
+		})
+		.unwrap()
+		.clone();
+
+	assert_eq!(epoch2.epoch_index, 2);
+	assert_eq!(epoch2.start_slot, Slot::from(epoch_length * 2 + 1));
+
+	// we now author a block that belongs to epoch 3, thereby skipping epoch 2
+	let last_block = client.expect_header(*blocks.last().unwrap()).unwrap();
+	let block = propose_and_import_block(
+		&last_block,
+		Some((epoch_length * 3 + 1).into()),
+		&mut proposer_factory,
+		&mut block_import,
+	)
+	.await;
+
+	// and the first block in epoch 3 (#8) announces epoch 4
+	let epoch4 = epoch_changes
+		.shared_data()
+		.epoch(&EpochIdentifier {
+			position: EpochIdentifierPosition::Regular,
+			hash: block,
+			number: epoch_length + 2,
+		})
+		.unwrap()
+		.clone();
+
+	assert_eq!(epoch4.epoch_index, 4);
+	assert_eq!(epoch4.start_slot, Slot::from(epoch_length * 4 + 1));
+
+	// if we try to get the epoch data for a slot in epoch 3
+	let epoch3 = epoch_changes
+		.shared_data()
+		.epoch_data_for_child_of(
+			descendent_query(&*client),
+			&block,
+			epoch_length + 2,
+			(epoch_length * 3 + 2).into(),
+			|slot| Epoch::genesis(&data.link.config, slot),
+		)
+		.unwrap()
+		.unwrap();
+
+	// we get back the data for epoch 2
+	assert_eq!(epoch3, epoch2);
+
+	// but if we try to get the epoch data for a slot in epoch 4
+	let epoch4_ = epoch_changes
+		.shared_data()
+		.epoch_data_for_child_of(
+			descendent_query(&*client),
+			&block,
+			epoch_length + 2,
+			(epoch_length * 4 + 1).into(),
+			|slot| Epoch::genesis(&data.link.config, slot),
+		)
+		.unwrap()
+		.unwrap();
+
+	// we get epoch 4 as expected
+	assert_eq!(epoch4, epoch4_);
+}
+
+#[tokio::test]
+async fn allows_skipping_epochs_on_some_forks() {
+	let mut net = BabeTestNet::new(1);
+
+	let peer = net.peer(0);
+	let data = peer.data.as_ref().expect("babe link set up during initialization");
+
+	let client = peer.client().as_client();
+	let mut block_import = data.block_import.lock().take().expect("import set up during init");
+
+	let mut proposer_factory = DummyFactory {
+		client: client.clone(),
+		epoch_changes: data.link.epoch_changes.clone(),
+		mutator: Arc::new(|_, _| ()),
+	};
+
+	let epoch_changes = data.link.epoch_changes.clone();
+	let epoch_length = data.link.config.epoch_length;
+
+	// we create all of the blocks in epoch 0 as well as two blocks in epoch 1
+	let blocks = propose_and_import_blocks(
+		&client,
+		&mut proposer_factory,
+		&mut block_import,
+		client.chain_info().genesis_hash,
+		epoch_length as usize + 1,
+	)
+	.await;
+
+	// we now author a block that belongs to epoch 2, built on top of the last
+	// authored block in epoch 1.
+	let last_block = client.expect_header(*blocks.last().unwrap()).unwrap();
+
+	let epoch2_block = propose_and_import_block(
+		&last_block,
+		Some((epoch_length * 2 + 1).into()),
+		&mut proposer_factory,
+		&mut block_import,
+	)
+	.await;
+
+	// if we try to get the epoch data for a slot in epoch 2, we get the data that
+	// was previously announced when epoch 1 started
+	let epoch2 = epoch_changes
+		.shared_data()
+		.epoch_data_for_child_of(
+			descendent_query(&*client),
+			&epoch2_block,
+			epoch_length + 2,
+			(epoch_length * 2 + 2).into(),
+			|slot| Epoch::genesis(&data.link.config, slot),
+		)
+		.unwrap()
+		.unwrap();
+
+	// we now author a block that belongs to epoch 3, built on top of the last
+	// authored block in epoch 1. authoring this block means we're skipping epoch 2
+	// entirely on this fork
+	let epoch3_block = propose_and_import_block(
+		&last_block,
+		Some((epoch_length * 3 + 1).into()),
+		&mut proposer_factory,
+		&mut block_import,
+	)
+	.await;
+
+	// if we try to get the epoch data for a slot in epoch 3
+	let epoch3_ = epoch_changes
+		.shared_data()
+		.epoch_data_for_child_of(
+			descendent_query(&*client),
+			&epoch3_block,
+			epoch_length + 2,
+			(epoch_length * 3 + 2).into(),
+			|slot| Epoch::genesis(&data.link.config, slot),
+		)
+		.unwrap()
+		.unwrap();
+
+	// we get back the data for epoch 2
+	assert_eq!(epoch3_, epoch2);
+
+	// if we try to get the epoch data for a slot in epoch 4 in the fork
+	// where we skipped epoch 2, we should get the epoch data for epoch 4
+	// that was announced at the beginning of epoch 3
+	let epoch_data = epoch_changes
+		.shared_data()
+		.epoch_data_for_child_of(
+			descendent_query(&*client),
+			&epoch3_block,
+			epoch_length + 2,
+			(epoch_length * 4 + 1).into(),
+			|slot| Epoch::genesis(&data.link.config, slot),
+		)
+		.unwrap()
+		.unwrap();
+
+	assert!(epoch_data != epoch3_);
+
+	// if we try to get the epoch data for a slot in epoch 4 in the fork
+	// where we didn't skip epoch 2, we should get back the data for epoch 3,
+	// that was announced when epoch 2 started in that fork
+	let epoch_data = epoch_changes
+		.shared_data()
+		.epoch_data_for_child_of(
+			descendent_query(&*client),
+			&epoch2_block,
+			epoch_length + 2,
+			(epoch_length * 4 + 1).into(),
+			|slot| Epoch::genesis(&data.link.config, slot),
+		)
+		.unwrap()
+		.unwrap();
+
+	assert!(epoch_data != epoch3_);
+
+	let epoch3 = epoch_changes
+		.shared_data()
+		.epoch(&EpochIdentifier {
+			position: EpochIdentifierPosition::Regular,
+			hash: epoch2_block,
+			number: epoch_length + 2,
+		})
+		.unwrap()
+		.clone();
+
+	assert_eq!(epoch_data, epoch3);
+}
diff --git a/substrate/client/consensus/babe/src/verification.rs b/substrate/client/consensus/babe/src/verification.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3de5eacc2c519a0b38a9484a687e4975a2c759e6
--- /dev/null
+++ b/substrate/client/consensus/babe/src/verification.rs
@@ -0,0 +1,263 @@
+// 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/>.
+
+//! Verification for BABE headers.
+use crate::{
+	authorship::{calculate_primary_threshold, secondary_slot_author},
+	babe_err, find_pre_digest, BlockT, Epoch, Error, AUTHORING_SCORE_LENGTH,
+	AUTHORING_SCORE_VRF_CONTEXT, LOG_TARGET,
+};
+use log::{debug, trace};
+use sc_consensus_epochs::Epoch as EpochT;
+use sc_consensus_slots::CheckedHeader;
+use sp_consensus_babe::{
+	digests::{
+		CompatibleDigestItem, PreDigest, PrimaryPreDigest, SecondaryPlainPreDigest,
+		SecondaryVRFPreDigest,
+	},
+	make_vrf_sign_data, AuthorityId, AuthorityPair, AuthoritySignature,
+};
+use sp_consensus_slots::Slot;
+use sp_core::{
+	crypto::{VrfPublic, Wraps},
+	Pair,
+};
+use sp_runtime::{traits::Header, DigestItem};
+
+/// BABE verification parameters
+pub(super) struct VerificationParams<'a, B: 'a + BlockT> {
+	/// The header being verified.
+	pub(super) header: B::Header,
+	/// The pre-digest of the header being verified. this is optional - if prior
+	/// verification code had to read it, it can be included here to avoid duplicate
+	/// work.
+	pub(super) pre_digest: Option<PreDigest>,
+	/// The slot number of the current time.
+	pub(super) slot_now: Slot,
+	/// Epoch descriptor of the epoch this block _should_ be under, if it's valid.
+	pub(super) epoch: &'a Epoch,
+}
+
+/// Check a header has been signed by the right key. If the slot is too far in
+/// the future, an error will be returned. If successful, returns the pre-header
+/// and the digest item containing the seal.
+///
+/// The seal must be the last digest.  Otherwise, the whole header is considered
+/// unsigned.  This is required for security and must not be changed.
+///
+/// This digest item will always return `Some` when used with `as_babe_pre_digest`.
+///
+/// The given header can either be from a primary or secondary slot assignment,
+/// with each having different validation logic.
+pub(super) fn check_header<B: BlockT + Sized>(
+	params: VerificationParams<B>,
+) -> Result<CheckedHeader<B::Header, VerifiedHeaderInfo>, Error<B>> {
+	let VerificationParams { mut header, pre_digest, slot_now, epoch } = params;
+
+	let authorities = &epoch.authorities;
+	let pre_digest = pre_digest.map(Ok).unwrap_or_else(|| find_pre_digest::<B>(&header))?;
+
+	trace!(target: LOG_TARGET, "Checking header");
+	let seal = header
+		.digest_mut()
+		.pop()
+		.ok_or_else(|| babe_err(Error::HeaderUnsealed(header.hash())))?;
+
+	let sig = seal
+		.as_babe_seal()
+		.ok_or_else(|| babe_err(Error::HeaderBadSeal(header.hash())))?;
+
+	// the pre-hash of the header doesn't include the seal
+	// and that's what we sign
+	let pre_hash = header.hash();
+
+	if pre_digest.slot() > slot_now {
+		header.digest_mut().push(seal);
+		return Ok(CheckedHeader::Deferred(header, pre_digest.slot()))
+	}
+
+	let author = match authorities.get(pre_digest.authority_index() as usize) {
+		Some(author) => author.0.clone(),
+		None => return Err(babe_err(Error::SlotAuthorNotFound)),
+	};
+
+	match &pre_digest {
+		PreDigest::Primary(primary) => {
+			debug!(
+				target: LOG_TARGET,
+				"Verifying primary block #{} at slot: {}",
+				header.number(),
+				primary.slot,
+			);
+
+			check_primary_header::<B>(pre_hash, primary, sig, epoch, epoch.config.c)?;
+		},
+		PreDigest::SecondaryPlain(secondary)
+			if epoch.config.allowed_slots.is_secondary_plain_slots_allowed() =>
+		{
+			debug!(
+				target: LOG_TARGET,
+				"Verifying secondary plain block #{} at slot: {}",
+				header.number(),
+				secondary.slot,
+			);
+
+			check_secondary_plain_header::<B>(pre_hash, secondary, sig, epoch)?;
+		},
+		PreDigest::SecondaryVRF(secondary)
+			if epoch.config.allowed_slots.is_secondary_vrf_slots_allowed() =>
+		{
+			debug!(
+				target: LOG_TARGET,
+				"Verifying secondary VRF block #{} at slot: {}",
+				header.number(),
+				secondary.slot,
+			);
+
+			check_secondary_vrf_header::<B>(pre_hash, secondary, sig, epoch)?;
+		},
+		_ => return Err(babe_err(Error::SecondarySlotAssignmentsDisabled)),
+	}
+
+	let info = VerifiedHeaderInfo {
+		pre_digest: CompatibleDigestItem::babe_pre_digest(pre_digest),
+		seal,
+		author,
+	};
+	Ok(CheckedHeader::Checked(header, info))
+}
+
+pub(super) struct VerifiedHeaderInfo {
+	pub(super) pre_digest: DigestItem,
+	pub(super) seal: DigestItem,
+	pub(super) author: AuthorityId,
+}
+
+/// Check a primary slot proposal header. We validate that the given header is
+/// properly signed by the expected authority, and that the contained VRF proof
+/// is valid. Additionally, the weight of this block must increase compared to
+/// its parent since it is a primary block.
+fn check_primary_header<B: BlockT + Sized>(
+	pre_hash: B::Hash,
+	pre_digest: &PrimaryPreDigest,
+	signature: AuthoritySignature,
+	epoch: &Epoch,
+	c: (u64, u64),
+) -> Result<(), Error<B>> {
+	let authority_id = &epoch.authorities[pre_digest.authority_index as usize].0;
+	let mut epoch_index = epoch.epoch_index;
+
+	if epoch.end_slot() <= pre_digest.slot {
+		// Slot doesn't strictly belong to this epoch, create a clone with fixed values.
+		epoch_index = epoch.clone_for_slot(pre_digest.slot).epoch_index;
+	}
+
+	if !AuthorityPair::verify(&signature, pre_hash, authority_id) {
+		return Err(babe_err(Error::BadSignature(pre_hash)))
+	}
+
+	let data = make_vrf_sign_data(&epoch.randomness, pre_digest.slot, epoch_index);
+
+	if !authority_id.as_inner_ref().vrf_verify(&data, &pre_digest.vrf_signature) {
+		return Err(babe_err(Error::VrfVerificationFailed))
+	}
+
+	let threshold =
+		calculate_primary_threshold(c, &epoch.authorities, pre_digest.authority_index as usize);
+
+	let score = authority_id
+		.as_inner_ref()
+		.make_bytes::<AUTHORING_SCORE_LENGTH>(
+			AUTHORING_SCORE_VRF_CONTEXT,
+			&data.as_ref(),
+			&pre_digest.vrf_signature.output,
+		)
+		.map(u128::from_le_bytes)
+		.map_err(|_| babe_err(Error::VrfVerificationFailed))?;
+
+	if score >= threshold {
+		return Err(babe_err(Error::VrfThresholdExceeded(threshold)))
+	}
+
+	Ok(())
+}
+
+/// Check a secondary slot proposal header. We validate that the given header is
+/// properly signed by the expected authority, which we have a deterministic way
+/// of computing. Additionally, the weight of this block must stay the same
+/// compared to its parent since it is a secondary block.
+fn check_secondary_plain_header<B: BlockT>(
+	pre_hash: B::Hash,
+	pre_digest: &SecondaryPlainPreDigest,
+	signature: AuthoritySignature,
+	epoch: &Epoch,
+) -> Result<(), Error<B>> {
+	// check the signature is valid under the expected authority and chain state.
+	let expected_author =
+		secondary_slot_author(pre_digest.slot, &epoch.authorities, epoch.randomness)
+			.ok_or(Error::NoSecondaryAuthorExpected)?;
+
+	let author = &epoch.authorities[pre_digest.authority_index as usize].0;
+
+	if expected_author != author {
+		return Err(Error::InvalidAuthor(expected_author.clone(), author.clone()))
+	}
+
+	if !AuthorityPair::verify(&signature, pre_hash.as_ref(), author) {
+		return Err(Error::BadSignature(pre_hash))
+	}
+
+	Ok(())
+}
+
+/// Check a secondary VRF slot proposal header.
+fn check_secondary_vrf_header<B: BlockT>(
+	pre_hash: B::Hash,
+	pre_digest: &SecondaryVRFPreDigest,
+	signature: AuthoritySignature,
+	epoch: &Epoch,
+) -> Result<(), Error<B>> {
+	// check the signature is valid under the expected authority and chain state.
+	let expected_author =
+		secondary_slot_author(pre_digest.slot, &epoch.authorities, epoch.randomness)
+			.ok_or(Error::NoSecondaryAuthorExpected)?;
+
+	let author = &epoch.authorities[pre_digest.authority_index as usize].0;
+
+	if expected_author != author {
+		return Err(Error::InvalidAuthor(expected_author.clone(), author.clone()))
+	}
+
+	let mut epoch_index = epoch.epoch_index;
+	if epoch.end_slot() <= pre_digest.slot {
+		// Slot doesn't strictly belong to this epoch, create a clone with fixed values.
+		epoch_index = epoch.clone_for_slot(pre_digest.slot).epoch_index;
+	}
+
+	if !AuthorityPair::verify(&signature, pre_hash.as_ref(), author) {
+		return Err(Error::BadSignature(pre_hash))
+	}
+
+	let data = make_vrf_sign_data(&epoch.randomness, pre_digest.slot, epoch_index);
+
+	if !author.as_inner_ref().vrf_verify(&data, &pre_digest.vrf_signature) {
+		return Err(Error::VrfVerificationFailed)
+	}
+
+	Ok(())
+}
diff --git a/substrate/client/consensus/beefy/Cargo.toml b/substrate/client/consensus/beefy/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aec605c6bf11bfa14afae57028f1c90ff410c267
--- /dev/null
+++ b/substrate/client/consensus/beefy/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "sc-consensus-beefy"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+repository = "https://github.com/paritytech/substrate"
+description = "BEEFY Client gadget for substrate"
+homepage = "https://substrate.io"
+
+[dependencies]
+array-bytes = "6.1"
+async-channel = "1.8.0"
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+fnv = "1.0.6"
+futures = "0.3"
+log = "0.4"
+parking_lot = "0.12.1"
+thiserror = "1.0"
+wasm-timer = "0.2.5"
+prometheus = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
+sc-network = { version = "0.10.0-dev", path = "../../network" }
+sc-network-gossip = { version = "0.10.0-dev", path = "../../network-gossip" }
+sc-network-sync = { version = "0.10.0-dev", path = "../../network/sync" }
+sc-utils = { version = "4.0.0-dev", path = "../../utils" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-application-crypto = { version = "23.0.0", path = "../../../primitives/application-crypto" }
+sp-arithmetic = { version = "16.0.0", path = "../../../primitives/arithmetic" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-beefy = { version = "4.0.0-dev", path = "../../../primitives/consensus/beefy" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-mmr-primitives = { version = "4.0.0-dev", path = "../../../primitives/merkle-mountain-range" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+serde = "1.0.163"
+tempfile = "3.1.0"
+tokio = "1.22.0"
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sc-network-test = { version = "0.8.0", path = "../../network/test" }
+sp-consensus-grandpa = { version = "4.0.0-dev", path = "../../../primitives/consensus/grandpa" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/client/consensus/beefy/README.md b/substrate/client/consensus/beefy/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d9099dc7c661df409b0240356273bed5f30879ea
--- /dev/null
+++ b/substrate/client/consensus/beefy/README.md
@@ -0,0 +1,373 @@
+# BEEFY
+**BEEFY** (**B**ridge **E**fficiency **E**nabling **F**inality **Y**ielder) is a secondary
+protocol running along GRANDPA Finality to support efficient bridging with non-Substrate
+blockchains, currently mainly ETH mainnet.
+
+It can be thought of as an (optional) Bridge-specific Gadget to the GRANDPA Finality protocol.
+The Protocol piggybacks on many assumptions provided by GRANDPA, and is required to be built
+on top of it to work correctly.
+
+BEEFY is a consensus protocol designed with efficient trustless bridging in mind. It means
+that building a light client of BEEFY protocol should be optimized for restricted environments
+like Ethereum Smart Contracts or On-Chain State Transition Function (e.g. Substrate Runtime).
+Note that BEEFY is not a standalone protocol, it is meant to be running alongside GRANDPA, a
+finality gadget created for Substrate/Polkadot ecosystem. More details about GRANDPA can be found
+in the [whitepaper](https://github.com/w3f/consensus/blob/master/pdf/grandpa.pdf).
+
+# Context
+
+## Bridges
+
+We want to be able to "bridge" different blockchains. We do so by safely sharing and verifying
+information about each chain’s state, i.e. blockchain `A` should be able to verify that blockchain
+`B` is at block #X.
+
+## Finality
+
+Finality in blockchains is a concept that means that after a given block #X has been finalized,
+it will never be reverted (e.g. due to a re-org). As such, we can be assured that any transaction
+that exists in this block will never be reverted.
+
+## GRANDPA
+
+GRANDPA is our finality gadget. It allows a set of nodes to come to BFT agreement on what is the
+canonical chain. It requires that 2/3 of the validator set agrees on a prefix of the canonical
+chain, which then becomes finalized.
+
+![img](https://miro.medium.com/max/955/1*NTg26i4xbO3JncF_Usu9MA.png)
+
+### Difficulties of GRANDPA finality proofs
+
+```rust
+struct Justification<Block: BlockT> {
+    round: u64,
+    commit: Commit<Block>,
+    votes_ancestries: Vec<Block::Header>,
+}
+
+struct Commit<Hash, Number, Signature, Id> {
+    target_hash: Hash,
+    target_number: Number,
+    precommits: Vec<SignedPrecommit<Hash, Number, Signature, Id>>,
+}
+
+struct SignedPrecommit<Hash, Number, Signature, Id> {
+    precommit: Precommit<Hash, Number>,
+    signature: Signature,
+    id: Id,
+}
+
+struct Precommit<Hash, Number> {
+    target_hash: Hash,
+    target_number: Number,
+}
+```
+
+The main difficulty of verifying GRANDPA finality proofs comes from the fact that voters are
+voting on different things. In GRANDPA each voter will vote for the block they think is the
+latest one, and the protocol will come to agreement on what is the common ancestor which has >
+2/3 support.
+
+This creates two sets of inefficiencies:
+
+- We may need to have each validator's vote data because they're all potentially different (i.e.
+  just the signature isn't enough).
+- We may need to attach a couple of headers to the finality proof in order to be able to verify
+  all of the votes' ancestries.
+
+Additionally, since our interim goal is to bridge to Ethereum there is also a difficulty related
+to "incompatible" crypto schemes. We use \`ed25519\` signatures in GRANDPA which we can't
+efficiently verify in the EVM.
+
+Hence,
+
+### Goals of BEEFY
+
+1. Allow customisation of crypto to adapt for different targets. Support thresholds signatures as
+   well eventually.
+1. Minimize the size of the "signed payload" and the finality proof.
+1. Unify data types and use backward-compatible versioning so that the protocol can be extended
+   (additional payload, different crypto) without breaking existing light clients.
+
+And since BEEFY is required to be running on top of GRANDPA. This allows us to take couple of
+shortcuts:
+1. BEEFY validator set is **the same** as GRANDPA's (i.e. the same bonded actors), they might be
+   identified by different session keys though.
+1. BEEFY runs on **finalized** canonical chain, i.e. no forks (note Misbehavior
+   section though).
+1. From a single validator perspective, BEEFY has at most one active voting round. Since GRANDPA
+   validators are reaching finality, we assume they are on-line and well-connected and have
+   similar view of the state of the blockchain.
+
+# The BEEFY Protocol
+
+## Mental Model
+
+BEEFY should be considered as an extra voting round done by GRANDPA validators for the current
+best finalized block. Similarily to how GRANDPA is lagging behind best produced (non-finalized)
+block, BEEFY is going to lag behind best GRANDPA (finalized) block.
+
+```
+                       ┌──────� ┌──────� ┌──────� ┌──────� ┌──────�
+                       │      │ │      │ │      │ │      │ │      │
+                       │  B1  │ │  B2  │ │  B3  │ │  B4  │ │  B5  │
+                       │      │ │      │ │      │ │      │ │      │
+                       └──────┘ └───▲──┘ └──────┘ └───▲──┘ └───▲──┘
+                                    │                 │        │
+     Best BEEFY block───────────────┘                 │        │
+                                                      │        │
+     Best GRANDPA block───────────────────────────────┘        │
+                                                               │
+     Best produced block───────────────────────────────────────┘
+
+```
+
+A pseudo-algorithm of behaviour for a fully-synced BEEFY validator is:
+
+```
+loop {
+  let (best_beefy, best_grandpa) = wait_for_best_blocks();
+
+  let block_to_vote_on = choose_next_beefy_block(
+    best_beefy,
+    best_grandpa
+  );
+
+  let payload_to_vote_on = retrieve_payload(block_to_vote_on);
+
+  let commitment = (block_to_vote_on, payload_to_vote_on);
+
+  let signature = sign_with_current_session_key(commitment);
+
+  broadcast_vote(commitment, signature);
+}
+```
+
+## Details
+
+Before we jump into describing how BEEFY works in details, let's agree on the terms we are going
+to use and actors in the system. All nodes in the network need to participate in the BEEFY
+networking protocol, but we can identify two distinct actors though: **regular nodes** and
+**BEEFY validators**.
+Validators are expected to actively participate in the protocol, by producing and broadcasting
+**votes**. Votes are simply their signatures over a **Commitment**. A Commitment consists of a
+**payload** (an opaque blob of bytes extracted from a block or state at that block, expected to
+be some form of crypto accumulator (like Merkle Tree Hash or Merkle Mountain Range Root Hash))
+and **block number** from which this payload originates. Additionally, Commitment contains BEEFY
+**validator set id** at that particular block. Note the block is finalized, so there is no
+ambiguity despite using block number instead of a hash. A collection of **votes**, or rather
+a Commitment and a collection of signatures is going to be called **Signed Commitment**. A valid
+(see later for the rules) Signed Commitment is also called a **BEEFY Justification** or
+**BEEFY Finality Proof**. For more details on the actual data structures please see
+[BEEFY primitives definitions](https://github.com/paritytech/substrate/tree/master/primitives/beefy/src).
+
+A **round** is an attempt by BEEFY validators to produce a BEEFY Justification. **Round number**
+is simply defined as a block number the validators are voting for, or to be more precise, the
+Commitment for that block number. Round ends when the next round is started, which may happen
+when one of the events occur:
+1. Either the node collects `2/3rd + 1` valid votes for that round.
+2. Or the node receives a BEEFY Justification for a block greater than the current best BEEFY block.
+
+In both cases the node proceeds to determining the new round number using "Round Selection"
+procedure.
+
+Regular nodes are expected to:
+1. Receive & validate votes for the current round and broadcast them to their peers.
+1. Receive & validate BEEFY Justifications and broadcast them to their peers.
+1. Return BEEFY Justifications for **Mandatory Blocks** on demand.
+1. Optionally return BEEFY Justifications for non-mandatory blocks on demand.
+
+Validators are expected to additionally:
+1. Produce & broadcast vote for the current round.
+
+Both kinds of actors are expected to fully participate in the protocol ONLY IF they believe they
+are up-to-date with the rest of the network, i.e. they are fully synced. Before this happens,
+the node should continue processing imported BEEFY Justifications and votes without actively
+voting themselves.
+
+### Round Selection
+
+Every node (both regular nodes and validators) need to determine locally what they believe
+current round number is. The choice is based on their knowledge of:
+
+1. Best GRANDPA finalized block number (`best_grandpa`).
+1. Best BEEFY finalized block number (`best_beefy`).
+1. Starting block of current session (`session_start`).
+
+**Session** means a period of time (or rather number of blocks) where validator set (keys) do not change.
+See `pallet_session` for implementation details in `FRAME` context. Since we piggy-back on
+GRANDPA, session boundaries for BEEFY are exactly the same as the ones for GRANDPA.
+
+We define two kinds of blocks from the perspective of BEEFY protocol:
+1. **Mandatory Blocks**
+2. **Non-mandatory Blocks**
+
+Mandatory blocks are the ones that MUST have BEEFY justification. That means that the validators
+will always start and conclude a round at mandatory blocks. For non-mandatory blocks, there may
+or may not be a justification and validators may never choose these blocks to start a round.
+
+Every **first block in** each **session** is considered a **mandatory block**. All other blocks
+in the session are non-mandatory, however validators are encouraged to finalize as many blocks as
+possible to enable lower latency for light clients and hence end users. Since GRANDPA is
+considering session boundary blocks as mandatory as well, `session_start` block will always have
+both GRANDPA and BEEFY Justification.
+
+Therefore, to determine current round number nodes use a formula:
+
+```
+round_number =
+      (1 - M) * session_start
+   +        M * (best_beefy + NEXT_POWER_OF_TWO((best_grandpa - best_beefy + 1) / 2))
+```
+
+where:
+
+- `M` is `1` if mandatory block in current session is already finalized and `0` otherwise.
+- `NEXT_POWER_OF_TWO(x)` returns the smallest number greater or equal to `x` that is a power of two.
+
+In other words, the next round number should be the oldest mandatory block without a justification,
+or the highest GRANDPA-finalized block, whose block number difference with `best_beefy` block is
+a power of two. The mental model for round selection is to first finalize the mandatory block and
+then to attempt to pick a block taking into account how fast BEEFY catches up with GRANDPA.
+In case GRANDPA makes progress, but BEEFY seems to be lagging behind, validators are changing
+rounds less often to increase the chance of concluding them.
+
+As mentioned earlier, every time the node picks a new `round_number` (and validator casts a vote)
+it ends the previous one, no matter if finality was reached (i.e. the round concluded) or not.
+Votes for an inactive round should not be propagated.
+
+Note that since BEEFY only votes for GRANDPA-finalized blocks, `session_start` here actually means:
+"the latest session for which the start of is GRANDPA-finalized", i.e. block production might
+have already progressed, but BEEFY needs to first finalize the mandatory block of the older
+session.
+
+In good networking conditions BEEFY may end up finalizing each and every block (if GRANDPA does
+the same). Practically, with short block times, it's going to be rare and might be excessive, so
+it's suggested for implementations to introduce a `min_delta` parameter which will limit the
+frequency with which new rounds are started. The affected component of the formula would be:
+`best_beefy + MAX(min_delta, NEXT_POWER_OF_TWO(...))`, so we start a new round only if the
+power-of-two component is greater than the min delta. Note that if `round_number > best_grandpa`
+the validators are not expected to start any round.
+
+### Catch up
+
+Every session is guaranteed to have at least one BEEFY-finalized block. However it also means
+that the round at mandatory block must be concluded even though, a new session has already started
+(i.e. the on-chain component has selected a new validator set and GRANDPA might have already
+finalized the transition). In such case BEEFY must "catch up" the previous sessions and make sure to
+conclude rounds for mandatory blocks. Note that older sessions must obviously be finalized by the
+validator set at that point in time, not the latest/current one.
+
+### Initial Sync
+
+It's all rainbows and unicorns when the node is fully synced with the network. However during cold
+startup it will have hard time determining the current round number. Because of that nodes that
+are not fully synced should not participate in BEEFY protocol at all.
+
+During the sync we should make sure to also fetch BEEFY justifications for all mandatory blocks.
+This can happen asynchronously, but validators, before starting to vote, need to be certain
+about the last session that contains a concluded round on mandatory block in order to initiate the
+catch up procedure.
+
+### Gossip
+
+Nodes participating in BEEFY protocol are expected to gossip messages around.
+The protocol defines following messages:
+
+1. Votes for the current round,
+2. BEEFY Justifications for recently concluded rounds,
+3. BEEFY Justification for the latest mandatory block,
+
+Each message is additionally associated with a **topic**, which can be either:
+1. the round number (i.e. topic associated with a particular round),
+2. or the global topic (independent from the rounds).
+
+Round-specific topic should only be used to gossip the votes, other messages are gossiped
+periodically on the global topic. Let's now dive into description of the messages.
+
+- **Votes**
+  - Votes are sent on the round-specific topic.
+  - Vote is considered valid when:
+    - The commitment matches local commitment.
+    - The validator is part of the current validator set.
+    - The signature is correct.
+
+- **BEEFY Justification**
+  - Justifications are sent on the global topic.
+  - Justification is considered worthwhile to gossip when:
+    - It is for a recent (implementation specific) round or the latest mandatory round.
+    - All signatures are valid and there is at least `2/3rd + 1` of them.
+    - Signatorees are part of the current validator set.
+  - Mandatory justifications should be announced periodically.
+
+## Misbehavior
+
+Similarily to other PoS protocols, BEEFY considers casting two different votes in the same round a
+misbehavior. I.e. for a particular `round_number`, the validator produces signatures for 2 different
+`Commitment`s and broadcasts them. This is called **equivocation**.
+
+On top of this, voting on an incorrect **payload** is considered a misbehavior as well, and since
+we piggy-back on GRANDPA there is no ambiguity in terms of the fork validators should be voting for.
+
+Misbehavior should be penalized. If more validators misbehave in the exact same `round` the
+penalty should be more severe, up to the entire bonded stake in case we reach `1/3rd + 1`
+validators misbehaving.
+
+## Ethereum
+
+Initial version of BEEFY was made to enable efficient bridging with Ethereum, where the light
+client is a Solidity Smart Contract compiled to EVM bytecode. Hence the choice of the initial
+cryptography for BEEFY: `secp256k1` and usage of `keccak256` hashing function.
+
+### Future: Supporting multiple crypto
+
+While BEEFY currently works with `secp256k1` signatures, we intend in the future to support
+multiple signature schemes.
+This means that multiple kinds of `SignedCommitment`s might exist and only together they form a
+full `BEEFY Justification`.
+
+## BEEFY Key
+
+The current cryptographic scheme used by BEEFY is `ecdsa`. This is **different** from other
+schemes like `sr25519` and `ed25519` which are commonly used in Substrate configurations for
+other pallets (BABE, GRANDPA, AuRa, etc). The most noticeable difference is that an `ecdsa`
+public key is `33` bytes long, instead of `32` bytes for a `sr25519` based public key. So, a
+BEEFY key [sticks out](https://github.com/paritytech/polkadot/blob/25951e45b1907853f120c752aaa01631a0b3e783/node/service/src/chain_spec.rs#L738)
+among the other public keys a bit.
+
+For other crypto (using the default Substrate configuration) the `AccountId` (32-bytes) matches
+the `PublicKey`, but note that it's not the case for BEEFY. As a consequence of this, you can
+**not** convert the `AccountId` raw bytes into a BEEFY `PublicKey`.
+
+The easiest way to generate or view hex-encoded or SS58-encoded BEEFY Public Key is by using the
+[Subkey](https://substrate.dev/docs/en/knowledgebase/integrate/subkey) tool. Generate a BEEFY key
+using the following command
+
+```sh
+subkey generate --scheme ecdsa
+```
+
+The output will look something like
+
+```sh
+Secret phrase `sunset anxiety liberty mention dwarf actress advice stove peasant olive kite rebuild` is account:
+  Secret seed:       0x9f844e21444683c8fcf558c4c11231a14ed9dea6f09a8cc505604368ef204a61
+  Public key (hex):  0x02d69740c3bbfbdbb365886c8270c4aafd17cbffb2e04ecef581e6dced5aded2cd
+  Public key (SS58): KW7n1vMENCBLQpbT5FWtmYWHNvEyGjSrNL4JE32mDds3xnXTf
+  Account ID:        0x295509ae9a9b04ade5f1756b5f58f4161cf57037b4543eac37b3b555644f6aed
+  SS58 Address:      5Czu5hudL79ETnQt6GAkVJHGhDQ6Qv3VWq54zN1CPKzKzYGu
+
+```
+
+In case your BEEFY keys are using the wrong cryptographic scheme, you will see an invalid public
+key format message at node startup. Basically something like
+
+```sh
+...
+2021-05-28 12:37:51  [Relaychain] Invalid BEEFY PublicKey format!
+...
+```
+
+# BEEFY Light Client
+
+TODO
diff --git a/substrate/client/consensus/beefy/rpc/Cargo.toml b/substrate/client/consensus/beefy/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4f6e0d8c84b6ba675a2bd5a67e2336f275f8d509
--- /dev/null
+++ b/substrate/client/consensus/beefy/rpc/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "sc-consensus-beefy-rpc"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+repository = "https://github.com/paritytech/substrate"
+description = "RPC for the BEEFY Client gadget for substrate"
+homepage = "https://substrate.io"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+futures = "0.3.21"
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+log = "0.4"
+parking_lot = "0.12.1"
+serde = { version = "1.0.163", features = ["derive"] }
+thiserror = "1.0"
+sc-consensus-beefy = { version = "4.0.0-dev", path = "../" }
+sp-consensus-beefy = { version = "4.0.0-dev", path = "../../../../primitives/consensus/beefy" }
+sc-rpc = { version = "4.0.0-dev", path = "../../../rpc" }
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+
+[dev-dependencies]
+serde_json = "1.0.85"
+sc-rpc = { version = "4.0.0-dev", features = ["test-helpers"], path = "../../../rpc" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../../test-utils/runtime/client" }
+tokio = { version = "1.22.0", features = ["macros"] }
diff --git a/substrate/client/consensus/beefy/rpc/src/lib.rs b/substrate/client/consensus/beefy/rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f5c0ff32627d5e1a7b67d05e1d836e23c0ba9402
--- /dev/null
+++ b/substrate/client/consensus/beefy/rpc/src/lib.rs
@@ -0,0 +1,303 @@
+// 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/>.
+
+//! RPC API for BEEFY.
+
+#![warn(missing_docs)]
+
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+use sc_rpc::SubscriptionTaskExecutor;
+use sp_runtime::traits::Block as BlockT;
+
+use futures::{task::SpawnError, FutureExt, StreamExt};
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError, RpcResult},
+	proc_macros::rpc,
+	types::{error::CallError, ErrorObject, SubscriptionResult},
+	SubscriptionSink,
+};
+use log::warn;
+
+use sc_consensus_beefy::communication::notification::{
+	BeefyBestBlockStream, BeefyVersionedFinalityProofStream,
+};
+
+mod notification;
+
+#[derive(Debug, thiserror::Error)]
+/// Top-level error type for the RPC handler
+pub enum Error {
+	/// The BEEFY RPC endpoint is not ready.
+	#[error("BEEFY RPC endpoint not ready")]
+	EndpointNotReady,
+	/// The BEEFY RPC background task failed to spawn.
+	#[error("BEEFY RPC background task failed to spawn")]
+	RpcTaskFailure(#[from] SpawnError),
+}
+
+/// The error codes returned by jsonrpc.
+pub enum ErrorCode {
+	/// Returned when BEEFY RPC endpoint is not ready.
+	NotReady = 1,
+	/// Returned on BEEFY RPC background task failure.
+	TaskFailure = 2,
+}
+
+impl From<Error> for ErrorCode {
+	fn from(error: Error) -> Self {
+		match error {
+			Error::EndpointNotReady => ErrorCode::NotReady,
+			Error::RpcTaskFailure(_) => ErrorCode::TaskFailure,
+		}
+	}
+}
+
+impl From<Error> for JsonRpseeError {
+	fn from(error: Error) -> Self {
+		let message = error.to_string();
+		let code = ErrorCode::from(error);
+		JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+			code as i32,
+			message,
+			None::<()>,
+		)))
+	}
+}
+
+// Provides RPC methods for interacting with BEEFY.
+#[rpc(client, server)]
+pub trait BeefyApi<Notification, Hash> {
+	/// Returns the block most recently finalized by BEEFY, alongside its justification.
+	#[subscription(
+		name = "beefy_subscribeJustifications" => "beefy_justifications",
+		unsubscribe = "beefy_unsubscribeJustifications",
+		item = Notification,
+	)]
+	fn subscribe_justifications(&self);
+
+	/// Returns hash of the latest BEEFY finalized block as seen by this client.
+	///
+	/// The latest BEEFY block might not be available if the BEEFY gadget is not running
+	/// in the network or if the client is still initializing or syncing with the network.
+	/// In such case an error would be returned.
+	#[method(name = "beefy_getFinalizedHead")]
+	async fn latest_finalized(&self) -> RpcResult<Hash>;
+}
+
+/// Implements the BeefyApi RPC trait for interacting with BEEFY.
+pub struct Beefy<Block: BlockT> {
+	finality_proof_stream: BeefyVersionedFinalityProofStream<Block>,
+	beefy_best_block: Arc<RwLock<Option<Block::Hash>>>,
+	executor: SubscriptionTaskExecutor,
+}
+
+impl<Block> Beefy<Block>
+where
+	Block: BlockT,
+{
+	/// Creates a new Beefy Rpc handler instance.
+	pub fn new(
+		finality_proof_stream: BeefyVersionedFinalityProofStream<Block>,
+		best_block_stream: BeefyBestBlockStream<Block>,
+		executor: SubscriptionTaskExecutor,
+	) -> Result<Self, Error> {
+		let beefy_best_block = Arc::new(RwLock::new(None));
+
+		let stream = best_block_stream.subscribe(100_000);
+		let closure_clone = beefy_best_block.clone();
+		let future = stream.for_each(move |best_beefy| {
+			let async_clone = closure_clone.clone();
+			async move { *async_clone.write() = Some(best_beefy) }
+		});
+
+		executor.spawn("substrate-rpc-subscription", Some("rpc"), future.map(drop).boxed());
+		Ok(Self { finality_proof_stream, beefy_best_block, executor })
+	}
+}
+
+#[async_trait]
+impl<Block> BeefyApiServer<notification::EncodedVersionedFinalityProof, Block::Hash>
+	for Beefy<Block>
+where
+	Block: BlockT,
+{
+	fn subscribe_justifications(&self, mut sink: SubscriptionSink) -> SubscriptionResult {
+		let stream = self
+			.finality_proof_stream
+			.subscribe(100_000)
+			.map(|vfp| notification::EncodedVersionedFinalityProof::new::<Block>(vfp));
+
+		let fut = async move {
+			sink.pipe_from_stream(stream).await;
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+		Ok(())
+	}
+
+	async fn latest_finalized(&self) -> RpcResult<Block::Hash> {
+		self.beefy_best_block
+			.read()
+			.as_ref()
+			.cloned()
+			.ok_or(Error::EndpointNotReady)
+			.map_err(Into::into)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use codec::{Decode, Encode};
+	use jsonrpsee::{types::EmptyServerParams as EmptyParams, RpcModule};
+	use sc_consensus_beefy::{
+		communication::notification::BeefyVersionedFinalityProofSender,
+		justification::BeefyVersionedFinalityProof,
+	};
+	use sp_consensus_beefy::{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>) {
+		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>) {
+		let (finality_proof_sender, finality_proof_stream) =
+			BeefyVersionedFinalityProofStream::<Block>::channel();
+
+		let handler =
+			Beefy::new(finality_proof_stream, best_block_stream, sc_rpc::testing::test_executor())
+				.expect("Setting up the BEEFY RPC handler works");
+
+		(handler.into_rpc(), finality_proof_sender)
+	}
+
+	#[tokio::test]
+	async fn uninitialized_rpc_handler() {
+		let (rpc, _) = setup_io_handler();
+		let request = r#"{"jsonrpc":"2.0","method":"beefy_getFinalizedHead","params":[],"id":1}"#;
+		let expected_response = r#"{"jsonrpc":"2.0","error":{"code":1,"message":"BEEFY RPC endpoint not ready"},"id":1}"#.to_string();
+		let (response, _) = rpc.raw_json_request(&request).await.unwrap();
+
+		assert_eq!(expected_response, response.result);
+	}
+
+	#[tokio::test]
+	async fn latest_finalized_rpc() {
+		let (sender, stream) = BeefyBestBlockStream::<Block>::channel();
+		let (io, _) = setup_io_handler_with_best_block_stream(stream);
+
+		let hash = BlakeTwo256::hash(b"42");
+		let r: Result<(), ()> = sender.notify(|| Ok(hash));
+		r.unwrap();
+
+		// Verify RPC `beefy_getFinalizedHead` returns expected hash.
+		let request = r#"{"jsonrpc":"2.0","method":"beefy_getFinalizedHead","params":[],"id":1}"#;
+		let expected = "{\
+			\"jsonrpc\":\"2.0\",\
+			\"result\":\"0x2f0039e93a27221fcf657fb877a1d4f60307106113e885096cb44a461cd0afbf\",\
+			\"id\":1\
+		}"
+		.to_string();
+		let not_ready = "{\
+			\"jsonrpc\":\"2.0\",\
+			\"error\":{\"code\":1,\"message\":\"BEEFY RPC endpoint not ready\"},\
+			\"id\":1\
+		}"
+		.to_string();
+
+		let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2);
+		while std::time::Instant::now() < deadline {
+			let (response, _) = io.raw_json_request(request).await.expect("RPC requests work");
+			if response.result != not_ready {
+				assert_eq!(response.result, expected);
+				// Success
+				return
+			}
+			std::thread::sleep(std::time::Duration::from_millis(50))
+		}
+
+		panic!(
+			"Deadline reached while waiting for best BEEFY block to update. Perhaps the background task is broken?"
+		);
+	}
+
+	#[tokio::test]
+	async fn subscribe_and_unsubscribe_with_wrong_id() {
+		let (rpc, _) = setup_io_handler();
+		// Subscribe call.
+		let _sub = rpc
+			.subscribe("beefy_subscribeJustifications", EmptyParams::new())
+			.await
+			.unwrap();
+
+		// Unsubscribe with wrong ID
+		let (response, _) = rpc
+			.raw_json_request(
+				r#"{"jsonrpc":"2.0","method":"beefy_unsubscribeJustifications","params":["FOO"],"id":1}"#,
+			)
+			.await
+			.unwrap();
+		let expected = r#"{"jsonrpc":"2.0","result":false,"id":1}"#;
+
+		assert_eq!(response.result, expected);
+	}
+
+	fn create_finality_proof() -> BeefyVersionedFinalityProof<Block> {
+		let payload =
+			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+		BeefyVersionedFinalityProof::<Block>::V1(SignedCommitment {
+			commitment: sp_consensus_beefy::Commitment {
+				payload,
+				block_number: 5,
+				validator_set_id: 0,
+			},
+			signatures: vec![],
+		})
+	}
+
+	#[tokio::test]
+	async fn subscribe_and_listen_to_one_justification() {
+		let (rpc, finality_proof_sender) = setup_io_handler();
+
+		// Subscribe
+		let mut sub = rpc
+			.subscribe("beefy_subscribeJustifications", EmptyParams::new())
+			.await
+			.unwrap();
+
+		// Notify with finality_proof
+		let finality_proof = create_finality_proof();
+		let r: Result<(), ()> = finality_proof_sender.notify(|| Ok(finality_proof.clone()));
+		r.unwrap();
+
+		// Inspect what we received
+		let (bytes, recv_sub_id) = sub.next::<sp_core::Bytes>().await.unwrap().unwrap();
+		let recv_finality_proof: BeefyVersionedFinalityProof<Block> =
+			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
new file mode 100644
index 0000000000000000000000000000000000000000..690c511b999ac1b89627cd1e67dc2ce8e2343862
--- /dev/null
+++ b/substrate/client/consensus/beefy/rpc/src/notification.rs
@@ -0,0 +1,39 @@
+// 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 codec::Encode;
+use serde::{Deserialize, Serialize};
+
+use sp_runtime::traits::Block as BlockT;
+
+/// An encoded finality proof proving that the given header has been finalized.
+/// The given bytes should be the SCALE-encoded representation of a
+/// `sp_consensus_beefy::VersionedFinalityProof`.
+#[derive(Clone, Serialize, Deserialize)]
+pub struct EncodedVersionedFinalityProof(sp_core::Bytes);
+
+impl EncodedVersionedFinalityProof {
+	pub fn new<Block>(
+		finality_proof: sc_consensus_beefy::justification::BeefyVersionedFinalityProof<Block>,
+	) -> Self
+	where
+		Block: BlockT,
+	{
+		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
new file mode 100644
index 0000000000000000000000000000000000000000..409eb30d09ab947f3beb997f81f926eb337efec1
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/aux_schema.rs
@@ -0,0 +1,106 @@
+// 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/>.
+
+//! Schema for BEEFY state persisted in the aux-db.
+
+use crate::{worker::PersistedState, LOG_TARGET};
+use codec::{Decode, Encode};
+use log::{info, trace};
+use sc_client_api::{backend::AuxStore, Backend};
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
+use sp_runtime::traits::Block as BlockT;
+
+const VERSION_KEY: &[u8] = b"beefy_auxschema_version";
+const WORKER_STATE_KEY: &[u8] = b"beefy_voter_state";
+
+const CURRENT_VERSION: u32 = 4;
+
+pub(crate) fn write_current_version<BE: AuxStore>(backend: &BE) -> ClientResult<()> {
+	info!(target: LOG_TARGET, "🥩 write aux schema version {:?}", CURRENT_VERSION);
+	AuxStore::insert_aux(backend, &[(VERSION_KEY, CURRENT_VERSION.encode().as_slice())], &[])
+}
+
+/// Write voter state.
+pub(crate) fn write_voter_state<B: BlockT, BE: AuxStore>(
+	backend: &BE,
+	state: &PersistedState<B>,
+) -> ClientResult<()> {
+	trace!(target: LOG_TARGET, "🥩 persisting {:?}", state);
+	AuxStore::insert_aux(backend, &[(WORKER_STATE_KEY, state.encode().as_slice())], &[])
+}
+
+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| 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) -> ClientResult<Option<PersistedState<B>>>
+where
+	B: BlockT,
+	BE: Backend<B>,
+{
+	let version: Option<u32> = load_decode(backend, VERSION_KEY)?;
+
+	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(ClientError::Backend(format!("Unsupported BEEFY DB version: {:?}", other))),
+	}
+
+	// No persistent state found in DB.
+	Ok(None)
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+	use crate::tests::BeefyTestNet;
+	use sc_network_test::TestNetFactory;
+
+	// also used in tests.rs
+	pub fn verify_persisted_version<B: BlockT, BE: Backend<B>>(backend: &BE) -> bool {
+		let version: u32 = load_decode(backend, VERSION_KEY).unwrap().unwrap();
+		version == CURRENT_VERSION
+	}
+
+	#[tokio::test]
+	async fn should_load_persistent_sanity_checks() {
+		let mut net = BeefyTestNet::new(1);
+		let backend = net.peer(0).client().as_backend();
+
+		// version not available in db -> None
+		assert_eq!(load_persistent(&*backend).unwrap(), None);
+
+		// populate version in db
+		write_current_version(&*backend).unwrap();
+		// verify correct version is retrieved
+		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);
+
+		// 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
new file mode 100644
index 0000000000000000000000000000000000000000..8c025ca0676197203035d652646a727e89354085
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/communication/gossip.rs
@@ -0,0 +1,811 @@
+// 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 std::{collections::BTreeMap, sync::Arc, time::Duration};
+
+use sc_network::{PeerId, ReputationChange};
+use sc_network_gossip::{MessageIntent, ValidationResult, Validator, ValidatorContext};
+use sp_core::hashing::twox_64;
+use sp_runtime::traits::{Block, Hash, Header, NumberFor};
+
+use codec::{Decode, DecodeAll, Encode};
+use log::{debug, trace};
+use parking_lot::{Mutex, RwLock};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use wasm_timer::Instant;
+
+use crate::{
+	communication::{
+		benefit, cost,
+		peers::{KnownPeers, PeerReport},
+	},
+	justification::{
+		proof_block_num_and_set_id, verify_with_validator_set, BeefyVersionedFinalityProof,
+	},
+	keystore::BeefyKeystore,
+	LOG_TARGET,
+};
+use sp_consensus_beefy::{
+	ecdsa_crypto::{AuthorityId, Signature},
+	ValidatorSet, ValidatorSetId, VoteMessage,
+};
+
+// Timeout for rebroadcasting messages.
+#[cfg(not(test))]
+const REBROADCAST_AFTER: Duration = Duration::from_secs(60);
+#[cfg(test)]
+const REBROADCAST_AFTER: Duration = Duration::from_secs(5);
+
+#[derive(Debug, PartialEq)]
+pub(super) enum Action<H> {
+	// repropagate under given topic, to the given peers, applying cost/benefit to originator.
+	Keep(H, ReputationChange),
+	// discard, applying cost/benefit to originator.
+	Discard(ReputationChange),
+}
+
+/// An outcome of examining a message.
+#[derive(Debug, PartialEq, Clone, Copy)]
+enum Consider {
+	/// Accept the message.
+	Accept,
+	/// Message is too early. Reject.
+	RejectPast,
+	/// Message is from the future. Reject.
+	RejectFuture,
+	/// Message cannot be evaluated. Reject.
+	RejectOutOfScope,
+}
+
+/// BEEFY gossip message type that gets encoded and sent on the network.
+#[derive(Debug, Encode, Decode)]
+pub(crate) enum GossipMessage<B: Block> {
+	/// BEEFY message with commitment and single signature.
+	Vote(VoteMessage<NumberFor<B>, AuthorityId, Signature>),
+	/// BEEFY justification with commitment and signatures.
+	FinalityProof(BeefyVersionedFinalityProof<B>),
+}
+
+impl<B: Block> GossipMessage<B> {
+	/// Return inner vote if this message is a Vote.
+	pub fn unwrap_vote(self) -> Option<VoteMessage<NumberFor<B>, AuthorityId, Signature>> {
+		match self {
+			GossipMessage::Vote(vote) => Some(vote),
+			GossipMessage::FinalityProof(_) => None,
+		}
+	}
+
+	/// Return inner finality proof if this message is a FinalityProof.
+	pub fn unwrap_finality_proof(self) -> Option<BeefyVersionedFinalityProof<B>> {
+		match self {
+			GossipMessage::Vote(_) => None,
+			GossipMessage::FinalityProof(proof) => Some(proof),
+		}
+	}
+}
+
+/// Gossip engine votes messages topic
+pub(crate) fn votes_topic<B: Block>() -> B::Hash
+where
+	B: Block,
+{
+	<<B::Header as Header>::Hashing as Hash>::hash(b"beefy-votes")
+}
+
+/// Gossip engine justifications messages topic
+pub(crate) fn proofs_topic<B: Block>() -> B::Hash
+where
+	B: Block,
+{
+	<<B::Header as Header>::Hashing as Hash>::hash(b"beefy-justifications")
+}
+
+/// A type that represents hash of the message.
+pub type MessageHash = [u8; 8];
+
+#[derive(Clone, Debug)]
+pub(crate) struct GossipFilterCfg<'a, B: Block> {
+	pub start: NumberFor<B>,
+	pub end: NumberFor<B>,
+	pub validator_set: &'a ValidatorSet<AuthorityId>,
+}
+
+#[derive(Clone, Debug)]
+struct FilterInner<B: Block> {
+	pub start: NumberFor<B>,
+	pub end: NumberFor<B>,
+	pub validator_set: ValidatorSet<AuthorityId>,
+}
+
+struct Filter<B: Block> {
+	inner: Option<FilterInner<B>>,
+	live_votes: BTreeMap<NumberFor<B>, fnv::FnvHashSet<MessageHash>>,
+}
+
+impl<B: Block> Filter<B> {
+	pub fn new() -> Self {
+		Self { inner: None, live_votes: BTreeMap::new() }
+	}
+
+	/// Update filter to new `start` and `set_id`.
+	fn update(&mut self, cfg: GossipFilterCfg<B>) {
+		self.live_votes.retain(|&round, _| round >= cfg.start && round <= cfg.end);
+		// only clone+overwrite big validator_set if set_id changed
+		match self.inner.as_mut() {
+			Some(f) if f.validator_set.id() == cfg.validator_set.id() => {
+				f.start = cfg.start;
+				f.end = cfg.end;
+			},
+			_ =>
+				self.inner = Some(FilterInner {
+					start: cfg.start,
+					end: cfg.end,
+					validator_set: cfg.validator_set.clone(),
+				}),
+		}
+	}
+
+	/// Accept if `max(session_start, best_beefy) <= round <= best_grandpa`,
+	/// and vote `set_id` matches session set id.
+	///
+	/// Latest concluded round is still considered alive to allow proper gossiping for it.
+	fn consider_vote(&self, round: NumberFor<B>, set_id: ValidatorSetId) -> Consider {
+		self.inner
+			.as_ref()
+			.map(|f|
+				// only from current set and only [filter.start, filter.end]
+				if set_id < f.validator_set.id() {
+					Consider::RejectPast
+				} else if set_id > f.validator_set.id() {
+					Consider::RejectFuture
+				} else if round < f.start {
+					Consider::RejectPast
+				} else if round > f.end {
+					Consider::RejectFuture
+				} else {
+					Consider::Accept
+				})
+			.unwrap_or(Consider::RejectOutOfScope)
+	}
+
+	/// Return true if `round` is >= than `max(session_start, best_beefy)`,
+	/// and proof `set_id` matches session set id.
+	///
+	/// Latest concluded round is still considered alive to allow proper gossiping for it.
+	fn consider_finality_proof(&self, round: NumberFor<B>, set_id: ValidatorSetId) -> Consider {
+		self.inner
+			.as_ref()
+			.map(|f|
+				// only from current set and only >= filter.start
+				if round < f.start || set_id < f.validator_set.id() {
+					Consider::RejectPast
+				} else if set_id > f.validator_set.id() {
+					Consider::RejectFuture
+				} else {
+					Consider::Accept
+				}
+			)
+			.unwrap_or(Consider::RejectOutOfScope)
+	}
+
+	/// Add new _known_ `hash` to the round's known votes.
+	fn add_known_vote(&mut self, round: NumberFor<B>, hash: MessageHash) {
+		self.live_votes.entry(round).or_default().insert(hash);
+	}
+
+	/// Check if `hash` is already part of round's known votes.
+	fn is_known_vote(&self, round: NumberFor<B>, hash: &MessageHash) -> bool {
+		self.live_votes.get(&round).map(|known| known.contains(hash)).unwrap_or(false)
+	}
+
+	fn validator_set(&self) -> Option<&ValidatorSet<AuthorityId>> {
+		self.inner.as_ref().map(|f| &f.validator_set)
+	}
+}
+
+/// BEEFY gossip validator
+///
+/// Validate BEEFY gossip messages and limit the number of live BEEFY voting rounds.
+///
+/// Allows messages for 'rounds >= last concluded' to flow, everything else gets
+/// rejected/expired.
+///
+///All messaging is handled in a single BEEFY global topic.
+pub(crate) struct GossipValidator<B>
+where
+	B: Block,
+{
+	votes_topic: B::Hash,
+	justifs_topic: B::Hash,
+	gossip_filter: RwLock<Filter<B>>,
+	next_rebroadcast: Mutex<Instant>,
+	known_peers: Arc<Mutex<KnownPeers<B>>>,
+	report_sender: TracingUnboundedSender<PeerReport>,
+}
+
+impl<B> GossipValidator<B>
+where
+	B: Block,
+{
+	pub(crate) fn new(
+		known_peers: Arc<Mutex<KnownPeers<B>>>,
+	) -> (GossipValidator<B>, TracingUnboundedReceiver<PeerReport>) {
+		let (tx, rx) = tracing_unbounded("mpsc_beefy_gossip_validator", 10_000);
+		let val = GossipValidator {
+			votes_topic: votes_topic::<B>(),
+			justifs_topic: proofs_topic::<B>(),
+			gossip_filter: RwLock::new(Filter::new()),
+			next_rebroadcast: Mutex::new(Instant::now() + REBROADCAST_AFTER),
+			known_peers,
+			report_sender: tx,
+		};
+		(val, rx)
+	}
+
+	/// 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>) {
+		debug!(target: LOG_TARGET, "🥩 New gossip filter {:?}", filter);
+		self.gossip_filter.write().update(filter);
+	}
+
+	fn report(&self, who: PeerId, cost_benefit: ReputationChange) {
+		let _ = self.report_sender.unbounded_send(PeerReport { who, cost_benefit });
+	}
+
+	fn validate_vote(
+		&self,
+		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
+		sender: &PeerId,
+		data: &[u8],
+	) -> Action<B::Hash> {
+		let msg_hash = twox_64(data);
+		let round = vote.commitment.block_number;
+		let set_id = vote.commitment.validator_set_id;
+		self.known_peers.lock().note_vote_for(*sender, round);
+
+		// Verify general usefulness of the message.
+		// We are going to discard old votes right away (without verification)
+		// Also we keep track of already received votes to avoid verifying duplicates.
+		{
+			let filter = self.gossip_filter.read();
+
+			match filter.consider_vote(round, set_id) {
+				Consider::RejectPast => return Action::Discard(cost::OUTDATED_MESSAGE),
+				Consider::RejectFuture => return Action::Discard(cost::FUTURE_MESSAGE),
+				Consider::RejectOutOfScope => return Action::Discard(cost::OUT_OF_SCOPE_MESSAGE),
+				Consider::Accept => {},
+			}
+
+			if filter.is_known_vote(round, &msg_hash) {
+				return Action::Keep(self.votes_topic, benefit::KNOWN_VOTE_MESSAGE)
+			}
+
+			// ensure authority is part of the set.
+			if !filter
+				.validator_set()
+				.map(|set| set.validators().contains(&vote.id))
+				.unwrap_or(false)
+			{
+				debug!(target: LOG_TARGET, "Message from voter not in validator set: {}", vote.id);
+				return Action::Discard(cost::UNKNOWN_VOTER)
+			}
+		}
+
+		if BeefyKeystore::verify(&vote.id, &vote.signature, &vote.commitment.encode()) {
+			self.gossip_filter.write().add_known_vote(round, msg_hash);
+			Action::Keep(self.votes_topic, benefit::VOTE_MESSAGE)
+		} else {
+			debug!(
+				target: LOG_TARGET,
+				"🥩 Bad signature on message: {:?}, from: {:?}", vote, sender
+			);
+			Action::Discard(cost::BAD_SIGNATURE)
+		}
+	}
+
+	fn validate_finality_proof(
+		&self,
+		proof: BeefyVersionedFinalityProof<B>,
+		sender: &PeerId,
+	) -> Action<B::Hash> {
+		let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
+		self.known_peers.lock().note_vote_for(*sender, round);
+
+		let guard = self.gossip_filter.read();
+		// Verify general usefulness of the justification.
+		match guard.consider_finality_proof(round, set_id) {
+			Consider::RejectPast => return Action::Discard(cost::OUTDATED_MESSAGE),
+			Consider::RejectFuture => return Action::Discard(cost::FUTURE_MESSAGE),
+			Consider::RejectOutOfScope => return Action::Discard(cost::OUT_OF_SCOPE_MESSAGE),
+			Consider::Accept => {},
+		}
+		// Verify justification signatures.
+		guard
+			.validator_set()
+			.map(|validator_set| {
+				if let Err((_, signatures_checked)) =
+					verify_with_validator_set::<B>(round, validator_set, &proof)
+				{
+					debug!(
+						target: LOG_TARGET,
+						"🥩 Bad signatures on message: {:?}, from: {:?}", proof, sender
+					);
+					let mut cost = cost::INVALID_PROOF;
+					cost.value +=
+						cost::PER_SIGNATURE_CHECKED.saturating_mul(signatures_checked as i32);
+					Action::Discard(cost)
+				} else {
+					Action::Keep(self.justifs_topic, benefit::VALIDATED_PROOF)
+				}
+			})
+			.unwrap_or(Action::Discard(cost::OUT_OF_SCOPE_MESSAGE))
+	}
+}
+
+impl<B> Validator<B> for GossipValidator<B>
+where
+	B: Block,
+{
+	fn peer_disconnected(&self, _context: &mut dyn ValidatorContext<B>, who: &PeerId) {
+		self.known_peers.lock().remove(who);
+	}
+
+	fn validate(
+		&self,
+		context: &mut dyn ValidatorContext<B>,
+		sender: &PeerId,
+		mut data: &[u8],
+	) -> ValidationResult<B::Hash> {
+		let raw = data;
+		let action = match GossipMessage::<B>::decode_all(&mut data) {
+			Ok(GossipMessage::Vote(msg)) => self.validate_vote(msg, sender, raw),
+			Ok(GossipMessage::FinalityProof(proof)) => self.validate_finality_proof(proof, sender),
+			Err(e) => {
+				debug!(target: LOG_TARGET, "Error decoding message: {}", e);
+				let bytes = raw.len().min(i32::MAX as usize) as i32;
+				let cost = ReputationChange::new(
+					bytes.saturating_mul(cost::PER_UNDECODABLE_BYTE),
+					"BEEFY: Bad packet",
+				);
+				Action::Discard(cost)
+			},
+		};
+		match action {
+			Action::Keep(topic, cb) => {
+				self.report(*sender, cb);
+				context.broadcast_message(topic, data.to_vec(), false);
+				ValidationResult::ProcessAndKeep(topic)
+			},
+			Action::Discard(cb) => {
+				self.report(*sender, cb);
+				ValidationResult::Discard
+			},
+		}
+	}
+
+	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,
+					expired
+				);
+				expired
+			},
+			Err(_) => true,
+		})
+	}
+
+	fn message_allowed<'a>(
+		&'a self,
+	) -> Box<dyn FnMut(&PeerId, MessageIntent, &B::Hash, &[u8]) -> bool + 'a> {
+		let do_rebroadcast = {
+			let now = Instant::now();
+			let mut next_rebroadcast = self.next_rebroadcast.lock();
+			if now >= *next_rebroadcast {
+				trace!(target: LOG_TARGET, "🥩 Gossip rebroadcast");
+				*next_rebroadcast = now + REBROADCAST_AFTER;
+				true
+			} else {
+				false
+			}
+		};
+
+		let filter = self.gossip_filter.read();
+		Box::new(move |_who, intent, _topic, mut data| {
+			if let MessageIntent::PeriodicRebroadcast = intent {
+				return do_rebroadcast
+			}
+
+			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 allowed = filter.consider_vote(round, set_id) == Consider::Accept;
+					trace!(target: LOG_TARGET, "🥩 Vote for round #{} allowed: {}", round, allowed);
+					allowed
+				},
+				Ok(GossipMessage::FinalityProof(proof)) => {
+					let (round, set_id) = proof_block_num_and_set_id::<B>(&proof);
+					let allowed = filter.consider_finality_proof(round, set_id) == Consider::Accept;
+					trace!(
+						target: LOG_TARGET,
+						"🥩 Finality proof for round #{} allowed: {}",
+						round,
+						allowed
+					);
+					allowed
+				},
+				Err(_) => false,
+			}
+		})
+	}
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+	use crate::keystore::BeefyKeystore;
+	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, Commitment, Keyring, MmrRootHash, Payload,
+		SignedCommitment, VoteMessage,
+	};
+	use sp_keystore::{testing::MemoryKeystore, Keystore};
+
+	#[test]
+	fn known_votes_insert_remove() {
+		let mut filter = Filter::<Block>::new();
+		let msg_hash = twox_64(b"data");
+		let keys = vec![Keyring::Alice.public()];
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 1).unwrap();
+
+		filter.add_known_vote(1, msg_hash);
+		filter.add_known_vote(1, msg_hash);
+		filter.add_known_vote(2, msg_hash);
+		assert_eq!(filter.live_votes.len(), 2);
+
+		filter.add_known_vote(3, msg_hash);
+		assert!(filter.is_known_vote(3, &msg_hash));
+		assert!(!filter.is_known_vote(3, &twox_64(b"other")));
+		assert!(!filter.is_known_vote(4, &msg_hash));
+		assert_eq!(filter.live_votes.len(), 3);
+
+		assert!(filter.inner.is_none());
+		assert_eq!(filter.consider_vote(1, 1), Consider::RejectOutOfScope);
+
+		filter.update(GossipFilterCfg { start: 3, end: 10, validator_set: &validator_set });
+		assert_eq!(filter.live_votes.len(), 1);
+		assert!(filter.live_votes.contains_key(&3));
+		assert_eq!(filter.consider_vote(2, 1), Consider::RejectPast);
+		assert_eq!(filter.consider_vote(3, 1), Consider::Accept);
+		assert_eq!(filter.consider_vote(4, 1), Consider::Accept);
+		assert_eq!(filter.consider_vote(20, 1), Consider::RejectFuture);
+		assert_eq!(filter.consider_vote(4, 2), Consider::RejectFuture);
+
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys, 2).unwrap();
+		filter.update(GossipFilterCfg { start: 5, end: 10, validator_set: &validator_set });
+		assert!(filter.live_votes.is_empty());
+	}
+
+	struct TestContext;
+	impl<B: sp_runtime::traits::Block> ValidatorContext<B> for TestContext {
+		fn broadcast_topic(&mut self, _topic: B::Hash, _force: bool) {
+			todo!()
+		}
+
+		fn broadcast_message(&mut self, _topic: B::Hash, _message: Vec<u8>, _force: bool) {}
+
+		fn send_message(&mut self, _who: &sc_network::PeerId, _message: Vec<u8>) {
+			todo!()
+		}
+
+		fn send_topic(&mut self, _who: &sc_network::PeerId, _topic: B::Hash, _force: bool) {
+			todo!()
+		}
+	}
+
+	pub fn sign_commitment<BN: Encode>(who: &Keyring, commitment: &Commitment<BN>) -> Signature {
+		let store = MemoryKeystore::new();
+		store.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&who.to_seed())).unwrap();
+		let beefy_keystore: BeefyKeystore = Some(store.into()).into();
+		beefy_keystore.sign(&who.public(), &commitment.encode()).unwrap()
+	}
+
+	fn dummy_vote(block_number: u64) -> VoteMessage<u64, AuthorityId, Signature> {
+		let payload = Payload::from_single_entry(
+			known_payloads::MMR_ROOT_ID,
+			MmrRootHash::default().encode(),
+		);
+		let commitment = Commitment { payload, block_number, validator_set_id: 0 };
+		let signature = sign_commitment(&Keyring::Alice, &commitment);
+
+		VoteMessage { commitment, id: Keyring::Alice.public(), signature }
+	}
+
+	pub fn dummy_proof(
+		block_number: u64,
+		validator_set: &ValidatorSet<AuthorityId>,
+	) -> BeefyVersionedFinalityProof<Block> {
+		let payload = Payload::from_single_entry(
+			known_payloads::MMR_ROOT_ID,
+			MmrRootHash::default().encode(),
+		);
+		let commitment = Commitment { payload, block_number, validator_set_id: validator_set.id() };
+		let signatures = validator_set
+			.validators()
+			.iter()
+			.map(|validator: &AuthorityId| {
+				Some(sign_commitment(&Keyring::from_public(validator).unwrap(), &commitment))
+			})
+			.collect();
+
+		BeefyVersionedFinalityProof::<Block>::V1(SignedCommitment { commitment, signatures })
+	}
+
+	#[test]
+	fn should_validate_messages() {
+		let keys = vec![Keyring::Alice.public()];
+		let validator_set = ValidatorSet::<AuthorityId>::new(keys.clone(), 0).unwrap();
+		let (gv, mut report_stream) =
+			GossipValidator::<Block>::new(Arc::new(Mutex::new(KnownPeers::new())));
+		let sender = PeerId::random();
+		let mut context = TestContext;
+
+		// reject message, decoding error
+		let bad_encoding = b"0000000000".as_slice();
+		let expected_cost = ReputationChange::new(
+			(bad_encoding.len() as i32).saturating_mul(cost::PER_UNDECODABLE_BYTE),
+			"BEEFY: Bad packet",
+		);
+		let mut expected_report = PeerReport { who: sender, cost_benefit: expected_cost };
+		let res = gv.validate(&mut context, &sender, bad_encoding);
+		assert!(matches!(res, ValidationResult::Discard));
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		// verify votes validation
+
+		let vote = dummy_vote(3);
+		let encoded = GossipMessage::<Block>::Vote(vote.clone()).encode();
+
+		// filter not initialized
+		let res = gv.validate(&mut context, &sender, &encoded);
+		assert!(matches!(res, ValidationResult::Discard));
+		expected_report.cost_benefit = cost::OUT_OF_SCOPE_MESSAGE;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
+		// nothing in cache first time
+		let res = gv.validate(&mut context, &sender, &encoded);
+		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
+		expected_report.cost_benefit = benefit::VOTE_MESSAGE;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+		assert_eq!(
+			gv.gossip_filter
+				.read()
+				.live_votes
+				.get(&vote.commitment.block_number)
+				.map(|x| x.len()),
+			Some(1)
+		);
+
+		// second time we should hit the cache
+		let res = gv.validate(&mut context, &sender, &encoded);
+		assert!(matches!(res, ValidationResult::ProcessAndKeep(_)));
+		expected_report.cost_benefit = benefit::KNOWN_VOTE_MESSAGE;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		// 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 res = gv.validate(&mut context, &sender, &bad_vote);
+		assert!(matches!(res, ValidationResult::Discard));
+		expected_report.cost_benefit = cost::UNKNOWN_VOTER;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		// reject if the round is not GRANDPA finalized
+		gv.update_filter(GossipFilterCfg { start: 1, end: 2, validator_set: &validator_set });
+		let number = vote.commitment.block_number;
+		let set_id = vote.commitment.validator_set_id;
+		assert_eq!(gv.gossip_filter.read().consider_vote(number, set_id), Consider::RejectFuture);
+		let res = gv.validate(&mut context, &sender, &encoded);
+		assert!(matches!(res, ValidationResult::Discard));
+		expected_report.cost_benefit = cost::FUTURE_MESSAGE;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		// reject if the round is not live anymore
+		gv.update_filter(GossipFilterCfg { start: 7, end: 10, validator_set: &validator_set });
+		let number = vote.commitment.block_number;
+		let set_id = vote.commitment.validator_set_id;
+		assert_eq!(gv.gossip_filter.read().consider_vote(number, set_id), Consider::RejectPast);
+		let res = gv.validate(&mut context, &sender, &encoded);
+		assert!(matches!(res, ValidationResult::Discard));
+		expected_report.cost_benefit = cost::OUTDATED_MESSAGE;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		// now verify proofs validation
+
+		// reject old proof
+		let proof = dummy_proof(5, &validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
+		assert!(matches!(res, ValidationResult::Discard));
+		expected_report.cost_benefit = cost::OUTDATED_MESSAGE;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		// accept next proof with good set_id
+		let proof = dummy_proof(7, &validator_set);
+		let encoded_proof = GossipMessage::<Block>::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_recv().unwrap(), expected_report);
+
+		// accept future proof with good set_id
+		let proof = dummy_proof(20, &validator_set);
+		let encoded_proof = GossipMessage::<Block>::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_recv().unwrap(), expected_report);
+
+		// reject proof, future set_id
+		let bad_validator_set = ValidatorSet::<AuthorityId>::new(keys, 1).unwrap();
+		let proof = dummy_proof(20, &bad_validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
+		assert!(matches!(res, ValidationResult::Discard));
+		expected_report.cost_benefit = cost::FUTURE_MESSAGE;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+
+		// reject proof, bad signatures (Bob instead of Alice)
+		let bad_validator_set =
+			ValidatorSet::<AuthorityId>::new(vec![Keyring::Bob.public()], 0).unwrap();
+		let proof = dummy_proof(20, &bad_validator_set);
+		let encoded_proof = GossipMessage::<Block>::FinalityProof(proof).encode();
+		let res = gv.validate(&mut context, &sender, &encoded_proof);
+		assert!(matches!(res, ValidationResult::Discard));
+		expected_report.cost_benefit = cost::INVALID_PROOF;
+		expected_report.cost_benefit.value += cost::PER_SIGNATURE_CHECKED;
+		assert_eq!(report_stream.try_recv().unwrap(), expected_report);
+	}
+
+	#[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(Arc::new(Mutex::new(KnownPeers::new())));
+		gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
+		let sender = sc_network::PeerId::random();
+		let topic = Default::default();
+		let intent = MessageIntent::Broadcast;
+
+		// conclude 2
+		gv.update_filter(GossipFilterCfg { start: 2, end: 10, validator_set: &validator_set });
+		let mut allowed = gv.message_allowed();
+		let mut expired = gv.message_expired();
+
+		// check bad vote format
+		assert!(!allowed(&sender, intent, &topic, &mut [0u8; 16]));
+		assert!(expired(topic, &mut [0u8; 16]));
+
+		// inactive round 1 -> expired
+		let vote = dummy_vote(1);
+		let mut encoded_vote = GossipMessage::<Block>::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();
+		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();
+		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();
+		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 proof = dummy_proof(2, &bad_validator_set);
+		let mut encoded_proof = GossipMessage::<Block>::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();
+		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();
+		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();
+		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();
+		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();
+		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();
+		assert!(allowed(&sender, intent, &topic, &mut encoded_proof));
+		assert!(!expired(topic, &mut encoded_proof));
+	}
+
+	#[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(Arc::new(Mutex::new(KnownPeers::new())));
+		gv.update_filter(GossipFilterCfg { start: 0, end: 10, validator_set: &validator_set });
+		let sender = sc_network::PeerId::random();
+		let topic = Default::default();
+
+		let vote = dummy_vote(1);
+		let mut encoded_vote = vote.encode();
+
+		// re-broadcasting only allowed at `REBROADCAST_AFTER` intervals
+		let intent = MessageIntent::PeriodicRebroadcast;
+		let mut allowed = gv.message_allowed();
+
+		// rebroadcast not allowed so soon after GossipValidator creation
+		assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
+
+		// hack the inner deadline to be `now`
+		*gv.next_rebroadcast.lock() = Instant::now();
+
+		// still not allowed on old `allowed` closure result
+		assert!(!allowed(&sender, intent, &topic, &mut encoded_vote));
+
+		// renew closure result
+		let mut allowed = gv.message_allowed();
+		// rebroadcast should be allowed now
+		assert!(allowed(&sender, intent, &topic, &mut encoded_vote));
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/communication/mod.rs b/substrate/client/consensus/beefy/src/communication/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7f9535bfc23f1322fbe4995f596e83360c85fc68
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/communication/mod.rs
@@ -0,0 +1,145 @@
+// 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/>.
+
+//! Communication streams for the BEEFY networking protocols.
+
+pub mod notification;
+pub mod request_response;
+
+pub(crate) mod gossip;
+pub(crate) mod peers;
+
+pub(crate) mod beefy_protocol_name {
+	use array_bytes::bytes2hex;
+	use sc_network::ProtocolName;
+
+	/// BEEFY votes gossip protocol name suffix.
+	const GOSSIP_NAME: &str = "/beefy/2";
+	/// BEEFY justifications protocol name suffix.
+	const JUSTIFICATIONS_NAME: &str = "/beefy/justifications/1";
+
+	/// Name of the votes gossip protocol used by BEEFY.
+	///
+	/// Must be registered towards the networking in order for BEEFY voter to properly function.
+	pub fn gossip_protocol_name<Hash: AsRef<[u8]>>(
+		genesis_hash: Hash,
+		fork_id: Option<&str>,
+	) -> ProtocolName {
+		let genesis_hash = genesis_hash.as_ref();
+		if let Some(fork_id) = fork_id {
+			format!("/{}/{}{}", bytes2hex("", genesis_hash), fork_id, GOSSIP_NAME).into()
+		} else {
+			format!("/{}{}", bytes2hex("", genesis_hash), GOSSIP_NAME).into()
+		}
+	}
+
+	/// Name of the BEEFY justifications request-response protocol.
+	pub fn justifications_protocol_name<Hash: AsRef<[u8]>>(
+		genesis_hash: Hash,
+		fork_id: Option<&str>,
+	) -> ProtocolName {
+		let genesis_hash = genesis_hash.as_ref();
+		if let Some(fork_id) = fork_id {
+			format!("/{}/{}{}", bytes2hex("", genesis_hash), fork_id, JUSTIFICATIONS_NAME).into()
+		} else {
+			format!("/{}{}", bytes2hex("", genesis_hash), JUSTIFICATIONS_NAME).into()
+		}
+	}
+}
+
+/// Returns the configuration value to put in
+/// [`sc_network::config::FullNetworkConfiguration`].
+/// For standard protocol name see [`beefy_protocol_name::gossip_protocol_name`].
+pub fn beefy_peers_set_config(
+	gossip_protocol_name: sc_network::ProtocolName,
+) -> sc_network::config::NonDefaultSetConfig {
+	let mut cfg = sc_network::config::NonDefaultSetConfig::new(gossip_protocol_name, 1024 * 1024);
+	cfg.allow_non_reserved(25, 25);
+	cfg
+}
+
+// cost scalars for reporting peers.
+mod cost {
+	use sc_network::ReputationChange as Rep;
+	// Message that's for an outdated round.
+	pub(super) const OUTDATED_MESSAGE: Rep = Rep::new(-50, "BEEFY: Past message");
+	// Message that's from the future relative to our current set-id.
+	pub(super) const FUTURE_MESSAGE: Rep = Rep::new(-100, "BEEFY: Future message");
+	// Vote message containing bad signature.
+	pub(super) const BAD_SIGNATURE: Rep = Rep::new(-100, "BEEFY: Bad signature");
+	// Message received with vote from voter not in validator set.
+	pub(super) const UNKNOWN_VOTER: Rep = Rep::new(-150, "BEEFY: Unknown voter");
+	// A message received that cannot be evaluated relative to our current state.
+	pub(super) const OUT_OF_SCOPE_MESSAGE: Rep = Rep::new(-500, "BEEFY: Out-of-scope message");
+	// Message containing invalid proof.
+	pub(super) const INVALID_PROOF: Rep = Rep::new(-5000, "BEEFY: Invalid commit");
+	// Reputation cost per signature checked for invalid proof.
+	pub(super) const PER_SIGNATURE_CHECKED: i32 = -25;
+	// Reputation cost per byte for un-decodable message.
+	pub(super) const PER_UNDECODABLE_BYTE: i32 = -5;
+	// On-demand request was refused by peer.
+	pub(super) const REFUSAL_RESPONSE: Rep = Rep::new(-100, "BEEFY: Proof request refused");
+	// On-demand request for a proof that can't be found in the backend.
+	pub(super) const UNKOWN_PROOF_REQUEST: Rep = Rep::new(-150, "BEEFY: Unknown proof request");
+}
+
+// benefit scalars for reporting peers.
+mod benefit {
+	use sc_network::ReputationChange as Rep;
+	pub(super) const VOTE_MESSAGE: Rep = Rep::new(100, "BEEFY: Round vote message");
+	pub(super) const KNOWN_VOTE_MESSAGE: Rep = Rep::new(50, "BEEFY: Known vote");
+	pub(super) const VALIDATED_PROOF: Rep = Rep::new(100, "BEEFY: Justification");
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use sp_core::H256;
+
+	#[test]
+	fn beefy_protocols_names() {
+		use beefy_protocol_name::{gossip_protocol_name, justifications_protocol_name};
+		// Create protocol name using random genesis hash.
+		let genesis_hash = H256::random();
+		let genesis_hex = array_bytes::bytes2hex("", genesis_hash);
+
+		let expected_gossip_name = format!("/{}/beefy/2", genesis_hex);
+		let gossip_proto_name = gossip_protocol_name(&genesis_hash, None);
+		assert_eq!(gossip_proto_name.to_string(), expected_gossip_name);
+
+		let expected_justif_name = format!("/{}/beefy/justifications/1", genesis_hex);
+		let justif_proto_name = justifications_protocol_name(&genesis_hash, None);
+		assert_eq!(justif_proto_name.to_string(), expected_justif_name);
+
+		// Create protocol name using hardcoded genesis hash. Verify exact representation.
+		let genesis_hash = [
+			50, 4, 60, 123, 58, 106, 216, 246, 194, 188, 139, 193, 33, 212, 202, 171, 9, 55, 123,
+			94, 8, 43, 12, 251, 187, 57, 173, 19, 188, 74, 205, 147,
+		];
+		let genesis_hex = "32043c7b3a6ad8f6c2bc8bc121d4caab09377b5e082b0cfbbb39ad13bc4acd93";
+
+		let expected_gossip_name = format!("/{}/beefy/2", genesis_hex);
+		let gossip_proto_name = gossip_protocol_name(&genesis_hash, None);
+		assert_eq!(gossip_proto_name.to_string(), expected_gossip_name);
+
+		let expected_justif_name = format!("/{}/beefy/justifications/1", genesis_hex);
+		let justif_proto_name = justifications_protocol_name(&genesis_hash, None);
+		assert_eq!(justif_proto_name.to_string(), expected_justif_name);
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/communication/notification.rs b/substrate/client/consensus/beefy/src/communication/notification.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a4486e523c301f6b64af3936a5bdba3456303ad2
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/communication/notification.rs
@@ -0,0 +1,55 @@
+// 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 sc_utils::notification::{NotificationSender, NotificationStream, TracingKeyStr};
+use sp_runtime::traits::Block as BlockT;
+
+use crate::justification::BeefyVersionedFinalityProof;
+
+/// The sending half of the notifications channel(s) used to send
+/// notifications about best BEEFY block from the gadget side.
+pub type BeefyBestBlockSender<Block> = NotificationSender<<Block as BlockT>::Hash>;
+
+/// The receiving half of a notifications channel used to receive
+/// notifications about best BEEFY blocks determined on the gadget side.
+pub type BeefyBestBlockStream<Block> =
+	NotificationStream<<Block as BlockT>::Hash, BeefyBestBlockTracingKey>;
+
+/// 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>>;
+
+/// 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>;
+
+/// Provides tracing key for BEEFY best block stream.
+#[derive(Clone)]
+pub struct BeefyBestBlockTracingKey;
+impl TracingKeyStr for BeefyBestBlockTracingKey {
+	const TRACING_KEY: &'static str = "mpsc_beefy_best_block_notification_stream";
+}
+
+/// Provides tracing key for BEEFY versioned finality proof stream.
+#[derive(Clone)]
+pub struct BeefyVersionedFinalityProofTracingKey;
+impl TracingKeyStr for BeefyVersionedFinalityProofTracingKey {
+	const TRACING_KEY: &'static str = "mpsc_beefy_versioned_finality_proof_notification_stream";
+}
diff --git a/substrate/client/consensus/beefy/src/communication/peers.rs b/substrate/client/consensus/beefy/src/communication/peers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8f2d5cc90a1d927b21cb0a0b6de8efee5a0d3a59
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/communication/peers.rs
@@ -0,0 +1,127 @@
+// 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/>.
+
+//! Logic for keeping track of BEEFY peers.
+
+use sc_network::{PeerId, ReputationChange};
+use sp_runtime::traits::{Block, NumberFor, Zero};
+use std::collections::{HashMap, VecDeque};
+
+/// Report specifying a reputation change for a given peer.
+#[derive(Debug, PartialEq)]
+pub struct PeerReport {
+	pub who: PeerId,
+	pub cost_benefit: ReputationChange,
+}
+
+struct PeerData<B: Block> {
+	last_voted_on: NumberFor<B>,
+}
+
+impl<B: Block> Default for PeerData<B> {
+	fn default() -> Self {
+		PeerData { last_voted_on: Zero::zero() }
+	}
+}
+
+/// Keep a simple map of connected peers
+/// and the most recent voting round they participated in.
+pub struct KnownPeers<B: Block> {
+	live: HashMap<PeerId, PeerData<B>>,
+}
+
+impl<B: Block> KnownPeers<B> {
+	pub fn new() -> Self {
+		Self { live: HashMap::new() }
+	}
+
+	/// Note vote round number for `peer`.
+	pub fn note_vote_for(&mut self, peer: PeerId, round: NumberFor<B>) {
+		let data = self.live.entry(peer).or_default();
+		data.last_voted_on = round.max(data.last_voted_on);
+	}
+
+	/// Remove connected `peer`.
+	pub fn remove(&mut self, peer: &PeerId) {
+		self.live.remove(peer);
+	}
+
+	/// Return _filtered and cloned_ list of peers that have voted on higher than `block`.
+	pub fn further_than(&self, block: NumberFor<B>) -> VecDeque<PeerId> {
+		self.live
+			.iter()
+			.filter_map(|(k, v)| (v.last_voted_on > block).then_some(k))
+			.cloned()
+			.collect()
+	}
+
+	/// Answer whether `peer` is part of `KnownPeers` set.
+	pub fn contains(&self, peer: &PeerId) -> bool {
+		self.live.contains_key(peer)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_track_known_peers_progress() {
+		let (alice, bob, charlie) = (PeerId::random(), PeerId::random(), PeerId::random());
+		let mut peers = KnownPeers::<sc_network_test::Block>::new();
+		assert!(peers.live.is_empty());
+
+		// 'Tracked' Bob seen voting for 5.
+		peers.note_vote_for(bob, 5);
+		// Previously unseen Charlie now seen voting for 10.
+		peers.note_vote_for(charlie, 10);
+
+		assert_eq!(peers.live.len(), 2);
+		assert!(!peers.contains(&alice));
+		assert!(peers.contains(&bob));
+		assert!(peers.contains(&charlie));
+
+		// Get peers at block > 4
+		let further_than_4 = peers.further_than(4);
+		// Should be Bob and Charlie
+		assert_eq!(further_than_4.len(), 2);
+		assert!(further_than_4.contains(&bob));
+		assert!(further_than_4.contains(&charlie));
+
+		// 'Tracked' Alice seen voting for 10.
+		peers.note_vote_for(alice, 10);
+
+		// Get peers at block > 9
+		let further_than_9 = peers.further_than(9);
+		// Should be Charlie and Alice
+		assert_eq!(further_than_9.len(), 2);
+		assert!(further_than_9.contains(&charlie));
+		assert!(further_than_9.contains(&alice));
+
+		// Remove Alice
+		peers.remove(&alice);
+		assert_eq!(peers.live.len(), 2);
+		assert!(!peers.contains(&alice));
+
+		// Get peers at block >= 9
+		let further_than_9 = peers.further_than(9);
+		// Now should be just Charlie
+		assert_eq!(further_than_9.len(), 1);
+		assert!(further_than_9.contains(&charlie));
+	}
+}
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
new file mode 100644
index 0000000000000000000000000000000000000000..b8d8cd35434c97ac91a54c6fa73e57e6348f5ddd
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs
@@ -0,0 +1,222 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Helper for handling (i.e. answering) BEEFY justifications requests from a remote peer.
+
+use codec::DecodeAll;
+use futures::{channel::oneshot, StreamExt};
+use log::{debug, trace};
+use sc_client_api::BlockBackend;
+use sc_network::{
+	config as netconfig, config::RequestResponseConfig, types::ProtocolName, PeerId,
+	ReputationChange,
+};
+use sp_consensus_beefy::BEEFY_ENGINE_ID;
+use sp_runtime::traits::Block;
+use std::{marker::PhantomData, sync::Arc};
+
+use crate::{
+	communication::{
+		cost,
+		request_response::{
+			on_demand_justifications_protocol_config, Error, JustificationRequest,
+			BEEFY_SYNC_LOG_TARGET,
+		},
+	},
+	metric_inc,
+	metrics::{register_metrics, OnDemandIncomingRequestsMetrics},
+};
+
+/// A request coming in, including a sender for sending responses.
+#[derive(Debug)]
+pub(crate) struct IncomingRequest<B: Block> {
+	/// `PeerId` of sending peer.
+	pub peer: PeerId,
+	/// The sent request.
+	pub payload: JustificationRequest<B>,
+	/// Sender for sending response back.
+	pub pending_response: oneshot::Sender<netconfig::OutgoingResponse>,
+}
+
+impl<B: Block> IncomingRequest<B> {
+	/// Create new `IncomingRequest`.
+	pub fn new(
+		peer: PeerId,
+		payload: JustificationRequest<B>,
+		pending_response: oneshot::Sender<netconfig::OutgoingResponse>,
+	) -> Self {
+		Self { peer, payload, pending_response }
+	}
+
+	/// Try building from raw network request.
+	///
+	/// This function will fail if the request cannot be decoded and will apply passed in
+	/// reputation changes in that case.
+	///
+	/// Params:
+	/// 	- The raw request to decode
+	/// 	- Reputation changes to apply for the peer in case decoding fails.
+	pub fn try_from_raw<F>(
+		raw: netconfig::IncomingRequest,
+		reputation_changes_on_err: F,
+	) -> Result<Self, Error>
+	where
+		F: FnOnce(usize) -> Vec<ReputationChange>,
+	{
+		let netconfig::IncomingRequest { payload, peer, pending_response } = raw;
+		let payload = match JustificationRequest::decode_all(&mut payload.as_ref()) {
+			Ok(payload) => payload,
+			Err(err) => {
+				let response = netconfig::OutgoingResponse {
+					result: Err(()),
+					reputation_changes: reputation_changes_on_err(payload.len()),
+					sent_feedback: None,
+				};
+				if let Err(_) = pending_response.send(response) {
+					return Err(Error::DecodingErrorNoReputationChange(peer, err))
+				}
+				return Err(Error::DecodingError(peer, err))
+			},
+		};
+		Ok(Self::new(peer, payload, pending_response))
+	}
+}
+
+/// Receiver for incoming BEEFY justifications requests.
+///
+/// Takes care of decoding and handling of invalid encoded requests.
+pub(crate) struct IncomingRequestReceiver {
+	raw: async_channel::Receiver<netconfig::IncomingRequest>,
+}
+
+impl IncomingRequestReceiver {
+	pub fn new(inner: async_channel::Receiver<netconfig::IncomingRequest>) -> Self {
+		Self { raw: inner }
+	}
+
+	/// Try to receive the next incoming request.
+	///
+	/// Any received request will be decoded, on decoding errors the provided reputation changes
+	/// will be applied and an error will be reported.
+	pub async fn recv<B, F>(&mut self, reputation_changes: F) -> Result<IncomingRequest<B>, Error>
+	where
+		B: Block,
+		F: FnOnce(usize) -> Vec<ReputationChange>,
+	{
+		let req = match self.raw.next().await {
+			None => return Err(Error::RequestChannelExhausted),
+			Some(raw) => IncomingRequest::<B>::try_from_raw(raw, reputation_changes)?,
+		};
+		Ok(req)
+	}
+}
+
+/// Handler for incoming BEEFY justifications requests from a remote peer.
+pub struct BeefyJustifsRequestHandler<B, Client> {
+	pub(crate) request_receiver: IncomingRequestReceiver,
+	pub(crate) justif_protocol_name: ProtocolName,
+	pub(crate) client: Arc<Client>,
+	pub(crate) metrics: Option<OnDemandIncomingRequestsMetrics>,
+	pub(crate) _block: PhantomData<B>,
+}
+
+impl<B, Client> BeefyJustifsRequestHandler<B, Client>
+where
+	B: Block,
+	Client: BlockBackend<B> + Send + Sync,
+{
+	/// Create a new [`BeefyJustifsRequestHandler`].
+	pub fn new<Hash: AsRef<[u8]>>(
+		genesis_hash: Hash,
+		fork_id: Option<&str>,
+		client: Arc<Client>,
+		prometheus_registry: Option<prometheus::Registry>,
+	) -> (Self, RequestResponseConfig) {
+		let (request_receiver, config) =
+			on_demand_justifications_protocol_config(genesis_hash, fork_id);
+		let justif_protocol_name = config.name.clone();
+		let metrics = register_metrics(prometheus_registry);
+		(
+			Self { request_receiver, justif_protocol_name, client, metrics, _block: PhantomData },
+			config,
+		)
+	}
+
+	/// Network request-response protocol name used by this handler.
+	pub fn protocol_name(&self) -> ProtocolName {
+		self.justif_protocol_name.clone()
+	}
+
+	// Sends back justification response if justification found in client backend.
+	fn handle_request(&self, request: IncomingRequest<B>) -> Result<(), Error> {
+		let mut reputation_changes = vec![];
+		let maybe_encoded_proof = self
+			.client
+			.block_hash(request.payload.begin)
+			.ok()
+			.flatten()
+			.and_then(|hash| self.client.justifications(hash).ok().flatten())
+			.and_then(|justifs| justifs.get(BEEFY_ENGINE_ID).cloned())
+			.ok_or_else(|| reputation_changes.push(cost::UNKOWN_PROOF_REQUEST));
+		request
+			.pending_response
+			.send(netconfig::OutgoingResponse {
+				result: maybe_encoded_proof,
+				reputation_changes,
+				sent_feedback: None,
+			})
+			.map_err(|_| Error::SendResponse)
+	}
+
+	/// Run [`BeefyJustifsRequestHandler`].
+	///
+	/// Should never end, returns `Error` otherwise.
+	pub async fn run(&mut self) -> Error {
+		trace!(target: BEEFY_SYNC_LOG_TARGET, "🥩 Running BeefyJustifsRequestHandler");
+
+		while let Ok(request) = self
+			.request_receiver
+			.recv(|bytes| {
+				let bytes = bytes.min(i32::MAX as usize) as i32;
+				vec![ReputationChange::new(
+					bytes.saturating_mul(cost::PER_UNDECODABLE_BYTE),
+					"BEEFY: Bad request payload",
+				)]
+			})
+			.await
+		{
+			let peer = request.peer;
+			match self.handle_request(request) {
+				Ok(()) => {
+					metric_inc!(self, beefy_successful_justification_responses);
+					debug!(
+						target: BEEFY_SYNC_LOG_TARGET,
+						"🥩 Handled BEEFY justification request from {:?}.", peer
+					)
+				},
+				Err(e) => {
+					// peer reputation changes already applied in `self.handle_request()`
+					metric_inc!(self, beefy_failed_justification_responses);
+					debug!(
+						target: BEEFY_SYNC_LOG_TARGET,
+						"🥩 Failed to handle BEEFY justification request from {:?}: {}", peer, e,
+					)
+				},
+			}
+		}
+		Error::RequestsReceiverStreamClosed
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/communication/request_response/mod.rs b/substrate/client/consensus/beefy/src/communication/request_response/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4bad3b061c8e9e67d61685e8f59f24bf983faa83
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/communication/request_response/mod.rs
@@ -0,0 +1,108 @@
+// 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/>.
+
+//! Request/response protocol for syncing BEEFY justifications.
+
+mod incoming_requests_handler;
+pub(crate) mod outgoing_requests_engine;
+
+pub use incoming_requests_handler::BeefyJustifsRequestHandler;
+
+use std::time::Duration;
+
+use codec::{Decode, Encode, Error as CodecError};
+use sc_network::{config::RequestResponseConfig, PeerId};
+use sp_runtime::traits::{Block, NumberFor};
+
+use crate::communication::{beefy_protocol_name::justifications_protocol_name, peers::PeerReport};
+use incoming_requests_handler::IncomingRequestReceiver;
+
+// 10 seems reasonable, considering justifs are explicitly requested only
+// for mandatory blocks, by nodes that are syncing/catching-up.
+const JUSTIF_CHANNEL_SIZE: usize = 10;
+
+const MAX_RESPONSE_SIZE: u64 = 1024 * 1024;
+const JUSTIF_REQUEST_TIMEOUT: Duration = Duration::from_secs(3);
+
+const BEEFY_SYNC_LOG_TARGET: &str = "beefy::sync";
+
+/// Get the configuration for the BEEFY justifications Request/response protocol.
+///
+/// Returns a receiver for messages received on this protocol and the requested
+/// `ProtocolConfig`.
+///
+/// Consider using [`BeefyJustifsRequestHandler`] instead of this low-level function.
+pub(crate) fn on_demand_justifications_protocol_config<Hash: AsRef<[u8]>>(
+	genesis_hash: Hash,
+	fork_id: Option<&str>,
+) -> (IncomingRequestReceiver, RequestResponseConfig) {
+	let name = justifications_protocol_name(genesis_hash, fork_id);
+	let fallback_names = vec![];
+	let (tx, rx) = async_channel::bounded(JUSTIF_CHANNEL_SIZE);
+	let rx = IncomingRequestReceiver::new(rx);
+	let cfg = RequestResponseConfig {
+		name,
+		fallback_names,
+		max_request_size: 32,
+		max_response_size: MAX_RESPONSE_SIZE,
+		// We are connected to all validators:
+		request_timeout: JUSTIF_REQUEST_TIMEOUT,
+		inbound_queue: Some(tx),
+	};
+	(rx, cfg)
+}
+
+/// BEEFY justification request.
+#[derive(Debug, Clone, Encode, Decode)]
+pub struct JustificationRequest<B: Block> {
+	/// Start collecting proofs from this block.
+	pub begin: NumberFor<B>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+
+	#[error(transparent)]
+	RuntimeApi(#[from] sp_api::ApiError),
+
+	/// Decoding failed, we were able to change the peer's reputation accordingly.
+	#[error("Decoding request failed for peer {0}.")]
+	DecodingError(PeerId, #[source] CodecError),
+
+	/// Decoding failed, but sending reputation change failed.
+	#[error("Decoding request failed for peer {0}, and changing reputation failed.")]
+	DecodingErrorNoReputationChange(PeerId, #[source] CodecError),
+
+	/// Incoming request stream exhausted. Should only happen on shutdown.
+	#[error("Incoming request channel got closed.")]
+	RequestChannelExhausted,
+
+	#[error("Failed to send response.")]
+	SendResponse,
+
+	#[error("Received invalid response.")]
+	InvalidResponse(PeerReport),
+
+	#[error("Internal error while getting response.")]
+	ResponseError,
+
+	#[error("On-demand requests receiver stream terminated.")]
+	RequestsReceiverStreamClosed,
+}
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
new file mode 100644
index 0000000000000000000000000000000000000000..ef462a54fca5b8c656b601a9296346cb1532433c
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.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/>.
+
+//! Generating request logic for request/response protocol for syncing BEEFY justifications.
+
+use codec::Encode;
+use futures::channel::{oneshot, oneshot::Canceled};
+use log::{debug, warn};
+use parking_lot::Mutex;
+use sc_network::{
+	request_responses::{IfDisconnected, RequestFailure},
+	NetworkRequest, PeerId, ProtocolName,
+};
+use sp_consensus_beefy::{ecdsa_crypto::AuthorityId, ValidatorSet};
+use sp_runtime::traits::{Block, NumberFor};
+use std::{collections::VecDeque, result::Result, sync::Arc};
+
+use crate::{
+	communication::{
+		benefit, cost,
+		peers::PeerReport,
+		request_response::{Error, JustificationRequest, BEEFY_SYNC_LOG_TARGET},
+	},
+	justification::{decode_and_verify_finality_proof, BeefyVersionedFinalityProof},
+	metric_inc,
+	metrics::{register_metrics, OnDemandOutgoingRequestsMetrics},
+	KnownPeers,
+};
+
+/// Response type received from network.
+type Response = Result<Vec<u8>, RequestFailure>;
+/// Used to receive a response from the network.
+type ResponseReceiver = oneshot::Receiver<Response>;
+
+#[derive(Clone, Debug)]
+struct RequestInfo<B: Block> {
+	block: NumberFor<B>,
+	active_set: ValidatorSet<AuthorityId>,
+}
+
+enum State<B: Block> {
+	Idle,
+	AwaitingResponse(PeerId, RequestInfo<B>, ResponseReceiver),
+}
+
+/// Possible engine responses.
+pub(crate) enum ResponseInfo<B: Block> {
+	/// No peer response available yet.
+	Pending,
+	/// Valid justification provided alongside peer reputation changes.
+	ValidProof(BeefyVersionedFinalityProof<B>, PeerReport),
+	/// No justification yet, only peer reputation changes.
+	PeerReport(PeerReport),
+}
+
+pub struct OnDemandJustificationsEngine<B: Block> {
+	network: Arc<dyn NetworkRequest + Send + Sync>,
+	protocol_name: ProtocolName,
+
+	live_peers: Arc<Mutex<KnownPeers<B>>>,
+	peers_cache: VecDeque<PeerId>,
+
+	state: State<B>,
+	metrics: Option<OnDemandOutgoingRequestsMetrics>,
+}
+
+impl<B: Block> OnDemandJustificationsEngine<B> {
+	pub fn new(
+		network: Arc<dyn NetworkRequest + Send + Sync>,
+		protocol_name: ProtocolName,
+		live_peers: Arc<Mutex<KnownPeers<B>>>,
+		prometheus_registry: Option<prometheus::Registry>,
+	) -> Self {
+		let metrics = register_metrics(prometheus_registry);
+		Self {
+			network,
+			protocol_name,
+			live_peers,
+			peers_cache: VecDeque::new(),
+			state: State::Idle,
+			metrics,
+		}
+	}
+
+	fn reset_peers_cache_for_block(&mut self, block: NumberFor<B>) {
+		self.peers_cache = self.live_peers.lock().further_than(block);
+	}
+
+	fn try_next_peer(&mut self) -> Option<PeerId> {
+		let live = self.live_peers.lock();
+		while let Some(peer) = self.peers_cache.pop_front() {
+			if live.contains(&peer) {
+				return Some(peer)
+			}
+		}
+		None
+	}
+
+	fn request_from_peer(&mut self, peer: PeerId, req_info: RequestInfo<B>) {
+		debug!(
+			target: BEEFY_SYNC_LOG_TARGET,
+			"🥩 requesting justif #{:?} from peer {:?}", req_info.block, peer,
+		);
+
+		let payload = JustificationRequest::<B> { begin: req_info.block }.encode();
+
+		let (tx, rx) = oneshot::channel();
+
+		self.network.start_request(
+			peer,
+			self.protocol_name.clone(),
+			payload,
+			tx,
+			IfDisconnected::ImmediateError,
+		);
+
+		self.state = State::AwaitingResponse(peer, req_info, rx);
+	}
+
+	/// Start new justification request for `block`, if no other request is in progress.
+	///
+	/// `active_set` will be used to verify validity of potential responses.
+	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
+		}
+		self.reset_peers_cache_for_block(block);
+
+		// Start the requests engine - each unsuccessful received response will automatically
+		// trigger a new request to the next peer in the `peers_cache` until there are none left.
+		if let Some(peer) = self.try_next_peer() {
+			self.request_from_peer(peer, RequestInfo { block, active_set });
+		} else {
+			metric_inc!(self, beefy_on_demand_justification_no_peer_to_request_from);
+			debug!(
+				target: BEEFY_SYNC_LOG_TARGET,
+				"🥩 no good peers to request justif #{:?} from", block
+			);
+		}
+	}
+
+	/// Cancel any pending request for block numbers smaller or equal to `block`.
+	pub fn cancel_requests_older_than(&mut self, block: NumberFor<B>) {
+		match &self.state {
+			State::AwaitingResponse(_, req_info, _) if req_info.block <= block => {
+				debug!(
+					target: BEEFY_SYNC_LOG_TARGET,
+					"🥩 cancel pending request for justification #{:?}", req_info.block
+				);
+				self.state = State::Idle;
+			},
+			_ => (),
+		}
+	}
+
+	fn process_response(
+		&mut self,
+		peer: &PeerId,
+		req_info: &RequestInfo<B>,
+		response: Result<Response, Canceled>,
+	) -> Result<BeefyVersionedFinalityProof<B>, Error> {
+		response
+			.map_err(|e| {
+				debug!(
+					target: BEEFY_SYNC_LOG_TARGET,
+					"🥩 on-demand sc-network channel sender closed, err: {:?}", e
+				);
+				Error::ResponseError
+			})?
+			.map_err(|e| {
+				debug!(
+					target: BEEFY_SYNC_LOG_TARGET,
+					"🥩 for on demand justification #{:?}, peer {:?} error: {:?}",
+					req_info.block,
+					peer,
+					e
+				);
+				match e {
+					RequestFailure::Refused => {
+						metric_inc!(self, beefy_on_demand_justification_peer_refused);
+						let peer_report =
+							PeerReport { who: *peer, cost_benefit: cost::REFUSAL_RESPONSE };
+						Error::InvalidResponse(peer_report)
+					},
+					_ => {
+						metric_inc!(self, beefy_on_demand_justification_peer_error);
+						Error::ResponseError
+					},
+				}
+			})
+			.and_then(|encoded| {
+				decode_and_verify_finality_proof::<B>(
+					&encoded[..],
+					req_info.block,
+					&req_info.active_set,
+				)
+				.map_err(|(err, signatures_checked)| {
+					metric_inc!(self, beefy_on_demand_justification_invalid_proof);
+					debug!(
+						target: BEEFY_SYNC_LOG_TARGET,
+						"🥩 for on demand justification #{:?}, peer {:?} responded with invalid proof: {:?}",
+						req_info.block, peer, err
+					);
+					let mut cost = cost::INVALID_PROOF;
+					cost.value +=
+						cost::PER_SIGNATURE_CHECKED.saturating_mul(signatures_checked as i32);
+					Error::InvalidResponse(PeerReport { who: *peer, cost_benefit: cost })
+				})
+			})
+	}
+
+	pub(crate) async fn next(&mut self) -> ResponseInfo<B> {
+		let (peer, req_info, resp) = match &mut self.state {
+			State::Idle => {
+				futures::future::pending::<()>().await;
+				return ResponseInfo::Pending
+			},
+			State::AwaitingResponse(peer, req_info, receiver) => {
+				let resp = receiver.await;
+				(*peer, req_info.clone(), resp)
+			},
+		};
+		// We received the awaited response. Our 'receiver' will never generate any other response,
+		// meaning we're done with current state. Move the engine to `State::Idle`.
+		self.state = State::Idle;
+
+		let block = req_info.block;
+		match self.process_response(&peer, &req_info, resp) {
+			Err(err) => {
+				// No valid justification received, try next peer in our set.
+				if let Some(peer) = self.try_next_peer() {
+					self.request_from_peer(peer, req_info);
+				} else {
+					warn!(
+						target: BEEFY_SYNC_LOG_TARGET,
+						"🥩 ran out of peers to request justif #{:?} from", block
+					);
+				}
+				// Report peer based on error type.
+				if let Error::InvalidResponse(peer_report) = err {
+					ResponseInfo::PeerReport(peer_report)
+				} else {
+					ResponseInfo::Pending
+				}
+			},
+			Ok(proof) => {
+				metric_inc!(self, beefy_on_demand_justification_good_proof);
+				debug!(
+					target: BEEFY_SYNC_LOG_TARGET,
+					"🥩 received valid on-demand justif #{:?} from {:?}", block, peer
+				);
+				let peer_report = PeerReport { who: peer, cost_benefit: benefit::VALIDATED_PROOF };
+				ResponseInfo::ValidProof(proof, peer_report)
+			},
+		}
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/error.rs b/substrate/client/consensus/beefy/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b4773f940193e07d4f6f6962b69096c91805bbeb
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/error.rs
@@ -0,0 +1,64 @@
+// 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/>.
+
+//! BEEFY gadget specific errors
+//!
+//! Used for BEEFY gadget internal error handling only
+
+use std::fmt::Debug;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	#[error("Backend: {0}")]
+	Backend(String),
+	#[error("Keystore error: {0}")]
+	Keystore(String),
+	#[error("Runtime api error: {0}")]
+	RuntimeApi(sp_api::ApiError),
+	#[error("Signature error: {0}")]
+	Signature(String),
+	#[error("Session uninitialized")]
+	UninitSession,
+	#[error("pallet-beefy was reset")]
+	ConsensusReset,
+	#[error("Block import stream terminated")]
+	BlockImportStreamTerminated,
+	#[error("Gossip Engine terminated")]
+	GossipEngineTerminated,
+	#[error("Finality proofs gossiping stream terminated")]
+	FinalityProofGossipStreamTerminated,
+	#[error("Finality stream terminated")]
+	FinalityStreamTerminated,
+	#[error("Votes gossiping stream terminated")]
+	VotesGossipStreamTerminated,
+}
+
+#[cfg(test)]
+impl PartialEq for Error {
+	fn eq(&self, other: &Self) -> bool {
+		match (self, other) {
+			(Error::Backend(s1), Error::Backend(s2)) => s1 == s2,
+			(Error::Keystore(s1), Error::Keystore(s2)) => s1 == s2,
+			(Error::RuntimeApi(_), Error::RuntimeApi(_)) => true,
+			(Error::Signature(s1), Error::Signature(s2)) => s1 == s2,
+			(Error::UninitSession, Error::UninitSession) => true,
+			(Error::ConsensusReset, Error::ConsensusReset) => true,
+			_ => false,
+		}
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/import.rs b/substrate/client/consensus/beefy/src/import.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5b2abb20acede2764502bfadb1948550c5c7a8b2
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/import.rs
@@ -0,0 +1,183 @@
+// 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 std::sync::Arc;
+
+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_runtime::{
+	traits::{Block as BlockT, Header as HeaderT, NumberFor},
+	EncodedJustification,
+};
+
+use sc_client_api::backend::Backend;
+use sc_consensus::{BlockCheckParams, BlockImport, BlockImportParams, ImportResult};
+
+use crate::{
+	communication::notification::BeefyVersionedFinalityProofSender,
+	justification::{decode_and_verify_finality_proof, BeefyVersionedFinalityProof},
+	metric_inc,
+	metrics::BlockImportMetrics,
+	LOG_TARGET,
+};
+
+/// A block-import handler for BEEFY.
+///
+/// This scans each imported block for BEEFY justifications and verifies them.
+/// 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> {
+	backend: Arc<Backend>,
+	runtime: Arc<RuntimeApi>,
+	inner: I,
+	justification_sender: BeefyVersionedFinalityProofSender<Block>,
+	metrics: Option<BlockImportMetrics>,
+}
+
+impl<Block: BlockT, BE, Runtime, I: Clone> Clone for BeefyBlockImport<Block, BE, Runtime, I> {
+	fn clone(&self) -> Self {
+		BeefyBlockImport {
+			backend: self.backend.clone(),
+			runtime: self.runtime.clone(),
+			inner: self.inner.clone(),
+			justification_sender: self.justification_sender.clone(),
+			metrics: self.metrics.clone(),
+		}
+	}
+}
+
+impl<Block: BlockT, BE, Runtime, I> BeefyBlockImport<Block, BE, Runtime, I> {
+	/// Create a new BeefyBlockImport.
+	pub fn new(
+		backend: Arc<BE>,
+		runtime: Arc<Runtime>,
+		inner: I,
+		justification_sender: BeefyVersionedFinalityProofSender<Block>,
+		metrics: Option<BlockImportMetrics>,
+	) -> BeefyBlockImport<Block, BE, Runtime, I> {
+		BeefyBlockImport { backend, runtime, inner, justification_sender, metrics }
+	}
+}
+
+impl<Block, BE, Runtime, I> BeefyBlockImport<Block, BE, Runtime, I>
+where
+	Block: BlockT,
+	BE: Backend<Block>,
+	Runtime: ProvideRuntimeApi<Block>,
+	Runtime::Api: BeefyApi<Block, AuthorityId> + Send,
+{
+	fn decode_and_verify(
+		&self,
+		encoded: &EncodedJustification,
+		number: NumberFor<Block>,
+		hash: <Block as BlockT>::Hash,
+	) -> Result<BeefyVersionedFinalityProof<Block>, ConsensusError> {
+		use ConsensusError::ClientImport as ImportError;
+		let beefy_genesis = self
+			.runtime
+			.runtime_api()
+			.beefy_genesis(hash)
+			.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()))
+		}
+		let validator_set = self
+			.runtime
+			.runtime_api()
+			.validator_set(hash)
+			.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)
+			.map_err(|(err, _)| err)
+	}
+}
+
+#[async_trait::async_trait]
+impl<Block, BE, Runtime, I> BlockImport<Block> for BeefyBlockImport<Block, BE, Runtime, I>
+where
+	Block: BlockT,
+	BE: Backend<Block>,
+	I: BlockImport<Block, Error = ConsensusError> + Send + Sync,
+	Runtime: ProvideRuntimeApi<Block> + Send + Sync,
+	Runtime::Api: BeefyApi<Block, AuthorityId>,
+{
+	type Error = ConsensusError;
+
+	async fn import_block(
+		&mut self,
+		mut block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		let hash = block.post_hash();
+		let number = *block.header.number();
+
+		let beefy_encoded = block.justifications.as_mut().and_then(|just| {
+			let encoded = just.get(BEEFY_ENGINE_ID).cloned();
+			// Remove BEEFY justification from the list before giving to `inner`; we send it to the
+			// voter (beefy-gadget) and it will append it to the backend after block is finalized.
+			just.remove(BEEFY_ENGINE_ID);
+			encoded
+		});
+
+		// Run inner block import.
+		let inner_import_result = self.inner.import_block(block).await?;
+
+		match (beefy_encoded, &inner_import_result) {
+			(Some(encoded), ImportResult::Imported(_)) => {
+				match self.decode_and_verify(&encoded, number, hash) {
+					Ok(proof) => {
+						// The proof is valid and the block is imported and final, we can import.
+						debug!(
+							target: LOG_TARGET,
+							"🥩 import justif {:?} for block number {:?}.", proof, number
+						);
+						// Send the justification to the BEEFY voter for processing.
+						self.justification_sender
+							.notify(|| Ok::<_, ()>(proof))
+							.expect("the closure always returns Ok; qed.");
+						metric_inc!(self, beefy_good_justification_imports);
+					},
+					Err(err) => {
+						debug!(
+							target: LOG_TARGET,
+							"🥩 error importing BEEFY justification for block {:?}: {:?}",
+							number,
+							err,
+						);
+						metric_inc!(self, beefy_bad_justification_imports);
+					},
+				}
+			},
+			_ => (),
+		}
+
+		Ok(inner_import_result)
+	}
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.inner.check_block(block).await
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/justification.rs b/substrate/client/consensus/beefy/src/justification.rs
new file mode 100644
index 0000000000000000000000000000000000000000..483184e2374a2b9239554e4ce2709cd7a294cb8c
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/justification.rs
@@ -0,0 +1,200 @@
+// 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::keystore::BeefyKeystore;
+use codec::{DecodeAll, Encode};
+use sp_consensus::Error as ConsensusError;
+use sp_consensus_beefy::{
+	ecdsa_crypto::{AuthorityId, Signature},
+	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(crate) fn proof_block_num_and_set_id<Block: BlockT>(
+	proof: &BeefyVersionedFinalityProof<Block>,
+) -> (NumberFor<Block>, ValidatorSetId) {
+	match proof {
+		VersionedFinalityProof::V1(sc) =>
+			(sc.commitment.block_number, sc.commitment.validator_set_id),
+	}
+}
+
+/// Decode and verify a Beefy FinalityProof.
+pub(crate) fn decode_and_verify_finality_proof<Block: BlockT>(
+	encoded: &[u8],
+	target_number: NumberFor<Block>,
+	validator_set: &ValidatorSet<AuthorityId>,
+) -> Result<BeefyVersionedFinalityProof<Block>, (ConsensusError, u32)> {
+	let proof = <BeefyVersionedFinalityProof<Block>>::decode_all(&mut &*encoded)
+		.map_err(|_| (ConsensusError::InvalidJustification, 0))?;
+	verify_with_validator_set::<Block>(target_number, validator_set, &proof).map(|_| proof)
+}
+
+/// Verify the Beefy finality proof against the validator set at the block it was generated.
+pub(crate) fn verify_with_validator_set<Block: BlockT>(
+	target_number: NumberFor<Block>,
+	validator_set: &ValidatorSet<AuthorityId>,
+	proof: &BeefyVersionedFinalityProof<Block>,
+) -> Result<(), (ConsensusError, u32)> {
+	let mut signatures_checked = 0u32;
+	match proof {
+		VersionedFinalityProof::V1(signed_commitment) => {
+			if signed_commitment.signatures.len() != validator_set.len() ||
+				signed_commitment.commitment.validator_set_id != validator_set.id() ||
+				signed_commitment.commitment.block_number != target_number
+			{
+				return Err((ConsensusError::InvalidJustification, 0))
+			}
+
+			// Arrangement of signatures in the commitment should be in the same order
+			// as validators for that set.
+			let message = signed_commitment.commitment.encode();
+			let valid_signatures = validator_set
+				.validators()
+				.into_iter()
+				.zip(signed_commitment.signatures.iter())
+				.filter(|(id, signature)| {
+					signature
+						.as_ref()
+						.map(|sig| {
+							signatures_checked += 1;
+							BeefyKeystore::verify(id, sig, &message[..])
+						})
+						.unwrap_or(false)
+				})
+				.count();
+			if valid_signatures >= crate::round::threshold(validator_set.len()) {
+				Ok(())
+			} else {
+				Err((ConsensusError::InvalidJustification, signatures_checked))
+			}
+		},
+	}
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use sp_consensus_beefy::{
+		known_payloads, Commitment, Keyring, Payload, SignedCommitment, VersionedFinalityProof,
+	};
+	use substrate_test_runtime_client::runtime::Block;
+
+	use super::*;
+	use crate::tests::make_beefy_ids;
+
+	pub(crate) fn new_finality_proof(
+		block_num: NumberFor<Block>,
+		validator_set: &ValidatorSet<AuthorityId>,
+		keys: &[Keyring],
+	) -> BeefyVersionedFinalityProof<Block> {
+		let commitment = Commitment {
+			payload: Payload::from_single_entry(known_payloads::MMR_ROOT_ID, vec![]),
+			block_number: block_num,
+			validator_set_id: validator_set.id(),
+		};
+		let message = commitment.encode();
+		let signatures = keys.iter().map(|key| Some(key.sign(&message))).collect();
+		VersionedFinalityProof::V1(SignedCommitment { commitment, signatures })
+	}
+
+	#[test]
+	fn should_verify_with_validator_set() {
+		let keys = &[Keyring::Alice, Keyring::Bob, Keyring::Charlie];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+
+		// build valid justification
+		let block_num = 42;
+		let proof = new_finality_proof(block_num, &validator_set, keys);
+
+		let good_proof = proof.clone().into();
+		// should verify successfully
+		verify_with_validator_set::<Block>(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) {
+			Err((ConsensusError::InvalidJustification, 0)) => (),
+			e => assert!(false, "Got unexpected {:?}", e),
+		};
+
+		// 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) {
+			Err((ConsensusError::InvalidJustification, 0)) => (),
+			e => assert!(false, "Got unexpected {:?}", e),
+		};
+
+		// wrong signatures length -> should fail verification
+		let mut bad_proof = proof.clone();
+		// change length of signatures
+		let bad_signed_commitment = match bad_proof {
+			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()) {
+			Err((ConsensusError::InvalidJustification, 0)) => (),
+			e => assert!(false, "Got unexpected {:?}", e),
+		};
+
+		// not enough signatures -> should fail verification
+		let mut bad_proof = proof.clone();
+		let bad_signed_commitment = match bad_proof {
+			VersionedFinalityProof::V1(ref mut sc) => sc,
+		};
+		// 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()) {
+			Err((ConsensusError::InvalidJustification, 2)) => (),
+			e => assert!(false, "Got unexpected {:?}", e),
+		};
+
+		// not enough _correct_ signatures -> should fail verification
+		let mut bad_proof = proof.clone();
+		let bad_signed_commitment = match bad_proof {
+			VersionedFinalityProof::V1(ref mut sc) => sc,
+		};
+		// change a signature to a different key
+		*bad_signed_commitment.signatures.first_mut().unwrap() =
+			Some(Keyring::Dave.sign(&bad_signed_commitment.commitment.encode()));
+		match verify_with_validator_set::<Block>(block_num, &validator_set, &bad_proof.into()) {
+			Err((ConsensusError::InvalidJustification, 3)) => (),
+			e => assert!(false, "Got unexpected {:?}", e),
+		};
+	}
+
+	#[test]
+	fn should_decode_and_verify_finality_proof() {
+		let keys = &[Keyring::Alice, Keyring::Bob];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+		let block_num = 1;
+
+		// build valid justification
+		let proof = new_finality_proof(block_num, &validator_set, keys);
+		let versioned_proof: BeefyVersionedFinalityProof<Block> = 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();
+		assert_eq!(verified, versioned_proof);
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/keystore.rs b/substrate/client/consensus/beefy/src/keystore.rs
new file mode 100644
index 0000000000000000000000000000000000000000..925bb08828220fa6720f222e71979721c26ffc62
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/keystore.rs
@@ -0,0 +1,343 @@
+// 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 sp_application_crypto::{key_types::BEEFY as BEEFY_KEY_TYPE, RuntimeAppPublic};
+use sp_core::keccak_256;
+use sp_keystore::KeystorePtr;
+
+use log::warn;
+
+use sp_consensus_beefy::{
+	ecdsa_crypto::{Public, Signature},
+	BeefyAuthorityId,
+};
+
+use crate::{error, LOG_TARGET};
+
+/// Hasher used for BEEFY signatures.
+pub(crate) type BeefySignatureHasher = sp_runtime::traits::Keccak256;
+
+/// A BEEFY specific keystore implemented as a `Newtype`. This is basically a
+/// wrapper around [`sp_keystore::Keystore`] and allows to customize
+/// common cryptographic functionality.
+pub(crate) struct BeefyKeystore(Option<KeystorePtr>);
+
+impl BeefyKeystore {
+	/// Check if the keystore contains a private key for one of the public keys
+	/// contained in `keys`. A public key with a matching private key is known
+	/// as a local authority id.
+	///
+	/// Return the public key for which we also do have a private key. If no
+	/// matching private key is found, `None` will be returned.
+	pub fn authority_id(&self, keys: &[Public]) -> Option<Public> {
+		let store = self.0.clone()?;
+
+		// we do check for multiple private keys as a key store sanity check.
+		let public: Vec<Public> = keys
+			.iter()
+			.filter(|k| store.has_keys(&[(k.to_raw_vec(), BEEFY_KEY_TYPE)]))
+			.cloned()
+			.collect();
+
+		if public.len() > 1 {
+			warn!(
+				target: LOG_TARGET,
+				"🥩 Multiple private keys found for: {:?} ({})",
+				public,
+				public.len()
+			);
+		}
+
+		public.get(0).cloned()
+	}
+
+	/// Sign `message` with the `public` key.
+	///
+	/// Note that `message` usually will be pre-hashed before being signed.
+	///
+	/// Return the message signature or an error in case of failure.
+	pub fn sign(&self, public: &Public, message: &[u8]) -> Result<Signature, error::Error> {
+		let store = self.0.clone().ok_or_else(|| error::Error::Keystore("no Keystore".into()))?;
+
+		let msg = keccak_256(message);
+		let public = public.as_ref();
+
+		let sig = store
+			.ecdsa_sign_prehashed(BEEFY_KEY_TYPE, public, &msg)
+			.map_err(|e| error::Error::Keystore(e.to_string()))?
+			.ok_or_else(|| error::Error::Signature("ecdsa_sign_prehashed() failed".to_string()))?;
+
+		// check that `sig` has the expected result type
+		let sig = sig.clone().try_into().map_err(|_| {
+			error::Error::Signature(format!("invalid signature {:?} for key {:?}", sig, public))
+		})?;
+
+		Ok(sig)
+	}
+
+	/// Returns a vector of [`sp_consensus_beefy::crypto::Public`] keys which are currently
+	/// supported (i.e. found in the keystore).
+	pub fn public_keys(&self) -> Result<Vec<Public>, error::Error> {
+		let store = self.0.clone().ok_or_else(|| error::Error::Keystore("no Keystore".into()))?;
+
+		let pk: Vec<Public> =
+			store.ecdsa_public_keys(BEEFY_KEY_TYPE).drain(..).map(Public::from).collect();
+
+		Ok(pk)
+	}
+
+	/// Use the `public` key to verify that `sig` is a valid signature for `message`.
+	///
+	/// Return `true` if the signature is authentic, `false` otherwise.
+	pub fn verify(public: &Public, sig: &Signature, message: &[u8]) -> bool {
+		BeefyAuthorityId::<BeefySignatureHasher>::verify(public, sig, message)
+	}
+}
+
+impl From<Option<KeystorePtr>> for BeefyKeystore {
+	fn from(store: Option<KeystorePtr>) -> BeefyKeystore {
+		BeefyKeystore(store)
+	}
+}
+
+#[cfg(test)]
+pub mod tests {
+	use sp_consensus_beefy::{ecdsa_crypto, Keyring};
+	use sp_core::{ecdsa, Pair};
+	use sp_keystore::testing::MemoryKeystore;
+
+	use super::*;
+	use crate::error::Error;
+
+	fn keystore() -> KeystorePtr {
+		MemoryKeystore::new().into()
+	}
+
+	#[test]
+	fn verify_should_work() {
+		let msg = keccak_256(b"I am Alice!");
+		let sig = Keyring::Alice.sign(b"I am Alice!");
+
+		assert!(ecdsa::Pair::verify_prehashed(
+			&sig.clone().into(),
+			&msg,
+			&Keyring::Alice.public().into(),
+		));
+
+		// different public key -> fail
+		assert!(!ecdsa::Pair::verify_prehashed(
+			&sig.clone().into(),
+			&msg,
+			&Keyring::Bob.public().into(),
+		));
+
+		let msg = keccak_256(b"I am not Alice!");
+
+		// different msg -> fail
+		assert!(
+			!ecdsa::Pair::verify_prehashed(&sig.into(), &msg, &Keyring::Alice.public().into(),)
+		);
+	}
+
+	#[test]
+	fn pair_works() {
+		let want = ecdsa_crypto::Pair::from_string("//Alice", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::Alice.pair().to_raw_vec();
+		assert_eq!(want, got);
+
+		let want = ecdsa_crypto::Pair::from_string("//Bob", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::Bob.pair().to_raw_vec();
+		assert_eq!(want, got);
+
+		let want = ecdsa_crypto::Pair::from_string("//Charlie", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::Charlie.pair().to_raw_vec();
+		assert_eq!(want, got);
+
+		let want = ecdsa_crypto::Pair::from_string("//Dave", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::Dave.pair().to_raw_vec();
+		assert_eq!(want, got);
+
+		let want = ecdsa_crypto::Pair::from_string("//Eve", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::Eve.pair().to_raw_vec();
+		assert_eq!(want, got);
+
+		let want = ecdsa_crypto::Pair::from_string("//Ferdie", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::Ferdie.pair().to_raw_vec();
+		assert_eq!(want, got);
+
+		let want = ecdsa_crypto::Pair::from_string("//One", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::One.pair().to_raw_vec();
+		assert_eq!(want, got);
+
+		let want = ecdsa_crypto::Pair::from_string("//Two", None)
+			.expect("Pair failed")
+			.to_raw_vec();
+		let got = Keyring::Two.pair().to_raw_vec();
+		assert_eq!(want, got);
+	}
+
+	#[test]
+	fn authority_id_works() {
+		let store = keystore();
+
+		let alice: ecdsa_crypto::Public = store
+			.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&Keyring::Alice.to_seed()))
+			.ok()
+			.unwrap()
+			.into();
+
+		let bob = Keyring::Bob.public();
+		let charlie = Keyring::Charlie.public();
+
+		let store: BeefyKeystore = Some(store).into();
+
+		let mut keys = vec![bob, charlie];
+
+		let id = store.authority_id(keys.as_slice());
+		assert!(id.is_none());
+
+		keys.push(alice.clone());
+
+		let id = store.authority_id(keys.as_slice()).unwrap();
+		assert_eq!(id, alice);
+	}
+
+	#[test]
+	fn sign_works() {
+		let store = keystore();
+
+		let alice: ecdsa_crypto::Public = store
+			.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&Keyring::Alice.to_seed()))
+			.ok()
+			.unwrap()
+			.into();
+
+		let store: BeefyKeystore = Some(store).into();
+
+		let msg = b"are you involved or commited?";
+
+		let sig1 = store.sign(&alice, msg).unwrap();
+		let sig2 = Keyring::Alice.sign(msg);
+
+		assert_eq!(sig1, sig2);
+	}
+
+	#[test]
+	fn sign_error() {
+		let store = keystore();
+
+		store
+			.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&Keyring::Bob.to_seed()))
+			.ok()
+			.unwrap();
+
+		let store: BeefyKeystore = Some(store).into();
+
+		let alice = Keyring::Alice.public();
+
+		let msg = b"are you involved or commited?";
+		let sig = store.sign(&alice, msg).err().unwrap();
+		let err = Error::Signature("ecdsa_sign_prehashed() failed".to_string());
+
+		assert_eq!(sig, err);
+	}
+
+	#[test]
+	fn sign_no_keystore() {
+		let store: BeefyKeystore = None.into();
+
+		let alice = Keyring::Alice.public();
+		let msg = b"are you involved or commited";
+
+		let sig = store.sign(&alice, msg).err().unwrap();
+		let err = Error::Keystore("no Keystore".to_string());
+		assert_eq!(sig, err);
+	}
+
+	#[test]
+	fn verify_works() {
+		let store = keystore();
+
+		let alice: ecdsa_crypto::Public = store
+			.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&Keyring::Alice.to_seed()))
+			.ok()
+			.unwrap()
+			.into();
+
+		let store: BeefyKeystore = Some(store).into();
+
+		// `msg` and `sig` match
+		let msg = b"are you involved or commited?";
+		let sig = store.sign(&alice, msg).unwrap();
+		assert!(BeefyKeystore::verify(&alice, &sig, msg));
+
+		// `msg and `sig` don't match
+		let msg = b"you are just involved";
+		assert!(!BeefyKeystore::verify(&alice, &sig, msg));
+	}
+
+	// Note that we use keys with and without a seed for this test.
+	#[test]
+	fn public_keys_works() {
+		const TEST_TYPE: sp_application_crypto::KeyTypeId =
+			sp_application_crypto::KeyTypeId(*b"test");
+
+		let store = keystore();
+
+		let add_key =
+			|key_type, seed: Option<&str>| store.ecdsa_generate_new(key_type, seed).unwrap();
+
+		// test keys
+		let _ = add_key(TEST_TYPE, Some(Keyring::Alice.to_seed().as_str()));
+		let _ = add_key(TEST_TYPE, Some(Keyring::Bob.to_seed().as_str()));
+
+		let _ = add_key(TEST_TYPE, None);
+		let _ = add_key(TEST_TYPE, None);
+
+		// BEEFY keys
+		let _ = add_key(BEEFY_KEY_TYPE, Some(Keyring::Dave.to_seed().as_str()));
+		let _ = add_key(BEEFY_KEY_TYPE, Some(Keyring::Eve.to_seed().as_str()));
+
+		let key1: ecdsa_crypto::Public = add_key(BEEFY_KEY_TYPE, None).into();
+		let key2: ecdsa_crypto::Public = add_key(BEEFY_KEY_TYPE, None).into();
+
+		let store: BeefyKeystore = Some(store).into();
+
+		let keys = store.public_keys().ok().unwrap();
+
+		assert!(keys.len() == 4);
+		assert!(keys.contains(&Keyring::Dave.public()));
+		assert!(keys.contains(&Keyring::Eve.public()));
+		assert!(keys.contains(&key1));
+		assert!(keys.contains(&key2));
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/lib.rs b/substrate/client/consensus/beefy/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0b3baa007c1ce83c56c3d0b1cd02cc08e5db1b9b
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/lib.rs
@@ -0,0 +1,559 @@
+// 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::{
+	communication::{
+		notification::{
+			BeefyBestBlockSender, BeefyBestBlockStream, BeefyVersionedFinalityProofSender,
+			BeefyVersionedFinalityProofStream,
+		},
+		peers::KnownPeers,
+		request_response::{
+			outgoing_requests_engine::OnDemandJustificationsEngine, BeefyJustifsRequestHandler,
+		},
+	},
+	import::BeefyBlockImport,
+	metrics::register_metrics,
+	round::Rounds,
+	worker::PersistedState,
+};
+use futures::{stream::Fuse, StreamExt};
+use log::{error, info};
+use parking_lot::Mutex;
+use prometheus::Registry;
+use sc_client_api::{Backend, BlockBackend, BlockchainEvents, FinalityNotifications, Finalizer};
+use sc_consensus::BlockImport;
+use sc_network::{NetworkRequest, ProtocolName};
+use sc_network_gossip::{GossipEngine, Network as GossipNetwork, Syncing as GossipSyncing};
+use sp_api::{HeaderT, NumberFor, ProvideRuntimeApi};
+use sp_blockchain::{
+	Backend as BlockchainBackend, Error as ClientError, HeaderBackend, Result as ClientResult,
+};
+use sp_consensus::{Error as ConsensusError, SyncOracle};
+use sp_consensus_beefy::{
+	ecdsa_crypto::AuthorityId, BeefyApi, MmrRootHash, PayloadProvider, ValidatorSet,
+	BEEFY_ENGINE_ID,
+};
+use sp_keystore::KeystorePtr;
+use sp_mmr_primitives::MmrApi;
+use sp_runtime::traits::{Block, Zero};
+use std::{
+	collections::{BTreeMap, VecDeque},
+	marker::PhantomData,
+	sync::Arc,
+};
+
+mod aux_schema;
+mod error;
+mod keystore;
+mod metrics;
+mod round;
+mod worker;
+
+pub mod communication;
+pub mod import;
+pub mod justification;
+
+pub use communication::beefy_protocol_name::{
+	gossip_protocol_name, justifications_protocol_name as justifs_protocol_name,
+};
+
+#[cfg(test)]
+mod tests;
+
+const LOG_TARGET: &str = "beefy";
+
+/// A convenience BEEFY client trait that defines all the type bounds a BEEFY client
+/// has to satisfy. Ideally that should actually be a trait alias. Unfortunately as
+/// of today, Rust does not allow a type alias to be used as a trait bound. Tracking
+/// issue is <https://github.com/rust-lang/rust/issues/41517>.
+pub trait Client<B, BE>:
+	BlockchainEvents<B> + HeaderBackend<B> + Finalizer<B, BE> + Send + Sync
+where
+	B: Block,
+	BE: Backend<B>,
+{
+	// empty
+}
+
+impl<B, BE, T> Client<B, BE> for T
+where
+	B: Block,
+	BE: Backend<B>,
+	T: BlockchainEvents<B>
+		+ HeaderBackend<B>
+		+ Finalizer<B, BE>
+		+ ProvideRuntimeApi<B>
+		+ Send
+		+ Sync,
+{
+	// empty
+}
+
+/// 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> {
+	// BlockImport -> Voter links
+	/// Stream of BEEFY signed commitments from block import to voter.
+	pub from_block_import_justif_stream: BeefyVersionedFinalityProofStream<B>,
+
+	// Voter -> RPC links
+	/// Sends BEEFY signed commitments from voter to RPC.
+	pub to_rpc_justif_sender: BeefyVersionedFinalityProofSender<B>,
+	/// 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> {
+	/// Stream of signed commitments coming from the voter.
+	pub from_voter_justif_stream: BeefyVersionedFinalityProofStream<B>,
+	/// 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>(
+	wrapped_block_import: I,
+	backend: Arc<BE>,
+	runtime: Arc<RuntimeApi>,
+	prometheus_registry: Option<Registry>,
+) -> (BeefyBlockImport<B, BE, RuntimeApi, I>, BeefyVoterLinks<B>, BeefyRPCLinks<B>)
+where
+	B: Block,
+	BE: Backend<B>,
+	I: BlockImport<B, Error = ConsensusError> + Send + Sync,
+	RuntimeApi: ProvideRuntimeApi<B> + Send + Sync,
+	RuntimeApi::Api: BeefyApi<B, AuthorityId>,
+{
+	// Voter -> RPC links
+	let (to_rpc_justif_sender, from_voter_justif_stream) =
+		BeefyVersionedFinalityProofStream::<B>::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();
+	let metrics = register_metrics(prometheus_registry);
+
+	// BlockImport
+	let import = BeefyBlockImport::new(
+		backend,
+		runtime,
+		wrapped_block_import,
+		to_voter_justif_sender,
+		metrics,
+	);
+	let voter_links = BeefyVoterLinks {
+		from_block_import_justif_stream,
+		to_rpc_justif_sender,
+		to_rpc_best_block_sender,
+	};
+	let rpc_links = BeefyRPCLinks { from_voter_best_beefy_stream, from_voter_justif_stream };
+
+	(import, voter_links, rpc_links)
+}
+
+/// BEEFY gadget network parameters.
+pub struct BeefyNetworkParams<B: Block, N, S> {
+	/// Network implementing gossip, requests and sync-oracle.
+	pub network: Arc<N>,
+	/// Syncing service implementing a sync oracle and an event stream for peers.
+	pub sync: Arc<S>,
+	/// Chain specific BEEFY gossip protocol name. See
+	/// [`communication::beefy_protocol_name::gossip_protocol_name`].
+	pub gossip_protocol_name: ProtocolName,
+	/// Chain specific BEEFY on-demand justifications protocol name. See
+	/// [`communication::beefy_protocol_name::justifications_protocol_name`].
+	pub justifications_protocol_name: ProtocolName,
+
+	pub _phantom: PhantomData<B>,
+}
+
+/// BEEFY gadget initialization parameters.
+pub struct BeefyParams<B: Block, BE, C, N, P, R, S> {
+	/// BEEFY client
+	pub client: Arc<C>,
+	/// Client Backend
+	pub backend: Arc<BE>,
+	/// BEEFY Payload provider
+	pub payload_provider: P,
+	/// Runtime Api Provider
+	pub runtime: Arc<R>,
+	/// Local key store
+	pub key_store: Option<KeystorePtr>,
+	/// BEEFY voter network params
+	pub network_params: BeefyNetworkParams<B, N, S>,
+	/// Minimal delta between blocks, BEEFY should vote for
+	pub min_block_delta: u32,
+	/// Prometheus metric registry
+	pub prometheus_registry: Option<Registry>,
+	/// Links between the block importer, the background voter and the RPC layer.
+	pub links: BeefyVoterLinks<B>,
+	/// Handler for incoming BEEFY justifications requests from a remote peer.
+	pub on_demand_justifications_handler: BeefyJustifsRequestHandler<B, C>,
+}
+
+/// 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>,
+) where
+	B: Block,
+	BE: Backend<B>,
+	C: Client<B, BE> + BlockBackend<B>,
+	P: PayloadProvider<B> + Clone,
+	R: ProvideRuntimeApi<B>,
+	R::Api: BeefyApi<B, AuthorityId> + MmrApi<B, MmrRootHash, NumberFor<B>>,
+	N: GossipNetwork<B> + NetworkRequest + Send + Sync + 'static,
+	S: GossipSyncing<B> + SyncOracle + 'static,
+{
+	let BeefyParams {
+		client,
+		backend,
+		payload_provider,
+		runtime,
+		key_store,
+		network_params,
+		min_block_delta,
+		prometheus_registry,
+		links,
+		mut on_demand_justifications_handler,
+	} = beefy_params;
+
+	let BeefyNetworkParams {
+		network,
+		sync,
+		gossip_protocol_name,
+		justifications_protocol_name,
+		..
+	} = network_params;
+
+	let metrics = register_metrics(prometheus_registry.clone());
+
+	// Subscribe to finality notifications and justifications before waiting for runtime pallet and
+	// reuse the streams, so we don't miss notifications while waiting for pallet to be available.
+	let mut finality_notifications = client.finality_notification_stream().fuse();
+	let mut block_import_justif = links.from_block_import_justif_stream.subscribe(100_000).fuse();
+
+	// We re-create and re-run the worker in this loop in order to quickly reinit and resume after
+	// select recoverable errors.
+	loop {
+		let known_peers = Arc::new(Mutex::new(KnownPeers::new()));
+		// Default votes filter is to discard everything.
+		// Validator is updated later with correct starting round and set id.
+		let (gossip_validator, gossip_report_stream) =
+			communication::gossip::GossipValidator::new(known_peers.clone());
+		let gossip_validator = Arc::new(gossip_validator);
+		let mut gossip_engine = GossipEngine::new(
+			network.clone(),
+			sync.clone(),
+			gossip_protocol_name.clone(),
+			gossip_validator.clone(),
+			None,
+		);
+
+		// The `GossipValidator` adds and removes known peers based on valid votes and network
+		// events.
+		let on_demand_justifications = OnDemandJustificationsEngine::new(
+			network.clone(),
+			justifications_protocol_name.clone(),
+			known_peers,
+			prometheus_registry.clone(),
+		);
+
+		// Wait for BEEFY pallet to be active before starting voter.
+		let persisted_state = match wait_for_runtime_pallet(
+			&*runtime,
+			&mut gossip_engine,
+			&mut finality_notifications,
+		)
+		.await
+		.and_then(|(beefy_genesis, best_grandpa)| {
+			load_or_init_voter_state(
+				&*backend,
+				&*runtime,
+				beefy_genesis,
+				best_grandpa,
+				min_block_delta,
+			)
+		}) {
+			Ok(state) => state,
+			Err(e) => {
+				error!(target: LOG_TARGET, "Error: {:?}. Terminating.", e);
+				return
+			},
+		};
+		// Update the gossip validator with the right starting round and set id.
+		if let Err(e) = persisted_state
+			.gossip_filter_config()
+			.map(|f| gossip_validator.update_filter(f))
+		{
+			error!(target: LOG_TARGET, "Error: {:?}. Terminating.", e);
+			return
+		}
+
+		let worker = worker::BeefyWorker {
+			backend: backend.clone(),
+			payload_provider: payload_provider.clone(),
+			runtime: runtime.clone(),
+			sync: sync.clone(),
+			key_store: key_store.clone().into(),
+			gossip_engine,
+			gossip_validator,
+			gossip_report_stream,
+			on_demand_justifications,
+			links: links.clone(),
+			metrics: metrics.clone(),
+			pending_justifications: BTreeMap::new(),
+			persisted_state,
+		};
+
+		match futures::future::select(
+			Box::pin(worker.run(&mut block_import_justif, &mut finality_notifications)),
+			Box::pin(on_demand_justifications_handler.run()),
+		)
+		.await
+		{
+			// On `ConsensusReset` error, just reinit and restart voter.
+			futures::future::Either::Left((error::Error::ConsensusReset, _)) => {
+				error!(target: LOG_TARGET, "🥩 Error: {:?}. Restarting voter.", error::Error::ConsensusReset);
+				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),
+		};
+		return
+	}
+}
+
+fn load_or_init_voter_state<B, BE, R>(
+	backend: &BE,
+	runtime: &R,
+	beefy_genesis: NumberFor<B>,
+	best_grandpa: <B as Block>::Header,
+	min_block_delta: u32,
+) -> ClientResult<PersistedState<B>>
+where
+	B: Block,
+	BE: Backend<B>,
+	R: ProvideRuntimeApi<B>,
+	R::Api: BeefyApi<B, AuthorityId>,
+{
+	// Initialize voter state from AUX DB if compatible.
+	crate::aux_schema::load_persistent(backend)?
+		// Verify state pallet genesis matches runtime.
+		.filter(|state| state.pallet_genesis() == beefy_genesis)
+		.and_then(|mut state| {
+			// Overwrite persisted state with current best GRANDPA block.
+			state.set_best_grandpa(best_grandpa.clone());
+			// Overwrite persisted data with newly provided `min_block_delta`.
+			state.set_min_block_delta(min_block_delta);
+			info!(target: LOG_TARGET, "🥩 Loading BEEFY voter state from db: {:?}.", state);
+			Some(Ok(state))
+		})
+		// No valid voter-state persisted, re-initialize from pallet genesis.
+		.unwrap_or_else(|| {
+			initialize_voter_state(backend, runtime, beefy_genesis, best_grandpa, min_block_delta)
+		})
+}
+
+// If no persisted state present, walk back the chain from first GRANDPA notification to either:
+//  - latest BEEFY finalized block, or if none found on the way,
+//  - BEEFY pallet genesis;
+// Enqueue any BEEFY mandatory blocks (session boundaries) found on the way, for voter to finalize.
+fn initialize_voter_state<B, BE, R>(
+	backend: &BE,
+	runtime: &R,
+	beefy_genesis: NumberFor<B>,
+	best_grandpa: <B as Block>::Header,
+	min_block_delta: u32,
+) -> ClientResult<PersistedState<B>>
+where
+	B: Block,
+	BE: Backend<B>,
+	R: ProvideRuntimeApi<B>,
+	R::Api: BeefyApi<B, AuthorityId>,
+{
+	let beefy_genesis = runtime
+		.runtime_api()
+		.beefy_genesis(best_grandpa.hash())
+		.ok()
+		.flatten()
+		.filter(|genesis| *genesis == beefy_genesis)
+		.ok_or_else(|| ClientError::Backend("BEEFY pallet expected to be active.".into()))?;
+	// Walk back the imported blocks and initialize voter either, at the last block with
+	// a BEEFY justification, or at pallet genesis block; voter will resume from there.
+	let blockchain = backend.blockchain();
+	let mut sessions = VecDeque::new();
+	let mut header = best_grandpa.clone();
+	let state = loop {
+		if let Some(true) = blockchain
+			.justifications(header.hash())
+			.ok()
+			.flatten()
+			.map(|justifs| justifs.get(BEEFY_ENGINE_ID).is_some())
+		{
+			info!(
+				target: LOG_TARGET,
+				"🥩 Initialize BEEFY voter at last BEEFY finalized block: {:?}.",
+				*header.number()
+			);
+			let best_beefy = *header.number();
+			// If no session boundaries detected so far, just initialize new rounds here.
+			if sessions.is_empty() {
+				let active_set = expect_validator_set(runtime, backend, &header, beefy_genesis)?;
+				let mut rounds = Rounds::new(best_beefy, active_set);
+				// Mark the round as already finalized.
+				rounds.conclude(best_beefy);
+				sessions.push_front(rounds);
+			}
+			let state = PersistedState::checked_new(
+				best_grandpa,
+				best_beefy,
+				sessions,
+				min_block_delta,
+				beefy_genesis,
+			)
+			.ok_or_else(|| ClientError::Backend("Invalid BEEFY chain".into()))?;
+			break state
+		}
+
+		if *header.number() == beefy_genesis {
+			// We've reached BEEFY genesis, initialize voter here.
+			let genesis_set = expect_validator_set(runtime, backend, &header, beefy_genesis)?;
+			info!(
+				target: LOG_TARGET,
+				"🥩 Loading BEEFY voter state from genesis on what appears to be first startup. \
+				Starting voting rounds at block {:?}, genesis validator set {:?}.",
+				beefy_genesis,
+				genesis_set,
+			);
+
+			sessions.push_front(Rounds::new(beefy_genesis, genesis_set));
+			break PersistedState::checked_new(
+				best_grandpa,
+				Zero::zero(),
+				sessions,
+				min_block_delta,
+				beefy_genesis,
+			)
+			.ok_or_else(|| ClientError::Backend("Invalid BEEFY chain".into()))?
+		}
+
+		if let Some(active) = worker::find_authorities_change::<B>(&header) {
+			info!(
+				target: LOG_TARGET,
+				"🥩 Marking block {:?} as BEEFY Mandatory.",
+				*header.number()
+			);
+			sessions.push_front(Rounds::new(*header.number(), active));
+		}
+
+		// Move up the chain.
+		header = blockchain.expect_header(*header.parent_hash())?;
+	};
+
+	aux_schema::write_current_version(backend)?;
+	aux_schema::write_voter_state(backend, &state)?;
+	Ok(state)
+}
+
+/// 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>(
+	runtime: &R,
+	mut gossip_engine: &mut GossipEngine<B>,
+	finality: &mut Fuse<FinalityNotifications<B>>,
+) -> ClientResult<(NumberFor<B>, <B as Block>::Header)>
+where
+	B: Block,
+	R: ProvideRuntimeApi<B>,
+	R::Api: BeefyApi<B, AuthorityId>,
+{
+	info!(target: LOG_TARGET, "🥩 BEEFY gadget waiting for BEEFY pallet to become available...");
+	loop {
+		futures::select! {
+			notif = finality.next() => {
+				let notif = match notif {
+					Some(notif) => notif,
+					None => break
+				};
+				let at = notif.header.hash();
+				if let Some(start) = runtime.runtime_api().beefy_genesis(at).ok().flatten() {
+					if *notif.header.number() >= start {
+						// Beefy pallet available, return header for best grandpa at the time.
+						info!(
+							target: LOG_TARGET,
+							"🥩 BEEFY pallet available: block {:?} beefy genesis {:?}",
+							notif.header.number(), start
+						);
+						return Ok((start, notif.header))
+					}
+				}
+			},
+			_ = gossip_engine => {
+				break
+			}
+		}
+	}
+	let err_msg = "🥩 Gossip engine has unexpectedly terminated.".into();
+	error!(target: LOG_TARGET, "{}", err_msg);
+	Err(ClientError::Backend(err_msg))
+}
+
+fn expect_validator_set<B, BE, R>(
+	runtime: &R,
+	backend: &BE,
+	at_header: &B::Header,
+	beefy_genesis: NumberFor<B>,
+) -> ClientResult<ValidatorSet<AuthorityId>>
+where
+	B: Block,
+	BE: Backend<B>,
+	R: ProvideRuntimeApi<B>,
+	R::Api: BeefyApi<B, AuthorityId>,
+{
+	runtime
+		.runtime_api()
+		.validator_set(at_header.hash())
+		.ok()
+		.flatten()
+		.or_else(|| {
+			// if state unavailable, fallback to walking up the chain looking for the header
+			// Digest emitted when validator set active 'at_header' was enacted.
+			let blockchain = backend.blockchain();
+			let mut header = at_header.clone();
+			while *header.number() >= beefy_genesis {
+				match worker::find_authorities_change::<B>(&header) {
+					Some(active) => return Some(active),
+					// Move up the chain.
+					None => header = blockchain.expect_header(*header.parent_hash()).ok()?,
+				}
+			}
+			None
+		})
+		.ok_or_else(|| ClientError::Backend("Could not find initial validator set".into()))
+}
diff --git a/substrate/client/consensus/beefy/src/metrics.rs b/substrate/client/consensus/beefy/src/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..031748bdceab5d3553f35b27fca4b6a2afdf70c9
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/metrics.rs
@@ -0,0 +1,345 @@
+// 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/>.
+
+//! BEEFY Prometheus metrics definition
+
+use crate::LOG_TARGET;
+use log::{debug, error};
+use prometheus::{register, Counter, Gauge, PrometheusError, Registry, U64};
+
+/// Helper trait for registering BEEFY metrics to Prometheus registry.
+pub(crate) trait PrometheusRegister<T: Sized = Self>: Sized {
+	const DESCRIPTION: &'static str;
+	fn register(registry: &Registry) -> Result<Self, PrometheusError>;
+}
+
+/// BEEFY voting-related metrics exposed through Prometheus
+#[derive(Clone, Debug)]
+pub struct VoterMetrics {
+	/// Current active validator set id
+	pub beefy_validator_set_id: Gauge<U64>,
+	/// Total number of votes sent by this node
+	pub beefy_votes_sent: Counter<U64>,
+	/// Best block finalized by BEEFY
+	pub beefy_best_block: Gauge<U64>,
+	/// Best block BEEFY voted on
+	pub beefy_best_voted: Gauge<U64>,
+	/// Next block BEEFY should vote on
+	pub beefy_should_vote_on: Gauge<U64>,
+	/// Number of sessions with lagging signed commitment on mandatory block
+	pub beefy_lagging_sessions: Counter<U64>,
+	/// Number of times no Authority public key found in store
+	pub beefy_no_authority_found_in_store: Counter<U64>,
+	/// Number of good votes successfully handled
+	pub beefy_good_votes_processed: Counter<U64>,
+	/// Number of equivocation votes received
+	pub beefy_equivocation_votes: Counter<U64>,
+	/// Number of invalid votes received
+	pub beefy_invalid_votes: Counter<U64>,
+	/// Number of valid but stale votes received
+	pub beefy_stale_votes: Counter<U64>,
+	/// Number of currently buffered justifications
+	pub beefy_buffered_justifications: Gauge<U64>,
+	/// Number of valid but stale justifications received
+	pub beefy_stale_justifications: Counter<U64>,
+	/// Number of valid justifications successfully imported
+	pub beefy_imported_justifications: Counter<U64>,
+	/// Number of justifications dropped due to full buffers
+	pub beefy_buffered_justifications_dropped: Counter<U64>,
+}
+
+impl PrometheusRegister for VoterMetrics {
+	const DESCRIPTION: &'static str = "voter";
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			beefy_validator_set_id: register(
+				Gauge::new(
+					"substrate_beefy_validator_set_id",
+					"Current BEEFY active validator set id.",
+				)?,
+				registry,
+			)?,
+			beefy_votes_sent: register(
+				Counter::new("substrate_beefy_votes_sent", "Number of votes sent by this node")?,
+				registry,
+			)?,
+			beefy_best_block: register(
+				Gauge::new("substrate_beefy_best_block", "Best block finalized by BEEFY")?,
+				registry,
+			)?,
+			beefy_best_voted: register(
+				Gauge::new("substrate_beefy_best_voted", "Best block voted on by BEEFY")?,
+				registry,
+			)?,
+			beefy_should_vote_on: register(
+				Gauge::new("substrate_beefy_should_vote_on", "Next block, BEEFY should vote on")?,
+				registry,
+			)?,
+			beefy_lagging_sessions: register(
+				Counter::new(
+					"substrate_beefy_lagging_sessions",
+					"Number of sessions with lagging signed commitment on mandatory block",
+				)?,
+				registry,
+			)?,
+			beefy_no_authority_found_in_store: register(
+				Counter::new(
+					"substrate_beefy_no_authority_found_in_store",
+					"Number of times no Authority public key found in store",
+				)?,
+				registry,
+			)?,
+			beefy_good_votes_processed: register(
+				Counter::new(
+					"substrate_beefy_successful_handled_votes",
+					"Number of good votes successfully handled",
+				)?,
+				registry,
+			)?,
+			beefy_equivocation_votes: register(
+				Counter::new(
+					"substrate_beefy_equivocation_votes",
+					"Number of equivocation votes received",
+				)?,
+				registry,
+			)?,
+			beefy_invalid_votes: register(
+				Counter::new("substrate_beefy_invalid_votes", "Number of invalid votes received")?,
+				registry,
+			)?,
+			beefy_stale_votes: register(
+				Counter::new(
+					"substrate_beefy_stale_votes",
+					"Number of valid but stale votes received",
+				)?,
+				registry,
+			)?,
+			beefy_buffered_justifications: register(
+				Gauge::new(
+					"substrate_beefy_buffered_justifications",
+					"Number of currently buffered justifications",
+				)?,
+				registry,
+			)?,
+			beefy_stale_justifications: register(
+				Counter::new(
+					"substrate_beefy_stale_justifications",
+					"Number of valid but stale justifications received",
+				)?,
+				registry,
+			)?,
+			beefy_imported_justifications: register(
+				Counter::new(
+					"substrate_beefy_imported_justifications",
+					"Number of valid justifications successfully imported",
+				)?,
+				registry,
+			)?,
+			beefy_buffered_justifications_dropped: register(
+				Counter::new(
+					"substrate_beefy_buffered_justifications_dropped",
+					"Number of justifications dropped due to full buffers",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// BEEFY block-import-related metrics exposed through Prometheus
+#[derive(Clone, Debug)]
+pub struct BlockImportMetrics {
+	/// Number of Good Justification imports
+	pub beefy_good_justification_imports: Counter<U64>,
+	/// Number of Bad Justification imports
+	pub beefy_bad_justification_imports: Counter<U64>,
+}
+
+impl PrometheusRegister for BlockImportMetrics {
+	const DESCRIPTION: &'static str = "block-import";
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			beefy_good_justification_imports: register(
+				Counter::new(
+					"substrate_beefy_good_justification_imports",
+					"Number of good justifications on block-import",
+				)?,
+				registry,
+			)?,
+			beefy_bad_justification_imports: register(
+				Counter::new(
+					"substrate_beefy_bad_justification_imports",
+					"Number of bad justifications on block-import",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// BEEFY on-demand-justifications-related metrics exposed through Prometheus
+#[derive(Clone, Debug)]
+pub struct OnDemandIncomingRequestsMetrics {
+	/// Number of Successful Justification responses
+	pub beefy_successful_justification_responses: Counter<U64>,
+	/// Number of Failed Justification responses
+	pub beefy_failed_justification_responses: Counter<U64>,
+}
+
+impl PrometheusRegister for OnDemandIncomingRequestsMetrics {
+	const DESCRIPTION: &'static str = "on-demand incoming justification requests";
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			beefy_successful_justification_responses: register(
+				Counter::new(
+					"substrate_beefy_successful_justification_responses",
+					"Number of Successful Justification responses",
+				)?,
+				registry,
+			)?,
+			beefy_failed_justification_responses: register(
+				Counter::new(
+					"substrate_beefy_failed_justification_responses",
+					"Number of Failed Justification responses",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// BEEFY on-demand-justifications-related metrics exposed through Prometheus
+#[derive(Clone, Debug)]
+pub struct OnDemandOutgoingRequestsMetrics {
+	/// Number of times there was no good peer to request justification from
+	pub beefy_on_demand_justification_no_peer_to_request_from: Counter<U64>,
+	/// Number of on-demand justification peer refused valid requests
+	pub beefy_on_demand_justification_peer_refused: Counter<U64>,
+	/// Number of on-demand justification peer error
+	pub beefy_on_demand_justification_peer_error: Counter<U64>,
+	/// Number of on-demand justification invalid proof
+	pub beefy_on_demand_justification_invalid_proof: Counter<U64>,
+	/// Number of on-demand justification good proof
+	pub beefy_on_demand_justification_good_proof: Counter<U64>,
+}
+
+impl PrometheusRegister for OnDemandOutgoingRequestsMetrics {
+	const DESCRIPTION: &'static str = "on-demand outgoing justification requests";
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			beefy_on_demand_justification_no_peer_to_request_from: register(
+				Counter::new(
+					"substrate_beefy_on_demand_justification_no_peer_to_request_from",
+					"Number of times there was no good peer to request justification from",
+				)?,
+				registry,
+			)?,
+			beefy_on_demand_justification_peer_refused: register(
+				Counter::new(
+					"beefy_on_demand_justification_peer_refused",
+					"Number of on-demand justification peer refused valid requests",
+				)?,
+				registry,
+			)?,
+			beefy_on_demand_justification_peer_error: register(
+				Counter::new(
+					"substrate_beefy_on_demand_justification_peer_error",
+					"Number of on-demand justification peer error",
+				)?,
+				registry,
+			)?,
+			beefy_on_demand_justification_invalid_proof: register(
+				Counter::new(
+					"substrate_beefy_on_demand_justification_invalid_proof",
+					"Number of on-demand justification invalid proof",
+				)?,
+				registry,
+			)?,
+			beefy_on_demand_justification_good_proof: register(
+				Counter::new(
+					"substrate_beefy_on_demand_justification_good_proof",
+					"Number of on-demand justification good proof",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+pub(crate) fn register_metrics<T: PrometheusRegister>(
+	prometheus_registry: Option<prometheus::Registry>,
+) -> Option<T> {
+	prometheus_registry.as_ref().map(T::register).and_then(|result| match result {
+		Ok(metrics) => {
+			debug!(target: LOG_TARGET, "🥩 Registered {} metrics", T::DESCRIPTION);
+			Some(metrics)
+		},
+		Err(err) => {
+			error!(
+				target: LOG_TARGET,
+				"🥩 Failed to register {} metrics: {:?}",
+				T::DESCRIPTION,
+				err
+			);
+			None
+		},
+	})
+}
+
+// Note: we use the `format` macro to convert an expr into a `u64`. This will fail,
+// if expr does not derive `Display`.
+#[macro_export]
+macro_rules! metric_set {
+	($self:ident, $m:ident, $v:expr) => {{
+		let val: u64 = format!("{}", $v).parse().unwrap();
+
+		if let Some(metrics) = $self.metrics.as_ref() {
+			metrics.$m.set(val);
+		}
+	}};
+}
+
+#[macro_export]
+macro_rules! metric_inc {
+	($self:ident, $m:ident) => {{
+		if let Some(metrics) = $self.metrics.as_ref() {
+			metrics.$m.inc();
+		}
+	}};
+}
+
+#[macro_export]
+macro_rules! metric_get {
+	($self:ident, $m:ident) => {{
+		$self.metrics.as_ref().map(|metrics| metrics.$m.clone())
+	}};
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+
+	#[test]
+	fn should_register_metrics() {
+		let registry = Some(Registry::new());
+		assert!(register_metrics::<VoterMetrics>(registry.clone()).is_some());
+		assert!(register_metrics::<BlockImportMetrics>(registry.clone()).is_some());
+		assert!(register_metrics::<OnDemandIncomingRequestsMetrics>(registry.clone()).is_some());
+		assert!(register_metrics::<OnDemandOutgoingRequestsMetrics>(registry.clone()).is_some());
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/round.rs b/substrate/client/consensus/beefy/src/round.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f400ce47843cb9e6579c35330767104419f5728
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/round.rs
@@ -0,0 +1,499 @@
+// 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::LOG_TARGET;
+
+use codec::{Decode, Encode};
+use log::debug;
+use sp_consensus_beefy::{
+	ecdsa_crypto::{AuthorityId, Signature},
+	Commitment, EquivocationProof, SignedCommitment, ValidatorSet, ValidatorSetId, VoteMessage,
+};
+use sp_runtime::traits::{Block, NumberFor};
+use std::collections::BTreeMap;
+
+/// Tracks for each round which validators have voted/signed and
+/// 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>,
+}
+
+impl RoundTracker {
+	fn add_vote(&mut self, vote: (AuthorityId, Signature)) -> bool {
+		if self.votes.contains_key(&vote.0) {
+			return false
+		}
+
+		self.votes.insert(vote.0, vote.1);
+		true
+	}
+
+	fn is_done(&self, threshold: usize) -> bool {
+		self.votes.len() >= threshold
+	}
+}
+
+/// Minimum size of `authorities` subset that produced valid signatures for a block to finalize.
+pub fn threshold(authorities: usize) -> usize {
+	let faulty = authorities.saturating_sub(1) / 3;
+	authorities - faulty
+}
+
+#[derive(Debug, PartialEq)]
+pub enum VoteImportResult<B: Block> {
+	Ok,
+	RoundConcluded(SignedCommitment<NumberFor<B>, Signature>),
+	Equivocation(EquivocationProof<NumberFor<B>, AuthorityId, Signature>),
+	Invalid,
+	Stale,
+}
+
+/// Keeps track of all voting rounds (block numbers) within a session.
+/// Only round numbers > `best_done` are of interest, all others are considered stale.
+///
+/// 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>>,
+	session_start: NumberFor<B>,
+	validator_set: ValidatorSet<AuthorityId>,
+	mandatory_done: bool,
+	best_done: Option<NumberFor<B>>,
+}
+
+impl<B> Rounds<B>
+where
+	B: Block,
+{
+	pub(crate) fn new(
+		session_start: NumberFor<B>,
+		validator_set: ValidatorSet<AuthorityId>,
+	) -> Self {
+		Rounds {
+			rounds: BTreeMap::new(),
+			previous_votes: BTreeMap::new(),
+			session_start,
+			validator_set,
+			mandatory_done: false,
+			best_done: None,
+		}
+	}
+
+	pub(crate) fn validator_set(&self) -> &ValidatorSet<AuthorityId> {
+		&self.validator_set
+	}
+
+	pub(crate) fn validator_set_id(&self) -> ValidatorSetId {
+		self.validator_set.id()
+	}
+
+	pub(crate) fn validators(&self) -> &[AuthorityId] {
+		self.validator_set.validators()
+	}
+
+	pub(crate) fn session_start(&self) -> NumberFor<B> {
+		self.session_start
+	}
+
+	pub(crate) fn mandatory_done(&self) -> bool {
+		self.mandatory_done
+	}
+
+	pub(crate) fn add_vote(
+		&mut self,
+		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
+	) -> VoteImportResult<B> {
+		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
+		} else if vote.commitment.validator_set_id != self.validator_set_id() {
+			debug!(
+				target: LOG_TARGET,
+				"🥩 expected set_id {:?}, ignoring vote {:?}.",
+				self.validator_set_id(),
+				vote,
+			);
+			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
+		}
+
+		if let Some(previous_vote) = self.previous_votes.get(&vote_key) {
+			// is the same public key voting for a different payload?
+			if previous_vote.commitment.payload != vote.commitment.payload {
+				debug!(
+					target: LOG_TARGET,
+					"🥩 detected equivocated vote: 1st: {:?}, 2nd: {:?}", previous_vote, vote
+				);
+				return VoteImportResult::Equivocation(EquivocationProof {
+					first: previous_vote.clone(),
+					second: vote,
+				})
+			}
+		} else {
+			// this is the first vote sent by `id` for `num`, all good
+			self.previous_votes.insert(vote_key, vote.clone());
+		}
+
+		// add valid vote
+		let round = self.rounds.entry(vote.commitment.clone()).or_default();
+		if round.add_vote((vote.id, vote.signature)) &&
+			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))
+			}
+		}
+		VoteImportResult::Ok
+	}
+
+	fn signed_commitment(
+		&mut self,
+		round: (Commitment<NumberFor<B>>, RoundTracker),
+	) -> SignedCommitment<NumberFor<B>, Signature> {
+		let votes = round.1.votes;
+		let signatures = self
+			.validators()
+			.iter()
+			.map(|authority_id| votes.get(authority_id).cloned())
+			.collect();
+		SignedCommitment { commitment: round.0, signatures }
+	}
+
+	pub(crate) fn conclude(&mut self, round_num: NumberFor<B>) {
+		// Remove this and older (now stale) rounds.
+		self.rounds.retain(|commitment, _| commitment.block_number > round_num);
+		self.previous_votes.retain(|&(_, number), _| number > round_num);
+		self.mandatory_done = self.mandatory_done || round_num == self.session_start;
+		self.best_done = self.best_done.max(Some(round_num));
+		debug!(target: LOG_TARGET, "🥩 Concluded round #{}", round_num);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use sc_network_test::Block;
+
+	use sp_consensus_beefy::{
+		known_payloads::MMR_ROOT_ID, Commitment, EquivocationProof, Keyring, Payload,
+		SignedCommitment, ValidatorSet, VoteMessage,
+	};
+
+	use super::{threshold, AuthorityId, Block as BlockT, RoundTracker, Rounds};
+	use crate::round::VoteImportResult;
+
+	impl<B> Rounds<B>
+	where
+		B: BlockT,
+	{
+		pub(crate) fn test_set_mandatory_done(&mut self, done: bool) {
+			self.mandatory_done = done;
+		}
+	}
+
+	#[test]
+	fn round_tracker() {
+		let mut rt = RoundTracker::default();
+		let bob_vote = (Keyring::Bob.public(), Keyring::Bob.sign(b"I am committed"));
+		let threshold = 2;
+
+		// adding new vote allowed
+		assert!(rt.add_vote(bob_vote.clone()));
+		// adding existing vote not allowed
+		assert!(!rt.add_vote(bob_vote));
+
+		// vote is not done
+		assert!(!rt.is_done(threshold));
+
+		let alice_vote = (Keyring::Alice.public(), Keyring::Alice.sign(b"I am committed"));
+		// adding new vote (self vote this time) allowed
+		assert!(rt.add_vote(alice_vote));
+
+		// vote is now done
+		assert!(rt.is_done(threshold));
+	}
+
+	#[test]
+	fn vote_threshold() {
+		assert_eq!(threshold(1), 1);
+		assert_eq!(threshold(2), 2);
+		assert_eq!(threshold(3), 3);
+		assert_eq!(threshold(4), 3);
+		assert_eq!(threshold(100), 67);
+		assert_eq!(threshold(300), 201);
+	}
+
+	#[test]
+	fn new_rounds() {
+		sp_tracing::try_init_simple();
+
+		let validators = ValidatorSet::<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);
+
+		assert_eq!(42, rounds.validator_set_id());
+		assert_eq!(1, rounds.session_start());
+		assert_eq!(
+			&vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()],
+			rounds.validators()
+		);
+	}
+
+	#[test]
+	fn add_and_conclude_votes() {
+		sp_tracing::try_init_simple();
+
+		let validators = ValidatorSet::<AuthorityId>::new(
+			vec![
+				Keyring::Alice.public(),
+				Keyring::Bob.public(),
+				Keyring::Charlie.public(),
+				Keyring::Eve.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 payload = Payload::from_single_entry(MMR_ROOT_ID, vec![]);
+		let block_number = 1;
+		let commitment = Commitment { block_number, payload, validator_set_id };
+		let mut vote = VoteMessage {
+			id: Keyring::Alice.public(),
+			commitment: commitment.clone(),
+			signature: Keyring::Alice.sign(b"I am committed"),
+		};
+		// add 1st good vote
+		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok);
+
+		// double voting (same vote), ok, no effect
+		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok);
+
+		vote.id = Keyring::Dave.public();
+		vote.signature = Keyring::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::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::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::Alice.sign(b"I am committed")),
+					Some(Keyring::Bob.sign(b"I am committed")),
+					Some(Keyring::Charlie.sign(b"I am committed")),
+					None,
+				]
+			})
+		);
+		rounds.conclude(block_number);
+
+		vote.id = Keyring::Eve.public();
+		vote.signature = Keyring::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);
+	}
+
+	#[test]
+	fn old_rounds_not_accepted() {
+		sp_tracing::try_init_simple();
+
+		let validators = ValidatorSet::<AuthorityId>::new(
+			vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()],
+			42,
+		)
+		.unwrap();
+		let validator_set_id = validators.id();
+
+		// active rounds starts at block 10
+		let session_start = 10u64.into();
+		let mut rounds = Rounds::<Block>::new(session_start, validators);
+
+		// vote on round 9
+		let block_number = 9;
+		let payload = Payload::from_single_entry(MMR_ROOT_ID, vec![]);
+		let commitment = Commitment { block_number, payload, validator_set_id };
+		let mut vote = VoteMessage {
+			id: Keyring::Alice.public(),
+			commitment,
+			signature: Keyring::Alice.sign(b"I am committed"),
+		};
+		// add vote for previous session, should fail
+		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Stale);
+		// no votes present
+		assert!(rounds.rounds.is_empty());
+
+		// simulate 11 was concluded
+		rounds.best_done = Some(11);
+		// add votes for current session, but already concluded rounds, should fail
+		vote.commitment.block_number = 10;
+		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Stale);
+		vote.commitment.block_number = 11;
+		assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Stale);
+		// no votes present
+		assert!(rounds.rounds.is_empty());
+
+		// add vote for active round 12
+		vote.commitment.block_number = 12;
+		assert_eq!(rounds.add_vote(vote), VoteImportResult::Ok);
+		// good vote present
+		assert_eq!(rounds.rounds.len(), 1);
+	}
+
+	#[test]
+	fn multiple_rounds() {
+		sp_tracing::try_init_simple();
+
+		let validators = ValidatorSet::<AuthorityId>::new(
+			vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.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 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::Alice.sign(b"I am committed"),
+		};
+		let mut bob_vote = VoteMessage {
+			id: Keyring::Bob.public(),
+			commitment: commitment.clone(),
+			signature: Keyring::Bob.sign(b"I am committed"),
+		};
+		let mut charlie_vote = VoteMessage {
+			id: Keyring::Charlie.public(),
+			commitment,
+			signature: Keyring::Charlie.sign(b"I am committed"),
+		};
+		let expected_signatures = vec![
+			Some(Keyring::Alice.sign(b"I am committed")),
+			Some(Keyring::Bob.sign(b"I am committed")),
+			Some(Keyring::Charlie.sign(b"I am committed")),
+		];
+
+		// round 1 - only 2 out of 3 vote
+		assert_eq!(rounds.add_vote(alice_vote.clone()), VoteImportResult::Ok);
+		assert_eq!(rounds.add_vote(charlie_vote.clone()), VoteImportResult::Ok);
+		// should be 1 active round
+		assert_eq!(1, rounds.rounds.len());
+
+		// round 2 - only Charlie votes
+		charlie_vote.commitment.block_number = 2;
+		assert_eq!(rounds.add_vote(charlie_vote.clone()), VoteImportResult::Ok);
+		// should be 2 active rounds
+		assert_eq!(2, rounds.rounds.len());
+
+		// round 3 - all validators vote -> round is concluded
+		alice_vote.commitment.block_number = 3;
+		bob_vote.commitment.block_number = 3;
+		charlie_vote.commitment.block_number = 3;
+		assert_eq!(rounds.add_vote(alice_vote.clone()), VoteImportResult::Ok);
+		assert_eq!(rounds.add_vote(bob_vote.clone()), VoteImportResult::Ok);
+		assert_eq!(
+			rounds.add_vote(charlie_vote.clone()),
+			VoteImportResult::RoundConcluded(SignedCommitment {
+				commitment: charlie_vote.commitment,
+				signatures: expected_signatures
+			})
+		);
+		// should be only 2 active since this one auto-concluded
+		assert_eq!(2, rounds.rounds.len());
+
+		// conclude round 2
+		rounds.conclude(2);
+		// should be no more active rounds since 2 was officially concluded and round "1" is stale
+		assert!(rounds.rounds.is_empty());
+
+		// conclude round 3
+		rounds.conclude(3);
+		assert!(rounds.previous_votes.is_empty());
+	}
+
+	#[test]
+	fn should_provide_equivocation_proof() {
+		sp_tracing::try_init_simple();
+
+		let validators = ValidatorSet::<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 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]);
+		let commitment1 = Commitment { block_number: 1, payload: payload1, validator_set_id };
+		let commitment2 = Commitment { block_number: 1, payload: payload2, validator_set_id };
+
+		let alice_vote1 = VoteMessage {
+			id: Keyring::Alice.public(),
+			commitment: commitment1,
+			signature: Keyring::Alice.sign(b"I am committed"),
+		};
+		let mut alice_vote2 = alice_vote1.clone();
+		alice_vote2.commitment = commitment2;
+
+		let expected_result = VoteImportResult::Equivocation(EquivocationProof {
+			first: alice_vote1.clone(),
+			second: alice_vote2.clone(),
+		});
+
+		// vote on one payload - ok
+		assert_eq!(rounds.add_vote(alice_vote1), VoteImportResult::Ok);
+
+		// vote on _another_ commitment/payload -> expected equivocation proof
+		assert_eq!(rounds.add_vote(alice_vote2), expected_result);
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/tests.rs b/substrate/client/consensus/beefy/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3bb65e9d57f435b78b9faccffb687bc4ab64757d
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/tests.rs
@@ -0,0 +1,1435 @@
+// 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/>.
+
+//! Tests and test helpers for BEEFY.
+
+use crate::{
+	aux_schema::{load_persistent, tests::verify_persisted_version},
+	beefy_block_import_and_links,
+	communication::{
+		gossip::{
+			proofs_topic, tests::sign_commitment, votes_topic, GossipFilterCfg, GossipMessage,
+			GossipValidator,
+		},
+		request_response::{on_demand_justifications_protocol_config, BeefyJustifsRequestHandler},
+	},
+	gossip_protocol_name,
+	justification::*,
+	load_or_init_voter_state, wait_for_runtime_pallet, BeefyRPCLinks, BeefyVoterLinks, KnownPeers,
+	PersistedState,
+};
+use futures::{future, stream::FuturesUnordered, Future, FutureExt, StreamExt};
+use parking_lot::Mutex;
+use sc_client_api::{Backend as BackendT, BlockchainEvents, FinalityNotifications, HeaderBackend};
+use sc_consensus::{
+	BlockImport, BlockImportParams, BoxJustificationImport, ForkChoiceStrategy, ImportResult,
+	ImportedAux,
+};
+use sc_network::{config::RequestResponseConfig, ProtocolName};
+use sc_network_test::{
+	Block, BlockImportAdapter, FullPeerConfig, PassThroughVerifier, Peer, PeersClient,
+	PeersFullClient, TestNetFactory,
+};
+use sc_utils::notification::NotificationReceiver;
+use serde::{Deserialize, Serialize};
+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::{AuthorityId, Signature},
+	known_payloads,
+	mmr::{find_mmr_root_digest, MmrRootProvider},
+	BeefyApi, Commitment, ConsensusLog, EquivocationProof, Keyring as BeefyKeyring, MmrRootHash,
+	OpaqueKeyOwnershipProof, Payload, SignedCommitment, ValidatorSet, ValidatorSetId,
+	VersionedFinalityProof, VoteMessage, BEEFY_ENGINE_ID,
+};
+use sp_core::H256;
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystorePtr};
+use sp_mmr_primitives::{Error as MmrError, MmrApi};
+use sp_runtime::{
+	codec::{Decode, Encode},
+	traits::{Header as HeaderT, NumberFor},
+	BuildStorage, DigestItem, EncodedJustification, Justifications, Storage,
+};
+use std::{marker::PhantomData, sync::Arc, task::Poll};
+use substrate_test_runtime_client::{BlockBuilderExt, ClientExt};
+use tokio::time::Duration;
+
+const GENESIS_HASH: H256 = H256::zero();
+fn beefy_gossip_proto_name() -> ProtocolName {
+	gossip_protocol_name(GENESIS_HASH, None)
+}
+
+const GOOD_MMR_ROOT: MmrRootHash = MmrRootHash::repeat_byte(0xbf);
+const BAD_MMR_ROOT: MmrRootHash = MmrRootHash::repeat_byte(0x42);
+const ALTERNATE_BAD_MMR_ROOT: MmrRootHash = MmrRootHash::repeat_byte(0x13);
+
+type BeefyBlockImport = crate::BeefyBlockImport<
+	Block,
+	substrate_test_runtime_client::Backend,
+	TestApi,
+	BlockImportAdapter<PeersClient>,
+>;
+
+pub(crate) type BeefyValidatorSet = ValidatorSet<AuthorityId>;
+pub(crate) type BeefyPeer = Peer<PeerData, BeefyBlockImport>;
+
+#[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(())
+	}
+}
+
+#[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_justif_req_handler:
+		Mutex<Option<BeefyJustifsRequestHandler<Block, PeersFullClient>>>,
+}
+
+#[derive(Default)]
+pub(crate) struct BeefyTestNet {
+	peers: Vec<BeefyPeer>,
+	pub beefy_genesis: NumberFor<Block>,
+}
+
+impl BeefyTestNet {
+	pub(crate) fn new(n_authority: usize) -> Self {
+		let beefy_genesis = 1;
+		let mut net = BeefyTestNet { peers: Vec::with_capacity(n_authority), beefy_genesis };
+
+		for i in 0..n_authority {
+			let (rx, cfg) = on_demand_justifications_protocol_config(GENESIS_HASH, None);
+			let justif_protocol_name = cfg.name.clone();
+
+			net.add_authority_peer(vec![cfg]);
+
+			let client = net.peers[i].client().as_client();
+			let justif_handler = BeefyJustifsRequestHandler {
+				request_receiver: rx,
+				justif_protocol_name,
+				client,
+				_block: PhantomData,
+				metrics: None,
+			};
+			*net.peers[i].data.beefy_justif_req_handler.lock() = Some(justif_handler);
+		}
+		net
+	}
+
+	pub(crate) fn add_authority_peer(&mut self, req_resp_cfgs: Vec<RequestResponseConfig>) {
+		self.add_full_peer_with_config(FullPeerConfig {
+			notifications_protocols: vec![beefy_gossip_proto_name()],
+			request_response_protocols: req_resp_cfgs,
+			is_authority: true,
+			..Default::default()
+		});
+	}
+
+	/// Builds the blocks and returns the vector of built block hashes.
+	/// Returned vector contains the genesis hash which allows for easy indexing (block number is
+	/// equal to index)
+	pub(crate) async fn generate_blocks_and_sync(
+		&mut self,
+		count: usize,
+		session_length: u64,
+		validator_set: &BeefyValidatorSet,
+		include_mmr_digest: bool,
+	) -> Vec<H256> {
+		let mut all_hashes = Vec::with_capacity(count + 1);
+
+		// make sure genesis is the only block in network, so we can insert genesis at the beginning
+		// of hashes, otherwise indexing would be broken
+		assert!(self.peer(0).client().as_backend().blockchain().hash(1).unwrap().is_none());
+
+		// push genesis to make indexing human readable (index equals to block number)
+		all_hashes.push(self.peer(0).client().info().genesis_hash);
+
+		let mut block_num: NumberFor<Block> = self.peer(0).client().info().best_number;
+		let built_hashes = self.peer(0).generate_blocks(count, BlockOrigin::File, |mut builder| {
+			block_num = block_num.saturating_add(1).try_into().unwrap();
+			if include_mmr_digest {
+				let num_byte = block_num.to_le_bytes().into_iter().next().unwrap();
+				let mmr_root = MmrRootHash::repeat_byte(num_byte);
+				add_mmr_digest(&mut builder, mmr_root);
+			}
+
+			if block_num % session_length == 0 {
+				add_auth_change_digest(&mut builder, validator_set.clone());
+			}
+
+			let block = builder.build().unwrap().block;
+			assert_eq!(block.header.number, block_num);
+
+			block
+		});
+		all_hashes.extend(built_hashes);
+		self.run_until_sync().await;
+
+		all_hashes
+	}
+}
+
+impl TestNetFactory for BeefyTestNet {
+	type Verifier = PassThroughVerifier;
+	type BlockImport = BeefyBlockImport;
+	type PeerData = PeerData;
+
+	fn make_verifier(&self, _client: PeersClient, _: &PeerData) -> Self::Verifier {
+		PassThroughVerifier::new(false) // use non-instant finality.
+	}
+
+	fn make_block_import(
+		&self,
+		client: PeersClient,
+	) -> (
+		BlockImportAdapter<Self::BlockImport>,
+		Option<BoxJustificationImport<Block>>,
+		Self::PeerData,
+	) {
+		let keys = &[BeefyKeyring::Alice, BeefyKeyring::Bob];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+		let api = Arc::new(TestApi::new(self.beefy_genesis, &validator_set, GOOD_MMR_ROOT));
+		let inner = BlockImportAdapter::new(client.clone());
+		let (block_import, voter_links, rpc_links) =
+			beefy_block_import_and_links(inner, client.as_backend(), api, None);
+		let peer_data = PeerData {
+			beefy_rpc_links: Mutex::new(Some(rpc_links)),
+			beefy_voter_links: Mutex::new(Some(voter_links)),
+			..Default::default()
+		};
+		(BlockImportAdapter::new(block_import), None, peer_data)
+	}
+
+	fn peer(&mut self, i: usize) -> &mut BeefyPeer {
+		&mut self.peers[i]
+	}
+
+	fn peers(&self) -> &Vec<BeefyPeer> {
+		&self.peers
+	}
+
+	fn peers_mut(&mut self) -> &mut Vec<BeefyPeer> {
+		&mut self.peers
+	}
+
+	fn mut_peers<F: FnOnce(&mut Vec<BeefyPeer>)>(&mut self, closure: F) {
+		closure(&mut self.peers);
+	}
+
+	fn add_full_peer(&mut self) {
+		// `add_authority_peer()` used instead.
+		unimplemented!()
+	}
+}
+
+#[derive(Clone)]
+pub(crate) struct TestApi {
+	pub beefy_genesis: u64,
+	pub validator_set: BeefyValidatorSet,
+	pub mmr_root_hash: MmrRootHash,
+	pub reported_equivocations:
+		Option<Arc<Mutex<Vec<EquivocationProof<NumberFor<Block>, AuthorityId, Signature>>>>>,
+}
+
+impl TestApi {
+	pub fn new(
+		beefy_genesis: u64,
+		validator_set: &BeefyValidatorSet,
+		mmr_root_hash: MmrRootHash,
+	) -> Self {
+		TestApi {
+			beefy_genesis,
+			validator_set: validator_set.clone(),
+			mmr_root_hash,
+			reported_equivocations: None,
+		}
+	}
+
+	pub fn with_validator_set(validator_set: &BeefyValidatorSet) -> Self {
+		TestApi {
+			beefy_genesis: 1,
+			validator_set: validator_set.clone(),
+			mmr_root_hash: GOOD_MMR_ROOT,
+			reported_equivocations: None,
+		}
+	}
+
+	pub fn allow_equivocations(&mut self) {
+		self.reported_equivocations = Some(Arc::new(Mutex::new(vec![])));
+	}
+}
+
+// compiler gets confused and warns us about unused inner
+#[allow(dead_code)]
+pub(crate) struct RuntimeApi {
+	inner: TestApi,
+}
+
+impl ProvideRuntimeApi<Block> for TestApi {
+	type Api = RuntimeApi;
+	fn runtime_api(&self) -> ApiRef<Self::Api> {
+		RuntimeApi { inner: self.clone() }.into()
+	}
+}
+sp_api::mock_impl_runtime_apis! {
+	impl BeefyApi<Block, AuthorityId> for RuntimeApi {
+		fn beefy_genesis() -> Option<NumberFor<Block>> {
+			Some(self.inner.beefy_genesis)
+		}
+
+		fn validator_set() -> Option<BeefyValidatorSet> {
+			Some(self.inner.validator_set.clone())
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			proof: EquivocationProof<NumberFor<Block>, AuthorityId, Signature>,
+			_dummy: OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			if let Some(equivocations_buf) = self.inner.reported_equivocations.as_ref() {
+				equivocations_buf.lock().push(proof);
+				None
+			} else {
+				panic!("Equivocations not expected, but following proof was reported: {:?}", proof);
+			}
+		}
+
+		fn generate_key_ownership_proof(
+			_dummy1: ValidatorSetId,
+			_dummy2: AuthorityId,
+		) -> Option<OpaqueKeyOwnershipProof> { Some(OpaqueKeyOwnershipProof::new(vec![])) }
+	}
+
+	impl MmrApi<Block, MmrRootHash, NumberFor<Block>> for RuntimeApi {
+		fn mmr_root() -> Result<MmrRootHash, MmrError> {
+			Ok(self.inner.mmr_root_hash)
+		}
+	}
+}
+
+fn add_mmr_digest(builder: &mut impl BlockBuilderExt, mmr_hash: MmrRootHash) {
+	builder
+		.push_deposit_log_digest_item(DigestItem::Consensus(
+			BEEFY_ENGINE_ID,
+			ConsensusLog::<AuthorityId>::MmrRoot(mmr_hash).encode(),
+		))
+		.unwrap();
+}
+
+fn add_auth_change_digest(builder: &mut impl BlockBuilderExt, new_auth_set: BeefyValidatorSet) {
+	builder
+		.push_deposit_log_digest_item(DigestItem::Consensus(
+			BEEFY_ENGINE_ID,
+			ConsensusLog::<AuthorityId>::AuthoritiesChange(new_auth_set).encode(),
+		))
+		.unwrap();
+}
+
+pub(crate) fn make_beefy_ids(keys: &[BeefyKeyring]) -> Vec<AuthorityId> {
+	keys.iter().map(|&key| key.public().into()).collect()
+}
+
+pub(crate) fn create_beefy_keystore(authority: BeefyKeyring) -> KeystorePtr {
+	let keystore = MemoryKeystore::new();
+	keystore
+		.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&authority.to_seed()))
+		.expect("Creates authority key");
+	keystore.into()
+}
+
+async fn voter_init_setup(
+	net: &mut BeefyTestNet,
+	finality: &mut futures::stream::Fuse<FinalityNotifications<Block>>,
+	api: &TestApi,
+) -> sp_blockchain::Result<PersistedState<Block>> {
+	let backend = net.peer(0).client().as_backend();
+	let known_peers = Arc::new(Mutex::new(KnownPeers::new()));
+	let (gossip_validator, _) = GossipValidator::new(known_peers);
+	let gossip_validator = Arc::new(gossip_validator);
+	let mut gossip_engine = sc_network_gossip::GossipEngine::new(
+		net.peer(0).network_service().clone(),
+		net.peer(0).sync_service().clone(),
+		"/beefy/whatever",
+		gossip_validator,
+		None,
+	);
+	let (beefy_genesis, best_grandpa) =
+		wait_for_runtime_pallet(api, &mut gossip_engine, finality).await.unwrap();
+	load_or_init_voter_state(&*backend, api, beefy_genesis, best_grandpa, 1)
+}
+
+// Spawns beefy voters. Returns a future to spawn on the runtime.
+fn initialize_beefy<API>(
+	net: &mut BeefyTestNet,
+	peers: Vec<(usize, &BeefyKeyring, Arc<API>)>,
+	min_block_delta: u32,
+) -> impl Future<Output = ()>
+where
+	API: ProvideRuntimeApi<Block> + Sync + Send,
+	API::Api: BeefyApi<Block, AuthorityId> + MmrApi<Block, MmrRootHash, NumberFor<Block>>,
+{
+	let tasks = FuturesUnordered::new();
+
+	for (peer_id, key, api) in peers.into_iter() {
+		let peer = &net.peers[peer_id];
+
+		let keystore = create_beefy_keystore(*key);
+
+		let (_, _, peer_data) = net.make_block_import(peer.client().clone());
+		let PeerData { beefy_rpc_links, beefy_voter_links, .. } = peer_data;
+
+		let beefy_voter_links = beefy_voter_links.lock().take();
+		*peer.data.beefy_rpc_links.lock() = beefy_rpc_links.lock().take();
+		*peer.data.beefy_voter_links.lock() = beefy_voter_links.clone();
+
+		let on_demand_justif_handler = peer.data.beefy_justif_req_handler.lock().take().unwrap();
+
+		let network_params = crate::BeefyNetworkParams {
+			network: peer.network_service().clone(),
+			sync: peer.sync_service().clone(),
+			gossip_protocol_name: beefy_gossip_proto_name(),
+			justifications_protocol_name: on_demand_justif_handler.protocol_name(),
+			_phantom: PhantomData,
+		};
+		let payload_provider = MmrRootProvider::new(api.clone());
+
+		let beefy_params = crate::BeefyParams {
+			client: peer.client().as_client(),
+			backend: peer.client().as_backend(),
+			payload_provider,
+			runtime: api.clone(),
+			key_store: Some(keystore),
+			network_params,
+			links: beefy_voter_links.unwrap(),
+			min_block_delta,
+			prometheus_registry: None,
+			on_demand_justifications_handler: on_demand_justif_handler,
+		};
+		let task = crate::start_beefy_gadget::<_, _, _, _, _, _, _>(beefy_params);
+
+		fn assert_send<T: Send>(_: &T) {}
+		assert_send(&task);
+		tasks.push(task);
+	}
+
+	tasks.for_each(|_| async move {})
+}
+
+async fn run_until(future: impl Future + Unpin, net: &Arc<Mutex<BeefyTestNet>>) {
+	let drive_to_completion = futures::future::poll_fn(|cx| {
+		net.lock().poll(cx);
+		Poll::<()>::Pending
+	});
+	let _ = future::select(future, drive_to_completion).await;
+}
+
+async fn run_for(duration: Duration, net: &Arc<Mutex<BeefyTestNet>>) {
+	run_until(Box::pin(tokio::time::sleep(duration)), net).await;
+}
+
+pub(crate) fn get_beefy_streams(
+	net: &mut BeefyTestNet,
+	// peer index and key
+	peers: impl Iterator<Item = (usize, BeefyKeyring)>,
+) -> (Vec<NotificationReceiver<H256>>, Vec<NotificationReceiver<BeefyVersionedFinalityProof<Block>>>)
+{
+	let mut best_block_streams = Vec::new();
+	let mut versioned_finality_proof_streams = Vec::new();
+	peers.for_each(|(index, _)| {
+		let beefy_rpc_links = net.peer(index).data.beefy_rpc_links.lock().clone().unwrap();
+		let BeefyRPCLinks { from_voter_justif_stream, from_voter_best_beefy_stream } =
+			beefy_rpc_links;
+		best_block_streams.push(from_voter_best_beefy_stream.subscribe(100_000));
+		versioned_finality_proof_streams.push(from_voter_justif_stream.subscribe(100_000));
+	});
+	(best_block_streams, versioned_finality_proof_streams)
+}
+
+async fn wait_for_best_beefy_blocks(
+	streams: Vec<NotificationReceiver<H256>>,
+	net: &Arc<Mutex<BeefyTestNet>>,
+	expected_beefy_blocks: &[u64],
+) {
+	let mut wait_for = Vec::new();
+	let len = expected_beefy_blocks.len();
+	streams.into_iter().enumerate().for_each(|(i, stream)| {
+		let mut expected = expected_beefy_blocks.iter();
+		wait_for.push(Box::pin(stream.take(len).for_each(move |best_beefy_hash| {
+			let expected = expected.next();
+			async move {
+				let header =
+					net.lock().peer(i).client().as_client().expect_header(best_beefy_hash).unwrap();
+				let best_beefy = *header.number();
+
+				assert_eq!(expected, Some(best_beefy).as_ref());
+			}
+		})));
+	});
+	let wait_for = futures::future::join_all(wait_for);
+	run_until(wait_for, net).await;
+}
+
+async fn wait_for_beefy_signed_commitments(
+	streams: Vec<NotificationReceiver<BeefyVersionedFinalityProof<Block>>>,
+	net: &Arc<Mutex<BeefyTestNet>>,
+	expected_commitment_block_nums: &[u64],
+) {
+	let mut wait_for = Vec::new();
+	let len = expected_commitment_block_nums.len();
+	streams.into_iter().for_each(|stream| {
+		let mut expected = expected_commitment_block_nums.iter();
+		wait_for.push(Box::pin(stream.take(len).for_each(move |versioned_finality_proof| {
+			let expected = expected.next();
+			async move {
+				let signed_commitment = match versioned_finality_proof {
+					sp_consensus_beefy::VersionedFinalityProof::V1(sc) => sc,
+				};
+				let commitment_block_num = signed_commitment.commitment.block_number;
+				assert_eq!(expected, Some(commitment_block_num).as_ref());
+				// TODO: also verify commitment payload, validator set id, and signatures.
+			}
+		})));
+	});
+	let wait_for = futures::future::join_all(wait_for);
+	run_until(wait_for, net).await;
+}
+
+async fn streams_empty_after_future<T>(
+	streams: Vec<NotificationReceiver<T>>,
+	future: Option<impl Future + Unpin>,
+) where
+	T: std::fmt::Debug,
+	T: std::cmp::PartialEq,
+{
+	if let Some(future) = future {
+		future.await;
+	}
+	for mut stream in streams.into_iter() {
+		future::poll_fn(move |cx| {
+			assert_eq!(stream.poll_next_unpin(cx), Poll::Pending);
+			Poll::Ready(())
+		})
+		.await;
+	}
+}
+
+async fn streams_empty_after_timeout<T>(
+	streams: Vec<NotificationReceiver<T>>,
+	net: &Arc<Mutex<BeefyTestNet>>,
+	timeout: Option<Duration>,
+) where
+	T: std::fmt::Debug,
+	T: std::cmp::PartialEq,
+{
+	let timeout = timeout.map(|timeout| Box::pin(run_for(timeout, net)));
+	streams_empty_after_future(streams, timeout).await;
+}
+
+async fn finalize_block_and_wait_for_beefy(
+	net: &Arc<Mutex<BeefyTestNet>>,
+	// peer index and key
+	peers: impl Iterator<Item = (usize, BeefyKeyring)> + Clone,
+	finalize_target: &H256,
+	expected_beefy: &[u64],
+) {
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
+
+	peers.clone().for_each(|(index, _)| {
+		let client = net.lock().peer(index).client().as_client();
+		client.finalize_block(*finalize_target, None).unwrap();
+	});
+
+	if expected_beefy.is_empty() {
+		// run for quarter second then verify no new best beefy block available
+		let timeout = Some(Duration::from_millis(250));
+		streams_empty_after_timeout(best_blocks, &net, timeout).await;
+		streams_empty_after_timeout(versioned_finality_proof, &net, None).await;
+	} else {
+		// run until expected beefy blocks are received
+		wait_for_best_beefy_blocks(best_blocks, &net, expected_beefy).await;
+		wait_for_beefy_signed_commitments(versioned_finality_proof, &net, expected_beefy).await;
+	}
+}
+
+#[tokio::test]
+async fn beefy_finalizing_blocks() {
+	sp_tracing::try_init_simple();
+
+	let peers = [BeefyKeyring::Alice, BeefyKeyring::Bob];
+	let validator_set = ValidatorSet::new(make_beefy_ids(&peers), 0).unwrap();
+	let session_len = 10;
+	let min_block_delta = 4;
+
+	let mut net = BeefyTestNet::new(2);
+
+	let api = Arc::new(TestApi::with_validator_set(&validator_set));
+	let beefy_peers = peers.iter().enumerate().map(|(id, key)| (id, key, api.clone())).collect();
+	tokio::spawn(initialize_beefy(&mut net, beefy_peers, min_block_delta));
+
+	// push 42 blocks including `AuthorityChange` digests every 10 blocks.
+	let hashes = net.generate_blocks_and_sync(42, session_len, &validator_set, true).await;
+
+	let net = Arc::new(Mutex::new(net));
+
+	// Minimum BEEFY block delta is 4.
+
+	let peers = peers.into_iter().enumerate();
+	// finalize block #5 -> BEEFY should finalize #1 (mandatory) and #5 from diff-power-of-two rule.
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[1], &[1]).await;
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[5], &[5]).await;
+
+	// GRANDPA finalize #10 -> BEEFY finalize #10 (mandatory)
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[10], &[10]).await;
+
+	// GRANDPA finalize #18 -> BEEFY finalize #14, then #18 (diff-power-of-two rule)
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[18], &[14, 18]).await;
+
+	// GRANDPA finalize #20 -> BEEFY finalize #20 (mandatory)
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[20], &[20]).await;
+
+	// GRANDPA finalize #21 -> BEEFY finalize nothing (yet) because min delta is 4
+	finalize_block_and_wait_for_beefy(&net, peers, &hashes[21], &[]).await;
+}
+
+#[tokio::test]
+async fn lagging_validators() {
+	sp_tracing::try_init_simple();
+
+	let peers = [BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie];
+	let validator_set = ValidatorSet::new(make_beefy_ids(&peers), 0).unwrap();
+	let session_len = 30;
+	let min_block_delta = 1;
+
+	let mut net = BeefyTestNet::new(3);
+	let api = Arc::new(TestApi::with_validator_set(&validator_set));
+	let beefy_peers = peers.iter().enumerate().map(|(id, key)| (id, key, api.clone())).collect();
+	tokio::spawn(initialize_beefy(&mut net, beefy_peers, min_block_delta));
+
+	// push 62 blocks including `AuthorityChange` digests every 30 blocks.
+	let hashes = net.generate_blocks_and_sync(62, session_len, &validator_set, true).await;
+
+	let net = Arc::new(Mutex::new(net));
+
+	let peers = peers.into_iter().enumerate();
+	// finalize block #15 -> BEEFY should finalize #1 (mandatory) and #9, #13, #14, #15 from
+	// diff-power-of-two rule.
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[1], &[1]).await;
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[15], &[9, 13, 14, 15]).await;
+
+	// Alice and Bob finalize #25, Charlie lags behind
+	let finalize = hashes[25];
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
+	net.lock().peer(0).client().as_client().finalize_block(finalize, None).unwrap();
+	net.lock().peer(1).client().as_client().finalize_block(finalize, None).unwrap();
+	// verify nothing gets finalized by BEEFY
+	let timeout = Some(Duration::from_millis(100));
+	streams_empty_after_timeout(best_blocks, &net, timeout).await;
+	streams_empty_after_timeout(versioned_finality_proof, &net, None).await;
+
+	// Charlie catches up and also finalizes #25
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
+	net.lock().peer(2).client().as_client().finalize_block(finalize, None).unwrap();
+	// expected beefy finalizes blocks 23, 24, 25 from diff-power-of-two
+	wait_for_best_beefy_blocks(best_blocks, &net, &[23, 24, 25]).await;
+	wait_for_beefy_signed_commitments(versioned_finality_proof, &net, &[23, 24, 25]).await;
+
+	// Both finalize #30 (mandatory session) and #32 -> BEEFY finalize #30 (mandatory), #31, #32
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[30], &[30]).await;
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[32], &[31, 32]).await;
+
+	// Verify that session-boundary votes get buffered by client and only processed once
+	// session-boundary block is GRANDPA-finalized (this guarantees authenticity for the new session
+	// validator set).
+
+	// Alice and Bob finalize session-boundary mandatory block #60, Charlie lags behind
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
+	let finalize = hashes[60];
+	net.lock().peer(0).client().as_client().finalize_block(finalize, None).unwrap();
+	net.lock().peer(1).client().as_client().finalize_block(finalize, None).unwrap();
+	// verify nothing gets finalized by BEEFY
+	let timeout = Some(Duration::from_millis(100));
+	streams_empty_after_timeout(best_blocks, &net, timeout).await;
+	streams_empty_after_timeout(versioned_finality_proof, &net, None).await;
+
+	// Charlie catches up and also finalizes #60 (and should have buffered Alice's vote on #60)
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers);
+	net.lock().peer(2).client().as_client().finalize_block(finalize, None).unwrap();
+	// verify beefy skips intermediary votes, and successfully finalizes mandatory block #60
+	wait_for_best_beefy_blocks(best_blocks, &net, &[60]).await;
+	wait_for_beefy_signed_commitments(versioned_finality_proof, &net, &[60]).await;
+}
+
+#[tokio::test]
+async fn correct_beefy_payload() {
+	sp_tracing::try_init_simple();
+
+	let peers = [BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie, BeefyKeyring::Dave];
+	let validator_set = ValidatorSet::new(make_beefy_ids(&peers), 0).unwrap();
+	let session_len = 20;
+	let min_block_delta = 2;
+
+	let mut net = BeefyTestNet::new(4);
+
+	// Alice, Bob, Charlie will vote on good payloads
+	let good_api = Arc::new(TestApi::new(1, &validator_set, GOOD_MMR_ROOT));
+	let good_peers = [BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie]
+		.iter()
+		.enumerate()
+		.map(|(id, key)| (id, key, good_api.clone()))
+		.collect();
+	tokio::spawn(initialize_beefy(&mut net, good_peers, min_block_delta));
+
+	// Dave will vote on bad mmr roots
+	let bad_api = Arc::new(TestApi::new(1, &validator_set, BAD_MMR_ROOT));
+	let bad_peers = vec![(3, &BeefyKeyring::Dave, bad_api)];
+	tokio::spawn(initialize_beefy(&mut net, bad_peers, min_block_delta));
+
+	// push 12 blocks
+	let hashes = net.generate_blocks_and_sync(12, session_len, &validator_set, false).await;
+
+	let net = Arc::new(Mutex::new(net));
+	let peers = peers.into_iter().enumerate();
+	// with 3 good voters and 1 bad one, consensus should happen and best blocks produced.
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[1], &[1]).await;
+	finalize_block_and_wait_for_beefy(&net, peers, &hashes[10], &[9]).await;
+
+	let (best_blocks, versioned_finality_proof) =
+		get_beefy_streams(&mut net.lock(), [(0, BeefyKeyring::Alice)].into_iter());
+
+	// now 2 good validators and 1 bad one are voting
+	let hashof11 = hashes[11];
+	net.lock().peer(0).client().as_client().finalize_block(hashof11, None).unwrap();
+	net.lock().peer(1).client().as_client().finalize_block(hashof11, None).unwrap();
+	net.lock().peer(3).client().as_client().finalize_block(hashof11, None).unwrap();
+
+	// verify consensus is _not_ reached
+	let timeout = Some(Duration::from_millis(100));
+	streams_empty_after_timeout(best_blocks, &net, timeout).await;
+	streams_empty_after_timeout(versioned_finality_proof, &net, None).await;
+
+	// 3rd good validator catches up and votes as well
+	let (best_blocks, versioned_finality_proof) =
+		get_beefy_streams(&mut net.lock(), [(0, BeefyKeyring::Alice)].into_iter());
+	net.lock().peer(2).client().as_client().finalize_block(hashof11, None).unwrap();
+
+	// verify consensus is reached
+	wait_for_best_beefy_blocks(best_blocks, &net, &[11]).await;
+	wait_for_beefy_signed_commitments(versioned_finality_proof, &net, &[11]).await;
+}
+
+#[tokio::test]
+async fn beefy_importing_justifications() {
+	use futures::{future::poll_fn, task::Poll};
+	use sc_block_builder::BlockBuilderProvider;
+	use sc_client_api::BlockBackend;
+
+	sp_tracing::try_init_simple();
+
+	let mut net = BeefyTestNet::new(2);
+	let keys = &[BeefyKeyring::Alice, BeefyKeyring::Bob];
+	let good_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+	// Set BEEFY genesis to block 3.
+	net.beefy_genesis = 3;
+
+	let client = net.peer(0).client().clone();
+	let full_client = client.as_client();
+	let (mut block_import, _, peer_data) = net.make_block_import(client.clone());
+	let PeerData { beefy_voter_links, .. } = peer_data;
+	let justif_stream = beefy_voter_links.lock().take().unwrap().from_block_import_justif_stream;
+	let mut justif_recv = justif_stream.subscribe(100_000);
+
+	let params = |block: Block, justifications: Option<Justifications>| {
+		let mut import = BlockImportParams::new(BlockOrigin::File, block.header);
+		import.justifications = justifications;
+		import.body = Some(block.extrinsics);
+		import.finalized = true;
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+		import
+	};
+	let backend_justif_for = |block_hash: H256| -> Option<EncodedJustification> {
+		full_client
+			.justifications(block_hash)
+			.unwrap()
+			.and_then(|j| j.get(BEEFY_ENGINE_ID).cloned())
+	};
+
+	let builder = full_client
+		.new_block_at(full_client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	let block = builder.build().unwrap().block;
+	let hashof1 = block.header.hash();
+
+	// Import block 1 without justifications.
+	assert_eq!(
+		block_import.import_block(params(block.clone(), None)).await.unwrap(),
+		ImportResult::Imported(ImportedAux { is_new_best: true, ..Default::default() }),
+	);
+	assert_eq!(
+		block_import.import_block(params(block, None)).await.unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+
+	// Import block 2 with "valid" justification (beefy pallet genesis block not yet reached).
+	let block_num = 2;
+	let builder = full_client.new_block_at(hashof1, Default::default(), false).unwrap();
+	let block = builder.build().unwrap().block;
+	let hashof2 = block.header.hash();
+
+	let proof = crate::justification::tests::new_finality_proof(block_num, &good_set, keys);
+	let versioned_proof: VersionedFinalityProof<NumberFor<Block>, Signature> = proof.into();
+	let encoded = versioned_proof.encode();
+	let justif = Some(Justifications::from((BEEFY_ENGINE_ID, encoded)));
+	assert_eq!(
+		block_import.import_block(params(block, justif)).await.unwrap(),
+		ImportResult::Imported(ImportedAux {
+			bad_justification: false,
+			is_new_best: true,
+			..Default::default()
+		}),
+	);
+
+	// Verify no BEEFY justifications present (for either block 1 or 2):
+	{
+		// none in backend,
+		assert_eq!(backend_justif_for(hashof1), None);
+		assert_eq!(backend_justif_for(hashof2), None);
+		// and none sent to BEEFY worker.
+		poll_fn(move |cx| {
+			assert_eq!(justif_recv.poll_next_unpin(cx), Poll::Pending);
+			Poll::Ready(())
+		})
+		.await;
+	}
+
+	// Import block 3 with valid justification.
+	let block_num = 3;
+	let builder = full_client.new_block_at(hashof2, Default::default(), false).unwrap();
+	let block = builder.build().unwrap().block;
+	let hashof3 = block.header.hash();
+	let proof = crate::justification::tests::new_finality_proof(block_num, &good_set, keys);
+	let versioned_proof: VersionedFinalityProof<NumberFor<Block>, Signature> = proof.into();
+	let encoded = versioned_proof.encode();
+	let justif = Some(Justifications::from((BEEFY_ENGINE_ID, encoded)));
+	let mut justif_recv = justif_stream.subscribe(100_000);
+	assert_eq!(
+		block_import.import_block(params(block, justif)).await.unwrap(),
+		ImportResult::Imported(ImportedAux {
+			bad_justification: false,
+			is_new_best: true,
+			..Default::default()
+		}),
+	);
+	// Verify BEEFY justification successfully imported:
+	{
+		// still not in backend (worker is responsible for appending to backend),
+		assert_eq!(backend_justif_for(hashof3), None);
+		// but sent to BEEFY worker
+		// (worker will append it to backend when all previous mandatory justifs are there as well).
+		poll_fn(move |cx| {
+			match justif_recv.poll_next_unpin(cx) {
+				Poll::Ready(Some(_justification)) => (),
+				v => panic!("unexpected value: {:?}", v),
+			}
+			Poll::Ready(())
+		})
+		.await;
+	}
+
+	// Import block 4 with invalid justification (incorrect validator set).
+	let block_num = 4;
+	let builder = full_client.new_block_at(hashof3, Default::default(), false).unwrap();
+	let block = builder.build().unwrap().block;
+	let hashof4 = block.header.hash();
+	let keys = &[BeefyKeyring::Alice];
+	let bad_set = ValidatorSet::new(make_beefy_ids(keys), 1).unwrap();
+	let proof = crate::justification::tests::new_finality_proof(block_num, &bad_set, keys);
+	let versioned_proof: VersionedFinalityProof<NumberFor<Block>, Signature> = proof.into();
+	let encoded = versioned_proof.encode();
+	let justif = Some(Justifications::from((BEEFY_ENGINE_ID, encoded)));
+	let mut justif_recv = justif_stream.subscribe(100_000);
+	assert_eq!(
+		block_import.import_block(params(block, justif)).await.unwrap(),
+		ImportResult::Imported(ImportedAux {
+			// Still `false` because we don't want to fail import on bad BEEFY justifications.
+			bad_justification: false,
+			is_new_best: true,
+			..Default::default()
+		}),
+	);
+	// Verify bad BEEFY justifications was not imported:
+	{
+		// none in backend,
+		assert_eq!(backend_justif_for(hashof4), None);
+		// and none sent to BEEFY worker.
+		poll_fn(move |cx| {
+			assert_eq!(justif_recv.poll_next_unpin(cx), Poll::Pending);
+			Poll::Ready(())
+		})
+		.await;
+	}
+}
+
+#[tokio::test]
+async fn on_demand_beefy_justification_sync() {
+	sp_tracing::try_init_simple();
+
+	let all_peers =
+		[BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie, BeefyKeyring::Dave];
+	let validator_set = ValidatorSet::new(make_beefy_ids(&all_peers), 0).unwrap();
+	let session_len = 5;
+	let min_block_delta = 4;
+
+	let mut net = BeefyTestNet::new(4);
+
+	// Alice, Bob, Charlie start first and make progress through voting.
+	let api = Arc::new(TestApi::with_validator_set(&validator_set));
+	let fast_peers = [BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie];
+	let voting_peers =
+		fast_peers.iter().enumerate().map(|(id, key)| (id, key, api.clone())).collect();
+	tokio::spawn(initialize_beefy(&mut net, voting_peers, min_block_delta));
+
+	// Dave will start late and have to catch up using on-demand justification requests (since
+	// in this test there is no block import queue to automatically import justifications).
+	let dave = vec![(3, &BeefyKeyring::Dave, api)];
+	// Instantiate but don't run Dave, yet.
+	let dave_task = initialize_beefy(&mut net, dave, min_block_delta);
+	let dave_index = 3;
+
+	// push 30 blocks
+	let mut hashes = net.generate_blocks_and_sync(30, session_len, &validator_set, false).await;
+
+	let fast_peers = fast_peers.into_iter().enumerate();
+	let net = Arc::new(Mutex::new(net));
+	// With 3 active voters and one inactive, consensus should happen and blocks BEEFY-finalized.
+	// Need to finalize at least one block in each session, choose randomly.
+	finalize_block_and_wait_for_beefy(&net, fast_peers.clone(), &hashes[1], &[1]).await;
+	finalize_block_and_wait_for_beefy(&net, fast_peers.clone(), &hashes[6], &[5]).await;
+	finalize_block_and_wait_for_beefy(&net, fast_peers.clone(), &hashes[10], &[10]).await;
+	finalize_block_and_wait_for_beefy(&net, fast_peers.clone(), &hashes[17], &[15]).await;
+	finalize_block_and_wait_for_beefy(&net, fast_peers.clone(), &hashes[24], &[20]).await;
+
+	// Spawn Dave, they are now way behind voting and can only catch up through on-demand justif
+	// sync.
+	tokio::spawn(dave_task);
+	// Dave pushes and syncs 4 more blocks just to make sure he gets included in gossip.
+	{
+		let mut net_guard = net.lock();
+		let built_hashes =
+			net_guard
+				.peer(dave_index)
+				.generate_blocks(4, BlockOrigin::File, |builder| builder.build().unwrap().block);
+		hashes.extend(built_hashes);
+		net_guard.run_until_sync().await;
+	}
+
+	let (dave_best_blocks, _) =
+		get_beefy_streams(&mut net.lock(), [(dave_index, BeefyKeyring::Dave)].into_iter());
+	let client = net.lock().peer(dave_index).client().as_client();
+	client.finalize_block(hashes[1], None).unwrap();
+	// Give Dave task some cpu cycles to process the finality notification,
+	run_for(Duration::from_millis(100), &net).await;
+	// freshly spun up Dave now needs to listen for gossip to figure out the state of their peers.
+
+	// Have the other peers do some gossip so Dave finds out about their progress.
+	finalize_block_and_wait_for_beefy(&net, fast_peers.clone(), &hashes[25], &[25]).await;
+	finalize_block_and_wait_for_beefy(&net, fast_peers, &hashes[29], &[29]).await;
+
+	// Kick Dave's async loop by finalizing another block.
+	client.finalize_block(hashes[2], None).unwrap();
+
+	// And verify Dave successfully finalized #1 (through on-demand justification request).
+	wait_for_best_beefy_blocks(dave_best_blocks, &net, &[1]).await;
+
+	// Give all tasks some cpu cycles to burn through their events queues,
+	run_for(Duration::from_millis(100), &net).await;
+	// then verify Dave catches up through on-demand justification requests.
+	let (dave_best_blocks, _) =
+		get_beefy_streams(&mut net.lock(), [(dave_index, BeefyKeyring::Dave)].into_iter());
+	client.finalize_block(hashes[6], None).unwrap();
+	client.finalize_block(hashes[10], None).unwrap();
+	client.finalize_block(hashes[17], None).unwrap();
+	client.finalize_block(hashes[24], None).unwrap();
+	client.finalize_block(hashes[26], None).unwrap();
+	wait_for_best_beefy_blocks(dave_best_blocks, &net, &[5, 10, 15, 20, 25]).await;
+}
+
+#[tokio::test]
+async fn should_initialize_voter_at_genesis() {
+	let keys = &[BeefyKeyring::Alice];
+	let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+	let mut net = BeefyTestNet::new(1);
+	let backend = net.peer(0).client().as_backend();
+
+	// push 15 blocks with `AuthorityChange` digests every 10 blocks
+	let hashes = net.generate_blocks_and_sync(15, 10, &validator_set, false).await;
+	let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse();
+	// finalize 13 without justifications
+	net.peer(0).client().as_client().finalize_block(hashes[13], None).unwrap();
+
+	let api = TestApi::with_validator_set(&validator_set);
+	// load persistent state - nothing in DB, should init at genesis
+	let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap();
+
+	// Test initialization at session boundary.
+	// verify voter initialized with two sessions starting at blocks 1 and 10
+	let sessions = persisted_state.voting_oracle().sessions();
+	assert_eq!(sessions.len(), 2);
+	assert_eq!(sessions[0].session_start(), 1);
+	assert_eq!(sessions[1].session_start(), 10);
+	let rounds = persisted_state.active_round().unwrap();
+	assert_eq!(rounds.session_start(), 1);
+	assert_eq!(rounds.validator_set_id(), validator_set.id());
+
+	// verify next vote target is mandatory block 1
+	assert_eq!(persisted_state.best_beefy_block(), 0);
+	assert_eq!(persisted_state.best_grandpa_number(), 13);
+	assert_eq!(persisted_state.voting_oracle().voting_target(), Some(1));
+
+	// verify state also saved to db
+	assert!(verify_persisted_version(&*backend));
+	let state = load_persistent(&*backend).unwrap().unwrap();
+	assert_eq!(state, persisted_state);
+}
+
+#[tokio::test]
+async fn should_initialize_voter_at_custom_genesis() {
+	let keys = &[BeefyKeyring::Alice];
+	let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+	let mut net = BeefyTestNet::new(1);
+	let backend = net.peer(0).client().as_backend();
+	// custom pallet genesis is block number 7
+	let custom_pallet_genesis = 7;
+	let api = TestApi::new(custom_pallet_genesis, &validator_set, GOOD_MMR_ROOT);
+
+	// push 15 blocks with `AuthorityChange` digests every 15 blocks
+	let hashes = net.generate_blocks_and_sync(15, 15, &validator_set, false).await;
+	let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse();
+	// finalize 3, 5, 8 without justifications
+	net.peer(0).client().as_client().finalize_block(hashes[3], None).unwrap();
+	net.peer(0).client().as_client().finalize_block(hashes[5], None).unwrap();
+	net.peer(0).client().as_client().finalize_block(hashes[8], None).unwrap();
+
+	// load persistent state - nothing in DB, should init at genesis
+	let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap();
+
+	// Test initialization at session boundary.
+	// verify voter initialized with single session starting at block `custom_pallet_genesis` (7)
+	let sessions = persisted_state.voting_oracle().sessions();
+	assert_eq!(sessions.len(), 1);
+	assert_eq!(sessions[0].session_start(), custom_pallet_genesis);
+	let rounds = persisted_state.active_round().unwrap();
+	assert_eq!(rounds.session_start(), custom_pallet_genesis);
+	assert_eq!(rounds.validator_set_id(), validator_set.id());
+
+	// verify next vote target is mandatory block 7
+	assert_eq!(persisted_state.best_beefy_block(), 0);
+	assert_eq!(persisted_state.best_grandpa_number(), 8);
+	assert_eq!(persisted_state.voting_oracle().voting_target(), Some(custom_pallet_genesis));
+
+	// verify state also saved to db
+	assert!(verify_persisted_version(&*backend));
+	let state = load_persistent(&*backend).unwrap().unwrap();
+	assert_eq!(state, persisted_state);
+
+	// now re-init after genesis changes
+
+	// should ignore existing aux db state and reinit at new genesis
+	let new_validator_set = ValidatorSet::new(make_beefy_ids(keys), 42).unwrap();
+	let new_pallet_genesis = 10;
+	let api = TestApi::new(new_pallet_genesis, &new_validator_set, GOOD_MMR_ROOT);
+
+	net.peer(0).client().as_client().finalize_block(hashes[10], None).unwrap();
+	// load persistent state - state preset in DB, but with different pallet genesis
+	let new_persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap();
+
+	// verify voter initialized with single session starting at block `new_pallet_genesis` (10)
+	let sessions = new_persisted_state.voting_oracle().sessions();
+	assert_eq!(sessions.len(), 1);
+	assert_eq!(sessions[0].session_start(), new_pallet_genesis);
+	let rounds = new_persisted_state.active_round().unwrap();
+	assert_eq!(rounds.session_start(), new_pallet_genesis);
+	assert_eq!(rounds.validator_set_id(), new_validator_set.id());
+
+	// verify next vote target is mandatory block 10
+	assert_eq!(new_persisted_state.best_beefy_block(), 0);
+	assert_eq!(new_persisted_state.best_grandpa_number(), 10);
+	assert_eq!(new_persisted_state.voting_oracle().voting_target(), Some(new_pallet_genesis));
+
+	// verify state also saved to db
+	assert!(verify_persisted_version(&*backend));
+	let state = load_persistent(&*backend).unwrap().unwrap();
+	assert_eq!(state, new_persisted_state);
+}
+
+#[tokio::test]
+async fn should_initialize_voter_when_last_final_is_session_boundary() {
+	let keys = &[BeefyKeyring::Alice];
+	let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+	let mut net = BeefyTestNet::new(1);
+	let backend = net.peer(0).client().as_backend();
+
+	// push 15 blocks with `AuthorityChange` digests every 10 blocks
+	let hashes = net.generate_blocks_and_sync(15, 10, &validator_set, false).await;
+
+	let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse();
+
+	// finalize 13 without justifications
+	net.peer(0).client().as_client().finalize_block(hashes[13], None).unwrap();
+
+	// import/append BEEFY justification for session boundary block 10
+	let commitment = Commitment {
+		payload: Payload::from_single_entry(known_payloads::MMR_ROOT_ID, vec![]),
+		block_number: 10,
+		validator_set_id: validator_set.id(),
+	};
+	let justif = VersionedFinalityProof::<_, Signature>::V1(SignedCommitment {
+		commitment,
+		signatures: vec![None],
+	});
+	backend
+		.append_justification(hashes[10], (BEEFY_ENGINE_ID, justif.encode()))
+		.unwrap();
+
+	// Test corner-case where session boundary == last beefy finalized,
+	// expect rounds initialized at last beefy finalized 10.
+
+	let api = TestApi::with_validator_set(&validator_set);
+	// load persistent state - nothing in DB, should init at session boundary
+	let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap();
+
+	// verify voter initialized with single session starting at block 10
+	assert_eq!(persisted_state.voting_oracle().sessions().len(), 1);
+	let rounds = persisted_state.active_round().unwrap();
+	assert_eq!(rounds.session_start(), 10);
+	assert_eq!(rounds.validator_set_id(), validator_set.id());
+
+	// verify block 10 is correctly marked as finalized
+	assert_eq!(persisted_state.best_beefy_block(), 10);
+	assert_eq!(persisted_state.best_grandpa_number(), 13);
+	// verify next vote target is diff-power-of-two block 12
+	assert_eq!(persisted_state.voting_oracle().voting_target(), Some(12));
+
+	// verify state also saved to db
+	assert!(verify_persisted_version(&*backend));
+	let state = load_persistent(&*backend).unwrap().unwrap();
+	assert_eq!(state, persisted_state);
+}
+
+#[tokio::test]
+async fn should_initialize_voter_at_latest_finalized() {
+	let keys = &[BeefyKeyring::Alice];
+	let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+	let mut net = BeefyTestNet::new(1);
+	let backend = net.peer(0).client().as_backend();
+
+	// push 15 blocks with `AuthorityChange` digests every 10 blocks
+	let hashes = net.generate_blocks_and_sync(15, 10, &validator_set, false).await;
+
+	let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse();
+
+	// finalize 13 without justifications
+	net.peer(0).client().as_client().finalize_block(hashes[13], None).unwrap();
+
+	// import/append BEEFY justification for block 12
+	let commitment = Commitment {
+		payload: Payload::from_single_entry(known_payloads::MMR_ROOT_ID, vec![]),
+		block_number: 12,
+		validator_set_id: validator_set.id(),
+	};
+	let justif = VersionedFinalityProof::<_, Signature>::V1(SignedCommitment {
+		commitment,
+		signatures: vec![None],
+	});
+	backend
+		.append_justification(hashes[12], (BEEFY_ENGINE_ID, justif.encode()))
+		.unwrap();
+
+	// Test initialization at last BEEFY finalized.
+
+	let api = TestApi::with_validator_set(&validator_set);
+	// load persistent state - nothing in DB, should init at last BEEFY finalized
+	let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap();
+
+	// verify voter initialized with single session starting at block 12
+	assert_eq!(persisted_state.voting_oracle().sessions().len(), 1);
+	let rounds = persisted_state.active_round().unwrap();
+	assert_eq!(rounds.session_start(), 12);
+	assert_eq!(rounds.validator_set_id(), validator_set.id());
+
+	// verify next vote target is 13
+	assert_eq!(persisted_state.best_beefy_block(), 12);
+	assert_eq!(persisted_state.best_grandpa_number(), 13);
+	assert_eq!(persisted_state.voting_oracle().voting_target(), Some(13));
+
+	// verify state also saved to db
+	assert!(verify_persisted_version(&*backend));
+	let state = load_persistent(&*backend).unwrap().unwrap();
+	assert_eq!(state, persisted_state);
+}
+
+#[tokio::test]
+async fn beefy_finalizing_after_pallet_genesis() {
+	sp_tracing::try_init_simple();
+
+	let peers = [BeefyKeyring::Alice, BeefyKeyring::Bob];
+	let validator_set = ValidatorSet::new(make_beefy_ids(&peers), 14).unwrap();
+	let session_len = 10;
+	let min_block_delta = 1;
+	let pallet_genesis = 15;
+
+	let mut net = BeefyTestNet::new(2);
+
+	let api = Arc::new(TestApi::new(pallet_genesis, &validator_set, GOOD_MMR_ROOT));
+	let beefy_peers = peers.iter().enumerate().map(|(id, key)| (id, key, api.clone())).collect();
+	tokio::spawn(initialize_beefy(&mut net, beefy_peers, min_block_delta));
+
+	// push 42 blocks including `AuthorityChange` digests every 10 blocks.
+	let hashes = net.generate_blocks_and_sync(42, session_len, &validator_set, true).await;
+
+	let net = Arc::new(Mutex::new(net));
+	let peers = peers.into_iter().enumerate();
+
+	// Minimum BEEFY block delta is 1.
+
+	// GRANDPA finalize blocks leading up to BEEFY pallet genesis -> BEEFY should finalize nothing.
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[14], &[]).await;
+
+	// GRANDPA finalize block #16 -> BEEFY should finalize #15 (genesis mandatory) and #16.
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[16], &[15, 16]).await;
+
+	// GRANDPA finalize #21 -> BEEFY finalize #20 (mandatory) and #21
+	finalize_block_and_wait_for_beefy(&net, peers.clone(), &hashes[21], &[20, 21]).await;
+}
+
+#[tokio::test]
+async fn beefy_reports_equivocations() {
+	sp_tracing::try_init_simple();
+
+	let peers = [BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie];
+	let validator_set = ValidatorSet::new(make_beefy_ids(&peers), 0).unwrap();
+	let session_len = 10;
+	let min_block_delta = 4;
+
+	let mut net = BeefyTestNet::new(3);
+
+	// Alice votes on good MMR roots, equivocations are allowed/expected.
+	let mut api_alice = TestApi::with_validator_set(&validator_set);
+	api_alice.allow_equivocations();
+	let api_alice = Arc::new(api_alice);
+	let alice = (0, &BeefyKeyring::Alice, api_alice.clone());
+	tokio::spawn(initialize_beefy(&mut net, vec![alice], min_block_delta));
+
+	// Bob votes on bad MMR roots, equivocations are allowed/expected.
+	let mut api_bob = TestApi::new(1, &validator_set, BAD_MMR_ROOT);
+	api_bob.allow_equivocations();
+	let api_bob = Arc::new(api_bob);
+	let bob = (1, &BeefyKeyring::Bob, api_bob.clone());
+	tokio::spawn(initialize_beefy(&mut net, vec![bob], min_block_delta));
+
+	// We spawn another node voting with Bob key, on alternate bad MMR roots (equivocating).
+	// Equivocations are allowed/expected.
+	let mut api_bob_prime = TestApi::new(1, &validator_set, ALTERNATE_BAD_MMR_ROOT);
+	api_bob_prime.allow_equivocations();
+	let api_bob_prime = Arc::new(api_bob_prime);
+	let bob_prime = (2, &BeefyKeyring::Bob, api_bob_prime.clone());
+	tokio::spawn(initialize_beefy(&mut net, vec![bob_prime], min_block_delta));
+
+	// push 42 blocks including `AuthorityChange` digests every 10 blocks.
+	let hashes = net.generate_blocks_and_sync(42, session_len, &validator_set, false).await;
+
+	let net = Arc::new(Mutex::new(net));
+
+	// Minimum BEEFY block delta is 4.
+
+	let peers = peers.into_iter().enumerate();
+	// finalize block #1 -> BEEFY should not finalize anything (each node votes on different MMR).
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
+	peers.clone().for_each(|(index, _)| {
+		let client = net.lock().peer(index).client().as_client();
+		client.finalize_block(hashes[1], None).unwrap();
+	});
+
+	// run for up to 5 seconds waiting for Alice's report of Bob/Bob_Prime equivocation.
+	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
+		}
+	}
+
+	// Verify expected equivocation
+	let alice_reported_equivocations = api_alice.reported_equivocations.as_ref().unwrap().lock();
+	assert_eq!(alice_reported_equivocations.len(), 1);
+	let equivocation_proof = alice_reported_equivocations.get(0).unwrap();
+	assert_eq!(equivocation_proof.first.id, BeefyKeyring::Bob.public());
+	assert_eq!(equivocation_proof.first.commitment.block_number, 1);
+
+	// Verify neither Bob or Bob_Prime report themselves as equivocating.
+	assert!(api_bob.reported_equivocations.as_ref().unwrap().lock().is_empty());
+	assert!(api_bob_prime.reported_equivocations.as_ref().unwrap().lock().is_empty());
+
+	// sanity verify no new blocks have been finalized by BEEFY
+	streams_empty_after_timeout(best_blocks, &net, None).await;
+	streams_empty_after_timeout(versioned_finality_proof, &net, None).await;
+}
+
+#[tokio::test]
+async fn gossipped_finality_proofs() {
+	sp_tracing::try_init_simple();
+
+	let validators = [BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie];
+	// Only Alice and Bob are running the voter -> finality threshold not reached
+	let peers = [BeefyKeyring::Alice, BeefyKeyring::Bob];
+	let validator_set = ValidatorSet::new(make_beefy_ids(&validators), 0).unwrap();
+	let session_len = 30;
+	let min_block_delta = 1;
+
+	let mut net = BeefyTestNet::new(3);
+	let api = Arc::new(TestApi::with_validator_set(&validator_set));
+	let beefy_peers = peers.iter().enumerate().map(|(id, key)| (id, key, api.clone())).collect();
+
+	let charlie = &net.peers[2];
+	let known_peers = Arc::new(Mutex::new(KnownPeers::<Block>::new()));
+	// Charlie will run just the gossip engine and not the full voter.
+	let (gossip_validator, _) = GossipValidator::new(known_peers);
+	let charlie_gossip_validator = Arc::new(gossip_validator);
+	charlie_gossip_validator.update_filter(GossipFilterCfg::<Block> {
+		start: 1,
+		end: 10,
+		validator_set: &validator_set,
+	});
+	let mut charlie_gossip_engine = sc_network_gossip::GossipEngine::new(
+		charlie.network_service().clone(),
+		charlie.sync_service().clone(),
+		beefy_gossip_proto_name(),
+		charlie_gossip_validator.clone(),
+		None,
+	);
+
+	// Alice and Bob run full voter.
+	tokio::spawn(initialize_beefy(&mut net, beefy_peers, min_block_delta));
+
+	let net = Arc::new(Mutex::new(net));
+
+	// Pump net + Charlie gossip to see peers.
+	let timeout = Box::pin(tokio::time::sleep(Duration::from_millis(200)));
+	let gossip_engine_pump = &mut charlie_gossip_engine;
+	let pump_with_timeout = future::select(gossip_engine_pump, timeout);
+	run_until(pump_with_timeout, &net).await;
+
+	// push 10 blocks
+	let hashes = net.lock().generate_blocks_and_sync(10, session_len, &validator_set, true).await;
+
+	let peers = peers.into_iter().enumerate();
+
+	// Alice, Bob and Charlie finalize #1, Alice and Bob vote on it, but not Charlie.
+	let finalize = hashes[1];
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
+	net.lock().peer(0).client().as_client().finalize_block(finalize, None).unwrap();
+	net.lock().peer(1).client().as_client().finalize_block(finalize, None).unwrap();
+	net.lock().peer(2).client().as_client().finalize_block(finalize, None).unwrap();
+	// verify nothing gets finalized by BEEFY
+	let timeout = Box::pin(tokio::time::sleep(Duration::from_millis(100)));
+	let pump_net = futures::future::poll_fn(|cx| {
+		net.lock().poll(cx);
+		Poll::<()>::Pending
+	});
+	let pump_gossip = &mut charlie_gossip_engine;
+	let pump_with_timeout = future::select(pump_gossip, future::select(pump_net, timeout));
+	streams_empty_after_future(best_blocks, Some(pump_with_timeout)).await;
+	streams_empty_after_timeout(versioned_finality_proof, &net, None).await;
+
+	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 encoded_proof = gossip_proof.encode();
+	charlie_gossip_engine.gossip_message(proofs_topic::<Block>(), encoded_proof, true);
+	// Expect #1 is finalized.
+	wait_for_best_beefy_blocks(best_blocks, &net, &[1]).await;
+	wait_for_beefy_signed_commitments(versioned_finality_proof, &net, &[1]).await;
+
+	// Code above verifies gossipped finality proofs are correctly imported and consumed by voters.
+	// Next, let's verify finality proofs are correctly generated and gossipped by voters.
+
+	// Everyone finalizes #2
+	let block_number = 2u64;
+	let finalize = hashes[block_number as usize];
+	let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone());
+	net.lock().peer(0).client().as_client().finalize_block(finalize, None).unwrap();
+	net.lock().peer(1).client().as_client().finalize_block(finalize, None).unwrap();
+	net.lock().peer(2).client().as_client().finalize_block(finalize, None).unwrap();
+
+	// Simulate Charlie vote on #2
+	let header = net.lock().peer(2).client().as_client().expect_header(finalize).unwrap();
+	let mmr_root = find_mmr_root_digest::<Block>(&header).unwrap();
+	let payload = Payload::from_single_entry(known_payloads::MMR_ROOT_ID, mmr_root.encode());
+	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();
+	charlie_gossip_engine.gossip_message(votes_topic::<Block>(), encoded_vote, true);
+
+	// Expect #2 is finalized.
+	wait_for_best_beefy_blocks(best_blocks, &net, &[2]).await;
+	wait_for_beefy_signed_commitments(versioned_finality_proof, &net, &[2]).await;
+
+	// Now verify Charlie also sees the gossipped proof generated by either Alice or Bob.
+	let mut charlie_gossip_proofs = Box::pin(
+		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),
+					},
+				)
+			})
+			.fuse(),
+	);
+	loop {
+		let pump_net = futures::future::poll_fn(|cx| {
+			net.lock().poll(cx);
+			Poll::<()>::Pending
+		});
+		let mut gossip_engine = &mut charlie_gossip_engine;
+		futures::select! {
+			// pump gossip engine
+			_ = gossip_engine => unreachable!(),
+			// pump network
+			_ = pump_net.fuse() => unreachable!(),
+			// 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);
+				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
+					_ => panic!("Charlie got unexpected finality proof"),
+				}
+			},
+		}
+	}
+}
diff --git a/substrate/client/consensus/beefy/src/worker.rs b/substrate/client/consensus/beefy/src/worker.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d3845a270368f89ca73f16f333e54acd95a99d4
--- /dev/null
+++ b/substrate/client/consensus/beefy/src/worker.rs
@@ -0,0 +1,1648 @@
+// 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::{
+	communication::{
+		gossip::{proofs_topic, votes_topic, GossipFilterCfg, GossipMessage, GossipValidator},
+		peers::PeerReport,
+		request_response::outgoing_requests_engine::{OnDemandJustificationsEngine, ResponseInfo},
+	},
+	error::Error,
+	justification::BeefyVersionedFinalityProof,
+	keystore::{BeefyKeystore, BeefySignatureHasher},
+	metric_inc, metric_set,
+	metrics::VoterMetrics,
+	round::{Rounds, VoteImportResult},
+	BeefyVoterLinks, LOG_TARGET,
+};
+use codec::{Codec, Decode, DecodeAll, Encode};
+use futures::{stream::Fuse, FutureExt, StreamExt};
+use log::{debug, error, info, log_enabled, trace, warn};
+use sc_client_api::{Backend, FinalityNotification, FinalityNotifications, HeaderBackend};
+use sc_network_gossip::GossipEngine;
+use sc_utils::{mpsc::TracingUnboundedReceiver, notification::NotificationReceiver};
+use sp_api::{BlockId, ProvideRuntimeApi};
+use sp_arithmetic::traits::{AtLeast32Bit, Saturating};
+use sp_consensus::SyncOracle;
+use sp_consensus_beefy::{
+	check_equivocation_proof,
+	ecdsa_crypto::{AuthorityId, Signature},
+	BeefyApi, Commitment, ConsensusLog, EquivocationProof, PayloadProvider, ValidatorSet,
+	VersionedFinalityProof, VoteMessage, BEEFY_ENGINE_ID,
+};
+use sp_runtime::{
+	generic::OpaqueDigestItemId,
+	traits::{Block, Header, NumberFor, Zero},
+	SaturatedConversion,
+};
+use std::{
+	collections::{BTreeMap, BTreeSet, VecDeque},
+	fmt::Debug,
+	sync::Arc,
+};
+
+/// Bound for the number of pending justifications - use 2400 - the max number
+/// of justifications possible in a single session.
+const MAX_BUFFERED_JUSTIFICATIONS: usize = 2400;
+
+pub(crate) enum RoundAction {
+	Drop,
+	Process,
+	Enqueue,
+}
+
+/// Responsible for the voting strategy.
+/// It chooses which incoming votes to accept and which votes to generate.
+/// Keeps track of voting seen for current and future rounds.
+///
+/// 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> {
+	/// Queue of known sessions. Keeps track of voting rounds (block numbers) within each session.
+	///
+	/// There are three voter states coresponding to three queue states:
+	/// 1. voter uninitialized: queue empty,
+	/// 2. up-to-date - all mandatory blocks leading up to current GRANDPA finalized: queue has ONE
+	///    element, the 'current session' where `mandatory_done == true`,
+	/// 3. lagging behind GRANDPA: queue has [1, N] elements, where all `mandatory_done == false`.
+	///    In this state, everytime 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>>,
+	/// 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>,
+}
+
+impl<B: Block> VoterOracle<B> {
+	/// Verify provided `sessions` satisfies requirements, then build `VoterOracle`.
+	pub fn checked_new(
+		sessions: VecDeque<Rounds<B>>,
+		min_block_delta: u32,
+		grandpa_header: <B as Block>::Header,
+		best_beefy: NumberFor<B>,
+	) -> Option<Self> {
+		let mut prev_start = Zero::zero();
+		let mut prev_validator_id = None;
+		// verifies the
+		let mut validate = || -> bool {
+			let best_grandpa = *grandpa_header.number();
+			if sessions.is_empty() || best_beefy > best_grandpa {
+				return false
+			}
+			for (idx, session) in sessions.iter().enumerate() {
+				let start = session.session_start();
+				if session.validators().is_empty() {
+					return false
+				}
+				if start > best_grandpa || start <= prev_start {
+					return false
+				}
+				#[cfg(not(test))]
+				if let Some(prev_id) = prev_validator_id {
+					if session.validator_set_id() <= prev_id {
+						return false
+					}
+				}
+				if idx != 0 && session.mandatory_done() {
+					return false
+				}
+				prev_start = session.session_start();
+				prev_validator_id = Some(session.validator_set_id());
+			}
+			true
+		};
+		if validate() {
+			Some(VoterOracle {
+				sessions,
+				// Always target at least one block better than current best beefy.
+				min_block_delta: min_block_delta.max(1),
+				best_grandpa_block_header: grandpa_header,
+				best_beefy_block: best_beefy,
+			})
+		} else {
+			error!(
+				target: LOG_TARGET,
+				"🥩 Invalid sessions queue: {:?}; best-beefy {:?} best-grandpa-header {:?}.",
+				sessions,
+				best_beefy,
+				grandpa_header
+			);
+			None
+		}
+	}
+
+	// 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> {
+		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> {
+		self.sessions.front_mut().ok_or(Error::UninitSession)
+	}
+
+	fn current_validator_set(&self) -> Result<&ValidatorSet<AuthorityId>, Error> {
+		self.active_rounds().map(|r| r.validator_set())
+	}
+
+	// Prune the sessions queue to keep the Oracle in one of the expected three states.
+	//
+	// To be called on each BEEFY finality and on each new rounds/session addition.
+	fn try_prune(&mut self) {
+		if self.sessions.len() > 1 {
+			// when there's multiple sessions, only keep the `!mandatory_done()` ones.
+			self.sessions.retain(|s| !s.mandatory_done())
+		}
+	}
+
+	/// Add new observed session to the Oracle.
+	pub fn add_session(&mut self, rounds: Rounds<B>) {
+		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();
+	}
+
+	/// Finalize a particular block.
+	pub fn finalize(&mut self, block: NumberFor<B>) -> Result<(), Error> {
+		// Conclude voting round for this block.
+		self.active_rounds_mut()?.conclude(block);
+		// Prune any now "finalized" sessions from queue.
+		self.try_prune();
+		Ok(())
+	}
+
+	/// Return current pending mandatory block, if any, plus its active validator set.
+	pub fn mandatory_pending(&self) -> Option<(NumberFor<B>, ValidatorSet<AuthorityId>)> {
+		self.sessions.front().and_then(|round| {
+			if round.mandatory_done() {
+				None
+			} else {
+				Some((round.session_start(), round.validator_set().clone()))
+			}
+		})
+	}
+
+	/// Return `(A, B)` tuple representing inclusive [A, B] interval of votes to accept.
+	pub fn accepted_interval(&self) -> Result<(NumberFor<B>, NumberFor<B>), Error> {
+		let rounds = self.sessions.front().ok_or(Error::UninitSession)?;
+
+		if rounds.mandatory_done() {
+			// There's only one session active and its mandatory is done.
+			// Accept any vote for a GRANDPA finalized block in a better round.
+			Ok((
+				rounds.session_start().max(self.best_beefy_block),
+				(*self.best_grandpa_block_header.number()).into(),
+			))
+		} else {
+			// Current session has mandatory not done.
+			// Only accept votes for the mandatory block in the front of queue.
+			Ok((rounds.session_start(), rounds.session_start()))
+		}
+	}
+
+	/// Utility function to quickly decide what to do for each round.
+	pub fn triage_round(&self, round: NumberFor<B>) -> Result<RoundAction, Error> {
+		let (start, end) = self.accepted_interval()?;
+		if start <= round && round <= end {
+			Ok(RoundAction::Process)
+		} else if round > end {
+			Ok(RoundAction::Enqueue)
+		} else {
+			Ok(RoundAction::Drop)
+		}
+	}
+
+	/// Return `Some(number)` if we should be voting on block `number`,
+	/// return `None` if there is no block we should vote on.
+	pub fn voting_target(&self) -> Option<NumberFor<B>> {
+		let rounds = if let Some(r) = self.sessions.front() {
+			r
+		} else {
+			debug!(target: LOG_TARGET, "🥩 No voting round started");
+			return None
+		};
+		let best_grandpa = *self.best_grandpa_block_header.number();
+		let best_beefy = self.best_beefy_block;
+
+		// `target` is guaranteed > `best_beefy` since `min_block_delta` is at least `1`.
+		let target =
+			vote_target(best_grandpa, best_beefy, rounds.session_start(), self.min_block_delta);
+		trace!(
+			target: LOG_TARGET,
+			"🥩 best beefy: #{:?}, best finalized: #{:?}, current_vote_target: {:?}",
+			best_beefy,
+			best_grandpa,
+			target
+		);
+		target
+	}
+}
+
+/// BEEFY voter state persisted in aux DB.
+///
+/// Note: Any changes here should also bump aux-db schema version.
+#[derive(Debug, Decode, Encode, PartialEq)]
+pub(crate) struct PersistedState<B: Block> {
+	/// 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>,
+	/// Pallet-beefy genesis block - block number when BEEFY consensus started for this chain.
+	pallet_genesis: NumberFor<B>,
+}
+
+impl<B: Block> PersistedState<B> {
+	pub fn checked_new(
+		grandpa_header: <B as Block>::Header,
+		best_beefy: NumberFor<B>,
+		sessions: VecDeque<Rounds<B>>,
+		min_block_delta: u32,
+		pallet_genesis: NumberFor<B>,
+	) -> Option<Self> {
+		VoterOracle::checked_new(sessions, min_block_delta, grandpa_header, best_beefy).map(
+			|voting_oracle| PersistedState {
+				best_voted: Zero::zero(),
+				voting_oracle,
+				pallet_genesis,
+			},
+		)
+	}
+
+	pub fn pallet_genesis(&self) -> NumberFor<B> {
+		self.pallet_genesis
+	}
+
+	pub(crate) fn set_min_block_delta(&mut self, min_block_delta: u32) {
+		self.voting_oracle.min_block_delta = min_block_delta.max(1);
+	}
+
+	pub(crate) fn set_best_beefy(&mut self, best_beefy: NumberFor<B>) {
+		self.voting_oracle.best_beefy_block = best_beefy;
+	}
+
+	pub(crate) fn set_best_grandpa(&mut self, best_grandpa: <B as Block>::Header) {
+		self.voting_oracle.best_grandpa_block_header = best_grandpa;
+	}
+
+	pub(crate) fn gossip_filter_config(&self) -> Result<GossipFilterCfg<B>, Error> {
+		let (start, end) = self.voting_oracle.accepted_interval()?;
+		let validator_set = self.voting_oracle.current_validator_set()?;
+		Ok(GossipFilterCfg { start, end, validator_set })
+	}
+}
+
+/// A BEEFY worker plays the BEEFY protocol
+pub(crate) struct BeefyWorker<B: Block, BE, P, RuntimeApi, S> {
+	// utilities
+	pub backend: Arc<BE>,
+	pub payload_provider: P,
+	pub runtime: Arc<RuntimeApi>,
+	pub sync: Arc<S>,
+	pub key_store: BeefyKeystore,
+
+	// communication
+	pub gossip_engine: GossipEngine<B>,
+	pub gossip_validator: Arc<GossipValidator<B>>,
+	pub gossip_report_stream: TracingUnboundedReceiver<PeerReport>,
+	pub on_demand_justifications: OnDemandJustificationsEngine<B>,
+
+	// channels
+	/// Links between the block importer, the background voter and the RPC layer.
+	pub links: BeefyVoterLinks<B>,
+
+	// voter state
+	/// BEEFY client metrics.
+	pub metrics: Option<VoterMetrics>,
+	/// Buffer holding justifications for future processing.
+	pub pending_justifications: BTreeMap<NumberFor<B>, BeefyVersionedFinalityProof<B>>,
+	/// Persisted voter state.
+	pub persisted_state: PersistedState<B>,
+}
+
+impl<B, BE, P, R, S> BeefyWorker<B, BE, P, R, S>
+where
+	B: Block + Codec,
+	BE: Backend<B>,
+	P: PayloadProvider<B>,
+	S: SyncOracle,
+	R: ProvideRuntimeApi<B>,
+	R::Api: BeefyApi<B, AuthorityId>,
+{
+	fn best_grandpa_block(&self) -> NumberFor<B> {
+		*self.persisted_state.voting_oracle.best_grandpa_block_header.number()
+	}
+
+	fn voting_oracle(&self) -> &VoterOracle<B> {
+		&self.persisted_state.voting_oracle
+	}
+
+	fn active_rounds(&mut self) -> Result<&Rounds<B>, Error> {
+		self.persisted_state.voting_oracle.active_rounds()
+	}
+
+	/// Verify `active` validator set for `block` against the key store
+	///
+	/// We want to make sure that we have _at least one_ key in our keystore that
+	/// is part of the validator set, that's because if there are no local keys
+	/// then we can't perform our job as a validator.
+	///
+	/// Note that for a non-authority node there will be no keystore, and we will
+	/// return an error and don't check. The error can usually be ignored.
+	fn verify_validator_set(
+		&self,
+		block: &NumberFor<B>,
+		active: &ValidatorSet<AuthorityId>,
+	) -> Result<(), Error> {
+		let active: BTreeSet<&AuthorityId> = active.validators().iter().collect();
+
+		let public_keys = self.key_store.public_keys()?;
+		let store: BTreeSet<&AuthorityId> = public_keys.iter().collect();
+
+		if store.intersection(&active).count() == 0 {
+			let msg = "no authority public key found in store".to_string();
+			debug!(target: LOG_TARGET, "🥩 for block {:?} {}", block, msg);
+			metric_inc!(self, beefy_no_authority_found_in_store);
+			Err(Error::Keystore(msg))
+		} else {
+			Ok(())
+		}
+	}
+
+	/// Handle session changes by starting new voting round for mandatory blocks.
+	fn init_session_at(
+		&mut self,
+		validator_set: ValidatorSet<AuthorityId>,
+		new_session_start: NumberFor<B>,
+	) {
+		debug!(target: LOG_TARGET, "🥩 New active validator set: {:?}", validator_set);
+
+		// BEEFY should finalize a mandatory block during each session.
+		if let Ok(active_session) = self.active_rounds() {
+			if !active_session.mandatory_done() {
+				debug!(
+					target: LOG_TARGET,
+					"🥩 New session {} while active session {} is still lagging.",
+					validator_set.id(),
+					active_session.validator_set_id(),
+				);
+				metric_inc!(self, beefy_lagging_sessions);
+			}
+		}
+
+		if log_enabled!(target: LOG_TARGET, log::Level::Debug) {
+			// verify the new validator set - only do it if we're also logging the warning
+			let _ = self.verify_validator_set(&new_session_start, &validator_set);
+		}
+
+		let id = validator_set.id();
+		self.persisted_state
+			.voting_oracle
+			.add_session(Rounds::new(new_session_start, validator_set));
+		metric_set!(self, beefy_validator_set_id, id);
+		info!(
+			target: LOG_TARGET,
+			"🥩 New Rounds for validator set id: {:?} with session_start {:?}",
+			id,
+			new_session_start
+		);
+	}
+
+	fn handle_finality_notification(
+		&mut self,
+		notification: &FinalityNotification<B>,
+	) -> Result<(), Error> {
+		debug!(
+			target: LOG_TARGET,
+			"🥩 Finality notification: header {:?} tree_route {:?}",
+			notification.header,
+			notification.tree_route,
+		);
+		let header = &notification.header;
+
+		self.runtime
+			.runtime_api()
+			.beefy_genesis(header.hash())
+			.ok()
+			.flatten()
+			.filter(|genesis| *genesis == self.persisted_state.pallet_genesis)
+			.ok_or(Error::ConsensusReset)?;
+
+		if *header.number() > self.best_grandpa_block() {
+			// update best GRANDPA finalized block we have seen
+			self.persisted_state.set_best_grandpa(header.clone());
+
+			// Check all (newly) finalized blocks for new session(s).
+			let backend = self.backend.clone();
+			for header in notification
+				.tree_route
+				.iter()
+				.map(|hash| {
+					backend
+						.blockchain()
+						.expect_header(*hash)
+						.expect("just finalized block should be available; qed.")
+				})
+				.chain(std::iter::once(header.clone()))
+			{
+				if let Some(new_validator_set) = find_authorities_change::<B>(&header) {
+					self.init_session_at(new_validator_set, *header.number());
+				}
+			}
+
+			// Update gossip validator votes filter.
+			if let Err(e) = self
+				.persisted_state
+				.gossip_filter_config()
+				.map(|filter| self.gossip_validator.update_filter(filter))
+			{
+				error!(target: LOG_TARGET, "🥩 Voter error: {:?}", e);
+			}
+		}
+
+		Ok(())
+	}
+
+	/// 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> {
+		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 encoded_proof = gossip_proof.encode();
+					self.gossip_engine.gossip_message(proofs_topic::<B>(), encoded_proof, true);
+				},
+			RoundAction::Drop => metric_inc!(self, beefy_stale_votes),
+			RoundAction::Enqueue => error!(target: LOG_TARGET, "🥩 unexpected vote: {:?}.", vote),
+		};
+		Ok(())
+	}
+
+	/// Based on [VoterOracle] this justification is either processed here or enqueued for later.
+	///
+	/// Expects `justification` to be valid.
+	fn triage_incoming_justif(
+		&mut self,
+		justification: BeefyVersionedFinalityProof<B>,
+	) -> Result<(), Error> {
+		let signed_commitment = match justification {
+			VersionedFinalityProof::V1(ref sc) => sc,
+		};
+		let block_num = signed_commitment.commitment.block_number;
+		match self.voting_oracle().triage_round(block_num)? {
+			RoundAction::Process => {
+				debug!(target: LOG_TARGET, "🥩 Process justification for round: {:?}.", block_num);
+				metric_inc!(self, beefy_imported_justifications);
+				self.finalize(justification)?
+			},
+			RoundAction::Enqueue => {
+				debug!(target: LOG_TARGET, "🥩 Buffer justification for round: {:?}.", block_num);
+				if self.pending_justifications.len() < MAX_BUFFERED_JUSTIFICATIONS {
+					self.pending_justifications.entry(block_num).or_insert(justification);
+					metric_inc!(self, beefy_buffered_justifications);
+				} else {
+					metric_inc!(self, beefy_buffered_justifications_dropped);
+					warn!(
+						target: LOG_TARGET,
+						"🥩 Buffer justification dropped for round: {:?}.", block_num
+					);
+				}
+			},
+			RoundAction::Drop => metric_inc!(self, beefy_stale_justifications),
+		};
+		Ok(())
+	}
+
+	fn handle_vote(
+		&mut self,
+		vote: VoteMessage<NumberFor<B>, AuthorityId, Signature>,
+	) -> Result<Option<BeefyVersionedFinalityProof<B>>, Error> {
+		let rounds = self.persisted_state.voting_oracle.active_rounds_mut()?;
+
+		let block_number = vote.commitment.block_number;
+		match rounds.add_vote(vote) {
+			VoteImportResult::RoundConcluded(signed_commitment) => {
+				let finality_proof = VersionedFinalityProof::V1(signed_commitment);
+				info!(
+					target: LOG_TARGET,
+					"🥩 Round #{} concluded, finality_proof: {:?}.", block_number, finality_proof
+				);
+				// We created the `finality_proof` and know to be valid.
+				// New state is persisted after finalization.
+				self.finalize(finality_proof.clone())?;
+				metric_inc!(self, beefy_good_votes_processed);
+				return Ok(Some(finality_proof))
+			},
+			VoteImportResult::Ok => {
+				// Persist state after handling mandatory block vote.
+				if self
+					.voting_oracle()
+					.mandatory_pending()
+					.map(|(mandatory_num, _)| mandatory_num == block_number)
+					.unwrap_or(false)
+				{
+					crate::aux_schema::write_voter_state(&*self.backend, &self.persisted_state)
+						.map_err(|e| Error::Backend(e.to_string()))?;
+				}
+				metric_inc!(self, beefy_good_votes_processed);
+			},
+			VoteImportResult::Equivocation(proof) => {
+				metric_inc!(self, beefy_equivocation_votes);
+				self.report_equivocation(proof)?;
+			},
+			VoteImportResult::Invalid => metric_inc!(self, beefy_invalid_votes),
+			VoteImportResult::Stale => metric_inc!(self, beefy_stale_votes),
+		};
+		Ok(None)
+	}
+
+	/// Provide BEEFY finality for block based on `finality_proof`:
+	/// 1. Prune now-irrelevant past sessions from the oracle,
+	/// 2. Set BEEFY best block,
+	/// 3. Persist voter state,
+	/// 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> {
+		let block_num = match finality_proof {
+			VersionedFinalityProof::V1(ref sc) => sc.commitment.block_number,
+		};
+
+		// Finalize inner round and update voting_oracle state.
+		self.persisted_state.voting_oracle.finalize(block_num)?;
+
+		// Set new best BEEFY block number.
+		self.persisted_state.set_best_beefy(block_num);
+		crate::aux_schema::write_voter_state(&*self.backend, &self.persisted_state)
+			.map_err(|e| Error::Backend(e.to_string()))?;
+
+		metric_set!(self, beefy_best_block, block_num);
+
+		self.on_demand_justifications.cancel_requests_older_than(block_num);
+
+		if let Err(e) = self
+			.backend
+			.blockchain()
+			.expect_block_hash_from_id(&BlockId::Number(block_num))
+			.and_then(|hash| {
+				self.links
+					.to_rpc_best_block_sender
+					.notify(|| Ok::<_, ()>(hash))
+					.expect("forwards closure result; the closure always returns Ok; qed.");
+
+				self.backend
+					.append_justification(hash, (BEEFY_ENGINE_ID, finality_proof.encode()))
+			}) {
+			error!(
+				target: LOG_TARGET,
+				"🥩 Error {:?} on appending justification: {:?}", e, finality_proof
+			);
+		}
+
+		self.links
+			.to_rpc_justif_sender
+			.notify(|| Ok::<_, ()>(finality_proof))
+			.expect("forwards closure result; the closure always returns Ok; qed.");
+
+		// Update gossip validator votes filter.
+		self.persisted_state
+			.gossip_filter_config()
+			.map(|filter| self.gossip_validator.update_filter(filter))?;
+		Ok(())
+	}
+
+	/// Handle previously buffered justifications, that now land in the voting interval.
+	fn try_pending_justififactions(&mut self) -> Result<(), Error> {
+		// Interval of blocks for which we can process justifications and votes right now.
+		let (start, end) = self.voting_oracle().accepted_interval()?;
+		// Process pending justifications.
+		if !self.pending_justifications.is_empty() {
+			// These are still pending.
+			let still_pending =
+				self.pending_justifications.split_off(&end.saturating_add(1u32.into()));
+			// These can be processed.
+			let justifs_to_process = self.pending_justifications.split_off(&start);
+			// The rest can be dropped.
+			self.pending_justifications = still_pending;
+
+			for (num, justification) in justifs_to_process.into_iter() {
+				debug!(target: LOG_TARGET, "🥩 Handle buffered justification for: {:?}.", num);
+				metric_inc!(self, beefy_imported_justifications);
+				if let Err(err) = self.finalize(justification) {
+					error!(target: LOG_TARGET, "🥩 Error finalizing block: {}", err);
+				}
+			}
+			metric_set!(self, beefy_buffered_justifications, self.pending_justifications.len());
+		}
+		Ok(())
+	}
+
+	/// Decide if should vote, then vote.. or don't..
+	fn try_to_vote(&mut self) -> Result<(), Error> {
+		// Vote if there's now a new vote target.
+		if let Some(target) = self.voting_oracle().voting_target() {
+			metric_set!(self, beefy_should_vote_on, target);
+			if target > self.persisted_state.best_voted {
+				self.do_vote(target)?;
+			}
+		}
+		Ok(())
+	}
+
+	/// Create and gossip Signed Commitment for block number `target_number`.
+	///
+	/// Also handle this self vote by calling `self.handle_vote()` for it.
+	fn do_vote(&mut self, target_number: NumberFor<B>) -> Result<(), Error> {
+		debug!(target: LOG_TARGET, "🥩 Try voting on {}", target_number);
+
+		// Most of the time we get here, `target` is actually `best_grandpa`,
+		// avoid getting header from backend in that case.
+		let target_header = if target_number == self.best_grandpa_block() {
+			self.persisted_state.voting_oracle.best_grandpa_block_header.clone()
+		} else {
+			let hash = self
+				.backend
+				.blockchain()
+				.expect_block_hash_from_id(&BlockId::Number(target_number))
+				.map_err(|err| {
+					let err_msg = format!(
+						"Couldn't get hash for block #{:?} (error: {:?}), skipping vote..",
+						target_number, err
+					);
+					Error::Backend(err_msg)
+				})?;
+
+			self.backend.blockchain().expect_header(hash).map_err(|err| {
+				let err_msg = format!(
+					"Couldn't get header for block #{:?} ({:?}) (error: {:?}), skipping vote..",
+					target_number, hash, err
+				);
+				Error::Backend(err_msg)
+			})?
+		};
+		let target_hash = target_header.hash();
+
+		let payload = if let Some(hash) = self.payload_provider.payload(&target_header) {
+			hash
+		} else {
+			warn!(target: LOG_TARGET, "🥩 No MMR root digest found for: {:?}", target_hash);
+			return Ok(())
+		};
+
+		let rounds = self.persisted_state.voting_oracle.active_rounds_mut()?;
+		let (validators, validator_set_id) = (rounds.validators(), rounds.validator_set_id());
+
+		let authority_id = if let Some(id) = self.key_store.authority_id(validators) {
+			debug!(target: LOG_TARGET, "🥩 Local authority id: {:?}", id);
+			id
+		} else {
+			debug!(
+				target: LOG_TARGET,
+				"🥩 Missing validator id - can't vote for: {:?}", target_hash
+			);
+			return Ok(())
+		};
+
+		let commitment = Commitment { payload, block_number: target_number, validator_set_id };
+		let encoded_commitment = commitment.encode();
+
+		let signature = match self.key_store.sign(&authority_id, &encoded_commitment) {
+			Ok(sig) => sig,
+			Err(err) => {
+				warn!(target: LOG_TARGET, "🥩 Error signing commitment: {:?}", err);
+				return Ok(())
+			},
+		};
+
+		trace!(
+			target: LOG_TARGET,
+			"🥩 Produced signature using {:?}, is_valid: {:?}",
+			authority_id,
+			BeefyKeystore::verify(&authority_id, &signature, &encoded_commitment)
+		);
+
+		let vote = VoteMessage { commitment, id: authority_id, signature };
+		if let Some(finality_proof) = self.handle_vote(vote.clone()).map_err(|err| {
+			error!(target: LOG_TARGET, "🥩 Error handling self vote: {}", err);
+			err
+		})? {
+			let encoded_proof = GossipMessage::<B>::FinalityProof(finality_proof).encode();
+			self.gossip_engine.gossip_message(proofs_topic::<B>(), encoded_proof, true);
+		} else {
+			metric_inc!(self, beefy_votes_sent);
+			debug!(target: LOG_TARGET, "🥩 Sent vote message: {:?}", vote);
+			let encoded_vote = GossipMessage::<B>::Vote(vote).encode();
+			self.gossip_engine.gossip_message(votes_topic::<B>(), encoded_vote, false);
+		}
+
+		// Persist state after vote to avoid double voting in case of voter restarts.
+		self.persisted_state.best_voted = target_number;
+		metric_set!(self, beefy_best_voted, target_number);
+		crate::aux_schema::write_voter_state(&*self.backend, &self.persisted_state)
+			.map_err(|e| Error::Backend(e.to_string()))
+	}
+
+	fn process_new_state(&mut self) {
+		// Handle pending justifications and/or votes for now GRANDPA finalized blocks.
+		if let Err(err) = self.try_pending_justififactions() {
+			debug!(target: LOG_TARGET, "🥩 {}", err);
+		}
+
+		// Don't bother voting or requesting justifications during major sync.
+		if !self.sync.is_major_syncing() {
+			// There were external events, 'state' is changed, author a vote if needed/possible.
+			if let Err(err) = self.try_to_vote() {
+				debug!(target: LOG_TARGET, "🥩 {}", err);
+			}
+			// If the current target is a mandatory block,
+			// make sure there's also an on-demand justification request out for it.
+			if let Some((block, active)) = self.voting_oracle().mandatory_pending() {
+				// This only starts new request if there isn't already an active one.
+				self.on_demand_justifications.request(block, active);
+			}
+		}
+	}
+
+	/// Main loop for BEEFY worker.
+	///
+	/// Run the main async loop which is driven by finality notifications and gossiped votes.
+	/// Should never end, returns `Error` otherwise.
+	pub(crate) async fn run(
+		mut self,
+		block_import_justif: &mut Fuse<NotificationReceiver<BeefyVersionedFinalityProof<B>>>,
+		finality_notifications: &mut Fuse<FinalityNotifications<B>>,
+	) -> Error {
+		info!(
+			target: LOG_TARGET,
+			"🥩 run BEEFY worker, best grandpa: #{:?}.",
+			self.best_grandpa_block()
+		);
+
+		let mut votes = Box::pin(
+			self.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());
+					trace!(target: LOG_TARGET, "🥩 Got vote message: {:?}", vote);
+					vote
+				})
+				.fuse(),
+		);
+		let mut gossip_proofs = Box::pin(
+			self.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());
+					trace!(target: LOG_TARGET, "🥩 Got gossip proof message: {:?}", proof);
+					proof
+				})
+				.fuse(),
+		);
+
+		loop {
+			// Act on changed 'state'.
+			self.process_new_state();
+
+			// Mutable reference used to drive the gossip engine.
+			let mut gossip_engine = &mut self.gossip_engine;
+			// Use temp val and report after async section,
+			// to avoid having to Mutex-wrap `gossip_engine`.
+			let mut gossip_report: Option<PeerReport> = None;
+
+			// Wait for, and handle external events.
+			// The branches below only change 'state', actual voting happens afterwards,
+			// based on the new resulting 'state'.
+			futures::select_biased! {
+				// Use `select_biased!` to prioritize order below.
+				// Process finality notifications first since these drive the voter.
+				notification = finality_notifications.next() => {
+					if let Some(notif) = notification {
+						if let Err(err) = self.handle_finality_notification(&notif) {
+							return err;
+						}
+					} else {
+						return Error::FinalityStreamTerminated;
+					}
+				},
+				// Make sure to pump gossip engine.
+				_ = gossip_engine => {
+					return Error::GossipEngineTerminated;
+				},
+				// Process incoming justifications as these can make some in-flight votes obsolete.
+				response_info = self.on_demand_justifications.next().fuse() => {
+					match response_info {
+						ResponseInfo::ValidProof(justif, peer_report) => {
+							if let Err(err) = self.triage_incoming_justif(justif) {
+								debug!(target: LOG_TARGET, "🥩 {}", err);
+							}
+							gossip_report = Some(peer_report);
+						},
+						ResponseInfo::PeerReport(peer_report) => gossip_report = Some(peer_report),
+						ResponseInfo::Pending => (),
+					}
+				},
+				justif = block_import_justif.next() => {
+					if let Some(justif) = justif {
+						// Block import justifications have already been verified to be valid
+						// by `BeefyBlockImport`.
+						if let Err(err) = self.triage_incoming_justif(justif) {
+							debug!(target: LOG_TARGET, "🥩 {}", err);
+						}
+					} else {
+						return Error::BlockImportStreamTerminated;
+					}
+				},
+				justif = gossip_proofs.next() => {
+					if let Some(justif) = justif {
+						// Gossiped justifications have already been verified by `GossipValidator`.
+						if let Err(err) = self.triage_incoming_justif(justif) {
+							debug!(target: LOG_TARGET, "🥩 {}", err);
+						}
+					} else {
+						return Error::FinalityProofGossipStreamTerminated;
+					}
+				},
+				// Finally process incoming votes.
+				vote = votes.next() => {
+					if let Some(vote) = vote {
+						// Votes have already been verified to be valid by the gossip validator.
+						if let Err(err) = self.triage_incoming_vote(vote) {
+							debug!(target: LOG_TARGET, "🥩 {}", err);
+						}
+					} else {
+						return Error::VotesGossipStreamTerminated;
+					}
+				},
+				// Process peer reports.
+				report = self.gossip_report_stream.next() => {
+					gossip_report = report;
+				},
+			}
+			if let Some(PeerReport { who, cost_benefit }) = gossip_report {
+				self.gossip_engine.report(who, cost_benefit);
+			}
+		}
+	}
+
+	/// Report the given equivocation to the BEEFY runtime module. This method
+	/// generates a session membership proof of the offender and then submits an
+	/// extrinsic to report the equivocation. In particular, the session membership
+	/// proof must be generated at the block at which the given set was active which
+	/// isn't necessarily the best block if there are pending authority set changes.
+	pub(crate) fn report_equivocation(
+		&self,
+		proof: EquivocationProof<NumberFor<B>, AuthorityId, Signature>,
+	) -> Result<(), Error> {
+		let rounds = self.persisted_state.voting_oracle.active_rounds()?;
+		let (validators, validator_set_id) = (rounds.validators(), rounds.validator_set_id());
+		let offender_id = proof.offender_id().clone();
+
+		if !check_equivocation_proof::<_, _, BeefySignatureHasher>(&proof) {
+			debug!(target: LOG_TARGET, "🥩 Skip report for bad equivocation {:?}", proof);
+			return Ok(())
+		} else if let Some(local_id) = self.key_store.authority_id(validators) {
+			if offender_id == local_id {
+				debug!(target: LOG_TARGET, "🥩 Skip equivocation report for own equivocation");
+				return Ok(())
+			}
+		}
+
+		let number = *proof.round_number();
+		let hash = self
+			.backend
+			.blockchain()
+			.expect_block_hash_from_id(&BlockId::Number(number))
+			.map_err(|err| {
+				let err_msg = format!(
+					"Couldn't get hash for block #{:?} (error: {:?}), skipping report for equivocation",
+					number, err
+				);
+				Error::Backend(err_msg)
+			})?;
+		let runtime_api = self.runtime.runtime_api();
+		// generate key ownership proof at that block
+		let key_owner_proof = match runtime_api
+			.generate_key_ownership_proof(hash, validator_set_id, offender_id)
+			.map_err(Error::RuntimeApi)?
+		{
+			Some(proof) => proof,
+			None => {
+				debug!(
+					target: LOG_TARGET,
+					"🥩 Equivocation offender not part of the authority set."
+				);
+				return Ok(())
+			},
+		};
+
+		// submit equivocation report at **best** block
+		let best_block_hash = self.backend.blockchain().info().best_hash;
+		runtime_api
+			.submit_report_equivocation_unsigned_extrinsic(best_block_hash, proof, key_owner_proof)
+			.map_err(Error::RuntimeApi)?;
+
+		Ok(())
+	}
+}
+
+/// 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>>
+where
+	B: Block,
+{
+	let id = OpaqueDigestItemId::Consensus(&BEEFY_ENGINE_ID);
+
+	let filter = |log: ConsensusLog<AuthorityId>| match log {
+		ConsensusLog::AuthoritiesChange(validator_set) => Some(validator_set),
+		_ => None,
+	};
+	header.digest().convert_first(|l| l.try_to(id).and_then(filter))
+}
+
+/// Calculate next block number to vote on.
+///
+/// Return `None` if there is no voteable target yet.
+fn vote_target<N>(best_grandpa: N, best_beefy: N, session_start: N, min_delta: u32) -> Option<N>
+where
+	N: AtLeast32Bit + Copy + Debug,
+{
+	// if the mandatory block (session_start) does not have a beefy justification yet,
+	// we vote on it
+	let target = if best_beefy < session_start {
+		debug!(target: LOG_TARGET, "🥩 vote target - mandatory block: #{:?}", session_start,);
+		session_start
+	} else {
+		let diff = best_grandpa.saturating_sub(best_beefy) + 1u32.into();
+		let diff = diff.saturated_into::<u32>() / 2;
+		let target = best_beefy + min_delta.max(diff.next_power_of_two()).into();
+		trace!(
+			target: LOG_TARGET,
+			"🥩 vote target - diff: {:?}, next_power_of_two: {:?}, target block: #{:?}",
+			diff,
+			diff.next_power_of_two(),
+			target,
+		);
+
+		target
+	};
+
+	// Don't vote for targets until they've been finalized
+	// (`target` can be > `best_grandpa` when `min_delta` is big enough).
+	if target > best_grandpa {
+		None
+	} else {
+		Some(target)
+	}
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+	use crate::{
+		communication::notification::{BeefyBestBlockStream, BeefyVersionedFinalityProofStream},
+		tests::{
+			create_beefy_keystore, get_beefy_streams, make_beefy_ids, BeefyPeer, BeefyTestNet,
+			TestApi,
+		},
+		BeefyRPCLinks, KnownPeers,
+	};
+	use futures::{future::poll_fn, task::Poll};
+	use parking_lot::Mutex;
+	use sc_client_api::{Backend as BackendT, HeaderBackend};
+	use sc_network_sync::SyncingService;
+	use sc_network_test::TestNetFactory;
+	use sp_api::HeaderT;
+	use sp_blockchain::Backend as BlockchainBackendT;
+	use sp_consensus_beefy::{
+		generate_equivocation_proof, known_payloads, known_payloads::MMR_ROOT_ID,
+		mmr::MmrRootProvider, Keyring, Payload, SignedCommitment,
+	};
+	use sp_runtime::traits::One;
+	use substrate_test_runtime_client::{
+		runtime::{Block, Digest, DigestItem, Header},
+		Backend,
+	};
+
+	impl<B: super::Block> PersistedState<B> {
+		pub fn voting_oracle(&self) -> &VoterOracle<B> {
+			&self.voting_oracle
+		}
+
+		pub fn active_round(&self) -> Result<&Rounds<B>, Error> {
+			self.voting_oracle.active_rounds()
+		}
+
+		pub fn best_beefy_block(&self) -> NumberFor<B> {
+			self.voting_oracle.best_beefy_block
+		}
+
+		pub fn best_grandpa_number(&self) -> NumberFor<B> {
+			*self.voting_oracle.best_grandpa_block_header.number()
+		}
+	}
+
+	impl<B: super::Block> VoterOracle<B> {
+		pub fn sessions(&self) -> &VecDeque<Rounds<B>> {
+			&self.sessions
+		}
+	}
+
+	fn create_beefy_worker(
+		peer: &mut BeefyPeer,
+		key: &Keyring,
+		min_block_delta: u32,
+		genesis_validator_set: ValidatorSet<AuthorityId>,
+	) -> BeefyWorker<
+		Block,
+		Backend,
+		MmrRootProvider<Block, TestApi>,
+		TestApi,
+		Arc<SyncingService<Block>>,
+	> {
+		let keystore = create_beefy_keystore(*key);
+
+		let (to_rpc_justif_sender, from_voter_justif_stream) =
+			BeefyVersionedFinalityProofStream::<Block>::channel();
+		let (to_rpc_best_block_sender, from_voter_best_beefy_stream) =
+			BeefyBestBlockStream::<Block>::channel();
+		let (_, from_block_import_justif_stream) =
+			BeefyVersionedFinalityProofStream::<Block>::channel();
+
+		let beefy_rpc_links =
+			BeefyRPCLinks { from_voter_justif_stream, from_voter_best_beefy_stream };
+		*peer.data.beefy_rpc_links.lock() = Some(beefy_rpc_links);
+
+		let links = BeefyVoterLinks {
+			from_block_import_justif_stream,
+			to_rpc_justif_sender,
+			to_rpc_best_block_sender,
+		};
+
+		let backend = peer.client().as_backend();
+		let beefy_genesis = 1;
+		let api = Arc::new(TestApi::with_validator_set(&genesis_validator_set));
+		let network = peer.network_service().clone();
+		let sync = peer.sync_service().clone();
+		let known_peers = Arc::new(Mutex::new(KnownPeers::new()));
+		let (gossip_validator, gossip_report_stream) = GossipValidator::new(known_peers.clone());
+		let gossip_validator = Arc::new(gossip_validator);
+		let gossip_engine = GossipEngine::new(
+			network.clone(),
+			sync.clone(),
+			"/beefy/1",
+			gossip_validator.clone(),
+			None,
+		);
+		let metrics = None;
+		let on_demand_justifications = OnDemandJustificationsEngine::new(
+			network.clone(),
+			"/beefy/justifs/1".into(),
+			known_peers,
+			None,
+		);
+		// Push 1 block - will start first session.
+		let hashes = peer.push_blocks(1, false);
+		backend.finalize_block(hashes[0], None).unwrap();
+		let first_header = backend
+			.blockchain()
+			.expect_header(backend.blockchain().info().best_hash)
+			.unwrap();
+		let persisted_state = PersistedState::checked_new(
+			first_header,
+			Zero::zero(),
+			vec![Rounds::new(One::one(), genesis_validator_set)].into(),
+			min_block_delta,
+			beefy_genesis,
+		)
+		.unwrap();
+		let payload_provider = MmrRootProvider::new(api.clone());
+		BeefyWorker {
+			backend,
+			payload_provider,
+			runtime: api,
+			key_store: Some(keystore).into(),
+			links,
+			gossip_engine,
+			gossip_validator,
+			gossip_report_stream,
+			metrics,
+			sync: Arc::new(sync),
+			on_demand_justifications,
+			pending_justifications: BTreeMap::new(),
+			persisted_state,
+		}
+	}
+
+	#[test]
+	fn vote_on_min_block_delta() {
+		let t = vote_target(1u32, 1, 1, 4);
+		assert_eq!(None, t);
+		let t = vote_target(2u32, 1, 1, 4);
+		assert_eq!(None, t);
+		let t = vote_target(4u32, 2, 1, 4);
+		assert_eq!(None, t);
+		let t = vote_target(6u32, 2, 1, 4);
+		assert_eq!(Some(6), t);
+
+		let t = vote_target(9u32, 4, 1, 4);
+		assert_eq!(Some(8), t);
+
+		let t = vote_target(10u32, 10, 1, 8);
+		assert_eq!(None, t);
+		let t = vote_target(12u32, 10, 1, 8);
+		assert_eq!(None, t);
+		let t = vote_target(18u32, 10, 1, 8);
+		assert_eq!(Some(18), t);
+	}
+
+	#[test]
+	fn vote_on_power_of_two() {
+		let t = vote_target(1008u32, 1000, 1, 4);
+		assert_eq!(Some(1004), t);
+
+		let t = vote_target(1016u32, 1000, 1, 4);
+		assert_eq!(Some(1008), t);
+
+		let t = vote_target(1032u32, 1000, 1, 4);
+		assert_eq!(Some(1016), t);
+
+		let t = vote_target(1064u32, 1000, 1, 4);
+		assert_eq!(Some(1032), t);
+
+		let t = vote_target(1128u32, 1000, 1, 4);
+		assert_eq!(Some(1064), t);
+
+		let t = vote_target(1256u32, 1000, 1, 4);
+		assert_eq!(Some(1128), t);
+
+		let t = vote_target(1512u32, 1000, 1, 4);
+		assert_eq!(Some(1256), t);
+
+		let t = vote_target(1024u32, 1, 1, 4);
+		assert_eq!(Some(513), t);
+	}
+
+	#[test]
+	fn vote_on_target_block() {
+		let t = vote_target(1008u32, 1002, 1, 4);
+		assert_eq!(Some(1006), t);
+		let t = vote_target(1010u32, 1002, 1, 4);
+		assert_eq!(Some(1006), t);
+
+		let t = vote_target(1016u32, 1006, 1, 4);
+		assert_eq!(Some(1014), t);
+		let t = vote_target(1022u32, 1006, 1, 4);
+		assert_eq!(Some(1014), t);
+
+		let t = vote_target(1032u32, 1012, 1, 4);
+		assert_eq!(Some(1028), t);
+		let t = vote_target(1044u32, 1012, 1, 4);
+		assert_eq!(Some(1028), t);
+
+		let t = vote_target(1064u32, 1014, 1, 4);
+		assert_eq!(Some(1046), t);
+		let t = vote_target(1078u32, 1014, 1, 4);
+		assert_eq!(Some(1046), t);
+
+		let t = vote_target(1128u32, 1008, 1, 4);
+		assert_eq!(Some(1072), t);
+		let t = vote_target(1136u32, 1008, 1, 4);
+		assert_eq!(Some(1072), t);
+	}
+
+	#[test]
+	fn vote_on_mandatory_block() {
+		let t = vote_target(1008u32, 1002, 1004, 4);
+		assert_eq!(Some(1004), t);
+		let t = vote_target(1016u32, 1006, 1007, 4);
+		assert_eq!(Some(1007), t);
+		let t = vote_target(1064u32, 1014, 1063, 4);
+		assert_eq!(Some(1063), t);
+		let t = vote_target(1320u32, 1012, 1234, 4);
+		assert_eq!(Some(1234), t);
+
+		let t = vote_target(1128u32, 1008, 1008, 4);
+		assert_eq!(Some(1072), t);
+	}
+
+	#[test]
+	fn should_vote_target() {
+		let header = Header::new(
+			1u32.into(),
+			Default::default(),
+			Default::default(),
+			Default::default(),
+			Digest::default(),
+		);
+		let mut oracle = VoterOracle::<Block> {
+			best_beefy_block: 0,
+			best_grandpa_block_header: header,
+			min_block_delta: 1,
+			sessions: VecDeque::new(),
+		};
+		let voting_target_with = |oracle: &mut VoterOracle<Block>,
+		                          best_beefy: NumberFor<Block>,
+		                          best_grandpa: NumberFor<Block>|
+		 -> Option<NumberFor<Block>> {
+			oracle.best_beefy_block = best_beefy;
+			oracle.best_grandpa_block_header.number = best_grandpa;
+			oracle.voting_target()
+		};
+
+		// rounds not initialized -> should vote: `None`
+		assert_eq!(voting_target_with(&mut oracle, 0, 1), None);
+
+		let keys = &[Keyring::Alice];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+
+		oracle.add_session(Rounds::new(1, validator_set.clone()));
+
+		// under min delta
+		oracle.min_block_delta = 4;
+		assert_eq!(voting_target_with(&mut oracle, 1, 1), None);
+		assert_eq!(voting_target_with(&mut oracle, 2, 5), None);
+
+		// vote on min delta
+		assert_eq!(voting_target_with(&mut oracle, 4, 9), Some(8));
+		oracle.min_block_delta = 8;
+		assert_eq!(voting_target_with(&mut oracle, 10, 18), Some(18));
+
+		// vote on power of two
+		oracle.min_block_delta = 1;
+		assert_eq!(voting_target_with(&mut oracle, 1000, 1008), Some(1004));
+		assert_eq!(voting_target_with(&mut oracle, 1000, 1016), Some(1008));
+
+		// nothing new to vote on
+		assert_eq!(voting_target_with(&mut oracle, 1000, 1000), None);
+
+		// vote on mandatory
+		oracle.sessions.clear();
+		oracle.add_session(Rounds::new(1000, validator_set.clone()));
+		assert_eq!(voting_target_with(&mut oracle, 0, 1008), Some(1000));
+		oracle.sessions.clear();
+		oracle.add_session(Rounds::new(1001, validator_set.clone()));
+		assert_eq!(voting_target_with(&mut oracle, 1000, 1008), Some(1001));
+	}
+
+	#[test]
+	fn test_oracle_accepted_interval() {
+		let keys = &[Keyring::Alice];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+
+		let header = Header::new(
+			1u32.into(),
+			Default::default(),
+			Default::default(),
+			Default::default(),
+			Digest::default(),
+		);
+		let mut oracle = VoterOracle::<Block> {
+			best_beefy_block: 0,
+			best_grandpa_block_header: header,
+			min_block_delta: 1,
+			sessions: VecDeque::new(),
+		};
+		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()
+		};
+
+		// rounds not initialized -> should accept votes: `None`
+		assert!(accepted_interval_with(&mut oracle, 1).is_err());
+
+		let session_one = 1;
+		oracle.add_session(Rounds::new(session_one, validator_set.clone()));
+		// mandatory not done, only accept mandatory
+		for i in 0..15 {
+			assert_eq!(accepted_interval_with(&mut oracle, i), Ok((session_one, session_one)));
+		}
+
+		// add more sessions, nothing changes
+		let session_two = 11;
+		let session_three = 21;
+		oracle.add_session(Rounds::new(session_two, validator_set.clone()));
+		oracle.add_session(Rounds::new(session_three, validator_set.clone()));
+		// mandatory not done, should accept mandatory for session_one
+		for i in session_three..session_three + 15 {
+			assert_eq!(accepted_interval_with(&mut oracle, i), Ok((session_one, session_one)));
+		}
+
+		// simulate finish mandatory for session one, prune oracle
+		oracle.sessions.front_mut().unwrap().test_set_mandatory_done(true);
+		oracle.try_prune();
+		// session_one pruned, should accept mandatory for session_two
+		for i in session_three..session_three + 15 {
+			assert_eq!(accepted_interval_with(&mut oracle, i), Ok((session_two, session_two)));
+		}
+
+		// simulate finish mandatory for session two, prune oracle
+		oracle.sessions.front_mut().unwrap().test_set_mandatory_done(true);
+		oracle.try_prune();
+		// session_two pruned, should accept mandatory for session_three
+		for i in session_three..session_three + 15 {
+			assert_eq!(accepted_interval_with(&mut oracle, i), Ok((session_three, session_three)));
+		}
+
+		// simulate finish mandatory for session three
+		oracle.sessions.front_mut().unwrap().test_set_mandatory_done(true);
+		// verify all other blocks in this session are now open to voting
+		for i in session_three..session_three + 15 {
+			assert_eq!(accepted_interval_with(&mut oracle, i), Ok((session_three, i)));
+		}
+		// pruning does nothing in this case
+		oracle.try_prune();
+		for i in session_three..session_three + 15 {
+			assert_eq!(accepted_interval_with(&mut oracle, i), Ok((session_three, i)));
+		}
+
+		// adding new session automatically prunes "finalized" previous session
+		let session_four = 31;
+		oracle.add_session(Rounds::new(session_four, validator_set.clone()));
+		assert_eq!(oracle.sessions.front().unwrap().session_start(), session_four);
+		assert_eq!(
+			accepted_interval_with(&mut oracle, session_four + 10),
+			Ok((session_four, session_four))
+		);
+	}
+
+	#[test]
+	fn extract_authorities_change_digest() {
+		let mut header = Header::new(
+			1u32.into(),
+			Default::default(),
+			Default::default(),
+			Default::default(),
+			Digest::default(),
+		);
+
+		// verify empty digest shows nothing
+		assert!(find_authorities_change::<Block>(&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(),
+		));
+
+		// verify validator set is correctly extracted from digest
+		let extracted = find_authorities_change::<Block>(&header);
+		assert_eq!(extracted, Some(validator_set));
+	}
+
+	#[tokio::test]
+	async fn keystore_vs_validator_set() {
+		let keys = &[Keyring::Alice];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+		let mut net = BeefyTestNet::new(1);
+		let mut worker = create_beefy_worker(net.peer(0), &keys[0], 1, validator_set.clone());
+
+		// keystore doesn't contain other keys than validators'
+		assert_eq!(worker.verify_validator_set(&1, &validator_set), Ok(()));
+
+		// unknown `Bob` key
+		let keys = &[Keyring::Bob];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+		let err_msg = "no authority public key found in store".to_string();
+		let expected = Err(Error::Keystore(err_msg));
+		assert_eq!(worker.verify_validator_set(&1, &validator_set), expected);
+
+		// worker has no keystore
+		worker.key_store = None.into();
+		let expected_err = Err(Error::Keystore("no Keystore".into()));
+		assert_eq!(worker.verify_validator_set(&1, &validator_set), expected_err);
+	}
+
+	#[tokio::test]
+	async fn should_finalize_correctly() {
+		let keys = [Keyring::Alice];
+		let validator_set = ValidatorSet::new(make_beefy_ids(&keys), 0).unwrap();
+		let mut net = BeefyTestNet::new(1);
+		let backend = net.peer(0).client().as_backend();
+		let mut worker = create_beefy_worker(net.peer(0), &keys[0], 1, validator_set.clone());
+		// remove default session, will manually add custom one.
+		worker.persisted_state.voting_oracle.sessions.clear();
+
+		let keys = keys.iter().cloned().enumerate();
+		let (mut best_block_streams, mut finality_proofs) =
+			get_beefy_streams(&mut net, keys.clone());
+		let mut best_block_stream = best_block_streams.drain(..).next().unwrap();
+		let mut finality_proof = finality_proofs.drain(..).next().unwrap();
+
+		let create_finality_proof = |block_num: NumberFor<Block>| {
+			let commitment = Commitment {
+				payload: Payload::from_single_entry(known_payloads::MMR_ROOT_ID, vec![]),
+				block_number: block_num,
+				validator_set_id: validator_set.id(),
+			};
+			VersionedFinalityProof::V1(SignedCommitment { commitment, signatures: vec![None] })
+		};
+
+		// no 'best beefy block' or finality proofs
+		assert_eq!(worker.persisted_state.best_beefy_block(), 0);
+		poll_fn(move |cx| {
+			assert_eq!(best_block_stream.poll_next_unpin(cx), Poll::Pending);
+			assert_eq!(finality_proof.poll_next_unpin(cx), Poll::Pending);
+			Poll::Ready(())
+		})
+		.await;
+
+		let client = net.peer(0).client().as_client();
+		// unknown hash for block #1
+		let (mut best_block_streams, mut finality_proofs) =
+			get_beefy_streams(&mut net, keys.clone());
+		let mut best_block_stream = best_block_streams.drain(..).next().unwrap();
+		let mut finality_proof = finality_proofs.drain(..).next().unwrap();
+		let justif = create_finality_proof(1);
+		// create new session at block #1
+		worker
+			.persisted_state
+			.voting_oracle
+			.add_session(Rounds::new(1, validator_set.clone()));
+		// try to finalize block #1
+		worker.finalize(justif.clone()).unwrap();
+		// verify block finalized
+		assert_eq!(worker.persisted_state.best_beefy_block(), 1);
+		poll_fn(move |cx| {
+			// expect Some(hash-of-block-1)
+			match best_block_stream.poll_next_unpin(cx) {
+				Poll::Ready(Some(hash)) => {
+					let block_num = client.number(hash).unwrap();
+					assert_eq!(block_num, Some(1));
+				},
+				v => panic!("unexpected value: {:?}", v),
+			}
+			// commitment streamed
+			match finality_proof.poll_next_unpin(cx) {
+				// expect justification
+				Poll::Ready(Some(received)) => assert_eq!(received, justif),
+				v => panic!("unexpected value: {:?}", v),
+			}
+			Poll::Ready(())
+		})
+		.await;
+
+		// generate 2 blocks, try again expect success
+		let (mut best_block_streams, _) = get_beefy_streams(&mut net, keys);
+		let mut best_block_stream = best_block_streams.drain(..).next().unwrap();
+		let hashes = net.peer(0).push_blocks(1, false);
+		// finalize 1 and 2 without justifications (hashes does not contain genesis)
+		let hashof2 = hashes[0];
+		backend.finalize_block(hashof2, None).unwrap();
+
+		let justif = create_finality_proof(2);
+		// create new session at block #2
+		worker.persisted_state.voting_oracle.add_session(Rounds::new(2, validator_set));
+		worker.finalize(justif).unwrap();
+		// verify old session pruned
+		assert_eq!(worker.voting_oracle().sessions.len(), 1);
+		// new session starting at #2 is in front
+		assert_eq!(worker.active_rounds().unwrap().session_start(), 2);
+		// verify block finalized
+		assert_eq!(worker.persisted_state.best_beefy_block(), 2);
+		poll_fn(move |cx| {
+			match best_block_stream.poll_next_unpin(cx) {
+				// expect Some(hash-of-block-2)
+				Poll::Ready(Some(hash)) => {
+					let block_num = net.peer(0).client().as_client().number(hash).unwrap();
+					assert_eq!(block_num, Some(2));
+				},
+				v => panic!("unexpected value: {:?}", v),
+			}
+			Poll::Ready(())
+		})
+		.await;
+
+		// check BEEFY justifications are also appended to backend
+		let justifs = backend.blockchain().justifications(hashof2).unwrap().unwrap();
+		assert!(justifs.get(BEEFY_ENGINE_ID).is_some())
+	}
+
+	#[tokio::test]
+	async fn should_init_session() {
+		let keys = &[Keyring::Alice, Keyring::Bob];
+		let validator_set = ValidatorSet::new(make_beefy_ids(keys), 0).unwrap();
+		let mut net = BeefyTestNet::new(1);
+		let mut worker = create_beefy_worker(net.peer(0), &keys[0], 1, validator_set.clone());
+
+		let worker_rounds = worker.active_rounds().unwrap();
+		assert_eq!(worker_rounds.session_start(), 1);
+		assert_eq!(worker_rounds.validators(), validator_set.validators());
+		assert_eq!(worker_rounds.validator_set_id(), validator_set.id());
+
+		// new validator set
+		let keys = &[Keyring::Bob];
+		let new_validator_set = ValidatorSet::new(make_beefy_ids(keys), 1).unwrap();
+
+		worker.init_session_at(new_validator_set.clone(), 11);
+		// Since mandatory is not done for old rounds, we still get those.
+		let rounds = worker.persisted_state.voting_oracle.active_rounds_mut().unwrap();
+		assert_eq!(rounds.validator_set_id(), validator_set.id());
+		// Let's finalize mandatory.
+		rounds.test_set_mandatory_done(true);
+		worker.persisted_state.voting_oracle.try_prune();
+		// Now we should get the next round.
+		let rounds = worker.active_rounds().unwrap();
+		// Expect new values.
+		assert_eq!(rounds.session_start(), 11);
+		assert_eq!(rounds.validators(), new_validator_set.validators());
+		assert_eq!(rounds.validator_set_id(), new_validator_set.id());
+	}
+
+	#[tokio::test]
+	async fn should_not_report_bad_old_or_self_equivocations() {
+		let block_num = 1;
+		let set_id = 1;
+		let keys = [Keyring::Alice];
+		let validator_set = ValidatorSet::new(make_beefy_ids(&keys), set_id).unwrap();
+		// Alice votes on good MMR roots, equivocations are allowed/expected
+		let mut api_alice = TestApi::with_validator_set(&validator_set);
+		api_alice.allow_equivocations();
+		let api_alice = Arc::new(api_alice);
+
+		let mut net = BeefyTestNet::new(1);
+		let mut worker = create_beefy_worker(net.peer(0), &keys[0], 1, validator_set.clone());
+		worker.runtime = api_alice.clone();
+
+		// let there be a block with num = 1:
+		let _ = net.peer(0).push_blocks(1, false);
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+
+		// generate an equivocation proof, with Bob as perpetrator
+		let good_proof = generate_equivocation_proof(
+			(block_num, payload1.clone(), set_id, &Keyring::Bob),
+			(block_num, payload2.clone(), set_id, &Keyring::Bob),
+		);
+		{
+			// expect voter (Alice) to successfully report it
+			assert_eq!(worker.report_equivocation(good_proof.clone()), Ok(()));
+			// verify Alice reports Bob equivocation to runtime
+			let reported = api_alice.reported_equivocations.as_ref().unwrap().lock();
+			assert_eq!(reported.len(), 1);
+			assert_eq!(*reported.get(0).unwrap(), good_proof);
+		}
+		api_alice.reported_equivocations.as_ref().unwrap().lock().clear();
+
+		// now let's try with a bad proof
+		let mut bad_proof = good_proof.clone();
+		bad_proof.first.id = Keyring::Charlie.public();
+		// bad proofs are simply ignored
+		assert_eq!(worker.report_equivocation(bad_proof), Ok(()));
+		// verify nothing reported to runtime
+		assert!(api_alice.reported_equivocations.as_ref().unwrap().lock().is_empty());
+
+		// now let's try with old set it
+		let mut old_proof = good_proof.clone();
+		old_proof.first.commitment.validator_set_id = 0;
+		old_proof.second.commitment.validator_set_id = 0;
+		// old proofs are simply ignored
+		assert_eq!(worker.report_equivocation(old_proof), Ok(()));
+		// verify nothing reported to runtime
+		assert!(api_alice.reported_equivocations.as_ref().unwrap().lock().is_empty());
+
+		// now let's try reporting a self-equivocation
+		let self_proof = generate_equivocation_proof(
+			(block_num, payload1.clone(), set_id, &Keyring::Alice),
+			(block_num, payload2.clone(), set_id, &Keyring::Alice),
+		);
+		// equivocations done by 'self' are simply ignored (not reported)
+		assert_eq!(worker.report_equivocation(self_proof), Ok(()));
+		// verify nothing reported to runtime
+		assert!(api_alice.reported_equivocations.as_ref().unwrap().lock().is_empty());
+	}
+}
diff --git a/substrate/client/consensus/common/Cargo.toml b/substrate/client/consensus/common/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..adb6f0920beef6720b3c88d549dd7f1623b10a64
--- /dev/null
+++ b/substrate/client/consensus/common/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "sc-consensus"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Collection of common consensus specific imlementations for Substrate (client)"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = "0.1.57"
+futures = { version = "0.3.21", features = ["thread-pool"] }
+futures-timer = "3.0.1"
+libp2p-identity = { version = "0.1.2", features = ["peerid", "ed25519"] }
+log = "0.4.17"
+mockall = "0.11.3"
+parking_lot = "0.12.1"
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "1.0.30"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-utils = { version = "4.0.0-dev", path = "../../utils" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../../primitives/state-machine" }
+
+[dev-dependencies]
+sp-test-primitives = { version = "2.0.0", path = "../../../primitives/test-primitives" }
diff --git a/substrate/client/consensus/common/README.md b/substrate/client/consensus/common/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a6717a1d7a6df682607e9ddf3c45d7bbf6115dfc
--- /dev/null
+++ b/substrate/client/consensus/common/README.md
@@ -0,0 +1,3 @@
+Collection of common consensus specific implementations
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/common/src/block_import.rs b/substrate/client/consensus/common/src/block_import.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a451692ad478e41fb48a055cd2a5a5ae3c12c510
--- /dev/null
+++ b/substrate/client/consensus/common/src/block_import.rs
@@ -0,0 +1,411 @@
+// 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/>.
+
+//! Block import helpers.
+
+use serde::{Deserialize, Serialize};
+use sp_runtime::{
+	traits::{Block as BlockT, HashingFor, Header as HeaderT, NumberFor},
+	DigestItem, Justification, Justifications,
+};
+use std::{any::Any, borrow::Cow, collections::HashMap, sync::Arc};
+
+use sp_consensus::{BlockOrigin, Error};
+
+/// Block import result.
+#[derive(Debug, PartialEq, Eq)]
+pub enum ImportResult {
+	/// Block imported.
+	Imported(ImportedAux),
+	/// Already in the blockchain.
+	AlreadyInChain,
+	/// Block or parent is known to be bad.
+	KnownBad,
+	/// Block parent is not in the chain.
+	UnknownParent,
+	/// Parent state is missing.
+	MissingState,
+}
+
+/// Auxiliary data associated with an imported block result.
+#[derive(Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ImportedAux {
+	/// Only the header has been imported. Block body verification was skipped.
+	pub header_only: bool,
+	/// Clear all pending justification requests.
+	pub clear_justification_requests: bool,
+	/// Request a justification for the given block.
+	pub needs_justification: bool,
+	/// Received a bad justification.
+	pub bad_justification: bool,
+	/// Whether the block that was imported is the new best block.
+	pub is_new_best: bool,
+}
+
+impl ImportResult {
+	/// Returns default value for `ImportResult::Imported` with
+	/// `clear_justification_requests`, `needs_justification`,
+	/// `bad_justification` set to false.
+	pub fn imported(is_new_best: bool) -> ImportResult {
+		let aux = ImportedAux { is_new_best, ..Default::default() };
+
+		ImportResult::Imported(aux)
+	}
+
+	/// Handles any necessary request for justifications (or clearing of pending requests) based on
+	/// the outcome of this block import.
+	pub fn handle_justification<B>(
+		&self,
+		hash: &B::Hash,
+		number: NumberFor<B>,
+		justification_sync_link: &dyn JustificationSyncLink<B>,
+	) where
+		B: BlockT,
+	{
+		match self {
+			ImportResult::Imported(aux) => {
+				if aux.clear_justification_requests {
+					justification_sync_link.clear_justification_requests();
+				}
+
+				if aux.needs_justification {
+					justification_sync_link.request_justification(hash, number);
+				}
+			},
+			_ => {},
+		}
+	}
+}
+
+/// Fork choice strategy.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum ForkChoiceStrategy {
+	/// Longest chain fork choice.
+	LongestChain,
+	/// Custom fork choice rule, where true indicates the new block should be the best block.
+	Custom(bool),
+}
+
+/// Data required to check validity of a Block.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct BlockCheckParams<Block: BlockT> {
+	/// Hash of the block that we verify.
+	pub hash: Block::Hash,
+	/// Block number of the block that we verify.
+	pub number: NumberFor<Block>,
+	/// Parent hash of the block that we verify.
+	pub parent_hash: Block::Hash,
+	/// Allow importing the block skipping state verification if parent state is missing.
+	pub allow_missing_state: bool,
+	/// Allow importing the block if parent block is missing.
+	pub allow_missing_parent: bool,
+	/// Re-validate existing block.
+	pub import_existing: bool,
+}
+
+/// Precomputed storage.
+pub enum StorageChanges<Block: BlockT> {
+	/// Changes coming from block execution.
+	Changes(sp_state_machine::StorageChanges<HashingFor<Block>>),
+	/// Whole new state.
+	Import(ImportedState<Block>),
+}
+
+/// Imported state data. A vector of key-value pairs that should form a trie.
+#[derive(PartialEq, Eq, Clone)]
+pub struct ImportedState<B: BlockT> {
+	/// Target block hash.
+	pub block: B::Hash,
+	/// State keys and values.
+	pub state: sp_state_machine::KeyValueStates,
+}
+
+impl<B: BlockT> std::fmt::Debug for ImportedState<B> {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.debug_struct("ImportedState").field("block", &self.block).finish()
+	}
+}
+
+/// Defines how a new state is computed for a given imported block.
+pub enum StateAction<Block: BlockT> {
+	/// Apply precomputed changes coming from block execution or state sync.
+	ApplyChanges(StorageChanges<Block>),
+	/// Execute block body (required) and compute state.
+	Execute,
+	/// Execute block body if parent state is available and compute state.
+	ExecuteIfPossible,
+	/// Don't execute or import state.
+	Skip,
+}
+
+impl<Block: BlockT> StateAction<Block> {
+	/// Check if execution checks that require runtime calls should be skipped.
+	pub fn skip_execution_checks(&self) -> bool {
+		match self {
+			StateAction::ApplyChanges(_) |
+			StateAction::Execute |
+			StateAction::ExecuteIfPossible => false,
+			StateAction::Skip => true,
+		}
+	}
+}
+
+/// Data required to import a Block.
+#[non_exhaustive]
+pub struct BlockImportParams<Block: BlockT> {
+	/// Origin of the Block
+	pub origin: BlockOrigin,
+	/// The header, without consensus post-digests applied. This should be in the same
+	/// state as it comes out of the runtime.
+	///
+	/// Consensus engines which alter the header (by adding post-runtime digests)
+	/// should strip those off in the initial verification process and pass them
+	/// via the `post_digests` field. During block authorship, they should
+	/// not be pushed to the header directly.
+	///
+	/// The reason for this distinction is so the header can be directly
+	/// re-executed in a runtime that checks digest equivalence -- the
+	/// post-runtime digests are pushed back on after.
+	pub header: Block::Header,
+	/// Justification(s) provided for this block from the outside.
+	pub justifications: Option<Justifications>,
+	/// Digest items that have been added after the runtime for external
+	/// work, like a consensus signature.
+	pub post_digests: Vec<DigestItem>,
+	/// The body of the block.
+	pub body: Option<Vec<Block::Extrinsic>>,
+	/// Indexed transaction body of the block.
+	pub indexed_body: Option<Vec<Vec<u8>>>,
+	/// Specify how the new state is computed.
+	pub state_action: StateAction<Block>,
+	/// Is this block finalized already?
+	/// `true` implies instant finality.
+	pub finalized: bool,
+	/// Intermediate values that are interpreted by block importers. Each block importer,
+	/// upon handling a value, removes it from the intermediate list. The final block importer
+	/// rejects block import if there are still intermediate values that remain unhandled.
+	pub intermediates: HashMap<Cow<'static, [u8]>, Box<dyn Any + Send>>,
+	/// Auxiliary consensus data produced by the block.
+	/// Contains a list of key-value pairs. If values are `None`, the keys will be deleted. These
+	/// changes will be applied to `AuxStore` database all as one batch, which is more efficient
+	/// than updating `AuxStore` directly.
+	pub auxiliary: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+	/// Fork choice strategy of this import. This should only be set by a
+	/// synchronous import, otherwise it may race against other imports.
+	/// `None` indicates that the current verifier or importer cannot yet
+	/// determine the fork choice value, and it expects subsequent importer
+	/// to modify it. If `None` is passed all the way down to bottom block
+	/// importer, the import fails with an `IncompletePipeline` error.
+	pub fork_choice: Option<ForkChoiceStrategy>,
+	/// Re-validate existing block.
+	pub import_existing: bool,
+	/// Cached full header hash (with post-digests applied).
+	pub post_hash: Option<Block::Hash>,
+}
+
+impl<Block: BlockT> BlockImportParams<Block> {
+	/// Create a new block import params.
+	pub fn new(origin: BlockOrigin, header: Block::Header) -> Self {
+		Self {
+			origin,
+			header,
+			justifications: None,
+			post_digests: Vec::new(),
+			body: None,
+			indexed_body: None,
+			state_action: StateAction::Execute,
+			finalized: false,
+			intermediates: HashMap::new(),
+			auxiliary: Vec::new(),
+			fork_choice: None,
+			import_existing: false,
+			post_hash: None,
+		}
+	}
+
+	/// Get the full header hash (with post-digests applied).
+	pub fn post_hash(&self) -> Block::Hash {
+		if let Some(hash) = self.post_hash {
+			hash
+		} else {
+			self.post_header().hash()
+		}
+	}
+
+	/// Get the post header.
+	pub fn post_header(&self) -> Block::Header {
+		if self.post_digests.is_empty() {
+			self.header.clone()
+		} else {
+			let mut hdr = self.header.clone();
+			for digest_item in &self.post_digests {
+				hdr.digest_mut().push(digest_item.clone());
+			}
+
+			hdr
+		}
+	}
+
+	/// Insert intermediate by given key.
+	pub fn insert_intermediate<T: 'static + Send>(&mut self, key: &'static [u8], value: T) {
+		self.intermediates.insert(Cow::from(key), Box::new(value));
+	}
+
+	/// Remove and return intermediate by given key.
+	pub fn remove_intermediate<T: 'static>(&mut self, key: &[u8]) -> Result<T, Error> {
+		let (k, v) = self.intermediates.remove_entry(key).ok_or(Error::NoIntermediate)?;
+
+		v.downcast::<T>().map(|v| *v).map_err(|v| {
+			self.intermediates.insert(k, v);
+			Error::InvalidIntermediate
+		})
+	}
+
+	/// Get a reference to a given intermediate.
+	pub fn get_intermediate<T: 'static>(&self, key: &[u8]) -> Result<&T, Error> {
+		self.intermediates
+			.get(key)
+			.ok_or(Error::NoIntermediate)?
+			.downcast_ref::<T>()
+			.ok_or(Error::InvalidIntermediate)
+	}
+
+	/// Get a mutable reference to a given intermediate.
+	pub fn get_intermediate_mut<T: 'static>(&mut self, key: &[u8]) -> Result<&mut T, Error> {
+		self.intermediates
+			.get_mut(key)
+			.ok_or(Error::NoIntermediate)?
+			.downcast_mut::<T>()
+			.ok_or(Error::InvalidIntermediate)
+	}
+
+	/// Check if this block contains state import action
+	pub fn with_state(&self) -> bool {
+		matches!(self.state_action, StateAction::ApplyChanges(StorageChanges::Import(_)))
+	}
+}
+
+/// Block import trait.
+#[async_trait::async_trait]
+pub trait BlockImport<B: BlockT> {
+	/// The error type.
+	type Error: std::error::Error + Send + 'static;
+
+	/// Check block preconditions.
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<B>,
+	) -> Result<ImportResult, Self::Error>;
+
+	/// Import a block.
+	async fn import_block(
+		&mut self,
+		block: BlockImportParams<B>,
+	) -> Result<ImportResult, Self::Error>;
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT> BlockImport<B> for crate::import_queue::BoxBlockImport<B> {
+	type Error = sp_consensus::error::Error;
+
+	/// Check block preconditions.
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<B>,
+	) -> Result<ImportResult, Self::Error> {
+		(**self).check_block(block).await
+	}
+
+	/// Import a block.
+	async fn import_block(
+		&mut self,
+		block: BlockImportParams<B>,
+	) -> Result<ImportResult, Self::Error> {
+		(**self).import_block(block).await
+	}
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT, T, E: std::error::Error + Send + 'static> BlockImport<B> for Arc<T>
+where
+	for<'r> &'r T: BlockImport<B, Error = E>,
+	T: Send + Sync,
+{
+	type Error = E;
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<B>,
+	) -> Result<ImportResult, Self::Error> {
+		(&**self).check_block(block).await
+	}
+
+	async fn import_block(
+		&mut self,
+		block: BlockImportParams<B>,
+	) -> Result<ImportResult, Self::Error> {
+		(&**self).import_block(block).await
+	}
+}
+
+/// Justification import trait
+#[async_trait::async_trait]
+pub trait JustificationImport<B: BlockT> {
+	type Error: std::error::Error + Send + 'static;
+
+	/// Called by the import queue when it is started. Returns a list of justifications to request
+	/// from the network.
+	async fn on_start(&mut self) -> Vec<(B::Hash, NumberFor<B>)>;
+
+	/// Import a Block justification and finalize the given block.
+	async fn import_justification(
+		&mut self,
+		hash: B::Hash,
+		number: NumberFor<B>,
+		justification: Justification,
+	) -> Result<(), Self::Error>;
+}
+
+/// Control the synchronization process of block justifications.
+///
+/// When importing blocks different consensus engines might require that
+/// additional finality data is provided (i.e. a justification for the block).
+/// This trait abstracts the required methods to issue those requests
+pub trait JustificationSyncLink<B: BlockT>: Send + Sync {
+	/// Request a justification for the given block.
+	fn request_justification(&self, hash: &B::Hash, number: NumberFor<B>);
+
+	/// Clear all pending justification requests.
+	fn clear_justification_requests(&self);
+}
+
+impl<B: BlockT> JustificationSyncLink<B> for () {
+	fn request_justification(&self, _hash: &B::Hash, _number: NumberFor<B>) {}
+
+	fn clear_justification_requests(&self) {}
+}
+
+impl<B: BlockT, L: JustificationSyncLink<B>> JustificationSyncLink<B> for Arc<L> {
+	fn request_justification(&self, hash: &B::Hash, number: NumberFor<B>) {
+		L::request_justification(self, hash, number);
+	}
+
+	fn clear_justification_requests(&self) {
+		L::clear_justification_requests(self);
+	}
+}
diff --git a/substrate/client/consensus/common/src/import_queue.rs b/substrate/client/consensus/common/src/import_queue.rs
new file mode 100644
index 0000000000000000000000000000000000000000..39d5bf8ed35d17468a8d8819a423f22a0d80667c
--- /dev/null
+++ b/substrate/client/consensus/common/src/import_queue.rs
@@ -0,0 +1,350 @@
+// 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/>.
+
+//! Import Queue primitive: something which can verify and import blocks.
+//!
+//! This serves as an intermediate and abstracted step between synchronization
+//! and import. Each mode of consensus will have its own requirements for block
+//! verification. Some algorithms can verify in parallel, while others only
+//! sequentially.
+//!
+//! The `ImportQueue` trait allows such verification strategies to be
+//! instantiated. The `BasicQueue` and `BasicVerifier` traits allow serial
+//! queues to be instantiated simply.
+
+use log::{debug, trace};
+
+use sp_consensus::{error::Error as ConsensusError, BlockOrigin};
+use sp_runtime::{
+	traits::{Block as BlockT, Header as _, NumberFor},
+	Justifications,
+};
+
+use crate::{
+	block_import::{
+		BlockCheckParams, BlockImport, BlockImportParams, ImportResult, ImportedAux, ImportedState,
+		JustificationImport, StateAction,
+	},
+	metrics::Metrics,
+};
+
+pub use basic_queue::BasicQueue;
+
+const LOG_TARGET: &str = "sync::import-queue";
+
+/// A commonly-used Import Queue type.
+///
+/// This defines the transaction type of the `BasicQueue` to be the transaction type for a client.
+pub type DefaultImportQueue<Block> = BasicQueue<Block>;
+
+mod basic_queue;
+pub mod buffered_link;
+pub mod mock;
+
+/// Shared block import struct used by the queue.
+pub type BoxBlockImport<B> = Box<dyn BlockImport<B, Error = ConsensusError> + Send + Sync>;
+
+/// Shared justification import struct used by the queue.
+pub type BoxJustificationImport<B> =
+	Box<dyn JustificationImport<B, Error = ConsensusError> + Send + Sync>;
+
+/// Maps to the RuntimeOrigin used by the network.
+pub type RuntimeOrigin = libp2p_identity::PeerId;
+
+/// Block data used by the queue.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct IncomingBlock<B: BlockT> {
+	/// Block header hash.
+	pub hash: <B as BlockT>::Hash,
+	/// Block header if requested.
+	pub header: Option<<B as BlockT>::Header>,
+	/// Block body if requested.
+	pub body: Option<Vec<<B as BlockT>::Extrinsic>>,
+	/// Indexed block body if requested.
+	pub indexed_body: Option<Vec<Vec<u8>>>,
+	/// Justification(s) if requested.
+	pub justifications: Option<Justifications>,
+	/// The peer, we received this from
+	pub origin: Option<RuntimeOrigin>,
+	/// Allow importing the block skipping state verification if parent state is missing.
+	pub allow_missing_state: bool,
+	/// Skip block execution and state verification.
+	pub skip_execution: bool,
+	/// Re-validate existing block.
+	pub import_existing: bool,
+	/// Do not compute new state, but rather set it to the given set.
+	pub state: Option<ImportedState<B>>,
+}
+
+/// Verify a justification of a block
+#[async_trait::async_trait]
+pub trait Verifier<B: BlockT>: Send {
+	/// Verify the given block data and return the `BlockImportParams` to
+	/// continue the block import process.
+	async fn verify(&mut self, block: BlockImportParams<B>)
+		-> Result<BlockImportParams<B>, String>;
+}
+
+/// Blocks import queue API.
+///
+/// The `import_*` methods can be called in order to send elements for the import queue to verify.
+pub trait ImportQueueService<B: BlockT>: Send {
+	/// Import bunch of blocks.
+	fn import_blocks(&mut self, origin: BlockOrigin, blocks: Vec<IncomingBlock<B>>);
+
+	/// Import block justifications.
+	fn import_justifications(
+		&mut self,
+		who: RuntimeOrigin,
+		hash: B::Hash,
+		number: NumberFor<B>,
+		justifications: Justifications,
+	);
+}
+
+#[async_trait::async_trait]
+pub trait ImportQueue<B: BlockT>: Send {
+	/// Get a copy of the handle to [`ImportQueueService`].
+	fn service(&self) -> Box<dyn ImportQueueService<B>>;
+
+	/// Get a reference to the handle to [`ImportQueueService`].
+	fn service_ref(&mut self) -> &mut dyn ImportQueueService<B>;
+
+	/// This method should behave in a way similar to `Future::poll`. It can register the current
+	/// task and notify later when more actions are ready to be polled. To continue the comparison,
+	/// it is as if this method always returned `Poll::Pending`.
+	fn poll_actions(&mut self, cx: &mut futures::task::Context, link: &mut dyn Link<B>);
+
+	/// Start asynchronous runner for import queue.
+	///
+	/// Takes an object implementing [`Link`] which allows the import queue to
+	/// influece the synchronization process.
+	async fn run(self, link: Box<dyn Link<B>>);
+}
+
+/// Hooks that the verification queue can use to influence the synchronization
+/// algorithm.
+pub trait Link<B: BlockT>: Send {
+	/// Batch of blocks imported, with or without error.
+	fn blocks_processed(
+		&mut self,
+		_imported: usize,
+		_count: usize,
+		_results: Vec<(BlockImportResult<B>, B::Hash)>,
+	) {
+	}
+
+	/// Justification import result.
+	fn justification_imported(
+		&mut self,
+		_who: RuntimeOrigin,
+		_hash: &B::Hash,
+		_number: NumberFor<B>,
+		_success: bool,
+	) {
+	}
+
+	/// Request a justification for the given block.
+	fn request_justification(&mut self, _hash: &B::Hash, _number: NumberFor<B>) {}
+}
+
+/// Block import successful result.
+#[derive(Debug, PartialEq)]
+pub enum BlockImportStatus<N: std::fmt::Debug + PartialEq> {
+	/// Imported known block.
+	ImportedKnown(N, Option<RuntimeOrigin>),
+	/// Imported unknown block.
+	ImportedUnknown(N, ImportedAux, Option<RuntimeOrigin>),
+}
+
+impl<N: std::fmt::Debug + PartialEq> BlockImportStatus<N> {
+	/// Returns the imported block number.
+	pub fn number(&self) -> &N {
+		match self {
+			BlockImportStatus::ImportedKnown(n, _) |
+			BlockImportStatus::ImportedUnknown(n, _, _) => n,
+		}
+	}
+}
+
+/// Block import error.
+#[derive(Debug, thiserror::Error)]
+pub enum BlockImportError {
+	/// Block missed header, can't be imported
+	#[error("block is missing a header (origin = {0:?})")]
+	IncompleteHeader(Option<RuntimeOrigin>),
+
+	/// Block verification failed, can't be imported
+	#[error("block verification failed (origin = {0:?}): {1}")]
+	VerificationFailed(Option<RuntimeOrigin>, String),
+
+	/// Block is known to be Bad
+	#[error("bad block (origin = {0:?})")]
+	BadBlock(Option<RuntimeOrigin>),
+
+	/// Parent state is missing.
+	#[error("block is missing parent state")]
+	MissingState,
+
+	/// Block has an unknown parent
+	#[error("block has an unknown parent")]
+	UnknownParent,
+
+	/// Block import has been cancelled. This can happen if the parent block fails to be imported.
+	#[error("import has been cancelled")]
+	Cancelled,
+
+	/// Other error.
+	#[error("consensus error: {0}")]
+	Other(ConsensusError),
+}
+
+type BlockImportResult<B> = Result<BlockImportStatus<NumberFor<B>>, BlockImportError>;
+
+/// Single block import function.
+pub async fn import_single_block<B: BlockT, V: Verifier<B>>(
+	import_handle: &mut impl BlockImport<B, Error = ConsensusError>,
+	block_origin: BlockOrigin,
+	block: IncomingBlock<B>,
+	verifier: &mut V,
+) -> BlockImportResult<B> {
+	import_single_block_metered(import_handle, block_origin, block, verifier, None).await
+}
+
+/// Single block import function with metering.
+pub(crate) async fn import_single_block_metered<B: BlockT, V: Verifier<B>>(
+	import_handle: &mut impl BlockImport<B, Error = ConsensusError>,
+	block_origin: BlockOrigin,
+	block: IncomingBlock<B>,
+	verifier: &mut V,
+	metrics: Option<Metrics>,
+) -> BlockImportResult<B> {
+	let peer = block.origin;
+
+	let (header, justifications) = match (block.header, block.justifications) {
+		(Some(header), justifications) => (header, justifications),
+		(None, _) => {
+			if let Some(ref peer) = peer {
+				debug!(target: LOG_TARGET, "Header {} was not provided by {} ", block.hash, peer);
+			} else {
+				debug!(target: LOG_TARGET, "Header {} was not provided ", block.hash);
+			}
+			return Err(BlockImportError::IncompleteHeader(peer))
+		},
+	};
+
+	trace!(target: LOG_TARGET, "Header {} has {:?} logs", block.hash, header.digest().logs().len());
+
+	let number = *header.number();
+	let hash = block.hash;
+	let parent_hash = *header.parent_hash();
+
+	let import_handler = |import| match import {
+		Ok(ImportResult::AlreadyInChain) => {
+			trace!(target: LOG_TARGET, "Block already in chain {}: {:?}", number, hash);
+			Ok(BlockImportStatus::ImportedKnown(number, peer))
+		},
+		Ok(ImportResult::Imported(aux)) =>
+			Ok(BlockImportStatus::ImportedUnknown(number, aux, peer)),
+		Ok(ImportResult::MissingState) => {
+			debug!(
+				target: LOG_TARGET,
+				"Parent state is missing for {}: {:?}, parent: {:?}", number, hash, parent_hash
+			);
+			Err(BlockImportError::MissingState)
+		},
+		Ok(ImportResult::UnknownParent) => {
+			debug!(
+				target: LOG_TARGET,
+				"Block with unknown parent {}: {:?}, parent: {:?}", number, hash, parent_hash
+			);
+			Err(BlockImportError::UnknownParent)
+		},
+		Ok(ImportResult::KnownBad) => {
+			debug!(target: LOG_TARGET, "Peer gave us a bad block {}: {:?}", number, hash);
+			Err(BlockImportError::BadBlock(peer))
+		},
+		Err(e) => {
+			debug!(target: LOG_TARGET, "Error importing block {}: {:?}: {}", number, hash, e);
+			Err(BlockImportError::Other(e))
+		},
+	};
+
+	match import_handler(
+		import_handle
+			.check_block(BlockCheckParams {
+				hash,
+				number,
+				parent_hash,
+				allow_missing_state: block.allow_missing_state,
+				import_existing: block.import_existing,
+				allow_missing_parent: block.state.is_some(),
+			})
+			.await,
+	)? {
+		BlockImportStatus::ImportedUnknown { .. } => (),
+		r => return Ok(r), // Any other successful result means that the block is already imported.
+	}
+
+	let started = std::time::Instant::now();
+
+	let mut import_block = BlockImportParams::new(block_origin, header);
+	import_block.body = block.body;
+	import_block.justifications = justifications;
+	import_block.post_hash = Some(hash);
+	import_block.import_existing = block.import_existing;
+	import_block.indexed_body = block.indexed_body;
+
+	if let Some(state) = block.state {
+		let changes = crate::block_import::StorageChanges::Import(state);
+		import_block.state_action = StateAction::ApplyChanges(changes);
+	} else if block.skip_execution {
+		import_block.state_action = StateAction::Skip;
+	} else if block.allow_missing_state {
+		import_block.state_action = StateAction::ExecuteIfPossible;
+	}
+
+	let import_block = verifier.verify(import_block).await.map_err(|msg| {
+		if let Some(ref peer) = peer {
+			trace!(
+				target: LOG_TARGET,
+				"Verifying {}({}) from {} failed: {}",
+				number,
+				hash,
+				peer,
+				msg
+			);
+		} else {
+			trace!(target: LOG_TARGET, "Verifying {}({}) failed: {}", number, hash, msg);
+		}
+		if let Some(metrics) = metrics.as_ref() {
+			metrics.report_verification(false, started.elapsed());
+		}
+		BlockImportError::VerificationFailed(peer, msg)
+	})?;
+
+	if let Some(metrics) = metrics.as_ref() {
+		metrics.report_verification(true, started.elapsed());
+	}
+
+	let imported = import_handle.import_block(import_block).await;
+	if let Some(metrics) = metrics.as_ref() {
+		metrics.report_verification_and_import(started.elapsed());
+	}
+	import_handler(imported)
+}
diff --git a/substrate/client/consensus/common/src/import_queue/basic_queue.rs b/substrate/client/consensus/common/src/import_queue/basic_queue.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1cc7ec26fd1930100ebe45f9c1e8ba643bd5be37
--- /dev/null
+++ b/substrate/client/consensus/common/src/import_queue/basic_queue.rs
@@ -0,0 +1,688 @@
+// 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 futures::{
+	prelude::*,
+	task::{Context, Poll},
+};
+use futures_timer::Delay;
+use log::{debug, trace};
+use prometheus_endpoint::Registry;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_consensus::BlockOrigin;
+use sp_runtime::{
+	traits::{Block as BlockT, Header as HeaderT, NumberFor},
+	Justification, Justifications,
+};
+use std::{pin::Pin, time::Duration};
+
+use crate::{
+	import_queue::{
+		buffered_link::{self, BufferedLinkReceiver, BufferedLinkSender},
+		import_single_block_metered, BlockImportError, BlockImportStatus, BoxBlockImport,
+		BoxJustificationImport, ImportQueue, ImportQueueService, IncomingBlock, Link,
+		RuntimeOrigin, Verifier, LOG_TARGET,
+	},
+	metrics::Metrics,
+};
+
+/// Interface to a basic block import queue that is importing blocks sequentially in a separate
+/// task, with plugable verification.
+pub struct BasicQueue<B: BlockT> {
+	/// Handle for sending justification and block import messages to the background task.
+	handle: BasicQueueHandle<B>,
+	/// Results coming from the worker task.
+	result_port: BufferedLinkReceiver<B>,
+}
+
+impl<B: BlockT> Drop for BasicQueue<B> {
+	fn drop(&mut self) {
+		// Flush the queue and close the receiver to terminate the future.
+		self.handle.close();
+		self.result_port.close();
+	}
+}
+
+impl<B: BlockT> BasicQueue<B> {
+	/// Instantiate a new basic queue, with given verifier.
+	///
+	/// This creates a background task, and calls `on_start` on the justification importer.
+	pub fn new<V: 'static + Verifier<B>>(
+		verifier: V,
+		block_import: BoxBlockImport<B>,
+		justification_import: Option<BoxJustificationImport<B>>,
+		spawner: &impl sp_core::traits::SpawnEssentialNamed,
+		prometheus_registry: Option<&Registry>,
+	) -> Self {
+		let (result_sender, result_port) = buffered_link::buffered_link(100_000);
+
+		let metrics = prometheus_registry.and_then(|r| {
+			Metrics::register(r)
+				.map_err(|err| {
+					log::warn!("Failed to register Prometheus metrics: {}", err);
+				})
+				.ok()
+		});
+
+		let (future, justification_sender, block_import_sender) = BlockImportWorker::new(
+			result_sender,
+			verifier,
+			block_import,
+			justification_import,
+			metrics,
+		);
+
+		spawner.spawn_essential_blocking(
+			"basic-block-import-worker",
+			Some("block-import"),
+			future.boxed(),
+		);
+
+		Self {
+			handle: BasicQueueHandle::new(justification_sender, block_import_sender),
+			result_port,
+		}
+	}
+}
+
+#[derive(Clone)]
+struct BasicQueueHandle<B: BlockT> {
+	/// Channel to send justification import messages to the background task.
+	justification_sender: TracingUnboundedSender<worker_messages::ImportJustification<B>>,
+	/// Channel to send block import messages to the background task.
+	block_import_sender: TracingUnboundedSender<worker_messages::ImportBlocks<B>>,
+}
+
+impl<B: BlockT> BasicQueueHandle<B> {
+	pub fn new(
+		justification_sender: TracingUnboundedSender<worker_messages::ImportJustification<B>>,
+		block_import_sender: TracingUnboundedSender<worker_messages::ImportBlocks<B>>,
+	) -> Self {
+		Self { justification_sender, block_import_sender }
+	}
+
+	pub fn close(&mut self) {
+		self.justification_sender.close();
+		self.block_import_sender.close();
+	}
+}
+
+impl<B: BlockT> ImportQueueService<B> for BasicQueueHandle<B> {
+	fn import_blocks(&mut self, origin: BlockOrigin, blocks: Vec<IncomingBlock<B>>) {
+		if blocks.is_empty() {
+			return
+		}
+
+		trace!(target: LOG_TARGET, "Scheduling {} blocks for import", blocks.len());
+		let res = self
+			.block_import_sender
+			.unbounded_send(worker_messages::ImportBlocks(origin, blocks));
+
+		if res.is_err() {
+			log::error!(
+				target: LOG_TARGET,
+				"import_blocks: Background import task is no longer alive"
+			);
+		}
+	}
+
+	fn import_justifications(
+		&mut self,
+		who: RuntimeOrigin,
+		hash: B::Hash,
+		number: NumberFor<B>,
+		justifications: Justifications,
+	) {
+		for justification in justifications {
+			let res = self.justification_sender.unbounded_send(
+				worker_messages::ImportJustification(who, hash, number, justification),
+			);
+
+			if res.is_err() {
+				log::error!(
+					target: LOG_TARGET,
+					"import_justification: Background import task is no longer alive"
+				);
+			}
+		}
+	}
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT> ImportQueue<B> for BasicQueue<B> {
+	/// Get handle to [`ImportQueueService`].
+	fn service(&self) -> Box<dyn ImportQueueService<B>> {
+		Box::new(self.handle.clone())
+	}
+
+	/// Get a reference to the handle to [`ImportQueueService`].
+	fn service_ref(&mut self) -> &mut dyn ImportQueueService<B> {
+		&mut self.handle
+	}
+
+	/// Poll actions from network.
+	fn poll_actions(&mut self, cx: &mut Context, link: &mut dyn Link<B>) {
+		if self.result_port.poll_actions(cx, link).is_err() {
+			log::error!(
+				target: LOG_TARGET,
+				"poll_actions: Background import task is no longer alive"
+			);
+		}
+	}
+
+	/// Start asynchronous runner for import queue.
+	///
+	/// Takes an object implementing [`Link`] which allows the import queue to
+	/// influece the synchronization process.
+	async fn run(mut self, mut link: Box<dyn Link<B>>) {
+		loop {
+			if let Err(_) = self.result_port.next_action(&mut *link).await {
+				log::error!(target: "sync", "poll_actions: Background import task is no longer alive");
+				return
+			}
+		}
+	}
+}
+
+/// Messages destinated to the background worker.
+mod worker_messages {
+	use super::*;
+
+	pub struct ImportBlocks<B: BlockT>(pub BlockOrigin, pub Vec<IncomingBlock<B>>);
+	pub struct ImportJustification<B: BlockT>(
+		pub RuntimeOrigin,
+		pub B::Hash,
+		pub NumberFor<B>,
+		pub Justification,
+	);
+}
+
+/// The process of importing blocks.
+///
+/// This polls the `block_import_receiver` for new blocks to import and than awaits on
+/// importing these blocks. After each block is imported, this async function yields once
+/// to give other futures the possibility to be run.
+///
+/// Returns when `block_import` ended.
+async fn block_import_process<B: BlockT>(
+	mut block_import: BoxBlockImport<B>,
+	mut verifier: impl Verifier<B>,
+	mut result_sender: BufferedLinkSender<B>,
+	mut block_import_receiver: TracingUnboundedReceiver<worker_messages::ImportBlocks<B>>,
+	metrics: Option<Metrics>,
+	delay_between_blocks: Duration,
+) {
+	loop {
+		let worker_messages::ImportBlocks(origin, blocks) = match block_import_receiver.next().await
+		{
+			Some(blocks) => blocks,
+			None => {
+				log::debug!(
+					target: LOG_TARGET,
+					"Stopping block import because the import channel was closed!",
+				);
+				return
+			},
+		};
+
+		let res = import_many_blocks(
+			&mut block_import,
+			origin,
+			blocks,
+			&mut verifier,
+			delay_between_blocks,
+			metrics.clone(),
+		)
+		.await;
+
+		result_sender.blocks_processed(res.imported, res.block_count, res.results);
+	}
+}
+
+struct BlockImportWorker<B: BlockT> {
+	result_sender: BufferedLinkSender<B>,
+	justification_import: Option<BoxJustificationImport<B>>,
+	metrics: Option<Metrics>,
+}
+
+impl<B: BlockT> BlockImportWorker<B> {
+	fn new<V: 'static + Verifier<B>>(
+		result_sender: BufferedLinkSender<B>,
+		verifier: V,
+		block_import: BoxBlockImport<B>,
+		justification_import: Option<BoxJustificationImport<B>>,
+		metrics: Option<Metrics>,
+	) -> (
+		impl Future<Output = ()> + Send,
+		TracingUnboundedSender<worker_messages::ImportJustification<B>>,
+		TracingUnboundedSender<worker_messages::ImportBlocks<B>>,
+	) {
+		use worker_messages::*;
+
+		let (justification_sender, mut justification_port) =
+			tracing_unbounded("mpsc_import_queue_worker_justification", 100_000);
+
+		let (block_import_sender, block_import_port) =
+			tracing_unbounded("mpsc_import_queue_worker_blocks", 100_000);
+
+		let mut worker = BlockImportWorker { result_sender, justification_import, metrics };
+
+		let delay_between_blocks = Duration::default();
+
+		let future = async move {
+			// Let's initialize `justification_import`
+			if let Some(justification_import) = worker.justification_import.as_mut() {
+				for (hash, number) in justification_import.on_start().await {
+					worker.result_sender.request_justification(&hash, number);
+				}
+			}
+
+			let block_import_process = block_import_process(
+				block_import,
+				verifier,
+				worker.result_sender.clone(),
+				block_import_port,
+				worker.metrics.clone(),
+				delay_between_blocks,
+			);
+			futures::pin_mut!(block_import_process);
+
+			loop {
+				// If the results sender is closed, that means that the import queue is shutting
+				// down and we should end this future.
+				if worker.result_sender.is_closed() {
+					log::debug!(
+						target: LOG_TARGET,
+						"Stopping block import because result channel was closed!",
+					);
+					return
+				}
+
+				// Make sure to first process all justifications
+				while let Poll::Ready(justification) = futures::poll!(justification_port.next()) {
+					match justification {
+						Some(ImportJustification(who, hash, number, justification)) =>
+							worker.import_justification(who, hash, number, justification).await,
+						None => {
+							log::debug!(
+								target: LOG_TARGET,
+								"Stopping block import because justification channel was closed!",
+							);
+							return
+						},
+					}
+				}
+
+				if let Poll::Ready(()) = futures::poll!(&mut block_import_process) {
+					return
+				}
+
+				// All futures that we polled are now pending.
+				futures::pending!()
+			}
+		};
+
+		(future, justification_sender, block_import_sender)
+	}
+
+	async fn import_justification(
+		&mut self,
+		who: RuntimeOrigin,
+		hash: B::Hash,
+		number: NumberFor<B>,
+		justification: Justification,
+	) {
+		let started = std::time::Instant::now();
+
+		let success = match self.justification_import.as_mut() {
+			Some(justification_import) => justification_import
+				.import_justification(hash, number, justification)
+				.await
+				.map_err(|e| {
+					debug!(
+						target: LOG_TARGET,
+						"Justification import failed for hash = {:?} with number = {:?} coming from node = {:?} with error: {}",
+						hash,
+						number,
+						who,
+						e,
+					);
+					e
+				})
+				.is_ok(),
+			None => false,
+		};
+
+		if let Some(metrics) = self.metrics.as_ref() {
+			metrics.justification_import_time.observe(started.elapsed().as_secs_f64());
+		}
+
+		self.result_sender.justification_imported(who, &hash, number, success);
+	}
+}
+
+/// Result of [`import_many_blocks`].
+struct ImportManyBlocksResult<B: BlockT> {
+	/// The number of blocks imported successfully.
+	imported: usize,
+	/// The total number of blocks processed.
+	block_count: usize,
+	/// The import results for each block.
+	results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>,
+}
+
+/// Import several blocks at once, returning import result for each block.
+///
+/// This will yield after each imported block once, to ensure that other futures can
+/// be called as well.
+async fn import_many_blocks<B: BlockT, V: Verifier<B>>(
+	import_handle: &mut BoxBlockImport<B>,
+	blocks_origin: BlockOrigin,
+	blocks: Vec<IncomingBlock<B>>,
+	verifier: &mut V,
+	delay_between_blocks: Duration,
+	metrics: Option<Metrics>,
+) -> ImportManyBlocksResult<B> {
+	let count = blocks.len();
+
+	let blocks_range = match (
+		blocks.first().and_then(|b| b.header.as_ref().map(|h| h.number())),
+		blocks.last().and_then(|b| b.header.as_ref().map(|h| h.number())),
+	) {
+		(Some(first), Some(last)) if first != last => format!(" ({}..{})", first, last),
+		(Some(first), Some(_)) => format!(" ({})", first),
+		_ => Default::default(),
+	};
+
+	trace!(target: LOG_TARGET, "Starting import of {} blocks {}", count, blocks_range);
+
+	let mut imported = 0;
+	let mut results = vec![];
+	let mut has_error = false;
+	let mut blocks = blocks.into_iter();
+
+	// Blocks in the response/drain should be in ascending order.
+	loop {
+		// Is there any block left to import?
+		let block = match blocks.next() {
+			Some(b) => b,
+			None => {
+				// No block left to import, success!
+				return ImportManyBlocksResult { block_count: count, imported, results }
+			},
+		};
+
+		let block_number = block.header.as_ref().map(|h| *h.number());
+		let block_hash = block.hash;
+		let import_result = if has_error {
+			Err(BlockImportError::Cancelled)
+		} else {
+			// The actual import.
+			import_single_block_metered(
+				import_handle,
+				blocks_origin,
+				block,
+				verifier,
+				metrics.clone(),
+			)
+			.await
+		};
+
+		if let Some(metrics) = metrics.as_ref() {
+			metrics.report_import::<B>(&import_result);
+		}
+
+		if import_result.is_ok() {
+			trace!(
+				target: LOG_TARGET,
+				"Block imported successfully {:?} ({})",
+				block_number,
+				block_hash,
+			);
+			imported += 1;
+		} else {
+			has_error = true;
+		}
+
+		results.push((import_result, block_hash));
+
+		if delay_between_blocks != Duration::default() && !has_error {
+			Delay::new(delay_between_blocks).await;
+		} else {
+			Yield::new().await
+		}
+	}
+}
+
+/// A future that will always `yield` on the first call of `poll` but schedules the
+/// current task for re-execution.
+///
+/// This is done by getting the waker and calling `wake_by_ref` followed by returning
+/// `Pending`. The next time the `poll` is called, it will return `Ready`.
+struct Yield(bool);
+
+impl Yield {
+	fn new() -> Self {
+		Self(false)
+	}
+}
+
+impl Future for Yield {
+	type Output = ();
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+		if !self.0 {
+			self.0 = true;
+			cx.waker().wake_by_ref();
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		block_import::{
+			BlockCheckParams, BlockImport, BlockImportParams, ImportResult, JustificationImport,
+		},
+		import_queue::Verifier,
+	};
+	use futures::{executor::block_on, Future};
+	use sp_test_primitives::{Block, BlockNumber, Hash, Header};
+
+	#[async_trait::async_trait]
+	impl Verifier<Block> for () {
+		async fn verify(
+			&mut self,
+			block: BlockImportParams<Block>,
+		) -> Result<BlockImportParams<Block>, String> {
+			Ok(BlockImportParams::new(block.origin, block.header))
+		}
+	}
+
+	#[async_trait::async_trait]
+	impl BlockImport<Block> for () {
+		type Error = sp_consensus::Error;
+
+		async fn check_block(
+			&mut self,
+			_block: BlockCheckParams<Block>,
+		) -> Result<ImportResult, Self::Error> {
+			Ok(ImportResult::imported(false))
+		}
+
+		async fn import_block(
+			&mut self,
+			_block: BlockImportParams<Block>,
+		) -> Result<ImportResult, Self::Error> {
+			Ok(ImportResult::imported(true))
+		}
+	}
+
+	#[async_trait::async_trait]
+	impl JustificationImport<Block> for () {
+		type Error = sp_consensus::Error;
+
+		async fn on_start(&mut self) -> Vec<(Hash, BlockNumber)> {
+			Vec::new()
+		}
+
+		async fn import_justification(
+			&mut self,
+			_hash: Hash,
+			_number: BlockNumber,
+			_justification: Justification,
+		) -> Result<(), Self::Error> {
+			Ok(())
+		}
+	}
+
+	#[derive(Debug, PartialEq)]
+	enum Event {
+		JustificationImported(Hash),
+		BlockImported(Hash),
+	}
+
+	#[derive(Default)]
+	struct TestLink {
+		events: Vec<Event>,
+	}
+
+	impl Link<Block> for TestLink {
+		fn blocks_processed(
+			&mut self,
+			_imported: usize,
+			_count: usize,
+			results: Vec<(Result<BlockImportStatus<BlockNumber>, BlockImportError>, Hash)>,
+		) {
+			if let Some(hash) = results.into_iter().find_map(|(r, h)| r.ok().map(|_| h)) {
+				self.events.push(Event::BlockImported(hash));
+			}
+		}
+
+		fn justification_imported(
+			&mut self,
+			_who: RuntimeOrigin,
+			hash: &Hash,
+			_number: BlockNumber,
+			_success: bool,
+		) {
+			self.events.push(Event::JustificationImported(*hash))
+		}
+	}
+
+	#[test]
+	fn prioritizes_finality_work_over_block_import() {
+		let (result_sender, mut result_port) = buffered_link::buffered_link(100_000);
+
+		let (worker, finality_sender, block_import_sender) =
+			BlockImportWorker::new(result_sender, (), Box::new(()), Some(Box::new(())), None);
+		futures::pin_mut!(worker);
+
+		let import_block = |n| {
+			let header = Header {
+				parent_hash: Hash::random(),
+				number: n,
+				extrinsics_root: Hash::random(),
+				state_root: Default::default(),
+				digest: Default::default(),
+			};
+
+			let hash = header.hash();
+
+			block_import_sender
+				.unbounded_send(worker_messages::ImportBlocks(
+					BlockOrigin::Own,
+					vec![IncomingBlock {
+						hash,
+						header: Some(header),
+						body: None,
+						indexed_body: None,
+						justifications: None,
+						origin: None,
+						allow_missing_state: false,
+						import_existing: false,
+						state: None,
+						skip_execution: false,
+					}],
+				))
+				.unwrap();
+
+			hash
+		};
+
+		let import_justification = || {
+			let hash = Hash::random();
+			finality_sender
+				.unbounded_send(worker_messages::ImportJustification(
+					libp2p_identity::PeerId::random(),
+					hash,
+					1,
+					(*b"TEST", Vec::new()),
+				))
+				.unwrap();
+
+			hash
+		};
+
+		let mut link = TestLink::default();
+
+		// we send a bunch of tasks to the worker
+		let block1 = import_block(1);
+		let block2 = import_block(2);
+		let block3 = import_block(3);
+		let justification1 = import_justification();
+		let justification2 = import_justification();
+		let block4 = import_block(4);
+		let block5 = import_block(5);
+		let block6 = import_block(6);
+		let justification3 = import_justification();
+
+		// we poll the worker until we have processed 9 events
+		block_on(futures::future::poll_fn(|cx| {
+			while link.events.len() < 9 {
+				match Future::poll(Pin::new(&mut worker), cx) {
+					Poll::Pending => {},
+					Poll::Ready(()) => panic!("import queue worker should not conclude."),
+				}
+
+				result_port.poll_actions(cx, &mut link).unwrap();
+			}
+
+			Poll::Ready(())
+		}));
+
+		// all justification tasks must be done before any block import work
+		assert_eq!(
+			link.events,
+			vec![
+				Event::JustificationImported(justification1),
+				Event::JustificationImported(justification2),
+				Event::JustificationImported(justification3),
+				Event::BlockImported(block1),
+				Event::BlockImported(block2),
+				Event::BlockImported(block3),
+				Event::BlockImported(block4),
+				Event::BlockImported(block5),
+				Event::BlockImported(block6),
+			]
+		);
+	}
+}
diff --git a/substrate/client/consensus/common/src/import_queue/buffered_link.rs b/substrate/client/consensus/common/src/import_queue/buffered_link.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c23a4b0d5d0abdcb2ec9291f44a8709c349fc048
--- /dev/null
+++ b/substrate/client/consensus/common/src/import_queue/buffered_link.rs
@@ -0,0 +1,185 @@
+// 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/>.
+
+//! Provides the `buffered_link` utility.
+//!
+//! The buffered link is a channel that allows buffering the method calls on `Link`.
+//!
+//! # Example
+//!
+//! ```
+//! use sc_consensus::import_queue::Link;
+//! # use sc_consensus::import_queue::buffered_link::buffered_link;
+//! # use sp_test_primitives::Block;
+//! # struct DummyLink; impl Link<Block> for DummyLink {}
+//! # let mut my_link = DummyLink;
+//! let (mut tx, mut rx) = buffered_link::<Block>(100_000);
+//! tx.blocks_processed(0, 0, vec![]);
+//!
+//! // Calls `my_link.blocks_processed(0, 0, vec![])` when polled.
+//! let _fut = futures::future::poll_fn(move |cx| {
+//! 	rx.poll_actions(cx, &mut my_link);
+//! 	std::task::Poll::Pending::<()>
+//! });
+//! ```
+
+use crate::import_queue::{Link, RuntimeOrigin};
+use futures::prelude::*;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::{
+	pin::Pin,
+	task::{Context, Poll},
+};
+
+use super::BlockImportResult;
+
+/// Wraps around an unbounded channel from the `futures` crate. The sender implements `Link` and
+/// can be used to buffer commands, and the receiver can be used to poll said commands and transfer
+/// them to another link. `queue_size_warning` sets the warning threshold of the channel queue size.
+pub fn buffered_link<B: BlockT>(
+	queue_size_warning: usize,
+) -> (BufferedLinkSender<B>, BufferedLinkReceiver<B>) {
+	let (tx, rx) = tracing_unbounded("mpsc_buffered_link", queue_size_warning);
+	let tx = BufferedLinkSender { tx };
+	let rx = BufferedLinkReceiver { rx: rx.fuse() };
+	(tx, rx)
+}
+
+/// See [`buffered_link`].
+pub struct BufferedLinkSender<B: BlockT> {
+	tx: TracingUnboundedSender<BlockImportWorkerMsg<B>>,
+}
+
+impl<B: BlockT> BufferedLinkSender<B> {
+	/// Returns true if the sender points to nowhere.
+	///
+	/// Once `true` is returned, it is pointless to use the sender anymore.
+	pub fn is_closed(&self) -> bool {
+		self.tx.is_closed()
+	}
+}
+
+impl<B: BlockT> Clone for BufferedLinkSender<B> {
+	fn clone(&self) -> Self {
+		BufferedLinkSender { tx: self.tx.clone() }
+	}
+}
+
+/// Internal buffered message.
+pub enum BlockImportWorkerMsg<B: BlockT> {
+	BlocksProcessed(usize, usize, Vec<(BlockImportResult<B>, B::Hash)>),
+	JustificationImported(RuntimeOrigin, B::Hash, NumberFor<B>, bool),
+	RequestJustification(B::Hash, NumberFor<B>),
+}
+
+impl<B: BlockT> Link<B> for BufferedLinkSender<B> {
+	fn blocks_processed(
+		&mut self,
+		imported: usize,
+		count: usize,
+		results: Vec<(BlockImportResult<B>, B::Hash)>,
+	) {
+		let _ = self
+			.tx
+			.unbounded_send(BlockImportWorkerMsg::BlocksProcessed(imported, count, results));
+	}
+
+	fn justification_imported(
+		&mut self,
+		who: RuntimeOrigin,
+		hash: &B::Hash,
+		number: NumberFor<B>,
+		success: bool,
+	) {
+		let msg = BlockImportWorkerMsg::JustificationImported(who, *hash, number, success);
+		let _ = self.tx.unbounded_send(msg);
+	}
+
+	fn request_justification(&mut self, hash: &B::Hash, number: NumberFor<B>) {
+		let _ = self
+			.tx
+			.unbounded_send(BlockImportWorkerMsg::RequestJustification(*hash, number));
+	}
+}
+
+/// See [`buffered_link`].
+pub struct BufferedLinkReceiver<B: BlockT> {
+	rx: stream::Fuse<TracingUnboundedReceiver<BlockImportWorkerMsg<B>>>,
+}
+
+impl<B: BlockT> BufferedLinkReceiver<B> {
+	/// Send action for the synchronization to perform.
+	pub fn send_actions(&mut self, msg: BlockImportWorkerMsg<B>, link: &mut dyn Link<B>) {
+		match msg {
+			BlockImportWorkerMsg::BlocksProcessed(imported, count, results) =>
+				link.blocks_processed(imported, count, results),
+			BlockImportWorkerMsg::JustificationImported(who, hash, number, success) =>
+				link.justification_imported(who, &hash, number, success),
+			BlockImportWorkerMsg::RequestJustification(hash, number) =>
+				link.request_justification(&hash, number),
+		}
+	}
+
+	/// Polls for the buffered link actions. Any enqueued action will be propagated to the link
+	/// passed as parameter.
+	///
+	/// This method should behave in a way similar to `Future::poll`. It can register the current
+	/// task and notify later when more actions are ready to be polled. To continue the comparison,
+	/// it is as if this method always returned `Poll::Pending`.
+	///
+	/// Returns an error if the corresponding [`BufferedLinkSender`] has been closed.
+	pub fn poll_actions(&mut self, cx: &mut Context, link: &mut dyn Link<B>) -> Result<(), ()> {
+		loop {
+			let msg = match Stream::poll_next(Pin::new(&mut self.rx), cx) {
+				Poll::Ready(Some(msg)) => msg,
+				Poll::Ready(None) => break Err(()),
+				Poll::Pending => break Ok(()),
+			};
+
+			self.send_actions(msg, &mut *link);
+		}
+	}
+
+	/// Poll next element from import queue and send the corresponding action command over the link.
+	pub async fn next_action(&mut self, link: &mut dyn Link<B>) -> Result<(), ()> {
+		if let Some(msg) = self.rx.next().await {
+			self.send_actions(msg, link);
+			return Ok(())
+		}
+		Err(())
+	}
+
+	/// Close the channel.
+	pub fn close(&mut self) -> bool {
+		self.rx.get_mut().close()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use sp_test_primitives::Block;
+
+	#[test]
+	fn is_closed() {
+		let (tx, rx) = super::buffered_link::<Block>(1);
+		assert!(!tx.is_closed());
+		drop(rx);
+		assert!(tx.is_closed());
+	}
+}
diff --git a/substrate/client/consensus/common/src/import_queue/mock.rs b/substrate/client/consensus/common/src/import_queue/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..64ac532ded854194121815878b935aff0291e5cd
--- /dev/null
+++ b/substrate/client/consensus/common/src/import_queue/mock.rs
@@ -0,0 +1,46 @@
+// 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::*;
+
+mockall::mock! {
+	pub ImportQueueHandle<B: BlockT> {}
+
+	impl<B: BlockT> ImportQueueService<B> for ImportQueueHandle<B> {
+		fn import_blocks(&mut self, origin: BlockOrigin, blocks: Vec<IncomingBlock<B>>);
+		fn import_justifications(
+			&mut self,
+			who: RuntimeOrigin,
+			hash: B::Hash,
+			number: NumberFor<B>,
+			justifications: Justifications,
+		);
+	}
+}
+
+mockall::mock! {
+	pub ImportQueue<B: BlockT> {}
+
+	#[async_trait::async_trait]
+	impl<B: BlockT> ImportQueue<B> for ImportQueue<B> {
+		fn service(&self) -> Box<dyn ImportQueueService<B>>;
+		fn service_ref(&mut self) -> &mut dyn ImportQueueService<B>;
+		fn poll_actions<'a>(&mut self, cx: &mut futures::task::Context<'a>, link: &mut dyn Link<B>);
+		async fn run(self, link: Box<dyn Link<B>>);
+	}
+}
diff --git a/substrate/client/consensus/common/src/lib.rs b/substrate/client/consensus/common/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6bf1ed0b48b4db0f612c8ae40c0196077c4db413
--- /dev/null
+++ b/substrate/client/consensus/common/src/lib.rs
@@ -0,0 +1,39 @@
+// 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/>.
+
+//! Collection of common consensus specific implementations
+
+pub mod block_import;
+pub mod import_queue;
+pub mod metrics;
+
+pub use block_import::{
+	BlockCheckParams, BlockImport, BlockImportParams, ForkChoiceStrategy, ImportResult,
+	ImportedAux, ImportedState, JustificationImport, JustificationSyncLink, StateAction,
+	StorageChanges,
+};
+pub use import_queue::{
+	import_single_block, BasicQueue, BlockImportError, BlockImportStatus, BoxBlockImport,
+	BoxJustificationImport, DefaultImportQueue, ImportQueue, IncomingBlock, Link, Verifier,
+};
+
+mod longest_chain;
+
+pub mod shared_data;
+
+pub use longest_chain::LongestChain;
diff --git a/substrate/client/consensus/common/src/longest_chain.rs b/substrate/client/consensus/common/src/longest_chain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f27cde4982def3669acd6e9b24a3c9f0c0eae704
--- /dev/null
+++ b/substrate/client/consensus/common/src/longest_chain.rs
@@ -0,0 +1,157 @@
+// 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/>.
+
+//! Longest chain implementation
+
+use sc_client_api::backend;
+use sp_blockchain::{Backend, HeaderBackend};
+use sp_consensus::{Error as ConsensusError, SelectChain};
+use sp_runtime::traits::{Block as BlockT, Header, NumberFor};
+use std::{marker::PhantomData, sync::Arc};
+
+/// Implement Longest Chain Select implementation
+/// where 'longest' is defined as the highest number of blocks
+pub struct LongestChain<B, Block> {
+	backend: Arc<B>,
+	_phantom: PhantomData<Block>,
+}
+
+impl<B, Block> Clone for LongestChain<B, Block> {
+	fn clone(&self) -> Self {
+		let backend = self.backend.clone();
+		LongestChain { backend, _phantom: Default::default() }
+	}
+}
+
+impl<B, Block> LongestChain<B, Block>
+where
+	B: backend::Backend<Block>,
+	Block: BlockT,
+{
+	/// Instantiate a new LongestChain for Backend B
+	pub fn new(backend: Arc<B>) -> Self {
+		LongestChain { backend, _phantom: Default::default() }
+	}
+
+	fn best_hash(&self) -> sp_blockchain::Result<<Block as BlockT>::Hash> {
+		let info = self.backend.blockchain().info();
+		let import_lock = self.backend.get_import_lock();
+		let best_hash = self
+			.backend
+			.blockchain()
+			.longest_containing(info.best_hash, import_lock)?
+			.unwrap_or(info.best_hash);
+		Ok(best_hash)
+	}
+
+	fn best_header(&self) -> sp_blockchain::Result<<Block as BlockT>::Header> {
+		let best_hash = self.best_hash()?;
+		Ok(self
+			.backend
+			.blockchain()
+			.header(best_hash)?
+			.expect("given block hash was fetched from block in db; qed"))
+	}
+
+	/// Returns the highest descendant of the given block that is a valid
+	/// candidate to be finalized.
+	///
+	/// In this context, being a valid target means being an ancestor of
+	/// the best chain according to the `best_header` method.
+	///
+	/// If `maybe_max_number` is `Some(max_block_number)` the search is
+	/// limited to block `number <= max_block_number`. In other words
+	/// as if there were no blocks greater than `max_block_number`.
+	fn finality_target(
+		&self,
+		base_hash: Block::Hash,
+		maybe_max_number: Option<NumberFor<Block>>,
+	) -> sp_blockchain::Result<Block::Hash> {
+		use sp_blockchain::Error::{Application, MissingHeader};
+		let blockchain = self.backend.blockchain();
+
+		let mut current_head = self.best_header()?;
+		let mut best_hash = current_head.hash();
+
+		let base_header = blockchain
+			.header(base_hash)?
+			.ok_or_else(|| MissingHeader(base_hash.to_string()))?;
+		let base_number = *base_header.number();
+
+		if let Some(max_number) = maybe_max_number {
+			if max_number < base_number {
+				let msg = format!(
+					"Requested a finality target using max number {} below the base number {}",
+					max_number, base_number
+				);
+				return Err(Application(msg.into()))
+			}
+
+			while current_head.number() > &max_number {
+				best_hash = *current_head.parent_hash();
+				current_head = blockchain
+					.header(best_hash)?
+					.ok_or_else(|| MissingHeader(format!("{best_hash:?}")))?;
+			}
+		}
+
+		while current_head.hash() != base_hash {
+			if *current_head.number() < base_number {
+				let msg = format!(
+					"Requested a finality target using a base {:?} not in the best chain {:?}",
+					base_hash, best_hash,
+				);
+				return Err(Application(msg.into()))
+			}
+			let current_hash = *current_head.parent_hash();
+			current_head = blockchain
+				.header(current_hash)?
+				.ok_or_else(|| MissingHeader(format!("{best_hash:?}")))?;
+		}
+
+		Ok(best_hash)
+	}
+
+	fn leaves(&self) -> Result<Vec<<Block as BlockT>::Hash>, sp_blockchain::Error> {
+		self.backend.blockchain().leaves()
+	}
+}
+
+#[async_trait::async_trait]
+impl<B, Block> SelectChain<Block> for LongestChain<B, Block>
+where
+	B: backend::Backend<Block>,
+	Block: BlockT,
+{
+	async fn leaves(&self) -> Result<Vec<<Block as BlockT>::Hash>, ConsensusError> {
+		LongestChain::leaves(self).map_err(|e| ConsensusError::ChainLookup(e.to_string()))
+	}
+
+	async fn best_chain(&self) -> Result<<Block as BlockT>::Header, ConsensusError> {
+		LongestChain::best_header(self).map_err(|e| ConsensusError::ChainLookup(e.to_string()))
+	}
+
+	async fn finality_target(
+		&self,
+		base_hash: Block::Hash,
+		maybe_max_number: Option<NumberFor<Block>>,
+	) -> Result<Block::Hash, ConsensusError> {
+		LongestChain::finality_target(self, base_hash, maybe_max_number)
+			.map_err(|e| ConsensusError::ChainLookup(e.to_string()))
+	}
+}
diff --git a/substrate/client/consensus/common/src/metrics.rs b/substrate/client/consensus/common/src/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e807189d46165e63b06fffc495be460bc60dad62
--- /dev/null
+++ b/substrate/client/consensus/common/src/metrics.rs
@@ -0,0 +1,106 @@
+// 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/>.
+
+//! Metering tools for consensus
+
+use prometheus_endpoint::{
+	register, CounterVec, Histogram, HistogramOpts, HistogramVec, Opts, PrometheusError, Registry,
+	U64,
+};
+
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use crate::import_queue::{BlockImportError, BlockImportStatus};
+
+/// Generic Prometheus metrics for common consensus functionality.
+#[derive(Clone)]
+pub(crate) struct Metrics {
+	pub import_queue_processed: CounterVec<U64>,
+	pub block_verification_time: HistogramVec,
+	pub block_verification_and_import_time: Histogram,
+	pub justification_import_time: Histogram,
+}
+
+impl Metrics {
+	pub(crate) fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			import_queue_processed: register(
+				CounterVec::new(
+					Opts::new(
+						"substrate_import_queue_processed_total",
+						"Blocks processed by import queue",
+					),
+					&["result"], // 'success or failure
+				)?,
+				registry,
+			)?,
+			block_verification_time: register(
+				HistogramVec::new(
+					HistogramOpts::new(
+						"substrate_block_verification_time",
+						"Time taken to verify blocks",
+					),
+					&["result"],
+				)?,
+				registry,
+			)?,
+			block_verification_and_import_time: register(
+				Histogram::with_opts(HistogramOpts::new(
+					"substrate_block_verification_and_import_time",
+					"Time taken to verify and import blocks",
+				))?,
+				registry,
+			)?,
+			justification_import_time: register(
+				Histogram::with_opts(HistogramOpts::new(
+					"substrate_justification_import_time",
+					"Time taken to import justifications",
+				))?,
+				registry,
+			)?,
+		})
+	}
+
+	pub fn report_import<B: BlockT>(
+		&self,
+		result: &Result<BlockImportStatus<NumberFor<B>>, BlockImportError>,
+	) {
+		let label = match result {
+			Ok(_) => "success",
+			Err(BlockImportError::IncompleteHeader(_)) => "incomplete_header",
+			Err(BlockImportError::VerificationFailed(_, _)) => "verification_failed",
+			Err(BlockImportError::BadBlock(_)) => "bad_block",
+			Err(BlockImportError::MissingState) => "missing_state",
+			Err(BlockImportError::UnknownParent) => "unknown_parent",
+			Err(BlockImportError::Cancelled) => "cancelled",
+			Err(BlockImportError::Other(_)) => "failed",
+		};
+
+		self.import_queue_processed.with_label_values(&[label]).inc();
+	}
+
+	pub fn report_verification(&self, success: bool, time: std::time::Duration) {
+		self.block_verification_time
+			.with_label_values(&[if success { "success" } else { "verification_failed" }])
+			.observe(time.as_secs_f64());
+	}
+
+	pub fn report_verification_and_import(&self, time: std::time::Duration) {
+		self.block_verification_and_import_time.observe(time.as_secs_f64());
+	}
+}
diff --git a/substrate/client/consensus/common/src/shared_data.rs b/substrate/client/consensus/common/src/shared_data.rs
new file mode 100644
index 0000000000000000000000000000000000000000..efd41d0985454d69be9d99761e97dfe58e09fd9c
--- /dev/null
+++ b/substrate/client/consensus/common/src/shared_data.rs
@@ -0,0 +1,272 @@
+// 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/>.
+
+//! Provides a generic wrapper around shared data. See [`SharedData`] for more information.
+
+use parking_lot::{Condvar, MappedMutexGuard, Mutex, MutexGuard};
+use std::sync::Arc;
+
+/// Created by [`SharedDataLocked::release_mutex`].
+///
+/// As long as the object isn't dropped, the shared data is locked. It is advised to drop this
+/// object when the shared data doesn't need to be locked anymore. To get access to the shared data
+/// [`Self::upgrade`] is provided.
+#[must_use = "Shared data will be unlocked on drop!"]
+pub struct SharedDataLockedUpgradable<T> {
+	shared_data: SharedData<T>,
+}
+
+impl<T> SharedDataLockedUpgradable<T> {
+	/// Upgrade to a *real* mutex guard that will give access to the inner data.
+	///
+	/// Every call to this function will reaquire the mutex again.
+	pub fn upgrade(&mut self) -> MappedMutexGuard<T> {
+		MutexGuard::map(self.shared_data.inner.lock(), |i| &mut i.shared_data)
+	}
+}
+
+impl<T> Drop for SharedDataLockedUpgradable<T> {
+	fn drop(&mut self) {
+		let mut inner = self.shared_data.inner.lock();
+		// It should not be locked anymore
+		inner.locked = false;
+
+		// Notify all waiting threads.
+		self.shared_data.cond_var.notify_all();
+	}
+}
+
+/// Created by [`SharedData::shared_data_locked`].
+///
+/// As long as this object isn't dropped, the shared data is held in a mutex guard and the shared
+/// data is tagged as locked. Access to the shared data is provided through
+/// [`Deref`](std::ops::Deref) and [`DerefMut`](std::ops::DerefMut). The trick is to use
+/// [`Self::release_mutex`] to release the mutex, but still keep the shared data locked. This means
+/// every other thread trying to access the shared data in this time will need to wait until this
+/// lock is freed.
+///
+/// If this object is dropped without calling [`Self::release_mutex`], the lock will be dropped
+/// immediately.
+#[must_use = "Shared data will be unlocked on drop!"]
+pub struct SharedDataLocked<'a, T> {
+	/// The current active mutex guard holding the inner data.
+	inner: MutexGuard<'a, SharedDataInner<T>>,
+	/// The [`SharedData`] instance that created this instance.
+	///
+	/// This instance is only taken on drop or when calling [`Self::release_mutex`].
+	shared_data: Option<SharedData<T>>,
+}
+
+impl<'a, T> SharedDataLocked<'a, T> {
+	/// Release the mutex, but keep the shared data locked.
+	pub fn release_mutex(mut self) -> SharedDataLockedUpgradable<T> {
+		SharedDataLockedUpgradable {
+			shared_data: self.shared_data.take().expect("`shared_data` is only taken on drop; qed"),
+		}
+	}
+}
+
+impl<'a, T> Drop for SharedDataLocked<'a, T> {
+	fn drop(&mut self) {
+		if let Some(shared_data) = self.shared_data.take() {
+			// If the `shared_data` is still set, it means [`Self::release_mutex`] wasn't
+			// called and the lock should be released.
+			self.inner.locked = false;
+
+			// Notify all waiting threads about the released lock.
+			shared_data.cond_var.notify_all();
+		}
+	}
+}
+
+impl<'a, T> std::ops::Deref for SharedDataLocked<'a, T> {
+	type Target = T;
+
+	fn deref(&self) -> &Self::Target {
+		&self.inner.shared_data
+	}
+}
+
+impl<'a, T> std::ops::DerefMut for SharedDataLocked<'a, T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.inner.shared_data
+	}
+}
+
+/// Holds the shared data and if the shared data is currently locked.
+///
+/// For more information see [`SharedData`].
+struct SharedDataInner<T> {
+	/// The actual shared data that is protected here against concurrent access.
+	shared_data: T,
+	/// Is `shared_data` currently locked and can not be accessed?
+	locked: bool,
+}
+
+/// Some shared data that provides support for locking this shared data for some time.
+///
+/// When working with consensus engines there is often data that needs to be shared between multiple
+/// parts of the system, like block production and block import. This struct provides an abstraction
+/// for this shared data in a generic way.
+///
+/// The pain point when sharing this data is often the usage of mutex guards in an async context as
+/// this doesn't work for most of them as these guards don't implement `Send`. This abstraction
+/// provides a way to lock the shared data, while not having the mutex locked. So, the data stays
+/// locked and we are still able to hold this lock over an `await` call.
+///
+/// # Example
+///
+/// ```
+/// # use sc_consensus::shared_data::SharedData;
+///
+/// let shared_data = SharedData::new(String::from("hello world"));
+///
+/// let lock = shared_data.shared_data_locked();
+///
+/// let shared_data2 = shared_data.clone();
+/// let join_handle1 = std::thread::spawn(move || {
+///     // This will need to wait for the outer lock to be released before it can access the data.
+///     shared_data2.shared_data().push_str("1");
+/// });
+///
+/// assert_eq!(*lock, "hello world");
+///
+/// // Let us release the mutex, but we still keep it locked.
+/// // Now we could call `await` for example.
+/// let mut lock = lock.release_mutex();
+///
+/// let shared_data2 = shared_data.clone();
+/// let join_handle2 = std::thread::spawn(move || {
+///     shared_data2.shared_data().push_str("2");
+/// });
+///
+/// // We still have the lock and can upgrade it to access the data.
+/// assert_eq!(*lock.upgrade(), "hello world");
+/// lock.upgrade().push_str("3");
+///
+/// drop(lock);
+/// join_handle1.join().unwrap();
+/// join_handle2.join().unwrap();
+///
+/// let data = shared_data.shared_data();
+/// // As we don't know the order of the threads, we need to check for both combinations
+/// assert!(*data == "hello world321" || *data == "hello world312");
+/// ```
+///
+/// # Deadlock
+///
+/// Be aware that this data structure doesn't give you any guarantees that you can not create a
+/// deadlock. If you use [`release_mutex`](SharedDataLocked::release_mutex) followed by a call
+/// to [`shared_data`](Self::shared_data) in the same thread will make your program dead lock.
+/// The same applies when you are using a single threaded executor.
+pub struct SharedData<T> {
+	inner: Arc<Mutex<SharedDataInner<T>>>,
+	cond_var: Arc<Condvar>,
+}
+
+impl<T> Clone for SharedData<T> {
+	fn clone(&self) -> Self {
+		Self { inner: self.inner.clone(), cond_var: self.cond_var.clone() }
+	}
+}
+
+impl<T> SharedData<T> {
+	/// Create a new instance of [`SharedData`] to share the given `shared_data`.
+	pub fn new(shared_data: T) -> Self {
+		Self {
+			inner: Arc::new(Mutex::new(SharedDataInner { shared_data, locked: false })),
+			cond_var: Default::default(),
+		}
+	}
+
+	/// Acquire access to the shared data.
+	///
+	/// This will give mutable access to the shared data. After the returned mutex guard is dropped,
+	/// the shared data is accessible by other threads. So, this function should be used when
+	/// reading/writing of the shared data in a local context is required.
+	///
+	/// When requiring to lock shared data for some longer time, even with temporarily releasing the
+	/// lock, [`Self::shared_data_locked`] should be used.
+	pub fn shared_data(&self) -> MappedMutexGuard<T> {
+		let mut guard = self.inner.lock();
+
+		while guard.locked {
+			self.cond_var.wait(&mut guard);
+		}
+
+		debug_assert!(!guard.locked);
+
+		MutexGuard::map(guard, |i| &mut i.shared_data)
+	}
+
+	/// Acquire access to the shared data and lock it.
+	///
+	/// This will give mutable access to the shared data. The returned [`SharedDataLocked`]
+	/// provides the function [`SharedDataLocked::release_mutex`] to release the mutex, but
+	/// keeping the data locked. This is useful in async contexts for example where the data needs
+	/// to be locked, but a mutex guard can not be held.
+	///
+	/// For an example see [`SharedData`].
+	pub fn shared_data_locked(&self) -> SharedDataLocked<T> {
+		let mut guard = self.inner.lock();
+
+		while guard.locked {
+			self.cond_var.wait(&mut guard);
+		}
+
+		debug_assert!(!guard.locked);
+		guard.locked = true;
+
+		SharedDataLocked { inner: guard, shared_data: Some(self.clone()) }
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn shared_data_locking_works() {
+		const THREADS: u32 = 100;
+		let shared_data = SharedData::new(0u32);
+
+		let lock = shared_data.shared_data_locked();
+
+		for i in 0..THREADS {
+			let data = shared_data.clone();
+			std::thread::spawn(move || {
+				if i % 2 == 1 {
+					*data.shared_data() += 1;
+				} else {
+					let mut lock = data.shared_data_locked().release_mutex();
+					// Give the other threads some time to wake up
+					std::thread::sleep(std::time::Duration::from_millis(10));
+					*lock.upgrade() += 1;
+				}
+			});
+		}
+
+		let lock = lock.release_mutex();
+		std::thread::sleep(std::time::Duration::from_millis(100));
+		drop(lock);
+
+		while *shared_data.shared_data() < THREADS {
+			std::thread::sleep(std::time::Duration::from_millis(100));
+		}
+	}
+}
diff --git a/substrate/client/consensus/epochs/Cargo.toml b/substrate/client/consensus/epochs/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6ee4597541d228902b83b016f35e606c6250a42a
--- /dev/null
+++ b/substrate/client/consensus/epochs/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "sc-consensus-epochs"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Generic epochs-based utilities for consensus"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+fork-tree = { version = "3.0.0", path = "../../../utils/fork-tree" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../common" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
diff --git a/substrate/client/consensus/epochs/README.md b/substrate/client/consensus/epochs/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1e74e04172c2400f41d9d3c18037132412feb299
--- /dev/null
+++ b/substrate/client/consensus/epochs/README.md
@@ -0,0 +1,3 @@
+Generic utilities for epoch-based consensus engines.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/epochs/src/lib.rs b/substrate/client/consensus/epochs/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..29bb18e147c2b8aef2a172130e753bf0d2f7193d
--- /dev/null
+++ b/substrate/client/consensus/epochs/src/lib.rs
@@ -0,0 +1,1137 @@
+// 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/>.
+
+//! Generic utilities for epoch-based consensus engines.
+
+pub mod migration;
+
+use codec::{Decode, Encode};
+use fork_tree::{FilterAction, ForkTree};
+use sc_client_api::utils::is_descendent_of;
+use sp_blockchain::{Error as ClientError, HeaderBackend, HeaderMetadata};
+use sp_runtime::traits::{Block as BlockT, NumberFor, One, Zero};
+use std::{
+	borrow::{Borrow, BorrowMut},
+	collections::BTreeMap,
+	ops::{Add, Sub},
+};
+
+/// A builder for `is_descendent_of` functions.
+pub trait IsDescendentOfBuilder<Hash> {
+	/// The error returned by the function.
+	type Error: std::error::Error;
+	/// A function that can tell you if the second parameter is a descendent of
+	/// the first.
+	type IsDescendentOf: Fn(&Hash, &Hash) -> Result<bool, Self::Error>;
+
+	/// Build an `is_descendent_of` function.
+	///
+	/// The `current` parameter can be `Some` with the details a fresh block whose
+	/// details aren't yet stored, but its parent is.
+	///
+	/// The format of `current` when `Some` is `(current, current_parent)`.
+	fn build_is_descendent_of(&self, current: Option<(Hash, Hash)>) -> Self::IsDescendentOf;
+}
+
+/// Produce a descendent query object given the client.
+pub fn descendent_query<H, Block>(client: &H) -> HeaderBackendDescendentBuilder<&H, Block> {
+	HeaderBackendDescendentBuilder(client, std::marker::PhantomData)
+}
+
+/// Wrapper to get around unconstrained type errors when implementing
+/// `IsDescendentOfBuilder` for header backends.
+pub struct HeaderBackendDescendentBuilder<H, Block>(H, std::marker::PhantomData<Block>);
+
+impl<'a, H, Block> IsDescendentOfBuilder<Block::Hash>
+	for HeaderBackendDescendentBuilder<&'a H, Block>
+where
+	H: HeaderBackend<Block> + HeaderMetadata<Block, Error = ClientError>,
+	Block: BlockT,
+{
+	type Error = ClientError;
+	type IsDescendentOf = Box<dyn Fn(&Block::Hash, &Block::Hash) -> Result<bool, ClientError> + 'a>;
+
+	fn build_is_descendent_of(
+		&self,
+		current: Option<(Block::Hash, Block::Hash)>,
+	) -> Self::IsDescendentOf {
+		Box::new(is_descendent_of(self.0, current))
+	}
+}
+
+/// Epoch data, distinguish whether it is genesis or not.
+///
+/// Once an epoch is created, it must have a known `start_slot` and `end_slot`, which cannot be
+/// changed. Consensus engine may modify any other data in the epoch, if needed.
+pub trait Epoch: std::fmt::Debug {
+	/// Descriptor for the next epoch.
+	type NextEpochDescriptor;
+	/// Type of the slot number.
+	type Slot: Ord + Copy + std::fmt::Debug;
+
+	/// The starting slot of the epoch.
+	fn start_slot(&self) -> Self::Slot;
+	/// Produce the "end slot" of the epoch. This is NOT inclusive to the epoch,
+	/// i.e. the slots covered by the epoch are `self.start_slot() .. self.end_slot()`.
+	fn end_slot(&self) -> Self::Slot;
+	/// Increment the epoch data, using the next epoch descriptor.
+	fn increment(&self, descriptor: Self::NextEpochDescriptor) -> Self;
+}
+
+impl<'a, E: Epoch> From<&'a E> for EpochHeader<E> {
+	fn from(epoch: &'a E) -> EpochHeader<E> {
+		Self { start_slot: epoch.start_slot(), end_slot: epoch.end_slot() }
+	}
+}
+
+/// Header of epoch data, consisting of start and end slot.
+#[derive(Eq, PartialEq, Encode, Decode, Debug)]
+pub struct EpochHeader<E: Epoch> {
+	/// The starting slot of the epoch.
+	pub start_slot: E::Slot,
+	/// The end slot of the epoch. This is NOT inclusive to the epoch,
+	/// i.e. the slots covered by the epoch are `self.start_slot() .. self.end_slot()`.
+	pub end_slot: E::Slot,
+}
+
+impl<E: Epoch> Clone for EpochHeader<E> {
+	fn clone(&self) -> Self {
+		Self { start_slot: self.start_slot, end_slot: self.end_slot }
+	}
+}
+
+/// Position of the epoch identifier.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone, Debug)]
+pub enum EpochIdentifierPosition {
+	/// The identifier points to a genesis epoch `epoch_0`.
+	Genesis0,
+	/// The identifier points to a genesis epoch `epoch_1`.
+	Genesis1,
+	/// The identifier points to a regular epoch.
+	Regular,
+}
+
+/// Epoch identifier.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
+pub struct EpochIdentifier<Hash, Number> {
+	/// Location of the epoch.
+	pub position: EpochIdentifierPosition,
+	/// Hash of the block when the epoch is signaled.
+	pub hash: Hash,
+	/// Number of the block when the epoch is signaled.
+	pub number: Number,
+}
+
+/// The viable epoch under which a block can be verified.
+///
+/// If this is the first non-genesis block in the chain, then it will
+/// hold an `UnimportedGenesis` epoch.
+pub enum ViableEpoch<E, ERef = E> {
+	/// Unimported genesis viable epoch data.
+	UnimportedGenesis(E),
+	/// Regular viable epoch data.
+	Signaled(ERef),
+}
+
+impl<E, ERef> AsRef<E> for ViableEpoch<E, ERef>
+where
+	ERef: Borrow<E>,
+{
+	fn as_ref(&self) -> &E {
+		match *self {
+			ViableEpoch::UnimportedGenesis(ref e) => e,
+			ViableEpoch::Signaled(ref e) => e.borrow(),
+		}
+	}
+}
+
+impl<E, ERef> AsMut<E> for ViableEpoch<E, ERef>
+where
+	ERef: BorrowMut<E>,
+{
+	fn as_mut(&mut self) -> &mut E {
+		match *self {
+			ViableEpoch::UnimportedGenesis(ref mut e) => e,
+			ViableEpoch::Signaled(ref mut e) => e.borrow_mut(),
+		}
+	}
+}
+
+impl<E, ERef> ViableEpoch<E, ERef>
+where
+	E: Epoch + Clone,
+	ERef: Borrow<E>,
+{
+	/// Extract the underlying epoch, disregarding the fact that a genesis
+	/// epoch may be unimported.
+	pub fn into_cloned_inner(self) -> E {
+		match self {
+			ViableEpoch::UnimportedGenesis(e) => e,
+			ViableEpoch::Signaled(e) => e.borrow().clone(),
+		}
+	}
+
+	/// Get cloned value for the viable epoch.
+	pub fn into_cloned(self) -> ViableEpoch<E, E> {
+		match self {
+			ViableEpoch::UnimportedGenesis(e) => ViableEpoch::UnimportedGenesis(e),
+			ViableEpoch::Signaled(e) => ViableEpoch::Signaled(e.borrow().clone()),
+		}
+	}
+
+	/// Increment the epoch, yielding an `IncrementedEpoch` to be imported
+	/// into the fork-tree.
+	pub fn increment(&self, next_descriptor: E::NextEpochDescriptor) -> IncrementedEpoch<E> {
+		let next = self.as_ref().increment(next_descriptor);
+		let to_persist = match *self {
+			ViableEpoch::UnimportedGenesis(ref epoch_0) =>
+				PersistedEpoch::Genesis(epoch_0.clone(), next),
+			ViableEpoch::Signaled(_) => PersistedEpoch::Regular(next),
+		};
+
+		IncrementedEpoch(to_persist)
+	}
+}
+
+/// Descriptor for a viable epoch.
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub enum ViableEpochDescriptor<Hash, Number, E: Epoch> {
+	/// The epoch is an unimported genesis, with given start slot number.
+	UnimportedGenesis(E::Slot),
+	/// The epoch is signaled and has been imported, with given identifier and header.
+	Signaled(EpochIdentifier<Hash, Number>, EpochHeader<E>),
+}
+
+impl<Hash, Number, E: Epoch> ViableEpochDescriptor<Hash, Number, E> {
+	/// Start slot of the descriptor.
+	pub fn start_slot(&self) -> E::Slot {
+		match self {
+			Self::UnimportedGenesis(start_slot) => *start_slot,
+			Self::Signaled(_, header) => header.start_slot,
+		}
+	}
+}
+
+/// Persisted epoch stored in EpochChanges.
+#[derive(Clone, Encode, Decode, Debug)]
+pub enum PersistedEpoch<E> {
+	/// Genesis persisted epoch data. epoch_0, epoch_1.
+	Genesis(E, E),
+	/// Regular persisted epoch data. epoch_n.
+	Regular(E),
+}
+
+impl<E> PersistedEpoch<E> {
+	/// Returns if this is a genesis epoch.
+	pub fn is_genesis(&self) -> bool {
+		matches!(self, Self::Genesis(_, _))
+	}
+}
+
+impl<'a, E: Epoch> From<&'a PersistedEpoch<E>> for PersistedEpochHeader<E> {
+	fn from(epoch: &'a PersistedEpoch<E>) -> Self {
+		match epoch {
+			PersistedEpoch::Genesis(ref epoch_0, ref epoch_1) =>
+				PersistedEpochHeader::Genesis(epoch_0.into(), epoch_1.into()),
+			PersistedEpoch::Regular(ref epoch_n) => PersistedEpochHeader::Regular(epoch_n.into()),
+		}
+	}
+}
+
+impl<E: Epoch> PersistedEpoch<E> {
+	/// Map the epoch to a different type using a conversion function.
+	pub fn map<B, F, Hash, Number>(self, h: &Hash, n: &Number, f: &mut F) -> PersistedEpoch<B>
+	where
+		B: Epoch<Slot = E::Slot>,
+		F: FnMut(&Hash, &Number, E) -> B,
+	{
+		match self {
+			PersistedEpoch::Genesis(epoch_0, epoch_1) =>
+				PersistedEpoch::Genesis(f(h, n, epoch_0), f(h, n, epoch_1)),
+			PersistedEpoch::Regular(epoch_n) => PersistedEpoch::Regular(f(h, n, epoch_n)),
+		}
+	}
+}
+
+/// Persisted epoch header stored in ForkTree.
+#[derive(Encode, Decode, PartialEq, Eq, Debug)]
+pub enum PersistedEpochHeader<E: Epoch> {
+	/// Genesis persisted epoch header. epoch_0, epoch_1.
+	Genesis(EpochHeader<E>, EpochHeader<E>),
+	/// Regular persisted epoch header. epoch_n.
+	Regular(EpochHeader<E>),
+}
+
+impl<E: Epoch> Clone for PersistedEpochHeader<E> {
+	fn clone(&self) -> Self {
+		match self {
+			Self::Genesis(epoch_0, epoch_1) => Self::Genesis(epoch_0.clone(), epoch_1.clone()),
+			Self::Regular(epoch_n) => Self::Regular(epoch_n.clone()),
+		}
+	}
+}
+
+impl<E: Epoch> PersistedEpochHeader<E> {
+	/// Map the epoch header to a different type.
+	pub fn map<B>(self) -> PersistedEpochHeader<B>
+	where
+		B: Epoch<Slot = E::Slot>,
+	{
+		match self {
+			PersistedEpochHeader::Genesis(epoch_0, epoch_1) => PersistedEpochHeader::Genesis(
+				EpochHeader { start_slot: epoch_0.start_slot, end_slot: epoch_0.end_slot },
+				EpochHeader { start_slot: epoch_1.start_slot, end_slot: epoch_1.end_slot },
+			),
+			PersistedEpochHeader::Regular(epoch_n) => PersistedEpochHeader::Regular(EpochHeader {
+				start_slot: epoch_n.start_slot,
+				end_slot: epoch_n.end_slot,
+			}),
+		}
+	}
+}
+
+/// A fresh, incremented epoch to import into the underlying fork-tree.
+///
+/// Create this with `ViableEpoch::increment`.
+#[must_use = "Freshly-incremented epoch must be imported with `EpochChanges::import`"]
+pub struct IncrementedEpoch<E: Epoch>(PersistedEpoch<E>);
+
+impl<E: Epoch> AsRef<E> for IncrementedEpoch<E> {
+	fn as_ref(&self) -> &E {
+		match self.0 {
+			PersistedEpoch::Genesis(_, ref epoch_1) => epoch_1,
+			PersistedEpoch::Regular(ref epoch_n) => epoch_n,
+		}
+	}
+}
+
+/// Tree of all epoch changes across all *seen* forks. Data stored in tree is
+/// the hash and block number of the block signaling the epoch change, and the
+/// epoch that was signalled at that block.
+///
+/// The first epoch, epoch_0, is special cased by saying that it starts at
+/// slot number of the first block in the chain. When bootstrapping a chain,
+/// there can be multiple competing block #1s, so we have to ensure that the overlayed
+/// DAG doesn't get confused.
+///
+/// The first block of every epoch should be producing a descriptor for the next
+/// epoch - this is checked in higher-level code. So the first block of epoch_0 contains
+/// a descriptor for epoch_1. We special-case these and bundle them together in the
+/// same DAG entry, pinned to a specific block #1.
+///
+/// Further epochs (epoch_2, ..., epoch_n) each get their own entry.
+#[derive(Clone, Encode, Decode, Debug)]
+pub struct EpochChanges<Hash, Number, E: Epoch> {
+	inner: ForkTree<Hash, Number, PersistedEpochHeader<E>>,
+	epochs: BTreeMap<(Hash, Number), PersistedEpoch<E>>,
+}
+
+// create a fake header hash which hasn't been included in the chain.
+fn fake_head_hash<H: AsRef<[u8]> + AsMut<[u8]> + Clone>(parent_hash: &H) -> H {
+	let mut h = parent_hash.clone();
+	// dirty trick: flip the first bit of the parent hash to create a hash
+	// which has not been in the chain before (assuming a strong hash function).
+	h.as_mut()[0] ^= 0b10000000;
+	h
+}
+
+impl<Hash, Number, E: Epoch> Default for EpochChanges<Hash, Number, E>
+where
+	Hash: PartialEq + Ord,
+	Number: Ord,
+{
+	fn default() -> Self {
+		EpochChanges { inner: ForkTree::new(), epochs: BTreeMap::new() }
+	}
+}
+
+impl<Hash, Number, E: Epoch> EpochChanges<Hash, Number, E>
+where
+	Hash: PartialEq + Ord + AsRef<[u8]> + AsMut<[u8]> + Copy + std::fmt::Debug,
+	Number: Ord + One + Zero + Add<Output = Number> + Sub<Output = Number> + Copy + std::fmt::Debug,
+{
+	/// Create a new epoch change.
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	/// Rebalances the tree of epoch changes so that it is sorted by length of
+	/// fork (longest fork first).
+	pub fn rebalance(&mut self) {
+		self.inner.rebalance()
+	}
+
+	/// Map the epoch changes from one storing data to a different one.
+	pub fn map<B, F>(self, mut f: F) -> EpochChanges<Hash, Number, B>
+	where
+		B: Epoch<Slot = E::Slot>,
+		F: FnMut(&Hash, &Number, E) -> B,
+	{
+		EpochChanges {
+			inner: self.inner.map(&mut |_, _, header: PersistedEpochHeader<E>| header.map()),
+			epochs: self
+				.epochs
+				.into_iter()
+				.map(|((hash, number), epoch)| ((hash, number), epoch.map(&hash, &number, &mut f)))
+				.collect(),
+		}
+	}
+
+	/// Prune out finalized epochs, except for the ancestor of the finalized
+	/// block. The given slot should be the slot number at which the finalized
+	/// block was authored.
+	pub fn prune_finalized<D: IsDescendentOfBuilder<Hash>>(
+		&mut self,
+		descendent_of_builder: D,
+		hash: &Hash,
+		number: Number,
+		slot: E::Slot,
+	) -> Result<(), fork_tree::Error<D::Error>> {
+		let is_descendent_of = descendent_of_builder.build_is_descendent_of(None);
+
+		let predicate = |epoch: &PersistedEpochHeader<E>| match *epoch {
+			PersistedEpochHeader::Genesis(_, ref epoch_1) => epoch_1.start_slot <= slot,
+			PersistedEpochHeader::Regular(ref epoch_n) => epoch_n.start_slot <= slot,
+		};
+
+		// Prune any epochs which could not be _live_ as of the children of the
+		// finalized block, i.e. re-root the fork tree to the oldest ancestor of
+		// (hash, number) where `epoch.start_slot() <= finalized_slot`.
+		let removed = self.inner.prune(hash, &number, &is_descendent_of, &predicate)?;
+
+		for (hash, number, _) in removed {
+			self.epochs.remove(&(hash, number));
+		}
+
+		Ok(())
+	}
+
+	/// Get a reference to an epoch with given identifier.
+	pub fn epoch(&self, id: &EpochIdentifier<Hash, Number>) -> Option<&E> {
+		self.epochs.get(&(id.hash, id.number)).and_then(|v| match v {
+			PersistedEpoch::Genesis(ref epoch_0, _)
+				if id.position == EpochIdentifierPosition::Genesis0 =>
+				Some(epoch_0),
+			PersistedEpoch::Genesis(_, ref epoch_1)
+				if id.position == EpochIdentifierPosition::Genesis1 =>
+				Some(epoch_1),
+			PersistedEpoch::Regular(ref epoch_n)
+				if id.position == EpochIdentifierPosition::Regular =>
+				Some(epoch_n),
+			_ => None,
+		})
+	}
+
+	/// Get a reference to a viable epoch with given descriptor.
+	pub fn viable_epoch<G>(
+		&self,
+		descriptor: &ViableEpochDescriptor<Hash, Number, E>,
+		make_genesis: G,
+	) -> Option<ViableEpoch<E, &E>>
+	where
+		G: FnOnce(E::Slot) -> E,
+	{
+		match descriptor {
+			ViableEpochDescriptor::UnimportedGenesis(slot) =>
+				Some(ViableEpoch::UnimportedGenesis(make_genesis(*slot))),
+			ViableEpochDescriptor::Signaled(identifier, _) =>
+				self.epoch(identifier).map(ViableEpoch::Signaled),
+		}
+	}
+
+	/// Get a mutable reference to an epoch with given identifier.
+	pub fn epoch_mut(&mut self, id: &EpochIdentifier<Hash, Number>) -> Option<&mut E> {
+		self.epochs.get_mut(&(id.hash, id.number)).and_then(|v| match v {
+			PersistedEpoch::Genesis(ref mut epoch_0, _)
+				if id.position == EpochIdentifierPosition::Genesis0 =>
+				Some(epoch_0),
+			PersistedEpoch::Genesis(_, ref mut epoch_1)
+				if id.position == EpochIdentifierPosition::Genesis1 =>
+				Some(epoch_1),
+			PersistedEpoch::Regular(ref mut epoch_n)
+				if id.position == EpochIdentifierPosition::Regular =>
+				Some(epoch_n),
+			_ => None,
+		})
+	}
+
+	/// Get a mutable reference to a viable epoch with given descriptor.
+	pub fn viable_epoch_mut<G>(
+		&mut self,
+		descriptor: &ViableEpochDescriptor<Hash, Number, E>,
+		make_genesis: G,
+	) -> Option<ViableEpoch<E, &mut E>>
+	where
+		G: FnOnce(E::Slot) -> E,
+	{
+		match descriptor {
+			ViableEpochDescriptor::UnimportedGenesis(slot) =>
+				Some(ViableEpoch::UnimportedGenesis(make_genesis(*slot))),
+			ViableEpochDescriptor::Signaled(identifier, _) =>
+				self.epoch_mut(identifier).map(ViableEpoch::Signaled),
+		}
+	}
+
+	/// Get the epoch data from an epoch descriptor.
+	///
+	/// Note that this function ignores the fact that an genesis epoch might need to be imported.
+	/// Mostly useful for testing.
+	pub fn epoch_data<G>(
+		&self,
+		descriptor: &ViableEpochDescriptor<Hash, Number, E>,
+		make_genesis: G,
+	) -> Option<E>
+	where
+		G: FnOnce(E::Slot) -> E,
+		E: Clone,
+	{
+		match descriptor {
+			ViableEpochDescriptor::UnimportedGenesis(slot) => Some(make_genesis(*slot)),
+			ViableEpochDescriptor::Signaled(identifier, _) => self.epoch(identifier).cloned(),
+		}
+	}
+
+	/// Finds the epoch data for a child of the given block. Similar to
+	/// `epoch_descriptor_for_child_of` but returns the full data.
+	///
+	/// Note that this function ignores the fact that an genesis epoch might need to be imported.
+	/// Mostly useful for testing.
+	pub fn epoch_data_for_child_of<D: IsDescendentOfBuilder<Hash>, G>(
+		&self,
+		descendent_of_builder: D,
+		parent_hash: &Hash,
+		parent_number: Number,
+		slot: E::Slot,
+		make_genesis: G,
+	) -> Result<Option<E>, fork_tree::Error<D::Error>>
+	where
+		G: FnOnce(E::Slot) -> E,
+		E: Clone,
+	{
+		let descriptor = self.epoch_descriptor_for_child_of(
+			descendent_of_builder,
+			parent_hash,
+			parent_number,
+			slot,
+		)?;
+
+		Ok(descriptor.and_then(|des| self.epoch_data(&des, make_genesis)))
+	}
+
+	/// Finds the epoch for a child of the given block, assuming the given slot number.
+	///
+	/// If the returned epoch is an `UnimportedGenesis` epoch, it should be imported into the
+	/// tree.
+	pub fn epoch_descriptor_for_child_of<D: IsDescendentOfBuilder<Hash>>(
+		&self,
+		descendent_of_builder: D,
+		parent_hash: &Hash,
+		parent_number: Number,
+		slot: E::Slot,
+	) -> Result<Option<ViableEpochDescriptor<Hash, Number, E>>, fork_tree::Error<D::Error>> {
+		if parent_number == Zero::zero() {
+			// need to insert the genesis epoch.
+			return Ok(Some(ViableEpochDescriptor::UnimportedGenesis(slot)))
+		}
+
+		// find_node_where will give you the node in the fork-tree which is an ancestor
+		// of the `parent_hash` by default. if the last epoch was signalled at the parent_hash,
+		// then it won't be returned. we need to create a new fake chain head hash which
+		// "descends" from our parent-hash.
+		let fake_head_hash = fake_head_hash(parent_hash);
+
+		let is_descendent_of =
+			descendent_of_builder.build_is_descendent_of(Some((fake_head_hash, *parent_hash)));
+
+		// We want to find the deepest node in the tree which is an ancestor
+		// of our block and where the start slot of the epoch was before the
+		// slot of our block. The genesis special-case doesn't need to look
+		// at epoch_1 -- all we're doing here is figuring out which node
+		// we need.
+		let predicate = |epoch: &PersistedEpochHeader<E>| match *epoch {
+			PersistedEpochHeader::Genesis(ref epoch_0, _) => epoch_0.start_slot <= slot,
+			PersistedEpochHeader::Regular(ref epoch_n) => epoch_n.start_slot <= slot,
+		};
+
+		self.inner
+			.find_node_where(
+				&fake_head_hash,
+				&(parent_number + One::one()),
+				&is_descendent_of,
+				&predicate,
+			)
+			.map(|n| {
+				n.map(|node| {
+					(
+						match node.data {
+							// Ok, we found our node.
+							// and here we figure out which of the internal epochs
+							// of a genesis node to use based on their start slot.
+							PersistedEpochHeader::Genesis(ref epoch_0, ref epoch_1) => {
+								if epoch_1.start_slot <= slot {
+									(EpochIdentifierPosition::Genesis1, epoch_1.clone())
+								} else {
+									(EpochIdentifierPosition::Genesis0, epoch_0.clone())
+								}
+							},
+							PersistedEpochHeader::Regular(ref epoch_n) =>
+								(EpochIdentifierPosition::Regular, epoch_n.clone()),
+						},
+						node,
+					)
+				})
+				.map(|((position, header), node)| {
+					ViableEpochDescriptor::Signaled(
+						EpochIdentifier { position, hash: node.hash, number: node.number },
+						header,
+					)
+				})
+			})
+	}
+
+	/// Import a new epoch-change, signalled at the given block.
+	///
+	/// This assumes that the given block is prospective (i.e. has not been
+	/// imported yet), but its parent has. This is why the parent hash needs
+	/// to be provided.
+	pub fn import<D: IsDescendentOfBuilder<Hash>>(
+		&mut self,
+		descendent_of_builder: D,
+		hash: Hash,
+		number: Number,
+		parent_hash: Hash,
+		epoch: IncrementedEpoch<E>,
+	) -> Result<(), fork_tree::Error<D::Error>> {
+		let is_descendent_of =
+			descendent_of_builder.build_is_descendent_of(Some((hash, parent_hash)));
+		let IncrementedEpoch(epoch) = epoch;
+		let header = PersistedEpochHeader::<E>::from(&epoch);
+
+		let res = self.inner.import(hash, number, header, &is_descendent_of);
+
+		match res {
+			Ok(_) | Err(fork_tree::Error::Duplicate) => {
+				self.epochs.insert((hash, number), epoch);
+				Ok(())
+			},
+			Err(e) => Err(e),
+		}
+	}
+
+	/// Reset to a specified pair of epochs, as if they were announced at blocks `parent_hash` and
+	/// `hash`.
+	pub fn reset(&mut self, parent_hash: Hash, hash: Hash, number: Number, current: E, next: E) {
+		self.inner = ForkTree::new();
+		self.epochs.clear();
+		let persisted = PersistedEpoch::Regular(current);
+		let header = PersistedEpochHeader::from(&persisted);
+		let _res = self.inner.import(parent_hash, number - One::one(), header, &|_, _| {
+			Ok(false) as Result<bool, fork_tree::Error<ClientError>>
+		});
+		self.epochs.insert((parent_hash, number - One::one()), persisted);
+
+		let persisted = PersistedEpoch::Regular(next);
+		let header = PersistedEpochHeader::from(&persisted);
+		let _res = self.inner.import(hash, number, header, &|_, _| {
+			Ok(true) as Result<bool, fork_tree::Error<ClientError>>
+		});
+		self.epochs.insert((hash, number), persisted);
+	}
+
+	/// Revert to a specified block given its `hash` and `number`.
+	/// This removes all the epoch changes information that were announced by
+	/// all the given block descendents.
+	pub fn revert<D: IsDescendentOfBuilder<Hash>>(
+		&mut self,
+		descendent_of_builder: D,
+		hash: Hash,
+		number: Number,
+	) {
+		let is_descendent_of = descendent_of_builder.build_is_descendent_of(None);
+
+		let filter = |node_hash: &Hash, node_num: &Number, _: &PersistedEpochHeader<E>| {
+			if number >= *node_num &&
+				(is_descendent_of(node_hash, &hash).unwrap_or_default() || *node_hash == hash)
+			{
+				// Continue the search in this subtree.
+				FilterAction::KeepNode
+			} else if number < *node_num && is_descendent_of(&hash, node_hash).unwrap_or_default() {
+				// Found a node to be removed.
+				FilterAction::Remove
+			} else {
+				// Not a parent or child of the one we're looking for, stop processing this branch.
+				FilterAction::KeepTree
+			}
+		};
+
+		self.inner.drain_filter(filter).for_each(|(h, n, _)| {
+			self.epochs.remove(&(h, n));
+		});
+	}
+
+	/// Return the inner fork tree (mostly useful for testing)
+	pub fn tree(&self) -> &ForkTree<Hash, Number, PersistedEpochHeader<E>> {
+		&self.inner
+	}
+}
+
+/// Type alias to produce the epoch-changes tree from a block type.
+pub type EpochChangesFor<Block, Epoch> =
+	EpochChanges<<Block as BlockT>::Hash, NumberFor<Block>, Epoch>;
+
+/// A shared epoch changes tree.
+pub type SharedEpochChanges<Block, Epoch> =
+	sc_consensus::shared_data::SharedData<EpochChangesFor<Block, Epoch>>;
+
+#[cfg(test)]
+mod tests {
+	use super::{Epoch as EpochT, *};
+
+	#[derive(Debug, PartialEq)]
+	pub struct TestError;
+
+	impl std::fmt::Display for TestError {
+		fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+			write!(f, "TestError")
+		}
+	}
+
+	impl std::error::Error for TestError {}
+
+	impl<'a, F: 'a, H: 'a + PartialEq + std::fmt::Debug> IsDescendentOfBuilder<H> for &'a F
+	where
+		F: Fn(&H, &H) -> Result<bool, TestError>,
+	{
+		type Error = TestError;
+		type IsDescendentOf = Box<dyn Fn(&H, &H) -> Result<bool, TestError> + 'a>;
+
+		fn build_is_descendent_of(&self, current: Option<(H, H)>) -> Self::IsDescendentOf {
+			let f = *self;
+			Box::new(move |base, head| {
+				let mut head = head;
+
+				if let Some((ref c_head, ref c_parent)) = current {
+					if head == c_head {
+						if base == c_parent {
+							return Ok(true)
+						} else {
+							head = c_parent;
+						}
+					}
+				}
+
+				f(base, head)
+			})
+		}
+	}
+
+	type Hash = [u8; 1];
+	type Slot = u64;
+
+	#[derive(Debug, Clone, Eq, PartialEq)]
+	struct Epoch {
+		start_slot: Slot,
+		duration: Slot,
+	}
+
+	impl EpochT for Epoch {
+		type NextEpochDescriptor = ();
+		type Slot = Slot;
+
+		fn increment(&self, _: ()) -> Self {
+			Epoch { start_slot: self.start_slot + self.duration, duration: self.duration }
+		}
+
+		fn end_slot(&self) -> Slot {
+			self.start_slot + self.duration
+		}
+
+		fn start_slot(&self) -> Slot {
+			self.start_slot
+		}
+	}
+
+	#[test]
+	fn genesis_epoch_is_created_but_not_imported() {
+		//
+		// A - B
+		//  \
+		//   — C
+		//
+		let is_descendent_of = |base: &Hash, block: &Hash| -> Result<bool, TestError> {
+			match (base, *block) {
+				(b"A", b) => Ok(b == *b"B" || b == *b"C" || b == *b"D"),
+				(b"B", b) | (b"C", b) => Ok(b == *b"D"),
+				(b"0", _) => Ok(true),
+				_ => Ok(false),
+			}
+		};
+
+		let epoch_changes = EpochChanges::<_, _, Epoch>::new();
+		let genesis_epoch = epoch_changes
+			.epoch_descriptor_for_child_of(&is_descendent_of, b"0", 0, 10101)
+			.unwrap()
+			.unwrap();
+
+		match genesis_epoch {
+			ViableEpochDescriptor::UnimportedGenesis(slot) => {
+				assert_eq!(slot, 10101u64);
+			},
+			_ => panic!("should be unimported genesis"),
+		};
+
+		let genesis_epoch_2 = epoch_changes
+			.epoch_descriptor_for_child_of(&is_descendent_of, b"0", 0, 10102)
+			.unwrap()
+			.unwrap();
+
+		match genesis_epoch_2 {
+			ViableEpochDescriptor::UnimportedGenesis(slot) => {
+				assert_eq!(slot, 10102u64);
+			},
+			_ => panic!("should be unimported genesis"),
+		};
+	}
+
+	#[test]
+	fn epoch_changes_between_blocks() {
+		//
+		// A - B
+		//  \
+		//   — C
+		//
+		let is_descendent_of = |base: &Hash, block: &Hash| -> Result<bool, TestError> {
+			match (base, *block) {
+				(b"A", b) => Ok(b == *b"B" || b == *b"C" || b == *b"D"),
+				(b"B", b) | (b"C", b) => Ok(b == *b"D"),
+				(b"0", _) => Ok(true),
+				_ => Ok(false),
+			}
+		};
+
+		let make_genesis = |slot| Epoch { start_slot: slot, duration: 100 };
+
+		let mut epoch_changes = EpochChanges::<_, _, Epoch>::new();
+		let genesis_epoch = epoch_changes
+			.epoch_descriptor_for_child_of(&is_descendent_of, b"0", 0, 100)
+			.unwrap()
+			.unwrap();
+
+		assert_eq!(genesis_epoch, ViableEpochDescriptor::UnimportedGenesis(100));
+
+		let import_epoch_1 =
+			epoch_changes.viable_epoch(&genesis_epoch, &make_genesis).unwrap().increment(());
+		let epoch_1 = import_epoch_1.as_ref().clone();
+
+		epoch_changes
+			.import(&is_descendent_of, *b"A", 1, *b"0", import_epoch_1)
+			.unwrap();
+		let genesis_epoch = epoch_changes.epoch_data(&genesis_epoch, &make_genesis).unwrap();
+
+		assert!(is_descendent_of(b"0", b"A").unwrap());
+
+		let end_slot = genesis_epoch.end_slot();
+		assert_eq!(end_slot, epoch_1.start_slot);
+
+		{
+			// x is still within the genesis epoch.
+			let x = epoch_changes
+				.epoch_data_for_child_of(&is_descendent_of, b"A", 1, end_slot - 1, &make_genesis)
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(x, genesis_epoch);
+		}
+
+		{
+			// x is now at the next epoch, because the block is now at the
+			// start slot of epoch 1.
+			let x = epoch_changes
+				.epoch_data_for_child_of(&is_descendent_of, b"A", 1, end_slot, &make_genesis)
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(x, epoch_1);
+		}
+
+		{
+			// x is now at the next epoch, because the block is now after
+			// start slot of epoch 1.
+			let x = epoch_changes
+				.epoch_data_for_child_of(
+					&is_descendent_of,
+					b"A",
+					1,
+					epoch_1.end_slot() - 1,
+					&make_genesis,
+				)
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(x, epoch_1);
+		}
+	}
+
+	#[test]
+	fn two_block_ones_dont_conflict() {
+		//     X - Y
+		//   /
+		// 0 - A - B
+		//
+		let is_descendent_of = |base: &Hash, block: &Hash| -> Result<bool, TestError> {
+			match (base, *block) {
+				(b"A", b) => Ok(b == *b"B"),
+				(b"X", b) => Ok(b == *b"Y"),
+				(b"0", _) => Ok(true),
+				_ => Ok(false),
+			}
+		};
+
+		let duration = 100;
+
+		let make_genesis = |slot| Epoch { start_slot: slot, duration };
+
+		let mut epoch_changes = EpochChanges::new();
+		let next_descriptor = ();
+
+		// insert genesis epoch for A
+		{
+			let genesis_epoch_a_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(&is_descendent_of, b"0", 0, 100)
+				.unwrap()
+				.unwrap();
+
+			let incremented_epoch = epoch_changes
+				.viable_epoch(&genesis_epoch_a_descriptor, &make_genesis)
+				.unwrap()
+				.increment(next_descriptor);
+
+			epoch_changes
+				.import(&is_descendent_of, *b"A", 1, *b"0", incremented_epoch)
+				.unwrap();
+		}
+
+		// insert genesis epoch for X
+		{
+			let genesis_epoch_x_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(&is_descendent_of, b"0", 0, 1000)
+				.unwrap()
+				.unwrap();
+
+			let incremented_epoch = epoch_changes
+				.viable_epoch(&genesis_epoch_x_descriptor, &make_genesis)
+				.unwrap()
+				.increment(next_descriptor);
+
+			epoch_changes
+				.import(&is_descendent_of, *b"X", 1, *b"0", incremented_epoch)
+				.unwrap();
+		}
+
+		// now check that the genesis epochs for our respective block 1s
+		// respect the chain structure.
+		{
+			let epoch_for_a_child = epoch_changes
+				.epoch_data_for_child_of(&is_descendent_of, b"A", 1, 101, &make_genesis)
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(epoch_for_a_child, make_genesis(100));
+
+			let epoch_for_x_child = epoch_changes
+				.epoch_data_for_child_of(&is_descendent_of, b"X", 1, 1001, &make_genesis)
+				.unwrap()
+				.unwrap();
+
+			assert_eq!(epoch_for_x_child, make_genesis(1000));
+
+			let epoch_for_x_child_before_genesis = epoch_changes
+				.epoch_data_for_child_of(&is_descendent_of, b"X", 1, 101, &make_genesis)
+				.unwrap();
+
+			// even though there is a genesis epoch at that slot, it's not in
+			// this chain.
+			assert!(epoch_for_x_child_before_genesis.is_none());
+		}
+	}
+
+	#[test]
+	fn prune_removes_stale_nodes() {
+		//     +---D       +-------F
+		//     |           |
+		// 0---A---B--(x)--C--(y)--G
+		// |       |
+		// +---H   +-------E
+		//
+		//  Test parameters:
+		//  - epoch duration: 100
+		//
+		//  We are going to prune the tree at:
+		//  - 'x', a node between B and C
+		//  - 'y', a node between C and G
+
+		let is_descendent_of = |base: &Hash, block: &Hash| -> Result<bool, TestError> {
+			match (base, block) {
+				(b"0", _) => Ok(true),
+				(b"A", b) => Ok(b != b"0"),
+				(b"B", b) => Ok(b != b"0" && b != b"A" && b != b"D"),
+				(b"C", b) => Ok(b == b"F" || b == b"G" || b == b"y"),
+				(b"x", b) => Ok(b == b"C" || b == b"F" || b == b"G" || b == b"y"),
+				(b"y", b) => Ok(b == b"G"),
+				_ => Ok(false),
+			}
+		};
+
+		let mut epoch_changes = EpochChanges::new();
+
+		let mut import_at = |slot, hash: &Hash, number, parent_hash, parent_number| {
+			let make_genesis = |slot| Epoch { start_slot: slot, duration: 100 };
+			// Get epoch descriptor valid for 'slot'
+			let epoch_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(&is_descendent_of, parent_hash, parent_number, slot)
+				.unwrap()
+				.unwrap();
+			// Increment it
+			let next_epoch_desc = epoch_changes
+				.viable_epoch(&epoch_descriptor, &make_genesis)
+				.unwrap()
+				.increment(());
+			// Assign it to hash/number
+			epoch_changes
+				.import(&is_descendent_of, *hash, number, *parent_hash, next_epoch_desc)
+				.unwrap();
+		};
+
+		import_at(100, b"A", 10, b"0", 0);
+		import_at(200, b"B", 20, b"A", 10);
+		import_at(300, b"C", 30, b"B", 20);
+		import_at(200, b"D", 20, b"A", 10);
+		import_at(300, b"E", 30, b"B", 20);
+		import_at(400, b"F", 40, b"C", 30);
+		import_at(400, b"G", 40, b"C", 30);
+		import_at(100, b"H", 10, b"0", 0);
+
+		let mut nodes: Vec<_> = epoch_changes.tree().iter().map(|(h, _, _)| h).collect();
+		nodes.sort();
+		assert_eq!(nodes, vec![b"A", b"B", b"C", b"D", b"E", b"F", b"G", b"H"]);
+
+		// Finalize block 'x' @ number 25, slot 230
+		// This should prune all nodes imported by blocks with a number < 25 that are not
+		// ancestors of 'x' and all nodes before the one holding the epoch information
+		// to which 'x' belongs to (i.e. before A).
+
+		epoch_changes.prune_finalized(&is_descendent_of, b"x", 25, 230).unwrap();
+
+		let mut nodes: Vec<_> = epoch_changes.tree().iter().map(|(h, _, _)| h).collect();
+		nodes.sort();
+		assert_eq!(nodes, vec![b"A", b"B", b"C", b"F", b"G"]);
+
+		// Finalize block y @ number 35, slot 330
+		// This should prune all nodes imported by blocks with a number < 35 that are not
+		// ancestors of 'y' and all nodes before the one holding the epoch information
+		// to which 'y' belongs to (i.e. before B).
+
+		epoch_changes.prune_finalized(&is_descendent_of, b"y", 35, 330).unwrap();
+
+		let mut nodes: Vec<_> = epoch_changes.tree().iter().map(|(h, _, _)| h).collect();
+		nodes.sort();
+		assert_eq!(nodes, vec![b"B", b"C", b"G"]);
+	}
+
+	#[test]
+	fn near_genesis_prune_works() {
+		// [X]: announces next epoch change (i.e. adds a node in the epoch changes tree)
+		//
+		// 0--[A]--B--C--D--E--[G]--H--I--J--K--[L]
+		//                  +
+		//                  \--[F]
+
+		let is_descendent_of = |base: &Hash, block: &Hash| -> Result<bool, TestError> {
+			match (block, base) {
+				| (b"A", b"0") |
+				(b"B", b"0" | b"A") |
+				(b"C", b"0" | b"A" | b"B") |
+				(b"D", b"0" | b"A" | b"B" | b"C") |
+				(b"E", b"0" | b"A" | b"B" | b"C" | b"D") |
+				(b"F", b"0" | b"A" | b"B" | b"C" | b"D" | b"E") |
+				(b"G", b"0" | b"A" | b"B" | b"C" | b"D" | b"E") |
+				(b"H", b"0" | b"A" | b"B" | b"C" | b"D" | b"E" | b"G") |
+				(b"I", b"0" | b"A" | b"B" | b"C" | b"D" | b"E" | b"G" | b"H") |
+				(b"J", b"0" | b"A" | b"B" | b"C" | b"D" | b"E" | b"G" | b"H" | b"I") |
+				(b"K", b"0" | b"A" | b"B" | b"C" | b"D" | b"E" | b"G" | b"H" | b"I" | b"J") |
+				(
+					b"L",
+					b"0" | b"A" | b"B" | b"C" | b"D" | b"E" | b"G" | b"H" | b"I" | b"J" | b"K",
+				) => Ok(true),
+				_ => Ok(false),
+			}
+		};
+
+		let mut epoch_changes = EpochChanges::new();
+
+		let epoch = Epoch { start_slot: 278183811, duration: 5 };
+		let epoch = PersistedEpoch::Genesis(epoch.clone(), epoch.increment(()));
+
+		epoch_changes
+			.import(&is_descendent_of, *b"A", 1, Default::default(), IncrementedEpoch(epoch))
+			.unwrap();
+
+		let import_at = |epoch_changes: &mut EpochChanges<_, _, Epoch>,
+		                 slot,
+		                 hash: &Hash,
+		                 number,
+		                 parent_hash,
+		                 parent_number| {
+			let make_genesis = |slot| Epoch { start_slot: slot, duration: 5 };
+			// Get epoch descriptor valid for 'slot'
+			let epoch_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(&is_descendent_of, parent_hash, parent_number, slot)
+				.unwrap()
+				.unwrap();
+			// Increment it
+			let next_epoch_desc = epoch_changes
+				.viable_epoch(&epoch_descriptor, &make_genesis)
+				.unwrap()
+				.increment(());
+			// Assign it to hash/number
+			epoch_changes
+				.import(&is_descendent_of, *hash, number, *parent_hash, next_epoch_desc)
+				.unwrap();
+		};
+
+		// Should not prune anything
+		epoch_changes.prune_finalized(&is_descendent_of, b"C", 3, 278183813).unwrap();
+
+		import_at(&mut epoch_changes, 278183816, b"G", 6, b"E", 5);
+		import_at(&mut epoch_changes, 278183816, b"F", 6, b"E", 5);
+
+		// Should not prune anything since we are on epoch0
+		epoch_changes.prune_finalized(&is_descendent_of, b"C", 3, 278183813).unwrap();
+		let mut list: Vec<_> = epoch_changes.inner.iter().map(|e| e.0).collect();
+		list.sort();
+		assert_eq!(list, vec![b"A", b"F", b"G"]);
+
+		import_at(&mut epoch_changes, 278183821, b"L", 11, b"K", 10);
+
+		// Should prune any fork of our ancestor not in the canonical chain (i.e. "F")
+		epoch_changes.prune_finalized(&is_descendent_of, b"J", 9, 278183819).unwrap();
+		let mut list: Vec<_> = epoch_changes.inner.iter().map(|e| e.0).collect();
+		list.sort();
+		assert_eq!(list, vec![b"A", b"G", b"L"]);
+	}
+}
diff --git a/substrate/client/consensus/epochs/src/migration.rs b/substrate/client/consensus/epochs/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8838dbb4605b73da73f6c019de946430c21c07d4
--- /dev/null
+++ b/substrate/client/consensus/epochs/src/migration.rs
@@ -0,0 +1,80 @@
+// 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/>.
+
+//! Migration types for epoch changes.
+
+use crate::{Epoch, EpochChanges, PersistedEpoch, PersistedEpochHeader};
+use codec::{Decode, Encode};
+use fork_tree::ForkTree;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::collections::BTreeMap;
+
+/// Legacy definition of epoch changes.
+#[derive(Clone, Encode, Decode)]
+pub struct EpochChangesV0<Hash, Number, E: Epoch> {
+	inner: ForkTree<Hash, Number, PersistedEpoch<E>>,
+}
+
+/// Legacy definition of epoch changes.
+#[derive(Clone, Encode, Decode)]
+pub struct EpochChangesV1<Hash, Number, E: Epoch> {
+	inner: ForkTree<Hash, Number, PersistedEpochHeader<E>>,
+	epochs: BTreeMap<(Hash, Number), PersistedEpoch<E>>,
+}
+
+/// Type alias for v0 definition of epoch changes.
+pub type EpochChangesV0For<Block, Epoch> =
+	EpochChangesV0<<Block as BlockT>::Hash, NumberFor<Block>, Epoch>;
+/// Type alias for v1 and v2 definition of epoch changes.
+pub type EpochChangesV1For<Block, Epoch> =
+	EpochChangesV1<<Block as BlockT>::Hash, NumberFor<Block>, Epoch>;
+
+impl<Hash, Number, E: Epoch> EpochChangesV0<Hash, Number, E>
+where
+	Hash: PartialEq + Ord + Copy,
+	Number: Ord + Copy,
+{
+	/// Create a new value of this type from raw.
+	pub fn from_raw(inner: ForkTree<Hash, Number, PersistedEpoch<E>>) -> Self {
+		Self { inner }
+	}
+
+	/// Migrate the type into current epoch changes definition.
+	pub fn migrate(self) -> EpochChanges<Hash, Number, E> {
+		let mut epochs = BTreeMap::new();
+
+		let inner = self.inner.map(&mut |hash, number, data| {
+			let header = PersistedEpochHeader::from(&data);
+			epochs.insert((*hash, *number), data);
+			header
+		});
+
+		EpochChanges { inner, epochs }
+	}
+}
+
+impl<Hash, Number, E: Epoch> EpochChangesV1<Hash, Number, E>
+where
+	Hash: PartialEq + Ord + Copy,
+	Number: Ord + Copy,
+{
+	/// Migrate the type into current epoch changes definition.
+	pub fn migrate(self) -> EpochChanges<Hash, Number, E> {
+		EpochChanges { inner: self.inner, epochs: self.epochs }
+	}
+}
diff --git a/substrate/client/consensus/grandpa/Cargo.toml b/substrate/client/consensus/grandpa/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..af39c640122b61bf0488f61af862c5ff72f93ab2
--- /dev/null
+++ b/substrate/client/consensus/grandpa/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "sc-consensus-grandpa"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Integration of the GRANDPA finality gadget into substrate."
+documentation = "https://docs.rs/sc-consensus-grandpa"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+ahash = "0.8.2"
+array-bytes = "6.1"
+async-trait = "0.1.57"
+dyn-clone = "1.0"
+finality-grandpa = { version = "0.16.2", features = ["derive-codec"] }
+futures = "0.3.21"
+futures-timer = "3.0.1"
+log = "0.4.17"
+parity-scale-codec = { version = "3.6.1", features = ["derive"] }
+parking_lot = "0.12.1"
+rand = "0.8.5"
+serde_json = "1.0.85"
+thiserror = "1.0"
+fork-tree = { version = "3.0.0", path = "../../../utils/fork-tree" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sc-chain-spec = { version = "4.0.0-dev", path = "../../../client/chain-spec" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../transaction-pool/api" }
+sc-consensus = { version = "0.10.0-dev", path = "../common" }
+sc-network = { version = "0.10.0-dev", path = "../../network" }
+sc-network-gossip = { version = "0.10.0-dev", path = "../../network-gossip" }
+sc-network-common = { version = "0.10.0-dev", path = "../../network/common" }
+sc-telemetry = { version = "4.0.0-dev", path = "../../telemetry" }
+sc-utils = { version = "4.0.0-dev", path = "../../utils" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-application-crypto = { version = "23.0.0", path = "../../../primitives/application-crypto" }
+sp-arithmetic = { version = "16.0.0", path = "../../../primitives/arithmetic" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-consensus-grandpa = { version = "4.0.0-dev", path = "../../../primitives/consensus/grandpa" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+assert_matches = "1.3.0"
+finality-grandpa = { version = "0.16.2", features = ["derive-codec", "test-helpers"] }
+serde = "1.0.163"
+tokio = "1.22.0"
+sc-network = { version = "0.10.0-dev", path = "../../network" }
+sc-network-test = { version = "0.8.0", path = "../../network/test" }
+sp-keyring = { version = "24.0.0", path = "../../../primitives/keyring" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/client/consensus/grandpa/README.md b/substrate/client/consensus/grandpa/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..64a7e70bc6a52631016bba71343b38d3e0f9f005
--- /dev/null
+++ b/substrate/client/consensus/grandpa/README.md
@@ -0,0 +1,39 @@
+Integration of the GRANDPA finality gadget into substrate.
+
+This crate is unstable and the API and usage may change.
+
+This crate provides a long-running future that produces finality notifications.
+
+# Usage
+
+First, create a block-import wrapper with the `block_import` function. The
+GRANDPA worker needs to be linked together with this block import object, so
+a `LinkHalf` is returned as well. All blocks imported (from network or
+consensus or otherwise) must pass through this wrapper, otherwise consensus
+is likely to break in unexpected ways.
+
+Next, use the `LinkHalf` and a local configuration to `run_grandpa_voter`.
+This requires a `Network` implementation. The returned future should be
+driven to completion and will finalize blocks in the background.
+
+# Changing authority sets
+
+The rough idea behind changing authority sets in GRANDPA is that at some point,
+we obtain agreement for some maximum block height that the current set can
+finalize, and once a block with that height is finalized the next set will
+pick up finalization from there.
+
+Technically speaking, this would be implemented as a voting rule which says,
+"if there is a signal for a change in N blocks in block B, only vote on
+chains with length NUM(B) + N if they contain B". This conditional-inclusion
+logic is complex to compute because it requires looking arbitrarily far
+back in the chain.
+
+Instead, we keep track of a list of all signals we've seen so far (across
+all forks), sorted ascending by the block number they would be applied at.
+We never vote on chains with number higher than the earliest handoff block
+number (this is num(signal) + N). When finalizing a block, we either apply
+or prune any signaled changes based on whether the signaling block is
+included in the newly-finalized chain.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/grandpa/rpc/Cargo.toml b/substrate/client/consensus/grandpa/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5c3b5a171b928909974a53a5cdeebc76d0e26d83
--- /dev/null
+++ b/substrate/client/consensus/grandpa/rpc/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "sc-consensus-grandpa-rpc"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "RPC extensions for the GRANDPA finality gadget"
+repository = "https://github.com/paritytech/substrate/"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+readme = "README.md"
+homepage = "https://substrate.io"
+
+[dependencies]
+finality-grandpa = { version = "0.16.2", features = ["derive-codec"] }
+futures = "0.3.16"
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+log = "0.4.8"
+parity-scale-codec = { version = "3.6.1", features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive"] }
+thiserror = "1.0"
+sc-client-api = { version = "4.0.0-dev", path = "../../../api" }
+sc-consensus-grandpa = { version = "0.10.0-dev", path = "../" }
+sc-rpc = { version = "4.0.0-dev", path = "../../../rpc" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+
+[dev-dependencies]
+sc-block-builder = { version = "0.10.0-dev", path = "../../../block-builder" }
+sc-rpc = { version = "4.0.0-dev", features = ["test-helpers"], path = "../../../rpc" }
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-consensus-grandpa = { version = "4.0.0-dev", path = "../../../../primitives/consensus/grandpa" }
+sp-keyring = { version = "24.0.0", path = "../../../../primitives/keyring" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../../test-utils/runtime/client" }
+tokio = { version = "1.22.0", features = ["macros"] }
diff --git a/substrate/client/consensus/grandpa/rpc/README.md b/substrate/client/consensus/grandpa/rpc/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0007f55dbd4dbfa5fe0b10b0cb9e0714def30b1a
--- /dev/null
+++ b/substrate/client/consensus/grandpa/rpc/README.md
@@ -0,0 +1,3 @@
+RPC API for GRANDPA.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/grandpa/rpc/src/error.rs b/substrate/client/consensus/grandpa/rpc/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4884380cd22d0797c8ab2174ec21fdec3026f72e
--- /dev/null
+++ b/substrate/client/consensus/grandpa/rpc/src/error.rs
@@ -0,0 +1,80 @@
+// 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 jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+
+#[derive(Debug, thiserror::Error)]
+/// Top-level error type for the RPC handler
+pub enum Error {
+	/// The GRANDPA RPC endpoint is not ready.
+	#[error("GRANDPA RPC endpoint not ready")]
+	EndpointNotReady,
+	/// GRANDPA reports the authority set id to be larger than 32-bits.
+	#[error("GRANDPA reports authority set id unreasonably large")]
+	AuthoritySetIdReportedAsUnreasonablyLarge,
+	/// GRANDPA reports voter state with round id or weights larger than 32-bits.
+	#[error("GRANDPA reports voter state as unreasonably large")]
+	VoterStateReportsUnreasonablyLargeNumbers,
+	/// GRANDPA prove finality failed.
+	#[error("GRANDPA prove finality rpc failed: {0}")]
+	ProveFinalityFailed(#[from] sc_consensus_grandpa::FinalityProofError),
+}
+
+/// The error codes returned by jsonrpc.
+pub enum ErrorCode {
+	/// Returned when Grandpa RPC endpoint is not ready.
+	NotReady = 1,
+	/// Authority set ID is larger than 32-bits.
+	AuthoritySetTooLarge,
+	/// Voter state with round id or weights larger than 32-bits.
+	VoterStateTooLarge,
+	/// Failed to prove finality.
+	ProveFinality,
+}
+
+impl From<Error> for ErrorCode {
+	fn from(error: Error) -> Self {
+		match error {
+			Error::EndpointNotReady => ErrorCode::NotReady,
+			Error::AuthoritySetIdReportedAsUnreasonablyLarge => ErrorCode::AuthoritySetTooLarge,
+			Error::VoterStateReportsUnreasonablyLargeNumbers => ErrorCode::VoterStateTooLarge,
+			Error::ProveFinalityFailed(_) => ErrorCode::ProveFinality,
+		}
+	}
+}
+
+impl From<Error> for JsonRpseeError {
+	fn from(error: Error) -> Self {
+		let message = error.to_string();
+		let code = ErrorCode::from(error);
+		JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+			code as i32,
+			message,
+			None::<()>,
+		)))
+	}
+}
+
+impl From<std::num::TryFromIntError> for Error {
+	fn from(_error: std::num::TryFromIntError) -> Self {
+		Error::VoterStateReportsUnreasonablyLargeNumbers
+	}
+}
diff --git a/substrate/client/consensus/grandpa/rpc/src/finality.rs b/substrate/client/consensus/grandpa/rpc/src/finality.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f8ec01781ac6b4bedd86a71103ca1d8fa0d0901b
--- /dev/null
+++ b/substrate/client/consensus/grandpa/rpc/src/finality.rs
@@ -0,0 +1,49 @@
+// 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 serde::{Deserialize, Serialize};
+
+use sc_consensus_grandpa::FinalityProofProvider;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+#[derive(Serialize, Deserialize)]
+pub struct EncodedFinalityProof(pub sp_core::Bytes);
+
+/// Local trait mainly to allow mocking in tests.
+pub trait RpcFinalityProofProvider<Block: BlockT> {
+	/// Prove finality for the given block number by returning a Justification for the last block of
+	/// the authority set.
+	fn rpc_prove_finality(
+		&self,
+		block: NumberFor<Block>,
+	) -> Result<Option<EncodedFinalityProof>, sc_consensus_grandpa::FinalityProofError>;
+}
+
+impl<B, Block> RpcFinalityProofProvider<Block> for FinalityProofProvider<B, Block>
+where
+	Block: BlockT,
+	NumberFor<Block>: finality_grandpa::BlockNumberOps,
+	B: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+{
+	fn rpc_prove_finality(
+		&self,
+		block: NumberFor<Block>,
+	) -> Result<Option<EncodedFinalityProof>, sc_consensus_grandpa::FinalityProofError> {
+		self.prove_finality(block).map(|x| x.map(|y| EncodedFinalityProof(y.into())))
+	}
+}
diff --git a/substrate/client/consensus/grandpa/rpc/src/lib.rs b/substrate/client/consensus/grandpa/rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c6298bff969bd8db2818a255436e8993954addf0
--- /dev/null
+++ b/substrate/client/consensus/grandpa/rpc/src/lib.rs
@@ -0,0 +1,425 @@
+// 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/>.
+
+//! RPC API for GRANDPA.
+#![warn(missing_docs)]
+
+use futures::{FutureExt, StreamExt};
+use log::warn;
+use std::sync::Arc;
+
+use jsonrpsee::{
+	core::{async_trait, RpcResult},
+	proc_macros::rpc,
+	types::SubscriptionResult,
+	SubscriptionSink,
+};
+
+mod error;
+mod finality;
+mod notification;
+mod report;
+
+use sc_consensus_grandpa::GrandpaJustificationStream;
+use sc_rpc::SubscriptionTaskExecutor;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use finality::{EncodedFinalityProof, RpcFinalityProofProvider};
+use notification::JustificationNotification;
+use report::{ReportAuthoritySet, ReportVoterState, ReportedRoundStates};
+
+/// Provides RPC methods for interacting with GRANDPA.
+#[rpc(client, server)]
+pub trait GrandpaApi<Notification, Hash, Number> {
+	/// Returns the state of the current best round state as well as the
+	/// ongoing background rounds.
+	#[method(name = "grandpa_roundState")]
+	async fn round_state(&self) -> RpcResult<ReportedRoundStates>;
+
+	/// Returns the block most recently finalized by Grandpa, alongside
+	/// side its justification.
+	#[subscription(
+		name = "grandpa_subscribeJustifications" => "grandpa_justifications",
+		unsubscribe = "grandpa_unsubscribeJustifications",
+		item = Notification
+	)]
+	fn subscribe_justifications(&self);
+
+	/// Prove finality for the given block number by returning the Justification for the last block
+	/// in the set and all the intermediary headers to link them together.
+	#[method(name = "grandpa_proveFinality")]
+	async fn prove_finality(&self, block: Number) -> RpcResult<Option<EncodedFinalityProof>>;
+}
+
+/// Provides RPC methods for interacting with GRANDPA.
+pub struct Grandpa<AuthoritySet, VoterState, Block: BlockT, ProofProvider> {
+	executor: SubscriptionTaskExecutor,
+	authority_set: AuthoritySet,
+	voter_state: VoterState,
+	justification_stream: GrandpaJustificationStream<Block>,
+	finality_proof_provider: Arc<ProofProvider>,
+}
+impl<AuthoritySet, VoterState, Block: BlockT, ProofProvider>
+	Grandpa<AuthoritySet, VoterState, Block, ProofProvider>
+{
+	/// Prepare a new [`Grandpa`] Rpc handler.
+	pub fn new(
+		executor: SubscriptionTaskExecutor,
+		authority_set: AuthoritySet,
+		voter_state: VoterState,
+		justification_stream: GrandpaJustificationStream<Block>,
+		finality_proof_provider: Arc<ProofProvider>,
+	) -> Self {
+		Self { executor, authority_set, voter_state, justification_stream, finality_proof_provider }
+	}
+}
+
+#[async_trait]
+impl<AuthoritySet, VoterState, Block, ProofProvider>
+	GrandpaApiServer<JustificationNotification, Block::Hash, NumberFor<Block>>
+	for Grandpa<AuthoritySet, VoterState, Block, ProofProvider>
+where
+	VoterState: ReportVoterState + Send + Sync + 'static,
+	AuthoritySet: ReportAuthoritySet + Send + Sync + 'static,
+	Block: BlockT,
+	ProofProvider: RpcFinalityProofProvider<Block> + Send + Sync + 'static,
+{
+	async fn round_state(&self) -> RpcResult<ReportedRoundStates> {
+		ReportedRoundStates::from(&self.authority_set, &self.voter_state).map_err(Into::into)
+	}
+
+	fn subscribe_justifications(&self, mut sink: SubscriptionSink) -> SubscriptionResult {
+		let stream = self.justification_stream.subscribe(100_000).map(
+			|x: sc_consensus_grandpa::GrandpaJustification<Block>| {
+				JustificationNotification::from(x)
+			},
+		);
+
+		let fut = async move {
+			sink.pipe_from_stream(stream).await;
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+		Ok(())
+	}
+
+	async fn prove_finality(
+		&self,
+		block: NumberFor<Block>,
+	) -> RpcResult<Option<EncodedFinalityProof>> {
+		self.finality_proof_provider
+			.rpc_prove_finality(block)
+			.map_err(|e| {
+				warn!("Error proving finality: {}", e);
+				error::Error::ProveFinalityFailed(e)
+			})
+			.map_err(Into::into)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::{collections::HashSet, convert::TryInto, sync::Arc};
+
+	use jsonrpsee::{
+		types::{EmptyServerParams as EmptyParams, SubscriptionId},
+		RpcModule,
+	};
+	use parity_scale_codec::{Decode, Encode};
+	use sc_block_builder::{BlockBuilder, RecordProof};
+	use sc_consensus_grandpa::{
+		report, AuthorityId, FinalityProof, GrandpaJustification, GrandpaJustificationSender,
+	};
+	use sp_blockchain::HeaderBackend;
+	use sp_core::{crypto::ByteArray, testing::TaskExecutor};
+	use sp_keyring::Ed25519Keyring;
+	use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+	use substrate_test_runtime_client::{
+		runtime::{Block, Header, H256},
+		DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+	};
+
+	struct TestAuthoritySet;
+	struct TestVoterState;
+	struct EmptyVoterState;
+
+	struct TestFinalityProofProvider {
+		finality_proof: Option<FinalityProof<Header>>,
+	}
+
+	fn voters() -> HashSet<AuthorityId> {
+		let voter_id_1 = AuthorityId::from_slice(&[1; 32]).unwrap();
+		let voter_id_2 = AuthorityId::from_slice(&[2; 32]).unwrap();
+
+		vec![voter_id_1, voter_id_2].into_iter().collect()
+	}
+
+	impl ReportAuthoritySet for TestAuthoritySet {
+		fn get(&self) -> (u64, HashSet<AuthorityId>) {
+			(1, voters())
+		}
+	}
+
+	impl ReportVoterState for EmptyVoterState {
+		fn get(&self) -> Option<report::VoterState<AuthorityId>> {
+			None
+		}
+	}
+
+	fn header(number: u64) -> Header {
+		let parent_hash = match number {
+			0 => Default::default(),
+			_ => header(number - 1).hash(),
+		};
+		Header::new(
+			number,
+			H256::from_low_u64_be(0),
+			H256::from_low_u64_be(0),
+			parent_hash,
+			Default::default(),
+		)
+	}
+
+	impl<Block: BlockT> RpcFinalityProofProvider<Block> for TestFinalityProofProvider {
+		fn rpc_prove_finality(
+			&self,
+			_block: NumberFor<Block>,
+		) -> Result<Option<EncodedFinalityProof>, sc_consensus_grandpa::FinalityProofError> {
+			Ok(Some(EncodedFinalityProof(
+				self.finality_proof
+					.as_ref()
+					.expect("Don't call rpc_prove_finality without setting the FinalityProof")
+					.encode()
+					.into(),
+			)))
+		}
+	}
+
+	impl ReportVoterState for TestVoterState {
+		fn get(&self) -> Option<report::VoterState<AuthorityId>> {
+			let voter_id_1 = AuthorityId::from_slice(&[1; 32]).unwrap();
+			let voters_best: HashSet<_> = vec![voter_id_1].into_iter().collect();
+
+			let best_round_state = sc_consensus_grandpa::report::RoundState {
+				total_weight: 100_u64.try_into().unwrap(),
+				threshold_weight: 67_u64.try_into().unwrap(),
+				prevote_current_weight: 50.into(),
+				prevote_ids: voters_best,
+				precommit_current_weight: 0.into(),
+				precommit_ids: HashSet::new(),
+			};
+
+			let past_round_state = sc_consensus_grandpa::report::RoundState {
+				total_weight: 100_u64.try_into().unwrap(),
+				threshold_weight: 67_u64.try_into().unwrap(),
+				prevote_current_weight: 100.into(),
+				prevote_ids: voters(),
+				precommit_current_weight: 100.into(),
+				precommit_ids: voters(),
+			};
+
+			let background_rounds = vec![(1, past_round_state)].into_iter().collect();
+
+			Some(report::VoterState { background_rounds, best_round: (2, best_round_state) })
+		}
+	}
+
+	fn setup_io_handler<VoterState>(
+		voter_state: VoterState,
+	) -> (
+		RpcModule<Grandpa<TestAuthoritySet, VoterState, Block, TestFinalityProofProvider>>,
+		GrandpaJustificationSender<Block>,
+	)
+	where
+		VoterState: ReportVoterState + Send + Sync + 'static,
+	{
+		setup_io_handler_with_finality_proofs(voter_state, None)
+	}
+
+	fn setup_io_handler_with_finality_proofs<VoterState>(
+		voter_state: VoterState,
+		finality_proof: Option<FinalityProof<Header>>,
+	) -> (
+		RpcModule<Grandpa<TestAuthoritySet, VoterState, Block, TestFinalityProofProvider>>,
+		GrandpaJustificationSender<Block>,
+	)
+	where
+		VoterState: ReportVoterState + Send + Sync + 'static,
+	{
+		let (justification_sender, justification_stream) = GrandpaJustificationStream::channel();
+		let finality_proof_provider = Arc::new(TestFinalityProofProvider { finality_proof });
+		let executor = Arc::new(TaskExecutor::default());
+
+		let rpc = Grandpa::new(
+			executor,
+			TestAuthoritySet,
+			voter_state,
+			justification_stream,
+			finality_proof_provider,
+		)
+		.into_rpc();
+
+		(rpc, justification_sender)
+	}
+
+	#[tokio::test]
+	async fn uninitialized_rpc_handler() {
+		let (rpc, _) = setup_io_handler(EmptyVoterState);
+		let expected_response = r#"{"jsonrpc":"2.0","error":{"code":1,"message":"GRANDPA RPC endpoint not ready"},"id":0}"#.to_string();
+		let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":0}"#;
+		let (response, _) = rpc.raw_json_request(&request).await.unwrap();
+
+		assert_eq!(expected_response, response.result);
+	}
+
+	#[tokio::test]
+	async fn working_rpc_handler() {
+		let (rpc, _) = setup_io_handler(TestVoterState);
+		let expected_response = "{\"jsonrpc\":\"2.0\",\"result\":{\
+			\"setId\":1,\
+			\"best\":{\
+				\"round\":2,\"totalWeight\":100,\"thresholdWeight\":67,\
+				\"prevotes\":{\"currentWeight\":50,\"missing\":[\"5C7LYpP2ZH3tpKbvVvwiVe54AapxErdPBbvkYhe6y9ZBkqWt\"]},\
+				\"precommits\":{\"currentWeight\":0,\"missing\":[\"5C62Ck4UrFPiBtoCmeSrgF7x9yv9mn38446dhCpsi2mLHiFT\",\"5C7LYpP2ZH3tpKbvVvwiVe54AapxErdPBbvkYhe6y9ZBkqWt\"]}\
+			},\
+				\"background\":[{\
+				\"round\":1,\"totalWeight\":100,\"thresholdWeight\":67,\
+				\"prevotes\":{\"currentWeight\":100,\"missing\":[]},\
+				\"precommits\":{\"currentWeight\":100,\"missing\":[]}\
+			}]\
+		},\"id\":0}".to_string();
+
+		let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":0}"#;
+		let (response, _) = rpc.raw_json_request(&request).await.unwrap();
+		assert_eq!(expected_response, response.result);
+	}
+
+	#[tokio::test]
+	async fn subscribe_and_unsubscribe_with_wrong_id() {
+		let (rpc, _) = setup_io_handler(TestVoterState);
+		// Subscribe call.
+		let _sub = rpc
+			.subscribe("grandpa_subscribeJustifications", EmptyParams::new())
+			.await
+			.unwrap();
+
+		// Unsubscribe with wrong ID
+		let (response, _) = rpc
+			.raw_json_request(
+				r#"{"jsonrpc":"2.0","method":"grandpa_unsubscribeJustifications","params":["FOO"],"id":1}"#,
+			)
+			.await
+			.unwrap();
+		let expected = r#"{"jsonrpc":"2.0","result":false,"id":1}"#;
+
+		assert_eq!(response.result, expected);
+	}
+
+	fn create_justification() -> GrandpaJustification<Block> {
+		let peers = &[Ed25519Keyring::Alice];
+
+		let builder = TestClientBuilder::new();
+		let backend = builder.backend();
+		let client = builder.build();
+		let client = Arc::new(client);
+
+		let built_block = BlockBuilder::new(
+			&*client,
+			client.info().best_hash,
+			client.info().best_number,
+			RecordProof::No,
+			Default::default(),
+			&*backend,
+		)
+		.unwrap()
+		.build()
+		.unwrap();
+
+		let block = built_block.block;
+		let block_hash = block.hash();
+
+		let justification = {
+			let round = 1;
+			let set_id = 0;
+
+			let precommit = finality_grandpa::Precommit {
+				target_hash: block_hash,
+				target_number: *block.header.number(),
+			};
+
+			let msg = finality_grandpa::Message::Precommit(precommit.clone());
+			let encoded = sp_consensus_grandpa::localized_payload(round, set_id, &msg);
+			let signature = peers[0].sign(&encoded[..]).into();
+
+			let precommit = finality_grandpa::SignedPrecommit {
+				precommit,
+				signature,
+				id: peers[0].public().into(),
+			};
+
+			let commit = finality_grandpa::Commit {
+				target_hash: block_hash,
+				target_number: *block.header.number(),
+				precommits: vec![precommit],
+			};
+
+			GrandpaJustification::from_commit(&client, round, commit).unwrap()
+		};
+
+		justification
+	}
+
+	#[tokio::test]
+	async fn subscribe_and_listen_to_one_justification() {
+		let (rpc, justification_sender) = setup_io_handler(TestVoterState);
+
+		let mut sub = rpc
+			.subscribe("grandpa_subscribeJustifications", EmptyParams::new())
+			.await
+			.unwrap();
+
+		// Notify with a header and justification
+		let justification = create_justification();
+		justification_sender.notify(|| Ok::<_, ()>(justification.clone())).unwrap();
+
+		// Inspect what we received
+		let (recv_justification, recv_sub_id): (sp_core::Bytes, SubscriptionId) =
+			sub.next().await.unwrap().unwrap();
+		let recv_justification: GrandpaJustification<Block> =
+			Decode::decode(&mut &recv_justification[..]).unwrap();
+
+		assert_eq!(&recv_sub_id, sub.subscription_id());
+		assert_eq!(recv_justification, justification);
+	}
+
+	#[tokio::test]
+	async fn prove_finality_with_test_finality_proof_provider() {
+		let finality_proof = FinalityProof {
+			block: header(42).hash(),
+			justification: create_justification().encode(),
+			unknown_headers: vec![header(2)],
+		};
+		let (rpc, _) =
+			setup_io_handler_with_finality_proofs(TestVoterState, Some(finality_proof.clone()));
+
+		let bytes: sp_core::Bytes = rpc.call("grandpa_proveFinality", [42]).await.unwrap();
+		let finality_proof_rpc: FinalityProof<Header> = Decode::decode(&mut &bytes[..]).unwrap();
+		assert_eq!(finality_proof_rpc, finality_proof);
+	}
+}
diff --git a/substrate/client/consensus/grandpa/rpc/src/notification.rs b/substrate/client/consensus/grandpa/rpc/src/notification.rs
new file mode 100644
index 0000000000000000000000000000000000000000..42b9123ed8c145a174ea8c7a11be3bfa740fce97
--- /dev/null
+++ b/substrate/client/consensus/grandpa/rpc/src/notification.rs
@@ -0,0 +1,32 @@
+// 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 parity_scale_codec::Encode;
+use sc_consensus_grandpa::GrandpaJustification;
+use serde::{Deserialize, Serialize};
+use sp_runtime::traits::Block as BlockT;
+
+/// An encoded justification proving that the given header has been finalized
+#[derive(Clone, Serialize, Deserialize)]
+pub struct JustificationNotification(sp_core::Bytes);
+
+impl<Block: BlockT> From<GrandpaJustification<Block>> for JustificationNotification {
+	fn from(notification: GrandpaJustification<Block>) -> Self {
+		JustificationNotification(notification.encode().into())
+	}
+}
diff --git a/substrate/client/consensus/grandpa/rpc/src/report.rs b/substrate/client/consensus/grandpa/rpc/src/report.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ae4fd76d2857a49f29cd807ee257fe3bac3e7f27
--- /dev/null
+++ b/substrate/client/consensus/grandpa/rpc/src/report.rs
@@ -0,0 +1,150 @@
+// 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 std::{
+	collections::{BTreeSet, HashSet},
+	fmt::Debug,
+	ops::Add,
+};
+
+use serde::{Deserialize, Serialize};
+
+use sc_consensus_grandpa::{report, AuthorityId, SharedAuthoritySet, SharedVoterState};
+
+use crate::error::Error;
+
+/// Utility trait to get reporting data for the current GRANDPA authority set.
+pub trait ReportAuthoritySet {
+	fn get(&self) -> (u64, HashSet<AuthorityId>);
+}
+
+/// Utility trait to get reporting data for the current GRANDPA voter state.
+pub trait ReportVoterState {
+	fn get(&self) -> Option<report::VoterState<AuthorityId>>;
+}
+
+impl<H, N> ReportAuthoritySet for SharedAuthoritySet<H, N>
+where
+	N: Add<Output = N> + Ord + Clone + Debug,
+	H: Clone + Debug + Eq,
+{
+	fn get(&self) -> (u64, HashSet<AuthorityId>) {
+		let current_voters: HashSet<AuthorityId> =
+			self.current_authorities().iter().map(|p| p.0.clone()).collect();
+
+		(self.set_id(), current_voters)
+	}
+}
+
+impl ReportVoterState for SharedVoterState {
+	fn get(&self) -> Option<report::VoterState<AuthorityId>> {
+		self.voter_state()
+	}
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Prevotes {
+	current_weight: u32,
+	missing: BTreeSet<AuthorityId>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct Precommits {
+	current_weight: u32,
+	missing: BTreeSet<AuthorityId>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct RoundState {
+	round: u32,
+	total_weight: u32,
+	threshold_weight: u32,
+	prevotes: Prevotes,
+	precommits: Precommits,
+}
+
+impl RoundState {
+	fn from(
+		round: u64,
+		round_state: &report::RoundState<AuthorityId>,
+		voters: &HashSet<AuthorityId>,
+	) -> Result<Self, Error> {
+		let prevotes = &round_state.prevote_ids;
+		let missing_prevotes = voters.difference(prevotes).cloned().collect();
+
+		let precommits = &round_state.precommit_ids;
+		let missing_precommits = voters.difference(precommits).cloned().collect();
+
+		Ok(Self {
+			round: round.try_into()?,
+			total_weight: round_state.total_weight.get().try_into()?,
+			threshold_weight: round_state.threshold_weight.get().try_into()?,
+			prevotes: Prevotes {
+				current_weight: round_state.prevote_current_weight.0.try_into()?,
+				missing: missing_prevotes,
+			},
+			precommits: Precommits {
+				current_weight: round_state.precommit_current_weight.0.try_into()?,
+				missing: missing_precommits,
+			},
+		})
+	}
+}
+
+/// The state of the current best round, as well as the background rounds in a
+/// form suitable for serialization.
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReportedRoundStates {
+	set_id: u32,
+	best: RoundState,
+	background: Vec<RoundState>,
+}
+
+impl ReportedRoundStates {
+	pub fn from<AuthoritySet, VoterState>(
+		authority_set: &AuthoritySet,
+		voter_state: &VoterState,
+	) -> Result<Self, Error>
+	where
+		AuthoritySet: ReportAuthoritySet,
+		VoterState: ReportVoterState,
+	{
+		let voter_state = voter_state.get().ok_or(Error::EndpointNotReady)?;
+
+		let (set_id, current_voters) = authority_set.get();
+		let set_id =
+			u32::try_from(set_id).map_err(|_| Error::AuthoritySetIdReportedAsUnreasonablyLarge)?;
+
+		let best = {
+			let (round, round_state) = voter_state.best_round;
+			RoundState::from(round, &round_state, &current_voters)?
+		};
+
+		let background = voter_state
+			.background_rounds
+			.iter()
+			.map(|(round, round_state)| RoundState::from(*round, round_state, &current_voters))
+			.collect::<Result<Vec<_>, Error>>()?;
+
+		Ok(Self { set_id, best, background })
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/authorities.rs b/substrate/client/consensus/grandpa/src/authorities.rs
new file mode 100644
index 0000000000000000000000000000000000000000..623223e41eb8234d85b3aa51a35bd4c1116e8ee7
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/authorities.rs
@@ -0,0 +1,1752 @@
+// 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/>.
+
+//! Utilities for dealing with authorities, authority sets, and handoffs.
+
+use std::{cmp::Ord, fmt::Debug, ops::Add};
+
+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};
+use sp_consensus_grandpa::{AuthorityId, AuthorityList};
+
+use crate::{SetId, LOG_TARGET};
+
+/// Error type returned on operations on the `AuthoritySet`.
+#[derive(Debug, thiserror::Error)]
+pub enum Error<N, E> {
+	#[error("Invalid authority set, either empty or with an authority weight set to 0.")]
+	InvalidAuthoritySet,
+	#[error("Client error during ancestry lookup: {0}")]
+	Client(E),
+	#[error("Duplicate authority set change.")]
+	DuplicateAuthoritySetChange,
+	#[error("Multiple pending forced authority set changes are not allowed.")]
+	MultiplePendingForcedAuthoritySetChanges,
+	#[error(
+		"A pending forced authority set change could not be applied since it must be applied \
+		after the pending standard change at #{0}"
+	)]
+	ForcedAuthoritySetChangeDependencyUnsatisfied(N),
+	#[error("Invalid operation in the pending changes tree: {0}")]
+	ForkTree(fork_tree::Error<E>),
+}
+
+impl<N, E> From<fork_tree::Error<E>> for Error<N, E> {
+	fn from(err: fork_tree::Error<E>) -> Error<N, E> {
+		match err {
+			fork_tree::Error::Client(err) => Error::Client(err),
+			fork_tree::Error::Duplicate => Error::DuplicateAuthoritySetChange,
+			err => Error::ForkTree(err),
+		}
+	}
+}
+
+impl<N, E: std::error::Error> From<E> for Error<N, E> {
+	fn from(err: E) -> Error<N, E> {
+		Error::Client(err)
+	}
+}
+
+/// A shared authority set.
+pub struct SharedAuthoritySet<H, N> {
+	inner: SharedData<AuthoritySet<H, N>>,
+}
+
+impl<H, N> Clone for SharedAuthoritySet<H, N> {
+	fn clone(&self) -> Self {
+		SharedAuthoritySet { inner: self.inner.clone() }
+	}
+}
+
+impl<H, N> SharedAuthoritySet<H, N> {
+	/// Returns access to the [`AuthoritySet`].
+	pub(crate) fn inner(&self) -> MappedMutexGuard<AuthoritySet<H, N>> {
+		self.inner.shared_data()
+	}
+
+	/// Returns access to the [`AuthoritySet`] and locks it.
+	///
+	/// For more information see [`SharedDataLocked`].
+	pub(crate) fn inner_locked(&self) -> SharedDataLocked<AuthoritySet<H, N>> {
+		self.inner.shared_data_locked()
+	}
+}
+
+impl<H: Eq, N> SharedAuthoritySet<H, N>
+where
+	N: Add<Output = N> + Ord + Clone + Debug,
+	H: Clone + Debug,
+{
+	/// Get the earliest limit-block number that's higher or equal to the given
+	/// min number, if any.
+	pub(crate) fn current_limit(&self, min: N) -> Option<N> {
+		self.inner().current_limit(min)
+	}
+
+	/// Get the current set ID. This is incremented every time the set changes.
+	pub fn set_id(&self) -> u64 {
+		self.inner().set_id
+	}
+
+	/// Get the current authorities and their weights (for the current set ID).
+	pub fn current_authorities(&self) -> VoterSet<AuthorityId> {
+		VoterSet::new(self.inner().current_authorities.iter().cloned()).expect(
+			"current_authorities is non-empty and weights are non-zero; \
+			 constructor and all mutating operations on `AuthoritySet` ensure this; \
+			 qed.",
+		)
+	}
+
+	/// Clone the inner `AuthoritySet`.
+	pub fn clone_inner(&self) -> AuthoritySet<H, N> {
+		self.inner().clone()
+	}
+
+	/// Clone the inner `AuthoritySetChanges`.
+	pub fn authority_set_changes(&self) -> AuthoritySetChanges<N> {
+		self.inner().authority_set_changes.clone()
+	}
+}
+
+impl<H, N> From<AuthoritySet<H, N>> for SharedAuthoritySet<H, N> {
+	fn from(set: AuthoritySet<H, N>) -> Self {
+		SharedAuthoritySet { inner: SharedData::new(set) }
+	}
+}
+
+/// Status of the set after changes were applied.
+#[derive(Debug)]
+pub(crate) struct Status<H, N> {
+	/// Whether internal changes were made.
+	pub(crate) changed: bool,
+	/// `Some` when underlying authority set has changed, containing the
+	/// block where that set changed.
+	pub(crate) new_set_block: Option<(H, N)>,
+}
+
+/// A set of authorities.
+#[derive(Debug, Clone, Encode, Decode, PartialEq)]
+pub struct AuthoritySet<H, N> {
+	/// The current active authorities.
+	pub(crate) current_authorities: AuthorityList,
+	/// The current set id.
+	pub(crate) set_id: u64,
+	/// Tree of pending standard changes across forks. Standard changes are
+	/// enacted on finality and must be enacted (i.e. finalized) in-order across
+	/// a given branch
+	pub(crate) pending_standard_changes: ForkTree<H, N, PendingChange<H, N>>,
+	/// Pending forced changes across different forks (at most one per fork).
+	/// Forced changes are enacted on block depth (not finality), for this
+	/// reason only one forced change should exist per fork. When trying to
+	/// apply forced changes we keep track of any pending standard changes that
+	/// they may depend on, this is done by making sure that any pending change
+	/// that is an ancestor of the forced changed and its effective block number
+	/// is lower than the last finalized block (as signaled in the forced
+	/// change) must be applied beforehand.
+	pending_forced_changes: Vec<PendingChange<H, N>>,
+	/// Track at which blocks the set id changed. This is useful when we need to prove finality for
+	/// a given block since we can figure out what set the block belongs to and when the set
+	/// started/ended.
+	pub(crate) authority_set_changes: AuthoritySetChanges<N>,
+}
+
+impl<H, N> AuthoritySet<H, N>
+where
+	H: PartialEq,
+	N: Ord + Clone,
+{
+	// authority sets must be non-empty and all weights must be greater than 0
+	fn invalid_authority_list(authorities: &AuthorityList) -> bool {
+		authorities.is_empty() || authorities.iter().any(|(_, w)| *w == 0)
+	}
+
+	/// Get a genesis set with given authorities.
+	pub(crate) fn genesis(initial: AuthorityList) -> Option<Self> {
+		if Self::invalid_authority_list(&initial) {
+			return None
+		}
+
+		Some(AuthoritySet {
+			current_authorities: initial,
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		})
+	}
+
+	/// Create a new authority set.
+	pub(crate) fn new(
+		authorities: AuthorityList,
+		set_id: u64,
+		pending_standard_changes: ForkTree<H, N, PendingChange<H, N>>,
+		pending_forced_changes: Vec<PendingChange<H, N>>,
+		authority_set_changes: AuthoritySetChanges<N>,
+	) -> Option<Self> {
+		if Self::invalid_authority_list(&authorities) {
+			return None
+		}
+
+		Some(AuthoritySet {
+			current_authorities: authorities,
+			set_id,
+			pending_standard_changes,
+			pending_forced_changes,
+			authority_set_changes,
+		})
+	}
+
+	/// Get the current set id and a reference to the current authority set.
+	pub(crate) fn current(&self) -> (u64, &[(AuthorityId, u64)]) {
+		(self.set_id, &self.current_authorities[..])
+	}
+
+	/// Revert to a specified block given its `hash` and `number`.
+	/// This removes all the authority set changes that were announced after
+	/// the revert point.
+	/// Revert point is identified by `number` and `hash`.
+	pub(crate) fn revert<F, E>(&mut self, hash: H, number: N, is_descendent_of: &F)
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+	{
+		let filter = |node_hash: &H, node_num: &N, _: &PendingChange<H, N>| {
+			if number >= *node_num &&
+				(is_descendent_of(node_hash, &hash).unwrap_or_default() || *node_hash == hash)
+			{
+				// Continue the search in this subtree.
+				FilterAction::KeepNode
+			} else if number < *node_num && is_descendent_of(&hash, node_hash).unwrap_or_default() {
+				// Found a node to be removed.
+				FilterAction::Remove
+			} else {
+				// Not a parent or child of the one we're looking for, stop processing this branch.
+				FilterAction::KeepTree
+			}
+		};
+
+		// Remove standard changes.
+		let _ = self.pending_standard_changes.drain_filter(&filter);
+
+		// Remove forced changes.
+		self.pending_forced_changes
+			.retain(|change| !is_descendent_of(&hash, &change.canon_hash).unwrap_or_default());
+	}
+}
+
+impl<H: Eq, N> AuthoritySet<H, N>
+where
+	N: Add<Output = N> + Ord + Clone + Debug,
+	H: Clone + Debug,
+{
+	/// Returns the block hash and height at which the next pending change in
+	/// the given chain (i.e. it includes `best_hash`) was signalled, `None` if
+	/// there are no pending changes for the given chain.
+	///
+	/// This is useful since we know that when a change is signalled the
+	/// underlying runtime authority set management module (e.g. session module)
+	/// has updated its internal state (e.g. a new session started).
+	pub(crate) fn next_change<F, E>(
+		&self,
+		best_hash: &H,
+		is_descendent_of: &F,
+	) -> Result<Option<(H, N)>, Error<N, E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		let mut forced = None;
+		for change in &self.pending_forced_changes {
+			if is_descendent_of(&change.canon_hash, best_hash)? {
+				forced = Some((change.canon_hash.clone(), change.canon_height.clone()));
+				break
+			}
+		}
+
+		let mut standard = None;
+		for (_, _, change) in self.pending_standard_changes.roots() {
+			if is_descendent_of(&change.canon_hash, best_hash)? {
+				standard = Some((change.canon_hash.clone(), change.canon_height.clone()));
+				break
+			}
+		}
+
+		let earliest = match (forced, standard) {
+			(Some(forced), Some(standard)) =>
+				Some(if forced.1 < standard.1 { forced } else { standard }),
+			(Some(forced), None) => Some(forced),
+			(None, Some(standard)) => Some(standard),
+			(None, None) => None,
+		};
+
+		Ok(earliest)
+	}
+
+	fn add_standard_change<F, E>(
+		&mut self,
+		pending: PendingChange<H, N>,
+		is_descendent_of: &F,
+	) -> Result<(), Error<N, E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		let hash = pending.canon_hash.clone();
+		let number = pending.canon_height.clone();
+
+		debug!(
+			target: LOG_TARGET,
+			"Inserting potential standard set change signaled at block {:?} (delayed by {:?} blocks).",
+			(&number, &hash),
+			pending.delay,
+		);
+
+		self.pending_standard_changes.import(hash, number, pending, is_descendent_of)?;
+
+		debug!(
+			target: LOG_TARGET,
+			"There are now {} alternatives for the next pending standard change (roots), and a \
+			 total of {} pending standard changes (across all forks).",
+			self.pending_standard_changes.roots().count(),
+			self.pending_standard_changes.iter().count(),
+		);
+
+		Ok(())
+	}
+
+	fn add_forced_change<F, E>(
+		&mut self,
+		pending: PendingChange<H, N>,
+		is_descendent_of: &F,
+	) -> Result<(), Error<N, E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		for change in &self.pending_forced_changes {
+			if change.canon_hash == pending.canon_hash {
+				return Err(Error::DuplicateAuthoritySetChange)
+			}
+
+			if is_descendent_of(&change.canon_hash, &pending.canon_hash)? {
+				return Err(Error::MultiplePendingForcedAuthoritySetChanges)
+			}
+		}
+
+		// ordered first by effective number and then by signal-block number.
+		let key = (pending.effective_number(), pending.canon_height.clone());
+		let idx = self
+			.pending_forced_changes
+			.binary_search_by_key(&key, |change| {
+				(change.effective_number(), change.canon_height.clone())
+			})
+			.unwrap_or_else(|i| i);
+
+		debug!(
+			target: LOG_TARGET,
+			"Inserting potential forced set change at block {:?} (delayed by {:?} blocks).",
+			(&pending.canon_height, &pending.canon_hash),
+			pending.delay,
+		);
+
+		self.pending_forced_changes.insert(idx, pending);
+
+		debug!(
+			target: LOG_TARGET,
+			"There are now {} pending forced changes.",
+			self.pending_forced_changes.len()
+		);
+
+		Ok(())
+	}
+
+	/// Note an upcoming pending transition. Multiple pending standard changes
+	/// on the same branch can be added as long as they don't overlap. Forced
+	/// changes are restricted to one per fork. This method assumes that changes
+	/// on the same branch will be added in-order. The given function
+	/// `is_descendent_of` should return `true` if the second hash (target) is a
+	/// descendent of the first hash (base).
+	pub(crate) fn add_pending_change<F, E>(
+		&mut self,
+		pending: PendingChange<H, N>,
+		is_descendent_of: &F,
+	) -> Result<(), Error<N, E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		if Self::invalid_authority_list(&pending.next_authorities) {
+			return Err(Error::InvalidAuthoritySet)
+		}
+
+		match pending.delay_kind {
+			DelayKind::Best { .. } => self.add_forced_change(pending, is_descendent_of),
+			DelayKind::Finalized => self.add_standard_change(pending, is_descendent_of),
+		}
+	}
+
+	/// Inspect pending changes. Standard pending changes are iterated first,
+	/// and the changes in the tree are traversed in pre-order, afterwards all
+	/// forced changes are iterated.
+	pub(crate) fn pending_changes(&self) -> impl Iterator<Item = &PendingChange<H, N>> {
+		self.pending_standard_changes
+			.iter()
+			.map(|(_, _, c)| c)
+			.chain(self.pending_forced_changes.iter())
+	}
+
+	/// Get the earliest limit-block number, if any. If there are pending changes across
+	/// different forks, this method will return the earliest effective number (across the
+	/// different branches) that is higher or equal to the given min number.
+	///
+	/// Only standard changes are taken into account for the current
+	/// limit, since any existing forced change should preclude the voter from voting.
+	pub(crate) fn current_limit(&self, min: N) -> Option<N> {
+		self.pending_standard_changes
+			.roots()
+			.filter(|&(_, _, c)| c.effective_number() >= min)
+			.min_by_key(|&(_, _, c)| c.effective_number())
+			.map(|(_, _, c)| c.effective_number())
+	}
+
+	/// Apply or prune any pending transitions based on a best-block trigger.
+	///
+	/// Returns `Ok((median, new_set))` when a forced change has occurred. The
+	/// median represents the median last finalized block at the time the change
+	/// was signaled, and it should be used as the canon block when starting the
+	/// new grandpa voter. Only alters the internal state in this case.
+	///
+	/// These transitions are always forced and do not lead to justifications
+	/// which light clients can follow.
+	///
+	/// Forced changes can only be applied after all pending standard changes
+	/// that it depends on have been applied. If any pending standard change
+	/// exists that is an ancestor of a given forced changed and which effective
+	/// block number is lower than the last finalized block (as defined by the
+	/// forced change), then the forced change cannot be applied. An error will
+	/// be returned in that case which will prevent block import.
+	pub(crate) fn apply_forced_changes<F, E>(
+		&self,
+		best_hash: H,
+		best_number: N,
+		is_descendent_of: &F,
+		initial_sync: bool,
+		telemetry: Option<TelemetryHandle>,
+	) -> Result<Option<(N, Self)>, Error<N, E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		let mut new_set = None;
+
+		for change in self
+			.pending_forced_changes
+			.iter()
+			.take_while(|c| c.effective_number() <= best_number) // to prevent iterating too far
+			.filter(|c| c.effective_number() == best_number)
+		{
+			// check if the given best block is in the same branch as
+			// the block that signaled the change.
+			if change.canon_hash == best_hash || is_descendent_of(&change.canon_hash, &best_hash)? {
+				let median_last_finalized = match change.delay_kind {
+					DelayKind::Best { ref median_last_finalized } => median_last_finalized.clone(),
+					_ => unreachable!(
+						"pending_forced_changes only contains forced changes; forced changes have delay kind Best; qed."
+					),
+				};
+
+				// check if there's any pending standard change that we depend on
+				for (_, _, standard_change) in self.pending_standard_changes.roots() {
+					if standard_change.effective_number() <= median_last_finalized &&
+						is_descendent_of(&standard_change.canon_hash, &change.canon_hash)?
+					{
+						log::info!(target: LOG_TARGET,
+							"Not applying authority set change forced at block #{:?}, due to pending standard change at block #{:?}",
+							change.canon_height,
+							standard_change.effective_number(),
+						);
+
+						return Err(Error::ForcedAuthoritySetChangeDependencyUnsatisfied(
+							standard_change.effective_number(),
+						))
+					}
+				}
+
+				// apply this change: make the set canonical
+				grandpa_log!(
+					initial_sync,
+					"👴 Applying authority set change forced at block #{:?}",
+					change.canon_height,
+				);
+
+				telemetry!(
+					telemetry;
+					CONSENSUS_INFO;
+					"afg.applying_forced_authority_set_change";
+					"block" => ?change.canon_height
+				);
+
+				let mut authority_set_changes = self.authority_set_changes.clone();
+				authority_set_changes.append(self.set_id, median_last_finalized.clone());
+
+				new_set = Some((
+					median_last_finalized,
+					AuthoritySet {
+						current_authorities: change.next_authorities.clone(),
+						set_id: self.set_id + 1,
+						pending_standard_changes: ForkTree::new(), // new set, new changes.
+						pending_forced_changes: Vec::new(),
+						authority_set_changes,
+					},
+				));
+
+				break
+			}
+		}
+
+		// we don't wipe forced changes until another change is applied, hence
+		// why we return a new set instead of mutating.
+		Ok(new_set)
+	}
+
+	/// Apply or prune any pending transitions based on a finality trigger. This
+	/// method ensures that if there are multiple changes in the same branch,
+	/// finalizing this block won't finalize past multiple transitions (i.e.
+	/// transitions must be finalized in-order). The given function
+	/// `is_descendent_of` should return `true` if the second hash (target) is a
+	/// descendent of the first hash (base).
+	///
+	/// When the set has changed, the return value will be `Ok(Some((H, N)))`
+	/// which is the canonical block where the set last changed (i.e. the given
+	/// hash and number).
+	pub(crate) fn apply_standard_changes<F, E>(
+		&mut self,
+		finalized_hash: H,
+		finalized_number: N,
+		is_descendent_of: &F,
+		initial_sync: bool,
+		telemetry: Option<&TelemetryHandle>,
+	) -> Result<Status<H, N>, Error<N, E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		let mut status = Status { changed: false, new_set_block: None };
+
+		match self.pending_standard_changes.finalize_with_descendent_if(
+			&finalized_hash,
+			finalized_number.clone(),
+			is_descendent_of,
+			|change| change.effective_number() <= finalized_number,
+		)? {
+			fork_tree::FinalizationResult::Changed(change) => {
+				status.changed = true;
+
+				let pending_forced_changes = std::mem::take(&mut self.pending_forced_changes);
+
+				// we will keep all forced changes for any later blocks and that are a
+				// descendent of the finalized block (i.e. they are part of this branch).
+				for change in pending_forced_changes {
+					if change.effective_number() > finalized_number &&
+						is_descendent_of(&finalized_hash, &change.canon_hash)?
+					{
+						self.pending_forced_changes.push(change)
+					}
+				}
+
+				if let Some(change) = change {
+					grandpa_log!(
+						initial_sync,
+						"👴 Applying authority set change scheduled at block #{:?}",
+						change.canon_height,
+					);
+					telemetry!(
+						telemetry;
+						CONSENSUS_INFO;
+						"afg.applying_scheduled_authority_set_change";
+						"block" => ?change.canon_height
+					);
+
+					// Store the set_id together with the last block_number for the set
+					self.authority_set_changes.append(self.set_id, finalized_number.clone());
+
+					self.current_authorities = change.next_authorities;
+					self.set_id += 1;
+
+					status.new_set_block = Some((finalized_hash, finalized_number));
+				}
+			},
+			fork_tree::FinalizationResult::Unchanged => {},
+		}
+
+		Ok(status)
+	}
+
+	/// Check whether the given finalized block number enacts any standard
+	/// authority set change (without triggering it), ensuring that if there are
+	/// multiple changes in the same branch, finalizing this block won't
+	/// finalize past multiple transitions (i.e. transitions must be finalized
+	/// in-order). Returns `Some(true)` if the block being finalized enacts a
+	/// change that can be immediately applied, `Some(false)` if the block being
+	/// finalized enacts a change but it cannot be applied yet since there are
+	/// other dependent changes, and `None` if no change is enacted. The given
+	/// function `is_descendent_of` should return `true` if the second hash
+	/// (target) is a descendent of the first hash (base).
+	pub fn enacts_standard_change<F, E>(
+		&self,
+		finalized_hash: H,
+		finalized_number: N,
+		is_descendent_of: &F,
+	) -> Result<Option<bool>, Error<N, E>>
+	where
+		F: Fn(&H, &H) -> Result<bool, E>,
+		E: std::error::Error,
+	{
+		self.pending_standard_changes
+			.finalizes_any_with_descendent_if(
+				&finalized_hash,
+				finalized_number.clone(),
+				is_descendent_of,
+				|change| change.effective_number() == finalized_number,
+			)
+			.map_err(Error::ForkTree)
+	}
+}
+
+/// Kinds of delays for pending changes.
+#[derive(Debug, Clone, Encode, Decode, PartialEq)]
+pub enum DelayKind<N> {
+	/// Depth in finalized chain.
+	Finalized,
+	/// Depth in best chain. The median last finalized block is calculated at the time the
+	/// change was signaled.
+	Best { median_last_finalized: N },
+}
+
+/// A pending change to the authority set.
+///
+/// This will be applied when the announcing block is at some depth within
+/// the finalized or unfinalized chain.
+#[derive(Debug, Clone, Encode, PartialEq)]
+pub struct PendingChange<H, N> {
+	/// The new authorities and weights to apply.
+	pub(crate) next_authorities: AuthorityList,
+	/// How deep in the chain the announcing block must be
+	/// before the change is applied.
+	pub(crate) delay: N,
+	/// The announcing block's height.
+	pub(crate) canon_height: N,
+	/// The announcing block's hash.
+	pub(crate) canon_hash: H,
+	/// The delay kind.
+	pub(crate) delay_kind: DelayKind<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> {
+		let next_authorities = Decode::decode(value)?;
+		let delay = Decode::decode(value)?;
+		let canon_height = Decode::decode(value)?;
+		let canon_hash = Decode::decode(value)?;
+
+		let delay_kind = DelayKind::decode(value).unwrap_or(DelayKind::Finalized);
+
+		Ok(PendingChange { next_authorities, delay, canon_height, canon_hash, delay_kind })
+	}
+}
+
+impl<H, N: Add<Output = N> + Clone> PendingChange<H, N> {
+	/// Returns the effective number this change will be applied at.
+	pub fn effective_number(&self) -> N {
+		self.canon_height.clone() + self.delay.clone()
+	}
+}
+
+/// Tracks historical authority set changes. We store the block numbers for the last block
+/// of each authority set, once they have been finalized. These blocks are guaranteed to
+/// have a justification unless they were triggered by a forced change.
+#[derive(Debug, Encode, Decode, Clone, PartialEq)]
+pub struct AuthoritySetChanges<N>(Vec<(u64, N)>);
+
+/// The response when querying for a set id for a specific block. Either we get a set id
+/// together with a block number for the last block in the set, or that the requested block is in
+/// the latest set, or that we don't know what set id the given block belongs to.
+#[derive(Debug, PartialEq)]
+pub enum AuthoritySetChangeId<N> {
+	/// The requested block is in the latest set.
+	Latest,
+	/// Tuple containing the set id and the last block number of that set.
+	Set(SetId, N),
+	/// We don't know which set id the request block belongs to (this can only happen due to
+	/// missing data).
+	Unknown,
+}
+
+impl<N> From<Vec<(u64, N)>> for AuthoritySetChanges<N> {
+	fn from(changes: Vec<(u64, N)>) -> AuthoritySetChanges<N> {
+		AuthoritySetChanges(changes)
+	}
+}
+
+impl<N: Ord + Clone> AuthoritySetChanges<N> {
+	pub(crate) fn empty() -> Self {
+		Self(Default::default())
+	}
+
+	pub(crate) fn append(&mut self, set_id: u64, block_number: N) {
+		self.0.push((set_id, block_number));
+	}
+
+	pub(crate) fn get_set_id(&self, block_number: N) -> AuthoritySetChangeId<N> {
+		if self
+			.0
+			.last()
+			.map(|last_auth_change| last_auth_change.1 < block_number)
+			.unwrap_or(false)
+		{
+			return AuthoritySetChangeId::Latest
+		}
+
+		let idx = self
+			.0
+			.binary_search_by_key(&block_number, |(_, n)| n.clone())
+			.unwrap_or_else(|b| b);
+
+		if idx < self.0.len() {
+			let (set_id, block_number) = self.0[idx].clone();
+
+			// if this is the first index but not the first set id then we are missing data.
+			if idx == 0 && set_id != 0 {
+				return AuthoritySetChangeId::Unknown
+			}
+
+			AuthoritySetChangeId::Set(set_id, block_number)
+		} else {
+			AuthoritySetChangeId::Unknown
+		}
+	}
+
+	pub(crate) fn insert(&mut self, block_number: N) {
+		let idx = self
+			.0
+			.binary_search_by_key(&block_number, |(_, n)| n.clone())
+			.unwrap_or_else(|b| b);
+
+		let set_id = if idx == 0 { 0 } else { self.0[idx - 1].0 + 1 };
+		assert!(idx == self.0.len() || self.0[idx].0 != set_id);
+		self.0.insert(idx, (set_id, block_number));
+	}
+
+	/// Returns an iterator over all historical authority set changes starting at the given block
+	/// number (excluded). The iterator yields a tuple representing the set id and the block number
+	/// of the last block in that set.
+	pub fn iter_from(&self, block_number: N) -> Option<impl Iterator<Item = &(u64, N)>> {
+		let idx = self
+			.0
+			.binary_search_by_key(&block_number, |(_, n)| n.clone())
+			// if there was a change at the given block number then we should start on the next
+			// index since we want to exclude the current block number
+			.map(|n| n + 1)
+			.unwrap_or_else(|b| b);
+
+		if idx < self.0.len() {
+			let (set_id, _) = self.0[idx].clone();
+
+			// if this is the first index but not the first set id then we are missing data.
+			if idx == 0 && set_id != 0 {
+				return None
+			}
+		}
+
+		Some(self.0[idx..].iter())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::crypto::{ByteArray, UncheckedFrom};
+
+	fn static_is_descendent_of<A>(value: bool) -> impl Fn(&A, &A) -> Result<bool, std::io::Error> {
+		move |_, _| Ok(value)
+	}
+
+	fn is_descendent_of<A, F>(f: F) -> impl Fn(&A, &A) -> Result<bool, std::io::Error>
+	where
+		F: Fn(&A, &A) -> bool,
+	{
+		move |base, hash| Ok(f(base, hash))
+	}
+
+	#[test]
+	fn current_limit_filters_min() {
+		let current_authorities = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 1)];
+
+		let mut authorities = AuthoritySet {
+			current_authorities: current_authorities.clone(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let change = |height| PendingChange {
+			next_authorities: current_authorities.clone(),
+			delay: 0,
+			canon_height: height,
+			canon_hash: height.to_string(),
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let is_descendent_of = static_is_descendent_of(false);
+
+		authorities.add_pending_change(change(1), &is_descendent_of).unwrap();
+		authorities.add_pending_change(change(2), &is_descendent_of).unwrap();
+
+		assert_eq!(authorities.current_limit(0), Some(1));
+
+		assert_eq!(authorities.current_limit(1), Some(1));
+
+		assert_eq!(authorities.current_limit(2), Some(2));
+
+		assert_eq!(authorities.current_limit(3), None);
+	}
+
+	#[test]
+	fn changes_iterated_in_pre_order() {
+		let current_authorities = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 1)];
+
+		let mut authorities = AuthoritySet {
+			current_authorities: current_authorities.clone(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let change_a = PendingChange {
+			next_authorities: current_authorities.clone(),
+			delay: 10,
+			canon_height: 5,
+			canon_hash: "hash_a",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_b = PendingChange {
+			next_authorities: current_authorities.clone(),
+			delay: 0,
+			canon_height: 5,
+			canon_hash: "hash_b",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_c = PendingChange {
+			next_authorities: current_authorities.clone(),
+			delay: 5,
+			canon_height: 10,
+			canon_hash: "hash_c",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		authorities
+			.add_pending_change(change_a.clone(), &static_is_descendent_of(false))
+			.unwrap();
+		authorities
+			.add_pending_change(change_b.clone(), &static_is_descendent_of(false))
+			.unwrap();
+		authorities
+			.add_pending_change(
+				change_c.clone(),
+				&is_descendent_of(|base, hash| match (*base, *hash) {
+					("hash_a", "hash_c") => true,
+					("hash_b", "hash_c") => false,
+					_ => unreachable!(),
+				}),
+			)
+			.unwrap();
+
+		// forced changes are iterated last
+		let change_d = PendingChange {
+			next_authorities: current_authorities.clone(),
+			delay: 2,
+			canon_height: 1,
+			canon_hash: "hash_d",
+			delay_kind: DelayKind::Best { median_last_finalized: 0 },
+		};
+
+		let change_e = PendingChange {
+			next_authorities: current_authorities.clone(),
+			delay: 2,
+			canon_height: 0,
+			canon_hash: "hash_e",
+			delay_kind: DelayKind::Best { median_last_finalized: 0 },
+		};
+
+		authorities
+			.add_pending_change(change_d.clone(), &static_is_descendent_of(false))
+			.unwrap();
+		authorities
+			.add_pending_change(change_e.clone(), &static_is_descendent_of(false))
+			.unwrap();
+
+		// ordered by subtree depth
+		assert_eq!(
+			authorities.pending_changes().collect::<Vec<_>>(),
+			vec![&change_a, &change_c, &change_b, &change_e, &change_d],
+		);
+	}
+
+	#[test]
+	fn apply_change() {
+		let mut authorities = AuthoritySet {
+			current_authorities: Vec::new(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let set_a = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 5)];
+		let set_b = vec![(AuthorityId::from_slice(&[2; 32]).unwrap(), 5)];
+
+		// two competing changes at the same height on different forks
+		let change_a = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 10,
+			canon_height: 5,
+			canon_hash: "hash_a",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_b = PendingChange {
+			next_authorities: set_b.clone(),
+			delay: 10,
+			canon_height: 5,
+			canon_hash: "hash_b",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		authorities
+			.add_pending_change(change_a.clone(), &static_is_descendent_of(true))
+			.unwrap();
+		authorities
+			.add_pending_change(change_b.clone(), &static_is_descendent_of(true))
+			.unwrap();
+
+		assert_eq!(authorities.pending_changes().collect::<Vec<_>>(), vec![&change_a, &change_b]);
+
+		// finalizing "hash_c" won't enact the change signaled at "hash_a" but it will prune out
+		// "hash_b"
+		let status = authorities
+			.apply_standard_changes(
+				"hash_c",
+				11,
+				&is_descendent_of(|base, hash| match (*base, *hash) {
+					("hash_a", "hash_c") => true,
+					("hash_b", "hash_c") => false,
+					_ => unreachable!(),
+				}),
+				false,
+				None,
+			)
+			.unwrap();
+
+		assert!(status.changed);
+		assert_eq!(status.new_set_block, None);
+		assert_eq!(authorities.pending_changes().collect::<Vec<_>>(), vec![&change_a]);
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges::empty());
+
+		// finalizing "hash_d" will enact the change signaled at "hash_a"
+		let status = authorities
+			.apply_standard_changes(
+				"hash_d",
+				15,
+				&is_descendent_of(|base, hash| match (*base, *hash) {
+					("hash_a", "hash_d") => true,
+					_ => unreachable!(),
+				}),
+				false,
+				None,
+			)
+			.unwrap();
+
+		assert!(status.changed);
+		assert_eq!(status.new_set_block, Some(("hash_d", 15)));
+
+		assert_eq!(authorities.current_authorities, set_a);
+		assert_eq!(authorities.set_id, 1);
+		assert_eq!(authorities.pending_changes().count(), 0);
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges(vec![(0, 15)]));
+	}
+
+	#[test]
+	fn disallow_multiple_changes_being_finalized_at_once() {
+		let mut authorities = AuthoritySet {
+			current_authorities: Vec::new(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let set_a = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 5)];
+		let set_c = vec![(AuthorityId::from_slice(&[2; 32]).unwrap(), 5)];
+
+		// two competing changes at the same height on different forks
+		let change_a = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 10,
+			canon_height: 5,
+			canon_hash: "hash_a",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_c = PendingChange {
+			next_authorities: set_c.clone(),
+			delay: 10,
+			canon_height: 30,
+			canon_hash: "hash_c",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		authorities
+			.add_pending_change(change_a.clone(), &static_is_descendent_of(true))
+			.unwrap();
+		authorities
+			.add_pending_change(change_c.clone(), &static_is_descendent_of(true))
+			.unwrap();
+
+		let is_descendent_of = is_descendent_of(|base, hash| match (*base, *hash) {
+			("hash_a", "hash_b") => true,
+			("hash_a", "hash_c") => true,
+			("hash_a", "hash_d") => true,
+
+			("hash_c", "hash_b") => false,
+			("hash_c", "hash_d") => true,
+
+			("hash_b", "hash_c") => true,
+			_ => unreachable!(),
+		});
+
+		// trying to finalize past `change_c` without finalizing `change_a` first
+		assert!(matches!(
+			authorities.apply_standard_changes("hash_d", 40, &is_descendent_of, false, None),
+			Err(Error::ForkTree(fork_tree::Error::UnfinalizedAncestor))
+		));
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges::empty());
+
+		let status = authorities
+			.apply_standard_changes("hash_b", 15, &is_descendent_of, false, None)
+			.unwrap();
+
+		assert!(status.changed);
+		assert_eq!(status.new_set_block, Some(("hash_b", 15)));
+
+		assert_eq!(authorities.current_authorities, set_a);
+		assert_eq!(authorities.set_id, 1);
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges(vec![(0, 15)]));
+
+		// after finalizing `change_a` it should be possible to finalize `change_c`
+		let status = authorities
+			.apply_standard_changes("hash_d", 40, &is_descendent_of, false, None)
+			.unwrap();
+
+		assert!(status.changed);
+		assert_eq!(status.new_set_block, Some(("hash_d", 40)));
+
+		assert_eq!(authorities.current_authorities, set_c);
+		assert_eq!(authorities.set_id, 2);
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges(vec![(0, 15), (1, 40)]));
+	}
+
+	#[test]
+	fn enacts_standard_change_works() {
+		let mut authorities = AuthoritySet {
+			current_authorities: Vec::new(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let set_a = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 5)];
+
+		let change_a = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 10,
+			canon_height: 5,
+			canon_hash: "hash_a",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_b = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 10,
+			canon_height: 20,
+			canon_hash: "hash_b",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		authorities
+			.add_pending_change(change_a.clone(), &static_is_descendent_of(false))
+			.unwrap();
+		authorities
+			.add_pending_change(change_b.clone(), &static_is_descendent_of(true))
+			.unwrap();
+
+		let is_descendent_of = is_descendent_of(|base, hash| match (*base, *hash) {
+			("hash_a", "hash_d") => true,
+			("hash_a", "hash_e") => true,
+			("hash_b", "hash_d") => true,
+			("hash_b", "hash_e") => true,
+			("hash_a", "hash_c") => false,
+			("hash_b", "hash_c") => false,
+			_ => unreachable!(),
+		});
+
+		// "hash_c" won't finalize the existing change since it isn't a descendent
+		assert_eq!(
+			authorities.enacts_standard_change("hash_c", 15, &is_descendent_of).unwrap(),
+			None,
+		);
+
+		// "hash_d" at depth 14 won't work either
+		assert_eq!(
+			authorities.enacts_standard_change("hash_d", 14, &is_descendent_of).unwrap(),
+			None,
+		);
+
+		// but it should work at depth 15 (change height + depth)
+		assert_eq!(
+			authorities.enacts_standard_change("hash_d", 15, &is_descendent_of).unwrap(),
+			Some(true),
+		);
+
+		// finalizing "hash_e" at depth 20 will trigger change at "hash_b", but
+		// it can't be applied yet since "hash_a" must be applied first
+		assert_eq!(
+			authorities.enacts_standard_change("hash_e", 30, &is_descendent_of).unwrap(),
+			Some(false),
+		);
+	}
+
+	#[test]
+	fn forced_changes() {
+		let mut authorities = AuthoritySet {
+			current_authorities: Vec::new(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let set_a = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 5)];
+		let set_b = vec![(AuthorityId::from_slice(&[2; 32]).unwrap(), 5)];
+
+		let change_a = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 10,
+			canon_height: 5,
+			canon_hash: "hash_a",
+			delay_kind: DelayKind::Best { median_last_finalized: 42 },
+		};
+
+		let change_b = PendingChange {
+			next_authorities: set_b.clone(),
+			delay: 10,
+			canon_height: 5,
+			canon_hash: "hash_b",
+			delay_kind: DelayKind::Best { median_last_finalized: 0 },
+		};
+
+		authorities
+			.add_pending_change(change_a, &static_is_descendent_of(false))
+			.unwrap();
+		authorities
+			.add_pending_change(change_b.clone(), &static_is_descendent_of(false))
+			.unwrap();
+
+		// no duplicates are allowed
+		assert!(matches!(
+			authorities.add_pending_change(change_b, &static_is_descendent_of(false)),
+			Err(Error::DuplicateAuthoritySetChange)
+		));
+
+		// there's an effective change triggered at block 15 but not a standard one.
+		// so this should do nothing.
+		assert_eq!(
+			authorities
+				.enacts_standard_change("hash_c", 15, &static_is_descendent_of(true))
+				.unwrap(),
+			None,
+		);
+
+		// there can only be one pending forced change per fork
+		let change_c = PendingChange {
+			next_authorities: set_b.clone(),
+			delay: 3,
+			canon_height: 8,
+			canon_hash: "hash_a8",
+			delay_kind: DelayKind::Best { median_last_finalized: 0 },
+		};
+
+		let is_descendent_of_a = is_descendent_of(|base: &&str, _| base.starts_with("hash_a"));
+
+		assert!(matches!(
+			authorities.add_pending_change(change_c, &is_descendent_of_a),
+			Err(Error::MultiplePendingForcedAuthoritySetChanges)
+		));
+
+		// let's try and apply the forced changes.
+		// too early and there's no forced changes to apply.
+		assert!(authorities
+			.apply_forced_changes("hash_a10", 10, &static_is_descendent_of(true), false, None)
+			.unwrap()
+			.is_none());
+
+		// too late.
+		assert!(authorities
+			.apply_forced_changes("hash_a16", 16, &is_descendent_of_a, false, None)
+			.unwrap()
+			.is_none());
+
+		// on time -- chooses the right change for this fork.
+		assert_eq!(
+			authorities
+				.apply_forced_changes("hash_a15", 15, &is_descendent_of_a, false, None)
+				.unwrap()
+				.unwrap(),
+			(
+				42,
+				AuthoritySet {
+					current_authorities: set_a,
+					set_id: 1,
+					pending_standard_changes: ForkTree::new(),
+					pending_forced_changes: Vec::new(),
+					authority_set_changes: AuthoritySetChanges(vec![(0, 42)]),
+				},
+			)
+		);
+	}
+
+	#[test]
+	fn forced_changes_with_no_delay() {
+		// NOTE: this is a regression test
+		let mut authorities = AuthoritySet {
+			current_authorities: Vec::new(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let set_a = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 5)];
+
+		// we create a forced change with no delay
+		let change_a = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 0,
+			canon_height: 5,
+			canon_hash: "hash_a",
+			delay_kind: DelayKind::Best { median_last_finalized: 0 },
+		};
+
+		// and import it
+		authorities
+			.add_pending_change(change_a, &static_is_descendent_of(false))
+			.unwrap();
+
+		// it should be enacted at the same block that signaled it
+		assert!(authorities
+			.apply_forced_changes("hash_a", 5, &static_is_descendent_of(false), false, None)
+			.unwrap()
+			.is_some());
+	}
+
+	#[test]
+	fn forced_changes_blocked_by_standard_changes() {
+		let set_a = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 1)];
+
+		let mut authorities = AuthoritySet {
+			current_authorities: set_a.clone(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		// effective at #15
+		let change_a = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 5,
+			canon_height: 10,
+			canon_hash: "hash_a",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		// effective #20
+		let change_b = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 0,
+			canon_height: 20,
+			canon_hash: "hash_b",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		// effective at #35
+		let change_c = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 5,
+			canon_height: 30,
+			canon_hash: "hash_c",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		// add some pending standard changes all on the same fork
+		authorities
+			.add_pending_change(change_a, &static_is_descendent_of(true))
+			.unwrap();
+		authorities
+			.add_pending_change(change_b, &static_is_descendent_of(true))
+			.unwrap();
+		authorities
+			.add_pending_change(change_c, &static_is_descendent_of(true))
+			.unwrap();
+
+		// effective at #45
+		let change_d = PendingChange {
+			next_authorities: set_a.clone(),
+			delay: 5,
+			canon_height: 40,
+			canon_hash: "hash_d",
+			delay_kind: DelayKind::Best { median_last_finalized: 31 },
+		};
+
+		// now add a forced change on the same fork
+		authorities
+			.add_pending_change(change_d, &static_is_descendent_of(true))
+			.unwrap();
+
+		// the forced change cannot be applied since the pending changes it depends on
+		// have not been applied yet.
+		assert!(matches!(
+			authorities.apply_forced_changes(
+				"hash_d45",
+				45,
+				&static_is_descendent_of(true),
+				false,
+				None
+			),
+			Err(Error::ForcedAuthoritySetChangeDependencyUnsatisfied(15))
+		));
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges::empty());
+
+		// we apply the first pending standard change at #15
+		authorities
+			.apply_standard_changes("hash_a15", 15, &static_is_descendent_of(true), false, None)
+			.unwrap();
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges(vec![(0, 15)]));
+
+		// but the forced change still depends on the next standard change
+		assert!(matches!(
+			authorities.apply_forced_changes(
+				"hash_d",
+				45,
+				&static_is_descendent_of(true),
+				false,
+				None
+			),
+			Err(Error::ForcedAuthoritySetChangeDependencyUnsatisfied(20))
+		));
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges(vec![(0, 15)]));
+
+		// we apply the pending standard change at #20
+		authorities
+			.apply_standard_changes("hash_b", 20, &static_is_descendent_of(true), false, None)
+			.unwrap();
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges(vec![(0, 15), (1, 20)]));
+
+		// afterwards the forced change at #45 can already be applied since it signals
+		// that finality stalled at #31, and the next pending standard change is effective
+		// at #35. subsequent forced changes on the same branch must be kept
+		assert_eq!(
+			authorities
+				.apply_forced_changes("hash_d", 45, &static_is_descendent_of(true), false, None)
+				.unwrap()
+				.unwrap(),
+			(
+				31,
+				AuthoritySet {
+					current_authorities: set_a.clone(),
+					set_id: 3,
+					pending_standard_changes: ForkTree::new(),
+					pending_forced_changes: Vec::new(),
+					authority_set_changes: AuthoritySetChanges(vec![(0, 15), (1, 20), (2, 31)]),
+				}
+			),
+		);
+		assert_eq!(authorities.authority_set_changes, AuthoritySetChanges(vec![(0, 15), (1, 20)]));
+	}
+
+	#[test]
+	fn next_change_works() {
+		let current_authorities = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 1)];
+
+		let mut authorities = AuthoritySet {
+			current_authorities: current_authorities.clone(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let new_set = current_authorities.clone();
+
+		// We have three pending changes with 2 possible roots that are enacted
+		// immediately on finality (i.e. standard changes).
+		let change_a0 = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 5,
+			canon_hash: "hash_a0",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_a1 = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 10,
+			canon_hash: "hash_a1",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		let change_b = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 4,
+			canon_hash: "hash_b",
+			delay_kind: DelayKind::Finalized,
+		};
+
+		// A0 (#5) <- A10 (#8) <- A1 (#10) <- best_a
+		// B (#4) <- best_b
+		let is_descendent_of = is_descendent_of(|base, hash| match (*base, *hash) {
+			("hash_a0", "hash_a1") => true,
+			("hash_a0", "best_a") => true,
+			("hash_a1", "best_a") => true,
+			("hash_a10", "best_a") => true,
+			("hash_b", "best_b") => true,
+			_ => false,
+		});
+
+		// add the three pending changes
+		authorities.add_pending_change(change_b, &is_descendent_of).unwrap();
+		authorities.add_pending_change(change_a0, &is_descendent_of).unwrap();
+		authorities.add_pending_change(change_a1, &is_descendent_of).unwrap();
+
+		// the earliest change at block `best_a` should be the change at A0 (#5)
+		assert_eq!(
+			authorities.next_change(&"best_a", &is_descendent_of).unwrap(),
+			Some(("hash_a0", 5)),
+		);
+
+		// the earliest change at block `best_b` should be the change at B (#4)
+		assert_eq!(
+			authorities.next_change(&"best_b", &is_descendent_of).unwrap(),
+			Some(("hash_b", 4)),
+		);
+
+		// we apply the change at A0 which should prune it and the fork at B
+		authorities
+			.apply_standard_changes("hash_a0", 5, &is_descendent_of, false, None)
+			.unwrap();
+
+		// the next change is now at A1 (#10)
+		assert_eq!(
+			authorities.next_change(&"best_a", &is_descendent_of).unwrap(),
+			Some(("hash_a1", 10)),
+		);
+
+		// there's no longer any pending change at `best_b` fork
+		assert_eq!(authorities.next_change(&"best_b", &is_descendent_of).unwrap(), None);
+
+		// we a forced change at A10 (#8)
+		let change_a10 = PendingChange {
+			next_authorities: new_set.clone(),
+			delay: 0,
+			canon_height: 8,
+			canon_hash: "hash_a10",
+			delay_kind: DelayKind::Best { median_last_finalized: 0 },
+		};
+
+		authorities
+			.add_pending_change(change_a10, &static_is_descendent_of(false))
+			.unwrap();
+
+		// it should take precedence over the change at A1 (#10)
+		assert_eq!(
+			authorities.next_change(&"best_a", &is_descendent_of).unwrap(),
+			Some(("hash_a10", 8)),
+		);
+	}
+
+	#[test]
+	fn maintains_authority_list_invariants() {
+		// empty authority lists are invalid
+		assert_eq!(AuthoritySet::<(), ()>::genesis(vec![]), None);
+		assert_eq!(
+			AuthoritySet::<(), ()>::new(
+				vec![],
+				0,
+				ForkTree::new(),
+				Vec::new(),
+				AuthoritySetChanges::empty(),
+			),
+			None,
+		);
+
+		let invalid_authorities_weight = vec![
+			(AuthorityId::from_slice(&[1; 32]).unwrap(), 5),
+			(AuthorityId::from_slice(&[2; 32]).unwrap(), 0),
+		];
+
+		// authority weight of zero is invalid
+		assert_eq!(AuthoritySet::<(), ()>::genesis(invalid_authorities_weight.clone()), None);
+		assert_eq!(
+			AuthoritySet::<(), ()>::new(
+				invalid_authorities_weight.clone(),
+				0,
+				ForkTree::new(),
+				Vec::new(),
+				AuthoritySetChanges::empty(),
+			),
+			None,
+		);
+
+		let mut authority_set =
+			AuthoritySet::<(), u64>::genesis(vec![(AuthorityId::unchecked_from([1; 32]), 5)])
+				.unwrap();
+
+		let invalid_change_empty_authorities = PendingChange {
+			next_authorities: vec![],
+			delay: 10,
+			canon_height: 5,
+			canon_hash: (),
+			delay_kind: DelayKind::Finalized,
+		};
+
+		// pending change contains an empty authority set
+		assert!(matches!(
+			authority_set.add_pending_change(
+				invalid_change_empty_authorities.clone(),
+				&static_is_descendent_of(false)
+			),
+			Err(Error::InvalidAuthoritySet)
+		));
+
+		let invalid_change_authorities_weight = PendingChange {
+			next_authorities: invalid_authorities_weight,
+			delay: 10,
+			canon_height: 5,
+			canon_hash: (),
+			delay_kind: DelayKind::Best { median_last_finalized: 0 },
+		};
+
+		// pending change contains an an authority set
+		// where one authority has weight of 0
+		assert!(matches!(
+			authority_set.add_pending_change(
+				invalid_change_authorities_weight,
+				&static_is_descendent_of(false)
+			),
+			Err(Error::InvalidAuthoritySet)
+		));
+	}
+
+	#[test]
+	fn cleans_up_stale_forced_changes_when_applying_standard_change() {
+		let current_authorities = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 1)];
+
+		let mut authorities = AuthoritySet {
+			current_authorities: current_authorities.clone(),
+			set_id: 0,
+			pending_standard_changes: ForkTree::new(),
+			pending_forced_changes: Vec::new(),
+			authority_set_changes: AuthoritySetChanges::empty(),
+		};
+
+		let new_set = current_authorities.clone();
+
+		// Create the following pending changes tree:
+		//
+		//               [#C3]
+		//              /
+		//             /- (#C2)
+		//            /
+		// (#A) - (#B) - [#C1]
+		//            \
+		//             (#C0) - [#D]
+		//
+		// () - Standard change
+		// [] - Forced change
+
+		let is_descendent_of = {
+			let hashes = vec!["B", "C0", "C1", "C2", "C3", "D"];
+			is_descendent_of(move |base, hash| match (*base, *hash) {
+				("B", "B") => false, // required to have the simpler case below
+				("A", b) | ("B", b) => hashes.iter().any(|h| *h == b),
+				("C0", "D") => true,
+				_ => false,
+			})
+		};
+
+		let mut add_pending_change = |canon_height, canon_hash, forced| {
+			let change = PendingChange {
+				next_authorities: new_set.clone(),
+				delay: 0,
+				canon_height,
+				canon_hash,
+				delay_kind: if forced {
+					DelayKind::Best { median_last_finalized: 0 }
+				} else {
+					DelayKind::Finalized
+				},
+			};
+
+			authorities.add_pending_change(change, &is_descendent_of).unwrap();
+		};
+
+		add_pending_change(5, "A", false);
+		add_pending_change(10, "B", false);
+		add_pending_change(15, "C0", false);
+		add_pending_change(15, "C1", true);
+		add_pending_change(15, "C2", false);
+		add_pending_change(15, "C3", true);
+		add_pending_change(20, "D", true);
+
+		// applying the standard change at A should not prune anything
+		// other then the change that was applied
+		authorities
+			.apply_standard_changes("A", 5, &is_descendent_of, false, None)
+			.unwrap();
+
+		assert_eq!(authorities.pending_changes().count(), 6);
+
+		// same for B
+		authorities
+			.apply_standard_changes("B", 10, &is_descendent_of, false, None)
+			.unwrap();
+
+		assert_eq!(authorities.pending_changes().count(), 5);
+
+		let authorities2 = authorities.clone();
+
+		// finalizing C2 should clear all forced changes
+		authorities
+			.apply_standard_changes("C2", 15, &is_descendent_of, false, None)
+			.unwrap();
+
+		assert_eq!(authorities.pending_forced_changes.len(), 0);
+
+		// finalizing C0 should clear all forced changes but D
+		let mut authorities = authorities2;
+		authorities
+			.apply_standard_changes("C0", 15, &is_descendent_of, false, None)
+			.unwrap();
+
+		assert_eq!(authorities.pending_forced_changes.len(), 1);
+		assert_eq!(authorities.pending_forced_changes.first().unwrap().canon_hash, "D");
+	}
+
+	#[test]
+	fn authority_set_changes_insert() {
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(0, 41);
+		authority_set_changes.append(1, 81);
+		authority_set_changes.append(4, 121);
+
+		authority_set_changes.insert(101);
+		assert_eq!(authority_set_changes.get_set_id(100), AuthoritySetChangeId::Set(2, 101));
+		assert_eq!(authority_set_changes.get_set_id(101), AuthoritySetChangeId::Set(2, 101));
+	}
+
+	#[test]
+	fn authority_set_changes_for_complete_data() {
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(0, 41);
+		authority_set_changes.append(1, 81);
+		authority_set_changes.append(2, 121);
+
+		assert_eq!(authority_set_changes.get_set_id(20), AuthoritySetChangeId::Set(0, 41));
+		assert_eq!(authority_set_changes.get_set_id(40), AuthoritySetChangeId::Set(0, 41));
+		assert_eq!(authority_set_changes.get_set_id(41), AuthoritySetChangeId::Set(0, 41));
+		assert_eq!(authority_set_changes.get_set_id(42), AuthoritySetChangeId::Set(1, 81));
+		assert_eq!(authority_set_changes.get_set_id(141), AuthoritySetChangeId::Latest);
+	}
+
+	#[test]
+	fn authority_set_changes_for_incomplete_data() {
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(2, 41);
+		authority_set_changes.append(3, 81);
+		authority_set_changes.append(4, 121);
+
+		assert_eq!(authority_set_changes.get_set_id(20), AuthoritySetChangeId::Unknown);
+		assert_eq!(authority_set_changes.get_set_id(40), AuthoritySetChangeId::Unknown);
+		assert_eq!(authority_set_changes.get_set_id(41), AuthoritySetChangeId::Unknown);
+		assert_eq!(authority_set_changes.get_set_id(42), AuthoritySetChangeId::Set(3, 81));
+		assert_eq!(authority_set_changes.get_set_id(141), AuthoritySetChangeId::Latest);
+	}
+
+	#[test]
+	fn iter_from_works() {
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(1, 41);
+		authority_set_changes.append(2, 81);
+
+		// we are missing the data for the first set, therefore we should return `None`
+		assert_eq!(None, authority_set_changes.iter_from(40).map(|it| it.collect::<Vec<_>>()));
+
+		// after adding the data for the first set the same query should work
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(0, 21);
+		authority_set_changes.append(1, 41);
+		authority_set_changes.append(2, 81);
+		authority_set_changes.append(3, 121);
+
+		assert_eq!(
+			Some(vec![(1, 41), (2, 81), (3, 121)]),
+			authority_set_changes.iter_from(40).map(|it| it.cloned().collect::<Vec<_>>()),
+		);
+
+		assert_eq!(
+			Some(vec![(2, 81), (3, 121)]),
+			authority_set_changes.iter_from(41).map(|it| it.cloned().collect::<Vec<_>>()),
+		);
+
+		assert_eq!(0, authority_set_changes.iter_from(121).unwrap().count());
+
+		assert_eq!(0, authority_set_changes.iter_from(200).unwrap().count());
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/aux_schema.rs b/substrate/client/consensus/grandpa/src/aux_schema.rs
new file mode 100644
index 0000000000000000000000000000000000000000..97a8bc660317ac36d551d6e0fb50f73a92fffe74
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/aux_schema.rs
@@ -0,0 +1,789 @@
+// 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/>.
+
+//! Schema for stuff in the aux-db.
+
+use std::fmt::Debug;
+
+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;
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
+use sp_consensus_grandpa::{AuthorityList, RoundNumber, SetId};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use crate::{
+	authorities::{
+		AuthoritySet, AuthoritySetChanges, DelayKind, PendingChange, SharedAuthoritySet,
+	},
+	environment::{
+		CompletedRound, CompletedRounds, CurrentRounds, HasVoted, SharedVoterSetState,
+		VoterSetState,
+	},
+	GrandpaJustification, NewAuthoritySet, LOG_TARGET,
+};
+
+const VERSION_KEY: &[u8] = b"grandpa_schema_version";
+const SET_STATE_KEY: &[u8] = b"grandpa_completed_round";
+const CONCLUDED_ROUNDS: &[u8] = b"grandpa_concluded_rounds";
+const AUTHORITY_SET_KEY: &[u8] = b"grandpa_voters";
+const BEST_JUSTIFICATION: &[u8] = b"grandpa_best_justification";
+
+const CURRENT_VERSION: u32 = 3;
+
+/// The voter set state.
+#[derive(Debug, Clone, Encode, Decode)]
+#[cfg_attr(test, derive(PartialEq))]
+pub enum V1VoterSetState<H, N> {
+	/// The voter set state, currently paused.
+	Paused(RoundNumber, RoundState<H, N>),
+	/// The voter set state, currently live.
+	Live(RoundNumber, RoundState<H, N>),
+}
+
+type V0VoterSetState<H, N> = (RoundNumber, RoundState<H, N>);
+
+#[derive(Debug, Clone, Encode, Decode, PartialEq)]
+struct V0PendingChange<H, N> {
+	next_authorities: AuthorityList,
+	delay: N,
+	canon_height: N,
+	canon_hash: H,
+}
+
+#[derive(Debug, Clone, Encode, Decode, PartialEq)]
+struct V0AuthoritySet<H, N> {
+	current_authorities: AuthorityList,
+	set_id: SetId,
+	pending_changes: Vec<V0PendingChange<H, N>>,
+}
+
+impl<H, N> Into<AuthoritySet<H, N>> for V0AuthoritySet<H, N>
+where
+	H: Clone + Debug + PartialEq,
+	N: Clone + Debug + Ord,
+{
+	fn into(self) -> AuthoritySet<H, N> {
+		let mut pending_standard_changes = ForkTree::new();
+
+		for old_change in self.pending_changes {
+			let new_change = PendingChange {
+				next_authorities: old_change.next_authorities,
+				delay: old_change.delay,
+				canon_height: old_change.canon_height,
+				canon_hash: old_change.canon_hash,
+				delay_kind: DelayKind::Finalized,
+			};
+
+			if let Err(err) = pending_standard_changes.import::<_, ClientError>(
+				new_change.canon_hash.clone(),
+				new_change.canon_height.clone(),
+				new_change,
+				// previously we only supported at most one pending change per fork
+				&|_, _| Ok(false),
+			) {
+				warn!(target: LOG_TARGET, "Error migrating pending authority set change: {}", err);
+				warn!(target: LOG_TARGET, "Node is in a potentially inconsistent state.");
+			}
+		}
+
+		let authority_set = AuthoritySet::new(
+			self.current_authorities,
+			self.set_id,
+			pending_standard_changes,
+			Vec::new(),
+			AuthoritySetChanges::empty(),
+		);
+
+		authority_set.expect("current_authorities is non-empty and weights are non-zero; qed.")
+	}
+}
+
+impl<H, N> Into<AuthoritySet<H, N>> for V2AuthoritySet<H, N>
+where
+	H: Clone + Debug + PartialEq,
+	N: Clone + Debug + Ord,
+{
+	fn into(self) -> AuthoritySet<H, N> {
+		AuthoritySet::new(
+			self.current_authorities,
+			self.set_id,
+			self.pending_standard_changes,
+			self.pending_forced_changes,
+			AuthoritySetChanges::empty(),
+		)
+		.expect("current_authorities is non-empty and weights are non-zero; qed.")
+	}
+}
+
+#[derive(Debug, Clone, Encode, Decode, PartialEq)]
+struct V2AuthoritySet<H, N> {
+	current_authorities: AuthorityList,
+	set_id: u64,
+	pending_standard_changes: ForkTree<H, N, PendingChange<H, N>>,
+	pending_forced_changes: Vec<PendingChange<H, N>>,
+}
+
+pub(crate) fn load_decode<B: AuxStore, T: Decode>(
+	backend: &B,
+	key: &[u8],
+) -> ClientResult<Option<T>> {
+	match backend.get_aux(key)? {
+		None => Ok(None),
+		Some(t) => T::decode(&mut &t[..])
+			.map_err(|e| ClientError::Backend(format!("GRANDPA DB is corrupted: {}", e)))
+			.map(Some),
+	}
+}
+
+/// Persistent data kept between runs.
+pub(crate) struct PersistentData<Block: BlockT> {
+	pub(crate) authority_set: SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+	pub(crate) set_state: SharedVoterSetState<Block>,
+}
+
+fn migrate_from_version0<Block: BlockT, B, G>(
+	backend: &B,
+	genesis_round: &G,
+) -> ClientResult<Option<(AuthoritySet<Block::Hash, NumberFor<Block>>, VoterSetState<Block>)>>
+where
+	B: AuxStore,
+	G: Fn() -> RoundState<Block::Hash, NumberFor<Block>>,
+{
+	CURRENT_VERSION.using_encoded(|s| backend.insert_aux(&[(VERSION_KEY, s)], &[]))?;
+
+	if let Some(old_set) =
+		load_decode::<_, V0AuthoritySet<Block::Hash, NumberFor<Block>>>(backend, AUTHORITY_SET_KEY)?
+	{
+		let new_set: AuthoritySet<Block::Hash, NumberFor<Block>> = old_set.into();
+		backend.insert_aux(&[(AUTHORITY_SET_KEY, new_set.encode().as_slice())], &[])?;
+
+		let (last_round_number, last_round_state) = match load_decode::<
+			_,
+			V0VoterSetState<Block::Hash, NumberFor<Block>>,
+		>(backend, SET_STATE_KEY)?
+		{
+			Some((number, state)) => (number, state),
+			None => (0, genesis_round()),
+		};
+
+		let set_id = new_set.set_id;
+
+		let base = last_round_state.prevote_ghost.expect(
+			"state is for completed round; completed rounds must have a prevote ghost; qed.",
+		);
+
+		let mut current_rounds = CurrentRounds::<Block>::new();
+		current_rounds.insert(last_round_number + 1, HasVoted::No);
+
+		let set_state = VoterSetState::Live {
+			completed_rounds: CompletedRounds::new(
+				CompletedRound {
+					number: last_round_number,
+					state: last_round_state,
+					votes: Vec::new(),
+					base,
+				},
+				set_id,
+				&new_set,
+			),
+			current_rounds,
+		};
+
+		backend.insert_aux(&[(SET_STATE_KEY, set_state.encode().as_slice())], &[])?;
+
+		return Ok(Some((new_set, set_state)))
+	}
+
+	Ok(None)
+}
+
+fn migrate_from_version1<Block: BlockT, B, G>(
+	backend: &B,
+	genesis_round: &G,
+) -> ClientResult<Option<(AuthoritySet<Block::Hash, NumberFor<Block>>, VoterSetState<Block>)>>
+where
+	B: AuxStore,
+	G: Fn() -> RoundState<Block::Hash, NumberFor<Block>>,
+{
+	CURRENT_VERSION.using_encoded(|s| backend.insert_aux(&[(VERSION_KEY, s)], &[]))?;
+
+	if let Some(set) =
+		load_decode::<_, AuthoritySet<Block::Hash, NumberFor<Block>>>(backend, AUTHORITY_SET_KEY)?
+	{
+		let set_id = set.set_id;
+
+		let completed_rounds = |number, state, base| {
+			CompletedRounds::new(
+				CompletedRound { number, state, votes: Vec::new(), base },
+				set_id,
+				&set,
+			)
+		};
+
+		let set_state = match load_decode::<_, V1VoterSetState<Block::Hash, NumberFor<Block>>>(
+			backend,
+			SET_STATE_KEY,
+		)? {
+			Some(V1VoterSetState::Paused(last_round_number, set_state)) => {
+				let base = set_state.prevote_ghost
+					.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");
+
+				VoterSetState::Paused {
+					completed_rounds: completed_rounds(last_round_number, set_state, base),
+				}
+			},
+			Some(V1VoterSetState::Live(last_round_number, set_state)) => {
+				let base = set_state.prevote_ghost
+					.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");
+
+				let mut current_rounds = CurrentRounds::<Block>::new();
+				current_rounds.insert(last_round_number + 1, HasVoted::No);
+
+				VoterSetState::Live {
+					completed_rounds: completed_rounds(last_round_number, set_state, base),
+					current_rounds,
+				}
+			},
+			None => {
+				let set_state = genesis_round();
+				let base = set_state.prevote_ghost
+					.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");
+
+				VoterSetState::live(set_id, &set, base)
+			},
+		};
+
+		backend.insert_aux(&[(SET_STATE_KEY, set_state.encode().as_slice())], &[])?;
+
+		return Ok(Some((set, set_state)))
+	}
+
+	Ok(None)
+}
+
+fn migrate_from_version2<Block: BlockT, B, G>(
+	backend: &B,
+	genesis_round: &G,
+) -> ClientResult<Option<(AuthoritySet<Block::Hash, NumberFor<Block>>, VoterSetState<Block>)>>
+where
+	B: AuxStore,
+	G: Fn() -> RoundState<Block::Hash, NumberFor<Block>>,
+{
+	CURRENT_VERSION.using_encoded(|s| backend.insert_aux(&[(VERSION_KEY, s)], &[]))?;
+
+	if let Some(old_set) =
+		load_decode::<_, V2AuthoritySet<Block::Hash, NumberFor<Block>>>(backend, AUTHORITY_SET_KEY)?
+	{
+		let new_set: AuthoritySet<Block::Hash, NumberFor<Block>> = old_set.into();
+		backend.insert_aux(&[(AUTHORITY_SET_KEY, new_set.encode().as_slice())], &[])?;
+
+		let set_state = match load_decode::<_, VoterSetState<Block>>(backend, SET_STATE_KEY)? {
+			Some(state) => state,
+			None => {
+				let state = genesis_round();
+				let base = state.prevote_ghost
+					.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");
+
+				VoterSetState::live(new_set.set_id, &new_set, base)
+			},
+		};
+
+		return Ok(Some((new_set, set_state)))
+	}
+
+	Ok(None)
+}
+
+/// Load or initialize persistent data from backend.
+pub(crate) fn load_persistent<Block: BlockT, B, G>(
+	backend: &B,
+	genesis_hash: Block::Hash,
+	genesis_number: NumberFor<Block>,
+	genesis_authorities: G,
+) -> ClientResult<PersistentData<Block>>
+where
+	B: AuxStore,
+	G: FnOnce() -> ClientResult<AuthorityList>,
+{
+	let version: Option<u32> = load_decode(backend, VERSION_KEY)?;
+
+	let make_genesis_round = move || RoundState::genesis((genesis_hash, genesis_number));
+
+	match version {
+		None => {
+			if let Some((new_set, set_state)) =
+				migrate_from_version0::<Block, _, _>(backend, &make_genesis_round)?
+			{
+				return Ok(PersistentData {
+					authority_set: new_set.into(),
+					set_state: set_state.into(),
+				})
+			}
+		},
+		Some(1) => {
+			if let Some((new_set, set_state)) =
+				migrate_from_version1::<Block, _, _>(backend, &make_genesis_round)?
+			{
+				return Ok(PersistentData {
+					authority_set: new_set.into(),
+					set_state: set_state.into(),
+				})
+			}
+		},
+		Some(2) => {
+			if let Some((new_set, set_state)) =
+				migrate_from_version2::<Block, _, _>(backend, &make_genesis_round)?
+			{
+				return Ok(PersistentData {
+					authority_set: new_set.into(),
+					set_state: set_state.into(),
+				})
+			}
+		},
+		Some(3) => {
+			if let Some(set) = load_decode::<_, AuthoritySet<Block::Hash, NumberFor<Block>>>(
+				backend,
+				AUTHORITY_SET_KEY,
+			)? {
+				let set_state =
+					match load_decode::<_, VoterSetState<Block>>(backend, SET_STATE_KEY)? {
+						Some(state) => state,
+						None => {
+							let state = make_genesis_round();
+							let base = state.prevote_ghost
+							.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");
+
+							VoterSetState::live(set.set_id, &set, base)
+						},
+					};
+
+				return Ok(PersistentData { authority_set: set.into(), set_state: set_state.into() })
+			}
+		},
+		Some(other) =>
+			return Err(ClientError::Backend(format!("Unsupported GRANDPA DB version: {:?}", other))),
+	}
+
+	// genesis.
+	info!(
+		target: LOG_TARGET,
+		"👴 Loading GRANDPA authority set \
+		from genesis on what appears to be first startup."
+	);
+
+	let genesis_authorities = genesis_authorities()?;
+	let genesis_set = AuthoritySet::genesis(genesis_authorities)
+		.expect("genesis authorities is non-empty; all weights are non-zero; qed.");
+	let state = make_genesis_round();
+	let base = state
+		.prevote_ghost
+		.expect("state is for completed round; completed rounds must have a prevote ghost; qed.");
+
+	let genesis_state = VoterSetState::live(0, &genesis_set, base);
+
+	backend.insert_aux(
+		&[
+			(AUTHORITY_SET_KEY, genesis_set.encode().as_slice()),
+			(SET_STATE_KEY, genesis_state.encode().as_slice()),
+		],
+		&[],
+	)?;
+
+	Ok(PersistentData { authority_set: genesis_set.into(), set_state: genesis_state.into() })
+}
+
+/// Update the authority set on disk after a change.
+///
+/// If there has just been a handoff, pass a `new_set` parameter that describes the
+/// handoff. `set` in all cases should reflect the current authority set, with all
+/// changes and handoffs applied.
+pub(crate) fn update_authority_set<Block: BlockT, F, R>(
+	set: &AuthoritySet<Block::Hash, NumberFor<Block>>,
+	new_set: Option<&NewAuthoritySet<Block::Hash, NumberFor<Block>>>,
+	write_aux: F,
+) -> R
+where
+	F: FnOnce(&[(&'static [u8], &[u8])]) -> R,
+{
+	// write new authority set state to disk.
+	let encoded_set = set.encode();
+
+	if let Some(new_set) = new_set {
+		// we also overwrite the "last completed round" entry with a blank slate
+		// because from the perspective of the finality gadget, the chain has
+		// reset.
+		let set_state = VoterSetState::<Block>::live(
+			new_set.set_id,
+			set,
+			(new_set.canon_hash, new_set.canon_number),
+		);
+		let encoded = set_state.encode();
+
+		write_aux(&[(AUTHORITY_SET_KEY, &encoded_set[..]), (SET_STATE_KEY, &encoded[..])])
+	} else {
+		write_aux(&[(AUTHORITY_SET_KEY, &encoded_set[..])])
+	}
+}
+
+/// Update the justification for the latest finalized block on-disk.
+///
+/// We always keep around the justification for the best finalized block and overwrite it
+/// as we finalize new blocks, this makes sure that we don't store useless justifications
+/// but can always prove finality of the latest block.
+pub(crate) fn update_best_justification<Block: BlockT, F, R>(
+	justification: &GrandpaJustification<Block>,
+	write_aux: F,
+) -> R
+where
+	F: FnOnce(&[(&'static [u8], &[u8])]) -> R,
+{
+	let encoded_justification = justification.encode();
+	write_aux(&[(BEST_JUSTIFICATION, &encoded_justification[..])])
+}
+
+/// Fetch the justification for the latest block finalized by GRANDPA, if any.
+pub fn best_justification<B, Block>(
+	backend: &B,
+) -> ClientResult<Option<GrandpaJustification<Block>>>
+where
+	B: AuxStore,
+	Block: BlockT,
+{
+	load_decode::<_, GrandpaJustification<Block>>(backend, BEST_JUSTIFICATION)
+}
+
+/// Write voter set state.
+pub(crate) fn write_voter_set_state<Block: BlockT, B: AuxStore>(
+	backend: &B,
+	state: &VoterSetState<Block>,
+) -> ClientResult<()> {
+	backend.insert_aux(&[(SET_STATE_KEY, state.encode().as_slice())], &[])
+}
+
+/// Write concluded round.
+pub(crate) fn write_concluded_round<Block: BlockT, B: AuxStore>(
+	backend: &B,
+	round_data: &CompletedRound<Block>,
+) -> ClientResult<()> {
+	let mut key = CONCLUDED_ROUNDS.to_vec();
+	let round_number = round_data.number;
+	round_number.using_encoded(|n| key.extend(n));
+
+	backend.insert_aux(&[(&key[..], round_data.encode().as_slice())], &[])
+}
+
+#[cfg(test)]
+pub(crate) fn load_authorities<B: AuxStore, H: Decode, N: Decode + Clone + Ord>(
+	backend: &B,
+) -> Option<AuthoritySet<H, N>> {
+	load_decode::<_, AuthoritySet<H, N>>(backend, AUTHORITY_SET_KEY).expect("backend error")
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use sp_consensus_grandpa::AuthorityId;
+	use sp_core::{crypto::UncheckedFrom, H256};
+	use substrate_test_runtime_client::{self, runtime::Block};
+
+	fn dummy_id() -> AuthorityId {
+		AuthorityId::unchecked_from([1; 32])
+	}
+
+	#[test]
+	fn load_decode_from_v0_migrates_data_format() {
+		let client = substrate_test_runtime_client::new();
+
+		let authorities = vec![(dummy_id(), 100)];
+		let set_id = 3;
+		let round_number: RoundNumber = 42;
+		let round_state = RoundState::<H256, u64> {
+			prevote_ghost: Some((H256::random(), 32)),
+			finalized: None,
+			estimate: None,
+			completable: false,
+		};
+
+		{
+			let authority_set = V0AuthoritySet::<H256, u64> {
+				current_authorities: authorities.clone(),
+				pending_changes: Vec::new(),
+				set_id,
+			};
+
+			let voter_set_state = (round_number, round_state.clone());
+
+			client
+				.insert_aux(
+					&[
+						(AUTHORITY_SET_KEY, authority_set.encode().as_slice()),
+						(SET_STATE_KEY, voter_set_state.encode().as_slice()),
+					],
+					&[],
+				)
+				.unwrap();
+		}
+
+		assert_eq!(load_decode::<_, u32>(&client, VERSION_KEY).unwrap(), None);
+
+		// should perform the migration
+		load_persistent::<substrate_test_runtime_client::runtime::Block, _, _>(
+			&client,
+			H256::random(),
+			0,
+			|| unreachable!(),
+		)
+		.unwrap();
+
+		assert_eq!(load_decode::<_, u32>(&client, VERSION_KEY).unwrap(), Some(3));
+
+		let PersistentData { authority_set, set_state, .. } =
+			load_persistent::<substrate_test_runtime_client::runtime::Block, _, _>(
+				&client,
+				H256::random(),
+				0,
+				|| unreachable!(),
+			)
+			.unwrap();
+
+		assert_eq!(
+			*authority_set.inner(),
+			AuthoritySet::new(
+				authorities.clone(),
+				set_id,
+				ForkTree::new(),
+				Vec::new(),
+				AuthoritySetChanges::empty(),
+			)
+			.unwrap(),
+		);
+
+		let mut current_rounds = CurrentRounds::<Block>::new();
+		current_rounds.insert(round_number + 1, HasVoted::No);
+
+		assert_eq!(
+			&*set_state.read(),
+			&VoterSetState::Live {
+				completed_rounds: CompletedRounds::new(
+					CompletedRound {
+						number: round_number,
+						state: round_state.clone(),
+						base: round_state.prevote_ghost.unwrap(),
+						votes: vec![],
+					},
+					set_id,
+					&*authority_set.inner(),
+				),
+				current_rounds,
+			},
+		);
+	}
+
+	#[test]
+	fn load_decode_from_v1_migrates_data_format() {
+		let client = substrate_test_runtime_client::new();
+
+		let authorities = vec![(dummy_id(), 100)];
+		let set_id = 3;
+		let round_number: RoundNumber = 42;
+		let round_state = RoundState::<H256, u64> {
+			prevote_ghost: Some((H256::random(), 32)),
+			finalized: None,
+			estimate: None,
+			completable: false,
+		};
+
+		{
+			let authority_set = AuthoritySet::<H256, u64>::new(
+				authorities.clone(),
+				set_id,
+				ForkTree::new(),
+				Vec::new(),
+				AuthoritySetChanges::empty(),
+			)
+			.unwrap();
+
+			let voter_set_state = V1VoterSetState::Live(round_number, round_state.clone());
+
+			client
+				.insert_aux(
+					&[
+						(AUTHORITY_SET_KEY, authority_set.encode().as_slice()),
+						(SET_STATE_KEY, voter_set_state.encode().as_slice()),
+						(VERSION_KEY, 1u32.encode().as_slice()),
+					],
+					&[],
+				)
+				.unwrap();
+		}
+
+		assert_eq!(load_decode::<_, u32>(&client, VERSION_KEY).unwrap(), Some(1));
+
+		// should perform the migration
+		load_persistent::<substrate_test_runtime_client::runtime::Block, _, _>(
+			&client,
+			H256::random(),
+			0,
+			|| unreachable!(),
+		)
+		.unwrap();
+
+		assert_eq!(load_decode::<_, u32>(&client, VERSION_KEY).unwrap(), Some(3));
+
+		let PersistentData { authority_set, set_state, .. } =
+			load_persistent::<substrate_test_runtime_client::runtime::Block, _, _>(
+				&client,
+				H256::random(),
+				0,
+				|| unreachable!(),
+			)
+			.unwrap();
+
+		assert_eq!(
+			*authority_set.inner(),
+			AuthoritySet::new(
+				authorities.clone(),
+				set_id,
+				ForkTree::new(),
+				Vec::new(),
+				AuthoritySetChanges::empty(),
+			)
+			.unwrap(),
+		);
+
+		let mut current_rounds = CurrentRounds::<Block>::new();
+		current_rounds.insert(round_number + 1, HasVoted::No);
+
+		assert_eq!(
+			&*set_state.read(),
+			&VoterSetState::Live {
+				completed_rounds: CompletedRounds::new(
+					CompletedRound {
+						number: round_number,
+						state: round_state.clone(),
+						base: round_state.prevote_ghost.unwrap(),
+						votes: vec![],
+					},
+					set_id,
+					&*authority_set.inner(),
+				),
+				current_rounds,
+			},
+		);
+	}
+
+	#[test]
+	fn load_decode_from_v2_migrates_data_format() {
+		let client = substrate_test_runtime_client::new();
+
+		let authorities = vec![(dummy_id(), 100)];
+		let set_id = 3;
+
+		{
+			let authority_set = V2AuthoritySet::<H256, u64> {
+				current_authorities: authorities.clone(),
+				set_id,
+				pending_standard_changes: ForkTree::new(),
+				pending_forced_changes: Vec::new(),
+			};
+
+			let genesis_state = (H256::random(), 32);
+			let voter_set_state: VoterSetState<substrate_test_runtime_client::runtime::Block> =
+				VoterSetState::live(
+					set_id,
+					&authority_set.clone().into(), // Note the conversion!
+					genesis_state,
+				);
+
+			client
+				.insert_aux(
+					&[
+						(AUTHORITY_SET_KEY, authority_set.encode().as_slice()),
+						(SET_STATE_KEY, voter_set_state.encode().as_slice()),
+						(VERSION_KEY, 2u32.encode().as_slice()),
+					],
+					&[],
+				)
+				.unwrap();
+		}
+
+		assert_eq!(load_decode::<_, u32>(&client, VERSION_KEY).unwrap(), Some(2));
+
+		// should perform the migration
+		load_persistent::<substrate_test_runtime_client::runtime::Block, _, _>(
+			&client,
+			H256::random(),
+			0,
+			|| unreachable!(),
+		)
+		.unwrap();
+
+		assert_eq!(load_decode::<_, u32>(&client, VERSION_KEY).unwrap(), Some(3));
+
+		let PersistentData { authority_set, .. } = load_persistent::<
+			substrate_test_runtime_client::runtime::Block,
+			_,
+			_,
+		>(&client, H256::random(), 0, || unreachable!())
+		.unwrap();
+
+		assert_eq!(
+			*authority_set.inner(),
+			AuthoritySet::new(
+				authorities.clone(),
+				set_id,
+				ForkTree::new(),
+				Vec::new(),
+				AuthoritySetChanges::empty(),
+			)
+			.unwrap(),
+		);
+	}
+
+	#[test]
+	fn write_read_concluded_rounds() {
+		let client = substrate_test_runtime_client::new();
+		let hash = H256::random();
+		let round_state = RoundState::genesis((hash, 0));
+
+		let completed_round = CompletedRound::<substrate_test_runtime_client::runtime::Block> {
+			number: 42,
+			state: round_state.clone(),
+			base: round_state.prevote_ghost.unwrap(),
+			votes: vec![],
+		};
+
+		assert!(write_concluded_round(&client, &completed_round).is_ok());
+
+		let round_number = completed_round.number;
+		let mut key = CONCLUDED_ROUNDS.to_vec();
+		round_number.using_encoded(|n| key.extend(n));
+
+		assert_eq!(
+			load_decode::<_, CompletedRound::<substrate_test_runtime_client::runtime::Block>>(
+				&client, &key
+			)
+			.unwrap(),
+			Some(completed_round),
+		);
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/communication/gossip.rs b/substrate/client/consensus/grandpa/src/communication/gossip.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3a78b157d5b1bcb00b7ff83afb407a0015ed529f
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/communication/gossip.rs
@@ -0,0 +1,2650 @@
+// 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/>.
+
+//! Gossip and politeness for polite-grandpa.
+//!
+//! This module implements the following message types:
+//! #### Neighbor Packet
+//!
+//! The neighbor packet is sent to only our neighbors. It contains this information
+//!
+//!   - Current Round
+//!   - Current voter set ID
+//!   - Last finalized hash from commit messages.
+//!
+//! If a peer is at a given voter set, it is impolite to send messages from
+//! an earlier voter set. It is extremely impolite to send messages
+//! from a future voter set. "future-set" messages can be dropped and ignored.
+//!
+//! If a peer is at round r, is impolite to send messages about r-2 or earlier and extremely
+//! impolite to send messages about r+1 or later. "future-round" messages can
+//!  be dropped and ignored.
+//!
+//! It is impolite to send a neighbor packet which moves backwards or does not progress
+//! protocol state.
+//!
+//! This is beneficial if it conveys some progress in the protocol state of the peer.
+//!
+//! #### Prevote / Precommit
+//!
+//! These are votes within a round. Noting that we receive these messages
+//! from our peers who are not necessarily voters, we have to account the benefit
+//! based on what they might have seen.
+//!
+//! #### Propose
+//!
+//! This is a broadcast by a known voter of the last-round estimate.
+//!
+//! #### Commit
+//!
+//! These are used to announce past agreement of finality.
+//!
+//! It is impolite to send commits which are earlier than the last commit
+//! sent. It is especially impolite to send commits which are invalid, or from
+//! a different Set ID than the receiving peer has indicated.
+//!
+//! Sending a commit is polite when it may finalize something that the receiving peer
+//! was not aware of.
+//!
+//! #### Catch Up
+//!
+//! These allow a peer to request another peer, which they perceive to be in a
+//! later round, to provide all the votes necessary to complete a given round
+//! `R`.
+//!
+//! It is impolite to send a catch up request for a round `R` to a peer whose
+//! announced view is behind `R`. It is also impolite to send a catch up request
+//! to a peer in a new different Set ID.
+//!
+//! The logic for issuing and tracking pending catch up requests is implemented
+//! in the `GossipValidator`. A catch up request is issued anytime we see a
+//! neighbor packet from a peer at a round `CATCH_UP_THRESHOLD` higher than at
+//! we are.
+//!
+//! ## Expiration
+//!
+//! We keep some amount of recent rounds' messages, but do not accept new ones from rounds
+//! older than our current_round - 1.
+//!
+//! ## Message Validation
+//!
+//! We only send polite messages to peers,
+
+use ahash::{AHashMap, AHashSet};
+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::{PeerId, ReputationChange};
+use sc_network_common::role::ObservedRole;
+use sc_network_gossip::{MessageIntent, ValidatorContext};
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_consensus_grandpa::AuthorityId;
+use sp_runtime::traits::{Block as BlockT, NumberFor, Zero};
+
+use super::{benefit, cost, Round, SetId, NEIGHBOR_REBROADCAST_PERIOD};
+use crate::{environment, CatchUp, CompactCommit, SignedMessage, LOG_TARGET};
+
+use std::{
+	collections::{HashSet, VecDeque},
+	time::{Duration, Instant},
+};
+
+const REBROADCAST_AFTER: Duration = Duration::from_secs(60 * 5);
+const CATCH_UP_REQUEST_TIMEOUT: Duration = Duration::from_secs(45);
+const CATCH_UP_PROCESS_TIMEOUT: Duration = Duration::from_secs(30);
+/// Maximum number of rounds we are behind a peer before issuing a
+/// catch up request.
+const CATCH_UP_THRESHOLD: u64 = 2;
+
+/// The total round duration measured in periods of gossip duration:
+/// 2 gossip durations for prevote timer
+/// 2 gossip durations for precommit timer
+/// 1 gossip duration for precommits to spread
+const ROUND_DURATION: u32 = 5;
+
+/// The period, measured in rounds, since the latest round start, after which we will start
+/// propagating gossip messages to more nodes than just the lucky ones.
+const PROPAGATION_SOME: f32 = 1.5;
+
+/// The period, measured in rounds, since the latest round start, after which we will start
+/// propagating gossip messages to all the nodes we are connected to.
+const PROPAGATION_ALL: f32 = 3.0;
+
+/// Assuming a network of 3000 nodes, using a fanout of 4, after about 6 iterations
+/// of gossip a message has very likely reached all nodes on the network (`log4(3000)`).
+const LUCKY_PEERS: usize = 4;
+
+type Report = (PeerId, ReputationChange);
+
+/// An outcome of examining a message.
+#[derive(Debug, PartialEq, Clone, Copy)]
+enum Consider {
+	/// Accept the message.
+	Accept,
+	/// Message is too early. Reject.
+	RejectPast,
+	/// Message is from the future. Reject.
+	RejectFuture,
+	/// Message cannot be evaluated. Reject.
+	RejectOutOfScope,
+}
+
+/// A view of protocol state.
+#[derive(Debug)]
+struct View<N> {
+	round: Round,                 // the current round we are at.
+	set_id: SetId,                // the current voter set id.
+	last_commit: Option<N>,       // commit-finalized block height, if any.
+	last_update: Option<Instant>, // last time we heard from peer, used for spamming detection.
+}
+
+impl<N> Default for View<N> {
+	fn default() -> Self {
+		View { round: Round(1), set_id: SetId(0), last_commit: None, last_update: None }
+	}
+}
+
+impl<N: Ord> View<N> {
+	/// Consider a round and set ID combination under a current view.
+	fn consider_vote(&self, round: Round, set_id: SetId) -> Consider {
+		// only from current set
+		if set_id < self.set_id {
+			return Consider::RejectPast
+		}
+		if set_id > self.set_id {
+			return Consider::RejectFuture
+		}
+
+		// only r-1 ... r+1
+		if round.0 > self.round.0.saturating_add(1) {
+			return Consider::RejectFuture
+		}
+		if round.0 < self.round.0.saturating_sub(1) {
+			return Consider::RejectPast
+		}
+
+		Consider::Accept
+	}
+
+	/// Consider a set-id global message. Rounds are not taken into account, but are implicitly
+	/// because we gate on finalization of a further block than a previous commit.
+	fn consider_global(&self, set_id: SetId, number: N) -> Consider {
+		// only from current set
+		if set_id < self.set_id {
+			return Consider::RejectPast
+		}
+		if set_id > self.set_id {
+			return Consider::RejectFuture
+		}
+
+		// only commits which claim to prove a higher block number than
+		// the one we're aware of.
+		match self.last_commit {
+			None => Consider::Accept,
+			Some(ref num) =>
+				if num < &number {
+					Consider::Accept
+				} else {
+					Consider::RejectPast
+				},
+		}
+	}
+}
+
+/// A local view of protocol state. Similar to `View` but we additionally track
+/// the round and set id at which the last commit was observed, and the instant
+/// at which the current round started.
+struct LocalView<N> {
+	round: Round,
+	set_id: SetId,
+	last_commit: Option<(N, Round, SetId)>,
+	round_start: Instant,
+}
+
+impl<N> LocalView<N> {
+	/// Creates a new `LocalView` at the given set id and round.
+	fn new(set_id: SetId, round: Round) -> LocalView<N> {
+		LocalView { set_id, round, last_commit: None, round_start: Instant::now() }
+	}
+
+	/// Converts the local view to a `View` discarding round and set id
+	/// information about the last commit.
+	fn as_view(&self) -> View<&N> {
+		View {
+			round: self.round,
+			set_id: self.set_id,
+			last_commit: self.last_commit_height(),
+			last_update: None,
+		}
+	}
+
+	/// Update the set ID. implies a reset to round 1.
+	fn update_set(&mut self, set_id: SetId) {
+		if set_id != self.set_id {
+			self.set_id = set_id;
+			self.round = Round(1);
+			self.round_start = Instant::now();
+		}
+	}
+
+	/// Updates the current round.
+	fn update_round(&mut self, round: Round) {
+		self.round = round;
+		self.round_start = Instant::now();
+	}
+
+	/// Returns the height of the block that the last observed commit finalizes.
+	fn last_commit_height(&self) -> Option<&N> {
+		self.last_commit.as_ref().map(|(number, _, _)| number)
+	}
+}
+
+const KEEP_RECENT_ROUNDS: usize = 3;
+
+/// Tracks gossip topics that we are keeping messages for. We keep topics of:
+///
+/// - the last `KEEP_RECENT_ROUNDS` complete GRANDPA rounds,
+///
+/// - the topic for the current and next round,
+///
+/// - and a global topic for commit and catch-up messages.
+struct KeepTopics<B: BlockT> {
+	current_set: SetId,
+	rounds: VecDeque<(Round, SetId)>,
+	reverse_map: AHashMap<B::Hash, (Option<Round>, SetId)>,
+}
+
+impl<B: BlockT> KeepTopics<B> {
+	fn new() -> Self {
+		KeepTopics {
+			current_set: SetId(0),
+			rounds: VecDeque::with_capacity(KEEP_RECENT_ROUNDS + 2),
+			reverse_map: Default::default(),
+		}
+	}
+
+	fn push(&mut self, round: Round, set_id: SetId) {
+		self.current_set = std::cmp::max(self.current_set, set_id);
+
+		// under normal operation the given round is already tracked (since we
+		// track one round ahead). if we skip rounds (with a catch up) the given
+		// round topic might not be tracked yet.
+		if !self.rounds.contains(&(round, set_id)) {
+			self.rounds.push_back((round, set_id));
+		}
+
+		// we also accept messages for the next round
+		self.rounds.push_back((Round(round.0.saturating_add(1)), set_id));
+
+		// the 2 is for the current and next round.
+		while self.rounds.len() > KEEP_RECENT_ROUNDS + 2 {
+			let _ = self.rounds.pop_front();
+		}
+
+		let mut map = AHashMap::with_capacity(KEEP_RECENT_ROUNDS + 3);
+		map.insert(super::global_topic::<B>(self.current_set.0), (None, self.current_set));
+
+		for &(round, set) in &self.rounds {
+			map.insert(super::round_topic::<B>(round.0, set.0), (Some(round), set));
+		}
+
+		self.reverse_map = map;
+	}
+
+	fn topic_info(&self, topic: &B::Hash) -> Option<(Option<Round>, SetId)> {
+		self.reverse_map.get(topic).cloned()
+	}
+}
+
+// topics to send to a neighbor based on their view.
+fn neighbor_topics<B: BlockT>(view: &View<NumberFor<B>>) -> Vec<B::Hash> {
+	let s = view.set_id;
+	let mut topics =
+		vec![super::global_topic::<B>(s.0), super::round_topic::<B>(view.round.0, s.0)];
+
+	if view.round.0 != 0 {
+		let r = Round(view.round.0 - 1);
+		topics.push(super::round_topic::<B>(r.0, s.0))
+	}
+
+	topics
+}
+
+/// Grandpa gossip message type.
+/// This is the root type that gets encoded and sent on the network.
+#[derive(Debug, Encode, Decode)]
+pub(super) enum GossipMessage<Block: BlockT> {
+	/// Grandpa message with round and set info.
+	Vote(VoteMessage<Block>),
+	/// Grandpa commit message with round and set info.
+	Commit(FullCommitMessage<Block>),
+	/// A neighbor packet. Not repropagated.
+	Neighbor(VersionedNeighborPacket<NumberFor<Block>>),
+	/// Grandpa catch up request message with round and set info. Not repropagated.
+	CatchUpRequest(CatchUpRequestMessage),
+	/// Grandpa catch up message with round and set info. Not repropagated.
+	CatchUp(FullCatchUpMessage<Block>),
+}
+
+impl<Block: BlockT> From<NeighborPacket<NumberFor<Block>>> for GossipMessage<Block> {
+	fn from(neighbor: NeighborPacket<NumberFor<Block>>) -> Self {
+		GossipMessage::Neighbor(VersionedNeighborPacket::V1(neighbor))
+	}
+}
+
+/// Network level vote message with topic information.
+#[derive(Debug, Encode, Decode)]
+pub(super) struct VoteMessage<Block: BlockT> {
+	/// The round this message is from.
+	pub(super) round: Round,
+	/// The voter set ID this message is from.
+	pub(super) set_id: SetId,
+	/// The message itself.
+	pub(super) message: SignedMessage<Block::Header>,
+}
+
+/// Network level commit message with topic information.
+#[derive(Debug, Encode, Decode)]
+pub(super) struct FullCommitMessage<Block: BlockT> {
+	/// The round this message is from.
+	pub(super) round: Round,
+	/// The voter set ID this message is from.
+	pub(super) set_id: SetId,
+	/// The compact commit message.
+	pub(super) message: CompactCommit<Block::Header>,
+}
+
+/// V1 neighbor packet. Neighbor packets are sent from nodes to their peers
+/// and are not repropagated. These contain information about the node's state.
+#[derive(Debug, Encode, Decode, Clone)]
+pub(super) struct NeighborPacket<N> {
+	/// The round the node is currently at.
+	pub(super) round: Round,
+	/// The set ID the node is currently at.
+	pub(super) set_id: SetId,
+	/// The highest finalizing commit observed.
+	pub(super) commit_finalized_height: N,
+}
+
+/// A versioned neighbor packet.
+#[derive(Debug, Encode, Decode)]
+pub(super) enum VersionedNeighborPacket<N> {
+	#[codec(index = 1)]
+	V1(NeighborPacket<N>),
+}
+
+impl<N> VersionedNeighborPacket<N> {
+	fn into_neighbor_packet(self) -> NeighborPacket<N> {
+		match self {
+			VersionedNeighborPacket::V1(p) => p,
+		}
+	}
+}
+
+/// A catch up request for a given round (or any further round) localized by set id.
+#[derive(Clone, Debug, Encode, Decode)]
+pub(super) struct CatchUpRequestMessage {
+	/// The round that we want to catch up to.
+	pub(super) round: Round,
+	/// The voter set ID this message is from.
+	pub(super) set_id: SetId,
+}
+
+/// Network level catch up message with topic information.
+#[derive(Debug, Encode, Decode)]
+pub(super) struct FullCatchUpMessage<Block: BlockT> {
+	/// The voter set ID this message is from.
+	pub(super) set_id: SetId,
+	/// The compact commit message.
+	pub(super) message: CatchUp<Block::Header>,
+}
+
+/// Misbehavior that peers can perform.
+///
+/// `cost` gives a cost that can be used to perform cost/benefit analysis of a
+/// peer.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(super) enum Misbehavior {
+	// invalid neighbor message, considering the last one.
+	InvalidViewChange,
+	// duplicate neighbor message.
+	DuplicateNeighborMessage,
+	// could not decode neighbor message. bytes-length of the packet.
+	UndecodablePacket(i32),
+	// Bad catch up message (invalid signatures).
+	BadCatchUpMessage { signatures_checked: i32 },
+	// Bad commit message
+	BadCommitMessage { signatures_checked: i32, blocks_loaded: i32, equivocations_caught: i32 },
+	// A message received that's from the future relative to our view.
+	// always misbehavior.
+	FutureMessage,
+	// A message received that cannot be evaluated relative to our view.
+	// This happens before we have a view and have sent out neighbor packets.
+	// always misbehavior.
+	OutOfScopeMessage,
+}
+
+impl Misbehavior {
+	pub(super) fn cost(&self) -> ReputationChange {
+		use Misbehavior::*;
+
+		match *self {
+			InvalidViewChange => cost::INVALID_VIEW_CHANGE,
+			DuplicateNeighborMessage => cost::DUPLICATE_NEIGHBOR_MESSAGE,
+			UndecodablePacket(bytes) => ReputationChange::new(
+				bytes.saturating_mul(cost::PER_UNDECODABLE_BYTE),
+				"Grandpa: Bad packet",
+			),
+			BadCatchUpMessage { signatures_checked } => ReputationChange::new(
+				cost::PER_SIGNATURE_CHECKED.saturating_mul(signatures_checked),
+				"Grandpa: Bad cath-up message",
+			),
+			BadCommitMessage { signatures_checked, blocks_loaded, equivocations_caught } => {
+				let cost = cost::PER_SIGNATURE_CHECKED
+					.saturating_mul(signatures_checked)
+					.saturating_add(cost::PER_BLOCK_LOADED.saturating_mul(blocks_loaded));
+
+				let benefit = equivocations_caught.saturating_mul(benefit::PER_EQUIVOCATION);
+
+				ReputationChange::new(
+					(benefit as i32).saturating_add(cost as i32),
+					"Grandpa: Bad commit",
+				)
+			},
+			FutureMessage => cost::FUTURE_MESSAGE,
+			OutOfScopeMessage => cost::OUT_OF_SCOPE_MESSAGE,
+		}
+	}
+}
+
+#[derive(Debug)]
+struct PeerInfo<N> {
+	view: View<N>,
+	roles: ObservedRole,
+}
+
+impl<N> PeerInfo<N> {
+	fn new(roles: ObservedRole) -> Self {
+		PeerInfo { view: View::default(), roles }
+	}
+}
+
+/// The peers we're connected to in gossip.
+struct Peers<N> {
+	inner: AHashMap<PeerId, PeerInfo<N>>,
+	/// The randomly picked set of `LUCKY_PEERS` we'll gossip to in the first stage of round
+	/// gossiping.
+	first_stage_peers: AHashSet<PeerId>,
+	/// The randomly picked set of peers we'll gossip to in the second stage of gossiping if the
+	/// first stage didn't allow us to spread the voting data enough to conclude the round. This
+	/// set should have size `sqrt(connected_peers)`.
+	second_stage_peers: HashSet<PeerId>,
+	/// The randomly picked set of `LUCKY_PEERS` light clients we'll gossip commit messages to.
+	lucky_light_peers: HashSet<PeerId>,
+	/// Neighbor packet rebroadcast period --- we reduce the reputation of peers sending duplicate
+	/// packets too often.
+	neighbor_rebroadcast_period: Duration,
+}
+
+impl<N: Ord> Peers<N> {
+	fn new(neighbor_rebroadcast_period: Duration) -> Self {
+		Peers {
+			inner: Default::default(),
+			first_stage_peers: Default::default(),
+			second_stage_peers: Default::default(),
+			lucky_light_peers: Default::default(),
+			neighbor_rebroadcast_period,
+		}
+	}
+
+	fn new_peer(&mut self, who: PeerId, role: ObservedRole) {
+		match role {
+			ObservedRole::Authority if self.first_stage_peers.len() < LUCKY_PEERS => {
+				self.first_stage_peers.insert(who);
+			},
+			ObservedRole::Authority if self.second_stage_peers.len() < LUCKY_PEERS => {
+				self.second_stage_peers.insert(who);
+			},
+			ObservedRole::Light if self.lucky_light_peers.len() < LUCKY_PEERS => {
+				self.lucky_light_peers.insert(who);
+			},
+			_ => {},
+		}
+
+		self.inner.insert(who, PeerInfo::new(role));
+	}
+
+	fn peer_disconnected(&mut self, who: &PeerId) {
+		self.inner.remove(who);
+		// This does not happen often enough compared to round duration,
+		// so we don't reshuffle.
+		self.first_stage_peers.remove(who);
+		self.second_stage_peers.remove(who);
+		self.lucky_light_peers.remove(who);
+	}
+
+	// returns a reference to the new view, if the peer is known.
+	fn update_peer_state(
+		&mut self,
+		who: &PeerId,
+		update: NeighborPacket<N>,
+	) -> Result<Option<&View<N>>, Misbehavior> {
+		let Some(peer) = self.inner.get_mut(who) else { return Ok(None) };
+
+		let invalid_change = peer.view.set_id > update.set_id ||
+			peer.view.round > update.round && peer.view.set_id == update.set_id ||
+			peer.view.last_commit.as_ref() > Some(&update.commit_finalized_height);
+
+		if invalid_change {
+			return Err(Misbehavior::InvalidViewChange)
+		}
+
+		let now = Instant::now();
+		let duplicate_packet = (update.set_id, update.round, Some(&update.commit_finalized_height)) ==
+			(peer.view.set_id, peer.view.round, peer.view.last_commit.as_ref());
+
+		if duplicate_packet {
+			if let Some(last_update) = peer.view.last_update {
+				if now < last_update + self.neighbor_rebroadcast_period / 2 {
+					return Err(Misbehavior::DuplicateNeighborMessage)
+				}
+			}
+		}
+
+		peer.view = View {
+			round: update.round,
+			set_id: update.set_id,
+			last_commit: Some(update.commit_finalized_height),
+			last_update: Some(now),
+		};
+
+		trace!(
+			target: LOG_TARGET,
+			"Peer {} updated view. Now at {:?}, {:?}",
+			who,
+			peer.view.round,
+			peer.view.set_id
+		);
+
+		Ok(Some(&peer.view))
+	}
+
+	fn update_commit_height(&mut self, who: &PeerId, new_height: N) -> Result<(), Misbehavior> {
+		let peer = match self.inner.get_mut(who) {
+			None => return Ok(()),
+			Some(p) => p,
+		};
+
+		// this doesn't allow a peer to send us unlimited commits with the
+		// same height, because there is still a misbehavior condition based on
+		// sending commits that are <= the best we are aware of.
+		if peer.view.last_commit.as_ref() > Some(&new_height) {
+			return Err(Misbehavior::InvalidViewChange)
+		}
+
+		peer.view.last_commit = Some(new_height);
+
+		Ok(())
+	}
+
+	fn peer<'a>(&'a self, who: &PeerId) -> Option<&'a PeerInfo<N>> {
+		self.inner.get(who)
+	}
+
+	fn reshuffle(&mut self) {
+		// we want to randomly select peers into three sets according to the following logic:
+		// - first set: LUCKY_PEERS random peers where at least LUCKY_PEERS/2 are authorities
+		//   (unless
+		// we're not connected to that many authorities)
+		// - second set: max(LUCKY_PEERS, sqrt(peers)) peers where at least LUCKY_PEERS are
+		//   authorities.
+		// - third set: LUCKY_PEERS random light client peers
+
+		let shuffled_peers = {
+			let mut peers =
+				self.inner.iter().map(|(peer_id, info)| (*peer_id, info)).collect::<Vec<_>>();
+
+			peers.shuffle(&mut rand::thread_rng());
+			peers
+		};
+
+		let shuffled_authorities = shuffled_peers.iter().filter_map(|(peer_id, info)| {
+			if matches!(info.roles, ObservedRole::Authority) {
+				Some(peer_id)
+			} else {
+				None
+			}
+		});
+
+		let mut first_stage_peers = AHashSet::new();
+		let mut second_stage_peers = HashSet::new();
+
+		// we start by allocating authorities to the first stage set and when the minimum of
+		// `LUCKY_PEERS / 2` is filled we start allocating to the second stage set.
+		let half_lucky = LUCKY_PEERS / 2;
+		let one_and_a_half_lucky = LUCKY_PEERS + half_lucky;
+		for (n_authorities_added, peer_id) in shuffled_authorities.enumerate() {
+			if n_authorities_added < half_lucky {
+				first_stage_peers.insert(*peer_id);
+			} else if n_authorities_added < one_and_a_half_lucky {
+				second_stage_peers.insert(*peer_id);
+			} else {
+				break
+			}
+		}
+
+		// fill up first and second sets with remaining peers (either full or authorities)
+		// prioritizing filling the first set over the second.
+		let n_second_stage_peers = LUCKY_PEERS.max((shuffled_peers.len() as f32).sqrt() as usize);
+		for (peer_id, info) in &shuffled_peers {
+			if info.roles.is_light() {
+				continue
+			}
+
+			if first_stage_peers.len() < LUCKY_PEERS {
+				first_stage_peers.insert(*peer_id);
+				second_stage_peers.remove(peer_id);
+			} else if second_stage_peers.len() < n_second_stage_peers {
+				if !first_stage_peers.contains(peer_id) {
+					second_stage_peers.insert(*peer_id);
+				}
+			} else {
+				break
+			}
+		}
+
+		// pick `LUCKY_PEERS` random light peers
+		let lucky_light_peers = shuffled_peers
+			.into_iter()
+			.filter_map(|(peer_id, info)| if info.roles.is_light() { Some(peer_id) } else { None })
+			.take(LUCKY_PEERS)
+			.collect();
+
+		self.first_stage_peers = first_stage_peers;
+		self.second_stage_peers = second_stage_peers;
+		self.lucky_light_peers = lucky_light_peers;
+	}
+}
+
+#[derive(Debug, PartialEq)]
+pub(super) enum Action<H> {
+	// repropagate under given topic, to the given peers, applying cost/benefit to originator.
+	Keep(H, ReputationChange),
+	// discard and process.
+	ProcessAndDiscard(H, ReputationChange),
+	// discard, applying cost/benefit to originator.
+	Discard(ReputationChange),
+}
+
+/// State of catch up request handling.
+#[derive(Debug)]
+enum PendingCatchUp {
+	/// No pending catch up requests.
+	None,
+	/// Pending catch up request which has not been answered yet.
+	Requesting { who: PeerId, request: CatchUpRequestMessage, instant: Instant },
+	/// Pending catch up request that was answered and is being processed.
+	Processing { instant: Instant },
+}
+
+/// Configuration for the round catch-up mechanism.
+enum CatchUpConfig {
+	/// Catch requests are enabled, our node will issue them whenever it sees a
+	/// neighbor packet for a round further than `CATCH_UP_THRESHOLD`. If
+	/// `only_from_authorities` is set, the node will only send catch-up
+	/// requests to other authorities it is connected to. This is useful if the
+	/// GRANDPA observer protocol is live on the network, in which case full
+	/// nodes (non-authorities) don't have the necessary round data to answer
+	/// catch-up requests.
+	Enabled { only_from_authorities: bool },
+	/// Catch-up requests are disabled, our node will never issue them. This is
+	/// useful for the GRANDPA observer mode, where we are only interested in
+	/// commit messages and don't need to follow the full round protocol.
+	Disabled,
+}
+
+impl CatchUpConfig {
+	fn enabled(only_from_authorities: bool) -> CatchUpConfig {
+		CatchUpConfig::Enabled { only_from_authorities }
+	}
+
+	fn disabled() -> CatchUpConfig {
+		CatchUpConfig::Disabled
+	}
+
+	fn request_allowed<N>(&self, peer: &PeerInfo<N>) -> bool {
+		match self {
+			CatchUpConfig::Disabled => false,
+			CatchUpConfig::Enabled { only_from_authorities, .. } => match peer.roles {
+				ObservedRole::Authority => true,
+				ObservedRole::Light => false,
+				ObservedRole::Full => !only_from_authorities,
+			},
+		}
+	}
+}
+
+struct Inner<Block: BlockT> {
+	local_view: Option<LocalView<NumberFor<Block>>>,
+	peers: Peers<NumberFor<Block>>,
+	live_topics: KeepTopics<Block>,
+	authorities: Vec<AuthorityId>,
+	config: crate::Config,
+	next_rebroadcast: Instant,
+	pending_catch_up: PendingCatchUp,
+	catch_up_config: CatchUpConfig,
+}
+
+type MaybeMessage<Block> = Option<(Vec<PeerId>, NeighborPacket<NumberFor<Block>>)>;
+
+impl<Block: BlockT> Inner<Block> {
+	fn new(config: crate::Config) -> Self {
+		let catch_up_config = if config.observer_enabled {
+			if config.local_role.is_authority() {
+				// since the observer protocol is enabled, we will only issue
+				// catch-up requests if we are an authority (and only to other
+				// authorities).
+				CatchUpConfig::enabled(true)
+			} else {
+				// otherwise, we are running the observer protocol and don't
+				// care about catch-up requests.
+				CatchUpConfig::disabled()
+			}
+		} else {
+			// if the observer protocol isn't enabled and we're not a light client, then any full
+			// node should be able to answer catch-up requests.
+			CatchUpConfig::enabled(false)
+		};
+
+		Inner {
+			local_view: None,
+			peers: Peers::new(NEIGHBOR_REBROADCAST_PERIOD),
+			live_topics: KeepTopics::new(),
+			next_rebroadcast: Instant::now() + REBROADCAST_AFTER,
+			authorities: Vec::new(),
+			pending_catch_up: PendingCatchUp::None,
+			catch_up_config,
+			config,
+		}
+	}
+
+	/// Note a round in the current set has started. Does nothing if the last
+	/// call to the function was with the same `round`.
+	fn note_round(&mut self, round: Round) -> MaybeMessage<Block> {
+		let local_view = self.local_view.as_mut()?;
+		if local_view.round == round {
+			// Do not send neighbor packets out if `round` has not changed ---
+			// such behavior is punishable.
+			return None
+		}
+
+		let set_id = local_view.set_id;
+
+		debug!(
+			target: LOG_TARGET,
+			"Voter {} noting beginning of round {:?} to network.",
+			self.config.name(),
+			(round, set_id)
+		);
+
+		local_view.update_round(round);
+
+		self.live_topics.push(round, set_id);
+		self.peers.reshuffle();
+
+		self.multicast_neighbor_packet(false)
+	}
+
+	/// Note that a voter set with given ID has started. Does nothing if the last
+	/// call to the function was with the same `set_id`.
+	fn note_set(&mut self, set_id: SetId, authorities: Vec<AuthorityId>) -> MaybeMessage<Block> {
+		let local_view = match self.local_view {
+			ref mut x @ None => x.get_or_insert(LocalView::new(set_id, Round(1))),
+			Some(ref mut v) => {
+				if v.set_id == set_id {
+					let diff_authorities = self.authorities.iter().collect::<HashSet<_>>() !=
+						authorities.iter().collect::<HashSet<_>>();
+
+					if diff_authorities {
+						debug!(
+							target: LOG_TARGET,
+							"Gossip validator noted set {:?} twice with different authorities. \
+							Was the authority set hard forked?",
+							set_id,
+						);
+
+						self.authorities = authorities;
+					}
+
+					// Do not send neighbor packets out if the `set_id` has not changed ---
+					// such behavior is punishable.
+					return None
+				} else {
+					v
+				}
+			},
+		};
+
+		local_view.update_set(set_id);
+		self.live_topics.push(Round(1), set_id);
+		self.authorities = authorities;
+
+		// when transitioning to a new set we also want to send neighbor packets to light clients,
+		// this is so that they know who to ask justifications from in order to finalize the last
+		// block in the previous set.
+		self.multicast_neighbor_packet(true)
+	}
+
+	/// Note that we've imported a commit finalizing a given block. Does nothing if the last
+	/// call to the function was with the same or higher `finalized` number.
+	/// `set_id` & `round` are the ones the commit message is from.
+	fn note_commit_finalized(
+		&mut self,
+		round: Round,
+		set_id: SetId,
+		finalized: NumberFor<Block>,
+	) -> MaybeMessage<Block> {
+		let local_view = self.local_view.as_mut()?;
+		if local_view.last_commit_height() < Some(&finalized) {
+			local_view.last_commit = Some((finalized, round, set_id));
+		} else {
+			return None
+		}
+
+		self.multicast_neighbor_packet(false)
+	}
+
+	fn consider_vote(&self, round: Round, set_id: SetId) -> Consider {
+		self.local_view
+			.as_ref()
+			.map(LocalView::as_view)
+			.map(|v| v.consider_vote(round, set_id))
+			.unwrap_or(Consider::RejectOutOfScope)
+	}
+
+	fn consider_global(&self, set_id: SetId, number: NumberFor<Block>) -> Consider {
+		self.local_view
+			.as_ref()
+			.map(LocalView::as_view)
+			.map(|v| v.consider_global(set_id, &number))
+			.unwrap_or(Consider::RejectOutOfScope)
+	}
+
+	fn cost_past_rejection(
+		&self,
+		_who: &PeerId,
+		_round: Round,
+		_set_id: SetId,
+	) -> ReputationChange {
+		// hardcoded for now.
+		cost::PAST_REJECTION
+	}
+
+	fn validate_round_message(
+		&self,
+		who: &PeerId,
+		full: &VoteMessage<Block>,
+	) -> Action<Block::Hash> {
+		match self.consider_vote(full.round, full.set_id) {
+			Consider::RejectFuture => return Action::Discard(Misbehavior::FutureMessage.cost()),
+			Consider::RejectOutOfScope =>
+				return Action::Discard(Misbehavior::OutOfScopeMessage.cost()),
+			Consider::RejectPast =>
+				return Action::Discard(self.cost_past_rejection(who, full.round, full.set_id)),
+			Consider::Accept => {},
+		}
+
+		// ensure authority is part of the set.
+		if !self.authorities.contains(&full.message.id) {
+			debug!(target: LOG_TARGET, "Message from unknown voter: {}", full.message.id);
+			telemetry!(
+				self.config.telemetry;
+				CONSENSUS_DEBUG;
+				"afg.bad_msg_signature";
+				"signature" => ?full.message.id,
+			);
+			return Action::Discard(cost::UNKNOWN_VOTER)
+		}
+
+		if !sp_consensus_grandpa::check_message_signature(
+			&full.message.message,
+			&full.message.id,
+			&full.message.signature,
+			full.round.0,
+			full.set_id.0,
+		) {
+			debug!(target: LOG_TARGET, "Bad message signature {}", full.message.id);
+			telemetry!(
+				self.config.telemetry;
+				CONSENSUS_DEBUG;
+				"afg.bad_msg_signature";
+				"signature" => ?full.message.id,
+			);
+			return Action::Discard(cost::BAD_SIGNATURE)
+		}
+
+		let topic = super::round_topic::<Block>(full.round.0, full.set_id.0);
+		Action::Keep(topic, benefit::ROUND_MESSAGE)
+	}
+
+	fn validate_commit_message(
+		&mut self,
+		who: &PeerId,
+		full: &FullCommitMessage<Block>,
+	) -> Action<Block::Hash> {
+		if let Err(misbehavior) = self.peers.update_commit_height(who, full.message.target_number) {
+			return Action::Discard(misbehavior.cost())
+		}
+
+		match self.consider_global(full.set_id, full.message.target_number) {
+			Consider::RejectFuture => return Action::Discard(Misbehavior::FutureMessage.cost()),
+			Consider::RejectPast =>
+				return Action::Discard(self.cost_past_rejection(who, full.round, full.set_id)),
+			Consider::RejectOutOfScope =>
+				return Action::Discard(Misbehavior::OutOfScopeMessage.cost()),
+			Consider::Accept => {},
+		}
+
+		if full.message.precommits.len() != full.message.auth_data.len() ||
+			full.message.precommits.is_empty()
+		{
+			debug!(target: LOG_TARGET, "Malformed compact commit");
+			telemetry!(
+				self.config.telemetry;
+				CONSENSUS_DEBUG;
+				"afg.malformed_compact_commit";
+				"precommits_len" => ?full.message.precommits.len(),
+				"auth_data_len" => ?full.message.auth_data.len(),
+				"precommits_is_empty" => ?full.message.precommits.is_empty(),
+			);
+			return Action::Discard(cost::MALFORMED_COMMIT)
+		}
+
+		// always discard commits initially and rebroadcast after doing full
+		// checking.
+		let topic = super::global_topic::<Block>(full.set_id.0);
+		Action::ProcessAndDiscard(topic, benefit::BASIC_VALIDATED_COMMIT)
+	}
+
+	fn validate_catch_up_message(
+		&mut self,
+		who: &PeerId,
+		full: &FullCatchUpMessage<Block>,
+	) -> Action<Block::Hash> {
+		match &self.pending_catch_up {
+			PendingCatchUp::Requesting { who: peer, request, instant } => {
+				if peer != who {
+					return Action::Discard(Misbehavior::OutOfScopeMessage.cost())
+				}
+
+				if request.set_id != full.set_id {
+					return Action::Discard(cost::MALFORMED_CATCH_UP)
+				}
+
+				if request.round.0 > full.message.round_number {
+					return Action::Discard(cost::MALFORMED_CATCH_UP)
+				}
+
+				if full.message.prevotes.is_empty() || full.message.precommits.is_empty() {
+					return Action::Discard(cost::MALFORMED_CATCH_UP)
+				}
+
+				// move request to pending processing state, we won't push out
+				// any catch up requests until we import this one (either with a
+				// success or failure).
+				self.pending_catch_up = PendingCatchUp::Processing { instant: *instant };
+
+				// always discard catch up messages, they're point-to-point
+				let topic = super::global_topic::<Block>(full.set_id.0);
+				Action::ProcessAndDiscard(topic, benefit::BASIC_VALIDATED_CATCH_UP)
+			},
+			_ => Action::Discard(Misbehavior::OutOfScopeMessage.cost()),
+		}
+	}
+
+	fn note_catch_up_message_processed(&mut self) {
+		match &self.pending_catch_up {
+			PendingCatchUp::Processing { .. } => {
+				self.pending_catch_up = PendingCatchUp::None;
+			},
+			state => debug!(
+				target: LOG_TARGET,
+				"Noted processed catch up message when state was: {:?}", state,
+			),
+		}
+	}
+
+	fn handle_catch_up_request(
+		&mut self,
+		who: &PeerId,
+		request: CatchUpRequestMessage,
+		set_state: &environment::SharedVoterSetState<Block>,
+	) -> (Option<GossipMessage<Block>>, Action<Block::Hash>) {
+		let Some(local_view) = &self.local_view else {
+			return (None, Action::Discard(Misbehavior::OutOfScopeMessage.cost()))
+		};
+
+		if request.set_id != local_view.set_id {
+			// NOTE: When we're close to a set change there is potentially a
+			// race where the peer sent us the request before it observed that
+			// we had transitioned to a new set. In this case we charge a lower
+			// cost.
+			if request.set_id.0.saturating_add(1) == local_view.set_id.0 &&
+				local_view.round.0.saturating_sub(CATCH_UP_THRESHOLD) == 0
+			{
+				return (None, Action::Discard(cost::HONEST_OUT_OF_SCOPE_CATCH_UP))
+			}
+
+			return (None, Action::Discard(Misbehavior::OutOfScopeMessage.cost()))
+		}
+
+		match self.peers.peer(who) {
+			None => return (None, Action::Discard(Misbehavior::OutOfScopeMessage.cost())),
+			Some(peer) if peer.view.round >= request.round =>
+				return (None, Action::Discard(Misbehavior::OutOfScopeMessage.cost())),
+			_ => {},
+		}
+
+		let last_completed_round = set_state.read().last_completed_round();
+		if last_completed_round.number < request.round.0 {
+			return (None, Action::Discard(Misbehavior::OutOfScopeMessage.cost()))
+		}
+
+		trace!(
+			target: LOG_TARGET,
+			"Replying to catch-up request for round {} from {} with round {}",
+			request.round.0,
+			who,
+			last_completed_round.number,
+		);
+
+		let mut prevotes = Vec::new();
+		let mut precommits = Vec::new();
+
+		// NOTE: the set of votes stored in `LastCompletedRound` is a minimal
+		// set of votes, i.e. at most one equivocation is stored per voter. The
+		// code below assumes this invariant is maintained when creating the
+		// catch up reply since peers won't accept catch-up messages that have
+		// too many equivocations (we exceed the fault-tolerance bound).
+		for vote in last_completed_round.votes {
+			match vote.message {
+				finality_grandpa::Message::Prevote(prevote) => {
+					prevotes.push(finality_grandpa::SignedPrevote {
+						prevote,
+						signature: vote.signature,
+						id: vote.id,
+					});
+				},
+				finality_grandpa::Message::Precommit(precommit) => {
+					precommits.push(finality_grandpa::SignedPrecommit {
+						precommit,
+						signature: vote.signature,
+						id: vote.id,
+					});
+				},
+				_ => {},
+			}
+		}
+
+		let (base_hash, base_number) = last_completed_round.base;
+
+		let catch_up = CatchUp::<Block::Header> {
+			round_number: last_completed_round.number,
+			prevotes,
+			precommits,
+			base_hash,
+			base_number,
+		};
+
+		let full_catch_up = GossipMessage::CatchUp::<Block>(FullCatchUpMessage {
+			set_id: request.set_id,
+			message: catch_up,
+		});
+
+		(Some(full_catch_up), Action::Discard(cost::CATCH_UP_REPLY))
+	}
+
+	fn try_catch_up(&mut self, who: &PeerId) -> (Option<GossipMessage<Block>>, Option<Report>) {
+		let mut catch_up = None;
+		let mut report = None;
+
+		// if the peer is on the same set and ahead of us by a margin bigger
+		// than `CATCH_UP_THRESHOLD` then we should ask it for a catch up
+		// message. we only send catch-up requests to authorities, observers
+		// won't be able to reply since they don't follow the full GRANDPA
+		// protocol and therefore might not have the vote data available.
+		if let (Some(peer), Some(local_view)) = (self.peers.peer(who), &self.local_view) {
+			if self.catch_up_config.request_allowed(peer) &&
+				peer.view.set_id == local_view.set_id &&
+				peer.view.round.0.saturating_sub(CATCH_UP_THRESHOLD) > local_view.round.0
+			{
+				// send catch up request if allowed
+				let round = peer.view.round.0 - 1; // peer.view.round is > 0
+				let request =
+					CatchUpRequestMessage { set_id: peer.view.set_id, round: Round(round) };
+
+				let (catch_up_allowed, catch_up_report) = self.note_catch_up_request(who, &request);
+
+				if catch_up_allowed {
+					debug!(
+						target: LOG_TARGET,
+						"Sending catch-up request for round {} to {}", round, who,
+					);
+
+					catch_up = Some(GossipMessage::<Block>::CatchUpRequest(request));
+				}
+
+				report = catch_up_report;
+			}
+		}
+
+		(catch_up, report)
+	}
+
+	fn import_neighbor_message(
+		&mut self,
+		who: &PeerId,
+		update: NeighborPacket<NumberFor<Block>>,
+	) -> (Vec<Block::Hash>, Action<Block::Hash>, Option<GossipMessage<Block>>, Option<Report>) {
+		let update_res = self.peers.update_peer_state(who, update);
+
+		let (cost_benefit, topics) = match update_res {
+			Ok(view) =>
+				(benefit::NEIGHBOR_MESSAGE, view.map(|view| neighbor_topics::<Block>(view))),
+			Err(misbehavior) => (misbehavior.cost(), None),
+		};
+
+		let (catch_up, report) =
+			if update_res.is_ok() { self.try_catch_up(who) } else { (None, None) };
+
+		let neighbor_topics = topics.unwrap_or_default();
+
+		// always discard neighbor messages, it's only valid for one hop.
+		let action = Action::Discard(cost_benefit);
+
+		(neighbor_topics, action, catch_up, report)
+	}
+
+	fn multicast_neighbor_packet(&self, force_light: bool) -> MaybeMessage<Block> {
+		self.local_view.as_ref().map(|local_view| {
+			let packet = NeighborPacket {
+				round: local_view.round,
+				set_id: local_view.set_id,
+				commit_finalized_height: *local_view.last_commit_height().unwrap_or(&Zero::zero()),
+			};
+
+			let peers = self
+				.peers
+				.inner
+				.iter()
+				.filter_map(|(id, info)| {
+					// light clients don't participate in the full GRANDPA voter protocol
+					// and therefore don't need to be informed about all view updates unless
+					// we explicitly require it (e.g. when transitioning to a new set)
+					if info.roles.is_light() && !force_light {
+						None
+					} else {
+						Some(id)
+					}
+				})
+				.cloned()
+				.collect();
+
+			(peers, packet)
+		})
+	}
+
+	fn note_catch_up_request(
+		&mut self,
+		who: &PeerId,
+		catch_up_request: &CatchUpRequestMessage,
+	) -> (bool, Option<Report>) {
+		let report = match &self.pending_catch_up {
+			PendingCatchUp::Requesting { who: peer, instant, .. } => {
+				if instant.elapsed() <= CATCH_UP_REQUEST_TIMEOUT {
+					return (false, None)
+				} else {
+					// report peer for timeout
+					Some((*peer, cost::CATCH_UP_REQUEST_TIMEOUT))
+				}
+			},
+			PendingCatchUp::Processing { instant, .. } => {
+				if instant.elapsed() < CATCH_UP_PROCESS_TIMEOUT {
+					return (false, None)
+				} else {
+					None
+				}
+			},
+			_ => None,
+		};
+
+		self.pending_catch_up = PendingCatchUp::Requesting {
+			who: *who,
+			request: catch_up_request.clone(),
+			instant: Instant::now(),
+		};
+
+		(true, report)
+	}
+
+	/// The initial logic for filtering round messages follows the given state
+	/// transitions:
+	///
+	/// - State 1: allowed to LUCKY_PEERS random peers (where at least LUCKY_PEERS/2 are
+	///   authorities)
+	/// - State 2: allowed to max(LUCKY_PEERS, sqrt(random peers)) (where at least LUCKY_PEERS are
+	///   authorities)
+	/// - State 3: allowed to all peers
+	///
+	/// Transitions will be triggered on repropagation attempts by the underlying gossip layer.
+	fn round_message_allowed(&self, who: &PeerId) -> bool {
+		let round_duration = self.config.gossip_duration * ROUND_DURATION;
+		let round_elapsed = match self.local_view {
+			Some(ref local_view) => local_view.round_start.elapsed(),
+			None => return false,
+		};
+
+		if round_elapsed < round_duration.mul_f32(PROPAGATION_SOME) {
+			self.peers.first_stage_peers.contains(who)
+		} else if round_elapsed < round_duration.mul_f32(PROPAGATION_ALL) {
+			self.peers.first_stage_peers.contains(who) ||
+				self.peers.second_stage_peers.contains(who)
+		} else {
+			self.peers.peer(who).map(|info| !info.roles.is_light()).unwrap_or(false)
+		}
+	}
+
+	/// The initial logic for filtering global messages follows the given state
+	/// transitions:
+	///
+	/// - State 1: allowed to max(LUCKY_PEERS, sqrt(peers)) (where at least LUCKY_PEERS are
+	///   authorities)
+	/// - State 2: allowed to all peers
+	///
+	/// We are more lenient with global messages since there should be a lot
+	/// less global messages than round messages (just commits), and we want
+	/// these to propagate to non-authorities fast enough so that they can
+	/// observe finality.
+	///
+	/// Transitions will be triggered on repropagation attempts by the
+	/// underlying gossip layer, which should happen every 30 seconds.
+	fn global_message_allowed(&self, who: &PeerId) -> bool {
+		let round_duration = self.config.gossip_duration * ROUND_DURATION;
+		let round_elapsed = match self.local_view {
+			Some(ref local_view) => local_view.round_start.elapsed(),
+			None => return false,
+		};
+
+		if round_elapsed < round_duration.mul_f32(PROPAGATION_ALL) {
+			self.peers.first_stage_peers.contains(who) ||
+				self.peers.second_stage_peers.contains(who) ||
+				self.peers.lucky_light_peers.contains(who)
+		} else {
+			true
+		}
+	}
+}
+
+// Prometheus metrics for [`GossipValidator`].
+pub(crate) struct Metrics {
+	messages_validated: CounterVec<U64>,
+}
+
+impl Metrics {
+	pub(crate) fn register(
+		registry: &prometheus_endpoint::Registry,
+	) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			messages_validated: register(
+				CounterVec::new(
+					Opts::new(
+						"substrate_finality_grandpa_communication_gossip_validator_messages",
+						"Number of messages validated by the finality grandpa gossip validator.",
+					),
+					&["message", "action"],
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// A validator for GRANDPA gossip messages.
+pub(super) struct GossipValidator<Block: BlockT> {
+	inner: parking_lot::RwLock<Inner<Block>>,
+	set_state: environment::SharedVoterSetState<Block>,
+	report_sender: TracingUnboundedSender<PeerReport>,
+	metrics: Option<Metrics>,
+	telemetry: Option<TelemetryHandle>,
+}
+
+impl<Block: BlockT> GossipValidator<Block> {
+	/// Create a new gossip-validator. The current set is initialized to 0. If
+	/// `catch_up_enabled` is set to false then the validator will not issue any
+	/// catch up requests (useful e.g. when running just the GRANDPA observer).
+	pub(super) fn new(
+		config: crate::Config,
+		set_state: environment::SharedVoterSetState<Block>,
+		prometheus_registry: Option<&Registry>,
+		telemetry: Option<TelemetryHandle>,
+	) -> (GossipValidator<Block>, TracingUnboundedReceiver<PeerReport>) {
+		let metrics = match prometheus_registry.map(Metrics::register) {
+			Some(Ok(metrics)) => Some(metrics),
+			Some(Err(e)) => {
+				debug!(target: LOG_TARGET, "Failed to register metrics: {:?}", e);
+				None
+			},
+			None => None,
+		};
+
+		let (tx, rx) = tracing_unbounded("mpsc_grandpa_gossip_validator", 100_000);
+		let val = GossipValidator {
+			inner: parking_lot::RwLock::new(Inner::new(config)),
+			set_state,
+			report_sender: tx,
+			metrics,
+			telemetry,
+		};
+
+		(val, rx)
+	}
+
+	/// Note a round in the current set has started.
+	pub(super) fn note_round<F>(&self, round: Round, send_neighbor: F)
+	where
+		F: FnOnce(Vec<PeerId>, NeighborPacket<NumberFor<Block>>),
+	{
+		let maybe_msg = self.inner.write().note_round(round);
+		if let Some((to, msg)) = maybe_msg {
+			send_neighbor(to, msg);
+		}
+	}
+
+	/// Note that a voter set with given ID has started. Updates the current set to given
+	/// value and initializes the round to 0.
+	pub(super) fn note_set<F>(&self, set_id: SetId, authorities: Vec<AuthorityId>, send_neighbor: F)
+	where
+		F: FnOnce(Vec<PeerId>, NeighborPacket<NumberFor<Block>>),
+	{
+		let maybe_msg = self.inner.write().note_set(set_id, authorities);
+		if let Some((to, msg)) = maybe_msg {
+			send_neighbor(to, msg);
+		}
+	}
+
+	/// Note that we've imported a commit finalizing a given block.
+	/// `set_id` & `round` are the ones the commit message is from and not necessarily
+	/// the latest set ID & round started.
+	pub(super) fn note_commit_finalized<F>(
+		&self,
+		round: Round,
+		set_id: SetId,
+		finalized: NumberFor<Block>,
+		send_neighbor: F,
+	) where
+		F: FnOnce(Vec<PeerId>, NeighborPacket<NumberFor<Block>>),
+	{
+		let maybe_msg = self.inner.write().note_commit_finalized(round, set_id, finalized);
+
+		if let Some((to, msg)) = maybe_msg {
+			send_neighbor(to, msg);
+		}
+	}
+
+	/// Note that we've processed a catch up message.
+	pub(super) fn note_catch_up_message_processed(&self) {
+		self.inner.write().note_catch_up_message_processed();
+	}
+
+	fn report(&self, who: PeerId, cost_benefit: ReputationChange) {
+		let _ = self.report_sender.unbounded_send(PeerReport { who, cost_benefit });
+	}
+
+	pub(super) fn do_validate(
+		&self,
+		who: &PeerId,
+		mut data: &[u8],
+	) -> (Action<Block::Hash>, Vec<Block::Hash>, Option<GossipMessage<Block>>) {
+		let mut broadcast_topics = Vec::new();
+		let mut peer_reply = None;
+
+		// Message name for Prometheus metric recording.
+		let message_name;
+
+		let action = {
+			match GossipMessage::<Block>::decode_all(&mut data) {
+				Ok(GossipMessage::Vote(ref message)) => {
+					message_name = Some("vote");
+					self.inner.write().validate_round_message(who, message)
+				},
+				Ok(GossipMessage::Commit(ref message)) => {
+					message_name = Some("commit");
+					self.inner.write().validate_commit_message(who, message)
+				},
+				Ok(GossipMessage::Neighbor(update)) => {
+					message_name = Some("neighbor");
+					let (topics, action, catch_up, report) = self
+						.inner
+						.write()
+						.import_neighbor_message(who, update.into_neighbor_packet());
+
+					if let Some((peer, cost_benefit)) = report {
+						self.report(peer, cost_benefit);
+					}
+
+					broadcast_topics = topics;
+					peer_reply = catch_up;
+					action
+				},
+				Ok(GossipMessage::CatchUp(ref message)) => {
+					message_name = Some("catch_up");
+					self.inner.write().validate_catch_up_message(who, message)
+				},
+				Ok(GossipMessage::CatchUpRequest(request)) => {
+					message_name = Some("catch_up_request");
+					let (reply, action) =
+						self.inner.write().handle_catch_up_request(who, request, &self.set_state);
+
+					peer_reply = reply;
+					action
+				},
+				Err(e) => {
+					message_name = None;
+					debug!(target: LOG_TARGET, "Error decoding message: {}", e);
+					telemetry!(
+						self.telemetry;
+						CONSENSUS_DEBUG;
+						"afg.err_decoding_msg";
+						"" => "",
+					);
+
+					let len = std::cmp::min(i32::MAX as usize, data.len()) as i32;
+					Action::Discard(Misbehavior::UndecodablePacket(len).cost())
+				},
+			}
+		};
+
+		// Prometheus metric recording.
+		if let (Some(metrics), Some(message_name)) = (&self.metrics, message_name) {
+			let action_name = match action {
+				Action::Keep(_, _) => "keep",
+				Action::ProcessAndDiscard(_, _) => "process_and_discard",
+				Action::Discard(_) => "discard",
+			};
+			metrics.messages_validated.with_label_values(&[message_name, action_name]).inc();
+		}
+
+		(action, broadcast_topics, peer_reply)
+	}
+
+	#[cfg(test)]
+	fn inner(&self) -> &parking_lot::RwLock<Inner<Block>> {
+		&self.inner
+	}
+}
+
+impl<Block: BlockT> sc_network_gossip::Validator<Block> for GossipValidator<Block> {
+	fn new_peer(
+		&self,
+		context: &mut dyn ValidatorContext<Block>,
+		who: &PeerId,
+		roles: ObservedRole,
+	) {
+		let packet = {
+			let mut inner = self.inner.write();
+			inner.peers.new_peer(*who, roles);
+
+			inner.local_view.as_ref().map(|v| NeighborPacket {
+				round: v.round,
+				set_id: v.set_id,
+				commit_finalized_height: *v.last_commit_height().unwrap_or(&Zero::zero()),
+			})
+		};
+
+		if let Some(packet) = packet {
+			let packet_data = GossipMessage::<Block>::from(packet).encode();
+			context.send_message(who, packet_data);
+		}
+	}
+
+	fn peer_disconnected(&self, _context: &mut dyn ValidatorContext<Block>, who: &PeerId) {
+		self.inner.write().peers.peer_disconnected(who);
+	}
+
+	fn validate(
+		&self,
+		context: &mut dyn ValidatorContext<Block>,
+		who: &PeerId,
+		data: &[u8],
+	) -> sc_network_gossip::ValidationResult<Block::Hash> {
+		let (action, broadcast_topics, peer_reply) = self.do_validate(who, data);
+
+		// not with lock held!
+		if let Some(msg) = peer_reply {
+			context.send_message(who, msg.encode());
+		}
+
+		for topic in broadcast_topics {
+			context.send_topic(who, topic, false);
+		}
+
+		match action {
+			Action::Keep(topic, cb) => {
+				self.report(*who, cb);
+				context.broadcast_message(topic, data.to_vec(), false);
+				sc_network_gossip::ValidationResult::ProcessAndKeep(topic)
+			},
+			Action::ProcessAndDiscard(topic, cb) => {
+				self.report(*who, cb);
+				sc_network_gossip::ValidationResult::ProcessAndDiscard(topic)
+			},
+			Action::Discard(cb) => {
+				self.report(*who, cb);
+				sc_network_gossip::ValidationResult::Discard
+			},
+		}
+	}
+
+	fn message_allowed<'a>(
+		&'a self,
+	) -> Box<dyn FnMut(&PeerId, MessageIntent, &Block::Hash, &[u8]) -> bool + 'a> {
+		let (inner, do_rebroadcast) = {
+			use parking_lot::RwLockWriteGuard;
+
+			let mut inner = self.inner.write();
+			let now = Instant::now();
+			let do_rebroadcast = if now >= inner.next_rebroadcast {
+				inner.next_rebroadcast = now + REBROADCAST_AFTER;
+				true
+			} else {
+				false
+			};
+
+			// downgrade to read-lock.
+			(RwLockWriteGuard::downgrade(inner), do_rebroadcast)
+		};
+
+		Box::new(move |who, intent, topic, mut data| {
+			if let MessageIntent::PeriodicRebroadcast = intent {
+				return do_rebroadcast
+			}
+
+			let peer = match inner.peers.peer(who) {
+				None => return false,
+				Some(x) => x,
+			};
+
+			// if the topic is not something we're keeping at the moment,
+			// do not send.
+			let Some((maybe_round, set_id)) = inner.live_topics.topic_info(topic) else {
+				return false
+			};
+
+			if let MessageIntent::Broadcast = intent {
+				if maybe_round.is_some() {
+					if !inner.round_message_allowed(who) {
+						// early return if the vote message isn't allowed at this stage.
+						return false
+					}
+				} else if !inner.global_message_allowed(who) {
+					// early return if the global message isn't allowed at this stage.
+					return false
+				}
+			}
+
+			// if the topic is not something the peer accepts, discard.
+			if let Some(round) = maybe_round {
+				return peer.view.consider_vote(round, set_id) == Consider::Accept
+			}
+
+			// global message.
+			let Some(local_view) = &inner.local_view else {
+				return false // cannot evaluate until we have a local view.
+			};
+
+			match GossipMessage::<Block>::decode_all(&mut data) {
+				Err(_) => false,
+				Ok(GossipMessage::Commit(full)) => {
+					// we only broadcast commit messages if they're for the same
+					// set the peer is in and if the commit is better than the
+					// last received by peer, additionally we make sure to only
+					// broadcast our best commit.
+					peer.view.consider_global(set_id, full.message.target_number) ==
+						Consider::Accept && Some(&full.message.target_number) ==
+						local_view.last_commit_height()
+				},
+				Ok(GossipMessage::Neighbor(_)) => false,
+				Ok(GossipMessage::CatchUpRequest(_)) => false,
+				Ok(GossipMessage::CatchUp(_)) => false,
+				Ok(GossipMessage::Vote(_)) => false, // should not be the case.
+			}
+		})
+	}
+
+	fn message_expired<'a>(&'a self) -> Box<dyn FnMut(Block::Hash, &[u8]) -> bool + 'a> {
+		let inner = self.inner.read();
+		Box::new(move |topic, mut data| {
+			// if the topic is not one of the ones that we are keeping at the moment,
+			// it is expired.
+			match inner.live_topics.topic_info(&topic) {
+				None => return true,
+				// round messages don't require further checking.
+				Some((Some(_), _)) => return false,
+				Some((None, _)) => {},
+			};
+
+			let Some(local_view) = &inner.local_view else {
+				return true // no local view means we can't evaluate or hold any topic.
+			};
+
+			// global messages -- only keep the best commit.
+			match GossipMessage::<Block>::decode_all(&mut data) {
+				Err(_) => true,
+				Ok(GossipMessage::Commit(full)) => match local_view.last_commit {
+					Some((number, round, set_id)) =>
+					// we expire any commit message that doesn't target the same block
+					// as our best commit or isn't from the same round and set id
+						!(full.message.target_number == number &&
+							full.round == round && full.set_id == set_id),
+					None => true,
+				},
+				Ok(_) => true,
+			}
+		})
+	}
+}
+
+/// Report specifying a reputation change for a given peer.
+pub(super) struct PeerReport {
+	pub who: PeerId,
+	pub cost_benefit: ReputationChange,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{super::NEIGHBOR_REBROADCAST_PERIOD, environment::SharedVoterSetState, *};
+	use crate::communication;
+	use sc_network::config::Role;
+	use sc_network_gossip::Validator as GossipValidatorT;
+	use sp_core::{crypto::UncheckedFrom, H256};
+	use std::time::Instant;
+	use substrate_test_runtime_client::runtime::{Block, Header};
+
+	// some random config (not really needed)
+	fn config() -> crate::Config {
+		crate::Config {
+			gossip_duration: Duration::from_millis(10),
+			justification_generation_period: 256,
+			keystore: None,
+			name: None,
+			local_role: Role::Authority,
+			observer_enabled: true,
+			telemetry: None,
+			protocol_name: communication::grandpa_protocol_name::NAME.into(),
+		}
+	}
+
+	// dummy voter set state
+	fn voter_set_state() -> SharedVoterSetState<Block> {
+		use crate::{authorities::AuthoritySet, environment::VoterSetState};
+
+		let base = (H256::zero(), 0);
+
+		let voters = vec![(AuthorityId::unchecked_from([1; 32]), 1)];
+		let voters = AuthoritySet::genesis(voters).unwrap();
+
+		let set_state = VoterSetState::live(0, &voters, base);
+
+		set_state.into()
+	}
+
+	#[test]
+	fn view_vote_rules() {
+		let view = View {
+			round: Round(100),
+			set_id: SetId(1),
+			last_commit: Some(1000u64),
+			last_update: None,
+		};
+
+		assert_eq!(view.consider_vote(Round(98), SetId(1)), Consider::RejectPast);
+		assert_eq!(view.consider_vote(Round(1), SetId(0)), Consider::RejectPast);
+		assert_eq!(view.consider_vote(Round(1000), SetId(0)), Consider::RejectPast);
+
+		assert_eq!(view.consider_vote(Round(99), SetId(1)), Consider::Accept);
+		assert_eq!(view.consider_vote(Round(100), SetId(1)), Consider::Accept);
+		assert_eq!(view.consider_vote(Round(101), SetId(1)), Consider::Accept);
+
+		assert_eq!(view.consider_vote(Round(102), SetId(1)), Consider::RejectFuture);
+		assert_eq!(view.consider_vote(Round(1), SetId(2)), Consider::RejectFuture);
+		assert_eq!(view.consider_vote(Round(1000), SetId(2)), Consider::RejectFuture);
+	}
+
+	#[test]
+	fn view_global_message_rules() {
+		let view = View {
+			round: Round(100),
+			set_id: SetId(2),
+			last_commit: Some(1000u64),
+			last_update: None,
+		};
+
+		assert_eq!(view.consider_global(SetId(3), 1), Consider::RejectFuture);
+		assert_eq!(view.consider_global(SetId(3), 1000), Consider::RejectFuture);
+		assert_eq!(view.consider_global(SetId(3), 10000), Consider::RejectFuture);
+
+		assert_eq!(view.consider_global(SetId(1), 1), Consider::RejectPast);
+		assert_eq!(view.consider_global(SetId(1), 1000), Consider::RejectPast);
+		assert_eq!(view.consider_global(SetId(1), 10000), Consider::RejectPast);
+
+		assert_eq!(view.consider_global(SetId(2), 1), Consider::RejectPast);
+		assert_eq!(view.consider_global(SetId(2), 1000), Consider::RejectPast);
+		assert_eq!(view.consider_global(SetId(2), 1001), Consider::Accept);
+		assert_eq!(view.consider_global(SetId(2), 10000), Consider::Accept);
+	}
+
+	#[test]
+	fn unknown_peer_cannot_be_updated() {
+		let mut peers = Peers::new(NEIGHBOR_REBROADCAST_PERIOD);
+		let id = PeerId::random();
+
+		let update =
+			NeighborPacket { round: Round(5), set_id: SetId(10), commit_finalized_height: 50 };
+
+		let res = peers.update_peer_state(&id, update.clone());
+		assert!(res.unwrap().is_none());
+
+		// connect & disconnect.
+		peers.new_peer(id, ObservedRole::Authority);
+		peers.peer_disconnected(&id);
+
+		let res = peers.update_peer_state(&id, update.clone());
+		assert!(res.unwrap().is_none());
+	}
+
+	#[test]
+	fn update_peer_state() {
+		let update1 =
+			NeighborPacket { round: Round(5), set_id: SetId(10), commit_finalized_height: 50u32 };
+
+		let update2 =
+			NeighborPacket { round: Round(6), set_id: SetId(10), commit_finalized_height: 60 };
+
+		let update3 =
+			NeighborPacket { round: Round(2), set_id: SetId(11), commit_finalized_height: 61 };
+
+		let update4 =
+			NeighborPacket { round: Round(3), set_id: SetId(11), commit_finalized_height: 80 };
+
+		// Use shorter rebroadcast period to safely roll the clock back in the last test
+		// and don't hit the system boot time on systems with unsigned time.
+		const SHORT_NEIGHBOR_REBROADCAST_PERIOD: Duration = Duration::from_secs(1);
+		let mut peers = Peers::new(SHORT_NEIGHBOR_REBROADCAST_PERIOD);
+		let id = PeerId::random();
+
+		peers.new_peer(id, ObservedRole::Authority);
+
+		let check_update = |peers: &mut Peers<_>, update: NeighborPacket<_>| {
+			let view = peers.update_peer_state(&id, update.clone()).unwrap().unwrap();
+			assert_eq!(view.round, update.round);
+			assert_eq!(view.set_id, update.set_id);
+			assert_eq!(view.last_commit, Some(update.commit_finalized_height));
+		};
+
+		check_update(&mut peers, update1);
+		check_update(&mut peers, update2);
+		check_update(&mut peers, update3);
+		check_update(&mut peers, update4.clone());
+
+		// Allow duplicate neighbor packets if enough time has passed.
+		peers.inner.get_mut(&id).unwrap().view.last_update =
+			Some(Instant::now() - SHORT_NEIGHBOR_REBROADCAST_PERIOD);
+		check_update(&mut peers, update4);
+	}
+
+	#[test]
+	fn invalid_view_change() {
+		let mut peers = Peers::new(NEIGHBOR_REBROADCAST_PERIOD);
+
+		let id = PeerId::random();
+		peers.new_peer(id, ObservedRole::Authority);
+
+		peers
+			.update_peer_state(
+				&id,
+				NeighborPacket { round: Round(10), set_id: SetId(10), commit_finalized_height: 10 },
+			)
+			.unwrap()
+			.unwrap();
+
+		let mut check_update = move |update: NeighborPacket<_>, misbehavior| {
+			let err = peers.update_peer_state(&id, update.clone()).unwrap_err();
+			assert_eq!(err, misbehavior);
+		};
+
+		// round moves backwards.
+		check_update(
+			NeighborPacket { round: Round(9), set_id: SetId(10), commit_finalized_height: 10 },
+			Misbehavior::InvalidViewChange,
+		);
+		// set ID moves backwards.
+		check_update(
+			NeighborPacket { round: Round(10), set_id: SetId(9), commit_finalized_height: 10 },
+			Misbehavior::InvalidViewChange,
+		);
+		// commit finalized height moves backwards.
+		check_update(
+			NeighborPacket { round: Round(10), set_id: SetId(10), commit_finalized_height: 9 },
+			Misbehavior::InvalidViewChange,
+		);
+		// duplicate packet without grace period.
+		check_update(
+			NeighborPacket { round: Round(10), set_id: SetId(10), commit_finalized_height: 10 },
+			Misbehavior::DuplicateNeighborMessage,
+		);
+		// commit finalized height moves backwards while round moves forward.
+		check_update(
+			NeighborPacket { round: Round(11), set_id: SetId(10), commit_finalized_height: 9 },
+			Misbehavior::InvalidViewChange,
+		);
+		// commit finalized height moves backwards while set ID moves forward.
+		check_update(
+			NeighborPacket { round: Round(10), set_id: SetId(11), commit_finalized_height: 9 },
+			Misbehavior::InvalidViewChange,
+		);
+	}
+
+	#[test]
+	fn messages_not_expired_immediately() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		let set_id = 1;
+
+		val.note_set(SetId(set_id), Vec::new(), |_, _| {});
+
+		for round_num in 1u64..10 {
+			val.note_round(Round(round_num), |_, _| {});
+		}
+
+		{
+			let mut is_expired = val.message_expired();
+			let last_kept_round = 10u64 - KEEP_RECENT_ROUNDS as u64 - 1;
+
+			// messages from old rounds are expired.
+			for round_num in 1u64..last_kept_round {
+				let topic = communication::round_topic::<Block>(round_num, 1);
+				assert!(is_expired(topic, &[1, 2, 3]));
+			}
+
+			// messages from not-too-old rounds are not expired.
+			for round_num in last_kept_round..10 {
+				let topic = communication::round_topic::<Block>(round_num, 1);
+				assert!(!is_expired(topic, &[1, 2, 3]));
+			}
+		}
+	}
+
+	#[test]
+	fn message_from_unknown_authority_discarded() {
+		assert!(cost::UNKNOWN_VOTER != cost::BAD_SIGNATURE);
+
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+		let set_id = 1;
+		let auth = AuthorityId::unchecked_from([1u8; 32]);
+		let peer = PeerId::random();
+
+		val.note_set(SetId(set_id), vec![auth.clone()], |_, _| {});
+		val.note_round(Round(1), |_, _| {});
+
+		let inner = val.inner.read();
+		let unknown_voter = inner.validate_round_message(
+			&peer,
+			&VoteMessage {
+				round: Round(1),
+				set_id: SetId(set_id),
+				message: SignedMessage::<Header> {
+					message: finality_grandpa::Message::Prevote(finality_grandpa::Prevote {
+						target_hash: Default::default(),
+						target_number: 10,
+					}),
+					signature: UncheckedFrom::unchecked_from([1; 64]),
+					id: UncheckedFrom::unchecked_from([2u8; 32]),
+				},
+			},
+		);
+
+		let bad_sig = inner.validate_round_message(
+			&peer,
+			&VoteMessage {
+				round: Round(1),
+				set_id: SetId(set_id),
+				message: SignedMessage::<Header> {
+					message: finality_grandpa::Message::Prevote(finality_grandpa::Prevote {
+						target_hash: Default::default(),
+						target_number: 10,
+					}),
+					signature: UncheckedFrom::unchecked_from([1; 64]),
+					id: auth.clone(),
+				},
+			},
+		);
+
+		assert_eq!(unknown_voter, Action::Discard(cost::UNKNOWN_VOTER));
+		assert_eq!(bad_sig, Action::Discard(cost::BAD_SIGNATURE));
+	}
+
+	#[test]
+	fn unsolicited_catch_up_messages_discarded() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		let set_id = 1;
+		let auth = AuthorityId::unchecked_from([1u8; 32]);
+		let peer = PeerId::random();
+
+		val.note_set(SetId(set_id), vec![auth.clone()], |_, _| {});
+		val.note_round(Round(1), |_, _| {});
+
+		let validate_catch_up = || {
+			let mut inner = val.inner.write();
+			inner.validate_catch_up_message(
+				&peer,
+				&FullCatchUpMessage {
+					set_id: SetId(set_id),
+					message: finality_grandpa::CatchUp {
+						round_number: 10,
+						prevotes: Default::default(),
+						precommits: Default::default(),
+						base_hash: Default::default(),
+						base_number: Default::default(),
+					},
+				},
+			)
+		};
+
+		// the catch up is discarded because we have no pending request
+		assert_eq!(validate_catch_up(), Action::Discard(cost::OUT_OF_SCOPE_MESSAGE));
+
+		let noted = val.inner.write().note_catch_up_request(
+			&peer,
+			&CatchUpRequestMessage { set_id: SetId(set_id), round: Round(10) },
+		);
+
+		assert!(noted.0);
+
+		// catch up is allowed because we have requested it, but it's rejected
+		// because it's malformed (empty prevotes and precommits)
+		assert_eq!(validate_catch_up(), Action::Discard(cost::MALFORMED_CATCH_UP));
+	}
+
+	#[test]
+	fn unanswerable_catch_up_requests_discarded() {
+		// create voter set state with round 2 completed
+		let set_state: SharedVoterSetState<Block> = {
+			let mut completed_rounds = voter_set_state().read().completed_rounds();
+
+			completed_rounds.push(environment::CompletedRound {
+				number: 2,
+				state: finality_grandpa::round::State::genesis(Default::default()),
+				base: Default::default(),
+				votes: Default::default(),
+			});
+
+			let mut current_rounds = environment::CurrentRounds::<Block>::new();
+			current_rounds.insert(3, environment::HasVoted::No);
+
+			let set_state =
+				environment::VoterSetState::<Block>::Live { completed_rounds, current_rounds };
+
+			set_state.into()
+		};
+
+		let (val, _) = GossipValidator::<Block>::new(config(), set_state.clone(), None, None);
+
+		let set_id = 1;
+		let auth = AuthorityId::unchecked_from([1u8; 32]);
+		let peer = PeerId::random();
+
+		val.note_set(SetId(set_id), vec![auth.clone()], |_, _| {});
+		val.note_round(Round(3), |_, _| {});
+
+		// add the peer making the request to the validator,
+		// otherwise it is discarded
+		let mut inner = val.inner.write();
+		inner.peers.new_peer(peer, ObservedRole::Authority);
+
+		let res = inner.handle_catch_up_request(
+			&peer,
+			CatchUpRequestMessage { set_id: SetId(set_id), round: Round(10) },
+			&set_state,
+		);
+
+		// we're at round 3, a catch up request for round 10 is out of scope
+		assert!(res.0.is_none());
+		assert_eq!(res.1, Action::Discard(cost::OUT_OF_SCOPE_MESSAGE));
+
+		let res = inner.handle_catch_up_request(
+			&peer,
+			CatchUpRequestMessage { set_id: SetId(set_id), round: Round(2) },
+			&set_state,
+		);
+
+		// a catch up request for round 2 should be answered successfully
+		match res.0.unwrap() {
+			GossipMessage::CatchUp(catch_up) => {
+				assert_eq!(catch_up.set_id, SetId(set_id));
+				assert_eq!(catch_up.message.round_number, 2);
+
+				assert_eq!(res.1, Action::Discard(cost::CATCH_UP_REPLY));
+			},
+			_ => panic!("expected catch up message"),
+		};
+	}
+
+	#[test]
+	fn detects_honest_out_of_scope_catch_requests() {
+		let set_state = voter_set_state();
+		let (val, _) = GossipValidator::<Block>::new(config(), set_state.clone(), None, None);
+
+		// the validator starts at set id 2
+		val.note_set(SetId(2), Vec::new(), |_, _| {});
+
+		// add the peer making the request to the validator,
+		// otherwise it is discarded
+		let peer = PeerId::random();
+		val.inner.write().peers.new_peer(peer, ObservedRole::Authority);
+
+		let send_request = |set_id, round| {
+			let mut inner = val.inner.write();
+			inner.handle_catch_up_request(
+				&peer,
+				CatchUpRequestMessage { set_id: SetId(set_id), round: Round(round) },
+				&set_state,
+			)
+		};
+
+		let assert_res = |res: (Option<_>, Action<_>), honest| {
+			assert!(res.0.is_none());
+			assert_eq!(
+				res.1,
+				if honest {
+					Action::Discard(cost::HONEST_OUT_OF_SCOPE_CATCH_UP)
+				} else {
+					Action::Discard(Misbehavior::OutOfScopeMessage.cost())
+				},
+			);
+		};
+
+		// the validator is at set id 2 and round 0. requests for set id 1
+		// should not be answered but they should be considered an honest
+		// mistake
+		assert_res(send_request(1, 1), true);
+
+		assert_res(send_request(1, 10), true);
+
+		// requests for set id 0 should be considered out of scope
+		assert_res(send_request(0, 1), false);
+
+		assert_res(send_request(0, 10), false);
+
+		// after the validator progresses further than CATCH_UP_THRESHOLD in set
+		// id 2, any request for set id 1 should no longer be considered an
+		// honest mistake.
+		val.note_round(Round(3), |_, _| {});
+
+		assert_res(send_request(1, 1), false);
+
+		assert_res(send_request(1, 2), false);
+	}
+
+	#[test]
+	fn issues_catch_up_request_on_neighbor_packet_import() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		// the validator starts at set id 1.
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		// add the peer making the request to the validator,
+		// otherwise it is discarded.
+		let peer = PeerId::random();
+		val.inner.write().peers.new_peer(peer, ObservedRole::Authority);
+
+		let import_neighbor_message = |set_id, round| {
+			let (_, _, catch_up_request, _) = val.inner.write().import_neighbor_message(
+				&peer,
+				NeighborPacket {
+					round: Round(round),
+					set_id: SetId(set_id),
+					commit_finalized_height: 42,
+				},
+			);
+
+			catch_up_request
+		};
+
+		// importing a neighbor message from a peer in the same set in a later
+		// round should lead to a catch up request for the previous round.
+		match import_neighbor_message(1, 42) {
+			Some(GossipMessage::CatchUpRequest(request)) => {
+				assert_eq!(request.set_id, SetId(1));
+				assert_eq!(request.round, Round(41));
+			},
+			_ => panic!("expected catch up message"),
+		}
+
+		// we note that we're at round 41.
+		val.note_round(Round(41), |_, _| {});
+
+		// if we import a neighbor message within CATCH_UP_THRESHOLD then we
+		// won't request a catch up.
+		match import_neighbor_message(1, 42) {
+			None => {},
+			_ => panic!("expected no catch up message"),
+		}
+
+		// or if the peer is on a lower round.
+		match import_neighbor_message(1, 40) {
+			None => {},
+			_ => panic!("expected no catch up message"),
+		}
+
+		// we also don't request a catch up if the peer is in a different set.
+		match import_neighbor_message(2, 42) {
+			None => {},
+			_ => panic!("expected no catch up message"),
+		}
+	}
+
+	#[test]
+	fn doesnt_send_catch_up_requests_when_disabled() {
+		// we create a gossip validator with catch up requests disabled.
+		let config = {
+			let mut c = config();
+
+			// if the observer protocol is enabled and we are not an authority,
+			// then we don't issue any catch-up requests.
+			c.local_role = Role::Full;
+			c.observer_enabled = true;
+
+			c
+		};
+
+		let (val, _) = GossipValidator::<Block>::new(config, voter_set_state(), None, None);
+
+		// the validator starts at set id 1.
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		// add the peer making the request to the validator,
+		// otherwise it is discarded.
+		let peer = PeerId::random();
+		val.inner.write().peers.new_peer(peer, ObservedRole::Authority);
+
+		// importing a neighbor message from a peer in the same set in a later
+		// round should lead to a catch up request but since they're disabled
+		// we should get `None`.
+		let (_, _, catch_up_request, _) = val.inner.write().import_neighbor_message(
+			&peer,
+			NeighborPacket { round: Round(42), set_id: SetId(1), commit_finalized_height: 50 },
+		);
+
+		match catch_up_request {
+			None => {},
+			_ => panic!("expected no catch up message"),
+		}
+	}
+
+	#[test]
+	fn doesnt_send_catch_up_requests_to_non_authorities_when_observer_enabled() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		// the validator starts at set id 1.
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		// add the peers making the requests to the validator,
+		// otherwise it is discarded.
+		let peer_authority = PeerId::random();
+		let peer_full = PeerId::random();
+
+		val.inner.write().peers.new_peer(peer_authority, ObservedRole::Authority);
+		val.inner.write().peers.new_peer(peer_full, ObservedRole::Full);
+
+		let import_neighbor_message = |peer| {
+			let (_, _, catch_up_request, _) = val.inner.write().import_neighbor_message(
+				&peer,
+				NeighborPacket { round: Round(42), set_id: SetId(1), commit_finalized_height: 50 },
+			);
+
+			catch_up_request
+		};
+
+		// importing a neighbor message from a peer in the same set in a later
+		// round should lead to a catch up request but since the node is not an
+		// authority we should get `None`.
+		if import_neighbor_message(peer_full).is_some() {
+			panic!("expected no catch up message");
+		}
+
+		// importing the same neighbor message from a peer who is an authority
+		// should lead to a catch up request.
+		match import_neighbor_message(peer_authority) {
+			Some(GossipMessage::CatchUpRequest(request)) => {
+				assert_eq!(request.set_id, SetId(1));
+				assert_eq!(request.round, Round(41));
+			},
+			_ => panic!("expected catch up message"),
+		}
+	}
+
+	#[test]
+	fn sends_catch_up_requests_to_non_authorities_when_observer_disabled() {
+		let config = {
+			let mut c = config();
+
+			// if the observer protocol is disable any full-node should be able
+			// to answer catch-up requests.
+			c.observer_enabled = false;
+
+			c
+		};
+
+		let (val, _) = GossipValidator::<Block>::new(config, voter_set_state(), None, None);
+
+		// the validator starts at set id 1.
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		// add the peer making the requests to the validator, otherwise it is
+		// discarded.
+		let peer_full = PeerId::random();
+		val.inner.write().peers.new_peer(peer_full, ObservedRole::Full);
+
+		let (_, _, catch_up_request, _) = val.inner.write().import_neighbor_message(
+			&peer_full,
+			NeighborPacket { round: Round(42), set_id: SetId(1), commit_finalized_height: 50 },
+		);
+
+		// importing a neighbor message from a peer in the same set in a later
+		// round should lead to a catch up request, the node is not an
+		// authority, but since the observer protocol is disabled we should
+		// issue a catch-up request to it anyway.
+		match catch_up_request {
+			Some(GossipMessage::CatchUpRequest(request)) => {
+				assert_eq!(request.set_id, SetId(1));
+				assert_eq!(request.round, Round(41));
+			},
+			_ => panic!("expected catch up message"),
+		}
+	}
+
+	#[test]
+	fn doesnt_expire_next_round_messages() {
+		// NOTE: this is a regression test
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		// the validator starts at set id 1.
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		// we are at round 10
+		val.note_round(Round(9), |_, _| {});
+		val.note_round(Round(10), |_, _| {});
+
+		let mut is_expired = val.message_expired();
+
+		// we accept messages from rounds 9, 10 and 11
+		// therefore neither of those should be considered expired
+		for round in &[9, 10, 11] {
+			assert!(!is_expired(communication::round_topic::<Block>(*round, 1), &[]))
+		}
+	}
+
+	#[test]
+	fn progressively_gossips_to_more_peers_as_round_duration_increases() {
+		let mut config = config();
+		config.gossip_duration = Duration::from_secs(300); // Set to high value to prevent test race
+		let round_duration = config.gossip_duration * ROUND_DURATION;
+
+		let (val, _) = GossipValidator::<Block>::new(config, voter_set_state(), None, None);
+
+		// the validator start at set id 0
+		val.note_set(SetId(0), Vec::new(), |_, _| {});
+
+		// add 60 peers, 30 authorities and 30 full nodes
+		let mut authorities = Vec::new();
+		authorities.resize_with(30, || PeerId::random());
+
+		let mut full_nodes = Vec::new();
+		full_nodes.resize_with(30, || PeerId::random());
+
+		for i in 0..30 {
+			val.inner.write().peers.new_peer(authorities[i], ObservedRole::Authority);
+
+			val.inner.write().peers.new_peer(full_nodes[i], ObservedRole::Full);
+		}
+
+		let test = |rounds_elapsed, peers| {
+			// rewind n round durations
+			val.inner.write().local_view.as_mut().unwrap().round_start = Instant::now() -
+				Duration::from_millis(
+					(round_duration.as_millis() as f32 * rounds_elapsed) as u64,
+				);
+
+			val.inner.write().peers.reshuffle();
+
+			let mut message_allowed = val.message_allowed();
+
+			move || {
+				let mut allowed = 0;
+				for peer in peers {
+					if message_allowed(
+						peer,
+						MessageIntent::Broadcast,
+						&communication::round_topic::<Block>(1, 0),
+						&[],
+					) {
+						allowed += 1;
+					}
+				}
+				allowed
+			}
+		};
+
+		fn trial<F: FnMut() -> usize>(mut test: F) -> usize {
+			let mut results = Vec::new();
+			let n = 1000;
+
+			for _ in 0..n {
+				results.push(test());
+			}
+
+			let n = results.len();
+			let sum: usize = results.iter().sum();
+
+			sum / n
+		}
+
+		let all_peers = authorities.iter().chain(full_nodes.iter()).cloned().collect();
+
+		// on the first attempt we will only gossip to 4 peers, either
+		// authorities or full nodes, but we'll guarantee that half of those
+		// are authorities
+		assert!(trial(test(1.0, &authorities)) >= LUCKY_PEERS / 2);
+		assert_eq!(trial(test(1.0, &all_peers)), LUCKY_PEERS);
+
+		// after more than 1.5 round durations have elapsed we should gossip to
+		// `sqrt(peers)` we're connected to, but we guarantee that at least 4 of
+		// those peers are authorities (plus the `LUCKY_PEERS` from the previous
+		// stage)
+		assert!(trial(test(PROPAGATION_SOME * 1.1, &authorities)) >= LUCKY_PEERS);
+		assert_eq!(
+			trial(test(2.0, &all_peers)),
+			LUCKY_PEERS + (all_peers.len() as f64).sqrt() as usize,
+		);
+
+		// after 3 rounds durations we should gossip to all peers we are
+		// connected to
+		assert_eq!(trial(test(PROPAGATION_ALL * 1.1, &all_peers)), all_peers.len());
+	}
+
+	#[test]
+	fn never_gossips_round_messages_to_light_clients() {
+		let config = config();
+		let round_duration = config.gossip_duration * ROUND_DURATION;
+		let (val, _) = GossipValidator::<Block>::new(config, voter_set_state(), None, None);
+
+		// the validator starts at set id 0
+		val.note_set(SetId(0), Vec::new(), |_, _| {});
+
+		// add a new light client as peer
+		let light_peer = PeerId::random();
+
+		val.inner.write().peers.new_peer(light_peer, ObservedRole::Light);
+
+		assert!(!val.message_allowed()(
+			&light_peer,
+			MessageIntent::Broadcast,
+			&communication::round_topic::<Block>(1, 0),
+			&[],
+		));
+
+		// we reverse the round start time so that the elapsed time is higher
+		// (which should lead to more peers getting the message)
+		val.inner.write().local_view.as_mut().unwrap().round_start =
+			Instant::now() - round_duration * 10;
+
+		// even after the round has been going for 10 round durations we will never
+		// gossip to light clients
+		assert!(!val.message_allowed()(
+			&light_peer,
+			MessageIntent::Broadcast,
+			&communication::round_topic::<Block>(1, 0),
+			&[],
+		));
+
+		// update the peer state and local state wrt commits
+		val.inner
+			.write()
+			.peers
+			.update_peer_state(
+				&light_peer,
+				NeighborPacket { round: Round(1), set_id: SetId(0), commit_finalized_height: 1 },
+			)
+			.unwrap();
+
+		val.note_commit_finalized(Round(1), SetId(0), 2, |_, _| {});
+
+		let commit = {
+			let commit = finality_grandpa::CompactCommit {
+				target_hash: H256::random(),
+				target_number: 2,
+				precommits: Vec::new(),
+				auth_data: Vec::new(),
+			};
+
+			communication::gossip::GossipMessage::<Block>::Commit(
+				communication::gossip::FullCommitMessage {
+					round: Round(2),
+					set_id: SetId(0),
+					message: commit,
+				},
+			)
+			.encode()
+		};
+
+		// global messages are gossiped to light clients though
+		assert!(val.message_allowed()(
+			&light_peer,
+			MessageIntent::Broadcast,
+			&communication::global_topic::<Block>(0),
+			&commit,
+		));
+	}
+
+	#[test]
+	fn only_gossip_commits_to_peers_on_same_set() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		// the validator starts at set id 1
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		// add a new peer at set id 1
+		let peer1 = PeerId::random();
+
+		val.inner.write().peers.new_peer(peer1, ObservedRole::Authority);
+
+		val.inner
+			.write()
+			.peers
+			.update_peer_state(
+				&peer1,
+				NeighborPacket { round: Round(1), set_id: SetId(1), commit_finalized_height: 1 },
+			)
+			.unwrap();
+
+		// peer2 will default to set id 0
+		let peer2 = PeerId::random();
+		val.inner.write().peers.new_peer(peer2, ObservedRole::Authority);
+
+		// create a commit for round 1 of set id 1
+		// targeting a block at height 2
+		let commit = {
+			let commit = finality_grandpa::CompactCommit {
+				target_hash: H256::random(),
+				target_number: 2,
+				precommits: Vec::new(),
+				auth_data: Vec::new(),
+			};
+
+			communication::gossip::GossipMessage::<Block>::Commit(
+				communication::gossip::FullCommitMessage {
+					round: Round(1),
+					set_id: SetId(1),
+					message: commit,
+				},
+			)
+			.encode()
+		};
+
+		// note the commit in the validator
+		val.note_commit_finalized(Round(1), SetId(1), 2, |_, _| {});
+
+		let mut message_allowed = val.message_allowed();
+
+		// the commit should be allowed to peer 1
+		assert!(message_allowed(
+			&peer1,
+			MessageIntent::Broadcast,
+			&communication::global_topic::<Block>(1),
+			&commit,
+		));
+
+		// but disallowed to peer 2 since the peer is on set id 0
+		// the commit should be allowed to peer 1
+		assert!(!message_allowed(
+			&peer2,
+			MessageIntent::Broadcast,
+			&communication::global_topic::<Block>(1),
+			&commit,
+		));
+	}
+
+	#[test]
+	fn expire_commits_from_older_rounds() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		let commit = |round, set_id, target_number| {
+			let commit = finality_grandpa::CompactCommit {
+				target_hash: H256::random(),
+				target_number,
+				precommits: Vec::new(),
+				auth_data: Vec::new(),
+			};
+
+			communication::gossip::GossipMessage::<Block>::Commit(
+				communication::gossip::FullCommitMessage {
+					round: Round(round),
+					set_id: SetId(set_id),
+					message: commit,
+				},
+			)
+			.encode()
+		};
+
+		// note the beginning of a new set with id 1
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		// note a commit for round 1 in the validator
+		// finalizing a block at height 2
+		val.note_commit_finalized(Round(1), SetId(1), 2, |_, _| {});
+
+		let mut message_expired = val.message_expired();
+
+		// a commit message for round 1 that finalizes the same height as we
+		// have observed previously should not be expired
+		assert!(!message_expired(communication::global_topic::<Block>(1), &commit(1, 1, 2),));
+
+		// it should be expired if it is for a lower block
+		assert!(message_expired(communication::global_topic::<Block>(1), &commit(1, 1, 1)));
+
+		// or the same block height but from the previous round
+		assert!(message_expired(communication::global_topic::<Block>(1), &commit(0, 1, 2)));
+	}
+
+	#[test]
+	fn allow_noting_different_authorities_for_same_set() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		let a1 = vec![UncheckedFrom::unchecked_from([0; 32])];
+		val.note_set(SetId(1), a1.clone(), |_, _| {});
+
+		assert_eq!(val.inner().read().authorities, a1);
+
+		let a2 =
+			vec![UncheckedFrom::unchecked_from([1; 32]), UncheckedFrom::unchecked_from([2; 32])];
+		val.note_set(SetId(1), a2.clone(), |_, _| {});
+
+		assert_eq!(val.inner().read().authorities, a2);
+	}
+
+	#[test]
+	fn sends_neighbor_packets_to_non_light_peers_when_starting_a_new_round() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		// initialize the validator to a stable set id
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		let authority_peer = PeerId::random();
+		let full_peer = PeerId::random();
+		let light_peer = PeerId::random();
+
+		val.inner.write().peers.new_peer(authority_peer, ObservedRole::Authority);
+		val.inner.write().peers.new_peer(full_peer, ObservedRole::Full);
+		val.inner.write().peers.new_peer(light_peer, ObservedRole::Light);
+
+		val.note_round(Round(2), |peers, message| {
+			assert_eq!(peers.len(), 2);
+			assert!(peers.contains(&authority_peer));
+			assert!(peers.contains(&full_peer));
+			assert!(!peers.contains(&light_peer));
+			assert!(matches!(message, NeighborPacket { set_id: SetId(1), round: Round(2), .. }));
+		});
+	}
+
+	#[test]
+	fn sends_neighbor_packets_to_all_peers_when_starting_a_new_set() {
+		let (val, _) = GossipValidator::<Block>::new(config(), voter_set_state(), None, None);
+
+		// initialize the validator to a stable set id
+		val.note_set(SetId(1), Vec::new(), |_, _| {});
+
+		let authority_peer = PeerId::random();
+		let full_peer = PeerId::random();
+		let light_peer = PeerId::random();
+
+		val.inner.write().peers.new_peer(authority_peer, ObservedRole::Authority);
+		val.inner.write().peers.new_peer(full_peer, ObservedRole::Full);
+		val.inner.write().peers.new_peer(light_peer, ObservedRole::Light);
+
+		val.note_set(SetId(2), Vec::new(), |peers, message| {
+			assert_eq!(peers.len(), 3);
+			assert!(peers.contains(&authority_peer));
+			assert!(peers.contains(&full_peer));
+			assert!(peers.contains(&light_peer));
+			assert!(matches!(message, NeighborPacket { set_id: SetId(2), round: Round(1), .. }));
+		});
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/communication/mod.rs b/substrate/client/consensus/grandpa/src/communication/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c0749858568f5a09bb25243de7c0c983fcecbd13
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/communication/mod.rs
@@ -0,0 +1,1104 @@
+// 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/>.
+
+//! Communication streams for the polite-grandpa networking protocol.
+//!
+//! GRANDPA nodes communicate over a gossip network, where messages are not sent to
+//! peers until they have reached a given round.
+//!
+//! Rather than expressing protocol rules,
+//! polite-grandpa just carries a notion of impoliteness. Nodes which pass some arbitrary
+//! threshold of impoliteness are removed. Messages are either costly, or beneficial.
+//!
+//! For instance, it is _impolite_ to send the same message more than once.
+//! In the future, there will be a fallback for allowing sending the same message
+//! under certain conditions that are used to un-stick the protocol.
+
+use futures::{channel::mpsc, prelude::*};
+use log::{debug, trace};
+use parking_lot::Mutex;
+use prometheus_endpoint::Registry;
+use std::{
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+use finality_grandpa::{
+	voter,
+	voter_set::VoterSet,
+	Message::{Precommit, Prevote, PrimaryPropose},
+};
+use parity_scale_codec::{Decode, DecodeAll, Encode};
+use sc_network::{NetworkBlock, NetworkSyncForkRequest, ReputationChange};
+use sc_network_gossip::{GossipEngine, Network as GossipNetwork};
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_INFO};
+use sp_keystore::KeystorePtr;
+use sp_runtime::traits::{Block as BlockT, Hash as HashT, Header as HeaderT, NumberFor};
+
+use crate::{
+	environment::HasVoted, CatchUp, Commit, CommunicationIn, CommunicationOutH, CompactCommit,
+	Error, Message, SignedMessage, LOG_TARGET,
+};
+use gossip::{
+	FullCatchUpMessage, FullCommitMessage, GossipMessage, GossipValidator, PeerReport, VoteMessage,
+};
+use sc_network_common::sync::SyncEventStream;
+use sc_utils::mpsc::TracingUnboundedReceiver;
+use sp_consensus_grandpa::{AuthorityId, AuthoritySignature, RoundNumber, SetId as SetIdNumber};
+
+pub mod gossip;
+mod periodic;
+
+#[cfg(test)]
+pub(crate) mod tests;
+
+// How often to rebroadcast neighbor packets, in cases where no new packets are created.
+pub(crate) const NEIGHBOR_REBROADCAST_PERIOD: Duration = Duration::from_secs(2 * 60);
+
+pub mod grandpa_protocol_name {
+	use sc_chain_spec::ChainSpec;
+	use sc_network::types::ProtocolName;
+
+	pub(crate) const NAME: &str = "/grandpa/1";
+	/// Old names for the notifications protocol, used for backward compatibility.
+	pub(crate) const LEGACY_NAMES: [&str; 1] = ["/paritytech/grandpa/1"];
+
+	/// Name of the notifications protocol used by GRANDPA.
+	///
+	/// Must be registered towards the networking in order for GRANDPA to properly function.
+	pub fn standard_name<Hash: AsRef<[u8]>>(
+		genesis_hash: &Hash,
+		chain_spec: &Box<dyn ChainSpec>,
+	) -> ProtocolName {
+		let genesis_hash = genesis_hash.as_ref();
+		let chain_prefix = match chain_spec.fork_id() {
+			Some(fork_id) => format!("/{}/{}", array_bytes::bytes2hex("", genesis_hash), fork_id),
+			None => format!("/{}", array_bytes::bytes2hex("", genesis_hash)),
+		};
+		format!("{}{}", chain_prefix, NAME).into()
+	}
+}
+
+// cost scalars for reporting peers.
+mod cost {
+	use sc_network::ReputationChange as Rep;
+	pub(super) const PAST_REJECTION: Rep = Rep::new(-50, "Grandpa: Past message");
+	pub(super) const BAD_SIGNATURE: Rep = Rep::new(-100, "Grandpa: Bad signature");
+	pub(super) const MALFORMED_CATCH_UP: Rep = Rep::new(-1000, "Grandpa: Malformed cath-up");
+	pub(super) const MALFORMED_COMMIT: Rep = Rep::new(-1000, "Grandpa: Malformed commit");
+	pub(super) const FUTURE_MESSAGE: Rep = Rep::new(-500, "Grandpa: Future message");
+	pub(super) const UNKNOWN_VOTER: Rep = Rep::new(-150, "Grandpa: Unknown voter");
+
+	pub(super) const INVALID_VIEW_CHANGE: Rep = Rep::new(-500, "Grandpa: Invalid view change");
+	pub(super) const DUPLICATE_NEIGHBOR_MESSAGE: Rep =
+		Rep::new(-500, "Grandpa: Duplicate neighbor message without grace period");
+	pub(super) const PER_UNDECODABLE_BYTE: i32 = -5;
+	pub(super) const PER_SIGNATURE_CHECKED: i32 = -25;
+	pub(super) const PER_BLOCK_LOADED: i32 = -10;
+	pub(super) const INVALID_CATCH_UP: Rep = Rep::new(-5000, "Grandpa: Invalid catch-up");
+	pub(super) const INVALID_COMMIT: Rep = Rep::new(-5000, "Grandpa: Invalid commit");
+	pub(super) const OUT_OF_SCOPE_MESSAGE: Rep = Rep::new(-500, "Grandpa: Out-of-scope message");
+	pub(super) const CATCH_UP_REQUEST_TIMEOUT: Rep =
+		Rep::new(-200, "Grandpa: Catch-up request timeout");
+
+	// cost of answering a catch up request
+	pub(super) const CATCH_UP_REPLY: Rep = Rep::new(-200, "Grandpa: Catch-up reply");
+	pub(super) const HONEST_OUT_OF_SCOPE_CATCH_UP: Rep =
+		Rep::new(-200, "Grandpa: Out-of-scope catch-up");
+}
+
+// benefit scalars for reporting peers.
+mod benefit {
+	use sc_network::ReputationChange as Rep;
+	pub(super) const NEIGHBOR_MESSAGE: Rep = Rep::new(100, "Grandpa: Neighbor message");
+	pub(super) const ROUND_MESSAGE: Rep = Rep::new(100, "Grandpa: Round message");
+	pub(super) const BASIC_VALIDATED_CATCH_UP: Rep = Rep::new(200, "Grandpa: Catch-up message");
+	pub(super) const BASIC_VALIDATED_COMMIT: Rep = Rep::new(100, "Grandpa: Commit");
+	pub(super) const PER_EQUIVOCATION: i32 = 10;
+}
+
+/// A type that ties together our local authority id and a keystore where it is
+/// available for signing.
+pub struct LocalIdKeystore((AuthorityId, KeystorePtr));
+
+impl LocalIdKeystore {
+	/// Returns a reference to our local authority id.
+	fn local_id(&self) -> &AuthorityId {
+		&(self.0).0
+	}
+
+	/// Returns a reference to the keystore.
+	fn keystore(&self) -> KeystorePtr {
+		(self.0).1.clone()
+	}
+}
+
+impl From<(AuthorityId, KeystorePtr)> for LocalIdKeystore {
+	fn from(inner: (AuthorityId, KeystorePtr)) -> LocalIdKeystore {
+		LocalIdKeystore(inner)
+	}
+}
+
+/// If the voter set is larger than this value some telemetry events are not
+/// sent to avoid increasing usage resource on the node and flooding the
+/// telemetry server (e.g. received votes, received commits.)
+const TELEMETRY_VOTERS_LIMIT: usize = 10;
+
+/// A handle to the network.
+///
+/// Something that provides the capabilities needed for the `gossip_network::Network` trait.
+pub trait Network<Block: BlockT>: GossipNetwork<Block> + Clone + Send + 'static {}
+
+impl<Block, T> Network<Block> for T
+where
+	Block: BlockT,
+	T: GossipNetwork<Block> + Clone + Send + 'static,
+{
+}
+
+/// A handle to syncing-related services.
+///
+/// Something that provides the ability to set a fork sync request for a particular block.
+pub trait Syncing<Block: BlockT>:
+	NetworkSyncForkRequest<Block::Hash, NumberFor<Block>>
+	+ NetworkBlock<Block::Hash, NumberFor<Block>>
+	+ SyncEventStream
+	+ Clone
+	+ Send
+	+ 'static
+{
+}
+
+impl<Block, T> Syncing<Block> for T
+where
+	Block: BlockT,
+	T: NetworkSyncForkRequest<Block::Hash, NumberFor<Block>>
+		+ NetworkBlock<Block::Hash, NumberFor<Block>>
+		+ SyncEventStream
+		+ Clone
+		+ Send
+		+ 'static,
+{
+}
+
+/// Create a unique topic for a round and set-id combo.
+pub(crate) fn round_topic<B: BlockT>(round: RoundNumber, set_id: SetIdNumber) -> B::Hash {
+	<<B::Header as HeaderT>::Hashing as HashT>::hash(format!("{}-{}", set_id, round).as_bytes())
+}
+
+/// Create a unique topic for global messages on a set ID.
+pub(crate) fn global_topic<B: BlockT>(set_id: SetIdNumber) -> B::Hash {
+	<<B::Header as HeaderT>::Hashing as HashT>::hash(format!("{}-GLOBAL", set_id).as_bytes())
+}
+
+/// Bridge between the underlying network service, gossiping consensus messages and Grandpa
+pub(crate) struct NetworkBridge<B: BlockT, N: Network<B>, S: Syncing<B>> {
+	service: N,
+	sync: S,
+	gossip_engine: Arc<Mutex<GossipEngine<B>>>,
+	validator: Arc<GossipValidator<B>>,
+
+	/// Sender side of the neighbor packet channel.
+	///
+	/// Packets sent into this channel are processed by the `NeighborPacketWorker` and passed on to
+	/// the underlying `GossipEngine`.
+	neighbor_sender: periodic::NeighborPacketSender<B>,
+
+	/// `NeighborPacketWorker` processing packets sent through the `NeighborPacketSender`.
+	// `NetworkBridge` is required to be cloneable, thus one needs to be able to clone its
+	// children, thus one has to wrap `neighbor_packet_worker` with an `Arc` `Mutex`.
+	neighbor_packet_worker: Arc<Mutex<periodic::NeighborPacketWorker<B>>>,
+
+	/// Receiver side of the peer report stream populated by the gossip validator, forwarded to the
+	/// gossip engine.
+	// `NetworkBridge` is required to be cloneable, thus one needs to be able to clone its
+	// children, thus one has to wrap gossip_validator_report_stream with an `Arc` `Mutex`. Given
+	// that it is just an `UnboundedReceiver`, one could also switch to a
+	// multi-producer-*multi*-consumer channel implementation.
+	gossip_validator_report_stream: Arc<Mutex<TracingUnboundedReceiver<PeerReport>>>,
+
+	telemetry: Option<TelemetryHandle>,
+}
+
+impl<B: BlockT, N: Network<B>, S: Syncing<B>> Unpin for NetworkBridge<B, N, S> {}
+
+impl<B: BlockT, N: Network<B>, S: Syncing<B>> NetworkBridge<B, N, S> {
+	/// Create a new NetworkBridge to the given NetworkService. Returns the service
+	/// handle.
+	/// On creation it will register previous rounds' votes with the gossip
+	/// service taken from the VoterSetState.
+	pub(crate) fn new(
+		service: N,
+		sync: S,
+		config: crate::Config,
+		set_state: crate::environment::SharedVoterSetState<B>,
+		prometheus_registry: Option<&Registry>,
+		telemetry: Option<TelemetryHandle>,
+	) -> Self {
+		let protocol = config.protocol_name.clone();
+		let (validator, report_stream) =
+			GossipValidator::new(config, set_state.clone(), prometheus_registry, telemetry.clone());
+
+		let validator = Arc::new(validator);
+		let gossip_engine = Arc::new(Mutex::new(GossipEngine::new(
+			service.clone(),
+			sync.clone(),
+			protocol,
+			validator.clone(),
+			prometheus_registry,
+		)));
+
+		{
+			// register all previous votes with the gossip service so that they're
+			// available to peers potentially stuck on a previous round.
+			let completed = set_state.read().completed_rounds();
+			let (set_id, voters) = completed.set_info();
+			validator.note_set(SetId(set_id), voters.to_vec(), |_, _| {});
+			for round in completed.iter() {
+				let topic = round_topic::<B>(round.number, set_id);
+
+				// we need to note the round with the gossip validator otherwise
+				// messages will be ignored.
+				validator.note_round(Round(round.number), |_, _| {});
+
+				for signed in round.votes.iter() {
+					let message = gossip::GossipMessage::Vote(gossip::VoteMessage::<B> {
+						message: signed.clone(),
+						round: Round(round.number),
+						set_id: SetId(set_id),
+					});
+
+					gossip_engine.lock().register_gossip_message(topic, message.encode());
+				}
+
+				trace!(
+					target: LOG_TARGET,
+					"Registered {} messages for topic {:?} (round: {}, set_id: {})",
+					round.votes.len(),
+					topic,
+					round.number,
+					set_id,
+				);
+			}
+		}
+
+		let (neighbor_packet_worker, neighbor_packet_sender) =
+			periodic::NeighborPacketWorker::new(NEIGHBOR_REBROADCAST_PERIOD);
+
+		NetworkBridge {
+			service,
+			sync,
+			gossip_engine,
+			validator,
+			neighbor_sender: neighbor_packet_sender,
+			neighbor_packet_worker: Arc::new(Mutex::new(neighbor_packet_worker)),
+			gossip_validator_report_stream: Arc::new(Mutex::new(report_stream)),
+			telemetry,
+		}
+	}
+
+	/// Note the beginning of a new round to the `GossipValidator`.
+	pub(crate) fn note_round(&self, round: Round, set_id: SetId, voters: &VoterSet<AuthorityId>) {
+		// is a no-op if currently in that set.
+		self.validator.note_set(
+			set_id,
+			voters.iter().map(|(v, _)| v.clone()).collect(),
+			|to, neighbor| self.neighbor_sender.send(to, neighbor),
+		);
+
+		self.validator
+			.note_round(round, |to, neighbor| self.neighbor_sender.send(to, neighbor));
+	}
+
+	/// Get a stream of signature-checked round messages from the network as well as a sink for
+	/// round messages to the network all within the current set.
+	pub(crate) fn round_communication(
+		&self,
+		keystore: Option<LocalIdKeystore>,
+		round: Round,
+		set_id: SetId,
+		voters: Arc<VoterSet<AuthorityId>>,
+		has_voted: HasVoted<B::Header>,
+	) -> (impl Stream<Item = SignedMessage<B::Header>> + Unpin, OutgoingMessages<B>) {
+		self.note_round(round, set_id, &voters);
+
+		let keystore = keystore.and_then(|ks| {
+			let id = ks.local_id();
+			if voters.contains(id) {
+				Some(ks)
+			} else {
+				None
+			}
+		});
+
+		let topic = round_topic::<B>(round.0, set_id.0);
+		let telemetry = self.telemetry.clone();
+		let incoming =
+			self.gossip_engine.lock().messages_for(topic).filter_map(move |notification| {
+				let decoded = GossipMessage::<B>::decode_all(&mut &notification.message[..]);
+
+				match decoded {
+					Err(ref e) => {
+						debug!(
+							target: LOG_TARGET,
+							"Skipping malformed message {:?}: {}", notification, e
+						);
+						future::ready(None)
+					},
+					Ok(GossipMessage::Vote(msg)) => {
+						// check signature.
+						if !voters.contains(&msg.message.id) {
+							debug!(
+								target: LOG_TARGET,
+								"Skipping message from unknown voter {}", msg.message.id
+							);
+							return future::ready(None)
+						}
+
+						if voters.len().get() <= TELEMETRY_VOTERS_LIMIT {
+							match &msg.message.message {
+								PrimaryPropose(propose) => {
+									telemetry!(
+										telemetry;
+										CONSENSUS_INFO;
+										"afg.received_propose";
+										"voter" => ?format!("{}", msg.message.id),
+										"target_number" => ?propose.target_number,
+										"target_hash" => ?propose.target_hash,
+									);
+								},
+								Prevote(prevote) => {
+									telemetry!(
+										telemetry;
+										CONSENSUS_INFO;
+										"afg.received_prevote";
+										"voter" => ?format!("{}", msg.message.id),
+										"target_number" => ?prevote.target_number,
+										"target_hash" => ?prevote.target_hash,
+									);
+								},
+								Precommit(precommit) => {
+									telemetry!(
+										telemetry;
+										CONSENSUS_INFO;
+										"afg.received_precommit";
+										"voter" => ?format!("{}", msg.message.id),
+										"target_number" => ?precommit.target_number,
+										"target_hash" => ?precommit.target_hash,
+									);
+								},
+							};
+						}
+
+						future::ready(Some(msg.message))
+					},
+					_ => {
+						debug!(target: LOG_TARGET, "Skipping unknown message type");
+						future::ready(None)
+					},
+				}
+			});
+
+		let (tx, out_rx) = mpsc::channel(0);
+		let outgoing = OutgoingMessages::<B> {
+			keystore,
+			round: round.0,
+			set_id: set_id.0,
+			network: self.gossip_engine.clone(),
+			sender: tx,
+			has_voted,
+			telemetry: self.telemetry.clone(),
+		};
+
+		// Combine incoming votes from external GRANDPA nodes with outgoing
+		// votes from our own GRANDPA voter to have a single
+		// vote-import-pipeline.
+		let incoming = stream::select(incoming, out_rx);
+
+		(incoming, outgoing)
+	}
+
+	/// Set up the global communication streams.
+	pub(crate) fn global_communication(
+		&self,
+		set_id: SetId,
+		voters: Arc<VoterSet<AuthorityId>>,
+		is_voter: bool,
+	) -> (
+		impl Stream<Item = CommunicationIn<B>>,
+		impl Sink<CommunicationOutH<B, B::Hash>, Error = Error> + Unpin,
+	) {
+		self.validator.note_set(
+			set_id,
+			voters.iter().map(|(v, _)| v.clone()).collect(),
+			|to, neighbor| self.neighbor_sender.send(to, neighbor),
+		);
+
+		let topic = global_topic::<B>(set_id.0);
+		let incoming = incoming_global(
+			self.gossip_engine.clone(),
+			topic,
+			voters,
+			self.validator.clone(),
+			self.neighbor_sender.clone(),
+			self.telemetry.clone(),
+		);
+
+		let outgoing = CommitsOut::<B>::new(
+			self.gossip_engine.clone(),
+			set_id.0,
+			is_voter,
+			self.validator.clone(),
+			self.neighbor_sender.clone(),
+			self.telemetry.clone(),
+		);
+
+		let outgoing = outgoing.with(|out| {
+			let voter::CommunicationOut::Commit(round, commit) = out;
+			future::ok((round, commit))
+		});
+
+		(incoming, outgoing)
+	}
+
+	/// Notifies the sync service to try and sync the given block from the given
+	/// peers.
+	///
+	/// If the given vector of peers is empty then the underlying implementation
+	/// should make a best effort to fetch the block from any peers it is
+	/// connected to (NOTE: this assumption will change in the future #3629).
+	pub(crate) fn set_sync_fork_request(
+		&self,
+		peers: Vec<sc_network::PeerId>,
+		hash: B::Hash,
+		number: NumberFor<B>,
+	) {
+		self.sync.set_sync_fork_request(peers, hash, number)
+	}
+}
+
+impl<B: BlockT, N: Network<B>, S: Syncing<B>> Future for NetworkBridge<B, N, S> {
+	type Output = Result<(), Error>;
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		loop {
+			match self.neighbor_packet_worker.lock().poll_next_unpin(cx) {
+				Poll::Ready(Some((to, packet))) => {
+					self.gossip_engine.lock().send_message(to, packet.encode());
+				},
+				Poll::Ready(None) =>
+					return Poll::Ready(Err(Error::Network(
+						"Neighbor packet worker stream closed.".into(),
+					))),
+				Poll::Pending => break,
+			}
+		}
+
+		loop {
+			match self.gossip_validator_report_stream.lock().poll_next_unpin(cx) {
+				Poll::Ready(Some(PeerReport { who, cost_benefit })) => {
+					self.gossip_engine.lock().report(who, cost_benefit);
+				},
+				Poll::Ready(None) =>
+					return Poll::Ready(Err(Error::Network(
+						"Gossip validator report stream closed.".into(),
+					))),
+				Poll::Pending => break,
+			}
+		}
+
+		match self.gossip_engine.lock().poll_unpin(cx) {
+			Poll::Ready(()) =>
+				return Poll::Ready(Err(Error::Network("Gossip engine future finished.".into()))),
+			Poll::Pending => {},
+		}
+
+		Poll::Pending
+	}
+}
+
+fn incoming_global<B: BlockT>(
+	gossip_engine: Arc<Mutex<GossipEngine<B>>>,
+	topic: B::Hash,
+	voters: Arc<VoterSet<AuthorityId>>,
+	gossip_validator: Arc<GossipValidator<B>>,
+	neighbor_sender: periodic::NeighborPacketSender<B>,
+	telemetry: Option<TelemetryHandle>,
+) -> impl Stream<Item = CommunicationIn<B>> {
+	let process_commit = {
+		let telemetry = telemetry.clone();
+		move |msg: FullCommitMessage<B>,
+		      mut notification: sc_network_gossip::TopicNotification,
+		      gossip_engine: &Arc<Mutex<GossipEngine<B>>>,
+		      gossip_validator: &Arc<GossipValidator<B>>,
+		      voters: &VoterSet<AuthorityId>| {
+			if voters.len().get() <= TELEMETRY_VOTERS_LIMIT {
+				let precommits_signed_by: Vec<String> =
+					msg.message.auth_data.iter().map(move |(_, a)| format!("{}", a)).collect();
+
+				telemetry!(
+					telemetry;
+					CONSENSUS_INFO;
+					"afg.received_commit";
+					"contains_precommits_signed_by" => ?precommits_signed_by,
+					"target_number" => ?msg.message.target_number.clone(),
+					"target_hash" => ?msg.message.target_hash.clone(),
+				);
+			}
+
+			if let Err(cost) = check_compact_commit::<B>(
+				&msg.message,
+				voters,
+				msg.round,
+				msg.set_id,
+				telemetry.as_ref(),
+			) {
+				if let Some(who) = notification.sender {
+					gossip_engine.lock().report(who, cost);
+				}
+
+				return None
+			}
+
+			let round = msg.round;
+			let set_id = msg.set_id;
+			let commit = msg.message;
+			let finalized_number = commit.target_number;
+			let gossip_validator = gossip_validator.clone();
+			let gossip_engine = gossip_engine.clone();
+			let neighbor_sender = neighbor_sender.clone();
+			let cb = move |outcome| match outcome {
+				voter::CommitProcessingOutcome::Good(_) => {
+					// if it checks out, gossip it. not accounting for
+					// any discrepancy between the actual ghost and the claimed
+					// finalized number.
+					gossip_validator.note_commit_finalized(
+						round,
+						set_id,
+						finalized_number,
+						|to, neighbor| neighbor_sender.send(to, neighbor),
+					);
+
+					gossip_engine.lock().gossip_message(topic, notification.message.clone(), false);
+				},
+				voter::CommitProcessingOutcome::Bad(_) => {
+					// report peer and do not gossip.
+					if let Some(who) = notification.sender.take() {
+						gossip_engine.lock().report(who, cost::INVALID_COMMIT);
+					}
+				},
+			};
+
+			let cb = voter::Callback::Work(Box::new(cb));
+
+			Some(voter::CommunicationIn::Commit(round.0, commit, cb))
+		}
+	};
+
+	let process_catch_up = move |msg: FullCatchUpMessage<B>,
+	                             mut notification: sc_network_gossip::TopicNotification,
+	                             gossip_engine: &Arc<Mutex<GossipEngine<B>>>,
+	                             gossip_validator: &Arc<GossipValidator<B>>,
+	                             voters: &VoterSet<AuthorityId>| {
+		let gossip_validator = gossip_validator.clone();
+		let gossip_engine = gossip_engine.clone();
+
+		if let Err(cost) = check_catch_up::<B>(&msg.message, voters, msg.set_id, telemetry.clone())
+		{
+			if let Some(who) = notification.sender {
+				gossip_engine.lock().report(who, cost);
+			}
+
+			return None
+		}
+
+		let cb = move |outcome| {
+			if let voter::CatchUpProcessingOutcome::Bad(_) = outcome {
+				// report peer
+				if let Some(who) = notification.sender.take() {
+					gossip_engine.lock().report(who, cost::INVALID_CATCH_UP);
+				}
+			}
+
+			gossip_validator.note_catch_up_message_processed();
+		};
+
+		let cb = voter::Callback::Work(Box::new(cb));
+
+		Some(voter::CommunicationIn::CatchUp(msg.message, cb))
+	};
+
+	gossip_engine
+		.clone()
+		.lock()
+		.messages_for(topic)
+		.filter_map(|notification| {
+			// this could be optimized by decoding piecewise.
+			let decoded = GossipMessage::<B>::decode_all(&mut &notification.message[..]);
+			if let Err(ref e) = decoded {
+				trace!(
+					target: LOG_TARGET,
+					"Skipping malformed commit message {:?}: {}",
+					notification,
+					e
+				);
+			}
+			future::ready(decoded.map(move |d| (notification, d)).ok())
+		})
+		.filter_map(move |(notification, msg)| {
+			future::ready(match msg {
+				GossipMessage::Commit(msg) =>
+					process_commit(msg, notification, &gossip_engine, &gossip_validator, &voters),
+				GossipMessage::CatchUp(msg) =>
+					process_catch_up(msg, notification, &gossip_engine, &gossip_validator, &voters),
+				_ => {
+					debug!(target: LOG_TARGET, "Skipping unknown message type");
+					None
+				},
+			})
+		})
+}
+
+impl<B: BlockT, N: Network<B>, S: Syncing<B>> Clone for NetworkBridge<B, N, S> {
+	fn clone(&self) -> Self {
+		NetworkBridge {
+			service: self.service.clone(),
+			sync: self.sync.clone(),
+			gossip_engine: self.gossip_engine.clone(),
+			validator: Arc::clone(&self.validator),
+			neighbor_sender: self.neighbor_sender.clone(),
+			neighbor_packet_worker: self.neighbor_packet_worker.clone(),
+			gossip_validator_report_stream: self.gossip_validator_report_stream.clone(),
+			telemetry: self.telemetry.clone(),
+		}
+	}
+}
+
+/// Type-safe wrapper around a round number.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Encode, Decode)]
+pub struct Round(pub RoundNumber);
+
+/// Type-safe wrapper around a set ID.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Encode, Decode)]
+pub struct SetId(pub SetIdNumber);
+
+/// A sink for outgoing messages to the network. Any messages that are sent will
+/// be replaced, as appropriate, according to the given `HasVoted`.
+/// NOTE: The votes are stored unsigned, which means that the signatures need to
+/// be "stable", i.e. we should end up with the exact same signed message if we
+/// use the same raw message and key to sign. This is currently true for
+/// `ed25519` and `BLS` signatures (which we might use in the future), care must
+/// be taken when switching to different key types.
+pub(crate) struct OutgoingMessages<Block: BlockT> {
+	round: RoundNumber,
+	set_id: SetIdNumber,
+	keystore: Option<LocalIdKeystore>,
+	sender: mpsc::Sender<SignedMessage<Block::Header>>,
+	network: Arc<Mutex<GossipEngine<Block>>>,
+	has_voted: HasVoted<Block::Header>,
+	telemetry: Option<TelemetryHandle>,
+}
+
+impl<B: BlockT> Unpin for OutgoingMessages<B> {}
+
+impl<Block: BlockT> Sink<Message<Block::Header>> for OutgoingMessages<Block> {
+	type Error = Error;
+
+	fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		Sink::poll_ready(Pin::new(&mut self.sender), cx).map(|elem| {
+			elem.map_err(|e| {
+				Error::Network(format!("Failed to poll_ready channel sender: {:?}", e))
+			})
+		})
+	}
+
+	fn start_send(
+		mut self: Pin<&mut Self>,
+		mut msg: Message<Block::Header>,
+	) -> Result<(), Self::Error> {
+		// if we've voted on this round previously under the same key, send that vote instead
+		match &mut msg {
+			finality_grandpa::Message::PrimaryPropose(ref mut vote) => {
+				if let Some(propose) = self.has_voted.propose() {
+					*vote = propose.clone();
+				}
+			},
+			finality_grandpa::Message::Prevote(ref mut vote) => {
+				if let Some(prevote) = self.has_voted.prevote() {
+					*vote = prevote.clone();
+				}
+			},
+			finality_grandpa::Message::Precommit(ref mut vote) => {
+				if let Some(precommit) = self.has_voted.precommit() {
+					*vote = precommit.clone();
+				}
+			},
+		}
+
+		// when locals exist, sign messages on import
+		if let Some(ref keystore) = self.keystore {
+			let target_hash = *(msg.target().0);
+			let signed = sp_consensus_grandpa::sign_message(
+				keystore.keystore(),
+				msg,
+				keystore.local_id().clone(),
+				self.round,
+				self.set_id,
+			)
+			.ok_or_else(|| {
+				Error::Signing(format!(
+					"Failed to sign GRANDPA vote for round {} targetting {:?}",
+					self.round, target_hash
+				))
+			})?;
+
+			let message = GossipMessage::Vote(VoteMessage::<Block> {
+				message: signed.clone(),
+				round: Round(self.round),
+				set_id: SetId(self.set_id),
+			});
+
+			debug!(
+				target: LOG_TARGET,
+				"Announcing block {} to peers which we voted on in round {} in set {}",
+				target_hash,
+				self.round,
+				self.set_id,
+			);
+
+			telemetry!(
+				self.telemetry;
+				CONSENSUS_DEBUG;
+				"afg.announcing_blocks_to_voted_peers";
+				"block" => ?target_hash, "round" => ?self.round, "set_id" => ?self.set_id,
+			);
+
+			// announce the block we voted on to our peers.
+			self.network.lock().announce(target_hash, None);
+
+			// propagate the message to peers
+			let topic = round_topic::<Block>(self.round, self.set_id);
+			self.network.lock().gossip_message(topic, message.encode(), false);
+
+			// forward the message to the inner sender.
+			return self.sender.start_send(signed).map_err(|e| {
+				Error::Network(format!("Failed to start_send on channel sender: {:?}", e))
+			})
+		};
+
+		Ok(())
+	}
+
+	fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		Poll::Ready(Ok(()))
+	}
+
+	fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		Sink::poll_close(Pin::new(&mut self.sender), cx).map(|elem| {
+			elem.map_err(|e| {
+				Error::Network(format!("Failed to poll_close channel sender: {:?}", e))
+			})
+		})
+	}
+}
+
+// checks a compact commit. returns the cost associated with processing it if
+// the commit was bad.
+fn check_compact_commit<Block: BlockT>(
+	msg: &CompactCommit<Block::Header>,
+	voters: &VoterSet<AuthorityId>,
+	round: Round,
+	set_id: SetId,
+	telemetry: Option<&TelemetryHandle>,
+) -> Result<(), ReputationChange> {
+	// 4f + 1 = equivocations from f voters.
+	let f = voters.total_weight() - voters.threshold();
+	let full_threshold = (f + voters.total_weight()).0;
+
+	// check total weight is not out of range.
+	let mut total_weight = 0;
+	for (_, ref id) in &msg.auth_data {
+		if let Some(weight) = voters.get(id).map(|info| info.weight()) {
+			total_weight += weight.get();
+			if total_weight > full_threshold {
+				return Err(cost::MALFORMED_COMMIT)
+			}
+		} else {
+			debug!(target: LOG_TARGET, "Skipping commit containing unknown voter {}", id);
+			return Err(cost::MALFORMED_COMMIT)
+		}
+	}
+
+	if total_weight < voters.threshold().get() {
+		return Err(cost::MALFORMED_COMMIT)
+	}
+
+	// check signatures on all contained precommits.
+	let mut buf = Vec::new();
+	for (i, (precommit, (sig, id))) in msg.precommits.iter().zip(&msg.auth_data).enumerate() {
+		use crate::communication::gossip::Misbehavior;
+		use finality_grandpa::Message as GrandpaMessage;
+
+		if !sp_consensus_grandpa::check_message_signature_with_buffer(
+			&GrandpaMessage::Precommit(precommit.clone()),
+			id,
+			sig,
+			round.0,
+			set_id.0,
+			&mut buf,
+		) {
+			debug!(target: LOG_TARGET, "Bad commit message signature {}", id);
+			telemetry!(
+				telemetry;
+				CONSENSUS_DEBUG;
+				"afg.bad_commit_msg_signature";
+				"id" => ?id,
+			);
+			let cost = Misbehavior::BadCommitMessage {
+				signatures_checked: i as i32,
+				blocks_loaded: 0,
+				equivocations_caught: 0,
+			}
+			.cost();
+
+			return Err(cost)
+		}
+	}
+
+	Ok(())
+}
+
+// checks a catch up. returns the cost associated with processing it if
+// the catch up was bad.
+fn check_catch_up<Block: BlockT>(
+	msg: &CatchUp<Block::Header>,
+	voters: &VoterSet<AuthorityId>,
+	set_id: SetId,
+	telemetry: Option<TelemetryHandle>,
+) -> Result<(), ReputationChange> {
+	// 4f + 1 = equivocations from f voters.
+	let f = voters.total_weight() - voters.threshold();
+	let full_threshold = (f + voters.total_weight()).0;
+
+	// check total weight is not out of range for a set of votes.
+	fn check_weight<'a>(
+		voters: &'a VoterSet<AuthorityId>,
+		votes: impl Iterator<Item = &'a AuthorityId>,
+		full_threshold: u64,
+	) -> Result<(), ReputationChange> {
+		let mut total_weight = 0;
+
+		for id in votes {
+			if let Some(weight) = voters.get(id).map(|info| info.weight()) {
+				total_weight += weight.get();
+				if total_weight > full_threshold {
+					return Err(cost::MALFORMED_CATCH_UP)
+				}
+			} else {
+				debug!(
+					target: LOG_TARGET,
+					"Skipping catch up message containing unknown voter {}", id
+				);
+				return Err(cost::MALFORMED_CATCH_UP)
+			}
+		}
+
+		if total_weight < voters.threshold().get() {
+			return Err(cost::MALFORMED_CATCH_UP)
+		}
+
+		Ok(())
+	}
+
+	check_weight(voters, msg.prevotes.iter().map(|vote| &vote.id), full_threshold)?;
+
+	check_weight(voters, msg.precommits.iter().map(|vote| &vote.id), full_threshold)?;
+
+	fn check_signatures<'a, B, I>(
+		messages: I,
+		round: RoundNumber,
+		set_id: SetIdNumber,
+		mut signatures_checked: usize,
+		buf: &mut Vec<u8>,
+		telemetry: Option<TelemetryHandle>,
+	) -> Result<usize, ReputationChange>
+	where
+		B: BlockT,
+		I: Iterator<Item = (Message<B::Header>, &'a AuthorityId, &'a AuthoritySignature)>,
+	{
+		use crate::communication::gossip::Misbehavior;
+
+		for (msg, id, sig) in messages {
+			signatures_checked += 1;
+
+			if !sp_consensus_grandpa::check_message_signature_with_buffer(
+				&msg, id, sig, round, set_id, buf,
+			) {
+				debug!(target: LOG_TARGET, "Bad catch up message signature {}", id);
+				telemetry!(
+					telemetry;
+					CONSENSUS_DEBUG;
+					"afg.bad_catch_up_msg_signature";
+					"id" => ?id,
+				);
+
+				let cost = Misbehavior::BadCatchUpMessage {
+					signatures_checked: signatures_checked as i32,
+				}
+				.cost();
+
+				return Err(cost)
+			}
+		}
+
+		Ok(signatures_checked)
+	}
+
+	let mut buf = Vec::new();
+
+	// check signatures on all contained prevotes.
+	let signatures_checked = check_signatures::<Block, _>(
+		msg.prevotes.iter().map(|vote| {
+			(finality_grandpa::Message::Prevote(vote.prevote.clone()), &vote.id, &vote.signature)
+		}),
+		msg.round_number,
+		set_id.0,
+		0,
+		&mut buf,
+		telemetry.clone(),
+	)?;
+
+	// check signatures on all contained precommits.
+	let _ = check_signatures::<Block, _>(
+		msg.precommits.iter().map(|vote| {
+			(
+				finality_grandpa::Message::Precommit(vote.precommit.clone()),
+				&vote.id,
+				&vote.signature,
+			)
+		}),
+		msg.round_number,
+		set_id.0,
+		signatures_checked,
+		&mut buf,
+		telemetry,
+	)?;
+
+	Ok(())
+}
+
+/// An output sink for commit messages.
+struct CommitsOut<Block: BlockT> {
+	network: Arc<Mutex<GossipEngine<Block>>>,
+	set_id: SetId,
+	is_voter: bool,
+	gossip_validator: Arc<GossipValidator<Block>>,
+	neighbor_sender: periodic::NeighborPacketSender<Block>,
+	telemetry: Option<TelemetryHandle>,
+}
+
+impl<Block: BlockT> CommitsOut<Block> {
+	/// Create a new commit output stream.
+	pub(crate) fn new(
+		network: Arc<Mutex<GossipEngine<Block>>>,
+		set_id: SetIdNumber,
+		is_voter: bool,
+		gossip_validator: Arc<GossipValidator<Block>>,
+		neighbor_sender: periodic::NeighborPacketSender<Block>,
+		telemetry: Option<TelemetryHandle>,
+	) -> Self {
+		CommitsOut {
+			network,
+			set_id: SetId(set_id),
+			is_voter,
+			gossip_validator,
+			neighbor_sender,
+			telemetry,
+		}
+	}
+}
+
+impl<Block: BlockT> Sink<(RoundNumber, Commit<Block::Header>)> for CommitsOut<Block> {
+	type Error = Error;
+
+	fn poll_ready(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+		Poll::Ready(Ok(()))
+	}
+
+	fn start_send(
+		self: Pin<&mut Self>,
+		input: (RoundNumber, Commit<Block::Header>),
+	) -> Result<(), Self::Error> {
+		if !self.is_voter {
+			return Ok(())
+		}
+
+		let (round, commit) = input;
+		let round = Round(round);
+
+		telemetry!(
+			self.telemetry;
+			CONSENSUS_DEBUG;
+			"afg.commit_issued";
+			"target_number" => ?commit.target_number,
+			"target_hash" => ?commit.target_hash,
+		);
+		let (precommits, auth_data) = commit
+			.precommits
+			.into_iter()
+			.map(|signed| (signed.precommit, (signed.signature, signed.id)))
+			.unzip();
+
+		let compact_commit = CompactCommit::<Block::Header> {
+			target_hash: commit.target_hash,
+			target_number: commit.target_number,
+			precommits,
+			auth_data,
+		};
+
+		let message = GossipMessage::Commit(FullCommitMessage::<Block> {
+			round,
+			set_id: self.set_id,
+			message: compact_commit,
+		});
+
+		let topic = global_topic::<Block>(self.set_id.0);
+
+		// the gossip validator needs to be made aware of the best commit-height we know of
+		// before gossiping
+		self.gossip_validator.note_commit_finalized(
+			round,
+			self.set_id,
+			commit.target_number,
+			|to, neighbor| self.neighbor_sender.send(to, neighbor),
+		);
+		self.network.lock().gossip_message(topic, message.encode(), false);
+
+		Ok(())
+	}
+
+	fn poll_close(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+		Poll::Ready(Ok(()))
+	}
+
+	fn poll_flush(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+		Poll::Ready(Ok(()))
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/communication/periodic.rs b/substrate/client/consensus/grandpa/src/communication/periodic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..daa752920287971ee986ae5c65fb995b52187495
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/communication/periodic.rs
@@ -0,0 +1,119 @@
+// 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/>.
+
+//! Periodic rebroadcast of neighbor packets.
+
+use futures::{future::FutureExt as _, prelude::*, ready, stream::Stream};
+use futures_timer::Delay;
+use log::debug;
+use std::{
+	pin::Pin,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+use sc_network::PeerId;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use super::gossip::{GossipMessage, NeighborPacket};
+use crate::LOG_TARGET;
+
+/// A sender used to send neighbor packets to a background job.
+#[derive(Clone)]
+pub(super) struct NeighborPacketSender<B: BlockT>(
+	TracingUnboundedSender<(Vec<PeerId>, NeighborPacket<NumberFor<B>>)>,
+);
+
+impl<B: BlockT> NeighborPacketSender<B> {
+	/// Send a neighbor packet for the background worker to gossip to peers.
+	pub fn send(
+		&self,
+		who: Vec<sc_network::PeerId>,
+		neighbor_packet: NeighborPacket<NumberFor<B>>,
+	) {
+		if let Err(err) = self.0.unbounded_send((who, neighbor_packet)) {
+			debug!(target: LOG_TARGET, "Failed to send neighbor packet: {:?}", err);
+		}
+	}
+}
+
+/// NeighborPacketWorker is listening on a channel for new neighbor packets being produced by
+/// components within `finality-grandpa` and forwards those packets to the underlying
+/// `NetworkEngine` through the `NetworkBridge` that it is being polled by (see `Stream`
+/// implementation). Periodically it sends out the last packet in cases where no new ones arrive.
+pub(super) struct NeighborPacketWorker<B: BlockT> {
+	last: Option<(Vec<PeerId>, NeighborPacket<NumberFor<B>>)>,
+	rebroadcast_period: Duration,
+	delay: Delay,
+	rx: TracingUnboundedReceiver<(Vec<PeerId>, NeighborPacket<NumberFor<B>>)>,
+}
+
+impl<B: BlockT> Unpin for NeighborPacketWorker<B> {}
+
+impl<B: BlockT> NeighborPacketWorker<B> {
+	pub(super) fn new(rebroadcast_period: Duration) -> (Self, NeighborPacketSender<B>) {
+		let (tx, rx) = tracing_unbounded::<(Vec<PeerId>, NeighborPacket<NumberFor<B>>)>(
+			"mpsc_grandpa_neighbor_packet_worker",
+			100_000,
+		);
+		let delay = Delay::new(rebroadcast_period);
+
+		(
+			NeighborPacketWorker { last: None, rebroadcast_period, delay, rx },
+			NeighborPacketSender(tx),
+		)
+	}
+}
+
+impl<B: BlockT> Stream for NeighborPacketWorker<B> {
+	type Item = (Vec<PeerId>, GossipMessage<B>);
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		let this = &mut *self;
+		match this.rx.poll_next_unpin(cx) {
+			Poll::Ready(None) => return Poll::Ready(None),
+			Poll::Ready(Some((to, packet))) => {
+				this.delay.reset(this.rebroadcast_period);
+				this.last = Some((to.clone(), packet.clone()));
+
+				return Poll::Ready(Some((to, GossipMessage::<B>::from(packet))))
+			},
+			// Don't return yet, maybe the timer fired.
+			Poll::Pending => {},
+		};
+
+		ready!(this.delay.poll_unpin(cx));
+
+		// Getting this far here implies that the timer fired.
+
+		this.delay.reset(this.rebroadcast_period);
+
+		// Make sure the underlying task is scheduled for wake-up.
+		//
+		// Note: In case poll_unpin is called after the resetted delay fires again, this
+		// will drop one tick. Deemed as very unlikely and also not critical.
+		while this.delay.poll_unpin(cx).is_ready() {}
+
+		if let Some((ref to, ref packet)) = this.last {
+			return Poll::Ready(Some((to.clone(), GossipMessage::<B>::from(packet.clone()))))
+		}
+
+		Poll::Pending
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/communication/tests.rs b/substrate/client/consensus/grandpa/src/communication/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..10c4772fc76d64078c1f0d5ac413d09c0da91bac
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/communication/tests.rs
@@ -0,0 +1,691 @@
+// 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/>.
+
+//! Tests for the communication portion of the GRANDPA crate.
+
+use super::{
+	gossip::{self, GossipValidator},
+	Round, SetId, VoterSet,
+};
+use crate::{communication::grandpa_protocol_name, environment::SharedVoterSetState};
+use futures::prelude::*;
+use parity_scale_codec::Encode;
+use sc_network::{
+	config::{MultiaddrWithPeerId, Role},
+	event::Event as NetworkEvent,
+	types::ProtocolName,
+	Multiaddr, NetworkBlock, NetworkEventStream, NetworkNotification, NetworkPeers,
+	NetworkSyncForkRequest, NotificationSenderError, NotificationSenderT as NotificationSender,
+	PeerId, ReputationChange,
+};
+use sc_network_common::{
+	role::ObservedRole,
+	sync::{SyncEvent as SyncStreamEvent, SyncEventStream},
+};
+use sc_network_gossip::Validator;
+use sc_network_test::{Block, Hash};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_consensus_grandpa::AuthorityList;
+use sp_keyring::Ed25519Keyring;
+use sp_runtime::traits::NumberFor;
+use std::{
+	collections::HashSet,
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+};
+
+#[derive(Debug)]
+pub(crate) enum Event {
+	EventStream(TracingUnboundedSender<NetworkEvent>),
+	WriteNotification(PeerId, Vec<u8>),
+	Report(PeerId, ReputationChange),
+	Announce(Hash),
+}
+
+#[derive(Clone)]
+pub(crate) struct TestNetwork {
+	sender: TracingUnboundedSender<Event>,
+}
+
+impl NetworkPeers for TestNetwork {
+	fn set_authorized_peers(&self, _peers: HashSet<PeerId>) {
+		unimplemented!();
+	}
+
+	fn set_authorized_only(&self, _reserved_only: bool) {
+		unimplemented!();
+	}
+
+	fn add_known_address(&self, _peer_id: PeerId, _addr: Multiaddr) {
+		unimplemented!();
+	}
+
+	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
+		let _ = self.sender.unbounded_send(Event::Report(who, cost_benefit));
+	}
+
+	fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {}
+
+	fn accept_unreserved_peers(&self) {
+		unimplemented!();
+	}
+
+	fn deny_unreserved_peers(&self) {
+		unimplemented!();
+	}
+
+	fn add_reserved_peer(&self, _peer: MultiaddrWithPeerId) -> Result<(), String> {
+		unimplemented!();
+	}
+
+	fn remove_reserved_peer(&self, _peer_id: PeerId) {
+		unimplemented!();
+	}
+
+	fn set_reserved_peers(
+		&self,
+		_protocol: ProtocolName,
+		_peers: HashSet<Multiaddr>,
+	) -> Result<(), String> {
+		unimplemented!();
+	}
+
+	fn add_peers_to_reserved_set(
+		&self,
+		_protocol: ProtocolName,
+		_peers: HashSet<Multiaddr>,
+	) -> Result<(), String> {
+		unimplemented!();
+	}
+
+	fn remove_peers_from_reserved_set(
+		&self,
+		_protocol: ProtocolName,
+		_peers: Vec<PeerId>,
+	) -> Result<(), String> {
+		unimplemented!();
+	}
+
+	fn sync_num_connected(&self) -> usize {
+		unimplemented!();
+	}
+}
+
+impl NetworkEventStream for TestNetwork {
+	fn event_stream(
+		&self,
+		_name: &'static str,
+	) -> Pin<Box<dyn Stream<Item = NetworkEvent> + Send>> {
+		let (tx, rx) = tracing_unbounded("test", 100_000);
+		let _ = self.sender.unbounded_send(Event::EventStream(tx));
+		Box::pin(rx)
+	}
+}
+
+impl NetworkNotification for TestNetwork {
+	fn write_notification(&self, target: PeerId, _protocol: ProtocolName, message: Vec<u8>) {
+		let _ = self.sender.unbounded_send(Event::WriteNotification(target, message));
+	}
+
+	fn notification_sender(
+		&self,
+		_target: PeerId,
+		_protocol: ProtocolName,
+	) -> Result<Box<dyn NotificationSender>, NotificationSenderError> {
+		unimplemented!();
+	}
+
+	fn set_notification_handshake(&self, _protocol: ProtocolName, _handshake: Vec<u8>) {
+		unimplemented!();
+	}
+}
+
+impl NetworkBlock<Hash, NumberFor<Block>> for TestNetwork {
+	fn announce_block(&self, hash: Hash, _data: Option<Vec<u8>>) {
+		let _ = self.sender.unbounded_send(Event::Announce(hash));
+	}
+
+	fn new_best_block_imported(&self, _hash: Hash, _number: NumberFor<Block>) {
+		unimplemented!();
+	}
+}
+
+impl NetworkSyncForkRequest<Hash, NumberFor<Block>> for TestNetwork {
+	fn set_sync_fork_request(&self, _peers: Vec<PeerId>, _hash: Hash, _number: NumberFor<Block>) {}
+}
+
+impl sc_network_gossip::ValidatorContext<Block> for TestNetwork {
+	fn broadcast_topic(&mut self, _: Hash, _: bool) {}
+
+	fn broadcast_message(&mut self, _: Hash, _: Vec<u8>, _: bool) {}
+
+	fn send_message(&mut self, who: &PeerId, data: Vec<u8>) {
+		<Self as NetworkNotification>::write_notification(
+			self,
+			*who,
+			grandpa_protocol_name::NAME.into(),
+			data,
+		);
+	}
+
+	fn send_topic(&mut self, _: &PeerId, _: Hash, _: bool) {}
+}
+
+#[derive(Clone)]
+pub(crate) struct TestSync;
+
+impl SyncEventStream for TestSync {
+	fn event_stream(
+		&self,
+		_name: &'static str,
+	) -> Pin<Box<dyn Stream<Item = SyncStreamEvent> + Send>> {
+		Box::pin(futures::stream::pending())
+	}
+}
+
+impl NetworkBlock<Hash, NumberFor<Block>> for TestSync {
+	fn announce_block(&self, _hash: Hash, _data: Option<Vec<u8>>) {
+		unimplemented!();
+	}
+
+	fn new_best_block_imported(&self, _hash: Hash, _number: NumberFor<Block>) {
+		unimplemented!();
+	}
+}
+
+impl NetworkSyncForkRequest<Hash, NumberFor<Block>> for TestSync {
+	fn set_sync_fork_request(&self, _peers: Vec<PeerId>, _hash: Hash, _number: NumberFor<Block>) {}
+}
+
+pub(crate) struct Tester {
+	pub(crate) net_handle: super::NetworkBridge<Block, TestNetwork, TestSync>,
+	gossip_validator: Arc<GossipValidator<Block>>,
+	pub(crate) events: TracingUnboundedReceiver<Event>,
+}
+
+impl Tester {
+	fn filter_network_events<F>(self, mut pred: F) -> impl Future<Output = Self>
+	where
+		F: FnMut(Event) -> bool,
+	{
+		let mut s = Some(self);
+		futures::future::poll_fn(move |cx| loop {
+			match Stream::poll_next(Pin::new(&mut s.as_mut().unwrap().events), cx) {
+				Poll::Ready(None) => panic!("concluded early"),
+				Poll::Ready(Some(item)) =>
+					if pred(item) {
+						return Poll::Ready(s.take().unwrap())
+					},
+				Poll::Pending => return Poll::Pending,
+			}
+		})
+	}
+
+	pub(crate) fn trigger_gossip_validator_reputation_change(&self, p: &PeerId) {
+		self.gossip_validator.validate(
+			&mut crate::communication::tests::NoopContext,
+			p,
+			&vec![1, 2, 3],
+		);
+	}
+}
+
+// some random config (not really needed)
+fn config() -> crate::Config {
+	crate::Config {
+		gossip_duration: std::time::Duration::from_millis(10),
+		justification_generation_period: 256,
+		keystore: None,
+		name: None,
+		local_role: Role::Authority,
+		observer_enabled: true,
+		telemetry: None,
+		protocol_name: grandpa_protocol_name::NAME.into(),
+	}
+}
+
+// dummy voter set state
+fn voter_set_state() -> SharedVoterSetState<Block> {
+	use crate::{authorities::AuthoritySet, environment::VoterSetState};
+	use finality_grandpa::round::State as RoundState;
+	use sp_consensus_grandpa::AuthorityId;
+	use sp_core::{crypto::ByteArray, H256};
+
+	let state = RoundState::genesis((H256::zero(), 0));
+	let base = state.prevote_ghost.unwrap();
+
+	let voters = vec![(AuthorityId::from_slice(&[1; 32]).unwrap(), 1)];
+	let voters = AuthoritySet::genesis(voters).unwrap();
+
+	let set_state = VoterSetState::live(0, &voters, base);
+
+	set_state.into()
+}
+
+// needs to run in a tokio runtime.
+pub(crate) fn make_test_network() -> (impl Future<Output = Tester>, TestNetwork) {
+	let (tx, rx) = tracing_unbounded("test", 100_000);
+	let net = TestNetwork { sender: tx };
+	let sync = TestSync {};
+
+	#[derive(Clone)]
+	struct Exit;
+
+	impl futures::Future for Exit {
+		type Output = ();
+
+		fn poll(self: Pin<&mut Self>, _: &mut Context) -> Poll<()> {
+			Poll::Pending
+		}
+	}
+
+	let bridge =
+		super::NetworkBridge::new(net.clone(), sync, config(), voter_set_state(), None, None);
+
+	(
+		futures::future::ready(Tester {
+			gossip_validator: bridge.validator.clone(),
+			net_handle: bridge,
+			events: rx,
+		}),
+		net,
+	)
+}
+
+fn make_ids(keys: &[Ed25519Keyring]) -> AuthorityList {
+	keys.iter().map(|&key| key.public().into()).map(|id| (id, 1)).collect()
+}
+
+struct NoopContext;
+
+impl sc_network_gossip::ValidatorContext<Block> for NoopContext {
+	fn broadcast_topic(&mut self, _: Hash, _: bool) {}
+	fn broadcast_message(&mut self, _: Hash, _: Vec<u8>, _: bool) {}
+	fn send_message(&mut self, _: &PeerId, _: Vec<u8>) {}
+	fn send_topic(&mut self, _: &PeerId, _: Hash, _: bool) {}
+}
+
+#[test]
+fn good_commit_leads_to_relay() {
+	let private = [Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let public = make_ids(&private[..]);
+	let voter_set = Arc::new(VoterSet::new(public.iter().cloned()).unwrap());
+
+	let round = 1;
+	let set_id = 1;
+
+	let commit = {
+		let target_hash: Hash = [1; 32].into();
+		let target_number = 500;
+
+		let precommit = finality_grandpa::Precommit { target_hash, target_number };
+		let payload = sp_consensus_grandpa::localized_payload(
+			round,
+			set_id,
+			&finality_grandpa::Message::Precommit(precommit.clone()),
+		);
+
+		let mut precommits = Vec::new();
+		let mut auth_data = Vec::new();
+
+		for (i, key) in private.iter().enumerate() {
+			precommits.push(precommit.clone());
+
+			let signature = sp_consensus_grandpa::AuthoritySignature::from(key.sign(&payload[..]));
+			auth_data.push((signature, public[i].0.clone()))
+		}
+
+		finality_grandpa::CompactCommit { target_hash, target_number, precommits, auth_data }
+	};
+
+	let encoded_commit = gossip::GossipMessage::<Block>::Commit(gossip::FullCommitMessage {
+		round: Round(round),
+		set_id: SetId(set_id),
+		message: commit,
+	})
+	.encode();
+
+	let id = PeerId::random();
+	let global_topic = super::global_topic::<Block>(set_id);
+
+	let test = make_test_network()
+		.0
+		.then(move |tester| {
+			// register a peer.
+			tester.gossip_validator.new_peer(&mut NoopContext, &id, ObservedRole::Full);
+			future::ready((tester, id))
+		})
+		.then(move |(tester, id)| {
+			// start round, dispatch commit, and wait for broadcast.
+			let (commits_in, _) =
+				tester.net_handle.global_communication(SetId(1), voter_set, false);
+
+			{
+				let (action, ..) = tester.gossip_validator.do_validate(&id, &encoded_commit[..]);
+				match action {
+					gossip::Action::ProcessAndDiscard(t, _) => assert_eq!(t, global_topic),
+					_ => panic!("wrong expected outcome from initial commit validation"),
+				}
+			}
+
+			let commit_to_send = encoded_commit.clone();
+			let network_bridge = tester.net_handle.clone();
+
+			// asking for global communication will cause the test network
+			// to send us an event asking us for a stream. use it to
+			// send a message.
+			let sender_id = id;
+			let send_message = tester.filter_network_events(move |event| match event {
+				Event::EventStream(sender) => {
+					// Add the sending peer and send the commit
+					let _ = sender.unbounded_send(NetworkEvent::NotificationStreamOpened {
+						remote: sender_id,
+						protocol: grandpa_protocol_name::NAME.into(),
+						negotiated_fallback: None,
+						role: ObservedRole::Full,
+						received_handshake: vec![],
+					});
+
+					let _ = sender.unbounded_send(NetworkEvent::NotificationsReceived {
+						remote: sender_id,
+						messages: vec![(
+							grandpa_protocol_name::NAME.into(),
+							commit_to_send.clone().into(),
+						)],
+					});
+
+					// Add a random peer which will be the recipient of this message
+					let receiver_id = PeerId::random();
+					let _ = sender.unbounded_send(NetworkEvent::NotificationStreamOpened {
+						remote: receiver_id,
+						protocol: grandpa_protocol_name::NAME.into(),
+						negotiated_fallback: None,
+						role: ObservedRole::Full,
+						received_handshake: vec![],
+					});
+
+					// Announce its local set has being on the current set id through a neighbor
+					// packet, otherwise it won't be eligible to receive the commit
+					let _ = {
+						let update = gossip::VersionedNeighborPacket::V1(gossip::NeighborPacket {
+							round: Round(round),
+							set_id: SetId(set_id),
+							commit_finalized_height: 1,
+						});
+
+						let msg = gossip::GossipMessage::<Block>::Neighbor(update);
+
+						sender.unbounded_send(NetworkEvent::NotificationsReceived {
+							remote: receiver_id,
+							messages: vec![(
+								grandpa_protocol_name::NAME.into(),
+								msg.encode().into(),
+							)],
+						})
+					};
+
+					true
+				},
+				_ => false,
+			});
+
+			// when the commit comes in, we'll tell the callback it was good.
+			let handle_commit = commits_in.into_future().map(|(item, _)| match item.unwrap() {
+				finality_grandpa::voter::CommunicationIn::Commit(_, _, mut callback) => {
+					callback.run(finality_grandpa::voter::CommitProcessingOutcome::good());
+				},
+				_ => panic!("commit expected"),
+			});
+
+			// once the message is sent and commit is "handled" we should have
+			// a repropagation event coming from the network.
+			let fut = future::join(send_message, handle_commit)
+				.then(move |(tester, ())| {
+					tester.filter_network_events(move |event| match event {
+						Event::WriteNotification(_, data) => data == encoded_commit,
+						_ => false,
+					})
+				})
+				.map(|_| ());
+
+			// Poll both the future sending and handling the commit, as well as the underlying
+			// NetworkBridge. Complete once the former completes.
+			future::select(fut, network_bridge)
+		});
+
+	futures::executor::block_on(test);
+}
+
+#[test]
+fn bad_commit_leads_to_report() {
+	sp_tracing::try_init_simple();
+	let private = [Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let public = make_ids(&private[..]);
+	let voter_set = Arc::new(VoterSet::new(public.iter().cloned()).unwrap());
+
+	let round = 1;
+	let set_id = 1;
+
+	let commit = {
+		let target_hash: Hash = [1; 32].into();
+		let target_number = 500;
+
+		let precommit = finality_grandpa::Precommit { target_hash, target_number };
+		let payload = sp_consensus_grandpa::localized_payload(
+			round,
+			set_id,
+			&finality_grandpa::Message::Precommit(precommit.clone()),
+		);
+
+		let mut precommits = Vec::new();
+		let mut auth_data = Vec::new();
+
+		for (i, key) in private.iter().enumerate() {
+			precommits.push(precommit.clone());
+
+			let signature = sp_consensus_grandpa::AuthoritySignature::from(key.sign(&payload[..]));
+			auth_data.push((signature, public[i].0.clone()))
+		}
+
+		finality_grandpa::CompactCommit { target_hash, target_number, precommits, auth_data }
+	};
+
+	let encoded_commit = gossip::GossipMessage::<Block>::Commit(gossip::FullCommitMessage {
+		round: Round(round),
+		set_id: SetId(set_id),
+		message: commit,
+	})
+	.encode();
+
+	let id = PeerId::random();
+	let global_topic = super::global_topic::<Block>(set_id);
+
+	let test = make_test_network()
+		.0
+		.map(move |tester| {
+			// register a peer.
+			tester.gossip_validator.new_peer(&mut NoopContext, &id, ObservedRole::Full);
+			(tester, id)
+		})
+		.then(move |(tester, id)| {
+			// start round, dispatch commit, and wait for broadcast.
+			let (commits_in, _) =
+				tester.net_handle.global_communication(SetId(1), voter_set, false);
+
+			{
+				let (action, ..) = tester.gossip_validator.do_validate(&id, &encoded_commit[..]);
+				match action {
+					gossip::Action::ProcessAndDiscard(t, _) => assert_eq!(t, global_topic),
+					_ => panic!("wrong expected outcome from initial commit validation"),
+				}
+			}
+
+			let commit_to_send = encoded_commit.clone();
+			let network_bridge = tester.net_handle.clone();
+
+			// asking for global communication will cause the test network
+			// to send us an event asking us for a stream. use it to
+			// send a message.
+			let sender_id = id;
+			let send_message = tester.filter_network_events(move |event| match event {
+				Event::EventStream(sender) => {
+					let _ = sender.unbounded_send(NetworkEvent::NotificationStreamOpened {
+						remote: sender_id,
+						protocol: grandpa_protocol_name::NAME.into(),
+						negotiated_fallback: None,
+						role: ObservedRole::Full,
+						received_handshake: vec![],
+					});
+					let _ = sender.unbounded_send(NetworkEvent::NotificationsReceived {
+						remote: sender_id,
+						messages: vec![(
+							grandpa_protocol_name::NAME.into(),
+							commit_to_send.clone().into(),
+						)],
+					});
+
+					true
+				},
+				_ => false,
+			});
+
+			// when the commit comes in, we'll tell the callback it was bad.
+			let handle_commit = commits_in.into_future().map(|(item, _)| match item.unwrap() {
+				finality_grandpa::voter::CommunicationIn::Commit(_, _, mut callback) => {
+					callback.run(finality_grandpa::voter::CommitProcessingOutcome::bad());
+				},
+				_ => panic!("commit expected"),
+			});
+
+			// once the message is sent and commit is "handled" we should have
+			// a report event coming from the network.
+			let fut = future::join(send_message, handle_commit)
+				.then(move |(tester, ())| {
+					tester.filter_network_events(move |event| match event {
+						Event::Report(who, cost_benefit) =>
+							who == id && cost_benefit == super::cost::INVALID_COMMIT,
+						_ => false,
+					})
+				})
+				.map(|_| ());
+
+			// Poll both the future sending and handling the commit, as well as the underlying
+			// NetworkBridge. Complete once the former completes.
+			future::select(fut, network_bridge)
+		});
+
+	futures::executor::block_on(test);
+}
+
+#[test]
+fn peer_with_higher_view_leads_to_catch_up_request() {
+	let id = PeerId::random();
+
+	let (tester, mut net) = make_test_network();
+	let test = tester
+		.map(move |tester| {
+			// register a peer with authority role.
+			tester.gossip_validator.new_peer(&mut NoopContext, &id, ObservedRole::Authority);
+			(tester, id)
+		})
+		.then(move |(tester, id)| {
+			// send neighbor message at round 10 and height 50
+			let result = tester.gossip_validator.validate(
+				&mut net,
+				&id,
+				&gossip::GossipMessage::<Block>::from(gossip::NeighborPacket {
+					set_id: SetId(0),
+					round: Round(10),
+					commit_finalized_height: 50,
+				})
+				.encode(),
+			);
+
+			// neighbor packets are always discard
+			match result {
+				sc_network_gossip::ValidationResult::Discard => {},
+				_ => panic!("wrong expected outcome from neighbor validation"),
+			}
+
+			// a catch up request should be sent to the peer for round - 1
+			tester
+				.filter_network_events(move |event| match event {
+					Event::WriteNotification(peer, message) => {
+						assert_eq!(peer, id);
+
+						assert_eq!(
+							message,
+							gossip::GossipMessage::<Block>::CatchUpRequest(
+								gossip::CatchUpRequestMessage { set_id: SetId(0), round: Round(9) }
+							)
+							.encode(),
+						);
+
+						true
+					},
+					_ => false,
+				})
+				.map(|_| ())
+		});
+
+	futures::executor::block_on(test);
+}
+
+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()
+}
+
+#[test]
+fn grandpa_protocol_name() {
+	let chain_spec = local_chain_spec();
+
+	// Create protocol name using random genesis hash.
+	let genesis_hash = sp_core::H256::random();
+	let expected = format!("/{}/grandpa/1", array_bytes::bytes2hex("", genesis_hash));
+	let proto_name = grandpa_protocol_name::standard_name(&genesis_hash, &chain_spec);
+	assert_eq!(proto_name.to_string(), expected);
+
+	// Create protocol name using hardcoded genesis hash. Verify exact representation.
+	let genesis_hash = [
+		53, 79, 112, 97, 119, 217, 39, 202, 147, 138, 225, 38, 88, 182, 215, 185, 110, 88, 8, 53,
+		125, 210, 158, 151, 50, 113, 102, 59, 245, 199, 221, 240,
+	];
+	let expected =
+		"/354f706177d927ca938ae12658b6d7b96e5808357dd29e973271663bf5c7ddf0/grandpa/1".to_string();
+	let proto_name = grandpa_protocol_name::standard_name(&genesis_hash, &chain_spec);
+	assert_eq!(proto_name.to_string(), expected);
+}
diff --git a/substrate/client/consensus/grandpa/src/environment.rs b/substrate/client/consensus/grandpa/src/environment.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d3e2beb84e79c101f7618421c16f7797123f55fa
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/environment.rs
@@ -0,0 +1,1544 @@
+// 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 std::{
+	collections::{BTreeMap, HashMap},
+	iter::FromIterator,
+	marker::PhantomData,
+	pin::Pin,
+	sync::Arc,
+	time::Duration,
+};
+
+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};
+
+use sc_client_api::{
+	backend::{apply_aux, Backend as BackendT},
+	utils::is_descendent_of,
+};
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_INFO};
+use sc_transaction_pool_api::OffchainTransactionPoolFactory;
+use sp_api::ApiExt;
+use sp_blockchain::HeaderMetadata;
+use sp_consensus::SelectChain as SelectChainT;
+use sp_consensus_grandpa::{
+	AuthorityId, AuthoritySignature, Equivocation, EquivocationProof, GrandpaApi, RoundNumber,
+	SetId, GRANDPA_ENGINE_ID,
+};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero};
+
+use crate::{
+	authorities::{AuthoritySet, SharedAuthoritySet},
+	communication::{Network as NetworkT, Syncing as SyncingT},
+	justification::GrandpaJustification,
+	local_authority_id,
+	notification::GrandpaJustificationSender,
+	until_imported::UntilVoteTargetImported,
+	voting_rule::VotingRule as VotingRuleT,
+	ClientForGrandpa, CommandOrError, Commit, Config, Error, NewAuthoritySet, Precommit, Prevote,
+	PrimaryPropose, SignedMessage, VoterCommand, LOG_TARGET,
+};
+
+type HistoricalVotes<Block> = finality_grandpa::HistoricalVotes<
+	<Block as BlockT>::Hash,
+	NumberFor<Block>,
+	AuthoritySignature,
+	AuthorityId,
+>;
+
+/// Data about a completed round. The set of votes that is stored must be
+/// minimal, i.e. at most one equivocation is stored per voter.
+#[derive(Debug, Clone, Decode, Encode, PartialEq)]
+pub struct CompletedRound<Block: BlockT> {
+	/// The round number.
+	pub number: RoundNumber,
+	/// The round state (prevote ghost, estimate, finalized, etc.)
+	pub state: RoundState<Block::Hash, NumberFor<Block>>,
+	/// The target block base used for voting in the round.
+	pub base: (Block::Hash, NumberFor<Block>),
+	/// All the votes observed in the round.
+	pub votes: Vec<SignedMessage<Block::Header>>,
+}
+
+// Data about last completed rounds within a single voter set. Stores
+// NUM_LAST_COMPLETED_ROUNDS and always contains data about at least one round
+// (genesis).
+#[derive(Debug, Clone, PartialEq)]
+pub struct CompletedRounds<Block: BlockT> {
+	rounds: Vec<CompletedRound<Block>>,
+	set_id: SetId,
+	voters: Vec<AuthorityId>,
+}
+
+// NOTE: the current strategy for persisting completed rounds is very naive
+// (update everything) and we also rely on cloning to do atomic updates,
+// therefore this value should be kept small for now.
+const NUM_LAST_COMPLETED_ROUNDS: usize = 2;
+
+impl<Block: BlockT> Encode for CompletedRounds<Block> {
+	fn encode(&self) -> Vec<u8> {
+		let v = Vec::from_iter(&self.rounds);
+		(&v, &self.set_id, &self.voters).encode()
+	}
+}
+
+impl<Block: BlockT> parity_scale_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> {
+		<(Vec<CompletedRound<Block>>, SetId, Vec<AuthorityId>)>::decode(value)
+			.map(|(rounds, set_id, voters)| CompletedRounds { rounds, set_id, voters })
+	}
+}
+
+impl<Block: BlockT> CompletedRounds<Block> {
+	/// Create a new completed rounds tracker with NUM_LAST_COMPLETED_ROUNDS capacity.
+	pub(crate) fn new(
+		genesis: CompletedRound<Block>,
+		set_id: SetId,
+		voters: &AuthoritySet<Block::Hash, NumberFor<Block>>,
+	) -> CompletedRounds<Block> {
+		let mut rounds = Vec::with_capacity(NUM_LAST_COMPLETED_ROUNDS);
+		rounds.push(genesis);
+
+		let voters = voters.current_authorities.iter().map(|(a, _)| a.clone()).collect();
+		CompletedRounds { rounds, set_id, voters }
+	}
+
+	/// Get the set-id and voter set of the completed rounds.
+	pub fn set_info(&self) -> (SetId, &[AuthorityId]) {
+		(self.set_id, &self.voters[..])
+	}
+
+	/// Iterate over all completed rounds.
+	pub fn iter(&self) -> impl Iterator<Item = &CompletedRound<Block>> {
+		self.rounds.iter().rev()
+	}
+
+	/// Returns the last (latest) completed round.
+	pub fn last(&self) -> &CompletedRound<Block> {
+		self.rounds
+			.first()
+			.expect("inner is never empty; always contains at least genesis; qed")
+	}
+
+	/// Push a new completed round, oldest round is evicted if number of rounds
+	/// is higher than `NUM_LAST_COMPLETED_ROUNDS`.
+	pub fn push(&mut self, completed_round: CompletedRound<Block>) {
+		use std::cmp::Reverse;
+
+		match self
+			.rounds
+			.binary_search_by_key(&Reverse(completed_round.number), |completed_round| {
+				Reverse(completed_round.number)
+			}) {
+			Ok(idx) => self.rounds[idx] = completed_round,
+			Err(idx) => self.rounds.insert(idx, completed_round),
+		};
+
+		if self.rounds.len() > NUM_LAST_COMPLETED_ROUNDS {
+			self.rounds.pop();
+		}
+	}
+}
+
+/// A map with voter status information for currently live rounds,
+/// which votes have we cast and what are they.
+pub type CurrentRounds<Block> = BTreeMap<RoundNumber, HasVoted<<Block as BlockT>::Header>>;
+
+/// The state of the current voter set, whether it is currently active or not
+/// and information related to the previously completed rounds. Current round
+/// voting status is used when restarting the voter, i.e. it will re-use the
+/// previous votes for a given round if appropriate (same round and same local
+/// key).
+#[derive(Debug, Decode, Encode, PartialEq)]
+pub enum VoterSetState<Block: BlockT> {
+	/// The voter is live, i.e. participating in rounds.
+	Live {
+		/// The previously completed rounds.
+		completed_rounds: CompletedRounds<Block>,
+		/// Voter status for the currently live rounds.
+		current_rounds: CurrentRounds<Block>,
+	},
+	/// The voter is paused, i.e. not casting or importing any votes.
+	Paused {
+		/// The previously completed rounds.
+		completed_rounds: CompletedRounds<Block>,
+	},
+}
+
+impl<Block: BlockT> VoterSetState<Block> {
+	/// Create a new live VoterSetState with round 0 as a completed round using
+	/// the given genesis state and the given authorities. Round 1 is added as a
+	/// current round (with state `HasVoted::No`).
+	pub(crate) fn live(
+		set_id: SetId,
+		authority_set: &AuthoritySet<Block::Hash, NumberFor<Block>>,
+		genesis_state: (Block::Hash, NumberFor<Block>),
+	) -> VoterSetState<Block> {
+		let state = RoundState::genesis((genesis_state.0, genesis_state.1));
+		let completed_rounds = CompletedRounds::new(
+			CompletedRound {
+				number: 0,
+				state,
+				base: (genesis_state.0, genesis_state.1),
+				votes: Vec::new(),
+			},
+			set_id,
+			authority_set,
+		);
+
+		let mut current_rounds = CurrentRounds::<Block>::new();
+		current_rounds.insert(1, HasVoted::No);
+
+		VoterSetState::Live { completed_rounds, current_rounds }
+	}
+
+	/// Returns the last completed rounds.
+	pub(crate) fn completed_rounds(&self) -> CompletedRounds<Block> {
+		match self {
+			VoterSetState::Live { completed_rounds, .. } => completed_rounds.clone(),
+			VoterSetState::Paused { completed_rounds } => completed_rounds.clone(),
+		}
+	}
+
+	/// Returns the last completed round.
+	pub(crate) fn last_completed_round(&self) -> CompletedRound<Block> {
+		match self {
+			VoterSetState::Live { completed_rounds, .. } => completed_rounds.last().clone(),
+			VoterSetState::Paused { completed_rounds } => completed_rounds.last().clone(),
+		}
+	}
+
+	/// Returns the voter set state validating that it includes the given round
+	/// in current rounds and that the voter isn't paused.
+	pub fn with_current_round(
+		&self,
+		round: RoundNumber,
+	) -> Result<(&CompletedRounds<Block>, &CurrentRounds<Block>), Error> {
+		if let VoterSetState::Live { completed_rounds, current_rounds } = self {
+			if current_rounds.contains_key(&round) {
+				Ok((completed_rounds, current_rounds))
+			} else {
+				let msg = "Voter acting on a live round we are not tracking.";
+				Err(Error::Safety(msg.to_string()))
+			}
+		} else {
+			let msg = "Voter acting while in paused state.";
+			Err(Error::Safety(msg.to_string()))
+		}
+	}
+}
+
+/// Whether we've voted already during a prior run of the program.
+#[derive(Clone, Debug, Decode, Encode, PartialEq)]
+pub enum HasVoted<Header: HeaderT> {
+	/// Has not voted already in this round.
+	No,
+	/// Has voted in this round.
+	Yes(AuthorityId, Vote<Header>),
+}
+
+/// The votes cast by this voter already during a prior run of the program.
+#[derive(Debug, Clone, Decode, Encode, PartialEq)]
+pub enum Vote<Header: HeaderT> {
+	/// Has cast a proposal.
+	Propose(PrimaryPropose<Header>),
+	/// Has cast a prevote.
+	Prevote(Option<PrimaryPropose<Header>>, Prevote<Header>),
+	/// Has cast a precommit (implies prevote.)
+	Precommit(Option<PrimaryPropose<Header>>, Prevote<Header>, Precommit<Header>),
+}
+
+impl<Header: HeaderT> HasVoted<Header> {
+	/// Returns the proposal we should vote with (if any.)
+	pub fn propose(&self) -> Option<&PrimaryPropose<Header>> {
+		match self {
+			HasVoted::Yes(_, Vote::Propose(propose)) => Some(propose),
+			HasVoted::Yes(_, Vote::Prevote(propose, _)) |
+			HasVoted::Yes(_, Vote::Precommit(propose, _, _)) => propose.as_ref(),
+			_ => None,
+		}
+	}
+
+	/// Returns the prevote we should vote with (if any.)
+	pub fn prevote(&self) -> Option<&Prevote<Header>> {
+		match self {
+			HasVoted::Yes(_, Vote::Prevote(_, prevote)) |
+			HasVoted::Yes(_, Vote::Precommit(_, prevote, _)) => Some(prevote),
+			_ => None,
+		}
+	}
+
+	/// Returns the precommit we should vote with (if any.)
+	pub fn precommit(&self) -> Option<&Precommit<Header>> {
+		match self {
+			HasVoted::Yes(_, Vote::Precommit(_, _, precommit)) => Some(precommit),
+			_ => None,
+		}
+	}
+
+	/// Returns true if the voter can still propose, false otherwise.
+	pub fn can_propose(&self) -> bool {
+		self.propose().is_none()
+	}
+
+	/// Returns true if the voter can still prevote, false otherwise.
+	pub fn can_prevote(&self) -> bool {
+		self.prevote().is_none()
+	}
+
+	/// Returns true if the voter can still precommit, false otherwise.
+	pub fn can_precommit(&self) -> bool {
+		self.precommit().is_none()
+	}
+}
+
+/// A voter set state meant to be shared safely across multiple owners.
+#[derive(Clone)]
+pub struct SharedVoterSetState<Block: BlockT> {
+	/// The inner shared `VoterSetState`.
+	inner: Arc<RwLock<VoterSetState<Block>>>,
+	/// A tracker for the rounds that we are actively participating on (i.e. voting)
+	/// and the authority id under which we are doing it.
+	voting: Arc<RwLock<HashMap<RoundNumber, AuthorityId>>>,
+}
+
+impl<Block: BlockT> From<VoterSetState<Block>> for SharedVoterSetState<Block> {
+	fn from(set_state: VoterSetState<Block>) -> Self {
+		SharedVoterSetState::new(set_state)
+	}
+}
+
+impl<Block: BlockT> SharedVoterSetState<Block> {
+	/// Create a new shared voter set tracker with the given state.
+	pub(crate) fn new(state: VoterSetState<Block>) -> Self {
+		SharedVoterSetState {
+			inner: Arc::new(RwLock::new(state)),
+			voting: Arc::new(RwLock::new(HashMap::new())),
+		}
+	}
+
+	/// Read the inner voter set state.
+	pub(crate) fn read(&self) -> parking_lot::RwLockReadGuard<VoterSetState<Block>> {
+		self.inner.read()
+	}
+
+	/// Get the authority id that we are using to vote on the given round, if any.
+	pub(crate) fn voting_on(&self, round: RoundNumber) -> Option<AuthorityId> {
+		self.voting.read().get(&round).cloned()
+	}
+
+	/// Note that we started voting on the give round with the given authority id.
+	pub(crate) fn started_voting_on(&self, round: RoundNumber, local_id: AuthorityId) {
+		self.voting.write().insert(round, local_id);
+	}
+
+	/// Note that we have finished voting on the given round. If we were voting on
+	/// the given round, the authority id that we were using to do it will be
+	/// cleared.
+	pub(crate) fn finished_voting_on(&self, round: RoundNumber) {
+		self.voting.write().remove(&round);
+	}
+
+	/// Return vote status information for the current round.
+	pub(crate) fn has_voted(&self, round: RoundNumber) -> HasVoted<Block::Header> {
+		match &*self.inner.read() {
+			VoterSetState::Live { current_rounds, .. } => current_rounds
+				.get(&round)
+				.and_then(|has_voted| match has_voted {
+					HasVoted::Yes(id, vote) => Some(HasVoted::Yes(id.clone(), vote.clone())),
+					_ => None,
+				})
+				.unwrap_or(HasVoted::No),
+			_ => HasVoted::No,
+		}
+	}
+
+	// NOTE: not exposed outside of this module intentionally.
+	fn with<F, R>(&self, f: F) -> R
+	where
+		F: FnOnce(&mut VoterSetState<Block>) -> R,
+	{
+		f(&mut *self.inner.write())
+	}
+}
+
+/// Prometheus metrics for GRANDPA.
+#[derive(Clone)]
+pub(crate) struct Metrics {
+	finality_grandpa_round: Gauge<U64>,
+	finality_grandpa_prevotes: Counter<U64>,
+	finality_grandpa_precommits: Counter<U64>,
+}
+
+impl Metrics {
+	pub(crate) fn register(
+		registry: &prometheus_endpoint::Registry,
+	) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			finality_grandpa_round: register(
+				Gauge::new("substrate_finality_grandpa_round", "Highest completed GRANDPA round.")?,
+				registry,
+			)?,
+			finality_grandpa_prevotes: register(
+				Counter::new(
+					"substrate_finality_grandpa_prevotes_total",
+					"Total number of GRANDPA prevotes cast locally.",
+				)?,
+				registry,
+			)?,
+			finality_grandpa_precommits: register(
+				Counter::new(
+					"substrate_finality_grandpa_precommits_total",
+					"Total number of GRANDPA precommits cast locally.",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// The environment we run GRANDPA in.
+pub(crate) struct Environment<
+	Backend,
+	Block: BlockT,
+	C,
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	SC,
+	VR,
+> {
+	pub(crate) client: Arc<C>,
+	pub(crate) select_chain: SC,
+	pub(crate) voters: Arc<VoterSet<AuthorityId>>,
+	pub(crate) config: Config,
+	pub(crate) authority_set: SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+	pub(crate) network: crate::communication::NetworkBridge<Block, N, S>,
+	pub(crate) set_id: SetId,
+	pub(crate) voter_set_state: SharedVoterSetState<Block>,
+	pub(crate) voting_rule: VR,
+	pub(crate) metrics: Option<Metrics>,
+	pub(crate) justification_sender: Option<GrandpaJustificationSender<Block>>,
+	pub(crate) telemetry: Option<TelemetryHandle>,
+	pub(crate) offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>,
+	pub(crate) _phantom: PhantomData<Backend>,
+}
+
+impl<BE, Block: BlockT, C, N: NetworkT<Block>, S: SyncingT<Block>, SC, VR>
+	Environment<BE, Block, C, N, S, SC, VR>
+{
+	/// Updates the voter set state using the given closure. The write lock is
+	/// held during evaluation of the closure and the environment's voter set
+	/// state is set to its result if successful.
+	pub(crate) fn update_voter_set_state<F>(&self, f: F) -> Result<(), Error>
+	where
+		F: FnOnce(&VoterSetState<Block>) -> Result<Option<VoterSetState<Block>>, Error>,
+	{
+		self.voter_set_state.with(|voter_set_state| {
+			if let Some(set_state) = f(voter_set_state)? {
+				*voter_set_state = set_state;
+
+				if let Some(metrics) = self.metrics.as_ref() {
+					if let VoterSetState::Live { completed_rounds, .. } = voter_set_state {
+						let highest = completed_rounds
+							.rounds
+							.iter()
+							.map(|round| round.number)
+							.max()
+							.expect("There is always one completed round (genesis); qed");
+
+						metrics.finality_grandpa_round.set(highest);
+					}
+				}
+			}
+			Ok(())
+		})
+	}
+}
+
+impl<BE, Block, C, N, S, SC, VR> Environment<BE, Block, C, N, S, SC, VR>
+where
+	Block: BlockT,
+	BE: BackendT<Block>,
+	C: ClientForGrandpa<Block, BE>,
+	C::Api: GrandpaApi<Block>,
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	SC: SelectChainT<Block>,
+{
+	/// Report the given equivocation to the GRANDPA runtime module. This method
+	/// generates a session membership proof of the offender and then submits an
+	/// extrinsic to report the equivocation. In particular, the session membership
+	/// proof must be generated at the block at which the given set was active which
+	/// isn't necessarily the best block if there are pending authority set changes.
+	pub(crate) fn report_equivocation(
+		&self,
+		equivocation: Equivocation<Block::Hash, NumberFor<Block>>,
+	) -> Result<(), Error> {
+		if let Some(local_id) = self.voter_set_state.voting_on(equivocation.round_number()) {
+			if *equivocation.offender() == local_id {
+				return Err(Error::Safety(
+					"Refraining from sending equivocation report for our own equivocation.".into(),
+				))
+			}
+		}
+
+		let is_descendent_of = is_descendent_of(&*self.client, None);
+
+		let (best_block_hash, best_block_number) = {
+			// TODO [#9158]: Use SelectChain::best_chain() to get a potentially
+			// more accurate best block
+			let info = self.client.info();
+			(info.best_hash, info.best_number)
+		};
+
+		let authority_set = self.authority_set.inner();
+
+		// block hash and number of the next pending authority set change in the
+		// given best chain.
+		let next_change = authority_set
+			.next_change(&best_block_hash, &is_descendent_of)
+			.map_err(|e| Error::Safety(e.to_string()))?;
+
+		// find the hash of the latest block in the current set
+		let current_set_latest_hash = match next_change {
+			Some((_, n)) if n.is_zero() =>
+				return Err(Error::Safety("Authority set change signalled at genesis.".to_string())),
+			// the next set starts at `n` so the current one lasts until `n - 1`. if
+			// `n` is later than the best block, then the current set is still live
+			// at best block.
+			Some((_, n)) if n > best_block_number => best_block_hash,
+			Some((h, _)) => {
+				// this is the header at which the new set will start
+				let header = self.client.header(h)?.expect(
+					"got block hash from registered pending change; \
+					 pending changes are only registered on block import; qed.",
+				);
+
+				// its parent block is the last block in the current set
+				*header.parent_hash()
+			},
+			// there is no pending change, the latest block for the current set is
+			// the best block.
+			None => best_block_hash,
+		};
+
+		// generate key ownership proof at that block
+		let key_owner_proof = match self
+			.client
+			.runtime_api()
+			.generate_key_ownership_proof(
+				current_set_latest_hash,
+				authority_set.set_id,
+				equivocation.offender().clone(),
+			)
+			.map_err(Error::RuntimeApi)?
+		{
+			Some(proof) => proof,
+			None => {
+				debug!(
+					target: LOG_TARGET,
+					"Equivocation offender is not part of the authority set."
+				);
+				return Ok(())
+			},
+		};
+
+		// submit equivocation report at **best** block
+		let equivocation_proof = EquivocationProof::new(authority_set.set_id, equivocation);
+
+		let mut runtime_api = self.client.runtime_api();
+
+		runtime_api.register_extension(
+			self.offchain_tx_pool_factory.offchain_transaction_pool(best_block_hash),
+		);
+
+		runtime_api
+			.submit_report_equivocation_unsigned_extrinsic(
+				best_block_hash,
+				equivocation_proof,
+				key_owner_proof,
+			)
+			.map_err(Error::RuntimeApi)?;
+
+		Ok(())
+	}
+}
+
+impl<BE, Block, C, N, S, SC, VR> finality_grandpa::Chain<Block::Hash, NumberFor<Block>>
+	for Environment<BE, Block, C, N, S, SC, VR>
+where
+	Block: BlockT,
+	BE: BackendT<Block>,
+	C: ClientForGrandpa<Block, BE>,
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	SC: SelectChainT<Block>,
+	VR: VotingRuleT<Block, C>,
+	NumberFor<Block>: BlockNumberOps,
+{
+	fn ancestry(
+		&self,
+		base: Block::Hash,
+		block: Block::Hash,
+	) -> Result<Vec<Block::Hash>, GrandpaError> {
+		ancestry(&self.client, base, block)
+	}
+}
+
+pub(crate) fn ancestry<Block: BlockT, Client>(
+	client: &Arc<Client>,
+	base: Block::Hash,
+	block: Block::Hash,
+) -> Result<Vec<Block::Hash>, GrandpaError>
+where
+	Client: HeaderMetadata<Block, Error = sp_blockchain::Error>,
+{
+	if base == block {
+		return Err(GrandpaError::NotDescendent)
+	}
+
+	let tree_route_res = sp_blockchain::tree_route(&**client, block, base);
+
+	let tree_route = match tree_route_res {
+		Ok(tree_route) => tree_route,
+		Err(e) => {
+			debug!(
+				target: LOG_TARGET,
+				"Encountered error computing ancestry between block {:?} and base {:?}: {}",
+				block,
+				base,
+				e
+			);
+
+			return Err(GrandpaError::NotDescendent)
+		},
+	};
+
+	if tree_route.common_block().hash != base {
+		return Err(GrandpaError::NotDescendent)
+	}
+
+	// skip one because our ancestry is meant to start from the parent of `block`,
+	// and `tree_route` includes it.
+	Ok(tree_route.retracted().iter().skip(1).map(|e| e.hash).collect())
+}
+
+impl<B, Block, C, N, S, SC, VR> voter::Environment<Block::Hash, NumberFor<Block>>
+	for Environment<B, Block, C, N, S, SC, VR>
+where
+	Block: BlockT,
+	B: BackendT<Block>,
+	C: ClientForGrandpa<Block, B> + 'static,
+	C::Api: GrandpaApi<Block>,
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	SC: SelectChainT<Block> + 'static,
+	VR: VotingRuleT<Block, C> + Clone + 'static,
+	NumberFor<Block>: BlockNumberOps,
+{
+	type Timer = Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send>>;
+	type BestChain = Pin<
+		Box<
+			dyn Future<Output = Result<Option<(Block::Hash, NumberFor<Block>)>, Self::Error>>
+				+ Send,
+		>,
+	>;
+
+	type Id = AuthorityId;
+	type Signature = AuthoritySignature;
+
+	// regular round message streams
+	type In = Pin<
+		Box<
+			dyn Stream<
+					Item = Result<
+						::finality_grandpa::SignedMessage<
+							Block::Hash,
+							NumberFor<Block>,
+							Self::Signature,
+							Self::Id,
+						>,
+						Self::Error,
+					>,
+				> + Send,
+		>,
+	>;
+	type Out = Pin<
+		Box<
+			dyn Sink<
+					::finality_grandpa::Message<Block::Hash, NumberFor<Block>>,
+					Error = Self::Error,
+				> + Send,
+		>,
+	>;
+
+	type Error = CommandOrError<Block::Hash, NumberFor<Block>>;
+
+	fn best_chain_containing(&self, block: Block::Hash) -> Self::BestChain {
+		let client = self.client.clone();
+		let authority_set = self.authority_set.clone();
+		let select_chain = self.select_chain.clone();
+		let voting_rule = self.voting_rule.clone();
+		let set_id = self.set_id;
+
+		Box::pin(async move {
+			// NOTE: when we finalize an authority set change through the sync protocol the voter is
+			//       signaled asynchronously. therefore the voter could still vote in the next round
+			//       before activating the new set. the `authority_set` is updated immediately thus
+			//       we restrict the voter based on that.
+			if set_id != authority_set.set_id() {
+				return Ok(None)
+			}
+
+			best_chain_containing(block, client, authority_set, select_chain, voting_rule)
+				.await
+				.map_err(|e| e.into())
+		})
+	}
+
+	fn round_data(
+		&self,
+		round: RoundNumber,
+	) -> voter::RoundData<Self::Id, Self::Timer, Self::In, Self::Out> {
+		let prevote_timer = Delay::new(self.config.gossip_duration * 2);
+		let precommit_timer = Delay::new(self.config.gossip_duration * 4);
+
+		let local_id = local_authority_id(&self.voters, self.config.keystore.as_ref());
+
+		let has_voted = match self.voter_set_state.has_voted(round) {
+			HasVoted::Yes(id, vote) =>
+				if local_id.as_ref().map(|k| k == &id).unwrap_or(false) {
+					HasVoted::Yes(id, vote)
+				} else {
+					HasVoted::No
+				},
+			HasVoted::No => HasVoted::No,
+		};
+
+		// NOTE: we cache the local authority id that we'll be using to vote on the
+		// given round. this is done to make sure we only check for available keys
+		// from the keystore in this method when beginning the round, otherwise if
+		// the keystore state changed during the round (e.g. a key was removed) it
+		// could lead to internal state inconsistencies in the voter environment
+		// (e.g. we wouldn't update the voter set state after prevoting since there's
+		// no local authority id).
+		if let Some(id) = local_id.as_ref() {
+			self.voter_set_state.started_voting_on(round, id.clone());
+		}
+
+		// we can only sign when we have a local key in the authority set
+		// and we have a reference to the keystore.
+		let keystore = match (local_id.as_ref(), self.config.keystore.as_ref()) {
+			(Some(id), Some(keystore)) => Some((id.clone(), keystore.clone()).into()),
+			_ => None,
+		};
+
+		let (incoming, outgoing) = self.network.round_communication(
+			keystore,
+			crate::communication::Round(round),
+			crate::communication::SetId(self.set_id),
+			self.voters.clone(),
+			has_voted,
+		);
+
+		// schedule incoming messages from the network to be held until
+		// corresponding blocks are imported.
+		let incoming = Box::pin(
+			UntilVoteTargetImported::new(
+				self.client.import_notification_stream(),
+				self.network.clone(),
+				self.client.clone(),
+				incoming,
+				"round",
+				None,
+			)
+			.map_err(Into::into),
+		);
+
+		// schedule network message cleanup when sink drops.
+		let outgoing = Box::pin(outgoing.sink_err_into());
+
+		voter::RoundData {
+			voter_id: local_id,
+			prevote_timer: Box::pin(prevote_timer.map(Ok)),
+			precommit_timer: Box::pin(precommit_timer.map(Ok)),
+			incoming,
+			outgoing,
+		}
+	}
+
+	fn proposed(
+		&self,
+		round: RoundNumber,
+		propose: PrimaryPropose<Block::Header>,
+	) -> Result<(), Self::Error> {
+		let local_id = match self.voter_set_state.voting_on(round) {
+			Some(id) => id,
+			None => return Ok(()),
+		};
+
+		self.update_voter_set_state(|voter_set_state| {
+			let (completed_rounds, current_rounds) = voter_set_state.with_current_round(round)?;
+			let current_round = current_rounds
+				.get(&round)
+				.expect("checked in with_current_round that key exists; qed.");
+
+			if !current_round.can_propose() {
+				// we've already proposed in this round (in a previous run),
+				// ignore the given vote and don't update the voter set
+				// state
+				return Ok(None)
+			}
+
+			let mut current_rounds = current_rounds.clone();
+			let current_round = current_rounds
+				.get_mut(&round)
+				.expect("checked previously that key exists; qed.");
+
+			*current_round = HasVoted::Yes(local_id, Vote::Propose(propose));
+
+			let set_state = VoterSetState::<Block>::Live {
+				completed_rounds: completed_rounds.clone(),
+				current_rounds,
+			};
+
+			crate::aux_schema::write_voter_set_state(&*self.client, &set_state)?;
+
+			Ok(Some(set_state))
+		})?;
+
+		Ok(())
+	}
+
+	fn prevoted(
+		&self,
+		round: RoundNumber,
+		prevote: Prevote<Block::Header>,
+	) -> Result<(), Self::Error> {
+		let local_id = match self.voter_set_state.voting_on(round) {
+			Some(id) => id,
+			None => return Ok(()),
+		};
+
+		let report_prevote_metrics = |prevote: &Prevote<Block::Header>| {
+			telemetry!(
+				self.telemetry;
+				CONSENSUS_DEBUG;
+				"afg.prevote_issued";
+				"round" => round,
+				"target_number" => ?prevote.target_number,
+				"target_hash" => ?prevote.target_hash,
+			);
+
+			if let Some(metrics) = self.metrics.as_ref() {
+				metrics.finality_grandpa_prevotes.inc();
+			}
+		};
+
+		self.update_voter_set_state(|voter_set_state| {
+			let (completed_rounds, current_rounds) = voter_set_state.with_current_round(round)?;
+			let current_round = current_rounds
+				.get(&round)
+				.expect("checked in with_current_round that key exists; qed.");
+
+			if !current_round.can_prevote() {
+				// we've already prevoted in this round (in a previous run),
+				// ignore the given vote and don't update the voter set
+				// state
+				return Ok(None)
+			}
+
+			// report to telemetry and prometheus
+			report_prevote_metrics(&prevote);
+
+			let propose = current_round.propose();
+
+			let mut current_rounds = current_rounds.clone();
+			let current_round = current_rounds
+				.get_mut(&round)
+				.expect("checked previously that key exists; qed.");
+
+			*current_round = HasVoted::Yes(local_id, Vote::Prevote(propose.cloned(), prevote));
+
+			let set_state = VoterSetState::<Block>::Live {
+				completed_rounds: completed_rounds.clone(),
+				current_rounds,
+			};
+
+			crate::aux_schema::write_voter_set_state(&*self.client, &set_state)?;
+
+			Ok(Some(set_state))
+		})?;
+
+		Ok(())
+	}
+
+	fn precommitted(
+		&self,
+		round: RoundNumber,
+		precommit: Precommit<Block::Header>,
+	) -> Result<(), Self::Error> {
+		let local_id = match self.voter_set_state.voting_on(round) {
+			Some(id) => id,
+			None => return Ok(()),
+		};
+
+		let report_precommit_metrics = |precommit: &Precommit<Block::Header>| {
+			telemetry!(
+				self.telemetry;
+				CONSENSUS_DEBUG;
+				"afg.precommit_issued";
+				"round" => round,
+				"target_number" => ?precommit.target_number,
+				"target_hash" => ?precommit.target_hash,
+			);
+
+			if let Some(metrics) = self.metrics.as_ref() {
+				metrics.finality_grandpa_precommits.inc();
+			}
+		};
+
+		self.update_voter_set_state(|voter_set_state| {
+			let (completed_rounds, current_rounds) = voter_set_state.with_current_round(round)?;
+			let current_round = current_rounds
+				.get(&round)
+				.expect("checked in with_current_round that key exists; qed.");
+
+			if !current_round.can_precommit() {
+				// we've already precommitted in this round (in a previous run),
+				// ignore the given vote and don't update the voter set
+				// state
+				return Ok(None)
+			}
+
+			// report to telemetry and prometheus
+			report_precommit_metrics(&precommit);
+
+			let propose = current_round.propose();
+			let prevote = match current_round {
+				HasVoted::Yes(_, Vote::Prevote(_, prevote)) => prevote,
+				_ => {
+					let msg = "Voter precommitting before prevoting.";
+					return Err(Error::Safety(msg.to_string()))
+				},
+			};
+
+			let mut current_rounds = current_rounds.clone();
+			let current_round = current_rounds
+				.get_mut(&round)
+				.expect("checked previously that key exists; qed.");
+
+			*current_round = HasVoted::Yes(
+				local_id,
+				Vote::Precommit(propose.cloned(), prevote.clone(), precommit),
+			);
+
+			let set_state = VoterSetState::<Block>::Live {
+				completed_rounds: completed_rounds.clone(),
+				current_rounds,
+			};
+
+			crate::aux_schema::write_voter_set_state(&*self.client, &set_state)?;
+
+			Ok(Some(set_state))
+		})?;
+
+		Ok(())
+	}
+
+	fn completed(
+		&self,
+		round: RoundNumber,
+		state: RoundState<Block::Hash, NumberFor<Block>>,
+		base: (Block::Hash, NumberFor<Block>),
+		historical_votes: &HistoricalVotes<Block>,
+	) -> Result<(), Self::Error> {
+		debug!(
+			target: LOG_TARGET,
+			"Voter {} completed round {} in set {}. Estimate = {:?}, Finalized in round = {:?}",
+			self.config.name(),
+			round,
+			self.set_id,
+			state.estimate.as_ref().map(|e| e.1),
+			state.finalized.as_ref().map(|e| e.1),
+		);
+
+		self.update_voter_set_state(|voter_set_state| {
+			// NOTE: we don't use `with_current_round` here, it is possible that
+			// we are not currently tracking this round if it is a round we
+			// caught up to.
+			let (completed_rounds, current_rounds) =
+				if let VoterSetState::Live { completed_rounds, current_rounds } = voter_set_state {
+					(completed_rounds, current_rounds)
+				} else {
+					let msg = "Voter acting while in paused state.";
+					return Err(Error::Safety(msg.to_string()))
+				};
+
+			let mut completed_rounds = completed_rounds.clone();
+
+			// TODO: Future integration will store the prevote and precommit index. See #2611.
+			let votes = historical_votes.seen().to_vec();
+
+			completed_rounds.push(CompletedRound {
+				number: round,
+				state: state.clone(),
+				base,
+				votes,
+			});
+
+			// remove the round from live rounds and start tracking the next round
+			let mut current_rounds = current_rounds.clone();
+			current_rounds.remove(&round);
+
+			// NOTE: this entry should always exist as GRANDPA rounds are always
+			// started in increasing order, still it's better to play it safe.
+			current_rounds.entry(round + 1).or_insert(HasVoted::No);
+
+			let set_state = VoterSetState::<Block>::Live { completed_rounds, current_rounds };
+
+			crate::aux_schema::write_voter_set_state(&*self.client, &set_state)?;
+
+			Ok(Some(set_state))
+		})?;
+
+		// clear any cached local authority id associated with this round
+		self.voter_set_state.finished_voting_on(round);
+
+		Ok(())
+	}
+
+	fn concluded(
+		&self,
+		round: RoundNumber,
+		state: RoundState<Block::Hash, NumberFor<Block>>,
+		_base: (Block::Hash, NumberFor<Block>),
+		historical_votes: &HistoricalVotes<Block>,
+	) -> Result<(), Self::Error> {
+		debug!(
+			target: LOG_TARGET,
+			"Voter {} concluded round {} in set {}. Estimate = {:?}, Finalized in round = {:?}",
+			self.config.name(),
+			round,
+			self.set_id,
+			state.estimate.as_ref().map(|e| e.1),
+			state.finalized.as_ref().map(|e| e.1),
+		);
+
+		self.update_voter_set_state(|voter_set_state| {
+			// NOTE: we don't use `with_current_round` here, because a concluded
+			// round is completed and cannot be current.
+			let (completed_rounds, current_rounds) =
+				if let VoterSetState::Live { completed_rounds, current_rounds } = voter_set_state {
+					(completed_rounds, current_rounds)
+				} else {
+					let msg = "Voter acting while in paused state.";
+					return Err(Error::Safety(msg.to_string()))
+				};
+
+			let mut completed_rounds = completed_rounds.clone();
+
+			if let Some(already_completed) =
+				completed_rounds.rounds.iter_mut().find(|r| r.number == round)
+			{
+				let n_existing_votes = already_completed.votes.len();
+
+				// the interface of Environment guarantees that the previous `historical_votes`
+				// from `completable` is a prefix of what is passed to `concluded`.
+				already_completed
+					.votes
+					.extend(historical_votes.seen().iter().skip(n_existing_votes).cloned());
+				already_completed.state = state;
+				crate::aux_schema::write_concluded_round(&*self.client, already_completed)?;
+			}
+
+			let set_state = VoterSetState::<Block>::Live {
+				completed_rounds,
+				current_rounds: current_rounds.clone(),
+			};
+
+			crate::aux_schema::write_voter_set_state(&*self.client, &set_state)?;
+
+			Ok(Some(set_state))
+		})?;
+
+		Ok(())
+	}
+
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		number: NumberFor<Block>,
+		round: RoundNumber,
+		commit: Commit<Block::Header>,
+	) -> Result<(), Self::Error> {
+		finalize_block(
+			self.client.clone(),
+			&self.authority_set,
+			Some(self.config.justification_generation_period),
+			hash,
+			number,
+			(round, commit).into(),
+			false,
+			self.justification_sender.as_ref(),
+			self.telemetry.clone(),
+		)
+	}
+
+	fn round_commit_timer(&self) -> Self::Timer {
+		use rand::{thread_rng, Rng};
+
+		// random between `[0, 2 * gossip_duration]` seconds.
+		let delay: u64 =
+			thread_rng().gen_range(0..2 * self.config.gossip_duration.as_millis() as u64);
+		Box::pin(Delay::new(Duration::from_millis(delay)).map(Ok))
+	}
+
+	fn prevote_equivocation(
+		&self,
+		_round: RoundNumber,
+		equivocation: finality_grandpa::Equivocation<
+			Self::Id,
+			Prevote<Block::Header>,
+			Self::Signature,
+		>,
+	) {
+		warn!(
+			target: LOG_TARGET,
+			"Detected prevote equivocation in the finality worker: {:?}", equivocation
+		);
+		if let Err(err) = self.report_equivocation(equivocation.into()) {
+			warn!(target: LOG_TARGET, "Error reporting prevote equivocation: {}", err);
+		}
+	}
+
+	fn precommit_equivocation(
+		&self,
+		_round: RoundNumber,
+		equivocation: finality_grandpa::Equivocation<
+			Self::Id,
+			Precommit<Block::Header>,
+			Self::Signature,
+		>,
+	) {
+		warn!(
+			target: LOG_TARGET,
+			"Detected precommit equivocation in the finality worker: {:?}", equivocation
+		);
+		if let Err(err) = self.report_equivocation(equivocation.into()) {
+			warn!(target: LOG_TARGET, "Error reporting precommit equivocation: {}", err);
+		}
+	}
+}
+
+pub(crate) enum JustificationOrCommit<Block: BlockT> {
+	Justification(GrandpaJustification<Block>),
+	Commit((RoundNumber, Commit<Block::Header>)),
+}
+
+impl<Block: BlockT> From<(RoundNumber, Commit<Block::Header>)> for JustificationOrCommit<Block> {
+	fn from(commit: (RoundNumber, Commit<Block::Header>)) -> JustificationOrCommit<Block> {
+		JustificationOrCommit::Commit(commit)
+	}
+}
+
+impl<Block: BlockT> From<GrandpaJustification<Block>> for JustificationOrCommit<Block> {
+	fn from(justification: GrandpaJustification<Block>) -> JustificationOrCommit<Block> {
+		JustificationOrCommit::Justification(justification)
+	}
+}
+
+async fn best_chain_containing<Block, Backend, Client, SelectChain, VotingRule>(
+	block: Block::Hash,
+	client: Arc<Client>,
+	authority_set: SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+	select_chain: SelectChain,
+	voting_rule: VotingRule,
+) -> Result<Option<(Block::Hash, NumberFor<Block>)>, Error>
+where
+	Backend: BackendT<Block>,
+	Block: BlockT,
+	Client: ClientForGrandpa<Block, Backend>,
+	SelectChain: SelectChainT<Block> + 'static,
+	VotingRule: VotingRuleT<Block, Client>,
+{
+	let base_header = match client.header(block)? {
+		Some(h) => h,
+		None => {
+			warn!(
+				target: LOG_TARGET,
+				"Encountered error finding best chain containing {:?}: couldn't find base block",
+				block,
+			);
+
+			return Ok(None)
+		},
+	};
+
+	// we refuse to vote beyond the current limit number where transitions are scheduled to occur.
+	// once blocks are finalized that make that transition irrelevant or activate it, we will
+	// proceed onwards. most of the time there will be no pending transition.  the limit, if any, is
+	// guaranteed to be higher than or equal to the given base number.
+	let limit = authority_set.current_limit(*base_header.number());
+	debug!(
+		target: LOG_TARGET,
+		"Finding best chain containing block {:?} with number limit {:?}", block, limit
+	);
+
+	let mut target_header = match select_chain.finality_target(block, None).await {
+		Ok(target_hash) => client
+			.header(target_hash)?
+			.expect("Header known to exist after `finality_target` call; qed"),
+		Err(err) => {
+			warn!(
+				target: LOG_TARGET,
+				"Encountered error finding best chain containing {:?}: couldn't find target block: {}",
+				block,
+				err,
+			);
+
+			return Ok(None)
+		},
+	};
+
+	// NOTE: this is purposefully done after `finality_target` to prevent a case
+	// where in-between these two requests there is a block import and
+	// `finality_target` returns something higher than `best_chain`.
+	let mut best_header = match select_chain.best_chain().await {
+		Ok(best_header) => best_header,
+		Err(err) => {
+			warn!(
+				target: LOG_TARGET,
+				"Encountered error finding best chain containing {:?}: couldn't find best block: {}",
+				block,
+				err,
+			);
+
+			return Ok(None)
+		},
+	};
+
+	let is_descendent_of = is_descendent_of(&*client, None);
+
+	if target_header.number() > best_header.number() ||
+		target_header.number() == best_header.number() &&
+			target_header.hash() != best_header.hash() ||
+		!is_descendent_of(&target_header.hash(), &best_header.hash())?
+	{
+		debug!(
+			target: LOG_TARGET,
+			"SelectChain returned a finality target inconsistent with its best block. Restricting best block to target block"
+		);
+
+		best_header = target_header.clone();
+	}
+
+	debug!(
+		target: LOG_TARGET,
+		"SelectChain: finality target: #{} ({}), best block: #{} ({})",
+		target_header.number(),
+		target_header.hash(),
+		best_header.number(),
+		best_header.hash(),
+	);
+
+	// check if our vote is currently being limited due to a pending change,
+	// in which case we will restrict our target header to the given limit
+	if let Some(target_number) = limit.filter(|limit| limit < target_header.number()) {
+		// walk backwards until we find the target block
+		loop {
+			if *target_header.number() < target_number {
+				unreachable!(
+					"we are traversing backwards from a known block; \
+					 blocks are stored contiguously; \
+					 qed"
+				);
+			}
+
+			if *target_header.number() == target_number {
+				break
+			}
+
+			target_header = client
+				.header(*target_header.parent_hash())?
+				.expect("Header known to exist after `finality_target` call; qed");
+		}
+
+		debug!(
+			target: LOG_TARGET,
+			"Finality target restricted to #{} ({}) due to pending authority set change",
+			target_header.number(),
+			target_header.hash()
+		)
+	}
+
+	// restrict vote according to the given voting rule, if the voting rule
+	// doesn't restrict the vote then we keep the previous target.
+	//
+	// we also make sure that the restricted vote is higher than the round base
+	// (i.e. last finalized), otherwise the value returned by the given voting
+	// rule is ignored and the original target is used instead.
+	Ok(voting_rule
+		.restrict_vote(client.clone(), &base_header, &best_header, &target_header)
+		.await
+		.filter(|(_, restricted_number)| {
+			// we can only restrict votes within the interval [base, target]
+			restricted_number >= base_header.number() && restricted_number < target_header.number()
+		})
+		.or_else(|| Some((target_header.hash(), *target_header.number()))))
+}
+
+/// Whether we should process a justification for the given block.
+///
+/// This can be used to decide whether to import a justification (when
+/// importing a block), or whether to generate a justification from a
+/// commit (when validating). Justifications for blocks that change the
+/// authority set will always be processed, otherwise we'll only process
+/// justifications if the last one was `justification_period` blocks ago.
+pub(crate) fn should_process_justification<BE, Block, Client>(
+	client: &Client,
+	justification_period: u32,
+	number: NumberFor<Block>,
+	enacts_change: bool,
+) -> bool
+where
+	Block: BlockT,
+	BE: BackendT<Block>,
+	Client: ClientForGrandpa<Block, BE>,
+{
+	if enacts_change {
+		return true
+	}
+
+	let last_finalized_number = client.info().finalized_number;
+
+	// keep the first justification before reaching the justification period
+	if last_finalized_number.is_zero() {
+		return true
+	}
+
+	last_finalized_number / justification_period.into() != number / justification_period.into()
+}
+
+/// Finalize the given block and apply any authority set changes. If an
+/// authority set change is enacted then a justification is created (if not
+/// given) and stored with the block when finalizing it.
+/// This method assumes that the block being finalized has already been imported.
+pub(crate) fn finalize_block<BE, Block, Client>(
+	client: Arc<Client>,
+	authority_set: &SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+	justification_generation_period: Option<u32>,
+	hash: Block::Hash,
+	number: NumberFor<Block>,
+	justification_or_commit: JustificationOrCommit<Block>,
+	initial_sync: bool,
+	justification_sender: Option<&GrandpaJustificationSender<Block>>,
+	telemetry: Option<TelemetryHandle>,
+) -> Result<(), CommandOrError<Block::Hash, NumberFor<Block>>>
+where
+	Block: BlockT,
+	BE: BackendT<Block>,
+	Client: ClientForGrandpa<Block, BE>,
+{
+	// NOTE: lock must be held through writing to DB to avoid race. this lock
+	//       also implicitly synchronizes the check for last finalized number
+	//       below.
+	let mut authority_set = authority_set.inner();
+
+	let status = client.info();
+
+	if number <= status.finalized_number && client.hash(number)? == Some(hash) {
+		// This can happen after a forced change (triggered manually from the runtime when
+		// finality is stalled), since the voter will be restarted at the median last finalized
+		// block, which can be lower than the local best finalized block.
+		warn!(target: LOG_TARGET, "Re-finalized block #{:?} ({:?}) in the canonical chain, current best finalized is #{:?}",
+				hash,
+				number,
+				status.finalized_number,
+		);
+
+		return Ok(())
+	}
+
+	// FIXME #1483: clone only when changed
+	let old_authority_set = authority_set.clone();
+
+	let update_res: Result<_, Error> = client.lock_import_and_run(|import_op| {
+		let status = authority_set
+			.apply_standard_changes(
+				hash,
+				number,
+				&is_descendent_of::<Block, _>(&*client, None),
+				initial_sync,
+				None,
+			)
+			.map_err(|e| Error::Safety(e.to_string()))?;
+
+		// send a justification notification if a sender exists and in case of error log it.
+		fn notify_justification<Block: BlockT>(
+			justification_sender: Option<&GrandpaJustificationSender<Block>>,
+			justification: impl FnOnce() -> Result<GrandpaJustification<Block>, Error>,
+		) {
+			if let Some(sender) = justification_sender {
+				if let Err(err) = sender.notify(justification) {
+					warn!(
+						target: LOG_TARGET,
+						"Error creating justification for subscriber: {}", err
+					);
+				}
+			}
+		}
+
+		// NOTE: this code assumes that honest voters will never vote past a
+		// transition block, thus we don't have to worry about the case where
+		// we have a transition with `effective_block = N`, but we finalize
+		// `N+1`. this assumption is required to make sure we store
+		// justifications for transition blocks which will be requested by
+		// syncing clients.
+		let (justification_required, justification) = match justification_or_commit {
+			JustificationOrCommit::Justification(justification) => (true, justification),
+			JustificationOrCommit::Commit((round_number, commit)) => {
+				let enacts_change = status.new_set_block.is_some();
+
+				let justification_required = justification_generation_period
+					.map(|period| {
+						should_process_justification(&*client, period, number, enacts_change)
+					})
+					.unwrap_or(enacts_change);
+
+				let justification =
+					GrandpaJustification::from_commit(&client, round_number, commit)?;
+
+				(justification_required, justification)
+			},
+		};
+
+		notify_justification(justification_sender, || Ok(justification.clone()));
+
+		let persisted_justification = if justification_required {
+			Some((GRANDPA_ENGINE_ID, justification.encode()))
+		} else {
+			None
+		};
+
+		// ideally some handle to a synchronization oracle would be used
+		// to avoid unconditionally notifying.
+		client
+			.apply_finality(import_op, hash, persisted_justification, true)
+			.map_err(|e| {
+				warn!(
+					target: LOG_TARGET,
+					"Error applying finality to block {:?}: {}",
+					(hash, number),
+					e
+				);
+				e
+			})?;
+
+		debug!(target: LOG_TARGET, "Finalizing blocks up to ({:?}, {})", number, hash);
+
+		telemetry!(
+			telemetry;
+			CONSENSUS_INFO;
+			"afg.finalized_blocks_up_to";
+			"number" => ?number, "hash" => ?hash,
+		);
+
+		crate::aux_schema::update_best_justification(&justification, |insert| {
+			apply_aux(import_op, insert, &[])
+		})?;
+
+		let new_authorities = if let Some((canon_hash, canon_number)) = status.new_set_block {
+			// the authority set has changed.
+			let (new_id, set_ref) = authority_set.current();
+
+			if set_ref.len() > 16 {
+				grandpa_log!(
+					initial_sync,
+					"👴 Applying GRANDPA set change to new set with {} authorities",
+					set_ref.len(),
+				);
+			} else {
+				grandpa_log!(
+					initial_sync,
+					"👴 Applying GRANDPA set change to new set {:?}",
+					set_ref
+				);
+			}
+
+			telemetry!(
+				telemetry;
+				CONSENSUS_INFO;
+				"afg.generating_new_authority_set";
+				"number" => ?canon_number, "hash" => ?canon_hash,
+				"authorities" => ?set_ref.to_vec(),
+				"set_id" => ?new_id,
+			);
+			Some(NewAuthoritySet {
+				canon_hash,
+				canon_number,
+				set_id: new_id,
+				authorities: set_ref.to_vec(),
+			})
+		} else {
+			None
+		};
+
+		if status.changed {
+			let write_result = crate::aux_schema::update_authority_set::<Block, _, _>(
+				&authority_set,
+				new_authorities.as_ref(),
+				|insert| apply_aux(import_op, insert, &[]),
+			);
+
+			if let Err(e) = write_result {
+				warn!(
+					target: LOG_TARGET,
+					"Failed to write updated authority set to disk. Bailing."
+				);
+				warn!(target: LOG_TARGET, "Node is in a potentially inconsistent state.");
+
+				return Err(e.into())
+			}
+		}
+
+		Ok(new_authorities.map(VoterCommand::ChangeAuthorities))
+	});
+
+	match update_res {
+		Ok(Some(command)) => Err(CommandOrError::VoterCommand(command)),
+		Ok(None) => Ok(()),
+		Err(e) => {
+			*authority_set = old_authority_set;
+
+			Err(CommandOrError::Error(e))
+		},
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/finality_proof.rs b/substrate/client/consensus/grandpa/src/finality_proof.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8a8a688583e34740b4bf49ca500ff15ee7239b1c
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/finality_proof.rs
@@ -0,0 +1,591 @@
+// 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/>.
+
+//! GRANDPA block finality proof generation and check.
+//!
+//! Finality of block B is proved by providing:
+//! 1) the justification for the descendant block F;
+//! 2) headers sub-chain (B; F] if B != F;
+//! 3) proof of GRANDPA::authorities() if the set changes at block F.
+//!
+//! Since earliest possible justification is returned, the GRANDPA authorities set
+//! at the block F is guaranteed to be the same as in the block B (this is because block
+//! that enacts new GRANDPA authorities set always comes with justification). It also
+//! means that the `set_id` is the same at blocks B and F.
+//!
+//! Let U be the last finalized block known to caller. If authorities set has changed several
+//! times in the (U; F] interval, multiple finality proof fragments are returned (one for each
+//! authority set change) and they must be verified in-order.
+//!
+//! Finality proof provider can choose how to provide finality proof on its own. The incomplete
+//! finality proof (that finalizes some block C that is ancestor of the B and descendant
+//! of the U) could be returned.
+
+use log::{trace, warn};
+use std::sync::Arc;
+
+use parity_scale_codec::{Decode, Encode};
+use sc_client_api::backend::Backend;
+use sp_blockchain::{Backend as BlockchainBackend, HeaderBackend};
+use sp_consensus_grandpa::GRANDPA_ENGINE_ID;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor, One},
+};
+
+use crate::{
+	authorities::{AuthoritySetChangeId, AuthoritySetChanges},
+	best_justification,
+	justification::GrandpaJustification,
+	SharedAuthoritySet, LOG_TARGET,
+};
+
+const MAX_UNKNOWN_HEADERS: usize = 100_000;
+
+/// Finality proof provider for serving network requests.
+#[derive(Clone)]
+pub struct FinalityProofProvider<BE, Block: BlockT> {
+	backend: Arc<BE>,
+	shared_authority_set: Option<SharedAuthoritySet<Block::Hash, NumberFor<Block>>>,
+}
+
+impl<B, Block> FinalityProofProvider<B, Block>
+where
+	Block: BlockT,
+	B: Backend<Block>,
+{
+	/// Create new finality proof provider using:
+	///
+	/// - backend for accessing blockchain data;
+	/// - authority_provider for calling and proving runtime methods.
+	/// - shared_authority_set for accessing authority set data
+	pub fn new(
+		backend: Arc<B>,
+		shared_authority_set: Option<SharedAuthoritySet<Block::Hash, NumberFor<Block>>>,
+	) -> Self {
+		FinalityProofProvider { backend, shared_authority_set }
+	}
+
+	/// Create new finality proof provider for the service using:
+	///
+	/// - backend for accessing blockchain data;
+	/// - storage_provider, which is generally a client.
+	/// - shared_authority_set for accessing authority set data
+	pub fn new_for_service(
+		backend: Arc<B>,
+		shared_authority_set: Option<SharedAuthoritySet<Block::Hash, NumberFor<Block>>>,
+	) -> Arc<Self> {
+		Arc::new(Self::new(backend, shared_authority_set))
+	}
+}
+
+impl<B, Block> FinalityProofProvider<B, Block>
+where
+	Block: BlockT,
+	B: Backend<Block>,
+{
+	/// Prove finality for the given block number by returning a Justification for the last block of
+	/// the authority set in bytes.
+	pub fn prove_finality(
+		&self,
+		block: NumberFor<Block>,
+	) -> Result<Option<Vec<u8>>, FinalityProofError> {
+		Ok(self.prove_finality_proof(block, true)?.map(|proof| proof.encode()))
+	}
+
+	/// Prove finality for the given block number by returning a Justification for the last block of
+	/// the authority set.
+	///
+	/// If `collect_unknown_headers` is true, the finality proof will include all headers from the
+	/// requested block until the block the justification refers to.
+	pub fn prove_finality_proof(
+		&self,
+		block: NumberFor<Block>,
+		collect_unknown_headers: bool,
+	) -> Result<Option<FinalityProof<Block::Header>>, FinalityProofError> {
+		let authority_set_changes = if let Some(changes) = self
+			.shared_authority_set
+			.as_ref()
+			.map(SharedAuthoritySet::authority_set_changes)
+		{
+			changes
+		} else {
+			return Ok(None)
+		};
+
+		prove_finality(&*self.backend, authority_set_changes, block, collect_unknown_headers)
+	}
+}
+
+/// Finality for block B is proved by providing:
+/// 1) the justification for the descendant block F;
+/// 2) headers sub-chain (B; F] if B != F;
+#[derive(Debug, PartialEq, Encode, Decode, Clone)]
+pub struct FinalityProof<Header: HeaderT> {
+	/// The hash of block F for which justification is provided.
+	pub block: Header::Hash,
+	/// Justification of the block F.
+	pub justification: Vec<u8>,
+	/// The set of headers in the range (B; F] that we believe are unknown to the caller. Ordered.
+	pub unknown_headers: Vec<Header>,
+}
+
+/// Errors occurring when trying to prove finality
+#[derive(Debug, thiserror::Error)]
+pub enum FinalityProofError {
+	/// The requested block has not yet been finalized.
+	#[error("Block not yet finalized")]
+	BlockNotYetFinalized,
+	/// The requested block is not covered by authority set changes. Likely this means the block is
+	/// in the latest authority set, and the subscription API is more appropriate.
+	#[error("Block not covered by authority set changes")]
+	BlockNotInAuthoritySetChanges,
+	/// Errors originating from the client.
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+}
+
+/// Prove finality for the given block number by returning a justification for the last block of
+/// the authority set of which the given block is part of, or a justification for the latest
+/// finalized block if the given block is part of the current authority set.
+///
+/// If `collect_unknown_headers` is true, the finality proof will include all headers from the
+/// requested block until the block the justification refers to.
+fn prove_finality<Block, B>(
+	backend: &B,
+	authority_set_changes: AuthoritySetChanges<NumberFor<Block>>,
+	block: NumberFor<Block>,
+	collect_unknown_headers: bool,
+) -> Result<Option<FinalityProof<Block::Header>>, FinalityProofError>
+where
+	Block: BlockT,
+	B: Backend<Block>,
+{
+	// Early-return if we are sure that there are no blocks finalized that cover the requested
+	// block.
+	let finalized_number = backend.blockchain().info().finalized_number;
+	if finalized_number < block {
+		let err = format!(
+			"Requested finality proof for descendant of #{} while we only have finalized #{}.",
+			block, finalized_number,
+		);
+		trace!(target: LOG_TARGET, "{}", &err);
+		return Err(FinalityProofError::BlockNotYetFinalized)
+	}
+
+	let (justification, just_block) = match authority_set_changes.get_set_id(block) {
+		AuthoritySetChangeId::Latest => {
+			if let Some(justification) = best_justification(backend)?
+				.map(|j: GrandpaJustification<Block>| (j.encode(), j.target().0))
+			{
+				justification
+			} else {
+				trace!(
+					target: LOG_TARGET,
+					"No justification found for the latest finalized block. \
+					Returning empty proof.",
+				);
+				return Ok(None)
+			}
+		},
+		AuthoritySetChangeId::Set(_, last_block_for_set) => {
+			let last_block_for_set_id = backend
+				.blockchain()
+				.expect_block_hash_from_id(&BlockId::Number(last_block_for_set))?;
+			let justification = if let Some(grandpa_justification) = backend
+				.blockchain()
+				.justifications(last_block_for_set_id)?
+				.and_then(|justifications| justifications.into_justification(GRANDPA_ENGINE_ID))
+			{
+				grandpa_justification
+			} else {
+				trace!(
+					target: LOG_TARGET,
+					"No justification found when making finality proof for {}. \
+					Returning empty proof.",
+					block,
+				);
+				return Ok(None)
+			};
+			(justification, last_block_for_set)
+		},
+		AuthoritySetChangeId::Unknown => {
+			warn!(
+				target: LOG_TARGET,
+				"AuthoritySetChanges does not cover the requested block #{} due to missing data. \
+				 You need to resync to populate AuthoritySetChanges properly.",
+				block,
+			);
+			return Err(FinalityProofError::BlockNotInAuthoritySetChanges)
+		},
+	};
+
+	let mut headers = Vec::new();
+	if collect_unknown_headers {
+		// Collect all headers from the requested block until the last block of the set
+		let mut current = block + One::one();
+		loop {
+			if current > just_block || headers.len() >= MAX_UNKNOWN_HEADERS {
+				break
+			}
+			let hash = backend.blockchain().expect_block_hash_from_id(&BlockId::Number(current))?;
+			headers.push(backend.blockchain().expect_header(hash)?);
+			current += One::one();
+		}
+	};
+
+	Ok(Some(FinalityProof {
+		block: backend.blockchain().expect_block_hash_from_id(&BlockId::Number(just_block))?,
+		justification,
+		unknown_headers: headers,
+	}))
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{authorities::AuthoritySetChanges, BlockNumberOps, ClientError, SetId};
+	use futures::executor::block_on;
+	use sc_block_builder::BlockBuilderProvider;
+	use sc_client_api::{apply_aux, LockImportRun};
+	use sp_consensus::BlockOrigin;
+	use sp_consensus_grandpa::GRANDPA_ENGINE_ID as ID;
+	use sp_core::crypto::UncheckedFrom;
+	use sp_keyring::Ed25519Keyring;
+	use substrate_test_runtime_client::{
+		runtime::{Block, Header, H256},
+		Backend as TestBackend, ClientBlockImportExt, ClientExt, DefaultTestClientBuilderExt,
+		TestClient, TestClientBuilder, TestClientBuilderExt,
+	};
+
+	/// Check GRANDPA proof-of-finality for the given block.
+	///
+	/// Returns the vector of headers that MUST be validated + imported
+	/// AND if at least one of those headers is invalid, all other MUST be considered invalid.
+	fn check_finality_proof<Block: BlockT>(
+		current_set_id: SetId,
+		current_authorities: sp_consensus_grandpa::AuthorityList,
+		remote_proof: Vec<u8>,
+	) -> sp_blockchain::Result<super::FinalityProof<Block::Header>>
+	where
+		NumberFor<Block>: BlockNumberOps,
+	{
+		let proof = super::FinalityProof::<Block::Header>::decode(&mut &remote_proof[..])
+			.map_err(|_| ClientError::BadJustification("failed to decode finality proof".into()))?;
+
+		let justification: GrandpaJustification<Block> =
+			Decode::decode(&mut &proof.justification[..])
+				.map_err(|_| ClientError::JustificationDecode)?;
+
+		justification.verify(current_set_id, &current_authorities)?;
+
+		Ok(proof)
+	}
+
+	pub(crate) type FinalityProof = super::FinalityProof<Header>;
+
+	fn header(number: u64) -> Header {
+		let parent_hash = match number {
+			0 => Default::default(),
+			_ => header(number - 1).hash(),
+		};
+		Header::new(
+			number,
+			H256::from_low_u64_be(0),
+			H256::from_low_u64_be(0),
+			parent_hash,
+			Default::default(),
+		)
+	}
+
+	fn test_blockchain(
+		number_of_blocks: u64,
+		to_finalize: &[u64],
+	) -> (Arc<TestClient>, Arc<TestBackend>, Vec<Block>) {
+		let builder = TestClientBuilder::new();
+		let backend = builder.backend();
+		let mut client = Arc::new(builder.build());
+
+		let mut blocks = Vec::new();
+		for _ in 0..number_of_blocks {
+			let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+			block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+			blocks.push(block);
+		}
+
+		for block in to_finalize {
+			let hash = blocks[*block as usize - 1].hash();
+			client.finalize_block(hash, None).unwrap();
+		}
+		(client, backend, blocks)
+	}
+
+	fn store_best_justification(client: &TestClient, just: &GrandpaJustification<Block>) {
+		client
+			.lock_import_and_run(|import_op| {
+				crate::aux_schema::update_best_justification(just, |insert| {
+					apply_aux(import_op, insert, &[])
+				})
+			})
+			.unwrap();
+	}
+
+	#[test]
+	fn finality_proof_fails_if_no_more_last_finalized_blocks() {
+		let (_, backend, _) = test_blockchain(6, &[4]);
+		let authority_set_changes = AuthoritySetChanges::empty();
+
+		// The last finalized block is 4, so we cannot provide further justifications.
+		let proof_of_5 = prove_finality(&*backend, authority_set_changes, 5, true);
+		assert!(matches!(proof_of_5, Err(FinalityProofError::BlockNotYetFinalized)));
+	}
+
+	#[test]
+	fn finality_proof_is_none_if_no_justification_known() {
+		let (_, backend, _) = test_blockchain(6, &[4]);
+
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(0, 4);
+
+		// Block 4 is finalized without justification
+		// => we can't prove finality of 3
+		let proof_of_3 = prove_finality(&*backend, authority_set_changes, 3, true).unwrap();
+		assert_eq!(proof_of_3, None);
+	}
+
+	#[test]
+	fn finality_proof_check_fails_when_proof_decode_fails() {
+		// When we can't decode proof from Vec<u8>
+		check_finality_proof::<Block>(
+			1,
+			vec![(UncheckedFrom::unchecked_from([3u8; 32]), 1u64)],
+			vec![42],
+		)
+		.unwrap_err();
+	}
+
+	#[test]
+	fn finality_proof_check_fails_when_proof_is_empty() {
+		// When decoded proof has zero length
+		check_finality_proof::<Block>(
+			1,
+			vec![(UncheckedFrom::unchecked_from([3u8; 32]), 1u64)],
+			Vec::<GrandpaJustification<Block>>::new().encode(),
+		)
+		.unwrap_err();
+	}
+
+	#[test]
+	fn finality_proof_check_fails_with_incomplete_justification() {
+		let (_, _, blocks) = test_blockchain(8, &[4, 5, 8]);
+
+		// Create a commit without precommits
+		let commit = finality_grandpa::Commit {
+			target_hash: blocks[7].hash(),
+			target_number: *blocks[7].header().number(),
+			precommits: Vec::new(),
+		};
+
+		let grandpa_just: GrandpaJustification<Block> =
+			sp_consensus_grandpa::GrandpaJustification::<Header> {
+				round: 8,
+				votes_ancestries: Vec::new(),
+				commit,
+			}
+			.into();
+
+		let finality_proof = FinalityProof {
+			block: header(2).hash(),
+			justification: grandpa_just.encode(),
+			unknown_headers: Vec::new(),
+		};
+
+		check_finality_proof::<Block>(
+			1,
+			vec![(UncheckedFrom::unchecked_from([3u8; 32]), 1u64)],
+			finality_proof.encode(),
+		)
+		.unwrap_err();
+	}
+
+	fn create_commit<S, Id>(
+		block: Block,
+		round: u64,
+		set_id: SetId,
+		auth: &[Ed25519Keyring],
+	) -> finality_grandpa::Commit<H256, u64, S, Id>
+	where
+		Id: From<sp_core::ed25519::Public>,
+		S: From<sp_core::ed25519::Signature>,
+	{
+		let mut precommits = Vec::new();
+
+		for voter in auth {
+			let precommit = finality_grandpa::Precommit {
+				target_hash: block.hash(),
+				target_number: *block.header().number(),
+			};
+
+			let msg = finality_grandpa::Message::Precommit(precommit.clone());
+			let encoded = sp_consensus_grandpa::localized_payload(round, set_id, &msg);
+			let signature = voter.sign(&encoded[..]).into();
+
+			let signed_precommit = finality_grandpa::SignedPrecommit {
+				precommit,
+				signature,
+				id: voter.public().into(),
+			};
+			precommits.push(signed_precommit);
+		}
+
+		finality_grandpa::Commit {
+			target_hash: block.hash(),
+			target_number: *block.header().number(),
+			precommits,
+		}
+	}
+
+	#[test]
+	fn finality_proof_check_works_with_correct_justification() {
+		let (client, _, blocks) = test_blockchain(8, &[4, 5, 8]);
+
+		let alice = Ed25519Keyring::Alice;
+		let set_id = 1;
+		let round = 8;
+		let commit = create_commit(blocks[7].clone(), round, set_id, &[alice]);
+		let grandpa_just = GrandpaJustification::from_commit(&client, round, commit).unwrap();
+
+		let finality_proof = FinalityProof {
+			block: header(2).hash(),
+			justification: grandpa_just.encode(),
+			unknown_headers: Vec::new(),
+		};
+		assert_eq!(
+			finality_proof,
+			check_finality_proof::<Block>(
+				set_id,
+				vec![(alice.public().into(), 1u64)],
+				finality_proof.encode(),
+			)
+			.unwrap(),
+		);
+	}
+
+	#[test]
+	fn finality_proof_using_authority_set_changes_fails_with_undefined_start() {
+		let (_, backend, _) = test_blockchain(8, &[4, 5, 8]);
+
+		// We have stored the correct block number for the relevant set, but as we are missing the
+		// block for the preceding set the start is not well-defined.
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(1, 8);
+
+		let proof_of_6 = prove_finality(&*backend, authority_set_changes, 6, true);
+		assert!(matches!(proof_of_6, Err(FinalityProofError::BlockNotInAuthoritySetChanges)));
+	}
+
+	#[test]
+	fn finality_proof_using_authority_set_changes_works() {
+		let (client, backend, blocks) = test_blockchain(8, &[4, 5]);
+		let block7 = &blocks[6];
+		let block8 = &blocks[7];
+
+		let round = 8;
+		let commit = create_commit(block8.clone(), round, 1, &[Ed25519Keyring::Alice]);
+		let grandpa_just8 = GrandpaJustification::from_commit(&client, round, commit).unwrap();
+
+		client
+			.finalize_block(block8.hash(), Some((ID, grandpa_just8.encode().clone())))
+			.unwrap();
+
+		// Authority set change at block 8, so the justification stored there will be used in the
+		// FinalityProof for block 6
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(0, 5);
+		authority_set_changes.append(1, 8);
+
+		let proof_of_6: FinalityProof =
+			prove_finality(&*backend, authority_set_changes.clone(), 6, true)
+				.unwrap()
+				.unwrap();
+
+		assert_eq!(
+			proof_of_6,
+			FinalityProof {
+				block: block8.hash(),
+				justification: grandpa_just8.encode(),
+				unknown_headers: vec![block7.header().clone(), block8.header().clone()],
+			},
+		);
+
+		let proof_of_6_without_unknown: FinalityProof =
+			prove_finality(&*backend, authority_set_changes.clone(), 6, false)
+				.unwrap()
+				.unwrap();
+
+		assert_eq!(
+			proof_of_6_without_unknown,
+			FinalityProof {
+				block: block8.hash(),
+				justification: grandpa_just8.encode(),
+				unknown_headers: vec![],
+			},
+		);
+	}
+
+	#[test]
+	fn finality_proof_in_last_set_fails_without_latest() {
+		let (_, backend, _) = test_blockchain(8, &[4, 5, 8]);
+
+		// No recent authority set change, so we are in the latest set, and we will try to pickup
+		// the best stored justification, for which there is none in this case.
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(0, 5);
+
+		assert!(matches!(prove_finality(&*backend, authority_set_changes, 6, true), Ok(None)));
+	}
+
+	#[test]
+	fn finality_proof_in_last_set_using_latest_justification_works() {
+		let (client, backend, blocks) = test_blockchain(8, &[4, 5, 8]);
+		let block7 = &blocks[6];
+		let block8 = &blocks[7];
+
+		let round = 8;
+		let commit = create_commit(block8.clone(), round, 1, &[Ed25519Keyring::Alice]);
+		let grandpa_just8 = GrandpaJustification::from_commit(&client, round, commit).unwrap();
+		store_best_justification(&client, &grandpa_just8);
+
+		// No recent authority set change, so we are in the latest set, and will pickup the best
+		// stored justification
+		let mut authority_set_changes = AuthoritySetChanges::empty();
+		authority_set_changes.append(0, 5);
+
+		let proof_of_6: FinalityProof =
+			prove_finality(&*backend, authority_set_changes, 6, true).unwrap().unwrap();
+
+		assert_eq!(
+			proof_of_6,
+			FinalityProof {
+				block: block8.hash(),
+				justification: grandpa_just8.encode(),
+				unknown_headers: vec![block7.header().clone(), block8.header().clone()],
+			}
+		);
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/import.rs b/substrate/client/consensus/grandpa/src/import.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8481b395847292173b4fa89206d9610d5aa767e0
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/import.rs
@@ -0,0 +1,844 @@
+// 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 std::{collections::HashMap, marker::PhantomData, sync::Arc};
+
+use log::debug;
+use parity_scale_codec::Decode;
+
+use sc_client_api::{backend::Backend, utils::is_descendent_of};
+use sc_consensus::{
+	shared_data::{SharedDataLocked, SharedDataLockedUpgradable},
+	BlockCheckParams, BlockImport, BlockImportParams, ImportResult, JustificationImport,
+};
+use sc_telemetry::TelemetryHandle;
+use sc_utils::mpsc::TracingUnboundedSender;
+use sp_api::{Core, RuntimeApiInfo};
+use sp_blockchain::BlockStatus;
+use sp_consensus::{BlockOrigin, Error as ConsensusError, SelectChain};
+use sp_consensus_grandpa::{ConsensusLog, GrandpaApi, ScheduledChange, SetId, GRANDPA_ENGINE_ID};
+use sp_core::hashing::twox_128;
+use sp_runtime::{
+	generic::OpaqueDigestItemId,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero},
+	Justification,
+};
+
+use crate::{
+	authorities::{AuthoritySet, DelayKind, PendingChange, SharedAuthoritySet},
+	environment,
+	justification::GrandpaJustification,
+	notification::GrandpaJustificationSender,
+	AuthoritySetChanges, ClientForGrandpa, CommandOrError, Error, NewAuthoritySet, VoterCommand,
+	LOG_TARGET,
+};
+
+/// A block-import handler for GRANDPA.
+///
+/// This scans each imported block for signals of changing authority set.
+/// If the block being imported enacts an authority set change then:
+/// - If the current authority set is still live: we import the block
+/// - Otherwise, the block must include a valid justification.
+///
+/// When using GRANDPA, the block import worker should be using this block import
+/// object.
+pub struct GrandpaBlockImport<Backend, Block: BlockT, Client, SC> {
+	inner: Arc<Client>,
+	justification_import_period: u32,
+	select_chain: SC,
+	authority_set: SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+	send_voter_commands: TracingUnboundedSender<VoterCommand<Block::Hash, NumberFor<Block>>>,
+	authority_set_hard_forks: HashMap<Block::Hash, PendingChange<Block::Hash, NumberFor<Block>>>,
+	justification_sender: GrandpaJustificationSender<Block>,
+	telemetry: Option<TelemetryHandle>,
+	_phantom: PhantomData<Backend>,
+}
+
+impl<Backend, Block: BlockT, Client, SC: Clone> Clone
+	for GrandpaBlockImport<Backend, Block, Client, SC>
+{
+	fn clone(&self) -> Self {
+		GrandpaBlockImport {
+			inner: self.inner.clone(),
+			justification_import_period: self.justification_import_period,
+			select_chain: self.select_chain.clone(),
+			authority_set: self.authority_set.clone(),
+			send_voter_commands: self.send_voter_commands.clone(),
+			authority_set_hard_forks: self.authority_set_hard_forks.clone(),
+			justification_sender: self.justification_sender.clone(),
+			telemetry: self.telemetry.clone(),
+			_phantom: PhantomData,
+		}
+	}
+}
+
+#[async_trait::async_trait]
+impl<BE, Block: BlockT, Client, SC> JustificationImport<Block>
+	for GrandpaBlockImport<BE, Block, Client, SC>
+where
+	NumberFor<Block>: finality_grandpa::BlockNumberOps,
+	BE: Backend<Block>,
+	Client: ClientForGrandpa<Block, BE>,
+	SC: SelectChain<Block>,
+{
+	type Error = ConsensusError;
+
+	async fn on_start(&mut self) -> Vec<(Block::Hash, NumberFor<Block>)> {
+		let mut out = Vec::new();
+		let chain_info = self.inner.info();
+
+		// request justifications for all pending changes for which change blocks have already been
+		// imported
+		let pending_changes: Vec<_> =
+			self.authority_set.inner().pending_changes().cloned().collect();
+
+		for pending_change in pending_changes {
+			if pending_change.delay_kind == DelayKind::Finalized &&
+				pending_change.effective_number() > chain_info.finalized_number &&
+				pending_change.effective_number() <= chain_info.best_number
+			{
+				let effective_block_hash = if !pending_change.delay.is_zero() {
+					self.select_chain
+						.finality_target(
+							pending_change.canon_hash,
+							Some(pending_change.effective_number()),
+						)
+						.await
+				} else {
+					Ok(pending_change.canon_hash)
+				};
+
+				if let Ok(hash) = effective_block_hash {
+					if let Ok(Some(header)) = self.inner.header(hash) {
+						if *header.number() == pending_change.effective_number() {
+							out.push((header.hash(), *header.number()));
+						}
+					}
+				}
+			}
+		}
+
+		out
+	}
+
+	async fn import_justification(
+		&mut self,
+		hash: Block::Hash,
+		number: NumberFor<Block>,
+		justification: Justification,
+	) -> Result<(), Self::Error> {
+		// this justification was requested by the sync service, therefore we
+		// are not sure if it should enact a change or not. it could have been a
+		// request made as part of initial sync but that means the justification
+		// wasn't part of the block and was requested asynchronously, probably
+		// makes sense to log in that case.
+		GrandpaBlockImport::import_justification(self, hash, number, justification, false, false)
+	}
+}
+
+enum AppliedChanges<H, N> {
+	Standard(bool), // true if the change is ready to be applied (i.e. it's a root)
+	Forced(NewAuthoritySet<H, N>),
+	None,
+}
+
+impl<H, N> AppliedChanges<H, N> {
+	fn needs_justification(&self) -> bool {
+		match *self {
+			AppliedChanges::Standard(_) => true,
+			AppliedChanges::Forced(_) | AppliedChanges::None => false,
+		}
+	}
+}
+
+struct PendingSetChanges<Block: BlockT> {
+	just_in_case: Option<(
+		AuthoritySet<Block::Hash, NumberFor<Block>>,
+		SharedDataLockedUpgradable<AuthoritySet<Block::Hash, NumberFor<Block>>>,
+	)>,
+	applied_changes: AppliedChanges<Block::Hash, NumberFor<Block>>,
+	do_pause: bool,
+}
+
+impl<Block: BlockT> PendingSetChanges<Block> {
+	// revert the pending set change explicitly.
+	fn revert(self) {}
+
+	fn defuse(mut self) -> (AppliedChanges<Block::Hash, NumberFor<Block>>, bool) {
+		self.just_in_case = None;
+		let applied_changes = std::mem::replace(&mut self.applied_changes, AppliedChanges::None);
+		(applied_changes, self.do_pause)
+	}
+}
+
+impl<Block: BlockT> Drop for PendingSetChanges<Block> {
+	fn drop(&mut self) {
+		if let Some((old_set, mut authorities)) = self.just_in_case.take() {
+			*authorities.upgrade() = old_set;
+		}
+	}
+}
+
+/// Checks the given header for a consensus digest signalling a **standard** scheduled change and
+/// extracts it.
+pub fn find_scheduled_change<B: BlockT>(
+	header: &B::Header,
+) -> Option<ScheduledChange<NumberFor<B>>> {
+	let id = OpaqueDigestItemId::Consensus(&GRANDPA_ENGINE_ID);
+
+	let filter_log = |log: ConsensusLog<NumberFor<B>>| match log {
+		ConsensusLog::ScheduledChange(change) => Some(change),
+		_ => None,
+	};
+
+	// find the first consensus digest with the right ID which converts to
+	// the right kind of consensus log.
+	header.digest().convert_first(|l| l.try_to(id).and_then(filter_log))
+}
+
+/// Checks the given header for a consensus digest signalling a **forced** scheduled change and
+/// extracts it.
+pub fn find_forced_change<B: BlockT>(
+	header: &B::Header,
+) -> Option<(NumberFor<B>, ScheduledChange<NumberFor<B>>)> {
+	let id = OpaqueDigestItemId::Consensus(&GRANDPA_ENGINE_ID);
+
+	let filter_log = |log: ConsensusLog<NumberFor<B>>| match log {
+		ConsensusLog::ForcedChange(delay, change) => Some((delay, change)),
+		_ => None,
+	};
+
+	// find the first consensus digest with the right ID which converts to
+	// the right kind of consensus log.
+	header.digest().convert_first(|l| l.try_to(id).and_then(filter_log))
+}
+
+impl<BE, Block: BlockT, Client, SC> GrandpaBlockImport<BE, Block, Client, SC>
+where
+	NumberFor<Block>: finality_grandpa::BlockNumberOps,
+	BE: Backend<Block>,
+	Client: ClientForGrandpa<Block, BE>,
+	Client::Api: GrandpaApi<Block>,
+	for<'a> &'a Client: BlockImport<Block, Error = ConsensusError>,
+{
+	// check for a new authority set change.
+	fn check_new_change(
+		&self,
+		header: &Block::Header,
+		hash: Block::Hash,
+	) -> Option<PendingChange<Block::Hash, NumberFor<Block>>> {
+		// check for forced authority set hard forks
+		if let Some(change) = self.authority_set_hard_forks.get(&hash) {
+			return Some(change.clone())
+		}
+
+		// check for forced change.
+		if let Some((median_last_finalized, change)) = find_forced_change::<Block>(header) {
+			return Some(PendingChange {
+				next_authorities: change.next_authorities,
+				delay: change.delay,
+				canon_height: *header.number(),
+				canon_hash: hash,
+				delay_kind: DelayKind::Best { median_last_finalized },
+			})
+		}
+
+		// check normal scheduled change.
+		let change = find_scheduled_change::<Block>(header)?;
+		Some(PendingChange {
+			next_authorities: change.next_authorities,
+			delay: change.delay,
+			canon_height: *header.number(),
+			canon_hash: hash,
+			delay_kind: DelayKind::Finalized,
+		})
+	}
+
+	fn make_authorities_changes(
+		&self,
+		block: &mut BlockImportParams<Block>,
+		hash: Block::Hash,
+		initial_sync: bool,
+	) -> Result<PendingSetChanges<Block>, ConsensusError> {
+		// when we update the authorities, we need to hold the lock
+		// until the block is written to prevent a race if we need to restore
+		// the old authority set on error or panic.
+		struct InnerGuard<'a, H, N> {
+			old: Option<AuthoritySet<H, N>>,
+			guard: Option<SharedDataLocked<'a, AuthoritySet<H, N>>>,
+		}
+
+		impl<'a, H, N> InnerGuard<'a, H, N> {
+			fn as_mut(&mut self) -> &mut AuthoritySet<H, N> {
+				self.guard.as_mut().expect("only taken on deconstruction; qed")
+			}
+
+			fn set_old(&mut self, old: AuthoritySet<H, N>) {
+				if self.old.is_none() {
+					// ignore "newer" old changes.
+					self.old = Some(old);
+				}
+			}
+
+			fn consume(
+				mut self,
+			) -> Option<(AuthoritySet<H, N>, SharedDataLocked<'a, AuthoritySet<H, N>>)> {
+				self.old
+					.take()
+					.map(|old| (old, self.guard.take().expect("only taken on deconstruction; qed")))
+			}
+		}
+
+		impl<'a, H, N> Drop for InnerGuard<'a, H, N> {
+			fn drop(&mut self) {
+				if let (Some(mut guard), Some(old)) = (self.guard.take(), self.old.take()) {
+					*guard = old;
+				}
+			}
+		}
+
+		let number = *(block.header.number());
+		let maybe_change = self.check_new_change(&block.header, hash);
+
+		// returns a function for checking whether a block is a descendent of another
+		// consistent with querying client directly after importing the block.
+		let parent_hash = *block.header.parent_hash();
+		let is_descendent_of = is_descendent_of(&*self.inner, Some((hash, parent_hash)));
+
+		let mut guard = InnerGuard { guard: Some(self.authority_set.inner_locked()), old: None };
+
+		// whether to pause the old authority set -- happens after import
+		// of a forced change block.
+		let mut do_pause = false;
+
+		// add any pending changes.
+		if let Some(change) = maybe_change {
+			let old = guard.as_mut().clone();
+			guard.set_old(old);
+
+			if let DelayKind::Best { .. } = change.delay_kind {
+				do_pause = true;
+			}
+
+			guard
+				.as_mut()
+				.add_pending_change(change, &is_descendent_of)
+				.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+		}
+
+		let applied_changes = {
+			let forced_change_set = guard
+				.as_mut()
+				.apply_forced_changes(
+					hash,
+					number,
+					&is_descendent_of,
+					initial_sync,
+					self.telemetry.clone(),
+				)
+				.map_err(|e| ConsensusError::ClientImport(e.to_string()))
+				.map_err(ConsensusError::from)?;
+
+			if let Some((median_last_finalized_number, new_set)) = forced_change_set {
+				let new_authorities = {
+					let (set_id, new_authorities) = new_set.current();
+
+					// we will use the median last finalized number as a hint
+					// for the canon block the new authority set should start
+					// with. we use the minimum between the median and the local
+					// best finalized block.
+					let best_finalized_number = self.inner.info().finalized_number;
+					let canon_number = best_finalized_number.min(median_last_finalized_number);
+					let canon_hash = self.inner.hash(canon_number)
+							.map_err(|e| ConsensusError::ClientImport(e.to_string()))?
+							.expect(
+								"the given block number is less or equal than the current best finalized number; \
+								 current best finalized number must exist in chain; qed."
+							);
+
+					NewAuthoritySet {
+						canon_number,
+						canon_hash,
+						set_id,
+						authorities: new_authorities.to_vec(),
+					}
+				};
+				let old = ::std::mem::replace(guard.as_mut(), new_set);
+				guard.set_old(old);
+
+				AppliedChanges::Forced(new_authorities)
+			} else {
+				let did_standard = guard
+					.as_mut()
+					.enacts_standard_change(hash, number, &is_descendent_of)
+					.map_err(|e| ConsensusError::ClientImport(e.to_string()))
+					.map_err(ConsensusError::from)?;
+
+				if let Some(root) = did_standard {
+					AppliedChanges::Standard(root)
+				} else {
+					AppliedChanges::None
+				}
+			}
+		};
+
+		// consume the guard safely and write necessary changes.
+		let just_in_case = guard.consume();
+		if let Some((_, ref authorities)) = just_in_case {
+			let authorities_change = match applied_changes {
+				AppliedChanges::Forced(ref new) => Some(new),
+				AppliedChanges::Standard(_) => None, // the change isn't actually applied yet.
+				AppliedChanges::None => None,
+			};
+
+			crate::aux_schema::update_authority_set::<Block, _, _>(
+				authorities,
+				authorities_change,
+				|insert| {
+					block
+						.auxiliary
+						.extend(insert.iter().map(|(k, v)| (k.to_vec(), Some(v.to_vec()))))
+				},
+			);
+		}
+
+		let just_in_case = just_in_case.map(|(o, i)| (o, i.release_mutex()));
+
+		Ok(PendingSetChanges { just_in_case, applied_changes, do_pause })
+	}
+
+	/// Read current set id form a given state.
+	fn current_set_id(&self, hash: Block::Hash) -> Result<SetId, ConsensusError> {
+		let runtime_version = self.inner.runtime_api().version(hash).map_err(|e| {
+			ConsensusError::ClientImport(format!(
+				"Unable to retrieve current runtime version. {}",
+				e
+			))
+		})?;
+
+		if runtime_version
+			.api_version(&<dyn GrandpaApi<Block>>::ID)
+			.map_or(false, |v| v < 3)
+		{
+			// The new API is not supported in this runtime. Try reading directly from storage.
+			// This code may be removed once warp sync to an old runtime is no longer needed.
+			for prefix in ["GrandpaFinality", "Grandpa"] {
+				let k = [twox_128(prefix.as_bytes()), twox_128(b"CurrentSetId")].concat();
+				if let Ok(Some(id)) =
+					self.inner.storage(hash, &sc_client_api::StorageKey(k.to_vec()))
+				{
+					if let Ok(id) = SetId::decode(&mut id.0.as_ref()) {
+						return Ok(id)
+					}
+				}
+			}
+			Err(ConsensusError::ClientImport("Unable to retrieve current set id.".into()))
+		} else {
+			self.inner
+				.runtime_api()
+				.current_set_id(hash)
+				.map_err(|e| ConsensusError::ClientImport(e.to_string()))
+		}
+	}
+
+	/// Import whole new state and reset authority set.
+	async fn import_state(
+		&mut self,
+		mut block: BlockImportParams<Block>,
+	) -> Result<ImportResult, ConsensusError> {
+		let hash = block.post_hash();
+		let number = *block.header.number();
+		// Force imported state finality.
+		block.finalized = true;
+		let import_result = (&*self.inner).import_block(block).await;
+		match import_result {
+			Ok(ImportResult::Imported(aux)) => {
+				// We've just imported a new state. We trust the sync module has verified
+				// finality proofs and that the state is correct and final.
+				// So we can read the authority list and set id from the state.
+				self.authority_set_hard_forks.clear();
+				let authorities = self
+					.inner
+					.runtime_api()
+					.grandpa_authorities(hash)
+					.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+				let set_id = self.current_set_id(hash)?;
+				let authority_set = AuthoritySet::new(
+					authorities.clone(),
+					set_id,
+					fork_tree::ForkTree::new(),
+					Vec::new(),
+					AuthoritySetChanges::empty(),
+				)
+				.ok_or_else(|| ConsensusError::ClientImport("Invalid authority list".into()))?;
+				*self.authority_set.inner_locked() = authority_set.clone();
+
+				crate::aux_schema::update_authority_set::<Block, _, _>(
+					&authority_set,
+					None,
+					|insert| self.inner.insert_aux(insert, []),
+				)
+				.map_err(|e| ConsensusError::ClientImport(e.to_string()))?;
+				let new_set =
+					NewAuthoritySet { canon_number: number, canon_hash: hash, set_id, authorities };
+				let _ = self
+					.send_voter_commands
+					.unbounded_send(VoterCommand::ChangeAuthorities(new_set));
+				Ok(ImportResult::Imported(aux))
+			},
+			Ok(r) => Ok(r),
+			Err(e) => Err(ConsensusError::ClientImport(e.to_string())),
+		}
+	}
+}
+
+#[async_trait::async_trait]
+impl<BE, Block: BlockT, Client, SC> BlockImport<Block> for GrandpaBlockImport<BE, Block, Client, SC>
+where
+	NumberFor<Block>: finality_grandpa::BlockNumberOps,
+	BE: Backend<Block>,
+	Client: ClientForGrandpa<Block, BE>,
+	Client::Api: GrandpaApi<Block>,
+	for<'a> &'a Client: BlockImport<Block, Error = ConsensusError>,
+	SC: Send,
+{
+	type Error = ConsensusError;
+
+	async fn import_block(
+		&mut self,
+		mut block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		let hash = block.post_hash();
+		let number = *block.header.number();
+
+		// early exit if block already in chain, otherwise the check for
+		// authority changes will error when trying to re-import a change block
+		match self.inner.status(hash) {
+			Ok(BlockStatus::InChain) => {
+				// Strip justifications when re-importing an existing block.
+				let _justifications = block.justifications.take();
+				return (&*self.inner).import_block(block).await
+			},
+			Ok(BlockStatus::Unknown) => {},
+			Err(e) => return Err(ConsensusError::ClientImport(e.to_string())),
+		}
+
+		if block.with_state() {
+			return self.import_state(block).await
+		}
+
+		if number <= self.inner.info().finalized_number {
+			// Importing an old block. Just save justifications and authority set changes
+			if self.check_new_change(&block.header, hash).is_some() {
+				if block.justifications.is_none() {
+					return Err(ConsensusError::ClientImport(
+						"Justification required when importing \
+							an old block with authority set change."
+							.into(),
+					))
+				}
+				assert!(block.justifications.is_some());
+				let mut authority_set = self.authority_set.inner_locked();
+				authority_set.authority_set_changes.insert(number);
+				crate::aux_schema::update_authority_set::<Block, _, _>(
+					&authority_set,
+					None,
+					|insert| {
+						block
+							.auxiliary
+							.extend(insert.iter().map(|(k, v)| (k.to_vec(), Some(v.to_vec()))))
+					},
+				);
+			}
+			return (&*self.inner).import_block(block).await
+		}
+
+		// on initial sync we will restrict logging under info to avoid spam.
+		let initial_sync = block.origin == BlockOrigin::NetworkInitialSync;
+
+		let pending_changes = self.make_authorities_changes(&mut block, hash, initial_sync)?;
+
+		// we don't want to finalize on `inner.import_block`
+		let mut justifications = block.justifications.take();
+		let import_result = (&*self.inner).import_block(block).await;
+
+		let mut imported_aux = {
+			match import_result {
+				Ok(ImportResult::Imported(aux)) => aux,
+				Ok(r) => {
+					debug!(
+						target: LOG_TARGET,
+						"Restoring old authority set after block import result: {:?}", r,
+					);
+					pending_changes.revert();
+					return Ok(r)
+				},
+				Err(e) => {
+					debug!(
+						target: LOG_TARGET,
+						"Restoring old authority set after block import error: {}", e,
+					);
+					pending_changes.revert();
+					return Err(ConsensusError::ClientImport(e.to_string()))
+				},
+			}
+		};
+
+		let (applied_changes, do_pause) = pending_changes.defuse();
+
+		// Send the pause signal after import but BEFORE sending a `ChangeAuthorities` message.
+		if do_pause {
+			let _ = self.send_voter_commands.unbounded_send(VoterCommand::Pause(
+				"Forced change scheduled after inactivity".to_string(),
+			));
+		}
+
+		let needs_justification = applied_changes.needs_justification();
+
+		match applied_changes {
+			AppliedChanges::Forced(new) => {
+				// NOTE: when we do a force change we are "discrediting" the old set so we
+				// ignore any justifications from them. this block may contain a justification
+				// which should be checked and imported below against the new authority
+				// triggered by this forced change. the new grandpa voter will start at the
+				// last median finalized block (which is before the block that enacts the
+				// change), full nodes syncing the chain will not be able to successfully
+				// import justifications for those blocks since their local authority set view
+				// is still of the set before the forced change was enacted, still after #1867
+				// they should import the block and discard the justification, and they will
+				// then request a justification from sync if it's necessary (which they should
+				// then be able to successfully validate).
+				let _ =
+					self.send_voter_commands.unbounded_send(VoterCommand::ChangeAuthorities(new));
+
+				// we must clear all pending justifications requests, presumably they won't be
+				// finalized hence why this forced changes was triggered
+				imported_aux.clear_justification_requests = true;
+			},
+			AppliedChanges::Standard(false) => {
+				// we can't apply this change yet since there are other dependent changes that we
+				// need to apply first, drop any justification that might have been provided with
+				// the block to make sure we request them from `sync` which will ensure they'll be
+				// applied in-order.
+				justifications.take();
+			},
+			_ => {},
+		}
+
+		let grandpa_justification =
+			justifications.and_then(|just| just.into_justification(GRANDPA_ENGINE_ID));
+
+		match grandpa_justification {
+			Some(justification) => {
+				if environment::should_process_justification(
+					&*self.inner,
+					self.justification_import_period,
+					number,
+					needs_justification,
+				) {
+					let import_res = self.import_justification(
+						hash,
+						number,
+						(GRANDPA_ENGINE_ID, justification),
+						needs_justification,
+						initial_sync,
+					);
+
+					import_res.unwrap_or_else(|err| {
+						if needs_justification {
+							debug!(
+								target: LOG_TARGET,
+								"Requesting justification from peers due to imported block #{} that enacts authority set change with invalid justification: {}",
+								number,
+								err
+							);
+							imported_aux.bad_justification = true;
+							imported_aux.needs_justification = true;
+						}
+					});
+				} else {
+					debug!(
+						target: LOG_TARGET,
+						"Ignoring unnecessary justification for block #{}",
+						number,
+					);
+				}
+			},
+			None =>
+				if needs_justification {
+					debug!(
+						target: LOG_TARGET,
+						"Imported unjustified block #{} that enacts authority set change, waiting for finality for enactment.",
+						number,
+					);
+
+					imported_aux.needs_justification = true;
+				},
+		}
+
+		Ok(ImportResult::Imported(imported_aux))
+	}
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.inner.check_block(block).await
+	}
+}
+
+impl<Backend, Block: BlockT, Client, SC> GrandpaBlockImport<Backend, Block, Client, SC> {
+	pub(crate) fn new(
+		inner: Arc<Client>,
+		justification_import_period: u32,
+		select_chain: SC,
+		authority_set: SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+		send_voter_commands: TracingUnboundedSender<VoterCommand<Block::Hash, NumberFor<Block>>>,
+		authority_set_hard_forks: Vec<(SetId, PendingChange<Block::Hash, NumberFor<Block>>)>,
+		justification_sender: GrandpaJustificationSender<Block>,
+		telemetry: Option<TelemetryHandle>,
+	) -> GrandpaBlockImport<Backend, Block, Client, SC> {
+		// check for and apply any forced authority set hard fork that applies
+		// to the *current* authority set.
+		if let Some((_, change)) = authority_set_hard_forks
+			.iter()
+			.find(|(set_id, _)| *set_id == authority_set.set_id())
+		{
+			authority_set.inner().current_authorities = change.next_authorities.clone();
+		}
+
+		// index authority set hard forks by block hash so that they can be used
+		// by any node syncing the chain and importing a block hard fork
+		// authority set changes.
+		let authority_set_hard_forks = authority_set_hard_forks
+			.into_iter()
+			.map(|(_, change)| (change.canon_hash, change))
+			.collect::<HashMap<_, _>>();
+
+		// check for and apply any forced authority set hard fork that apply to
+		// any *pending* standard changes, checking by the block hash at which
+		// they were announced.
+		{
+			let mut authority_set = authority_set.inner();
+
+			authority_set.pending_standard_changes =
+				authority_set.pending_standard_changes.clone().map(&mut |hash, _, original| {
+					authority_set_hard_forks.get(hash).cloned().unwrap_or(original)
+				});
+		}
+
+		GrandpaBlockImport {
+			inner,
+			justification_import_period,
+			select_chain,
+			authority_set,
+			send_voter_commands,
+			authority_set_hard_forks,
+			justification_sender,
+			telemetry,
+			_phantom: PhantomData,
+		}
+	}
+}
+
+impl<BE, Block: BlockT, Client, SC> GrandpaBlockImport<BE, Block, Client, SC>
+where
+	BE: Backend<Block>,
+	Client: ClientForGrandpa<Block, BE>,
+	NumberFor<Block>: finality_grandpa::BlockNumberOps,
+{
+	/// Import a block justification and finalize the block.
+	///
+	/// If `enacts_change` is set to true, then finalizing this block *must*
+	/// enact an authority set change, the function will panic otherwise.
+	fn import_justification(
+		&mut self,
+		hash: Block::Hash,
+		number: NumberFor<Block>,
+		justification: Justification,
+		enacts_change: bool,
+		initial_sync: bool,
+	) -> Result<(), ConsensusError> {
+		if justification.0 != GRANDPA_ENGINE_ID {
+			// TODO: the import queue needs to be refactored to be able dispatch to the correct
+			// `JustificationImport` instance based on `ConsensusEngineId`, or we need to build a
+			// justification import pipeline similar to what we do for `BlockImport`. In the
+			// meantime we'll just drop the justification, since this is only used for BEEFY which
+			// is still WIP.
+			return Ok(())
+		}
+
+		let justification = GrandpaJustification::decode_and_verify_finalizes(
+			&justification.1,
+			(hash, number),
+			self.authority_set.set_id(),
+			&self.authority_set.current_authorities(),
+		);
+
+		let justification = match justification {
+			Err(e) => return Err(ConsensusError::ClientImport(e.to_string())),
+			Ok(justification) => justification,
+		};
+
+		let result = environment::finalize_block(
+			self.inner.clone(),
+			&self.authority_set,
+			None,
+			hash,
+			number,
+			justification.into(),
+			initial_sync,
+			Some(&self.justification_sender),
+			self.telemetry.clone(),
+		);
+
+		match result {
+			Err(CommandOrError::VoterCommand(command)) => {
+				grandpa_log!(
+					initial_sync,
+					"👴 Imported justification for block #{} that triggers \
+					command {}, signaling voter.",
+					number,
+					command,
+				);
+
+				// send the command to the voter
+				let _ = self.send_voter_commands.unbounded_send(command);
+			},
+			Err(CommandOrError::Error(e)) =>
+				return Err(match e {
+					Error::Grandpa(error) => ConsensusError::ClientImport(error.to_string()),
+					Error::Network(error) => ConsensusError::ClientImport(error),
+					Error::Blockchain(error) => ConsensusError::ClientImport(error),
+					Error::Client(error) => ConsensusError::ClientImport(error.to_string()),
+					Error::Safety(error) => ConsensusError::ClientImport(error),
+					Error::Signing(error) => ConsensusError::ClientImport(error),
+					Error::Timer(error) => ConsensusError::ClientImport(error.to_string()),
+					Error::RuntimeApi(error) => ConsensusError::ClientImport(error.to_string()),
+				}),
+			Ok(_) => {
+				assert!(
+					!enacts_change,
+					"returns Ok when no authority set change should be enacted; qed;"
+				);
+			},
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/justification.rs b/substrate/client/consensus/grandpa/src/justification.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a38cb113b40a7ad1b73a5d9302468c09a3c926a9
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/justification.rs
@@ -0,0 +1,307 @@
+// 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 std::{
+	collections::{HashMap, HashSet},
+	marker::PhantomData,
+	sync::Arc,
+};
+
+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};
+
+use crate::{AuthorityList, Commit, Error};
+
+/// A GRANDPA justification for block finality, it includes a commit message and
+/// an ancestry proof including all headers routing all precommit target blocks
+/// to the commit target block. Due to the current voting strategy the precommit
+/// targets should be the same as the commit target, since honest voters don't
+/// vote past authority set change blocks.
+///
+/// This is meant to be stored in the db and passed around the network to other
+/// nodes, and are used by syncing nodes to prove authority set handoffs.
+#[derive(Clone, Encode, Decode, PartialEq, Eq, Debug)]
+pub struct GrandpaJustification<Block: BlockT> {
+	/// The GRANDPA justification for block finality.
+	pub justification: sp_consensus_grandpa::GrandpaJustification<Block::Header>,
+	_block: PhantomData<Block>,
+}
+
+impl<Block: BlockT> From<sp_consensus_grandpa::GrandpaJustification<Block::Header>>
+	for GrandpaJustification<Block>
+{
+	fn from(justification: sp_consensus_grandpa::GrandpaJustification<Block::Header>) -> Self {
+		Self { justification, _block: Default::default() }
+	}
+}
+
+impl<Block: BlockT> Into<sp_consensus_grandpa::GrandpaJustification<Block::Header>>
+	for GrandpaJustification<Block>
+{
+	fn into(self) -> sp_consensus_grandpa::GrandpaJustification<Block::Header> {
+		self.justification
+	}
+}
+
+impl<Block: BlockT> GrandpaJustification<Block> {
+	/// Create a GRANDPA justification from the given commit. This method
+	/// assumes the commit is valid and well-formed.
+	pub fn from_commit<C>(
+		client: &Arc<C>,
+		round: u64,
+		commit: Commit<Block::Header>,
+	) -> Result<Self, Error>
+	where
+		C: HeaderBackend<Block>,
+	{
+		let mut votes_ancestries_hashes = HashSet::new();
+		let mut votes_ancestries = Vec::new();
+
+		let error = || {
+			let msg = "invalid precommits for target commit".to_string();
+			Err(Error::Client(ClientError::BadJustification(msg)))
+		};
+
+		// we pick the precommit for the lowest block as the base that
+		// should serve as the root block for populating ancestry (i.e.
+		// collect all headers from all precommit blocks to the base)
+		let (base_hash, base_number) = match commit
+			.precommits
+			.iter()
+			.map(|signed| &signed.precommit)
+			.min_by_key(|precommit| precommit.target_number)
+			.map(|precommit| (precommit.target_hash, precommit.target_number))
+		{
+			None => return error(),
+			Some(base) => base,
+		};
+
+		for signed in commit.precommits.iter() {
+			let mut current_hash = signed.precommit.target_hash;
+			loop {
+				if current_hash == base_hash {
+					break
+				}
+
+				match client.header(current_hash)? {
+					Some(current_header) => {
+						// NOTE: this should never happen as we pick the lowest block
+						// as base and only traverse backwards from the other blocks
+						// in the commit. but better be safe to avoid an unbound loop.
+						if *current_header.number() <= base_number {
+							return error()
+						}
+
+						let parent_hash = *current_header.parent_hash();
+						if votes_ancestries_hashes.insert(current_hash) {
+							votes_ancestries.push(current_header);
+						}
+
+						current_hash = parent_hash;
+					},
+					_ => return error(),
+				}
+			}
+		}
+
+		Ok(sp_consensus_grandpa::GrandpaJustification { round, commit, votes_ancestries }.into())
+	}
+
+	/// Decode a GRANDPA justification and validate the commit and the votes'
+	/// ancestry proofs finalize the given block.
+	pub fn decode_and_verify_finalizes(
+		encoded: &[u8],
+		finalized_target: (Block::Hash, NumberFor<Block>),
+		set_id: u64,
+		voters: &VoterSet<AuthorityId>,
+	) -> Result<Self, ClientError>
+	where
+		NumberFor<Block>: finality_grandpa::BlockNumberOps,
+	{
+		let justification = GrandpaJustification::<Block>::decode_all(&mut &*encoded)
+			.map_err(|_| ClientError::JustificationDecode)?;
+
+		if (
+			justification.justification.commit.target_hash,
+			justification.justification.commit.target_number,
+		) != finalized_target
+		{
+			let msg = "invalid commit target in grandpa justification".to_string();
+			Err(ClientError::BadJustification(msg))
+		} else {
+			justification.verify_with_voter_set(set_id, voters).map(|_| justification)
+		}
+	}
+
+	/// Validate the commit and the votes' ancestry proofs.
+	pub fn verify(&self, set_id: u64, authorities: &AuthorityList) -> Result<(), ClientError>
+	where
+		NumberFor<Block>: finality_grandpa::BlockNumberOps,
+	{
+		let voters = VoterSet::new(authorities.iter().cloned())
+			.ok_or(ClientError::Consensus(sp_consensus::Error::InvalidAuthoritiesSet))?;
+
+		self.verify_with_voter_set(set_id, &voters)
+	}
+
+	/// Validate the commit and the votes' ancestry proofs.
+	pub(crate) fn verify_with_voter_set(
+		&self,
+		set_id: u64,
+		voters: &VoterSet<AuthorityId>,
+	) -> Result<(), ClientError>
+	where
+		NumberFor<Block>: finality_grandpa::BlockNumberOps,
+	{
+		use finality_grandpa::Chain;
+
+		let ancestry_chain = AncestryChain::<Block>::new(&self.justification.votes_ancestries);
+
+		match finality_grandpa::validate_commit(&self.justification.commit, voters, &ancestry_chain)
+		{
+			Ok(ref result) if result.is_valid() => {},
+			_ => {
+				let msg = "invalid commit in grandpa justification".to_string();
+				return Err(ClientError::BadJustification(msg))
+			},
+		}
+
+		// we pick the precommit for the lowest block as the base that
+		// should serve as the root block for populating ancestry (i.e.
+		// collect all headers from all precommit blocks to the base)
+		let base_hash = self
+			.justification
+			.commit
+			.precommits
+			.iter()
+			.map(|signed| &signed.precommit)
+			.min_by_key(|precommit| precommit.target_number)
+			.map(|precommit| precommit.target_hash)
+			.expect(
+				"can only fail if precommits is empty; \
+				 commit has been validated above; \
+				 valid commits must include precommits; \
+				 qed.",
+			);
+
+		let mut buf = Vec::new();
+		let mut visited_hashes = HashSet::new();
+		for signed in self.justification.commit.precommits.iter() {
+			if !sp_consensus_grandpa::check_message_signature_with_buffer(
+				&finality_grandpa::Message::Precommit(signed.precommit.clone()),
+				&signed.id,
+				&signed.signature,
+				self.justification.round,
+				set_id,
+				&mut buf,
+			) {
+				return Err(ClientError::BadJustification(
+					"invalid signature for precommit in grandpa justification".to_string(),
+				))
+			}
+
+			if base_hash == signed.precommit.target_hash {
+				continue
+			}
+
+			match ancestry_chain.ancestry(base_hash, signed.precommit.target_hash) {
+				Ok(route) => {
+					// ancestry starts from parent hash but the precommit target hash has been
+					// visited
+					visited_hashes.insert(signed.precommit.target_hash);
+					for hash in route {
+						visited_hashes.insert(hash);
+					}
+				},
+				_ =>
+					return Err(ClientError::BadJustification(
+						"invalid precommit ancestry proof in grandpa justification".to_string(),
+					)),
+			}
+		}
+
+		let ancestry_hashes: HashSet<_> = self
+			.justification
+			.votes_ancestries
+			.iter()
+			.map(|h: &Block::Header| h.hash())
+			.collect();
+
+		if visited_hashes != ancestry_hashes {
+			return Err(ClientError::BadJustification(
+				"invalid precommit ancestries in grandpa justification with unused headers"
+					.to_string(),
+			))
+		}
+
+		Ok(())
+	}
+
+	/// The target block number and hash that this justifications proves finality for.
+	pub fn target(&self) -> (NumberFor<Block>, Block::Hash) {
+		(self.justification.commit.target_number, self.justification.commit.target_hash)
+	}
+}
+
+/// A utility trait implementing `finality_grandpa::Chain` using a given set of headers.
+/// This is useful when validating commits, using the given set of headers to
+/// verify a valid ancestry route to the target commit block.
+struct AncestryChain<Block: BlockT> {
+	ancestry: HashMap<Block::Hash, Block::Header>,
+}
+
+impl<Block: BlockT> AncestryChain<Block> {
+	fn new(ancestry: &[Block::Header]) -> AncestryChain<Block> {
+		let ancestry: HashMap<_, _> =
+			ancestry.iter().cloned().map(|h: Block::Header| (h.hash(), h)).collect();
+
+		AncestryChain { ancestry }
+	}
+}
+
+impl<Block: BlockT> finality_grandpa::Chain<Block::Hash, NumberFor<Block>> for AncestryChain<Block>
+where
+	NumberFor<Block>: finality_grandpa::BlockNumberOps,
+{
+	fn ancestry(
+		&self,
+		base: Block::Hash,
+		block: Block::Hash,
+	) -> Result<Vec<Block::Hash>, GrandpaError> {
+		let mut route = Vec::new();
+		let mut current_hash = block;
+		loop {
+			if current_hash == base {
+				break
+			}
+			match self.ancestry.get(&current_hash) {
+				Some(current_header) => {
+					current_hash = *current_header.parent_hash();
+					route.push(current_hash);
+				},
+				_ => return Err(GrandpaError::NotDescendent),
+			}
+		}
+		route.pop(); // remove the base
+
+		Ok(route)
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/lib.rs b/substrate/client/consensus/grandpa/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da621abd254caf90abf5dfab0511d5e868218168
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/lib.rs
@@ -0,0 +1,1217 @@
+// 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/>.
+
+//! Integration of the GRANDPA finality gadget into substrate.
+//!
+//! This crate is unstable and the API and usage may change.
+//!
+//! This crate provides a long-running future that produces finality notifications.
+//!
+//! # Usage
+//!
+//! First, create a block-import wrapper with the `block_import` function. The
+//! GRANDPA worker needs to be linked together with this block import object, so
+//! a `LinkHalf` is returned as well. All blocks imported (from network or
+//! consensus or otherwise) must pass through this wrapper, otherwise consensus
+//! is likely to break in unexpected ways.
+//!
+//! Next, use the `LinkHalf` and a local configuration to `run_grandpa_voter`.
+//! This requires a `Network` implementation. The returned future should be
+//! driven to completion and will finalize blocks in the background.
+//!
+//! # Changing authority sets
+//!
+//! The rough idea behind changing authority sets in GRANDPA is that at some point,
+//! we obtain agreement for some maximum block height that the current set can
+//! finalize, and once a block with that height is finalized the next set will
+//! pick up finalization from there.
+//!
+//! Technically speaking, this would be implemented as a voting rule which says,
+//! "if there is a signal for a change in N blocks in block B, only vote on
+//! chains with length NUM(B) + N if they contain B". This conditional-inclusion
+//! logic is complex to compute because it requires looking arbitrarily far
+//! back in the chain.
+//!
+//! Instead, we keep track of a list of all signals we've seen so far (across
+//! all forks), sorted ascending by the block number they would be applied at.
+//! We never vote on chains with number higher than the earliest handoff block
+//! number (this is num(signal) + N). When finalizing a block, we either apply
+//! or prune any signaled changes based on whether the signaling block is
+//! included in the newly-finalized chain.
+
+#![warn(missing_docs)]
+
+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::{
+	backend::{AuxStore, Backend},
+	utils::is_descendent_of,
+	BlockchainEvents, CallExecutor, ExecutorProvider, Finalizer, LockImportRun, StorageProvider,
+};
+use sc_consensus::BlockImport;
+use sc_network::types::ProtocolName;
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_INFO};
+use sc_transaction_pool_api::OffchainTransactionPoolFactory;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver};
+use sp_api::ProvideRuntimeApi;
+use sp_application_crypto::AppCrypto;
+use sp_blockchain::{Error as ClientError, HeaderBackend, HeaderMetadata, Result as ClientResult};
+use sp_consensus::SelectChain;
+use sp_consensus_grandpa::{
+	AuthorityList, AuthoritySignature, SetId, CLIENT_LOG_TARGET as LOG_TARGET,
+};
+use sp_core::{crypto::ByteArray, traits::CallContext};
+use sp_keystore::KeystorePtr;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, NumberFor, Zero},
+};
+
+pub use finality_grandpa::BlockNumberOps;
+use finality_grandpa::{voter, voter_set::VoterSet, Error as GrandpaError};
+
+use std::{
+	fmt, io,
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+// utility logging macro that takes as first argument a conditional to
+// decide whether to log under debug or info level (useful to restrict
+// logging under initial sync).
+macro_rules! grandpa_log {
+	($condition:expr, $($msg: expr),+ $(,)?) => {
+		{
+			let log_level = if $condition {
+				log::Level::Debug
+			} else {
+				log::Level::Info
+			};
+
+			log::log!(target: LOG_TARGET, log_level, $($msg),+);
+		}
+	};
+}
+
+mod authorities;
+mod aux_schema;
+mod communication;
+mod environment;
+mod finality_proof;
+mod import;
+mod justification;
+mod notification;
+mod observer;
+mod until_imported;
+mod voting_rule;
+pub mod warp_proof;
+
+pub use authorities::{AuthoritySet, AuthoritySetChanges, SharedAuthoritySet};
+pub use aux_schema::best_justification;
+pub use communication::grandpa_protocol_name::standard_name as protocol_standard_name;
+pub use finality_grandpa::voter::report;
+pub use finality_proof::{FinalityProof, FinalityProofError, FinalityProofProvider};
+pub use import::{find_forced_change, find_scheduled_change, GrandpaBlockImport};
+pub use justification::GrandpaJustification;
+pub use notification::{GrandpaJustificationSender, GrandpaJustificationStream};
+pub use observer::run_grandpa_observer;
+pub use voting_rule::{
+	BeforeBestBlockBy, ThreeQuartersOfTheUnfinalizedChain, VotingRule, VotingRuleResult,
+	VotingRulesBuilder,
+};
+
+use aux_schema::PersistentData;
+use communication::{Network as NetworkT, NetworkBridge, Syncing as SyncingT};
+use environment::{Environment, VoterSetState};
+use until_imported::UntilGlobalMessageBlocksImported;
+
+// Re-export these two because it's just so damn convenient.
+pub use sp_consensus_grandpa::{
+	AuthorityId, AuthorityPair, CatchUp, Commit, CompactCommit, GrandpaApi, Message, Precommit,
+	Prevote, PrimaryPropose, ScheduledChange, SignedMessage,
+};
+use std::marker::PhantomData;
+
+#[cfg(test)]
+mod tests;
+
+/// A global communication input stream for commits and catch up messages. Not
+/// exposed publicly, used internally to simplify types in the communication
+/// layer.
+type CommunicationIn<Block> = voter::CommunicationIn<
+	<Block as BlockT>::Hash,
+	NumberFor<Block>,
+	AuthoritySignature,
+	AuthorityId,
+>;
+/// Global communication input stream for commits and catch up messages, with
+/// the hash type not being derived from the block, useful for forcing the hash
+/// to some type (e.g. `H256`) when the compiler can't do the inference.
+type CommunicationInH<Block, H> =
+	voter::CommunicationIn<H, NumberFor<Block>, AuthoritySignature, AuthorityId>;
+
+/// Global communication sink for commits with the hash type not being derived
+/// from the block, useful for forcing the hash to some type (e.g. `H256`) when
+/// the compiler can't do the inference.
+type CommunicationOutH<Block, H> =
+	voter::CommunicationOut<H, NumberFor<Block>, AuthoritySignature, AuthorityId>;
+
+/// Shared voter state for querying.
+pub struct SharedVoterState {
+	inner: Arc<RwLock<Option<Box<dyn voter::VoterState<AuthorityId> + Sync + Send>>>>,
+}
+
+impl SharedVoterState {
+	/// Create a new empty `SharedVoterState` instance.
+	pub fn empty() -> Self {
+		Self { inner: Arc::new(RwLock::new(None)) }
+	}
+
+	fn reset(
+		&self,
+		voter_state: Box<dyn voter::VoterState<AuthorityId> + Sync + Send>,
+	) -> Option<()> {
+		let mut shared_voter_state = self.inner.try_write_for(Duration::from_secs(1))?;
+
+		*shared_voter_state = Some(voter_state);
+		Some(())
+	}
+
+	/// Get the inner `VoterState` instance.
+	pub fn voter_state(&self) -> Option<report::VoterState<AuthorityId>> {
+		self.inner.read().as_ref().map(|vs| vs.get())
+	}
+}
+
+impl Clone for SharedVoterState {
+	fn clone(&self) -> Self {
+		SharedVoterState { inner: self.inner.clone() }
+	}
+}
+
+/// Configuration for the GRANDPA service
+#[derive(Clone)]
+pub struct Config {
+	/// The expected duration for a message to be gossiped across the network.
+	pub gossip_duration: Duration,
+	/// Justification generation period (in blocks). GRANDPA will try to generate
+	/// justifications at least every justification_generation_period blocks. There
+	/// are some other events which might cause justification generation.
+	pub justification_generation_period: u32,
+	/// Whether the GRANDPA observer protocol is live on the network and thereby
+	/// a full-node not running as a validator is running the GRANDPA observer
+	/// protocol (we will only issue catch-up requests to authorities when the
+	/// observer protocol is enabled).
+	pub observer_enabled: bool,
+	/// The role of the local node (i.e. authority, full-node or light).
+	pub local_role: sc_network::config::Role,
+	/// Some local identifier of the voter.
+	pub name: Option<String>,
+	/// The keystore that manages the keys of this node.
+	pub keystore: Option<KeystorePtr>,
+	/// TelemetryHandle instance.
+	pub telemetry: Option<TelemetryHandle>,
+	/// Chain specific GRANDPA protocol name. See [`crate::protocol_standard_name`].
+	pub protocol_name: ProtocolName,
+}
+
+impl Config {
+	fn name(&self) -> &str {
+		self.name.as_deref().unwrap_or("<unknown>")
+	}
+}
+
+/// Errors that can occur while voting in GRANDPA.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// An error within grandpa.
+	#[error("grandpa error: {0}")]
+	Grandpa(#[from] GrandpaError),
+
+	/// A network error.
+	#[error("network error: {0}")]
+	Network(String),
+
+	/// A blockchain error.
+	#[error("blockchain error: {0}")]
+	Blockchain(String),
+
+	/// Could not complete a round on disk.
+	#[error("could not complete a round on disk: {0}")]
+	Client(#[from] ClientError),
+
+	/// Could not sign outgoing message
+	#[error("could not sign outgoing message: {0}")]
+	Signing(String),
+
+	/// An invariant has been violated (e.g. not finalizing pending change blocks in-order)
+	#[error("safety invariant has been violated: {0}")]
+	Safety(String),
+
+	/// A timer failed to fire.
+	#[error("a timer failed to fire: {0}")]
+	Timer(io::Error),
+
+	/// A runtime api request failed.
+	#[error("runtime API request failed: {0}")]
+	RuntimeApi(sp_api::ApiError),
+}
+
+/// Something which can determine if a block is known.
+pub(crate) trait BlockStatus<Block: BlockT> {
+	/// Return `Ok(Some(number))` or `Ok(None)` depending on whether the block
+	/// is definitely known and has been imported.
+	/// If an unexpected error occurs, return that.
+	fn block_number(&self, hash: Block::Hash) -> Result<Option<NumberFor<Block>>, Error>;
+}
+
+impl<Block: BlockT, Client> BlockStatus<Block> for Arc<Client>
+where
+	Client: HeaderBackend<Block>,
+	NumberFor<Block>: BlockNumberOps,
+{
+	fn block_number(&self, hash: Block::Hash) -> Result<Option<NumberFor<Block>>, Error> {
+		self.block_number_from_id(&BlockId::Hash(hash))
+			.map_err(|e| Error::Blockchain(e.to_string()))
+	}
+}
+
+/// A trait that includes all the client functionalities grandpa requires.
+/// Ideally this would be a trait alias, we're not there yet.
+/// tracking issue <https://github.com/rust-lang/rust/issues/41517>
+pub trait ClientForGrandpa<Block, BE>:
+	LockImportRun<Block, BE>
+	+ Finalizer<Block, BE>
+	+ AuxStore
+	+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+	+ HeaderBackend<Block>
+	+ BlockchainEvents<Block>
+	+ ProvideRuntimeApi<Block>
+	+ ExecutorProvider<Block>
+	+ BlockImport<Block, Error = sp_consensus::Error>
+	+ StorageProvider<Block, BE>
+where
+	BE: Backend<Block>,
+	Block: BlockT,
+{
+}
+
+impl<Block, BE, T> ClientForGrandpa<Block, BE> for T
+where
+	BE: Backend<Block>,
+	Block: BlockT,
+	T: LockImportRun<Block, BE>
+		+ Finalizer<Block, BE>
+		+ AuxStore
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ HeaderBackend<Block>
+		+ BlockchainEvents<Block>
+		+ ProvideRuntimeApi<Block>
+		+ ExecutorProvider<Block>
+		+ BlockImport<Block, Error = sp_consensus::Error>
+		+ StorageProvider<Block, BE>,
+{
+}
+
+/// Something that one can ask to do a block sync request.
+pub(crate) trait BlockSyncRequester<Block: BlockT> {
+	/// Notifies the sync service to try and sync the given block from the given
+	/// peers.
+	///
+	/// If the given vector of peers is empty then the underlying implementation
+	/// should make a best effort to fetch the block from any peers it is
+	/// connected to (NOTE: this assumption will change in the future #3629).
+	fn set_sync_fork_request(
+		&self,
+		peers: Vec<sc_network::PeerId>,
+		hash: Block::Hash,
+		number: NumberFor<Block>,
+	);
+}
+
+impl<Block, Network, Syncing> BlockSyncRequester<Block> for NetworkBridge<Block, Network, Syncing>
+where
+	Block: BlockT,
+	Network: NetworkT<Block>,
+	Syncing: SyncingT<Block>,
+{
+	fn set_sync_fork_request(
+		&self,
+		peers: Vec<sc_network::PeerId>,
+		hash: Block::Hash,
+		number: NumberFor<Block>,
+	) {
+		NetworkBridge::set_sync_fork_request(self, peers, hash, number)
+	}
+}
+
+/// A new authority set along with the canonical block it changed at.
+#[derive(Debug)]
+pub(crate) struct NewAuthoritySet<H, N> {
+	pub(crate) canon_number: N,
+	pub(crate) canon_hash: H,
+	pub(crate) set_id: SetId,
+	pub(crate) authorities: AuthorityList,
+}
+
+/// Commands issued to the voter.
+#[derive(Debug)]
+pub(crate) enum VoterCommand<H, N> {
+	/// Pause the voter for given reason.
+	Pause(String),
+	/// New authorities.
+	ChangeAuthorities(NewAuthoritySet<H, N>),
+}
+
+impl<H, N> fmt::Display for VoterCommand<H, N> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match *self {
+			VoterCommand::Pause(ref reason) => write!(f, "Pausing voter: {}", reason),
+			VoterCommand::ChangeAuthorities(_) => write!(f, "Changing authorities"),
+		}
+	}
+}
+
+/// Signals either an early exit of a voter or an error.
+#[derive(Debug)]
+pub(crate) enum CommandOrError<H, N> {
+	/// An error occurred.
+	Error(Error),
+	/// A command to the voter.
+	VoterCommand(VoterCommand<H, N>),
+}
+
+impl<H, N> From<Error> for CommandOrError<H, N> {
+	fn from(e: Error) -> Self {
+		CommandOrError::Error(e)
+	}
+}
+
+impl<H, N> From<ClientError> for CommandOrError<H, N> {
+	fn from(e: ClientError) -> Self {
+		CommandOrError::Error(Error::Client(e))
+	}
+}
+
+impl<H, N> From<finality_grandpa::Error> for CommandOrError<H, N> {
+	fn from(e: finality_grandpa::Error) -> Self {
+		CommandOrError::Error(Error::from(e))
+	}
+}
+
+impl<H, N> From<VoterCommand<H, N>> for CommandOrError<H, N> {
+	fn from(e: VoterCommand<H, N>) -> Self {
+		CommandOrError::VoterCommand(e)
+	}
+}
+
+impl<H: fmt::Debug, N: fmt::Debug> ::std::error::Error for CommandOrError<H, N> {}
+
+impl<H, N> fmt::Display for CommandOrError<H, N> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match *self {
+			CommandOrError::Error(ref e) => write!(f, "{}", e),
+			CommandOrError::VoterCommand(ref cmd) => write!(f, "{}", cmd),
+		}
+	}
+}
+
+/// Link between the block importer and the background voter.
+pub struct LinkHalf<Block: BlockT, C, SC> {
+	client: Arc<C>,
+	select_chain: SC,
+	persistent_data: PersistentData<Block>,
+	voter_commands_rx: TracingUnboundedReceiver<VoterCommand<Block::Hash, NumberFor<Block>>>,
+	justification_sender: GrandpaJustificationSender<Block>,
+	justification_stream: GrandpaJustificationStream<Block>,
+	telemetry: Option<TelemetryHandle>,
+}
+
+impl<Block: BlockT, C, SC> LinkHalf<Block, C, SC> {
+	/// Get the shared authority set.
+	pub fn shared_authority_set(&self) -> &SharedAuthoritySet<Block::Hash, NumberFor<Block>> {
+		&self.persistent_data.authority_set
+	}
+
+	/// Get the receiving end of justification notifications.
+	pub fn justification_stream(&self) -> GrandpaJustificationStream<Block> {
+		self.justification_stream.clone()
+	}
+}
+
+/// Provider for the Grandpa authority set configured on the genesis block.
+pub trait GenesisAuthoritySetProvider<Block: BlockT> {
+	/// Get the authority set at the genesis block.
+	fn get(&self) -> Result<AuthorityList, ClientError>;
+}
+
+impl<Block: BlockT, E, Client> GenesisAuthoritySetProvider<Block> for Arc<Client>
+where
+	E: CallExecutor<Block>,
+	Client: ExecutorProvider<Block, Executor = E> + HeaderBackend<Block>,
+{
+	fn get(&self) -> Result<AuthorityList, ClientError> {
+		// This implementation uses the Grandpa runtime API instead of reading directly from the
+		// `GRANDPA_AUTHORITIES_KEY` as the data may have been migrated since the genesis block of
+		// the chain, whereas the runtime API is backwards compatible.
+		self.executor()
+			.call(
+				self.expect_block_hash_from_id(&BlockId::Number(Zero::zero()))?,
+				"GrandpaApi_grandpa_authorities",
+				&[],
+				CallContext::Offchain,
+			)
+			.and_then(|call_result| {
+				Decode::decode(&mut &call_result[..]).map_err(|err| {
+					ClientError::CallResultDecode(
+						"failed to decode GRANDPA authorities set proof",
+						err,
+					)
+				})
+			})
+	}
+}
+
+/// Make block importer and link half necessary to tie the background voter
+/// to it.
+///
+/// The `justification_import_period` sets the minimum period on which
+/// justifications will be imported.  When importing a block, if it includes a
+/// justification it will only be processed if it fits within this period,
+/// otherwise it will be ignored (and won't be validated). This is to avoid
+/// slowing down sync by a peer serving us unnecessary justifications which
+/// aren't trivial to validate.
+pub fn block_import<BE, Block: BlockT, Client, SC>(
+	client: Arc<Client>,
+	justification_import_period: u32,
+	genesis_authorities_provider: &dyn GenesisAuthoritySetProvider<Block>,
+	select_chain: SC,
+	telemetry: Option<TelemetryHandle>,
+) -> Result<(GrandpaBlockImport<BE, Block, Client, SC>, LinkHalf<Block, Client, SC>), ClientError>
+where
+	SC: SelectChain<Block>,
+	BE: Backend<Block> + 'static,
+	Client: ClientForGrandpa<Block, BE> + 'static,
+{
+	block_import_with_authority_set_hard_forks(
+		client,
+		justification_import_period,
+		genesis_authorities_provider,
+		select_chain,
+		Default::default(),
+		telemetry,
+	)
+}
+
+/// A descriptor for an authority set hard fork. These are authority set changes
+/// that are not signalled by the runtime and instead are defined off-chain
+/// (hence the hard fork).
+pub struct AuthoritySetHardFork<Block: BlockT> {
+	/// The new authority set id.
+	pub set_id: SetId,
+	/// The block hash and number at which the hard fork should be applied.
+	pub block: (Block::Hash, NumberFor<Block>),
+	/// The authorities in the new set.
+	pub authorities: AuthorityList,
+	/// The latest block number that was finalized before this authority set
+	/// hard fork. When defined, the authority set change will be forced, i.e.
+	/// the node won't wait for the block above to be finalized before enacting
+	/// the change, and the given finalized number will be used as a base for
+	/// voting.
+	pub last_finalized: Option<NumberFor<Block>>,
+}
+
+/// Make block importer and link half necessary to tie the background voter to
+/// it. A vector of authority set hard forks can be passed, any authority set
+/// change signaled at the given block (either already signalled or in a further
+/// block when importing it) will be replaced by a standard change with the
+/// given static authorities.
+pub fn block_import_with_authority_set_hard_forks<BE, Block: BlockT, Client, SC>(
+	client: Arc<Client>,
+	justification_import_period: u32,
+	genesis_authorities_provider: &dyn GenesisAuthoritySetProvider<Block>,
+	select_chain: SC,
+	authority_set_hard_forks: Vec<AuthoritySetHardFork<Block>>,
+	telemetry: Option<TelemetryHandle>,
+) -> Result<(GrandpaBlockImport<BE, Block, Client, SC>, LinkHalf<Block, Client, SC>), ClientError>
+where
+	SC: SelectChain<Block>,
+	BE: Backend<Block> + 'static,
+	Client: ClientForGrandpa<Block, BE> + 'static,
+{
+	let chain_info = client.info();
+	let genesis_hash = chain_info.genesis_hash;
+
+	let persistent_data =
+		aux_schema::load_persistent(&*client, genesis_hash, <NumberFor<Block>>::zero(), {
+			let telemetry = telemetry.clone();
+			move || {
+				let authorities = genesis_authorities_provider.get()?;
+				telemetry!(
+					telemetry;
+					CONSENSUS_DEBUG;
+					"afg.loading_authorities";
+					"authorities_len" => ?authorities.len()
+				);
+				Ok(authorities)
+			}
+		})?;
+
+	let (voter_commands_tx, voter_commands_rx) =
+		tracing_unbounded("mpsc_grandpa_voter_command", 100_000);
+
+	let (justification_sender, justification_stream) = GrandpaJustificationStream::channel();
+
+	// create pending change objects with 0 delay for each authority set hard fork.
+	let authority_set_hard_forks = authority_set_hard_forks
+		.into_iter()
+		.map(|fork| {
+			let delay_kind = if let Some(last_finalized) = fork.last_finalized {
+				authorities::DelayKind::Best { median_last_finalized: last_finalized }
+			} else {
+				authorities::DelayKind::Finalized
+			};
+
+			(
+				fork.set_id,
+				authorities::PendingChange {
+					next_authorities: fork.authorities,
+					delay: Zero::zero(),
+					canon_hash: fork.block.0,
+					canon_height: fork.block.1,
+					delay_kind,
+				},
+			)
+		})
+		.collect();
+
+	Ok((
+		GrandpaBlockImport::new(
+			client.clone(),
+			justification_import_period,
+			select_chain.clone(),
+			persistent_data.authority_set.clone(),
+			voter_commands_tx,
+			authority_set_hard_forks,
+			justification_sender.clone(),
+			telemetry.clone(),
+		),
+		LinkHalf {
+			client,
+			select_chain,
+			persistent_data,
+			voter_commands_rx,
+			justification_sender,
+			justification_stream,
+			telemetry,
+		},
+	))
+}
+
+fn global_communication<BE, Block: BlockT, C, N, S>(
+	set_id: SetId,
+	voters: &Arc<VoterSet<AuthorityId>>,
+	client: Arc<C>,
+	network: &NetworkBridge<Block, N, S>,
+	keystore: Option<&KeystorePtr>,
+	metrics: Option<until_imported::Metrics>,
+) -> (
+	impl Stream<
+		Item = Result<
+			CommunicationInH<Block, Block::Hash>,
+			CommandOrError<Block::Hash, NumberFor<Block>>,
+		>,
+	>,
+	impl Sink<
+		CommunicationOutH<Block, Block::Hash>,
+		Error = CommandOrError<Block::Hash, NumberFor<Block>>,
+	>,
+)
+where
+	BE: Backend<Block> + 'static,
+	C: ClientForGrandpa<Block, BE> + 'static,
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	NumberFor<Block>: BlockNumberOps,
+{
+	let is_voter = local_authority_id(voters, keystore).is_some();
+
+	// verification stream
+	let (global_in, global_out) =
+		network.global_communication(communication::SetId(set_id), voters.clone(), is_voter);
+
+	// block commit and catch up messages until relevant blocks are imported.
+	let global_in = UntilGlobalMessageBlocksImported::new(
+		client.import_notification_stream(),
+		network.clone(),
+		client.clone(),
+		global_in,
+		"global",
+		metrics,
+	);
+
+	let global_in = global_in.map_err(CommandOrError::from);
+	let global_out = global_out.sink_map_err(CommandOrError::from);
+
+	(global_in, global_out)
+}
+
+/// Parameters used to run Grandpa.
+pub struct GrandpaParams<Block: BlockT, C, N, S, SC, VR> {
+	/// Configuration for the GRANDPA service.
+	pub config: Config,
+	/// A link to the block import worker.
+	pub link: LinkHalf<Block, C, SC>,
+	/// The Network instance.
+	///
+	/// It is assumed that this network will feed us Grandpa notifications. When using the
+	/// `sc_network` crate, it is assumed that the Grandpa notifications protocol has been passed
+	/// to the configuration of the networking. See [`grandpa_peers_set_config`].
+	pub network: N,
+	/// Event stream for syncing-related events.
+	pub sync: S,
+	/// A voting rule used to potentially restrict target votes.
+	pub voting_rule: VR,
+	/// The prometheus metrics registry.
+	pub prometheus_registry: Option<prometheus_endpoint::Registry>,
+	/// The voter state is exposed at an RPC endpoint.
+	pub shared_voter_state: SharedVoterState,
+	/// TelemetryHandle instance.
+	pub telemetry: Option<TelemetryHandle>,
+	/// Offchain transaction pool factory.
+	///
+	/// This will be used to create an offchain transaction pool instance for sending an
+	/// equivocation report from the runtime.
+	pub offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>,
+}
+
+/// Returns the configuration value to put in
+/// [`sc_network::config::FullNetworkConfiguration`].
+/// For standard protocol name see [`crate::protocol_standard_name`].
+pub fn grandpa_peers_set_config(
+	protocol_name: ProtocolName,
+) -> sc_network::config::NonDefaultSetConfig {
+	use communication::grandpa_protocol_name;
+	sc_network::config::NonDefaultSetConfig {
+		notifications_protocol: protocol_name,
+		fallback_names: grandpa_protocol_name::LEGACY_NAMES.iter().map(|&n| n.into()).collect(),
+		// Notifications reach ~256kiB in size at the time of writing on Kusama and Polkadot.
+		max_notification_size: 1024 * 1024,
+		handshake: None,
+		set_config: sc_network::config::SetConfig {
+			in_peers: 0,
+			out_peers: 0,
+			reserved_nodes: Vec::new(),
+			non_reserved_mode: sc_network::config::NonReservedPeerMode::Deny,
+		},
+	}
+}
+
+/// Run a GRANDPA voter as a task. Provide configuration and a link to a
+/// block import worker that has already been instantiated with `block_import`.
+pub fn run_grandpa_voter<Block: BlockT, BE: 'static, C, N, S, SC, VR>(
+	grandpa_params: GrandpaParams<Block, C, N, S, SC, VR>,
+) -> sp_blockchain::Result<impl Future<Output = ()> + Send>
+where
+	BE: Backend<Block> + 'static,
+	N: NetworkT<Block> + Sync + 'static,
+	S: SyncingT<Block> + Sync + 'static,
+	SC: SelectChain<Block> + 'static,
+	VR: VotingRule<Block, C> + Clone + 'static,
+	NumberFor<Block>: BlockNumberOps,
+	C: ClientForGrandpa<Block, BE> + 'static,
+	C::Api: GrandpaApi<Block>,
+{
+	let GrandpaParams {
+		mut config,
+		link,
+		network,
+		sync,
+		voting_rule,
+		prometheus_registry,
+		shared_voter_state,
+		telemetry,
+		offchain_tx_pool_factory,
+	} = grandpa_params;
+
+	// NOTE: we have recently removed `run_grandpa_observer` from the public
+	// API, I felt it is easier to just ignore this field rather than removing
+	// it from the config temporarily. This should be removed after #5013 is
+	// fixed and we re-add the observer to the public API.
+	config.observer_enabled = false;
+
+	let LinkHalf {
+		client,
+		select_chain,
+		persistent_data,
+		voter_commands_rx,
+		justification_sender,
+		justification_stream: _,
+		telemetry: _,
+	} = link;
+
+	let network = NetworkBridge::new(
+		network,
+		sync,
+		config.clone(),
+		persistent_data.set_state.clone(),
+		prometheus_registry.as_ref(),
+		telemetry.clone(),
+	);
+
+	let conf = config.clone();
+	let telemetry_task =
+		if let Some(telemetry_on_connect) = telemetry.as_ref().map(|x| x.on_connect_stream()) {
+			let authorities = persistent_data.authority_set.clone();
+			let telemetry = telemetry.clone();
+			let events = telemetry_on_connect.for_each(move |_| {
+				let current_authorities = authorities.current_authorities();
+				let set_id = authorities.set_id();
+				let maybe_authority_id =
+					local_authority_id(&current_authorities, conf.keystore.as_ref());
+
+				let authorities =
+					current_authorities.iter().map(|(id, _)| id.to_string()).collect::<Vec<_>>();
+
+				let authorities = serde_json::to_string(&authorities).expect(
+					"authorities is always at least an empty vector; \
+					 elements are always of type string",
+				);
+
+				telemetry!(
+					telemetry;
+					CONSENSUS_INFO;
+					"afg.authority_set";
+					"authority_id" => maybe_authority_id.map_or("".into(), |s| s.to_string()),
+					"authority_set_id" => ?set_id,
+					"authorities" => authorities,
+				);
+
+				future::ready(())
+			});
+			future::Either::Left(events)
+		} else {
+			future::Either::Right(future::pending())
+		};
+
+	let voter_work = VoterWork::new(
+		client,
+		config,
+		network,
+		select_chain,
+		voting_rule,
+		persistent_data,
+		voter_commands_rx,
+		prometheus_registry,
+		shared_voter_state,
+		justification_sender,
+		telemetry,
+		offchain_tx_pool_factory,
+	);
+
+	let voter_work = voter_work.map(|res| match res {
+		Ok(()) => error!(
+			target: LOG_TARGET,
+			"GRANDPA voter future has concluded naturally, this should be unreachable."
+		),
+		Err(e) => error!(target: LOG_TARGET, "GRANDPA voter error: {}", e),
+	});
+
+	// Make sure that `telemetry_task` doesn't accidentally finish and kill grandpa.
+	let telemetry_task = telemetry_task.then(|_| future::pending::<()>());
+
+	Ok(future::select(voter_work, telemetry_task).map(drop))
+}
+
+struct Metrics {
+	environment: environment::Metrics,
+	until_imported: until_imported::Metrics,
+}
+
+impl Metrics {
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Metrics {
+			environment: environment::Metrics::register(registry)?,
+			until_imported: until_imported::Metrics::register(registry)?,
+		})
+	}
+}
+
+/// Future that powers the voter.
+#[must_use]
+struct VoterWork<B, Block: BlockT, C, N: NetworkT<Block>, S: SyncingT<Block>, SC, VR> {
+	voter: Pin<
+		Box<dyn Future<Output = Result<(), CommandOrError<Block::Hash, NumberFor<Block>>>> + Send>,
+	>,
+	shared_voter_state: SharedVoterState,
+	env: Arc<Environment<B, Block, C, N, S, SC, VR>>,
+	voter_commands_rx: TracingUnboundedReceiver<VoterCommand<Block::Hash, NumberFor<Block>>>,
+	network: NetworkBridge<Block, N, S>,
+	telemetry: Option<TelemetryHandle>,
+	/// Prometheus metrics.
+	metrics: Option<Metrics>,
+}
+
+impl<B, Block, C, N, S, SC, VR> VoterWork<B, Block, C, N, S, SC, VR>
+where
+	Block: BlockT,
+	B: Backend<Block> + 'static,
+	C: ClientForGrandpa<Block, B> + 'static,
+	C::Api: GrandpaApi<Block>,
+	N: NetworkT<Block> + Sync,
+	S: SyncingT<Block> + Sync,
+	NumberFor<Block>: BlockNumberOps,
+	SC: SelectChain<Block> + 'static,
+	VR: VotingRule<Block, C> + Clone + 'static,
+{
+	fn new(
+		client: Arc<C>,
+		config: Config,
+		network: NetworkBridge<Block, N, S>,
+		select_chain: SC,
+		voting_rule: VR,
+		persistent_data: PersistentData<Block>,
+		voter_commands_rx: TracingUnboundedReceiver<VoterCommand<Block::Hash, NumberFor<Block>>>,
+		prometheus_registry: Option<prometheus_endpoint::Registry>,
+		shared_voter_state: SharedVoterState,
+		justification_sender: GrandpaJustificationSender<Block>,
+		telemetry: Option<TelemetryHandle>,
+		offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>,
+	) -> Self {
+		let metrics = match prometheus_registry.as_ref().map(Metrics::register) {
+			Some(Ok(metrics)) => Some(metrics),
+			Some(Err(e)) => {
+				debug!(target: LOG_TARGET, "Failed to register metrics: {:?}", e);
+				None
+			},
+			None => None,
+		};
+
+		let voters = persistent_data.authority_set.current_authorities();
+		let env = Arc::new(Environment {
+			client,
+			select_chain,
+			voting_rule,
+			voters: Arc::new(voters),
+			config,
+			network: network.clone(),
+			set_id: persistent_data.authority_set.set_id(),
+			authority_set: persistent_data.authority_set.clone(),
+			voter_set_state: persistent_data.set_state,
+			metrics: metrics.as_ref().map(|m| m.environment.clone()),
+			justification_sender: Some(justification_sender),
+			telemetry: telemetry.clone(),
+			offchain_tx_pool_factory,
+			_phantom: PhantomData,
+		});
+
+		let mut work = VoterWork {
+			// `voter` is set to a temporary value and replaced below when
+			// calling `rebuild_voter`.
+			voter: Box::pin(future::pending()),
+			shared_voter_state,
+			env,
+			voter_commands_rx,
+			network,
+			telemetry,
+			metrics,
+		};
+		work.rebuild_voter();
+		work
+	}
+
+	/// Rebuilds the `self.voter` field using the current authority set
+	/// state. This method should be called when we know that the authority set
+	/// has changed (e.g. as signalled by a voter command).
+	fn rebuild_voter(&mut self) {
+		debug!(
+			target: LOG_TARGET,
+			"{}: Starting new voter with set ID {}",
+			self.env.config.name(),
+			self.env.set_id
+		);
+
+		let maybe_authority_id =
+			local_authority_id(&self.env.voters, self.env.config.keystore.as_ref());
+		let authority_id = maybe_authority_id.map_or("<unknown>".into(), |s| s.to_string());
+
+		telemetry!(
+			self.telemetry;
+			CONSENSUS_DEBUG;
+			"afg.starting_new_voter";
+			"name" => ?self.env.config.name(),
+			"set_id" => ?self.env.set_id,
+			"authority_id" => authority_id,
+		);
+
+		let chain_info = self.env.client.info();
+
+		let authorities = self.env.voters.iter().map(|(id, _)| id.to_string()).collect::<Vec<_>>();
+
+		let authorities = serde_json::to_string(&authorities).expect(
+			"authorities is always at least an empty vector; elements are always of type string; qed.",
+		);
+
+		telemetry!(
+			self.telemetry;
+			CONSENSUS_INFO;
+			"afg.authority_set";
+			"number" => ?chain_info.finalized_number,
+			"hash" => ?chain_info.finalized_hash,
+			"authority_id" => authority_id,
+			"authority_set_id" => ?self.env.set_id,
+			"authorities" => authorities,
+		);
+
+		match &*self.env.voter_set_state.read() {
+			VoterSetState::Live { completed_rounds, .. } => {
+				let last_finalized = (chain_info.finalized_hash, chain_info.finalized_number);
+
+				let global_comms = global_communication(
+					self.env.set_id,
+					&self.env.voters,
+					self.env.client.clone(),
+					&self.env.network,
+					self.env.config.keystore.as_ref(),
+					self.metrics.as_ref().map(|m| m.until_imported.clone()),
+				);
+
+				let last_completed_round = completed_rounds.last();
+
+				let voter = voter::Voter::new(
+					self.env.clone(),
+					(*self.env.voters).clone(),
+					global_comms,
+					last_completed_round.number,
+					last_completed_round.votes.clone(),
+					last_completed_round.base,
+					last_finalized,
+				);
+
+				// Repoint shared_voter_state so that the RPC endpoint can query the state
+				if self.shared_voter_state.reset(voter.voter_state()).is_none() {
+					info!(
+						target: LOG_TARGET,
+						"Timed out trying to update shared GRANDPA voter state. \
+						RPC endpoints may return stale data."
+					);
+				}
+
+				self.voter = Box::pin(voter);
+			},
+			VoterSetState::Paused { .. } => self.voter = Box::pin(future::pending()),
+		};
+	}
+
+	fn handle_voter_command(
+		&mut self,
+		command: VoterCommand<Block::Hash, NumberFor<Block>>,
+	) -> Result<(), Error> {
+		match command {
+			VoterCommand::ChangeAuthorities(new) => {
+				let voters: Vec<String> =
+					new.authorities.iter().map(move |(a, _)| format!("{}", a)).collect();
+				telemetry!(
+					self.telemetry;
+					CONSENSUS_INFO;
+					"afg.voter_command_change_authorities";
+					"number" => ?new.canon_number,
+					"hash" => ?new.canon_hash,
+					"voters" => ?voters,
+					"set_id" => ?new.set_id,
+				);
+
+				self.env.update_voter_set_state(|_| {
+					// start the new authority set using the block where the
+					// set changed (not where the signal happened!) as the base.
+					let set_state = VoterSetState::live(
+						new.set_id,
+						&*self.env.authority_set.inner(),
+						(new.canon_hash, new.canon_number),
+					);
+
+					aux_schema::write_voter_set_state(&*self.env.client, &set_state)?;
+					Ok(Some(set_state))
+				})?;
+
+				let voters = Arc::new(VoterSet::new(new.authorities.into_iter()).expect(
+					"new authorities come from pending change; pending change comes from \
+					 `AuthoritySet`; `AuthoritySet` validates authorities is non-empty and \
+					 weights are non-zero; qed.",
+				));
+
+				self.env = Arc::new(Environment {
+					voters,
+					set_id: new.set_id,
+					voter_set_state: self.env.voter_set_state.clone(),
+					client: self.env.client.clone(),
+					select_chain: self.env.select_chain.clone(),
+					config: self.env.config.clone(),
+					authority_set: self.env.authority_set.clone(),
+					network: self.env.network.clone(),
+					voting_rule: self.env.voting_rule.clone(),
+					metrics: self.env.metrics.clone(),
+					justification_sender: self.env.justification_sender.clone(),
+					telemetry: self.telemetry.clone(),
+					offchain_tx_pool_factory: self.env.offchain_tx_pool_factory.clone(),
+					_phantom: PhantomData,
+				});
+
+				self.rebuild_voter();
+				Ok(())
+			},
+			VoterCommand::Pause(reason) => {
+				info!(target: LOG_TARGET, "Pausing old validator set: {}", reason);
+
+				// not racing because old voter is shut down.
+				self.env.update_voter_set_state(|voter_set_state| {
+					let completed_rounds = voter_set_state.completed_rounds();
+					let set_state = VoterSetState::Paused { completed_rounds };
+
+					aux_schema::write_voter_set_state(&*self.env.client, &set_state)?;
+					Ok(Some(set_state))
+				})?;
+
+				self.rebuild_voter();
+				Ok(())
+			},
+		}
+	}
+}
+
+impl<B, Block, C, N, S, SC, VR> Future for VoterWork<B, Block, C, N, S, SC, VR>
+where
+	Block: BlockT,
+	B: Backend<Block> + 'static,
+	N: NetworkT<Block> + Sync,
+	S: SyncingT<Block> + Sync,
+	NumberFor<Block>: BlockNumberOps,
+	SC: SelectChain<Block> + 'static,
+	C: ClientForGrandpa<Block, B> + 'static,
+	C::Api: GrandpaApi<Block>,
+	VR: VotingRule<Block, C> + Clone + 'static,
+{
+	type Output = Result<(), Error>;
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		match Future::poll(Pin::new(&mut self.voter), cx) {
+			Poll::Pending => {},
+			Poll::Ready(Ok(())) => {
+				// voters don't conclude naturally
+				return Poll::Ready(Err(Error::Safety(
+					"consensus-grandpa inner voter has concluded.".into(),
+				)))
+			},
+			Poll::Ready(Err(CommandOrError::Error(e))) => {
+				// return inner observer error
+				return Poll::Ready(Err(e))
+			},
+			Poll::Ready(Err(CommandOrError::VoterCommand(command))) => {
+				// some command issued internally
+				self.handle_voter_command(command)?;
+				cx.waker().wake_by_ref();
+			},
+		}
+
+		match Stream::poll_next(Pin::new(&mut self.voter_commands_rx), cx) {
+			Poll::Pending => {},
+			Poll::Ready(None) => {
+				// the `voter_commands_rx` stream should never conclude since it's never closed.
+				return Poll::Ready(Err(Error::Safety("`voter_commands_rx` was closed.".into())))
+			},
+			Poll::Ready(Some(command)) => {
+				// some command issued externally
+				self.handle_voter_command(command)?;
+				cx.waker().wake_by_ref();
+			},
+		}
+
+		Future::poll(Pin::new(&mut self.network), cx)
+	}
+}
+
+/// Checks if this node has any available keys in the keystore for any authority id in the given
+/// voter set.  Returns the authority id for which keys are available, or `None` if no keys are
+/// available.
+fn local_authority_id(
+	voters: &VoterSet<AuthorityId>,
+	keystore: Option<&KeystorePtr>,
+) -> Option<AuthorityId> {
+	keystore.and_then(|keystore| {
+		voters
+			.iter()
+			.find(|(p, _)| keystore.has_keys(&[(p.to_raw_vec(), AuthorityId::ID)]))
+			.map(|(p, _)| p.clone())
+	})
+}
+
+/// Reverts protocol aux data to at most the last finalized block.
+/// In particular, standard and forced authority set changes announced after the
+/// revert point are removed.
+pub fn revert<Block, Client>(client: Arc<Client>, blocks: NumberFor<Block>) -> ClientResult<()>
+where
+	Block: BlockT,
+	Client: AuxStore + HeaderMetadata<Block, Error = ClientError> + HeaderBackend<Block>,
+{
+	let best_number = client.info().best_number;
+	let finalized = client.info().finalized_number;
+
+	let revertible = blocks.min(best_number - finalized);
+	if revertible == Zero::zero() {
+		return Ok(())
+	}
+
+	let number = best_number - revertible;
+	let hash = client
+		.block_hash_from_id(&BlockId::Number(number))?
+		.ok_or(ClientError::Backend(format!(
+			"Unexpected hash lookup failure for block number: {}",
+			number
+		)))?;
+
+	let info = client.info();
+
+	let persistent_data: PersistentData<Block> =
+		aux_schema::load_persistent(&*client, info.genesis_hash, Zero::zero(), || {
+			const MSG: &str = "Unexpected missing grandpa data during revert";
+			Err(ClientError::Application(Box::from(MSG)))
+		})?;
+
+	let shared_authority_set = persistent_data.authority_set;
+	let mut authority_set = shared_authority_set.inner();
+
+	let is_descendent_of = is_descendent_of(&*client, None);
+	authority_set.revert(hash, number, &is_descendent_of);
+
+	// The following has the side effect to properly reset the current voter state.
+	let (set_id, set_ref) = authority_set.current();
+	let new_set = Some(NewAuthoritySet {
+		canon_hash: info.finalized_hash,
+		canon_number: info.finalized_number,
+		set_id,
+		authorities: set_ref.to_vec(),
+	});
+	aux_schema::update_authority_set::<Block, _, _>(&authority_set, new_set.as_ref(), |values| {
+		client.insert_aux(values, None)
+	})
+}
diff --git a/substrate/client/consensus/grandpa/src/notification.rs b/substrate/client/consensus/grandpa/src/notification.rs
new file mode 100644
index 0000000000000000000000000000000000000000..de1fba09ea3d4fca63c550a131af462910e52a63
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/notification.rs
@@ -0,0 +1,43 @@
+// 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 sc_utils::notification::{NotificationSender, NotificationStream, TracingKeyStr};
+
+use crate::justification::GrandpaJustification;
+
+/// The sending half of the Grandpa justification channel(s).
+///
+/// Used to send notifications about justifications generated
+/// at the end of a Grandpa round.
+pub type GrandpaJustificationSender<Block> = NotificationSender<GrandpaJustification<Block>>;
+
+/// The receiving half of the Grandpa justification channel.
+///
+/// Used to receive notifications about justifications generated
+/// at the end of a Grandpa round.
+/// The `GrandpaJustificationStream` entity stores the `SharedJustificationSenders`
+/// so it can be used to add more subscriptions.
+pub type GrandpaJustificationStream<Block> =
+	NotificationStream<GrandpaJustification<Block>, GrandpaJustificationsTracingKey>;
+
+/// Provides tracing key for GRANDPA justifications stream.
+#[derive(Clone)]
+pub struct GrandpaJustificationsTracingKey;
+impl TracingKeyStr for GrandpaJustificationsTracingKey {
+	const TRACING_KEY: &'static str = "mpsc_grandpa_justification_notification_stream";
+}
diff --git a/substrate/client/consensus/grandpa/src/observer.rs b/substrate/client/consensus/grandpa/src/observer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8541baa822bb44aeac0613f6870884f904cbca2d
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/observer.rs
@@ -0,0 +1,475 @@
+// 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 std::{
+	marker::{PhantomData, Unpin},
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+};
+
+use finality_grandpa::{voter, voter_set::VoterSet, BlockNumberOps, Error as GrandpaError};
+use futures::prelude::*;
+use log::{debug, info, warn};
+
+use sc_client_api::backend::Backend;
+use sc_telemetry::TelemetryHandle;
+use sc_utils::mpsc::TracingUnboundedReceiver;
+use sp_blockchain::HeaderMetadata;
+use sp_consensus::SelectChain;
+use sp_consensus_grandpa::AuthorityId;
+use sp_keystore::KeystorePtr;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use crate::{
+	authorities::SharedAuthoritySet,
+	aux_schema::PersistentData,
+	communication::{Network as NetworkT, NetworkBridge, Syncing as SyncingT},
+	environment, global_communication,
+	notification::GrandpaJustificationSender,
+	ClientForGrandpa, CommandOrError, CommunicationIn, Config, Error, LinkHalf, VoterCommand,
+	VoterSetState, LOG_TARGET,
+};
+
+struct ObserverChain<'a, Block: BlockT, Client> {
+	client: &'a Arc<Client>,
+	_phantom: PhantomData<Block>,
+}
+
+impl<'a, Block, Client> finality_grandpa::Chain<Block::Hash, NumberFor<Block>>
+	for ObserverChain<'a, Block, Client>
+where
+	Block: BlockT,
+	Client: HeaderMetadata<Block, Error = sp_blockchain::Error>,
+	NumberFor<Block>: BlockNumberOps,
+{
+	fn ancestry(
+		&self,
+		base: Block::Hash,
+		block: Block::Hash,
+	) -> Result<Vec<Block::Hash>, GrandpaError> {
+		environment::ancestry(self.client, base, block)
+	}
+}
+
+fn grandpa_observer<BE, Block: BlockT, Client, S, F>(
+	client: &Arc<Client>,
+	authority_set: &SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+	voters: &Arc<VoterSet<AuthorityId>>,
+	justification_sender: &Option<GrandpaJustificationSender<Block>>,
+	last_finalized_number: NumberFor<Block>,
+	commits: S,
+	note_round: F,
+	telemetry: Option<TelemetryHandle>,
+) -> impl Future<Output = Result<(), CommandOrError<Block::Hash, NumberFor<Block>>>>
+where
+	NumberFor<Block>: BlockNumberOps,
+	S: Stream<Item = Result<CommunicationIn<Block>, CommandOrError<Block::Hash, NumberFor<Block>>>>,
+	F: Fn(u64),
+	BE: Backend<Block>,
+	Client: ClientForGrandpa<Block, BE>,
+{
+	let authority_set = authority_set.clone();
+	let client = client.clone();
+	let voters = voters.clone();
+	let justification_sender = justification_sender.clone();
+
+	let observer = commits.try_fold(last_finalized_number, move |last_finalized_number, global| {
+		let (round, commit, callback) = match global {
+			voter::CommunicationIn::Commit(round, commit, callback) => {
+				let commit = finality_grandpa::Commit::from(commit);
+				(round, commit, callback)
+			},
+			voter::CommunicationIn::CatchUp(..) => {
+				// ignore catch up messages
+				return future::ok(last_finalized_number)
+			},
+		};
+
+		// if the commit we've received targets a block lower or equal to the last
+		// finalized, ignore it and continue with the current state
+		if commit.target_number <= last_finalized_number {
+			return future::ok(last_finalized_number)
+		}
+
+		let validation_result = match finality_grandpa::validate_commit(
+			&commit,
+			&voters,
+			&ObserverChain { client: &client, _phantom: PhantomData },
+		) {
+			Ok(r) => r,
+			Err(e) => return future::err(e.into()),
+		};
+
+		if validation_result.is_valid() {
+			let finalized_hash = commit.target_hash;
+			let finalized_number = commit.target_number;
+
+			// commit is valid, finalize the block it targets
+			match environment::finalize_block(
+				client.clone(),
+				&authority_set,
+				None,
+				finalized_hash,
+				finalized_number,
+				(round, commit).into(),
+				false,
+				justification_sender.as_ref(),
+				telemetry.clone(),
+			) {
+				Ok(_) => {},
+				Err(e) => return future::err(e),
+			};
+
+			// note that we've observed completion of this round through the commit,
+			// and that implies that the next round has started.
+			note_round(round + 1);
+
+			finality_grandpa::process_commit_validation_result(validation_result, callback);
+
+			// proceed processing with new finalized block number
+			future::ok(finalized_number)
+		} else {
+			debug!(target: LOG_TARGET, "Received invalid commit: ({:?}, {:?})", round, commit);
+
+			finality_grandpa::process_commit_validation_result(validation_result, callback);
+
+			// commit is invalid, continue processing commits with the current state
+			future::ok(last_finalized_number)
+		}
+	});
+
+	observer.map_ok(|_| ())
+}
+
+/// Run a GRANDPA observer as a task, the observer will finalize blocks only by
+/// listening for and validating GRANDPA commits instead of following the full
+/// protocol. Provide configuration and a link to a block import worker that has
+/// already been instantiated with `block_import`.
+/// NOTE: this is currently not part of the crate's public API since we don't consider
+/// it stable enough to use on a live network.
+pub fn run_grandpa_observer<BE, Block: BlockT, Client, N, S, SC>(
+	config: Config,
+	link: LinkHalf<Block, Client, SC>,
+	network: N,
+	sync: S,
+) -> sp_blockchain::Result<impl Future<Output = ()> + Send>
+where
+	BE: Backend<Block> + Unpin + 'static,
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	SC: SelectChain<Block>,
+	NumberFor<Block>: BlockNumberOps,
+	Client: ClientForGrandpa<Block, BE> + 'static,
+{
+	let LinkHalf {
+		client,
+		persistent_data,
+		voter_commands_rx,
+		justification_sender,
+		telemetry,
+		..
+	} = link;
+
+	let network = NetworkBridge::new(
+		network,
+		sync,
+		config.clone(),
+		persistent_data.set_state.clone(),
+		None,
+		telemetry.clone(),
+	);
+
+	let observer_work = ObserverWork::new(
+		client,
+		network,
+		persistent_data,
+		config.keystore,
+		voter_commands_rx,
+		Some(justification_sender),
+		telemetry,
+	);
+
+	let observer_work = observer_work.map_ok(|_| ()).map_err(|e| {
+		warn!("GRANDPA Observer failed: {}", e);
+	});
+
+	Ok(observer_work.map(drop))
+}
+
+/// Future that powers the observer.
+#[must_use]
+struct ObserverWork<B: BlockT, BE, Client, N: NetworkT<B>, S: SyncingT<B>> {
+	observer:
+		Pin<Box<dyn Future<Output = Result<(), CommandOrError<B::Hash, NumberFor<B>>>> + Send>>,
+	client: Arc<Client>,
+	network: NetworkBridge<B, N, S>,
+	persistent_data: PersistentData<B>,
+	keystore: Option<KeystorePtr>,
+	voter_commands_rx: TracingUnboundedReceiver<VoterCommand<B::Hash, NumberFor<B>>>,
+	justification_sender: Option<GrandpaJustificationSender<B>>,
+	telemetry: Option<TelemetryHandle>,
+	_phantom: PhantomData<BE>,
+}
+
+impl<B, BE, Client, Network, Syncing> ObserverWork<B, BE, Client, Network, Syncing>
+where
+	B: BlockT,
+	BE: Backend<B> + 'static,
+	Client: ClientForGrandpa<B, BE> + 'static,
+	Network: NetworkT<B>,
+	Syncing: SyncingT<B>,
+	NumberFor<B>: BlockNumberOps,
+{
+	fn new(
+		client: Arc<Client>,
+		network: NetworkBridge<B, Network, Syncing>,
+		persistent_data: PersistentData<B>,
+		keystore: Option<KeystorePtr>,
+		voter_commands_rx: TracingUnboundedReceiver<VoterCommand<B::Hash, NumberFor<B>>>,
+		justification_sender: Option<GrandpaJustificationSender<B>>,
+		telemetry: Option<TelemetryHandle>,
+	) -> Self {
+		let mut work = ObserverWork {
+			// `observer` is set to a temporary value and replaced below when
+			// calling `rebuild_observer`.
+			observer: Box::pin(future::pending()) as Pin<Box<_>>,
+			client,
+			network,
+			persistent_data,
+			keystore: keystore.clone(),
+			voter_commands_rx,
+			justification_sender,
+			telemetry,
+			_phantom: PhantomData,
+		};
+		work.rebuild_observer();
+		work
+	}
+
+	/// Rebuilds the `self.observer` field using the current authority set
+	/// state. This method should be called when we know that the authority set
+	/// has changed (e.g. as signalled by a voter command).
+	fn rebuild_observer(&mut self) {
+		let set_id = self.persistent_data.authority_set.set_id();
+		let voters = Arc::new(self.persistent_data.authority_set.current_authorities());
+
+		// start global communication stream for the current set
+		let (global_in, _) = global_communication(
+			set_id,
+			&voters,
+			self.client.clone(),
+			&self.network,
+			self.keystore.as_ref(),
+			None,
+		);
+
+		let last_finalized_number = self.client.info().finalized_number;
+
+		// NOTE: since we are not using `round_communication` we have to
+		// manually note the round with the gossip validator, otherwise we won't
+		// relay round messages. we want all full nodes to contribute to vote
+		// availability.
+		let note_round = {
+			let network = self.network.clone();
+			let voters = voters.clone();
+
+			move |round| {
+				network.note_round(
+					crate::communication::Round(round),
+					crate::communication::SetId(set_id),
+					&voters,
+				)
+			}
+		};
+
+		// create observer for the current set
+		let observer = grandpa_observer(
+			&self.client,
+			&self.persistent_data.authority_set,
+			&voters,
+			&self.justification_sender,
+			last_finalized_number,
+			global_in,
+			note_round,
+			self.telemetry.clone(),
+		);
+
+		self.observer = Box::pin(observer);
+	}
+
+	fn handle_voter_command(
+		&mut self,
+		command: VoterCommand<B::Hash, NumberFor<B>>,
+	) -> Result<(), Error> {
+		// the observer doesn't use the voter set state, but we need to
+		// update it on-disk in case we restart as validator in the future.
+		self.persistent_data.set_state = match command {
+			VoterCommand::Pause(reason) => {
+				info!(target: LOG_TARGET, "Pausing old validator set: {}", reason);
+
+				let completed_rounds = self.persistent_data.set_state.read().completed_rounds();
+				let set_state = VoterSetState::Paused { completed_rounds };
+
+				crate::aux_schema::write_voter_set_state(&*self.client, &set_state)?;
+
+				set_state
+			},
+			VoterCommand::ChangeAuthorities(new) => {
+				// start the new authority set using the block where the
+				// set changed (not where the signal happened!) as the base.
+				let set_state = VoterSetState::live(
+					new.set_id,
+					&*self.persistent_data.authority_set.inner(),
+					(new.canon_hash, new.canon_number),
+				);
+
+				crate::aux_schema::write_voter_set_state(&*self.client, &set_state)?;
+
+				set_state
+			},
+		}
+		.into();
+
+		self.rebuild_observer();
+		Ok(())
+	}
+}
+
+impl<B, BE, C, N, S> Future for ObserverWork<B, BE, C, N, S>
+where
+	B: BlockT,
+	BE: Backend<B> + Unpin + 'static,
+	C: ClientForGrandpa<B, BE> + 'static,
+	N: NetworkT<B>,
+	S: SyncingT<B>,
+	NumberFor<B>: BlockNumberOps,
+{
+	type Output = Result<(), Error>;
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		match Future::poll(Pin::new(&mut self.observer), cx) {
+			Poll::Pending => {},
+			Poll::Ready(Ok(())) => {
+				// observer commit stream doesn't conclude naturally; this could reasonably be an
+				// error.
+				return Poll::Ready(Ok(()))
+			},
+			Poll::Ready(Err(CommandOrError::Error(e))) => {
+				// return inner observer error
+				return Poll::Ready(Err(e))
+			},
+			Poll::Ready(Err(CommandOrError::VoterCommand(command))) => {
+				// some command issued internally
+				self.handle_voter_command(command)?;
+				cx.waker().wake_by_ref();
+			},
+		}
+
+		match Stream::poll_next(Pin::new(&mut self.voter_commands_rx), cx) {
+			Poll::Pending => {},
+			Poll::Ready(None) => {
+				// the `voter_commands_rx` stream should never conclude since it's never closed.
+				return Poll::Ready(Ok(()))
+			},
+			Poll::Ready(Some(command)) => {
+				// some command issued externally
+				self.handle_voter_command(command)?;
+				cx.waker().wake_by_ref();
+			},
+		}
+
+		Future::poll(Pin::new(&mut self.network), cx)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use crate::{
+		aux_schema,
+		communication::tests::{make_test_network, Event},
+	};
+	use assert_matches::assert_matches;
+	use sc_network::PeerId;
+	use sc_utils::mpsc::tracing_unbounded;
+	use sp_blockchain::HeaderBackend as _;
+	use substrate_test_runtime_client::{TestClientBuilder, TestClientBuilderExt};
+
+	use futures::executor;
+
+	/// Ensure `Future` implementation of `ObserverWork` is polling its `NetworkBridge`. Regression
+	/// test for bug introduced in d4fbb897c and fixed in b7af8b339.
+	///
+	/// When polled, `NetworkBridge` forwards reputation change requests from the `GossipValidator`
+	/// to the underlying `dyn Network`. This test triggers a reputation change by calling
+	/// `GossipValidator::validate` with an invalid gossip message. After polling the `ObserverWork`
+	/// which should poll the `NetworkBridge`, the reputation change should be forwarded to the test
+	/// network.
+	#[test]
+	fn observer_work_polls_underlying_network_bridge() {
+		// Create a test network.
+		let (tester_fut, _network) = make_test_network();
+		let mut tester = executor::block_on(tester_fut);
+
+		// Create an observer.
+		let (client, backend) = {
+			let builder = TestClientBuilder::with_default_backend();
+			let backend = builder.backend();
+			let (client, _) = builder.build_with_longest_chain();
+			(Arc::new(client), backend)
+		};
+
+		let voters = vec![(sp_keyring::Ed25519Keyring::Alice.public().into(), 1)];
+
+		let persistent_data =
+			aux_schema::load_persistent(&*backend, client.info().genesis_hash, 0, || Ok(voters))
+				.unwrap();
+
+		let (_tx, voter_command_rx) = tracing_unbounded("test_mpsc_voter_command", 100_000);
+
+		let observer = ObserverWork::new(
+			client,
+			tester.net_handle.clone(),
+			persistent_data,
+			None,
+			voter_command_rx,
+			None,
+			None,
+		);
+
+		// Trigger a reputation change through the gossip validator.
+		let peer_id = PeerId::random();
+		tester.trigger_gossip_validator_reputation_change(&peer_id);
+
+		executor::block_on(async move {
+			// Poll the observer once and have it forward the reputation change from the gossip
+			// validator to the test network.
+			assert!(observer.now_or_never().is_none());
+
+			// Ignore initial event stream request by gossip engine.
+			match tester.events.next().now_or_never() {
+				Some(Some(Event::EventStream(_))) => {},
+				_ => panic!("expected event stream request"),
+			};
+
+			assert_matches!(tester.events.next().now_or_never(), Some(Some(Event::Report(_, _))));
+		});
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/tests.rs b/substrate/client/consensus/grandpa/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0175f7d1b473cb8be88da088df4792099f015a31
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/tests.rs
@@ -0,0 +1,2165 @@
+// 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/>.
+
+//! Tests and test helpers for GRANDPA.
+
+use super::*;
+use assert_matches::assert_matches;
+use async_trait::async_trait;
+use environment::HasVoted;
+use futures_timer::Delay;
+use parking_lot::{Mutex, RwLock};
+use sc_consensus::{
+	BlockImport, BlockImportParams, BoxJustificationImport, ForkChoiceStrategy, ImportResult,
+	ImportedAux,
+};
+use sc_network::config::Role;
+use sc_network_test::{
+	Block, BlockImportAdapter, FullPeerConfig, Hash, PassThroughVerifier, Peer, PeersClient,
+	PeersFullClient, TestClient, TestNetFactory,
+};
+use sc_transaction_pool_api::RejectAllTxPool;
+use sp_api::{ApiRef, ProvideRuntimeApi};
+use sp_consensus::{BlockOrigin, Error as ConsensusError, SelectChain};
+use sp_consensus_grandpa::{
+	AuthorityList, EquivocationProof, GrandpaApi, OpaqueKeyOwnershipProof, GRANDPA_ENGINE_ID,
+};
+use sp_core::H256;
+use sp_keyring::Ed25519Keyring;
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystorePtr};
+use sp_runtime::{
+	codec::Encode,
+	generic::{BlockId, DigestItem},
+	traits::{Block as BlockT, Header as HeaderT},
+	Justifications,
+};
+use std::{collections::HashSet, pin::Pin};
+use substrate_test_runtime_client::{runtime::BlockNumber, BlockBuilderExt};
+use tokio::runtime::Handle;
+
+use authorities::AuthoritySet;
+use communication::grandpa_protocol_name;
+use sc_block_builder::{BlockBuilder, BlockBuilderProvider};
+use sc_consensus::LongestChain;
+use sp_application_crypto::key_types::GRANDPA;
+
+type TestLinkHalf =
+	LinkHalf<Block, PeersFullClient, LongestChain<substrate_test_runtime_client::Backend, Block>>;
+type PeerData = Mutex<Option<TestLinkHalf>>;
+type GrandpaPeer = Peer<PeerData, GrandpaBlockImport>;
+type GrandpaBlockImport = crate::GrandpaBlockImport<
+	substrate_test_runtime_client::Backend,
+	Block,
+	PeersFullClient,
+	LongestChain<substrate_test_runtime_client::Backend, Block>,
+>;
+
+const JUSTIFICATION_IMPORT_PERIOD: u32 = 32;
+
+#[derive(Default)]
+struct GrandpaTestNet {
+	peers: Vec<GrandpaPeer>,
+	test_config: TestApi,
+}
+
+impl GrandpaTestNet {
+	fn new(test_config: TestApi, n_authority: usize, n_full: usize) -> Self {
+		let mut net =
+			GrandpaTestNet { peers: Vec::with_capacity(n_authority + n_full), test_config };
+
+		for _ in 0..n_authority {
+			net.add_authority_peer();
+		}
+
+		for _ in 0..n_full {
+			net.add_full_peer();
+		}
+
+		net
+	}
+}
+
+impl GrandpaTestNet {
+	fn add_authority_peer(&mut self) {
+		self.add_full_peer_with_config(FullPeerConfig {
+			notifications_protocols: vec![grandpa_protocol_name::NAME.into()],
+			is_authority: true,
+			..Default::default()
+		})
+	}
+}
+
+impl TestNetFactory for GrandpaTestNet {
+	type Verifier = PassThroughVerifier;
+	type PeerData = PeerData;
+	type BlockImport = GrandpaBlockImport;
+
+	fn add_full_peer(&mut self) {
+		self.add_full_peer_with_config(FullPeerConfig {
+			notifications_protocols: vec![grandpa_protocol_name::NAME.into()],
+			is_authority: false,
+			..Default::default()
+		})
+	}
+
+	fn make_verifier(&self, _client: PeersClient, _: &PeerData) -> Self::Verifier {
+		PassThroughVerifier::new(false) // use non-instant finality.
+	}
+
+	fn make_block_import(
+		&self,
+		client: PeersClient,
+	) -> (BlockImportAdapter<Self::BlockImport>, Option<BoxJustificationImport<Block>>, PeerData) {
+		let (client, backend) = (client.as_client(), client.as_backend());
+		let (import, link) = block_import(
+			client.clone(),
+			JUSTIFICATION_IMPORT_PERIOD,
+			&self.test_config,
+			LongestChain::new(backend.clone()),
+			None,
+		)
+		.expect("Could not create block import for fresh peer.");
+		let justification_import = Box::new(import.clone());
+		(BlockImportAdapter::new(import), Some(justification_import), Mutex::new(Some(link)))
+	}
+
+	fn peer(&mut self, i: usize) -> &mut GrandpaPeer {
+		&mut self.peers[i]
+	}
+
+	fn peers(&self) -> &Vec<GrandpaPeer> {
+		&self.peers
+	}
+
+	fn peers_mut(&mut self) -> &mut Vec<GrandpaPeer> {
+		&mut self.peers
+	}
+
+	fn mut_peers<F: FnOnce(&mut Vec<GrandpaPeer>)>(&mut self, closure: F) {
+		closure(&mut self.peers);
+	}
+}
+
+#[derive(Default, Clone)]
+pub(crate) struct TestApi {
+	genesis_authorities: AuthorityList,
+}
+
+impl TestApi {
+	pub fn new(genesis_authorities: AuthorityList) -> Self {
+		TestApi { genesis_authorities }
+	}
+}
+
+pub(crate) struct RuntimeApi {
+	inner: TestApi,
+}
+
+impl ProvideRuntimeApi<Block> for TestApi {
+	type Api = RuntimeApi;
+
+	fn runtime_api(&self) -> ApiRef<'_, Self::Api> {
+		RuntimeApi { inner: self.clone() }.into()
+	}
+}
+
+sp_api::mock_impl_runtime_apis! {
+	impl GrandpaApi<Block> for RuntimeApi {
+		fn grandpa_authorities(&self) -> AuthorityList {
+			self.inner.genesis_authorities.clone()
+		}
+
+		fn current_set_id(&self) -> SetId {
+			0
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			_equivocation_proof: EquivocationProof<Hash, BlockNumber>,
+			_key_owner_proof: OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			None
+		}
+
+		fn generate_key_ownership_proof(
+			_set_id: SetId,
+			_authority_id: AuthorityId,
+		) -> Option<OpaqueKeyOwnershipProof> {
+			None
+		}
+	}
+}
+
+impl GenesisAuthoritySetProvider<Block> for TestApi {
+	fn get(&self) -> sp_blockchain::Result<AuthorityList> {
+		Ok(self.genesis_authorities.clone())
+	}
+}
+
+/// A mock `SelectChain` that allows the user to set the return values for each
+/// method. After the `SelectChain` methods are called the pending value is
+/// discarded and another call to set new values must be performed.
+#[derive(Clone, Default)]
+struct MockSelectChain {
+	leaves: Arc<Mutex<Option<Vec<Hash>>>>,
+	best_chain: Arc<Mutex<Option<<Block as BlockT>::Header>>>,
+	finality_target: Arc<Mutex<Option<Hash>>>,
+}
+
+impl MockSelectChain {
+	fn set_best_chain(&self, best: <Block as BlockT>::Header) {
+		*self.best_chain.lock() = Some(best);
+	}
+
+	fn set_finality_target(&self, target: Hash) {
+		*self.finality_target.lock() = Some(target);
+	}
+}
+
+#[async_trait]
+impl SelectChain<Block> for MockSelectChain {
+	async fn leaves(&self) -> Result<Vec<Hash>, ConsensusError> {
+		Ok(self.leaves.lock().take().unwrap())
+	}
+
+	async fn best_chain(&self) -> Result<<Block as BlockT>::Header, ConsensusError> {
+		Ok(self.best_chain.lock().take().unwrap())
+	}
+
+	async fn finality_target(
+		&self,
+		_base_hash: Hash,
+		_maybe_max_number: Option<NumberFor<Block>>,
+	) -> Result<Hash, ConsensusError> {
+		Ok(self.finality_target.lock().take().unwrap())
+	}
+}
+
+// A mock voting rule that allows asserting an expected value for best block
+#[derive(Clone, Default)]
+struct AssertBestBlock(Arc<Mutex<Option<Hash>>>);
+
+impl<B> VotingRule<Block, B> for AssertBestBlock
+where
+	B: HeaderBackend<Block>,
+{
+	fn restrict_vote(
+		&self,
+		_backend: Arc<B>,
+		_base: &<Block as BlockT>::Header,
+		best_target: &<Block as BlockT>::Header,
+		_current_target: &<Block as BlockT>::Header,
+	) -> VotingRuleResult<Block> {
+		if let Some(expected) = *self.0.lock() {
+			assert_eq!(best_target.hash(), expected);
+		}
+
+		Box::pin(std::future::ready(None))
+	}
+}
+
+impl AssertBestBlock {
+	fn set_expected_best_block(&self, hash: Hash) {
+		*self.0.lock() = Some(hash);
+	}
+}
+
+const TEST_GOSSIP_DURATION: Duration = Duration::from_millis(500);
+
+fn make_ids(keys: &[Ed25519Keyring]) -> AuthorityList {
+	keys.iter().map(|&key| key.public().into()).map(|id| (id, 1)).collect()
+}
+
+fn create_keystore(authority: Ed25519Keyring) -> KeystorePtr {
+	let keystore = MemoryKeystore::new();
+	keystore
+		.ed25519_generate_new(GRANDPA, Some(&authority.to_seed()))
+		.expect("Creates authority key");
+	keystore.into()
+}
+
+async fn run_until_complete(future: impl Future + Unpin, net: &Arc<Mutex<GrandpaTestNet>>) {
+	let drive_to_completion = futures::future::poll_fn(|cx| {
+		net.lock().poll(cx);
+		Poll::<()>::Pending
+	});
+	future::select(future, drive_to_completion).await;
+}
+
+// Spawns grandpa voters. Returns a future to spawn on the runtime.
+fn initialize_grandpa(
+	net: &mut GrandpaTestNet,
+	peers: &[Ed25519Keyring],
+) -> impl Future<Output = ()> {
+	let voters = stream::FuturesUnordered::new();
+
+	for (peer_id, key) in peers.iter().enumerate() {
+		let keystore = create_keystore(*key);
+
+		let (net_service, link) = {
+			// temporary needed for some reason
+			let link =
+				net.peers[peer_id].data.lock().take().expect("link initialized at startup; qed");
+			(net.peers[peer_id].network_service().clone(), link)
+		};
+		let sync = net.peers[peer_id].sync_service().clone();
+
+		let grandpa_params = GrandpaParams {
+			config: Config {
+				gossip_duration: TEST_GOSSIP_DURATION,
+				justification_generation_period: 32,
+				keystore: Some(keystore),
+				name: Some(format!("peer#{}", peer_id)),
+				local_role: Role::Authority,
+				observer_enabled: true,
+				telemetry: None,
+				protocol_name: grandpa_protocol_name::NAME.into(),
+			},
+			link,
+			network: net_service,
+			sync,
+			voting_rule: (),
+			prometheus_registry: None,
+			shared_voter_state: SharedVoterState::empty(),
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+				RejectAllTxPool::default(),
+			),
+			telemetry: None,
+		};
+		let voter =
+			run_grandpa_voter(grandpa_params).expect("all in order with client and network");
+
+		fn assert_send<T: Send>(_: &T) {}
+		assert_send(&voter);
+
+		voters.push(voter);
+	}
+
+	voters.for_each(|_| async move {})
+}
+
+// run the voters to completion. provide a closure to be invoked after
+// the voters are spawned but before blocking on them.
+async fn run_to_completion_with<F>(
+	blocks: u64,
+	net: Arc<Mutex<GrandpaTestNet>>,
+	peers: &[Ed25519Keyring],
+	with: F,
+) -> u64
+where
+	F: FnOnce(Handle) -> Option<Pin<Box<dyn Future<Output = ()>>>>,
+{
+	let mut wait_for = Vec::new();
+
+	let highest_finalized = Arc::new(RwLock::new(0));
+
+	if let Some(f) = (with)(Handle::current()) {
+		wait_for.push(f);
+	};
+
+	for (peer_id, _) in peers.iter().enumerate() {
+		let highest_finalized = highest_finalized.clone();
+		let client = net.lock().peers[peer_id].client().clone();
+
+		wait_for.push(Box::pin(
+			client
+				.finality_notification_stream()
+				.take_while(move |n| {
+					let mut highest_finalized = highest_finalized.write();
+					if *n.header.number() > *highest_finalized {
+						*highest_finalized = *n.header.number();
+					}
+					future::ready(n.header.number() < &blocks)
+				})
+				.collect::<Vec<_>>()
+				.map(|_| ()),
+		));
+	}
+
+	// wait for all finalized on each.
+	let wait_for = ::futures::future::join_all(wait_for);
+
+	run_until_complete(wait_for, &net).await;
+	let highest_finalized = *highest_finalized.read();
+	highest_finalized
+}
+
+async fn run_to_completion(
+	blocks: u64,
+	net: Arc<Mutex<GrandpaTestNet>>,
+	peers: &[Ed25519Keyring],
+) -> u64 {
+	run_to_completion_with(blocks, net, peers, |_| None).await
+}
+
+fn add_scheduled_change(builder: &mut impl BlockBuilderExt, change: ScheduledChange<BlockNumber>) {
+	builder
+		.push_deposit_log_digest_item(DigestItem::Consensus(
+			GRANDPA_ENGINE_ID,
+			sp_consensus_grandpa::ConsensusLog::ScheduledChange(change).encode(),
+		))
+		.unwrap();
+}
+
+fn add_forced_change(
+	builder: &mut impl BlockBuilderExt,
+	median_last_finalized: BlockNumber,
+	change: ScheduledChange<BlockNumber>,
+) {
+	builder
+		.push_deposit_log_digest_item(DigestItem::Consensus(
+			GRANDPA_ENGINE_ID,
+			sp_consensus_grandpa::ConsensusLog::ForcedChange(median_last_finalized, change)
+				.encode(),
+		))
+		.unwrap();
+}
+
+#[tokio::test]
+async fn finalize_3_voters_no_observers() {
+	sp_tracing::try_init_simple();
+	let peers = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let voters = make_ids(peers);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 3, 0);
+	tokio::spawn(initialize_grandpa(&mut net, peers));
+	net.peer(0).push_blocks(20, false);
+	net.run_until_sync().await;
+	let hashof20 = net.peer(0).client().info().best_hash;
+
+	for i in 0..3 {
+		assert_eq!(net.peer(i).client().info().best_number, 20, "Peer #{} failed to sync", i);
+		assert_eq!(net.peer(i).client().info().best_hash, hashof20, "Peer #{} failed to sync", i);
+	}
+
+	let net = Arc::new(Mutex::new(net));
+	run_to_completion(20, net.clone(), peers).await;
+
+	// all peers should have stored the justification for the best finalized block #20
+	for peer_id in 0..3 {
+		let client = net.lock().peers[peer_id].client().as_client();
+		let justification =
+			crate::aux_schema::best_justification::<_, Block>(&*client).unwrap().unwrap();
+
+		assert_eq!(justification.justification.commit.target_number, 20);
+	}
+}
+
+#[tokio::test]
+async fn finalize_3_voters_1_full_observer() {
+	let peers = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let voters = make_ids(peers);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 3, 1);
+	tokio::spawn(initialize_grandpa(&mut net, peers));
+
+	tokio::spawn({
+		let peer_id = 3;
+		let net_service = net.peers[peer_id].network_service().clone();
+		let sync = net.peers[peer_id].sync_service().clone();
+		let link = net.peers[peer_id].data.lock().take().expect("link initialized at startup; qed");
+
+		let grandpa_params = GrandpaParams {
+			config: Config {
+				gossip_duration: TEST_GOSSIP_DURATION,
+				justification_generation_period: 32,
+				keystore: None,
+				name: Some(format!("peer#{}", peer_id)),
+				local_role: Role::Authority,
+				observer_enabled: true,
+				telemetry: None,
+				protocol_name: grandpa_protocol_name::NAME.into(),
+			},
+			link,
+			network: net_service,
+			sync,
+			voting_rule: (),
+			prometheus_registry: None,
+			shared_voter_state: SharedVoterState::empty(),
+			telemetry: None,
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+				RejectAllTxPool::default(),
+			),
+		};
+
+		run_grandpa_voter(grandpa_params).expect("all in order with client and network")
+	});
+
+	net.peer(0).push_blocks(20, false);
+
+	let net = Arc::new(Mutex::new(net));
+	let mut finality_notifications = Vec::new();
+
+	for peer_id in 0..4 {
+		let client = net.lock().peers[peer_id].client().clone();
+		finality_notifications.push(
+			client
+				.finality_notification_stream()
+				.take_while(|n| future::ready(n.header.number() < &20))
+				.for_each(move |_| future::ready(())),
+		);
+	}
+
+	// wait for all finalized on each.
+	let wait_for = futures::future::join_all(finality_notifications).map(|_| ());
+
+	run_until_complete(wait_for, &net).await;
+
+	// all peers should have stored the justification for the best finalized block #20
+	for peer_id in 0..4 {
+		let client = net.lock().peers[peer_id].client().as_client();
+		let justification =
+			crate::aux_schema::best_justification::<_, Block>(&*client).unwrap().unwrap();
+
+		assert_eq!(justification.justification.commit.target_number, 20);
+	}
+}
+
+#[tokio::test]
+async fn transition_3_voters_twice_1_full_observer() {
+	sp_tracing::try_init_simple();
+	let peers_a = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+
+	let peers_b = &[Ed25519Keyring::Dave, Ed25519Keyring::Eve, Ed25519Keyring::Ferdie];
+
+	let peers_c = &[Ed25519Keyring::Alice, Ed25519Keyring::Eve, Ed25519Keyring::Two];
+
+	let observer = &[Ed25519Keyring::One];
+
+	let all_peers = peers_a
+		.iter()
+		.chain(peers_b)
+		.chain(peers_c)
+		.chain(observer)
+		.cloned()
+		.collect::<HashSet<_>>(); // deduplicate
+
+	let genesis_voters = make_ids(peers_a);
+
+	let api = TestApi::new(genesis_voters);
+	let net = Arc::new(Mutex::new(GrandpaTestNet::new(api, 8, 1)));
+
+	let mut voters = Vec::new();
+	for (peer_id, local_key) in all_peers.clone().into_iter().enumerate() {
+		let keystore = create_keystore(local_key);
+
+		let (net_service, link, sync) = {
+			let net = net.lock();
+			let link =
+				net.peers[peer_id].data.lock().take().expect("link initialized at startup; qed");
+			(
+				net.peers[peer_id].network_service().clone(),
+				link,
+				net.peers[peer_id].sync_service().clone(),
+			)
+		};
+
+		let grandpa_params = GrandpaParams {
+			config: Config {
+				gossip_duration: TEST_GOSSIP_DURATION,
+				justification_generation_period: 32,
+				keystore: Some(keystore),
+				name: Some(format!("peer#{}", peer_id)),
+				local_role: Role::Authority,
+				observer_enabled: true,
+				telemetry: None,
+				protocol_name: grandpa_protocol_name::NAME.into(),
+			},
+			link,
+			network: net_service,
+			sync,
+			voting_rule: (),
+			prometheus_registry: None,
+			shared_voter_state: SharedVoterState::empty(),
+			telemetry: None,
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+				RejectAllTxPool::default(),
+			),
+		};
+
+		voters
+			.push(run_grandpa_voter(grandpa_params).expect("all in order with client and network"));
+	}
+
+	net.lock().peer(0).push_blocks(1, false);
+	net.lock().run_until_sync().await;
+
+	for (i, peer) in net.lock().peers().iter().enumerate() {
+		let full_client = peer.client().as_client();
+		assert_eq!(full_client.chain_info().best_number, 1, "Peer #{} failed to sync", i);
+
+		let set: AuthoritySet<Hash, BlockNumber> =
+			crate::aux_schema::load_authorities(&*full_client).unwrap();
+
+		assert_eq!(set.current(), (0, make_ids(peers_a).as_slice()));
+		assert_eq!(set.pending_changes().count(), 0);
+	}
+
+	{
+		let net = net.clone();
+		let client = net.lock().peers[0].client().clone();
+		let peers_c = *peers_c;
+
+		// wait for blocks to be finalized before generating new ones
+		let block_production = client
+			.finality_notification_stream()
+			.take_while(|n| future::ready(n.header.number() < &30))
+			.for_each(move |n| {
+				match n.header.number() {
+					1 => {
+						// first 14 blocks.
+						net.lock().peer(0).push_blocks(13, false);
+					},
+					14 => {
+						// generate transition at block 15, applied at 20.
+						net.lock().peer(0).generate_blocks(1, BlockOrigin::File, |mut builder| {
+							add_scheduled_change(
+								&mut builder,
+								ScheduledChange { next_authorities: make_ids(peers_b), delay: 4 },
+							);
+							builder.build().unwrap().block
+						});
+						net.lock().peer(0).push_blocks(5, false);
+					},
+					20 => {
+						// at block 21 we do another transition, but this time instant.
+						// add more until we have 30.
+						net.lock().peer(0).generate_blocks(1, BlockOrigin::File, |mut builder| {
+							add_scheduled_change(
+								&mut builder,
+								ScheduledChange { next_authorities: make_ids(&peers_c), delay: 0 },
+							);
+							builder.build().unwrap().block
+						});
+						net.lock().peer(0).push_blocks(9, false);
+					},
+					_ => {},
+				}
+
+				future::ready(())
+			});
+
+		tokio::spawn(block_production);
+	}
+
+	let mut finality_notifications = Vec::new();
+
+	for voter in voters {
+		tokio::spawn(voter);
+	}
+
+	for (peer_id, _) in all_peers.into_iter().enumerate() {
+		let client = net.lock().peers[peer_id].client().clone();
+		finality_notifications.push(
+			client
+				.finality_notification_stream()
+				.take_while(|n| future::ready(n.header.number() < &30))
+				.for_each(move |_| future::ready(()))
+				.map(move |()| {
+					let full_client = client.as_client();
+					let set: AuthoritySet<Hash, BlockNumber> =
+						crate::aux_schema::load_authorities(&*full_client).unwrap();
+
+					assert_eq!(set.current(), (2, make_ids(peers_c).as_slice()));
+					assert_eq!(set.pending_changes().count(), 0);
+				}),
+		);
+	}
+
+	// wait for all finalized on each.
+	let wait_for = ::futures::future::join_all(finality_notifications);
+
+	run_until_complete(wait_for, &net).await;
+}
+
+#[tokio::test]
+async fn justification_is_generated_periodically() {
+	let peers = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let voters = make_ids(peers);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 3, 0);
+	tokio::spawn(initialize_grandpa(&mut net, peers));
+	net.peer(0).push_blocks(32, false);
+	net.run_until_sync().await;
+
+	let hashof32 = net.peer(0).client().info().best_hash;
+
+	let net = Arc::new(Mutex::new(net));
+	run_to_completion(32, net.clone(), peers).await;
+
+	// when block#32 (justification_generation_period) is finalized,
+	// justification is required => generated
+	for i in 0..3 {
+		assert!(net.lock().peer(i).client().justifications(hashof32).unwrap().is_some());
+	}
+}
+
+#[tokio::test]
+async fn sync_justifications_on_change_blocks() {
+	let peers_a = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let peers_b = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob];
+	let voters = make_ids(peers_b);
+
+	// 4 peers, 3 of them are authorities and participate in grandpa
+	let api = TestApi::new(voters);
+	let mut net = GrandpaTestNet::new(api, 3, 1);
+	let voters = initialize_grandpa(&mut net, peers_a);
+
+	// add 20 blocks
+	net.peer(0).push_blocks(20, false);
+
+	// at block 21 we do add a transition which is instant
+	let hashof21 = net
+		.peer(0)
+		.generate_blocks(1, BlockOrigin::File, |mut builder| {
+			add_scheduled_change(
+				&mut builder,
+				ScheduledChange { next_authorities: make_ids(peers_b), delay: 0 },
+			);
+			builder.build().unwrap().block
+		})
+		.pop()
+		.unwrap();
+
+	// add more blocks on top of it (until we have 25)
+	net.peer(0).push_blocks(4, false);
+	net.run_until_sync().await;
+
+	for i in 0..4 {
+		assert_eq!(net.peer(i).client().info().best_number, 25, "Peer #{} failed to sync", i);
+	}
+
+	let net = Arc::new(Mutex::new(net));
+	tokio::spawn(voters);
+	run_to_completion(25, net.clone(), peers_a).await;
+
+	// the first 3 peers are grandpa voters and therefore have already finalized
+	// block 21 and stored a justification
+	for i in 0..3 {
+		assert!(net.lock().peer(i).client().justifications(hashof21).unwrap().is_some());
+	}
+
+	// the last peer should get the justification by syncing from other peers
+	futures::future::poll_fn(move |cx| {
+		if net.lock().peer(3).client().justifications(hashof21).unwrap().is_none() {
+			net.lock().poll(cx);
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+}
+
+#[tokio::test]
+async fn finalizes_multiple_pending_changes_in_order() {
+	sp_tracing::try_init_simple();
+
+	let peers_a = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let peers_b = &[Ed25519Keyring::Dave, Ed25519Keyring::Eve, Ed25519Keyring::Ferdie];
+	let peers_c = &[Ed25519Keyring::Dave, Ed25519Keyring::Alice, Ed25519Keyring::Bob];
+
+	let all_peers = &[
+		Ed25519Keyring::Alice,
+		Ed25519Keyring::Bob,
+		Ed25519Keyring::Charlie,
+		Ed25519Keyring::Dave,
+		Ed25519Keyring::Eve,
+		Ed25519Keyring::Ferdie,
+	];
+	let genesis_voters = make_ids(peers_a);
+
+	// 6 peers, 3 of them are authorities and participate in grandpa from genesis
+	// but all of them will be part of the voter set eventually so they should be
+	// all added to the network as authorities
+	let api = TestApi::new(genesis_voters);
+	let mut net = GrandpaTestNet::new(api, 6, 0);
+	tokio::spawn(initialize_grandpa(&mut net, all_peers));
+
+	// add 20 blocks
+	net.peer(0).push_blocks(20, false);
+
+	// at block 21 we do add a transition which is instant
+	net.peer(0).generate_blocks(1, BlockOrigin::File, |mut builder| {
+		add_scheduled_change(
+			&mut builder,
+			ScheduledChange { next_authorities: make_ids(peers_b), delay: 0 },
+		);
+		builder.build().unwrap().block
+	});
+
+	// add more blocks on top of it (until we have 25)
+	net.peer(0).push_blocks(4, false);
+
+	// at block 26 we add another which is enacted at block 30
+	net.peer(0).generate_blocks(1, BlockOrigin::File, |mut builder| {
+		add_scheduled_change(
+			&mut builder,
+			ScheduledChange { next_authorities: make_ids(peers_c), delay: 4 },
+		);
+		builder.build().unwrap().block
+	});
+
+	// add more blocks on top of it (until we have 30)
+	net.peer(0).push_blocks(4, false);
+
+	net.run_until_sync().await;
+
+	// all peers imported both change blocks
+	for i in 0..6 {
+		assert_eq!(net.peer(i).client().info().best_number, 30, "Peer #{} failed to sync", i);
+	}
+
+	let net = Arc::new(Mutex::new(net));
+	run_to_completion(30, net.clone(), all_peers).await;
+}
+
+#[tokio::test]
+async fn force_change_to_new_set() {
+	sp_tracing::try_init_simple();
+	// two of these guys are offline.
+	let genesis_authorities = &[
+		Ed25519Keyring::Alice,
+		Ed25519Keyring::Bob,
+		Ed25519Keyring::Charlie,
+		Ed25519Keyring::One,
+		Ed25519Keyring::Two,
+	];
+	let peers_a = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let api = TestApi::new(make_ids(genesis_authorities));
+
+	let voters = make_ids(peers_a);
+	let mut net = GrandpaTestNet::new(api, 3, 0);
+	let voters_future = initialize_grandpa(&mut net, peers_a);
+	let net = Arc::new(Mutex::new(net));
+
+	net.lock().peer(0).generate_blocks(1, BlockOrigin::File, |mut builder| {
+		// add a forced transition at block 12.
+		add_forced_change(
+			&mut builder,
+			0,
+			ScheduledChange { next_authorities: voters.clone(), delay: 10 },
+		);
+
+		// add a normal transition too to ensure that forced changes take priority.
+		add_scheduled_change(
+			&mut builder,
+			ScheduledChange { next_authorities: make_ids(genesis_authorities), delay: 5 },
+		);
+
+		builder.build().unwrap().block
+	});
+
+	net.lock().peer(0).push_blocks(25, false);
+	net.lock().run_until_sync().await;
+
+	for (i, peer) in net.lock().peers().iter().enumerate() {
+		assert_eq!(peer.client().info().best_number, 26, "Peer #{} failed to sync", i);
+
+		let full_client = peer.client().as_client();
+		let set: AuthoritySet<Hash, BlockNumber> =
+			crate::aux_schema::load_authorities(&*full_client).unwrap();
+
+		assert_eq!(set.current(), (1, voters.as_slice()));
+		assert_eq!(set.pending_changes().count(), 0);
+	}
+
+	// it will only finalize if the forced transition happens.
+	// we add_blocks after the voters are spawned because otherwise
+	// the link-halves have the wrong AuthoritySet
+	tokio::spawn(voters_future);
+	run_to_completion(25, net, peers_a).await;
+}
+
+#[tokio::test]
+async fn allows_reimporting_change_blocks() {
+	let peers_a = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let peers_b = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob];
+	let voters = make_ids(peers_a);
+	let api = TestApi::new(voters);
+	let mut net = GrandpaTestNet::new(api.clone(), 3, 0);
+
+	let client = net.peer(0).client().clone();
+	let (mut block_import, ..) = net.make_block_import(client.clone());
+
+	let full_client = client.as_client();
+	let mut builder = full_client
+		.new_block_at(full_client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+
+	add_scheduled_change(
+		&mut builder,
+		ScheduledChange { next_authorities: make_ids(peers_b), delay: 0 },
+	);
+	let block = builder.build().unwrap().block;
+
+	let block = || {
+		let block = block.clone();
+		let mut import = BlockImportParams::new(BlockOrigin::File, block.header);
+		import.body = Some(block.extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		import
+	};
+
+	assert_eq!(
+		block_import.import_block(block()).await.unwrap(),
+		ImportResult::Imported(ImportedAux {
+			needs_justification: true,
+			clear_justification_requests: false,
+			bad_justification: false,
+			is_new_best: true,
+			header_only: false,
+		}),
+	);
+
+	assert_eq!(block_import.import_block(block()).await.unwrap(), ImportResult::AlreadyInChain);
+}
+
+#[tokio::test]
+async fn test_bad_justification() {
+	let peers_a = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let peers_b = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob];
+	let voters = make_ids(peers_a);
+	let api = TestApi::new(voters);
+	let mut net = GrandpaTestNet::new(api.clone(), 3, 0);
+
+	let client = net.peer(0).client().clone();
+	let (mut block_import, ..) = net.make_block_import(client.clone());
+
+	let full_client = client.as_client();
+	let mut builder = full_client
+		.new_block_at(full_client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+
+	add_scheduled_change(
+		&mut builder,
+		ScheduledChange { next_authorities: make_ids(peers_b), delay: 0 },
+	);
+
+	let block = builder.build().unwrap().block;
+
+	let block = || {
+		let block = block.clone();
+		let mut import = BlockImportParams::new(BlockOrigin::File, block.header);
+		import.justifications = Some(Justifications::from((GRANDPA_ENGINE_ID, Vec::new())));
+		import.body = Some(block.extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		import
+	};
+
+	assert_eq!(
+		block_import.import_block(block()).await.unwrap(),
+		ImportResult::Imported(ImportedAux {
+			needs_justification: true,
+			clear_justification_requests: false,
+			bad_justification: true,
+			is_new_best: true,
+			..Default::default()
+		}),
+	);
+
+	assert_eq!(block_import.import_block(block()).await.unwrap(), ImportResult::AlreadyInChain);
+}
+
+#[tokio::test]
+async fn voter_persists_its_votes() {
+	use futures::future;
+	use std::sync::atomic::{AtomicUsize, Ordering};
+
+	sp_tracing::try_init_simple();
+
+	// we have two authorities but we'll only be running the voter for alice
+	// we are going to be listening for the prevotes it casts
+	let peers = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob];
+	let voters = make_ids(peers);
+
+	// alice has a chain with 20 blocks
+	let mut net = GrandpaTestNet::new(TestApi::new(voters.clone()), 2, 0);
+
+	// create the communication layer for bob, but don't start any
+	// voter. instead we'll listen for the prevote that alice casts
+	// and cast our own manually
+	let bob_keystore = create_keystore(peers[1]);
+	let bob_network = {
+		let config = Config {
+			gossip_duration: TEST_GOSSIP_DURATION,
+			justification_generation_period: 32,
+			keystore: Some(bob_keystore.clone()),
+			name: Some(format!("peer#{}", 1)),
+			local_role: Role::Authority,
+			observer_enabled: true,
+			telemetry: None,
+			protocol_name: grandpa_protocol_name::NAME.into(),
+		};
+
+		let set_state = {
+			let bob_client = net.peer(1).client().clone();
+			let (_, _, link) = net.make_block_import(bob_client);
+			let LinkHalf { persistent_data, .. } = link.lock().take().unwrap();
+			let PersistentData { set_state, .. } = persistent_data;
+			set_state
+		};
+
+		communication::NetworkBridge::new(
+			net.peers[1].network_service().clone(),
+			net.peers[1].sync_service().clone(),
+			config.clone(),
+			set_state,
+			None,
+			None,
+		)
+	};
+
+	// spawn two voters for alice.
+	// half-way through the test, we stop one and start the other.
+	let (alice_voter1, abort) = future::abortable({
+		let keystore = create_keystore(peers[0]);
+
+		let (net_service, link) = {
+			// temporary needed for some reason
+			let link = net.peers[0].data.lock().take().expect("link initialized at startup; qed");
+			(net.peers[0].network_service().clone(), link)
+		};
+		let sync = net.peers[0].sync_service().clone();
+
+		let grandpa_params = GrandpaParams {
+			config: Config {
+				gossip_duration: TEST_GOSSIP_DURATION,
+				justification_generation_period: 32,
+				keystore: Some(keystore),
+				name: Some(format!("peer#{}", 0)),
+				local_role: Role::Authority,
+				observer_enabled: true,
+				telemetry: None,
+				protocol_name: grandpa_protocol_name::NAME.into(),
+			},
+			link,
+			network: net_service,
+			sync,
+			voting_rule: VotingRulesBuilder::default().build(),
+			prometheus_registry: None,
+			shared_voter_state: SharedVoterState::empty(),
+			telemetry: None,
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+				RejectAllTxPool::default(),
+			),
+		};
+
+		run_grandpa_voter(grandpa_params).expect("all in order with client and network")
+	});
+
+	fn alice_voter2(
+		peers: &[Ed25519Keyring],
+		net: Arc<Mutex<GrandpaTestNet>>,
+	) -> impl Future<Output = ()> + Send {
+		let keystore = create_keystore(peers[0]);
+		let mut net = net.lock();
+
+		// we add a new peer to the test network and we'll use
+		// the network service of this new peer
+		net.add_authority_peer();
+		let net_service = net.peers[2].network_service().clone();
+		let sync = net.peers[2].sync_service().clone();
+		// but we'll reuse the client from the first peer (alice_voter1)
+		// since we want to share the same database, so that we can
+		// read the persisted state after aborting alice_voter1.
+		let alice_client = net.peer(0).client().clone();
+
+		let (_block_import, _, link) = net.make_block_import(alice_client);
+		let link = link.lock().take().unwrap();
+
+		let grandpa_params = GrandpaParams {
+			config: Config {
+				gossip_duration: TEST_GOSSIP_DURATION,
+				justification_generation_period: 32,
+				keystore: Some(keystore),
+				name: Some(format!("peer#{}", 0)),
+				local_role: Role::Authority,
+				observer_enabled: true,
+				telemetry: None,
+				protocol_name: grandpa_protocol_name::NAME.into(),
+			},
+			link,
+			network: net_service,
+			sync,
+			voting_rule: VotingRulesBuilder::default().build(),
+			prometheus_registry: None,
+			shared_voter_state: SharedVoterState::empty(),
+			telemetry: None,
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+				RejectAllTxPool::default(),
+			),
+		};
+
+		run_grandpa_voter(grandpa_params)
+			.expect("all in order with client and network")
+			.map(move |r| {
+				// we need to keep the block_import alive since it owns the
+				// sender for the voter commands channel, if that gets dropped
+				// then the voter will stop
+				drop(_block_import);
+				r
+			})
+	}
+
+	tokio::spawn(alice_voter1);
+
+	net.peer(0).push_blocks(20, false);
+	net.run_until_sync().await;
+
+	assert_eq!(net.peer(0).client().info().best_number, 20, "Peer #{} failed to sync", 0);
+
+	let net = Arc::new(Mutex::new(net));
+
+	let (exit_tx, exit_rx) = futures::channel::oneshot::channel::<()>();
+
+	{
+		let (round_rx, round_tx) = bob_network.round_communication(
+			Some((peers[1].public().into(), bob_keystore).into()),
+			communication::Round(1),
+			communication::SetId(0),
+			Arc::new(VoterSet::new(voters).unwrap()),
+			HasVoted::No,
+		);
+
+		tokio::spawn(bob_network);
+
+		let round_tx = Arc::new(Mutex::new(round_tx));
+		let exit_tx = Arc::new(Mutex::new(Some(exit_tx)));
+
+		let net = net.clone();
+		let state = Arc::new(AtomicUsize::new(0));
+
+		tokio::spawn(round_rx.for_each(move |signed| {
+			let net2 = net.clone();
+			let net = net.clone();
+			let abort = abort.clone();
+			let round_tx = round_tx.clone();
+			let state = state.clone();
+			let exit_tx = exit_tx.clone();
+
+			async move {
+				if state.compare_exchange(0, 1, Ordering::SeqCst, Ordering::SeqCst).unwrap() == 0 {
+					// the first message we receive should be a prevote from alice.
+					let prevote = match signed.message {
+						finality_grandpa::Message::Prevote(prevote) => prevote,
+						_ => panic!("voter should prevote."),
+					};
+
+					// its chain has 20 blocks and the voter targets 3/4 of the
+					// unfinalized chain, so the vote should be for block 15
+					assert_eq!(prevote.target_number, 15);
+
+					// we push 20 more blocks to alice's chain
+					net.lock().peer(0).push_blocks(20, false);
+
+					let interval =
+						futures::stream::unfold(Delay::new(Duration::from_millis(200)), |delay| {
+							Box::pin(async move {
+								delay.await;
+								Some(((), Delay::new(Duration::from_millis(200))))
+							})
+						});
+
+					interval
+						.take_while(move |_| {
+							future::ready(net2.lock().peer(1).client().info().best_number != 40)
+						})
+						.for_each(|_| future::ready(()))
+						.await;
+
+					let block_30_hash =
+						net.lock().peer(0).client().as_client().hash(30).unwrap().unwrap();
+
+					// we restart alice's voter
+					abort.abort();
+					tokio::spawn(alice_voter2(peers, net.clone()));
+
+					// and we push our own prevote for block 30
+					let prevote =
+						finality_grandpa::Prevote { target_number: 30, target_hash: block_30_hash };
+
+					// One should either be calling `Sink::send` or `Sink::start_send` followed
+					// by `Sink::poll_complete` to make sure items are being flushed. Given that
+					// we send in a loop including a delay until items are received, this can be
+					// ignored for the sake of reduced complexity.
+					Pin::new(&mut *round_tx.lock())
+						.start_send(finality_grandpa::Message::Prevote(prevote))
+						.unwrap();
+				} else if state.compare_exchange(1, 2, Ordering::SeqCst, Ordering::SeqCst).unwrap() ==
+					1
+				{
+					// the next message we receive should be our own prevote
+					let prevote = match signed.message {
+						finality_grandpa::Message::Prevote(prevote) => prevote,
+						_ => panic!("We should receive our own prevote."),
+					};
+
+					// targeting block 30
+					assert!(prevote.target_number == 30);
+
+				// after alice restarts it should send its previous prevote
+				// therefore we won't ever receive it again since it will be a
+				// known message on the gossip layer
+				} else if state.compare_exchange(2, 3, Ordering::SeqCst, Ordering::SeqCst).unwrap() ==
+					2
+				{
+					// we then receive a precommit from alice for block 15
+					// even though we casted a prevote for block 30
+					let precommit = match signed.message {
+						finality_grandpa::Message::Precommit(precommit) => precommit,
+						_ => panic!("voter should precommit."),
+					};
+
+					assert!(precommit.target_number == 15);
+
+					// signal exit
+					exit_tx.clone().lock().take().unwrap().send(()).unwrap();
+				} else {
+					panic!()
+				}
+			}
+		}));
+	}
+
+	run_until_complete(exit_rx.into_future(), &net).await;
+}
+
+#[tokio::test]
+async fn finalize_3_voters_1_light_observer() {
+	sp_tracing::try_init_simple();
+	let authorities = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+	let voters = make_ids(authorities);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 3, 1);
+	let voters = initialize_grandpa(&mut net, authorities);
+	let observer = observer::run_grandpa_observer(
+		Config {
+			gossip_duration: TEST_GOSSIP_DURATION,
+			justification_generation_period: 32,
+			keystore: None,
+			name: Some("observer".to_string()),
+			local_role: Role::Full,
+			observer_enabled: true,
+			telemetry: None,
+			protocol_name: grandpa_protocol_name::NAME.into(),
+		},
+		net.peers[3].data.lock().take().expect("link initialized at startup; qed"),
+		net.peers[3].network_service().clone(),
+		net.peers[3].sync_service().clone(),
+	)
+	.unwrap();
+	net.peer(0).push_blocks(20, false);
+	net.run_until_sync().await;
+
+	for i in 0..4 {
+		assert_eq!(net.peer(i).client().info().best_number, 20, "Peer #{} failed to sync", i);
+	}
+
+	let net = Arc::new(Mutex::new(net));
+
+	tokio::spawn(voters);
+	tokio::spawn(observer);
+	run_to_completion(20, net.clone(), authorities).await;
+}
+
+#[tokio::test]
+async fn voter_catches_up_to_latest_round_when_behind() {
+	sp_tracing::try_init_simple();
+
+	let peers = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob];
+	let voters = make_ids(peers);
+
+	let net = GrandpaTestNet::new(TestApi::new(voters), 2, 0);
+
+	let net = Arc::new(Mutex::new(net));
+	let mut finality_notifications = Vec::new();
+
+	let voter = |keystore,
+	             peer_id,
+	             link,
+	             net: Arc<Mutex<GrandpaTestNet>>|
+	 -> Pin<Box<dyn Future<Output = ()> + Send>> {
+		let mut net = net.lock();
+		let grandpa_params = GrandpaParams {
+			config: Config {
+				gossip_duration: TEST_GOSSIP_DURATION,
+				justification_generation_period: 32,
+				keystore,
+				name: Some(format!("peer#{}", peer_id)),
+				local_role: Role::Authority,
+				observer_enabled: true,
+				telemetry: None,
+				protocol_name: grandpa_protocol_name::NAME.into(),
+			},
+			link,
+			network: net.peer(peer_id).network_service().clone(),
+			sync: net.peer(peer_id).sync_service().clone(),
+			voting_rule: (),
+			prometheus_registry: None,
+			shared_voter_state: SharedVoterState::empty(),
+			telemetry: None,
+			offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(
+				RejectAllTxPool::default(),
+			),
+		};
+
+		Box::pin(run_grandpa_voter(grandpa_params).expect("all in order with client and network"))
+	};
+
+	// spawn authorities
+	for (peer_id, key) in peers.iter().enumerate() {
+		let (client, link) = {
+			let net = net.lock();
+			let link =
+				net.peers[peer_id].data.lock().take().expect("link initialized at startup; qed");
+			(net.peers[peer_id].client().clone(), link)
+		};
+
+		finality_notifications.push(
+			client
+				.finality_notification_stream()
+				.take_while(|n| future::ready(n.header.number() < &50))
+				.for_each(move |_| future::ready(())),
+		);
+
+		let keystore = create_keystore(*key);
+
+		let voter = voter(Some(keystore), peer_id, link, net.clone());
+
+		tokio::spawn(voter);
+	}
+
+	net.lock().peer(0).push_blocks(50, false);
+	net.lock().run_until_sync().await;
+
+	// wait for them to finalize block 50. since they'll vote on 3/4 of the
+	// unfinalized chain it will take at least 4 rounds to do it.
+	let wait_for_finality = ::futures::future::join_all(finality_notifications);
+
+	// spawn a new voter, it should be behind by at least 4 rounds and should be
+	// able to catch up to the latest round
+	let test = {
+		let net = net.clone();
+
+		wait_for_finality.then(move |_| {
+			net.lock().add_authority_peer();
+
+			let link = {
+				let net = net.lock();
+				let mut link = net.peers[2].data.lock();
+				link.take().expect("link initialized at startup; qed")
+			};
+			let set_state = link.persistent_data.set_state.clone();
+			tokio::spawn(voter(None, 2, link, net.clone()));
+
+			let start_time = std::time::Instant::now();
+			let timeout = Duration::from_secs(5 * 60);
+			let wait_for_catch_up = futures::future::poll_fn(move |_| {
+				// The voter will start at round 1 and since everyone else is
+				// already at a later round the only way to get to round 4 (or
+				// later) is by issuing a catch up request.
+				if set_state.read().last_completed_round().number >= 4 {
+					Poll::Ready(())
+				} else if start_time.elapsed() > timeout {
+					panic!("Timed out while waiting for catch up to happen")
+				} else {
+					Poll::Pending
+				}
+			});
+
+			wait_for_catch_up
+		})
+	};
+
+	let drive_to_completion = futures::future::poll_fn(|cx| {
+		net.lock().poll(cx);
+		Poll::<()>::Pending
+	});
+	future::select(test, drive_to_completion).await;
+}
+
+type TestEnvironment<N, S, SC, VR> =
+	Environment<substrate_test_runtime_client::Backend, Block, TestClient, N, S, SC, VR>;
+
+fn test_environment_with_select_chain<N, S, VR, SC>(
+	link: &TestLinkHalf,
+	keystore: Option<KeystorePtr>,
+	network_service: N,
+	sync_service: S,
+	select_chain: SC,
+	voting_rule: VR,
+) -> TestEnvironment<N, S, SC, VR>
+where
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	VR: VotingRule<Block, TestClient>,
+{
+	let PersistentData { ref authority_set, ref set_state, .. } = link.persistent_data;
+
+	let config = Config {
+		gossip_duration: TEST_GOSSIP_DURATION,
+		justification_generation_period: 32,
+		keystore,
+		name: None,
+		local_role: Role::Authority,
+		observer_enabled: true,
+		telemetry: None,
+		protocol_name: grandpa_protocol_name::NAME.into(),
+	};
+
+	let network = NetworkBridge::new(
+		network_service.clone(),
+		sync_service,
+		config.clone(),
+		set_state.clone(),
+		None,
+		None,
+	);
+
+	Environment {
+		authority_set: authority_set.clone(),
+		config: config.clone(),
+		client: link.client.clone(),
+		select_chain,
+		set_id: authority_set.set_id(),
+		voter_set_state: set_state.clone(),
+		voters: Arc::new(authority_set.current_authorities()),
+		network,
+		voting_rule,
+		metrics: None,
+		justification_sender: None,
+		telemetry: None,
+		_phantom: PhantomData,
+		offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(RejectAllTxPool::default()),
+	}
+}
+
+fn test_environment<N, S, VR>(
+	link: &TestLinkHalf,
+	keystore: Option<KeystorePtr>,
+	network_service: N,
+	sync_service: S,
+	voting_rule: VR,
+) -> TestEnvironment<N, S, LongestChain<substrate_test_runtime_client::Backend, Block>, VR>
+where
+	N: NetworkT<Block>,
+	S: SyncingT<Block>,
+	VR: VotingRule<Block, TestClient>,
+{
+	test_environment_with_select_chain(
+		link,
+		keystore,
+		network_service,
+		sync_service,
+		link.select_chain.clone(),
+		voting_rule,
+	)
+}
+
+#[tokio::test]
+async fn grandpa_environment_respects_voting_rules() {
+	use finality_grandpa::voter::Environment;
+
+	let peers = &[Ed25519Keyring::Alice];
+	let voters = make_ids(peers);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 1, 0);
+	let peer = net.peer(0);
+	let network_service = peer.network_service().clone();
+	let sync_service = peer.sync_service().clone();
+	let link = peer.data.lock().take().unwrap();
+
+	// add 21 blocks
+	let hashes = peer.push_blocks(21, false);
+
+	// create an environment with no voting rule restrictions
+	let unrestricted_env =
+		test_environment(&link, None, network_service.clone(), sync_service.clone(), ());
+
+	// another with 3/4 unfinalized chain voting rule restriction
+	let three_quarters_env = test_environment(
+		&link,
+		None,
+		network_service.clone(),
+		sync_service.clone(),
+		voting_rule::ThreeQuartersOfTheUnfinalizedChain,
+	);
+
+	// and another restricted with the default voting rules: i.e. 3/4 rule and
+	// always below best block
+	let default_env = test_environment(
+		&link,
+		None,
+		network_service.clone(),
+		sync_service,
+		VotingRulesBuilder::default().build(),
+	);
+
+	// the unrestricted environment should just return the best block
+	assert_eq!(
+		unrestricted_env
+			.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		21,
+	);
+
+	// both the other environments should return block 16, which is 3/4 of the
+	// way in the unfinalized chain
+	assert_eq!(
+		three_quarters_env
+			.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		16,
+	);
+
+	assert_eq!(
+		default_env
+			.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		16,
+	);
+
+	// we finalize block 19 with block 21 being the best block
+	peer.client().finalize_block(hashes[18], None, false).unwrap();
+
+	// the 3/4 environment should propose block 21 for voting
+	assert_eq!(
+		three_quarters_env
+			.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		21,
+	);
+
+	// while the default environment will always still make sure we don't vote
+	// on the best block (2 behind)
+	assert_eq!(
+		default_env
+			.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		19,
+	);
+
+	// we finalize block 21 with block 21 being the best block
+	let hashof21 = hashes[20];
+	peer.client().finalize_block(hashof21, None, false).unwrap();
+
+	// even though the default environment will always try to not vote on the
+	// best block, there's a hard rule that we can't cast any votes lower than
+	// the given base (#21).
+	assert_eq!(
+		default_env
+			.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		21,
+	);
+}
+
+#[tokio::test]
+async fn grandpa_environment_passes_actual_best_block_to_voting_rules() {
+	// NOTE: this is a "regression" test since initially we were not passing the
+	// best block to the voting rules
+	use finality_grandpa::voter::Environment;
+
+	let peers = &[Ed25519Keyring::Alice];
+	let voters = make_ids(peers);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 1, 0);
+	let peer = net.peer(0);
+	let network_service = peer.network_service().clone();
+	let sync_service = peer.sync_service().clone();
+	let link = peer.data.lock().take().unwrap();
+	let client = peer.client().as_client().clone();
+	let select_chain = MockSelectChain::default();
+
+	// add 42 blocks
+	peer.push_blocks(42, false);
+
+	// create an environment with a voting rule that always restricts votes to
+	// before the best block by 5 blocks
+	let env = test_environment_with_select_chain(
+		&link,
+		None,
+		network_service.clone(),
+		sync_service,
+		select_chain.clone(),
+		voting_rule::BeforeBestBlockBy(5),
+	);
+
+	// both best block and finality target are pointing to the same latest block,
+	// therefore we must restrict our vote on top of the given target (#21)
+	let hashof21 = client.expect_block_hash_from_id(&BlockId::Number(21)).unwrap();
+	select_chain.set_best_chain(client.expect_header(hashof21).unwrap());
+	select_chain.set_finality_target(client.expect_header(hashof21).unwrap().hash());
+
+	assert_eq!(
+		env.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		16,
+	);
+
+	// the returned finality target is already 11 blocks from the best block,
+	// therefore there should be no further restriction by the voting rule
+	let hashof10 = client.expect_block_hash_from_id(&BlockId::Number(10)).unwrap();
+	select_chain.set_best_chain(client.expect_header(hashof21).unwrap());
+	select_chain.set_finality_target(client.expect_header(hashof10).unwrap().hash());
+
+	assert_eq!(
+		env.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.1,
+		10,
+	);
+}
+
+#[tokio::test]
+async fn grandpa_environment_checks_if_best_block_is_descendent_of_finality_target() {
+	sp_tracing::try_init_simple();
+	use finality_grandpa::voter::Environment;
+
+	let peers = &[Ed25519Keyring::Alice];
+	let voters = make_ids(peers);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 1, 0);
+	let peer = net.peer(0);
+	let network_service = peer.network_service().clone();
+	let sync_service = peer.sync_service().clone();
+	let link = peer.data.lock().take().unwrap();
+	let client = peer.client().as_client().clone();
+	let select_chain = MockSelectChain::default();
+	let voting_rule = AssertBestBlock::default();
+	let env = test_environment_with_select_chain(
+		&link,
+		None,
+		network_service.clone(),
+		sync_service.clone(),
+		select_chain.clone(),
+		voting_rule.clone(),
+	);
+
+	// create a chain that is 10 blocks long
+	peer.push_blocks(10, false);
+
+	let hashof5_a = client.expect_block_hash_from_id(&BlockId::Number(5)).unwrap();
+	let hashof10_a = client.expect_block_hash_from_id(&BlockId::Number(10)).unwrap();
+
+	// create a fork starting at block 4 that is 6 blocks long
+	let fork = peer.generate_blocks_at(
+		BlockId::Number(4),
+		6,
+		BlockOrigin::File,
+		|mut builder| {
+			builder.push_deposit_log_digest_item(DigestItem::Other(vec![1])).unwrap();
+			builder.build().unwrap().block
+		},
+		false,
+		false,
+		true,
+		ForkChoiceStrategy::LongestChain,
+	);
+
+	let hashof5_b = *fork.first().unwrap();
+	let hashof10_b = *fork.last().unwrap();
+
+	// returning a finality target that's higher than the best block is inconsistent,
+	// therefore the best block should be set to be the same block as the target
+	select_chain.set_best_chain(client.expect_header(hashof5_a).unwrap());
+	select_chain.set_finality_target(client.expect_header(hashof10_a).unwrap().hash());
+	voting_rule.set_expected_best_block(hashof10_a);
+
+	// the voting rule will internally assert that the best block that was passed was `hashof10_a`,
+	// instead of the one returned by `SelectChain`
+	assert_eq!(
+		env.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.0,
+		hashof10_a,
+	);
+
+	// best block and finality target are blocks at the same height but on different forks,
+	// we should override the initial best block (#5B) with the target block (#5A)
+	select_chain.set_best_chain(client.expect_header(hashof5_b).unwrap());
+	select_chain.set_finality_target(client.expect_header(hashof5_a).unwrap().hash());
+	voting_rule.set_expected_best_block(hashof5_a);
+
+	assert_eq!(
+		env.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.0,
+		hashof5_a,
+	);
+
+	// best block is higher than finality target but it's on a different fork,
+	// we should override the initial best block (#5A) with the target block (#5B)
+	select_chain.set_best_chain(client.expect_header(hashof10_b).unwrap());
+	select_chain.set_finality_target(client.expect_header(hashof5_a).unwrap().hash());
+	voting_rule.set_expected_best_block(hashof5_a);
+
+	assert_eq!(
+		env.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.0,
+		hashof5_a,
+	);
+
+	// best block is higher than finality target and it's on the same fork,
+	// the best block passed to the voting rule should not be overriden
+	select_chain.set_best_chain(client.expect_header(hashof10_a).unwrap());
+	select_chain.set_finality_target(client.expect_header(hashof5_a).unwrap().hash());
+	voting_rule.set_expected_best_block(hashof10_a);
+
+	assert_eq!(
+		env.best_chain_containing(peer.client().info().finalized_hash)
+			.await
+			.unwrap()
+			.unwrap()
+			.0,
+		hashof5_a,
+	);
+}
+
+#[tokio::test]
+async fn grandpa_environment_never_overwrites_round_voter_state() {
+	use finality_grandpa::voter::Environment;
+
+	let peers = &[Ed25519Keyring::Alice];
+	let voters = make_ids(peers);
+
+	let mut net = GrandpaTestNet::new(TestApi::new(voters), 1, 0);
+	let peer = net.peer(0);
+	let network_service = peer.network_service().clone();
+	let sync_service = peer.sync_service().clone();
+	let link = peer.data.lock().take().unwrap();
+
+	let keystore = create_keystore(peers[0]);
+	let environment =
+		test_environment(&link, Some(keystore), network_service.clone(), sync_service, ());
+
+	let round_state = || finality_grandpa::round::State::genesis(Default::default());
+	let base = || Default::default();
+	let historical_votes = || finality_grandpa::HistoricalVotes::new();
+
+	let get_current_round = |n| {
+		let current_rounds = environment
+			.voter_set_state
+			.read()
+			.with_current_round(n)
+			.map(|(_, current_rounds)| current_rounds.clone())
+			.ok()?;
+
+		Some(current_rounds.get(&n).unwrap().clone())
+	};
+
+	// round 2 should not be tracked
+	assert_eq!(get_current_round(2), None);
+
+	// after completing round 1 we should start tracking round 2
+	environment.completed(1, round_state(), base(), &historical_votes()).unwrap();
+
+	assert_eq!(get_current_round(2).unwrap(), HasVoted::No);
+
+	// we need to call `round_data` for the next round to pick up
+	// from the keystore which authority id we'll be using to vote
+	environment.round_data(2);
+
+	let info = peer.client().info();
+
+	let prevote =
+		finality_grandpa::Prevote { target_hash: info.best_hash, target_number: info.best_number };
+
+	// we prevote for round 2 which should lead to us updating the voter state
+	environment.prevoted(2, prevote.clone()).unwrap();
+
+	let has_voted = get_current_round(2).unwrap();
+
+	assert_matches!(has_voted, HasVoted::Yes(_, _));
+	assert_eq!(*has_voted.prevote().unwrap(), prevote);
+
+	// if we report round 1 as completed again we should not overwrite the
+	// voter state for round 2
+	environment.completed(1, round_state(), base(), &historical_votes()).unwrap();
+
+	assert_matches!(get_current_round(2).unwrap(), HasVoted::Yes(_, _));
+}
+
+#[tokio::test]
+async fn justification_with_equivocation() {
+	use sp_application_crypto::Pair;
+
+	// we have 100 authorities
+	let pairs = (0..100).map(|n| AuthorityPair::from_seed(&[n; 32])).collect::<Vec<_>>();
+	let voters = pairs.iter().map(AuthorityPair::public).map(|id| (id, 1)).collect::<Vec<_>>();
+	let api = TestApi::new(voters.clone());
+	let mut net = GrandpaTestNet::new(api.clone(), 1, 0);
+
+	// we create a basic chain with 3 blocks (no forks)
+	net.peer(0).push_blocks(3, false);
+
+	let client = net.peer(0).client().as_client().clone();
+	let hashof1 = client.expect_block_hash_from_id(&BlockId::Number(1)).unwrap();
+	let hashof2 = client.expect_block_hash_from_id(&BlockId::Number(2)).unwrap();
+	let hashof3 = client.expect_block_hash_from_id(&BlockId::Number(3)).unwrap();
+	let block1 = client.expect_header(hashof1).unwrap();
+	let block2 = client.expect_header(hashof2).unwrap();
+	let block3 = client.expect_header(hashof3).unwrap();
+
+	let set_id = 0;
+	let justification = {
+		let round = 1;
+
+		let make_precommit = |target_hash, target_number, pair: &AuthorityPair| {
+			let precommit = finality_grandpa::Precommit { target_hash, target_number };
+
+			let msg = finality_grandpa::Message::Precommit(precommit.clone());
+			let encoded = sp_consensus_grandpa::localized_payload(round, set_id, &msg);
+
+			let precommit = finality_grandpa::SignedPrecommit {
+				precommit: precommit.clone(),
+				signature: pair.sign(&encoded[..]),
+				id: pair.public(),
+			};
+
+			precommit
+		};
+
+		let mut precommits = Vec::new();
+
+		// we have 66/100 votes for block #3 and therefore do not have threshold to finalize
+		for pair in pairs.iter().take(66) {
+			let precommit = make_precommit(block3.hash(), *block3.number(), pair);
+			precommits.push(precommit);
+		}
+
+		// we create an equivocation for the 67th validator targetting blocks #1 and #2.
+		// this should be accounted as "voting for all blocks" and therefore block #3 will
+		// have 67/100 votes, reaching finality threshold.
+		{
+			precommits.push(make_precommit(block1.hash(), *block1.number(), &pairs[66]));
+			precommits.push(make_precommit(block2.hash(), *block2.number(), &pairs[66]));
+		}
+
+		let commit = finality_grandpa::Commit {
+			target_hash: block3.hash(),
+			target_number: *block3.number(),
+			precommits,
+		};
+
+		GrandpaJustification::from_commit(&client, round, commit).unwrap()
+	};
+
+	// the justification should include the minimal necessary vote ancestry and
+	// the commit should be valid
+	assert!(justification.verify(set_id, &voters).is_ok());
+}
+
+#[tokio::test]
+async fn imports_justification_for_regular_blocks_on_import() {
+	// NOTE: this is a regression test since initially we would only import
+	// justifications for authority change blocks, and would discard any
+	// existing justification otherwise.
+	let peers = &[Ed25519Keyring::Alice];
+	let voters = make_ids(peers);
+	let api = TestApi::new(voters);
+	let mut net = GrandpaTestNet::new(api.clone(), 1, 0);
+
+	let client = net.peer(0).client().clone();
+	let (mut block_import, ..) = net.make_block_import(client.clone());
+	let full_client = client.as_client();
+
+	// create a new block (without importing it)
+	let generate_block = |parent| {
+		let builder = full_client.new_block_at(parent, Default::default(), false).unwrap();
+		builder.build().unwrap().block
+	};
+
+	// create a valid justification, with one precommit targeting the block
+	let make_justification = |round, hash, number| {
+		let set_id = 0;
+
+		let precommit = finality_grandpa::Precommit { target_hash: hash, target_number: number };
+
+		let msg = finality_grandpa::Message::Precommit(precommit.clone());
+		let encoded = sp_consensus_grandpa::localized_payload(round, set_id, &msg);
+		let signature = peers[0].sign(&encoded[..]).into();
+
+		let precommit = finality_grandpa::SignedPrecommit {
+			precommit,
+			signature,
+			id: peers[0].public().into(),
+		};
+
+		let commit = finality_grandpa::Commit {
+			target_hash: hash,
+			target_number: number,
+			precommits: vec![precommit],
+		};
+
+		GrandpaJustification::from_commit(&full_client, round, commit).unwrap()
+	};
+
+	let mut generate_and_import_block_with_justification = |parent| {
+		// we import the block with justification attached
+		let block = generate_block(parent);
+		let block_hash = block.hash();
+		let justification = make_justification(1, block_hash, *block.header.number());
+
+		let mut import = BlockImportParams::new(BlockOrigin::File, block.header);
+		import.justifications = Some((GRANDPA_ENGINE_ID, justification.encode()).into());
+		import.body = Some(block.extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		assert_eq!(
+			// NOTE: we use `block_on` here because async closures are
+			// unsupported and it doesn't matter if we block in a test
+			futures::executor::block_on(block_import.import_block(import)).unwrap(),
+			ImportResult::Imported(ImportedAux {
+				needs_justification: false,
+				clear_justification_requests: false,
+				bad_justification: false,
+				is_new_best: true,
+				..Default::default()
+			}),
+		);
+
+		block_hash
+	};
+
+	let block1 =
+		generate_and_import_block_with_justification(full_client.chain_info().genesis_hash);
+
+	// the justification should be imported and available from the client
+	assert!(client.justifications(block1).unwrap().is_some());
+
+	// subsequent justifications should be ignored and not imported
+	let mut parent = block1;
+	for _ in 2..JUSTIFICATION_IMPORT_PERIOD {
+		parent = generate_and_import_block_with_justification(parent);
+		assert!(client.justifications(parent).unwrap().is_none());
+	}
+
+	let block32 = generate_and_import_block_with_justification(parent);
+
+	// until we reach a block in the next justification import period, at
+	// which point we should import it
+	assert!(client.justifications(block32).unwrap().is_some());
+}
+
+#[tokio::test]
+async fn grandpa_environment_doesnt_send_equivocation_reports_for_itself() {
+	use finality_grandpa::voter::Environment;
+
+	let alice = Ed25519Keyring::Alice;
+	let voters = make_ids(&[alice]);
+
+	let environment = {
+		let mut net = GrandpaTestNet::new(TestApi::new(voters), 1, 0);
+		let peer = net.peer(0);
+		let network_service = peer.network_service().clone();
+		let sync_service = peer.sync_service().clone();
+		let link = peer.data.lock().take().unwrap();
+		let keystore = create_keystore(alice);
+		test_environment(&link, Some(keystore), network_service.clone(), sync_service, ())
+	};
+
+	let signed_prevote = {
+		let prevote = finality_grandpa::Prevote { target_hash: H256::random(), target_number: 1 };
+
+		let signed = alice.sign(&[]).into();
+		(prevote, signed)
+	};
+
+	let mut equivocation = finality_grandpa::Equivocation {
+		round_number: 1,
+		identity: alice.public().into(),
+		first: signed_prevote.clone(),
+		second: signed_prevote.clone(),
+	};
+
+	// we need to call `round_data` to pick up from the keystore which
+	// authority id we'll be using to vote
+	environment.round_data(1);
+
+	// reporting the equivocation should fail since the offender is a local
+	// authority (i.e. we have keys in our keystore for the given id)
+	let equivocation_proof = sp_consensus_grandpa::Equivocation::Prevote(equivocation.clone());
+	assert!(matches!(environment.report_equivocation(equivocation_proof), Err(Error::Safety(_))));
+
+	// if we set the equivocation offender to another id for which we don't have
+	// keys it should work
+	equivocation.identity = TryFrom::try_from(&[1; 32][..]).unwrap();
+	let equivocation_proof = sp_consensus_grandpa::Equivocation::Prevote(equivocation);
+	environment.report_equivocation(equivocation_proof).unwrap();
+}
+
+#[tokio::test]
+async fn revert_prunes_authority_changes() {
+	sp_tracing::try_init_simple();
+
+	let peers = &[Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+
+	type TestBlockBuilder<'a> =
+		BlockBuilder<'a, Block, PeersFullClient, substrate_test_runtime_client::Backend>;
+	let edit_block = |mut builder: TestBlockBuilder| {
+		add_scheduled_change(
+			&mut builder,
+			ScheduledChange { next_authorities: make_ids(peers), delay: 0 },
+		);
+		builder.build().unwrap().block
+	};
+
+	let api = TestApi::new(make_ids(peers));
+
+	let mut net = GrandpaTestNet::new(api, 3, 0);
+	tokio::spawn(initialize_grandpa(&mut net, peers));
+
+	let peer = net.peer(0);
+	let client = peer.client().as_client();
+
+	// Test scenario: (X) = auth-change, 24 = revert-point
+	//
+	//              +---------(27)
+	//             /
+	// 0---(21)---23---24---25---(28)---30
+	//                  ^    \
+	//        revert-point    +------(29)
+
+	// Construct canonical chain
+
+	// add 20 blocks
+	peer.push_blocks(20, false);
+	// at block 21 we add an authority transition
+	peer.generate_blocks(1, BlockOrigin::File, edit_block);
+	// add more blocks on top of it (until we have 24)
+	peer.push_blocks(3, false);
+	// add more blocks on top of it (until we have 27)
+	peer.push_blocks(3, false);
+	// at block 28 we add an authority transition
+	peer.generate_blocks(1, BlockOrigin::File, edit_block);
+	// add more blocks on top of it (until we have 30)
+	peer.push_blocks(2, false);
+
+	// Fork before revert point
+
+	// add more blocks on top of block 23 (until we have 26)
+	let hash = peer
+		.generate_blocks_at(
+			BlockId::Number(23),
+			3,
+			BlockOrigin::File,
+			|mut builder| {
+				builder.push_deposit_log_digest_item(DigestItem::Other(vec![1])).unwrap();
+				builder.build().unwrap().block
+			},
+			false,
+			false,
+			true,
+			ForkChoiceStrategy::LongestChain,
+		)
+		.pop()
+		.unwrap();
+	// at block 27 of the fork add an authority transition
+	peer.generate_blocks_at(
+		BlockId::Hash(hash),
+		1,
+		BlockOrigin::File,
+		edit_block,
+		false,
+		false,
+		true,
+		ForkChoiceStrategy::LongestChain,
+	);
+
+	// Fork after revert point
+
+	// add more block on top of block 25 (until we have 28)
+	let hash = peer
+		.generate_blocks_at(
+			BlockId::Number(25),
+			3,
+			BlockOrigin::File,
+			|mut builder| {
+				builder.push_deposit_log_digest_item(DigestItem::Other(vec![2])).unwrap();
+				builder.build().unwrap().block
+			},
+			false,
+			false,
+			true,
+			ForkChoiceStrategy::LongestChain,
+		)
+		.pop()
+		.unwrap();
+	// at block 29 of the fork add an authority transition
+	peer.generate_blocks_at(
+		BlockId::Hash(hash),
+		1,
+		BlockOrigin::File,
+		edit_block,
+		false,
+		false,
+		true,
+		ForkChoiceStrategy::LongestChain,
+	);
+
+	revert(client.clone(), 6).unwrap();
+
+	let persistent_data: PersistentData<Block> = aux_schema::load_persistent(
+		&*client,
+		client.info().genesis_hash,
+		Zero::zero(),
+		|| unreachable!(),
+	)
+	.unwrap();
+	let changes_num: Vec<_> = persistent_data
+		.authority_set
+		.inner()
+		.pending_standard_changes
+		.iter()
+		.map(|(_, n, _)| *n)
+		.collect();
+	assert_eq!(changes_num, [21, 27]);
+}
diff --git a/substrate/client/consensus/grandpa/src/until_imported.rs b/substrate/client/consensus/grandpa/src/until_imported.rs
new file mode 100644
index 0000000000000000000000000000000000000000..14f32ecc883662d9d690b75611657cef0aa797e6
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/until_imported.rs
@@ -0,0 +1,1041 @@
+// 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/>.
+
+//! Helper stream for waiting until one or more blocks are imported before
+//! passing through inner items. This is done in a generic way to support
+//! many different kinds of items.
+//!
+//! This is used for votes and commit messages currently.
+
+use super::{
+	BlockStatus as BlockStatusT, BlockSyncRequester as BlockSyncRequesterT, CommunicationIn, Error,
+	SignedMessage, LOG_TARGET,
+};
+
+use finality_grandpa::voter;
+use futures::{
+	prelude::*,
+	stream::{Fuse, StreamExt},
+};
+use futures_timer::Delay;
+use log::{debug, warn};
+use parking_lot::Mutex;
+use prometheus_endpoint::{register, Gauge, PrometheusError, Registry, U64};
+use sc_client_api::{BlockImportNotification, ImportNotifications};
+use sc_utils::mpsc::TracingUnboundedReceiver;
+use sp_consensus_grandpa::AuthorityId;
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
+
+use std::{
+	collections::{HashMap, VecDeque},
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+	time::{Duration, Instant},
+};
+
+const LOG_PENDING_INTERVAL: Duration = Duration::from_secs(15);
+
+/// Something that needs to be withheld until specific blocks are available.
+///
+/// For example a GRANDPA commit message which is not of any use without the corresponding block
+/// that it commits on.
+pub(crate) trait BlockUntilImported<Block: BlockT>: Sized {
+	/// The type that is blocked on.
+	type Blocked;
+
+	/// Check if a new incoming item needs awaiting until a block(s) is imported.
+	fn needs_waiting<S: BlockStatusT<Block>>(
+		input: Self::Blocked,
+		status_check: &S,
+	) -> Result<DiscardWaitOrReady<Block, Self, Self::Blocked>, Error>;
+
+	/// called when the wait has completed. The canonical number is passed through
+	/// for further checks.
+	fn wait_completed(self, canon_number: NumberFor<Block>) -> Option<Self::Blocked>;
+}
+
+/// Describes whether a given [`BlockUntilImported`] (a) should be discarded, (b) is waiting for
+/// specific blocks to be imported or (c) is ready to be used.
+///
+/// A reason for discarding a [`BlockUntilImported`] would be if a referenced block is perceived
+/// under a different number than specified in the message.
+pub(crate) enum DiscardWaitOrReady<Block: BlockT, W, R> {
+	Discard,
+	Wait(Vec<(Block::Hash, NumberFor<Block>, W)>),
+	Ready(R),
+}
+
+/// Prometheus metrics for the `UntilImported` queue.
+// At a given point in time there can be more than one `UntilImported` queue. One can not register a
+// metric twice, thus queues need to share the same Prometheus metrics instead of instantiating
+// their own ones.
+//
+// When a queue is dropped it might still contain messages. In order for those to not distort the
+// Prometheus metrics, the `Metric` struct cleans up after itself within its `Drop` implementation
+// by subtracting the local_waiting_messages (the amount of messages left in the queue about to
+// be dropped) from the global_waiting_messages gauge.
+pub(crate) struct Metrics {
+	global_waiting_messages: Gauge<U64>,
+	local_waiting_messages: u64,
+}
+
+impl Metrics {
+	pub(crate) fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			global_waiting_messages: register(
+				Gauge::new(
+					"substrate_finality_grandpa_until_imported_waiting_messages_number",
+					"Number of finality grandpa messages waiting within the until imported queue.",
+				)?,
+				registry,
+			)?,
+			local_waiting_messages: 0,
+		})
+	}
+
+	fn waiting_messages_inc(&mut self) {
+		self.local_waiting_messages += 1;
+		self.global_waiting_messages.inc();
+	}
+
+	fn waiting_messages_dec(&mut self) {
+		self.local_waiting_messages -= 1;
+		self.global_waiting_messages.dec();
+	}
+}
+
+impl Clone for Metrics {
+	fn clone(&self) -> Self {
+		Metrics {
+			global_waiting_messages: self.global_waiting_messages.clone(),
+			// When cloned, reset local_waiting_messages, so the global counter is not reduced a
+			// second time for the same messages on `drop` of the clone.
+			local_waiting_messages: 0,
+		}
+	}
+}
+
+impl Drop for Metrics {
+	fn drop(&mut self) {
+		// Reduce the global counter by the amount of messages that were still left in the dropped
+		// queue.
+		self.global_waiting_messages.sub(self.local_waiting_messages)
+	}
+}
+
+/// Buffering incoming messages until blocks with given hashes are imported.
+pub(crate) struct UntilImported<Block, BlockStatus, BlockSyncRequester, I, M>
+where
+	Block: BlockT,
+	I: Stream<Item = M::Blocked> + Unpin,
+	M: BlockUntilImported<Block>,
+{
+	import_notifications: Fuse<TracingUnboundedReceiver<BlockImportNotification<Block>>>,
+	block_sync_requester: BlockSyncRequester,
+	status_check: BlockStatus,
+	incoming_messages: Fuse<I>,
+	ready: VecDeque<M::Blocked>,
+	/// Interval at which to check status of each awaited block.
+	check_pending: Pin<Box<dyn Stream<Item = Result<(), std::io::Error>> + Send>>,
+	/// Mapping block hashes to their block number, the point in time it was
+	/// first encountered (Instant) and a list of GRANDPA messages referencing
+	/// the block hash.
+	pending: HashMap<Block::Hash, (NumberFor<Block>, Instant, Vec<M>)>,
+
+	/// Queue identifier for differentiation in logs.
+	identifier: &'static str,
+	/// Prometheus metrics.
+	metrics: Option<Metrics>,
+}
+
+impl<Block, BlockStatus, BlockSyncRequester, I, M> Unpin
+	for UntilImported<Block, BlockStatus, BlockSyncRequester, I, M>
+where
+	Block: BlockT,
+	I: Stream<Item = M::Blocked> + Unpin,
+	M: BlockUntilImported<Block>,
+{
+}
+
+impl<Block, BlockStatus, BlockSyncRequester, I, M>
+	UntilImported<Block, BlockStatus, BlockSyncRequester, I, M>
+where
+	Block: BlockT,
+	BlockStatus: BlockStatusT<Block>,
+	BlockSyncRequester: BlockSyncRequesterT<Block>,
+	I: Stream<Item = M::Blocked> + Unpin,
+	M: BlockUntilImported<Block>,
+{
+	/// Create a new `UntilImported` wrapper.
+	pub(crate) fn new(
+		import_notifications: ImportNotifications<Block>,
+		block_sync_requester: BlockSyncRequester,
+		status_check: BlockStatus,
+		incoming_messages: I,
+		identifier: &'static str,
+		metrics: Option<Metrics>,
+	) -> Self {
+		// how often to check if pending messages that are waiting for blocks to be
+		// imported can be checked.
+		//
+		// the import notifications interval takes care of most of this; this is
+		// used in the event of missed import notifications
+		const CHECK_PENDING_INTERVAL: Duration = Duration::from_secs(5);
+
+		let check_pending = futures::stream::unfold(Delay::new(CHECK_PENDING_INTERVAL), |delay| {
+			Box::pin(async move {
+				delay.await;
+				Some((Ok(()), Delay::new(CHECK_PENDING_INTERVAL)))
+			})
+		});
+
+		UntilImported {
+			import_notifications: import_notifications.fuse(),
+			block_sync_requester,
+			status_check,
+			incoming_messages: incoming_messages.fuse(),
+			ready: VecDeque::new(),
+			check_pending: Box::pin(check_pending),
+			pending: HashMap::new(),
+			identifier,
+			metrics,
+		}
+	}
+}
+
+impl<Block, BStatus, BSyncRequester, I, M> Stream
+	for UntilImported<Block, BStatus, BSyncRequester, I, M>
+where
+	Block: BlockT,
+	BStatus: BlockStatusT<Block>,
+	BSyncRequester: BlockSyncRequesterT<Block>,
+	I: Stream<Item = M::Blocked> + Unpin,
+	M: BlockUntilImported<Block>,
+{
+	type Item = Result<M::Blocked, Error>;
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		// We are using a `this` variable in order to allow multiple simultaneous mutable borrow to
+		// `self`.
+		let this = &mut *self;
+
+		loop {
+			match StreamExt::poll_next_unpin(&mut this.incoming_messages, cx) {
+				Poll::Ready(None) => return Poll::Ready(None),
+				Poll::Ready(Some(input)) => {
+					// new input: schedule wait of any parts which require
+					// blocks to be known.
+					match M::needs_waiting(input, &this.status_check)? {
+						DiscardWaitOrReady::Discard => {},
+						DiscardWaitOrReady::Wait(items) => {
+							for (target_hash, target_number, wait) in items {
+								this.pending
+									.entry(target_hash)
+									.or_insert_with(|| (target_number, Instant::now(), Vec::new()))
+									.2
+									.push(wait)
+							}
+						},
+						DiscardWaitOrReady::Ready(item) => this.ready.push_back(item),
+					}
+
+					if let Some(metrics) = &mut this.metrics {
+						metrics.waiting_messages_inc();
+					}
+				},
+				Poll::Pending => break,
+			}
+		}
+
+		loop {
+			match StreamExt::poll_next_unpin(&mut this.import_notifications, cx) {
+				Poll::Ready(None) => return Poll::Ready(None),
+				Poll::Ready(Some(notification)) => {
+					// new block imported. queue up all messages tied to that hash.
+					if let Some((_, _, messages)) = this.pending.remove(&notification.hash) {
+						let canon_number = *notification.header.number();
+						let ready_messages =
+							messages.into_iter().filter_map(|m| m.wait_completed(canon_number));
+
+						this.ready.extend(ready_messages);
+					}
+				},
+				Poll::Pending => break,
+			}
+		}
+
+		let mut update_interval = false;
+		while let Poll::Ready(Some(Ok(()))) = this.check_pending.poll_next_unpin(cx) {
+			update_interval = true;
+		}
+
+		if update_interval {
+			let mut known_keys = Vec::new();
+			for (&block_hash, &mut (block_number, ref mut last_log, ref v)) in
+				this.pending.iter_mut()
+			{
+				if let Some(number) = this.status_check.block_number(block_hash)? {
+					known_keys.push((block_hash, number));
+				} else {
+					let next_log = *last_log + LOG_PENDING_INTERVAL;
+					if Instant::now() >= next_log {
+						debug!(
+							target: LOG_TARGET,
+							"Waiting to import block {} before {} {} messages can be imported. \
+							Requesting network sync service to retrieve block from. \
+							Possible fork?",
+							block_hash,
+							v.len(),
+							this.identifier,
+						);
+
+						// NOTE: when sending an empty vec of peers the
+						// underlying should make a best effort to sync the
+						// block from any peers it knows about.
+						this.block_sync_requester.set_sync_fork_request(
+							vec![],
+							block_hash,
+							block_number,
+						);
+
+						*last_log = next_log;
+					}
+				}
+			}
+
+			for (known_hash, canon_number) in known_keys {
+				if let Some((_, _, pending_messages)) = this.pending.remove(&known_hash) {
+					let ready_messages =
+						pending_messages.into_iter().filter_map(|m| m.wait_completed(canon_number));
+
+					this.ready.extend(ready_messages);
+				}
+			}
+		}
+
+		if let Some(ready) = this.ready.pop_front() {
+			if let Some(metrics) = &mut this.metrics {
+				metrics.waiting_messages_dec();
+			}
+			return Poll::Ready(Some(Ok(ready)))
+		}
+
+		if this.import_notifications.is_done() && this.incoming_messages.is_done() {
+			Poll::Ready(None)
+		} else {
+			Poll::Pending
+		}
+	}
+}
+
+fn warn_authority_wrong_target<H: ::std::fmt::Display>(hash: H, id: AuthorityId) {
+	warn!(
+		target: LOG_TARGET,
+		"Authority {:?} signed GRANDPA message with \
+		wrong block number for hash {}",
+		id,
+		hash,
+	);
+}
+
+impl<Block: BlockT> BlockUntilImported<Block> for SignedMessage<Block::Header> {
+	type Blocked = Self;
+
+	fn needs_waiting<BlockStatus: BlockStatusT<Block>>(
+		msg: Self::Blocked,
+		status_check: &BlockStatus,
+	) -> Result<DiscardWaitOrReady<Block, Self, Self::Blocked>, Error> {
+		let (&target_hash, target_number) = msg.target();
+
+		if let Some(number) = status_check.block_number(target_hash)? {
+			if number != target_number {
+				warn_authority_wrong_target(target_hash, msg.id);
+				return Ok(DiscardWaitOrReady::Discard)
+			} else {
+				return Ok(DiscardWaitOrReady::Ready(msg))
+			}
+		}
+
+		Ok(DiscardWaitOrReady::Wait(vec![(target_hash, target_number, msg)]))
+	}
+
+	fn wait_completed(self, canon_number: NumberFor<Block>) -> Option<Self::Blocked> {
+		let (&target_hash, target_number) = self.target();
+		if canon_number != target_number {
+			warn_authority_wrong_target(target_hash, self.id);
+
+			None
+		} else {
+			Some(self)
+		}
+	}
+}
+
+/// Helper type definition for the stream which waits until vote targets for
+/// signed messages are imported.
+pub(crate) type UntilVoteTargetImported<Block, BlockStatus, BlockSyncRequester, I> = UntilImported<
+	Block,
+	BlockStatus,
+	BlockSyncRequester,
+	I,
+	SignedMessage<<Block as BlockT>::Header>,
+>;
+
+/// This blocks a global message import, i.e. a commit or catch up messages,
+/// until all blocks referenced in its votes are known.
+///
+/// This is used for compact commits and catch up messages which have already
+/// been checked for structural soundness (e.g. valid signatures).
+///
+/// We use the `Arc`'s reference count to implicitly count the number of outstanding blocks that we
+/// are waiting on for the same message (i.e. other `BlockGlobalMessage` instances with the same
+/// `inner`).
+pub(crate) struct BlockGlobalMessage<Block: BlockT> {
+	inner: Arc<Mutex<Option<CommunicationIn<Block>>>>,
+	target_number: NumberFor<Block>,
+}
+
+impl<Block: BlockT> Unpin for BlockGlobalMessage<Block> {}
+
+impl<Block: BlockT> BlockUntilImported<Block> for BlockGlobalMessage<Block> {
+	type Blocked = CommunicationIn<Block>;
+
+	fn needs_waiting<BlockStatus: BlockStatusT<Block>>(
+		input: Self::Blocked,
+		status_check: &BlockStatus,
+	) -> Result<DiscardWaitOrReady<Block, Self, Self::Blocked>, Error> {
+		use std::collections::hash_map::Entry;
+
+		enum KnownOrUnknown<N> {
+			Known(N),
+			Unknown(N),
+		}
+
+		impl<N> KnownOrUnknown<N> {
+			fn number(&self) -> &N {
+				match *self {
+					KnownOrUnknown::Known(ref n) => n,
+					KnownOrUnknown::Unknown(ref n) => n,
+				}
+			}
+		}
+
+		let mut checked_hashes: HashMap<_, KnownOrUnknown<NumberFor<Block>>> = HashMap::new();
+
+		{
+			// returns false when should early exit.
+			let mut query_known = |target_hash, perceived_number| -> Result<bool, Error> {
+				// check integrity: all votes for same hash have same number.
+				let canon_number = match checked_hashes.entry(target_hash) {
+					Entry::Occupied(entry) => *entry.get().number(),
+					Entry::Vacant(entry) => {
+						if let Some(number) = status_check.block_number(target_hash)? {
+							entry.insert(KnownOrUnknown::Known(number));
+							number
+						} else {
+							entry.insert(KnownOrUnknown::Unknown(perceived_number));
+							perceived_number
+						}
+					},
+				};
+
+				if canon_number != perceived_number {
+					// invalid global message: messages targeting wrong number
+					// or at least different from other vote in same global
+					// message.
+					return Ok(false)
+				}
+
+				Ok(true)
+			};
+
+			match input {
+				voter::CommunicationIn::Commit(_, ref commit, ..) => {
+					// add known hashes from all precommits.
+					let precommit_targets =
+						commit.precommits.iter().map(|c| (c.target_number, c.target_hash));
+
+					for (target_number, target_hash) in precommit_targets {
+						if !query_known(target_hash, target_number)? {
+							return Ok(DiscardWaitOrReady::Discard)
+						}
+					}
+				},
+				voter::CommunicationIn::CatchUp(ref catch_up, ..) => {
+					// add known hashes from all prevotes and precommits.
+					let prevote_targets = catch_up
+						.prevotes
+						.iter()
+						.map(|s| (s.prevote.target_number, s.prevote.target_hash));
+
+					let precommit_targets = catch_up
+						.precommits
+						.iter()
+						.map(|s| (s.precommit.target_number, s.precommit.target_hash));
+
+					let targets = prevote_targets.chain(precommit_targets);
+
+					for (target_number, target_hash) in targets {
+						if !query_known(target_hash, target_number)? {
+							return Ok(DiscardWaitOrReady::Discard)
+						}
+					}
+				},
+			};
+		}
+
+		let unknown_hashes = checked_hashes
+			.into_iter()
+			.filter_map(|(hash, num)| match num {
+				KnownOrUnknown::Unknown(number) => Some((hash, number)),
+				KnownOrUnknown::Known(_) => None,
+			})
+			.collect::<Vec<_>>();
+
+		if unknown_hashes.is_empty() {
+			// none of the hashes in the global message were unknown.
+			// we can just return the message directly.
+			return Ok(DiscardWaitOrReady::Ready(input))
+		}
+
+		let locked_global = Arc::new(Mutex::new(Some(input)));
+
+		let items_to_await = unknown_hashes
+			.into_iter()
+			.map(|(hash, target_number)| {
+				(
+					hash,
+					target_number,
+					BlockGlobalMessage { inner: locked_global.clone(), target_number },
+				)
+			})
+			.collect();
+
+		// schedule waits for all unknown messages.
+		// when the last one of these has `wait_completed` called on it,
+		// the global message will be returned.
+		Ok(DiscardWaitOrReady::Wait(items_to_await))
+	}
+
+	fn wait_completed(self, canon_number: NumberFor<Block>) -> Option<Self::Blocked> {
+		if self.target_number != canon_number {
+			// Delete the inner message so it won't ever be forwarded. Future calls to
+			// `wait_completed` on the same `inner` will ignore it.
+			*self.inner.lock() = None;
+			return None
+		}
+
+		match Arc::try_unwrap(self.inner) {
+			// This is the last reference and thus the last outstanding block to be awaited. `inner`
+			// is either `Some(_)` or `None`. The latter implies that a previous `wait_completed`
+			// call witnessed a block number mismatch (see above).
+			Ok(inner) => Mutex::into_inner(inner),
+			// There are still other strong references to this `Arc`, thus the message is blocked on
+			// other blocks to be imported.
+			Err(_) => None,
+		}
+	}
+}
+
+/// A stream which gates off incoming global messages, i.e. commit and catch up
+/// messages, until all referenced block hashes have been imported.
+pub(crate) type UntilGlobalMessageBlocksImported<Block, BlockStatus, BlockSyncRequester, I> =
+	UntilImported<Block, BlockStatus, BlockSyncRequester, I, BlockGlobalMessage<Block>>;
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{CatchUp, CompactCommit};
+	use finality_grandpa::Precommit;
+	use futures::future::Either;
+	use futures_timer::Delay;
+	use sc_client_api::BlockImportNotification;
+	use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
+	use sp_consensus::BlockOrigin;
+	use sp_core::crypto::UncheckedFrom;
+	use substrate_test_runtime_client::runtime::{Block, Hash, Header};
+
+	#[derive(Clone)]
+	struct TestChainState {
+		sender: TracingUnboundedSender<BlockImportNotification<Block>>,
+		known_blocks: Arc<Mutex<HashMap<Hash, u64>>>,
+	}
+
+	impl TestChainState {
+		fn new() -> (Self, ImportNotifications<Block>) {
+			let (tx, rx) = tracing_unbounded("test", 100_000);
+			let state =
+				TestChainState { sender: tx, known_blocks: Arc::new(Mutex::new(HashMap::new())) };
+
+			(state, rx)
+		}
+
+		fn block_status(&self) -> TestBlockStatus {
+			TestBlockStatus { inner: self.known_blocks.clone() }
+		}
+
+		fn import_header(&self, header: Header) {
+			let hash = header.hash();
+			let number = *header.number();
+			let (tx, _rx) = tracing_unbounded("unpin-worker-channel", 10_000);
+			self.known_blocks.lock().insert(hash, number);
+			self.sender
+				.unbounded_send(BlockImportNotification::<Block>::new(
+					hash,
+					BlockOrigin::File,
+					header,
+					false,
+					None,
+					tx,
+				))
+				.unwrap();
+		}
+	}
+
+	struct TestBlockStatus {
+		inner: Arc<Mutex<HashMap<Hash, u64>>>,
+	}
+
+	impl BlockStatusT<Block> for TestBlockStatus {
+		fn block_number(&self, hash: Hash) -> Result<Option<u64>, Error> {
+			Ok(self.inner.lock().get(&hash).map(|x| *x))
+		}
+	}
+
+	#[derive(Clone)]
+	struct TestBlockSyncRequester {
+		requests: Arc<Mutex<Vec<(Hash, NumberFor<Block>)>>>,
+	}
+
+	impl Default for TestBlockSyncRequester {
+		fn default() -> Self {
+			TestBlockSyncRequester { requests: Arc::new(Mutex::new(Vec::new())) }
+		}
+	}
+
+	impl BlockSyncRequesterT<Block> for TestBlockSyncRequester {
+		fn set_sync_fork_request(
+			&self,
+			_peers: Vec<sc_network::PeerId>,
+			hash: Hash,
+			number: NumberFor<Block>,
+		) {
+			self.requests.lock().push((hash, number));
+		}
+	}
+
+	fn make_header(number: u64) -> Header {
+		Header::new(
+			number,
+			Default::default(),
+			Default::default(),
+			Default::default(),
+			Default::default(),
+		)
+	}
+
+	// unwrap the commit from `CommunicationIn` returning its fields in a tuple,
+	// panics if the given message isn't a commit
+	fn unapply_commit(msg: CommunicationIn<Block>) -> (u64, CompactCommit<Header>) {
+		match msg {
+			voter::CommunicationIn::Commit(round, commit, ..) => (round, commit),
+			_ => panic!("expected commit"),
+		}
+	}
+
+	// unwrap the catch up from `CommunicationIn` returning its inner representation,
+	// panics if the given message isn't a catch up
+	fn unapply_catch_up(msg: CommunicationIn<Block>) -> CatchUp<Header> {
+		match msg {
+			voter::CommunicationIn::CatchUp(catch_up, ..) => catch_up,
+			_ => panic!("expected catch up"),
+		}
+	}
+
+	fn message_all_dependencies_satisfied<F>(
+		msg: CommunicationIn<Block>,
+		enact_dependencies: F,
+	) -> CommunicationIn<Block>
+	where
+		F: FnOnce(&TestChainState),
+	{
+		let (chain_state, import_notifications) = TestChainState::new();
+		let block_status = chain_state.block_status();
+
+		// enact all dependencies before importing the message
+		enact_dependencies(&chain_state);
+
+		let (global_tx, global_rx) = tracing_unbounded("test", 100_000);
+
+		let until_imported = UntilGlobalMessageBlocksImported::new(
+			import_notifications,
+			TestBlockSyncRequester::default(),
+			block_status,
+			global_rx,
+			"global",
+			None,
+		);
+
+		global_tx.unbounded_send(msg).unwrap();
+
+		let work = until_imported.into_future();
+
+		futures::executor::block_on(work).0.unwrap().unwrap()
+	}
+
+	fn blocking_message_on_dependencies<F>(
+		msg: CommunicationIn<Block>,
+		enact_dependencies: F,
+	) -> CommunicationIn<Block>
+	where
+		F: FnOnce(&TestChainState),
+	{
+		let (chain_state, import_notifications) = TestChainState::new();
+		let block_status = chain_state.block_status();
+
+		let (global_tx, global_rx) = tracing_unbounded("test", 100_000);
+
+		let until_imported = UntilGlobalMessageBlocksImported::new(
+			import_notifications,
+			TestBlockSyncRequester::default(),
+			block_status,
+			global_rx,
+			"global",
+			None,
+		);
+
+		global_tx.unbounded_send(msg).unwrap();
+
+		// NOTE: needs to be cloned otherwise it is moved to the stream and
+		// dropped too early.
+		let inner_chain_state = chain_state.clone();
+		let work =
+			future::select(until_imported.into_future(), Delay::new(Duration::from_millis(100)))
+				.then(move |res| match res {
+					Either::Left(_) => panic!("timeout should have fired first"),
+					Either::Right((_, until_imported)) => {
+						// timeout fired. push in the headers.
+						enact_dependencies(&inner_chain_state);
+
+						until_imported
+					},
+				});
+
+		futures::executor::block_on(work).0.unwrap().unwrap()
+	}
+
+	#[test]
+	fn blocking_commit_message() {
+		let h1 = make_header(5);
+		let h2 = make_header(6);
+		let h3 = make_header(7);
+
+		let unknown_commit = CompactCommit::<Header> {
+			target_hash: h1.hash(),
+			target_number: 5,
+			precommits: vec![
+				Precommit { target_hash: h2.hash(), target_number: 6 },
+				Precommit { target_hash: h3.hash(), target_number: 7 },
+			],
+			auth_data: Vec::new(), // not used
+		};
+
+		let unknown_commit =
+			|| voter::CommunicationIn::Commit(0, unknown_commit.clone(), voter::Callback::Blank);
+
+		let res = blocking_message_on_dependencies(unknown_commit(), |chain_state| {
+			chain_state.import_header(h1);
+			chain_state.import_header(h2);
+			chain_state.import_header(h3);
+		});
+
+		assert_eq!(unapply_commit(res), unapply_commit(unknown_commit()));
+	}
+
+	#[test]
+	fn commit_message_all_known() {
+		let h1 = make_header(5);
+		let h2 = make_header(6);
+		let h3 = make_header(7);
+
+		let known_commit = CompactCommit::<Header> {
+			target_hash: h1.hash(),
+			target_number: 5,
+			precommits: vec![
+				Precommit { target_hash: h2.hash(), target_number: 6 },
+				Precommit { target_hash: h3.hash(), target_number: 7 },
+			],
+			auth_data: Vec::new(), // not used
+		};
+
+		let known_commit =
+			|| voter::CommunicationIn::Commit(0, known_commit.clone(), voter::Callback::Blank);
+
+		let res = message_all_dependencies_satisfied(known_commit(), |chain_state| {
+			chain_state.import_header(h1);
+			chain_state.import_header(h2);
+			chain_state.import_header(h3);
+		});
+
+		assert_eq!(unapply_commit(res), unapply_commit(known_commit()));
+	}
+
+	#[test]
+	fn blocking_catch_up_message() {
+		let h1 = make_header(5);
+		let h2 = make_header(6);
+		let h3 = make_header(7);
+
+		let signed_prevote = |header: &Header| finality_grandpa::SignedPrevote {
+			id: UncheckedFrom::unchecked_from([1; 32]),
+			signature: UncheckedFrom::unchecked_from([1; 64]),
+			prevote: finality_grandpa::Prevote {
+				target_hash: header.hash(),
+				target_number: *header.number(),
+			},
+		};
+
+		let signed_precommit = |header: &Header| finality_grandpa::SignedPrecommit {
+			id: UncheckedFrom::unchecked_from([1; 32]),
+			signature: UncheckedFrom::unchecked_from([1; 64]),
+			precommit: finality_grandpa::Precommit {
+				target_hash: header.hash(),
+				target_number: *header.number(),
+			},
+		};
+
+		let prevotes = vec![signed_prevote(&h1), signed_prevote(&h3)];
+
+		let precommits = vec![signed_precommit(&h1), signed_precommit(&h2)];
+
+		let unknown_catch_up = finality_grandpa::CatchUp {
+			round_number: 1,
+			prevotes,
+			precommits,
+			base_hash: h1.hash(),
+			base_number: *h1.number(),
+		};
+
+		let unknown_catch_up =
+			|| voter::CommunicationIn::CatchUp(unknown_catch_up.clone(), voter::Callback::Blank);
+
+		let res = blocking_message_on_dependencies(unknown_catch_up(), |chain_state| {
+			chain_state.import_header(h1);
+			chain_state.import_header(h2);
+			chain_state.import_header(h3);
+		});
+
+		assert_eq!(unapply_catch_up(res), unapply_catch_up(unknown_catch_up()));
+	}
+
+	#[test]
+	fn catch_up_message_all_known() {
+		let h1 = make_header(5);
+		let h2 = make_header(6);
+		let h3 = make_header(7);
+
+		let signed_prevote = |header: &Header| finality_grandpa::SignedPrevote {
+			id: UncheckedFrom::unchecked_from([1; 32]),
+			signature: UncheckedFrom::unchecked_from([1; 64]),
+			prevote: finality_grandpa::Prevote {
+				target_hash: header.hash(),
+				target_number: *header.number(),
+			},
+		};
+
+		let signed_precommit = |header: &Header| finality_grandpa::SignedPrecommit {
+			id: UncheckedFrom::unchecked_from([1; 32]),
+			signature: UncheckedFrom::unchecked_from([1; 64]),
+			precommit: finality_grandpa::Precommit {
+				target_hash: header.hash(),
+				target_number: *header.number(),
+			},
+		};
+
+		let prevotes = vec![signed_prevote(&h1), signed_prevote(&h3)];
+
+		let precommits = vec![signed_precommit(&h1), signed_precommit(&h2)];
+
+		let unknown_catch_up = finality_grandpa::CatchUp {
+			round_number: 1,
+			prevotes,
+			precommits,
+			base_hash: h1.hash(),
+			base_number: *h1.number(),
+		};
+
+		let unknown_catch_up =
+			|| voter::CommunicationIn::CatchUp(unknown_catch_up.clone(), voter::Callback::Blank);
+
+		let res = message_all_dependencies_satisfied(unknown_catch_up(), |chain_state| {
+			chain_state.import_header(h1);
+			chain_state.import_header(h2);
+			chain_state.import_header(h3);
+		});
+
+		assert_eq!(unapply_catch_up(res), unapply_catch_up(unknown_catch_up()));
+	}
+
+	#[test]
+	fn request_block_sync_for_needed_blocks() {
+		let (chain_state, import_notifications) = TestChainState::new();
+		let block_status = chain_state.block_status();
+
+		let (global_tx, global_rx) = tracing_unbounded("test", 100_000);
+
+		let block_sync_requester = TestBlockSyncRequester::default();
+
+		let until_imported = UntilGlobalMessageBlocksImported::new(
+			import_notifications,
+			block_sync_requester.clone(),
+			block_status,
+			global_rx,
+			"global",
+			None,
+		);
+
+		let h1 = make_header(5);
+		let h2 = make_header(6);
+		let h3 = make_header(7);
+
+		// we create a commit message, with precommits for blocks 6 and 7 which
+		// we haven't imported.
+		let unknown_commit = CompactCommit::<Header> {
+			target_hash: h1.hash(),
+			target_number: 5,
+			precommits: vec![
+				Precommit { target_hash: h2.hash(), target_number: 6 },
+				Precommit { target_hash: h3.hash(), target_number: 7 },
+			],
+			auth_data: Vec::new(), // not used
+		};
+
+		let unknown_commit =
+			|| voter::CommunicationIn::Commit(0, unknown_commit.clone(), voter::Callback::Blank);
+
+		// we send the commit message and spawn the until_imported stream
+		global_tx.unbounded_send(unknown_commit()).unwrap();
+
+		let threads_pool = futures::executor::ThreadPool::new().unwrap();
+		threads_pool.spawn_ok(until_imported.into_future().map(|_| ()));
+
+		// assert that we will make sync requests
+		let assert = futures::future::poll_fn(|ctx| {
+			let block_sync_requests = block_sync_requester.requests.lock();
+
+			// we request blocks targeted by the precommits that aren't imported
+			if block_sync_requests.contains(&(h2.hash(), *h2.number())) &&
+				block_sync_requests.contains(&(h3.hash(), *h3.number()))
+			{
+				return Poll::Ready(())
+			}
+
+			// NOTE: nothing in this function is future-aware (i.e nothing gets registered to wake
+			// up this future), we manually wake up this task to avoid having to wait until the
+			// timeout below triggers.
+			ctx.waker().wake_by_ref();
+
+			Poll::Pending
+		});
+
+		// the `until_imported` stream doesn't request the blocks immediately,
+		// but it should request them after a small timeout
+		let timeout = Delay::new(Duration::from_secs(60));
+		let test = future::select(assert, timeout)
+			.map(|res| match res {
+				Either::Left(_) => {},
+				Either::Right(_) => panic!("timed out waiting for block sync request"),
+			})
+			.map(drop);
+
+		futures::executor::block_on(test);
+	}
+
+	fn test_catch_up() -> Arc<Mutex<Option<CommunicationIn<Block>>>> {
+		let header = make_header(5);
+
+		let unknown_catch_up = finality_grandpa::CatchUp {
+			round_number: 1,
+			precommits: vec![],
+			prevotes: vec![],
+			base_hash: header.hash(),
+			base_number: *header.number(),
+		};
+
+		let catch_up =
+			voter::CommunicationIn::CatchUp(unknown_catch_up.clone(), voter::Callback::Blank);
+
+		Arc::new(Mutex::new(Some(catch_up)))
+	}
+
+	#[test]
+	fn block_global_message_wait_completed_return_when_all_awaited() {
+		let msg_inner = test_catch_up();
+
+		let waiting_block_1 =
+			BlockGlobalMessage::<Block> { inner: msg_inner.clone(), target_number: 1 };
+
+		let waiting_block_2 = BlockGlobalMessage::<Block> { inner: msg_inner, target_number: 2 };
+
+		// waiting_block_2 is still waiting for block 2, thus this should return `None`.
+		assert!(waiting_block_1.wait_completed(1).is_none());
+
+		// Message only depended on block 1 and 2. Both have been imported, thus this should yield
+		// the message.
+		assert!(waiting_block_2.wait_completed(2).is_some());
+	}
+
+	#[test]
+	fn block_global_message_wait_completed_return_none_on_block_number_missmatch() {
+		let msg_inner = test_catch_up();
+
+		let waiting_block_1 =
+			BlockGlobalMessage::<Block> { inner: msg_inner.clone(), target_number: 1 };
+
+		let waiting_block_2 = BlockGlobalMessage::<Block> { inner: msg_inner, target_number: 2 };
+
+		// Calling wait_completed with wrong block number should yield None.
+		assert!(waiting_block_1.wait_completed(1234).is_none());
+
+		// All blocks, that the message depended on, have been imported. Still, given the above
+		// block number mismatch this should return None.
+		assert!(waiting_block_2.wait_completed(2).is_none());
+	}
+
+	#[test]
+	fn metrics_cleans_up_after_itself() {
+		let r = Registry::new();
+
+		let mut m1 = Metrics::register(&r).unwrap();
+		let m2 = m1.clone();
+
+		// Add a new message to the 'queue' of m1.
+		m1.waiting_messages_inc();
+
+		// m1 and m2 are synced through the shared atomic.
+		assert_eq!(1, m2.global_waiting_messages.get());
+
+		// Drop 'queue' m1.
+		drop(m1);
+
+		// Make sure m1 cleaned up after itself, removing all messages that were left in its queue
+		// when dropped from the global metric.
+		assert_eq!(0, m2.global_waiting_messages.get());
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/voting_rule.rs b/substrate/client/consensus/grandpa/src/voting_rule.rs
new file mode 100644
index 0000000000000000000000000000000000000000..27a91d54783705e1ff2beeac72bfa1621062a04e
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/voting_rule.rs
@@ -0,0 +1,440 @@
+// 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/>.
+
+//! Handling custom voting rules for GRANDPA.
+//!
+//! This exposes the `VotingRule` trait used to implement arbitrary voting
+//! restrictions that are taken into account by the GRANDPA environment when
+//! selecting a finality target to vote on.
+
+use std::{future::Future, pin::Pin, sync::Arc};
+
+use dyn_clone::DynClone;
+
+use sc_client_api::blockchain::HeaderBackend;
+use sp_runtime::traits::{Block as BlockT, Header, NumberFor, One, Zero};
+
+/// A future returned by a `VotingRule` to restrict a given vote, if any restriction is necessary.
+pub type VotingRuleResult<Block> =
+	Pin<Box<dyn Future<Output = Option<(<Block as BlockT>::Hash, NumberFor<Block>)>> + Send>>;
+
+/// A trait for custom voting rules in GRANDPA.
+pub trait VotingRule<Block, B>: DynClone + Send + Sync
+where
+	Block: BlockT,
+	B: HeaderBackend<Block>,
+{
+	/// Restrict the given `current_target` vote, returning the block hash and
+	/// number of the block to vote on, and `None` in case the vote should not
+	/// be restricted. `base` is the block that we're basing our votes on in
+	/// order to pick our target (e.g. last round estimate), and `best_target`
+	/// is the initial best vote target before any vote rules were applied. When
+	/// applying multiple `VotingRule`s both `base` and `best_target` should
+	/// remain unchanged.
+	///
+	/// The contract of this interface requires that when restricting a vote, the
+	/// returned value **must** be an ancestor of the given `current_target`,
+	/// this also means that a variant must be maintained throughout the
+	/// execution of voting rules wherein `current_target <= best_target`.
+	fn restrict_vote(
+		&self,
+		backend: Arc<B>,
+		base: &Block::Header,
+		best_target: &Block::Header,
+		current_target: &Block::Header,
+	) -> VotingRuleResult<Block>;
+}
+
+impl<Block, B> VotingRule<Block, B> for ()
+where
+	Block: BlockT,
+	B: HeaderBackend<Block>,
+{
+	fn restrict_vote(
+		&self,
+		_backend: Arc<B>,
+		_base: &Block::Header,
+		_best_target: &Block::Header,
+		_current_target: &Block::Header,
+	) -> VotingRuleResult<Block> {
+		Box::pin(async { None })
+	}
+}
+
+/// A custom voting rule that guarantees that our vote is always behind the best
+/// block by at least N blocks, unless the base number is < N blocks behind the
+/// best, in which case it votes for the base.
+///
+/// In the best case our vote is exactly N blocks
+/// behind the best block, but if there is a scenario where either
+/// >34% of validators run without this rule or the fork-choice rule
+/// can prioritize shorter chains over longer ones, the vote may be
+/// closer to the best block than N.
+#[derive(Clone)]
+pub struct BeforeBestBlockBy<N>(pub N);
+impl<Block, B> VotingRule<Block, B> for BeforeBestBlockBy<NumberFor<Block>>
+where
+	Block: BlockT,
+	B: HeaderBackend<Block>,
+{
+	fn restrict_vote(
+		&self,
+		backend: Arc<B>,
+		base: &Block::Header,
+		best_target: &Block::Header,
+		current_target: &Block::Header,
+	) -> VotingRuleResult<Block> {
+		use sp_arithmetic::traits::Saturating;
+
+		if current_target.number().is_zero() {
+			return Box::pin(async { None })
+		}
+
+		// Constrain to the base number, if that's the minimal
+		// vote that can be placed.
+		if *base.number() + self.0 > *best_target.number() {
+			return Box::pin(std::future::ready(Some((base.hash(), *base.number()))))
+		}
+
+		// find the target number restricted by this rule
+		let target_number = best_target.number().saturating_sub(self.0);
+
+		// our current target is already lower than this rule would restrict
+		if target_number >= *current_target.number() {
+			return Box::pin(async { None })
+		}
+
+		let current_target = current_target.clone();
+
+		// find the block at the given target height
+		Box::pin(std::future::ready(find_target(&*backend, target_number, &current_target)))
+	}
+}
+
+/// A custom voting rule that limits votes towards 3/4 of the unfinalized chain,
+/// using the given `base` and `best_target` to figure where the 3/4 target
+/// should fall.
+#[derive(Clone)]
+pub struct ThreeQuartersOfTheUnfinalizedChain;
+
+impl<Block, B> VotingRule<Block, B> for ThreeQuartersOfTheUnfinalizedChain
+where
+	Block: BlockT,
+	B: HeaderBackend<Block>,
+{
+	fn restrict_vote(
+		&self,
+		backend: Arc<B>,
+		base: &Block::Header,
+		best_target: &Block::Header,
+		current_target: &Block::Header,
+	) -> VotingRuleResult<Block> {
+		// target a vote towards 3/4 of the unfinalized chain (rounding up)
+		let target_number = {
+			let two = NumberFor::<Block>::one() + One::one();
+			let three = two + One::one();
+			let four = three + One::one();
+
+			let diff = *best_target.number() - *base.number();
+			let diff = ((diff * three) + two) / four;
+
+			*base.number() + diff
+		};
+
+		// our current target is already lower than this rule would restrict
+		if target_number >= *current_target.number() {
+			return Box::pin(async { None })
+		}
+
+		// find the block at the given target height
+		Box::pin(std::future::ready(find_target(&*backend, target_number, current_target)))
+	}
+}
+
+// walk backwards until we find the target block
+fn find_target<Block, B>(
+	backend: &B,
+	target_number: NumberFor<Block>,
+	current_header: &Block::Header,
+) -> Option<(Block::Hash, NumberFor<Block>)>
+where
+	Block: BlockT,
+	B: HeaderBackend<Block>,
+{
+	let mut target_hash = current_header.hash();
+	let mut target_header = current_header.clone();
+
+	loop {
+		if *target_header.number() < target_number {
+			unreachable!(
+				"we are traversing backwards from a known block; \
+				 blocks are stored contiguously; \
+				 qed"
+			);
+		}
+
+		if *target_header.number() == target_number {
+			return Some((target_hash, target_number))
+		}
+
+		target_hash = *target_header.parent_hash();
+		target_header = backend
+			.header(target_hash)
+			.ok()?
+			.expect("Header known to exist due to the existence of one of its descendents; qed");
+	}
+}
+
+struct VotingRules<Block, B> {
+	rules: Arc<Vec<Box<dyn VotingRule<Block, B>>>>,
+}
+
+impl<B, Block> Clone for VotingRules<B, Block> {
+	fn clone(&self) -> Self {
+		VotingRules { rules: self.rules.clone() }
+	}
+}
+
+impl<Block, B> VotingRule<Block, B> for VotingRules<Block, B>
+where
+	Block: BlockT,
+	B: HeaderBackend<Block> + 'static,
+{
+	fn restrict_vote(
+		&self,
+		backend: Arc<B>,
+		base: &Block::Header,
+		best_target: &Block::Header,
+		current_target: &Block::Header,
+	) -> VotingRuleResult<Block> {
+		let rules = self.rules.clone();
+		let base = base.clone();
+		let best_target = best_target.clone();
+		let current_target = current_target.clone();
+
+		Box::pin(async move {
+			let mut restricted_target = current_target.clone();
+
+			for rule in rules.iter() {
+				if let Some(header) = rule
+					.restrict_vote(backend.clone(), &base, &best_target, &restricted_target)
+					.await
+					.filter(|(_, restricted_number)| {
+						// NOTE: we can only restrict votes within the interval [base, target)
+						restricted_number >= base.number() &&
+							restricted_number < restricted_target.number()
+					})
+					.and_then(|(hash, _)| backend.header(hash).ok())
+					.and_then(std::convert::identity)
+				{
+					restricted_target = header;
+				}
+			}
+
+			let restricted_hash = restricted_target.hash();
+
+			if restricted_hash != current_target.hash() {
+				Some((restricted_hash, *restricted_target.number()))
+			} else {
+				None
+			}
+		})
+	}
+}
+
+/// A builder of a composite voting rule that applies a set of rules to
+/// progressively restrict the vote.
+pub struct VotingRulesBuilder<Block, B> {
+	rules: Vec<Box<dyn VotingRule<Block, B>>>,
+}
+
+impl<Block, B> Default for VotingRulesBuilder<Block, B>
+where
+	Block: BlockT,
+	B: HeaderBackend<Block> + 'static,
+{
+	fn default() -> Self {
+		VotingRulesBuilder::new()
+			.add(BeforeBestBlockBy(2u32.into()))
+			.add(ThreeQuartersOfTheUnfinalizedChain)
+	}
+}
+
+impl<Block, B> VotingRulesBuilder<Block, B>
+where
+	Block: BlockT,
+	B: HeaderBackend<Block> + 'static,
+{
+	/// Return a new voting rule builder using the given backend.
+	pub fn new() -> Self {
+		VotingRulesBuilder { rules: Vec::new() }
+	}
+
+	/// Add a new voting rule to the builder.
+	pub fn add<R>(mut self, rule: R) -> Self
+	where
+		R: VotingRule<Block, B> + 'static,
+	{
+		self.rules.push(Box::new(rule));
+		self
+	}
+
+	/// Add all given voting rules to the builder.
+	pub fn add_all<I>(mut self, rules: I) -> Self
+	where
+		I: IntoIterator<Item = Box<dyn VotingRule<Block, B>>>,
+	{
+		self.rules.extend(rules);
+		self
+	}
+
+	/// Return a new `VotingRule` that applies all of the previously added
+	/// voting rules in-order.
+	pub fn build(self) -> impl VotingRule<Block, B> + Clone {
+		VotingRules { rules: Arc::new(self.rules) }
+	}
+}
+
+impl<Block, B> VotingRule<Block, B> for Box<dyn VotingRule<Block, B>>
+where
+	Block: BlockT,
+	B: HeaderBackend<Block>,
+	Self: Clone,
+{
+	fn restrict_vote(
+		&self,
+		backend: Arc<B>,
+		base: &Block::Header,
+		best_target: &Block::Header,
+		current_target: &Block::Header,
+	) -> VotingRuleResult<Block> {
+		(**self).restrict_vote(backend, base, best_target, current_target)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_block_builder::BlockBuilderProvider;
+	use sp_consensus::BlockOrigin;
+	use sp_runtime::traits::Header as _;
+
+	use substrate_test_runtime_client::{
+		runtime::{Block, Header},
+		Backend, Client, ClientBlockImportExt, DefaultTestClientBuilderExt, TestClientBuilder,
+		TestClientBuilderExt,
+	};
+
+	/// A mock voting rule that subtracts a static number of block from the `current_target`.
+	#[derive(Clone)]
+	struct Subtract(u64);
+	impl VotingRule<Block, Client<Backend>> for Subtract {
+		fn restrict_vote(
+			&self,
+			backend: Arc<Client<Backend>>,
+			_base: &Header,
+			_best_target: &Header,
+			current_target: &Header,
+		) -> VotingRuleResult<Block> {
+			let target_number = current_target.number() - self.0;
+			let res = backend
+				.hash(target_number)
+				.unwrap()
+				.map(|target_hash| (target_hash, target_number));
+
+			Box::pin(std::future::ready(res))
+		}
+	}
+
+	#[test]
+	fn multiple_voting_rules_cannot_restrict_past_base() {
+		// setup an aggregate voting rule composed of two voting rules
+		// where each subtracts 50 blocks from the current target
+		let rule = VotingRulesBuilder::new().add(Subtract(50)).add(Subtract(50)).build();
+
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let mut hashes = Vec::with_capacity(200);
+
+		for _ in 0..200 {
+			let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+			hashes.push(block.hash());
+
+			futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+		}
+
+		let genesis = client.header(client.info().genesis_hash).unwrap().unwrap();
+
+		let best = client.header(client.info().best_hash).unwrap().unwrap();
+
+		let (_, number) =
+			futures::executor::block_on(rule.restrict_vote(client.clone(), &genesis, &best, &best))
+				.unwrap();
+
+		// we apply both rules which should subtract 100 blocks from best block (#200)
+		// which means that we should be voting for block #100
+		assert_eq!(number, 100);
+
+		let block110 = client.header(hashes[109]).unwrap().unwrap();
+
+		let (_, number) = futures::executor::block_on(rule.restrict_vote(
+			client.clone(),
+			&block110,
+			&best,
+			&best,
+		))
+		.unwrap();
+
+		// base block is #110 while best block is #200, applying both rules would make
+		// would make the target block (#100) be lower than the base block, therefore
+		// only one of the rules is applied.
+		assert_eq!(number, 150);
+	}
+
+	#[test]
+	fn before_best_by_has_cutoff_at_base() {
+		let rule = BeforeBestBlockBy(2);
+
+		let mut client = Arc::new(TestClientBuilder::new().build());
+
+		let n = 5;
+		let mut hashes = Vec::with_capacity(n);
+		for _ in 0..n {
+			let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+			hashes.push(block.hash());
+
+			futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+		}
+
+		let best = client.header(client.info().best_hash).unwrap().unwrap();
+		let best_number = *best.number();
+
+		for i in 0..n {
+			let base = client.header(hashes[i]).unwrap().unwrap();
+			let (_, number) = futures::executor::block_on(rule.restrict_vote(
+				client.clone(),
+				&base,
+				&best,
+				&best,
+			))
+			.unwrap();
+
+			let expected = std::cmp::max(best_number - 2, *base.number());
+			assert_eq!(number, expected, "best = {}, lag = 2, base = {}", best_number, i);
+		}
+	}
+}
diff --git a/substrate/client/consensus/grandpa/src/warp_proof.rs b/substrate/client/consensus/grandpa/src/warp_proof.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9acf1f2187793c0ad5a722c0481f7cde2b22d77d
--- /dev/null
+++ b/substrate/client/consensus/grandpa/src/warp_proof.rs
@@ -0,0 +1,445 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Utilities for generating and verifying GRANDPA warp sync proofs.
+
+use parity_scale_codec::{Decode, DecodeAll, Encode};
+
+use crate::{
+	best_justification, find_scheduled_change, AuthoritySetChanges, AuthoritySetHardFork,
+	BlockNumberOps, GrandpaJustification, SharedAuthoritySet,
+};
+use sc_client_api::Backend as ClientBackend;
+use sc_network_common::sync::warp::{EncodedProof, VerificationResult, WarpSyncProvider};
+use sp_blockchain::{Backend as BlockchainBackend, HeaderBackend};
+use sp_consensus_grandpa::{AuthorityList, SetId, GRANDPA_ENGINE_ID};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor, One},
+};
+
+use std::{collections::HashMap, sync::Arc};
+
+/// Warp proof processing error.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Decoding error.
+	#[error("Failed to decode block hash: {0}.")]
+	DecodeScale(#[from] parity_scale_codec::Error),
+	/// Client backend error.
+	#[error("{0}")]
+	Client(#[from] sp_blockchain::Error),
+	/// Invalid request data.
+	#[error("{0}")]
+	InvalidRequest(String),
+	/// Invalid warp proof.
+	#[error("{0}")]
+	InvalidProof(String),
+	/// Missing header or authority set change data.
+	#[error("Missing required data to be able to answer request.")]
+	MissingData,
+}
+
+/// The maximum size in bytes of the `WarpSyncProof`.
+pub(super) const MAX_WARP_SYNC_PROOF_SIZE: usize = 8 * 1024 * 1024;
+
+/// A proof of an authority set change.
+#[derive(Decode, Encode, Debug)]
+pub struct WarpSyncFragment<Block: BlockT> {
+	/// The last block that the given authority set finalized. This block should contain a digest
+	/// signaling an authority set change from which we can fetch the next authority set.
+	pub header: Block::Header,
+	/// A justification for the header above which proves its finality. In order to validate it the
+	/// verifier must be aware of the authorities and set id for which the justification refers to.
+	pub justification: GrandpaJustification<Block>,
+}
+
+/// An accumulated proof of multiple authority set changes.
+#[derive(Decode, Encode)]
+pub struct WarpSyncProof<Block: BlockT> {
+	proofs: Vec<WarpSyncFragment<Block>>,
+	is_finished: bool,
+}
+
+impl<Block: BlockT> WarpSyncProof<Block> {
+	/// Generates a warp sync proof starting at the given block. It will generate authority set
+	/// change proofs for all changes that happened from `begin` until the current authority set
+	/// (capped by MAX_WARP_SYNC_PROOF_SIZE).
+	fn generate<Backend>(
+		backend: &Backend,
+		begin: Block::Hash,
+		set_changes: &AuthoritySetChanges<NumberFor<Block>>,
+	) -> Result<WarpSyncProof<Block>, Error>
+	where
+		Backend: ClientBackend<Block>,
+	{
+		// TODO: cache best response (i.e. the one with lowest begin_number)
+		let blockchain = backend.blockchain();
+
+		let begin_number = blockchain
+			.block_number_from_id(&BlockId::Hash(begin))?
+			.ok_or_else(|| Error::InvalidRequest("Missing start block".to_string()))?;
+
+		if begin_number > blockchain.info().finalized_number {
+			return Err(Error::InvalidRequest("Start block is not finalized".to_string()))
+		}
+
+		let canon_hash = blockchain.hash(begin_number)?.expect(
+			"begin number is lower than finalized number; \
+			 all blocks below finalized number must have been imported; \
+			 qed.",
+		);
+
+		if canon_hash != begin {
+			return Err(Error::InvalidRequest(
+				"Start block is not in the finalized chain".to_string(),
+			))
+		}
+
+		let mut proofs = Vec::new();
+		let mut proofs_encoded_len = 0;
+		let mut proof_limit_reached = false;
+
+		let set_changes = set_changes.iter_from(begin_number).ok_or(Error::MissingData)?;
+
+		for (_, last_block) in set_changes {
+			let hash = blockchain.block_hash_from_id(&BlockId::Number(*last_block))?
+				.expect("header number comes from previously applied set changes; corresponding hash must exist in db; qed.");
+
+			let header = blockchain
+				.header(hash)?
+				.expect("header hash obtained from header number exists in db; corresponding header must exist in db too; qed.");
+
+			// the last block in a set is the one that triggers a change to the next set,
+			// therefore the block must have a digest that signals the authority set change
+			if find_scheduled_change::<Block>(&header).is_none() {
+				// if it doesn't contain a signal for standard change then the set must have changed
+				// through a forced changed, in which case we stop collecting proofs as the chain of
+				// trust in authority handoffs was broken.
+				break
+			}
+
+			let justification = blockchain
+				.justifications(header.hash())?
+				.and_then(|just| just.into_justification(GRANDPA_ENGINE_ID))
+				.ok_or_else(|| Error::MissingData)?;
+
+			let justification = GrandpaJustification::<Block>::decode_all(&mut &justification[..])?;
+
+			let proof = WarpSyncFragment { header: header.clone(), justification };
+			let proof_size = proof.encoded_size();
+
+			// Check for the limit. We remove some bytes from the maximum size, because we're only
+			// counting the size of the `WarpSyncFragment`s. The extra margin is here to leave
+			// room for rest of the data (the size of the `Vec` and the boolean).
+			if proofs_encoded_len + proof_size >= MAX_WARP_SYNC_PROOF_SIZE - 50 {
+				proof_limit_reached = true;
+				break
+			}
+
+			proofs_encoded_len += proof_size;
+			proofs.push(proof);
+		}
+
+		let is_finished = if proof_limit_reached {
+			false
+		} else {
+			let latest_justification = best_justification(backend)?.filter(|justification| {
+				// the existing best justification must be for a block higher than the
+				// last authority set change. if we didn't prove any authority set
+				// change then we fallback to make sure it's higher or equal to the
+				// initial warp sync block.
+				let limit = proofs
+					.last()
+					.map(|proof| proof.justification.target().0 + One::one())
+					.unwrap_or(begin_number);
+
+				justification.target().0 >= limit
+			});
+
+			if let Some(latest_justification) = latest_justification {
+				let header = blockchain.header(latest_justification.target().1)?
+					.expect("header hash corresponds to a justification in db; must exist in db as well; qed.");
+
+				proofs.push(WarpSyncFragment { header, justification: latest_justification })
+			}
+
+			true
+		};
+
+		let final_outcome = WarpSyncProof { proofs, is_finished };
+		debug_assert!(final_outcome.encoded_size() <= MAX_WARP_SYNC_PROOF_SIZE);
+		Ok(final_outcome)
+	}
+
+	/// Verifies the warp sync proof starting at the given set id and with the given authorities.
+	/// Verification stops when either the proof is exhausted or finality for the target header can
+	/// be proven. If the proof is valid the new set id and authorities is returned.
+	fn verify(
+		&self,
+		set_id: SetId,
+		authorities: AuthorityList,
+		hard_forks: &HashMap<(Block::Hash, NumberFor<Block>), (SetId, AuthorityList)>,
+	) -> Result<(SetId, AuthorityList), Error>
+	where
+		NumberFor<Block>: BlockNumberOps,
+	{
+		let mut current_set_id = set_id;
+		let mut current_authorities = authorities;
+
+		for (fragment_num, proof) in self.proofs.iter().enumerate() {
+			let hash = proof.header.hash();
+			let number = *proof.header.number();
+
+			if let Some((set_id, list)) = hard_forks.get(&(hash, number)) {
+				current_set_id = *set_id;
+				current_authorities = list.clone();
+			} else {
+				proof
+					.justification
+					.verify(current_set_id, &current_authorities)
+					.map_err(|err| Error::InvalidProof(err.to_string()))?;
+
+				if proof.justification.target().1 != hash {
+					return Err(Error::InvalidProof(
+						"Mismatch between header and justification".to_owned(),
+					))
+				}
+
+				if let Some(scheduled_change) = find_scheduled_change::<Block>(&proof.header) {
+					current_authorities = scheduled_change.next_authorities;
+					current_set_id += 1;
+				} else if fragment_num != self.proofs.len() - 1 || !self.is_finished {
+					// Only the last fragment of the last proof message is allowed to be missing the
+					// authority set change.
+					return Err(Error::InvalidProof(
+						"Header is missing authority set change digest".to_string(),
+					))
+				}
+			}
+		}
+		Ok((current_set_id, current_authorities))
+	}
+}
+
+/// Implements network API for warp sync.
+pub struct NetworkProvider<Block: BlockT, Backend: ClientBackend<Block>>
+where
+	NumberFor<Block>: BlockNumberOps,
+{
+	backend: Arc<Backend>,
+	authority_set: SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+	hard_forks: HashMap<(Block::Hash, NumberFor<Block>), (SetId, AuthorityList)>,
+}
+
+impl<Block: BlockT, Backend: ClientBackend<Block>> NetworkProvider<Block, Backend>
+where
+	NumberFor<Block>: BlockNumberOps,
+{
+	/// Create a new istance for a given backend and authority set.
+	pub fn new(
+		backend: Arc<Backend>,
+		authority_set: SharedAuthoritySet<Block::Hash, NumberFor<Block>>,
+		hard_forks: Vec<AuthoritySetHardFork<Block>>,
+	) -> Self {
+		NetworkProvider {
+			backend,
+			authority_set,
+			hard_forks: hard_forks
+				.into_iter()
+				.map(|fork| (fork.block, (fork.set_id, fork.authorities)))
+				.collect(),
+		}
+	}
+}
+
+impl<Block: BlockT, Backend: ClientBackend<Block>> WarpSyncProvider<Block>
+	for NetworkProvider<Block, Backend>
+where
+	NumberFor<Block>: BlockNumberOps,
+{
+	fn generate(
+		&self,
+		start: Block::Hash,
+	) -> Result<EncodedProof, Box<dyn std::error::Error + Send + Sync>> {
+		let proof = WarpSyncProof::<Block>::generate(
+			&*self.backend,
+			start,
+			&self.authority_set.authority_set_changes(),
+		)
+		.map_err(Box::new)?;
+		Ok(EncodedProof(proof.encode()))
+	}
+
+	fn verify(
+		&self,
+		proof: &EncodedProof,
+		set_id: SetId,
+		authorities: AuthorityList,
+	) -> Result<VerificationResult<Block>, Box<dyn std::error::Error + Send + Sync>> {
+		let EncodedProof(proof) = proof;
+		let proof = WarpSyncProof::<Block>::decode_all(&mut proof.as_slice())
+			.map_err(|e| format!("Proof decoding error: {:?}", e))?;
+		let last_header = proof
+			.proofs
+			.last()
+			.map(|p| p.header.clone())
+			.ok_or_else(|| "Empty proof".to_string())?;
+		let (next_set_id, next_authorities) =
+			proof.verify(set_id, authorities, &self.hard_forks).map_err(Box::new)?;
+		if proof.is_finished {
+			Ok(VerificationResult::<Block>::Complete(next_set_id, next_authorities, last_header))
+		} else {
+			Ok(VerificationResult::<Block>::Partial(
+				next_set_id,
+				next_authorities,
+				last_header.hash(),
+			))
+		}
+	}
+
+	fn current_authorities(&self) -> AuthorityList {
+		self.authority_set.inner().current_authorities.clone()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::WarpSyncProof;
+	use crate::{AuthoritySetChanges, GrandpaJustification};
+	use parity_scale_codec::Encode;
+	use rand::prelude::*;
+	use sc_block_builder::BlockBuilderProvider;
+	use sp_blockchain::HeaderBackend;
+	use sp_consensus::BlockOrigin;
+	use sp_consensus_grandpa::GRANDPA_ENGINE_ID;
+	use sp_keyring::Ed25519Keyring;
+	use std::sync::Arc;
+	use substrate_test_runtime_client::{
+		BlockBuilderExt, ClientBlockImportExt, ClientExt, DefaultTestClientBuilderExt,
+		TestClientBuilder, TestClientBuilderExt,
+	};
+
+	#[test]
+	fn warp_sync_proof_generate_verify() {
+		let mut rng = rand::rngs::StdRng::from_seed([0; 32]);
+		let builder = TestClientBuilder::new();
+		let backend = builder.backend();
+		let mut client = Arc::new(builder.build());
+
+		let available_authorities = Ed25519Keyring::iter().collect::<Vec<_>>();
+		let genesis_authorities = vec![(Ed25519Keyring::Alice.public().into(), 1)];
+
+		let mut current_authorities = vec![Ed25519Keyring::Alice];
+		let mut current_set_id = 0;
+		let mut authority_set_changes = Vec::new();
+
+		for n in 1..=100 {
+			let mut builder = client.new_block(Default::default()).unwrap();
+			let mut new_authorities = None;
+
+			// we will trigger an authority set change every 10 blocks
+			if n != 0 && n % 10 == 0 {
+				// pick next authorities and add digest for the set change
+				let n_authorities = rng.gen_range(1..available_authorities.len());
+				let next_authorities = available_authorities
+					.choose_multiple(&mut rng, n_authorities)
+					.cloned()
+					.collect::<Vec<_>>();
+
+				new_authorities = Some(next_authorities.clone());
+
+				let next_authorities = next_authorities
+					.iter()
+					.map(|keyring| (keyring.public().into(), 1))
+					.collect::<Vec<_>>();
+
+				let digest = sp_runtime::generic::DigestItem::Consensus(
+					sp_consensus_grandpa::GRANDPA_ENGINE_ID,
+					sp_consensus_grandpa::ConsensusLog::ScheduledChange(
+						sp_consensus_grandpa::ScheduledChange { delay: 0u64, next_authorities },
+					)
+					.encode(),
+				);
+
+				builder.push_deposit_log_digest_item(digest).unwrap();
+			}
+
+			let block = builder.build().unwrap().block;
+
+			futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+			if let Some(new_authorities) = new_authorities {
+				// generate a justification for this block, finalize it and note the authority set
+				// change
+				let (target_hash, target_number) = {
+					let info = client.info();
+					(info.best_hash, info.best_number)
+				};
+
+				let mut precommits = Vec::new();
+				for keyring in &current_authorities {
+					let precommit = finality_grandpa::Precommit { target_hash, target_number };
+
+					let msg = finality_grandpa::Message::Precommit(precommit.clone());
+					let encoded = sp_consensus_grandpa::localized_payload(42, current_set_id, &msg);
+					let signature = keyring.sign(&encoded[..]).into();
+
+					let precommit = finality_grandpa::SignedPrecommit {
+						precommit,
+						signature,
+						id: keyring.public().into(),
+					};
+
+					precommits.push(precommit);
+				}
+
+				let commit = finality_grandpa::Commit { target_hash, target_number, precommits };
+
+				let justification = GrandpaJustification::from_commit(&client, 42, commit).unwrap();
+
+				client
+					.finalize_block(target_hash, Some((GRANDPA_ENGINE_ID, justification.encode())))
+					.unwrap();
+
+				authority_set_changes.push((current_set_id, n));
+
+				current_set_id += 1;
+				current_authorities = new_authorities;
+			}
+		}
+
+		let authority_set_changes = AuthoritySetChanges::from(authority_set_changes);
+
+		// generate a warp sync proof
+		let genesis_hash = client.hash(0).unwrap().unwrap();
+
+		let warp_sync_proof =
+			WarpSyncProof::generate(&*backend, genesis_hash, &authority_set_changes).unwrap();
+
+		// verifying the proof should yield the last set id and authorities
+		let (new_set_id, new_authorities) =
+			warp_sync_proof.verify(0, genesis_authorities, &Default::default()).unwrap();
+
+		let expected_authorities = current_authorities
+			.iter()
+			.map(|keyring| (keyring.public().into(), 1))
+			.collect::<Vec<_>>();
+
+		assert_eq!(new_set_id, current_set_id);
+		assert_eq!(new_authorities, expected_authorities);
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/Cargo.toml b/substrate/client/consensus/manual-seal/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4bc389ac3f4cd1be9516dde01260041e337ed1f1
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "sc-consensus-manual-seal"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Manual sealing engine for Substrate"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+assert_matches = "1.3.0"
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+futures-timer = "3.0.1"
+log = "0.4.17"
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "1.0"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
+sc-consensus-aura = { version = "0.10.0-dev", path = "../../consensus/aura" }
+sc-consensus-babe = { version = "0.10.0-dev", path = "../../consensus/babe" }
+sc-consensus-epochs = { version = "0.10.0-dev", path = "../../consensus/epochs" }
+sc-transaction-pool = { version = "4.0.0-dev", path = "../../transaction-pool" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../client/transaction-pool/api" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-aura = { version = "0.10.0-dev", path = "../../../primitives/consensus/aura" }
+sp-consensus-babe = { version = "0.10.0-dev", path = "../../../primitives/consensus/babe" }
+sp-consensus-slots = { version = "0.10.0-dev", path = "../../../primitives/consensus/slots" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-timestamp = { version = "4.0.0-dev", path = "../../../primitives/timestamp" }
+
+[dev-dependencies]
+tokio = { version = "1.22.0", features = ["rt-multi-thread", "macros"] }
+sc-basic-authorship = { version = "0.10.0-dev", path = "../../basic-authorship" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
+substrate-test-runtime-transaction-pool = { version = "2.0.0", path = "../../../test-utils/runtime/transaction-pool" }
diff --git a/substrate/client/consensus/manual-seal/README.md b/substrate/client/consensus/manual-seal/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b355f8b73183cc9661b4c65d76a060d9f6cc8918
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/README.md
@@ -0,0 +1,4 @@
+A manual sealing engine: the engine listens for rpc calls to seal blocks and create forks.
+This is suitable for a testing environment.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/manual-seal/src/consensus.rs b/substrate/client/consensus/manual-seal/src/consensus.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2cc2b902b1ce9a57c19ea4fd34a26b62412deb99
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/consensus.rs
@@ -0,0 +1,47 @@
+// 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/>.
+
+//! Extensions for manual seal to produce blocks valid for any runtime.
+use super::Error;
+
+use sc_consensus::BlockImportParams;
+use sp_inherents::InherentData;
+use sp_runtime::{traits::Block as BlockT, Digest};
+
+pub mod aura;
+pub mod babe;
+pub mod timestamp;
+
+/// Consensus data provider, manual seal uses this trait object for authoring blocks valid
+/// for any runtime.
+pub trait ConsensusDataProvider<B: BlockT>: Send + Sync {
+	/// The proof type.
+	type Proof;
+
+	/// Attempt to create a consensus digest.
+	fn create_digest(&self, parent: &B::Header, inherents: &InherentData) -> Result<Digest, Error>;
+
+	/// Set up the necessary import params.
+	fn append_block_import(
+		&self,
+		parent: &B::Header,
+		params: &mut BlockImportParams<B>,
+		inherents: &InherentData,
+		proof: Self::Proof,
+	) -> Result<(), Error>;
+}
diff --git a/substrate/client/consensus/manual-seal/src/consensus/aura.rs b/substrate/client/consensus/manual-seal/src/consensus/aura.rs
new file mode 100644
index 0000000000000000000000000000000000000000..566a2266c701b4cdffaa98caef14d8e88ac60952
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/consensus/aura.rs
@@ -0,0 +1,100 @@
+// 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/>.
+
+//! Aura consensus data provider, This allows manual seal author blocks that are valid for
+//! runtimes that expect the aura-specific digests.
+
+use crate::{ConsensusDataProvider, Error};
+use sc_client_api::{AuxStore, UsageProvider};
+use sc_consensus::BlockImportParams;
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::{HeaderBackend, HeaderMetadata};
+use sp_consensus_aura::{
+	digests::CompatibleDigestItem,
+	sr25519::{AuthorityId, AuthoritySignature},
+	AuraApi, Slot, SlotDuration,
+};
+use sp_inherents::InherentData;
+use sp_runtime::{traits::Block as BlockT, Digest, DigestItem};
+use sp_timestamp::TimestampInherentData;
+use std::{marker::PhantomData, sync::Arc};
+
+/// Consensus data provider for Aura.
+pub struct AuraConsensusDataProvider<B, C, P> {
+	// slot duration
+	slot_duration: SlotDuration,
+	// phantom data for required generics
+	_phantom: PhantomData<(B, C, P)>,
+}
+
+impl<B, C, P> AuraConsensusDataProvider<B, C, P>
+where
+	B: BlockT,
+	C: AuxStore + ProvideRuntimeApi<B> + UsageProvider<B>,
+	C::Api: AuraApi<B, AuthorityId>,
+{
+	/// Creates a new instance of the [`AuraConsensusDataProvider`], requires that `client`
+	/// implements [`sp_consensus_aura::AuraApi`]
+	pub fn new(client: Arc<C>) -> Self {
+		let slot_duration = sc_consensus_aura::slot_duration(&*client)
+			.expect("slot_duration is always present; qed.");
+
+		Self { slot_duration, _phantom: PhantomData }
+	}
+}
+
+impl<B, C, P> ConsensusDataProvider<B> for AuraConsensusDataProvider<B, C, P>
+where
+	B: BlockT,
+	C: AuxStore
+		+ HeaderBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ UsageProvider<B>
+		+ ProvideRuntimeApi<B>,
+	C::Api: AuraApi<B, AuthorityId>,
+	P: Send + Sync,
+{
+	type Proof = P;
+
+	fn create_digest(
+		&self,
+		_parent: &B::Header,
+		inherents: &InherentData,
+	) -> Result<Digest, Error> {
+		let timestamp =
+			inherents.timestamp_inherent_data()?.expect("Timestamp is always present; qed");
+
+		// we always calculate the new slot number based on the current time-stamp and the slot
+		// duration.
+		let digest_item = <DigestItem as CompatibleDigestItem<AuthoritySignature>>::aura_pre_digest(
+			Slot::from_timestamp(timestamp, self.slot_duration),
+		);
+
+		Ok(Digest { logs: vec![digest_item] })
+	}
+
+	fn append_block_import(
+		&self,
+		_parent: &B::Header,
+		_params: &mut BlockImportParams<B>,
+		_inherents: &InherentData,
+		_proof: Self::Proof,
+	) -> Result<(), Error> {
+		Ok(())
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/src/consensus/babe.rs b/substrate/client/consensus/manual-seal/src/consensus/babe.rs
new file mode 100644
index 0000000000000000000000000000000000000000..26fa81459808c39635a1970b0fef7b36774803a9
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/consensus/babe.rs
@@ -0,0 +1,318 @@
+// 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/>.
+
+//! BABE consensus data provider, This allows manual seal author blocks that are valid for runtimes
+//! that expect babe-specific digests.
+
+use super::ConsensusDataProvider;
+use crate::{Error, LOG_TARGET};
+use codec::Encode;
+use sc_client_api::{AuxStore, UsageProvider};
+use sc_consensus_babe::{
+	authorship, find_pre_digest, BabeIntermediate, CompatibleDigestItem, Epoch, INTERMEDIATE_KEY,
+};
+use sc_consensus_epochs::{
+	descendent_query, EpochHeader, SharedEpochChanges, ViableEpochDescriptor,
+};
+use sp_keystore::KeystorePtr;
+use std::{marker::PhantomData, sync::Arc};
+
+use sc_consensus::{BlockImportParams, ForkChoiceStrategy, Verifier};
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::{HeaderBackend, HeaderMetadata};
+use sp_consensus_babe::{
+	digests::{NextEpochDescriptor, PreDigest, SecondaryPlainPreDigest},
+	inherents::BabeInherentData,
+	AuthorityId, BabeApi, BabeAuthorityWeight, BabeConfiguration, ConsensusLog, BABE_ENGINE_ID,
+};
+use sp_consensus_slots::Slot;
+use sp_inherents::InherentData;
+use sp_runtime::{
+	generic::Digest,
+	traits::{Block as BlockT, Header},
+	DigestItem,
+};
+use sp_timestamp::TimestampInherentData;
+
+/// Provides BABE-compatible predigests and BlockImportParams.
+/// Intended for use with BABE runtimes.
+pub struct BabeConsensusDataProvider<B: BlockT, C, P> {
+	/// shared reference to keystore
+	keystore: KeystorePtr,
+
+	/// Shared reference to the client.
+	client: Arc<C>,
+
+	/// Shared epoch changes
+	epoch_changes: SharedEpochChanges<B, Epoch>,
+
+	/// BABE config, gotten from the runtime.
+	/// NOTE: This is used to fetch `slot_duration` and `epoch_length` in the
+	/// `ConsensusDataProvider` implementation. Correct as far as these values
+	/// are not changed during an epoch change.
+	config: BabeConfiguration,
+
+	/// Authorities to be used for this babe chain.
+	authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+	_phantom: PhantomData<P>,
+}
+
+/// Verifier to be used for babe chains
+pub struct BabeVerifier<B: BlockT, C> {
+	/// Shared epoch changes
+	epoch_changes: SharedEpochChanges<B, Epoch>,
+
+	/// Shared reference to the client.
+	client: Arc<C>,
+}
+
+impl<B: BlockT, C> BabeVerifier<B, C> {
+	/// create a nrew verifier
+	pub fn new(epoch_changes: SharedEpochChanges<B, Epoch>, client: Arc<C>) -> BabeVerifier<B, C> {
+		BabeVerifier { epoch_changes, client }
+	}
+}
+
+/// The verifier for the manual seal engine; instantly finalizes.
+#[async_trait::async_trait]
+impl<B, C> Verifier<B> for BabeVerifier<B, C>
+where
+	B: BlockT,
+	C: HeaderBackend<B> + HeaderMetadata<B, Error = sp_blockchain::Error>,
+{
+	async fn verify(
+		&mut self,
+		mut import_params: BlockImportParams<B>,
+	) -> Result<BlockImportParams<B>, String> {
+		import_params.finalized = false;
+		import_params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		let pre_digest = find_pre_digest::<B>(&import_params.header)?;
+
+		let parent_hash = import_params.header.parent_hash();
+		let parent = self
+			.client
+			.header(*parent_hash)
+			.ok()
+			.flatten()
+			.ok_or_else(|| format!("header for block {} not found", parent_hash))?;
+		let epoch_changes = self.epoch_changes.shared_data();
+		let epoch_descriptor = epoch_changes
+			.epoch_descriptor_for_child_of(
+				descendent_query(&*self.client),
+				&parent.hash(),
+				*parent.number(),
+				pre_digest.slot(),
+			)
+			.map_err(|e| format!("failed to fetch epoch_descriptor: {}", e))?
+			.ok_or_else(|| format!("{}", sp_consensus::Error::InvalidAuthoritiesSet))?;
+		// drop the lock
+		drop(epoch_changes);
+
+		import_params
+			.insert_intermediate(INTERMEDIATE_KEY, BabeIntermediate::<B> { epoch_descriptor });
+
+		Ok(import_params)
+	}
+}
+
+impl<B, C, P> BabeConsensusDataProvider<B, C, P>
+where
+	B: BlockT,
+	C: AuxStore
+		+ HeaderBackend<B>
+		+ ProvideRuntimeApi<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ UsageProvider<B>,
+	C::Api: BabeApi<B>,
+{
+	pub fn new(
+		client: Arc<C>,
+		keystore: KeystorePtr,
+		epoch_changes: SharedEpochChanges<B, Epoch>,
+		authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+	) -> Result<Self, Error> {
+		if authorities.is_empty() {
+			return Err(Error::StringError("Cannot supply empty authority set!".into()))
+		}
+
+		let config = sc_consensus_babe::configuration(&*client)?;
+
+		Ok(Self {
+			config,
+			client,
+			keystore,
+			epoch_changes,
+			authorities,
+			_phantom: Default::default(),
+		})
+	}
+
+	fn epoch(&self, parent: &B::Header, slot: Slot) -> Result<Epoch, Error> {
+		let epoch_changes = self.epoch_changes.shared_data();
+		let epoch_descriptor = epoch_changes
+			.epoch_descriptor_for_child_of(
+				descendent_query(&*self.client),
+				&parent.hash(),
+				*parent.number(),
+				slot,
+			)
+			.map_err(|e| Error::StringError(format!("failed to fetch epoch_descriptor: {}", e)))?
+			.ok_or(sp_consensus::Error::InvalidAuthoritiesSet)?;
+
+		let epoch = epoch_changes
+			.viable_epoch(&epoch_descriptor, |slot| Epoch::genesis(&self.config, slot))
+			.ok_or_else(|| {
+				log::info!(target: LOG_TARGET, "create_digest: no viable_epoch :(");
+				sp_consensus::Error::InvalidAuthoritiesSet
+			})?;
+
+		Ok(epoch.as_ref().clone())
+	}
+}
+
+impl<B, C, P> ConsensusDataProvider<B> for BabeConsensusDataProvider<B, C, P>
+where
+	B: BlockT,
+	C: AuxStore
+		+ HeaderBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ UsageProvider<B>
+		+ ProvideRuntimeApi<B>,
+	C::Api: BabeApi<B>,
+	P: Send + Sync,
+{
+	type Proof = P;
+
+	fn create_digest(&self, parent: &B::Header, inherents: &InherentData) -> Result<Digest, Error> {
+		let slot = inherents
+			.babe_inherent_data()?
+			.ok_or_else(|| Error::StringError("No babe inherent data".into()))?;
+		let epoch = self.epoch(parent, slot)?;
+
+		// this is a dev node environment, we should always be able to claim a slot.
+		let logs = if let Some((predigest, _)) =
+			authorship::claim_slot(slot, &epoch, &self.keystore)
+		{
+			vec![<DigestItem as CompatibleDigestItem>::babe_pre_digest(predigest)]
+		} else {
+			// well we couldn't claim a slot because this is an existing chain and we're not in the
+			// authorities. we need to tell BabeBlockImport that the epoch has changed, and we put
+			// ourselves in the authorities.
+			let predigest =
+				PreDigest::SecondaryPlain(SecondaryPlainPreDigest { slot, authority_index: 0_u32 });
+
+			let mut epoch_changes = self.epoch_changes.shared_data();
+			let epoch_descriptor = epoch_changes
+				.epoch_descriptor_for_child_of(
+					descendent_query(&*self.client),
+					&parent.hash(),
+					*parent.number(),
+					slot,
+				)
+				.map_err(|e| {
+					Error::StringError(format!("failed to fetch epoch_descriptor: {}", e))
+				})?
+				.ok_or(sp_consensus::Error::InvalidAuthoritiesSet)?;
+
+			match epoch_descriptor {
+				ViableEpochDescriptor::Signaled(identifier, _epoch_header) => {
+					let epoch_mut = epoch_changes
+						.epoch_mut(&identifier)
+						.ok_or(sp_consensus::Error::InvalidAuthoritiesSet)?;
+
+					// mutate the current epoch
+					epoch_mut.authorities = self.authorities.clone();
+
+					let next_epoch = ConsensusLog::NextEpochData(NextEpochDescriptor {
+						authorities: self.authorities.clone(),
+						// copy the old randomness
+						randomness: epoch_mut.randomness,
+					});
+
+					vec![
+						DigestItem::PreRuntime(BABE_ENGINE_ID, predigest.encode()),
+						DigestItem::Consensus(BABE_ENGINE_ID, next_epoch.encode()),
+					]
+				},
+				ViableEpochDescriptor::UnimportedGenesis(_) => {
+					// since this is the genesis, secondary predigest works for now.
+					vec![DigestItem::PreRuntime(BABE_ENGINE_ID, predigest.encode())]
+				},
+			}
+		};
+
+		Ok(Digest { logs })
+	}
+
+	fn append_block_import(
+		&self,
+		parent: &B::Header,
+		params: &mut BlockImportParams<B>,
+		inherents: &InherentData,
+		_proof: Self::Proof,
+	) -> Result<(), Error> {
+		let slot = inherents
+			.babe_inherent_data()?
+			.ok_or_else(|| Error::StringError("No babe inherent data".into()))?;
+		let epoch_changes = self.epoch_changes.shared_data();
+		let mut epoch_descriptor = epoch_changes
+			.epoch_descriptor_for_child_of(
+				descendent_query(&*self.client),
+				&parent.hash(),
+				*parent.number(),
+				slot,
+			)
+			.map_err(|e| Error::StringError(format!("failed to fetch epoch_descriptor: {}", e)))?
+			.ok_or(sp_consensus::Error::InvalidAuthoritiesSet)?;
+		// drop the lock
+		drop(epoch_changes);
+		// a quick check to see if we're in the authorities
+		let epoch = self.epoch(parent, slot)?;
+		let (authority, _) = self.authorities.first().expect("authorities is non-emptyp; qed");
+		let has_authority = epoch.authorities.iter().any(|(id, _)| *id == *authority);
+
+		if !has_authority {
+			log::info!(target: LOG_TARGET, "authority not found");
+			let timestamp = inherents
+				.timestamp_inherent_data()?
+				.ok_or_else(|| Error::StringError("No timestamp inherent data".into()))?;
+
+			let slot = Slot::from_timestamp(timestamp, self.config.slot_duration());
+
+			// manually hard code epoch descriptor
+			epoch_descriptor = match epoch_descriptor {
+				ViableEpochDescriptor::Signaled(identifier, _header) =>
+					ViableEpochDescriptor::Signaled(
+						identifier,
+						EpochHeader {
+							start_slot: slot,
+							end_slot: (*slot * self.config.epoch_length).into(),
+						},
+					),
+				_ => unreachable!(
+					"we're not in the authorities, so this isn't the genesis epoch; qed"
+				),
+			};
+		}
+
+		params.insert_intermediate(INTERMEDIATE_KEY, BabeIntermediate::<B> { epoch_descriptor });
+
+		Ok(())
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/src/consensus/timestamp.rs b/substrate/client/consensus/manual-seal/src/consensus/timestamp.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dbffb2fbba8245b6cb52d3063a575e431d251cd0
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/consensus/timestamp.rs
@@ -0,0 +1,161 @@
+// 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/>.
+
+//! Mocked timestamp inherent, allows for manual seal to create blocks for runtimes
+//! that expect this inherent.
+
+use crate::Error;
+use sc_client_api::{AuxStore, UsageProvider};
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::HeaderBackend;
+use sp_consensus_aura::{
+	sr25519::{AuthorityId, AuthoritySignature},
+	AuraApi,
+};
+use sp_consensus_babe::BabeApi;
+use sp_consensus_slots::{Slot, SlotDuration};
+use sp_inherents::{InherentData, InherentDataProvider, InherentIdentifier};
+use sp_runtime::traits::{Block as BlockT, Zero};
+use sp_timestamp::{InherentType, INHERENT_IDENTIFIER};
+use std::{
+	sync::{atomic, Arc},
+	time::SystemTime,
+};
+
+/// Provide duration since unix epoch in millisecond for timestamp inherent.
+/// Mocks the timestamp inherent to always produce a valid timestamp for the next slot.
+///
+/// This works by either fetching the `slot_number` from the most recent header and dividing
+/// that value by `slot_duration` in order to fork chains that expect this inherent.
+///
+/// It produces timestamp inherents that are increased by `slot_duration` whenever
+/// `provide_inherent_data` is called.
+pub struct SlotTimestampProvider {
+	// holds the unix millisecond timestamp for the most recent block
+	unix_millis: atomic::AtomicU64,
+	// configured slot_duration in the runtime
+	slot_duration: SlotDuration,
+}
+
+impl SlotTimestampProvider {
+	/// Create a new mocked time stamp provider, for babe.
+	pub fn new_babe<B, C>(client: Arc<C>) -> Result<Self, Error>
+	where
+		B: BlockT,
+		C: AuxStore + HeaderBackend<B> + ProvideRuntimeApi<B> + UsageProvider<B>,
+		C::Api: BabeApi<B>,
+	{
+		let slot_duration = sc_consensus_babe::configuration(&*client)?.slot_duration();
+
+		let time = Self::with_header(&client, slot_duration, |header| {
+			let slot_number = *sc_consensus_babe::find_pre_digest::<B>(&header)
+				.map_err(|err| format!("{}", err))?
+				.slot();
+			Ok(slot_number)
+		})?;
+
+		Ok(Self { unix_millis: atomic::AtomicU64::new(time), slot_duration })
+	}
+
+	/// Create a new mocked time stamp provider, for aura
+	pub fn new_aura<B, C>(client: Arc<C>) -> Result<Self, Error>
+	where
+		B: BlockT,
+		C: AuxStore + HeaderBackend<B> + ProvideRuntimeApi<B> + UsageProvider<B>,
+		C::Api: AuraApi<B, AuthorityId>,
+	{
+		let slot_duration = sc_consensus_aura::slot_duration(&*client)?;
+
+		let time = Self::with_header(&client, slot_duration, |header| {
+			let slot_number = *sc_consensus_aura::find_pre_digest::<B, AuthoritySignature>(&header)
+				.map_err(|err| format!("{}", err))?;
+			Ok(slot_number)
+		})?;
+
+		Ok(Self { unix_millis: atomic::AtomicU64::new(time), slot_duration })
+	}
+
+	fn with_header<F, C, B>(
+		client: &Arc<C>,
+		slot_duration: SlotDuration,
+		func: F,
+	) -> Result<u64, Error>
+	where
+		B: BlockT,
+		C: AuxStore + HeaderBackend<B> + UsageProvider<B>,
+		F: Fn(B::Header) -> Result<u64, Error>,
+	{
+		let info = client.info();
+
+		// looks like this isn't the first block, rehydrate the fake time.
+		// otherwise we'd be producing blocks for older slots.
+		let time = if info.best_number != Zero::zero() {
+			let header = client
+				.header(info.best_hash)?
+				.ok_or_else(|| "best header not found in the db!".to_string())?;
+			let slot = func(header)?;
+			// add the slot duration so there's no collision of slots
+			(slot * slot_duration.as_millis() as u64) + slot_duration.as_millis() as u64
+		} else {
+			// this is the first block, use the correct time.
+			let now = SystemTime::now();
+			now.duration_since(SystemTime::UNIX_EPOCH)
+				.map_err(|err| Error::StringError(format!("{}", err)))?
+				.as_millis() as u64
+		};
+
+		Ok(time)
+	}
+
+	/// Get the current slot number
+	pub fn slot(&self) -> Slot {
+		Slot::from_timestamp(
+			self.unix_millis.load(atomic::Ordering::SeqCst).into(),
+			self.slot_duration,
+		)
+	}
+
+	/// Gets the current time stamp.
+	pub fn timestamp(&self) -> sp_timestamp::Timestamp {
+		sp_timestamp::Timestamp::new(self.unix_millis.load(atomic::Ordering::SeqCst))
+	}
+}
+
+#[async_trait::async_trait]
+impl InherentDataProvider for SlotTimestampProvider {
+	async fn provide_inherent_data(
+		&self,
+		inherent_data: &mut InherentData,
+	) -> Result<(), sp_inherents::Error> {
+		// we update the time here.
+		let new_time: InherentType = self
+			.unix_millis
+			.fetch_add(self.slot_duration.as_millis() as u64, atomic::Ordering::SeqCst)
+			.into();
+		inherent_data.put_data(INHERENT_IDENTIFIER, &new_time)?;
+		Ok(())
+	}
+
+	async fn try_handle_error(
+		&self,
+		_: &InherentIdentifier,
+		_: &[u8],
+	) -> Option<Result<(), sp_inherents::Error>> {
+		None
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/src/error.rs b/substrate/client/consensus/manual-seal/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eeae1d153e81bcdd0ebf25bb117749c52ef128fc
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/error.rs
@@ -0,0 +1,113 @@
+// 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/>.
+
+//! A manual sealing engine: the engine listens for rpc calls to seal blocks and create forks.
+//! This is suitable for a testing environment.
+
+use futures::channel::{mpsc::SendError, oneshot};
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+use sc_consensus::ImportResult;
+use sp_blockchain::Error as BlockchainError;
+use sp_consensus::Error as ConsensusError;
+use sp_inherents::Error as InherentsError;
+
+/// Error code for rpc
+mod codes {
+	pub const SERVER_SHUTTING_DOWN: i32 = 10_000;
+	pub const BLOCK_IMPORT_FAILED: i32 = 11_000;
+	pub const EMPTY_TRANSACTION_POOL: i32 = 12_000;
+	pub const BLOCK_NOT_FOUND: i32 = 13_000;
+	pub const CONSENSUS_ERROR: i32 = 14_000;
+	pub const INHERENTS_ERROR: i32 = 15_000;
+	pub const BLOCKCHAIN_ERROR: i32 = 16_000;
+	pub const UNKNOWN_ERROR: i32 = 20_000;
+}
+
+/// errors encountered by background block authorship task
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// An error occurred while importing the block
+	#[error("Block import failed: {0:?}")]
+	BlockImportError(ImportResult),
+	/// Transaction pool is empty, cannot create a block
+	#[error(
+		"Transaction pool is empty, set create_empty to true, if you want to create empty blocks"
+	)]
+	EmptyTransactionPool,
+	/// encountered during creation of Proposer.
+	#[error("Consensus Error: {0}")]
+	ConsensusError(#[from] ConsensusError),
+	/// Failed to create Inherents data
+	#[error("Inherents Error: {0}")]
+	InherentError(#[from] InherentsError),
+	/// error encountered during finalization
+	#[error("Finalization Error: {0}")]
+	BlockchainError(#[from] BlockchainError),
+	/// Supplied parent_hash doesn't exist in chain
+	#[error("Supplied parent_hash: {0} doesn't exist in chain")]
+	BlockNotFound(String),
+	/// Some string error
+	#[error("{0}")]
+	StringError(String),
+	/// send error
+	#[error("Consensus process is terminating")]
+	Canceled(#[from] oneshot::Canceled),
+	/// send error
+	#[error("Consensus process is terminating")]
+	SendError(#[from] SendError),
+	/// Some other error.
+	#[error("Other error: {0}")]
+	Other(Box<dyn std::error::Error + Send + Sync>),
+}
+
+impl From<ImportResult> for Error {
+	fn from(err: ImportResult) -> Self {
+		Error::BlockImportError(err)
+	}
+}
+
+impl From<String> for Error {
+	fn from(s: String) -> Self {
+		Error::StringError(s)
+	}
+}
+
+impl Error {
+	fn to_code(&self) -> i32 {
+		use Error::*;
+		match self {
+			BlockImportError(_) => codes::BLOCK_IMPORT_FAILED,
+			BlockNotFound(_) => codes::BLOCK_NOT_FOUND,
+			EmptyTransactionPool => codes::EMPTY_TRANSACTION_POOL,
+			ConsensusError(_) => codes::CONSENSUS_ERROR,
+			InherentError(_) => codes::INHERENTS_ERROR,
+			BlockchainError(_) => codes::BLOCKCHAIN_ERROR,
+			SendError(_) | Canceled(_) => codes::SERVER_SHUTTING_DOWN,
+			_ => codes::UNKNOWN_ERROR,
+		}
+	}
+}
+
+impl From<Error> for JsonRpseeError {
+	fn from(err: Error) -> Self {
+		CallError::Custom(ErrorObject::owned(err.to_code(), err.to_string(), None::<()>)).into()
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/src/finalize_block.rs b/substrate/client/consensus/manual-seal/src/finalize_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..06883b2291bd28367a2957086c5eb4e3c37047e5
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/finalize_block.rs
@@ -0,0 +1,59 @@
+// 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/>.
+
+//! Block finalization utilities
+
+use crate::rpc;
+use sc_client_api::backend::{Backend as ClientBackend, Finalizer};
+use sp_runtime::{traits::Block as BlockT, Justification};
+use std::{marker::PhantomData, sync::Arc};
+
+/// params for block finalization.
+pub struct FinalizeBlockParams<B: BlockT, F, CB> {
+	/// hash of the block
+	pub hash: <B as BlockT>::Hash,
+	/// sender to report errors/success to the rpc.
+	pub sender: rpc::Sender<()>,
+	/// finalization justification
+	pub justification: Option<Justification>,
+	/// Finalizer trait object.
+	pub finalizer: Arc<F>,
+	/// phantom type to pin the Backend type
+	pub _phantom: PhantomData<CB>,
+}
+
+/// finalizes a block in the backend with the given params.
+pub async fn finalize_block<B, F, CB>(params: FinalizeBlockParams<B, F, CB>)
+where
+	B: BlockT,
+	F: Finalizer<B, CB>,
+	CB: ClientBackend<B>,
+{
+	let FinalizeBlockParams { hash, mut sender, justification, finalizer, .. } = params;
+
+	match finalizer.finalize_block(hash, justification, true) {
+		Err(e) => {
+			log::warn!("Failed to finalize block {}", e);
+			rpc::send_result(&mut sender, Err(e.into()))
+		},
+		Ok(()) => {
+			log::info!("✅ Successfully finalized block: {}", hash);
+			rpc::send_result(&mut sender, Ok(()))
+		},
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/src/lib.rs b/substrate/client/consensus/manual-seal/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1e5db966e66dbdbc453f9cdc04ff80d2f15ad9b2
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/lib.rs
@@ -0,0 +1,811 @@
+// 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/>.
+
+//! A manual sealing engine: the engine listens for rpc calls to seal blocks and create forks.
+//! This is suitable for a testing environment.
+
+use futures::prelude::*;
+use futures_timer::Delay;
+use prometheus_endpoint::Registry;
+use sc_client_api::{
+	backend::{Backend as ClientBackend, Finalizer},
+	client::BlockchainEvents,
+};
+use sc_consensus::{
+	block_import::{BlockImport, BlockImportParams, ForkChoiceStrategy},
+	import_queue::{BasicQueue, BoxBlockImport, Verifier},
+};
+use sp_blockchain::HeaderBackend;
+use sp_consensus::{Environment, Proposer, SelectChain};
+use sp_core::traits::SpawnNamed;
+use sp_inherents::CreateInherentDataProviders;
+use sp_runtime::{traits::Block as BlockT, ConsensusEngineId};
+use std::{marker::PhantomData, sync::Arc, time::Duration};
+
+mod error;
+mod finalize_block;
+mod seal_block;
+
+pub mod consensus;
+pub mod rpc;
+
+pub use self::{
+	consensus::ConsensusDataProvider,
+	error::Error,
+	finalize_block::{finalize_block, FinalizeBlockParams},
+	rpc::{CreatedBlock, EngineCommand},
+	seal_block::{seal_block, SealBlockParams, MAX_PROPOSAL_DURATION},
+};
+use sc_transaction_pool_api::TransactionPool;
+use sp_api::ProvideRuntimeApi;
+
+const LOG_TARGET: &str = "manual-seal";
+
+/// The `ConsensusEngineId` of Manual Seal.
+pub const MANUAL_SEAL_ENGINE_ID: ConsensusEngineId = [b'm', b'a', b'n', b'l'];
+
+/// The verifier for the manual seal engine; instantly finalizes.
+struct ManualSealVerifier;
+
+#[async_trait::async_trait]
+impl<B: BlockT> Verifier<B> for ManualSealVerifier {
+	async fn verify(
+		&mut self,
+		mut block: BlockImportParams<B>,
+	) -> Result<BlockImportParams<B>, String> {
+		block.finalized = false;
+		block.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+		Ok(block)
+	}
+}
+
+/// Instantiate the import queue for the manual seal consensus engine.
+pub fn import_queue<Block>(
+	block_import: BoxBlockImport<Block>,
+	spawner: &impl sp_core::traits::SpawnEssentialNamed,
+	registry: Option<&Registry>,
+) -> BasicQueue<Block>
+where
+	Block: BlockT,
+{
+	BasicQueue::new(ManualSealVerifier, block_import, None, spawner, registry)
+}
+
+/// Params required to start the instant sealing authorship task.
+pub struct ManualSealParams<B: BlockT, BI, E, C: ProvideRuntimeApi<B>, TP, SC, CS, CIDP, P> {
+	/// Block import instance.
+	pub block_import: BI,
+
+	/// The environment we are producing blocks for.
+	pub env: E,
+
+	/// Client instance
+	pub client: Arc<C>,
+
+	/// Shared reference to the transaction pool.
+	pub pool: Arc<TP>,
+
+	/// Stream<Item = EngineCommands>, Basically the receiving end of a channel for sending
+	/// commands to the authorship task.
+	pub commands_stream: CS,
+
+	/// SelectChain strategy.
+	pub select_chain: SC,
+
+	/// Digest provider for inclusion in blocks.
+	pub consensus_data_provider: Option<Box<dyn ConsensusDataProvider<B, Proof = P>>>,
+
+	/// Something that can create the inherent data providers.
+	pub create_inherent_data_providers: CIDP,
+}
+
+/// Params required to start the manual sealing authorship task.
+pub struct InstantSealParams<B: BlockT, BI, E, C: ProvideRuntimeApi<B>, TP, SC, CIDP, P> {
+	/// Block import instance for well. importing blocks.
+	pub block_import: BI,
+
+	/// The environment we are producing blocks for.
+	pub env: E,
+
+	/// Client instance
+	pub client: Arc<C>,
+
+	/// Shared reference to the transaction pool.
+	pub pool: Arc<TP>,
+
+	/// SelectChain strategy.
+	pub select_chain: SC,
+
+	/// Digest provider for inclusion in blocks.
+	pub consensus_data_provider: Option<Box<dyn ConsensusDataProvider<B, Proof = P>>>,
+
+	/// Something that can create the inherent data providers.
+	pub create_inherent_data_providers: CIDP,
+}
+
+/// Params required to start the delayed finalization task.
+pub struct DelayedFinalizeParams<C, S> {
+	/// Block import instance.
+	pub client: Arc<C>,
+
+	/// Handle for spawning delayed finalization tasks.
+	pub spawn_handle: S,
+
+	/// The delay in seconds before a block is finalized.
+	pub delay_sec: u64,
+}
+
+/// Creates the background authorship task for the manually seal engine.
+pub async fn run_manual_seal<B, BI, CB, E, C, TP, SC, CS, CIDP, P>(
+	ManualSealParams {
+		mut block_import,
+		mut env,
+		client,
+		pool,
+		mut commands_stream,
+		select_chain,
+		consensus_data_provider,
+		create_inherent_data_providers,
+	}: ManualSealParams<B, BI, E, C, TP, SC, CS, CIDP, P>,
+) where
+	B: BlockT + 'static,
+	BI: BlockImport<B, Error = sp_consensus::Error> + Send + Sync + 'static,
+	C: HeaderBackend<B> + Finalizer<B, CB> + ProvideRuntimeApi<B> + 'static,
+	CB: ClientBackend<B> + 'static,
+	E: Environment<B> + 'static,
+	E::Proposer: Proposer<B, Proof = P>,
+	CS: Stream<Item = EngineCommand<<B as BlockT>::Hash>> + Unpin + 'static,
+	SC: SelectChain<B> + 'static,
+	TP: TransactionPool<Block = B>,
+	CIDP: CreateInherentDataProviders<B, ()>,
+	P: codec::Encode + Send + Sync + 'static,
+{
+	while let Some(command) = commands_stream.next().await {
+		match command {
+			EngineCommand::SealNewBlock { create_empty, finalize, parent_hash, sender } => {
+				seal_block(SealBlockParams {
+					sender,
+					parent_hash,
+					finalize,
+					create_empty,
+					env: &mut env,
+					select_chain: &select_chain,
+					block_import: &mut block_import,
+					consensus_data_provider: consensus_data_provider.as_deref(),
+					pool: pool.clone(),
+					client: client.clone(),
+					create_inherent_data_providers: &create_inherent_data_providers,
+				})
+				.await;
+			},
+			EngineCommand::FinalizeBlock { hash, sender, justification } => {
+				let justification = justification.map(|j| (MANUAL_SEAL_ENGINE_ID, j));
+				finalize_block(FinalizeBlockParams {
+					hash,
+					sender,
+					justification,
+					finalizer: client.clone(),
+					_phantom: PhantomData,
+				})
+				.await
+			},
+		}
+	}
+}
+
+/// runs the background authorship task for the instant seal engine.
+/// instant-seal creates a new block for every transaction imported into
+/// the transaction pool.
+pub async fn run_instant_seal<B, BI, CB, E, C, TP, SC, CIDP, P>(
+	InstantSealParams {
+		block_import,
+		env,
+		client,
+		pool,
+		select_chain,
+		consensus_data_provider,
+		create_inherent_data_providers,
+	}: InstantSealParams<B, BI, E, C, TP, SC, CIDP, P>,
+) where
+	B: BlockT + 'static,
+	BI: BlockImport<B, Error = sp_consensus::Error> + Send + Sync + 'static,
+	C: HeaderBackend<B> + Finalizer<B, CB> + ProvideRuntimeApi<B> + 'static,
+	CB: ClientBackend<B> + 'static,
+	E: Environment<B> + 'static,
+	E::Proposer: Proposer<B, Proof = P>,
+	SC: SelectChain<B> + 'static,
+	TP: TransactionPool<Block = B>,
+	CIDP: CreateInherentDataProviders<B, ()>,
+	P: codec::Encode + Send + Sync + 'static,
+{
+	// instant-seal creates blocks as soon as transactions are imported
+	// into the transaction pool.
+	let commands_stream = pool.import_notification_stream().map(|_| EngineCommand::SealNewBlock {
+		create_empty: false,
+		finalize: false,
+		parent_hash: None,
+		sender: None,
+	});
+
+	run_manual_seal(ManualSealParams {
+		block_import,
+		env,
+		client,
+		pool,
+		commands_stream,
+		select_chain,
+		consensus_data_provider,
+		create_inherent_data_providers,
+	})
+	.await
+}
+
+/// Runs the background authorship task for the instant seal engine.
+/// instant-seal creates a new block for every transaction imported into
+/// the transaction pool.
+///
+/// This function will finalize the block immediately as well. If you don't
+/// want this behavior use `run_instant_seal` instead.
+pub async fn run_instant_seal_and_finalize<B, BI, CB, E, C, TP, SC, CIDP, P>(
+	InstantSealParams {
+		block_import,
+		env,
+		client,
+		pool,
+		select_chain,
+		consensus_data_provider,
+		create_inherent_data_providers,
+	}: InstantSealParams<B, BI, E, C, TP, SC, CIDP, P>,
+) where
+	B: BlockT + 'static,
+	BI: BlockImport<B, Error = sp_consensus::Error> + Send + Sync + 'static,
+	C: HeaderBackend<B> + Finalizer<B, CB> + ProvideRuntimeApi<B> + 'static,
+	CB: ClientBackend<B> + 'static,
+	E: Environment<B> + 'static,
+	E::Proposer: Proposer<B, Proof = P>,
+	SC: SelectChain<B> + 'static,
+	TP: TransactionPool<Block = B>,
+	CIDP: CreateInherentDataProviders<B, ()>,
+	P: codec::Encode + Send + Sync + 'static,
+{
+	// Creates and finalizes blocks as soon as transactions are imported
+	// into the transaction pool.
+	let commands_stream = pool.import_notification_stream().map(|_| EngineCommand::SealNewBlock {
+		create_empty: false,
+		finalize: true,
+		parent_hash: None,
+		sender: None,
+	});
+
+	run_manual_seal(ManualSealParams {
+		block_import,
+		env,
+		client,
+		pool,
+		commands_stream,
+		select_chain,
+		consensus_data_provider,
+		create_inherent_data_providers,
+	})
+	.await
+}
+
+/// Creates a future for delayed finalization of manual sealed blocks.
+///
+/// The future needs to be spawned in the background alongside the
+/// [`run_manual_seal`]/[`run_instant_seal`] future. It is required that
+/// [`EngineCommand::SealNewBlock`] is send with `finalize = false` to not finalize blocks directly
+/// after building them. This also means that delayed finality can not be used with
+/// [`run_instant_seal_and_finalize`].
+pub async fn run_delayed_finalize<B, CB, C, S>(
+	DelayedFinalizeParams { client, spawn_handle, delay_sec }: DelayedFinalizeParams<C, S>,
+) where
+	B: BlockT + 'static,
+	CB: ClientBackend<B> + 'static,
+	C: HeaderBackend<B> + Finalizer<B, CB> + ProvideRuntimeApi<B> + BlockchainEvents<B> + 'static,
+	S: SpawnNamed,
+{
+	let mut block_import_stream = client.import_notification_stream();
+
+	while let Some(notification) = block_import_stream.next().await {
+		let delay = Delay::new(Duration::from_secs(delay_sec));
+		let cloned_client = client.clone();
+		spawn_handle.spawn(
+			"delayed-finalize",
+			None,
+			Box::pin(async move {
+				delay.await;
+				finalize_block(FinalizeBlockParams {
+					hash: notification.hash,
+					sender: None,
+					justification: None,
+					finalizer: cloned_client,
+					_phantom: PhantomData,
+				})
+				.await
+			}),
+		);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_basic_authorship::ProposerFactory;
+	use sc_consensus::ImportedAux;
+	use sc_transaction_pool::{BasicPool, FullChainApi, Options, RevalidationType};
+	use sc_transaction_pool_api::{MaintainedTransactionPool, TransactionPool, TransactionSource};
+	use sp_inherents::InherentData;
+	use sp_runtime::generic::{BlockId, Digest, DigestItem};
+	use substrate_test_runtime_client::{
+		AccountKeyring::*, DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+	};
+	use substrate_test_runtime_transaction_pool::{uxt, TestApi};
+
+	fn api() -> Arc<TestApi> {
+		Arc::new(TestApi::empty())
+	}
+
+	const SOURCE: TransactionSource = TransactionSource::External;
+
+	struct TestDigestProvider<C> {
+		_client: Arc<C>,
+	}
+	impl<B, C> ConsensusDataProvider<B> for TestDigestProvider<C>
+	where
+		B: BlockT,
+		C: ProvideRuntimeApi<B> + Send + Sync,
+	{
+		type Proof = ();
+
+		fn create_digest(
+			&self,
+			_parent: &B::Header,
+			_inherents: &InherentData,
+		) -> Result<Digest, Error> {
+			Ok(Digest { logs: vec![] })
+		}
+
+		fn append_block_import(
+			&self,
+			_parent: &B::Header,
+			params: &mut BlockImportParams<B>,
+			_inherents: &InherentData,
+			_proof: Self::Proof,
+		) -> Result<(), Error> {
+			params.post_digests.push(DigestItem::Other(vec![1]));
+			Ok(())
+		}
+	}
+
+	#[tokio::test]
+	async fn instant_seal() {
+		let builder = TestClientBuilder::new();
+		let (client, select_chain) = builder.build_with_longest_chain();
+		let client = Arc::new(client);
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let genesis_hash = client.info().genesis_hash;
+		let pool = Arc::new(BasicPool::with_revalidation_type(
+			Options::default(),
+			true.into(),
+			api(),
+			None,
+			RevalidationType::Full,
+			spawner.clone(),
+			0,
+			genesis_hash,
+			genesis_hash,
+		));
+		let env = ProposerFactory::new(spawner.clone(), client.clone(), pool.clone(), None, None);
+		// this test checks that blocks are created as soon as transactions are imported into the
+		// pool.
+		let (sender, receiver) = futures::channel::oneshot::channel();
+		let mut sender = Arc::new(Some(sender));
+		let commands_stream =
+			pool.pool().validated_pool().import_notification_stream().map(move |_| {
+				// we're only going to submit one tx so this fn will only be called once.
+				let mut_sender = Arc::get_mut(&mut sender).unwrap();
+				let sender = std::mem::take(mut_sender);
+				EngineCommand::SealNewBlock {
+					create_empty: false,
+					finalize: true,
+					parent_hash: None,
+					sender,
+				}
+			});
+		let future = run_manual_seal(ManualSealParams {
+			block_import: client.clone(),
+			env,
+			client: client.clone(),
+			pool: pool.clone(),
+			commands_stream,
+			select_chain,
+			create_inherent_data_providers: |_, _| async { Ok(()) },
+			consensus_data_provider: None,
+		});
+		std::thread::spawn(|| {
+			let rt = tokio::runtime::Runtime::new().unwrap();
+			// spawn the background authorship task
+			rt.block_on(future);
+		});
+		// submit a transaction to pool.
+		let result = pool.submit_one(&BlockId::Number(0), SOURCE, uxt(Alice, 0)).await;
+		// assert that it was successfully imported
+		assert!(result.is_ok());
+		// assert that the background task returns ok
+		let created_block = receiver.await.unwrap().unwrap();
+		assert_eq!(
+			created_block,
+			CreatedBlock {
+				hash: created_block.hash,
+				aux: ImportedAux {
+					header_only: false,
+					clear_justification_requests: false,
+					needs_justification: false,
+					bad_justification: false,
+					is_new_best: true,
+				},
+				proof_size: 0
+			}
+		);
+		// assert that there's a new block in the db.
+		assert!(client.header(created_block.hash).unwrap().is_some());
+		assert_eq!(client.header(created_block.hash).unwrap().unwrap().number, 1)
+	}
+
+	#[tokio::test]
+	async fn instant_seal_delayed_finalize() {
+		let builder = TestClientBuilder::new();
+		let (client, select_chain) = builder.build_with_longest_chain();
+		let client = Arc::new(client);
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let genesis_hash = client.info().genesis_hash;
+		let pool = Arc::new(BasicPool::with_revalidation_type(
+			Options::default(),
+			true.into(),
+			api(),
+			None,
+			RevalidationType::Full,
+			spawner.clone(),
+			0,
+			genesis_hash,
+			genesis_hash,
+		));
+		let env = ProposerFactory::new(spawner.clone(), client.clone(), pool.clone(), None, None);
+		// this test checks that blocks are created as soon as transactions are imported into the
+		// pool.
+		let (sender, receiver) = futures::channel::oneshot::channel();
+		let mut sender = Arc::new(Some(sender));
+		let commands_stream =
+			pool.pool().validated_pool().import_notification_stream().map(move |_| {
+				// we're only going to submit one tx so this fn will only be called once.
+				let mut_sender = Arc::get_mut(&mut sender).unwrap();
+				let sender = std::mem::take(mut_sender);
+				EngineCommand::SealNewBlock {
+					create_empty: false,
+					// set to `false`, expecting to be finalized by delayed finalize
+					finalize: false,
+					parent_hash: None,
+					sender,
+				}
+			});
+
+		let future_instant_seal = run_manual_seal(ManualSealParams {
+			block_import: client.clone(),
+			commands_stream,
+			env,
+			client: client.clone(),
+			pool: pool.clone(),
+			select_chain,
+			create_inherent_data_providers: |_, _| async { Ok(()) },
+			consensus_data_provider: None,
+		});
+		std::thread::spawn(|| {
+			let rt = tokio::runtime::Runtime::new().unwrap();
+			// spawn the background authorship task
+			rt.block_on(future_instant_seal);
+		});
+
+		let delay_sec = 5;
+		let future_delayed_finalize = run_delayed_finalize(DelayedFinalizeParams {
+			client: client.clone(),
+			delay_sec,
+			spawn_handle: spawner,
+		});
+		std::thread::spawn(|| {
+			let rt = tokio::runtime::Runtime::new().unwrap();
+			// spawn the background authorship task
+			rt.block_on(future_delayed_finalize);
+		});
+
+		let mut finality_stream = client.finality_notification_stream();
+		// submit a transaction to pool.
+		let result = pool.submit_one(&BlockId::Number(0), SOURCE, uxt(Alice, 0)).await;
+		// assert that it was successfully imported
+		assert!(result.is_ok());
+		// assert that the background task returns ok
+		let created_block = receiver.await.unwrap().unwrap();
+		assert_eq!(
+			created_block,
+			CreatedBlock {
+				hash: created_block.hash,
+				aux: ImportedAux {
+					header_only: false,
+					clear_justification_requests: false,
+					needs_justification: false,
+					bad_justification: false,
+					is_new_best: true,
+				},
+				proof_size: created_block.proof_size
+			}
+		);
+		// assert that there's a new block in the db.
+		assert!(client.header(created_block.hash).unwrap().is_some());
+		assert_eq!(client.header(created_block.hash).unwrap().unwrap().number, 1);
+
+		assert_eq!(client.info().finalized_hash, client.info().genesis_hash);
+
+		let finalized = finality_stream.select_next_some().await;
+		assert_eq!(finalized.hash, created_block.hash);
+	}
+
+	#[tokio::test]
+	async fn manual_seal_and_finalization() {
+		let builder = TestClientBuilder::new();
+		let (client, select_chain) = builder.build_with_longest_chain();
+		let client = Arc::new(client);
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let genesis_hash = client.info().genesis_hash;
+		let pool = Arc::new(BasicPool::with_revalidation_type(
+			Options::default(),
+			true.into(),
+			api(),
+			None,
+			RevalidationType::Full,
+			spawner.clone(),
+			0,
+			genesis_hash,
+			genesis_hash,
+		));
+		let env = ProposerFactory::new(spawner.clone(), client.clone(), pool.clone(), None, None);
+		// this test checks that blocks are created as soon as an engine command is sent over the
+		// stream.
+		let (mut sink, commands_stream) = futures::channel::mpsc::channel(1024);
+		let future = run_manual_seal(ManualSealParams {
+			block_import: client.clone(),
+			env,
+			client: client.clone(),
+			pool: pool.clone(),
+			commands_stream,
+			select_chain,
+			consensus_data_provider: None,
+			create_inherent_data_providers: |_, _| async { Ok(()) },
+		});
+		std::thread::spawn(|| {
+			let rt = tokio::runtime::Runtime::new().unwrap();
+			// spawn the background authorship task
+			rt.block_on(future);
+		});
+		// submit a transaction to pool.
+		let result = pool.submit_one(&BlockId::Number(0), SOURCE, uxt(Alice, 0)).await;
+		// assert that it was successfully imported
+		assert!(result.is_ok());
+		let (tx, rx) = futures::channel::oneshot::channel();
+		sink.send(EngineCommand::SealNewBlock {
+			parent_hash: None,
+			sender: Some(tx),
+			create_empty: false,
+			finalize: false,
+		})
+		.await
+		.unwrap();
+		let created_block = rx.await.unwrap().unwrap();
+
+		// assert that the background task returns ok
+		assert_eq!(
+			created_block,
+			CreatedBlock {
+				hash: created_block.hash,
+				aux: ImportedAux {
+					header_only: false,
+					clear_justification_requests: false,
+					needs_justification: false,
+					bad_justification: false,
+					is_new_best: true,
+				},
+				proof_size: 0
+			}
+		);
+		// assert that there's a new block in the db.
+		let header = client.header(created_block.hash).unwrap().unwrap();
+		let (tx, rx) = futures::channel::oneshot::channel();
+		sink.send(EngineCommand::FinalizeBlock {
+			sender: Some(tx),
+			hash: header.hash(),
+			justification: None,
+		})
+		.await
+		.unwrap();
+		// check that the background task returns ok:
+		rx.await.unwrap().unwrap();
+	}
+
+	#[tokio::test]
+	async fn manual_seal_fork_blocks() {
+		let builder = TestClientBuilder::new();
+		let (client, select_chain) = builder.build_with_longest_chain();
+		let client = Arc::new(client);
+		let pool_api = Arc::new(FullChainApi::new(
+			client.clone(),
+			None,
+			&sp_core::testing::TaskExecutor::new(),
+		));
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let genesis_hash = client.info().genesis_hash;
+		let pool = Arc::new(BasicPool::with_revalidation_type(
+			Options::default(),
+			true.into(),
+			pool_api.clone(),
+			None,
+			RevalidationType::Full,
+			spawner.clone(),
+			0,
+			genesis_hash,
+			genesis_hash,
+		));
+		let env = ProposerFactory::new(spawner.clone(), client.clone(), pool.clone(), None, None);
+		// this test checks that blocks are created as soon as an engine command is sent over the
+		// stream.
+		let (mut sink, commands_stream) = futures::channel::mpsc::channel(1024);
+		let future = run_manual_seal(ManualSealParams {
+			block_import: client.clone(),
+			env,
+			client: client.clone(),
+			pool: pool.clone(),
+			commands_stream,
+			select_chain,
+			consensus_data_provider: None,
+			create_inherent_data_providers: |_, _| async { Ok(()) },
+		});
+		std::thread::spawn(|| {
+			let rt = tokio::runtime::Runtime::new().unwrap();
+			// spawn the background authorship task
+			rt.block_on(future);
+		});
+		// submit a transaction to pool.
+		let result = pool.submit_one(&BlockId::Number(0), SOURCE, uxt(Alice, 0)).await;
+		// assert that it was successfully imported
+		assert!(result.is_ok());
+
+		let (tx, rx) = futures::channel::oneshot::channel();
+		sink.send(EngineCommand::SealNewBlock {
+			parent_hash: None,
+			sender: Some(tx),
+			create_empty: false,
+			finalize: false,
+		})
+		.await
+		.unwrap();
+		let created_block = rx.await.unwrap().unwrap();
+
+		// assert that the background task returns ok
+		assert_eq!(
+			created_block,
+			CreatedBlock {
+				hash: created_block.hash,
+				aux: ImportedAux {
+					header_only: false,
+					clear_justification_requests: false,
+					needs_justification: false,
+					bad_justification: false,
+					is_new_best: true
+				},
+				proof_size: 0
+			}
+		);
+
+		assert!(pool.submit_one(&BlockId::Number(1), SOURCE, uxt(Alice, 1)).await.is_ok());
+
+		let header = client.header(created_block.hash).expect("db error").expect("imported above");
+		assert_eq!(header.number, 1);
+		pool.maintain(sc_transaction_pool_api::ChainEvent::NewBestBlock {
+			hash: header.hash(),
+			tree_route: None,
+		})
+		.await;
+
+		let (tx1, rx1) = futures::channel::oneshot::channel();
+		assert!(sink
+			.send(EngineCommand::SealNewBlock {
+				parent_hash: Some(created_block.hash),
+				sender: Some(tx1),
+				create_empty: false,
+				finalize: false,
+			})
+			.await
+			.is_ok());
+		assert_matches::assert_matches!(rx1.await.expect("should be no error receiving"), Ok(_));
+
+		assert!(pool.submit_one(&BlockId::Number(1), SOURCE, uxt(Bob, 0)).await.is_ok());
+		let (tx2, rx2) = futures::channel::oneshot::channel();
+		assert!(sink
+			.send(EngineCommand::SealNewBlock {
+				parent_hash: Some(created_block.hash),
+				sender: Some(tx2),
+				create_empty: false,
+				finalize: false,
+			})
+			.await
+			.is_ok());
+		let imported = rx2.await.unwrap().unwrap();
+		// assert that fork block is in the db
+		assert!(client.header(imported.hash).unwrap().is_some())
+	}
+
+	#[tokio::test]
+	async fn manual_seal_post_hash() {
+		let builder = TestClientBuilder::new();
+		let (client, select_chain) = builder.build_with_longest_chain();
+		let client = Arc::new(client);
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let genesis_hash = client.header(client.info().genesis_hash).unwrap().unwrap().hash();
+		let pool = Arc::new(BasicPool::with_revalidation_type(
+			Options::default(),
+			true.into(),
+			api(),
+			None,
+			RevalidationType::Full,
+			spawner.clone(),
+			0,
+			genesis_hash,
+			genesis_hash,
+		));
+		let env = ProposerFactory::new(spawner.clone(), client.clone(), pool.clone(), None, None);
+
+		let (mut sink, commands_stream) = futures::channel::mpsc::channel(1024);
+		let future = run_manual_seal(ManualSealParams {
+			block_import: client.clone(),
+			env,
+			client: client.clone(),
+			pool: pool.clone(),
+			commands_stream,
+			select_chain,
+			// use a provider that pushes some post digest data
+			consensus_data_provider: Some(Box::new(TestDigestProvider { _client: client.clone() })),
+			create_inherent_data_providers: |_, _| async { Ok(()) },
+		});
+		std::thread::spawn(|| {
+			let rt = tokio::runtime::Runtime::new().unwrap();
+			rt.block_on(future);
+		});
+		let (tx, rx) = futures::channel::oneshot::channel();
+		sink.send(EngineCommand::SealNewBlock {
+			parent_hash: None,
+			sender: Some(tx),
+			create_empty: true,
+			finalize: false,
+		})
+		.await
+		.unwrap();
+		let created_block = rx.await.unwrap().unwrap();
+
+		// assert that the background task returned the actual header hash
+		let header = client.header(created_block.hash).unwrap().unwrap();
+		assert_eq!(header.number, 1);
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/src/rpc.rs b/substrate/client/consensus/manual-seal/src/rpc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c0b3af69bedf40884598c19eea16defbdf1ae679
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/rpc.rs
@@ -0,0 +1,172 @@
+// 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/>.
+
+//! RPC interface for the `ManualSeal` Engine.
+
+use crate::error::Error;
+use futures::{
+	channel::{mpsc, oneshot},
+	SinkExt,
+};
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError, RpcResult},
+	proc_macros::rpc,
+};
+use sc_consensus::ImportedAux;
+use serde::{Deserialize, Serialize};
+use sp_runtime::EncodedJustification;
+
+/// Sender passed to the authorship task to report errors or successes.
+pub type Sender<T> = Option<oneshot::Sender<std::result::Result<T, Error>>>;
+
+/// Message sent to the background authorship task, usually by RPC.
+pub enum EngineCommand<Hash> {
+	/// Tells the engine to propose a new block
+	///
+	/// if create_empty == true, it will create empty blocks if there are no transactions
+	/// in the transaction pool.
+	///
+	/// if finalize == true, the block will be instantly finalized.
+	SealNewBlock {
+		/// if true, empty blocks(without extrinsics) will be created.
+		/// otherwise, will return Error::EmptyTransactionPool.
+		create_empty: bool,
+		/// instantly finalize this block?
+		finalize: bool,
+		/// specify the parent hash of the about-to-created block
+		parent_hash: Option<Hash>,
+		/// sender to report errors/success to the rpc.
+		sender: Sender<CreatedBlock<Hash>>,
+	},
+	/// Tells the engine to finalize the block with the supplied hash
+	FinalizeBlock {
+		/// hash of the block
+		hash: Hash,
+		/// sender to report errors/success to the rpc.
+		sender: Sender<()>,
+		/// finalization justification
+		justification: Option<EncodedJustification>,
+	},
+}
+
+/// RPC trait that provides methods for interacting with the manual-seal authorship task over rpc.
+#[rpc(client, server)]
+pub trait ManualSealApi<Hash> {
+	/// Instructs the manual-seal authorship task to create a new block
+	#[method(name = "engine_createBlock")]
+	async fn create_block(
+		&self,
+		create_empty: bool,
+		finalize: bool,
+		parent_hash: Option<Hash>,
+	) -> RpcResult<CreatedBlock<Hash>>;
+
+	/// Instructs the manual-seal authorship task to finalize a block
+	#[method(name = "engine_finalizeBlock")]
+	async fn finalize_block(
+		&self,
+		hash: Hash,
+		justification: Option<EncodedJustification>,
+	) -> RpcResult<bool>;
+}
+
+/// A struct that implements the [`ManualSealApiServer`].
+pub struct ManualSeal<Hash> {
+	import_block_channel: mpsc::Sender<EngineCommand<Hash>>,
+}
+
+/// return type of `engine_createBlock`
+#[derive(Debug, Deserialize, Serialize, PartialEq, Eq)]
+pub struct CreatedBlock<Hash> {
+	/// hash of the created block.
+	pub hash: Hash,
+	/// some extra details about the import operation
+	pub aux: ImportedAux,
+	/// uncompacted storage proof size (zero mean that there is no proof)
+	pub proof_size: usize,
+}
+
+impl<Hash> ManualSeal<Hash> {
+	/// Create new `ManualSeal` with the given reference to the client.
+	pub fn new(import_block_channel: mpsc::Sender<EngineCommand<Hash>>) -> Self {
+		Self { import_block_channel }
+	}
+}
+
+#[async_trait]
+impl<Hash: Send + 'static> ManualSealApiServer<Hash> for ManualSeal<Hash> {
+	async fn create_block(
+		&self,
+		create_empty: bool,
+		finalize: bool,
+		parent_hash: Option<Hash>,
+	) -> RpcResult<CreatedBlock<Hash>> {
+		let mut sink = self.import_block_channel.clone();
+		let (sender, receiver) = oneshot::channel();
+		// NOTE: this sends a Result over the channel.
+		let command = EngineCommand::SealNewBlock {
+			create_empty,
+			finalize,
+			parent_hash,
+			sender: Some(sender),
+		};
+
+		sink.send(command).await?;
+
+		match receiver.await {
+			Ok(Ok(rx)) => Ok(rx),
+			Ok(Err(e)) => Err(e.into()),
+			Err(e) => Err(JsonRpseeError::to_call_error(e)),
+		}
+	}
+
+	async fn finalize_block(
+		&self,
+		hash: Hash,
+		justification: Option<EncodedJustification>,
+	) -> RpcResult<bool> {
+		let mut sink = self.import_block_channel.clone();
+		let (sender, receiver) = oneshot::channel();
+		let command = EngineCommand::FinalizeBlock { hash, sender: Some(sender), justification };
+		sink.send(command).await?;
+		receiver.await.map(|_| true).map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+}
+
+/// report any errors or successes encountered by the authorship task back
+/// to the rpc
+pub fn send_result<T: std::fmt::Debug>(
+	sender: &mut Sender<T>,
+	result: std::result::Result<T, crate::Error>,
+) {
+	if let Some(sender) = sender.take() {
+		if let Err(err) = sender.send(result) {
+			match err {
+				Ok(value) => log::warn!("Server is shutting down: {:?}", value),
+				Err(error) => log::warn!("Server is shutting down with error: {}", error),
+			}
+		}
+	} else {
+		// Sealing/Finalization with no RPC sender such as instant seal or delayed finalize doesn't
+		// report errors over rpc, simply log them.
+		match result {
+			Ok(r) => log::info!("Consensus with no RPC sender success: {:?}", r),
+			Err(e) => log::error!("Consensus with no RPC sender encountered an error: {}", e),
+		}
+	}
+}
diff --git a/substrate/client/consensus/manual-seal/src/seal_block.rs b/substrate/client/consensus/manual-seal/src/seal_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..716e889ec0395436a2e0a2cdc7a4a5cd056bdc28
--- /dev/null
+++ b/substrate/client/consensus/manual-seal/src/seal_block.rs
@@ -0,0 +1,163 @@
+// 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/>.
+
+//! Block sealing utilities
+
+use crate::{rpc, ConsensusDataProvider, CreatedBlock, Error};
+use futures::prelude::*;
+use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy, ImportResult, StateAction};
+use sc_transaction_pool_api::TransactionPool;
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::HeaderBackend;
+use sp_consensus::{self, BlockOrigin, Environment, Proposer, SelectChain};
+use sp_inherents::{CreateInherentDataProviders, InherentDataProvider};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use std::{sync::Arc, time::Duration};
+
+/// max duration for creating a proposal in secs
+pub const MAX_PROPOSAL_DURATION: u64 = 10;
+
+/// params for sealing a new block
+pub struct SealBlockParams<'a, B: BlockT, BI, SC, C: ProvideRuntimeApi<B>, E, TP, CIDP, P> {
+	/// if true, empty blocks(without extrinsics) will be created.
+	/// otherwise, will return Error::EmptyTransactionPool.
+	pub create_empty: bool,
+	/// instantly finalize this block?
+	pub finalize: bool,
+	/// specify the parent hash of the about-to-created block
+	pub parent_hash: Option<<B as BlockT>::Hash>,
+	/// sender to report errors/success to the rpc.
+	pub sender: rpc::Sender<CreatedBlock<<B as BlockT>::Hash>>,
+	/// transaction pool
+	pub pool: Arc<TP>,
+	/// header backend
+	pub client: Arc<C>,
+	/// Environment trait object for creating a proposer
+	pub env: &'a mut E,
+	/// SelectChain object
+	pub select_chain: &'a SC,
+	/// Digest provider for inclusion in blocks.
+	pub consensus_data_provider: Option<&'a dyn ConsensusDataProvider<B, Proof = P>>,
+	/// block import object
+	pub block_import: &'a mut BI,
+	/// Something that can create the inherent data providers.
+	pub create_inherent_data_providers: &'a CIDP,
+}
+
+/// seals a new block with the given params
+pub async fn seal_block<B, BI, SC, C, E, TP, CIDP, P>(
+	SealBlockParams {
+		create_empty,
+		finalize,
+		pool,
+		parent_hash,
+		client,
+		select_chain,
+		block_import,
+		env,
+		create_inherent_data_providers,
+		consensus_data_provider: digest_provider,
+		mut sender,
+	}: SealBlockParams<'_, B, BI, SC, C, E, TP, CIDP, P>,
+) where
+	B: BlockT,
+	BI: BlockImport<B, Error = sp_consensus::Error> + Send + Sync + 'static,
+	C: HeaderBackend<B> + ProvideRuntimeApi<B>,
+	E: Environment<B>,
+	E::Proposer: Proposer<B, Proof = P>,
+	TP: TransactionPool<Block = B>,
+	SC: SelectChain<B>,
+	CIDP: CreateInherentDataProviders<B, ()>,
+	P: codec::Encode + Send + Sync + 'static,
+{
+	let future = async {
+		if pool.status().ready == 0 && !create_empty {
+			return Err(Error::EmptyTransactionPool)
+		}
+
+		// get the header to build this new block on.
+		// use the parent_hash supplied via `EngineCommand`
+		// or fetch the best_block.
+		let parent = match parent_hash {
+			Some(hash) =>
+				client.header(hash)?.ok_or_else(|| Error::BlockNotFound(format!("{}", hash)))?,
+			None => select_chain.best_chain().await?,
+		};
+
+		let inherent_data_providers = create_inherent_data_providers
+			.create_inherent_data_providers(parent.hash(), ())
+			.await
+			.map_err(|e| Error::Other(e))?;
+
+		let inherent_data = inherent_data_providers.create_inherent_data().await?;
+
+		let proposer = env.init(&parent).map_err(|err| Error::StringError(err.to_string())).await?;
+		let inherents_len = inherent_data.len();
+
+		let digest = if let Some(digest_provider) = digest_provider {
+			digest_provider.create_digest(&parent, &inherent_data)?
+		} else {
+			Default::default()
+		};
+
+		let proposal = proposer
+			.propose(
+				inherent_data.clone(),
+				digest,
+				Duration::from_secs(MAX_PROPOSAL_DURATION),
+				None,
+			)
+			.map_err(|err| Error::StringError(err.to_string()))
+			.await?;
+
+		if proposal.block.extrinsics().len() == inherents_len && !create_empty {
+			return Err(Error::EmptyTransactionPool)
+		}
+
+		let (header, body) = proposal.block.deconstruct();
+		let proof = proposal.proof;
+		let proof_size = proof.encoded_size();
+		let mut params = BlockImportParams::new(BlockOrigin::Own, header.clone());
+		params.body = Some(body);
+		params.finalized = finalize;
+		params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+		params.state_action = StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(
+			proposal.storage_changes,
+		));
+
+		if let Some(digest_provider) = digest_provider {
+			digest_provider.append_block_import(&parent, &mut params, &inherent_data, proof)?;
+		}
+
+		// Make sure we return the same post-hash that will be calculated when importing the block
+		// This is important in case the digest_provider added any signature, seal, ect.
+		let mut post_header = header.clone();
+		post_header.digest_mut().logs.extend(params.post_digests.iter().cloned());
+
+		match block_import.import_block(params).await? {
+			ImportResult::Imported(aux) => Ok(CreatedBlock {
+				hash: <B as BlockT>::Header::hash(&post_header),
+				aux,
+				proof_size,
+			}),
+			other => Err(other.into()),
+		}
+	};
+
+	rpc::send_result(&mut sender, future.await)
+}
diff --git a/substrate/client/consensus/pow/Cargo.toml b/substrate/client/consensus/pow/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..91c9754508591cde3e248023ca7d79d9b4da6860
--- /dev/null
+++ b/substrate/client/consensus/pow/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "sc-consensus-pow"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "PoW consensus algorithm for substrate"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+futures = "0.3.21"
+futures-timer = "3.0.1"
+log = "0.4.17"
+parking_lot = "0.12.1"
+thiserror = "1.0"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../../primitives/block-builder" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-pow = { version = "0.10.0-dev", path = "../../../primitives/consensus/pow" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
diff --git a/substrate/client/consensus/pow/README.md b/substrate/client/consensus/pow/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8dba30fc5a38e64ada65f068f327143eb40962b3
--- /dev/null
+++ b/substrate/client/consensus/pow/README.md
@@ -0,0 +1,24 @@
+Proof of work consensus for Substrate.
+
+To use this engine, you can need to have a struct that implements
+`PowAlgorithm`. After that, pass an instance of the struct, along
+with other necessary client references to `import_queue` to setup
+the queue.
+
+This library also comes with an async mining worker, which can be
+started via the `start_mining_worker` function. It returns a worker
+handle together with a future. The future must be pulled. Through
+the worker handle, you can pull the metadata needed to start the
+mining process via `MiningWorker::metadata`, and then do the actual
+mining on a standalone thread. Finally, when a seal is found, call
+`MiningWorker::submit` to build the block.
+
+The auxiliary storage for PoW engine only stores the total difficulty.
+For other storage requirements for particular PoW algorithm (such as
+the actual difficulty for each particular blocks), you can take a client
+reference in your `PowAlgorithm` implementation, and use a separate prefix
+for the auxiliary storage. It is also possible to just use the runtime
+as the storage, but it is not recommended as it won't work well with light
+clients.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
diff --git a/substrate/client/consensus/pow/src/lib.rs b/substrate/client/consensus/pow/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee5c1dfc6f11a26599c0f01efee9224caded43cd
--- /dev/null
+++ b/substrate/client/consensus/pow/src/lib.rs
@@ -0,0 +1,679 @@
+// 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/>.
+
+//! Proof of work consensus for Substrate.
+//!
+//! To use this engine, you can need to have a struct that implements
+//! [`PowAlgorithm`]. After that, pass an instance of the struct, along
+//! with other necessary client references to [`import_queue`] to setup
+//! the queue.
+//!
+//! This library also comes with an async mining worker, which can be
+//! started via the [`start_mining_worker`] function. It returns a worker
+//! handle together with a future. The future must be pulled. Through
+//! the worker handle, you can pull the metadata needed to start the
+//! mining process via [`MiningHandle::metadata`], and then do the actual
+//! mining on a standalone thread. Finally, when a seal is found, call
+//! [`MiningHandle::submit`] to build the block.
+//!
+//! The auxiliary storage for PoW engine only stores the total difficulty.
+//! For other storage requirements for particular PoW algorithm (such as
+//! the actual difficulty for each particular blocks), you can take a client
+//! reference in your [`PowAlgorithm`] implementation, and use a separate prefix
+//! for the auxiliary storage. It is also possible to just use the runtime
+//! as the storage, but it is not recommended as it won't work well with light
+//! clients.
+
+mod worker;
+
+pub use crate::worker::{MiningBuild, MiningHandle, MiningMetadata};
+
+use crate::worker::UntilImportedOrTimeout;
+use codec::{Decode, Encode};
+use futures::{Future, StreamExt};
+use log::*;
+use prometheus_endpoint::Registry;
+use sc_client_api::{self, backend::AuxStore, BlockOf, BlockchainEvents};
+use sc_consensus::{
+	BasicQueue, BlockCheckParams, BlockImport, BlockImportParams, BoxBlockImport,
+	BoxJustificationImport, ForkChoiceStrategy, ImportResult, Verifier,
+};
+use sp_api::ProvideRuntimeApi;
+use sp_block_builder::BlockBuilder as BlockBuilderApi;
+use sp_blockchain::HeaderBackend;
+use sp_consensus::{Environment, Error as ConsensusError, Proposer, SelectChain, SyncOracle};
+use sp_consensus_pow::{Seal, TotalDifficulty, POW_ENGINE_ID};
+use sp_inherents::{CreateInherentDataProviders, InherentDataProvider};
+use sp_runtime::{
+	generic::{BlockId, Digest, DigestItem},
+	traits::{Block as BlockT, Header as HeaderT},
+	RuntimeString,
+};
+use std::{cmp::Ordering, marker::PhantomData, sync::Arc, time::Duration};
+
+const LOG_TARGET: &str = "pow";
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error<B: BlockT> {
+	#[error("Header uses the wrong engine {0:?}")]
+	WrongEngine([u8; 4]),
+	#[error("Header {0:?} is unsealed")]
+	HeaderUnsealed(B::Hash),
+	#[error("PoW validation error: invalid seal")]
+	InvalidSeal,
+	#[error("PoW validation error: preliminary verification failed")]
+	FailedPreliminaryVerify,
+	#[error("Rejecting block too far in future")]
+	TooFarInFuture,
+	#[error("Fetching best header failed using select chain: {0}")]
+	BestHeaderSelectChain(ConsensusError),
+	#[error("Fetching best header failed: {0}")]
+	BestHeader(sp_blockchain::Error),
+	#[error("Best header does not exist")]
+	NoBestHeader,
+	#[error("Block proposing error: {0}")]
+	BlockProposingError(String),
+	#[error("Fetch best hash failed via select chain: {0}")]
+	BestHashSelectChain(ConsensusError),
+	#[error("Error with block built on {0:?}: {1}")]
+	BlockBuiltError(B::Hash, ConsensusError),
+	#[error("Creating inherents failed: {0}")]
+	CreateInherents(sp_inherents::Error),
+	#[error("Checking inherents failed: {0}")]
+	CheckInherents(sp_inherents::Error),
+	#[error(
+		"Checking inherents unknown error for identifier: {}",
+		String::from_utf8_lossy(.0)
+	)]
+	CheckInherentsUnknownError(sp_inherents::InherentIdentifier),
+	#[error("Multiple pre-runtime digests")]
+	MultiplePreRuntimeDigests,
+	#[error(transparent)]
+	Client(sp_blockchain::Error),
+	#[error(transparent)]
+	Codec(codec::Error),
+	#[error("{0}")]
+	Environment(String),
+	#[error("{0}")]
+	Runtime(RuntimeString),
+	#[error("{0}")]
+	Other(String),
+}
+
+impl<B: BlockT> From<Error<B>> for String {
+	fn from(error: Error<B>) -> String {
+		error.to_string()
+	}
+}
+
+impl<B: BlockT> From<Error<B>> for ConsensusError {
+	fn from(error: Error<B>) -> ConsensusError {
+		ConsensusError::ClientImport(error.to_string())
+	}
+}
+
+/// Auxiliary storage prefix for PoW engine.
+pub const POW_AUX_PREFIX: [u8; 4] = *b"PoW:";
+
+/// Get the auxiliary storage key used by engine to store total difficulty.
+fn aux_key<T: AsRef<[u8]>>(hash: &T) -> Vec<u8> {
+	POW_AUX_PREFIX.iter().chain(hash.as_ref()).copied().collect()
+}
+
+/// Intermediate value passed to block importer.
+#[derive(Encode, Decode, Clone, Debug, Default)]
+pub struct PowIntermediate<Difficulty> {
+	/// Difficulty of the block, if known.
+	pub difficulty: Option<Difficulty>,
+}
+
+/// Intermediate key for PoW engine.
+pub static INTERMEDIATE_KEY: &[u8] = b"pow1";
+
+/// Auxiliary storage data for PoW.
+#[derive(Encode, Decode, Clone, Debug, Default)]
+pub struct PowAux<Difficulty> {
+	/// Difficulty of the current block.
+	pub difficulty: Difficulty,
+	/// Total difficulty up to current block.
+	pub total_difficulty: Difficulty,
+}
+
+impl<Difficulty> PowAux<Difficulty>
+where
+	Difficulty: Decode + Default,
+{
+	/// Read the auxiliary from client.
+	pub fn read<C: AuxStore, B: BlockT>(client: &C, hash: &B::Hash) -> Result<Self, Error<B>> {
+		let key = aux_key(&hash);
+
+		match client.get_aux(&key).map_err(Error::Client)? {
+			Some(bytes) => Self::decode(&mut &bytes[..]).map_err(Error::Codec),
+			None => Ok(Self::default()),
+		}
+	}
+}
+
+/// Algorithm used for proof of work.
+pub trait PowAlgorithm<B: BlockT> {
+	/// Difficulty for the algorithm.
+	type Difficulty: TotalDifficulty + Default + Encode + Decode + Ord + Clone + Copy;
+
+	/// Get the next block's difficulty.
+	///
+	/// This function will be called twice during the import process, so the implementation
+	/// should be properly cached.
+	fn difficulty(&self, parent: B::Hash) -> Result<Self::Difficulty, Error<B>>;
+	/// Verify that the seal is valid against given pre hash when parent block is not yet imported.
+	///
+	/// None means that preliminary verify is not available for this algorithm.
+	fn preliminary_verify(
+		&self,
+		_pre_hash: &B::Hash,
+		_seal: &Seal,
+	) -> Result<Option<bool>, Error<B>> {
+		Ok(None)
+	}
+	/// Break a fork choice tie.
+	///
+	/// By default this chooses the earliest block seen. Using uniform tie
+	/// breaking algorithms will help to protect against selfish mining.
+	///
+	/// Returns if the new seal should be considered best block.
+	fn break_tie(&self, _own_seal: &Seal, _new_seal: &Seal) -> bool {
+		false
+	}
+	/// Verify that the difficulty is valid against given seal.
+	fn verify(
+		&self,
+		parent: &BlockId<B>,
+		pre_hash: &B::Hash,
+		pre_digest: Option<&[u8]>,
+		seal: &Seal,
+		difficulty: Self::Difficulty,
+	) -> Result<bool, Error<B>>;
+}
+
+/// A block importer for PoW.
+pub struct PowBlockImport<B: BlockT, I, C, S, Algorithm, CIDP> {
+	algorithm: Algorithm,
+	inner: I,
+	select_chain: S,
+	client: Arc<C>,
+	create_inherent_data_providers: Arc<CIDP>,
+	check_inherents_after: <<B as BlockT>::Header as HeaderT>::Number,
+}
+
+impl<B: BlockT, I: Clone, C, S: Clone, Algorithm: Clone, CIDP> Clone
+	for PowBlockImport<B, I, C, S, Algorithm, CIDP>
+{
+	fn clone(&self) -> Self {
+		Self {
+			algorithm: self.algorithm.clone(),
+			inner: self.inner.clone(),
+			select_chain: self.select_chain.clone(),
+			client: self.client.clone(),
+			create_inherent_data_providers: self.create_inherent_data_providers.clone(),
+			check_inherents_after: self.check_inherents_after,
+		}
+	}
+}
+
+impl<B, I, C, S, Algorithm, CIDP> PowBlockImport<B, I, C, S, Algorithm, CIDP>
+where
+	B: BlockT,
+	I: BlockImport<B> + Send + Sync,
+	I::Error: Into<ConsensusError>,
+	C: ProvideRuntimeApi<B> + Send + Sync + HeaderBackend<B> + AuxStore + BlockOf,
+	C::Api: BlockBuilderApi<B>,
+	Algorithm: PowAlgorithm<B>,
+	CIDP: CreateInherentDataProviders<B, ()>,
+{
+	/// Create a new block import suitable to be used in PoW
+	pub fn new(
+		inner: I,
+		client: Arc<C>,
+		algorithm: Algorithm,
+		check_inherents_after: <<B as BlockT>::Header as HeaderT>::Number,
+		select_chain: S,
+		create_inherent_data_providers: CIDP,
+	) -> Self {
+		Self {
+			inner,
+			client,
+			algorithm,
+			check_inherents_after,
+			select_chain,
+			create_inherent_data_providers: Arc::new(create_inherent_data_providers),
+		}
+	}
+
+	async fn check_inherents(
+		&self,
+		block: B,
+		at_hash: B::Hash,
+		inherent_data_providers: CIDP::InherentDataProviders,
+	) -> Result<(), Error<B>> {
+		if *block.header().number() < self.check_inherents_after {
+			return Ok(())
+		}
+
+		let inherent_data = inherent_data_providers
+			.create_inherent_data()
+			.await
+			.map_err(|e| Error::CreateInherents(e))?;
+
+		let inherent_res = self
+			.client
+			.runtime_api()
+			.check_inherents(at_hash, block, inherent_data)
+			.map_err(|e| Error::Client(e.into()))?;
+
+		if !inherent_res.ok() {
+			for (identifier, error) in inherent_res.into_errors() {
+				match inherent_data_providers.try_handle_error(&identifier, &error).await {
+					Some(res) => res.map_err(Error::CheckInherents)?,
+					None => return Err(Error::CheckInherentsUnknownError(identifier)),
+				}
+			}
+		}
+
+		Ok(())
+	}
+}
+
+#[async_trait::async_trait]
+impl<B, I, C, S, Algorithm, CIDP> BlockImport<B> for PowBlockImport<B, I, C, S, Algorithm, CIDP>
+where
+	B: BlockT,
+	I: BlockImport<B> + Send + Sync,
+	I::Error: Into<ConsensusError>,
+	S: SelectChain<B>,
+	C: ProvideRuntimeApi<B> + Send + Sync + HeaderBackend<B> + AuxStore + BlockOf,
+	C::Api: BlockBuilderApi<B>,
+	Algorithm: PowAlgorithm<B> + Send + Sync,
+	Algorithm::Difficulty: 'static + Send,
+	CIDP: CreateInherentDataProviders<B, ()> + Send + Sync,
+{
+	type Error = ConsensusError;
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<B>,
+	) -> Result<ImportResult, Self::Error> {
+		self.inner.check_block(block).await.map_err(Into::into)
+	}
+
+	async fn import_block(
+		&mut self,
+		mut block: BlockImportParams<B>,
+	) -> Result<ImportResult, Self::Error> {
+		let best_header = self
+			.select_chain
+			.best_chain()
+			.await
+			.map_err(|e| format!("Fetch best chain failed via select chain: {}", e))
+			.map_err(ConsensusError::ChainLookup)?;
+		let best_hash = best_header.hash();
+
+		let parent_hash = *block.header.parent_hash();
+		let best_aux = PowAux::read::<_, B>(self.client.as_ref(), &best_hash)?;
+		let mut aux = PowAux::read::<_, B>(self.client.as_ref(), &parent_hash)?;
+
+		if let Some(inner_body) = block.body.take() {
+			let check_block = B::new(block.header.clone(), inner_body);
+
+			if !block.state_action.skip_execution_checks() {
+				self.check_inherents(
+					check_block.clone(),
+					parent_hash,
+					self.create_inherent_data_providers
+						.create_inherent_data_providers(parent_hash, ())
+						.await?,
+				)
+				.await?;
+			}
+
+			block.body = Some(check_block.deconstruct().1);
+		}
+
+		let inner_seal = fetch_seal::<B>(block.post_digests.last(), block.header.hash())?;
+
+		let intermediate = block
+			.remove_intermediate::<PowIntermediate<Algorithm::Difficulty>>(INTERMEDIATE_KEY)?;
+
+		let difficulty = match intermediate.difficulty {
+			Some(difficulty) => difficulty,
+			None => self.algorithm.difficulty(parent_hash)?,
+		};
+
+		let pre_hash = block.header.hash();
+		let pre_digest = find_pre_digest::<B>(&block.header)?;
+		if !self.algorithm.verify(
+			&BlockId::hash(parent_hash),
+			&pre_hash,
+			pre_digest.as_ref().map(|v| &v[..]),
+			&inner_seal,
+			difficulty,
+		)? {
+			return Err(Error::<B>::InvalidSeal.into())
+		}
+
+		aux.difficulty = difficulty;
+		aux.total_difficulty.increment(difficulty);
+
+		let key = aux_key(&block.post_hash());
+		block.auxiliary.push((key, Some(aux.encode())));
+		if block.fork_choice.is_none() {
+			block.fork_choice = Some(ForkChoiceStrategy::Custom(
+				match aux.total_difficulty.cmp(&best_aux.total_difficulty) {
+					Ordering::Less => false,
+					Ordering::Greater => true,
+					Ordering::Equal => {
+						let best_inner_seal =
+							fetch_seal::<B>(best_header.digest().logs.last(), best_hash)?;
+
+						self.algorithm.break_tie(&best_inner_seal, &inner_seal)
+					},
+				},
+			));
+		}
+
+		self.inner.import_block(block).await.map_err(Into::into)
+	}
+}
+
+/// A verifier for PoW blocks.
+pub struct PowVerifier<B: BlockT, Algorithm> {
+	algorithm: Algorithm,
+	_marker: PhantomData<B>,
+}
+
+impl<B: BlockT, Algorithm> PowVerifier<B, Algorithm> {
+	pub fn new(algorithm: Algorithm) -> Self {
+		Self { algorithm, _marker: PhantomData }
+	}
+
+	fn check_header(&self, mut header: B::Header) -> Result<(B::Header, DigestItem), Error<B>>
+	where
+		Algorithm: PowAlgorithm<B>,
+	{
+		let hash = header.hash();
+
+		let (seal, inner_seal) = match header.digest_mut().pop() {
+			Some(DigestItem::Seal(id, seal)) =>
+				if id == POW_ENGINE_ID {
+					(DigestItem::Seal(id, seal.clone()), seal)
+				} else {
+					return Err(Error::WrongEngine(id))
+				},
+			_ => return Err(Error::HeaderUnsealed(hash)),
+		};
+
+		let pre_hash = header.hash();
+
+		if !self.algorithm.preliminary_verify(&pre_hash, &inner_seal)?.unwrap_or(true) {
+			return Err(Error::FailedPreliminaryVerify)
+		}
+
+		Ok((header, seal))
+	}
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT, Algorithm> Verifier<B> for PowVerifier<B, Algorithm>
+where
+	Algorithm: PowAlgorithm<B> + Send + Sync,
+	Algorithm::Difficulty: 'static + Send,
+{
+	async fn verify(
+		&mut self,
+		mut block: BlockImportParams<B>,
+	) -> Result<BlockImportParams<B>, String> {
+		let hash = block.header.hash();
+		let (checked_header, seal) = self.check_header(block.header)?;
+
+		let intermediate = PowIntermediate::<Algorithm::Difficulty> { difficulty: None };
+		block.header = checked_header;
+		block.post_digests.push(seal);
+		block.insert_intermediate(INTERMEDIATE_KEY, intermediate);
+		block.post_hash = Some(hash);
+
+		Ok(block)
+	}
+}
+
+/// The PoW import queue type.
+pub type PowImportQueue<B> = BasicQueue<B>;
+
+/// Import queue for PoW engine.
+pub fn import_queue<B, Algorithm>(
+	block_import: BoxBlockImport<B>,
+	justification_import: Option<BoxJustificationImport<B>>,
+	algorithm: Algorithm,
+	spawner: &impl sp_core::traits::SpawnEssentialNamed,
+	registry: Option<&Registry>,
+) -> Result<PowImportQueue<B>, sp_consensus::Error>
+where
+	B: BlockT,
+	Algorithm: PowAlgorithm<B> + Clone + Send + Sync + 'static,
+	Algorithm::Difficulty: Send,
+{
+	let verifier = PowVerifier::new(algorithm);
+
+	Ok(BasicQueue::new(verifier, block_import, justification_import, spawner, registry))
+}
+
+/// Start the mining worker for PoW. This function provides the necessary helper functions that can
+/// be used to implement a miner. However, it does not do the CPU-intensive mining itself.
+///
+/// Two values are returned -- a worker, which contains functions that allows querying the current
+/// mining metadata and submitting mined blocks, and a future, which must be polled to fill in
+/// information in the worker.
+///
+/// `pre_runtime` is a parameter that allows a custom additional pre-runtime digest to be inserted
+/// for blocks being built. This can encode authorship information, or just be a graffiti.
+pub fn start_mining_worker<Block, C, S, Algorithm, E, SO, L, CIDP>(
+	block_import: BoxBlockImport<Block>,
+	client: Arc<C>,
+	select_chain: S,
+	algorithm: Algorithm,
+	mut env: E,
+	sync_oracle: SO,
+	justification_sync_link: L,
+	pre_runtime: Option<Vec<u8>>,
+	create_inherent_data_providers: CIDP,
+	timeout: Duration,
+	build_time: Duration,
+) -> (
+	MiningHandle<Block, Algorithm, L, <E::Proposer as Proposer<Block>>::Proof>,
+	impl Future<Output = ()>,
+)
+where
+	Block: BlockT,
+	C: BlockchainEvents<Block> + 'static,
+	S: SelectChain<Block> + 'static,
+	Algorithm: PowAlgorithm<Block> + Clone,
+	Algorithm::Difficulty: Send + 'static,
+	E: Environment<Block> + Send + Sync + 'static,
+	E::Error: std::fmt::Debug,
+	E::Proposer: Proposer<Block>,
+	SO: SyncOracle + Clone + Send + Sync + 'static,
+	L: sc_consensus::JustificationSyncLink<Block>,
+	CIDP: CreateInherentDataProviders<Block, ()>,
+{
+	let mut timer = UntilImportedOrTimeout::new(client.import_notification_stream(), timeout);
+	let worker = MiningHandle::new(algorithm.clone(), block_import, justification_sync_link);
+	let worker_ret = worker.clone();
+
+	let task = async move {
+		loop {
+			if timer.next().await.is_none() {
+				break
+			}
+
+			if sync_oracle.is_major_syncing() {
+				debug!(target: LOG_TARGET, "Skipping proposal due to sync.");
+				worker.on_major_syncing();
+				continue
+			}
+
+			let best_header = match select_chain.best_chain().await {
+				Ok(x) => x,
+				Err(err) => {
+					warn!(
+						target: LOG_TARGET,
+						"Unable to pull new block for authoring. \
+						 Select best chain error: {}",
+						err
+					);
+					continue
+				},
+			};
+			let best_hash = best_header.hash();
+
+			if worker.best_hash() == Some(best_hash) {
+				continue
+			}
+
+			// The worker is locked for the duration of the whole proposing period. Within this
+			// period, the mining target is outdated and useless anyway.
+
+			let difficulty = match algorithm.difficulty(best_hash) {
+				Ok(x) => x,
+				Err(err) => {
+					warn!(
+						target: LOG_TARGET,
+						"Unable to propose new block for authoring. \
+						 Fetch difficulty failed: {}",
+						err,
+					);
+					continue
+				},
+			};
+
+			let inherent_data_providers = match create_inherent_data_providers
+				.create_inherent_data_providers(best_hash, ())
+				.await
+			{
+				Ok(x) => x,
+				Err(err) => {
+					warn!(
+						target: LOG_TARGET,
+						"Unable to propose new block for authoring. \
+						 Creating inherent data providers failed: {}",
+						err,
+					);
+					continue
+				},
+			};
+
+			let inherent_data = match inherent_data_providers.create_inherent_data().await {
+				Ok(r) => r,
+				Err(e) => {
+					warn!(
+						target: LOG_TARGET,
+						"Unable to propose new block for authoring. \
+						 Creating inherent data failed: {}",
+						e,
+					);
+					continue
+				},
+			};
+
+			let mut inherent_digest = Digest::default();
+			if let Some(pre_runtime) = &pre_runtime {
+				inherent_digest.push(DigestItem::PreRuntime(POW_ENGINE_ID, pre_runtime.to_vec()));
+			}
+
+			let pre_runtime = pre_runtime.clone();
+
+			let proposer = match env.init(&best_header).await {
+				Ok(x) => x,
+				Err(err) => {
+					warn!(
+						target: LOG_TARGET,
+						"Unable to propose new block for authoring. \
+						 Creating proposer failed: {:?}",
+						err,
+					);
+					continue
+				},
+			};
+
+			let proposal =
+				match proposer.propose(inherent_data, inherent_digest, build_time, None).await {
+					Ok(x) => x,
+					Err(err) => {
+						warn!(
+							target: LOG_TARGET,
+							"Unable to propose new block for authoring. \
+							 Creating proposal failed: {}",
+							err,
+						);
+						continue
+					},
+				};
+
+			let build = MiningBuild::<Block, Algorithm, _> {
+				metadata: MiningMetadata {
+					best_hash,
+					pre_hash: proposal.block.header().hash(),
+					pre_runtime: pre_runtime.clone(),
+					difficulty,
+				},
+				proposal,
+			};
+
+			worker.on_build(build);
+		}
+	};
+
+	(worker_ret, task)
+}
+
+/// Find PoW pre-runtime.
+fn find_pre_digest<B: BlockT>(header: &B::Header) -> Result<Option<Vec<u8>>, Error<B>> {
+	let mut pre_digest: Option<_> = None;
+	for log in header.digest().logs() {
+		trace!(target: LOG_TARGET, "Checking log {:?}, looking for pre runtime digest", log);
+		match (log, pre_digest.is_some()) {
+			(DigestItem::PreRuntime(POW_ENGINE_ID, _), true) =>
+				return Err(Error::MultiplePreRuntimeDigests),
+			(DigestItem::PreRuntime(POW_ENGINE_ID, v), false) => {
+				pre_digest = Some(v.clone());
+			},
+			(_, _) => trace!(target: LOG_TARGET, "Ignoring digest not meant for us"),
+		}
+	}
+
+	Ok(pre_digest)
+}
+
+/// Fetch PoW seal.
+fn fetch_seal<B: BlockT>(digest: Option<&DigestItem>, hash: B::Hash) -> Result<Vec<u8>, Error<B>> {
+	match digest {
+		Some(DigestItem::Seal(id, seal)) =>
+			if id == &POW_ENGINE_ID {
+				Ok(seal.clone())
+			} else {
+				Err(Error::<B>::WrongEngine(*id))
+			},
+		_ => Err(Error::<B>::HeaderUnsealed(hash)),
+	}
+}
diff --git a/substrate/client/consensus/pow/src/worker.rs b/substrate/client/consensus/pow/src/worker.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9e9c4fc137d86dd3945d5cbc3aa44b43558a757d
--- /dev/null
+++ b/substrate/client/consensus/pow/src/worker.rs
@@ -0,0 +1,283 @@
+// 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 futures::{
+	prelude::*,
+	task::{Context, Poll},
+};
+use futures_timer::Delay;
+use log::*;
+use parking_lot::Mutex;
+use sc_client_api::ImportNotifications;
+use sc_consensus::{BlockImportParams, BoxBlockImport, StateAction, StorageChanges};
+use sp_consensus::{BlockOrigin, Proposal};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT},
+	DigestItem,
+};
+use std::{
+	pin::Pin,
+	sync::{
+		atomic::{AtomicUsize, Ordering},
+		Arc,
+	},
+	time::Duration,
+};
+
+use crate::{PowAlgorithm, PowIntermediate, Seal, INTERMEDIATE_KEY, LOG_TARGET, POW_ENGINE_ID};
+
+/// Mining metadata. This is the information needed to start an actual mining loop.
+#[derive(Clone, Eq, PartialEq)]
+pub struct MiningMetadata<H, D> {
+	/// Currently known best hash which the pre-hash is built on.
+	pub best_hash: H,
+	/// Mining pre-hash.
+	pub pre_hash: H,
+	/// Pre-runtime digest item.
+	pub pre_runtime: Option<Vec<u8>>,
+	/// Mining target difficulty.
+	pub difficulty: D,
+}
+
+/// A build of mining, containing the metadata and the block proposal.
+pub struct MiningBuild<Block: BlockT, Algorithm: PowAlgorithm<Block>, Proof> {
+	/// Mining metadata.
+	pub metadata: MiningMetadata<Block::Hash, Algorithm::Difficulty>,
+	/// Mining proposal.
+	pub proposal: Proposal<Block, Proof>,
+}
+
+/// Version of the mining worker.
+#[derive(Eq, PartialEq, Clone, Copy)]
+pub struct Version(usize);
+
+/// Mining worker that exposes structs to query the current mining build and submit mined blocks.
+pub struct MiningHandle<
+	Block: BlockT,
+	Algorithm: PowAlgorithm<Block>,
+	L: sc_consensus::JustificationSyncLink<Block>,
+	Proof,
+> {
+	version: Arc<AtomicUsize>,
+	algorithm: Arc<Algorithm>,
+	justification_sync_link: Arc<L>,
+	build: Arc<Mutex<Option<MiningBuild<Block, Algorithm, Proof>>>>,
+	block_import: Arc<Mutex<BoxBlockImport<Block>>>,
+}
+
+impl<Block, Algorithm, L, Proof> MiningHandle<Block, Algorithm, L, Proof>
+where
+	Block: BlockT,
+	Algorithm: PowAlgorithm<Block>,
+	Algorithm::Difficulty: 'static + Send,
+	L: sc_consensus::JustificationSyncLink<Block>,
+{
+	fn increment_version(&self) {
+		self.version.fetch_add(1, Ordering::SeqCst);
+	}
+
+	pub(crate) fn new(
+		algorithm: Algorithm,
+		block_import: BoxBlockImport<Block>,
+		justification_sync_link: L,
+	) -> Self {
+		Self {
+			version: Arc::new(AtomicUsize::new(0)),
+			algorithm: Arc::new(algorithm),
+			justification_sync_link: Arc::new(justification_sync_link),
+			build: Arc::new(Mutex::new(None)),
+			block_import: Arc::new(Mutex::new(block_import)),
+		}
+	}
+
+	pub(crate) fn on_major_syncing(&self) {
+		let mut build = self.build.lock();
+		*build = None;
+		self.increment_version();
+	}
+
+	pub(crate) fn on_build(&self, value: MiningBuild<Block, Algorithm, Proof>) {
+		let mut build = self.build.lock();
+		*build = Some(value);
+		self.increment_version();
+	}
+
+	/// Get the version of the mining worker.
+	///
+	/// This returns type `Version` which can only compare equality. If `Version` is unchanged, then
+	/// it can be certain that `best_hash` and `metadata` were not changed.
+	pub fn version(&self) -> Version {
+		Version(self.version.load(Ordering::SeqCst))
+	}
+
+	/// Get the current best hash. `None` if the worker has just started or the client is doing
+	/// major syncing.
+	pub fn best_hash(&self) -> Option<Block::Hash> {
+		self.build.lock().as_ref().map(|b| b.metadata.best_hash)
+	}
+
+	/// Get a copy of the current mining metadata, if available.
+	pub fn metadata(&self) -> Option<MiningMetadata<Block::Hash, Algorithm::Difficulty>> {
+		self.build.lock().as_ref().map(|b| b.metadata.clone())
+	}
+
+	/// Submit a mined seal. The seal will be validated again. Returns true if the submission is
+	/// successful.
+	pub async fn submit(&self, seal: Seal) -> bool {
+		if let Some(metadata) = self.metadata() {
+			match self.algorithm.verify(
+				&BlockId::Hash(metadata.best_hash),
+				&metadata.pre_hash,
+				metadata.pre_runtime.as_ref().map(|v| &v[..]),
+				&seal,
+				metadata.difficulty,
+			) {
+				Ok(true) => (),
+				Ok(false) => {
+					warn!(target: LOG_TARGET, "Unable to import mined block: seal is invalid",);
+					return false
+				},
+				Err(err) => {
+					warn!(target: LOG_TARGET, "Unable to import mined block: {}", err,);
+					return false
+				},
+			}
+		} else {
+			warn!(target: LOG_TARGET, "Unable to import mined block: metadata does not exist",);
+			return false
+		}
+
+		let build = if let Some(build) = {
+			let mut build = self.build.lock();
+			let value = build.take();
+			if value.is_some() {
+				self.increment_version();
+			}
+			value
+		} {
+			build
+		} else {
+			warn!(target: LOG_TARGET, "Unable to import mined block: build does not exist",);
+			return false
+		};
+
+		let seal = DigestItem::Seal(POW_ENGINE_ID, seal);
+		let (header, body) = build.proposal.block.deconstruct();
+
+		let mut import_block = BlockImportParams::new(BlockOrigin::Own, header);
+		import_block.post_digests.push(seal);
+		import_block.body = Some(body);
+		import_block.state_action =
+			StateAction::ApplyChanges(StorageChanges::Changes(build.proposal.storage_changes));
+
+		let intermediate = PowIntermediate::<Algorithm::Difficulty> {
+			difficulty: Some(build.metadata.difficulty),
+		};
+		import_block.insert_intermediate(INTERMEDIATE_KEY, intermediate);
+
+		let header = import_block.post_header();
+		let mut block_import = self.block_import.lock();
+
+		match block_import.import_block(import_block).await {
+			Ok(res) => {
+				res.handle_justification(
+					&header.hash(),
+					*header.number(),
+					&self.justification_sync_link,
+				);
+
+				info!(
+					target: LOG_TARGET,
+					"✅ Successfully mined block on top of: {}", build.metadata.best_hash
+				);
+				true
+			},
+			Err(err) => {
+				warn!(target: LOG_TARGET, "Unable to import mined block: {}", err,);
+				false
+			},
+		}
+	}
+}
+
+impl<Block, Algorithm, L, Proof> Clone for MiningHandle<Block, Algorithm, L, Proof>
+where
+	Block: BlockT,
+	Algorithm: PowAlgorithm<Block>,
+	L: sc_consensus::JustificationSyncLink<Block>,
+{
+	fn clone(&self) -> Self {
+		Self {
+			version: self.version.clone(),
+			algorithm: self.algorithm.clone(),
+			justification_sync_link: self.justification_sync_link.clone(),
+			build: self.build.clone(),
+			block_import: self.block_import.clone(),
+		}
+	}
+}
+
+/// A stream that waits for a block import or timeout.
+pub struct UntilImportedOrTimeout<Block: BlockT> {
+	import_notifications: ImportNotifications<Block>,
+	timeout: Duration,
+	inner_delay: Option<Delay>,
+}
+
+impl<Block: BlockT> UntilImportedOrTimeout<Block> {
+	/// Create a new stream using the given import notification and timeout duration.
+	pub fn new(import_notifications: ImportNotifications<Block>, timeout: Duration) -> Self {
+		Self { import_notifications, timeout, inner_delay: None }
+	}
+}
+
+impl<Block: BlockT> Stream for UntilImportedOrTimeout<Block> {
+	type Item = ();
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<()>> {
+		let mut fire = false;
+
+		loop {
+			match Stream::poll_next(Pin::new(&mut self.import_notifications), cx) {
+				Poll::Pending => break,
+				Poll::Ready(Some(_)) => {
+					fire = true;
+				},
+				Poll::Ready(None) => return Poll::Ready(None),
+			}
+		}
+
+		let timeout = self.timeout;
+		let inner_delay = self.inner_delay.get_or_insert_with(|| Delay::new(timeout));
+
+		match Future::poll(Pin::new(inner_delay), cx) {
+			Poll::Pending => (),
+			Poll::Ready(()) => {
+				fire = true;
+			},
+		}
+
+		if fire {
+			self.inner_delay = None;
+			Poll::Ready(Some(()))
+		} else {
+			Poll::Pending
+		}
+	}
+}
diff --git a/substrate/client/consensus/slots/Cargo.toml b/substrate/client/consensus/slots/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..67eeae5317abb31603d6f5c1d2096fc1f29e38d7
--- /dev/null
+++ b/substrate/client/consensus/slots/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "sc-consensus-slots"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Generic slots-based utilities for consensus"
+edition = "2021"
+build = "build.rs"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+futures-timer = "3.0.1"
+log = "0.4.17"
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-telemetry = { version = "4.0.0-dev", path = "../../telemetry" }
+sp-arithmetic = { version = "16.0.0", path = "../../../primitives/arithmetic" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-slots = { version = "0.10.0-dev", path = "../../../primitives/consensus/slots" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../../primitives/state-machine" }
+
+[dev-dependencies]
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/client/consensus/slots/README.md b/substrate/client/consensus/slots/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ab3c3742f33076b46be61efbf3c3e5fd824b50c
--- /dev/null
+++ b/substrate/client/consensus/slots/README.md
@@ -0,0 +1,7 @@
+Slots functionality for Substrate.
+
+Some consensus algorithms have a concept of *slots*, which are intervals in
+time during which certain events can and/or must occur.  This crate
+provides generic functionality for slots.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/consensus/slots/build.rs b/substrate/client/consensus/slots/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a68cb706e8fbdc2526aa18730f0e7ddb9719f838
--- /dev/null
+++ b/substrate/client/consensus/slots/build.rs
@@ -0,0 +1,25 @@
+// 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 std::env;
+
+fn main() {
+	if let Ok(profile) = env::var("PROFILE") {
+		println!("cargo:rustc-cfg=build_type=\"{}\"", profile);
+	}
+}
diff --git a/substrate/client/consensus/slots/src/aux_schema.rs b/substrate/client/consensus/slots/src/aux_schema.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9c6bc0ad0cdc41004523c9b0c56054ec5bab3bcc
--- /dev/null
+++ b/substrate/client/consensus/slots/src/aux_schema.rs
@@ -0,0 +1,223 @@
+// 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/>.
+
+//! Schema for slots in the aux-db.
+
+use codec::{Decode, Encode};
+use sc_client_api::backend::AuxStore;
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
+use sp_consensus_slots::{EquivocationProof, Slot};
+use sp_runtime::traits::Header;
+
+const SLOT_HEADER_MAP_KEY: &[u8] = b"slot_header_map";
+const SLOT_HEADER_START: &[u8] = b"slot_header_start";
+
+/// We keep at least this number of slots in database.
+pub const MAX_SLOT_CAPACITY: u64 = 1000;
+/// We prune slots when they reach this number.
+pub const PRUNING_BOUND: u64 = 2 * MAX_SLOT_CAPACITY;
+
+fn load_decode<C, T>(backend: &C, key: &[u8]) -> ClientResult<Option<T>>
+where
+	C: AuxStore,
+	T: Decode,
+{
+	match backend.get_aux(key)? {
+		None => Ok(None),
+		Some(t) => T::decode(&mut &t[..])
+			.map_err(|e| {
+				ClientError::Backend(format!("Slots DB is corrupted. Decode error: {}", e))
+			})
+			.map(Some),
+	}
+}
+
+/// Checks if the header is an equivocation and returns the proof in that case.
+///
+/// Note: it detects equivocations only when slot_now - slot <= MAX_SLOT_CAPACITY.
+pub fn check_equivocation<C, H, P>(
+	backend: &C,
+	slot_now: Slot,
+	slot: Slot,
+	header: &H,
+	signer: &P,
+) -> ClientResult<Option<EquivocationProof<H, P>>>
+where
+	H: Header,
+	C: AuxStore,
+	P: Clone + Encode + Decode + PartialEq,
+{
+	// We don't check equivocations for old headers out of our capacity.
+	if slot_now.saturating_sub(*slot) > MAX_SLOT_CAPACITY {
+		return Ok(None)
+	}
+
+	// Key for this slot.
+	let mut curr_slot_key = SLOT_HEADER_MAP_KEY.to_vec();
+	slot.using_encoded(|s| curr_slot_key.extend(s));
+
+	// Get headers of this slot.
+	let mut headers_with_sig =
+		load_decode::<_, Vec<(H, P)>>(backend, &curr_slot_key[..])?.unwrap_or_else(Vec::new);
+
+	// Get first slot saved.
+	let slot_header_start = SLOT_HEADER_START.to_vec();
+	let first_saved_slot = load_decode::<_, Slot>(backend, &slot_header_start[..])?.unwrap_or(slot);
+
+	if slot_now < first_saved_slot {
+		// The code below assumes that slots will be visited sequentially.
+		return Ok(None)
+	}
+
+	for (prev_header, prev_signer) in headers_with_sig.iter() {
+		// A proof of equivocation consists of two headers:
+		// 1) signed by the same voter,
+		if prev_signer == signer {
+			// 2) with different hash
+			return if header.hash() != prev_header.hash() {
+				Ok(Some(EquivocationProof {
+					slot,
+					offender: signer.clone(),
+					first_header: prev_header.clone(),
+					second_header: header.clone(),
+				}))
+			} else {
+				// We don't need to continue in case of duplicated header,
+				// since it's already saved and a possible equivocation
+				// would have been detected before.
+				Ok(None)
+			}
+		}
+	}
+
+	let mut keys_to_delete = vec![];
+	let mut new_first_saved_slot = first_saved_slot;
+
+	if *slot_now - *first_saved_slot >= PRUNING_BOUND {
+		let prefix = SLOT_HEADER_MAP_KEY.to_vec();
+		new_first_saved_slot = slot_now.saturating_sub(MAX_SLOT_CAPACITY);
+
+		for s in u64::from(first_saved_slot)..new_first_saved_slot.into() {
+			let mut p = prefix.clone();
+			s.using_encoded(|s| p.extend(s));
+			keys_to_delete.push(p);
+		}
+	}
+
+	headers_with_sig.push((header.clone(), signer.clone()));
+
+	backend.insert_aux(
+		&[
+			(&curr_slot_key[..], headers_with_sig.encode().as_slice()),
+			(&slot_header_start[..], new_first_saved_slot.encode().as_slice()),
+		],
+		&keys_to_delete.iter().map(|k| &k[..]).collect::<Vec<&[u8]>>()[..],
+	)?;
+
+	Ok(None)
+}
+
+#[cfg(test)]
+mod test {
+	use sp_core::{hash::H256, sr25519, Pair};
+	use sp_runtime::testing::{Digest as DigestTest, Header as HeaderTest};
+	use substrate_test_runtime_client;
+
+	use super::{check_equivocation, MAX_SLOT_CAPACITY, PRUNING_BOUND};
+
+	fn create_header(number: u64) -> HeaderTest {
+		// so that different headers for the same number get different hashes
+		let parent_hash = H256::random();
+
+		let header = HeaderTest {
+			parent_hash,
+			number,
+			state_root: Default::default(),
+			extrinsics_root: Default::default(),
+			digest: DigestTest { logs: vec![] },
+		};
+
+		header
+	}
+
+	#[test]
+	fn check_equivocation_works() {
+		let client = substrate_test_runtime_client::new();
+		let (pair, _seed) = sr25519::Pair::generate();
+		let public = pair.public();
+
+		let header1 = create_header(1); // @ slot 2
+		let header2 = create_header(2); // @ slot 2
+		let header3 = create_header(2); // @ slot 4
+		let header4 = create_header(3); // @ slot MAX_SLOT_CAPACITY + 4
+		let header5 = create_header(4); // @ slot MAX_SLOT_CAPACITY + 4
+		let header6 = create_header(3); // @ slot 4
+
+		// It's ok to sign same headers.
+		assert!(check_equivocation(&client, 2.into(), 2.into(), &header1, &public)
+			.unwrap()
+			.is_none(),);
+
+		assert!(check_equivocation(&client, 3.into(), 2.into(), &header1, &public)
+			.unwrap()
+			.is_none(),);
+
+		// But not two different headers at the same slot.
+		assert!(check_equivocation(&client, 4.into(), 2.into(), &header2, &public)
+			.unwrap()
+			.is_some(),);
+
+		// Different slot is ok.
+		assert!(check_equivocation(&client, 5.into(), 4.into(), &header3, &public)
+			.unwrap()
+			.is_none(),);
+
+		// Here we trigger pruning and save header 4.
+		assert!(check_equivocation(
+			&client,
+			(PRUNING_BOUND + 2).into(),
+			(MAX_SLOT_CAPACITY + 4).into(),
+			&header4,
+			&public,
+		)
+		.unwrap()
+		.is_none(),);
+
+		// This fails because header 5 is an equivocation of header 4.
+		assert!(check_equivocation(
+			&client,
+			(PRUNING_BOUND + 3).into(),
+			(MAX_SLOT_CAPACITY + 4).into(),
+			&header5,
+			&public,
+		)
+		.unwrap()
+		.is_some(),);
+
+		// This is ok because we pruned the corresponding header. Shows that we are pruning.
+		assert!(check_equivocation(
+			&client,
+			(PRUNING_BOUND + 4).into(),
+			4.into(),
+			&header6,
+			&public,
+		)
+		.unwrap()
+		.is_none(),);
+	}
+}
diff --git a/substrate/client/consensus/slots/src/lib.rs b/substrate/client/consensus/slots/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5ee93d168643702387d0ee1529b8875d66b1a860
--- /dev/null
+++ b/substrate/client/consensus/slots/src/lib.rs
@@ -0,0 +1,1243 @@
+// 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/>.
+
+//! Slots functionality for Substrate.
+//!
+//! Some consensus algorithms have a concept of *slots*, which are intervals in
+//! time during which certain events can and/or must occur.  This crate
+//! provides generic functionality for slots.
+
+#![forbid(unsafe_code)]
+#![warn(missing_docs)]
+
+mod aux_schema;
+mod slots;
+
+pub use aux_schema::{check_equivocation, MAX_SLOT_CAPACITY, PRUNING_BOUND};
+pub use slots::SlotInfo;
+use slots::Slots;
+
+use futures::{future::Either, Future, TryFutureExt};
+use futures_timer::Delay;
+use log::{debug, info, warn};
+use sc_consensus::{BlockImport, JustificationSyncLink};
+use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_INFO, CONSENSUS_WARN};
+use sp_arithmetic::traits::BaseArithmetic;
+use sp_consensus::{Proposal, Proposer, SelectChain, SyncOracle};
+use sp_consensus_slots::{Slot, SlotDuration};
+use sp_inherents::CreateInherentDataProviders;
+use sp_runtime::traits::{Block as BlockT, HashingFor, Header as HeaderT};
+use std::{
+	fmt::Debug,
+	ops::Deref,
+	time::{Duration, Instant},
+};
+
+const LOG_TARGET: &str = "slots";
+
+/// The changes that need to applied to the storage to create the state for a block.
+///
+/// See [`sp_state_machine::StorageChanges`] for more information.
+pub type StorageChanges<Block> = sp_state_machine::StorageChanges<HashingFor<Block>>;
+
+/// The result of [`SlotWorker::on_slot`].
+#[derive(Debug, Clone)]
+pub struct SlotResult<Block: BlockT, Proof> {
+	/// The block that was built.
+	pub block: Block,
+	/// The storage proof that was recorded while building the block.
+	pub storage_proof: Proof,
+}
+
+/// A worker that should be invoked at every new slot.
+///
+/// The implementation should not make any assumptions of the slot being bound to the time or
+/// similar. The only valid assumption is that the slot number is always increasing.
+#[async_trait::async_trait]
+pub trait SlotWorker<B: BlockT, Proof> {
+	/// Called when a new slot is triggered.
+	///
+	/// Returns a future that resolves to a [`SlotResult`] iff a block was successfully built in
+	/// the slot. Otherwise `None` is returned.
+	async fn on_slot(&mut self, slot_info: SlotInfo<B>) -> Option<SlotResult<B, Proof>>;
+}
+
+/// A skeleton implementation for `SlotWorker` which tries to claim a slot at
+/// its beginning and tries to produce a block if successfully claimed, timing
+/// out if block production takes too long.
+#[async_trait::async_trait]
+pub trait SimpleSlotWorker<B: BlockT> {
+	/// A handle to a `BlockImport`.
+	type BlockImport: BlockImport<B> + Send + 'static;
+
+	/// A handle to a `SyncOracle`.
+	type SyncOracle: SyncOracle;
+
+	/// A handle to a `JustificationSyncLink`, allows hooking into the sync module to control the
+	/// justification sync process.
+	type JustificationSyncLink: JustificationSyncLink<B>;
+
+	/// The type of future resolving to the proposer.
+	type CreateProposer: Future<Output = Result<Self::Proposer, sp_consensus::Error>>
+		+ Send
+		+ Unpin
+		+ 'static;
+
+	/// The type of proposer to use to build blocks.
+	type Proposer: Proposer<B> + Send;
+
+	/// Data associated with a slot claim.
+	type Claim: Send + Sync + 'static;
+
+	/// Auxiliary data necessary for authoring.
+	type AuxData: Send + Sync + 'static;
+
+	/// The logging target to use when logging messages.
+	fn logging_target(&self) -> &'static str;
+
+	/// A handle to a `BlockImport`.
+	fn block_import(&mut self) -> &mut Self::BlockImport;
+
+	/// Returns the auxiliary data necessary for authoring.
+	fn aux_data(
+		&self,
+		header: &B::Header,
+		slot: Slot,
+	) -> Result<Self::AuxData, sp_consensus::Error>;
+
+	/// Returns the number of authorities.
+	/// None indicate that the authorities information is incomplete.
+	fn authorities_len(&self, aux_data: &Self::AuxData) -> Option<usize>;
+
+	/// Tries to claim the given slot, returning an object with claim data if successful.
+	async fn claim_slot(
+		&self,
+		header: &B::Header,
+		slot: Slot,
+		aux_data: &Self::AuxData,
+	) -> Option<Self::Claim>;
+
+	/// Notifies the given slot. Similar to `claim_slot`, but will be called no matter whether we
+	/// need to author blocks or not.
+	fn notify_slot(&self, _header: &B::Header, _slot: Slot, _aux_data: &Self::AuxData) {}
+
+	/// Return the pre digest data to include in a block authored with the given claim.
+	fn pre_digest_data(&self, slot: Slot, claim: &Self::Claim) -> Vec<sp_runtime::DigestItem>;
+
+	/// Returns a function which produces a `BlockImportParams`.
+	async fn block_import_params(
+		&self,
+		header: B::Header,
+		header_hash: &B::Hash,
+		body: Vec<B::Extrinsic>,
+		storage_changes: StorageChanges<B>,
+		public: Self::Claim,
+		aux_data: Self::AuxData,
+	) -> Result<sc_consensus::BlockImportParams<B>, sp_consensus::Error>;
+
+	/// Whether to force authoring if offline.
+	fn force_authoring(&self) -> bool;
+
+	/// Returns whether the block production should back off.
+	///
+	/// By default this function always returns `false`.
+	///
+	/// An example strategy that back offs if the finalized head is lagging too much behind the tip
+	/// is implemented by [`BackoffAuthoringOnFinalizedHeadLagging`].
+	fn should_backoff(&self, _slot: Slot, _chain_head: &B::Header) -> bool {
+		false
+	}
+
+	/// Returns a handle to a `SyncOracle`.
+	fn sync_oracle(&mut self) -> &mut Self::SyncOracle;
+
+	/// Returns a handle to a `JustificationSyncLink`.
+	fn justification_sync_link(&mut self) -> &mut Self::JustificationSyncLink;
+
+	/// Returns a `Proposer` to author on top of the given block.
+	fn proposer(&mut self, block: &B::Header) -> Self::CreateProposer;
+
+	/// Returns a [`TelemetryHandle`] if any.
+	fn telemetry(&self) -> Option<TelemetryHandle>;
+
+	/// Remaining duration for proposing.
+	fn proposing_remaining_duration(&self, slot_info: &SlotInfo<B>) -> Duration;
+
+	/// Propose a block by `Proposer`.
+	async fn propose(
+		&mut self,
+		proposer: Self::Proposer,
+		claim: &Self::Claim,
+		slot_info: SlotInfo<B>,
+		end_proposing_at: Instant,
+	) -> Option<Proposal<B, <Self::Proposer as Proposer<B>>::Proof>> {
+		let slot = slot_info.slot;
+		let telemetry = self.telemetry();
+		let log_target = self.logging_target();
+
+		let inherent_data =
+			Self::create_inherent_data(&slot_info, &log_target, end_proposing_at).await?;
+
+		let proposing_remaining_duration =
+			end_proposing_at.saturating_duration_since(Instant::now());
+		let logs = self.pre_digest_data(slot, claim);
+
+		// deadline our production to 98% of the total time left for proposing. As we deadline
+		// the proposing below to the same total time left, the 2% margin should be enough for
+		// the result to be returned.
+		let proposing = proposer
+			.propose(
+				inherent_data,
+				sp_runtime::generic::Digest { logs },
+				proposing_remaining_duration.mul_f32(0.98),
+				slot_info.block_size_limit,
+			)
+			.map_err(|e| sp_consensus::Error::ClientImport(e.to_string()));
+
+		let proposal = match futures::future::select(
+			proposing,
+			Delay::new(proposing_remaining_duration),
+		)
+		.await
+		{
+			Either::Left((Ok(p), _)) => p,
+			Either::Left((Err(err), _)) => {
+				warn!(target: log_target, "Proposing failed: {}", err);
+
+				return None
+			},
+			Either::Right(_) => {
+				info!(
+					target: log_target,
+					"⌛� Discarding proposal for slot {}; block production took too long", slot,
+				);
+				// If the node was compiled with debug, tell the user to use release optimizations.
+				#[cfg(build_type = "debug")]
+				info!(
+					target: log_target,
+					"👉 Recompile your node in `--release` mode to mitigate this problem.",
+				);
+				telemetry!(
+					telemetry;
+					CONSENSUS_INFO;
+					"slots.discarding_proposal_took_too_long";
+					"slot" => *slot,
+				);
+
+				return None
+			},
+		};
+
+		Some(proposal)
+	}
+
+	/// Calls `create_inherent_data` and handles errors.
+	async fn create_inherent_data(
+		slot_info: &SlotInfo<B>,
+		logging_target: &str,
+		end_proposing_at: Instant,
+	) -> Option<sp_inherents::InherentData> {
+		let remaining_duration = end_proposing_at.saturating_duration_since(Instant::now());
+		let delay = Delay::new(remaining_duration);
+		let cid = slot_info.create_inherent_data.create_inherent_data();
+		let inherent_data = match futures::future::select(delay, cid).await {
+			Either::Right((Ok(data), _)) => data,
+			Either::Right((Err(err), _)) => {
+				warn!(
+					target: logging_target,
+					"Unable to create inherent data for block {:?}: {}",
+					slot_info.chain_head.hash(),
+					err,
+				);
+
+				return None
+			},
+			Either::Left(_) => {
+				warn!(
+					target: logging_target,
+					"Creating inherent data took more time than we had left for slot {} for block {:?}.",
+					slot_info.slot,
+					slot_info.chain_head.hash(),
+				);
+
+				return None
+			},
+		};
+
+		Some(inherent_data)
+	}
+
+	/// Implements [`SlotWorker::on_slot`].
+	async fn on_slot(
+		&mut self,
+		slot_info: SlotInfo<B>,
+	) -> Option<SlotResult<B, <Self::Proposer as Proposer<B>>::Proof>>
+	where
+		Self: Sync,
+	{
+		let slot = slot_info.slot;
+		let telemetry = self.telemetry();
+		let logging_target = self.logging_target();
+
+		let proposing_remaining_duration = self.proposing_remaining_duration(&slot_info);
+
+		let end_proposing_at = if proposing_remaining_duration == Duration::default() {
+			debug!(
+				target: logging_target,
+				"Skipping proposal slot {} since there's no time left to propose", slot,
+			);
+
+			return None
+		} else {
+			Instant::now() + proposing_remaining_duration
+		};
+
+		let aux_data = match self.aux_data(&slot_info.chain_head, slot) {
+			Ok(aux_data) => aux_data,
+			Err(err) => {
+				warn!(
+					target: logging_target,
+					"Unable to fetch auxiliary data for block {:?}: {}",
+					slot_info.chain_head.hash(),
+					err,
+				);
+
+				telemetry!(
+					telemetry;
+					CONSENSUS_WARN;
+					"slots.unable_fetching_authorities";
+					"slot" => ?slot_info.chain_head.hash(),
+					"err" => ?err,
+				);
+
+				return None
+			},
+		};
+
+		self.notify_slot(&slot_info.chain_head, slot, &aux_data);
+
+		let authorities_len = self.authorities_len(&aux_data);
+
+		if !self.force_authoring() &&
+			self.sync_oracle().is_offline() &&
+			authorities_len.map(|a| a > 1).unwrap_or(false)
+		{
+			debug!(target: logging_target, "Skipping proposal slot. Waiting for the network.");
+			telemetry!(
+				telemetry;
+				CONSENSUS_DEBUG;
+				"slots.skipping_proposal_slot";
+				"authorities_len" => authorities_len,
+			);
+
+			return None
+		}
+
+		let claim = self.claim_slot(&slot_info.chain_head, slot, &aux_data).await?;
+
+		if self.should_backoff(slot, &slot_info.chain_head) {
+			return None
+		}
+
+		debug!(target: logging_target, "Starting authorship at slot: {slot}");
+
+		telemetry!(telemetry; CONSENSUS_DEBUG; "slots.starting_authorship"; "slot_num" => slot);
+
+		let proposer = match self.proposer(&slot_info.chain_head).await {
+			Ok(p) => p,
+			Err(err) => {
+				warn!(target: logging_target, "Unable to author block in slot {slot:?}: {err}");
+
+				telemetry!(
+					telemetry;
+					CONSENSUS_WARN;
+					"slots.unable_authoring_block";
+					"slot" => *slot,
+					"err" => ?err
+				);
+
+				return None
+			},
+		};
+
+		let proposal = self.propose(proposer, &claim, slot_info, end_proposing_at).await?;
+
+		let (block, storage_proof) = (proposal.block, proposal.proof);
+		let (header, body) = block.deconstruct();
+		let header_num = *header.number();
+		let header_hash = header.hash();
+		let parent_hash = *header.parent_hash();
+
+		let block_import_params = match self
+			.block_import_params(
+				header,
+				&header_hash,
+				body.clone(),
+				proposal.storage_changes,
+				claim,
+				aux_data,
+			)
+			.await
+		{
+			Ok(bi) => bi,
+			Err(err) => {
+				warn!(target: logging_target, "Failed to create block import params: {}", err);
+
+				return None
+			},
+		};
+
+		info!(
+			target: logging_target,
+			"🔖 Pre-sealed block for proposal at {}. Hash now {:?}, previously {:?}.",
+			header_num,
+			block_import_params.post_hash(),
+			header_hash,
+		);
+
+		telemetry!(
+			telemetry;
+			CONSENSUS_INFO;
+			"slots.pre_sealed_block";
+			"header_num" => ?header_num,
+			"hash_now" => ?block_import_params.post_hash(),
+			"hash_previously" => ?header_hash,
+		);
+
+		let header = block_import_params.post_header();
+		match self.block_import().import_block(block_import_params).await {
+			Ok(res) => {
+				res.handle_justification(
+					&header.hash(),
+					*header.number(),
+					self.justification_sync_link(),
+				);
+			},
+			Err(err) => {
+				warn!(
+					target: logging_target,
+					"Error with block built on {:?}: {}", parent_hash, err,
+				);
+
+				telemetry!(
+					telemetry;
+					CONSENSUS_WARN;
+					"slots.err_with_block_built_on";
+					"hash" => ?parent_hash,
+					"err" => ?err,
+				);
+			},
+		}
+
+		Some(SlotResult { block: B::new(header, body), storage_proof })
+	}
+}
+
+/// A type that implements [`SlotWorker`] for a type that implements [`SimpleSlotWorker`].
+///
+/// This is basically a workaround for Rust not supporting specialization. Otherwise we could
+/// implement [`SlotWorker`] for any `T` that implements [`SimpleSlotWorker`], but currently
+/// that would prevent downstream users to implement [`SlotWorker`] for their own types.
+pub struct SimpleSlotWorkerToSlotWorker<T>(pub T);
+
+#[async_trait::async_trait]
+impl<T: SimpleSlotWorker<B> + Send + Sync, B: BlockT>
+	SlotWorker<B, <T::Proposer as Proposer<B>>::Proof> for SimpleSlotWorkerToSlotWorker<T>
+{
+	async fn on_slot(
+		&mut self,
+		slot_info: SlotInfo<B>,
+	) -> Option<SlotResult<B, <T::Proposer as Proposer<B>>::Proof>> {
+		self.0.on_slot(slot_info).await
+	}
+}
+
+/// Slot specific extension that the inherent data provider needs to implement.
+pub trait InherentDataProviderExt {
+	/// The current slot that will be found in the [`InherentData`](`sp_inherents::InherentData`).
+	fn slot(&self) -> Slot;
+}
+
+/// Small macro for implementing `InherentDataProviderExt` for inherent data provider tuple.
+macro_rules! impl_inherent_data_provider_ext_tuple {
+	( S $(, $TN:ident)* $( , )?) => {
+		impl<S, $( $TN ),*>  InherentDataProviderExt for (S, $($TN),*)
+		where
+			S: Deref<Target = Slot>,
+		{
+			fn slot(&self) -> Slot {
+				*self.0.deref()
+			}
+		}
+	}
+}
+
+impl_inherent_data_provider_ext_tuple!(S);
+impl_inherent_data_provider_ext_tuple!(S, A);
+impl_inherent_data_provider_ext_tuple!(S, A, B);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C, D);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C, D, E);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C, D, E, F);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C, D, E, F, G);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C, D, E, F, G, H);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C, D, E, F, G, H, I);
+impl_inherent_data_provider_ext_tuple!(S, A, B, C, D, E, F, G, H, I, J);
+
+/// Start a new slot worker.
+///
+/// Every time a new slot is triggered, `worker.on_slot` is called and the future it returns is
+/// polled until completion, unless we are major syncing.
+pub async fn start_slot_worker<B, C, W, SO, CIDP, Proof>(
+	slot_duration: SlotDuration,
+	client: C,
+	mut worker: W,
+	sync_oracle: SO,
+	create_inherent_data_providers: CIDP,
+) where
+	B: BlockT,
+	C: SelectChain<B>,
+	W: SlotWorker<B, Proof>,
+	SO: SyncOracle + Send,
+	CIDP: CreateInherentDataProviders<B, ()> + Send + 'static,
+	CIDP::InherentDataProviders: InherentDataProviderExt + Send,
+{
+	let mut slots = Slots::new(slot_duration.as_duration(), create_inherent_data_providers, client);
+
+	loop {
+		let slot_info = slots.next_slot().await;
+
+		if sync_oracle.is_major_syncing() {
+			debug!(target: LOG_TARGET, "Skipping proposal slot due to sync.");
+			continue
+		}
+
+		let _ = worker.on_slot(slot_info).await;
+	}
+}
+
+/// A header which has been checked
+pub enum CheckedHeader<H, S> {
+	/// A header which has slot in the future. this is the full header (not stripped)
+	/// and the slot in which it should be processed.
+	Deferred(H, Slot),
+	/// A header which is fully checked, including signature. This is the pre-header
+	/// accompanied by the seal components.
+	///
+	/// Includes the digest item that encoded the seal.
+	Checked(H, S),
+}
+
+/// A unit type wrapper to express the proportion of a slot.
+pub struct SlotProportion(f32);
+
+impl SlotProportion {
+	/// Create a new proportion.
+	///
+	/// The given value `inner` should be in the range `[0,1]`. If the value is not in the required
+	/// range, it is clamped into the range.
+	pub fn new(inner: f32) -> Self {
+		Self(inner.clamp(0.0, 1.0))
+	}
+
+	/// Returns the inner that is guaranted to be in the range `[0,1]`.
+	pub fn get(&self) -> f32 {
+		self.0
+	}
+}
+
+/// The strategy used to calculate the slot lenience used to increase the block proposal time when
+/// slots have been skipped with no blocks authored.
+pub enum SlotLenienceType {
+	/// Increase the lenience linearly with the number of skipped slots.
+	Linear,
+	/// Increase the lenience exponentially with the number of skipped slots.
+	Exponential,
+}
+
+impl SlotLenienceType {
+	fn as_str(&self) -> &'static str {
+		match self {
+			SlotLenienceType::Linear => "linear",
+			SlotLenienceType::Exponential => "exponential",
+		}
+	}
+}
+
+/// Calculate the remaining duration for block proposal taking into account whether any slots have
+/// been skipped and applying the given lenience strategy. If `max_block_proposal_slot_portion` is
+/// not none this method guarantees that the returned duration must be lower or equal to
+/// `slot_info.duration * max_block_proposal_slot_portion`.
+pub fn proposing_remaining_duration<Block: BlockT>(
+	parent_slot: Option<Slot>,
+	slot_info: &SlotInfo<Block>,
+	block_proposal_slot_portion: &SlotProportion,
+	max_block_proposal_slot_portion: Option<&SlotProportion>,
+	slot_lenience_type: SlotLenienceType,
+	log_target: &str,
+) -> Duration {
+	use sp_runtime::traits::Zero;
+
+	let proposing_duration = slot_info.duration.mul_f32(block_proposal_slot_portion.get());
+
+	let slot_remaining = slot_info
+		.ends_at
+		.checked_duration_since(std::time::Instant::now())
+		.unwrap_or_default();
+
+	let proposing_duration = std::cmp::min(slot_remaining, proposing_duration);
+
+	// If parent is genesis block, we don't require any lenience factor.
+	if slot_info.chain_head.number().is_zero() {
+		return proposing_duration
+	}
+
+	let parent_slot = match parent_slot {
+		Some(parent_slot) => parent_slot,
+		None => return proposing_duration,
+	};
+
+	let slot_lenience = match slot_lenience_type {
+		SlotLenienceType::Exponential => slot_lenience_exponential(parent_slot, slot_info),
+		SlotLenienceType::Linear => slot_lenience_linear(parent_slot, slot_info),
+	};
+
+	if let Some(slot_lenience) = slot_lenience {
+		let lenient_proposing_duration =
+			proposing_duration + slot_lenience.mul_f32(block_proposal_slot_portion.get());
+
+		// if we defined a maximum portion of the slot for proposal then we must make sure the
+		// lenience doesn't go over it
+		let lenient_proposing_duration =
+			if let Some(max_block_proposal_slot_portion) = max_block_proposal_slot_portion {
+				std::cmp::min(
+					lenient_proposing_duration,
+					slot_info.duration.mul_f32(max_block_proposal_slot_portion.get()),
+				)
+			} else {
+				lenient_proposing_duration
+			};
+
+		debug!(
+			target: log_target,
+			"No block for {} slots. Applying {} lenience, total proposing duration: {}ms",
+			slot_info.slot.saturating_sub(parent_slot + 1),
+			slot_lenience_type.as_str(),
+			lenient_proposing_duration.as_millis(),
+		);
+
+		lenient_proposing_duration
+	} else {
+		proposing_duration
+	}
+}
+
+/// Calculate a slot duration lenience based on the number of missed slots from current
+/// to parent. If the number of skipped slots is greated than 0 this method will apply
+/// an exponential backoff of at most `2^7 * slot_duration`, if no slots were skipped
+/// this method will return `None.`
+pub fn slot_lenience_exponential<Block: BlockT>(
+	parent_slot: Slot,
+	slot_info: &SlotInfo<Block>,
+) -> Option<Duration> {
+	// never give more than 2^this times the lenience.
+	const BACKOFF_CAP: u64 = 7;
+
+	// how many slots it takes before we double the lenience.
+	const BACKOFF_STEP: u64 = 2;
+
+	// we allow a lenience of the number of slots since the head of the
+	// chain was produced, minus 1 (since there is always a difference of at least 1)
+	//
+	// exponential back-off.
+	// in normal cases we only attempt to issue blocks up to the end of the slot.
+	// when the chain has been stalled for a few slots, we give more lenience.
+	let skipped_slots = *slot_info.slot.saturating_sub(parent_slot + 1);
+
+	if skipped_slots == 0 {
+		None
+	} else {
+		let slot_lenience = skipped_slots / BACKOFF_STEP;
+		let slot_lenience = std::cmp::min(slot_lenience, BACKOFF_CAP);
+		let slot_lenience = 1 << slot_lenience;
+		Some(slot_lenience * slot_info.duration)
+	}
+}
+
+/// Calculate a slot duration lenience based on the number of missed slots from current
+/// to parent. If the number of skipped slots is greated than 0 this method will apply
+/// a linear backoff of at most `20 * slot_duration`, if no slots were skipped
+/// this method will return `None.`
+pub fn slot_lenience_linear<Block: BlockT>(
+	parent_slot: Slot,
+	slot_info: &SlotInfo<Block>,
+) -> Option<Duration> {
+	// never give more than 20 times more lenience.
+	const BACKOFF_CAP: u64 = 20;
+
+	// we allow a lenience of the number of slots since the head of the
+	// chain was produced, minus 1 (since there is always a difference of at least 1)
+	//
+	// linear back-off.
+	// in normal cases we only attempt to issue blocks up to the end of the slot.
+	// when the chain has been stalled for a few slots, we give more lenience.
+	let skipped_slots = *slot_info.slot.saturating_sub(parent_slot + 1);
+
+	if skipped_slots == 0 {
+		None
+	} else {
+		let slot_lenience = std::cmp::min(skipped_slots, BACKOFF_CAP);
+		// We cap `slot_lenience` to `20`, so it should always fit into an `u32`.
+		Some(slot_info.duration * (slot_lenience as u32))
+	}
+}
+
+/// Trait for providing the strategy for when to backoff block authoring.
+pub trait BackoffAuthoringBlocksStrategy<N> {
+	/// Returns true if we should backoff authoring new blocks.
+	fn should_backoff(
+		&self,
+		chain_head_number: N,
+		chain_head_slot: Slot,
+		finalized_number: N,
+		slow_now: Slot,
+		logging_target: &str,
+	) -> bool;
+}
+
+/// A simple default strategy for how to decide backing off authoring blocks if the number of
+/// unfinalized blocks grows too large.
+#[derive(Clone)]
+pub struct BackoffAuthoringOnFinalizedHeadLagging<N> {
+	/// The max interval to backoff when authoring blocks, regardless of delay in finality.
+	pub max_interval: N,
+	/// The number of unfinalized blocks allowed before starting to consider to backoff authoring
+	/// blocks. Note that depending on the value for `authoring_bias`, there might still be an
+	/// additional wait until block authorship starts getting declined.
+	pub unfinalized_slack: N,
+	/// Scales the backoff rate. A higher value effectively means we backoff slower, taking longer
+	/// time to reach the maximum backoff as the unfinalized head of chain grows.
+	pub authoring_bias: N,
+}
+
+/// These parameters is supposed to be some form of sensible defaults.
+impl<N: BaseArithmetic> Default for BackoffAuthoringOnFinalizedHeadLagging<N> {
+	fn default() -> Self {
+		Self {
+			// Never wait more than 100 slots before authoring blocks, regardless of delay in
+			// finality.
+			max_interval: 100.into(),
+			// Start to consider backing off block authorship once we have 50 or more unfinalized
+			// blocks at the head of the chain.
+			unfinalized_slack: 50.into(),
+			// A reasonable default for the authoring bias, or reciprocal interval scaling, is 2.
+			// Effectively meaning that consider the unfinalized head suffix length to grow half as
+			// fast as in actuality.
+			authoring_bias: 2.into(),
+		}
+	}
+}
+
+impl<N> BackoffAuthoringBlocksStrategy<N> for BackoffAuthoringOnFinalizedHeadLagging<N>
+where
+	N: BaseArithmetic + Copy,
+{
+	fn should_backoff(
+		&self,
+		chain_head_number: N,
+		chain_head_slot: Slot,
+		finalized_number: N,
+		slot_now: Slot,
+		logging_target: &str,
+	) -> bool {
+		// This should not happen, but we want to keep the previous behaviour if it does.
+		if slot_now <= chain_head_slot {
+			return false
+		}
+
+		// There can be race between getting the finalized number and getting the best number.
+		// So, better be safe than sorry.
+		let unfinalized_block_length = chain_head_number.saturating_sub(finalized_number);
+		let interval =
+			unfinalized_block_length.saturating_sub(self.unfinalized_slack) / self.authoring_bias;
+		let interval = interval.min(self.max_interval);
+
+		// We're doing arithmetic between block and slot numbers.
+		let interval: u64 = interval.unique_saturated_into();
+
+		// If interval is nonzero we backoff if the current slot isn't far enough ahead of the chain
+		// head.
+		if *slot_now <= *chain_head_slot + interval {
+			info!(
+				target: logging_target,
+				"Backing off claiming new slot for block authorship: finality is lagging.",
+			);
+			true
+		} else {
+			false
+		}
+	}
+}
+
+impl<N> BackoffAuthoringBlocksStrategy<N> for () {
+	fn should_backoff(
+		&self,
+		_chain_head_number: N,
+		_chain_head_slot: Slot,
+		_finalized_number: N,
+		_slot_now: Slot,
+		_logging_target: &str,
+	) -> bool {
+		false
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use sp_runtime::traits::NumberFor;
+	use std::time::{Duration, Instant};
+	use substrate_test_runtime_client::runtime::{Block, Header};
+
+	const SLOT_DURATION: Duration = Duration::from_millis(6000);
+
+	fn slot(slot: u64) -> super::slots::SlotInfo<Block> {
+		super::slots::SlotInfo {
+			slot: slot.into(),
+			duration: SLOT_DURATION,
+			create_inherent_data: Box::new(()),
+			ends_at: Instant::now() + SLOT_DURATION,
+			chain_head: Header::new(
+				1,
+				Default::default(),
+				Default::default(),
+				Default::default(),
+				Default::default(),
+			),
+			block_size_limit: None,
+		}
+	}
+
+	#[test]
+	fn linear_slot_lenience() {
+		// if no slots are skipped there should be no lenience
+		assert_eq!(super::slot_lenience_linear(1u64.into(), &slot(2)), None);
+
+		// otherwise the lenience is incremented linearly with
+		// the number of skipped slots.
+		for n in 3..=22 {
+			assert_eq!(
+				super::slot_lenience_linear(1u64.into(), &slot(n)),
+				Some(SLOT_DURATION * (n - 2) as u32),
+			);
+		}
+
+		// but we cap it to a maximum of 20 slots
+		assert_eq!(super::slot_lenience_linear(1u64.into(), &slot(23)), Some(SLOT_DURATION * 20));
+	}
+
+	#[test]
+	fn exponential_slot_lenience() {
+		// if no slots are skipped there should be no lenience
+		assert_eq!(super::slot_lenience_exponential(1u64.into(), &slot(2)), None);
+
+		// otherwise the lenience is incremented exponentially every two slots
+		for n in 3..=17 {
+			assert_eq!(
+				super::slot_lenience_exponential(1u64.into(), &slot(n)),
+				Some(SLOT_DURATION * 2u32.pow((n / 2 - 1) as u32)),
+			);
+		}
+
+		// but we cap it to a maximum of 14 slots
+		assert_eq!(
+			super::slot_lenience_exponential(1u64.into(), &slot(18)),
+			Some(SLOT_DURATION * 2u32.pow(7)),
+		);
+
+		assert_eq!(
+			super::slot_lenience_exponential(1u64.into(), &slot(19)),
+			Some(SLOT_DURATION * 2u32.pow(7)),
+		);
+	}
+
+	#[test]
+	fn proposing_remaining_duration_should_apply_lenience_based_on_proposal_slot_proportion() {
+		assert_eq!(
+			proposing_remaining_duration(
+				Some(0.into()),
+				&slot(2),
+				&SlotProportion(0.25),
+				None,
+				SlotLenienceType::Linear,
+				"test",
+			),
+			SLOT_DURATION.mul_f32(0.25 * 2.0),
+		);
+	}
+
+	#[test]
+	fn proposing_remaining_duration_should_never_exceed_max_proposal_slot_proportion() {
+		assert_eq!(
+			proposing_remaining_duration(
+				Some(0.into()),
+				&slot(100),
+				&SlotProportion(0.25),
+				Some(SlotProportion(0.9)).as_ref(),
+				SlotLenienceType::Exponential,
+				"test",
+			),
+			SLOT_DURATION.mul_f32(0.9),
+		);
+	}
+
+	#[derive(PartialEq, Debug)]
+	struct HeadState {
+		head_number: NumberFor<Block>,
+		head_slot: u64,
+		slot_now: NumberFor<Block>,
+	}
+
+	impl HeadState {
+		fn author_block(&mut self) {
+			// Add a block to the head, and set latest slot to the current
+			self.head_number += 1;
+			self.head_slot = self.slot_now;
+			// Advance slot to next
+			self.slot_now += 1;
+		}
+
+		fn dont_author_block(&mut self) {
+			self.slot_now += 1;
+		}
+	}
+
+	#[test]
+	fn should_never_backoff_when_head_not_advancing() {
+		let strategy = BackoffAuthoringOnFinalizedHeadLagging::<NumberFor<Block>> {
+			max_interval: 100,
+			unfinalized_slack: 5,
+			authoring_bias: 2,
+		};
+
+		let head_number = 1;
+		let head_slot = 1;
+		let finalized_number = 1;
+		let slot_now = 2;
+
+		let should_backoff: Vec<bool> = (slot_now..1000)
+			.map(|s| {
+				strategy.should_backoff(
+					head_number,
+					head_slot.into(),
+					finalized_number,
+					s.into(),
+					"slots",
+				)
+			})
+			.collect();
+
+		// Should always be false, since the head isn't advancing
+		let expected: Vec<bool> = (slot_now..1000).map(|_| false).collect();
+		assert_eq!(should_backoff, expected);
+	}
+
+	#[test]
+	fn should_stop_authoring_if_blocks_are_still_produced_when_finality_stalled() {
+		let strategy = BackoffAuthoringOnFinalizedHeadLagging::<NumberFor<Block>> {
+			max_interval: 100,
+			unfinalized_slack: 5,
+			authoring_bias: 2,
+		};
+
+		let mut head_number = 1;
+		let mut head_slot = 1;
+		let finalized_number = 1;
+		let slot_now = 2;
+
+		let should_backoff: Vec<bool> = (slot_now..300)
+			.map(move |s| {
+				let b = strategy.should_backoff(
+					head_number,
+					head_slot.into(),
+					finalized_number,
+					s.into(),
+					"slots",
+				);
+				// Chain is still advancing (by someone else)
+				head_number += 1;
+				head_slot = s;
+				b
+			})
+			.collect();
+
+		// Should always be true after a short while, since the chain is advancing but finality is
+		// stalled
+		let expected: Vec<bool> = (slot_now..300).map(|s| s > 8).collect();
+		assert_eq!(should_backoff, expected);
+	}
+
+	#[test]
+	fn should_never_backoff_if_max_interval_is_reached() {
+		let strategy = BackoffAuthoringOnFinalizedHeadLagging::<NumberFor<Block>> {
+			max_interval: 100,
+			unfinalized_slack: 5,
+			authoring_bias: 2,
+		};
+
+		// The limit `max_interval` is used when the unfinalized chain grows to
+		// 	`max_interval * authoring_bias + unfinalized_slack`,
+		// which for the above parameters becomes
+		// 	100 * 2 + 5 = 205.
+		// Hence we trigger this with head_number > finalized_number + 205.
+		let head_number = 207;
+		let finalized_number = 1;
+
+		// The limit is then used once the current slot is `max_interval` ahead of slot of the head.
+		let head_slot = 1;
+		let slot_now = 2;
+		let max_interval = strategy.max_interval;
+
+		let should_backoff: Vec<bool> = (slot_now..200)
+			.map(|s| {
+				strategy.should_backoff(
+					head_number,
+					head_slot.into(),
+					finalized_number,
+					s.into(),
+					"slots",
+				)
+			})
+			.collect();
+
+		// Should backoff (true) until we are `max_interval` number of slots ahead of the chain
+		// head slot, then we never backoff (false).
+		let expected: Vec<bool> = (slot_now..200).map(|s| s <= max_interval + head_slot).collect();
+		assert_eq!(should_backoff, expected);
+	}
+
+	#[test]
+	fn should_backoff_authoring_when_finality_stalled() {
+		let param = BackoffAuthoringOnFinalizedHeadLagging {
+			max_interval: 100,
+			unfinalized_slack: 5,
+			authoring_bias: 2,
+		};
+
+		let finalized_number = 2;
+		let mut head_state = HeadState { head_number: 4, head_slot: 10, slot_now: 11 };
+
+		let should_backoff = |head_state: &HeadState| -> bool {
+			<dyn BackoffAuthoringBlocksStrategy<NumberFor<Block>>>::should_backoff(
+				&param,
+				head_state.head_number,
+				head_state.head_slot.into(),
+				finalized_number,
+				head_state.slot_now.into(),
+				"slots",
+			)
+		};
+
+		let backoff: Vec<bool> = (head_state.slot_now..200)
+			.map(|_| {
+				if should_backoff(&head_state) {
+					head_state.dont_author_block();
+					true
+				} else {
+					head_state.author_block();
+					false
+				}
+			})
+			.collect();
+
+		// Gradually start to backoff more and more frequently
+		let expected = [
+			false, false, false, false, false, // no effect
+			true, false, true, false, // 1:1
+			true, true, false, true, true, false, // 2:1
+			true, true, true, false, true, true, true, false, // 3:1
+			true, true, true, true, false, true, true, true, true, false, // 4:1
+			true, true, true, true, true, false, true, true, true, true, true, false, // 5:1
+			true, true, true, true, true, true, false, true, true, true, true, true, true,
+			false, // 6:1
+			true, true, true, true, true, true, true, false, true, true, true, true, true, true,
+			true, false, // 7:1
+			true, true, true, true, true, true, true, true, false, true, true, true, true, true,
+			true, true, true, false, // 8:1
+			true, true, true, true, true, true, true, true, true, false, true, true, true, true,
+			true, true, true, true, true, false, // 9:1
+			true, true, true, true, true, true, true, true, true, true, false, true, true, true,
+			true, true, true, true, true, true, true, false, // 10:1
+			true, true, true, true, true, true, true, true, true, true, true, false, true, true,
+			true, true, true, true, true, true, true, true, true, false, // 11:1
+			true, true, true, true, true, true, true, true, true, true, true, true, false, true,
+			true, true, true, true, true, true, true, true, true, true, true, false, // 12:1
+			true, true, true, true,
+		];
+
+		assert_eq!(backoff.as_slice(), &expected[..]);
+	}
+
+	#[test]
+	fn should_never_wait_more_than_max_interval() {
+		let param = BackoffAuthoringOnFinalizedHeadLagging {
+			max_interval: 100,
+			unfinalized_slack: 5,
+			authoring_bias: 2,
+		};
+
+		let finalized_number = 2;
+		let starting_slot = 11;
+		let mut head_state = HeadState { head_number: 4, head_slot: 10, slot_now: starting_slot };
+
+		let should_backoff = |head_state: &HeadState| -> bool {
+			<dyn BackoffAuthoringBlocksStrategy<NumberFor<Block>>>::should_backoff(
+				&param,
+				head_state.head_number,
+				head_state.head_slot.into(),
+				finalized_number,
+				head_state.slot_now.into(),
+				"slots",
+			)
+		};
+
+		let backoff: Vec<bool> = (head_state.slot_now..40000)
+			.map(|_| {
+				if should_backoff(&head_state) {
+					head_state.dont_author_block();
+					true
+				} else {
+					head_state.author_block();
+					false
+				}
+			})
+			.collect();
+
+		let slots_claimed: Vec<usize> = backoff
+			.iter()
+			.enumerate()
+			.filter(|&(_i, x)| x == &false)
+			.map(|(i, _x)| i + starting_slot as usize)
+			.collect();
+
+		let last_slot = backoff.len() + starting_slot as usize;
+		let mut last_two_claimed = slots_claimed.iter().rev().take(2);
+
+		// Check that we claimed all the way to the end. Check two slots for when we have an uneven
+		// number of slots_claimed.
+		let expected_distance = param.max_interval as usize + 1;
+		assert_eq!(last_slot - last_two_claimed.next().unwrap(), 92);
+		assert_eq!(last_slot - last_two_claimed.next().unwrap(), 92 + expected_distance);
+
+		let intervals: Vec<_> = slots_claimed.windows(2).map(|x| x[1] - x[0]).collect();
+
+		// The key thing is that the distance between claimed slots is capped to `max_interval + 1`
+		// assert_eq!(max_observed_interval, Some(&expected_distance));
+		assert_eq!(intervals.iter().max(), Some(&expected_distance));
+
+		// But lets assert all distances, which we expect to grow linearly until `max_interval + 1`
+		let expected_intervals: Vec<_> =
+			(0..497).map(|i| (i / 2).clamp(1, expected_distance)).collect();
+
+		assert_eq!(intervals, expected_intervals);
+	}
+
+	fn run_until_max_interval(param: BackoffAuthoringOnFinalizedHeadLagging<u64>) -> (u64, u64) {
+		let finalized_number = 0;
+		let mut head_state = HeadState { head_number: 0, head_slot: 0, slot_now: 1 };
+
+		let should_backoff = |head_state: &HeadState| -> bool {
+			<dyn BackoffAuthoringBlocksStrategy<NumberFor<Block>>>::should_backoff(
+				&param,
+				head_state.head_number,
+				head_state.head_slot.into(),
+				finalized_number,
+				head_state.slot_now.into(),
+				"slots",
+			)
+		};
+
+		// Number of blocks until we reach the max interval
+		let block_for_max_interval =
+			param.max_interval * param.authoring_bias + param.unfinalized_slack;
+
+		while head_state.head_number < block_for_max_interval {
+			if should_backoff(&head_state) {
+				head_state.dont_author_block();
+			} else {
+				head_state.author_block();
+			}
+		}
+
+		let slot_time = 6;
+		let time_to_reach_limit = slot_time * head_state.slot_now;
+		(block_for_max_interval, time_to_reach_limit)
+	}
+
+	// Denoting
+	// 	C: unfinalized_slack
+	// 	M: authoring_bias
+	// 	X: max_interval
+	// then the number of slots to reach the max interval can be computed from
+	// 	(start_slot + C) + M * sum(n, 1, X)
+	// or
+	// 	(start_slot + C) + M * X*(X+1)/2
+	fn expected_time_to_reach_max_interval(
+		param: &BackoffAuthoringOnFinalizedHeadLagging<u64>,
+	) -> (u64, u64) {
+		let c = param.unfinalized_slack;
+		let m = param.authoring_bias;
+		let x = param.max_interval;
+		let slot_time = 6;
+
+		let block_for_max_interval = x * m + c;
+
+		// The 1 is because we start at slot_now = 1.
+		let expected_number_of_slots = (1 + c) + m * x * (x + 1) / 2;
+		let time_to_reach = expected_number_of_slots * slot_time;
+
+		(block_for_max_interval, time_to_reach)
+	}
+
+	#[test]
+	fn time_to_reach_upper_bound_for_smaller_slack() {
+		let param = BackoffAuthoringOnFinalizedHeadLagging {
+			max_interval: 100,
+			unfinalized_slack: 5,
+			authoring_bias: 2,
+		};
+		let expected = expected_time_to_reach_max_interval(&param);
+		let (block_for_max_interval, time_to_reach_limit) = run_until_max_interval(param);
+		assert_eq!((block_for_max_interval, time_to_reach_limit), expected);
+		// Note: 16 hours is 57600 sec
+		assert_eq!((block_for_max_interval, time_to_reach_limit), (205, 60636));
+	}
+
+	#[test]
+	fn time_to_reach_upper_bound_for_larger_slack() {
+		let param = BackoffAuthoringOnFinalizedHeadLagging {
+			max_interval: 100,
+			unfinalized_slack: 50,
+			authoring_bias: 2,
+		};
+		let expected = expected_time_to_reach_max_interval(&param);
+		let (block_for_max_interval, time_to_reach_limit) = run_until_max_interval(param);
+		assert_eq!((block_for_max_interval, time_to_reach_limit), expected);
+		assert_eq!((block_for_max_interval, time_to_reach_limit), (250, 60906));
+	}
+}
diff --git a/substrate/client/consensus/slots/src/slots.rs b/substrate/client/consensus/slots/src/slots.rs
new file mode 100644
index 0000000000000000000000000000000000000000..203764310601af5f6225582a1e775a6beeb4d1dc
--- /dev/null
+++ b/substrate/client/consensus/slots/src/slots.rs
@@ -0,0 +1,187 @@
+// 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/>.
+
+//! Utility stream for yielding slots in a loop.
+//!
+//! This is used instead of `futures_timer::Interval` because it was unreliable.
+
+use super::{InherentDataProviderExt, Slot, LOG_TARGET};
+use sp_consensus::SelectChain;
+use sp_inherents::{CreateInherentDataProviders, InherentDataProvider};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+
+use futures_timer::Delay;
+use std::time::{Duration, Instant};
+
+/// Returns current duration since unix epoch.
+pub fn duration_now() -> Duration {
+	use std::time::SystemTime;
+	let now = SystemTime::now();
+	now.duration_since(SystemTime::UNIX_EPOCH).unwrap_or_else(|e| {
+		panic!("Current time {:?} is before unix epoch. Something is wrong: {:?}", now, e)
+	})
+}
+
+/// Returns the duration until the next slot from now.
+pub fn time_until_next_slot(slot_duration: Duration) -> Duration {
+	let now = duration_now().as_millis();
+
+	let next_slot = (now + slot_duration.as_millis()) / slot_duration.as_millis();
+	let remaining_millis = next_slot * slot_duration.as_millis() - now;
+	Duration::from_millis(remaining_millis as u64)
+}
+
+/// Information about a slot.
+pub struct SlotInfo<B: BlockT> {
+	/// The slot number as found in the inherent data.
+	pub slot: Slot,
+	/// The instant at which the slot ends.
+	pub ends_at: Instant,
+	/// The inherent data provider.
+	pub create_inherent_data: Box<dyn InherentDataProvider>,
+	/// Slot duration.
+	pub duration: Duration,
+	/// The chain header this slot is based on.
+	pub chain_head: B::Header,
+	/// Some potential block size limit for the block to be authored at this slot.
+	///
+	/// For more information see [`Proposer::propose`](sp_consensus::Proposer::propose).
+	pub block_size_limit: Option<usize>,
+}
+
+impl<B: BlockT> SlotInfo<B> {
+	/// Create a new [`SlotInfo`].
+	///
+	/// `ends_at` is calculated using `timestamp` and `duration`.
+	pub fn new(
+		slot: Slot,
+		create_inherent_data: Box<dyn InherentDataProvider>,
+		duration: Duration,
+		chain_head: B::Header,
+		block_size_limit: Option<usize>,
+	) -> Self {
+		Self {
+			slot,
+			create_inherent_data,
+			duration,
+			chain_head,
+			block_size_limit,
+			ends_at: Instant::now() + time_until_next_slot(duration),
+		}
+	}
+}
+
+/// A stream that returns every time there is a new slot.
+pub(crate) struct Slots<Block, SC, IDP> {
+	last_slot: Slot,
+	slot_duration: Duration,
+	until_next_slot: Option<Delay>,
+	create_inherent_data_providers: IDP,
+	select_chain: SC,
+	_phantom: std::marker::PhantomData<Block>,
+}
+
+impl<Block, SC, IDP> Slots<Block, SC, IDP> {
+	/// Create a new `Slots` stream.
+	pub fn new(
+		slot_duration: Duration,
+		create_inherent_data_providers: IDP,
+		select_chain: SC,
+	) -> Self {
+		Slots {
+			last_slot: 0.into(),
+			slot_duration,
+			until_next_slot: None,
+			create_inherent_data_providers,
+			select_chain,
+			_phantom: Default::default(),
+		}
+	}
+}
+
+impl<Block, SC, IDP> Slots<Block, SC, IDP>
+where
+	Block: BlockT,
+	SC: SelectChain<Block>,
+	IDP: CreateInherentDataProviders<Block, ()> + 'static,
+	IDP::InherentDataProviders: crate::InherentDataProviderExt,
+{
+	/// Returns a future that fires when the next slot starts.
+	pub async fn next_slot(&mut self) -> SlotInfo<Block> {
+		loop {
+			// Wait for slot timeout
+			self.until_next_slot
+				.take()
+				.unwrap_or_else(|| {
+					// Schedule first timeout.
+					let wait_dur = time_until_next_slot(self.slot_duration);
+					Delay::new(wait_dur)
+				})
+				.await;
+
+			// Schedule delay for next slot.
+			let wait_dur = time_until_next_slot(self.slot_duration);
+			self.until_next_slot = Some(Delay::new(wait_dur));
+
+			let chain_head = match self.select_chain.best_chain().await {
+				Ok(x) => x,
+				Err(e) => {
+					log::warn!(
+						target: LOG_TARGET,
+						"Unable to author block in slot. No best block header: {}",
+						e,
+					);
+					// Let's retry at the next slot.
+					continue
+				},
+			};
+
+			let inherent_data_providers = match self
+				.create_inherent_data_providers
+				.create_inherent_data_providers(chain_head.hash(), ())
+				.await
+			{
+				Ok(x) => x,
+				Err(e) => {
+					log::warn!(
+						target: LOG_TARGET,
+						"Unable to author block in slot. Failure creating inherent data provider: {}",
+						e,
+					);
+					// Let's retry at the next slot.
+					continue
+				},
+			};
+
+			let slot = inherent_data_providers.slot();
+
+			// Never yield the same slot twice.
+			if slot > self.last_slot {
+				self.last_slot = slot;
+
+				break SlotInfo::new(
+					slot,
+					Box::new(inherent_data_providers),
+					self.slot_duration,
+					chain_head,
+					None,
+				)
+			}
+		}
+	}
+}
diff --git a/substrate/client/db/Cargo.toml b/substrate/client/db/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e351798a026f73b4fc6a26c2d20ad36875b2007c
--- /dev/null
+++ b/substrate/client/db/Cargo.toml
@@ -0,0 +1,63 @@
+[package]
+name = "sc-client-db"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Client backend that uses RocksDB database as storage."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = [
+	"derive",
+] }
+hash-db = "0.16.0"
+kvdb = "0.13.0"
+kvdb-memorydb = "0.13.0"
+kvdb-rocksdb = { version = "0.19.0", optional = true }
+linked-hash-map = "0.5.4"
+log = "0.4.17"
+parity-db = "0.4.8"
+parking_lot = "0.12.1"
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-state-db = { version = "0.10.0-dev", path = "../state-db" }
+schnellru = "0.2.1"
+sp-arithmetic = { version = "16.0.0", path = "../../primitives/arithmetic" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-database = { version = "4.0.0-dev", path = "../../primitives/database" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../primitives/state-machine" }
+sp-trie = { version = "22.0.0", path = "../../primitives/trie" }
+
+[dev-dependencies]
+criterion = "0.4.0"
+kvdb-rocksdb = "0.19.0"
+rand = "0.8.5"
+tempfile = "3.1.0"
+quickcheck = { version = "1.0.3", default-features = false }
+kitchensink-runtime = { path = "../../bin/node/runtime" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+array-bytes = "6.1"
+
+[features]
+default = []
+test-helpers = []
+runtime-benchmarks = [
+	"kitchensink-runtime/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+rocksdb = [ "kvdb-rocksdb" ]
+
+[[bench]]
+name = "state_access"
+harness = false
+
+[lib]
+bench = false
diff --git a/substrate/client/db/README.md b/substrate/client/db/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e5fb3fce1d9763d92554b3d0c6262e4e3cfccd66
--- /dev/null
+++ b/substrate/client/db/README.md
@@ -0,0 +1,11 @@
+Client backend that is backed by a database.
+
+# Canonicality vs. Finality
+
+Finality indicates that a block will not be reverted, according to the consensus algorithm,
+while canonicality indicates that the block may be reverted, but we will be unable to do so,
+having discarded heavy state that will allow a chain reorganization.
+
+Finality implies canonicality but not vice-versa.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/db/benches/state_access.rs b/substrate/client/db/benches/state_access.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e47559e710df1e21dab3d2a57b0c6434dd790289
--- /dev/null
+++ b/substrate/client/db/benches/state_access.rs
@@ -0,0 +1,311 @@
+// 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 criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use rand::{distributions::Uniform, rngs::StdRng, Rng, SeedableRng};
+use sc_client_api::{Backend as _, BlockImportOperation, NewBlockState, StateBackend};
+use sc_client_db::{Backend, BlocksPruning, DatabaseSettings, DatabaseSource, PruningMode};
+use sp_core::H256;
+use sp_runtime::{
+	testing::{Block as RawBlock, ExtrinsicWrapper, Header},
+	StateVersion, Storage,
+};
+use tempfile::TempDir;
+
+pub(crate) type Block = RawBlock<ExtrinsicWrapper<u64>>;
+
+fn insert_blocks(db: &Backend<Block>, storage: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
+	let mut op = db.begin_operation().unwrap();
+	let mut header = Header {
+		number: 0,
+		parent_hash: Default::default(),
+		state_root: Default::default(),
+		digest: Default::default(),
+		extrinsics_root: Default::default(),
+	};
+
+	header.state_root = op
+		.set_genesis_state(
+			Storage {
+				top: vec![(
+					sp_core::storage::well_known_keys::CODE.to_vec(),
+					kitchensink_runtime::wasm_binary_unwrap().to_vec(),
+				)]
+				.into_iter()
+				.collect(),
+				children_default: Default::default(),
+			},
+			true,
+			StateVersion::V1,
+		)
+		.unwrap();
+
+	op.set_block_data(header.clone(), Some(vec![]), None, None, NewBlockState::Best)
+		.unwrap();
+
+	db.commit_operation(op).unwrap();
+
+	let mut number = 1;
+	let mut parent_hash = header.hash();
+
+	for i in 0..10 {
+		let mut op = db.begin_operation().unwrap();
+
+		db.begin_state_operation(&mut op, parent_hash).unwrap();
+
+		let mut header = Header {
+			number,
+			parent_hash,
+			state_root: Default::default(),
+			digest: Default::default(),
+			extrinsics_root: Default::default(),
+		};
+
+		let changes = storage
+			.iter()
+			.skip(i * 100_000)
+			.take(100_000)
+			.map(|(k, v)| (k.clone(), Some(v.clone())))
+			.collect::<Vec<_>>();
+
+		let (state_root, tx) = db.state_at(parent_hash).unwrap().storage_root(
+			changes.iter().map(|(k, v)| (k.as_slice(), v.as_deref())),
+			StateVersion::V1,
+		);
+		header.state_root = state_root;
+
+		op.update_db_storage(tx).unwrap();
+		op.update_storage(changes.clone(), Default::default()).unwrap();
+
+		op.set_block_data(header.clone(), Some(vec![]), None, None, NewBlockState::Best)
+			.unwrap();
+
+		db.commit_operation(op).unwrap();
+
+		number += 1;
+		parent_hash = header.hash();
+	}
+
+	parent_hash
+}
+
+enum BenchmarkConfig {
+	NoCache,
+	TrieNodeCache,
+}
+
+fn create_backend(config: BenchmarkConfig, temp_dir: &TempDir) -> Backend<Block> {
+	let path = temp_dir.path().to_owned();
+
+	let trie_cache_maximum_size = match config {
+		BenchmarkConfig::NoCache => None,
+		BenchmarkConfig::TrieNodeCache => Some(2 * 1024 * 1024 * 1024),
+	};
+
+	let settings = DatabaseSettings {
+		trie_cache_maximum_size,
+		state_pruning: Some(PruningMode::ArchiveAll),
+		source: DatabaseSource::ParityDb { path },
+		blocks_pruning: BlocksPruning::KeepAll,
+	};
+
+	Backend::new(settings, 100).expect("Creates backend")
+}
+
+/// Generate the storage that will be used for the benchmark
+///
+/// Returns the `Vec<key>` and the `Vec<(key, value)>`
+fn generate_storage() -> (Vec<Vec<u8>>, Vec<(Vec<u8>, Vec<u8>)>) {
+	let mut rng = StdRng::seed_from_u64(353893213);
+
+	let mut storage = Vec::new();
+	let mut keys = Vec::new();
+
+	for _ in 0..1_000_000 {
+		let key_len: usize = rng.gen_range(32..128);
+		let key = (&mut rng)
+			.sample_iter(Uniform::new_inclusive(0, 255))
+			.take(key_len)
+			.collect::<Vec<u8>>();
+
+		let value_len: usize = rng.gen_range(20..60);
+		let value = (&mut rng)
+			.sample_iter(Uniform::new_inclusive(0, 255))
+			.take(value_len)
+			.collect::<Vec<u8>>();
+
+		keys.push(key.clone());
+		storage.push((key, value));
+	}
+
+	(keys, storage)
+}
+
+fn state_access_benchmarks(c: &mut Criterion) {
+	sp_tracing::try_init_simple();
+
+	let (keys, storage) = generate_storage();
+	let path = TempDir::new().expect("Creates temporary directory");
+
+	let block_hash = {
+		let backend = create_backend(BenchmarkConfig::NoCache, &path);
+		insert_blocks(&backend, storage.clone())
+	};
+
+	let mut group = c.benchmark_group("Reading entire state");
+	group.sample_size(20);
+
+	let mut bench_multiple_values = |config, desc, multiplier| {
+		let backend = create_backend(config, &path);
+
+		group.bench_function(desc, |b| {
+			b.iter_batched(
+				|| backend.state_at(block_hash).expect("Creates state"),
+				|state| {
+					for key in keys.iter().cycle().take(keys.len() * multiplier) {
+						let _ = state.storage(&key).expect("Doesn't fail").unwrap();
+					}
+				},
+				BatchSize::SmallInput,
+			)
+		});
+	};
+
+	bench_multiple_values(
+		BenchmarkConfig::TrieNodeCache,
+		"with trie node cache and reading each key once",
+		1,
+	);
+	bench_multiple_values(BenchmarkConfig::NoCache, "no cache and reading each key once", 1);
+
+	bench_multiple_values(
+		BenchmarkConfig::TrieNodeCache,
+		"with trie node cache and reading 4 times each key in a row",
+		4,
+	);
+	bench_multiple_values(
+		BenchmarkConfig::NoCache,
+		"no cache and reading 4 times each key in a row",
+		4,
+	);
+
+	group.finish();
+
+	let mut group = c.benchmark_group("Reading a single value");
+
+	let mut bench_single_value = |config, desc, multiplier| {
+		let backend = create_backend(config, &path);
+
+		group.bench_function(desc, |b| {
+			b.iter_batched(
+				|| backend.state_at(block_hash).expect("Creates state"),
+				|state| {
+					for key in keys.iter().take(1).cycle().take(multiplier) {
+						let _ = state.storage(&key).expect("Doesn't fail").unwrap();
+					}
+				},
+				BatchSize::SmallInput,
+			)
+		});
+	};
+
+	bench_single_value(
+		BenchmarkConfig::TrieNodeCache,
+		"with trie node cache and reading the key once",
+		1,
+	);
+	bench_single_value(BenchmarkConfig::NoCache, "no cache and reading the key once", 1);
+
+	bench_single_value(
+		BenchmarkConfig::TrieNodeCache,
+		"with trie node cache and reading 4 times each key in a row",
+		4,
+	);
+	bench_single_value(
+		BenchmarkConfig::NoCache,
+		"no cache and reading 4 times each key in a row",
+		4,
+	);
+
+	group.finish();
+
+	let mut group = c.benchmark_group("Hashing a value");
+
+	let mut bench_single_value = |config, desc, multiplier| {
+		let backend = create_backend(config, &path);
+
+		group.bench_function(desc, |b| {
+			b.iter_batched(
+				|| backend.state_at(block_hash).expect("Creates state"),
+				|state| {
+					for key in keys.iter().take(1).cycle().take(multiplier) {
+						let _ = state.storage_hash(&key).expect("Doesn't fail").unwrap();
+					}
+				},
+				BatchSize::SmallInput,
+			)
+		});
+	};
+
+	bench_single_value(
+		BenchmarkConfig::TrieNodeCache,
+		"with trie node cache and hashing the key once",
+		1,
+	);
+	bench_single_value(BenchmarkConfig::NoCache, "no cache and hashing the key once", 1);
+
+	bench_single_value(
+		BenchmarkConfig::TrieNodeCache,
+		"with trie node cache and hashing 4 times each key in a row",
+		4,
+	);
+	bench_single_value(
+		BenchmarkConfig::NoCache,
+		"no cache and hashing 4 times each key in a row",
+		4,
+	);
+
+	group.finish();
+
+	let mut group = c.benchmark_group("Hashing `:code`");
+
+	let mut bench_single_value = |config, desc| {
+		let backend = create_backend(config, &path);
+
+		group.bench_function(desc, |b| {
+			b.iter_batched(
+				|| backend.state_at(block_hash).expect("Creates state"),
+				|state| {
+					let _ = state
+						.storage_hash(sp_core::storage::well_known_keys::CODE)
+						.expect("Doesn't fail")
+						.unwrap();
+				},
+				BatchSize::SmallInput,
+			)
+		});
+	};
+
+	bench_single_value(BenchmarkConfig::TrieNodeCache, "with trie node cache");
+	bench_single_value(BenchmarkConfig::NoCache, "no cache");
+
+	group.finish();
+}
+
+criterion_group!(benches, state_access_benchmarks);
+criterion_main!(benches);
diff --git a/substrate/client/db/src/bench.rs b/substrate/client/db/src/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..38c37a42ede79659639268eb34e10316c8cbed15
--- /dev/null
+++ b/substrate/client/db/src/bench.rs
@@ -0,0 +1,705 @@
+// 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/>.
+
+//! State backend that's useful for benchmarking
+
+use crate::{DbState, DbStateBuilder};
+use hash_db::{Hasher, Prefix};
+use kvdb::{DBTransaction, KeyValueDB};
+use linked_hash_map::LinkedHashMap;
+use parking_lot::Mutex;
+use sp_core::{
+	hexdisplay::HexDisplay,
+	storage::{ChildInfo, TrackedStorageKey},
+};
+use sp_runtime::{
+	traits::{Block as BlockT, HashingFor},
+	StateVersion, Storage,
+};
+use sp_state_machine::{
+	backend::Backend as StateBackend, BackendTransaction, ChildStorageCollection, DBValue,
+	IterArgs, StorageCollection, StorageIterator, StorageKey, StorageValue,
+};
+use sp_trie::{
+	cache::{CacheSize, SharedTrieCache},
+	prefixed_key, MemoryDB,
+};
+use std::{
+	cell::{Cell, RefCell},
+	collections::HashMap,
+	sync::Arc,
+};
+
+type State<B> = DbState<B>;
+
+struct StorageDb<Block: BlockT> {
+	db: Arc<dyn KeyValueDB>,
+	_block: std::marker::PhantomData<Block>,
+}
+
+impl<Block: BlockT> sp_state_machine::Storage<HashingFor<Block>> for StorageDb<Block> {
+	fn get(&self, key: &Block::Hash, prefix: Prefix) -> Result<Option<DBValue>, String> {
+		let prefixed_key = prefixed_key::<HashingFor<Block>>(key, prefix);
+		self.db
+			.get(0, &prefixed_key)
+			.map_err(|e| format!("Database backend error: {:?}", e))
+	}
+}
+
+struct KeyTracker {
+	enable_tracking: bool,
+	/// Key tracker for keys in the main trie.
+	/// We track the total number of reads and writes to these keys,
+	/// not de-duplicated for repeats.
+	main_keys: LinkedHashMap<Vec<u8>, TrackedStorageKey>,
+	/// Key tracker for keys in a child trie.
+	/// Child trie are identified by their storage key (i.e. `ChildInfo::storage_key()`)
+	/// We track the total number of reads and writes to these keys,
+	/// not de-duplicated for repeats.
+	child_keys: LinkedHashMap<Vec<u8>, LinkedHashMap<Vec<u8>, TrackedStorageKey>>,
+}
+
+/// State that manages the backend database reference. Allows runtime to control the database.
+pub struct BenchmarkingState<B: BlockT> {
+	root: Cell<B::Hash>,
+	genesis_root: B::Hash,
+	state: RefCell<Option<State<B>>>,
+	db: Cell<Option<Arc<dyn KeyValueDB>>>,
+	genesis: HashMap<Vec<u8>, (Vec<u8>, i32)>,
+	record: Cell<Vec<Vec<u8>>>,
+	key_tracker: Arc<Mutex<KeyTracker>>,
+	whitelist: RefCell<Vec<TrackedStorageKey>>,
+	proof_recorder: Option<sp_trie::recorder::Recorder<HashingFor<B>>>,
+	proof_recorder_root: Cell<B::Hash>,
+	shared_trie_cache: SharedTrieCache<HashingFor<B>>,
+}
+
+/// A raw iterator over the `BenchmarkingState`.
+pub struct RawIter<B: BlockT> {
+	inner: <DbState<B> as StateBackend<HashingFor<B>>>::RawIter,
+	child_trie: Option<Vec<u8>>,
+	key_tracker: Arc<Mutex<KeyTracker>>,
+}
+
+impl<B: BlockT> StorageIterator<HashingFor<B>> for RawIter<B> {
+	type Backend = BenchmarkingState<B>;
+	type Error = String;
+
+	fn next_key(&mut self, backend: &Self::Backend) -> Option<Result<StorageKey, Self::Error>> {
+		match self.inner.next_key(backend.state.borrow().as_ref()?) {
+			Some(Ok(key)) => {
+				self.key_tracker.lock().add_read_key(self.child_trie.as_deref(), &key);
+				Some(Ok(key))
+			},
+			result => result,
+		}
+	}
+
+	fn next_pair(
+		&mut self,
+		backend: &Self::Backend,
+	) -> Option<Result<(StorageKey, StorageValue), Self::Error>> {
+		match self.inner.next_pair(backend.state.borrow().as_ref()?) {
+			Some(Ok((key, value))) => {
+				self.key_tracker.lock().add_read_key(self.child_trie.as_deref(), &key);
+				Some(Ok((key, value)))
+			},
+			result => result,
+		}
+	}
+
+	fn was_complete(&self) -> bool {
+		self.inner.was_complete()
+	}
+}
+
+impl<B: BlockT> BenchmarkingState<B> {
+	/// Create a new instance that creates a database in a temporary dir.
+	pub fn new(
+		genesis: Storage,
+		_cache_size_mb: Option<usize>,
+		record_proof: bool,
+		enable_tracking: bool,
+	) -> Result<Self, String> {
+		let state_version = sp_runtime::StateVersion::default();
+		let mut root = B::Hash::default();
+		let mut mdb = MemoryDB::<HashingFor<B>>::default();
+		sp_trie::trie_types::TrieDBMutBuilderV1::<HashingFor<B>>::new(&mut mdb, &mut root).build();
+
+		let mut state = BenchmarkingState {
+			state: RefCell::new(None),
+			db: Cell::new(None),
+			root: Cell::new(root),
+			genesis: Default::default(),
+			genesis_root: Default::default(),
+			record: Default::default(),
+			key_tracker: Arc::new(Mutex::new(KeyTracker {
+				main_keys: Default::default(),
+				child_keys: Default::default(),
+				enable_tracking,
+			})),
+			whitelist: Default::default(),
+			proof_recorder: record_proof.then(Default::default),
+			proof_recorder_root: Cell::new(root),
+			// Enable the cache, but do not sync anything to the shared state.
+			shared_trie_cache: SharedTrieCache::new(CacheSize::new(0)),
+		};
+
+		state.add_whitelist_to_tracker();
+
+		state.reopen()?;
+		let child_delta = genesis.children_default.values().map(|child_content| {
+			(
+				&child_content.child_info,
+				child_content.data.iter().map(|(k, v)| (k.as_ref(), Some(v.as_ref()))),
+			)
+		});
+		let (root, transaction): (B::Hash, _) =
+			state.state.borrow().as_ref().unwrap().full_storage_root(
+				genesis.top.iter().map(|(k, v)| (k.as_ref(), Some(v.as_ref()))),
+				child_delta,
+				state_version,
+			);
+		state.genesis = transaction.clone().drain();
+		state.genesis_root = root;
+		state.commit(root, transaction, Vec::new(), Vec::new())?;
+		state.record.take();
+		Ok(state)
+	}
+
+	fn reopen(&self) -> Result<(), String> {
+		*self.state.borrow_mut() = None;
+		let db = match self.db.take() {
+			Some(db) => db,
+			None => Arc::new(kvdb_memorydb::create(1)),
+		};
+		self.db.set(Some(db.clone()));
+		if let Some(recorder) = &self.proof_recorder {
+			recorder.reset();
+			self.proof_recorder_root.set(self.root.get());
+		}
+		let storage_db = Arc::new(StorageDb::<B> { db, _block: Default::default() });
+		*self.state.borrow_mut() = Some(
+			DbStateBuilder::<B>::new(storage_db, self.root.get())
+				.with_optional_recorder(self.proof_recorder.clone())
+				.with_cache(self.shared_trie_cache.local_cache())
+				.build(),
+		);
+		Ok(())
+	}
+
+	fn add_whitelist_to_tracker(&self) {
+		self.key_tracker.lock().add_whitelist(&self.whitelist.borrow());
+	}
+
+	fn wipe_tracker(&self) {
+		let mut key_tracker = self.key_tracker.lock();
+		key_tracker.main_keys = LinkedHashMap::new();
+		key_tracker.child_keys = LinkedHashMap::new();
+		key_tracker.add_whitelist(&self.whitelist.borrow());
+	}
+
+	fn add_read_key(&self, childtrie: Option<&[u8]>, key: &[u8]) {
+		self.key_tracker.lock().add_read_key(childtrie, key);
+	}
+
+	fn add_write_key(&self, childtrie: Option<&[u8]>, key: &[u8]) {
+		self.key_tracker.lock().add_write_key(childtrie, key);
+	}
+
+	fn all_trackers(&self) -> Vec<TrackedStorageKey> {
+		self.key_tracker.lock().all_trackers()
+	}
+}
+
+impl KeyTracker {
+	fn add_whitelist(&mut self, whitelist: &[TrackedStorageKey]) {
+		whitelist.iter().for_each(|key| {
+			let mut whitelisted = TrackedStorageKey::new(key.key.clone());
+			whitelisted.whitelist();
+			self.main_keys.insert(key.key.clone(), whitelisted);
+		});
+	}
+
+	// Childtrie is identified by its storage key (i.e. `ChildInfo::storage_key`)
+	fn add_read_key(&mut self, childtrie: Option<&[u8]>, key: &[u8]) {
+		if !self.enable_tracking {
+			return
+		}
+
+		let child_key_tracker = &mut self.child_keys;
+		let main_key_tracker = &mut self.main_keys;
+
+		let key_tracker = if let Some(childtrie) = childtrie {
+			child_key_tracker.entry(childtrie.to_vec()).or_insert_with(LinkedHashMap::new)
+		} else {
+			main_key_tracker
+		};
+
+		let should_log = match key_tracker.get_mut(key) {
+			None => {
+				let mut has_been_read = TrackedStorageKey::new(key.to_vec());
+				has_been_read.add_read();
+				key_tracker.insert(key.to_vec(), has_been_read);
+				true
+			},
+			Some(tracker) => {
+				let should_log = !tracker.has_been_read();
+				tracker.add_read();
+				should_log
+			},
+		};
+
+		if should_log {
+			if let Some(childtrie) = childtrie {
+				log::trace!(
+					target: "benchmark",
+					"Childtrie Read: {} {}", HexDisplay::from(&childtrie), HexDisplay::from(&key)
+				);
+			} else {
+				log::trace!(target: "benchmark", "Read: {}", HexDisplay::from(&key));
+			}
+		}
+	}
+
+	// Childtrie is identified by its storage key (i.e. `ChildInfo::storage_key`)
+	fn add_write_key(&mut self, childtrie: Option<&[u8]>, key: &[u8]) {
+		if !self.enable_tracking {
+			return
+		}
+
+		let child_key_tracker = &mut self.child_keys;
+		let main_key_tracker = &mut self.main_keys;
+
+		let key_tracker = if let Some(childtrie) = childtrie {
+			child_key_tracker.entry(childtrie.to_vec()).or_insert_with(LinkedHashMap::new)
+		} else {
+			main_key_tracker
+		};
+
+		// If we have written to the key, we also consider that we have read from it.
+		let should_log = match key_tracker.get_mut(key) {
+			None => {
+				let mut has_been_written = TrackedStorageKey::new(key.to_vec());
+				has_been_written.add_write();
+				key_tracker.insert(key.to_vec(), has_been_written);
+				true
+			},
+			Some(tracker) => {
+				let should_log = !tracker.has_been_written();
+				tracker.add_write();
+				should_log
+			},
+		};
+
+		if should_log {
+			if let Some(childtrie) = childtrie {
+				log::trace!(
+					target: "benchmark",
+					"Childtrie Write: {} {}", HexDisplay::from(&childtrie), HexDisplay::from(&key)
+				);
+			} else {
+				log::trace!(target: "benchmark", "Write: {}", HexDisplay::from(&key));
+			}
+		}
+	}
+
+	// Return all the tracked storage keys among main and child trie.
+	fn all_trackers(&self) -> Vec<TrackedStorageKey> {
+		let mut all_trackers = Vec::new();
+
+		self.main_keys.iter().for_each(|(_, tracker)| {
+			all_trackers.push(tracker.clone());
+		});
+
+		self.child_keys.iter().for_each(|(_, child_tracker)| {
+			child_tracker.iter().for_each(|(_, tracker)| {
+				all_trackers.push(tracker.clone());
+			});
+		});
+
+		all_trackers
+	}
+}
+
+fn state_err() -> String {
+	"State is not open".into()
+}
+
+impl<B: BlockT> StateBackend<HashingFor<B>> for BenchmarkingState<B> {
+	type Error = <DbState<B> as StateBackend<HashingFor<B>>>::Error;
+	type TrieBackendStorage = <DbState<B> as StateBackend<HashingFor<B>>>::TrieBackendStorage;
+	type RawIter = RawIter<B>;
+
+	fn storage(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.add_read_key(None, key);
+		self.state.borrow().as_ref().ok_or_else(state_err)?.storage(key)
+	}
+
+	fn storage_hash(&self, key: &[u8]) -> Result<Option<B::Hash>, Self::Error> {
+		self.add_read_key(None, key);
+		self.state.borrow().as_ref().ok_or_else(state_err)?.storage_hash(key)
+	}
+
+	fn child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.add_read_key(Some(child_info.storage_key()), key);
+		self.state
+			.borrow()
+			.as_ref()
+			.ok_or_else(state_err)?
+			.child_storage(child_info, key)
+	}
+
+	fn child_storage_hash(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<B::Hash>, Self::Error> {
+		self.add_read_key(Some(child_info.storage_key()), key);
+		self.state
+			.borrow()
+			.as_ref()
+			.ok_or_else(state_err)?
+			.child_storage_hash(child_info, key)
+	}
+
+	fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> {
+		self.add_read_key(None, key);
+		self.state.borrow().as_ref().ok_or_else(state_err)?.exists_storage(key)
+	}
+
+	fn exists_child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<bool, Self::Error> {
+		self.add_read_key(Some(child_info.storage_key()), key);
+		self.state
+			.borrow()
+			.as_ref()
+			.ok_or_else(state_err)?
+			.exists_child_storage(child_info, key)
+	}
+
+	fn next_storage_key(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.add_read_key(None, key);
+		self.state.borrow().as_ref().ok_or_else(state_err)?.next_storage_key(key)
+	}
+
+	fn next_child_storage_key(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.add_read_key(Some(child_info.storage_key()), key);
+		self.state
+			.borrow()
+			.as_ref()
+			.ok_or_else(state_err)?
+			.next_child_storage_key(child_info, key)
+	}
+
+	fn storage_root<'a>(
+		&self,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (B::Hash, BackendTransaction<HashingFor<B>>) {
+		self.state
+			.borrow()
+			.as_ref()
+			.map_or(Default::default(), |s| s.storage_root(delta, state_version))
+	}
+
+	fn child_storage_root<'a>(
+		&self,
+		child_info: &ChildInfo,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (B::Hash, bool, BackendTransaction<HashingFor<B>>) {
+		self.state
+			.borrow()
+			.as_ref()
+			.map_or(Default::default(), |s| s.child_storage_root(child_info, delta, state_version))
+	}
+
+	fn raw_iter(&self, args: IterArgs) -> Result<Self::RawIter, Self::Error> {
+		let child_trie =
+			args.child_info.as_ref().map(|child_info| child_info.storage_key().to_vec());
+		self.state
+			.borrow()
+			.as_ref()
+			.map(|s| s.raw_iter(args))
+			.unwrap_or(Ok(Default::default()))
+			.map(|raw_iter| RawIter {
+				inner: raw_iter,
+				key_tracker: self.key_tracker.clone(),
+				child_trie,
+			})
+	}
+
+	fn commit(
+		&self,
+		storage_root: <HashingFor<B> as Hasher>::Out,
+		mut transaction: BackendTransaction<HashingFor<B>>,
+		main_storage_changes: StorageCollection,
+		child_storage_changes: ChildStorageCollection,
+	) -> Result<(), Self::Error> {
+		if let Some(db) = self.db.take() {
+			let mut db_transaction = DBTransaction::new();
+			let changes = transaction.drain();
+			let mut keys = Vec::with_capacity(changes.len());
+			for (key, (val, rc)) in changes {
+				if rc > 0 {
+					db_transaction.put(0, &key, &val);
+				} else if rc < 0 {
+					db_transaction.delete(0, &key);
+				}
+				keys.push(key);
+			}
+			let mut record = self.record.take();
+			record.extend(keys);
+			self.record.set(record);
+			db.write(db_transaction)
+				.map_err(|_| String::from("Error committing transaction"))?;
+			self.root.set(storage_root);
+			self.db.set(Some(db));
+
+			// Track DB Writes
+			main_storage_changes.iter().for_each(|(key, _)| {
+				self.add_write_key(None, key);
+			});
+			child_storage_changes.iter().for_each(|(child_storage_key, storage_changes)| {
+				storage_changes.iter().for_each(|(key, _)| {
+					self.add_write_key(Some(child_storage_key), key);
+				})
+			});
+		} else {
+			return Err("Trying to commit to a closed db".into())
+		}
+		self.reopen()
+	}
+
+	fn wipe(&self) -> Result<(), Self::Error> {
+		// Restore to genesis
+		let record = self.record.take();
+		if let Some(db) = self.db.take() {
+			let mut db_transaction = DBTransaction::new();
+			for key in record {
+				match self.genesis.get(&key) {
+					Some((v, _)) => db_transaction.put(0, &key, v),
+					None => db_transaction.delete(0, &key),
+				}
+			}
+			db.write(db_transaction)
+				.map_err(|_| String::from("Error committing transaction"))?;
+			self.db.set(Some(db));
+		}
+
+		self.root.set(self.genesis_root);
+		self.reopen()?;
+		self.wipe_tracker();
+		Ok(())
+	}
+
+	/// Get the key tracking information for the state db.
+	/// 1. `reads` - Total number of DB reads.
+	/// 2. `repeat_reads` - Total number of in-memory reads.
+	/// 3. `writes` - Total number of DB writes.
+	/// 4. `repeat_writes` - Total number of in-memory writes.
+	fn read_write_count(&self) -> (u32, u32, u32, u32) {
+		let mut reads = 0;
+		let mut repeat_reads = 0;
+		let mut writes = 0;
+		let mut repeat_writes = 0;
+
+		self.all_trackers().iter().for_each(|tracker| {
+			if !tracker.whitelisted {
+				if tracker.reads > 0 {
+					reads += 1;
+					repeat_reads += tracker.reads - 1;
+				}
+
+				if tracker.writes > 0 {
+					writes += 1;
+					repeat_writes += tracker.writes - 1;
+				}
+			}
+		});
+		(reads, repeat_reads, writes, repeat_writes)
+	}
+
+	/// Reset the key tracking information for the state db.
+	fn reset_read_write_count(&self) {
+		self.wipe_tracker()
+	}
+
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey> {
+		self.whitelist.borrow().to_vec()
+	}
+
+	fn set_whitelist(&self, new: Vec<TrackedStorageKey>) {
+		*self.whitelist.borrow_mut() = new;
+	}
+
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> {
+		// We only track at the level of a key-prefix and not whitelisted for now for memory size.
+		// TODO: Refactor to enable full storage key transparency, where we can remove the
+		// `prefix_key_tracker`.
+		let mut prefix_key_tracker = LinkedHashMap::<Vec<u8>, (u32, u32, bool)>::new();
+		self.all_trackers().iter().for_each(|tracker| {
+			if !tracker.whitelisted {
+				let prefix_length = tracker.key.len().min(32);
+				let prefix = tracker.key[0..prefix_length].to_vec();
+				// each read / write of a specific key is counted at most one time, since
+				// additional reads / writes happen in the memory overlay.
+				let reads = tracker.reads.min(1);
+				let writes = tracker.writes.min(1);
+				if let Some(prefix_tracker) = prefix_key_tracker.get_mut(&prefix) {
+					prefix_tracker.0 += reads;
+					prefix_tracker.1 += writes;
+				} else {
+					prefix_key_tracker.insert(prefix, (reads, writes, tracker.whitelisted));
+				}
+			}
+		});
+
+		prefix_key_tracker
+			.iter()
+			.map(|(key, tracker)| -> (Vec<u8>, u32, u32, bool) {
+				(key.to_vec(), tracker.0, tracker.1, tracker.2)
+			})
+			.collect::<Vec<_>>()
+	}
+
+	fn register_overlay_stats(&self, stats: &sp_state_machine::StateMachineStats) {
+		self.state.borrow().as_ref().map(|s| s.register_overlay_stats(stats));
+	}
+
+	fn usage_info(&self) -> sp_state_machine::UsageInfo {
+		self.state
+			.borrow()
+			.as_ref()
+			.map_or(sp_state_machine::UsageInfo::empty(), |s| s.usage_info())
+	}
+
+	fn proof_size(&self) -> Option<u32> {
+		self.proof_recorder.as_ref().map(|recorder| {
+			let proof_size = recorder.estimate_encoded_size() as u32;
+
+			let proof = recorder.to_storage_proof();
+
+			let proof_recorder_root = self.proof_recorder_root.get();
+			if proof_recorder_root == Default::default() || proof_size == 1 {
+				// empty trie
+				log::debug!(target: "benchmark", "Some proof size: {}", &proof_size);
+				proof_size
+			} else {
+				if let Some(size) = proof.encoded_compact_size::<HashingFor<B>>(proof_recorder_root)
+				{
+					size as u32
+				} else if proof_recorder_root == self.root.get() {
+					log::debug!(target: "benchmark", "No changes - no proof");
+					0
+				} else {
+					panic!(
+						"proof rec root {:?}, root {:?}, genesis {:?}, rec_len {:?}",
+						self.proof_recorder_root.get(),
+						self.root.get(),
+						self.genesis_root,
+						proof_size,
+					);
+				}
+			}
+		})
+	}
+}
+
+impl<Block: BlockT> std::fmt::Debug for BenchmarkingState<Block> {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "Bench DB")
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use crate::bench::BenchmarkingState;
+	use sp_state_machine::backend::Backend as _;
+
+	fn hex(hex: &str) -> Vec<u8> {
+		array_bytes::hex2bytes(hex).unwrap()
+	}
+
+	#[test]
+	fn iteration_is_also_counted_in_rw_counts() {
+		let storage = sp_runtime::Storage {
+			top: vec![(
+				hex("ce6e1397e668c7fcf47744350dc59688455a2c2dbd2e2a649df4e55d93cd7158"),
+				hex("0102030405060708"),
+			)]
+			.into_iter()
+			.collect(),
+			..sp_runtime::Storage::default()
+		};
+		let bench_state =
+			BenchmarkingState::<crate::tests::Block>::new(storage, None, false, true).unwrap();
+
+		assert_eq!(bench_state.read_write_count(), (0, 0, 0, 0));
+		assert_eq!(bench_state.keys(Default::default()).unwrap().count(), 1);
+		assert_eq!(bench_state.read_write_count(), (1, 0, 0, 0));
+	}
+
+	#[test]
+	fn read_to_main_and_child_tries() {
+		let bench_state =
+			BenchmarkingState::<crate::tests::Block>::new(Default::default(), None, false, true)
+				.unwrap();
+
+		for _ in 0..2 {
+			let child1 = sp_core::storage::ChildInfo::new_default(b"child1");
+			let child2 = sp_core::storage::ChildInfo::new_default(b"child2");
+
+			bench_state.storage(b"foo").unwrap();
+			bench_state.child_storage(&child1, b"foo").unwrap();
+			bench_state.child_storage(&child2, b"foo").unwrap();
+
+			bench_state.storage(b"bar").unwrap();
+			bench_state.child_storage(&child1, b"bar").unwrap();
+			bench_state.child_storage(&child2, b"bar").unwrap();
+
+			bench_state
+				.commit(
+					Default::default(),
+					Default::default(),
+					vec![("foo".as_bytes().to_vec(), None)],
+					vec![("child1".as_bytes().to_vec(), vec![("foo".as_bytes().to_vec(), None)])],
+				)
+				.unwrap();
+
+			let rw_tracker = bench_state.read_write_count();
+			assert_eq!(rw_tracker.0, 6);
+			assert_eq!(rw_tracker.1, 0);
+			assert_eq!(rw_tracker.2, 2);
+			assert_eq!(rw_tracker.3, 0);
+			bench_state.wipe().unwrap();
+		}
+	}
+}
diff --git a/substrate/client/db/src/children.rs b/substrate/client/db/src/children.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0671376537182716d83a27b02aa074895f6d014c
--- /dev/null
+++ b/substrate/client/db/src/children.rs
@@ -0,0 +1,123 @@
+// 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/>.
+
+//! Functionality for reading and storing children hashes from db.
+
+use crate::DbHash;
+use codec::{Decode, Encode};
+use sp_blockchain;
+use sp_database::{Database, Transaction};
+use std::hash::Hash;
+
+/// Returns the hashes of the children blocks of the block with `parent_hash`.
+pub fn read_children<
+	K: Eq + Hash + Clone + Encode + Decode,
+	V: Eq + Hash + Clone + Encode + Decode,
+>(
+	db: &dyn Database<DbHash>,
+	column: u32,
+	prefix: &[u8],
+	parent_hash: K,
+) -> sp_blockchain::Result<Vec<V>> {
+	let mut buf = prefix.to_vec();
+	parent_hash.using_encoded(|s| buf.extend(s));
+
+	let raw_val_opt = db.get(column, &buf[..]);
+
+	let raw_val = match raw_val_opt {
+		Some(val) => val,
+		None => return Ok(Vec::new()),
+	};
+
+	let children: Vec<V> = match Decode::decode(&mut &raw_val[..]) {
+		Ok(children) => children,
+		Err(_) => return Err(sp_blockchain::Error::Backend("Error decoding children".into())),
+	};
+
+	Ok(children)
+}
+
+/// Insert the key-value pair (`parent_hash`, `children_hashes`) in the transaction.
+/// Any existing value is overwritten upon write.
+pub fn write_children<
+	K: Eq + Hash + Clone + Encode + Decode,
+	V: Eq + Hash + Clone + Encode + Decode,
+>(
+	tx: &mut Transaction<DbHash>,
+	column: u32,
+	prefix: &[u8],
+	parent_hash: K,
+	children_hashes: V,
+) {
+	let mut key = prefix.to_vec();
+	parent_hash.using_encoded(|s| key.extend(s));
+	tx.set_from_vec(column, &key[..], children_hashes.encode());
+}
+
+/// Prepare transaction to remove the children of `parent_hash`.
+pub fn remove_children<K: Eq + Hash + Clone + Encode + Decode>(
+	tx: &mut Transaction<DbHash>,
+	column: u32,
+	prefix: &[u8],
+	parent_hash: K,
+) {
+	let mut key = prefix.to_vec();
+	parent_hash.using_encoded(|s| key.extend(s));
+	tx.remove(column, &key);
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::sync::Arc;
+
+	#[test]
+	fn children_write_read_remove() {
+		const PREFIX: &[u8] = b"children";
+		let db = Arc::new(sp_database::MemDb::default());
+
+		let mut tx = Transaction::new();
+
+		let mut children1 = Vec::new();
+		children1.push(1_3);
+		children1.push(1_5);
+		write_children(&mut tx, 0, PREFIX, 1_1, children1);
+
+		let mut children2 = Vec::new();
+		children2.push(1_4);
+		children2.push(1_6);
+		write_children(&mut tx, 0, PREFIX, 1_2, children2);
+
+		db.commit(tx.clone()).unwrap();
+
+		let r1: Vec<u32> = read_children(&*db, 0, PREFIX, 1_1).expect("(1) Getting r1 failed");
+		let r2: Vec<u32> = read_children(&*db, 0, PREFIX, 1_2).expect("(1) Getting r2 failed");
+
+		assert_eq!(r1, vec![1_3, 1_5]);
+		assert_eq!(r2, vec![1_4, 1_6]);
+
+		remove_children(&mut tx, 0, PREFIX, 1_2);
+		db.commit(tx).unwrap();
+
+		let r1: Vec<u32> = read_children(&*db, 0, PREFIX, 1_1).expect("(2) Getting r1 failed");
+		let r2: Vec<u32> = read_children(&*db, 0, PREFIX, 1_2).expect("(2) Getting r2 failed");
+
+		assert_eq!(r1, vec![1_3, 1_5]);
+		assert_eq!(r2.len(), 0);
+	}
+}
diff --git a/substrate/client/db/src/lib.rs b/substrate/client/db/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..73fb4f8ce6db37f0857813d5b64821e77413b34b
--- /dev/null
+++ b/substrate/client/db/src/lib.rs
@@ -0,0 +1,4410 @@
+// 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/>.
+
+//! Client backend that is backed by a database.
+//!
+//! # Canonicality vs. Finality
+//!
+//! Finality indicates that a block will not be reverted, according to the consensus algorithm,
+//! while canonicality indicates that the block may be reverted, but we will be unable to do so,
+//! having discarded heavy state that will allow a chain reorganization.
+//!
+//! Finality implies canonicality but not vice-versa.
+
+#![warn(missing_docs)]
+
+pub mod offchain;
+
+pub mod bench;
+
+mod children;
+mod parity_db;
+mod pinned_blocks_cache;
+mod record_stats_state;
+mod stats;
+#[cfg(any(feature = "rocksdb", test))]
+mod upgrade;
+mod utils;
+
+use linked_hash_map::LinkedHashMap;
+use log::{debug, trace, warn};
+use parking_lot::{Mutex, RwLock};
+use std::{
+	collections::{HashMap, HashSet},
+	io,
+	path::{Path, PathBuf},
+	sync::Arc,
+};
+
+use crate::{
+	pinned_blocks_cache::PinnedBlocksCache,
+	record_stats_state::RecordStatsState,
+	stats::StateUsageStats,
+	utils::{meta_keys, read_db, read_meta, DatabaseType, Meta},
+};
+use codec::{Decode, Encode};
+use hash_db::Prefix;
+use sc_client_api::{
+	backend::NewBlockState,
+	leaves::{FinalizationOutcome, LeafSet},
+	utils::is_descendent_of,
+	IoInfo, MemoryInfo, MemorySize, UsageInfo,
+};
+use sc_state_db::{IsPruned, LastCanonicalized, StateDb};
+use sp_arithmetic::traits::Saturating;
+use sp_blockchain::{
+	Backend as _, CachedHeaderMetadata, Error as ClientError, HeaderBackend, HeaderMetadata,
+	HeaderMetadataCache, Result as ClientResult,
+};
+use sp_core::{
+	offchain::OffchainOverlayedChange,
+	storage::{well_known_keys, ChildInfo},
+};
+use sp_database::Transaction;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{
+		Block as BlockT, Hash, HashingFor, Header as HeaderT, NumberFor, One, SaturatedConversion,
+		Zero,
+	},
+	Justification, Justifications, StateVersion, Storage,
+};
+use sp_state_machine::{
+	backend::{AsTrieBackend, Backend as StateBackend},
+	BackendTransaction, ChildStorageCollection, DBValue, IndexOperation, IterArgs,
+	OffchainChangesCollection, StateMachineStats, StorageCollection, StorageIterator, StorageKey,
+	StorageValue, UsageInfo as StateUsageInfo,
+};
+use sp_trie::{cache::SharedTrieCache, prefixed_key, MemoryDB, PrefixedMemoryDB};
+
+// Re-export the Database trait so that one can pass an implementation of it.
+pub use sc_state_db::PruningMode;
+pub use sp_database::Database;
+
+pub use bench::BenchmarkingState;
+
+const CACHE_HEADERS: usize = 8;
+
+/// DB-backed patricia trie state, transaction type is an overlay of changes to commit.
+pub type DbState<B> =
+	sp_state_machine::TrieBackend<Arc<dyn sp_state_machine::Storage<HashingFor<B>>>, HashingFor<B>>;
+
+/// Builder for [`DbState`].
+pub type DbStateBuilder<B> = sp_state_machine::TrieBackendBuilder<
+	Arc<dyn sp_state_machine::Storage<HashingFor<B>>>,
+	HashingFor<B>,
+>;
+
+/// Length of a [`DbHash`].
+const DB_HASH_LEN: usize = 32;
+
+/// Hash type that this backend uses for the database.
+pub type DbHash = sp_core::H256;
+
+/// An extrinsic entry in the database.
+#[derive(Debug, Encode, Decode)]
+enum DbExtrinsic<B: BlockT> {
+	/// Extrinsic that contains indexed data.
+	Indexed {
+		/// Hash of the indexed part.
+		hash: DbHash,
+		/// Extrinsic header.
+		header: Vec<u8>,
+	},
+	/// Complete extrinsic data.
+	Full(B::Extrinsic),
+}
+
+/// A reference tracking state.
+///
+/// It makes sure that the hash we are using stays pinned in storage
+/// until this structure is dropped.
+pub struct RefTrackingState<Block: BlockT> {
+	state: DbState<Block>,
+	storage: Arc<StorageDb<Block>>,
+	parent_hash: Option<Block::Hash>,
+}
+
+impl<B: BlockT> RefTrackingState<B> {
+	fn new(state: DbState<B>, storage: Arc<StorageDb<B>>, parent_hash: Option<B::Hash>) -> Self {
+		RefTrackingState { state, parent_hash, storage }
+	}
+}
+
+impl<B: BlockT> Drop for RefTrackingState<B> {
+	fn drop(&mut self) {
+		if let Some(hash) = &self.parent_hash {
+			self.storage.state_db.unpin(hash);
+		}
+	}
+}
+
+impl<Block: BlockT> std::fmt::Debug for RefTrackingState<Block> {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "Block {:?}", self.parent_hash)
+	}
+}
+
+/// A raw iterator over the `RefTrackingState`.
+pub struct RawIter<B: BlockT> {
+	inner: <DbState<B> as StateBackend<HashingFor<B>>>::RawIter,
+}
+
+impl<B: BlockT> StorageIterator<HashingFor<B>> for RawIter<B> {
+	type Backend = RefTrackingState<B>;
+	type Error = <DbState<B> as StateBackend<HashingFor<B>>>::Error;
+
+	fn next_key(&mut self, backend: &Self::Backend) -> Option<Result<StorageKey, Self::Error>> {
+		self.inner.next_key(&backend.state)
+	}
+
+	fn next_pair(
+		&mut self,
+		backend: &Self::Backend,
+	) -> Option<Result<(StorageKey, StorageValue), Self::Error>> {
+		self.inner.next_pair(&backend.state)
+	}
+
+	fn was_complete(&self) -> bool {
+		self.inner.was_complete()
+	}
+}
+
+impl<B: BlockT> StateBackend<HashingFor<B>> for RefTrackingState<B> {
+	type Error = <DbState<B> as StateBackend<HashingFor<B>>>::Error;
+	type TrieBackendStorage = <DbState<B> as StateBackend<HashingFor<B>>>::TrieBackendStorage;
+	type RawIter = RawIter<B>;
+
+	fn storage(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.state.storage(key)
+	}
+
+	fn storage_hash(&self, key: &[u8]) -> Result<Option<B::Hash>, Self::Error> {
+		self.state.storage_hash(key)
+	}
+
+	fn child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.state.child_storage(child_info, key)
+	}
+
+	fn child_storage_hash(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<B::Hash>, Self::Error> {
+		self.state.child_storage_hash(child_info, key)
+	}
+
+	fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> {
+		self.state.exists_storage(key)
+	}
+
+	fn exists_child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<bool, Self::Error> {
+		self.state.exists_child_storage(child_info, key)
+	}
+
+	fn next_storage_key(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.state.next_storage_key(key)
+	}
+
+	fn next_child_storage_key(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.state.next_child_storage_key(child_info, key)
+	}
+
+	fn storage_root<'a>(
+		&self,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (B::Hash, BackendTransaction<HashingFor<B>>) {
+		self.state.storage_root(delta, state_version)
+	}
+
+	fn child_storage_root<'a>(
+		&self,
+		child_info: &ChildInfo,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (B::Hash, bool, BackendTransaction<HashingFor<B>>) {
+		self.state.child_storage_root(child_info, delta, state_version)
+	}
+
+	fn raw_iter(&self, args: IterArgs) -> Result<Self::RawIter, Self::Error> {
+		self.state.raw_iter(args).map(|inner| RawIter { inner })
+	}
+
+	fn register_overlay_stats(&self, stats: &StateMachineStats) {
+		self.state.register_overlay_stats(stats);
+	}
+
+	fn usage_info(&self) -> StateUsageInfo {
+		self.state.usage_info()
+	}
+}
+
+impl<B: BlockT> AsTrieBackend<HashingFor<B>> for RefTrackingState<B> {
+	type TrieBackendStorage = <DbState<B> as StateBackend<HashingFor<B>>>::TrieBackendStorage;
+
+	fn as_trie_backend(
+		&self,
+	) -> &sp_state_machine::TrieBackend<Self::TrieBackendStorage, HashingFor<B>> {
+		&self.state.as_trie_backend()
+	}
+}
+
+/// Database settings.
+pub struct DatabaseSettings {
+	/// The maximum trie cache size in bytes.
+	///
+	/// If `None` is given, the cache is disabled.
+	pub trie_cache_maximum_size: Option<usize>,
+	/// Requested state pruning mode.
+	pub state_pruning: Option<PruningMode>,
+	/// Where to find the database.
+	pub source: DatabaseSource,
+	/// Block pruning mode.
+	///
+	/// NOTE: only finalized blocks are subject for removal!
+	pub blocks_pruning: BlocksPruning,
+}
+
+/// Block pruning settings.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum BlocksPruning {
+	/// Keep full block history, of every block that was ever imported.
+	KeepAll,
+	/// Keep full finalized block history.
+	KeepFinalized,
+	/// Keep N recent finalized blocks.
+	Some(u32),
+}
+
+/// Where to find the database..
+#[derive(Debug, Clone)]
+pub enum DatabaseSource {
+	/// Check given path, and see if there is an existing database there. If it's either `RocksDb`
+	/// or `ParityDb`, use it. If there is none, create a new instance of `ParityDb`.
+	Auto {
+		/// Path to the paritydb database.
+		paritydb_path: PathBuf,
+		/// Path to the rocksdb database.
+		rocksdb_path: PathBuf,
+		/// Cache size in MiB. Used only by `RocksDb` variant of `DatabaseSource`.
+		cache_size: usize,
+	},
+	/// Load a RocksDB database from a given path. Recommended for most uses.
+	#[cfg(feature = "rocksdb")]
+	RocksDb {
+		/// Path to the database.
+		path: PathBuf,
+		/// Cache size in MiB.
+		cache_size: usize,
+	},
+
+	/// Load a ParityDb database from a given path.
+	ParityDb {
+		/// Path to the database.
+		path: PathBuf,
+	},
+
+	/// Use a custom already-open database.
+	Custom {
+		/// the handle to the custom storage
+		db: Arc<dyn Database<DbHash>>,
+
+		/// if set, the `create` flag will be required to open such datasource
+		require_create_flag: bool,
+	},
+}
+
+impl DatabaseSource {
+	/// Return path for databases that are stored on disk.
+	pub fn path(&self) -> Option<&Path> {
+		match self {
+			// as per https://github.com/paritytech/substrate/pull/9500#discussion_r684312550
+			//
+			// IIUC this is needed for polkadot to create its own dbs, so until it can use parity db
+			// I would think rocksdb, but later parity-db.
+			DatabaseSource::Auto { paritydb_path, .. } => Some(paritydb_path),
+			#[cfg(feature = "rocksdb")]
+			DatabaseSource::RocksDb { path, .. } => Some(path),
+			DatabaseSource::ParityDb { path } => Some(path),
+			DatabaseSource::Custom { .. } => None,
+		}
+	}
+
+	/// Set path for databases that are stored on disk.
+	pub fn set_path(&mut self, p: &Path) -> bool {
+		match self {
+			DatabaseSource::Auto { ref mut paritydb_path, .. } => {
+				*paritydb_path = p.into();
+				true
+			},
+			#[cfg(feature = "rocksdb")]
+			DatabaseSource::RocksDb { ref mut path, .. } => {
+				*path = p.into();
+				true
+			},
+			DatabaseSource::ParityDb { ref mut path } => {
+				*path = p.into();
+				true
+			},
+			DatabaseSource::Custom { .. } => false,
+		}
+	}
+}
+
+impl std::fmt::Display for DatabaseSource {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		let name = match self {
+			DatabaseSource::Auto { .. } => "Auto",
+			#[cfg(feature = "rocksdb")]
+			DatabaseSource::RocksDb { .. } => "RocksDb",
+			DatabaseSource::ParityDb { .. } => "ParityDb",
+			DatabaseSource::Custom { .. } => "Custom",
+		};
+		write!(f, "{}", name)
+	}
+}
+
+pub(crate) mod columns {
+	pub const META: u32 = crate::utils::COLUMN_META;
+	pub const STATE: u32 = 1;
+	pub const STATE_META: u32 = 2;
+	/// maps hashes to lookup keys and numbers to canon hashes.
+	pub const KEY_LOOKUP: u32 = 3;
+	pub const HEADER: u32 = 4;
+	pub const BODY: u32 = 5;
+	pub const JUSTIFICATIONS: u32 = 6;
+	pub const AUX: u32 = 8;
+	/// Offchain workers local storage
+	pub const OFFCHAIN: u32 = 9;
+	/// Transactions
+	pub const TRANSACTION: u32 = 11;
+	pub const BODY_INDEX: u32 = 12;
+}
+
+struct PendingBlock<Block: BlockT> {
+	header: Block::Header,
+	justifications: Option<Justifications>,
+	body: Option<Vec<Block::Extrinsic>>,
+	indexed_body: Option<Vec<Vec<u8>>>,
+	leaf_state: NewBlockState,
+}
+
+// wrapper that implements trait required for state_db
+#[derive(Clone)]
+struct StateMetaDb(Arc<dyn Database<DbHash>>);
+
+impl sc_state_db::MetaDb for StateMetaDb {
+	type Error = sp_database::error::DatabaseError;
+
+	fn get_meta(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		Ok(self.0.get(columns::STATE_META, key))
+	}
+}
+
+struct MetaUpdate<Block: BlockT> {
+	pub hash: Block::Hash,
+	pub number: NumberFor<Block>,
+	pub is_best: bool,
+	pub is_finalized: bool,
+	pub with_state: bool,
+}
+
+fn cache_header<Hash: std::cmp::Eq + std::hash::Hash, Header>(
+	cache: &mut LinkedHashMap<Hash, Option<Header>>,
+	hash: Hash,
+	header: Option<Header>,
+) {
+	cache.insert(hash, header);
+	while cache.len() > CACHE_HEADERS {
+		cache.pop_front();
+	}
+}
+
+/// Block database
+pub struct BlockchainDb<Block: BlockT> {
+	db: Arc<dyn Database<DbHash>>,
+	meta: Arc<RwLock<Meta<NumberFor<Block>, Block::Hash>>>,
+	leaves: RwLock<LeafSet<Block::Hash, NumberFor<Block>>>,
+	header_metadata_cache: Arc<HeaderMetadataCache<Block>>,
+	header_cache: Mutex<LinkedHashMap<Block::Hash, Option<Block::Header>>>,
+	pinned_blocks_cache: Arc<RwLock<PinnedBlocksCache<Block>>>,
+}
+
+impl<Block: BlockT> BlockchainDb<Block> {
+	fn new(db: Arc<dyn Database<DbHash>>) -> ClientResult<Self> {
+		let meta = read_meta::<Block>(&*db, columns::HEADER)?;
+		let leaves = LeafSet::read_from_db(&*db, columns::META, meta_keys::LEAF_PREFIX)?;
+		Ok(BlockchainDb {
+			db,
+			leaves: RwLock::new(leaves),
+			meta: Arc::new(RwLock::new(meta)),
+			header_metadata_cache: Arc::new(HeaderMetadataCache::default()),
+			header_cache: Default::default(),
+			pinned_blocks_cache: Arc::new(RwLock::new(PinnedBlocksCache::new())),
+		})
+	}
+
+	fn update_meta(&self, update: MetaUpdate<Block>) {
+		let MetaUpdate { hash, number, is_best, is_finalized, with_state } = update;
+		let mut meta = self.meta.write();
+		if number.is_zero() {
+			meta.genesis_hash = hash;
+		}
+
+		if is_best {
+			meta.best_number = number;
+			meta.best_hash = hash;
+		}
+
+		if is_finalized {
+			if with_state {
+				meta.finalized_state = Some((hash, number));
+			}
+			meta.finalized_number = number;
+			meta.finalized_hash = hash;
+		}
+	}
+
+	fn update_block_gap(&self, gap: Option<(NumberFor<Block>, NumberFor<Block>)>) {
+		let mut meta = self.meta.write();
+		meta.block_gap = gap;
+	}
+
+	/// Empty the cache of pinned items.
+	fn clear_pinning_cache(&self) {
+		self.pinned_blocks_cache.write().clear();
+	}
+
+	/// Load a justification into the cache of pinned items.
+	/// Reference count of the item will not be increased. Use this
+	/// to load values for items into the cache which have already been pinned.
+	fn insert_justifications_if_pinned(&self, hash: Block::Hash, justification: Justification) {
+		let mut cache = self.pinned_blocks_cache.write();
+		if !cache.contains(hash) {
+			return
+		}
+
+		let justifications = Justifications::from(justification);
+		cache.insert_justifications(hash, Some(justifications));
+	}
+
+	/// Load a justification from the db into the cache of pinned items.
+	/// Reference count of the item will not be increased. Use this
+	/// to load values for items into the cache which have already been pinned.
+	fn insert_persisted_justifications_if_pinned(&self, hash: Block::Hash) -> ClientResult<()> {
+		let mut cache = self.pinned_blocks_cache.write();
+		if !cache.contains(hash) {
+			return Ok(())
+		}
+
+		let justifications = self.justifications_uncached(hash)?;
+		cache.insert_justifications(hash, justifications);
+		Ok(())
+	}
+
+	/// Load a block body from the db into the cache of pinned items.
+	/// Reference count of the item will not be increased. Use this
+	/// to load values for items items into the cache which have already been pinned.
+	fn insert_persisted_body_if_pinned(&self, hash: Block::Hash) -> ClientResult<()> {
+		let mut cache = self.pinned_blocks_cache.write();
+		if !cache.contains(hash) {
+			return Ok(())
+		}
+
+		let body = self.body_uncached(hash)?;
+		cache.insert_body(hash, body);
+		Ok(())
+	}
+
+	/// Bump reference count for pinned item.
+	fn bump_ref(&self, hash: Block::Hash) {
+		self.pinned_blocks_cache.write().pin(hash);
+	}
+
+	/// Decrease reference count for pinned item and remove if reference count is 0.
+	fn unpin(&self, hash: Block::Hash) {
+		self.pinned_blocks_cache.write().unpin(hash);
+	}
+
+	fn justifications_uncached(&self, hash: Block::Hash) -> ClientResult<Option<Justifications>> {
+		match read_db(
+			&*self.db,
+			columns::KEY_LOOKUP,
+			columns::JUSTIFICATIONS,
+			BlockId::<Block>::Hash(hash),
+		)? {
+			Some(justifications) => match Decode::decode(&mut &justifications[..]) {
+				Ok(justifications) => Ok(Some(justifications)),
+				Err(err) =>
+					return Err(sp_blockchain::Error::Backend(format!(
+						"Error decoding justifications: {}",
+						err
+					))),
+			},
+			None => Ok(None),
+		}
+	}
+
+	fn body_uncached(&self, hash: Block::Hash) -> ClientResult<Option<Vec<Block::Extrinsic>>> {
+		if let Some(body) =
+			read_db(&*self.db, columns::KEY_LOOKUP, columns::BODY, BlockId::Hash::<Block>(hash))?
+		{
+			// Plain body
+			match Decode::decode(&mut &body[..]) {
+				Ok(body) => return Ok(Some(body)),
+				Err(err) =>
+					return Err(sp_blockchain::Error::Backend(format!(
+						"Error decoding body: {}",
+						err
+					))),
+			}
+		}
+
+		if let Some(index) = read_db(
+			&*self.db,
+			columns::KEY_LOOKUP,
+			columns::BODY_INDEX,
+			BlockId::Hash::<Block>(hash),
+		)? {
+			match Vec::<DbExtrinsic<Block>>::decode(&mut &index[..]) {
+				Ok(index) => {
+					let mut body = Vec::new();
+					for ex in index {
+						match ex {
+							DbExtrinsic::Indexed { hash, header } => {
+								match self.db.get(columns::TRANSACTION, hash.as_ref()) {
+									Some(t) => {
+										let mut input =
+											utils::join_input(header.as_ref(), t.as_ref());
+										let ex = Block::Extrinsic::decode(&mut input).map_err(
+											|err| {
+												sp_blockchain::Error::Backend(format!(
+													"Error decoding indexed extrinsic: {}",
+													err
+												))
+											},
+										)?;
+										body.push(ex);
+									},
+									None =>
+										return Err(sp_blockchain::Error::Backend(format!(
+											"Missing indexed transaction {:?}",
+											hash
+										))),
+								};
+							},
+							DbExtrinsic::Full(ex) => {
+								body.push(ex);
+							},
+						}
+					}
+					return Ok(Some(body))
+				},
+				Err(err) =>
+					return Err(sp_blockchain::Error::Backend(format!(
+						"Error decoding body list: {}",
+						err
+					))),
+			}
+		}
+		Ok(None)
+	}
+}
+
+impl<Block: BlockT> sc_client_api::blockchain::HeaderBackend<Block> for BlockchainDb<Block> {
+	fn header(&self, hash: Block::Hash) -> ClientResult<Option<Block::Header>> {
+		let mut cache = self.header_cache.lock();
+		if let Some(result) = cache.get_refresh(&hash) {
+			return Ok(result.clone())
+		}
+		let header = utils::read_header(
+			&*self.db,
+			columns::KEY_LOOKUP,
+			columns::HEADER,
+			BlockId::<Block>::Hash(hash),
+		)?;
+		cache_header(&mut cache, hash, header.clone());
+		Ok(header)
+	}
+
+	fn info(&self) -> sc_client_api::blockchain::Info<Block> {
+		let meta = self.meta.read();
+		sc_client_api::blockchain::Info {
+			best_hash: meta.best_hash,
+			best_number: meta.best_number,
+			genesis_hash: meta.genesis_hash,
+			finalized_hash: meta.finalized_hash,
+			finalized_number: meta.finalized_number,
+			finalized_state: meta.finalized_state,
+			number_leaves: self.leaves.read().count(),
+			block_gap: meta.block_gap,
+		}
+	}
+
+	fn status(&self, hash: Block::Hash) -> ClientResult<sc_client_api::blockchain::BlockStatus> {
+		match self.header(hash)?.is_some() {
+			true => Ok(sc_client_api::blockchain::BlockStatus::InChain),
+			false => Ok(sc_client_api::blockchain::BlockStatus::Unknown),
+		}
+	}
+
+	fn number(&self, hash: Block::Hash) -> ClientResult<Option<NumberFor<Block>>> {
+		Ok(self.header_metadata(hash).ok().map(|header_metadata| header_metadata.number))
+	}
+
+	fn hash(&self, number: NumberFor<Block>) -> ClientResult<Option<Block::Hash>> {
+		Ok(utils::read_header::<Block>(
+			&*self.db,
+			columns::KEY_LOOKUP,
+			columns::HEADER,
+			BlockId::Number(number),
+		)?
+		.map(|header| header.hash()))
+	}
+}
+
+impl<Block: BlockT> sc_client_api::blockchain::Backend<Block> for BlockchainDb<Block> {
+	fn body(&self, hash: Block::Hash) -> ClientResult<Option<Vec<Block::Extrinsic>>> {
+		let cache = self.pinned_blocks_cache.read();
+		if let Some(result) = cache.body(&hash) {
+			return Ok(result.clone())
+		}
+
+		self.body_uncached(hash)
+	}
+
+	fn justifications(&self, hash: Block::Hash) -> ClientResult<Option<Justifications>> {
+		let cache = self.pinned_blocks_cache.read();
+		if let Some(result) = cache.justifications(&hash) {
+			return Ok(result.clone())
+		}
+
+		self.justifications_uncached(hash)
+	}
+
+	fn last_finalized(&self) -> ClientResult<Block::Hash> {
+		Ok(self.meta.read().finalized_hash)
+	}
+
+	fn leaves(&self) -> ClientResult<Vec<Block::Hash>> {
+		Ok(self.leaves.read().hashes())
+	}
+
+	fn displaced_leaves_after_finalizing(
+		&self,
+		block_number: NumberFor<Block>,
+	) -> ClientResult<Vec<Block::Hash>> {
+		Ok(self
+			.leaves
+			.read()
+			.displaced_by_finalize_height(block_number)
+			.leaves()
+			.cloned()
+			.collect::<Vec<_>>())
+	}
+
+	fn children(&self, parent_hash: Block::Hash) -> ClientResult<Vec<Block::Hash>> {
+		children::read_children(&*self.db, columns::META, meta_keys::CHILDREN_PREFIX, parent_hash)
+	}
+
+	fn indexed_transaction(&self, hash: Block::Hash) -> ClientResult<Option<Vec<u8>>> {
+		Ok(self.db.get(columns::TRANSACTION, hash.as_ref()))
+	}
+
+	fn has_indexed_transaction(&self, hash: Block::Hash) -> ClientResult<bool> {
+		Ok(self.db.contains(columns::TRANSACTION, hash.as_ref()))
+	}
+
+	fn block_indexed_body(&self, hash: Block::Hash) -> ClientResult<Option<Vec<Vec<u8>>>> {
+		let body = match read_db(
+			&*self.db,
+			columns::KEY_LOOKUP,
+			columns::BODY_INDEX,
+			BlockId::<Block>::Hash(hash),
+		)? {
+			Some(body) => body,
+			None => return Ok(None),
+		};
+		match Vec::<DbExtrinsic<Block>>::decode(&mut &body[..]) {
+			Ok(index) => {
+				let mut transactions = Vec::new();
+				for ex in index.into_iter() {
+					if let DbExtrinsic::Indexed { hash, .. } = ex {
+						match self.db.get(columns::TRANSACTION, hash.as_ref()) {
+							Some(t) => transactions.push(t),
+							None =>
+								return Err(sp_blockchain::Error::Backend(format!(
+									"Missing indexed transaction {:?}",
+									hash
+								))),
+						}
+					}
+				}
+				Ok(Some(transactions))
+			},
+			Err(err) =>
+				Err(sp_blockchain::Error::Backend(format!("Error decoding body list: {}", err))),
+		}
+	}
+}
+
+impl<Block: BlockT> HeaderMetadata<Block> for BlockchainDb<Block> {
+	type Error = sp_blockchain::Error;
+
+	fn header_metadata(
+		&self,
+		hash: Block::Hash,
+	) -> Result<CachedHeaderMetadata<Block>, Self::Error> {
+		self.header_metadata_cache.header_metadata(hash).map_or_else(
+			|| {
+				self.header(hash)?
+					.map(|header| {
+						let header_metadata = CachedHeaderMetadata::from(&header);
+						self.header_metadata_cache
+							.insert_header_metadata(header_metadata.hash, header_metadata.clone());
+						header_metadata
+					})
+					.ok_or_else(|| {
+						ClientError::UnknownBlock(format!(
+							"Header was not found in the database: {:?}",
+							hash
+						))
+					})
+			},
+			Ok,
+		)
+	}
+
+	fn insert_header_metadata(&self, hash: Block::Hash, metadata: CachedHeaderMetadata<Block>) {
+		self.header_metadata_cache.insert_header_metadata(hash, metadata)
+	}
+
+	fn remove_header_metadata(&self, hash: Block::Hash) {
+		self.header_cache.lock().remove(&hash);
+		self.header_metadata_cache.remove_header_metadata(hash);
+	}
+}
+
+/// Database transaction
+pub struct BlockImportOperation<Block: BlockT> {
+	old_state: RecordStatsState<RefTrackingState<Block>, Block>,
+	db_updates: PrefixedMemoryDB<HashingFor<Block>>,
+	storage_updates: StorageCollection,
+	child_storage_updates: ChildStorageCollection,
+	offchain_storage_updates: OffchainChangesCollection,
+	pending_block: Option<PendingBlock<Block>>,
+	aux_ops: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+	finalized_blocks: Vec<(Block::Hash, Option<Justification>)>,
+	set_head: Option<Block::Hash>,
+	commit_state: bool,
+	index_ops: Vec<IndexOperation>,
+}
+
+impl<Block: BlockT> BlockImportOperation<Block> {
+	fn apply_offchain(&mut self, transaction: &mut Transaction<DbHash>) {
+		let mut count = 0;
+		for ((prefix, key), value_operation) in self.offchain_storage_updates.drain(..) {
+			count += 1;
+			let key = crate::offchain::concatenate_prefix_and_key(&prefix, &key);
+			match value_operation {
+				OffchainOverlayedChange::SetValue(val) =>
+					transaction.set_from_vec(columns::OFFCHAIN, &key, val),
+				OffchainOverlayedChange::Remove => transaction.remove(columns::OFFCHAIN, &key),
+			}
+		}
+
+		if count > 0 {
+			log::debug!(target: "sc_offchain", "Applied {} offchain indexing changes.", count);
+		}
+	}
+
+	fn apply_aux(&mut self, transaction: &mut Transaction<DbHash>) {
+		for (key, maybe_val) in self.aux_ops.drain(..) {
+			match maybe_val {
+				Some(val) => transaction.set_from_vec(columns::AUX, &key, val),
+				None => transaction.remove(columns::AUX, &key),
+			}
+		}
+	}
+
+	fn apply_new_state(
+		&mut self,
+		storage: Storage,
+		state_version: StateVersion,
+	) -> ClientResult<Block::Hash> {
+		if storage.top.keys().any(|k| well_known_keys::is_child_storage_key(k)) {
+			return Err(sp_blockchain::Error::InvalidState)
+		}
+
+		let child_delta = storage.children_default.values().map(|child_content| {
+			(
+				&child_content.child_info,
+				child_content.data.iter().map(|(k, v)| (&k[..], Some(&v[..]))),
+			)
+		});
+
+		let (root, transaction) = self.old_state.full_storage_root(
+			storage.top.iter().map(|(k, v)| (&k[..], Some(&v[..]))),
+			child_delta,
+			state_version,
+		);
+
+		self.db_updates = transaction;
+		Ok(root)
+	}
+}
+
+impl<Block: BlockT> sc_client_api::backend::BlockImportOperation<Block>
+	for BlockImportOperation<Block>
+{
+	type State = RecordStatsState<RefTrackingState<Block>, Block>;
+
+	fn state(&self) -> ClientResult<Option<&Self::State>> {
+		Ok(Some(&self.old_state))
+	}
+
+	fn set_block_data(
+		&mut self,
+		header: Block::Header,
+		body: Option<Vec<Block::Extrinsic>>,
+		indexed_body: Option<Vec<Vec<u8>>>,
+		justifications: Option<Justifications>,
+		leaf_state: NewBlockState,
+	) -> ClientResult<()> {
+		assert!(self.pending_block.is_none(), "Only one block per operation is allowed");
+		self.pending_block =
+			Some(PendingBlock { header, body, indexed_body, justifications, leaf_state });
+		Ok(())
+	}
+
+	fn update_db_storage(
+		&mut self,
+		update: PrefixedMemoryDB<HashingFor<Block>>,
+	) -> ClientResult<()> {
+		self.db_updates = update;
+		Ok(())
+	}
+
+	fn reset_storage(
+		&mut self,
+		storage: Storage,
+		state_version: StateVersion,
+	) -> ClientResult<Block::Hash> {
+		let root = self.apply_new_state(storage, state_version)?;
+		self.commit_state = true;
+		Ok(root)
+	}
+
+	fn set_genesis_state(
+		&mut self,
+		storage: Storage,
+		commit: bool,
+		state_version: StateVersion,
+	) -> ClientResult<Block::Hash> {
+		let root = self.apply_new_state(storage, state_version)?;
+		self.commit_state = commit;
+		Ok(root)
+	}
+
+	fn insert_aux<I>(&mut self, ops: I) -> ClientResult<()>
+	where
+		I: IntoIterator<Item = (Vec<u8>, Option<Vec<u8>>)>,
+	{
+		self.aux_ops.append(&mut ops.into_iter().collect());
+		Ok(())
+	}
+
+	fn update_storage(
+		&mut self,
+		update: StorageCollection,
+		child_update: ChildStorageCollection,
+	) -> ClientResult<()> {
+		self.storage_updates = update;
+		self.child_storage_updates = child_update;
+		Ok(())
+	}
+
+	fn update_offchain_storage(
+		&mut self,
+		offchain_update: OffchainChangesCollection,
+	) -> ClientResult<()> {
+		self.offchain_storage_updates = offchain_update;
+		Ok(())
+	}
+
+	fn mark_finalized(
+		&mut self,
+		block: Block::Hash,
+		justification: Option<Justification>,
+	) -> ClientResult<()> {
+		self.finalized_blocks.push((block, justification));
+		Ok(())
+	}
+
+	fn mark_head(&mut self, hash: Block::Hash) -> ClientResult<()> {
+		assert!(self.set_head.is_none(), "Only one set head per operation is allowed");
+		self.set_head = Some(hash);
+		Ok(())
+	}
+
+	fn update_transaction_index(&mut self, index_ops: Vec<IndexOperation>) -> ClientResult<()> {
+		self.index_ops = index_ops;
+		Ok(())
+	}
+}
+
+struct StorageDb<Block: BlockT> {
+	pub db: Arc<dyn Database<DbHash>>,
+	pub state_db: StateDb<Block::Hash, Vec<u8>, StateMetaDb>,
+	prefix_keys: bool,
+}
+
+impl<Block: BlockT> sp_state_machine::Storage<HashingFor<Block>> for StorageDb<Block> {
+	fn get(&self, key: &Block::Hash, prefix: Prefix) -> Result<Option<DBValue>, String> {
+		if self.prefix_keys {
+			let key = prefixed_key::<HashingFor<Block>>(key, prefix);
+			self.state_db.get(&key, self)
+		} else {
+			self.state_db.get(key.as_ref(), self)
+		}
+		.map_err(|e| format!("Database backend error: {:?}", e))
+	}
+}
+
+impl<Block: BlockT> sc_state_db::NodeDb for StorageDb<Block> {
+	type Error = io::Error;
+	type Key = [u8];
+
+	fn get(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		Ok(self.db.get(columns::STATE, key))
+	}
+}
+
+struct DbGenesisStorage<Block: BlockT> {
+	root: Block::Hash,
+	storage: PrefixedMemoryDB<HashingFor<Block>>,
+}
+
+impl<Block: BlockT> DbGenesisStorage<Block> {
+	pub fn new(root: Block::Hash, storage: PrefixedMemoryDB<HashingFor<Block>>) -> Self {
+		DbGenesisStorage { root, storage }
+	}
+}
+
+impl<Block: BlockT> sp_state_machine::Storage<HashingFor<Block>> for DbGenesisStorage<Block> {
+	fn get(&self, key: &Block::Hash, prefix: Prefix) -> Result<Option<DBValue>, String> {
+		use hash_db::HashDB;
+		Ok(self.storage.get(key, prefix))
+	}
+}
+
+struct EmptyStorage<Block: BlockT>(pub Block::Hash);
+
+impl<Block: BlockT> EmptyStorage<Block> {
+	pub fn new() -> Self {
+		let mut root = Block::Hash::default();
+		let mut mdb = MemoryDB::<HashingFor<Block>>::default();
+		// both triedbmut are the same on empty storage.
+		sp_trie::trie_types::TrieDBMutBuilderV1::<HashingFor<Block>>::new(&mut mdb, &mut root)
+			.build();
+		EmptyStorage(root)
+	}
+}
+
+impl<Block: BlockT> sp_state_machine::Storage<HashingFor<Block>> for EmptyStorage<Block> {
+	fn get(&self, _key: &Block::Hash, _prefix: Prefix) -> Result<Option<DBValue>, String> {
+		Ok(None)
+	}
+}
+
+/// Frozen `value` at time `at`.
+///
+/// Used as inner structure under lock in `FrozenForDuration`.
+struct Frozen<T: Clone> {
+	at: std::time::Instant,
+	value: Option<T>,
+}
+
+/// Some value frozen for period of time.
+///
+/// If time `duration` not passed since the value was instantiated,
+/// current frozen value is returned. Otherwise, you have to provide
+/// a new value which will be again frozen for `duration`.
+pub(crate) struct FrozenForDuration<T: Clone> {
+	duration: std::time::Duration,
+	value: parking_lot::Mutex<Frozen<T>>,
+}
+
+impl<T: Clone> FrozenForDuration<T> {
+	fn new(duration: std::time::Duration) -> Self {
+		Self { duration, value: Frozen { at: std::time::Instant::now(), value: None }.into() }
+	}
+
+	fn take_or_else<F>(&self, f: F) -> T
+	where
+		F: FnOnce() -> T,
+	{
+		let mut lock = self.value.lock();
+		let now = std::time::Instant::now();
+		if now.saturating_duration_since(lock.at) > self.duration || lock.value.is_none() {
+			let new_value = f();
+			lock.at = now;
+			lock.value = Some(new_value.clone());
+			new_value
+		} else {
+			lock.value.as_ref().expect("Checked with in branch above; qed").clone()
+		}
+	}
+}
+
+/// Disk backend.
+///
+/// Disk backend keeps data in a key-value store. In archive mode, trie nodes are kept from all
+/// blocks. Otherwise, trie nodes are kept only from some recent blocks.
+pub struct Backend<Block: BlockT> {
+	storage: Arc<StorageDb<Block>>,
+	offchain_storage: offchain::LocalStorage,
+	blockchain: BlockchainDb<Block>,
+	canonicalization_delay: u64,
+	import_lock: Arc<RwLock<()>>,
+	is_archive: bool,
+	blocks_pruning: BlocksPruning,
+	io_stats: FrozenForDuration<(kvdb::IoStats, StateUsageInfo)>,
+	state_usage: Arc<StateUsageStats>,
+	genesis_state: RwLock<Option<Arc<DbGenesisStorage<Block>>>>,
+	shared_trie_cache: Option<sp_trie::cache::SharedTrieCache<HashingFor<Block>>>,
+}
+
+impl<Block: BlockT> Backend<Block> {
+	/// Create a new instance of database backend.
+	///
+	/// The pruning window is how old a block must be before the state is pruned.
+	pub fn new(db_config: DatabaseSettings, canonicalization_delay: u64) -> ClientResult<Self> {
+		use utils::OpenDbError;
+
+		let db_source = &db_config.source;
+
+		let (needs_init, db) =
+			match crate::utils::open_database::<Block>(db_source, DatabaseType::Full, false) {
+				Ok(db) => (false, db),
+				Err(OpenDbError::DoesNotExist) => {
+					let db =
+						crate::utils::open_database::<Block>(db_source, DatabaseType::Full, true)?;
+					(true, db)
+				},
+				Err(as_is) => return Err(as_is.into()),
+			};
+
+		Self::from_database(db as Arc<_>, canonicalization_delay, &db_config, needs_init)
+	}
+
+	/// Reset the shared trie cache.
+	pub fn reset_trie_cache(&self) {
+		if let Some(cache) = &self.shared_trie_cache {
+			cache.reset();
+		}
+	}
+
+	/// Create new memory-backed client backend for tests.
+	#[cfg(any(test, feature = "test-helpers"))]
+	pub fn new_test(blocks_pruning: u32, canonicalization_delay: u64) -> Self {
+		Self::new_test_with_tx_storage(BlocksPruning::Some(blocks_pruning), canonicalization_delay)
+	}
+
+	/// Create new memory-backed client backend for tests.
+	#[cfg(any(test, feature = "test-helpers"))]
+	pub fn new_test_with_tx_storage(
+		blocks_pruning: BlocksPruning,
+		canonicalization_delay: u64,
+	) -> Self {
+		let db = kvdb_memorydb::create(crate::utils::NUM_COLUMNS);
+		let db = sp_database::as_database(db);
+		let state_pruning = match blocks_pruning {
+			BlocksPruning::KeepAll => PruningMode::ArchiveAll,
+			BlocksPruning::KeepFinalized => PruningMode::ArchiveCanonical,
+			BlocksPruning::Some(n) => PruningMode::blocks_pruning(n),
+		};
+		let db_setting = DatabaseSettings {
+			trie_cache_maximum_size: Some(16 * 1024 * 1024),
+			state_pruning: Some(state_pruning),
+			source: DatabaseSource::Custom { db, require_create_flag: true },
+			blocks_pruning,
+		};
+
+		Self::new(db_setting, canonicalization_delay).expect("failed to create test-db")
+	}
+
+	/// Expose the Database that is used by this backend.
+	/// The second argument is the Column that stores the State.
+	///
+	/// Should only be needed for benchmarking.
+	#[cfg(any(feature = "runtime-benchmarks"))]
+	pub fn expose_db(&self) -> (Arc<dyn sp_database::Database<DbHash>>, sp_database::ColumnId) {
+		(self.storage.db.clone(), columns::STATE)
+	}
+
+	/// Expose the Storage that is used by this backend.
+	///
+	/// Should only be needed for benchmarking.
+	#[cfg(any(feature = "runtime-benchmarks"))]
+	pub fn expose_storage(&self) -> Arc<dyn sp_state_machine::Storage<HashingFor<Block>>> {
+		self.storage.clone()
+	}
+
+	fn from_database(
+		db: Arc<dyn Database<DbHash>>,
+		canonicalization_delay: u64,
+		config: &DatabaseSettings,
+		should_init: bool,
+	) -> ClientResult<Self> {
+		let mut db_init_transaction = Transaction::new();
+
+		let requested_state_pruning = config.state_pruning.clone();
+		let state_meta_db = StateMetaDb(db.clone());
+		let map_e = sp_blockchain::Error::from_state_db;
+
+		let (state_db_init_commit_set, state_db) = StateDb::open(
+			state_meta_db,
+			requested_state_pruning,
+			!db.supports_ref_counting(),
+			should_init,
+		)
+		.map_err(map_e)?;
+
+		apply_state_commit(&mut db_init_transaction, state_db_init_commit_set);
+
+		let state_pruning_used = state_db.pruning_mode();
+		let is_archive_pruning = state_pruning_used.is_archive();
+		let blockchain = BlockchainDb::new(db.clone())?;
+
+		let storage_db =
+			StorageDb { db: db.clone(), state_db, prefix_keys: !db.supports_ref_counting() };
+
+		let offchain_storage = offchain::LocalStorage::new(db.clone());
+
+		let backend = Backend {
+			storage: Arc::new(storage_db),
+			offchain_storage,
+			blockchain,
+			canonicalization_delay,
+			import_lock: Default::default(),
+			is_archive: is_archive_pruning,
+			io_stats: FrozenForDuration::new(std::time::Duration::from_secs(1)),
+			state_usage: Arc::new(StateUsageStats::new()),
+			blocks_pruning: config.blocks_pruning,
+			genesis_state: RwLock::new(None),
+			shared_trie_cache: config.trie_cache_maximum_size.map(|maximum_size| {
+				SharedTrieCache::new(sp_trie::cache::CacheSize::new(maximum_size))
+			}),
+		};
+
+		// Older DB versions have no last state key. Check if the state is available and set it.
+		let info = backend.blockchain.info();
+		if info.finalized_state.is_none() &&
+			info.finalized_hash != Default::default() &&
+			sc_client_api::Backend::have_state_at(
+				&backend,
+				info.finalized_hash,
+				info.finalized_number,
+			) {
+			backend.blockchain.update_meta(MetaUpdate {
+				hash: info.finalized_hash,
+				number: info.finalized_number,
+				is_best: info.finalized_hash == info.best_hash,
+				is_finalized: true,
+				with_state: true,
+			});
+		}
+
+		db.commit(db_init_transaction)?;
+
+		Ok(backend)
+	}
+
+	/// Handle setting head within a transaction. `route_to` should be the last
+	/// block that existed in the database. `best_to` should be the best block
+	/// to be set.
+	///
+	/// In the case where the new best block is a block to be imported, `route_to`
+	/// should be the parent of `best_to`. In the case where we set an existing block
+	/// to be best, `route_to` should equal to `best_to`.
+	fn set_head_with_transaction(
+		&self,
+		transaction: &mut Transaction<DbHash>,
+		route_to: Block::Hash,
+		best_to: (NumberFor<Block>, Block::Hash),
+	) -> ClientResult<(Vec<Block::Hash>, Vec<Block::Hash>)> {
+		let mut enacted = Vec::default();
+		let mut retracted = Vec::default();
+
+		let (best_number, best_hash) = best_to;
+
+		let meta = self.blockchain.meta.read();
+
+		if meta.best_number.saturating_sub(best_number).saturated_into::<u64>() >
+			self.canonicalization_delay
+		{
+			return Err(sp_blockchain::Error::SetHeadTooOld)
+		}
+
+		let parent_exists =
+			self.blockchain.status(route_to)? == sp_blockchain::BlockStatus::InChain;
+
+		// Cannot find tree route with empty DB or when imported a detached block.
+		if meta.best_hash != Default::default() && parent_exists {
+			let tree_route = sp_blockchain::tree_route(&self.blockchain, meta.best_hash, route_to)?;
+
+			// uncanonicalize: check safety violations and ensure the numbers no longer
+			// point to these block hashes in the key mapping.
+			for r in tree_route.retracted() {
+				if r.hash == meta.finalized_hash {
+					warn!(
+						"Potential safety failure: reverting finalized block {:?}",
+						(&r.number, &r.hash)
+					);
+
+					return Err(sp_blockchain::Error::NotInFinalizedChain)
+				}
+
+				retracted.push(r.hash);
+				utils::remove_number_to_key_mapping(transaction, columns::KEY_LOOKUP, r.number)?;
+			}
+
+			// canonicalize: set the number lookup to map to this block's hash.
+			for e in tree_route.enacted() {
+				enacted.push(e.hash);
+				utils::insert_number_to_key_mapping(
+					transaction,
+					columns::KEY_LOOKUP,
+					e.number,
+					e.hash,
+				)?;
+			}
+		}
+
+		let lookup_key = utils::number_and_hash_to_lookup_key(best_number, &best_hash)?;
+		transaction.set_from_vec(columns::META, meta_keys::BEST_BLOCK, lookup_key);
+		utils::insert_number_to_key_mapping(
+			transaction,
+			columns::KEY_LOOKUP,
+			best_number,
+			best_hash,
+		)?;
+
+		Ok((enacted, retracted))
+	}
+
+	fn ensure_sequential_finalization(
+		&self,
+		header: &Block::Header,
+		last_finalized: Option<Block::Hash>,
+	) -> ClientResult<()> {
+		let last_finalized =
+			last_finalized.unwrap_or_else(|| self.blockchain.meta.read().finalized_hash);
+		if last_finalized != self.blockchain.meta.read().genesis_hash &&
+			*header.parent_hash() != last_finalized
+		{
+			return Err(sp_blockchain::Error::NonSequentialFinalization(format!(
+				"Last finalized {:?} not parent of {:?}",
+				last_finalized,
+				header.hash()
+			)))
+		}
+		Ok(())
+	}
+
+	fn finalize_block_with_transaction(
+		&self,
+		transaction: &mut Transaction<DbHash>,
+		hash: Block::Hash,
+		header: &Block::Header,
+		last_finalized: Option<Block::Hash>,
+		justification: Option<Justification>,
+		current_transaction_justifications: &mut HashMap<Block::Hash, Justification>,
+	) -> ClientResult<MetaUpdate<Block>> {
+		// TODO: ensure best chain contains this block.
+		let number = *header.number();
+		self.ensure_sequential_finalization(header, last_finalized)?;
+		let with_state = sc_client_api::Backend::have_state_at(self, hash, number);
+
+		self.note_finalized(
+			transaction,
+			header,
+			hash,
+			with_state,
+			current_transaction_justifications,
+		)?;
+
+		if let Some(justification) = justification {
+			transaction.set_from_vec(
+				columns::JUSTIFICATIONS,
+				&utils::number_and_hash_to_lookup_key(number, hash)?,
+				Justifications::from(justification.clone()).encode(),
+			);
+			current_transaction_justifications.insert(hash, justification);
+		}
+		Ok(MetaUpdate { hash, number, is_best: false, is_finalized: true, with_state })
+	}
+
+	// performs forced canonicalization with a delay after importing a non-finalized block.
+	fn force_delayed_canonicalize(
+		&self,
+		transaction: &mut Transaction<DbHash>,
+	) -> ClientResult<()> {
+		let best_canonical = match self.storage.state_db.last_canonicalized() {
+			LastCanonicalized::None => 0,
+			LastCanonicalized::Block(b) => b,
+			// Nothing needs to be done when canonicalization is not happening.
+			LastCanonicalized::NotCanonicalizing => return Ok(()),
+		};
+
+		let info = self.blockchain.info();
+		let best_number: u64 = self.blockchain.info().best_number.saturated_into();
+
+		for to_canonicalize in
+			best_canonical + 1..=best_number.saturating_sub(self.canonicalization_delay)
+		{
+			let hash_to_canonicalize = sc_client_api::blockchain::HeaderBackend::hash(
+				&self.blockchain,
+				to_canonicalize.saturated_into(),
+			)?
+			.ok_or_else(|| {
+				let best_hash = info.best_hash;
+
+				sp_blockchain::Error::Backend(format!(
+					"Can't canonicalize missing block number #{to_canonicalize} when for best block {best_hash:?} (#{best_number})",
+				))
+			})?;
+
+			if !sc_client_api::Backend::have_state_at(
+				self,
+				hash_to_canonicalize,
+				to_canonicalize.saturated_into(),
+			) {
+				return Ok(())
+			}
+
+			trace!(target: "db", "Canonicalize block #{} ({:?})", to_canonicalize, hash_to_canonicalize);
+			let commit = self.storage.state_db.canonicalize_block(&hash_to_canonicalize).map_err(
+				sp_blockchain::Error::from_state_db::<
+					sc_state_db::Error<sp_database::error::DatabaseError>,
+				>,
+			)?;
+			apply_state_commit(transaction, commit);
+		}
+
+		Ok(())
+	}
+
+	fn try_commit_operation(&self, mut operation: BlockImportOperation<Block>) -> ClientResult<()> {
+		let mut transaction = Transaction::new();
+
+		operation.apply_aux(&mut transaction);
+		operation.apply_offchain(&mut transaction);
+
+		let mut meta_updates = Vec::with_capacity(operation.finalized_blocks.len());
+		let (best_num, mut last_finalized_hash, mut last_finalized_num, mut block_gap) = {
+			let meta = self.blockchain.meta.read();
+			(meta.best_number, meta.finalized_hash, meta.finalized_number, meta.block_gap)
+		};
+
+		let mut current_transaction_justifications: HashMap<Block::Hash, Justification> =
+			HashMap::new();
+		for (block_hash, justification) in operation.finalized_blocks {
+			let block_header = self.blockchain.expect_header(block_hash)?;
+			meta_updates.push(self.finalize_block_with_transaction(
+				&mut transaction,
+				block_hash,
+				&block_header,
+				Some(last_finalized_hash),
+				justification,
+				&mut current_transaction_justifications,
+			)?);
+			last_finalized_hash = block_hash;
+			last_finalized_num = *block_header.number();
+		}
+
+		let imported = if let Some(pending_block) = operation.pending_block {
+			let hash = pending_block.header.hash();
+
+			let parent_hash = *pending_block.header.parent_hash();
+			let number = *pending_block.header.number();
+			let highest_leaf = self
+				.blockchain
+				.leaves
+				.read()
+				.highest_leaf()
+				.map(|(n, _)| n)
+				.unwrap_or(Zero::zero());
+			let existing_header = number <= highest_leaf && self.blockchain.header(hash)?.is_some();
+
+			// blocks are keyed by number + hash.
+			let lookup_key = utils::number_and_hash_to_lookup_key(number, hash)?;
+
+			if pending_block.leaf_state.is_best() {
+				self.set_head_with_transaction(&mut transaction, parent_hash, (number, hash))?;
+			};
+
+			utils::insert_hash_to_key_mapping(&mut transaction, columns::KEY_LOOKUP, number, hash)?;
+
+			transaction.set_from_vec(columns::HEADER, &lookup_key, pending_block.header.encode());
+			if let Some(body) = pending_block.body {
+				// If we have any index operations we save block in the new format with indexed
+				// extrinsic headers Otherwise we save the body as a single blob.
+				if operation.index_ops.is_empty() {
+					transaction.set_from_vec(columns::BODY, &lookup_key, body.encode());
+				} else {
+					let body =
+						apply_index_ops::<Block>(&mut transaction, body, operation.index_ops);
+					transaction.set_from_vec(columns::BODY_INDEX, &lookup_key, body);
+				}
+			}
+			if let Some(body) = pending_block.indexed_body {
+				apply_indexed_body::<Block>(&mut transaction, body);
+			}
+			if let Some(justifications) = pending_block.justifications {
+				transaction.set_from_vec(
+					columns::JUSTIFICATIONS,
+					&lookup_key,
+					justifications.encode(),
+				);
+			}
+
+			if number.is_zero() {
+				transaction.set(columns::META, meta_keys::GENESIS_HASH, hash.as_ref());
+
+				if operation.commit_state {
+					transaction.set_from_vec(columns::META, meta_keys::FINALIZED_STATE, lookup_key);
+				} else {
+					// When we don't want to commit the genesis state, we still preserve it in
+					// memory to bootstrap consensus. It is queried for an initial list of
+					// authorities, etc.
+					*self.genesis_state.write() = Some(Arc::new(DbGenesisStorage::new(
+						*pending_block.header.state_root(),
+						operation.db_updates.clone(),
+					)));
+				}
+			}
+
+			let finalized = if operation.commit_state {
+				let mut changeset: sc_state_db::ChangeSet<Vec<u8>> =
+					sc_state_db::ChangeSet::default();
+				let mut ops: u64 = 0;
+				let mut bytes: u64 = 0;
+				let mut removal: u64 = 0;
+				let mut bytes_removal: u64 = 0;
+				for (mut key, (val, rc)) in operation.db_updates.drain() {
+					self.storage.db.sanitize_key(&mut key);
+					if rc > 0 {
+						ops += 1;
+						bytes += key.len() as u64 + val.len() as u64;
+						if rc == 1 {
+							changeset.inserted.push((key, val.to_vec()));
+						} else {
+							changeset.inserted.push((key.clone(), val.to_vec()));
+							for _ in 0..rc - 1 {
+								changeset.inserted.push((key.clone(), Default::default()));
+							}
+						}
+					} else if rc < 0 {
+						removal += 1;
+						bytes_removal += key.len() as u64;
+						if rc == -1 {
+							changeset.deleted.push(key);
+						} else {
+							for _ in 0..-rc {
+								changeset.deleted.push(key.clone());
+							}
+						}
+					}
+				}
+				self.state_usage.tally_writes_nodes(ops, bytes);
+				self.state_usage.tally_removed_nodes(removal, bytes_removal);
+
+				let mut ops: u64 = 0;
+				let mut bytes: u64 = 0;
+				for (key, value) in operation
+					.storage_updates
+					.iter()
+					.chain(operation.child_storage_updates.iter().flat_map(|(_, s)| s.iter()))
+				{
+					ops += 1;
+					bytes += key.len() as u64;
+					if let Some(v) = value.as_ref() {
+						bytes += v.len() as u64;
+					}
+				}
+				self.state_usage.tally_writes(ops, bytes);
+				let number_u64 = number.saturated_into::<u64>();
+				let commit = self
+					.storage
+					.state_db
+					.insert_block(&hash, number_u64, pending_block.header.parent_hash(), changeset)
+					.map_err(|e: sc_state_db::Error<sp_database::error::DatabaseError>| {
+						sp_blockchain::Error::from_state_db(e)
+					})?;
+				apply_state_commit(&mut transaction, commit);
+				if number <= last_finalized_num {
+					// Canonicalize in the db when re-importing existing blocks with state.
+					let commit = self.storage.state_db.canonicalize_block(&hash).map_err(
+						sp_blockchain::Error::from_state_db::<
+							sc_state_db::Error<sp_database::error::DatabaseError>,
+						>,
+					)?;
+					apply_state_commit(&mut transaction, commit);
+					meta_updates.push(MetaUpdate {
+						hash,
+						number,
+						is_best: false,
+						is_finalized: true,
+						with_state: true,
+					});
+				}
+
+				// Check if need to finalize. Genesis is always finalized instantly.
+				let finalized = number_u64 == 0 || pending_block.leaf_state.is_final();
+				finalized
+			} else {
+				(number.is_zero() && last_finalized_num.is_zero()) ||
+					pending_block.leaf_state.is_final()
+			};
+
+			let header = &pending_block.header;
+			let is_best = pending_block.leaf_state.is_best();
+			debug!(
+				target: "db",
+				"DB Commit {:?} ({}), best={}, state={}, existing={}, finalized={}",
+				hash,
+				number,
+				is_best,
+				operation.commit_state,
+				existing_header,
+				finalized,
+			);
+
+			self.state_usage.merge_sm(operation.old_state.usage_info());
+
+			// release state reference so that it can be finalized
+			// VERY IMPORTANT
+			drop(operation.old_state);
+
+			if finalized {
+				// TODO: ensure best chain contains this block.
+				self.ensure_sequential_finalization(header, Some(last_finalized_hash))?;
+				let mut current_transaction_justifications = HashMap::new();
+				self.note_finalized(
+					&mut transaction,
+					header,
+					hash,
+					operation.commit_state,
+					&mut current_transaction_justifications,
+				)?;
+			} else {
+				// canonicalize blocks which are old enough, regardless of finality.
+				self.force_delayed_canonicalize(&mut transaction)?
+			}
+
+			if !existing_header {
+				// Add a new leaf if the block has the potential to be finalized.
+				if number > last_finalized_num || last_finalized_num.is_zero() {
+					let mut leaves = self.blockchain.leaves.write();
+					leaves.import(hash, number, parent_hash);
+					leaves.prepare_transaction(
+						&mut transaction,
+						columns::META,
+						meta_keys::LEAF_PREFIX,
+					);
+				}
+
+				let mut children = children::read_children(
+					&*self.storage.db,
+					columns::META,
+					meta_keys::CHILDREN_PREFIX,
+					parent_hash,
+				)?;
+				if !children.contains(&hash) {
+					children.push(hash);
+					children::write_children(
+						&mut transaction,
+						columns::META,
+						meta_keys::CHILDREN_PREFIX,
+						parent_hash,
+						children,
+					);
+				}
+
+				if let Some((mut start, end)) = block_gap {
+					if number == start {
+						start += One::one();
+						utils::insert_number_to_key_mapping(
+							&mut transaction,
+							columns::KEY_LOOKUP,
+							number,
+							hash,
+						)?;
+					}
+					if start > end {
+						transaction.remove(columns::META, meta_keys::BLOCK_GAP);
+						block_gap = None;
+						debug!(target: "db", "Removed block gap.");
+					} else {
+						block_gap = Some((start, end));
+						debug!(target: "db", "Update block gap. {:?}", block_gap);
+						transaction.set(
+							columns::META,
+							meta_keys::BLOCK_GAP,
+							&(start, end).encode(),
+						);
+					}
+				} else if number > best_num + One::one() &&
+					number > One::one() && self.blockchain.header(parent_hash)?.is_none()
+				{
+					let gap = (best_num + One::one(), number - One::one());
+					transaction.set(columns::META, meta_keys::BLOCK_GAP, &gap.encode());
+					block_gap = Some(gap);
+					debug!(target: "db", "Detected block gap {:?}", block_gap);
+				}
+			}
+
+			meta_updates.push(MetaUpdate {
+				hash,
+				number,
+				is_best: pending_block.leaf_state.is_best(),
+				is_finalized: finalized,
+				with_state: operation.commit_state,
+			});
+			Some((pending_block.header, hash))
+		} else {
+			None
+		};
+
+		if let Some(set_head) = operation.set_head {
+			if let Some(header) =
+				sc_client_api::blockchain::HeaderBackend::header(&self.blockchain, set_head)?
+			{
+				let number = header.number();
+				let hash = header.hash();
+
+				self.set_head_with_transaction(&mut transaction, hash, (*number, hash))?;
+
+				meta_updates.push(MetaUpdate {
+					hash,
+					number: *number,
+					is_best: true,
+					is_finalized: false,
+					with_state: false,
+				});
+			} else {
+				return Err(sp_blockchain::Error::UnknownBlock(format!(
+					"Cannot set head {:?}",
+					set_head
+				)))
+			}
+		}
+
+		self.storage.db.commit(transaction)?;
+
+		// Apply all in-memory state changes.
+		// Code beyond this point can't fail.
+
+		if let Some((header, hash)) = imported {
+			trace!(target: "db", "DB Commit done {:?}", hash);
+			let header_metadata = CachedHeaderMetadata::from(&header);
+			self.blockchain.insert_header_metadata(header_metadata.hash, header_metadata);
+			cache_header(&mut self.blockchain.header_cache.lock(), hash, Some(header));
+		}
+
+		for m in meta_updates {
+			self.blockchain.update_meta(m);
+		}
+		self.blockchain.update_block_gap(block_gap);
+
+		Ok(())
+	}
+
+	// write stuff to a transaction after a new block is finalized.
+	// this canonicalizes finalized blocks. Fails if called with a block which
+	// was not a child of the last finalized block.
+	fn note_finalized(
+		&self,
+		transaction: &mut Transaction<DbHash>,
+		f_header: &Block::Header,
+		f_hash: Block::Hash,
+		with_state: bool,
+		current_transaction_justifications: &mut HashMap<Block::Hash, Justification>,
+	) -> ClientResult<()> {
+		let f_num = *f_header.number();
+
+		let lookup_key = utils::number_and_hash_to_lookup_key(f_num, f_hash)?;
+		if with_state {
+			transaction.set_from_vec(columns::META, meta_keys::FINALIZED_STATE, lookup_key.clone());
+		}
+		transaction.set_from_vec(columns::META, meta_keys::FINALIZED_BLOCK, lookup_key);
+
+		let requires_canonicalization = match self.storage.state_db.last_canonicalized() {
+			LastCanonicalized::None => true,
+			LastCanonicalized::Block(b) => f_num.saturated_into::<u64>() > b,
+			LastCanonicalized::NotCanonicalizing => false,
+		};
+
+		if requires_canonicalization && sc_client_api::Backend::have_state_at(self, f_hash, f_num) {
+			let commit = self.storage.state_db.canonicalize_block(&f_hash).map_err(
+				sp_blockchain::Error::from_state_db::<
+					sc_state_db::Error<sp_database::error::DatabaseError>,
+				>,
+			)?;
+			apply_state_commit(transaction, commit);
+		}
+
+		let new_displaced = self.blockchain.leaves.write().finalize_height(f_num);
+		self.prune_blocks(
+			transaction,
+			f_num,
+			f_hash,
+			&new_displaced,
+			current_transaction_justifications,
+		)?;
+
+		Ok(())
+	}
+
+	fn prune_blocks(
+		&self,
+		transaction: &mut Transaction<DbHash>,
+		finalized_number: NumberFor<Block>,
+		finalized_hash: Block::Hash,
+		displaced: &FinalizationOutcome<Block::Hash, NumberFor<Block>>,
+		current_transaction_justifications: &mut HashMap<Block::Hash, Justification>,
+	) -> ClientResult<()> {
+		match self.blocks_pruning {
+			BlocksPruning::KeepAll => {},
+			BlocksPruning::Some(blocks_pruning) => {
+				// Always keep the last finalized block
+				let keep = std::cmp::max(blocks_pruning, 1);
+				if finalized_number >= keep.into() {
+					let number = finalized_number.saturating_sub(keep.into());
+
+					// Before we prune a block, check if it is pinned
+					if let Some(hash) = self.blockchain.hash(number)? {
+						self.blockchain.insert_persisted_body_if_pinned(hash)?;
+
+						// If the block was finalized in this transaction, it will not be in the db
+						// yet.
+						if let Some(justification) =
+							current_transaction_justifications.remove(&hash)
+						{
+							self.blockchain.insert_justifications_if_pinned(hash, justification);
+						} else {
+							self.blockchain.insert_persisted_justifications_if_pinned(hash)?;
+						}
+					};
+
+					self.prune_block(transaction, BlockId::<Block>::number(number))?;
+				}
+				self.prune_displaced_branches(transaction, finalized_hash, displaced)?;
+			},
+			BlocksPruning::KeepFinalized => {
+				self.prune_displaced_branches(transaction, finalized_hash, displaced)?;
+			},
+		}
+		Ok(())
+	}
+
+	fn prune_displaced_branches(
+		&self,
+		transaction: &mut Transaction<DbHash>,
+		finalized: Block::Hash,
+		displaced: &FinalizationOutcome<Block::Hash, NumberFor<Block>>,
+	) -> ClientResult<()> {
+		// Discard all blocks from displaced branches
+		for h in displaced.leaves() {
+			match sp_blockchain::tree_route(&self.blockchain, *h, finalized) {
+				Ok(tree_route) =>
+					for r in tree_route.retracted() {
+						self.blockchain.insert_persisted_body_if_pinned(r.hash)?;
+						self.prune_block(transaction, BlockId::<Block>::hash(r.hash))?;
+					},
+				Err(sp_blockchain::Error::UnknownBlock(_)) => {
+					// Sometimes routes can't be calculated. E.g. after warp sync.
+				},
+				Err(e) => Err(e)?,
+			}
+		}
+		Ok(())
+	}
+
+	fn prune_block(
+		&self,
+		transaction: &mut Transaction<DbHash>,
+		id: BlockId<Block>,
+	) -> ClientResult<()> {
+		debug!(target: "db", "Removing block #{}", id);
+		utils::remove_from_db(
+			transaction,
+			&*self.storage.db,
+			columns::KEY_LOOKUP,
+			columns::BODY,
+			id,
+		)?;
+		utils::remove_from_db(
+			transaction,
+			&*self.storage.db,
+			columns::KEY_LOOKUP,
+			columns::JUSTIFICATIONS,
+			id,
+		)?;
+		if let Some(index) =
+			read_db(&*self.storage.db, columns::KEY_LOOKUP, columns::BODY_INDEX, id)?
+		{
+			utils::remove_from_db(
+				transaction,
+				&*self.storage.db,
+				columns::KEY_LOOKUP,
+				columns::BODY_INDEX,
+				id,
+			)?;
+			match Vec::<DbExtrinsic<Block>>::decode(&mut &index[..]) {
+				Ok(index) =>
+					for ex in index {
+						if let DbExtrinsic::Indexed { hash, .. } = ex {
+							transaction.release(columns::TRANSACTION, hash);
+						}
+					},
+				Err(err) =>
+					return Err(sp_blockchain::Error::Backend(format!(
+						"Error decoding body list: {}",
+						err
+					))),
+			}
+		}
+		Ok(())
+	}
+
+	fn empty_state(&self) -> RecordStatsState<RefTrackingState<Block>, Block> {
+		let root = EmptyStorage::<Block>::new().0; // Empty trie
+		let db_state = DbStateBuilder::<Block>::new(self.storage.clone(), root)
+			.with_optional_cache(self.shared_trie_cache.as_ref().map(|c| c.local_cache()))
+			.build();
+		let state = RefTrackingState::new(db_state, self.storage.clone(), None);
+		RecordStatsState::new(state, None, self.state_usage.clone())
+	}
+}
+
+fn apply_state_commit(
+	transaction: &mut Transaction<DbHash>,
+	commit: sc_state_db::CommitSet<Vec<u8>>,
+) {
+	for (key, val) in commit.data.inserted.into_iter() {
+		transaction.set_from_vec(columns::STATE, &key[..], val);
+	}
+	for key in commit.data.deleted.into_iter() {
+		transaction.remove(columns::STATE, &key[..]);
+	}
+	for (key, val) in commit.meta.inserted.into_iter() {
+		transaction.set_from_vec(columns::STATE_META, &key[..], val);
+	}
+	for key in commit.meta.deleted.into_iter() {
+		transaction.remove(columns::STATE_META, &key[..]);
+	}
+}
+
+fn apply_index_ops<Block: BlockT>(
+	transaction: &mut Transaction<DbHash>,
+	body: Vec<Block::Extrinsic>,
+	ops: Vec<IndexOperation>,
+) -> Vec<u8> {
+	let mut extrinsic_index: Vec<DbExtrinsic<Block>> = Vec::with_capacity(body.len());
+	let mut index_map = HashMap::new();
+	let mut renewed_map = HashMap::new();
+	for op in ops {
+		match op {
+			IndexOperation::Insert { extrinsic, hash, size } => {
+				index_map.insert(extrinsic, (hash, size));
+			},
+			IndexOperation::Renew { extrinsic, hash } => {
+				renewed_map.insert(extrinsic, DbHash::from_slice(hash.as_ref()));
+			},
+		}
+	}
+	for (index, extrinsic) in body.into_iter().enumerate() {
+		let db_extrinsic = if let Some(hash) = renewed_map.get(&(index as u32)) {
+			// Bump ref counter
+			let extrinsic = extrinsic.encode();
+			transaction.reference(columns::TRANSACTION, DbHash::from_slice(hash.as_ref()));
+			DbExtrinsic::Indexed { hash: *hash, header: extrinsic }
+		} else {
+			match index_map.get(&(index as u32)) {
+				Some((hash, size)) => {
+					let encoded = extrinsic.encode();
+					if *size as usize <= encoded.len() {
+						let offset = encoded.len() - *size as usize;
+						transaction.store(
+							columns::TRANSACTION,
+							DbHash::from_slice(hash.as_ref()),
+							encoded[offset..].to_vec(),
+						);
+						DbExtrinsic::Indexed {
+							hash: DbHash::from_slice(hash.as_ref()),
+							header: encoded[..offset].to_vec(),
+						}
+					} else {
+						// Invalid indexed slice. Just store full data and don't index anything.
+						DbExtrinsic::Full(extrinsic)
+					}
+				},
+				_ => DbExtrinsic::Full(extrinsic),
+			}
+		};
+		extrinsic_index.push(db_extrinsic);
+	}
+	debug!(
+		target: "db",
+		"DB transaction index: {} inserted, {} renewed, {} full",
+		index_map.len(),
+		renewed_map.len(),
+		extrinsic_index.len() - index_map.len() - renewed_map.len(),
+	);
+	extrinsic_index.encode()
+}
+
+fn apply_indexed_body<Block: BlockT>(transaction: &mut Transaction<DbHash>, body: Vec<Vec<u8>>) {
+	for extrinsic in body {
+		let hash = sp_runtime::traits::BlakeTwo256::hash(&extrinsic);
+		transaction.store(columns::TRANSACTION, DbHash::from_slice(hash.as_ref()), extrinsic);
+	}
+}
+
+impl<Block> sc_client_api::backend::AuxStore for Backend<Block>
+where
+	Block: BlockT,
+{
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item = &'a &'b [u8]>,
+	>(
+		&self,
+		insert: I,
+		delete: D,
+	) -> ClientResult<()> {
+		let mut transaction = Transaction::new();
+		for (k, v) in insert {
+			transaction.set(columns::AUX, k, v);
+		}
+		for k in delete {
+			transaction.remove(columns::AUX, k);
+		}
+		self.storage.db.commit(transaction)?;
+		Ok(())
+	}
+
+	fn get_aux(&self, key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
+		Ok(self.storage.db.get(columns::AUX, key))
+	}
+}
+
+impl<Block: BlockT> sc_client_api::backend::Backend<Block> for Backend<Block> {
+	type BlockImportOperation = BlockImportOperation<Block>;
+	type Blockchain = BlockchainDb<Block>;
+	type State = RecordStatsState<RefTrackingState<Block>, Block>;
+	type OffchainStorage = offchain::LocalStorage;
+
+	fn begin_operation(&self) -> ClientResult<Self::BlockImportOperation> {
+		Ok(BlockImportOperation {
+			pending_block: None,
+			old_state: self.empty_state(),
+			db_updates: PrefixedMemoryDB::default(),
+			storage_updates: Default::default(),
+			child_storage_updates: Default::default(),
+			offchain_storage_updates: Default::default(),
+			aux_ops: Vec::new(),
+			finalized_blocks: Vec::new(),
+			set_head: None,
+			commit_state: false,
+			index_ops: Default::default(),
+		})
+	}
+
+	fn begin_state_operation(
+		&self,
+		operation: &mut Self::BlockImportOperation,
+		block: Block::Hash,
+	) -> ClientResult<()> {
+		if block == Default::default() {
+			operation.old_state = self.empty_state();
+		} else {
+			operation.old_state = self.state_at(block)?;
+		}
+
+		operation.commit_state = true;
+		Ok(())
+	}
+
+	fn commit_operation(&self, operation: Self::BlockImportOperation) -> ClientResult<()> {
+		let usage = operation.old_state.usage_info();
+		self.state_usage.merge_sm(usage);
+
+		if let Err(e) = self.try_commit_operation(operation) {
+			let state_meta_db = StateMetaDb(self.storage.db.clone());
+			self.storage
+				.state_db
+				.reset(state_meta_db)
+				.map_err(sp_blockchain::Error::from_state_db)?;
+			self.blockchain.clear_pinning_cache();
+			Err(e)
+		} else {
+			self.storage.state_db.sync();
+			Ok(())
+		}
+	}
+
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+	) -> ClientResult<()> {
+		let mut transaction = Transaction::new();
+		let header = self.blockchain.expect_header(hash)?;
+
+		let mut current_transaction_justifications = HashMap::new();
+		let m = self.finalize_block_with_transaction(
+			&mut transaction,
+			hash,
+			&header,
+			None,
+			justification,
+			&mut current_transaction_justifications,
+		)?;
+
+		self.storage.db.commit(transaction)?;
+		self.blockchain.update_meta(m);
+		Ok(())
+	}
+
+	fn append_justification(
+		&self,
+		hash: Block::Hash,
+		justification: Justification,
+	) -> ClientResult<()> {
+		let mut transaction: Transaction<DbHash> = Transaction::new();
+		let header = self.blockchain.expect_header(hash)?;
+		let number = *header.number();
+
+		// Check if the block is finalized first.
+		let is_descendent_of = is_descendent_of(&self.blockchain, None);
+		let last_finalized = self.blockchain.last_finalized()?;
+
+		// We can do a quick check first, before doing a proper but more expensive check
+		if number > self.blockchain.info().finalized_number ||
+			(hash != last_finalized && !is_descendent_of(&hash, &last_finalized)?)
+		{
+			return Err(ClientError::NotInFinalizedChain)
+		}
+
+		let justifications = if let Some(mut stored_justifications) =
+			self.blockchain.justifications(hash)?
+		{
+			if !stored_justifications.append(justification) {
+				return Err(ClientError::BadJustification("Duplicate consensus engine ID".into()))
+			}
+			stored_justifications
+		} else {
+			Justifications::from(justification)
+		};
+
+		transaction.set_from_vec(
+			columns::JUSTIFICATIONS,
+			&utils::number_and_hash_to_lookup_key(number, hash)?,
+			justifications.encode(),
+		);
+
+		self.storage.db.commit(transaction)?;
+
+		Ok(())
+	}
+
+	fn offchain_storage(&self) -> Option<Self::OffchainStorage> {
+		Some(self.offchain_storage.clone())
+	}
+
+	fn usage_info(&self) -> Option<UsageInfo> {
+		let (io_stats, state_stats) = self.io_stats.take_or_else(|| {
+			(
+				// TODO: implement DB stats and cache size retrieval
+				kvdb::IoStats::empty(),
+				self.state_usage.take(),
+			)
+		});
+		let database_cache = MemorySize::from_bytes(0);
+		let state_cache = MemorySize::from_bytes(
+			self.shared_trie_cache.as_ref().map_or(0, |c| c.used_memory_size()),
+		);
+
+		Some(UsageInfo {
+			memory: MemoryInfo { state_cache, database_cache },
+			io: IoInfo {
+				transactions: io_stats.transactions,
+				bytes_read: io_stats.bytes_read,
+				bytes_written: io_stats.bytes_written,
+				writes: io_stats.writes,
+				reads: io_stats.reads,
+				average_transaction_size: io_stats.avg_transaction_size() as u64,
+				state_reads: state_stats.reads.ops,
+				state_writes: state_stats.writes.ops,
+				state_writes_cache: state_stats.overlay_writes.ops,
+				state_reads_cache: state_stats.cache_reads.ops,
+				state_writes_nodes: state_stats.nodes_writes.ops,
+			},
+		})
+	}
+
+	fn revert(
+		&self,
+		n: NumberFor<Block>,
+		revert_finalized: bool,
+	) -> ClientResult<(NumberFor<Block>, HashSet<Block::Hash>)> {
+		let mut reverted_finalized = HashSet::new();
+
+		let info = self.blockchain.info();
+
+		let highest_leaf = self
+			.blockchain
+			.leaves
+			.read()
+			.highest_leaf()
+			.and_then(|(n, h)| h.last().map(|h| (n, *h)));
+
+		let best_number = info.best_number;
+		let best_hash = info.best_hash;
+
+		let finalized = info.finalized_number;
+
+		let revertible = best_number - finalized;
+		let n = if !revert_finalized && revertible < n { revertible } else { n };
+
+		let (n, mut number_to_revert, mut hash_to_revert) = match highest_leaf {
+			Some((l_n, l_h)) => (n + (l_n - best_number), l_n, l_h),
+			None => (n, best_number, best_hash),
+		};
+
+		let mut revert_blocks = || -> ClientResult<NumberFor<Block>> {
+			for c in 0..n.saturated_into::<u64>() {
+				if number_to_revert.is_zero() {
+					return Ok(c.saturated_into::<NumberFor<Block>>())
+				}
+				let mut transaction = Transaction::new();
+				let removed = self.blockchain.header(hash_to_revert)?.ok_or_else(|| {
+					sp_blockchain::Error::UnknownBlock(format!(
+						"Error reverting to {}. Block header not found.",
+						hash_to_revert,
+					))
+				})?;
+				let removed_hash = removed.hash();
+
+				let prev_number = number_to_revert.saturating_sub(One::one());
+				let prev_hash =
+					if prev_number == best_number { best_hash } else { *removed.parent_hash() };
+
+				if !self.have_state_at(prev_hash, prev_number) {
+					return Ok(c.saturated_into::<NumberFor<Block>>())
+				}
+
+				match self.storage.state_db.revert_one() {
+					Some(commit) => {
+						apply_state_commit(&mut transaction, commit);
+
+						number_to_revert = prev_number;
+						hash_to_revert = prev_hash;
+
+						let update_finalized = number_to_revert < finalized;
+
+						let key = utils::number_and_hash_to_lookup_key(
+							number_to_revert,
+							&hash_to_revert,
+						)?;
+						if update_finalized {
+							transaction.set_from_vec(
+								columns::META,
+								meta_keys::FINALIZED_BLOCK,
+								key.clone(),
+							);
+
+							reverted_finalized.insert(removed_hash);
+							if let Some((hash, _)) = self.blockchain.info().finalized_state {
+								if hash == hash_to_revert {
+									if !number_to_revert.is_zero() &&
+										self.have_state_at(
+											prev_hash,
+											number_to_revert - One::one(),
+										) {
+										let lookup_key = utils::number_and_hash_to_lookup_key(
+											number_to_revert - One::one(),
+											prev_hash,
+										)?;
+										transaction.set_from_vec(
+											columns::META,
+											meta_keys::FINALIZED_STATE,
+											lookup_key,
+										);
+									} else {
+										transaction
+											.remove(columns::META, meta_keys::FINALIZED_STATE);
+									}
+								}
+							}
+						}
+						transaction.set_from_vec(columns::META, meta_keys::BEST_BLOCK, key);
+						transaction.remove(columns::KEY_LOOKUP, removed.hash().as_ref());
+						children::remove_children(
+							&mut transaction,
+							columns::META,
+							meta_keys::CHILDREN_PREFIX,
+							hash_to_revert,
+						);
+						self.storage.db.commit(transaction)?;
+
+						let is_best = number_to_revert < best_number;
+
+						self.blockchain.update_meta(MetaUpdate {
+							hash: hash_to_revert,
+							number: number_to_revert,
+							is_best,
+							is_finalized: update_finalized,
+							with_state: false,
+						});
+					},
+					None => return Ok(c.saturated_into::<NumberFor<Block>>()),
+				}
+			}
+
+			Ok(n)
+		};
+
+		let reverted = revert_blocks()?;
+
+		let revert_leaves = || -> ClientResult<()> {
+			let mut transaction = Transaction::new();
+			let mut leaves = self.blockchain.leaves.write();
+
+			leaves.revert(hash_to_revert, number_to_revert);
+			leaves.prepare_transaction(&mut transaction, columns::META, meta_keys::LEAF_PREFIX);
+			self.storage.db.commit(transaction)?;
+
+			Ok(())
+		};
+
+		revert_leaves()?;
+
+		Ok((reverted, reverted_finalized))
+	}
+
+	fn remove_leaf_block(&self, hash: Block::Hash) -> ClientResult<()> {
+		let best_hash = self.blockchain.info().best_hash;
+
+		if best_hash == hash {
+			return Err(sp_blockchain::Error::Backend(format!("Can't remove best block {:?}", hash)))
+		}
+
+		let hdr = self.blockchain.header_metadata(hash)?;
+		if !self.have_state_at(hash, hdr.number) {
+			return Err(sp_blockchain::Error::UnknownBlock(format!(
+				"State already discarded for {:?}",
+				hash
+			)))
+		}
+
+		let mut leaves = self.blockchain.leaves.write();
+		if !leaves.contains(hdr.number, hash) {
+			return Err(sp_blockchain::Error::Backend(format!(
+				"Can't remove non-leaf block {:?}",
+				hash
+			)))
+		}
+
+		let mut transaction = Transaction::new();
+		if let Some(commit) = self.storage.state_db.remove(&hash) {
+			apply_state_commit(&mut transaction, commit);
+		}
+		transaction.remove(columns::KEY_LOOKUP, hash.as_ref());
+
+		let children: Vec<_> = self
+			.blockchain()
+			.children(hdr.parent)?
+			.into_iter()
+			.filter(|child_hash| *child_hash != hash)
+			.collect();
+		let parent_leaf = if children.is_empty() {
+			children::remove_children(
+				&mut transaction,
+				columns::META,
+				meta_keys::CHILDREN_PREFIX,
+				hdr.parent,
+			);
+			Some(hdr.parent)
+		} else {
+			children::write_children(
+				&mut transaction,
+				columns::META,
+				meta_keys::CHILDREN_PREFIX,
+				hdr.parent,
+				children,
+			);
+			None
+		};
+
+		let remove_outcome = leaves.remove(hash, hdr.number, parent_leaf);
+		leaves.prepare_transaction(&mut transaction, columns::META, meta_keys::LEAF_PREFIX);
+		if let Err(e) = self.storage.db.commit(transaction) {
+			if let Some(outcome) = remove_outcome {
+				leaves.undo().undo_remove(outcome);
+			}
+			return Err(e.into())
+		}
+		self.blockchain().remove_header_metadata(hash);
+		Ok(())
+	}
+
+	fn blockchain(&self) -> &BlockchainDb<Block> {
+		&self.blockchain
+	}
+
+	fn state_at(&self, hash: Block::Hash) -> ClientResult<Self::State> {
+		if hash == self.blockchain.meta.read().genesis_hash {
+			if let Some(genesis_state) = &*self.genesis_state.read() {
+				let root = genesis_state.root;
+				let db_state = DbStateBuilder::<Block>::new(genesis_state.clone(), root)
+					.with_optional_cache(self.shared_trie_cache.as_ref().map(|c| c.local_cache()))
+					.build();
+
+				let state = RefTrackingState::new(db_state, self.storage.clone(), None);
+				return Ok(RecordStatsState::new(state, None, self.state_usage.clone()))
+			}
+		}
+
+		match self.blockchain.header_metadata(hash) {
+			Ok(ref hdr) => {
+				let hint = || {
+					sc_state_db::NodeDb::get(self.storage.as_ref(), hdr.state_root.as_ref())
+						.unwrap_or(None)
+						.is_some()
+				};
+
+				if let Ok(()) =
+					self.storage.state_db.pin(&hash, hdr.number.saturated_into::<u64>(), hint)
+				{
+					let root = hdr.state_root;
+					let db_state = DbStateBuilder::<Block>::new(self.storage.clone(), root)
+						.with_optional_cache(
+							self.shared_trie_cache.as_ref().map(|c| c.local_cache()),
+						)
+						.build();
+					let state = RefTrackingState::new(db_state, self.storage.clone(), Some(hash));
+					Ok(RecordStatsState::new(state, Some(hash), self.state_usage.clone()))
+				} else {
+					Err(sp_blockchain::Error::UnknownBlock(format!(
+						"State already discarded for {:?}",
+						hash
+					)))
+				}
+			},
+			Err(e) => Err(e),
+		}
+	}
+
+	fn have_state_at(&self, hash: Block::Hash, number: NumberFor<Block>) -> bool {
+		if self.is_archive {
+			match self.blockchain.header_metadata(hash) {
+				Ok(header) => sp_state_machine::Storage::get(
+					self.storage.as_ref(),
+					&header.state_root,
+					(&[], None),
+				)
+				.unwrap_or(None)
+				.is_some(),
+				_ => false,
+			}
+		} else {
+			match self.storage.state_db.is_pruned(&hash, number.saturated_into::<u64>()) {
+				IsPruned::Pruned => false,
+				IsPruned::NotPruned => true,
+				IsPruned::MaybePruned => match self.blockchain.header_metadata(hash) {
+					Ok(header) => sp_state_machine::Storage::get(
+						self.storage.as_ref(),
+						&header.state_root,
+						(&[], None),
+					)
+					.unwrap_or(None)
+					.is_some(),
+					_ => false,
+				},
+			}
+		}
+	}
+
+	fn get_import_lock(&self) -> &RwLock<()> {
+		&self.import_lock
+	}
+
+	fn requires_full_sync(&self) -> bool {
+		matches!(
+			self.storage.state_db.pruning_mode(),
+			PruningMode::ArchiveAll | PruningMode::ArchiveCanonical
+		)
+	}
+
+	fn pin_block(&self, hash: <Block as BlockT>::Hash) -> sp_blockchain::Result<()> {
+		let hint = || {
+			let header_metadata = self.blockchain.header_metadata(hash);
+			header_metadata
+				.map(|hdr| {
+					sc_state_db::NodeDb::get(self.storage.as_ref(), hdr.state_root.as_ref())
+						.unwrap_or(None)
+						.is_some()
+				})
+				.unwrap_or(false)
+		};
+
+		if let Some(number) = self.blockchain.number(hash)? {
+			self.storage.state_db.pin(&hash, number.saturated_into::<u64>(), hint).map_err(
+				|_| {
+					sp_blockchain::Error::UnknownBlock(format!(
+						"State already discarded for `{:?}`",
+						hash
+					))
+				},
+			)?;
+		} else {
+			return Err(ClientError::UnknownBlock(format!(
+				"Can not pin block with hash `{:?}`. Block not found.",
+				hash
+			)))
+		}
+
+		if self.blocks_pruning != BlocksPruning::KeepAll {
+			// Only increase reference count for this hash. Value is loaded once we prune.
+			self.blockchain.bump_ref(hash);
+		}
+		Ok(())
+	}
+
+	fn unpin_block(&self, hash: <Block as BlockT>::Hash) {
+		self.storage.state_db.unpin(&hash);
+
+		if self.blocks_pruning != BlocksPruning::KeepAll {
+			self.blockchain.unpin(hash);
+		}
+	}
+}
+
+impl<Block: BlockT> sc_client_api::backend::LocalBackend<Block> for Backend<Block> {}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+	use crate::columns;
+	use hash_db::{HashDB, EMPTY_PREFIX};
+	use sc_client_api::{
+		backend::{Backend as BTrait, BlockImportOperation as Op},
+		blockchain::Backend as BLBTrait,
+	};
+	use sp_blockchain::{lowest_common_ancestor, tree_route};
+	use sp_core::H256;
+	use sp_runtime::{
+		testing::{Block as RawBlock, ExtrinsicWrapper, Header},
+		traits::{BlakeTwo256, Hash},
+		ConsensusEngineId, StateVersion,
+	};
+
+	const CONS0_ENGINE_ID: ConsensusEngineId = *b"CON0";
+	const CONS1_ENGINE_ID: ConsensusEngineId = *b"CON1";
+
+	pub(crate) type Block = RawBlock<ExtrinsicWrapper<u64>>;
+
+	pub fn insert_header(
+		backend: &Backend<Block>,
+		number: u64,
+		parent_hash: H256,
+		changes: Option<Vec<(Vec<u8>, Vec<u8>)>>,
+		extrinsics_root: H256,
+	) -> H256 {
+		insert_block(backend, number, parent_hash, changes, extrinsics_root, Vec::new(), None)
+			.unwrap()
+	}
+
+	pub fn insert_block(
+		backend: &Backend<Block>,
+		number: u64,
+		parent_hash: H256,
+		_changes: Option<Vec<(Vec<u8>, Vec<u8>)>>,
+		extrinsics_root: H256,
+		body: Vec<ExtrinsicWrapper<u64>>,
+		transaction_index: Option<Vec<IndexOperation>>,
+	) -> Result<H256, sp_blockchain::Error> {
+		use sp_runtime::testing::Digest;
+
+		let digest = Digest::default();
+		let mut header =
+			Header { number, parent_hash, state_root: Default::default(), digest, extrinsics_root };
+
+		let block_hash = if number == 0 { Default::default() } else { parent_hash };
+		let mut op = backend.begin_operation().unwrap();
+		backend.begin_state_operation(&mut op, block_hash).unwrap();
+		if let Some(index) = transaction_index {
+			op.update_transaction_index(index).unwrap();
+		}
+
+		// Insert some fake data to ensure that the block can be found in the state column.
+		let (root, overlay) = op.old_state.storage_root(
+			vec![(block_hash.as_ref(), Some(block_hash.as_ref()))].into_iter(),
+			StateVersion::V1,
+		);
+		op.update_db_storage(overlay).unwrap();
+		header.state_root = root.into();
+
+		op.set_block_data(header.clone(), Some(body), None, None, NewBlockState::Best)
+			.unwrap();
+
+		backend.commit_operation(op)?;
+
+		Ok(header.hash())
+	}
+
+	pub fn insert_header_no_head(
+		backend: &Backend<Block>,
+		number: u64,
+		parent_hash: H256,
+		extrinsics_root: H256,
+	) -> H256 {
+		use sp_runtime::testing::Digest;
+
+		let digest = Digest::default();
+		let mut header =
+			Header { number, parent_hash, state_root: Default::default(), digest, extrinsics_root };
+		let mut op = backend.begin_operation().unwrap();
+
+		let root = backend
+			.state_at(parent_hash)
+			.unwrap_or_else(|_| {
+				if parent_hash == Default::default() {
+					backend.empty_state()
+				} else {
+					panic!("Unknown block: {parent_hash:?}")
+				}
+			})
+			.storage_root(
+				vec![(parent_hash.as_ref(), Some(parent_hash.as_ref()))].into_iter(),
+				StateVersion::V1,
+			)
+			.0;
+		header.state_root = root.into();
+
+		op.set_block_data(header.clone(), None, None, None, NewBlockState::Normal)
+			.unwrap();
+		backend.commit_operation(op).unwrap();
+
+		header.hash()
+	}
+
+	#[test]
+	fn block_hash_inserted_correctly() {
+		let backing = {
+			let db = Backend::<Block>::new_test(1, 0);
+			for i in 0..10 {
+				assert!(db.blockchain().hash(i).unwrap().is_none());
+
+				{
+					let hash = if i == 0 {
+						Default::default()
+					} else {
+						db.blockchain.hash(i - 1).unwrap().unwrap()
+					};
+
+					let mut op = db.begin_operation().unwrap();
+					db.begin_state_operation(&mut op, hash).unwrap();
+					let header = Header {
+						number: i,
+						parent_hash: hash,
+						state_root: Default::default(),
+						digest: Default::default(),
+						extrinsics_root: Default::default(),
+					};
+
+					op.set_block_data(header, Some(vec![]), None, None, NewBlockState::Best)
+						.unwrap();
+					db.commit_operation(op).unwrap();
+				}
+
+				assert!(db.blockchain().hash(i).unwrap().is_some())
+			}
+			db.storage.db.clone()
+		};
+
+		let backend = Backend::<Block>::new(
+			DatabaseSettings {
+				trie_cache_maximum_size: Some(16 * 1024 * 1024),
+				state_pruning: Some(PruningMode::blocks_pruning(1)),
+				source: DatabaseSource::Custom { db: backing, require_create_flag: false },
+				blocks_pruning: BlocksPruning::KeepFinalized,
+			},
+			0,
+		)
+		.unwrap();
+		assert_eq!(backend.blockchain().info().best_number, 9);
+		for i in 0..10 {
+			assert!(backend.blockchain().hash(i).unwrap().is_some())
+		}
+	}
+
+	#[test]
+	fn set_state_data() {
+		set_state_data_inner(StateVersion::V0);
+		set_state_data_inner(StateVersion::V1);
+	}
+	fn set_state_data_inner(state_version: StateVersion) {
+		let db = Backend::<Block>::new_test(2, 0);
+		let hash = {
+			let mut op = db.begin_operation().unwrap();
+			let mut header = Header {
+				number: 0,
+				parent_hash: Default::default(),
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage = vec![(vec![1, 3, 5], vec![2, 4, 6]), (vec![1, 2, 3], vec![9, 9, 9])];
+
+			header.state_root = op
+				.old_state
+				.storage_root(storage.iter().map(|(x, y)| (&x[..], Some(&y[..]))), state_version)
+				.0
+				.into();
+			let hash = header.hash();
+
+			op.reset_storage(
+				Storage {
+					top: storage.into_iter().collect(),
+					children_default: Default::default(),
+				},
+				state_version,
+			)
+			.unwrap();
+			op.set_block_data(header.clone(), Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			db.commit_operation(op).unwrap();
+
+			let state = db.state_at(hash).unwrap();
+
+			assert_eq!(state.storage(&[1, 3, 5]).unwrap(), Some(vec![2, 4, 6]));
+			assert_eq!(state.storage(&[1, 2, 3]).unwrap(), Some(vec![9, 9, 9]));
+			assert_eq!(state.storage(&[5, 5, 5]).unwrap(), None);
+
+			hash
+		};
+
+		{
+			let mut op = db.begin_operation().unwrap();
+			db.begin_state_operation(&mut op, hash).unwrap();
+			let mut header = Header {
+				number: 1,
+				parent_hash: hash,
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage = vec![(vec![1, 3, 5], None), (vec![5, 5, 5], Some(vec![4, 5, 6]))];
+
+			let (root, overlay) = op.old_state.storage_root(
+				storage.iter().map(|(k, v)| (k.as_slice(), v.as_ref().map(|v| &v[..]))),
+				state_version,
+			);
+			op.update_db_storage(overlay).unwrap();
+			header.state_root = root.into();
+
+			op.update_storage(storage, Vec::new()).unwrap();
+			op.set_block_data(header.clone(), Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			db.commit_operation(op).unwrap();
+
+			let state = db.state_at(header.hash()).unwrap();
+
+			assert_eq!(state.storage(&[1, 3, 5]).unwrap(), None);
+			assert_eq!(state.storage(&[1, 2, 3]).unwrap(), Some(vec![9, 9, 9]));
+			assert_eq!(state.storage(&[5, 5, 5]).unwrap(), Some(vec![4, 5, 6]));
+		}
+	}
+
+	#[test]
+	fn delete_only_when_negative_rc() {
+		sp_tracing::try_init_simple();
+		let state_version = StateVersion::default();
+		let key;
+		let backend = Backend::<Block>::new_test(1, 0);
+
+		let hash = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, Default::default()).unwrap();
+			let mut header = Header {
+				number: 0,
+				parent_hash: Default::default(),
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			header.state_root =
+				op.old_state.storage_root(std::iter::empty(), state_version).0.into();
+			let hash = header.hash();
+
+			op.reset_storage(
+				Storage { top: Default::default(), children_default: Default::default() },
+				state_version,
+			)
+			.unwrap();
+
+			key = op.db_updates.insert(EMPTY_PREFIX, b"hello");
+			op.set_block_data(header, Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+			assert_eq!(
+				backend
+					.storage
+					.db
+					.get(columns::STATE, &sp_trie::prefixed_key::<BlakeTwo256>(&key, EMPTY_PREFIX))
+					.unwrap(),
+				&b"hello"[..]
+			);
+			hash
+		};
+
+		let hashof1 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, hash).unwrap();
+			let mut header = Header {
+				number: 1,
+				parent_hash: hash,
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage: Vec<(_, _)> = vec![];
+
+			header.state_root = op
+				.old_state
+				.storage_root(storage.iter().cloned().map(|(x, y)| (x, Some(y))), state_version)
+				.0
+				.into();
+			let hash = header.hash();
+
+			op.db_updates.insert(EMPTY_PREFIX, b"hello");
+			op.db_updates.remove(&key, EMPTY_PREFIX);
+			op.set_block_data(header, Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+			assert_eq!(
+				backend
+					.storage
+					.db
+					.get(columns::STATE, &sp_trie::prefixed_key::<BlakeTwo256>(&key, EMPTY_PREFIX))
+					.unwrap(),
+				&b"hello"[..]
+			);
+			hash
+		};
+
+		let hashof2 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, hashof1).unwrap();
+			let mut header = Header {
+				number: 2,
+				parent_hash: hashof1,
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage: Vec<(_, _)> = vec![];
+
+			header.state_root = op
+				.old_state
+				.storage_root(storage.iter().cloned().map(|(x, y)| (x, Some(y))), state_version)
+				.0
+				.into();
+			let hash = header.hash();
+
+			op.db_updates.remove(&key, EMPTY_PREFIX);
+			op.set_block_data(header, Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+
+			assert!(backend
+				.storage
+				.db
+				.get(columns::STATE, &sp_trie::prefixed_key::<BlakeTwo256>(&key, EMPTY_PREFIX))
+				.is_some());
+			hash
+		};
+
+		let hashof3 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, hashof2).unwrap();
+			let mut header = Header {
+				number: 3,
+				parent_hash: hashof2,
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage: Vec<(_, _)> = vec![];
+
+			header.state_root = op
+				.old_state
+				.storage_root(storage.iter().cloned().map(|(x, y)| (x, Some(y))), state_version)
+				.0
+				.into();
+			let hash = header.hash();
+
+			op.set_block_data(header, Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+			hash
+		};
+
+		let hashof4 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, hashof3).unwrap();
+			let mut header = Header {
+				number: 4,
+				parent_hash: hashof3,
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage: Vec<(_, _)> = vec![];
+
+			header.state_root = op
+				.old_state
+				.storage_root(storage.iter().cloned().map(|(x, y)| (x, Some(y))), state_version)
+				.0
+				.into();
+			let hash = header.hash();
+
+			op.set_block_data(header, Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+			assert!(backend
+				.storage
+				.db
+				.get(columns::STATE, &sp_trie::prefixed_key::<BlakeTwo256>(&key, EMPTY_PREFIX))
+				.is_none());
+			hash
+		};
+
+		backend.finalize_block(hashof1, None).unwrap();
+		backend.finalize_block(hashof2, None).unwrap();
+		backend.finalize_block(hashof3, None).unwrap();
+		backend.finalize_block(hashof4, None).unwrap();
+		assert!(backend
+			.storage
+			.db
+			.get(columns::STATE, &sp_trie::prefixed_key::<BlakeTwo256>(&key, EMPTY_PREFIX))
+			.is_none());
+	}
+
+	#[test]
+	fn tree_route_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.
+		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());
+
+		{
+			let tree_route = tree_route(blockchain, a1, a1).unwrap();
+
+			assert_eq!(tree_route.common_block().hash, a1);
+			assert!(tree_route.retracted().is_empty());
+			assert!(tree_route.enacted().is_empty());
+		}
+
+		{
+			let tree_route = tree_route(blockchain, a3, b2).unwrap();
+
+			assert_eq!(tree_route.common_block().hash, block0);
+			assert_eq!(
+				tree_route.retracted().iter().map(|r| r.hash).collect::<Vec<_>>(),
+				vec![a3, a2, a1]
+			);
+			assert_eq!(
+				tree_route.enacted().iter().map(|r| r.hash).collect::<Vec<_>>(),
+				vec![b1, b2]
+			);
+		}
+
+		{
+			let tree_route = tree_route(blockchain, a1, a3).unwrap();
+
+			assert_eq!(tree_route.common_block().hash, a1);
+			assert!(tree_route.retracted().is_empty());
+			assert_eq!(
+				tree_route.enacted().iter().map(|r| r.hash).collect::<Vec<_>>(),
+				vec![a2, a3]
+			);
+		}
+
+		{
+			let tree_route = tree_route(blockchain, a3, a1).unwrap();
+
+			assert_eq!(tree_route.common_block().hash, a1);
+			assert_eq!(
+				tree_route.retracted().iter().map(|r| r.hash).collect::<Vec<_>>(),
+				vec![a3, a2]
+			);
+			assert!(tree_route.enacted().is_empty());
+		}
+
+		{
+			let tree_route = tree_route(blockchain, a2, a2).unwrap();
+
+			assert_eq!(tree_route.common_block().hash, a2);
+			assert!(tree_route.retracted().is_empty());
+			assert!(tree_route.enacted().is_empty());
+		}
+	}
+
+	#[test]
+	fn tree_route_child() {
+		let backend = Backend::<Block>::new_test(1000, 100);
+		let blockchain = backend.blockchain();
+
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+
+		{
+			let tree_route = tree_route(blockchain, block0, block1).unwrap();
+
+			assert_eq!(tree_route.common_block().hash, block0);
+			assert!(tree_route.retracted().is_empty());
+			assert_eq!(
+				tree_route.enacted().iter().map(|r| r.hash).collect::<Vec<_>>(),
+				vec![block1]
+			);
+		}
+	}
+
+	#[test]
+	fn lowest_common_ancestor_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.
+		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());
+
+		{
+			let lca = lowest_common_ancestor(blockchain, a3, b2).unwrap();
+
+			assert_eq!(lca.hash, block0);
+			assert_eq!(lca.number, 0);
+		}
+
+		{
+			let lca = lowest_common_ancestor(blockchain, a1, a3).unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor(blockchain, a3, a1).unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor(blockchain, a2, a3).unwrap();
+
+			assert_eq!(lca.hash, a2);
+			assert_eq!(lca.number, 2);
+		}
+
+		{
+			let lca = lowest_common_ancestor(blockchain, a2, a1).unwrap();
+
+			assert_eq!(lca.hash, a1);
+			assert_eq!(lca.number, 1);
+		}
+
+		{
+			let lca = lowest_common_ancestor(blockchain, a2, a2).unwrap();
+
+			assert_eq!(lca.hash, a2);
+			assert_eq!(lca.number, 2);
+		}
+	}
+
+	#[test]
+	fn test_tree_route_regression() {
+		// NOTE: this is a test for a regression introduced in #3665, the result
+		// of tree_route would be erroneously computed, since it was taking into
+		// account the `ancestor` in `CachedHeaderMetadata` for the comparison.
+		// in this test we simulate the same behavior with the side-effect
+		// triggering the issue being eviction of a previously fetched record
+		// from the cache, therefore this test is dependent on the LRU cache
+		// size for header metadata, which is currently set to 5000 elements.
+		let backend = Backend::<Block>::new_test(10000, 10000);
+		let blockchain = backend.blockchain();
+
+		let genesis = insert_header(&backend, 0, Default::default(), None, Default::default());
+
+		let block100 = (1..=100).fold(genesis, |parent, n| {
+			insert_header(&backend, n, parent, None, Default::default())
+		});
+
+		let block7000 = (101..=7000).fold(block100, |parent, n| {
+			insert_header(&backend, n, parent, None, Default::default())
+		});
+
+		// This will cause the ancestor of `block100` to be set to `genesis` as a side-effect.
+		lowest_common_ancestor(blockchain, genesis, block100).unwrap();
+
+		// While traversing the tree we will have to do 6900 calls to
+		// `header_metadata`, which will make sure we will exhaust our cache
+		// which only takes 5000 elements. In particular, the `CachedHeaderMetadata` struct for
+		// block #100 will be evicted and will get a new value (with ancestor set to its parent).
+		let tree_route = tree_route(blockchain, block100, block7000).unwrap();
+
+		assert!(tree_route.retracted().is_empty());
+	}
+
+	#[test]
+	fn test_leaves_with_complex_block_tree() {
+		let backend: Arc<Backend<substrate_test_runtime_client::runtime::Block>> =
+			Arc::new(Backend::new_test(20, 20));
+		substrate_test_runtime_client::trait_tests::test_leaves_for_backend(backend);
+	}
+
+	#[test]
+	fn test_children_with_complex_block_tree() {
+		let backend: Arc<Backend<substrate_test_runtime_client::runtime::Block>> =
+			Arc::new(Backend::new_test(20, 20));
+		substrate_test_runtime_client::trait_tests::test_children_for_backend(backend);
+	}
+
+	#[test]
+	fn test_blockchain_query_by_number_gets_canonical() {
+		let backend: Arc<Backend<substrate_test_runtime_client::runtime::Block>> =
+			Arc::new(Backend::new_test(20, 20));
+		substrate_test_runtime_client::trait_tests::test_blockchain_query_by_number_gets_canonical(
+			backend,
+		);
+	}
+
+	#[test]
+	fn test_leaves_pruned_on_finality() {
+		let backend: Backend<Block> = Backend::new_test(10, 10);
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+
+		let block1_a = insert_header(&backend, 1, block0, None, Default::default());
+		let block1_b = insert_header(&backend, 1, block0, None, [1; 32].into());
+		let block1_c = insert_header(&backend, 1, block0, None, [2; 32].into());
+
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![block1_a, block1_b, block1_c]);
+
+		let block2_a = insert_header(&backend, 2, block1_a, None, Default::default());
+		let block2_b = insert_header(&backend, 2, block1_b, None, Default::default());
+		let block2_c = insert_header(&backend, 2, block1_b, None, [1; 32].into());
+
+		assert_eq!(
+			backend.blockchain().leaves().unwrap(),
+			vec![block2_a, block2_b, block2_c, block1_c]
+		);
+
+		backend.finalize_block(block1_a, None).unwrap();
+		backend.finalize_block(block2_a, None).unwrap();
+
+		// leaves at same height stay. Leaves at lower heights pruned.
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a, block2_b, block2_c]);
+	}
+
+	#[test]
+	fn test_aux() {
+		let backend: Backend<substrate_test_runtime_client::runtime::Block> =
+			Backend::new_test(0, 0);
+		assert!(backend.get_aux(b"test").unwrap().is_none());
+		backend.insert_aux(&[(&b"test"[..], &b"hello"[..])], &[]).unwrap();
+		assert_eq!(b"hello", &backend.get_aux(b"test").unwrap().unwrap()[..]);
+		backend.insert_aux(&[], &[&b"test"[..]]).unwrap();
+		assert!(backend.get_aux(b"test").unwrap().is_none());
+	}
+
+	#[test]
+	fn test_finalize_block_with_justification() {
+		use sc_client_api::blockchain::Backend as BlockChainBackend;
+
+		let backend = Backend::<Block>::new_test(10, 10);
+
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+
+		let justification = Some((CONS0_ENGINE_ID, vec![1, 2, 3]));
+		backend.finalize_block(block1, justification.clone()).unwrap();
+
+		assert_eq!(
+			backend.blockchain().justifications(block1).unwrap(),
+			justification.map(Justifications::from),
+		);
+	}
+
+	#[test]
+	fn test_append_justification_to_finalized_block() {
+		use sc_client_api::blockchain::Backend as BlockChainBackend;
+
+		let backend = Backend::<Block>::new_test(10, 10);
+
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+
+		let just0 = (CONS0_ENGINE_ID, vec![1, 2, 3]);
+		backend.finalize_block(block1, Some(just0.clone().into())).unwrap();
+
+		let just1 = (CONS1_ENGINE_ID, vec![4, 5]);
+		backend.append_justification(block1, just1.clone()).unwrap();
+
+		let just2 = (CONS1_ENGINE_ID, vec![6, 7]);
+		assert!(matches!(
+			backend.append_justification(block1, just2),
+			Err(ClientError::BadJustification(_))
+		));
+
+		let justifications = {
+			let mut just = Justifications::from(just0);
+			just.append(just1);
+			just
+		};
+		assert_eq!(backend.blockchain().justifications(block1).unwrap(), Some(justifications),);
+	}
+
+	#[test]
+	fn test_finalize_multiple_blocks_in_single_op() {
+		let backend = Backend::<Block>::new_test(10, 10);
+
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+		let block2 = insert_header(&backend, 2, block1, None, Default::default());
+		let block3 = insert_header(&backend, 3, block2, None, Default::default());
+		let block4 = insert_header(&backend, 4, block3, None, Default::default());
+		{
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, block0).unwrap();
+			op.mark_finalized(block1, None).unwrap();
+			op.mark_finalized(block2, None).unwrap();
+			backend.commit_operation(op).unwrap();
+		}
+		{
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, block2).unwrap();
+			op.mark_finalized(block3, None).unwrap();
+			op.mark_finalized(block4, None).unwrap();
+			backend.commit_operation(op).unwrap();
+		}
+	}
+
+	#[test]
+	fn storage_hash_is_cached_correctly() {
+		let state_version = StateVersion::default();
+		let backend = Backend::<Block>::new_test(10, 10);
+
+		let hash0 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, Default::default()).unwrap();
+			let mut header = Header {
+				number: 0,
+				parent_hash: Default::default(),
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage = vec![(b"test".to_vec(), b"test".to_vec())];
+
+			header.state_root = op
+				.old_state
+				.storage_root(storage.iter().map(|(x, y)| (&x[..], Some(&y[..]))), state_version)
+				.0
+				.into();
+			let hash = header.hash();
+
+			op.reset_storage(
+				Storage {
+					top: storage.into_iter().collect(),
+					children_default: Default::default(),
+				},
+				state_version,
+			)
+			.unwrap();
+			op.set_block_data(header.clone(), Some(vec![]), None, None, NewBlockState::Best)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+
+			hash
+		};
+
+		let block0_hash = backend.state_at(hash0).unwrap().storage_hash(&b"test"[..]).unwrap();
+
+		let hash1 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, hash0).unwrap();
+			let mut header = Header {
+				number: 1,
+				parent_hash: hash0,
+				state_root: Default::default(),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			let storage = vec![(b"test".to_vec(), Some(b"test2".to_vec()))];
+
+			let (root, overlay) = op.old_state.storage_root(
+				storage.iter().map(|(k, v)| (k.as_slice(), v.as_ref().map(|v| &v[..]))),
+				state_version,
+			);
+			op.update_db_storage(overlay).unwrap();
+			header.state_root = root.into();
+			let hash = header.hash();
+
+			op.update_storage(storage, Vec::new()).unwrap();
+			op.set_block_data(header, Some(vec![]), None, None, NewBlockState::Normal)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+
+			hash
+		};
+
+		{
+			let header = backend.blockchain().header(hash1).unwrap().unwrap();
+			let mut op = backend.begin_operation().unwrap();
+			op.set_block_data(header, None, None, None, NewBlockState::Best).unwrap();
+			backend.commit_operation(op).unwrap();
+		}
+
+		let block1_hash = backend.state_at(hash1).unwrap().storage_hash(&b"test"[..]).unwrap();
+
+		assert_ne!(block0_hash, block1_hash);
+	}
+
+	#[test]
+	fn test_finalize_non_sequential() {
+		let backend = Backend::<Block>::new_test(10, 10);
+
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+		let block2 = insert_header(&backend, 2, block1, None, Default::default());
+		{
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, block0).unwrap();
+			op.mark_finalized(block2, None).unwrap();
+			backend.commit_operation(op).unwrap_err();
+		}
+	}
+
+	#[test]
+	fn prune_blocks_on_finalize() {
+		let pruning_modes =
+			vec![BlocksPruning::Some(2), BlocksPruning::KeepFinalized, BlocksPruning::KeepAll];
+
+		for pruning_mode in pruning_modes {
+			let backend = Backend::<Block>::new_test_with_tx_storage(pruning_mode, 0);
+			let mut blocks = Vec::new();
+			let mut prev_hash = Default::default();
+			for i in 0..5 {
+				let hash = insert_block(
+					&backend,
+					i,
+					prev_hash,
+					None,
+					Default::default(),
+					vec![i.into()],
+					None,
+				)
+				.unwrap();
+				blocks.push(hash);
+				prev_hash = hash;
+			}
+
+			{
+				let mut op = backend.begin_operation().unwrap();
+				backend.begin_state_operation(&mut op, blocks[4]).unwrap();
+				for i in 1..5 {
+					op.mark_finalized(blocks[i], None).unwrap();
+				}
+				backend.commit_operation(op).unwrap();
+			}
+			let bc = backend.blockchain();
+
+			if matches!(pruning_mode, BlocksPruning::Some(_)) {
+				assert_eq!(None, bc.body(blocks[0]).unwrap());
+				assert_eq!(None, bc.body(blocks[1]).unwrap());
+				assert_eq!(None, bc.body(blocks[2]).unwrap());
+				assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
+				assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
+			} else {
+				for i in 0..5 {
+					assert_eq!(Some(vec![(i as u64).into()]), bc.body(blocks[i]).unwrap());
+				}
+			}
+		}
+	}
+
+	#[test]
+	fn prune_blocks_on_finalize_with_fork() {
+		sp_tracing::try_init_simple();
+
+		let pruning_modes =
+			vec![BlocksPruning::Some(2), BlocksPruning::KeepFinalized, BlocksPruning::KeepAll];
+
+		for pruning in pruning_modes {
+			let backend = Backend::<Block>::new_test_with_tx_storage(pruning, 10);
+			let mut blocks = Vec::new();
+			let mut prev_hash = Default::default();
+			for i in 0..5 {
+				let hash = insert_block(
+					&backend,
+					i,
+					prev_hash,
+					None,
+					Default::default(),
+					vec![i.into()],
+					None,
+				)
+				.unwrap();
+				blocks.push(hash);
+				prev_hash = hash;
+			}
+
+			// insert a fork at block 2
+			let fork_hash_root =
+				insert_block(&backend, 2, blocks[1], None, H256::random(), vec![2.into()], None)
+					.unwrap();
+			insert_block(
+				&backend,
+				3,
+				fork_hash_root,
+				None,
+				H256::random(),
+				vec![3.into(), 11.into()],
+				None,
+			)
+			.unwrap();
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, blocks[4]).unwrap();
+			op.mark_head(blocks[4]).unwrap();
+			backend.commit_operation(op).unwrap();
+
+			let bc = backend.blockchain();
+			assert_eq!(Some(vec![2.into()]), bc.body(fork_hash_root).unwrap());
+
+			for i in 1..5 {
+				let mut op = backend.begin_operation().unwrap();
+				backend.begin_state_operation(&mut op, blocks[4]).unwrap();
+				op.mark_finalized(blocks[i], None).unwrap();
+				backend.commit_operation(op).unwrap();
+			}
+
+			if matches!(pruning, BlocksPruning::Some(_)) {
+				assert_eq!(None, bc.body(blocks[0]).unwrap());
+				assert_eq!(None, bc.body(blocks[1]).unwrap());
+				assert_eq!(None, bc.body(blocks[2]).unwrap());
+
+				assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
+				assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
+			} else {
+				for i in 0..5 {
+					assert_eq!(Some(vec![(i as u64).into()]), bc.body(blocks[i]).unwrap());
+				}
+			}
+
+			if matches!(pruning, BlocksPruning::KeepAll) {
+				assert_eq!(Some(vec![2.into()]), bc.body(fork_hash_root).unwrap());
+			} else {
+				assert_eq!(None, bc.body(fork_hash_root).unwrap());
+			}
+
+			assert_eq!(bc.info().best_number, 4);
+			for i in 0..5 {
+				assert!(bc.hash(i).unwrap().is_some());
+			}
+		}
+	}
+
+	#[test]
+	fn prune_blocks_on_finalize_and_reorg() {
+		//	0 - 1b
+		//	\ - 1a - 2a - 3a
+		//	     \ - 2b
+
+		let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(10), 10);
+
+		let make_block = |index, parent, val: u64| {
+			insert_block(&backend, index, parent, None, H256::random(), vec![val.into()], None)
+				.unwrap()
+		};
+
+		let block_0 = make_block(0, Default::default(), 0x00);
+		let block_1a = make_block(1, block_0, 0x1a);
+		let block_1b = make_block(1, block_0, 0x1b);
+		let block_2a = make_block(2, block_1a, 0x2a);
+		let block_2b = make_block(2, block_1a, 0x2b);
+		let block_3a = make_block(3, block_2a, 0x3a);
+
+		// Make sure 1b is head
+		let mut op = backend.begin_operation().unwrap();
+		backend.begin_state_operation(&mut op, block_0).unwrap();
+		op.mark_head(block_1b).unwrap();
+		backend.commit_operation(op).unwrap();
+
+		// Finalize 3a
+		let mut op = backend.begin_operation().unwrap();
+		backend.begin_state_operation(&mut op, block_0).unwrap();
+		op.mark_head(block_3a).unwrap();
+		op.mark_finalized(block_1a, None).unwrap();
+		op.mark_finalized(block_2a, None).unwrap();
+		op.mark_finalized(block_3a, None).unwrap();
+		backend.commit_operation(op).unwrap();
+
+		let bc = backend.blockchain();
+		assert_eq!(None, bc.body(block_1b).unwrap());
+		assert_eq!(None, bc.body(block_2b).unwrap());
+		assert_eq!(Some(vec![0x00.into()]), bc.body(block_0).unwrap());
+		assert_eq!(Some(vec![0x1a.into()]), bc.body(block_1a).unwrap());
+		assert_eq!(Some(vec![0x2a.into()]), bc.body(block_2a).unwrap());
+		assert_eq!(Some(vec![0x3a.into()]), bc.body(block_3a).unwrap());
+	}
+
+	#[test]
+	fn indexed_data_block_body() {
+		let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(1), 10);
+
+		let x0 = ExtrinsicWrapper::from(0u64).encode();
+		let x1 = ExtrinsicWrapper::from(1u64).encode();
+		let x0_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x0[1..]);
+		let x1_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x1[1..]);
+		let index = vec![
+			IndexOperation::Insert {
+				extrinsic: 0,
+				hash: x0_hash.as_ref().to_vec(),
+				size: (x0.len() - 1) as u32,
+			},
+			IndexOperation::Insert {
+				extrinsic: 1,
+				hash: x1_hash.as_ref().to_vec(),
+				size: (x1.len() - 1) as u32,
+			},
+		];
+		let hash = insert_block(
+			&backend,
+			0,
+			Default::default(),
+			None,
+			Default::default(),
+			vec![0u64.into(), 1u64.into()],
+			Some(index),
+		)
+		.unwrap();
+		let bc = backend.blockchain();
+		assert_eq!(bc.indexed_transaction(x0_hash).unwrap().unwrap(), &x0[1..]);
+		assert_eq!(bc.indexed_transaction(x1_hash).unwrap().unwrap(), &x1[1..]);
+
+		let hashof0 = bc.info().genesis_hash;
+		// Push one more blocks and make sure block is pruned and transaction index is cleared.
+		let block1 =
+			insert_block(&backend, 1, hash, None, Default::default(), vec![], None).unwrap();
+		backend.finalize_block(block1, None).unwrap();
+		assert_eq!(bc.body(hashof0).unwrap(), None);
+		assert_eq!(bc.indexed_transaction(x0_hash).unwrap(), None);
+		assert_eq!(bc.indexed_transaction(x1_hash).unwrap(), None);
+	}
+
+	#[test]
+	fn index_invalid_size() {
+		let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(1), 10);
+
+		let x0 = ExtrinsicWrapper::from(0u64).encode();
+		let x1 = ExtrinsicWrapper::from(1u64).encode();
+		let x0_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x0[..]);
+		let x1_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x1[..]);
+		let index = vec![
+			IndexOperation::Insert {
+				extrinsic: 0,
+				hash: x0_hash.as_ref().to_vec(),
+				size: (x0.len()) as u32,
+			},
+			IndexOperation::Insert {
+				extrinsic: 1,
+				hash: x1_hash.as_ref().to_vec(),
+				size: (x1.len() + 1) as u32,
+			},
+		];
+		insert_block(
+			&backend,
+			0,
+			Default::default(),
+			None,
+			Default::default(),
+			vec![0u64.into(), 1u64.into()],
+			Some(index),
+		)
+		.unwrap();
+		let bc = backend.blockchain();
+		assert_eq!(bc.indexed_transaction(x0_hash).unwrap().unwrap(), &x0[..]);
+		assert_eq!(bc.indexed_transaction(x1_hash).unwrap(), None);
+	}
+
+	#[test]
+	fn renew_transaction_storage() {
+		let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(2), 10);
+		let mut blocks = Vec::new();
+		let mut prev_hash = Default::default();
+		let x1 = ExtrinsicWrapper::from(0u64).encode();
+		let x1_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x1[1..]);
+		for i in 0..10 {
+			let mut index = Vec::new();
+			if i == 0 {
+				index.push(IndexOperation::Insert {
+					extrinsic: 0,
+					hash: x1_hash.as_ref().to_vec(),
+					size: (x1.len() - 1) as u32,
+				});
+			} else if i < 5 {
+				// keep renewing 1st
+				index.push(IndexOperation::Renew { extrinsic: 0, hash: x1_hash.as_ref().to_vec() });
+			} // else stop renewing
+			let hash = insert_block(
+				&backend,
+				i,
+				prev_hash,
+				None,
+				Default::default(),
+				vec![i.into()],
+				Some(index),
+			)
+			.unwrap();
+			blocks.push(hash);
+			prev_hash = hash;
+		}
+
+		for i in 1..10 {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, blocks[4]).unwrap();
+			op.mark_finalized(blocks[i], None).unwrap();
+			backend.commit_operation(op).unwrap();
+			let bc = backend.blockchain();
+			if i < 6 {
+				assert!(bc.indexed_transaction(x1_hash).unwrap().is_some());
+			} else {
+				assert!(bc.indexed_transaction(x1_hash).unwrap().is_none());
+			}
+		}
+	}
+
+	#[test]
+	fn remove_leaf_block_works() {
+		let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(2), 10);
+		let mut blocks = Vec::new();
+		let mut prev_hash = Default::default();
+		for i in 0..2 {
+			let hash = insert_block(
+				&backend,
+				i,
+				prev_hash,
+				None,
+				Default::default(),
+				vec![i.into()],
+				None,
+			)
+			.unwrap();
+			blocks.push(hash);
+			prev_hash = hash;
+		}
+
+		for i in 0..2 {
+			let hash = insert_block(
+				&backend,
+				2,
+				blocks[1],
+				None,
+				sp_core::H256::random(),
+				vec![i.into()],
+				None,
+			)
+			.unwrap();
+			blocks.push(hash);
+		}
+
+		// insert a fork at block 1, which becomes best block
+		let best_hash = insert_block(
+			&backend,
+			1,
+			blocks[0],
+			None,
+			sp_core::H256::random(),
+			vec![42.into()],
+			None,
+		)
+		.unwrap();
+
+		assert_eq!(backend.blockchain().info().best_hash, best_hash);
+		assert!(backend.remove_leaf_block(best_hash).is_err());
+
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![blocks[2], blocks[3], best_hash]);
+		assert_eq!(backend.blockchain().children(blocks[1]).unwrap(), vec![blocks[2], blocks[3]]);
+
+		assert!(backend.have_state_at(blocks[3], 2));
+		assert!(backend.blockchain().header(blocks[3]).unwrap().is_some());
+		backend.remove_leaf_block(blocks[3]).unwrap();
+		assert!(!backend.have_state_at(blocks[3], 2));
+		assert!(backend.blockchain().header(blocks[3]).unwrap().is_none());
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![blocks[2], best_hash]);
+		assert_eq!(backend.blockchain().children(blocks[1]).unwrap(), vec![blocks[2]]);
+
+		assert!(backend.have_state_at(blocks[2], 2));
+		assert!(backend.blockchain().header(blocks[2]).unwrap().is_some());
+		backend.remove_leaf_block(blocks[2]).unwrap();
+		assert!(!backend.have_state_at(blocks[2], 2));
+		assert!(backend.blockchain().header(blocks[2]).unwrap().is_none());
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![best_hash, blocks[1]]);
+		assert_eq!(backend.blockchain().children(blocks[1]).unwrap(), vec![]);
+
+		assert!(backend.have_state_at(blocks[1], 1));
+		assert!(backend.blockchain().header(blocks[1]).unwrap().is_some());
+		backend.remove_leaf_block(blocks[1]).unwrap();
+		assert!(!backend.have_state_at(blocks[1], 1));
+		assert!(backend.blockchain().header(blocks[1]).unwrap().is_none());
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![best_hash]);
+		assert_eq!(backend.blockchain().children(blocks[0]).unwrap(), vec![best_hash]);
+	}
+
+	#[test]
+	fn test_import_existing_block_as_new_head() {
+		let backend: Backend<Block> = Backend::new_test(10, 3);
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+		let block2 = insert_header(&backend, 2, block1, None, Default::default());
+		let block3 = insert_header(&backend, 3, block2, None, Default::default());
+		let block4 = insert_header(&backend, 4, block3, None, Default::default());
+		let block5 = insert_header(&backend, 5, block4, None, Default::default());
+		assert_eq!(backend.blockchain().info().best_hash, block5);
+
+		// Insert 1 as best again. This should fail because canonicalization_delay == 3 and best ==
+		// 5
+		let header = Header {
+			number: 1,
+			parent_hash: block0,
+			state_root: BlakeTwo256::trie_root(Vec::new(), StateVersion::V1),
+			digest: Default::default(),
+			extrinsics_root: Default::default(),
+		};
+		let mut op = backend.begin_operation().unwrap();
+		op.set_block_data(header, None, None, None, NewBlockState::Best).unwrap();
+		assert!(matches!(backend.commit_operation(op), Err(sp_blockchain::Error::SetHeadTooOld)));
+
+		// Insert 2 as best again.
+		let header = backend.blockchain().header(block2).unwrap().unwrap();
+		let mut op = backend.begin_operation().unwrap();
+		op.set_block_data(header, None, None, None, NewBlockState::Best).unwrap();
+		backend.commit_operation(op).unwrap();
+		assert_eq!(backend.blockchain().info().best_hash, block2);
+	}
+
+	#[test]
+	fn test_import_existing_block_as_final() {
+		let backend: Backend<Block> = Backend::new_test(10, 10);
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+		let _block2 = insert_header(&backend, 2, block1, None, Default::default());
+		// Genesis is auto finalized, the rest are not.
+		assert_eq!(backend.blockchain().info().finalized_hash, block0);
+
+		// Insert 1 as final again.
+		let header = backend.blockchain().header(block1).unwrap().unwrap();
+
+		let mut op = backend.begin_operation().unwrap();
+		op.set_block_data(header, None, None, None, NewBlockState::Final).unwrap();
+		backend.commit_operation(op).unwrap();
+
+		assert_eq!(backend.blockchain().info().finalized_hash, block1);
+	}
+
+	#[test]
+	fn test_import_existing_state_fails() {
+		let backend: Backend<Block> = Backend::new_test(10, 10);
+		let genesis =
+			insert_block(&backend, 0, Default::default(), None, Default::default(), vec![], None)
+				.unwrap();
+
+		insert_block(&backend, 1, genesis, None, Default::default(), vec![], None).unwrap();
+		let err = insert_block(&backend, 1, genesis, None, Default::default(), vec![], None)
+			.err()
+			.unwrap();
+		match err {
+			sp_blockchain::Error::StateDatabase(m) if m == "Block already exists" => (),
+			e @ _ => panic!("Unexpected error {:?}", e),
+		}
+	}
+
+	#[test]
+	fn test_leaves_not_created_for_ancient_blocks() {
+		let backend: Backend<Block> = Backend::new_test(10, 10);
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+
+		let block1_a = insert_header(&backend, 1, block0, None, Default::default());
+		let block2_a = insert_header(&backend, 2, block1_a, None, Default::default());
+		backend.finalize_block(block1_a, None).unwrap();
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a]);
+
+		// Insert a fork prior to finalization point. Leave should not be created.
+		insert_header_no_head(&backend, 1, block0, [1; 32].into());
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a]);
+	}
+
+	#[test]
+	fn revert_non_best_blocks() {
+		let backend = Backend::<Block>::new_test(10, 10);
+
+		let genesis =
+			insert_block(&backend, 0, Default::default(), None, Default::default(), vec![], None)
+				.unwrap();
+
+		let block1 =
+			insert_block(&backend, 1, genesis, None, Default::default(), vec![], None).unwrap();
+
+		let block2 =
+			insert_block(&backend, 2, block1, None, Default::default(), vec![], None).unwrap();
+
+		let block3 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, block1).unwrap();
+			let header = Header {
+				number: 3,
+				parent_hash: block2,
+				state_root: BlakeTwo256::trie_root(Vec::new(), StateVersion::V1),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			op.set_block_data(header.clone(), Some(Vec::new()), None, None, NewBlockState::Normal)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+
+			header.hash()
+		};
+
+		let block4 = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, block2).unwrap();
+			let header = Header {
+				number: 4,
+				parent_hash: block3,
+				state_root: BlakeTwo256::trie_root(Vec::new(), StateVersion::V1),
+				digest: Default::default(),
+				extrinsics_root: Default::default(),
+			};
+
+			op.set_block_data(header.clone(), Some(Vec::new()), None, None, NewBlockState::Normal)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+
+			header.hash()
+		};
+
+		let block3_fork = {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, block2).unwrap();
+			let header = Header {
+				number: 3,
+				parent_hash: block2,
+				state_root: BlakeTwo256::trie_root(Vec::new(), StateVersion::V1),
+				digest: Default::default(),
+				extrinsics_root: H256::from_low_u64_le(42),
+			};
+
+			op.set_block_data(header.clone(), Some(Vec::new()), None, None, NewBlockState::Normal)
+				.unwrap();
+
+			backend.commit_operation(op).unwrap();
+
+			header.hash()
+		};
+
+		assert!(backend.have_state_at(block1, 1));
+		assert!(backend.have_state_at(block2, 2));
+		assert!(backend.have_state_at(block3, 3));
+		assert!(backend.have_state_at(block4, 4));
+		assert!(backend.have_state_at(block3_fork, 3));
+
+		assert_eq!(backend.blockchain.leaves().unwrap(), vec![block4, block3_fork]);
+		assert_eq!(4, backend.blockchain.leaves.read().highest_leaf().unwrap().0);
+
+		assert_eq!(3, backend.revert(1, false).unwrap().0);
+
+		assert!(backend.have_state_at(block1, 1));
+		assert!(!backend.have_state_at(block2, 2));
+		assert!(!backend.have_state_at(block3, 3));
+		assert!(!backend.have_state_at(block4, 4));
+		assert!(!backend.have_state_at(block3_fork, 3));
+
+		assert_eq!(backend.blockchain.leaves().unwrap(), vec![block1]);
+		assert_eq!(1, backend.blockchain.leaves.read().highest_leaf().unwrap().0);
+	}
+
+	#[test]
+	fn revert_finalized_blocks() {
+		let pruning_modes = [BlocksPruning::Some(10), BlocksPruning::KeepAll];
+
+		// we will create a chain with 11 blocks, finalize block #8 and then
+		// attempt to revert 5 blocks.
+		for pruning_mode in pruning_modes {
+			let backend = Backend::<Block>::new_test_with_tx_storage(pruning_mode, 1);
+
+			let mut parent = Default::default();
+			for i in 0..=10 {
+				parent = insert_block(&backend, i, parent, None, Default::default(), vec![], None)
+					.unwrap();
+			}
+
+			assert_eq!(backend.blockchain().info().best_number, 10);
+
+			let block8 = backend.blockchain().hash(8).unwrap().unwrap();
+			backend.finalize_block(block8, None).unwrap();
+			backend.revert(5, true).unwrap();
+
+			match pruning_mode {
+				// we can only revert to blocks for which we have state, if pruning is enabled
+				// then the last state available will be that of the latest finalized block
+				BlocksPruning::Some(_) =>
+					assert_eq!(backend.blockchain().info().finalized_number, 8),
+				// otherwise if we're not doing state pruning we can revert past finalized blocks
+				_ => assert_eq!(backend.blockchain().info().finalized_number, 5),
+			}
+		}
+	}
+
+	#[test]
+	fn test_no_duplicated_leaves_allowed() {
+		let backend: Backend<Block> = Backend::new_test(10, 10);
+		let block0 = insert_header(&backend, 0, Default::default(), None, Default::default());
+		let block1 = insert_header(&backend, 1, block0, None, Default::default());
+		// Add block 2 not as the best block
+		let block2 = insert_header_no_head(&backend, 2, block1, Default::default());
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2]);
+		assert_eq!(backend.blockchain().info().best_hash, block1);
+
+		// Add block 2 as the best block
+		let block2 = insert_header(&backend, 2, block1, None, Default::default());
+		assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2]);
+		assert_eq!(backend.blockchain().info().best_hash, block2);
+	}
+
+	#[test]
+	fn force_delayed_canonicalize_waiting_for_blocks_to_be_finalized() {
+		let pruning_modes =
+			[BlocksPruning::Some(10), BlocksPruning::KeepAll, BlocksPruning::KeepFinalized];
+
+		for pruning_mode in pruning_modes {
+			eprintln!("Running with pruning mode: {:?}", pruning_mode);
+
+			let backend = Backend::<Block>::new_test_with_tx_storage(pruning_mode, 1);
+
+			let genesis = insert_block(
+				&backend,
+				0,
+				Default::default(),
+				None,
+				Default::default(),
+				vec![],
+				None,
+			)
+			.unwrap();
+
+			let block1 = {
+				let mut op = backend.begin_operation().unwrap();
+				backend.begin_state_operation(&mut op, genesis).unwrap();
+				let mut header = Header {
+					number: 1,
+					parent_hash: genesis,
+					state_root: Default::default(),
+					digest: Default::default(),
+					extrinsics_root: Default::default(),
+				};
+
+				let storage = vec![(vec![1, 3, 5], None), (vec![5, 5, 5], Some(vec![4, 5, 6]))];
+
+				let (root, overlay) = op.old_state.storage_root(
+					storage.iter().map(|(k, v)| (k.as_slice(), v.as_ref().map(|v| &v[..]))),
+					StateVersion::V1,
+				);
+				op.update_db_storage(overlay).unwrap();
+				header.state_root = root.into();
+
+				op.update_storage(storage, Vec::new()).unwrap();
+
+				op.set_block_data(
+					header.clone(),
+					Some(Vec::new()),
+					None,
+					None,
+					NewBlockState::Normal,
+				)
+				.unwrap();
+
+				backend.commit_operation(op).unwrap();
+
+				header.hash()
+			};
+
+			if matches!(pruning_mode, BlocksPruning::Some(_)) {
+				assert_eq!(
+					LastCanonicalized::Block(0),
+					backend.storage.state_db.last_canonicalized()
+				);
+			}
+
+			// This should not trigger any forced canonicalization as we didn't have imported any
+			// best block by now.
+			let block2 = {
+				let mut op = backend.begin_operation().unwrap();
+				backend.begin_state_operation(&mut op, block1).unwrap();
+				let mut header = Header {
+					number: 2,
+					parent_hash: block1,
+					state_root: Default::default(),
+					digest: Default::default(),
+					extrinsics_root: Default::default(),
+				};
+
+				let storage = vec![(vec![5, 5, 5], Some(vec![4, 5, 6, 2]))];
+
+				let (root, overlay) = op.old_state.storage_root(
+					storage.iter().map(|(k, v)| (k.as_slice(), v.as_ref().map(|v| &v[..]))),
+					StateVersion::V1,
+				);
+				op.update_db_storage(overlay).unwrap();
+				header.state_root = root.into();
+
+				op.update_storage(storage, Vec::new()).unwrap();
+
+				op.set_block_data(
+					header.clone(),
+					Some(Vec::new()),
+					None,
+					None,
+					NewBlockState::Normal,
+				)
+				.unwrap();
+
+				backend.commit_operation(op).unwrap();
+
+				header.hash()
+			};
+
+			if matches!(pruning_mode, BlocksPruning::Some(_)) {
+				assert_eq!(
+					LastCanonicalized::Block(0),
+					backend.storage.state_db.last_canonicalized()
+				);
+			}
+
+			// This should also not trigger it yet, because we import a best block, but the best
+			// block from the POV of the db is still at `0`.
+			let block3 = {
+				let mut op = backend.begin_operation().unwrap();
+				backend.begin_state_operation(&mut op, block2).unwrap();
+				let mut header = Header {
+					number: 3,
+					parent_hash: block2,
+					state_root: Default::default(),
+					digest: Default::default(),
+					extrinsics_root: Default::default(),
+				};
+
+				let storage = vec![(vec![5, 5, 5], Some(vec![4, 5, 6, 3]))];
+
+				let (root, overlay) = op.old_state.storage_root(
+					storage.iter().map(|(k, v)| (k.as_slice(), v.as_ref().map(|v| &v[..]))),
+					StateVersion::V1,
+				);
+				op.update_db_storage(overlay).unwrap();
+				header.state_root = root.into();
+
+				op.update_storage(storage, Vec::new()).unwrap();
+
+				op.set_block_data(
+					header.clone(),
+					Some(Vec::new()),
+					None,
+					None,
+					NewBlockState::Best,
+				)
+				.unwrap();
+
+				backend.commit_operation(op).unwrap();
+
+				header.hash()
+			};
+
+			// Now it should kick in.
+			let block4 = {
+				let mut op = backend.begin_operation().unwrap();
+				backend.begin_state_operation(&mut op, block3).unwrap();
+				let mut header = Header {
+					number: 4,
+					parent_hash: block3,
+					state_root: Default::default(),
+					digest: Default::default(),
+					extrinsics_root: Default::default(),
+				};
+
+				let storage = vec![(vec![5, 5, 5], Some(vec![4, 5, 6, 4]))];
+
+				let (root, overlay) = op.old_state.storage_root(
+					storage.iter().map(|(k, v)| (k.as_slice(), v.as_ref().map(|v| &v[..]))),
+					StateVersion::V1,
+				);
+				op.update_db_storage(overlay).unwrap();
+				header.state_root = root.into();
+
+				op.update_storage(storage, Vec::new()).unwrap();
+
+				op.set_block_data(
+					header.clone(),
+					Some(Vec::new()),
+					None,
+					None,
+					NewBlockState::Best,
+				)
+				.unwrap();
+
+				backend.commit_operation(op).unwrap();
+
+				header.hash()
+			};
+
+			if matches!(pruning_mode, BlocksPruning::Some(_)) {
+				assert_eq!(
+					LastCanonicalized::Block(2),
+					backend.storage.state_db.last_canonicalized()
+				);
+			}
+
+			assert_eq!(block1, backend.blockchain().hash(1).unwrap().unwrap());
+			assert_eq!(block2, backend.blockchain().hash(2).unwrap().unwrap());
+			assert_eq!(block3, backend.blockchain().hash(3).unwrap().unwrap());
+			assert_eq!(block4, backend.blockchain().hash(4).unwrap().unwrap());
+		}
+	}
+
+	#[test]
+	fn test_pinned_blocks_on_finalize() {
+		let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(1), 10);
+		let mut blocks = Vec::new();
+		let mut prev_hash = Default::default();
+
+		let build_justification = |i: u64| ([0, 0, 0, 0], vec![i.try_into().unwrap()]);
+		// Block tree:
+		//   0 -> 1 -> 2 -> 3 -> 4
+		for i in 0..5 {
+			let hash = insert_block(
+				&backend,
+				i,
+				prev_hash,
+				None,
+				Default::default(),
+				vec![i.into()],
+				None,
+			)
+			.unwrap();
+			blocks.push(hash);
+			// Avoid block pruning.
+			backend.pin_block(blocks[i as usize]).unwrap();
+
+			prev_hash = hash;
+		}
+
+		let bc = backend.blockchain();
+
+		// Check that we can properly access values when there is reference count
+		// but no value.
+		assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
+
+		// Block 1 gets pinned three times
+		backend.pin_block(blocks[1]).unwrap();
+		backend.pin_block(blocks[1]).unwrap();
+
+		// Finalize all blocks. This will trigger pruning.
+		let mut op = backend.begin_operation().unwrap();
+		backend.begin_state_operation(&mut op, blocks[4]).unwrap();
+		for i in 1..5 {
+			op.mark_finalized(blocks[i], Some(build_justification(i.try_into().unwrap())))
+				.unwrap();
+		}
+		backend.commit_operation(op).unwrap();
+
+		// Block 0, 1, 2, 3 are pinned, so all values should be cached.
+		// Block 4 is inside the pruning window, its value is in db.
+		assert_eq!(Some(vec![0.into()]), bc.body(blocks[0]).unwrap());
+
+		assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
+		assert_eq!(
+			Some(Justifications::from(build_justification(1))),
+			bc.justifications(blocks[1]).unwrap()
+		);
+
+		assert_eq!(Some(vec![2.into()]), bc.body(blocks[2]).unwrap());
+		assert_eq!(
+			Some(Justifications::from(build_justification(2))),
+			bc.justifications(blocks[2]).unwrap()
+		);
+
+		assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
+		assert_eq!(
+			Some(Justifications::from(build_justification(3))),
+			bc.justifications(blocks[3]).unwrap()
+		);
+
+		assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
+		assert_eq!(
+			Some(Justifications::from(build_justification(4))),
+			bc.justifications(blocks[4]).unwrap()
+		);
+
+		// Unpin all blocks. Values should be removed from cache.
+		for block in &blocks {
+			backend.unpin_block(*block);
+		}
+
+		assert!(bc.body(blocks[0]).unwrap().is_none());
+		// Block 1 was pinned twice, we expect it to be still cached
+		assert!(bc.body(blocks[1]).unwrap().is_some());
+		assert!(bc.justifications(blocks[1]).unwrap().is_some());
+		// Headers should also be available while pinned
+		assert!(bc.header(blocks[1]).ok().flatten().is_some());
+		assert!(bc.body(blocks[2]).unwrap().is_none());
+		assert!(bc.justifications(blocks[2]).unwrap().is_none());
+		assert!(bc.body(blocks[3]).unwrap().is_none());
+		assert!(bc.justifications(blocks[3]).unwrap().is_none());
+
+		// After these unpins, block 1 should also be removed
+		backend.unpin_block(blocks[1]);
+		assert!(bc.body(blocks[1]).unwrap().is_some());
+		assert!(bc.justifications(blocks[1]).unwrap().is_some());
+		backend.unpin_block(blocks[1]);
+		assert!(bc.body(blocks[1]).unwrap().is_none());
+		assert!(bc.justifications(blocks[1]).unwrap().is_none());
+
+		// Block 4 is inside the pruning window and still kept
+		assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
+		assert_eq!(
+			Some(Justifications::from(build_justification(4))),
+			bc.justifications(blocks[4]).unwrap()
+		);
+
+		// Block tree:
+		//   0 -> 1 -> 2 -> 3 -> 4 -> 5
+		let hash =
+			insert_block(&backend, 5, prev_hash, None, Default::default(), vec![5.into()], None)
+				.unwrap();
+		blocks.push(hash);
+
+		backend.pin_block(blocks[4]).unwrap();
+		// Mark block 5 as finalized.
+		let mut op = backend.begin_operation().unwrap();
+		backend.begin_state_operation(&mut op, blocks[5]).unwrap();
+		op.mark_finalized(blocks[5], Some(build_justification(5))).unwrap();
+		backend.commit_operation(op).unwrap();
+
+		assert!(bc.body(blocks[0]).unwrap().is_none());
+		assert!(bc.body(blocks[1]).unwrap().is_none());
+		assert!(bc.body(blocks[2]).unwrap().is_none());
+		assert!(bc.body(blocks[3]).unwrap().is_none());
+
+		assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
+		assert_eq!(
+			Some(Justifications::from(build_justification(4))),
+			bc.justifications(blocks[4]).unwrap()
+		);
+		assert_eq!(Some(vec![5.into()]), bc.body(blocks[5]).unwrap());
+		assert!(bc.header(blocks[5]).ok().flatten().is_some());
+
+		backend.unpin_block(blocks[4]);
+		assert!(bc.body(blocks[4]).unwrap().is_none());
+		assert!(bc.justifications(blocks[4]).unwrap().is_none());
+
+		// Append a justification to block 5.
+		backend.append_justification(blocks[5], ([0, 0, 0, 1], vec![42])).unwrap();
+
+		let hash =
+			insert_block(&backend, 6, blocks[5], None, Default::default(), vec![6.into()], None)
+				.unwrap();
+		blocks.push(hash);
+
+		// Pin block 5 so it gets loaded into the cache on prune
+		backend.pin_block(blocks[5]).unwrap();
+
+		// Finalize block 6 so block 5 gets pruned. Since it is pinned both justifications should be
+		// in memory.
+		let mut op = backend.begin_operation().unwrap();
+		backend.begin_state_operation(&mut op, blocks[6]).unwrap();
+		op.mark_finalized(blocks[6], None).unwrap();
+		backend.commit_operation(op).unwrap();
+
+		assert_eq!(Some(vec![5.into()]), bc.body(blocks[5]).unwrap());
+		assert!(bc.header(blocks[5]).ok().flatten().is_some());
+		let mut expected = Justifications::from(build_justification(5));
+		expected.append(([0, 0, 0, 1], vec![42]));
+		assert_eq!(Some(expected), bc.justifications(blocks[5]).unwrap());
+	}
+
+	#[test]
+	fn test_pinned_blocks_on_finalize_with_fork() {
+		let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(1), 10);
+		let mut blocks = Vec::new();
+		let mut prev_hash = Default::default();
+
+		// Block tree:
+		//   0 -> 1 -> 2 -> 3 -> 4
+		for i in 0..5 {
+			let hash = insert_block(
+				&backend,
+				i,
+				prev_hash,
+				None,
+				Default::default(),
+				vec![i.into()],
+				None,
+			)
+			.unwrap();
+			blocks.push(hash);
+
+			// Avoid block pruning.
+			backend.pin_block(blocks[i as usize]).unwrap();
+
+			prev_hash = hash;
+		}
+
+		// Insert a fork at the second block.
+		// Block tree:
+		//   0 -> 1 -> 2 -> 3 -> 4
+		//        \ -> 2 -> 3
+		let fork_hash_root =
+			insert_block(&backend, 2, blocks[1], None, H256::random(), vec![2.into()], None)
+				.unwrap();
+		let fork_hash_3 = insert_block(
+			&backend,
+			3,
+			fork_hash_root,
+			None,
+			H256::random(),
+			vec![3.into(), 11.into()],
+			None,
+		)
+		.unwrap();
+
+		// Do not prune the fork hash.
+		backend.pin_block(fork_hash_3).unwrap();
+
+		let mut op = backend.begin_operation().unwrap();
+		backend.begin_state_operation(&mut op, blocks[4]).unwrap();
+		op.mark_head(blocks[4]).unwrap();
+		backend.commit_operation(op).unwrap();
+
+		for i in 1..5 {
+			let mut op = backend.begin_operation().unwrap();
+			backend.begin_state_operation(&mut op, blocks[4]).unwrap();
+			op.mark_finalized(blocks[i], None).unwrap();
+			backend.commit_operation(op).unwrap();
+		}
+
+		let bc = backend.blockchain();
+		assert_eq!(Some(vec![0.into()]), bc.body(blocks[0]).unwrap());
+		assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
+		assert_eq!(Some(vec![2.into()]), bc.body(blocks[2]).unwrap());
+		assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
+		assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
+		// Check the fork hashes.
+		assert_eq!(None, bc.body(fork_hash_root).unwrap());
+		assert_eq!(Some(vec![3.into(), 11.into()]), bc.body(fork_hash_3).unwrap());
+
+		// Unpin all blocks, except the forked one.
+		for block in &blocks {
+			backend.unpin_block(*block);
+		}
+		assert!(bc.body(blocks[0]).unwrap().is_none());
+		assert!(bc.body(blocks[1]).unwrap().is_none());
+		assert!(bc.body(blocks[2]).unwrap().is_none());
+		assert!(bc.body(blocks[3]).unwrap().is_none());
+
+		assert!(bc.body(fork_hash_3).unwrap().is_some());
+		backend.unpin_block(fork_hash_3);
+		assert!(bc.body(fork_hash_3).unwrap().is_none());
+	}
+}
diff --git a/substrate/client/db/src/offchain.rs b/substrate/client/db/src/offchain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dc7202ff6d290506eb0031d19119512ad04ef74f
--- /dev/null
+++ b/substrate/client/db/src/offchain.rs
@@ -0,0 +1,150 @@
+// 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/>.
+
+//! RocksDB-based offchain workers local storage.
+
+use std::{collections::HashMap, sync::Arc};
+
+use crate::{columns, Database, DbHash, Transaction};
+use log::error;
+use parking_lot::Mutex;
+
+/// Offchain local storage
+#[derive(Clone)]
+pub struct LocalStorage {
+	db: Arc<dyn Database<DbHash>>,
+	locks: Arc<Mutex<HashMap<Vec<u8>, Arc<Mutex<()>>>>>,
+}
+
+impl std::fmt::Debug for LocalStorage {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.debug_struct("LocalStorage").finish()
+	}
+}
+
+impl LocalStorage {
+	/// Create new offchain storage for tests (backed by memorydb)
+	#[cfg(any(feature = "test-helpers", test))]
+	pub fn new_test() -> Self {
+		let db = kvdb_memorydb::create(crate::utils::NUM_COLUMNS);
+		let db = sp_database::as_database(db);
+		Self::new(db as _)
+	}
+
+	/// Create offchain local storage with given `KeyValueDB` backend.
+	pub fn new(db: Arc<dyn Database<DbHash>>) -> Self {
+		Self { db, locks: Default::default() }
+	}
+}
+
+impl sp_core::offchain::OffchainStorage for LocalStorage {
+	fn set(&mut self, prefix: &[u8], key: &[u8], value: &[u8]) {
+		let mut tx = Transaction::new();
+		tx.set(columns::OFFCHAIN, &concatenate_prefix_and_key(prefix, key), value);
+
+		if let Err(err) = self.db.commit(tx) {
+			error!("Error setting on local storage: {}", err)
+		}
+	}
+
+	fn remove(&mut self, prefix: &[u8], key: &[u8]) {
+		let mut tx = Transaction::new();
+		tx.remove(columns::OFFCHAIN, &concatenate_prefix_and_key(prefix, key));
+
+		if let Err(err) = self.db.commit(tx) {
+			error!("Error removing on local storage: {}", err)
+		}
+	}
+
+	fn get(&self, prefix: &[u8], key: &[u8]) -> Option<Vec<u8>> {
+		self.db.get(columns::OFFCHAIN, &concatenate_prefix_and_key(prefix, key))
+	}
+
+	fn compare_and_set(
+		&mut self,
+		prefix: &[u8],
+		item_key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool {
+		let key = concatenate_prefix_and_key(prefix, item_key);
+		let key_lock = {
+			let mut locks = self.locks.lock();
+			locks.entry(key.clone()).or_default().clone()
+		};
+
+		let is_set;
+		{
+			let _key_guard = key_lock.lock();
+			let val = self.db.get(columns::OFFCHAIN, &key);
+			is_set = val.as_deref() == old_value;
+
+			if is_set {
+				self.set(prefix, item_key, new_value)
+			}
+		}
+
+		// clean the lock map if we're the only entry
+		let mut locks = self.locks.lock();
+		{
+			drop(key_lock);
+			let key_lock = locks.get_mut(&key);
+			if key_lock.and_then(Arc::get_mut).is_some() {
+				locks.remove(&key);
+			}
+		}
+		is_set
+	}
+}
+
+/// Concatenate the prefix and key to create an offchain key in the db.
+pub(crate) fn concatenate_prefix_and_key(prefix: &[u8], key: &[u8]) -> Vec<u8> {
+	prefix.iter().chain(key.iter()).cloned().collect()
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::offchain::OffchainStorage;
+
+	#[test]
+	fn should_compare_and_set_and_clear_the_locks_map() {
+		let mut storage = LocalStorage::new_test();
+		let prefix = b"prefix";
+		let key = b"key";
+		let value = b"value";
+
+		storage.set(prefix, key, value);
+		assert_eq!(storage.get(prefix, key), Some(value.to_vec()));
+
+		assert_eq!(storage.compare_and_set(prefix, key, Some(value), b"asd"), true);
+		assert_eq!(storage.get(prefix, key), Some(b"asd".to_vec()));
+		assert!(storage.locks.lock().is_empty(), "Locks map should be empty!");
+	}
+
+	#[test]
+	fn should_compare_and_set_on_empty_field() {
+		let mut storage = LocalStorage::new_test();
+		let prefix = b"prefix";
+		let key = b"key";
+
+		assert_eq!(storage.compare_and_set(prefix, key, None, b"asd"), true);
+		assert_eq!(storage.get(prefix, key), Some(b"asd".to_vec()));
+		assert!(storage.locks.lock().is_empty(), "Locks map should be empty!");
+	}
+}
diff --git a/substrate/client/db/src/parity_db.rs b/substrate/client/db/src/parity_db.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b7068f2430ef73c34134ecd5cebfac0a8a57a034
--- /dev/null
+++ b/substrate/client/db/src/parity_db.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::{
+	columns,
+	utils::{DatabaseType, NUM_COLUMNS},
+};
+/// A `Database` adapter for parity-db.
+use sp_database::{error::DatabaseError, Change, ColumnId, Database, Transaction};
+
+struct DbAdapter(parity_db::Db);
+
+fn handle_err<T>(result: parity_db::Result<T>) -> T {
+	match result {
+		Ok(r) => r,
+		Err(e) => {
+			panic!("Critical database error: {:?}", e);
+		},
+	}
+}
+
+/// Wrap parity-db database into a trait object that implements `sp_database::Database`
+pub fn open<H: Clone + AsRef<[u8]>>(
+	path: &std::path::Path,
+	db_type: DatabaseType,
+	create: bool,
+	upgrade: bool,
+) -> parity_db::Result<std::sync::Arc<dyn Database<H>>> {
+	let mut config = parity_db::Options::with_columns(path, NUM_COLUMNS as u8);
+
+	match db_type {
+		DatabaseType::Full => {
+			let compressed = [
+				columns::STATE,
+				columns::HEADER,
+				columns::BODY,
+				columns::BODY_INDEX,
+				columns::TRANSACTION,
+				columns::JUSTIFICATIONS,
+			];
+
+			for i in compressed {
+				let column = &mut config.columns[i as usize];
+				column.compression = parity_db::CompressionType::Lz4;
+			}
+
+			let state_col = &mut config.columns[columns::STATE as usize];
+			state_col.ref_counted = true;
+			state_col.preimage = true;
+			state_col.uniform = true;
+
+			let tx_col = &mut config.columns[columns::TRANSACTION as usize];
+			tx_col.ref_counted = true;
+			tx_col.preimage = true;
+			tx_col.uniform = true;
+		},
+	}
+
+	if upgrade {
+		log::info!("Upgrading database metadata.");
+		if let Some(meta) = parity_db::Options::load_metadata(path)? {
+			config.write_metadata_with_version(path, &meta.salt, Some(meta.version))?;
+		}
+	}
+
+	let db = if create {
+		parity_db::Db::open_or_create(&config)?
+	} else {
+		parity_db::Db::open(&config)?
+	};
+
+	Ok(std::sync::Arc::new(DbAdapter(db)))
+}
+
+fn ref_counted_column(col: u32) -> bool {
+	col == columns::TRANSACTION || col == columns::STATE
+}
+
+impl<H: Clone + AsRef<[u8]>> Database<H> for DbAdapter {
+	fn commit(&self, transaction: Transaction<H>) -> Result<(), DatabaseError> {
+		let mut not_ref_counted_column = Vec::new();
+		let result = self.0.commit(transaction.0.into_iter().filter_map(|change| {
+			Some(match change {
+				Change::Set(col, key, value) => (col as u8, key, Some(value)),
+				Change::Remove(col, key) => (col as u8, key, None),
+				Change::Store(col, key, value) =>
+					if ref_counted_column(col) {
+						(col as u8, key.as_ref().to_vec(), Some(value))
+					} else {
+						if !not_ref_counted_column.contains(&col) {
+							not_ref_counted_column.push(col);
+						}
+						return None
+					},
+				Change::Reference(col, key) => {
+					if ref_counted_column(col) {
+						// FIXME accessing value is not strictly needed, optimize this in parity-db.
+						let value = <Self as Database<H>>::get(self, col, key.as_ref());
+						(col as u8, key.as_ref().to_vec(), value)
+					} else {
+						if !not_ref_counted_column.contains(&col) {
+							not_ref_counted_column.push(col);
+						}
+						return None
+					}
+				},
+				Change::Release(col, key) =>
+					if ref_counted_column(col) {
+						(col as u8, key.as_ref().to_vec(), None)
+					} else {
+						if !not_ref_counted_column.contains(&col) {
+							not_ref_counted_column.push(col);
+						}
+						return None
+					},
+			})
+		}));
+
+		if not_ref_counted_column.len() > 0 {
+			return Err(DatabaseError(Box::new(parity_db::Error::InvalidInput(format!(
+				"Ref counted operation on non ref counted columns {:?}",
+				not_ref_counted_column
+			)))))
+		}
+
+		result.map_err(|e| DatabaseError(Box::new(e)))
+	}
+
+	fn get(&self, col: ColumnId, key: &[u8]) -> Option<Vec<u8>> {
+		handle_err(self.0.get(col as u8, key))
+	}
+
+	fn contains(&self, col: ColumnId, key: &[u8]) -> bool {
+		handle_err(self.0.get_size(col as u8, key)).is_some()
+	}
+
+	fn value_size(&self, col: ColumnId, key: &[u8]) -> Option<usize> {
+		handle_err(self.0.get_size(col as u8, key)).map(|s| s as usize)
+	}
+
+	fn supports_ref_counting(&self) -> bool {
+		true
+	}
+
+	fn sanitize_key(&self, key: &mut Vec<u8>) {
+		let _prefix = key.drain(0..key.len() - crate::DB_HASH_LEN);
+	}
+}
diff --git a/substrate/client/db/src/pinned_blocks_cache.rs b/substrate/client/db/src/pinned_blocks_cache.rs
new file mode 100644
index 0000000000000000000000000000000000000000..46c9287fb19ac1361153dbb65f4f0b353170042f
--- /dev/null
+++ b/substrate/client/db/src/pinned_blocks_cache.rs
@@ -0,0 +1,232 @@
+// 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 schnellru::{Limiter, LruMap};
+use sp_runtime::{traits::Block as BlockT, Justifications};
+
+const LOG_TARGET: &str = "db::pin";
+const PINNING_CACHE_SIZE: usize = 1024;
+
+/// Entry for pinned blocks cache.
+struct PinnedBlockCacheEntry<Block: BlockT> {
+	/// How many times this item has been pinned
+	ref_count: u32,
+
+	/// Cached justifications for this block
+	pub justifications: Option<Option<Justifications>>,
+
+	/// Cached body for this block
+	pub body: Option<Option<Vec<Block::Extrinsic>>>,
+}
+
+impl<Block: BlockT> Default for PinnedBlockCacheEntry<Block> {
+	fn default() -> Self {
+		Self { ref_count: 0, justifications: None, body: None }
+	}
+}
+
+impl<Block: BlockT> PinnedBlockCacheEntry<Block> {
+	pub fn decrease_ref(&mut self) {
+		self.ref_count = self.ref_count.saturating_sub(1);
+	}
+
+	pub fn increase_ref(&mut self) {
+		self.ref_count = self.ref_count.saturating_add(1);
+	}
+
+	pub fn has_no_references(&self) -> bool {
+		self.ref_count == 0
+	}
+}
+
+/// A limiter for a map which is limited by the number of elements.
+#[derive(Copy, Clone, Debug)]
+struct LoggingByLengthLimiter {
+	max_length: usize,
+}
+
+impl LoggingByLengthLimiter {
+	/// Creates a new length limiter with a given `max_length`.
+	pub const fn new(max_length: usize) -> LoggingByLengthLimiter {
+		LoggingByLengthLimiter { max_length }
+	}
+}
+
+impl<Block: BlockT> Limiter<Block::Hash, PinnedBlockCacheEntry<Block>> for LoggingByLengthLimiter {
+	type KeyToInsert<'a> = Block::Hash;
+	type LinkType = usize;
+
+	fn is_over_the_limit(&self, length: usize) -> bool {
+		length > self.max_length
+	}
+
+	fn on_insert(
+		&mut self,
+		_length: usize,
+		key: Self::KeyToInsert<'_>,
+		value: PinnedBlockCacheEntry<Block>,
+	) -> Option<(Block::Hash, PinnedBlockCacheEntry<Block>)> {
+		if self.max_length > 0 {
+			Some((key, value))
+		} else {
+			None
+		}
+	}
+
+	fn on_replace(
+		&mut self,
+		_length: usize,
+		_old_key: &mut Block::Hash,
+		_new_key: Block::Hash,
+		_old_value: &mut PinnedBlockCacheEntry<Block>,
+		_new_value: &mut PinnedBlockCacheEntry<Block>,
+	) -> bool {
+		true
+	}
+
+	fn on_removed(&mut self, key: &mut Block::Hash, value: &mut PinnedBlockCacheEntry<Block>) {
+		// If reference count was larger than 0 on removal,
+		// the item was removed due to capacity limitations.
+		// Since the cache should be large enough for pinned items,
+		// we want to know about these evictions.
+		if value.ref_count > 0 {
+			log::warn!(
+				target: LOG_TARGET,
+				"Pinned block cache limit reached. Evicting value. hash = {}",
+				key
+			);
+		} else {
+			log::trace!(
+				target: LOG_TARGET,
+				"Evicting value from pinned block cache. hash = {}",
+				key
+			)
+		}
+	}
+
+	fn on_cleared(&mut self) {}
+
+	fn on_grow(&mut self, _new_memory_usage: usize) -> bool {
+		true
+	}
+}
+
+/// Reference counted cache for pinned block bodies and justifications.
+pub struct PinnedBlocksCache<Block: BlockT> {
+	cache: LruMap<Block::Hash, PinnedBlockCacheEntry<Block>, LoggingByLengthLimiter>,
+}
+
+impl<Block: BlockT> PinnedBlocksCache<Block> {
+	pub fn new() -> Self {
+		Self { cache: LruMap::new(LoggingByLengthLimiter::new(PINNING_CACHE_SIZE)) }
+	}
+
+	/// Increase reference count of an item.
+	/// Create an entry with empty value in the cache if necessary.
+	pub fn pin(&mut self, hash: Block::Hash) {
+		match self.cache.get_or_insert(hash, Default::default) {
+			Some(entry) => {
+				entry.increase_ref();
+				log::trace!(
+					target: LOG_TARGET,
+					"Bumped cache refcount. hash = {}, num_entries = {}",
+					hash,
+					self.cache.len()
+				);
+			},
+			None => {
+				log::warn!(target: LOG_TARGET, "Unable to bump reference count. hash = {}", hash)
+			},
+		};
+	}
+
+	/// Clear the cache
+	pub fn clear(&mut self) {
+		self.cache.clear();
+	}
+
+	/// Check if item is contained in the cache
+	pub fn contains(&self, hash: Block::Hash) -> bool {
+		self.cache.peek(&hash).is_some()
+	}
+
+	/// Attach body to an existing cache item
+	pub fn insert_body(&mut self, hash: Block::Hash, extrinsics: Option<Vec<Block::Extrinsic>>) {
+		match self.cache.peek_mut(&hash) {
+			Some(entry) => {
+				entry.body = Some(extrinsics);
+				log::trace!(
+					target: LOG_TARGET,
+					"Cached body. hash = {}, num_entries = {}",
+					hash,
+					self.cache.len()
+				);
+			},
+			None => log::warn!(
+				target: LOG_TARGET,
+				"Unable to insert body for uncached item. hash = {}",
+				hash
+			),
+		}
+	}
+
+	/// Attach justification to an existing cache item
+	pub fn insert_justifications(
+		&mut self,
+		hash: Block::Hash,
+		justifications: Option<Justifications>,
+	) {
+		match self.cache.peek_mut(&hash) {
+			Some(entry) => {
+				entry.justifications = Some(justifications);
+				log::trace!(
+					target: LOG_TARGET,
+					"Cached justification. hash = {}, num_entries = {}",
+					hash,
+					self.cache.len()
+				);
+			},
+			None => log::warn!(
+				target: LOG_TARGET,
+				"Unable to insert justifications for uncached item. hash = {}",
+				hash
+			),
+		}
+	}
+
+	/// Decreases reference count of an item.
+	/// If the count hits 0, the item is removed.
+	pub fn unpin(&mut self, hash: Block::Hash) {
+		if let Some(entry) = self.cache.peek_mut(&hash) {
+			entry.decrease_ref();
+			if entry.has_no_references() {
+				self.cache.remove(&hash);
+			}
+		}
+	}
+
+	/// Get justifications for cached block
+	pub fn justifications(&self, hash: &Block::Hash) -> Option<&Option<Justifications>> {
+		self.cache.peek(hash).and_then(|entry| entry.justifications.as_ref())
+	}
+
+	/// Get body for cached block
+	pub fn body(&self, hash: &Block::Hash) -> Option<&Option<Vec<Block::Extrinsic>>> {
+		self.cache.peek(hash).and_then(|entry| entry.body.as_ref())
+	}
+}
diff --git a/substrate/client/db/src/record_stats_state.rs b/substrate/client/db/src/record_stats_state.rs
new file mode 100644
index 0000000000000000000000000000000000000000..29ece84f97e5744c7fb0902d5f5fc98ba0eb7ced
--- /dev/null
+++ b/substrate/client/db/src/record_stats_state.rs
@@ -0,0 +1,211 @@
+// 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/>.
+
+//! Provides [`RecordStatsState`] for recording stats about state access.
+
+use crate::stats::StateUsageStats;
+use sp_core::storage::ChildInfo;
+use sp_runtime::{
+	traits::{Block as BlockT, HashingFor},
+	StateVersion,
+};
+use sp_state_machine::{
+	backend::{AsTrieBackend, Backend as StateBackend},
+	BackendTransaction, IterArgs, StorageIterator, StorageKey, StorageValue, TrieBackend,
+};
+use std::sync::Arc;
+
+/// State abstraction for recording stats about state access.
+pub struct RecordStatsState<S, B: BlockT> {
+	/// Usage statistics
+	usage: StateUsageStats,
+	/// State machine registered stats
+	overlay_stats: sp_state_machine::StateMachineStats,
+	/// Backing state.
+	state: S,
+	/// The hash of the block is state belongs to.
+	block_hash: Option<B::Hash>,
+	/// The usage statistics of the backend. These will be updated on drop.
+	state_usage: Arc<StateUsageStats>,
+}
+
+impl<S, B: BlockT> std::fmt::Debug for RecordStatsState<S, B> {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "Block {:?}", self.block_hash)
+	}
+}
+
+impl<S, B: BlockT> Drop for RecordStatsState<S, B> {
+	fn drop(&mut self) {
+		self.state_usage.merge_sm(self.usage.take());
+	}
+}
+
+impl<S: StateBackend<HashingFor<B>>, B: BlockT> RecordStatsState<S, B> {
+	/// Create a new instance wrapping generic State and shared cache.
+	pub(crate) fn new(
+		state: S,
+		block_hash: Option<B::Hash>,
+		state_usage: Arc<StateUsageStats>,
+	) -> Self {
+		RecordStatsState {
+			usage: StateUsageStats::new(),
+			overlay_stats: sp_state_machine::StateMachineStats::default(),
+			state,
+			block_hash,
+			state_usage,
+		}
+	}
+}
+
+pub struct RawIter<S, B>
+where
+	S: StateBackend<HashingFor<B>>,
+	B: BlockT,
+{
+	inner: <S as StateBackend<HashingFor<B>>>::RawIter,
+}
+
+impl<S, B> StorageIterator<HashingFor<B>> for RawIter<S, B>
+where
+	S: StateBackend<HashingFor<B>>,
+	B: BlockT,
+{
+	type Backend = RecordStatsState<S, B>;
+	type Error = S::Error;
+
+	fn next_key(&mut self, backend: &Self::Backend) -> Option<Result<StorageKey, Self::Error>> {
+		self.inner.next_key(&backend.state)
+	}
+
+	fn next_pair(
+		&mut self,
+		backend: &Self::Backend,
+	) -> Option<Result<(StorageKey, StorageValue), Self::Error>> {
+		self.inner.next_pair(&backend.state)
+	}
+
+	fn was_complete(&self) -> bool {
+		self.inner.was_complete()
+	}
+}
+
+impl<S: StateBackend<HashingFor<B>>, B: BlockT> StateBackend<HashingFor<B>>
+	for RecordStatsState<S, B>
+{
+	type Error = S::Error;
+	type TrieBackendStorage = S::TrieBackendStorage;
+	type RawIter = RawIter<S, B>;
+
+	fn storage(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		let value = self.state.storage(key)?;
+		self.usage.tally_key_read(key, value.as_ref(), false);
+		Ok(value)
+	}
+
+	fn storage_hash(&self, key: &[u8]) -> Result<Option<B::Hash>, Self::Error> {
+		self.state.storage_hash(key)
+	}
+
+	fn child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Self::Error> {
+		let key = (child_info.storage_key().to_vec(), key.to_vec());
+		let value = self.state.child_storage(child_info, &key.1)?;
+
+		// just pass it through the usage counter
+		let value = self.usage.tally_child_key_read(&key, value, false);
+
+		Ok(value)
+	}
+
+	fn child_storage_hash(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<B::Hash>, Self::Error> {
+		self.state.child_storage_hash(child_info, key)
+	}
+
+	fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> {
+		self.state.exists_storage(key)
+	}
+
+	fn exists_child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<bool, Self::Error> {
+		self.state.exists_child_storage(child_info, key)
+	}
+
+	fn next_storage_key(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.state.next_storage_key(key)
+	}
+
+	fn next_child_storage_key(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Self::Error> {
+		self.state.next_child_storage_key(child_info, key)
+	}
+
+	fn storage_root<'a>(
+		&self,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (B::Hash, BackendTransaction<HashingFor<B>>) {
+		self.state.storage_root(delta, state_version)
+	}
+
+	fn child_storage_root<'a>(
+		&self,
+		child_info: &ChildInfo,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (B::Hash, bool, BackendTransaction<HashingFor<B>>) {
+		self.state.child_storage_root(child_info, delta, state_version)
+	}
+
+	fn raw_iter(&self, args: IterArgs) -> Result<Self::RawIter, Self::Error> {
+		self.state.raw_iter(args).map(|inner| RawIter { inner })
+	}
+
+	fn register_overlay_stats(&self, stats: &sp_state_machine::StateMachineStats) {
+		self.overlay_stats.add(stats);
+	}
+
+	fn usage_info(&self) -> sp_state_machine::UsageInfo {
+		let mut info = self.usage.take();
+		info.include_state_machine_states(&self.overlay_stats);
+		info
+	}
+}
+
+impl<S: StateBackend<HashingFor<B>> + AsTrieBackend<HashingFor<B>>, B: BlockT>
+	AsTrieBackend<HashingFor<B>> for RecordStatsState<S, B>
+{
+	type TrieBackendStorage = <S as AsTrieBackend<HashingFor<B>>>::TrieBackendStorage;
+
+	fn as_trie_backend(&self) -> &TrieBackend<Self::TrieBackendStorage, HashingFor<B>> {
+		self.state.as_trie_backend()
+	}
+}
diff --git a/substrate/client/db/src/stats.rs b/substrate/client/db/src/stats.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1609ef9d5dad891d6409cd1880908f66fdd9feb6
--- /dev/null
+++ b/substrate/client/db/src/stats.rs
@@ -0,0 +1,145 @@
+// 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/>.
+
+//! Database usage statistics
+
+use std::sync::atomic::{AtomicU64, Ordering as AtomicOrdering};
+
+/// Accumulated usage statistics for state queries.
+pub struct StateUsageStats {
+	started: std::time::Instant,
+	reads: AtomicU64,
+	bytes_read: AtomicU64,
+	writes: AtomicU64,
+	bytes_written: AtomicU64,
+	writes_nodes: AtomicU64,
+	bytes_written_nodes: AtomicU64,
+	removed_nodes: AtomicU64,
+	bytes_removed_nodes: AtomicU64,
+	reads_cache: AtomicU64,
+	bytes_read_cache: AtomicU64,
+}
+
+impl StateUsageStats {
+	/// New empty usage stats.
+	pub fn new() -> Self {
+		Self {
+			started: std::time::Instant::now(),
+			reads: 0.into(),
+			bytes_read: 0.into(),
+			writes: 0.into(),
+			bytes_written: 0.into(),
+			writes_nodes: 0.into(),
+			bytes_written_nodes: 0.into(),
+			removed_nodes: 0.into(),
+			bytes_removed_nodes: 0.into(),
+			reads_cache: 0.into(),
+			bytes_read_cache: 0.into(),
+		}
+	}
+
+	/// Tally one read operation, of some length.
+	pub fn tally_read(&self, data_bytes: u64, cache: bool) {
+		self.reads.fetch_add(1, AtomicOrdering::Relaxed);
+		self.bytes_read.fetch_add(data_bytes, AtomicOrdering::Relaxed);
+		if cache {
+			self.reads_cache.fetch_add(1, AtomicOrdering::Relaxed);
+			self.bytes_read_cache.fetch_add(data_bytes, AtomicOrdering::Relaxed);
+		}
+	}
+
+	/// Tally one key read.
+	pub fn tally_key_read(&self, key: &[u8], val: Option<&Vec<u8>>, cache: bool) {
+		self.tally_read(
+			key.len() as u64 + val.as_ref().map(|x| x.len() as u64).unwrap_or(0),
+			cache,
+		);
+	}
+
+	/// Tally one child key read.
+	pub fn tally_child_key_read(
+		&self,
+		key: &(Vec<u8>, Vec<u8>),
+		val: Option<Vec<u8>>,
+		cache: bool,
+	) -> Option<Vec<u8>> {
+		let bytes = key.0.len() + key.1.len() + val.as_ref().map(|x| x.len()).unwrap_or(0);
+		self.tally_read(bytes as u64, cache);
+		val
+	}
+
+	/// Tally some write trie nodes operations, including their byte count.
+	pub fn tally_writes_nodes(&self, ops: u64, data_bytes: u64) {
+		self.writes_nodes.fetch_add(ops, AtomicOrdering::Relaxed);
+		self.bytes_written_nodes.fetch_add(data_bytes, AtomicOrdering::Relaxed);
+	}
+
+	/// Tally some removed trie nodes operations, including their byte count.
+	pub fn tally_removed_nodes(&self, ops: u64, data_bytes: u64) {
+		self.removed_nodes.fetch_add(ops, AtomicOrdering::Relaxed);
+		self.bytes_removed_nodes.fetch_add(data_bytes, AtomicOrdering::Relaxed);
+	}
+
+	/// Tally some write trie nodes operations, including their byte count.
+	pub fn tally_writes(&self, ops: u64, data_bytes: u64) {
+		self.writes.fetch_add(ops, AtomicOrdering::Relaxed);
+		self.bytes_written.fetch_add(data_bytes, AtomicOrdering::Relaxed);
+	}
+
+	/// Merge state machine usage info.
+	pub fn merge_sm(&self, info: sp_state_machine::UsageInfo) {
+		self.reads.fetch_add(info.reads.ops, AtomicOrdering::Relaxed);
+		self.bytes_read.fetch_add(info.reads.bytes, AtomicOrdering::Relaxed);
+		self.writes_nodes.fetch_add(info.nodes_writes.ops, AtomicOrdering::Relaxed);
+		self.bytes_written_nodes
+			.fetch_add(info.nodes_writes.bytes, AtomicOrdering::Relaxed);
+		self.removed_nodes.fetch_add(info.removed_nodes.ops, AtomicOrdering::Relaxed);
+		self.bytes_removed_nodes
+			.fetch_add(info.removed_nodes.bytes, AtomicOrdering::Relaxed);
+		self.reads_cache.fetch_add(info.cache_reads.ops, AtomicOrdering::Relaxed);
+		self.bytes_read_cache.fetch_add(info.cache_reads.bytes, AtomicOrdering::Relaxed);
+	}
+
+	/// Returns the collected `UsageInfo` and resets the internal state.
+	pub fn take(&self) -> sp_state_machine::UsageInfo {
+		use sp_state_machine::UsageUnit;
+
+		fn unit(ops: &AtomicU64, bytes: &AtomicU64) -> UsageUnit {
+			UsageUnit {
+				ops: ops.swap(0, AtomicOrdering::Relaxed),
+				bytes: bytes.swap(0, AtomicOrdering::Relaxed),
+			}
+		}
+
+		sp_state_machine::UsageInfo {
+			reads: unit(&self.reads, &self.bytes_read),
+			writes: unit(&self.writes, &self.bytes_written),
+			nodes_writes: unit(&self.writes_nodes, &self.bytes_written_nodes),
+			removed_nodes: unit(&self.removed_nodes, &self.bytes_removed_nodes),
+			cache_reads: unit(&self.reads_cache, &self.bytes_read_cache),
+			modified_reads: Default::default(),
+			overlay_writes: Default::default(),
+			// TODO: Proper tracking state of memory footprint here requires
+			//       imposing `MallocSizeOf` requirement on half of the codebase,
+			//       so it is an open question how to do it better
+			memory: 0,
+			started: self.started,
+			span: self.started.elapsed(),
+		}
+	}
+}
diff --git a/substrate/client/db/src/upgrade.rs b/substrate/client/db/src/upgrade.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f1e503867dfc3e4a9ad3ddd5135f5d426e9c221c
--- /dev/null
+++ b/substrate/client/db/src/upgrade.rs
@@ -0,0 +1,256 @@
+// 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/>.
+
+//! Database upgrade logic.
+
+use std::{
+	fmt, fs,
+	io::{self, ErrorKind, Read, Write},
+	path::{Path, PathBuf},
+};
+
+use crate::{columns, utils::DatabaseType};
+use codec::{Decode, Encode};
+use kvdb_rocksdb::{Database, DatabaseConfig};
+use sp_runtime::traits::Block as BlockT;
+
+/// Version file name.
+const VERSION_FILE_NAME: &str = "db_version";
+
+/// Current db version.
+const CURRENT_VERSION: u32 = 4;
+
+/// Number of columns in v1.
+const V1_NUM_COLUMNS: u32 = 11;
+const V2_NUM_COLUMNS: u32 = 12;
+const V3_NUM_COLUMNS: u32 = 12;
+
+/// Database upgrade errors.
+#[derive(Debug)]
+pub enum UpgradeError {
+	/// Database version cannot be read from existing db_version file.
+	UnknownDatabaseVersion,
+	/// Missing database version file.
+	MissingDatabaseVersionFile,
+	/// Database version no longer supported.
+	UnsupportedVersion(u32),
+	/// Database version comes from future version of the client.
+	FutureDatabaseVersion(u32),
+	/// Invalid justification block.
+	DecodingJustificationBlock,
+	/// Common io error.
+	Io(io::Error),
+}
+
+pub type UpgradeResult<T> = Result<T, UpgradeError>;
+
+impl From<io::Error> for UpgradeError {
+	fn from(err: io::Error) -> Self {
+		UpgradeError::Io(err)
+	}
+}
+
+impl fmt::Display for UpgradeError {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			UpgradeError::UnknownDatabaseVersion => {
+				write!(f, "Database version cannot be read from existing db_version file")
+			},
+			UpgradeError::MissingDatabaseVersionFile => write!(f, "Missing database version file"),
+			UpgradeError::UnsupportedVersion(version) => {
+				write!(f, "Database version no longer supported: {}", version)
+			},
+			UpgradeError::FutureDatabaseVersion(version) => {
+				write!(f, "Database version comes from future version of the client: {}", version)
+			},
+			UpgradeError::DecodingJustificationBlock => {
+				write!(f, "Decodoning justification block failed")
+			},
+			UpgradeError::Io(err) => write!(f, "Io error: {}", err),
+		}
+	}
+}
+
+/// Upgrade database to current version.
+pub fn upgrade_db<Block: BlockT>(db_path: &Path, db_type: DatabaseType) -> UpgradeResult<()> {
+	let db_version = current_version(db_path)?;
+	match db_version {
+		0 => return Err(UpgradeError::UnsupportedVersion(db_version)),
+		1 => {
+			migrate_1_to_2::<Block>(db_path, db_type)?;
+			migrate_2_to_3::<Block>(db_path, db_type)?;
+			migrate_3_to_4::<Block>(db_path, db_type)?;
+		},
+		2 => {
+			migrate_2_to_3::<Block>(db_path, db_type)?;
+			migrate_3_to_4::<Block>(db_path, db_type)?;
+		},
+		3 => {
+			migrate_3_to_4::<Block>(db_path, db_type)?;
+		},
+		CURRENT_VERSION => (),
+		_ => return Err(UpgradeError::FutureDatabaseVersion(db_version)),
+	}
+	update_version(db_path)?;
+	Ok(())
+}
+
+/// Migration from version1 to version2:
+/// 1) the number of columns has changed from 11 to 12;
+/// 2) transactions column is added;
+fn migrate_1_to_2<Block: BlockT>(db_path: &Path, _db_type: DatabaseType) -> UpgradeResult<()> {
+	let db_cfg = DatabaseConfig::with_columns(V1_NUM_COLUMNS);
+	let mut db = Database::open(&db_cfg, db_path)?;
+	db.add_column().map_err(Into::into)
+}
+
+/// Migration from version2 to version3:
+/// - The format of the stored Justification changed to support multiple Justifications.
+fn migrate_2_to_3<Block: BlockT>(db_path: &Path, _db_type: DatabaseType) -> UpgradeResult<()> {
+	let db_cfg = DatabaseConfig::with_columns(V2_NUM_COLUMNS);
+	let db = Database::open(&db_cfg, db_path)?;
+
+	// Get all the keys we need to update
+	let keys: Vec<_> = db
+		.iter(columns::JUSTIFICATIONS)
+		.map(|r| r.map(|e| e.0))
+		.collect::<Result<_, _>>()?;
+
+	// Read and update each entry
+	let mut transaction = db.transaction();
+	for key in keys {
+		if let Some(justification) = db.get(columns::JUSTIFICATIONS, &key)? {
+			// Tag each justification with the hardcoded ID for GRANDPA to avoid the dependency on
+			// the GRANDPA crate.
+			// NOTE: when storing justifications the previous API would get a `Vec<u8>` and still
+			// call encode on it.
+			let justification = Vec::<u8>::decode(&mut &justification[..])
+				.map_err(|_| UpgradeError::DecodingJustificationBlock)?;
+			let justifications = sp_runtime::Justifications::from((*b"FRNK", justification));
+			transaction.put_vec(columns::JUSTIFICATIONS, &key, justifications.encode());
+		}
+	}
+	db.write(transaction)?;
+
+	Ok(())
+}
+
+/// Migration from version3 to version4:
+/// 1) the number of columns has changed from 12 to 13;
+/// 2) BODY_INDEX column is added;
+fn migrate_3_to_4<Block: BlockT>(db_path: &Path, _db_type: DatabaseType) -> UpgradeResult<()> {
+	let db_cfg = DatabaseConfig::with_columns(V3_NUM_COLUMNS);
+	let mut db = Database::open(&db_cfg, db_path)?;
+	db.add_column().map_err(Into::into)
+}
+
+/// Reads current database version from the file at given path.
+/// If the file does not exist returns 0.
+fn current_version(path: &Path) -> UpgradeResult<u32> {
+	match fs::File::open(version_file_path(path)) {
+		Err(ref err) if err.kind() == ErrorKind::NotFound =>
+			Err(UpgradeError::MissingDatabaseVersionFile),
+		Err(_) => Err(UpgradeError::UnknownDatabaseVersion),
+		Ok(mut file) => {
+			let mut s = String::new();
+			file.read_to_string(&mut s).map_err(|_| UpgradeError::UnknownDatabaseVersion)?;
+			u32::from_str_radix(&s, 10).map_err(|_| UpgradeError::UnknownDatabaseVersion)
+		},
+	}
+}
+
+/// Writes current database version to the file.
+/// Creates a new file if the version file does not exist yet.
+pub fn update_version(path: &Path) -> io::Result<()> {
+	fs::create_dir_all(path)?;
+	let mut file = fs::File::create(version_file_path(path))?;
+	file.write_all(format!("{}", CURRENT_VERSION).as_bytes())?;
+	Ok(())
+}
+
+/// Returns the version file path.
+fn version_file_path(path: &Path) -> PathBuf {
+	let mut file_path = path.to_owned();
+	file_path.push(VERSION_FILE_NAME);
+	file_path
+}
+
+#[cfg(all(test, feature = "rocksdb"))]
+mod tests {
+	use super::*;
+	use crate::{tests::Block, DatabaseSource};
+
+	fn create_db(db_path: &Path, version: Option<u32>) {
+		if let Some(version) = version {
+			fs::create_dir_all(db_path).unwrap();
+			let mut file = fs::File::create(version_file_path(db_path)).unwrap();
+			file.write_all(format!("{}", version).as_bytes()).unwrap();
+		}
+	}
+
+	fn open_database(db_path: &Path, db_type: DatabaseType) -> sp_blockchain::Result<()> {
+		crate::utils::open_database::<Block>(
+			&DatabaseSource::RocksDb { path: db_path.to_owned(), cache_size: 128 },
+			db_type,
+			true,
+		)
+		.map(|_| ())
+		.map_err(|e| sp_blockchain::Error::Backend(e.to_string()))
+	}
+
+	#[test]
+	fn downgrade_never_happens() {
+		let db_dir = tempfile::TempDir::new().unwrap();
+		create_db(db_dir.path(), Some(CURRENT_VERSION + 1));
+		assert!(open_database(db_dir.path(), DatabaseType::Full).is_err());
+	}
+
+	#[test]
+	fn open_empty_database_works() {
+		let db_type = DatabaseType::Full;
+		let db_dir = tempfile::TempDir::new().unwrap();
+		let db_dir = db_dir.path().join(db_type.as_str());
+		open_database(&db_dir, db_type).unwrap();
+		open_database(&db_dir, db_type).unwrap();
+		assert_eq!(current_version(&db_dir).unwrap(), CURRENT_VERSION);
+	}
+
+	#[test]
+	fn upgrade_to_3_works() {
+		let db_type = DatabaseType::Full;
+		for version_from_file in &[None, Some(1), Some(2)] {
+			let db_dir = tempfile::TempDir::new().unwrap();
+			let db_path = db_dir.path().join(db_type.as_str());
+			create_db(&db_path, *version_from_file);
+			open_database(&db_path, db_type).unwrap();
+			assert_eq!(current_version(&db_path).unwrap(), CURRENT_VERSION);
+		}
+	}
+
+	#[test]
+	fn upgrade_to_4_works() {
+		let db_type = DatabaseType::Full;
+		for version_from_file in &[None, Some(1), Some(2), Some(3)] {
+			let db_dir = tempfile::TempDir::new().unwrap();
+			let db_path = db_dir.path().join(db_type.as_str());
+			create_db(&db_path, *version_from_file);
+			open_database(&db_path, db_type).unwrap();
+			assert_eq!(current_version(&db_path).unwrap(), CURRENT_VERSION);
+		}
+	}
+}
diff --git a/substrate/client/db/src/utils.rs b/substrate/client/db/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..abf9c4629cee47e31d18a18c827212b48fe31511
--- /dev/null
+++ b/substrate/client/db/src/utils.rs
@@ -0,0 +1,827 @@
+// 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/>.
+
+//! Db-based backend utility structures and functions, used by both
+//! full and light storages.
+
+use std::{fmt, fs, io, path::Path, sync::Arc};
+
+use log::{debug, info};
+
+use crate::{Database, DatabaseSource, DbHash};
+use codec::Decode;
+use sp_database::Transaction;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT, UniqueSaturatedFrom, UniqueSaturatedInto, Zero},
+};
+use sp_trie::DBValue;
+
+/// Number of columns in the db. Must be the same for both full && light dbs.
+/// Otherwise RocksDb will fail to open database && check its type.
+pub const NUM_COLUMNS: u32 = 13;
+/// Meta column. The set of keys in the column is shared by full && light storages.
+pub const COLUMN_META: u32 = 0;
+
+/// Keys of entries in COLUMN_META.
+pub mod meta_keys {
+	/// Type of storage (full or light).
+	pub const TYPE: &[u8; 4] = b"type";
+	/// Best block key.
+	pub const BEST_BLOCK: &[u8; 4] = b"best";
+	/// Last finalized block key.
+	pub const FINALIZED_BLOCK: &[u8; 5] = b"final";
+	/// Last finalized state key.
+	pub const FINALIZED_STATE: &[u8; 6] = b"fstate";
+	/// Block gap.
+	pub const BLOCK_GAP: &[u8; 3] = b"gap";
+	/// Genesis block hash.
+	pub const GENESIS_HASH: &[u8; 3] = b"gen";
+	/// Leaves prefix list key.
+	pub const LEAF_PREFIX: &[u8; 4] = b"leaf";
+	/// Children prefix list key.
+	pub const CHILDREN_PREFIX: &[u8; 8] = b"children";
+}
+
+/// Database metadata.
+#[derive(Debug)]
+pub struct Meta<N, H> {
+	/// Hash of the best known block.
+	pub best_hash: H,
+	/// Number of the best known block.
+	pub best_number: N,
+	/// Hash of the best finalized block.
+	pub finalized_hash: H,
+	/// Number of the best finalized block.
+	pub finalized_number: N,
+	/// Hash of the genesis block.
+	pub genesis_hash: H,
+	/// Finalized state, if any
+	pub finalized_state: Option<(H, N)>,
+	/// Block gap, start and end inclusive, if any.
+	pub block_gap: Option<(N, N)>,
+}
+
+/// A block lookup key: used for canonical lookup from block number to hash
+pub type NumberIndexKey = [u8; 4];
+
+/// Database type.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum DatabaseType {
+	/// Full node database.
+	Full,
+}
+
+/// Convert block number into short lookup key (LE representation) for
+/// blocks that are in the canonical chain.
+///
+/// In the current database schema, this kind of key is only used for
+/// lookups into an index, NOT for storing header data or others.
+pub fn number_index_key<N: TryInto<u32>>(n: N) -> sp_blockchain::Result<NumberIndexKey> {
+	let n = n.try_into().map_err(|_| {
+		sp_blockchain::Error::Backend("Block number cannot be converted to u32".into())
+	})?;
+
+	Ok([(n >> 24) as u8, ((n >> 16) & 0xff) as u8, ((n >> 8) & 0xff) as u8, (n & 0xff) as u8])
+}
+
+/// Convert number and hash into long lookup key for blocks that are
+/// not in the canonical chain.
+pub fn number_and_hash_to_lookup_key<N, H>(number: N, hash: H) -> sp_blockchain::Result<Vec<u8>>
+where
+	N: TryInto<u32>,
+	H: AsRef<[u8]>,
+{
+	let mut lookup_key = number_index_key(number)?.to_vec();
+	lookup_key.extend_from_slice(hash.as_ref());
+	Ok(lookup_key)
+}
+
+/// Delete number to hash mapping in DB transaction.
+pub fn remove_number_to_key_mapping<N: TryInto<u32>>(
+	transaction: &mut Transaction<DbHash>,
+	key_lookup_col: u32,
+	number: N,
+) -> sp_blockchain::Result<()> {
+	transaction.remove(key_lookup_col, number_index_key(number)?.as_ref());
+	Ok(())
+}
+
+/// Place a number mapping into the database. This maps number to current perceived
+/// block hash at that position.
+pub fn insert_number_to_key_mapping<N: TryInto<u32> + Clone, H: AsRef<[u8]>>(
+	transaction: &mut Transaction<DbHash>,
+	key_lookup_col: u32,
+	number: N,
+	hash: H,
+) -> sp_blockchain::Result<()> {
+	transaction.set_from_vec(
+		key_lookup_col,
+		number_index_key(number.clone())?.as_ref(),
+		number_and_hash_to_lookup_key(number, hash)?,
+	);
+	Ok(())
+}
+
+/// Insert a hash to key mapping in the database.
+pub fn insert_hash_to_key_mapping<N: TryInto<u32>, H: AsRef<[u8]> + Clone>(
+	transaction: &mut Transaction<DbHash>,
+	key_lookup_col: u32,
+	number: N,
+	hash: H,
+) -> sp_blockchain::Result<()> {
+	transaction.set_from_vec(
+		key_lookup_col,
+		hash.as_ref(),
+		number_and_hash_to_lookup_key(number, hash.clone())?,
+	);
+	Ok(())
+}
+
+/// Convert block id to block lookup key.
+/// block lookup key is the DB-key header, block and justification are stored under.
+/// looks up lookup key by hash from DB as necessary.
+pub fn block_id_to_lookup_key<Block>(
+	db: &dyn Database<DbHash>,
+	key_lookup_col: u32,
+	id: BlockId<Block>,
+) -> Result<Option<Vec<u8>>, sp_blockchain::Error>
+where
+	Block: BlockT,
+	::sp_runtime::traits::NumberFor<Block>: UniqueSaturatedFrom<u64> + UniqueSaturatedInto<u64>,
+{
+	Ok(match id {
+		BlockId::Number(n) => db.get(key_lookup_col, number_index_key(n)?.as_ref()),
+		BlockId::Hash(h) => db.get(key_lookup_col, h.as_ref()),
+	})
+}
+
+/// Opens the configured database.
+pub fn open_database<Block: BlockT>(
+	db_source: &DatabaseSource,
+	db_type: DatabaseType,
+	create: bool,
+) -> OpenDbResult {
+	// Maybe migrate (copy) the database to a type specific subdirectory to make it
+	// possible that light and full databases coexist
+	// NOTE: This function can be removed in a few releases
+	maybe_migrate_to_type_subdir::<Block>(db_source, db_type)?;
+
+	open_database_at::<Block>(db_source, db_type, create)
+}
+
+fn open_database_at<Block: BlockT>(
+	db_source: &DatabaseSource,
+	db_type: DatabaseType,
+	create: bool,
+) -> OpenDbResult {
+	let db: Arc<dyn Database<DbHash>> = match &db_source {
+		DatabaseSource::ParityDb { path } => open_parity_db::<Block>(path, db_type, create)?,
+		#[cfg(feature = "rocksdb")]
+		DatabaseSource::RocksDb { path, cache_size } =>
+			open_kvdb_rocksdb::<Block>(path, db_type, create, *cache_size)?,
+		DatabaseSource::Custom { db, require_create_flag } => {
+			if *require_create_flag && !create {
+				return Err(OpenDbError::DoesNotExist)
+			}
+			db.clone()
+		},
+		DatabaseSource::Auto { paritydb_path, rocksdb_path, cache_size } => {
+			// check if rocksdb exists first, if not, open paritydb
+			match open_kvdb_rocksdb::<Block>(rocksdb_path, db_type, false, *cache_size) {
+				Ok(db) => db,
+				Err(OpenDbError::NotEnabled(_)) | Err(OpenDbError::DoesNotExist) =>
+					open_parity_db::<Block>(paritydb_path, db_type, create)?,
+				Err(as_is) => return Err(as_is),
+			}
+		},
+	};
+
+	check_database_type(&*db, db_type)?;
+	Ok(db)
+}
+
+#[derive(Debug)]
+pub enum OpenDbError {
+	// constructed only when rocksdb and paritydb are disabled
+	#[allow(dead_code)]
+	NotEnabled(&'static str),
+	DoesNotExist,
+	Internal(String),
+	DatabaseError(sp_database::error::DatabaseError),
+	UnexpectedDbType {
+		expected: DatabaseType,
+		found: Vec<u8>,
+	},
+}
+
+type OpenDbResult = Result<Arc<dyn Database<DbHash>>, OpenDbError>;
+
+impl fmt::Display for OpenDbError {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			OpenDbError::Internal(e) => write!(f, "{}", e),
+			OpenDbError::DoesNotExist => write!(f, "Database does not exist at given location"),
+			OpenDbError::NotEnabled(feat) => {
+				write!(f, "`{}` feature not enabled, database can not be opened", feat)
+			},
+			OpenDbError::DatabaseError(db_error) => {
+				write!(f, "Database Error: {}", db_error)
+			},
+			OpenDbError::UnexpectedDbType { expected, found } => {
+				write!(
+					f,
+					"Unexpected DB-Type. Expected: {:?}, Found: {:?}",
+					expected.as_str().as_bytes(),
+					found
+				)
+			},
+		}
+	}
+}
+
+impl From<OpenDbError> for sp_blockchain::Error {
+	fn from(err: OpenDbError) -> Self {
+		sp_blockchain::Error::Backend(err.to_string())
+	}
+}
+
+impl From<parity_db::Error> for OpenDbError {
+	fn from(err: parity_db::Error) -> Self {
+		if matches!(err, parity_db::Error::DatabaseNotFound) {
+			OpenDbError::DoesNotExist
+		} else {
+			OpenDbError::Internal(err.to_string())
+		}
+	}
+}
+
+impl From<io::Error> for OpenDbError {
+	fn from(err: io::Error) -> Self {
+		if err.to_string().contains("create_if_missing is false") {
+			OpenDbError::DoesNotExist
+		} else {
+			OpenDbError::Internal(err.to_string())
+		}
+	}
+}
+
+fn open_parity_db<Block: BlockT>(path: &Path, db_type: DatabaseType, create: bool) -> OpenDbResult {
+	match crate::parity_db::open(path, db_type, create, false) {
+		Ok(db) => Ok(db),
+		Err(parity_db::Error::InvalidConfiguration(_)) => {
+			log::warn!("Invalid parity db configuration, attempting database metadata update.");
+			// Try to update the database with the new config
+			Ok(crate::parity_db::open(path, db_type, create, true)?)
+		},
+		Err(e) => Err(e.into()),
+	}
+}
+
+#[cfg(any(feature = "rocksdb", test))]
+fn open_kvdb_rocksdb<Block: BlockT>(
+	path: &Path,
+	db_type: DatabaseType,
+	create: bool,
+	cache_size: usize,
+) -> OpenDbResult {
+	// first upgrade database to required version
+	match crate::upgrade::upgrade_db::<Block>(path, db_type) {
+		// in case of missing version file, assume that database simply does not exist at given
+		// location
+		Ok(_) | Err(crate::upgrade::UpgradeError::MissingDatabaseVersionFile) => (),
+		Err(err) => return Err(io::Error::new(io::ErrorKind::Other, err.to_string()).into()),
+	}
+
+	// and now open database assuming that it has the latest version
+	let mut db_config = kvdb_rocksdb::DatabaseConfig::with_columns(NUM_COLUMNS);
+	db_config.create_if_missing = create;
+
+	let mut memory_budget = std::collections::HashMap::new();
+	match db_type {
+		DatabaseType::Full => {
+			let state_col_budget = (cache_size as f64 * 0.9) as usize;
+			let other_col_budget = (cache_size - state_col_budget) / (NUM_COLUMNS as usize - 1);
+
+			for i in 0..NUM_COLUMNS {
+				if i == crate::columns::STATE {
+					memory_budget.insert(i, state_col_budget);
+				} else {
+					memory_budget.insert(i, other_col_budget);
+				}
+			}
+			log::trace!(
+				target: "db",
+				"Open RocksDB database at {:?}, state column budget: {} MiB, others({}) column cache: {} MiB",
+				path,
+				state_col_budget,
+				NUM_COLUMNS,
+				other_col_budget,
+			);
+		},
+	}
+	db_config.memory_budget = memory_budget;
+
+	let db = kvdb_rocksdb::Database::open(&db_config, path)?;
+	// write database version only after the database is succesfully opened
+	crate::upgrade::update_version(path)?;
+	Ok(sp_database::as_database(db))
+}
+
+#[cfg(not(any(feature = "rocksdb", test)))]
+fn open_kvdb_rocksdb<Block: BlockT>(
+	_path: &Path,
+	_db_type: DatabaseType,
+	_create: bool,
+	_cache_size: usize,
+) -> OpenDbResult {
+	Err(OpenDbError::NotEnabled("with-kvdb-rocksdb"))
+}
+
+/// Check database type.
+pub fn check_database_type(
+	db: &dyn Database<DbHash>,
+	db_type: DatabaseType,
+) -> Result<(), OpenDbError> {
+	match db.get(COLUMN_META, meta_keys::TYPE) {
+		Some(stored_type) =>
+			if db_type.as_str().as_bytes() != &*stored_type {
+				return Err(OpenDbError::UnexpectedDbType {
+					expected: db_type,
+					found: stored_type.to_owned(),
+				})
+			},
+		None => {
+			let mut transaction = Transaction::new();
+			transaction.set(COLUMN_META, meta_keys::TYPE, db_type.as_str().as_bytes());
+			db.commit(transaction).map_err(OpenDbError::DatabaseError)?;
+		},
+	}
+
+	Ok(())
+}
+
+fn maybe_migrate_to_type_subdir<Block: BlockT>(
+	source: &DatabaseSource,
+	db_type: DatabaseType,
+) -> Result<(), OpenDbError> {
+	if let Some(p) = source.path() {
+		let mut basedir = p.to_path_buf();
+		basedir.pop();
+
+		// Do we have to migrate to a database-type-based subdirectory layout:
+		// See if there's a file identifying a rocksdb or paritydb folder in the parent dir and
+		// the target path ends in a role specific directory
+		if (basedir.join("db_version").exists() || basedir.join("metadata").exists()) &&
+			(p.ends_with(DatabaseType::Full.as_str()))
+		{
+			// Try to open the database to check if the current `DatabaseType` matches the type of
+			// database stored in the target directory and close the database on success.
+			let mut old_source = source.clone();
+			old_source.set_path(&basedir);
+			open_database_at::<Block>(&old_source, db_type, false)?;
+
+			info!(
+				"Migrating database to a database-type-based subdirectory: '{:?}' -> '{:?}'",
+				basedir,
+				basedir.join(db_type.as_str())
+			);
+
+			let mut tmp_dir = basedir.clone();
+			tmp_dir.pop();
+			tmp_dir.push("tmp");
+
+			fs::rename(&basedir, &tmp_dir)?;
+			fs::create_dir_all(&p)?;
+			fs::rename(tmp_dir, &p)?;
+		}
+	}
+
+	Ok(())
+}
+
+/// Read database column entry for the given block.
+pub fn read_db<Block>(
+	db: &dyn Database<DbHash>,
+	col_index: u32,
+	col: u32,
+	id: BlockId<Block>,
+) -> sp_blockchain::Result<Option<DBValue>>
+where
+	Block: BlockT,
+{
+	block_id_to_lookup_key(db, col_index, id).map(|key| match key {
+		Some(key) => db.get(col, key.as_ref()),
+		None => None,
+	})
+}
+
+/// Remove database column entry for the given block.
+pub fn remove_from_db<Block>(
+	transaction: &mut Transaction<DbHash>,
+	db: &dyn Database<DbHash>,
+	col_index: u32,
+	col: u32,
+	id: BlockId<Block>,
+) -> sp_blockchain::Result<()>
+where
+	Block: BlockT,
+{
+	block_id_to_lookup_key(db, col_index, id).map(|key| {
+		if let Some(key) = key {
+			transaction.remove(col, key.as_ref());
+		}
+	})
+}
+
+/// Read a header from the database.
+pub fn read_header<Block: BlockT>(
+	db: &dyn Database<DbHash>,
+	col_index: u32,
+	col: u32,
+	id: BlockId<Block>,
+) -> sp_blockchain::Result<Option<Block::Header>> {
+	match read_db(db, col_index, col, id)? {
+		Some(header) => match Block::Header::decode(&mut &header[..]) {
+			Ok(header) => Ok(Some(header)),
+			Err(_) => Err(sp_blockchain::Error::Backend("Error decoding header".into())),
+		},
+		None => Ok(None),
+	}
+}
+
+/// Read meta from the database.
+pub fn read_meta<Block>(
+	db: &dyn Database<DbHash>,
+	col_header: u32,
+) -> Result<Meta<<<Block as BlockT>::Header as HeaderT>::Number, Block::Hash>, sp_blockchain::Error>
+where
+	Block: BlockT,
+{
+	let genesis_hash: Block::Hash = match read_genesis_hash(db)? {
+		Some(genesis_hash) => genesis_hash,
+		None =>
+			return Ok(Meta {
+				best_hash: Default::default(),
+				best_number: Zero::zero(),
+				finalized_hash: Default::default(),
+				finalized_number: Zero::zero(),
+				genesis_hash: Default::default(),
+				finalized_state: None,
+				block_gap: None,
+			}),
+	};
+
+	let load_meta_block = |desc, key| -> Result<_, sp_blockchain::Error> {
+		if let Some(Some(header)) = db
+			.get(COLUMN_META, key)
+			.and_then(|id| db.get(col_header, &id).map(|b| Block::Header::decode(&mut &b[..]).ok()))
+		{
+			let hash = header.hash();
+			debug!(
+				target: "db",
+				"Opened blockchain db, fetched {} = {:?} ({})",
+				desc,
+				hash,
+				header.number(),
+			);
+			Ok((hash, *header.number()))
+		} else {
+			Ok((Default::default(), Zero::zero()))
+		}
+	};
+
+	let (best_hash, best_number) = load_meta_block("best", meta_keys::BEST_BLOCK)?;
+	let (finalized_hash, finalized_number) = load_meta_block("final", meta_keys::FINALIZED_BLOCK)?;
+	let (finalized_state_hash, finalized_state_number) =
+		load_meta_block("final_state", meta_keys::FINALIZED_STATE)?;
+	let finalized_state = if finalized_state_hash != Default::default() {
+		Some((finalized_state_hash, finalized_state_number))
+	} else {
+		None
+	};
+	let block_gap = db
+		.get(COLUMN_META, meta_keys::BLOCK_GAP)
+		.and_then(|d| Decode::decode(&mut d.as_slice()).ok());
+	debug!(target: "db", "block_gap={:?}", block_gap);
+
+	Ok(Meta {
+		best_hash,
+		best_number,
+		finalized_hash,
+		finalized_number,
+		genesis_hash,
+		finalized_state,
+		block_gap,
+	})
+}
+
+/// Read genesis hash from database.
+pub fn read_genesis_hash<Hash: Decode>(
+	db: &dyn Database<DbHash>,
+) -> sp_blockchain::Result<Option<Hash>> {
+	match db.get(COLUMN_META, meta_keys::GENESIS_HASH) {
+		Some(h) => match Decode::decode(&mut &h[..]) {
+			Ok(h) => Ok(Some(h)),
+			Err(err) =>
+				Err(sp_blockchain::Error::Backend(format!("Error decoding genesis hash: {}", err))),
+		},
+		None => Ok(None),
+	}
+}
+
+impl DatabaseType {
+	/// Returns str representation of the type.
+	pub fn as_str(&self) -> &'static str {
+		match *self {
+			DatabaseType::Full => "full",
+		}
+	}
+}
+
+pub(crate) struct JoinInput<'a, 'b>(&'a [u8], &'b [u8]);
+
+pub(crate) fn join_input<'a, 'b>(i1: &'a [u8], i2: &'b [u8]) -> JoinInput<'a, 'b> {
+	JoinInput(i1, i2)
+}
+
+impl<'a, 'b> codec::Input for JoinInput<'a, 'b> {
+	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
+		Ok(Some(self.0.len() + self.1.len()))
+	}
+
+	fn read(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
+		let mut read = 0;
+		if self.0.len() > 0 {
+			read = std::cmp::min(self.0.len(), into.len());
+			self.0.read(&mut into[..read])?;
+		}
+		if read < into.len() {
+			self.1.read(&mut into[read..])?;
+		}
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::Input;
+	use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper};
+	type Block = RawBlock<ExtrinsicWrapper<u32>>;
+
+	#[cfg(feature = "rocksdb")]
+	#[test]
+	fn database_type_subdir_migration() {
+		use std::path::PathBuf;
+		type Block = RawBlock<ExtrinsicWrapper<u64>>;
+
+		fn check_dir_for_db_type(
+			db_type: DatabaseType,
+			mut source: DatabaseSource,
+			db_check_file: &str,
+		) {
+			let base_path = tempfile::TempDir::new().unwrap();
+			let old_db_path = base_path.path().join("chains/dev/db");
+
+			source.set_path(&old_db_path);
+
+			{
+				let db_res = open_database::<Block>(&source, db_type, true);
+				assert!(db_res.is_ok(), "New database should be created.");
+				assert!(old_db_path.join(db_check_file).exists());
+				assert!(!old_db_path.join(db_type.as_str()).join("db_version").exists());
+			}
+
+			source.set_path(&old_db_path.join(db_type.as_str()));
+
+			let db_res = open_database::<Block>(&source, db_type, true);
+			assert!(db_res.is_ok(), "Reopening the db with the same role should work");
+			// check if the database dir had been migrated
+			assert!(!old_db_path.join(db_check_file).exists());
+			assert!(old_db_path.join(db_type.as_str()).join(db_check_file).exists());
+		}
+
+		check_dir_for_db_type(
+			DatabaseType::Full,
+			DatabaseSource::RocksDb { path: PathBuf::new(), cache_size: 128 },
+			"db_version",
+		);
+
+		check_dir_for_db_type(
+			DatabaseType::Full,
+			DatabaseSource::ParityDb { path: PathBuf::new() },
+			"metadata",
+		);
+
+		// check failure on reopening with wrong role
+		{
+			let base_path = tempfile::TempDir::new().unwrap();
+			let old_db_path = base_path.path().join("chains/dev/db");
+
+			let source = DatabaseSource::RocksDb { path: old_db_path.clone(), cache_size: 128 };
+			{
+				let db_res = open_database::<Block>(&source, DatabaseType::Full, true);
+				assert!(db_res.is_ok(), "New database should be created.");
+
+				// check if the database dir had been migrated
+				assert!(old_db_path.join("db_version").exists());
+				assert!(!old_db_path.join("light/db_version").exists());
+				assert!(!old_db_path.join("full/db_version").exists());
+			}
+			// assert nothing was changed
+			assert!(old_db_path.join("db_version").exists());
+			assert!(!old_db_path.join("full/db_version").exists());
+		}
+	}
+
+	#[test]
+	fn number_index_key_doesnt_panic() {
+		let id = BlockId::<Block>::Number(72340207214430721);
+		match id {
+			BlockId::Number(n) => number_index_key(n).expect_err("number should overflow u32"),
+			_ => unreachable!(),
+		};
+	}
+
+	#[test]
+	fn database_type_as_str_works() {
+		assert_eq!(DatabaseType::Full.as_str(), "full");
+	}
+
+	#[test]
+	fn join_input_works() {
+		let buf1 = [1, 2, 3, 4];
+		let buf2 = [5, 6, 7, 8];
+		let mut test = [0, 0, 0];
+		let mut joined = join_input(buf1.as_ref(), buf2.as_ref());
+		assert_eq!(joined.remaining_len().unwrap(), Some(8));
+
+		joined.read(&mut test).unwrap();
+		assert_eq!(test, [1, 2, 3]);
+		assert_eq!(joined.remaining_len().unwrap(), Some(5));
+
+		joined.read(&mut test).unwrap();
+		assert_eq!(test, [4, 5, 6]);
+		assert_eq!(joined.remaining_len().unwrap(), Some(2));
+
+		joined.read(&mut test[0..2]).unwrap();
+		assert_eq!(test, [7, 8, 6]);
+		assert_eq!(joined.remaining_len().unwrap(), Some(0));
+	}
+
+	#[cfg(feature = "rocksdb")]
+	#[test]
+	fn test_open_database_auto_new() {
+		let db_dir = tempfile::TempDir::new().unwrap();
+		let db_path = db_dir.path().to_owned();
+		let paritydb_path = db_path.join("paritydb");
+		let rocksdb_path = db_path.join("rocksdb_path");
+		let source = DatabaseSource::Auto {
+			paritydb_path: paritydb_path.clone(),
+			rocksdb_path: rocksdb_path.clone(),
+			cache_size: 128,
+		};
+
+		// it should create new auto (paritydb) database
+		{
+			let db_res = open_database::<Block>(&source, DatabaseType::Full, true);
+			assert!(db_res.is_ok(), "New database should be created.");
+		}
+
+		// it should reopen existing auto (pairtydb) database
+		{
+			let db_res = open_database::<Block>(&source, DatabaseType::Full, true);
+			assert!(db_res.is_ok(), "Existing parity database should be reopened");
+		}
+
+		// it should fail to open existing auto (pairtydb) database
+		{
+			let db_res = open_database::<Block>(
+				&DatabaseSource::RocksDb { path: rocksdb_path, cache_size: 128 },
+				DatabaseType::Full,
+				true,
+			);
+			assert!(db_res.is_ok(), "New database should be opened.");
+		}
+
+		// it should reopen existing auto (pairtydb) database
+		{
+			let db_res = open_database::<Block>(
+				&DatabaseSource::ParityDb { path: paritydb_path },
+				DatabaseType::Full,
+				true,
+			);
+			assert!(db_res.is_ok(), "Existing parity database should be reopened");
+		}
+	}
+
+	#[cfg(feature = "rocksdb")]
+	#[test]
+	fn test_open_database_rocksdb_new() {
+		let db_dir = tempfile::TempDir::new().unwrap();
+		let db_path = db_dir.path().to_owned();
+		let paritydb_path = db_path.join("paritydb");
+		let rocksdb_path = db_path.join("rocksdb_path");
+
+		let source = DatabaseSource::RocksDb { path: rocksdb_path.clone(), cache_size: 128 };
+
+		// it should create new rocksdb database
+		{
+			let db_res = open_database::<Block>(&source, DatabaseType::Full, true);
+			assert!(db_res.is_ok(), "New rocksdb database should be created");
+		}
+
+		// it should reopen existing auto (rocksdb) database
+		{
+			let db_res = open_database::<Block>(
+				&DatabaseSource::Auto {
+					paritydb_path: paritydb_path.clone(),
+					rocksdb_path: rocksdb_path.clone(),
+					cache_size: 128,
+				},
+				DatabaseType::Full,
+				true,
+			);
+			assert!(db_res.is_ok(), "Existing rocksdb database should be reopened");
+		}
+
+		// it should fail to open existing auto (rocksdb) database
+		{
+			let db_res = open_database::<Block>(
+				&DatabaseSource::ParityDb { path: paritydb_path },
+				DatabaseType::Full,
+				true,
+			);
+			assert!(db_res.is_ok(), "New paritydb database should be created");
+		}
+
+		// it should reopen existing auto (pairtydb) database
+		{
+			let db_res = open_database::<Block>(
+				&DatabaseSource::RocksDb { path: rocksdb_path, cache_size: 128 },
+				DatabaseType::Full,
+				true,
+			);
+			assert!(db_res.is_ok(), "Existing rocksdb database should be reopened");
+		}
+	}
+
+	#[cfg(feature = "rocksdb")]
+	#[test]
+	fn test_open_database_paritydb_new() {
+		let db_dir = tempfile::TempDir::new().unwrap();
+		let db_path = db_dir.path().to_owned();
+		let paritydb_path = db_path.join("paritydb");
+		let rocksdb_path = db_path.join("rocksdb_path");
+
+		let source = DatabaseSource::ParityDb { path: paritydb_path.clone() };
+
+		// it should create new paritydb database
+		{
+			let db_res = open_database::<Block>(&source, DatabaseType::Full, true);
+			assert!(db_res.is_ok(), "New database should be created.");
+		}
+
+		// it should reopen existing pairtydb database
+		{
+			let db_res = open_database::<Block>(&source, DatabaseType::Full, true);
+			assert!(db_res.is_ok(), "Existing parity database should be reopened");
+		}
+
+		// it should fail to open existing pairtydb database
+		{
+			let db_res = open_database::<Block>(
+				&DatabaseSource::RocksDb { path: rocksdb_path.clone(), cache_size: 128 },
+				DatabaseType::Full,
+				true,
+			);
+			assert!(db_res.is_ok(), "New rocksdb database should be created");
+		}
+
+		// it should reopen existing auto (pairtydb) database
+		{
+			let db_res = open_database::<Block>(
+				&DatabaseSource::Auto { paritydb_path, rocksdb_path, cache_size: 128 },
+				DatabaseType::Full,
+				true,
+			);
+			assert!(db_res.is_ok(), "Existing parity database should be reopened");
+		}
+	}
+}
diff --git a/substrate/client/executor/Cargo.toml b/substrate/client/executor/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e7252ef3f19cbb5967e2963a33c0969b1ffebc8a
--- /dev/null
+++ b/substrate/client/executor/Cargo.toml
@@ -0,0 +1,75 @@
+[package]
+name = "sc-executor"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "A crate that provides means of executing/dispatching calls into the runtime."
+documentation = "https://docs.rs/sc-executor"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+parking_lot = "0.12.1"
+schnellru = "0.2.1"
+tracing = "0.1.29"
+
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+sc-executor-common = { version = "0.10.0-dev", path = "common" }
+sc-executor-wasmtime = { version = "0.10.0-dev", path = "wasmtime" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-externalities = { version = "0.19.0", path = "../../primitives/externalities" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-panic-handler = { version = "8.0.0", path = "../../primitives/panic-handler" }
+sp-runtime-interface = { version = "17.0.0", path = "../../primitives/runtime-interface" }
+sp-trie = { version = "22.0.0", path = "../../primitives/trie" }
+sp-version = { version = "22.0.0", path = "../../primitives/version" }
+sp-wasm-interface = { version = "14.0.0", path = "../../primitives/wasm-interface" }
+
+[dev-dependencies]
+array-bytes = "6.1"
+assert_matches = "1.3.0"
+wat = "1.0"
+sc-runtime-test = { version = "2.0.0", path = "runtime-test" }
+substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../primitives/state-machine" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-maybe-compressed-blob = { version = "4.1.0-dev", path = "../../primitives/maybe-compressed-blob" }
+sc-tracing = { version = "4.0.0-dev", path = "../tracing" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+tracing-subscriber = "0.2.19"
+paste = "1.0"
+regex = "1.6.0"
+criterion = "0.4.0"
+env_logger = "0.9"
+num_cpus = "1.13.1"
+tempfile = "3.3.0"
+
+[[bench]]
+name = "bench"
+harness = false
+
+[features]
+default = [ "std" ]
+# This crate does not have `no_std` support, we just require this for tests
+std = [
+	"sc-runtime-test/std",
+	"sp-api/std",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-io/std",
+	"sp-runtime-interface/std",
+	"sp-runtime/std",
+	"sp-state-machine/std",
+	"sp-tracing/std",
+	"sp-trie/std",
+	"sp-version/std",
+	"sp-wasm-interface/std",
+	"substrate-test-runtime/std",
+]
+wasm-extern-trace = []
diff --git a/substrate/client/executor/README.md b/substrate/client/executor/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ab7b3d45206f9fc4ca4e0323dcc5b27bbf943226
--- /dev/null
+++ b/substrate/client/executor/README.md
@@ -0,0 +1,13 @@
+A crate that provides means of executing/dispatching calls into the runtime.
+
+There are a few responsibilities of this crate at the moment:
+
+- It provides an implementation of a common entrypoint for calling into the runtime, both
+wasm and compiled.
+- It defines the environment for the wasm execution, namely the host functions that are to be
+provided into the wasm runtime module.
+- It also provides the required infrastructure for executing the current wasm runtime (specified
+by the current value of `:code` in the provided externalities), i.e. interfacing with
+wasm engine used, instance cache.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/executor/benches/bench.rs b/substrate/client/executor/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..66a82a175221d6a9aa229c5a593f3531f80f656f
--- /dev/null
+++ b/substrate/client/executor/benches/bench.rs
@@ -0,0 +1,259 @@
+// 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 criterion::{criterion_group, criterion_main, Criterion};
+
+use codec::Encode;
+
+use sc_executor_common::{
+	runtime_blob::RuntimeBlob,
+	wasm_runtime::{WasmInstance, WasmModule, DEFAULT_HEAP_ALLOC_STRATEGY},
+};
+use sc_executor_wasmtime::InstantiationStrategy;
+use sc_runtime_test::wasm_binary_unwrap as test_runtime;
+use std::sync::{
+	atomic::{AtomicBool, AtomicUsize, Ordering},
+	Arc,
+};
+
+#[derive(Clone)]
+enum Method {
+	Compiled { instantiation_strategy: InstantiationStrategy, precompile: bool },
+}
+
+// This is just a bog-standard Kusama runtime with an extra
+// `test_empty_return` and `test_dirty_plenty_memory` functions
+// copy-pasted from the test runtime.
+fn kusama_runtime() -> &'static [u8] {
+	include_bytes!("kusama_runtime.wasm")
+}
+
+fn initialize(
+	_tmpdir: &mut Option<tempfile::TempDir>,
+	runtime: &[u8],
+	method: Method,
+) -> Box<dyn WasmModule> {
+	let blob = RuntimeBlob::uncompress_if_needed(runtime).unwrap();
+
+	let allow_missing_func_imports = true;
+
+	match method {
+		Method::Compiled { instantiation_strategy, precompile } => {
+			let config = sc_executor_wasmtime::Config {
+				allow_missing_func_imports,
+				cache_path: None,
+				semantics: sc_executor_wasmtime::Semantics {
+					heap_alloc_strategy: DEFAULT_HEAP_ALLOC_STRATEGY,
+					instantiation_strategy,
+					deterministic_stack_limit: None,
+					canonicalize_nans: false,
+					parallel_compilation: true,
+					wasm_multi_value: false,
+					wasm_bulk_memory: false,
+					wasm_reference_types: false,
+					wasm_simd: false,
+				},
+			};
+
+			if precompile {
+				let precompiled_blob =
+					sc_executor_wasmtime::prepare_runtime_artifact(blob, &config.semantics)
+						.unwrap();
+
+				// Create a fresh temporary directory to make absolutely sure
+				// we'll use the right module.
+				*_tmpdir = Some(tempfile::tempdir().unwrap());
+				let tmpdir = _tmpdir.as_ref().unwrap();
+
+				let path = tmpdir.path().join("module.bin");
+				std::fs::write(&path, &precompiled_blob).unwrap();
+				unsafe {
+					sc_executor_wasmtime::create_runtime_from_artifact::<
+						sp_io::SubstrateHostFunctions,
+					>(&path, config)
+				}
+			} else {
+				sc_executor_wasmtime::create_runtime::<sp_io::SubstrateHostFunctions>(blob, config)
+			}
+			.map(|runtime| -> Box<dyn WasmModule> { Box::new(runtime) })
+		},
+	}
+	.unwrap()
+}
+
+fn run_benchmark(
+	c: &mut Criterion,
+	benchmark_name: &str,
+	thread_count: usize,
+	runtime: &dyn WasmModule,
+	testcase: impl Fn(&mut Box<dyn WasmInstance>) + Copy + Send + 'static,
+) {
+	c.bench_function(benchmark_name, |b| {
+		// Here we deliberately start a bunch of extra threads which will just
+		// keep on independently instantiating the runtime over and over again.
+		//
+		// We don't really have to measure how much time those take since the
+		// work done is essentially the same on each thread, and what we're
+		// interested in here is only how those extra threads affect the execution
+		// on the current thread.
+		//
+		// In an ideal case assuming we have enough CPU cores those extra threads
+		// shouldn't affect the main thread's runtime at all, however in practice
+		// they're not completely independent. There might be per-process
+		// locks in the kernel which are briefly held during instantiation, etc.,
+		// and how much those affect the execution here is what we want to measure.
+		let is_benchmark_running = Arc::new(AtomicBool::new(true));
+		let threads_running = Arc::new(AtomicUsize::new(0));
+		let aux_threads: Vec<_> = (0..thread_count - 1)
+			.map(|_| {
+				let mut instance = runtime.new_instance().unwrap();
+				let is_benchmark_running = is_benchmark_running.clone();
+				let threads_running = threads_running.clone();
+				std::thread::spawn(move || {
+					threads_running.fetch_add(1, Ordering::SeqCst);
+					while is_benchmark_running.load(Ordering::Relaxed) {
+						testcase(&mut instance);
+					}
+				})
+			})
+			.collect();
+
+		while threads_running.load(Ordering::SeqCst) != (thread_count - 1) {
+			std::thread::yield_now();
+		}
+
+		let mut instance = runtime.new_instance().unwrap();
+		b.iter(|| testcase(&mut instance));
+
+		is_benchmark_running.store(false, Ordering::SeqCst);
+		for thread in aux_threads {
+			thread.join().unwrap();
+		}
+	});
+}
+
+fn bench_call_instance(c: &mut Criterion) {
+	let _ = env_logger::try_init();
+
+	let strategies = [
+		(
+			"legacy_instance_reuse",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::LegacyInstanceReuse,
+				precompile: false,
+			},
+		),
+		(
+			"recreate_instance_vanilla",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::RecreateInstance,
+				precompile: false,
+			},
+		),
+		(
+			"recreate_instance_cow_fresh",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::RecreateInstanceCopyOnWrite,
+				precompile: false,
+			},
+		),
+		(
+			"recreate_instance_cow_precompiled",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::RecreateInstanceCopyOnWrite,
+				precompile: true,
+			},
+		),
+		(
+			"pooling_vanilla_fresh",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::Pooling,
+				precompile: false,
+			},
+		),
+		(
+			"pooling_vanilla_precompiled",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::Pooling,
+				precompile: true,
+			},
+		),
+		(
+			"pooling_cow_fresh",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::PoolingCopyOnWrite,
+				precompile: false,
+			},
+		),
+		(
+			"pooling_cow_precompiled",
+			Method::Compiled {
+				instantiation_strategy: InstantiationStrategy::PoolingCopyOnWrite,
+				precompile: true,
+			},
+		),
+	];
+
+	let runtimes = [("kusama_runtime", kusama_runtime()), ("test_runtime", test_runtime())];
+
+	let thread_counts = [1, 2, 4, 8, 16];
+
+	fn test_call_empty_function(instance: &mut Box<dyn WasmInstance>) {
+		instance.call_export("test_empty_return", &[0]).unwrap();
+	}
+
+	fn test_dirty_1mb_of_memory(instance: &mut Box<dyn WasmInstance>) {
+		instance.call_export("test_dirty_plenty_memory", &(0, 16).encode()).unwrap();
+	}
+
+	let testcases = [
+		("call_empty_function", test_call_empty_function as fn(&mut Box<dyn WasmInstance>)),
+		("dirty_1mb_of_memory", test_dirty_1mb_of_memory),
+	];
+
+	let num_cpus = num_cpus::get_physical();
+	let mut tmpdir = None;
+
+	for (strategy_name, strategy) in strategies {
+		for (runtime_name, runtime) in runtimes {
+			let runtime = initialize(&mut tmpdir, runtime, strategy.clone());
+
+			for (testcase_name, testcase) in testcases {
+				for thread_count in thread_counts {
+					if thread_count > num_cpus {
+						// If there are not enough cores available the benchmark is pointless.
+						continue
+					}
+
+					let benchmark_name = format!(
+						"{}_from_{}_with_{}_on_{}_threads",
+						testcase_name, runtime_name, strategy_name, thread_count
+					);
+
+					run_benchmark(c, &benchmark_name, thread_count, &*runtime, testcase);
+				}
+			}
+		}
+	}
+}
+
+criterion_group! {
+	name = benches;
+	config = Criterion::default();
+	targets = bench_call_instance
+}
+criterion_main!(benches);
diff --git a/substrate/client/executor/benches/kusama_runtime.wasm b/substrate/client/executor/benches/kusama_runtime.wasm
new file mode 100755
index 0000000000000000000000000000000000000000..28adce962340037a0dca62724add224218c50b66
Binary files /dev/null and b/substrate/client/executor/benches/kusama_runtime.wasm differ
diff --git a/substrate/client/executor/common/Cargo.toml b/substrate/client/executor/common/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dfde1902631cd0f4b1b279c79763921ef7884354
--- /dev/null
+++ b/substrate/client/executor/common/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "sc-executor-common"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "A set of common definitions that are needed for defining execution engines."
+documentation = "https://docs.rs/sc-executor-common/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+thiserror = "1.0.30"
+wasm-instrument = "0.3"
+sc-allocator = { version = "4.1.0-dev", path = "../../allocator" }
+sp-maybe-compressed-blob = { version = "4.1.0-dev", path = "../../../primitives/maybe-compressed-blob" }
+sp-wasm-interface = { version = "14.0.0", path = "../../../primitives/wasm-interface" }
+
+[features]
+default = []
diff --git a/substrate/client/executor/common/README.md b/substrate/client/executor/common/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c0d3bf08bcb20519013a428ee4daf9ce6c1a622
--- /dev/null
+++ b/substrate/client/executor/common/README.md
@@ -0,0 +1,3 @@
+A set of common definitions that are needed for defining execution engines.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/executor/common/src/error.rs b/substrate/client/executor/common/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a0dc364b4103ebc53ee767300bf25cc7211fe8b
--- /dev/null
+++ b/substrate/client/executor/common/src/error.rs
@@ -0,0 +1,186 @@
+// 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/>.
+
+//! Rust executor possible errors.
+
+/// Result type alias.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Error type.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+	#[error("Error calling api function: {0}")]
+	ApiError(Box<dyn std::error::Error + Send + Sync>),
+
+	#[error("Method not found: '{0}'")]
+	MethodNotFound(String),
+
+	#[error("On-chain runtime does not specify version")]
+	VersionInvalid,
+
+	#[error("Externalities error")]
+	Externalities,
+
+	#[error("Invalid index provided")]
+	InvalidIndex,
+
+	#[error("Invalid type returned (should be u64)")]
+	InvalidReturn,
+
+	#[error("Runtime panicked: {0}")]
+	RuntimePanicked(String),
+
+	#[error("Invalid memory reference")]
+	InvalidMemoryReference,
+
+	#[error("The runtime doesn't provide a global named `__heap_base` of type `i32`")]
+	HeapBaseNotFoundOrInvalid,
+
+	#[error("The runtime must not have the `start` function defined")]
+	RuntimeHasStartFn,
+
+	#[error("Other: {0}")]
+	Other(String),
+
+	#[error(transparent)]
+	Allocator(#[from] sc_allocator::Error),
+
+	#[error("Host function {0} execution failed with: {1}")]
+	FunctionExecution(String, String),
+
+	#[error("No table exported by wasm blob")]
+	NoTable,
+
+	#[error("No table entry with index {0} in wasm blob exported table")]
+	NoTableEntryWithIndex(u32),
+
+	#[error("Table element with index {0} is not a function in wasm blob exported table")]
+	TableElementIsNotAFunction(u32),
+
+	#[error("Table entry with index {0} in wasm blob is null")]
+	FunctionRefIsNull(u32),
+
+	#[error(transparent)]
+	RuntimeConstruction(#[from] WasmError),
+
+	#[error("Shared memory is not supported")]
+	SharedMemUnsupported,
+
+	#[error("Imported globals are not supported yet")]
+	ImportedGlobalsUnsupported,
+
+	#[error("initializer expression can have only up to 2 expressions in wasm 1.0")]
+	InitializerHasTooManyExpressions,
+
+	#[error("Invalid initializer expression provided {0}")]
+	InvalidInitializerExpression(String),
+
+	#[error("Execution aborted due to panic: {0}")]
+	AbortedDueToPanic(MessageWithBacktrace),
+
+	#[error("Execution aborted due to trap: {0}")]
+	AbortedDueToTrap(MessageWithBacktrace),
+
+	#[error("Output exceeds bounds of wasm memory")]
+	OutputExceedsBounds,
+}
+
+impl From<&'static str> for Error {
+	fn from(err: &'static str) -> Error {
+		Error::Other(err.into())
+	}
+}
+
+impl From<String> for Error {
+	fn from(err: String) -> Error {
+		Error::Other(err)
+	}
+}
+
+/// Type for errors occurring during Wasm runtime construction.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum WasmError {
+	#[error("Code could not be read from the state.")]
+	CodeNotFound,
+
+	#[error("Failure to reinitialize runtime instance from snapshot.")]
+	ApplySnapshotFailed,
+
+	/// Failure to erase the wasm memory.
+	///
+	/// Depending on the implementation might mean failure of allocating memory.
+	#[error("Failure to erase the wasm memory: {0}")]
+	ErasingFailed(String),
+
+	#[error("Wasm code failed validation.")]
+	InvalidModule,
+
+	#[error("Wasm code could not be deserialized.")]
+	CantDeserializeWasm,
+
+	#[error("The module does not export a linear memory named `memory`.")]
+	InvalidMemory,
+
+	#[error("The number of heap pages requested is disallowed by the module.")]
+	InvalidHeapPages,
+
+	/// Instantiation error.
+	#[error("{0}")]
+	Instantiation(String),
+
+	/// Other error happenend.
+	#[error("Other error happened while constructing the runtime: {0}")]
+	Other(String),
+}
+
+/// An error message with an attached backtrace.
+#[derive(Debug)]
+pub struct MessageWithBacktrace {
+	/// The error message.
+	pub message: String,
+
+	/// The backtrace associated with the error message.
+	pub backtrace: Option<Backtrace>,
+}
+
+impl std::fmt::Display for MessageWithBacktrace {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.write_str(&self.message)?;
+		if let Some(ref backtrace) = self.backtrace {
+			fmt.write_str("\nWASM backtrace:\n")?;
+			backtrace.backtrace_string.fmt(fmt)?;
+		}
+
+		Ok(())
+	}
+}
+
+/// A WASM backtrace.
+#[derive(Debug)]
+pub struct Backtrace {
+	/// The string containing the backtrace.
+	pub backtrace_string: String,
+}
+
+impl std::fmt::Display for Backtrace {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.write_str(&self.backtrace_string)
+	}
+}
diff --git a/substrate/client/executor/common/src/lib.rs b/substrate/client/executor/common/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..751801fb30da18e48e05daedbde644ad8699ce10
--- /dev/null
+++ b/substrate/client/executor/common/src/lib.rs
@@ -0,0 +1,27 @@
+// 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/>.
+
+//! A set of common definitions that are needed for defining execution engines.
+
+#![warn(missing_docs)]
+#![deny(unused_crate_dependencies)]
+
+pub mod error;
+pub mod runtime_blob;
+pub mod util;
+pub mod wasm_runtime;
diff --git a/substrate/client/executor/common/src/runtime_blob/data_segments_snapshot.rs b/substrate/client/executor/common/src/runtime_blob/data_segments_snapshot.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3fd546ce4457b225819aed8ff785a43c81e93d4d
--- /dev/null
+++ b/substrate/client/executor/common/src/runtime_blob/data_segments_snapshot.rs
@@ -0,0 +1,87 @@
+// 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::RuntimeBlob;
+use crate::error::{self, Error};
+use std::mem;
+use wasm_instrument::parity_wasm::elements::Instruction;
+
+/// This is a snapshot of data segments specialzied for a particular instantiation.
+///
+/// Note that this assumes that no mutable globals are used.
+#[derive(Clone)]
+pub struct DataSegmentsSnapshot {
+	/// The list of data segments represented by (offset, contents).
+	data_segments: Vec<(u32, Vec<u8>)>,
+}
+
+impl DataSegmentsSnapshot {
+	/// Create a snapshot from the data segments from the module.
+	pub fn take(module: &RuntimeBlob) -> error::Result<Self> {
+		let data_segments = module
+			.data_segments()
+			.into_iter()
+			.map(|mut segment| {
+				// Just replace contents of the segment since the segments will be discarded later
+				// anyway.
+				let contents = mem::take(segment.value_mut());
+
+				let init_expr = match segment.offset() {
+					Some(offset) => offset.code(),
+					// Return if the segment is passive
+					None => return Err(Error::SharedMemUnsupported),
+				};
+
+				// [op, End]
+				if init_expr.len() != 2 {
+					return Err(Error::InitializerHasTooManyExpressions)
+				}
+				let offset = match &init_expr[0] {
+					Instruction::I32Const(v) => *v as u32,
+					Instruction::GetGlobal(_) => {
+						// In a valid wasm file, initializer expressions can only refer imported
+						// globals.
+						//
+						// At the moment of writing the Substrate Runtime Interface does not provide
+						// any globals. There is nothing that prevents us from supporting this
+						// if/when we gain those.
+						return Err(Error::ImportedGlobalsUnsupported)
+					},
+					insn => return Err(Error::InvalidInitializerExpression(format!("{:?}", insn))),
+				};
+
+				Ok((offset, contents))
+			})
+			.collect::<error::Result<Vec<_>>>()?;
+
+		Ok(Self { data_segments })
+	}
+
+	/// Apply the given snapshot to a linear memory.
+	///
+	/// Linear memory interface is represented by a closure `memory_set`.
+	pub fn apply<E>(
+		&self,
+		mut memory_set: impl FnMut(u32, &[u8]) -> Result<(), E>,
+	) -> Result<(), E> {
+		for (offset, contents) in &self.data_segments {
+			memory_set(*offset, contents)?;
+		}
+		Ok(())
+	}
+}
diff --git a/substrate/client/executor/common/src/runtime_blob/globals_snapshot.rs b/substrate/client/executor/common/src/runtime_blob/globals_snapshot.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9ba6fc55e49c2a002d6e574a56e6b6865292e969
--- /dev/null
+++ b/substrate/client/executor/common/src/runtime_blob/globals_snapshot.rs
@@ -0,0 +1,112 @@
+// 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::RuntimeBlob;
+
+/// Saved value of particular exported global.
+struct SavedValue<Global> {
+	/// The handle of this global which can be used to refer to this global.
+	handle: Global,
+	/// The global value that was observed during the snapshot creation.
+	value: sp_wasm_interface::Value,
+}
+
+/// An adapter for a wasm module instance that is focused on getting and setting globals.
+pub trait InstanceGlobals {
+	/// A handle to a global which can be used to get or set a global variable. This is supposed to
+	/// be a lightweight handle, like an index or an Rc-like smart-pointer, which is cheap to clone.
+	type Global: Clone;
+	/// Get a handle to a global by it's export name.
+	///
+	/// The requested export is must exist in the exported list, and it should be a mutable global.
+	fn get_global(&mut self, export_name: &str) -> Self::Global;
+	/// Get the current value of the global.
+	fn get_global_value(&mut self, global: &Self::Global) -> sp_wasm_interface::Value;
+	/// Update the current value of the global.
+	///
+	/// The global behind the handle is guaranteed to be mutable and the value to be the same type
+	/// as the global.
+	fn set_global_value(&mut self, global: &Self::Global, value: sp_wasm_interface::Value);
+}
+
+/// A set of exposed mutable globals.
+///
+/// This is set of globals required to create a [`GlobalsSnapshot`] and that are collected from
+/// a runtime blob that was instrumented by
+/// [`RuntimeBlob::expose_mutable_globals`](super::RuntimeBlob::expose_mutable_globals`).
+
+/// If the code wasn't instrumented then it would be empty and snapshot would do nothing.
+pub struct ExposedMutableGlobalsSet(Vec<String>);
+
+impl ExposedMutableGlobalsSet {
+	/// Collect the set from the given runtime blob. See the struct documentation for details.
+	pub fn collect(runtime_blob: &RuntimeBlob) -> Self {
+		let global_names =
+			runtime_blob.exported_internal_global_names().map(ToOwned::to_owned).collect();
+		Self(global_names)
+	}
+}
+
+/// A snapshot of a global variables values. This snapshot can be later used for restoring the
+/// values to the preserved state.
+///
+/// Technically, a snapshot stores only values of mutable global variables. This is because
+/// immutable global variables always have the same values.
+///
+/// We take it from an instance rather from a module because the start function could potentially
+/// change any of the mutable global values.
+pub struct GlobalsSnapshot<Global>(Vec<SavedValue<Global>>);
+
+impl<Global> GlobalsSnapshot<Global> {
+	/// Take a snapshot of global variables for a given instance.
+	///
+	/// # Panics
+	///
+	/// This function panics if the instance doesn't correspond to the module from which the
+	/// [`ExposedMutableGlobalsSet`] was collected.
+	pub fn take<Instance>(
+		mutable_globals: &ExposedMutableGlobalsSet,
+		instance: &mut Instance,
+	) -> Self
+	where
+		Instance: InstanceGlobals<Global = Global>,
+	{
+		let global_names = &mutable_globals.0;
+		let mut saved_values = Vec::with_capacity(global_names.len());
+
+		for global_name in global_names {
+			let handle = instance.get_global(global_name);
+			let value = instance.get_global_value(&handle);
+			saved_values.push(SavedValue { handle, value });
+		}
+
+		Self(saved_values)
+	}
+
+	/// Apply the snapshot to the given instance.
+	///
+	/// This instance must be the same that was used for creation of this snapshot.
+	pub fn apply<Instance>(&self, instance: &mut Instance)
+	where
+		Instance: InstanceGlobals<Global = Global>,
+	{
+		for saved_value in &self.0 {
+			instance.set_global_value(&saved_value.handle, saved_value.value);
+		}
+	}
+}
diff --git a/substrate/client/executor/common/src/runtime_blob/mod.rs b/substrate/client/executor/common/src/runtime_blob/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..07a0945cc2b668b1c9737b171bd3dc4707903d11
--- /dev/null
+++ b/substrate/client/executor/common/src/runtime_blob/mod.rs
@@ -0,0 +1,55 @@
+// 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/>.
+
+//! This module allows for inspection and instrumentation, i.e. modifying the module to alter it's
+//! structure or behavior, of a wasm module.
+//!
+//! ## Instrumentation
+//!
+//! In ideal world, there would be no instrumentation. However, in the real world the execution
+//! engines we use are somewhat limited in their APIs or abilities.
+//!
+//! To give you some examples:
+//!
+//!   We need to reset the globals because when we
+//!   execute the Substrate Runtime, we do not drop and create the instance anew, instead
+//!   we restore some selected parts of the state.
+//!
+//! - stack depth metering can be performed via instrumentation or deferred to the engine and say be
+//!   added directly in machine code. Implementing this in machine code is rather cumbersome so
+//!   instrumentation looks like a good solution.
+//!
+//!   Stack depth metering is needed to make a wasm blob
+//!   execution deterministic, which in turn is needed by the Parachain Validation Function in
+//! Polkadot.
+//!
+//! ## Inspection
+//!
+//! Inspection of a wasm module may be needed to extract some useful information, such as to extract
+//! data segment snapshot, which is helpful for quickly restoring the initial state of instances.
+//! Inspection can be also useful to prove that a wasm module possesses some properties, such as,
+//! is free of any floating point operations, which is a useful step towards making instances
+//! produced from such a module deterministic.
+
+mod data_segments_snapshot;
+mod globals_snapshot;
+mod runtime_blob;
+
+pub use data_segments_snapshot::DataSegmentsSnapshot;
+pub use globals_snapshot::{ExposedMutableGlobalsSet, GlobalsSnapshot, InstanceGlobals};
+pub use runtime_blob::RuntimeBlob;
diff --git a/substrate/client/executor/common/src/runtime_blob/runtime_blob.rs b/substrate/client/executor/common/src/runtime_blob/runtime_blob.rs
new file mode 100644
index 0000000000000000000000000000000000000000..24dc7e393a4bccd1806f4ce5b6dccacaeeac8302
--- /dev/null
+++ b/substrate/client/executor/common/src/runtime_blob/runtime_blob.rs
@@ -0,0 +1,221 @@
+// 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::{error::WasmError, wasm_runtime::HeapAllocStrategy};
+use wasm_instrument::{
+	export_mutable_globals,
+	parity_wasm::elements::{
+		deserialize_buffer, serialize, DataSegment, ExportEntry, External, Internal, MemorySection,
+		MemoryType, Module, Section,
+	},
+};
+
+/// A bunch of information collected from a WebAssembly module.
+#[derive(Clone)]
+pub struct RuntimeBlob {
+	raw_module: Module,
+}
+
+impl RuntimeBlob {
+	/// Create `RuntimeBlob` from the given wasm code. Will attempt to decompress the code before
+	/// deserializing it.
+	///
+	/// See [`sp_maybe_compressed_blob`] for details about decompression.
+	pub fn uncompress_if_needed(wasm_code: &[u8]) -> Result<Self, WasmError> {
+		use sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT;
+		let wasm_code = sp_maybe_compressed_blob::decompress(wasm_code, CODE_BLOB_BOMB_LIMIT)
+			.map_err(|e| WasmError::Other(format!("Decompression error: {:?}", e)))?;
+		Self::new(&wasm_code)
+	}
+
+	/// Create `RuntimeBlob` from the given wasm code.
+	///
+	/// Returns `Err` if the wasm code cannot be deserialized.
+	pub fn new(wasm_code: &[u8]) -> Result<Self, WasmError> {
+		let raw_module: Module = deserialize_buffer(wasm_code)
+			.map_err(|e| WasmError::Other(format!("cannot deserialize module: {:?}", e)))?;
+		Ok(Self { raw_module })
+	}
+
+	/// Extract the data segments from the given wasm code.
+	pub(super) fn data_segments(&self) -> Vec<DataSegment> {
+		self.raw_module.data_section().map(|ds| ds.entries()).unwrap_or(&[]).to_vec()
+	}
+
+	/// The number of globals defined in locally in this module.
+	pub fn declared_globals_count(&self) -> u32 {
+		self.raw_module
+			.global_section()
+			.map(|gs| gs.entries().len() as u32)
+			.unwrap_or(0)
+	}
+
+	/// The number of imports of globals.
+	pub fn imported_globals_count(&self) -> u32 {
+		self.raw_module.import_section().map(|is| is.globals() as u32).unwrap_or(0)
+	}
+
+	/// Perform an instrumentation that makes sure that the mutable globals are exported.
+	pub fn expose_mutable_globals(&mut self) {
+		export_mutable_globals(&mut self.raw_module, "exported_internal_global");
+	}
+
+	/// Run a pass that instrument this module so as to introduce a deterministic stack height
+	/// limit.
+	///
+	/// It will introduce a global mutable counter. The instrumentation will increase the counter
+	/// according to the "cost" of the callee. If the cost exceeds the `stack_depth_limit` constant,
+	/// the instrumentation will trap. The counter will be decreased as soon as the the callee
+	/// returns.
+	///
+	/// The stack cost of a function is computed based on how much locals there are and the maximum
+	/// depth of the wasm operand stack.
+	pub fn inject_stack_depth_metering(self, stack_depth_limit: u32) -> Result<Self, WasmError> {
+		let injected_module =
+			wasm_instrument::inject_stack_limiter(self.raw_module, stack_depth_limit).map_err(
+				|e| WasmError::Other(format!("cannot inject the stack limiter: {:?}", e)),
+			)?;
+
+		Ok(Self { raw_module: injected_module })
+	}
+
+	/// Perform an instrumentation that makes sure that a specific function `entry_point` is
+	/// exported
+	pub fn entry_point_exists(&self, entry_point: &str) -> bool {
+		self.raw_module
+			.export_section()
+			.map(|e| {
+				e.entries().iter().any(|e| {
+					matches!(e.internal(), Internal::Function(_)) && e.field() == entry_point
+				})
+			})
+			.unwrap_or_default()
+	}
+
+	/// Converts a WASM memory import into a memory section and exports it.
+	///
+	/// Does nothing if there's no memory import.
+	///
+	/// May return an error in case the WASM module is invalid.
+	pub fn convert_memory_import_into_export(&mut self) -> Result<(), WasmError> {
+		let import_section = match self.raw_module.import_section_mut() {
+			Some(import_section) => import_section,
+			None => return Ok(()),
+		};
+
+		let import_entries = import_section.entries_mut();
+		for index in 0..import_entries.len() {
+			let entry = &import_entries[index];
+			let memory_ty = match entry.external() {
+				External::Memory(memory_ty) => *memory_ty,
+				_ => continue,
+			};
+
+			let memory_name = entry.field().to_owned();
+			import_entries.remove(index);
+
+			self.raw_module
+				.insert_section(Section::Memory(MemorySection::with_entries(vec![memory_ty])))
+				.map_err(|error| {
+					WasmError::Other(format!(
+					"can't convert a memory import into an export: failed to insert a new memory section: {}",
+					error
+				))
+				})?;
+
+			if self.raw_module.export_section_mut().is_none() {
+				// A module without an export section is somewhat unrealistic, but let's do this
+				// just in case to cover all of our bases.
+				self.raw_module
+					.insert_section(Section::Export(Default::default()))
+					.expect("an export section can be always inserted if it doesn't exist; qed");
+			}
+			self.raw_module
+				.export_section_mut()
+				.expect("export section already existed or we just added it above, so it always exists; qed")
+				.entries_mut()
+				.push(ExportEntry::new(memory_name, Internal::Memory(0)));
+
+			break
+		}
+
+		Ok(())
+	}
+
+	/// Modifies the blob's memory section according to the given `heap_alloc_strategy`.
+	///
+	/// Will return an error in case there is no memory section present,
+	/// or if the memory section is empty.
+	pub fn setup_memory_according_to_heap_alloc_strategy(
+		&mut self,
+		heap_alloc_strategy: HeapAllocStrategy,
+	) -> Result<(), WasmError> {
+		let memory_section = self
+			.raw_module
+			.memory_section_mut()
+			.ok_or_else(|| WasmError::Other("no memory section found".into()))?;
+
+		if memory_section.entries().is_empty() {
+			return Err(WasmError::Other("memory section is empty".into()))
+		}
+		for memory_ty in memory_section.entries_mut() {
+			let initial = memory_ty.limits().initial();
+			let (min, max) = match heap_alloc_strategy {
+				HeapAllocStrategy::Dynamic { maximum_pages } => {
+					// Ensure `initial <= maximum_pages`
+					(maximum_pages.map(|m| m.min(initial)).unwrap_or(initial), maximum_pages)
+				},
+				HeapAllocStrategy::Static { extra_pages } => {
+					let pages = initial.saturating_add(extra_pages);
+					(pages, Some(pages))
+				},
+			};
+			*memory_ty = MemoryType::new(min, max);
+		}
+		Ok(())
+	}
+
+	/// Returns an iterator of all globals which were exported by [`expose_mutable_globals`].
+	pub(super) fn exported_internal_global_names(&self) -> impl Iterator<Item = &str> {
+		let exports = self.raw_module.export_section().map(|es| es.entries()).unwrap_or(&[]);
+		exports.iter().filter_map(|export| match export.internal() {
+			Internal::Global(_) if export.field().starts_with("exported_internal_global") =>
+				Some(export.field()),
+			_ => None,
+		})
+	}
+
+	/// Scans the wasm blob for the first section with the name that matches the given. Returns the
+	/// contents of the custom section if found or `None` otherwise.
+	pub fn custom_section_contents(&self, section_name: &str) -> Option<&[u8]> {
+		self.raw_module
+			.custom_sections()
+			.find(|cs| cs.name() == section_name)
+			.map(|cs| cs.payload())
+	}
+
+	/// Consumes this runtime blob and serializes it.
+	pub fn serialize(self) -> Vec<u8> {
+		serialize(self.raw_module).expect("serializing into a vec should succeed; qed")
+	}
+
+	/// Destructure this structure into the underlying parity-wasm Module.
+	pub fn into_inner(self) -> Module {
+		self.raw_module
+	}
+}
diff --git a/substrate/client/executor/common/src/util.rs b/substrate/client/executor/common/src/util.rs
new file mode 100644
index 0000000000000000000000000000000000000000..34967f86595d660cb8806402aa9ab22c66c6d7b7
--- /dev/null
+++ b/substrate/client/executor/common/src/util.rs
@@ -0,0 +1,48 @@
+// 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/>.
+
+//! Utilities used by all backends
+
+use crate::error::Result;
+use sp_wasm_interface::Pointer;
+use std::ops::Range;
+
+/// Construct a range from an offset to a data length after the offset.
+/// Returns None if the end of the range would exceed some maximum offset.
+pub fn checked_range(offset: usize, len: usize, max: usize) -> Option<Range<usize>> {
+	let end = offset.checked_add(len)?;
+	(end <= max).then(|| offset..end)
+}
+
+/// Provides safe memory access interface using an external buffer
+pub trait MemoryTransfer {
+	/// Read data from a slice of memory into a newly allocated buffer.
+	///
+	/// Returns an error if the read would go out of the memory bounds.
+	fn read(&self, source_addr: Pointer<u8>, size: usize) -> Result<Vec<u8>>;
+
+	/// Read data from a slice of memory into a destination buffer.
+	///
+	/// Returns an error if the read would go out of the memory bounds.
+	fn read_into(&self, source_addr: Pointer<u8>, destination: &mut [u8]) -> Result<()>;
+
+	/// Write data to a slice of memory.
+	///
+	/// Returns an error if the write would go out of the memory bounds.
+	fn write_from(&self, dest_addr: Pointer<u8>, source: &[u8]) -> Result<()>;
+}
diff --git a/substrate/client/executor/common/src/wasm_runtime.rs b/substrate/client/executor/common/src/wasm_runtime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5dac77e59fa7488e14fe35059f465ffce9b6407e
--- /dev/null
+++ b/substrate/client/executor/common/src/wasm_runtime.rs
@@ -0,0 +1,154 @@
+// 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/>.
+
+//! Definitions for a wasm runtime.
+
+use crate::error::Error;
+use sp_wasm_interface::Value;
+
+pub use sc_allocator::AllocationStats;
+
+/// Default heap allocation strategy.
+pub const DEFAULT_HEAP_ALLOC_STRATEGY: HeapAllocStrategy =
+	HeapAllocStrategy::Static { extra_pages: DEFAULT_HEAP_ALLOC_PAGES };
+
+/// Default heap allocation pages.
+pub const DEFAULT_HEAP_ALLOC_PAGES: u32 = 2048;
+
+/// A method to be used to find the entrypoint when calling into the runtime
+///
+/// Contains variants on how to resolve wasm function that will be invoked.
+pub enum InvokeMethod<'a> {
+	/// Call function exported with this name.
+	///
+	/// Located function should have (u32, u32) -> u64 signature.
+	Export(&'a str),
+	/// Call a function found in the exported table found under the given index.
+	///
+	/// Located function should have (u32, u32) -> u64 signature.
+	Table(u32),
+	/// Call function by reference from table through a wrapper.
+	///
+	/// Invoked function (`dispatcher_ref`) function
+	/// should have (u32, u32, u32) -> u64 signature.
+	///
+	/// `func` will be passed to the invoked function as a first argument.
+	TableWithWrapper {
+		/// Wrapper for the call.
+		///
+		/// Function pointer, index into runtime exported table.
+		dispatcher_ref: u32,
+		/// Extra argument for dispatch.
+		///
+		/// Common usage would be to use it as an actual wasm function pointer
+		/// that should be invoked, but can be used as any extra argument on the
+		/// callee side.
+		///
+		/// This is typically generated and invoked by the runtime itself.
+		func: u32,
+	},
+}
+
+impl<'a> From<&'a str> for InvokeMethod<'a> {
+	fn from(val: &'a str) -> InvokeMethod<'a> {
+		InvokeMethod::Export(val)
+	}
+}
+
+/// A trait that defines an abstract WASM runtime module.
+///
+/// This can be implemented by an execution engine.
+pub trait WasmModule: Sync + Send {
+	/// Create a new instance.
+	fn new_instance(&self) -> Result<Box<dyn WasmInstance>, Error>;
+}
+
+/// A trait that defines an abstract wasm module instance.
+///
+/// This can be implemented by an execution engine.
+pub trait WasmInstance: Send {
+	/// Call a method on this WASM instance.
+	///
+	/// Before execution, instance is reset.
+	///
+	/// Returns the encoded result on success.
+	fn call(&mut self, method: InvokeMethod, data: &[u8]) -> Result<Vec<u8>, Error> {
+		self.call_with_allocation_stats(method, data).0
+	}
+
+	/// Call a method on this WASM instance.
+	///
+	/// Before execution, instance is reset.
+	///
+	/// Returns the encoded result on success.
+	fn call_with_allocation_stats(
+		&mut self,
+		method: InvokeMethod,
+		data: &[u8],
+	) -> (Result<Vec<u8>, Error>, Option<AllocationStats>);
+
+	/// Call an exported method on this WASM instance.
+	///
+	/// Before execution, instance is reset.
+	///
+	/// Returns the encoded result on success.
+	fn call_export(&mut self, method: &str, data: &[u8]) -> Result<Vec<u8>, Error> {
+		self.call(method.into(), data)
+	}
+
+	/// Get the value from a global with the given `name`.
+	///
+	/// This method is only suitable for getting immutable globals.
+	fn get_global_const(&mut self, name: &str) -> Result<Option<Value>, Error>;
+
+	/// **Testing Only**. This function returns the base address of the linear memory.
+	///
+	/// This is meant to be the starting address of the memory mapped area for the linear memory.
+	///
+	/// This function is intended only for a specific test that measures physical memory
+	/// consumption.
+	fn linear_memory_base_ptr(&self) -> Option<*const u8> {
+		None
+	}
+}
+
+/// Defines the heap pages allocation strategy the wasm runtime should use.
+///
+/// A heap page is defined as 64KiB of memory.
+#[derive(Debug, Copy, Clone, PartialEq, Hash, Eq)]
+pub enum HeapAllocStrategy {
+	/// Allocate a static number of heap pages.
+	///
+	/// The total number of allocated heap pages is the initial number of heap pages requested by
+	/// the wasm file plus the `extra_pages`.
+	Static {
+		/// The number of pages that will be added on top of the initial heap pages requested by
+		/// the wasm file.
+		extra_pages: u32,
+	},
+	/// Allocate the initial heap pages as requested by the wasm file and then allow it to grow
+	/// dynamically.
+	Dynamic {
+		/// The absolute maximum size of the linear memory (in pages).
+		///
+		/// When `Some(_)` the linear memory will be allowed to grow up to this limit.
+		/// When `None` the linear memory will be allowed to grow up to the maximum limit supported
+		/// by WASM (4GB).
+		maximum_pages: Option<u32>,
+	},
+}
diff --git a/substrate/client/executor/runtime-test/Cargo.toml b/substrate/client/executor/runtime-test/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..628297ade6b7456a6bbbd9c6be8c770872486258
--- /dev/null
+++ b/substrate/client/executor/runtime-test/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "sc-runtime-test"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+build = "build.rs"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, features = ["improved_panic_error_reporting"], path = "../../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../../../primitives/runtime-interface" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[build-dependencies]
+substrate-wasm-builder = { version = "5.0.0-dev", path = "../../../utils/wasm-builder", optional = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime-interface/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"substrate-wasm-builder",
+]
diff --git a/substrate/client/executor/runtime-test/build.rs b/substrate/client/executor/runtime-test/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..088c93110d85505f615b118de2fa6901fc0bbf95
--- /dev/null
+++ b/substrate/client/executor/runtime-test/build.rs
@@ -0,0 +1,43 @@
+// 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/>.
+
+fn main() {
+	// regular build
+	#[cfg(feature = "std")]
+	{
+		substrate_wasm_builder::WasmBuilder::new()
+			.with_current_project()
+			.export_heap_base()
+			.import_memory()
+			.disable_runtime_version_section_check()
+			.build();
+	}
+
+	// and building with tracing activated
+	#[cfg(feature = "std")]
+	{
+		substrate_wasm_builder::WasmBuilder::new()
+			.with_current_project()
+			.export_heap_base()
+			.import_memory()
+			.set_file_name("wasm_binary_with_tracing.rs")
+			.append_to_rust_flags(r#"--cfg feature="with-tracing""#)
+			.disable_runtime_version_section_check()
+			.build();
+	}
+}
diff --git a/substrate/client/executor/runtime-test/src/lib.rs b/substrate/client/executor/runtime-test/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2bd2aeeb606ebed10a50743d13cccb6aa08abe39
--- /dev/null
+++ b/substrate/client/executor/runtime-test/src/lib.rs
@@ -0,0 +1,398 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+// Make the WASM binary available.
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+/// Wasm binary unwrapped. If built with `SKIP_WASM_BUILD`, the function panics.
+#[cfg(feature = "std")]
+pub fn wasm_binary_unwrap() -> &'static [u8] {
+	WASM_BINARY.expect(
+		"Development wasm binary is not available. Testing is only supported with the flag \
+		 disabled.",
+	)
+}
+
+#[cfg(not(feature = "std"))]
+use sp_std::{vec, vec::Vec};
+
+#[cfg(not(feature = "std"))]
+use sp_core::{ed25519, sr25519};
+#[cfg(not(feature = "std"))]
+use sp_io::{
+	crypto::{ed25519_verify, sr25519_verify},
+	hashing::{blake2_128, blake2_256, sha2_256, twox_128, twox_256},
+	storage, wasm_tracing,
+};
+#[cfg(not(feature = "std"))]
+use sp_runtime::{
+	print,
+	traits::{BlakeTwo256, Hash},
+};
+
+extern "C" {
+	#[allow(dead_code)]
+	fn missing_external();
+
+	#[allow(dead_code)]
+	fn yet_another_missing_external();
+}
+
+#[cfg(not(feature = "std"))]
+/// The size of a WASM page in bytes.
+const WASM_PAGE_SIZE: usize = 65536;
+
+#[cfg(not(feature = "std"))]
+/// Mutable static variables should be always observed to have
+/// the initialized value at the start of a runtime call.
+static mut MUTABLE_STATIC: u64 = 32;
+
+#[cfg(not(feature = "std"))]
+/// This is similar to `MUTABLE_STATIC`. The tests need `MUTABLE_STATIC` for testing that
+/// non-null initialization data is properly restored during instance reusing.
+///
+/// `MUTABLE_STATIC_BSS` on the other hand focuses on the zeroed data. This is important since there
+/// may be differences in handling zeroed and non-zeroed data.
+static mut MUTABLE_STATIC_BSS: u64 = 0;
+
+sp_core::wasm_export_functions! {
+	fn test_calling_missing_external() {
+		unsafe { missing_external() }
+	}
+
+	fn test_calling_yet_another_missing_external() {
+		unsafe { yet_another_missing_external() }
+	}
+
+	fn test_data_in(input: Vec<u8>) -> Vec<u8> {
+		print("set_storage");
+		storage::set(b"input", &input);
+
+		print("storage");
+		let foo = storage::get(b"foo").unwrap();
+
+		print("set_storage");
+		storage::set(b"baz", &foo);
+
+		print("finished!");
+		b"all ok!".to_vec()
+	}
+
+	fn test_clear_prefix(input: Vec<u8>) -> Vec<u8> {
+		storage::clear_prefix(&input, None);
+		b"all ok!".to_vec()
+	}
+
+	fn test_empty_return() {}
+
+	fn test_dirty_plenty_memory(heap_base: u32, heap_pages: u32) {
+		// This piece of code will dirty multiple pages of memory. The number of pages is given by
+		// the `heap_pages`. It's unit is a wasm page (64KiB). The first page to be cleared
+		// is a wasm page that that follows the one that holds the `heap_base` address.
+		//
+		// This function dirties the **host** pages. I.e. we dirty 4KiB at a time and it will take
+		// 16 writes to process a single wasm page.
+
+		let heap_ptr = heap_base as usize;
+
+		// Find the next wasm page boundary.
+		let heap_ptr = round_up_to(heap_ptr, WASM_PAGE_SIZE);
+
+		// Make it an actual pointer
+		let heap_ptr = heap_ptr as *mut u8;
+
+		// Traverse the host pages and make each one dirty
+		let host_pages = heap_pages as usize * 16;
+		for i in 0..host_pages {
+			unsafe {
+				// technically this is an UB, but there is no way Rust can find this out.
+				heap_ptr.add(i * 4096).write(0);
+			}
+		}
+
+		fn round_up_to(n: usize, divisor: usize) -> usize {
+			(n + divisor - 1) / divisor
+		}
+	}
+
+	fn test_allocate_vec(size: u32) -> Vec<u8> {
+		Vec::with_capacity(size as usize)
+	}
+
+	fn test_fp_f32add(a: [u8; 4], b: [u8; 4]) -> [u8; 4] {
+		let a = f32::from_le_bytes(a);
+		let b = f32::from_le_bytes(b);
+		f32::to_le_bytes(a + b)
+	}
+
+	fn test_panic() { panic!("test panic") }
+
+	fn test_conditional_panic(input: Vec<u8>) -> Vec<u8> {
+		if input.len() > 0 {
+			panic!("test panic")
+		}
+
+		input
+	}
+
+	fn test_blake2_256(input: Vec<u8>) -> Vec<u8> {
+		blake2_256(&input).to_vec()
+	}
+
+	fn test_blake2_128(input: Vec<u8>) -> Vec<u8> {
+		blake2_128(&input).to_vec()
+	}
+
+	fn test_sha2_256(input: Vec<u8>) -> Vec<u8> {
+		sha2_256(&input).to_vec()
+	}
+
+	fn test_twox_256(input: Vec<u8>) -> Vec<u8> {
+		twox_256(&input).to_vec()
+	}
+
+	fn test_twox_128(input: Vec<u8>) -> Vec<u8> {
+		twox_128(&input).to_vec()
+	}
+
+	fn test_ed25519_verify(input: Vec<u8>) -> bool {
+		let mut pubkey = [0; 32];
+		let mut sig = [0; 64];
+
+		pubkey.copy_from_slice(&input[0..32]);
+		sig.copy_from_slice(&input[32..96]);
+
+		let msg = b"all ok!";
+		ed25519_verify(&ed25519::Signature(sig), &msg[..], &ed25519::Public(pubkey))
+	}
+
+	fn test_sr25519_verify(input: Vec<u8>) -> bool {
+		let mut pubkey = [0; 32];
+		let mut sig = [0; 64];
+
+		pubkey.copy_from_slice(&input[0..32]);
+		sig.copy_from_slice(&input[32..96]);
+
+		let msg = b"all ok!";
+		sr25519_verify(&sr25519::Signature(sig), &msg[..], &sr25519::Public(pubkey))
+	}
+
+	fn test_ordered_trie_root() -> Vec<u8> {
+		BlakeTwo256::ordered_trie_root(
+			vec![
+				b"zero"[..].into(),
+				b"one"[..].into(),
+				b"two"[..].into(),
+			],
+			sp_core::storage::StateVersion::V1,
+		).as_ref().to_vec()
+	}
+
+	fn test_offchain_index_set() {
+		sp_io::offchain_index::set(b"k", b"v");
+	}
+
+	fn test_offchain_local_storage() -> bool {
+		let kind = sp_core::offchain::StorageKind::PERSISTENT;
+		assert_eq!(sp_io::offchain::local_storage_get(kind, b"test"), None);
+		sp_io::offchain::local_storage_set(kind, b"test", b"asd");
+		assert_eq!(sp_io::offchain::local_storage_get(kind, b"test"), Some(b"asd".to_vec()));
+
+		let res = sp_io::offchain::local_storage_compare_and_set(
+			kind,
+			b"test",
+			Some(b"asd".to_vec()),
+			b"",
+		);
+		assert_eq!(sp_io::offchain::local_storage_get(kind, b"test"), Some(b"".to_vec()));
+		res
+	}
+
+	fn test_offchain_local_storage_with_none() {
+		let kind = sp_core::offchain::StorageKind::PERSISTENT;
+		assert_eq!(sp_io::offchain::local_storage_get(kind, b"test"), None);
+
+		let res = sp_io::offchain::local_storage_compare_and_set(kind, b"test", None, b"value");
+		assert_eq!(res, true);
+		assert_eq!(sp_io::offchain::local_storage_get(kind, b"test"), Some(b"value".to_vec()));
+	}
+
+	fn test_offchain_http() -> bool {
+		use sp_core::offchain::HttpRequestStatus;
+		let run = || -> Option<()> {
+			let id = sp_io::offchain::http_request_start(
+				"POST",
+				"http://localhost:12345",
+				&[],
+			).ok()?;
+			sp_io::offchain::http_request_add_header(id, "X-Auth", "test").ok()?;
+			sp_io::offchain::http_request_write_body(id, &[1, 2, 3, 4], None).ok()?;
+			sp_io::offchain::http_request_write_body(id, &[], None).ok()?;
+			let status = sp_io::offchain::http_response_wait(&[id], None);
+			assert!(status == vec![HttpRequestStatus::Finished(200)], "Expected Finished(200) status.");
+			let headers = sp_io::offchain::http_response_headers(id);
+			assert_eq!(headers, vec![(b"X-Auth".to_vec(), b"hello".to_vec())]);
+			let mut buffer = vec![0; 64];
+			let read = sp_io::offchain::http_response_read_body(id, &mut buffer, None).ok()?;
+			assert_eq!(read, 3);
+			assert_eq!(&buffer[0..read as usize], &[1, 2, 3]);
+			let read = sp_io::offchain::http_response_read_body(id, &mut buffer, None).ok()?;
+			assert_eq!(read, 0);
+
+			Some(())
+		};
+
+		run().is_some()
+	}
+
+	fn test_enter_span() -> u64 {
+		wasm_tracing::enter_span(Default::default())
+	}
+
+	fn test_exit_span(span_id: u64) {
+		wasm_tracing::exit(span_id)
+	}
+
+	fn test_nested_spans() {
+		sp_io::init_tracing();
+		let span_id = wasm_tracing::enter_span(Default::default());
+		{
+			sp_io::init_tracing();
+			let span_id = wasm_tracing::enter_span(Default::default());
+			wasm_tracing::exit(span_id);
+		}
+		wasm_tracing::exit(span_id);
+	}
+
+	fn returns_mutable_static() -> u64 {
+		unsafe {
+			MUTABLE_STATIC += 1;
+			MUTABLE_STATIC
+		}
+	}
+
+	fn returns_mutable_static_bss() -> u64 {
+		unsafe {
+			MUTABLE_STATIC_BSS += 1;
+			MUTABLE_STATIC_BSS
+		}
+	}
+
+	fn allocates_huge_stack_array(trap: bool) -> Vec<u8> {
+		// Allocate a stack frame that is approx. 75% of the stack (assuming it is 1MB).
+		// This will just decrease (stacks in wasm32-u-u grow downwards) the stack
+		// pointer. This won't trap on the current compilers.
+		let mut data = [0u8; 1024 * 768];
+
+		// Then make sure we actually write something to it.
+		//
+		// If:
+		// 1. the stack area is placed at the beginning of the linear memory space, and
+		// 2. the stack pointer points to out-of-bounds area, and
+		// 3. a write is performed around the current stack pointer.
+		//
+		// then a trap should happen.
+		//
+		for (i, v) in data.iter_mut().enumerate() {
+			*v = i as u8; // deliberate truncation
+		}
+
+		if trap {
+			// There is a small chance of this to be pulled up in theory. In practice
+			// the probability of that is rather low.
+			panic!()
+		}
+
+		data.to_vec()
+	}
+
+	// Check that the heap at `heap_base + offset` don't contains the test message.
+	// After the check succeeds the test message is written into the heap.
+	//
+	// It is expected that the given pointer is not allocated.
+	fn check_and_set_in_heap(heap_base: u32, offset: u32) {
+		let test_message = b"Hello invalid heap memory";
+		let ptr = (heap_base + offset) as *mut u8;
+
+		let message_slice = unsafe { sp_std::slice::from_raw_parts_mut(ptr, test_message.len()) };
+
+		assert_ne!(test_message, message_slice);
+		message_slice.copy_from_slice(test_message);
+	}
+
+	fn test_return_i8() -> i8 {
+		-66
+	}
+
+	fn test_take_i8(value: i8) {
+		assert_eq!(value, -66);
+	}
+
+	fn allocate_two_gigabyte() -> u32 {
+		let mut data = Vec::new();
+		for _ in 0..205 {
+			data.push(Vec::<u8>::with_capacity(10 * 1024 * 1024));
+		}
+
+		data.iter().map(|d| d.capacity() as u32).sum()
+	}
+
+	fn test_abort_on_panic() {
+		sp_io::panic_handler::abort_on_panic("test_abort_on_panic called");
+	}
+
+	fn test_unreachable_intrinsic() {
+		core::arch::wasm32::unreachable()
+	}
+
+	fn test_return_value() -> u64 {
+		// Mainly a test that the macro is working when we have a return statement here.
+		return 1234;
+	}
+}
+
+// Tests that check output validity. We explicitly return the ptr and len, so we avoid using the
+// `wasm_export_functions` macro.
+mod output_validity {
+	#[cfg(not(feature = "std"))]
+	use super::WASM_PAGE_SIZE;
+
+	#[cfg(not(feature = "std"))]
+	use sp_runtime_interface::pack_ptr_and_len;
+
+	// Returns a huge len. It should result in an error, and not an allocation.
+	#[no_mangle]
+	#[cfg(not(feature = "std"))]
+	pub extern "C" fn test_return_huge_len(_params: *const u8, _len: usize) -> u64 {
+		pack_ptr_and_len(0, u32::MAX)
+	}
+
+	// Returns an offset right before the edge of the wasm memory boundary. It should succeed.
+	#[no_mangle]
+	#[cfg(not(feature = "std"))]
+	pub extern "C" fn test_return_max_memory_offset(_params: *const u8, _len: usize) -> u64 {
+		let output_ptr = (core::arch::wasm32::memory_size(0) * WASM_PAGE_SIZE) as u32 - 1;
+		let ptr = output_ptr as *mut u8;
+		unsafe {
+			ptr.write(u8::MAX);
+		}
+		pack_ptr_and_len(output_ptr, 1)
+	}
+
+	// Returns an offset right after the edge of the wasm memory boundary. It should fail.
+	#[no_mangle]
+	#[cfg(not(feature = "std"))]
+	pub extern "C" fn test_return_max_memory_offset_plus_one(
+		_params: *const u8,
+		_len: usize,
+	) -> u64 {
+		pack_ptr_and_len((core::arch::wasm32::memory_size(0) * WASM_PAGE_SIZE) as u32, 1)
+	}
+
+	// Returns an output that overflows the u32 range. It should result in an error.
+	#[no_mangle]
+	#[cfg(not(feature = "std"))]
+	pub extern "C" fn test_return_overflow(_params: *const u8, _len: usize) -> u64 {
+		pack_ptr_and_len(u32::MAX, 1)
+	}
+}
diff --git a/substrate/client/executor/src/executor.rs b/substrate/client/executor/src/executor.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c292a83da0895e670e203edbad24cf592164446
--- /dev/null
+++ b/substrate/client/executor/src/executor.rs
@@ -0,0 +1,778 @@
+// 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::{
+	error::{Error, Result},
+	wasm_runtime::{RuntimeCache, WasmExecutionMethod},
+	RuntimeVersionOf,
+};
+
+use std::{
+	marker::PhantomData,
+	panic::{AssertUnwindSafe, UnwindSafe},
+	path::PathBuf,
+	sync::Arc,
+};
+
+use codec::Encode;
+use sc_executor_common::{
+	runtime_blob::RuntimeBlob,
+	wasm_runtime::{
+		AllocationStats, HeapAllocStrategy, WasmInstance, WasmModule, DEFAULT_HEAP_ALLOC_STRATEGY,
+	},
+};
+use sp_core::traits::{CallContext, CodeExecutor, Externalities, RuntimeCode};
+use sp_version::{GetNativeVersion, NativeVersion, RuntimeVersion};
+use sp_wasm_interface::{ExtendedHostFunctions, HostFunctions};
+
+/// Set up the externalities and safe calling environment to execute runtime calls.
+///
+/// If the inner closure panics, it will be caught and return an error.
+pub fn with_externalities_safe<F, U>(ext: &mut dyn Externalities, f: F) -> Result<U>
+where
+	F: UnwindSafe + FnOnce() -> U,
+{
+	sp_externalities::set_and_run_with_externalities(ext, move || {
+		// Substrate uses custom panic hook that terminates process on panic. Disable
+		// termination for the native call.
+		let _guard = sp_panic_handler::AbortGuard::force_unwind();
+		std::panic::catch_unwind(f).map_err(|e| {
+			if let Some(err) = e.downcast_ref::<String>() {
+				Error::RuntimePanicked(err.clone())
+			} else if let Some(err) = e.downcast_ref::<&'static str>() {
+				Error::RuntimePanicked(err.to_string())
+			} else {
+				Error::RuntimePanicked("Unknown panic".into())
+			}
+		})
+	})
+}
+
+/// Delegate for dispatching a CodeExecutor call.
+///
+/// By dispatching we mean that we execute a runtime function specified by it's name.
+pub trait NativeExecutionDispatch: Send + Sync {
+	/// Host functions for custom runtime interfaces that should be callable from within the runtime
+	/// besides the default Substrate runtime interfaces.
+	type ExtendHostFunctions: HostFunctions;
+
+	/// Dispatch a method in the runtime.
+	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>>;
+
+	/// Provide native runtime version.
+	fn native_version() -> NativeVersion;
+}
+
+fn unwrap_heap_pages(pages: Option<HeapAllocStrategy>) -> HeapAllocStrategy {
+	pages.unwrap_or_else(|| DEFAULT_HEAP_ALLOC_STRATEGY)
+}
+
+/// Builder for creating a [`WasmExecutor`] instance.
+pub struct WasmExecutorBuilder<H> {
+	_phantom: PhantomData<H>,
+	method: WasmExecutionMethod,
+	onchain_heap_alloc_strategy: Option<HeapAllocStrategy>,
+	offchain_heap_alloc_strategy: Option<HeapAllocStrategy>,
+	ignore_onchain_heap_pages: bool,
+	max_runtime_instances: usize,
+	cache_path: Option<PathBuf>,
+	allow_missing_host_functions: bool,
+	runtime_cache_size: u8,
+}
+
+impl<H> WasmExecutorBuilder<H> {
+	/// Create a new instance of `Self`
+	///
+	/// - `method`: The wasm execution method that should be used by the executor.
+	pub fn new() -> Self {
+		Self {
+			_phantom: PhantomData,
+			method: WasmExecutionMethod::default(),
+			onchain_heap_alloc_strategy: None,
+			offchain_heap_alloc_strategy: None,
+			ignore_onchain_heap_pages: false,
+			max_runtime_instances: 2,
+			runtime_cache_size: 4,
+			allow_missing_host_functions: false,
+			cache_path: None,
+		}
+	}
+
+	/// Create the wasm executor with execution method that should be used by the executor.
+	pub fn with_execution_method(mut self, method: WasmExecutionMethod) -> Self {
+		self.method = method;
+		self
+	}
+
+	/// Create the wasm executor with the given number of `heap_alloc_strategy` for onchain runtime
+	/// calls.
+	pub fn with_onchain_heap_alloc_strategy(
+		mut self,
+		heap_alloc_strategy: HeapAllocStrategy,
+	) -> Self {
+		self.onchain_heap_alloc_strategy = Some(heap_alloc_strategy);
+		self
+	}
+
+	/// Create the wasm executor with the given number of `heap_alloc_strategy` for offchain runtime
+	/// calls.
+	pub fn with_offchain_heap_alloc_strategy(
+		mut self,
+		heap_alloc_strategy: HeapAllocStrategy,
+	) -> Self {
+		self.offchain_heap_alloc_strategy = Some(heap_alloc_strategy);
+		self
+	}
+
+	/// Create the wasm executor and follow/ignore onchain heap pages value.
+	///
+	/// By default this the onchain heap pages value is followed.
+	pub fn with_ignore_onchain_heap_pages(mut self, ignore_onchain_heap_pages: bool) -> Self {
+		self.ignore_onchain_heap_pages = ignore_onchain_heap_pages;
+		self
+	}
+
+	/// Create the wasm executor with the given maximum number of `instances`.
+	///
+	/// The number of `instances` defines how many different instances of a runtime the cache is
+	/// storing.
+	///
+	/// By default the maximum number of `instances` is `2`.
+	pub fn with_max_runtime_instances(mut self, instances: usize) -> Self {
+		self.max_runtime_instances = instances;
+		self
+	}
+
+	/// Create the wasm executor with the given `cache_path`.
+	///
+	/// The `cache_path` is A path to a directory where the executor can place its files for
+	/// purposes of caching. This may be important in cases when there are many different modules
+	/// with the compiled execution method is used.
+	///
+	/// By default there is no `cache_path` given.
+	pub fn with_cache_path(mut self, cache_path: impl Into<PathBuf>) -> Self {
+		self.cache_path = Some(cache_path.into());
+		self
+	}
+
+	/// Create the wasm executor and allow/forbid missing host functions.
+	///
+	/// If missing host functions are forbidden, the instantiation of a wasm blob will fail
+	/// for imported host functions that the executor is not aware of. If they are allowed,
+	/// a stub is generated that will return an error when being called while executing the wasm.
+	///
+	/// By default missing host functions are forbidden.
+	pub fn with_allow_missing_host_functions(mut self, allow: bool) -> Self {
+		self.allow_missing_host_functions = allow;
+		self
+	}
+
+	/// Create the wasm executor with the given `runtime_cache_size`.
+	///
+	/// Defines the number of different runtimes/instantiated wasm blobs the cache stores.
+	/// Runtimes/wasm blobs are differentiated based on the hash and the number of heap pages.
+	///
+	/// By default this value is set to `4`.
+	pub fn with_runtime_cache_size(mut self, runtime_cache_size: u8) -> Self {
+		self.runtime_cache_size = runtime_cache_size;
+		self
+	}
+
+	/// Build the configured [`WasmExecutor`].
+	pub fn build(self) -> WasmExecutor<H> {
+		WasmExecutor {
+			method: self.method,
+			default_offchain_heap_alloc_strategy: unwrap_heap_pages(
+				self.offchain_heap_alloc_strategy,
+			),
+			default_onchain_heap_alloc_strategy: unwrap_heap_pages(
+				self.onchain_heap_alloc_strategy,
+			),
+			ignore_onchain_heap_pages: self.ignore_onchain_heap_pages,
+			cache: Arc::new(RuntimeCache::new(
+				self.max_runtime_instances,
+				self.cache_path.clone(),
+				self.runtime_cache_size,
+			)),
+			cache_path: self.cache_path,
+			allow_missing_host_functions: self.allow_missing_host_functions,
+			phantom: PhantomData,
+		}
+	}
+}
+
+/// An abstraction over Wasm code executor. Supports selecting execution backend and
+/// manages runtime cache.
+pub struct WasmExecutor<H> {
+	/// Method used to execute fallback Wasm code.
+	method: WasmExecutionMethod,
+	/// The heap allocation strategy for onchain Wasm calls.
+	default_onchain_heap_alloc_strategy: HeapAllocStrategy,
+	/// The heap allocation strategy for offchain Wasm calls.
+	default_offchain_heap_alloc_strategy: HeapAllocStrategy,
+	/// Ignore onchain heap pages value.
+	ignore_onchain_heap_pages: bool,
+	/// WASM runtime cache.
+	cache: Arc<RuntimeCache>,
+	/// The path to a directory which the executor can leverage for a file cache, e.g. put there
+	/// compiled artifacts.
+	cache_path: Option<PathBuf>,
+	/// Ignore missing function imports.
+	allow_missing_host_functions: bool,
+	phantom: PhantomData<H>,
+}
+
+impl<H> Clone for WasmExecutor<H> {
+	fn clone(&self) -> Self {
+		Self {
+			method: self.method,
+			default_onchain_heap_alloc_strategy: self.default_onchain_heap_alloc_strategy,
+			default_offchain_heap_alloc_strategy: self.default_offchain_heap_alloc_strategy,
+			ignore_onchain_heap_pages: self.ignore_onchain_heap_pages,
+			cache: self.cache.clone(),
+			cache_path: self.cache_path.clone(),
+			allow_missing_host_functions: self.allow_missing_host_functions,
+			phantom: self.phantom,
+		}
+	}
+}
+
+impl<H> WasmExecutor<H>
+where
+	H: HostFunctions,
+{
+	/// Create new instance.
+	///
+	/// # Parameters
+	///
+	/// `method` - Method used to execute Wasm code.
+	///
+	/// `default_heap_pages` - Number of 64KB pages to allocate for Wasm execution. Internally this
+	/// will be mapped as [`HeapAllocStrategy::Static`] where `default_heap_pages` represent the
+	/// static number of heap pages to allocate. Defaults to `DEFAULT_HEAP_ALLOC_STRATEGY` if `None`
+	/// is provided.
+	///
+	/// `max_runtime_instances` - The number of runtime instances to keep in memory ready for reuse.
+	///
+	/// `cache_path` - A path to a directory where the executor can place its files for purposes of
+	///   caching. This may be important in cases when there are many different modules with the
+	///   compiled execution method is used.
+	///
+	/// `runtime_cache_size` - The capacity of runtime cache.
+	#[deprecated(note = "use `Self::builder` method instead of it")]
+	pub fn new(
+		method: WasmExecutionMethod,
+		default_heap_pages: Option<u64>,
+		max_runtime_instances: usize,
+		cache_path: Option<PathBuf>,
+		runtime_cache_size: u8,
+	) -> Self {
+		WasmExecutor {
+			method,
+			default_onchain_heap_alloc_strategy: unwrap_heap_pages(
+				default_heap_pages.map(|h| HeapAllocStrategy::Static { extra_pages: h as _ }),
+			),
+			default_offchain_heap_alloc_strategy: unwrap_heap_pages(
+				default_heap_pages.map(|h| HeapAllocStrategy::Static { extra_pages: h as _ }),
+			),
+			ignore_onchain_heap_pages: false,
+			cache: Arc::new(RuntimeCache::new(
+				max_runtime_instances,
+				cache_path.clone(),
+				runtime_cache_size,
+			)),
+			cache_path,
+			allow_missing_host_functions: false,
+			phantom: PhantomData,
+		}
+	}
+
+	/// Instantiate a builder for creating an instance of `Self`.
+	pub fn builder() -> WasmExecutorBuilder<H> {
+		WasmExecutorBuilder::new()
+	}
+
+	/// Ignore missing function imports if set true.
+	#[deprecated(note = "use `Self::builder` method instead of it")]
+	pub fn allow_missing_host_functions(&mut self, allow_missing_host_functions: bool) {
+		self.allow_missing_host_functions = allow_missing_host_functions
+	}
+
+	/// Execute the given closure `f` with the latest runtime (based on `runtime_code`).
+	///
+	/// The closure `f` is expected to return `Err(_)` when there happened a `panic!` in native code
+	/// while executing the runtime in Wasm. If a `panic!` occurred, the runtime is invalidated to
+	/// prevent any poisoned state. Native runtime execution does not need to report back
+	/// any `panic!`.
+	///
+	/// # Safety
+	///
+	/// `runtime` and `ext` are given as `AssertUnwindSafe` to the closure. As described above, the
+	/// runtime is invalidated on any `panic!` to prevent a poisoned state. `ext` is already
+	/// implicitly handled as unwind safe, as we store it in a global variable while executing the
+	/// native runtime.
+	pub fn with_instance<R, F>(
+		&self,
+		runtime_code: &RuntimeCode,
+		ext: &mut dyn Externalities,
+		heap_alloc_strategy: HeapAllocStrategy,
+		f: F,
+	) -> Result<R>
+	where
+		F: FnOnce(
+			AssertUnwindSafe<&dyn WasmModule>,
+			AssertUnwindSafe<&mut dyn WasmInstance>,
+			Option<&RuntimeVersion>,
+			AssertUnwindSafe<&mut dyn Externalities>,
+		) -> Result<Result<R>>,
+	{
+		match self.cache.with_instance::<H, _, _>(
+			runtime_code,
+			ext,
+			self.method,
+			heap_alloc_strategy,
+			self.allow_missing_host_functions,
+			|module, instance, version, ext| {
+				let module = AssertUnwindSafe(module);
+				let instance = AssertUnwindSafe(instance);
+				let ext = AssertUnwindSafe(ext);
+				f(module, instance, version, ext)
+			},
+		)? {
+			Ok(r) => r,
+			Err(e) => Err(e),
+		}
+	}
+
+	/// Perform a call into the given runtime.
+	///
+	/// The runtime is passed as a [`RuntimeBlob`]. The runtime will be instantiated with the
+	/// parameters this `WasmExecutor` was initialized with.
+	///
+	/// In case of problems with during creation of the runtime or instantiation, a `Err` is
+	/// returned. that describes the message.
+	#[doc(hidden)] // We use this function for tests across multiple crates.
+	pub fn uncached_call(
+		&self,
+		runtime_blob: RuntimeBlob,
+		ext: &mut dyn Externalities,
+		allow_missing_host_functions: bool,
+		export_name: &str,
+		call_data: &[u8],
+	) -> std::result::Result<Vec<u8>, Error> {
+		self.uncached_call_impl(
+			runtime_blob,
+			ext,
+			allow_missing_host_functions,
+			export_name,
+			call_data,
+			&mut None,
+		)
+	}
+
+	/// Same as `uncached_call`, except it also returns allocation statistics.
+	#[doc(hidden)] // We use this function in tests.
+	pub fn uncached_call_with_allocation_stats(
+		&self,
+		runtime_blob: RuntimeBlob,
+		ext: &mut dyn Externalities,
+		allow_missing_host_functions: bool,
+		export_name: &str,
+		call_data: &[u8],
+	) -> (std::result::Result<Vec<u8>, Error>, Option<AllocationStats>) {
+		let mut allocation_stats = None;
+		let result = self.uncached_call_impl(
+			runtime_blob,
+			ext,
+			allow_missing_host_functions,
+			export_name,
+			call_data,
+			&mut allocation_stats,
+		);
+		(result, allocation_stats)
+	}
+
+	fn uncached_call_impl(
+		&self,
+		runtime_blob: RuntimeBlob,
+		ext: &mut dyn Externalities,
+		allow_missing_host_functions: bool,
+		export_name: &str,
+		call_data: &[u8],
+		allocation_stats_out: &mut Option<AllocationStats>,
+	) -> std::result::Result<Vec<u8>, Error> {
+		let module = crate::wasm_runtime::create_wasm_runtime_with_code::<H>(
+			self.method,
+			self.default_onchain_heap_alloc_strategy,
+			runtime_blob,
+			allow_missing_host_functions,
+			self.cache_path.as_deref(),
+		)
+		.map_err(|e| format!("Failed to create module: {}", e))?;
+
+		let instance =
+			module.new_instance().map_err(|e| format!("Failed to create instance: {}", e))?;
+
+		let mut instance = AssertUnwindSafe(instance);
+		let mut ext = AssertUnwindSafe(ext);
+		let mut allocation_stats_out = AssertUnwindSafe(allocation_stats_out);
+
+		with_externalities_safe(&mut **ext, move || {
+			let (result, allocation_stats) =
+				instance.call_with_allocation_stats(export_name.into(), call_data);
+			**allocation_stats_out = allocation_stats;
+			result
+		})
+		.and_then(|r| r)
+	}
+}
+
+impl<H> sp_core::traits::ReadRuntimeVersion for WasmExecutor<H>
+where
+	H: HostFunctions,
+{
+	fn read_runtime_version(
+		&self,
+		wasm_code: &[u8],
+		ext: &mut dyn Externalities,
+	) -> std::result::Result<Vec<u8>, String> {
+		let runtime_blob = RuntimeBlob::uncompress_if_needed(wasm_code)
+			.map_err(|e| format!("Failed to create runtime blob: {:?}", e))?;
+
+		if let Some(version) = crate::wasm_runtime::read_embedded_version(&runtime_blob)
+			.map_err(|e| format!("Failed to read the static section: {:?}", e))
+			.map(|v| v.map(|v| v.encode()))?
+		{
+			return Ok(version)
+		}
+
+		// If the blob didn't have embedded runtime version section, we fallback to the legacy
+		// way of fetching the version: i.e. instantiating the given instance and calling
+		// `Core_version` on it.
+
+		self.uncached_call(
+			runtime_blob,
+			ext,
+			// If a runtime upgrade introduces new host functions that are not provided by
+			// the node, we should not fail at instantiation. Otherwise nodes that are
+			// updated could run this successfully and it could lead to a storage root
+			// mismatch when importing this block.
+			true,
+			"Core_version",
+			&[],
+		)
+		.map_err(|e| e.to_string())
+	}
+}
+
+impl<H> CodeExecutor for WasmExecutor<H>
+where
+	H: HostFunctions,
+{
+	type Error = Error;
+
+	fn call(
+		&self,
+		ext: &mut dyn Externalities,
+		runtime_code: &RuntimeCode,
+		method: &str,
+		data: &[u8],
+		_use_native: bool,
+		context: CallContext,
+	) -> (Result<Vec<u8>>, bool) {
+		tracing::trace!(
+			target: "executor",
+			%method,
+			"Executing function",
+		);
+
+		let on_chain_heap_alloc_strategy = if self.ignore_onchain_heap_pages {
+			self.default_onchain_heap_alloc_strategy
+		} else {
+			runtime_code
+				.heap_pages
+				.map(|h| HeapAllocStrategy::Static { extra_pages: h as _ })
+				.unwrap_or_else(|| self.default_onchain_heap_alloc_strategy)
+		};
+
+		let heap_alloc_strategy = match context {
+			CallContext::Offchain => self.default_offchain_heap_alloc_strategy,
+			CallContext::Onchain => on_chain_heap_alloc_strategy,
+		};
+
+		let result = self.with_instance(
+			runtime_code,
+			ext,
+			heap_alloc_strategy,
+			|_, mut instance, _onchain_version, mut ext| {
+				with_externalities_safe(&mut **ext, move || instance.call_export(method, data))
+			},
+		);
+
+		(result, false)
+	}
+}
+
+impl<H> RuntimeVersionOf for WasmExecutor<H>
+where
+	H: HostFunctions,
+{
+	fn runtime_version(
+		&self,
+		ext: &mut dyn Externalities,
+		runtime_code: &RuntimeCode,
+	) -> Result<RuntimeVersion> {
+		let on_chain_heap_pages = if self.ignore_onchain_heap_pages {
+			self.default_onchain_heap_alloc_strategy
+		} else {
+			runtime_code
+				.heap_pages
+				.map(|h| HeapAllocStrategy::Static { extra_pages: h as _ })
+				.unwrap_or_else(|| self.default_onchain_heap_alloc_strategy)
+		};
+
+		self.with_instance(
+			runtime_code,
+			ext,
+			on_chain_heap_pages,
+			|_module, _instance, version, _ext| {
+				Ok(version.cloned().ok_or_else(|| Error::ApiError("Unknown version".into())))
+			},
+		)
+	}
+}
+
+/// A generic `CodeExecutor` implementation that uses a delegate to determine wasm code equivalence
+/// and dispatch to native code when possible, falling back on `WasmExecutor` when not.
+pub struct NativeElseWasmExecutor<D: NativeExecutionDispatch> {
+	/// Native runtime version info.
+	native_version: NativeVersion,
+	/// Fallback wasm executor.
+	wasm:
+		WasmExecutor<ExtendedHostFunctions<sp_io::SubstrateHostFunctions, D::ExtendHostFunctions>>,
+}
+
+impl<D: NativeExecutionDispatch> NativeElseWasmExecutor<D> {
+	///
+	/// Create new instance.
+	///
+	/// # Parameters
+	///
+	/// `fallback_method` - Method used to execute fallback Wasm code.
+	///
+	/// `default_heap_pages` - Number of 64KB pages to allocate for Wasm execution. Internally this
+	/// will be mapped as [`HeapAllocStrategy::Static`] where `default_heap_pages` represent the
+	/// static number of heap pages to allocate. Defaults to `DEFAULT_HEAP_ALLOC_STRATEGY` if `None`
+	/// is provided.
+	///
+	/// `max_runtime_instances` - The number of runtime instances to keep in memory ready for reuse.
+	///
+	/// `runtime_cache_size` - The capacity of runtime cache.
+	#[deprecated(note = "use `Self::new_with_wasm_executor` method instead of it")]
+	pub fn new(
+		fallback_method: WasmExecutionMethod,
+		default_heap_pages: Option<u64>,
+		max_runtime_instances: usize,
+		runtime_cache_size: u8,
+	) -> Self {
+		let heap_pages = default_heap_pages.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |h| {
+			HeapAllocStrategy::Static { extra_pages: h as _ }
+		});
+		let wasm = WasmExecutor::builder()
+			.with_execution_method(fallback_method)
+			.with_onchain_heap_alloc_strategy(heap_pages)
+			.with_offchain_heap_alloc_strategy(heap_pages)
+			.with_max_runtime_instances(max_runtime_instances)
+			.with_runtime_cache_size(runtime_cache_size)
+			.build();
+
+		NativeElseWasmExecutor { native_version: D::native_version(), wasm }
+	}
+
+	/// Create a new instance using the given [`WasmExecutor`].
+	pub fn new_with_wasm_executor(
+		executor: WasmExecutor<
+			ExtendedHostFunctions<sp_io::SubstrateHostFunctions, D::ExtendHostFunctions>,
+		>,
+	) -> Self {
+		Self { native_version: D::native_version(), wasm: executor }
+	}
+
+	/// Ignore missing function imports if set true.
+	#[deprecated(note = "use `Self::new_with_wasm_executor` method instead of it")]
+	pub fn allow_missing_host_functions(&mut self, allow_missing_host_functions: bool) {
+		self.wasm.allow_missing_host_functions = allow_missing_host_functions
+	}
+}
+
+impl<D: NativeExecutionDispatch> RuntimeVersionOf for NativeElseWasmExecutor<D> {
+	fn runtime_version(
+		&self,
+		ext: &mut dyn Externalities,
+		runtime_code: &RuntimeCode,
+	) -> Result<RuntimeVersion> {
+		self.wasm.runtime_version(ext, runtime_code)
+	}
+}
+
+impl<D: NativeExecutionDispatch> GetNativeVersion for NativeElseWasmExecutor<D> {
+	fn native_version(&self) -> &NativeVersion {
+		&self.native_version
+	}
+}
+
+impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeElseWasmExecutor<D> {
+	type Error = Error;
+
+	fn call(
+		&self,
+		ext: &mut dyn Externalities,
+		runtime_code: &RuntimeCode,
+		method: &str,
+		data: &[u8],
+		use_native: bool,
+		context: CallContext,
+	) -> (Result<Vec<u8>>, bool) {
+		tracing::trace!(
+			target: "executor",
+			function = %method,
+			"Executing function",
+		);
+
+		let on_chain_heap_alloc_strategy = if self.wasm.ignore_onchain_heap_pages {
+			self.wasm.default_onchain_heap_alloc_strategy
+		} else {
+			runtime_code
+				.heap_pages
+				.map(|h| HeapAllocStrategy::Static { extra_pages: h as _ })
+				.unwrap_or_else(|| self.wasm.default_onchain_heap_alloc_strategy)
+		};
+
+		let heap_alloc_strategy = match context {
+			CallContext::Offchain => self.wasm.default_offchain_heap_alloc_strategy,
+			CallContext::Onchain => on_chain_heap_alloc_strategy,
+		};
+
+		let mut used_native = false;
+		let result = self.wasm.with_instance(
+			runtime_code,
+			ext,
+			heap_alloc_strategy,
+			|_, mut instance, onchain_version, mut ext| {
+				let onchain_version =
+					onchain_version.ok_or_else(|| Error::ApiError("Unknown version".into()))?;
+
+				let can_call_with =
+					onchain_version.can_call_with(&self.native_version.runtime_version);
+
+				if use_native && can_call_with {
+					tracing::trace!(
+						target: "executor",
+						native = %self.native_version.runtime_version,
+						chain = %onchain_version,
+						"Request for native execution succeeded",
+					);
+
+					used_native = true;
+					Ok(with_externalities_safe(&mut **ext, move || D::dispatch(method, data))?
+						.ok_or_else(|| Error::MethodNotFound(method.to_owned())))
+				} else {
+					if !can_call_with {
+						tracing::trace!(
+							target: "executor",
+							native = %self.native_version.runtime_version,
+							chain = %onchain_version,
+							"Request for native execution failed",
+						);
+					}
+
+					with_externalities_safe(&mut **ext, move || instance.call_export(method, data))
+				}
+			},
+		);
+		(result, used_native)
+	}
+}
+
+impl<D: NativeExecutionDispatch> Clone for NativeElseWasmExecutor<D> {
+	fn clone(&self) -> Self {
+		NativeElseWasmExecutor { native_version: D::native_version(), wasm: self.wasm.clone() }
+	}
+}
+
+impl<D: NativeExecutionDispatch> sp_core::traits::ReadRuntimeVersion for NativeElseWasmExecutor<D> {
+	fn read_runtime_version(
+		&self,
+		wasm_code: &[u8],
+		ext: &mut dyn Externalities,
+	) -> std::result::Result<Vec<u8>, String> {
+		self.wasm.read_runtime_version(wasm_code, ext)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_runtime_interface::runtime_interface;
+
+	#[runtime_interface]
+	trait MyInterface {
+		fn say_hello_world(data: &str) {
+			println!("Hello world from: {}", data);
+		}
+	}
+
+	pub struct MyExecutorDispatch;
+
+	impl NativeExecutionDispatch for MyExecutorDispatch {
+		type ExtendHostFunctions = (my_interface::HostFunctions, my_interface::HostFunctions);
+
+		fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
+			substrate_test_runtime::api::dispatch(method, data)
+		}
+
+		fn native_version() -> NativeVersion {
+			substrate_test_runtime::native_version()
+		}
+	}
+
+	#[test]
+	fn native_executor_registers_custom_interface() {
+		let executor = NativeElseWasmExecutor::<MyExecutorDispatch>::new_with_wasm_executor(
+			WasmExecutor::builder().build(),
+		);
+
+		fn extract_host_functions<H>(
+			_: &WasmExecutor<H>,
+		) -> Vec<&'static dyn sp_wasm_interface::Function>
+		where
+			H: HostFunctions,
+		{
+			H::host_functions()
+		}
+
+		my_interface::HostFunctions::host_functions().iter().for_each(|function| {
+			assert_eq!(
+				extract_host_functions(&executor.wasm).iter().filter(|f| f == &function).count(),
+				2
+			);
+		});
+
+		my_interface::say_hello_world("hey");
+	}
+}
diff --git a/substrate/client/executor/src/integration_tests/linux.rs b/substrate/client/executor/src/integration_tests/linux.rs
new file mode 100644
index 0000000000000000000000000000000000000000..68ac37e9011a18a811ad8acba7026ac974a2c888
--- /dev/null
+++ b/substrate/client/executor/src/integration_tests/linux.rs
@@ -0,0 +1,84 @@
+// 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/>.
+
+//! Tests that are only relevant for Linux.
+
+mod smaps;
+
+use super::mk_test_runtime;
+use crate::WasmExecutionMethod;
+use codec::Encode as _;
+use sc_executor_common::wasm_runtime::DEFAULT_HEAP_ALLOC_STRATEGY;
+
+use self::smaps::Smaps;
+
+#[test]
+fn memory_consumption_compiled() {
+	let _ = sp_tracing::try_init_simple();
+
+	if std::env::var("RUN_TEST").is_ok() {
+		memory_consumption(WasmExecutionMethod::Compiled {
+			instantiation_strategy:
+				sc_executor_wasmtime::InstantiationStrategy::LegacyInstanceReuse,
+		});
+	} else {
+		// We need to run the test in isolation, to not getting interfered by the other tests.
+		let executable = std::env::current_exe().unwrap();
+		let status = std::process::Command::new(executable)
+			.env("RUN_TEST", "1")
+			.args(&["--nocapture", "memory_consumption_compiled"])
+			.status()
+			.unwrap();
+
+		assert!(status.success());
+	}
+}
+
+fn memory_consumption(wasm_method: WasmExecutionMethod) {
+	// This aims to see if linear memory stays backed by the physical memory after a runtime call.
+	//
+	// For that we make a series of runtime calls, probing the RSS for the VMA matching the linear
+	// memory. After the call we expect RSS to be equal to 0.
+
+	let runtime = mk_test_runtime(wasm_method, DEFAULT_HEAP_ALLOC_STRATEGY);
+
+	let mut instance = runtime.new_instance().unwrap();
+	let heap_base = instance
+		.get_global_const("__heap_base")
+		.expect("`__heap_base` is valid")
+		.expect("`__heap_base` exists")
+		.as_i32()
+		.expect("`__heap_base` is an `i32`");
+
+	fn probe_rss(instance: &dyn sc_executor_common::wasm_runtime::WasmInstance) -> usize {
+		let base_addr = instance.linear_memory_base_ptr().unwrap() as usize;
+		Smaps::new().get_rss(base_addr).expect("failed to get rss")
+	}
+
+	instance
+		.call_export("test_dirty_plenty_memory", &(heap_base as u32, 1u32).encode())
+		.unwrap();
+	let probe_1 = probe_rss(&*instance);
+	instance
+		.call_export("test_dirty_plenty_memory", &(heap_base as u32, 1024u32).encode())
+		.unwrap();
+	let probe_2 = probe_rss(&*instance);
+
+	assert_eq!(probe_1, 0);
+	assert_eq!(probe_2, 0);
+}
diff --git a/substrate/client/executor/src/integration_tests/linux/smaps.rs b/substrate/client/executor/src/integration_tests/linux/smaps.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ac570dd8d5f237b61eb4006e39c8b25bb211a90
--- /dev/null
+++ b/substrate/client/executor/src/integration_tests/linux/smaps.rs
@@ -0,0 +1,82 @@
+// 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/>.
+
+//! A tool for extracting information about the memory consumption of the current process from
+//! the procfs.
+
+use std::{collections::BTreeMap, ops::Range};
+
+/// An interface to the /proc/self/smaps
+///
+/// See docs about [procfs on kernel.org][procfs]
+///
+/// [procfs]: https://www.kernel.org/doc/html/latest/filesystems/proc.html
+pub struct Smaps(Vec<(Range<usize>, BTreeMap<String, usize>)>);
+
+impl Smaps {
+	pub fn new() -> Self {
+		let regex_start = regex::RegexBuilder::new("^([0-9a-f]+)-([0-9a-f]+)")
+			.multi_line(true)
+			.build()
+			.unwrap();
+		let regex_kv = regex::RegexBuilder::new(r#"^([^:]+):\s*(\d+) kB"#)
+			.multi_line(true)
+			.build()
+			.unwrap();
+		let smaps = std::fs::read_to_string("/proc/self/smaps").unwrap();
+		let boundaries: Vec<_> = regex_start
+			.find_iter(&smaps)
+			.map(|matched| matched.start())
+			.chain(std::iter::once(smaps.len()))
+			.collect();
+
+		let mut output = Vec::new();
+		for window in boundaries.windows(2) {
+			let chunk = &smaps[window[0]..window[1]];
+			let caps = regex_start.captures(chunk).unwrap();
+			let start = usize::from_str_radix(caps.get(1).unwrap().as_str(), 16).unwrap();
+			let end = usize::from_str_radix(caps.get(2).unwrap().as_str(), 16).unwrap();
+
+			let values = regex_kv
+				.captures_iter(chunk)
+				.map(|cap| {
+					let key = cap.get(1).unwrap().as_str().to_owned();
+					let value = cap.get(2).unwrap().as_str().parse().unwrap();
+					(key, value)
+				})
+				.collect();
+
+			output.push((start..end, values));
+		}
+
+		Self(output)
+	}
+
+	fn get_map(&self, addr: usize) -> &BTreeMap<String, usize> {
+		&self
+			.0
+			.iter()
+			.find(|(range, _)| addr >= range.start && addr < range.end)
+			.unwrap()
+			.1
+	}
+
+	pub fn get_rss(&self, addr: usize) -> Option<usize> {
+		self.get_map(addr).get("Rss").cloned()
+	}
+}
diff --git a/substrate/client/executor/src/integration_tests/mod.rs b/substrate/client/executor/src/integration_tests/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..37aed8eef96a1b81e703a26b9cd95e6a19c346a1
--- /dev/null
+++ b/substrate/client/executor/src/integration_tests/mod.rs
@@ -0,0 +1,823 @@
+// 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/>.
+
+#[cfg(target_os = "linux")]
+mod linux;
+
+use assert_matches::assert_matches;
+use codec::{Decode, Encode};
+use sc_executor_common::{
+	error::Error,
+	runtime_blob::RuntimeBlob,
+	wasm_runtime::{HeapAllocStrategy, WasmModule},
+};
+use sc_runtime_test::wasm_binary_unwrap;
+use sp_core::{
+	blake2_128, blake2_256, ed25519, map,
+	offchain::{testing, OffchainDbExt, OffchainWorkerExt},
+	sr25519,
+	traits::Externalities,
+	Pair,
+};
+use sp_runtime::traits::BlakeTwo256;
+use sp_state_machine::TestExternalities as CoreTestExternalities;
+use sp_trie::{LayoutV1 as Layout, TrieConfiguration};
+use std::sync::Arc;
+use tracing_subscriber::layer::SubscriberExt;
+
+use crate::WasmExecutionMethod;
+
+pub type TestExternalities = CoreTestExternalities<BlakeTwo256>;
+type HostFunctions = sp_io::SubstrateHostFunctions;
+
+/// Simple macro that runs a given method as test with the available wasm execution methods.
+#[macro_export]
+macro_rules! test_wasm_execution {
+	($method_name:ident) => {
+		paste::item! {
+			#[test]
+			fn [<$method_name _compiled_recreate_instance_cow>]() {
+				let _ = sp_tracing::try_init_simple();
+				$method_name(WasmExecutionMethod::Compiled {
+					instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::RecreateInstanceCopyOnWrite
+				});
+			}
+
+			#[test]
+			fn [<$method_name _compiled_recreate_instance_vanilla>]() {
+				let _ = sp_tracing::try_init_simple();
+				$method_name(WasmExecutionMethod::Compiled {
+					instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::RecreateInstance
+				});
+			}
+
+			#[test]
+			fn [<$method_name _compiled_pooling_cow>]() {
+				let _ = sp_tracing::try_init_simple();
+				$method_name(WasmExecutionMethod::Compiled {
+					instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::PoolingCopyOnWrite
+				});
+			}
+
+			#[test]
+			fn [<$method_name _compiled_pooling_vanilla>]() {
+				let _ = sp_tracing::try_init_simple();
+				$method_name(WasmExecutionMethod::Compiled {
+					instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::Pooling
+				});
+			}
+
+			#[test]
+			fn [<$method_name _compiled_legacy_instance_reuse>]() {
+				let _ = sp_tracing::try_init_simple();
+				$method_name(WasmExecutionMethod::Compiled {
+					instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::LegacyInstanceReuse
+				});
+			}
+		}
+	};
+}
+
+fn call_in_wasm<E: Externalities>(
+	function: &str,
+	call_data: &[u8],
+	execution_method: WasmExecutionMethod,
+	ext: &mut E,
+) -> Result<Vec<u8>, Error> {
+	let executor = crate::WasmExecutor::<HostFunctions>::builder()
+		.with_execution_method(execution_method)
+		.build();
+
+	executor.uncached_call(
+		RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),
+		ext,
+		true,
+		function,
+		call_data,
+	)
+}
+
+test_wasm_execution!(returning_should_work);
+fn returning_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	let output = call_in_wasm("test_empty_return", &[], wasm_method, &mut ext).unwrap();
+	assert_eq!(output, vec![0u8; 0]);
+}
+
+test_wasm_execution!(call_not_existing_function);
+fn call_not_existing_function(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	match call_in_wasm("test_calling_missing_external", &[], wasm_method, &mut ext).unwrap_err() {
+		Error::AbortedDueToTrap(error) => {
+			let expected = match wasm_method {
+				WasmExecutionMethod::Compiled { .. } =>
+					"call to a missing function env:missing_external",
+			};
+			assert_eq!(error.message, expected);
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(call_yet_another_not_existing_function);
+fn call_yet_another_not_existing_function(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	match call_in_wasm("test_calling_yet_another_missing_external", &[], wasm_method, &mut ext)
+		.unwrap_err()
+	{
+		Error::AbortedDueToTrap(error) => {
+			let expected = match wasm_method {
+				WasmExecutionMethod::Compiled { .. } =>
+					"call to a missing function env:yet_another_missing_external",
+			};
+			assert_eq!(error.message, expected);
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(panicking_should_work);
+fn panicking_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	let output = call_in_wasm("test_panic", &[], wasm_method, &mut ext);
+	assert!(output.is_err());
+
+	let output = call_in_wasm("test_conditional_panic", &[0], wasm_method, &mut ext);
+	assert_eq!(Decode::decode(&mut &output.unwrap()[..]), Ok(Vec::<u8>::new()));
+
+	let output = call_in_wasm("test_conditional_panic", &vec![2].encode(), wasm_method, &mut ext);
+	assert!(output.is_err());
+}
+
+test_wasm_execution!(storage_should_work);
+fn storage_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	// Test value must be bigger than 32 bytes
+	// to test the trie versioning.
+	let value = vec![7u8; 60];
+
+	{
+		let mut ext = ext.ext();
+		ext.set_storage(b"foo".to_vec(), b"bar".to_vec());
+
+		let output = call_in_wasm("test_data_in", &value.encode(), wasm_method, &mut ext).unwrap();
+
+		assert_eq!(output, b"all ok!".to_vec().encode());
+	}
+
+	let expected = TestExternalities::new(sp_core::storage::Storage {
+		top: map![
+			b"input".to_vec() => value,
+			b"foo".to_vec() => b"bar".to_vec(),
+			b"baz".to_vec() => b"bar".to_vec()
+		],
+		children_default: map![],
+	});
+	assert_eq!(ext, expected);
+}
+
+test_wasm_execution!(clear_prefix_should_work);
+fn clear_prefix_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	{
+		let mut ext = ext.ext();
+		ext.set_storage(b"aaa".to_vec(), b"1".to_vec());
+		ext.set_storage(b"aab".to_vec(), b"2".to_vec());
+		ext.set_storage(b"aba".to_vec(), b"3".to_vec());
+		ext.set_storage(b"abb".to_vec(), b"4".to_vec());
+		ext.set_storage(b"bbb".to_vec(), b"5".to_vec());
+
+		// This will clear all entries which prefix is "ab".
+		let output =
+			call_in_wasm("test_clear_prefix", &b"ab".to_vec().encode(), wasm_method, &mut ext)
+				.unwrap();
+
+		assert_eq!(output, b"all ok!".to_vec().encode());
+	}
+
+	let 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(),
+			b"bbb".to_vec() => b"5".to_vec()
+		],
+		children_default: map![],
+	});
+	assert_eq!(expected, ext);
+}
+
+test_wasm_execution!(blake2_256_should_work);
+fn blake2_256_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+	assert_eq!(
+		call_in_wasm("test_blake2_256", &[0], wasm_method, &mut ext,).unwrap(),
+		blake2_256(&b""[..]).to_vec().encode(),
+	);
+	assert_eq!(
+		call_in_wasm("test_blake2_256", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
+		blake2_256(&b"Hello world!"[..]).to_vec().encode(),
+	);
+}
+
+test_wasm_execution!(blake2_128_should_work);
+fn blake2_128_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+	assert_eq!(
+		call_in_wasm("test_blake2_128", &[0], wasm_method, &mut ext,).unwrap(),
+		blake2_128(&b""[..]).to_vec().encode(),
+	);
+	assert_eq!(
+		call_in_wasm("test_blake2_128", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
+		blake2_128(&b"Hello world!"[..]).to_vec().encode(),
+	);
+}
+
+test_wasm_execution!(sha2_256_should_work);
+fn sha2_256_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+	assert_eq!(
+		call_in_wasm("test_sha2_256", &[0], wasm_method, &mut ext,).unwrap(),
+		array_bytes::hex2bytes_unchecked(
+			"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+		)
+		.encode(),
+	);
+	assert_eq!(
+		call_in_wasm("test_sha2_256", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
+		array_bytes::hex2bytes_unchecked(
+			"c0535e4be2b79ffd93291305436bf889314e4a3faec05ecffcbb7df31ad9e51a"
+		)
+		.encode(),
+	);
+}
+
+test_wasm_execution!(twox_256_should_work);
+fn twox_256_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+	assert_eq!(
+		call_in_wasm("test_twox_256", &[0], wasm_method, &mut ext,).unwrap(),
+		array_bytes::hex2bytes_unchecked(
+			"99e9d85137db46ef4bbea33613baafd56f963c64b1f3685a4eb4abd67ff6203a"
+		)
+		.encode(),
+	);
+	assert_eq!(
+		call_in_wasm("test_twox_256", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
+		array_bytes::hex2bytes_unchecked(
+			"b27dfd7f223f177f2a13647b533599af0c07f68bda23d96d059da2b451a35a74"
+		)
+		.encode(),
+	);
+}
+
+test_wasm_execution!(twox_128_should_work);
+fn twox_128_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+	assert_eq!(
+		call_in_wasm("test_twox_128", &[0], wasm_method, &mut ext,).unwrap(),
+		array_bytes::hex2bytes_unchecked("99e9d85137db46ef4bbea33613baafd5").encode(),
+	);
+	assert_eq!(
+		call_in_wasm("test_twox_128", &b"Hello world!".to_vec().encode(), wasm_method, &mut ext,)
+			.unwrap(),
+		array_bytes::hex2bytes_unchecked("b27dfd7f223f177f2a13647b533599af").encode(),
+	);
+}
+
+test_wasm_execution!(ed25519_verify_should_work);
+fn ed25519_verify_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+	let key = ed25519::Pair::from_seed(&blake2_256(b"test"));
+	let sig = key.sign(b"all ok!");
+	let mut calldata = vec![];
+	calldata.extend_from_slice(key.public().as_ref());
+	calldata.extend_from_slice(sig.as_ref());
+
+	assert_eq!(
+		call_in_wasm("test_ed25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
+		true.encode(),
+	);
+
+	let other_sig = key.sign(b"all is not ok!");
+	let mut calldata = vec![];
+	calldata.extend_from_slice(key.public().as_ref());
+	calldata.extend_from_slice(other_sig.as_ref());
+
+	assert_eq!(
+		call_in_wasm("test_ed25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
+		false.encode(),
+	);
+}
+
+test_wasm_execution!(sr25519_verify_should_work);
+fn sr25519_verify_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+	let key = sr25519::Pair::from_seed(&blake2_256(b"test"));
+	let sig = key.sign(b"all ok!");
+	let mut calldata = vec![];
+	calldata.extend_from_slice(key.public().as_ref());
+	calldata.extend_from_slice(sig.as_ref());
+
+	assert_eq!(
+		call_in_wasm("test_sr25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
+		true.encode(),
+	);
+
+	let other_sig = key.sign(b"all is not ok!");
+	let mut calldata = vec![];
+	calldata.extend_from_slice(key.public().as_ref());
+	calldata.extend_from_slice(other_sig.as_ref());
+
+	assert_eq!(
+		call_in_wasm("test_sr25519_verify", &calldata.encode(), wasm_method, &mut ext,).unwrap(),
+		false.encode(),
+	);
+}
+
+test_wasm_execution!(ordered_trie_root_should_work);
+fn ordered_trie_root_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let trie_input = vec![b"zero".to_vec(), b"one".to_vec(), b"two".to_vec()];
+	assert_eq!(
+		call_in_wasm("test_ordered_trie_root", &[0], wasm_method, &mut ext.ext(),).unwrap(),
+		Layout::<BlakeTwo256>::ordered_trie_root(trie_input.iter()).as_bytes().encode(),
+	);
+}
+
+test_wasm_execution!(offchain_index);
+fn offchain_index(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let (offchain, _state) = testing::TestOffchainExt::new();
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	call_in_wasm("test_offchain_index_set", &[0], wasm_method, &mut ext.ext()).unwrap();
+
+	use sp_core::offchain::OffchainOverlayedChange;
+	let data = ext
+		.overlayed_changes()
+		.clone()
+		.offchain_drain_committed()
+		.find(|(k, _v)| k == &(sp_core::offchain::STORAGE_PREFIX.to_vec(), b"k".to_vec()));
+	assert_eq!(data.map(|data| data.1), Some(OffchainOverlayedChange::SetValue(b"v".to_vec())));
+}
+
+test_wasm_execution!(offchain_local_storage_should_work);
+fn offchain_local_storage_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let (offchain, state) = testing::TestOffchainExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	assert_eq!(
+		call_in_wasm("test_offchain_local_storage", &[0], wasm_method, &mut ext.ext(),).unwrap(),
+		true.encode(),
+	);
+	assert_eq!(state.read().persistent_storage.get(b"test"), Some(vec![]));
+}
+
+test_wasm_execution!(offchain_http_should_work);
+fn offchain_http_should_work(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let (offchain, state) = testing::TestOffchainExt::new();
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	state.write().expect_request(testing::PendingRequest {
+		method: "POST".into(),
+		uri: "http://localhost:12345".into(),
+		body: vec![1, 2, 3, 4],
+		headers: vec![("X-Auth".to_owned(), "test".to_owned())],
+		sent: true,
+		response: Some(vec![1, 2, 3]),
+		response_headers: vec![("X-Auth".to_owned(), "hello".to_owned())],
+		..Default::default()
+	});
+
+	assert_eq!(
+		call_in_wasm("test_offchain_http", &[0], wasm_method, &mut ext.ext(),).unwrap(),
+		true.encode(),
+	);
+}
+
+test_wasm_execution!(should_trap_when_heap_exhausted);
+fn should_trap_when_heap_exhausted(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+
+	let executor = crate::WasmExecutor::<HostFunctions>::builder()
+		.with_execution_method(wasm_method)
+		// `17` is the initial number of pages compiled into the binary.
+		.with_onchain_heap_alloc_strategy(HeapAllocStrategy::Static { extra_pages: 17 })
+		.build();
+
+	let err = executor
+		.uncached_call(
+			RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),
+			&mut ext.ext(),
+			true,
+			"test_allocate_vec",
+			&16777216_u32.encode(),
+		)
+		.unwrap_err();
+
+	match err {
+		Error::AbortedDueToTrap(error)
+			if matches!(wasm_method, WasmExecutionMethod::Compiled { .. }) =>
+		{
+			assert_eq!(
+				error.message,
+				r#"host code panicked while being called by the runtime: Failed to allocate memory: "Allocator ran out of space""#
+			);
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+fn mk_test_runtime(
+	wasm_method: WasmExecutionMethod,
+	pages: HeapAllocStrategy,
+) -> Box<dyn WasmModule> {
+	let blob = RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap())
+		.expect("failed to create a runtime blob out of test runtime");
+
+	crate::wasm_runtime::create_wasm_runtime_with_code::<HostFunctions>(
+		wasm_method,
+		pages,
+		blob,
+		true,
+		None,
+	)
+	.expect("failed to instantiate wasm runtime")
+}
+
+test_wasm_execution!(returns_mutable_static);
+fn returns_mutable_static(wasm_method: WasmExecutionMethod) {
+	let runtime =
+		mk_test_runtime(wasm_method, HeapAllocStrategy::Dynamic { maximum_pages: Some(1024) });
+
+	let mut instance = runtime.new_instance().unwrap();
+	let res = instance.call_export("returns_mutable_static", &[0]).unwrap();
+	assert_eq!(33, u64::decode(&mut &res[..]).unwrap());
+
+	// We expect that every invocation will need to return the initial
+	// value plus one. If the value increases more than that then it is
+	// a sign that the wasm runtime preserves the memory content.
+	let res = instance.call_export("returns_mutable_static", &[0]).unwrap();
+	assert_eq!(33, u64::decode(&mut &res[..]).unwrap());
+}
+
+test_wasm_execution!(returns_mutable_static_bss);
+fn returns_mutable_static_bss(wasm_method: WasmExecutionMethod) {
+	let runtime =
+		mk_test_runtime(wasm_method, HeapAllocStrategy::Dynamic { maximum_pages: Some(1024) });
+
+	let mut instance = runtime.new_instance().unwrap();
+	let res = instance.call_export("returns_mutable_static_bss", &[0]).unwrap();
+	assert_eq!(1, u64::decode(&mut &res[..]).unwrap());
+
+	// We expect that every invocation will need to return the initial
+	// value plus one. If the value increases more than that then it is
+	// a sign that the wasm runtime preserves the memory content.
+	let res = instance.call_export("returns_mutable_static_bss", &[0]).unwrap();
+	assert_eq!(1, u64::decode(&mut &res[..]).unwrap());
+}
+
+// If we didn't restore the wasm instance properly, on a trap the stack pointer would not be
+// returned to its initial value and thus the stack space is going to be leaked.
+//
+// See https://github.com/paritytech/substrate/issues/2967 for details
+test_wasm_execution!(restoration_of_globals);
+fn restoration_of_globals(wasm_method: WasmExecutionMethod) {
+	// Allocate 32 pages (of 65536 bytes) which gives the runtime 2048KB of heap to operate on
+	// (plus some additional space unused from the initial pages requested by the wasm runtime
+	// module).
+	//
+	// The fixture performs 2 allocations of 768KB and this theoretically gives 1536KB, however, due
+	// to our allocator algorithm there are inefficiencies.
+	const REQUIRED_MEMORY_PAGES: u32 = 32;
+
+	let runtime = mk_test_runtime(
+		wasm_method,
+		HeapAllocStrategy::Static { extra_pages: REQUIRED_MEMORY_PAGES },
+	);
+	let mut instance = runtime.new_instance().unwrap();
+
+	// On the first invocation we allocate approx. 768KB (75%) of stack and then trap.
+	let res = instance.call_export("allocates_huge_stack_array", &true.encode());
+	assert!(res.is_err());
+
+	// On the second invocation we allocate yet another 768KB (75%) of stack
+	let res = instance.call_export("allocates_huge_stack_array", &false.encode());
+	assert!(res.is_ok());
+}
+
+test_wasm_execution!(parallel_execution);
+fn parallel_execution(wasm_method: WasmExecutionMethod) {
+	let executor = Arc::new(
+		crate::WasmExecutor::<HostFunctions>::builder()
+			.with_execution_method(wasm_method)
+			.build(),
+	);
+	let threads: Vec<_> = (0..8)
+		.map(|_| {
+			let executor = executor.clone();
+			std::thread::spawn(move || {
+				let mut ext = TestExternalities::default();
+				let mut ext = ext.ext();
+				assert_eq!(
+					executor
+						.uncached_call(
+							RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),
+							&mut ext,
+							true,
+							"test_twox_128",
+							&[0],
+						)
+						.unwrap(),
+					array_bytes::hex2bytes_unchecked("99e9d85137db46ef4bbea33613baafd5").encode()
+				);
+			})
+		})
+		.collect();
+
+	for t in threads.into_iter() {
+		t.join().unwrap();
+	}
+}
+
+test_wasm_execution!(wasm_tracing_should_work);
+fn wasm_tracing_should_work(wasm_method: WasmExecutionMethod) {
+	use sc_tracing::{SpanDatum, TraceEvent};
+	use std::sync::Mutex;
+
+	struct TestTraceHandler(Arc<Mutex<Vec<SpanDatum>>>);
+
+	impl sc_tracing::TraceHandler for TestTraceHandler {
+		fn handle_span(&self, sd: &SpanDatum) {
+			self.0.lock().unwrap().push(sd.clone());
+		}
+
+		fn handle_event(&self, _event: &TraceEvent) {}
+	}
+
+	let traces = Arc::new(Mutex::new(Vec::new()));
+	let handler = TestTraceHandler(traces.clone());
+
+	// Create subscriber with wasm_tracing disabled
+	let test_subscriber = tracing_subscriber::fmt()
+		.finish()
+		.with(sc_tracing::ProfilingLayer::new_with_handler(Box::new(handler), "default"));
+
+	let _guard = tracing::subscriber::set_default(test_subscriber);
+
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	let span_id =
+		call_in_wasm("test_enter_span", Default::default(), wasm_method, &mut ext).unwrap();
+
+	let span_id = u64::decode(&mut &span_id[..]).unwrap();
+
+	assert!(span_id > 0);
+
+	call_in_wasm("test_exit_span", &span_id.encode(), wasm_method, &mut ext).unwrap();
+
+	// Check there is only the single trace
+	let len = traces.lock().unwrap().len();
+	assert_eq!(len, 1);
+
+	let span_datum = traces.lock().unwrap().pop().unwrap();
+	let values = span_datum.values;
+	assert_eq!(span_datum.target, "default");
+	assert_eq!(span_datum.name, "");
+	assert_eq!(values.bool_values.get("wasm").unwrap(), &true);
+
+	call_in_wasm("test_nested_spans", Default::default(), wasm_method, &mut ext).unwrap();
+	let len = traces.lock().unwrap().len();
+	assert_eq!(len, 2);
+}
+
+test_wasm_execution!(allocate_two_gigabyte);
+fn allocate_two_gigabyte(wasm_method: WasmExecutionMethod) {
+	let runtime = mk_test_runtime(wasm_method, HeapAllocStrategy::Dynamic { maximum_pages: None });
+
+	let mut instance = runtime.new_instance().unwrap();
+	let res = instance.call_export("allocate_two_gigabyte", &[0]).unwrap();
+	assert_eq!(10 * 1024 * 1024 * 205, u32::decode(&mut &res[..]).unwrap());
+}
+
+test_wasm_execution!(memory_is_cleared_between_invocations);
+fn memory_is_cleared_between_invocations(wasm_method: WasmExecutionMethod) {
+	// This is based on the code generated by compiling a runtime *without*
+	// the `-C link-arg=--import-memory` using the following code and then
+	// disassembling the resulting blob with `wasm-dis`:
+	//
+	// ```
+	// #[no_mangle]
+	// #[cfg(not(feature = "std"))]
+	// pub fn returns_no_bss_mutable_static(_: *mut u8, _: usize) -> u64 {
+	//     static mut COUNTER: usize = 0;
+	//     let output = unsafe {
+	//        COUNTER += 1;
+	//        COUNTER as u64
+	//     };
+	//     sp_core::to_substrate_wasm_fn_return_value(&output)
+	// }
+	// ```
+	//
+	// This results in the BSS section to *not* be emitted, hence the executor has no way
+	// of knowing about the `static` variable's existence, so this test will fail if the linear
+	// memory is not properly cleared between invocations.
+	let binary = wat::parse_str(r#"
+	(module
+	 (type $i32_=>_i32 (func (param i32) (result i32)))
+	 (type $i32_i32_=>_i64 (func (param i32 i32) (result i64)))
+	 (import "env" "ext_allocator_malloc_version_1" (func $ext_allocator_malloc_version_1 (param i32) (result i32)))
+	 (global $__stack_pointer (mut i32) (i32.const 1048576))
+	 (global $global$1 i32 (i32.const 1048580))
+	 (global $global$2 i32 (i32.const 1048592))
+	 (memory $0 17)
+	 (export "memory" (memory $0))
+	 (export "returns_no_bss_mutable_static" (func $returns_no_bss_mutable_static))
+	 (export "__data_end" (global $global$1))
+	 (export "__heap_base" (global $global$2))
+	 (func $returns_no_bss_mutable_static (param $0 i32) (param $1 i32) (result i64)
+	  (local $2 i32)
+	  (local $3 i32)
+	  (i32.store offset=1048576
+	   (i32.const 0)
+	   (local.tee $2
+	    (i32.add
+	     (i32.load offset=1048576 (i32.const 0))
+	     (i32.const 1)
+	    )
+	   )
+	  )
+	  (i64.store
+	   (local.tee $3
+	    (call $ext_allocator_malloc_version_1 (i32.const 8))
+	   )
+	   (i64.extend_i32_u (local.get $2))
+	  )
+	  (i64.or
+	   (i64.extend_i32_u (local.get $3))
+	   (i64.const 34359738368)
+	  )
+	 )
+	)"#).unwrap();
+
+	let runtime = crate::wasm_runtime::create_wasm_runtime_with_code::<HostFunctions>(
+		wasm_method,
+		HeapAllocStrategy::Dynamic { maximum_pages: Some(1024) },
+		RuntimeBlob::uncompress_if_needed(&binary[..]).unwrap(),
+		true,
+		None,
+	)
+	.unwrap();
+
+	let mut instance = runtime.new_instance().unwrap();
+	let res = instance.call_export("returns_no_bss_mutable_static", &[0]).unwrap();
+	assert_eq!(1, u64::decode(&mut &res[..]).unwrap());
+
+	let res = instance.call_export("returns_no_bss_mutable_static", &[0]).unwrap();
+	assert_eq!(1, u64::decode(&mut &res[..]).unwrap());
+}
+
+test_wasm_execution!(return_i8);
+fn return_i8(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	assert_eq!(
+		call_in_wasm("test_return_i8", &[], wasm_method, &mut ext).unwrap(),
+		(-66_i8).encode()
+	);
+}
+
+test_wasm_execution!(take_i8);
+fn take_i8(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	call_in_wasm("test_take_i8", &(-66_i8).encode(), wasm_method, &mut ext).unwrap();
+}
+
+test_wasm_execution!(abort_on_panic);
+fn abort_on_panic(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	match call_in_wasm("test_abort_on_panic", &[], wasm_method, &mut ext).unwrap_err() {
+		Error::AbortedDueToPanic(error) => assert_eq!(error.message, "test_abort_on_panic called"),
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(unreachable_intrinsic);
+fn unreachable_intrinsic(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	match call_in_wasm("test_unreachable_intrinsic", &[], wasm_method, &mut ext).unwrap_err() {
+		Error::AbortedDueToTrap(error) => {
+			let expected = match wasm_method {
+				WasmExecutionMethod::Compiled { .. } =>
+					"wasm trap: wasm `unreachable` instruction executed",
+			};
+			assert_eq!(error.message, expected);
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(return_value);
+fn return_value(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	assert_eq!(
+		call_in_wasm("test_return_value", &[], wasm_method, &mut ext).unwrap(),
+		(1234u64).encode()
+	);
+}
+
+test_wasm_execution!(return_huge_len);
+fn return_huge_len(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	match call_in_wasm("test_return_huge_len", &[], wasm_method, &mut ext).unwrap_err() {
+		Error::OutputExceedsBounds => {
+			assert_matches!(wasm_method, WasmExecutionMethod::Compiled { .. });
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(return_max_memory_offset);
+fn return_max_memory_offset(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	assert_eq!(
+		call_in_wasm("test_return_max_memory_offset", &[], wasm_method, &mut ext).unwrap(),
+		(u8::MAX).encode()
+	);
+}
+
+test_wasm_execution!(return_max_memory_offset_plus_one);
+fn return_max_memory_offset_plus_one(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	match call_in_wasm("test_return_max_memory_offset_plus_one", &[], wasm_method, &mut ext)
+		.unwrap_err()
+	{
+		Error::OutputExceedsBounds => {
+			assert_matches!(wasm_method, WasmExecutionMethod::Compiled { .. });
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(return_overflow);
+fn return_overflow(wasm_method: WasmExecutionMethod) {
+	let mut ext = TestExternalities::default();
+	let mut ext = ext.ext();
+
+	match call_in_wasm("test_return_overflow", &[], wasm_method, &mut ext).unwrap_err() {
+		Error::OutputExceedsBounds => {
+			assert_matches!(wasm_method, WasmExecutionMethod::Compiled { .. });
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
diff --git a/substrate/client/executor/src/lib.rs b/substrate/client/executor/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6ee0ab3512ac0071d51b08a7071d1aaeac53fd2a
--- /dev/null
+++ b/substrate/client/executor/src/lib.rs
@@ -0,0 +1,93 @@
+// 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/>.
+
+//! A crate that provides means of executing/dispatching calls into the runtime.
+//!
+//! There are a few responsibilities of this crate at the moment:
+//!
+//! - It provides an implementation of a common entrypoint for calling into the runtime, both
+//! wasm and compiled.
+//! - It defines the environment for the wasm execution, namely the host functions that are to be
+//! provided into the wasm runtime module.
+//! - It also provides the required infrastructure for executing the current wasm runtime (specified
+//! by the current value of `:code` in the provided externalities), i.e. interfacing with
+//! wasm engine used, instance cache.
+
+#![warn(missing_docs)]
+#![recursion_limit = "128"]
+
+#[macro_use]
+mod executor;
+#[cfg(test)]
+mod integration_tests;
+mod wasm_runtime;
+
+pub use self::{
+	executor::{
+		with_externalities_safe, NativeElseWasmExecutor, NativeExecutionDispatch, WasmExecutor,
+	},
+	wasm_runtime::{read_embedded_version, WasmExecutionMethod},
+};
+pub use codec::Codec;
+#[doc(hidden)]
+pub use sp_core::traits::Externalities;
+pub use sp_version::{NativeVersion, RuntimeVersion};
+#[doc(hidden)]
+pub use sp_wasm_interface;
+
+pub use sc_executor_common::{
+	error,
+	wasm_runtime::{HeapAllocStrategy, DEFAULT_HEAP_ALLOC_PAGES, DEFAULT_HEAP_ALLOC_STRATEGY},
+};
+pub use sc_executor_wasmtime::InstantiationStrategy as WasmtimeInstantiationStrategy;
+
+/// Extracts the runtime version of a given runtime code.
+pub trait RuntimeVersionOf {
+	/// Extract [`RuntimeVersion`](sp_version::RuntimeVersion) of the given `runtime_code`.
+	fn runtime_version(
+		&self,
+		ext: &mut dyn Externalities,
+		runtime_code: &sp_core::traits::RuntimeCode,
+	) -> error::Result<RuntimeVersion>;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_executor_common::runtime_blob::RuntimeBlob;
+	use sc_runtime_test::wasm_binary_unwrap;
+	use sp_io::TestExternalities;
+
+	#[test]
+	fn call_in_interpreted_wasm_works() {
+		let mut ext = TestExternalities::default();
+		let mut ext = ext.ext();
+
+		let executor = WasmExecutor::<sp_io::SubstrateHostFunctions>::builder().build();
+		let res = executor
+			.uncached_call(
+				RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),
+				&mut ext,
+				true,
+				"test_empty_return",
+				&[],
+			)
+			.unwrap();
+		assert_eq!(res, vec![0u8; 0]);
+	}
+}
diff --git a/substrate/client/executor/src/wasm_runtime.rs b/substrate/client/executor/src/wasm_runtime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6dec3abdb20cf5ff50ca8cc3c09102dd7f2a6573
--- /dev/null
+++ b/substrate/client/executor/src/wasm_runtime.rs
@@ -0,0 +1,557 @@
+// 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/>.
+
+//! Traits and accessor functions for calling into the Substrate Wasm runtime.
+//!
+//! The primary means of accessing the runtimes is through a cache which saves the reusable
+//! components of the runtime that are expensive to initialize.
+
+use crate::error::{Error, WasmError};
+
+use codec::Decode;
+use parking_lot::Mutex;
+use sc_executor_common::{
+	runtime_blob::RuntimeBlob,
+	wasm_runtime::{HeapAllocStrategy, WasmInstance, WasmModule},
+};
+use schnellru::{ByLength, LruMap};
+use sp_core::traits::{Externalities, FetchRuntimeCode, RuntimeCode};
+use sp_version::RuntimeVersion;
+use sp_wasm_interface::HostFunctions;
+
+use std::{
+	panic::AssertUnwindSafe,
+	path::{Path, PathBuf},
+	sync::Arc,
+};
+
+/// Specification of different methods of executing the runtime Wasm code.
+#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
+pub enum WasmExecutionMethod {
+	/// Uses the Wasmtime compiled runtime.
+	Compiled {
+		/// The instantiation strategy to use.
+		instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy,
+	},
+}
+
+impl Default for WasmExecutionMethod {
+	fn default() -> Self {
+		Self::Compiled {
+			instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::PoolingCopyOnWrite,
+		}
+	}
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+struct VersionedRuntimeId {
+	/// Runtime code hash.
+	code_hash: Vec<u8>,
+	/// Wasm runtime type.
+	wasm_method: WasmExecutionMethod,
+	/// The heap allocation strategy this runtime was created with.
+	heap_alloc_strategy: HeapAllocStrategy,
+}
+
+/// A Wasm runtime object along with its cached runtime version.
+struct VersionedRuntime {
+	/// Shared runtime that can spawn instances.
+	module: Box<dyn WasmModule>,
+	/// Runtime version according to `Core_version` if any.
+	version: Option<RuntimeVersion>,
+
+	// TODO: Remove this once the legacy instance reuse instantiation strategy
+	//       for `wasmtime` is gone, as this only makes sense with that particular strategy.
+	/// Cached instance pool.
+	instances: Vec<Mutex<Option<Box<dyn WasmInstance>>>>,
+}
+
+impl VersionedRuntime {
+	/// Run the given closure `f` with an instance of this runtime.
+	fn with_instance<R, F>(&self, ext: &mut dyn Externalities, f: F) -> Result<R, Error>
+	where
+		F: FnOnce(
+			&dyn WasmModule,
+			&mut dyn WasmInstance,
+			Option<&RuntimeVersion>,
+			&mut dyn Externalities,
+		) -> Result<R, Error>,
+	{
+		// Find a free instance
+		let instance = self
+			.instances
+			.iter()
+			.enumerate()
+			.find_map(|(index, i)| i.try_lock().map(|i| (index, i)));
+
+		match instance {
+			Some((index, mut locked)) => {
+				let (mut instance, new_inst) = locked
+					.take()
+					.map(|r| Ok((r, false)))
+					.unwrap_or_else(|| self.module.new_instance().map(|i| (i, true)))?;
+
+				let result = f(&*self.module, &mut *instance, self.version.as_ref(), ext);
+				if let Err(e) = &result {
+					if new_inst {
+						tracing::warn!(
+							target: "wasm-runtime",
+							error = %e,
+							"Fresh runtime instance failed",
+						)
+					} else {
+						tracing::warn!(
+							target: "wasm-runtime",
+							error = %e,
+							"Evicting failed runtime instance",
+						);
+					}
+				} else {
+					*locked = Some(instance);
+
+					if new_inst {
+						tracing::debug!(
+							target: "wasm-runtime",
+							"Allocated WASM instance {}/{}",
+							index + 1,
+							self.instances.len(),
+						);
+					}
+				}
+
+				result
+			},
+			None => {
+				tracing::warn!(target: "wasm-runtime", "Ran out of free WASM instances");
+
+				// Allocate a new instance
+				let mut instance = self.module.new_instance()?;
+
+				f(&*self.module, &mut *instance, self.version.as_ref(), ext)
+			},
+		}
+	}
+}
+
+/// Cache for the runtimes.
+///
+/// When an instance is requested for the first time it is added to this cache. Metadata is kept
+/// with the instance so that it can be efficiently reinitialized.
+///
+/// When using the Wasmi interpreter execution method, the metadata includes the initial memory and
+/// values of mutable globals. Follow-up requests to fetch a runtime return this one instance with
+/// the memory reset to the initial memory. So, one runtime instance is reused for every fetch
+/// request.
+///
+/// The size of cache is configurable via the cli option `--runtime-cache-size`.
+pub struct RuntimeCache {
+	/// A cache of runtimes along with metadata.
+	///
+	/// Runtimes sorted by recent usage. The most recently used is at the front.
+	runtimes: Mutex<LruMap<VersionedRuntimeId, Arc<VersionedRuntime>>>,
+	/// The size of the instances cache for each runtime.
+	max_runtime_instances: usize,
+	cache_path: Option<PathBuf>,
+}
+
+impl RuntimeCache {
+	/// Creates a new instance of a runtimes cache.
+	///
+	/// `max_runtime_instances` specifies the number of instances per runtime preserved in an
+	/// in-memory cache.
+	///
+	/// `cache_path` allows to specify an optional directory where the executor can store files
+	/// for caching.
+	///
+	/// `runtime_cache_size` specifies the number of different runtimes versions preserved in an
+	/// in-memory cache, must always be at least 1.
+	pub fn new(
+		max_runtime_instances: usize,
+		cache_path: Option<PathBuf>,
+		runtime_cache_size: u8,
+	) -> RuntimeCache {
+		let cap = ByLength::new(runtime_cache_size.max(1) as u32);
+		RuntimeCache { runtimes: Mutex::new(LruMap::new(cap)), max_runtime_instances, cache_path }
+	}
+
+	/// Prepares a WASM module instance and executes given function for it.
+	///
+	/// This uses internal cache to find available instance or create a new one.
+	/// # Parameters
+	///
+	/// `runtime_code` - The runtime wasm code used setup the runtime.
+	///
+	/// `ext` - The externalities to access the state.
+	///
+	/// `wasm_method` - Type of WASM backend to use.
+	///
+	/// `heap_alloc_strategy` - The heap allocation strategy to use.
+	///
+	/// `allow_missing_func_imports` - Ignore missing function imports.
+	///
+	/// `f` - Function to execute.
+	///
+	/// `H` - A compile-time list of host functions to expose to the runtime.
+	///
+	/// # Returns result of `f` wrapped in an additional result.
+	/// In case of failure one of two errors can be returned:
+	///
+	/// `Err::RuntimeConstruction` is returned for runtime construction issues.
+	///
+	/// `Error::InvalidMemoryReference` is returned if no memory export with the
+	/// identifier `memory` can be found in the runtime.
+	pub fn with_instance<'c, H, R, F>(
+		&self,
+		runtime_code: &'c RuntimeCode<'c>,
+		ext: &mut dyn Externalities,
+		wasm_method: WasmExecutionMethod,
+		heap_alloc_strategy: HeapAllocStrategy,
+		allow_missing_func_imports: bool,
+		f: F,
+	) -> Result<Result<R, Error>, Error>
+	where
+		H: HostFunctions,
+		F: FnOnce(
+			&dyn WasmModule,
+			&mut dyn WasmInstance,
+			Option<&RuntimeVersion>,
+			&mut dyn Externalities,
+		) -> Result<R, Error>,
+	{
+		let code_hash = &runtime_code.hash;
+
+		let versioned_runtime_id =
+			VersionedRuntimeId { code_hash: code_hash.clone(), heap_alloc_strategy, wasm_method };
+
+		let mut runtimes = self.runtimes.lock(); // this must be released prior to calling f
+		let versioned_runtime = if let Some(versioned_runtime) = runtimes.get(&versioned_runtime_id)
+		{
+			versioned_runtime.clone()
+		} else {
+			let code = runtime_code.fetch_runtime_code().ok_or(WasmError::CodeNotFound)?;
+
+			let time = std::time::Instant::now();
+
+			let result = create_versioned_wasm_runtime::<H>(
+				&code,
+				ext,
+				wasm_method,
+				heap_alloc_strategy,
+				allow_missing_func_imports,
+				self.max_runtime_instances,
+				self.cache_path.as_deref(),
+			);
+
+			match result {
+				Ok(ref result) => {
+					tracing::debug!(
+						target: "wasm-runtime",
+						"Prepared new runtime version {:?} in {} ms.",
+						result.version,
+						time.elapsed().as_millis(),
+					);
+				},
+				Err(ref err) => {
+					tracing::warn!(target: "wasm-runtime", error = ?err, "Cannot create a runtime");
+				},
+			}
+
+			let versioned_runtime = Arc::new(result?);
+
+			// Save new versioned wasm runtime in cache
+			runtimes.insert(versioned_runtime_id, versioned_runtime.clone());
+
+			versioned_runtime
+		};
+
+		// Lock must be released prior to calling f
+		drop(runtimes);
+
+		Ok(versioned_runtime.with_instance(ext, f))
+	}
+}
+
+/// Create a wasm runtime with the given `code`.
+pub fn create_wasm_runtime_with_code<H>(
+	wasm_method: WasmExecutionMethod,
+	heap_alloc_strategy: HeapAllocStrategy,
+	blob: RuntimeBlob,
+	allow_missing_func_imports: bool,
+	cache_path: Option<&Path>,
+) -> Result<Box<dyn WasmModule>, WasmError>
+where
+	H: HostFunctions,
+{
+	match wasm_method {
+		WasmExecutionMethod::Compiled { instantiation_strategy } =>
+			sc_executor_wasmtime::create_runtime::<H>(
+				blob,
+				sc_executor_wasmtime::Config {
+					allow_missing_func_imports,
+					cache_path: cache_path.map(ToOwned::to_owned),
+					semantics: sc_executor_wasmtime::Semantics {
+						heap_alloc_strategy,
+						instantiation_strategy,
+						deterministic_stack_limit: None,
+						canonicalize_nans: false,
+						parallel_compilation: true,
+						wasm_multi_value: false,
+						wasm_bulk_memory: false,
+						wasm_reference_types: false,
+						wasm_simd: false,
+					},
+				},
+			)
+			.map(|runtime| -> Box<dyn WasmModule> { Box::new(runtime) }),
+	}
+}
+
+fn decode_version(mut version: &[u8]) -> Result<RuntimeVersion, WasmError> {
+	Decode::decode(&mut version).map_err(|_| {
+		WasmError::Instantiation(
+			"failed to decode \"Core_version\" result using old runtime version".into(),
+		)
+	})
+}
+
+fn decode_runtime_apis(apis: &[u8]) -> Result<Vec<([u8; 8], u32)>, WasmError> {
+	use sp_api::RUNTIME_API_INFO_SIZE;
+
+	apis.chunks(RUNTIME_API_INFO_SIZE)
+		.map(|chunk| {
+			// `chunk` can be less than `RUNTIME_API_INFO_SIZE` if the total length of `apis`
+			// doesn't completely divide by `RUNTIME_API_INFO_SIZE`.
+			<[u8; RUNTIME_API_INFO_SIZE]>::try_from(chunk)
+				.map(sp_api::deserialize_runtime_api_info)
+				.map_err(|_| WasmError::Other("a clipped runtime api info declaration".to_owned()))
+		})
+		.collect::<Result<Vec<_>, WasmError>>()
+}
+
+/// Take the runtime blob and scan it for the custom wasm sections containing the version
+/// information and construct the `RuntimeVersion` from them.
+///
+/// If there are no such sections, it returns `None`. If there is an error during decoding those
+/// sections, `Err` will be returned.
+pub fn read_embedded_version(blob: &RuntimeBlob) -> Result<Option<RuntimeVersion>, WasmError> {
+	if let Some(mut version_section) = blob.custom_section_contents("runtime_version") {
+		let apis = blob
+			.custom_section_contents("runtime_apis")
+			.map(decode_runtime_apis)
+			.transpose()?
+			.map(Into::into);
+
+		let core_version = apis.as_ref().and_then(sp_version::core_version_from_apis);
+		// We do not use `RuntimeVersion::decode` here because that `decode_version` relies on
+		// presence of a special API in the `apis` field to treat the input as a non-legacy version.
+		// However the structure found in the `runtime_version` always contain an empty `apis`
+		// field. Therefore the version read will be mistakenly treated as an legacy one.
+		let mut decoded_version = sp_version::RuntimeVersion::decode_with_version_hint(
+			&mut version_section,
+			core_version,
+		)
+		.map_err(|_| WasmError::Instantiation("failed to decode version section".into()))?;
+
+		if let Some(apis) = apis {
+			decoded_version.apis = apis;
+		}
+
+		Ok(Some(decoded_version))
+	} else {
+		Ok(None)
+	}
+}
+
+fn create_versioned_wasm_runtime<H>(
+	code: &[u8],
+	ext: &mut dyn Externalities,
+	wasm_method: WasmExecutionMethod,
+	heap_alloc_strategy: HeapAllocStrategy,
+	allow_missing_func_imports: bool,
+	max_instances: usize,
+	cache_path: Option<&Path>,
+) -> Result<VersionedRuntime, WasmError>
+where
+	H: HostFunctions,
+{
+	// The incoming code may be actually compressed. We decompress it here and then work with
+	// the uncompressed code from now on.
+	let blob = sc_executor_common::runtime_blob::RuntimeBlob::uncompress_if_needed(code)?;
+
+	// Use the runtime blob to scan if there is any metadata embedded into the wasm binary
+	// pertaining to runtime version. We do it before consuming the runtime blob for creating the
+	// runtime.
+	let mut version = read_embedded_version(&blob)?;
+
+	let runtime = create_wasm_runtime_with_code::<H>(
+		wasm_method,
+		heap_alloc_strategy,
+		blob,
+		allow_missing_func_imports,
+		cache_path,
+	)?;
+
+	// If the runtime blob doesn't embed the runtime version then use the legacy version query
+	// mechanism: call the runtime.
+	if version.is_none() {
+		// Call to determine runtime version.
+		let version_result = {
+			// `ext` is already implicitly handled as unwind safe, as we store it in a global
+			// variable.
+			let mut ext = AssertUnwindSafe(ext);
+
+			// The following unwind safety assertion is OK because if the method call panics, the
+			// runtime will be dropped.
+			let runtime = AssertUnwindSafe(runtime.as_ref());
+			crate::executor::with_externalities_safe(&mut **ext, move || {
+				runtime.new_instance()?.call("Core_version".into(), &[])
+			})
+			.map_err(|_| WasmError::Instantiation("panic in call to get runtime version".into()))?
+		};
+
+		if let Ok(version_buf) = version_result {
+			version = Some(decode_version(&version_buf)?)
+		}
+	}
+
+	let mut instances = Vec::with_capacity(max_instances);
+	instances.resize_with(max_instances, || Mutex::new(None));
+
+	Ok(VersionedRuntime { module: runtime, version, instances })
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::Encode;
+	use sp_api::{Core, RuntimeApiInfo};
+	use sp_runtime::RuntimeString;
+	use sp_wasm_interface::HostFunctions;
+	use substrate_test_runtime::Block;
+
+	#[derive(Encode)]
+	pub struct OldRuntimeVersion {
+		pub spec_name: RuntimeString,
+		pub impl_name: RuntimeString,
+		pub authoring_version: u32,
+		pub spec_version: u32,
+		pub impl_version: u32,
+		pub apis: sp_version::ApisVec,
+	}
+
+	#[test]
+	fn host_functions_are_equal() {
+		let host_functions = sp_io::SubstrateHostFunctions::host_functions();
+
+		let equal = &host_functions[..] == &host_functions[..];
+		assert!(equal, "Host functions are not equal");
+	}
+
+	#[test]
+	fn old_runtime_version_decodes() {
+		let old_runtime_version = OldRuntimeVersion {
+			spec_name: "test".into(),
+			impl_name: "test".into(),
+			authoring_version: 1,
+			spec_version: 1,
+			impl_version: 1,
+			apis: sp_api::create_apis_vec!([(<dyn Core::<Block>>::ID, 1)]),
+		};
+
+		let version = decode_version(&old_runtime_version.encode()).unwrap();
+		assert_eq!(1, version.transaction_version);
+		assert_eq!(0, version.state_version);
+	}
+
+	#[test]
+	fn old_runtime_version_decodes_fails_with_version_3() {
+		let old_runtime_version = OldRuntimeVersion {
+			spec_name: "test".into(),
+			impl_name: "test".into(),
+			authoring_version: 1,
+			spec_version: 1,
+			impl_version: 1,
+			apis: sp_api::create_apis_vec!([(<dyn Core::<Block>>::ID, 3)]),
+		};
+
+		decode_version(&old_runtime_version.encode()).unwrap_err();
+	}
+
+	#[test]
+	fn new_runtime_version_decodes() {
+		let old_runtime_version = sp_api::RuntimeVersion {
+			spec_name: "test".into(),
+			impl_name: "test".into(),
+			authoring_version: 1,
+			spec_version: 1,
+			impl_version: 1,
+			apis: sp_api::create_apis_vec!([(<dyn Core::<Block>>::ID, 3)]),
+			transaction_version: 3,
+			state_version: 4,
+		};
+
+		let version = decode_version(&old_runtime_version.encode()).unwrap();
+		assert_eq!(3, version.transaction_version);
+		assert_eq!(0, version.state_version);
+
+		let old_runtime_version = sp_api::RuntimeVersion {
+			spec_name: "test".into(),
+			impl_name: "test".into(),
+			authoring_version: 1,
+			spec_version: 1,
+			impl_version: 1,
+			apis: sp_api::create_apis_vec!([(<dyn Core::<Block>>::ID, 4)]),
+			transaction_version: 3,
+			state_version: 4,
+		};
+
+		let version = decode_version(&old_runtime_version.encode()).unwrap();
+		assert_eq!(3, version.transaction_version);
+		assert_eq!(4, version.state_version);
+	}
+
+	#[test]
+	fn embed_runtime_version_works() {
+		let wasm = sp_maybe_compressed_blob::decompress(
+			substrate_test_runtime::wasm_binary_unwrap(),
+			sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT,
+		)
+		.expect("Decompressing works");
+		let runtime_version = RuntimeVersion {
+			spec_name: "test_replace".into(),
+			impl_name: "test_replace".into(),
+			authoring_version: 100,
+			spec_version: 100,
+			impl_version: 100,
+			apis: sp_api::create_apis_vec!([(<dyn Core::<Block>>::ID, 4)]),
+			transaction_version: 100,
+			state_version: 1,
+		};
+
+		let embedded = sp_version::embed::embed_runtime_version(&wasm, runtime_version.clone())
+			.expect("Embedding works");
+
+		let blob = RuntimeBlob::new(&embedded).expect("Embedded blob is valid");
+		let read_version = read_embedded_version(&blob)
+			.ok()
+			.flatten()
+			.expect("Reading embedded version works");
+
+		assert_eq!(runtime_version, read_version);
+	}
+}
diff --git a/substrate/client/executor/wasmtime/Cargo.toml b/substrate/client/executor/wasmtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3e669e7c9e70152b06d92585dfb7b3e5a220031e
--- /dev/null
+++ b/substrate/client/executor/wasmtime/Cargo.toml
@@ -0,0 +1,50 @@
+[package]
+name = "sc-executor-wasmtime"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Defines a `WasmRuntime` that uses the Wasmtime JIT to execute."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+log = "0.4.17"
+cfg-if = "1.0"
+libc = "0.2.121"
+
+# When bumping wasmtime do not forget to also bump rustix
+# to exactly the same version as used by wasmtime!
+wasmtime = { version = "8.0.1", default-features = false, features = [
+	"cache",
+	"cranelift",
+	"jitdump",
+	"parallel-compilation",
+	"pooling-allocator"
+] }
+anyhow = "1.0.68"
+sc-allocator = { version = "4.1.0-dev", path = "../../allocator" }
+sc-executor-common = { version = "0.10.0-dev", path = "../common" }
+sp-runtime-interface = { version = "17.0.0", path = "../../../primitives/runtime-interface" }
+sp-wasm-interface = { version = "14.0.0", path = "../../../primitives/wasm-interface", features = ["wasmtime"] }
+
+# Here we include the rustix crate in the exactly same semver-compatible version as used by
+# wasmtime and enable its 'use-libc' flag.
+#
+# By default rustix directly calls the appropriate syscalls completely bypassing libc;
+# this doesn't have any actual benefits for us besides making it harder to debug memory
+# problems (since then `mmap` etc. cannot be easily hooked into).
+rustix = { version = "0.36.7", default-features = false, features = ["std", "mm", "fs", "param", "use-libc"] }
+
+[dev-dependencies]
+wat = "1.0"
+sc-runtime-test = { version = "2.0.0", path = "../runtime-test" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+tempfile = "3.3.0"
+paste = "1.0"
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+cargo_metadata = "0.15.4"
diff --git a/substrate/client/executor/wasmtime/README.md b/substrate/client/executor/wasmtime/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3e9ac0bddbdc17539d12893553789983e38ab05f
--- /dev/null
+++ b/substrate/client/executor/wasmtime/README.md
@@ -0,0 +1 @@
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/executor/wasmtime/build.rs b/substrate/client/executor/wasmtime/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a68cb706e8fbdc2526aa18730f0e7ddb9719f838
--- /dev/null
+++ b/substrate/client/executor/wasmtime/build.rs
@@ -0,0 +1,25 @@
+// 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 std::env;
+
+fn main() {
+	if let Ok(profile) = env::var("PROFILE") {
+		println!("cargo:rustc-cfg=build_type=\"{}\"", profile);
+	}
+}
diff --git a/substrate/client/executor/wasmtime/src/host.rs b/substrate/client/executor/wasmtime/src/host.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9bd3ca3dade5eaefc4f9457bd43663b0effaf03d
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/host.rs
@@ -0,0 +1,128 @@
+// 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/>.
+
+//! This module defines `HostState` and `HostContext` structs which provide logic and state
+//! required for execution of host.
+
+use wasmtime::Caller;
+
+use sc_allocator::{AllocationStats, FreeingBumpHeapAllocator};
+use sp_wasm_interface::{Pointer, WordSize};
+
+use crate::{instance_wrapper::MemoryWrapper, runtime::StoreData, util};
+
+/// The state required to construct a HostContext context. The context only lasts for one host
+/// call, whereas the state is maintained for the duration of a Wasm runtime call, which may make
+/// many different host calls that must share state.
+pub struct HostState {
+	/// The allocator instance to keep track of allocated memory.
+	///
+	/// This is stored as an `Option` as we need to temporarly set this to `None` when we are
+	/// allocating/deallocating memory. The problem being that we can only mutable access `caller`
+	/// once.
+	allocator: Option<FreeingBumpHeapAllocator>,
+	panic_message: Option<String>,
+}
+
+impl HostState {
+	/// Constructs a new `HostState`.
+	pub fn new(allocator: FreeingBumpHeapAllocator) -> Self {
+		HostState { allocator: Some(allocator), panic_message: None }
+	}
+
+	/// Takes the error message out of the host state, leaving a `None` in its place.
+	pub fn take_panic_message(&mut self) -> Option<String> {
+		self.panic_message.take()
+	}
+
+	pub(crate) fn allocation_stats(&self) -> AllocationStats {
+		self.allocator.as_ref()
+			.expect("Allocator is always set and only unavailable when doing an allocation/deallocation; qed")
+			.stats()
+	}
+}
+
+/// A `HostContext` implements `FunctionContext` for making host calls from a Wasmtime
+/// runtime. The `HostContext` exists only for the lifetime of the call and borrows state from
+/// a longer-living `HostState`.
+pub(crate) struct HostContext<'a> {
+	pub(crate) caller: Caller<'a, StoreData>,
+}
+
+impl<'a> HostContext<'a> {
+	fn host_state_mut(&mut self) -> &mut HostState {
+		self.caller
+			.data_mut()
+			.host_state_mut()
+			.expect("host state is not empty when calling a function in wasm; qed")
+	}
+}
+
+impl<'a> sp_wasm_interface::FunctionContext for HostContext<'a> {
+	fn read_memory_into(
+		&self,
+		address: Pointer<u8>,
+		dest: &mut [u8],
+	) -> sp_wasm_interface::Result<()> {
+		util::read_memory_into(&self.caller, address, dest).map_err(|e| e.to_string())
+	}
+
+	fn write_memory(&mut self, address: Pointer<u8>, data: &[u8]) -> sp_wasm_interface::Result<()> {
+		util::write_memory_from(&mut self.caller, address, data).map_err(|e| e.to_string())
+	}
+
+	fn allocate_memory(&mut self, size: WordSize) -> sp_wasm_interface::Result<Pointer<u8>> {
+		let memory = self.caller.data().memory();
+		let mut allocator = self
+			.host_state_mut()
+			.allocator
+			.take()
+			.expect("allocator is not empty when calling a function in wasm; qed");
+
+		// We can not return on error early, as we need to store back allocator.
+		let res = allocator
+			.allocate(&mut MemoryWrapper(&memory, &mut self.caller), size)
+			.map_err(|e| e.to_string());
+
+		self.host_state_mut().allocator = Some(allocator);
+
+		res
+	}
+
+	fn deallocate_memory(&mut self, ptr: Pointer<u8>) -> sp_wasm_interface::Result<()> {
+		let memory = self.caller.data().memory();
+		let mut allocator = self
+			.host_state_mut()
+			.allocator
+			.take()
+			.expect("allocator is not empty when calling a function in wasm; qed");
+
+		// We can not return on error early, as we need to store back allocator.
+		let res = allocator
+			.deallocate(&mut MemoryWrapper(&memory, &mut self.caller), ptr)
+			.map_err(|e| e.to_string());
+
+		self.host_state_mut().allocator = Some(allocator);
+
+		res
+	}
+
+	fn register_panic_error_message(&mut self, message: &str) {
+		self.host_state_mut().panic_message = Some(message.to_owned());
+	}
+}
diff --git a/substrate/client/executor/wasmtime/src/imports.rs b/substrate/client/executor/wasmtime/src/imports.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fccc121fa0887c07abeb3fa9a0def1698330e58c
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/imports.rs
@@ -0,0 +1,123 @@
+// 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::{host::HostContext, runtime::StoreData};
+use sc_executor_common::error::WasmError;
+use sp_wasm_interface::{FunctionContext, HostFunctions};
+use std::collections::HashMap;
+use wasmtime::{ExternType, FuncType, ImportType, Linker, Module};
+
+/// Goes over all imports of a module and prepares the given linker for instantiation of the module.
+/// Returns an error if there are imports that cannot be satisfied.
+pub(crate) fn prepare_imports<H>(
+	linker: &mut Linker<StoreData>,
+	module: &Module,
+	allow_missing_func_imports: bool,
+) -> Result<(), WasmError>
+where
+	H: HostFunctions,
+{
+	let mut pending_func_imports = HashMap::new();
+	for import_ty in module.imports() {
+		let name = import_ty.name();
+
+		if import_ty.module() != "env" {
+			return Err(WasmError::Other(format!(
+				"host doesn't provide any imports from non-env module: {}:{}",
+				import_ty.module(),
+				name,
+			)))
+		}
+
+		match import_ty.ty() {
+			ExternType::Func(func_ty) => {
+				pending_func_imports.insert(name.to_owned(), (import_ty, func_ty));
+			},
+			_ =>
+				return Err(WasmError::Other(format!(
+					"host doesn't provide any non function imports: {}:{}",
+					import_ty.module(),
+					name,
+				))),
+		};
+	}
+
+	let mut registry = Registry { linker, pending_func_imports };
+	H::register_static(&mut registry)?;
+
+	if !registry.pending_func_imports.is_empty() {
+		if allow_missing_func_imports {
+			for (name, (import_ty, func_ty)) in registry.pending_func_imports {
+				let error = format!("call to a missing function {}:{}", import_ty.module(), name);
+				log::debug!("Missing import: '{}' {:?}", name, func_ty);
+				linker
+					.func_new("env", &name, func_ty.clone(), move |_, _, _| {
+					    Err(anyhow::Error::msg(error.clone()))
+					})
+					.expect("adding a missing import stub can only fail when the item already exists, and it is missing here; qed");
+			}
+		} else {
+			let mut names = Vec::new();
+			for (name, (import_ty, _)) in registry.pending_func_imports {
+				names.push(format!("'{}:{}'", import_ty.module(), name));
+			}
+			let names = names.join(", ");
+			return Err(WasmError::Other(format!(
+				"runtime requires function imports which are not present on the host: {}",
+				names
+			)))
+		}
+	}
+
+	Ok(())
+}
+
+struct Registry<'a, 'b> {
+	linker: &'a mut Linker<StoreData>,
+	pending_func_imports: HashMap<String, (ImportType<'b>, FuncType)>,
+}
+
+impl<'a, 'b> sp_wasm_interface::HostFunctionRegistry for Registry<'a, 'b> {
+	type State = StoreData;
+	type Error = WasmError;
+	type FunctionContext = HostContext<'a>;
+
+	fn with_function_context<R>(
+		caller: wasmtime::Caller<Self::State>,
+		callback: impl FnOnce(&mut dyn FunctionContext) -> R,
+	) -> R {
+		callback(&mut HostContext { caller })
+	}
+
+	fn register_static<Params, Results>(
+		&mut self,
+		fn_name: &str,
+		func: impl wasmtime::IntoFunc<Self::State, Params, Results>,
+	) -> Result<(), Self::Error> {
+		if self.pending_func_imports.remove(fn_name).is_some() {
+			self.linker.func_wrap("env", fn_name, func).map_err(|error| {
+				WasmError::Other(format!(
+					"failed to register host function '{}' with the WASM linker: {:#}",
+					fn_name, error
+				))
+			})?;
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/client/executor/wasmtime/src/instance_wrapper.rs b/substrate/client/executor/wasmtime/src/instance_wrapper.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6d319cce509e54c6c52c2f55359e6c4bedd64bae
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/instance_wrapper.rs
@@ -0,0 +1,405 @@
+// 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/>.
+
+//! Defines data and logic needed for interaction with an WebAssembly instance of a substrate
+//! runtime module.
+
+use crate::runtime::{Store, StoreData};
+use sc_executor_common::{
+	error::{Backtrace, Error, MessageWithBacktrace, Result, WasmError},
+	wasm_runtime::InvokeMethod,
+};
+use sp_wasm_interface::{Pointer, Value, WordSize};
+use wasmtime::{
+	AsContext, AsContextMut, Engine, Extern, Instance, InstancePre, Memory, Table, Val,
+};
+
+/// Invoked entrypoint format.
+pub enum EntryPointType {
+	/// Direct call.
+	///
+	/// Call is made by providing only payload reference and length.
+	Direct { entrypoint: wasmtime::TypedFunc<(u32, u32), u64> },
+	/// Indirect call.
+	///
+	/// Call is made by providing payload reference and length, and extra argument
+	/// for advanced routing.
+	Wrapped {
+		/// The extra argument passed to the runtime. It is typically a wasm function pointer.
+		func: u32,
+		dispatcher: wasmtime::TypedFunc<(u32, u32, u32), u64>,
+	},
+}
+
+/// Wasm blob entry point.
+pub struct EntryPoint {
+	call_type: EntryPointType,
+}
+
+impl EntryPoint {
+	/// Call this entry point.
+	pub(crate) fn call(
+		&self,
+		store: &mut Store,
+		data_ptr: Pointer<u8>,
+		data_len: WordSize,
+	) -> Result<u64> {
+		let data_ptr = u32::from(data_ptr);
+		let data_len = u32::from(data_len);
+
+		match self.call_type {
+			EntryPointType::Direct { ref entrypoint } =>
+				entrypoint.call(&mut *store, (data_ptr, data_len)),
+			EntryPointType::Wrapped { func, ref dispatcher } =>
+				dispatcher.call(&mut *store, (func, data_ptr, data_len)),
+		}
+		.map_err(|trap| {
+			let host_state = store
+				.data_mut()
+				.host_state
+				.as_mut()
+				.expect("host state cannot be empty while a function is being called; qed");
+
+			let backtrace = trap.downcast_ref::<wasmtime::WasmBacktrace>().map(|backtrace| {
+				// The logic to print out a backtrace is somewhat complicated,
+				// so let's get wasmtime to print it out for us.
+				Backtrace { backtrace_string: backtrace.to_string() }
+			});
+
+			if let Some(message) = host_state.take_panic_message() {
+				Error::AbortedDueToPanic(MessageWithBacktrace { message, backtrace })
+			} else {
+				let message = trap.root_cause().to_string();
+				Error::AbortedDueToTrap(MessageWithBacktrace { message, backtrace })
+			}
+		})
+	}
+
+	pub fn direct(
+		func: wasmtime::Func,
+		ctx: impl AsContext,
+	) -> std::result::Result<Self, &'static str> {
+		let entrypoint = func
+			.typed::<(u32, u32), u64>(ctx)
+			.map_err(|_| "Invalid signature for direct entry point")?;
+		Ok(Self { call_type: EntryPointType::Direct { entrypoint } })
+	}
+
+	pub fn wrapped(
+		dispatcher: wasmtime::Func,
+		func: u32,
+		ctx: impl AsContext,
+	) -> std::result::Result<Self, &'static str> {
+		let dispatcher = dispatcher
+			.typed::<(u32, u32, u32), u64>(ctx)
+			.map_err(|_| "Invalid signature for wrapped entry point")?;
+		Ok(Self { call_type: EntryPointType::Wrapped { func, dispatcher } })
+	}
+}
+
+/// Wrapper around [`Memory`] that implements [`sc_allocator::Memory`].
+pub(crate) struct MemoryWrapper<'a, C>(pub &'a wasmtime::Memory, pub &'a mut C);
+
+impl<C: AsContextMut> sc_allocator::Memory for MemoryWrapper<'_, C> {
+	fn with_access<R>(&self, run: impl FnOnce(&[u8]) -> R) -> R {
+		run(self.0.data(&self.1))
+	}
+
+	fn with_access_mut<R>(&mut self, run: impl FnOnce(&mut [u8]) -> R) -> R {
+		run(self.0.data_mut(&mut self.1))
+	}
+
+	fn grow(&mut self, additional: u32) -> std::result::Result<(), ()> {
+		self.0
+			.grow(&mut self.1, additional as u64)
+			.map_err(|e| {
+				log::error!(
+					target: "wasm-executor",
+					"Failed to grow memory by {} pages: {}",
+					additional,
+					e,
+				)
+			})
+			.map(drop)
+	}
+
+	fn pages(&self) -> u32 {
+		self.0.size(&self.1) as u32
+	}
+
+	fn max_pages(&self) -> Option<u32> {
+		self.0.ty(&self.1).maximum().map(|p| p as _)
+	}
+}
+
+/// Wrap the given WebAssembly Instance of a wasm module with Substrate-runtime.
+///
+/// This struct is a handy wrapper around a wasmtime `Instance` that provides substrate specific
+/// routines.
+pub struct InstanceWrapper {
+	instance: Instance,
+	/// The memory instance of the `instance`.
+	///
+	/// It is important to make sure that we don't make any copies of this to make it easier to
+	/// proof
+	memory: Memory,
+	store: Store,
+}
+
+impl InstanceWrapper {
+	pub(crate) fn new(engine: &Engine, instance_pre: &InstancePre<StoreData>) -> Result<Self> {
+		let mut store = Store::new(engine, Default::default());
+		let instance = instance_pre.instantiate(&mut store).map_err(|error| {
+			WasmError::Other(format!(
+				"failed to instantiate a new WASM module instance: {:#}",
+				error,
+			))
+		})?;
+
+		let memory = get_linear_memory(&instance, &mut store)?;
+		let table = get_table(&instance, &mut store);
+
+		store.data_mut().memory = Some(memory);
+		store.data_mut().table = table;
+
+		Ok(InstanceWrapper { instance, memory, store })
+	}
+
+	/// Resolves a substrate entrypoint by the given name.
+	///
+	/// An entrypoint must have a signature `(i32, i32) -> i64`, otherwise this function will return
+	/// an error.
+	pub fn resolve_entrypoint(&mut self, method: InvokeMethod) -> Result<EntryPoint> {
+		Ok(match method {
+			InvokeMethod::Export(method) => {
+				// Resolve the requested method and verify that it has a proper signature.
+				let export =
+					self.instance.get_export(&mut self.store, method).ok_or_else(|| {
+						Error::from(format!("Exported method {} is not found", method))
+					})?;
+				let func = export
+					.into_func()
+					.ok_or_else(|| Error::from(format!("Export {} is not a function", method)))?;
+				EntryPoint::direct(func, &self.store).map_err(|_| {
+					Error::from(format!("Exported function '{}' has invalid signature.", method))
+				})?
+			},
+			InvokeMethod::Table(func_ref) => {
+				let table = self
+					.instance
+					.get_table(&mut self.store, "__indirect_function_table")
+					.ok_or(Error::NoTable)?;
+				let val = table
+					.get(&mut self.store, func_ref)
+					.ok_or(Error::NoTableEntryWithIndex(func_ref))?;
+				let func = val
+					.funcref()
+					.ok_or(Error::TableElementIsNotAFunction(func_ref))?
+					.ok_or(Error::FunctionRefIsNull(func_ref))?;
+
+				EntryPoint::direct(*func, &self.store).map_err(|_| {
+					Error::from(format!(
+						"Function @{} in exported table has invalid signature for direct call.",
+						func_ref,
+					))
+				})?
+			},
+			InvokeMethod::TableWithWrapper { dispatcher_ref, func } => {
+				let table = self
+					.instance
+					.get_table(&mut self.store, "__indirect_function_table")
+					.ok_or(Error::NoTable)?;
+				let val = table
+					.get(&mut self.store, dispatcher_ref)
+					.ok_or(Error::NoTableEntryWithIndex(dispatcher_ref))?;
+				let dispatcher = val
+					.funcref()
+					.ok_or(Error::TableElementIsNotAFunction(dispatcher_ref))?
+					.ok_or(Error::FunctionRefIsNull(dispatcher_ref))?;
+
+				EntryPoint::wrapped(*dispatcher, func, &self.store).map_err(|_| {
+					Error::from(format!(
+						"Function @{} in exported table has invalid signature for wrapped call.",
+						dispatcher_ref,
+					))
+				})?
+			},
+		})
+	}
+
+	/// Reads `__heap_base: i32` global variable and returns it.
+	///
+	/// If it doesn't exist, not a global or of not i32 type returns an error.
+	pub fn extract_heap_base(&mut self) -> Result<u32> {
+		let heap_base_export = self
+			.instance
+			.get_export(&mut self.store, "__heap_base")
+			.ok_or_else(|| Error::from("__heap_base is not found"))?;
+
+		let heap_base_global = heap_base_export
+			.into_global()
+			.ok_or_else(|| Error::from("__heap_base is not a global"))?;
+
+		let heap_base = heap_base_global
+			.get(&mut self.store)
+			.i32()
+			.ok_or_else(|| Error::from("__heap_base is not a i32"))?;
+
+		Ok(heap_base as u32)
+	}
+
+	/// Get the value from a global with the given `name`.
+	pub fn get_global_val(&mut self, name: &str) -> Result<Option<Value>> {
+		let global = match self.instance.get_export(&mut self.store, name) {
+			Some(global) => global,
+			None => return Ok(None),
+		};
+
+		let global = global.into_global().ok_or_else(|| format!("`{}` is not a global", name))?;
+
+		match global.get(&mut self.store) {
+			Val::I32(val) => Ok(Some(Value::I32(val))),
+			Val::I64(val) => Ok(Some(Value::I64(val))),
+			Val::F32(val) => Ok(Some(Value::F32(val))),
+			Val::F64(val) => Ok(Some(Value::F64(val))),
+			_ => Err("Unknown value type".into()),
+		}
+	}
+
+	/// Get a global with the given `name`.
+	pub fn get_global(&mut self, name: &str) -> Option<wasmtime::Global> {
+		self.instance.get_global(&mut self.store, name)
+	}
+}
+
+/// Extract linear memory instance from the given instance.
+fn get_linear_memory(instance: &Instance, ctx: impl AsContextMut) -> Result<Memory> {
+	let memory_export = instance
+		.get_export(ctx, "memory")
+		.ok_or_else(|| Error::from("memory is not exported under `memory` name"))?;
+
+	let memory = memory_export
+		.into_memory()
+		.ok_or_else(|| Error::from("the `memory` export should have memory type"))?;
+
+	Ok(memory)
+}
+
+/// Extract the table from the given instance if any.
+fn get_table(instance: &Instance, ctx: &mut Store) -> Option<Table> {
+	instance
+		.get_export(ctx, "__indirect_function_table")
+		.as_ref()
+		.cloned()
+		.and_then(Extern::into_table)
+}
+
+/// Functions related to memory.
+impl InstanceWrapper {
+	/// Returns the pointer to the first byte of the linear memory for this instance.
+	pub fn base_ptr(&self) -> *const u8 {
+		self.memory.data_ptr(&self.store)
+	}
+
+	/// If possible removes physical backing from the allocated linear memory which
+	/// leads to returning the memory back to the system; this also zeroes the memory
+	/// as a side-effect.
+	pub fn decommit(&mut self) {
+		if self.memory.data_size(&self.store) == 0 {
+			return
+		}
+
+		cfg_if::cfg_if! {
+			if #[cfg(target_os = "linux")] {
+				use std::sync::Once;
+
+				unsafe {
+					let ptr = self.memory.data_ptr(&self.store);
+					let len = self.memory.data_size(&self.store);
+
+					// Linux handles MADV_DONTNEED reliably. The result is that the given area
+					// is unmapped and will be zeroed on the next pagefault.
+					if libc::madvise(ptr as _, len, libc::MADV_DONTNEED) != 0 {
+						static LOGGED: Once = Once::new();
+						LOGGED.call_once(|| {
+							log::warn!(
+								"madvise(MADV_DONTNEED) failed: {}",
+								std::io::Error::last_os_error(),
+							);
+						});
+					} else {
+						return;
+					}
+				}
+			} else if #[cfg(target_os = "macos")] {
+				use std::sync::Once;
+
+				unsafe {
+					let ptr = self.memory.data_ptr(&self.store);
+					let len = self.memory.data_size(&self.store);
+
+					// On MacOS we can simply overwrite memory mapping.
+					if libc::mmap(
+						ptr as _,
+						len,
+						libc::PROT_READ | libc::PROT_WRITE,
+						libc::MAP_FIXED | libc::MAP_PRIVATE | libc::MAP_ANONYMOUS,
+						-1,
+						0,
+					) == libc::MAP_FAILED {
+						static LOGGED: Once = Once::new();
+						LOGGED.call_once(|| {
+							log::warn!(
+								"Failed to decommit WASM instance memory through mmap: {}",
+								std::io::Error::last_os_error(),
+							);
+						});
+					} else {
+						return;
+					}
+				}
+			}
+		}
+
+		// If we're on an unsupported OS or the memory couldn't have been
+		// decommited for some reason then just manually zero it out.
+		self.memory.data_mut(self.store.as_context_mut()).fill(0);
+	}
+
+	pub(crate) fn store(&self) -> &Store {
+		&self.store
+	}
+
+	pub(crate) fn store_mut(&mut self) -> &mut Store {
+		&mut self.store
+	}
+}
+
+#[test]
+fn decommit_works() {
+	let engine = wasmtime::Engine::default();
+	let code = wat::parse_str("(module (memory (export \"memory\") 1 4))").unwrap();
+	let module = wasmtime::Module::new(&engine, code).unwrap();
+	let linker = wasmtime::Linker::new(&engine);
+	let instance_pre = linker.instantiate_pre(&module).unwrap();
+	let mut wrapper = InstanceWrapper::new(&engine, &instance_pre).unwrap();
+	unsafe { *wrapper.memory.data_ptr(&wrapper.store) = 42 };
+	assert_eq!(unsafe { *wrapper.memory.data_ptr(&wrapper.store) }, 42);
+	wrapper.decommit();
+	assert_eq!(unsafe { *wrapper.memory.data_ptr(&wrapper.store) }, 0);
+}
diff --git a/substrate/client/executor/wasmtime/src/lib.rs b/substrate/client/executor/wasmtime/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..82e62b4a5dd3cd6d7b009e019f0c24c28551743a
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/lib.rs
@@ -0,0 +1,43 @@
+// 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/>.
+
+//! Defines a `WasmRuntime` that uses the Wasmtime JIT to execute.
+//!
+//! You can choose a profiling strategy at runtime with
+//! environment variable `WASMTIME_PROFILING_STRATEGY`:
+//!
+//! | `WASMTIME_PROFILING_STRATEGY` | Effect |
+//! |-------------|-------------------------|
+//! | undefined   | No profiling            |
+//! | `"jitdump"` | jitdump profiling       |
+//! | other value | No profiling (warning)  |
+
+mod host;
+mod imports;
+mod instance_wrapper;
+mod runtime;
+mod util;
+
+#[cfg(test)]
+mod tests;
+
+pub use runtime::{
+	create_runtime, create_runtime_from_artifact, create_runtime_from_artifact_bytes,
+	prepare_runtime_artifact, Config, DeterministicStackLimit, InstantiationStrategy, Semantics,
+	WasmtimeRuntime,
+};
diff --git a/substrate/client/executor/wasmtime/src/runtime.rs b/substrate/client/executor/wasmtime/src/runtime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..23b069870aa36f8c7e2b2e0fa45f9126c86c24de
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/runtime.rs
@@ -0,0 +1,832 @@
+// 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/>.
+
+//! Defines the compiled Wasm runtime that uses Wasmtime internally.
+
+use crate::{
+	host::HostState,
+	instance_wrapper::{EntryPoint, InstanceWrapper, MemoryWrapper},
+	util::{self, replace_strategy_if_broken},
+};
+
+use sc_allocator::{AllocationStats, FreeingBumpHeapAllocator};
+use sc_executor_common::{
+	error::{Error, Result, WasmError},
+	runtime_blob::{
+		self, DataSegmentsSnapshot, ExposedMutableGlobalsSet, GlobalsSnapshot, RuntimeBlob,
+	},
+	util::checked_range,
+	wasm_runtime::{HeapAllocStrategy, InvokeMethod, WasmInstance, WasmModule},
+};
+use sp_runtime_interface::unpack_ptr_and_len;
+use sp_wasm_interface::{HostFunctions, Pointer, Value, WordSize};
+use std::{
+	path::{Path, PathBuf},
+	sync::{
+		atomic::{AtomicBool, Ordering},
+		Arc,
+	},
+};
+use wasmtime::{AsContext, Engine, Memory, Table};
+
+#[derive(Default)]
+pub(crate) struct StoreData {
+	/// This will only be set when we call into the runtime.
+	pub(crate) host_state: Option<HostState>,
+	/// This will be always set once the store is initialized.
+	pub(crate) memory: Option<Memory>,
+	/// This will be set only if the runtime actually contains a table.
+	pub(crate) table: Option<Table>,
+}
+
+impl StoreData {
+	/// Returns a mutable reference to the host state.
+	pub fn host_state_mut(&mut self) -> Option<&mut HostState> {
+		self.host_state.as_mut()
+	}
+
+	/// Returns the host memory.
+	pub fn memory(&self) -> Memory {
+		self.memory.expect("memory is always set; qed")
+	}
+}
+
+pub(crate) type Store = wasmtime::Store<StoreData>;
+
+enum Strategy {
+	LegacyInstanceReuse {
+		instance_wrapper: InstanceWrapper,
+		globals_snapshot: GlobalsSnapshot<wasmtime::Global>,
+		data_segments_snapshot: Arc<DataSegmentsSnapshot>,
+		heap_base: u32,
+	},
+	RecreateInstance(InstanceCreator),
+}
+
+struct InstanceCreator {
+	engine: wasmtime::Engine,
+	instance_pre: Arc<wasmtime::InstancePre<StoreData>>,
+}
+
+impl InstanceCreator {
+	fn instantiate(&mut self) -> Result<InstanceWrapper> {
+		InstanceWrapper::new(&self.engine, &self.instance_pre)
+	}
+}
+
+struct InstanceGlobals<'a> {
+	instance: &'a mut InstanceWrapper,
+}
+
+impl<'a> runtime_blob::InstanceGlobals for InstanceGlobals<'a> {
+	type Global = wasmtime::Global;
+
+	fn get_global(&mut self, export_name: &str) -> Self::Global {
+		self.instance
+			.get_global(export_name)
+			.expect("get_global is guaranteed to be called with an export name of a global; qed")
+	}
+
+	fn get_global_value(&mut self, global: &Self::Global) -> Value {
+		util::from_wasmtime_val(global.get(&mut self.instance.store_mut()))
+	}
+
+	fn set_global_value(&mut self, global: &Self::Global, value: Value) {
+		global.set(&mut self.instance.store_mut(), util::into_wasmtime_val(value)).expect(
+			"the value is guaranteed to be of the same value; the global is guaranteed to be mutable; qed",
+		);
+	}
+}
+
+/// Data required for creating instances with the fast instance reuse strategy.
+struct InstanceSnapshotData {
+	mutable_globals: ExposedMutableGlobalsSet,
+	data_segments_snapshot: Arc<DataSegmentsSnapshot>,
+}
+
+/// A `WasmModule` implementation using wasmtime to compile the runtime module to machine code
+/// and execute the compiled code.
+pub struct WasmtimeRuntime {
+	engine: wasmtime::Engine,
+	instance_pre: Arc<wasmtime::InstancePre<StoreData>>,
+	instantiation_strategy: InternalInstantiationStrategy,
+}
+
+impl WasmModule for WasmtimeRuntime {
+	fn new_instance(&self) -> Result<Box<dyn WasmInstance>> {
+		let strategy = match self.instantiation_strategy {
+			InternalInstantiationStrategy::LegacyInstanceReuse(ref snapshot_data) => {
+				let mut instance_wrapper = InstanceWrapper::new(&self.engine, &self.instance_pre)?;
+				let heap_base = instance_wrapper.extract_heap_base()?;
+
+				// This function panics if the instance was created from a runtime blob different
+				// from which the mutable globals were collected. Here, it is easy to see that there
+				// is only a single runtime blob and thus it's the same that was used for both
+				// creating the instance and collecting the mutable globals.
+				let globals_snapshot = GlobalsSnapshot::take(
+					&snapshot_data.mutable_globals,
+					&mut InstanceGlobals { instance: &mut instance_wrapper },
+				);
+
+				Strategy::LegacyInstanceReuse {
+					instance_wrapper,
+					globals_snapshot,
+					data_segments_snapshot: snapshot_data.data_segments_snapshot.clone(),
+					heap_base,
+				}
+			},
+			InternalInstantiationStrategy::Builtin => Strategy::RecreateInstance(InstanceCreator {
+				engine: self.engine.clone(),
+				instance_pre: self.instance_pre.clone(),
+			}),
+		};
+
+		Ok(Box::new(WasmtimeInstance { strategy }))
+	}
+}
+
+/// A `WasmInstance` implementation that reuses compiled module and spawns instances
+/// to execute the compiled code.
+pub struct WasmtimeInstance {
+	strategy: Strategy,
+}
+
+impl WasmtimeInstance {
+	fn call_impl(
+		&mut self,
+		method: InvokeMethod,
+		data: &[u8],
+		allocation_stats: &mut Option<AllocationStats>,
+	) -> Result<Vec<u8>> {
+		match &mut self.strategy {
+			Strategy::LegacyInstanceReuse {
+				ref mut instance_wrapper,
+				globals_snapshot,
+				data_segments_snapshot,
+				heap_base,
+			} => {
+				let entrypoint = instance_wrapper.resolve_entrypoint(method)?;
+
+				data_segments_snapshot.apply(|offset, contents| {
+					util::write_memory_from(
+						instance_wrapper.store_mut(),
+						Pointer::new(offset),
+						contents,
+					)
+				})?;
+				globals_snapshot.apply(&mut InstanceGlobals { instance: instance_wrapper });
+				let allocator = FreeingBumpHeapAllocator::new(*heap_base);
+
+				let result =
+					perform_call(data, instance_wrapper, entrypoint, allocator, allocation_stats);
+
+				// Signal to the OS that we are done with the linear memory and that it can be
+				// reclaimed.
+				instance_wrapper.decommit();
+
+				result
+			},
+			Strategy::RecreateInstance(ref mut instance_creator) => {
+				let mut instance_wrapper = instance_creator.instantiate()?;
+				let heap_base = instance_wrapper.extract_heap_base()?;
+				let entrypoint = instance_wrapper.resolve_entrypoint(method)?;
+
+				let allocator = FreeingBumpHeapAllocator::new(heap_base);
+				perform_call(data, &mut instance_wrapper, entrypoint, allocator, allocation_stats)
+			},
+		}
+	}
+}
+
+impl WasmInstance for WasmtimeInstance {
+	fn call_with_allocation_stats(
+		&mut self,
+		method: InvokeMethod,
+		data: &[u8],
+	) -> (Result<Vec<u8>>, Option<AllocationStats>) {
+		let mut allocation_stats = None;
+		let result = self.call_impl(method, data, &mut allocation_stats);
+		(result, allocation_stats)
+	}
+
+	fn get_global_const(&mut self, name: &str) -> Result<Option<Value>> {
+		match &mut self.strategy {
+			Strategy::LegacyInstanceReuse { instance_wrapper, .. } =>
+				instance_wrapper.get_global_val(name),
+			Strategy::RecreateInstance(ref mut instance_creator) =>
+				instance_creator.instantiate()?.get_global_val(name),
+		}
+	}
+
+	fn linear_memory_base_ptr(&self) -> Option<*const u8> {
+		match &self.strategy {
+			Strategy::RecreateInstance(_) => {
+				// We do not keep the wasm instance around, therefore there is no linear memory
+				// associated with it.
+				None
+			},
+			Strategy::LegacyInstanceReuse { instance_wrapper, .. } =>
+				Some(instance_wrapper.base_ptr()),
+		}
+	}
+}
+
+/// Prepare a directory structure and a config file to enable wasmtime caching.
+///
+/// In case of an error the caching will not be enabled.
+fn setup_wasmtime_caching(
+	cache_path: &Path,
+	config: &mut wasmtime::Config,
+) -> std::result::Result<(), String> {
+	use std::fs;
+
+	let wasmtime_cache_root = cache_path.join("wasmtime");
+	fs::create_dir_all(&wasmtime_cache_root)
+		.map_err(|err| format!("cannot create the dirs to cache: {}", err))?;
+
+	// Canonicalize the path after creating the directories.
+	let wasmtime_cache_root = wasmtime_cache_root
+		.canonicalize()
+		.map_err(|err| format!("failed to canonicalize the path: {}", err))?;
+
+	// Write the cache config file
+	let cache_config_path = wasmtime_cache_root.join("cache-config.toml");
+	let config_content = format!(
+		"\
+[cache]
+enabled = true
+directory = \"{cache_dir}\"
+",
+		cache_dir = wasmtime_cache_root.display()
+	);
+	fs::write(&cache_config_path, config_content)
+		.map_err(|err| format!("cannot write the cache config: {}", err))?;
+
+	config
+		.cache_config_load(cache_config_path)
+		.map_err(|err| format!("failed to parse the config: {:#}", err))?;
+
+	Ok(())
+}
+
+fn common_config(semantics: &Semantics) -> std::result::Result<wasmtime::Config, WasmError> {
+	let mut config = wasmtime::Config::new();
+	config.cranelift_opt_level(wasmtime::OptLevel::SpeedAndSize);
+	config.cranelift_nan_canonicalization(semantics.canonicalize_nans);
+
+	// Since wasmtime 6.0.0 the default for this is `true`, but that heavily regresses
+	// the contracts pallet's performance, so disable it for now.
+	#[allow(deprecated)]
+	config.cranelift_use_egraphs(false);
+
+	let profiler = match std::env::var_os("WASMTIME_PROFILING_STRATEGY") {
+		Some(os_string) if os_string == "jitdump" => wasmtime::ProfilingStrategy::JitDump,
+		None => wasmtime::ProfilingStrategy::None,
+		Some(_) => {
+			// Remember if we have already logged a warning due to an unknown profiling strategy.
+			static UNKNOWN_PROFILING_STRATEGY: AtomicBool = AtomicBool::new(false);
+			// Make sure that the warning will not be relogged regularly.
+			if !UNKNOWN_PROFILING_STRATEGY.swap(true, Ordering::Relaxed) {
+				log::warn!("WASMTIME_PROFILING_STRATEGY is set to unknown value, ignored.");
+			}
+			wasmtime::ProfilingStrategy::None
+		},
+	};
+	config.profiler(profiler);
+
+	let native_stack_max = match semantics.deterministic_stack_limit {
+		Some(DeterministicStackLimit { native_stack_max, .. }) => native_stack_max,
+
+		// In `wasmtime` 0.35 the default stack size limit was changed from 1MB to 512KB.
+		//
+		// This broke at least one parachain which depended on the original 1MB limit,
+		// so here we restore it to what it was originally.
+		None => 1024 * 1024,
+	};
+
+	config.max_wasm_stack(native_stack_max as usize);
+
+	config.parallel_compilation(semantics.parallel_compilation);
+
+	// Be clear and specific about the extensions we support. If an update brings new features
+	// they should be introduced here as well.
+	config.wasm_reference_types(semantics.wasm_reference_types);
+	config.wasm_simd(semantics.wasm_simd);
+	config.wasm_bulk_memory(semantics.wasm_bulk_memory);
+	config.wasm_multi_value(semantics.wasm_multi_value);
+	config.wasm_multi_memory(false);
+	config.wasm_threads(false);
+	config.wasm_memory64(false);
+
+	let (use_pooling, use_cow) = match semantics.instantiation_strategy {
+		InstantiationStrategy::PoolingCopyOnWrite => (true, true),
+		InstantiationStrategy::Pooling => (true, false),
+		InstantiationStrategy::RecreateInstanceCopyOnWrite => (false, true),
+		InstantiationStrategy::RecreateInstance => (false, false),
+		InstantiationStrategy::LegacyInstanceReuse => (false, false),
+	};
+
+	const WASM_PAGE_SIZE: u64 = 65536;
+
+	config.memory_init_cow(use_cow);
+	config.memory_guaranteed_dense_image_size(match semantics.heap_alloc_strategy {
+		HeapAllocStrategy::Dynamic { maximum_pages } =>
+			maximum_pages.map(|p| p as u64 * WASM_PAGE_SIZE).unwrap_or(u64::MAX),
+		HeapAllocStrategy::Static { .. } => u64::MAX,
+	});
+
+	if use_pooling {
+		const MAX_WASM_PAGES: u64 = 0x10000;
+
+		let memory_pages = match semantics.heap_alloc_strategy {
+			HeapAllocStrategy::Dynamic { maximum_pages } =>
+				maximum_pages.map(|p| p as u64).unwrap_or(MAX_WASM_PAGES),
+			HeapAllocStrategy::Static { .. } => MAX_WASM_PAGES,
+		};
+
+		let mut pooling_config = wasmtime::PoolingAllocationConfig::default();
+		pooling_config
+			.max_unused_warm_slots(4)
+			// Pooling needs a bunch of hard limits to be set; if we go over
+			// any of these then the instantiation will fail.
+			//
+			// Current minimum values for kusama (as of 2022-04-14):
+			//   size: 32384
+			//   table_elements: 1249
+			//   memory_pages: 2070
+			.instance_size(128 * 1024)
+			.instance_table_elements(8192)
+			.instance_memory_pages(memory_pages)
+			// We can only have a single of those.
+			.instance_tables(1)
+			.instance_memories(1)
+			// This determines how many instances of the module can be
+			// instantiated in parallel from the same `Module`.
+			.instance_count(32);
+
+		config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(pooling_config));
+	}
+
+	Ok(config)
+}
+
+/// Knobs for deterministic stack height limiting.
+///
+/// The WebAssembly standard defines a call/value stack but it doesn't say anything about its
+/// size except that it has to be finite. The implementations are free to choose their own notion
+/// of limit: some may count the number of calls or values, others would rely on the host machine
+/// stack and trap on reaching a guard page.
+///
+/// This obviously is a source of non-determinism during execution. This feature can be used
+/// to instrument the code so that it will count the depth of execution in some deterministic
+/// way (the machine stack limit should be so high that the deterministic limit always triggers
+/// first).
+///
+/// The deterministic stack height limiting feature allows to instrument the code so that it will
+/// count the number of items that may be on the stack. This counting will only act as an rough
+/// estimate of the actual stack limit in wasmtime. This is because wasmtime measures it's stack
+/// usage in bytes.
+///
+/// The actual number of bytes consumed by a function is not trivial to compute  without going
+/// through full compilation. Therefore, it's expected that `native_stack_max` is greatly
+/// overestimated and thus never reached in practice. The stack overflow check introduced by the
+/// instrumentation and that relies on the logical item count should be reached first.
+///
+/// See [here][stack_height] for more details of the instrumentation
+///
+/// [stack_height]: https://github.com/paritytech/wasm-utils/blob/d9432baf/src/stack_height/mod.rs#L1-L50
+#[derive(Clone)]
+pub struct DeterministicStackLimit {
+	/// A number of logical "values" that can be pushed on the wasm stack. A trap will be triggered
+	/// if exceeded.
+	///
+	/// A logical value is a local, an argument or a value pushed on operand stack.
+	pub logical_max: u32,
+	/// The maximum number of bytes for stack used by wasmtime JITed code.
+	///
+	/// It's not specified how much bytes will be consumed by a stack frame for a given wasm
+	/// function after translation into machine code. It is also not quite trivial.
+	///
+	/// Therefore, this number should be chosen conservatively. It must be so large so that it can
+	/// fit the [`logical_max`](Self::logical_max) logical values on the stack, according to the
+	/// current instrumentation algorithm.
+	///
+	/// This value cannot be 0.
+	pub native_stack_max: u32,
+}
+
+/// The instantiation strategy to use for the WASM executor.
+///
+/// All of the CoW strategies (with `CopyOnWrite` suffix) are only supported when either:
+///   a) we're running on Linux,
+///   b) we're running on an Unix-like system and we're precompiling
+///      our module beforehand and instantiating from a file.
+///
+/// If the CoW variant of a strategy is unsupported the executor will
+/// fall back to the non-CoW equivalent.
+#[non_exhaustive]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub enum InstantiationStrategy {
+	/// Pool the instances to avoid initializing everything from scratch
+	/// on each instantiation. Use copy-on-write memory when possible.
+	///
+	/// This is the fastest instantiation strategy.
+	PoolingCopyOnWrite,
+
+	/// Recreate the instance from scratch on every instantiation.
+	/// Use copy-on-write memory when possible.
+	RecreateInstanceCopyOnWrite,
+
+	/// Pool the instances to avoid initializing everything from scratch
+	/// on each instantiation.
+	Pooling,
+
+	/// Recreate the instance from scratch on every instantiation. Very slow.
+	RecreateInstance,
+
+	/// Legacy instance reuse mechanism. DEPRECATED. Will be removed. Do not use.
+	LegacyInstanceReuse,
+}
+
+enum InternalInstantiationStrategy {
+	LegacyInstanceReuse(InstanceSnapshotData),
+	Builtin,
+}
+
+#[derive(Clone)]
+pub struct Semantics {
+	/// The instantiation strategy to use.
+	pub instantiation_strategy: InstantiationStrategy,
+
+	/// Specifying `Some` will enable deterministic stack height. That is, all executor
+	/// invocations will reach stack overflow at the exactly same point across different wasmtime
+	/// versions and architectures.
+	///
+	/// This is achieved by a combination of running an instrumentation pass on input code and
+	/// configuring wasmtime accordingly.
+	///
+	/// Since this feature depends on instrumentation, it can be set only if runtime is
+	/// instantiated using the runtime blob, e.g. using [`create_runtime`].
+	// I.e. if [`CodeSupplyMode::Verbatim`] is used.
+	pub deterministic_stack_limit: Option<DeterministicStackLimit>,
+
+	/// Controls whether wasmtime should compile floating point in a way that doesn't allow for
+	/// non-determinism.
+	///
+	/// By default, the wasm spec allows some local non-determinism wrt. certain floating point
+	/// operations. Specifically, those operations that are not defined to operate on bits (e.g.
+	/// fneg) can produce NaN values. The exact bit pattern for those is not specified and may
+	/// depend on the particular machine that executes wasmtime generated JITed machine code. That
+	/// is a source of non-deterministic values.
+	///
+	/// The classical runtime environment for Substrate allowed it and punted this on the runtime
+	/// developers. For PVFs, we want to ensure that execution is deterministic though. Therefore,
+	/// for PVF execution this flag is meant to be turned on.
+	pub canonicalize_nans: bool,
+
+	/// Configures wasmtime to use multiple threads for compiling.
+	pub parallel_compilation: bool,
+
+	/// The heap allocation strategy to use.
+	pub heap_alloc_strategy: HeapAllocStrategy,
+
+	/// Enables WASM Multi-Value proposal
+	pub wasm_multi_value: bool,
+
+	/// Enables WASM Bulk Memory Operations proposal
+	pub wasm_bulk_memory: bool,
+
+	/// Enables WASM Reference Types proposal
+	pub wasm_reference_types: bool,
+
+	/// Enables WASM Fixed-Width SIMD proposal
+	pub wasm_simd: bool,
+}
+
+#[derive(Clone)]
+pub struct Config {
+	/// The WebAssembly standard requires all imports of an instantiated module to be resolved,
+	/// otherwise, the instantiation fails. If this option is set to `true`, then this behavior is
+	/// overriden and imports that are requested by the module and not provided by the host
+	/// functions will be resolved using stubs. These stubs will trap upon a call.
+	pub allow_missing_func_imports: bool,
+
+	/// A directory in which wasmtime can store its compiled artifacts cache.
+	pub cache_path: Option<PathBuf>,
+
+	/// Tuning of various semantics of the wasmtime executor.
+	pub semantics: Semantics,
+}
+
+enum CodeSupplyMode<'a> {
+	/// The runtime is instantiated using the given runtime blob.
+	Fresh(RuntimeBlob),
+
+	/// The runtime is instantiated using a precompiled module at the given path.
+	///
+	/// This assumes that the code is already prepared for execution and the same `Config` was
+	/// used.
+	///
+	/// We use a `Path` here instead of simply passing a byte slice to allow `wasmtime` to
+	/// map the runtime's linear memory on supported platforms in a copy-on-write fashion.
+	Precompiled(&'a Path),
+
+	/// The runtime is instantiated using a precompiled module with the given bytes.
+	///
+	/// This assumes that the code is already prepared for execution and the same `Config` was
+	/// used.
+	PrecompiledBytes(&'a [u8]),
+}
+
+/// Create a new `WasmtimeRuntime` given the code. This function performs translation from Wasm to
+/// machine code, which can be computationally heavy.
+///
+/// The `H` generic parameter is used to statically pass a set of host functions which are exposed
+/// to the runtime.
+pub fn create_runtime<H>(
+	blob: RuntimeBlob,
+	config: Config,
+) -> std::result::Result<WasmtimeRuntime, WasmError>
+where
+	H: HostFunctions,
+{
+	// SAFETY: this is safe because it doesn't use `CodeSupplyMode::Precompiled`.
+	unsafe { do_create_runtime::<H>(CodeSupplyMode::Fresh(blob), config) }
+}
+
+/// The same as [`create_runtime`] but takes a path to a precompiled artifact,
+/// which makes this function considerably faster than [`create_runtime`].
+///
+/// # Safety
+///
+/// The caller must ensure that the compiled artifact passed here was:
+///   1) produced by [`prepare_runtime_artifact`],
+///   2) written to the disk as a file,
+///   3) was not modified,
+///   4) will not be modified while any runtime using this artifact is alive, or is being
+///      instantiated.
+///
+/// Failure to adhere to these requirements might lead to crashes and arbitrary code execution.
+///
+/// It is ok though if the compiled artifact was created by code of another version or with
+/// different configuration flags. In such case the caller will receive an `Err` deterministically.
+pub unsafe fn create_runtime_from_artifact<H>(
+	compiled_artifact_path: &Path,
+	config: Config,
+) -> std::result::Result<WasmtimeRuntime, WasmError>
+where
+	H: HostFunctions,
+{
+	do_create_runtime::<H>(CodeSupplyMode::Precompiled(compiled_artifact_path), config)
+}
+
+/// The same as [`create_runtime`] but takes the bytes of a precompiled artifact,
+/// which makes this function considerably faster than [`create_runtime`],
+/// but slower than the more optimized [`create_runtime_from_artifact`].
+/// This is especially slow on non-Linux Unix systems. Useful in very niche cases.
+///
+/// # Safety
+///
+/// The caller must ensure that the compiled artifact passed here was:
+///   1) produced by [`prepare_runtime_artifact`],
+///   2) was not modified,
+///
+/// Failure to adhere to these requirements might lead to crashes and arbitrary code execution.
+///
+/// It is ok though if the compiled artifact was created by code of another version or with
+/// different configuration flags. In such case the caller will receive an `Err` deterministically.
+pub unsafe fn create_runtime_from_artifact_bytes<H>(
+	compiled_artifact_bytes: &[u8],
+	config: Config,
+) -> std::result::Result<WasmtimeRuntime, WasmError>
+where
+	H: HostFunctions,
+{
+	do_create_runtime::<H>(CodeSupplyMode::PrecompiledBytes(compiled_artifact_bytes), config)
+}
+
+/// # Safety
+///
+/// This is only unsafe if called with [`CodeSupplyMode::Artifact`]. See
+/// [`create_runtime_from_artifact`] to get more details.
+unsafe fn do_create_runtime<H>(
+	code_supply_mode: CodeSupplyMode<'_>,
+	mut config: Config,
+) -> std::result::Result<WasmtimeRuntime, WasmError>
+where
+	H: HostFunctions,
+{
+	replace_strategy_if_broken(&mut config.semantics.instantiation_strategy);
+
+	let mut wasmtime_config = common_config(&config.semantics)?;
+	if let Some(ref cache_path) = config.cache_path {
+		if let Err(reason) = setup_wasmtime_caching(cache_path, &mut wasmtime_config) {
+			log::warn!(
+				"failed to setup wasmtime cache. Performance may degrade significantly: {}.",
+				reason,
+			);
+		}
+	}
+
+	let engine = Engine::new(&wasmtime_config)
+		.map_err(|e| WasmError::Other(format!("cannot create the wasmtime engine: {:#}", e)))?;
+
+	let (module, instantiation_strategy) = match code_supply_mode {
+		CodeSupplyMode::Fresh(blob) => {
+			let blob = prepare_blob_for_compilation(blob, &config.semantics)?;
+			let serialized_blob = blob.clone().serialize();
+
+			let module = wasmtime::Module::new(&engine, &serialized_blob)
+				.map_err(|e| WasmError::Other(format!("cannot create module: {:#}", e)))?;
+
+			match config.semantics.instantiation_strategy {
+				InstantiationStrategy::LegacyInstanceReuse => {
+					let data_segments_snapshot =
+						DataSegmentsSnapshot::take(&blob).map_err(|e| {
+							WasmError::Other(format!("cannot take data segments snapshot: {}", e))
+						})?;
+					let data_segments_snapshot = Arc::new(data_segments_snapshot);
+					let mutable_globals = ExposedMutableGlobalsSet::collect(&blob);
+
+					(
+						module,
+						InternalInstantiationStrategy::LegacyInstanceReuse(InstanceSnapshotData {
+							data_segments_snapshot,
+							mutable_globals,
+						}),
+					)
+				},
+				InstantiationStrategy::Pooling |
+				InstantiationStrategy::PoolingCopyOnWrite |
+				InstantiationStrategy::RecreateInstance |
+				InstantiationStrategy::RecreateInstanceCopyOnWrite =>
+					(module, InternalInstantiationStrategy::Builtin),
+			}
+		},
+		CodeSupplyMode::Precompiled(compiled_artifact_path) => {
+			if let InstantiationStrategy::LegacyInstanceReuse =
+				config.semantics.instantiation_strategy
+			{
+				return Err(WasmError::Other("the legacy instance reuse instantiation strategy is incompatible with precompiled modules".into()));
+			}
+
+			// SAFETY: The unsafety of `deserialize_file` is covered by this function. The
+			//         responsibilities to maintain the invariants are passed to the caller.
+			//
+			//         See [`create_runtime_from_artifact`] for more details.
+			let module = wasmtime::Module::deserialize_file(&engine, compiled_artifact_path)
+				.map_err(|e| WasmError::Other(format!("cannot deserialize module: {:#}", e)))?;
+
+			(module, InternalInstantiationStrategy::Builtin)
+		},
+		CodeSupplyMode::PrecompiledBytes(compiled_artifact_bytes) => {
+			if let InstantiationStrategy::LegacyInstanceReuse =
+				config.semantics.instantiation_strategy
+			{
+				return Err(WasmError::Other("the legacy instance reuse instantiation strategy is incompatible with precompiled modules".into()));
+			}
+
+			// SAFETY: The unsafety of `deserialize` is covered by this function. The
+			//         responsibilities to maintain the invariants are passed to the caller.
+			//
+			//         See [`create_runtime_from_artifact_bytes`] for more details.
+			let module = wasmtime::Module::deserialize(&engine, compiled_artifact_bytes)
+				.map_err(|e| WasmError::Other(format!("cannot deserialize module: {:#}", e)))?;
+
+			(module, InternalInstantiationStrategy::Builtin)
+		},
+	};
+
+	let mut linker = wasmtime::Linker::new(&engine);
+	crate::imports::prepare_imports::<H>(&mut linker, &module, config.allow_missing_func_imports)?;
+
+	let instance_pre = linker
+		.instantiate_pre(&module)
+		.map_err(|e| WasmError::Other(format!("cannot preinstantiate module: {:#}", e)))?;
+
+	Ok(WasmtimeRuntime { engine, instance_pre: Arc::new(instance_pre), instantiation_strategy })
+}
+
+fn prepare_blob_for_compilation(
+	mut blob: RuntimeBlob,
+	semantics: &Semantics,
+) -> std::result::Result<RuntimeBlob, WasmError> {
+	if let Some(DeterministicStackLimit { logical_max, .. }) = semantics.deterministic_stack_limit {
+		blob = blob.inject_stack_depth_metering(logical_max)?;
+	}
+
+	if let InstantiationStrategy::LegacyInstanceReuse = semantics.instantiation_strategy {
+		// When this strategy is used this must be called after all other passes which may introduce
+		// new global variables, otherwise they will not be reset when we call into the runtime
+		// again.
+		blob.expose_mutable_globals();
+	}
+
+	// We don't actually need the memory to be imported so we can just convert any memory
+	// import into an export with impunity. This simplifies our code since `wasmtime` will
+	// now automatically take care of creating the memory for us, and it is also necessary
+	// to enable `wasmtime`'s instance pooling. (Imported memories are ineligible for pooling.)
+	blob.convert_memory_import_into_export()?;
+	blob.setup_memory_according_to_heap_alloc_strategy(semantics.heap_alloc_strategy)?;
+
+	Ok(blob)
+}
+
+/// Takes a [`RuntimeBlob`] and precompiles it returning the serialized result of compilation. It
+/// can then be used for calling [`create_runtime`] avoiding long compilation times.
+pub fn prepare_runtime_artifact(
+	blob: RuntimeBlob,
+	semantics: &Semantics,
+) -> std::result::Result<Vec<u8>, WasmError> {
+	let mut semantics = semantics.clone();
+	replace_strategy_if_broken(&mut semantics.instantiation_strategy);
+
+	let blob = prepare_blob_for_compilation(blob, &semantics)?;
+
+	let engine = Engine::new(&common_config(&semantics)?)
+		.map_err(|e| WasmError::Other(format!("cannot create the engine: {:#}", e)))?;
+
+	engine
+		.precompile_module(&blob.serialize())
+		.map_err(|e| WasmError::Other(format!("cannot precompile module: {:#}", e)))
+}
+
+fn perform_call(
+	data: &[u8],
+	instance_wrapper: &mut InstanceWrapper,
+	entrypoint: EntryPoint,
+	mut allocator: FreeingBumpHeapAllocator,
+	allocation_stats: &mut Option<AllocationStats>,
+) -> Result<Vec<u8>> {
+	let (data_ptr, data_len) = inject_input_data(instance_wrapper, &mut allocator, data)?;
+
+	let host_state = HostState::new(allocator);
+
+	// Set the host state before calling into wasm.
+	instance_wrapper.store_mut().data_mut().host_state = Some(host_state);
+
+	let ret = entrypoint
+		.call(instance_wrapper.store_mut(), data_ptr, data_len)
+		.map(unpack_ptr_and_len);
+
+	// Reset the host state
+	let host_state = instance_wrapper.store_mut().data_mut().host_state.take().expect(
+		"the host state is always set before calling into WASM so it can't be None here; qed",
+	);
+	*allocation_stats = Some(host_state.allocation_stats());
+
+	let (output_ptr, output_len) = ret?;
+	let output = extract_output_data(instance_wrapper, output_ptr, output_len)?;
+
+	Ok(output)
+}
+
+fn inject_input_data(
+	instance: &mut InstanceWrapper,
+	allocator: &mut FreeingBumpHeapAllocator,
+	data: &[u8],
+) -> Result<(Pointer<u8>, WordSize)> {
+	let mut ctx = instance.store_mut();
+	let memory = ctx.data().memory();
+	let data_len = data.len() as WordSize;
+	let data_ptr = allocator.allocate(&mut MemoryWrapper(&memory, &mut ctx), data_len)?;
+	util::write_memory_from(instance.store_mut(), data_ptr, data)?;
+	Ok((data_ptr, data_len))
+}
+
+fn extract_output_data(
+	instance: &InstanceWrapper,
+	output_ptr: u32,
+	output_len: u32,
+) -> Result<Vec<u8>> {
+	let ctx = instance.store();
+
+	// Do a length check before allocating. The returned output should not be bigger than the
+	// available WASM memory. Otherwise, a malicious parachain can trigger a large allocation,
+	// potentially causing memory exhaustion.
+	//
+	// Get the size of the WASM memory in bytes.
+	let memory_size = ctx.as_context().data().memory().data_size(ctx);
+	if checked_range(output_ptr as usize, output_len as usize, memory_size).is_none() {
+		Err(Error::OutputExceedsBounds)?
+	}
+	let mut output = vec![0; output_len as usize];
+
+	util::read_memory_into(ctx, Pointer::new(output_ptr), &mut output)?;
+	Ok(output)
+}
diff --git a/substrate/client/executor/wasmtime/src/test-guard-page-skip.wat b/substrate/client/executor/wasmtime/src/test-guard-page-skip.wat
new file mode 100644
index 0000000000000000000000000000000000000000..2f7339d45c9ef6403026f416b1e85bf999fc953d
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/test-guard-page-skip.wat
@@ -0,0 +1,2293 @@
+;; This file is a modified version of
+;; https://github.com/WebAssembly/testsuite/blob/01efde81028c5b0d099eb836645a2dc5e7755449/skip-stack-guard-page.wast
+;; Licensed Apache 2.0 https://github.com/WebAssembly/testsuite/blob/01efde81028c5b0d099eb836645a2dc5e7755449/LICENSE
+
+;; This wasm module implements a Substrate Runtime with one entrypoint: `test-many-locals`. This
+;; entrypoint does not take any parameters nor returns a result. Each execution should end up with
+;; a stack overflow trap.
+;;
+;; What it does is essentially a recursive call. The function that recurses into itself declares
+;; lots of local variables. It reads into each local at the corresponding offset, recurses into itself
+;; and then writes the contents of the locals back into the memory at the same offset.
+;;
+;; The original purpose of this file in the test suite is to test skipping the guard page (hence the
+;; size 256 + 4096 + 4096). However, what's important here is to just an infinite recursion with
+;; many locals.
+;;
+;; NOTE That memory accesses are put there in an attempt to prevent eliminating the dead locals.
+;; At the moment of writing, wasmtime should be dumb enough to be tricked into thinking that the code
+;; does something.
+
+(module
+  (import "env" "memory" (memory 1))
+  (export "test-many-locals" (func $test-many-locals))
+
+  ;; The heap base is chosen so that the heap doesn't overlap with the data below.
+  (global (export "__heap_base") i32 (i32.const 8448))
+
+  (func $test-many-locals
+    (param i32 i32) (result i64)
+    (call $function-with-many-locals)
+    (i64.const 0)
+  )
+
+  (func $function-with-many-locals
+
+    ;; 1056 i64 = 8448 bytes of locals
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x000-0x007
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x008-0x00f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x010-0x017
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x018-0x01f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x020-0x027
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x028-0x02f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x030-0x037
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x038-0x03f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x040-0x047
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x048-0x04f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x050-0x057
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x058-0x05f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x060-0x067
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x068-0x06f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x070-0x077
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x078-0x07f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x080-0x087
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x088-0x08f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x090-0x097
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x098-0x09f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a0-0x0a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a8-0x0af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b0-0x0b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b8-0x0bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c0-0x0c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c8-0x0cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d0-0x0d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d8-0x0df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e0-0x0e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e8-0x0ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f0-0x0f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f8-0x0ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x100-0x107
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x108-0x10f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x110-0x117
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x118-0x11f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x120-0x127
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x128-0x12f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x130-0x137
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x138-0x13f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x140-0x147
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x148-0x14f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x150-0x157
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x158-0x15f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x160-0x167
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x168-0x16f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x170-0x177
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x178-0x17f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x180-0x187
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x188-0x18f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x190-0x197
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x198-0x19f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a0-0x1a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a8-0x1af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b0-0x1b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b8-0x1bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c0-0x1c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c8-0x1cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d0-0x1d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d8-0x1df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e0-0x1e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e8-0x1ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f0-0x1f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f8-0x1ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x200-0x207
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x208-0x20f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x210-0x217
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x218-0x21f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x220-0x227
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x228-0x22f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x230-0x237
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x238-0x23f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x240-0x247
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x248-0x24f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x250-0x257
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x258-0x25f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x260-0x267
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x268-0x26f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x270-0x277
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x278-0x27f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x280-0x287
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x288-0x28f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x290-0x297
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x298-0x29f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a0-0x2a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a8-0x2af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b0-0x2b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b8-0x2bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c0-0x2c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c8-0x2cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d0-0x2d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d8-0x2df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e0-0x2e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e8-0x2ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f0-0x2f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f8-0x2ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x300-0x307
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x308-0x30f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x310-0x317
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x318-0x31f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x320-0x327
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x328-0x32f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x330-0x337
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x338-0x33f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x340-0x347
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x348-0x34f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x350-0x357
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x358-0x35f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x360-0x367
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x368-0x36f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x370-0x377
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x378-0x37f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x380-0x387
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x388-0x38f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x390-0x397
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x398-0x39f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a0-0x3a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a8-0x3af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b0-0x3b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b8-0x3bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c0-0x3c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c8-0x3cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d0-0x3d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d8-0x3df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e0-0x3e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e8-0x3ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f0-0x3f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f8-0x3ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x400-0x407
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x408-0x40f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x410-0x417
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x418-0x41f
+
+    ;; recurse first to try to make the callee access the stack below the space allocated for the locals before the locals themselves have been initialized.
+    (call $function-with-many-locals)
+
+    ;; load from memory into the locals.
+    (local.set 0x000 (i64.load offset=0x000 align=1 (i32.const 0)))
+    (local.set 0x001 (i64.load offset=0x001 align=1 (i32.const 0)))
+    (local.set 0x002 (i64.load offset=0x002 align=1 (i32.const 0)))
+    (local.set 0x003 (i64.load offset=0x003 align=1 (i32.const 0)))
+    (local.set 0x004 (i64.load offset=0x004 align=1 (i32.const 0)))
+    (local.set 0x005 (i64.load offset=0x005 align=1 (i32.const 0)))
+    (local.set 0x006 (i64.load offset=0x006 align=1 (i32.const 0)))
+    (local.set 0x007 (i64.load offset=0x007 align=1 (i32.const 0)))
+    (local.set 0x008 (i64.load offset=0x008 align=1 (i32.const 0)))
+    (local.set 0x009 (i64.load offset=0x009 align=1 (i32.const 0)))
+    (local.set 0x00a (i64.load offset=0x00a align=1 (i32.const 0)))
+    (local.set 0x00b (i64.load offset=0x00b align=1 (i32.const 0)))
+    (local.set 0x00c (i64.load offset=0x00c align=1 (i32.const 0)))
+    (local.set 0x00d (i64.load offset=0x00d align=1 (i32.const 0)))
+    (local.set 0x00e (i64.load offset=0x00e align=1 (i32.const 0)))
+    (local.set 0x00f (i64.load offset=0x00f align=1 (i32.const 0)))
+    (local.set 0x010 (i64.load offset=0x010 align=1 (i32.const 0)))
+    (local.set 0x011 (i64.load offset=0x011 align=1 (i32.const 0)))
+    (local.set 0x012 (i64.load offset=0x012 align=1 (i32.const 0)))
+    (local.set 0x013 (i64.load offset=0x013 align=1 (i32.const 0)))
+    (local.set 0x014 (i64.load offset=0x014 align=1 (i32.const 0)))
+    (local.set 0x015 (i64.load offset=0x015 align=1 (i32.const 0)))
+    (local.set 0x016 (i64.load offset=0x016 align=1 (i32.const 0)))
+    (local.set 0x017 (i64.load offset=0x017 align=1 (i32.const 0)))
+    (local.set 0x018 (i64.load offset=0x018 align=1 (i32.const 0)))
+    (local.set 0x019 (i64.load offset=0x019 align=1 (i32.const 0)))
+    (local.set 0x01a (i64.load offset=0x01a align=1 (i32.const 0)))
+    (local.set 0x01b (i64.load offset=0x01b align=1 (i32.const 0)))
+    (local.set 0x01c (i64.load offset=0x01c align=1 (i32.const 0)))
+    (local.set 0x01d (i64.load offset=0x01d align=1 (i32.const 0)))
+    (local.set 0x01e (i64.load offset=0x01e align=1 (i32.const 0)))
+    (local.set 0x01f (i64.load offset=0x01f align=1 (i32.const 0)))
+    (local.set 0x020 (i64.load offset=0x020 align=1 (i32.const 0)))
+    (local.set 0x021 (i64.load offset=0x021 align=1 (i32.const 0)))
+    (local.set 0x022 (i64.load offset=0x022 align=1 (i32.const 0)))
+    (local.set 0x023 (i64.load offset=0x023 align=1 (i32.const 0)))
+    (local.set 0x024 (i64.load offset=0x024 align=1 (i32.const 0)))
+    (local.set 0x025 (i64.load offset=0x025 align=1 (i32.const 0)))
+    (local.set 0x026 (i64.load offset=0x026 align=1 (i32.const 0)))
+    (local.set 0x027 (i64.load offset=0x027 align=1 (i32.const 0)))
+    (local.set 0x028 (i64.load offset=0x028 align=1 (i32.const 0)))
+    (local.set 0x029 (i64.load offset=0x029 align=1 (i32.const 0)))
+    (local.set 0x02a (i64.load offset=0x02a align=1 (i32.const 0)))
+    (local.set 0x02b (i64.load offset=0x02b align=1 (i32.const 0)))
+    (local.set 0x02c (i64.load offset=0x02c align=1 (i32.const 0)))
+    (local.set 0x02d (i64.load offset=0x02d align=1 (i32.const 0)))
+    (local.set 0x02e (i64.load offset=0x02e align=1 (i32.const 0)))
+    (local.set 0x02f (i64.load offset=0x02f align=1 (i32.const 0)))
+    (local.set 0x030 (i64.load offset=0x030 align=1 (i32.const 0)))
+    (local.set 0x031 (i64.load offset=0x031 align=1 (i32.const 0)))
+    (local.set 0x032 (i64.load offset=0x032 align=1 (i32.const 0)))
+    (local.set 0x033 (i64.load offset=0x033 align=1 (i32.const 0)))
+    (local.set 0x034 (i64.load offset=0x034 align=1 (i32.const 0)))
+    (local.set 0x035 (i64.load offset=0x035 align=1 (i32.const 0)))
+    (local.set 0x036 (i64.load offset=0x036 align=1 (i32.const 0)))
+    (local.set 0x037 (i64.load offset=0x037 align=1 (i32.const 0)))
+    (local.set 0x038 (i64.load offset=0x038 align=1 (i32.const 0)))
+    (local.set 0x039 (i64.load offset=0x039 align=1 (i32.const 0)))
+    (local.set 0x03a (i64.load offset=0x03a align=1 (i32.const 0)))
+    (local.set 0x03b (i64.load offset=0x03b align=1 (i32.const 0)))
+    (local.set 0x03c (i64.load offset=0x03c align=1 (i32.const 0)))
+    (local.set 0x03d (i64.load offset=0x03d align=1 (i32.const 0)))
+    (local.set 0x03e (i64.load offset=0x03e align=1 (i32.const 0)))
+    (local.set 0x03f (i64.load offset=0x03f align=1 (i32.const 0)))
+    (local.set 0x040 (i64.load offset=0x040 align=1 (i32.const 0)))
+    (local.set 0x041 (i64.load offset=0x041 align=1 (i32.const 0)))
+    (local.set 0x042 (i64.load offset=0x042 align=1 (i32.const 0)))
+    (local.set 0x043 (i64.load offset=0x043 align=1 (i32.const 0)))
+    (local.set 0x044 (i64.load offset=0x044 align=1 (i32.const 0)))
+    (local.set 0x045 (i64.load offset=0x045 align=1 (i32.const 0)))
+    (local.set 0x046 (i64.load offset=0x046 align=1 (i32.const 0)))
+    (local.set 0x047 (i64.load offset=0x047 align=1 (i32.const 0)))
+    (local.set 0x048 (i64.load offset=0x048 align=1 (i32.const 0)))
+    (local.set 0x049 (i64.load offset=0x049 align=1 (i32.const 0)))
+    (local.set 0x04a (i64.load offset=0x04a align=1 (i32.const 0)))
+    (local.set 0x04b (i64.load offset=0x04b align=1 (i32.const 0)))
+    (local.set 0x04c (i64.load offset=0x04c align=1 (i32.const 0)))
+    (local.set 0x04d (i64.load offset=0x04d align=1 (i32.const 0)))
+    (local.set 0x04e (i64.load offset=0x04e align=1 (i32.const 0)))
+    (local.set 0x04f (i64.load offset=0x04f align=1 (i32.const 0)))
+    (local.set 0x050 (i64.load offset=0x050 align=1 (i32.const 0)))
+    (local.set 0x051 (i64.load offset=0x051 align=1 (i32.const 0)))
+    (local.set 0x052 (i64.load offset=0x052 align=1 (i32.const 0)))
+    (local.set 0x053 (i64.load offset=0x053 align=1 (i32.const 0)))
+    (local.set 0x054 (i64.load offset=0x054 align=1 (i32.const 0)))
+    (local.set 0x055 (i64.load offset=0x055 align=1 (i32.const 0)))
+    (local.set 0x056 (i64.load offset=0x056 align=1 (i32.const 0)))
+    (local.set 0x057 (i64.load offset=0x057 align=1 (i32.const 0)))
+    (local.set 0x058 (i64.load offset=0x058 align=1 (i32.const 0)))
+    (local.set 0x059 (i64.load offset=0x059 align=1 (i32.const 0)))
+    (local.set 0x05a (i64.load offset=0x05a align=1 (i32.const 0)))
+    (local.set 0x05b (i64.load offset=0x05b align=1 (i32.const 0)))
+    (local.set 0x05c (i64.load offset=0x05c align=1 (i32.const 0)))
+    (local.set 0x05d (i64.load offset=0x05d align=1 (i32.const 0)))
+    (local.set 0x05e (i64.load offset=0x05e align=1 (i32.const 0)))
+    (local.set 0x05f (i64.load offset=0x05f align=1 (i32.const 0)))
+    (local.set 0x060 (i64.load offset=0x060 align=1 (i32.const 0)))
+    (local.set 0x061 (i64.load offset=0x061 align=1 (i32.const 0)))
+    (local.set 0x062 (i64.load offset=0x062 align=1 (i32.const 0)))
+    (local.set 0x063 (i64.load offset=0x063 align=1 (i32.const 0)))
+    (local.set 0x064 (i64.load offset=0x064 align=1 (i32.const 0)))
+    (local.set 0x065 (i64.load offset=0x065 align=1 (i32.const 0)))
+    (local.set 0x066 (i64.load offset=0x066 align=1 (i32.const 0)))
+    (local.set 0x067 (i64.load offset=0x067 align=1 (i32.const 0)))
+    (local.set 0x068 (i64.load offset=0x068 align=1 (i32.const 0)))
+    (local.set 0x069 (i64.load offset=0x069 align=1 (i32.const 0)))
+    (local.set 0x06a (i64.load offset=0x06a align=1 (i32.const 0)))
+    (local.set 0x06b (i64.load offset=0x06b align=1 (i32.const 0)))
+    (local.set 0x06c (i64.load offset=0x06c align=1 (i32.const 0)))
+    (local.set 0x06d (i64.load offset=0x06d align=1 (i32.const 0)))
+    (local.set 0x06e (i64.load offset=0x06e align=1 (i32.const 0)))
+    (local.set 0x06f (i64.load offset=0x06f align=1 (i32.const 0)))
+    (local.set 0x070 (i64.load offset=0x070 align=1 (i32.const 0)))
+    (local.set 0x071 (i64.load offset=0x071 align=1 (i32.const 0)))
+    (local.set 0x072 (i64.load offset=0x072 align=1 (i32.const 0)))
+    (local.set 0x073 (i64.load offset=0x073 align=1 (i32.const 0)))
+    (local.set 0x074 (i64.load offset=0x074 align=1 (i32.const 0)))
+    (local.set 0x075 (i64.load offset=0x075 align=1 (i32.const 0)))
+    (local.set 0x076 (i64.load offset=0x076 align=1 (i32.const 0)))
+    (local.set 0x077 (i64.load offset=0x077 align=1 (i32.const 0)))
+    (local.set 0x078 (i64.load offset=0x078 align=1 (i32.const 0)))
+    (local.set 0x079 (i64.load offset=0x079 align=1 (i32.const 0)))
+    (local.set 0x07a (i64.load offset=0x07a align=1 (i32.const 0)))
+    (local.set 0x07b (i64.load offset=0x07b align=1 (i32.const 0)))
+    (local.set 0x07c (i64.load offset=0x07c align=1 (i32.const 0)))
+    (local.set 0x07d (i64.load offset=0x07d align=1 (i32.const 0)))
+    (local.set 0x07e (i64.load offset=0x07e align=1 (i32.const 0)))
+    (local.set 0x07f (i64.load offset=0x07f align=1 (i32.const 0)))
+    (local.set 0x080 (i64.load offset=0x080 align=1 (i32.const 0)))
+    (local.set 0x081 (i64.load offset=0x081 align=1 (i32.const 0)))
+    (local.set 0x082 (i64.load offset=0x082 align=1 (i32.const 0)))
+    (local.set 0x083 (i64.load offset=0x083 align=1 (i32.const 0)))
+    (local.set 0x084 (i64.load offset=0x084 align=1 (i32.const 0)))
+    (local.set 0x085 (i64.load offset=0x085 align=1 (i32.const 0)))
+    (local.set 0x086 (i64.load offset=0x086 align=1 (i32.const 0)))
+    (local.set 0x087 (i64.load offset=0x087 align=1 (i32.const 0)))
+    (local.set 0x088 (i64.load offset=0x088 align=1 (i32.const 0)))
+    (local.set 0x089 (i64.load offset=0x089 align=1 (i32.const 0)))
+    (local.set 0x08a (i64.load offset=0x08a align=1 (i32.const 0)))
+    (local.set 0x08b (i64.load offset=0x08b align=1 (i32.const 0)))
+    (local.set 0x08c (i64.load offset=0x08c align=1 (i32.const 0)))
+    (local.set 0x08d (i64.load offset=0x08d align=1 (i32.const 0)))
+    (local.set 0x08e (i64.load offset=0x08e align=1 (i32.const 0)))
+    (local.set 0x08f (i64.load offset=0x08f align=1 (i32.const 0)))
+    (local.set 0x090 (i64.load offset=0x090 align=1 (i32.const 0)))
+    (local.set 0x091 (i64.load offset=0x091 align=1 (i32.const 0)))
+    (local.set 0x092 (i64.load offset=0x092 align=1 (i32.const 0)))
+    (local.set 0x093 (i64.load offset=0x093 align=1 (i32.const 0)))
+    (local.set 0x094 (i64.load offset=0x094 align=1 (i32.const 0)))
+    (local.set 0x095 (i64.load offset=0x095 align=1 (i32.const 0)))
+    (local.set 0x096 (i64.load offset=0x096 align=1 (i32.const 0)))
+    (local.set 0x097 (i64.load offset=0x097 align=1 (i32.const 0)))
+    (local.set 0x098 (i64.load offset=0x098 align=1 (i32.const 0)))
+    (local.set 0x099 (i64.load offset=0x099 align=1 (i32.const 0)))
+    (local.set 0x09a (i64.load offset=0x09a align=1 (i32.const 0)))
+    (local.set 0x09b (i64.load offset=0x09b align=1 (i32.const 0)))
+    (local.set 0x09c (i64.load offset=0x09c align=1 (i32.const 0)))
+    (local.set 0x09d (i64.load offset=0x09d align=1 (i32.const 0)))
+    (local.set 0x09e (i64.load offset=0x09e align=1 (i32.const 0)))
+    (local.set 0x09f (i64.load offset=0x09f align=1 (i32.const 0)))
+    (local.set 0x0a0 (i64.load offset=0x0a0 align=1 (i32.const 0)))
+    (local.set 0x0a1 (i64.load offset=0x0a1 align=1 (i32.const 0)))
+    (local.set 0x0a2 (i64.load offset=0x0a2 align=1 (i32.const 0)))
+    (local.set 0x0a3 (i64.load offset=0x0a3 align=1 (i32.const 0)))
+    (local.set 0x0a4 (i64.load offset=0x0a4 align=1 (i32.const 0)))
+    (local.set 0x0a5 (i64.load offset=0x0a5 align=1 (i32.const 0)))
+    (local.set 0x0a6 (i64.load offset=0x0a6 align=1 (i32.const 0)))
+    (local.set 0x0a7 (i64.load offset=0x0a7 align=1 (i32.const 0)))
+    (local.set 0x0a8 (i64.load offset=0x0a8 align=1 (i32.const 0)))
+    (local.set 0x0a9 (i64.load offset=0x0a9 align=1 (i32.const 0)))
+    (local.set 0x0aa (i64.load offset=0x0aa align=1 (i32.const 0)))
+    (local.set 0x0ab (i64.load offset=0x0ab align=1 (i32.const 0)))
+    (local.set 0x0ac (i64.load offset=0x0ac align=1 (i32.const 0)))
+    (local.set 0x0ad (i64.load offset=0x0ad align=1 (i32.const 0)))
+    (local.set 0x0ae (i64.load offset=0x0ae align=1 (i32.const 0)))
+    (local.set 0x0af (i64.load offset=0x0af align=1 (i32.const 0)))
+    (local.set 0x0b0 (i64.load offset=0x0b0 align=1 (i32.const 0)))
+    (local.set 0x0b1 (i64.load offset=0x0b1 align=1 (i32.const 0)))
+    (local.set 0x0b2 (i64.load offset=0x0b2 align=1 (i32.const 0)))
+    (local.set 0x0b3 (i64.load offset=0x0b3 align=1 (i32.const 0)))
+    (local.set 0x0b4 (i64.load offset=0x0b4 align=1 (i32.const 0)))
+    (local.set 0x0b5 (i64.load offset=0x0b5 align=1 (i32.const 0)))
+    (local.set 0x0b6 (i64.load offset=0x0b6 align=1 (i32.const 0)))
+    (local.set 0x0b7 (i64.load offset=0x0b7 align=1 (i32.const 0)))
+    (local.set 0x0b8 (i64.load offset=0x0b8 align=1 (i32.const 0)))
+    (local.set 0x0b9 (i64.load offset=0x0b9 align=1 (i32.const 0)))
+    (local.set 0x0ba (i64.load offset=0x0ba align=1 (i32.const 0)))
+    (local.set 0x0bb (i64.load offset=0x0bb align=1 (i32.const 0)))
+    (local.set 0x0bc (i64.load offset=0x0bc align=1 (i32.const 0)))
+    (local.set 0x0bd (i64.load offset=0x0bd align=1 (i32.const 0)))
+    (local.set 0x0be (i64.load offset=0x0be align=1 (i32.const 0)))
+    (local.set 0x0bf (i64.load offset=0x0bf align=1 (i32.const 0)))
+    (local.set 0x0c0 (i64.load offset=0x0c0 align=1 (i32.const 0)))
+    (local.set 0x0c1 (i64.load offset=0x0c1 align=1 (i32.const 0)))
+    (local.set 0x0c2 (i64.load offset=0x0c2 align=1 (i32.const 0)))
+    (local.set 0x0c3 (i64.load offset=0x0c3 align=1 (i32.const 0)))
+    (local.set 0x0c4 (i64.load offset=0x0c4 align=1 (i32.const 0)))
+    (local.set 0x0c5 (i64.load offset=0x0c5 align=1 (i32.const 0)))
+    (local.set 0x0c6 (i64.load offset=0x0c6 align=1 (i32.const 0)))
+    (local.set 0x0c7 (i64.load offset=0x0c7 align=1 (i32.const 0)))
+    (local.set 0x0c8 (i64.load offset=0x0c8 align=1 (i32.const 0)))
+    (local.set 0x0c9 (i64.load offset=0x0c9 align=1 (i32.const 0)))
+    (local.set 0x0ca (i64.load offset=0x0ca align=1 (i32.const 0)))
+    (local.set 0x0cb (i64.load offset=0x0cb align=1 (i32.const 0)))
+    (local.set 0x0cc (i64.load offset=0x0cc align=1 (i32.const 0)))
+    (local.set 0x0cd (i64.load offset=0x0cd align=1 (i32.const 0)))
+    (local.set 0x0ce (i64.load offset=0x0ce align=1 (i32.const 0)))
+    (local.set 0x0cf (i64.load offset=0x0cf align=1 (i32.const 0)))
+    (local.set 0x0d0 (i64.load offset=0x0d0 align=1 (i32.const 0)))
+    (local.set 0x0d1 (i64.load offset=0x0d1 align=1 (i32.const 0)))
+    (local.set 0x0d2 (i64.load offset=0x0d2 align=1 (i32.const 0)))
+    (local.set 0x0d3 (i64.load offset=0x0d3 align=1 (i32.const 0)))
+    (local.set 0x0d4 (i64.load offset=0x0d4 align=1 (i32.const 0)))
+    (local.set 0x0d5 (i64.load offset=0x0d5 align=1 (i32.const 0)))
+    (local.set 0x0d6 (i64.load offset=0x0d6 align=1 (i32.const 0)))
+    (local.set 0x0d7 (i64.load offset=0x0d7 align=1 (i32.const 0)))
+    (local.set 0x0d8 (i64.load offset=0x0d8 align=1 (i32.const 0)))
+    (local.set 0x0d9 (i64.load offset=0x0d9 align=1 (i32.const 0)))
+    (local.set 0x0da (i64.load offset=0x0da align=1 (i32.const 0)))
+    (local.set 0x0db (i64.load offset=0x0db align=1 (i32.const 0)))
+    (local.set 0x0dc (i64.load offset=0x0dc align=1 (i32.const 0)))
+    (local.set 0x0dd (i64.load offset=0x0dd align=1 (i32.const 0)))
+    (local.set 0x0de (i64.load offset=0x0de align=1 (i32.const 0)))
+    (local.set 0x0df (i64.load offset=0x0df align=1 (i32.const 0)))
+    (local.set 0x0e0 (i64.load offset=0x0e0 align=1 (i32.const 0)))
+    (local.set 0x0e1 (i64.load offset=0x0e1 align=1 (i32.const 0)))
+    (local.set 0x0e2 (i64.load offset=0x0e2 align=1 (i32.const 0)))
+    (local.set 0x0e3 (i64.load offset=0x0e3 align=1 (i32.const 0)))
+    (local.set 0x0e4 (i64.load offset=0x0e4 align=1 (i32.const 0)))
+    (local.set 0x0e5 (i64.load offset=0x0e5 align=1 (i32.const 0)))
+    (local.set 0x0e6 (i64.load offset=0x0e6 align=1 (i32.const 0)))
+    (local.set 0x0e7 (i64.load offset=0x0e7 align=1 (i32.const 0)))
+    (local.set 0x0e8 (i64.load offset=0x0e8 align=1 (i32.const 0)))
+    (local.set 0x0e9 (i64.load offset=0x0e9 align=1 (i32.const 0)))
+    (local.set 0x0ea (i64.load offset=0x0ea align=1 (i32.const 0)))
+    (local.set 0x0eb (i64.load offset=0x0eb align=1 (i32.const 0)))
+    (local.set 0x0ec (i64.load offset=0x0ec align=1 (i32.const 0)))
+    (local.set 0x0ed (i64.load offset=0x0ed align=1 (i32.const 0)))
+    (local.set 0x0ee (i64.load offset=0x0ee align=1 (i32.const 0)))
+    (local.set 0x0ef (i64.load offset=0x0ef align=1 (i32.const 0)))
+    (local.set 0x0f0 (i64.load offset=0x0f0 align=1 (i32.const 0)))
+    (local.set 0x0f1 (i64.load offset=0x0f1 align=1 (i32.const 0)))
+    (local.set 0x0f2 (i64.load offset=0x0f2 align=1 (i32.const 0)))
+    (local.set 0x0f3 (i64.load offset=0x0f3 align=1 (i32.const 0)))
+    (local.set 0x0f4 (i64.load offset=0x0f4 align=1 (i32.const 0)))
+    (local.set 0x0f5 (i64.load offset=0x0f5 align=1 (i32.const 0)))
+    (local.set 0x0f6 (i64.load offset=0x0f6 align=1 (i32.const 0)))
+    (local.set 0x0f7 (i64.load offset=0x0f7 align=1 (i32.const 0)))
+    (local.set 0x0f8 (i64.load offset=0x0f8 align=1 (i32.const 0)))
+    (local.set 0x0f9 (i64.load offset=0x0f9 align=1 (i32.const 0)))
+    (local.set 0x0fa (i64.load offset=0x0fa align=1 (i32.const 0)))
+    (local.set 0x0fb (i64.load offset=0x0fb align=1 (i32.const 0)))
+    (local.set 0x0fc (i64.load offset=0x0fc align=1 (i32.const 0)))
+    (local.set 0x0fd (i64.load offset=0x0fd align=1 (i32.const 0)))
+    (local.set 0x0fe (i64.load offset=0x0fe align=1 (i32.const 0)))
+    (local.set 0x0ff (i64.load offset=0x0ff align=1 (i32.const 0)))
+    (local.set 0x100 (i64.load offset=0x100 align=1 (i32.const 0)))
+    (local.set 0x101 (i64.load offset=0x101 align=1 (i32.const 0)))
+    (local.set 0x102 (i64.load offset=0x102 align=1 (i32.const 0)))
+    (local.set 0x103 (i64.load offset=0x103 align=1 (i32.const 0)))
+    (local.set 0x104 (i64.load offset=0x104 align=1 (i32.const 0)))
+    (local.set 0x105 (i64.load offset=0x105 align=1 (i32.const 0)))
+    (local.set 0x106 (i64.load offset=0x106 align=1 (i32.const 0)))
+    (local.set 0x107 (i64.load offset=0x107 align=1 (i32.const 0)))
+    (local.set 0x108 (i64.load offset=0x108 align=1 (i32.const 0)))
+    (local.set 0x109 (i64.load offset=0x109 align=1 (i32.const 0)))
+    (local.set 0x10a (i64.load offset=0x10a align=1 (i32.const 0)))
+    (local.set 0x10b (i64.load offset=0x10b align=1 (i32.const 0)))
+    (local.set 0x10c (i64.load offset=0x10c align=1 (i32.const 0)))
+    (local.set 0x10d (i64.load offset=0x10d align=1 (i32.const 0)))
+    (local.set 0x10e (i64.load offset=0x10e align=1 (i32.const 0)))
+    (local.set 0x10f (i64.load offset=0x10f align=1 (i32.const 0)))
+    (local.set 0x110 (i64.load offset=0x110 align=1 (i32.const 0)))
+    (local.set 0x111 (i64.load offset=0x111 align=1 (i32.const 0)))
+    (local.set 0x112 (i64.load offset=0x112 align=1 (i32.const 0)))
+    (local.set 0x113 (i64.load offset=0x113 align=1 (i32.const 0)))
+    (local.set 0x114 (i64.load offset=0x114 align=1 (i32.const 0)))
+    (local.set 0x115 (i64.load offset=0x115 align=1 (i32.const 0)))
+    (local.set 0x116 (i64.load offset=0x116 align=1 (i32.const 0)))
+    (local.set 0x117 (i64.load offset=0x117 align=1 (i32.const 0)))
+    (local.set 0x118 (i64.load offset=0x118 align=1 (i32.const 0)))
+    (local.set 0x119 (i64.load offset=0x119 align=1 (i32.const 0)))
+    (local.set 0x11a (i64.load offset=0x11a align=1 (i32.const 0)))
+    (local.set 0x11b (i64.load offset=0x11b align=1 (i32.const 0)))
+    (local.set 0x11c (i64.load offset=0x11c align=1 (i32.const 0)))
+    (local.set 0x11d (i64.load offset=0x11d align=1 (i32.const 0)))
+    (local.set 0x11e (i64.load offset=0x11e align=1 (i32.const 0)))
+    (local.set 0x11f (i64.load offset=0x11f align=1 (i32.const 0)))
+    (local.set 0x120 (i64.load offset=0x120 align=1 (i32.const 0)))
+    (local.set 0x121 (i64.load offset=0x121 align=1 (i32.const 0)))
+    (local.set 0x122 (i64.load offset=0x122 align=1 (i32.const 0)))
+    (local.set 0x123 (i64.load offset=0x123 align=1 (i32.const 0)))
+    (local.set 0x124 (i64.load offset=0x124 align=1 (i32.const 0)))
+    (local.set 0x125 (i64.load offset=0x125 align=1 (i32.const 0)))
+    (local.set 0x126 (i64.load offset=0x126 align=1 (i32.const 0)))
+    (local.set 0x127 (i64.load offset=0x127 align=1 (i32.const 0)))
+    (local.set 0x128 (i64.load offset=0x128 align=1 (i32.const 0)))
+    (local.set 0x129 (i64.load offset=0x129 align=1 (i32.const 0)))
+    (local.set 0x12a (i64.load offset=0x12a align=1 (i32.const 0)))
+    (local.set 0x12b (i64.load offset=0x12b align=1 (i32.const 0)))
+    (local.set 0x12c (i64.load offset=0x12c align=1 (i32.const 0)))
+    (local.set 0x12d (i64.load offset=0x12d align=1 (i32.const 0)))
+    (local.set 0x12e (i64.load offset=0x12e align=1 (i32.const 0)))
+    (local.set 0x12f (i64.load offset=0x12f align=1 (i32.const 0)))
+    (local.set 0x130 (i64.load offset=0x130 align=1 (i32.const 0)))
+    (local.set 0x131 (i64.load offset=0x131 align=1 (i32.const 0)))
+    (local.set 0x132 (i64.load offset=0x132 align=1 (i32.const 0)))
+    (local.set 0x133 (i64.load offset=0x133 align=1 (i32.const 0)))
+    (local.set 0x134 (i64.load offset=0x134 align=1 (i32.const 0)))
+    (local.set 0x135 (i64.load offset=0x135 align=1 (i32.const 0)))
+    (local.set 0x136 (i64.load offset=0x136 align=1 (i32.const 0)))
+    (local.set 0x137 (i64.load offset=0x137 align=1 (i32.const 0)))
+    (local.set 0x138 (i64.load offset=0x138 align=1 (i32.const 0)))
+    (local.set 0x139 (i64.load offset=0x139 align=1 (i32.const 0)))
+    (local.set 0x13a (i64.load offset=0x13a align=1 (i32.const 0)))
+    (local.set 0x13b (i64.load offset=0x13b align=1 (i32.const 0)))
+    (local.set 0x13c (i64.load offset=0x13c align=1 (i32.const 0)))
+    (local.set 0x13d (i64.load offset=0x13d align=1 (i32.const 0)))
+    (local.set 0x13e (i64.load offset=0x13e align=1 (i32.const 0)))
+    (local.set 0x13f (i64.load offset=0x13f align=1 (i32.const 0)))
+    (local.set 0x140 (i64.load offset=0x140 align=1 (i32.const 0)))
+    (local.set 0x141 (i64.load offset=0x141 align=1 (i32.const 0)))
+    (local.set 0x142 (i64.load offset=0x142 align=1 (i32.const 0)))
+    (local.set 0x143 (i64.load offset=0x143 align=1 (i32.const 0)))
+    (local.set 0x144 (i64.load offset=0x144 align=1 (i32.const 0)))
+    (local.set 0x145 (i64.load offset=0x145 align=1 (i32.const 0)))
+    (local.set 0x146 (i64.load offset=0x146 align=1 (i32.const 0)))
+    (local.set 0x147 (i64.load offset=0x147 align=1 (i32.const 0)))
+    (local.set 0x148 (i64.load offset=0x148 align=1 (i32.const 0)))
+    (local.set 0x149 (i64.load offset=0x149 align=1 (i32.const 0)))
+    (local.set 0x14a (i64.load offset=0x14a align=1 (i32.const 0)))
+    (local.set 0x14b (i64.load offset=0x14b align=1 (i32.const 0)))
+    (local.set 0x14c (i64.load offset=0x14c align=1 (i32.const 0)))
+    (local.set 0x14d (i64.load offset=0x14d align=1 (i32.const 0)))
+    (local.set 0x14e (i64.load offset=0x14e align=1 (i32.const 0)))
+    (local.set 0x14f (i64.load offset=0x14f align=1 (i32.const 0)))
+    (local.set 0x150 (i64.load offset=0x150 align=1 (i32.const 0)))
+    (local.set 0x151 (i64.load offset=0x151 align=1 (i32.const 0)))
+    (local.set 0x152 (i64.load offset=0x152 align=1 (i32.const 0)))
+    (local.set 0x153 (i64.load offset=0x153 align=1 (i32.const 0)))
+    (local.set 0x154 (i64.load offset=0x154 align=1 (i32.const 0)))
+    (local.set 0x155 (i64.load offset=0x155 align=1 (i32.const 0)))
+    (local.set 0x156 (i64.load offset=0x156 align=1 (i32.const 0)))
+    (local.set 0x157 (i64.load offset=0x157 align=1 (i32.const 0)))
+    (local.set 0x158 (i64.load offset=0x158 align=1 (i32.const 0)))
+    (local.set 0x159 (i64.load offset=0x159 align=1 (i32.const 0)))
+    (local.set 0x15a (i64.load offset=0x15a align=1 (i32.const 0)))
+    (local.set 0x15b (i64.load offset=0x15b align=1 (i32.const 0)))
+    (local.set 0x15c (i64.load offset=0x15c align=1 (i32.const 0)))
+    (local.set 0x15d (i64.load offset=0x15d align=1 (i32.const 0)))
+    (local.set 0x15e (i64.load offset=0x15e align=1 (i32.const 0)))
+    (local.set 0x15f (i64.load offset=0x15f align=1 (i32.const 0)))
+    (local.set 0x160 (i64.load offset=0x160 align=1 (i32.const 0)))
+    (local.set 0x161 (i64.load offset=0x161 align=1 (i32.const 0)))
+    (local.set 0x162 (i64.load offset=0x162 align=1 (i32.const 0)))
+    (local.set 0x163 (i64.load offset=0x163 align=1 (i32.const 0)))
+    (local.set 0x164 (i64.load offset=0x164 align=1 (i32.const 0)))
+    (local.set 0x165 (i64.load offset=0x165 align=1 (i32.const 0)))
+    (local.set 0x166 (i64.load offset=0x166 align=1 (i32.const 0)))
+    (local.set 0x167 (i64.load offset=0x167 align=1 (i32.const 0)))
+    (local.set 0x168 (i64.load offset=0x168 align=1 (i32.const 0)))
+    (local.set 0x169 (i64.load offset=0x169 align=1 (i32.const 0)))
+    (local.set 0x16a (i64.load offset=0x16a align=1 (i32.const 0)))
+    (local.set 0x16b (i64.load offset=0x16b align=1 (i32.const 0)))
+    (local.set 0x16c (i64.load offset=0x16c align=1 (i32.const 0)))
+    (local.set 0x16d (i64.load offset=0x16d align=1 (i32.const 0)))
+    (local.set 0x16e (i64.load offset=0x16e align=1 (i32.const 0)))
+    (local.set 0x16f (i64.load offset=0x16f align=1 (i32.const 0)))
+    (local.set 0x170 (i64.load offset=0x170 align=1 (i32.const 0)))
+    (local.set 0x171 (i64.load offset=0x171 align=1 (i32.const 0)))
+    (local.set 0x172 (i64.load offset=0x172 align=1 (i32.const 0)))
+    (local.set 0x173 (i64.load offset=0x173 align=1 (i32.const 0)))
+    (local.set 0x174 (i64.load offset=0x174 align=1 (i32.const 0)))
+    (local.set 0x175 (i64.load offset=0x175 align=1 (i32.const 0)))
+    (local.set 0x176 (i64.load offset=0x176 align=1 (i32.const 0)))
+    (local.set 0x177 (i64.load offset=0x177 align=1 (i32.const 0)))
+    (local.set 0x178 (i64.load offset=0x178 align=1 (i32.const 0)))
+    (local.set 0x179 (i64.load offset=0x179 align=1 (i32.const 0)))
+    (local.set 0x17a (i64.load offset=0x17a align=1 (i32.const 0)))
+    (local.set 0x17b (i64.load offset=0x17b align=1 (i32.const 0)))
+    (local.set 0x17c (i64.load offset=0x17c align=1 (i32.const 0)))
+    (local.set 0x17d (i64.load offset=0x17d align=1 (i32.const 0)))
+    (local.set 0x17e (i64.load offset=0x17e align=1 (i32.const 0)))
+    (local.set 0x17f (i64.load offset=0x17f align=1 (i32.const 0)))
+    (local.set 0x180 (i64.load offset=0x180 align=1 (i32.const 0)))
+    (local.set 0x181 (i64.load offset=0x181 align=1 (i32.const 0)))
+    (local.set 0x182 (i64.load offset=0x182 align=1 (i32.const 0)))
+    (local.set 0x183 (i64.load offset=0x183 align=1 (i32.const 0)))
+    (local.set 0x184 (i64.load offset=0x184 align=1 (i32.const 0)))
+    (local.set 0x185 (i64.load offset=0x185 align=1 (i32.const 0)))
+    (local.set 0x186 (i64.load offset=0x186 align=1 (i32.const 0)))
+    (local.set 0x187 (i64.load offset=0x187 align=1 (i32.const 0)))
+    (local.set 0x188 (i64.load offset=0x188 align=1 (i32.const 0)))
+    (local.set 0x189 (i64.load offset=0x189 align=1 (i32.const 0)))
+    (local.set 0x18a (i64.load offset=0x18a align=1 (i32.const 0)))
+    (local.set 0x18b (i64.load offset=0x18b align=1 (i32.const 0)))
+    (local.set 0x18c (i64.load offset=0x18c align=1 (i32.const 0)))
+    (local.set 0x18d (i64.load offset=0x18d align=1 (i32.const 0)))
+    (local.set 0x18e (i64.load offset=0x18e align=1 (i32.const 0)))
+    (local.set 0x18f (i64.load offset=0x18f align=1 (i32.const 0)))
+    (local.set 0x190 (i64.load offset=0x190 align=1 (i32.const 0)))
+    (local.set 0x191 (i64.load offset=0x191 align=1 (i32.const 0)))
+    (local.set 0x192 (i64.load offset=0x192 align=1 (i32.const 0)))
+    (local.set 0x193 (i64.load offset=0x193 align=1 (i32.const 0)))
+    (local.set 0x194 (i64.load offset=0x194 align=1 (i32.const 0)))
+    (local.set 0x195 (i64.load offset=0x195 align=1 (i32.const 0)))
+    (local.set 0x196 (i64.load offset=0x196 align=1 (i32.const 0)))
+    (local.set 0x197 (i64.load offset=0x197 align=1 (i32.const 0)))
+    (local.set 0x198 (i64.load offset=0x198 align=1 (i32.const 0)))
+    (local.set 0x199 (i64.load offset=0x199 align=1 (i32.const 0)))
+    (local.set 0x19a (i64.load offset=0x19a align=1 (i32.const 0)))
+    (local.set 0x19b (i64.load offset=0x19b align=1 (i32.const 0)))
+    (local.set 0x19c (i64.load offset=0x19c align=1 (i32.const 0)))
+    (local.set 0x19d (i64.load offset=0x19d align=1 (i32.const 0)))
+    (local.set 0x19e (i64.load offset=0x19e align=1 (i32.const 0)))
+    (local.set 0x19f (i64.load offset=0x19f align=1 (i32.const 0)))
+    (local.set 0x1a0 (i64.load offset=0x1a0 align=1 (i32.const 0)))
+    (local.set 0x1a1 (i64.load offset=0x1a1 align=1 (i32.const 0)))
+    (local.set 0x1a2 (i64.load offset=0x1a2 align=1 (i32.const 0)))
+    (local.set 0x1a3 (i64.load offset=0x1a3 align=1 (i32.const 0)))
+    (local.set 0x1a4 (i64.load offset=0x1a4 align=1 (i32.const 0)))
+    (local.set 0x1a5 (i64.load offset=0x1a5 align=1 (i32.const 0)))
+    (local.set 0x1a6 (i64.load offset=0x1a6 align=1 (i32.const 0)))
+    (local.set 0x1a7 (i64.load offset=0x1a7 align=1 (i32.const 0)))
+    (local.set 0x1a8 (i64.load offset=0x1a8 align=1 (i32.const 0)))
+    (local.set 0x1a9 (i64.load offset=0x1a9 align=1 (i32.const 0)))
+    (local.set 0x1aa (i64.load offset=0x1aa align=1 (i32.const 0)))
+    (local.set 0x1ab (i64.load offset=0x1ab align=1 (i32.const 0)))
+    (local.set 0x1ac (i64.load offset=0x1ac align=1 (i32.const 0)))
+    (local.set 0x1ad (i64.load offset=0x1ad align=1 (i32.const 0)))
+    (local.set 0x1ae (i64.load offset=0x1ae align=1 (i32.const 0)))
+    (local.set 0x1af (i64.load offset=0x1af align=1 (i32.const 0)))
+    (local.set 0x1b0 (i64.load offset=0x1b0 align=1 (i32.const 0)))
+    (local.set 0x1b1 (i64.load offset=0x1b1 align=1 (i32.const 0)))
+    (local.set 0x1b2 (i64.load offset=0x1b2 align=1 (i32.const 0)))
+    (local.set 0x1b3 (i64.load offset=0x1b3 align=1 (i32.const 0)))
+    (local.set 0x1b4 (i64.load offset=0x1b4 align=1 (i32.const 0)))
+    (local.set 0x1b5 (i64.load offset=0x1b5 align=1 (i32.const 0)))
+    (local.set 0x1b6 (i64.load offset=0x1b6 align=1 (i32.const 0)))
+    (local.set 0x1b7 (i64.load offset=0x1b7 align=1 (i32.const 0)))
+    (local.set 0x1b8 (i64.load offset=0x1b8 align=1 (i32.const 0)))
+    (local.set 0x1b9 (i64.load offset=0x1b9 align=1 (i32.const 0)))
+    (local.set 0x1ba (i64.load offset=0x1ba align=1 (i32.const 0)))
+    (local.set 0x1bb (i64.load offset=0x1bb align=1 (i32.const 0)))
+    (local.set 0x1bc (i64.load offset=0x1bc align=1 (i32.const 0)))
+    (local.set 0x1bd (i64.load offset=0x1bd align=1 (i32.const 0)))
+    (local.set 0x1be (i64.load offset=0x1be align=1 (i32.const 0)))
+    (local.set 0x1bf (i64.load offset=0x1bf align=1 (i32.const 0)))
+    (local.set 0x1c0 (i64.load offset=0x1c0 align=1 (i32.const 0)))
+    (local.set 0x1c1 (i64.load offset=0x1c1 align=1 (i32.const 0)))
+    (local.set 0x1c2 (i64.load offset=0x1c2 align=1 (i32.const 0)))
+    (local.set 0x1c3 (i64.load offset=0x1c3 align=1 (i32.const 0)))
+    (local.set 0x1c4 (i64.load offset=0x1c4 align=1 (i32.const 0)))
+    (local.set 0x1c5 (i64.load offset=0x1c5 align=1 (i32.const 0)))
+    (local.set 0x1c6 (i64.load offset=0x1c6 align=1 (i32.const 0)))
+    (local.set 0x1c7 (i64.load offset=0x1c7 align=1 (i32.const 0)))
+    (local.set 0x1c8 (i64.load offset=0x1c8 align=1 (i32.const 0)))
+    (local.set 0x1c9 (i64.load offset=0x1c9 align=1 (i32.const 0)))
+    (local.set 0x1ca (i64.load offset=0x1ca align=1 (i32.const 0)))
+    (local.set 0x1cb (i64.load offset=0x1cb align=1 (i32.const 0)))
+    (local.set 0x1cc (i64.load offset=0x1cc align=1 (i32.const 0)))
+    (local.set 0x1cd (i64.load offset=0x1cd align=1 (i32.const 0)))
+    (local.set 0x1ce (i64.load offset=0x1ce align=1 (i32.const 0)))
+    (local.set 0x1cf (i64.load offset=0x1cf align=1 (i32.const 0)))
+    (local.set 0x1d0 (i64.load offset=0x1d0 align=1 (i32.const 0)))
+    (local.set 0x1d1 (i64.load offset=0x1d1 align=1 (i32.const 0)))
+    (local.set 0x1d2 (i64.load offset=0x1d2 align=1 (i32.const 0)))
+    (local.set 0x1d3 (i64.load offset=0x1d3 align=1 (i32.const 0)))
+    (local.set 0x1d4 (i64.load offset=0x1d4 align=1 (i32.const 0)))
+    (local.set 0x1d5 (i64.load offset=0x1d5 align=1 (i32.const 0)))
+    (local.set 0x1d6 (i64.load offset=0x1d6 align=1 (i32.const 0)))
+    (local.set 0x1d7 (i64.load offset=0x1d7 align=1 (i32.const 0)))
+    (local.set 0x1d8 (i64.load offset=0x1d8 align=1 (i32.const 0)))
+    (local.set 0x1d9 (i64.load offset=0x1d9 align=1 (i32.const 0)))
+    (local.set 0x1da (i64.load offset=0x1da align=1 (i32.const 0)))
+    (local.set 0x1db (i64.load offset=0x1db align=1 (i32.const 0)))
+    (local.set 0x1dc (i64.load offset=0x1dc align=1 (i32.const 0)))
+    (local.set 0x1dd (i64.load offset=0x1dd align=1 (i32.const 0)))
+    (local.set 0x1de (i64.load offset=0x1de align=1 (i32.const 0)))
+    (local.set 0x1df (i64.load offset=0x1df align=1 (i32.const 0)))
+    (local.set 0x1e0 (i64.load offset=0x1e0 align=1 (i32.const 0)))
+    (local.set 0x1e1 (i64.load offset=0x1e1 align=1 (i32.const 0)))
+    (local.set 0x1e2 (i64.load offset=0x1e2 align=1 (i32.const 0)))
+    (local.set 0x1e3 (i64.load offset=0x1e3 align=1 (i32.const 0)))
+    (local.set 0x1e4 (i64.load offset=0x1e4 align=1 (i32.const 0)))
+    (local.set 0x1e5 (i64.load offset=0x1e5 align=1 (i32.const 0)))
+    (local.set 0x1e6 (i64.load offset=0x1e6 align=1 (i32.const 0)))
+    (local.set 0x1e7 (i64.load offset=0x1e7 align=1 (i32.const 0)))
+    (local.set 0x1e8 (i64.load offset=0x1e8 align=1 (i32.const 0)))
+    (local.set 0x1e9 (i64.load offset=0x1e9 align=1 (i32.const 0)))
+    (local.set 0x1ea (i64.load offset=0x1ea align=1 (i32.const 0)))
+    (local.set 0x1eb (i64.load offset=0x1eb align=1 (i32.const 0)))
+    (local.set 0x1ec (i64.load offset=0x1ec align=1 (i32.const 0)))
+    (local.set 0x1ed (i64.load offset=0x1ed align=1 (i32.const 0)))
+    (local.set 0x1ee (i64.load offset=0x1ee align=1 (i32.const 0)))
+    (local.set 0x1ef (i64.load offset=0x1ef align=1 (i32.const 0)))
+    (local.set 0x1f0 (i64.load offset=0x1f0 align=1 (i32.const 0)))
+    (local.set 0x1f1 (i64.load offset=0x1f1 align=1 (i32.const 0)))
+    (local.set 0x1f2 (i64.load offset=0x1f2 align=1 (i32.const 0)))
+    (local.set 0x1f3 (i64.load offset=0x1f3 align=1 (i32.const 0)))
+    (local.set 0x1f4 (i64.load offset=0x1f4 align=1 (i32.const 0)))
+    (local.set 0x1f5 (i64.load offset=0x1f5 align=1 (i32.const 0)))
+    (local.set 0x1f6 (i64.load offset=0x1f6 align=1 (i32.const 0)))
+    (local.set 0x1f7 (i64.load offset=0x1f7 align=1 (i32.const 0)))
+    (local.set 0x1f8 (i64.load offset=0x1f8 align=1 (i32.const 0)))
+    (local.set 0x1f9 (i64.load offset=0x1f9 align=1 (i32.const 0)))
+    (local.set 0x1fa (i64.load offset=0x1fa align=1 (i32.const 0)))
+    (local.set 0x1fb (i64.load offset=0x1fb align=1 (i32.const 0)))
+    (local.set 0x1fc (i64.load offset=0x1fc align=1 (i32.const 0)))
+    (local.set 0x1fd (i64.load offset=0x1fd align=1 (i32.const 0)))
+    (local.set 0x1fe (i64.load offset=0x1fe align=1 (i32.const 0)))
+    (local.set 0x1ff (i64.load offset=0x1ff align=1 (i32.const 0)))
+    (local.set 0x200 (i64.load offset=0x200 align=1 (i32.const 0)))
+    (local.set 0x201 (i64.load offset=0x201 align=1 (i32.const 0)))
+    (local.set 0x202 (i64.load offset=0x202 align=1 (i32.const 0)))
+    (local.set 0x203 (i64.load offset=0x203 align=1 (i32.const 0)))
+    (local.set 0x204 (i64.load offset=0x204 align=1 (i32.const 0)))
+    (local.set 0x205 (i64.load offset=0x205 align=1 (i32.const 0)))
+    (local.set 0x206 (i64.load offset=0x206 align=1 (i32.const 0)))
+    (local.set 0x207 (i64.load offset=0x207 align=1 (i32.const 0)))
+    (local.set 0x208 (i64.load offset=0x208 align=1 (i32.const 0)))
+    (local.set 0x209 (i64.load offset=0x209 align=1 (i32.const 0)))
+    (local.set 0x20a (i64.load offset=0x20a align=1 (i32.const 0)))
+    (local.set 0x20b (i64.load offset=0x20b align=1 (i32.const 0)))
+    (local.set 0x20c (i64.load offset=0x20c align=1 (i32.const 0)))
+    (local.set 0x20d (i64.load offset=0x20d align=1 (i32.const 0)))
+    (local.set 0x20e (i64.load offset=0x20e align=1 (i32.const 0)))
+    (local.set 0x20f (i64.load offset=0x20f align=1 (i32.const 0)))
+    (local.set 0x210 (i64.load offset=0x210 align=1 (i32.const 0)))
+    (local.set 0x211 (i64.load offset=0x211 align=1 (i32.const 0)))
+    (local.set 0x212 (i64.load offset=0x212 align=1 (i32.const 0)))
+    (local.set 0x213 (i64.load offset=0x213 align=1 (i32.const 0)))
+    (local.set 0x214 (i64.load offset=0x214 align=1 (i32.const 0)))
+    (local.set 0x215 (i64.load offset=0x215 align=1 (i32.const 0)))
+    (local.set 0x216 (i64.load offset=0x216 align=1 (i32.const 0)))
+    (local.set 0x217 (i64.load offset=0x217 align=1 (i32.const 0)))
+    (local.set 0x218 (i64.load offset=0x218 align=1 (i32.const 0)))
+    (local.set 0x219 (i64.load offset=0x219 align=1 (i32.const 0)))
+    (local.set 0x21a (i64.load offset=0x21a align=1 (i32.const 0)))
+    (local.set 0x21b (i64.load offset=0x21b align=1 (i32.const 0)))
+    (local.set 0x21c (i64.load offset=0x21c align=1 (i32.const 0)))
+    (local.set 0x21d (i64.load offset=0x21d align=1 (i32.const 0)))
+    (local.set 0x21e (i64.load offset=0x21e align=1 (i32.const 0)))
+    (local.set 0x21f (i64.load offset=0x21f align=1 (i32.const 0)))
+    (local.set 0x220 (i64.load offset=0x220 align=1 (i32.const 0)))
+    (local.set 0x221 (i64.load offset=0x221 align=1 (i32.const 0)))
+    (local.set 0x222 (i64.load offset=0x222 align=1 (i32.const 0)))
+    (local.set 0x223 (i64.load offset=0x223 align=1 (i32.const 0)))
+    (local.set 0x224 (i64.load offset=0x224 align=1 (i32.const 0)))
+    (local.set 0x225 (i64.load offset=0x225 align=1 (i32.const 0)))
+    (local.set 0x226 (i64.load offset=0x226 align=1 (i32.const 0)))
+    (local.set 0x227 (i64.load offset=0x227 align=1 (i32.const 0)))
+    (local.set 0x228 (i64.load offset=0x228 align=1 (i32.const 0)))
+    (local.set 0x229 (i64.load offset=0x229 align=1 (i32.const 0)))
+    (local.set 0x22a (i64.load offset=0x22a align=1 (i32.const 0)))
+    (local.set 0x22b (i64.load offset=0x22b align=1 (i32.const 0)))
+    (local.set 0x22c (i64.load offset=0x22c align=1 (i32.const 0)))
+    (local.set 0x22d (i64.load offset=0x22d align=1 (i32.const 0)))
+    (local.set 0x22e (i64.load offset=0x22e align=1 (i32.const 0)))
+    (local.set 0x22f (i64.load offset=0x22f align=1 (i32.const 0)))
+    (local.set 0x230 (i64.load offset=0x230 align=1 (i32.const 0)))
+    (local.set 0x231 (i64.load offset=0x231 align=1 (i32.const 0)))
+    (local.set 0x232 (i64.load offset=0x232 align=1 (i32.const 0)))
+    (local.set 0x233 (i64.load offset=0x233 align=1 (i32.const 0)))
+    (local.set 0x234 (i64.load offset=0x234 align=1 (i32.const 0)))
+    (local.set 0x235 (i64.load offset=0x235 align=1 (i32.const 0)))
+    (local.set 0x236 (i64.load offset=0x236 align=1 (i32.const 0)))
+    (local.set 0x237 (i64.load offset=0x237 align=1 (i32.const 0)))
+    (local.set 0x238 (i64.load offset=0x238 align=1 (i32.const 0)))
+    (local.set 0x239 (i64.load offset=0x239 align=1 (i32.const 0)))
+    (local.set 0x23a (i64.load offset=0x23a align=1 (i32.const 0)))
+    (local.set 0x23b (i64.load offset=0x23b align=1 (i32.const 0)))
+    (local.set 0x23c (i64.load offset=0x23c align=1 (i32.const 0)))
+    (local.set 0x23d (i64.load offset=0x23d align=1 (i32.const 0)))
+    (local.set 0x23e (i64.load offset=0x23e align=1 (i32.const 0)))
+    (local.set 0x23f (i64.load offset=0x23f align=1 (i32.const 0)))
+    (local.set 0x240 (i64.load offset=0x240 align=1 (i32.const 0)))
+    (local.set 0x241 (i64.load offset=0x241 align=1 (i32.const 0)))
+    (local.set 0x242 (i64.load offset=0x242 align=1 (i32.const 0)))
+    (local.set 0x243 (i64.load offset=0x243 align=1 (i32.const 0)))
+    (local.set 0x244 (i64.load offset=0x244 align=1 (i32.const 0)))
+    (local.set 0x245 (i64.load offset=0x245 align=1 (i32.const 0)))
+    (local.set 0x246 (i64.load offset=0x246 align=1 (i32.const 0)))
+    (local.set 0x247 (i64.load offset=0x247 align=1 (i32.const 0)))
+    (local.set 0x248 (i64.load offset=0x248 align=1 (i32.const 0)))
+    (local.set 0x249 (i64.load offset=0x249 align=1 (i32.const 0)))
+    (local.set 0x24a (i64.load offset=0x24a align=1 (i32.const 0)))
+    (local.set 0x24b (i64.load offset=0x24b align=1 (i32.const 0)))
+    (local.set 0x24c (i64.load offset=0x24c align=1 (i32.const 0)))
+    (local.set 0x24d (i64.load offset=0x24d align=1 (i32.const 0)))
+    (local.set 0x24e (i64.load offset=0x24e align=1 (i32.const 0)))
+    (local.set 0x24f (i64.load offset=0x24f align=1 (i32.const 0)))
+    (local.set 0x250 (i64.load offset=0x250 align=1 (i32.const 0)))
+    (local.set 0x251 (i64.load offset=0x251 align=1 (i32.const 0)))
+    (local.set 0x252 (i64.load offset=0x252 align=1 (i32.const 0)))
+    (local.set 0x253 (i64.load offset=0x253 align=1 (i32.const 0)))
+    (local.set 0x254 (i64.load offset=0x254 align=1 (i32.const 0)))
+    (local.set 0x255 (i64.load offset=0x255 align=1 (i32.const 0)))
+    (local.set 0x256 (i64.load offset=0x256 align=1 (i32.const 0)))
+    (local.set 0x257 (i64.load offset=0x257 align=1 (i32.const 0)))
+    (local.set 0x258 (i64.load offset=0x258 align=1 (i32.const 0)))
+    (local.set 0x259 (i64.load offset=0x259 align=1 (i32.const 0)))
+    (local.set 0x25a (i64.load offset=0x25a align=1 (i32.const 0)))
+    (local.set 0x25b (i64.load offset=0x25b align=1 (i32.const 0)))
+    (local.set 0x25c (i64.load offset=0x25c align=1 (i32.const 0)))
+    (local.set 0x25d (i64.load offset=0x25d align=1 (i32.const 0)))
+    (local.set 0x25e (i64.load offset=0x25e align=1 (i32.const 0)))
+    (local.set 0x25f (i64.load offset=0x25f align=1 (i32.const 0)))
+    (local.set 0x260 (i64.load offset=0x260 align=1 (i32.const 0)))
+    (local.set 0x261 (i64.load offset=0x261 align=1 (i32.const 0)))
+    (local.set 0x262 (i64.load offset=0x262 align=1 (i32.const 0)))
+    (local.set 0x263 (i64.load offset=0x263 align=1 (i32.const 0)))
+    (local.set 0x264 (i64.load offset=0x264 align=1 (i32.const 0)))
+    (local.set 0x265 (i64.load offset=0x265 align=1 (i32.const 0)))
+    (local.set 0x266 (i64.load offset=0x266 align=1 (i32.const 0)))
+    (local.set 0x267 (i64.load offset=0x267 align=1 (i32.const 0)))
+    (local.set 0x268 (i64.load offset=0x268 align=1 (i32.const 0)))
+    (local.set 0x269 (i64.load offset=0x269 align=1 (i32.const 0)))
+    (local.set 0x26a (i64.load offset=0x26a align=1 (i32.const 0)))
+    (local.set 0x26b (i64.load offset=0x26b align=1 (i32.const 0)))
+    (local.set 0x26c (i64.load offset=0x26c align=1 (i32.const 0)))
+    (local.set 0x26d (i64.load offset=0x26d align=1 (i32.const 0)))
+    (local.set 0x26e (i64.load offset=0x26e align=1 (i32.const 0)))
+    (local.set 0x26f (i64.load offset=0x26f align=1 (i32.const 0)))
+    (local.set 0x270 (i64.load offset=0x270 align=1 (i32.const 0)))
+    (local.set 0x271 (i64.load offset=0x271 align=1 (i32.const 0)))
+    (local.set 0x272 (i64.load offset=0x272 align=1 (i32.const 0)))
+    (local.set 0x273 (i64.load offset=0x273 align=1 (i32.const 0)))
+    (local.set 0x274 (i64.load offset=0x274 align=1 (i32.const 0)))
+    (local.set 0x275 (i64.load offset=0x275 align=1 (i32.const 0)))
+    (local.set 0x276 (i64.load offset=0x276 align=1 (i32.const 0)))
+    (local.set 0x277 (i64.load offset=0x277 align=1 (i32.const 0)))
+    (local.set 0x278 (i64.load offset=0x278 align=1 (i32.const 0)))
+    (local.set 0x279 (i64.load offset=0x279 align=1 (i32.const 0)))
+    (local.set 0x27a (i64.load offset=0x27a align=1 (i32.const 0)))
+    (local.set 0x27b (i64.load offset=0x27b align=1 (i32.const 0)))
+    (local.set 0x27c (i64.load offset=0x27c align=1 (i32.const 0)))
+    (local.set 0x27d (i64.load offset=0x27d align=1 (i32.const 0)))
+    (local.set 0x27e (i64.load offset=0x27e align=1 (i32.const 0)))
+    (local.set 0x27f (i64.load offset=0x27f align=1 (i32.const 0)))
+    (local.set 0x280 (i64.load offset=0x280 align=1 (i32.const 0)))
+    (local.set 0x281 (i64.load offset=0x281 align=1 (i32.const 0)))
+    (local.set 0x282 (i64.load offset=0x282 align=1 (i32.const 0)))
+    (local.set 0x283 (i64.load offset=0x283 align=1 (i32.const 0)))
+    (local.set 0x284 (i64.load offset=0x284 align=1 (i32.const 0)))
+    (local.set 0x285 (i64.load offset=0x285 align=1 (i32.const 0)))
+    (local.set 0x286 (i64.load offset=0x286 align=1 (i32.const 0)))
+    (local.set 0x287 (i64.load offset=0x287 align=1 (i32.const 0)))
+    (local.set 0x288 (i64.load offset=0x288 align=1 (i32.const 0)))
+    (local.set 0x289 (i64.load offset=0x289 align=1 (i32.const 0)))
+    (local.set 0x28a (i64.load offset=0x28a align=1 (i32.const 0)))
+    (local.set 0x28b (i64.load offset=0x28b align=1 (i32.const 0)))
+    (local.set 0x28c (i64.load offset=0x28c align=1 (i32.const 0)))
+    (local.set 0x28d (i64.load offset=0x28d align=1 (i32.const 0)))
+    (local.set 0x28e (i64.load offset=0x28e align=1 (i32.const 0)))
+    (local.set 0x28f (i64.load offset=0x28f align=1 (i32.const 0)))
+    (local.set 0x290 (i64.load offset=0x290 align=1 (i32.const 0)))
+    (local.set 0x291 (i64.load offset=0x291 align=1 (i32.const 0)))
+    (local.set 0x292 (i64.load offset=0x292 align=1 (i32.const 0)))
+    (local.set 0x293 (i64.load offset=0x293 align=1 (i32.const 0)))
+    (local.set 0x294 (i64.load offset=0x294 align=1 (i32.const 0)))
+    (local.set 0x295 (i64.load offset=0x295 align=1 (i32.const 0)))
+    (local.set 0x296 (i64.load offset=0x296 align=1 (i32.const 0)))
+    (local.set 0x297 (i64.load offset=0x297 align=1 (i32.const 0)))
+    (local.set 0x298 (i64.load offset=0x298 align=1 (i32.const 0)))
+    (local.set 0x299 (i64.load offset=0x299 align=1 (i32.const 0)))
+    (local.set 0x29a (i64.load offset=0x29a align=1 (i32.const 0)))
+    (local.set 0x29b (i64.load offset=0x29b align=1 (i32.const 0)))
+    (local.set 0x29c (i64.load offset=0x29c align=1 (i32.const 0)))
+    (local.set 0x29d (i64.load offset=0x29d align=1 (i32.const 0)))
+    (local.set 0x29e (i64.load offset=0x29e align=1 (i32.const 0)))
+    (local.set 0x29f (i64.load offset=0x29f align=1 (i32.const 0)))
+    (local.set 0x2a0 (i64.load offset=0x2a0 align=1 (i32.const 0)))
+    (local.set 0x2a1 (i64.load offset=0x2a1 align=1 (i32.const 0)))
+    (local.set 0x2a2 (i64.load offset=0x2a2 align=1 (i32.const 0)))
+    (local.set 0x2a3 (i64.load offset=0x2a3 align=1 (i32.const 0)))
+    (local.set 0x2a4 (i64.load offset=0x2a4 align=1 (i32.const 0)))
+    (local.set 0x2a5 (i64.load offset=0x2a5 align=1 (i32.const 0)))
+    (local.set 0x2a6 (i64.load offset=0x2a6 align=1 (i32.const 0)))
+    (local.set 0x2a7 (i64.load offset=0x2a7 align=1 (i32.const 0)))
+    (local.set 0x2a8 (i64.load offset=0x2a8 align=1 (i32.const 0)))
+    (local.set 0x2a9 (i64.load offset=0x2a9 align=1 (i32.const 0)))
+    (local.set 0x2aa (i64.load offset=0x2aa align=1 (i32.const 0)))
+    (local.set 0x2ab (i64.load offset=0x2ab align=1 (i32.const 0)))
+    (local.set 0x2ac (i64.load offset=0x2ac align=1 (i32.const 0)))
+    (local.set 0x2ad (i64.load offset=0x2ad align=1 (i32.const 0)))
+    (local.set 0x2ae (i64.load offset=0x2ae align=1 (i32.const 0)))
+    (local.set 0x2af (i64.load offset=0x2af align=1 (i32.const 0)))
+    (local.set 0x2b0 (i64.load offset=0x2b0 align=1 (i32.const 0)))
+    (local.set 0x2b1 (i64.load offset=0x2b1 align=1 (i32.const 0)))
+    (local.set 0x2b2 (i64.load offset=0x2b2 align=1 (i32.const 0)))
+    (local.set 0x2b3 (i64.load offset=0x2b3 align=1 (i32.const 0)))
+    (local.set 0x2b4 (i64.load offset=0x2b4 align=1 (i32.const 0)))
+    (local.set 0x2b5 (i64.load offset=0x2b5 align=1 (i32.const 0)))
+    (local.set 0x2b6 (i64.load offset=0x2b6 align=1 (i32.const 0)))
+    (local.set 0x2b7 (i64.load offset=0x2b7 align=1 (i32.const 0)))
+    (local.set 0x2b8 (i64.load offset=0x2b8 align=1 (i32.const 0)))
+    (local.set 0x2b9 (i64.load offset=0x2b9 align=1 (i32.const 0)))
+    (local.set 0x2ba (i64.load offset=0x2ba align=1 (i32.const 0)))
+    (local.set 0x2bb (i64.load offset=0x2bb align=1 (i32.const 0)))
+    (local.set 0x2bc (i64.load offset=0x2bc align=1 (i32.const 0)))
+    (local.set 0x2bd (i64.load offset=0x2bd align=1 (i32.const 0)))
+    (local.set 0x2be (i64.load offset=0x2be align=1 (i32.const 0)))
+    (local.set 0x2bf (i64.load offset=0x2bf align=1 (i32.const 0)))
+    (local.set 0x2c0 (i64.load offset=0x2c0 align=1 (i32.const 0)))
+    (local.set 0x2c1 (i64.load offset=0x2c1 align=1 (i32.const 0)))
+    (local.set 0x2c2 (i64.load offset=0x2c2 align=1 (i32.const 0)))
+    (local.set 0x2c3 (i64.load offset=0x2c3 align=1 (i32.const 0)))
+    (local.set 0x2c4 (i64.load offset=0x2c4 align=1 (i32.const 0)))
+    (local.set 0x2c5 (i64.load offset=0x2c5 align=1 (i32.const 0)))
+    (local.set 0x2c6 (i64.load offset=0x2c6 align=1 (i32.const 0)))
+    (local.set 0x2c7 (i64.load offset=0x2c7 align=1 (i32.const 0)))
+    (local.set 0x2c8 (i64.load offset=0x2c8 align=1 (i32.const 0)))
+    (local.set 0x2c9 (i64.load offset=0x2c9 align=1 (i32.const 0)))
+    (local.set 0x2ca (i64.load offset=0x2ca align=1 (i32.const 0)))
+    (local.set 0x2cb (i64.load offset=0x2cb align=1 (i32.const 0)))
+    (local.set 0x2cc (i64.load offset=0x2cc align=1 (i32.const 0)))
+    (local.set 0x2cd (i64.load offset=0x2cd align=1 (i32.const 0)))
+    (local.set 0x2ce (i64.load offset=0x2ce align=1 (i32.const 0)))
+    (local.set 0x2cf (i64.load offset=0x2cf align=1 (i32.const 0)))
+    (local.set 0x2d0 (i64.load offset=0x2d0 align=1 (i32.const 0)))
+    (local.set 0x2d1 (i64.load offset=0x2d1 align=1 (i32.const 0)))
+    (local.set 0x2d2 (i64.load offset=0x2d2 align=1 (i32.const 0)))
+    (local.set 0x2d3 (i64.load offset=0x2d3 align=1 (i32.const 0)))
+    (local.set 0x2d4 (i64.load offset=0x2d4 align=1 (i32.const 0)))
+    (local.set 0x2d5 (i64.load offset=0x2d5 align=1 (i32.const 0)))
+    (local.set 0x2d6 (i64.load offset=0x2d6 align=1 (i32.const 0)))
+    (local.set 0x2d7 (i64.load offset=0x2d7 align=1 (i32.const 0)))
+    (local.set 0x2d8 (i64.load offset=0x2d8 align=1 (i32.const 0)))
+    (local.set 0x2d9 (i64.load offset=0x2d9 align=1 (i32.const 0)))
+    (local.set 0x2da (i64.load offset=0x2da align=1 (i32.const 0)))
+    (local.set 0x2db (i64.load offset=0x2db align=1 (i32.const 0)))
+    (local.set 0x2dc (i64.load offset=0x2dc align=1 (i32.const 0)))
+    (local.set 0x2dd (i64.load offset=0x2dd align=1 (i32.const 0)))
+    (local.set 0x2de (i64.load offset=0x2de align=1 (i32.const 0)))
+    (local.set 0x2df (i64.load offset=0x2df align=1 (i32.const 0)))
+    (local.set 0x2e0 (i64.load offset=0x2e0 align=1 (i32.const 0)))
+    (local.set 0x2e1 (i64.load offset=0x2e1 align=1 (i32.const 0)))
+    (local.set 0x2e2 (i64.load offset=0x2e2 align=1 (i32.const 0)))
+    (local.set 0x2e3 (i64.load offset=0x2e3 align=1 (i32.const 0)))
+    (local.set 0x2e4 (i64.load offset=0x2e4 align=1 (i32.const 0)))
+    (local.set 0x2e5 (i64.load offset=0x2e5 align=1 (i32.const 0)))
+    (local.set 0x2e6 (i64.load offset=0x2e6 align=1 (i32.const 0)))
+    (local.set 0x2e7 (i64.load offset=0x2e7 align=1 (i32.const 0)))
+    (local.set 0x2e8 (i64.load offset=0x2e8 align=1 (i32.const 0)))
+    (local.set 0x2e9 (i64.load offset=0x2e9 align=1 (i32.const 0)))
+    (local.set 0x2ea (i64.load offset=0x2ea align=1 (i32.const 0)))
+    (local.set 0x2eb (i64.load offset=0x2eb align=1 (i32.const 0)))
+    (local.set 0x2ec (i64.load offset=0x2ec align=1 (i32.const 0)))
+    (local.set 0x2ed (i64.load offset=0x2ed align=1 (i32.const 0)))
+    (local.set 0x2ee (i64.load offset=0x2ee align=1 (i32.const 0)))
+    (local.set 0x2ef (i64.load offset=0x2ef align=1 (i32.const 0)))
+    (local.set 0x2f0 (i64.load offset=0x2f0 align=1 (i32.const 0)))
+    (local.set 0x2f1 (i64.load offset=0x2f1 align=1 (i32.const 0)))
+    (local.set 0x2f2 (i64.load offset=0x2f2 align=1 (i32.const 0)))
+    (local.set 0x2f3 (i64.load offset=0x2f3 align=1 (i32.const 0)))
+    (local.set 0x2f4 (i64.load offset=0x2f4 align=1 (i32.const 0)))
+    (local.set 0x2f5 (i64.load offset=0x2f5 align=1 (i32.const 0)))
+    (local.set 0x2f6 (i64.load offset=0x2f6 align=1 (i32.const 0)))
+    (local.set 0x2f7 (i64.load offset=0x2f7 align=1 (i32.const 0)))
+    (local.set 0x2f8 (i64.load offset=0x2f8 align=1 (i32.const 0)))
+    (local.set 0x2f9 (i64.load offset=0x2f9 align=1 (i32.const 0)))
+    (local.set 0x2fa (i64.load offset=0x2fa align=1 (i32.const 0)))
+    (local.set 0x2fb (i64.load offset=0x2fb align=1 (i32.const 0)))
+    (local.set 0x2fc (i64.load offset=0x2fc align=1 (i32.const 0)))
+    (local.set 0x2fd (i64.load offset=0x2fd align=1 (i32.const 0)))
+    (local.set 0x2fe (i64.load offset=0x2fe align=1 (i32.const 0)))
+    (local.set 0x2ff (i64.load offset=0x2ff align=1 (i32.const 0)))
+    (local.set 0x300 (i64.load offset=0x300 align=1 (i32.const 0)))
+    (local.set 0x301 (i64.load offset=0x301 align=1 (i32.const 0)))
+    (local.set 0x302 (i64.load offset=0x302 align=1 (i32.const 0)))
+    (local.set 0x303 (i64.load offset=0x303 align=1 (i32.const 0)))
+    (local.set 0x304 (i64.load offset=0x304 align=1 (i32.const 0)))
+    (local.set 0x305 (i64.load offset=0x305 align=1 (i32.const 0)))
+    (local.set 0x306 (i64.load offset=0x306 align=1 (i32.const 0)))
+    (local.set 0x307 (i64.load offset=0x307 align=1 (i32.const 0)))
+    (local.set 0x308 (i64.load offset=0x308 align=1 (i32.const 0)))
+    (local.set 0x309 (i64.load offset=0x309 align=1 (i32.const 0)))
+    (local.set 0x30a (i64.load offset=0x30a align=1 (i32.const 0)))
+    (local.set 0x30b (i64.load offset=0x30b align=1 (i32.const 0)))
+    (local.set 0x30c (i64.load offset=0x30c align=1 (i32.const 0)))
+    (local.set 0x30d (i64.load offset=0x30d align=1 (i32.const 0)))
+    (local.set 0x30e (i64.load offset=0x30e align=1 (i32.const 0)))
+    (local.set 0x30f (i64.load offset=0x30f align=1 (i32.const 0)))
+    (local.set 0x310 (i64.load offset=0x310 align=1 (i32.const 0)))
+    (local.set 0x311 (i64.load offset=0x311 align=1 (i32.const 0)))
+    (local.set 0x312 (i64.load offset=0x312 align=1 (i32.const 0)))
+    (local.set 0x313 (i64.load offset=0x313 align=1 (i32.const 0)))
+    (local.set 0x314 (i64.load offset=0x314 align=1 (i32.const 0)))
+    (local.set 0x315 (i64.load offset=0x315 align=1 (i32.const 0)))
+    (local.set 0x316 (i64.load offset=0x316 align=1 (i32.const 0)))
+    (local.set 0x317 (i64.load offset=0x317 align=1 (i32.const 0)))
+    (local.set 0x318 (i64.load offset=0x318 align=1 (i32.const 0)))
+    (local.set 0x319 (i64.load offset=0x319 align=1 (i32.const 0)))
+    (local.set 0x31a (i64.load offset=0x31a align=1 (i32.const 0)))
+    (local.set 0x31b (i64.load offset=0x31b align=1 (i32.const 0)))
+    (local.set 0x31c (i64.load offset=0x31c align=1 (i32.const 0)))
+    (local.set 0x31d (i64.load offset=0x31d align=1 (i32.const 0)))
+    (local.set 0x31e (i64.load offset=0x31e align=1 (i32.const 0)))
+    (local.set 0x31f (i64.load offset=0x31f align=1 (i32.const 0)))
+    (local.set 0x320 (i64.load offset=0x320 align=1 (i32.const 0)))
+    (local.set 0x321 (i64.load offset=0x321 align=1 (i32.const 0)))
+    (local.set 0x322 (i64.load offset=0x322 align=1 (i32.const 0)))
+    (local.set 0x323 (i64.load offset=0x323 align=1 (i32.const 0)))
+    (local.set 0x324 (i64.load offset=0x324 align=1 (i32.const 0)))
+    (local.set 0x325 (i64.load offset=0x325 align=1 (i32.const 0)))
+    (local.set 0x326 (i64.load offset=0x326 align=1 (i32.const 0)))
+    (local.set 0x327 (i64.load offset=0x327 align=1 (i32.const 0)))
+    (local.set 0x328 (i64.load offset=0x328 align=1 (i32.const 0)))
+    (local.set 0x329 (i64.load offset=0x329 align=1 (i32.const 0)))
+    (local.set 0x32a (i64.load offset=0x32a align=1 (i32.const 0)))
+    (local.set 0x32b (i64.load offset=0x32b align=1 (i32.const 0)))
+    (local.set 0x32c (i64.load offset=0x32c align=1 (i32.const 0)))
+    (local.set 0x32d (i64.load offset=0x32d align=1 (i32.const 0)))
+    (local.set 0x32e (i64.load offset=0x32e align=1 (i32.const 0)))
+    (local.set 0x32f (i64.load offset=0x32f align=1 (i32.const 0)))
+    (local.set 0x330 (i64.load offset=0x330 align=1 (i32.const 0)))
+    (local.set 0x331 (i64.load offset=0x331 align=1 (i32.const 0)))
+    (local.set 0x332 (i64.load offset=0x332 align=1 (i32.const 0)))
+    (local.set 0x333 (i64.load offset=0x333 align=1 (i32.const 0)))
+    (local.set 0x334 (i64.load offset=0x334 align=1 (i32.const 0)))
+    (local.set 0x335 (i64.load offset=0x335 align=1 (i32.const 0)))
+    (local.set 0x336 (i64.load offset=0x336 align=1 (i32.const 0)))
+    (local.set 0x337 (i64.load offset=0x337 align=1 (i32.const 0)))
+    (local.set 0x338 (i64.load offset=0x338 align=1 (i32.const 0)))
+    (local.set 0x339 (i64.load offset=0x339 align=1 (i32.const 0)))
+    (local.set 0x33a (i64.load offset=0x33a align=1 (i32.const 0)))
+    (local.set 0x33b (i64.load offset=0x33b align=1 (i32.const 0)))
+    (local.set 0x33c (i64.load offset=0x33c align=1 (i32.const 0)))
+    (local.set 0x33d (i64.load offset=0x33d align=1 (i32.const 0)))
+    (local.set 0x33e (i64.load offset=0x33e align=1 (i32.const 0)))
+    (local.set 0x33f (i64.load offset=0x33f align=1 (i32.const 0)))
+    (local.set 0x340 (i64.load offset=0x340 align=1 (i32.const 0)))
+    (local.set 0x341 (i64.load offset=0x341 align=1 (i32.const 0)))
+    (local.set 0x342 (i64.load offset=0x342 align=1 (i32.const 0)))
+    (local.set 0x343 (i64.load offset=0x343 align=1 (i32.const 0)))
+    (local.set 0x344 (i64.load offset=0x344 align=1 (i32.const 0)))
+    (local.set 0x345 (i64.load offset=0x345 align=1 (i32.const 0)))
+    (local.set 0x346 (i64.load offset=0x346 align=1 (i32.const 0)))
+    (local.set 0x347 (i64.load offset=0x347 align=1 (i32.const 0)))
+    (local.set 0x348 (i64.load offset=0x348 align=1 (i32.const 0)))
+    (local.set 0x349 (i64.load offset=0x349 align=1 (i32.const 0)))
+    (local.set 0x34a (i64.load offset=0x34a align=1 (i32.const 0)))
+    (local.set 0x34b (i64.load offset=0x34b align=1 (i32.const 0)))
+    (local.set 0x34c (i64.load offset=0x34c align=1 (i32.const 0)))
+    (local.set 0x34d (i64.load offset=0x34d align=1 (i32.const 0)))
+    (local.set 0x34e (i64.load offset=0x34e align=1 (i32.const 0)))
+    (local.set 0x34f (i64.load offset=0x34f align=1 (i32.const 0)))
+    (local.set 0x350 (i64.load offset=0x350 align=1 (i32.const 0)))
+    (local.set 0x351 (i64.load offset=0x351 align=1 (i32.const 0)))
+    (local.set 0x352 (i64.load offset=0x352 align=1 (i32.const 0)))
+    (local.set 0x353 (i64.load offset=0x353 align=1 (i32.const 0)))
+    (local.set 0x354 (i64.load offset=0x354 align=1 (i32.const 0)))
+    (local.set 0x355 (i64.load offset=0x355 align=1 (i32.const 0)))
+    (local.set 0x356 (i64.load offset=0x356 align=1 (i32.const 0)))
+    (local.set 0x357 (i64.load offset=0x357 align=1 (i32.const 0)))
+    (local.set 0x358 (i64.load offset=0x358 align=1 (i32.const 0)))
+    (local.set 0x359 (i64.load offset=0x359 align=1 (i32.const 0)))
+    (local.set 0x35a (i64.load offset=0x35a align=1 (i32.const 0)))
+    (local.set 0x35b (i64.load offset=0x35b align=1 (i32.const 0)))
+    (local.set 0x35c (i64.load offset=0x35c align=1 (i32.const 0)))
+    (local.set 0x35d (i64.load offset=0x35d align=1 (i32.const 0)))
+    (local.set 0x35e (i64.load offset=0x35e align=1 (i32.const 0)))
+    (local.set 0x35f (i64.load offset=0x35f align=1 (i32.const 0)))
+    (local.set 0x360 (i64.load offset=0x360 align=1 (i32.const 0)))
+    (local.set 0x361 (i64.load offset=0x361 align=1 (i32.const 0)))
+    (local.set 0x362 (i64.load offset=0x362 align=1 (i32.const 0)))
+    (local.set 0x363 (i64.load offset=0x363 align=1 (i32.const 0)))
+    (local.set 0x364 (i64.load offset=0x364 align=1 (i32.const 0)))
+    (local.set 0x365 (i64.load offset=0x365 align=1 (i32.const 0)))
+    (local.set 0x366 (i64.load offset=0x366 align=1 (i32.const 0)))
+    (local.set 0x367 (i64.load offset=0x367 align=1 (i32.const 0)))
+    (local.set 0x368 (i64.load offset=0x368 align=1 (i32.const 0)))
+    (local.set 0x369 (i64.load offset=0x369 align=1 (i32.const 0)))
+    (local.set 0x36a (i64.load offset=0x36a align=1 (i32.const 0)))
+    (local.set 0x36b (i64.load offset=0x36b align=1 (i32.const 0)))
+    (local.set 0x36c (i64.load offset=0x36c align=1 (i32.const 0)))
+    (local.set 0x36d (i64.load offset=0x36d align=1 (i32.const 0)))
+    (local.set 0x36e (i64.load offset=0x36e align=1 (i32.const 0)))
+    (local.set 0x36f (i64.load offset=0x36f align=1 (i32.const 0)))
+    (local.set 0x370 (i64.load offset=0x370 align=1 (i32.const 0)))
+    (local.set 0x371 (i64.load offset=0x371 align=1 (i32.const 0)))
+    (local.set 0x372 (i64.load offset=0x372 align=1 (i32.const 0)))
+    (local.set 0x373 (i64.load offset=0x373 align=1 (i32.const 0)))
+    (local.set 0x374 (i64.load offset=0x374 align=1 (i32.const 0)))
+    (local.set 0x375 (i64.load offset=0x375 align=1 (i32.const 0)))
+    (local.set 0x376 (i64.load offset=0x376 align=1 (i32.const 0)))
+    (local.set 0x377 (i64.load offset=0x377 align=1 (i32.const 0)))
+    (local.set 0x378 (i64.load offset=0x378 align=1 (i32.const 0)))
+    (local.set 0x379 (i64.load offset=0x379 align=1 (i32.const 0)))
+    (local.set 0x37a (i64.load offset=0x37a align=1 (i32.const 0)))
+    (local.set 0x37b (i64.load offset=0x37b align=1 (i32.const 0)))
+    (local.set 0x37c (i64.load offset=0x37c align=1 (i32.const 0)))
+    (local.set 0x37d (i64.load offset=0x37d align=1 (i32.const 0)))
+    (local.set 0x37e (i64.load offset=0x37e align=1 (i32.const 0)))
+    (local.set 0x37f (i64.load offset=0x37f align=1 (i32.const 0)))
+    (local.set 0x380 (i64.load offset=0x380 align=1 (i32.const 0)))
+    (local.set 0x381 (i64.load offset=0x381 align=1 (i32.const 0)))
+    (local.set 0x382 (i64.load offset=0x382 align=1 (i32.const 0)))
+    (local.set 0x383 (i64.load offset=0x383 align=1 (i32.const 0)))
+    (local.set 0x384 (i64.load offset=0x384 align=1 (i32.const 0)))
+    (local.set 0x385 (i64.load offset=0x385 align=1 (i32.const 0)))
+    (local.set 0x386 (i64.load offset=0x386 align=1 (i32.const 0)))
+    (local.set 0x387 (i64.load offset=0x387 align=1 (i32.const 0)))
+    (local.set 0x388 (i64.load offset=0x388 align=1 (i32.const 0)))
+    (local.set 0x389 (i64.load offset=0x389 align=1 (i32.const 0)))
+    (local.set 0x38a (i64.load offset=0x38a align=1 (i32.const 0)))
+    (local.set 0x38b (i64.load offset=0x38b align=1 (i32.const 0)))
+    (local.set 0x38c (i64.load offset=0x38c align=1 (i32.const 0)))
+    (local.set 0x38d (i64.load offset=0x38d align=1 (i32.const 0)))
+    (local.set 0x38e (i64.load offset=0x38e align=1 (i32.const 0)))
+    (local.set 0x38f (i64.load offset=0x38f align=1 (i32.const 0)))
+    (local.set 0x390 (i64.load offset=0x390 align=1 (i32.const 0)))
+    (local.set 0x391 (i64.load offset=0x391 align=1 (i32.const 0)))
+    (local.set 0x392 (i64.load offset=0x392 align=1 (i32.const 0)))
+    (local.set 0x393 (i64.load offset=0x393 align=1 (i32.const 0)))
+    (local.set 0x394 (i64.load offset=0x394 align=1 (i32.const 0)))
+    (local.set 0x395 (i64.load offset=0x395 align=1 (i32.const 0)))
+    (local.set 0x396 (i64.load offset=0x396 align=1 (i32.const 0)))
+    (local.set 0x397 (i64.load offset=0x397 align=1 (i32.const 0)))
+    (local.set 0x398 (i64.load offset=0x398 align=1 (i32.const 0)))
+    (local.set 0x399 (i64.load offset=0x399 align=1 (i32.const 0)))
+    (local.set 0x39a (i64.load offset=0x39a align=1 (i32.const 0)))
+    (local.set 0x39b (i64.load offset=0x39b align=1 (i32.const 0)))
+    (local.set 0x39c (i64.load offset=0x39c align=1 (i32.const 0)))
+    (local.set 0x39d (i64.load offset=0x39d align=1 (i32.const 0)))
+    (local.set 0x39e (i64.load offset=0x39e align=1 (i32.const 0)))
+    (local.set 0x39f (i64.load offset=0x39f align=1 (i32.const 0)))
+    (local.set 0x3a0 (i64.load offset=0x3a0 align=1 (i32.const 0)))
+    (local.set 0x3a1 (i64.load offset=0x3a1 align=1 (i32.const 0)))
+    (local.set 0x3a2 (i64.load offset=0x3a2 align=1 (i32.const 0)))
+    (local.set 0x3a3 (i64.load offset=0x3a3 align=1 (i32.const 0)))
+    (local.set 0x3a4 (i64.load offset=0x3a4 align=1 (i32.const 0)))
+    (local.set 0x3a5 (i64.load offset=0x3a5 align=1 (i32.const 0)))
+    (local.set 0x3a6 (i64.load offset=0x3a6 align=1 (i32.const 0)))
+    (local.set 0x3a7 (i64.load offset=0x3a7 align=1 (i32.const 0)))
+    (local.set 0x3a8 (i64.load offset=0x3a8 align=1 (i32.const 0)))
+    (local.set 0x3a9 (i64.load offset=0x3a9 align=1 (i32.const 0)))
+    (local.set 0x3aa (i64.load offset=0x3aa align=1 (i32.const 0)))
+    (local.set 0x3ab (i64.load offset=0x3ab align=1 (i32.const 0)))
+    (local.set 0x3ac (i64.load offset=0x3ac align=1 (i32.const 0)))
+    (local.set 0x3ad (i64.load offset=0x3ad align=1 (i32.const 0)))
+    (local.set 0x3ae (i64.load offset=0x3ae align=1 (i32.const 0)))
+    (local.set 0x3af (i64.load offset=0x3af align=1 (i32.const 0)))
+    (local.set 0x3b0 (i64.load offset=0x3b0 align=1 (i32.const 0)))
+    (local.set 0x3b1 (i64.load offset=0x3b1 align=1 (i32.const 0)))
+    (local.set 0x3b2 (i64.load offset=0x3b2 align=1 (i32.const 0)))
+    (local.set 0x3b3 (i64.load offset=0x3b3 align=1 (i32.const 0)))
+    (local.set 0x3b4 (i64.load offset=0x3b4 align=1 (i32.const 0)))
+    (local.set 0x3b5 (i64.load offset=0x3b5 align=1 (i32.const 0)))
+    (local.set 0x3b6 (i64.load offset=0x3b6 align=1 (i32.const 0)))
+    (local.set 0x3b7 (i64.load offset=0x3b7 align=1 (i32.const 0)))
+    (local.set 0x3b8 (i64.load offset=0x3b8 align=1 (i32.const 0)))
+    (local.set 0x3b9 (i64.load offset=0x3b9 align=1 (i32.const 0)))
+    (local.set 0x3ba (i64.load offset=0x3ba align=1 (i32.const 0)))
+    (local.set 0x3bb (i64.load offset=0x3bb align=1 (i32.const 0)))
+    (local.set 0x3bc (i64.load offset=0x3bc align=1 (i32.const 0)))
+    (local.set 0x3bd (i64.load offset=0x3bd align=1 (i32.const 0)))
+    (local.set 0x3be (i64.load offset=0x3be align=1 (i32.const 0)))
+    (local.set 0x3bf (i64.load offset=0x3bf align=1 (i32.const 0)))
+    (local.set 0x3c0 (i64.load offset=0x3c0 align=1 (i32.const 0)))
+    (local.set 0x3c1 (i64.load offset=0x3c1 align=1 (i32.const 0)))
+    (local.set 0x3c2 (i64.load offset=0x3c2 align=1 (i32.const 0)))
+    (local.set 0x3c3 (i64.load offset=0x3c3 align=1 (i32.const 0)))
+    (local.set 0x3c4 (i64.load offset=0x3c4 align=1 (i32.const 0)))
+    (local.set 0x3c5 (i64.load offset=0x3c5 align=1 (i32.const 0)))
+    (local.set 0x3c6 (i64.load offset=0x3c6 align=1 (i32.const 0)))
+    (local.set 0x3c7 (i64.load offset=0x3c7 align=1 (i32.const 0)))
+    (local.set 0x3c8 (i64.load offset=0x3c8 align=1 (i32.const 0)))
+    (local.set 0x3c9 (i64.load offset=0x3c9 align=1 (i32.const 0)))
+    (local.set 0x3ca (i64.load offset=0x3ca align=1 (i32.const 0)))
+    (local.set 0x3cb (i64.load offset=0x3cb align=1 (i32.const 0)))
+    (local.set 0x3cc (i64.load offset=0x3cc align=1 (i32.const 0)))
+    (local.set 0x3cd (i64.load offset=0x3cd align=1 (i32.const 0)))
+    (local.set 0x3ce (i64.load offset=0x3ce align=1 (i32.const 0)))
+    (local.set 0x3cf (i64.load offset=0x3cf align=1 (i32.const 0)))
+    (local.set 0x3d0 (i64.load offset=0x3d0 align=1 (i32.const 0)))
+    (local.set 0x3d1 (i64.load offset=0x3d1 align=1 (i32.const 0)))
+    (local.set 0x3d2 (i64.load offset=0x3d2 align=1 (i32.const 0)))
+    (local.set 0x3d3 (i64.load offset=0x3d3 align=1 (i32.const 0)))
+    (local.set 0x3d4 (i64.load offset=0x3d4 align=1 (i32.const 0)))
+    (local.set 0x3d5 (i64.load offset=0x3d5 align=1 (i32.const 0)))
+    (local.set 0x3d6 (i64.load offset=0x3d6 align=1 (i32.const 0)))
+    (local.set 0x3d7 (i64.load offset=0x3d7 align=1 (i32.const 0)))
+    (local.set 0x3d8 (i64.load offset=0x3d8 align=1 (i32.const 0)))
+    (local.set 0x3d9 (i64.load offset=0x3d9 align=1 (i32.const 0)))
+    (local.set 0x3da (i64.load offset=0x3da align=1 (i32.const 0)))
+    (local.set 0x3db (i64.load offset=0x3db align=1 (i32.const 0)))
+    (local.set 0x3dc (i64.load offset=0x3dc align=1 (i32.const 0)))
+    (local.set 0x3dd (i64.load offset=0x3dd align=1 (i32.const 0)))
+    (local.set 0x3de (i64.load offset=0x3de align=1 (i32.const 0)))
+    (local.set 0x3df (i64.load offset=0x3df align=1 (i32.const 0)))
+    (local.set 0x3e0 (i64.load offset=0x3e0 align=1 (i32.const 0)))
+    (local.set 0x3e1 (i64.load offset=0x3e1 align=1 (i32.const 0)))
+    (local.set 0x3e2 (i64.load offset=0x3e2 align=1 (i32.const 0)))
+    (local.set 0x3e3 (i64.load offset=0x3e3 align=1 (i32.const 0)))
+    (local.set 0x3e4 (i64.load offset=0x3e4 align=1 (i32.const 0)))
+    (local.set 0x3e5 (i64.load offset=0x3e5 align=1 (i32.const 0)))
+    (local.set 0x3e6 (i64.load offset=0x3e6 align=1 (i32.const 0)))
+    (local.set 0x3e7 (i64.load offset=0x3e7 align=1 (i32.const 0)))
+    (local.set 0x3e8 (i64.load offset=0x3e8 align=1 (i32.const 0)))
+    (local.set 0x3e9 (i64.load offset=0x3e9 align=1 (i32.const 0)))
+    (local.set 0x3ea (i64.load offset=0x3ea align=1 (i32.const 0)))
+    (local.set 0x3eb (i64.load offset=0x3eb align=1 (i32.const 0)))
+    (local.set 0x3ec (i64.load offset=0x3ec align=1 (i32.const 0)))
+    (local.set 0x3ed (i64.load offset=0x3ed align=1 (i32.const 0)))
+    (local.set 0x3ee (i64.load offset=0x3ee align=1 (i32.const 0)))
+    (local.set 0x3ef (i64.load offset=0x3ef align=1 (i32.const 0)))
+    (local.set 0x3f0 (i64.load offset=0x3f0 align=1 (i32.const 0)))
+    (local.set 0x3f1 (i64.load offset=0x3f1 align=1 (i32.const 0)))
+    (local.set 0x3f2 (i64.load offset=0x3f2 align=1 (i32.const 0)))
+    (local.set 0x3f3 (i64.load offset=0x3f3 align=1 (i32.const 0)))
+    (local.set 0x3f4 (i64.load offset=0x3f4 align=1 (i32.const 0)))
+    (local.set 0x3f5 (i64.load offset=0x3f5 align=1 (i32.const 0)))
+    (local.set 0x3f6 (i64.load offset=0x3f6 align=1 (i32.const 0)))
+    (local.set 0x3f7 (i64.load offset=0x3f7 align=1 (i32.const 0)))
+    (local.set 0x3f8 (i64.load offset=0x3f8 align=1 (i32.const 0)))
+    (local.set 0x3f9 (i64.load offset=0x3f9 align=1 (i32.const 0)))
+    (local.set 0x3fa (i64.load offset=0x3fa align=1 (i32.const 0)))
+    (local.set 0x3fb (i64.load offset=0x3fb align=1 (i32.const 0)))
+    (local.set 0x3fc (i64.load offset=0x3fc align=1 (i32.const 0)))
+    (local.set 0x3fd (i64.load offset=0x3fd align=1 (i32.const 0)))
+    (local.set 0x3fe (i64.load offset=0x3fe align=1 (i32.const 0)))
+    (local.set 0x3ff (i64.load offset=0x3ff align=1 (i32.const 0)))
+    (local.set 0x400 (i64.load offset=0x400 align=1 (i32.const 0)))
+    (local.set 0x401 (i64.load offset=0x401 align=1 (i32.const 0)))
+    (local.set 0x402 (i64.load offset=0x402 align=1 (i32.const 0)))
+    (local.set 0x403 (i64.load offset=0x403 align=1 (i32.const 0)))
+    (local.set 0x404 (i64.load offset=0x404 align=1 (i32.const 0)))
+    (local.set 0x405 (i64.load offset=0x405 align=1 (i32.const 0)))
+    (local.set 0x406 (i64.load offset=0x406 align=1 (i32.const 0)))
+    (local.set 0x407 (i64.load offset=0x407 align=1 (i32.const 0)))
+    (local.set 0x408 (i64.load offset=0x408 align=1 (i32.const 0)))
+    (local.set 0x409 (i64.load offset=0x409 align=1 (i32.const 0)))
+    (local.set 0x40a (i64.load offset=0x40a align=1 (i32.const 0)))
+    (local.set 0x40b (i64.load offset=0x40b align=1 (i32.const 0)))
+    (local.set 0x40c (i64.load offset=0x40c align=1 (i32.const 0)))
+    (local.set 0x40d (i64.load offset=0x40d align=1 (i32.const 0)))
+    (local.set 0x40e (i64.load offset=0x40e align=1 (i32.const 0)))
+    (local.set 0x40f (i64.load offset=0x40f align=1 (i32.const 0)))
+    (local.set 0x410 (i64.load offset=0x410 align=1 (i32.const 0)))
+    (local.set 0x411 (i64.load offset=0x411 align=1 (i32.const 0)))
+    (local.set 0x412 (i64.load offset=0x412 align=1 (i32.const 0)))
+    (local.set 0x413 (i64.load offset=0x413 align=1 (i32.const 0)))
+    (local.set 0x414 (i64.load offset=0x414 align=1 (i32.const 0)))
+    (local.set 0x415 (i64.load offset=0x415 align=1 (i32.const 0)))
+    (local.set 0x416 (i64.load offset=0x416 align=1 (i32.const 0)))
+    (local.set 0x417 (i64.load offset=0x417 align=1 (i32.const 0)))
+    (local.set 0x418 (i64.load offset=0x418 align=1 (i32.const 0)))
+    (local.set 0x419 (i64.load offset=0x419 align=1 (i32.const 0)))
+    (local.set 0x41a (i64.load offset=0x41a align=1 (i32.const 0)))
+    (local.set 0x41b (i64.load offset=0x41b align=1 (i32.const 0)))
+    (local.set 0x41c (i64.load offset=0x41c align=1 (i32.const 0)))
+    (local.set 0x41d (i64.load offset=0x41d align=1 (i32.const 0)))
+    (local.set 0x41e (i64.load offset=0x41e align=1 (i32.const 0)))
+    (local.set 0x41f (i64.load offset=0x41f align=1 (i32.const 0)))
+
+    ;; store the locals back to memory
+    (i64.store offset=0x000 align=1 (i32.const 0) (local.get 0x000))
+    (i64.store offset=0x001 align=1 (i32.const 0) (local.get 0x001))
+    (i64.store offset=0x002 align=1 (i32.const 0) (local.get 0x002))
+    (i64.store offset=0x003 align=1 (i32.const 0) (local.get 0x003))
+    (i64.store offset=0x004 align=1 (i32.const 0) (local.get 0x004))
+    (i64.store offset=0x005 align=1 (i32.const 0) (local.get 0x005))
+    (i64.store offset=0x006 align=1 (i32.const 0) (local.get 0x006))
+    (i64.store offset=0x007 align=1 (i32.const 0) (local.get 0x007))
+    (i64.store offset=0x008 align=1 (i32.const 0) (local.get 0x008))
+    (i64.store offset=0x009 align=1 (i32.const 0) (local.get 0x009))
+    (i64.store offset=0x00a align=1 (i32.const 0) (local.get 0x00a))
+    (i64.store offset=0x00b align=1 (i32.const 0) (local.get 0x00b))
+    (i64.store offset=0x00c align=1 (i32.const 0) (local.get 0x00c))
+    (i64.store offset=0x00d align=1 (i32.const 0) (local.get 0x00d))
+    (i64.store offset=0x00e align=1 (i32.const 0) (local.get 0x00e))
+    (i64.store offset=0x00f align=1 (i32.const 0) (local.get 0x00f))
+    (i64.store offset=0x010 align=1 (i32.const 0) (local.get 0x010))
+    (i64.store offset=0x011 align=1 (i32.const 0) (local.get 0x011))
+    (i64.store offset=0x012 align=1 (i32.const 0) (local.get 0x012))
+    (i64.store offset=0x013 align=1 (i32.const 0) (local.get 0x013))
+    (i64.store offset=0x014 align=1 (i32.const 0) (local.get 0x014))
+    (i64.store offset=0x015 align=1 (i32.const 0) (local.get 0x015))
+    (i64.store offset=0x016 align=1 (i32.const 0) (local.get 0x016))
+    (i64.store offset=0x017 align=1 (i32.const 0) (local.get 0x017))
+    (i64.store offset=0x018 align=1 (i32.const 0) (local.get 0x018))
+    (i64.store offset=0x019 align=1 (i32.const 0) (local.get 0x019))
+    (i64.store offset=0x01a align=1 (i32.const 0) (local.get 0x01a))
+    (i64.store offset=0x01b align=1 (i32.const 0) (local.get 0x01b))
+    (i64.store offset=0x01c align=1 (i32.const 0) (local.get 0x01c))
+    (i64.store offset=0x01d align=1 (i32.const 0) (local.get 0x01d))
+    (i64.store offset=0x01e align=1 (i32.const 0) (local.get 0x01e))
+    (i64.store offset=0x01f align=1 (i32.const 0) (local.get 0x01f))
+    (i64.store offset=0x020 align=1 (i32.const 0) (local.get 0x020))
+    (i64.store offset=0x021 align=1 (i32.const 0) (local.get 0x021))
+    (i64.store offset=0x022 align=1 (i32.const 0) (local.get 0x022))
+    (i64.store offset=0x023 align=1 (i32.const 0) (local.get 0x023))
+    (i64.store offset=0x024 align=1 (i32.const 0) (local.get 0x024))
+    (i64.store offset=0x025 align=1 (i32.const 0) (local.get 0x025))
+    (i64.store offset=0x026 align=1 (i32.const 0) (local.get 0x026))
+    (i64.store offset=0x027 align=1 (i32.const 0) (local.get 0x027))
+    (i64.store offset=0x028 align=1 (i32.const 0) (local.get 0x028))
+    (i64.store offset=0x029 align=1 (i32.const 0) (local.get 0x029))
+    (i64.store offset=0x02a align=1 (i32.const 0) (local.get 0x02a))
+    (i64.store offset=0x02b align=1 (i32.const 0) (local.get 0x02b))
+    (i64.store offset=0x02c align=1 (i32.const 0) (local.get 0x02c))
+    (i64.store offset=0x02d align=1 (i32.const 0) (local.get 0x02d))
+    (i64.store offset=0x02e align=1 (i32.const 0) (local.get 0x02e))
+    (i64.store offset=0x02f align=1 (i32.const 0) (local.get 0x02f))
+    (i64.store offset=0x030 align=1 (i32.const 0) (local.get 0x030))
+    (i64.store offset=0x031 align=1 (i32.const 0) (local.get 0x031))
+    (i64.store offset=0x032 align=1 (i32.const 0) (local.get 0x032))
+    (i64.store offset=0x033 align=1 (i32.const 0) (local.get 0x033))
+    (i64.store offset=0x034 align=1 (i32.const 0) (local.get 0x034))
+    (i64.store offset=0x035 align=1 (i32.const 0) (local.get 0x035))
+    (i64.store offset=0x036 align=1 (i32.const 0) (local.get 0x036))
+    (i64.store offset=0x037 align=1 (i32.const 0) (local.get 0x037))
+    (i64.store offset=0x038 align=1 (i32.const 0) (local.get 0x038))
+    (i64.store offset=0x039 align=1 (i32.const 0) (local.get 0x039))
+    (i64.store offset=0x03a align=1 (i32.const 0) (local.get 0x03a))
+    (i64.store offset=0x03b align=1 (i32.const 0) (local.get 0x03b))
+    (i64.store offset=0x03c align=1 (i32.const 0) (local.get 0x03c))
+    (i64.store offset=0x03d align=1 (i32.const 0) (local.get 0x03d))
+    (i64.store offset=0x03e align=1 (i32.const 0) (local.get 0x03e))
+    (i64.store offset=0x03f align=1 (i32.const 0) (local.get 0x03f))
+    (i64.store offset=0x040 align=1 (i32.const 0) (local.get 0x040))
+    (i64.store offset=0x041 align=1 (i32.const 0) (local.get 0x041))
+    (i64.store offset=0x042 align=1 (i32.const 0) (local.get 0x042))
+    (i64.store offset=0x043 align=1 (i32.const 0) (local.get 0x043))
+    (i64.store offset=0x044 align=1 (i32.const 0) (local.get 0x044))
+    (i64.store offset=0x045 align=1 (i32.const 0) (local.get 0x045))
+    (i64.store offset=0x046 align=1 (i32.const 0) (local.get 0x046))
+    (i64.store offset=0x047 align=1 (i32.const 0) (local.get 0x047))
+    (i64.store offset=0x048 align=1 (i32.const 0) (local.get 0x048))
+    (i64.store offset=0x049 align=1 (i32.const 0) (local.get 0x049))
+    (i64.store offset=0x04a align=1 (i32.const 0) (local.get 0x04a))
+    (i64.store offset=0x04b align=1 (i32.const 0) (local.get 0x04b))
+    (i64.store offset=0x04c align=1 (i32.const 0) (local.get 0x04c))
+    (i64.store offset=0x04d align=1 (i32.const 0) (local.get 0x04d))
+    (i64.store offset=0x04e align=1 (i32.const 0) (local.get 0x04e))
+    (i64.store offset=0x04f align=1 (i32.const 0) (local.get 0x04f))
+    (i64.store offset=0x050 align=1 (i32.const 0) (local.get 0x050))
+    (i64.store offset=0x051 align=1 (i32.const 0) (local.get 0x051))
+    (i64.store offset=0x052 align=1 (i32.const 0) (local.get 0x052))
+    (i64.store offset=0x053 align=1 (i32.const 0) (local.get 0x053))
+    (i64.store offset=0x054 align=1 (i32.const 0) (local.get 0x054))
+    (i64.store offset=0x055 align=1 (i32.const 0) (local.get 0x055))
+    (i64.store offset=0x056 align=1 (i32.const 0) (local.get 0x056))
+    (i64.store offset=0x057 align=1 (i32.const 0) (local.get 0x057))
+    (i64.store offset=0x058 align=1 (i32.const 0) (local.get 0x058))
+    (i64.store offset=0x059 align=1 (i32.const 0) (local.get 0x059))
+    (i64.store offset=0x05a align=1 (i32.const 0) (local.get 0x05a))
+    (i64.store offset=0x05b align=1 (i32.const 0) (local.get 0x05b))
+    (i64.store offset=0x05c align=1 (i32.const 0) (local.get 0x05c))
+    (i64.store offset=0x05d align=1 (i32.const 0) (local.get 0x05d))
+    (i64.store offset=0x05e align=1 (i32.const 0) (local.get 0x05e))
+    (i64.store offset=0x05f align=1 (i32.const 0) (local.get 0x05f))
+    (i64.store offset=0x060 align=1 (i32.const 0) (local.get 0x060))
+    (i64.store offset=0x061 align=1 (i32.const 0) (local.get 0x061))
+    (i64.store offset=0x062 align=1 (i32.const 0) (local.get 0x062))
+    (i64.store offset=0x063 align=1 (i32.const 0) (local.get 0x063))
+    (i64.store offset=0x064 align=1 (i32.const 0) (local.get 0x064))
+    (i64.store offset=0x065 align=1 (i32.const 0) (local.get 0x065))
+    (i64.store offset=0x066 align=1 (i32.const 0) (local.get 0x066))
+    (i64.store offset=0x067 align=1 (i32.const 0) (local.get 0x067))
+    (i64.store offset=0x068 align=1 (i32.const 0) (local.get 0x068))
+    (i64.store offset=0x069 align=1 (i32.const 0) (local.get 0x069))
+    (i64.store offset=0x06a align=1 (i32.const 0) (local.get 0x06a))
+    (i64.store offset=0x06b align=1 (i32.const 0) (local.get 0x06b))
+    (i64.store offset=0x06c align=1 (i32.const 0) (local.get 0x06c))
+    (i64.store offset=0x06d align=1 (i32.const 0) (local.get 0x06d))
+    (i64.store offset=0x06e align=1 (i32.const 0) (local.get 0x06e))
+    (i64.store offset=0x06f align=1 (i32.const 0) (local.get 0x06f))
+    (i64.store offset=0x070 align=1 (i32.const 0) (local.get 0x070))
+    (i64.store offset=0x071 align=1 (i32.const 0) (local.get 0x071))
+    (i64.store offset=0x072 align=1 (i32.const 0) (local.get 0x072))
+    (i64.store offset=0x073 align=1 (i32.const 0) (local.get 0x073))
+    (i64.store offset=0x074 align=1 (i32.const 0) (local.get 0x074))
+    (i64.store offset=0x075 align=1 (i32.const 0) (local.get 0x075))
+    (i64.store offset=0x076 align=1 (i32.const 0) (local.get 0x076))
+    (i64.store offset=0x077 align=1 (i32.const 0) (local.get 0x077))
+    (i64.store offset=0x078 align=1 (i32.const 0) (local.get 0x078))
+    (i64.store offset=0x079 align=1 (i32.const 0) (local.get 0x079))
+    (i64.store offset=0x07a align=1 (i32.const 0) (local.get 0x07a))
+    (i64.store offset=0x07b align=1 (i32.const 0) (local.get 0x07b))
+    (i64.store offset=0x07c align=1 (i32.const 0) (local.get 0x07c))
+    (i64.store offset=0x07d align=1 (i32.const 0) (local.get 0x07d))
+    (i64.store offset=0x07e align=1 (i32.const 0) (local.get 0x07e))
+    (i64.store offset=0x07f align=1 (i32.const 0) (local.get 0x07f))
+    (i64.store offset=0x080 align=1 (i32.const 0) (local.get 0x080))
+    (i64.store offset=0x081 align=1 (i32.const 0) (local.get 0x081))
+    (i64.store offset=0x082 align=1 (i32.const 0) (local.get 0x082))
+    (i64.store offset=0x083 align=1 (i32.const 0) (local.get 0x083))
+    (i64.store offset=0x084 align=1 (i32.const 0) (local.get 0x084))
+    (i64.store offset=0x085 align=1 (i32.const 0) (local.get 0x085))
+    (i64.store offset=0x086 align=1 (i32.const 0) (local.get 0x086))
+    (i64.store offset=0x087 align=1 (i32.const 0) (local.get 0x087))
+    (i64.store offset=0x088 align=1 (i32.const 0) (local.get 0x088))
+    (i64.store offset=0x089 align=1 (i32.const 0) (local.get 0x089))
+    (i64.store offset=0x08a align=1 (i32.const 0) (local.get 0x08a))
+    (i64.store offset=0x08b align=1 (i32.const 0) (local.get 0x08b))
+    (i64.store offset=0x08c align=1 (i32.const 0) (local.get 0x08c))
+    (i64.store offset=0x08d align=1 (i32.const 0) (local.get 0x08d))
+    (i64.store offset=0x08e align=1 (i32.const 0) (local.get 0x08e))
+    (i64.store offset=0x08f align=1 (i32.const 0) (local.get 0x08f))
+    (i64.store offset=0x090 align=1 (i32.const 0) (local.get 0x090))
+    (i64.store offset=0x091 align=1 (i32.const 0) (local.get 0x091))
+    (i64.store offset=0x092 align=1 (i32.const 0) (local.get 0x092))
+    (i64.store offset=0x093 align=1 (i32.const 0) (local.get 0x093))
+    (i64.store offset=0x094 align=1 (i32.const 0) (local.get 0x094))
+    (i64.store offset=0x095 align=1 (i32.const 0) (local.get 0x095))
+    (i64.store offset=0x096 align=1 (i32.const 0) (local.get 0x096))
+    (i64.store offset=0x097 align=1 (i32.const 0) (local.get 0x097))
+    (i64.store offset=0x098 align=1 (i32.const 0) (local.get 0x098))
+    (i64.store offset=0x099 align=1 (i32.const 0) (local.get 0x099))
+    (i64.store offset=0x09a align=1 (i32.const 0) (local.get 0x09a))
+    (i64.store offset=0x09b align=1 (i32.const 0) (local.get 0x09b))
+    (i64.store offset=0x09c align=1 (i32.const 0) (local.get 0x09c))
+    (i64.store offset=0x09d align=1 (i32.const 0) (local.get 0x09d))
+    (i64.store offset=0x09e align=1 (i32.const 0) (local.get 0x09e))
+    (i64.store offset=0x09f align=1 (i32.const 0) (local.get 0x09f))
+    (i64.store offset=0x0a0 align=1 (i32.const 0) (local.get 0x0a0))
+    (i64.store offset=0x0a1 align=1 (i32.const 0) (local.get 0x0a1))
+    (i64.store offset=0x0a2 align=1 (i32.const 0) (local.get 0x0a2))
+    (i64.store offset=0x0a3 align=1 (i32.const 0) (local.get 0x0a3))
+    (i64.store offset=0x0a4 align=1 (i32.const 0) (local.get 0x0a4))
+    (i64.store offset=0x0a5 align=1 (i32.const 0) (local.get 0x0a5))
+    (i64.store offset=0x0a6 align=1 (i32.const 0) (local.get 0x0a6))
+    (i64.store offset=0x0a7 align=1 (i32.const 0) (local.get 0x0a7))
+    (i64.store offset=0x0a8 align=1 (i32.const 0) (local.get 0x0a8))
+    (i64.store offset=0x0a9 align=1 (i32.const 0) (local.get 0x0a9))
+    (i64.store offset=0x0aa align=1 (i32.const 0) (local.get 0x0aa))
+    (i64.store offset=0x0ab align=1 (i32.const 0) (local.get 0x0ab))
+    (i64.store offset=0x0ac align=1 (i32.const 0) (local.get 0x0ac))
+    (i64.store offset=0x0ad align=1 (i32.const 0) (local.get 0x0ad))
+    (i64.store offset=0x0ae align=1 (i32.const 0) (local.get 0x0ae))
+    (i64.store offset=0x0af align=1 (i32.const 0) (local.get 0x0af))
+    (i64.store offset=0x0b0 align=1 (i32.const 0) (local.get 0x0b0))
+    (i64.store offset=0x0b1 align=1 (i32.const 0) (local.get 0x0b1))
+    (i64.store offset=0x0b2 align=1 (i32.const 0) (local.get 0x0b2))
+    (i64.store offset=0x0b3 align=1 (i32.const 0) (local.get 0x0b3))
+    (i64.store offset=0x0b4 align=1 (i32.const 0) (local.get 0x0b4))
+    (i64.store offset=0x0b5 align=1 (i32.const 0) (local.get 0x0b5))
+    (i64.store offset=0x0b6 align=1 (i32.const 0) (local.get 0x0b6))
+    (i64.store offset=0x0b7 align=1 (i32.const 0) (local.get 0x0b7))
+    (i64.store offset=0x0b8 align=1 (i32.const 0) (local.get 0x0b8))
+    (i64.store offset=0x0b9 align=1 (i32.const 0) (local.get 0x0b9))
+    (i64.store offset=0x0ba align=1 (i32.const 0) (local.get 0x0ba))
+    (i64.store offset=0x0bb align=1 (i32.const 0) (local.get 0x0bb))
+    (i64.store offset=0x0bc align=1 (i32.const 0) (local.get 0x0bc))
+    (i64.store offset=0x0bd align=1 (i32.const 0) (local.get 0x0bd))
+    (i64.store offset=0x0be align=1 (i32.const 0) (local.get 0x0be))
+    (i64.store offset=0x0bf align=1 (i32.const 0) (local.get 0x0bf))
+    (i64.store offset=0x0c0 align=1 (i32.const 0) (local.get 0x0c0))
+    (i64.store offset=0x0c1 align=1 (i32.const 0) (local.get 0x0c1))
+    (i64.store offset=0x0c2 align=1 (i32.const 0) (local.get 0x0c2))
+    (i64.store offset=0x0c3 align=1 (i32.const 0) (local.get 0x0c3))
+    (i64.store offset=0x0c4 align=1 (i32.const 0) (local.get 0x0c4))
+    (i64.store offset=0x0c5 align=1 (i32.const 0) (local.get 0x0c5))
+    (i64.store offset=0x0c6 align=1 (i32.const 0) (local.get 0x0c6))
+    (i64.store offset=0x0c7 align=1 (i32.const 0) (local.get 0x0c7))
+    (i64.store offset=0x0c8 align=1 (i32.const 0) (local.get 0x0c8))
+    (i64.store offset=0x0c9 align=1 (i32.const 0) (local.get 0x0c9))
+    (i64.store offset=0x0ca align=1 (i32.const 0) (local.get 0x0ca))
+    (i64.store offset=0x0cb align=1 (i32.const 0) (local.get 0x0cb))
+    (i64.store offset=0x0cc align=1 (i32.const 0) (local.get 0x0cc))
+    (i64.store offset=0x0cd align=1 (i32.const 0) (local.get 0x0cd))
+    (i64.store offset=0x0ce align=1 (i32.const 0) (local.get 0x0ce))
+    (i64.store offset=0x0cf align=1 (i32.const 0) (local.get 0x0cf))
+    (i64.store offset=0x0d0 align=1 (i32.const 0) (local.get 0x0d0))
+    (i64.store offset=0x0d1 align=1 (i32.const 0) (local.get 0x0d1))
+    (i64.store offset=0x0d2 align=1 (i32.const 0) (local.get 0x0d2))
+    (i64.store offset=0x0d3 align=1 (i32.const 0) (local.get 0x0d3))
+    (i64.store offset=0x0d4 align=1 (i32.const 0) (local.get 0x0d4))
+    (i64.store offset=0x0d5 align=1 (i32.const 0) (local.get 0x0d5))
+    (i64.store offset=0x0d6 align=1 (i32.const 0) (local.get 0x0d6))
+    (i64.store offset=0x0d7 align=1 (i32.const 0) (local.get 0x0d7))
+    (i64.store offset=0x0d8 align=1 (i32.const 0) (local.get 0x0d8))
+    (i64.store offset=0x0d9 align=1 (i32.const 0) (local.get 0x0d9))
+    (i64.store offset=0x0da align=1 (i32.const 0) (local.get 0x0da))
+    (i64.store offset=0x0db align=1 (i32.const 0) (local.get 0x0db))
+    (i64.store offset=0x0dc align=1 (i32.const 0) (local.get 0x0dc))
+    (i64.store offset=0x0dd align=1 (i32.const 0) (local.get 0x0dd))
+    (i64.store offset=0x0de align=1 (i32.const 0) (local.get 0x0de))
+    (i64.store offset=0x0df align=1 (i32.const 0) (local.get 0x0df))
+    (i64.store offset=0x0e0 align=1 (i32.const 0) (local.get 0x0e0))
+    (i64.store offset=0x0e1 align=1 (i32.const 0) (local.get 0x0e1))
+    (i64.store offset=0x0e2 align=1 (i32.const 0) (local.get 0x0e2))
+    (i64.store offset=0x0e3 align=1 (i32.const 0) (local.get 0x0e3))
+    (i64.store offset=0x0e4 align=1 (i32.const 0) (local.get 0x0e4))
+    (i64.store offset=0x0e5 align=1 (i32.const 0) (local.get 0x0e5))
+    (i64.store offset=0x0e6 align=1 (i32.const 0) (local.get 0x0e6))
+    (i64.store offset=0x0e7 align=1 (i32.const 0) (local.get 0x0e7))
+    (i64.store offset=0x0e8 align=1 (i32.const 0) (local.get 0x0e8))
+    (i64.store offset=0x0e9 align=1 (i32.const 0) (local.get 0x0e9))
+    (i64.store offset=0x0ea align=1 (i32.const 0) (local.get 0x0ea))
+    (i64.store offset=0x0eb align=1 (i32.const 0) (local.get 0x0eb))
+    (i64.store offset=0x0ec align=1 (i32.const 0) (local.get 0x0ec))
+    (i64.store offset=0x0ed align=1 (i32.const 0) (local.get 0x0ed))
+    (i64.store offset=0x0ee align=1 (i32.const 0) (local.get 0x0ee))
+    (i64.store offset=0x0ef align=1 (i32.const 0) (local.get 0x0ef))
+    (i64.store offset=0x0f0 align=1 (i32.const 0) (local.get 0x0f0))
+    (i64.store offset=0x0f1 align=1 (i32.const 0) (local.get 0x0f1))
+    (i64.store offset=0x0f2 align=1 (i32.const 0) (local.get 0x0f2))
+    (i64.store offset=0x0f3 align=1 (i32.const 0) (local.get 0x0f3))
+    (i64.store offset=0x0f4 align=1 (i32.const 0) (local.get 0x0f4))
+    (i64.store offset=0x0f5 align=1 (i32.const 0) (local.get 0x0f5))
+    (i64.store offset=0x0f6 align=1 (i32.const 0) (local.get 0x0f6))
+    (i64.store offset=0x0f7 align=1 (i32.const 0) (local.get 0x0f7))
+    (i64.store offset=0x0f8 align=1 (i32.const 0) (local.get 0x0f8))
+    (i64.store offset=0x0f9 align=1 (i32.const 0) (local.get 0x0f9))
+    (i64.store offset=0x0fa align=1 (i32.const 0) (local.get 0x0fa))
+    (i64.store offset=0x0fb align=1 (i32.const 0) (local.get 0x0fb))
+    (i64.store offset=0x0fc align=1 (i32.const 0) (local.get 0x0fc))
+    (i64.store offset=0x0fd align=1 (i32.const 0) (local.get 0x0fd))
+    (i64.store offset=0x0fe align=1 (i32.const 0) (local.get 0x0fe))
+    (i64.store offset=0x0ff align=1 (i32.const 0) (local.get 0x0ff))
+    (i64.store offset=0x100 align=1 (i32.const 0) (local.get 0x100))
+    (i64.store offset=0x101 align=1 (i32.const 0) (local.get 0x101))
+    (i64.store offset=0x102 align=1 (i32.const 0) (local.get 0x102))
+    (i64.store offset=0x103 align=1 (i32.const 0) (local.get 0x103))
+    (i64.store offset=0x104 align=1 (i32.const 0) (local.get 0x104))
+    (i64.store offset=0x105 align=1 (i32.const 0) (local.get 0x105))
+    (i64.store offset=0x106 align=1 (i32.const 0) (local.get 0x106))
+    (i64.store offset=0x107 align=1 (i32.const 0) (local.get 0x107))
+    (i64.store offset=0x108 align=1 (i32.const 0) (local.get 0x108))
+    (i64.store offset=0x109 align=1 (i32.const 0) (local.get 0x109))
+    (i64.store offset=0x10a align=1 (i32.const 0) (local.get 0x10a))
+    (i64.store offset=0x10b align=1 (i32.const 0) (local.get 0x10b))
+    (i64.store offset=0x10c align=1 (i32.const 0) (local.get 0x10c))
+    (i64.store offset=0x10d align=1 (i32.const 0) (local.get 0x10d))
+    (i64.store offset=0x10e align=1 (i32.const 0) (local.get 0x10e))
+    (i64.store offset=0x10f align=1 (i32.const 0) (local.get 0x10f))
+    (i64.store offset=0x110 align=1 (i32.const 0) (local.get 0x110))
+    (i64.store offset=0x111 align=1 (i32.const 0) (local.get 0x111))
+    (i64.store offset=0x112 align=1 (i32.const 0) (local.get 0x112))
+    (i64.store offset=0x113 align=1 (i32.const 0) (local.get 0x113))
+    (i64.store offset=0x114 align=1 (i32.const 0) (local.get 0x114))
+    (i64.store offset=0x115 align=1 (i32.const 0) (local.get 0x115))
+    (i64.store offset=0x116 align=1 (i32.const 0) (local.get 0x116))
+    (i64.store offset=0x117 align=1 (i32.const 0) (local.get 0x117))
+    (i64.store offset=0x118 align=1 (i32.const 0) (local.get 0x118))
+    (i64.store offset=0x119 align=1 (i32.const 0) (local.get 0x119))
+    (i64.store offset=0x11a align=1 (i32.const 0) (local.get 0x11a))
+    (i64.store offset=0x11b align=1 (i32.const 0) (local.get 0x11b))
+    (i64.store offset=0x11c align=1 (i32.const 0) (local.get 0x11c))
+    (i64.store offset=0x11d align=1 (i32.const 0) (local.get 0x11d))
+    (i64.store offset=0x11e align=1 (i32.const 0) (local.get 0x11e))
+    (i64.store offset=0x11f align=1 (i32.const 0) (local.get 0x11f))
+    (i64.store offset=0x120 align=1 (i32.const 0) (local.get 0x120))
+    (i64.store offset=0x121 align=1 (i32.const 0) (local.get 0x121))
+    (i64.store offset=0x122 align=1 (i32.const 0) (local.get 0x122))
+    (i64.store offset=0x123 align=1 (i32.const 0) (local.get 0x123))
+    (i64.store offset=0x124 align=1 (i32.const 0) (local.get 0x124))
+    (i64.store offset=0x125 align=1 (i32.const 0) (local.get 0x125))
+    (i64.store offset=0x126 align=1 (i32.const 0) (local.get 0x126))
+    (i64.store offset=0x127 align=1 (i32.const 0) (local.get 0x127))
+    (i64.store offset=0x128 align=1 (i32.const 0) (local.get 0x128))
+    (i64.store offset=0x129 align=1 (i32.const 0) (local.get 0x129))
+    (i64.store offset=0x12a align=1 (i32.const 0) (local.get 0x12a))
+    (i64.store offset=0x12b align=1 (i32.const 0) (local.get 0x12b))
+    (i64.store offset=0x12c align=1 (i32.const 0) (local.get 0x12c))
+    (i64.store offset=0x12d align=1 (i32.const 0) (local.get 0x12d))
+    (i64.store offset=0x12e align=1 (i32.const 0) (local.get 0x12e))
+    (i64.store offset=0x12f align=1 (i32.const 0) (local.get 0x12f))
+    (i64.store offset=0x130 align=1 (i32.const 0) (local.get 0x130))
+    (i64.store offset=0x131 align=1 (i32.const 0) (local.get 0x131))
+    (i64.store offset=0x132 align=1 (i32.const 0) (local.get 0x132))
+    (i64.store offset=0x133 align=1 (i32.const 0) (local.get 0x133))
+    (i64.store offset=0x134 align=1 (i32.const 0) (local.get 0x134))
+    (i64.store offset=0x135 align=1 (i32.const 0) (local.get 0x135))
+    (i64.store offset=0x136 align=1 (i32.const 0) (local.get 0x136))
+    (i64.store offset=0x137 align=1 (i32.const 0) (local.get 0x137))
+    (i64.store offset=0x138 align=1 (i32.const 0) (local.get 0x138))
+    (i64.store offset=0x139 align=1 (i32.const 0) (local.get 0x139))
+    (i64.store offset=0x13a align=1 (i32.const 0) (local.get 0x13a))
+    (i64.store offset=0x13b align=1 (i32.const 0) (local.get 0x13b))
+    (i64.store offset=0x13c align=1 (i32.const 0) (local.get 0x13c))
+    (i64.store offset=0x13d align=1 (i32.const 0) (local.get 0x13d))
+    (i64.store offset=0x13e align=1 (i32.const 0) (local.get 0x13e))
+    (i64.store offset=0x13f align=1 (i32.const 0) (local.get 0x13f))
+    (i64.store offset=0x140 align=1 (i32.const 0) (local.get 0x140))
+    (i64.store offset=0x141 align=1 (i32.const 0) (local.get 0x141))
+    (i64.store offset=0x142 align=1 (i32.const 0) (local.get 0x142))
+    (i64.store offset=0x143 align=1 (i32.const 0) (local.get 0x143))
+    (i64.store offset=0x144 align=1 (i32.const 0) (local.get 0x144))
+    (i64.store offset=0x145 align=1 (i32.const 0) (local.get 0x145))
+    (i64.store offset=0x146 align=1 (i32.const 0) (local.get 0x146))
+    (i64.store offset=0x147 align=1 (i32.const 0) (local.get 0x147))
+    (i64.store offset=0x148 align=1 (i32.const 0) (local.get 0x148))
+    (i64.store offset=0x149 align=1 (i32.const 0) (local.get 0x149))
+    (i64.store offset=0x14a align=1 (i32.const 0) (local.get 0x14a))
+    (i64.store offset=0x14b align=1 (i32.const 0) (local.get 0x14b))
+    (i64.store offset=0x14c align=1 (i32.const 0) (local.get 0x14c))
+    (i64.store offset=0x14d align=1 (i32.const 0) (local.get 0x14d))
+    (i64.store offset=0x14e align=1 (i32.const 0) (local.get 0x14e))
+    (i64.store offset=0x14f align=1 (i32.const 0) (local.get 0x14f))
+    (i64.store offset=0x150 align=1 (i32.const 0) (local.get 0x150))
+    (i64.store offset=0x151 align=1 (i32.const 0) (local.get 0x151))
+    (i64.store offset=0x152 align=1 (i32.const 0) (local.get 0x152))
+    (i64.store offset=0x153 align=1 (i32.const 0) (local.get 0x153))
+    (i64.store offset=0x154 align=1 (i32.const 0) (local.get 0x154))
+    (i64.store offset=0x155 align=1 (i32.const 0) (local.get 0x155))
+    (i64.store offset=0x156 align=1 (i32.const 0) (local.get 0x156))
+    (i64.store offset=0x157 align=1 (i32.const 0) (local.get 0x157))
+    (i64.store offset=0x158 align=1 (i32.const 0) (local.get 0x158))
+    (i64.store offset=0x159 align=1 (i32.const 0) (local.get 0x159))
+    (i64.store offset=0x15a align=1 (i32.const 0) (local.get 0x15a))
+    (i64.store offset=0x15b align=1 (i32.const 0) (local.get 0x15b))
+    (i64.store offset=0x15c align=1 (i32.const 0) (local.get 0x15c))
+    (i64.store offset=0x15d align=1 (i32.const 0) (local.get 0x15d))
+    (i64.store offset=0x15e align=1 (i32.const 0) (local.get 0x15e))
+    (i64.store offset=0x15f align=1 (i32.const 0) (local.get 0x15f))
+    (i64.store offset=0x160 align=1 (i32.const 0) (local.get 0x160))
+    (i64.store offset=0x161 align=1 (i32.const 0) (local.get 0x161))
+    (i64.store offset=0x162 align=1 (i32.const 0) (local.get 0x162))
+    (i64.store offset=0x163 align=1 (i32.const 0) (local.get 0x163))
+    (i64.store offset=0x164 align=1 (i32.const 0) (local.get 0x164))
+    (i64.store offset=0x165 align=1 (i32.const 0) (local.get 0x165))
+    (i64.store offset=0x166 align=1 (i32.const 0) (local.get 0x166))
+    (i64.store offset=0x167 align=1 (i32.const 0) (local.get 0x167))
+    (i64.store offset=0x168 align=1 (i32.const 0) (local.get 0x168))
+    (i64.store offset=0x169 align=1 (i32.const 0) (local.get 0x169))
+    (i64.store offset=0x16a align=1 (i32.const 0) (local.get 0x16a))
+    (i64.store offset=0x16b align=1 (i32.const 0) (local.get 0x16b))
+    (i64.store offset=0x16c align=1 (i32.const 0) (local.get 0x16c))
+    (i64.store offset=0x16d align=1 (i32.const 0) (local.get 0x16d))
+    (i64.store offset=0x16e align=1 (i32.const 0) (local.get 0x16e))
+    (i64.store offset=0x16f align=1 (i32.const 0) (local.get 0x16f))
+    (i64.store offset=0x170 align=1 (i32.const 0) (local.get 0x170))
+    (i64.store offset=0x171 align=1 (i32.const 0) (local.get 0x171))
+    (i64.store offset=0x172 align=1 (i32.const 0) (local.get 0x172))
+    (i64.store offset=0x173 align=1 (i32.const 0) (local.get 0x173))
+    (i64.store offset=0x174 align=1 (i32.const 0) (local.get 0x174))
+    (i64.store offset=0x175 align=1 (i32.const 0) (local.get 0x175))
+    (i64.store offset=0x176 align=1 (i32.const 0) (local.get 0x176))
+    (i64.store offset=0x177 align=1 (i32.const 0) (local.get 0x177))
+    (i64.store offset=0x178 align=1 (i32.const 0) (local.get 0x178))
+    (i64.store offset=0x179 align=1 (i32.const 0) (local.get 0x179))
+    (i64.store offset=0x17a align=1 (i32.const 0) (local.get 0x17a))
+    (i64.store offset=0x17b align=1 (i32.const 0) (local.get 0x17b))
+    (i64.store offset=0x17c align=1 (i32.const 0) (local.get 0x17c))
+    (i64.store offset=0x17d align=1 (i32.const 0) (local.get 0x17d))
+    (i64.store offset=0x17e align=1 (i32.const 0) (local.get 0x17e))
+    (i64.store offset=0x17f align=1 (i32.const 0) (local.get 0x17f))
+    (i64.store offset=0x180 align=1 (i32.const 0) (local.get 0x180))
+    (i64.store offset=0x181 align=1 (i32.const 0) (local.get 0x181))
+    (i64.store offset=0x182 align=1 (i32.const 0) (local.get 0x182))
+    (i64.store offset=0x183 align=1 (i32.const 0) (local.get 0x183))
+    (i64.store offset=0x184 align=1 (i32.const 0) (local.get 0x184))
+    (i64.store offset=0x185 align=1 (i32.const 0) (local.get 0x185))
+    (i64.store offset=0x186 align=1 (i32.const 0) (local.get 0x186))
+    (i64.store offset=0x187 align=1 (i32.const 0) (local.get 0x187))
+    (i64.store offset=0x188 align=1 (i32.const 0) (local.get 0x188))
+    (i64.store offset=0x189 align=1 (i32.const 0) (local.get 0x189))
+    (i64.store offset=0x18a align=1 (i32.const 0) (local.get 0x18a))
+    (i64.store offset=0x18b align=1 (i32.const 0) (local.get 0x18b))
+    (i64.store offset=0x18c align=1 (i32.const 0) (local.get 0x18c))
+    (i64.store offset=0x18d align=1 (i32.const 0) (local.get 0x18d))
+    (i64.store offset=0x18e align=1 (i32.const 0) (local.get 0x18e))
+    (i64.store offset=0x18f align=1 (i32.const 0) (local.get 0x18f))
+    (i64.store offset=0x190 align=1 (i32.const 0) (local.get 0x190))
+    (i64.store offset=0x191 align=1 (i32.const 0) (local.get 0x191))
+    (i64.store offset=0x192 align=1 (i32.const 0) (local.get 0x192))
+    (i64.store offset=0x193 align=1 (i32.const 0) (local.get 0x193))
+    (i64.store offset=0x194 align=1 (i32.const 0) (local.get 0x194))
+    (i64.store offset=0x195 align=1 (i32.const 0) (local.get 0x195))
+    (i64.store offset=0x196 align=1 (i32.const 0) (local.get 0x196))
+    (i64.store offset=0x197 align=1 (i32.const 0) (local.get 0x197))
+    (i64.store offset=0x198 align=1 (i32.const 0) (local.get 0x198))
+    (i64.store offset=0x199 align=1 (i32.const 0) (local.get 0x199))
+    (i64.store offset=0x19a align=1 (i32.const 0) (local.get 0x19a))
+    (i64.store offset=0x19b align=1 (i32.const 0) (local.get 0x19b))
+    (i64.store offset=0x19c align=1 (i32.const 0) (local.get 0x19c))
+    (i64.store offset=0x19d align=1 (i32.const 0) (local.get 0x19d))
+    (i64.store offset=0x19e align=1 (i32.const 0) (local.get 0x19e))
+    (i64.store offset=0x19f align=1 (i32.const 0) (local.get 0x19f))
+    (i64.store offset=0x1a0 align=1 (i32.const 0) (local.get 0x1a0))
+    (i64.store offset=0x1a1 align=1 (i32.const 0) (local.get 0x1a1))
+    (i64.store offset=0x1a2 align=1 (i32.const 0) (local.get 0x1a2))
+    (i64.store offset=0x1a3 align=1 (i32.const 0) (local.get 0x1a3))
+    (i64.store offset=0x1a4 align=1 (i32.const 0) (local.get 0x1a4))
+    (i64.store offset=0x1a5 align=1 (i32.const 0) (local.get 0x1a5))
+    (i64.store offset=0x1a6 align=1 (i32.const 0) (local.get 0x1a6))
+    (i64.store offset=0x1a7 align=1 (i32.const 0) (local.get 0x1a7))
+    (i64.store offset=0x1a8 align=1 (i32.const 0) (local.get 0x1a8))
+    (i64.store offset=0x1a9 align=1 (i32.const 0) (local.get 0x1a9))
+    (i64.store offset=0x1aa align=1 (i32.const 0) (local.get 0x1aa))
+    (i64.store offset=0x1ab align=1 (i32.const 0) (local.get 0x1ab))
+    (i64.store offset=0x1ac align=1 (i32.const 0) (local.get 0x1ac))
+    (i64.store offset=0x1ad align=1 (i32.const 0) (local.get 0x1ad))
+    (i64.store offset=0x1ae align=1 (i32.const 0) (local.get 0x1ae))
+    (i64.store offset=0x1af align=1 (i32.const 0) (local.get 0x1af))
+    (i64.store offset=0x1b0 align=1 (i32.const 0) (local.get 0x1b0))
+    (i64.store offset=0x1b1 align=1 (i32.const 0) (local.get 0x1b1))
+    (i64.store offset=0x1b2 align=1 (i32.const 0) (local.get 0x1b2))
+    (i64.store offset=0x1b3 align=1 (i32.const 0) (local.get 0x1b3))
+    (i64.store offset=0x1b4 align=1 (i32.const 0) (local.get 0x1b4))
+    (i64.store offset=0x1b5 align=1 (i32.const 0) (local.get 0x1b5))
+    (i64.store offset=0x1b6 align=1 (i32.const 0) (local.get 0x1b6))
+    (i64.store offset=0x1b7 align=1 (i32.const 0) (local.get 0x1b7))
+    (i64.store offset=0x1b8 align=1 (i32.const 0) (local.get 0x1b8))
+    (i64.store offset=0x1b9 align=1 (i32.const 0) (local.get 0x1b9))
+    (i64.store offset=0x1ba align=1 (i32.const 0) (local.get 0x1ba))
+    (i64.store offset=0x1bb align=1 (i32.const 0) (local.get 0x1bb))
+    (i64.store offset=0x1bc align=1 (i32.const 0) (local.get 0x1bc))
+    (i64.store offset=0x1bd align=1 (i32.const 0) (local.get 0x1bd))
+    (i64.store offset=0x1be align=1 (i32.const 0) (local.get 0x1be))
+    (i64.store offset=0x1bf align=1 (i32.const 0) (local.get 0x1bf))
+    (i64.store offset=0x1c0 align=1 (i32.const 0) (local.get 0x1c0))
+    (i64.store offset=0x1c1 align=1 (i32.const 0) (local.get 0x1c1))
+    (i64.store offset=0x1c2 align=1 (i32.const 0) (local.get 0x1c2))
+    (i64.store offset=0x1c3 align=1 (i32.const 0) (local.get 0x1c3))
+    (i64.store offset=0x1c4 align=1 (i32.const 0) (local.get 0x1c4))
+    (i64.store offset=0x1c5 align=1 (i32.const 0) (local.get 0x1c5))
+    (i64.store offset=0x1c6 align=1 (i32.const 0) (local.get 0x1c6))
+    (i64.store offset=0x1c7 align=1 (i32.const 0) (local.get 0x1c7))
+    (i64.store offset=0x1c8 align=1 (i32.const 0) (local.get 0x1c8))
+    (i64.store offset=0x1c9 align=1 (i32.const 0) (local.get 0x1c9))
+    (i64.store offset=0x1ca align=1 (i32.const 0) (local.get 0x1ca))
+    (i64.store offset=0x1cb align=1 (i32.const 0) (local.get 0x1cb))
+    (i64.store offset=0x1cc align=1 (i32.const 0) (local.get 0x1cc))
+    (i64.store offset=0x1cd align=1 (i32.const 0) (local.get 0x1cd))
+    (i64.store offset=0x1ce align=1 (i32.const 0) (local.get 0x1ce))
+    (i64.store offset=0x1cf align=1 (i32.const 0) (local.get 0x1cf))
+    (i64.store offset=0x1d0 align=1 (i32.const 0) (local.get 0x1d0))
+    (i64.store offset=0x1d1 align=1 (i32.const 0) (local.get 0x1d1))
+    (i64.store offset=0x1d2 align=1 (i32.const 0) (local.get 0x1d2))
+    (i64.store offset=0x1d3 align=1 (i32.const 0) (local.get 0x1d3))
+    (i64.store offset=0x1d4 align=1 (i32.const 0) (local.get 0x1d4))
+    (i64.store offset=0x1d5 align=1 (i32.const 0) (local.get 0x1d5))
+    (i64.store offset=0x1d6 align=1 (i32.const 0) (local.get 0x1d6))
+    (i64.store offset=0x1d7 align=1 (i32.const 0) (local.get 0x1d7))
+    (i64.store offset=0x1d8 align=1 (i32.const 0) (local.get 0x1d8))
+    (i64.store offset=0x1d9 align=1 (i32.const 0) (local.get 0x1d9))
+    (i64.store offset=0x1da align=1 (i32.const 0) (local.get 0x1da))
+    (i64.store offset=0x1db align=1 (i32.const 0) (local.get 0x1db))
+    (i64.store offset=0x1dc align=1 (i32.const 0) (local.get 0x1dc))
+    (i64.store offset=0x1dd align=1 (i32.const 0) (local.get 0x1dd))
+    (i64.store offset=0x1de align=1 (i32.const 0) (local.get 0x1de))
+    (i64.store offset=0x1df align=1 (i32.const 0) (local.get 0x1df))
+    (i64.store offset=0x1e0 align=1 (i32.const 0) (local.get 0x1e0))
+    (i64.store offset=0x1e1 align=1 (i32.const 0) (local.get 0x1e1))
+    (i64.store offset=0x1e2 align=1 (i32.const 0) (local.get 0x1e2))
+    (i64.store offset=0x1e3 align=1 (i32.const 0) (local.get 0x1e3))
+    (i64.store offset=0x1e4 align=1 (i32.const 0) (local.get 0x1e4))
+    (i64.store offset=0x1e5 align=1 (i32.const 0) (local.get 0x1e5))
+    (i64.store offset=0x1e6 align=1 (i32.const 0) (local.get 0x1e6))
+    (i64.store offset=0x1e7 align=1 (i32.const 0) (local.get 0x1e7))
+    (i64.store offset=0x1e8 align=1 (i32.const 0) (local.get 0x1e8))
+    (i64.store offset=0x1e9 align=1 (i32.const 0) (local.get 0x1e9))
+    (i64.store offset=0x1ea align=1 (i32.const 0) (local.get 0x1ea))
+    (i64.store offset=0x1eb align=1 (i32.const 0) (local.get 0x1eb))
+    (i64.store offset=0x1ec align=1 (i32.const 0) (local.get 0x1ec))
+    (i64.store offset=0x1ed align=1 (i32.const 0) (local.get 0x1ed))
+    (i64.store offset=0x1ee align=1 (i32.const 0) (local.get 0x1ee))
+    (i64.store offset=0x1ef align=1 (i32.const 0) (local.get 0x1ef))
+    (i64.store offset=0x1f0 align=1 (i32.const 0) (local.get 0x1f0))
+    (i64.store offset=0x1f1 align=1 (i32.const 0) (local.get 0x1f1))
+    (i64.store offset=0x1f2 align=1 (i32.const 0) (local.get 0x1f2))
+    (i64.store offset=0x1f3 align=1 (i32.const 0) (local.get 0x1f3))
+    (i64.store offset=0x1f4 align=1 (i32.const 0) (local.get 0x1f4))
+    (i64.store offset=0x1f5 align=1 (i32.const 0) (local.get 0x1f5))
+    (i64.store offset=0x1f6 align=1 (i32.const 0) (local.get 0x1f6))
+    (i64.store offset=0x1f7 align=1 (i32.const 0) (local.get 0x1f7))
+    (i64.store offset=0x1f8 align=1 (i32.const 0) (local.get 0x1f8))
+    (i64.store offset=0x1f9 align=1 (i32.const 0) (local.get 0x1f9))
+    (i64.store offset=0x1fa align=1 (i32.const 0) (local.get 0x1fa))
+    (i64.store offset=0x1fb align=1 (i32.const 0) (local.get 0x1fb))
+    (i64.store offset=0x1fc align=1 (i32.const 0) (local.get 0x1fc))
+    (i64.store offset=0x1fd align=1 (i32.const 0) (local.get 0x1fd))
+    (i64.store offset=0x1fe align=1 (i32.const 0) (local.get 0x1fe))
+    (i64.store offset=0x1ff align=1 (i32.const 0) (local.get 0x1ff))
+    (i64.store offset=0x200 align=1 (i32.const 0) (local.get 0x200))
+    (i64.store offset=0x201 align=1 (i32.const 0) (local.get 0x201))
+    (i64.store offset=0x202 align=1 (i32.const 0) (local.get 0x202))
+    (i64.store offset=0x203 align=1 (i32.const 0) (local.get 0x203))
+    (i64.store offset=0x204 align=1 (i32.const 0) (local.get 0x204))
+    (i64.store offset=0x205 align=1 (i32.const 0) (local.get 0x205))
+    (i64.store offset=0x206 align=1 (i32.const 0) (local.get 0x206))
+    (i64.store offset=0x207 align=1 (i32.const 0) (local.get 0x207))
+    (i64.store offset=0x208 align=1 (i32.const 0) (local.get 0x208))
+    (i64.store offset=0x209 align=1 (i32.const 0) (local.get 0x209))
+    (i64.store offset=0x20a align=1 (i32.const 0) (local.get 0x20a))
+    (i64.store offset=0x20b align=1 (i32.const 0) (local.get 0x20b))
+    (i64.store offset=0x20c align=1 (i32.const 0) (local.get 0x20c))
+    (i64.store offset=0x20d align=1 (i32.const 0) (local.get 0x20d))
+    (i64.store offset=0x20e align=1 (i32.const 0) (local.get 0x20e))
+    (i64.store offset=0x20f align=1 (i32.const 0) (local.get 0x20f))
+    (i64.store offset=0x210 align=1 (i32.const 0) (local.get 0x210))
+    (i64.store offset=0x211 align=1 (i32.const 0) (local.get 0x211))
+    (i64.store offset=0x212 align=1 (i32.const 0) (local.get 0x212))
+    (i64.store offset=0x213 align=1 (i32.const 0) (local.get 0x213))
+    (i64.store offset=0x214 align=1 (i32.const 0) (local.get 0x214))
+    (i64.store offset=0x215 align=1 (i32.const 0) (local.get 0x215))
+    (i64.store offset=0x216 align=1 (i32.const 0) (local.get 0x216))
+    (i64.store offset=0x217 align=1 (i32.const 0) (local.get 0x217))
+    (i64.store offset=0x218 align=1 (i32.const 0) (local.get 0x218))
+    (i64.store offset=0x219 align=1 (i32.const 0) (local.get 0x219))
+    (i64.store offset=0x21a align=1 (i32.const 0) (local.get 0x21a))
+    (i64.store offset=0x21b align=1 (i32.const 0) (local.get 0x21b))
+    (i64.store offset=0x21c align=1 (i32.const 0) (local.get 0x21c))
+    (i64.store offset=0x21d align=1 (i32.const 0) (local.get 0x21d))
+    (i64.store offset=0x21e align=1 (i32.const 0) (local.get 0x21e))
+    (i64.store offset=0x21f align=1 (i32.const 0) (local.get 0x21f))
+    (i64.store offset=0x220 align=1 (i32.const 0) (local.get 0x220))
+    (i64.store offset=0x221 align=1 (i32.const 0) (local.get 0x221))
+    (i64.store offset=0x222 align=1 (i32.const 0) (local.get 0x222))
+    (i64.store offset=0x223 align=1 (i32.const 0) (local.get 0x223))
+    (i64.store offset=0x224 align=1 (i32.const 0) (local.get 0x224))
+    (i64.store offset=0x225 align=1 (i32.const 0) (local.get 0x225))
+    (i64.store offset=0x226 align=1 (i32.const 0) (local.get 0x226))
+    (i64.store offset=0x227 align=1 (i32.const 0) (local.get 0x227))
+    (i64.store offset=0x228 align=1 (i32.const 0) (local.get 0x228))
+    (i64.store offset=0x229 align=1 (i32.const 0) (local.get 0x229))
+    (i64.store offset=0x22a align=1 (i32.const 0) (local.get 0x22a))
+    (i64.store offset=0x22b align=1 (i32.const 0) (local.get 0x22b))
+    (i64.store offset=0x22c align=1 (i32.const 0) (local.get 0x22c))
+    (i64.store offset=0x22d align=1 (i32.const 0) (local.get 0x22d))
+    (i64.store offset=0x22e align=1 (i32.const 0) (local.get 0x22e))
+    (i64.store offset=0x22f align=1 (i32.const 0) (local.get 0x22f))
+    (i64.store offset=0x230 align=1 (i32.const 0) (local.get 0x230))
+    (i64.store offset=0x231 align=1 (i32.const 0) (local.get 0x231))
+    (i64.store offset=0x232 align=1 (i32.const 0) (local.get 0x232))
+    (i64.store offset=0x233 align=1 (i32.const 0) (local.get 0x233))
+    (i64.store offset=0x234 align=1 (i32.const 0) (local.get 0x234))
+    (i64.store offset=0x235 align=1 (i32.const 0) (local.get 0x235))
+    (i64.store offset=0x236 align=1 (i32.const 0) (local.get 0x236))
+    (i64.store offset=0x237 align=1 (i32.const 0) (local.get 0x237))
+    (i64.store offset=0x238 align=1 (i32.const 0) (local.get 0x238))
+    (i64.store offset=0x239 align=1 (i32.const 0) (local.get 0x239))
+    (i64.store offset=0x23a align=1 (i32.const 0) (local.get 0x23a))
+    (i64.store offset=0x23b align=1 (i32.const 0) (local.get 0x23b))
+    (i64.store offset=0x23c align=1 (i32.const 0) (local.get 0x23c))
+    (i64.store offset=0x23d align=1 (i32.const 0) (local.get 0x23d))
+    (i64.store offset=0x23e align=1 (i32.const 0) (local.get 0x23e))
+    (i64.store offset=0x23f align=1 (i32.const 0) (local.get 0x23f))
+    (i64.store offset=0x240 align=1 (i32.const 0) (local.get 0x240))
+    (i64.store offset=0x241 align=1 (i32.const 0) (local.get 0x241))
+    (i64.store offset=0x242 align=1 (i32.const 0) (local.get 0x242))
+    (i64.store offset=0x243 align=1 (i32.const 0) (local.get 0x243))
+    (i64.store offset=0x244 align=1 (i32.const 0) (local.get 0x244))
+    (i64.store offset=0x245 align=1 (i32.const 0) (local.get 0x245))
+    (i64.store offset=0x246 align=1 (i32.const 0) (local.get 0x246))
+    (i64.store offset=0x247 align=1 (i32.const 0) (local.get 0x247))
+    (i64.store offset=0x248 align=1 (i32.const 0) (local.get 0x248))
+    (i64.store offset=0x249 align=1 (i32.const 0) (local.get 0x249))
+    (i64.store offset=0x24a align=1 (i32.const 0) (local.get 0x24a))
+    (i64.store offset=0x24b align=1 (i32.const 0) (local.get 0x24b))
+    (i64.store offset=0x24c align=1 (i32.const 0) (local.get 0x24c))
+    (i64.store offset=0x24d align=1 (i32.const 0) (local.get 0x24d))
+    (i64.store offset=0x24e align=1 (i32.const 0) (local.get 0x24e))
+    (i64.store offset=0x24f align=1 (i32.const 0) (local.get 0x24f))
+    (i64.store offset=0x250 align=1 (i32.const 0) (local.get 0x250))
+    (i64.store offset=0x251 align=1 (i32.const 0) (local.get 0x251))
+    (i64.store offset=0x252 align=1 (i32.const 0) (local.get 0x252))
+    (i64.store offset=0x253 align=1 (i32.const 0) (local.get 0x253))
+    (i64.store offset=0x254 align=1 (i32.const 0) (local.get 0x254))
+    (i64.store offset=0x255 align=1 (i32.const 0) (local.get 0x255))
+    (i64.store offset=0x256 align=1 (i32.const 0) (local.get 0x256))
+    (i64.store offset=0x257 align=1 (i32.const 0) (local.get 0x257))
+    (i64.store offset=0x258 align=1 (i32.const 0) (local.get 0x258))
+    (i64.store offset=0x259 align=1 (i32.const 0) (local.get 0x259))
+    (i64.store offset=0x25a align=1 (i32.const 0) (local.get 0x25a))
+    (i64.store offset=0x25b align=1 (i32.const 0) (local.get 0x25b))
+    (i64.store offset=0x25c align=1 (i32.const 0) (local.get 0x25c))
+    (i64.store offset=0x25d align=1 (i32.const 0) (local.get 0x25d))
+    (i64.store offset=0x25e align=1 (i32.const 0) (local.get 0x25e))
+    (i64.store offset=0x25f align=1 (i32.const 0) (local.get 0x25f))
+    (i64.store offset=0x260 align=1 (i32.const 0) (local.get 0x260))
+    (i64.store offset=0x261 align=1 (i32.const 0) (local.get 0x261))
+    (i64.store offset=0x262 align=1 (i32.const 0) (local.get 0x262))
+    (i64.store offset=0x263 align=1 (i32.const 0) (local.get 0x263))
+    (i64.store offset=0x264 align=1 (i32.const 0) (local.get 0x264))
+    (i64.store offset=0x265 align=1 (i32.const 0) (local.get 0x265))
+    (i64.store offset=0x266 align=1 (i32.const 0) (local.get 0x266))
+    (i64.store offset=0x267 align=1 (i32.const 0) (local.get 0x267))
+    (i64.store offset=0x268 align=1 (i32.const 0) (local.get 0x268))
+    (i64.store offset=0x269 align=1 (i32.const 0) (local.get 0x269))
+    (i64.store offset=0x26a align=1 (i32.const 0) (local.get 0x26a))
+    (i64.store offset=0x26b align=1 (i32.const 0) (local.get 0x26b))
+    (i64.store offset=0x26c align=1 (i32.const 0) (local.get 0x26c))
+    (i64.store offset=0x26d align=1 (i32.const 0) (local.get 0x26d))
+    (i64.store offset=0x26e align=1 (i32.const 0) (local.get 0x26e))
+    (i64.store offset=0x26f align=1 (i32.const 0) (local.get 0x26f))
+    (i64.store offset=0x270 align=1 (i32.const 0) (local.get 0x270))
+    (i64.store offset=0x271 align=1 (i32.const 0) (local.get 0x271))
+    (i64.store offset=0x272 align=1 (i32.const 0) (local.get 0x272))
+    (i64.store offset=0x273 align=1 (i32.const 0) (local.get 0x273))
+    (i64.store offset=0x274 align=1 (i32.const 0) (local.get 0x274))
+    (i64.store offset=0x275 align=1 (i32.const 0) (local.get 0x275))
+    (i64.store offset=0x276 align=1 (i32.const 0) (local.get 0x276))
+    (i64.store offset=0x277 align=1 (i32.const 0) (local.get 0x277))
+    (i64.store offset=0x278 align=1 (i32.const 0) (local.get 0x278))
+    (i64.store offset=0x279 align=1 (i32.const 0) (local.get 0x279))
+    (i64.store offset=0x27a align=1 (i32.const 0) (local.get 0x27a))
+    (i64.store offset=0x27b align=1 (i32.const 0) (local.get 0x27b))
+    (i64.store offset=0x27c align=1 (i32.const 0) (local.get 0x27c))
+    (i64.store offset=0x27d align=1 (i32.const 0) (local.get 0x27d))
+    (i64.store offset=0x27e align=1 (i32.const 0) (local.get 0x27e))
+    (i64.store offset=0x27f align=1 (i32.const 0) (local.get 0x27f))
+    (i64.store offset=0x280 align=1 (i32.const 0) (local.get 0x280))
+    (i64.store offset=0x281 align=1 (i32.const 0) (local.get 0x281))
+    (i64.store offset=0x282 align=1 (i32.const 0) (local.get 0x282))
+    (i64.store offset=0x283 align=1 (i32.const 0) (local.get 0x283))
+    (i64.store offset=0x284 align=1 (i32.const 0) (local.get 0x284))
+    (i64.store offset=0x285 align=1 (i32.const 0) (local.get 0x285))
+    (i64.store offset=0x286 align=1 (i32.const 0) (local.get 0x286))
+    (i64.store offset=0x287 align=1 (i32.const 0) (local.get 0x287))
+    (i64.store offset=0x288 align=1 (i32.const 0) (local.get 0x288))
+    (i64.store offset=0x289 align=1 (i32.const 0) (local.get 0x289))
+    (i64.store offset=0x28a align=1 (i32.const 0) (local.get 0x28a))
+    (i64.store offset=0x28b align=1 (i32.const 0) (local.get 0x28b))
+    (i64.store offset=0x28c align=1 (i32.const 0) (local.get 0x28c))
+    (i64.store offset=0x28d align=1 (i32.const 0) (local.get 0x28d))
+    (i64.store offset=0x28e align=1 (i32.const 0) (local.get 0x28e))
+    (i64.store offset=0x28f align=1 (i32.const 0) (local.get 0x28f))
+    (i64.store offset=0x290 align=1 (i32.const 0) (local.get 0x290))
+    (i64.store offset=0x291 align=1 (i32.const 0) (local.get 0x291))
+    (i64.store offset=0x292 align=1 (i32.const 0) (local.get 0x292))
+    (i64.store offset=0x293 align=1 (i32.const 0) (local.get 0x293))
+    (i64.store offset=0x294 align=1 (i32.const 0) (local.get 0x294))
+    (i64.store offset=0x295 align=1 (i32.const 0) (local.get 0x295))
+    (i64.store offset=0x296 align=1 (i32.const 0) (local.get 0x296))
+    (i64.store offset=0x297 align=1 (i32.const 0) (local.get 0x297))
+    (i64.store offset=0x298 align=1 (i32.const 0) (local.get 0x298))
+    (i64.store offset=0x299 align=1 (i32.const 0) (local.get 0x299))
+    (i64.store offset=0x29a align=1 (i32.const 0) (local.get 0x29a))
+    (i64.store offset=0x29b align=1 (i32.const 0) (local.get 0x29b))
+    (i64.store offset=0x29c align=1 (i32.const 0) (local.get 0x29c))
+    (i64.store offset=0x29d align=1 (i32.const 0) (local.get 0x29d))
+    (i64.store offset=0x29e align=1 (i32.const 0) (local.get 0x29e))
+    (i64.store offset=0x29f align=1 (i32.const 0) (local.get 0x29f))
+    (i64.store offset=0x2a0 align=1 (i32.const 0) (local.get 0x2a0))
+    (i64.store offset=0x2a1 align=1 (i32.const 0) (local.get 0x2a1))
+    (i64.store offset=0x2a2 align=1 (i32.const 0) (local.get 0x2a2))
+    (i64.store offset=0x2a3 align=1 (i32.const 0) (local.get 0x2a3))
+    (i64.store offset=0x2a4 align=1 (i32.const 0) (local.get 0x2a4))
+    (i64.store offset=0x2a5 align=1 (i32.const 0) (local.get 0x2a5))
+    (i64.store offset=0x2a6 align=1 (i32.const 0) (local.get 0x2a6))
+    (i64.store offset=0x2a7 align=1 (i32.const 0) (local.get 0x2a7))
+    (i64.store offset=0x2a8 align=1 (i32.const 0) (local.get 0x2a8))
+    (i64.store offset=0x2a9 align=1 (i32.const 0) (local.get 0x2a9))
+    (i64.store offset=0x2aa align=1 (i32.const 0) (local.get 0x2aa))
+    (i64.store offset=0x2ab align=1 (i32.const 0) (local.get 0x2ab))
+    (i64.store offset=0x2ac align=1 (i32.const 0) (local.get 0x2ac))
+    (i64.store offset=0x2ad align=1 (i32.const 0) (local.get 0x2ad))
+    (i64.store offset=0x2ae align=1 (i32.const 0) (local.get 0x2ae))
+    (i64.store offset=0x2af align=1 (i32.const 0) (local.get 0x2af))
+    (i64.store offset=0x2b0 align=1 (i32.const 0) (local.get 0x2b0))
+    (i64.store offset=0x2b1 align=1 (i32.const 0) (local.get 0x2b1))
+    (i64.store offset=0x2b2 align=1 (i32.const 0) (local.get 0x2b2))
+    (i64.store offset=0x2b3 align=1 (i32.const 0) (local.get 0x2b3))
+    (i64.store offset=0x2b4 align=1 (i32.const 0) (local.get 0x2b4))
+    (i64.store offset=0x2b5 align=1 (i32.const 0) (local.get 0x2b5))
+    (i64.store offset=0x2b6 align=1 (i32.const 0) (local.get 0x2b6))
+    (i64.store offset=0x2b7 align=1 (i32.const 0) (local.get 0x2b7))
+    (i64.store offset=0x2b8 align=1 (i32.const 0) (local.get 0x2b8))
+    (i64.store offset=0x2b9 align=1 (i32.const 0) (local.get 0x2b9))
+    (i64.store offset=0x2ba align=1 (i32.const 0) (local.get 0x2ba))
+    (i64.store offset=0x2bb align=1 (i32.const 0) (local.get 0x2bb))
+    (i64.store offset=0x2bc align=1 (i32.const 0) (local.get 0x2bc))
+    (i64.store offset=0x2bd align=1 (i32.const 0) (local.get 0x2bd))
+    (i64.store offset=0x2be align=1 (i32.const 0) (local.get 0x2be))
+    (i64.store offset=0x2bf align=1 (i32.const 0) (local.get 0x2bf))
+    (i64.store offset=0x2c0 align=1 (i32.const 0) (local.get 0x2c0))
+    (i64.store offset=0x2c1 align=1 (i32.const 0) (local.get 0x2c1))
+    (i64.store offset=0x2c2 align=1 (i32.const 0) (local.get 0x2c2))
+    (i64.store offset=0x2c3 align=1 (i32.const 0) (local.get 0x2c3))
+    (i64.store offset=0x2c4 align=1 (i32.const 0) (local.get 0x2c4))
+    (i64.store offset=0x2c5 align=1 (i32.const 0) (local.get 0x2c5))
+    (i64.store offset=0x2c6 align=1 (i32.const 0) (local.get 0x2c6))
+    (i64.store offset=0x2c7 align=1 (i32.const 0) (local.get 0x2c7))
+    (i64.store offset=0x2c8 align=1 (i32.const 0) (local.get 0x2c8))
+    (i64.store offset=0x2c9 align=1 (i32.const 0) (local.get 0x2c9))
+    (i64.store offset=0x2ca align=1 (i32.const 0) (local.get 0x2ca))
+    (i64.store offset=0x2cb align=1 (i32.const 0) (local.get 0x2cb))
+    (i64.store offset=0x2cc align=1 (i32.const 0) (local.get 0x2cc))
+    (i64.store offset=0x2cd align=1 (i32.const 0) (local.get 0x2cd))
+    (i64.store offset=0x2ce align=1 (i32.const 0) (local.get 0x2ce))
+    (i64.store offset=0x2cf align=1 (i32.const 0) (local.get 0x2cf))
+    (i64.store offset=0x2d0 align=1 (i32.const 0) (local.get 0x2d0))
+    (i64.store offset=0x2d1 align=1 (i32.const 0) (local.get 0x2d1))
+    (i64.store offset=0x2d2 align=1 (i32.const 0) (local.get 0x2d2))
+    (i64.store offset=0x2d3 align=1 (i32.const 0) (local.get 0x2d3))
+    (i64.store offset=0x2d4 align=1 (i32.const 0) (local.get 0x2d4))
+    (i64.store offset=0x2d5 align=1 (i32.const 0) (local.get 0x2d5))
+    (i64.store offset=0x2d6 align=1 (i32.const 0) (local.get 0x2d6))
+    (i64.store offset=0x2d7 align=1 (i32.const 0) (local.get 0x2d7))
+    (i64.store offset=0x2d8 align=1 (i32.const 0) (local.get 0x2d8))
+    (i64.store offset=0x2d9 align=1 (i32.const 0) (local.get 0x2d9))
+    (i64.store offset=0x2da align=1 (i32.const 0) (local.get 0x2da))
+    (i64.store offset=0x2db align=1 (i32.const 0) (local.get 0x2db))
+    (i64.store offset=0x2dc align=1 (i32.const 0) (local.get 0x2dc))
+    (i64.store offset=0x2dd align=1 (i32.const 0) (local.get 0x2dd))
+    (i64.store offset=0x2de align=1 (i32.const 0) (local.get 0x2de))
+    (i64.store offset=0x2df align=1 (i32.const 0) (local.get 0x2df))
+    (i64.store offset=0x2e0 align=1 (i32.const 0) (local.get 0x2e0))
+    (i64.store offset=0x2e1 align=1 (i32.const 0) (local.get 0x2e1))
+    (i64.store offset=0x2e2 align=1 (i32.const 0) (local.get 0x2e2))
+    (i64.store offset=0x2e3 align=1 (i32.const 0) (local.get 0x2e3))
+    (i64.store offset=0x2e4 align=1 (i32.const 0) (local.get 0x2e4))
+    (i64.store offset=0x2e5 align=1 (i32.const 0) (local.get 0x2e5))
+    (i64.store offset=0x2e6 align=1 (i32.const 0) (local.get 0x2e6))
+    (i64.store offset=0x2e7 align=1 (i32.const 0) (local.get 0x2e7))
+    (i64.store offset=0x2e8 align=1 (i32.const 0) (local.get 0x2e8))
+    (i64.store offset=0x2e9 align=1 (i32.const 0) (local.get 0x2e9))
+    (i64.store offset=0x2ea align=1 (i32.const 0) (local.get 0x2ea))
+    (i64.store offset=0x2eb align=1 (i32.const 0) (local.get 0x2eb))
+    (i64.store offset=0x2ec align=1 (i32.const 0) (local.get 0x2ec))
+    (i64.store offset=0x2ed align=1 (i32.const 0) (local.get 0x2ed))
+    (i64.store offset=0x2ee align=1 (i32.const 0) (local.get 0x2ee))
+    (i64.store offset=0x2ef align=1 (i32.const 0) (local.get 0x2ef))
+    (i64.store offset=0x2f0 align=1 (i32.const 0) (local.get 0x2f0))
+    (i64.store offset=0x2f1 align=1 (i32.const 0) (local.get 0x2f1))
+    (i64.store offset=0x2f2 align=1 (i32.const 0) (local.get 0x2f2))
+    (i64.store offset=0x2f3 align=1 (i32.const 0) (local.get 0x2f3))
+    (i64.store offset=0x2f4 align=1 (i32.const 0) (local.get 0x2f4))
+    (i64.store offset=0x2f5 align=1 (i32.const 0) (local.get 0x2f5))
+    (i64.store offset=0x2f6 align=1 (i32.const 0) (local.get 0x2f6))
+    (i64.store offset=0x2f7 align=1 (i32.const 0) (local.get 0x2f7))
+    (i64.store offset=0x2f8 align=1 (i32.const 0) (local.get 0x2f8))
+    (i64.store offset=0x2f9 align=1 (i32.const 0) (local.get 0x2f9))
+    (i64.store offset=0x2fa align=1 (i32.const 0) (local.get 0x2fa))
+    (i64.store offset=0x2fb align=1 (i32.const 0) (local.get 0x2fb))
+    (i64.store offset=0x2fc align=1 (i32.const 0) (local.get 0x2fc))
+    (i64.store offset=0x2fd align=1 (i32.const 0) (local.get 0x2fd))
+    (i64.store offset=0x2fe align=1 (i32.const 0) (local.get 0x2fe))
+    (i64.store offset=0x2ff align=1 (i32.const 0) (local.get 0x2ff))
+    (i64.store offset=0x300 align=1 (i32.const 0) (local.get 0x300))
+    (i64.store offset=0x301 align=1 (i32.const 0) (local.get 0x301))
+    (i64.store offset=0x302 align=1 (i32.const 0) (local.get 0x302))
+    (i64.store offset=0x303 align=1 (i32.const 0) (local.get 0x303))
+    (i64.store offset=0x304 align=1 (i32.const 0) (local.get 0x304))
+    (i64.store offset=0x305 align=1 (i32.const 0) (local.get 0x305))
+    (i64.store offset=0x306 align=1 (i32.const 0) (local.get 0x306))
+    (i64.store offset=0x307 align=1 (i32.const 0) (local.get 0x307))
+    (i64.store offset=0x308 align=1 (i32.const 0) (local.get 0x308))
+    (i64.store offset=0x309 align=1 (i32.const 0) (local.get 0x309))
+    (i64.store offset=0x30a align=1 (i32.const 0) (local.get 0x30a))
+    (i64.store offset=0x30b align=1 (i32.const 0) (local.get 0x30b))
+    (i64.store offset=0x30c align=1 (i32.const 0) (local.get 0x30c))
+    (i64.store offset=0x30d align=1 (i32.const 0) (local.get 0x30d))
+    (i64.store offset=0x30e align=1 (i32.const 0) (local.get 0x30e))
+    (i64.store offset=0x30f align=1 (i32.const 0) (local.get 0x30f))
+    (i64.store offset=0x310 align=1 (i32.const 0) (local.get 0x310))
+    (i64.store offset=0x311 align=1 (i32.const 0) (local.get 0x311))
+    (i64.store offset=0x312 align=1 (i32.const 0) (local.get 0x312))
+    (i64.store offset=0x313 align=1 (i32.const 0) (local.get 0x313))
+    (i64.store offset=0x314 align=1 (i32.const 0) (local.get 0x314))
+    (i64.store offset=0x315 align=1 (i32.const 0) (local.get 0x315))
+    (i64.store offset=0x316 align=1 (i32.const 0) (local.get 0x316))
+    (i64.store offset=0x317 align=1 (i32.const 0) (local.get 0x317))
+    (i64.store offset=0x318 align=1 (i32.const 0) (local.get 0x318))
+    (i64.store offset=0x319 align=1 (i32.const 0) (local.get 0x319))
+    (i64.store offset=0x31a align=1 (i32.const 0) (local.get 0x31a))
+    (i64.store offset=0x31b align=1 (i32.const 0) (local.get 0x31b))
+    (i64.store offset=0x31c align=1 (i32.const 0) (local.get 0x31c))
+    (i64.store offset=0x31d align=1 (i32.const 0) (local.get 0x31d))
+    (i64.store offset=0x31e align=1 (i32.const 0) (local.get 0x31e))
+    (i64.store offset=0x31f align=1 (i32.const 0) (local.get 0x31f))
+    (i64.store offset=0x320 align=1 (i32.const 0) (local.get 0x320))
+    (i64.store offset=0x321 align=1 (i32.const 0) (local.get 0x321))
+    (i64.store offset=0x322 align=1 (i32.const 0) (local.get 0x322))
+    (i64.store offset=0x323 align=1 (i32.const 0) (local.get 0x323))
+    (i64.store offset=0x324 align=1 (i32.const 0) (local.get 0x324))
+    (i64.store offset=0x325 align=1 (i32.const 0) (local.get 0x325))
+    (i64.store offset=0x326 align=1 (i32.const 0) (local.get 0x326))
+    (i64.store offset=0x327 align=1 (i32.const 0) (local.get 0x327))
+    (i64.store offset=0x328 align=1 (i32.const 0) (local.get 0x328))
+    (i64.store offset=0x329 align=1 (i32.const 0) (local.get 0x329))
+    (i64.store offset=0x32a align=1 (i32.const 0) (local.get 0x32a))
+    (i64.store offset=0x32b align=1 (i32.const 0) (local.get 0x32b))
+    (i64.store offset=0x32c align=1 (i32.const 0) (local.get 0x32c))
+    (i64.store offset=0x32d align=1 (i32.const 0) (local.get 0x32d))
+    (i64.store offset=0x32e align=1 (i32.const 0) (local.get 0x32e))
+    (i64.store offset=0x32f align=1 (i32.const 0) (local.get 0x32f))
+    (i64.store offset=0x330 align=1 (i32.const 0) (local.get 0x330))
+    (i64.store offset=0x331 align=1 (i32.const 0) (local.get 0x331))
+    (i64.store offset=0x332 align=1 (i32.const 0) (local.get 0x332))
+    (i64.store offset=0x333 align=1 (i32.const 0) (local.get 0x333))
+    (i64.store offset=0x334 align=1 (i32.const 0) (local.get 0x334))
+    (i64.store offset=0x335 align=1 (i32.const 0) (local.get 0x335))
+    (i64.store offset=0x336 align=1 (i32.const 0) (local.get 0x336))
+    (i64.store offset=0x337 align=1 (i32.const 0) (local.get 0x337))
+    (i64.store offset=0x338 align=1 (i32.const 0) (local.get 0x338))
+    (i64.store offset=0x339 align=1 (i32.const 0) (local.get 0x339))
+    (i64.store offset=0x33a align=1 (i32.const 0) (local.get 0x33a))
+    (i64.store offset=0x33b align=1 (i32.const 0) (local.get 0x33b))
+    (i64.store offset=0x33c align=1 (i32.const 0) (local.get 0x33c))
+    (i64.store offset=0x33d align=1 (i32.const 0) (local.get 0x33d))
+    (i64.store offset=0x33e align=1 (i32.const 0) (local.get 0x33e))
+    (i64.store offset=0x33f align=1 (i32.const 0) (local.get 0x33f))
+    (i64.store offset=0x340 align=1 (i32.const 0) (local.get 0x340))
+    (i64.store offset=0x341 align=1 (i32.const 0) (local.get 0x341))
+    (i64.store offset=0x342 align=1 (i32.const 0) (local.get 0x342))
+    (i64.store offset=0x343 align=1 (i32.const 0) (local.get 0x343))
+    (i64.store offset=0x344 align=1 (i32.const 0) (local.get 0x344))
+    (i64.store offset=0x345 align=1 (i32.const 0) (local.get 0x345))
+    (i64.store offset=0x346 align=1 (i32.const 0) (local.get 0x346))
+    (i64.store offset=0x347 align=1 (i32.const 0) (local.get 0x347))
+    (i64.store offset=0x348 align=1 (i32.const 0) (local.get 0x348))
+    (i64.store offset=0x349 align=1 (i32.const 0) (local.get 0x349))
+    (i64.store offset=0x34a align=1 (i32.const 0) (local.get 0x34a))
+    (i64.store offset=0x34b align=1 (i32.const 0) (local.get 0x34b))
+    (i64.store offset=0x34c align=1 (i32.const 0) (local.get 0x34c))
+    (i64.store offset=0x34d align=1 (i32.const 0) (local.get 0x34d))
+    (i64.store offset=0x34e align=1 (i32.const 0) (local.get 0x34e))
+    (i64.store offset=0x34f align=1 (i32.const 0) (local.get 0x34f))
+    (i64.store offset=0x350 align=1 (i32.const 0) (local.get 0x350))
+    (i64.store offset=0x351 align=1 (i32.const 0) (local.get 0x351))
+    (i64.store offset=0x352 align=1 (i32.const 0) (local.get 0x352))
+    (i64.store offset=0x353 align=1 (i32.const 0) (local.get 0x353))
+    (i64.store offset=0x354 align=1 (i32.const 0) (local.get 0x354))
+    (i64.store offset=0x355 align=1 (i32.const 0) (local.get 0x355))
+    (i64.store offset=0x356 align=1 (i32.const 0) (local.get 0x356))
+    (i64.store offset=0x357 align=1 (i32.const 0) (local.get 0x357))
+    (i64.store offset=0x358 align=1 (i32.const 0) (local.get 0x358))
+    (i64.store offset=0x359 align=1 (i32.const 0) (local.get 0x359))
+    (i64.store offset=0x35a align=1 (i32.const 0) (local.get 0x35a))
+    (i64.store offset=0x35b align=1 (i32.const 0) (local.get 0x35b))
+    (i64.store offset=0x35c align=1 (i32.const 0) (local.get 0x35c))
+    (i64.store offset=0x35d align=1 (i32.const 0) (local.get 0x35d))
+    (i64.store offset=0x35e align=1 (i32.const 0) (local.get 0x35e))
+    (i64.store offset=0x35f align=1 (i32.const 0) (local.get 0x35f))
+    (i64.store offset=0x360 align=1 (i32.const 0) (local.get 0x360))
+    (i64.store offset=0x361 align=1 (i32.const 0) (local.get 0x361))
+    (i64.store offset=0x362 align=1 (i32.const 0) (local.get 0x362))
+    (i64.store offset=0x363 align=1 (i32.const 0) (local.get 0x363))
+    (i64.store offset=0x364 align=1 (i32.const 0) (local.get 0x364))
+    (i64.store offset=0x365 align=1 (i32.const 0) (local.get 0x365))
+    (i64.store offset=0x366 align=1 (i32.const 0) (local.get 0x366))
+    (i64.store offset=0x367 align=1 (i32.const 0) (local.get 0x367))
+    (i64.store offset=0x368 align=1 (i32.const 0) (local.get 0x368))
+    (i64.store offset=0x369 align=1 (i32.const 0) (local.get 0x369))
+    (i64.store offset=0x36a align=1 (i32.const 0) (local.get 0x36a))
+    (i64.store offset=0x36b align=1 (i32.const 0) (local.get 0x36b))
+    (i64.store offset=0x36c align=1 (i32.const 0) (local.get 0x36c))
+    (i64.store offset=0x36d align=1 (i32.const 0) (local.get 0x36d))
+    (i64.store offset=0x36e align=1 (i32.const 0) (local.get 0x36e))
+    (i64.store offset=0x36f align=1 (i32.const 0) (local.get 0x36f))
+    (i64.store offset=0x370 align=1 (i32.const 0) (local.get 0x370))
+    (i64.store offset=0x371 align=1 (i32.const 0) (local.get 0x371))
+    (i64.store offset=0x372 align=1 (i32.const 0) (local.get 0x372))
+    (i64.store offset=0x373 align=1 (i32.const 0) (local.get 0x373))
+    (i64.store offset=0x374 align=1 (i32.const 0) (local.get 0x374))
+    (i64.store offset=0x375 align=1 (i32.const 0) (local.get 0x375))
+    (i64.store offset=0x376 align=1 (i32.const 0) (local.get 0x376))
+    (i64.store offset=0x377 align=1 (i32.const 0) (local.get 0x377))
+    (i64.store offset=0x378 align=1 (i32.const 0) (local.get 0x378))
+    (i64.store offset=0x379 align=1 (i32.const 0) (local.get 0x379))
+    (i64.store offset=0x37a align=1 (i32.const 0) (local.get 0x37a))
+    (i64.store offset=0x37b align=1 (i32.const 0) (local.get 0x37b))
+    (i64.store offset=0x37c align=1 (i32.const 0) (local.get 0x37c))
+    (i64.store offset=0x37d align=1 (i32.const 0) (local.get 0x37d))
+    (i64.store offset=0x37e align=1 (i32.const 0) (local.get 0x37e))
+    (i64.store offset=0x37f align=1 (i32.const 0) (local.get 0x37f))
+    (i64.store offset=0x380 align=1 (i32.const 0) (local.get 0x380))
+    (i64.store offset=0x381 align=1 (i32.const 0) (local.get 0x381))
+    (i64.store offset=0x382 align=1 (i32.const 0) (local.get 0x382))
+    (i64.store offset=0x383 align=1 (i32.const 0) (local.get 0x383))
+    (i64.store offset=0x384 align=1 (i32.const 0) (local.get 0x384))
+    (i64.store offset=0x385 align=1 (i32.const 0) (local.get 0x385))
+    (i64.store offset=0x386 align=1 (i32.const 0) (local.get 0x386))
+    (i64.store offset=0x387 align=1 (i32.const 0) (local.get 0x387))
+    (i64.store offset=0x388 align=1 (i32.const 0) (local.get 0x388))
+    (i64.store offset=0x389 align=1 (i32.const 0) (local.get 0x389))
+    (i64.store offset=0x38a align=1 (i32.const 0) (local.get 0x38a))
+    (i64.store offset=0x38b align=1 (i32.const 0) (local.get 0x38b))
+    (i64.store offset=0x38c align=1 (i32.const 0) (local.get 0x38c))
+    (i64.store offset=0x38d align=1 (i32.const 0) (local.get 0x38d))
+    (i64.store offset=0x38e align=1 (i32.const 0) (local.get 0x38e))
+    (i64.store offset=0x38f align=1 (i32.const 0) (local.get 0x38f))
+    (i64.store offset=0x390 align=1 (i32.const 0) (local.get 0x390))
+    (i64.store offset=0x391 align=1 (i32.const 0) (local.get 0x391))
+    (i64.store offset=0x392 align=1 (i32.const 0) (local.get 0x392))
+    (i64.store offset=0x393 align=1 (i32.const 0) (local.get 0x393))
+    (i64.store offset=0x394 align=1 (i32.const 0) (local.get 0x394))
+    (i64.store offset=0x395 align=1 (i32.const 0) (local.get 0x395))
+    (i64.store offset=0x396 align=1 (i32.const 0) (local.get 0x396))
+    (i64.store offset=0x397 align=1 (i32.const 0) (local.get 0x397))
+    (i64.store offset=0x398 align=1 (i32.const 0) (local.get 0x398))
+    (i64.store offset=0x399 align=1 (i32.const 0) (local.get 0x399))
+    (i64.store offset=0x39a align=1 (i32.const 0) (local.get 0x39a))
+    (i64.store offset=0x39b align=1 (i32.const 0) (local.get 0x39b))
+    (i64.store offset=0x39c align=1 (i32.const 0) (local.get 0x39c))
+    (i64.store offset=0x39d align=1 (i32.const 0) (local.get 0x39d))
+    (i64.store offset=0x39e align=1 (i32.const 0) (local.get 0x39e))
+    (i64.store offset=0x39f align=1 (i32.const 0) (local.get 0x39f))
+    (i64.store offset=0x3a0 align=1 (i32.const 0) (local.get 0x3a0))
+    (i64.store offset=0x3a1 align=1 (i32.const 0) (local.get 0x3a1))
+    (i64.store offset=0x3a2 align=1 (i32.const 0) (local.get 0x3a2))
+    (i64.store offset=0x3a3 align=1 (i32.const 0) (local.get 0x3a3))
+    (i64.store offset=0x3a4 align=1 (i32.const 0) (local.get 0x3a4))
+    (i64.store offset=0x3a5 align=1 (i32.const 0) (local.get 0x3a5))
+    (i64.store offset=0x3a6 align=1 (i32.const 0) (local.get 0x3a6))
+    (i64.store offset=0x3a7 align=1 (i32.const 0) (local.get 0x3a7))
+    (i64.store offset=0x3a8 align=1 (i32.const 0) (local.get 0x3a8))
+    (i64.store offset=0x3a9 align=1 (i32.const 0) (local.get 0x3a9))
+    (i64.store offset=0x3aa align=1 (i32.const 0) (local.get 0x3aa))
+    (i64.store offset=0x3ab align=1 (i32.const 0) (local.get 0x3ab))
+    (i64.store offset=0x3ac align=1 (i32.const 0) (local.get 0x3ac))
+    (i64.store offset=0x3ad align=1 (i32.const 0) (local.get 0x3ad))
+    (i64.store offset=0x3ae align=1 (i32.const 0) (local.get 0x3ae))
+    (i64.store offset=0x3af align=1 (i32.const 0) (local.get 0x3af))
+    (i64.store offset=0x3b0 align=1 (i32.const 0) (local.get 0x3b0))
+    (i64.store offset=0x3b1 align=1 (i32.const 0) (local.get 0x3b1))
+    (i64.store offset=0x3b2 align=1 (i32.const 0) (local.get 0x3b2))
+    (i64.store offset=0x3b3 align=1 (i32.const 0) (local.get 0x3b3))
+    (i64.store offset=0x3b4 align=1 (i32.const 0) (local.get 0x3b4))
+    (i64.store offset=0x3b5 align=1 (i32.const 0) (local.get 0x3b5))
+    (i64.store offset=0x3b6 align=1 (i32.const 0) (local.get 0x3b6))
+    (i64.store offset=0x3b7 align=1 (i32.const 0) (local.get 0x3b7))
+    (i64.store offset=0x3b8 align=1 (i32.const 0) (local.get 0x3b8))
+    (i64.store offset=0x3b9 align=1 (i32.const 0) (local.get 0x3b9))
+    (i64.store offset=0x3ba align=1 (i32.const 0) (local.get 0x3ba))
+    (i64.store offset=0x3bb align=1 (i32.const 0) (local.get 0x3bb))
+    (i64.store offset=0x3bc align=1 (i32.const 0) (local.get 0x3bc))
+    (i64.store offset=0x3bd align=1 (i32.const 0) (local.get 0x3bd))
+    (i64.store offset=0x3be align=1 (i32.const 0) (local.get 0x3be))
+    (i64.store offset=0x3bf align=1 (i32.const 0) (local.get 0x3bf))
+    (i64.store offset=0x3c0 align=1 (i32.const 0) (local.get 0x3c0))
+    (i64.store offset=0x3c1 align=1 (i32.const 0) (local.get 0x3c1))
+    (i64.store offset=0x3c2 align=1 (i32.const 0) (local.get 0x3c2))
+    (i64.store offset=0x3c3 align=1 (i32.const 0) (local.get 0x3c3))
+    (i64.store offset=0x3c4 align=1 (i32.const 0) (local.get 0x3c4))
+    (i64.store offset=0x3c5 align=1 (i32.const 0) (local.get 0x3c5))
+    (i64.store offset=0x3c6 align=1 (i32.const 0) (local.get 0x3c6))
+    (i64.store offset=0x3c7 align=1 (i32.const 0) (local.get 0x3c7))
+    (i64.store offset=0x3c8 align=1 (i32.const 0) (local.get 0x3c8))
+    (i64.store offset=0x3c9 align=1 (i32.const 0) (local.get 0x3c9))
+    (i64.store offset=0x3ca align=1 (i32.const 0) (local.get 0x3ca))
+    (i64.store offset=0x3cb align=1 (i32.const 0) (local.get 0x3cb))
+    (i64.store offset=0x3cc align=1 (i32.const 0) (local.get 0x3cc))
+    (i64.store offset=0x3cd align=1 (i32.const 0) (local.get 0x3cd))
+    (i64.store offset=0x3ce align=1 (i32.const 0) (local.get 0x3ce))
+    (i64.store offset=0x3cf align=1 (i32.const 0) (local.get 0x3cf))
+    (i64.store offset=0x3d0 align=1 (i32.const 0) (local.get 0x3d0))
+    (i64.store offset=0x3d1 align=1 (i32.const 0) (local.get 0x3d1))
+    (i64.store offset=0x3d2 align=1 (i32.const 0) (local.get 0x3d2))
+    (i64.store offset=0x3d3 align=1 (i32.const 0) (local.get 0x3d3))
+    (i64.store offset=0x3d4 align=1 (i32.const 0) (local.get 0x3d4))
+    (i64.store offset=0x3d5 align=1 (i32.const 0) (local.get 0x3d5))
+    (i64.store offset=0x3d6 align=1 (i32.const 0) (local.get 0x3d6))
+    (i64.store offset=0x3d7 align=1 (i32.const 0) (local.get 0x3d7))
+    (i64.store offset=0x3d8 align=1 (i32.const 0) (local.get 0x3d8))
+    (i64.store offset=0x3d9 align=1 (i32.const 0) (local.get 0x3d9))
+    (i64.store offset=0x3da align=1 (i32.const 0) (local.get 0x3da))
+    (i64.store offset=0x3db align=1 (i32.const 0) (local.get 0x3db))
+    (i64.store offset=0x3dc align=1 (i32.const 0) (local.get 0x3dc))
+    (i64.store offset=0x3dd align=1 (i32.const 0) (local.get 0x3dd))
+    (i64.store offset=0x3de align=1 (i32.const 0) (local.get 0x3de))
+    (i64.store offset=0x3df align=1 (i32.const 0) (local.get 0x3df))
+    (i64.store offset=0x3e0 align=1 (i32.const 0) (local.get 0x3e0))
+    (i64.store offset=0x3e1 align=1 (i32.const 0) (local.get 0x3e1))
+    (i64.store offset=0x3e2 align=1 (i32.const 0) (local.get 0x3e2))
+    (i64.store offset=0x3e3 align=1 (i32.const 0) (local.get 0x3e3))
+    (i64.store offset=0x3e4 align=1 (i32.const 0) (local.get 0x3e4))
+    (i64.store offset=0x3e5 align=1 (i32.const 0) (local.get 0x3e5))
+    (i64.store offset=0x3e6 align=1 (i32.const 0) (local.get 0x3e6))
+    (i64.store offset=0x3e7 align=1 (i32.const 0) (local.get 0x3e7))
+    (i64.store offset=0x3e8 align=1 (i32.const 0) (local.get 0x3e8))
+    (i64.store offset=0x3e9 align=1 (i32.const 0) (local.get 0x3e9))
+    (i64.store offset=0x3ea align=1 (i32.const 0) (local.get 0x3ea))
+    (i64.store offset=0x3eb align=1 (i32.const 0) (local.get 0x3eb))
+    (i64.store offset=0x3ec align=1 (i32.const 0) (local.get 0x3ec))
+    (i64.store offset=0x3ed align=1 (i32.const 0) (local.get 0x3ed))
+    (i64.store offset=0x3ee align=1 (i32.const 0) (local.get 0x3ee))
+    (i64.store offset=0x3ef align=1 (i32.const 0) (local.get 0x3ef))
+    (i64.store offset=0x3f0 align=1 (i32.const 0) (local.get 0x3f0))
+    (i64.store offset=0x3f1 align=1 (i32.const 0) (local.get 0x3f1))
+    (i64.store offset=0x3f2 align=1 (i32.const 0) (local.get 0x3f2))
+    (i64.store offset=0x3f3 align=1 (i32.const 0) (local.get 0x3f3))
+    (i64.store offset=0x3f4 align=1 (i32.const 0) (local.get 0x3f4))
+    (i64.store offset=0x3f5 align=1 (i32.const 0) (local.get 0x3f5))
+    (i64.store offset=0x3f6 align=1 (i32.const 0) (local.get 0x3f6))
+    (i64.store offset=0x3f7 align=1 (i32.const 0) (local.get 0x3f7))
+    (i64.store offset=0x3f8 align=1 (i32.const 0) (local.get 0x3f8))
+    (i64.store offset=0x3f9 align=1 (i32.const 0) (local.get 0x3f9))
+    (i64.store offset=0x3fa align=1 (i32.const 0) (local.get 0x3fa))
+    (i64.store offset=0x3fb align=1 (i32.const 0) (local.get 0x3fb))
+    (i64.store offset=0x3fc align=1 (i32.const 0) (local.get 0x3fc))
+    (i64.store offset=0x3fd align=1 (i32.const 0) (local.get 0x3fd))
+    (i64.store offset=0x3fe align=1 (i32.const 0) (local.get 0x3fe))
+    (i64.store offset=0x3ff align=1 (i32.const 0) (local.get 0x3ff))
+    (i64.store offset=0x400 align=1 (i32.const 0) (local.get 0x400))
+    (i64.store offset=0x401 align=1 (i32.const 0) (local.get 0x401))
+    (i64.store offset=0x402 align=1 (i32.const 0) (local.get 0x402))
+    (i64.store offset=0x403 align=1 (i32.const 0) (local.get 0x403))
+    (i64.store offset=0x404 align=1 (i32.const 0) (local.get 0x404))
+    (i64.store offset=0x405 align=1 (i32.const 0) (local.get 0x405))
+    (i64.store offset=0x406 align=1 (i32.const 0) (local.get 0x406))
+    (i64.store offset=0x407 align=1 (i32.const 0) (local.get 0x407))
+    (i64.store offset=0x408 align=1 (i32.const 0) (local.get 0x408))
+    (i64.store offset=0x409 align=1 (i32.const 0) (local.get 0x409))
+    (i64.store offset=0x40a align=1 (i32.const 0) (local.get 0x40a))
+    (i64.store offset=0x40b align=1 (i32.const 0) (local.get 0x40b))
+    (i64.store offset=0x40c align=1 (i32.const 0) (local.get 0x40c))
+    (i64.store offset=0x40d align=1 (i32.const 0) (local.get 0x40d))
+    (i64.store offset=0x40e align=1 (i32.const 0) (local.get 0x40e))
+    (i64.store offset=0x40f align=1 (i32.const 0) (local.get 0x40f))
+    (i64.store offset=0x410 align=1 (i32.const 0) (local.get 0x410))
+    (i64.store offset=0x411 align=1 (i32.const 0) (local.get 0x411))
+    (i64.store offset=0x412 align=1 (i32.const 0) (local.get 0x412))
+    (i64.store offset=0x413 align=1 (i32.const 0) (local.get 0x413))
+    (i64.store offset=0x414 align=1 (i32.const 0) (local.get 0x414))
+    (i64.store offset=0x415 align=1 (i32.const 0) (local.get 0x415))
+    (i64.store offset=0x416 align=1 (i32.const 0) (local.get 0x416))
+    (i64.store offset=0x417 align=1 (i32.const 0) (local.get 0x417))
+    (i64.store offset=0x418 align=1 (i32.const 0) (local.get 0x418))
+    (i64.store offset=0x419 align=1 (i32.const 0) (local.get 0x419))
+    (i64.store offset=0x41a align=1 (i32.const 0) (local.get 0x41a))
+    (i64.store offset=0x41b align=1 (i32.const 0) (local.get 0x41b))
+    (i64.store offset=0x41c align=1 (i32.const 0) (local.get 0x41c))
+    (i64.store offset=0x41d align=1 (i32.const 0) (local.get 0x41d))
+    (i64.store offset=0x41e align=1 (i32.const 0) (local.get 0x41e))
+    (i64.store offset=0x41f align=1 (i32.const 0) (local.get 0x41f))
+  )
+)
diff --git a/substrate/client/executor/wasmtime/src/tests.rs b/substrate/client/executor/wasmtime/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..65093687822d49b650c7a2a639b8a9ac864a202a
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/tests.rs
@@ -0,0 +1,531 @@
+// 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 codec::{Decode as _, Encode as _};
+use sc_executor_common::{
+	error::Error,
+	runtime_blob::RuntimeBlob,
+	wasm_runtime::{HeapAllocStrategy, WasmModule, DEFAULT_HEAP_ALLOC_STRATEGY},
+};
+use sc_runtime_test::wasm_binary_unwrap;
+
+use crate::InstantiationStrategy;
+
+type HostFunctions = sp_io::SubstrateHostFunctions;
+
+#[macro_export]
+macro_rules! test_wasm_execution {
+	(@no_legacy_instance_reuse $method_name:ident) => {
+		paste::item! {
+			#[test]
+			fn [<$method_name _recreate_instance_cow>]() {
+				$method_name(
+					InstantiationStrategy::RecreateInstanceCopyOnWrite
+				);
+			}
+
+			#[test]
+			fn [<$method_name _recreate_instance_vanilla>]() {
+				$method_name(
+					InstantiationStrategy::RecreateInstance
+				);
+			}
+
+			#[test]
+			fn [<$method_name _pooling_cow>]() {
+				$method_name(
+					InstantiationStrategy::PoolingCopyOnWrite
+				);
+			}
+
+			#[test]
+			fn [<$method_name _pooling_vanilla>]() {
+				$method_name(
+					InstantiationStrategy::Pooling
+				);
+			}
+		}
+	};
+
+	($method_name:ident) => {
+		test_wasm_execution!(@no_legacy_instance_reuse $method_name);
+
+		paste::item! {
+			#[test]
+			fn [<$method_name _legacy_instance_reuse>]() {
+				$method_name(
+					InstantiationStrategy::LegacyInstanceReuse
+				);
+			}
+		}
+	};
+}
+
+struct RuntimeBuilder {
+	code: Option<String>,
+	instantiation_strategy: InstantiationStrategy,
+	canonicalize_nans: bool,
+	deterministic_stack: bool,
+	heap_pages: HeapAllocStrategy,
+	precompile_runtime: bool,
+	tmpdir: Option<tempfile::TempDir>,
+}
+
+impl RuntimeBuilder {
+	fn new(instantiation_strategy: InstantiationStrategy) -> Self {
+		Self {
+			code: None,
+			instantiation_strategy,
+			canonicalize_nans: false,
+			deterministic_stack: false,
+			heap_pages: DEFAULT_HEAP_ALLOC_STRATEGY,
+			precompile_runtime: false,
+			tmpdir: None,
+		}
+	}
+
+	fn use_wat(mut self, code: String) -> Self {
+		self.code = Some(code);
+		self
+	}
+
+	fn canonicalize_nans(mut self, canonicalize_nans: bool) -> Self {
+		self.canonicalize_nans = canonicalize_nans;
+		self
+	}
+
+	fn deterministic_stack(mut self, deterministic_stack: bool) -> Self {
+		self.deterministic_stack = deterministic_stack;
+		self
+	}
+
+	fn precompile_runtime(mut self, precompile_runtime: bool) -> Self {
+		self.precompile_runtime = precompile_runtime;
+		self
+	}
+
+	fn heap_alloc_strategy(mut self, heap_pages: HeapAllocStrategy) -> Self {
+		self.heap_pages = heap_pages;
+		self
+	}
+
+	fn build(&mut self) -> impl WasmModule + '_ {
+		let blob = {
+			let wasm: Vec<u8>;
+
+			let wasm = match self.code {
+				None => wasm_binary_unwrap(),
+				Some(ref wat) => {
+					wasm = wat::parse_str(wat).expect("wat parsing failed");
+					&wasm
+				},
+			};
+
+			RuntimeBlob::uncompress_if_needed(&wasm)
+				.expect("failed to create a runtime blob out of test runtime")
+		};
+
+		let config = crate::Config {
+			allow_missing_func_imports: true,
+			cache_path: None,
+			semantics: crate::Semantics {
+				instantiation_strategy: self.instantiation_strategy,
+				deterministic_stack_limit: match self.deterministic_stack {
+					true => Some(crate::DeterministicStackLimit {
+						logical_max: 65536,
+						native_stack_max: 256 * 1024 * 1024,
+					}),
+					false => None,
+				},
+				canonicalize_nans: self.canonicalize_nans,
+				parallel_compilation: true,
+				heap_alloc_strategy: self.heap_pages,
+				wasm_multi_value: false,
+				wasm_bulk_memory: false,
+				wasm_reference_types: false,
+				wasm_simd: false,
+			},
+		};
+
+		if self.precompile_runtime {
+			let dir = tempfile::tempdir().unwrap();
+			let path = dir.path().join("runtime.bin");
+
+			// Delay the removal of the temporary directory until we're dropped.
+			self.tmpdir = Some(dir);
+
+			let artifact = crate::prepare_runtime_artifact(blob, &config.semantics).unwrap();
+			std::fs::write(&path, artifact).unwrap();
+			unsafe { crate::create_runtime_from_artifact::<HostFunctions>(&path, config) }
+		} else {
+			crate::create_runtime::<HostFunctions>(blob, config)
+		}
+		.expect("cannot create runtime")
+	}
+}
+
+fn deep_call_stack_wat(depth: usize) -> String {
+	format!(
+		r#"
+			(module
+			  (memory $0 32)
+			  (export "memory" (memory $0))
+			  (global (export "__heap_base") i32 (i32.const 0))
+			  (func (export "overflow") call 0)
+
+			  (func $overflow (param $0 i32)
+			    (block $label$1
+			      (br_if $label$1
+			        (i32.ge_u
+			          (local.get $0)
+			          (i32.const {depth})
+			        )
+			      )
+			      (call $overflow
+			        (i32.add
+			          (local.get $0)
+			          (i32.const 1)
+			        )
+			      )
+			    )
+			  )
+
+			  (func (export "main")
+			    (param i32 i32) (result i64)
+			    (call $overflow (i32.const 0))
+			    (i64.const 0)
+			  )
+			)
+		"#
+	)
+}
+
+// These two tests ensure that the `wasmtime`'s stack size limit and the amount of
+// stack space used by a single stack frame doesn't suddenly change without us noticing.
+//
+// If they do (e.g. because we've pulled in a new version of `wasmtime`) we want to know
+// that it did, regardless of how small the change was.
+//
+// If these tests starting failing it doesn't necessarily mean that something is broken;
+// what it means is that one (or multiple) of the following has to be done:
+//   a) the tests may need to be updated for the new call depth,
+//   b) the stack limit may need to be changed to maintain backwards compatibility,
+//   c) the root cause of the new call depth limit determined, and potentially fixed,
+//   d) the new call depth limit may need to be validated to ensure it doesn't prevent any
+//      existing chain from syncing (if it was effectively decreased)
+
+// We need two limits here since depending on whether the code is compiled in debug
+// or in release mode the maximum call depth is slightly different.
+const CALL_DEPTH_LOWER_LIMIT: usize = 65455;
+const CALL_DEPTH_UPPER_LIMIT: usize = 65509;
+
+test_wasm_execution!(test_consume_under_1mb_of_stack_does_not_trap);
+fn test_consume_under_1mb_of_stack_does_not_trap(instantiation_strategy: InstantiationStrategy) {
+	let wat = deep_call_stack_wat(CALL_DEPTH_LOWER_LIMIT);
+	let mut builder = RuntimeBuilder::new(instantiation_strategy).use_wat(wat);
+	let runtime = builder.build();
+	let mut instance = runtime.new_instance().expect("failed to instantiate a runtime");
+	instance.call_export("main", &[]).unwrap();
+}
+
+test_wasm_execution!(test_consume_over_1mb_of_stack_does_trap);
+fn test_consume_over_1mb_of_stack_does_trap(instantiation_strategy: InstantiationStrategy) {
+	let wat = deep_call_stack_wat(CALL_DEPTH_UPPER_LIMIT + 1);
+	let mut builder = RuntimeBuilder::new(instantiation_strategy).use_wat(wat);
+	let runtime = builder.build();
+	let mut instance = runtime.new_instance().expect("failed to instantiate a runtime");
+	match instance.call_export("main", &[]).unwrap_err() {
+		Error::AbortedDueToTrap(error) => {
+			let expected = "wasm trap: call stack exhausted";
+			assert_eq!(error.message, expected);
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(test_nan_canonicalization);
+fn test_nan_canonicalization(instantiation_strategy: InstantiationStrategy) {
+	let mut builder = RuntimeBuilder::new(instantiation_strategy).canonicalize_nans(true);
+	let runtime = builder.build();
+
+	let mut instance = runtime.new_instance().expect("failed to instantiate a runtime");
+
+	/// A NaN with canonical payload bits.
+	const CANONICAL_NAN_BITS: u32 = 0x7fc00000;
+	/// A NaN value with an abitrary payload.
+	const ARBITRARY_NAN_BITS: u32 = 0x7f812345;
+
+	// This test works like this: we essentially do
+	//
+	//     a + b
+	//
+	// where
+	//
+	//     * a is a nan with arbitrary bits in its payload
+	//     * b is 1.
+	//
+	// according to the wasm spec, if one of the inputs to the operation is a non-canonical NaN
+	// then the value be a NaN with non-deterministic payload bits.
+	//
+	// However, with the `canonicalize_nans` option turned on above, we expect that the output will
+	// be a canonical NaN.
+	//
+	// We exterpolate the results of this tests so that we assume that all intermediate computations
+	// that involve floats are sanitized and cannot produce a non-deterministic NaN.
+
+	let params = (u32::to_le_bytes(ARBITRARY_NAN_BITS), u32::to_le_bytes(1)).encode();
+	let res = {
+		let raw_result = instance.call_export("test_fp_f32add", &params).unwrap();
+		u32::from_le_bytes(<[u8; 4]>::decode(&mut &raw_result[..]).unwrap())
+	};
+	assert_eq!(res, CANONICAL_NAN_BITS);
+}
+
+test_wasm_execution!(test_stack_depth_reaching);
+fn test_stack_depth_reaching(instantiation_strategy: InstantiationStrategy) {
+	const TEST_GUARD_PAGE_SKIP: &str = include_str!("test-guard-page-skip.wat");
+
+	let mut builder = RuntimeBuilder::new(instantiation_strategy)
+		.use_wat(TEST_GUARD_PAGE_SKIP.to_string())
+		.deterministic_stack(true);
+
+	let runtime = builder.build();
+	let mut instance = runtime.new_instance().expect("failed to instantiate a runtime");
+
+	match instance.call_export("test-many-locals", &[]).unwrap_err() {
+		Error::AbortedDueToTrap(error) => {
+			let expected = "wasm trap: wasm `unreachable` instruction executed";
+			assert_eq!(error.message, expected);
+		},
+		error => panic!("unexpected error: {:?}", error),
+	}
+}
+
+test_wasm_execution!(test_max_memory_pages_imported_memory_without_precompilation);
+fn test_max_memory_pages_imported_memory_without_precompilation(
+	instantiation_strategy: InstantiationStrategy,
+) {
+	test_max_memory_pages(instantiation_strategy, true, false);
+}
+
+test_wasm_execution!(test_max_memory_pages_exported_memory_without_precompilation);
+fn test_max_memory_pages_exported_memory_without_precompilation(
+	instantiation_strategy: InstantiationStrategy,
+) {
+	test_max_memory_pages(instantiation_strategy, false, false);
+}
+
+test_wasm_execution!(@no_legacy_instance_reuse test_max_memory_pages_imported_memory_with_precompilation);
+fn test_max_memory_pages_imported_memory_with_precompilation(
+	instantiation_strategy: InstantiationStrategy,
+) {
+	test_max_memory_pages(instantiation_strategy, true, true);
+}
+
+test_wasm_execution!(@no_legacy_instance_reuse test_max_memory_pages_exported_memory_with_precompilation);
+fn test_max_memory_pages_exported_memory_with_precompilation(
+	instantiation_strategy: InstantiationStrategy,
+) {
+	test_max_memory_pages(instantiation_strategy, false, true);
+}
+
+fn test_max_memory_pages(
+	instantiation_strategy: InstantiationStrategy,
+	import_memory: bool,
+	precompile_runtime: bool,
+) {
+	fn call(
+		heap_alloc_strategy: HeapAllocStrategy,
+		wat: String,
+		instantiation_strategy: InstantiationStrategy,
+		precompile_runtime: bool,
+	) -> Result<(), Box<dyn std::error::Error>> {
+		let mut builder = RuntimeBuilder::new(instantiation_strategy)
+			.use_wat(wat)
+			.heap_alloc_strategy(heap_alloc_strategy)
+			.precompile_runtime(precompile_runtime);
+
+		let runtime = builder.build();
+		let mut instance = runtime.new_instance().unwrap();
+		let _ = instance.call_export("main", &[])?;
+		Ok(())
+	}
+
+	fn memory(initial: u32, maximum: u32, import: bool) -> String {
+		let memory = format!("(memory $0 {} {})", initial, maximum);
+
+		if import {
+			format!("(import \"env\" \"memory\" {})", memory)
+		} else {
+			format!("{}\n(export \"memory\" (memory $0))", memory)
+		}
+	}
+
+	let assert_grow_ok = |alloc_strategy: HeapAllocStrategy, initial_pages: u32, max_pages: u32| {
+		eprintln!("assert_grow_ok({alloc_strategy:?}, {initial_pages}, {max_pages})");
+
+		call(
+			alloc_strategy,
+			format!(
+				r#"
+					(module
+						{}
+						(global (export "__heap_base") i32 (i32.const 0))
+						(func (export "main")
+							(param i32 i32) (result i64)
+
+							;; assert(memory.grow returns != -1)
+							(if
+								(i32.eq
+									(memory.grow
+										(i32.const 1)
+									)
+									(i32.const -1)
+								)
+								(unreachable)
+							)
+
+							(i64.const 0)
+						)
+					)
+			"#,
+				memory(initial_pages, max_pages, import_memory)
+			),
+			instantiation_strategy,
+			precompile_runtime,
+		)
+		.unwrap()
+	};
+
+	let assert_grow_fail =
+		|alloc_strategy: HeapAllocStrategy, initial_pages: u32, max_pages: u32| {
+			eprintln!("assert_grow_fail({alloc_strategy:?}, {initial_pages}, {max_pages})");
+
+			call(
+				alloc_strategy,
+				format!(
+					r#"
+						(module
+							{}
+							(global (export "__heap_base") i32 (i32.const 0))
+							(func (export "main")
+								(param i32 i32) (result i64)
+
+								;; assert(memory.grow returns == -1)
+								(if
+									(i32.ne
+										(memory.grow
+											(i32.const 1)
+										)
+										(i32.const -1)
+									)
+									(unreachable)
+								)
+
+								(i64.const 0)
+							)
+						)
+					"#,
+					memory(initial_pages, max_pages, import_memory)
+				),
+				instantiation_strategy,
+				precompile_runtime,
+			)
+			.unwrap()
+		};
+
+	assert_grow_ok(HeapAllocStrategy::Dynamic { maximum_pages: Some(10) }, 1, 10);
+	assert_grow_ok(HeapAllocStrategy::Dynamic { maximum_pages: Some(10) }, 9, 10);
+	assert_grow_fail(HeapAllocStrategy::Dynamic { maximum_pages: Some(10) }, 10, 10);
+
+	assert_grow_ok(HeapAllocStrategy::Dynamic { maximum_pages: None }, 1, 10);
+	assert_grow_ok(HeapAllocStrategy::Dynamic { maximum_pages: None }, 9, 10);
+	assert_grow_ok(HeapAllocStrategy::Dynamic { maximum_pages: None }, 10, 10);
+
+	assert_grow_fail(HeapAllocStrategy::Static { extra_pages: 10 }, 1, 10);
+	assert_grow_fail(HeapAllocStrategy::Static { extra_pages: 10 }, 9, 10);
+	assert_grow_fail(HeapAllocStrategy::Static { extra_pages: 10 }, 10, 10);
+}
+
+// This test takes quite a while to execute in a debug build (over 6 minutes on a TR 3970x)
+// so it's ignored by default unless it was compiled with `--release`.
+#[cfg_attr(build_type = "debug", ignore)]
+#[test]
+fn test_instances_without_reuse_are_not_leaked() {
+	let runtime = crate::create_runtime::<HostFunctions>(
+		RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),
+		crate::Config {
+			allow_missing_func_imports: true,
+			cache_path: None,
+			semantics: crate::Semantics {
+				instantiation_strategy: InstantiationStrategy::RecreateInstance,
+				deterministic_stack_limit: None,
+				canonicalize_nans: false,
+				parallel_compilation: true,
+				heap_alloc_strategy: DEFAULT_HEAP_ALLOC_STRATEGY,
+				wasm_multi_value: false,
+				wasm_bulk_memory: false,
+				wasm_reference_types: false,
+				wasm_simd: false,
+			},
+		},
+	)
+	.unwrap();
+
+	// As long as the `wasmtime`'s `Store` lives the instances spawned through it
+	// will live indefinitely. Currently it has a maximum limit of 10k instances,
+	// so let's spawn 10k + 1 of them to make sure our code doesn't keep the `Store`
+	// alive longer than it is necessary. (And since we disabled instance reuse
+	// a new instance will be spawned on each call.)
+	let mut instance = runtime.new_instance().unwrap();
+	for _ in 0..10001 {
+		instance.call_export("test_empty_return", &[0]).unwrap();
+	}
+}
+
+#[test]
+fn test_rustix_version_matches_with_wasmtime() {
+	let metadata = cargo_metadata::MetadataCommand::new().exec().unwrap();
+
+	let wasmtime_rustix = metadata
+		.packages
+		.iter()
+		.find(|pkg| pkg.name == "wasmtime-runtime")
+		.unwrap()
+		.dependencies
+		.iter()
+		.find(|dep| dep.name == "rustix")
+		.unwrap();
+	let our_rustix = metadata
+		.packages
+		.iter()
+		.find(|pkg| pkg.name == "sc-executor-wasmtime")
+		.unwrap()
+		.dependencies
+		.iter()
+		.find(|dep| dep.name == "rustix")
+		.unwrap();
+
+	if wasmtime_rustix.req != our_rustix.req {
+		panic!(
+			"our version of rustix ({0}) doesn't match wasmtime's ({1}); \
+				bump the version in `sc-executor-wasmtime`'s `Cargo.toml' to '{1}' and try again",
+			our_rustix.req, wasmtime_rustix.req,
+		);
+	}
+}
diff --git a/substrate/client/executor/wasmtime/src/util.rs b/substrate/client/executor/wasmtime/src/util.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c38d969ce9dcdc67575a6259265e10f8e9b0ed91
--- /dev/null
+++ b/substrate/client/executor/wasmtime/src/util.rs
@@ -0,0 +1,173 @@
+// 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::{runtime::StoreData, InstantiationStrategy};
+use sc_executor_common::{
+	error::{Error, Result},
+	util::checked_range,
+};
+use sp_wasm_interface::{Pointer, Value};
+use wasmtime::{AsContext, AsContextMut};
+
+/// Converts a [`wasmtime::Val`] into a substrate runtime interface [`Value`].
+///
+/// Panics if the given value doesn't have a corresponding variant in `Value`.
+pub fn from_wasmtime_val(val: wasmtime::Val) -> Value {
+	match val {
+		wasmtime::Val::I32(v) => Value::I32(v),
+		wasmtime::Val::I64(v) => Value::I64(v),
+		wasmtime::Val::F32(f_bits) => Value::F32(f_bits),
+		wasmtime::Val::F64(f_bits) => Value::F64(f_bits),
+		v => panic!("Given value type is unsupported by Substrate: {:?}", v),
+	}
+}
+
+/// Converts a sp_wasm_interface's [`Value`] into the corresponding variant in wasmtime's
+/// [`wasmtime::Val`].
+pub fn into_wasmtime_val(value: Value) -> wasmtime::Val {
+	match value {
+		Value::I32(v) => wasmtime::Val::I32(v),
+		Value::I64(v) => wasmtime::Val::I64(v),
+		Value::F32(f_bits) => wasmtime::Val::F32(f_bits),
+		Value::F64(f_bits) => wasmtime::Val::F64(f_bits),
+	}
+}
+
+/// Read data from the instance memory into a slice.
+///
+/// Returns an error if the read would go out of the memory bounds.
+pub(crate) fn read_memory_into(
+	ctx: impl AsContext<Data = StoreData>,
+	address: Pointer<u8>,
+	dest: &mut [u8],
+) -> Result<()> {
+	let memory = ctx.as_context().data().memory().data(&ctx);
+
+	let range = checked_range(address.into(), dest.len(), memory.len())
+		.ok_or_else(|| Error::Other("memory read is out of bounds".into()))?;
+	dest.copy_from_slice(&memory[range]);
+	Ok(())
+}
+
+/// Write data to the instance memory from a slice.
+///
+/// Returns an error if the write would go out of the memory bounds.
+pub(crate) fn write_memory_from(
+	mut ctx: impl AsContextMut<Data = StoreData>,
+	address: Pointer<u8>,
+	data: &[u8],
+) -> Result<()> {
+	let memory = ctx.as_context().data().memory();
+	let memory = memory.data_mut(&mut ctx);
+
+	let range = checked_range(address.into(), data.len(), memory.len())
+		.ok_or_else(|| Error::Other("memory write is out of bounds".into()))?;
+	memory[range].copy_from_slice(data);
+	Ok(())
+}
+
+/// Checks whether the `madvise(MADV_DONTNEED)` works as expected.
+///
+/// In certain environments (e.g. when running under the QEMU user-mode emulator)
+/// this syscall is broken.
+#[cfg(target_os = "linux")]
+fn is_madvise_working() -> std::result::Result<bool, String> {
+	let page_size = rustix::param::page_size();
+
+	unsafe {
+		// Allocate two memory pages.
+		let pointer = rustix::mm::mmap_anonymous(
+			std::ptr::null_mut(),
+			2 * page_size,
+			rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
+			rustix::mm::MapFlags::PRIVATE,
+		)
+		.map_err(|error| format!("mmap failed: {}", error))?;
+
+		// Dirty them both.
+		std::ptr::write_volatile(pointer.cast::<u8>(), b'A');
+		std::ptr::write_volatile(pointer.cast::<u8>().add(page_size), b'B');
+
+		// Clear the first page.
+		let result_madvise =
+			rustix::mm::madvise(pointer, page_size, rustix::mm::Advice::LinuxDontNeed)
+				.map_err(|error| format!("madvise failed: {}", error));
+
+		// Fetch the values.
+		let value_1 = std::ptr::read_volatile(pointer.cast::<u8>());
+		let value_2 = std::ptr::read_volatile(pointer.cast::<u8>().add(page_size));
+
+		let result_munmap = rustix::mm::munmap(pointer, 2 * page_size)
+			.map_err(|error| format!("munmap failed: {}", error));
+
+		result_madvise?;
+		result_munmap?;
+
+		// Verify that the first page was cleared, while the second one was not.
+		Ok(value_1 == 0 && value_2 == b'B')
+	}
+}
+
+#[cfg(test)]
+#[cfg(target_os = "linux")]
+#[test]
+fn test_is_madvise_working_check_does_not_fail() {
+	assert!(is_madvise_working().is_ok());
+}
+
+/// Checks whether a given instantiation strategy can be safely used, and replaces
+/// it with a slower (but sound) alternative if it isn't.
+#[cfg(target_os = "linux")]
+pub(crate) fn replace_strategy_if_broken(strategy: &mut InstantiationStrategy) {
+	let replacement_strategy = match *strategy {
+		// These strategies don't need working `madvise`.
+		InstantiationStrategy::Pooling | InstantiationStrategy::RecreateInstance => return,
+
+		// These strategies require a working `madvise` to be sound.
+		InstantiationStrategy::PoolingCopyOnWrite => InstantiationStrategy::Pooling,
+		InstantiationStrategy::RecreateInstanceCopyOnWrite |
+		InstantiationStrategy::LegacyInstanceReuse => InstantiationStrategy::RecreateInstance,
+	};
+
+	use std::sync::OnceLock;
+	static IS_OK: OnceLock<bool> = OnceLock::new();
+
+	let is_ok = IS_OK.get_or_init(|| {
+		let is_ok = match is_madvise_working() {
+			Ok(is_ok) => is_ok,
+			Err(error) => {
+				// This should never happen.
+				log::warn!("Failed to check whether `madvise(MADV_DONTNEED)` works: {}", error);
+				false
+			}
+		};
+
+		if !is_ok {
+			log::warn!("You're running on a system with a broken `madvise(MADV_DONTNEED)` implementation. This will result in lower performance.");
+		}
+
+		is_ok
+	});
+
+	if !is_ok {
+		*strategy = replacement_strategy;
+	}
+}
+
+#[cfg(not(target_os = "linux"))]
+pub(crate) fn replace_strategy_if_broken(_: &mut InstantiationStrategy) {}
diff --git a/substrate/client/informant/Cargo.toml b/substrate/client/informant/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..eb6e854ee35836cf5b269bc68ec93eeb2d43a777
--- /dev/null
+++ b/substrate/client/informant/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "sc-informant"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate informant."
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+ansi_term = "0.12.1"
+futures = "0.3.21"
+futures-timer = "3.0.1"
+log = "0.4.17"
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
+sc-network = { version = "0.10.0-dev", path = "../network" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
diff --git a/substrate/client/informant/README.md b/substrate/client/informant/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b494042590a4218aaa9c63d5e4b3c8a09a804b5b
--- /dev/null
+++ b/substrate/client/informant/README.md
@@ -0,0 +1,3 @@
+Console informant. Prints sync progress and block events. Runs on the calling thread.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/informant/src/display.rs b/substrate/client/informant/src/display.rs
new file mode 100644
index 0000000000000000000000000000000000000000..722cf56d778d64d44631c6bc8e530c455f81b7f6
--- /dev/null
+++ b/substrate/client/informant/src/display.rs
@@ -0,0 +1,248 @@
+// 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::OutputFormat;
+use ansi_term::Colour;
+use log::info;
+use sc_client_api::ClientInfo;
+use sc_network::NetworkStatus;
+use sc_network_common::sync::{
+	warp::{WarpSyncPhase, WarpSyncProgress},
+	SyncState, SyncStatus,
+};
+use sp_runtime::traits::{Block as BlockT, CheckedDiv, NumberFor, Saturating, Zero};
+use std::{fmt, time::Instant};
+
+/// State of the informant display system.
+///
+/// This is the system that handles the line that gets regularly printed and that looks something
+/// like:
+///
+/// > Syncing  5.4 bps, target=#531028 (4 peers), best: #90683 (0x4ca8…51b8),
+/// > finalized #360 (0x6f24…a38b), ⬇ 5.5kiB/s ⬆ 0.9kiB/s
+///
+/// # Usage
+///
+/// Call `InformantDisplay::new` to initialize the state, then regularly call `display` with the
+/// information to display.
+pub struct InformantDisplay<B: BlockT> {
+	/// Head of chain block number from the last time `display` has been called.
+	/// `None` if `display` has never been called.
+	last_number: Option<NumberFor<B>>,
+	/// The last time `display` or `new` has been called.
+	last_update: Instant,
+	/// The last seen total of bytes received.
+	last_total_bytes_inbound: u64,
+	/// The last seen total of bytes sent.
+	last_total_bytes_outbound: u64,
+	/// The format to print output in.
+	format: OutputFormat,
+}
+
+impl<B: BlockT> InformantDisplay<B> {
+	/// Builds a new informant display system.
+	pub fn new(format: OutputFormat) -> InformantDisplay<B> {
+		InformantDisplay {
+			last_number: None,
+			last_update: Instant::now(),
+			last_total_bytes_inbound: 0,
+			last_total_bytes_outbound: 0,
+			format,
+		}
+	}
+
+	/// Displays the informant by calling `info!`.
+	pub fn display(
+		&mut self,
+		info: &ClientInfo<B>,
+		net_status: NetworkStatus,
+		sync_status: SyncStatus<B>,
+	) {
+		let best_number = info.chain.best_number;
+		let best_hash = info.chain.best_hash;
+		let finalized_number = info.chain.finalized_number;
+		let num_connected_peers = sync_status.num_connected_peers;
+		let speed = speed::<B>(best_number, self.last_number, self.last_update);
+		let total_bytes_inbound = net_status.total_bytes_inbound;
+		let total_bytes_outbound = net_status.total_bytes_outbound;
+
+		let now = Instant::now();
+		let elapsed = (now - self.last_update).as_secs();
+		self.last_update = now;
+		self.last_number = Some(best_number);
+
+		let diff_bytes_inbound = total_bytes_inbound - self.last_total_bytes_inbound;
+		let diff_bytes_outbound = total_bytes_outbound - self.last_total_bytes_outbound;
+		let (avg_bytes_per_sec_inbound, avg_bytes_per_sec_outbound) = if elapsed > 0 {
+			self.last_total_bytes_inbound = total_bytes_inbound;
+			self.last_total_bytes_outbound = total_bytes_outbound;
+			(diff_bytes_inbound / elapsed, diff_bytes_outbound / elapsed)
+		} else {
+			(diff_bytes_inbound, diff_bytes_outbound)
+		};
+
+		let (level, status, target) =
+			match (sync_status.state, sync_status.state_sync, sync_status.warp_sync) {
+				// Do not set status to "Block history" when we are doing a major sync.
+				//
+				// A node could for example have been warp synced to the tip of the chain and
+				// shutdown. At the next start we still need to download the block history, but
+				// first will sync to the tip of the chain.
+				(
+					sync_status,
+					_,
+					Some(WarpSyncProgress { phase: WarpSyncPhase::DownloadingBlocks(n), .. }),
+				) if !sync_status.is_major_syncing() => ("�", "Block history".into(), format!(", #{}", n)),
+				(
+					_,
+					_,
+					Some(WarpSyncProgress { phase: WarpSyncPhase::AwaitingTargetBlock, .. }),
+				) => ("�", "Waiting for pending target block".into(), "".into()),
+				// Handle all phases besides the two phases we already handle above.
+				(_, _, Some(warp))
+					if !matches!(
+						warp.phase,
+						WarpSyncPhase::AwaitingTargetBlock | WarpSyncPhase::DownloadingBlocks(_)
+					) =>
+					(
+						"�",
+						"Warping".into(),
+						format!(
+							", {}, {:.2} Mib",
+							warp.phase,
+							(warp.total_bytes as f32) / (1024f32 * 1024f32)
+						),
+					),
+				(_, Some(state), _) => (
+					"⚙� ",
+					"Downloading state".into(),
+					format!(
+						", {}%, {:.2} Mib",
+						state.percentage,
+						(state.size as f32) / (1024f32 * 1024f32)
+					),
+				),
+				(SyncState::Idle, _, _) => ("💤", "Idle".into(), "".into()),
+				(SyncState::Downloading { target }, _, _) =>
+					("⚙� ", format!("Syncing{}", speed), format!(", target=#{target}")),
+				(SyncState::Importing { target }, _, _) =>
+					("⚙� ", format!("Preparing{}", speed), format!(", target=#{target}")),
+			};
+
+		if self.format.enable_color {
+			info!(
+				target: "substrate",
+				"{} {}{} ({} peers), best: #{} ({}), finalized #{} ({}), {} {}",
+				level,
+				Colour::White.bold().paint(&status),
+				target,
+				Colour::White.bold().paint(format!("{}", num_connected_peers)),
+				Colour::White.bold().paint(format!("{}", best_number)),
+				best_hash,
+				Colour::White.bold().paint(format!("{}", finalized_number)),
+				info.chain.finalized_hash,
+				Colour::Green.paint(format!("⬇ {}", TransferRateFormat(avg_bytes_per_sec_inbound))),
+				Colour::Red.paint(format!("⬆ {}", TransferRateFormat(avg_bytes_per_sec_outbound))),
+			)
+		} else {
+			info!(
+				target: "substrate",
+				"{} {}{} ({} peers), best: #{} ({}), finalized #{} ({}), ⬇ {} ⬆ {}",
+				level,
+				status,
+				target,
+				num_connected_peers,
+				best_number,
+				best_hash,
+				finalized_number,
+				info.chain.finalized_hash,
+				TransferRateFormat(avg_bytes_per_sec_inbound),
+				TransferRateFormat(avg_bytes_per_sec_outbound),
+			)
+		}
+	}
+}
+
+/// Calculates `(best_number - last_number) / (now - last_update)` and returns a `String`
+/// representing the speed of import.
+fn speed<B: BlockT>(
+	best_number: NumberFor<B>,
+	last_number: Option<NumberFor<B>>,
+	last_update: Instant,
+) -> String {
+	// Number of milliseconds elapsed since last time.
+	let elapsed_ms = {
+		let elapsed = last_update.elapsed();
+		let since_last_millis = elapsed.as_secs() * 1000;
+		let since_last_subsec_millis = elapsed.subsec_millis() as u64;
+		since_last_millis + since_last_subsec_millis
+	};
+
+	// Number of blocks that have been imported since last time.
+	let diff = match last_number {
+		None => return String::new(),
+		Some(n) => best_number.saturating_sub(n),
+	};
+
+	if let Ok(diff) = TryInto::<u128>::try_into(diff) {
+		// If the number of blocks can be converted to a regular integer, then it's easy: just
+		// do the math and turn it into a `f64`.
+		let speed = diff
+			.saturating_mul(10_000)
+			.checked_div(u128::from(elapsed_ms))
+			.map_or(0.0, |s| s as f64) /
+			10.0;
+		format!(" {:4.1} bps", speed)
+	} else {
+		// If the number of blocks can't be converted to a regular integer, then we need a more
+		// algebraic approach and we stay within the realm of integers.
+		let one_thousand = NumberFor::<B>::from(1_000u32);
+		let elapsed =
+			NumberFor::<B>::from(<u32 as TryFrom<_>>::try_from(elapsed_ms).unwrap_or(u32::MAX));
+
+		let speed = diff
+			.saturating_mul(one_thousand)
+			.checked_div(&elapsed)
+			.unwrap_or_else(Zero::zero);
+		format!(" {} bps", speed)
+	}
+}
+
+/// Contains a number of bytes per second. Implements `fmt::Display` and shows this number of bytes
+/// per second in a nice way.
+struct TransferRateFormat(u64);
+impl fmt::Display for TransferRateFormat {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		// Special case 0.
+		if self.0 == 0 {
+			return write!(f, "0")
+		}
+
+		// Under 0.1 kiB, display plain bytes.
+		if self.0 < 100 {
+			return write!(f, "{} B/s", self.0)
+		}
+
+		// Under 1.0 MiB/sec, display the value in kiB/sec.
+		if self.0 < 1024 * 1024 {
+			return write!(f, "{:.1}kiB/s", self.0 as f64 / 1024.0)
+		}
+
+		write!(f, "{:.1}MiB/s", self.0 as f64 / (1024.0 * 1024.0))
+	}
+}
diff --git a/substrate/client/informant/src/lib.rs b/substrate/client/informant/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..03f9075055e2ff98346d84fe6f6c362c468f45b6
--- /dev/null
+++ b/substrate/client/informant/src/lib.rs
@@ -0,0 +1,156 @@
+// 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/>.
+
+//! Console informant. Prints sync progress and block events. Runs on the calling thread.
+
+use ansi_term::Colour;
+use futures::prelude::*;
+use futures_timer::Delay;
+use log::{debug, info, trace};
+use sc_client_api::{BlockchainEvents, UsageProvider};
+use sc_network::NetworkStatusProvider;
+use sc_network_common::sync::SyncStatusProvider;
+use sp_blockchain::HeaderMetadata;
+use sp_runtime::traits::{Block as BlockT, Header};
+use std::{collections::VecDeque, fmt::Display, sync::Arc, time::Duration};
+
+mod display;
+
+/// Creates a stream that returns a new value every `duration`.
+fn interval(duration: Duration) -> impl Stream<Item = ()> + Unpin {
+	futures::stream::unfold((), move |_| Delay::new(duration).map(|_| Some(((), ())))).map(drop)
+}
+
+/// The format to print telemetry output in.
+#[derive(Clone, Debug)]
+pub struct OutputFormat {
+	/// Enable color output in logs.
+	///
+	/// Is enabled by default.
+	pub enable_color: bool,
+}
+
+impl Default for OutputFormat {
+	fn default() -> Self {
+		Self { enable_color: true }
+	}
+}
+
+/// Builds the informant and returns a `Future` that drives the informant.
+pub async fn build<B: BlockT, C, N, S>(client: Arc<C>, network: N, syncing: S, format: OutputFormat)
+where
+	N: NetworkStatusProvider,
+	S: SyncStatusProvider<B>,
+	C: UsageProvider<B> + HeaderMetadata<B> + BlockchainEvents<B>,
+	<C as HeaderMetadata<B>>::Error: Display,
+{
+	let mut display = display::InformantDisplay::new(format.clone());
+
+	let client_1 = client.clone();
+
+	let display_notifications = interval(Duration::from_millis(5000))
+		.filter_map(|_| async {
+			let net_status = network.status().await;
+			let sync_status = syncing.status().await;
+
+			match (net_status.ok(), sync_status.ok()) {
+				(Some(net), Some(sync)) => Some((net, sync)),
+				_ => None,
+			}
+		})
+		.for_each(move |(net_status, sync_status)| {
+			let info = client_1.usage_info();
+			if let Some(ref usage) = info.usage {
+				trace!(target: "usage", "Usage statistics: {}", usage);
+			} else {
+				trace!(
+					target: "usage",
+					"Usage statistics not displayed as backend does not provide it",
+				)
+			}
+			display.display(&info, net_status, sync_status);
+			future::ready(())
+		});
+
+	futures::select! {
+		() = display_notifications.fuse() => (),
+		() = display_block_import(client).fuse() => (),
+	};
+}
+
+fn display_block_import<B: BlockT, C>(client: Arc<C>) -> impl Future<Output = ()>
+where
+	C: UsageProvider<B> + HeaderMetadata<B> + BlockchainEvents<B>,
+	<C as HeaderMetadata<B>>::Error: Display,
+{
+	let mut last_best = {
+		let info = client.usage_info();
+		Some((info.chain.best_number, info.chain.best_hash))
+	};
+
+	// Hashes of the last blocks we have seen at import.
+	let mut last_blocks = VecDeque::new();
+	let max_blocks_to_track = 100;
+
+	client.import_notification_stream().for_each(move |n| {
+		// detect and log reorganizations.
+		if let Some((ref last_num, ref last_hash)) = last_best {
+			if n.header.parent_hash() != last_hash && n.is_new_best {
+				let maybe_ancestor =
+					sp_blockchain::lowest_common_ancestor(&*client, *last_hash, n.hash);
+
+				match maybe_ancestor {
+					Ok(ref ancestor) if ancestor.hash != *last_hash => info!(
+						"♻�  Reorg on #{},{} to #{},{}, common ancestor #{},{}",
+						Colour::Red.bold().paint(format!("{}", last_num)),
+						last_hash,
+						Colour::Green.bold().paint(format!("{}", n.header.number())),
+						n.hash,
+						Colour::White.bold().paint(format!("{}", ancestor.number)),
+						ancestor.hash,
+					),
+					Ok(_) => {},
+					Err(e) => debug!("Error computing tree route: {}", e),
+				}
+			}
+		}
+
+		if n.is_new_best {
+			last_best = Some((*n.header.number(), n.hash));
+		}
+
+		// If we already printed a message for a given block recently,
+		// we should not print it again.
+		if !last_blocks.contains(&n.hash) {
+			last_blocks.push_back(n.hash);
+
+			if last_blocks.len() > max_blocks_to_track {
+				last_blocks.pop_front();
+			}
+
+			info!(
+				target: "substrate",
+				"✨ Imported #{} ({})",
+				Colour::White.bold().paint(format!("{}", n.header.number())),
+				n.hash,
+			);
+		}
+
+		future::ready(())
+	})
+}
diff --git a/substrate/client/keystore/Cargo.toml b/substrate/client/keystore/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b5af0bc90343a44506e16c1285dafcb5352caf6d
--- /dev/null
+++ b/substrate/client/keystore/Cargo.toml
@@ -0,0 +1,43 @@
+[package]
+name = "sc-keystore"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Keystore (and session key management) for ed25519 based chains like Polkadot."
+documentation = "https://docs.rs/sc-keystore"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+parking_lot = "0.12.1"
+serde_json = "1.0.85"
+thiserror = "1.0"
+sp-application-crypto = { version = "23.0.0", path = "../../primitives/application-crypto" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+
+[dev-dependencies]
+tempfile = "3.1.0"
+
+[features]
+# This feature adds BLS crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bls-experimental = [
+	"sp-core/bls-experimental",
+	"sp-keystore/bls-experimental",
+]
+
+# This feature adds Bandersnatch crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bandersnatch-experimental = [
+	"sp-core/bandersnatch-experimental",
+	"sp-keystore/bandersnatch-experimental",
+]
diff --git a/substrate/client/keystore/README.md b/substrate/client/keystore/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9946a61d6fde65e8c0988d03c6d3e34b9d3d7bfb
--- /dev/null
+++ b/substrate/client/keystore/README.md
@@ -0,0 +1,3 @@
+Keystore (and session key management) for ed25519 based chains like Polkadot.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/keystore/src/lib.rs b/substrate/client/keystore/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2d353f3ceba5d715d7c9b01e9a1f04e7a9a86c4e
--- /dev/null
+++ b/substrate/client/keystore/src/lib.rs
@@ -0,0 +1,74 @@
+// 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/>.
+
+//! Keystore (and session key management) for ed25519 based chains like Polkadot.
+
+#![warn(missing_docs)]
+use sp_core::crypto::KeyTypeId;
+use sp_keystore::Error as TraitError;
+use std::io;
+
+/// Local keystore implementation
+mod local;
+pub use local::LocalKeystore;
+pub use sp_keystore::Keystore;
+
+/// Keystore error.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// IO error.
+	#[error(transparent)]
+	Io(#[from] io::Error),
+	/// JSON error.
+	#[error(transparent)]
+	Json(#[from] serde_json::Error),
+	/// Invalid password.
+	#[error(
+		"Requested public key and public key of the loaded private key do not match. \n
+			This means either that the keystore password is incorrect or that the private key was stored under a wrong public key."
+	)]
+	PublicKeyMismatch,
+	/// Invalid BIP39 phrase
+	#[error("Invalid recovery phrase (BIP39) data")]
+	InvalidPhrase,
+	/// Invalid seed
+	#[error("Invalid seed")]
+	InvalidSeed,
+	/// Public key type is not supported
+	#[error("Key crypto type is not supported")]
+	KeyNotSupported(KeyTypeId),
+	/// Keystore unavailable
+	#[error("Keystore unavailable")]
+	Unavailable,
+}
+
+/// Keystore Result
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl From<Error> for TraitError {
+	fn from(error: Error) -> Self {
+		match error {
+			Error::KeyNotSupported(id) => TraitError::KeyNotSupported(id),
+			Error::InvalidSeed | Error::InvalidPhrase | Error::PublicKeyMismatch =>
+				TraitError::ValidationError(error.to_string()),
+			Error::Unavailable => TraitError::Unavailable,
+			Error::Io(e) => TraitError::Other(e.to_string()),
+			Error::Json(e) => TraitError::Other(e.to_string()),
+		}
+	}
+}
diff --git a/substrate/client/keystore/src/local.rs b/substrate/client/keystore/src/local.rs
new file mode 100644
index 0000000000000000000000000000000000000000..97bc7c71a4a58a9ee317f075e79a5df740ec6093
--- /dev/null
+++ b/substrate/client/keystore/src/local.rs
@@ -0,0 +1,797 @@
+// 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.
+//
+//! Local keystore implementation
+
+use parking_lot::RwLock;
+use sp_application_crypto::{AppCrypto, AppPair, IsWrappedBy};
+#[cfg(feature = "bandersnatch-experimental")]
+use sp_core::bandersnatch;
+#[cfg(feature = "bls-experimental")]
+use sp_core::{bls377, bls381};
+use sp_core::{
+	crypto::{ByteArray, ExposeSecret, KeyTypeId, Pair as CorePair, SecretString, VrfSecret},
+	ecdsa, ed25519, sr25519,
+};
+use sp_keystore::{Error as TraitError, Keystore, KeystorePtr};
+use std::{
+	collections::HashMap,
+	fs::{self, File},
+	io::Write,
+	path::PathBuf,
+	sync::Arc,
+};
+
+use crate::{Error, Result};
+
+/// A local based keystore that is either memory-based or filesystem-based.
+pub struct LocalKeystore(RwLock<KeystoreInner>);
+
+impl LocalKeystore {
+	/// Create a local keystore from filesystem.
+	pub fn open<T: Into<PathBuf>>(path: T, password: Option<SecretString>) -> Result<Self> {
+		let inner = KeystoreInner::open(path, password)?;
+		Ok(Self(RwLock::new(inner)))
+	}
+
+	/// Create a local keystore in memory.
+	pub fn in_memory() -> Self {
+		let inner = KeystoreInner::new_in_memory();
+		Self(RwLock::new(inner))
+	}
+
+	/// Get a key pair for the given public key.
+	///
+	/// Returns `Ok(None)` if the key doesn't exist, `Ok(Some(_))` if the key exists and
+	/// `Err(_)` when something failed.
+	pub fn key_pair<Pair: AppPair>(
+		&self,
+		public: &<Pair as AppCrypto>::Public,
+	) -> Result<Option<Pair>> {
+		self.0.read().key_pair::<Pair>(public)
+	}
+
+	fn public_keys<T: CorePair>(&self, key_type: KeyTypeId) -> Vec<T::Public> {
+		self.0
+			.read()
+			.raw_public_keys(key_type)
+			.map(|v| {
+				v.into_iter().filter_map(|k| T::Public::from_slice(k.as_slice()).ok()).collect()
+			})
+			.unwrap_or_default()
+	}
+
+	fn generate_new<T: CorePair>(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> std::result::Result<T::Public, TraitError> {
+		let pair = match seed {
+			Some(seed) => self.0.write().insert_ephemeral_from_seed_by_type::<T>(seed, key_type),
+			None => self.0.write().generate_by_type::<T>(key_type),
+		}
+		.map_err(|e| -> TraitError { e.into() })?;
+		Ok(pair.public())
+	}
+
+	fn sign<T: CorePair>(
+		&self,
+		key_type: KeyTypeId,
+		public: &T::Public,
+		msg: &[u8],
+	) -> std::result::Result<Option<T::Signature>, TraitError> {
+		let signature = self
+			.0
+			.read()
+			.key_pair_by_type::<T>(public, key_type)?
+			.map(|pair| pair.sign(msg));
+		Ok(signature)
+	}
+
+	fn vrf_sign<T: CorePair + VrfSecret>(
+		&self,
+		key_type: KeyTypeId,
+		public: &T::Public,
+		data: &T::VrfSignData,
+	) -> std::result::Result<Option<T::VrfSignature>, TraitError> {
+		let sig = self
+			.0
+			.read()
+			.key_pair_by_type::<T>(public, key_type)?
+			.map(|pair| pair.vrf_sign(data));
+		Ok(sig)
+	}
+
+	fn vrf_output<T: CorePair + VrfSecret>(
+		&self,
+		key_type: KeyTypeId,
+		public: &T::Public,
+		input: &T::VrfInput,
+	) -> std::result::Result<Option<T::VrfOutput>, TraitError> {
+		let preout = self
+			.0
+			.read()
+			.key_pair_by_type::<T>(public, key_type)?
+			.map(|pair| pair.vrf_output(input));
+		Ok(preout)
+	}
+}
+
+impl Keystore for LocalKeystore {
+	fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<sr25519::Public> {
+		self.public_keys::<sr25519::Pair>(key_type)
+	}
+
+	/// Generate a new pair compatible with the 'ed25519' signature scheme.
+	///
+	/// If `[seed]` is `Some` then the key will be ephemeral and stored in memory.
+	fn sr25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> std::result::Result<sr25519::Public, TraitError> {
+		self.generate_new::<sr25519::Pair>(key_type, seed)
+	}
+
+	fn sr25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		msg: &[u8],
+	) -> std::result::Result<Option<sr25519::Signature>, TraitError> {
+		self.sign::<sr25519::Pair>(key_type, public, msg)
+	}
+
+	fn sr25519_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		data: &sr25519::vrf::VrfSignData,
+	) -> std::result::Result<Option<sr25519::vrf::VrfSignature>, TraitError> {
+		self.vrf_sign::<sr25519::Pair>(key_type, public, data)
+	}
+
+	fn sr25519_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		input: &sr25519::vrf::VrfInput,
+	) -> std::result::Result<Option<sr25519::vrf::VrfOutput>, TraitError> {
+		self.vrf_output::<sr25519::Pair>(key_type, public, input)
+	}
+
+	fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<ed25519::Public> {
+		self.public_keys::<ed25519::Pair>(key_type)
+	}
+
+	/// Generate a new pair compatible with the 'sr25519' signature scheme.
+	///
+	/// If `[seed]` is `Some` then the key will be ephemeral and stored in memory.
+	fn ed25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> std::result::Result<ed25519::Public, TraitError> {
+		self.generate_new::<ed25519::Pair>(key_type, seed)
+	}
+
+	fn ed25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ed25519::Public,
+		msg: &[u8],
+	) -> std::result::Result<Option<ed25519::Signature>, TraitError> {
+		self.sign::<ed25519::Pair>(key_type, public, msg)
+	}
+
+	fn ecdsa_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa::Public> {
+		self.public_keys::<ecdsa::Pair>(key_type)
+	}
+
+	/// Generate a new pair compatible with the 'ecdsa' signature scheme.
+	///
+	/// If `[seed]` is `Some` then the key will be ephemeral and stored in memory.
+	fn ecdsa_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> std::result::Result<ecdsa::Public, TraitError> {
+		self.generate_new::<ecdsa::Pair>(key_type, seed)
+	}
+
+	fn ecdsa_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8],
+	) -> std::result::Result<Option<ecdsa::Signature>, TraitError> {
+		self.sign::<ecdsa::Pair>(key_type, public, msg)
+	}
+
+	fn ecdsa_sign_prehashed(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8; 32],
+	) -> std::result::Result<Option<ecdsa::Signature>, TraitError> {
+		let sig = self
+			.0
+			.read()
+			.key_pair_by_type::<ecdsa::Pair>(public, key_type)?
+			.map(|pair| pair.sign_prehashed(msg));
+		Ok(sig)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_public_keys(&self, key_type: KeyTypeId) -> Vec<bandersnatch::Public> {
+		self.public_keys::<bandersnatch::Pair>(key_type)
+	}
+
+	/// Generate a new pair compatible with the 'bandersnatch' signature scheme.
+	///
+	/// If `[seed]` is `Some` then the key will be ephemeral and stored in memory.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> std::result::Result<bandersnatch::Public, TraitError> {
+		self.generate_new::<bandersnatch::Pair>(key_type, seed)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		msg: &[u8],
+	) -> std::result::Result<Option<bandersnatch::Signature>, TraitError> {
+		self.sign::<bandersnatch::Pair>(key_type, public, msg)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		data: &bandersnatch::vrf::VrfSignData,
+	) -> std::result::Result<Option<bandersnatch::vrf::VrfSignature>, TraitError> {
+		self.vrf_sign::<bandersnatch::Pair>(key_type, public, data)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfInput,
+	) -> std::result::Result<Option<bandersnatch::vrf::VrfOutput>, TraitError> {
+		self.vrf_output::<bandersnatch::Pair>(key_type, public, input)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_ring_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		data: &bandersnatch::vrf::VrfSignData,
+		prover: &bandersnatch::ring_vrf::RingProver,
+	) -> std::result::Result<Option<bandersnatch::ring_vrf::RingVrfSignature>, TraitError> {
+		let sig = self
+			.0
+			.read()
+			.key_pair_by_type::<bandersnatch::Pair>(public, key_type)?
+			.map(|pair| pair.ring_vrf_sign(data, prover));
+		Ok(sig)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_public_keys(&self, key_type: KeyTypeId) -> Vec<bls381::Public> {
+		self.public_keys::<bls381::Pair>(key_type)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	/// Generate a new pair compatible with the 'bls381' signature scheme.
+	///
+	/// If `[seed]` is `Some` then the key will be ephemeral and stored in memory.
+	fn bls381_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> std::result::Result<bls381::Public, TraitError> {
+		self.generate_new::<bls381::Pair>(key_type, seed)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls381::Public,
+		msg: &[u8],
+	) -> std::result::Result<Option<bls381::Signature>, TraitError> {
+		self.sign::<bls381::Pair>(key_type, public, msg)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_public_keys(&self, key_type: KeyTypeId) -> Vec<bls377::Public> {
+		self.public_keys::<bls377::Pair>(key_type)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	/// Generate a new pair compatible with the 'bls377' signature scheme.
+	///
+	/// If `[seed]` is `Some` then the key will be ephemeral and stored in memory.
+	fn bls377_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> std::result::Result<bls377::Public, TraitError> {
+		self.generate_new::<bls377::Pair>(key_type, seed)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls377::Public,
+		msg: &[u8],
+	) -> std::result::Result<Option<bls377::Signature>, TraitError> {
+		self.sign::<bls377::Pair>(key_type, public, msg)
+	}
+
+	fn insert(
+		&self,
+		key_type: KeyTypeId,
+		suri: &str,
+		public: &[u8],
+	) -> std::result::Result<(), ()> {
+		self.0.write().insert(key_type, suri, public).map_err(|_| ())
+	}
+
+	fn keys(&self, key_type: KeyTypeId) -> std::result::Result<Vec<Vec<u8>>, TraitError> {
+		self.0.read().raw_public_keys(key_type).map_err(|e| e.into())
+	}
+
+	fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool {
+		public_keys
+			.iter()
+			.all(|(p, t)| self.0.read().key_phrase_by_type(p, *t).ok().flatten().is_some())
+	}
+}
+
+impl Into<KeystorePtr> for LocalKeystore {
+	fn into(self) -> KeystorePtr {
+		Arc::new(self)
+	}
+}
+
+/// A local key store.
+///
+/// Stores key pairs in a file system store + short lived key pairs in memory.
+///
+/// Every pair that is being generated by a `seed`, will be placed in memory.
+struct KeystoreInner {
+	path: Option<PathBuf>,
+	/// Map over `(KeyTypeId, Raw public key)` -> `Key phrase/seed`
+	additional: HashMap<(KeyTypeId, Vec<u8>), String>,
+	password: Option<SecretString>,
+}
+
+impl KeystoreInner {
+	/// Open the store at the given path.
+	///
+	/// Optionally takes a password that will be used to encrypt/decrypt the keys.
+	fn open<T: Into<PathBuf>>(path: T, password: Option<SecretString>) -> Result<Self> {
+		let path = path.into();
+		fs::create_dir_all(&path)?;
+
+		Ok(Self { path: Some(path), additional: HashMap::new(), password })
+	}
+
+	/// Get the password for this store.
+	fn password(&self) -> Option<&str> {
+		self.password.as_ref().map(|p| p.expose_secret()).map(|p| p.as_str())
+	}
+
+	/// Create a new in-memory store.
+	fn new_in_memory() -> Self {
+		Self { path: None, additional: HashMap::new(), password: None }
+	}
+
+	/// Get the key phrase for the given public key and key type from the in-memory store.
+	fn get_additional_pair(&self, public: &[u8], key_type: KeyTypeId) -> Option<&String> {
+		let key = (key_type, public.to_vec());
+		self.additional.get(&key)
+	}
+
+	/// Insert the given public/private key pair with the given key type.
+	///
+	/// Does not place it into the file system store.
+	fn insert_ephemeral_pair<Pair: CorePair>(
+		&mut self,
+		pair: &Pair,
+		seed: &str,
+		key_type: KeyTypeId,
+	) {
+		let key = (key_type, pair.public().to_raw_vec());
+		self.additional.insert(key, seed.into());
+	}
+
+	/// Insert a new key with anonymous crypto.
+	///
+	/// Places it into the file system store, if a path is configured.
+	fn insert(&self, key_type: KeyTypeId, suri: &str, public: &[u8]) -> Result<()> {
+		if let Some(path) = self.key_file_path(public, key_type) {
+			Self::write_to_file(path, suri)?;
+		}
+
+		Ok(())
+	}
+
+	/// Generate a new key.
+	///
+	/// Places it into the file system store, if a path is configured. Otherwise insert
+	/// it into the memory cache only.
+	fn generate_by_type<Pair: CorePair>(&mut self, key_type: KeyTypeId) -> Result<Pair> {
+		let (pair, phrase, _) = Pair::generate_with_phrase(self.password());
+		if let Some(path) = self.key_file_path(pair.public().as_slice(), key_type) {
+			Self::write_to_file(path, &phrase)?;
+		} else {
+			self.insert_ephemeral_pair(&pair, &phrase, key_type);
+		}
+
+		Ok(pair)
+	}
+
+	/// Write the given `data` to `file`.
+	fn write_to_file(file: PathBuf, data: &str) -> Result<()> {
+		let mut file = File::create(file)?;
+
+		#[cfg(target_family = "unix")]
+		{
+			use std::os::unix::fs::PermissionsExt;
+			file.set_permissions(fs::Permissions::from_mode(0o600))?;
+		}
+
+		serde_json::to_writer(&file, data)?;
+		file.flush()?;
+		Ok(())
+	}
+
+	/// Create a new key from seed.
+	///
+	/// Does not place it into the file system store.
+	fn insert_ephemeral_from_seed_by_type<Pair: CorePair>(
+		&mut self,
+		seed: &str,
+		key_type: KeyTypeId,
+	) -> Result<Pair> {
+		let pair = Pair::from_string(seed, None).map_err(|_| Error::InvalidSeed)?;
+		self.insert_ephemeral_pair(&pair, seed, key_type);
+		Ok(pair)
+	}
+
+	/// Get the key phrase for a given public key and key type.
+	fn key_phrase_by_type(&self, public: &[u8], key_type: KeyTypeId) -> Result<Option<String>> {
+		if let Some(phrase) = self.get_additional_pair(public, key_type) {
+			return Ok(Some(phrase.clone()))
+		}
+
+		let path = if let Some(path) = self.key_file_path(public, key_type) {
+			path
+		} else {
+			return Ok(None)
+		};
+
+		if path.exists() {
+			let file = File::open(path)?;
+
+			serde_json::from_reader(&file).map_err(Into::into).map(Some)
+		} else {
+			Ok(None)
+		}
+	}
+
+	/// Get a key pair for the given public key and key type.
+	fn key_pair_by_type<Pair: CorePair>(
+		&self,
+		public: &Pair::Public,
+		key_type: KeyTypeId,
+	) -> Result<Option<Pair>> {
+		let phrase = if let Some(p) = self.key_phrase_by_type(public.as_slice(), key_type)? {
+			p
+		} else {
+			return Ok(None)
+		};
+
+		let pair = Pair::from_string(&phrase, self.password()).map_err(|_| Error::InvalidPhrase)?;
+
+		if &pair.public() == public {
+			Ok(Some(pair))
+		} else {
+			Err(Error::PublicKeyMismatch)
+		}
+	}
+
+	/// Get the file path for the given public key and key type.
+	///
+	/// Returns `None` if the keystore only exists in-memory and there isn't any path to provide.
+	fn key_file_path(&self, public: &[u8], key_type: KeyTypeId) -> Option<PathBuf> {
+		let mut buf = self.path.as_ref()?.clone();
+		let key_type = array_bytes::bytes2hex("", &key_type.0);
+		let key = array_bytes::bytes2hex("", public);
+		buf.push(key_type + key.as_str());
+		Some(buf)
+	}
+
+	/// Returns a list of raw public keys filtered by `KeyTypeId`
+	fn raw_public_keys(&self, key_type: KeyTypeId) -> Result<Vec<Vec<u8>>> {
+		let mut public_keys: Vec<Vec<u8>> = self
+			.additional
+			.keys()
+			.into_iter()
+			.filter_map(|k| if k.0 == key_type { Some(k.1.clone()) } else { None })
+			.collect();
+
+		if let Some(path) = &self.path {
+			for entry in fs::read_dir(&path)? {
+				let entry = entry?;
+				let path = entry.path();
+
+				// skip directories and non-unicode file names (hex is unicode)
+				if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
+					match array_bytes::hex2bytes(name) {
+						Ok(ref hex) if hex.len() > 4 => {
+							if hex[0..4] != key_type.0 {
+								continue
+							}
+							let public = hex[4..].to_vec();
+							public_keys.push(public);
+						},
+						_ => continue,
+					}
+				}
+			}
+		}
+
+		Ok(public_keys)
+	}
+
+	/// Get a key pair for the given public key.
+	///
+	/// Returns `Ok(None)` if the key doesn't exist, `Ok(Some(_))` if the key exists or `Err(_)`
+	/// when something failed.
+	pub fn key_pair<Pair: AppPair>(
+		&self,
+		public: &<Pair as AppCrypto>::Public,
+	) -> Result<Option<Pair>> {
+		self.key_pair_by_type::<Pair::Generic>(IsWrappedBy::from_ref(public), Pair::ID)
+			.map(|v| v.map(Into::into))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_application_crypto::{ed25519, sr25519, AppPublic};
+	use sp_core::{crypto::Ss58Codec, testing::SR25519, Pair};
+	use std::{fs, str::FromStr};
+	use tempfile::TempDir;
+
+	const TEST_KEY_TYPE: KeyTypeId = KeyTypeId(*b"test");
+
+	impl KeystoreInner {
+		fn insert_ephemeral_from_seed<Pair: AppPair>(&mut self, seed: &str) -> Result<Pair> {
+			self.insert_ephemeral_from_seed_by_type::<Pair::Generic>(seed, Pair::ID)
+				.map(Into::into)
+		}
+
+		fn public_keys<Public: AppPublic>(&self) -> Result<Vec<Public>> {
+			self.raw_public_keys(Public::ID).map(|v| {
+				v.into_iter().filter_map(|k| Public::from_slice(k.as_slice()).ok()).collect()
+			})
+		}
+
+		fn generate<Pair: AppPair>(&mut self) -> Result<Pair> {
+			self.generate_by_type::<Pair::Generic>(Pair::ID).map(Into::into)
+		}
+	}
+
+	#[test]
+	fn basic_store() {
+		let temp_dir = TempDir::new().unwrap();
+		let mut store = KeystoreInner::open(temp_dir.path(), None).unwrap();
+
+		assert!(store.public_keys::<ed25519::AppPublic>().unwrap().is_empty());
+
+		let key: ed25519::AppPair = store.generate().unwrap();
+		let key2: ed25519::AppPair = store.key_pair(&key.public()).unwrap().unwrap();
+
+		assert_eq!(key.public(), key2.public());
+
+		assert_eq!(store.public_keys::<ed25519::AppPublic>().unwrap()[0], key.public());
+	}
+
+	#[test]
+	fn has_keys_works() {
+		let temp_dir = TempDir::new().unwrap();
+		let store = LocalKeystore::open(temp_dir.path(), None).unwrap();
+
+		let key: ed25519::AppPair = store.0.write().generate().unwrap();
+		let key2 = ed25519::Pair::generate().0;
+
+		assert!(!store.has_keys(&[(key2.public().to_vec(), ed25519::AppPublic::ID)]));
+
+		assert!(!store.has_keys(&[
+			(key2.public().to_vec(), ed25519::AppPublic::ID),
+			(key.public().to_raw_vec(), ed25519::AppPublic::ID),
+		],));
+
+		assert!(store.has_keys(&[(key.public().to_raw_vec(), ed25519::AppPublic::ID)]));
+	}
+
+	#[test]
+	fn test_insert_ephemeral_from_seed() {
+		let temp_dir = TempDir::new().unwrap();
+		let mut store = KeystoreInner::open(temp_dir.path(), None).unwrap();
+
+		let pair: ed25519::AppPair = store
+			.insert_ephemeral_from_seed(
+				"0x3d97c819d68f9bafa7d6e79cb991eebcd77d966c5334c0b94d9e1fa7ad0869dc",
+			)
+			.unwrap();
+		assert_eq!(
+			"5DKUrgFqCPV8iAXx9sjy1nyBygQCeiUYRFWurZGhnrn3HJCA",
+			pair.public().to_ss58check()
+		);
+
+		drop(store);
+		let store = KeystoreInner::open(temp_dir.path(), None).unwrap();
+		// Keys generated from seed should not be persisted!
+		assert!(store.key_pair::<ed25519::AppPair>(&pair.public()).unwrap().is_none());
+	}
+
+	#[test]
+	fn password_being_used() {
+		let password = String::from("password");
+		let temp_dir = TempDir::new().unwrap();
+		let mut store = KeystoreInner::open(
+			temp_dir.path(),
+			Some(FromStr::from_str(password.as_str()).unwrap()),
+		)
+		.unwrap();
+
+		let pair: ed25519::AppPair = store.generate().unwrap();
+		assert_eq!(
+			pair.public(),
+			store.key_pair::<ed25519::AppPair>(&pair.public()).unwrap().unwrap().public(),
+		);
+
+		// Without the password the key should not be retrievable
+		let store = KeystoreInner::open(temp_dir.path(), None).unwrap();
+		assert!(store.key_pair::<ed25519::AppPair>(&pair.public()).is_err());
+
+		let store = KeystoreInner::open(
+			temp_dir.path(),
+			Some(FromStr::from_str(password.as_str()).unwrap()),
+		)
+		.unwrap();
+		assert_eq!(
+			pair.public(),
+			store.key_pair::<ed25519::AppPair>(&pair.public()).unwrap().unwrap().public(),
+		);
+	}
+
+	#[test]
+	fn public_keys_are_returned() {
+		let temp_dir = TempDir::new().unwrap();
+		let mut store = KeystoreInner::open(temp_dir.path(), None).unwrap();
+
+		let mut keys = Vec::new();
+		for i in 0..10 {
+			keys.push(store.generate::<ed25519::AppPair>().unwrap().public());
+			keys.push(
+				store
+					.insert_ephemeral_from_seed::<ed25519::AppPair>(&format!(
+						"0x3d97c819d68f9bafa7d6e79cb991eebcd7{}d966c5334c0b94d9e1fa7ad0869dc",
+						i
+					))
+					.unwrap()
+					.public(),
+			);
+		}
+
+		// Generate a key of a different type
+		store.generate::<sr25519::AppPair>().unwrap();
+
+		keys.sort();
+		let mut store_pubs = store.public_keys::<ed25519::AppPublic>().unwrap();
+		store_pubs.sort();
+
+		assert_eq!(keys, store_pubs);
+	}
+
+	#[test]
+	fn store_unknown_and_extract_it() {
+		let temp_dir = TempDir::new().unwrap();
+		let store = KeystoreInner::open(temp_dir.path(), None).unwrap();
+
+		let secret_uri = "//Alice";
+		let key_pair = sr25519::AppPair::from_string(secret_uri, None).expect("Generates key pair");
+
+		store
+			.insert(SR25519, secret_uri, key_pair.public().as_ref())
+			.expect("Inserts unknown key");
+
+		let store_key_pair = store
+			.key_pair_by_type::<sr25519::AppPair>(&key_pair.public(), SR25519)
+			.expect("Gets key pair from keystore")
+			.unwrap();
+
+		assert_eq!(key_pair.public(), store_key_pair.public());
+	}
+
+	#[test]
+	fn store_ignores_files_with_invalid_name() {
+		let temp_dir = TempDir::new().unwrap();
+		let store = LocalKeystore::open(temp_dir.path(), None).unwrap();
+
+		let file_name = temp_dir.path().join(array_bytes::bytes2hex("", &SR25519.0[..2]));
+		fs::write(file_name, "test").expect("Invalid file is written");
+
+		assert!(store.sr25519_public_keys(SR25519).is_empty());
+	}
+
+	#[test]
+	fn generate_with_seed_is_not_stored() {
+		let temp_dir = TempDir::new().unwrap();
+		let store = LocalKeystore::open(temp_dir.path(), None).unwrap();
+		let _alice_tmp_key = store.sr25519_generate_new(TEST_KEY_TYPE, Some("//Alice")).unwrap();
+
+		assert_eq!(store.sr25519_public_keys(TEST_KEY_TYPE).len(), 1);
+
+		drop(store);
+		let store = LocalKeystore::open(temp_dir.path(), None).unwrap();
+		assert_eq!(store.sr25519_public_keys(TEST_KEY_TYPE).len(), 0);
+	}
+
+	#[test]
+	fn generate_can_be_fetched_in_memory() {
+		let store = LocalKeystore::in_memory();
+		store.sr25519_generate_new(TEST_KEY_TYPE, Some("//Alice")).unwrap();
+
+		assert_eq!(store.sr25519_public_keys(TEST_KEY_TYPE).len(), 1);
+		store.sr25519_generate_new(TEST_KEY_TYPE, None).unwrap();
+		assert_eq!(store.sr25519_public_keys(TEST_KEY_TYPE).len(), 2);
+	}
+
+	#[test]
+	#[cfg(target_family = "unix")]
+	fn uses_correct_file_permissions_on_unix() {
+		use std::os::unix::fs::PermissionsExt;
+
+		let temp_dir = TempDir::new().unwrap();
+		let store = LocalKeystore::open(temp_dir.path(), None).unwrap();
+
+		let public = store.sr25519_generate_new(TEST_KEY_TYPE, None).unwrap();
+
+		let path = store.0.read().key_file_path(public.as_ref(), TEST_KEY_TYPE).unwrap();
+		let permissions = File::open(path).unwrap().metadata().unwrap().permissions();
+
+		assert_eq!(0o100600, permissions.mode());
+	}
+}
diff --git a/substrate/client/merkle-mountain-range/Cargo.toml b/substrate/client/merkle-mountain-range/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7270cfbda016948ba6bde49fd6423eb2bf68628b
--- /dev/null
+++ b/substrate/client/merkle-mountain-range/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "mmr-gadget"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+repository = "https://github.com/paritytech/substrate"
+description = "MMR Client gadget for substrate"
+homepage = "https://substrate.io"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3"
+log = "0.4"
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sp-consensus-beefy = { version = "4.0.0-dev", path = "../../primitives/consensus/beefy" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-mmr-primitives = { version = "4.0.0-dev", path = "../../primitives/merkle-mountain-range" }
+sc-offchain = { version = "4.0.0-dev", path = "../offchain" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+
+[dev-dependencies]
+parking_lot = "0.12.1"
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+tokio = "1.17.0"
diff --git a/substrate/client/merkle-mountain-range/rpc/Cargo.toml b/substrate/client/merkle-mountain-range/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c6f8652c7e8436e9df71e736987e94adba82da59
--- /dev/null
+++ b/substrate/client/merkle-mountain-range/rpc/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "mmr-rpc"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Node-specific RPC methods for interaction with Merkle Mountain Range pallet."
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+serde = { version = "1.0.163", features = ["derive"] }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-mmr-primitives = { version = "4.0.0-dev", path = "../../../primitives/merkle-mountain-range" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+anyhow = "1"
+
+[dev-dependencies]
+serde_json = "1.0.85"
diff --git a/substrate/client/merkle-mountain-range/rpc/src/lib.rs b/substrate/client/merkle-mountain-range/rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5be82b600d91425589df1b0e9638067f1c636b25
--- /dev/null
+++ b/substrate/client/merkle-mountain-range/rpc/src/lib.rs
@@ -0,0 +1,355 @@
+// 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.
+
+#![warn(missing_docs)]
+#![warn(unused_crate_dependencies)]
+
+//! Node-specific RPC methods for interaction with Merkle Mountain Range pallet.
+
+use std::{marker::PhantomData, sync::Arc};
+
+use codec::{Codec, Decode, Encode};
+use jsonrpsee::{
+	core::{async_trait, RpcResult},
+	proc_macros::rpc,
+	types::error::{CallError, ErrorObject},
+};
+use serde::{Deserialize, Serialize};
+
+use sp_api::{ApiExt, NumberFor, ProvideRuntimeApi};
+use sp_blockchain::HeaderBackend;
+use sp_core::{
+	offchain::{storage::OffchainDb, OffchainDbExt, OffchainStorage},
+	Bytes,
+};
+use sp_mmr_primitives::{Error as MmrError, Proof};
+use sp_runtime::traits::Block as BlockT;
+
+pub use sp_mmr_primitives::MmrApi as MmrRuntimeApi;
+
+const RUNTIME_ERROR: i32 = 8000;
+const MMR_ERROR: i32 = 8010;
+
+/// Retrieved MMR leaves and their proof.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct LeavesProof<BlockHash> {
+	/// Block hash the proof was generated for.
+	pub block_hash: BlockHash,
+	/// SCALE-encoded vector of `LeafData`.
+	pub leaves: Bytes,
+	/// SCALE-encoded proof data. See [sp_mmr_primitives::Proof].
+	pub proof: Bytes,
+}
+
+impl<BlockHash> LeavesProof<BlockHash> {
+	/// Create new `LeavesProof` from a given vector of `Leaf` and a
+	/// [sp_mmr_primitives::Proof].
+	pub fn new<Leaf, MmrHash>(
+		block_hash: BlockHash,
+		leaves: Vec<Leaf>,
+		proof: Proof<MmrHash>,
+	) -> Self
+	where
+		Leaf: Encode,
+		MmrHash: Encode,
+	{
+		Self { block_hash, leaves: Bytes(leaves.encode()), proof: Bytes(proof.encode()) }
+	}
+}
+
+/// MMR RPC methods.
+#[rpc(client, server)]
+pub trait MmrApi<BlockHash, BlockNumber, MmrHash> {
+	/// Get the MMR root hash for the current best block.
+	#[method(name = "mmr_root")]
+	fn mmr_root(&self, at: Option<BlockHash>) -> RpcResult<MmrHash>;
+
+	/// Generate an MMR proof for the given `block_numbers`.
+	///
+	/// This method calls into a runtime with MMR pallet included and attempts to generate
+	/// an MMR proof for the set of blocks that have the given `block_numbers` with the MMR root at
+	/// `best_known_block_number`. `best_known_block_number` must be larger than all the
+	/// `block_numbers` for the function to succeed.
+	///
+	/// Optionally via `at`, a block hash at which the runtime should be queried can be specified.
+	/// Optionally via `best_known_block_number`, the proof can be generated using the MMR's state
+	/// at a specific best block. Note that if `best_known_block_number` is provided, then also
+	/// specifying the block hash via `at` isn't super-useful here, unless you're generating proof
+	/// using non-finalized blocks where there are several competing forks. That's because MMR state
+	/// will be fixed to the state with `best_known_block_number`, which already points to
+	/// some historical block.
+	///
+	/// Returns the (full) leaves and a proof for these leaves (compact encoding, i.e. hash of
+	/// the leaves). Both parameters are SCALE-encoded.
+	/// The order of entries in the `leaves` field of the returned struct
+	/// is the same as the order of the entries in `block_numbers` supplied
+	#[method(name = "mmr_generateProof")]
+	fn generate_proof(
+		&self,
+		block_numbers: Vec<BlockNumber>,
+		best_known_block_number: Option<BlockNumber>,
+		at: Option<BlockHash>,
+	) -> RpcResult<LeavesProof<BlockHash>>;
+
+	/// Verify an MMR `proof`.
+	///
+	/// This method calls into a runtime with MMR pallet included and attempts to verify
+	/// an MMR proof.
+	///
+	/// Returns `true` if the proof is valid, else returns the verification error.
+	#[method(name = "mmr_verifyProof")]
+	fn verify_proof(&self, proof: LeavesProof<BlockHash>) -> RpcResult<bool>;
+
+	/// Verify an MMR `proof` statelessly given an `mmr_root`.
+	///
+	/// This method calls into a runtime with MMR pallet included and attempts to verify
+	/// an MMR proof against a provided MMR root.
+	///
+	/// Returns `true` if the proof is valid, else returns the verification error.
+	#[method(name = "mmr_verifyProofStateless")]
+	fn verify_proof_stateless(
+		&self,
+		mmr_root: MmrHash,
+		proof: LeavesProof<BlockHash>,
+	) -> RpcResult<bool>;
+}
+
+/// MMR RPC methods.
+pub struct Mmr<Client, Block, S> {
+	client: Arc<Client>,
+	offchain_db: OffchainDb<S>,
+	_marker: PhantomData<Block>,
+}
+
+impl<C, B, S> Mmr<C, B, S> {
+	/// Create new `Mmr` with the given reference to the client.
+	pub fn new(client: Arc<C>, offchain_storage: S) -> Self {
+		Self { client, _marker: Default::default(), offchain_db: OffchainDb::new(offchain_storage) }
+	}
+}
+
+#[async_trait]
+impl<Client, Block, MmrHash, S> MmrApiServer<<Block as BlockT>::Hash, NumberFor<Block>, MmrHash>
+	for Mmr<Client, (Block, MmrHash), S>
+where
+	Block: BlockT,
+	Client: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
+	Client::Api: MmrRuntimeApi<Block, MmrHash, NumberFor<Block>>,
+	MmrHash: Codec + Send + Sync + 'static,
+	S: OffchainStorage + 'static,
+{
+	fn mmr_root(&self, at: Option<<Block as BlockT>::Hash>) -> RpcResult<MmrHash> {
+		let block_hash = at.unwrap_or_else(||
+			// If the block hash is not supplied assume the best block.
+			self.client.info().best_hash);
+		let api = self.client.runtime_api();
+		let mmr_root = api
+			.mmr_root(block_hash)
+			.map_err(runtime_error_into_rpc_error)?
+			.map_err(mmr_error_into_rpc_error)?;
+		Ok(mmr_root)
+	}
+
+	fn generate_proof(
+		&self,
+		block_numbers: Vec<NumberFor<Block>>,
+		best_known_block_number: Option<NumberFor<Block>>,
+		at: Option<<Block as BlockT>::Hash>,
+	) -> RpcResult<LeavesProof<<Block as BlockT>::Hash>> {
+		let mut api = self.client.runtime_api();
+		let block_hash = at.unwrap_or_else(||
+			// If the block hash is not supplied assume the best block.
+			self.client.info().best_hash);
+
+		api.register_extension(OffchainDbExt::new(self.offchain_db.clone()));
+
+		let (leaves, proof) = api
+			.generate_proof(block_hash, block_numbers, best_known_block_number)
+			.map_err(runtime_error_into_rpc_error)?
+			.map_err(mmr_error_into_rpc_error)?;
+
+		Ok(LeavesProof::new(block_hash, leaves, proof))
+	}
+
+	fn verify_proof(&self, proof: LeavesProof<<Block as BlockT>::Hash>) -> RpcResult<bool> {
+		let mut api = self.client.runtime_api();
+
+		let leaves = Decode::decode(&mut &proof.leaves.0[..])
+			.map_err(|e| CallError::InvalidParams(anyhow::Error::new(e)))?;
+
+		let decoded_proof = Decode::decode(&mut &proof.proof.0[..])
+			.map_err(|e| CallError::InvalidParams(anyhow::Error::new(e)))?;
+
+		api.register_extension(OffchainDbExt::new(self.offchain_db.clone()));
+
+		api.verify_proof(proof.block_hash, leaves, decoded_proof)
+			.map_err(runtime_error_into_rpc_error)?
+			.map_err(mmr_error_into_rpc_error)?;
+
+		Ok(true)
+	}
+
+	fn verify_proof_stateless(
+		&self,
+		mmr_root: MmrHash,
+		proof: LeavesProof<<Block as BlockT>::Hash>,
+	) -> RpcResult<bool> {
+		let api = self.client.runtime_api();
+
+		let leaves = Decode::decode(&mut &proof.leaves.0[..])
+			.map_err(|e| CallError::InvalidParams(anyhow::Error::new(e)))?;
+
+		let decoded_proof = Decode::decode(&mut &proof.proof.0[..])
+			.map_err(|e| CallError::InvalidParams(anyhow::Error::new(e)))?;
+
+		api.verify_proof_stateless(proof.block_hash, mmr_root, leaves, decoded_proof)
+			.map_err(runtime_error_into_rpc_error)?
+			.map_err(mmr_error_into_rpc_error)?;
+
+		Ok(true)
+	}
+}
+
+/// Converts an mmr-specific error into a [`CallError`].
+fn mmr_error_into_rpc_error(err: MmrError) -> CallError {
+	let error_code = MMR_ERROR +
+		match err {
+			MmrError::LeafNotFound => 1,
+			MmrError::GenerateProof => 2,
+			MmrError::Verify => 3,
+			MmrError::InvalidNumericOp => 4,
+			MmrError::InvalidBestKnownBlock => 5,
+			_ => 0,
+		};
+
+	CallError::Custom(ErrorObject::owned(error_code, err.to_string(), Some(format!("{:?}", err))))
+}
+
+/// Converts a runtime trap into a [`CallError`].
+fn runtime_error_into_rpc_error(err: impl std::fmt::Debug) -> CallError {
+	CallError::Custom(ErrorObject::owned(
+		RUNTIME_ERROR,
+		"Runtime trapped",
+		Some(format!("{:?}", err)),
+	))
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::H256;
+
+	#[test]
+	fn should_serialize_leaf_proof() {
+		// given
+		let leaf = vec![1_u8, 2, 3, 4];
+		let proof = Proof {
+			leaf_indices: vec![1],
+			leaf_count: 9,
+			items: vec![H256::repeat_byte(1), H256::repeat_byte(2)],
+		};
+
+		let leaf_proof = LeavesProof::new(H256::repeat_byte(0), vec![leaf], proof);
+
+		// when
+		let actual = serde_json::to_string(&leaf_proof).unwrap();
+
+		// then
+		assert_eq!(
+			actual,
+			r#"{"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","leaves":"0x041001020304","proof":"0x04010000000000000009000000000000000801010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202"}"#
+		);
+	}
+
+	#[test]
+	fn should_serialize_leaves_proof() {
+		// given
+		let leaf_a = vec![1_u8, 2, 3, 4];
+		let leaf_b = vec![2_u8, 2, 3, 4];
+		let proof = Proof {
+			leaf_indices: vec![1, 2],
+			leaf_count: 9,
+			items: vec![H256::repeat_byte(1), H256::repeat_byte(2)],
+		};
+
+		let leaf_proof = LeavesProof::new(H256::repeat_byte(0), vec![leaf_a, leaf_b], proof);
+
+		// when
+		let actual = serde_json::to_string(&leaf_proof).unwrap();
+
+		// then
+		assert_eq!(
+			actual,
+			r#"{"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000","leaves":"0x0810010203041002020304","proof":"0x080100000000000000020000000000000009000000000000000801010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202"}"#
+		);
+	}
+
+	#[test]
+	fn should_deserialize_leaf_proof() {
+		// given
+		let expected = LeavesProof {
+			block_hash: H256::repeat_byte(0),
+			leaves: Bytes(vec![vec![1_u8, 2, 3, 4]].encode()),
+			proof: Bytes(
+				Proof {
+					leaf_indices: vec![1],
+					leaf_count: 9,
+					items: vec![H256::repeat_byte(1), H256::repeat_byte(2)],
+				}
+				.encode(),
+			),
+		};
+
+		// when
+		let actual: LeavesProof<H256> = serde_json::from_str(r#"{
+			"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000",
+			"leaves":"0x041001020304",
+			"proof":"0x04010000000000000009000000000000000801010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202"
+		}"#).unwrap();
+
+		// then
+		assert_eq!(actual, expected);
+	}
+
+	#[test]
+	fn should_deserialize_leaves_proof() {
+		// given
+		let expected = LeavesProof {
+			block_hash: H256::repeat_byte(0),
+			leaves: Bytes(vec![vec![1_u8, 2, 3, 4], vec![2_u8, 2, 3, 4]].encode()),
+			proof: Bytes(
+				Proof {
+					leaf_indices: vec![1, 2],
+					leaf_count: 9,
+					items: vec![H256::repeat_byte(1), H256::repeat_byte(2)],
+				}
+				.encode(),
+			),
+		};
+
+		// when
+		let actual: LeavesProof<H256> = serde_json::from_str(r#"{
+			"blockHash":"0x0000000000000000000000000000000000000000000000000000000000000000",
+			"leaves":"0x0810010203041002020304",
+			"proof":"0x080100000000000000020000000000000009000000000000000801010101010101010101010101010101010101010101010101010101010101010202020202020202020202020202020202020202020202020202020202020202"
+		}"#).unwrap();
+
+		// then
+		assert_eq!(actual, expected);
+	}
+}
diff --git a/substrate/client/merkle-mountain-range/src/aux_schema.rs b/substrate/client/merkle-mountain-range/src/aux_schema.rs
new file mode 100644
index 0000000000000000000000000000000000000000..436252267f1070ca98dd4fbb00787d980ee60c28
--- /dev/null
+++ b/substrate/client/merkle-mountain-range/src/aux_schema.rs
@@ -0,0 +1,238 @@
+// 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/>.
+
+//! Schema for MMR-gadget state persisted in the aux-db.
+
+use crate::LOG_TARGET;
+use codec::{Decode, Encode};
+use log::{info, trace};
+use sc_client_api::backend::AuxStore;
+use sp_blockchain::{Error as ClientError, Result as ClientResult};
+use sp_runtime::traits::{Block, NumberFor};
+
+const VERSION_KEY: &[u8] = b"mmr_auxschema_version";
+const GADGET_STATE: &[u8] = b"mmr_gadget_state";
+
+const CURRENT_VERSION: u32 = 1;
+pub(crate) type PersistedState<B> = NumberFor<B>;
+
+pub(crate) fn write_current_version<B: AuxStore>(backend: &B) -> ClientResult<()> {
+	info!(target: LOG_TARGET, "write aux schema version {:?}", CURRENT_VERSION);
+	AuxStore::insert_aux(backend, &[(VERSION_KEY, CURRENT_VERSION.encode().as_slice())], &[])
+}
+
+/// Write gadget state.
+pub(crate) fn write_gadget_state<B: Block, BE: AuxStore>(
+	backend: &BE,
+	state: &PersistedState<B>,
+) -> ClientResult<()> {
+	trace!(target: LOG_TARGET, "persisting {:?}", state);
+	backend.insert_aux(&[(GADGET_STATE, state.encode().as_slice())], &[])
+}
+
+fn load_decode<B: AuxStore, T: Decode>(backend: &B, key: &[u8]) -> ClientResult<Option<T>> {
+	match backend.get_aux(key)? {
+		None => Ok(None),
+		Some(t) => T::decode(&mut &t[..])
+			.map_err(|e| ClientError::Backend(format!("MMR aux DB is corrupted: {}", e)))
+			.map(Some),
+	}
+}
+
+/// Load persistent data from backend.
+pub(crate) fn load_state<B, BE>(backend: &BE) -> ClientResult<Option<PersistedState<B>>>
+where
+	B: Block,
+	BE: AuxStore,
+{
+	let version: Option<u32> = load_decode(backend, VERSION_KEY)?;
+
+	match version {
+		None => (),
+		Some(1) => return load_decode::<_, PersistedState<B>>(backend, GADGET_STATE),
+		other =>
+			return Err(ClientError::Backend(format!("Unsupported MMR aux DB version: {:?}", other))),
+	}
+
+	// No persistent state found in DB.
+	Ok(None)
+}
+
+/// Load or initialize persistent data from backend.
+pub(crate) fn load_or_init_state<B, BE>(
+	backend: &BE,
+	default: NumberFor<B>,
+) -> sp_blockchain::Result<NumberFor<B>>
+where
+	B: Block,
+	BE: AuxStore,
+{
+	// Initialize gadget best_canon from AUX DB or from pallet genesis.
+	if let Some(best) = load_state::<B, BE>(backend)? {
+		info!(target: LOG_TARGET, "Loading MMR best canonicalized state from db: {:?}.", best);
+		Ok(best)
+	} else {
+		info!(
+			target: LOG_TARGET,
+			"Loading MMR from pallet genesis on what appears to be the first startup: {:?}.",
+			default
+		);
+		write_current_version(backend)?;
+		write_gadget_state::<B, BE>(backend, &default)?;
+		Ok(default)
+	}
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+	use crate::test_utils::{run_test_with_mmr_gadget_pre_post_using_client, MmrBlock, MockClient};
+	use parking_lot::Mutex;
+	use sp_runtime::generic::BlockId;
+	use std::{sync::Arc, time::Duration};
+	use substrate_test_runtime_client::{runtime::Block, Backend};
+
+	#[test]
+	fn should_load_persistent_sanity_checks() {
+		let client = MockClient::new();
+		let backend = &*client.backend;
+
+		// version not available in db -> None
+		assert_eq!(load_state::<Block, Backend>(backend).unwrap(), None);
+
+		// populate version in db
+		write_current_version(backend).unwrap();
+		// verify correct version is retrieved
+		assert_eq!(load_decode(backend, VERSION_KEY).unwrap(), Some(CURRENT_VERSION));
+
+		// version is available in db but state isn't -> None
+		assert_eq!(load_state::<Block, Backend>(backend).unwrap(), None);
+	}
+
+	#[test]
+	fn should_persist_progress_across_runs() {
+		sp_tracing::try_init_simple();
+
+		let client = Arc::new(MockClient::new());
+		let backend = client.backend.clone();
+
+		// version not available in db -> None
+		assert_eq!(load_decode::<Backend, Option<u32>>(&*backend, VERSION_KEY).unwrap(), None);
+		// state not available in db -> None
+		assert_eq!(load_state::<Block, Backend>(&*backend).unwrap(), None);
+		// run the gadget while importing and finalizing 3 blocks
+		run_test_with_mmr_gadget_pre_post_using_client(
+			client.clone(),
+			|_| async {},
+			|client| async move {
+				let a1 = client.import_block(&BlockId::Number(0), b"a1", Some(0)).await;
+				let a2 = client.import_block(&BlockId::Number(1), b"a2", Some(1)).await;
+				let a3 = client.import_block(&BlockId::Number(2), b"a3", Some(2)).await;
+				client.finalize_block(a3.hash(), Some(3));
+				tokio::time::sleep(Duration::from_millis(200)).await;
+				// a1, a2, a3 were canonicalized
+				client.assert_canonicalized(&[&a1, &a2, &a3]);
+			},
+		);
+
+		// verify previous progress was persisted and run the gadget again
+		run_test_with_mmr_gadget_pre_post_using_client(
+			client.clone(),
+			|client| async move {
+				let backend = &*client.backend;
+				// check there is both version and best canon available in db before running gadget
+				assert_eq!(load_decode(backend, VERSION_KEY).unwrap(), Some(CURRENT_VERSION));
+				assert_eq!(load_state::<Block, Backend>(backend).unwrap(), Some(3));
+			},
+			|client| async move {
+				let a4 = client.import_block(&BlockId::Number(3), b"a4", Some(3)).await;
+				let a5 = client.import_block(&BlockId::Number(4), b"a5", Some(4)).await;
+				let a6 = client.import_block(&BlockId::Number(5), b"a6", Some(5)).await;
+				client.finalize_block(a6.hash(), Some(6));
+				tokio::time::sleep(Duration::from_millis(200)).await;
+
+				// a4, a5, a6 were canonicalized
+				client.assert_canonicalized(&[&a4, &a5, &a6]);
+				// check persisted best canon was updated
+				assert_eq!(load_state::<Block, Backend>(&*client.backend).unwrap(), Some(6));
+			},
+		);
+	}
+
+	#[test]
+	fn should_resume_from_persisted_state() {
+		sp_tracing::try_init_simple();
+
+		let client = Arc::new(MockClient::new());
+		let blocks = Arc::new(Mutex::new(Vec::<MmrBlock>::new()));
+		let blocks_clone = blocks.clone();
+
+		// run the gadget while importing and finalizing 3 blocks
+		run_test_with_mmr_gadget_pre_post_using_client(
+			client.clone(),
+			|_| async {},
+			|client| async move {
+				let mut blocks = blocks_clone.lock();
+				blocks.push(client.import_block(&BlockId::Number(0), b"a1", Some(0)).await);
+				blocks.push(client.import_block(&BlockId::Number(1), b"a2", Some(1)).await);
+				blocks.push(client.import_block(&BlockId::Number(2), b"a3", Some(2)).await);
+				client.finalize_block(blocks.last().unwrap().hash(), Some(3));
+				tokio::time::sleep(Duration::from_millis(200)).await;
+				// a1, a2, a3 were canonicalized
+				let slice: Vec<&MmrBlock> = blocks.iter().collect();
+				client.assert_canonicalized(&slice);
+
+				// now manually move them back to non-canon/temp location
+				for mmr_block in slice {
+					client.undo_block_canonicalization(mmr_block)
+				}
+			},
+		);
+
+		let blocks_clone = blocks.clone();
+		// verify new gadget continues from block 4 and ignores 1, 2, 3 based on persisted state
+		run_test_with_mmr_gadget_pre_post_using_client(
+			client.clone(),
+			|client| async move {
+				let blocks = blocks_clone.lock();
+				let slice: Vec<&MmrBlock> = blocks.iter().collect();
+
+				// verify persisted state says a1, a2, a3 were canonicalized,
+				assert_eq!(load_state::<Block, Backend>(&*client.backend).unwrap(), Some(3));
+				// but actually they are NOT canon (we manually reverted them earlier).
+				client.assert_not_canonicalized(&slice);
+			},
+			|client| async move {
+				let a4 = client.import_block(&BlockId::Number(3), b"a4", Some(3)).await;
+				let a5 = client.import_block(&BlockId::Number(4), b"a5", Some(4)).await;
+				let a6 = client.import_block(&BlockId::Number(5), b"a6", Some(5)).await;
+				client.finalize_block(a6.hash(), Some(6));
+				tokio::time::sleep(Duration::from_millis(200)).await;
+
+				let block_1_to_3 = blocks.lock();
+				let slice: Vec<&MmrBlock> = block_1_to_3.iter().collect();
+				// verify a1, a2, a3 are still NOT canon (skipped by gadget based on data in aux db)
+				client.assert_not_canonicalized(&slice);
+				// but a4, a5, a6 were canonicalized
+				client.assert_canonicalized(&[&a4, &a5, &a6]);
+				// check persisted best canon was updated
+				assert_eq!(load_state::<Block, Backend>(&*client.backend).unwrap(), Some(6));
+			},
+		);
+	}
+}
diff --git a/substrate/client/merkle-mountain-range/src/lib.rs b/substrate/client/merkle-mountain-range/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e174af7068abb8e80e78e405093907b3ffb4ace0
--- /dev/null
+++ b/substrate/client/merkle-mountain-range/src/lib.rs
@@ -0,0 +1,283 @@
+// 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/>.
+
+//! # MMR offchain gadget
+//!
+//! The MMR offchain gadget is run alongside `pallet-mmr` to assist it with offchain
+//! canonicalization of finalized MMR leaves and nodes.
+//! The gadget should only be run on nodes that have Indexing API enabled (otherwise
+//! `pallet-mmr` cannot write to offchain and this gadget has nothing to do).
+//!
+//! The runtime `pallet-mmr` creates one new MMR leaf per block and all inner MMR parent nodes
+//! generated by the MMR when adding said leaf. MMR nodes are stored both in:
+//! - on-chain storage - hashes only; not full leaf content;
+//! - off-chain storage - via Indexing API, full leaf content (and all internal nodes as well) is
+//!   saved to the Off-chain DB using a key derived from `parent_hash` and node index in MMR. The
+//!   `parent_hash` is also used within the key to avoid conflicts and overwrites on forks (leaf
+//!   data is only allowed to reference data coming from parent block).
+//!
+//! This gadget is driven by block finality and in responsible for pruning stale forks from
+//! offchain db, and moving finalized forks under a "canonical" key based solely on node `pos`
+//! in the MMR.
+
+#![warn(missing_docs)]
+
+mod aux_schema;
+mod offchain_mmr;
+#[cfg(test)]
+pub mod test_utils;
+
+use crate::offchain_mmr::OffchainMmr;
+use futures::StreamExt;
+use log::{debug, error, trace, warn};
+use sc_client_api::{Backend, BlockchainEvents, FinalityNotification, FinalityNotifications};
+use sc_offchain::OffchainDb;
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::{HeaderBackend, HeaderMetadata};
+use sp_consensus_beefy::MmrRootHash;
+use sp_mmr_primitives::{utils, LeafIndex, MmrApi};
+use sp_runtime::traits::{Block, Header, NumberFor};
+use std::{marker::PhantomData, sync::Arc};
+
+/// Logging target for the mmr gadget.
+pub const LOG_TARGET: &str = "mmr";
+
+/// A convenience MMR client trait that defines all the type bounds a MMR client
+/// has to satisfy and defines some helper methods.
+pub trait MmrClient<B, BE>:
+	BlockchainEvents<B> + HeaderBackend<B> + HeaderMetadata<B> + ProvideRuntimeApi<B>
+where
+	B: Block,
+	BE: Backend<B>,
+	Self::Api: MmrApi<B, MmrRootHash, NumberFor<B>>,
+{
+	/// Get the block number where the mmr pallet was added to the runtime.
+	fn first_mmr_block_num(&self, notification: &FinalityNotification<B>) -> Option<NumberFor<B>> {
+		let best_block_hash = notification.header.hash();
+		let best_block_number = *notification.header.number();
+		match self.runtime_api().mmr_leaf_count(best_block_hash) {
+			Ok(Ok(mmr_leaf_count)) => {
+				match utils::first_mmr_block_num::<B::Header>(best_block_number, mmr_leaf_count) {
+					Ok(first_mmr_block) => {
+						debug!(
+							target: LOG_TARGET,
+							"pallet-mmr detected at block {:?} with genesis at block {:?}",
+							best_block_number,
+							first_mmr_block
+						);
+						Some(first_mmr_block)
+					},
+					Err(e) => {
+						error!(
+							target: LOG_TARGET,
+							"Error calculating the first mmr block: {:?}", e
+						);
+						None
+					},
+				}
+			},
+			_ => {
+				trace!(
+					target: LOG_TARGET,
+					"pallet-mmr not detected at block {:?} ... (best finalized {:?})",
+					best_block_number,
+					notification.header.number()
+				);
+				None
+			},
+		}
+	}
+}
+
+impl<B, BE, T> MmrClient<B, BE> for T
+where
+	B: Block,
+	BE: Backend<B>,
+	T: BlockchainEvents<B> + HeaderBackend<B> + HeaderMetadata<B> + ProvideRuntimeApi<B>,
+	T::Api: MmrApi<B, MmrRootHash, NumberFor<B>>,
+{
+	// empty
+}
+
+struct OffchainMmrBuilder<B: Block, BE: Backend<B>, C> {
+	backend: Arc<BE>,
+	client: Arc<C>,
+	offchain_db: OffchainDb<BE::OffchainStorage>,
+	indexing_prefix: Vec<u8>,
+
+	_phantom: PhantomData<B>,
+}
+
+impl<B, BE, C> OffchainMmrBuilder<B, BE, C>
+where
+	B: Block,
+	BE: Backend<B>,
+	C: MmrClient<B, BE>,
+	C::Api: MmrApi<B, MmrRootHash, NumberFor<B>>,
+{
+	async fn try_build(
+		self,
+		finality_notifications: &mut FinalityNotifications<B>,
+	) -> Option<OffchainMmr<B, BE, C>> {
+		while let Some(notification) = finality_notifications.next().await {
+			if let Some(first_mmr_block_num) = self.client.first_mmr_block_num(&notification) {
+				let mut offchain_mmr = OffchainMmr::new(
+					self.backend,
+					self.client,
+					self.offchain_db,
+					self.indexing_prefix,
+					first_mmr_block_num,
+				)?;
+				// We need to make sure all blocks leading up to current notification
+				// have also been canonicalized.
+				offchain_mmr.canonicalize_catch_up(&notification);
+				// We have to canonicalize and prune the blocks in the finality
+				// notification that lead to building the offchain-mmr as well.
+				offchain_mmr.canonicalize_and_prune(notification);
+				return Some(offchain_mmr)
+			}
+		}
+
+		error!(
+			target: LOG_TARGET,
+			"Finality notifications stream closed unexpectedly. \
+			Couldn't build the canonicalization engine",
+		);
+		None
+	}
+}
+
+/// A MMR Gadget.
+pub struct MmrGadget<B: Block, BE: Backend<B>, C> {
+	finality_notifications: FinalityNotifications<B>,
+
+	_phantom: PhantomData<(B, BE, C)>,
+}
+
+impl<B, BE, C> MmrGadget<B, BE, C>
+where
+	B: Block,
+	<B::Header as Header>::Number: Into<LeafIndex>,
+	BE: Backend<B>,
+	C: MmrClient<B, BE>,
+	C::Api: MmrApi<B, MmrRootHash, NumberFor<B>>,
+{
+	async fn run(mut self, builder: OffchainMmrBuilder<B, BE, C>) {
+		let mut offchain_mmr = match builder.try_build(&mut self.finality_notifications).await {
+			Some(offchain_mmr) => offchain_mmr,
+			None => return,
+		};
+
+		while let Some(notification) = self.finality_notifications.next().await {
+			offchain_mmr.canonicalize_and_prune(notification);
+		}
+	}
+
+	/// Create and run the MMR gadget.
+	pub async fn start(client: Arc<C>, backend: Arc<BE>, indexing_prefix: Vec<u8>) {
+		let offchain_db = match backend.offchain_storage() {
+			Some(offchain_storage) => OffchainDb::new(offchain_storage),
+			None => {
+				warn!(
+					target: LOG_TARGET,
+					"Can't spawn a MmrGadget for a node without offchain storage."
+				);
+				return
+			},
+		};
+
+		let mmr_gadget = MmrGadget::<B, BE, C> {
+			finality_notifications: client.finality_notification_stream(),
+
+			_phantom: Default::default(),
+		};
+		mmr_gadget
+			.run(OffchainMmrBuilder {
+				backend,
+				client,
+				offchain_db,
+				indexing_prefix,
+				_phantom: Default::default(),
+			})
+			.await
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::test_utils::run_test_with_mmr_gadget;
+	use sp_runtime::generic::BlockId;
+	use std::time::Duration;
+
+	#[test]
+	fn mmr_first_block_is_computed_correctly() {
+		// Check the case where the first block is also the first block with MMR.
+		run_test_with_mmr_gadget(|client| async move {
+			// G -> A1 -> A2
+			//      |
+			//      | -> first mmr block
+
+			let a1 = client.import_block(&BlockId::Number(0), b"a1", Some(0)).await;
+			let a2 = client.import_block(&BlockId::Hash(a1.hash()), b"a2", Some(1)).await;
+
+			client.finalize_block(a1.hash(), Some(1));
+			tokio::time::sleep(Duration::from_millis(200)).await;
+			// expected finalized heads: a1
+			client.assert_canonicalized(&[&a1]);
+			client.assert_not_pruned(&[&a2]);
+		});
+
+		// Check the case where the first block with MMR comes later.
+		run_test_with_mmr_gadget(|client| async move {
+			// G -> A1 -> A2 -> A3 -> A4 -> A5 -> A6
+			//                        |
+			//                        | -> first mmr block
+
+			let a1 = client.import_block(&BlockId::Number(0), b"a1", None).await;
+			let a2 = client.import_block(&BlockId::Hash(a1.hash()), b"a2", None).await;
+			let a3 = client.import_block(&BlockId::Hash(a2.hash()), b"a3", None).await;
+			let a4 = client.import_block(&BlockId::Hash(a3.hash()), b"a4", Some(0)).await;
+			let a5 = client.import_block(&BlockId::Hash(a4.hash()), b"a5", Some(1)).await;
+			let a6 = client.import_block(&BlockId::Hash(a5.hash()), b"a6", Some(2)).await;
+
+			client.finalize_block(a5.hash(), Some(2));
+			tokio::time::sleep(Duration::from_millis(200)).await;
+			// expected finalized heads: a4, a5
+			client.assert_canonicalized(&[&a4, &a5]);
+			client.assert_not_pruned(&[&a6]);
+		});
+	}
+
+	#[test]
+	fn does_not_panic_on_invalid_num_mmr_blocks() {
+		run_test_with_mmr_gadget(|client| async move {
+			// G -> A1
+			//      |
+			//      | -> first mmr block
+
+			let a1 = client.import_block(&BlockId::Number(0), b"a1", Some(0)).await;
+
+			// Simulate the case where the runtime says that there are 2 mmr_blocks when in fact
+			// there is only 1.
+			client.finalize_block(a1.hash(), Some(2));
+			tokio::time::sleep(Duration::from_millis(200)).await;
+			// expected finalized heads: -
+			client.assert_not_canonicalized(&[&a1]);
+		});
+	}
+}
diff --git a/substrate/client/merkle-mountain-range/src/offchain_mmr.rs b/substrate/client/merkle-mountain-range/src/offchain_mmr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3c3f0beb6c6a9196bfb8bf6d1108b737869d346c
--- /dev/null
+++ b/substrate/client/merkle-mountain-range/src/offchain_mmr.rs
@@ -0,0 +1,458 @@
+// 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/>.
+
+//! Logic for canonicalizing MMR offchain entries for finalized forks,
+//! and for pruning MMR offchain entries for stale forks.
+
+#![warn(missing_docs)]
+
+use crate::{aux_schema, MmrClient, LOG_TARGET};
+use log::{debug, error, info, warn};
+use sc_client_api::{Backend, FinalityNotification};
+use sc_offchain::OffchainDb;
+use sp_blockchain::{CachedHeaderMetadata, ForkBackend};
+use sp_consensus_beefy::MmrRootHash;
+use sp_core::offchain::{DbExternalities, StorageKind};
+use sp_mmr_primitives::{utils, utils::NodesUtils, MmrApi, NodeIndex};
+use sp_runtime::{
+	traits::{Block, Header, NumberFor, One},
+	Saturating,
+};
+use std::{collections::VecDeque, sync::Arc};
+
+/// `OffchainMMR` exposes MMR offchain canonicalization and pruning logic.
+pub struct OffchainMmr<B: Block, BE: Backend<B>, C> {
+	backend: Arc<BE>,
+	client: Arc<C>,
+	offchain_db: OffchainDb<BE::OffchainStorage>,
+	indexing_prefix: Vec<u8>,
+	first_mmr_block: NumberFor<B>,
+	best_canonicalized: NumberFor<B>,
+}
+
+impl<B, BE, C> OffchainMmr<B, BE, C>
+where
+	BE: Backend<B>,
+	B: Block,
+	C: MmrClient<B, BE>,
+	C::Api: MmrApi<B, MmrRootHash, NumberFor<B>>,
+{
+	pub fn new(
+		backend: Arc<BE>,
+		client: Arc<C>,
+		offchain_db: OffchainDb<BE::OffchainStorage>,
+		indexing_prefix: Vec<u8>,
+		first_mmr_block: NumberFor<B>,
+	) -> Option<Self> {
+		let mut best_canonicalized = first_mmr_block.saturating_sub(One::one());
+		best_canonicalized = aux_schema::load_or_init_state::<B, BE>(&*backend, best_canonicalized)
+			.map_err(|e| error!(target: LOG_TARGET, "Error loading state from aux db: {:?}", e))
+			.ok()?;
+
+		Some(Self {
+			backend,
+			client,
+			offchain_db,
+			indexing_prefix,
+			first_mmr_block,
+			best_canonicalized,
+		})
+	}
+
+	fn node_temp_offchain_key(&self, pos: NodeIndex, parent_hash: B::Hash) -> Vec<u8> {
+		NodesUtils::node_temp_offchain_key::<B::Header>(&self.indexing_prefix, pos, parent_hash)
+	}
+
+	fn node_canon_offchain_key(&self, pos: NodeIndex) -> Vec<u8> {
+		NodesUtils::node_canon_offchain_key(&self.indexing_prefix, pos)
+	}
+
+	fn write_gadget_state_or_log(&self) {
+		if let Err(e) =
+			aux_schema::write_gadget_state::<B, BE>(&*self.backend, &self.best_canonicalized)
+		{
+			debug!(target: LOG_TARGET, "error saving state: {:?}", e);
+		}
+	}
+
+	fn header_metadata_or_log(
+		&self,
+		hash: B::Hash,
+		action: &str,
+	) -> Option<CachedHeaderMetadata<B>> {
+		match self.client.header_metadata(hash) {
+			Ok(header) => Some(header),
+			_ => {
+				debug!(
+					target: LOG_TARGET,
+					"Block {} not found. Couldn't {} associated branch.", hash, action
+				);
+				None
+			},
+		}
+	}
+
+	fn right_branch_ending_in_block_or_log(
+		&self,
+		block_num: NumberFor<B>,
+		action: &str,
+	) -> Option<Vec<NodeIndex>> {
+		match utils::block_num_to_leaf_index::<B::Header>(block_num, self.first_mmr_block) {
+			Ok(leaf_idx) => {
+				let branch = NodesUtils::right_branch_ending_in_leaf(leaf_idx);
+				debug!(
+					target: LOG_TARGET,
+					"Nodes to {} for block {}: {:?}", action, block_num, branch
+				);
+				Some(branch)
+			},
+			Err(e) => {
+				error!(
+					target: LOG_TARGET,
+					"Error converting block number {} to leaf index: {:?}. \
+					Couldn't {} associated branch.",
+					block_num,
+					e,
+					action
+				);
+				None
+			},
+		}
+	}
+
+	fn prune_branch(&mut self, block_hash: &B::Hash) {
+		let action = "prune";
+		let header = match self.header_metadata_or_log(*block_hash, action) {
+			Some(header) => header,
+			_ => return,
+		};
+
+		// We prune the leaf associated with the provided block and all the nodes added by that
+		// leaf.
+		let stale_nodes = match self.right_branch_ending_in_block_or_log(header.number, action) {
+			Some(nodes) => nodes,
+			None => {
+				// If we can't convert the block number to a leaf index, the chain state is probably
+				// corrupted. We only log the error, hoping that the chain state will be fixed.
+				return
+			},
+		};
+
+		for pos in stale_nodes {
+			let temp_key = self.node_temp_offchain_key(pos, header.parent);
+			self.offchain_db.local_storage_clear(StorageKind::PERSISTENT, &temp_key);
+			debug!(target: LOG_TARGET, "Pruned elem at pos {} with temp key {:?}", pos, temp_key);
+		}
+	}
+
+	fn canonicalize_branch(&mut self, block_hash: B::Hash) {
+		let action = "canonicalize";
+		let header = match self.header_metadata_or_log(block_hash, action) {
+			Some(header) => header,
+			_ => return,
+		};
+
+		// Don't canonicalize branches corresponding to blocks for which the MMR pallet
+		// wasn't yet initialized.
+		if header.number < self.first_mmr_block {
+			return
+		}
+
+		// We "canonicalize" the leaf associated with the provided block
+		// and all the nodes added by that leaf.
+		let to_canon_nodes = match self.right_branch_ending_in_block_or_log(header.number, action) {
+			Some(nodes) => nodes,
+			None => {
+				// If we can't convert the block number to a leaf index, the chain state is probably
+				// corrupted. We only log the error, hoping that the chain state will be fixed.
+				self.best_canonicalized = header.number;
+				return
+			},
+		};
+
+		for pos in to_canon_nodes {
+			let temp_key = self.node_temp_offchain_key(pos, header.parent);
+			if let Some(elem) =
+				self.offchain_db.local_storage_get(StorageKind::PERSISTENT, &temp_key)
+			{
+				let canon_key = self.node_canon_offchain_key(pos);
+				self.offchain_db.local_storage_set(StorageKind::PERSISTENT, &canon_key, &elem);
+				self.offchain_db.local_storage_clear(StorageKind::PERSISTENT, &temp_key);
+				debug!(
+					target: LOG_TARGET,
+					"Moved elem at pos {} from temp key {:?} to canon key {:?}",
+					pos,
+					temp_key,
+					canon_key
+				);
+			} else {
+				debug!(
+					target: LOG_TARGET,
+					"Couldn't canonicalize elem at pos {} using temp key {:?}", pos, temp_key
+				);
+			}
+		}
+		if self.best_canonicalized != header.number.saturating_sub(One::one()) {
+			warn!(
+				target: LOG_TARGET,
+				"Detected canonicalization skip: best {:?} current {:?}.",
+				self.best_canonicalized,
+				header.number,
+			);
+		}
+		self.best_canonicalized = header.number;
+	}
+
+	/// In case of missed finality notifications (node restarts for example),
+	/// make sure to also canon everything leading up to `notification.tree_route`.
+	pub fn canonicalize_catch_up(&mut self, notification: &FinalityNotification<B>) {
+		let first = notification.tree_route.first().unwrap_or(&notification.hash);
+		if let Some(mut header) = self.header_metadata_or_log(*first, "canonicalize") {
+			let mut to_canon = VecDeque::<<B as Block>::Hash>::new();
+			// Walk up the chain adding all blocks newer than `self.best_canonicalized`.
+			loop {
+				header = match self.header_metadata_or_log(header.parent, "canonicalize") {
+					Some(header) => header,
+					_ => break,
+				};
+				if header.number <= self.best_canonicalized {
+					break
+				}
+				to_canon.push_front(header.hash);
+			}
+			// Canonicalize all blocks leading up to current finality notification.
+			for hash in to_canon.drain(..) {
+				self.canonicalize_branch(hash);
+			}
+			self.write_gadget_state_or_log();
+		}
+	}
+
+	fn handle_potential_pallet_reset(&mut self, notification: &FinalityNotification<B>) {
+		if let Some(first_mmr_block_num) = self.client.first_mmr_block_num(&notification) {
+			if first_mmr_block_num != self.first_mmr_block {
+				info!(
+					target: LOG_TARGET,
+					"pallet-mmr reset detected at block {:?} with new genesis at block {:?}",
+					notification.header.number(),
+					first_mmr_block_num
+				);
+				self.first_mmr_block = first_mmr_block_num;
+				self.best_canonicalized = first_mmr_block_num.saturating_sub(One::one());
+				self.write_gadget_state_or_log();
+			}
+		}
+	}
+
+	/// Move leafs and nodes added by finalized blocks in offchain db from _fork-aware key_ to
+	/// _canonical key_.
+	/// Prune leafs and nodes added by stale blocks in offchain db from _fork-aware key_.
+	pub fn canonicalize_and_prune(&mut self, notification: FinalityNotification<B>) {
+		// Update the first MMR block in case of a pallet reset.
+		self.handle_potential_pallet_reset(&notification);
+
+		// Move offchain MMR nodes for finalized blocks to canonical keys.
+		for hash in notification.tree_route.iter().chain(std::iter::once(&notification.hash)) {
+			self.canonicalize_branch(*hash);
+		}
+		self.write_gadget_state_or_log();
+
+		// Remove offchain MMR nodes for stale forks.
+		let stale_forks = self.client.expand_forks(&notification.stale_heads).unwrap_or_else(
+			|(stale_forks, e)| {
+				warn!(target: LOG_TARGET, "{:?}", e);
+				stale_forks
+			},
+		);
+		for hash in stale_forks.iter() {
+			self.prune_branch(hash);
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::test_utils::{run_test_with_mmr_gadget, run_test_with_mmr_gadget_pre_post};
+	use parking_lot::Mutex;
+	use sp_runtime::generic::BlockId;
+	use std::{sync::Arc, time::Duration};
+
+	#[test]
+	fn canonicalize_and_prune_works_correctly() {
+		run_test_with_mmr_gadget(|client| async move {
+			//                     -> D4 -> D5
+			// G -> A1 -> A2 -> A3 -> A4
+			//   -> B1 -> B2 -> B3
+			//   -> C1
+
+			let a1 = client.import_block(&BlockId::Number(0), b"a1", Some(0)).await;
+			let a2 = client.import_block(&BlockId::Hash(a1.hash()), b"a2", Some(1)).await;
+			let a3 = client.import_block(&BlockId::Hash(a2.hash()), b"a3", Some(2)).await;
+			let a4 = client.import_block(&BlockId::Hash(a3.hash()), b"a4", Some(3)).await;
+
+			let b1 = client.import_block(&BlockId::Number(0), b"b1", Some(0)).await;
+			let b2 = client.import_block(&BlockId::Hash(b1.hash()), b"b2", Some(1)).await;
+			let b3 = client.import_block(&BlockId::Hash(b2.hash()), b"b3", Some(2)).await;
+
+			let c1 = client.import_block(&BlockId::Number(0), b"c1", Some(0)).await;
+
+			let d4 = client.import_block(&BlockId::Hash(a3.hash()), b"d4", Some(3)).await;
+			let d5 = client.import_block(&BlockId::Hash(d4.hash()), b"d5", Some(4)).await;
+
+			client.finalize_block(a3.hash(), Some(3));
+			tokio::time::sleep(Duration::from_millis(200)).await;
+			// expected finalized heads: a1, a2, a3
+			client.assert_canonicalized(&[&a1, &a2, &a3]);
+			// expected stale heads: c1
+			// expected pruned heads because of temp key collision: b1
+			client.assert_pruned(&[&c1, &b1]);
+
+			client.finalize_block(d5.hash(), Some(5));
+			tokio::time::sleep(Duration::from_millis(200)).await;
+			// expected finalized heads: d4, d5,
+			client.assert_canonicalized(&[&d4, &d5]);
+			// expected stale heads: b1, b2, b3, a4
+			client.assert_pruned(&[&b1, &b2, &b3, &a4]);
+		})
+	}
+
+	#[test]
+	fn canonicalize_and_prune_handles_pallet_reset() {
+		run_test_with_mmr_gadget(|client| async move {
+			// G -> A1 -> A2 -> A3 -> A4 -> A5
+			//      |           |
+			//      |           | -> pallet reset
+			//      |
+			//      | -> first finality notification
+
+			let a1 = client.import_block(&BlockId::Number(0), b"a1", Some(0)).await;
+			let a2 = client.import_block(&BlockId::Hash(a1.hash()), b"a2", Some(1)).await;
+			let a3 = client.import_block(&BlockId::Hash(a2.hash()), b"a3", Some(0)).await;
+			let a4 = client.import_block(&BlockId::Hash(a3.hash()), b"a4", Some(1)).await;
+			let a5 = client.import_block(&BlockId::Hash(a4.hash()), b"a5", Some(2)).await;
+
+			client.finalize_block(a1.hash(), Some(1));
+			tokio::time::sleep(Duration::from_millis(200)).await;
+			// expected finalized heads: a1
+			client.assert_canonicalized(&[&a1]);
+			// a2 shouldn't be either canonicalized or pruned. It should be handled as part of the
+			// reset process.
+			client.assert_not_canonicalized(&[&a2]);
+
+			client.finalize_block(a5.hash(), Some(3));
+			tokio::time::sleep(Duration::from_millis(200)).await;
+			//expected finalized heads: a3, a4, a5,
+			client.assert_canonicalized(&[&a3, &a4, &a5]);
+		})
+	}
+
+	#[test]
+	fn canonicalize_catchup_works_correctly() {
+		let mmr_blocks = Arc::new(Mutex::new(vec![]));
+		let mmr_blocks_ref = mmr_blocks.clone();
+		run_test_with_mmr_gadget_pre_post(
+			|client| async move {
+				// G -> A1 -> A2
+				//      |     |
+				//      |     | -> finalized without gadget (missed notification)
+				//      |
+				//      | -> first mmr block
+
+				let a1 = client.import_block(&BlockId::Number(0), b"a1", Some(0)).await;
+				let a2 = client.import_block(&BlockId::Hash(a1.hash()), b"a2", Some(1)).await;
+
+				client.finalize_block(a2.hash(), Some(2));
+
+				let mut mmr_blocks = mmr_blocks_ref.lock();
+				mmr_blocks.push(a1);
+				mmr_blocks.push(a2);
+			},
+			|client| async move {
+				// G -> A1 -> A2 -> A3 -> A4
+				//      |     |     |     |
+				//      |     |     |     | -> finalized after starting gadget
+				//      |     |     |
+				//      |     |     | -> gadget start
+				//      |     |
+				//      |     | -> finalized before starting gadget (missed notification)
+				//      |
+				//      | -> first mmr block
+				let blocks = mmr_blocks.lock();
+				let a1 = blocks[0].clone();
+				let a2 = blocks[1].clone();
+				let a3 = client.import_block(&BlockId::Hash(a2.hash()), b"a3", Some(2)).await;
+				let a4 = client.import_block(&BlockId::Hash(a3.hash()), b"a4", Some(3)).await;
+
+				client.finalize_block(a4.hash(), Some(4));
+				tokio::time::sleep(Duration::from_millis(200)).await;
+				// expected finalized heads: a1, a2 _and_ a3, a4.
+				client.assert_canonicalized(&[&a1, &a2, &a3, &a4]);
+			},
+		)
+	}
+
+	#[test]
+	fn canonicalize_catchup_works_correctly_with_pallet_reset() {
+		let mmr_blocks = Arc::new(Mutex::new(vec![]));
+		let mmr_blocks_ref = mmr_blocks.clone();
+		run_test_with_mmr_gadget_pre_post(
+			|client| async move {
+				// G -> A1 -> A2
+				//      |     |
+				//      |     | -> finalized without gadget (missed notification)
+				//      |
+				//      | -> first mmr block
+
+				let a1 = client.import_block(&BlockId::Number(0), b"a1", Some(0)).await;
+				let a2 = client.import_block(&BlockId::Hash(a1.hash()), b"a2", Some(0)).await;
+
+				client.finalize_block(a2.hash(), Some(1));
+
+				let mut mmr_blocks = mmr_blocks_ref.lock();
+				mmr_blocks.push(a1);
+				mmr_blocks.push(a2);
+			},
+			|client| async move {
+				// G -> A1 -> A2 -> A3 -> A4
+				//      |     |     |     |
+				//      |     |     |     | -> finalized after starting gadget
+				//      |     |     |
+				//      |     |     | -> gadget start
+				//      |     |
+				//      |     | -> finalized before gadget start (missed notification)
+				//      |     |    + pallet reset
+				//      |
+				//      | -> first mmr block
+				let blocks = mmr_blocks.lock();
+				let a1 = blocks[0].clone();
+				let a2 = blocks[1].clone();
+				let a3 = client.import_block(&BlockId::Hash(a2.hash()), b"a3", Some(1)).await;
+				let a4 = client.import_block(&BlockId::Hash(a3.hash()), b"a4", Some(2)).await;
+
+				client.finalize_block(a4.hash(), Some(3));
+				tokio::time::sleep(Duration::from_millis(200)).await;
+				// a1 shouldn't be either canonicalized or pruned. It should be handled as part of
+				// the reset process. Checking only that it wasn't pruned. Because of temp key
+				// collision with a2 we can't check that it wasn't canonicalized.
+				client.assert_not_pruned(&[&a1]);
+				// expected finalized heads: a4, a5.
+				client.assert_canonicalized(&[&a2, &a3, &a4]);
+			},
+		)
+	}
+}
diff --git a/substrate/client/merkle-mountain-range/src/test_utils.rs b/substrate/client/merkle-mountain-range/src/test_utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..010b48bb3d7da36914f40d106f08bb1938974e7c
--- /dev/null
+++ b/substrate/client/merkle-mountain-range/src/test_utils.rs
@@ -0,0 +1,371 @@
+// 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::MmrGadget;
+use parking_lot::Mutex;
+use sc_block_builder::BlockBuilderProvider;
+use sc_client_api::{
+	Backend as BackendT, BlockchainEvents, FinalityNotifications, ImportNotifications,
+	StorageEventStream, StorageKey,
+};
+use sc_offchain::OffchainDb;
+use sp_api::{ApiRef, ProvideRuntimeApi};
+use sp_blockchain::{BlockStatus, CachedHeaderMetadata, HeaderBackend, HeaderMetadata, Info};
+use sp_consensus::BlockOrigin;
+use sp_core::{
+	offchain::{DbExternalities, StorageKind},
+	H256,
+};
+use sp_mmr_primitives as mmr;
+use sp_mmr_primitives::{utils::NodesUtils, LeafIndex, NodeIndex};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT},
+};
+use std::{future::Future, sync::Arc, time::Duration};
+use substrate_test_runtime_client::{
+	runtime::{Block, BlockNumber, Hash, Header},
+	Backend, BlockBuilderExt, Client, ClientBlockImportExt, ClientExt, DefaultTestClientBuilderExt,
+	TestClientBuilder, TestClientBuilderExt,
+};
+use tokio::runtime::Runtime;
+
+type MmrHash = H256;
+
+pub(crate) struct MockRuntimeApiData {
+	pub(crate) num_blocks: BlockNumber,
+}
+
+#[derive(Clone)]
+pub(crate) struct MockRuntimeApi {
+	pub(crate) data: Arc<Mutex<MockRuntimeApiData>>,
+}
+
+impl MockRuntimeApi {
+	pub(crate) const INDEXING_PREFIX: &'static [u8] = b"mmr_test";
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct MmrBlock {
+	pub(crate) block: Block,
+	pub(crate) leaf_idx: Option<LeafIndex>,
+	pub(crate) leaf_data: Vec<u8>,
+}
+
+#[derive(Clone, Copy)]
+pub enum OffchainKeyType {
+	Temp,
+	Canon,
+}
+
+impl MmrBlock {
+	pub fn hash(&self) -> Hash {
+		self.block.hash()
+	}
+
+	pub fn parent_hash(&self) -> Hash {
+		*self.block.header.parent_hash()
+	}
+
+	pub fn get_offchain_key(&self, node: NodeIndex, key_type: OffchainKeyType) -> Vec<u8> {
+		match key_type {
+			OffchainKeyType::Temp => NodesUtils::node_temp_offchain_key::<Header>(
+				MockRuntimeApi::INDEXING_PREFIX,
+				node,
+				self.parent_hash(),
+			),
+			OffchainKeyType::Canon =>
+				NodesUtils::node_canon_offchain_key(MockRuntimeApi::INDEXING_PREFIX, node),
+		}
+	}
+}
+
+pub(crate) struct MockClient {
+	pub(crate) client: Mutex<Client<Backend>>,
+	pub(crate) backend: Arc<Backend>,
+	pub(crate) runtime_api_params: Arc<Mutex<MockRuntimeApiData>>,
+}
+
+impl MockClient {
+	pub(crate) fn new() -> Self {
+		let client_builder = TestClientBuilder::new().enable_offchain_indexing_api();
+		let (client, backend) = client_builder.build_with_backend();
+		MockClient {
+			client: Mutex::new(client),
+			backend,
+			runtime_api_params: Arc::new(Mutex::new(MockRuntimeApiData { num_blocks: 0 })),
+		}
+	}
+
+	pub(crate) fn offchain_db(&self) -> OffchainDb<<Backend as BackendT<Block>>::OffchainStorage> {
+		OffchainDb::new(self.backend.offchain_storage().unwrap())
+	}
+
+	pub async fn import_block(
+		&self,
+		at: &BlockId<Block>,
+		name: &[u8],
+		maybe_leaf_idx: Option<LeafIndex>,
+	) -> MmrBlock {
+		let mut client = self.client.lock();
+
+		let hash = client.expect_block_hash_from_id(&at).unwrap();
+		let mut block_builder = client.new_block_at(hash, Default::default(), false).unwrap();
+		// Make sure the block has a different hash than its siblings
+		block_builder
+			.push_storage_change(b"name".to_vec(), Some(name.to_vec()))
+			.unwrap();
+		let block = block_builder.build().unwrap().block;
+		client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+		let parent_hash = *block.header.parent_hash();
+		// Simulate writing MMR nodes in offchain storage
+		if let Some(leaf_idx) = maybe_leaf_idx {
+			let mut offchain_db = self.offchain_db();
+			for node in NodesUtils::right_branch_ending_in_leaf(leaf_idx) {
+				let temp_key = NodesUtils::node_temp_offchain_key::<Header>(
+					MockRuntimeApi::INDEXING_PREFIX,
+					node,
+					parent_hash,
+				);
+				offchain_db.local_storage_set(
+					StorageKind::PERSISTENT,
+					&temp_key,
+					parent_hash.as_ref(),
+				)
+			}
+		}
+
+		MmrBlock { block, leaf_idx: maybe_leaf_idx, leaf_data: parent_hash.as_ref().to_vec() }
+	}
+
+	pub fn finalize_block(&self, hash: Hash, maybe_num_mmr_blocks: Option<BlockNumber>) {
+		let client = self.client.lock();
+		if let Some(num_mmr_blocks) = maybe_num_mmr_blocks {
+			self.runtime_api_params.lock().num_blocks = num_mmr_blocks;
+		}
+
+		client.finalize_block(hash, None).unwrap();
+	}
+
+	pub fn undo_block_canonicalization(&self, mmr_block: &MmrBlock) {
+		let mut offchain_db = self.offchain_db();
+		for node in NodesUtils::right_branch_ending_in_leaf(mmr_block.leaf_idx.unwrap()) {
+			let canon_key = mmr_block.get_offchain_key(node, OffchainKeyType::Canon);
+			let val = offchain_db.local_storage_get(StorageKind::PERSISTENT, &canon_key).unwrap();
+			offchain_db.local_storage_clear(StorageKind::PERSISTENT, &canon_key);
+
+			let temp_key = mmr_block.get_offchain_key(node, OffchainKeyType::Temp);
+			offchain_db.local_storage_set(StorageKind::PERSISTENT, &temp_key, &val);
+		}
+	}
+
+	pub fn check_offchain_storage<F>(
+		&self,
+		key_type: OffchainKeyType,
+		blocks: &[&MmrBlock],
+		mut f: F,
+	) where
+		F: FnMut(Option<Vec<u8>>, &MmrBlock),
+	{
+		let mut offchain_db = self.offchain_db();
+		for mmr_block in blocks {
+			for node in NodesUtils::right_branch_ending_in_leaf(mmr_block.leaf_idx.unwrap()) {
+				let temp_key = mmr_block.get_offchain_key(node, key_type);
+				let val = offchain_db.local_storage_get(StorageKind::PERSISTENT, &temp_key);
+				f(val, mmr_block);
+			}
+		}
+	}
+
+	pub fn assert_pruned(&self, blocks: &[&MmrBlock]) {
+		self.check_offchain_storage(OffchainKeyType::Temp, blocks, |val, _block| {
+			assert!(val.is_none());
+		})
+	}
+
+	pub fn assert_not_pruned(&self, blocks: &[&MmrBlock]) {
+		self.check_offchain_storage(OffchainKeyType::Temp, blocks, |val, block| {
+			assert_eq!(val.as_ref(), Some(&block.leaf_data));
+		})
+	}
+
+	pub fn assert_canonicalized(&self, blocks: &[&MmrBlock]) {
+		self.check_offchain_storage(OffchainKeyType::Canon, blocks, |val, block| {
+			assert_eq!(val.as_ref(), Some(&block.leaf_data));
+		});
+
+		self.assert_pruned(blocks);
+	}
+
+	pub fn assert_not_canonicalized(&self, blocks: &[&MmrBlock]) {
+		self.check_offchain_storage(OffchainKeyType::Canon, blocks, |val, _block| {
+			assert!(val.is_none());
+		});
+
+		self.assert_not_pruned(blocks);
+	}
+}
+
+impl HeaderMetadata<Block> for MockClient {
+	type Error = <Client<Backend> as HeaderMetadata<Block>>::Error;
+
+	fn header_metadata(&self, hash: Hash) -> Result<CachedHeaderMetadata<Block>, Self::Error> {
+		self.client.lock().header_metadata(hash)
+	}
+
+	fn insert_header_metadata(&self, _hash: Hash, _header_metadata: CachedHeaderMetadata<Block>) {
+		todo!()
+	}
+
+	fn remove_header_metadata(&self, _hash: Hash) {
+		todo!()
+	}
+}
+
+impl HeaderBackend<Block> for MockClient {
+	fn header(&self, hash: Hash) -> sc_client_api::blockchain::Result<Option<Header>> {
+		self.client.lock().header(hash)
+	}
+
+	fn info(&self) -> Info<Block> {
+		self.client.lock().info()
+	}
+
+	fn status(&self, hash: Hash) -> sc_client_api::blockchain::Result<BlockStatus> {
+		self.client.lock().status(hash)
+	}
+
+	fn number(&self, hash: Hash) -> sc_client_api::blockchain::Result<Option<BlockNumber>> {
+		self.client.lock().number(hash)
+	}
+
+	fn hash(&self, number: BlockNumber) -> sc_client_api::blockchain::Result<Option<Hash>> {
+		self.client.lock().hash(number)
+	}
+}
+
+impl BlockchainEvents<Block> for MockClient {
+	fn import_notification_stream(&self) -> ImportNotifications<Block> {
+		unimplemented!()
+	}
+
+	fn every_import_notification_stream(&self) -> ImportNotifications<Block> {
+		unimplemented!()
+	}
+
+	fn finality_notification_stream(&self) -> FinalityNotifications<Block> {
+		self.client.lock().finality_notification_stream()
+	}
+
+	fn storage_changes_notification_stream(
+		&self,
+		_filter_keys: Option<&[StorageKey]>,
+		_child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+	) -> sc_client_api::blockchain::Result<StorageEventStream<Hash>> {
+		unimplemented!()
+	}
+}
+
+impl ProvideRuntimeApi<Block> for MockClient {
+	type Api = MockRuntimeApi;
+
+	fn runtime_api(&self) -> ApiRef<'_, Self::Api> {
+		MockRuntimeApi { data: self.runtime_api_params.clone() }.into()
+	}
+}
+
+sp_api::mock_impl_runtime_apis! {
+	impl mmr::MmrApi<Block, MmrHash, BlockNumber> for MockRuntimeApi {
+		fn mmr_root() -> Result<MmrHash, mmr::Error> {
+			Err(mmr::Error::PalletNotIncluded)
+		}
+
+		fn mmr_leaf_count(&self) -> Result<LeafIndex, mmr::Error> {
+			Ok(self.data.lock().num_blocks)
+		}
+
+		fn generate_proof(
+			&self,
+			_block_numbers: Vec<u64>,
+			_best_known_block_number: Option<u64>,
+		) -> Result<(Vec<mmr::EncodableOpaqueLeaf>, mmr::Proof<MmrHash>), mmr::Error> {
+			Err(mmr::Error::PalletNotIncluded)
+		}
+
+		fn verify_proof(_leaves: Vec<mmr::EncodableOpaqueLeaf>, _proof: mmr::Proof<MmrHash>)
+			-> Result<(), mmr::Error>
+		{
+			Err(mmr::Error::PalletNotIncluded)
+		}
+
+		fn verify_proof_stateless(
+			_root: MmrHash,
+			_leaves: Vec<mmr::EncodableOpaqueLeaf>,
+			_proof: mmr::Proof<MmrHash>
+		) -> Result<(), mmr::Error> {
+			Err(mmr::Error::PalletNotIncluded)
+		}
+	}
+}
+
+pub(crate) fn run_test_with_mmr_gadget<F, Fut>(post_gadget: F)
+where
+	F: FnOnce(Arc<MockClient>) -> Fut + 'static,
+	Fut: Future<Output = ()>,
+{
+	run_test_with_mmr_gadget_pre_post(|_| async {}, post_gadget);
+}
+
+pub(crate) fn run_test_with_mmr_gadget_pre_post<F, G, RetF, RetG>(pre_gadget: F, post_gadget: G)
+where
+	F: FnOnce(Arc<MockClient>) -> RetF + 'static,
+	G: FnOnce(Arc<MockClient>) -> RetG + 'static,
+	RetF: Future<Output = ()>,
+	RetG: Future<Output = ()>,
+{
+	let client = Arc::new(MockClient::new());
+	run_test_with_mmr_gadget_pre_post_using_client(client, pre_gadget, post_gadget)
+}
+
+pub(crate) fn run_test_with_mmr_gadget_pre_post_using_client<F, G, RetF, RetG>(
+	client: Arc<MockClient>,
+	pre_gadget: F,
+	post_gadget: G,
+) where
+	F: FnOnce(Arc<MockClient>) -> RetF + 'static,
+	G: FnOnce(Arc<MockClient>) -> RetG + 'static,
+	RetF: Future<Output = ()>,
+	RetG: Future<Output = ()>,
+{
+	let client_clone = client.clone();
+	let runtime = Runtime::new().unwrap();
+	runtime.block_on(async move { pre_gadget(client_clone).await });
+
+	let client_clone = client.clone();
+	runtime.spawn(async move {
+		let backend = client_clone.backend.clone();
+		MmrGadget::start(client_clone, backend, MockRuntimeApi::INDEXING_PREFIX.to_vec()).await
+	});
+
+	runtime.block_on(async move {
+		tokio::time::sleep(Duration::from_millis(200)).await;
+
+		post_gadget(client).await
+	});
+}
diff --git a/substrate/client/network-gossip/Cargo.toml b/substrate/client/network-gossip/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e25a769587dab18bdbceb8a53e5f4edc7f4562e9
--- /dev/null
+++ b/substrate/client/network-gossip/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+description = "Gossiping for the Substrate network protocol"
+name = "sc-network-gossip"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network-gossip"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+ahash = "0.8.2"
+futures = "0.3.21"
+futures-timer = "3.0.1"
+libp2p = "0.51.3"
+log = "0.4.17"
+schnellru = "0.2.1"
+tracing = "0.1.29"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+sc-network = { version = "0.10.0-dev", path = "../network/" }
+sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+
+[dev-dependencies]
+tokio = "1.22.0"
+quickcheck = { version = "1.0.3", default-features = false }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
diff --git a/substrate/client/network-gossip/README.md b/substrate/client/network-gossip/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9030fac056407aada04522af786058f8f75d8718
--- /dev/null
+++ b/substrate/client/network-gossip/README.md
@@ -0,0 +1,41 @@
+Polite gossiping.
+
+This crate provides gossiping capabilities on top of a network.
+
+Gossip messages are separated by two categories: "topics" and consensus engine ID.
+The consensus engine ID is sent over the wire with the message, while the topic is not,
+with the expectation that the topic can be derived implicitly from the content of the
+message, assuming it is valid.
+
+Topics are a single 32-byte tag associated with a message, used to group those messages
+in an opaque way. Consensus code can invoke `broadcast_topic` to attempt to send all messages
+under a single topic to all peers who don't have them yet, and `send_topic` to
+send all messages under a single topic to a specific peer.
+
+# Usage
+
+- Implement the `Network` trait, representing the low-level networking primitives. It is
+  already implemented on `sc_network::NetworkService`.
+- Implement the `Validator` trait. See the section below.
+- Decide on a `ConsensusEngineId`. Each gossiping protocol should have a different one.
+- Build a `GossipEngine` using these three elements.
+- Use the methods of the `GossipEngine` in order to send out messages and receive incoming
+  messages.
+
+# What is a validator?
+
+The primary role of a `Validator` is to process incoming messages from peers, and decide
+whether to discard them or process them. It also decides whether to re-broadcast the message.
+
+The secondary role of the `Validator` is to check if a message is allowed to be sent to a given
+peer. All messages, before being sent, will be checked against this filter.
+This enables the validator to use information it's aware of about connected peers to decide
+whether to send messages to them at any given moment in time - In particular, to wait until
+peers can accept and process the message before sending it.
+
+Lastly, the fact that gossip validators can decide not to rebroadcast messages
+opens the door for neighbor status packets to be baked into the gossip protocol.
+These status packets will typically contain light pieces of information
+used to inform peers of a current view of protocol state.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/network-gossip/src/bridge.rs b/substrate/client/network-gossip/src/bridge.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6a3790ee2b2b2b098dd0f039a67c281b9da0bf95
--- /dev/null
+++ b/substrate/client/network-gossip/src/bridge.rs
@@ -0,0 +1,824 @@
+// 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::{
+	state_machine::{ConsensusGossip, TopicNotification, PERIODIC_MAINTENANCE_INTERVAL},
+	Network, Syncing, Validator,
+};
+
+use sc_network::{event::Event, types::ProtocolName, ReputationChange};
+use sc_network_common::sync::SyncEvent;
+
+use futures::{
+	channel::mpsc::{channel, Receiver, Sender},
+	prelude::*,
+};
+use libp2p::PeerId;
+use log::trace;
+use prometheus_endpoint::Registry;
+use sp_runtime::traits::Block as BlockT;
+use std::{
+	collections::{HashMap, VecDeque},
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+};
+
+/// Wraps around an implementation of the [`Network`] trait and provides gossiping capabilities on
+/// top of it.
+pub struct GossipEngine<B: BlockT> {
+	state_machine: ConsensusGossip<B>,
+	network: Box<dyn Network<B> + Send>,
+	sync: Box<dyn Syncing<B>>,
+	periodic_maintenance_interval: futures_timer::Delay,
+	protocol: ProtocolName,
+
+	/// Incoming events from the network.
+	network_event_stream: Pin<Box<dyn Stream<Item = Event> + Send>>,
+	/// Incoming events from the syncing service.
+	sync_event_stream: Pin<Box<dyn Stream<Item = SyncEvent> + Send>>,
+	/// Outgoing events to the consumer.
+	message_sinks: HashMap<B::Hash, Vec<Sender<TopicNotification>>>,
+	/// Buffered messages (see [`ForwardingState`]).
+	forwarding_state: ForwardingState<B>,
+
+	is_terminated: bool,
+}
+
+/// A gossip engine receives messages from the network via the `network_event_stream` and forwards
+/// them to upper layers via the `message_sinks`. In the scenario where messages have been received
+/// from the network but a subscribed message sink is not yet ready to receive the messages, the
+/// messages are buffered. To model this process a gossip engine can be in two states.
+enum ForwardingState<B: BlockT> {
+	/// The gossip engine is currently not forwarding any messages and will poll the network for
+	/// more messages to forward.
+	Idle,
+	/// The gossip engine is in the progress of forwarding messages and thus will not poll the
+	/// network for more messages until it has send all current messages into the subscribed
+	/// message sinks.
+	Busy(VecDeque<(B::Hash, TopicNotification)>),
+}
+
+impl<B: BlockT> Unpin for GossipEngine<B> {}
+
+impl<B: BlockT> GossipEngine<B> {
+	/// Create a new instance.
+	pub fn new<N, S>(
+		network: N,
+		sync: S,
+		protocol: impl Into<ProtocolName>,
+		validator: Arc<dyn Validator<B>>,
+		metrics_registry: Option<&Registry>,
+	) -> Self
+	where
+		B: 'static,
+		N: Network<B> + Send + Clone + 'static,
+		S: Syncing<B> + Send + Clone + 'static,
+	{
+		let protocol = protocol.into();
+		let network_event_stream = network.event_stream("network-gossip");
+		let sync_event_stream = sync.event_stream("network-gossip");
+
+		GossipEngine {
+			state_machine: ConsensusGossip::new(validator, protocol.clone(), metrics_registry),
+			network: Box::new(network),
+			sync: Box::new(sync),
+			periodic_maintenance_interval: futures_timer::Delay::new(PERIODIC_MAINTENANCE_INTERVAL),
+			protocol,
+
+			network_event_stream,
+			sync_event_stream,
+			message_sinks: HashMap::new(),
+			forwarding_state: ForwardingState::Idle,
+
+			is_terminated: false,
+		}
+	}
+
+	pub fn report(&self, who: PeerId, reputation: ReputationChange) {
+		self.network.report_peer(who, reputation);
+	}
+
+	/// Registers a message without propagating it to any peers. The message
+	/// becomes available to new peers or when the service is asked to gossip
+	/// the message's topic. No validation is performed on the message, if the
+	/// message is already expired it should be dropped on the next garbage
+	/// collection.
+	pub fn register_gossip_message(&mut self, topic: B::Hash, message: Vec<u8>) {
+		self.state_machine.register_message(topic, message);
+	}
+
+	/// Broadcast all messages with given topic.
+	pub fn broadcast_topic(&mut self, topic: B::Hash, force: bool) {
+		self.state_machine.broadcast_topic(&mut *self.network, topic, force);
+	}
+
+	/// Get data of valid, incoming messages for a topic (but might have expired meanwhile).
+	pub fn messages_for(&mut self, topic: B::Hash) -> Receiver<TopicNotification> {
+		let past_messages = self.state_machine.messages_for(topic).collect::<Vec<_>>();
+		// The channel length is not critical for correctness. By the implementation of `channel`
+		// each sender is guaranteed a single buffer slot, making it a non-rendezvous channel and
+		// thus preventing direct dead-locks. A minimum channel length of 10 is an estimate based on
+		// the fact that despite `NotificationsReceived` having a `Vec` of messages, it only ever
+		// contains a single message.
+		let (mut tx, rx) = channel(usize::max(past_messages.len(), 10));
+
+		for notification in past_messages {
+			tx.try_send(notification)
+				.expect("receiver known to be live, and buffer size known to suffice; qed");
+		}
+
+		self.message_sinks.entry(topic).or_default().push(tx);
+
+		rx
+	}
+
+	/// Send all messages with given topic to a peer.
+	pub fn send_topic(&mut self, who: &PeerId, topic: B::Hash, force: bool) {
+		self.state_machine.send_topic(&mut *self.network, who, topic, force)
+	}
+
+	/// Multicast a message to all peers.
+	pub fn gossip_message(&mut self, topic: B::Hash, message: Vec<u8>, force: bool) {
+		self.state_machine.multicast(&mut *self.network, topic, message, force)
+	}
+
+	/// Send addressed message to the given peers. The message is not kept or multicast
+	/// later on.
+	pub fn send_message(&mut self, who: Vec<PeerId>, data: Vec<u8>) {
+		for who in &who {
+			self.state_machine.send_message(&mut *self.network, who, data.clone());
+		}
+	}
+
+	/// Notify everyone we're connected to that we have the given block.
+	///
+	/// Note: this method isn't strictly related to gossiping and should eventually be moved
+	/// somewhere else.
+	pub fn announce(&self, block: B::Hash, associated_data: Option<Vec<u8>>) {
+		self.sync.announce_block(block, associated_data);
+	}
+}
+
+impl<B: BlockT> Future for GossipEngine<B> {
+	type Output = ();
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		let this = &mut *self;
+
+		'outer: loop {
+			match &mut this.forwarding_state {
+				ForwardingState::Idle => {
+					let net_event_stream = this.network_event_stream.poll_next_unpin(cx);
+					let sync_event_stream = this.sync_event_stream.poll_next_unpin(cx);
+
+					if net_event_stream.is_pending() && sync_event_stream.is_pending() {
+						break
+					}
+
+					match net_event_stream {
+						Poll::Ready(Some(event)) => match event {
+							Event::NotificationStreamOpened { remote, protocol, role, .. } =>
+								if protocol == this.protocol {
+									this.state_machine.new_peer(&mut *this.network, remote, role);
+								},
+							Event::NotificationStreamClosed { remote, protocol } => {
+								if protocol == this.protocol {
+									this.state_machine
+										.peer_disconnected(&mut *this.network, remote);
+								}
+							},
+							Event::NotificationsReceived { remote, messages } => {
+								let messages = messages
+									.into_iter()
+									.filter_map(|(engine, data)| {
+										if engine == this.protocol {
+											Some(data.to_vec())
+										} else {
+											None
+										}
+									})
+									.collect();
+
+								let to_forward = this.state_machine.on_incoming(
+									&mut *this.network,
+									remote,
+									messages,
+								);
+
+								this.forwarding_state = ForwardingState::Busy(to_forward.into());
+							},
+							Event::Dht(_) => {},
+						},
+						// The network event stream closed. Do the same for [`GossipValidator`].
+						Poll::Ready(None) => {
+							self.is_terminated = true;
+							return Poll::Ready(())
+						},
+						Poll::Pending => {},
+					}
+
+					match sync_event_stream {
+						Poll::Ready(Some(event)) => match event {
+							SyncEvent::PeerConnected(remote) =>
+								this.network.add_set_reserved(remote, this.protocol.clone()),
+							SyncEvent::PeerDisconnected(remote) =>
+								this.network.remove_set_reserved(remote, this.protocol.clone()),
+						},
+						// The sync event stream closed. Do the same for [`GossipValidator`].
+						Poll::Ready(None) => {
+							self.is_terminated = true;
+							return Poll::Ready(())
+						},
+						Poll::Pending => {},
+					}
+				},
+				ForwardingState::Busy(to_forward) => {
+					let (topic, notification) = match to_forward.pop_front() {
+						Some(n) => n,
+						None => {
+							this.forwarding_state = ForwardingState::Idle;
+							continue
+						},
+					};
+
+					let sinks = match this.message_sinks.get_mut(&topic) {
+						Some(sinks) => sinks,
+						None => continue,
+					};
+
+					// Make sure all sinks for the given topic are ready.
+					for sink in sinks.iter_mut() {
+						match sink.poll_ready(cx) {
+							Poll::Ready(Ok(())) => {},
+							// Receiver has been dropped. Ignore for now, filtered out in (1).
+							Poll::Ready(Err(_)) => {},
+							Poll::Pending => {
+								// Push back onto queue for later.
+								to_forward.push_front((topic, notification));
+								break 'outer
+							},
+						}
+					}
+
+					// Filter out all closed sinks.
+					sinks.retain(|sink| !sink.is_closed()); // (1)
+
+					if sinks.is_empty() {
+						this.message_sinks.remove(&topic);
+						continue
+					}
+
+					trace!(
+						target: "gossip",
+						"Pushing consensus message to sinks for {}.", topic,
+					);
+
+					// Send the notification on each sink.
+					for sink in sinks {
+						match sink.start_send(notification.clone()) {
+							Ok(()) => {},
+							Err(e) if e.is_full() => {
+								unreachable!("Previously ensured that all sinks are ready; qed.")
+							},
+							// Receiver got dropped. Will be removed in next iteration (See (1)).
+							Err(_) => {},
+						}
+					}
+				},
+			}
+		}
+
+		while let Poll::Ready(()) = this.periodic_maintenance_interval.poll_unpin(cx) {
+			this.periodic_maintenance_interval.reset(PERIODIC_MAINTENANCE_INTERVAL);
+			this.state_machine.tick(&mut *this.network);
+
+			this.message_sinks.retain(|_, sinks| {
+				sinks.retain(|sink| !sink.is_closed());
+				!sinks.is_empty()
+			});
+		}
+
+		Poll::Pending
+	}
+}
+
+impl<B: BlockT> futures::future::FusedFuture for GossipEngine<B> {
+	fn is_terminated(&self) -> bool {
+		self.is_terminated
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{multiaddr::Multiaddr, ValidationResult, ValidatorContext};
+	use futures::{
+		channel::mpsc::{unbounded, UnboundedSender},
+		executor::{block_on, block_on_stream},
+		future::poll_fn,
+	};
+	use quickcheck::{Arbitrary, Gen, QuickCheck};
+	use sc_network::{
+		config::MultiaddrWithPeerId, NetworkBlock, NetworkEventStream, NetworkNotification,
+		NetworkPeers, NotificationSenderError, NotificationSenderT as NotificationSender,
+	};
+	use sc_network_common::{role::ObservedRole, sync::SyncEventStream};
+	use sp_runtime::{
+		testing::H256,
+		traits::{Block as BlockT, NumberFor},
+	};
+	use std::{
+		collections::HashSet,
+		sync::{Arc, Mutex},
+	};
+	use substrate_test_runtime_client::runtime::Block;
+
+	#[derive(Clone, Default)]
+	struct TestNetwork {
+		inner: Arc<Mutex<TestNetworkInner>>,
+	}
+
+	#[derive(Clone, Default)]
+	struct TestNetworkInner {
+		event_senders: Vec<UnboundedSender<Event>>,
+	}
+
+	impl NetworkPeers for TestNetwork {
+		fn set_authorized_peers(&self, _peers: HashSet<PeerId>) {
+			unimplemented!();
+		}
+
+		fn set_authorized_only(&self, _reserved_only: bool) {
+			unimplemented!();
+		}
+
+		fn add_known_address(&self, _peer_id: PeerId, _addr: Multiaddr) {
+			unimplemented!();
+		}
+
+		fn report_peer(&self, _who: PeerId, _cost_benefit: ReputationChange) {}
+
+		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+			unimplemented!();
+		}
+
+		fn accept_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn deny_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn add_reserved_peer(&self, _peer: MultiaddrWithPeerId) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_reserved_peer(&self, _peer_id: PeerId) {
+			unimplemented!();
+		}
+
+		fn set_reserved_peers(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn add_peers_to_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_peers_from_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: Vec<PeerId>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn sync_num_connected(&self) -> usize {
+			unimplemented!();
+		}
+	}
+
+	impl NetworkEventStream for TestNetwork {
+		fn event_stream(&self, _name: &'static str) -> Pin<Box<dyn Stream<Item = Event> + Send>> {
+			let (tx, rx) = unbounded();
+			self.inner.lock().unwrap().event_senders.push(tx);
+
+			Box::pin(rx)
+		}
+	}
+
+	impl NetworkNotification for TestNetwork {
+		fn write_notification(&self, _target: PeerId, _protocol: ProtocolName, _message: Vec<u8>) {
+			unimplemented!();
+		}
+
+		fn notification_sender(
+			&self,
+			_target: PeerId,
+			_protocol: ProtocolName,
+		) -> Result<Box<dyn NotificationSender>, NotificationSenderError> {
+			unimplemented!();
+		}
+
+		fn set_notification_handshake(&self, _protocol: ProtocolName, _handshake: Vec<u8>) {
+			unimplemented!();
+		}
+	}
+
+	impl NetworkBlock<<Block as BlockT>::Hash, NumberFor<Block>> for TestNetwork {
+		fn announce_block(&self, _hash: <Block as BlockT>::Hash, _data: Option<Vec<u8>>) {
+			unimplemented!();
+		}
+
+		fn new_best_block_imported(
+			&self,
+			_hash: <Block as BlockT>::Hash,
+			_number: NumberFor<Block>,
+		) {
+			unimplemented!();
+		}
+	}
+
+	#[derive(Clone, Default)]
+	struct TestSync {
+		inner: Arc<Mutex<TestSyncInner>>,
+	}
+
+	#[derive(Clone, Default)]
+	struct TestSyncInner {
+		event_senders: Vec<UnboundedSender<SyncEvent>>,
+	}
+
+	impl SyncEventStream for TestSync {
+		fn event_stream(
+			&self,
+			_name: &'static str,
+		) -> Pin<Box<dyn Stream<Item = SyncEvent> + Send>> {
+			let (tx, rx) = unbounded();
+			self.inner.lock().unwrap().event_senders.push(tx);
+
+			Box::pin(rx)
+		}
+	}
+
+	impl NetworkBlock<<Block as BlockT>::Hash, NumberFor<Block>> for TestSync {
+		fn announce_block(&self, _hash: <Block as BlockT>::Hash, _data: Option<Vec<u8>>) {
+			unimplemented!();
+		}
+
+		fn new_best_block_imported(
+			&self,
+			_hash: <Block as BlockT>::Hash,
+			_number: NumberFor<Block>,
+		) {
+			unimplemented!();
+		}
+	}
+
+	struct AllowAll;
+	impl Validator<Block> for AllowAll {
+		fn validate(
+			&self,
+			_context: &mut dyn ValidatorContext<Block>,
+			_sender: &PeerId,
+			_data: &[u8],
+		) -> ValidationResult<H256> {
+			ValidationResult::ProcessAndKeep(H256::default())
+		}
+	}
+
+	/// Regression test for the case where the `GossipEngine.network_event_stream` closes. One
+	/// should not ignore a `Poll::Ready(None)` as `poll_next_unpin` will panic on subsequent calls.
+	///
+	/// See https://github.com/paritytech/substrate/issues/5000 for details.
+	#[test]
+	fn returns_when_network_event_stream_closes() {
+		let network = TestNetwork::default();
+		let sync = Arc::new(TestSync::default());
+		let mut gossip_engine = GossipEngine::<Block>::new(
+			network.clone(),
+			sync,
+			"/my_protocol",
+			Arc::new(AllowAll {}),
+			None,
+		);
+
+		// Drop network event stream sender side.
+		drop(network.inner.lock().unwrap().event_senders.pop());
+
+		block_on(poll_fn(move |ctx| {
+			if let Poll::Pending = gossip_engine.poll_unpin(ctx) {
+				panic!(
+					"Expected gossip engine to finish on first poll, given that \
+					 `GossipEngine.network_event_stream` closes right away."
+				)
+			}
+			Poll::Ready(())
+		}))
+	}
+
+	#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+	async fn keeps_multiple_subscribers_per_topic_updated_with_both_old_and_new_messages() {
+		let topic = H256::default();
+		let protocol = ProtocolName::from("/my_protocol");
+		let remote_peer = PeerId::random();
+		let network = TestNetwork::default();
+		let sync = Arc::new(TestSync::default());
+
+		let mut gossip_engine = GossipEngine::<Block>::new(
+			network.clone(),
+			sync.clone(),
+			protocol.clone(),
+			Arc::new(AllowAll {}),
+			None,
+		);
+
+		let mut event_sender = network.inner.lock().unwrap().event_senders.pop().unwrap();
+
+		// Register the remote peer.
+		event_sender
+			.start_send(Event::NotificationStreamOpened {
+				remote: remote_peer,
+				protocol: protocol.clone(),
+				negotiated_fallback: None,
+				role: ObservedRole::Authority,
+				received_handshake: vec![],
+			})
+			.expect("Event stream is unbounded; qed.");
+
+		let messages = vec![vec![1], vec![2]];
+		let events = messages
+			.iter()
+			.cloned()
+			.map(|m| Event::NotificationsReceived {
+				remote: remote_peer,
+				messages: vec![(protocol.clone(), m.into())],
+			})
+			.collect::<Vec<_>>();
+
+		// Send first event before subscribing.
+		event_sender
+			.start_send(events[0].clone())
+			.expect("Event stream is unbounded; qed.");
+
+		let mut subscribers = vec![];
+		for _ in 0..2 {
+			subscribers.push(gossip_engine.messages_for(topic));
+		}
+
+		// Send second event after subscribing.
+		event_sender
+			.start_send(events[1].clone())
+			.expect("Event stream is unbounded; qed.");
+
+		tokio::spawn(gossip_engine);
+
+		// Note: `block_on_stream()`-derived iterator will block the current thread,
+		//       so we need a `multi_thread` `tokio::test` runtime flavor.
+		let mut subscribers =
+			subscribers.into_iter().map(|s| block_on_stream(s)).collect::<Vec<_>>();
+
+		// Expect each subscriber to receive both events.
+		for message in messages {
+			for subscriber in subscribers.iter_mut() {
+				assert_eq!(
+					subscriber.next(),
+					Some(TopicNotification { message: message.clone(), sender: Some(remote_peer) }),
+				);
+			}
+		}
+	}
+
+	#[test]
+	fn forwarding_to_different_size_and_topic_channels() {
+		#[derive(Clone, Debug)]
+		struct ChannelLengthAndTopic {
+			length: usize,
+			topic: H256,
+		}
+
+		impl Arbitrary for ChannelLengthAndTopic {
+			fn arbitrary(g: &mut Gen) -> Self {
+				let possible_length = (0..100).collect::<Vec<usize>>();
+				let possible_topics = (0..10).collect::<Vec<u64>>();
+				Self {
+					length: *g.choose(&possible_length).unwrap(),
+					// Make sure channel topics and message topics overlap by choosing a small
+					// range.
+					topic: H256::from_low_u64_ne(*g.choose(&possible_topics).unwrap()),
+				}
+			}
+		}
+
+		#[derive(Clone, Debug)]
+		struct Message {
+			topic: H256,
+		}
+
+		impl Arbitrary for Message {
+			fn arbitrary(g: &mut Gen) -> Self {
+				let possible_topics = (0..10).collect::<Vec<u64>>();
+				Self {
+					// Make sure channel topics and message topics overlap by choosing a small
+					// range.
+					topic: H256::from_low_u64_ne(*g.choose(&possible_topics).unwrap()),
+				}
+			}
+		}
+
+		/// Validator that always returns `ProcessAndKeep` interpreting the first 32 bytes of data
+		/// as the message topic.
+		struct TestValidator;
+
+		impl Validator<Block> for TestValidator {
+			fn validate(
+				&self,
+				_context: &mut dyn ValidatorContext<Block>,
+				_sender: &PeerId,
+				data: &[u8],
+			) -> ValidationResult<H256> {
+				ValidationResult::ProcessAndKeep(H256::from_slice(&data[0..32]))
+			}
+		}
+
+		fn prop(channels: Vec<ChannelLengthAndTopic>, notifications: Vec<Vec<Message>>) {
+			let protocol = ProtocolName::from("/my_protocol");
+			let remote_peer = PeerId::random();
+			let network = TestNetwork::default();
+			let sync = Arc::new(TestSync::default());
+
+			let num_channels_per_topic = channels.iter().fold(
+				HashMap::new(),
+				|mut acc, ChannelLengthAndTopic { topic, .. }| {
+					acc.entry(topic).and_modify(|e| *e += 1).or_insert(1);
+					acc
+				},
+			);
+
+			let expected_msgs_per_topic_all_chan = notifications
+				.iter()
+				.fold(HashMap::new(), |mut acc, messages| {
+					for message in messages {
+						acc.entry(message.topic).and_modify(|e| *e += 1).or_insert(1);
+					}
+					acc
+				})
+				.into_iter()
+				// Messages are cloned for each channel with the corresponding topic, thus multiply
+				// with the amount of channels per topic. If there is no channel for a given topic,
+				// don't expect any messages for the topic to be received.
+				.map(|(topic, num)| (topic, num_channels_per_topic.get(&topic).unwrap_or(&0) * num))
+				.collect::<HashMap<H256, _>>();
+
+			let mut gossip_engine = GossipEngine::<Block>::new(
+				network.clone(),
+				sync.clone(),
+				protocol.clone(),
+				Arc::new(TestValidator {}),
+				None,
+			);
+
+			// Create channels.
+			let (txs, mut rxs) = channels
+				.iter()
+				.map(|ChannelLengthAndTopic { length, topic }| (*topic, channel(*length)))
+				.fold((vec![], vec![]), |mut acc, (topic, (tx, rx))| {
+					acc.0.push((topic, tx));
+					acc.1.push((topic, rx));
+					acc
+				});
+
+			// Insert sender sides into `gossip_engine`.
+			for (topic, tx) in txs {
+				match gossip_engine.message_sinks.get_mut(&topic) {
+					Some(entry) => entry.push(tx),
+					None => {
+						gossip_engine.message_sinks.insert(topic, vec![tx]);
+					},
+				}
+			}
+
+			let mut event_sender = network.inner.lock().unwrap().event_senders.pop().unwrap();
+
+			// Register the remote peer.
+			event_sender
+				.start_send(Event::NotificationStreamOpened {
+					remote: remote_peer,
+					protocol: protocol.clone(),
+					negotiated_fallback: None,
+					role: ObservedRole::Authority,
+					received_handshake: vec![],
+				})
+				.expect("Event stream is unbounded; qed.");
+
+			// Send messages into the network event stream.
+			for (i_notification, messages) in notifications.iter().enumerate() {
+				let messages = messages
+					.into_iter()
+					.enumerate()
+					.map(|(i_message, Message { topic })| {
+						// Embed the topic in the first 256 bytes of the message to be extracted by
+						// the [`TestValidator`] later on.
+						let mut message = topic.as_bytes().to_vec();
+
+						// Make sure the message is unique via `i_notification` and `i_message` to
+						// ensure [`ConsensusBridge`] does not deduplicate it.
+						message.push(i_notification.try_into().unwrap());
+						message.push(i_message.try_into().unwrap());
+
+						(protocol.clone(), message.into())
+					})
+					.collect();
+
+				event_sender
+					.start_send(Event::NotificationsReceived { remote: remote_peer, messages })
+					.expect("Event stream is unbounded; qed.");
+			}
+
+			let mut received_msgs_per_topic_all_chan = HashMap::<H256, _>::new();
+
+			// Poll both gossip engine and each receiver and track the amount of received messages.
+			block_on(poll_fn(|cx| {
+				loop {
+					if let Poll::Ready(()) = gossip_engine.poll_unpin(cx) {
+						unreachable!(
+							"Event stream sender side is not dropped, thus gossip engine does not \
+							 terminate",
+						);
+					}
+
+					let mut progress = false;
+
+					for (topic, rx) in rxs.iter_mut() {
+						match rx.poll_next_unpin(cx) {
+							Poll::Ready(Some(_)) => {
+								progress = true;
+								received_msgs_per_topic_all_chan
+									.entry(*topic)
+									.and_modify(|e| *e += 1)
+									.or_insert(1);
+							},
+							Poll::Ready(None) => {
+								unreachable!("Sender side of channel is never dropped")
+							},
+							Poll::Pending => {},
+						}
+					}
+
+					if !progress {
+						break
+					}
+				}
+				Poll::Ready(())
+			}));
+
+			// Compare amount of expected messages with amount of received messages.
+			for (expected_topic, expected_num) in expected_msgs_per_topic_all_chan.iter() {
+				assert_eq!(
+					received_msgs_per_topic_all_chan.get(&expected_topic).unwrap_or(&0),
+					expected_num,
+				);
+			}
+			for (received_topic, received_num) in expected_msgs_per_topic_all_chan.iter() {
+				assert_eq!(
+					expected_msgs_per_topic_all_chan.get(&received_topic).unwrap_or(&0),
+					received_num,
+				);
+			}
+		}
+
+		// Past regressions.
+		prop(vec![], vec![vec![Message { topic: H256::default() }]]);
+		prop(
+			vec![ChannelLengthAndTopic { length: 71, topic: H256::default() }],
+			vec![vec![Message { topic: H256::default() }]],
+		);
+
+		QuickCheck::new().quickcheck(prop as fn(_, _))
+	}
+}
diff --git a/substrate/client/network-gossip/src/lib.rs b/substrate/client/network-gossip/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5b02be5c23f69f630957434190d2da6a8a654309
--- /dev/null
+++ b/substrate/client/network-gossip/src/lib.rs
@@ -0,0 +1,105 @@
+// 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/>.
+
+//! Polite gossiping.
+//!
+//! This crate provides gossiping capabilities on top of a network.
+//!
+//! Gossip messages are separated by two categories: "topics" and consensus engine ID.
+//! The consensus engine ID is sent over the wire with the message, while the topic is not,
+//! with the expectation that the topic can be derived implicitly from the content of the
+//! message, assuming it is valid.
+//!
+//! Topics are a single 32-byte tag associated with a message, used to group those messages
+//! in an opaque way. Consensus code can invoke [`ValidatorContext::broadcast_topic`] to
+//! attempt to send all messages under a single topic to all peers who don't have them yet, and
+//! [`ValidatorContext::send_topic`] to send all messages under a single topic to a specific peer.
+//!
+//! # Usage
+//!
+//! - Implement the [`Network`] trait, representing the low-level networking primitives. It is
+//!   already implemented on `sc_network::NetworkService`.
+//! - Implement the [`Validator`] trait. See the section below.
+//! - Decide on a protocol name. Each gossiping protocol should have a different one.
+//! - Build a [`GossipEngine`] using these three elements.
+//! - Use the methods of the [`GossipEngine`] in order to send out messages and receive incoming
+//!   messages.
+//!
+//! The [`GossipEngine`] will automatically use [`Network::add_set_reserved`] and
+//! [`NetworkPeers::remove_peers_from_reserved_set`] to maintain a set of peers equal to the set of
+//! peers the node is syncing from. See the documentation of `sc-network` for more explanations
+//! about the concepts of peer sets.
+//!
+//! # What is a validator?
+//!
+//! The primary role of a [`Validator`] is to process incoming messages from peers, and decide
+//! whether to discard them or process them. It also decides whether to re-broadcast the message.
+//!
+//! The secondary role of the [`Validator`] is to check if a message is allowed to be sent to a
+//! given peer. All messages, before being sent, will be checked against this filter.
+//! This enables the validator to use information it's aware of about connected peers to decide
+//! whether to send messages to them at any given moment in time - In particular, to wait until
+//! peers can accept and process the message before sending it.
+//!
+//! Lastly, the fact that gossip validators can decide not to rebroadcast messages
+//! opens the door for neighbor status packets to be baked into the gossip protocol.
+//! These status packets will typically contain light pieces of information
+//! used to inform peers of a current view of protocol state.
+
+pub use self::{
+	bridge::GossipEngine,
+	state_machine::TopicNotification,
+	validator::{DiscardAll, MessageIntent, ValidationResult, Validator, ValidatorContext},
+};
+
+use libp2p::{multiaddr, PeerId};
+use sc_network::{
+	types::ProtocolName, NetworkBlock, NetworkEventStream, NetworkNotification, NetworkPeers,
+};
+use sc_network_common::sync::SyncEventStream;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::iter;
+
+mod bridge;
+mod state_machine;
+mod validator;
+
+/// Abstraction over a network.
+pub trait Network<B: BlockT>: NetworkPeers + NetworkEventStream + NetworkNotification {
+	fn add_set_reserved(&self, who: PeerId, protocol: ProtocolName) {
+		let addr =
+			iter::once(multiaddr::Protocol::P2p(who.into())).collect::<multiaddr::Multiaddr>();
+		let result = self.add_peers_to_reserved_set(protocol, iter::once(addr).collect());
+		if let Err(err) = result {
+			log::error!(target: "gossip", "add_set_reserved failed: {}", err);
+		}
+	}
+	fn remove_set_reserved(&self, who: PeerId, protocol: ProtocolName) {
+		let result = self.remove_peers_from_reserved_set(protocol, iter::once(who).collect());
+		if let Err(err) = result {
+			log::error!(target: "gossip", "remove_set_reserved failed: {}", err);
+		}
+	}
+}
+
+impl<T, B: BlockT> Network<B> for T where T: NetworkPeers + NetworkEventStream + NetworkNotification {}
+
+/// Abstraction over the syncing subsystem.
+pub trait Syncing<B: BlockT>: SyncEventStream + NetworkBlock<B::Hash, NumberFor<B>> {}
+
+impl<T, B: BlockT> Syncing<B> for T where T: SyncEventStream + NetworkBlock<B::Hash, NumberFor<B>> {}
diff --git a/substrate/client/network-gossip/src/state_machine.rs b/substrate/client/network-gossip/src/state_machine.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4bfb5a7d37f49bf6d8325006dd65420cdbb7fb42
--- /dev/null
+++ b/substrate/client/network-gossip/src/state_machine.rs
@@ -0,0 +1,843 @@
+// 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::{MessageIntent, Network, ValidationResult, Validator, ValidatorContext};
+
+use ahash::AHashSet;
+use libp2p::PeerId;
+use schnellru::{ByLength, LruMap};
+
+use prometheus_endpoint::{register, Counter, PrometheusError, Registry, U64};
+use sc_network::types::ProtocolName;
+use sc_network_common::role::ObservedRole;
+use sp_runtime::traits::{Block as BlockT, Hash, HashingFor};
+use std::{collections::HashMap, iter, sync::Arc, time, time::Instant};
+
+// FIXME: Add additional spam/DoS attack protection: https://github.com/paritytech/substrate/issues/1115
+// NOTE: The current value is adjusted based on largest production network deployment (Kusama) and
+// the current main gossip user (GRANDPA). Currently there are ~800 validators on Kusama, as such,
+// each GRANDPA round should generate ~1600 messages, and we currently keep track of the last 2
+// completed rounds and the current live one. That makes it so that at any point we will be holding
+// ~4800 live messages.
+//
+// Assuming that each known message is tracked with a 32 byte hash (common for `Block::Hash`), then
+// this cache should take about 256 KB of memory.
+const KNOWN_MESSAGES_CACHE_SIZE: u32 = 8192;
+
+const REBROADCAST_INTERVAL: time::Duration = time::Duration::from_millis(750);
+
+pub(crate) const PERIODIC_MAINTENANCE_INTERVAL: time::Duration = time::Duration::from_millis(1100);
+
+mod rep {
+	use sc_network::ReputationChange as Rep;
+	/// Reputation change when a peer sends us a gossip message that we didn't know about.
+	pub const GOSSIP_SUCCESS: Rep = Rep::new(1 << 4, "Successful gossip");
+	/// Reputation change when a peer sends us a gossip message that we already knew about.
+	pub const DUPLICATE_GOSSIP: Rep = Rep::new(-(1 << 2), "Duplicate gossip");
+}
+
+struct PeerConsensus<H> {
+	known_messages: AHashSet<H>,
+}
+
+/// Topic stream message with sender.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct TopicNotification {
+	/// Message data.
+	pub message: Vec<u8>,
+	/// Sender if available.
+	pub sender: Option<PeerId>,
+}
+
+struct MessageEntry<B: BlockT> {
+	message_hash: B::Hash,
+	topic: B::Hash,
+	message: Vec<u8>,
+	sender: Option<PeerId>,
+}
+
+/// Local implementation of `ValidatorContext`.
+struct NetworkContext<'g, 'p, B: BlockT> {
+	gossip: &'g mut ConsensusGossip<B>,
+	network: &'p mut dyn Network<B>,
+}
+
+impl<'g, 'p, B: BlockT> ValidatorContext<B> for NetworkContext<'g, 'p, B> {
+	/// Broadcast all messages with given topic to peers that do not have it yet.
+	fn broadcast_topic(&mut self, topic: B::Hash, force: bool) {
+		self.gossip.broadcast_topic(self.network, topic, force);
+	}
+
+	/// Broadcast a message to all peers that have not received it previously.
+	fn broadcast_message(&mut self, topic: B::Hash, message: Vec<u8>, force: bool) {
+		self.gossip.multicast(self.network, topic, message, force);
+	}
+
+	/// Send addressed message to a peer.
+	fn send_message(&mut self, who: &PeerId, message: Vec<u8>) {
+		self.network.write_notification(*who, self.gossip.protocol.clone(), message);
+	}
+
+	/// Send all messages with given topic to a peer.
+	fn send_topic(&mut self, who: &PeerId, topic: B::Hash, force: bool) {
+		self.gossip.send_topic(self.network, who, topic, force);
+	}
+}
+
+fn propagate<'a, B: BlockT, I>(
+	network: &mut dyn Network<B>,
+	protocol: ProtocolName,
+	messages: I,
+	intent: MessageIntent,
+	peers: &mut HashMap<PeerId, PeerConsensus<B::Hash>>,
+	validator: &Arc<dyn Validator<B>>,
+)
+// (msg_hash, topic, message)
+where
+	I: Clone + IntoIterator<Item = (&'a B::Hash, &'a B::Hash, &'a Vec<u8>)>,
+{
+	let mut message_allowed = validator.message_allowed();
+
+	for (id, ref mut peer) in peers.iter_mut() {
+		for (message_hash, topic, message) in messages.clone() {
+			let intent = match intent {
+				MessageIntent::Broadcast { .. } =>
+					if peer.known_messages.contains(message_hash) {
+						continue
+					} else {
+						MessageIntent::Broadcast
+					},
+				MessageIntent::PeriodicRebroadcast => {
+					if peer.known_messages.contains(message_hash) {
+						MessageIntent::PeriodicRebroadcast
+					} else {
+						// peer doesn't know message, so the logic should treat it as an
+						// initial broadcast.
+						MessageIntent::Broadcast
+					}
+				},
+				other => other,
+			};
+
+			if !message_allowed(id, intent, topic, message) {
+				continue
+			}
+
+			peer.known_messages.insert(*message_hash);
+
+			tracing::trace!(
+				target: "gossip",
+				to = %id,
+				%protocol,
+				?message,
+				"Propagating message",
+			);
+			network.write_notification(*id, protocol.clone(), message.clone());
+		}
+	}
+}
+
+/// Consensus network protocol handler. Manages statements and candidate requests.
+pub struct ConsensusGossip<B: BlockT> {
+	peers: HashMap<PeerId, PeerConsensus<B::Hash>>,
+	messages: Vec<MessageEntry<B>>,
+	known_messages: LruMap<B::Hash, ()>,
+	protocol: ProtocolName,
+	validator: Arc<dyn Validator<B>>,
+	next_broadcast: Instant,
+	metrics: Option<Metrics>,
+}
+
+impl<B: BlockT> ConsensusGossip<B> {
+	/// Create a new instance using the given validator.
+	pub fn new(
+		validator: Arc<dyn Validator<B>>,
+		protocol: ProtocolName,
+		metrics_registry: Option<&Registry>,
+	) -> Self {
+		let metrics = match metrics_registry.map(Metrics::register) {
+			Some(Ok(metrics)) => Some(metrics),
+			Some(Err(e)) => {
+				tracing::debug!(target: "gossip", "Failed to register metrics: {:?}", e);
+				None
+			},
+			None => None,
+		};
+
+		ConsensusGossip {
+			peers: HashMap::new(),
+			messages: Default::default(),
+			known_messages: { LruMap::new(ByLength::new(KNOWN_MESSAGES_CACHE_SIZE)) },
+			protocol,
+			validator,
+			next_broadcast: Instant::now() + REBROADCAST_INTERVAL,
+			metrics,
+		}
+	}
+
+	/// Handle new connected peer.
+	pub fn new_peer(&mut self, network: &mut dyn Network<B>, who: PeerId, role: ObservedRole) {
+		tracing::trace!(
+			target:"gossip",
+			%who,
+			protocol = %self.protocol,
+			?role,
+			"Registering peer",
+		);
+		self.peers.insert(who, PeerConsensus { known_messages: Default::default() });
+
+		let validator = self.validator.clone();
+		let mut context = NetworkContext { gossip: self, network };
+		validator.new_peer(&mut context, &who, role);
+	}
+
+	fn register_message_hashed(
+		&mut self,
+		message_hash: B::Hash,
+		topic: B::Hash,
+		message: Vec<u8>,
+		sender: Option<PeerId>,
+	) {
+		if self.known_messages.insert(message_hash, ()) {
+			self.messages.push(MessageEntry { message_hash, topic, message, sender });
+
+			if let Some(ref metrics) = self.metrics {
+				metrics.registered_messages.inc();
+			}
+		}
+	}
+
+	/// Registers a message without propagating it to any peers. The message
+	/// becomes available to new peers or when the service is asked to gossip
+	/// the message's topic. No validation is performed on the message, if the
+	/// message is already expired it should be dropped on the next garbage
+	/// collection.
+	pub fn register_message(&mut self, topic: B::Hash, message: Vec<u8>) {
+		let message_hash = HashingFor::<B>::hash(&message[..]);
+		self.register_message_hashed(message_hash, topic, message, None);
+	}
+
+	/// Call when a peer has been disconnected to stop tracking gossip status.
+	pub fn peer_disconnected(&mut self, network: &mut dyn Network<B>, who: PeerId) {
+		let validator = self.validator.clone();
+		let mut context = NetworkContext { gossip: self, network };
+		validator.peer_disconnected(&mut context, &who);
+		self.peers.remove(&who);
+	}
+
+	/// Perform periodic maintenance
+	pub fn tick(&mut self, network: &mut dyn Network<B>) {
+		self.collect_garbage();
+		if Instant::now() >= self.next_broadcast {
+			self.rebroadcast(network);
+			self.next_broadcast = Instant::now() + REBROADCAST_INTERVAL;
+		}
+	}
+
+	/// Rebroadcast all messages to all peers.
+	fn rebroadcast(&mut self, network: &mut dyn Network<B>) {
+		let messages = self
+			.messages
+			.iter()
+			.map(|entry| (&entry.message_hash, &entry.topic, &entry.message));
+		propagate(
+			network,
+			self.protocol.clone(),
+			messages,
+			MessageIntent::PeriodicRebroadcast,
+			&mut self.peers,
+			&self.validator,
+		);
+	}
+
+	/// Broadcast all messages with given topic.
+	pub fn broadcast_topic(&mut self, network: &mut dyn Network<B>, topic: B::Hash, force: bool) {
+		let messages = self.messages.iter().filter_map(|entry| {
+			if entry.topic == topic {
+				Some((&entry.message_hash, &entry.topic, &entry.message))
+			} else {
+				None
+			}
+		});
+		let intent = if force { MessageIntent::ForcedBroadcast } else { MessageIntent::Broadcast };
+		propagate(
+			network,
+			self.protocol.clone(),
+			messages,
+			intent,
+			&mut self.peers,
+			&self.validator,
+		);
+	}
+
+	/// Prune old or no longer relevant consensus messages. Provide a predicate
+	/// for pruning, which returns `false` when the items with a given topic should be pruned.
+	pub fn collect_garbage(&mut self) {
+		let known_messages = &mut self.known_messages;
+		let before = self.messages.len();
+
+		let mut message_expired = self.validator.message_expired();
+		self.messages.retain(|entry| !message_expired(entry.topic, &entry.message));
+
+		let expired_messages = before - self.messages.len();
+
+		if let Some(ref metrics) = self.metrics {
+			metrics.expired_messages.inc_by(expired_messages as u64)
+		}
+
+		tracing::trace!(
+			target: "gossip",
+			protocol = %self.protocol,
+			"Cleaned up {} stale messages, {} left ({} known)",
+			expired_messages,
+			self.messages.len(),
+			known_messages.len(),
+		);
+
+		for (_, ref mut peer) in self.peers.iter_mut() {
+			peer.known_messages.retain(|h| known_messages.get(h).is_some());
+		}
+	}
+
+	/// Get valid messages received in the past for a topic (might have expired meanwhile).
+	pub fn messages_for(&mut self, topic: B::Hash) -> impl Iterator<Item = TopicNotification> + '_ {
+		self.messages
+			.iter()
+			.filter(move |e| e.topic == topic)
+			.map(|entry| TopicNotification { message: entry.message.clone(), sender: entry.sender })
+	}
+
+	/// Register incoming messages and return the ones that are new and valid (according to a gossip
+	/// validator) and should thus be forwarded to the upper layers.
+	pub fn on_incoming(
+		&mut self,
+		network: &mut dyn Network<B>,
+		who: PeerId,
+		messages: Vec<Vec<u8>>,
+	) -> Vec<(B::Hash, TopicNotification)> {
+		let mut to_forward = vec![];
+
+		if !messages.is_empty() {
+			tracing::trace!(
+				target: "gossip",
+				messages_num = %messages.len(),
+				%who,
+				protocol = %self.protocol,
+				"Received messages from peer",
+			);
+		}
+
+		for message in messages {
+			let message_hash = HashingFor::<B>::hash(&message[..]);
+
+			if self.known_messages.get(&message_hash).is_some() {
+				tracing::trace!(
+					target: "gossip",
+					%who,
+					protocol = %self.protocol,
+					"Ignored already known message",
+				);
+
+				// If the peer already send us the message once, let's report them.
+				if self
+					.peers
+					.get_mut(&who)
+					.map_or(false, |p| !p.known_messages.insert(message_hash))
+				{
+					network.report_peer(who, rep::DUPLICATE_GOSSIP);
+				}
+				continue
+			}
+
+			// validate the message
+			let validation = {
+				let validator = self.validator.clone();
+				let mut context = NetworkContext { gossip: self, network };
+				validator.validate(&mut context, &who, &message)
+			};
+
+			let (topic, keep) = match validation {
+				ValidationResult::ProcessAndKeep(topic) => (topic, true),
+				ValidationResult::ProcessAndDiscard(topic) => (topic, false),
+				ValidationResult::Discard => {
+					tracing::trace!(
+						target: "gossip",
+						%who,
+						protocol = %self.protocol,
+						"Discard message from peer",
+					);
+					continue
+				},
+			};
+
+			let peer = match self.peers.get_mut(&who) {
+				Some(peer) => peer,
+				None => {
+					tracing::error!(
+						target: "gossip",
+						%who,
+						protocol = %self.protocol,
+						"Got message from unregistered peer",
+					);
+					continue
+				},
+			};
+
+			network.report_peer(who, rep::GOSSIP_SUCCESS);
+			peer.known_messages.insert(message_hash);
+			to_forward
+				.push((topic, TopicNotification { message: message.clone(), sender: Some(who) }));
+
+			if keep {
+				self.register_message_hashed(message_hash, topic, message, Some(who));
+			}
+		}
+
+		to_forward
+	}
+
+	/// Send all messages with given topic to a peer.
+	pub fn send_topic(
+		&mut self,
+		network: &mut dyn Network<B>,
+		who: &PeerId,
+		topic: B::Hash,
+		force: bool,
+	) {
+		let mut message_allowed = self.validator.message_allowed();
+
+		if let Some(ref mut peer) = self.peers.get_mut(who) {
+			for entry in self.messages.iter().filter(|m| m.topic == topic) {
+				let intent =
+					if force { MessageIntent::ForcedBroadcast } else { MessageIntent::Broadcast };
+
+				if !force && peer.known_messages.contains(&entry.message_hash) {
+					continue
+				}
+
+				if !message_allowed(who, intent, &entry.topic, &entry.message) {
+					continue
+				}
+
+				peer.known_messages.insert(entry.message_hash);
+
+				tracing::trace!(
+					target: "gossip",
+					to = %who,
+					protocol = %self.protocol,
+					?entry.message,
+					"Sending topic message",
+				);
+				network.write_notification(*who, self.protocol.clone(), entry.message.clone());
+			}
+		}
+	}
+
+	/// Multicast a message to all peers.
+	pub fn multicast(
+		&mut self,
+		network: &mut dyn Network<B>,
+		topic: B::Hash,
+		message: Vec<u8>,
+		force: bool,
+	) {
+		let message_hash = HashingFor::<B>::hash(&message);
+		self.register_message_hashed(message_hash, topic, message.clone(), None);
+		let intent = if force { MessageIntent::ForcedBroadcast } else { MessageIntent::Broadcast };
+		propagate(
+			network,
+			self.protocol.clone(),
+			iter::once((&message_hash, &topic, &message)),
+			intent,
+			&mut self.peers,
+			&self.validator,
+		);
+	}
+
+	/// Send addressed message to a peer. The message is not kept or multicast
+	/// later on.
+	pub fn send_message(&mut self, network: &mut dyn Network<B>, who: &PeerId, message: Vec<u8>) {
+		let peer = match self.peers.get_mut(who) {
+			None => return,
+			Some(peer) => peer,
+		};
+
+		let message_hash = HashingFor::<B>::hash(&message);
+
+		tracing::trace!(
+			target: "gossip",
+			to = %who,
+			protocol = %self.protocol,
+			?message,
+			"Sending direct message",
+		);
+
+		peer.known_messages.insert(message_hash);
+		network.write_notification(*who, self.protocol.clone(), message);
+	}
+}
+
+struct Metrics {
+	registered_messages: Counter<U64>,
+	expired_messages: Counter<U64>,
+}
+
+impl Metrics {
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			registered_messages: register(
+				Counter::new(
+					"substrate_network_gossip_registered_messages_total",
+					"Number of registered messages by the gossip service.",
+				)?,
+				registry,
+			)?,
+			expired_messages: register(
+				Counter::new(
+					"substrate_network_gossip_expired_messages_total",
+					"Number of expired messages by the gossip service.",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::multiaddr::Multiaddr;
+	use futures::prelude::*;
+	use sc_network::{
+		config::MultiaddrWithPeerId, event::Event, NetworkBlock, NetworkEventStream,
+		NetworkNotification, NetworkPeers, NotificationSenderError,
+		NotificationSenderT as NotificationSender, ReputationChange,
+	};
+	use sp_runtime::{
+		testing::{Block as RawBlock, ExtrinsicWrapper, H256},
+		traits::NumberFor,
+	};
+	use std::{
+		collections::HashSet,
+		pin::Pin,
+		sync::{Arc, Mutex},
+	};
+
+	type Block = RawBlock<ExtrinsicWrapper<u64>>;
+
+	macro_rules! push_msg {
+		($consensus:expr, $topic:expr, $hash: expr, $m:expr) => {
+			if $consensus.known_messages.insert($hash, ()) {
+				$consensus.messages.push(MessageEntry {
+					message_hash: $hash,
+					topic: $topic,
+					message: $m,
+					sender: None,
+				});
+			}
+		};
+	}
+
+	struct AllowAll;
+	impl Validator<Block> for AllowAll {
+		fn validate(
+			&self,
+			_context: &mut dyn ValidatorContext<Block>,
+			_sender: &PeerId,
+			_data: &[u8],
+		) -> ValidationResult<H256> {
+			ValidationResult::ProcessAndKeep(H256::default())
+		}
+	}
+
+	struct DiscardAll;
+	impl Validator<Block> for DiscardAll {
+		fn validate(
+			&self,
+			_context: &mut dyn ValidatorContext<Block>,
+			_sender: &PeerId,
+			_data: &[u8],
+		) -> ValidationResult<H256> {
+			ValidationResult::Discard
+		}
+	}
+
+	#[derive(Clone, Default)]
+	struct NoOpNetwork {
+		inner: Arc<Mutex<NoOpNetworkInner>>,
+	}
+
+	#[derive(Clone, Default)]
+	struct NoOpNetworkInner {
+		peer_reports: Vec<(PeerId, ReputationChange)>,
+	}
+
+	impl NetworkPeers for NoOpNetwork {
+		fn set_authorized_peers(&self, _peers: HashSet<PeerId>) {
+			unimplemented!();
+		}
+
+		fn set_authorized_only(&self, _reserved_only: bool) {
+			unimplemented!();
+		}
+
+		fn add_known_address(&self, _peer_id: PeerId, _addr: Multiaddr) {
+			unimplemented!();
+		}
+
+		fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
+			self.inner.lock().unwrap().peer_reports.push((who, cost_benefit));
+		}
+
+		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+			unimplemented!();
+		}
+
+		fn accept_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn deny_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn add_reserved_peer(&self, _peer: MultiaddrWithPeerId) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_reserved_peer(&self, _peer_id: PeerId) {
+			unimplemented!();
+		}
+
+		fn set_reserved_peers(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn add_peers_to_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_peers_from_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: Vec<PeerId>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn sync_num_connected(&self) -> usize {
+			unimplemented!();
+		}
+	}
+
+	impl NetworkEventStream for NoOpNetwork {
+		fn event_stream(&self, _name: &'static str) -> Pin<Box<dyn Stream<Item = Event> + Send>> {
+			unimplemented!();
+		}
+	}
+
+	impl NetworkNotification for NoOpNetwork {
+		fn write_notification(&self, _target: PeerId, _protocol: ProtocolName, _message: Vec<u8>) {
+			unimplemented!();
+		}
+
+		fn notification_sender(
+			&self,
+			_target: PeerId,
+			_protocol: ProtocolName,
+		) -> Result<Box<dyn NotificationSender>, NotificationSenderError> {
+			unimplemented!();
+		}
+
+		fn set_notification_handshake(&self, _protocol: ProtocolName, _handshake: Vec<u8>) {
+			unimplemented!();
+		}
+	}
+
+	impl NetworkBlock<<Block as BlockT>::Hash, NumberFor<Block>> for NoOpNetwork {
+		fn announce_block(&self, _hash: <Block as BlockT>::Hash, _data: Option<Vec<u8>>) {
+			unimplemented!();
+		}
+
+		fn new_best_block_imported(
+			&self,
+			_hash: <Block as BlockT>::Hash,
+			_number: NumberFor<Block>,
+		) {
+			unimplemented!();
+		}
+	}
+
+	#[test]
+	fn collects_garbage() {
+		struct AllowOne;
+		impl Validator<Block> for AllowOne {
+			fn validate(
+				&self,
+				_context: &mut dyn ValidatorContext<Block>,
+				_sender: &PeerId,
+				data: &[u8],
+			) -> ValidationResult<H256> {
+				if data[0] == 1 {
+					ValidationResult::ProcessAndKeep(H256::default())
+				} else {
+					ValidationResult::Discard
+				}
+			}
+
+			fn message_expired<'a>(&'a self) -> Box<dyn FnMut(H256, &[u8]) -> bool + 'a> {
+				Box::new(move |_topic, data| data[0] != 1)
+			}
+		}
+
+		let prev_hash = H256::random();
+		let best_hash = H256::random();
+		let mut consensus = ConsensusGossip::<Block>::new(Arc::new(AllowAll), "/foo".into(), None);
+		let m1_hash = H256::random();
+		let m2_hash = H256::random();
+		let m1 = vec![1, 2, 3];
+		let m2 = vec![4, 5, 6];
+
+		push_msg!(consensus, prev_hash, m1_hash, m1);
+		push_msg!(consensus, best_hash, m2_hash, m2);
+		consensus.known_messages.insert(m1_hash, ());
+		consensus.known_messages.insert(m2_hash, ());
+
+		consensus.collect_garbage();
+		assert_eq!(consensus.messages.len(), 2);
+		assert_eq!(consensus.known_messages.len(), 2);
+
+		consensus.validator = Arc::new(AllowOne);
+
+		// m2 is expired
+		consensus.collect_garbage();
+		assert_eq!(consensus.messages.len(), 1);
+		// known messages are only pruned based on size.
+		assert_eq!(consensus.known_messages.len(), 2);
+		assert!(consensus.known_messages.get(&m2_hash).is_some());
+	}
+
+	#[test]
+	fn message_stream_include_those_sent_before_asking() {
+		let mut consensus = ConsensusGossip::<Block>::new(Arc::new(AllowAll), "/foo".into(), None);
+
+		// Register message.
+		let message = vec![4, 5, 6];
+		let topic = HashingFor::<Block>::hash(&[1, 2, 3]);
+		consensus.register_message(topic, message.clone());
+
+		assert_eq!(
+			consensus.messages_for(topic).next(),
+			Some(TopicNotification { message, sender: None }),
+		);
+	}
+
+	#[test]
+	fn can_keep_multiple_messages_per_topic() {
+		let mut consensus = ConsensusGossip::<Block>::new(Arc::new(AllowAll), "/foo".into(), None);
+
+		let topic = [1; 32].into();
+		let msg_a = vec![1, 2, 3];
+		let msg_b = vec![4, 5, 6];
+
+		consensus.register_message(topic, msg_a);
+		consensus.register_message(topic, msg_b);
+
+		assert_eq!(consensus.messages.len(), 2);
+	}
+
+	#[test]
+	fn peer_is_removed_on_disconnect() {
+		let mut consensus = ConsensusGossip::<Block>::new(Arc::new(AllowAll), "/foo".into(), None);
+
+		let mut network = NoOpNetwork::default();
+
+		let peer_id = PeerId::random();
+		consensus.new_peer(&mut network, peer_id, ObservedRole::Full);
+		assert!(consensus.peers.contains_key(&peer_id));
+
+		consensus.peer_disconnected(&mut network, peer_id);
+		assert!(!consensus.peers.contains_key(&peer_id));
+	}
+
+	#[test]
+	fn on_incoming_ignores_discarded_messages() {
+		let to_forward = ConsensusGossip::<Block>::new(Arc::new(DiscardAll), "/foo".into(), None)
+			.on_incoming(&mut NoOpNetwork::default(), PeerId::random(), vec![vec![1, 2, 3]]);
+
+		assert!(
+			to_forward.is_empty(),
+			"Expected `on_incoming` to ignore discarded message but got {:?}",
+			to_forward,
+		);
+	}
+
+	#[test]
+	fn on_incoming_ignores_unregistered_peer() {
+		let mut network = NoOpNetwork::default();
+		let remote = PeerId::random();
+
+		let to_forward = ConsensusGossip::<Block>::new(Arc::new(AllowAll), "/foo".into(), None)
+			.on_incoming(
+				&mut network,
+				// Unregistered peer.
+				remote,
+				vec![vec![1, 2, 3]],
+			);
+
+		assert!(
+			to_forward.is_empty(),
+			"Expected `on_incoming` to ignore message from unregistered peer but got {:?}",
+			to_forward,
+		);
+	}
+
+	// Two peers can send us the same gossip message. We should not report the second peer
+	// sending the gossip message as long as its the first time the peer send us this message.
+	#[test]
+	fn do_not_report_peer_for_first_time_duplicate_gossip_message() {
+		let mut consensus = ConsensusGossip::<Block>::new(Arc::new(AllowAll), "/foo".into(), None);
+
+		let mut network = NoOpNetwork::default();
+
+		let peer_id = PeerId::random();
+		consensus.new_peer(&mut network, peer_id, ObservedRole::Full);
+		assert!(consensus.peers.contains_key(&peer_id));
+
+		let peer_id2 = PeerId::random();
+		consensus.new_peer(&mut network, peer_id2, ObservedRole::Full);
+		assert!(consensus.peers.contains_key(&peer_id2));
+
+		let message = vec![vec![1, 2, 3]];
+		consensus.on_incoming(&mut network, peer_id, message.clone());
+		consensus.on_incoming(&mut network, peer_id2, message.clone());
+
+		assert_eq!(
+			vec![(peer_id, rep::GOSSIP_SUCCESS)],
+			network.inner.lock().unwrap().peer_reports
+		);
+	}
+}
diff --git a/substrate/client/network-gossip/src/validator.rs b/substrate/client/network-gossip/src/validator.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2272efba50652492178fe7cfa2c0bcbd731e9138
--- /dev/null
+++ b/substrate/client/network-gossip/src/validator.rs
@@ -0,0 +1,109 @@
+// 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 libp2p::PeerId;
+use sc_network_common::role::ObservedRole;
+use sp_runtime::traits::Block as BlockT;
+
+/// Validates consensus messages.
+pub trait Validator<B: BlockT>: Send + Sync {
+	/// New peer is connected.
+	fn new_peer(&self, _context: &mut dyn ValidatorContext<B>, _who: &PeerId, _role: ObservedRole) {
+	}
+
+	/// New connection is dropped.
+	fn peer_disconnected(&self, _context: &mut dyn ValidatorContext<B>, _who: &PeerId) {}
+
+	/// Validate consensus message.
+	fn validate(
+		&self,
+		context: &mut dyn ValidatorContext<B>,
+		sender: &PeerId,
+		data: &[u8],
+	) -> ValidationResult<B::Hash>;
+
+	/// Produce a closure for validating messages on a given topic.
+	fn message_expired<'a>(&'a self) -> Box<dyn FnMut(B::Hash, &[u8]) -> bool + 'a> {
+		Box::new(move |_topic, _data| false)
+	}
+
+	/// Produce a closure for filtering egress messages.
+	fn message_allowed<'a>(
+		&'a self,
+	) -> Box<dyn FnMut(&PeerId, MessageIntent, &B::Hash, &[u8]) -> bool + 'a> {
+		Box::new(move |_who, _intent, _topic, _data| true)
+	}
+}
+
+/// Validation context. Allows reacting to incoming messages by sending out further messages.
+pub trait ValidatorContext<B: BlockT> {
+	/// Broadcast all messages with given topic to peers that do not have it yet.
+	fn broadcast_topic(&mut self, topic: B::Hash, force: bool);
+	/// Broadcast a message to all peers that have not received it previously.
+	fn broadcast_message(&mut self, topic: B::Hash, message: Vec<u8>, force: bool);
+	/// Send addressed message to a peer.
+	fn send_message(&mut self, who: &PeerId, message: Vec<u8>);
+	/// Send all messages with given topic to a peer.
+	fn send_topic(&mut self, who: &PeerId, topic: B::Hash, force: bool);
+}
+
+/// The reason for sending out the message.
+#[derive(Eq, PartialEq, Copy, Clone)]
+#[cfg_attr(test, derive(Debug))]
+pub enum MessageIntent {
+	/// Requested broadcast.
+	Broadcast,
+	/// Requested broadcast to all peers.
+	ForcedBroadcast,
+	/// Periodic rebroadcast of all messages to all peers.
+	PeriodicRebroadcast,
+}
+
+/// Message validation result.
+pub enum ValidationResult<H> {
+	/// Message should be stored and propagated under given topic.
+	ProcessAndKeep(H),
+	/// Message should be processed, but not propagated.
+	ProcessAndDiscard(H),
+	/// Message should be ignored.
+	Discard,
+}
+
+/// A gossip message validator that discards all messages.
+pub struct DiscardAll;
+
+impl<B: BlockT> Validator<B> for DiscardAll {
+	fn validate(
+		&self,
+		_context: &mut dyn ValidatorContext<B>,
+		_sender: &PeerId,
+		_data: &[u8],
+	) -> ValidationResult<B::Hash> {
+		ValidationResult::Discard
+	}
+
+	fn message_expired<'a>(&'a self) -> Box<dyn FnMut(B::Hash, &[u8]) -> bool + 'a> {
+		Box::new(move |_topic, _data| true)
+	}
+
+	fn message_allowed<'a>(
+		&'a self,
+	) -> Box<dyn FnMut(&PeerId, MessageIntent, &B::Hash, &[u8]) -> bool + 'a> {
+		Box::new(move |_who, _intent, _topic, _data| false)
+	}
+}
diff --git a/substrate/client/network/Cargo.toml b/substrate/client/network/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..887368a02bccad51e163c6adf045aee1ae7570e6
--- /dev/null
+++ b/substrate/client/network/Cargo.toml
@@ -0,0 +1,69 @@
+[package]
+description = "Substrate network protocol"
+name = "sc-network"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+async-channel = "1.8.0"
+async-trait = "0.1"
+asynchronous-codec = "0.6"
+bytes = "1"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+either = "1.5.3"
+fnv = "1.0.6"
+futures = "0.3.21"
+futures-timer = "3.0.2"
+ip_network = "0.4.1"
+libp2p = { version = "0.51.3", features = ["dns", "identify", "kad", "macros", "mdns", "noise", "ping", "tcp",  "tokio", "yamux", "websocket", "request-response"] }
+linked_hash_set = "0.1.3"
+log = "0.4.17"
+mockall = "0.11.3"
+parking_lot = "0.12.1"
+partial_sort = "0.2.0"
+pin-project = "1.0.12"
+rand = "0.8.5"
+serde = { version = "1.0.163", features = ["derive"] }
+serde_json = "1.0.85"
+smallvec = "1.11.0"
+thiserror = "1.0"
+unsigned-varint = { version = "0.7.1", features = ["futures", "asynchronous_codec"] }
+zeroize = "1.4.3"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-network-common = { version = "0.10.0-dev", path = "./common" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+sp-arithmetic = { version = "16.0.0", path = "../../primitives/arithmetic" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+wasm-timer = "0.2"
+
+[dev-dependencies]
+assert_matches = "1.3"
+mockall = "0.11.3"
+multistream-select = "0.12.1"
+rand = "0.8.5"
+tempfile = "3.1.0"
+tokio = { version = "1.22.0", features = ["macros"] }
+tokio-util = { version = "0.7.4", features = ["compat"] }
+tokio-test = "0.4.2"
+sc-network-light = { version = "0.10.0-dev", path = "./light" }
+sc-network-sync = { version = "0.10.0-dev", path = "./sync" }
+sp-test-primitives = { version = "2.0.0", path = "../../primitives/test-primitives" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+
+[features]
+default = []
diff --git a/substrate/client/network/README.md b/substrate/client/network/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cad46d059092c366754df98181e978651b8e3fa6
--- /dev/null
+++ b/substrate/client/network/README.md
@@ -0,0 +1,287 @@
+Substrate-specific P2P networking.
+
+**Important**: This crate is unstable and the API and usage may change.
+
+# Node identities and addresses
+
+In a decentralized network, each node possesses a network private key and a network public key.
+In Substrate, the keys are based on the ed25519 curve.
+
+From a node's public key, we can derive its *identity*. In Substrate and libp2p, a node's
+identity is represented with the [`PeerId`] struct. All network communications between nodes on
+the network use encryption derived from both sides's keys, which means that **identities cannot
+be faked**.
+
+A node's identity uniquely identifies a machine on the network. If you start two or more
+clients using the same network key, large interferences will happen.
+
+# Substrate's network protocol
+
+Substrate's networking protocol is based upon libp2p. It is at the moment not possible and not
+planned to permit using something else than the libp2p network stack and the rust-libp2p
+library. However the libp2p framework is very flexible and the rust-libp2p library could be
+extended to support a wider range of protocols than what is offered by libp2p.
+
+## Discovery mechanisms
+
+In order for our node to join a peer-to-peer network, it has to know a list of nodes that are
+part of said network. This includes nodes identities and their address (how to reach them).
+Building such a list is called the **discovery** mechanism. There are three mechanisms that
+Substrate uses:
+
+- Bootstrap nodes. These are hard-coded node identities and addresses passed alongside with
+the network configuration.
+- mDNS. We perform a UDP broadcast on the local network. Nodes that listen may respond with
+their identity. More info [here](https://github.com/libp2p/specs/blob/master/discovery/mdns.md).
+mDNS can be disabled in the network configuration.
+- Kademlia random walk. Once connected, we perform random Kademlia `FIND_NODE` requests on the
+configured Kademlia DHTs (one per configured chain protocol) in order for nodes to propagate to
+us their view of the network. More information about Kademlia can be found [on
+Wikipedia](https://en.wikipedia.org/wiki/Kademlia).
+
+## Connection establishment
+
+When node Alice knows node Bob's identity and address, it can establish a connection with Bob.
+All connections must always use encryption and multiplexing. While some node addresses (eg.
+addresses using `/quic`) already imply which encryption and/or multiplexing to use, for others
+the **multistream-select** protocol is used in order to negotiate an encryption layer and/or a
+multiplexing layer.
+
+The connection establishment mechanism is called the **transport**.
+
+As of the writing of this documentation, the following base-layer protocols are supported by
+Substrate:
+
+- TCP/IP for addresses of the form `/ip4/1.2.3.4/tcp/5`. Once the TCP connection is open, an
+encryption and a multiplexing layer are negotiated on top.
+- WebSockets for addresses of the form `/ip4/1.2.3.4/tcp/5/ws`. A TCP/IP connection is open and
+the WebSockets protocol is negotiated on top. Communications then happen inside WebSockets data
+frames. Encryption and multiplexing are additionally negotiated again inside this channel.
+- DNS for addresses of the form `/dns/example.com/tcp/5` or `/dns/example.com/tcp/5/ws`. A
+node's address can contain a domain name.
+- (All of the above using IPv6 instead of IPv4.)
+
+On top of the base-layer protocol, the [Noise](https://noiseprotocol.org/) protocol is
+negotiated and applied. The exact handshake protocol is experimental and is subject to change.
+
+The following multiplexing protocols are supported:
+
+- [Yamux](https://github.com/hashicorp/yamux/blob/master/spec.md).
+
+## Substreams
+
+Once a connection has been established and uses multiplexing, substreams can be opened. When
+a substream is open, the **multistream-select** protocol is used to negotiate which protocol
+to use on that given substream.
+
+Protocols that are specific to a certain chain have a `<protocol-id>` in their name. This
+"protocol ID" is defined in the chain specifications. For example, the protocol ID of Polkadot
+is "dot". In the protocol names below, `<protocol-id>` must be replaced with the corresponding
+protocol ID.
+
+> **Note**: It is possible for the same connection to be used for multiple chains. For example,
+>           one can use both the `/dot/sync/2` and `/sub/sync/2` protocols on the same
+>           connection, provided that the remote supports them.
+
+Substrate uses the following standard libp2p protocols:
+
+- **`/ipfs/ping/1.0.0`**. We periodically open an ephemeral substream in order to ping the
+remote and check whether the connection is still alive. Failure for the remote to reply leads
+to a disconnection.
+- **[`/ipfs/id/1.0.0`](https://github.com/libp2p/specs/tree/master/identify)**. We
+periodically open an ephemeral substream in order to ask information from the remote.
+- **[`/<protocol_id>/kad`](https://github.com/libp2p/specs/pull/108)**. We periodically open
+ephemeral substreams for Kademlia random walk queries. Each Kademlia query is done in a
+separate substream.
+
+Additionally, Substrate uses the following non-libp2p-standard protocols:
+
+- **`/substrate/<protocol-id>/<version>`** (where `<protocol-id>` must be replaced with the
+protocol ID of the targeted chain, and `<version>` is a number between 2 and 6). For each
+connection we optionally keep an additional substream for all Substrate-based communications alive.
+This protocol is considered legacy, and is progressively being replaced with alternatives.
+This is designated as "The legacy Substrate substream" in this documentation. See below for
+more details.
+- **`/<protocol-id>/sync/2`** is a request-response protocol (see below) that lets one perform
+requests for information about blocks. Each request is the encoding of a `BlockRequest` and
+each response is the encoding of a `BlockResponse`, as defined in the `api.v1.proto` file in
+this source tree.
+- **`/<protocol-id>/light/2`** is a request-response protocol (see below) that lets one perform
+light-client-related requests for information about the state. Each request is the encoding of
+a `light::Request` and each response is the encoding of a `light::Response`, as defined in the
+`light.v1.proto` file in this source tree.
+- **`/<protocol-id>/transactions/1`** is a notifications protocol (see below) where
+transactions are pushed to other nodes. The handshake is empty on both sides. The message
+format is a SCALE-encoded list of transactions, where each transaction is an opaque list of
+bytes.
+- **`/<protocol-id>/block-announces/1`** is a notifications protocol (see below) where
+block announces are pushed to other nodes. The handshake is empty on both sides. The message
+format is a SCALE-encoded tuple containing a block header followed with an opaque list of
+bytes containing some data associated with this block announcement, e.g. a candidate message.
+- Notifications protocols that are registered using `NetworkConfiguration::notifications_protocols`.
+For example: `/paritytech/grandpa/1`. See below for more information.
+
+## The legacy Substrate substream
+
+Substrate uses a component named the **peerset manager (PSM)**. Through the discovery
+mechanism, the PSM is aware of the nodes that are part of the network and decides which nodes
+we should perform Substrate-based communications with. For these nodes, we open a connection
+if necessary and open a unique substream for Substrate-based communications. If the PSM decides
+that we should disconnect a node, then that substream is closed.
+
+For more information about the PSM, see the *sc-peerset* crate.
+
+Note that at the moment there is no mechanism in place to solve the issues that arise where the
+two sides of a connection open the unique substream simultaneously. In order to not run into
+issues, only the dialer of a connection is allowed to open the unique substream. When the
+substream is closed, the entire connection is closed as well. This is a bug that will be
+resolved by deprecating the protocol entirely.
+
+Within the unique Substrate substream, messages encoded using
+[*parity-scale-codec*](https://github.com/paritytech/parity-scale-codec) are exchanged.
+The detail of theses messages is not totally in place, but they can be found in the
+`message.rs` file.
+
+Once the substream is open, the first step is an exchange of a *status* message from both
+sides, containing information such as the chain root hash, head of chain, and so on.
+
+Communications within this substream include:
+
+- Syncing. Blocks are announced and requested from other nodes.
+- Light-client requests. When a light client requires information, a random node we have a
+substream open with is chosen, and the information is requested from it.
+- Gossiping. Used for example by grandpa.
+
+## Request-response protocols
+
+A so-called request-response protocol is defined as follow:
+
+- When a substream is opened, the opening side sends a message whose content is
+protocol-specific. The message must be prefixed with an
+[LEB128-encoded number](https://en.wikipedia.org/wiki/LEB128) indicating its length. After the
+message has been sent, the writing side is closed.
+- The remote sends back the response prefixed with a LEB128-encoded length, and closes its
+side as well.
+
+Each request is performed in a new separate substream.
+
+## Notifications protocols
+
+A so-called notifications protocol is defined as follow:
+
+- When a substream is opened, the opening side sends a handshake message whose content is
+protocol-specific. The handshake message must be prefixed with an
+[LEB128-encoded number](https://en.wikipedia.org/wiki/LEB128) indicating its length. The
+handshake message can be of length 0, in which case the sender has to send a single `0`.
+- The receiver then either immediately closes the substream, or answers with its own
+LEB128-prefixed protocol-specific handshake response. The message can be of length 0, in which
+case a single `0` has to be sent back.
+- Once the handshake has completed, the notifications protocol is unidirectional. Only the
+node which initiated the substream can push notifications. If the remote wants to send
+notifications as well, it has to open its own undirectional substream.
+- Each notification must be prefixed with an LEB128-encoded length. The encoding of the
+messages is specific to each protocol.
+- Either party can signal that it doesn't want a notifications substream anymore by closing
+its writing side. The other party should respond by closing its own writing side soon after.
+
+The API of `sc-network` allows one to register user-defined notification protocols.
+`sc-network` automatically tries to open a substream towards each node for which the legacy
+Substream substream is open. The handshake is then performed automatically.
+
+For example, the `sc-consensus-grandpa` crate registers the `/paritytech/grandpa/1`
+notifications protocol.
+
+At the moment, for backwards-compatibility, notification protocols are tied to the legacy
+Substrate substream. Additionally, the handshake message is hardcoded to be a single 8-bits
+integer representing the role of the node:
+
+- 1 for a full node.
+- 2 for a light node.
+- 4 for an authority.
+
+In the future, though, these restrictions will be removed.
+
+# Sync
+
+The crate implements a number of syncing algorithms. The main purpose of the syncing algorithm is
+get the chain to the latest state and keep it synced with the rest of the network by downloading and
+importing new data as soon as it becomes available. Once the node starts it catches up with the network
+with one of the initial sync methods listed below, and once it is completed uses a keep-up sync to
+download new blocks.
+
+## Full and light sync
+
+This is the default syncing method for the initial and keep-up sync. The algorithm starts with the
+current best block and downloads block data progressively from multiple peers if available. Once
+there's a sequence of blocks ready to be imported they are fed to the import queue. Full nodes download
+and execute full blocks, while light nodes only download and import headers. This continues until each peers
+has no more new blocks to give.
+
+For each peer the sync maintains the number of our common best block with that peer. This number is updates
+whenever peer announce new blocks or our best block advances. This allows to keep track of peers that have new
+block data and request new information as soon as it is announced. In keep-up mode, we also track peers that
+announce blocks on all branches and not just the best branch. The sync algorithm tries to be greedy and download
+all data that's announced.
+
+## Fast sync
+
+In this mode the initial downloads and verifies full header history. This allows to validate
+authority set transitions and arrive at a recent header. After header chain is verified and imported
+the node starts downloading a state snapshot using the state request protocol. Each `StateRequest`
+contains a starting storage key, which is empty for the first request.
+`StateResponse` contains a storage proof for a sequence of keys and values in the storage
+starting (but not including) from the key that is in the request. After iterating the proof trie against
+the storage root that is in the target header, the node issues The next `StateRequest` with set starting
+key set to the last key from the previous response. This continues until trie iteration reaches the end.
+The state is then imported into the database and the keep-up sync starts in normal full/light sync mode.
+
+## Warp sync
+
+This is similar to fast sync, but instead of downloading and verifying full header chain, the algorithm
+only downloads finalized authority set changes.
+
+### GRANDPA warp sync.
+
+GRANDPA keeps justifications for each finalized authority set change. Each change is signed by the
+authorities from the previous set. By downloading and verifying these signed hand-offs starting from genesis,
+we arrive at a recent header faster than downloading full header chain. Each `WarpSyncRequest` contains a block
+hash to a to start collecting proofs from. `WarpSyncResponse` contains a sequence of block headers and
+justifications. The proof downloader checks the justifications and continues requesting proofs from the last
+header hash, until it arrives at some recent header.
+
+Once the finality chain is proved for a header, the state matching the header is downloaded much like during
+the fast sync. The state is verified to match the header storage root. After the state is imported into the
+database it is queried for the information that allows GRANDPA and BABE to continue operating from that state.
+This includes BABE epoch information and GRANDPA authority set id.
+
+### Background block download.
+
+After the latest state has been imported the node is fully operational, but is still missing historic block
+data. I.e. it is unable to serve bock bodies and headers other than the most recent one. To make sure all
+nodes have block history available, a background sync process is started that downloads all the missing blocks.
+It is run in parallel with the keep-up sync and does not interfere with downloading of the recent blocks.
+During this download we also import GRANDPA justifications for blocks with authority set changes, so that
+the warp-synced node has all the data to serve for other nodes nodes that might want to sync from it with
+any method.
+
+# Usage
+
+Using the `sc-network` crate is done through the [`NetworkWorker`] struct. Create this
+struct by passing a [`config::Params`], then poll it as if it was a `Future`. You can extract an
+`Arc<NetworkService>` from the `NetworkWorker`, which can be shared amongst multiple places
+in order to give orders to the networking.
+
+See the [`config`] module for more information about how to configure the networking.
+
+After the `NetworkWorker` has been created, the important things to do are:
+
+- Calling `NetworkWorker::poll` in order to advance the network. This can be done by
+dispatching a background task with the [`NetworkWorker`].
+- Calling `on_block_import` whenever a block is added to the client.
+- Calling `on_block_finalized` whenever a block is finalized.
+- Calling `trigger_repropagate` when a transaction is added to the pool.
+
+More precise usage details are still being worked on and will likely change in the future.
+
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
diff --git a/substrate/client/network/bitswap/Cargo.toml b/substrate/client/network/bitswap/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bdc9e18f7457d443f39940eb123209296e07ba64
--- /dev/null
+++ b/substrate/client/network/bitswap/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+description = "Substrate bitswap protocol"
+name = "sc-network-bitswap"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network-bitswap"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[build-dependencies]
+prost-build = "0.11"
+
+[dependencies]
+async-channel = "1.8.0"
+cid = "0.9.0"
+futures = "0.3.21"
+libp2p-identity = { version = "0.1.2", features = ["peerid"] }
+log = "0.4.17"
+prost = "0.11"
+thiserror = "1.0"
+unsigned-varint = { version = "0.7.1", features = ["futures", "asynchronous_codec"] }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-network = { version = "0.10.0-dev", path = "../" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+tokio = { version = "1.22.0", features = ["full"] }
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sc-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+substrate-test-runtime = { version = "2.0.0", path = "../../../test-utils/runtime" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/client/network/bitswap/build.rs b/substrate/client/network/bitswap/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..671277230a7746b4da5e4e1d9d6b68f5ccf10b3e
--- /dev/null
+++ b/substrate/client/network/bitswap/build.rs
@@ -0,0 +1,5 @@
+const PROTOS: &[&str] = &["src/schema/bitswap.v1.2.0.proto"];
+
+fn main() {
+	prost_build::compile_protos(PROTOS, &["src/schema"]).unwrap();
+}
diff --git a/substrate/client/network/bitswap/src/lib.rs b/substrate/client/network/bitswap/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..beaaa8fd0fdec2d5d526ccc4447871cb832b4225
--- /dev/null
+++ b/substrate/client/network/bitswap/src/lib.rs
@@ -0,0 +1,527 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Bitswap server for Substrate.
+//!
+//! Allows querying transactions by hash over standard bitswap protocol
+//! Only supports bitswap 1.2.0.
+//! CID is expected to reference 256-bit Blake2b transaction hash.
+
+use cid::{self, Version};
+use futures::StreamExt;
+use libp2p_identity::PeerId;
+use log::{debug, error, trace};
+use prost::Message;
+use sc_client_api::BlockBackend;
+use sc_network::{
+	request_responses::{IncomingRequest, OutgoingResponse, ProtocolConfig},
+	types::ProtocolName,
+};
+use schema::bitswap::{
+	message::{wantlist::WantType, Block as MessageBlock, BlockPresence, BlockPresenceType},
+	Message as BitswapMessage,
+};
+use sp_runtime::traits::Block as BlockT;
+use std::{io, sync::Arc, time::Duration};
+use unsigned_varint::encode as varint_encode;
+
+mod schema;
+
+const LOG_TARGET: &str = "bitswap";
+
+// Undocumented, but according to JS the bitswap messages have a max size of 512*1024 bytes
+// https://github.com/ipfs/js-ipfs-bitswap/blob/
+// d8f80408aadab94c962f6b88f343eb9f39fa0fcc/src/decision-engine/index.js#L16
+// We set it to the same value as max substrate protocol message
+const MAX_PACKET_SIZE: u64 = 16 * 1024 * 1024;
+
+/// Max number of queued responses before denying requests.
+const MAX_REQUEST_QUEUE: usize = 20;
+
+/// Max number of blocks per wantlist
+const MAX_WANTED_BLOCKS: usize = 16;
+
+/// Bitswap protocol name
+const PROTOCOL_NAME: &'static str = "/ipfs/bitswap/1.2.0";
+
+/// Prefix represents all metadata of a CID, without the actual content.
+#[derive(PartialEq, Eq, Clone, Debug)]
+struct Prefix {
+	/// The version of CID.
+	pub version: Version,
+	/// The codec of CID.
+	pub codec: u64,
+	/// The multihash type of CID.
+	pub mh_type: u64,
+	/// The multihash length of CID.
+	pub mh_len: u8,
+}
+
+impl Prefix {
+	/// Convert the prefix to encoded bytes.
+	pub fn to_bytes(&self) -> Vec<u8> {
+		let mut res = Vec::with_capacity(4);
+		let mut buf = varint_encode::u64_buffer();
+		let version = varint_encode::u64(self.version.into(), &mut buf);
+		res.extend_from_slice(version);
+		let mut buf = varint_encode::u64_buffer();
+		let codec = varint_encode::u64(self.codec, &mut buf);
+		res.extend_from_slice(codec);
+		let mut buf = varint_encode::u64_buffer();
+		let mh_type = varint_encode::u64(self.mh_type, &mut buf);
+		res.extend_from_slice(mh_type);
+		let mut buf = varint_encode::u64_buffer();
+		let mh_len = varint_encode::u64(self.mh_len as u64, &mut buf);
+		res.extend_from_slice(mh_len);
+		res
+	}
+}
+
+/// Bitswap request handler
+pub struct BitswapRequestHandler<B> {
+	client: Arc<dyn BlockBackend<B> + Send + Sync>,
+	request_receiver: async_channel::Receiver<IncomingRequest>,
+}
+
+impl<B: BlockT> BitswapRequestHandler<B> {
+	/// Create a new [`BitswapRequestHandler`].
+	pub fn new(client: Arc<dyn BlockBackend<B> + Send + Sync>) -> (Self, ProtocolConfig) {
+		let (tx, request_receiver) = async_channel::bounded(MAX_REQUEST_QUEUE);
+
+		let config = ProtocolConfig {
+			name: ProtocolName::from(PROTOCOL_NAME),
+			fallback_names: vec![],
+			max_request_size: MAX_PACKET_SIZE,
+			max_response_size: MAX_PACKET_SIZE,
+			request_timeout: Duration::from_secs(15),
+			inbound_queue: Some(tx),
+		};
+
+		(Self { client, request_receiver }, config)
+	}
+
+	/// Run [`BitswapRequestHandler`].
+	pub async fn run(mut self) {
+		while let Some(request) = self.request_receiver.next().await {
+			let IncomingRequest { peer, payload, pending_response } = request;
+
+			match self.handle_message(&peer, &payload) {
+				Ok(response) => {
+					let response = OutgoingResponse {
+						result: Ok(response),
+						reputation_changes: Vec::new(),
+						sent_feedback: None,
+					};
+
+					match pending_response.send(response) {
+						Ok(()) => {
+							trace!(target: LOG_TARGET, "Handled bitswap request from {peer}.",)
+						},
+						Err(_) => debug!(
+							target: LOG_TARGET,
+							"Failed to handle light client request from {peer}: {}",
+							BitswapError::SendResponse,
+						),
+					}
+				},
+				Err(err) => {
+					error!(target: LOG_TARGET, "Failed to process request from {peer}: {err}");
+
+					// TODO: adjust reputation?
+
+					let response = OutgoingResponse {
+						result: Err(()),
+						reputation_changes: vec![],
+						sent_feedback: None,
+					};
+
+					if pending_response.send(response).is_err() {
+						debug!(
+							target: LOG_TARGET,
+							"Failed to handle bitswap request from {peer}: {}",
+							BitswapError::SendResponse,
+						);
+					}
+				},
+			}
+		}
+	}
+
+	/// Handle received Bitswap request
+	fn handle_message(
+		&mut self,
+		peer: &PeerId,
+		payload: &Vec<u8>,
+	) -> Result<Vec<u8>, BitswapError> {
+		let request = schema::bitswap::Message::decode(&payload[..])?;
+
+		trace!(target: LOG_TARGET, "Received request: {:?} from {}", request, peer);
+
+		let mut response = BitswapMessage::default();
+
+		let wantlist = match request.wantlist {
+			Some(wantlist) => wantlist,
+			None => {
+				debug!(target: LOG_TARGET, "Unexpected bitswap message from {}", peer);
+				return Err(BitswapError::InvalidWantList)
+			},
+		};
+
+		if wantlist.entries.len() > MAX_WANTED_BLOCKS {
+			trace!(target: LOG_TARGET, "Ignored request: too many entries");
+			return Err(BitswapError::TooManyEntries)
+		}
+
+		for entry in wantlist.entries {
+			let cid = match cid::Cid::read_bytes(entry.block.as_slice()) {
+				Ok(cid) => cid,
+				Err(e) => {
+					trace!(target: LOG_TARGET, "Bad CID {:?}: {:?}", entry.block, e);
+					continue
+				},
+			};
+
+			if cid.version() != cid::Version::V1 ||
+				cid.hash().code() != u64::from(cid::multihash::Code::Blake2b256) ||
+				cid.hash().size() != 32
+			{
+				debug!(target: LOG_TARGET, "Ignoring unsupported CID {}: {}", peer, cid);
+				continue
+			}
+
+			let mut hash = B::Hash::default();
+			hash.as_mut().copy_from_slice(&cid.hash().digest()[0..32]);
+			let transaction = match self.client.indexed_transaction(hash) {
+				Ok(ex) => ex,
+				Err(e) => {
+					error!(target: LOG_TARGET, "Error retrieving transaction {}: {}", hash, e);
+					None
+				},
+			};
+
+			match transaction {
+				Some(transaction) => {
+					trace!(target: LOG_TARGET, "Found CID {:?}, hash {:?}", cid, hash);
+
+					if entry.want_type == WantType::Block as i32 {
+						let prefix = Prefix {
+							version: cid.version(),
+							codec: cid.codec(),
+							mh_type: cid.hash().code(),
+							mh_len: cid.hash().size(),
+						};
+						response
+							.payload
+							.push(MessageBlock { prefix: prefix.to_bytes(), data: transaction });
+					} else {
+						response.block_presences.push(BlockPresence {
+							r#type: BlockPresenceType::Have as i32,
+							cid: cid.to_bytes(),
+						});
+					}
+				},
+				None => {
+					trace!(target: LOG_TARGET, "Missing CID {:?}, hash {:?}", cid, hash);
+
+					if entry.send_dont_have {
+						response.block_presences.push(BlockPresence {
+							r#type: BlockPresenceType::DontHave as i32,
+							cid: cid.to_bytes(),
+						});
+					}
+				},
+			}
+		}
+
+		Ok(response.encode_to_vec())
+	}
+}
+
+/// Bitswap protocol error.
+#[derive(Debug, thiserror::Error)]
+pub enum BitswapError {
+	/// Protobuf decoding error.
+	#[error("Failed to decode request: {0}.")]
+	DecodeProto(#[from] prost::DecodeError),
+
+	/// Protobuf encoding error.
+	#[error("Failed to encode response: {0}.")]
+	EncodeProto(#[from] prost::EncodeError),
+
+	/// Client backend error.
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+
+	/// Error parsing CID
+	#[error(transparent)]
+	BadCid(#[from] cid::Error),
+
+	/// Packet read error.
+	#[error(transparent)]
+	Read(#[from] io::Error),
+
+	/// Error sending response.
+	#[error("Failed to send response.")]
+	SendResponse,
+
+	/// Message doesn't have a WANT list.
+	#[error("Invalid WANT list.")]
+	InvalidWantList,
+
+	/// Too many blocks requested.
+	#[error("Too many block entries in the request.")]
+	TooManyEntries,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use futures::channel::oneshot;
+	use sc_block_builder::BlockBuilderProvider;
+	use schema::bitswap::{
+		message::{wantlist::Entry, Wantlist},
+		Message as BitswapMessage,
+	};
+	use sp_consensus::BlockOrigin;
+	use sp_runtime::codec::Encode;
+	use substrate_test_runtime::ExtrinsicBuilder;
+	use substrate_test_runtime_client::{self, prelude::*, TestClientBuilder};
+
+	#[tokio::test]
+	async fn undecodeable_message() {
+		let client = substrate_test_runtime_client::new();
+		let (bitswap, config) = BitswapRequestHandler::new(Arc::new(client));
+
+		tokio::spawn(async move { bitswap.run().await });
+
+		let (tx, rx) = oneshot::channel();
+		config
+			.inbound_queue
+			.unwrap()
+			.send(IncomingRequest {
+				peer: PeerId::random(),
+				payload: vec![0x13, 0x37, 0x13, 0x38],
+				pending_response: tx,
+			})
+			.await
+			.unwrap();
+
+		if let Ok(OutgoingResponse { result, reputation_changes, sent_feedback }) = rx.await {
+			assert_eq!(result, Err(()));
+			assert_eq!(reputation_changes, Vec::new());
+			assert!(sent_feedback.is_none());
+		} else {
+			panic!("invalid event received");
+		}
+	}
+
+	#[tokio::test]
+	async fn empty_want_list() {
+		let client = substrate_test_runtime_client::new();
+		let (bitswap, mut config) = BitswapRequestHandler::new(Arc::new(client));
+
+		tokio::spawn(async move { bitswap.run().await });
+
+		let (tx, rx) = oneshot::channel();
+		config
+			.inbound_queue
+			.as_mut()
+			.unwrap()
+			.send(IncomingRequest {
+				peer: PeerId::random(),
+				payload: BitswapMessage { wantlist: None, ..Default::default() }.encode_to_vec(),
+				pending_response: tx,
+			})
+			.await
+			.unwrap();
+
+		if let Ok(OutgoingResponse { result, reputation_changes, sent_feedback }) = rx.await {
+			assert_eq!(result, Err(()));
+			assert_eq!(reputation_changes, Vec::new());
+			assert!(sent_feedback.is_none());
+		} else {
+			panic!("invalid event received");
+		}
+
+		// Empty WANT list should not cause an error
+		let (tx, rx) = oneshot::channel();
+		config
+			.inbound_queue
+			.unwrap()
+			.send(IncomingRequest {
+				peer: PeerId::random(),
+				payload: BitswapMessage {
+					wantlist: Some(Default::default()),
+					..Default::default()
+				}
+				.encode_to_vec(),
+				pending_response: tx,
+			})
+			.await
+			.unwrap();
+
+		if let Ok(OutgoingResponse { result, reputation_changes, sent_feedback }) = rx.await {
+			assert_eq!(result, Ok(BitswapMessage::default().encode_to_vec()));
+			assert_eq!(reputation_changes, Vec::new());
+			assert!(sent_feedback.is_none());
+		} else {
+			panic!("invalid event received");
+		}
+	}
+
+	#[tokio::test]
+	async fn too_long_want_list() {
+		let client = substrate_test_runtime_client::new();
+		let (bitswap, config) = BitswapRequestHandler::new(Arc::new(client));
+
+		tokio::spawn(async move { bitswap.run().await });
+
+		let (tx, rx) = oneshot::channel();
+		config
+			.inbound_queue
+			.unwrap()
+			.send(IncomingRequest {
+				peer: PeerId::random(),
+				payload: BitswapMessage {
+					wantlist: Some(Wantlist {
+						entries: (0..MAX_WANTED_BLOCKS + 1)
+							.map(|_| Entry::default())
+							.collect::<Vec<_>>(),
+						full: false,
+					}),
+					..Default::default()
+				}
+				.encode_to_vec(),
+				pending_response: tx,
+			})
+			.await
+			.unwrap();
+
+		if let Ok(OutgoingResponse { result, reputation_changes, sent_feedback }) = rx.await {
+			assert_eq!(result, Err(()));
+			assert_eq!(reputation_changes, Vec::new());
+			assert!(sent_feedback.is_none());
+		} else {
+			panic!("invalid event received");
+		}
+	}
+
+	#[tokio::test]
+	async fn transaction_not_found() {
+		let client = TestClientBuilder::with_tx_storage(u32::MAX).build();
+
+		let (bitswap, config) = BitswapRequestHandler::new(Arc::new(client));
+		tokio::spawn(async move { bitswap.run().await });
+
+		let (tx, rx) = oneshot::channel();
+		config
+			.inbound_queue
+			.unwrap()
+			.send(IncomingRequest {
+				peer: PeerId::random(),
+				payload: BitswapMessage {
+					wantlist: Some(Wantlist {
+						entries: vec![Entry {
+							block: cid::Cid::new_v1(
+								0x70,
+								cid::multihash::Multihash::wrap(
+									u64::from(cid::multihash::Code::Blake2b256),
+									&[0u8; 32],
+								)
+								.unwrap(),
+							)
+							.to_bytes(),
+							..Default::default()
+						}],
+						full: false,
+					}),
+					..Default::default()
+				}
+				.encode_to_vec(),
+				pending_response: tx,
+			})
+			.await
+			.unwrap();
+
+		if let Ok(OutgoingResponse { result, reputation_changes, sent_feedback }) = rx.await {
+			assert_eq!(result, Ok(vec![]));
+			assert_eq!(reputation_changes, Vec::new());
+			assert!(sent_feedback.is_none());
+		} else {
+			panic!("invalid event received");
+		}
+	}
+
+	#[tokio::test]
+	async fn transaction_found() {
+		let mut client = TestClientBuilder::with_tx_storage(u32::MAX).build();
+		let mut block_builder = client.new_block(Default::default()).unwrap();
+
+		// encoded extrinsic: [161, .. , 2, 6, 16, 19, 55, 19, 56]
+		let ext = ExtrinsicBuilder::new_indexed_call(vec![0x13, 0x37, 0x13, 0x38]).build();
+		let pattern_index = ext.encoded_size() - 4;
+
+		block_builder.push(ext.clone()).unwrap();
+		let block = block_builder.build().unwrap().block;
+
+		client.import(BlockOrigin::File, block).await.unwrap();
+
+		let (bitswap, config) = BitswapRequestHandler::new(Arc::new(client));
+
+		tokio::spawn(async move { bitswap.run().await });
+
+		let (tx, rx) = oneshot::channel();
+		config
+			.inbound_queue
+			.unwrap()
+			.send(IncomingRequest {
+				peer: PeerId::random(),
+				payload: BitswapMessage {
+					wantlist: Some(Wantlist {
+						entries: vec![Entry {
+							block: cid::Cid::new_v1(
+								0x70,
+								cid::multihash::Multihash::wrap(
+									u64::from(cid::multihash::Code::Blake2b256),
+									&sp_core::hashing::blake2_256(&ext.encode()[pattern_index..]),
+								)
+								.unwrap(),
+							)
+							.to_bytes(),
+							..Default::default()
+						}],
+						full: false,
+					}),
+					..Default::default()
+				}
+				.encode_to_vec(),
+				pending_response: tx,
+			})
+			.await
+			.unwrap();
+
+		if let Ok(OutgoingResponse { result, reputation_changes, sent_feedback }) = rx.await {
+			assert_eq!(reputation_changes, Vec::new());
+			assert!(sent_feedback.is_none());
+
+			let response =
+				schema::bitswap::Message::decode(&result.expect("fetch to succeed")[..]).unwrap();
+			assert_eq!(response.payload[0].data, vec![0x13, 0x37, 0x13, 0x38]);
+		} else {
+			panic!("invalid event received");
+		}
+	}
+}
diff --git a/substrate/client/network/bitswap/src/schema.rs b/substrate/client/network/bitswap/src/schema.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1d62847c21d08a43d2eeb19e1405d32b7f0ab83e
--- /dev/null
+++ b/substrate/client/network/bitswap/src/schema.rs
@@ -0,0 +1,23 @@
+// 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/>.
+
+//! Include sources generated from protobuf definitions.
+
+pub(crate) mod bitswap {
+	include!(concat!(env!("OUT_DIR"), "/bitswap.message.rs"));
+}
diff --git a/substrate/client/network/bitswap/src/schema/bitswap.v1.2.0.proto b/substrate/client/network/bitswap/src/schema/bitswap.v1.2.0.proto
new file mode 100644
index 0000000000000000000000000000000000000000..a4138b516d63d47739327a76e2ee07e0b277cc41
--- /dev/null
+++ b/substrate/client/network/bitswap/src/schema/bitswap.v1.2.0.proto
@@ -0,0 +1,43 @@
+syntax = "proto3";
+
+package bitswap.message;
+
+message Message {
+	message Wantlist {
+		enum WantType {
+			Block = 0;
+			Have = 1;
+		}
+
+		message Entry {
+			bytes block = 1; 	// the block cid (cidV0 in bitswap 1.0.0, cidV1 in bitswap 1.1.0)
+			int32 priority = 2;	// the priority (normalized). default to 1
+			bool cancel = 3;		// whether this revokes an entry
+			WantType wantType = 4; // Note: defaults to enum 0, ie Block
+			bool sendDontHave = 5; // Note: defaults to false
+		}
+
+		repeated Entry entries = 1; // a list of wantlist entries
+		bool full = 2;							// whether this is the full wantlist. default to false
+	}
+
+	message Block {
+		bytes prefix = 1;		// CID prefix (cid version, multicodec and multihash prefix (type + length)
+		bytes data = 2;
+	}
+
+	enum BlockPresenceType {
+		Have = 0;
+		DontHave = 1;
+	}
+	message BlockPresence {
+		bytes cid = 1;
+		BlockPresenceType type = 2;
+	}
+
+	Wantlist wantlist = 1;
+	repeated bytes blocks = 2;		// used to send Blocks in bitswap 1.0.0
+	repeated Block payload = 3;		// used to send Blocks in bitswap 1.1.0
+	repeated BlockPresence blockPresences = 4;
+	int32 pendingBytes = 5;
+}
diff --git a/substrate/client/network/common/Cargo.toml b/substrate/client/network/common/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c2fee608d79b6f20b94a346ff0704f4dab11ebfb
--- /dev/null
+++ b/substrate/client/network/common/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+description = "Substrate network common"
+name = "sc-network-common"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network-sync"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[build-dependencies]
+prost-build = "0.11"
+
+[dependencies]
+async-trait = "0.1.57"
+bitflags = "1.3.2"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = [
+	"derive",
+] }
+futures = "0.3.21"
+libp2p-identity = { version = "0.1.2", features = ["peerid"] }
+sc-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-consensus-grandpa = { version = "4.0.0-dev", path = "../../../primitives/consensus/grandpa" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+tempfile = "3.1.0"
diff --git a/substrate/client/network/common/src/lib.rs b/substrate/client/network/common/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8149f5ea708cdeccd99157f42807c899f26e41c0
--- /dev/null
+++ b/substrate/client/network/common/src/lib.rs
@@ -0,0 +1,30 @@
+// 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/>.
+
+//! Common data structures of the networking layer.
+
+pub mod message;
+pub mod role;
+pub mod sync;
+pub mod types;
+
+/// Minimum Requirements for a Hash within Networking
+pub trait ExHashT: std::hash::Hash + Eq + std::fmt::Debug + Clone + Send + Sync + 'static {}
+
+impl<T> ExHashT for T where T: std::hash::Hash + Eq + std::fmt::Debug + Clone + Send + Sync + 'static
+{}
diff --git a/substrate/client/network/common/src/message.rs b/substrate/client/network/common/src/message.rs
new file mode 100644
index 0000000000000000000000000000000000000000..12d2a6800490f229aff5e8d3225bd5a720b56742
--- /dev/null
+++ b/substrate/client/network/common/src/message.rs
@@ -0,0 +1,23 @@
+// 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/>.
+
+//! Network packet message types. These get serialized and put into the lower level protocol
+//! payload.
+
+/// A unique ID of a request.
+pub type RequestId = u64;
diff --git a/substrate/client/network/common/src/role.rs b/substrate/client/network/common/src/role.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cd43f6655b72cc2d5f1b35c0187ebcfb7a2a9b8c
--- /dev/null
+++ b/substrate/client/network/common/src/role.rs
@@ -0,0 +1,121 @@
+// 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 codec::{self, Encode, EncodeLike, Input, Output};
+
+/// Role that the peer sent to us during the handshake, with the addition of what our local node
+/// knows about that peer.
+///
+/// > **Note**: This enum is different from the `Role` enum. The `Role` enum indicates what a
+/// >			node says about itself, while `ObservedRole` is a `Role` merged with the
+/// >			information known locally about that node.
+#[derive(Debug, Clone)]
+pub enum ObservedRole {
+	/// Full node.
+	Full,
+	/// Light node.
+	Light,
+	/// Third-party authority.
+	Authority,
+}
+
+impl ObservedRole {
+	/// Returns `true` for `ObservedRole::Light`.
+	pub fn is_light(&self) -> bool {
+		matches!(self, Self::Light)
+	}
+}
+
+/// Role of the local node.
+#[derive(Debug, Clone)]
+pub enum Role {
+	/// Regular full node.
+	Full,
+	/// Actual authority.
+	Authority,
+}
+
+impl Role {
+	/// True for [`Role::Authority`].
+	pub fn is_authority(&self) -> bool {
+		matches!(self, Self::Authority)
+	}
+}
+
+impl std::fmt::Display for Role {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Self::Full => write!(f, "FULL"),
+			Self::Authority => write!(f, "AUTHORITY"),
+		}
+	}
+}
+
+bitflags::bitflags! {
+	/// Bitmask of the roles that a node fulfills.
+	pub struct Roles: u8 {
+		/// No network.
+		const NONE = 0b00000000;
+		/// Full node, does not participate in consensus.
+		const FULL = 0b00000001;
+		/// Light client node.
+		const LIGHT = 0b00000010;
+		/// Act as an authority
+		const AUTHORITY = 0b00000100;
+	}
+}
+
+impl Roles {
+	/// Does this role represents a client that holds full chain data locally?
+	pub fn is_full(&self) -> bool {
+		self.intersects(Self::FULL | Self::AUTHORITY)
+	}
+
+	/// Does this role represents a client that does not participates in the consensus?
+	pub fn is_authority(&self) -> bool {
+		*self == Self::AUTHORITY
+	}
+
+	/// Does this role represents a client that does not hold full chain data locally?
+	pub fn is_light(&self) -> bool {
+		!self.is_full()
+	}
+}
+
+impl<'a> From<&'a Role> for Roles {
+	fn from(roles: &'a Role) -> Self {
+		match roles {
+			Role::Full => Self::FULL,
+			Role::Authority => Self::AUTHORITY,
+		}
+	}
+}
+
+impl Encode for Roles {
+	fn encode_to<T: Output + ?Sized>(&self, dest: &mut T) {
+		dest.push_byte(self.bits())
+	}
+}
+
+impl EncodeLike for Roles {}
+
+impl codec::Decode for Roles {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		Self::from_bits(input.read_byte()?).ok_or_else(|| codec::Error::from("Invalid bytes"))
+	}
+}
diff --git a/substrate/client/network/common/src/sync.rs b/substrate/client/network/common/src/sync.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b142925aeb10c90971bdadff33b6bc10ccde471e
--- /dev/null
+++ b/substrate/client/network/common/src/sync.rs
@@ -0,0 +1,461 @@
+// 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/>.
+
+//! Abstract interfaces and data structures related to network sync.
+
+pub mod message;
+pub mod metrics;
+pub mod warp;
+
+use crate::{role::Roles, types::ReputationChange};
+use futures::Stream;
+
+use libp2p_identity::PeerId;
+
+use message::{BlockAnnounce, BlockData, BlockRequest, BlockResponse};
+use sc_consensus::{import_queue::RuntimeOrigin, IncomingBlock};
+use sp_consensus::BlockOrigin;
+use sp_runtime::{
+	traits::{Block as BlockT, NumberFor},
+	Justifications,
+};
+use warp::WarpSyncProgress;
+
+use std::{any::Any, fmt, fmt::Formatter, pin::Pin, sync::Arc, task::Poll};
+
+/// The sync status of a peer we are trying to sync with
+#[derive(Debug)]
+pub struct PeerInfo<Block: BlockT> {
+	/// Their best block hash.
+	pub best_hash: Block::Hash,
+	/// Their best block number.
+	pub best_number: NumberFor<Block>,
+}
+
+/// Info about a peer's known state (both full and light).
+#[derive(Clone, Debug)]
+pub struct ExtendedPeerInfo<B: BlockT> {
+	/// Roles
+	pub roles: Roles,
+	/// Peer best block hash
+	pub best_hash: B::Hash,
+	/// Peer best block number
+	pub best_number: NumberFor<B>,
+}
+
+/// Reported sync state.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum SyncState<BlockNumber> {
+	/// Initial sync is complete, keep-up sync is active.
+	Idle,
+	/// Actively catching up with the chain.
+	Downloading { target: BlockNumber },
+	/// All blocks are downloaded and are being imported.
+	Importing { target: BlockNumber },
+}
+
+impl<BlockNumber> SyncState<BlockNumber> {
+	/// Are we actively catching up with the chain?
+	pub fn is_major_syncing(&self) -> bool {
+		!matches!(self, SyncState::Idle)
+	}
+}
+
+/// Reported state download progress.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct StateDownloadProgress {
+	/// Estimated download percentage.
+	pub percentage: u32,
+	/// Total state size in bytes downloaded so far.
+	pub size: u64,
+}
+
+/// Syncing status and statistics.
+#[derive(Debug, Clone)]
+pub struct SyncStatus<Block: BlockT> {
+	/// Current global sync state.
+	pub state: SyncState<NumberFor<Block>>,
+	/// Target sync block number.
+	pub best_seen_block: Option<NumberFor<Block>>,
+	/// Number of peers participating in syncing.
+	pub num_peers: u32,
+	/// Number of peers known to `SyncingEngine` (both full and light).
+	pub num_connected_peers: u32,
+	/// Number of blocks queued for import
+	pub queued_blocks: u32,
+	/// State sync status in progress, if any.
+	pub state_sync: Option<StateDownloadProgress>,
+	/// Warp sync in progress, if any.
+	pub warp_sync: Option<WarpSyncProgress<Block>>,
+}
+
+/// A peer did not behave as expected and should be reported.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BadPeer(pub PeerId, pub ReputationChange);
+
+impl fmt::Display for BadPeer {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "Bad peer {}; Reputation change: {:?}", self.0, self.1)
+	}
+}
+
+impl std::error::Error for BadPeer {}
+
+/// Result of [`ChainSync::on_block_data`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum OnBlockData<Block: BlockT> {
+	/// The block should be imported.
+	Import(BlockOrigin, Vec<IncomingBlock<Block>>),
+	/// A new block request needs to be made to the given peer.
+	Request(PeerId, BlockRequest<Block>),
+	/// Continue processing events.
+	Continue,
+}
+
+/// Result of [`ChainSync::on_block_justification`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum OnBlockJustification<Block: BlockT> {
+	/// The justification needs no further handling.
+	Nothing,
+	/// The justification should be imported.
+	Import {
+		peer: PeerId,
+		hash: Block::Hash,
+		number: NumberFor<Block>,
+		justifications: Justifications,
+	},
+}
+
+/// Result of `ChainSync::on_state_data`.
+#[derive(Debug)]
+pub enum OnStateData<Block: BlockT> {
+	/// The block and state that should be imported.
+	Import(BlockOrigin, IncomingBlock<Block>),
+	/// A new state request needs to be made to the given peer.
+	Continue,
+}
+
+/// Block or justification request polled from `ChainSync`
+#[derive(Debug)]
+pub enum ImportResult<B: BlockT> {
+	BlockImport(BlockOrigin, Vec<IncomingBlock<B>>),
+	JustificationImport(RuntimeOrigin, B::Hash, NumberFor<B>, Justifications),
+}
+
+/// Value polled from `ChainSync`
+#[derive(Debug)]
+pub enum PollResult<B: BlockT> {
+	Import(ImportResult<B>),
+	Announce(PollBlockAnnounceValidation<B::Header>),
+}
+
+/// Result of [`ChainSync::poll_block_announce_validation`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PollBlockAnnounceValidation<H> {
+	/// The announcement failed at validation.
+	///
+	/// The peer reputation should be decreased.
+	Failure {
+		/// Who sent the processed block announcement?
+		who: PeerId,
+		/// Should the peer be disconnected?
+		disconnect: bool,
+	},
+	/// The announcement does not require further handling.
+	Nothing {
+		/// Who sent the processed block announcement?
+		who: PeerId,
+		/// Was this their new best block?
+		is_best: bool,
+		/// The announcement.
+		announce: BlockAnnounce<H>,
+	},
+	/// The block announcement should be skipped.
+	Skip,
+}
+
+/// Sync operation mode.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum SyncMode {
+	/// Full block download and verification.
+	Full,
+	/// Download blocks and the latest state.
+	LightState {
+		/// Skip state proof download and verification.
+		skip_proofs: bool,
+		/// Download indexed transactions for recent blocks.
+		storage_chain_mode: bool,
+	},
+	/// Warp sync - verify authority set transitions and the latest state.
+	Warp,
+}
+
+impl SyncMode {
+	/// Returns `true` if `self` is [`Self::Warp`].
+	pub fn is_warp(&self) -> bool {
+		matches!(self, Self::Warp)
+	}
+
+	/// Returns `true` if `self` is [`Self::LightState`].
+	pub fn light_state(&self) -> bool {
+		matches!(self, Self::LightState { .. })
+	}
+}
+
+impl Default for SyncMode {
+	fn default() -> Self {
+		Self::Full
+	}
+}
+#[derive(Debug)]
+pub struct Metrics {
+	pub queued_blocks: u32,
+	pub fork_targets: u32,
+	pub justifications: metrics::Metrics,
+}
+
+#[derive(Debug)]
+pub enum PeerRequest<B: BlockT> {
+	Block(BlockRequest<B>),
+	State,
+	WarpProof,
+}
+
+/// Wrapper for implementation-specific state request.
+///
+/// NOTE: Implementation must be able to encode and decode it for network purposes.
+pub struct OpaqueStateRequest(pub Box<dyn Any + Send>);
+
+impl fmt::Debug for OpaqueStateRequest {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		f.debug_struct("OpaqueStateRequest").finish()
+	}
+}
+
+/// Wrapper for implementation-specific state response.
+///
+/// NOTE: Implementation must be able to encode and decode it for network purposes.
+pub struct OpaqueStateResponse(pub Box<dyn Any + Send>);
+
+impl fmt::Debug for OpaqueStateResponse {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		f.debug_struct("OpaqueStateResponse").finish()
+	}
+}
+
+/// Wrapper for implementation-specific block request.
+///
+/// NOTE: Implementation must be able to encode and decode it for network purposes.
+pub struct OpaqueBlockRequest(pub Box<dyn Any + Send>);
+
+impl fmt::Debug for OpaqueBlockRequest {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		f.debug_struct("OpaqueBlockRequest").finish()
+	}
+}
+
+/// Wrapper for implementation-specific block response.
+///
+/// NOTE: Implementation must be able to encode and decode it for network purposes.
+pub struct OpaqueBlockResponse(pub Box<dyn Any + Send>);
+
+impl fmt::Debug for OpaqueBlockResponse {
+	fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+		f.debug_struct("OpaqueBlockResponse").finish()
+	}
+}
+
+/// Provides high-level status of syncing.
+#[async_trait::async_trait]
+pub trait SyncStatusProvider<Block: BlockT>: Send + Sync {
+	/// Get high-level view of the syncing status.
+	async fn status(&self) -> Result<SyncStatus<Block>, ()>;
+}
+
+#[async_trait::async_trait]
+impl<T, Block> SyncStatusProvider<Block> for Arc<T>
+where
+	T: ?Sized,
+	T: SyncStatusProvider<Block>,
+	Block: BlockT,
+{
+	async fn status(&self) -> Result<SyncStatus<Block>, ()> {
+		T::status(self).await
+	}
+}
+
+/// Syncing-related events that other protocols can subscribe to.
+pub enum SyncEvent {
+	/// Peer that the syncing implementation is tracking connected.
+	PeerConnected(PeerId),
+
+	/// Peer that the syncing implementation was tracking disconnected.
+	PeerDisconnected(PeerId),
+}
+
+pub trait SyncEventStream: Send + Sync {
+	/// Subscribe to syncing-related events.
+	fn event_stream(&self, name: &'static str) -> Pin<Box<dyn Stream<Item = SyncEvent> + Send>>;
+}
+
+impl<T> SyncEventStream for Arc<T>
+where
+	T: ?Sized,
+	T: SyncEventStream,
+{
+	fn event_stream(&self, name: &'static str) -> Pin<Box<dyn Stream<Item = SyncEvent> + Send>> {
+		T::event_stream(self, name)
+	}
+}
+
+/// Something that represents the syncing strategy to download past and future blocks of the chain.
+pub trait ChainSync<Block: BlockT>: Send {
+	/// Returns the state of the sync of the given peer.
+	///
+	/// Returns `None` if the peer is unknown.
+	fn peer_info(&self, who: &PeerId) -> Option<PeerInfo<Block>>;
+
+	/// Returns the current sync status.
+	fn status(&self) -> SyncStatus<Block>;
+
+	/// Number of active forks requests. This includes
+	/// requests that are pending or could be issued right away.
+	fn num_sync_requests(&self) -> usize;
+
+	/// Number of downloaded blocks.
+	fn num_downloaded_blocks(&self) -> usize;
+
+	/// Returns the current number of peers stored within this state machine.
+	fn num_peers(&self) -> usize;
+
+	/// Returns the number of peers we're connected to and that are being queried.
+	fn num_active_peers(&self) -> usize;
+
+	/// Handle a new connected peer.
+	///
+	/// Call this method whenever we connect to a new peer.
+	fn new_peer(
+		&mut self,
+		who: PeerId,
+		best_hash: Block::Hash,
+		best_number: NumberFor<Block>,
+	) -> Result<Option<BlockRequest<Block>>, BadPeer>;
+
+	/// Signal that a new best block has been imported.
+	fn update_chain_info(&mut self, best_hash: &Block::Hash, best_number: NumberFor<Block>);
+
+	/// Schedule a justification request for the given block.
+	fn request_justification(&mut self, hash: &Block::Hash, number: NumberFor<Block>);
+
+	/// Clear all pending justification requests.
+	fn clear_justification_requests(&mut self);
+
+	/// Request syncing for the given block from given set of peers.
+	fn set_sync_fork_request(
+		&mut self,
+		peers: Vec<PeerId>,
+		hash: &Block::Hash,
+		number: NumberFor<Block>,
+	);
+
+	/// Handle a response from the remote to a block request that we made.
+	///
+	/// `request` must be the original request that triggered `response`.
+	/// or `None` if data comes from the block announcement.
+	///
+	/// If this corresponds to a valid block, this outputs the block that
+	/// must be imported in the import queue.
+	fn on_block_data(
+		&mut self,
+		who: &PeerId,
+		request: Option<BlockRequest<Block>>,
+		response: BlockResponse<Block>,
+	) -> Result<OnBlockData<Block>, BadPeer>;
+
+	/// Handle a response from the remote to a justification request that we made.
+	///
+	/// `request` must be the original request that triggered `response`.
+	fn on_block_justification(
+		&mut self,
+		who: PeerId,
+		response: BlockResponse<Block>,
+	) -> Result<OnBlockJustification<Block>, BadPeer>;
+
+	/// Call this when a justification has been processed by the import queue,
+	/// with or without errors.
+	fn on_justification_import(
+		&mut self,
+		hash: Block::Hash,
+		number: NumberFor<Block>,
+		success: bool,
+	);
+
+	/// Notify about finalization of the given block.
+	fn on_block_finalized(&mut self, hash: &Block::Hash, number: NumberFor<Block>);
+
+	/// Push a block announce validation.
+	///
+	/// It is required that [`ChainSync::poll_block_announce_validation`] is called
+	/// to check for finished block announce validations.
+	fn push_block_announce_validation(
+		&mut self,
+		who: PeerId,
+		hash: Block::Hash,
+		announce: BlockAnnounce<Block::Header>,
+		is_best: bool,
+	);
+
+	/// Poll block announce validation.
+	///
+	/// Block announce validations can be pushed by using
+	/// [`ChainSync::push_block_announce_validation`].
+	///
+	/// This should be polled until it returns [`Poll::Pending`].
+	fn poll_block_announce_validation(
+		&mut self,
+		cx: &mut std::task::Context<'_>,
+	) -> Poll<PollBlockAnnounceValidation<Block::Header>>;
+
+	/// Call when a peer has disconnected.
+	/// Canceled obsolete block request may result in some blocks being ready for
+	/// import, so this functions checks for such blocks and returns them.
+	fn peer_disconnected(&mut self, who: &PeerId);
+
+	/// Return some key metrics.
+	fn metrics(&self) -> Metrics;
+
+	/// Access blocks from implementation-specific block response.
+	fn block_response_into_blocks(
+		&self,
+		request: &BlockRequest<Block>,
+		response: OpaqueBlockResponse,
+	) -> Result<Vec<BlockData<Block>>, String>;
+
+	/// Advance the state of `ChainSync`
+	///
+	/// Internally calls [`ChainSync::poll_block_announce_validation()`] and
+	/// this function should be polled until it returns [`Poll::Pending`] to
+	/// consume all pending events.
+	fn poll(
+		&mut self,
+		cx: &mut std::task::Context,
+	) -> Poll<PollBlockAnnounceValidation<Block::Header>>;
+
+	/// Send block request to peer
+	fn send_block_request(&mut self, who: PeerId, request: BlockRequest<Block>);
+}
diff --git a/substrate/client/network/common/src/sync/message.rs b/substrate/client/network/common/src/sync/message.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7cdb14172885ea4354443336eef910fb1d525d34
--- /dev/null
+++ b/substrate/client/network/common/src/sync/message.rs
@@ -0,0 +1,246 @@
+// 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/>.
+
+//! Network packet message types. These get serialized and put into the lower level protocol
+//! payload.
+
+use crate::role::Roles;
+
+use bitflags::bitflags;
+use codec::{Decode, Encode, Error, Input, Output};
+pub use generic::{BlockAnnounce, FromBlock};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
+
+/// Type alias for using the block request type using block type parameters.
+pub type BlockRequest<B> =
+	generic::BlockRequest<<B as BlockT>::Hash, <<B as BlockT>::Header as HeaderT>::Number>;
+
+/// Type alias for using the BlockData type using block type parameters.
+pub type BlockData<B> =
+	generic::BlockData<<B as BlockT>::Header, <B as BlockT>::Hash, <B as BlockT>::Extrinsic>;
+
+/// Type alias for using the BlockResponse type using block type parameters.
+pub type BlockResponse<B> =
+	generic::BlockResponse<<B as BlockT>::Header, <B as BlockT>::Hash, <B as BlockT>::Extrinsic>;
+
+// Bits of block data and associated artifacts to request.
+bitflags! {
+	/// Node roles bitmask.
+	pub struct BlockAttributes: u8 {
+		/// Include block header.
+		const HEADER = 0b00000001;
+		/// Include block body.
+		const BODY = 0b00000010;
+		/// Include block receipt.
+		const RECEIPT = 0b00000100;
+		/// Include block message queue.
+		const MESSAGE_QUEUE = 0b00001000;
+		/// Include a justification for the block.
+		const JUSTIFICATION = 0b00010000;
+		/// Include indexed transactions for a block.
+		const INDEXED_BODY = 0b00100000;
+	}
+}
+
+impl BlockAttributes {
+	/// Encodes attributes as big endian u32, compatible with SCALE-encoding (i.e the
+	/// significant byte has zero index).
+	pub fn to_be_u32(&self) -> u32 {
+		u32::from_be_bytes([self.bits(), 0, 0, 0])
+	}
+
+	/// Decodes attributes, encoded with the `encode_to_be_u32()` call.
+	pub fn from_be_u32(encoded: u32) -> Result<Self, Error> {
+		Self::from_bits(encoded.to_be_bytes()[0])
+			.ok_or_else(|| Error::from("Invalid BlockAttributes"))
+	}
+}
+
+impl Encode for BlockAttributes {
+	fn encode_to<T: Output + ?Sized>(&self, dest: &mut T) {
+		dest.push_byte(self.bits())
+	}
+}
+
+impl codec::EncodeLike for BlockAttributes {}
+
+impl Decode for BlockAttributes {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
+		Self::from_bits(input.read_byte()?).ok_or_else(|| Error::from("Invalid bytes"))
+	}
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Encode, Decode)]
+/// Block enumeration direction.
+pub enum Direction {
+	/// Enumerate in ascending order (from child to parent).
+	Ascending = 0,
+	/// Enumerate in descending order (from parent to canonical child).
+	Descending = 1,
+}
+
+/// Block state in the chain.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Encode, Decode)]
+pub enum BlockState {
+	/// Block is not part of the best chain.
+	Normal,
+	/// Latest best block.
+	Best,
+}
+
+/// Announcement summary used for debug logging.
+#[derive(Debug)]
+pub struct AnnouncementSummary<H: HeaderT> {
+	pub block_hash: H::Hash,
+	pub number: H::Number,
+	pub parent_hash: H::Hash,
+	pub state: Option<BlockState>,
+}
+
+impl<H: HeaderT> BlockAnnounce<H> {
+	pub fn summary(&self) -> AnnouncementSummary<H> {
+		AnnouncementSummary {
+			block_hash: self.header.hash(),
+			number: *self.header.number(),
+			parent_hash: *self.header.parent_hash(),
+			state: self.state,
+		}
+	}
+}
+
+/// Generic types.
+pub mod generic {
+	use super::{BlockAttributes, BlockState, Direction};
+	use crate::message::RequestId;
+	use codec::{Decode, Encode, Input, Output};
+	use sp_runtime::{EncodedJustification, Justifications};
+
+	/// Block data sent in the response.
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	pub struct BlockData<Header, Hash, Extrinsic> {
+		/// Block header hash.
+		pub hash: Hash,
+		/// Block header if requested.
+		pub header: Option<Header>,
+		/// Block body if requested.
+		pub body: Option<Vec<Extrinsic>>,
+		/// Block body indexed transactions if requested.
+		pub indexed_body: Option<Vec<Vec<u8>>>,
+		/// Block receipt if requested.
+		pub receipt: Option<Vec<u8>>,
+		/// Block message queue if requested.
+		pub message_queue: Option<Vec<u8>>,
+		/// Justification if requested.
+		pub justification: Option<EncodedJustification>,
+		/// Justifications if requested.
+		pub justifications: Option<Justifications>,
+	}
+
+	/// Request block data from a peer.
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	pub struct BlockRequest<Hash, Number> {
+		/// Unique request id.
+		pub id: RequestId,
+		/// Bits of block data to request.
+		pub fields: BlockAttributes,
+		/// Start from this block.
+		pub from: FromBlock<Hash, Number>,
+		/// Sequence direction.
+		pub direction: Direction,
+		/// Maximum number of blocks to return. An implementation defined maximum is used when
+		/// unspecified.
+		pub max: Option<u32>,
+	}
+
+	/// Identifies starting point of a block sequence.
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	pub enum FromBlock<Hash, Number> {
+		/// Start with given hash.
+		Hash(Hash),
+		/// Start with given block number.
+		Number(Number),
+	}
+
+	/// Response to `BlockRequest`
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	pub struct BlockResponse<Header, Hash, Extrinsic> {
+		/// Id of a request this response was made for.
+		pub id: RequestId,
+		/// Block data for the requested sequence.
+		pub blocks: Vec<BlockData<Header, Hash, Extrinsic>>,
+	}
+
+	/// Announce a new complete block on the network.
+	#[derive(Debug, PartialEq, Eq, Clone)]
+	pub struct BlockAnnounce<H> {
+		/// New block header.
+		pub header: H,
+		/// Block state. TODO: Remove `Option` and custom encoding when v4 becomes common.
+		pub state: Option<BlockState>,
+		/// Data associated with this block announcement, e.g. a candidate message.
+		pub data: Option<Vec<u8>>,
+	}
+
+	// Custom Encode/Decode impl to maintain backwards compatibility with v3.
+	// This assumes that the packet contains nothing but the announcement message.
+	// TODO: Get rid of it once protocol v4 is common.
+	impl<H: Encode> Encode for BlockAnnounce<H> {
+		fn encode_to<T: Output + ?Sized>(&self, dest: &mut T) {
+			self.header.encode_to(dest);
+			if let Some(state) = &self.state {
+				state.encode_to(dest);
+			}
+			if let Some(data) = &self.data {
+				data.encode_to(dest)
+			}
+		}
+	}
+
+	impl<H: Decode> Decode for BlockAnnounce<H> {
+		fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+			let header = H::decode(input)?;
+			let state = BlockState::decode(input).ok();
+			let data = Vec::decode(input).ok();
+			Ok(Self { header, state, data })
+		}
+	}
+}
+
+/// Handshake sent when we open a block announces substream.
+#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+pub struct BlockAnnouncesHandshake<B: BlockT> {
+	/// Roles of the node.
+	pub roles: Roles,
+	/// Best block number.
+	pub best_number: NumberFor<B>,
+	/// Best block hash.
+	pub best_hash: B::Hash,
+	/// Genesis block hash.
+	pub genesis_hash: B::Hash,
+}
+
+impl<B: BlockT> BlockAnnouncesHandshake<B> {
+	pub fn build(
+		roles: Roles,
+		best_number: NumberFor<B>,
+		best_hash: B::Hash,
+		genesis_hash: B::Hash,
+	) -> Self {
+		Self { genesis_hash, roles, best_number, best_hash }
+	}
+}
diff --git a/substrate/client/network/common/src/sync/metrics.rs b/substrate/client/network/common/src/sync/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..455f57ec3933992cb2e84ba35ce52b7ea3d350e8
--- /dev/null
+++ b/substrate/client/network/common/src/sync/metrics.rs
@@ -0,0 +1,25 @@
+// 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/>.
+
+#[derive(Debug)]
+pub struct Metrics {
+	pub pending_requests: u32,
+	pub active_requests: u32,
+	pub importing_requests: u32,
+	pub failed_requests: u32,
+}
diff --git a/substrate/client/network/common/src/sync/warp.rs b/substrate/client/network/common/src/sync/warp.rs
new file mode 100644
index 0000000000000000000000000000000000000000..37a6e62c53b4e834914df12b6a39b1881f312c14
--- /dev/null
+++ b/substrate/client/network/common/src/sync/warp.rs
@@ -0,0 +1,112 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use codec::{Decode, Encode};
+use futures::channel::oneshot;
+pub use sp_consensus_grandpa::{AuthorityList, SetId};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::{fmt, sync::Arc};
+
+/// Scale-encoded warp sync proof response.
+pub struct EncodedProof(pub Vec<u8>);
+
+/// Warp sync request
+#[derive(Encode, Decode, Debug)]
+pub struct WarpProofRequest<B: BlockT> {
+	/// Start collecting proofs from this block.
+	pub begin: B::Hash,
+}
+
+/// The different types of warp syncing.
+pub enum WarpSyncParams<Block: BlockT> {
+	/// Standard warp sync for the chain.
+	WithProvider(Arc<dyn WarpSyncProvider<Block>>),
+	/// Skip downloading proofs and wait for a header of the state that should be downloaded.
+	///
+	/// It is expected that the header provider ensures that the header is trusted.
+	WaitForTarget(oneshot::Receiver<<Block as BlockT>::Header>),
+}
+
+/// Proof verification result.
+pub enum VerificationResult<Block: BlockT> {
+	/// Proof is valid, but the target was not reached.
+	Partial(SetId, AuthorityList, Block::Hash),
+	/// Target finality is proved.
+	Complete(SetId, AuthorityList, Block::Header),
+}
+
+/// Warp sync backend. Handles retrieving and verifying warp sync proofs.
+pub trait WarpSyncProvider<Block: BlockT>: Send + Sync {
+	/// Generate proof starting at given block hash. The proof is accumulated until maximum proof
+	/// size is reached.
+	fn generate(
+		&self,
+		start: Block::Hash,
+	) -> Result<EncodedProof, Box<dyn std::error::Error + Send + Sync>>;
+	/// Verify warp proof against current set of authorities.
+	fn verify(
+		&self,
+		proof: &EncodedProof,
+		set_id: SetId,
+		authorities: AuthorityList,
+	) -> Result<VerificationResult<Block>, Box<dyn std::error::Error + Send + Sync>>;
+	/// Get current list of authorities. This is supposed to be genesis authorities when starting
+	/// sync.
+	fn current_authorities(&self) -> AuthorityList;
+}
+
+/// Reported warp sync phase.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum WarpSyncPhase<Block: BlockT> {
+	/// Waiting for peers to connect.
+	AwaitingPeers { required_peers: usize },
+	/// Waiting for target block to be received.
+	AwaitingTargetBlock,
+	/// Downloading and verifying grandpa warp proofs.
+	DownloadingWarpProofs,
+	/// Downloading target block.
+	DownloadingTargetBlock,
+	/// Downloading state data.
+	DownloadingState,
+	/// Importing state.
+	ImportingState,
+	/// Downloading block history.
+	DownloadingBlocks(NumberFor<Block>),
+}
+
+impl<Block: BlockT> fmt::Display for WarpSyncPhase<Block> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			Self::AwaitingPeers { required_peers } =>
+				write!(f, "Waiting for {required_peers} peers to be connected"),
+			Self::AwaitingTargetBlock => write!(f, "Waiting for target block to be received"),
+			Self::DownloadingWarpProofs => write!(f, "Downloading finality proofs"),
+			Self::DownloadingTargetBlock => write!(f, "Downloading target block"),
+			Self::DownloadingState => write!(f, "Downloading state"),
+			Self::ImportingState => write!(f, "Importing state"),
+			Self::DownloadingBlocks(n) => write!(f, "Downloading block history (#{})", n),
+		}
+	}
+}
+
+/// Reported warp sync progress.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct WarpSyncProgress<Block: BlockT> {
+	/// Estimated download percentage.
+	pub phase: WarpSyncPhase<Block>,
+	/// Total bytes downloaded so far.
+	pub total_bytes: u64,
+}
diff --git a/substrate/client/network/common/src/types.rs b/substrate/client/network/common/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d23a2236d556a6eb0467fd0e937116d7faf5f9ce
--- /dev/null
+++ b/substrate/client/network/common/src/types.rs
@@ -0,0 +1,38 @@
+// 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/>.
+
+/// Description of a reputation adjustment for a node.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ReputationChange {
+	/// Reputation delta.
+	pub value: i32,
+	/// Reason for reputation change.
+	pub reason: &'static str,
+}
+
+impl ReputationChange {
+	/// New reputation change with given delta and reason.
+	pub const fn new(value: i32, reason: &'static str) -> ReputationChange {
+		Self { value, reason }
+	}
+
+	/// New reputation change that forces minimum possible reputation.
+	pub const fn new_fatal(reason: &'static str) -> ReputationChange {
+		Self { value: i32::MIN, reason }
+	}
+}
diff --git a/substrate/client/network/light/Cargo.toml b/substrate/client/network/light/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8bdb640d5558ba462ad12f478a820db32119fc36
--- /dev/null
+++ b/substrate/client/network/light/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+description = "Substrate light network protocol"
+name = "sc-network-light"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network-light"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[build-dependencies]
+prost-build = "0.11"
+
+[dependencies]
+async-channel = "1.8.0"
+array-bytes = "6.1"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = [
+    "derive",
+] }
+futures = "0.3.21"
+libp2p-identity = { version = "0.1.2", features = ["peerid"] }
+log = "0.4.16"
+prost = "0.11"
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-network = { version = "0.10.0-dev", path = "../" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+thiserror = "1.0"
diff --git a/substrate/client/network/light/build.rs b/substrate/client/network/light/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9c44bcd29318168397802bb7de04088c55309cc7
--- /dev/null
+++ b/substrate/client/network/light/build.rs
@@ -0,0 +1,5 @@
+const PROTOS: &[&str] = &["src/schema/light.v1.proto"];
+
+fn main() {
+	prost_build::compile_protos(PROTOS, &["src/schema"]).unwrap();
+}
diff --git a/substrate/client/network/light/src/lib.rs b/substrate/client/network/light/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..656f658d4c92fb50b5079c0c10e63290e0a977f6
--- /dev/null
+++ b/substrate/client/network/light/src/lib.rs
@@ -0,0 +1,22 @@
+// 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/>.
+
+//! Light client data structures of the networking layer.
+
+pub mod light_client_requests;
+mod schema;
diff --git a/substrate/client/network/light/src/light_client_requests.rs b/substrate/client/network/light/src/light_client_requests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d2a301c00e6b491e204f008ca0393608e966933
--- /dev/null
+++ b/substrate/client/network/light/src/light_client_requests.rs
@@ -0,0 +1,59 @@
+// 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/>.
+
+//! Helpers for outgoing and incoming light client requests.
+
+use sc_network::{config::ProtocolId, request_responses::ProtocolConfig};
+
+use std::time::Duration;
+
+/// For incoming light client requests.
+pub mod handler;
+
+/// Generate the light client protocol name from the genesis hash and fork id.
+fn generate_protocol_name<Hash: AsRef<[u8]>>(genesis_hash: Hash, fork_id: Option<&str>) -> String {
+	let genesis_hash = genesis_hash.as_ref();
+	if let Some(fork_id) = fork_id {
+		format!("/{}/{}/light/2", array_bytes::bytes2hex("", genesis_hash), fork_id)
+	} else {
+		format!("/{}/light/2", array_bytes::bytes2hex("", genesis_hash))
+	}
+}
+
+/// Generate the legacy light client protocol name from chain specific protocol identifier.
+fn generate_legacy_protocol_name(protocol_id: &ProtocolId) -> String {
+	format!("/{}/light/2", protocol_id.as_ref())
+}
+
+/// Generates a [`ProtocolConfig`] for the light client request protocol, refusing incoming
+/// requests.
+pub fn generate_protocol_config<Hash: AsRef<[u8]>>(
+	protocol_id: &ProtocolId,
+	genesis_hash: Hash,
+	fork_id: Option<&str>,
+) -> ProtocolConfig {
+	ProtocolConfig {
+		name: generate_protocol_name(genesis_hash, fork_id).into(),
+		fallback_names: std::iter::once(generate_legacy_protocol_name(protocol_id).into())
+			.collect(),
+		max_request_size: 1 * 1024 * 1024,
+		max_response_size: 16 * 1024 * 1024,
+		request_timeout: Duration::from_secs(15),
+		inbound_queue: None,
+	}
+}
diff --git a/substrate/client/network/light/src/light_client_requests/handler.rs b/substrate/client/network/light/src/light_client_requests/handler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8f2bcc7384b33515412dc7ccdc7d695ce6db87da
--- /dev/null
+++ b/substrate/client/network/light/src/light_client_requests/handler.rs
@@ -0,0 +1,313 @@
+// 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/>.
+
+//! Helper for incoming light client requests.
+//!
+//! Handle (i.e. answer) incoming light client requests from a remote peer received via
+//! `crate::request_responses::RequestResponsesBehaviour` with
+//! [`LightClientRequestHandler`](handler::LightClientRequestHandler).
+
+use crate::schema;
+use codec::{self, Decode, Encode};
+use futures::prelude::*;
+use libp2p_identity::PeerId;
+use log::{debug, trace};
+use prost::Message;
+use sc_client_api::{BlockBackend, ProofProvider};
+use sc_network::{
+	config::ProtocolId,
+	request_responses::{IncomingRequest, OutgoingResponse, ProtocolConfig},
+	ReputationChange,
+};
+use sp_core::{
+	hexdisplay::HexDisplay,
+	storage::{ChildInfo, ChildType, PrefixedStorageKey},
+};
+use sp_runtime::traits::Block;
+use std::{marker::PhantomData, sync::Arc};
+
+const LOG_TARGET: &str = "light-client-request-handler";
+
+/// Incoming requests bounded queue size. For now due to lack of data on light client request
+/// handling in production systems, this value is chosen to match the block request limit.
+const MAX_LIGHT_REQUEST_QUEUE: usize = 20;
+
+/// Handler for incoming light client requests from a remote peer.
+pub struct LightClientRequestHandler<B, Client> {
+	request_receiver: async_channel::Receiver<IncomingRequest>,
+	/// Blockchain client.
+	client: Arc<Client>,
+	_block: PhantomData<B>,
+}
+
+impl<B, Client> LightClientRequestHandler<B, Client>
+where
+	B: Block,
+	Client: BlockBackend<B> + ProofProvider<B> + Send + Sync + 'static,
+{
+	/// Create a new [`LightClientRequestHandler`].
+	pub fn new(
+		protocol_id: &ProtocolId,
+		fork_id: Option<&str>,
+		client: Arc<Client>,
+	) -> (Self, ProtocolConfig) {
+		let (tx, request_receiver) = async_channel::bounded(MAX_LIGHT_REQUEST_QUEUE);
+
+		let mut protocol_config = super::generate_protocol_config(
+			protocol_id,
+			client
+				.block_hash(0u32.into())
+				.ok()
+				.flatten()
+				.expect("Genesis block exists; qed"),
+			fork_id,
+		);
+		protocol_config.inbound_queue = Some(tx);
+
+		(Self { client, request_receiver, _block: PhantomData::default() }, protocol_config)
+	}
+
+	/// Run [`LightClientRequestHandler`].
+	pub async fn run(mut self) {
+		while let Some(request) = self.request_receiver.next().await {
+			let IncomingRequest { peer, payload, pending_response } = request;
+
+			match self.handle_request(peer, payload) {
+				Ok(response_data) => {
+					let response = OutgoingResponse {
+						result: Ok(response_data),
+						reputation_changes: Vec::new(),
+						sent_feedback: None,
+					};
+
+					match pending_response.send(response) {
+						Ok(()) => trace!(
+							target: LOG_TARGET,
+							"Handled light client request from {}.",
+							peer,
+						),
+						Err(_) => debug!(
+							target: LOG_TARGET,
+							"Failed to handle light client request from {}: {}",
+							peer,
+							HandleRequestError::SendResponse,
+						),
+					};
+				},
+				Err(e) => {
+					debug!(
+						target: LOG_TARGET,
+						"Failed to handle light client request from {}: {}", peer, e,
+					);
+
+					let reputation_changes = match e {
+						HandleRequestError::BadRequest(_) => {
+							vec![ReputationChange::new(-(1 << 12), "bad request")]
+						},
+						_ => Vec::new(),
+					};
+
+					let response = OutgoingResponse {
+						result: Err(()),
+						reputation_changes,
+						sent_feedback: None,
+					};
+
+					if pending_response.send(response).is_err() {
+						debug!(
+							target: LOG_TARGET,
+							"Failed to handle light client request from {}: {}",
+							peer,
+							HandleRequestError::SendResponse,
+						);
+					};
+				},
+			}
+		}
+	}
+
+	fn handle_request(
+		&mut self,
+		peer: PeerId,
+		payload: Vec<u8>,
+	) -> Result<Vec<u8>, HandleRequestError> {
+		let request = schema::v1::light::Request::decode(&payload[..])?;
+
+		let response = match &request.request {
+			Some(schema::v1::light::request::Request::RemoteCallRequest(r)) =>
+				self.on_remote_call_request(&peer, r)?,
+			Some(schema::v1::light::request::Request::RemoteReadRequest(r)) =>
+				self.on_remote_read_request(&peer, r)?,
+			Some(schema::v1::light::request::Request::RemoteReadChildRequest(r)) =>
+				self.on_remote_read_child_request(&peer, r)?,
+			None =>
+				return Err(HandleRequestError::BadRequest("Remote request without request data.")),
+		};
+
+		let mut data = Vec::new();
+		response.encode(&mut data)?;
+
+		Ok(data)
+	}
+
+	fn on_remote_call_request(
+		&mut self,
+		peer: &PeerId,
+		request: &schema::v1::light::RemoteCallRequest,
+	) -> Result<schema::v1::light::Response, HandleRequestError> {
+		trace!("Remote call request from {} ({} at {:?}).", peer, request.method, request.block,);
+
+		let block = Decode::decode(&mut request.block.as_ref())?;
+
+		let response = match self.client.execution_proof(block, &request.method, &request.data) {
+			Ok((_, proof)) => schema::v1::light::RemoteCallResponse { proof: Some(proof.encode()) },
+			Err(e) => {
+				trace!(
+					"remote call request from {} ({} at {:?}) failed with: {}",
+					peer,
+					request.method,
+					request.block,
+					e,
+				);
+				schema::v1::light::RemoteCallResponse { proof: None }
+			},
+		};
+
+		Ok(schema::v1::light::Response {
+			response: Some(schema::v1::light::response::Response::RemoteCallResponse(response)),
+		})
+	}
+
+	fn on_remote_read_request(
+		&mut self,
+		peer: &PeerId,
+		request: &schema::v1::light::RemoteReadRequest,
+	) -> Result<schema::v1::light::Response, HandleRequestError> {
+		if request.keys.is_empty() {
+			debug!("Invalid remote read request sent by {}.", peer);
+			return Err(HandleRequestError::BadRequest("Remote read request without keys."))
+		}
+
+		trace!(
+			"Remote read request from {} ({} at {:?}).",
+			peer,
+			fmt_keys(request.keys.first(), request.keys.last()),
+			request.block,
+		);
+
+		let block = Decode::decode(&mut request.block.as_ref())?;
+
+		let response =
+			match self.client.read_proof(block, &mut request.keys.iter().map(AsRef::as_ref)) {
+				Ok(proof) => schema::v1::light::RemoteReadResponse { proof: Some(proof.encode()) },
+				Err(error) => {
+					trace!(
+						"remote read request from {} ({} at {:?}) failed with: {}",
+						peer,
+						fmt_keys(request.keys.first(), request.keys.last()),
+						request.block,
+						error,
+					);
+					schema::v1::light::RemoteReadResponse { proof: None }
+				},
+			};
+
+		Ok(schema::v1::light::Response {
+			response: Some(schema::v1::light::response::Response::RemoteReadResponse(response)),
+		})
+	}
+
+	fn on_remote_read_child_request(
+		&mut self,
+		peer: &PeerId,
+		request: &schema::v1::light::RemoteReadChildRequest,
+	) -> Result<schema::v1::light::Response, HandleRequestError> {
+		if request.keys.is_empty() {
+			debug!("Invalid remote child read request sent by {}.", peer);
+			return Err(HandleRequestError::BadRequest("Remove read child request without keys."))
+		}
+
+		trace!(
+			"Remote read child request from {} ({} {} at {:?}).",
+			peer,
+			HexDisplay::from(&request.storage_key),
+			fmt_keys(request.keys.first(), request.keys.last()),
+			request.block,
+		);
+
+		let block = Decode::decode(&mut request.block.as_ref())?;
+
+		let prefixed_key = PrefixedStorageKey::new_ref(&request.storage_key);
+		let child_info = match ChildType::from_prefixed_key(prefixed_key) {
+			Some((ChildType::ParentKeyId, storage_key)) => Ok(ChildInfo::new_default(storage_key)),
+			None => Err(sp_blockchain::Error::InvalidChildStorageKey),
+		};
+		let response = match child_info.and_then(|child_info| {
+			self.client.read_child_proof(
+				block,
+				&child_info,
+				&mut request.keys.iter().map(AsRef::as_ref),
+			)
+		}) {
+			Ok(proof) => schema::v1::light::RemoteReadResponse { proof: Some(proof.encode()) },
+			Err(error) => {
+				trace!(
+					"remote read child request from {} ({} {} at {:?}) failed with: {}",
+					peer,
+					HexDisplay::from(&request.storage_key),
+					fmt_keys(request.keys.first(), request.keys.last()),
+					request.block,
+					error,
+				);
+				schema::v1::light::RemoteReadResponse { proof: None }
+			},
+		};
+
+		Ok(schema::v1::light::Response {
+			response: Some(schema::v1::light::response::Response::RemoteReadResponse(response)),
+		})
+	}
+}
+
+#[derive(Debug, thiserror::Error)]
+enum HandleRequestError {
+	#[error("Failed to decode request: {0}.")]
+	DecodeProto(#[from] prost::DecodeError),
+	#[error("Failed to encode response: {0}.")]
+	EncodeProto(#[from] prost::EncodeError),
+	#[error("Failed to send response.")]
+	SendResponse,
+	/// A bad request has been received.
+	#[error("bad request: {0}")]
+	BadRequest(&'static str),
+	/// Encoding or decoding of some data failed.
+	#[error("codec error: {0}")]
+	Codec(#[from] codec::Error),
+}
+
+fn fmt_keys(first: Option<&Vec<u8>>, last: Option<&Vec<u8>>) -> String {
+	if let (Some(first), Some(last)) = (first, last) {
+		if first == last {
+			HexDisplay::from(first).to_string()
+		} else {
+			format!("{}..{}", HexDisplay::from(first), HexDisplay::from(last))
+		}
+	} else {
+		String::from("n/a")
+	}
+}
diff --git a/substrate/client/network/light/src/schema.rs b/substrate/client/network/light/src/schema.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0ef9bac4df976eb703d50ad5e291d426d3bda905
--- /dev/null
+++ b/substrate/client/network/light/src/schema.rs
@@ -0,0 +1,69 @@
+// 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/>.
+
+//! Include sources generated from protobuf definitions.
+
+pub(crate) mod v1 {
+	pub(crate) mod light {
+		include!(concat!(env!("OUT_DIR"), "/api.v1.light.rs"));
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use prost::Message as _;
+
+	#[test]
+	fn empty_proof_encodes_correctly() {
+		let encoded = super::v1::light::Response {
+			response: Some(super::v1::light::response::Response::RemoteReadResponse(
+				super::v1::light::RemoteReadResponse { proof: Some(Vec::new()) },
+			)),
+		}
+		.encode_to_vec();
+
+		// Make sure that the response contains one field of number 2 and wire type 2 (message),
+		// then another field of number 2 and wire type 2 (bytes), then a length of 0.
+		assert_eq!(encoded, vec![(2 << 3) | 2, 2, (2 << 3) | 2, 0]);
+	}
+
+	#[test]
+	fn no_proof_encodes_correctly() {
+		let encoded = super::v1::light::Response {
+			response: Some(super::v1::light::response::Response::RemoteReadResponse(
+				super::v1::light::RemoteReadResponse { proof: None },
+			)),
+		}
+		.encode_to_vec();
+
+		// Make sure that the response contains one field of number 2 and wire type 2 (message).
+		assert_eq!(encoded, vec![(2 << 3) | 2, 0]);
+	}
+
+	#[test]
+	fn proof_encodes_correctly() {
+		let encoded = super::v1::light::Response {
+			response: Some(super::v1::light::response::Response::RemoteReadResponse(
+				super::v1::light::RemoteReadResponse { proof: Some(vec![1, 2, 3, 4]) },
+			)),
+		}
+		.encode_to_vec();
+
+		assert_eq!(encoded, vec![(2 << 3) | 2, 6, (2 << 3) | 2, 4, 1, 2, 3, 4]);
+	}
+}
diff --git a/substrate/client/network/light/src/schema/light.v1.proto b/substrate/client/network/light/src/schema/light.v1.proto
new file mode 100644
index 0000000000000000000000000000000000000000..a269ea73c2074bff654746f49083e649ce7ff7d1
--- /dev/null
+++ b/substrate/client/network/light/src/schema/light.v1.proto
@@ -0,0 +1,67 @@
+// Schema definition for light client messages.
+
+syntax = "proto2";
+
+package api.v1.light;
+
+// Enumerate all possible light client request messages.
+message Request {
+	oneof request {
+		RemoteCallRequest remote_call_request = 1;
+		RemoteReadRequest remote_read_request = 2;
+		RemoteReadChildRequest remote_read_child_request = 4;
+		// Note: ids 3 and 5 were used in the past. It would be preferable to not re-use them.
+	}
+}
+
+// Enumerate all possible light client response messages.
+message Response {
+	oneof response {
+		RemoteCallResponse remote_call_response = 1;
+		RemoteReadResponse remote_read_response = 2;
+		// Note: ids 3 and 4 were used in the past. It would be preferable to not re-use them.
+	}
+}
+
+// Remote call request.
+message RemoteCallRequest {
+	// Block at which to perform call.
+	required bytes block = 2;
+	// Method name.
+	required string method = 3;
+	// Call data.
+	required bytes data = 4;
+}
+
+// Remote call response.
+message RemoteCallResponse {
+	// Execution proof. If missing, indicates that the remote couldn't answer, for example because
+	// the block is pruned.
+	optional bytes proof = 2;
+}
+
+// Remote storage read request.
+message RemoteReadRequest {
+	// Block at which to perform call.
+	required bytes block = 2;
+	// Storage keys.
+	repeated bytes keys = 3;
+}
+
+// Remote read response.
+message RemoteReadResponse {
+	// Read proof. If missing, indicates that the remote couldn't answer, for example because
+	// the block is pruned.
+	optional bytes proof = 2;
+}
+
+// Remote storage read child request.
+message RemoteReadChildRequest {
+	// Block at which to perform call.
+	required bytes block = 2;
+	// Child Storage key, this is relative
+	// to the child type storage location.
+	required bytes storage_key = 3;
+	// Storage keys.
+	repeated bytes keys = 6;
+}
diff --git a/substrate/client/network/src/behaviour.rs b/substrate/client/network/src/behaviour.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0aa724818e02a3b4db78eefebfb7223ca7e04c1f
--- /dev/null
+++ b/substrate/client/network/src/behaviour.rs
@@ -0,0 +1,359 @@
+// 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::{
+	discovery::{DiscoveryBehaviour, DiscoveryConfig, DiscoveryOut},
+	event::DhtEvent,
+	peer_info,
+	peer_store::PeerStoreHandle,
+	protocol::{CustomMessageOutcome, NotificationsSink, Protocol},
+	request_responses::{self, IfDisconnected, ProtocolConfig, RequestFailure},
+	types::ProtocolName,
+	ReputationChange,
+};
+
+use bytes::Bytes;
+use futures::channel::oneshot;
+use libp2p::{
+	core::Multiaddr, identify::Info as IdentifyInfo, identity::PublicKey, kad::RecordKey,
+	swarm::NetworkBehaviour, PeerId,
+};
+
+use parking_lot::Mutex;
+use sc_network_common::role::{ObservedRole, Roles};
+use sp_runtime::traits::Block as BlockT;
+use std::{collections::HashSet, sync::Arc, time::Duration};
+
+pub use crate::request_responses::{InboundFailure, OutboundFailure, RequestId, ResponseFailure};
+
+/// General behaviour of the network. Combines all protocols together.
+#[derive(NetworkBehaviour)]
+#[behaviour(out_event = "BehaviourOut")]
+pub struct Behaviour<B: BlockT> {
+	/// All the substrate-specific protocols.
+	substrate: Protocol<B>,
+	/// Periodically pings and identifies the nodes we are connected to, and store information in a
+	/// cache.
+	peer_info: peer_info::PeerInfoBehaviour,
+	/// Discovers nodes of the network.
+	discovery: DiscoveryBehaviour,
+	/// Generic request-response protocols.
+	request_responses: request_responses::RequestResponsesBehaviour,
+}
+
+/// Event generated by `Behaviour`.
+pub enum BehaviourOut {
+	/// Started a random iterative Kademlia discovery query.
+	RandomKademliaStarted,
+
+	/// We have received a request from a peer and answered it.
+	///
+	/// This event is generated for statistics purposes.
+	InboundRequest {
+		/// Peer which sent us a request.
+		peer: PeerId,
+		/// Protocol name of the request.
+		protocol: ProtocolName,
+		/// If `Ok`, contains the time elapsed between when we received the request and when we
+		/// sent back the response. If `Err`, the error that happened.
+		result: Result<Duration, ResponseFailure>,
+	},
+
+	/// A request has succeeded or failed.
+	///
+	/// This event is generated for statistics purposes.
+	RequestFinished {
+		/// Peer that we send a request to.
+		peer: PeerId,
+		/// Name of the protocol in question.
+		protocol: ProtocolName,
+		/// Duration the request took.
+		duration: Duration,
+		/// Result of the request.
+		result: Result<(), RequestFailure>,
+	},
+
+	/// A request protocol handler issued reputation changes for the given peer.
+	ReputationChanges { peer: PeerId, changes: Vec<ReputationChange> },
+
+	/// Opened a substream with the given node with the given notifications protocol.
+	///
+	/// The protocol is always one of the notification protocols that have been registered.
+	NotificationStreamOpened {
+		/// Node we opened the substream with.
+		remote: PeerId,
+		/// The concerned protocol. Each protocol uses a different substream.
+		protocol: ProtocolName,
+		/// If the negotiation didn't use the main name of the protocol (the one in
+		/// `notifications_protocol`), then this field contains which name has actually been
+		/// used.
+		/// See also [`crate::Event::NotificationStreamOpened`].
+		negotiated_fallback: Option<ProtocolName>,
+		/// Object that permits sending notifications to the peer.
+		notifications_sink: NotificationsSink,
+		/// Role of the remote.
+		role: ObservedRole,
+		/// Received handshake.
+		received_handshake: Vec<u8>,
+	},
+
+	/// The [`NotificationsSink`] object used to send notifications with the given peer must be
+	/// replaced with a new one.
+	///
+	/// This event is typically emitted when a transport-level connection is closed and we fall
+	/// back to a secondary connection.
+	NotificationStreamReplaced {
+		/// Id of the peer we are connected to.
+		remote: PeerId,
+		/// The concerned protocol. Each protocol uses a different substream.
+		protocol: ProtocolName,
+		/// Replacement for the previous [`NotificationsSink`].
+		notifications_sink: NotificationsSink,
+	},
+
+	/// Closed a substream with the given node. Always matches a corresponding previous
+	/// `NotificationStreamOpened` message.
+	NotificationStreamClosed {
+		/// Node we closed the substream with.
+		remote: PeerId,
+		/// The concerned protocol. Each protocol uses a different substream.
+		protocol: ProtocolName,
+	},
+
+	/// Received one or more messages from the given node using the given protocol.
+	NotificationsReceived {
+		/// Node we received the message from.
+		remote: PeerId,
+		/// Concerned protocol and associated message.
+		messages: Vec<(ProtocolName, Bytes)>,
+	},
+
+	/// We have obtained identity information from a peer, including the addresses it is listening
+	/// on.
+	PeerIdentify {
+		/// Id of the peer that has been identified.
+		peer_id: PeerId,
+		/// Information about the peer.
+		info: IdentifyInfo,
+	},
+
+	/// 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),
+
+	/// Ignored event generated by lower layers.
+	None,
+}
+
+impl<B: BlockT> Behaviour<B> {
+	/// Builds a new `Behaviour`.
+	pub fn new(
+		substrate: Protocol<B>,
+		user_agent: String,
+		local_public_key: PublicKey,
+		disco_config: DiscoveryConfig,
+		request_response_protocols: Vec<ProtocolConfig>,
+		peer_store_handle: PeerStoreHandle,
+		external_addresses: Arc<Mutex<HashSet<Multiaddr>>>,
+	) -> Result<Self, request_responses::RegisterError> {
+		Ok(Self {
+			substrate,
+			peer_info: peer_info::PeerInfoBehaviour::new(
+				user_agent,
+				local_public_key,
+				external_addresses,
+			),
+			discovery: disco_config.finish(),
+			request_responses: request_responses::RequestResponsesBehaviour::new(
+				request_response_protocols.into_iter(),
+				Box::new(peer_store_handle),
+			)?,
+		})
+	}
+
+	/// Returns the list of nodes that we know exist in the network.
+	pub fn known_peers(&mut self) -> HashSet<PeerId> {
+		self.discovery.known_peers()
+	}
+
+	/// Adds a hard-coded address for the given peer, that never expires.
+	pub fn add_known_address(&mut self, peer_id: PeerId, addr: Multiaddr) {
+		self.discovery.add_known_address(peer_id, addr)
+	}
+
+	/// Returns the number of nodes in each Kademlia kbucket.
+	///
+	/// Identifies kbuckets by the base 2 logarithm of their lower bound.
+	pub fn num_entries_per_kbucket(&mut self) -> Option<Vec<(u32, usize)>> {
+		self.discovery.num_entries_per_kbucket()
+	}
+
+	/// Returns the number of records in the Kademlia record stores.
+	pub fn num_kademlia_records(&mut self) -> Option<usize> {
+		self.discovery.num_kademlia_records()
+	}
+
+	/// Returns the total size in bytes of all the records in the Kademlia record stores.
+	pub fn kademlia_records_total_size(&mut self) -> Option<usize> {
+		self.discovery.kademlia_records_total_size()
+	}
+
+	/// Borrows `self` and returns a struct giving access to the information about a node.
+	///
+	/// Returns `None` if we don't know anything about this node. Always returns `Some` for nodes
+	/// we're connected to, meaning that if `None` is returned then we're not connected to that
+	/// node.
+	pub fn node(&self, peer_id: &PeerId) -> Option<peer_info::Node> {
+		self.peer_info.node(peer_id)
+	}
+
+	/// Initiates sending a request.
+	pub fn send_request(
+		&mut self,
+		target: &PeerId,
+		protocol: &str,
+		request: Vec<u8>,
+		pending_response: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		connect: IfDisconnected,
+	) {
+		self.request_responses
+			.send_request(target, protocol, request, pending_response, connect)
+	}
+
+	/// Returns a shared reference to the user protocol.
+	pub fn user_protocol(&self) -> &Protocol<B> {
+		&self.substrate
+	}
+
+	/// Returns a mutable reference to the user protocol.
+	pub fn user_protocol_mut(&mut self) -> &mut Protocol<B> {
+		&mut self.substrate
+	}
+
+	/// Add a self-reported address of a remote peer to the k-buckets of the supported
+	/// DHTs (`supported_protocols`).
+	pub fn add_self_reported_address_to_dht(
+		&mut self,
+		peer_id: &PeerId,
+		supported_protocols: &[impl AsRef<[u8]>],
+		addr: Multiaddr,
+	) {
+		self.discovery.add_self_reported_address(peer_id, supported_protocols, addr);
+	}
+
+	/// Start querying a record from the DHT. Will later produce either a `ValueFound` or a
+	/// `ValueNotFound` event.
+	pub fn get_value(&mut self, key: RecordKey) {
+		self.discovery.get_value(key);
+	}
+
+	/// Starts putting a record into DHT. Will later produce either a `ValuePut` or a
+	/// `ValuePutFailed` event.
+	pub fn put_value(&mut self, key: RecordKey, value: Vec<u8>) {
+		self.discovery.put_value(key, value);
+	}
+}
+
+fn reported_roles_to_observed_role(roles: Roles) -> ObservedRole {
+	if roles.is_authority() {
+		ObservedRole::Authority
+	} else if roles.is_full() {
+		ObservedRole::Full
+	} else {
+		ObservedRole::Light
+	}
+}
+
+impl From<CustomMessageOutcome> for BehaviourOut {
+	fn from(event: CustomMessageOutcome) -> Self {
+		match event {
+			CustomMessageOutcome::NotificationStreamOpened {
+				remote,
+				protocol,
+				negotiated_fallback,
+				roles,
+				received_handshake,
+				notifications_sink,
+			} => BehaviourOut::NotificationStreamOpened {
+				remote,
+				protocol,
+				negotiated_fallback,
+				role: reported_roles_to_observed_role(roles),
+				received_handshake,
+				notifications_sink,
+			},
+			CustomMessageOutcome::NotificationStreamReplaced {
+				remote,
+				protocol,
+				notifications_sink,
+			} => BehaviourOut::NotificationStreamReplaced { remote, protocol, notifications_sink },
+			CustomMessageOutcome::NotificationStreamClosed { remote, protocol } =>
+				BehaviourOut::NotificationStreamClosed { remote, protocol },
+			CustomMessageOutcome::NotificationsReceived { remote, messages } =>
+				BehaviourOut::NotificationsReceived { remote, messages },
+			CustomMessageOutcome::None => BehaviourOut::None,
+		}
+	}
+}
+
+impl From<request_responses::Event> for BehaviourOut {
+	fn from(event: request_responses::Event) -> Self {
+		match event {
+			request_responses::Event::InboundRequest { peer, protocol, result } =>
+				BehaviourOut::InboundRequest { peer, protocol, result },
+			request_responses::Event::RequestFinished { peer, protocol, duration, result } =>
+				BehaviourOut::RequestFinished { peer, protocol, duration, result },
+			request_responses::Event::ReputationChanges { peer, changes } =>
+				BehaviourOut::ReputationChanges { peer, changes },
+		}
+	}
+}
+
+impl From<peer_info::PeerInfoEvent> for BehaviourOut {
+	fn from(event: peer_info::PeerInfoEvent) -> Self {
+		let peer_info::PeerInfoEvent::Identified { peer_id, info } = event;
+		BehaviourOut::PeerIdentify { peer_id, info }
+	}
+}
+
+impl From<DiscoveryOut> for BehaviourOut {
+	fn from(event: DiscoveryOut) -> Self {
+		match event {
+			DiscoveryOut::UnroutablePeer(_peer_id) => {
+				// Obtaining and reporting listen addresses for unroutable peers back
+				// to Kademlia is handled by the `Identify` protocol, part of the
+				// `PeerInfoBehaviour`. See the `From<peer_info::PeerInfoEvent>`
+				// implementation.
+				BehaviourOut::None
+			},
+			DiscoveryOut::Discovered(peer_id) => BehaviourOut::Discovered(peer_id),
+			DiscoveryOut::ValueFound(results, duration) =>
+				BehaviourOut::Dht(DhtEvent::ValueFound(results), duration),
+			DiscoveryOut::ValueNotFound(key, duration) =>
+				BehaviourOut::Dht(DhtEvent::ValueNotFound(key), duration),
+			DiscoveryOut::ValuePut(key, duration) =>
+				BehaviourOut::Dht(DhtEvent::ValuePut(key), duration),
+			DiscoveryOut::ValuePutFailed(key, duration) =>
+				BehaviourOut::Dht(DhtEvent::ValuePutFailed(key), duration),
+			DiscoveryOut::RandomKademliaStarted => BehaviourOut::RandomKademliaStarted,
+		}
+	}
+}
diff --git a/substrate/client/network/src/config.rs b/substrate/client/network/src/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d069c3f458ff5d0391286687f10a08aefc5793fc
--- /dev/null
+++ b/substrate/client/network/src/config.rs
@@ -0,0 +1,792 @@
+// 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/>.
+
+//! Configuration of the networking layer.
+//!
+//! The [`Params`] struct is the struct that must be passed in order to initialize the networking.
+//! See the documentation of [`Params`].
+
+pub use crate::{
+	discovery::DEFAULT_KADEMLIA_REPLICATION_FACTOR,
+	protocol::NotificationsSink,
+	request_responses::{
+		IncomingRequest, OutgoingResponse, ProtocolConfig as RequestResponseConfig,
+	},
+	types::ProtocolName,
+};
+
+pub use libp2p::{identity::Keypair, multiaddr, Multiaddr, PeerId};
+
+use crate::peer_store::PeerStoreHandle;
+use codec::Encode;
+use prometheus_endpoint::Registry;
+use zeroize::Zeroize;
+
+pub use sc_network_common::{
+	role::{Role, Roles},
+	sync::{warp::WarpSyncProvider, SyncMode},
+	ExHashT,
+};
+use sc_utils::mpsc::TracingUnboundedSender;
+use sp_runtime::traits::Block as BlockT;
+
+use std::{
+	error::Error,
+	fmt, fs,
+	future::Future,
+	io::{self, Write},
+	iter,
+	net::Ipv4Addr,
+	num::NonZeroUsize,
+	path::{Path, PathBuf},
+	pin::Pin,
+	str::{self, FromStr},
+};
+
+pub use libp2p::{
+	build_multiaddr,
+	identity::{self, ed25519},
+};
+
+/// Protocol name prefix, transmitted on the wire for legacy protocol names.
+/// I.e., `dot` in `/dot/sync/2`. Should be unique for each chain. Always UTF-8.
+/// Deprecated in favour of genesis hash & fork ID based protocol names.
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct ProtocolId(smallvec::SmallVec<[u8; 6]>);
+
+impl<'a> From<&'a str> for ProtocolId {
+	fn from(bytes: &'a str) -> ProtocolId {
+		Self(bytes.as_bytes().into())
+	}
+}
+
+impl AsRef<str> for ProtocolId {
+	fn as_ref(&self) -> &str {
+		str::from_utf8(&self.0[..])
+			.expect("the only way to build a ProtocolId is through a UTF-8 String; qed")
+	}
+}
+
+impl fmt::Debug for ProtocolId {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		fmt::Debug::fmt(self.as_ref(), f)
+	}
+}
+
+/// Parses a string address and splits it into Multiaddress and PeerId, if
+/// valid.
+///
+/// # Example
+///
+/// ```
+/// # use libp2p::{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"
+/// ).unwrap();
+/// assert_eq!(peer_id, "QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".parse::<PeerId>().unwrap());
+/// assert_eq!(addr, "/ip4/198.51.100.19/tcp/30333".parse::<Multiaddr>().unwrap());
+/// ```
+pub fn parse_str_addr(addr_str: &str) -> Result<(PeerId, Multiaddr), ParseErr> {
+	let addr: Multiaddr = addr_str.parse()?;
+	parse_addr(addr)
+}
+
+/// Splits a Multiaddress into a Multiaddress and PeerId.
+pub fn parse_addr(mut addr: Multiaddr) -> Result<(PeerId, Multiaddr), ParseErr> {
+	let who = match addr.pop() {
+		Some(multiaddr::Protocol::P2p(key)) =>
+			PeerId::from_multihash(key).map_err(|_| ParseErr::InvalidPeerId)?,
+		_ => return Err(ParseErr::PeerIdMissing),
+	};
+
+	Ok((who, addr))
+}
+
+/// Address of a node, including its identity.
+///
+/// This struct represents a decoded version of a multiaddress that ends with `/p2p/<peerid>`.
+///
+/// # Example
+///
+/// ```
+/// # use libp2p::{Multiaddr, PeerId};
+/// use sc_network::config::MultiaddrWithPeerId;
+/// let addr: MultiaddrWithPeerId =
+/// 	"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".parse().unwrap();
+/// assert_eq!(addr.peer_id.to_base58(), "QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV");
+/// assert_eq!(addr.multiaddr.to_string(), "/ip4/198.51.100.19/tcp/30333");
+/// ```
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
+#[serde(try_from = "String", into = "String")]
+pub struct MultiaddrWithPeerId {
+	/// Address of the node.
+	pub multiaddr: Multiaddr,
+	/// Its identity.
+	pub peer_id: PeerId,
+}
+
+impl MultiaddrWithPeerId {
+	/// Concatenates the multiaddress and peer ID into one multiaddress containing both.
+	pub fn concat(&self) -> Multiaddr {
+		let proto = multiaddr::Protocol::P2p(From::from(self.peer_id));
+		self.multiaddr.clone().with(proto)
+	}
+}
+
+impl fmt::Display for MultiaddrWithPeerId {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		fmt::Display::fmt(&self.concat(), f)
+	}
+}
+
+impl FromStr for MultiaddrWithPeerId {
+	type Err = ParseErr;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let (peer_id, multiaddr) = parse_str_addr(s)?;
+		Ok(Self { peer_id, multiaddr })
+	}
+}
+
+impl From<MultiaddrWithPeerId> for String {
+	fn from(ma: MultiaddrWithPeerId) -> String {
+		format!("{}", ma)
+	}
+}
+
+impl TryFrom<String> for MultiaddrWithPeerId {
+	type Error = ParseErr;
+	fn try_from(string: String) -> Result<Self, Self::Error> {
+		string.parse()
+	}
+}
+
+/// Error that can be generated by `parse_str_addr`.
+#[derive(Debug)]
+pub enum ParseErr {
+	/// Error while parsing the multiaddress.
+	MultiaddrParse(multiaddr::Error),
+	/// Multihash of the peer ID is invalid.
+	InvalidPeerId,
+	/// The peer ID is missing from the address.
+	PeerIdMissing,
+}
+
+impl fmt::Display for ParseErr {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		match self {
+			Self::MultiaddrParse(err) => write!(f, "{}", err),
+			Self::InvalidPeerId => write!(f, "Peer id at the end of the address is invalid"),
+			Self::PeerIdMissing => write!(f, "Peer id is missing from the address"),
+		}
+	}
+}
+
+impl std::error::Error for ParseErr {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		match self {
+			Self::MultiaddrParse(err) => Some(err),
+			Self::InvalidPeerId => None,
+			Self::PeerIdMissing => None,
+		}
+	}
+}
+
+impl From<multiaddr::Error> for ParseErr {
+	fn from(err: multiaddr::Error) -> ParseErr {
+		Self::MultiaddrParse(err)
+	}
+}
+
+/// Custom handshake for the notification protocol
+#[derive(Debug, Clone)]
+pub struct NotificationHandshake(Vec<u8>);
+
+impl NotificationHandshake {
+	/// Create new `NotificationHandshake` from an object that implements `Encode`
+	pub fn new<H: Encode>(handshake: H) -> Self {
+		Self(handshake.encode())
+	}
+
+	/// Create new `NotificationHandshake` from raw bytes
+	pub fn from_bytes(bytes: Vec<u8>) -> Self {
+		Self(bytes)
+	}
+}
+
+impl std::ops::Deref for NotificationHandshake {
+	type Target = Vec<u8>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+/// Configuration for the transport layer.
+#[derive(Clone, Debug)]
+pub enum TransportConfig {
+	/// Normal transport mode.
+	Normal {
+		/// If true, the network will use mDNS to discover other libp2p nodes on the local network
+		/// and connect to them if they support the same chain.
+		enable_mdns: bool,
+
+		/// If true, allow connecting to private IPv4/IPv6 addresses (as defined in
+		/// [RFC1918](https://tools.ietf.org/html/rfc1918)). Irrelevant for addresses that have
+		/// been passed in `::sc_network::config::NetworkConfiguration::boot_nodes`.
+		allow_private_ip: bool,
+	},
+
+	/// Only allow connections within the same process.
+	/// Only addresses of the form `/memory/...` will be supported.
+	MemoryOnly,
+}
+
+/// The policy for connections to non-reserved peers.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum NonReservedPeerMode {
+	/// Accept them. This is the default.
+	Accept,
+	/// Deny them.
+	Deny,
+}
+
+impl NonReservedPeerMode {
+	/// Attempt to parse the peer mode from a string.
+	pub fn parse(s: &str) -> Option<Self> {
+		match s {
+			"accept" => Some(Self::Accept),
+			"deny" => Some(Self::Deny),
+			_ => None,
+		}
+	}
+
+	/// If we are in "reserved-only" peer mode.
+	pub fn is_reserved_only(&self) -> bool {
+		matches!(self, NonReservedPeerMode::Deny)
+	}
+}
+
+/// The configuration of a node's secret key, describing the type of key
+/// and how it is obtained. A node's identity keypair is the result of
+/// the evaluation of the node key configuration.
+#[derive(Clone, Debug)]
+pub enum NodeKeyConfig {
+	/// A Ed25519 secret key configuration.
+	Ed25519(Secret<ed25519::SecretKey>),
+}
+
+impl Default for NodeKeyConfig {
+	fn default() -> NodeKeyConfig {
+		Self::Ed25519(Secret::New)
+	}
+}
+
+/// The options for obtaining a Ed25519 secret key.
+pub type Ed25519Secret = Secret<ed25519::SecretKey>;
+
+/// The configuration options for obtaining a secret key `K`.
+#[derive(Clone)]
+pub enum Secret<K> {
+	/// Use the given secret key `K`.
+	Input(K),
+	/// Read the secret key from a file. If the file does not exist,
+	/// it is created with a newly generated secret key `K`. The format
+	/// of the file is determined by `K`:
+	///
+	///   * `ed25519::SecretKey`: An unencoded 32 bytes Ed25519 secret key.
+	File(PathBuf),
+	/// Always generate a new secret key `K`.
+	New,
+}
+
+impl<K> fmt::Debug for Secret<K> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			Self::Input(_) => f.debug_tuple("Secret::Input").finish(),
+			Self::File(path) => f.debug_tuple("Secret::File").field(path).finish(),
+			Self::New => f.debug_tuple("Secret::New").finish(),
+		}
+	}
+}
+
+impl NodeKeyConfig {
+	/// Evaluate a `NodeKeyConfig` to obtain an identity `Keypair`:
+	///
+	///  * If the secret is configured as input, the corresponding keypair is returned.
+	///
+	///  * If the secret is configured as a file, it is read from that file, if it exists. Otherwise
+	///    a new secret is generated and stored. In either case, the keypair obtained from the
+	///    secret is returned.
+	///
+	///  * 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> {
+		use NodeKeyConfig::*;
+		match self {
+			Ed25519(Secret::New) => Ok(Keypair::generate_ed25519()),
+
+			Ed25519(Secret::Input(k)) => Ok(ed25519::Keypair::from(k).into()),
+
+			Ed25519(Secret::File(f)) => get_secret(
+				f,
+				|mut b| match String::from_utf8(b.to_vec()).ok().and_then(|s| {
+					if s.len() == 64 {
+						array_bytes::hex2bytes(&s).ok()
+					} else {
+						None
+					}
+				}) {
+					Some(s) => ed25519::SecretKey::try_from_bytes(s),
+					_ => ed25519::SecretKey::try_from_bytes(&mut b),
+				},
+				ed25519::SecretKey::generate,
+				|b| b.as_ref().to_vec(),
+			)
+			.map(ed25519::Keypair::from)
+			.map(Keypair::from),
+		}
+	}
+}
+
+/// Load a secret key from a file, if it exists, or generate a
+/// new secret key and write it to that file. In either case,
+/// the secret key is returned.
+fn get_secret<P, F, G, E, W, K>(file: P, parse: F, generate: G, serialize: W) -> io::Result<K>
+where
+	P: AsRef<Path>,
+	F: for<'r> FnOnce(&'r mut [u8]) -> Result<K, E>,
+	G: FnOnce() -> K,
+	E: Error + Send + Sync + 'static,
+	W: Fn(&K) -> Vec<u8>,
+{
+	std::fs::read(&file)
+		.and_then(|mut sk_bytes| {
+			parse(&mut sk_bytes).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+		})
+		.or_else(|e| {
+			if e.kind() == io::ErrorKind::NotFound {
+				file.as_ref().parent().map_or(Ok(()), fs::create_dir_all)?;
+				let sk = generate();
+				let mut sk_vec = serialize(&sk);
+				write_secret_file(file, &sk_vec)?;
+				sk_vec.zeroize();
+				Ok(sk)
+			} else {
+				Err(e)
+			}
+		})
+}
+
+/// Write secret bytes to a file.
+fn write_secret_file<P>(path: P, sk_bytes: &[u8]) -> io::Result<()>
+where
+	P: AsRef<Path>,
+{
+	let mut file = open_secret_file(&path)?;
+	file.write_all(sk_bytes)
+}
+
+/// Opens a file containing a secret key in write mode.
+#[cfg(unix)]
+fn open_secret_file<P>(path: P) -> io::Result<fs::File>
+where
+	P: AsRef<Path>,
+{
+	use std::os::unix::fs::OpenOptionsExt;
+	fs::OpenOptions::new().write(true).create_new(true).mode(0o600).open(path)
+}
+
+/// Opens a file containing a secret key in write mode.
+#[cfg(not(unix))]
+fn open_secret_file<P>(path: P) -> Result<fs::File, io::Error>
+where
+	P: AsRef<Path>,
+{
+	fs::OpenOptions::new().write(true).create_new(true).open(path)
+}
+
+/// Configuration for a set of nodes.
+#[derive(Clone, Debug)]
+pub struct SetConfig {
+	/// Maximum allowed number of incoming substreams related to this set.
+	pub in_peers: u32,
+
+	/// Number of outgoing substreams related to this set that we're trying to maintain.
+	pub out_peers: u32,
+
+	/// List of reserved node addresses.
+	pub reserved_nodes: Vec<MultiaddrWithPeerId>,
+
+	/// Whether nodes that aren't in [`SetConfig::reserved_nodes`] are accepted or automatically
+	/// refused.
+	pub non_reserved_mode: NonReservedPeerMode,
+}
+
+impl Default for SetConfig {
+	fn default() -> Self {
+		Self {
+			in_peers: 25,
+			out_peers: 75,
+			reserved_nodes: Vec::new(),
+			non_reserved_mode: NonReservedPeerMode::Accept,
+		}
+	}
+}
+
+/// Extension to [`SetConfig`] for sets that aren't the default set.
+///
+/// > **Note**: As new fields might be added in the future, please consider using the `new` method
+/// >			and modifiers instead of creating this struct manually.
+#[derive(Clone, Debug)]
+pub struct NonDefaultSetConfig {
+	/// Name of the notifications protocols of this set. A substream on this set will be
+	/// considered established once this protocol is open.
+	///
+	/// > **Note**: This field isn't present for the default set, as this is handled internally
+	/// > by the networking code.
+	pub notifications_protocol: ProtocolName,
+
+	/// If the remote reports that it doesn't support the protocol indicated in the
+	/// `notifications_protocol` field, then each of these fallback names will be tried one by
+	/// one.
+	///
+	/// If a fallback is used, it will be reported in
+	/// `sc_network::protocol::event::Event::NotificationStreamOpened::negotiated_fallback`
+	pub fallback_names: Vec<ProtocolName>,
+
+	/// Handshake of the protocol
+	///
+	/// NOTE: Currently custom handshakes are not fully supported. See issue #5685 for more
+	/// details. This field is temporarily used to allow moving the hardcoded block announcement
+	/// protocol out of `protocol.rs`.
+	pub handshake: Option<NotificationHandshake>,
+
+	/// Maximum allowed size of single notifications.
+	pub max_notification_size: u64,
+
+	/// Base configuration.
+	pub set_config: SetConfig,
+}
+
+impl NonDefaultSetConfig {
+	/// Creates a new [`NonDefaultSetConfig`]. Zero slots and accepts only reserved nodes.
+	pub fn new(notifications_protocol: ProtocolName, max_notification_size: u64) -> Self {
+		Self {
+			notifications_protocol,
+			max_notification_size,
+			fallback_names: Vec::new(),
+			handshake: None,
+			set_config: SetConfig {
+				in_peers: 0,
+				out_peers: 0,
+				reserved_nodes: Vec::new(),
+				non_reserved_mode: NonReservedPeerMode::Deny,
+			},
+		}
+	}
+
+	/// Modifies the configuration to allow non-reserved nodes.
+	pub fn allow_non_reserved(&mut self, in_peers: u32, out_peers: u32) {
+		self.set_config.in_peers = in_peers;
+		self.set_config.out_peers = out_peers;
+		self.set_config.non_reserved_mode = NonReservedPeerMode::Accept;
+	}
+
+	/// Add a node to the list of reserved nodes.
+	pub fn add_reserved(&mut self, peer: MultiaddrWithPeerId) {
+		self.set_config.reserved_nodes.push(peer);
+	}
+
+	/// Add a list of protocol names used for backward compatibility.
+	///
+	/// See the explanations in [`NonDefaultSetConfig::fallback_names`].
+	pub fn add_fallback_names(&mut self, fallback_names: Vec<ProtocolName>) {
+		self.fallback_names.extend(fallback_names);
+	}
+}
+
+/// Network service configuration.
+#[derive(Clone, Debug)]
+pub struct NetworkConfiguration {
+	/// Directory path to store network-specific configuration. None means nothing will be saved.
+	pub net_config_path: Option<PathBuf>,
+
+	/// Multiaddresses to listen for incoming connections.
+	pub listen_addresses: Vec<Multiaddr>,
+
+	/// Multiaddresses to advertise. Detected automatically if empty.
+	pub public_addresses: Vec<Multiaddr>,
+
+	/// List of initial node addresses
+	pub boot_nodes: Vec<MultiaddrWithPeerId>,
+
+	/// The node key configuration, which determines the node's network identity keypair.
+	pub node_key: NodeKeyConfig,
+
+	/// Configuration for the default set of nodes used for block syncing and transactions.
+	pub default_peers_set: SetConfig,
+
+	/// Number of substreams to reserve for full nodes for block syncing and transactions.
+	/// Any other slot will be dedicated to light nodes.
+	///
+	/// This value is implicitly capped to `default_set.out_peers + default_set.in_peers`.
+	pub default_peers_set_num_full: u32,
+
+	/// Client identifier. Sent over the wire for debugging purposes.
+	pub client_version: String,
+
+	/// Name of the node. Sent over the wire for debugging purposes.
+	pub node_name: String,
+
+	/// Configuration for the transport layer.
+	pub transport: TransportConfig,
+
+	/// Maximum number of peers to ask the same blocks in parallel.
+	pub max_parallel_downloads: u32,
+
+	/// Maximum number of blocks per request.
+	pub max_blocks_per_request: u32,
+
+	/// Initial syncing mode.
+	pub sync_mode: SyncMode,
+
+	/// True if Kademlia random discovery should be enabled.
+	///
+	/// If true, the node will automatically randomly walk the DHT in order to find new peers.
+	pub enable_dht_random_walk: bool,
+
+	/// Should we insert non-global addresses into the DHT?
+	pub allow_non_globals_in_dht: bool,
+
+	/// Require iterative Kademlia DHT queries to use disjoint paths for increased resiliency in
+	/// the presence of potentially adversarial nodes.
+	pub kademlia_disjoint_query_paths: bool,
+
+	/// Kademlia replication factor determines to how many closest peers a record is replicated to.
+	///
+	/// Discovery mechanism requires successful replication to all
+	/// `kademlia_replication_factor` peers to consider record successfully put.
+	pub kademlia_replication_factor: NonZeroUsize,
+
+	/// Enable serving block data over IPFS bitswap.
+	pub ipfs_server: bool,
+
+	/// Size of Yamux receive window of all substreams. `None` for the default (256kiB).
+	/// Any value less than 256kiB is invalid.
+	///
+	/// # Context
+	///
+	/// By design, notifications substreams on top of Yamux connections only allow up to `N` bytes
+	/// to be transferred at a time, where `N` is the Yamux receive window size configurable here.
+	/// This means, in practice, that every `N` bytes must be acknowledged by the receiver before
+	/// the sender can send more data. The maximum bandwidth of each notifications substream is
+	/// therefore `N / round_trip_time`.
+	///
+	/// It is recommended to leave this to `None`, and use a request-response protocol instead if
+	/// a large amount of data must be transferred. The reason why the value is configurable is
+	/// that some Substrate users mis-use notification protocols to send large amounts of data.
+	/// As such, this option isn't designed to stay and will likely get removed in the future.
+	///
+	/// Note that configuring a value here isn't a modification of the Yamux protocol, but rather
+	/// a modification of the way the implementation works. Different nodes with different
+	/// configured values remain compatible with each other.
+	pub yamux_window_size: Option<u32>,
+}
+
+impl NetworkConfiguration {
+	/// Create new default configuration
+	pub fn new<SN: Into<String>, SV: Into<String>>(
+		node_name: SN,
+		client_version: SV,
+		node_key: NodeKeyConfig,
+		net_config_path: Option<PathBuf>,
+	) -> Self {
+		let default_peers_set = SetConfig::default();
+		Self {
+			net_config_path,
+			listen_addresses: Vec::new(),
+			public_addresses: Vec::new(),
+			boot_nodes: Vec::new(),
+			node_key,
+			default_peers_set_num_full: default_peers_set.in_peers + default_peers_set.out_peers,
+			default_peers_set,
+			client_version: client_version.into(),
+			node_name: node_name.into(),
+			transport: TransportConfig::Normal { enable_mdns: false, allow_private_ip: true },
+			max_parallel_downloads: 5,
+			max_blocks_per_request: 64,
+			sync_mode: SyncMode::Full,
+			enable_dht_random_walk: true,
+			allow_non_globals_in_dht: false,
+			kademlia_disjoint_query_paths: false,
+			kademlia_replication_factor: NonZeroUsize::new(DEFAULT_KADEMLIA_REPLICATION_FACTOR)
+				.expect("value is a constant; constant is non-zero; qed."),
+			yamux_window_size: None,
+			ipfs_server: false,
+		}
+	}
+
+	/// Create new default configuration for localhost-only connection with random port (useful for
+	/// testing)
+	pub fn new_local() -> NetworkConfiguration {
+		let mut config =
+			NetworkConfiguration::new("test-node", "test-client", Default::default(), None);
+
+		config.listen_addresses =
+			vec![iter::once(multiaddr::Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)))
+				.chain(iter::once(multiaddr::Protocol::Tcp(0)))
+				.collect()];
+
+		config.allow_non_globals_in_dht = true;
+		config
+	}
+
+	/// Create new default configuration for localhost-only connection with random port (useful for
+	/// testing)
+	pub fn new_memory() -> NetworkConfiguration {
+		let mut config =
+			NetworkConfiguration::new("test-node", "test-client", Default::default(), None);
+
+		config.listen_addresses =
+			vec![iter::once(multiaddr::Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)))
+				.chain(iter::once(multiaddr::Protocol::Tcp(0)))
+				.collect()];
+
+		config.allow_non_globals_in_dht = true;
+		config
+	}
+}
+
+/// Network initialization parameters.
+pub struct Params<Block: BlockT> {
+	/// Assigned role for our node (full, light, ...).
+	pub role: Role,
+
+	/// How to spawn background tasks.
+	pub executor: Box<dyn Fn(Pin<Box<dyn Future<Output = ()> + Send>>) + Send>,
+
+	/// Network layer configuration.
+	pub network_config: FullNetworkConfiguration,
+
+	/// Peer store with known nodes, peer reputations, etc.
+	pub peer_store: PeerStoreHandle,
+
+	/// Legacy name of the protocol to use on the wire. Should be different for each chain.
+	pub protocol_id: ProtocolId,
+
+	/// Genesis hash of the chain
+	pub genesis_hash: Block::Hash,
+
+	/// Fork ID to distinguish protocols of different hard forks. Part of the standard protocol
+	/// name on the wire.
+	pub fork_id: Option<String>,
+
+	/// Registry for recording prometheus metrics to.
+	pub metrics_registry: Option<Registry>,
+
+	/// Block announce protocol configuration
+	pub block_announce_config: NonDefaultSetConfig,
+
+	/// TX channel for direct communication with `SyncingEngine` and `Protocol`.
+	pub tx: TracingUnboundedSender<crate::event::SyncEvent<Block>>,
+}
+
+/// Full network configuration.
+pub struct FullNetworkConfiguration {
+	/// Installed notification protocols.
+	pub(crate) notification_protocols: Vec<NonDefaultSetConfig>,
+
+	/// List of request-response protocols that the node supports.
+	pub(crate) request_response_protocols: Vec<RequestResponseConfig>,
+
+	/// Network configuration.
+	pub network_config: NetworkConfiguration,
+}
+
+impl FullNetworkConfiguration {
+	/// Create new [`FullNetworkConfiguration`].
+	pub fn new(network_config: &NetworkConfiguration) -> Self {
+		Self {
+			notification_protocols: Vec::new(),
+			request_response_protocols: Vec::new(),
+			network_config: network_config.clone(),
+		}
+	}
+
+	/// Add a notification protocol.
+	pub fn add_notification_protocol(&mut self, config: NonDefaultSetConfig) {
+		self.notification_protocols.push(config);
+	}
+
+	/// Get reference to installed notification protocols.
+	pub fn notification_protocols(&self) -> &Vec<NonDefaultSetConfig> {
+		&self.notification_protocols
+	}
+
+	/// Add a request-response protocol.
+	pub fn add_request_response_protocol(&mut self, config: RequestResponseConfig) {
+		self.request_response_protocols.push(config);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use tempfile::TempDir;
+
+	fn tempdir_with_prefix(prefix: &str) -> TempDir {
+		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()
+	}
+
+	#[test]
+	fn test_secret_file() {
+		let tmp = tempdir_with_prefix("x");
+		std::fs::remove_dir(tmp.path()).unwrap(); // should be recreated
+		let file = tmp.path().join("x").to_path_buf();
+		let kp1 = NodeKeyConfig::Ed25519(Secret::File(file.clone())).into_keypair().unwrap();
+		let kp2 = NodeKeyConfig::Ed25519(Secret::File(file.clone())).into_keypair().unwrap();
+		assert!(file.is_file() && secret_bytes(kp1) == secret_bytes(kp2))
+	}
+
+	#[test]
+	fn test_secret_input() {
+		let sk = ed25519::SecretKey::generate();
+		let kp1 = NodeKeyConfig::Ed25519(Secret::Input(sk.clone())).into_keypair().unwrap();
+		let kp2 = NodeKeyConfig::Ed25519(Secret::Input(sk)).into_keypair().unwrap();
+		assert!(secret_bytes(kp1) == secret_bytes(kp2));
+	}
+
+	#[test]
+	fn test_secret_new() {
+		let kp1 = NodeKeyConfig::Ed25519(Secret::New).into_keypair().unwrap();
+		let kp2 = NodeKeyConfig::Ed25519(Secret::New).into_keypair().unwrap();
+		assert!(secret_bytes(kp1) != secret_bytes(kp2));
+	}
+}
diff --git a/substrate/client/network/src/discovery.rs b/substrate/client/network/src/discovery.rs
new file mode 100644
index 0000000000000000000000000000000000000000..77c26266aac4691cf36b440e6d06c792e57a311e
--- /dev/null
+++ b/substrate/client/network/src/discovery.rs
@@ -0,0 +1,1190 @@
+// 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/>.
+
+//! Discovery mechanisms of Substrate.
+//!
+//! The `DiscoveryBehaviour` struct implements the `NetworkBehaviour` trait of libp2p and is
+//! responsible for discovering other nodes that are part of the network.
+//!
+//! Substrate uses the following mechanisms in order to discover nodes that are part of the network:
+//!
+//! - Bootstrap nodes. These are hard-coded node identities and addresses passed in the constructor
+//! of the `DiscoveryBehaviour`. You can also call `add_known_address` later to add an entry.
+//!
+//! - mDNS. Discovers nodes on the local network by broadcasting UDP packets.
+//!
+//! - Kademlia random walk. Once connected, we perform random Kademlia `FIND_NODE` requests on the
+//! configured Kademlia DHTs in order for nodes to propagate to us their view of the network. This
+//! is performed automatically by the `DiscoveryBehaviour`.
+//!
+//! Additionally, the `DiscoveryBehaviour` is also capable of storing and loading value in the
+//! configured DHTs.
+//!
+//! ## Usage
+//!
+//! The `DiscoveryBehaviour` generates events of type `DiscoveryOut`, most notably
+//! `DiscoveryOut::Discovered` that is generated whenever we discover a node.
+//! Only the identity of the node is returned. The node's addresses are stored within the
+//! `DiscoveryBehaviour` and can be queried through the `NetworkBehaviour` trait.
+//!
+//! **Important**: In order for the discovery mechanism to work properly, there needs to be an
+//! active mechanism that asks nodes for the addresses they are listening on. Whenever we learn
+//! of a node's address, you must call `add_self_reported_address`.
+
+use crate::{config::ProtocolId, utils::LruHashSet};
+
+use array_bytes::bytes2hex;
+use futures::prelude::*;
+use futures_timer::Delay;
+use ip_network::IpNetwork;
+use libp2p::{
+	core::{Endpoint, Multiaddr},
+	kad::{
+		handler::KademliaHandler,
+		record::store::{MemoryStore, RecordStore},
+		GetClosestPeersError, GetRecordOk, Kademlia, KademliaBucketInserts, KademliaConfig,
+		KademliaEvent, QueryId, QueryResult, Quorum, Record, RecordKey,
+	},
+	mdns::{self, tokio::Behaviour as TokioMdns},
+	multiaddr::Protocol,
+	swarm::{
+		behaviour::{
+			toggle::{Toggle, ToggleConnectionHandler},
+			DialFailure, FromSwarm, NewExternalAddr,
+		},
+		ConnectionDenied, ConnectionId, DialError, NetworkBehaviour, PollParameters, THandler,
+		THandlerInEvent, THandlerOutEvent, ToSwarm,
+	},
+	PeerId,
+};
+use log::{debug, info, trace, warn};
+use sp_core::hexdisplay::HexDisplay;
+use std::{
+	cmp,
+	collections::{hash_map::Entry, HashMap, HashSet, VecDeque},
+	num::NonZeroUsize,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+/// Maximum number of known external addresses that we will cache.
+/// This only affects whether we will log whenever we (re-)discover
+/// a given address.
+const MAX_KNOWN_EXTERNAL_ADDRESSES: usize = 32;
+
+/// Default value for Kademlia replication factor which  determines to how many closest peers a
+/// record is replicated to.
+pub const DEFAULT_KADEMLIA_REPLICATION_FACTOR: usize = 20;
+
+/// `DiscoveryBehaviour` configuration.
+///
+/// Note: In order to discover nodes or load and store values via Kademlia one has to add
+///       Kademlia protocol via [`DiscoveryConfig::with_kademlia`].
+pub struct DiscoveryConfig {
+	local_peer_id: PeerId,
+	permanent_addresses: Vec<(PeerId, Multiaddr)>,
+	dht_random_walk: bool,
+	allow_private_ip: bool,
+	allow_non_globals_in_dht: bool,
+	discovery_only_if_under_num: u64,
+	enable_mdns: bool,
+	kademlia_disjoint_query_paths: bool,
+	kademlia_protocols: Vec<Vec<u8>>,
+	kademlia_replication_factor: NonZeroUsize,
+}
+
+impl DiscoveryConfig {
+	/// Create a default configuration with the given public key.
+	pub fn new(local_peer_id: PeerId) -> Self {
+		Self {
+			local_peer_id,
+			permanent_addresses: Vec::new(),
+			dht_random_walk: true,
+			allow_private_ip: true,
+			allow_non_globals_in_dht: false,
+			discovery_only_if_under_num: std::u64::MAX,
+			enable_mdns: false,
+			kademlia_disjoint_query_paths: false,
+			kademlia_protocols: Vec::new(),
+			kademlia_replication_factor: NonZeroUsize::new(DEFAULT_KADEMLIA_REPLICATION_FACTOR)
+				.expect("value is a constant; constant is non-zero; qed."),
+		}
+	}
+
+	/// Set the number of active connections at which we pause discovery.
+	pub fn discovery_limit(&mut self, limit: u64) -> &mut Self {
+		self.discovery_only_if_under_num = limit;
+		self
+	}
+
+	/// Set custom nodes which never expire, e.g. bootstrap or reserved nodes.
+	pub fn with_permanent_addresses<I>(&mut self, permanent_addresses: I) -> &mut Self
+	where
+		I: IntoIterator<Item = (PeerId, Multiaddr)>,
+	{
+		self.permanent_addresses.extend(permanent_addresses);
+		self
+	}
+
+	/// Whether the discovery behaviour should periodically perform a random
+	/// walk on the DHT to discover peers.
+	pub fn with_dht_random_walk(&mut self, value: bool) -> &mut Self {
+		self.dht_random_walk = value;
+		self
+	}
+
+	/// Should private IPv4/IPv6 addresses be reported?
+	pub fn allow_private_ip(&mut self, value: bool) -> &mut Self {
+		self.allow_private_ip = value;
+		self
+	}
+
+	/// Should non-global addresses be inserted to the DHT?
+	pub fn allow_non_globals_in_dht(&mut self, value: bool) -> &mut Self {
+		self.allow_non_globals_in_dht = value;
+		self
+	}
+
+	/// Should MDNS discovery be supported?
+	pub fn with_mdns(&mut self, value: bool) -> &mut Self {
+		self.enable_mdns = value;
+		self
+	}
+
+	/// Add discovery via Kademlia for the given protocol.
+	///
+	/// Currently accepts `protocol_id`. This should be removed once all the nodes
+	/// are upgraded to genesis hash- and fork ID-based Kademlia protocol name.
+	pub fn with_kademlia<Hash: AsRef<[u8]>>(
+		&mut self,
+		genesis_hash: Hash,
+		fork_id: Option<&str>,
+		protocol_id: &ProtocolId,
+	) -> &mut Self {
+		self.kademlia_protocols = Vec::new();
+		self.kademlia_protocols.push(kademlia_protocol_name(genesis_hash, fork_id));
+		self.kademlia_protocols.push(legacy_kademlia_protocol_name(protocol_id));
+		self
+	}
+
+	/// Require iterative Kademlia DHT queries to use disjoint paths for increased resiliency in the
+	/// presence of potentially adversarial nodes.
+	pub fn use_kademlia_disjoint_query_paths(&mut self, value: bool) -> &mut Self {
+		self.kademlia_disjoint_query_paths = value;
+		self
+	}
+
+	/// Sets Kademlia replication factor.
+	pub fn with_kademlia_replication_factor(&mut self, value: NonZeroUsize) -> &mut Self {
+		self.kademlia_replication_factor = value;
+		self
+	}
+
+	/// Create a `DiscoveryBehaviour` from this config.
+	pub fn finish(self) -> DiscoveryBehaviour {
+		let Self {
+			local_peer_id,
+			permanent_addresses,
+			dht_random_walk,
+			allow_private_ip,
+			allow_non_globals_in_dht,
+			discovery_only_if_under_num,
+			enable_mdns,
+			kademlia_disjoint_query_paths,
+			kademlia_protocols,
+			kademlia_replication_factor,
+		} = self;
+
+		let kademlia = if !kademlia_protocols.is_empty() {
+			let mut config = KademliaConfig::default();
+
+			config.set_replication_factor(kademlia_replication_factor);
+			config.set_protocol_names(kademlia_protocols.into_iter().map(Into::into).collect());
+			// 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.
+			config.set_kbucket_inserts(KademliaBucketInserts::Manual);
+			config.disjoint_query_paths(kademlia_disjoint_query_paths);
+
+			let store = MemoryStore::new(local_peer_id);
+			let mut kad = Kademlia::with_config(local_peer_id, store, config);
+
+			for (peer_id, addr) in &permanent_addresses {
+				kad.add_address(peer_id, addr.clone());
+			}
+
+			Some(kad)
+		} else {
+			None
+		};
+
+		DiscoveryBehaviour {
+			permanent_addresses,
+			ephemeral_addresses: HashMap::new(),
+			kademlia: Toggle::from(kademlia),
+			next_kad_random_query: if dht_random_walk {
+				Some(Delay::new(Duration::new(0, 0)))
+			} else {
+				None
+			},
+			duration_to_next_kad: Duration::from_secs(1),
+			pending_events: VecDeque::new(),
+			local_peer_id,
+			num_connections: 0,
+			allow_private_ip,
+			discovery_only_if_under_num,
+			mdns: if enable_mdns {
+				match TokioMdns::new(mdns::Config::default(), local_peer_id) {
+					Ok(mdns) => Toggle::from(Some(mdns)),
+					Err(err) => {
+						warn!(target: "sub-libp2p", "Failed to initialize mDNS: {:?}", err);
+						Toggle::from(None)
+					},
+				}
+			} else {
+				Toggle::from(None)
+			},
+			allow_non_globals_in_dht,
+			known_external_addresses: LruHashSet::new(
+				NonZeroUsize::new(MAX_KNOWN_EXTERNAL_ADDRESSES)
+					.expect("value is a constant; constant is non-zero; qed."),
+			),
+			records_to_publish: Default::default(),
+		}
+	}
+}
+
+/// Implementation of `NetworkBehaviour` that discovers the nodes on the network.
+pub struct DiscoveryBehaviour {
+	/// User-defined list of nodes and their addresses. Typically includes bootstrap nodes and
+	/// reserved nodes.
+	permanent_addresses: Vec<(PeerId, Multiaddr)>,
+	/// Same as `permanent_addresses`, except that addresses that fail to reach a peer are
+	/// removed.
+	ephemeral_addresses: HashMap<PeerId, Vec<Multiaddr>>,
+	/// Kademlia requests and answers. Even though it's wrapped in `Toggle`, currently
+	/// it's always enabled in `NetworkWorker::new()`.
+	kademlia: Toggle<Kademlia<MemoryStore>>,
+	/// Discovers nodes on the local network.
+	mdns: Toggle<TokioMdns>,
+	/// Stream that fires when we need to perform the next random Kademlia query. `None` if
+	/// random walking is disabled.
+	next_kad_random_query: Option<Delay>,
+	/// After `next_kad_random_query` triggers, the next one triggers after this duration.
+	duration_to_next_kad: Duration,
+	/// Events to return in priority when polled.
+	pending_events: VecDeque<DiscoveryOut>,
+	/// Identity of our local node.
+	local_peer_id: PeerId,
+	/// Number of nodes we're currently connected to.
+	num_connections: u64,
+	/// If false, `addresses_of_peer` won't return any private IPv4/IPv6 address, except for the
+	/// ones stored in `permanent_addresses` or `ephemeral_addresses`.
+	allow_private_ip: bool,
+	/// Number of active connections over which we interrupt the discovery process.
+	discovery_only_if_under_num: u64,
+	/// Should non-global addresses be added to the DHT?
+	allow_non_globals_in_dht: bool,
+	/// A cache of discovered external addresses. Only used for logging purposes.
+	known_external_addresses: LruHashSet<Multiaddr>,
+	/// Records to publish per QueryId.
+	///
+	/// After finishing a Kademlia query, libp2p will return us a list of the closest peers that
+	/// did not return the record(in `FinishedWithNoAdditionalRecord`). We will then put the record
+	/// to these peers.
+	records_to_publish: HashMap<QueryId, Record>,
+}
+
+impl DiscoveryBehaviour {
+	/// Returns the list of nodes that we know exist in the network.
+	pub fn known_peers(&mut self) -> HashSet<PeerId> {
+		let mut peers = HashSet::new();
+		if let Some(k) = self.kademlia.as_mut() {
+			for b in k.kbuckets() {
+				for e in b.iter() {
+					if !peers.contains(e.node.key.preimage()) {
+						peers.insert(*e.node.key.preimage());
+					}
+				}
+			}
+		}
+		peers
+	}
+
+	/// Adds a hard-coded address for the given peer, that never expires.
+	///
+	/// This adds an entry to the parameter that was passed to `new`.
+	///
+	/// If we didn't know this address before, also generates a `Discovered` event.
+	pub fn add_known_address(&mut self, peer_id: PeerId, addr: Multiaddr) {
+		let addrs_list = self.ephemeral_addresses.entry(peer_id).or_default();
+		if addrs_list.contains(&addr) {
+			return
+		}
+
+		if let Some(k) = self.kademlia.as_mut() {
+			k.add_address(&peer_id, addr.clone());
+		}
+
+		self.pending_events.push_back(DiscoveryOut::Discovered(peer_id));
+		addrs_list.push(addr);
+	}
+
+	/// Add a self-reported address of a remote peer to the k-buckets of the DHT
+	/// if it has compatible `supported_protocols`.
+	///
+	/// **Note**: It is important that you call this method. The discovery mechanism will not
+	/// automatically add connecting peers to the Kademlia k-buckets.
+	pub fn add_self_reported_address(
+		&mut self,
+		peer_id: &PeerId,
+		supported_protocols: &[impl AsRef<[u8]>],
+		addr: Multiaddr,
+	) {
+		if let Some(kademlia) = self.kademlia.as_mut() {
+			if !self.allow_non_globals_in_dht && !Self::can_add_to_dht(&addr) {
+				trace!(
+					target: "sub-libp2p",
+					"Ignoring self-reported non-global address {} from {}.", addr, peer_id
+				);
+				return
+			}
+
+			if let Some(matching_protocol) = supported_protocols
+				.iter()
+				.find(|p| kademlia.protocol_names().iter().any(|k| k.as_ref() == p.as_ref()))
+			{
+				trace!(
+					target: "sub-libp2p",
+					"Adding self-reported address {} from {} to Kademlia DHT {}.",
+					addr, peer_id, String::from_utf8_lossy(matching_protocol.as_ref()),
+				);
+				kademlia.add_address(peer_id, addr.clone());
+			} else {
+				trace!(
+					target: "sub-libp2p",
+					"Ignoring self-reported address {} from {} as remote node is not part of the \
+					 Kademlia DHT supported by the local node.", addr, peer_id,
+				);
+			}
+		}
+	}
+
+	/// Start fetching a record from the DHT.
+	///
+	/// A corresponding `ValueFound` or `ValueNotFound` event will later be generated.
+	pub fn get_value(&mut self, key: RecordKey) {
+		if let Some(k) = self.kademlia.as_mut() {
+			k.get_record(key.clone());
+		}
+	}
+
+	/// Start putting a record into the DHT. Other nodes can later fetch that value with
+	/// `get_value`.
+	///
+	/// A corresponding `ValuePut` or `ValuePutFailed` event will later be generated.
+	pub fn put_value(&mut self, key: RecordKey, value: Vec<u8>) {
+		if let Some(k) = self.kademlia.as_mut() {
+			if let Err(e) = k.put_record(Record::new(key.clone(), value.clone()), Quorum::All) {
+				warn!(target: "sub-libp2p", "Libp2p => Failed to put record: {:?}", e);
+				self.pending_events
+					.push_back(DiscoveryOut::ValuePutFailed(key.clone(), Duration::from_secs(0)));
+			}
+		}
+	}
+
+	/// 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
+	/// of their lower bound.
+	pub fn num_entries_per_kbucket(&mut self) -> Option<Vec<(u32, usize)>> {
+		self.kademlia.as_mut().map(|kad| {
+			kad.kbuckets()
+				.map(|bucket| (bucket.range().0.ilog2().unwrap_or(0), bucket.iter().count()))
+				.collect()
+		})
+	}
+
+	/// Returns the number of records in the Kademlia record stores.
+	pub fn num_kademlia_records(&mut self) -> Option<usize> {
+		// Note that this code is ok only because we use a `MemoryStore`.
+		self.kademlia.as_mut().map(|kad| kad.store_mut().records().count())
+	}
+
+	/// Returns the total size in bytes of all the records in the Kademlia record stores.
+	pub fn kademlia_records_total_size(&mut self) -> Option<usize> {
+		// Note that this code is ok only because we use a `MemoryStore`. If the records were
+		// for example stored on disk, this would load every single one of them every single time.
+		self.kademlia
+			.as_mut()
+			.map(|kad| kad.store_mut().records().fold(0, |tot, rec| tot + rec.value.len()))
+	}
+
+	/// Can the given `Multiaddr` be put into the DHT?
+	///
+	/// This test is successful only for global IP addresses and DNS names.
+	// NB: Currently all DNS names are allowed and no check for TLD suffixes is done
+	// because the set of valid domains is highly dynamic and would require frequent
+	// updates, for example by utilising publicsuffix.org or IANA.
+	pub fn can_add_to_dht(addr: &Multiaddr) -> bool {
+		let ip = match addr.iter().next() {
+			Some(Protocol::Ip4(ip)) => IpNetwork::from(ip),
+			Some(Protocol::Ip6(ip)) => IpNetwork::from(ip),
+			Some(Protocol::Dns(_)) | Some(Protocol::Dns4(_)) | Some(Protocol::Dns6(_)) =>
+				return true,
+			_ => return false,
+		};
+		ip.is_global()
+	}
+}
+
+/// Event generated by the `DiscoveryBehaviour`.
+#[derive(Debug)]
+pub enum DiscoveryOut {
+	/// A connection to a peer has been established but the peer has not been
+	/// added to the routing table because [`KademliaBucketInserts::Manual`] is
+	/// configured. If the peer is to be included in the routing table, it must
+	/// be explicitly added via
+	/// [`DiscoveryBehaviour::add_self_reported_address`].
+	Discovered(PeerId),
+
+	/// A peer connected to this node for whom no listen address is known.
+	///
+	/// In order for the peer to be added to the Kademlia routing table, a known
+	/// listen address must be added via
+	/// [`DiscoveryBehaviour::add_self_reported_address`], e.g. obtained through
+	/// the `identify` protocol.
+	UnroutablePeer(PeerId),
+
+	/// The DHT yielded results for the record request.
+	///
+	/// Returning the result grouped in (key, value) pairs as well as the request duration.
+	ValueFound(Vec<(RecordKey, Vec<u8>)>, Duration),
+
+	/// The record requested was not found in the DHT.
+	///
+	/// Returning the corresponding key as well as the request duration.
+	ValueNotFound(RecordKey, Duration),
+
+	/// The record with a given key was successfully inserted into the DHT.
+	///
+	/// Returning the corresponding key as well as the request duration.
+	ValuePut(RecordKey, Duration),
+
+	/// Inserting a value into the DHT failed.
+	///
+	/// Returning the corresponding key as well as the request duration.
+	ValuePutFailed(RecordKey, Duration),
+
+	/// Started a random Kademlia query.
+	///
+	/// Only happens if [`DiscoveryConfig::with_dht_random_walk`] has been configured to `true`.
+	RandomKademliaStarted,
+}
+
+impl NetworkBehaviour for DiscoveryBehaviour {
+	type ConnectionHandler = ToggleConnectionHandler<KademliaHandler<QueryId>>;
+	type OutEvent = DiscoveryOut;
+
+	fn handle_established_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		self.kademlia.handle_established_inbound_connection(
+			connection_id,
+			peer,
+			local_addr,
+			remote_addr,
+		)
+	}
+
+	fn handle_established_outbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		addr: &Multiaddr,
+		role_override: Endpoint,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		self.kademlia.handle_established_outbound_connection(
+			connection_id,
+			peer,
+			addr,
+			role_override,
+		)
+	}
+
+	fn handle_pending_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<(), ConnectionDenied> {
+		self.kademlia
+			.handle_pending_inbound_connection(connection_id, local_addr, remote_addr)
+	}
+
+	fn handle_pending_outbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		maybe_peer: Option<PeerId>,
+		addresses: &[Multiaddr],
+		effective_role: Endpoint,
+	) -> Result<Vec<Multiaddr>, ConnectionDenied> {
+		let Some(peer_id) = maybe_peer else { return Ok(Vec::new()) };
+
+		let mut list = self
+			.permanent_addresses
+			.iter()
+			.filter_map(|(p, a)| (*p == peer_id).then_some(a.clone()))
+			.collect::<Vec<_>>();
+
+		if let Some(ephemeral_addresses) = self.ephemeral_addresses.get(&peer_id) {
+			list.extend(ephemeral_addresses.clone());
+		}
+
+		{
+			let mut list_to_filter = self.kademlia.handle_pending_outbound_connection(
+				connection_id,
+				maybe_peer,
+				addresses,
+				effective_role,
+			)?;
+
+			list_to_filter.extend(self.mdns.handle_pending_outbound_connection(
+				connection_id,
+				maybe_peer,
+				addresses,
+				effective_role,
+			)?);
+
+			if !self.allow_private_ip {
+				list_to_filter.retain(|addr| match addr.iter().next() {
+					Some(Protocol::Ip4(addr)) if !IpNetwork::from(addr).is_global() => false,
+					Some(Protocol::Ip6(addr)) if !IpNetwork::from(addr).is_global() => false,
+					_ => true,
+				});
+			}
+
+			list.extend(list_to_filter);
+		}
+
+		trace!(target: "sub-libp2p", "Addresses of {:?}: {:?}", peer_id, list);
+
+		Ok(list)
+	}
+
+	fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+		match event {
+			FromSwarm::ConnectionEstablished(e) => {
+				self.num_connections += 1;
+				self.kademlia.on_swarm_event(FromSwarm::ConnectionEstablished(e));
+			},
+			FromSwarm::ConnectionClosed(e) => {
+				self.num_connections -= 1;
+				self.kademlia.on_swarm_event(FromSwarm::ConnectionClosed(e));
+			},
+			FromSwarm::DialFailure(e @ DialFailure { peer_id, error, .. }) => {
+				if let Some(peer_id) = peer_id {
+					if let DialError::Transport(errors) = error {
+						if let Entry::Occupied(mut entry) = self.ephemeral_addresses.entry(peer_id)
+						{
+							for (addr, _error) in errors {
+								entry.get_mut().retain(|a| a != addr);
+							}
+							if entry.get().is_empty() {
+								entry.remove();
+							}
+						}
+					}
+				}
+
+				self.kademlia.on_swarm_event(FromSwarm::DialFailure(e));
+			},
+			FromSwarm::ListenerClosed(e) => {
+				self.kademlia.on_swarm_event(FromSwarm::ListenerClosed(e));
+			},
+			FromSwarm::ListenFailure(e) => {
+				self.kademlia.on_swarm_event(FromSwarm::ListenFailure(e));
+			},
+			FromSwarm::ListenerError(e) => {
+				self.kademlia.on_swarm_event(FromSwarm::ListenerError(e));
+			},
+			FromSwarm::ExpiredExternalAddr(e) => {
+				// We intentionally don't remove the element from `known_external_addresses` in
+				// order to not print the log line again.
+
+				self.kademlia.on_swarm_event(FromSwarm::ExpiredExternalAddr(e));
+			},
+			FromSwarm::NewListener(e) => {
+				self.kademlia.on_swarm_event(FromSwarm::NewListener(e));
+			},
+			FromSwarm::ExpiredListenAddr(e) => {
+				self.kademlia.on_swarm_event(FromSwarm::ExpiredListenAddr(e));
+			},
+			FromSwarm::NewExternalAddr(e @ NewExternalAddr { addr }) => {
+				let new_addr = addr.clone().with(Protocol::P2p(self.local_peer_id.into()));
+
+				if Self::can_add_to_dht(addr) {
+					// NOTE: we might re-discover the same address multiple times
+					// in which case we just want to refrain from logging.
+					if self.known_external_addresses.insert(new_addr.clone()) {
+						info!(
+						  target: "sub-libp2p",
+						  "� Discovered new external address for our node: {}",
+						  new_addr,
+						);
+					}
+				}
+
+				self.kademlia.on_swarm_event(FromSwarm::NewExternalAddr(e));
+			},
+			FromSwarm::AddressChange(e) => {
+				self.kademlia.on_swarm_event(FromSwarm::AddressChange(e));
+			},
+			FromSwarm::NewListenAddr(e) => {
+				self.kademlia.on_swarm_event(FromSwarm::NewListenAddr(e));
+				self.mdns.on_swarm_event(FromSwarm::NewListenAddr(e));
+			},
+		}
+	}
+
+	fn on_connection_handler_event(
+		&mut self,
+		peer_id: PeerId,
+		connection_id: ConnectionId,
+		event: THandlerOutEvent<Self>,
+	) {
+		self.kademlia.on_connection_handler_event(peer_id, connection_id, event);
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut Context,
+		params: &mut impl PollParameters,
+	) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
+		// Immediately process the content of `discovered`.
+		if let Some(ev) = self.pending_events.pop_front() {
+			return Poll::Ready(ToSwarm::GenerateEvent(ev))
+		}
+
+		// Poll the stream that fires when we need to start a random Kademlia query.
+		if let Some(kademlia) = self.kademlia.as_mut() {
+			if let Some(next_kad_random_query) = self.next_kad_random_query.as_mut() {
+				while next_kad_random_query.poll_unpin(cx).is_ready() {
+					let actually_started =
+						if self.num_connections < self.discovery_only_if_under_num {
+							let random_peer_id = PeerId::random();
+							debug!(
+								target: "sub-libp2p",
+								"Libp2p <= Starting random Kademlia request for {:?}",
+								random_peer_id,
+							);
+							kademlia.get_closest_peers(random_peer_id);
+							true
+						} else {
+							debug!(
+								target: "sub-libp2p",
+								"Kademlia paused due to high number of connections ({})",
+								self.num_connections
+							);
+							false
+						};
+
+					// Schedule the next random query with exponentially increasing delay,
+					// capped at 60 seconds.
+					*next_kad_random_query = Delay::new(self.duration_to_next_kad);
+					self.duration_to_next_kad =
+						cmp::min(self.duration_to_next_kad * 2, Duration::from_secs(60));
+
+					if actually_started {
+						let ev = DiscoveryOut::RandomKademliaStarted;
+						return Poll::Ready(ToSwarm::GenerateEvent(ev))
+					}
+				}
+			}
+		}
+
+		while let Poll::Ready(ev) = self.kademlia.poll(cx, params) {
+			match ev {
+				ToSwarm::GenerateEvent(ev) => match ev {
+					KademliaEvent::RoutingUpdated { peer, .. } => {
+						let ev = DiscoveryOut::Discovered(peer);
+						return Poll::Ready(ToSwarm::GenerateEvent(ev))
+					},
+					KademliaEvent::UnroutablePeer { peer, .. } => {
+						let ev = DiscoveryOut::UnroutablePeer(peer);
+						return Poll::Ready(ToSwarm::GenerateEvent(ev))
+					},
+					KademliaEvent::RoutablePeer { peer, .. } => {
+						let ev = DiscoveryOut::Discovered(peer);
+						return Poll::Ready(ToSwarm::GenerateEvent(ev))
+					},
+					KademliaEvent::PendingRoutablePeer { .. } |
+					KademliaEvent::InboundRequest { .. } => {
+						// We are not interested in this event at the moment.
+					},
+					KademliaEvent::OutboundQueryProgressed {
+						result: QueryResult::GetClosestPeers(res),
+						..
+					} => match res {
+						Err(GetClosestPeersError::Timeout { key, peers }) => {
+							debug!(
+								target: "sub-libp2p",
+								"Libp2p => Query for {:?} timed out with {} results",
+								HexDisplay::from(&key), peers.len(),
+							);
+						},
+						Ok(ok) => {
+							trace!(
+								target: "sub-libp2p",
+								"Libp2p => Query for {:?} yielded {:?} results",
+								HexDisplay::from(&ok.key), ok.peers.len(),
+							);
+							if ok.peers.is_empty() && self.num_connections != 0 {
+								debug!(
+									target: "sub-libp2p",
+									"Libp2p => Random Kademlia query has yielded empty results",
+								);
+							}
+						},
+					},
+					KademliaEvent::OutboundQueryProgressed {
+						result: QueryResult::GetRecord(res),
+						stats,
+						id,
+						..
+					} => {
+						let ev = match res {
+							Ok(GetRecordOk::FoundRecord(r)) => {
+								debug!(
+									target: "sub-libp2p",
+									"Libp2p => Found record ({:?}) with value: {:?}",
+									r.record.key,
+									r.record.value,
+								);
+
+								// Let's directly finish the query, as we are only interested in a
+								// quorum of 1.
+								if let Some(kad) = self.kademlia.as_mut() {
+									if let Some(mut query) = kad.query_mut(&id) {
+										query.finish();
+									}
+								}
+
+								// Will be removed below when we receive
+								// `FinishedWithNoAdditionalRecord`.
+								self.records_to_publish.insert(id, r.record.clone());
+
+								DiscoveryOut::ValueFound(
+									vec![(r.record.key, r.record.value)],
+									stats.duration().unwrap_or_default(),
+								)
+							},
+							Ok(GetRecordOk::FinishedWithNoAdditionalRecord {
+								cache_candidates,
+							}) => {
+								// We always need to remove the record to not leak any data!
+								if let Some(record) = self.records_to_publish.remove(&id) {
+									if cache_candidates.is_empty() {
+										continue
+									}
+
+									// Put the record to the `cache_candidates` that are nearest to
+									// the record key from our point of view of the network.
+									if let Some(kad) = self.kademlia.as_mut() {
+										kad.put_record_to(
+											record,
+											cache_candidates.into_iter().map(|v| v.1),
+											Quorum::One,
+										);
+									}
+								}
+
+								continue
+							},
+							Err(e @ libp2p::kad::GetRecordError::NotFound { .. }) => {
+								trace!(
+									target: "sub-libp2p",
+									"Libp2p => Failed to get record: {:?}",
+									e,
+								);
+								DiscoveryOut::ValueNotFound(
+									e.into_key(),
+									stats.duration().unwrap_or_default(),
+								)
+							},
+							Err(e) => {
+								debug!(
+									target: "sub-libp2p",
+									"Libp2p => Failed to get record: {:?}",
+									e,
+								);
+								DiscoveryOut::ValueNotFound(
+									e.into_key(),
+									stats.duration().unwrap_or_default(),
+								)
+							},
+						};
+						return Poll::Ready(ToSwarm::GenerateEvent(ev))
+					},
+					KademliaEvent::OutboundQueryProgressed {
+						result: QueryResult::PutRecord(res),
+						stats,
+						..
+					} => {
+						let ev = match res {
+							Ok(ok) =>
+								DiscoveryOut::ValuePut(ok.key, stats.duration().unwrap_or_default()),
+							Err(e) => {
+								debug!(
+									target: "sub-libp2p",
+									"Libp2p => Failed to put record: {:?}",
+									e,
+								);
+								DiscoveryOut::ValuePutFailed(
+									e.into_key(),
+									stats.duration().unwrap_or_default(),
+								)
+							},
+						};
+						return Poll::Ready(ToSwarm::GenerateEvent(ev))
+					},
+					KademliaEvent::OutboundQueryProgressed {
+						result: QueryResult::RepublishRecord(res),
+						..
+					} => match res {
+						Ok(ok) => debug!(
+							target: "sub-libp2p",
+							"Libp2p => Record republished: {:?}",
+							ok.key,
+						),
+						Err(e) => debug!(
+							target: "sub-libp2p",
+							"Libp2p => Republishing of record {:?} failed with: {:?}",
+							e.key(), e,
+						),
+					},
+					// We never start any other type of query.
+					KademliaEvent::OutboundQueryProgressed { result: e, .. } => {
+						warn!(target: "sub-libp2p", "Libp2p => Unhandled Kademlia event: {:?}", e)
+					},
+				},
+				ToSwarm::Dial { opts } => return Poll::Ready(ToSwarm::Dial { opts }),
+				ToSwarm::NotifyHandler { peer_id, handler, event } =>
+					return Poll::Ready(ToSwarm::NotifyHandler { peer_id, handler, event }),
+				ToSwarm::ReportObservedAddr { address, score } =>
+					return Poll::Ready(ToSwarm::ReportObservedAddr { address, score }),
+				ToSwarm::CloseConnection { peer_id, connection } =>
+					return Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }),
+			}
+		}
+
+		// Poll mDNS.
+		while let Poll::Ready(ev) = self.mdns.poll(cx, params) {
+			match ev {
+				ToSwarm::GenerateEvent(event) => match event {
+					mdns::Event::Discovered(list) => {
+						if self.num_connections >= self.discovery_only_if_under_num {
+							continue
+						}
+
+						self.pending_events
+							.extend(list.map(|(peer_id, _)| DiscoveryOut::Discovered(peer_id)));
+						if let Some(ev) = self.pending_events.pop_front() {
+							return Poll::Ready(ToSwarm::GenerateEvent(ev))
+						}
+					},
+					mdns::Event::Expired(_) => {},
+				},
+				ToSwarm::Dial { .. } => {
+					unreachable!("mDNS never dials!");
+				},
+				ToSwarm::NotifyHandler { event, .. } => match event {}, /* `event` is an */
+				// enum with no
+				// variant
+				ToSwarm::ReportObservedAddr { address, score } =>
+					return Poll::Ready(ToSwarm::ReportObservedAddr { address, score }),
+				ToSwarm::CloseConnection { peer_id, connection } =>
+					return Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }),
+			}
+		}
+
+		Poll::Pending
+	}
+}
+
+/// Legacy (fallback) Kademlia protocol name based on `protocol_id`.
+fn legacy_kademlia_protocol_name(id: &ProtocolId) -> Vec<u8> {
+	let mut v = vec![b'/'];
+	v.extend_from_slice(id.as_ref().as_bytes());
+	v.extend_from_slice(b"/kad");
+	v
+}
+
+/// Kademlia protocol name based on `genesis_hash` and `fork_id`.
+fn kademlia_protocol_name<Hash: AsRef<[u8]>>(genesis_hash: Hash, fork_id: Option<&str>) -> Vec<u8> {
+	let genesis_hash_hex = bytes2hex("", genesis_hash.as_ref());
+	if let Some(fork_id) = fork_id {
+		format!("/{}/{}/kad", genesis_hash_hex, fork_id).as_bytes().into()
+	} else {
+		format!("/{}/kad", genesis_hash_hex).as_bytes().into()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{
+		kademlia_protocol_name, legacy_kademlia_protocol_name, DiscoveryConfig, DiscoveryOut,
+	};
+	use crate::config::ProtocolId;
+	use futures::prelude::*;
+	use libp2p::{
+		core::{
+			transport::{MemoryTransport, Transport},
+			upgrade,
+		},
+		identity::Keypair,
+		noise,
+		swarm::{Executor, Swarm, SwarmBuilder, SwarmEvent},
+		yamux, Multiaddr,
+	};
+	use sp_core::hash::H256;
+	use std::{collections::HashSet, pin::Pin, task::Poll};
+
+	struct TokioExecutor(tokio::runtime::Runtime);
+	impl Executor for TokioExecutor {
+		fn exec(&self, f: Pin<Box<dyn Future<Output = ()> + Send>>) {
+			let _ = self.0.spawn(f);
+		}
+	}
+
+	#[test]
+	fn discovery_working() {
+		let mut first_swarm_peer_id_and_addr = None;
+
+		let genesis_hash = H256::from_low_u64_be(1);
+		let fork_id = Some("test-fork-id");
+		let protocol_id = ProtocolId::from("dot");
+
+		// Build swarms whose behaviour is `DiscoveryBehaviour`, each aware of
+		// the first swarm via `with_permanent_addresses`.
+		let mut swarms = (0..25)
+			.map(|i| {
+				let keypair = Keypair::generate_ed25519();
+
+				let transport = MemoryTransport::new()
+					.upgrade(upgrade::Version::V1)
+					.authenticate(noise::Config::new(&keypair).unwrap())
+					.multiplex(yamux::Config::default())
+					.boxed();
+
+				let behaviour = {
+					let mut config = DiscoveryConfig::new(keypair.public().to_peer_id());
+					config
+						.with_permanent_addresses(first_swarm_peer_id_and_addr.clone())
+						.allow_private_ip(true)
+						.allow_non_globals_in_dht(true)
+						.discovery_limit(50)
+						.with_kademlia(genesis_hash, fork_id, &protocol_id);
+
+					config.finish()
+				};
+
+				let runtime = tokio::runtime::Runtime::new().unwrap();
+				let mut swarm = SwarmBuilder::with_executor(
+					transport,
+					behaviour,
+					keypair.public().to_peer_id(),
+					TokioExecutor(runtime),
+				)
+				.build();
+
+				let listen_addr: Multiaddr =
+					format!("/memory/{}", rand::random::<u64>()).parse().unwrap();
+
+				if i == 0 {
+					first_swarm_peer_id_and_addr =
+						Some((keypair.public().to_peer_id(), listen_addr.clone()))
+				}
+
+				swarm.listen_on(listen_addr.clone()).unwrap();
+				(swarm, listen_addr)
+			})
+			.collect::<Vec<_>>();
+
+		// Build a `Vec<HashSet<PeerId>>` with the list of nodes remaining to be discovered.
+		let mut to_discover = (0..swarms.len())
+			.map(|n| {
+				(0..swarms.len())
+					// Skip the first swarm as all other swarms already know it.
+					.skip(1)
+					.filter(|p| *p != n)
+					.map(|p| *Swarm::local_peer_id(&swarms[p].0))
+					.collect::<HashSet<_>>()
+			})
+			.collect::<Vec<_>>();
+
+		let fut = futures::future::poll_fn(move |cx| {
+			'polling: loop {
+				for swarm_n in 0..swarms.len() {
+					match swarms[swarm_n].0.poll_next_unpin(cx) {
+						Poll::Ready(Some(e)) => {
+							match e {
+								SwarmEvent::Behaviour(behavior) => {
+									match behavior {
+										DiscoveryOut::UnroutablePeer(other) |
+										DiscoveryOut::Discovered(other) => {
+											// Call `add_self_reported_address` to simulate identify
+											// happening.
+											let addr = swarms
+												.iter()
+												.find_map(|(s, a)| {
+													if s.behaviour().local_peer_id == other {
+														Some(a.clone())
+													} else {
+														None
+													}
+												})
+												.unwrap();
+											// Test both genesis hash-based and legacy
+											// protocol names.
+											let protocol_name = if swarm_n % 2 == 0 {
+												kademlia_protocol_name(genesis_hash, fork_id)
+											} else {
+												legacy_kademlia_protocol_name(&protocol_id)
+											};
+											swarms[swarm_n]
+												.0
+												.behaviour_mut()
+												.add_self_reported_address(
+													&other,
+													&[protocol_name],
+													addr,
+												);
+
+											to_discover[swarm_n].remove(&other);
+										},
+										DiscoveryOut::RandomKademliaStarted => {},
+										e => {
+											panic!("Unexpected event: {:?}", e)
+										},
+									}
+								},
+								// ignore non Behaviour events
+								_ => {},
+							}
+							continue 'polling
+						},
+						_ => {},
+					}
+				}
+				break
+			}
+
+			if to_discover.iter().all(|l| l.is_empty()) {
+				Poll::Ready(())
+			} else {
+				Poll::Pending
+			}
+		});
+
+		futures::executor::block_on(fut);
+	}
+
+	#[test]
+	fn discovery_ignores_peers_with_unknown_protocols() {
+		let supported_genesis_hash = H256::from_low_u64_be(1);
+		let unsupported_genesis_hash = H256::from_low_u64_be(2);
+		let supported_protocol_id = ProtocolId::from("a");
+		let unsupported_protocol_id = ProtocolId::from("b");
+
+		let mut discovery = {
+			let keypair = Keypair::generate_ed25519();
+			let mut config = DiscoveryConfig::new(keypair.public().to_peer_id());
+			config
+				.allow_private_ip(true)
+				.allow_non_globals_in_dht(true)
+				.discovery_limit(50)
+				.with_kademlia(supported_genesis_hash, None, &supported_protocol_id);
+			config.finish()
+		};
+
+		let predictable_peer_id = |bytes: &[u8; 32]| {
+			Keypair::ed25519_from_bytes(bytes.to_owned()).unwrap().public().to_peer_id()
+		};
+
+		let remote_peer_id = predictable_peer_id(b"00000000000000000000000000000001");
+		let remote_addr: Multiaddr = "/memory/1".parse().unwrap();
+		let another_peer_id = predictable_peer_id(b"00000000000000000000000000000002");
+		let another_addr: Multiaddr = "/memory/2".parse().unwrap();
+
+		// Try adding remote peers with unsupported protocols.
+		discovery.add_self_reported_address(
+			&remote_peer_id,
+			&[kademlia_protocol_name(unsupported_genesis_hash, None)],
+			remote_addr.clone(),
+		);
+		discovery.add_self_reported_address(
+			&another_peer_id,
+			&[legacy_kademlia_protocol_name(&unsupported_protocol_id)],
+			another_addr.clone(),
+		);
+
+		{
+			let kademlia = discovery.kademlia.as_mut().unwrap();
+			assert!(
+				kademlia
+					.kbucket(remote_peer_id)
+					.expect("Remote peer id not to be equal to local peer id.")
+					.is_empty(),
+				"Expect peer with unsupported protocol not to be added."
+			);
+			assert!(
+				kademlia
+					.kbucket(another_peer_id)
+					.expect("Remote peer id not to be equal to local peer id.")
+					.is_empty(),
+				"Expect peer with unsupported protocol not to be added."
+			);
+		}
+
+		// Add remote peers with supported protocols.
+		discovery.add_self_reported_address(
+			&remote_peer_id,
+			&[kademlia_protocol_name(supported_genesis_hash, None)],
+			remote_addr.clone(),
+		);
+		discovery.add_self_reported_address(
+			&another_peer_id,
+			&[legacy_kademlia_protocol_name(&supported_protocol_id)],
+			another_addr.clone(),
+		);
+
+		{
+			let kademlia = discovery.kademlia.as_mut().unwrap();
+			assert_eq!(
+				2,
+				kademlia.kbuckets().fold(0, |acc, bucket| acc + bucket.num_entries()),
+				"Expect peers with supported protocol to be added."
+			);
+		}
+	}
+}
diff --git a/substrate/client/network/src/error.rs b/substrate/client/network/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f0828fb821f3504b63669ebfd663cc703388a437
--- /dev/null
+++ b/substrate/client/network/src/error.rs
@@ -0,0 +1,78 @@
+// 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/>.
+
+//! Substrate network possible errors.
+
+use crate::{config::TransportConfig, types::ProtocolName};
+
+use libp2p::{Multiaddr, PeerId};
+
+use std::fmt;
+
+/// Result type alias for the network.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Error type for the network.
+#[derive(thiserror::Error)]
+pub enum Error {
+	/// Io error
+	#[error(transparent)]
+	Io(#[from] std::io::Error),
+
+	/// Client error
+	#[error(transparent)]
+	Client(#[from] Box<sp_blockchain::Error>),
+	/// The same bootnode (based on address) is registered with two different peer ids.
+	#[error(
+		"The same bootnode (`{address}`) is registered with two different peer ids: `{first_id}` and `{second_id}`"
+	)]
+	DuplicateBootnode {
+		/// The address of the bootnode.
+		address: Multiaddr,
+		/// The first peer id that was found for the bootnode.
+		first_id: PeerId,
+		/// The second peer id that was found for the bootnode.
+		second_id: PeerId,
+	},
+	/// Prometheus metrics error.
+	#[error(transparent)]
+	Prometheus(#[from] prometheus_endpoint::PrometheusError),
+	/// The network addresses are invalid because they don't match the transport.
+	#[error(
+		"The following addresses are invalid because they don't match the transport: {addresses:?}"
+	)]
+	AddressesForAnotherTransport {
+		/// Transport used.
+		transport: TransportConfig,
+		/// The invalid addresses.
+		addresses: Vec<Multiaddr>,
+	},
+	/// The same request-response protocol has been registered multiple times.
+	#[error("Request-response protocol registered multiple times: {protocol}")]
+	DuplicateRequestResponseProtocol {
+		/// Name of the protocol registered multiple times.
+		protocol: ProtocolName,
+	},
+}
+
+// Make `Debug` use the `Display` implementation.
+impl fmt::Debug for Error {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		fmt::Display::fmt(self, f)
+	}
+}
diff --git a/substrate/client/network/src/event.rs b/substrate/client/network/src/event.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2913f0b55225f07df8005026deae5edcf19d85bf
--- /dev/null
+++ b/substrate/client/network/src/event.rs
@@ -0,0 +1,137 @@
+// 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/>.
+
+//! Network event types. These are are not the part of the protocol, but rather
+//! events that happen on the network like DHT get/put results received.
+
+use crate::{types::ProtocolName, NotificationsSink};
+
+use bytes::Bytes;
+use futures::channel::oneshot;
+use libp2p::{kad::record::Key, PeerId};
+
+use sc_network_common::{role::ObservedRole, sync::message::BlockAnnouncesHandshake};
+use sp_runtime::traits::Block as BlockT;
+
+/// Events generated by DHT as a response to get_value and put_value requests.
+#[derive(Debug, Clone)]
+#[must_use]
+pub enum DhtEvent {
+	/// The value was found.
+	ValueFound(Vec<(Key, Vec<u8>)>),
+
+	/// The requested record has not been found in the DHT.
+	ValueNotFound(Key),
+
+	/// The record has been successfully inserted into the DHT.
+	ValuePut(Key),
+
+	/// An error has occurred while putting a record into the DHT.
+	ValuePutFailed(Key),
+}
+
+/// Type for events generated by networking layer.
+#[derive(Debug, Clone)]
+#[must_use]
+pub enum Event {
+	/// Event generated by a DHT.
+	Dht(DhtEvent),
+
+	/// Opened a substream with the given node with the given notifications protocol.
+	///
+	/// The protocol is always one of the notification protocols that have been registered.
+	NotificationStreamOpened {
+		/// Node we opened the substream with.
+		remote: PeerId,
+		/// The concerned protocol. Each protocol uses a different substream.
+		/// This is always equal to the value of
+		/// `sc_network::config::NonDefaultSetConfig::notifications_protocol` of one of the
+		/// configured sets.
+		protocol: ProtocolName,
+		/// If the negotiation didn't use the main name of the protocol (the one in
+		/// `notifications_protocol`), then this field contains which name has actually been
+		/// used.
+		/// Always contains a value equal to the value in
+		/// `sc_network::config::NonDefaultSetConfig::fallback_names`.
+		negotiated_fallback: Option<ProtocolName>,
+		/// Role of the remote.
+		role: ObservedRole,
+		/// Received handshake.
+		received_handshake: Vec<u8>,
+	},
+
+	/// Closed a substream with the given node. Always matches a corresponding previous
+	/// `NotificationStreamOpened` message.
+	NotificationStreamClosed {
+		/// Node we closed the substream with.
+		remote: PeerId,
+		/// The concerned protocol. Each protocol uses a different substream.
+		protocol: ProtocolName,
+	},
+
+	/// Received one or more messages from the given node using the given protocol.
+	NotificationsReceived {
+		/// Node we received the message from.
+		remote: PeerId,
+		/// Concerned protocol and associated message.
+		messages: Vec<(ProtocolName, Bytes)>,
+	},
+}
+
+/// Event sent to `SyncingEngine`
+// TODO: remove once `NotificationService` is implemented.
+pub enum SyncEvent<B: BlockT> {
+	/// Opened a substream with the given node with the given notifications protocol.
+	///
+	/// The protocol is always one of the notification protocols that have been registered.
+	NotificationStreamOpened {
+		/// Node we opened the substream with.
+		remote: PeerId,
+		/// Received handshake.
+		received_handshake: BlockAnnouncesHandshake<B>,
+		/// Notification sink.
+		sink: NotificationsSink,
+		/// Is the connection inbound.
+		inbound: bool,
+		/// Channel for reporting accept/reject of the substream.
+		tx: oneshot::Sender<bool>,
+	},
+
+	/// Closed a substream with the given node. Always matches a corresponding previous
+	/// `NotificationStreamOpened` message.
+	NotificationStreamClosed {
+		/// Node we closed the substream with.
+		remote: PeerId,
+	},
+
+	/// Notification sink was replaced.
+	NotificationSinkReplaced {
+		/// Node we closed the substream with.
+		remote: PeerId,
+		/// Notification sink.
+		sink: NotificationsSink,
+	},
+
+	/// Received one or more messages from the given node using the given protocol.
+	NotificationsReceived {
+		/// Node we received the message from.
+		remote: PeerId,
+		/// Concerned protocol and associated message.
+		messages: Vec<Bytes>,
+	},
+}
diff --git a/substrate/client/network/src/lib.rs b/substrate/client/network/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee307596878417c0de2e58305ce73f49c2744944
--- /dev/null
+++ b/substrate/client/network/src/lib.rs
@@ -0,0 +1,300 @@
+// 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/>.
+
+#![warn(unused_extern_crates)]
+#![warn(missing_docs)]
+
+//! Substrate-specific P2P networking.
+//!
+//! **Important**: This crate is unstable and the API and usage may change.
+//!
+//! # Node identities and addresses
+//!
+//! In a decentralized network, each node possesses a network private key and a network public key.
+//! In Substrate, the keys are based on the ed25519 curve.
+//!
+//! From a node's public key, we can derive its *identity*. In Substrate and libp2p, a node's
+//! identity is represented with the [`PeerId`] struct. All network communications between nodes on
+//! the network use encryption derived from both sides's keys, which means that **identities cannot
+//! be faked**.
+//!
+//! A node's identity uniquely identifies a machine on the network. If you start two or more
+//! clients using the same network key, large interferences will happen.
+//!
+//! # Substrate's network protocol
+//!
+//! Substrate's networking protocol is based upon libp2p. It is at the moment not possible and not
+//! planned to permit using something else than the libp2p network stack and the rust-libp2p
+//! library. However the libp2p framework is very flexible and the rust-libp2p library could be
+//! extended to support a wider range of protocols than what is offered by libp2p.
+//!
+//! ## Discovery mechanisms
+//!
+//! In order for our node to join a peer-to-peer network, it has to know a list of nodes that are
+//! part of said network. This includes nodes identities and their address (how to reach them).
+//! Building such a list is called the **discovery** mechanism. There are three mechanisms that
+//! Substrate uses:
+//!
+//! - Bootstrap nodes. These are hard-coded node identities and addresses passed alongside with
+//! the network configuration.
+//! - mDNS. We perform a UDP broadcast on the local network. Nodes that listen may respond with
+//! their identity. More info [here](https://github.com/libp2p/specs/blob/master/discovery/mdns.md).
+//! mDNS can be disabled in the network configuration.
+//! - Kademlia random walk. Once connected, we perform random Kademlia `FIND_NODE` requests on the
+//! configured Kademlia DHTs (one per configured chain protocol) in order for nodes to propagate to
+//! us their view of the network. More information about Kademlia can be found [on
+//! Wikipedia](https://en.wikipedia.org/wiki/Kademlia).
+//!
+//! ## Connection establishment
+//!
+//! When node Alice knows node Bob's identity and address, it can establish a connection with Bob.
+//! All connections must always use encryption and multiplexing. While some node addresses (eg.
+//! addresses using `/quic`) already imply which encryption and/or multiplexing to use, for others
+//! the **multistream-select** protocol is used in order to negotiate an encryption layer and/or a
+//! multiplexing layer.
+//!
+//! The connection establishment mechanism is called the **transport**.
+//!
+//! As of the writing of this documentation, the following base-layer protocols are supported by
+//! Substrate:
+//!
+//! - TCP/IP for addresses of the form `/ip4/1.2.3.4/tcp/5`. Once the TCP connection is open, an
+//! encryption and a multiplexing layer are negotiated on top.
+//! - WebSockets for addresses of the form `/ip4/1.2.3.4/tcp/5/ws`. A TCP/IP connection is open and
+//! the WebSockets protocol is negotiated on top. Communications then happen inside WebSockets data
+//! frames. Encryption and multiplexing are additionally negotiated again inside this channel.
+//! - DNS for addresses of the form `/dns/example.com/tcp/5` or `/dns/example.com/tcp/5/ws`. A
+//! node's address can contain a domain name.
+//! - (All of the above using IPv6 instead of IPv4.)
+//!
+//! On top of the base-layer protocol, the [Noise](https://noiseprotocol.org/) protocol is
+//! negotiated and applied. The exact handshake protocol is experimental and is subject to change.
+//!
+//! The following multiplexing protocols are supported:
+//!
+//! - [Yamux](https://github.com/hashicorp/yamux/blob/master/spec.md).
+//!
+//! ## Substreams
+//!
+//! Once a connection has been established and uses multiplexing, substreams can be opened. When
+//! a substream is open, the **multistream-select** protocol is used to negotiate which protocol
+//! to use on that given substream.
+//!
+//! Protocols that are specific to a certain chain have a `<protocol-id>` in their name. This
+//! "protocol ID" is defined in the chain specifications. For example, the protocol ID of Polkadot
+//! is "dot". In the protocol names below, `<protocol-id>` must be replaced with the corresponding
+//! protocol ID.
+//!
+//! > **Note**: It is possible for the same connection to be used for multiple chains. For example,
+//! > one can use both the `/dot/sync/2` and `/sub/sync/2` protocols on the same
+//! > connection, provided that the remote supports them.
+//!
+//! Substrate uses the following standard libp2p protocols:
+//!
+//! - **`/ipfs/ping/1.0.0`**. We periodically open an ephemeral substream in order to ping the
+//! remote and check whether the connection is still alive. Failure for the remote to reply leads
+//! to a disconnection.
+//! - **[`/ipfs/id/1.0.0`](https://github.com/libp2p/specs/tree/master/identify)**. We
+//! periodically open an ephemeral substream in order to ask information from the remote.
+//! - **[`/<protocol_id>/kad`](https://github.com/libp2p/specs/pull/108)**. We periodically open
+//! ephemeral substreams for Kademlia random walk queries. Each Kademlia query is done in a
+//! separate substream.
+//!
+//! Additionally, Substrate uses the following non-libp2p-standard protocols:
+//!
+//! - **`/substrate/<protocol-id>/<version>`** (where `<protocol-id>` must be replaced with the
+//! protocol ID of the targeted chain, and `<version>` is a number between 2 and 6). For each
+//! connection we optionally keep an additional substream for all Substrate-based communications
+//! alive. This protocol is considered legacy, and is progressively being replaced with
+//! alternatives. This is designated as "The legacy Substrate substream" in this documentation. See
+//! below for more details.
+//! - **`/<protocol-id>/sync/2`** is a request-response protocol (see below) that lets one perform
+//! requests for information about blocks. Each request is the encoding of a `BlockRequest` and
+//! each response is the encoding of a `BlockResponse`, as defined in the `api.v1.proto` file in
+//! this source tree.
+//! - **`/<protocol-id>/light/2`** is a request-response protocol (see below) that lets one perform
+//! light-client-related requests for information about the state. Each request is the encoding of
+//! a `light::Request` and each response is the encoding of a `light::Response`, as defined in the
+//! `light.v1.proto` file in this source tree.
+//! - **`/<protocol-id>/transactions/1`** is a notifications protocol (see below) where
+//! transactions are pushed to other nodes. The handshake is empty on both sides. The message
+//! format is a SCALE-encoded list of transactions, where each transaction is an opaque list of
+//! bytes.
+//! - **`/<protocol-id>/block-announces/1`** is a notifications protocol (see below) where
+//! block announces are pushed to other nodes. The handshake is empty on both sides. The message
+//! format is a SCALE-encoded tuple containing a block header followed with an opaque list of
+//! bytes containing some data associated with this block announcement, e.g. a candidate message.
+//! - Notifications protocols that are registered using
+//! `NetworkConfiguration::notifications_protocols`. For example: `/paritytech/grandpa/1`. See
+//! below for more information.
+//!
+//! ## The legacy Substrate substream
+//!
+//! Substrate uses a component named the **peerset manager (PSM)**. Through the discovery
+//! mechanism, the PSM is aware of the nodes that are part of the network and decides which nodes
+//! we should perform Substrate-based communications with. For these nodes, we open a connection
+//! if necessary and open a unique substream for Substrate-based communications. If the PSM decides
+//! that we should disconnect a node, then that substream is closed.
+//!
+//! For more information about the PSM, see the *sc-peerset* crate.
+//!
+//! Note that at the moment there is no mechanism in place to solve the issues that arise where the
+//! two sides of a connection open the unique substream simultaneously. In order to not run into
+//! issues, only the dialer of a connection is allowed to open the unique substream. When the
+//! substream is closed, the entire connection is closed as well. This is a bug that will be
+//! resolved by deprecating the protocol entirely.
+//!
+//! Within the unique Substrate substream, messages encoded using
+//! [*parity-scale-codec*](https://github.com/paritytech/parity-scale-codec) are exchanged.
+//! The detail of theses messages is not totally in place, but they can be found in the
+//! `message.rs` file.
+//!
+//! Once the substream is open, the first step is an exchange of a *status* message from both
+//! sides, containing information such as the chain root hash, head of chain, and so on.
+//!
+//! Communications within this substream include:
+//!
+//! - Syncing. Blocks are announced and requested from other nodes.
+//! - Light-client requests. When a light client requires information, a random node we have a
+//! substream open with is chosen, and the information is requested from it.
+//! - Gossiping. Used for example by grandpa.
+//!
+//! ## Request-response protocols
+//!
+//! A so-called request-response protocol is defined as follow:
+//!
+//! - When a substream is opened, the opening side sends a message whose content is
+//! protocol-specific. The message must be prefixed with an
+//! [LEB128-encoded number](https://en.wikipedia.org/wiki/LEB128) indicating its length. After the
+//! message has been sent, the writing side is closed.
+//! - The remote sends back the response prefixed with a LEB128-encoded length, and closes its
+//! side as well.
+//!
+//! Each request is performed in a new separate substream.
+//!
+//! ## Notifications protocols
+//!
+//! A so-called notifications protocol is defined as follow:
+//!
+//! - When a substream is opened, the opening side sends a handshake message whose content is
+//! protocol-specific. The handshake message must be prefixed with an
+//! [LEB128-encoded number](https://en.wikipedia.org/wiki/LEB128) indicating its length. The
+//! handshake message can be of length 0, in which case the sender has to send a single `0`.
+//! - The receiver then either immediately closes the substream, or answers with its own
+//! LEB128-prefixed protocol-specific handshake response. The message can be of length 0, in which
+//! case a single `0` has to be sent back.
+//! - Once the handshake has completed, the notifications protocol is unidirectional. Only the
+//! node which initiated the substream can push notifications. If the remote wants to send
+//! notifications as well, it has to open its own undirectional substream.
+//! - Each notification must be prefixed with an LEB128-encoded length. The encoding of the
+//! messages is specific to each protocol.
+//! - Either party can signal that it doesn't want a notifications substream anymore by closing
+//! its writing side. The other party should respond by closing its own writing side soon after.
+//!
+//! The API of `sc-network` allows one to register user-defined notification protocols.
+//! `sc-network` automatically tries to open a substream towards each node for which the legacy
+//! Substream substream is open. The handshake is then performed automatically.
+//!
+//! For example, the `sc-consensus-grandpa` crate registers the `/paritytech/grandpa/1`
+//! notifications protocol.
+//!
+//! At the moment, for backwards-compatibility, notification protocols are tied to the legacy
+//! Substrate substream. Additionally, the handshake message is hardcoded to be a single 8-bits
+//! integer representing the role of the node:
+//!
+//! - 1 for a full node.
+//! - 2 for a light node.
+//! - 4 for an authority.
+//!
+//! In the future, though, these restrictions will be removed.
+//!
+//! # Usage
+//!
+//! Using the `sc-network` crate is done through the [`NetworkWorker`] struct. Create this
+//! struct by passing a [`config::Params`], then poll it as if it was a `Future`. You can extract an
+//! `Arc<NetworkService>` from the `NetworkWorker`, which can be shared amongst multiple places
+//! in order to give orders to the networking.
+//!
+//! See the [`config`] module for more information about how to configure the networking.
+//!
+//! After the `NetworkWorker` has been created, the important things to do are:
+//!
+//! - Calling `NetworkWorker::poll` in order to advance the network. This can be done by
+//! dispatching a background task with the [`NetworkWorker`].
+//! - Calling `on_block_import` whenever a block is added to the client.
+//! - Calling `on_block_finalized` whenever a block is finalized.
+//! - Calling `trigger_repropagate` when a transaction is added to the pool.
+//!
+//! More precise usage details are still being worked on and will likely change in the future.
+
+mod behaviour;
+mod protocol;
+mod service;
+
+#[cfg(test)]
+mod mock;
+
+pub mod config;
+pub mod discovery;
+pub mod error;
+pub mod event;
+pub mod network_state;
+pub mod peer_info;
+pub mod peer_store;
+pub mod protocol_controller;
+pub mod request_responses;
+pub mod transport;
+pub mod types;
+pub mod utils;
+
+pub use event::{DhtEvent, Event, SyncEvent};
+#[doc(inline)]
+pub use libp2p::{multiaddr, Multiaddr, PeerId};
+pub use request_responses::{Config, IfDisconnected, RequestFailure};
+pub use sc_network_common::{
+	role::ObservedRole,
+	sync::{
+		warp::{WarpSyncPhase, WarpSyncProgress},
+		ExtendedPeerInfo, StateDownloadProgress, SyncEventStream, SyncState, SyncStatusProvider,
+	},
+	types::ReputationChange,
+};
+pub use service::{
+	signature::Signature,
+	traits::{
+		KademliaKey, NetworkBlock, NetworkDHTProvider, NetworkEventStream, NetworkNotification,
+		NetworkPeers, NetworkRequest, NetworkSigner, NetworkStateInfo, NetworkStatus,
+		NetworkStatusProvider, NetworkSyncForkRequest, NotificationSender as NotificationSenderT,
+		NotificationSenderError, NotificationSenderReady,
+	},
+	DecodingError, Keypair, NetworkService, NetworkWorker, NotificationSender, NotificationsSink,
+	OutboundFailure, PublicKey,
+};
+pub use types::ProtocolName;
+
+/// The maximum allowed number of established connections per peer.
+///
+/// Typically, and by design of the network behaviours in this crate,
+/// there is a single established connection per peer. However, to
+/// avoid unnecessary and nondeterministic connection closure in
+/// case of (possibly repeated) simultaneous dialing attempts between
+/// two peers, the per-peer connection limit is not set to 1 but 2.
+const MAX_CONNECTIONS_PER_PEER: usize = 2;
+
+/// The maximum number of concurrent established connections that were incoming.
+const MAX_CONNECTIONS_ESTABLISHED_INCOMING: u32 = 10_000;
diff --git a/substrate/client/network/src/mock.rs b/substrate/client/network/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bc596b0fa579e1bc356cabcd54b6ef94e7de416f
--- /dev/null
+++ b/substrate/client/network/src/mock.rs
@@ -0,0 +1,55 @@
+// 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/>.
+
+//! Mocked components for tests.
+
+use crate::{peer_store::PeerStoreProvider, protocol_controller::ProtocolHandle, ReputationChange};
+use libp2p::PeerId;
+use std::collections::HashSet;
+
+/// No-op `PeerStore`.
+#[derive(Debug)]
+pub struct MockPeerStore {}
+
+impl PeerStoreProvider for MockPeerStore {
+	fn is_banned(&self, _peer_id: &PeerId) -> bool {
+		// Make sure that the peer is not banned.
+		false
+	}
+
+	fn register_protocol(&self, _protocol_handle: ProtocolHandle) {
+		// Make sure not to fail.
+	}
+
+	fn report_disconnect(&mut self, _peer_id: PeerId) {
+		// Make sure not to fail.
+	}
+
+	fn report_peer(&mut self, _peer_id: PeerId, _change: ReputationChange) {
+		// Make sure not to fail.
+	}
+
+	fn peer_reputation(&self, _peer_id: &PeerId) -> i32 {
+		// Make sure that the peer is not banned.
+		0
+	}
+
+	fn outgoing_candidates(&self, _count: usize, _ignored: HashSet<&PeerId>) -> Vec<PeerId> {
+		unimplemented!()
+	}
+}
diff --git a/substrate/client/network/src/network_state.rs b/substrate/client/network/src/network_state.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cf8b8b55a7ff8e40fed261b90ca9a75fe979ebe6
--- /dev/null
+++ b/substrate/client/network/src/network_state.rs
@@ -0,0 +1,124 @@
+// 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/>.
+
+//! Information about the networking, for diagnostic purposes.
+//!
+//! **Warning**: These APIs are not stable.
+
+use libp2p::{
+	core::{ConnectedPoint, Endpoint as CoreEndpoint},
+	Multiaddr,
+};
+use serde::{Deserialize, Serialize};
+use std::{
+	collections::{HashMap, HashSet},
+	time::Duration,
+};
+
+/// Returns general information about the networking.
+///
+/// Meant for general diagnostic purposes.
+///
+/// **Warning**: This API is not stable.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NetworkState {
+	/// PeerId of the local node.
+	pub peer_id: String,
+	/// List of addresses the node is currently listening on.
+	pub listened_addresses: HashSet<Multiaddr>,
+	/// List of addresses the node knows it can be reached as.
+	pub external_addresses: HashSet<Multiaddr>,
+	/// List of node we're connected to.
+	pub connected_peers: HashMap<String, Peer>,
+	/// List of node that we know of but that we're not connected to.
+	pub not_connected_peers: HashMap<String, NotConnectedPeer>,
+	/// State of the peerset manager.
+	pub peerset: serde_json::Value,
+}
+
+/// Part of the `NetworkState` struct. Unstable.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Peer {
+	/// How we are connected to the node.
+	pub endpoint: PeerEndpoint,
+	/// Node information, as provided by the node itself. Can be empty if not known yet.
+	pub version_string: Option<String>,
+	/// Latest ping duration with this node.
+	pub latest_ping_time: Option<Duration>,
+	/// List of addresses known for this node.
+	pub known_addresses: HashSet<Multiaddr>,
+}
+
+/// Part of the `NetworkState` struct. Unstable.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NotConnectedPeer {
+	/// List of addresses known for this node.
+	pub known_addresses: HashSet<Multiaddr>,
+	/// Node information, as provided by the node itself, if we were ever connected to this node.
+	pub version_string: Option<String>,
+	/// Latest ping duration with this node, if we were ever connected to this node.
+	pub latest_ping_time: Option<Duration>,
+}
+
+/// Part of the `NetworkState` struct. Unstable.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum PeerEndpoint {
+	/// We are dialing the given address.
+	Dialing(Multiaddr, Endpoint),
+	/// We are listening.
+	Listening {
+		/// Local address of the connection.
+		local_addr: Multiaddr,
+		/// Address data is sent back to.
+		send_back_addr: Multiaddr,
+	},
+}
+
+/// Part of the `NetworkState` struct. Unstable.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Endpoint {
+	/// The socket comes from a dialer.
+	Dialer,
+	/// The socket comes from a listener.
+	Listener,
+}
+
+impl From<ConnectedPoint> for PeerEndpoint {
+	fn from(endpoint: ConnectedPoint) -> Self {
+		match endpoint {
+			ConnectedPoint::Dialer { address, role_override } =>
+				Self::Dialing(address, role_override.into()),
+			ConnectedPoint::Listener { local_addr, send_back_addr } =>
+				Self::Listening { local_addr, send_back_addr },
+		}
+	}
+}
+
+impl From<CoreEndpoint> for Endpoint {
+	fn from(endpoint: CoreEndpoint) -> Self {
+		match endpoint {
+			CoreEndpoint::Dialer => Self::Dialer,
+			CoreEndpoint::Listener => Self::Listener,
+		}
+	}
+}
diff --git a/substrate/client/network/src/peer_info.rs b/substrate/client/network/src/peer_info.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2735bd873db91dbcc0a54786e2c64408d6f21133
--- /dev/null
+++ b/substrate/client/network/src/peer_info.rs
@@ -0,0 +1,500 @@
+// 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/>.
+
+//! [`PeerInfoBehaviour`] is implementation of `NetworkBehaviour` that holds information about peers
+//! in cache.
+
+use crate::utils::interval;
+use either::Either;
+
+use fnv::FnvHashMap;
+use futures::prelude::*;
+use libp2p::{
+	core::{ConnectedPoint, Endpoint},
+	identify::{
+		Behaviour as Identify, Config as IdentifyConfig, Event as IdentifyEvent,
+		Info as IdentifyInfo,
+	},
+	identity::PublicKey,
+	ping::{Behaviour as Ping, Config as PingConfig, Event as PingEvent, Success as PingSuccess},
+	swarm::{
+		behaviour::{
+			AddressChange, ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm,
+			ListenFailure,
+		},
+		ConnectionDenied, ConnectionHandler, ConnectionId, IntoConnectionHandlerSelect,
+		NetworkBehaviour, PollParameters, THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
+	},
+	Multiaddr, PeerId,
+};
+use log::{debug, error, trace};
+use parking_lot::Mutex;
+use smallvec::SmallVec;
+
+use std::{
+	collections::{hash_map::Entry, HashSet},
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+	time::{Duration, Instant},
+};
+
+/// Time after we disconnect from a node before we purge its information from the cache.
+const CACHE_EXPIRE: Duration = Duration::from_secs(10 * 60);
+/// Interval at which we perform garbage collection on the node info.
+const GARBAGE_COLLECT_INTERVAL: Duration = Duration::from_secs(2 * 60);
+
+/// Implementation of `NetworkBehaviour` that holds information about peers in cache.
+pub struct PeerInfoBehaviour {
+	/// Periodically ping nodes, and close the connection if it's unresponsive.
+	ping: Ping,
+	/// Periodically identifies the remote and responds to incoming requests.
+	identify: Identify,
+	/// Information that we know about all nodes.
+	nodes_info: FnvHashMap<PeerId, NodeInfo>,
+	/// Interval at which we perform garbage collection in `nodes_info`.
+	garbage_collect: Pin<Box<dyn Stream<Item = ()> + Send>>,
+	/// Record keeping of external addresses. Data is queried by the `NetworkService`.
+	external_addresses: ExternalAddresses,
+}
+
+/// Information about a node we're connected to.
+#[derive(Debug)]
+struct NodeInfo {
+	/// When we will remove the entry about this node from the list, or `None` if we're connected
+	/// to the node.
+	info_expire: Option<Instant>,
+	/// Non-empty list of connected endpoints, one per connection.
+	endpoints: SmallVec<[ConnectedPoint; crate::MAX_CONNECTIONS_PER_PEER]>,
+	/// Version reported by the remote, or `None` if unknown.
+	client_version: Option<String>,
+	/// Latest ping time with this node.
+	latest_ping: Option<Duration>,
+}
+
+impl NodeInfo {
+	fn new(endpoint: ConnectedPoint) -> Self {
+		let mut endpoints = SmallVec::new();
+		endpoints.push(endpoint);
+		Self { info_expire: None, endpoints, client_version: None, latest_ping: None }
+	}
+}
+
+/// Utility struct for tracking external addresses. The data is shared with the `NetworkService`.
+#[derive(Debug, Clone, Default)]
+pub struct ExternalAddresses {
+	addresses: Arc<Mutex<HashSet<Multiaddr>>>,
+}
+
+impl ExternalAddresses {
+	/// Add an external address.
+	pub fn add(&mut self, addr: Multiaddr) {
+		self.addresses.lock().insert(addr);
+	}
+
+	/// Remove an external address.
+	pub fn remove(&mut self, addr: &Multiaddr) {
+		self.addresses.lock().remove(addr);
+	}
+}
+
+impl PeerInfoBehaviour {
+	/// Builds a new `PeerInfoBehaviour`.
+	pub fn new(
+		user_agent: String,
+		local_public_key: PublicKey,
+		external_addresses: Arc<Mutex<HashSet<Multiaddr>>>,
+	) -> Self {
+		let identify = {
+			let cfg = IdentifyConfig::new("/substrate/1.0".to_string(), local_public_key)
+				.with_agent_version(user_agent)
+				// We don't need any peer information cached.
+				.with_cache_size(0);
+			Identify::new(cfg)
+		};
+
+		Self {
+			ping: Ping::new(PingConfig::new()),
+			identify,
+			nodes_info: FnvHashMap::default(),
+			garbage_collect: Box::pin(interval(GARBAGE_COLLECT_INTERVAL)),
+			external_addresses: ExternalAddresses { addresses: external_addresses },
+		}
+	}
+
+	/// Borrows `self` and returns a struct giving access to the information about a node.
+	///
+	/// Returns `None` if we don't know anything about this node. Always returns `Some` for nodes
+	/// we're connected to, meaning that if `None` is returned then we're not connected to that
+	/// node.
+	pub fn node(&self, peer_id: &PeerId) -> Option<Node> {
+		self.nodes_info.get(peer_id).map(Node)
+	}
+
+	/// Inserts a ping time in the cache. Has no effect if we don't have any entry for that node,
+	/// which shouldn't happen.
+	fn handle_ping_report(&mut self, peer_id: &PeerId, ping_time: Duration) {
+		trace!(target: "sub-libp2p", "Ping time with {:?}: {:?}", peer_id, ping_time);
+		if let Some(entry) = self.nodes_info.get_mut(peer_id) {
+			entry.latest_ping = Some(ping_time);
+		} else {
+			error!(target: "sub-libp2p",
+				"Received ping from node we're not connected to {:?}", peer_id);
+		}
+	}
+
+	/// Inserts an identify record in the cache. Has no effect if we don't have any entry for that
+	/// node, which shouldn't happen.
+	fn handle_identify_report(&mut self, peer_id: &PeerId, info: &IdentifyInfo) {
+		trace!(target: "sub-libp2p", "Identified {:?} => {:?}", peer_id, info);
+		if let Some(entry) = self.nodes_info.get_mut(peer_id) {
+			entry.client_version = Some(info.agent_version.clone());
+		} else {
+			error!(target: "sub-libp2p",
+				"Received pong from node we're not connected to {:?}", peer_id);
+		}
+	}
+}
+
+/// Gives access to the information about a node.
+pub struct Node<'a>(&'a NodeInfo);
+
+impl<'a> Node<'a> {
+	/// Returns the endpoint of an established connection to the peer.
+	///
+	/// Returns `None` if we are disconnected from the node.
+	pub fn endpoint(&self) -> Option<&'a ConnectedPoint> {
+		self.0.endpoints.get(0)
+	}
+
+	/// Returns the latest version information we know of.
+	pub fn client_version(&self) -> Option<&'a str> {
+		self.0.client_version.as_deref()
+	}
+
+	/// Returns the latest ping time we know of for this node. `None` if we never successfully
+	/// pinged this node.
+	pub fn latest_ping(&self) -> Option<Duration> {
+		self.0.latest_ping
+	}
+}
+
+/// Event that can be emitted by the behaviour.
+#[derive(Debug)]
+pub enum PeerInfoEvent {
+	/// We have obtained identity information from a peer, including the addresses it is listening
+	/// on.
+	Identified {
+		/// Id of the peer that has been identified.
+		peer_id: PeerId,
+		/// Information about the peer.
+		info: IdentifyInfo,
+	},
+}
+
+impl NetworkBehaviour for PeerInfoBehaviour {
+	type ConnectionHandler = IntoConnectionHandlerSelect<
+		<Ping as NetworkBehaviour>::ConnectionHandler,
+		<Identify as NetworkBehaviour>::ConnectionHandler,
+	>;
+	type OutEvent = PeerInfoEvent;
+
+	fn handle_pending_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<(), ConnectionDenied> {
+		self.ping
+			.handle_pending_inbound_connection(connection_id, local_addr, remote_addr)?;
+		self.identify
+			.handle_pending_inbound_connection(connection_id, local_addr, remote_addr)
+	}
+
+	fn handle_pending_outbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		_maybe_peer: Option<PeerId>,
+		_addresses: &[Multiaddr],
+		_effective_role: Endpoint,
+	) -> Result<Vec<Multiaddr>, ConnectionDenied> {
+		// Only `Discovery::handle_pending_outbound_connection` must be returning addresses to
+		// ensure that we don't return unwanted addresses.
+		Ok(Vec::new())
+	}
+
+	fn handle_established_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		let ping_handler = self.ping.handle_established_inbound_connection(
+			connection_id,
+			peer,
+			local_addr,
+			remote_addr,
+		)?;
+		let identify_handler = self.identify.handle_established_inbound_connection(
+			connection_id,
+			peer,
+			local_addr,
+			remote_addr,
+		)?;
+		Ok(ping_handler.select(identify_handler))
+	}
+
+	fn handle_established_outbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		addr: &Multiaddr,
+		role_override: Endpoint,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		let ping_handler = self.ping.handle_established_outbound_connection(
+			connection_id,
+			peer,
+			addr,
+			role_override,
+		)?;
+		let identify_handler = self.identify.handle_established_outbound_connection(
+			connection_id,
+			peer,
+			addr,
+			role_override,
+		)?;
+		Ok(ping_handler.select(identify_handler))
+	}
+
+	fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+		match event {
+			FromSwarm::ConnectionEstablished(
+				e @ ConnectionEstablished { peer_id, endpoint, .. },
+			) => {
+				self.ping.on_swarm_event(FromSwarm::ConnectionEstablished(e));
+				self.identify.on_swarm_event(FromSwarm::ConnectionEstablished(e));
+
+				match self.nodes_info.entry(peer_id) {
+					Entry::Vacant(e) => {
+						e.insert(NodeInfo::new(endpoint.clone()));
+					},
+					Entry::Occupied(e) => {
+						let e = e.into_mut();
+						if e.info_expire.as_ref().map(|exp| *exp < Instant::now()).unwrap_or(false)
+						{
+							e.client_version = None;
+							e.latest_ping = None;
+						}
+						e.info_expire = None;
+						e.endpoints.push(endpoint.clone());
+					},
+				}
+			},
+			FromSwarm::ConnectionClosed(ConnectionClosed {
+				peer_id,
+				connection_id,
+				endpoint,
+				handler,
+				remaining_established,
+			}) => {
+				let (ping_handler, identity_handler) = handler.into_inner();
+				self.ping.on_swarm_event(FromSwarm::ConnectionClosed(ConnectionClosed {
+					peer_id,
+					connection_id,
+					endpoint,
+					handler: ping_handler,
+					remaining_established,
+				}));
+				self.identify.on_swarm_event(FromSwarm::ConnectionClosed(ConnectionClosed {
+					peer_id,
+					connection_id,
+					endpoint,
+					handler: identity_handler,
+					remaining_established,
+				}));
+
+				if let Some(entry) = self.nodes_info.get_mut(&peer_id) {
+					if remaining_established == 0 {
+						entry.info_expire = Some(Instant::now() + CACHE_EXPIRE);
+					}
+					entry.endpoints.retain(|ep| ep != endpoint)
+				} else {
+					error!(target: "sub-libp2p",
+						"Unknown connection to {:?} closed: {:?}", peer_id, endpoint);
+				}
+			},
+			FromSwarm::DialFailure(DialFailure { peer_id, error, connection_id }) => {
+				self.ping.on_swarm_event(FromSwarm::DialFailure(DialFailure {
+					peer_id,
+					error,
+					connection_id,
+				}));
+				self.identify.on_swarm_event(FromSwarm::DialFailure(DialFailure {
+					peer_id,
+					error,
+					connection_id,
+				}));
+			},
+			FromSwarm::ListenerClosed(e) => {
+				self.ping.on_swarm_event(FromSwarm::ListenerClosed(e));
+				self.identify.on_swarm_event(FromSwarm::ListenerClosed(e));
+			},
+			FromSwarm::ListenFailure(ListenFailure {
+				local_addr,
+				send_back_addr,
+				error,
+				connection_id,
+			}) => {
+				self.ping.on_swarm_event(FromSwarm::ListenFailure(ListenFailure {
+					local_addr,
+					send_back_addr,
+					error,
+					connection_id,
+				}));
+				self.identify.on_swarm_event(FromSwarm::ListenFailure(ListenFailure {
+					local_addr,
+					send_back_addr,
+					error,
+					connection_id,
+				}));
+			},
+			FromSwarm::ListenerError(e) => {
+				self.ping.on_swarm_event(FromSwarm::ListenerError(e));
+				self.identify.on_swarm_event(FromSwarm::ListenerError(e));
+			},
+			FromSwarm::ExpiredExternalAddr(e) => {
+				self.ping.on_swarm_event(FromSwarm::ExpiredExternalAddr(e));
+				self.identify.on_swarm_event(FromSwarm::ExpiredExternalAddr(e));
+			},
+			FromSwarm::NewListener(e) => {
+				self.ping.on_swarm_event(FromSwarm::NewListener(e));
+				self.identify.on_swarm_event(FromSwarm::NewListener(e));
+			},
+			FromSwarm::ExpiredListenAddr(e) => {
+				self.ping.on_swarm_event(FromSwarm::ExpiredListenAddr(e));
+				self.identify.on_swarm_event(FromSwarm::ExpiredListenAddr(e));
+				self.external_addresses.remove(e.addr);
+			},
+			FromSwarm::NewExternalAddr(e) => {
+				self.ping.on_swarm_event(FromSwarm::NewExternalAddr(e));
+				self.identify.on_swarm_event(FromSwarm::NewExternalAddr(e));
+				self.external_addresses.add(e.addr.clone());
+			},
+			FromSwarm::AddressChange(e @ AddressChange { peer_id, old, new, .. }) => {
+				self.ping.on_swarm_event(FromSwarm::AddressChange(e));
+				self.identify.on_swarm_event(FromSwarm::AddressChange(e));
+
+				if let Some(entry) = self.nodes_info.get_mut(&peer_id) {
+					if let Some(endpoint) = entry.endpoints.iter_mut().find(|e| e == &old) {
+						*endpoint = new.clone();
+					} else {
+						error!(target: "sub-libp2p",
+							"Unknown address change for peer {:?} from {:?} to {:?}", peer_id, old, new);
+					}
+				} else {
+					error!(target: "sub-libp2p",
+						"Unknown peer {:?} to change address from {:?} to {:?}", peer_id, old, new);
+				}
+			},
+			FromSwarm::NewListenAddr(e) => {
+				self.ping.on_swarm_event(FromSwarm::NewListenAddr(e));
+				self.identify.on_swarm_event(FromSwarm::NewListenAddr(e));
+			},
+		}
+	}
+
+	fn on_connection_handler_event(
+		&mut self,
+		peer_id: PeerId,
+		connection_id: ConnectionId,
+		event: THandlerOutEvent<Self>,
+	) {
+		match event {
+			Either::Left(event) =>
+				self.ping.on_connection_handler_event(peer_id, connection_id, event),
+			Either::Right(event) =>
+				self.identify.on_connection_handler_event(peer_id, connection_id, event),
+		}
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut Context,
+		params: &mut impl PollParameters,
+	) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
+		loop {
+			match self.ping.poll(cx, params) {
+				Poll::Pending => break,
+				Poll::Ready(ToSwarm::GenerateEvent(ev)) => {
+					if let PingEvent { peer, result: Ok(PingSuccess::Ping { rtt }) } = ev {
+						self.handle_ping_report(&peer, rtt)
+					}
+				},
+				Poll::Ready(ToSwarm::Dial { opts }) => return Poll::Ready(ToSwarm::Dial { opts }),
+				Poll::Ready(ToSwarm::NotifyHandler { peer_id, handler, event }) =>
+					return Poll::Ready(ToSwarm::NotifyHandler {
+						peer_id,
+						handler,
+						event: Either::Left(event),
+					}),
+				Poll::Ready(ToSwarm::ReportObservedAddr { address, score }) =>
+					return Poll::Ready(ToSwarm::ReportObservedAddr { address, score }),
+				Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }) =>
+					return Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }),
+			}
+		}
+
+		loop {
+			match self.identify.poll(cx, params) {
+				Poll::Pending => break,
+				Poll::Ready(ToSwarm::GenerateEvent(event)) => match event {
+					IdentifyEvent::Received { peer_id, info, .. } => {
+						self.handle_identify_report(&peer_id, &info);
+						let event = PeerInfoEvent::Identified { peer_id, info };
+						return Poll::Ready(ToSwarm::GenerateEvent(event))
+					},
+					IdentifyEvent::Error { peer_id, error } => {
+						debug!(target: "sub-libp2p", "Identification with peer {:?} failed => {}", peer_id, error)
+					},
+					IdentifyEvent::Pushed { .. } => {},
+					IdentifyEvent::Sent { .. } => {},
+				},
+				Poll::Ready(ToSwarm::Dial { opts }) => return Poll::Ready(ToSwarm::Dial { opts }),
+				Poll::Ready(ToSwarm::NotifyHandler { peer_id, handler, event }) =>
+					return Poll::Ready(ToSwarm::NotifyHandler {
+						peer_id,
+						handler,
+						event: Either::Right(event),
+					}),
+				Poll::Ready(ToSwarm::ReportObservedAddr { address, score }) =>
+					return Poll::Ready(ToSwarm::ReportObservedAddr { address, score }),
+				Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }) =>
+					return Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }),
+			}
+		}
+
+		while let Poll::Ready(Some(())) = self.garbage_collect.poll_next_unpin(cx) {
+			self.nodes_info.retain(|_, node| {
+				node.info_expire.as_ref().map(|exp| *exp >= Instant::now()).unwrap_or(true)
+			});
+		}
+
+		Poll::Pending
+	}
+}
diff --git a/substrate/client/network/src/peer_store.rs b/substrate/client/network/src/peer_store.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f3d4a1fd1a0b00ed8bbb17c90a997d956b8bca6
--- /dev/null
+++ b/substrate/client/network/src/peer_store.rs
@@ -0,0 +1,413 @@
+// 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/>.
+
+//! [`PeerStore`] manages peer reputations and provides connection candidates to
+//! [`crate::protocol_controller::ProtocolController`].
+
+use libp2p::PeerId;
+use log::trace;
+use parking_lot::Mutex;
+use partial_sort::PartialSort;
+use sc_network_common::types::ReputationChange;
+use std::{
+	cmp::{Ord, Ordering, PartialOrd},
+	collections::{hash_map::Entry, HashMap, HashSet},
+	fmt::Debug,
+	sync::Arc,
+	time::{Duration, Instant},
+};
+use wasm_timer::Delay;
+
+use crate::protocol_controller::ProtocolHandle;
+
+/// Log target for this file.
+pub const LOG_TARGET: &str = "peerset";
+
+/// We don't accept nodes whose reputation is under this value.
+pub const BANNED_THRESHOLD: i32 = 82 * (i32::MIN / 100);
+/// Reputation change for a node when we get disconnected from it.
+const DISCONNECT_REPUTATION_CHANGE: i32 = -256;
+/// Relative decrement of a reputation value that is applied every second. I.e., for inverse
+/// decrement of 50 we decrease absolute value of the reputation by 1/50. This corresponds to a
+/// factor of `k = 0.98`. It takes ~ `ln(0.5) / ln(k)` seconds to reduce the reputation by half,
+/// or 34.3 seconds for the values above. In this setup the maximum allowed absolute value of
+/// `i32::MAX` becomes 0 in ~1100 seconds (actually less due to integer arithmetic).
+const INVERSE_DECREMENT: i32 = 50;
+/// Amount of time between the moment we last updated the [`PeerStore`] entry and the moment we
+/// remove it, once the reputation value reaches 0.
+const FORGET_AFTER: Duration = Duration::from_secs(3600);
+
+/// Trait providing peer reputation management and connection candidates.
+pub trait PeerStoreProvider: Debug + Send {
+	/// Check whether the peer is banned.
+	fn is_banned(&self, peer_id: &PeerId) -> bool;
+
+	/// Register a protocol handle to disconnect peers whose reputation drops below the threshold.
+	fn register_protocol(&self, protocol_handle: ProtocolHandle);
+
+	/// Report peer disconnection for reputation adjustment.
+	fn report_disconnect(&mut self, peer_id: PeerId);
+
+	/// Adjust peer reputation.
+	fn report_peer(&mut self, peer_id: PeerId, change: ReputationChange);
+
+	/// Get peer reputation.
+	fn peer_reputation(&self, peer_id: &PeerId) -> i32;
+
+	/// Get candidates with highest reputations for initiating outgoing connections.
+	fn outgoing_candidates(&self, count: usize, ignored: HashSet<&PeerId>) -> Vec<PeerId>;
+}
+
+/// Actual implementation of peer reputations and connection candidates provider.
+#[derive(Debug, Clone)]
+pub struct PeerStoreHandle {
+	inner: Arc<Mutex<PeerStoreInner>>,
+}
+
+impl PeerStoreProvider for PeerStoreHandle {
+	fn is_banned(&self, peer_id: &PeerId) -> bool {
+		self.inner.lock().is_banned(peer_id)
+	}
+
+	fn register_protocol(&self, protocol_handle: ProtocolHandle) {
+		self.inner.lock().register_protocol(protocol_handle);
+	}
+
+	fn report_disconnect(&mut self, peer_id: PeerId) {
+		self.inner.lock().report_disconnect(peer_id)
+	}
+
+	fn report_peer(&mut self, peer_id: PeerId, change: ReputationChange) {
+		self.inner.lock().report_peer(peer_id, change)
+	}
+
+	fn peer_reputation(&self, peer_id: &PeerId) -> i32 {
+		self.inner.lock().peer_reputation(peer_id)
+	}
+
+	fn outgoing_candidates(&self, count: usize, ignored: HashSet<&PeerId>) -> Vec<PeerId> {
+		self.inner.lock().outgoing_candidates(count, ignored)
+	}
+}
+
+impl PeerStoreHandle {
+	/// Get the number of known peers.
+	///
+	/// This number might not include some connected peers in rare cases when their reputation
+	/// was not updated for one hour, because their entries in [`PeerStore`] were dropped.
+	pub fn num_known_peers(&self) -> usize {
+		self.inner.lock().peers.len()
+	}
+
+	/// Add known peer.
+	pub fn add_known_peer(&mut self, peer_id: PeerId) {
+		self.inner.lock().add_known_peer(peer_id);
+	}
+}
+
+#[derive(Debug, Clone, Copy)]
+struct PeerInfo {
+	reputation: i32,
+	last_updated: Instant,
+}
+
+impl Default for PeerInfo {
+	fn default() -> Self {
+		Self { reputation: 0, last_updated: Instant::now() }
+	}
+}
+
+impl PartialEq for PeerInfo {
+	fn eq(&self, other: &Self) -> bool {
+		self.reputation == other.reputation
+	}
+}
+
+impl Eq for PeerInfo {}
+
+impl Ord for PeerInfo {
+	// We define reverse order by reputation values.
+	fn cmp(&self, other: &Self) -> Ordering {
+		self.reputation.cmp(&other.reputation).reverse()
+	}
+}
+
+impl PartialOrd for PeerInfo {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl PeerInfo {
+	fn is_banned(&self) -> bool {
+		self.reputation < BANNED_THRESHOLD
+	}
+
+	fn add_reputation(&mut self, increment: i32) {
+		self.reputation = self.reputation.saturating_add(increment);
+		self.bump_last_updated();
+	}
+
+	fn decay_reputation(&mut self, seconds_passed: u64) {
+		// Note that decaying the reputation value happens "on its own",
+		// so we don't do `bump_last_updated()`.
+		for _ in 0..seconds_passed {
+			let mut diff = self.reputation / INVERSE_DECREMENT;
+			if diff == 0 && self.reputation < 0 {
+				diff = -1;
+			} else if diff == 0 && self.reputation > 0 {
+				diff = 1;
+			}
+
+			self.reputation = self.reputation.saturating_sub(diff);
+
+			if self.reputation == 0 {
+				break
+			}
+		}
+	}
+
+	fn bump_last_updated(&mut self) {
+		self.last_updated = Instant::now();
+	}
+}
+
+#[derive(Debug)]
+struct PeerStoreInner {
+	peers: HashMap<PeerId, PeerInfo>,
+	protocols: Vec<ProtocolHandle>,
+}
+
+impl PeerStoreInner {
+	fn is_banned(&self, peer_id: &PeerId) -> bool {
+		self.peers.get(peer_id).map_or(false, |info| info.is_banned())
+	}
+
+	fn register_protocol(&mut self, protocol_handle: ProtocolHandle) {
+		self.protocols.push(protocol_handle);
+	}
+
+	fn report_disconnect(&mut self, peer_id: PeerId) {
+		let peer_info = self.peers.entry(peer_id).or_default();
+		peer_info.add_reputation(DISCONNECT_REPUTATION_CHANGE);
+
+		log::trace!(
+			target: LOG_TARGET,
+			"Peer {} disconnected, reputation: {:+} to {}",
+			peer_id,
+			DISCONNECT_REPUTATION_CHANGE,
+			peer_info.reputation,
+		);
+	}
+
+	fn report_peer(&mut self, peer_id: PeerId, change: ReputationChange) {
+		let peer_info = self.peers.entry(peer_id).or_default();
+		peer_info.add_reputation(change.value);
+
+		if peer_info.reputation < BANNED_THRESHOLD {
+			self.protocols.iter().for_each(|handle| handle.disconnect_peer(peer_id));
+
+			log::trace!(
+				target: LOG_TARGET,
+				"Report {}: {:+} to {}. Reason: {}. Banned, disconnecting.",
+				peer_id,
+				change.value,
+				peer_info.reputation,
+				change.reason,
+			);
+		} else {
+			log::trace!(
+				target: LOG_TARGET,
+				"Report {}: {:+} to {}. Reason: {}.",
+				peer_id,
+				change.value,
+				peer_info.reputation,
+				change.reason,
+			);
+		}
+	}
+
+	fn peer_reputation(&self, peer_id: &PeerId) -> i32 {
+		self.peers.get(peer_id).map_or(0, |info| info.reputation)
+	}
+
+	fn outgoing_candidates(&self, count: usize, ignored: HashSet<&PeerId>) -> Vec<PeerId> {
+		let mut candidates = self
+			.peers
+			.iter()
+			.filter_map(|(peer_id, info)| {
+				(!info.is_banned() && !ignored.contains(peer_id)).then_some((*peer_id, *info))
+			})
+			.collect::<Vec<_>>();
+		let count = std::cmp::min(count, candidates.len());
+		candidates.partial_sort(count, |(_, info1), (_, info2)| info1.cmp(info2));
+		candidates.iter().take(count).map(|(peer_id, _)| *peer_id).collect()
+
+		// TODO: keep the peers sorted (in a "bi-multi-map"?) to not repeat sorting every time.
+	}
+
+	fn progress_time(&mut self, seconds_passed: u64) {
+		if seconds_passed == 0 {
+			return
+		}
+
+		// Drive reputation values towards 0.
+		self.peers
+			.iter_mut()
+			.for_each(|(_, info)| info.decay_reputation(seconds_passed));
+
+		// Retain only entries with non-zero reputation values or not expired ones.
+		let now = Instant::now();
+		self.peers
+			.retain(|_, info| info.reputation != 0 || info.last_updated + FORGET_AFTER > now);
+	}
+
+	fn add_known_peer(&mut self, peer_id: PeerId) {
+		match self.peers.entry(peer_id) {
+			Entry::Occupied(mut e) => {
+				trace!(
+					target: LOG_TARGET,
+					"Trying to add an already known peer {peer_id}, bumping `last_updated`.",
+				);
+				e.get_mut().bump_last_updated();
+			},
+			Entry::Vacant(e) => {
+				trace!(target: LOG_TARGET, "Adding a new known peer {peer_id}.");
+				e.insert(PeerInfo::default());
+			},
+		}
+	}
+}
+
+/// Worker part of [`PeerStoreHandle`]
+#[derive(Debug)]
+pub struct PeerStore {
+	inner: Arc<Mutex<PeerStoreInner>>,
+}
+
+impl PeerStore {
+	/// Create a new peer store from the list of bootnodes.
+	pub fn new(bootnodes: Vec<PeerId>) -> Self {
+		PeerStore {
+			inner: Arc::new(Mutex::new(PeerStoreInner {
+				peers: bootnodes
+					.into_iter()
+					.map(|peer_id| (peer_id, PeerInfo::default()))
+					.collect(),
+				protocols: Vec::new(),
+			})),
+		}
+	}
+
+	/// Get `PeerStoreHandle`.
+	pub fn handle(&self) -> PeerStoreHandle {
+		PeerStoreHandle { inner: self.inner.clone() }
+	}
+
+	/// Drive the `PeerStore`, decaying reputation values over time and removing expired entries.
+	pub async fn run(self) {
+		let started = Instant::now();
+		let mut latest_time_update = started;
+
+		loop {
+			let now = Instant::now();
+			// We basically do `(now - self.latest_update).as_secs()`, except that by the way we do
+			// it we know that we're not going to miss seconds because of rounding to integers.
+			let seconds_passed = {
+				let elapsed_latest = latest_time_update - started;
+				let elapsed_now = now - started;
+				latest_time_update = now;
+				elapsed_now.as_secs() - elapsed_latest.as_secs()
+			};
+
+			self.inner.lock().progress_time(seconds_passed);
+			let _ = Delay::new(Duration::from_secs(1)).await;
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::PeerInfo;
+
+	#[test]
+	fn decaying_zero_reputation_yields_zero() {
+		let mut peer_info = PeerInfo::default();
+		assert_eq!(peer_info.reputation, 0);
+
+		peer_info.decay_reputation(1);
+		assert_eq!(peer_info.reputation, 0);
+
+		peer_info.decay_reputation(100_000);
+		assert_eq!(peer_info.reputation, 0);
+	}
+
+	#[test]
+	fn decaying_positive_reputation_decreases_it() {
+		const INITIAL_REPUTATION: i32 = 100;
+
+		let mut peer_info = PeerInfo::default();
+		peer_info.reputation = INITIAL_REPUTATION;
+
+		peer_info.decay_reputation(1);
+		assert!(peer_info.reputation >= 0);
+		assert!(peer_info.reputation < INITIAL_REPUTATION);
+	}
+
+	#[test]
+	fn decaying_negative_reputation_increases_it() {
+		const INITIAL_REPUTATION: i32 = -100;
+
+		let mut peer_info = PeerInfo::default();
+		peer_info.reputation = INITIAL_REPUTATION;
+
+		peer_info.decay_reputation(1);
+		assert!(peer_info.reputation <= 0);
+		assert!(peer_info.reputation > INITIAL_REPUTATION);
+	}
+
+	#[test]
+	fn decaying_max_reputation_finally_yields_zero() {
+		const INITIAL_REPUTATION: i32 = i32::MAX;
+		const SECONDS: u64 = 1000;
+
+		let mut peer_info = PeerInfo::default();
+		peer_info.reputation = INITIAL_REPUTATION;
+
+		peer_info.decay_reputation(SECONDS / 2);
+		assert!(peer_info.reputation > 0);
+
+		peer_info.decay_reputation(SECONDS / 2);
+		assert_eq!(peer_info.reputation, 0);
+	}
+
+	#[test]
+	fn decaying_min_reputation_finally_yields_zero() {
+		const INITIAL_REPUTATION: i32 = i32::MIN;
+		const SECONDS: u64 = 1000;
+
+		let mut peer_info = PeerInfo::default();
+		peer_info.reputation = INITIAL_REPUTATION;
+
+		peer_info.decay_reputation(SECONDS / 2);
+		assert!(peer_info.reputation < 0);
+
+		peer_info.decay_reputation(SECONDS / 2);
+		assert_eq!(peer_info.reputation, 0);
+	}
+}
diff --git a/substrate/client/network/src/protocol.rs b/substrate/client/network/src/protocol.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9b94f288352841073840dc07bba4cbbab581b204
--- /dev/null
+++ b/substrate/client/network/src/protocol.rs
@@ -0,0 +1,510 @@
+// 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::{
+	config, error,
+	peer_store::{PeerStoreHandle, PeerStoreProvider},
+	protocol_controller::{self, SetId},
+	types::ProtocolName,
+};
+
+use bytes::Bytes;
+use codec::{DecodeAll, Encode};
+use futures::{channel::oneshot, stream::FuturesUnordered, StreamExt};
+use libp2p::{
+	core::Endpoint,
+	swarm::{
+		behaviour::FromSwarm, ConnectionDenied, ConnectionId, NetworkBehaviour, PollParameters,
+		THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
+	},
+	Multiaddr, PeerId,
+};
+use log::{debug, error, warn};
+
+use sc_network_common::{role::Roles, sync::message::BlockAnnouncesHandshake};
+use sc_utils::mpsc::{TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_runtime::traits::Block as BlockT;
+
+use std::{
+	collections::{HashMap, HashSet},
+	future::Future,
+	iter,
+	pin::Pin,
+	task::Poll,
+};
+
+use message::{generic::Message as GenericMessage, Message};
+use notifications::{Notifications, NotificationsOut};
+
+pub use notifications::{NotificationsSink, NotifsHandlerError, Ready};
+
+mod notifications;
+
+pub mod message;
+
+/// Maximum size used for notifications in the block announce and transaction protocols.
+// Must be equal to `max(MAX_BLOCK_ANNOUNCE_SIZE, MAX_TRANSACTIONS_SIZE)`.
+pub(crate) const BLOCK_ANNOUNCES_TRANSACTIONS_SUBSTREAM_SIZE: u64 = 16 * 1024 * 1024;
+
+/// Identifier of the peerset for the block announces protocol.
+const HARDCODED_PEERSETS_SYNC: SetId = SetId::from(0);
+
+mod rep {
+	use crate::ReputationChange as Rep;
+	/// We received a message that failed to decode.
+	pub const BAD_MESSAGE: Rep = Rep::new(-(1 << 12), "Bad message");
+}
+
+type PendingSyncSubstreamValidation =
+	Pin<Box<dyn Future<Output = Result<(PeerId, Roles), PeerId>> + Send>>;
+
+// Lock must always be taken in order declared here.
+pub struct Protocol<B: BlockT> {
+	/// Used to report reputation changes.
+	peer_store_handle: PeerStoreHandle,
+	/// Handles opening the unique substream and sending and receiving raw messages.
+	behaviour: Notifications,
+	/// List of notifications protocols that have been registered.
+	notification_protocols: Vec<ProtocolName>,
+	/// If we receive a new "substream open" event that contains an invalid handshake, we ask the
+	/// inner layer to force-close the substream. Force-closing the substream will generate a
+	/// "substream closed" event. This is a problem: since we can't propagate the "substream open"
+	/// event to the outer layers, we also shouldn't propagate this "substream closed" event. To
+	/// solve this, an entry is added to this map whenever an invalid handshake is received.
+	/// Entries are removed when the corresponding "substream closed" is later received.
+	bad_handshake_substreams: HashSet<(PeerId, SetId)>,
+	/// Connected peers on sync protocol.
+	peers: HashMap<PeerId, Roles>,
+	sync_substream_validations: FuturesUnordered<PendingSyncSubstreamValidation>,
+	tx: TracingUnboundedSender<crate::event::SyncEvent<B>>,
+	_marker: std::marker::PhantomData<B>,
+}
+
+impl<B: BlockT> Protocol<B> {
+	/// Create a new instance.
+	pub fn new(
+		roles: Roles,
+		notification_protocols: Vec<config::NonDefaultSetConfig>,
+		block_announces_protocol: config::NonDefaultSetConfig,
+		peer_store_handle: PeerStoreHandle,
+		protocol_controller_handles: Vec<protocol_controller::ProtocolHandle>,
+		from_protocol_controllers: TracingUnboundedReceiver<protocol_controller::Message>,
+		tx: TracingUnboundedSender<crate::event::SyncEvent<B>>,
+	) -> error::Result<Self> {
+		let behaviour = {
+			Notifications::new(
+				protocol_controller_handles,
+				from_protocol_controllers,
+				// NOTE: Block announcement protocol is still very much hardcoded into `Protocol`.
+				// 	This protocol must be the first notification protocol given to
+				// `Notifications`
+				iter::once(notifications::ProtocolConfig {
+					name: block_announces_protocol.notifications_protocol.clone(),
+					fallback_names: block_announces_protocol.fallback_names.clone(),
+					handshake: block_announces_protocol.handshake.as_ref().unwrap().to_vec(),
+					max_notification_size: block_announces_protocol.max_notification_size,
+				})
+				.chain(notification_protocols.iter().map(|s| notifications::ProtocolConfig {
+					name: s.notifications_protocol.clone(),
+					fallback_names: s.fallback_names.clone(),
+					handshake: s.handshake.as_ref().map_or(roles.encode(), |h| (*h).to_vec()),
+					max_notification_size: s.max_notification_size,
+				})),
+			)
+		};
+
+		let protocol = Self {
+			peer_store_handle,
+			behaviour,
+			notification_protocols: iter::once(block_announces_protocol.notifications_protocol)
+				.chain(notification_protocols.iter().map(|s| s.notifications_protocol.clone()))
+				.collect(),
+			bad_handshake_substreams: Default::default(),
+			peers: HashMap::new(),
+			sync_substream_validations: FuturesUnordered::new(),
+			tx,
+			// TODO: remove when `BlockAnnouncesHandshake` is moved away from `Protocol`
+			_marker: Default::default(),
+		};
+
+		Ok(protocol)
+	}
+
+	/// Returns the list of all the peers we have an open channel to.
+	pub fn open_peers(&self) -> impl Iterator<Item = &PeerId> {
+		self.behaviour.open_peers()
+	}
+
+	/// Disconnects the given peer if we are connected to it.
+	pub fn disconnect_peer(&mut self, peer_id: &PeerId, protocol_name: ProtocolName) {
+		if let Some(position) = self.notification_protocols.iter().position(|p| *p == protocol_name)
+		{
+			// Note: no need to remove a peer from `self.peers` if we are dealing with sync
+			// protocol, because it will be done when handling
+			// `NotificationsOut::CustomProtocolClosed`.
+			self.behaviour.disconnect_peer(peer_id, SetId::from(position));
+		} else {
+			warn!(target: "sub-libp2p", "disconnect_peer() with invalid protocol name")
+		}
+	}
+
+	/// Returns the number of peers we're connected to on sync protocol.
+	pub fn num_connected_peers(&self) -> usize {
+		self.peers.len()
+	}
+
+	/// Set handshake for the notification protocol.
+	pub fn set_notification_handshake(&mut self, protocol: ProtocolName, handshake: Vec<u8>) {
+		if let Some(index) = self.notification_protocols.iter().position(|p| *p == protocol) {
+			self.behaviour.set_notif_protocol_handshake(SetId::from(index), handshake);
+		} else {
+			error!(
+				target: "sub-libp2p",
+				"set_notification_handshake with unknown protocol: {}",
+				protocol
+			);
+		}
+	}
+}
+
+/// Outcome of an incoming custom message.
+#[derive(Debug)]
+#[must_use]
+pub enum CustomMessageOutcome {
+	/// Notification protocols have been opened with a remote.
+	NotificationStreamOpened {
+		remote: PeerId,
+		protocol: ProtocolName,
+		/// See [`crate::Event::NotificationStreamOpened::negotiated_fallback`].
+		negotiated_fallback: Option<ProtocolName>,
+		roles: Roles,
+		received_handshake: Vec<u8>,
+		notifications_sink: NotificationsSink,
+	},
+	/// The [`NotificationsSink`] of some notification protocols need an update.
+	NotificationStreamReplaced {
+		remote: PeerId,
+		protocol: ProtocolName,
+		notifications_sink: NotificationsSink,
+	},
+	/// Notification protocols have been closed with a remote.
+	NotificationStreamClosed { remote: PeerId, protocol: ProtocolName },
+	/// Messages have been received on one or more notifications protocols.
+	NotificationsReceived { remote: PeerId, messages: Vec<(ProtocolName, Bytes)> },
+	/// Now connected to a new peer for syncing purposes.
+	None,
+}
+
+impl<B: BlockT> NetworkBehaviour for Protocol<B> {
+	type ConnectionHandler = <Notifications as NetworkBehaviour>::ConnectionHandler;
+	type OutEvent = CustomMessageOutcome;
+
+	fn handle_established_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		self.behaviour.handle_established_inbound_connection(
+			connection_id,
+			peer,
+			local_addr,
+			remote_addr,
+		)
+	}
+
+	fn handle_established_outbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		addr: &Multiaddr,
+		role_override: Endpoint,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		self.behaviour.handle_established_outbound_connection(
+			connection_id,
+			peer,
+			addr,
+			role_override,
+		)
+	}
+
+	fn handle_pending_outbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		_maybe_peer: Option<PeerId>,
+		_addresses: &[Multiaddr],
+		_effective_role: Endpoint,
+	) -> Result<Vec<Multiaddr>, ConnectionDenied> {
+		// Only `Discovery::handle_pending_outbound_connection` must be returning addresses to
+		// ensure that we don't return unwanted addresses.
+		Ok(Vec::new())
+	}
+
+	fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+		self.behaviour.on_swarm_event(event);
+	}
+
+	fn on_connection_handler_event(
+		&mut self,
+		peer_id: PeerId,
+		connection_id: ConnectionId,
+		event: THandlerOutEvent<Self>,
+	) {
+		self.behaviour.on_connection_handler_event(peer_id, connection_id, event);
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut std::task::Context,
+		params: &mut impl PollParameters,
+	) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
+		while let Poll::Ready(Some(validation_result)) =
+			self.sync_substream_validations.poll_next_unpin(cx)
+		{
+			match validation_result {
+				Ok((peer, roles)) => {
+					self.peers.insert(peer, roles);
+				},
+				Err(peer) => {
+					log::debug!(
+						target: "sub-libp2p",
+						"`SyncingEngine` rejected stream"
+					);
+					self.behaviour.disconnect_peer(&peer, HARDCODED_PEERSETS_SYNC);
+				},
+			}
+		}
+
+		let event = match self.behaviour.poll(cx, params) {
+			Poll::Pending => return Poll::Pending,
+			Poll::Ready(ToSwarm::GenerateEvent(ev)) => ev,
+			Poll::Ready(ToSwarm::Dial { opts }) => return Poll::Ready(ToSwarm::Dial { opts }),
+			Poll::Ready(ToSwarm::NotifyHandler { peer_id, handler, event }) =>
+				return Poll::Ready(ToSwarm::NotifyHandler { peer_id, handler, event }),
+			Poll::Ready(ToSwarm::ReportObservedAddr { address, score }) =>
+				return Poll::Ready(ToSwarm::ReportObservedAddr { address, score }),
+			Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }) =>
+				return Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }),
+		};
+
+		let outcome = match event {
+			NotificationsOut::CustomProtocolOpen {
+				peer_id,
+				set_id,
+				received_handshake,
+				notifications_sink,
+				negotiated_fallback,
+				inbound,
+			} => {
+				// Set number 0 is hardcoded the default set of peers we sync from.
+				if set_id == HARDCODED_PEERSETS_SYNC {
+					// `received_handshake` can be either a `Status` message if received from the
+					// legacy substream ,or a `BlockAnnouncesHandshake` if received from the block
+					// announces substream.
+					match <Message<B> as DecodeAll>::decode_all(&mut &received_handshake[..]) {
+						Ok(GenericMessage::Status(handshake)) => {
+							let roles = handshake.roles;
+							let handshake = BlockAnnouncesHandshake::<B> {
+								roles: handshake.roles,
+								best_number: handshake.best_number,
+								best_hash: handshake.best_hash,
+								genesis_hash: handshake.genesis_hash,
+							};
+
+							let (tx, rx) = oneshot::channel();
+							let _ = self.tx.unbounded_send(
+								crate::SyncEvent::NotificationStreamOpened {
+									inbound,
+									remote: peer_id,
+									received_handshake: handshake,
+									sink: notifications_sink,
+									tx,
+								},
+							);
+							self.sync_substream_validations.push(Box::pin(async move {
+								match rx.await {
+									Ok(accepted) =>
+										if accepted {
+											Ok((peer_id, roles))
+										} else {
+											Err(peer_id)
+										},
+									Err(_) => Err(peer_id),
+								}
+							}));
+
+							CustomMessageOutcome::None
+						},
+						Ok(msg) => {
+							debug!(
+								target: "sync",
+								"Expected Status message from {}, but got {:?}",
+								peer_id,
+								msg,
+							);
+							self.peer_store_handle.report_peer(peer_id, rep::BAD_MESSAGE);
+							CustomMessageOutcome::None
+						},
+						Err(err) => {
+							match <BlockAnnouncesHandshake<B> as DecodeAll>::decode_all(
+								&mut &received_handshake[..],
+							) {
+								Ok(handshake) => {
+									let roles = handshake.roles;
+
+									let (tx, rx) = oneshot::channel();
+									let _ = self.tx.unbounded_send(
+										crate::SyncEvent::NotificationStreamOpened {
+											inbound,
+											remote: peer_id,
+											received_handshake: handshake,
+											sink: notifications_sink,
+											tx,
+										},
+									);
+									self.sync_substream_validations.push(Box::pin(async move {
+										match rx.await {
+											Ok(accepted) =>
+												if accepted {
+													Ok((peer_id, roles))
+												} else {
+													Err(peer_id)
+												},
+											Err(_) => Err(peer_id),
+										}
+									}));
+									CustomMessageOutcome::None
+								},
+								Err(err2) => {
+									log::debug!(
+										target: "sync",
+										"Couldn't decode handshake sent by {}: {:?}: {} & {}",
+										peer_id,
+										received_handshake,
+										err,
+										err2,
+									);
+									self.peer_store_handle.report_peer(peer_id, rep::BAD_MESSAGE);
+									CustomMessageOutcome::None
+								},
+							}
+						},
+					}
+				} else {
+					match (
+						Roles::decode_all(&mut &received_handshake[..]),
+						self.peers.get(&peer_id),
+					) {
+						(Ok(roles), _) => CustomMessageOutcome::NotificationStreamOpened {
+							remote: peer_id,
+							protocol: self.notification_protocols[usize::from(set_id)].clone(),
+							negotiated_fallback,
+							roles,
+							received_handshake,
+							notifications_sink,
+						},
+						(Err(_), Some(roles)) if received_handshake.is_empty() => {
+							// As a convenience, we allow opening substreams for "external"
+							// notification protocols with an empty handshake. This fetches the
+							// roles from the locally-known roles.
+							// TODO: remove this after https://github.com/paritytech/substrate/issues/5685
+							CustomMessageOutcome::NotificationStreamOpened {
+								remote: peer_id,
+								protocol: self.notification_protocols[usize::from(set_id)].clone(),
+								negotiated_fallback,
+								roles: *roles,
+								received_handshake,
+								notifications_sink,
+							}
+						},
+						(Err(err), _) => {
+							debug!(target: "sync", "Failed to parse remote handshake: {}", err);
+							self.bad_handshake_substreams.insert((peer_id, set_id));
+							self.behaviour.disconnect_peer(&peer_id, set_id);
+							self.peer_store_handle.report_peer(peer_id, rep::BAD_MESSAGE);
+							CustomMessageOutcome::None
+						},
+					}
+				}
+			},
+			NotificationsOut::CustomProtocolReplaced { peer_id, notifications_sink, set_id } =>
+				if self.bad_handshake_substreams.contains(&(peer_id, set_id)) {
+					CustomMessageOutcome::None
+				} else if set_id == HARDCODED_PEERSETS_SYNC {
+					let _ = self.tx.unbounded_send(crate::SyncEvent::NotificationSinkReplaced {
+						remote: peer_id,
+						sink: notifications_sink,
+					});
+					CustomMessageOutcome::None
+				} else {
+					CustomMessageOutcome::NotificationStreamReplaced {
+						remote: peer_id,
+						protocol: self.notification_protocols[usize::from(set_id)].clone(),
+						notifications_sink,
+					}
+				},
+			NotificationsOut::CustomProtocolClosed { peer_id, set_id } => {
+				if self.bad_handshake_substreams.remove(&(peer_id, set_id)) {
+					// The substream that has just been closed had been opened with a bad
+					// handshake. The outer layers have never received an opening event about this
+					// substream, and consequently shouldn't receive a closing event either.
+					CustomMessageOutcome::None
+				} else if set_id == HARDCODED_PEERSETS_SYNC {
+					let _ = self.tx.unbounded_send(crate::SyncEvent::NotificationStreamClosed {
+						remote: peer_id,
+					});
+					self.peers.remove(&peer_id);
+					CustomMessageOutcome::None
+				} else {
+					CustomMessageOutcome::NotificationStreamClosed {
+						remote: peer_id,
+						protocol: self.notification_protocols[usize::from(set_id)].clone(),
+					}
+				}
+			},
+			NotificationsOut::Notification { peer_id, set_id, message } => {
+				if self.bad_handshake_substreams.contains(&(peer_id, set_id)) {
+					CustomMessageOutcome::None
+				} else if set_id == HARDCODED_PEERSETS_SYNC {
+					let _ = self.tx.unbounded_send(crate::SyncEvent::NotificationsReceived {
+						remote: peer_id,
+						messages: vec![message.freeze()],
+					});
+					CustomMessageOutcome::None
+				} else {
+					let protocol_name = self.notification_protocols[usize::from(set_id)].clone();
+					CustomMessageOutcome::NotificationsReceived {
+						remote: peer_id,
+						messages: vec![(protocol_name, message.freeze())],
+					}
+				}
+			},
+		};
+
+		if !matches!(outcome, CustomMessageOutcome::None) {
+			return Poll::Ready(ToSwarm::GenerateEvent(outcome))
+		}
+
+		// This block can only be reached if an event was pulled from the behaviour and that
+		// resulted in `CustomMessageOutcome::None`. Since there might be another pending
+		// message from the behaviour, the task is scheduled again.
+		cx.waker().wake_by_ref();
+		Poll::Pending
+	}
+}
diff --git a/substrate/client/network/src/protocol/message.rs b/substrate/client/network/src/protocol/message.rs
new file mode 100644
index 0000000000000000000000000000000000000000..66dca2975375f9886b6f15513c2debf09883db03
--- /dev/null
+++ b/substrate/client/network/src/protocol/message.rs
@@ -0,0 +1,290 @@
+// 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/>.
+
+//! Network packet message types. These get serialized and put into the lower level protocol
+//! payload.
+
+pub use self::generic::{
+	RemoteCallRequest, RemoteChangesRequest, RemoteChangesResponse, RemoteHeaderRequest,
+	RemoteHeaderResponse, RemoteReadChildRequest, RemoteReadRequest,
+};
+use codec::{Decode, Encode};
+use sc_client_api::StorageProof;
+use sc_network_common::message::RequestId;
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+
+/// Type alias for using the message type using block type parameters.
+pub type Message<B> = generic::Message<
+	<B as BlockT>::Header,
+	<B as BlockT>::Hash,
+	<<B as BlockT>::Header as HeaderT>::Number,
+	<B as BlockT>::Extrinsic,
+>;
+
+/// Remote call response.
+#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+pub struct RemoteCallResponse {
+	/// Id of a request this response was made for.
+	pub id: RequestId,
+	/// Execution proof.
+	pub proof: StorageProof,
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+/// Remote read response.
+pub struct RemoteReadResponse {
+	/// Id of a request this response was made for.
+	pub id: RequestId,
+	/// Read proof.
+	pub proof: StorageProof,
+}
+
+/// Generic types.
+pub mod generic {
+	use super::{RemoteCallResponse, RemoteReadResponse};
+	use codec::{Decode, Encode, Input};
+	use sc_client_api::StorageProof;
+	use sc_network_common::{
+		message::RequestId,
+		role::Roles,
+		sync::message::{
+			generic::{BlockRequest, BlockResponse},
+			BlockAnnounce,
+		},
+	};
+	use sp_runtime::ConsensusEngineId;
+
+	/// Consensus is mostly opaque to us
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	pub struct ConsensusMessage {
+		/// Identifies consensus engine.
+		pub protocol: ConsensusEngineId,
+		/// Message payload.
+		pub data: Vec<u8>,
+	}
+
+	/// A network message.
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	pub enum Message<Header, Hash, Number, Extrinsic> {
+		/// Status packet.
+		Status(Status<Hash, Number>),
+		/// Block request.
+		BlockRequest(BlockRequest<Hash, Number>),
+		/// Block response.
+		BlockResponse(BlockResponse<Header, Hash, Extrinsic>),
+		/// Block announce.
+		BlockAnnounce(BlockAnnounce<Header>),
+		/// Consensus protocol message.
+		// NOTE: index is incremented by 1 due to transaction-related
+		// message that was removed
+		#[codec(index = 6)]
+		Consensus(ConsensusMessage),
+		/// Remote method call request.
+		RemoteCallRequest(RemoteCallRequest<Hash>),
+		/// Remote method call response.
+		RemoteCallResponse(RemoteCallResponse),
+		/// Remote storage read request.
+		RemoteReadRequest(RemoteReadRequest<Hash>),
+		/// Remote storage read response.
+		RemoteReadResponse(RemoteReadResponse),
+		/// Remote header request.
+		RemoteHeaderRequest(RemoteHeaderRequest<Number>),
+		/// Remote header response.
+		RemoteHeaderResponse(RemoteHeaderResponse<Header>),
+		/// Remote changes request.
+		RemoteChangesRequest(RemoteChangesRequest<Hash>),
+		/// Remote changes response.
+		RemoteChangesResponse(RemoteChangesResponse<Number, Hash>),
+		/// Remote child storage read request.
+		RemoteReadChildRequest(RemoteReadChildRequest<Hash>),
+		/// Batch of consensus protocol messages.
+		// NOTE: index is incremented by 2 due to finality proof related
+		// messages that were removed.
+		#[codec(index = 17)]
+		ConsensusBatch(Vec<ConsensusMessage>),
+	}
+
+	/// Status sent on connection.
+	// TODO https://github.com/paritytech/substrate/issues/4674: replace the `Status`
+	// struct with this one, after waiting a few releases beyond `NetworkSpecialization`'s
+	// removal (https://github.com/paritytech/substrate/pull/4665)
+	//
+	// and set MIN_VERSION to 6.
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	pub struct CompactStatus<Hash, Number> {
+		/// Protocol version.
+		pub version: u32,
+		/// Minimum supported version.
+		pub min_supported_version: u32,
+		/// Supported roles.
+		pub roles: Roles,
+		/// Best block number.
+		pub best_number: Number,
+		/// Best block hash.
+		pub best_hash: Hash,
+		/// Genesis block hash.
+		pub genesis_hash: Hash,
+	}
+
+	/// Status sent on connection.
+	#[derive(Debug, PartialEq, Eq, Clone, Encode)]
+	pub struct Status<Hash, Number> {
+		/// Protocol version.
+		pub version: u32,
+		/// Minimum supported version.
+		pub min_supported_version: u32,
+		/// Supported roles.
+		pub roles: Roles,
+		/// Best block number.
+		pub best_number: Number,
+		/// Best block hash.
+		pub best_hash: Hash,
+		/// Genesis block hash.
+		pub genesis_hash: Hash,
+		/// DEPRECATED. Chain-specific status.
+		pub chain_status: Vec<u8>,
+	}
+
+	impl<Hash: Decode, Number: Decode> Decode for Status<Hash, Number> {
+		fn decode<I: Input>(value: &mut I) -> Result<Self, codec::Error> {
+			const LAST_CHAIN_STATUS_VERSION: u32 = 5;
+			let compact = CompactStatus::decode(value)?;
+			let chain_status = match <Vec<u8>>::decode(value) {
+				Ok(v) => v,
+				Err(e) =>
+					if compact.version <= LAST_CHAIN_STATUS_VERSION {
+						return Err(e)
+					} else {
+						Vec::new()
+					},
+			};
+
+			let CompactStatus {
+				version,
+				min_supported_version,
+				roles,
+				best_number,
+				best_hash,
+				genesis_hash,
+			} = compact;
+
+			Ok(Self {
+				version,
+				min_supported_version,
+				roles,
+				best_number,
+				best_hash,
+				genesis_hash,
+				chain_status,
+			})
+		}
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	/// Remote call request.
+	pub struct RemoteCallRequest<H> {
+		/// Unique request id.
+		pub id: RequestId,
+		/// Block at which to perform call.
+		pub block: H,
+		/// Method name.
+		pub method: String,
+		/// Call data.
+		pub data: Vec<u8>,
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	/// Remote storage read request.
+	pub struct RemoteReadRequest<H> {
+		/// Unique request id.
+		pub id: RequestId,
+		/// Block at which to perform call.
+		pub block: H,
+		/// Storage key.
+		pub keys: Vec<Vec<u8>>,
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	/// Remote storage read child request.
+	pub struct RemoteReadChildRequest<H> {
+		/// Unique request id.
+		pub id: RequestId,
+		/// Block at which to perform call.
+		pub block: H,
+		/// Child Storage key.
+		pub storage_key: Vec<u8>,
+		/// Storage key.
+		pub keys: Vec<Vec<u8>>,
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	/// Remote header request.
+	pub struct RemoteHeaderRequest<N> {
+		/// Unique request id.
+		pub id: RequestId,
+		/// Block number to request header for.
+		pub block: N,
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	/// Remote header response.
+	pub struct RemoteHeaderResponse<Header> {
+		/// Id of a request this response was made for.
+		pub id: RequestId,
+		/// Header. None if proof generation has failed (e.g. header is unknown).
+		pub header: Option<Header>,
+		/// Header proof.
+		pub proof: StorageProof,
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	/// Remote changes request.
+	pub struct RemoteChangesRequest<H> {
+		/// Unique request id.
+		pub id: RequestId,
+		/// Hash of the first block of the range (including first) where changes are requested.
+		pub first: H,
+		/// Hash of the last block of the range (including last) where changes are requested.
+		pub last: H,
+		/// Hash of the first block for which the requester has the changes trie root. All other
+		/// affected roots must be proved.
+		pub min: H,
+		/// Hash of the last block that we can use when querying changes.
+		pub max: H,
+		/// Storage child node key which changes are requested.
+		pub storage_key: Option<Vec<u8>>,
+		/// Storage key which changes are requested.
+		pub key: Vec<u8>,
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode)]
+	/// Remote changes response.
+	pub struct RemoteChangesResponse<N, H> {
+		/// Id of a request this response was made for.
+		pub id: RequestId,
+		/// Proof has been generated using block with this number as a max block. Should be
+		/// less than or equal to the RemoteChangesRequest::max block number.
+		pub max: N,
+		/// Changes proof.
+		pub proof: Vec<Vec<u8>>,
+		/// Changes tries roots missing on the requester' node.
+		pub roots: Vec<(N, H)>,
+		/// Missing changes tries roots proof.
+		pub roots_proof: StorageProof,
+	}
+}
diff --git a/substrate/client/network/src/protocol/notifications.rs b/substrate/client/network/src/protocol/notifications.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa49cfcf9d44e230d7948e9ef251f81734e8ff07
--- /dev/null
+++ b/substrate/client/network/src/protocol/notifications.rs
@@ -0,0 +1,30 @@
+// 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/>.
+
+//! Implementation of libp2p's `NetworkBehaviour` trait that establishes communications and opens
+//! notifications substreams.
+
+pub use self::{
+	behaviour::{Notifications, NotificationsOut, ProtocolConfig},
+	handler::{NotificationsSink, NotifsHandlerError, Ready},
+};
+
+mod behaviour;
+mod handler;
+mod tests;
+mod upgrade;
diff --git a/substrate/client/network/src/protocol/notifications/behaviour.rs b/substrate/client/network/src/protocol/notifications/behaviour.rs
new file mode 100644
index 0000000000000000000000000000000000000000..89513e004c6df701d6bfc93f023282629abac782
--- /dev/null
+++ b/substrate/client/network/src/protocol/notifications/behaviour.rs
@@ -0,0 +1,4567 @@
+// 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::{
+	protocol::notifications::handler::{
+		self, NotificationsSink, NotifsHandler, NotifsHandlerIn, NotifsHandlerOut,
+	},
+	protocol_controller::{self, IncomingIndex, Message, SetId},
+	types::ProtocolName,
+};
+
+use bytes::BytesMut;
+use fnv::FnvHashMap;
+use futures::prelude::*;
+use libp2p::{
+	core::{ConnectedPoint, Endpoint, Multiaddr},
+	swarm::{
+		behaviour::{ConnectionClosed, ConnectionEstablished, DialFailure, FromSwarm},
+		ConnectionDenied, ConnectionId, DialError, NetworkBehaviour, NotifyHandler, PollParameters,
+		THandler, THandlerInEvent, THandlerOutEvent, ToSwarm,
+	},
+	PeerId,
+};
+use log::{debug, error, info, trace, warn};
+use parking_lot::RwLock;
+use rand::distributions::{Distribution as _, Uniform};
+use sc_utils::mpsc::TracingUnboundedReceiver;
+use smallvec::SmallVec;
+use std::{
+	cmp,
+	collections::{hash_map::Entry, VecDeque},
+	mem,
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+	time::{Duration, Instant},
+};
+
+/// Network behaviour that handles opening substreams for custom protocols with other peers.
+///
+/// # How it works
+///
+/// The role of the `Notifications` is to synchronize the following components:
+///
+/// - The libp2p swarm that opens new connections and reports disconnects.
+/// - The connection handler (see `group.rs`) that handles individual connections.
+/// - The peerset manager (PSM) that requests links to peers to be established or broken.
+/// - The external API, that requires knowledge of the links that have been established.
+///
+/// In the state machine below, each `PeerId` is attributed one of these states:
+///
+/// - [`PeerState::Requested`]: No open connection, but requested by the peerset. Currently dialing.
+/// - [`PeerState::Disabled`]: Has open TCP connection(s) unbeknownst to the peerset. No substream
+///   is open.
+/// - [`PeerState::Enabled`]: Has open TCP connection(s), acknowledged by the peerset.
+///   - Notifications substreams are open on at least one connection, and external API has been
+///     notified.
+///   - Notifications substreams aren't open.
+/// - [`PeerState::Incoming`]: Has open TCP connection(s) and remote would like to open substreams.
+///   Peerset has been asked to attribute an inbound slot.
+///
+/// In addition to these states, there also exists a "banning" system. If we fail to dial a peer,
+/// we back-off for a few seconds. If the PSM requests connecting to a peer that is currently
+/// backed-off, the next dialing attempt is delayed until after the ban expires. However, the PSM
+/// will still consider the peer to be connected. This "ban" is thus not a ban in a strict sense:
+/// if a backed-off peer tries to connect, the connection is accepted. A ban only delays dialing
+/// attempts.
+///
+/// There may be multiple connections to a peer. The status of a peer on
+/// the API of this behaviour and towards the peerset manager is aggregated in
+/// the following way:
+///
+///   1. The enabled/disabled status is the same across all connections, as decided by the peerset
+///      manager.
+///   2. `send_packet` and `write_notification` always send all data over the same connection to
+///      preserve the ordering provided by the transport, as long as that connection is open. If it
+///      closes, a second open connection may take over, if one exists, but that case should be no
+///      different than a single connection failing and being re-established in terms of potential
+///      reordering and dropped messages. Messages can be received on any connection.
+///   3. The behaviour reports `NotificationsOut::CustomProtocolOpen` when the first connection
+///      reports `NotifsHandlerOut::OpenResultOk`.
+///   4. The behaviour reports `NotificationsOut::CustomProtocolClosed` when the last connection
+///      reports `NotifsHandlerOut::ClosedResult`.
+///
+/// In this way, the number of actual established connections to the peer is
+/// an implementation detail of this behaviour. Note that, in practice and at
+/// the time of this writing, there may be at most two connections to a peer
+/// and only as a result of simultaneous dialing. However, the implementation
+/// accommodates for any number of connections.
+pub struct Notifications {
+	/// Notification protocols. Entries never change after initialization.
+	notif_protocols: Vec<handler::ProtocolConfig>,
+
+	/// Protocol controllers are responsible for peer connections management.
+	protocol_controller_handles: Vec<protocol_controller::ProtocolHandle>,
+
+	/// Receiver for instructions about who to connect to or disconnect from.
+	from_protocol_controllers: TracingUnboundedReceiver<Message>,
+
+	/// List of peers in our state.
+	peers: FnvHashMap<(PeerId, SetId), PeerState>,
+
+	/// The elements in `peers` occasionally contain `Delay` objects that we would normally have
+	/// to be polled one by one. In order to avoid doing so, as an optimization, every `Delay` is
+	/// instead put inside of `delays` and reference by a [`DelayId`]. This stream
+	/// yields `PeerId`s whose `DelayId` is potentially ready.
+	///
+	/// By design, we never remove elements from this list. Elements are removed only when the
+	/// `Delay` triggers. As such, this stream may produce obsolete elements.
+	delays:
+		stream::FuturesUnordered<Pin<Box<dyn Future<Output = (DelayId, PeerId, SetId)> + Send>>>,
+
+	/// [`DelayId`] to assign to the next delay.
+	next_delay_id: DelayId,
+
+	/// List of incoming messages we have sent to the peer set manager and that are waiting for an
+	/// answer.
+	incoming: SmallVec<[IncomingPeer; 6]>,
+
+	/// We generate indices to identify incoming connections. This is the next value for the index
+	/// to use when a connection is incoming.
+	next_incoming_index: IncomingIndex,
+
+	/// Events to produce from `poll()`.
+	events: VecDeque<ToSwarm<NotificationsOut, NotifsHandlerIn>>,
+}
+
+/// Configuration for a notifications protocol.
+#[derive(Debug, Clone)]
+pub struct ProtocolConfig {
+	/// Name of the protocol.
+	pub name: ProtocolName,
+	/// Names of the protocol to use if the main one isn't available.
+	pub fallback_names: Vec<ProtocolName>,
+	/// Handshake of the protocol.
+	pub handshake: Vec<u8>,
+	/// Maximum allowed size for a notification.
+	pub max_notification_size: u64,
+}
+
+/// Identifier for a delay firing.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+struct DelayId(u64);
+
+/// State of a peer we're connected to.
+///
+/// The variants correspond to the state of the peer w.r.t. the peerset.
+#[derive(Debug)]
+enum PeerState {
+	/// State is poisoned. This is a temporary state for a peer and we should always switch back
+	/// to it later. If it is found in the wild, that means there was either a panic or a bug in
+	/// the state machine code.
+	Poisoned,
+
+	/// The peer misbehaved. If the PSM wants us to connect to this peer, we will add an artificial
+	/// delay to the connection.
+	Backoff {
+		/// When the ban expires. For clean-up purposes. References an entry in `delays`.
+		timer: DelayId,
+		/// Until when the peer is backed-off.
+		timer_deadline: Instant,
+	},
+
+	/// The peerset requested that we connect to this peer. We are currently not connected.
+	PendingRequest {
+		/// When to actually start dialing. References an entry in `delays`.
+		timer: DelayId,
+		/// When the `timer` will trigger.
+		timer_deadline: Instant,
+	},
+
+	/// The peerset requested that we connect to this peer. We are currently dialing this peer.
+	Requested,
+
+	/// We are connected to this peer but the peerset hasn't requested it or has denied it.
+	///
+	/// The handler is either in the closed state, or a `Close` message has been sent to it and
+	/// hasn't been answered yet.
+	Disabled {
+		/// If `Some`, any connection request from the peerset to this peer is delayed until the
+		/// given `Instant`.
+		backoff_until: Option<Instant>,
+
+		/// List of connections with this peer, and their state.
+		connections: SmallVec<[(ConnectionId, ConnectionState); crate::MAX_CONNECTIONS_PER_PEER]>,
+	},
+
+	/// We are connected to this peer. The peerset has requested a connection to this peer, but
+	/// it is currently in a "backed-off" phase. The state will switch to `Enabled` once the timer
+	/// expires.
+	///
+	/// The handler is either in the closed state, or a `Close` message has been sent to it and
+	/// hasn't been answered yet.
+	///
+	/// The handler will be opened when `timer` fires.
+	DisabledPendingEnable {
+		/// When to enable this remote. References an entry in `delays`.
+		timer: DelayId,
+		/// When the `timer` will trigger.
+		timer_deadline: Instant,
+
+		/// List of connections with this peer, and their state.
+		connections: SmallVec<[(ConnectionId, ConnectionState); crate::MAX_CONNECTIONS_PER_PEER]>,
+	},
+
+	/// We are connected to this peer and the peerset has accepted it.
+	Enabled {
+		/// List of connections with this peer, and their state.
+		connections: SmallVec<[(ConnectionId, ConnectionState); crate::MAX_CONNECTIONS_PER_PEER]>,
+	},
+
+	/// We are connected to this peer. We have received an `OpenDesiredByRemote` from one of the
+	/// handlers and forwarded that request to the peerset. The connection handlers are waiting for
+	/// a response, i.e. to be opened or closed based on whether the peerset accepts or rejects
+	/// the peer.
+	Incoming {
+		/// If `Some`, any dial attempts to this peer are delayed until the given `Instant`.
+		backoff_until: Option<Instant>,
+
+		/// Incoming index tracking this connection.
+		incoming_index: IncomingIndex,
+
+		/// List of connections with this peer, and their state.
+		connections: SmallVec<[(ConnectionId, ConnectionState); crate::MAX_CONNECTIONS_PER_PEER]>,
+	},
+}
+
+impl PeerState {
+	/// True if there exists an established connection to the peer
+	/// that is open for custom protocol traffic.
+	fn is_open(&self) -> bool {
+		self.get_open().is_some()
+	}
+
+	/// Returns the [`NotificationsSink`] of the first established connection
+	/// that is open for custom protocol traffic.
+	fn get_open(&self) -> Option<&NotificationsSink> {
+		match self {
+			Self::Enabled { connections, .. } => connections.iter().find_map(|(_, s)| match s {
+				ConnectionState::Open(s) => Some(s),
+				_ => None,
+			}),
+			_ => None,
+		}
+	}
+}
+
+/// State of the handler of a single connection visible from this state machine.
+#[derive(Debug)]
+enum ConnectionState {
+	/// Connection is in the `Closed` state, meaning that the remote hasn't requested anything.
+	Closed,
+
+	/// Connection is either in the `Open` or the `Closed` state, but a
+	/// [`NotifsHandlerIn::Close`] message has been sent. Waiting for this message to be
+	/// acknowledged through a [`NotifsHandlerOut::CloseResult`].
+	Closing,
+
+	/// Connection is in the `Closed` state but a [`NotifsHandlerIn::Open`] message has been sent.
+	/// An `OpenResultOk`/`OpenResultErr` message is expected.
+	Opening,
+
+	/// Connection is in the `Closed` state but a [`NotifsHandlerIn::Open`] message then a
+	/// [`NotifsHandlerIn::Close`] message has been sent. An `OpenResultOk`/`OpenResultErr` message
+	/// followed with a `CloseResult` message are expected.
+	OpeningThenClosing,
+
+	/// Connection is in the `Closed` state, but a [`NotifsHandlerOut::OpenDesiredByRemote`]
+	/// message has been received, meaning that the remote wants to open a substream.
+	OpenDesiredByRemote,
+
+	/// Connection is in the `Open` state.
+	///
+	/// The external API is notified of a channel with this peer if any of its connection is in
+	/// this state.
+	Open(NotificationsSink),
+}
+
+/// State of an "incoming" message sent to the peer set manager.
+#[derive(Debug)]
+struct IncomingPeer {
+	/// Id of the remote peer of the incoming substream.
+	peer_id: PeerId,
+	/// Id of the set the incoming substream would belong to.
+	set_id: SetId,
+	/// If true, this "incoming" still corresponds to an actual connection. If false, then the
+	/// connection corresponding to it has been closed or replaced already.
+	alive: bool,
+	/// Id that the we sent to the peerset.
+	incoming_id: IncomingIndex,
+}
+
+/// Event that can be emitted by the `Notifications`.
+#[derive(Debug)]
+pub enum NotificationsOut {
+	/// Opened a custom protocol with the remote.
+	CustomProtocolOpen {
+		/// Id of the peer we are connected to.
+		peer_id: PeerId,
+		/// Peerset set ID the substream is tied to.
+		set_id: SetId,
+		/// If `Some`, a fallback protocol name has been used rather the main protocol name.
+		/// Always matches one of the fallback names passed at initialization.
+		negotiated_fallback: Option<ProtocolName>,
+		/// Handshake that was sent to us.
+		/// This is normally a "Status" message, but this is out of the concern of this code.
+		received_handshake: Vec<u8>,
+		/// Object that permits sending notifications to the peer.
+		notifications_sink: NotificationsSink,
+		/// Is the connection inbound.
+		inbound: bool,
+	},
+
+	/// The [`NotificationsSink`] object used to send notifications with the given peer must be
+	/// replaced with a new one.
+	///
+	/// This event is typically emitted when a transport-level connection is closed and we fall
+	/// back to a secondary connection.
+	CustomProtocolReplaced {
+		/// Id of the peer we are connected to.
+		peer_id: PeerId,
+		/// Peerset set ID the substream is tied to.
+		set_id: SetId,
+		/// Replacement for the previous [`NotificationsSink`].
+		notifications_sink: NotificationsSink,
+	},
+
+	/// Closed a custom protocol with the remote. The existing [`NotificationsSink`] should
+	/// be dropped.
+	CustomProtocolClosed {
+		/// Id of the peer we were connected to.
+		peer_id: PeerId,
+		/// Peerset set ID the substream was tied to.
+		set_id: SetId,
+	},
+
+	/// Receives a message on a custom protocol substream.
+	///
+	/// Also concerns received notifications for the notifications API.
+	Notification {
+		/// Id of the peer the message came from.
+		peer_id: PeerId,
+		/// Peerset set ID the substream is tied to.
+		set_id: SetId,
+		/// Message that has been received.
+		message: BytesMut,
+	},
+}
+
+impl Notifications {
+	/// Creates a `CustomProtos`.
+	pub fn new(
+		protocol_controller_handles: Vec<protocol_controller::ProtocolHandle>,
+		from_protocol_controllers: TracingUnboundedReceiver<Message>,
+		notif_protocols: impl Iterator<Item = ProtocolConfig>,
+	) -> Self {
+		let notif_protocols = notif_protocols
+			.map(|cfg| handler::ProtocolConfig {
+				name: cfg.name,
+				fallback_names: cfg.fallback_names,
+				handshake: Arc::new(RwLock::new(cfg.handshake)),
+				max_notification_size: cfg.max_notification_size,
+			})
+			.collect::<Vec<_>>();
+
+		assert!(!notif_protocols.is_empty());
+
+		Self {
+			notif_protocols,
+			protocol_controller_handles,
+			from_protocol_controllers,
+			peers: FnvHashMap::default(),
+			delays: Default::default(),
+			next_delay_id: DelayId(0),
+			incoming: SmallVec::new(),
+			next_incoming_index: IncomingIndex(0),
+			events: VecDeque::new(),
+		}
+	}
+
+	/// Modifies the handshake of the given notifications protocol.
+	pub fn set_notif_protocol_handshake(
+		&mut self,
+		set_id: SetId,
+		handshake_message: impl Into<Vec<u8>>,
+	) {
+		if let Some(p) = self.notif_protocols.get_mut(usize::from(set_id)) {
+			*p.handshake.write() = handshake_message.into();
+		} else {
+			log::error!(target: "sub-libp2p", "Unknown handshake change set: {:?}", set_id);
+			debug_assert!(false);
+		}
+	}
+
+	/// Returns the list of all the peers we have an open channel to.
+	pub fn open_peers(&self) -> impl Iterator<Item = &PeerId> {
+		self.peers.iter().filter(|(_, state)| state.is_open()).map(|((id, _), _)| id)
+	}
+
+	/// Returns true if we have an open substream to the given peer.
+	pub fn is_open(&self, peer_id: &PeerId, set_id: SetId) -> bool {
+		self.peers.get(&(*peer_id, set_id)).map(|p| p.is_open()).unwrap_or(false)
+	}
+
+	/// Disconnects the given peer if we are connected to it.
+	pub fn disconnect_peer(&mut self, peer_id: &PeerId, set_id: SetId) {
+		trace!(target: "sub-libp2p", "External API => Disconnect({}, {:?})", peer_id, set_id);
+		self.disconnect_peer_inner(peer_id, set_id);
+	}
+
+	/// Inner implementation of `disconnect_peer`.
+	fn disconnect_peer_inner(&mut self, peer_id: &PeerId, set_id: SetId) {
+		let mut entry = if let Entry::Occupied(entry) = self.peers.entry((*peer_id, set_id)) {
+			entry
+		} else {
+			return
+		};
+
+		match mem::replace(entry.get_mut(), PeerState::Poisoned) {
+			// We're not connected anyway.
+			st @ PeerState::Disabled { .. } => *entry.into_mut() = st,
+			st @ PeerState::Requested => *entry.into_mut() = st,
+			st @ PeerState::PendingRequest { .. } => *entry.into_mut() = st,
+			st @ PeerState::Backoff { .. } => *entry.into_mut() = st,
+
+			// DisabledPendingEnable => Disabled.
+			PeerState::DisabledPendingEnable { connections, timer_deadline, timer: _ } => {
+				trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})", peer_id, set_id);
+				self.protocol_controller_handles[usize::from(set_id)].dropped(*peer_id);
+				*entry.into_mut() =
+					PeerState::Disabled { connections, backoff_until: Some(timer_deadline) }
+			},
+
+			// Enabled => Disabled.
+			// All open or opening connections are sent a `Close` message.
+			// If relevant, the external API is instantly notified.
+			PeerState::Enabled { mut connections } => {
+				trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})", peer_id, set_id);
+				self.protocol_controller_handles[usize::from(set_id)].dropped(*peer_id);
+
+				if connections.iter().any(|(_, s)| matches!(s, ConnectionState::Open(_))) {
+					trace!(target: "sub-libp2p", "External API <= Closed({}, {:?})", peer_id, set_id);
+					let event =
+						NotificationsOut::CustomProtocolClosed { peer_id: *peer_id, set_id };
+					self.events.push_back(ToSwarm::GenerateEvent(event));
+				}
+
+				for (connec_id, connec_state) in
+					connections.iter_mut().filter(|(_, s)| matches!(s, ConnectionState::Open(_)))
+				{
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Close({:?})", peer_id, *connec_id, set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id: *peer_id,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Close { protocol_index: set_id.into() },
+					});
+					*connec_state = ConnectionState::Closing;
+				}
+
+				for (connec_id, connec_state) in
+					connections.iter_mut().filter(|(_, s)| matches!(s, ConnectionState::Opening))
+				{
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Close({:?})", peer_id, *connec_id, set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id: *peer_id,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Close { protocol_index: set_id.into() },
+					});
+					*connec_state = ConnectionState::OpeningThenClosing;
+				}
+
+				debug_assert!(!connections
+					.iter()
+					.any(|(_, s)| matches!(s, ConnectionState::Open(_))));
+				debug_assert!(!connections
+					.iter()
+					.any(|(_, s)| matches!(s, ConnectionState::Opening)));
+
+				*entry.into_mut() = PeerState::Disabled { connections, backoff_until: None }
+			},
+
+			// Incoming => Disabled.
+			// Ongoing opening requests from the remote are rejected.
+			PeerState::Incoming { mut connections, backoff_until, .. } => {
+				let inc = if let Some(inc) = self
+					.incoming
+					.iter_mut()
+					.find(|i| i.peer_id == entry.key().0 && i.set_id == set_id && i.alive)
+				{
+					inc
+				} else {
+					error!(
+						target: "sub-libp2p",
+						"State mismatch in libp2p: no entry in incoming for incoming peer"
+					);
+					return
+				};
+
+				inc.alive = false;
+
+				for (connec_id, connec_state) in connections
+					.iter_mut()
+					.filter(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote))
+				{
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Close({:?})", peer_id, *connec_id, set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id: *peer_id,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Close { protocol_index: set_id.into() },
+					});
+					*connec_state = ConnectionState::Closing;
+				}
+
+				debug_assert!(!connections
+					.iter()
+					.any(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote)));
+				*entry.into_mut() = PeerState::Disabled { connections, backoff_until }
+			},
+
+			PeerState::Poisoned => {
+				error!(target: "sub-libp2p", "State of {:?} is poisoned", peer_id)
+			},
+		}
+	}
+
+	/// Function that is called when the peerset wants us to connect to a peer.
+	fn peerset_report_connect(&mut self, peer_id: PeerId, set_id: SetId) {
+		// If `PeerId` is unknown to us, insert an entry, start dialing, and return early.
+		let mut occ_entry = match self.peers.entry((peer_id, set_id)) {
+			Entry::Occupied(entry) => entry,
+			Entry::Vacant(entry) => {
+				// If there's no entry in `self.peers`, start dialing.
+				trace!(
+					target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): Starting to connect",
+					entry.key().0,
+					set_id,
+				);
+				trace!(target: "sub-libp2p", "Libp2p <= Dial {}", entry.key().0);
+				self.events.push_back(ToSwarm::Dial { opts: entry.key().0.into() });
+				entry.insert(PeerState::Requested);
+				return
+			},
+		};
+
+		let now = Instant::now();
+
+		match mem::replace(occ_entry.get_mut(), PeerState::Poisoned) {
+			// Backoff (not expired) => PendingRequest
+			PeerState::Backoff { ref timer, ref timer_deadline } if *timer_deadline > now => {
+				let peer_id = occ_entry.key().0;
+				trace!(
+					target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): Will start to connect at until {:?}",
+					peer_id,
+					set_id,
+					timer_deadline,
+				);
+				*occ_entry.into_mut() =
+					PeerState::PendingRequest { timer: *timer, timer_deadline: *timer_deadline };
+			},
+
+			// Backoff (expired) => Requested
+			PeerState::Backoff { .. } => {
+				trace!(
+					target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): Starting to connect",
+					occ_entry.key().0,
+					set_id,
+				);
+				trace!(target: "sub-libp2p", "Libp2p <= Dial {:?}", occ_entry.key());
+				self.events.push_back(ToSwarm::Dial { opts: occ_entry.key().0.into() });
+				*occ_entry.into_mut() = PeerState::Requested;
+			},
+
+			// Disabled (with non-expired ban) => DisabledPendingEnable
+			PeerState::Disabled { connections, backoff_until: Some(ref backoff) }
+				if *backoff > now =>
+			{
+				let peer_id = occ_entry.key().0;
+				trace!(
+					target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): But peer is backed-off until {:?}",
+					peer_id,
+					set_id,
+					backoff,
+				);
+
+				let delay_id = self.next_delay_id;
+				self.next_delay_id.0 += 1;
+				let delay = futures_timer::Delay::new(*backoff - now);
+				self.delays.push(
+					async move {
+						delay.await;
+						(delay_id, peer_id, set_id)
+					}
+					.boxed(),
+				);
+
+				*occ_entry.into_mut() = PeerState::DisabledPendingEnable {
+					connections,
+					timer: delay_id,
+					timer_deadline: *backoff,
+				};
+			},
+
+			// Disabled => Enabled
+			PeerState::Disabled { mut connections, backoff_until } => {
+				debug_assert!(!connections
+					.iter()
+					.any(|(_, s)| { matches!(s, ConnectionState::Open(_)) }));
+
+				// The first element of `closed` is chosen to open the notifications substream.
+				if let Some((connec_id, connec_state)) =
+					connections.iter_mut().find(|(_, s)| matches!(s, ConnectionState::Closed))
+				{
+					trace!(target: "sub-libp2p", "PSM => Connect({}, {:?}): Enabling connections.",
+						occ_entry.key().0, set_id);
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Open({:?})", peer_id, *connec_id, set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Open { protocol_index: set_id.into() },
+					});
+					*connec_state = ConnectionState::Opening;
+					*occ_entry.into_mut() = PeerState::Enabled { connections };
+				} else {
+					// If no connection is available, switch to `DisabledPendingEnable` in order
+					// to try again later.
+					debug_assert!(connections.iter().any(|(_, s)| {
+						matches!(s, ConnectionState::OpeningThenClosing | ConnectionState::Closing)
+					}));
+					trace!(
+						target: "sub-libp2p",
+						"PSM => Connect({}, {:?}): No connection in proper state. Delaying.",
+						occ_entry.key().0, set_id
+					);
+
+					let timer_deadline = {
+						let base = now + Duration::from_secs(5);
+						if let Some(backoff_until) = backoff_until {
+							cmp::max(base, backoff_until)
+						} else {
+							base
+						}
+					};
+
+					let delay_id = self.next_delay_id;
+					self.next_delay_id.0 += 1;
+					debug_assert!(timer_deadline > now);
+					let delay = futures_timer::Delay::new(timer_deadline - now);
+					self.delays.push(
+						async move {
+							delay.await;
+							(delay_id, peer_id, set_id)
+						}
+						.boxed(),
+					);
+
+					*occ_entry.into_mut() = PeerState::DisabledPendingEnable {
+						connections,
+						timer: delay_id,
+						timer_deadline,
+					};
+				}
+			},
+			// Incoming => Incoming
+			st @ PeerState::Incoming { .. } => {
+				debug!(
+					target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): Ignoring obsolete connect, we are awaiting accept/reject.",
+					occ_entry.key().0, set_id
+				);
+				*occ_entry.into_mut() = st;
+			},
+
+			// Other states are kept as-is.
+			st @ PeerState::Enabled { .. } => {
+				debug!(target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): Already connected.",
+					occ_entry.key().0, set_id);
+				*occ_entry.into_mut() = st;
+			},
+			st @ PeerState::DisabledPendingEnable { .. } => {
+				debug!(target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): Already pending enabling.",
+					occ_entry.key().0, set_id);
+				*occ_entry.into_mut() = st;
+			},
+			st @ PeerState::Requested { .. } | st @ PeerState::PendingRequest { .. } => {
+				debug!(target: "sub-libp2p",
+					"PSM => Connect({}, {:?}): Duplicate request.",
+					occ_entry.key().0, set_id);
+				*occ_entry.into_mut() = st;
+			},
+
+			PeerState::Poisoned => {
+				error!(target: "sub-libp2p", "State of {:?} is poisoned", occ_entry.key());
+				debug_assert!(false);
+			},
+		}
+	}
+
+	/// Function that is called when the peerset wants us to disconnect from a peer.
+	fn peerset_report_disconnect(&mut self, peer_id: PeerId, set_id: SetId) {
+		let mut entry = match self.peers.entry((peer_id, set_id)) {
+			Entry::Occupied(entry) => entry,
+			Entry::Vacant(entry) => {
+				trace!(target: "sub-libp2p", "PSM => Drop({}, {:?}): Already disabled.",
+					entry.key().0, set_id);
+				return
+			},
+		};
+
+		match mem::replace(entry.get_mut(), PeerState::Poisoned) {
+			st @ PeerState::Disabled { .. } | st @ PeerState::Backoff { .. } => {
+				trace!(target: "sub-libp2p", "PSM => Drop({}, {:?}): Already disabled.",
+					entry.key().0, set_id);
+				*entry.into_mut() = st;
+			},
+
+			// DisabledPendingEnable => Disabled
+			PeerState::DisabledPendingEnable { connections, timer_deadline, timer: _ } => {
+				debug_assert!(!connections.is_empty());
+				trace!(target: "sub-libp2p",
+					"PSM => Drop({}, {:?}): Interrupting pending enabling.",
+					entry.key().0, set_id);
+				*entry.into_mut() =
+					PeerState::Disabled { connections, backoff_until: Some(timer_deadline) };
+			},
+
+			// Enabled => Disabled
+			PeerState::Enabled { mut connections } => {
+				trace!(target: "sub-libp2p", "PSM => Drop({}, {:?}): Disabling connections.",
+					entry.key().0, set_id);
+
+				debug_assert!(connections.iter().any(|(_, s)| matches!(
+					s,
+					ConnectionState::Opening | ConnectionState::Open(_)
+				)));
+
+				if connections.iter().any(|(_, s)| matches!(s, ConnectionState::Open(_))) {
+					trace!(target: "sub-libp2p", "External API <= Closed({}, {:?})", entry.key().0, set_id);
+					let event =
+						NotificationsOut::CustomProtocolClosed { peer_id: entry.key().0, set_id };
+					self.events.push_back(ToSwarm::GenerateEvent(event));
+				}
+
+				for (connec_id, connec_state) in
+					connections.iter_mut().filter(|(_, s)| matches!(s, ConnectionState::Opening))
+				{
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Close({:?})",
+						entry.key(), *connec_id, set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id: entry.key().0,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Close { protocol_index: set_id.into() },
+					});
+					*connec_state = ConnectionState::OpeningThenClosing;
+				}
+
+				for (connec_id, connec_state) in
+					connections.iter_mut().filter(|(_, s)| matches!(s, ConnectionState::Open(_)))
+				{
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Close({:?})",
+						entry.key(), *connec_id, set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id: entry.key().0,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Close { protocol_index: set_id.into() },
+					});
+					*connec_state = ConnectionState::Closing;
+				}
+
+				*entry.into_mut() = PeerState::Disabled { connections, backoff_until: None }
+			},
+
+			// Requested => Ø
+			PeerState::Requested => {
+				// We don't cancel dialing. Libp2p doesn't expose that on purpose, as other
+				// sub-systems (such as the discovery mechanism) may require dialing this peer as
+				// well at the same time.
+				trace!(target: "sub-libp2p", "PSM => Drop({}, {:?}): Not yet connected.",
+					entry.key().0, set_id);
+				entry.remove();
+			},
+
+			// PendingRequest => Backoff
+			PeerState::PendingRequest { timer, timer_deadline } => {
+				trace!(target: "sub-libp2p", "PSM => Drop({}, {:?}): Not yet connected",
+					entry.key().0, set_id);
+				*entry.into_mut() = PeerState::Backoff { timer, timer_deadline }
+			},
+
+			// Invalid state transitions.
+			st @ PeerState::Incoming { .. } => {
+				info!(
+					target: "sub-libp2p",
+					"PSM => Drop({}, {:?}): Ignoring obsolete disconnect, we are awaiting accept/reject.",
+					entry.key().0, set_id,
+				);
+				*entry.into_mut() = st;
+			},
+			PeerState::Poisoned => {
+				error!(target: "sub-libp2p", "State of {:?} is poisoned", entry.key());
+				debug_assert!(false);
+			},
+		}
+	}
+
+	/// Function that is called when the peerset wants us to accept a connection
+	/// request from a peer.
+	fn peerset_report_accept(&mut self, index: IncomingIndex) {
+		let incoming = if let Some(pos) = self.incoming.iter().position(|i| i.incoming_id == index)
+		{
+			self.incoming.remove(pos)
+		} else {
+			error!(target: "sub-libp2p", "PSM => Accept({:?}): Invalid index", index);
+			return
+		};
+
+		if !incoming.alive {
+			trace!(target: "sub-libp2p", "PSM => Accept({:?}, {}, {:?}): Obsolete incoming",
+				index, incoming.peer_id, incoming.set_id);
+			match self.peers.get_mut(&(incoming.peer_id, incoming.set_id)) {
+				Some(PeerState::DisabledPendingEnable { .. }) | Some(PeerState::Enabled { .. }) => {
+				},
+				_ => {
+					trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})",
+						incoming.peer_id, incoming.set_id);
+					self.protocol_controller_handles[usize::from(incoming.set_id)]
+						.dropped(incoming.peer_id);
+				},
+			}
+			return
+		}
+
+		let state = match self.peers.get_mut(&(incoming.peer_id, incoming.set_id)) {
+			Some(s) => s,
+			None => {
+				debug_assert!(false);
+				return
+			},
+		};
+
+		match mem::replace(state, PeerState::Poisoned) {
+			// Incoming => Enabled
+			PeerState::Incoming { mut connections, incoming_index, .. } => {
+				if index < incoming_index {
+					warn!(
+						target: "sub-libp2p",
+						"PSM => Accept({:?}, {}, {:?}): Ignoring obsolete incoming index, we are already awaiting {:?}.",
+						index, incoming.peer_id, incoming.set_id, incoming_index
+					);
+					return
+				} else if index > incoming_index {
+					error!(
+						target: "sub-libp2p",
+						"PSM => Accept({:?}, {}, {:?}): Ignoring incoming index from the future, we are awaiting {:?}.",
+						index, incoming.peer_id, incoming.set_id, incoming_index
+					);
+					debug_assert!(false);
+					return
+				}
+
+				trace!(target: "sub-libp2p", "PSM => Accept({:?}, {}, {:?}): Enabling connections.",
+					index, incoming.peer_id, incoming.set_id);
+
+				debug_assert!(connections
+					.iter()
+					.any(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote)));
+				for (connec_id, connec_state) in connections
+					.iter_mut()
+					.filter(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote))
+				{
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Open({:?})",
+						incoming.peer_id, *connec_id, incoming.set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id: incoming.peer_id,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Open { protocol_index: incoming.set_id.into() },
+					});
+					*connec_state = ConnectionState::Opening;
+				}
+
+				*state = PeerState::Enabled { connections };
+			},
+
+			// Any state other than `Incoming` is invalid.
+			peer => {
+				error!(target: "sub-libp2p",
+					"State mismatch in libp2p: Expected alive incoming. Got {:?}.",
+					peer);
+				debug_assert!(false);
+			},
+		}
+	}
+
+	/// Function that is called when the peerset wants us to reject an incoming peer.
+	fn peerset_report_reject(&mut self, index: IncomingIndex) {
+		let incoming = if let Some(pos) = self.incoming.iter().position(|i| i.incoming_id == index)
+		{
+			self.incoming.remove(pos)
+		} else {
+			error!(target: "sub-libp2p", "PSM => Reject({:?}): Invalid index", index);
+			return
+		};
+
+		if !incoming.alive {
+			trace!(target: "sub-libp2p", "PSM => Reject({:?}, {}, {:?}): Obsolete incoming, \
+				ignoring", index, incoming.peer_id, incoming.set_id);
+			return
+		}
+
+		let state = match self.peers.get_mut(&(incoming.peer_id, incoming.set_id)) {
+			Some(s) => s,
+			None => {
+				debug_assert!(false);
+				return
+			},
+		};
+
+		match mem::replace(state, PeerState::Poisoned) {
+			// Incoming => Disabled
+			PeerState::Incoming { mut connections, backoff_until, incoming_index } => {
+				if index < incoming_index {
+					warn!(
+						target: "sub-libp2p",
+						"PSM => Reject({:?}, {}, {:?}): Ignoring obsolete incoming index, we are already awaiting {:?}.",
+						index, incoming.peer_id, incoming.set_id, incoming_index
+					);
+					return
+				} else if index > incoming_index {
+					error!(
+						target: "sub-libp2p",
+						"PSM => Reject({:?}, {}, {:?}): Ignoring incoming index from the future, we are awaiting {:?}.",
+						index, incoming.peer_id, incoming.set_id, incoming_index
+					);
+					debug_assert!(false);
+					return
+				}
+
+				trace!(target: "sub-libp2p", "PSM => Reject({:?}, {}, {:?}): Rejecting connections.",
+					index, incoming.peer_id, incoming.set_id);
+
+				debug_assert!(connections
+					.iter()
+					.any(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote)));
+				for (connec_id, connec_state) in connections
+					.iter_mut()
+					.filter(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote))
+				{
+					trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Close({:?})",
+						incoming.peer_id, connec_id, incoming.set_id);
+					self.events.push_back(ToSwarm::NotifyHandler {
+						peer_id: incoming.peer_id,
+						handler: NotifyHandler::One(*connec_id),
+						event: NotifsHandlerIn::Close { protocol_index: incoming.set_id.into() },
+					});
+					*connec_state = ConnectionState::Closing;
+				}
+
+				*state = PeerState::Disabled { connections, backoff_until };
+			},
+			peer => error!(target: "sub-libp2p",
+				"State mismatch in libp2p: Expected alive incoming. Got {:?}.",
+				peer),
+		}
+	}
+}
+
+impl NetworkBehaviour for Notifications {
+	type ConnectionHandler = NotifsHandler;
+	type OutEvent = NotificationsOut;
+
+	fn handle_pending_inbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		_local_addr: &Multiaddr,
+		_remote_addr: &Multiaddr,
+	) -> Result<(), ConnectionDenied> {
+		Ok(())
+	}
+
+	fn handle_pending_outbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		_maybe_peer: Option<PeerId>,
+		_addresses: &[Multiaddr],
+		_effective_role: Endpoint,
+	) -> Result<Vec<Multiaddr>, ConnectionDenied> {
+		Ok(Vec::new())
+	}
+
+	fn handle_established_inbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		peer: PeerId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		Ok(NotifsHandler::new(
+			peer,
+			ConnectedPoint::Listener {
+				local_addr: local_addr.clone(),
+				send_back_addr: remote_addr.clone(),
+			},
+			self.notif_protocols.clone(),
+		))
+	}
+
+	fn handle_established_outbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		peer: PeerId,
+		addr: &Multiaddr,
+		role_override: Endpoint,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		Ok(NotifsHandler::new(
+			peer,
+			ConnectedPoint::Dialer { address: addr.clone(), role_override },
+			self.notif_protocols.clone(),
+		))
+	}
+
+	fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+		match event {
+			FromSwarm::ConnectionEstablished(ConnectionEstablished {
+				peer_id,
+				endpoint,
+				connection_id,
+				..
+			}) => {
+				for set_id in (0..self.notif_protocols.len()).map(SetId::from) {
+					match self.peers.entry((peer_id, set_id)).or_insert(PeerState::Poisoned) {
+						// Requested | PendingRequest => Enabled
+						st @ &mut PeerState::Requested |
+						st @ &mut PeerState::PendingRequest { .. } => {
+							trace!(target: "sub-libp2p",
+								"Libp2p => Connected({}, {:?}, {:?}): Connection was requested by PSM.",
+								peer_id, set_id, endpoint
+							);
+							trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Open({:?})", peer_id, connection_id, set_id);
+							self.events.push_back(ToSwarm::NotifyHandler {
+								peer_id,
+								handler: NotifyHandler::One(connection_id),
+								event: NotifsHandlerIn::Open { protocol_index: set_id.into() },
+							});
+
+							let mut connections = SmallVec::new();
+							connections.push((connection_id, ConnectionState::Opening));
+							*st = PeerState::Enabled { connections };
+						},
+
+						// Poisoned gets inserted above if the entry was missing.
+						// Ø | Backoff => Disabled
+						st @ &mut PeerState::Poisoned | st @ &mut PeerState::Backoff { .. } => {
+							let backoff_until =
+								if let PeerState::Backoff { timer_deadline, .. } = st {
+									Some(*timer_deadline)
+								} else {
+									None
+								};
+							trace!(target: "sub-libp2p",
+								"Libp2p => Connected({}, {:?}, {:?}, {:?}): Not requested by PSM, disabling.",
+								peer_id, set_id, endpoint, connection_id);
+
+							let mut connections = SmallVec::new();
+							connections.push((connection_id, ConnectionState::Closed));
+							*st = PeerState::Disabled { connections, backoff_until };
+						},
+
+						// In all other states, add this new connection to the list of closed
+						// inactive connections.
+						PeerState::Incoming { connections, .. } |
+						PeerState::Disabled { connections, .. } |
+						PeerState::DisabledPendingEnable { connections, .. } |
+						PeerState::Enabled { connections, .. } => {
+							trace!(target: "sub-libp2p",
+								"Libp2p => Connected({}, {:?}, {:?}, {:?}): Secondary connection. Leaving closed.",
+								peer_id, set_id, endpoint, connection_id);
+							connections.push((connection_id, ConnectionState::Closed));
+						},
+					}
+				}
+			},
+			FromSwarm::ConnectionClosed(ConnectionClosed { peer_id, connection_id, .. }) => {
+				for set_id in (0..self.notif_protocols.len()).map(SetId::from) {
+					let mut entry = if let Entry::Occupied(entry) =
+						self.peers.entry((peer_id, set_id))
+					{
+						entry
+					} else {
+						error!(target: "sub-libp2p", "inject_connection_closed: State mismatch in the custom protos handler");
+						debug_assert!(false);
+						return
+					};
+
+					match mem::replace(entry.get_mut(), PeerState::Poisoned) {
+						// Disabled => Disabled | Backoff | Ø
+						PeerState::Disabled { mut connections, backoff_until } => {
+							trace!(target: "sub-libp2p", "Libp2p => Disconnected({}, {:?}, {:?}): Disabled.",
+								peer_id, set_id, connection_id);
+
+							if let Some(pos) =
+								connections.iter().position(|(c, _)| *c == connection_id)
+							{
+								connections.remove(pos);
+							} else {
+								debug_assert!(false);
+								error!(target: "sub-libp2p",
+									"inject_connection_closed: State mismatch in the custom protos handler");
+							}
+
+							if connections.is_empty() {
+								if let Some(until) = backoff_until {
+									let now = Instant::now();
+									if until > now {
+										let delay_id = self.next_delay_id;
+										self.next_delay_id.0 += 1;
+										let delay = futures_timer::Delay::new(until - now);
+										self.delays.push(
+											async move {
+												delay.await;
+												(delay_id, peer_id, set_id)
+											}
+											.boxed(),
+										);
+
+										*entry.get_mut() = PeerState::Backoff {
+											timer: delay_id,
+											timer_deadline: until,
+										};
+									} else {
+										entry.remove();
+									}
+								} else {
+									entry.remove();
+								}
+							} else {
+								*entry.get_mut() =
+									PeerState::Disabled { connections, backoff_until };
+							}
+						},
+
+						// DisabledPendingEnable => DisabledPendingEnable | Backoff
+						PeerState::DisabledPendingEnable {
+							mut connections,
+							timer_deadline,
+							timer,
+						} => {
+							trace!(
+								target: "sub-libp2p",
+								"Libp2p => Disconnected({}, {:?}, {:?}): Disabled but pending enable.",
+								peer_id, set_id, connection_id
+							);
+
+							if let Some(pos) =
+								connections.iter().position(|(c, _)| *c == connection_id)
+							{
+								connections.remove(pos);
+							} else {
+								error!(target: "sub-libp2p",
+									"inject_connection_closed: State mismatch in the custom protos handler");
+								debug_assert!(false);
+							}
+
+							if connections.is_empty() {
+								trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})", peer_id, set_id);
+								self.protocol_controller_handles[usize::from(set_id)]
+									.dropped(peer_id);
+								*entry.get_mut() = PeerState::Backoff { timer, timer_deadline };
+							} else {
+								*entry.get_mut() = PeerState::DisabledPendingEnable {
+									connections,
+									timer_deadline,
+									timer,
+								};
+							}
+						},
+
+						// Incoming => Incoming | Disabled | Backoff | Ø
+						PeerState::Incoming { mut connections, backoff_until, incoming_index } => {
+							trace!(
+								target: "sub-libp2p",
+								"Libp2p => Disconnected({}, {:?}, {:?}): OpenDesiredByRemote.",
+								peer_id, set_id, connection_id
+							);
+
+							debug_assert!(connections
+								.iter()
+								.any(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote)));
+
+							if let Some(pos) =
+								connections.iter().position(|(c, _)| *c == connection_id)
+							{
+								connections.remove(pos);
+							} else {
+								error!(target: "sub-libp2p",
+									"inject_connection_closed: State mismatch in the custom protos handler");
+								debug_assert!(false);
+							}
+
+							let no_desired_left = !connections
+								.iter()
+								.any(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote));
+
+							// If no connection is `OpenDesiredByRemote` anymore, clean up the
+							// peerset incoming request.
+							if no_desired_left {
+								// In the incoming state, we don't report "Dropped" straight away.
+								// Instead we will report "Dropped" if receive the corresponding
+								// "Accept".
+								if let Some(state) = self
+									.incoming
+									.iter_mut()
+									.find(|i| i.alive && i.set_id == set_id && i.peer_id == peer_id)
+								{
+									state.alive = false;
+								} else {
+									error!(target: "sub-libp2p", "State mismatch in libp2p: no entry in \
+										incoming corresponding to an incoming state in peers");
+									debug_assert!(false);
+								}
+							}
+
+							if connections.is_empty() {
+								if let Some(until) = backoff_until {
+									let now = Instant::now();
+									if until > now {
+										let delay_id = self.next_delay_id;
+										self.next_delay_id.0 += 1;
+										let delay = futures_timer::Delay::new(until - now);
+										self.delays.push(
+											async move {
+												delay.await;
+												(delay_id, peer_id, set_id)
+											}
+											.boxed(),
+										);
+
+										*entry.get_mut() = PeerState::Backoff {
+											timer: delay_id,
+											timer_deadline: until,
+										};
+									} else {
+										entry.remove();
+									}
+								} else {
+									entry.remove();
+								}
+							} else if no_desired_left {
+								// If no connection is `OpenDesiredByRemote` anymore, switch to
+								// `Disabled`.
+								*entry.get_mut() =
+									PeerState::Disabled { connections, backoff_until };
+							} else {
+								*entry.get_mut() = PeerState::Incoming {
+									connections,
+									backoff_until,
+									incoming_index,
+								};
+							}
+						},
+
+						// Enabled => Enabled | Backoff
+						// Peers are always backed-off when disconnecting while Enabled.
+						PeerState::Enabled { mut connections } => {
+							trace!(
+								target: "sub-libp2p",
+								"Libp2p => Disconnected({}, {:?}, {:?}): Enabled.",
+								peer_id, set_id, connection_id
+							);
+
+							debug_assert!(connections.iter().any(|(_, s)| matches!(
+								s,
+								ConnectionState::Opening | ConnectionState::Open(_)
+							)));
+
+							if let Some(pos) =
+								connections.iter().position(|(c, _)| *c == connection_id)
+							{
+								let (_, state) = connections.remove(pos);
+								if let ConnectionState::Open(_) = state {
+									if let Some((replacement_pos, replacement_sink)) = connections
+										.iter()
+										.enumerate()
+										.find_map(|(num, (_, s))| match s {
+											ConnectionState::Open(s) => Some((num, s.clone())),
+											_ => None,
+										}) {
+										if pos <= replacement_pos {
+											trace!(
+												target: "sub-libp2p",
+												"External API <= Sink replaced({}, {:?})",
+												peer_id, set_id
+											);
+											let event = NotificationsOut::CustomProtocolReplaced {
+												peer_id,
+												set_id,
+												notifications_sink: replacement_sink,
+											};
+											self.events.push_back(ToSwarm::GenerateEvent(event));
+										}
+									} else {
+										trace!(
+											target: "sub-libp2p", "External API <= Closed({}, {:?})",
+											peer_id, set_id
+										);
+										let event = NotificationsOut::CustomProtocolClosed {
+											peer_id,
+											set_id,
+										};
+										self.events.push_back(ToSwarm::GenerateEvent(event));
+									}
+								}
+							} else {
+								error!(target: "sub-libp2p",
+									"inject_connection_closed: State mismatch in the custom protos handler");
+								debug_assert!(false);
+							}
+
+							if connections.is_empty() {
+								trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})", peer_id, set_id);
+								self.protocol_controller_handles[usize::from(set_id)]
+									.dropped(peer_id);
+								let ban_dur = Uniform::new(5, 10).sample(&mut rand::thread_rng());
+
+								let delay_id = self.next_delay_id;
+								self.next_delay_id.0 += 1;
+								let delay = futures_timer::Delay::new(Duration::from_secs(ban_dur));
+								self.delays.push(
+									async move {
+										delay.await;
+										(delay_id, peer_id, set_id)
+									}
+									.boxed(),
+								);
+
+								*entry.get_mut() = PeerState::Backoff {
+									timer: delay_id,
+									timer_deadline: Instant::now() + Duration::from_secs(ban_dur),
+								};
+							} else if !connections.iter().any(|(_, s)| {
+								matches!(s, ConnectionState::Opening | ConnectionState::Open(_))
+							}) {
+								trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})", peer_id, set_id);
+								self.protocol_controller_handles[usize::from(set_id)]
+									.dropped(peer_id);
+
+								*entry.get_mut() =
+									PeerState::Disabled { connections, backoff_until: None };
+							} else {
+								*entry.get_mut() = PeerState::Enabled { connections };
+							}
+						},
+
+						PeerState::Requested |
+						PeerState::PendingRequest { .. } |
+						PeerState::Backoff { .. } => {
+							// This is a serious bug either in this state machine or in libp2p.
+							error!(target: "sub-libp2p",
+								"`inject_connection_closed` called for unknown peer {}",
+								peer_id);
+							debug_assert!(false);
+						},
+						PeerState::Poisoned => {
+							error!(target: "sub-libp2p", "State of peer {} is poisoned", peer_id);
+							debug_assert!(false);
+						},
+					}
+				}
+			},
+			FromSwarm::DialFailure(DialFailure { peer_id, error, .. }) => {
+				if let DialError::Transport(errors) = error {
+					for (addr, error) in errors.iter() {
+						trace!(target: "sub-libp2p", "Libp2p => Reach failure for {:?} through {:?}: {:?}", peer_id, addr, error);
+					}
+				}
+
+				if let Some(peer_id) = peer_id {
+					trace!(target: "sub-libp2p", "Libp2p => Dial failure for {:?}", peer_id);
+
+					for set_id in (0..self.notif_protocols.len()).map(SetId::from) {
+						if let Entry::Occupied(mut entry) = self.peers.entry((peer_id, set_id)) {
+							match mem::replace(entry.get_mut(), PeerState::Poisoned) {
+								// The peer is not in our list.
+								st @ PeerState::Backoff { .. } => {
+									*entry.into_mut() = st;
+								},
+
+								// "Basic" situation: we failed to reach a peer that the peerset
+								// requested.
+								st @ PeerState::Requested |
+								st @ PeerState::PendingRequest { .. } => {
+									trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})", peer_id, set_id);
+									self.protocol_controller_handles[usize::from(set_id)]
+										.dropped(peer_id);
+
+									let now = Instant::now();
+									let ban_duration = match st {
+										PeerState::PendingRequest { timer_deadline, .. }
+											if timer_deadline > now =>
+											cmp::max(timer_deadline - now, Duration::from_secs(5)),
+										_ => Duration::from_secs(5),
+									};
+
+									let delay_id = self.next_delay_id;
+									self.next_delay_id.0 += 1;
+									let delay = futures_timer::Delay::new(ban_duration);
+									let peer_id = peer_id;
+									self.delays.push(
+										async move {
+											delay.await;
+											(delay_id, peer_id, set_id)
+										}
+										.boxed(),
+									);
+
+									*entry.into_mut() = PeerState::Backoff {
+										timer: delay_id,
+										timer_deadline: now + ban_duration,
+									};
+								},
+
+								// We can still get dial failures even if we are already connected
+								// to the peer, as an extra diagnostic for an earlier attempt.
+								st @ PeerState::Disabled { .. } |
+								st @ PeerState::Enabled { .. } |
+								st @ PeerState::DisabledPendingEnable { .. } |
+								st @ PeerState::Incoming { .. } => {
+									*entry.into_mut() = st;
+								},
+
+								PeerState::Poisoned => {
+									error!(target: "sub-libp2p", "State of {:?} is poisoned", peer_id);
+									debug_assert!(false);
+								},
+							}
+						}
+					}
+				}
+			},
+			FromSwarm::ListenerClosed(_) => {},
+			FromSwarm::ListenFailure(_) => {},
+			FromSwarm::ListenerError(_) => {},
+			FromSwarm::ExpiredExternalAddr(_) => {},
+			FromSwarm::NewListener(_) => {},
+			FromSwarm::ExpiredListenAddr(_) => {},
+			FromSwarm::NewExternalAddr(_) => {},
+			FromSwarm::AddressChange(_) => {},
+			FromSwarm::NewListenAddr(_) => {},
+		}
+	}
+
+	fn on_connection_handler_event(
+		&mut self,
+		peer_id: PeerId,
+		connection_id: ConnectionId,
+		event: THandlerOutEvent<Self>,
+	) {
+		match event {
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index } => {
+				let set_id = SetId::from(protocol_index);
+
+				trace!(target: "sub-libp2p",
+					"Handler({:?}, {:?}]) => OpenDesiredByRemote({:?})",
+					peer_id, connection_id, set_id);
+
+				let mut entry = if let Entry::Occupied(entry) = self.peers.entry((peer_id, set_id))
+				{
+					entry
+				} else {
+					error!(
+						target: "sub-libp2p",
+						"OpenDesiredByRemote: State mismatch in the custom protos handler"
+					);
+					debug_assert!(false);
+					return
+				};
+
+				match mem::replace(entry.get_mut(), PeerState::Poisoned) {
+					// Incoming => Incoming
+					PeerState::Incoming { mut connections, backoff_until, incoming_index } => {
+						debug_assert!(connections
+							.iter()
+							.any(|(_, s)| matches!(s, ConnectionState::OpenDesiredByRemote)));
+						if let Some((_, connec_state)) =
+							connections.iter_mut().find(|(c, _)| *c == connection_id)
+						{
+							if let ConnectionState::Closed = *connec_state {
+								*connec_state = ConnectionState::OpenDesiredByRemote;
+							} else {
+								// Connections in `OpeningThenClosing` and `Closing` state can be
+								// in a Closed phase, and as such can emit `OpenDesiredByRemote`
+								// messages.
+								// Since an `Open` and/or a `Close` message have already been sent,
+								// there is nothing much that can be done about this anyway.
+								debug_assert!(matches!(
+									connec_state,
+									ConnectionState::OpeningThenClosing | ConnectionState::Closing
+								));
+							}
+						} else {
+							error!(
+								target: "sub-libp2p",
+								"OpenDesiredByRemote: State mismatch in the custom protos handler"
+							);
+							debug_assert!(false);
+						}
+
+						*entry.into_mut() =
+							PeerState::Incoming { connections, backoff_until, incoming_index };
+					},
+
+					PeerState::Enabled { mut connections } => {
+						debug_assert!(connections.iter().any(|(_, s)| matches!(
+							s,
+							ConnectionState::Opening | ConnectionState::Open(_)
+						)));
+
+						if let Some((_, connec_state)) =
+							connections.iter_mut().find(|(c, _)| *c == connection_id)
+						{
+							if let ConnectionState::Closed = *connec_state {
+								trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Open({:?})",
+									peer_id, connection_id, set_id);
+								self.events.push_back(ToSwarm::NotifyHandler {
+									peer_id,
+									handler: NotifyHandler::One(connection_id),
+									event: NotifsHandlerIn::Open { protocol_index: set_id.into() },
+								});
+								*connec_state = ConnectionState::Opening;
+							} else {
+								// Connections in `OpeningThenClosing`, `Opening`, and `Closing`
+								// state can be in a Closed phase, and as such can emit
+								// `OpenDesiredByRemote` messages.
+								// Since an `Open` message haS already been sent, there is nothing
+								// more to do.
+								debug_assert!(matches!(
+									connec_state,
+									ConnectionState::OpenDesiredByRemote |
+										ConnectionState::Closing | ConnectionState::Opening
+								));
+							}
+						} else {
+							error!(
+								target: "sub-libp2p",
+								"OpenDesiredByRemote: State mismatch in the custom protos handler"
+							);
+							debug_assert!(false);
+						}
+
+						*entry.into_mut() = PeerState::Enabled { connections };
+					},
+
+					// Disabled => Disabled | Incoming
+					PeerState::Disabled { mut connections, backoff_until } => {
+						if let Some((_, connec_state)) =
+							connections.iter_mut().find(|(c, _)| *c == connection_id)
+						{
+							if let ConnectionState::Closed = *connec_state {
+								*connec_state = ConnectionState::OpenDesiredByRemote;
+
+								let incoming_id = self.next_incoming_index;
+								self.next_incoming_index.0 += 1;
+
+								trace!(target: "sub-libp2p", "PSM <= Incoming({}, {:?}, {:?}).",
+									peer_id, set_id, incoming_id);
+								self.protocol_controller_handles[usize::from(set_id)]
+									.incoming_connection(peer_id, incoming_id);
+								self.incoming.push(IncomingPeer {
+									peer_id,
+									set_id,
+									alive: true,
+									incoming_id,
+								});
+
+								*entry.into_mut() = PeerState::Incoming {
+									connections,
+									backoff_until,
+									incoming_index: incoming_id,
+								};
+							} else {
+								// Connections in `OpeningThenClosing` and `Closing` state can be
+								// in a Closed phase, and as such can emit `OpenDesiredByRemote`
+								// messages.
+								// We ignore them.
+								debug_assert!(matches!(
+									connec_state,
+									ConnectionState::OpeningThenClosing | ConnectionState::Closing
+								));
+								*entry.into_mut() =
+									PeerState::Disabled { connections, backoff_until };
+							}
+						} else {
+							error!(
+								target: "sub-libp2p",
+								"OpenDesiredByRemote: State mismatch in the custom protos handler"
+							);
+							debug_assert!(false);
+						}
+					},
+
+					// DisabledPendingEnable => Enabled | DisabledPendingEnable
+					PeerState::DisabledPendingEnable { mut connections, timer, timer_deadline } => {
+						if let Some((_, connec_state)) =
+							connections.iter_mut().find(|(c, _)| *c == connection_id)
+						{
+							if let ConnectionState::Closed = *connec_state {
+								trace!(target: "sub-libp2p", "Handler({:?}, {:?}) <= Open({:?})",
+									peer_id, connection_id, set_id);
+								self.events.push_back(ToSwarm::NotifyHandler {
+									peer_id,
+									handler: NotifyHandler::One(connection_id),
+									event: NotifsHandlerIn::Open { protocol_index: set_id.into() },
+								});
+								*connec_state = ConnectionState::Opening;
+
+								*entry.into_mut() = PeerState::Enabled { connections };
+							} else {
+								// Connections in `OpeningThenClosing` and `Closing` state can be
+								// in a Closed phase, and as such can emit `OpenDesiredByRemote`
+								// messages.
+								// We ignore them.
+								debug_assert!(matches!(
+									connec_state,
+									ConnectionState::OpeningThenClosing | ConnectionState::Closing
+								));
+								*entry.into_mut() = PeerState::DisabledPendingEnable {
+									connections,
+									timer,
+									timer_deadline,
+								};
+							}
+						} else {
+							error!(
+								target: "sub-libp2p",
+								"OpenDesiredByRemote: State mismatch in the custom protos handler"
+							);
+							debug_assert!(false);
+						}
+					},
+
+					state => {
+						error!(target: "sub-libp2p",
+							   "OpenDesiredByRemote: Unexpected state in the custom protos handler: {:?}",
+							   state);
+						debug_assert!(false);
+					},
+				};
+			},
+
+			NotifsHandlerOut::CloseDesired { protocol_index } => {
+				let set_id = SetId::from(protocol_index);
+
+				trace!(target: "sub-libp2p",
+					"Handler({}, {:?}) => CloseDesired({:?})",
+					peer_id, connection_id, set_id);
+
+				let mut entry = if let Entry::Occupied(entry) = self.peers.entry((peer_id, set_id))
+				{
+					entry
+				} else {
+					error!(target: "sub-libp2p", "CloseDesired: State mismatch in the custom protos handler");
+					debug_assert!(false);
+					return
+				};
+
+				match mem::replace(entry.get_mut(), PeerState::Poisoned) {
+					// Enabled => Enabled | Disabled
+					PeerState::Enabled { mut connections } => {
+						debug_assert!(connections.iter().any(|(_, s)| matches!(
+							s,
+							ConnectionState::Opening | ConnectionState::Open(_)
+						)));
+
+						let pos = if let Some(pos) =
+							connections.iter().position(|(c, _)| *c == connection_id)
+						{
+							pos
+						} else {
+							error!(target: "sub-libp2p",
+								"CloseDesired: State mismatch in the custom protos handler");
+							debug_assert!(false);
+							return
+						};
+
+						if matches!(connections[pos].1, ConnectionState::Closing) {
+							*entry.into_mut() = PeerState::Enabled { connections };
+							return
+						}
+
+						debug_assert!(matches!(connections[pos].1, ConnectionState::Open(_)));
+						connections[pos].1 = ConnectionState::Closing;
+
+						trace!(target: "sub-libp2p", "Handler({}, {:?}) <= Close({:?})", peer_id, connection_id, set_id);
+						self.events.push_back(ToSwarm::NotifyHandler {
+							peer_id,
+							handler: NotifyHandler::One(connection_id),
+							event: NotifsHandlerIn::Close { protocol_index: set_id.into() },
+						});
+
+						if let Some((replacement_pos, replacement_sink)) =
+							connections.iter().enumerate().find_map(|(num, (_, s))| match s {
+								ConnectionState::Open(s) => Some((num, s.clone())),
+								_ => None,
+							}) {
+							if pos <= replacement_pos {
+								trace!(target: "sub-libp2p", "External API <= Sink replaced({:?}, {:?})", peer_id, set_id);
+								let event = NotificationsOut::CustomProtocolReplaced {
+									peer_id,
+									set_id,
+									notifications_sink: replacement_sink,
+								};
+								self.events.push_back(ToSwarm::GenerateEvent(event));
+							}
+
+							*entry.into_mut() = PeerState::Enabled { connections };
+						} else {
+							// List of open connections wasn't empty before but now it is.
+							if !connections
+								.iter()
+								.any(|(_, s)| matches!(s, ConnectionState::Opening))
+							{
+								trace!(target: "sub-libp2p", "PSM <= Dropped({}, {:?})", peer_id, set_id);
+								self.protocol_controller_handles[usize::from(set_id)]
+									.dropped(peer_id);
+								*entry.into_mut() =
+									PeerState::Disabled { connections, backoff_until: None };
+							} else {
+								*entry.into_mut() = PeerState::Enabled { connections };
+							}
+
+							trace!(target: "sub-libp2p", "External API <= Closed({}, {:?})", peer_id, set_id);
+							let event = NotificationsOut::CustomProtocolClosed { peer_id, set_id };
+							self.events.push_back(ToSwarm::GenerateEvent(event));
+						}
+					},
+
+					// All connections in `Disabled` and `DisabledPendingEnable` have been sent a
+					// `Close` message already, and as such ignore any `CloseDesired` message.
+					state @ PeerState::Disabled { .. } |
+					state @ PeerState::DisabledPendingEnable { .. } => {
+						*entry.into_mut() = state;
+					},
+					state => {
+						error!(target: "sub-libp2p",
+							"Unexpected state in the custom protos handler: {:?}",
+							state);
+					},
+				}
+			},
+
+			NotifsHandlerOut::CloseResult { protocol_index } => {
+				let set_id = SetId::from(protocol_index);
+
+				trace!(target: "sub-libp2p",
+					"Handler({}, {:?}) => CloseResult({:?})",
+					peer_id, connection_id, set_id);
+
+				match self.peers.get_mut(&(peer_id, set_id)) {
+					// Move the connection from `Closing` to `Closed`.
+					Some(PeerState::Incoming { connections, .. }) |
+					Some(PeerState::DisabledPendingEnable { connections, .. }) |
+					Some(PeerState::Disabled { connections, .. }) |
+					Some(PeerState::Enabled { connections, .. }) => {
+						if let Some((_, connec_state)) = connections.iter_mut().find(|(c, s)| {
+							*c == connection_id && matches!(s, ConnectionState::Closing)
+						}) {
+							*connec_state = ConnectionState::Closed;
+						} else {
+							error!(target: "sub-libp2p",
+								"CloseResult: State mismatch in the custom protos handler");
+							debug_assert!(false);
+						}
+					},
+
+					state => {
+						error!(target: "sub-libp2p",
+							   "CloseResult: Unexpected state in the custom protos handler: {:?}",
+							   state);
+						debug_assert!(false);
+					},
+				}
+			},
+
+			NotifsHandlerOut::OpenResultOk {
+				protocol_index,
+				negotiated_fallback,
+				received_handshake,
+				notifications_sink,
+				inbound,
+				..
+			} => {
+				let set_id = SetId::from(protocol_index);
+				trace!(target: "sub-libp2p",
+					"Handler({}, {:?}) => OpenResultOk({:?})",
+					peer_id, connection_id, set_id);
+
+				match self.peers.get_mut(&(peer_id, set_id)) {
+					Some(PeerState::Enabled { connections, .. }) => {
+						debug_assert!(connections.iter().any(|(_, s)| matches!(
+							s,
+							ConnectionState::Opening | ConnectionState::Open(_)
+						)));
+						let any_open =
+							connections.iter().any(|(_, s)| matches!(s, ConnectionState::Open(_)));
+
+						if let Some((_, connec_state)) = connections.iter_mut().find(|(c, s)| {
+							*c == connection_id && matches!(s, ConnectionState::Opening)
+						}) {
+							if !any_open {
+								trace!(target: "sub-libp2p", "External API <= Open({}, {:?})", peer_id, set_id);
+								let event = NotificationsOut::CustomProtocolOpen {
+									peer_id,
+									set_id,
+									inbound,
+									negotiated_fallback,
+									received_handshake,
+									notifications_sink: notifications_sink.clone(),
+								};
+								self.events.push_back(ToSwarm::GenerateEvent(event));
+							}
+							*connec_state = ConnectionState::Open(notifications_sink);
+						} else if let Some((_, connec_state)) =
+							connections.iter_mut().find(|(c, s)| {
+								*c == connection_id &&
+									matches!(s, ConnectionState::OpeningThenClosing)
+							}) {
+							*connec_state = ConnectionState::Closing;
+						} else {
+							error!(target: "sub-libp2p",
+								"OpenResultOk State mismatch in the custom protos handler");
+							debug_assert!(false);
+						}
+					},
+
+					Some(PeerState::Incoming { connections, .. }) |
+					Some(PeerState::DisabledPendingEnable { connections, .. }) |
+					Some(PeerState::Disabled { connections, .. }) => {
+						if let Some((_, connec_state)) = connections.iter_mut().find(|(c, s)| {
+							*c == connection_id && matches!(s, ConnectionState::OpeningThenClosing)
+						}) {
+							*connec_state = ConnectionState::Closing;
+						} else {
+							error!(target: "sub-libp2p",
+								"OpenResultOk State mismatch in the custom protos handler");
+							debug_assert!(false);
+						}
+					},
+
+					state => {
+						error!(target: "sub-libp2p",
+							   "OpenResultOk: Unexpected state in the custom protos handler: {:?}",
+							   state);
+						debug_assert!(false);
+					},
+				}
+			},
+
+			NotifsHandlerOut::OpenResultErr { protocol_index } => {
+				let set_id = SetId::from(protocol_index);
+				trace!(target: "sub-libp2p",
+					"Handler({:?}, {:?}) => OpenResultErr({:?})",
+					peer_id, connection_id, set_id);
+
+				let mut entry = if let Entry::Occupied(entry) = self.peers.entry((peer_id, set_id))
+				{
+					entry
+				} else {
+					error!(target: "sub-libp2p", "OpenResultErr: State mismatch in the custom protos handler");
+					debug_assert!(false);
+					return
+				};
+
+				match mem::replace(entry.get_mut(), PeerState::Poisoned) {
+					PeerState::Enabled { mut connections } => {
+						debug_assert!(connections.iter().any(|(_, s)| matches!(
+							s,
+							ConnectionState::Opening | ConnectionState::Open(_)
+						)));
+
+						if let Some((_, connec_state)) = connections.iter_mut().find(|(c, s)| {
+							*c == connection_id && matches!(s, ConnectionState::Opening)
+						}) {
+							*connec_state = ConnectionState::Closed;
+						} else if let Some((_, connec_state)) =
+							connections.iter_mut().find(|(c, s)| {
+								*c == connection_id &&
+									matches!(s, ConnectionState::OpeningThenClosing)
+							}) {
+							*connec_state = ConnectionState::Closing;
+						} else {
+							error!(target: "sub-libp2p",
+								"OpenResultErr: State mismatch in the custom protos handler");
+							debug_assert!(false);
+						}
+
+						if !connections.iter().any(|(_, s)| {
+							matches!(s, ConnectionState::Opening | ConnectionState::Open(_))
+						}) {
+							trace!(target: "sub-libp2p", "PSM <= Dropped({:?}, {:?})", peer_id, set_id);
+							self.protocol_controller_handles[usize::from(set_id)].dropped(peer_id);
+
+							let ban_dur = Uniform::new(5, 10).sample(&mut rand::thread_rng());
+							*entry.into_mut() = PeerState::Disabled {
+								connections,
+								backoff_until: Some(Instant::now() + Duration::from_secs(ban_dur)),
+							};
+						} else {
+							*entry.into_mut() = PeerState::Enabled { connections };
+						}
+					},
+					mut state @ PeerState::Incoming { .. } |
+					mut state @ PeerState::DisabledPendingEnable { .. } |
+					mut state @ PeerState::Disabled { .. } => {
+						match &mut state {
+							PeerState::Incoming { connections, .. } |
+							PeerState::Disabled { connections, .. } |
+							PeerState::DisabledPendingEnable { connections, .. } => {
+								if let Some((_, connec_state)) =
+									connections.iter_mut().find(|(c, s)| {
+										*c == connection_id &&
+											matches!(s, ConnectionState::OpeningThenClosing)
+									}) {
+									*connec_state = ConnectionState::Closing;
+								} else {
+									error!(target: "sub-libp2p",
+										"OpenResultErr: State mismatch in the custom protos handler");
+									debug_assert!(false);
+								}
+							},
+							_ => unreachable!(
+								"Match branches are the same as the one on which we
+							enter this block; qed"
+							),
+						};
+
+						*entry.into_mut() = state;
+					},
+					state => {
+						error!(target: "sub-libp2p",
+							"Unexpected state in the custom protos handler: {:?}",
+							state);
+						debug_assert!(false);
+					},
+				};
+			},
+
+			NotifsHandlerOut::Notification { protocol_index, message } => {
+				let set_id = SetId::from(protocol_index);
+				if self.is_open(&peer_id, set_id) {
+					trace!(
+						target: "sub-libp2p",
+						"Handler({:?}) => Notification({}, {:?}, {} bytes)",
+						connection_id,
+						peer_id,
+						set_id,
+						message.len()
+					);
+					trace!(
+						target: "sub-libp2p",
+						"External API <= Message({}, {:?})",
+						peer_id,
+						set_id,
+					);
+					let event = NotificationsOut::Notification { peer_id, set_id, message };
+
+					self.events.push_back(ToSwarm::GenerateEvent(event));
+				} else {
+					trace!(
+						target: "sub-libp2p",
+						"Handler({:?}) => Post-close notification({}, {:?}, {} bytes)",
+						connection_id,
+						peer_id,
+						set_id,
+						message.len()
+					);
+				}
+			},
+		}
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut Context,
+		_params: &mut impl PollParameters,
+	) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
+		if let Some(event) = self.events.pop_front() {
+			return Poll::Ready(event)
+		}
+
+		// Poll for instructions from the protocol controllers.
+		loop {
+			match futures::Stream::poll_next(Pin::new(&mut self.from_protocol_controllers), cx) {
+				Poll::Ready(Some(Message::Accept(index))) => {
+					self.peerset_report_accept(index);
+				},
+				Poll::Ready(Some(Message::Reject(index))) => {
+					self.peerset_report_reject(index);
+				},
+				Poll::Ready(Some(Message::Connect { peer_id, set_id, .. })) => {
+					self.peerset_report_connect(peer_id, set_id);
+				},
+				Poll::Ready(Some(Message::Drop { peer_id, set_id, .. })) => {
+					self.peerset_report_disconnect(peer_id, set_id);
+				},
+				Poll::Ready(None) => {
+					error!(
+						target: "sub-libp2p",
+						"Protocol controllers receiver stream has returned `None`. Ignore this error if the node is shutting down.",
+					);
+					break
+				},
+				Poll::Pending => break,
+			}
+		}
+
+		while let Poll::Ready(Some((delay_id, peer_id, set_id))) =
+			Pin::new(&mut self.delays).poll_next(cx)
+		{
+			let peer_state = match self.peers.get_mut(&(peer_id, set_id)) {
+				Some(s) => s,
+				// We intentionally never remove elements from `delays`, and it may
+				// thus contain peers which are now gone. This is a normal situation.
+				None => continue,
+			};
+
+			match peer_state {
+				PeerState::Backoff { timer, .. } if *timer == delay_id => {
+					trace!(target: "sub-libp2p", "Libp2p <= Clean up ban of {:?} from the state ({:?})", peer_id, set_id);
+					self.peers.remove(&(peer_id, set_id));
+				},
+
+				PeerState::PendingRequest { timer, .. } if *timer == delay_id => {
+					trace!(target: "sub-libp2p", "Libp2p <= Dial {:?} now that ban has expired ({:?})", peer_id, set_id);
+					self.events.push_back(ToSwarm::Dial { opts: peer_id.into() });
+					*peer_state = PeerState::Requested;
+				},
+
+				PeerState::DisabledPendingEnable { connections, timer, timer_deadline }
+					if *timer == delay_id =>
+				{
+					// The first element of `closed` is chosen to open the notifications substream.
+					if let Some((connec_id, connec_state)) =
+						connections.iter_mut().find(|(_, s)| matches!(s, ConnectionState::Closed))
+					{
+						trace!(target: "sub-libp2p", "Handler({}, {:?}) <= Open({:?}) (ban expired)",
+							peer_id, *connec_id, set_id);
+						self.events.push_back(ToSwarm::NotifyHandler {
+							peer_id,
+							handler: NotifyHandler::One(*connec_id),
+							event: NotifsHandlerIn::Open { protocol_index: set_id.into() },
+						});
+						*connec_state = ConnectionState::Opening;
+						*peer_state = PeerState::Enabled { connections: mem::take(connections) };
+					} else {
+						*timer_deadline = Instant::now() + Duration::from_secs(5);
+						let delay = futures_timer::Delay::new(Duration::from_secs(5));
+						let timer = *timer;
+						self.delays.push(
+							async move {
+								delay.await;
+								(timer, peer_id, set_id)
+							}
+							.boxed(),
+						);
+					}
+				},
+
+				// We intentionally never remove elements from `delays`, and it may
+				// thus contain obsolete entries. This is a normal situation.
+				_ => {},
+			}
+		}
+
+		if let Some(event) = self.events.pop_front() {
+			return Poll::Ready(event)
+		}
+
+		Poll::Pending
+	}
+}
+
+#[cfg(test)]
+#[allow(deprecated)]
+mod tests {
+	use super::*;
+	use crate::{
+		mock::MockPeerStore,
+		protocol::notifications::handler::tests::*,
+		protocol_controller::{IncomingIndex, ProtoSetConfig, ProtocolController},
+	};
+	use libp2p::swarm::AddressRecord;
+	use sc_utils::mpsc::tracing_unbounded;
+	use std::{collections::HashSet, iter};
+
+	impl PartialEq for ConnectionState {
+		fn eq(&self, other: &ConnectionState) -> bool {
+			match (self, other) {
+				(ConnectionState::Closed, ConnectionState::Closed) => true,
+				(ConnectionState::Closing, ConnectionState::Closing) => true,
+				(ConnectionState::Opening, ConnectionState::Opening) => true,
+				(ConnectionState::OpeningThenClosing, ConnectionState::OpeningThenClosing) => true,
+				(ConnectionState::OpenDesiredByRemote, ConnectionState::OpenDesiredByRemote) =>
+					true,
+				(ConnectionState::Open(_), ConnectionState::Open(_)) => true,
+				_ => false,
+			}
+		}
+	}
+
+	#[derive(Clone)]
+	struct MockPollParams {
+		peer_id: PeerId,
+		addr: Multiaddr,
+	}
+
+	impl PollParameters for MockPollParams {
+		type SupportedProtocolsIter = std::vec::IntoIter<Vec<u8>>;
+		type ListenedAddressesIter = std::vec::IntoIter<Multiaddr>;
+		type ExternalAddressesIter = std::vec::IntoIter<AddressRecord>;
+
+		fn supported_protocols(&self) -> Self::SupportedProtocolsIter {
+			vec![].into_iter()
+		}
+
+		fn listened_addresses(&self) -> Self::ListenedAddressesIter {
+			vec![self.addr.clone()].into_iter()
+		}
+
+		fn external_addresses(&self) -> Self::ExternalAddressesIter {
+			vec![].into_iter()
+		}
+
+		fn local_peer_id(&self) -> &PeerId {
+			&self.peer_id
+		}
+	}
+
+	fn development_notifs() -> (Notifications, ProtocolController) {
+		let (to_notifications, from_controller) =
+			tracing_unbounded("test_controller_to_notifications", 10_000);
+
+		let (handle, controller) = ProtocolController::new(
+			SetId::from(0),
+			ProtoSetConfig {
+				in_peers: 25,
+				out_peers: 25,
+				reserved_nodes: HashSet::new(),
+				reserved_only: false,
+			},
+			to_notifications,
+			Box::new(MockPeerStore {}),
+		);
+
+		(
+			Notifications::new(
+				vec![handle],
+				from_controller,
+				iter::once(ProtocolConfig {
+					name: "/foo".into(),
+					fallback_names: Vec::new(),
+					handshake: vec![1, 2, 3, 4],
+					max_notification_size: u64::MAX,
+				}),
+			),
+			controller,
+		)
+	}
+
+	#[test]
+	fn update_handshake() {
+		let (mut notif, _controller) = development_notifs();
+
+		let inner = notif.notif_protocols.get_mut(0).unwrap().handshake.read().clone();
+		assert_eq!(inner, vec![1, 2, 3, 4]);
+
+		notif.set_notif_protocol_handshake(0.into(), vec![5, 6, 7, 8]);
+
+		let inner = notif.notif_protocols.get_mut(0).unwrap().handshake.read().clone();
+		assert_eq!(inner, vec![5, 6, 7, 8]);
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn update_unknown_handshake() {
+		let (mut notif, _controller) = development_notifs();
+
+		notif.set_notif_protocol_handshake(1337.into(), vec![5, 6, 7, 8]);
+	}
+
+	#[test]
+	fn disconnect_backoff_peer() {
+		let (mut notif, _controller) = development_notifs();
+
+		let peer = PeerId::random();
+		notif.peers.insert(
+			(peer, 0.into()),
+			PeerState::Backoff { timer: DelayId(0), timer_deadline: Instant::now() },
+		);
+		notif.disconnect_peer(&peer, 0.into());
+
+		assert!(std::matches!(
+			notif.peers.get(&(peer, 0.into())),
+			Some(PeerState::Backoff { timer: DelayId(0), .. })
+		));
+	}
+
+	#[test]
+	fn disconnect_pending_request() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+
+		notif.peers.insert(
+			(peer, 0.into()),
+			PeerState::PendingRequest { timer: DelayId(0), timer_deadline: Instant::now() },
+		);
+		notif.disconnect_peer(&peer, 0.into());
+
+		assert!(std::matches!(
+			notif.peers.get(&(peer, 0.into())),
+			Some(PeerState::PendingRequest { timer: DelayId(0), .. })
+		));
+	}
+
+	#[test]
+	fn disconnect_requested_peer() {
+		let (mut notif, _controller) = development_notifs();
+
+		let peer = PeerId::random();
+		notif.peers.insert((peer, 0.into()), PeerState::Requested);
+		notif.disconnect_peer(&peer, 0.into());
+
+		assert!(std::matches!(notif.peers.get(&(peer, 0.into())), Some(PeerState::Requested)));
+	}
+
+	#[test]
+	fn disconnect_disabled_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		notif.peers.insert(
+			(peer, 0.into()),
+			PeerState::Disabled { backoff_until: None, connections: SmallVec::new() },
+		);
+		notif.disconnect_peer(&peer, 0.into());
+
+		assert!(std::matches!(
+			notif.peers.get(&(peer, 0.into())),
+			Some(PeerState::Disabled { backoff_until: None, .. })
+		));
+	}
+
+	#[test]
+	fn remote_opens_connection_and_substream() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+
+		if let Some(&PeerState::Disabled { ref connections, backoff_until: None }) =
+			notif.peers.get(&(peer, 0.into()))
+		{
+			assert_eq!(connections[0], (conn, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+
+		if let Some(&PeerState::Incoming { ref connections, backoff_until: None, .. }) =
+			notif.peers.get(&(peer, 0.into()))
+		{
+			assert_eq!(connections.len(), 1);
+			assert_eq!(connections[0], (conn, ConnectionState::OpenDesiredByRemote));
+		} else {
+			panic!("invalid state");
+		}
+
+		assert!(std::matches!(
+			notif.incoming.pop(),
+			Some(IncomingPeer { alive: true, incoming_id: IncomingIndex(0), .. }),
+		));
+	}
+
+	#[tokio::test]
+	async fn disconnect_remote_substream_before_handled_by_controller() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		notif.disconnect_peer(&peer, 0.into());
+
+		if let Some(&PeerState::Disabled { ref connections, backoff_until: None }) =
+			notif.peers.get(&(peer, 0.into()))
+		{
+			assert_eq!(connections.len(), 1);
+			assert_eq!(connections[0], (conn, ConnectionState::Closing));
+		} else {
+			panic!("invalid state");
+		}
+	}
+
+	#[test]
+	fn peerset_report_connect_backoff() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		//
+		// there is not straight-forward way of adding backoff to `PeerState::Disabled`
+		// so manually adjust the value in order to progress on to the next stage.
+		// This modification together with `ConnectionClosed` will conver the peer
+		// state into `PeerState::Backoff`.
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+
+		let timer = if let Some(&PeerState::Backoff { timer_deadline, .. }) =
+			notif.peers.get(&(peer, set_id))
+		{
+			timer_deadline
+		} else {
+			panic!("invalid state");
+		};
+
+		// attempt to connect the backed-off peer and verify that the request is pending
+		notif.peerset_report_connect(peer, set_id);
+
+		if let Some(&PeerState::PendingRequest { timer_deadline, .. }) =
+			notif.peers.get(&(peer, set_id))
+		{
+			assert_eq!(timer, timer_deadline);
+		} else {
+			panic!("invalid state");
+		}
+	}
+
+	#[test]
+	fn peerset_connect_incoming() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+
+		// attempt to connect to the peer and verify that the peer state is `Enabled`;
+		// we rely on implementation detail that incoming indices are counted from 0
+		// to not mock the `Peerset`
+		notif.peerset_report_accept(IncomingIndex(0));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+	}
+
+	#[test]
+	fn peerset_disconnect_disable_pending_enable() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		// switch state to `DisabledPendingEnable`
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::DisabledPendingEnable { .. })
+		));
+
+		notif.peerset_report_disconnect(peer, set_id);
+
+		if let Some(PeerState::Disabled { backoff_until, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert!(backoff_until.is_some());
+			assert!(backoff_until.unwrap() > Instant::now());
+		} else {
+			panic!("invalid state");
+		}
+	}
+
+	#[test]
+	fn peerset_disconnect_enabled() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		// Set peer into `Enabled` state.
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		// we rely on the implementation detail that incoming indices are counted from 0
+		// to not mock the `Peerset`
+		notif.peerset_report_accept(IncomingIndex(0));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		// disconnect peer and verify that the state is `Disabled`
+		notif.peerset_report_disconnect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+	}
+
+	#[test]
+	fn peerset_disconnect_requested() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+
+		// Set peer into `Requested` state.
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Requested)));
+
+		// disconnect peer and verify that the state is `Disabled`
+		notif.peerset_report_disconnect(peer, set_id);
+		assert!(notif.peers.get(&(peer, set_id)).is_none());
+	}
+
+	#[test]
+	fn peerset_disconnect_pending_request() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+
+		// attempt to connect the backed-off peer and verify that the request is pending
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::PendingRequest { .. })
+		));
+
+		// attempt to disconnect the backed-off peer and verify that the request is pending
+		notif.peerset_report_disconnect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+	}
+
+	#[test]
+	fn peerset_accept_peer_not_alive() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		assert!(std::matches!(
+			notif.incoming[0],
+			IncomingPeer { alive: true, incoming_id: IncomingIndex(0), .. },
+		));
+
+		notif.disconnect_peer(&peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+		assert!(std::matches!(
+			notif.incoming[0],
+			IncomingPeer { alive: false, incoming_id: IncomingIndex(0), .. },
+		));
+
+		notif.peerset_report_accept(IncomingIndex(0));
+		assert_eq!(notif.incoming.len(), 0);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(PeerState::Disabled { .. })));
+	}
+
+	#[test]
+	fn secondary_connection_peer_state_incoming() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let conn2 = ConnectionId::new_unchecked(1);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		if let Some(PeerState::Incoming { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections.len(), 1);
+			assert_eq!(connections[0], (conn, ConnectionState::OpenDesiredByRemote));
+		} else {
+			panic!("invalid state");
+		}
+
+		// add another connection
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn2,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+
+		if let Some(PeerState::Incoming { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections.len(), 2);
+			assert_eq!(connections[0], (conn, ConnectionState::OpenDesiredByRemote));
+			assert_eq!(connections[1], (conn2, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+	}
+
+	#[test]
+	fn close_connection_for_disabled_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(notif.peers.get(&(peer, set_id)).is_none());
+	}
+
+	#[test]
+	fn close_connection_for_incoming_peer_one_connection() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(notif.peers.get(&(peer, set_id)).is_none());
+		assert!(std::matches!(
+			notif.incoming[0],
+			IncomingPeer { alive: false, incoming_id: IncomingIndex(0), .. },
+		));
+	}
+
+	#[test]
+	fn close_connection_for_incoming_peer_two_connections() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let conn1 = ConnectionId::new_unchecked(1);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conns = SmallVec::<
+			[(ConnectionId, ConnectionState); crate::MAX_CONNECTIONS_PER_PEER],
+		>::from(vec![(conn, ConnectionState::Closed)]);
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn1,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		conns.push((conn1, ConnectionState::Closed));
+
+		if let Some(PeerState::Incoming { ref connections, .. }) = notif.peers.get(&(peer, set_id))
+		{
+			assert_eq!(connections.len(), 2);
+			assert_eq!(connections[0], (conn, ConnectionState::OpenDesiredByRemote));
+			assert_eq!(connections[1], (conn1, ConnectionState::Closed));
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+
+		if let Some(PeerState::Disabled { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections.len(), 1);
+			assert_eq!(connections[0], (conn1, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+	}
+
+	#[test]
+	fn connection_and_substream_open() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		// move the peer to `Enabled` state
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		// We rely on the implementation detail that incoming indices are counted
+		// from 0 to not mock the `Peerset`.
+		notif.peerset_report_accept(IncomingIndex(0));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		// open new substream
+		let event = conn_yielder.open_substream(peer, 0, connected, vec![1, 2, 3, 4]);
+
+		notif.on_connection_handler_event(peer, conn, event);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		if let Some(PeerState::Enabled { ref connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections.len(), 1);
+			assert_eq!(connections[0].0, conn);
+			assert!(std::matches!(connections[0].1, ConnectionState::Open(_)));
+		}
+
+		assert!(std::matches!(
+			notif.events[notif.events.len() - 1],
+			ToSwarm::GenerateEvent(NotificationsOut::CustomProtocolOpen { .. })
+		));
+	}
+
+	#[test]
+	fn connection_closed_sink_replaced() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn1 = ConnectionId::new_unchecked(0);
+		let conn2 = ConnectionId::new_unchecked(1);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		// open two connections
+		for conn_id in vec![conn1, conn2] {
+			notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+				libp2p::swarm::behaviour::ConnectionEstablished {
+					peer_id: peer,
+					connection_id: conn_id,
+					endpoint: &connected,
+					failed_addresses: &[],
+					other_established: 0usize,
+				},
+			));
+		}
+
+		if let Some(PeerState::Disabled { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0], (conn1, ConnectionState::Closed));
+			assert_eq!(connections[1], (conn2, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+
+		// open substreams on both active connections
+		notif.peerset_report_connect(peer, set_id);
+		notif.on_connection_handler_event(
+			peer,
+			conn2,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+
+		if let Some(PeerState::Enabled { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0], (conn1, ConnectionState::Opening));
+			assert_eq!(connections[1], (conn2, ConnectionState::Opening));
+		} else {
+			panic!("invalid state");
+		}
+
+		// add two new substreams, one for each connection and verify that both are in open state
+		for conn in vec![conn1, conn2].iter() {
+			notif.on_connection_handler_event(
+				peer,
+				*conn,
+				conn_yielder.open_substream(peer, 0, connected.clone(), vec![1, 2, 3, 4]),
+			);
+		}
+
+		if let Some(PeerState::Enabled { ref connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0].0, conn1);
+			assert!(std::matches!(connections[0].1, ConnectionState::Open(_)));
+			assert_eq!(connections[1].0, conn2);
+			assert!(std::matches!(connections[1].1, ConnectionState::Open(_)));
+		} else {
+			panic!("invalid state");
+		}
+
+		// check peer information
+		assert_eq!(notif.open_peers().collect::<Vec<_>>(), vec![&peer],);
+
+		// close the other connection and verify that notification replacement event is emitted
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn1,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+
+		if let Some(PeerState::Enabled { ref connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections.len(), 1);
+			assert_eq!(connections[0].0, conn2);
+			assert!(std::matches!(connections[0].1, ConnectionState::Open(_)));
+		} else {
+			panic!("invalid state");
+		}
+
+		assert!(std::matches!(
+			notif.events[notif.events.len() - 1],
+			ToSwarm::GenerateEvent(NotificationsOut::CustomProtocolReplaced { .. })
+		));
+	}
+
+	#[test]
+	fn dial_failure_for_requested_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+
+		// Set peer into `Requested` state.
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Requested)));
+
+		notif.on_swarm_event(FromSwarm::DialFailure(libp2p::swarm::behaviour::DialFailure {
+			peer_id: Some(peer),
+			error: &libp2p::swarm::DialError::Banned,
+			connection_id: ConnectionId::new_unchecked(1337),
+		}));
+
+		if let Some(PeerState::Backoff { timer_deadline, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert!(timer_deadline > &Instant::now());
+		} else {
+			panic!("invalid state");
+		}
+	}
+
+	#[tokio::test]
+	async fn write_notification() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			conn_yielder.open_substream(peer, 0, connected, vec![1, 2, 3, 4]),
+		);
+
+		if let Some(PeerState::Enabled { ref connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0].0, conn);
+			assert!(std::matches!(connections[0].1, ConnectionState::Open(_)));
+		} else {
+			panic!("invalid state");
+		}
+
+		notif
+			.peers
+			.get(&(peer, set_id))
+			.unwrap()
+			.get_open()
+			.unwrap()
+			.send_sync_notification(vec![1, 3, 3, 7]);
+		assert_eq!(conn_yielder.get_next_event(peer, set_id.into()).await, Some(vec![1, 3, 3, 7]));
+	}
+
+	#[test]
+	fn peerset_report_connect_backoff_expired() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let backoff_duration = Duration::from_millis(100);
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until = Some(Instant::now().checked_add(backoff_duration).unwrap());
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+
+		// wait until the backoff time has passed
+		std::thread::sleep(backoff_duration * 2);
+
+		// attempt to connect the backed-off peer and verify that the request is pending
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Requested { .. })))
+	}
+
+	#[test]
+	fn peerset_report_disconnect_disabled() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.peerset_report_disconnect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+	}
+
+	#[test]
+	fn peerset_report_disconnect_backoff() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let backoff_duration = Duration::from_secs(2);
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until = Some(Instant::now().checked_add(backoff_duration).unwrap());
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+
+		notif.peerset_report_disconnect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+	}
+
+	#[test]
+	fn peer_is_backed_off_if_both_connections_get_closed_while_peer_is_disabled_with_back_off() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn1 = ConnectionId::new_unchecked(0);
+		let conn2 = ConnectionId::new_unchecked(1);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn1,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn2,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		// switch state to `DisabledPendingEnable`
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::DisabledPendingEnable { .. })
+		));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn1,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected.clone(), vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::DisabledPendingEnable { .. })
+		));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn2,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+	}
+
+	#[test]
+	fn inject_connection_closed_incoming_with_backoff() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+
+		// manually add backoff for the entry
+		if let Some(&mut PeerState::Incoming { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, 0.into()))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		} else {
+			panic!("invalid state");
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+	}
+
+	#[test]
+	fn two_connections_inactive_connection_gets_closed_peer_state_is_still_incoming() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn1 = ConnectionId::new_unchecked(0);
+		let conn2 = ConnectionId::new_unchecked(1);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		// open two connections
+		for conn_id in vec![conn1, conn2] {
+			notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+				libp2p::swarm::behaviour::ConnectionEstablished {
+					peer_id: peer,
+					connection_id: conn_id,
+					endpoint: &connected,
+					failed_addresses: &[],
+					other_established: 0usize,
+				},
+			));
+		}
+
+		if let Some(PeerState::Disabled { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0], (conn1, ConnectionState::Closed));
+			assert_eq!(connections[1], (conn2, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn1,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(
+			notif.peers.get_mut(&(peer, 0.into())),
+			Some(&mut PeerState::Incoming { .. })
+		));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn2,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+	}
+
+	#[test]
+	fn two_connections_active_connection_gets_closed_peer_state_is_disabled() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn1 = ConnectionId::new_unchecked(0);
+		let conn2 = ConnectionId::new_unchecked(1);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		// open two connections
+		for conn_id in vec![conn1, conn2] {
+			notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+				libp2p::swarm::behaviour::ConnectionEstablished {
+					peer_id: peer,
+					connection_id: conn_id,
+					endpoint: &ConnectedPoint::Listener {
+						local_addr: Multiaddr::empty(),
+						send_back_addr: Multiaddr::empty(),
+					},
+					failed_addresses: &[],
+					other_established: 0usize,
+				},
+			));
+		}
+
+		if let Some(PeerState::Disabled { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0], (conn1, ConnectionState::Closed));
+			assert_eq!(connections[1], (conn2, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn1,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(
+			notif.peers.get_mut(&(peer, 0.into())),
+			Some(PeerState::Incoming { .. })
+		));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn1,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+	}
+
+	#[test]
+	fn inject_connection_closed_for_active_connection() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn1 = ConnectionId::new_unchecked(0);
+		let conn2 = ConnectionId::new_unchecked(1);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		// open two connections
+		for conn_id in vec![conn1, conn2] {
+			notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+				libp2p::swarm::behaviour::ConnectionEstablished {
+					peer_id: peer,
+					connection_id: conn_id,
+					endpoint: &connected,
+					failed_addresses: &[],
+					other_established: 0usize,
+				},
+			));
+		}
+
+		if let Some(PeerState::Disabled { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0], (conn1, ConnectionState::Closed));
+			assert_eq!(connections[1], (conn2, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+
+		// open substreams on both active connections
+		notif.peerset_report_connect(peer, set_id);
+
+		if let Some(PeerState::Enabled { connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert_eq!(connections[0], (conn1, ConnectionState::Opening));
+			assert_eq!(connections[1], (conn2, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+
+		notif.on_connection_handler_event(
+			peer,
+			conn1,
+			conn_yielder.open_substream(peer, 0, connected.clone(), vec![1, 2, 3, 4]),
+		);
+
+		if let Some(PeerState::Enabled { ref connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert!(std::matches!(connections[0].1, ConnectionState::Open(_)));
+			assert_eq!(connections[0].0, conn1);
+			assert_eq!(connections[1], (conn2, ConnectionState::Closed));
+		} else {
+			panic!("invalid state");
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn1,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	fn inject_dial_failure_for_pending_request() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+
+		// attempt to connect the backed-off peer and verify that the request is pending
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::PendingRequest { .. })
+		));
+
+		let now = Instant::now();
+		notif.on_swarm_event(FromSwarm::DialFailure(libp2p::swarm::behaviour::DialFailure {
+			peer_id: Some(peer),
+			error: &libp2p::swarm::DialError::Banned,
+			connection_id: ConnectionId::new_unchecked(0),
+		}));
+
+		if let Some(PeerState::PendingRequest { ref timer_deadline, .. }) =
+			notif.peers.get(&(peer, set_id))
+		{
+			assert!(timer_deadline > &(now + std::time::Duration::from_secs(5)));
+		}
+	}
+
+	#[test]
+	fn peerstate_incoming_open_desired_by_remote() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+		let conn1 = ConnectionId::new_unchecked(0);
+		let conn2 = ConnectionId::new_unchecked(1);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn1,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn2,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn1,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		// add another open event from remote
+		notif.on_connection_handler_event(
+			peer,
+			conn2,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+
+		if let Some(PeerState::Incoming { ref connections, .. }) = notif.peers.get(&(peer, set_id))
+		{
+			assert_eq!(connections[0], (conn1, ConnectionState::OpenDesiredByRemote));
+			assert_eq!(connections[1], (conn2, ConnectionState::OpenDesiredByRemote));
+		}
+	}
+
+	#[tokio::test]
+	async fn remove_backoff_peer_after_timeout() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+
+		if let Some(&mut PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, 0.into()))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_millis(100)).unwrap());
+		} else {
+			panic!("invalid state");
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+
+		let until = if let Some(&PeerState::Backoff { timer_deadline, .. }) =
+			notif.peers.get(&(peer, set_id))
+		{
+			timer_deadline
+		} else {
+			panic!("invalid state");
+		};
+
+		if until > Instant::now() {
+			std::thread::sleep(until - Instant::now());
+		}
+
+		assert!(notif.peers.get(&(peer, set_id)).is_some());
+
+		if tokio::time::timeout(Duration::from_secs(5), async {
+			let mut params = MockPollParams { peer_id: PeerId::random(), addr: Multiaddr::empty() };
+
+			loop {
+				futures::future::poll_fn(|cx| {
+					let _ = notif.poll(cx, &mut params);
+					Poll::Ready(())
+				})
+				.await;
+
+				if notif.peers.get(&(peer, set_id)).is_none() {
+					break
+				}
+			}
+		})
+		.await
+		.is_err()
+		{
+			panic!("backoff peer was not removed in time");
+		}
+
+		assert!(notif.peers.get(&(peer, set_id)).is_none());
+	}
+
+	#[tokio::test]
+	async fn reschedule_disabled_pending_enable_when_connection_not_closed() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		// move the peer to `Enabled` state
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &ConnectedPoint::Listener {
+					local_addr: Multiaddr::empty(),
+					send_back_addr: Multiaddr::empty(),
+				},
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// open substream
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		// we rely on the implementation detail that incoming indices are counted from 0
+		// to not mock the `Peerset`
+		notif.peerset_report_accept(IncomingIndex(0));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		let event = conn_yielder.open_substream(peer, 0, connected, vec![1, 2, 3, 4]);
+
+		notif.on_connection_handler_event(peer, conn, event);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		if let Some(PeerState::Enabled { ref connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert!(std::matches!(connections[0], (_, ConnectionState::Open(_))));
+			assert_eq!(connections[0].0, conn);
+		} else {
+			panic!("invalid state");
+		}
+
+		notif.peerset_report_disconnect(peer, set_id);
+
+		if let Some(PeerState::Disabled { ref connections, ref mut backoff_until }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			assert!(std::matches!(connections[0], (_, ConnectionState::Closing)));
+			assert_eq!(connections[0].0, conn);
+
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(2)).unwrap());
+		} else {
+			panic!("invalid state");
+		}
+
+		notif.peerset_report_connect(peer, set_id);
+
+		let prev_instant =
+			if let Some(PeerState::DisabledPendingEnable {
+				ref connections, timer_deadline, ..
+			}) = notif.peers.get(&(peer, set_id))
+			{
+				assert!(std::matches!(connections[0], (_, ConnectionState::Closing)));
+				assert_eq!(connections[0].0, conn);
+
+				*timer_deadline
+			} else {
+				panic!("invalid state");
+			};
+
+		// one of the peers has an active backoff timer so poll the notifications code until
+		// the timer has expired. Because the connection is still in the state of `Closing`,
+		// verify that the code continues to keep the peer disabled by resetting the timer
+		// after the first one expired.
+		if tokio::time::timeout(Duration::from_secs(5), async {
+			let mut params = MockPollParams { peer_id: PeerId::random(), addr: Multiaddr::empty() };
+
+			loop {
+				futures::future::poll_fn(|cx| {
+					let _ = notif.poll(cx, &mut params);
+					Poll::Ready(())
+				})
+				.await;
+
+				if let Some(PeerState::DisabledPendingEnable {
+					timer_deadline, connections, ..
+				}) = notif.peers.get(&(peer, set_id))
+				{
+					assert!(std::matches!(connections[0], (_, ConnectionState::Closing)));
+
+					if timer_deadline != &prev_instant {
+						break
+					}
+				} else {
+					panic!("invalid state");
+				}
+			}
+		})
+		.await
+		.is_err()
+		{
+			panic!("backoff peer was not removed in time");
+		}
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn peerset_report_connect_with_enabled_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		// move the peer to `Enabled` state
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		let event = conn_yielder.open_substream(peer, 0, connected, vec![1, 2, 3, 4]);
+
+		notif.on_connection_handler_event(peer, conn, event);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		if let Some(PeerState::Enabled { ref connections, .. }) = notif.peers.get(&(peer, set_id)) {
+			assert!(std::matches!(connections[0], (_, ConnectionState::Open(_))));
+			assert_eq!(connections[0].0, conn);
+		} else {
+			panic!("invalid state");
+		}
+
+		notif.peerset_report_connect(peer, set_id);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	fn peerset_report_connect_with_disabled_pending_enable_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		// switch state to `DisabledPendingEnable`
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::DisabledPendingEnable { .. })
+		));
+
+		// duplicate "connect" must not change the state
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::DisabledPendingEnable { .. })
+		));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	fn peerset_report_connect_with_requested_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+
+		// Set peer into `Requested` state.
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Requested)));
+
+		// Duplicate "connect" must not change the state.
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Requested)));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	fn peerset_report_connect_with_pending_requested() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+
+		// attempt to connect the backed-off peer and verify that the request is pending
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::PendingRequest { .. })
+		));
+
+		// duplicate "connect" must not change the state
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::PendingRequest { .. })
+		));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	fn peerset_report_connect_with_incoming_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	fn peerset_report_disconnect_with_incoming_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		notif.peerset_report_disconnect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn peerset_report_accept_incoming_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		assert!(std::matches!(
+			notif.incoming[0],
+			IncomingPeer { alive: true, incoming_id: IncomingIndex(0), .. },
+		));
+
+		notif.peers.remove(&(peer, set_id));
+		notif.peerset_report_accept(IncomingIndex(0));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn peerset_report_accept_not_incoming_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		assert!(std::matches!(
+			notif.incoming[0],
+			IncomingPeer { alive: true, incoming_id: IncomingIndex(0), .. },
+		));
+
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		let event = conn_yielder.open_substream(peer, 0, connected, vec![1, 2, 3, 4]);
+		notif.on_connection_handler_event(peer, conn, event);
+
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+		notif.incoming[0].alive = true;
+		notif.peerset_report_accept(IncomingIndex(0));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn inject_connection_closed_non_existent_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let endpoint = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: ConnectionId::new_unchecked(0),
+				endpoint: &endpoint.clone(),
+				handler: NotifsHandler::new(peer, endpoint, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	fn disconnect_non_existent_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let set_id = SetId::from(0);
+
+		notif.peerset_report_disconnect(peer, set_id);
+
+		assert!(notif.peers.is_empty());
+		assert!(notif.incoming.is_empty());
+	}
+
+	#[test]
+	fn accept_non_existent_connection() {
+		let (mut notif, _controller) = development_notifs();
+
+		notif.peerset_report_accept(0.into());
+
+		assert!(notif.peers.is_empty());
+		assert!(notif.incoming.is_empty());
+	}
+
+	#[test]
+	fn reject_non_existent_connection() {
+		let (mut notif, _controller) = development_notifs();
+
+		notif.peerset_report_reject(0.into());
+
+		assert!(notif.peers.is_empty());
+		assert!(notif.incoming.is_empty());
+	}
+
+	#[test]
+	fn reject_non_active_connection() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		notif.incoming[0].alive = false;
+		notif.peerset_report_reject(0.into());
+
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn reject_non_existent_peer_but_alive_connection() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+		assert!(std::matches!(
+			notif.incoming[0],
+			IncomingPeer { alive: true, incoming_id: IncomingIndex(0), .. },
+		));
+
+		notif.peers.remove(&(peer, set_id));
+		notif.peerset_report_reject(0.into());
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn inject_non_existent_connection_closed_for_incoming_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: ConnectionId::new_unchecked(1337),
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn inject_non_existent_connection_closed_for_disabled_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: ConnectionId::new_unchecked(1337),
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn inject_non_existent_connection_closed_for_disabled_pending_enable() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		// switch state to `DisabledPendingEnable`
+		notif.peerset_report_connect(peer, set_id);
+
+		assert!(std::matches!(
+			notif.peers.get(&(peer, set_id)),
+			Some(&PeerState::DisabledPendingEnable { .. })
+		));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: ConnectionId::new_unchecked(1337),
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn inject_connection_closed_for_incoming_peer_state_mismatch() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+		notif.incoming[0].alive = false;
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn inject_connection_closed_for_enabled_state_mismatch() {
+		let (mut notif, _controller) = development_notifs();
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let set_id = SetId::from(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// remote opens a substream, verify that peer state is updated to `Incoming`
+		notif.on_connection_handler_event(
+			peer,
+			conn,
+			NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+		);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Incoming { .. })));
+
+		// attempt to connect to the peer and verify that the peer state is `Enabled`
+		notif.peerset_report_connect(peer, set_id);
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Enabled { .. })));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: ConnectionId::new_unchecked(1337),
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn inject_connection_closed_for_backoff_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let set_id = SetId::from(0);
+		let peer = PeerId::random();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+
+		notif.on_swarm_event(FromSwarm::ConnectionEstablished(
+			libp2p::swarm::behaviour::ConnectionEstablished {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected,
+				failed_addresses: &[],
+				other_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Disabled { .. })));
+
+		// manually add backoff for the entry
+		if let Some(PeerState::Disabled { ref mut backoff_until, .. }) =
+			notif.peers.get_mut(&(peer, set_id))
+		{
+			*backoff_until =
+				Some(Instant::now().checked_add(std::time::Duration::from_secs(5)).unwrap());
+		}
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected.clone(), vec![]),
+				remaining_established: 0usize,
+			},
+		));
+		assert!(std::matches!(notif.peers.get(&(peer, set_id)), Some(&PeerState::Backoff { .. })));
+
+		notif.on_swarm_event(FromSwarm::ConnectionClosed(
+			libp2p::swarm::behaviour::ConnectionClosed {
+				peer_id: peer,
+				connection_id: conn,
+				endpoint: &connected.clone(),
+				handler: NotifsHandler::new(peer, connected, vec![]),
+				remaining_established: 0usize,
+			},
+		));
+	}
+
+	#[test]
+	#[should_panic]
+	#[cfg(debug_assertions)]
+	fn open_result_ok_non_existent_peer() {
+		let (mut notif, _controller) = development_notifs();
+		let conn = ConnectionId::new_unchecked(0);
+		let connected = ConnectedPoint::Listener {
+			local_addr: Multiaddr::empty(),
+			send_back_addr: Multiaddr::empty(),
+		};
+		let mut conn_yielder = ConnectionYielder::new();
+
+		notif.on_connection_handler_event(
+			PeerId::random(),
+			conn,
+			conn_yielder.open_substream(PeerId::random(), 0, connected, vec![1, 2, 3, 4]),
+		);
+	}
+}
diff --git a/substrate/client/network/src/protocol/notifications/handler.rs b/substrate/client/network/src/protocol/notifications/handler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cffdec7d71ee4e11d3167e506e8ae71f70039e73
--- /dev/null
+++ b/substrate/client/network/src/protocol/notifications/handler.rs
@@ -0,0 +1,1613 @@
+// 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/>.
+
+//! Implementations of the `IntoConnectionHandler` and `ConnectionHandler` traits for both incoming
+//! and outgoing substreams for all gossiping protocols.
+//!
+//! This is the main implementation of `ConnectionHandler` in this crate, that handles all the
+//! gossiping protocols that are Substrate-related and outside of the scope of libp2p.
+//!
+//! # Usage
+//!
+//! From an API perspective, for each of its protocols, the [`NotifsHandler`] is always in one of
+//! the following state (see [`State`]):
+//!
+//! - Closed substream. This is the initial state.
+//! - Closed substream, but remote desires them to be open.
+//! - Open substream.
+//! - Open substream, but remote desires them to be closed.
+//!
+//! Each protocol in the [`NotifsHandler`] can spontaneously switch between these states:
+//!
+//! - "Closed substream" to "Closed substream but open desired". When that happens, a
+//! [`NotifsHandlerOut::OpenDesiredByRemote`] is emitted.
+//! - "Closed substream but open desired" to "Closed substream" (i.e. the remote has cancelled
+//! their request). When that happens, a [`NotifsHandlerOut::CloseDesired`] is emitted.
+//! - "Open substream" to "Open substream but close desired". When that happens, a
+//! [`NotifsHandlerOut::CloseDesired`] is emitted.
+//!
+//! The user can instruct a protocol in the `NotifsHandler` to switch from "closed" to "open" or
+//! vice-versa by sending either a [`NotifsHandlerIn::Open`] or a [`NotifsHandlerIn::Close`]. The
+//! `NotifsHandler` must answer with [`NotifsHandlerOut::OpenResultOk`] or
+//! [`NotifsHandlerOut::OpenResultErr`], or with [`NotifsHandlerOut::CloseResult`].
+//!
+//! When a [`NotifsHandlerOut::OpenResultOk`] is emitted, the substream is now in the open state.
+//! When a [`NotifsHandlerOut::OpenResultErr`] or [`NotifsHandlerOut::CloseResult`] is emitted,
+//! the `NotifsHandler` is now (or remains) in the closed state.
+//!
+//! When a [`NotifsHandlerOut::OpenDesiredByRemote`] is emitted, the user should always send back
+//! either a [`NotifsHandlerIn::Open`] or a [`NotifsHandlerIn::Close`].If this isn't done, the
+//! remote will be left in a pending state.
+//!
+//! It is illegal to send a [`NotifsHandlerIn::Open`] before a previously-emitted
+//! [`NotifsHandlerIn::Open`] has gotten an answer.
+
+use crate::{
+	protocol::notifications::upgrade::{
+		NotificationsIn, NotificationsInSubstream, NotificationsOut, NotificationsOutSubstream,
+		UpgradeCollec,
+	},
+	types::ProtocolName,
+};
+
+use bytes::BytesMut;
+use futures::{
+	channel::mpsc,
+	lock::{Mutex as FuturesMutex, MutexGuard as FuturesMutexGuard},
+	prelude::*,
+};
+use libp2p::{
+	core::ConnectedPoint,
+	swarm::{
+		handler::ConnectionEvent, ConnectionHandler, ConnectionHandlerEvent, KeepAlive,
+		NegotiatedSubstream, SubstreamProtocol,
+	},
+	PeerId,
+};
+use log::error;
+use parking_lot::{Mutex, RwLock};
+use std::{
+	collections::VecDeque,
+	mem,
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+	time::{Duration, Instant},
+};
+
+/// Number of pending notifications in asynchronous contexts.
+/// See [`NotificationsSink::reserve_notification`] for context.
+const ASYNC_NOTIFICATIONS_BUFFER_SIZE: usize = 8;
+
+/// Number of pending notifications in synchronous contexts.
+const SYNC_NOTIFICATIONS_BUFFER_SIZE: usize = 2048;
+
+/// Maximum duration to open a substream and receive the handshake message. After that, we
+/// consider that we failed to open the substream.
+const OPEN_TIMEOUT: Duration = Duration::from_secs(10);
+
+/// After successfully establishing a connection with the remote, we keep the connection open for
+/// at least this amount of time in order to give the rest of the code the chance to notify us to
+/// open substreams.
+const INITIAL_KEEPALIVE_TIME: Duration = Duration::from_secs(5);
+
+/// The actual handler once the connection has been established.
+///
+/// See the documentation at the module level for more information.
+pub struct NotifsHandler {
+	/// List of notification protocols, specified by the user at initialization.
+	protocols: Vec<Protocol>,
+
+	/// When the connection with the remote has been successfully established.
+	when_connection_open: Instant,
+
+	/// Whether we are the connection dialer or listener.
+	endpoint: ConnectedPoint,
+
+	/// Remote we are connected to.
+	peer_id: PeerId,
+
+	/// Events to return in priority from `poll`.
+	events_queue: VecDeque<
+		ConnectionHandlerEvent<NotificationsOut, usize, NotifsHandlerOut, NotifsHandlerError>,
+	>,
+}
+
+impl NotifsHandler {
+	/// Creates new [`NotifsHandler`].
+	pub fn new(peer_id: PeerId, endpoint: ConnectedPoint, protocols: Vec<ProtocolConfig>) -> Self {
+		Self {
+			protocols: protocols
+				.into_iter()
+				.map(|config| {
+					let in_upgrade = NotificationsIn::new(
+						config.name.clone(),
+						config.fallback_names.clone(),
+						config.max_notification_size,
+					);
+
+					Protocol { config, in_upgrade, state: State::Closed { pending_opening: false } }
+				})
+				.collect(),
+			peer_id,
+			endpoint,
+			when_connection_open: Instant::now(),
+			events_queue: VecDeque::with_capacity(16),
+		}
+	}
+}
+
+/// Configuration for a notifications protocol.
+#[derive(Debug, Clone)]
+pub struct ProtocolConfig {
+	/// Name of the protocol.
+	pub name: ProtocolName,
+	/// Names of the protocol to use if the main one isn't available.
+	pub fallback_names: Vec<ProtocolName>,
+	/// Handshake of the protocol. The `RwLock` is locked every time a new substream is opened.
+	pub handshake: Arc<RwLock<Vec<u8>>>,
+	/// Maximum allowed size for a notification.
+	pub max_notification_size: u64,
+}
+
+/// Fields specific for each individual protocol.
+struct Protocol {
+	/// Other fields.
+	config: ProtocolConfig,
+
+	/// Prototype for the inbound upgrade.
+	in_upgrade: NotificationsIn,
+
+	/// Current state of the substreams for this protocol.
+	state: State,
+}
+
+/// See the module-level documentation to learn about the meaning of these variants.
+enum State {
+	/// Protocol is in the "Closed" state.
+	Closed {
+		/// True if an outgoing substream is still in the process of being opened.
+		pending_opening: bool,
+	},
+
+	/// Protocol is in the "Closed" state. A [`NotifsHandlerOut::OpenDesiredByRemote`] has been
+	/// emitted.
+	OpenDesiredByRemote {
+		/// Substream opened by the remote and that hasn't been accepted/rejected yet.
+		in_substream: NotificationsInSubstream<NegotiatedSubstream>,
+
+		/// See [`State::Closed::pending_opening`].
+		pending_opening: bool,
+	},
+
+	/// Protocol is in the "Closed" state, but has received a [`NotifsHandlerIn::Open`] and is
+	/// consequently trying to open the various notifications substreams.
+	///
+	/// A [`NotifsHandlerOut::OpenResultOk`] or a [`NotifsHandlerOut::OpenResultErr`] event must
+	/// be emitted when transitionning to respectively [`State::Open`] or [`State::Closed`].
+	Opening {
+		/// Substream opened by the remote. If `Some`, has been accepted.
+		in_substream: Option<NotificationsInSubstream<NegotiatedSubstream>>,
+		/// Is the connection inbound.
+		inbound: bool,
+	},
+
+	/// Protocol is in the "Open" state.
+	Open {
+		/// Contains the two `Receiver`s connected to the [`NotificationsSink`] that has been
+		/// sent out. The notifications to send out can be pulled from this receivers.
+		/// We use two different channels in order to have two different channel sizes, but from
+		/// the receiving point of view, the two channels are the same.
+		/// The receivers are fused in case the user drops the [`NotificationsSink`] entirely.
+		notifications_sink_rx: stream::Peekable<
+			stream::Select<
+				stream::Fuse<mpsc::Receiver<NotificationsSinkMessage>>,
+				stream::Fuse<mpsc::Receiver<NotificationsSinkMessage>>,
+			>,
+		>,
+
+		/// Outbound substream that has been accepted by the remote.
+		///
+		/// Always `Some` on transition to [`State::Open`]. Switched to `None` only if the remote
+		/// closed the substream. If `None`, a [`NotifsHandlerOut::CloseDesired`] event has been
+		/// emitted.
+		out_substream: Option<NotificationsOutSubstream<NegotiatedSubstream>>,
+
+		/// Substream opened by the remote.
+		///
+		/// Contrary to the `out_substream` field, operations continue as normal even if the
+		/// substream has been closed by the remote. A `None` is treated the same way as if there
+		/// was an idle substream.
+		in_substream: Option<NotificationsInSubstream<NegotiatedSubstream>>,
+	},
+}
+
+/// Event that can be received by a `NotifsHandler`.
+#[derive(Debug, Clone)]
+pub enum NotifsHandlerIn {
+	/// Instruct the handler to open the notification substreams.
+	///
+	/// Must always be answered by a [`NotifsHandlerOut::OpenResultOk`] or a
+	/// [`NotifsHandlerOut::OpenResultErr`] event.
+	///
+	/// Importantly, it is forbidden to send a [`NotifsHandlerIn::Open`] while a previous one is
+	/// already in the fly. It is however possible if a `Close` is still in the fly.
+	Open {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+	},
+
+	/// Instruct the handler to close the notification substreams, or reject any pending incoming
+	/// substream request.
+	///
+	/// Must always be answered by a [`NotifsHandlerOut::CloseResult`] event.
+	Close {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+	},
+}
+
+/// Event that can be emitted by a `NotifsHandler`.
+#[derive(Debug)]
+pub enum NotifsHandlerOut {
+	/// Acknowledges a [`NotifsHandlerIn::Open`].
+	OpenResultOk {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+		/// Name of the protocol that was actually negotiated, if the default one wasn't available.
+		negotiated_fallback: Option<ProtocolName>,
+		/// The endpoint of the connection that is open for custom protocols.
+		endpoint: ConnectedPoint,
+		/// Handshake that was sent to us.
+		/// This is normally a "Status" message, but this out of the concern of this code.
+		received_handshake: Vec<u8>,
+		/// How notifications can be sent to this node.
+		notifications_sink: NotificationsSink,
+		/// Is the connection inbound.
+		inbound: bool,
+	},
+
+	/// Acknowledges a [`NotifsHandlerIn::Open`]. The remote has refused the attempt to open
+	/// notification substreams.
+	OpenResultErr {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+	},
+
+	/// Acknowledges a [`NotifsHandlerIn::Close`].
+	CloseResult {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+	},
+
+	/// The remote would like the substreams to be open. Send a [`NotifsHandlerIn::Open`] or a
+	/// [`NotifsHandlerIn::Close`] in order to either accept or deny this request. If a
+	/// [`NotifsHandlerIn::Open`] or [`NotifsHandlerIn::Close`] has been sent before and has not
+	/// yet been acknowledged by a matching [`NotifsHandlerOut`], then you don't need to a send
+	/// another [`NotifsHandlerIn`].
+	OpenDesiredByRemote {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+	},
+
+	/// The remote would like the substreams to be closed. Send a [`NotifsHandlerIn::Close`] in
+	/// order to close them. If a [`NotifsHandlerIn::Close`] has been sent before and has not yet
+	/// been acknowledged by a [`NotifsHandlerOut::CloseResult`], then you don't need to a send
+	/// another one.
+	CloseDesired {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+	},
+
+	/// Received a message on a custom protocol substream.
+	///
+	/// Can only happen when the handler is in the open state.
+	Notification {
+		/// Index of the protocol in the list of protocols passed at initialization.
+		protocol_index: usize,
+		/// Message that has been received.
+		message: BytesMut,
+	},
+}
+
+/// Sink connected directly to the node background task. Allows sending notifications to the peer.
+///
+/// Can be cloned in order to obtain multiple references to the substream of the same peer.
+#[derive(Debug, Clone)]
+pub struct NotificationsSink {
+	inner: Arc<NotificationsSinkInner>,
+}
+
+#[derive(Debug)]
+struct NotificationsSinkInner {
+	/// Target of the sink.
+	peer_id: PeerId,
+	/// Sender to use in asynchronous contexts. Uses an asynchronous mutex.
+	async_channel: FuturesMutex<mpsc::Sender<NotificationsSinkMessage>>,
+	/// Sender to use in synchronous contexts. Uses a synchronous mutex.
+	/// Contains `None` if the channel was full at some point, in which case the channel will
+	/// be closed in the near future anyway.
+	/// This channel has a large capacity and is meant to be used in contexts where
+	/// back-pressure cannot be properly exerted.
+	/// It will be removed in a future version.
+	sync_channel: Mutex<Option<mpsc::Sender<NotificationsSinkMessage>>>,
+}
+
+/// Message emitted through the [`NotificationsSink`] and processed by the background task
+/// dedicated to the peer.
+#[derive(Debug)]
+enum NotificationsSinkMessage {
+	/// Message emitted by [`NotificationsSink::reserve_notification`] and
+	/// [`NotificationsSink::write_notification_now`].
+	Notification { message: Vec<u8> },
+
+	/// Must close the connection.
+	ForceClose,
+}
+
+impl NotificationsSink {
+	/// Returns the [`PeerId`] the sink is connected to.
+	pub fn peer_id(&self) -> &PeerId {
+		&self.inner.peer_id
+	}
+
+	/// Sends a notification to the peer.
+	///
+	/// If too many messages are already buffered, the notification is silently discarded and the
+	/// connection to the peer will be closed shortly after.
+	///
+	/// The protocol name is expected to be checked ahead of calling this method. It is a logic
+	/// error to send a notification using an unknown protocol.
+	///
+	/// This method will be removed in a future version.
+	pub fn send_sync_notification(&self, message: impl Into<Vec<u8>>) {
+		let mut lock = self.inner.sync_channel.lock();
+
+		if let Some(tx) = lock.as_mut() {
+			let result =
+				tx.try_send(NotificationsSinkMessage::Notification { message: message.into() });
+
+			if result.is_err() {
+				// Cloning the `mpsc::Sender` guarantees the allocation of an extra spot in the
+				// buffer, and therefore `try_send` will succeed.
+				let _result2 = tx.clone().try_send(NotificationsSinkMessage::ForceClose);
+				debug_assert!(_result2.map(|()| true).unwrap_or_else(|err| err.is_disconnected()));
+
+				// Destroy the sender in order to not send more `ForceClose` messages.
+				*lock = None;
+			}
+		}
+	}
+
+	/// Wait until the remote is ready to accept a notification.
+	///
+	/// Returns an error in the case where the connection is closed.
+	///
+	/// The protocol name is expected to be checked ahead of calling this method. It is a logic
+	/// error to send a notification using an unknown protocol.
+	pub async fn reserve_notification(&self) -> Result<Ready<'_>, ()> {
+		let mut lock = self.inner.async_channel.lock().await;
+
+		let poll_ready = future::poll_fn(|cx| lock.poll_ready(cx)).await;
+		if poll_ready.is_ok() {
+			Ok(Ready { lock })
+		} else {
+			Err(())
+		}
+	}
+}
+
+/// Notification slot is reserved and the notification can actually be sent.
+#[must_use]
+#[derive(Debug)]
+pub struct Ready<'a> {
+	/// Guarded channel. The channel inside is guaranteed to not be full.
+	lock: FuturesMutexGuard<'a, mpsc::Sender<NotificationsSinkMessage>>,
+}
+
+impl<'a> Ready<'a> {
+	/// Consumes this slots reservation and actually queues the notification.
+	///
+	/// Returns an error if the substream has been closed.
+	pub fn send(mut self, notification: impl Into<Vec<u8>>) -> Result<(), ()> {
+		self.lock
+			.start_send(NotificationsSinkMessage::Notification { message: notification.into() })
+			.map_err(|_| ())
+	}
+}
+
+/// Error specific to the collection of protocols.
+#[derive(Debug, thiserror::Error)]
+pub enum NotifsHandlerError {
+	#[error("Channel of synchronous notifications is full.")]
+	SyncNotificationsClogged,
+}
+
+impl ConnectionHandler for NotifsHandler {
+	type InEvent = NotifsHandlerIn;
+	type OutEvent = NotifsHandlerOut;
+	type Error = NotifsHandlerError;
+	type InboundProtocol = UpgradeCollec<NotificationsIn>;
+	type OutboundProtocol = NotificationsOut;
+	// Index within the `out_protocols`.
+	type OutboundOpenInfo = usize;
+	type InboundOpenInfo = ();
+
+	fn listen_protocol(&self) -> SubstreamProtocol<Self::InboundProtocol, ()> {
+		let protocols = self
+			.protocols
+			.iter()
+			.map(|p| p.in_upgrade.clone())
+			.collect::<UpgradeCollec<_>>();
+
+		SubstreamProtocol::new(protocols, ())
+	}
+
+	fn on_connection_event(
+		&mut self,
+		event: ConnectionEvent<
+			'_,
+			Self::InboundProtocol,
+			Self::OutboundProtocol,
+			Self::InboundOpenInfo,
+			Self::OutboundOpenInfo,
+		>,
+	) {
+		match event {
+			ConnectionEvent::FullyNegotiatedInbound(inbound) => {
+				let (mut in_substream_open, protocol_index) = inbound.protocol;
+				let protocol_info = &mut self.protocols[protocol_index];
+
+				match protocol_info.state {
+					State::Closed { pending_opening } => {
+						self.events_queue.push_back(ConnectionHandlerEvent::Custom(
+							NotifsHandlerOut::OpenDesiredByRemote { protocol_index },
+						));
+
+						protocol_info.state = State::OpenDesiredByRemote {
+							in_substream: in_substream_open.substream,
+							pending_opening,
+						};
+					},
+					State::OpenDesiredByRemote { .. } => {
+						// If a substream already exists, silently drop the new one.
+						// Note that we drop the substream, which will send an equivalent to a
+						// TCP "RST" to the remote and force-close the substream. It might
+						// seem like an unclean way to get rid of a substream. However, keep
+						// in mind that it is invalid for the remote to open multiple such
+						// substreams, and therefore sending a "RST" is the most correct thing
+						// to do.
+						return
+					},
+					State::Opening { ref mut in_substream, .. } |
+					State::Open { ref mut in_substream, .. } => {
+						if in_substream.is_some() {
+							// Same remark as above.
+							return
+						}
+
+						// Create `handshake_message` on a separate line to be sure that the
+						// lock is released as soon as possible.
+						let handshake_message = protocol_info.config.handshake.read().clone();
+						in_substream_open.substream.send_handshake(handshake_message);
+						*in_substream = Some(in_substream_open.substream);
+					},
+				}
+			},
+			ConnectionEvent::FullyNegotiatedOutbound(outbound) => {
+				let (new_open, protocol_index) = (outbound.protocol, outbound.info);
+
+				match self.protocols[protocol_index].state {
+					State::Closed { ref mut pending_opening } |
+					State::OpenDesiredByRemote { ref mut pending_opening, .. } => {
+						debug_assert!(*pending_opening);
+						*pending_opening = false;
+					},
+					State::Open { .. } => {
+						error!(target: "sub-libp2p", "☎� State mismatch in notifications handler");
+						debug_assert!(false);
+					},
+					State::Opening { ref mut in_substream, inbound } => {
+						let (async_tx, async_rx) = mpsc::channel(ASYNC_NOTIFICATIONS_BUFFER_SIZE);
+						let (sync_tx, sync_rx) = mpsc::channel(SYNC_NOTIFICATIONS_BUFFER_SIZE);
+						let notifications_sink = NotificationsSink {
+							inner: Arc::new(NotificationsSinkInner {
+								peer_id: self.peer_id,
+								async_channel: FuturesMutex::new(async_tx),
+								sync_channel: Mutex::new(Some(sync_tx)),
+							}),
+						};
+
+						self.protocols[protocol_index].state = State::Open {
+							notifications_sink_rx: stream::select(async_rx.fuse(), sync_rx.fuse())
+								.peekable(),
+							out_substream: Some(new_open.substream),
+							in_substream: in_substream.take(),
+						};
+
+						self.events_queue.push_back(ConnectionHandlerEvent::Custom(
+							NotifsHandlerOut::OpenResultOk {
+								protocol_index,
+								negotiated_fallback: new_open.negotiated_fallback,
+								endpoint: self.endpoint.clone(),
+								received_handshake: new_open.handshake,
+								notifications_sink,
+								inbound,
+							},
+						));
+					},
+				}
+			},
+			ConnectionEvent::AddressChange(_address_change) => {},
+			ConnectionEvent::DialUpgradeError(dial_upgrade_error) => match self.protocols
+				[dial_upgrade_error.info]
+				.state
+			{
+				State::Closed { ref mut pending_opening } |
+				State::OpenDesiredByRemote { ref mut pending_opening, .. } => {
+					debug_assert!(*pending_opening);
+					*pending_opening = false;
+				},
+
+				State::Opening { .. } => {
+					self.protocols[dial_upgrade_error.info].state =
+						State::Closed { pending_opening: false };
+
+					self.events_queue.push_back(ConnectionHandlerEvent::Custom(
+						NotifsHandlerOut::OpenResultErr { protocol_index: dial_upgrade_error.info },
+					));
+				},
+
+				// No substream is being open when already `Open`.
+				State::Open { .. } => debug_assert!(false),
+			},
+			ConnectionEvent::ListenUpgradeError(_listen_upgrade_error) => {},
+		}
+	}
+
+	fn on_behaviour_event(&mut self, message: NotifsHandlerIn) {
+		match message {
+			NotifsHandlerIn::Open { protocol_index } => {
+				let protocol_info = &mut self.protocols[protocol_index];
+				match &mut protocol_info.state {
+					State::Closed { pending_opening } => {
+						if !*pending_opening {
+							let proto = NotificationsOut::new(
+								protocol_info.config.name.clone(),
+								protocol_info.config.fallback_names.clone(),
+								protocol_info.config.handshake.read().clone(),
+								protocol_info.config.max_notification_size,
+							);
+
+							self.events_queue.push_back(
+								ConnectionHandlerEvent::OutboundSubstreamRequest {
+									protocol: SubstreamProtocol::new(proto, protocol_index)
+										.with_timeout(OPEN_TIMEOUT),
+								},
+							);
+						}
+
+						protocol_info.state = State::Opening { in_substream: None, inbound: false };
+					},
+					State::OpenDesiredByRemote { pending_opening, in_substream } => {
+						let handshake_message = protocol_info.config.handshake.read().clone();
+
+						if !*pending_opening {
+							let proto = NotificationsOut::new(
+								protocol_info.config.name.clone(),
+								protocol_info.config.fallback_names.clone(),
+								handshake_message.clone(),
+								protocol_info.config.max_notification_size,
+							);
+
+							self.events_queue.push_back(
+								ConnectionHandlerEvent::OutboundSubstreamRequest {
+									protocol: SubstreamProtocol::new(proto, protocol_index)
+										.with_timeout(OPEN_TIMEOUT),
+								},
+							);
+						}
+
+						in_substream.send_handshake(handshake_message);
+
+						// The state change is done in two steps because of borrowing issues.
+						let in_substream = match mem::replace(
+							&mut protocol_info.state,
+							State::Opening { in_substream: None, inbound: false },
+						) {
+							State::OpenDesiredByRemote { in_substream, .. } => in_substream,
+							_ => unreachable!(),
+						};
+						protocol_info.state =
+							State::Opening { in_substream: Some(in_substream), inbound: true };
+					},
+					State::Opening { .. } | State::Open { .. } => {
+						// As documented, it is forbidden to send an `Open` while there is already
+						// one in the fly.
+						error!(target: "sub-libp2p", "opening already-opened handler");
+						debug_assert!(false);
+					},
+				}
+			},
+
+			NotifsHandlerIn::Close { protocol_index } => {
+				match self.protocols[protocol_index].state {
+					State::Open { .. } => {
+						self.protocols[protocol_index].state =
+							State::Closed { pending_opening: false };
+					},
+					State::Opening { .. } => {
+						self.protocols[protocol_index].state =
+							State::Closed { pending_opening: true };
+
+						self.events_queue.push_back(ConnectionHandlerEvent::Custom(
+							NotifsHandlerOut::OpenResultErr { protocol_index },
+						));
+					},
+					State::OpenDesiredByRemote { pending_opening, .. } => {
+						self.protocols[protocol_index].state = State::Closed { pending_opening };
+					},
+					State::Closed { .. } => {},
+				}
+
+				self.events_queue.push_back(ConnectionHandlerEvent::Custom(
+					NotifsHandlerOut::CloseResult { protocol_index },
+				));
+			},
+		}
+	}
+
+	fn connection_keep_alive(&self) -> KeepAlive {
+		// `Yes` if any protocol has some activity.
+		if self.protocols.iter().any(|p| !matches!(p.state, State::Closed { .. })) {
+			return KeepAlive::Yes
+		}
+
+		// A grace period of `INITIAL_KEEPALIVE_TIME` must be given to leave time for the remote
+		// to express desire to open substreams.
+		KeepAlive::Until(self.when_connection_open + INITIAL_KEEPALIVE_TIME)
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut Context,
+	) -> Poll<
+		ConnectionHandlerEvent<
+			Self::OutboundProtocol,
+			Self::OutboundOpenInfo,
+			Self::OutEvent,
+			Self::Error,
+		>,
+	> {
+		if let Some(ev) = self.events_queue.pop_front() {
+			return Poll::Ready(ev)
+		}
+
+		// For each open substream, try send messages from `notifications_sink_rx` to the
+		// substream.
+		for protocol_index in 0..self.protocols.len() {
+			if let State::Open {
+				notifications_sink_rx, out_substream: Some(out_substream), ..
+			} = &mut self.protocols[protocol_index].state
+			{
+				loop {
+					// Only proceed with `out_substream.poll_ready_unpin` if there is an element
+					// available in `notifications_sink_rx`. This avoids waking up the task when
+					// a substream is ready to send if there isn't actually something to send.
+					match Pin::new(&mut *notifications_sink_rx).as_mut().poll_peek(cx) {
+						Poll::Ready(Some(&NotificationsSinkMessage::ForceClose)) =>
+							return Poll::Ready(ConnectionHandlerEvent::Close(
+								NotifsHandlerError::SyncNotificationsClogged,
+							)),
+						Poll::Ready(Some(&NotificationsSinkMessage::Notification { .. })) => {},
+						Poll::Ready(None) | Poll::Pending => break,
+					}
+
+					// Before we extract the element from `notifications_sink_rx`, check that the
+					// substream is ready to accept a message.
+					match out_substream.poll_ready_unpin(cx) {
+						Poll::Ready(_) => {},
+						Poll::Pending => break,
+					}
+
+					// Now that the substream is ready for a message, grab what to send.
+					let message = match notifications_sink_rx.poll_next_unpin(cx) {
+						Poll::Ready(Some(NotificationsSinkMessage::Notification { message })) =>
+							message,
+						Poll::Ready(Some(NotificationsSinkMessage::ForceClose)) |
+						Poll::Ready(None) |
+						Poll::Pending => {
+							// Should never be reached, as per `poll_peek` above.
+							debug_assert!(false);
+							break
+						},
+					};
+
+					let _ = out_substream.start_send_unpin(message);
+					// Note that flushing is performed later down this function.
+				}
+			}
+		}
+
+		// Flush all outbound substreams.
+		// When `poll` returns `Poll::Ready`, the libp2p `Swarm` may decide to no longer call
+		// `poll` again before it is ready to accept more events.
+		// In order to make sure that substreams are flushed as soon as possible, the flush is
+		// performed before the code paths that can produce `Ready` (with some rare exceptions).
+		// Importantly, however, the flush is performed *after* notifications are queued with
+		// `Sink::start_send`.
+		for protocol_index in 0..self.protocols.len() {
+			match &mut self.protocols[protocol_index].state {
+				State::Open { out_substream: out_substream @ Some(_), .. } => {
+					match Sink::poll_flush(Pin::new(out_substream.as_mut().unwrap()), cx) {
+						Poll::Pending | Poll::Ready(Ok(())) => {},
+						Poll::Ready(Err(_)) => {
+							*out_substream = None;
+							let event = NotifsHandlerOut::CloseDesired { protocol_index };
+							return Poll::Ready(ConnectionHandlerEvent::Custom(event))
+						},
+					};
+				},
+
+				State::Closed { .. } |
+				State::Opening { .. } |
+				State::Open { out_substream: None, .. } |
+				State::OpenDesiredByRemote { .. } => {},
+			}
+		}
+
+		// Poll inbound substreams.
+		for protocol_index in 0..self.protocols.len() {
+			// Inbound substreams being closed is always tolerated, except for the
+			// `OpenDesiredByRemote` state which might need to be switched back to `Closed`.
+			match &mut self.protocols[protocol_index].state {
+				State::Closed { .. } |
+				State::Open { in_substream: None, .. } |
+				State::Opening { in_substream: None, .. } => {},
+
+				State::Open { in_substream: in_substream @ Some(_), .. } =>
+					match Stream::poll_next(Pin::new(in_substream.as_mut().unwrap()), cx) {
+						Poll::Pending => {},
+						Poll::Ready(Some(Ok(message))) => {
+							let event = NotifsHandlerOut::Notification { protocol_index, message };
+							return Poll::Ready(ConnectionHandlerEvent::Custom(event))
+						},
+						Poll::Ready(None) | Poll::Ready(Some(Err(_))) => *in_substream = None,
+					},
+
+				State::OpenDesiredByRemote { in_substream, pending_opening } =>
+					match NotificationsInSubstream::poll_process(Pin::new(in_substream), cx) {
+						Poll::Pending => {},
+						Poll::Ready(Ok(void)) => match void {},
+						Poll::Ready(Err(_)) => {
+							self.protocols[protocol_index].state =
+								State::Closed { pending_opening: *pending_opening };
+							return Poll::Ready(ConnectionHandlerEvent::Custom(
+								NotifsHandlerOut::CloseDesired { protocol_index },
+							))
+						},
+					},
+
+				State::Opening { in_substream: in_substream @ Some(_), .. } =>
+					match NotificationsInSubstream::poll_process(
+						Pin::new(in_substream.as_mut().unwrap()),
+						cx,
+					) {
+						Poll::Pending => {},
+						Poll::Ready(Ok(void)) => match void {},
+						Poll::Ready(Err(_)) => *in_substream = None,
+					},
+			}
+		}
+
+		// This is the only place in this method that can return `Pending`.
+		// By putting it at the very bottom, we are guaranteed that everything has been properly
+		// polled.
+		Poll::Pending
+	}
+}
+
+#[cfg(test)]
+pub mod tests {
+	use super::*;
+	use crate::protocol::notifications::upgrade::{
+		NotificationsInOpen, NotificationsInSubstreamHandshake, NotificationsOutOpen,
+	};
+	use asynchronous_codec::Framed;
+	use libp2p::{
+		core::muxing::SubstreamBox,
+		swarm::{handler, ConnectionHandlerUpgrErr},
+		Multiaddr,
+	};
+	use multistream_select::{dialer_select_proto, listener_select_proto, Negotiated, Version};
+	use std::{
+		collections::HashMap,
+		io::{Error, IoSlice, IoSliceMut},
+	};
+	use tokio::sync::mpsc;
+	use unsigned_varint::codec::UviBytes;
+
+	struct OpenSubstream {
+		notifications: stream::Peekable<
+			stream::Select<
+				stream::Fuse<futures::channel::mpsc::Receiver<NotificationsSinkMessage>>,
+				stream::Fuse<futures::channel::mpsc::Receiver<NotificationsSinkMessage>>,
+			>,
+		>,
+		_in_substream: MockSubstream,
+		_out_substream: MockSubstream,
+	}
+
+	pub struct ConnectionYielder {
+		connections: HashMap<(PeerId, usize), OpenSubstream>,
+	}
+
+	impl ConnectionYielder {
+		/// Create new [`ConnectionYielder`].
+		pub fn new() -> Self {
+			Self { connections: HashMap::new() }
+		}
+
+		/// Open a new substream for peer.
+		pub fn open_substream(
+			&mut self,
+			peer: PeerId,
+			protocol_index: usize,
+			endpoint: ConnectedPoint,
+			received_handshake: Vec<u8>,
+		) -> NotifsHandlerOut {
+			let (async_tx, async_rx) =
+				futures::channel::mpsc::channel(ASYNC_NOTIFICATIONS_BUFFER_SIZE);
+			let (sync_tx, sync_rx) =
+				futures::channel::mpsc::channel(SYNC_NOTIFICATIONS_BUFFER_SIZE);
+			let notifications_sink = NotificationsSink {
+				inner: Arc::new(NotificationsSinkInner {
+					peer_id: peer,
+					async_channel: FuturesMutex::new(async_tx),
+					sync_channel: Mutex::new(Some(sync_tx)),
+				}),
+			};
+			let (in_substream, out_substream) = MockSubstream::new();
+
+			self.connections.insert(
+				(peer, protocol_index),
+				OpenSubstream {
+					notifications: stream::select(async_rx.fuse(), sync_rx.fuse()).peekable(),
+					_in_substream: in_substream,
+					_out_substream: out_substream,
+				},
+			);
+
+			NotifsHandlerOut::OpenResultOk {
+				protocol_index,
+				negotiated_fallback: None,
+				endpoint,
+				received_handshake,
+				notifications_sink,
+				inbound: false,
+			}
+		}
+
+		/// Attempt to get next pending event from one of the notification sinks.
+		pub async fn get_next_event(&mut self, peer: PeerId, set: usize) -> Option<Vec<u8>> {
+			let substream = if let Some(info) = self.connections.get_mut(&(peer, set)) {
+				info
+			} else {
+				return None
+			};
+
+			futures::future::poll_fn(|cx| match substream.notifications.poll_next_unpin(cx) {
+				Poll::Ready(Some(NotificationsSinkMessage::Notification { message })) =>
+					Poll::Ready(Some(message)),
+				Poll::Pending => Poll::Ready(None),
+				Poll::Ready(Some(NotificationsSinkMessage::ForceClose)) | Poll::Ready(None) => {
+					panic!("sink closed")
+				},
+			})
+			.await
+		}
+	}
+	struct MockSubstream {
+		pub rx: mpsc::Receiver<Vec<u8>>,
+		pub tx: mpsc::Sender<Vec<u8>>,
+		rx_buffer: BytesMut,
+	}
+
+	impl MockSubstream {
+		/// Create new substream pair.
+		pub fn new() -> (Self, Self) {
+			let (tx1, rx1) = mpsc::channel(32);
+			let (tx2, rx2) = mpsc::channel(32);
+
+			(
+				Self { rx: rx1, tx: tx2, rx_buffer: BytesMut::with_capacity(512) },
+				Self { rx: rx2, tx: tx1, rx_buffer: BytesMut::with_capacity(512) },
+			)
+		}
+
+		/// Create new negotiated substream pair.
+		pub async fn negotiated() -> (Negotiated<SubstreamBox>, Negotiated<SubstreamBox>) {
+			let (socket1, socket2) = Self::new();
+			let socket1 = SubstreamBox::new(socket1);
+			let socket2 = SubstreamBox::new(socket2);
+
+			let protos = vec![b"/echo/1.0.0", b"/echo/2.5.0"];
+			let (res1, res2) = tokio::join!(
+				dialer_select_proto(socket1, protos.clone(), Version::V1),
+				listener_select_proto(socket2, protos),
+			);
+
+			(res1.unwrap().1, res2.unwrap().1)
+		}
+	}
+
+	impl AsyncWrite for MockSubstream {
+		fn poll_write<'a>(
+			self: Pin<&mut Self>,
+			_cx: &mut Context<'a>,
+			buf: &[u8],
+		) -> Poll<Result<usize, Error>> {
+			match self.tx.try_send(buf.to_vec()) {
+				Ok(_) => Poll::Ready(Ok(buf.len())),
+				Err(_) => Poll::Ready(Err(std::io::ErrorKind::UnexpectedEof.into())),
+			}
+		}
+
+		fn poll_flush<'a>(self: Pin<&mut Self>, _cx: &mut Context<'a>) -> Poll<Result<(), Error>> {
+			Poll::Ready(Ok(()))
+		}
+
+		fn poll_close<'a>(self: Pin<&mut Self>, _cx: &mut Context<'a>) -> Poll<Result<(), Error>> {
+			Poll::Ready(Ok(()))
+		}
+
+		fn poll_write_vectored<'a, 'b>(
+			self: Pin<&mut Self>,
+			_cx: &mut Context<'a>,
+			_bufs: &[IoSlice<'b>],
+		) -> Poll<Result<usize, Error>> {
+			unimplemented!();
+		}
+	}
+
+	impl AsyncRead for MockSubstream {
+		fn poll_read<'a>(
+			mut self: Pin<&mut Self>,
+			cx: &mut Context<'a>,
+			buf: &mut [u8],
+		) -> Poll<Result<usize, Error>> {
+			match self.rx.poll_recv(cx) {
+				Poll::Ready(Some(data)) => self.rx_buffer.extend_from_slice(&data),
+				Poll::Ready(None) =>
+					return Poll::Ready(Err(std::io::ErrorKind::UnexpectedEof.into())),
+				_ => {},
+			}
+
+			let nsize = std::cmp::min(self.rx_buffer.len(), buf.len());
+			let data = self.rx_buffer.split_to(nsize);
+			buf[..nsize].copy_from_slice(&data[..]);
+
+			if nsize > 0 {
+				return Poll::Ready(Ok(nsize))
+			}
+
+			Poll::Pending
+		}
+
+		fn poll_read_vectored<'a, 'b>(
+			self: Pin<&mut Self>,
+			_cx: &mut Context<'a>,
+			_bufs: &mut [IoSliceMut<'b>],
+		) -> Poll<Result<usize, Error>> {
+			unimplemented!();
+		}
+	}
+
+	/// Create new [`NotifsHandler`].
+	fn notifs_handler() -> NotifsHandler {
+		let proto = Protocol {
+			config: ProtocolConfig {
+				name: "/foo".into(),
+				fallback_names: vec![],
+				handshake: Arc::new(RwLock::new(b"hello, world".to_vec())),
+				max_notification_size: u64::MAX,
+			},
+			in_upgrade: NotificationsIn::new("/foo", Vec::new(), u64::MAX),
+			state: State::Closed { pending_opening: false },
+		};
+
+		NotifsHandler {
+			protocols: vec![proto],
+			when_connection_open: Instant::now(),
+			endpoint: ConnectedPoint::Listener {
+				local_addr: Multiaddr::empty(),
+				send_back_addr: Multiaddr::empty(),
+			},
+			peer_id: PeerId::random(),
+			events_queue: VecDeque::new(),
+		}
+	}
+
+	// verify that if another substream is attempted to be opened by remote while an inbound
+	// substream already exists, the new inbound stream is rejected and closed by the local node.
+	#[tokio::test]
+	async fn second_open_desired_by_remote_rejected() {
+		let mut handler = notifs_handler();
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the substream is in (partly) opened state
+		assert!(std::matches!(handler.protocols[0].state, State::OpenDesiredByRemote { .. }));
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+			assert!(std::matches!(Pin::new(&mut io2).poll_read(cx, &mut buf), Poll::Pending));
+			Poll::Ready(())
+		})
+		.await;
+
+		// attempt to open another inbound substream and verify that it is rejected
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the new substream is rejected and closed
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+
+			if let Poll::Ready(Err(err)) = Pin::new(&mut io2).poll_read(cx, &mut buf) {
+				assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof,);
+			}
+
+			Poll::Ready(())
+		})
+		.await;
+	}
+
+	#[tokio::test]
+	async fn open_rejected_if_substream_is_opening() {
+		let mut handler = notifs_handler();
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the substream is in (partly) opened state
+		assert!(std::matches!(handler.protocols[0].state, State::OpenDesiredByRemote { .. }));
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+			assert!(std::matches!(Pin::new(&mut io2).poll_read(cx, &mut buf), Poll::Pending));
+			Poll::Ready(())
+		})
+		.await;
+
+		// move the handler state to 'Opening'
+		handler.on_behaviour_event(NotifsHandlerIn::Open { protocol_index: 0 });
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Opening { in_substream: Some(_), .. }
+		));
+
+		// remote now tries to open another substream, verify that it is rejected and closed
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the new substream is rejected and closed but that the first substream is
+		// still in correct state
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+
+			if let Poll::Ready(Err(err)) = Pin::new(&mut io2).poll_read(cx, &mut buf) {
+				assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof,);
+			} else {
+				panic!("unexpected result");
+			}
+
+			Poll::Ready(())
+		})
+		.await;
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Opening { in_substream: Some(_), .. }
+		));
+	}
+
+	#[tokio::test]
+	async fn open_rejected_if_substream_already_open() {
+		let mut handler = notifs_handler();
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the substream is in (partly) opened state
+		assert!(std::matches!(handler.protocols[0].state, State::OpenDesiredByRemote { .. }));
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+			assert!(std::matches!(Pin::new(&mut io2).poll_read(cx, &mut buf), Poll::Pending));
+			Poll::Ready(())
+		})
+		.await;
+
+		// move the handler state to 'Opening'
+		handler.on_behaviour_event(NotifsHandlerIn::Open { protocol_index: 0 });
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Opening { in_substream: Some(_), .. }
+		));
+
+		// accept the substream and move its state to `Open`
+		let (io, _io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_out = NotificationsOutOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsOutSubstream::new(Framed::new(io, codec)),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedOutbound(
+			handler::FullyNegotiatedOutbound { protocol: notif_out, info: 0 },
+		));
+
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Open { in_substream: Some(_), .. }
+		));
+
+		// remote now tries to open another substream, verify that it is rejected and closed
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the new substream is rejected and closed but that the first substream is
+		// still in correct state
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+
+			if let Poll::Ready(Err(err)) = Pin::new(&mut io2).poll_read(cx, &mut buf) {
+				assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof);
+			} else {
+				panic!("unexpected result");
+			}
+
+			Poll::Ready(())
+		})
+		.await;
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Open { in_substream: Some(_), .. }
+		));
+	}
+
+	#[tokio::test]
+	async fn fully_negotiated_resets_state_for_closed_substream() {
+		let mut handler = notifs_handler();
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the substream is in (partly) opened state
+		assert!(std::matches!(handler.protocols[0].state, State::OpenDesiredByRemote { .. }));
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+			assert!(std::matches!(Pin::new(&mut io2).poll_read(cx, &mut buf), Poll::Pending));
+			Poll::Ready(())
+		})
+		.await;
+
+		// first instruct the handler to open a connection and then close it right after
+		// so the handler is in state `Closed { pending_opening: true }`
+		handler.on_behaviour_event(NotifsHandlerIn::Open { protocol_index: 0 });
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Opening { in_substream: Some(_), .. }
+		));
+
+		handler.on_behaviour_event(NotifsHandlerIn::Close { protocol_index: 0 });
+		assert!(std::matches!(handler.protocols[0].state, State::Closed { pending_opening: true }));
+
+		// verify that if the the outbound substream is successfully negotiated, the state is not
+		// changed as the substream was commanded to be closed by the handler.
+		let (io, _io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_out = NotificationsOutOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsOutSubstream::new(Framed::new(io, codec)),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedOutbound(
+			handler::FullyNegotiatedOutbound { protocol: notif_out, info: 0 },
+		));
+
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Closed { pending_opening: false }
+		));
+	}
+
+	#[tokio::test]
+	async fn fully_negotiated_resets_state_for_open_desired_substream() {
+		let mut handler = notifs_handler();
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the substream is in (partly) opened state
+		assert!(std::matches!(handler.protocols[0].state, State::OpenDesiredByRemote { .. }));
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+			assert!(std::matches!(Pin::new(&mut io2).poll_read(cx, &mut buf), Poll::Pending));
+			Poll::Ready(())
+		})
+		.await;
+
+		// first instruct the handler to open a connection and then close it right after
+		// so the handler is in state `Closed { pending_opening: true }`
+		handler.on_behaviour_event(NotifsHandlerIn::Open { protocol_index: 0 });
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Opening { in_substream: Some(_), .. }
+		));
+
+		handler.on_behaviour_event(NotifsHandlerIn::Close { protocol_index: 0 });
+		assert!(std::matches!(handler.protocols[0].state, State::Closed { pending_opening: true }));
+
+		// attempt to open another inbound substream and verify that it is rejected
+		let (io, _io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::OpenDesiredByRemote { pending_opening: true, .. }
+		));
+
+		// verify that if the the outbound substream is successfully negotiated, the state is not
+		// changed as the substream was commanded to be closed by the handler.
+		let (io, _io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_out = NotificationsOutOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsOutSubstream::new(Framed::new(io, codec)),
+		};
+
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedOutbound(
+			handler::FullyNegotiatedOutbound { protocol: notif_out, info: 0 },
+		));
+
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::OpenDesiredByRemote { pending_opening: false, .. }
+		));
+	}
+
+	#[tokio::test]
+	async fn dial_upgrade_error_resets_closed_outbound_state() {
+		let mut handler = notifs_handler();
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the substream is in (partly) opened state
+		assert!(std::matches!(handler.protocols[0].state, State::OpenDesiredByRemote { .. }));
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+			assert!(std::matches!(Pin::new(&mut io2).poll_read(cx, &mut buf), Poll::Pending));
+			Poll::Ready(())
+		})
+		.await;
+
+		// first instruct the handler to open a connection and then close it right after
+		// so the handler is in state `Closed { pending_opening: true }`
+		handler.on_behaviour_event(NotifsHandlerIn::Open { protocol_index: 0 });
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Opening { in_substream: Some(_), .. }
+		));
+
+		handler.on_behaviour_event(NotifsHandlerIn::Close { protocol_index: 0 });
+		assert!(std::matches!(handler.protocols[0].state, State::Closed { pending_opening: true }));
+
+		// inject dial failure to an already closed substream and verify outbound state is reset
+		handler.on_connection_event(handler::ConnectionEvent::DialUpgradeError(
+			handler::DialUpgradeError { info: 0, error: ConnectionHandlerUpgrErr::Timeout },
+		));
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Closed { pending_opening: false }
+		));
+	}
+
+	#[tokio::test]
+	async fn dial_upgrade_error_resets_open_desired_state() {
+		let mut handler = notifs_handler();
+		let (io, mut io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		// verify that the substream is in (partly) opened state
+		assert!(std::matches!(handler.protocols[0].state, State::OpenDesiredByRemote { .. }));
+		futures::future::poll_fn(|cx| {
+			let mut buf = Vec::with_capacity(512);
+			assert!(std::matches!(Pin::new(&mut io2).poll_read(cx, &mut buf), Poll::Pending));
+			Poll::Ready(())
+		})
+		.await;
+
+		// first instruct the handler to open a connection and then close it right after
+		// so the handler is in state `Closed { pending_opening: true }`
+		handler.on_behaviour_event(NotifsHandlerIn::Open { protocol_index: 0 });
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::Opening { in_substream: Some(_), .. }
+		));
+
+		handler.on_behaviour_event(NotifsHandlerIn::Close { protocol_index: 0 });
+		assert!(std::matches!(handler.protocols[0].state, State::Closed { pending_opening: true }));
+
+		let (io, _io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::NotSent,
+			),
+		};
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::OpenDesiredByRemote { pending_opening: true, .. }
+		));
+
+		// inject dial failure to an already closed substream and verify outbound state is reset
+		handler.on_connection_event(handler::ConnectionEvent::DialUpgradeError(
+			handler::DialUpgradeError { info: 0, error: ConnectionHandlerUpgrErr::Timeout },
+		));
+		assert!(std::matches!(
+			handler.protocols[0].state,
+			State::OpenDesiredByRemote { pending_opening: false, .. }
+		));
+	}
+
+	#[tokio::test]
+	async fn sync_notifications_clogged() {
+		let mut handler = notifs_handler();
+		let (io, _) = MockSubstream::negotiated().await;
+		let codec = UviBytes::default();
+
+		let (async_tx, async_rx) = futures::channel::mpsc::channel(ASYNC_NOTIFICATIONS_BUFFER_SIZE);
+		let (sync_tx, sync_rx) = futures::channel::mpsc::channel(1);
+		let notifications_sink = NotificationsSink {
+			inner: Arc::new(NotificationsSinkInner {
+				peer_id: PeerId::random(),
+				async_channel: FuturesMutex::new(async_tx),
+				sync_channel: Mutex::new(Some(sync_tx)),
+			}),
+		};
+
+		handler.protocols[0].state = State::Open {
+			notifications_sink_rx: stream::select(async_rx.fuse(), sync_rx.fuse()).peekable(),
+			out_substream: Some(NotificationsOutSubstream::new(Framed::new(io, codec))),
+			in_substream: None,
+		};
+
+		notifications_sink.send_sync_notification(vec![1, 3, 3, 7]);
+		notifications_sink.send_sync_notification(vec![1, 3, 3, 8]);
+		notifications_sink.send_sync_notification(vec![1, 3, 3, 9]);
+		notifications_sink.send_sync_notification(vec![1, 3, 4, 0]);
+
+		futures::future::poll_fn(|cx| {
+			assert!(std::matches!(
+				handler.poll(cx),
+				Poll::Ready(ConnectionHandlerEvent::Close(
+					NotifsHandlerError::SyncNotificationsClogged,
+				))
+			));
+			Poll::Ready(())
+		})
+		.await;
+	}
+
+	#[tokio::test]
+	async fn close_desired_by_remote() {
+		let mut handler = notifs_handler();
+		let (io, io2) = MockSubstream::negotiated().await;
+		let mut codec = UviBytes::default();
+		codec.set_max_len(usize::MAX);
+
+		let notif_in = NotificationsInOpen {
+			handshake: b"hello, world".to_vec(),
+			negotiated_fallback: None,
+			substream: NotificationsInSubstream::new(
+				Framed::new(io, codec),
+				NotificationsInSubstreamHandshake::PendingSend(vec![1, 2, 3, 4]),
+			),
+		};
+
+		// add new inbound substream but close it immediately and verify that correct events are
+		// emitted
+		handler.on_connection_event(handler::ConnectionEvent::FullyNegotiatedInbound(
+			handler::FullyNegotiatedInbound { protocol: (notif_in, 0), info: () },
+		));
+		drop(io2);
+
+		futures::future::poll_fn(|cx| {
+			assert!(std::matches!(
+				handler.poll(cx),
+				Poll::Ready(ConnectionHandlerEvent::Custom(
+					NotifsHandlerOut::OpenDesiredByRemote { protocol_index: 0 },
+				))
+			));
+			assert!(std::matches!(
+				handler.poll(cx),
+				Poll::Ready(ConnectionHandlerEvent::Custom(NotifsHandlerOut::CloseDesired {
+					protocol_index: 0
+				},))
+			));
+			Poll::Ready(())
+		})
+		.await;
+	}
+}
diff --git a/substrate/client/network/src/protocol/notifications/tests.rs b/substrate/client/network/src/protocol/notifications/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d57c24144f571ee75981a5ebeb6dbdfd38d7ae1f
--- /dev/null
+++ b/substrate/client/network/src/protocol/notifications/tests.rs
@@ -0,0 +1,370 @@
+// 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/>.
+
+#![cfg(test)]
+
+use crate::{
+	peer_store::PeerStore,
+	protocol::notifications::{Notifications, NotificationsOut, ProtocolConfig},
+	protocol_controller::{ProtoSetConfig, ProtocolController, SetId},
+};
+
+use futures::{future::BoxFuture, prelude::*};
+use libp2p::{
+	core::{transport::MemoryTransport, upgrade, Endpoint},
+	identity, noise,
+	swarm::{
+		behaviour::FromSwarm, ConnectionDenied, ConnectionId, Executor, NetworkBehaviour,
+		PollParameters, Swarm, SwarmBuilder, SwarmEvent, THandler, THandlerInEvent,
+		THandlerOutEvent, ToSwarm,
+	},
+	yamux, Multiaddr, PeerId, Transport,
+};
+use sc_utils::mpsc::tracing_unbounded;
+use std::{
+	iter,
+	pin::Pin,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+struct TokioExecutor(tokio::runtime::Runtime);
+impl Executor for TokioExecutor {
+	fn exec(&self, f: Pin<Box<dyn Future<Output = ()> + Send>>) {
+		let _ = self.0.spawn(f);
+	}
+}
+
+/// Builds two nodes that have each other as bootstrap nodes.
+/// This is to be used only for testing, and a panic will happen if something goes wrong.
+fn build_nodes() -> (Swarm<CustomProtoWithAddr>, Swarm<CustomProtoWithAddr>) {
+	let mut out = Vec::with_capacity(2);
+
+	let keypairs: Vec<_> = (0..2).map(|_| identity::Keypair::generate_ed25519()).collect();
+	let addrs: Vec<Multiaddr> = (0..2)
+		.map(|_| format!("/memory/{}", rand::random::<u64>()).parse().unwrap())
+		.collect();
+
+	for index in 0..2 {
+		let keypair = keypairs[index].clone();
+
+		let transport = MemoryTransport::new()
+			.upgrade(upgrade::Version::V1)
+			.authenticate(noise::Config::new(&keypair).unwrap())
+			.multiplex(yamux::Config::default())
+			.timeout(Duration::from_secs(20))
+			.boxed();
+
+		let peer_store = PeerStore::new(if index == 0 {
+			keypairs.iter().skip(1).map(|keypair| keypair.public().to_peer_id()).collect()
+		} else {
+			vec![]
+		});
+
+		let (to_notifications, from_controller) =
+			tracing_unbounded("test_protocol_controller_to_notifications", 10_000);
+
+		let (controller_handle, controller) = ProtocolController::new(
+			SetId::from(0),
+			ProtoSetConfig {
+				in_peers: 25,
+				out_peers: 25,
+				reserved_nodes: Default::default(),
+				reserved_only: false,
+			},
+			to_notifications,
+			Box::new(peer_store.handle()),
+		);
+
+		let behaviour = CustomProtoWithAddr {
+			inner: Notifications::new(
+				vec![controller_handle],
+				from_controller,
+				iter::once(ProtocolConfig {
+					name: "/foo".into(),
+					fallback_names: Vec::new(),
+					handshake: Vec::new(),
+					max_notification_size: 1024 * 1024,
+				}),
+			),
+			peer_store_future: peer_store.run().boxed(),
+			protocol_controller_future: controller.run().boxed(),
+			addrs: addrs
+				.iter()
+				.enumerate()
+				.filter_map(|(n, a)| {
+					if n != index {
+						Some((keypairs[n].public().to_peer_id(), a.clone()))
+					} else {
+						None
+					}
+				})
+				.collect(),
+		};
+
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let mut swarm = SwarmBuilder::with_executor(
+			transport,
+			behaviour,
+			keypairs[index].public().to_peer_id(),
+			TokioExecutor(runtime),
+		)
+		.build();
+		swarm.listen_on(addrs[index].clone()).unwrap();
+		out.push(swarm);
+	}
+
+	// Final output
+	let mut out_iter = out.into_iter();
+	let first = out_iter.next().unwrap();
+	let second = out_iter.next().unwrap();
+	(first, second)
+}
+
+/// Wraps around the `CustomBehaviour` network behaviour, and adds hardcoded node addresses to it.
+struct CustomProtoWithAddr {
+	inner: Notifications,
+	peer_store_future: BoxFuture<'static, ()>,
+	protocol_controller_future: BoxFuture<'static, ()>,
+	addrs: Vec<(PeerId, Multiaddr)>,
+}
+
+impl std::ops::Deref for CustomProtoWithAddr {
+	type Target = Notifications;
+
+	fn deref(&self) -> &Self::Target {
+		&self.inner
+	}
+}
+
+impl std::ops::DerefMut for CustomProtoWithAddr {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.inner
+	}
+}
+
+impl NetworkBehaviour for CustomProtoWithAddr {
+	type ConnectionHandler = <Notifications as NetworkBehaviour>::ConnectionHandler;
+	type OutEvent = <Notifications as NetworkBehaviour>::OutEvent;
+
+	fn handle_pending_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<(), ConnectionDenied> {
+		self.inner
+			.handle_pending_inbound_connection(connection_id, local_addr, remote_addr)
+	}
+
+	fn handle_pending_outbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		maybe_peer: Option<PeerId>,
+		addresses: &[Multiaddr],
+		effective_role: Endpoint,
+	) -> Result<Vec<Multiaddr>, ConnectionDenied> {
+		let mut list = self.inner.handle_pending_outbound_connection(
+			connection_id,
+			maybe_peer,
+			addresses,
+			effective_role,
+		)?;
+		if let Some(peer_id) = maybe_peer {
+			for (p, a) in self.addrs.iter() {
+				if *p == peer_id {
+					list.push(a.clone());
+				}
+			}
+		}
+		Ok(list)
+	}
+
+	fn handle_established_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		self.inner.handle_established_inbound_connection(
+			connection_id,
+			peer,
+			local_addr,
+			remote_addr,
+		)
+	}
+
+	fn handle_established_outbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		addr: &Multiaddr,
+		role_override: Endpoint,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		self.inner
+			.handle_established_outbound_connection(connection_id, peer, addr, role_override)
+	}
+
+	fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+		self.inner.on_swarm_event(event);
+	}
+
+	fn on_connection_handler_event(
+		&mut self,
+		peer_id: PeerId,
+		connection_id: ConnectionId,
+		event: THandlerOutEvent<Self>,
+	) {
+		self.inner.on_connection_handler_event(peer_id, connection_id, event);
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut Context,
+		params: &mut impl PollParameters,
+	) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
+		let _ = self.peer_store_future.poll_unpin(cx);
+		let _ = self.protocol_controller_future.poll_unpin(cx);
+		self.inner.poll(cx, params)
+	}
+}
+
+#[test]
+fn reconnect_after_disconnect() {
+	// We connect two nodes together, then force a disconnect (through the API of the `Service`),
+	// check that the disconnect worked, and finally check whether they successfully reconnect.
+
+	let (mut service1, mut service2) = build_nodes();
+
+	// For this test, the services can be in the following states.
+	#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+	enum ServiceState {
+		NotConnected,
+		FirstConnec,
+		Disconnected,
+		ConnectedAgain,
+	}
+	let mut service1_state = ServiceState::NotConnected;
+	let mut service2_state = ServiceState::NotConnected;
+
+	futures::executor::block_on(async move {
+		loop {
+			// Grab next event from services.
+			let event = {
+				let s1 = service1.select_next_some();
+				let s2 = service2.select_next_some();
+				futures::pin_mut!(s1, s2);
+				match future::select(s1, s2).await {
+					future::Either::Left((ev, _)) => future::Either::Left(ev),
+					future::Either::Right((ev, _)) => future::Either::Right(ev),
+				}
+			};
+
+			match event {
+				future::Either::Left(SwarmEvent::Behaviour(
+					NotificationsOut::CustomProtocolOpen { .. },
+				)) => match service1_state {
+					ServiceState::NotConnected => {
+						service1_state = ServiceState::FirstConnec;
+						if service2_state == ServiceState::FirstConnec {
+							service1
+								.behaviour_mut()
+								.disconnect_peer(Swarm::local_peer_id(&service2), SetId::from(0));
+						}
+					},
+					ServiceState::Disconnected => service1_state = ServiceState::ConnectedAgain,
+					ServiceState::FirstConnec | ServiceState::ConnectedAgain => panic!(),
+				},
+				future::Either::Left(SwarmEvent::Behaviour(
+					NotificationsOut::CustomProtocolClosed { .. },
+				)) => match service1_state {
+					ServiceState::FirstConnec => service1_state = ServiceState::Disconnected,
+					ServiceState::ConnectedAgain |
+					ServiceState::NotConnected |
+					ServiceState::Disconnected => panic!(),
+				},
+				future::Either::Right(SwarmEvent::Behaviour(
+					NotificationsOut::CustomProtocolOpen { .. },
+				)) => match service2_state {
+					ServiceState::NotConnected => {
+						service2_state = ServiceState::FirstConnec;
+						if service1_state == ServiceState::FirstConnec {
+							service1
+								.behaviour_mut()
+								.disconnect_peer(Swarm::local_peer_id(&service2), SetId::from(0));
+						}
+					},
+					ServiceState::Disconnected => service2_state = ServiceState::ConnectedAgain,
+					ServiceState::FirstConnec | ServiceState::ConnectedAgain => panic!(),
+				},
+				future::Either::Right(SwarmEvent::Behaviour(
+					NotificationsOut::CustomProtocolClosed { .. },
+				)) => match service2_state {
+					ServiceState::FirstConnec => service2_state = ServiceState::Disconnected,
+					ServiceState::ConnectedAgain |
+					ServiceState::NotConnected |
+					ServiceState::Disconnected => panic!(),
+				},
+				_ => {},
+			}
+
+			// Due to the bug in `Notifications`, the disconnected node does not always detect that
+			// it was disconnected. The closed inbound substream is tolerated by design, and the
+			// closed outbound substream is not detected until something is sent into it.
+			// See [PR #13396](https://github.com/paritytech/substrate/pull/13396).
+			// This happens if the disconnecting node reconnects to it fast enough.
+			// In this case the disconnected node does not transit via `ServiceState::NotConnected`
+			// and stays in `ServiceState::FirstConnec`.
+			// TODO: update this once the fix is finally merged.
+			if service1_state == ServiceState::ConnectedAgain &&
+				service2_state == ServiceState::ConnectedAgain ||
+				service1_state == ServiceState::ConnectedAgain &&
+					service2_state == ServiceState::FirstConnec ||
+				service1_state == ServiceState::FirstConnec &&
+					service2_state == ServiceState::ConnectedAgain
+			{
+				break
+			}
+		}
+
+		// Now that the two services have disconnected and reconnected, wait for 3 seconds and
+		// check whether they're still connected.
+		let mut delay = futures_timer::Delay::new(Duration::from_secs(3));
+
+		loop {
+			// Grab next event from services.
+			let event = {
+				let s1 = service1.select_next_some();
+				let s2 = service2.select_next_some();
+				futures::pin_mut!(s1, s2);
+				match future::select(future::select(s1, s2), &mut delay).await {
+					future::Either::Right(_) => break, // success
+					future::Either::Left((future::Either::Left((ev, _)), _)) => ev,
+					future::Either::Left((future::Either::Right((ev, _)), _)) => ev,
+				}
+			};
+
+			match event {
+				SwarmEvent::Behaviour(NotificationsOut::CustomProtocolOpen { .. }) |
+				SwarmEvent::Behaviour(NotificationsOut::CustomProtocolClosed { .. }) => panic!(),
+				_ => {},
+			}
+		}
+	});
+}
diff --git a/substrate/client/network/src/protocol/notifications/upgrade.rs b/substrate/client/network/src/protocol/notifications/upgrade.rs
new file mode 100644
index 0000000000000000000000000000000000000000..70c6023623f51b2c0d97379298febc8e4826dfbe
--- /dev/null
+++ b/substrate/client/network/src/protocol/notifications/upgrade.rs
@@ -0,0 +1,29 @@
+// 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/>.
+
+pub use self::{
+	collec::UpgradeCollec,
+	notifications::{
+		NotificationsHandshakeError, NotificationsIn, NotificationsInOpen,
+		NotificationsInSubstream, NotificationsInSubstreamHandshake, NotificationsOut,
+		NotificationsOutError, NotificationsOutOpen, NotificationsOutSubstream,
+	},
+};
+
+mod collec;
+mod notifications;
diff --git a/substrate/client/network/src/protocol/notifications/upgrade/collec.rs b/substrate/client/network/src/protocol/notifications/upgrade/collec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..791821b3f75dab135a34f7478b4c1c808566890e
--- /dev/null
+++ b/substrate/client/network/src/protocol/notifications/upgrade/collec.rs
@@ -0,0 +1,179 @@
+// 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 futures::prelude::*;
+use libp2p::core::upgrade::{InboundUpgrade, ProtocolName, UpgradeInfo};
+use std::{
+	iter::FromIterator,
+	pin::Pin,
+	task::{Context, Poll},
+	vec,
+};
+
+// TODO: move this to libp2p => https://github.com/libp2p/rust-libp2p/issues/1445
+
+/// Upgrade that combines multiple upgrades of the same type into one. Supports all the protocols
+/// supported by either sub-upgrade.
+#[derive(Debug, Clone)]
+pub struct UpgradeCollec<T>(pub Vec<T>);
+
+impl<T> From<Vec<T>> for UpgradeCollec<T> {
+	fn from(list: Vec<T>) -> Self {
+		Self(list)
+	}
+}
+
+impl<T> FromIterator<T> for UpgradeCollec<T> {
+	fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+		Self(iter.into_iter().collect())
+	}
+}
+
+impl<T: UpgradeInfo> UpgradeInfo for UpgradeCollec<T> {
+	type Info = ProtoNameWithUsize<T::Info>;
+	type InfoIter = vec::IntoIter<Self::Info>;
+
+	fn protocol_info(&self) -> Self::InfoIter {
+		self.0
+			.iter()
+			.enumerate()
+			.flat_map(|(n, p)| p.protocol_info().into_iter().map(move |i| ProtoNameWithUsize(i, n)))
+			.collect::<Vec<_>>()
+			.into_iter()
+	}
+}
+
+impl<T, C> InboundUpgrade<C> for UpgradeCollec<T>
+where
+	T: InboundUpgrade<C>,
+{
+	type Output = (T::Output, usize);
+	type Error = (T::Error, usize);
+	type Future = FutWithUsize<T::Future>;
+
+	fn upgrade_inbound(mut self, sock: C, info: Self::Info) -> Self::Future {
+		let fut = self.0.remove(info.1).upgrade_inbound(sock, info.0);
+		FutWithUsize(fut, info.1)
+	}
+}
+
+/// Groups a `ProtocolName` with a `usize`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ProtoNameWithUsize<T>(T, usize);
+
+impl<T: ProtocolName> ProtocolName for ProtoNameWithUsize<T> {
+	fn protocol_name(&self) -> &[u8] {
+		self.0.protocol_name()
+	}
+}
+
+/// Equivalent to `fut.map_ok(|v| (v, num)).map_err(|e| (e, num))`, where `fut` and `num` are
+/// the two fields of this struct.
+#[pin_project::pin_project]
+pub struct FutWithUsize<T>(#[pin] T, usize);
+
+impl<T: Future<Output = Result<O, E>>, O, E> Future for FutWithUsize<T> {
+	type Output = Result<(O, usize), (E, usize)>;
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		let this = self.project();
+		match Future::poll(this.0, cx) {
+			Poll::Ready(Ok(v)) => Poll::Ready(Ok((v, *this.1))),
+			Poll::Ready(Err(e)) => Poll::Ready(Err((e, *this.1))),
+			Poll::Pending => Poll::Pending,
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::types::ProtocolName as ProtoName;
+	use libp2p::core::upgrade::{ProtocolName, UpgradeInfo};
+
+	// TODO: move to mocks
+	mockall::mock! {
+		pub ProtocolUpgrade<T> {}
+
+		impl<T: Clone + ProtocolName> UpgradeInfo for ProtocolUpgrade<T> {
+			type Info = T;
+			type InfoIter = vec::IntoIter<T>;
+			fn protocol_info(&self) -> vec::IntoIter<T>;
+		}
+	}
+
+	#[test]
+	fn protocol_info() {
+		let upgrades = (1..=3)
+			.map(|i| {
+				let mut upgrade = MockProtocolUpgrade::<ProtoNameWithUsize<ProtoName>>::new();
+				upgrade.expect_protocol_info().return_once(move || {
+					vec![ProtoNameWithUsize(ProtoName::from(format!("protocol{i}")), i)].into_iter()
+				});
+				upgrade
+			})
+			.collect::<Vec<_>>();
+
+		let upgrade: UpgradeCollec<_> = upgrades.into_iter().collect::<UpgradeCollec<_>>();
+		let protos = vec![
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol1".to_string()), 1), 0),
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol2".to_string()), 2), 1),
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol3".to_string()), 3), 2),
+		];
+		let upgrades = upgrade.protocol_info().collect::<Vec<_>>();
+
+		assert_eq!(upgrades, protos,);
+	}
+
+	#[test]
+	fn nested_protocol_info() {
+		let mut upgrades = (1..=2)
+			.map(|i| {
+				let mut upgrade = MockProtocolUpgrade::<ProtoNameWithUsize<ProtoName>>::new();
+				upgrade.expect_protocol_info().return_once(move || {
+					vec![ProtoNameWithUsize(ProtoName::from(format!("protocol{i}")), i)].into_iter()
+				});
+				upgrade
+			})
+			.collect::<Vec<_>>();
+
+		upgrades.push({
+			let mut upgrade = MockProtocolUpgrade::<ProtoNameWithUsize<ProtoName>>::new();
+			upgrade.expect_protocol_info().return_once(move || {
+				vec![
+					ProtoNameWithUsize(ProtoName::from("protocol22".to_string()), 1),
+					ProtoNameWithUsize(ProtoName::from("protocol33".to_string()), 2),
+					ProtoNameWithUsize(ProtoName::from("protocol44".to_string()), 3),
+				]
+				.into_iter()
+			});
+			upgrade
+		});
+
+		let upgrade: UpgradeCollec<_> = upgrades.into_iter().collect::<UpgradeCollec<_>>();
+		let protos = vec![
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol1".to_string()), 1), 0),
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol2".to_string()), 2), 1),
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol22".to_string()), 1), 2),
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol33".to_string()), 2), 2),
+			ProtoNameWithUsize(ProtoNameWithUsize(ProtoName::from("protocol44".to_string()), 3), 2),
+		];
+		let upgrades = upgrade.protocol_info().collect::<Vec<_>>();
+		assert_eq!(upgrades, protos,);
+	}
+}
diff --git a/substrate/client/network/src/protocol/notifications/upgrade/notifications.rs b/substrate/client/network/src/protocol/notifications/upgrade/notifications.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e1c033f33b68e551fbd98e9c06edcbdd7173b5c
--- /dev/null
+++ b/substrate/client/network/src/protocol/notifications/upgrade/notifications.rs
@@ -0,0 +1,696 @@
+// 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/>.
+
+/// Notifications protocol.
+///
+/// The Substrate notifications protocol consists in the following:
+///
+/// - Node A opens a substream to node B and sends a message which contains some
+///   protocol-specific higher-level logic. This message is prefixed with a variable-length
+///   integer message length. This message can be empty, in which case `0` is sent.
+/// - If node B accepts the substream, it sends back a message with the same properties.
+/// - If instead B refuses the connection (which typically happens because no empty slot is
+///   available), then it immediately closes the substream without sending back anything.
+/// - Node A can then send notifications to B, prefixed with a variable-length integer
+///   indicating the length of the message.
+/// - Either node A or node B can signal that it doesn't want this notifications substream
+///   anymore by closing its writing side. The other party should respond by also closing their
+///   own writing side soon after.
+///
+/// Notification substreams are unidirectional. If A opens a substream with B, then B is
+/// encouraged but not required to open a substream to A as well.
+use crate::types::ProtocolName;
+
+use asynchronous_codec::Framed;
+use bytes::BytesMut;
+use futures::prelude::*;
+use libp2p::core::{upgrade, InboundUpgrade, OutboundUpgrade, UpgradeInfo};
+use log::{error, warn};
+use unsigned_varint::codec::UviBytes;
+
+use std::{
+	convert::Infallible,
+	io, mem,
+	pin::Pin,
+	task::{Context, Poll},
+	vec,
+};
+
+/// Maximum allowed size of the two handshake messages, in bytes.
+const MAX_HANDSHAKE_SIZE: usize = 1024;
+
+/// Upgrade that accepts a substream, sends back a status message, then becomes a unidirectional
+/// stream of messages.
+#[derive(Debug, Clone)]
+pub struct NotificationsIn {
+	/// Protocol name to use when negotiating the substream.
+	/// The first one is the main name, while the other ones are fall backs.
+	protocol_names: Vec<ProtocolName>,
+	/// Maximum allowed size for a single notification.
+	max_notification_size: u64,
+}
+
+/// Upgrade that opens a substream, waits for the remote to accept by sending back a status
+/// message, then becomes a unidirectional sink of data.
+#[derive(Debug, Clone)]
+pub struct NotificationsOut {
+	/// Protocol name to use when negotiating the substream.
+	/// The first one is the main name, while the other ones are fall backs.
+	protocol_names: Vec<ProtocolName>,
+	/// Message to send when we start the handshake.
+	initial_message: Vec<u8>,
+	/// Maximum allowed size for a single notification.
+	max_notification_size: u64,
+}
+
+/// A substream for incoming notification messages.
+///
+/// When creating, this struct starts in a state in which we must first send back a handshake
+/// message to the remote. No message will come before this has been done.
+#[pin_project::pin_project]
+pub struct NotificationsInSubstream<TSubstream> {
+	#[pin]
+	socket: Framed<TSubstream, UviBytes<io::Cursor<Vec<u8>>>>,
+	handshake: NotificationsInSubstreamHandshake,
+}
+
+/// State of the handshake sending back process.
+#[derive(Debug)]
+pub enum NotificationsInSubstreamHandshake {
+	/// Waiting for the user to give us the handshake message.
+	NotSent,
+	/// User gave us the handshake message. Trying to push it in the socket.
+	PendingSend(Vec<u8>),
+	/// Handshake message was pushed in the socket. Still need to flush.
+	Flush,
+	/// Handshake message successfully sent and flushed.
+	Sent,
+	/// Remote has closed their writing side. We close our own writing side in return.
+	ClosingInResponseToRemote,
+	/// Both our side and the remote have closed their writing side.
+	BothSidesClosed,
+}
+
+/// A substream for outgoing notification messages.
+#[pin_project::pin_project]
+pub struct NotificationsOutSubstream<TSubstream> {
+	/// Substream where to send messages.
+	#[pin]
+	socket: Framed<TSubstream, UviBytes<io::Cursor<Vec<u8>>>>,
+}
+
+#[cfg(test)]
+impl<TSubstream> NotificationsOutSubstream<TSubstream> {
+	pub fn new(socket: Framed<TSubstream, UviBytes<io::Cursor<Vec<u8>>>>) -> Self {
+		Self { socket }
+	}
+}
+
+impl NotificationsIn {
+	/// Builds a new potential upgrade.
+	pub fn new(
+		main_protocol_name: impl Into<ProtocolName>,
+		fallback_names: Vec<ProtocolName>,
+		max_notification_size: u64,
+	) -> Self {
+		let mut protocol_names = fallback_names;
+		protocol_names.insert(0, main_protocol_name.into());
+
+		Self { protocol_names, max_notification_size }
+	}
+}
+
+impl UpgradeInfo for NotificationsIn {
+	type Info = ProtocolName;
+	type InfoIter = vec::IntoIter<Self::Info>;
+
+	fn protocol_info(&self) -> Self::InfoIter {
+		self.protocol_names.clone().into_iter()
+	}
+}
+
+impl<TSubstream> InboundUpgrade<TSubstream> for NotificationsIn
+where
+	TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+{
+	type Output = NotificationsInOpen<TSubstream>;
+	type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
+	type Error = NotificationsHandshakeError;
+
+	fn upgrade_inbound(self, mut socket: TSubstream, negotiated_name: Self::Info) -> Self::Future {
+		Box::pin(async move {
+			let handshake_len = unsigned_varint::aio::read_usize(&mut socket).await?;
+			if handshake_len > MAX_HANDSHAKE_SIZE {
+				return Err(NotificationsHandshakeError::TooLarge {
+					requested: handshake_len,
+					max: MAX_HANDSHAKE_SIZE,
+				})
+			}
+
+			let mut handshake = vec![0u8; handshake_len];
+			if !handshake.is_empty() {
+				socket.read_exact(&mut handshake).await?;
+			}
+
+			let mut codec = UviBytes::default();
+			codec.set_max_len(usize::try_from(self.max_notification_size).unwrap_or(usize::MAX));
+
+			let substream = NotificationsInSubstream {
+				socket: Framed::new(socket, codec),
+				handshake: NotificationsInSubstreamHandshake::NotSent,
+			};
+
+			Ok(NotificationsInOpen {
+				handshake,
+				negotiated_fallback: if negotiated_name == self.protocol_names[0] {
+					None
+				} else {
+					Some(negotiated_name)
+				},
+				substream,
+			})
+		})
+	}
+}
+
+/// Yielded by the [`NotificationsIn`] after a successfuly upgrade.
+pub struct NotificationsInOpen<TSubstream> {
+	/// Handshake sent by the remote.
+	pub handshake: Vec<u8>,
+	/// If the negotiated name is not the "main" protocol name but a fallback, contains the
+	/// name of the negotiated fallback.
+	pub negotiated_fallback: Option<ProtocolName>,
+	/// Implementation of `Stream` that allows receives messages from the substream.
+	pub substream: NotificationsInSubstream<TSubstream>,
+}
+
+impl<TSubstream> NotificationsInSubstream<TSubstream>
+where
+	TSubstream: AsyncRead + AsyncWrite + Unpin,
+{
+	#[cfg(test)]
+	pub fn new(
+		socket: Framed<TSubstream, UviBytes<io::Cursor<Vec<u8>>>>,
+		handshake: NotificationsInSubstreamHandshake,
+	) -> Self {
+		Self { socket, handshake }
+	}
+
+	/// Sends the handshake in order to inform the remote that we accept the substream.
+	pub fn send_handshake(&mut self, message: impl Into<Vec<u8>>) {
+		if !matches!(self.handshake, NotificationsInSubstreamHandshake::NotSent) {
+			error!(target: "sub-libp2p", "Tried to send handshake twice");
+			return
+		}
+
+		self.handshake = NotificationsInSubstreamHandshake::PendingSend(message.into());
+	}
+
+	/// Equivalent to `Stream::poll_next`, except that it only drives the handshake and is
+	/// guaranteed to not generate any notification.
+	pub fn poll_process(
+		self: Pin<&mut Self>,
+		cx: &mut Context,
+	) -> Poll<Result<Infallible, io::Error>> {
+		let mut this = self.project();
+
+		loop {
+			match mem::replace(this.handshake, NotificationsInSubstreamHandshake::Sent) {
+				NotificationsInSubstreamHandshake::PendingSend(msg) => {
+					match Sink::poll_ready(this.socket.as_mut(), cx) {
+						Poll::Ready(_) => {
+							*this.handshake = NotificationsInSubstreamHandshake::Flush;
+							match Sink::start_send(this.socket.as_mut(), io::Cursor::new(msg)) {
+								Ok(()) => {},
+								Err(err) => return Poll::Ready(Err(err)),
+							}
+						},
+						Poll::Pending => {
+							*this.handshake = NotificationsInSubstreamHandshake::PendingSend(msg);
+							return Poll::Pending
+						},
+					}
+				},
+				NotificationsInSubstreamHandshake::Flush => {
+					match Sink::poll_flush(this.socket.as_mut(), cx)? {
+						Poll::Ready(()) =>
+							*this.handshake = NotificationsInSubstreamHandshake::Sent,
+						Poll::Pending => {
+							*this.handshake = NotificationsInSubstreamHandshake::Flush;
+							return Poll::Pending
+						},
+					}
+				},
+
+				st @ NotificationsInSubstreamHandshake::NotSent |
+				st @ NotificationsInSubstreamHandshake::Sent |
+				st @ NotificationsInSubstreamHandshake::ClosingInResponseToRemote |
+				st @ NotificationsInSubstreamHandshake::BothSidesClosed => {
+					*this.handshake = st;
+					return Poll::Pending
+				},
+			}
+		}
+	}
+}
+
+impl<TSubstream> Stream for NotificationsInSubstream<TSubstream>
+where
+	TSubstream: AsyncRead + AsyncWrite + Unpin,
+{
+	type Item = Result<BytesMut, io::Error>;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		let mut this = self.project();
+
+		// This `Stream` implementation first tries to send back the handshake if necessary.
+		loop {
+			match mem::replace(this.handshake, NotificationsInSubstreamHandshake::Sent) {
+				NotificationsInSubstreamHandshake::NotSent => {
+					*this.handshake = NotificationsInSubstreamHandshake::NotSent;
+					return Poll::Pending
+				},
+				NotificationsInSubstreamHandshake::PendingSend(msg) => {
+					match Sink::poll_ready(this.socket.as_mut(), cx) {
+						Poll::Ready(_) => {
+							*this.handshake = NotificationsInSubstreamHandshake::Flush;
+							match Sink::start_send(this.socket.as_mut(), io::Cursor::new(msg)) {
+								Ok(()) => {},
+								Err(err) => return Poll::Ready(Some(Err(err))),
+							}
+						},
+						Poll::Pending => {
+							*this.handshake = NotificationsInSubstreamHandshake::PendingSend(msg);
+							return Poll::Pending
+						},
+					}
+				},
+				NotificationsInSubstreamHandshake::Flush => {
+					match Sink::poll_flush(this.socket.as_mut(), cx)? {
+						Poll::Ready(()) =>
+							*this.handshake = NotificationsInSubstreamHandshake::Sent,
+						Poll::Pending => {
+							*this.handshake = NotificationsInSubstreamHandshake::Flush;
+							return Poll::Pending
+						},
+					}
+				},
+
+				NotificationsInSubstreamHandshake::Sent => {
+					match Stream::poll_next(this.socket.as_mut(), cx) {
+						Poll::Ready(None) =>
+							*this.handshake =
+								NotificationsInSubstreamHandshake::ClosingInResponseToRemote,
+						Poll::Ready(Some(msg)) => {
+							*this.handshake = NotificationsInSubstreamHandshake::Sent;
+							return Poll::Ready(Some(msg))
+						},
+						Poll::Pending => {
+							*this.handshake = NotificationsInSubstreamHandshake::Sent;
+							return Poll::Pending
+						},
+					}
+				},
+
+				NotificationsInSubstreamHandshake::ClosingInResponseToRemote =>
+					match Sink::poll_close(this.socket.as_mut(), cx)? {
+						Poll::Ready(()) =>
+							*this.handshake = NotificationsInSubstreamHandshake::BothSidesClosed,
+						Poll::Pending => {
+							*this.handshake =
+								NotificationsInSubstreamHandshake::ClosingInResponseToRemote;
+							return Poll::Pending
+						},
+					},
+
+				NotificationsInSubstreamHandshake::BothSidesClosed => return Poll::Ready(None),
+			}
+		}
+	}
+}
+
+impl NotificationsOut {
+	/// Builds a new potential upgrade.
+	pub fn new(
+		main_protocol_name: impl Into<ProtocolName>,
+		fallback_names: Vec<ProtocolName>,
+		initial_message: impl Into<Vec<u8>>,
+		max_notification_size: u64,
+	) -> Self {
+		let initial_message = initial_message.into();
+		if initial_message.len() > MAX_HANDSHAKE_SIZE {
+			error!(target: "sub-libp2p", "Outbound networking handshake is above allowed protocol limit");
+		}
+
+		let mut protocol_names = fallback_names;
+		protocol_names.insert(0, main_protocol_name.into());
+
+		Self { protocol_names, initial_message, max_notification_size }
+	}
+}
+
+impl UpgradeInfo for NotificationsOut {
+	type Info = ProtocolName;
+	type InfoIter = vec::IntoIter<Self::Info>;
+
+	fn protocol_info(&self) -> Self::InfoIter {
+		self.protocol_names.clone().into_iter()
+	}
+}
+
+impl<TSubstream> OutboundUpgrade<TSubstream> for NotificationsOut
+where
+	TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static,
+{
+	type Output = NotificationsOutOpen<TSubstream>;
+	type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
+	type Error = NotificationsHandshakeError;
+
+	fn upgrade_outbound(self, mut socket: TSubstream, negotiated_name: Self::Info) -> Self::Future {
+		Box::pin(async move {
+			upgrade::write_length_prefixed(&mut socket, &self.initial_message).await?;
+
+			// Reading handshake.
+			let handshake_len = unsigned_varint::aio::read_usize(&mut socket).await?;
+			if handshake_len > MAX_HANDSHAKE_SIZE {
+				return Err(NotificationsHandshakeError::TooLarge {
+					requested: handshake_len,
+					max: MAX_HANDSHAKE_SIZE,
+				})
+			}
+
+			let mut handshake = vec![0u8; handshake_len];
+			if !handshake.is_empty() {
+				socket.read_exact(&mut handshake).await?;
+			}
+
+			let mut codec = UviBytes::default();
+			codec.set_max_len(usize::try_from(self.max_notification_size).unwrap_or(usize::MAX));
+
+			Ok(NotificationsOutOpen {
+				handshake,
+				negotiated_fallback: if negotiated_name == self.protocol_names[0] {
+					None
+				} else {
+					Some(negotiated_name)
+				},
+				substream: NotificationsOutSubstream { socket: Framed::new(socket, codec) },
+			})
+		})
+	}
+}
+
+/// Yielded by the [`NotificationsOut`] after a successfuly upgrade.
+pub struct NotificationsOutOpen<TSubstream> {
+	/// Handshake returned by the remote.
+	pub handshake: Vec<u8>,
+	/// If the negotiated name is not the "main" protocol name but a fallback, contains the
+	/// name of the negotiated fallback.
+	pub negotiated_fallback: Option<ProtocolName>,
+	/// Implementation of `Sink` that allows sending messages on the substream.
+	pub substream: NotificationsOutSubstream<TSubstream>,
+}
+
+impl<TSubstream> Sink<Vec<u8>> for NotificationsOutSubstream<TSubstream>
+where
+	TSubstream: AsyncRead + AsyncWrite + Unpin,
+{
+	type Error = NotificationsOutError;
+
+	fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		let mut this = self.project();
+		Sink::poll_ready(this.socket.as_mut(), cx).map_err(NotificationsOutError::Io)
+	}
+
+	fn start_send(self: Pin<&mut Self>, item: Vec<u8>) -> Result<(), Self::Error> {
+		let mut this = self.project();
+		Sink::start_send(this.socket.as_mut(), io::Cursor::new(item))
+			.map_err(NotificationsOutError::Io)
+	}
+
+	fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		let mut this = self.project();
+		Sink::poll_flush(this.socket.as_mut(), cx).map_err(NotificationsOutError::Io)
+	}
+
+	fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		let mut this = self.project();
+		Sink::poll_close(this.socket.as_mut(), cx).map_err(NotificationsOutError::Io)
+	}
+}
+
+/// Error generated by sending on a notifications out substream.
+#[derive(Debug, thiserror::Error)]
+pub enum NotificationsHandshakeError {
+	/// I/O error on the substream.
+	#[error(transparent)]
+	Io(#[from] io::Error),
+
+	/// Initial message or handshake was too large.
+	#[error("Initial message or handshake was too large: {requested}")]
+	TooLarge {
+		/// Size requested by the remote.
+		requested: usize,
+		/// Maximum allowed,
+		max: usize,
+	},
+
+	/// Error while decoding the variable-length integer.
+	#[error(transparent)]
+	VarintDecode(#[from] unsigned_varint::decode::Error),
+}
+
+impl From<unsigned_varint::io::ReadError> for NotificationsHandshakeError {
+	fn from(err: unsigned_varint::io::ReadError) -> Self {
+		match err {
+			unsigned_varint::io::ReadError::Io(err) => Self::Io(err),
+			unsigned_varint::io::ReadError::Decode(err) => Self::VarintDecode(err),
+			_ => {
+				warn!("Unrecognized varint decoding error");
+				Self::Io(From::from(io::ErrorKind::InvalidData))
+			},
+		}
+	}
+}
+
+/// Error generated by sending on a notifications out substream.
+#[derive(Debug, thiserror::Error)]
+pub enum NotificationsOutError {
+	/// I/O error on the substream.
+	#[error(transparent)]
+	Io(#[from] io::Error),
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{NotificationsIn, NotificationsInOpen, NotificationsOut, NotificationsOutOpen};
+	use futures::{channel::oneshot, prelude::*};
+	use libp2p::core::upgrade;
+	use tokio::net::{TcpListener, TcpStream};
+	use tokio_util::compat::TokioAsyncReadCompatExt;
+
+	#[tokio::test]
+	async fn basic_works() {
+		const PROTO_NAME: &str = "/test/proto/1";
+		let (listener_addr_tx, listener_addr_rx) = oneshot::channel();
+
+		let client = tokio::spawn(async move {
+			let socket = TcpStream::connect(listener_addr_rx.await.unwrap()).await.unwrap();
+			let NotificationsOutOpen { handshake, mut substream, .. } = upgrade::apply_outbound(
+				socket.compat(),
+				NotificationsOut::new(PROTO_NAME, Vec::new(), &b"initial message"[..], 1024 * 1024),
+				upgrade::Version::V1,
+			)
+			.await
+			.unwrap();
+
+			assert_eq!(handshake, b"hello world");
+			substream.send(b"test message".to_vec()).await.unwrap();
+		});
+
+		let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+		listener_addr_tx.send(listener.local_addr().unwrap()).unwrap();
+
+		let (socket, _) = listener.accept().await.unwrap();
+		let NotificationsInOpen { handshake, mut substream, .. } = upgrade::apply_inbound(
+			socket.compat(),
+			NotificationsIn::new(PROTO_NAME, Vec::new(), 1024 * 1024),
+		)
+		.await
+		.unwrap();
+
+		assert_eq!(handshake, b"initial message");
+		substream.send_handshake(&b"hello world"[..]);
+
+		let msg = substream.next().await.unwrap().unwrap();
+		assert_eq!(msg.as_ref(), b"test message");
+
+		client.await.unwrap();
+	}
+
+	#[tokio::test]
+	async fn empty_handshake() {
+		// Check that everything still works when the handshake messages are empty.
+
+		const PROTO_NAME: &str = "/test/proto/1";
+		let (listener_addr_tx, listener_addr_rx) = oneshot::channel();
+
+		let client = tokio::spawn(async move {
+			let socket = TcpStream::connect(listener_addr_rx.await.unwrap()).await.unwrap();
+			let NotificationsOutOpen { handshake, mut substream, .. } = upgrade::apply_outbound(
+				socket.compat(),
+				NotificationsOut::new(PROTO_NAME, Vec::new(), vec![], 1024 * 1024),
+				upgrade::Version::V1,
+			)
+			.await
+			.unwrap();
+
+			assert!(handshake.is_empty());
+			substream.send(Default::default()).await.unwrap();
+		});
+
+		let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+		listener_addr_tx.send(listener.local_addr().unwrap()).unwrap();
+
+		let (socket, _) = listener.accept().await.unwrap();
+		let NotificationsInOpen { handshake, mut substream, .. } = upgrade::apply_inbound(
+			socket.compat(),
+			NotificationsIn::new(PROTO_NAME, Vec::new(), 1024 * 1024),
+		)
+		.await
+		.unwrap();
+
+		assert!(handshake.is_empty());
+		substream.send_handshake(vec![]);
+
+		let msg = substream.next().await.unwrap().unwrap();
+		assert!(msg.as_ref().is_empty());
+
+		client.await.unwrap();
+	}
+
+	#[tokio::test]
+	async fn refused() {
+		const PROTO_NAME: &str = "/test/proto/1";
+		let (listener_addr_tx, listener_addr_rx) = oneshot::channel();
+
+		let client = tokio::spawn(async move {
+			let socket = TcpStream::connect(listener_addr_rx.await.unwrap()).await.unwrap();
+			let outcome = upgrade::apply_outbound(
+				socket.compat(),
+				NotificationsOut::new(PROTO_NAME, Vec::new(), &b"hello"[..], 1024 * 1024),
+				upgrade::Version::V1,
+			)
+			.await;
+
+			// Despite the protocol negotiation being successfully conducted on the listener
+			// side, we have to receive an error here because the listener didn't send the
+			// handshake.
+			assert!(outcome.is_err());
+		});
+
+		let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+		listener_addr_tx.send(listener.local_addr().unwrap()).unwrap();
+
+		let (socket, _) = listener.accept().await.unwrap();
+		let NotificationsInOpen { handshake, substream, .. } = upgrade::apply_inbound(
+			socket.compat(),
+			NotificationsIn::new(PROTO_NAME, Vec::new(), 1024 * 1024),
+		)
+		.await
+		.unwrap();
+
+		assert_eq!(handshake, b"hello");
+
+		// We successfully upgrade to the protocol, but then close the substream.
+		drop(substream);
+
+		client.await.unwrap();
+	}
+
+	#[tokio::test]
+	async fn large_initial_message_refused() {
+		const PROTO_NAME: &str = "/test/proto/1";
+		let (listener_addr_tx, listener_addr_rx) = oneshot::channel();
+
+		let client = tokio::spawn(async move {
+			let socket = TcpStream::connect(listener_addr_rx.await.unwrap()).await.unwrap();
+			let ret = upgrade::apply_outbound(
+				socket.compat(),
+				// We check that an initial message that is too large gets refused.
+				NotificationsOut::new(
+					PROTO_NAME,
+					Vec::new(),
+					(0..32768).map(|_| 0).collect::<Vec<_>>(),
+					1024 * 1024,
+				),
+				upgrade::Version::V1,
+			)
+			.await;
+			assert!(ret.is_err());
+		});
+
+		let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+		listener_addr_tx.send(listener.local_addr().unwrap()).unwrap();
+
+		let (socket, _) = listener.accept().await.unwrap();
+		let ret = upgrade::apply_inbound(
+			socket.compat(),
+			NotificationsIn::new(PROTO_NAME, Vec::new(), 1024 * 1024),
+		)
+		.await;
+		assert!(ret.is_err());
+
+		client.await.unwrap();
+	}
+
+	#[tokio::test]
+	async fn large_handshake_refused() {
+		const PROTO_NAME: &str = "/test/proto/1";
+		let (listener_addr_tx, listener_addr_rx) = oneshot::channel();
+
+		let client = tokio::spawn(async move {
+			let socket = TcpStream::connect(listener_addr_rx.await.unwrap()).await.unwrap();
+			let ret = upgrade::apply_outbound(
+				socket.compat(),
+				NotificationsOut::new(PROTO_NAME, Vec::new(), &b"initial message"[..], 1024 * 1024),
+				upgrade::Version::V1,
+			)
+			.await;
+			assert!(ret.is_err());
+		});
+
+		let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+		listener_addr_tx.send(listener.local_addr().unwrap()).unwrap();
+
+		let (socket, _) = listener.accept().await.unwrap();
+		let NotificationsInOpen { handshake, mut substream, .. } = upgrade::apply_inbound(
+			socket.compat(),
+			NotificationsIn::new(PROTO_NAME, Vec::new(), 1024 * 1024),
+		)
+		.await
+		.unwrap();
+		assert_eq!(handshake, b"initial message");
+
+		// We check that a handshake that is too large gets refused.
+		substream.send_handshake((0..32768).map(|_| 0).collect::<Vec<_>>());
+		let _ = substream.next().await;
+
+		client.await.unwrap();
+	}
+}
diff --git a/substrate/client/network/src/protocol_controller.rs b/substrate/client/network/src/protocol_controller.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c9baa0a77d4ba401da0ea3cc565134c034724102
--- /dev/null
+++ b/substrate/client/network/src/protocol_controller.rs
@@ -0,0 +1,2018 @@
+// 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/>.
+
+//! Protocol Controller. Generic implementation of peer management for protocols.
+//! Responsible for accepting/rejecting incoming connections and initiating outgoing connections,
+//! respecting the inbound and outbound peer slot counts. Communicates with `PeerStore` to get and
+//! update peer reputation values and sends commands to `Notifications`.
+//!
+//! Due to asynchronous nature of communication between `ProtocolController` and `Notifications`,
+//! `ProtocolController` has an imperfect view of the states of the peers. To reduce this
+//! desynchronization, the following measures are taken:
+//!
+//! 1. Network peer events from `Notifications` are prioritized over actions from external API and
+//!    internal actions by `ProtocolController` (like slot allocation).
+//! 2. `Notifications` ignores all commands from `ProtocolController` after sending "incoming"
+//!    request until receiving the answer to this "incoming" request.
+//! 3. After sending a "connect" message, `ProtocolController` switches the state of the peer from
+//!    `Outbound` to `Inbound` if it receives an "incoming" request from `Notifications` for this
+//!    peer.
+//!
+//! These measures do not eliminate confusing commands from `ProtocolController` completely,
+//! so `Notifications` must correctly handle seemingly inconsistent commands, like a "connect"
+//! command for the peer it thinks is already connected, and a "drop" command for a peer that
+//! was previously dropped.
+//!
+//! 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 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;
+use std::{
+	collections::{HashMap, HashSet},
+	time::{Duration, Instant},
+};
+use wasm_timer::Delay;
+
+use crate::peer_store::PeerStoreProvider;
+
+/// Log target for this file.
+pub const LOG_TARGET: &str = "peerset";
+
+/// `Notifications` protocol index. For historical reasons it's called `SetId`, because it
+/// used to refer to a set of peers in a peerset for this protocol.
+///
+/// Can be constructed using the `From<usize>` trait implementation based on the index of the
+/// protocol in `Notifications`.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SetId(usize);
+
+impl SetId {
+	/// Const conversion function for initialization of hardcoded peerset indices.
+	pub const fn from(id: usize) -> Self {
+		Self(id)
+	}
+}
+
+impl From<usize> for SetId {
+	fn from(id: usize) -> Self {
+		Self(id)
+	}
+}
+
+impl From<SetId> for usize {
+	fn from(id: SetId) -> Self {
+		id.0
+	}
+}
+
+/// Configuration for a set of nodes for a specific protocol.
+#[derive(Debug)]
+pub struct ProtoSetConfig {
+	/// Maximum number of incoming links to peers.
+	pub in_peers: u32,
+
+	/// Maximum number of outgoing links to peers.
+	pub out_peers: u32,
+
+	/// Lists of nodes we should always be connected to.
+	///
+	/// > **Note**: Keep in mind that the networking has to know an address for these nodes,
+	/// >			otherwise it will not be able to connect to them.
+	pub reserved_nodes: HashSet<PeerId>,
+
+	/// If true, we only accept nodes in [`ProtoSetConfig::reserved_nodes`].
+	pub reserved_only: bool,
+}
+
+/// Message that is sent by [`ProtocolController`] to `Notifications`.
+#[derive(Debug, PartialEq)]
+pub enum Message {
+	/// Request to open a connection to the given peer. From the point of view of the
+	/// `ProtocolController`, we are immediately connected.
+	Connect {
+		/// Set id to connect on.
+		set_id: SetId,
+		/// Peer to connect to.
+		peer_id: PeerId,
+	},
+
+	/// Drop the connection to the given peer, or cancel the connection attempt after a `Connect`.
+	Drop {
+		/// Set id to disconnect on.
+		set_id: SetId,
+		/// Peer to disconnect from.
+		peer_id: PeerId,
+	},
+
+	/// Equivalent to `Connect` for the peer corresponding to this incoming index.
+	Accept(IncomingIndex),
+
+	/// Equivalent to `Drop` for the peer corresponding to this incoming index.
+	Reject(IncomingIndex),
+}
+
+/// Opaque identifier for an incoming connection. Allocated by the network.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct IncomingIndex(pub u64);
+
+impl From<u64> for IncomingIndex {
+	fn from(val: u64) -> Self {
+		Self(val)
+	}
+}
+
+/// External API actions.
+#[derive(Debug)]
+enum Action {
+	/// Add a reserved peer or mark already connected peer as reserved.
+	AddReservedPeer(PeerId),
+	/// Remove a reserved peer.
+	RemoveReservedPeer(PeerId),
+	/// Update reserved peers to match the provided set.
+	SetReservedPeers(HashSet<PeerId>),
+	/// Set/unset reserved-only mode.
+	SetReservedOnly(bool),
+	/// Disconnect a peer.
+	DisconnectPeer(PeerId),
+	/// Get the list of reserved peers.
+	GetReservedPeers(oneshot::Sender<Vec<PeerId>>),
+}
+
+/// Network events from `Notifications`.
+#[derive(Debug)]
+enum Event {
+	/// Incoming connection from the peer.
+	IncomingConnection(PeerId, IncomingIndex),
+	/// Connection with the peer dropped.
+	Dropped(PeerId),
+}
+
+/// Shared handle to [`ProtocolController`]. Distributed around the code outside of the
+/// protocol implementation.
+#[derive(Debug, Clone)]
+pub struct ProtocolHandle {
+	/// Actions from outer API.
+	actions_tx: TracingUnboundedSender<Action>,
+	/// Connection events from `Notifications`. We prioritize them over actions.
+	events_tx: TracingUnboundedSender<Event>,
+}
+
+impl ProtocolHandle {
+	/// Adds a new reserved peer. [`ProtocolController`] will make an effort
+	/// to always remain connected to this peer.
+	///
+	/// Has no effect if the node was already a reserved peer.
+	///
+	/// > **Note**: Keep in mind that the networking has to know an address for this node,
+	/// > otherwise it will not be able to connect to it.
+	pub fn add_reserved_peer(&self, peer_id: PeerId) {
+		let _ = self.actions_tx.unbounded_send(Action::AddReservedPeer(peer_id));
+	}
+
+	/// Demotes reserved peer to non-reserved. Does not disconnect the peer.
+	///
+	/// Has no effect if the node was not a reserved peer.
+	pub fn remove_reserved_peer(&self, peer_id: PeerId) {
+		let _ = self.actions_tx.unbounded_send(Action::RemoveReservedPeer(peer_id));
+	}
+
+	/// Set reserved peers to the new set.
+	pub fn set_reserved_peers(&self, peer_ids: HashSet<PeerId>) {
+		let _ = self.actions_tx.unbounded_send(Action::SetReservedPeers(peer_ids));
+	}
+
+	/// Sets whether or not [`ProtocolController`] only has connections with nodes marked
+	/// as reserved for the given set.
+	pub fn set_reserved_only(&self, reserved: bool) {
+		let _ = self.actions_tx.unbounded_send(Action::SetReservedOnly(reserved));
+	}
+
+	/// Disconnect peer. You should remove the `PeerId` from the `PeerStore` first
+	/// to not connect to the peer again during the next slot allocation.
+	pub fn disconnect_peer(&self, peer_id: PeerId) {
+		let _ = self.actions_tx.unbounded_send(Action::DisconnectPeer(peer_id));
+	}
+
+	/// Get the list of reserved peers.
+	pub fn reserved_peers(&self, pending_response: oneshot::Sender<Vec<PeerId>>) {
+		let _ = self.actions_tx.unbounded_send(Action::GetReservedPeers(pending_response));
+	}
+
+	/// Notify about incoming connection. [`ProtocolController`] will either accept or reject it.
+	pub fn incoming_connection(&self, peer_id: PeerId, incoming_index: IncomingIndex) {
+		let _ = self
+			.events_tx
+			.unbounded_send(Event::IncomingConnection(peer_id, incoming_index));
+	}
+
+	/// Notify that connection was dropped (either refused or disconnected).
+	pub fn dropped(&self, peer_id: PeerId) {
+		let _ = self.events_tx.unbounded_send(Event::Dropped(peer_id));
+	}
+}
+
+/// Direction of a connection
+#[derive(Clone, Copy, Debug)]
+enum Direction {
+	Inbound,
+	Outbound,
+}
+
+/// Status of a connection with a peer.
+#[derive(Clone, Debug)]
+enum PeerState {
+	/// We are connected to the peer.
+	Connected(Direction),
+	/// We are not connected.
+	NotConnected,
+}
+
+impl PeerState {
+	/// Returns true if we are connected with the node.
+	fn is_connected(&self) -> bool {
+		matches!(self, PeerState::Connected(_))
+	}
+}
+
+impl Default for PeerState {
+	fn default() -> PeerState {
+		PeerState::NotConnected
+	}
+}
+
+/// Worker side of [`ProtocolHandle`] responsible for all the logic.
+#[derive(Debug)]
+pub struct ProtocolController {
+	/// Set id to use when sending connect/drop requests to `Notifications`.
+	// Will likely be replaced by `ProtocolName` in the future.
+	set_id: SetId,
+	/// Receiver for outer API messages from [`ProtocolHandle`].
+	actions_rx: TracingUnboundedReceiver<Action>,
+	/// Receiver for connection events from `Notifications` sent via [`ProtocolHandle`].
+	events_rx: TracingUnboundedReceiver<Event>,
+	/// Number of occupied slots for incoming connections (not counting reserved nodes).
+	num_in: u32,
+	/// Number of occupied slots for outgoing connections (not counting reserved nodes).
+	num_out: u32,
+	/// Maximum number of slots for incoming connections (not counting reserved nodes).
+	max_in: u32,
+	/// Maximum number of slots for outgoing connections (not counting reserved nodes).
+	max_out: u32,
+	/// Connected regular nodes.
+	nodes: HashMap<PeerId, Direction>,
+	/// Reserved nodes. Should be always connected and do not occupy peer slots.
+	reserved_nodes: HashMap<PeerId, PeerState>,
+	/// Connect only to reserved nodes.
+	reserved_only: bool,
+	/// Next time to allocate slots. This is done once per second.
+	next_periodic_alloc_slots: Instant,
+	/// Outgoing channel for messages to `Notifications`.
+	to_notifications: TracingUnboundedSender<Message>,
+	/// `PeerStore` handle for checking peer reputation values and getting connection candidates
+	/// with highest reputation.
+	peer_store: Box<dyn PeerStoreProvider>,
+}
+
+impl ProtocolController {
+	/// Construct new [`ProtocolController`].
+	pub fn new(
+		set_id: SetId,
+		config: ProtoSetConfig,
+		to_notifications: TracingUnboundedSender<Message>,
+		peer_store: Box<dyn PeerStoreProvider>,
+	) -> (ProtocolHandle, ProtocolController) {
+		let (actions_tx, actions_rx) = tracing_unbounded("mpsc_api_protocol", 10_000);
+		let (events_tx, events_rx) = tracing_unbounded("mpsc_notifications_protocol", 10_000);
+		let handle = ProtocolHandle { actions_tx, events_tx };
+		peer_store.register_protocol(handle.clone());
+		let reserved_nodes =
+			config.reserved_nodes.iter().map(|p| (*p, PeerState::NotConnected)).collect();
+		let controller = ProtocolController {
+			set_id,
+			actions_rx,
+			events_rx,
+			num_in: 0,
+			num_out: 0,
+			max_in: config.in_peers,
+			max_out: config.out_peers,
+			nodes: HashMap::new(),
+			reserved_nodes,
+			reserved_only: config.reserved_only,
+			next_periodic_alloc_slots: Instant::now(),
+			to_notifications,
+			peer_store,
+		};
+		(handle, controller)
+	}
+
+	/// Drive [`ProtocolController`]. This function returns when all instances of
+	/// [`ProtocolHandle`] are dropped.
+	pub async fn run(mut self) {
+		while self.next_action().await {}
+	}
+
+	/// Perform one action. Returns `true` if it should be called again.
+	///
+	/// Intended for tests only. Use `run` for driving [`ProtocolController`].
+	pub async fn next_action(&mut self) -> bool {
+		let either = loop {
+			let mut next_alloc_slots = Delay::new_at(self.next_periodic_alloc_slots).fuse();
+
+			// See the module doc for why we use `select_biased!`.
+			futures::select_biased! {
+				event = self.events_rx.next() => match event {
+					Some(event) => break Either::Left(event),
+					None => return false,
+				},
+				action = self.actions_rx.next() => match action {
+					Some(action) => break Either::Right(action),
+					None => return false,
+				},
+				_ = next_alloc_slots => {
+					self.alloc_slots();
+					self.next_periodic_alloc_slots = Instant::now() + Duration::new(1, 0);
+				},
+			}
+		};
+
+		match either {
+			Either::Left(event) => self.process_event(event),
+			Either::Right(action) => self.process_action(action),
+		}
+
+		true
+	}
+
+	/// Process connection event.
+	fn process_event(&mut self, event: Event) {
+		match event {
+			Event::IncomingConnection(peer_id, index) =>
+				self.on_incoming_connection(peer_id, index),
+			Event::Dropped(peer_id) => self.on_peer_dropped(peer_id),
+		}
+	}
+
+	/// Process action command.
+	fn process_action(&mut self, action: Action) {
+		match action {
+			Action::AddReservedPeer(peer_id) => self.on_add_reserved_peer(peer_id),
+			Action::RemoveReservedPeer(peer_id) => self.on_remove_reserved_peer(peer_id),
+			Action::SetReservedPeers(peer_ids) => self.on_set_reserved_peers(peer_ids),
+			Action::SetReservedOnly(reserved_only) => self.on_set_reserved_only(reserved_only),
+			Action::DisconnectPeer(peer_id) => self.on_disconnect_peer(peer_id),
+			Action::GetReservedPeers(pending_response) =>
+				self.on_get_reserved_peers(pending_response),
+		}
+	}
+
+	/// Send "accept" message to `Notifications`.
+	fn accept_connection(&mut self, peer_id: PeerId, incoming_index: IncomingIndex) {
+		trace!(
+			target: LOG_TARGET,
+			"Accepting {peer_id} ({incoming_index:?}) on {:?} ({}/{} num_in/max_in).",
+			self.set_id,
+			self.num_in,
+			self.max_in,
+		);
+
+		let _ = self.to_notifications.unbounded_send(Message::Accept(incoming_index));
+	}
+
+	/// Send "reject" message to `Notifications`.
+	fn reject_connection(&mut self, peer_id: PeerId, incoming_index: IncomingIndex) {
+		trace!(
+			target: LOG_TARGET,
+			"Rejecting {peer_id} ({incoming_index:?}) on {:?} ({}/{} num_in/max_in).",
+			self.set_id,
+			self.num_in,
+			self.max_in,
+		);
+
+		let _ = self.to_notifications.unbounded_send(Message::Reject(incoming_index));
+	}
+
+	/// Send "connect" message to `Notifications`.
+	fn start_connection(&mut self, peer_id: PeerId) {
+		trace!(
+			target: LOG_TARGET,
+			"Connecting to {peer_id} on {:?} ({}/{} num_out/max_out).",
+			self.set_id,
+			self.num_out,
+			self.max_out,
+		);
+
+		let _ = self
+			.to_notifications
+			.unbounded_send(Message::Connect { set_id: self.set_id, peer_id });
+	}
+
+	/// Send "drop" message to `Notifications`.
+	fn drop_connection(&mut self, peer_id: PeerId) {
+		trace!(
+			target: LOG_TARGET,
+			"Dropping {peer_id} on {:?} ({}/{} num_in/max_in, {}/{} num_out/max_out).",
+			self.set_id,
+			self.num_in,
+			self.max_in,
+			self.num_out,
+			self.max_out,
+		);
+
+		let _ = self
+			.to_notifications
+			.unbounded_send(Message::Drop { set_id: self.set_id, peer_id });
+	}
+
+	/// Report peer disconnect event to `PeerStore` for it to update peer's reputation accordingly.
+	/// Should only be called if the remote node disconnected us, not the other way around.
+	fn report_disconnect(&mut self, peer_id: PeerId) {
+		self.peer_store.report_disconnect(peer_id);
+	}
+
+	/// Ask `Peerset` if the peer has a reputation value not sufficent for connection with it.
+	fn is_banned(&self, peer_id: &PeerId) -> bool {
+		self.peer_store.is_banned(peer_id)
+	}
+
+	/// Add the peer to the set of reserved peers. [`ProtocolController`] will try to always
+	/// maintain connections with such peers.
+	fn on_add_reserved_peer(&mut self, peer_id: PeerId) {
+		if self.reserved_nodes.contains_key(&peer_id) {
+			warn!(
+				target: LOG_TARGET,
+				"Trying to add an already reserved node {peer_id} as reserved on {:?}.",
+				self.set_id,
+			);
+			return
+		}
+
+		// Get the peer out of non-reserved peers if it's there.
+		let state = match self.nodes.remove(&peer_id) {
+			Some(direction) => {
+				trace!(
+					target: LOG_TARGET,
+					"Marking previously connected node {} ({:?}) as reserved on {:?}.",
+					peer_id,
+					direction,
+					self.set_id
+				);
+				PeerState::Connected(direction)
+			},
+			None => {
+				trace!(target: LOG_TARGET, "Adding reserved node {peer_id} on {:?}.", self.set_id,);
+				PeerState::NotConnected
+			},
+		};
+
+		self.reserved_nodes.insert(peer_id, state.clone());
+
+		// Discount occupied slots or connect to the node.
+		match state {
+			PeerState::Connected(Direction::Inbound) => self.num_in -= 1,
+			PeerState::Connected(Direction::Outbound) => self.num_out -= 1,
+			PeerState::NotConnected => self.alloc_slots(),
+		}
+	}
+
+	/// Remove the peer from the set of reserved peers. The peer is moved to the set of regular
+	/// nodes.
+	fn on_remove_reserved_peer(&mut self, peer_id: PeerId) {
+		let state = match self.reserved_nodes.remove(&peer_id) {
+			Some(state) => state,
+			None => {
+				warn!(
+					target: LOG_TARGET,
+					"Trying to remove unknown reserved node {peer_id} from {:?}.", self.set_id,
+				);
+				return
+			},
+		};
+
+		if let PeerState::Connected(direction) = state {
+			if self.reserved_only {
+				// Disconnect the node.
+				trace!(
+					target: LOG_TARGET,
+					"Disconnecting previously reserved node {peer_id} ({direction:?}) on {:?}.",
+					self.set_id,
+				);
+				self.drop_connection(peer_id);
+			} else {
+				// Count connections as of regular node.
+				trace!(
+					target: LOG_TARGET,
+					"Making a connected reserved node {peer_id} ({:?}) on {:?} a regular one.",
+					direction,
+					self.set_id,
+				);
+
+				match direction {
+					Direction::Inbound => self.num_in += 1,
+					Direction::Outbound => self.num_out += 1,
+				}
+
+				// Put the node into the list of regular nodes.
+				let prev = self.nodes.insert(peer_id, direction);
+				assert!(prev.is_none(), "Corrupted state: reserved node was also non-reserved.");
+			}
+		} else {
+			trace!(
+				target: LOG_TARGET,
+				"Removed disconnected reserved node {peer_id} from {:?}.",
+				self.set_id,
+			);
+		}
+	}
+
+	/// Replace the set of reserved peers.
+	fn on_set_reserved_peers(&mut self, peer_ids: HashSet<PeerId>) {
+		// Determine the difference between the current group and the new list.
+		let current = self.reserved_nodes.keys().cloned().collect();
+		let to_insert = peer_ids.difference(&current).cloned().collect::<Vec<_>>();
+		let to_remove = current.difference(&peer_ids).cloned().collect::<Vec<_>>();
+
+		for node in to_insert {
+			self.on_add_reserved_peer(node);
+		}
+
+		for node in to_remove {
+			self.on_remove_reserved_peer(node);
+		}
+	}
+
+	/// Change "reserved only" flag. In "reserved only" mode we connect and accept connections to
+	/// reserved nodes only.
+	fn on_set_reserved_only(&mut self, reserved_only: bool) {
+		trace!(target: LOG_TARGET, "Set reserved only to `{reserved_only}` on {:?}", self.set_id);
+
+		self.reserved_only = reserved_only;
+
+		if !reserved_only {
+			return self.alloc_slots()
+		}
+
+		// Disconnect all non-reserved peers.
+		self.nodes
+			.iter()
+			.map(|(k, v)| (*k, *v))
+			.collect::<Vec<(_, _)>>()
+			.iter()
+			.for_each(|(peer_id, direction)| {
+				// Update counters in the loop for `drop_connection` to report the correct number.
+				match direction {
+					Direction::Inbound => self.num_in -= 1,
+					Direction::Outbound => self.num_out -= 1,
+				}
+				self.drop_connection(*peer_id)
+			});
+		self.nodes.clear();
+	}
+
+	/// Get the list of reserved peers.
+	fn on_get_reserved_peers(&self, pending_response: oneshot::Sender<Vec<PeerId>>) {
+		let _ = pending_response.send(self.reserved_nodes.keys().cloned().collect());
+	}
+
+	/// Disconnect the peer.
+	fn on_disconnect_peer(&mut self, peer_id: PeerId) {
+		// Don't do anything if the node is reserved.
+		if self.reserved_nodes.contains_key(&peer_id) {
+			debug!(
+				target: LOG_TARGET,
+				"Ignoring request to disconnect reserved peer {peer_id} from {:?}.", self.set_id,
+			);
+			return
+		}
+
+		match self.nodes.remove(&peer_id) {
+			Some(direction) => {
+				trace!(
+					target: LOG_TARGET,
+					"Disconnecting peer {peer_id} ({direction:?}) from {:?}.",
+					self.set_id
+				);
+				match direction {
+					Direction::Inbound => self.num_in -= 1,
+					Direction::Outbound => self.num_out -= 1,
+				}
+				self.drop_connection(peer_id);
+			},
+			None => {
+				debug!(
+					target: LOG_TARGET,
+					"Trying to disconnect unknown peer {peer_id} from {:?}.", self.set_id,
+				);
+			},
+		}
+	}
+
+	/// Indicate that we received an incoming connection. Must be answered either with
+	/// a corresponding `Accept` or `Reject`, except if we were already connected to this peer.
+	///
+	/// Note that this mechanism is orthogonal to `Connect`/`Drop`. Accepting an incoming
+	/// connection implicitly means `Connect`, but incoming connections aren't cancelled by
+	/// `dropped`.
+	// Implementation note: because of concurrency issues, `ProtocolController` has an imperfect
+	// view of the peers' states, and may issue commands for a peer after `Notifications` received
+	// an incoming request for that peer. In this case, `Notifications` ignores all the commands
+	// until it receives a response for the incoming request to `ProtocolController`, so we must
+	// ensure we handle this incoming request correctly.
+	fn on_incoming_connection(&mut self, peer_id: PeerId, incoming_index: IncomingIndex) {
+		trace!(
+			target: LOG_TARGET,
+			"Incoming connection from peer {peer_id} ({incoming_index:?}) on {:?}.",
+			self.set_id,
+		);
+
+		if self.reserved_only && !self.reserved_nodes.contains_key(&peer_id) {
+			self.reject_connection(peer_id, incoming_index);
+			return
+		}
+
+		// Check if the node is reserved first.
+		if let Some(state) = self.reserved_nodes.get_mut(&peer_id) {
+			match state {
+				PeerState::Connected(ref mut direction) => {
+					// We are accepting an incoming connection, so ensure the direction is inbound.
+					// (See the implementation note above.)
+					*direction = Direction::Inbound;
+					self.accept_connection(peer_id, incoming_index);
+				},
+				PeerState::NotConnected =>
+					if self.peer_store.is_banned(&peer_id) {
+						self.reject_connection(peer_id, incoming_index);
+					} else {
+						*state = PeerState::Connected(Direction::Inbound);
+						self.accept_connection(peer_id, incoming_index);
+					},
+			}
+			return
+		}
+
+		// If we're already connected, pretend we are not connected and decide on the node again.
+		// (See the note above.)
+		if let Some(direction) = self.nodes.remove(&peer_id) {
+			trace!(
+				target: LOG_TARGET,
+				"Handling incoming connection from peer {} we think we already connected as {:?} on {:?}.",
+				peer_id,
+				direction,
+				self.set_id
+			);
+			match direction {
+				Direction::Inbound => self.num_in -= 1,
+				Direction::Outbound => self.num_out -= 1,
+			}
+		}
+
+		if self.num_in >= self.max_in {
+			self.reject_connection(peer_id, incoming_index);
+			return
+		}
+
+		if self.is_banned(&peer_id) {
+			self.reject_connection(peer_id, incoming_index);
+			return
+		}
+
+		self.num_in += 1;
+		self.nodes.insert(peer_id, Direction::Inbound);
+		self.accept_connection(peer_id, incoming_index);
+	}
+
+	/// Indicate that a connection with the peer was dropped.
+	fn on_peer_dropped(&mut self, peer_id: PeerId) {
+		self.on_peer_dropped_inner(peer_id).unwrap_or_else(|peer_id| {
+			// We do not assert here, because due to asynchronous nature of communication
+			// between `ProtocolController` and `Notifications` we can receive `Action::Dropped`
+			// for a peer we already disconnected ourself.
+			trace!(
+				target: LOG_TARGET,
+				"Received `Action::Dropped` for not connected peer {peer_id} on {:?}.",
+				self.set_id,
+			)
+		});
+	}
+
+	/// Indicate that a connection with the peer was dropped.
+	/// Returns `Err(PeerId)` if the peer wasn't connected or is not known to us.
+	fn on_peer_dropped_inner(&mut self, peer_id: PeerId) -> Result<(), PeerId> {
+		if self.drop_reserved_peer(&peer_id)? || self.drop_regular_peer(&peer_id) {
+			// The peer found and disconnected.
+			self.report_disconnect(peer_id);
+			Ok(())
+		} else {
+			// The peer was not found in neither regular or reserved lists.
+			Err(peer_id)
+		}
+	}
+
+	/// Try dropping the peer as a reserved peer. Return `Ok(true)` if the peer was found and
+	/// disconnected, `Ok(false)` if it wasn't found, `Err(PeerId)`, if the peer found, but not in
+	/// connected state.
+	fn drop_reserved_peer(&mut self, peer_id: &PeerId) -> Result<bool, PeerId> {
+		let Some(state) = self.reserved_nodes.get_mut(peer_id) else { return Ok(false) };
+
+		if let PeerState::Connected(direction) = state {
+			trace!(
+				target: LOG_TARGET,
+				"Reserved peer {peer_id} ({direction:?}) dropped from {:?}.",
+				self.set_id,
+			);
+			*state = PeerState::NotConnected;
+			Ok(true)
+		} else {
+			Err(*peer_id)
+		}
+	}
+
+	/// Try dropping the peer as a regular peer. Return `true` if the peer was found and
+	/// disconnected, `false` if it wasn't found.
+	fn drop_regular_peer(&mut self, peer_id: &PeerId) -> bool {
+		let Some(direction) = self.nodes.remove(peer_id) else { return false };
+
+		trace!(
+			target: LOG_TARGET,
+			"Peer {peer_id} ({direction:?}) dropped from {:?}.",
+			self.set_id,
+		);
+
+		match direction {
+			Direction::Inbound => self.num_in -= 1,
+			Direction::Outbound => self.num_out -= 1,
+		}
+
+		true
+	}
+
+	/// Initiate outgoing connections trying to connect all reserved nodes and fill in all outgoing
+	/// slots.
+	fn alloc_slots(&mut self) {
+		// Try connecting to reserved nodes first, ignoring nodes with outstanding events/actions.
+		self.reserved_nodes
+			.iter_mut()
+			.filter_map(|(peer_id, state)| {
+				(!state.is_connected() && !self.peer_store.is_banned(peer_id)).then(|| {
+					*state = PeerState::Connected(Direction::Outbound);
+					peer_id
+				})
+			})
+			.cloned()
+			.collect::<Vec<_>>()
+			.into_iter()
+			.for_each(|peer_id| {
+				self.start_connection(peer_id);
+			});
+
+		// Nothing more to do if we're in reserved-only mode or don't have slots available.
+		if self.reserved_only || self.num_out >= self.max_out {
+			return
+		}
+
+		// Fill available slots.
+		let available_slots = (self.max_out - self.num_out).saturated_into();
+
+		// Ignore reserved nodes (connected above), already connected nodes, and nodes with
+		// outstanding events/actions.
+		let ignored = self
+			.reserved_nodes
+			.keys()
+			.collect::<HashSet<&PeerId>>()
+			.union(&self.nodes.keys().collect::<HashSet<&PeerId>>())
+			.cloned()
+			.collect();
+
+		let candidates = self
+			.peer_store
+			.outgoing_candidates(available_slots, ignored)
+			.into_iter()
+			.filter_map(|peer_id| {
+				(!self.reserved_nodes.contains_key(&peer_id) && !self.nodes.contains_key(&peer_id))
+					.then_some(peer_id)
+					.or_else(|| {
+						error!(
+							target: LOG_TARGET,
+							"`PeerStore` returned a node we asked to ignore: {peer_id}.",
+						);
+						debug_assert!(false, "`PeerStore` returned a node we asked to ignore.");
+						None
+					})
+			})
+			.collect::<Vec<_>>();
+
+		if candidates.len() > available_slots {
+			error!(
+				target: LOG_TARGET,
+				"`PeerStore` returned more nodes than there are slots available.",
+			);
+			debug_assert!(false, "`PeerStore` returned more nodes than there are slots available.");
+		}
+
+		candidates.into_iter().take(available_slots).for_each(|peer_id| {
+			self.num_out += 1;
+			self.nodes.insert(peer_id, Direction::Outbound);
+			self.start_connection(peer_id);
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{peer_store::PeerStoreProvider, ReputationChange};
+	use libp2p::PeerId;
+	use sc_utils::mpsc::{tracing_unbounded, TryRecvError};
+	use std::collections::HashSet;
+
+	mockall::mock! {
+		#[derive(Debug)]
+		pub PeerStoreHandle {}
+
+		impl PeerStoreProvider for PeerStoreHandle {
+			fn is_banned(&self, peer_id: &PeerId) -> bool;
+			fn register_protocol(&self, protocol_handle: ProtocolHandle);
+			fn report_disconnect(&mut self, peer_id: PeerId);
+			fn report_peer(&mut self, peer_id: PeerId, change: ReputationChange);
+			fn peer_reputation(&self, peer_id: &PeerId) -> i32;
+			fn outgoing_candidates<'a>(&self, count: usize, ignored: HashSet<&'a PeerId>) -> Vec<PeerId>;
+		}
+	}
+
+	#[test]
+	fn reserved_nodes_are_connected_dropped_and_accepted() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+
+		// Add first reserved node via config.
+		let config = ProtoSetConfig {
+			in_peers: 0,
+			out_peers: 0,
+			reserved_nodes: std::iter::once(reserved1).collect(),
+			reserved_only: true,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(4).return_const(false);
+		peer_store.expect_report_disconnect().times(2).return_const(());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Add second reserved node at runtime (this currently calls `alloc_slots` internally).
+		controller.on_add_reserved_peer(reserved2);
+
+		// Initiate connections (currently, `alloc_slots` is also called internally in
+		// `on_add_reserved_peer` above).
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+
+		// Reserved peers do not occupy slots.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// Drop connections to be able to accept reserved nodes.
+		controller.on_peer_dropped(reserved1);
+		controller.on_peer_dropped(reserved2);
+
+		// Incoming connection from `reserved1`.
+		let incoming1 = IncomingIndex(1);
+		controller.on_incoming_connection(reserved1, incoming1);
+		assert_eq!(rx.try_recv().unwrap(), Message::Accept(incoming1));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// Incoming connection from `reserved2`.
+		let incoming2 = IncomingIndex(2);
+		controller.on_incoming_connection(reserved2, incoming2);
+		assert_eq!(rx.try_recv().unwrap(), Message::Accept(incoming2));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// Reserved peers do not occupy slots.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn banned_reserved_nodes_are_not_connected_and_not_accepted() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+
+		// Add first reserved node via config.
+		let config = ProtoSetConfig {
+			in_peers: 0,
+			out_peers: 0,
+			reserved_nodes: std::iter::once(reserved1).collect(),
+			reserved_only: true,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(6).return_const(true);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Add second reserved node at runtime (this currently calls `alloc_slots` internally).
+		controller.on_add_reserved_peer(reserved2);
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		// No slots occupied.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// No commands are generated.
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// Incoming connection from `reserved1`.
+		let incoming1 = IncomingIndex(1);
+		controller.on_incoming_connection(reserved1, incoming1);
+		assert_eq!(rx.try_recv().unwrap(), Message::Reject(incoming1));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// Incoming connection from `reserved2`.
+		let incoming2 = IncomingIndex(2);
+		controller.on_incoming_connection(reserved2, incoming2);
+		assert_eq!(rx.try_recv().unwrap(), Message::Reject(incoming2));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// No slots occupied.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn we_try_to_reconnect_to_dropped_reserved_nodes() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+
+		// Add first reserved node via config.
+		let config = ProtoSetConfig {
+			in_peers: 0,
+			out_peers: 0,
+			reserved_nodes: std::iter::once(reserved1).collect(),
+			reserved_only: true,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(4).return_const(false);
+		peer_store.expect_report_disconnect().times(2).return_const(());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Add second reserved node at runtime (this calls `alloc_slots` internally).
+		controller.on_add_reserved_peer(reserved2);
+
+		// Initiate connections (actually redundant, see previous comment).
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+
+		// Drop both reserved nodes.
+		controller.on_peer_dropped(reserved1);
+		controller.on_peer_dropped(reserved2);
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+
+		// No slots occupied.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn nodes_supplied_by_peer_store_are_connected() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+		let candidates = vec![peer1, peer2];
+
+		let config = ProtoSetConfig {
+			in_peers: 0,
+			// Less slots than candidates.
+			out_peers: 2,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_outgoing_candidates().once().return_const(candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+
+		// Only first two peers are connected (we only have 2 slots).
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer2 }));
+
+		// Outgoing slots occupied.
+		assert_eq!(controller.num_out, 2);
+		assert_eq!(controller.num_in, 0);
+
+		// No more nodes are connected.
+		controller.alloc_slots();
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// No more slots occupied.
+		assert_eq!(controller.num_out, 2);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn both_reserved_nodes_and_nodes_supplied_by_peer_store_are_connected() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+		let regular1 = PeerId::random();
+		let regular2 = PeerId::random();
+		let outgoing_candidates = vec![regular1, regular2];
+		let reserved_nodes = [reserved1, reserved2].iter().cloned().collect();
+
+		let config =
+			ProtoSetConfig { in_peers: 10, out_peers: 10, reserved_nodes, reserved_only: false };
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(2).return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 4);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: regular1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: regular2 }));
+		assert_eq!(controller.num_out, 2);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn if_slots_are_freed_we_try_to_allocate_them_again() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+		let peer3 = PeerId::random();
+		let candidates1 = vec![peer1, peer2];
+		let candidates2 = vec![peer3];
+
+		let config = ProtoSetConfig {
+			in_peers: 0,
+			// Less slots than candidates.
+			out_peers: 2,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_outgoing_candidates().once().return_const(candidates1);
+		peer_store.expect_outgoing_candidates().once().return_const(candidates2);
+		peer_store.expect_report_disconnect().times(2).return_const(());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+
+		// Only first two peers are connected (we only have 2 slots).
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer2 }));
+
+		// Outgoing slots occupied.
+		assert_eq!(controller.num_out, 2);
+		assert_eq!(controller.num_in, 0);
+
+		// No more nodes are connected.
+		controller.alloc_slots();
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// No more slots occupied.
+		assert_eq!(controller.num_out, 2);
+		assert_eq!(controller.num_in, 0);
+
+		// Drop peers.
+		controller.on_peer_dropped(peer1);
+		controller.on_peer_dropped(peer2);
+
+		// Slots are freed.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+
+		// Peers are connected.
+		assert_eq!(messages.len(), 1);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer3 }));
+
+		// Outgoing slots occupied.
+		assert_eq!(controller.num_out, 1);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn in_reserved_only_mode_no_peers_are_requested_from_peer_store_and_connected() {
+		let config = ProtoSetConfig {
+			in_peers: 0,
+			// Make sure we have slots available.
+			out_peers: 2,
+			reserved_nodes: HashSet::new(),
+			reserved_only: true,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		// No nodes are connected.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+	}
+
+	#[test]
+	fn in_reserved_only_mode_no_regular_peers_are_accepted() {
+		let config = ProtoSetConfig {
+			// Make sure we have slots available.
+			in_peers: 2,
+			out_peers: 0,
+			reserved_nodes: HashSet::new(),
+			reserved_only: true,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		let peer = PeerId::random();
+		let incoming_index = IncomingIndex(1);
+		controller.on_incoming_connection(peer, incoming_index);
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+
+		// Peer is rejected.
+		assert_eq!(messages.len(), 1);
+		assert!(messages.contains(&Message::Reject(incoming_index)));
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn disabling_reserved_only_mode_allows_to_connect_to_peers() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+		let candidates = vec![peer1, peer2];
+
+		let config = ProtoSetConfig {
+			in_peers: 0,
+			// Make sure we have slots available.
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: true,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_outgoing_candidates().once().return_const(candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Initiate connections.
+		controller.alloc_slots();
+
+		// No nodes are connected.
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// Disable reserved-only mode (this also connects to peers).
+		controller.on_set_reserved_only(false);
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer2 }));
+		assert_eq!(controller.num_out, 2);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn enabling_reserved_only_mode_disconnects_regular_peers() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+		let regular1 = PeerId::random();
+		let regular2 = PeerId::random();
+		let outgoing_candidates = vec![regular1];
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: [reserved1, reserved2].iter().cloned().collect(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(3).return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// Connect `regular1` as outbound.
+		controller.alloc_slots();
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 3);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: regular1 }));
+		assert_eq!(controller.num_out, 1);
+		assert_eq!(controller.num_in, 0);
+
+		// Connect `regular2` as inbound.
+		let incoming_index = IncomingIndex(1);
+		controller.on_incoming_connection(regular2, incoming_index);
+		assert_eq!(rx.try_recv().unwrap(), Message::Accept(incoming_index));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.num_out, 1);
+		assert_eq!(controller.num_in, 1);
+
+		// Switch to reserved-only mode.
+		controller.on_set_reserved_only(true);
+
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Drop { set_id: SetId::from(0), peer_id: regular1 }));
+		assert!(messages.contains(&Message::Drop { set_id: SetId::from(0), peer_id: regular2 }));
+		assert_eq!(controller.nodes.len(), 0);
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn removed_disconnected_reserved_node_is_forgotten() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: [reserved1, reserved2].iter().cloned().collect(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+		assert_eq!(controller.reserved_nodes.len(), 2);
+		assert_eq!(controller.nodes.len(), 0);
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		controller.on_remove_reserved_peer(reserved1);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.reserved_nodes.len(), 1);
+		assert!(!controller.reserved_nodes.contains_key(&reserved1));
+		assert_eq!(controller.nodes.len(), 0);
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+	}
+
+	#[test]
+	fn removed_connected_reserved_node_is_disconnected_in_reserved_only_mode() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: [reserved1, reserved2].iter().cloned().collect(),
+			reserved_only: true,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(2).return_const(false);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Initiate connections.
+		controller.alloc_slots();
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved1 }));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+		assert_eq!(controller.reserved_nodes.len(), 2);
+		assert!(controller.reserved_nodes.contains_key(&reserved1));
+		assert!(controller.reserved_nodes.contains_key(&reserved2));
+		assert!(controller.nodes.is_empty());
+
+		// Remove reserved node
+		controller.on_remove_reserved_peer(reserved1);
+		assert_eq!(
+			rx.try_recv().unwrap(),
+			Message::Drop { set_id: SetId::from(0), peer_id: reserved1 }
+		);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.reserved_nodes.len(), 1);
+		assert!(controller.reserved_nodes.contains_key(&reserved2));
+		assert!(controller.nodes.is_empty());
+	}
+
+	#[test]
+	fn removed_connected_reserved_nodes_become_regular_in_non_reserved_mode() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: [peer1, peer2].iter().cloned().collect(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(2).return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(Vec::new());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Connect `peer1` as inbound, `peer2` as outbound.
+		controller.on_incoming_connection(peer1, IncomingIndex(1));
+		controller.alloc_slots();
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Accept(IncomingIndex(1))));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer2 }));
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// Remove reserved nodes (and make them regular)
+		controller.on_remove_reserved_peer(peer1);
+		controller.on_remove_reserved_peer(peer2);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.nodes.len(), 2);
+		assert!(matches!(controller.nodes.get(&peer1), Some(Direction::Inbound)));
+		assert!(matches!(controller.nodes.get(&peer2), Some(Direction::Outbound)));
+		assert_eq!(controller.num_out, 1);
+		assert_eq!(controller.num_in, 1);
+	}
+
+	#[test]
+	fn regular_nodes_stop_occupying_slots_when_become_reserved() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+		let outgoing_candidates = vec![peer1];
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Connect `peer1` as outbound & `peer2` as inbound.
+		controller.alloc_slots();
+		controller.on_incoming_connection(peer2, IncomingIndex(1));
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer1 }));
+		assert!(messages.contains(&Message::Accept(IncomingIndex(1))));
+		assert_eq!(controller.num_in, 1);
+		assert_eq!(controller.num_out, 1);
+
+		controller.on_add_reserved_peer(peer1);
+		controller.on_add_reserved_peer(peer2);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.num_in, 0);
+		assert_eq!(controller.num_out, 0);
+	}
+
+	#[test]
+	fn disconnecting_regular_peers_work() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+		let outgoing_candidates = vec![peer1];
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Connect `peer1` as outbound & `peer2` as inbound.
+		controller.alloc_slots();
+		controller.on_incoming_connection(peer2, IncomingIndex(1));
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer1 }));
+		assert!(messages.contains(&Message::Accept(IncomingIndex(1))));
+		assert_eq!(controller.nodes.len(), 2);
+		assert!(matches!(controller.nodes.get(&peer1), Some(Direction::Outbound)));
+		assert!(matches!(controller.nodes.get(&peer2), Some(Direction::Inbound)));
+		assert_eq!(controller.num_in, 1);
+		assert_eq!(controller.num_out, 1);
+
+		controller.on_disconnect_peer(peer1);
+		assert_eq!(
+			rx.try_recv().unwrap(),
+			Message::Drop { set_id: SetId::from(0), peer_id: peer1 }
+		);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.nodes.len(), 1);
+		assert!(!controller.nodes.contains_key(&peer1));
+		assert_eq!(controller.num_in, 1);
+		assert_eq!(controller.num_out, 0);
+
+		controller.on_disconnect_peer(peer2);
+		assert_eq!(
+			rx.try_recv().unwrap(),
+			Message::Drop { set_id: SetId::from(0), peer_id: peer2 }
+		);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.nodes.len(), 0);
+		assert_eq!(controller.num_in, 0);
+		assert_eq!(controller.num_out, 0);
+	}
+
+	#[test]
+	fn disconnecting_reserved_peers_is_a_noop() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: [reserved1, reserved2].iter().cloned().collect(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(2).return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(Vec::new());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Connect `reserved1` as inbound & `reserved2` as outbound.
+		controller.on_incoming_connection(reserved1, IncomingIndex(1));
+		controller.alloc_slots();
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Accept(IncomingIndex(1))));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved1),
+			Some(PeerState::Connected(Direction::Inbound))
+		));
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved2),
+			Some(PeerState::Connected(Direction::Outbound))
+		));
+
+		controller.on_disconnect_peer(reserved1);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved1),
+			Some(PeerState::Connected(Direction::Inbound))
+		));
+
+		controller.on_disconnect_peer(reserved2);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved2),
+			Some(PeerState::Connected(Direction::Outbound))
+		));
+	}
+
+	#[test]
+	fn dropping_regular_peers_work() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+		let outgoing_candidates = vec![peer1];
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+		peer_store.expect_report_disconnect().times(2).return_const(());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Connect `peer1` as outbound & `peer2` as inbound.
+		controller.alloc_slots();
+		controller.on_incoming_connection(peer2, IncomingIndex(1));
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: peer1 }));
+		assert!(messages.contains(&Message::Accept(IncomingIndex(1))));
+		assert_eq!(controller.nodes.len(), 2);
+		assert!(matches!(controller.nodes.get(&peer1), Some(Direction::Outbound)));
+		assert!(matches!(controller.nodes.get(&peer2), Some(Direction::Inbound)));
+		assert_eq!(controller.num_in, 1);
+		assert_eq!(controller.num_out, 1);
+
+		controller.on_peer_dropped(peer1);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.nodes.len(), 1);
+		assert!(!controller.nodes.contains_key(&peer1));
+		assert_eq!(controller.num_in, 1);
+		assert_eq!(controller.num_out, 0);
+
+		controller.on_peer_dropped(peer2);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert_eq!(controller.nodes.len(), 0);
+		assert_eq!(controller.num_in, 0);
+		assert_eq!(controller.num_out, 0);
+	}
+
+	#[test]
+	fn incoming_request_for_connected_reserved_node_switches_it_to_inbound() {
+		let reserved1 = PeerId::random();
+		let reserved2 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: [reserved1, reserved2].iter().cloned().collect(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(2).return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(Vec::new());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Connect `reserved1` as inbound & `reserved2` as outbound.
+		controller.on_incoming_connection(reserved1, IncomingIndex(1));
+		controller.alloc_slots();
+		let mut messages = Vec::new();
+		while let Some(message) = rx.try_recv().ok() {
+			messages.push(message);
+		}
+		assert_eq!(messages.len(), 2);
+		assert!(messages.contains(&Message::Accept(IncomingIndex(1))));
+		assert!(messages.contains(&Message::Connect { set_id: SetId::from(0), peer_id: reserved2 }));
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved1),
+			Some(PeerState::Connected(Direction::Inbound))
+		));
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved2),
+			Some(PeerState::Connected(Direction::Outbound))
+		));
+
+		// Incoming request for `reserved1`.
+		controller.on_incoming_connection(reserved1, IncomingIndex(2));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Accept(IncomingIndex(2)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved1),
+			Some(PeerState::Connected(Direction::Inbound))
+		));
+
+		// Incoming request for `reserved2`.
+		controller.on_incoming_connection(reserved2, IncomingIndex(3));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Accept(IncomingIndex(3)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(
+			controller.reserved_nodes.get(&reserved2),
+			Some(PeerState::Connected(Direction::Inbound))
+		));
+	}
+
+	#[test]
+	fn incoming_request_for_connected_regular_node_switches_it_to_inbound() {
+		let regular1 = PeerId::random();
+		let regular2 = PeerId::random();
+		let outgoing_candidates = vec![regular1];
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().times(3).return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// Connect `regular1` as outbound.
+		controller.alloc_slots();
+		assert_eq!(
+			rx.try_recv().ok().unwrap(),
+			Message::Connect { set_id: SetId::from(0), peer_id: regular1 }
+		);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular1).unwrap(), Direction::Outbound,));
+
+		// Connect `regular2` as inbound.
+		controller.on_incoming_connection(regular2, IncomingIndex(0));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Accept(IncomingIndex(0)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular2).unwrap(), Direction::Inbound,));
+
+		// Incoming request for `regular1`.
+		controller.on_incoming_connection(regular1, IncomingIndex(1));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Accept(IncomingIndex(1)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular1).unwrap(), Direction::Inbound,));
+
+		// Incoming request for `regular2`.
+		controller.on_incoming_connection(regular2, IncomingIndex(2));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Accept(IncomingIndex(2)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular2).unwrap(), Direction::Inbound,));
+	}
+
+	#[test]
+	fn incoming_request_for_connected_node_is_rejected_if_its_banned() {
+		let regular1 = PeerId::random();
+		let regular2 = PeerId::random();
+		let outgoing_candidates = vec![regular1];
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(false);
+		peer_store.expect_is_banned().times(2).return_const(true);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// Connect `regular1` as outbound.
+		controller.alloc_slots();
+		assert_eq!(
+			rx.try_recv().ok().unwrap(),
+			Message::Connect { set_id: SetId::from(0), peer_id: regular1 }
+		);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular1).unwrap(), Direction::Outbound,));
+
+		// Connect `regular2` as inbound.
+		controller.on_incoming_connection(regular2, IncomingIndex(0));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Accept(IncomingIndex(0)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular2).unwrap(), Direction::Inbound,));
+
+		// Incoming request for `regular1`.
+		controller.on_incoming_connection(regular1, IncomingIndex(1));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Reject(IncomingIndex(1)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(!controller.nodes.contains_key(&regular1));
+
+		// Incoming request for `regular2`.
+		controller.on_incoming_connection(regular2, IncomingIndex(2));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Reject(IncomingIndex(2)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(!controller.nodes.contains_key(&regular2));
+	}
+
+	#[test]
+	fn incoming_request_for_connected_node_is_rejected_if_no_slots_available() {
+		let regular1 = PeerId::random();
+		let regular2 = PeerId::random();
+		let outgoing_candidates = vec![regular1];
+
+		let config = ProtoSetConfig {
+			in_peers: 1,
+			out_peers: 1,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(false);
+		peer_store.expect_outgoing_candidates().once().return_const(outgoing_candidates);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+		assert_eq!(controller.num_out, 0);
+		assert_eq!(controller.num_in, 0);
+
+		// Connect `regular1` as outbound.
+		controller.alloc_slots();
+		assert_eq!(
+			rx.try_recv().ok().unwrap(),
+			Message::Connect { set_id: SetId::from(0), peer_id: regular1 }
+		);
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular1).unwrap(), Direction::Outbound,));
+
+		// Connect `regular2` as inbound.
+		controller.on_incoming_connection(regular2, IncomingIndex(0));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Accept(IncomingIndex(0)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(matches!(controller.nodes.get(&regular2).unwrap(), Direction::Inbound,));
+
+		controller.max_in = 0;
+
+		// Incoming request for `regular1`.
+		controller.on_incoming_connection(regular1, IncomingIndex(1));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Reject(IncomingIndex(1)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(!controller.nodes.contains_key(&regular1));
+
+		// Incoming request for `regular2`.
+		controller.on_incoming_connection(regular2, IncomingIndex(2));
+		assert_eq!(rx.try_recv().ok().unwrap(), Message::Reject(IncomingIndex(2)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+		assert!(!controller.nodes.contains_key(&regular2));
+	}
+
+	#[test]
+	fn incoming_peers_that_exceed_slots_are_rejected() {
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 1,
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(false);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Connect `peer1` as inbound.
+		controller.on_incoming_connection(peer1, IncomingIndex(1));
+		assert_eq!(rx.try_recv().unwrap(), Message::Accept(IncomingIndex(1)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+
+		// Incoming requests for `peer2`.
+		controller.on_incoming_connection(peer2, IncomingIndex(2));
+		assert_eq!(rx.try_recv().unwrap(), Message::Reject(IncomingIndex(2)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+	}
+
+	#[test]
+	fn banned_regular_incoming_node_is_rejected() {
+		let peer1 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: HashSet::new(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(true);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+
+		// Incoming request.
+		controller.on_incoming_connection(peer1, IncomingIndex(1));
+		assert_eq!(rx.try_recv().unwrap(), Message::Reject(IncomingIndex(1)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+	}
+
+	#[test]
+	fn banned_reserved_incoming_node_is_rejected() {
+		let reserved1 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: std::iter::once(reserved1).collect(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(true);
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+		assert!(controller.reserved_nodes.contains_key(&reserved1));
+
+		// Incoming request.
+		controller.on_incoming_connection(reserved1, IncomingIndex(1));
+		assert_eq!(rx.try_recv().unwrap(), Message::Reject(IncomingIndex(1)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+	}
+
+	#[test]
+	fn we_dont_connect_to_banned_reserved_node() {
+		let reserved1 = PeerId::random();
+
+		let config = ProtoSetConfig {
+			in_peers: 10,
+			out_peers: 10,
+			reserved_nodes: std::iter::once(reserved1).collect(),
+			reserved_only: false,
+		};
+		let (tx, mut rx) = tracing_unbounded("mpsc_test_to_notifications", 100);
+
+		let mut peer_store = MockPeerStoreHandle::new();
+		peer_store.expect_register_protocol().once().return_const(());
+		peer_store.expect_is_banned().once().return_const(true);
+		peer_store.expect_outgoing_candidates().once().return_const(Vec::new());
+
+		let (_handle, mut controller) =
+			ProtocolController::new(SetId::from(0), config, tx, Box::new(peer_store));
+		assert!(matches!(controller.reserved_nodes.get(&reserved1), Some(PeerState::NotConnected)));
+
+		// Initiate connectios
+		controller.alloc_slots();
+		assert!(matches!(controller.reserved_nodes.get(&reserved1), Some(PeerState::NotConnected)));
+		assert_eq!(rx.try_recv().unwrap_err(), TryRecvError::Empty);
+	}
+}
diff --git a/substrate/client/network/src/request_responses.rs b/substrate/client/network/src/request_responses.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5af072aaddc62c93149f762752f50837521a910c
--- /dev/null
+++ b/substrate/client/network/src/request_responses.rs
@@ -0,0 +1,1392 @@
+// 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/>.
+
+//! Collection of request-response protocols.
+//!
+//! The [`RequestResponsesBehaviour`] struct defined in this module provides support for zero or
+//! more so-called "request-response" protocols.
+//!
+//! A request-response protocol works in the following way:
+//!
+//! - For every emitted request, a new substream is open and the protocol is negotiated. If the
+//! remote supports the protocol, the size of the request is sent as a LEB128 number, followed
+//! with the request itself. The remote then sends the size of the response as a LEB128 number,
+//! followed with the response.
+//!
+//! - Requests have a certain time limit before they time out. This time includes the time it
+//! takes to send/receive the request and response.
+//!
+//! - If provided, a ["requests processing"](ProtocolConfig::inbound_queue) channel
+//! is used to handle incoming requests.
+
+use crate::{
+	peer_store::{PeerStoreProvider, BANNED_THRESHOLD},
+	types::ProtocolName,
+	ReputationChange,
+};
+
+use futures::{channel::oneshot, prelude::*};
+use libp2p::{
+	core::{Endpoint, Multiaddr},
+	request_response::{self, Behaviour, Codec, Message, ProtocolSupport, ResponseChannel},
+	swarm::{
+		behaviour::{ConnectionClosed, FromSwarm},
+		handler::multi::MultiHandler,
+		ConnectionDenied, ConnectionId, NetworkBehaviour, PollParameters, THandler,
+		THandlerInEvent, THandlerOutEvent, ToSwarm,
+	},
+	PeerId,
+};
+
+use std::{
+	collections::{hash_map::Entry, HashMap},
+	io, iter,
+	pin::Pin,
+	task::{Context, Poll},
+	time::{Duration, Instant},
+};
+
+pub use libp2p::request_response::{Config, InboundFailure, OutboundFailure, RequestId};
+
+/// Error in a request.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum RequestFailure {
+	#[error("We are not currently connected to the requested peer.")]
+	NotConnected,
+	#[error("Given protocol hasn't been registered.")]
+	UnknownProtocol,
+	#[error("Remote has closed the substream before answering, thereby signaling that it considers the request as valid, but refused to answer it.")]
+	Refused,
+	#[error("The remote replied, but the local node is no longer interested in the response.")]
+	Obsolete,
+	#[error("Problem on the network: {0}")]
+	Network(OutboundFailure),
+}
+
+/// Configuration for a single request-response protocol.
+#[derive(Debug, Clone)]
+pub struct ProtocolConfig {
+	/// Name of the protocol on the wire. Should be something like `/foo/bar`.
+	pub name: ProtocolName,
+
+	/// Fallback on the wire protocol names to support.
+	pub fallback_names: Vec<ProtocolName>,
+
+	/// Maximum allowed size, in bytes, of a request.
+	///
+	/// Any request larger than this value will be declined as a way to avoid allocating too
+	/// much memory for it.
+	pub max_request_size: u64,
+
+	/// Maximum allowed size, in bytes, of a response.
+	///
+	/// Any response larger than this value will be declined as a way to avoid allocating too
+	/// much memory for it.
+	pub max_response_size: u64,
+
+	/// Duration after which emitted requests are considered timed out.
+	///
+	/// If you expect the response to come back quickly, you should set this to a smaller duration.
+	pub request_timeout: Duration,
+
+	/// Channel on which the networking service will send incoming requests.
+	///
+	/// Every time a peer sends a request to the local node using this protocol, the networking
+	/// service will push an element on this channel. The receiving side of this channel then has
+	/// to pull this element, process the request, and send back the response to send back to the
+	/// peer.
+	///
+	/// The size of the channel has to be carefully chosen. If the channel is full, the networking
+	/// service will discard the incoming request send back an error to the peer. Consequently,
+	/// the channel being full is an indicator that the node is overloaded.
+	///
+	/// You can typically set the size of the channel to `T / d`, where `T` is the
+	/// `request_timeout` and `d` is the expected average duration of CPU and I/O it takes to
+	/// build a response.
+	///
+	/// Can be `None` if the local node does not support answering incoming requests.
+	/// If this is `None`, then the local node will not advertise support for this protocol towards
+	/// other peers. If this is `Some` but the channel is closed, then the local node will
+	/// advertise support for this protocol, but any incoming request will lead to an error being
+	/// sent back.
+	pub inbound_queue: Option<async_channel::Sender<IncomingRequest>>,
+}
+
+/// A single request received by a peer on a request-response protocol.
+#[derive(Debug)]
+pub struct IncomingRequest {
+	/// Who sent the request.
+	pub peer: PeerId,
+
+	/// Request sent by the remote. Will always be smaller than
+	/// [`ProtocolConfig::max_request_size`].
+	pub payload: Vec<u8>,
+
+	/// Channel to send back the response.
+	///
+	/// There are two ways to indicate that handling the request failed:
+	///
+	/// 1. Drop `pending_response` and thus not changing the reputation of the peer.
+	///
+	/// 2. Sending an `Err(())` via `pending_response`, optionally including reputation changes for
+	/// the given peer.
+	pub pending_response: oneshot::Sender<OutgoingResponse>,
+}
+
+/// Response for an incoming request to be send by a request protocol handler.
+#[derive(Debug)]
+pub struct OutgoingResponse {
+	/// The payload of the response.
+	///
+	/// `Err(())` if none is available e.g. due an error while handling the request.
+	pub result: Result<Vec<u8>, ()>,
+
+	/// Reputation changes accrued while handling the request. To be applied to the reputation of
+	/// the peer sending the request.
+	pub reputation_changes: Vec<ReputationChange>,
+
+	/// If provided, the `oneshot::Sender` will be notified when the request has been sent to the
+	/// peer.
+	///
+	/// > **Note**: Operating systems typically maintain a buffer of a few dozen kilobytes of
+	/// >			outgoing data for each TCP socket, and it is not possible for a user
+	/// >			application to inspect this buffer. This channel here is not actually notified
+	/// >			when the response has been fully sent out, but rather when it has fully been
+	/// >			written to the buffer managed by the operating system.
+	pub sent_feedback: Option<oneshot::Sender<()>>,
+}
+
+/// When sending a request, what to do on a disconnected recipient.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub enum IfDisconnected {
+	/// Try to connect to the peer.
+	TryConnect,
+	/// Just fail if the destination is not yet connected.
+	ImmediateError,
+}
+
+/// Convenience functions for `IfDisconnected`.
+impl IfDisconnected {
+	/// Shall we connect to a disconnected peer?
+	pub fn should_connect(self) -> bool {
+		match self {
+			Self::TryConnect => true,
+			Self::ImmediateError => false,
+		}
+	}
+}
+
+/// Event generated by the [`RequestResponsesBehaviour`].
+#[derive(Debug)]
+pub enum Event {
+	/// A remote sent a request and either we have successfully answered it or an error happened.
+	///
+	/// This event is generated for statistics purposes.
+	InboundRequest {
+		/// Peer which has emitted the request.
+		peer: PeerId,
+		/// Name of the protocol in question.
+		protocol: ProtocolName,
+		/// Whether handling the request was successful or unsuccessful.
+		///
+		/// When successful contains the time elapsed between when we received the request and when
+		/// we sent back the response. When unsuccessful contains the failure reason.
+		result: Result<Duration, ResponseFailure>,
+	},
+
+	/// A request initiated using [`RequestResponsesBehaviour::send_request`] has succeeded or
+	/// failed.
+	///
+	/// This event is generated for statistics purposes.
+	RequestFinished {
+		/// Peer that we send a request to.
+		peer: PeerId,
+		/// Name of the protocol in question.
+		protocol: ProtocolName,
+		/// Duration the request took.
+		duration: Duration,
+		/// Result of the request.
+		result: Result<(), RequestFailure>,
+	},
+
+	/// A request protocol handler issued reputation changes for the given peer.
+	ReputationChanges {
+		/// Peer whose reputation needs to be adjust.
+		peer: PeerId,
+		/// Reputation changes.
+		changes: Vec<ReputationChange>,
+	},
+}
+
+/// Combination of a protocol name and a request id.
+///
+/// Uniquely identifies an inbound or outbound request among all handled protocols. Note however
+/// that uniqueness is only guaranteed between two inbound and likewise between two outbound
+/// requests. There is no uniqueness guarantee in a set of both inbound and outbound
+/// [`ProtocolRequestId`]s.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct ProtocolRequestId {
+	protocol: ProtocolName,
+	request_id: RequestId,
+}
+
+impl From<(ProtocolName, RequestId)> for ProtocolRequestId {
+	fn from((protocol, request_id): (ProtocolName, RequestId)) -> Self {
+		Self { protocol, request_id }
+	}
+}
+
+/// Implementation of `NetworkBehaviour` that provides support for request-response protocols.
+pub struct RequestResponsesBehaviour {
+	/// The multiple sub-protocols, by name.
+	///
+	/// Contains the underlying libp2p request-response [`Behaviour`], plus an optional
+	/// "response builder" used to build responses for incoming requests.
+	protocols: HashMap<
+		ProtocolName,
+		(Behaviour<GenericCodec>, Option<async_channel::Sender<IncomingRequest>>),
+	>,
+
+	/// Pending requests, passed down to a request-response [`Behaviour`], awaiting a reply.
+	pending_requests:
+		HashMap<ProtocolRequestId, (Instant, oneshot::Sender<Result<Vec<u8>, RequestFailure>>)>,
+
+	/// Whenever an incoming request arrives, a `Future` is added to this list and will yield the
+	/// start time and the response to send back to the remote.
+	pending_responses: stream::FuturesUnordered<
+		Pin<Box<dyn Future<Output = Option<RequestProcessingOutcome>> + Send>>,
+	>,
+
+	/// Whenever an incoming request arrives, the arrival [`Instant`] is recorded here.
+	pending_responses_arrival_time: HashMap<ProtocolRequestId, Instant>,
+
+	/// Whenever a response is received on `pending_responses`, insert a channel to be notified
+	/// when the request has been sent out.
+	send_feedback: HashMap<ProtocolRequestId, oneshot::Sender<()>>,
+
+	/// Primarily used to get a reputation of a node.
+	peer_store: Box<dyn PeerStoreProvider>,
+}
+
+/// Generated by the response builder and waiting to be processed.
+struct RequestProcessingOutcome {
+	peer: PeerId,
+	request_id: RequestId,
+	protocol: ProtocolName,
+	inner_channel: ResponseChannel<Result<Vec<u8>, ()>>,
+	response: OutgoingResponse,
+}
+
+impl RequestResponsesBehaviour {
+	/// Creates a new behaviour. Must be passed a list of supported protocols. Returns an error if
+	/// the same protocol is passed twice.
+	pub fn new(
+		list: impl Iterator<Item = ProtocolConfig>,
+		peer_store: Box<dyn PeerStoreProvider>,
+	) -> Result<Self, RegisterError> {
+		let mut protocols = HashMap::new();
+		for protocol in list {
+			let mut cfg = Config::default();
+			cfg.set_connection_keep_alive(Duration::from_secs(10));
+			cfg.set_request_timeout(protocol.request_timeout);
+
+			let protocol_support = if protocol.inbound_queue.is_some() {
+				ProtocolSupport::Full
+			} else {
+				ProtocolSupport::Outbound
+			};
+
+			let rq_rp = Behaviour::new(
+				GenericCodec {
+					max_request_size: protocol.max_request_size,
+					max_response_size: protocol.max_response_size,
+				},
+				iter::once(protocol.name.as_bytes().to_vec())
+					.chain(protocol.fallback_names.iter().map(|name| name.as_bytes().to_vec()))
+					.zip(iter::repeat(protocol_support)),
+				cfg,
+			);
+
+			match protocols.entry(protocol.name) {
+				Entry::Vacant(e) => e.insert((rq_rp, protocol.inbound_queue)),
+				Entry::Occupied(e) => return Err(RegisterError::DuplicateProtocol(e.key().clone())),
+			};
+		}
+
+		Ok(Self {
+			protocols,
+			pending_requests: Default::default(),
+			pending_responses: Default::default(),
+			pending_responses_arrival_time: Default::default(),
+			send_feedback: Default::default(),
+			peer_store,
+		})
+	}
+
+	/// Initiates sending a request.
+	///
+	/// If there is no established connection to the target peer, the behavior is determined by the
+	/// choice of `connect`.
+	///
+	/// An error is returned if the protocol doesn't match one that has been registered.
+	pub fn send_request(
+		&mut self,
+		target: &PeerId,
+		protocol_name: &str,
+		request: Vec<u8>,
+		pending_response: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		connect: IfDisconnected,
+	) {
+		log::trace!(target: "sub-libp2p", "send request to {target} ({protocol_name:?}), {} bytes", request.len());
+
+		if let Some((protocol, _)) = self.protocols.get_mut(protocol_name) {
+			if protocol.is_connected(target) || connect.should_connect() {
+				let request_id = protocol.send_request(target, request);
+				let prev_req_id = self.pending_requests.insert(
+					(protocol_name.to_string().into(), request_id).into(),
+					(Instant::now(), pending_response),
+				);
+				debug_assert!(prev_req_id.is_none(), "Expect request id to be unique.");
+			} else if pending_response.send(Err(RequestFailure::NotConnected)).is_err() {
+				log::debug!(
+					target: "sub-libp2p",
+					"Not connected to peer {:?}. At the same time local \
+					 node is no longer interested in the result.",
+					target,
+				);
+			}
+		} else if pending_response.send(Err(RequestFailure::UnknownProtocol)).is_err() {
+			log::debug!(
+				target: "sub-libp2p",
+				"Unknown protocol {:?}. At the same time local \
+				 node is no longer interested in the result.",
+				protocol_name,
+			);
+		}
+	}
+}
+
+impl NetworkBehaviour for RequestResponsesBehaviour {
+	type ConnectionHandler =
+		MultiHandler<String, <Behaviour<GenericCodec> as NetworkBehaviour>::ConnectionHandler>;
+	type OutEvent = Event;
+
+	fn handle_pending_inbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		_local_addr: &Multiaddr,
+		_remote_addr: &Multiaddr,
+	) -> Result<(), ConnectionDenied> {
+		Ok(())
+	}
+
+	fn handle_pending_outbound_connection(
+		&mut self,
+		_connection_id: ConnectionId,
+		_maybe_peer: Option<PeerId>,
+		_addresses: &[Multiaddr],
+		_effective_role: Endpoint,
+	) -> Result<Vec<Multiaddr>, ConnectionDenied> {
+		Ok(Vec::new())
+	}
+
+	fn handle_established_inbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		local_addr: &Multiaddr,
+		remote_addr: &Multiaddr,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		let iter = self.protocols.iter_mut().filter_map(|(p, (r, _))| {
+			if let Ok(handler) = r.handle_established_inbound_connection(
+				connection_id,
+				peer,
+				local_addr,
+				remote_addr,
+			) {
+				Some((p.to_string(), handler))
+			} else {
+				None
+			}
+		});
+
+		Ok(MultiHandler::try_from_iter(iter).expect(
+			"Protocols are in a HashMap and there can be at most one handler per protocol name, \
+			 which is the only possible error; qed",
+		))
+	}
+
+	fn handle_established_outbound_connection(
+		&mut self,
+		connection_id: ConnectionId,
+		peer: PeerId,
+		addr: &Multiaddr,
+		role_override: Endpoint,
+	) -> Result<THandler<Self>, ConnectionDenied> {
+		let iter = self.protocols.iter_mut().filter_map(|(p, (r, _))| {
+			if let Ok(handler) =
+				r.handle_established_outbound_connection(connection_id, peer, addr, role_override)
+			{
+				Some((p.to_string(), handler))
+			} else {
+				None
+			}
+		});
+
+		Ok(MultiHandler::try_from_iter(iter).expect(
+			"Protocols are in a HashMap and there can be at most one handler per protocol name, \
+			 which is the only possible error; qed",
+		))
+	}
+
+	fn on_swarm_event(&mut self, event: FromSwarm<Self::ConnectionHandler>) {
+		match event {
+			FromSwarm::ConnectionEstablished(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::ConnectionEstablished(e));
+				},
+			FromSwarm::ConnectionClosed(ConnectionClosed {
+				peer_id,
+				connection_id,
+				endpoint,
+				handler,
+				remaining_established,
+			}) =>
+				for (p_name, p_handler) in handler.into_iter() {
+					if let Some((proto, _)) = self.protocols.get_mut(p_name.as_str()) {
+						proto.on_swarm_event(FromSwarm::ConnectionClosed(ConnectionClosed {
+							peer_id,
+							connection_id,
+							endpoint,
+							handler: p_handler,
+							remaining_established,
+						}));
+					} else {
+						log::error!(
+						  target: "sub-libp2p",
+						  "on_swarm_event/connection_closed: no request-response instance registered for protocol {:?}",
+						  p_name,
+						)
+					}
+				},
+			FromSwarm::DialFailure(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::DialFailure(e));
+				},
+			FromSwarm::ListenerClosed(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::ListenerClosed(e));
+				},
+			FromSwarm::ListenFailure(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::ListenFailure(e));
+				},
+			FromSwarm::ListenerError(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::ListenerError(e));
+				},
+			FromSwarm::ExpiredExternalAddr(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::ExpiredExternalAddr(e));
+				},
+			FromSwarm::NewListener(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::NewListener(e));
+				},
+			FromSwarm::ExpiredListenAddr(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::ExpiredListenAddr(e));
+				},
+			FromSwarm::NewExternalAddr(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::NewExternalAddr(e));
+				},
+			FromSwarm::AddressChange(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::AddressChange(e));
+				},
+			FromSwarm::NewListenAddr(e) =>
+				for (p, _) in self.protocols.values_mut() {
+					NetworkBehaviour::on_swarm_event(p, FromSwarm::NewListenAddr(e));
+				},
+		}
+	}
+
+	fn on_connection_handler_event(
+		&mut self,
+		peer_id: PeerId,
+		connection_id: ConnectionId,
+		event: THandlerOutEvent<Self>,
+	) {
+		let p_name = event.0;
+		if let Some((proto, _)) = self.protocols.get_mut(p_name.as_str()) {
+			return proto.on_connection_handler_event(peer_id, connection_id, event.1)
+		} else {
+			log::warn!(
+				target: "sub-libp2p",
+				"on_connection_handler_event: no request-response instance registered for protocol {:?}",
+				p_name
+			);
+		}
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut Context,
+		params: &mut impl PollParameters,
+	) -> Poll<ToSwarm<Self::OutEvent, THandlerInEvent<Self>>> {
+		'poll_all: loop {
+			// Poll to see if any response is ready to be sent back.
+			while let Poll::Ready(Some(outcome)) = self.pending_responses.poll_next_unpin(cx) {
+				let RequestProcessingOutcome {
+					peer,
+					request_id,
+					protocol: protocol_name,
+					inner_channel,
+					response: OutgoingResponse { result, reputation_changes, sent_feedback },
+				} = match outcome {
+					Some(outcome) => outcome,
+					// The response builder was too busy or handling the request failed. This is
+					// later on reported as a `InboundFailure::Omission`.
+					None => continue,
+				};
+
+				if let Ok(payload) = result {
+					if let Some((protocol, _)) = self.protocols.get_mut(&*protocol_name) {
+						log::trace!(target: "sub-libp2p", "send response to {peer} ({protocol_name:?}), {} bytes", payload.len());
+
+						if protocol.send_response(inner_channel, Ok(payload)).is_err() {
+							// Note: Failure is handled further below when receiving
+							// `InboundFailure` event from request-response [`Behaviour`].
+							log::debug!(
+								target: "sub-libp2p",
+								"Failed to send response for {:?} on protocol {:?} due to a \
+								 timeout or due to the connection to the peer being closed. \
+								 Dropping response",
+								request_id, protocol_name,
+							);
+						} else if let Some(sent_feedback) = sent_feedback {
+							self.send_feedback
+								.insert((protocol_name, request_id).into(), sent_feedback);
+						}
+					}
+				}
+
+				if !reputation_changes.is_empty() {
+					return Poll::Ready(ToSwarm::GenerateEvent(Event::ReputationChanges {
+						peer,
+						changes: reputation_changes,
+					}))
+				}
+			}
+
+			// Poll request-responses protocols.
+			for (protocol, (behaviour, resp_builder)) in &mut self.protocols {
+				'poll_protocol: while let Poll::Ready(ev) = behaviour.poll(cx, params) {
+					let ev = match ev {
+						// Main events we are interested in.
+						ToSwarm::GenerateEvent(ev) => ev,
+
+						// Other events generated by the underlying behaviour are transparently
+						// passed through.
+						ToSwarm::Dial { opts } => {
+							if opts.get_peer_id().is_none() {
+								log::error!(
+									"The request-response isn't supposed to start dialing addresses"
+								);
+							}
+							return Poll::Ready(ToSwarm::Dial { opts })
+						},
+						ToSwarm::NotifyHandler { peer_id, handler, event } =>
+							return Poll::Ready(ToSwarm::NotifyHandler {
+								peer_id,
+								handler,
+								event: ((*protocol).to_string(), event),
+							}),
+						ToSwarm::ReportObservedAddr { address, score } =>
+							return Poll::Ready(ToSwarm::ReportObservedAddr { address, score }),
+						ToSwarm::CloseConnection { peer_id, connection } =>
+							return Poll::Ready(ToSwarm::CloseConnection { peer_id, connection }),
+					};
+
+					match ev {
+						// Received a request from a remote.
+						request_response::Event::Message {
+							peer,
+							message: Message::Request { request_id, request, channel, .. },
+						} => {
+							self.pending_responses_arrival_time
+								.insert((protocol.clone(), request_id).into(), Instant::now());
+
+							let reputation = self.peer_store.peer_reputation(&peer);
+
+							if reputation < BANNED_THRESHOLD {
+								log::debug!(
+									target: "sub-libp2p",
+									"Cannot handle requests from a node with a low reputation {}: {}",
+									peer,
+									reputation,
+								);
+								continue 'poll_protocol
+							}
+
+							let (tx, rx) = oneshot::channel();
+
+							// Submit the request to the "response builder" passed by the user at
+							// initialization.
+							if let Some(resp_builder) = resp_builder {
+								// If the response builder is too busy, silently drop `tx`. This
+								// will be reported by the corresponding request-response
+								// [`Behaviour`] through an `InboundFailure::Omission` event.
+								// Note that we use `async_channel::bounded` and not `mpsc::channel`
+								// because the latter allocates an extra slot for every cloned
+								// sender.
+								let _ = resp_builder.try_send(IncomingRequest {
+									peer,
+									payload: request,
+									pending_response: tx,
+								});
+							} else {
+								debug_assert!(false, "Received message on outbound-only protocol.");
+							}
+
+							let protocol = protocol.clone();
+
+							self.pending_responses.push(Box::pin(async move {
+								// The `tx` created above can be dropped if we are not capable of
+								// processing this request, which is reflected as a
+								// `InboundFailure::Omission` event.
+								rx.await.map_or(None, |response| {
+									Some(RequestProcessingOutcome {
+										peer,
+										request_id,
+										protocol,
+										inner_channel: channel,
+										response,
+									})
+								})
+							}));
+
+							// This `continue` makes sure that `pending_responses` gets polled
+							// after we have added the new element.
+							continue 'poll_all
+						},
+
+						// Received a response from a remote to one of our requests.
+						request_response::Event::Message {
+							peer,
+							message: Message::Response { request_id, response },
+							..
+						} => {
+							let (started, delivered) = match self
+								.pending_requests
+								.remove(&(protocol.clone(), request_id).into())
+							{
+								Some((started, pending_response)) => {
+									log::trace!(
+										target: "sub-libp2p",
+										"received response from {peer} ({protocol:?}), {} bytes",
+										response.as_ref().map_or(0usize, |response| response.len()),
+									);
+
+									let delivered = pending_response
+										.send(response.map_err(|()| RequestFailure::Refused))
+										.map_err(|_| RequestFailure::Obsolete);
+									(started, delivered)
+								},
+								None => {
+									log::warn!(
+										target: "sub-libp2p",
+										"Received `RequestResponseEvent::Message` with unexpected request id {:?}",
+										request_id,
+									);
+									debug_assert!(false);
+									continue
+								},
+							};
+
+							let out = Event::RequestFinished {
+								peer,
+								protocol: protocol.clone(),
+								duration: started.elapsed(),
+								result: delivered,
+							};
+
+							return Poll::Ready(ToSwarm::GenerateEvent(out))
+						},
+
+						// One of our requests has failed.
+						request_response::Event::OutboundFailure {
+							peer,
+							request_id,
+							error,
+							..
+						} => {
+							let started = match self
+								.pending_requests
+								.remove(&(protocol.clone(), request_id).into())
+							{
+								Some((started, pending_response)) => {
+									if pending_response
+										.send(Err(RequestFailure::Network(error.clone())))
+										.is_err()
+									{
+										log::debug!(
+											target: "sub-libp2p",
+											"Request with id {:?} failed. At the same time local \
+											 node is no longer interested in the result.",
+											request_id,
+										);
+									}
+									started
+								},
+								None => {
+									log::warn!(
+										target: "sub-libp2p",
+										"Received `RequestResponseEvent::Message` with unexpected request id {:?}",
+										request_id,
+									);
+									debug_assert!(false);
+									continue
+								},
+							};
+
+							let out = Event::RequestFinished {
+								peer,
+								protocol: protocol.clone(),
+								duration: started.elapsed(),
+								result: Err(RequestFailure::Network(error)),
+							};
+
+							return Poll::Ready(ToSwarm::GenerateEvent(out))
+						},
+
+						// An inbound request failed, either while reading the request or due to
+						// failing to send a response.
+						request_response::Event::InboundFailure {
+							request_id, peer, error, ..
+						} => {
+							self.pending_responses_arrival_time
+								.remove(&(protocol.clone(), request_id).into());
+							self.send_feedback.remove(&(protocol.clone(), request_id).into());
+							let out = Event::InboundRequest {
+								peer,
+								protocol: protocol.clone(),
+								result: Err(ResponseFailure::Network(error)),
+							};
+							return Poll::Ready(ToSwarm::GenerateEvent(out))
+						},
+
+						// A response to an inbound request has been sent.
+						request_response::Event::ResponseSent { request_id, peer } => {
+							let arrival_time = self
+								.pending_responses_arrival_time
+								.remove(&(protocol.clone(), request_id).into())
+								.map(|t| t.elapsed())
+								.expect(
+									"Time is added for each inbound request on arrival and only \
+									 removed on success (`ResponseSent`) or failure \
+									 (`InboundFailure`). One can not receive a success event for a \
+									 request that either never arrived, or that has previously \
+									 failed; qed.",
+								);
+
+							if let Some(send_feedback) =
+								self.send_feedback.remove(&(protocol.clone(), request_id).into())
+							{
+								let _ = send_feedback.send(());
+							}
+
+							let out = Event::InboundRequest {
+								peer,
+								protocol: protocol.clone(),
+								result: Ok(arrival_time),
+							};
+
+							return Poll::Ready(ToSwarm::GenerateEvent(out))
+						},
+					};
+				}
+			}
+
+			break Poll::Pending
+		}
+	}
+}
+
+/// Error when registering a protocol.
+#[derive(Debug, thiserror::Error)]
+pub enum RegisterError {
+	/// A protocol has been specified multiple times.
+	#[error("{0}")]
+	DuplicateProtocol(ProtocolName),
+}
+
+/// Error when processing a request sent by a remote.
+#[derive(Debug, thiserror::Error)]
+pub enum ResponseFailure {
+	/// Problem on the network.
+	#[error("Problem on the network: {0}")]
+	Network(InboundFailure),
+}
+
+/// Implements the libp2p [`Codec`] trait. Defines how streams of bytes are turned
+/// into requests and responses and vice-versa.
+#[derive(Debug, Clone)]
+#[doc(hidden)] // Needs to be public in order to satisfy the Rust compiler.
+pub struct GenericCodec {
+	max_request_size: u64,
+	max_response_size: u64,
+}
+
+#[async_trait::async_trait]
+impl Codec for GenericCodec {
+	type Protocol = Vec<u8>;
+	type Request = Vec<u8>;
+	type Response = Result<Vec<u8>, ()>;
+
+	async fn read_request<T>(
+		&mut self,
+		_: &Self::Protocol,
+		mut io: &mut T,
+	) -> io::Result<Self::Request>
+	where
+		T: AsyncRead + Unpin + Send,
+	{
+		// Read the length.
+		let length = unsigned_varint::aio::read_usize(&mut io)
+			.await
+			.map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
+		if length > usize::try_from(self.max_request_size).unwrap_or(usize::MAX) {
+			return Err(io::Error::new(
+				io::ErrorKind::InvalidInput,
+				format!("Request size exceeds limit: {} > {}", length, self.max_request_size),
+			))
+		}
+
+		// Read the payload.
+		let mut buffer = vec![0; length];
+		io.read_exact(&mut buffer).await?;
+		Ok(buffer)
+	}
+
+	async fn read_response<T>(
+		&mut self,
+		_: &Self::Protocol,
+		mut io: &mut T,
+	) -> io::Result<Self::Response>
+	where
+		T: AsyncRead + Unpin + Send,
+	{
+		// Note that this function returns a `Result<Result<...>>`. Returning an `Err` is
+		// considered as a protocol error and will result in the entire connection being closed.
+		// Returning `Ok(Err(_))` signifies that a response has successfully been fetched, and
+		// that this response is an error.
+
+		// Read the length.
+		let length = match unsigned_varint::aio::read_usize(&mut io).await {
+			Ok(l) => l,
+			Err(unsigned_varint::io::ReadError::Io(err))
+				if matches!(err.kind(), io::ErrorKind::UnexpectedEof) =>
+				return Ok(Err(())),
+			Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidInput, err)),
+		};
+
+		if length > usize::try_from(self.max_response_size).unwrap_or(usize::MAX) {
+			return Err(io::Error::new(
+				io::ErrorKind::InvalidInput,
+				format!("Response size exceeds limit: {} > {}", length, self.max_response_size),
+			))
+		}
+
+		// Read the payload.
+		let mut buffer = vec![0; length];
+		io.read_exact(&mut buffer).await?;
+		Ok(Ok(buffer))
+	}
+
+	async fn write_request<T>(
+		&mut self,
+		_: &Self::Protocol,
+		io: &mut T,
+		req: Self::Request,
+	) -> io::Result<()>
+	where
+		T: AsyncWrite + Unpin + Send,
+	{
+		// TODO: check the length?
+		// Write the length.
+		{
+			let mut buffer = unsigned_varint::encode::usize_buffer();
+			io.write_all(unsigned_varint::encode::usize(req.len(), &mut buffer)).await?;
+		}
+
+		// Write the payload.
+		io.write_all(&req).await?;
+
+		io.close().await?;
+		Ok(())
+	}
+
+	async fn write_response<T>(
+		&mut self,
+		_: &Self::Protocol,
+		io: &mut T,
+		res: Self::Response,
+	) -> io::Result<()>
+	where
+		T: AsyncWrite + Unpin + Send,
+	{
+		// If `res` is an `Err`, we jump to closing the substream without writing anything on it.
+		if let Ok(res) = res {
+			// TODO: check the length?
+			// Write the length.
+			{
+				let mut buffer = unsigned_varint::encode::usize_buffer();
+				io.write_all(unsigned_varint::encode::usize(res.len(), &mut buffer)).await?;
+			}
+
+			// Write the payload.
+			io.write_all(&res).await?;
+		}
+
+		io.close().await?;
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use crate::mock::MockPeerStore;
+	use futures::{channel::oneshot, executor::LocalPool, task::Spawn};
+	use libp2p::{
+		core::{
+			transport::{MemoryTransport, Transport},
+			upgrade,
+		},
+		identity::Keypair,
+		noise,
+		swarm::{Executor, Swarm, SwarmBuilder, SwarmEvent},
+		Multiaddr,
+	};
+	use std::{iter, time::Duration};
+
+	struct TokioExecutor(tokio::runtime::Runtime);
+	impl Executor for TokioExecutor {
+		fn exec(&self, f: Pin<Box<dyn Future<Output = ()> + Send>>) {
+			let _ = self.0.spawn(f);
+		}
+	}
+
+	fn build_swarm(
+		list: impl Iterator<Item = ProtocolConfig>,
+	) -> (Swarm<RequestResponsesBehaviour>, Multiaddr) {
+		let keypair = Keypair::generate_ed25519();
+
+		let transport = MemoryTransport::new()
+			.upgrade(upgrade::Version::V1)
+			.authenticate(noise::Config::new(&keypair).unwrap())
+			.multiplex(libp2p::yamux::Config::default())
+			.boxed();
+
+		let behaviour = RequestResponsesBehaviour::new(list, Box::new(MockPeerStore {})).unwrap();
+
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let mut swarm = SwarmBuilder::with_executor(
+			transport,
+			behaviour,
+			keypair.public().to_peer_id(),
+			TokioExecutor(runtime),
+		)
+		.build();
+		let listen_addr: Multiaddr = format!("/memory/{}", rand::random::<u64>()).parse().unwrap();
+
+		swarm.listen_on(listen_addr.clone()).unwrap();
+		(swarm, listen_addr)
+	}
+
+	#[test]
+	fn basic_request_response_works() {
+		let protocol_name = "/test/req-resp/1";
+		let mut pool = LocalPool::new();
+
+		// Build swarms whose behaviour is [`RequestResponsesBehaviour`].
+		let mut swarms = (0..2)
+			.map(|_| {
+				let (tx, mut rx) = async_channel::bounded::<IncomingRequest>(64);
+
+				pool.spawner()
+					.spawn_obj(
+						async move {
+							while let Some(rq) = rx.next().await {
+								let (fb_tx, fb_rx) = oneshot::channel();
+								assert_eq!(rq.payload, b"this is a request");
+								let _ = rq.pending_response.send(super::OutgoingResponse {
+									result: Ok(b"this is a response".to_vec()),
+									reputation_changes: Vec::new(),
+									sent_feedback: Some(fb_tx),
+								});
+								fb_rx.await.unwrap();
+							}
+						}
+						.boxed()
+						.into(),
+					)
+					.unwrap();
+
+				let protocol_config = ProtocolConfig {
+					name: From::from(protocol_name),
+					fallback_names: Vec::new(),
+					max_request_size: 1024,
+					max_response_size: 1024 * 1024,
+					request_timeout: Duration::from_secs(30),
+					inbound_queue: Some(tx),
+				};
+
+				build_swarm(iter::once(protocol_config))
+			})
+			.collect::<Vec<_>>();
+
+		// Ask `swarm[0]` to dial `swarm[1]`. There isn't any discovery mechanism in place in
+		// this test, so they wouldn't connect to each other.
+		{
+			let dial_addr = swarms[1].1.clone();
+			Swarm::dial(&mut swarms[0].0, dial_addr).unwrap();
+		}
+
+		let (mut swarm, _) = swarms.remove(0);
+		// Running `swarm[0]` in the background.
+		pool.spawner()
+			.spawn_obj({
+				async move {
+					loop {
+						match swarm.select_next_some().await {
+							SwarmEvent::Behaviour(Event::InboundRequest { result, .. }) => {
+								result.unwrap();
+							},
+							_ => {},
+						}
+					}
+				}
+				.boxed()
+				.into()
+			})
+			.unwrap();
+
+		// Remove and run the remaining swarm.
+		let (mut swarm, _) = swarms.remove(0);
+		pool.run_until(async move {
+			let mut response_receiver = None;
+
+			loop {
+				match swarm.select_next_some().await {
+					SwarmEvent::ConnectionEstablished { peer_id, .. } => {
+						let (sender, receiver) = oneshot::channel();
+						swarm.behaviour_mut().send_request(
+							&peer_id,
+							protocol_name,
+							b"this is a request".to_vec(),
+							sender,
+							IfDisconnected::ImmediateError,
+						);
+						assert!(response_receiver.is_none());
+						response_receiver = Some(receiver);
+					},
+					SwarmEvent::Behaviour(Event::RequestFinished { result, .. }) => {
+						result.unwrap();
+						break
+					},
+					_ => {},
+				}
+			}
+
+			assert_eq!(response_receiver.unwrap().await.unwrap().unwrap(), b"this is a response");
+		});
+	}
+
+	#[test]
+	fn max_response_size_exceeded() {
+		let protocol_name = "/test/req-resp/1";
+		let mut pool = LocalPool::new();
+
+		// Build swarms whose behaviour is [`RequestResponsesBehaviour`].
+		let mut swarms = (0..2)
+			.map(|_| {
+				let (tx, mut rx) = async_channel::bounded::<IncomingRequest>(64);
+
+				pool.spawner()
+					.spawn_obj(
+						async move {
+							while let Some(rq) = rx.next().await {
+								assert_eq!(rq.payload, b"this is a request");
+								let _ = rq.pending_response.send(super::OutgoingResponse {
+									result: Ok(b"this response exceeds the limit".to_vec()),
+									reputation_changes: Vec::new(),
+									sent_feedback: None,
+								});
+							}
+						}
+						.boxed()
+						.into(),
+					)
+					.unwrap();
+
+				let protocol_config = ProtocolConfig {
+					name: From::from(protocol_name),
+					fallback_names: Vec::new(),
+					max_request_size: 1024,
+					max_response_size: 8, // <-- important for the test
+					request_timeout: Duration::from_secs(30),
+					inbound_queue: Some(tx),
+				};
+
+				build_swarm(iter::once(protocol_config))
+			})
+			.collect::<Vec<_>>();
+
+		// Ask `swarm[0]` to dial `swarm[1]`. There isn't any discovery mechanism in place in
+		// this test, so they wouldn't connect to each other.
+		{
+			let dial_addr = swarms[1].1.clone();
+			Swarm::dial(&mut swarms[0].0, dial_addr).unwrap();
+		}
+
+		// Running `swarm[0]` in the background until a `InboundRequest` event happens,
+		// which is a hint about the test having ended.
+		let (mut swarm, _) = swarms.remove(0);
+		pool.spawner()
+			.spawn_obj({
+				async move {
+					loop {
+						match swarm.select_next_some().await {
+							SwarmEvent::Behaviour(Event::InboundRequest { result, .. }) => {
+								assert!(result.is_ok());
+								break
+							},
+							_ => {},
+						}
+					}
+				}
+				.boxed()
+				.into()
+			})
+			.unwrap();
+
+		// Remove and run the remaining swarm.
+		let (mut swarm, _) = swarms.remove(0);
+		pool.run_until(async move {
+			let mut response_receiver = None;
+
+			loop {
+				match swarm.select_next_some().await {
+					SwarmEvent::ConnectionEstablished { peer_id, .. } => {
+						let (sender, receiver) = oneshot::channel();
+						swarm.behaviour_mut().send_request(
+							&peer_id,
+							protocol_name,
+							b"this is a request".to_vec(),
+							sender,
+							IfDisconnected::ImmediateError,
+						);
+						assert!(response_receiver.is_none());
+						response_receiver = Some(receiver);
+					},
+					SwarmEvent::Behaviour(Event::RequestFinished { result, .. }) => {
+						assert!(result.is_err());
+						break
+					},
+					_ => {},
+				}
+			}
+
+			match response_receiver.unwrap().await.unwrap().unwrap_err() {
+				RequestFailure::Network(OutboundFailure::ConnectionClosed) => {},
+				_ => panic!(),
+			}
+		});
+	}
+
+	/// A [`RequestId`] is a unique identifier among either all inbound or all outbound requests for
+	/// a single [`RequestResponsesBehaviour`] behaviour. It is not guaranteed to be unique across
+	/// multiple [`RequestResponsesBehaviour`] behaviours. Thus when handling [`RequestId`] in the
+	/// context of multiple [`RequestResponsesBehaviour`] behaviours, one needs to couple the
+	/// protocol name with the [`RequestId`] to get a unique request identifier.
+	///
+	/// This test ensures that two requests on different protocols can be handled concurrently
+	/// without a [`RequestId`] collision.
+	///
+	/// See [`ProtocolRequestId`] for additional information.
+	#[test]
+	fn request_id_collision() {
+		let protocol_name_1 = "/test/req-resp-1/1";
+		let protocol_name_2 = "/test/req-resp-2/1";
+		let mut pool = LocalPool::new();
+
+		let mut swarm_1 = {
+			let protocol_configs = vec![
+				ProtocolConfig {
+					name: From::from(protocol_name_1),
+					fallback_names: Vec::new(),
+					max_request_size: 1024,
+					max_response_size: 1024 * 1024,
+					request_timeout: Duration::from_secs(30),
+					inbound_queue: None,
+				},
+				ProtocolConfig {
+					name: From::from(protocol_name_2),
+					fallback_names: Vec::new(),
+					max_request_size: 1024,
+					max_response_size: 1024 * 1024,
+					request_timeout: Duration::from_secs(30),
+					inbound_queue: None,
+				},
+			];
+
+			build_swarm(protocol_configs.into_iter()).0
+		};
+
+		let (mut swarm_2, mut swarm_2_handler_1, mut swarm_2_handler_2, listen_add_2) = {
+			let (tx_1, rx_1) = async_channel::bounded(64);
+			let (tx_2, rx_2) = async_channel::bounded(64);
+
+			let protocol_configs = vec![
+				ProtocolConfig {
+					name: From::from(protocol_name_1),
+					fallback_names: Vec::new(),
+					max_request_size: 1024,
+					max_response_size: 1024 * 1024,
+					request_timeout: Duration::from_secs(30),
+					inbound_queue: Some(tx_1),
+				},
+				ProtocolConfig {
+					name: From::from(protocol_name_2),
+					fallback_names: Vec::new(),
+					max_request_size: 1024,
+					max_response_size: 1024 * 1024,
+					request_timeout: Duration::from_secs(30),
+					inbound_queue: Some(tx_2),
+				},
+			];
+
+			let (swarm, listen_addr) = build_swarm(protocol_configs.into_iter());
+
+			(swarm, rx_1, rx_2, listen_addr)
+		};
+
+		// Ask swarm 1 to dial swarm 2. There isn't any discovery mechanism in place in this test,
+		// so they wouldn't connect to each other.
+		swarm_1.dial(listen_add_2).unwrap();
+
+		// Run swarm 2 in the background, receiving two requests.
+		pool.spawner()
+			.spawn_obj(
+				async move {
+					loop {
+						match swarm_2.select_next_some().await {
+							SwarmEvent::Behaviour(Event::InboundRequest { result, .. }) => {
+								result.unwrap();
+							},
+							_ => {},
+						}
+					}
+				}
+				.boxed()
+				.into(),
+			)
+			.unwrap();
+
+		// Handle both requests sent by swarm 1 to swarm 2 in the background.
+		//
+		// Make sure both requests overlap, by answering the first only after receiving the
+		// second.
+		pool.spawner()
+			.spawn_obj(
+				async move {
+					let protocol_1_request = swarm_2_handler_1.next().await;
+					let protocol_2_request = swarm_2_handler_2.next().await;
+
+					protocol_1_request
+						.unwrap()
+						.pending_response
+						.send(OutgoingResponse {
+							result: Ok(b"this is a response".to_vec()),
+							reputation_changes: Vec::new(),
+							sent_feedback: None,
+						})
+						.unwrap();
+					protocol_2_request
+						.unwrap()
+						.pending_response
+						.send(OutgoingResponse {
+							result: Ok(b"this is a response".to_vec()),
+							reputation_changes: Vec::new(),
+							sent_feedback: None,
+						})
+						.unwrap();
+				}
+				.boxed()
+				.into(),
+			)
+			.unwrap();
+
+		// Have swarm 1 send two requests to swarm 2 and await responses.
+		pool.run_until(async move {
+			let mut response_receivers = None;
+			let mut num_responses = 0;
+
+			loop {
+				match swarm_1.select_next_some().await {
+					SwarmEvent::ConnectionEstablished { peer_id, .. } => {
+						let (sender_1, receiver_1) = oneshot::channel();
+						let (sender_2, receiver_2) = oneshot::channel();
+						swarm_1.behaviour_mut().send_request(
+							&peer_id,
+							protocol_name_1,
+							b"this is a request".to_vec(),
+							sender_1,
+							IfDisconnected::ImmediateError,
+						);
+						swarm_1.behaviour_mut().send_request(
+							&peer_id,
+							protocol_name_2,
+							b"this is a request".to_vec(),
+							sender_2,
+							IfDisconnected::ImmediateError,
+						);
+						assert!(response_receivers.is_none());
+						response_receivers = Some((receiver_1, receiver_2));
+					},
+					SwarmEvent::Behaviour(Event::RequestFinished { result, .. }) => {
+						num_responses += 1;
+						result.unwrap();
+						if num_responses == 2 {
+							break
+						}
+					},
+					_ => {},
+				}
+			}
+			let (response_receiver_1, response_receiver_2) = response_receivers.unwrap();
+			assert_eq!(response_receiver_1.await.unwrap().unwrap(), b"this is a response");
+			assert_eq!(response_receiver_2.await.unwrap().unwrap(), b"this is a response");
+		});
+	}
+}
diff --git a/substrate/client/network/src/service.rs b/substrate/client/network/src/service.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aca0072a31de6425d0658e6d540c2500407814e4
--- /dev/null
+++ b/substrate/client/network/src/service.rs
@@ -0,0 +1,1831 @@
+// 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/>.
+
+//! Main entry point of the sc-network crate.
+//!
+//! There are two main structs in this module: [`NetworkWorker`] and [`NetworkService`].
+//! The [`NetworkWorker`] *is* the network. Network is driven by [`NetworkWorker::run`] future that
+//! terminates only when all instances of the control handles [`NetworkService`] were dropped.
+//! The [`NetworkService`] is merely a shared version of the [`NetworkWorker`]. You can obtain an
+//! `Arc<NetworkService>` by calling [`NetworkWorker::service`].
+//!
+//! The methods of the [`NetworkService`] are implemented by sending a message over a channel,
+//! which is then processed by [`NetworkWorker::next_action`].
+
+use crate::{
+	behaviour::{self, Behaviour, BehaviourOut},
+	config::{parse_addr, FullNetworkConfiguration, MultiaddrWithPeerId, Params, TransportConfig},
+	discovery::DiscoveryConfig,
+	error::Error,
+	event::{DhtEvent, Event},
+	network_state::{
+		NetworkState, NotConnectedPeer as NetworkStateNotConnectedPeer, Peer as NetworkStatePeer,
+	},
+	peer_store::{PeerStoreHandle, PeerStoreProvider},
+	protocol::{self, NotifsHandlerError, Protocol, Ready},
+	protocol_controller::{self, ProtoSetConfig, ProtocolController, SetId},
+	request_responses::{IfDisconnected, RequestFailure},
+	service::{
+		signature::{Signature, SigningError},
+		traits::{
+			NetworkDHTProvider, NetworkEventStream, NetworkNotification, NetworkPeers,
+			NetworkRequest, NetworkSigner, NetworkStateInfo, NetworkStatus, NetworkStatusProvider,
+			NotificationSender as NotificationSenderT, NotificationSenderError,
+			NotificationSenderReady as NotificationSenderReadyT,
+		},
+	},
+	transport,
+	types::ProtocolName,
+	ReputationChange,
+};
+
+use either::Either;
+use futures::{channel::oneshot, prelude::*};
+#[allow(deprecated)]
+use libp2p::{
+	connection_limits::Exceeded,
+	core::{upgrade, ConnectedPoint, Endpoint},
+	identify::Info as IdentifyInfo,
+	kad::record::Key as KademliaKey,
+	multiaddr,
+	ping::Failure as PingFailure,
+	swarm::{
+		AddressScore, ConnectionError, ConnectionId, ConnectionLimits, DialError, Executor,
+		ListenError, NetworkBehaviour, Swarm, SwarmBuilder, SwarmEvent, THandlerErr,
+	},
+	Multiaddr, PeerId,
+};
+use log::{debug, error, info, trace, warn};
+use metrics::{Histogram, HistogramVec, MetricSources, Metrics};
+use parking_lot::Mutex;
+
+use sc_network_common::ExHashT;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_runtime::traits::Block as BlockT;
+
+use std::{
+	cmp,
+	collections::{HashMap, HashSet},
+	fs, iter,
+	marker::PhantomData,
+	num::NonZeroUsize,
+	pin::Pin,
+	str,
+	sync::{
+		atomic::{AtomicUsize, Ordering},
+		Arc,
+	},
+};
+
+pub use behaviour::{InboundFailure, OutboundFailure, ResponseFailure};
+pub use libp2p::identity::{DecodingError, Keypair, PublicKey};
+pub use protocol::NotificationsSink;
+
+mod metrics;
+mod out_events;
+
+pub mod signature;
+pub mod traits;
+
+/// Substrate network service. Handles network IO and manages connectivity.
+pub struct NetworkService<B: BlockT + 'static, H: ExHashT> {
+	/// Number of peers we're connected to.
+	num_connected: Arc<AtomicUsize>,
+	/// The local external addresses.
+	external_addresses: Arc<Mutex<HashSet<Multiaddr>>>,
+	/// Listen addresses. Do **NOT** include a trailing `/p2p/` with our `PeerId`.
+	listen_addresses: Arc<Mutex<HashSet<Multiaddr>>>,
+	/// Local copy of the `PeerId` of the local node.
+	local_peer_id: PeerId,
+	/// The `KeyPair` that defines the `PeerId` of the local node.
+	local_identity: Keypair,
+	/// Bandwidth logging system. Can be queried to know the average bandwidth consumed.
+	bandwidth: Arc<transport::BandwidthSinks>,
+	/// Channel that sends messages to the actual worker.
+	to_worker: TracingUnboundedSender<ServiceToWorkerMsg>,
+	/// For each peer and protocol combination, an object that allows sending notifications to
+	/// that peer. Updated by the [`NetworkWorker`].
+	peers_notifications_sinks: Arc<Mutex<HashMap<(PeerId, ProtocolName), NotificationsSink>>>,
+	/// Field extracted from the [`Metrics`] struct and necessary to report the
+	/// notifications-related metrics.
+	notifications_sizes_metric: Option<HistogramVec>,
+	/// Protocol name -> `SetId` mapping for notification protocols. The map never changes after
+	/// initialization.
+	notification_protocol_ids: HashMap<ProtocolName, SetId>,
+	/// Handles to manage peer connections on notification protocols. The vector never changes
+	/// after initialization.
+	protocol_handles: Vec<protocol_controller::ProtocolHandle>,
+	/// Shortcut to sync protocol handle (`protocol_handles[0]`).
+	sync_protocol_handle: protocol_controller::ProtocolHandle,
+	/// Marker to pin the `H` generic. Serves no purpose except to not break backwards
+	/// compatibility.
+	_marker: PhantomData<H>,
+	/// Marker for block type
+	_block: PhantomData<B>,
+}
+
+impl<B, H> NetworkWorker<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	/// Creates the network service.
+	///
+	/// Returns a `NetworkWorker` that implements `Future` and must be regularly polled in order
+	/// for the network processing to advance. From it, you can extract a `NetworkService` using
+	/// `worker.service()`. The `NetworkService` can be shared through the codebase.
+	pub fn new(params: Params<B>) -> Result<Self, Error> {
+		let FullNetworkConfiguration {
+			notification_protocols,
+			request_response_protocols,
+			mut network_config,
+		} = params.network_config;
+
+		// Private and public keys configuration.
+		let local_identity = network_config.node_key.clone().into_keypair()?;
+		let local_public = local_identity.public();
+		let local_peer_id = local_public.to_peer_id();
+
+		network_config.boot_nodes = network_config
+			.boot_nodes
+			.into_iter()
+			.filter(|boot_node| boot_node.peer_id != local_peer_id)
+			.collect();
+		network_config.default_peers_set.reserved_nodes = network_config
+			.default_peers_set
+			.reserved_nodes
+			.into_iter()
+			.filter(|reserved_node| {
+				if reserved_node.peer_id == local_peer_id {
+					warn!(
+						target: "sub-libp2p",
+						"Local peer ID used in reserved node, ignoring: {}",
+						reserved_node,
+					);
+					false
+				} else {
+					true
+				}
+			})
+			.collect();
+
+		// Ensure the listen addresses are consistent with the transport.
+		ensure_addresses_consistent_with_transport(
+			network_config.listen_addresses.iter(),
+			&network_config.transport,
+		)?;
+		ensure_addresses_consistent_with_transport(
+			network_config.boot_nodes.iter().map(|x| &x.multiaddr),
+			&network_config.transport,
+		)?;
+		ensure_addresses_consistent_with_transport(
+			network_config.default_peers_set.reserved_nodes.iter().map(|x| &x.multiaddr),
+			&network_config.transport,
+		)?;
+		for notification_protocol in &notification_protocols {
+			ensure_addresses_consistent_with_transport(
+				notification_protocol.set_config.reserved_nodes.iter().map(|x| &x.multiaddr),
+				&network_config.transport,
+			)?;
+		}
+		ensure_addresses_consistent_with_transport(
+			network_config.public_addresses.iter(),
+			&network_config.transport,
+		)?;
+
+		let (to_worker, from_service) = tracing_unbounded("mpsc_network_worker", 100_000);
+
+		if let Some(path) = &network_config.net_config_path {
+			fs::create_dir_all(path)?;
+		}
+
+		info!(
+			target: "sub-libp2p",
+			"�  Local node identity is: {}",
+			local_peer_id.to_base58(),
+		);
+
+		let (transport, bandwidth) = {
+			let config_mem = match network_config.transport {
+				TransportConfig::MemoryOnly => true,
+				TransportConfig::Normal { .. } => false,
+			};
+
+			// The yamux buffer size limit is configured to be equal to the maximum frame size
+			// of all protocols. 10 bytes are added to each limit for the length prefix that
+			// is not included in the upper layer protocols limit but is still present in the
+			// yamux buffer. These 10 bytes correspond to the maximum size required to encode
+			// a variable-length-encoding 64bits number. In other words, we make the
+			// assumption that no notification larger than 2^64 will ever be sent.
+			let yamux_maximum_buffer_size = {
+				let requests_max = request_response_protocols
+					.iter()
+					.map(|cfg| usize::try_from(cfg.max_request_size).unwrap_or(usize::MAX));
+				let responses_max = request_response_protocols
+					.iter()
+					.map(|cfg| usize::try_from(cfg.max_response_size).unwrap_or(usize::MAX));
+				let notifs_max = notification_protocols
+					.iter()
+					.map(|cfg| usize::try_from(cfg.max_notification_size).unwrap_or(usize::MAX));
+
+				// A "default" max is added to cover all the other protocols: ping, identify,
+				// kademlia, block announces, and transactions.
+				let default_max = cmp::max(
+					1024 * 1024,
+					usize::try_from(protocol::BLOCK_ANNOUNCES_TRANSACTIONS_SUBSTREAM_SIZE)
+						.unwrap_or(usize::MAX),
+				);
+
+				iter::once(default_max)
+					.chain(requests_max)
+					.chain(responses_max)
+					.chain(notifs_max)
+					.max()
+					.expect("iterator known to always yield at least one element; qed")
+					.saturating_add(10)
+			};
+
+			transport::build_transport(
+				local_identity.clone(),
+				config_mem,
+				network_config.yamux_window_size,
+				yamux_maximum_buffer_size,
+			)
+		};
+
+		let (to_notifications, from_protocol_controllers) =
+			tracing_unbounded("mpsc_protocol_controllers_to_notifications", 10_000);
+
+		// We must prepend a hardcoded default peer set to notification protocols.
+		let all_peer_sets_iter = iter::once(&network_config.default_peers_set)
+			.chain(notification_protocols.iter().map(|protocol| &protocol.set_config));
+
+		let (protocol_handles, protocol_controllers): (Vec<_>, Vec<_>) = all_peer_sets_iter
+			.enumerate()
+			.map(|(set_id, set_config)| {
+				let proto_set_config = ProtoSetConfig {
+					in_peers: set_config.in_peers,
+					out_peers: set_config.out_peers,
+					reserved_nodes: set_config
+						.reserved_nodes
+						.iter()
+						.map(|node| node.peer_id)
+						.collect(),
+					reserved_only: set_config.non_reserved_mode.is_reserved_only(),
+				};
+
+				ProtocolController::new(
+					SetId::from(set_id),
+					proto_set_config,
+					to_notifications.clone(),
+					Box::new(params.peer_store.clone()),
+				)
+			})
+			.unzip();
+
+		// Shortcut to default (sync) peer set protocol handle.
+		let sync_protocol_handle = protocol_handles[0].clone();
+
+		// Spawn `ProtocolController` runners.
+		protocol_controllers
+			.into_iter()
+			.for_each(|controller| (params.executor)(controller.run().boxed()));
+
+		// Protocol name to protocol id mapping. The first protocol is always block announce (sync)
+		// protocol, aka default (hardcoded) peer set.
+		let notification_protocol_ids: HashMap<ProtocolName, SetId> =
+			iter::once(&params.block_announce_config)
+				.chain(notification_protocols.iter())
+				.enumerate()
+				.map(|(index, protocol)| {
+					(protocol.notifications_protocol.clone(), SetId::from(index))
+				})
+				.collect();
+
+		let protocol = Protocol::new(
+			From::from(&params.role),
+			notification_protocols.clone(),
+			params.block_announce_config,
+			params.peer_store.clone(),
+			protocol_handles.clone(),
+			from_protocol_controllers,
+			params.tx,
+		)?;
+
+		let known_addresses = {
+			// Collect all reserved nodes and bootnodes addresses.
+			let mut addresses: Vec<_> = network_config
+				.default_peers_set
+				.reserved_nodes
+				.iter()
+				.map(|reserved| (reserved.peer_id, reserved.multiaddr.clone()))
+				.chain(notification_protocols.iter().flat_map(|protocol| {
+					protocol
+						.set_config
+						.reserved_nodes
+						.iter()
+						.map(|reserved| (reserved.peer_id, reserved.multiaddr.clone()))
+				}))
+				.chain(
+					network_config
+						.boot_nodes
+						.iter()
+						.map(|bootnode| (bootnode.peer_id, bootnode.multiaddr.clone())),
+				)
+				.collect();
+
+			// Remove possible duplicates.
+			addresses.sort();
+			addresses.dedup();
+
+			addresses
+		};
+
+		// Check for duplicate bootnodes.
+		network_config.boot_nodes.iter().try_for_each(|bootnode| {
+			if let Some(other) = network_config
+				.boot_nodes
+				.iter()
+				.filter(|o| o.multiaddr == bootnode.multiaddr)
+				.find(|o| o.peer_id != bootnode.peer_id)
+			{
+				Err(Error::DuplicateBootnode {
+					address: bootnode.multiaddr.clone(),
+					first_id: bootnode.peer_id,
+					second_id: other.peer_id,
+				})
+			} else {
+				Ok(())
+			}
+		})?;
+
+		// List of bootnode multiaddresses.
+		let mut boot_node_ids = HashMap::<PeerId, Vec<Multiaddr>>::new();
+
+		for bootnode in network_config.boot_nodes.iter() {
+			boot_node_ids
+				.entry(bootnode.peer_id)
+				.or_default()
+				.push(bootnode.multiaddr.clone());
+		}
+
+		let boot_node_ids = Arc::new(boot_node_ids);
+
+		let num_connected = Arc::new(AtomicUsize::new(0));
+		let external_addresses = Arc::new(Mutex::new(HashSet::new()));
+
+		// Build the swarm.
+		let (mut swarm, bandwidth): (Swarm<Behaviour<B>>, _) = {
+			let user_agent =
+				format!("{} ({})", network_config.client_version, network_config.node_name);
+
+			let discovery_config = {
+				let mut config = DiscoveryConfig::new(local_public.to_peer_id());
+				config.with_permanent_addresses(known_addresses);
+				config.discovery_limit(u64::from(network_config.default_peers_set.out_peers) + 15);
+				config.with_kademlia(
+					params.genesis_hash,
+					params.fork_id.as_deref(),
+					&params.protocol_id,
+				);
+				config.with_dht_random_walk(network_config.enable_dht_random_walk);
+				config.allow_non_globals_in_dht(network_config.allow_non_globals_in_dht);
+				config.use_kademlia_disjoint_query_paths(
+					network_config.kademlia_disjoint_query_paths,
+				);
+				config.with_kademlia_replication_factor(network_config.kademlia_replication_factor);
+
+				match network_config.transport {
+					TransportConfig::MemoryOnly => {
+						config.with_mdns(false);
+						config.allow_private_ip(false);
+					},
+					TransportConfig::Normal {
+						enable_mdns,
+						allow_private_ip: allow_private_ipv4,
+						..
+					} => {
+						config.with_mdns(enable_mdns);
+						config.allow_private_ip(allow_private_ipv4);
+					},
+				}
+
+				config
+			};
+
+			let behaviour = {
+				let result = Behaviour::new(
+					protocol,
+					user_agent,
+					local_public,
+					discovery_config,
+					request_response_protocols,
+					params.peer_store.clone(),
+					external_addresses.clone(),
+				);
+
+				match result {
+					Ok(b) => b,
+					Err(crate::request_responses::RegisterError::DuplicateProtocol(proto)) =>
+						return Err(Error::DuplicateRequestResponseProtocol { protocol: proto }),
+				}
+			};
+
+			let builder = {
+				struct SpawnImpl<F>(F);
+				impl<F: Fn(Pin<Box<dyn Future<Output = ()> + Send>>)> Executor for SpawnImpl<F> {
+					fn exec(&self, f: Pin<Box<dyn Future<Output = ()> + Send>>) {
+						(self.0)(f)
+					}
+				}
+				SwarmBuilder::with_executor(
+					transport,
+					behaviour,
+					local_peer_id,
+					SpawnImpl(params.executor),
+				)
+			};
+			#[allow(deprecated)]
+			let builder = builder
+				.connection_limits(
+					ConnectionLimits::default()
+						.with_max_established_per_peer(Some(crate::MAX_CONNECTIONS_PER_PEER as u32))
+						.with_max_established_incoming(Some(
+							crate::MAX_CONNECTIONS_ESTABLISHED_INCOMING,
+						)),
+				)
+				.substream_upgrade_protocol_override(upgrade::Version::V1Lazy)
+				.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>
+				.per_connection_event_buffer_size(24)
+				.max_negotiating_inbound_streams(2048);
+
+			(builder.build(), bandwidth)
+		};
+
+		// Initialize the metrics.
+		let metrics = match &params.metrics_registry {
+			Some(registry) => Some(metrics::register(
+				registry,
+				MetricSources {
+					bandwidth: bandwidth.clone(),
+					connected_peers: num_connected.clone(),
+				},
+			)?),
+			None => None,
+		};
+
+		// Listen on multiaddresses.
+		for addr in &network_config.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 {
+			Swarm::<Behaviour<B>>::add_external_address(
+				&mut swarm,
+				addr.clone(),
+				AddressScore::Infinite,
+			);
+		}
+
+		let listen_addresses = Arc::new(Mutex::new(HashSet::new()));
+		let peers_notifications_sinks = Arc::new(Mutex::new(HashMap::new()));
+
+		let service = Arc::new(NetworkService {
+			bandwidth,
+			external_addresses,
+			listen_addresses: listen_addresses.clone(),
+			num_connected: num_connected.clone(),
+			local_peer_id,
+			local_identity,
+			to_worker,
+			peers_notifications_sinks: peers_notifications_sinks.clone(),
+			notifications_sizes_metric: metrics
+				.as_ref()
+				.map(|metrics| metrics.notifications_sizes.clone()),
+			notification_protocol_ids,
+			protocol_handles,
+			sync_protocol_handle,
+			_marker: PhantomData,
+			_block: Default::default(),
+		});
+
+		Ok(NetworkWorker {
+			listen_addresses,
+			num_connected,
+			network_service: swarm,
+			service,
+			from_service,
+			event_streams: out_events::OutChannels::new(params.metrics_registry.as_ref())?,
+			metrics,
+			boot_node_ids,
+			reported_invalid_boot_nodes: Default::default(),
+			peers_notifications_sinks,
+			peer_store_handle: params.peer_store,
+			_marker: Default::default(),
+			_block: Default::default(),
+		})
+	}
+
+	/// High-level network status information.
+	pub fn status(&self) -> NetworkStatus {
+		NetworkStatus {
+			num_connected_peers: self.num_connected_peers(),
+			total_bytes_inbound: self.total_bytes_inbound(),
+			total_bytes_outbound: self.total_bytes_outbound(),
+		}
+	}
+
+	/// Returns the total number of bytes received so far.
+	pub fn total_bytes_inbound(&self) -> u64 {
+		self.service.bandwidth.total_inbound()
+	}
+
+	/// Returns the total number of bytes sent so far.
+	pub fn total_bytes_outbound(&self) -> u64 {
+		self.service.bandwidth.total_outbound()
+	}
+
+	/// Returns the number of peers we're connected to.
+	pub fn num_connected_peers(&self) -> usize {
+		self.network_service.behaviour().user_protocol().num_connected_peers()
+	}
+
+	/// Adds an address for a node.
+	pub fn add_known_address(&mut self, peer_id: PeerId, addr: Multiaddr) {
+		self.network_service.behaviour_mut().add_known_address(peer_id, addr);
+	}
+
+	/// Return a `NetworkService` that can be shared through the code base and can be used to
+	/// manipulate the worker.
+	pub fn service(&self) -> &Arc<NetworkService<B, H>> {
+		&self.service
+	}
+
+	/// Returns the local `PeerId`.
+	pub fn local_peer_id(&self) -> &PeerId {
+		Swarm::<Behaviour<B>>::local_peer_id(&self.network_service)
+	}
+
+	/// Returns the list of addresses we are listening on.
+	///
+	/// Does **NOT** include a trailing `/p2p/` with our `PeerId`.
+	pub fn listen_addresses(&self) -> impl Iterator<Item = &Multiaddr> {
+		Swarm::<Behaviour<B>>::listeners(&self.network_service)
+	}
+
+	/// Get network state.
+	///
+	/// **Note**: Use this only for debugging. This API is unstable. There are warnings literally
+	/// everywhere about this. Please don't use this function to retrieve actual information.
+	pub fn network_state(&mut self) -> NetworkState {
+		let swarm = &mut self.network_service;
+		let open = swarm.behaviour_mut().user_protocol().open_peers().cloned().collect::<Vec<_>>();
+		let connected_peers = {
+			let swarm = &mut *swarm;
+			open.iter()
+				.filter_map(move |peer_id| {
+					let known_addresses = if let Ok(addrs) =
+						NetworkBehaviour::handle_pending_outbound_connection(
+							swarm.behaviour_mut(),
+							ConnectionId::new_unchecked(0), // dummy value
+							Some(*peer_id),
+							&vec![],
+							Endpoint::Listener,
+						) {
+						addrs.into_iter().collect()
+					} else {
+						error!(target: "sub-libp2p", "Was not able to get known addresses for {:?}", peer_id);
+						return None
+					};
+
+					let endpoint = if let Some(e) =
+						swarm.behaviour_mut().node(peer_id).and_then(|i| i.endpoint())
+					{
+						e.clone().into()
+					} else {
+						error!(target: "sub-libp2p", "Found state inconsistency between custom protocol \
+						and debug information about {:?}", peer_id);
+						return None
+					};
+
+					Some((
+						peer_id.to_base58(),
+						NetworkStatePeer {
+							endpoint,
+							version_string: swarm
+								.behaviour_mut()
+								.node(peer_id)
+								.and_then(|i| i.client_version().map(|s| s.to_owned())),
+							latest_ping_time: swarm
+								.behaviour_mut()
+								.node(peer_id)
+								.and_then(|i| i.latest_ping()),
+							known_addresses,
+						},
+					))
+				})
+				.collect()
+		};
+
+		let not_connected_peers = {
+			let swarm = &mut *swarm;
+			swarm
+				.behaviour_mut()
+				.known_peers()
+				.into_iter()
+				.filter(|p| open.iter().all(|n| n != p))
+				.map(move |peer_id| {
+					let known_addresses = if let Ok(addrs) =
+						NetworkBehaviour::handle_pending_outbound_connection(
+							swarm.behaviour_mut(),
+							ConnectionId::new_unchecked(0), // dummy value
+							Some(peer_id),
+							&vec![],
+							Endpoint::Listener,
+						) {
+						addrs.into_iter().collect()
+					} else {
+						error!(target: "sub-libp2p", "Was not able to get known addresses for {:?}", peer_id);
+						Default::default()
+					};
+
+					(
+						peer_id.to_base58(),
+						NetworkStateNotConnectedPeer {
+							version_string: swarm
+								.behaviour_mut()
+								.node(&peer_id)
+								.and_then(|i| i.client_version().map(|s| s.to_owned())),
+							latest_ping_time: swarm
+								.behaviour_mut()
+								.node(&peer_id)
+								.and_then(|i| i.latest_ping()),
+							known_addresses,
+						},
+					)
+				})
+				.collect()
+		};
+
+		let peer_id = Swarm::<Behaviour<B>>::local_peer_id(swarm).to_base58();
+		let listened_addresses = swarm.listeners().cloned().collect();
+		let external_addresses = swarm.external_addresses().map(|r| &r.addr).cloned().collect();
+
+		NetworkState {
+			peer_id,
+			listened_addresses,
+			external_addresses,
+			connected_peers,
+			not_connected_peers,
+			// TODO: Check what info we can include here.
+			//       Issue reference: https://github.com/paritytech/substrate/issues/14160.
+			peerset: serde_json::json!(
+				"Unimplemented. See https://github.com/paritytech/substrate/issues/14160."
+			),
+		}
+	}
+
+	/// Removes a `PeerId` from the list of reserved peers.
+	pub fn remove_reserved_peer(&self, peer: PeerId) {
+		self.service.remove_reserved_peer(peer);
+	}
+
+	/// Adds a `PeerId` and its `Multiaddr` as reserved.
+	pub fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String> {
+		self.service.add_reserved_peer(peer)
+	}
+}
+
+impl<B: BlockT + 'static, H: ExHashT> NetworkService<B, H> {
+	/// Get network state.
+	///
+	/// **Note**: Use this only for debugging. This API is unstable. There are warnings literally
+	/// everywhere about this. Please don't use this function to retrieve actual information.
+	///
+	/// Returns an error if the `NetworkWorker` is no longer running.
+	pub async fn network_state(&self) -> Result<NetworkState, ()> {
+		let (tx, rx) = oneshot::channel();
+
+		let _ = self
+			.to_worker
+			.unbounded_send(ServiceToWorkerMsg::NetworkState { pending_response: tx });
+
+		match rx.await {
+			Ok(v) => v.map_err(|_| ()),
+			// The channel can only be closed if the network worker no longer exists.
+			Err(_) => Err(()),
+		}
+	}
+
+	/// Get the list of reserved peers.
+	///
+	/// Returns an error if the `NetworkWorker` is no longer running.
+	pub async fn reserved_peers(&self) -> Result<Vec<PeerId>, ()> {
+		let (tx, rx) = oneshot::channel();
+
+		self.sync_protocol_handle.reserved_peers(tx);
+
+		// The channel can only be closed if `ProtocolController` no longer exists.
+		rx.await.map_err(|_| ())
+	}
+
+	/// Utility function to extract `PeerId` from each `Multiaddr` for peer set updates.
+	///
+	/// Returns an `Err` if one of the given addresses is invalid or contains an
+	/// invalid peer ID (which includes the local peer ID).
+	fn split_multiaddr_and_peer_id(
+		&self,
+		peers: HashSet<Multiaddr>,
+	) -> Result<Vec<(PeerId, Multiaddr)>, String> {
+		peers
+			.into_iter()
+			.map(|mut addr| {
+				let peer = match addr.pop() {
+					Some(multiaddr::Protocol::P2p(key)) => PeerId::from_multihash(key)
+						.map_err(|_| "Invalid PeerId format".to_string())?,
+					_ => return Err("Missing PeerId from address".to_string()),
+				};
+
+				// Make sure the local peer ID is never added to the PSM
+				// or added as a "known address", even if given.
+				if peer == self.local_peer_id {
+					Err("Local peer ID in peer set.".to_string())
+				} else {
+					Ok((peer, addr))
+				}
+			})
+			.collect::<Result<Vec<(PeerId, Multiaddr)>, String>>()
+	}
+}
+
+impl<B, H> NetworkStateInfo for NetworkService<B, H>
+where
+	B: sp_runtime::traits::Block,
+	H: ExHashT,
+{
+	/// Returns the local external addresses.
+	fn external_addresses(&self) -> Vec<Multiaddr> {
+		self.external_addresses.lock().iter().cloned().collect()
+	}
+
+	/// Returns the listener addresses (without trailing `/p2p/` with our `PeerId`).
+	fn listen_addresses(&self) -> Vec<Multiaddr> {
+		self.listen_addresses.lock().iter().cloned().collect()
+	}
+
+	/// Returns the local Peer ID.
+	fn local_peer_id(&self) -> PeerId {
+		self.local_peer_id
+	}
+}
+
+impl<B, H> NetworkSigner for NetworkService<B, H>
+where
+	B: sp_runtime::traits::Block,
+	H: ExHashT,
+{
+	fn sign_with_local_identity(&self, msg: impl AsRef<[u8]>) -> Result<Signature, SigningError> {
+		Signature::sign_message(msg.as_ref(), &self.local_identity)
+	}
+}
+
+impl<B, H> NetworkDHTProvider for NetworkService<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	/// Start getting a value from the DHT.
+	///
+	/// This will generate either a `ValueFound` or a `ValueNotFound` event and pass it as an
+	/// item on the [`NetworkWorker`] stream.
+	fn get_value(&self, key: &KademliaKey) {
+		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::GetValue(key.clone()));
+	}
+
+	/// Start putting a value in the DHT.
+	///
+	/// This will generate either a `ValuePut` or a `ValuePutFailed` event and pass it as an
+	/// item on the [`NetworkWorker`] stream.
+	fn put_value(&self, key: KademliaKey, value: Vec<u8>) {
+		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::PutValue(key, value));
+	}
+}
+
+#[async_trait::async_trait]
+impl<B, H> NetworkStatusProvider for NetworkService<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	async fn status(&self) -> Result<NetworkStatus, ()> {
+		let (tx, rx) = oneshot::channel();
+
+		let _ = self
+			.to_worker
+			.unbounded_send(ServiceToWorkerMsg::NetworkStatus { pending_response: tx });
+
+		match rx.await {
+			Ok(v) => v.map_err(|_| ()),
+			// The channel can only be closed if the network worker no longer exists.
+			Err(_) => Err(()),
+		}
+	}
+}
+
+impl<B, H> NetworkPeers for NetworkService<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	fn set_authorized_peers(&self, peers: HashSet<PeerId>) {
+		self.sync_protocol_handle.set_reserved_peers(peers);
+	}
+
+	fn set_authorized_only(&self, reserved_only: bool) {
+		self.sync_protocol_handle.set_reserved_only(reserved_only);
+	}
+
+	fn add_known_address(&self, peer_id: PeerId, addr: Multiaddr) {
+		let _ = self
+			.to_worker
+			.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(peer_id, addr));
+	}
+
+	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
+		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::ReportPeer(who, cost_benefit));
+	}
+
+	fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName) {
+		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::DisconnectPeer(who, protocol));
+	}
+
+	fn accept_unreserved_peers(&self) {
+		self.sync_protocol_handle.set_reserved_only(false);
+	}
+
+	fn deny_unreserved_peers(&self) {
+		self.sync_protocol_handle.set_reserved_only(true);
+	}
+
+	fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String> {
+		// Make sure the local peer ID is never added as a reserved peer.
+		if peer.peer_id == self.local_peer_id {
+			return Err("Local peer ID cannot be added as a reserved peer.".to_string())
+		}
+
+		let _ = self
+			.to_worker
+			.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(peer.peer_id, peer.multiaddr));
+		self.sync_protocol_handle.add_reserved_peer(peer.peer_id);
+		Ok(())
+	}
+
+	fn remove_reserved_peer(&self, peer_id: PeerId) {
+		self.sync_protocol_handle.remove_reserved_peer(peer_id);
+	}
+
+	fn set_reserved_peers(
+		&self,
+		protocol: ProtocolName,
+		peers: HashSet<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_addrs = self.split_multiaddr_and_peer_id(peers)?;
+
+		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.
+			if peer_id == self.local_peer_id {
+				return Err("Local peer ID cannot be added as a reserved peer.".to_string())
+			}
+
+			peers.insert(peer_id);
+
+			if !addr.is_empty() {
+				let _ = self
+					.to_worker
+					.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(peer_id, addr));
+			}
+		}
+
+		self.protocol_handles[usize::from(*set_id)].set_reserved_peers(peers);
+
+		Ok(())
+	}
+
+	fn add_peers_to_reserved_set(
+		&self,
+		protocol: ProtocolName,
+		peers: HashSet<Multiaddr>,
+	) -> Result<(), String> {
+		let Some(set_id) = self.notification_protocol_ids.get(&protocol) else {
+			return Err(
+				format!("Cannot add peers to reserved set of unknown protocol: {}", protocol)
+			)
+		};
+
+		let peers = self.split_multiaddr_and_peer_id(peers)?;
+
+		for (peer_id, addr) in peers.into_iter() {
+			// Make sure the local peer ID is never added to the PSM.
+			if peer_id == self.local_peer_id {
+				return Err("Local peer ID cannot be added as a reserved peer.".to_string())
+			}
+
+			if !addr.is_empty() {
+				let _ = self
+					.to_worker
+					.unbounded_send(ServiceToWorkerMsg::AddKnownAddress(peer_id, addr));
+			}
+
+			self.protocol_handles[usize::from(*set_id)].add_reserved_peer(peer_id);
+		}
+
+		Ok(())
+	}
+
+	fn remove_peers_from_reserved_set(
+		&self,
+		protocol: ProtocolName,
+		peers: Vec<PeerId>,
+	) -> Result<(), String> {
+		let Some(set_id) = self.notification_protocol_ids.get(&protocol) else {
+			return Err(
+				format!("Cannot remove peers from reserved set of unknown protocol: {}", protocol)
+			)
+		};
+
+		for peer_id in peers.into_iter() {
+			self.protocol_handles[usize::from(*set_id)].remove_reserved_peer(peer_id);
+		}
+
+		Ok(())
+	}
+
+	fn sync_num_connected(&self) -> usize {
+		self.num_connected.load(Ordering::Relaxed)
+	}
+}
+
+impl<B, H> NetworkEventStream for NetworkService<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	fn event_stream(&self, name: &'static str) -> Pin<Box<dyn Stream<Item = Event> + Send>> {
+		let (tx, rx) = out_events::channel(name, 100_000);
+		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::EventStream(tx));
+		Box::pin(rx)
+	}
+}
+
+impl<B, H> NetworkNotification for NetworkService<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	fn write_notification(&self, target: PeerId, protocol: ProtocolName, message: Vec<u8>) {
+		// We clone the `NotificationsSink` in order to be able to unlock the network-wide
+		// `peers_notifications_sinks` mutex as soon as possible.
+		let sink = {
+			let peers_notifications_sinks = self.peers_notifications_sinks.lock();
+			if let Some(sink) = peers_notifications_sinks.get(&(target, protocol.clone())) {
+				sink.clone()
+			} else {
+				// Notification silently discarded, as documented.
+				debug!(
+					target: "sub-libp2p",
+					"Attempted to send notification on missing or closed substream: {}, {:?}",
+					target, protocol,
+				);
+				return
+			}
+		};
+
+		if let Some(notifications_sizes_metric) = self.notifications_sizes_metric.as_ref() {
+			notifications_sizes_metric
+				.with_label_values(&["out", &protocol])
+				.observe(message.len() as f64);
+		}
+
+		// Sending is communicated to the `NotificationsSink`.
+		trace!(
+			target: "sub-libp2p",
+			"External API => Notification({:?}, {:?}, {} bytes)",
+			target, protocol, message.len()
+		);
+		trace!(target: "sub-libp2p", "Handler({:?}) <= Sync notification", target);
+		sink.send_sync_notification(message);
+	}
+
+	fn notification_sender(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+	) -> Result<Box<dyn NotificationSenderT>, NotificationSenderError> {
+		// We clone the `NotificationsSink` in order to be able to unlock the network-wide
+		// `peers_notifications_sinks` mutex as soon as possible.
+		let sink = {
+			let peers_notifications_sinks = self.peers_notifications_sinks.lock();
+			if let Some(sink) = peers_notifications_sinks.get(&(target, protocol.clone())) {
+				sink.clone()
+			} else {
+				return Err(NotificationSenderError::Closed)
+			}
+		};
+
+		let notification_size_metric = self
+			.notifications_sizes_metric
+			.as_ref()
+			.map(|histogram| histogram.with_label_values(&["out", &protocol]));
+
+		Ok(Box::new(NotificationSender { sink, protocol_name: protocol, notification_size_metric }))
+	}
+
+	fn set_notification_handshake(&self, protocol: ProtocolName, handshake: Vec<u8>) {
+		let _ = self
+			.to_worker
+			.unbounded_send(ServiceToWorkerMsg::SetNotificationHandshake(protocol, handshake));
+	}
+}
+
+#[async_trait::async_trait]
+impl<B, H> NetworkRequest for NetworkService<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	async fn request(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		connect: IfDisconnected,
+	) -> Result<Vec<u8>, RequestFailure> {
+		let (tx, rx) = oneshot::channel();
+
+		self.start_request(target, protocol, request, tx, connect);
+
+		match rx.await {
+			Ok(v) => v,
+			// The channel can only be closed if the network worker no longer exists. If the
+			// network worker no longer exists, then all connections to `target` are necessarily
+			// closed, and we legitimately report this situation as a "ConnectionClosed".
+			Err(_) => Err(RequestFailure::Network(OutboundFailure::ConnectionClosed)),
+		}
+	}
+
+	fn start_request(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		tx: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		connect: IfDisconnected,
+	) {
+		let _ = self.to_worker.unbounded_send(ServiceToWorkerMsg::Request {
+			target,
+			protocol: protocol.into(),
+			request,
+			pending_response: tx,
+			connect,
+		});
+	}
+}
+
+/// A `NotificationSender` allows for sending notifications to a peer with a chosen protocol.
+#[must_use]
+pub struct NotificationSender {
+	sink: NotificationsSink,
+
+	/// Name of the protocol on the wire.
+	protocol_name: ProtocolName,
+
+	/// Field extracted from the [`Metrics`] struct and necessary to report the
+	/// notifications-related metrics.
+	notification_size_metric: Option<Histogram>,
+}
+
+#[async_trait::async_trait]
+impl NotificationSenderT for NotificationSender {
+	async fn ready(
+		&self,
+	) -> Result<Box<dyn NotificationSenderReadyT + '_>, NotificationSenderError> {
+		Ok(Box::new(NotificationSenderReady {
+			ready: match self.sink.reserve_notification().await {
+				Ok(r) => Some(r),
+				Err(()) => return Err(NotificationSenderError::Closed),
+			},
+			peer_id: self.sink.peer_id(),
+			protocol_name: &self.protocol_name,
+			notification_size_metric: self.notification_size_metric.clone(),
+		}))
+	}
+}
+
+/// Reserved slot in the notifications buffer, ready to accept data.
+#[must_use]
+pub struct NotificationSenderReady<'a> {
+	ready: Option<Ready<'a>>,
+
+	/// Target of the notification.
+	peer_id: &'a PeerId,
+
+	/// Name of the protocol on the wire.
+	protocol_name: &'a ProtocolName,
+
+	/// Field extracted from the [`Metrics`] struct and necessary to report the
+	/// notifications-related metrics.
+	notification_size_metric: Option<Histogram>,
+}
+
+impl<'a> NotificationSenderReadyT for NotificationSenderReady<'a> {
+	fn send(&mut self, notification: Vec<u8>) -> Result<(), NotificationSenderError> {
+		if let Some(notification_size_metric) = &self.notification_size_metric {
+			notification_size_metric.observe(notification.len() as f64);
+		}
+
+		trace!(
+			target: "sub-libp2p",
+			"External API => Notification({:?}, {}, {} bytes)",
+			self.peer_id, self.protocol_name, notification.len(),
+		);
+		trace!(target: "sub-libp2p", "Handler({:?}) <= Async notification", self.peer_id);
+
+		self.ready
+			.take()
+			.ok_or(NotificationSenderError::Closed)?
+			.send(notification)
+			.map_err(|()| NotificationSenderError::Closed)
+	}
+}
+
+/// Messages sent from the `NetworkService` to the `NetworkWorker`.
+///
+/// Each entry corresponds to a method of `NetworkService`.
+enum ServiceToWorkerMsg {
+	GetValue(KademliaKey),
+	PutValue(KademliaKey, Vec<u8>),
+	AddKnownAddress(PeerId, Multiaddr),
+	ReportPeer(PeerId, ReputationChange),
+	EventStream(out_events::Sender),
+	Request {
+		target: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		pending_response: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		connect: IfDisconnected,
+	},
+	NetworkStatus {
+		pending_response: oneshot::Sender<Result<NetworkStatus, RequestFailure>>,
+	},
+	NetworkState {
+		pending_response: oneshot::Sender<Result<NetworkState, RequestFailure>>,
+	},
+	DisconnectPeer(PeerId, ProtocolName),
+	SetNotificationHandshake(ProtocolName, Vec<u8>),
+}
+
+/// Main network worker. Must be polled in order for the network to advance.
+///
+/// You are encouraged to poll this in a separate background thread or task.
+#[must_use = "The NetworkWorker must be polled in order for the network to advance"]
+pub struct NetworkWorker<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	/// Updated by the `NetworkWorker` and loaded by the `NetworkService`.
+	listen_addresses: Arc<Mutex<HashSet<Multiaddr>>>,
+	/// Updated by the `NetworkWorker` and loaded by the `NetworkService`.
+	num_connected: Arc<AtomicUsize>,
+	/// The network service that can be extracted and shared through the codebase.
+	service: Arc<NetworkService<B, H>>,
+	/// The *actual* network.
+	network_service: Swarm<Behaviour<B>>,
+	/// Messages from the [`NetworkService`] that must be processed.
+	from_service: TracingUnboundedReceiver<ServiceToWorkerMsg>,
+	/// Senders for events that happen on the network.
+	event_streams: out_events::OutChannels,
+	/// Prometheus network metrics.
+	metrics: Option<Metrics>,
+	/// The `PeerId`'s of all boot nodes mapped to the registered addresses.
+	boot_node_ids: Arc<HashMap<PeerId, Vec<Multiaddr>>>,
+	/// Boot nodes that we already have reported as invalid.
+	reported_invalid_boot_nodes: HashSet<PeerId>,
+	/// For each peer and protocol combination, an object that allows sending notifications to
+	/// that peer. Shared with the [`NetworkService`].
+	peers_notifications_sinks: Arc<Mutex<HashMap<(PeerId, ProtocolName), NotificationsSink>>>,
+	/// Peer reputation store handle.
+	peer_store_handle: PeerStoreHandle,
+	/// Marker to pin the `H` generic. Serves no purpose except to not break backwards
+	/// compatibility.
+	_marker: PhantomData<H>,
+	/// Marker for block type
+	_block: PhantomData<B>,
+}
+
+impl<B, H> NetworkWorker<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+	/// Run the network.
+	pub async fn run(mut self) {
+		while self.next_action().await {}
+	}
+
+	/// Perform one action on the network.
+	///
+	/// Returns `false` when the worker should be shutdown.
+	/// Use in tests only.
+	pub async fn next_action(&mut self) -> bool {
+		futures::select! {
+			// Next message from the service.
+			msg = self.from_service.next() => {
+				if let Some(msg) = msg {
+					self.handle_worker_message(msg);
+				} else {
+					return false
+				}
+			},
+			// Next event from `Swarm` (the stream guaranteed to never terminate).
+			event = self.network_service.select_next_some() => {
+				self.handle_swarm_event(event);
+			},
+		};
+
+		// Update the `num_connected` count shared with the `NetworkService`.
+		let num_connected_peers =
+			self.network_service.behaviour_mut().user_protocol_mut().num_connected_peers();
+		self.num_connected.store(num_connected_peers, Ordering::Relaxed);
+
+		if let Some(metrics) = self.metrics.as_ref() {
+			if let Some(buckets) = self.network_service.behaviour_mut().num_entries_per_kbucket() {
+				for (lower_ilog2_bucket_bound, num_entries) in buckets {
+					metrics
+						.kbuckets_num_nodes
+						.with_label_values(&[&lower_ilog2_bucket_bound.to_string()])
+						.set(num_entries as u64);
+				}
+			}
+			if let Some(num_entries) = self.network_service.behaviour_mut().num_kademlia_records() {
+				metrics.kademlia_records_count.set(num_entries as u64);
+			}
+			if let Some(num_entries) =
+				self.network_service.behaviour_mut().kademlia_records_total_size()
+			{
+				metrics.kademlia_records_sizes_total.set(num_entries as u64);
+			}
+			metrics
+				.peerset_num_discovered
+				.set(self.peer_store_handle.num_known_peers() as u64);
+			metrics.pending_connections.set(
+				Swarm::network_info(&self.network_service).connection_counters().num_pending()
+					as u64,
+			);
+		}
+
+		true
+	}
+
+	/// Process the next message coming from the `NetworkService`.
+	fn handle_worker_message(&mut self, msg: ServiceToWorkerMsg) {
+		match msg {
+			ServiceToWorkerMsg::GetValue(key) =>
+				self.network_service.behaviour_mut().get_value(key),
+			ServiceToWorkerMsg::PutValue(key, value) =>
+				self.network_service.behaviour_mut().put_value(key, value),
+			ServiceToWorkerMsg::AddKnownAddress(peer_id, addr) =>
+				self.network_service.behaviour_mut().add_known_address(peer_id, addr),
+			ServiceToWorkerMsg::ReportPeer(peer_id, reputation_change) =>
+				self.peer_store_handle.report_peer(peer_id, reputation_change),
+			ServiceToWorkerMsg::EventStream(sender) => self.event_streams.push(sender),
+			ServiceToWorkerMsg::Request {
+				target,
+				protocol,
+				request,
+				pending_response,
+				connect,
+			} => {
+				self.network_service.behaviour_mut().send_request(
+					&target,
+					&protocol,
+					request,
+					pending_response,
+					connect,
+				);
+			},
+			ServiceToWorkerMsg::NetworkStatus { pending_response } => {
+				let _ = pending_response.send(Ok(self.status()));
+			},
+			ServiceToWorkerMsg::NetworkState { pending_response } => {
+				let _ = pending_response.send(Ok(self.network_state()));
+			},
+			ServiceToWorkerMsg::DisconnectPeer(who, protocol_name) => self
+				.network_service
+				.behaviour_mut()
+				.user_protocol_mut()
+				.disconnect_peer(&who, protocol_name),
+			ServiceToWorkerMsg::SetNotificationHandshake(protocol, handshake) => self
+				.network_service
+				.behaviour_mut()
+				.user_protocol_mut()
+				.set_notification_handshake(protocol, handshake),
+		}
+	}
+
+	/// Process the next event coming from `Swarm`.
+	fn handle_swarm_event(&mut self, event: SwarmEvent<BehaviourOut, THandlerErr<Behaviour<B>>>) {
+		match event {
+			SwarmEvent::Behaviour(BehaviourOut::InboundRequest { protocol, result, .. }) => {
+				if let Some(metrics) = self.metrics.as_ref() {
+					match result {
+						Ok(serve_time) => {
+							metrics
+								.requests_in_success_total
+								.with_label_values(&[&protocol])
+								.observe(serve_time.as_secs_f64());
+						},
+						Err(err) => {
+							let reason = match err {
+								ResponseFailure::Network(InboundFailure::Timeout) =>
+									Some("timeout"),
+								ResponseFailure::Network(InboundFailure::UnsupportedProtocols) =>
+								// `UnsupportedProtocols` is reported for every single
+								// inbound request whenever a request with an unsupported
+								// protocol is received. This is not reported in order to
+								// avoid confusions.
+									None,
+								ResponseFailure::Network(InboundFailure::ResponseOmission) =>
+									Some("busy-omitted"),
+								ResponseFailure::Network(InboundFailure::ConnectionClosed) =>
+									Some("connection-closed"),
+							};
+
+							if let Some(reason) = reason {
+								metrics
+									.requests_in_failure_total
+									.with_label_values(&[&protocol, reason])
+									.inc();
+							}
+						},
+					}
+				}
+			},
+			SwarmEvent::Behaviour(BehaviourOut::RequestFinished {
+				protocol,
+				duration,
+				result,
+				..
+			}) =>
+				if let Some(metrics) = self.metrics.as_ref() {
+					match result {
+						Ok(_) => {
+							metrics
+								.requests_out_success_total
+								.with_label_values(&[&protocol])
+								.observe(duration.as_secs_f64());
+						},
+						Err(err) => {
+							let reason = match err {
+								RequestFailure::NotConnected => "not-connected",
+								RequestFailure::UnknownProtocol => "unknown-protocol",
+								RequestFailure::Refused => "refused",
+								RequestFailure::Obsolete => "obsolete",
+								RequestFailure::Network(OutboundFailure::DialFailure) =>
+									"dial-failure",
+								RequestFailure::Network(OutboundFailure::Timeout) => "timeout",
+								RequestFailure::Network(OutboundFailure::ConnectionClosed) =>
+									"connection-closed",
+								RequestFailure::Network(OutboundFailure::UnsupportedProtocols) =>
+									"unsupported",
+							};
+
+							metrics
+								.requests_out_failure_total
+								.with_label_values(&[&protocol, reason])
+								.inc();
+						},
+					}
+				},
+			SwarmEvent::Behaviour(BehaviourOut::ReputationChanges { peer, changes }) => {
+				for change in changes {
+					self.peer_store_handle.report_peer(peer, change);
+				}
+			},
+			SwarmEvent::Behaviour(BehaviourOut::PeerIdentify {
+				peer_id,
+				info:
+					IdentifyInfo {
+						protocol_version, agent_version, mut listen_addrs, protocols, ..
+					},
+			}) => {
+				if listen_addrs.len() > 30 {
+					debug!(
+						target: "sub-libp2p",
+						"Node {:?} has reported more than 30 addresses; it is identified by {:?} and {:?}",
+						peer_id, protocol_version, agent_version
+					);
+					listen_addrs.truncate(30);
+				}
+				for addr in listen_addrs {
+					self.network_service
+						.behaviour_mut()
+						.add_self_reported_address_to_dht(&peer_id, &protocols, addr);
+				}
+				self.peer_store_handle.add_known_peer(peer_id);
+			},
+			SwarmEvent::Behaviour(BehaviourOut::Discovered(peer_id)) => {
+				self.peer_store_handle.add_known_peer(peer_id);
+			},
+			SwarmEvent::Behaviour(BehaviourOut::RandomKademliaStarted) => {
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics.kademlia_random_queries_total.inc();
+				}
+			},
+			SwarmEvent::Behaviour(BehaviourOut::NotificationStreamOpened {
+				remote,
+				protocol,
+				negotiated_fallback,
+				notifications_sink,
+				role,
+				received_handshake,
+			}) => {
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics
+						.notifications_streams_opened_total
+						.with_label_values(&[&protocol])
+						.inc();
+				}
+				{
+					let mut peers_notifications_sinks = self.peers_notifications_sinks.lock();
+					let _previous_value = peers_notifications_sinks
+						.insert((remote, protocol.clone()), notifications_sink);
+					debug_assert!(_previous_value.is_none());
+				}
+				self.event_streams.send(Event::NotificationStreamOpened {
+					remote,
+					protocol,
+					negotiated_fallback,
+					role,
+					received_handshake,
+				});
+			},
+			SwarmEvent::Behaviour(BehaviourOut::NotificationStreamReplaced {
+				remote,
+				protocol,
+				notifications_sink,
+			}) => {
+				let mut peers_notifications_sinks = self.peers_notifications_sinks.lock();
+				if let Some(s) = peers_notifications_sinks.get_mut(&(remote, protocol)) {
+					*s = notifications_sink;
+				} else {
+					error!(
+						target: "sub-libp2p",
+						"NotificationStreamReplaced for non-existing substream"
+					);
+					debug_assert!(false);
+				}
+
+				// TODO: Notifications might have been lost as a result of the previous
+				// connection being dropped, and as a result it would be preferable to notify
+				// the users of this fact by simulating the substream being closed then
+				// reopened.
+				// The code below doesn't compile because `role` is unknown. Propagating the
+				// handshake of the secondary connections is quite an invasive change and
+				// would conflict with https://github.com/paritytech/substrate/issues/6403.
+				// Considering that dropping notifications is generally regarded as
+				// acceptable, this bug is at the moment intentionally left there and is
+				// intended to be fixed at the same time as
+				// https://github.com/paritytech/substrate/issues/6403.
+				// self.event_streams.send(Event::NotificationStreamClosed {
+				// remote,
+				// protocol,
+				// });
+				// self.event_streams.send(Event::NotificationStreamOpened {
+				// remote,
+				// protocol,
+				// role,
+				// });
+			},
+			SwarmEvent::Behaviour(BehaviourOut::NotificationStreamClosed { remote, protocol }) => {
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics
+						.notifications_streams_closed_total
+						.with_label_values(&[&protocol[..]])
+						.inc();
+				}
+				self.event_streams
+					.send(Event::NotificationStreamClosed { remote, protocol: protocol.clone() });
+				{
+					let mut peers_notifications_sinks = self.peers_notifications_sinks.lock();
+					let _previous_value = peers_notifications_sinks.remove(&(remote, protocol));
+					debug_assert!(_previous_value.is_some());
+				}
+			},
+			SwarmEvent::Behaviour(BehaviourOut::NotificationsReceived { remote, messages }) => {
+				if let Some(metrics) = self.metrics.as_ref() {
+					for (protocol, message) in &messages {
+						metrics
+							.notifications_sizes
+							.with_label_values(&["in", protocol])
+							.observe(message.len() as f64);
+					}
+				}
+				self.event_streams.send(Event::NotificationsReceived { remote, messages });
+			},
+			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());
+				}
+
+				self.event_streams.send(Event::Dht(event));
+			},
+			SwarmEvent::Behaviour(BehaviourOut::None) => {
+				// Ignored event from lower layers.
+			},
+			SwarmEvent::ConnectionEstablished {
+				peer_id,
+				endpoint,
+				num_established,
+				concurrent_dial_errors,
+				..
+			} => {
+				if let Some(errors) = concurrent_dial_errors {
+					debug!(target: "sub-libp2p", "Libp2p => Connected({:?}) with errors: {:?}", peer_id, errors);
+				} else {
+					debug!(target: "sub-libp2p", "Libp2p => Connected({:?})", peer_id);
+				}
+
+				if let Some(metrics) = self.metrics.as_ref() {
+					let direction = match endpoint {
+						ConnectedPoint::Dialer { .. } => "out",
+						ConnectedPoint::Listener { .. } => "in",
+					};
+					metrics.connections_opened_total.with_label_values(&[direction]).inc();
+
+					if num_established.get() == 1 {
+						metrics.distinct_peers_connections_opened_total.inc();
+					}
+				}
+			},
+			SwarmEvent::ConnectionClosed { peer_id, cause, endpoint, num_established } => {
+				debug!(target: "sub-libp2p", "Libp2p => Disconnected({:?}, {:?})", peer_id, cause);
+				if let Some(metrics) = self.metrics.as_ref() {
+					let direction = match endpoint {
+						ConnectedPoint::Dialer { .. } => "out",
+						ConnectedPoint::Listener { .. } => "in",
+					};
+					let reason = match cause {
+						Some(ConnectionError::IO(_)) => "transport-error",
+						Some(ConnectionError::Handler(Either::Left(Either::Left(
+							Either::Right(Either::Left(PingFailure::Timeout)),
+						)))) => "ping-timeout",
+						Some(ConnectionError::Handler(Either::Left(Either::Left(
+							Either::Left(NotifsHandlerError::SyncNotificationsClogged),
+						)))) => "sync-notifications-clogged",
+						Some(ConnectionError::Handler(_)) => "protocol-error",
+						Some(ConnectionError::KeepAliveTimeout) => "keep-alive-timeout",
+						None => "actively-closed",
+					};
+					metrics.connections_closed_total.with_label_values(&[direction, reason]).inc();
+
+					// `num_established` represents the number of *remaining* connections.
+					if num_established == 0 {
+						metrics.distinct_peers_connections_closed_total.inc();
+					}
+				}
+			},
+			SwarmEvent::NewListenAddr { address, .. } => {
+				trace!(target: "sub-libp2p", "Libp2p => NewListenAddr({})", address);
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics.listeners_local_addresses.inc();
+				}
+				self.listen_addresses.lock().insert(address.clone());
+			},
+			SwarmEvent::ExpiredListenAddr { address, .. } => {
+				info!(target: "sub-libp2p", "📪 No longer listening on {}", address);
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics.listeners_local_addresses.dec();
+				}
+				self.listen_addresses.lock().remove(&address);
+			},
+			SwarmEvent::OutgoingConnectionError { peer_id, error } => {
+				if let Some(peer_id) = peer_id {
+					trace!(
+						target: "sub-libp2p",
+						"Libp2p => Failed to reach {:?}: {}",
+						peer_id, error,
+					);
+
+					let not_reported = !self.reported_invalid_boot_nodes.contains(&peer_id);
+
+					if let Some(addresses) =
+						not_reported.then(|| self.boot_node_ids.get(&peer_id)).flatten()
+					{
+						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);
+
+								// 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
+								// boot node.
+								if addresses.iter().any(|a| address_without_peer_id == *a) {
+									warn!(
+										"💔 The bootnode you want to connect to at `{address}` provided a \
+										 different peer ID `{obtained}` than the one you expect `{peer_id}`.",
+									);
+
+									self.reported_invalid_boot_nodes.insert(peer_id);
+								}
+							}
+						}
+					}
+				}
+
+				if let Some(metrics) = self.metrics.as_ref() {
+					#[allow(deprecated)]
+					let reason = match error {
+						DialError::Denied { cause } =>
+							if cause.downcast::<Exceeded>().is_ok() {
+								Some("limit-reached")
+							} else {
+								None
+							},
+						DialError::ConnectionLimit(_) => Some("limit-reached"),
+						DialError::InvalidPeerId(_) |
+						DialError::WrongPeerId { .. } |
+						DialError::LocalPeerId { .. } => Some("invalid-peer-id"),
+						DialError::Transport(_) => Some("transport-error"),
+						DialError::Banned |
+						DialError::NoAddresses |
+						DialError::DialPeerConditionFalse(_) |
+						DialError::Aborted => None, // ignore them
+					};
+					if let Some(reason) = reason {
+						metrics.pending_connections_errors_total.with_label_values(&[reason]).inc();
+					}
+				}
+			},
+			SwarmEvent::Dialing(peer_id) => {
+				trace!(target: "sub-libp2p", "Libp2p => Dialing({:?})", peer_id)
+			},
+			SwarmEvent::IncomingConnection { local_addr, send_back_addr } => {
+				trace!(target: "sub-libp2p", "Libp2p => IncomingConnection({},{}))",
+					local_addr, send_back_addr);
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics.incoming_connections_total.inc();
+				}
+			},
+			SwarmEvent::IncomingConnectionError { local_addr, send_back_addr, error } => {
+				debug!(
+					target: "sub-libp2p",
+					"Libp2p => IncomingConnectionError({},{}): {}",
+					local_addr, send_back_addr, error,
+				);
+				if let Some(metrics) = self.metrics.as_ref() {
+					#[allow(deprecated)]
+					let reason = match error {
+						ListenError::Denied { cause } =>
+							if cause.downcast::<Exceeded>().is_ok() {
+								Some("limit-reached")
+							} else {
+								None
+							},
+						ListenError::ConnectionLimit(_) => Some("limit-reached"),
+						ListenError::WrongPeerId { .. } | ListenError::LocalPeerId { .. } =>
+							Some("invalid-peer-id"),
+						ListenError::Transport(_) => Some("transport-error"),
+						ListenError::Aborted => None, // ignore it
+					};
+
+					if let Some(reason) = reason {
+						metrics
+							.incoming_connections_errors_total
+							.with_label_values(&[reason])
+							.inc();
+					}
+				}
+			},
+			#[allow(deprecated)]
+			SwarmEvent::BannedPeer { peer_id, endpoint } => {
+				debug!(
+					target: "sub-libp2p",
+					"Libp2p => BannedPeer({}). Connected via {:?}.",
+					peer_id, endpoint,
+				);
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics.incoming_connections_errors_total.with_label_values(&["banned"]).inc();
+				}
+			},
+			SwarmEvent::ListenerClosed { reason, addresses, .. } => {
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics.listeners_local_addresses.sub(addresses.len() as u64);
+				}
+				let mut listen_addresses = self.listen_addresses.lock();
+				for addr in &addresses {
+					listen_addresses.remove(addr);
+				}
+				drop(listen_addresses);
+
+				let addrs =
+					addresses.into_iter().map(|a| a.to_string()).collect::<Vec<_>>().join(", ");
+				match reason {
+					Ok(()) => error!(
+						target: "sub-libp2p",
+						"📪 Libp2p listener ({}) closed gracefully",
+						addrs
+					),
+					Err(e) => error!(
+						target: "sub-libp2p",
+						"📪 Libp2p listener ({}) closed: {}",
+						addrs, e
+					),
+				}
+			},
+			SwarmEvent::ListenerError { error, .. } => {
+				debug!(target: "sub-libp2p", "Libp2p => ListenerError: {}", error);
+				if let Some(metrics) = self.metrics.as_ref() {
+					metrics.listeners_errors_total.inc();
+				}
+			},
+		}
+	}
+}
+
+impl<B, H> Unpin for NetworkWorker<B, H>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+{
+}
+
+fn ensure_addresses_consistent_with_transport<'a>(
+	addresses: impl Iterator<Item = &'a Multiaddr>,
+	transport: &TransportConfig,
+) -> Result<(), Error> {
+	if matches!(transport, TransportConfig::MemoryOnly) {
+		let addresses: Vec<_> = addresses
+			.filter(|x| {
+				x.iter().any(|y| !matches!(y, libp2p::core::multiaddr::Protocol::Memory(_)))
+			})
+			.cloned()
+			.collect();
+
+		if !addresses.is_empty() {
+			return Err(Error::AddressesForAnotherTransport {
+				transport: transport.clone(),
+				addresses,
+			})
+		}
+	} else {
+		let addresses: Vec<_> = addresses
+			.filter(|x| x.iter().any(|y| matches!(y, libp2p::core::multiaddr::Protocol::Memory(_))))
+			.cloned()
+			.collect();
+
+		if !addresses.is_empty() {
+			return Err(Error::AddressesForAnotherTransport {
+				transport: transport.clone(),
+				addresses,
+			})
+		}
+	}
+
+	Ok(())
+}
diff --git a/substrate/client/network/src/service/metrics.rs b/substrate/client/network/src/service/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..13bc4b4e7aff8bc948da3976882d011a9f81d867
--- /dev/null
+++ b/substrate/client/network/src/service/metrics.rs
@@ -0,0 +1,293 @@
+// 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::transport::BandwidthSinks;
+use prometheus_endpoint::{
+	self as prometheus, Counter, CounterVec, Gauge, GaugeVec, HistogramOpts, MetricSource, Opts,
+	PrometheusError, Registry, SourcedCounter, SourcedGauge, U64,
+};
+use std::{
+	str,
+	sync::{
+		atomic::{AtomicUsize, Ordering},
+		Arc,
+	},
+};
+
+pub use prometheus_endpoint::{Histogram, HistogramVec};
+
+/// Registers all networking metrics with the given registry.
+pub fn register(registry: &Registry, sources: MetricSources) -> Result<Metrics, PrometheusError> {
+	BandwidthCounters::register(registry, sources.bandwidth)?;
+	NumConnectedGauge::register(registry, sources.connected_peers)?;
+	Metrics::register(registry)
+}
+
+/// Predefined metric sources that are fed directly into prometheus.
+pub struct MetricSources {
+	pub bandwidth: Arc<BandwidthSinks>,
+	pub connected_peers: Arc<AtomicUsize>,
+}
+
+/// Dedicated metrics.
+pub struct Metrics {
+	// This list is ordered alphabetically
+	pub connections_closed_total: CounterVec<U64>,
+	pub connections_opened_total: CounterVec<U64>,
+	pub distinct_peers_connections_closed_total: Counter<U64>,
+	pub distinct_peers_connections_opened_total: Counter<U64>,
+	pub incoming_connections_errors_total: CounterVec<U64>,
+	pub incoming_connections_total: Counter<U64>,
+	pub issued_light_requests: Counter<U64>,
+	pub kademlia_query_duration: HistogramVec,
+	pub kademlia_random_queries_total: Counter<U64>,
+	pub kademlia_records_count: Gauge<U64>,
+	pub kademlia_records_sizes_total: Gauge<U64>,
+	pub kbuckets_num_nodes: GaugeVec<U64>,
+	pub listeners_local_addresses: Gauge<U64>,
+	pub listeners_errors_total: Counter<U64>,
+	pub notifications_sizes: HistogramVec,
+	pub notifications_streams_closed_total: CounterVec<U64>,
+	pub notifications_streams_opened_total: CounterVec<U64>,
+	pub peerset_num_discovered: Gauge<U64>,
+	pub pending_connections: Gauge<U64>,
+	pub pending_connections_errors_total: CounterVec<U64>,
+	pub requests_in_failure_total: CounterVec<U64>,
+	pub requests_in_success_total: HistogramVec,
+	pub requests_out_failure_total: CounterVec<U64>,
+	pub requests_out_success_total: HistogramVec,
+}
+
+impl Metrics {
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			// This list is ordered alphabetically
+			connections_closed_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_connections_closed_total",
+					"Total number of connections closed, by direction and reason"
+				),
+				&["direction", "reason"]
+			)?, registry)?,
+			connections_opened_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_connections_opened_total",
+					"Total number of connections opened by direction"
+				),
+				&["direction"]
+			)?, registry)?,
+			distinct_peers_connections_closed_total: prometheus::register(Counter::new(
+					"substrate_sub_libp2p_distinct_peers_connections_closed_total",
+					"Total number of connections closed with distinct peers"
+			)?, registry)?,
+			distinct_peers_connections_opened_total: prometheus::register(Counter::new(
+					"substrate_sub_libp2p_distinct_peers_connections_opened_total",
+					"Total number of connections opened with distinct peers"
+			)?, registry)?,
+			incoming_connections_errors_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_incoming_connections_handshake_errors_total",
+					"Total number of incoming connections that have failed during the \
+					initial handshake"
+				),
+				&["reason"]
+			)?, registry)?,
+			incoming_connections_total: prometheus::register(Counter::new(
+				"substrate_sub_libp2p_incoming_connections_total",
+				"Total number of incoming connections on the listening sockets"
+			)?, registry)?,
+			issued_light_requests: prometheus::register(Counter::new(
+				"substrate_issued_light_requests",
+				"Number of light client requests that our node has issued.",
+			)?, registry)?,
+			kademlia_query_duration: prometheus::register(HistogramVec::new(
+				HistogramOpts {
+					common_opts: Opts::new(
+						"substrate_sub_libp2p_kademlia_query_duration",
+						"Duration of Kademlia queries per query type"
+					),
+					buckets: prometheus::exponential_buckets(0.5, 2.0, 10)
+						.expect("parameters are always valid values; qed"),
+				},
+				&["type"]
+			)?, registry)?,
+			kademlia_random_queries_total: prometheus::register(Counter::new(
+				"substrate_sub_libp2p_kademlia_random_queries_total",
+				"Number of random Kademlia queries started",
+			)?, registry)?,
+			kademlia_records_count: prometheus::register(Gauge::new(
+				"substrate_sub_libp2p_kademlia_records_count",
+				"Number of records in the Kademlia records store",
+			)?, registry)?,
+			kademlia_records_sizes_total: prometheus::register(Gauge::new(
+				"substrate_sub_libp2p_kademlia_records_sizes_total",
+				"Total size of all the records in the Kademlia records store",
+			)?, registry)?,
+			kbuckets_num_nodes: prometheus::register(GaugeVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_kbuckets_num_nodes",
+					"Number of nodes per kbucket per Kademlia instance"
+				),
+				&["lower_ilog2_bucket_bound"]
+			)?, registry)?,
+			listeners_local_addresses: prometheus::register(Gauge::new(
+				"substrate_sub_libp2p_listeners_local_addresses",
+				"Number of local addresses we're listening on"
+			)?, registry)?,
+			listeners_errors_total: prometheus::register(Counter::new(
+				"substrate_sub_libp2p_listeners_errors_total",
+				"Total number of non-fatal errors reported by a listener"
+			)?, registry)?,
+			notifications_sizes: prometheus::register(HistogramVec::new(
+				HistogramOpts {
+					common_opts: Opts::new(
+						"substrate_sub_libp2p_notifications_sizes",
+						"Sizes of the notifications send to and received from all nodes"
+					),
+					buckets: prometheus::exponential_buckets(64.0, 4.0, 8)
+						.expect("parameters are always valid values; qed"),
+				},
+				&["direction", "protocol"]
+			)?, registry)?,
+			notifications_streams_closed_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_notifications_streams_closed_total",
+					"Total number of notification substreams that have been closed"
+				),
+				&["protocol"]
+			)?, registry)?,
+			notifications_streams_opened_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_notifications_streams_opened_total",
+					"Total number of notification substreams that have been opened"
+				),
+				&["protocol"]
+			)?, registry)?,
+			peerset_num_discovered: prometheus::register(Gauge::new(
+				"substrate_sub_libp2p_peerset_num_discovered",
+				"Number of nodes stored in the peerset manager",
+			)?, registry)?,
+			pending_connections: prometheus::register(Gauge::new(
+				"substrate_sub_libp2p_pending_connections",
+				"Number of connections in the process of being established",
+			)?, registry)?,
+			pending_connections_errors_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_pending_connections_errors_total",
+					"Total number of pending connection errors"
+				),
+				&["reason"]
+			)?, registry)?,
+			requests_in_failure_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_requests_in_failure_total",
+					"Total number of incoming requests that the node has failed to answer"
+				),
+				&["protocol", "reason"]
+			)?, registry)?,
+			requests_in_success_total: prometheus::register(HistogramVec::new(
+				HistogramOpts {
+					common_opts: Opts::new(
+						"substrate_sub_libp2p_requests_in_success_total",
+						"For successful incoming requests, time between receiving the request and \
+						 starting to send the response"
+					),
+					buckets: prometheus::exponential_buckets(0.001, 2.0, 16)
+						.expect("parameters are always valid values; qed"),
+				},
+				&["protocol"]
+			)?, registry)?,
+			requests_out_failure_total: prometheus::register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_requests_out_failure_total",
+					"Total number of requests that have failed"
+				),
+				&["protocol", "reason"]
+			)?, registry)?,
+			requests_out_success_total: prometheus::register(HistogramVec::new(
+				HistogramOpts {
+					common_opts: Opts::new(
+						"substrate_sub_libp2p_requests_out_success_total",
+						"For successful outgoing requests, time between a request's start and finish"
+					),
+					buckets: prometheus::exponential_buckets(0.001, 2.0, 16)
+						.expect("parameters are always valid values; qed"),
+				},
+				&["protocol"]
+			)?, registry)?,
+		})
+	}
+}
+
+/// The bandwidth counter metric.
+#[derive(Clone)]
+pub struct BandwidthCounters(Arc<BandwidthSinks>);
+
+impl BandwidthCounters {
+	/// Registers the `BandwidthCounters` metric whose values are
+	/// obtained from the given sinks.
+	fn register(registry: &Registry, sinks: Arc<BandwidthSinks>) -> Result<(), PrometheusError> {
+		prometheus::register(
+			SourcedCounter::new(
+				&Opts::new("substrate_sub_libp2p_network_bytes_total", "Total bandwidth usage")
+					.variable_label("direction"),
+				BandwidthCounters(sinks),
+			)?,
+			registry,
+		)?;
+
+		Ok(())
+	}
+}
+
+impl MetricSource for BandwidthCounters {
+	type N = u64;
+
+	fn collect(&self, mut set: impl FnMut(&[&str], Self::N)) {
+		set(&["in"], self.0.total_inbound());
+		set(&["out"], self.0.total_outbound());
+	}
+}
+
+/// The connected peers metric.
+#[derive(Clone)]
+pub struct NumConnectedGauge(Arc<AtomicUsize>);
+
+impl NumConnectedGauge {
+	/// Registers the `MajorSyncingGauge` metric whose value is
+	/// obtained from the given `AtomicUsize`.
+	fn register(registry: &Registry, value: Arc<AtomicUsize>) -> Result<(), PrometheusError> {
+		prometheus::register(
+			SourcedGauge::new(
+				&Opts::new("substrate_sub_libp2p_peers_count", "Number of connected peers"),
+				NumConnectedGauge(value),
+			)?,
+			registry,
+		)?;
+
+		Ok(())
+	}
+}
+
+impl MetricSource for NumConnectedGauge {
+	type N = u64;
+
+	fn collect(&self, mut set: impl FnMut(&[&str], Self::N)) {
+		set(&[], self.0.load(Ordering::Relaxed) as u64);
+	}
+}
diff --git a/substrate/client/network/src/service/out_events.rs b/substrate/client/network/src/service/out_events.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ededccd5e32335d4e0ae53fef2f29b7f78db963a
--- /dev/null
+++ b/substrate/client/network/src/service/out_events.rs
@@ -0,0 +1,347 @@
+// 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/>.
+
+//! Registering events streams.
+//!
+//! This code holds the logic that is used for the network service to inform other parts of
+//! Substrate about what is happening.
+//!
+//! # Usage
+//!
+//! - Create an instance of [`OutChannels`].
+//! - Create channels using the [`channel`] function. The receiving side implements the `Stream`
+//! trait.
+//! - You cannot directly send an event on a sender. Instead, you have to call
+//! [`OutChannels::push`] to put the sender within a [`OutChannels`].
+//! - Send events by calling [`OutChannels::send`]. Events are cloned for each sender in the
+//! collection.
+
+use crate::event::Event;
+
+use futures::{prelude::*, ready, stream::FusedStream};
+use log::{debug, error};
+use prometheus_endpoint::{register, CounterVec, GaugeVec, Opts, PrometheusError, Registry, U64};
+use std::{
+	backtrace::Backtrace,
+	cell::RefCell,
+	fmt,
+	pin::Pin,
+	task::{Context, Poll},
+};
+
+/// Log target for this file.
+pub const LOG_TARGET: &str = "sub-libp2p::out_events";
+
+/// Creates a new channel that can be associated to a [`OutChannels`].
+///
+/// The name is used in Prometheus reports, the queue size threshold is used
+/// to warn if there are too many unprocessed events in the channel.
+pub fn channel(name: &'static str, queue_size_warning: usize) -> (Sender, Receiver) {
+	let (tx, rx) = async_channel::unbounded();
+	let tx = Sender {
+		inner: tx,
+		name,
+		queue_size_warning,
+		warning_fired: SenderWarningState::NotFired,
+		creation_backtrace: Backtrace::force_capture(),
+		metrics: None,
+	};
+	let rx = Receiver { inner: rx, name, metrics: None };
+	(tx, rx)
+}
+
+/// A state of a sender warning that is used to avoid spamming the logs.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SenderWarningState {
+	/// The warning has not been fired yet.
+	NotFired,
+	/// The warning has been fired, and the channel is full
+	FiredFull,
+	/// The warning has been fired and the channel is not full anymore.
+	FiredFree,
+}
+
+/// Sending side of a channel.
+///
+/// Must be associated with an [`OutChannels`] before anything can be sent on it
+///
+/// > **Note**: Contrary to regular channels, this `Sender` is purposefully designed to not
+/// implement the `Clone` trait e.g. in Order to not complicate the logic keeping the metrics in
+/// sync on drop. If someone adds a `#[derive(Clone)]` below, it is **wrong**.
+pub struct Sender {
+	inner: async_channel::Sender<Event>,
+	/// Name to identify the channel (e.g., in Prometheus and logs).
+	name: &'static str,
+	/// Threshold queue size to generate an error message in the logs.
+	queue_size_warning: usize,
+	/// We generate the error message only once to not spam the logs after the first error.
+	/// Subsequently we indicate channel fullness on debug level.
+	warning_fired: SenderWarningState,
+	/// Backtrace of a place where the channel was created.
+	creation_backtrace: Backtrace,
+	/// Clone of [`Receiver::metrics`]. Will be initialized when [`Sender`] is added to
+	/// [`OutChannels`] with `OutChannels::push()`.
+	metrics: Option<Metrics>,
+}
+
+impl fmt::Debug for Sender {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.debug_tuple("Sender").finish()
+	}
+}
+
+impl Drop for Sender {
+	fn drop(&mut self) {
+		if let Some(metrics) = self.metrics.as_ref() {
+			metrics.num_channels.with_label_values(&[self.name]).dec();
+		}
+	}
+}
+
+/// Receiving side of a channel.
+pub struct Receiver {
+	inner: async_channel::Receiver<Event>,
+	name: &'static str,
+	/// Initially contains `None`, and will be set to a value once the corresponding [`Sender`]
+	/// is assigned to an instance of [`OutChannels`].
+	metrics: Option<Metrics>,
+}
+
+impl Stream for Receiver {
+	type Item = Event;
+
+	fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Event>> {
+		if let Some(ev) = ready!(Pin::new(&mut self.inner).poll_next(cx)) {
+			if let Some(metrics) = &self.metrics {
+				metrics.event_out(&ev, self.name);
+			}
+			Poll::Ready(Some(ev))
+		} else {
+			Poll::Ready(None)
+		}
+	}
+}
+
+impl fmt::Debug for Receiver {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.debug_tuple("Receiver").finish()
+	}
+}
+
+impl Drop for Receiver {
+	fn drop(&mut self) {
+		if !self.inner.is_terminated() {
+			// Empty the list to properly decrease the metrics.
+			while let Some(Some(_)) = self.next().now_or_never() {}
+		}
+	}
+}
+
+/// Collection of senders.
+pub struct OutChannels {
+	event_streams: Vec<Sender>,
+	/// The metrics we collect. A clone of this is sent to each [`Receiver`] associated with this
+	/// object.
+	metrics: Option<Metrics>,
+}
+
+impl OutChannels {
+	/// Creates a new empty collection of senders.
+	pub fn new(registry: Option<&Registry>) -> Result<Self, PrometheusError> {
+		let metrics =
+			if let Some(registry) = registry { Some(Metrics::register(registry)?) } else { None };
+
+		Ok(Self { event_streams: Vec::new(), metrics })
+	}
+
+	/// Adds a new [`Sender`] to the collection.
+	pub fn push(&mut self, mut sender: Sender) {
+		debug_assert!(sender.metrics.is_none());
+		sender.metrics = self.metrics.clone();
+
+		if let Some(metrics) = &self.metrics {
+			metrics.num_channels.with_label_values(&[sender.name]).inc();
+		}
+
+		self.event_streams.push(sender);
+	}
+
+	/// Sends an event.
+	pub fn send(&mut self, event: Event) {
+		self.event_streams.retain_mut(|sender| {
+			let current_pending = sender.inner.len();
+			if current_pending >= sender.queue_size_warning {
+				if sender.warning_fired == SenderWarningState::NotFired {
+					error!(
+						"The number of unprocessed events in channel `{}` exceeded {}.\n\
+						 The channel was created at:\n{:}\n
+						 The last event was sent from:\n{:}",
+						sender.name,
+						sender.queue_size_warning,
+						sender.creation_backtrace,
+						Backtrace::force_capture(),
+					);
+				} else if sender.warning_fired == SenderWarningState::FiredFree {
+					// We don't want to spam the logs, so we only log on debug level
+					debug!(
+						target: LOG_TARGET,
+						"Channel `{}` is overflowed again. Number of events: {}",
+						sender.name, current_pending
+					);
+				}
+				sender.warning_fired = SenderWarningState::FiredFull;
+			} else if sender.warning_fired == SenderWarningState::FiredFull &&
+				current_pending < sender.queue_size_warning.wrapping_div(2)
+			{
+				sender.warning_fired = SenderWarningState::FiredFree;
+				debug!(
+					target: LOG_TARGET,
+					"Channel `{}` is no longer overflowed. Number of events: {}",
+					sender.name, current_pending
+				);
+			}
+
+			sender.inner.try_send(event.clone()).is_ok()
+		});
+
+		if let Some(metrics) = &self.metrics {
+			for ev in &self.event_streams {
+				metrics.event_in(&event, ev.name);
+			}
+		}
+	}
+}
+
+impl fmt::Debug for OutChannels {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.debug_struct("OutChannels")
+			.field("num_channels", &self.event_streams.len())
+			.finish()
+	}
+}
+
+#[derive(Clone)]
+struct Metrics {
+	// This list is ordered alphabetically
+	events_total: CounterVec<U64>,
+	notifications_sizes: CounterVec<U64>,
+	num_channels: GaugeVec<U64>,
+}
+
+thread_local! {
+	static LABEL_BUFFER: RefCell<String> = RefCell::new(String::new());
+}
+
+fn format_label(prefix: &str, protocol: &str, callback: impl FnOnce(&str)) {
+	LABEL_BUFFER.with(|label_buffer| {
+		let mut label_buffer = label_buffer.borrow_mut();
+		label_buffer.clear();
+		label_buffer.reserve(prefix.len() + protocol.len() + 2);
+		label_buffer.push_str(prefix);
+		label_buffer.push('"');
+		label_buffer.push_str(protocol);
+		label_buffer.push('"');
+		callback(&label_buffer);
+	});
+}
+
+impl Metrics {
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			events_total: register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_out_events_events_total",
+					"Number of broadcast network events that have been sent or received across all \
+					 channels"
+				),
+				&["event_name", "action", "name"]
+			)?, registry)?,
+			notifications_sizes: register(CounterVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_out_events_notifications_sizes",
+					"Size of notification events that have been sent or received across all \
+					 channels"
+				),
+				&["protocol", "action", "name"]
+			)?, registry)?,
+			num_channels: register(GaugeVec::new(
+				Opts::new(
+					"substrate_sub_libp2p_out_events_num_channels",
+					"Number of internal active channels that broadcast network events",
+				),
+				&["name"]
+			)?, registry)?,
+		})
+	}
+
+	fn event_in(&self, event: &Event, name: &str) {
+		match event {
+			Event::Dht(_) => {
+				self.events_total.with_label_values(&["dht", "sent", name]).inc();
+			},
+			Event::NotificationStreamOpened { protocol, .. } => {
+				format_label("notif-open-", protocol, |protocol_label| {
+					self.events_total.with_label_values(&[protocol_label, "sent", name]).inc();
+				});
+			},
+			Event::NotificationStreamClosed { protocol, .. } => {
+				format_label("notif-closed-", protocol, |protocol_label| {
+					self.events_total.with_label_values(&[protocol_label, "sent", name]).inc();
+				});
+			},
+			Event::NotificationsReceived { messages, .. } =>
+				for (protocol, message) in messages {
+					format_label("notif-", protocol, |protocol_label| {
+						self.events_total.with_label_values(&[protocol_label, "sent", name]).inc();
+					});
+					self.notifications_sizes
+						.with_label_values(&[protocol, "sent", name])
+						.inc_by(u64::try_from(message.len()).unwrap_or(u64::MAX));
+				},
+		}
+	}
+
+	fn event_out(&self, event: &Event, name: &str) {
+		match event {
+			Event::Dht(_) => {
+				self.events_total.with_label_values(&["dht", "received", name]).inc();
+			},
+			Event::NotificationStreamOpened { protocol, .. } => {
+				format_label("notif-open-", protocol, |protocol_label| {
+					self.events_total.with_label_values(&[protocol_label, "received", name]).inc();
+				});
+			},
+			Event::NotificationStreamClosed { protocol, .. } => {
+				format_label("notif-closed-", protocol, |protocol_label| {
+					self.events_total.with_label_values(&[protocol_label, "received", name]).inc();
+				});
+			},
+			Event::NotificationsReceived { messages, .. } =>
+				for (protocol, message) in messages {
+					format_label("notif-", protocol, |protocol_label| {
+						self.events_total
+							.with_label_values(&[protocol_label, "received", name])
+							.inc();
+					});
+					self.notifications_sizes
+						.with_label_values(&[protocol, "received", name])
+						.inc_by(u64::try_from(message.len()).unwrap_or(u64::MAX));
+				},
+		}
+	}
+}
diff --git a/substrate/client/network/src/service/signature.rs b/substrate/client/network/src/service/signature.rs
new file mode 100644
index 0000000000000000000000000000000000000000..024f60e4c466bda1c1df8ce47b4222b69da28093
--- /dev/null
+++ b/substrate/client/network/src/service/signature.rs
@@ -0,0 +1,55 @@
+// 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/>.
+//
+// If you read this, you are very thorough, congratulations.
+
+use libp2p::{
+	identity::{Keypair, PublicKey},
+	PeerId,
+};
+
+pub use libp2p::identity::SigningError;
+
+/// A result of signing a message with a network identity. Since `PeerId` is potentially a hash of a
+/// `PublicKey`, you need to reveal the `PublicKey` next to the signature, so the verifier can check
+/// if the signature was made by the entity that controls a given `PeerId`.
+pub struct Signature {
+	/// The public key derived from the network identity that signed the message.
+	pub public_key: PublicKey,
+	/// The actual signature made for the message signed.
+	pub bytes: Vec<u8>,
+}
+
+impl Signature {
+	/// Create a signature for a message with a given network identity.
+	pub fn sign_message(
+		message: impl AsRef<[u8]>,
+		keypair: &Keypair,
+	) -> Result<Self, SigningError> {
+		let public_key = keypair.public();
+		let bytes = keypair.sign(message.as_ref())?;
+		Ok(Self { public_key, bytes })
+	}
+
+	/// Verify whether the signature was made for the given message by the entity that controls the
+	/// given `PeerId`.
+	pub fn verify(&self, message: impl AsRef<[u8]>, peer_id: &PeerId) -> bool {
+		*peer_id == self.public_key.to_peer_id() &&
+			self.public_key.verify(message.as_ref(), &self.bytes)
+	}
+}
diff --git a/substrate/client/network/src/service/traits.rs b/substrate/client/network/src/service/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bed325ede4a85552510eeb0f25edb837d50ea397
--- /dev/null
+++ b/substrate/client/network/src/service/traits.rs
@@ -0,0 +1,613 @@
+// 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/>.
+//
+// If you read this, you are very thorough, congratulations.
+
+use crate::{
+	config::MultiaddrWithPeerId,
+	event::Event,
+	request_responses::{IfDisconnected, RequestFailure},
+	service::signature::Signature,
+	types::ProtocolName,
+	ReputationChange,
+};
+
+use futures::{channel::oneshot, Stream};
+use libp2p::{Multiaddr, PeerId};
+
+use std::{collections::HashSet, future::Future, pin::Pin, sync::Arc};
+
+pub use libp2p::{identity::SigningError, kad::record::Key as KademliaKey};
+
+/// Signer with network identity
+pub trait NetworkSigner {
+	/// Signs the message with the `KeyPair` that defines the local [`PeerId`].
+	fn sign_with_local_identity(&self, msg: impl AsRef<[u8]>) -> Result<Signature, SigningError>;
+}
+
+impl<T> NetworkSigner for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkSigner,
+{
+	fn sign_with_local_identity(&self, msg: impl AsRef<[u8]>) -> Result<Signature, SigningError> {
+		T::sign_with_local_identity(self, msg)
+	}
+}
+
+/// Provides access to the networking DHT.
+pub trait NetworkDHTProvider {
+	/// Start getting a value from the DHT.
+	fn get_value(&self, key: &KademliaKey);
+
+	/// Start putting a value in the DHT.
+	fn put_value(&self, key: KademliaKey, value: Vec<u8>);
+}
+
+impl<T> NetworkDHTProvider for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkDHTProvider,
+{
+	fn get_value(&self, key: &KademliaKey) {
+		T::get_value(self, key)
+	}
+
+	fn put_value(&self, key: KademliaKey, value: Vec<u8>) {
+		T::put_value(self, key, value)
+	}
+}
+
+/// Provides an ability to set a fork sync request for a particular block.
+pub trait NetworkSyncForkRequest<BlockHash, BlockNumber> {
+	/// Notifies the sync service to try and sync the given block from the given
+	/// peers.
+	///
+	/// If the given vector of peers is empty then the underlying implementation
+	/// should make a best effort to fetch the block from any peers it is
+	/// connected to (NOTE: this assumption will change in the future #3629).
+	fn set_sync_fork_request(&self, peers: Vec<PeerId>, hash: BlockHash, number: BlockNumber);
+}
+
+impl<T, BlockHash, BlockNumber> NetworkSyncForkRequest<BlockHash, BlockNumber> for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkSyncForkRequest<BlockHash, BlockNumber>,
+{
+	fn set_sync_fork_request(&self, peers: Vec<PeerId>, hash: BlockHash, number: BlockNumber) {
+		T::set_sync_fork_request(self, peers, hash, number)
+	}
+}
+
+/// Overview status of the network.
+#[derive(Clone)]
+pub struct NetworkStatus {
+	/// Total number of connected peers.
+	pub num_connected_peers: usize,
+	/// The total number of bytes received.
+	pub total_bytes_inbound: u64,
+	/// The total number of bytes sent.
+	pub total_bytes_outbound: u64,
+}
+
+/// Provides high-level status information about network.
+#[async_trait::async_trait]
+pub trait NetworkStatusProvider {
+	/// High-level network status information.
+	///
+	/// Returns an error if the `NetworkWorker` is no longer running.
+	async fn status(&self) -> Result<NetworkStatus, ()>;
+}
+
+// Manual implementation to avoid extra boxing here
+impl<T> NetworkStatusProvider for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkStatusProvider,
+{
+	fn status<'life0, 'async_trait>(
+		&'life0 self,
+	) -> Pin<Box<dyn Future<Output = Result<NetworkStatus, ()>> + Send + 'async_trait>>
+	where
+		'life0: 'async_trait,
+		Self: 'async_trait,
+	{
+		T::status(self)
+	}
+}
+
+/// Provides low-level API for manipulating network peers.
+pub trait NetworkPeers {
+	/// Set authorized peers.
+	///
+	/// Need a better solution to manage authorized peers, but now just use reserved peers for
+	/// prototyping.
+	fn set_authorized_peers(&self, peers: HashSet<PeerId>);
+
+	/// Set authorized_only flag.
+	///
+	/// Need a better solution to decide authorized_only, but now just use reserved_only flag for
+	/// prototyping.
+	fn set_authorized_only(&self, reserved_only: bool);
+
+	/// Adds an address known to a node.
+	fn add_known_address(&self, peer_id: PeerId, addr: Multiaddr);
+
+	/// Report a given peer as either beneficial (+) or costly (-) according to the
+	/// given scalar.
+	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange);
+
+	/// Disconnect from a node as soon as possible.
+	///
+	/// This triggers the same effects as if the connection had closed itself spontaneously.
+	fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName);
+
+	/// Connect to unreserved peers and allow unreserved peers to connect for syncing purposes.
+	fn accept_unreserved_peers(&self);
+
+	/// Disconnect from unreserved peers and deny new unreserved peers to connect for syncing
+	/// purposes.
+	fn deny_unreserved_peers(&self);
+
+	/// Adds a `PeerId` and its `Multiaddr` as reserved for a sync protocol (default peer set).
+	///
+	/// Returns an `Err` if the given string is not a valid multiaddress
+	/// or contains an invalid peer ID (which includes the local peer ID).
+	fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String>;
+
+	/// Removes a `PeerId` from the list of reserved peers for a sync protocol (default peer set).
+	fn remove_reserved_peer(&self, peer_id: PeerId);
+
+	/// Sets the reserved set of a protocol to the given set of peers.
+	///
+	/// Each `Multiaddr` must end with a `/p2p/` component containing the `PeerId`. It can also
+	/// consist of only `/p2p/<peerid>`.
+	///
+	/// The node will start establishing/accepting connections and substreams to/from peers in this
+	/// set, if it doesn't have any substream open with them yet.
+	///
+	/// Note however, if a call to this function results in less peers on the reserved set, they
+	/// will not necessarily get disconnected (depending on available free slots in the peer set).
+	/// If you want to also disconnect those removed peers, you will have to call
+	/// `remove_from_peers_set` on those in addition to updating the reserved set. You can omit
+	/// this step if the peer set is in reserved only mode.
+	///
+	/// Returns an `Err` if one of the given addresses is invalid or contains an
+	/// invalid peer ID (which includes the local peer ID), or if `protocol` does not
+	/// refer to a known protocol.
+	fn set_reserved_peers(
+		&self,
+		protocol: ProtocolName,
+		peers: HashSet<Multiaddr>,
+	) -> Result<(), String>;
+
+	/// Add peers to a peer set.
+	///
+	/// Each `Multiaddr` must end with a `/p2p/` component containing the `PeerId`. It can also
+	/// consist of only `/p2p/<peerid>`.
+	///
+	/// Returns an `Err` if one of the given addresses is invalid or contains an
+	/// invalid peer ID (which includes the local peer ID), or if `protocol` does not
+	/// refer to a know protocol.
+	fn add_peers_to_reserved_set(
+		&self,
+		protocol: ProtocolName,
+		peers: HashSet<Multiaddr>,
+	) -> Result<(), String>;
+
+	/// Remove peers from a peer set.
+	///
+	/// Returns `Err` if `protocol` does not refer to a known protocol.
+	fn remove_peers_from_reserved_set(
+		&self,
+		protocol: ProtocolName,
+		peers: Vec<PeerId>,
+	) -> Result<(), String>;
+
+	/// Returns the number of peers in the sync peer set we're connected to.
+	fn sync_num_connected(&self) -> usize;
+}
+
+// Manual implementation to avoid extra boxing here
+impl<T> NetworkPeers for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkPeers,
+{
+	fn set_authorized_peers(&self, peers: HashSet<PeerId>) {
+		T::set_authorized_peers(self, peers)
+	}
+
+	fn set_authorized_only(&self, reserved_only: bool) {
+		T::set_authorized_only(self, reserved_only)
+	}
+
+	fn add_known_address(&self, peer_id: PeerId, addr: Multiaddr) {
+		T::add_known_address(self, peer_id, addr)
+	}
+
+	fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
+		// TODO: when we get rid of `Peerset`, we'll likely need to add some kind of async
+		// interface to `PeerStore`, otherwise we'll have trouble calling functions accepting
+		// `&mut self` via `Arc`.
+		// See https://github.com/paritytech/substrate/issues/14170.
+		T::report_peer(self, who, cost_benefit)
+	}
+
+	fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName) {
+		T::disconnect_peer(self, who, protocol)
+	}
+
+	fn accept_unreserved_peers(&self) {
+		T::accept_unreserved_peers(self)
+	}
+
+	fn deny_unreserved_peers(&self) {
+		T::deny_unreserved_peers(self)
+	}
+
+	fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String> {
+		T::add_reserved_peer(self, peer)
+	}
+
+	fn remove_reserved_peer(&self, peer_id: PeerId) {
+		T::remove_reserved_peer(self, peer_id)
+	}
+
+	fn set_reserved_peers(
+		&self,
+		protocol: ProtocolName,
+		peers: HashSet<Multiaddr>,
+	) -> Result<(), String> {
+		T::set_reserved_peers(self, protocol, peers)
+	}
+
+	fn add_peers_to_reserved_set(
+		&self,
+		protocol: ProtocolName,
+		peers: HashSet<Multiaddr>,
+	) -> Result<(), String> {
+		T::add_peers_to_reserved_set(self, protocol, peers)
+	}
+
+	fn remove_peers_from_reserved_set(
+		&self,
+		protocol: ProtocolName,
+		peers: Vec<PeerId>,
+	) -> Result<(), String> {
+		T::remove_peers_from_reserved_set(self, protocol, peers)
+	}
+
+	fn sync_num_connected(&self) -> usize {
+		T::sync_num_connected(self)
+	}
+}
+
+/// Provides access to network-level event stream.
+pub trait NetworkEventStream {
+	/// Returns a stream containing the events that happen on the network.
+	///
+	/// If this method is called multiple times, the events are duplicated.
+	///
+	/// The stream never ends (unless the `NetworkWorker` gets shut down).
+	///
+	/// The name passed is used to identify the channel in the Prometheus metrics. Note that the
+	/// parameter is a `&'static str`, and not a `String`, in order to avoid accidentally having
+	/// an unbounded set of Prometheus metrics, which would be quite bad in terms of memory
+	fn event_stream(&self, name: &'static str) -> Pin<Box<dyn Stream<Item = Event> + Send>>;
+}
+
+impl<T> NetworkEventStream for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkEventStream,
+{
+	fn event_stream(&self, name: &'static str) -> Pin<Box<dyn Stream<Item = Event> + Send>> {
+		T::event_stream(self, name)
+	}
+}
+
+/// Trait for providing information about the local network state
+pub trait NetworkStateInfo {
+	/// Returns the local external addresses.
+	fn external_addresses(&self) -> Vec<Multiaddr>;
+
+	/// Returns the listening addresses (without trailing `/p2p/` with our `PeerId`).
+	fn listen_addresses(&self) -> Vec<Multiaddr>;
+
+	/// Returns the local Peer ID.
+	fn local_peer_id(&self) -> PeerId;
+}
+
+impl<T> NetworkStateInfo for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkStateInfo,
+{
+	fn external_addresses(&self) -> Vec<Multiaddr> {
+		T::external_addresses(self)
+	}
+
+	fn listen_addresses(&self) -> Vec<Multiaddr> {
+		T::listen_addresses(self)
+	}
+
+	fn local_peer_id(&self) -> PeerId {
+		T::local_peer_id(self)
+	}
+}
+
+/// Reserved slot in the notifications buffer, ready to accept data.
+pub trait NotificationSenderReady {
+	/// Consumes this slots reservation and actually queues the notification.
+	///
+	/// NOTE: Traits can't consume itself, but calling this method second time will return an error.
+	fn send(&mut self, notification: Vec<u8>) -> Result<(), NotificationSenderError>;
+}
+
+/// A `NotificationSender` allows for sending notifications to a peer with a chosen protocol.
+#[async_trait::async_trait]
+pub trait NotificationSender: Send + Sync + 'static {
+	/// Returns a future that resolves when the `NotificationSender` is ready to send a
+	/// notification.
+	async fn ready(&self)
+		-> Result<Box<dyn NotificationSenderReady + '_>, NotificationSenderError>;
+}
+
+/// Error returned by [`NetworkNotification::notification_sender`].
+#[derive(Debug, thiserror::Error)]
+pub enum NotificationSenderError {
+	/// The notification receiver has been closed, usually because the underlying connection
+	/// closed.
+	///
+	/// Some of the notifications most recently sent may not have been received. However,
+	/// the peer may still be connected and a new `NotificationSender` for the same
+	/// protocol obtained from [`NetworkNotification::notification_sender`].
+	#[error("The notification receiver has been closed")]
+	Closed,
+	/// Protocol name hasn't been registered.
+	#[error("Protocol name hasn't been registered")]
+	BadProtocol,
+}
+
+/// Provides ability to send network notifications.
+pub trait NetworkNotification {
+	/// Appends a notification to the buffer of pending outgoing notifications with the given peer.
+	/// Has no effect if the notifications channel with this protocol name is not open.
+	///
+	/// If the buffer of pending outgoing notifications with that peer is full, the notification
+	/// is silently dropped and the connection to the remote will start being shut down. This
+	/// happens if you call this method at a higher rate than the rate at which the peer processes
+	/// these notifications, or if the available network bandwidth is too low.
+	///
+	/// For this reason, this method is considered soft-deprecated. You are encouraged to use
+	/// [`NetworkNotification::notification_sender`] instead.
+	///
+	/// > **Note**: The reason why this is a no-op in the situation where we have no channel is
+	/// >			that we don't guarantee message delivery anyway. Networking issues can cause
+	/// >			connections to drop at any time, and higher-level logic shouldn't differentiate
+	/// >			between the remote voluntarily closing a substream or a network error
+	/// >			preventing the message from being delivered.
+	///
+	/// The protocol must have been registered with
+	/// `crate::config::NetworkConfiguration::notifications_protocols`.
+	fn write_notification(&self, target: PeerId, protocol: ProtocolName, message: Vec<u8>);
+
+	/// Obtains a [`NotificationSender`] for a connected peer, if it exists.
+	///
+	/// A `NotificationSender` is scoped to a particular connection to the peer that holds
+	/// a receiver. With a `NotificationSender` at hand, sending a notification is done in two
+	/// steps:
+	///
+	/// 1. [`NotificationSender::ready`] is used to wait for the sender to become ready
+	/// for another notification, yielding a [`NotificationSenderReady`] token.
+	/// 2. [`NotificationSenderReady::send`] enqueues the notification for sending. This operation
+	/// can only fail if the underlying notification substream or connection has suddenly closed.
+	///
+	/// An error is returned by [`NotificationSenderReady::send`] if there exists no open
+	/// notifications substream with that combination of peer and protocol, or if the remote
+	/// has asked to close the notifications substream. If that happens, it is guaranteed that an
+	/// [`Event::NotificationStreamClosed`] has been generated on the stream returned by
+	/// [`NetworkEventStream::event_stream`].
+	///
+	/// If the remote requests to close the notifications substream, all notifications successfully
+	/// enqueued using [`NotificationSenderReady::send`] will finish being sent out before the
+	/// substream actually gets closed, but attempting to enqueue more notifications will now
+	/// return an error. It is however possible for the entire connection to be abruptly closed,
+	/// in which case enqueued notifications will be lost.
+	///
+	/// The protocol must have been registered with
+	/// `crate::config::NetworkConfiguration::notifications_protocols`.
+	///
+	/// # Usage
+	///
+	/// This method returns a struct that allows waiting until there is space available in the
+	/// buffer of messages towards the given peer. If the peer processes notifications at a slower
+	/// rate than we send them, this buffer will quickly fill up.
+	///
+	/// As such, you should never do something like this:
+	///
+	/// ```ignore
+	/// // Do NOT do this
+	/// for peer in peers {
+	/// 	if let Ok(n) = network.notification_sender(peer, ...) {
+	/// 			if let Ok(s) = n.ready().await {
+	/// 				let _ = s.send(...);
+	/// 			}
+	/// 	}
+	/// }
+	/// ```
+	///
+	/// Doing so would slow down all peers to the rate of the slowest one. A malicious or
+	/// malfunctioning peer could intentionally process notifications at a very slow rate.
+	///
+	/// Instead, you are encouraged to maintain your own buffer of notifications on top of the one
+	/// maintained by `sc-network`, and use `notification_sender` to progressively send out
+	/// elements from your buffer. If this additional buffer is full (which will happen at some
+	/// point if the peer is too slow to process notifications), appropriate measures can be taken,
+	/// such as removing non-critical notifications from the buffer or disconnecting the peer
+	/// using [`NetworkPeers::disconnect_peer`].
+	///
+	///
+	/// Notifications              Per-peer buffer
+	///   broadcast    +------->   of notifications   +-->  `notification_sender`  +-->  Internet
+	///                    ^       (not covered by
+	///                    |         sc-network)
+	///                    +
+	///      Notifications should be dropped
+	///             if buffer is full
+	///
+	///
+	/// See also the `sc-network-gossip` crate for a higher-level way to send notifications.
+	fn notification_sender(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+	) -> Result<Box<dyn NotificationSender>, NotificationSenderError>;
+
+	/// Set handshake for the notification protocol.
+	fn set_notification_handshake(&self, protocol: ProtocolName, handshake: Vec<u8>);
+}
+
+impl<T> NetworkNotification for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkNotification,
+{
+	fn write_notification(&self, target: PeerId, protocol: ProtocolName, message: Vec<u8>) {
+		T::write_notification(self, target, protocol, message)
+	}
+
+	fn notification_sender(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+	) -> Result<Box<dyn NotificationSender>, NotificationSenderError> {
+		T::notification_sender(self, target, protocol)
+	}
+
+	fn set_notification_handshake(&self, protocol: ProtocolName, handshake: Vec<u8>) {
+		T::set_notification_handshake(self, protocol, handshake)
+	}
+}
+
+/// Provides ability to send network requests.
+#[async_trait::async_trait]
+pub trait NetworkRequest {
+	/// Sends a single targeted request to a specific peer. On success, returns the response of
+	/// the peer.
+	///
+	/// Request-response protocols are a way to complement notifications protocols, but
+	/// notifications should remain the default ways of communicating information. For example, a
+	/// peer can announce something through a notification, after which the recipient can obtain
+	/// more information by performing a request.
+	/// As such, call this function with `IfDisconnected::ImmediateError` for `connect`. This way
+	/// you will get an error immediately for disconnected peers, instead of waiting for a
+	/// potentially very long connection attempt, which would suggest that something is wrong
+	/// anyway, as you are supposed to be connected because of the notification protocol.
+	///
+	/// No limit or throttling of concurrent outbound requests per peer and protocol are enforced.
+	/// Such restrictions, if desired, need to be enforced at the call site(s).
+	///
+	/// The protocol must have been registered through
+	/// `NetworkConfiguration::request_response_protocols`.
+	async fn request(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		connect: IfDisconnected,
+	) -> Result<Vec<u8>, RequestFailure>;
+
+	/// Variation of `request` which starts a request whose response is delivered on a provided
+	/// channel.
+	///
+	/// Instead of blocking and waiting for a reply, this function returns immediately, sending
+	/// responses via the passed in sender. This alternative API exists to make it easier to
+	/// integrate with message passing APIs.
+	///
+	/// Keep in mind that the connected receiver might receive a `Canceled` event in case of a
+	/// closing connection. This is expected behaviour. With `request` you would get a
+	/// `RequestFailure::Network(OutboundFailure::ConnectionClosed)` in that case.
+	fn start_request(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		tx: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		connect: IfDisconnected,
+	);
+}
+
+// Manual implementation to avoid extra boxing here
+impl<T> NetworkRequest for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkRequest,
+{
+	fn request<'life0, 'async_trait>(
+		&'life0 self,
+		target: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		connect: IfDisconnected,
+	) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, RequestFailure>> + Send + 'async_trait>>
+	where
+		'life0: 'async_trait,
+		Self: 'async_trait,
+	{
+		T::request(self, target, protocol, request, connect)
+	}
+
+	fn start_request(
+		&self,
+		target: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		tx: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		connect: IfDisconnected,
+	) {
+		T::start_request(self, target, protocol, request, tx, connect)
+	}
+}
+
+/// Provides ability to announce blocks to the network.
+pub trait NetworkBlock<BlockHash, BlockNumber> {
+	/// Make sure an important block is propagated to peers.
+	///
+	/// In chain-based consensus, we often need to make sure non-best forks are
+	/// at least temporarily synced. This function forces such an announcement.
+	fn announce_block(&self, hash: BlockHash, data: Option<Vec<u8>>);
+
+	/// Inform the network service about new best imported block.
+	fn new_best_block_imported(&self, hash: BlockHash, number: BlockNumber);
+}
+
+impl<T, BlockHash, BlockNumber> NetworkBlock<BlockHash, BlockNumber> for Arc<T>
+where
+	T: ?Sized,
+	T: NetworkBlock<BlockHash, BlockNumber>,
+{
+	fn announce_block(&self, hash: BlockHash, data: Option<Vec<u8>>) {
+		T::announce_block(self, hash, data)
+	}
+
+	fn new_best_block_imported(&self, hash: BlockHash, number: BlockNumber) {
+		T::new_best_block_imported(self, hash, number)
+	}
+}
diff --git a/substrate/client/network/src/transport.rs b/substrate/client/network/src/transport.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4136b34fc0e8e728b4d1a96e3ad5d8517ee4b552
--- /dev/null
+++ b/substrate/client/network/src/transport.rs
@@ -0,0 +1,106 @@
+// 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/>.
+
+//! Transport that serves as a common ground for all connections.
+
+use either::Either;
+use libp2p::{
+	core::{
+		muxing::StreamMuxerBox,
+		transport::{Boxed, OptionalTransport},
+		upgrade,
+	},
+	dns, identity, noise, tcp, websocket, PeerId, Transport, TransportExt,
+};
+use std::{sync::Arc, time::Duration};
+
+pub use libp2p::bandwidth::BandwidthSinks;
+
+/// Builds the transport that serves as a common ground for all connections.
+///
+/// If `memory_only` is true, then only communication within the same process are allowed. Only
+/// addresses with the format `/memory/...` are allowed.
+///
+/// `yamux_window_size` is the maximum size of the Yamux receive windows. `None` to leave the
+/// default (256kiB).
+///
+/// `yamux_maximum_buffer_size` is the maximum allowed size of the Yamux buffer. This should be
+/// set either to the maximum of all the maximum allowed sizes of messages frames of all
+/// high-level protocols combined, or to some generously high value if you are sure that a maximum
+/// size is enforced on all high-level protocols.
+///
+/// Returns a `BandwidthSinks` object that allows querying the average bandwidth produced by all
+/// the connections spawned with this transport.
+pub fn build_transport(
+	keypair: identity::Keypair,
+	memory_only: bool,
+	yamux_window_size: Option<u32>,
+	yamux_maximum_buffer_size: usize,
+) -> (Boxed<(PeerId, StreamMuxerBox)>, Arc<BandwidthSinks>) {
+	// Build the base layer of the transport.
+	let transport = if !memory_only {
+		// Main transport: DNS(TCP)
+		let tcp_config = tcp::Config::new().nodelay(true);
+		let tcp_trans = tcp::tokio::Transport::new(tcp_config.clone());
+		let dns_init = dns::TokioDnsConfig::system(tcp_trans);
+
+		Either::Left(if let Ok(dns) = dns_init {
+			// WS + WSS transport
+			//
+			// Main transport can't be used for `/wss` addresses because WSS transport needs
+			// unresolved addresses (BUT WSS transport itself needs an instance of DNS transport to
+			// resolve and dial addresses).
+			let tcp_trans = tcp::tokio::Transport::new(tcp_config);
+			let dns_for_wss = dns::TokioDnsConfig::system(tcp_trans)
+				.expect("same system_conf & resolver to work");
+			Either::Left(websocket::WsConfig::new(dns_for_wss).or_transport(dns))
+		} else {
+			// In case DNS can't be constructed, fallback to TCP + WS (WSS won't work)
+			let tcp_trans = tcp::tokio::Transport::new(tcp_config.clone());
+			let desktop_trans = websocket::WsConfig::new(tcp_trans)
+				.or_transport(tcp::tokio::Transport::new(tcp_config));
+			Either::Right(desktop_trans)
+		})
+	} else {
+		Either::Right(OptionalTransport::some(libp2p::core::transport::MemoryTransport::default()))
+	};
+
+	let authentication_config = noise::Config::new(&keypair).expect("Can create noise config. qed");
+	let multiplexing_config = {
+		let mut yamux_config = libp2p::yamux::Config::default();
+		// Enable proper flow-control: window updates are only sent when
+		// buffered data has been consumed.
+		yamux_config.set_window_update_mode(libp2p::yamux::WindowUpdateMode::on_read());
+		yamux_config.set_max_buffer_size(yamux_maximum_buffer_size);
+
+		if let Some(yamux_window_size) = yamux_window_size {
+			yamux_config.set_receive_window_size(yamux_window_size);
+		}
+
+		yamux_config
+	};
+
+	let transport = transport
+		.upgrade(upgrade::Version::V1Lazy)
+		.authenticate(authentication_config)
+		.multiplex(multiplexing_config)
+		.timeout(Duration::from_secs(20))
+		.boxed();
+
+	transport.with_bandwidth_logging()
+}
diff --git a/substrate/client/network/src/types.rs b/substrate/client/network/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b0e32ae109149e2485c62d469c1b14624989ac03
--- /dev/null
+++ b/substrate/client/network/src/types.rs
@@ -0,0 +1,146 @@
+// 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/>.
+
+//! `sc-network` type definitions
+
+use libp2p::core::upgrade;
+
+use std::{
+	borrow::Borrow,
+	fmt,
+	hash::{Hash, Hasher},
+	ops::Deref,
+	sync::Arc,
+};
+
+/// The protocol name transmitted on the wire.
+#[derive(Debug, Clone)]
+pub enum ProtocolName {
+	/// The protocol name as a static string.
+	Static(&'static str),
+	/// The protocol name as a dynamically allocated string.
+	OnHeap(Arc<str>),
+}
+
+impl From<&'static str> for ProtocolName {
+	fn from(name: &'static str) -> Self {
+		Self::Static(name)
+	}
+}
+
+impl From<Arc<str>> for ProtocolName {
+	fn from(name: Arc<str>) -> Self {
+		Self::OnHeap(name)
+	}
+}
+
+impl From<String> for ProtocolName {
+	fn from(name: String) -> Self {
+		Self::OnHeap(Arc::from(name))
+	}
+}
+
+impl Deref for ProtocolName {
+	type Target = str;
+
+	fn deref(&self) -> &str {
+		match self {
+			Self::Static(name) => name,
+			Self::OnHeap(name) => &name,
+		}
+	}
+}
+
+impl Borrow<str> for ProtocolName {
+	fn borrow(&self) -> &str {
+		self
+	}
+}
+
+impl PartialEq for ProtocolName {
+	fn eq(&self, other: &Self) -> bool {
+		(self as &str) == (other as &str)
+	}
+}
+
+impl Eq for ProtocolName {}
+
+impl Hash for ProtocolName {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		(self as &str).hash(state)
+	}
+}
+
+impl fmt::Display for ProtocolName {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.write_str(self)
+	}
+}
+
+impl upgrade::ProtocolName for ProtocolName {
+	fn protocol_name(&self) -> &[u8] {
+		(self as &str).as_bytes()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::ProtocolName;
+	use std::{
+		borrow::Borrow,
+		collections::hash_map::DefaultHasher,
+		hash::{Hash, Hasher},
+	};
+
+	#[test]
+	fn protocol_name_keys_are_equivalent_to_str_keys() {
+		const PROTOCOL: &'static str = "/some/protocol/1";
+		let static_protocol_name = ProtocolName::from(PROTOCOL);
+		let on_heap_protocol_name = ProtocolName::from(String::from(PROTOCOL));
+
+		assert_eq!(<ProtocolName as Borrow<str>>::borrow(&static_protocol_name), PROTOCOL);
+		assert_eq!(<ProtocolName as Borrow<str>>::borrow(&on_heap_protocol_name), PROTOCOL);
+		assert_eq!(static_protocol_name, on_heap_protocol_name);
+
+		assert_eq!(hash(static_protocol_name), hash(PROTOCOL));
+		assert_eq!(hash(on_heap_protocol_name), hash(PROTOCOL));
+	}
+
+	#[test]
+	fn different_protocol_names_do_not_compare_equal() {
+		const PROTOCOL1: &'static str = "/some/protocol/1";
+		let static_protocol_name1 = ProtocolName::from(PROTOCOL1);
+		let on_heap_protocol_name1 = ProtocolName::from(String::from(PROTOCOL1));
+
+		const PROTOCOL2: &'static str = "/some/protocol/2";
+		let static_protocol_name2 = ProtocolName::from(PROTOCOL2);
+		let on_heap_protocol_name2 = ProtocolName::from(String::from(PROTOCOL2));
+
+		assert_ne!(<ProtocolName as Borrow<str>>::borrow(&static_protocol_name1), PROTOCOL2);
+		assert_ne!(<ProtocolName as Borrow<str>>::borrow(&on_heap_protocol_name1), PROTOCOL2);
+		assert_ne!(static_protocol_name1, static_protocol_name2);
+		assert_ne!(static_protocol_name1, on_heap_protocol_name2);
+		assert_ne!(on_heap_protocol_name1, on_heap_protocol_name2);
+	}
+
+	fn hash<T: Hash>(x: T) -> u64 {
+		let mut hasher = DefaultHasher::new();
+		x.hash(&mut hasher);
+		hasher.finish()
+	}
+}
diff --git a/substrate/client/network/src/utils.rs b/substrate/client/network/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8db2cf4e7920d8072f63300f6ebdfcf1889c9e13
--- /dev/null
+++ b/substrate/client/network/src/utils.rs
@@ -0,0 +1,88 @@
+// 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/>.
+
+//! `sc-network` utilities
+
+use futures::{stream::unfold, FutureExt, Stream, StreamExt};
+use futures_timer::Delay;
+use linked_hash_set::LinkedHashSet;
+
+use std::{hash::Hash, num::NonZeroUsize, time::Duration};
+
+/// Creates a stream that returns a new value every `duration`.
+pub fn interval(duration: Duration) -> impl Stream<Item = ()> + Unpin {
+	unfold((), move |_| Delay::new(duration).map(|_| Some(((), ())))).map(drop)
+}
+
+/// Wrapper around `LinkedHashSet` with bounded growth.
+///
+/// In the limit, for each element inserted the oldest existing element will be removed.
+#[derive(Debug, Clone)]
+pub struct LruHashSet<T: Hash + Eq> {
+	set: LinkedHashSet<T>,
+	limit: NonZeroUsize,
+}
+
+impl<T: Hash + Eq> LruHashSet<T> {
+	/// Create a new `LruHashSet` with the given (exclusive) limit.
+	pub fn new(limit: NonZeroUsize) -> Self {
+		Self { set: LinkedHashSet::new(), limit }
+	}
+
+	/// Insert element into the set.
+	///
+	/// Returns `true` if this is a new element to the set, `false` otherwise.
+	/// Maintains the limit of the set by removing the oldest entry if necessary.
+	/// Inserting the same element will update its LRU position.
+	pub fn insert(&mut self, e: T) -> bool {
+		if self.set.insert(e) {
+			if self.set.len() == usize::from(self.limit) {
+				self.set.pop_front(); // remove oldest entry
+			}
+			return true
+		}
+		false
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn maintains_limit() {
+		let three = NonZeroUsize::new(3).unwrap();
+		let mut set = LruHashSet::<u8>::new(three);
+
+		// First element.
+		assert!(set.insert(1));
+		assert_eq!(vec![&1], set.set.iter().collect::<Vec<_>>());
+
+		// Second element.
+		assert!(set.insert(2));
+		assert_eq!(vec![&1, &2], set.set.iter().collect::<Vec<_>>());
+
+		// Inserting the same element updates its LRU position.
+		assert!(!set.insert(1));
+		assert_eq!(vec![&2, &1], set.set.iter().collect::<Vec<_>>());
+
+		// We reached the limit. The next element forces the oldest one out.
+		assert!(set.insert(3));
+		assert_eq!(vec![&1, &3], set.set.iter().collect::<Vec<_>>());
+	}
+}
diff --git a/substrate/client/network/statement/Cargo.toml b/substrate/client/network/statement/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..63377710dc403e281d7761dcbd9e5e664a3e3130
--- /dev/null
+++ b/substrate/client/network/statement/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+description = "Substrate statement protocol"
+name = "sc-network-statement"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network-statement"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+async-channel = "1.8.0"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+futures = "0.3.21"
+libp2p = "0.51.3"
+log = "0.4.17"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-network-common = { version = "0.10.0-dev", path = "../common" }
+sc-network = { version = "0.10.0-dev", path = "../" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-statement-store = { version = "4.0.0-dev", path = "../../../primitives/statement-store" }
diff --git a/substrate/client/network/statement/src/config.rs b/substrate/client/network/statement/src/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..159998a0fe30008e775eea4710fcf5584f356874
--- /dev/null
+++ b/substrate/client/network/statement/src/config.rs
@@ -0,0 +1,33 @@
+// 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/>.
+
+//! Configuration of the statement protocol
+
+use std::time;
+
+/// Interval at which we propagate statements;
+pub(crate) const PROPAGATE_TIMEOUT: time::Duration = time::Duration::from_millis(1000);
+
+/// Maximum number of known statement hashes to keep for a peer.
+pub(crate) const MAX_KNOWN_STATEMENTS: usize = 10240;
+
+/// Maximum allowed size for a statement notification.
+pub(crate) const MAX_STATEMENT_SIZE: u64 = 256 * 1024;
+
+/// Maximum number of statement validation request we keep at any moment.
+pub(crate) const MAX_PENDING_STATEMENTS: usize = 8192;
diff --git a/substrate/client/network/statement/src/lib.rs b/substrate/client/network/statement/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c5d83b59b260ae7edb1bd1d93b8e7002cf97cb8b
--- /dev/null
+++ b/substrate/client/network/statement/src/lib.rs
@@ -0,0 +1,489 @@
+// 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/>.
+
+//! Statement handling to plug on top of the network service.
+//!
+//! Usage:
+//!
+//! - Use [`StatementHandlerPrototype::new`] to create a prototype.
+//! - Pass the return value of [`StatementHandlerPrototype::set_config`] to the network
+//! configuration as an extra peers set.
+//! - Use [`StatementHandlerPrototype::build`] then [`StatementHandler::run`] to obtain a
+//! `Future` that processes statements.
+
+use crate::config::*;
+use codec::{Decode, Encode};
+use futures::{channel::oneshot, prelude::*, stream::FuturesUnordered, FutureExt};
+use libp2p::{multiaddr, PeerId};
+use prometheus_endpoint::{register, Counter, PrometheusError, Registry, U64};
+use sc_network::{
+	config::{NonDefaultSetConfig, NonReservedPeerMode, SetConfig},
+	error,
+	event::Event,
+	types::ProtocolName,
+	utils::{interval, LruHashSet},
+	NetworkEventStream, NetworkNotification, NetworkPeers,
+};
+use sc_network_common::{
+	role::ObservedRole,
+	sync::{SyncEvent, SyncEventStream},
+};
+use sp_statement_store::{
+	Hash, NetworkPriority, Statement, StatementSource, StatementStore, SubmitResult,
+};
+use std::{
+	collections::{hash_map::Entry, HashMap, HashSet},
+	iter,
+	num::NonZeroUsize,
+	pin::Pin,
+	sync::Arc,
+};
+
+pub mod config;
+
+/// A set of statements.
+pub type Statements = Vec<Statement>;
+/// Future resolving to statement import result.
+pub type StatementImportFuture = oneshot::Receiver<SubmitResult>;
+
+mod rep {
+	use sc_network::ReputationChange as Rep;
+	/// Reputation change when a peer sends us any statement.
+	///
+	/// This forces node to verify it, thus the negative value here. Once statement is verified,
+	/// reputation change should be refunded with `ANY_STATEMENT_REFUND`
+	pub const ANY_STATEMENT: Rep = Rep::new(-(1 << 4), "Any statement");
+	/// Reputation change when a peer sends us any statement that is not invalid.
+	pub const ANY_STATEMENT_REFUND: Rep = Rep::new(1 << 4, "Any statement (refund)");
+	/// Reputation change when a peer sends us an statement that we didn't know about.
+	pub const GOOD_STATEMENT: Rep = Rep::new(1 << 7, "Good statement");
+	/// Reputation change when a peer sends us a bad statement.
+	pub const BAD_STATEMENT: Rep = Rep::new(-(1 << 12), "Bad statement");
+	/// Reputation change when a peer sends us a duplicate statement.
+	pub const DUPLICATE_STATEMENT: Rep = Rep::new(-(1 << 7), "Duplicate statement");
+	/// Reputation change when a peer sends us particularly useful statement
+	pub const EXCELLENT_STATEMENT: Rep = Rep::new(1 << 8, "High priority statement");
+}
+
+const LOG_TARGET: &str = "statement-gossip";
+
+struct Metrics {
+	propagated_statements: Counter<U64>,
+}
+
+impl Metrics {
+	fn register(r: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			propagated_statements: register(
+				Counter::new(
+					"substrate_sync_propagated_statements",
+					"Number of statements propagated to at least one peer",
+				)?,
+				r,
+			)?,
+		})
+	}
+}
+
+/// Prototype for a [`StatementHandler`].
+pub struct StatementHandlerPrototype {
+	protocol_name: ProtocolName,
+}
+
+impl StatementHandlerPrototype {
+	/// Create a new instance.
+	pub fn new<Hash: AsRef<[u8]>>(genesis_hash: Hash, fork_id: Option<&str>) -> Self {
+		let genesis_hash = genesis_hash.as_ref();
+		let protocol_name = if let Some(fork_id) = fork_id {
+			format!("/{}/{}/statement/1", array_bytes::bytes2hex("", genesis_hash), fork_id)
+		} else {
+			format!("/{}/statement/1", array_bytes::bytes2hex("", genesis_hash))
+		};
+
+		Self { protocol_name: protocol_name.into() }
+	}
+
+	/// Returns the configuration of the set to put in the network configuration.
+	pub fn set_config(&self) -> NonDefaultSetConfig {
+		NonDefaultSetConfig {
+			notifications_protocol: self.protocol_name.clone(),
+			fallback_names: Vec::new(),
+			max_notification_size: MAX_STATEMENT_SIZE,
+			handshake: None,
+			set_config: SetConfig {
+				in_peers: 0,
+				out_peers: 0,
+				reserved_nodes: Vec::new(),
+				non_reserved_mode: NonReservedPeerMode::Deny,
+			},
+		}
+	}
+
+	/// Turns the prototype into the actual handler.
+	///
+	/// Important: the statements handler is initially disabled and doesn't gossip statements.
+	/// Gossiping is enabled when major syncing is done.
+	pub fn build<
+		N: NetworkPeers + NetworkEventStream + NetworkNotification,
+		S: SyncEventStream + sp_consensus::SyncOracle,
+	>(
+		self,
+		network: N,
+		sync: S,
+		statement_store: Arc<dyn StatementStore>,
+		metrics_registry: Option<&Registry>,
+		executor: impl Fn(Pin<Box<dyn Future<Output = ()> + Send>>) + Send,
+	) -> error::Result<StatementHandler<N, S>> {
+		let net_event_stream = network.event_stream("statement-handler-net");
+		let sync_event_stream = sync.event_stream("statement-handler-sync");
+		let (queue_sender, mut queue_receiver) = async_channel::bounded(100_000);
+
+		let store = statement_store.clone();
+		executor(
+			async move {
+				loop {
+					let task: Option<(Statement, oneshot::Sender<SubmitResult>)> =
+						queue_receiver.next().await;
+					match task {
+						None => return,
+						Some((statement, completion)) => {
+							let result = store.submit(statement, StatementSource::Network);
+							if completion.send(result).is_err() {
+								log::debug!(
+									target: LOG_TARGET,
+									"Error sending validation completion"
+								);
+							}
+						},
+					}
+				}
+			}
+			.boxed(),
+		);
+
+		let handler = StatementHandler {
+			protocol_name: self.protocol_name,
+			propagate_timeout: (Box::pin(interval(PROPAGATE_TIMEOUT))
+				as Pin<Box<dyn Stream<Item = ()> + Send>>)
+				.fuse(),
+			pending_statements: FuturesUnordered::new(),
+			pending_statements_peers: HashMap::new(),
+			network,
+			sync,
+			net_event_stream: net_event_stream.fuse(),
+			sync_event_stream: sync_event_stream.fuse(),
+			peers: HashMap::new(),
+			statement_store,
+			queue_sender,
+			metrics: if let Some(r) = metrics_registry {
+				Some(Metrics::register(r)?)
+			} else {
+				None
+			},
+		};
+
+		Ok(handler)
+	}
+}
+
+/// Handler for statements. Call [`StatementHandler::run`] to start the processing.
+pub struct StatementHandler<
+	N: NetworkPeers + NetworkEventStream + NetworkNotification,
+	S: SyncEventStream + sp_consensus::SyncOracle,
+> {
+	protocol_name: ProtocolName,
+	/// Interval at which we call `propagate_statements`.
+	propagate_timeout: stream::Fuse<Pin<Box<dyn Stream<Item = ()> + Send>>>,
+	/// Pending statements verification tasks.
+	pending_statements:
+		FuturesUnordered<Pin<Box<dyn Future<Output = (Hash, Option<SubmitResult>)> + Send>>>,
+	/// As multiple peers can send us the same statement, we group
+	/// these peers using the statement hash while the statement is
+	/// imported. This prevents that we import the same statement
+	/// multiple times concurrently.
+	pending_statements_peers: HashMap<Hash, HashSet<PeerId>>,
+	/// Network service to use to send messages and manage peers.
+	network: N,
+	/// Syncing service.
+	sync: S,
+	/// Stream of networking events.
+	net_event_stream: stream::Fuse<Pin<Box<dyn Stream<Item = Event> + Send>>>,
+	/// Receiver for syncing-related events.
+	sync_event_stream: stream::Fuse<Pin<Box<dyn Stream<Item = SyncEvent> + Send>>>,
+	// All connected peers
+	peers: HashMap<PeerId, Peer>,
+	statement_store: Arc<dyn StatementStore>,
+	queue_sender: async_channel::Sender<(Statement, oneshot::Sender<SubmitResult>)>,
+	/// Prometheus metrics.
+	metrics: Option<Metrics>,
+}
+
+/// Peer information
+#[derive(Debug)]
+struct Peer {
+	/// Holds a set of statements known to this peer.
+	known_statements: LruHashSet<Hash>,
+	role: ObservedRole,
+}
+
+impl<N, S> StatementHandler<N, S>
+where
+	N: NetworkPeers + NetworkEventStream + NetworkNotification,
+	S: SyncEventStream + sp_consensus::SyncOracle,
+{
+	/// Turns the [`StatementHandler`] into a future that should run forever and not be
+	/// interrupted.
+	pub async fn run(mut self) {
+		loop {
+			futures::select! {
+				_ = self.propagate_timeout.next() => {
+					self.propagate_statements();
+				},
+				(hash, result) = self.pending_statements.select_next_some() => {
+					if let Some(peers) = self.pending_statements_peers.remove(&hash) {
+						if let Some(result) = result {
+							peers.into_iter().for_each(|p| self.on_handle_statement_import(p, &result));
+						}
+					} else {
+						log::warn!(target: LOG_TARGET, "Inconsistent state, no peers for pending statement!");
+					}
+				},
+				network_event = self.net_event_stream.next() => {
+					if let Some(network_event) = network_event {
+						self.handle_network_event(network_event).await;
+					} else {
+						// Networking has seemingly closed. Closing as well.
+						return;
+					}
+				},
+				sync_event = self.sync_event_stream.next() => {
+					if let Some(sync_event) = sync_event {
+						self.handle_sync_event(sync_event);
+					} else {
+						// Syncing has seemingly closed. Closing as well.
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	fn handle_sync_event(&mut self, event: SyncEvent) {
+		match event {
+			SyncEvent::PeerConnected(remote) => {
+				let addr = iter::once(multiaddr::Protocol::P2p(remote.into()))
+					.collect::<multiaddr::Multiaddr>();
+				let result = self.network.add_peers_to_reserved_set(
+					self.protocol_name.clone(),
+					iter::once(addr).collect(),
+				);
+				if let Err(err) = result {
+					log::error!(target: LOG_TARGET, "Add reserved peer failed: {}", err);
+				}
+			},
+			SyncEvent::PeerDisconnected(remote) => {
+				let result = self.network.remove_peers_from_reserved_set(
+					self.protocol_name.clone(),
+					iter::once(remote).collect(),
+				);
+				if let Err(err) = result {
+					log::error!(target: LOG_TARGET, "Failed to remove reserved peer: {err}");
+				}
+			},
+		}
+	}
+
+	async fn handle_network_event(&mut self, event: Event) {
+		match event {
+			Event::Dht(_) => {},
+			Event::NotificationStreamOpened { remote, protocol, role, .. }
+				if protocol == self.protocol_name =>
+			{
+				let _was_in = self.peers.insert(
+					remote,
+					Peer {
+						known_statements: LruHashSet::new(
+							NonZeroUsize::new(MAX_KNOWN_STATEMENTS).expect("Constant is nonzero"),
+						),
+						role,
+					},
+				);
+				debug_assert!(_was_in.is_none());
+			},
+			Event::NotificationStreamClosed { remote, protocol }
+				if protocol == self.protocol_name =>
+			{
+				let _peer = self.peers.remove(&remote);
+				debug_assert!(_peer.is_some());
+			},
+
+			Event::NotificationsReceived { remote, messages } => {
+				for (protocol, message) in messages {
+					if protocol != self.protocol_name {
+						continue
+					}
+					// Accept statements only when node is not major syncing
+					if self.sync.is_major_syncing() {
+						log::trace!(
+							target: LOG_TARGET,
+							"{remote}: Ignoring statements while major syncing or offline"
+						);
+						continue
+					}
+					if let Ok(statements) = <Statements as Decode>::decode(&mut message.as_ref()) {
+						self.on_statements(remote, statements);
+					} else {
+						log::debug!(
+							target: LOG_TARGET,
+							"Failed to decode statement list from {remote}"
+						);
+					}
+				}
+			},
+
+			// Not our concern.
+			Event::NotificationStreamOpened { .. } | Event::NotificationStreamClosed { .. } => {},
+		}
+	}
+
+	/// Called when peer sends us new statements
+	fn on_statements(&mut self, who: PeerId, statements: Statements) {
+		log::trace!(target: LOG_TARGET, "Received {} statements from {}", statements.len(), who);
+		if let Some(ref mut peer) = self.peers.get_mut(&who) {
+			for s in statements {
+				if self.pending_statements.len() > MAX_PENDING_STATEMENTS {
+					log::debug!(
+						target: LOG_TARGET,
+						"Ignoring any further statements that exceed `MAX_PENDING_STATEMENTS`({}) limit",
+						MAX_PENDING_STATEMENTS,
+					);
+					break
+				}
+
+				let hash = s.hash();
+				peer.known_statements.insert(hash);
+
+				self.network.report_peer(who, rep::ANY_STATEMENT);
+
+				match self.pending_statements_peers.entry(hash) {
+					Entry::Vacant(entry) => {
+						let (completion_sender, completion_receiver) = oneshot::channel();
+						match self.queue_sender.try_send((s, completion_sender)) {
+							Ok(()) => {
+								self.pending_statements.push(
+									async move {
+										let res = completion_receiver.await;
+										(hash, res.ok())
+									}
+									.boxed(),
+								);
+								entry.insert(HashSet::from_iter([who]));
+							},
+							Err(async_channel::TrySendError::Full(_)) => {
+								log::debug!(
+									target: LOG_TARGET,
+									"Dropped statement because validation channel is full",
+								);
+							},
+							Err(async_channel::TrySendError::Closed(_)) => {
+								log::trace!(
+									target: LOG_TARGET,
+									"Dropped statement because validation channel is closed",
+								);
+							},
+						}
+					},
+					Entry::Occupied(mut entry) => {
+						if !entry.get_mut().insert(who) {
+							// Already received this from the same peer.
+							self.network.report_peer(who, rep::DUPLICATE_STATEMENT);
+						}
+					},
+				}
+			}
+		}
+	}
+
+	fn on_handle_statement_import(&mut self, who: PeerId, import: &SubmitResult) {
+		match import {
+			SubmitResult::New(NetworkPriority::High) =>
+				self.network.report_peer(who, rep::EXCELLENT_STATEMENT),
+			SubmitResult::New(NetworkPriority::Low) =>
+				self.network.report_peer(who, rep::GOOD_STATEMENT),
+			SubmitResult::Known => self.network.report_peer(who, rep::ANY_STATEMENT_REFUND),
+			SubmitResult::KnownExpired => {},
+			SubmitResult::Ignored => {},
+			SubmitResult::Bad(_) => self.network.report_peer(who, rep::BAD_STATEMENT),
+			SubmitResult::InternalError(_) => {},
+		}
+	}
+
+	/// Propagate one statement.
+	pub fn propagate_statement(&mut self, hash: &Hash) {
+		// Accept statements only when node is not major syncing
+		if self.sync.is_major_syncing() {
+			return
+		}
+
+		log::debug!(target: LOG_TARGET, "Propagating statement [{:?}]", hash);
+		if let Ok(Some(statement)) = self.statement_store.statement(hash) {
+			self.do_propagate_statements(&[(*hash, statement)]);
+		}
+	}
+
+	fn do_propagate_statements(&mut self, statements: &[(Hash, Statement)]) {
+		let mut propagated_statements = 0;
+
+		for (who, peer) in self.peers.iter_mut() {
+			// never send statements to light nodes
+			if matches!(peer.role, ObservedRole::Light) {
+				continue
+			}
+
+			let to_send = statements
+				.iter()
+				.filter_map(|(hash, stmt)| peer.known_statements.insert(*hash).then(|| stmt))
+				.collect::<Vec<_>>();
+
+			propagated_statements += to_send.len();
+
+			if !to_send.is_empty() {
+				log::trace!(target: LOG_TARGET, "Sending {} statements to {}", to_send.len(), who);
+				self.network
+					.write_notification(*who, self.protocol_name.clone(), to_send.encode());
+			}
+		}
+
+		if let Some(ref metrics) = self.metrics {
+			metrics.propagated_statements.inc_by(propagated_statements as _)
+		}
+	}
+
+	/// Call when we must propagate ready statements to peers.
+	fn propagate_statements(&mut self) {
+		// Send out statements only when node is not major syncing
+		if self.sync.is_major_syncing() {
+			return
+		}
+
+		log::debug!(target: LOG_TARGET, "Propagating statements");
+		if let Ok(statements) = self.statement_store.statements() {
+			self.do_propagate_statements(&statements);
+		}
+	}
+}
diff --git a/substrate/client/network/sync/Cargo.toml b/substrate/client/network/sync/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8c02a4f1ec15f93692c261fcf5fd09005448eab0
--- /dev/null
+++ b/substrate/client/network/sync/Cargo.toml
@@ -0,0 +1,52 @@
+[package]
+description = "Substrate sync network protocol"
+name = "sc-network-sync"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network-sync"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[build-dependencies]
+prost-build = "0.11"
+
+[dependencies]
+array-bytes = "6.1"
+async-channel = "1.8.0"
+async-trait = "0.1.58"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+futures = "0.3.21"
+futures-timer = "3.0.2"
+libp2p = "0.51.3"
+log = "0.4.17"
+mockall = "0.11.3"
+prost = "0.11"
+schnellru = "0.2.1"
+smallvec = "1.11.0"
+thiserror = "1.0"
+fork-tree = { version = "3.0.0", path = "../../../utils/fork-tree" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
+sc-network = { version = "0.10.0-dev", path = "../" }
+sc-network-common = { version = "0.10.0-dev", path = "../common" }
+sc-utils = { version = "4.0.0-dev", path = "../../utils" }
+sp-arithmetic = { version = "16.0.0", path = "../../../primitives/arithmetic" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-consensus-grandpa = { version = "4.0.0-dev", path = "../../../primitives/consensus/grandpa" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+tokio = { version = "1.22.0", features = ["macros"] }
+quickcheck = { version = "1.0.3", default-features = false }
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sp-test-primitives = { version = "2.0.0", path = "../../../primitives/test-primitives" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/client/network/sync/build.rs b/substrate/client/network/sync/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..55794919cdb42881975eb3d3911e8f7cfe9074a6
--- /dev/null
+++ b/substrate/client/network/sync/build.rs
@@ -0,0 +1,5 @@
+const PROTOS: &[&str] = &["src/schema/api.v1.proto"];
+
+fn main() {
+	prost_build::compile_protos(PROTOS, &["src/schema"]).unwrap();
+}
diff --git a/substrate/client/network/sync/src/block_request_handler.rs b/substrate/client/network/sync/src/block_request_handler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..291157eae4b07699572b2a66136f90dd4b33e1a8
--- /dev/null
+++ b/substrate/client/network/sync/src/block_request_handler.rs
@@ -0,0 +1,467 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Helper for handling (i.e. answering) block requests from a remote peer via the
+//! `crate::request_responses::RequestResponsesBehaviour`.
+
+use crate::{
+	schema::v1::{block_request::FromBlock, BlockResponse, Direction},
+	MAX_BLOCKS_IN_RESPONSE,
+};
+
+use codec::{Decode, Encode};
+use futures::{channel::oneshot, stream::StreamExt};
+use libp2p::PeerId;
+use log::debug;
+use prost::Message;
+use schnellru::{ByLength, LruMap};
+
+use sc_client_api::BlockBackend;
+use sc_network::{
+	config::ProtocolId,
+	request_responses::{IncomingRequest, OutgoingResponse, ProtocolConfig},
+};
+use sc_network_common::sync::message::BlockAttributes;
+use sp_blockchain::HeaderBackend;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header, One, Zero},
+};
+
+use std::{
+	cmp::min,
+	hash::{Hash, Hasher},
+	sync::Arc,
+	time::Duration,
+};
+
+const LOG_TARGET: &str = "sync";
+const MAX_BODY_BYTES: usize = 8 * 1024 * 1024;
+const MAX_NUMBER_OF_SAME_REQUESTS_PER_PEER: usize = 2;
+
+mod rep {
+	use sc_network::ReputationChange as Rep;
+
+	/// Reputation change when a peer sent us the same request multiple times.
+	pub const SAME_REQUEST: Rep = Rep::new_fatal("Same block request multiple times");
+
+	/// Reputation change when a peer sent us the same "small" request multiple times.
+	pub const SAME_SMALL_REQUEST: Rep =
+		Rep::new(-(1 << 10), "same small block request multiple times");
+}
+
+/// Generates a [`ProtocolConfig`] for the block request protocol, refusing incoming requests.
+pub fn generate_protocol_config<Hash: AsRef<[u8]>>(
+	protocol_id: &ProtocolId,
+	genesis_hash: Hash,
+	fork_id: Option<&str>,
+) -> ProtocolConfig {
+	ProtocolConfig {
+		name: generate_protocol_name(genesis_hash, fork_id).into(),
+		fallback_names: std::iter::once(generate_legacy_protocol_name(protocol_id).into())
+			.collect(),
+		max_request_size: 1024 * 1024,
+		max_response_size: 16 * 1024 * 1024,
+		request_timeout: Duration::from_secs(20),
+		inbound_queue: None,
+	}
+}
+
+/// Generate the block protocol name from the genesis hash and fork id.
+fn generate_protocol_name<Hash: AsRef<[u8]>>(genesis_hash: Hash, fork_id: Option<&str>) -> String {
+	let genesis_hash = genesis_hash.as_ref();
+	if let Some(fork_id) = fork_id {
+		format!("/{}/{}/sync/2", array_bytes::bytes2hex("", genesis_hash), fork_id)
+	} else {
+		format!("/{}/sync/2", array_bytes::bytes2hex("", genesis_hash))
+	}
+}
+
+/// Generate the legacy block protocol name from chain specific protocol identifier.
+fn generate_legacy_protocol_name(protocol_id: &ProtocolId) -> String {
+	format!("/{}/sync/2", protocol_id.as_ref())
+}
+
+/// The key of [`BlockRequestHandler::seen_requests`].
+#[derive(Eq, PartialEq, Clone)]
+struct SeenRequestsKey<B: BlockT> {
+	peer: PeerId,
+	from: BlockId<B>,
+	max_blocks: usize,
+	direction: Direction,
+	attributes: BlockAttributes,
+	support_multiple_justifications: bool,
+}
+
+#[allow(clippy::derived_hash_with_manual_eq)]
+impl<B: BlockT> Hash for SeenRequestsKey<B> {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		self.peer.hash(state);
+		self.max_blocks.hash(state);
+		self.direction.hash(state);
+		self.attributes.hash(state);
+		self.support_multiple_justifications.hash(state);
+		match self.from {
+			BlockId::Hash(h) => h.hash(state),
+			BlockId::Number(n) => n.hash(state),
+		}
+	}
+}
+
+/// The value of [`BlockRequestHandler::seen_requests`].
+enum SeenRequestsValue {
+	/// First time we have seen the request.
+	First,
+	/// We have fulfilled the request `n` times.
+	Fulfilled(usize),
+}
+
+/// Handler for incoming block requests from a remote peer.
+pub struct BlockRequestHandler<B: BlockT, Client> {
+	client: Arc<Client>,
+	request_receiver: async_channel::Receiver<IncomingRequest>,
+	/// Maps from request to number of times we have seen this request.
+	///
+	/// This is used to check if a peer is spamming us with the same request.
+	seen_requests: LruMap<SeenRequestsKey<B>, SeenRequestsValue>,
+}
+
+impl<B, Client> BlockRequestHandler<B, Client>
+where
+	B: BlockT,
+	Client: HeaderBackend<B> + BlockBackend<B> + Send + Sync + 'static,
+{
+	/// Create a new [`BlockRequestHandler`].
+	pub fn new(
+		protocol_id: &ProtocolId,
+		fork_id: Option<&str>,
+		client: Arc<Client>,
+		num_peer_hint: usize,
+	) -> (Self, ProtocolConfig) {
+		// Reserve enough request slots for one request per peer when we are at the maximum
+		// number of peers.
+		let capacity = std::cmp::max(num_peer_hint, 1);
+		let (tx, request_receiver) = async_channel::bounded(capacity);
+
+		let mut protocol_config = generate_protocol_config(
+			protocol_id,
+			client
+				.block_hash(0u32.into())
+				.ok()
+				.flatten()
+				.expect("Genesis block exists; qed"),
+			fork_id,
+		);
+		protocol_config.inbound_queue = Some(tx);
+
+		let capacity = ByLength::new(num_peer_hint.max(1) as u32 * 2);
+		let seen_requests = LruMap::new(capacity);
+
+		(Self { client, request_receiver, seen_requests }, protocol_config)
+	}
+
+	/// Run [`BlockRequestHandler`].
+	pub async fn run(mut self) {
+		while let Some(request) = self.request_receiver.next().await {
+			let IncomingRequest { peer, payload, pending_response } = request;
+
+			match self.handle_request(payload, pending_response, &peer) {
+				Ok(()) => debug!(target: LOG_TARGET, "Handled block request from {}.", peer),
+				Err(e) => debug!(
+					target: LOG_TARGET,
+					"Failed to handle block request from {}: {}", peer, e,
+				),
+			}
+		}
+	}
+
+	fn handle_request(
+		&mut self,
+		payload: Vec<u8>,
+		pending_response: oneshot::Sender<OutgoingResponse>,
+		peer: &PeerId,
+	) -> Result<(), HandleRequestError> {
+		let request = crate::schema::v1::BlockRequest::decode(&payload[..])?;
+
+		let from_block_id = match request.from_block.ok_or(HandleRequestError::MissingFromField)? {
+			FromBlock::Hash(ref h) => {
+				let h = Decode::decode(&mut h.as_ref())?;
+				BlockId::<B>::Hash(h)
+			},
+			FromBlock::Number(ref n) => {
+				let n = Decode::decode(&mut n.as_ref())?;
+				BlockId::<B>::Number(n)
+			},
+		};
+
+		let max_blocks = if request.max_blocks == 0 {
+			MAX_BLOCKS_IN_RESPONSE
+		} else {
+			min(request.max_blocks as usize, MAX_BLOCKS_IN_RESPONSE)
+		};
+
+		let direction =
+			Direction::from_i32(request.direction).ok_or(HandleRequestError::ParseDirection)?;
+
+		let attributes = BlockAttributes::from_be_u32(request.fields)?;
+
+		let support_multiple_justifications = request.support_multiple_justifications;
+
+		let key = SeenRequestsKey {
+			peer: *peer,
+			max_blocks,
+			direction,
+			from: from_block_id,
+			attributes,
+			support_multiple_justifications,
+		};
+
+		let mut reputation_change = None;
+
+		let small_request = attributes
+			.difference(BlockAttributes::HEADER | BlockAttributes::JUSTIFICATION)
+			.is_empty();
+
+		match self.seen_requests.get(&key) {
+			Some(SeenRequestsValue::First) => {},
+			Some(SeenRequestsValue::Fulfilled(ref mut requests)) => {
+				*requests = requests.saturating_add(1);
+
+				if *requests > MAX_NUMBER_OF_SAME_REQUESTS_PER_PEER {
+					reputation_change = Some(if small_request {
+						rep::SAME_SMALL_REQUEST
+					} else {
+						rep::SAME_REQUEST
+					});
+				}
+			},
+			None => {
+				self.seen_requests.insert(key.clone(), SeenRequestsValue::First);
+			},
+		}
+
+		debug!(
+			target: LOG_TARGET,
+			"Handling block request from {peer}: Starting at `{from_block_id:?}` with \
+			maximum blocks of `{max_blocks}`, reputation_change: `{reputation_change:?}`, \
+			small_request `{small_request:?}`, direction `{direction:?}` and \
+			attributes `{attributes:?}`.",
+		);
+
+		let maybe_block_response = if reputation_change.is_none() || small_request {
+			let block_response = self.get_block_response(
+				attributes,
+				from_block_id,
+				direction,
+				max_blocks,
+				support_multiple_justifications,
+			)?;
+
+			// If any of the blocks contains any data, we can consider it as successful request.
+			if block_response
+				.blocks
+				.iter()
+				.any(|b| !b.header.is_empty() || !b.body.is_empty() || b.is_empty_justification)
+			{
+				if let Some(value) = self.seen_requests.get(&key) {
+					// If this is the first time we have processed this request, we need to change
+					// it to `Fulfilled`.
+					if let SeenRequestsValue::First = value {
+						*value = SeenRequestsValue::Fulfilled(1);
+					}
+				}
+			}
+
+			Some(block_response)
+		} else {
+			None
+		};
+
+		debug!(
+			target: LOG_TARGET,
+			"Sending result of block request from {peer} starting at `{from_block_id:?}`: \
+			blocks: {:?}, data: {:?}",
+			maybe_block_response.as_ref().map(|res| res.blocks.len()),
+			maybe_block_response.as_ref().map(|res| res.encoded_len()),
+		);
+
+		let result = if let Some(block_response) = maybe_block_response {
+			let mut data = Vec::with_capacity(block_response.encoded_len());
+			block_response.encode(&mut data)?;
+			Ok(data)
+		} else {
+			Err(())
+		};
+
+		pending_response
+			.send(OutgoingResponse {
+				result,
+				reputation_changes: reputation_change.into_iter().collect(),
+				sent_feedback: None,
+			})
+			.map_err(|_| HandleRequestError::SendResponse)
+	}
+
+	fn get_block_response(
+		&self,
+		attributes: BlockAttributes,
+		mut block_id: BlockId<B>,
+		direction: Direction,
+		max_blocks: usize,
+		support_multiple_justifications: bool,
+	) -> Result<BlockResponse, HandleRequestError> {
+		let get_header = attributes.contains(BlockAttributes::HEADER);
+		let get_body = attributes.contains(BlockAttributes::BODY);
+		let get_indexed_body = attributes.contains(BlockAttributes::INDEXED_BODY);
+		let get_justification = attributes.contains(BlockAttributes::JUSTIFICATION);
+
+		let mut blocks = Vec::new();
+
+		let mut total_size: usize = 0;
+
+		let client_header_from_block_id =
+			|block_id: BlockId<B>| -> Result<Option<B::Header>, HandleRequestError> {
+				if let Some(hash) = self.client.block_hash_from_id(&block_id)? {
+					return self.client.header(hash).map_err(Into::into)
+				}
+				Ok(None)
+			};
+
+		while let Some(header) = client_header_from_block_id(block_id).unwrap_or_default() {
+			let number = *header.number();
+			let hash = header.hash();
+			let parent_hash = *header.parent_hash();
+			let justifications =
+				if get_justification { self.client.justifications(hash)? } else { None };
+
+			let (justifications, justification, is_empty_justification) =
+				if support_multiple_justifications {
+					let justifications = match justifications {
+						Some(v) => v.encode(),
+						None => Vec::new(),
+					};
+					(justifications, Vec::new(), false)
+				} else {
+					// For now we keep compatibility by selecting precisely the GRANDPA one, and not
+					// just the first one. When sending we could have just taken the first one,
+					// since we don't expect there to be any other kind currently, but when
+					// receiving we need to add the engine ID tag.
+					// The ID tag is hardcoded here to avoid depending on the GRANDPA crate, and
+					// will be removed once we remove the backwards compatibility.
+					// See: https://github.com/paritytech/substrate/issues/8172
+					let justification =
+						justifications.and_then(|just| just.into_justification(*b"FRNK"));
+
+					let is_empty_justification =
+						justification.as_ref().map(|j| j.is_empty()).unwrap_or(false);
+
+					let justification = justification.unwrap_or_default();
+
+					(Vec::new(), justification, is_empty_justification)
+				};
+
+			let body = if get_body {
+				match self.client.block_body(hash)? {
+					Some(mut extrinsics) =>
+						extrinsics.iter_mut().map(|extrinsic| extrinsic.encode()).collect(),
+					None => {
+						log::trace!(target: LOG_TARGET, "Missing data for block request.");
+						break
+					},
+				}
+			} else {
+				Vec::new()
+			};
+
+			let indexed_body = if get_indexed_body {
+				match self.client.block_indexed_body(hash)? {
+					Some(transactions) => transactions,
+					None => {
+						log::trace!(
+							target: LOG_TARGET,
+							"Missing indexed block data for block request."
+						);
+						// If the indexed body is missing we still continue returning headers.
+						// Ideally `None` should distinguish a missing body from the empty body,
+						// but the current protobuf based protocol does not allow it.
+						Vec::new()
+					},
+				}
+			} else {
+				Vec::new()
+			};
+
+			let block_data = crate::schema::v1::BlockData {
+				hash: hash.encode(),
+				header: if get_header { header.encode() } else { Vec::new() },
+				body,
+				receipt: Vec::new(),
+				message_queue: Vec::new(),
+				justification,
+				is_empty_justification,
+				justifications,
+				indexed_body,
+			};
+
+			let new_total_size = total_size +
+				block_data.body.iter().map(|ex| ex.len()).sum::<usize>() +
+				block_data.indexed_body.iter().map(|ex| ex.len()).sum::<usize>();
+
+			// Send at least one block, but make sure to not exceed the limit.
+			if !blocks.is_empty() && new_total_size > MAX_BODY_BYTES {
+				break
+			}
+
+			total_size = new_total_size;
+
+			blocks.push(block_data);
+
+			if blocks.len() >= max_blocks as usize {
+				break
+			}
+
+			match direction {
+				Direction::Ascending => block_id = BlockId::Number(number + One::one()),
+				Direction::Descending => {
+					if number.is_zero() {
+						break
+					}
+					block_id = BlockId::Hash(parent_hash)
+				},
+			}
+		}
+
+		Ok(BlockResponse { blocks })
+	}
+}
+
+#[derive(Debug, thiserror::Error)]
+enum HandleRequestError {
+	#[error("Failed to decode request: {0}.")]
+	DecodeProto(#[from] prost::DecodeError),
+	#[error("Failed to encode response: {0}.")]
+	EncodeProto(#[from] prost::EncodeError),
+	#[error("Failed to decode block hash: {0}.")]
+	DecodeScale(#[from] codec::Error),
+	#[error("Missing `BlockRequest::from_block` field.")]
+	MissingFromField,
+	#[error("Failed to parse BlockRequest::direction.")]
+	ParseDirection,
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+	#[error("Failed to send response.")]
+	SendResponse,
+}
diff --git a/substrate/client/network/sync/src/blocks.rs b/substrate/client/network/sync/src/blocks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..240c1ca1f8b26aba92f2d8db53be9684d69fee5d
--- /dev/null
+++ b/substrate/client/network/sync/src/blocks.rs
@@ -0,0 +1,434 @@
+// 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 libp2p::PeerId;
+use log::trace;
+use sc_network_common::sync::message;
+use sp_runtime::traits::{Block as BlockT, NumberFor, One};
+use std::{
+	cmp,
+	collections::{BTreeMap, HashMap},
+	ops::Range,
+};
+
+/// Block data with origin.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockData<B: BlockT> {
+	/// The Block Message from the wire
+	pub block: message::BlockData<B>,
+	/// The peer, we received this from
+	pub origin: Option<PeerId>,
+}
+
+#[derive(Debug)]
+enum BlockRangeState<B: BlockT> {
+	Downloading { len: NumberFor<B>, downloading: u32 },
+	Complete(Vec<BlockData<B>>),
+	Queued { len: NumberFor<B> },
+}
+
+impl<B: BlockT> BlockRangeState<B> {
+	pub fn len(&self) -> NumberFor<B> {
+		match *self {
+			Self::Downloading { len, .. } => len,
+			Self::Complete(ref blocks) => (blocks.len() as u32).into(),
+			Self::Queued { len } => len,
+		}
+	}
+}
+
+/// A collection of blocks being downloaded.
+#[derive(Default)]
+pub struct BlockCollection<B: BlockT> {
+	/// Downloaded blocks.
+	blocks: BTreeMap<NumberFor<B>, BlockRangeState<B>>,
+	peer_requests: HashMap<PeerId, NumberFor<B>>,
+	/// Block ranges downloaded and queued for import.
+	/// Maps start_hash => (start_num, end_num).
+	queued_blocks: HashMap<B::Hash, (NumberFor<B>, NumberFor<B>)>,
+}
+
+impl<B: BlockT> BlockCollection<B> {
+	/// Create a new instance.
+	pub fn new() -> Self {
+		Self {
+			blocks: BTreeMap::new(),
+			peer_requests: HashMap::new(),
+			queued_blocks: HashMap::new(),
+		}
+	}
+
+	/// Clear everything.
+	pub fn clear(&mut self) {
+		self.blocks.clear();
+		self.peer_requests.clear();
+	}
+
+	/// Insert a set of blocks into collection.
+	pub fn insert(&mut self, start: NumberFor<B>, blocks: Vec<message::BlockData<B>>, who: PeerId) {
+		if blocks.is_empty() {
+			return
+		}
+
+		match self.blocks.get(&start) {
+			Some(&BlockRangeState::Downloading { .. }) => {
+				trace!(target: "sync", "Inserting block data still marked as being downloaded: {}", start);
+			},
+			Some(BlockRangeState::Complete(existing)) if existing.len() >= blocks.len() => {
+				trace!(target: "sync", "Ignored block data already downloaded: {}", start);
+				return
+			},
+			_ => (),
+		}
+
+		self.blocks.insert(
+			start,
+			BlockRangeState::Complete(
+				blocks.into_iter().map(|b| BlockData { origin: Some(who), block: b }).collect(),
+			),
+		);
+	}
+
+	/// Returns a set of block hashes that require a header download. The returned set is marked as
+	/// being downloaded.
+	pub fn needed_blocks(
+		&mut self,
+		who: PeerId,
+		count: u32,
+		peer_best: NumberFor<B>,
+		common: NumberFor<B>,
+		max_parallel: u32,
+		max_ahead: u32,
+	) -> Option<Range<NumberFor<B>>> {
+		if peer_best <= common {
+			// Bail out early
+			return None
+		}
+		// First block number that we need to download
+		let first_different = common + <NumberFor<B>>::one();
+		let count = (count as u32).into();
+		let (mut range, downloading) = {
+			let mut downloading_iter = self.blocks.iter().peekable();
+			let mut prev: Option<(&NumberFor<B>, &BlockRangeState<B>)> = None;
+			loop {
+				let next = downloading_iter.next();
+				break match (prev, next) {
+					(Some((start, &BlockRangeState::Downloading { ref len, downloading })), _)
+						if downloading < max_parallel =>
+						(*start..*start + *len, downloading),
+					(Some((start, r)), Some((next_start, _))) if *start + r.len() < *next_start =>
+						(*start + r.len()..cmp::min(*next_start, *start + r.len() + count), 0), // gap
+					(Some((start, r)), None) => (*start + r.len()..*start + r.len() + count, 0), /* last range */
+					(None, None) => (first_different..first_different + count, 0),               /* empty */
+					(None, Some((start, _))) if *start > first_different =>
+						(first_different..cmp::min(first_different + count, *start), 0), /* gap at the start */
+					_ => {
+						prev = next;
+						continue
+					},
+				}
+			}
+		};
+		// crop to peers best
+		if range.start > peer_best {
+			trace!(target: "sync", "Out of range for peer {} ({} vs {})", who, range.start, peer_best);
+			return None
+		}
+		range.end = cmp::min(peer_best + One::one(), range.end);
+
+		if self
+			.blocks
+			.iter()
+			.next()
+			.map_or(false, |(n, _)| range.start > *n + max_ahead.into())
+		{
+			trace!(target: "sync", "Too far ahead for peer {} ({})", who, range.start);
+			return None
+		}
+
+		self.peer_requests.insert(who, range.start);
+		self.blocks.insert(
+			range.start,
+			BlockRangeState::Downloading {
+				len: range.end - range.start,
+				downloading: downloading + 1,
+			},
+		);
+		if range.end <= range.start {
+			panic!(
+				"Empty range {:?}, count={}, peer_best={}, common={}, blocks={:?}",
+				range, count, peer_best, common, self.blocks
+			);
+		}
+		Some(range)
+	}
+
+	/// Get a valid chain of blocks ordered in descending order and ready for importing into
+	/// the blockchain.
+	/// `from` is the maximum block number for the start of the range that we are interested in.
+	/// The function will return empty Vec if the first block ready is higher than `from`.
+	/// For each returned block hash `clear_queued` must be called at some later stage.
+	pub fn ready_blocks(&mut self, from: NumberFor<B>) -> Vec<BlockData<B>> {
+		let mut ready = Vec::new();
+
+		let mut prev = from;
+		for (&start, range_data) in &mut self.blocks {
+			if start > prev {
+				break
+			}
+			let len = match range_data {
+				BlockRangeState::Complete(blocks) => {
+					let len = (blocks.len() as u32).into();
+					prev = start + len;
+					if let Some(BlockData { block, .. }) = blocks.first() {
+						self.queued_blocks
+							.insert(block.hash, (start, start + (blocks.len() as u32).into()));
+					}
+					// Remove all elements from `blocks` and add them to `ready`
+					ready.append(blocks);
+					len
+				},
+				BlockRangeState::Queued { .. } => continue,
+				_ => break,
+			};
+			*range_data = BlockRangeState::Queued { len };
+		}
+		trace!(target: "sync", "{} blocks ready for import", ready.len());
+		ready
+	}
+
+	pub fn clear_queued(&mut self, hash: &B::Hash) {
+		if let Some((from, to)) = self.queued_blocks.remove(hash) {
+			let mut block_num = from;
+			while block_num < to {
+				self.blocks.remove(&block_num);
+				block_num += One::one();
+			}
+			trace!(target: "sync", "Cleared blocks from {:?} to {:?}", from, to);
+		}
+	}
+
+	pub fn clear_peer_download(&mut self, who: &PeerId) {
+		if let Some(start) = self.peer_requests.remove(who) {
+			let remove = match self.blocks.get_mut(&start) {
+				Some(&mut BlockRangeState::Downloading { ref mut downloading, .. })
+					if *downloading > 1 =>
+				{
+					*downloading -= 1;
+					false
+				},
+				Some(&mut BlockRangeState::Downloading { .. }) => true,
+				_ => false,
+			};
+			if remove {
+				self.blocks.remove(&start);
+			}
+		}
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::{BlockCollection, BlockData, BlockRangeState};
+	use libp2p::PeerId;
+	use sc_network_common::sync::message;
+	use sp_core::H256;
+	use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper};
+
+	type Block = RawBlock<ExtrinsicWrapper<u64>>;
+
+	fn is_empty(bc: &BlockCollection<Block>) -> bool {
+		bc.blocks.is_empty() && bc.peer_requests.is_empty()
+	}
+
+	fn generate_blocks(n: usize) -> Vec<message::BlockData<Block>> {
+		(0..n)
+			.map(|_| message::generic::BlockData {
+				hash: H256::random(),
+				header: None,
+				body: None,
+				indexed_body: None,
+				message_queue: None,
+				receipt: None,
+				justification: None,
+				justifications: None,
+			})
+			.collect()
+	}
+
+	#[test]
+	fn create_clear() {
+		let mut bc = BlockCollection::new();
+		assert!(is_empty(&bc));
+		bc.insert(1, generate_blocks(100), PeerId::random());
+		assert!(!is_empty(&bc));
+		bc.clear();
+		assert!(is_empty(&bc));
+	}
+
+	#[test]
+	fn insert_blocks() {
+		let mut bc = BlockCollection::new();
+		assert!(is_empty(&bc));
+		let peer0 = PeerId::random();
+		let peer1 = PeerId::random();
+		let peer2 = PeerId::random();
+
+		let blocks = generate_blocks(150);
+		assert_eq!(bc.needed_blocks(peer0, 40, 150, 0, 1, 200), Some(1..41));
+		assert_eq!(bc.needed_blocks(peer1, 40, 150, 0, 1, 200), Some(41..81));
+		assert_eq!(bc.needed_blocks(peer2, 40, 150, 0, 1, 200), Some(81..121));
+
+		bc.clear_peer_download(&peer1);
+		bc.insert(41, blocks[41..81].to_vec(), peer1);
+		assert_eq!(bc.ready_blocks(1), vec![]);
+		assert_eq!(bc.needed_blocks(peer1, 40, 150, 0, 1, 200), Some(121..151));
+		bc.clear_peer_download(&peer0);
+		bc.insert(1, blocks[1..11].to_vec(), peer0);
+
+		assert_eq!(bc.needed_blocks(peer0, 40, 150, 0, 1, 200), Some(11..41));
+		assert_eq!(
+			bc.ready_blocks(1),
+			blocks[1..11]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer0) })
+				.collect::<Vec<_>>()
+		);
+
+		bc.clear_peer_download(&peer0);
+		bc.insert(11, blocks[11..41].to_vec(), peer0);
+
+		let ready = bc.ready_blocks(12);
+		assert_eq!(
+			ready[..30],
+			blocks[11..41]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer0) })
+				.collect::<Vec<_>>()[..]
+		);
+		assert_eq!(
+			ready[30..],
+			blocks[41..81]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer1) })
+				.collect::<Vec<_>>()[..]
+		);
+
+		bc.clear_peer_download(&peer2);
+		assert_eq!(bc.needed_blocks(peer2, 40, 150, 80, 1, 200), Some(81..121));
+		bc.clear_peer_download(&peer2);
+		bc.insert(81, blocks[81..121].to_vec(), peer2);
+		bc.clear_peer_download(&peer1);
+		bc.insert(121, blocks[121..150].to_vec(), peer1);
+
+		assert_eq!(bc.ready_blocks(80), vec![]);
+		let ready = bc.ready_blocks(81);
+		assert_eq!(
+			ready[..40],
+			blocks[81..121]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer2) })
+				.collect::<Vec<_>>()[..]
+		);
+		assert_eq!(
+			ready[40..],
+			blocks[121..150]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer1) })
+				.collect::<Vec<_>>()[..]
+		);
+	}
+
+	#[test]
+	fn large_gap() {
+		let mut bc: BlockCollection<Block> = BlockCollection::new();
+		bc.blocks.insert(100, BlockRangeState::Downloading { len: 128, downloading: 1 });
+		let blocks = generate_blocks(10)
+			.into_iter()
+			.map(|b| BlockData { block: b, origin: None })
+			.collect();
+		bc.blocks.insert(114305, BlockRangeState::Complete(blocks));
+
+		let peer0 = PeerId::random();
+		assert_eq!(bc.needed_blocks(peer0, 128, 10000, 000, 1, 200), Some(1..100));
+		assert_eq!(bc.needed_blocks(peer0, 128, 10000, 600, 1, 200), None); // too far ahead
+		assert_eq!(
+			bc.needed_blocks(peer0, 128, 10000, 600, 1, 200000),
+			Some(100 + 128..100 + 128 + 128)
+		);
+	}
+
+	#[test]
+	fn no_duplicate_requests_on_fork() {
+		let mut bc = BlockCollection::new();
+		assert!(is_empty(&bc));
+		let peer = PeerId::random();
+
+		let blocks = generate_blocks(10);
+
+		// count = 5, peer_best = 50, common = 39, max_parallel = 0, max_ahead = 200
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(40..45));
+
+		// got a response on the request for `40..45`
+		bc.clear_peer_download(&peer);
+		bc.insert(40, blocks[..5].to_vec(), peer);
+
+		// our "node" started on a fork, with its current best = 47, which is > common
+		let ready = bc.ready_blocks(48);
+		assert_eq!(
+			ready,
+			blocks[..5]
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer) })
+				.collect::<Vec<_>>()
+		);
+
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(45..50));
+	}
+
+	#[test]
+	fn clear_queued_subsequent_ranges() {
+		let mut bc = BlockCollection::new();
+		assert!(is_empty(&bc));
+		let peer = PeerId::random();
+
+		let blocks = generate_blocks(10);
+
+		// Request 2 ranges
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(40..45));
+		assert_eq!(bc.needed_blocks(peer, 5, 50, 39, 0, 200), Some(45..50));
+
+		// got a response on the request for `40..50`
+		bc.clear_peer_download(&peer);
+		bc.insert(40, blocks.to_vec(), peer);
+
+		// request any blocks starting from 1000 or lower.
+		let ready = bc.ready_blocks(1000);
+		assert_eq!(
+			ready,
+			blocks
+				.iter()
+				.map(|b| BlockData { block: b.clone(), origin: Some(peer) })
+				.collect::<Vec<_>>()
+		);
+
+		bc.clear_queued(&blocks[0].hash);
+		assert!(bc.blocks.is_empty());
+		assert!(bc.queued_blocks.is_empty());
+	}
+}
diff --git a/substrate/client/network/sync/src/engine.rs b/substrate/client/network/sync/src/engine.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d5c4957ab3d706db81c9f24f415e622cc117656e
--- /dev/null
+++ b/substrate/client/network/sync/src/engine.rs
@@ -0,0 +1,944 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-2023 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/>.
+
+//! `SyncingEngine` is the actor responsible for syncing Substrate chain
+//! to tip and keep the blockchain up to date with network updates.
+
+use crate::{
+	service::{self, chain_sync::ToServiceCommand},
+	ChainSync, ClientError, SyncingService,
+};
+
+use codec::{Decode, Encode};
+use futures::{FutureExt, StreamExt};
+use futures_timer::Delay;
+use libp2p::PeerId;
+use prometheus_endpoint::{
+	register, Gauge, GaugeVec, MetricSource, Opts, PrometheusError, Registry, SourcedGauge, U64,
+};
+use schnellru::{ByLength, LruMap};
+
+use sc_client_api::{BlockBackend, HeaderBackend, ProofProvider};
+use sc_consensus::import_queue::ImportQueueService;
+use sc_network::{
+	config::{FullNetworkConfiguration, NonDefaultSetConfig, ProtocolId},
+	utils::LruHashSet,
+	NotificationsSink, ProtocolName, ReputationChange,
+};
+use sc_network_common::{
+	role::Roles,
+	sync::{
+		message::{BlockAnnounce, BlockAnnouncesHandshake, BlockState},
+		warp::WarpSyncParams,
+		BadPeer, ChainSync as ChainSyncT, ExtendedPeerInfo, PollBlockAnnounceValidation, SyncEvent,
+	},
+};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_blockchain::HeaderMetadata;
+use sp_consensus::block_validation::BlockAnnounceValidator;
+use sp_runtime::traits::{Block as BlockT, Header, NumberFor, Zero};
+
+use std::{
+	collections::{HashMap, HashSet},
+	num::NonZeroUsize,
+	sync::{
+		atomic::{AtomicBool, AtomicUsize, Ordering},
+		Arc,
+	},
+	task::Poll,
+	time::{Duration, Instant},
+};
+
+/// Interval at which we perform time based maintenance
+const TICK_TIMEOUT: std::time::Duration = std::time::Duration::from_millis(1100);
+
+/// Maximum number of known block hashes to keep for a peer.
+const MAX_KNOWN_BLOCKS: usize = 1024; // ~32kb per peer + LruHashSet overhead
+
+/// If the block announces stream to peer has been inactive for 30 seconds meaning local node
+/// has not sent or received block announcements to/from the peer, report the node for inactivity,
+/// disconnect it and attempt to establish connection to some other peer.
+const INACTIVITY_EVICT_THRESHOLD: Duration = Duration::from_secs(30);
+
+/// When `SyncingEngine` is started, wait two minutes before actually staring to count peers as
+/// evicted.
+///
+/// Parachain collator may incorrectly get evicted because it's waiting to receive a number of
+/// relaychain blocks before it can start creating parachain blocks. During this wait,
+/// `SyncingEngine` still counts it as active and as the peer is not sending blocks, it may get
+/// evicted if a block is not received within the first 30 secons since the peer connected.
+///
+/// To prevent this from happening, define a threshold for how long `SyncingEngine` should wait
+/// before it starts evicting peers.
+const INITIAL_EVICTION_WAIT_PERIOD: Duration = Duration::from_secs(2 * 60);
+
+mod rep {
+	use sc_network::ReputationChange as Rep;
+	/// Peer has different genesis.
+	pub const GENESIS_MISMATCH: Rep = Rep::new_fatal("Genesis mismatch");
+	/// Peer send us a block announcement that failed at validation.
+	pub const BAD_BLOCK_ANNOUNCEMENT: Rep = Rep::new(-(1 << 12), "Bad block announcement");
+	/// Block announce substream with the peer has been inactive too long
+	pub const INACTIVE_SUBSTREAM: Rep = Rep::new(-(1 << 10), "Inactive block announce substream");
+}
+
+struct Metrics {
+	peers: Gauge<U64>,
+	queued_blocks: Gauge<U64>,
+	fork_targets: Gauge<U64>,
+	justifications: GaugeVec<U64>,
+}
+
+impl Metrics {
+	fn register(r: &Registry, major_syncing: Arc<AtomicBool>) -> Result<Self, PrometheusError> {
+		let _ = MajorSyncingGauge::register(r, major_syncing)?;
+		Ok(Self {
+			peers: {
+				let g = Gauge::new("substrate_sync_peers", "Number of peers we sync with")?;
+				register(g, r)?
+			},
+			queued_blocks: {
+				let g =
+					Gauge::new("substrate_sync_queued_blocks", "Number of blocks in import queue")?;
+				register(g, r)?
+			},
+			fork_targets: {
+				let g = Gauge::new("substrate_sync_fork_targets", "Number of fork sync targets")?;
+				register(g, r)?
+			},
+			justifications: {
+				let g = GaugeVec::new(
+					Opts::new(
+						"substrate_sync_extra_justifications",
+						"Number of extra justifications requests",
+					),
+					&["status"],
+				)?;
+				register(g, r)?
+			},
+		})
+	}
+}
+
+/// The "major syncing" metric.
+#[derive(Clone)]
+pub struct MajorSyncingGauge(Arc<AtomicBool>);
+
+impl MajorSyncingGauge {
+	/// Registers the [`MajorSyncGauge`] metric whose value is
+	/// obtained from the given `AtomicBool`.
+	fn register(registry: &Registry, value: Arc<AtomicBool>) -> Result<(), PrometheusError> {
+		prometheus_endpoint::register(
+			SourcedGauge::new(
+				&Opts::new(
+					"substrate_sub_libp2p_is_major_syncing",
+					"Whether the node is performing a major sync or not.",
+				),
+				MajorSyncingGauge(value),
+			)?,
+			registry,
+		)?;
+
+		Ok(())
+	}
+}
+
+impl MetricSource for MajorSyncingGauge {
+	type N = u64;
+
+	fn collect(&self, mut set: impl FnMut(&[&str], Self::N)) {
+		set(&[], self.0.load(Ordering::Relaxed) as u64);
+	}
+}
+
+/// Peer information
+#[derive(Debug)]
+pub struct Peer<B: BlockT> {
+	pub info: ExtendedPeerInfo<B>,
+	/// Holds a set of blocks known to this peer.
+	pub known_blocks: LruHashSet<B::Hash>,
+	/// Notification sink.
+	sink: NotificationsSink,
+	/// Is the peer inbound.
+	inbound: bool,
+}
+
+pub struct SyncingEngine<B: BlockT, Client> {
+	/// State machine that handles the list of in-progress requests. Only full node peers are
+	/// registered.
+	chain_sync: ChainSync<B, Client>,
+
+	/// Blockchain client.
+	client: Arc<Client>,
+
+	/// Number of peers we're connected to.
+	num_connected: Arc<AtomicUsize>,
+
+	/// Are we actively catching up with the chain?
+	is_major_syncing: Arc<AtomicBool>,
+
+	/// Network service.
+	network_service: service::network::NetworkServiceHandle,
+
+	/// Channel for receiving service commands
+	service_rx: TracingUnboundedReceiver<ToServiceCommand<B>>,
+
+	/// Channel for receiving inbound connections from `Protocol`.
+	rx: sc_utils::mpsc::TracingUnboundedReceiver<sc_network::SyncEvent<B>>,
+
+	/// Assigned roles.
+	roles: Roles,
+
+	/// Genesis hash.
+	genesis_hash: B::Hash,
+
+	/// Set of channels for other protocols that have subscribed to syncing events.
+	event_streams: Vec<TracingUnboundedSender<SyncEvent>>,
+
+	/// Interval at which we call `tick`.
+	tick_timeout: Delay,
+
+	/// All connected peers. Contains both full and light node peers.
+	peers: HashMap<PeerId, Peer<B>>,
+
+	/// List of nodes for which we perform additional logging because they are important for the
+	/// user.
+	important_peers: HashSet<PeerId>,
+
+	/// Actual list of connected no-slot nodes.
+	default_peers_set_no_slot_connected_peers: HashSet<PeerId>,
+
+	/// List of nodes that should never occupy peer slots.
+	default_peers_set_no_slot_peers: HashSet<PeerId>,
+
+	/// Value that was passed as part of the configuration. Used to cap the number of full
+	/// nodes.
+	default_peers_set_num_full: usize,
+
+	/// Number of slots to allocate to light nodes.
+	default_peers_set_num_light: usize,
+
+	/// Maximum number of inbound peers.
+	max_in_peers: usize,
+
+	/// Number of inbound peers accepted so far.
+	num_in_peers: usize,
+
+	/// A cache for the data that was associated to a block announcement.
+	block_announce_data_cache: LruMap<B::Hash, Vec<u8>>,
+
+	/// The `PeerId`'s of all boot nodes.
+	boot_node_ids: HashSet<PeerId>,
+
+	/// Protocol name used for block announcements
+	block_announce_protocol_name: ProtocolName,
+
+	/// Prometheus metrics.
+	metrics: Option<Metrics>,
+
+	/// When the syncing was started.
+	///
+	/// Stored as an `Option<Instant>` so once the initial wait has passed, `SyncingEngine`
+	/// can reset the peer timers and continue with the normal eviction process.
+	syncing_started: Option<Instant>,
+
+	/// Instant when the last notification was sent or received.
+	last_notification_io: Instant,
+}
+
+impl<B: BlockT, Client> SyncingEngine<B, Client>
+where
+	B: BlockT,
+	Client: HeaderBackend<B>
+		+ BlockBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ ProofProvider<B>
+		+ Send
+		+ Sync
+		+ 'static,
+{
+	pub fn new(
+		roles: Roles,
+		client: Arc<Client>,
+		metrics_registry: Option<&Registry>,
+		net_config: &FullNetworkConfiguration,
+		protocol_id: ProtocolId,
+		fork_id: &Option<String>,
+		block_announce_validator: Box<dyn BlockAnnounceValidator<B> + Send>,
+		warp_sync_params: Option<WarpSyncParams<B>>,
+		network_service: service::network::NetworkServiceHandle,
+		import_queue: Box<dyn ImportQueueService<B>>,
+		block_request_protocol_name: ProtocolName,
+		state_request_protocol_name: ProtocolName,
+		warp_sync_protocol_name: Option<ProtocolName>,
+		rx: sc_utils::mpsc::TracingUnboundedReceiver<sc_network::SyncEvent<B>>,
+	) -> Result<(Self, SyncingService<B>, NonDefaultSetConfig), ClientError> {
+		let mode = net_config.network_config.sync_mode;
+		let max_parallel_downloads = net_config.network_config.max_parallel_downloads;
+		let max_blocks_per_request = if net_config.network_config.max_blocks_per_request >
+			crate::MAX_BLOCKS_IN_RESPONSE as u32
+		{
+			log::info!(target: "sync", "clamping maximum blocks per request to {}", crate::MAX_BLOCKS_IN_RESPONSE);
+			crate::MAX_BLOCKS_IN_RESPONSE as u32
+		} else {
+			net_config.network_config.max_blocks_per_request
+		};
+		let cache_capacity = (net_config.network_config.default_peers_set.in_peers +
+			net_config.network_config.default_peers_set.out_peers)
+			.max(1);
+		let important_peers = {
+			let mut imp_p = HashSet::new();
+			for reserved in &net_config.network_config.default_peers_set.reserved_nodes {
+				imp_p.insert(reserved.peer_id);
+			}
+			for config in net_config.notification_protocols() {
+				let peer_ids = config
+					.set_config
+					.reserved_nodes
+					.iter()
+					.map(|info| info.peer_id)
+					.collect::<Vec<PeerId>>();
+				imp_p.extend(peer_ids);
+			}
+
+			imp_p.shrink_to_fit();
+			imp_p
+		};
+		let boot_node_ids = {
+			let mut list = HashSet::new();
+			for node in &net_config.network_config.boot_nodes {
+				list.insert(node.peer_id);
+			}
+			list.shrink_to_fit();
+			list
+		};
+		let default_peers_set_no_slot_peers = {
+			let mut no_slot_p: HashSet<PeerId> = net_config
+				.network_config
+				.default_peers_set
+				.reserved_nodes
+				.iter()
+				.map(|reserved| reserved.peer_id)
+				.collect();
+			no_slot_p.shrink_to_fit();
+			no_slot_p
+		};
+		let default_peers_set_num_full =
+			net_config.network_config.default_peers_set_num_full as usize;
+		let default_peers_set_num_light = {
+			let total = net_config.network_config.default_peers_set.out_peers +
+				net_config.network_config.default_peers_set.in_peers;
+			total.saturating_sub(net_config.network_config.default_peers_set_num_full) as usize
+		};
+
+		let (chain_sync, block_announce_config) = ChainSync::new(
+			mode,
+			client.clone(),
+			protocol_id,
+			fork_id,
+			roles,
+			block_announce_validator,
+			max_parallel_downloads,
+			max_blocks_per_request,
+			warp_sync_params,
+			metrics_registry,
+			network_service.clone(),
+			import_queue,
+			block_request_protocol_name,
+			state_request_protocol_name,
+			warp_sync_protocol_name,
+		)?;
+
+		let block_announce_protocol_name = block_announce_config.notifications_protocol.clone();
+		let (tx, service_rx) = tracing_unbounded("mpsc_chain_sync", 100_000);
+		let num_connected = Arc::new(AtomicUsize::new(0));
+		let is_major_syncing = Arc::new(AtomicBool::new(false));
+		let genesis_hash = client
+			.block_hash(0u32.into())
+			.ok()
+			.flatten()
+			.expect("Genesis block exists; qed");
+
+		// `default_peers_set.in_peers` contains an unspecified amount of light peers so the number
+		// of full inbound peers must be calculated from the total full peer count
+		let max_full_peers = net_config.network_config.default_peers_set_num_full;
+		let max_out_peers = net_config.network_config.default_peers_set.out_peers;
+		let max_in_peers = (max_full_peers - max_out_peers) as usize;
+
+		Ok((
+			Self {
+				roles,
+				client,
+				chain_sync,
+				network_service,
+				peers: HashMap::new(),
+				block_announce_data_cache: LruMap::new(ByLength::new(cache_capacity)),
+				block_announce_protocol_name,
+				num_connected: num_connected.clone(),
+				is_major_syncing: is_major_syncing.clone(),
+				service_rx,
+				rx,
+				genesis_hash,
+				important_peers,
+				default_peers_set_no_slot_connected_peers: HashSet::new(),
+				boot_node_ids,
+				default_peers_set_no_slot_peers,
+				default_peers_set_num_full,
+				default_peers_set_num_light,
+				num_in_peers: 0usize,
+				max_in_peers,
+				event_streams: Vec::new(),
+				tick_timeout: Delay::new(TICK_TIMEOUT),
+				syncing_started: None,
+				last_notification_io: Instant::now(),
+				metrics: if let Some(r) = metrics_registry {
+					match Metrics::register(r, is_major_syncing.clone()) {
+						Ok(metrics) => Some(metrics),
+						Err(err) => {
+							log::error!(target: "sync", "Failed to register metrics {err:?}");
+							None
+						},
+					}
+				} else {
+					None
+				},
+			},
+			SyncingService::new(tx, num_connected, is_major_syncing),
+			block_announce_config,
+		))
+	}
+
+	/// Report Prometheus metrics.
+	pub fn report_metrics(&self) {
+		if let Some(metrics) = &self.metrics {
+			let n = u64::try_from(self.peers.len()).unwrap_or(std::u64::MAX);
+			metrics.peers.set(n);
+
+			let m = self.chain_sync.metrics();
+
+			metrics.fork_targets.set(m.fork_targets.into());
+			metrics.queued_blocks.set(m.queued_blocks.into());
+
+			metrics
+				.justifications
+				.with_label_values(&["pending"])
+				.set(m.justifications.pending_requests.into());
+			metrics
+				.justifications
+				.with_label_values(&["active"])
+				.set(m.justifications.active_requests.into());
+			metrics
+				.justifications
+				.with_label_values(&["failed"])
+				.set(m.justifications.failed_requests.into());
+			metrics
+				.justifications
+				.with_label_values(&["importing"])
+				.set(m.justifications.importing_requests.into());
+		}
+	}
+
+	fn update_peer_info(&mut self, who: &PeerId) {
+		if let Some(info) = self.chain_sync.peer_info(who) {
+			if let Some(ref mut peer) = self.peers.get_mut(who) {
+				peer.info.best_hash = info.best_hash;
+				peer.info.best_number = info.best_number;
+			}
+		}
+	}
+
+	/// Process the result of the block announce validation.
+	pub fn process_block_announce_validation_result(
+		&mut self,
+		validation_result: PollBlockAnnounceValidation<B::Header>,
+	) {
+		match validation_result {
+			PollBlockAnnounceValidation::Skip => {},
+			PollBlockAnnounceValidation::Nothing { is_best: _, who, announce } => {
+				self.update_peer_info(&who);
+
+				if let Some(data) = announce.data {
+					if !data.is_empty() {
+						self.block_announce_data_cache.insert(announce.header.hash(), data);
+					}
+				}
+			},
+			PollBlockAnnounceValidation::Failure { who, disconnect } => {
+				if disconnect {
+					self.network_service
+						.disconnect_peer(who, self.block_announce_protocol_name.clone());
+				}
+
+				self.network_service.report_peer(who, rep::BAD_BLOCK_ANNOUNCEMENT);
+			},
+		}
+	}
+
+	/// Push a block announce validation.
+	///
+	/// It is required that [`ChainSync::poll_block_announce_validation`] is
+	/// called later to check for finished validations. The result of the validation
+	/// needs to be passed to [`SyncingEngine::process_block_announce_validation_result`]
+	/// to finish the processing.
+	///
+	/// # Note
+	///
+	/// This will internally create a future, but this future will not be registered
+	/// in the task before being polled once. So, it is required to call
+	/// [`ChainSync::poll_block_announce_validation`] to ensure that the future is
+	/// registered properly and will wake up the task when being ready.
+	pub fn push_block_announce_validation(
+		&mut self,
+		who: PeerId,
+		announce: BlockAnnounce<B::Header>,
+	) {
+		let hash = announce.header.hash();
+
+		let peer = match self.peers.get_mut(&who) {
+			Some(p) => p,
+			None => {
+				log::error!(target: "sync", "Received block announce from disconnected peer {}", who);
+				debug_assert!(false);
+				return
+			},
+		};
+		peer.known_blocks.insert(hash);
+
+		if peer.info.roles.is_full() {
+			let is_best = match announce.state.unwrap_or(BlockState::Best) {
+				BlockState::Best => true,
+				BlockState::Normal => false,
+			};
+
+			self.chain_sync.push_block_announce_validation(who, hash, announce, is_best);
+		}
+	}
+
+	/// Make sure an important block is propagated to peers.
+	///
+	/// In chain-based consensus, we often need to make sure non-best forks are
+	/// at least temporarily synced.
+	pub fn announce_block(&mut self, hash: B::Hash, data: Option<Vec<u8>>) {
+		let header = match self.client.header(hash) {
+			Ok(Some(header)) => header,
+			Ok(None) => {
+				log::warn!(target: "sync", "Trying to announce unknown block: {}", hash);
+				return
+			},
+			Err(e) => {
+				log::warn!(target: "sync", "Error reading block header {}: {}", hash, e);
+				return
+			},
+		};
+
+		// don't announce genesis block since it will be ignored
+		if header.number().is_zero() {
+			return
+		}
+
+		let is_best = self.client.info().best_hash == hash;
+		log::debug!(target: "sync", "Reannouncing block {:?} is_best: {}", hash, is_best);
+
+		let data = data
+			.or_else(|| self.block_announce_data_cache.get(&hash).cloned())
+			.unwrap_or_default();
+
+		for (who, ref mut peer) in self.peers.iter_mut() {
+			let inserted = peer.known_blocks.insert(hash);
+			if inserted {
+				log::trace!(target: "sync", "Announcing block {:?} to {}", hash, who);
+				let message = BlockAnnounce {
+					header: header.clone(),
+					state: if is_best { Some(BlockState::Best) } else { Some(BlockState::Normal) },
+					data: Some(data.clone()),
+				};
+
+				self.last_notification_io = Instant::now();
+				peer.sink.send_sync_notification(message.encode());
+			}
+		}
+	}
+
+	/// Inform sync about new best imported block.
+	pub fn new_best_block_imported(&mut self, hash: B::Hash, number: NumberFor<B>) {
+		log::debug!(target: "sync", "New best block imported {:?}/#{}", hash, number);
+
+		self.chain_sync.update_chain_info(&hash, number);
+		self.network_service.set_notification_handshake(
+			self.block_announce_protocol_name.clone(),
+			BlockAnnouncesHandshake::<B>::build(self.roles, number, hash, self.genesis_hash)
+				.encode(),
+		)
+	}
+
+	pub async fn run(mut self) {
+		self.syncing_started = Some(Instant::now());
+
+		loop {
+			futures::future::poll_fn(|cx| self.poll(cx)).await;
+		}
+	}
+
+	pub fn poll(&mut self, cx: &mut std::task::Context) -> Poll<()> {
+		self.num_connected.store(self.peers.len(), Ordering::Relaxed);
+		self.is_major_syncing
+			.store(self.chain_sync.status().state.is_major_syncing(), Ordering::Relaxed);
+
+		while let Poll::Ready(()) = self.tick_timeout.poll_unpin(cx) {
+			self.report_metrics();
+			self.tick_timeout.reset(TICK_TIMEOUT);
+
+			// if `SyncingEngine` has just started, don't evict seemingly inactive peers right away
+			// as they may not have produced blocks not because they've disconnected but because
+			// they're still waiting to receive enough relaychain blocks to start producing blocks.
+			if let Some(started) = self.syncing_started {
+				if started.elapsed() < INITIAL_EVICTION_WAIT_PERIOD {
+					continue
+				}
+
+				self.syncing_started = None;
+				self.last_notification_io = Instant::now();
+			}
+
+			// if syncing hasn't sent or received any blocks within `INACTIVITY_EVICT_THRESHOLD`,
+			// it means the local node has stalled and is connected to peers who either don't
+			// consider it connected or are also all stalled. In order to unstall the node,
+			// disconnect all peers and allow `ProtocolController` to establish new connections.
+			if self.last_notification_io.elapsed() > INACTIVITY_EVICT_THRESHOLD {
+				log::debug!(target: "sync", "syncing has halted due to inactivity, evicting all peers");
+
+				for peer in self.peers.keys() {
+					self.network_service.report_peer(*peer, rep::INACTIVE_SUBSTREAM);
+					self.network_service
+						.disconnect_peer(*peer, self.block_announce_protocol_name.clone());
+				}
+
+				// after all the peers have been evicted, start timer again to prevent evicting
+				// new peers that join after the old peer have been evicted
+				self.last_notification_io = Instant::now();
+			}
+		}
+
+		while let Poll::Ready(Some(event)) = self.service_rx.poll_next_unpin(cx) {
+			match event {
+				ToServiceCommand::SetSyncForkRequest(peers, hash, number) => {
+					self.chain_sync.set_sync_fork_request(peers, &hash, number);
+				},
+				ToServiceCommand::EventStream(tx) => self.event_streams.push(tx),
+				ToServiceCommand::RequestJustification(hash, number) =>
+					self.chain_sync.request_justification(&hash, number),
+				ToServiceCommand::ClearJustificationRequests =>
+					self.chain_sync.clear_justification_requests(),
+				ToServiceCommand::BlocksProcessed(imported, count, results) => {
+					for result in self.chain_sync.on_blocks_processed(imported, count, results) {
+						match result {
+							Ok((id, req)) => self.chain_sync.send_block_request(id, req),
+							Err(BadPeer(id, repu)) => {
+								self.network_service
+									.disconnect_peer(id, self.block_announce_protocol_name.clone());
+								self.network_service.report_peer(id, repu)
+							},
+						}
+					}
+				},
+				ToServiceCommand::JustificationImported(peer, hash, number, success) => {
+					self.chain_sync.on_justification_import(hash, number, success);
+					if !success {
+						log::info!(target: "sync", "💔 Invalid justification provided by {} for #{}", peer, hash);
+						self.network_service
+							.disconnect_peer(peer, self.block_announce_protocol_name.clone());
+						self.network_service.report_peer(
+							peer,
+							ReputationChange::new_fatal("Invalid justification"),
+						);
+					}
+				},
+				ToServiceCommand::AnnounceBlock(hash, data) => self.announce_block(hash, data),
+				ToServiceCommand::NewBestBlockImported(hash, number) =>
+					self.new_best_block_imported(hash, number),
+				ToServiceCommand::Status(tx) => {
+					let mut status = self.chain_sync.status();
+					status.num_connected_peers = self.peers.len() as u32;
+					let _ = tx.send(status);
+				},
+				ToServiceCommand::NumActivePeers(tx) => {
+					let _ = tx.send(self.chain_sync.num_active_peers());
+				},
+				ToServiceCommand::SyncState(tx) => {
+					let _ = tx.send(self.chain_sync.status());
+				},
+				ToServiceCommand::BestSeenBlock(tx) => {
+					let _ = tx.send(self.chain_sync.status().best_seen_block);
+				},
+				ToServiceCommand::NumSyncPeers(tx) => {
+					let _ = tx.send(self.chain_sync.status().num_peers);
+				},
+				ToServiceCommand::NumQueuedBlocks(tx) => {
+					let _ = tx.send(self.chain_sync.status().queued_blocks);
+				},
+				ToServiceCommand::NumDownloadedBlocks(tx) => {
+					let _ = tx.send(self.chain_sync.num_downloaded_blocks());
+				},
+				ToServiceCommand::NumSyncRequests(tx) => {
+					let _ = tx.send(self.chain_sync.num_sync_requests());
+				},
+				ToServiceCommand::PeersInfo(tx) => {
+					let peers_info =
+						self.peers.iter().map(|(id, peer)| (*id, peer.info.clone())).collect();
+					let _ = tx.send(peers_info);
+				},
+				ToServiceCommand::OnBlockFinalized(hash, header) =>
+					self.chain_sync.on_block_finalized(&hash, *header.number()),
+			}
+		}
+
+		while let Poll::Ready(Some(event)) = self.rx.poll_next_unpin(cx) {
+			match event {
+				sc_network::SyncEvent::NotificationStreamOpened {
+					remote,
+					received_handshake,
+					sink,
+					inbound,
+					tx,
+				} => match self.on_sync_peer_connected(remote, &received_handshake, sink, inbound) {
+					Ok(()) => {
+						let _ = tx.send(true);
+					},
+					Err(()) => {
+						log::debug!(
+							target: "sync",
+							"Failed to register peer {remote:?}: {received_handshake:?}",
+						);
+						let _ = tx.send(false);
+					},
+				},
+				sc_network::SyncEvent::NotificationStreamClosed { remote } => {
+					if self.on_sync_peer_disconnected(remote).is_err() {
+						log::trace!(
+							target: "sync",
+							"Disconnected peer which had earlier been refused by on_sync_peer_connected {}",
+							remote
+						);
+					}
+				},
+				sc_network::SyncEvent::NotificationsReceived { remote, messages } => {
+					for message in messages {
+						if self.peers.contains_key(&remote) {
+							if let Ok(announce) = BlockAnnounce::decode(&mut message.as_ref()) {
+								self.last_notification_io = Instant::now();
+								self.push_block_announce_validation(remote, announce);
+
+								// Make sure that the newly added block announce validation future
+								// was polled once to be registered in the task.
+								if let Poll::Ready(res) =
+									self.chain_sync.poll_block_announce_validation(cx)
+								{
+									self.process_block_announce_validation_result(res)
+								}
+							} else {
+								log::warn!(target: "sub-libp2p", "Failed to decode block announce");
+							}
+						} else {
+							log::trace!(
+								target: "sync",
+								"Received sync for peer earlier refused by sync layer: {}",
+								remote
+							);
+						}
+					}
+				},
+				sc_network::SyncEvent::NotificationSinkReplaced { remote, sink } => {
+					if let Some(peer) = self.peers.get_mut(&remote) {
+						peer.sink = sink;
+					}
+				},
+			}
+		}
+
+		// poll `ChainSync` last because of a block announcement was received through the
+		// event stream between `SyncingEngine` and `Protocol` and the validation finished
+		// right after it as queued, the resulting block request (if any) can be sent right away.
+		while let Poll::Ready(result) = self.chain_sync.poll(cx) {
+			self.process_block_announce_validation_result(result);
+		}
+
+		Poll::Pending
+	}
+
+	/// Called by peer when it is disconnecting.
+	///
+	/// Returns a result if the handshake of this peer was indeed accepted.
+	pub fn on_sync_peer_disconnected(&mut self, peer: PeerId) -> Result<(), ()> {
+		if let Some(info) = self.peers.remove(&peer) {
+			if self.important_peers.contains(&peer) {
+				log::warn!(target: "sync", "Reserved peer {} disconnected", peer);
+			} else {
+				log::debug!(target: "sync", "{} disconnected", peer);
+			}
+
+			if !self.default_peers_set_no_slot_connected_peers.remove(&peer) &&
+				info.inbound && info.info.roles.is_full()
+			{
+				match self.num_in_peers.checked_sub(1) {
+					Some(value) => {
+						self.num_in_peers = value;
+					},
+					None => {
+						log::error!(
+							target: "sync",
+							"trying to disconnect an inbound node which is not counted as inbound"
+						);
+						debug_assert!(false);
+					},
+				}
+			}
+
+			self.chain_sync.peer_disconnected(&peer);
+			self.event_streams
+				.retain(|stream| stream.unbounded_send(SyncEvent::PeerDisconnected(peer)).is_ok());
+			Ok(())
+		} else {
+			Err(())
+		}
+	}
+
+	/// Called on the first connection between two peers on the default set, after their exchange
+	/// of handshake.
+	///
+	/// Returns `Ok` if the handshake is accepted and the peer added to the list of peers we sync
+	/// from.
+	pub fn on_sync_peer_connected(
+		&mut self,
+		who: PeerId,
+		status: &BlockAnnouncesHandshake<B>,
+		sink: NotificationsSink,
+		inbound: bool,
+	) -> Result<(), ()> {
+		log::trace!(target: "sync", "New peer {} {:?}", who, status);
+
+		if self.peers.contains_key(&who) {
+			log::error!(target: "sync", "Called on_sync_peer_connected with already connected peer {}", who);
+			debug_assert!(false);
+			return Err(())
+		}
+
+		if status.genesis_hash != self.genesis_hash {
+			self.network_service.report_peer(who, rep::GENESIS_MISMATCH);
+
+			if self.important_peers.contains(&who) {
+				log::error!(
+					target: "sync",
+					"Reserved peer id `{}` is on a different chain (our genesis: {} theirs: {})",
+					who,
+					self.genesis_hash,
+					status.genesis_hash,
+				);
+			} else if self.boot_node_ids.contains(&who) {
+				log::error!(
+					target: "sync",
+					"Bootnode with peer id `{}` is on a different chain (our genesis: {} theirs: {})",
+					who,
+					self.genesis_hash,
+					status.genesis_hash,
+				);
+			} else {
+				log::debug!(
+					target: "sync",
+					"Peer is on different chain (our genesis: {} theirs: {})",
+					self.genesis_hash, status.genesis_hash
+				);
+			}
+
+			return Err(())
+		}
+
+		let no_slot_peer = self.default_peers_set_no_slot_peers.contains(&who);
+		let this_peer_reserved_slot: usize = if no_slot_peer { 1 } else { 0 };
+
+		// make sure to accept no more than `--in-peers` many full nodes
+		if !no_slot_peer &&
+			status.roles.is_full() &&
+			inbound && self.num_in_peers == self.max_in_peers
+		{
+			log::debug!(target: "sync", "All inbound slots have been consumed, rejecting {who}");
+			return Err(())
+		}
+
+		if status.roles.is_full() &&
+			self.chain_sync.num_peers() >=
+				self.default_peers_set_num_full +
+					self.default_peers_set_no_slot_connected_peers.len() +
+					this_peer_reserved_slot
+		{
+			log::debug!(target: "sync", "Too many full nodes, rejecting {}", who);
+			return Err(())
+		}
+
+		if status.roles.is_light() &&
+			(self.peers.len() - self.chain_sync.num_peers()) >= self.default_peers_set_num_light
+		{
+			// Make sure that not all slots are occupied by light clients.
+			log::debug!(target: "sync", "Too many light nodes, rejecting {}", who);
+			return Err(())
+		}
+
+		let peer = Peer {
+			info: ExtendedPeerInfo {
+				roles: status.roles,
+				best_hash: status.best_hash,
+				best_number: status.best_number,
+			},
+			known_blocks: LruHashSet::new(
+				NonZeroUsize::new(MAX_KNOWN_BLOCKS).expect("Constant is nonzero"),
+			),
+			sink,
+			inbound,
+		};
+
+		let req = if peer.info.roles.is_full() {
+			match self.chain_sync.new_peer(who, peer.info.best_hash, peer.info.best_number) {
+				Ok(req) => req,
+				Err(BadPeer(id, repu)) => {
+					self.network_service.report_peer(id, repu);
+					return Err(())
+				},
+			}
+		} else {
+			None
+		};
+
+		log::debug!(target: "sync", "Connected {}", who);
+
+		self.peers.insert(who, peer);
+
+		if no_slot_peer {
+			self.default_peers_set_no_slot_connected_peers.insert(who);
+		} else if inbound && status.roles.is_full() {
+			self.num_in_peers += 1;
+		}
+
+		if let Some(req) = req {
+			self.chain_sync.send_block_request(who, req);
+		}
+
+		self.event_streams
+			.retain(|stream| stream.unbounded_send(SyncEvent::PeerConnected(who)).is_ok());
+
+		Ok(())
+	}
+}
diff --git a/substrate/client/network/sync/src/extra_requests.rs b/substrate/client/network/sync/src/extra_requests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..09e6bdb57399f3dbd7bd30aec8da15662f853179
--- /dev/null
+++ b/substrate/client/network/sync/src/extra_requests.rs
@@ -0,0 +1,582 @@
+// 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::{PeerSync, PeerSyncState};
+use fork_tree::ForkTree;
+use libp2p::PeerId;
+use log::{debug, trace, warn};
+use sc_network_common::sync::metrics::Metrics;
+use sp_blockchain::Error as ClientError;
+use sp_runtime::traits::{Block as BlockT, NumberFor, Zero};
+use std::{
+	collections::{HashMap, HashSet, VecDeque},
+	time::{Duration, Instant},
+};
+
+// Time to wait before trying to get the same extra data from the same peer.
+const EXTRA_RETRY_WAIT: Duration = Duration::from_secs(10);
+
+/// Pending extra data request for the given block (hash and number).
+type ExtraRequest<B> = (<B as BlockT>::Hash, NumberFor<B>);
+
+/// Manages pending block extra data (e.g. justification) requests.
+///
+/// Multiple extras may be requested for competing forks, or for the same branch
+/// at different (increasing) heights. This structure will guarantee that extras
+/// are fetched in-order, and that obsolete changes are pruned (when finalizing a
+/// competing fork).
+#[derive(Debug)]
+pub(crate) struct ExtraRequests<B: BlockT> {
+	tree: ForkTree<B::Hash, NumberFor<B>, ()>,
+	/// best finalized block number that we have seen since restart
+	best_seen_finalized_number: NumberFor<B>,
+	/// requests which have been queued for later processing
+	pending_requests: VecDeque<ExtraRequest<B>>,
+	/// requests which are currently underway to some peer
+	active_requests: HashMap<PeerId, ExtraRequest<B>>,
+	/// previous requests without response
+	failed_requests: HashMap<ExtraRequest<B>, Vec<(PeerId, Instant)>>,
+	/// successful requests
+	importing_requests: HashSet<ExtraRequest<B>>,
+	/// the name of this type of extra request (useful for logging.)
+	request_type_name: &'static str,
+}
+
+impl<B: BlockT> ExtraRequests<B> {
+	pub(crate) fn new(request_type_name: &'static str) -> Self {
+		Self {
+			tree: ForkTree::new(),
+			best_seen_finalized_number: Zero::zero(),
+			pending_requests: VecDeque::new(),
+			active_requests: HashMap::new(),
+			failed_requests: HashMap::new(),
+			importing_requests: HashSet::new(),
+			request_type_name,
+		}
+	}
+
+	/// Reset all state as if returned from `new`.
+	pub(crate) fn reset(&mut self) {
+		self.tree = ForkTree::new();
+		self.pending_requests.clear();
+		self.active_requests.clear();
+		self.failed_requests.clear();
+	}
+
+	/// Returns an iterator-like struct that yields peers which extra
+	/// requests can be sent to.
+	pub(crate) fn matcher(&mut self) -> Matcher<B> {
+		Matcher::new(self)
+	}
+
+	/// Queue an extra data request to be considered by the `Matcher`.
+	pub(crate) fn schedule<F>(&mut self, request: ExtraRequest<B>, is_descendent_of: F)
+	where
+		F: Fn(&B::Hash, &B::Hash) -> Result<bool, ClientError>,
+	{
+		match self.tree.import(request.0, request.1, (), &is_descendent_of) {
+			Ok(true) => {
+				// this is a new root so we add it to the current `pending_requests`
+				self.pending_requests.push_back((request.0, request.1));
+			},
+			Err(fork_tree::Error::Revert) => {
+				// we have finalized further than the given request, presumably
+				// by some other part of the system (not sync). we can safely
+				// ignore the `Revert` error.
+			},
+			Err(err) => {
+				debug!(target: "sync", "Failed to insert request {:?} into tree: {}", request, err);
+			},
+			_ => (),
+		}
+	}
+
+	/// Retry any pending request if a peer disconnected.
+	pub(crate) fn peer_disconnected(&mut self, who: &PeerId) {
+		if let Some(request) = self.active_requests.remove(who) {
+			self.pending_requests.push_front(request);
+		}
+	}
+
+	/// Processes the response for the request previously sent to the given peer.
+	pub(crate) fn on_response<R>(
+		&mut self,
+		who: PeerId,
+		resp: Option<R>,
+	) -> Option<(PeerId, B::Hash, NumberFor<B>, R)> {
+		// we assume that the request maps to the given response, this is
+		// currently enforced by the outer network protocol before passing on
+		// messages to chain sync.
+		if let Some(request) = self.active_requests.remove(&who) {
+			if let Some(r) = resp {
+				trace!(target: "sync",
+					"Queuing import of {} from {:?} for {:?}",
+					self.request_type_name, who, request,
+				);
+
+				self.importing_requests.insert(request);
+				return Some((who, request.0, request.1, r))
+			} else {
+				trace!(target: "sync",
+					"Empty {} response from {:?} for {:?}",
+					self.request_type_name, who, request,
+				);
+			}
+			self.failed_requests.entry(request).or_default().push((who, Instant::now()));
+			self.pending_requests.push_front(request);
+		} else {
+			trace!(target: "sync",
+				"No active {} request to {:?}",
+				self.request_type_name, who,
+			);
+		}
+		None
+	}
+
+	/// Removes any pending extra requests for blocks lower than the given best finalized.
+	pub(crate) fn on_block_finalized<F>(
+		&mut self,
+		best_finalized_hash: &B::Hash,
+		best_finalized_number: NumberFor<B>,
+		is_descendent_of: F,
+	) -> Result<(), fork_tree::Error<ClientError>>
+	where
+		F: Fn(&B::Hash, &B::Hash) -> Result<bool, ClientError>,
+	{
+		let request = (*best_finalized_hash, best_finalized_number);
+
+		if self.try_finalize_root::<()>(request, Ok(request), false) {
+			return Ok(())
+		}
+
+		if best_finalized_number > self.best_seen_finalized_number {
+			// we receive finality notification only for the finalized branch head.
+			match self.tree.finalize_with_ancestors(
+				best_finalized_hash,
+				best_finalized_number,
+				&is_descendent_of,
+			) {
+				Err(fork_tree::Error::Revert) => {
+					// we might have finalized further already in which case we
+					// will get a `Revert` error which we can safely ignore.
+				},
+				Err(err) => return Err(err),
+				Ok(_) => {},
+			}
+
+			self.best_seen_finalized_number = best_finalized_number;
+		}
+
+		let roots = self.tree.roots().collect::<HashSet<_>>();
+
+		self.pending_requests.retain(|(h, n)| roots.contains(&(h, n, &())));
+		self.active_requests.retain(|_, (h, n)| roots.contains(&(h, n, &())));
+		self.failed_requests.retain(|(h, n), _| roots.contains(&(h, n, &())));
+
+		Ok(())
+	}
+
+	/// Try to finalize pending root.
+	///
+	/// Returns true if import of this request has been scheduled.
+	pub(crate) fn try_finalize_root<E>(
+		&mut self,
+		request: ExtraRequest<B>,
+		result: Result<ExtraRequest<B>, E>,
+		reschedule_on_failure: bool,
+	) -> bool {
+		if !self.importing_requests.remove(&request) {
+			return false
+		}
+
+		let (finalized_hash, finalized_number) = match result {
+			Ok(req) => (req.0, req.1),
+			Err(_) => {
+				if reschedule_on_failure {
+					self.pending_requests.push_front(request);
+				}
+				return true
+			},
+		};
+
+		if self.tree.finalize_root(&finalized_hash).is_none() {
+			warn!(target: "sync",
+				"‼� Imported {:?} {:?} which isn't a root in the tree: {:?}",
+				finalized_hash, finalized_number, self.tree.roots().collect::<Vec<_>>()
+			);
+			return true
+		}
+
+		self.failed_requests.clear();
+		self.active_requests.clear();
+		self.pending_requests.clear();
+		self.pending_requests.extend(self.tree.roots().map(|(&h, &n, _)| (h, n)));
+		self.best_seen_finalized_number = finalized_number;
+
+		true
+	}
+
+	/// Returns an iterator over all active (in-flight) requests and associated peer id.
+	#[cfg(test)]
+	pub(crate) fn active_requests(&self) -> impl Iterator<Item = (&PeerId, &ExtraRequest<B>)> {
+		self.active_requests.iter()
+	}
+
+	/// Returns an iterator over all scheduled pending requests.
+	#[cfg(test)]
+	pub(crate) fn pending_requests(&self) -> impl Iterator<Item = &ExtraRequest<B>> {
+		self.pending_requests.iter()
+	}
+
+	/// Get some key metrics.
+	pub(crate) fn metrics(&self) -> Metrics {
+		Metrics {
+			pending_requests: self.pending_requests.len().try_into().unwrap_or(std::u32::MAX),
+			active_requests: self.active_requests.len().try_into().unwrap_or(std::u32::MAX),
+			failed_requests: self.failed_requests.len().try_into().unwrap_or(std::u32::MAX),
+			importing_requests: self.importing_requests.len().try_into().unwrap_or(std::u32::MAX),
+		}
+	}
+}
+
+/// Matches peers with pending extra requests.
+#[derive(Debug)]
+pub(crate) struct Matcher<'a, B: BlockT> {
+	/// Length of pending requests collection.
+	/// Used to ensure we do not loop more than once over all pending requests.
+	remaining: usize,
+	extras: &'a mut ExtraRequests<B>,
+}
+
+impl<'a, B: BlockT> Matcher<'a, B> {
+	fn new(extras: &'a mut ExtraRequests<B>) -> Self {
+		Self { remaining: extras.pending_requests.len(), extras }
+	}
+
+	/// Finds a peer to which a pending request can be sent.
+	///
+	/// Peers are filtered according to the current known best block (i.e. we won't
+	/// send an extra request for block #10 to a peer at block #2), and we also
+	/// throttle requests to the same peer if a previous request yielded no results.
+	///
+	/// This method returns as soon as it finds a peer that should be able to answer
+	/// our request. If no request is pending or no peer can handle it, `None` is
+	/// returned instead.
+	///
+	/// # Note
+	///
+	/// The returned `PeerId` (if any) is guaranteed to come from the given `peers`
+	/// argument.
+	pub(crate) fn next(
+		&mut self,
+		peers: &HashMap<PeerId, PeerSync<B>>,
+	) -> Option<(PeerId, ExtraRequest<B>)> {
+		if self.remaining == 0 {
+			return None
+		}
+
+		// clean up previously failed requests so we can retry again
+		for requests in self.extras.failed_requests.values_mut() {
+			requests.retain(|(_, instant)| instant.elapsed() < EXTRA_RETRY_WAIT);
+		}
+
+		while let Some(request) = self.extras.pending_requests.pop_front() {
+			for (peer, sync) in
+				peers.iter().filter(|(_, sync)| sync.state == PeerSyncState::Available)
+			{
+				// only ask peers that have synced at least up to the block number that we're asking
+				// the extra for
+				if sync.best_number < request.1 {
+					continue
+				}
+				// don't request to any peers that already have pending requests
+				if self.extras.active_requests.contains_key(peer) {
+					continue
+				}
+				// only ask if the same request has not failed for this peer before
+				if self
+					.extras
+					.failed_requests
+					.get(&request)
+					.map(|rr| rr.iter().any(|i| &i.0 == peer))
+					.unwrap_or(false)
+				{
+					continue
+				}
+				self.extras.active_requests.insert(*peer, request);
+
+				trace!(target: "sync",
+					"Sending {} request to {:?} for {:?}",
+					self.extras.request_type_name, peer, request,
+				);
+
+				return Some((*peer, request))
+			}
+
+			self.extras.pending_requests.push_back(request);
+			self.remaining -= 1;
+
+			if self.remaining == 0 {
+				break
+			}
+		}
+
+		None
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::PeerSync;
+	use quickcheck::{Arbitrary, Gen, QuickCheck};
+	use sp_blockchain::Error as ClientError;
+	use sp_test_primitives::{Block, BlockNumber, Hash};
+	use std::collections::{HashMap, HashSet};
+
+	#[test]
+	fn requests_are_processed_in_order() {
+		fn property(mut peers: ArbitraryPeers) {
+			let mut requests = ExtraRequests::<Block>::new("test");
+
+			let num_peers_available =
+				peers.0.values().filter(|s| s.state == PeerSyncState::Available).count();
+
+			for i in 0..num_peers_available {
+				requests.schedule((Hash::random(), i as u64), |a, b| Ok(a[0] >= b[0]))
+			}
+
+			let pending = requests.pending_requests.clone();
+			let mut m = requests.matcher();
+
+			for p in &pending {
+				let (peer, r) = m.next(&peers.0).unwrap();
+				assert_eq!(p, &r);
+				peers.0.get_mut(&peer).unwrap().state =
+					PeerSyncState::DownloadingJustification(r.0);
+			}
+		}
+
+		QuickCheck::new().quickcheck(property as fn(ArbitraryPeers))
+	}
+
+	#[test]
+	fn new_roots_schedule_new_request() {
+		fn property(data: Vec<BlockNumber>) {
+			let mut requests = ExtraRequests::<Block>::new("test");
+			for (i, number) in data.into_iter().enumerate() {
+				let hash = [i as u8; 32].into();
+				let pending = requests.pending_requests.len();
+				let is_root = requests.tree.roots().any(|(&h, &n, _)| hash == h && number == n);
+				requests.schedule((hash, number), |a, b| Ok(a[0] >= b[0]));
+				if !is_root {
+					assert_eq!(1 + pending, requests.pending_requests.len())
+				}
+			}
+		}
+		QuickCheck::new().quickcheck(property as fn(Vec<BlockNumber>))
+	}
+
+	#[test]
+	fn disconnecting_implies_rescheduling() {
+		fn property(mut peers: ArbitraryPeers) -> bool {
+			let mut requests = ExtraRequests::<Block>::new("test");
+
+			let num_peers_available =
+				peers.0.values().filter(|s| s.state == PeerSyncState::Available).count();
+
+			for i in 0..num_peers_available {
+				requests.schedule((Hash::random(), i as u64), |a, b| Ok(a[0] >= b[0]))
+			}
+
+			let mut m = requests.matcher();
+			while let Some((peer, r)) = m.next(&peers.0) {
+				peers.0.get_mut(&peer).unwrap().state =
+					PeerSyncState::DownloadingJustification(r.0);
+			}
+
+			assert!(requests.pending_requests.is_empty());
+
+			let active_peers = requests.active_requests.keys().cloned().collect::<Vec<_>>();
+			let previously_active =
+				requests.active_requests.values().cloned().collect::<HashSet<_>>();
+
+			for peer in &active_peers {
+				requests.peer_disconnected(peer)
+			}
+
+			assert!(requests.active_requests.is_empty());
+
+			previously_active == requests.pending_requests.iter().cloned().collect::<HashSet<_>>()
+		}
+
+		QuickCheck::new().quickcheck(property as fn(ArbitraryPeers) -> bool)
+	}
+
+	#[test]
+	fn no_response_reschedules() {
+		fn property(mut peers: ArbitraryPeers) {
+			let mut requests = ExtraRequests::<Block>::new("test");
+
+			let num_peers_available =
+				peers.0.values().filter(|s| s.state == PeerSyncState::Available).count();
+
+			for i in 0..num_peers_available {
+				requests.schedule((Hash::random(), i as u64), |a, b| Ok(a[0] >= b[0]))
+			}
+
+			let mut m = requests.matcher();
+			while let Some((peer, r)) = m.next(&peers.0) {
+				peers.0.get_mut(&peer).unwrap().state =
+					PeerSyncState::DownloadingJustification(r.0);
+			}
+
+			let active = requests.active_requests.iter().map(|(&p, &r)| (p, r)).collect::<Vec<_>>();
+
+			for (peer, req) in &active {
+				assert!(requests.failed_requests.get(req).is_none());
+				assert!(!requests.pending_requests.contains(req));
+				assert!(requests.on_response::<()>(*peer, None).is_none());
+				assert!(requests.pending_requests.contains(req));
+				assert_eq!(
+					1,
+					requests
+						.failed_requests
+						.get(req)
+						.unwrap()
+						.iter()
+						.filter(|(p, _)| p == peer)
+						.count()
+				)
+			}
+		}
+
+		QuickCheck::new().quickcheck(property as fn(ArbitraryPeers))
+	}
+
+	#[test]
+	fn request_is_rescheduled_when_earlier_block_is_finalized() {
+		sp_tracing::try_init_simple();
+
+		let mut finality_proofs = ExtraRequests::<Block>::new("test");
+
+		let hash4 = [4; 32].into();
+		let hash5 = [5; 32].into();
+		let hash6 = [6; 32].into();
+		let hash7 = [7; 32].into();
+
+		fn is_descendent_of(base: &Hash, target: &Hash) -> Result<bool, ClientError> {
+			Ok(target[0] >= base[0])
+		}
+
+		// make #4 last finalized block
+		finality_proofs.tree.import(hash4, 4, (), &is_descendent_of).unwrap();
+		finality_proofs.tree.finalize_root(&hash4);
+
+		// schedule request for #6
+		finality_proofs.schedule((hash6, 6), is_descendent_of);
+
+		// receive finality proof for #5
+		finality_proofs.importing_requests.insert((hash6, 6));
+		finality_proofs.on_block_finalized(&hash5, 5, is_descendent_of).unwrap();
+		finality_proofs.try_finalize_root::<()>((hash6, 6), Ok((hash5, 5)), true);
+
+		// ensure that request for #6 is still pending
+		assert_eq!(finality_proofs.pending_requests.iter().collect::<Vec<_>>(), vec![&(hash6, 6)]);
+
+		// receive finality proof for #7
+		finality_proofs.importing_requests.insert((hash6, 6));
+		finality_proofs.on_block_finalized(&hash6, 6, is_descendent_of).unwrap();
+		finality_proofs.on_block_finalized(&hash7, 7, is_descendent_of).unwrap();
+		finality_proofs.try_finalize_root::<()>((hash6, 6), Ok((hash7, 7)), true);
+
+		// ensure that there's no request for #6
+		assert_eq!(
+			finality_proofs.pending_requests.iter().collect::<Vec<_>>(),
+			Vec::<&(Hash, u64)>::new()
+		);
+	}
+
+	#[test]
+	fn ancestor_roots_are_finalized_when_finality_notification_is_missed() {
+		let mut finality_proofs = ExtraRequests::<Block>::new("test");
+
+		let hash4 = [4; 32].into();
+		let hash5 = [5; 32].into();
+
+		fn is_descendent_of(base: &Hash, target: &Hash) -> Result<bool, ClientError> {
+			Ok(target[0] >= base[0])
+		}
+
+		// schedule request for #4
+		finality_proofs.schedule((hash4, 4), is_descendent_of);
+
+		// receive finality notification for #5 (missing notification for #4!!!)
+		finality_proofs.importing_requests.insert((hash4, 5));
+		finality_proofs.on_block_finalized(&hash5, 5, is_descendent_of).unwrap();
+		assert_eq!(finality_proofs.tree.roots().count(), 0);
+	}
+
+	// Some Arbitrary instances to allow easy construction of random peer sets:
+
+	#[derive(Debug, Clone)]
+	struct ArbitraryPeerSyncState(PeerSyncState<Block>);
+
+	impl Arbitrary for ArbitraryPeerSyncState {
+		fn arbitrary(g: &mut Gen) -> Self {
+			let s = match u8::arbitrary(g) % 4 {
+				0 => PeerSyncState::Available,
+				// TODO: 1 => PeerSyncState::AncestorSearch(g.gen(), AncestorSearchState<B>),
+				1 => PeerSyncState::DownloadingNew(BlockNumber::arbitrary(g)),
+				2 => PeerSyncState::DownloadingStale(Hash::random()),
+				_ => PeerSyncState::DownloadingJustification(Hash::random()),
+			};
+			ArbitraryPeerSyncState(s)
+		}
+	}
+
+	#[derive(Debug, Clone)]
+	struct ArbitraryPeerSync(PeerSync<Block>);
+
+	impl Arbitrary for ArbitraryPeerSync {
+		fn arbitrary(g: &mut Gen) -> Self {
+			let ps = PeerSync {
+				peer_id: PeerId::random(),
+				common_number: u64::arbitrary(g),
+				best_hash: Hash::random(),
+				best_number: u64::arbitrary(g),
+				state: ArbitraryPeerSyncState::arbitrary(g).0,
+			};
+			ArbitraryPeerSync(ps)
+		}
+	}
+
+	#[derive(Debug, Clone)]
+	struct ArbitraryPeers(HashMap<PeerId, PeerSync<Block>>);
+
+	impl Arbitrary for ArbitraryPeers {
+		fn arbitrary(g: &mut Gen) -> Self {
+			let mut peers = HashMap::with_capacity(g.size());
+			for _ in 0..g.size() {
+				let ps = ArbitraryPeerSync::arbitrary(g).0;
+				peers.insert(ps.peer_id, ps);
+			}
+			ArbitraryPeers(peers)
+		}
+	}
+}
diff --git a/substrate/client/network/sync/src/lib.rs b/substrate/client/network/sync/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..175c1c43f46f703d09404a79a1234eecf6149e30
--- /dev/null
+++ b/substrate/client/network/sync/src/lib.rs
@@ -0,0 +1,4191 @@
+// 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/>.
+
+//! Contains the state of the chain synchronization process
+//!
+//! At any given point in time, a running node tries as much as possible to be at the head of the
+//! chain. This module handles the logic of which blocks to request from remotes, and processing
+//! responses. It yields blocks to check and potentially move to the database.
+//!
+//! # Usage
+//!
+//! The `ChainSync` struct maintains the state of the block requests. Whenever something happens on
+//! the network, or whenever a block has been successfully verified, call the appropriate method in
+//! order to update it.
+
+use crate::{
+	blocks::BlockCollection,
+	schema::v1::{StateRequest, StateResponse},
+	state::StateSync,
+	warp::{WarpProofImportResult, WarpSync},
+};
+
+use codec::{Decode, DecodeAll, Encode};
+use extra_requests::ExtraRequests;
+use futures::{
+	channel::oneshot, stream::FuturesUnordered, task::Poll, Future, FutureExt, StreamExt,
+};
+use libp2p::{request_response::OutboundFailure, PeerId};
+use log::{debug, error, info, trace, warn};
+use prost::Message;
+
+use prometheus_endpoint::{register, Counter, PrometheusError, Registry, U64};
+use sc_client_api::{BlockBackend, ProofProvider};
+use sc_consensus::{
+	import_queue::ImportQueueService, BlockImportError, BlockImportStatus, IncomingBlock,
+};
+use sc_network::{
+	config::{
+		NonDefaultSetConfig, NonReservedPeerMode, NotificationHandshake, ProtocolId, SetConfig,
+	},
+	request_responses::{IfDisconnected, RequestFailure},
+	types::ProtocolName,
+};
+use sc_network_common::{
+	role::Roles,
+	sync::{
+		message::{
+			BlockAnnounce, BlockAnnouncesHandshake, BlockAttributes, BlockData, BlockRequest,
+			BlockResponse, Direction, FromBlock,
+		},
+		warp::{EncodedProof, WarpProofRequest, WarpSyncParams, WarpSyncPhase, WarpSyncProgress},
+		BadPeer, ChainSync as ChainSyncT, ImportResult, Metrics, OnBlockData, OnBlockJustification,
+		OnStateData, OpaqueBlockRequest, OpaqueBlockResponse, OpaqueStateRequest,
+		OpaqueStateResponse, PeerInfo, PeerRequest, PollBlockAnnounceValidation, SyncMode,
+		SyncState, SyncStatus,
+	},
+};
+use sp_arithmetic::traits::Saturating;
+use sp_blockchain::{Error as ClientError, HeaderBackend, HeaderMetadata};
+use sp_consensus::{
+	block_validation::{BlockAnnounceValidator, Validation},
+	BlockOrigin, BlockStatus,
+};
+use sp_runtime::{
+	traits::{
+		Block as BlockT, CheckedSub, Hash, HashingFor, Header as HeaderT, NumberFor, One,
+		SaturatedConversion, Zero,
+	},
+	EncodedJustification, Justifications,
+};
+
+use std::{
+	collections::{hash_map::Entry, HashMap, HashSet},
+	iter,
+	ops::Range,
+	pin::Pin,
+	sync::Arc,
+};
+
+pub use service::chain_sync::SyncingService;
+
+mod extra_requests;
+mod schema;
+
+pub mod block_request_handler;
+pub mod blocks;
+pub mod engine;
+pub mod mock;
+pub mod service;
+pub mod state;
+pub mod state_request_handler;
+pub mod warp;
+pub mod warp_request_handler;
+
+/// Maximum blocks to store in the import queue.
+const MAX_IMPORTING_BLOCKS: usize = 2048;
+
+/// Maximum blocks to download ahead of any gap.
+const MAX_DOWNLOAD_AHEAD: u32 = 2048;
+
+/// Maximum blocks to look backwards. The gap is the difference between the highest block and the
+/// common block of a node.
+const MAX_BLOCKS_TO_LOOK_BACKWARDS: u32 = MAX_DOWNLOAD_AHEAD / 2;
+
+/// Maximum number of concurrent block announce validations.
+///
+/// If the queue reaches the maximum, we drop any new block
+/// announcements.
+const MAX_CONCURRENT_BLOCK_ANNOUNCE_VALIDATIONS: usize = 256;
+
+/// Maximum number of concurrent block announce validations per peer.
+///
+/// See [`MAX_CONCURRENT_BLOCK_ANNOUNCE_VALIDATIONS`] for more information.
+const MAX_CONCURRENT_BLOCK_ANNOUNCE_VALIDATIONS_PER_PEER: usize = 4;
+
+/// Pick the state to sync as the latest finalized number minus this.
+const STATE_SYNC_FINALITY_THRESHOLD: u32 = 8;
+
+/// We use a heuristic that with a high likelihood, by the time
+/// `MAJOR_SYNC_BLOCKS` have been imported we'll be on the same
+/// chain as (or at least closer to) the peer so we want to delay
+/// the ancestor search to not waste time doing that when we are
+/// so far behind.
+const MAJOR_SYNC_BLOCKS: u8 = 5;
+
+/// Number of peers that need to be connected before warp sync is started.
+const MIN_PEERS_TO_START_WARP_SYNC: usize = 3;
+
+/// Maximum allowed size for a block announce.
+const MAX_BLOCK_ANNOUNCE_SIZE: u64 = 1024 * 1024;
+
+/// Maximum blocks per response.
+pub(crate) const MAX_BLOCKS_IN_RESPONSE: usize = 128;
+
+mod rep {
+	use sc_network::ReputationChange as Rep;
+	/// Reputation change when a peer sent us a message that led to a
+	/// database read error.
+	pub const BLOCKCHAIN_READ_ERROR: Rep = Rep::new(-(1 << 16), "DB Error");
+
+	/// Reputation change when a peer sent us a status message with a different
+	/// genesis than us.
+	pub const GENESIS_MISMATCH: Rep = Rep::new(i32::MIN, "Genesis mismatch");
+
+	/// Reputation change for peers which send us a block with an incomplete header.
+	pub const INCOMPLETE_HEADER: Rep = Rep::new(-(1 << 20), "Incomplete header");
+
+	/// Reputation change for peers which send us a block which we fail to verify.
+	pub const VERIFICATION_FAIL: Rep = Rep::new(-(1 << 29), "Block verification failed");
+
+	/// Reputation change for peers which send us a known bad block.
+	pub const BAD_BLOCK: Rep = Rep::new(-(1 << 29), "Bad block");
+
+	/// Peer did not provide us with advertised block data.
+	pub const NO_BLOCK: Rep = Rep::new(-(1 << 29), "No requested block data");
+
+	/// Reputation change for peers which send us non-requested block data.
+	pub const NOT_REQUESTED: Rep = Rep::new(-(1 << 29), "Not requested block data");
+
+	/// Reputation change for peers which send us a block with bad justifications.
+	pub const BAD_JUSTIFICATION: Rep = Rep::new(-(1 << 16), "Bad justification");
+
+	/// Reputation change when a peer sent us invlid ancestry result.
+	pub const UNKNOWN_ANCESTOR: Rep = Rep::new(-(1 << 16), "DB Error");
+
+	/// Peer response data does not have requested bits.
+	pub const BAD_RESPONSE: Rep = Rep::new(-(1 << 12), "Incomplete response");
+
+	/// Reputation change when a peer doesn't respond in time to our messages.
+	pub const TIMEOUT: Rep = Rep::new(-(1 << 10), "Request timeout");
+
+	/// Peer is on unsupported protocol version.
+	pub const BAD_PROTOCOL: Rep = Rep::new_fatal("Unsupported protocol");
+
+	/// Reputation change when a peer refuses a request.
+	pub const REFUSED: Rep = Rep::new(-(1 << 10), "Request refused");
+
+	/// We received a message that failed to decode.
+	pub const BAD_MESSAGE: Rep = Rep::new(-(1 << 12), "Bad message");
+}
+
+enum AllowedRequests {
+	Some(HashSet<PeerId>),
+	All,
+}
+
+impl AllowedRequests {
+	fn add(&mut self, id: &PeerId) {
+		if let Self::Some(ref mut set) = self {
+			set.insert(*id);
+		}
+	}
+
+	fn take(&mut self) -> Self {
+		std::mem::take(self)
+	}
+
+	fn set_all(&mut self) {
+		*self = Self::All;
+	}
+
+	fn contains(&self, id: &PeerId) -> bool {
+		match self {
+			Self::Some(set) => set.contains(id),
+			Self::All => true,
+		}
+	}
+
+	fn is_empty(&self) -> bool {
+		match self {
+			Self::Some(set) => set.is_empty(),
+			Self::All => false,
+		}
+	}
+
+	fn clear(&mut self) {
+		std::mem::take(self);
+	}
+}
+
+impl Default for AllowedRequests {
+	fn default() -> Self {
+		Self::Some(HashSet::default())
+	}
+}
+
+struct SyncingMetrics {
+	pub import_queue_blocks_submitted: Counter<U64>,
+	pub import_queue_justifications_submitted: Counter<U64>,
+}
+
+impl SyncingMetrics {
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			import_queue_blocks_submitted: register(
+				Counter::new(
+					"substrate_sync_import_queue_blocks_submitted",
+					"Number of blocks submitted to the import queue.",
+				)?,
+				registry,
+			)?,
+			import_queue_justifications_submitted: register(
+				Counter::new(
+					"substrate_sync_import_queue_justifications_submitted",
+					"Number of justifications submitted to the import queue.",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+struct GapSync<B: BlockT> {
+	blocks: BlockCollection<B>,
+	best_queued_number: NumberFor<B>,
+	target: NumberFor<B>,
+}
+
+type PendingResponse<B> = Pin<
+	Box<
+		dyn Future<
+				Output = (
+					PeerId,
+					PeerRequest<B>,
+					Result<Result<Vec<u8>, RequestFailure>, oneshot::Canceled>,
+				),
+			> + Send,
+	>,
+>;
+
+/// The main data structure which contains all the state for a chains
+/// active syncing strategy.
+pub struct ChainSync<B: BlockT, Client> {
+	/// Chain client.
+	client: Arc<Client>,
+	/// The active peers that we are using to sync and their PeerSync status
+	peers: HashMap<PeerId, PeerSync<B>>,
+	/// A `BlockCollection` of blocks that are being downloaded from peers
+	blocks: BlockCollection<B>,
+	/// The best block number in our queue of blocks to import
+	best_queued_number: NumberFor<B>,
+	/// The best block hash in our queue of blocks to import
+	best_queued_hash: B::Hash,
+	/// Current mode (full/light)
+	mode: SyncMode,
+	/// Any extra justification requests.
+	extra_justifications: ExtraRequests<B>,
+	/// A set of hashes of blocks that are being downloaded or have been
+	/// downloaded and are queued for import.
+	queue_blocks: HashSet<B::Hash>,
+	/// Fork sync targets.
+	fork_targets: HashMap<B::Hash, ForkTarget<B>>,
+	/// A set of peers for which there might be potential block requests
+	allowed_requests: AllowedRequests,
+	/// A type to check incoming block announcements.
+	block_announce_validator: Box<dyn BlockAnnounceValidator<B> + Send>,
+	/// Maximum number of peers to ask the same blocks in parallel.
+	max_parallel_downloads: u32,
+	/// Maximum blocks per request.
+	max_blocks_per_request: u32,
+	/// Total number of downloaded blocks.
+	downloaded_blocks: usize,
+	/// All block announcement that are currently being validated.
+	block_announce_validation:
+		FuturesUnordered<Pin<Box<dyn Future<Output = PreValidateBlockAnnounce<B::Header>> + Send>>>,
+	/// Stats per peer about the number of concurrent block announce validations.
+	block_announce_validation_per_peer_stats: HashMap<PeerId, usize>,
+	/// State sync in progress, if any.
+	state_sync: Option<StateSync<B, Client>>,
+	/// Warp sync in progress, if any.
+	warp_sync: Option<WarpSync<B, Client>>,
+	/// Warp sync params.
+	///
+	/// Will be `None` after `self.warp_sync` is `Some(_)`.
+	warp_sync_params: Option<WarpSyncParams<B>>,
+	/// Enable importing existing blocks. This is used used after the state download to
+	/// catch up to the latest state while re-importing blocks.
+	import_existing: bool,
+	/// Gap download process.
+	gap_sync: Option<GapSync<B>>,
+	/// Handle for communicating with `NetworkService`
+	network_service: service::network::NetworkServiceHandle,
+	/// Protocol name used for block announcements
+	block_announce_protocol_name: ProtocolName,
+	/// Protocol name used to send out block requests
+	block_request_protocol_name: ProtocolName,
+	/// Protocol name used to send out state requests
+	state_request_protocol_name: ProtocolName,
+	/// Protocol name used to send out warp sync requests
+	warp_sync_protocol_name: Option<ProtocolName>,
+	/// Pending responses
+	pending_responses: HashMap<PeerId, PendingResponse<B>>,
+	/// Handle to import queue.
+	import_queue: Box<dyn ImportQueueService<B>>,
+	/// Metrics.
+	metrics: Option<SyncingMetrics>,
+}
+
+/// All the data we have about a Peer that we are trying to sync with
+#[derive(Debug, Clone)]
+pub struct PeerSync<B: BlockT> {
+	/// Peer id of this peer.
+	pub peer_id: PeerId,
+	/// The common number is the block number that is a common point of
+	/// ancestry for both our chains (as far as we know).
+	pub common_number: NumberFor<B>,
+	/// The hash of the best block that we've seen for this peer.
+	pub best_hash: B::Hash,
+	/// The number of the best block that we've seen for this peer.
+	pub best_number: NumberFor<B>,
+	/// The state of syncing this peer is in for us, generally categories
+	/// into `Available` or "busy" with something as defined by `PeerSyncState`.
+	pub state: PeerSyncState<B>,
+}
+
+impl<B: BlockT> PeerSync<B> {
+	/// Update the `common_number` iff `new_common > common_number`.
+	fn update_common_number(&mut self, new_common: NumberFor<B>) {
+		if self.common_number < new_common {
+			trace!(
+				target: "sync",
+				"Updating peer {} common number from={} => to={}.",
+				self.peer_id,
+				self.common_number,
+				new_common,
+			);
+			self.common_number = new_common;
+		}
+	}
+}
+
+struct ForkTarget<B: BlockT> {
+	number: NumberFor<B>,
+	parent_hash: Option<B::Hash>,
+	peers: HashSet<PeerId>,
+}
+
+/// The state of syncing between a Peer and ourselves.
+///
+/// Generally two categories, "busy" or `Available`. If busy, the enum
+/// defines what we are busy with.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum PeerSyncState<B: BlockT> {
+	/// Available for sync requests.
+	Available,
+	/// Searching for ancestors the Peer has in common with us.
+	AncestorSearch { start: NumberFor<B>, current: NumberFor<B>, state: AncestorSearchState<B> },
+	/// Actively downloading new blocks, starting from the given Number.
+	DownloadingNew(NumberFor<B>),
+	/// Downloading a stale block with given Hash. Stale means that it is a
+	/// block with a number that is lower than our best number. It might be
+	/// from a fork and not necessarily already imported.
+	DownloadingStale(B::Hash),
+	/// Downloading justification for given block hash.
+	DownloadingJustification(B::Hash),
+	/// Downloading state.
+	DownloadingState,
+	/// Downloading warp proof.
+	DownloadingWarpProof,
+	/// Downloading warp sync target block.
+	DownloadingWarpTargetBlock,
+	/// Actively downloading block history after warp sync.
+	DownloadingGap(NumberFor<B>),
+}
+
+impl<B: BlockT> PeerSyncState<B> {
+	pub fn is_available(&self) -> bool {
+		matches!(self, Self::Available)
+	}
+}
+
+/// Result of [`ChainSync::block_announce_validation`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum PreValidateBlockAnnounce<H> {
+	/// The announcement failed at validation.
+	///
+	/// The peer reputation should be decreased.
+	Failure {
+		/// Who sent the processed block announcement?
+		who: PeerId,
+		/// Should the peer be disconnected?
+		disconnect: bool,
+	},
+	/// The pre-validation was sucessful and the announcement should be
+	/// further processed.
+	Process {
+		/// Is this the new best block of the peer?
+		is_new_best: bool,
+		/// The id of the peer that send us the announcement.
+		who: PeerId,
+		/// The announcement.
+		announce: BlockAnnounce<H>,
+	},
+	/// The announcement validation returned an error.
+	///
+	/// An error means that *this* node failed to validate it because some internal error happened.
+	/// If the block announcement was invalid, [`Self::Failure`] is the correct variant to express
+	/// this.
+	Error { who: PeerId },
+	/// The block announcement should be skipped.
+	///
+	/// This should *only* be returned when there wasn't a slot registered
+	/// for this block announcement validation.
+	Skip,
+}
+
+/// Result of [`ChainSync::has_slot_for_block_announce_validation`].
+enum HasSlotForBlockAnnounceValidation {
+	/// Yes, there is a slot for the block announce validation.
+	Yes,
+	/// We reached the total maximum number of validation slots.
+	TotalMaximumSlotsReached,
+	/// We reached the maximum number of validation slots for the given peer.
+	MaximumPeerSlotsReached,
+}
+
+impl<B, Client> ChainSyncT<B> for ChainSync<B, Client>
+where
+	B: BlockT,
+	Client: HeaderBackend<B>
+		+ BlockBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ ProofProvider<B>
+		+ Send
+		+ Sync
+		+ 'static,
+{
+	fn peer_info(&self, who: &PeerId) -> Option<PeerInfo<B>> {
+		self.peers
+			.get(who)
+			.map(|p| PeerInfo { best_hash: p.best_hash, best_number: p.best_number })
+	}
+
+	/// Returns the current sync status.
+	fn status(&self) -> SyncStatus<B> {
+		let median_seen = self.median_seen();
+		let best_seen_block =
+			median_seen.and_then(|median| (median > self.best_queued_number).then_some(median));
+		let sync_state = if let Some(target) = median_seen {
+			// A chain is classified as downloading if the provided best block is
+			// more than `MAJOR_SYNC_BLOCKS` behind the best block or as importing
+			// if the same can be said about queued blocks.
+			let best_block = self.client.info().best_number;
+			if target > best_block && target - best_block > MAJOR_SYNC_BLOCKS.into() {
+				// If target is not queued, we're downloading, otherwise importing.
+				if target > self.best_queued_number {
+					SyncState::Downloading { target }
+				} else {
+					SyncState::Importing { target }
+				}
+			} else {
+				SyncState::Idle
+			}
+		} else {
+			SyncState::Idle
+		};
+
+		let warp_sync_progress = match (&self.warp_sync, &self.mode, &self.gap_sync) {
+			(_, _, Some(gap_sync)) => Some(WarpSyncProgress {
+				phase: WarpSyncPhase::DownloadingBlocks(gap_sync.best_queued_number),
+				total_bytes: 0,
+			}),
+			(None, SyncMode::Warp, _) => Some(WarpSyncProgress {
+				phase: WarpSyncPhase::AwaitingPeers {
+					required_peers: MIN_PEERS_TO_START_WARP_SYNC,
+				},
+				total_bytes: 0,
+			}),
+			(Some(sync), _, _) => Some(sync.progress()),
+			_ => None,
+		};
+
+		SyncStatus {
+			state: sync_state,
+			best_seen_block,
+			num_peers: self.peers.len() as u32,
+			num_connected_peers: 0u32,
+			queued_blocks: self.queue_blocks.len() as u32,
+			state_sync: self.state_sync.as_ref().map(|s| s.progress()),
+			warp_sync: warp_sync_progress,
+		}
+	}
+
+	fn num_sync_requests(&self) -> usize {
+		self.fork_targets
+			.values()
+			.filter(|f| f.number <= self.best_queued_number)
+			.count()
+	}
+
+	fn num_downloaded_blocks(&self) -> usize {
+		self.downloaded_blocks
+	}
+
+	fn num_peers(&self) -> usize {
+		self.peers.len()
+	}
+
+	fn num_active_peers(&self) -> usize {
+		self.pending_responses.len()
+	}
+
+	fn new_peer(
+		&mut self,
+		who: PeerId,
+		best_hash: B::Hash,
+		best_number: NumberFor<B>,
+	) -> Result<Option<BlockRequest<B>>, BadPeer> {
+		// There is nothing sync can get from the node that has no blockchain data.
+		match self.block_status(&best_hash) {
+			Err(e) => {
+				debug!(target:"sync", "Error reading blockchain: {}", e);
+				Err(BadPeer(who, rep::BLOCKCHAIN_READ_ERROR))
+			},
+			Ok(BlockStatus::KnownBad) => {
+				info!("💔 New peer with known bad best block {} ({}).", best_hash, best_number);
+				Err(BadPeer(who, rep::BAD_BLOCK))
+			},
+			Ok(BlockStatus::Unknown) => {
+				if best_number.is_zero() {
+					info!("💔 New peer with unknown genesis hash {} ({}).", best_hash, best_number);
+					return Err(BadPeer(who, rep::GENESIS_MISMATCH))
+				}
+
+				// If there are more than `MAJOR_SYNC_BLOCKS` in the import queue then we have
+				// enough to do in the import queue that it's not worth kicking off
+				// an ancestor search, which is what we do in the next match case below.
+				if self.queue_blocks.len() > MAJOR_SYNC_BLOCKS.into() {
+					debug!(
+						target:"sync",
+						"New peer with unknown best hash {} ({}), assuming common block.",
+						self.best_queued_hash,
+						self.best_queued_number
+					);
+					self.peers.insert(
+						who,
+						PeerSync {
+							peer_id: who,
+							common_number: self.best_queued_number,
+							best_hash,
+							best_number,
+							state: PeerSyncState::Available,
+						},
+					);
+					return Ok(None)
+				}
+
+				// If we are at genesis, just start downloading.
+				let (state, req) = if self.best_queued_number.is_zero() {
+					debug!(
+						target:"sync",
+						"New peer with best hash {} ({}).",
+						best_hash,
+						best_number,
+					);
+
+					(PeerSyncState::Available, None)
+				} else {
+					let common_best = std::cmp::min(self.best_queued_number, best_number);
+
+					debug!(
+						target:"sync",
+						"New peer with unknown best hash {} ({}), searching for common ancestor.",
+						best_hash,
+						best_number
+					);
+
+					(
+						PeerSyncState::AncestorSearch {
+							current: common_best,
+							start: self.best_queued_number,
+							state: AncestorSearchState::ExponentialBackoff(One::one()),
+						},
+						Some(ancestry_request::<B>(common_best)),
+					)
+				};
+
+				self.allowed_requests.add(&who);
+				self.peers.insert(
+					who,
+					PeerSync {
+						peer_id: who,
+						common_number: Zero::zero(),
+						best_hash,
+						best_number,
+						state,
+					},
+				);
+
+				if let SyncMode::Warp = self.mode {
+					if self.peers.len() >= MIN_PEERS_TO_START_WARP_SYNC && self.warp_sync.is_none()
+					{
+						log::debug!(target: "sync", "Starting warp state sync.");
+						if let Some(params) = self.warp_sync_params.take() {
+							self.warp_sync = Some(WarpSync::new(self.client.clone(), params));
+						}
+					}
+				}
+				Ok(req)
+			},
+			Ok(BlockStatus::Queued) |
+			Ok(BlockStatus::InChainWithState) |
+			Ok(BlockStatus::InChainPruned) => {
+				debug!(
+					target: "sync",
+					"New peer with known best hash {} ({}).",
+					best_hash,
+					best_number,
+				);
+				self.peers.insert(
+					who,
+					PeerSync {
+						peer_id: who,
+						common_number: std::cmp::min(self.best_queued_number, best_number),
+						best_hash,
+						best_number,
+						state: PeerSyncState::Available,
+					},
+				);
+				self.allowed_requests.add(&who);
+				Ok(None)
+			},
+		}
+	}
+
+	fn update_chain_info(&mut self, best_hash: &B::Hash, best_number: NumberFor<B>) {
+		self.on_block_queued(best_hash, best_number);
+	}
+
+	fn request_justification(&mut self, hash: &B::Hash, number: NumberFor<B>) {
+		let client = &self.client;
+		self.extra_justifications
+			.schedule((*hash, number), |base, block| is_descendent_of(&**client, base, block))
+	}
+
+	fn clear_justification_requests(&mut self) {
+		self.extra_justifications.reset();
+	}
+
+	// The implementation is similar to on_block_announce with unknown parent hash.
+	fn set_sync_fork_request(
+		&mut self,
+		mut peers: Vec<PeerId>,
+		hash: &B::Hash,
+		number: NumberFor<B>,
+	) {
+		if peers.is_empty() {
+			peers = self
+				.peers
+				.iter()
+				// Only request blocks from peers who are ahead or on a par.
+				.filter(|(_, peer)| peer.best_number >= number)
+				.map(|(id, _)| *id)
+				.collect();
+
+			debug!(
+				target: "sync",
+				"Explicit sync request for block {:?} with no peers specified. \
+				Syncing from these peers {:?} instead.",
+				hash, peers,
+			);
+		} else {
+			debug!(target: "sync", "Explicit sync request for block {:?} with {:?}", hash, peers);
+		}
+
+		if self.is_known(hash) {
+			debug!(target: "sync", "Refusing to sync known hash {:?}", hash);
+			return
+		}
+
+		trace!(target: "sync", "Downloading requested old fork {:?}", hash);
+		for peer_id in &peers {
+			if let Some(peer) = self.peers.get_mut(peer_id) {
+				if let PeerSyncState::AncestorSearch { .. } = peer.state {
+					continue
+				}
+
+				if number > peer.best_number {
+					peer.best_number = number;
+					peer.best_hash = *hash;
+				}
+				self.allowed_requests.add(peer_id);
+			}
+		}
+
+		self.fork_targets
+			.entry(*hash)
+			.or_insert_with(|| ForkTarget { number, peers: Default::default(), parent_hash: None })
+			.peers
+			.extend(peers);
+	}
+
+	fn on_block_data(
+		&mut self,
+		who: &PeerId,
+		request: Option<BlockRequest<B>>,
+		response: BlockResponse<B>,
+	) -> Result<OnBlockData<B>, BadPeer> {
+		self.downloaded_blocks += response.blocks.len();
+		let mut gap = false;
+		let new_blocks: Vec<IncomingBlock<B>> = if let Some(peer) = self.peers.get_mut(who) {
+			let mut blocks = response.blocks;
+			if request.as_ref().map_or(false, |r| r.direction == Direction::Descending) {
+				trace!(target: "sync", "Reversing incoming block list");
+				blocks.reverse()
+			}
+			self.allowed_requests.add(who);
+			if let Some(request) = request {
+				match &mut peer.state {
+					PeerSyncState::DownloadingNew(_) => {
+						self.blocks.clear_peer_download(who);
+						peer.state = PeerSyncState::Available;
+						if let Some(start_block) =
+							validate_blocks::<B>(&blocks, who, Some(request))?
+						{
+							self.blocks.insert(start_block, blocks, *who);
+						}
+						self.ready_blocks()
+					},
+					PeerSyncState::DownloadingGap(_) => {
+						peer.state = PeerSyncState::Available;
+						if let Some(gap_sync) = &mut self.gap_sync {
+							gap_sync.blocks.clear_peer_download(who);
+							if let Some(start_block) =
+								validate_blocks::<B>(&blocks, who, Some(request))?
+							{
+								gap_sync.blocks.insert(start_block, blocks, *who);
+							}
+							gap = true;
+							let blocks: Vec<_> = gap_sync
+								.blocks
+								.ready_blocks(gap_sync.best_queued_number + One::one())
+								.into_iter()
+								.map(|block_data| {
+									let justifications =
+										block_data.block.justifications.or_else(|| {
+											legacy_justification_mapping(
+												block_data.block.justification,
+											)
+										});
+									IncomingBlock {
+										hash: block_data.block.hash,
+										header: block_data.block.header,
+										body: block_data.block.body,
+										indexed_body: block_data.block.indexed_body,
+										justifications,
+										origin: block_data.origin,
+										allow_missing_state: true,
+										import_existing: self.import_existing,
+										skip_execution: true,
+										state: None,
+									}
+								})
+								.collect();
+							debug!(target: "sync", "Drained {} gap blocks from {}", blocks.len(), gap_sync.best_queued_number);
+							blocks
+						} else {
+							debug!(target: "sync", "Unexpected gap block response from {}", who);
+							return Err(BadPeer(*who, rep::NO_BLOCK))
+						}
+					},
+					PeerSyncState::DownloadingStale(_) => {
+						peer.state = PeerSyncState::Available;
+						if blocks.is_empty() {
+							debug!(target: "sync", "Empty block response from {}", who);
+							return Err(BadPeer(*who, rep::NO_BLOCK))
+						}
+						validate_blocks::<B>(&blocks, who, Some(request))?;
+						blocks
+							.into_iter()
+							.map(|b| {
+								let justifications = b
+									.justifications
+									.or_else(|| legacy_justification_mapping(b.justification));
+								IncomingBlock {
+									hash: b.hash,
+									header: b.header,
+									body: b.body,
+									indexed_body: None,
+									justifications,
+									origin: Some(*who),
+									allow_missing_state: true,
+									import_existing: self.import_existing,
+									skip_execution: self.skip_execution(),
+									state: None,
+								}
+							})
+							.collect()
+					},
+					PeerSyncState::AncestorSearch { current, start, state } => {
+						let matching_hash = match (blocks.get(0), self.client.hash(*current)) {
+							(Some(block), Ok(maybe_our_block_hash)) => {
+								trace!(
+									target: "sync",
+									"Got ancestry block #{} ({}) from peer {}",
+									current,
+									block.hash,
+									who,
+								);
+								maybe_our_block_hash.filter(|x| x == &block.hash)
+							},
+							(None, _) => {
+								debug!(
+									target: "sync",
+									"Invalid response when searching for ancestor from {}",
+									who,
+								);
+								return Err(BadPeer(*who, rep::UNKNOWN_ANCESTOR))
+							},
+							(_, Err(e)) => {
+								info!(
+									target: "sync",
+									"� Error answering legitimate blockchain query: {}",
+									e,
+								);
+								return Err(BadPeer(*who, rep::BLOCKCHAIN_READ_ERROR))
+							},
+						};
+						if matching_hash.is_some() {
+							if *start < self.best_queued_number &&
+								self.best_queued_number <= peer.best_number
+							{
+								// We've made progress on this chain since the search was started.
+								// Opportunistically set common number to updated number
+								// instead of the one that started the search.
+								peer.common_number = self.best_queued_number;
+							} else if peer.common_number < *current {
+								peer.common_number = *current;
+							}
+						}
+						if matching_hash.is_none() && current.is_zero() {
+							trace!(target:"sync", "Ancestry search: genesis mismatch for peer {}", who);
+							return Err(BadPeer(*who, rep::GENESIS_MISMATCH))
+						}
+						if let Some((next_state, next_num)) =
+							handle_ancestor_search_state(state, *current, matching_hash.is_some())
+						{
+							peer.state = PeerSyncState::AncestorSearch {
+								current: next_num,
+								start: *start,
+								state: next_state,
+							};
+							return Ok(OnBlockData::Request(*who, ancestry_request::<B>(next_num)))
+						} else {
+							// Ancestry search is complete. Check if peer is on a stale fork unknown
+							// to us and add it to sync targets if necessary.
+							trace!(
+								target: "sync",
+								"Ancestry search complete. Ours={} ({}), Theirs={} ({}), Common={:?} ({})",
+								self.best_queued_hash,
+								self.best_queued_number,
+								peer.best_hash,
+								peer.best_number,
+								matching_hash,
+								peer.common_number,
+							);
+							if peer.common_number < peer.best_number &&
+								peer.best_number < self.best_queued_number
+							{
+								trace!(
+									target: "sync",
+									"Added fork target {} for {}",
+									peer.best_hash,
+									who,
+								);
+								self.fork_targets
+									.entry(peer.best_hash)
+									.or_insert_with(|| ForkTarget {
+										number: peer.best_number,
+										parent_hash: None,
+										peers: Default::default(),
+									})
+									.peers
+									.insert(*who);
+							}
+							peer.state = PeerSyncState::Available;
+							Vec::new()
+						}
+					},
+					PeerSyncState::DownloadingWarpTargetBlock => {
+						peer.state = PeerSyncState::Available;
+						if let Some(warp_sync) = &mut self.warp_sync {
+							if blocks.len() == 1 {
+								validate_blocks::<B>(&blocks, who, Some(request))?;
+								match warp_sync.import_target_block(
+									blocks.pop().expect("`blocks` len checked above."),
+								) {
+									warp::TargetBlockImportResult::Success =>
+										return Ok(OnBlockData::Continue),
+									warp::TargetBlockImportResult::BadResponse =>
+										return Err(BadPeer(*who, rep::VERIFICATION_FAIL)),
+								}
+							} else if blocks.is_empty() {
+								debug!(target: "sync", "Empty block response from {}", who);
+								return Err(BadPeer(*who, rep::NO_BLOCK))
+							} else {
+								debug!(
+									target: "sync",
+									"Too many blocks ({}) in warp target block response from {}",
+									blocks.len(),
+									who,
+								);
+								return Err(BadPeer(*who, rep::NOT_REQUESTED))
+							}
+						} else {
+							debug!(
+								target: "sync",
+								"Logic error: we think we are downloading warp target block from {}, but no warp sync is happening.",
+								who,
+							);
+							return Ok(OnBlockData::Continue)
+						}
+					},
+					PeerSyncState::Available |
+					PeerSyncState::DownloadingJustification(..) |
+					PeerSyncState::DownloadingState |
+					PeerSyncState::DownloadingWarpProof => Vec::new(),
+				}
+			} else {
+				// When request.is_none() this is a block announcement. Just accept blocks.
+				validate_blocks::<B>(&blocks, who, None)?;
+				blocks
+					.into_iter()
+					.map(|b| {
+						let justifications = b
+							.justifications
+							.or_else(|| legacy_justification_mapping(b.justification));
+						IncomingBlock {
+							hash: b.hash,
+							header: b.header,
+							body: b.body,
+							indexed_body: None,
+							justifications,
+							origin: Some(*who),
+							allow_missing_state: true,
+							import_existing: false,
+							skip_execution: true,
+							state: None,
+						}
+					})
+					.collect()
+			}
+		} else {
+			// We don't know of this peer, so we also did not request anything from it.
+			return Err(BadPeer(*who, rep::NOT_REQUESTED))
+		};
+
+		Ok(self.validate_and_queue_blocks(new_blocks, gap))
+	}
+
+	fn on_block_justification(
+		&mut self,
+		who: PeerId,
+		response: BlockResponse<B>,
+	) -> Result<OnBlockJustification<B>, BadPeer> {
+		let peer = if let Some(peer) = self.peers.get_mut(&who) {
+			peer
+		} else {
+			error!(target: "sync", "💔 Called on_block_justification with a peer ID of an unknown peer");
+			return Ok(OnBlockJustification::Nothing)
+		};
+
+		self.allowed_requests.add(&who);
+		if let PeerSyncState::DownloadingJustification(hash) = peer.state {
+			peer.state = PeerSyncState::Available;
+
+			// We only request one justification at a time
+			let justification = if let Some(block) = response.blocks.into_iter().next() {
+				if hash != block.hash {
+					warn!(
+						target: "sync",
+						"💔 Invalid block justification provided by {}: requested: {:?} got: {:?}",
+						who,
+						hash,
+						block.hash,
+					);
+					return Err(BadPeer(who, rep::BAD_JUSTIFICATION))
+				}
+
+				block
+					.justifications
+					.or_else(|| legacy_justification_mapping(block.justification))
+			} else {
+				// we might have asked the peer for a justification on a block that we assumed it
+				// had but didn't (regardless of whether it had a justification for it or not).
+				trace!(
+					target: "sync",
+					"Peer {:?} provided empty response for justification request {:?}",
+					who,
+					hash,
+				);
+
+				None
+			};
+
+			if let Some((peer, hash, number, j)) =
+				self.extra_justifications.on_response(who, justification)
+			{
+				return Ok(OnBlockJustification::Import { peer, hash, number, justifications: j })
+			}
+		}
+
+		Ok(OnBlockJustification::Nothing)
+	}
+
+	fn on_justification_import(&mut self, hash: B::Hash, number: NumberFor<B>, success: bool) {
+		let finalization_result = if success { Ok((hash, number)) } else { Err(()) };
+		self.extra_justifications
+			.try_finalize_root((hash, number), finalization_result, true);
+		self.allowed_requests.set_all();
+	}
+
+	fn on_block_finalized(&mut self, hash: &B::Hash, number: NumberFor<B>) {
+		let client = &self.client;
+		let r = self.extra_justifications.on_block_finalized(hash, number, |base, block| {
+			is_descendent_of(&**client, base, block)
+		});
+
+		if let SyncMode::LightState { skip_proofs, .. } = &self.mode {
+			if self.state_sync.is_none() && !self.peers.is_empty() && self.queue_blocks.is_empty() {
+				// Finalized a recent block.
+				let mut heads: Vec<_> = self.peers.values().map(|peer| peer.best_number).collect();
+				heads.sort();
+				let median = heads[heads.len() / 2];
+				if number + STATE_SYNC_FINALITY_THRESHOLD.saturated_into() >= median {
+					if let Ok(Some(header)) = self.client.header(*hash) {
+						log::debug!(
+							target: "sync",
+							"Starting state sync for #{} ({})",
+							number,
+							hash,
+						);
+						self.state_sync = Some(StateSync::new(
+							self.client.clone(),
+							header,
+							None,
+							None,
+							*skip_proofs,
+						));
+						self.allowed_requests.set_all();
+					}
+				}
+			}
+		}
+
+		if let Err(err) = r {
+			warn!(
+				target: "sync",
+				"💔 Error cleaning up pending extra justification data requests: {}",
+				err,
+			);
+		}
+	}
+
+	fn push_block_announce_validation(
+		&mut self,
+		who: PeerId,
+		hash: B::Hash,
+		announce: BlockAnnounce<B::Header>,
+		is_best: bool,
+	) {
+		let header = &announce.header;
+		let number = *header.number();
+		debug!(
+			target: "sync",
+			"Pre-validating received block announcement {:?} with number {:?} from {}",
+			hash,
+			number,
+			who,
+		);
+
+		if number.is_zero() {
+			self.block_announce_validation.push(
+				async move {
+					warn!(
+						target: "sync",
+						"💔 Ignored genesis block (#0) announcement from {}: {}",
+						who,
+						hash,
+					);
+					PreValidateBlockAnnounce::Skip
+				}
+				.boxed(),
+			);
+			return
+		}
+
+		// Check if there is a slot for this block announce validation.
+		match self.has_slot_for_block_announce_validation(&who) {
+			HasSlotForBlockAnnounceValidation::Yes => {},
+			HasSlotForBlockAnnounceValidation::TotalMaximumSlotsReached => {
+				self.block_announce_validation.push(
+					async move {
+						warn!(
+							target: "sync",
+							"💔 Ignored block (#{} -- {}) announcement from {} because all validation slots are occupied.",
+							number,
+							hash,
+							who,
+						);
+						PreValidateBlockAnnounce::Skip
+					}
+					.boxed(),
+				);
+				return
+			},
+			HasSlotForBlockAnnounceValidation::MaximumPeerSlotsReached => {
+				self.block_announce_validation.push(async move {
+					warn!(
+						target: "sync",
+						"💔 Ignored block (#{} -- {}) announcement from {} because all validation slots for this peer are occupied.",
+						number,
+						hash,
+						who,
+					);
+					PreValidateBlockAnnounce::Skip
+				}.boxed());
+				return
+			},
+		}
+
+		// Let external validator check the block announcement.
+		let assoc_data = announce.data.as_ref().map_or(&[][..], |v| v.as_slice());
+		let future = self.block_announce_validator.validate(header, assoc_data);
+
+		self.block_announce_validation.push(
+			async move {
+				match future.await {
+					Ok(Validation::Success { is_new_best }) => PreValidateBlockAnnounce::Process {
+						is_new_best: is_new_best || is_best,
+						announce,
+						who,
+					},
+					Ok(Validation::Failure { disconnect }) => {
+						debug!(
+							target: "sync",
+							"Block announcement validation of block {:?} from {} failed",
+							hash,
+							who,
+						);
+						PreValidateBlockAnnounce::Failure { who, disconnect }
+					},
+					Err(e) => {
+						debug!(
+							target: "sync",
+							"💔 Block announcement validation of block {:?} errored: {}",
+							hash,
+							e,
+						);
+						PreValidateBlockAnnounce::Error { who }
+					},
+				}
+			}
+			.boxed(),
+		);
+	}
+
+	fn poll_block_announce_validation(
+		&mut self,
+		cx: &mut std::task::Context,
+	) -> Poll<PollBlockAnnounceValidation<B::Header>> {
+		match self.block_announce_validation.poll_next_unpin(cx) {
+			Poll::Ready(Some(res)) => {
+				self.peer_block_announce_validation_finished(&res);
+				Poll::Ready(self.finish_block_announce_validation(res))
+			},
+			_ => Poll::Pending,
+		}
+	}
+
+	fn peer_disconnected(&mut self, who: &PeerId) {
+		self.blocks.clear_peer_download(who);
+		if let Some(gap_sync) = &mut self.gap_sync {
+			gap_sync.blocks.clear_peer_download(who)
+		}
+		self.peers.remove(who);
+		self.pending_responses.remove(who);
+		self.extra_justifications.peer_disconnected(who);
+		self.allowed_requests.set_all();
+		self.fork_targets.retain(|_, target| {
+			target.peers.remove(who);
+			!target.peers.is_empty()
+		});
+
+		let blocks = self.ready_blocks();
+		if let Some(OnBlockData::Import(origin, blocks)) =
+			(!blocks.is_empty()).then(|| self.validate_and_queue_blocks(blocks, false))
+		{
+			self.import_blocks(origin, blocks);
+		}
+	}
+
+	fn metrics(&self) -> Metrics {
+		Metrics {
+			queued_blocks: self.queue_blocks.len().try_into().unwrap_or(std::u32::MAX),
+			fork_targets: self.fork_targets.len().try_into().unwrap_or(std::u32::MAX),
+			justifications: self.extra_justifications.metrics(),
+		}
+	}
+
+	fn block_response_into_blocks(
+		&self,
+		request: &BlockRequest<B>,
+		response: OpaqueBlockResponse,
+	) -> Result<Vec<BlockData<B>>, String> {
+		let response: Box<schema::v1::BlockResponse> = response.0.downcast().map_err(|_error| {
+			"Failed to downcast opaque block response during encoding, this is an \
+				implementation bug."
+				.to_string()
+		})?;
+
+		response
+			.blocks
+			.into_iter()
+			.map(|block_data| {
+				Ok(BlockData::<B> {
+					hash: Decode::decode(&mut block_data.hash.as_ref())?,
+					header: if !block_data.header.is_empty() {
+						Some(Decode::decode(&mut block_data.header.as_ref())?)
+					} else {
+						None
+					},
+					body: if request.fields.contains(BlockAttributes::BODY) {
+						Some(
+							block_data
+								.body
+								.iter()
+								.map(|body| Decode::decode(&mut body.as_ref()))
+								.collect::<Result<Vec<_>, _>>()?,
+						)
+					} else {
+						None
+					},
+					indexed_body: if request.fields.contains(BlockAttributes::INDEXED_BODY) {
+						Some(block_data.indexed_body)
+					} else {
+						None
+					},
+					receipt: if !block_data.receipt.is_empty() {
+						Some(block_data.receipt)
+					} else {
+						None
+					},
+					message_queue: if !block_data.message_queue.is_empty() {
+						Some(block_data.message_queue)
+					} else {
+						None
+					},
+					justification: if !block_data.justification.is_empty() {
+						Some(block_data.justification)
+					} else if block_data.is_empty_justification {
+						Some(Vec::new())
+					} else {
+						None
+					},
+					justifications: if !block_data.justifications.is_empty() {
+						Some(DecodeAll::decode_all(&mut block_data.justifications.as_ref())?)
+					} else {
+						None
+					},
+				})
+			})
+			.collect::<Result<_, _>>()
+			.map_err(|error: codec::Error| error.to_string())
+	}
+
+	fn poll(
+		&mut self,
+		cx: &mut std::task::Context,
+	) -> Poll<PollBlockAnnounceValidation<B::Header>> {
+		// Should be called before `process_outbound_requests` to ensure
+		// that a potential target block is directly leading to requests.
+		if let Some(warp_sync) = &mut self.warp_sync {
+			let _ = warp_sync.poll(cx);
+		}
+
+		self.process_outbound_requests();
+
+		while let Poll::Ready(result) = self.poll_pending_responses(cx) {
+			match result {
+				ImportResult::BlockImport(origin, blocks) => self.import_blocks(origin, blocks),
+				ImportResult::JustificationImport(who, hash, number, justifications) =>
+					self.import_justifications(who, hash, number, justifications),
+			}
+		}
+
+		if let Poll::Ready(announce) = self.poll_block_announce_validation(cx) {
+			return Poll::Ready(announce)
+		}
+
+		Poll::Pending
+	}
+
+	fn send_block_request(&mut self, who: PeerId, request: BlockRequest<B>) {
+		let (tx, rx) = oneshot::channel();
+		let opaque_req = self.create_opaque_block_request(&request);
+
+		if self.peers.contains_key(&who) {
+			self.pending_responses
+				.insert(who, Box::pin(async move { (who, PeerRequest::Block(request), rx.await) }));
+		}
+
+		match self.encode_block_request(&opaque_req) {
+			Ok(data) => {
+				self.network_service.start_request(
+					who,
+					self.block_request_protocol_name.clone(),
+					data,
+					tx,
+					IfDisconnected::ImmediateError,
+				);
+			},
+			Err(err) => {
+				log::warn!(
+					target: "sync",
+					"Failed to encode block request {:?}: {:?}",
+					opaque_req, err
+				);
+			},
+		}
+	}
+}
+
+impl<B, Client> ChainSync<B, Client>
+where
+	Self: ChainSyncT<B>,
+	B: BlockT,
+	Client: HeaderBackend<B>
+		+ BlockBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ ProofProvider<B>
+		+ Send
+		+ Sync
+		+ 'static,
+{
+	/// Create a new instance.
+	pub fn new(
+		mode: SyncMode,
+		client: Arc<Client>,
+		protocol_id: ProtocolId,
+		fork_id: &Option<String>,
+		roles: Roles,
+		block_announce_validator: Box<dyn BlockAnnounceValidator<B> + Send>,
+		max_parallel_downloads: u32,
+		max_blocks_per_request: u32,
+		warp_sync_params: Option<WarpSyncParams<B>>,
+		metrics_registry: Option<&Registry>,
+		network_service: service::network::NetworkServiceHandle,
+		import_queue: Box<dyn ImportQueueService<B>>,
+		block_request_protocol_name: ProtocolName,
+		state_request_protocol_name: ProtocolName,
+		warp_sync_protocol_name: Option<ProtocolName>,
+	) -> Result<(Self, NonDefaultSetConfig), ClientError> {
+		let block_announce_config = Self::get_block_announce_proto_config(
+			protocol_id,
+			fork_id,
+			roles,
+			client.info().best_number,
+			client.info().best_hash,
+			client
+				.block_hash(Zero::zero())
+				.ok()
+				.flatten()
+				.expect("Genesis block exists; qed"),
+		);
+
+		let mut sync = Self {
+			client,
+			peers: HashMap::new(),
+			blocks: BlockCollection::new(),
+			best_queued_hash: Default::default(),
+			best_queued_number: Zero::zero(),
+			extra_justifications: ExtraRequests::new("justification"),
+			mode,
+			queue_blocks: Default::default(),
+			fork_targets: Default::default(),
+			allowed_requests: Default::default(),
+			block_announce_validator,
+			max_parallel_downloads,
+			max_blocks_per_request,
+			downloaded_blocks: 0,
+			block_announce_validation: Default::default(),
+			block_announce_validation_per_peer_stats: Default::default(),
+			state_sync: None,
+			warp_sync: None,
+			import_existing: false,
+			gap_sync: None,
+			network_service,
+			block_request_protocol_name,
+			state_request_protocol_name,
+			warp_sync_params,
+			warp_sync_protocol_name,
+			block_announce_protocol_name: block_announce_config
+				.notifications_protocol
+				.clone()
+				.into(),
+			pending_responses: HashMap::new(),
+			import_queue,
+			metrics: if let Some(r) = &metrics_registry {
+				match SyncingMetrics::register(r) {
+					Ok(metrics) => Some(metrics),
+					Err(err) => {
+						error!(target: "sync", "Failed to register metrics for ChainSync: {err:?}");
+						None
+					},
+				}
+			} else {
+				None
+			},
+		};
+
+		sync.reset_sync_start_point()?;
+		Ok((sync, block_announce_config))
+	}
+
+	/// Returns the median seen block number.
+	fn median_seen(&self) -> Option<NumberFor<B>> {
+		let mut best_seens = self.peers.values().map(|p| p.best_number).collect::<Vec<_>>();
+
+		if best_seens.is_empty() {
+			None
+		} else {
+			let middle = best_seens.len() / 2;
+
+			// Not the "perfect median" when we have an even number of peers.
+			Some(*best_seens.select_nth_unstable(middle).1)
+		}
+	}
+
+	fn required_block_attributes(&self) -> BlockAttributes {
+		match self.mode {
+			SyncMode::Full =>
+				BlockAttributes::HEADER | BlockAttributes::JUSTIFICATION | BlockAttributes::BODY,
+			SyncMode::LightState { storage_chain_mode: false, .. } | SyncMode::Warp =>
+				BlockAttributes::HEADER | BlockAttributes::JUSTIFICATION | BlockAttributes::BODY,
+			SyncMode::LightState { storage_chain_mode: true, .. } =>
+				BlockAttributes::HEADER |
+					BlockAttributes::JUSTIFICATION |
+					BlockAttributes::INDEXED_BODY,
+		}
+	}
+
+	fn skip_execution(&self) -> bool {
+		match self.mode {
+			SyncMode::Full => false,
+			SyncMode::LightState { .. } => true,
+			SyncMode::Warp => true,
+		}
+	}
+
+	fn validate_and_queue_blocks(
+		&mut self,
+		mut new_blocks: Vec<IncomingBlock<B>>,
+		gap: bool,
+	) -> OnBlockData<B> {
+		let orig_len = new_blocks.len();
+		new_blocks.retain(|b| !self.queue_blocks.contains(&b.hash));
+		if new_blocks.len() != orig_len {
+			debug!(
+				target: "sync",
+				"Ignoring {} blocks that are already queued",
+				orig_len - new_blocks.len(),
+			);
+		}
+
+		let origin = if !gap && !self.status().state.is_major_syncing() {
+			BlockOrigin::NetworkBroadcast
+		} else {
+			BlockOrigin::NetworkInitialSync
+		};
+
+		if let Some((h, n)) = new_blocks
+			.last()
+			.and_then(|b| b.header.as_ref().map(|h| (&b.hash, *h.number())))
+		{
+			trace!(
+				target:"sync",
+				"Accepted {} blocks ({:?}) with origin {:?}",
+				new_blocks.len(),
+				h,
+				origin,
+			);
+			self.on_block_queued(h, n)
+		}
+		self.queue_blocks.extend(new_blocks.iter().map(|b| b.hash));
+		OnBlockData::Import(origin, new_blocks)
+	}
+
+	fn update_peer_common_number(&mut self, peer_id: &PeerId, new_common: NumberFor<B>) {
+		if let Some(peer) = self.peers.get_mut(peer_id) {
+			peer.update_common_number(new_common);
+		}
+	}
+
+	/// Called when a block has been queued for import.
+	///
+	/// Updates our internal state for best queued block and then goes
+	/// through all peers to update our view of their state as well.
+	fn on_block_queued(&mut self, hash: &B::Hash, number: NumberFor<B>) {
+		if self.fork_targets.remove(hash).is_some() {
+			trace!(target: "sync", "Completed fork sync {:?}", hash);
+		}
+		if let Some(gap_sync) = &mut self.gap_sync {
+			if number > gap_sync.best_queued_number && number <= gap_sync.target {
+				gap_sync.best_queued_number = number;
+			}
+		}
+		if number > self.best_queued_number {
+			self.best_queued_number = number;
+			self.best_queued_hash = *hash;
+			// Update common blocks
+			for (n, peer) in self.peers.iter_mut() {
+				if let PeerSyncState::AncestorSearch { .. } = peer.state {
+					// Wait for ancestry search to complete first.
+					continue
+				}
+				let new_common_number =
+					if peer.best_number >= number { number } else { peer.best_number };
+				trace!(
+					target: "sync",
+					"Updating peer {} info, ours={}, common={}->{}, their best={}",
+					n,
+					number,
+					peer.common_number,
+					new_common_number,
+					peer.best_number,
+				);
+				peer.common_number = new_common_number;
+			}
+		}
+		self.allowed_requests.set_all();
+	}
+
+	/// Checks if there is a slot for a block announce validation.
+	///
+	/// The total number and the number per peer of concurrent block announce validations
+	/// is capped.
+	///
+	/// Returns [`HasSlotForBlockAnnounceValidation`] to inform about the result.
+	///
+	/// # Note
+	///
+	/// It is *required* to call [`Self::peer_block_announce_validation_finished`] when the
+	/// validation is finished to clear the slot.
+	fn has_slot_for_block_announce_validation(
+		&mut self,
+		peer: &PeerId,
+	) -> HasSlotForBlockAnnounceValidation {
+		if self.block_announce_validation.len() >= MAX_CONCURRENT_BLOCK_ANNOUNCE_VALIDATIONS {
+			return HasSlotForBlockAnnounceValidation::TotalMaximumSlotsReached
+		}
+
+		match self.block_announce_validation_per_peer_stats.entry(*peer) {
+			Entry::Vacant(entry) => {
+				entry.insert(1);
+				HasSlotForBlockAnnounceValidation::Yes
+			},
+			Entry::Occupied(mut entry) => {
+				if *entry.get() < MAX_CONCURRENT_BLOCK_ANNOUNCE_VALIDATIONS_PER_PEER {
+					*entry.get_mut() += 1;
+					HasSlotForBlockAnnounceValidation::Yes
+				} else {
+					HasSlotForBlockAnnounceValidation::MaximumPeerSlotsReached
+				}
+			},
+		}
+	}
+
+	/// Should be called when a block announce validation is finished, to update the slots
+	/// of the peer that send the block announce.
+	fn peer_block_announce_validation_finished(
+		&mut self,
+		res: &PreValidateBlockAnnounce<B::Header>,
+	) {
+		let peer = match res {
+			PreValidateBlockAnnounce::Failure { who, .. } |
+			PreValidateBlockAnnounce::Process { who, .. } |
+			PreValidateBlockAnnounce::Error { who } => who,
+			PreValidateBlockAnnounce::Skip => return,
+		};
+
+		match self.block_announce_validation_per_peer_stats.entry(*peer) {
+			Entry::Vacant(_) => {
+				error!(
+					target: "sync",
+					"💔 Block announcement validation from peer {} finished for that no slot was allocated!",
+					peer,
+				);
+			},
+			Entry::Occupied(mut entry) => {
+				*entry.get_mut() = entry.get().saturating_sub(1);
+				if *entry.get() == 0 {
+					entry.remove();
+				}
+			},
+		}
+	}
+
+	/// This will finish processing of the block announcement.
+	fn finish_block_announce_validation(
+		&mut self,
+		pre_validation_result: PreValidateBlockAnnounce<B::Header>,
+	) -> PollBlockAnnounceValidation<B::Header> {
+		let (announce, is_best, who) = match pre_validation_result {
+			PreValidateBlockAnnounce::Failure { who, disconnect } => {
+				debug!(
+					target: "sync",
+					"Failed announce validation: {:?}, disconnect: {}",
+					who,
+					disconnect,
+				);
+				return PollBlockAnnounceValidation::Failure { who, disconnect }
+			},
+			PreValidateBlockAnnounce::Process { announce, is_new_best, who } =>
+				(announce, is_new_best, who),
+			PreValidateBlockAnnounce::Error { .. } | PreValidateBlockAnnounce::Skip => {
+				debug!(
+					target: "sync",
+					"Ignored announce validation",
+				);
+				return PollBlockAnnounceValidation::Skip
+			},
+		};
+
+		trace!(
+			target: "sync",
+			"Finished block announce validation: from {:?}: {:?}. local_best={}",
+			who,
+			announce.summary(),
+			is_best,
+		);
+
+		let number = *announce.header.number();
+		let hash = announce.header.hash();
+		let parent_status =
+			self.block_status(announce.header.parent_hash()).unwrap_or(BlockStatus::Unknown);
+		let known_parent = parent_status != BlockStatus::Unknown;
+		let ancient_parent = parent_status == BlockStatus::InChainPruned;
+
+		let known = self.is_known(&hash);
+		let peer = if let Some(peer) = self.peers.get_mut(&who) {
+			peer
+		} else {
+			error!(target: "sync", "💔 Called on_block_announce with a bad peer ID");
+			return PollBlockAnnounceValidation::Nothing { is_best, who, announce }
+		};
+
+		if let PeerSyncState::AncestorSearch { .. } = peer.state {
+			trace!(target: "sync", "Peer state is ancestor search.");
+			return PollBlockAnnounceValidation::Nothing { is_best, who, announce }
+		}
+
+		if is_best {
+			// update their best block
+			peer.best_number = number;
+			peer.best_hash = hash;
+		}
+
+		// If the announced block is the best they have and is not ahead of us, our common number
+		// is either one further ahead or it's the one they just announced, if we know about it.
+		if is_best {
+			if known && self.best_queued_number >= number {
+				self.update_peer_common_number(&who, number);
+			} else if announce.header.parent_hash() == &self.best_queued_hash ||
+				known_parent && self.best_queued_number >= number
+			{
+				self.update_peer_common_number(&who, number - One::one());
+			}
+		}
+		self.allowed_requests.add(&who);
+
+		// known block case
+		if known || self.is_already_downloading(&hash) {
+			trace!(target: "sync", "Known block announce from {}: {}", who, hash);
+			if let Some(target) = self.fork_targets.get_mut(&hash) {
+				target.peers.insert(who);
+			}
+			return PollBlockAnnounceValidation::Nothing { is_best, who, announce }
+		}
+
+		if ancient_parent {
+			trace!(
+				target: "sync",
+				"Ignored ancient block announced from {}: {} {:?}",
+				who,
+				hash,
+				announce.header,
+			);
+			return PollBlockAnnounceValidation::Nothing { is_best, who, announce }
+		}
+
+		if self.status().state == SyncState::Idle {
+			trace!(
+				target: "sync",
+				"Added sync target for block announced from {}: {} {:?}",
+				who,
+				hash,
+				announce.summary(),
+			);
+			self.fork_targets
+				.entry(hash)
+				.or_insert_with(|| ForkTarget {
+					number,
+					parent_hash: Some(*announce.header.parent_hash()),
+					peers: Default::default(),
+				})
+				.peers
+				.insert(who);
+		}
+
+		PollBlockAnnounceValidation::Nothing { is_best, who, announce }
+	}
+
+	/// Restart the sync process. This will reset all pending block requests and return an iterator
+	/// of new block requests to make to peers. Peers that were downloading finality data (i.e.
+	/// their state was `DownloadingJustification`) are unaffected and will stay in the same state.
+	fn restart(&mut self) -> impl Iterator<Item = Result<(PeerId, BlockRequest<B>), BadPeer>> + '_ {
+		self.blocks.clear();
+		if let Err(e) = self.reset_sync_start_point() {
+			warn!(target: "sync", "💔  Unable to restart sync: {}", e);
+		}
+		self.allowed_requests.set_all();
+		debug!(target:"sync", "Restarted with {} ({})", self.best_queued_number, self.best_queued_hash);
+		let old_peers = std::mem::take(&mut self.peers);
+
+		old_peers.into_iter().filter_map(move |(id, mut p)| {
+			// peers that were downloading justifications
+			// should be kept in that state.
+			if let PeerSyncState::DownloadingJustification(_) = p.state {
+				// We make sure our commmon number is at least something we have.
+				p.common_number = self.best_queued_number;
+				self.peers.insert(id, p);
+				return None
+			}
+
+			// since the request is not a justification, remove it from pending responses
+			self.pending_responses.remove(&id);
+
+			// handle peers that were in other states.
+			match self.new_peer(id, p.best_hash, p.best_number) {
+				Ok(None) => None,
+				Ok(Some(x)) => Some(Ok((id, x))),
+				Err(e) => Some(Err(e)),
+			}
+		})
+	}
+
+	/// Find a block to start sync from. If we sync with state, that's the latest block we have
+	/// state for.
+	fn reset_sync_start_point(&mut self) -> Result<(), ClientError> {
+		let info = self.client.info();
+		if matches!(self.mode, SyncMode::LightState { .. }) && info.finalized_state.is_some() {
+			warn!(
+				target: "sync",
+				"Can't use fast sync mode with a partially synced database. Reverting to full sync mode."
+			);
+			self.mode = SyncMode::Full;
+		}
+		if matches!(self.mode, SyncMode::Warp) && info.finalized_state.is_some() {
+			warn!(
+				target: "sync",
+				"Can't use warp sync mode with a partially synced database. Reverting to full sync mode."
+			);
+			self.mode = SyncMode::Full;
+		}
+		self.import_existing = false;
+		self.best_queued_hash = info.best_hash;
+		self.best_queued_number = info.best_number;
+
+		if self.mode == SyncMode::Full &&
+			self.client.block_status(info.best_hash)? != BlockStatus::InChainWithState
+		{
+			self.import_existing = true;
+			// Latest state is missing, start with the last finalized state or genesis instead.
+			if let Some((hash, number)) = info.finalized_state {
+				debug!(target: "sync", "Starting from finalized state #{}", number);
+				self.best_queued_hash = hash;
+				self.best_queued_number = number;
+			} else {
+				debug!(target: "sync", "Restarting from genesis");
+				self.best_queued_hash = Default::default();
+				self.best_queued_number = Zero::zero();
+			}
+		}
+
+		if let Some((start, end)) = info.block_gap {
+			debug!(target: "sync", "Starting gap sync #{} - #{}", start, end);
+			self.gap_sync = Some(GapSync {
+				best_queued_number: start - One::one(),
+				target: end,
+				blocks: BlockCollection::new(),
+			});
+		}
+		trace!(target: "sync", "Restarted sync at #{} ({:?})", self.best_queued_number, self.best_queued_hash);
+		Ok(())
+	}
+
+	/// What is the status of the block corresponding to the given hash?
+	fn block_status(&self, hash: &B::Hash) -> Result<BlockStatus, ClientError> {
+		if self.queue_blocks.contains(hash) {
+			return Ok(BlockStatus::Queued)
+		}
+		self.client.block_status(*hash)
+	}
+
+	/// Is the block corresponding to the given hash known?
+	fn is_known(&self, hash: &B::Hash) -> bool {
+		self.block_status(hash).ok().map_or(false, |s| s != BlockStatus::Unknown)
+	}
+
+	/// Is any peer downloading the given hash?
+	fn is_already_downloading(&self, hash: &B::Hash) -> bool {
+		self.peers
+			.iter()
+			.any(|(_, p)| p.state == PeerSyncState::DownloadingStale(*hash))
+	}
+
+	/// Get the set of downloaded blocks that are ready to be queued for import.
+	fn ready_blocks(&mut self) -> Vec<IncomingBlock<B>> {
+		self.blocks
+			.ready_blocks(self.best_queued_number + One::one())
+			.into_iter()
+			.map(|block_data| {
+				let justifications = block_data
+					.block
+					.justifications
+					.or_else(|| legacy_justification_mapping(block_data.block.justification));
+				IncomingBlock {
+					hash: block_data.block.hash,
+					header: block_data.block.header,
+					body: block_data.block.body,
+					indexed_body: block_data.block.indexed_body,
+					justifications,
+					origin: block_data.origin,
+					allow_missing_state: true,
+					import_existing: self.import_existing,
+					skip_execution: self.skip_execution(),
+					state: None,
+				}
+			})
+			.collect()
+	}
+
+	/// Generate block request for downloading of the target block body during warp sync.
+	fn warp_target_block_request(&mut self) -> Option<(PeerId, BlockRequest<B>)> {
+		let sync = &self.warp_sync.as_ref()?;
+
+		if self.allowed_requests.is_empty() ||
+			sync.is_complete() ||
+			self.peers
+				.iter()
+				.any(|(_, peer)| peer.state == PeerSyncState::DownloadingWarpTargetBlock)
+		{
+			// Only one pending warp target block request is allowed.
+			return None
+		}
+
+		if let Some((target_number, request)) = sync.next_target_block_request() {
+			// Find a random peer that has a block with the target number.
+			for (id, peer) in self.peers.iter_mut() {
+				if peer.state.is_available() && peer.best_number >= target_number {
+					trace!(target: "sync", "New warp target block request for {}", id);
+					peer.state = PeerSyncState::DownloadingWarpTargetBlock;
+					self.allowed_requests.clear();
+					return Some((*id, request))
+				}
+			}
+		}
+
+		None
+	}
+
+	/// Get config for the block announcement protocol
+	pub fn get_block_announce_proto_config(
+		protocol_id: ProtocolId,
+		fork_id: &Option<String>,
+		roles: Roles,
+		best_number: NumberFor<B>,
+		best_hash: B::Hash,
+		genesis_hash: B::Hash,
+	) -> NonDefaultSetConfig {
+		let block_announces_protocol = {
+			let genesis_hash = genesis_hash.as_ref();
+			if let Some(ref fork_id) = fork_id {
+				format!(
+					"/{}/{}/block-announces/1",
+					array_bytes::bytes2hex("", genesis_hash),
+					fork_id
+				)
+			} else {
+				format!("/{}/block-announces/1", array_bytes::bytes2hex("", genesis_hash))
+			}
+		};
+
+		NonDefaultSetConfig {
+			notifications_protocol: block_announces_protocol.into(),
+			fallback_names: iter::once(
+				format!("/{}/block-announces/1", protocol_id.as_ref()).into(),
+			)
+			.collect(),
+			max_notification_size: MAX_BLOCK_ANNOUNCE_SIZE,
+			handshake: Some(NotificationHandshake::new(BlockAnnouncesHandshake::<B>::build(
+				roles,
+				best_number,
+				best_hash,
+				genesis_hash,
+			))),
+			// NOTE: `set_config` will be ignored by `protocol.rs` as the block announcement
+			// protocol is still hardcoded into the peerset.
+			set_config: SetConfig {
+				in_peers: 0,
+				out_peers: 0,
+				reserved_nodes: Vec::new(),
+				non_reserved_mode: NonReservedPeerMode::Deny,
+			},
+		}
+	}
+
+	fn decode_block_response(response: &[u8]) -> Result<OpaqueBlockResponse, String> {
+		let response = schema::v1::BlockResponse::decode(response)
+			.map_err(|error| format!("Failed to decode block response: {error}"))?;
+
+		Ok(OpaqueBlockResponse(Box::new(response)))
+	}
+
+	fn decode_state_response(response: &[u8]) -> Result<OpaqueStateResponse, String> {
+		let response = StateResponse::decode(response)
+			.map_err(|error| format!("Failed to decode state response: {error}"))?;
+
+		Ok(OpaqueStateResponse(Box::new(response)))
+	}
+
+	fn send_state_request(&mut self, who: PeerId, request: OpaqueStateRequest) {
+		let (tx, rx) = oneshot::channel();
+
+		if self.peers.contains_key(&who) {
+			self.pending_responses
+				.insert(who, Box::pin(async move { (who, PeerRequest::State, rx.await) }));
+		}
+
+		match self.encode_state_request(&request) {
+			Ok(data) => {
+				self.network_service.start_request(
+					who,
+					self.state_request_protocol_name.clone(),
+					data,
+					tx,
+					IfDisconnected::ImmediateError,
+				);
+			},
+			Err(err) => {
+				log::warn!(
+					target: "sync",
+					"Failed to encode state request {:?}: {:?}",
+					request, err
+				);
+			},
+		}
+	}
+
+	fn send_warp_sync_request(&mut self, who: PeerId, request: WarpProofRequest<B>) {
+		let (tx, rx) = oneshot::channel();
+
+		if self.peers.contains_key(&who) {
+			self.pending_responses
+				.insert(who, Box::pin(async move { (who, PeerRequest::WarpProof, rx.await) }));
+		}
+
+		match &self.warp_sync_protocol_name {
+			Some(name) => self.network_service.start_request(
+				who,
+				name.clone(),
+				request.encode(),
+				tx,
+				IfDisconnected::ImmediateError,
+			),
+			None => {
+				log::warn!(
+					target: "sync",
+					"Trying to send warp sync request when no protocol is configured {:?}",
+					request,
+				);
+			},
+		}
+	}
+
+	fn on_block_response(
+		&mut self,
+		peer_id: PeerId,
+		request: BlockRequest<B>,
+		response: OpaqueBlockResponse,
+	) -> Option<ImportResult<B>> {
+		let blocks = match self.block_response_into_blocks(&request, response) {
+			Ok(blocks) => blocks,
+			Err(err) => {
+				debug!(target: "sync", "Failed to decode block response from {}: {}", peer_id, err);
+				self.network_service.report_peer(peer_id, rep::BAD_MESSAGE);
+				return None
+			},
+		};
+
+		let block_response = BlockResponse::<B> { id: request.id, blocks };
+
+		let blocks_range = || match (
+			block_response
+				.blocks
+				.first()
+				.and_then(|b| b.header.as_ref().map(|h| h.number())),
+			block_response.blocks.last().and_then(|b| b.header.as_ref().map(|h| h.number())),
+		) {
+			(Some(first), Some(last)) if first != last => format!(" ({}..{})", first, last),
+			(Some(first), Some(_)) => format!(" ({})", first),
+			_ => Default::default(),
+		};
+		trace!(
+			target: "sync",
+			"BlockResponse {} from {} with {} blocks {}",
+			block_response.id,
+			peer_id,
+			block_response.blocks.len(),
+			blocks_range(),
+		);
+
+		if request.fields == BlockAttributes::JUSTIFICATION {
+			match self.on_block_justification(peer_id, block_response) {
+				Ok(OnBlockJustification::Nothing) => None,
+				Ok(OnBlockJustification::Import { peer, hash, number, justifications }) => {
+					self.import_justifications(peer, hash, number, justifications);
+					None
+				},
+				Err(BadPeer(id, repu)) => {
+					self.network_service
+						.disconnect_peer(id, self.block_announce_protocol_name.clone());
+					self.network_service.report_peer(id, repu);
+					None
+				},
+			}
+		} else {
+			match self.on_block_data(&peer_id, Some(request), block_response) {
+				Ok(OnBlockData::Import(origin, blocks)) => {
+					self.import_blocks(origin, blocks);
+					None
+				},
+				Ok(OnBlockData::Request(peer, req)) => {
+					self.send_block_request(peer, req);
+					None
+				},
+				Ok(OnBlockData::Continue) => None,
+				Err(BadPeer(id, repu)) => {
+					self.network_service
+						.disconnect_peer(id, self.block_announce_protocol_name.clone());
+					self.network_service.report_peer(id, repu);
+					None
+				},
+			}
+		}
+	}
+
+	pub fn on_state_response(
+		&mut self,
+		peer_id: PeerId,
+		response: OpaqueStateResponse,
+	) -> Option<ImportResult<B>> {
+		match self.on_state_data(&peer_id, response) {
+			Ok(OnStateData::Import(origin, block)) =>
+				Some(ImportResult::BlockImport(origin, vec![block])),
+			Ok(OnStateData::Continue) => None,
+			Err(BadPeer(id, repu)) => {
+				self.network_service
+					.disconnect_peer(id, self.block_announce_protocol_name.clone());
+				self.network_service.report_peer(id, repu);
+				None
+			},
+		}
+	}
+
+	pub fn on_warp_sync_response(&mut self, peer_id: PeerId, response: EncodedProof) {
+		if let Err(BadPeer(id, repu)) = self.on_warp_sync_data(&peer_id, response) {
+			self.network_service
+				.disconnect_peer(id, self.block_announce_protocol_name.clone());
+			self.network_service.report_peer(id, repu);
+		}
+	}
+
+	fn process_outbound_requests(&mut self) {
+		for (id, request) in self.block_requests() {
+			self.send_block_request(id, request);
+		}
+
+		if let Some((id, request)) = self.state_request() {
+			self.send_state_request(id, request);
+		}
+
+		for (id, request) in self.justification_requests().collect::<Vec<_>>() {
+			self.send_block_request(id, request);
+		}
+
+		if let Some((id, request)) = self.warp_sync_request() {
+			self.send_warp_sync_request(id, request);
+		}
+	}
+
+	fn poll_pending_responses(&mut self, cx: &mut std::task::Context) -> Poll<ImportResult<B>> {
+		let ready_responses = self
+			.pending_responses
+			.values_mut()
+			.filter_map(|future| match future.poll_unpin(cx) {
+				Poll::Pending => None,
+				Poll::Ready(result) => Some(result),
+			})
+			.collect::<Vec<_>>();
+
+		for (id, request, response) in ready_responses {
+			self.pending_responses
+				.remove(&id)
+				.expect("Logic error: peer id from pending response is missing in the map.");
+
+			match response {
+				Ok(Ok(resp)) => match request {
+					PeerRequest::Block(req) => {
+						let response = match Self::decode_block_response(&resp[..]) {
+							Ok(proto) => proto,
+							Err(e) => {
+								debug!(
+									target: "sync",
+									"Failed to decode block response from peer {:?}: {:?}.",
+									id,
+									e
+								);
+								self.network_service.report_peer(id, rep::BAD_MESSAGE);
+								self.network_service
+									.disconnect_peer(id, self.block_announce_protocol_name.clone());
+								continue
+							},
+						};
+
+						if let Some(import) = self.on_block_response(id, req, response) {
+							return Poll::Ready(import)
+						}
+					},
+					PeerRequest::State => {
+						let response = match Self::decode_state_response(&resp[..]) {
+							Ok(proto) => proto,
+							Err(e) => {
+								debug!(
+									target: "sync",
+									"Failed to decode state response from peer {:?}: {:?}.",
+									id,
+									e
+								);
+								self.network_service.report_peer(id, rep::BAD_MESSAGE);
+								self.network_service
+									.disconnect_peer(id, self.block_announce_protocol_name.clone());
+								continue
+							},
+						};
+
+						if let Some(import) = self.on_state_response(id, response) {
+							return Poll::Ready(import)
+						}
+					},
+					PeerRequest::WarpProof => {
+						self.on_warp_sync_response(id, EncodedProof(resp));
+					},
+				},
+				Ok(Err(e)) => {
+					debug!(target: "sync", "Request to peer {:?} failed: {:?}.", id, e);
+
+					match e {
+						RequestFailure::Network(OutboundFailure::Timeout) => {
+							self.network_service.report_peer(id, rep::TIMEOUT);
+							self.network_service
+								.disconnect_peer(id, self.block_announce_protocol_name.clone());
+						},
+						RequestFailure::Network(OutboundFailure::UnsupportedProtocols) => {
+							self.network_service.report_peer(id, rep::BAD_PROTOCOL);
+							self.network_service
+								.disconnect_peer(id, self.block_announce_protocol_name.clone());
+						},
+						RequestFailure::Network(OutboundFailure::DialFailure) => {
+							self.network_service
+								.disconnect_peer(id, self.block_announce_protocol_name.clone());
+						},
+						RequestFailure::Refused => {
+							self.network_service.report_peer(id, rep::REFUSED);
+							self.network_service
+								.disconnect_peer(id, self.block_announce_protocol_name.clone());
+						},
+						RequestFailure::Network(OutboundFailure::ConnectionClosed) |
+						RequestFailure::NotConnected => {
+							self.network_service
+								.disconnect_peer(id, self.block_announce_protocol_name.clone());
+						},
+						RequestFailure::UnknownProtocol => {
+							debug_assert!(false, "Block request protocol should always be known.");
+						},
+						RequestFailure::Obsolete => {
+							debug_assert!(
+								false,
+								"Can not receive `RequestFailure::Obsolete` after dropping the \
+								 response receiver.",
+							);
+						},
+					}
+				},
+				Err(oneshot::Canceled) => {
+					trace!(
+						target: "sync",
+						"Request to peer {:?} failed due to oneshot being canceled.",
+						id,
+					);
+					self.network_service
+						.disconnect_peer(id, self.block_announce_protocol_name.clone());
+				},
+			}
+		}
+
+		Poll::Pending
+	}
+
+	/// Create implementation-specific block request.
+	fn create_opaque_block_request(&self, request: &BlockRequest<B>) -> OpaqueBlockRequest {
+		OpaqueBlockRequest(Box::new(schema::v1::BlockRequest {
+			fields: request.fields.to_be_u32(),
+			from_block: match request.from {
+				FromBlock::Hash(h) => Some(schema::v1::block_request::FromBlock::Hash(h.encode())),
+				FromBlock::Number(n) =>
+					Some(schema::v1::block_request::FromBlock::Number(n.encode())),
+			},
+			direction: request.direction as i32,
+			max_blocks: request.max.unwrap_or(0),
+			support_multiple_justifications: true,
+		}))
+	}
+
+	fn encode_block_request(&self, request: &OpaqueBlockRequest) -> Result<Vec<u8>, String> {
+		let request: &schema::v1::BlockRequest = request.0.downcast_ref().ok_or_else(|| {
+			"Failed to downcast opaque block response during encoding, this is an \
+				implementation bug."
+				.to_string()
+		})?;
+
+		Ok(request.encode_to_vec())
+	}
+
+	fn encode_state_request(&self, request: &OpaqueStateRequest) -> Result<Vec<u8>, String> {
+		let request: &StateRequest = request.0.downcast_ref().ok_or_else(|| {
+			"Failed to downcast opaque state response during encoding, this is an \
+				implementation bug."
+				.to_string()
+		})?;
+
+		Ok(request.encode_to_vec())
+	}
+
+	fn justification_requests<'a>(
+		&'a mut self,
+	) -> Box<dyn Iterator<Item = (PeerId, BlockRequest<B>)> + 'a> {
+		let peers = &mut self.peers;
+		let mut matcher = self.extra_justifications.matcher();
+		Box::new(std::iter::from_fn(move || {
+			if let Some((peer, request)) = matcher.next(peers) {
+				peers
+					.get_mut(&peer)
+					.expect(
+						"`Matcher::next` guarantees the `PeerId` comes from the given peers; qed",
+					)
+					.state = PeerSyncState::DownloadingJustification(request.0);
+				let req = BlockRequest::<B> {
+					id: 0,
+					fields: BlockAttributes::JUSTIFICATION,
+					from: FromBlock::Hash(request.0),
+					direction: Direction::Ascending,
+					max: Some(1),
+				};
+				Some((peer, req))
+			} else {
+				None
+			}
+		}))
+	}
+
+	fn block_requests(&mut self) -> Vec<(PeerId, BlockRequest<B>)> {
+		if self.mode == SyncMode::Warp {
+			return self
+				.warp_target_block_request()
+				.map_or_else(|| Vec::new(), |req| Vec::from([req]))
+		}
+
+		if self.allowed_requests.is_empty() || self.state_sync.is_some() {
+			return Vec::new()
+		}
+
+		if self.queue_blocks.len() > MAX_IMPORTING_BLOCKS {
+			trace!(target: "sync", "Too many blocks in the queue.");
+			return Vec::new()
+		}
+		let is_major_syncing = self.status().state.is_major_syncing();
+		let attrs = self.required_block_attributes();
+		let blocks = &mut self.blocks;
+		let fork_targets = &mut self.fork_targets;
+		let last_finalized =
+			std::cmp::min(self.best_queued_number, self.client.info().finalized_number);
+		let best_queued = self.best_queued_number;
+		let client = &self.client;
+		let queue = &self.queue_blocks;
+		let allowed_requests = self.allowed_requests.take();
+		let max_parallel = if is_major_syncing { 1 } else { self.max_parallel_downloads };
+		let max_blocks_per_request = self.max_blocks_per_request;
+		let gap_sync = &mut self.gap_sync;
+		self.peers
+			.iter_mut()
+			.filter_map(move |(&id, peer)| {
+				if !peer.state.is_available() || !allowed_requests.contains(&id) {
+					return None
+				}
+
+				// If our best queued is more than `MAX_BLOCKS_TO_LOOK_BACKWARDS` blocks away from
+				// the common number, the peer best number is higher than our best queued and the
+				// common number is smaller than the last finalized block number, we should do an
+				// ancestor search to find a better common block. If the queue is full we wait till
+				// all blocks are imported though.
+				if best_queued.saturating_sub(peer.common_number) >
+					MAX_BLOCKS_TO_LOOK_BACKWARDS.into() &&
+					best_queued < peer.best_number &&
+					peer.common_number < last_finalized &&
+					queue.len() <= MAJOR_SYNC_BLOCKS.into()
+				{
+					trace!(
+						target: "sync",
+						"Peer {:?} common block {} too far behind of our best {}. Starting ancestry search.",
+						id,
+						peer.common_number,
+						best_queued,
+					);
+					let current = std::cmp::min(peer.best_number, best_queued);
+					peer.state = PeerSyncState::AncestorSearch {
+						current,
+						start: best_queued,
+						state: AncestorSearchState::ExponentialBackoff(One::one()),
+					};
+					Some((id, ancestry_request::<B>(current)))
+				} else if let Some((range, req)) = peer_block_request(
+					&id,
+					peer,
+					blocks,
+					attrs,
+					max_parallel,
+					max_blocks_per_request,
+					last_finalized,
+					best_queued,
+				) {
+					peer.state = PeerSyncState::DownloadingNew(range.start);
+					trace!(
+						target: "sync",
+						"New block request for {}, (best:{}, common:{}) {:?}",
+						id,
+						peer.best_number,
+						peer.common_number,
+						req,
+					);
+					Some((id, req))
+				} else if let Some((hash, req)) = fork_sync_request(
+					&id,
+					fork_targets,
+					best_queued,
+					last_finalized,
+					attrs,
+					|hash| {
+						if queue.contains(hash) {
+							BlockStatus::Queued
+						} else {
+							client.block_status(*hash).unwrap_or(BlockStatus::Unknown)
+						}
+					},
+					max_blocks_per_request,
+				) {
+					trace!(target: "sync", "Downloading fork {:?} from {}", hash, id);
+					peer.state = PeerSyncState::DownloadingStale(hash);
+					Some((id, req))
+				} else if let Some((range, req)) = gap_sync.as_mut().and_then(|sync| {
+					peer_gap_block_request(
+						&id,
+						peer,
+						&mut sync.blocks,
+						attrs,
+						sync.target,
+						sync.best_queued_number,
+						max_blocks_per_request,
+					)
+				}) {
+					peer.state = PeerSyncState::DownloadingGap(range.start);
+					trace!(
+						target: "sync",
+						"New gap block request for {}, (best:{}, common:{}) {:?}",
+						id,
+						peer.best_number,
+						peer.common_number,
+						req,
+					);
+					Some((id, req))
+				} else {
+					None
+				}
+			})
+			.collect()
+		// Box::new(iter)
+	}
+
+	fn state_request(&mut self) -> Option<(PeerId, OpaqueStateRequest)> {
+		if self.allowed_requests.is_empty() {
+			return None
+		}
+		if (self.state_sync.is_some() || self.warp_sync.is_some()) &&
+			self.peers.iter().any(|(_, peer)| peer.state == PeerSyncState::DownloadingState)
+		{
+			// Only one pending state request is allowed.
+			return None
+		}
+		if let Some(sync) = &self.state_sync {
+			if sync.is_complete() {
+				return None
+			}
+
+			for (id, peer) in self.peers.iter_mut() {
+				if peer.state.is_available() && peer.common_number >= sync.target_block_num() {
+					peer.state = PeerSyncState::DownloadingState;
+					let request = sync.next_request();
+					trace!(target: "sync", "New StateRequest for {}: {:?}", id, request);
+					self.allowed_requests.clear();
+					return Some((*id, OpaqueStateRequest(Box::new(request))))
+				}
+			}
+		}
+		if let Some(sync) = &self.warp_sync {
+			if sync.is_complete() {
+				return None
+			}
+			if let (Some(request), Some(target)) =
+				(sync.next_state_request(), sync.target_block_number())
+			{
+				for (id, peer) in self.peers.iter_mut() {
+					if peer.state.is_available() && peer.best_number >= target {
+						trace!(target: "sync", "New StateRequest for {}: {:?}", id, request);
+						peer.state = PeerSyncState::DownloadingState;
+						self.allowed_requests.clear();
+						return Some((*id, OpaqueStateRequest(Box::new(request))))
+					}
+				}
+			}
+		}
+		None
+	}
+
+	fn warp_sync_request(&mut self) -> Option<(PeerId, WarpProofRequest<B>)> {
+		if let Some(sync) = &self.warp_sync {
+			if self.allowed_requests.is_empty() ||
+				sync.is_complete() ||
+				self.peers
+					.iter()
+					.any(|(_, peer)| peer.state == PeerSyncState::DownloadingWarpProof)
+			{
+				// Only one pending state request is allowed.
+				return None
+			}
+			if let Some(request) = sync.next_warp_proof_request() {
+				let mut targets: Vec<_> = self.peers.values().map(|p| p.best_number).collect();
+				if !targets.is_empty() {
+					targets.sort();
+					let median = targets[targets.len() / 2];
+					// Find a random peer that is synced as much as peer majority.
+					for (id, peer) in self.peers.iter_mut() {
+						if peer.state.is_available() && peer.best_number >= median {
+							trace!(target: "sync", "New WarpProofRequest for {}", id);
+							peer.state = PeerSyncState::DownloadingWarpProof;
+							self.allowed_requests.clear();
+							return Some((*id, request))
+						}
+					}
+				}
+			}
+		}
+		None
+	}
+
+	fn on_state_data(
+		&mut self,
+		who: &PeerId,
+		response: OpaqueStateResponse,
+	) -> Result<OnStateData<B>, BadPeer> {
+		let response: Box<StateResponse> = response.0.downcast().map_err(|_error| {
+			error!(
+				target: "sync",
+				"Failed to downcast opaque state response, this is an implementation bug."
+			);
+
+			BadPeer(*who, rep::BAD_RESPONSE)
+		})?;
+
+		if let Some(peer) = self.peers.get_mut(who) {
+			if let PeerSyncState::DownloadingState = peer.state {
+				peer.state = PeerSyncState::Available;
+				self.allowed_requests.set_all();
+			}
+		}
+		let import_result = if let Some(sync) = &mut self.state_sync {
+			debug!(
+				target: "sync",
+				"Importing state data from {} with {} keys, {} proof nodes.",
+				who,
+				response.entries.len(),
+				response.proof.len(),
+			);
+			sync.import(*response)
+		} else if let Some(sync) = &mut self.warp_sync {
+			debug!(
+				target: "sync",
+				"Importing state data from {} with {} keys, {} proof nodes.",
+				who,
+				response.entries.len(),
+				response.proof.len(),
+			);
+			sync.import_state(*response)
+		} else {
+			debug!(target: "sync", "Ignored obsolete state response from {}", who);
+			return Err(BadPeer(*who, rep::NOT_REQUESTED))
+		};
+
+		match import_result {
+			state::ImportResult::Import(hash, header, state, body, justifications) => {
+				let origin = BlockOrigin::NetworkInitialSync;
+				let block = IncomingBlock {
+					hash,
+					header: Some(header),
+					body,
+					indexed_body: None,
+					justifications,
+					origin: None,
+					allow_missing_state: true,
+					import_existing: true,
+					skip_execution: self.skip_execution(),
+					state: Some(state),
+				};
+				debug!(target: "sync", "State download is complete. Import is queued");
+				Ok(OnStateData::Import(origin, block))
+			},
+			state::ImportResult::Continue => Ok(OnStateData::Continue),
+			state::ImportResult::BadResponse => {
+				debug!(target: "sync", "Bad state data received from {}", who);
+				Err(BadPeer(*who, rep::BAD_BLOCK))
+			},
+		}
+	}
+
+	fn on_warp_sync_data(&mut self, who: &PeerId, response: EncodedProof) -> Result<(), BadPeer> {
+		if let Some(peer) = self.peers.get_mut(who) {
+			if let PeerSyncState::DownloadingWarpProof = peer.state {
+				peer.state = PeerSyncState::Available;
+				self.allowed_requests.set_all();
+			}
+		}
+		let import_result = if let Some(sync) = &mut self.warp_sync {
+			debug!(
+				target: "sync",
+				"Importing warp proof data from {}, {} bytes.",
+				who,
+				response.0.len(),
+			);
+			sync.import_warp_proof(response)
+		} else {
+			debug!(target: "sync", "Ignored obsolete warp sync response from {}", who);
+			return Err(BadPeer(*who, rep::NOT_REQUESTED))
+		};
+
+		match import_result {
+			WarpProofImportResult::Success => Ok(()),
+			WarpProofImportResult::BadResponse => {
+				debug!(target: "sync", "Bad proof data received from {}", who);
+				Err(BadPeer(*who, rep::BAD_BLOCK))
+			},
+		}
+	}
+
+	fn import_blocks(&mut self, origin: BlockOrigin, blocks: Vec<IncomingBlock<B>>) {
+		if let Some(metrics) = &self.metrics {
+			metrics.import_queue_blocks_submitted.inc();
+		}
+
+		self.import_queue.import_blocks(origin, blocks);
+	}
+
+	fn import_justifications(
+		&mut self,
+		peer: PeerId,
+		hash: B::Hash,
+		number: NumberFor<B>,
+		justifications: Justifications,
+	) {
+		if let Some(metrics) = &self.metrics {
+			metrics.import_queue_justifications_submitted.inc();
+		}
+
+		self.import_queue.import_justifications(peer, hash, number, justifications);
+	}
+
+	/// A batch of blocks have been processed, with or without errors.
+	///
+	/// Call this when a batch of blocks have been processed by the import
+	/// queue, with or without errors.
+	fn on_blocks_processed(
+		&mut self,
+		imported: usize,
+		count: usize,
+		results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>,
+	) -> Box<dyn Iterator<Item = Result<(PeerId, BlockRequest<B>), BadPeer>>> {
+		trace!(target: "sync", "Imported {} of {}", imported, count);
+
+		let mut output = Vec::new();
+
+		let mut has_error = false;
+		for (_, hash) in &results {
+			self.queue_blocks.remove(hash);
+			self.blocks.clear_queued(hash);
+			if let Some(gap_sync) = &mut self.gap_sync {
+				gap_sync.blocks.clear_queued(hash);
+			}
+		}
+		for (result, hash) in results {
+			if has_error {
+				break
+			}
+
+			has_error |= result.is_err();
+
+			match result {
+				Ok(BlockImportStatus::ImportedKnown(number, who)) =>
+					if let Some(peer) = who {
+						self.update_peer_common_number(&peer, number);
+					},
+				Ok(BlockImportStatus::ImportedUnknown(number, aux, who)) => {
+					if aux.clear_justification_requests {
+						trace!(
+							target: "sync",
+							"Block imported clears all pending justification requests {number}: {hash:?}",
+						);
+						self.clear_justification_requests();
+					}
+
+					if aux.needs_justification {
+						trace!(
+							target: "sync",
+							"Block imported but requires justification {number}: {hash:?}",
+						);
+						self.request_justification(&hash, number);
+					}
+
+					if aux.bad_justification {
+						if let Some(ref peer) = who {
+							warn!("💔 Sent block with bad justification to import");
+							output.push(Err(BadPeer(*peer, rep::BAD_JUSTIFICATION)));
+						}
+					}
+
+					if let Some(peer) = who {
+						self.update_peer_common_number(&peer, number);
+					}
+					let state_sync_complete =
+						self.state_sync.as_ref().map_or(false, |s| s.target() == hash);
+					if state_sync_complete {
+						info!(
+							target: "sync",
+							"State sync is complete ({} MiB), restarting block sync.",
+							self.state_sync.as_ref().map_or(0, |s| s.progress().size / (1024 * 1024)),
+						);
+						self.state_sync = None;
+						self.mode = SyncMode::Full;
+						output.extend(self.restart());
+					}
+					let warp_sync_complete = self
+						.warp_sync
+						.as_ref()
+						.map_or(false, |s| s.target_block_hash() == Some(hash));
+					if warp_sync_complete {
+						info!(
+							target: "sync",
+							"Warp sync is complete ({} MiB), restarting block sync.",
+							self.warp_sync.as_ref().map_or(0, |s| s.progress().total_bytes / (1024 * 1024)),
+						);
+						self.warp_sync = None;
+						self.mode = SyncMode::Full;
+						output.extend(self.restart());
+					}
+					let gap_sync_complete =
+						self.gap_sync.as_ref().map_or(false, |s| s.target == number);
+					if gap_sync_complete {
+						info!(
+							target: "sync",
+							"Block history download is complete."
+						);
+						self.gap_sync = None;
+					}
+				},
+				Err(BlockImportError::IncompleteHeader(who)) =>
+					if let Some(peer) = who {
+						warn!(
+							target: "sync",
+							"💔 Peer sent block with incomplete header to import",
+						);
+						output.push(Err(BadPeer(peer, rep::INCOMPLETE_HEADER)));
+						output.extend(self.restart());
+					},
+				Err(BlockImportError::VerificationFailed(who, e)) => {
+					let extra_message =
+						who.map_or_else(|| "".into(), |peer| format!(" received from ({peer})"));
+
+					warn!(
+						target: "sync",
+						"💔 Verification failed for block {hash:?}{extra_message}: {e:?}",
+					);
+
+					if let Some(peer) = who {
+						output.push(Err(BadPeer(peer, rep::VERIFICATION_FAIL)));
+					}
+
+					output.extend(self.restart());
+				},
+				Err(BlockImportError::BadBlock(who)) =>
+					if let Some(peer) = who {
+						warn!(
+							target: "sync",
+							"💔 Block {hash:?} received from peer {peer} has been blacklisted",
+						);
+						output.push(Err(BadPeer(peer, rep::BAD_BLOCK)));
+					},
+				Err(BlockImportError::MissingState) => {
+					// This may happen if the chain we were requesting upon has been discarded
+					// in the meantime because other chain has been finalized.
+					// Don't mark it as bad as it still may be synced if explicitly requested.
+					trace!(target: "sync", "Obsolete block {hash:?}");
+				},
+				e @ Err(BlockImportError::UnknownParent) | e @ Err(BlockImportError::Other(_)) => {
+					warn!(target: "sync", "💔 Error importing block {hash:?}: {}", e.unwrap_err());
+					self.state_sync = None;
+					self.warp_sync = None;
+					output.extend(self.restart());
+				},
+				Err(BlockImportError::Cancelled) => {},
+			};
+		}
+
+		self.allowed_requests.set_all();
+		Box::new(output.into_iter())
+	}
+}
+
+// This is purely during a backwards compatible transitionary period and should be removed
+// once we can assume all nodes can send and receive multiple Justifications
+// The ID tag is hardcoded here to avoid depending on the GRANDPA crate.
+// See: https://github.com/paritytech/substrate/issues/8172
+fn legacy_justification_mapping(
+	justification: Option<EncodedJustification>,
+) -> Option<Justifications> {
+	justification.map(|just| (*b"FRNK", just).into())
+}
+
+/// Request the ancestry for a block. Sends a request for header and justification for the given
+/// block number. Used during ancestry search.
+fn ancestry_request<B: BlockT>(block: NumberFor<B>) -> BlockRequest<B> {
+	BlockRequest::<B> {
+		id: 0,
+		fields: BlockAttributes::HEADER | BlockAttributes::JUSTIFICATION,
+		from: FromBlock::Number(block),
+		direction: Direction::Ascending,
+		max: Some(1),
+	}
+}
+
+/// The ancestor search state expresses which algorithm, and its stateful parameters, we are using
+/// to try to find an ancestor block
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum AncestorSearchState<B: BlockT> {
+	/// Use exponential backoff to find an ancestor, then switch to binary search.
+	/// We keep track of the exponent.
+	ExponentialBackoff(NumberFor<B>),
+	/// Using binary search to find the best ancestor.
+	/// We keep track of left and right bounds.
+	BinarySearch(NumberFor<B>, NumberFor<B>),
+}
+
+/// This function handles the ancestor search strategy used. The goal is to find a common point
+/// that both our chains agree on that is as close to the tip as possible.
+/// The way this works is we first have an exponential backoff strategy, where we try to step
+/// forward until we find a block hash mismatch. The size of the step doubles each step we take.
+///
+/// When we've found a block hash mismatch we then fall back to a binary search between the two
+/// last known points to find the common block closest to the tip.
+fn handle_ancestor_search_state<B: BlockT>(
+	state: &AncestorSearchState<B>,
+	curr_block_num: NumberFor<B>,
+	block_hash_match: bool,
+) -> Option<(AncestorSearchState<B>, NumberFor<B>)> {
+	let two = <NumberFor<B>>::one() + <NumberFor<B>>::one();
+	match state {
+		AncestorSearchState::ExponentialBackoff(next_distance_to_tip) => {
+			let next_distance_to_tip = *next_distance_to_tip;
+			if block_hash_match && next_distance_to_tip == One::one() {
+				// We found the ancestor in the first step so there is no need to execute binary
+				// search.
+				return None
+			}
+			if block_hash_match {
+				let left = curr_block_num;
+				let right = left + next_distance_to_tip / two;
+				let middle = left + (right - left) / two;
+				Some((AncestorSearchState::BinarySearch(left, right), middle))
+			} else {
+				let next_block_num =
+					curr_block_num.checked_sub(&next_distance_to_tip).unwrap_or_else(Zero::zero);
+				let next_distance_to_tip = next_distance_to_tip * two;
+				Some((
+					AncestorSearchState::ExponentialBackoff(next_distance_to_tip),
+					next_block_num,
+				))
+			}
+		},
+		AncestorSearchState::BinarySearch(mut left, mut right) => {
+			if left >= curr_block_num {
+				return None
+			}
+			if block_hash_match {
+				left = curr_block_num;
+			} else {
+				right = curr_block_num;
+			}
+			assert!(right >= left);
+			let middle = left + (right - left) / two;
+			if middle == curr_block_num {
+				None
+			} else {
+				Some((AncestorSearchState::BinarySearch(left, right), middle))
+			}
+		},
+	}
+}
+
+/// Get a new block request for the peer if any.
+fn peer_block_request<B: BlockT>(
+	id: &PeerId,
+	peer: &PeerSync<B>,
+	blocks: &mut BlockCollection<B>,
+	attrs: BlockAttributes,
+	max_parallel_downloads: u32,
+	max_blocks_per_request: u32,
+	finalized: NumberFor<B>,
+	best_num: NumberFor<B>,
+) -> Option<(Range<NumberFor<B>>, BlockRequest<B>)> {
+	if best_num >= peer.best_number {
+		// Will be downloaded as alternative fork instead.
+		return None
+	} else if peer.common_number < finalized {
+		trace!(
+			target: "sync",
+			"Requesting pre-finalized chain from {:?}, common={}, finalized={}, peer best={}, our best={}",
+			id, peer.common_number, finalized, peer.best_number, best_num,
+		);
+	}
+	let range = blocks.needed_blocks(
+		*id,
+		max_blocks_per_request,
+		peer.best_number,
+		peer.common_number,
+		max_parallel_downloads,
+		MAX_DOWNLOAD_AHEAD,
+	)?;
+
+	// The end is not part of the range.
+	let last = range.end.saturating_sub(One::one());
+
+	let from = if peer.best_number == last {
+		FromBlock::Hash(peer.best_hash)
+	} else {
+		FromBlock::Number(last)
+	};
+
+	let request = BlockRequest::<B> {
+		id: 0,
+		fields: attrs,
+		from,
+		direction: Direction::Descending,
+		max: Some((range.end - range.start).saturated_into::<u32>()),
+	};
+
+	Some((range, request))
+}
+
+/// Get a new block request for the peer if any.
+fn peer_gap_block_request<B: BlockT>(
+	id: &PeerId,
+	peer: &PeerSync<B>,
+	blocks: &mut BlockCollection<B>,
+	attrs: BlockAttributes,
+	target: NumberFor<B>,
+	common_number: NumberFor<B>,
+	max_blocks_per_request: u32,
+) -> Option<(Range<NumberFor<B>>, BlockRequest<B>)> {
+	let range = blocks.needed_blocks(
+		*id,
+		max_blocks_per_request,
+		std::cmp::min(peer.best_number, target),
+		common_number,
+		1,
+		MAX_DOWNLOAD_AHEAD,
+	)?;
+
+	// The end is not part of the range.
+	let last = range.end.saturating_sub(One::one());
+	let from = FromBlock::Number(last);
+
+	let request = BlockRequest::<B> {
+		id: 0,
+		fields: attrs,
+		from,
+		direction: Direction::Descending,
+		max: Some((range.end - range.start).saturated_into::<u32>()),
+	};
+	Some((range, request))
+}
+
+/// Get pending fork sync targets for a peer.
+fn fork_sync_request<B: BlockT>(
+	id: &PeerId,
+	targets: &mut HashMap<B::Hash, ForkTarget<B>>,
+	best_num: NumberFor<B>,
+	finalized: NumberFor<B>,
+	attributes: BlockAttributes,
+	check_block: impl Fn(&B::Hash) -> BlockStatus,
+	max_blocks_per_request: u32,
+) -> Option<(B::Hash, BlockRequest<B>)> {
+	targets.retain(|hash, r| {
+		if r.number <= finalized {
+			trace!(target: "sync", "Removed expired fork sync request {:?} (#{})", hash, r.number);
+			return false
+		}
+		if check_block(hash) != BlockStatus::Unknown {
+			trace!(target: "sync", "Removed obsolete fork sync request {:?} (#{})", hash, r.number);
+			return false
+		}
+		true
+	});
+	for (hash, r) in targets {
+		if !r.peers.contains(&id) {
+			continue
+		}
+		// Download the fork only if it is behind or not too far ahead our tip of the chain
+		// Otherwise it should be downloaded in full sync mode.
+		if r.number <= best_num ||
+			(r.number - best_num).saturated_into::<u32>() < max_blocks_per_request as u32
+		{
+			let parent_status = r.parent_hash.as_ref().map_or(BlockStatus::Unknown, check_block);
+			let count = if parent_status == BlockStatus::Unknown {
+				(r.number - finalized).saturated_into::<u32>() // up to the last finalized block
+			} else {
+				// request only single block
+				1
+			};
+			trace!(target: "sync", "Downloading requested fork {:?} from {}, {} blocks", hash, id, count);
+			return Some((
+				*hash,
+				BlockRequest::<B> {
+					id: 0,
+					fields: attributes,
+					from: FromBlock::Hash(*hash),
+					direction: Direction::Descending,
+					max: Some(count),
+				},
+			))
+		} else {
+			trace!(target: "sync", "Fork too far in the future: {:?} (#{})", hash, r.number);
+		}
+	}
+	None
+}
+
+/// Returns `true` if the given `block` is a descendent of `base`.
+fn is_descendent_of<Block, T>(
+	client: &T,
+	base: &Block::Hash,
+	block: &Block::Hash,
+) -> sp_blockchain::Result<bool>
+where
+	Block: BlockT,
+	T: HeaderMetadata<Block, Error = sp_blockchain::Error> + ?Sized,
+{
+	if base == block {
+		return Ok(false)
+	}
+
+	let ancestor = sp_blockchain::lowest_common_ancestor(client, *block, *base)?;
+
+	Ok(ancestor.hash == *base)
+}
+
+/// Validate that the given `blocks` are correct.
+/// Returns the number of the first block in the sequence.
+///
+/// It is expected that `blocks` are in ascending order.
+fn validate_blocks<Block: BlockT>(
+	blocks: &Vec<BlockData<Block>>,
+	who: &PeerId,
+	request: Option<BlockRequest<Block>>,
+) -> Result<Option<NumberFor<Block>>, BadPeer> {
+	if let Some(request) = request {
+		if Some(blocks.len() as _) > request.max {
+			debug!(
+				target: "sync",
+				"Received more blocks than requested from {}. Expected in maximum {:?}, got {}.",
+				who,
+				request.max,
+				blocks.len(),
+			);
+
+			return Err(BadPeer(*who, rep::NOT_REQUESTED))
+		}
+
+		let block_header =
+			if request.direction == Direction::Descending { blocks.last() } else { blocks.first() }
+				.and_then(|b| b.header.as_ref());
+
+		let expected_block = block_header.as_ref().map_or(false, |h| match request.from {
+			FromBlock::Hash(hash) => h.hash() == hash,
+			FromBlock::Number(n) => h.number() == &n,
+		});
+
+		if !expected_block {
+			debug!(
+				target: "sync",
+				"Received block that was not requested. Requested {:?}, got {:?}.",
+				request.from,
+				block_header,
+			);
+
+			return Err(BadPeer(*who, rep::NOT_REQUESTED))
+		}
+
+		if request.fields.contains(BlockAttributes::HEADER) &&
+			blocks.iter().any(|b| b.header.is_none())
+		{
+			trace!(
+				target: "sync",
+				"Missing requested header for a block in response from {}.",
+				who,
+			);
+
+			return Err(BadPeer(*who, rep::BAD_RESPONSE))
+		}
+
+		if request.fields.contains(BlockAttributes::BODY) && blocks.iter().any(|b| b.body.is_none())
+		{
+			trace!(
+				target: "sync",
+				"Missing requested body for a block in response from {}.",
+				who,
+			);
+
+			return Err(BadPeer(*who, rep::BAD_RESPONSE))
+		}
+	}
+
+	for b in blocks {
+		if let Some(header) = &b.header {
+			let hash = header.hash();
+			if hash != b.hash {
+				debug!(
+					target:"sync",
+					"Bad header received from {}. Expected hash {:?}, got {:?}",
+					who,
+					b.hash,
+					hash,
+				);
+				return Err(BadPeer(*who, rep::BAD_BLOCK))
+			}
+		}
+		if let (Some(header), Some(body)) = (&b.header, &b.body) {
+			let expected = *header.extrinsics_root();
+			let got = HashingFor::<Block>::ordered_trie_root(
+				body.iter().map(Encode::encode).collect(),
+				sp_runtime::StateVersion::V0,
+			);
+			if expected != got {
+				debug!(
+					target:"sync",
+					"Bad extrinsic root for a block {} received from {}. Expected {:?}, got {:?}",
+					b.hash,
+					who,
+					expected,
+					got,
+				);
+				return Err(BadPeer(*who, rep::BAD_BLOCK))
+			}
+		}
+	}
+
+	Ok(blocks.first().and_then(|b| b.header.as_ref()).map(|h| *h.number()))
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::service::network::NetworkServiceProvider;
+	use futures::{executor::block_on, future::poll_fn};
+	use sc_block_builder::BlockBuilderProvider;
+	use sc_network_common::{
+		role::Role,
+		sync::message::{BlockData, BlockState, FromBlock},
+	};
+	use sp_blockchain::HeaderBackend;
+	use sp_consensus::block_validation::DefaultBlockAnnounceValidator;
+	use substrate_test_runtime_client::{
+		runtime::{Block, Hash, Header},
+		BlockBuilderExt, ClientBlockImportExt, ClientExt, DefaultTestClientBuilderExt, TestClient,
+		TestClientBuilder, TestClientBuilderExt,
+	};
+
+	#[test]
+	fn processes_empty_response_on_justification_request_for_unknown_block() {
+		// if we ask for a justification for a given block to a peer that doesn't know that block
+		// (different from not having a justification), the peer will reply with an empty response.
+		// internally we should process the response as the justification not being available.
+
+		let client = Arc::new(TestClientBuilder::new().build());
+		let block_announce_validator = Box::new(DefaultBlockAnnounceValidator);
+		let peer_id = PeerId::random();
+
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			block_announce_validator,
+			1,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let (a1_hash, a1_number) = {
+			let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+			(a1.hash(), *a1.header.number())
+		};
+
+		// add a new peer with the same best block
+		sync.new_peer(peer_id, a1_hash, a1_number).unwrap();
+
+		// and request a justification for the block
+		sync.request_justification(&a1_hash, a1_number);
+
+		// the justification request should be scheduled to that peer
+		assert!(sync
+			.justification_requests()
+			.any(|(who, request)| { who == peer_id && request.from == FromBlock::Hash(a1_hash) }));
+
+		// there are no extra pending requests
+		assert_eq!(sync.extra_justifications.pending_requests().count(), 0);
+
+		// there's one in-flight extra request to the expected peer
+		assert!(sync.extra_justifications.active_requests().any(|(who, (hash, number))| {
+			*who == peer_id && *hash == a1_hash && *number == a1_number
+		}));
+
+		// if the peer replies with an empty response (i.e. it doesn't know the block),
+		// the active request should be cleared.
+		assert_eq!(
+			sync.on_block_justification(peer_id, BlockResponse::<Block> { id: 0, blocks: vec![] }),
+			Ok(OnBlockJustification::Nothing),
+		);
+
+		// there should be no in-flight requests
+		assert_eq!(sync.extra_justifications.active_requests().count(), 0);
+
+		// and the request should now be pending again, waiting for reschedule
+		assert!(sync
+			.extra_justifications
+			.pending_requests()
+			.any(|(hash, number)| { *hash == a1_hash && *number == a1_number }));
+	}
+
+	#[test]
+	fn restart_doesnt_affect_peers_downloading_finality_data() {
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			Box::new(DefaultBlockAnnounceValidator),
+			1,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let peer_id1 = PeerId::random();
+		let peer_id2 = PeerId::random();
+		let peer_id3 = PeerId::random();
+
+		let mut new_blocks = |n| {
+			for _ in 0..n {
+				let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+				block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+			}
+
+			let info = client.info();
+			(info.best_hash, info.best_number)
+		};
+
+		let (b1_hash, b1_number) = new_blocks(50);
+
+		// add 2 peers at blocks that we don't have locally
+		sync.new_peer(peer_id1, Hash::random(), 42).unwrap();
+		sync.new_peer(peer_id2, Hash::random(), 10).unwrap();
+
+		// we wil send block requests to these peers
+		// for these blocks we don't know about
+		assert!(sync
+			.block_requests()
+			.into_iter()
+			.all(|(p, _)| { p == peer_id1 || p == peer_id2 }));
+
+		// add a new peer at a known block
+		sync.new_peer(peer_id3, b1_hash, b1_number).unwrap();
+
+		// we request a justification for a block we have locally
+		sync.request_justification(&b1_hash, b1_number);
+
+		// the justification request should be scheduled to the
+		// new peer which is at the given block
+		assert!(sync.justification_requests().any(|(p, r)| {
+			p == peer_id3 &&
+				r.fields == BlockAttributes::JUSTIFICATION &&
+				r.from == FromBlock::Hash(b1_hash)
+		}));
+
+		assert_eq!(
+			sync.peers.get(&peer_id3).unwrap().state,
+			PeerSyncState::DownloadingJustification(b1_hash),
+		);
+
+		// we restart the sync state
+		let block_requests = sync.restart();
+
+		// which should make us send out block requests to the first two peers
+		assert!(block_requests
+			.map(|r| r.unwrap())
+			.all(|(p, _)| { p == peer_id1 || p == peer_id2 }));
+
+		// peer 3 should be unaffected it was downloading finality data
+		assert_eq!(
+			sync.peers.get(&peer_id3).unwrap().state,
+			PeerSyncState::DownloadingJustification(b1_hash),
+		);
+
+		// Set common block to something that we don't have (e.g. failed import)
+		sync.peers.get_mut(&peer_id3).unwrap().common_number = 100;
+		let _ = sync.restart().count();
+		assert_eq!(sync.peers.get(&peer_id3).unwrap().common_number, 50);
+	}
+
+	/// Send a block annoucnement for the given `header`.
+	fn send_block_announce(
+		header: Header,
+		peer_id: &PeerId,
+		sync: &mut ChainSync<Block, TestClient>,
+	) {
+		let block_annnounce = BlockAnnounce {
+			header: header.clone(),
+			state: Some(BlockState::Best),
+			data: Some(Vec::new()),
+		};
+
+		sync.push_block_announce_validation(*peer_id, header.hash(), block_annnounce, true);
+
+		// Poll until we have procssed the block announcement
+		block_on(poll_fn(|cx| loop {
+			if sync.poll_block_announce_validation(cx).is_pending() {
+				break Poll::Ready(())
+			}
+		}))
+	}
+
+	/// Create a block response from the given `blocks`.
+	fn create_block_response(blocks: Vec<Block>) -> BlockResponse<Block> {
+		BlockResponse::<Block> {
+			id: 0,
+			blocks: blocks
+				.into_iter()
+				.map(|b| BlockData::<Block> {
+					hash: b.hash(),
+					header: Some(b.header().clone()),
+					body: Some(b.deconstruct().1),
+					indexed_body: None,
+					receipt: None,
+					message_queue: None,
+					justification: None,
+					justifications: None,
+				})
+				.collect(),
+		}
+	}
+
+	/// Get a block request from `sync` and check that is matches the expected request.
+	fn get_block_request(
+		sync: &mut ChainSync<Block, TestClient>,
+		from: FromBlock<Hash, u64>,
+		max: u32,
+		peer: &PeerId,
+	) -> BlockRequest<Block> {
+		let requests = sync.block_requests();
+
+		log::trace!(target: "sync", "Requests: {:?}", requests);
+
+		assert_eq!(1, requests.len());
+		assert_eq!(*peer, requests[0].0);
+
+		let request = requests[0].1.clone();
+
+		assert_eq!(from, request.from);
+		assert_eq!(Some(max), request.max);
+		request
+	}
+
+	/// Build and import a new best block.
+	fn build_block(client: &mut Arc<TestClient>, at: Option<Hash>, fork: bool) -> Block {
+		let at = at.unwrap_or_else(|| client.info().best_hash);
+
+		let mut block_builder = client.new_block_at(at, Default::default(), false).unwrap();
+
+		if fork {
+			block_builder.push_storage_change(vec![1, 2, 3], Some(vec![4, 5, 6])).unwrap();
+		}
+
+		let block = block_builder.build().unwrap().block;
+
+		block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+		block
+	}
+
+	/// This test is a regression test as observed on a real network.
+	///
+	/// The node is connected to multiple peers. Both of these peers are having a best block (1)
+	/// that is below our best block (3). Now peer 2 announces a fork of block 3 that we will
+	/// request from peer 2. After importing the fork, peer 2 and then peer 1 will announce block 4.
+	/// But as peer 1 in our view is still at block 1, we will request block 2 (which we already
+	/// have) from it. In the meanwhile peer 2 sends us block 4 and 3 and we send another request
+	/// for block 2 to peer 2. Peer 1 answers with block 2 and then peer 2. This will need to
+	/// succeed, as we have requested block 2 from both peers.
+	#[test]
+	fn do_not_report_peer_on_block_response_for_block_request() {
+		sp_tracing::try_init_simple();
+
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			Box::new(DefaultBlockAnnounceValidator),
+			5,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let peer_id1 = PeerId::random();
+		let peer_id2 = PeerId::random();
+
+		let mut client2 = client.clone();
+		let mut build_block_at = |at, import| {
+			let mut block_builder = client2.new_block_at(at, Default::default(), false).unwrap();
+			// Make sure we generate a different block as fork
+			block_builder.push_storage_change(vec![1, 2, 3], Some(vec![4, 5, 6])).unwrap();
+
+			let block = block_builder.build().unwrap().block;
+
+			if import {
+				block_on(client2.import(BlockOrigin::Own, block.clone())).unwrap();
+			}
+
+			block
+		};
+
+		let block1 = build_block(&mut client, None, false);
+		let block2 = build_block(&mut client, None, false);
+		let block3 = build_block(&mut client, None, false);
+		let block3_fork = build_block_at(block2.hash(), false);
+
+		// Add two peers which are on block 1.
+		sync.new_peer(peer_id1, block1.hash(), 1).unwrap();
+		sync.new_peer(peer_id2, block1.hash(), 1).unwrap();
+
+		// Tell sync that our best block is 3.
+		sync.update_chain_info(&block3.hash(), 3);
+
+		// There should be no requests.
+		assert!(sync.block_requests().is_empty());
+
+		// Let peer2 announce a fork of block 3
+		send_block_announce(block3_fork.header().clone(), &peer_id2, &mut sync);
+
+		// Import and tell sync that we now have the fork.
+		block_on(client.import(BlockOrigin::Own, block3_fork.clone())).unwrap();
+		sync.update_chain_info(&block3_fork.hash(), 3);
+
+		let block4 = build_block_at(block3_fork.hash(), false);
+
+		// Let peer2 announce block 4 and check that sync wants to get the block.
+		send_block_announce(block4.header().clone(), &peer_id2, &mut sync);
+
+		let request = get_block_request(&mut sync, FromBlock::Hash(block4.hash()), 2, &peer_id2);
+
+		// Peer1 announces the same block, but as the common block is still `1`, sync will request
+		// block 2 again.
+		send_block_announce(block4.header().clone(), &peer_id1, &mut sync);
+
+		let request2 = get_block_request(&mut sync, FromBlock::Number(2), 1, &peer_id1);
+
+		let response = create_block_response(vec![block4.clone(), block3_fork.clone()]);
+		let res = sync.on_block_data(&peer_id2, Some(request), response).unwrap();
+
+		// We should not yet import the blocks, because there is still an open request for fetching
+		// block `2` which blocks the import.
+		assert!(matches!(res, OnBlockData::Import(_, blocks) if blocks.is_empty()));
+
+		let request3 = get_block_request(&mut sync, FromBlock::Number(2), 1, &peer_id2);
+
+		let response = create_block_response(vec![block2.clone()]);
+		let res = sync.on_block_data(&peer_id1, Some(request2), response).unwrap();
+		assert!(matches!(
+			res,
+			OnBlockData::Import(_, blocks)
+				if blocks.iter().all(|b| [2, 3, 4].contains(b.header.as_ref().unwrap().number()))
+		));
+
+		let response = create_block_response(vec![block2.clone()]);
+		let res = sync.on_block_data(&peer_id2, Some(request3), response).unwrap();
+		// Nothing to import
+		assert!(matches!(res, OnBlockData::Import(_, blocks) if blocks.is_empty()));
+	}
+
+	fn unwrap_from_block_number(from: FromBlock<Hash, u64>) -> u64 {
+		if let FromBlock::Number(from) = from {
+			from
+		} else {
+			panic!("Expected a number!");
+		}
+	}
+
+	/// A regression test for a behavior we have seen on a live network.
+	///
+	/// The scenario is that the node is doing a full resync and is connected to some node that is
+	/// doing a major sync as well. This other node that is doing a major sync will finish before
+	/// our node and send a block announcement message, but we don't have seen any block
+	/// announcement from this node in its sync process. Meaning our common number didn't change. It
+	/// is now expected that we start an ancestor search to find the common number.
+	#[test]
+	fn do_ancestor_search_when_common_block_to_best_qeued_gap_is_to_big() {
+		sp_tracing::try_init_simple();
+
+		let blocks = {
+			let mut client = Arc::new(TestClientBuilder::new().build());
+			(0..MAX_DOWNLOAD_AHEAD * 2)
+				.map(|_| build_block(&mut client, None, false))
+				.collect::<Vec<_>>()
+		};
+
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+		let info = client.info();
+
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			Box::new(DefaultBlockAnnounceValidator),
+			5,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let peer_id1 = PeerId::random();
+		let peer_id2 = PeerId::random();
+
+		let best_block = blocks.last().unwrap().clone();
+		let max_blocks_to_request = sync.max_blocks_per_request;
+		// Connect the node we will sync from
+		sync.new_peer(peer_id1, best_block.hash(), *best_block.header().number())
+			.unwrap();
+		sync.new_peer(peer_id2, info.best_hash, 0).unwrap();
+
+		let mut best_block_num = 0;
+		while best_block_num < MAX_DOWNLOAD_AHEAD {
+			let request = get_block_request(
+				&mut sync,
+				FromBlock::Number(max_blocks_to_request as u64 + best_block_num as u64),
+				max_blocks_to_request as u32,
+				&peer_id1,
+			);
+
+			let from = unwrap_from_block_number(request.from.clone());
+
+			let mut resp_blocks = blocks[best_block_num as usize..from as usize].to_vec();
+			resp_blocks.reverse();
+
+			let response = create_block_response(resp_blocks.clone());
+
+			let res = sync.on_block_data(&peer_id1, Some(request), response).unwrap();
+			assert!(matches!(
+				res,
+				OnBlockData::Import(_, blocks) if blocks.len() == max_blocks_to_request as usize
+			),);
+
+			best_block_num += max_blocks_to_request as u32;
+
+			let _ = sync.on_blocks_processed(
+				max_blocks_to_request as usize,
+				max_blocks_to_request as usize,
+				resp_blocks
+					.iter()
+					.rev()
+					.map(|b| {
+						(
+							Ok(BlockImportStatus::ImportedUnknown(
+								*b.header().number(),
+								Default::default(),
+								Some(peer_id1),
+							)),
+							b.hash(),
+						)
+					})
+					.collect(),
+			);
+
+			resp_blocks
+				.into_iter()
+				.rev()
+				.for_each(|b| block_on(client.import_as_final(BlockOrigin::Own, b)).unwrap());
+		}
+
+		// "Wait" for the queue to clear
+		sync.queue_blocks.clear();
+
+		// Let peer2 announce that it finished syncing
+		send_block_announce(best_block.header().clone(), &peer_id2, &mut sync);
+
+		let (peer1_req, peer2_req) =
+			sync.block_requests().into_iter().fold((None, None), |res, req| {
+				if req.0 == peer_id1 {
+					(Some(req.1), res.1)
+				} else if req.0 == peer_id2 {
+					(res.0, Some(req.1))
+				} else {
+					panic!("Unexpected req: {:?}", req)
+				}
+			});
+
+		// We should now do an ancestor search to find the correct common block.
+		let peer2_req = peer2_req.unwrap();
+		assert_eq!(Some(1), peer2_req.max);
+		assert_eq!(FromBlock::Number(best_block_num as u64), peer2_req.from);
+
+		let response = create_block_response(vec![blocks[(best_block_num - 1) as usize].clone()]);
+		let res = sync.on_block_data(&peer_id2, Some(peer2_req), response).unwrap();
+		assert!(matches!(
+			res,
+			OnBlockData::Import(_, blocks) if blocks.is_empty()
+		),);
+
+		let peer1_from = unwrap_from_block_number(peer1_req.unwrap().from);
+
+		// As we are on the same chain, we should directly continue with requesting blocks from
+		// peer 2 as well.
+		get_block_request(
+			&mut sync,
+			FromBlock::Number(peer1_from + max_blocks_to_request as u64),
+			max_blocks_to_request as u32,
+			&peer_id2,
+		);
+	}
+
+	/// A test that ensures that we can sync a huge fork.
+	///
+	/// The following scenario:
+	/// A peer connects to us and we both have the common block 512. The last finalized is 2048.
+	/// Our best block is 4096. The peer send us a block announcement with 4097 from a fork.
+	///
+	/// We will first do an ancestor search to find the common block. After that we start to sync
+	/// the fork and finish it ;)
+	#[test]
+	fn can_sync_huge_fork() {
+		sp_tracing::try_init_simple();
+
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let blocks = (0..MAX_BLOCKS_TO_LOOK_BACKWARDS * 4)
+			.map(|_| build_block(&mut client, None, false))
+			.collect::<Vec<_>>();
+
+		let fork_blocks = {
+			let mut client = Arc::new(TestClientBuilder::new().build());
+			let fork_blocks = blocks[..MAX_BLOCKS_TO_LOOK_BACKWARDS as usize * 2]
+				.into_iter()
+				.inspect(|b| block_on(client.import(BlockOrigin::Own, (*b).clone())).unwrap())
+				.cloned()
+				.collect::<Vec<_>>();
+
+			fork_blocks
+				.into_iter()
+				.chain(
+					(0..MAX_BLOCKS_TO_LOOK_BACKWARDS * 2 + 1)
+						.map(|_| build_block(&mut client, None, true)),
+				)
+				.collect::<Vec<_>>()
+		};
+
+		let info = client.info();
+
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			Box::new(DefaultBlockAnnounceValidator),
+			5,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let finalized_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize * 2 - 1].clone();
+		let just = (*b"TEST", Vec::new());
+		client.finalize_block(finalized_block.hash(), Some(just)).unwrap();
+		sync.update_chain_info(&info.best_hash, info.best_number);
+
+		let peer_id1 = PeerId::random();
+
+		let common_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize / 2].clone();
+		// Connect the node we will sync from
+		sync.new_peer(peer_id1, common_block.hash(), *common_block.header().number())
+			.unwrap();
+
+		send_block_announce(fork_blocks.last().unwrap().header().clone(), &peer_id1, &mut sync);
+
+		let mut request =
+			get_block_request(&mut sync, FromBlock::Number(info.best_number), 1, &peer_id1);
+
+		// Do the ancestor search
+		loop {
+			let block = &fork_blocks[unwrap_from_block_number(request.from.clone()) as usize - 1];
+			let response = create_block_response(vec![block.clone()]);
+
+			let on_block_data = sync.on_block_data(&peer_id1, Some(request), response).unwrap();
+			request = if let OnBlockData::Request(_peer, request) = on_block_data {
+				request
+			} else {
+				// We found the ancenstor
+				break
+			};
+
+			log::trace!(target: "sync", "Request: {:?}", request);
+		}
+
+		// Now request and import the fork.
+		let mut best_block_num = *finalized_block.header().number() as u32;
+		let max_blocks_to_request = sync.max_blocks_per_request;
+		while best_block_num < *fork_blocks.last().unwrap().header().number() as u32 - 1 {
+			let request = get_block_request(
+				&mut sync,
+				FromBlock::Number(max_blocks_to_request as u64 + best_block_num as u64),
+				max_blocks_to_request as u32,
+				&peer_id1,
+			);
+
+			let from = unwrap_from_block_number(request.from.clone());
+
+			let mut resp_blocks = fork_blocks[best_block_num as usize..from as usize].to_vec();
+			resp_blocks.reverse();
+
+			let response = create_block_response(resp_blocks.clone());
+
+			let res = sync.on_block_data(&peer_id1, Some(request), response).unwrap();
+			assert!(matches!(
+				res,
+				OnBlockData::Import(_, blocks) if blocks.len() == sync.max_blocks_per_request as usize
+			),);
+
+			best_block_num += sync.max_blocks_per_request as u32;
+
+			let _ = sync.on_blocks_processed(
+				max_blocks_to_request as usize,
+				max_blocks_to_request as usize,
+				resp_blocks
+					.iter()
+					.rev()
+					.map(|b| {
+						(
+							Ok(BlockImportStatus::ImportedUnknown(
+								*b.header().number(),
+								Default::default(),
+								Some(peer_id1),
+							)),
+							b.hash(),
+						)
+					})
+					.collect(),
+			);
+
+			resp_blocks
+				.into_iter()
+				.rev()
+				.for_each(|b| block_on(client.import(BlockOrigin::Own, b)).unwrap());
+		}
+
+		// Request the tip
+		get_block_request(
+			&mut sync,
+			FromBlock::Hash(fork_blocks.last().unwrap().hash()),
+			1,
+			&peer_id1,
+		);
+	}
+
+	#[test]
+	fn syncs_fork_without_duplicate_requests() {
+		sp_tracing::try_init_simple();
+
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let blocks = (0..MAX_BLOCKS_TO_LOOK_BACKWARDS * 4)
+			.map(|_| build_block(&mut client, None, false))
+			.collect::<Vec<_>>();
+
+		let fork_blocks = {
+			let mut client = Arc::new(TestClientBuilder::new().build());
+			let fork_blocks = blocks[..MAX_BLOCKS_TO_LOOK_BACKWARDS as usize * 2]
+				.into_iter()
+				.inspect(|b| block_on(client.import(BlockOrigin::Own, (*b).clone())).unwrap())
+				.cloned()
+				.collect::<Vec<_>>();
+
+			fork_blocks
+				.into_iter()
+				.chain(
+					(0..MAX_BLOCKS_TO_LOOK_BACKWARDS * 2 + 1)
+						.map(|_| build_block(&mut client, None, true)),
+				)
+				.collect::<Vec<_>>()
+		};
+
+		let info = client.info();
+
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			Box::new(DefaultBlockAnnounceValidator),
+			5,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let finalized_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize * 2 - 1].clone();
+		let just = (*b"TEST", Vec::new());
+		client.finalize_block(finalized_block.hash(), Some(just)).unwrap();
+		sync.update_chain_info(&info.best_hash, info.best_number);
+
+		let peer_id1 = PeerId::random();
+
+		let common_block = blocks[MAX_BLOCKS_TO_LOOK_BACKWARDS as usize / 2].clone();
+		// Connect the node we will sync from
+		sync.new_peer(peer_id1, common_block.hash(), *common_block.header().number())
+			.unwrap();
+
+		send_block_announce(fork_blocks.last().unwrap().header().clone(), &peer_id1, &mut sync);
+
+		let mut request =
+			get_block_request(&mut sync, FromBlock::Number(info.best_number), 1, &peer_id1);
+
+		// Do the ancestor search
+		loop {
+			let block = &fork_blocks[unwrap_from_block_number(request.from.clone()) as usize - 1];
+			let response = create_block_response(vec![block.clone()]);
+
+			let on_block_data = sync.on_block_data(&peer_id1, Some(request), response).unwrap();
+			request = if let OnBlockData::Request(_peer, request) = on_block_data {
+				request
+			} else {
+				// We found the ancenstor
+				break
+			};
+
+			log::trace!(target: "sync", "Request: {:?}", request);
+		}
+
+		// Now request and import the fork.
+		let mut best_block_num = *finalized_block.header().number() as u32;
+		let max_blocks_to_request = sync.max_blocks_per_request;
+
+		let mut request = get_block_request(
+			&mut sync,
+			FromBlock::Number(max_blocks_to_request as u64 + best_block_num as u64),
+			max_blocks_to_request as u32,
+			&peer_id1,
+		);
+		let last_block_num = *fork_blocks.last().unwrap().header().number() as u32 - 1;
+		while best_block_num < last_block_num {
+			let from = unwrap_from_block_number(request.from.clone());
+
+			let mut resp_blocks = fork_blocks[best_block_num as usize..from as usize].to_vec();
+			resp_blocks.reverse();
+
+			let response = create_block_response(resp_blocks.clone());
+
+			let res = sync.on_block_data(&peer_id1, Some(request.clone()), response).unwrap();
+			assert!(matches!(
+				res,
+				OnBlockData::Import(_, blocks) if blocks.len() == max_blocks_to_request as usize
+			),);
+
+			best_block_num += max_blocks_to_request as u32;
+
+			if best_block_num < last_block_num {
+				// make sure we're not getting a duplicate request in the time before the blocks are
+				// processed
+				request = get_block_request(
+					&mut sync,
+					FromBlock::Number(max_blocks_to_request as u64 + best_block_num as u64),
+					max_blocks_to_request as u32,
+					&peer_id1,
+				);
+			}
+
+			let mut notify_imported: Vec<_> = resp_blocks
+				.iter()
+				.rev()
+				.map(|b| {
+					(
+						Ok(BlockImportStatus::ImportedUnknown(
+							*b.header().number(),
+							Default::default(),
+							Some(peer_id1),
+						)),
+						b.hash(),
+					)
+				})
+				.collect();
+
+			// The import queue may send notifications in batches of varying size. So we simulate
+			// this here by splitting the batch into 2 notifications.
+			let max_blocks_to_request = sync.max_blocks_per_request;
+			let second_batch = notify_imported.split_off(notify_imported.len() / 2);
+			let _ = sync.on_blocks_processed(
+				max_blocks_to_request as usize,
+				max_blocks_to_request as usize,
+				notify_imported,
+			);
+
+			let _ = sync.on_blocks_processed(
+				max_blocks_to_request as usize,
+				max_blocks_to_request as usize,
+				second_batch,
+			);
+
+			resp_blocks
+				.into_iter()
+				.rev()
+				.for_each(|b| block_on(client.import(BlockOrigin::Own, b)).unwrap());
+		}
+
+		// Request the tip
+		get_block_request(
+			&mut sync,
+			FromBlock::Hash(fork_blocks.last().unwrap().hash()),
+			1,
+			&peer_id1,
+		);
+	}
+
+	#[test]
+	fn removes_target_fork_on_disconnect() {
+		sp_tracing::try_init_simple();
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let blocks = (0..3).map(|_| build_block(&mut client, None, false)).collect::<Vec<_>>();
+
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			Box::new(DefaultBlockAnnounceValidator),
+			1,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let peer_id1 = PeerId::random();
+		let common_block = blocks[1].clone();
+		// Connect the node we will sync from
+		sync.new_peer(peer_id1, common_block.hash(), *common_block.header().number())
+			.unwrap();
+
+		// Create a "new" header and announce it
+		let mut header = blocks[0].header().clone();
+		header.number = 4;
+		send_block_announce(header, &peer_id1, &mut sync);
+		assert!(sync.fork_targets.len() == 1);
+
+		sync.peer_disconnected(&peer_id1);
+		assert!(sync.fork_targets.len() == 0);
+	}
+
+	#[test]
+	fn can_import_response_with_missing_blocks() {
+		sp_tracing::try_init_simple();
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+		let mut client2 = Arc::new(TestClientBuilder::new().build());
+		let blocks = (0..4).map(|_| build_block(&mut client2, None, false)).collect::<Vec<_>>();
+
+		let empty_client = Arc::new(TestClientBuilder::new().build());
+
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			empty_client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			Box::new(DefaultBlockAnnounceValidator),
+			1,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let peer_id1 = PeerId::random();
+		let best_block = blocks[3].clone();
+		sync.new_peer(peer_id1, best_block.hash(), *best_block.header().number())
+			.unwrap();
+
+		sync.peers.get_mut(&peer_id1).unwrap().state = PeerSyncState::Available;
+		sync.peers.get_mut(&peer_id1).unwrap().common_number = 0;
+
+		// Request all missing blocks and respond only with some.
+		let request =
+			get_block_request(&mut sync, FromBlock::Hash(best_block.hash()), 4, &peer_id1);
+		let response =
+			create_block_response(vec![blocks[3].clone(), blocks[2].clone(), blocks[1].clone()]);
+		sync.on_block_data(&peer_id1, Some(request.clone()), response).unwrap();
+		assert_eq!(sync.best_queued_number, 0);
+
+		// Request should only contain the missing block.
+		let request = get_block_request(&mut sync, FromBlock::Number(1), 1, &peer_id1);
+		let response = create_block_response(vec![blocks[0].clone()]);
+		sync.on_block_data(&peer_id1, Some(request), response).unwrap();
+		assert_eq!(sync.best_queued_number, 4);
+	}
+	#[test]
+	fn ancestor_search_repeat() {
+		let state = AncestorSearchState::<Block>::BinarySearch(1, 3);
+		assert!(handle_ancestor_search_state(&state, 2, true).is_none());
+	}
+
+	#[test]
+	fn sync_restart_removes_block_but_not_justification_requests() {
+		let mut client = Arc::new(TestClientBuilder::new().build());
+		let block_announce_validator = Box::new(DefaultBlockAnnounceValidator);
+		let import_queue = Box::new(sc_consensus::import_queue::mock::MockImportQueueHandle::new());
+		let (_chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+		let (mut sync, _) = ChainSync::new(
+			SyncMode::Full,
+			client.clone(),
+			ProtocolId::from("test-protocol-name"),
+			&Some(String::from("test-fork-id")),
+			Roles::from(&Role::Full),
+			block_announce_validator,
+			1,
+			64,
+			None,
+			None,
+			chain_sync_network_handle,
+			import_queue,
+			ProtocolName::from("block-request"),
+			ProtocolName::from("state-request"),
+			None,
+		)
+		.unwrap();
+
+		let peers = vec![PeerId::random(), PeerId::random()];
+
+		let mut new_blocks = |n| {
+			for _ in 0..n {
+				let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+				block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+			}
+
+			let info = client.info();
+			(info.best_hash, info.best_number)
+		};
+
+		let (b1_hash, b1_number) = new_blocks(50);
+
+		// add new peer and request blocks from them
+		sync.new_peer(peers[0], Hash::random(), 42).unwrap();
+
+		// we wil send block requests to these peers
+		// for these blocks we don't know about
+		for (peer, request) in sync.block_requests() {
+			sync.send_block_request(peer, request);
+		}
+
+		// add a new peer at a known block
+		sync.new_peer(peers[1], b1_hash, b1_number).unwrap();
+
+		// we request a justification for a block we have locally
+		sync.request_justification(&b1_hash, b1_number);
+
+		// the justification request should be scheduled to the
+		// new peer which is at the given block
+		let mut requests = sync.justification_requests().collect::<Vec<_>>();
+		assert_eq!(requests.len(), 1);
+		let (peer, request) = requests.remove(0);
+		sync.send_block_request(peer, request);
+
+		assert!(!std::matches!(
+			sync.peers.get(&peers[0]).unwrap().state,
+			PeerSyncState::DownloadingJustification(_),
+		));
+		assert_eq!(
+			sync.peers.get(&peers[1]).unwrap().state,
+			PeerSyncState::DownloadingJustification(b1_hash),
+		);
+		assert_eq!(sync.pending_responses.len(), 2);
+
+		let requests = sync.restart().collect::<Vec<_>>();
+		assert!(requests.iter().any(|res| res.as_ref().unwrap().0 == peers[0]));
+
+		assert_eq!(sync.pending_responses.len(), 1);
+		assert!(sync.pending_responses.get(&peers[1]).is_some());
+		assert_eq!(
+			sync.peers.get(&peers[1]).unwrap().state,
+			PeerSyncState::DownloadingJustification(b1_hash),
+		);
+		sync.peer_disconnected(&peers[1]);
+		assert_eq!(sync.pending_responses.len(), 0);
+	}
+}
diff --git a/substrate/client/network/sync/src/mock.rs b/substrate/client/network/sync/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..838c6cf7667a2463a38dc093addce42577bfc89f
--- /dev/null
+++ b/substrate/client/network/sync/src/mock.rs
@@ -0,0 +1,102 @@
+// 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/>.
+
+//! Contains a mock implementation of `ChainSync` that can be used
+//! for testing calls made to `ChainSync`.
+
+use futures::task::Poll;
+use libp2p::PeerId;
+use sc_network_common::sync::{
+	message::{BlockAnnounce, BlockData, BlockRequest, BlockResponse},
+	BadPeer, ChainSync as ChainSyncT, Metrics, OnBlockData, OnBlockJustification,
+	OpaqueBlockResponse, PeerInfo, PollBlockAnnounceValidation, SyncStatus,
+};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+mockall::mock! {
+	pub ChainSync<Block: BlockT> {}
+
+	impl<Block: BlockT> ChainSyncT<Block> for ChainSync<Block> {
+		fn peer_info(&self, who: &PeerId) -> Option<PeerInfo<Block>>;
+		fn status(&self) -> SyncStatus<Block>;
+		fn num_sync_requests(&self) -> usize;
+		fn num_downloaded_blocks(&self) -> usize;
+		fn num_peers(&self) -> usize;
+		fn num_active_peers(&self) -> usize;
+		fn new_peer(
+			&mut self,
+			who: PeerId,
+			best_hash: Block::Hash,
+			best_number: NumberFor<Block>,
+		) -> Result<Option<BlockRequest<Block>>, BadPeer>;
+		fn update_chain_info(&mut self, best_hash: &Block::Hash, best_number: NumberFor<Block>);
+		fn request_justification(&mut self, hash: &Block::Hash, number: NumberFor<Block>);
+		fn clear_justification_requests(&mut self);
+		fn set_sync_fork_request(
+			&mut self,
+			peers: Vec<PeerId>,
+			hash: &Block::Hash,
+			number: NumberFor<Block>,
+		);
+		fn on_block_data(
+			&mut self,
+			who: &PeerId,
+			request: Option<BlockRequest<Block>>,
+			response: BlockResponse<Block>,
+		) -> Result<OnBlockData<Block>, BadPeer>;
+		fn on_block_justification(
+			&mut self,
+			who: PeerId,
+			response: BlockResponse<Block>,
+		) -> Result<OnBlockJustification<Block>, BadPeer>;
+		fn on_justification_import(
+			&mut self,
+			hash: Block::Hash,
+			number: NumberFor<Block>,
+			success: bool,
+		);
+		fn on_block_finalized(&mut self, hash: &Block::Hash, number: NumberFor<Block>);
+		fn push_block_announce_validation(
+			&mut self,
+			who: PeerId,
+			hash: Block::Hash,
+			announce: BlockAnnounce<Block::Header>,
+			is_best: bool,
+		);
+		fn poll_block_announce_validation<'a>(
+			&mut self,
+			cx: &mut std::task::Context<'a>,
+		) -> Poll<PollBlockAnnounceValidation<Block::Header>>;
+		fn peer_disconnected(&mut self, who: &PeerId);
+		fn metrics(&self) -> Metrics;
+		fn block_response_into_blocks(
+			&self,
+			request: &BlockRequest<Block>,
+			response: OpaqueBlockResponse,
+		) -> Result<Vec<BlockData<Block>>, String>;
+		fn poll<'a>(
+			&mut self,
+			cx: &mut std::task::Context<'a>,
+		) -> Poll<PollBlockAnnounceValidation<Block::Header>>;
+		fn send_block_request(
+			&mut self,
+			who: PeerId,
+			request: BlockRequest<Block>,
+		);
+	}
+}
diff --git a/substrate/client/network/sync/src/schema.rs b/substrate/client/network/sync/src/schema.rs
new file mode 100644
index 0000000000000000000000000000000000000000..22b7ee592778ef68f0240bb6033c09738ff124ff
--- /dev/null
+++ b/substrate/client/network/sync/src/schema.rs
@@ -0,0 +1,23 @@
+// 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/>.
+
+//! Include sources generated from protobuf definitions.
+
+pub(crate) mod v1 {
+	include!(concat!(env!("OUT_DIR"), "/api.v1.rs"));
+}
diff --git a/substrate/client/network/sync/src/schema/api.v1.proto b/substrate/client/network/sync/src/schema/api.v1.proto
new file mode 100644
index 0000000000000000000000000000000000000000..1490f61a41ddd4b913f0ba8238d83191d58cb262
--- /dev/null
+++ b/substrate/client/network/sync/src/schema/api.v1.proto
@@ -0,0 +1,106 @@
+// Schema definition for block request/response messages.
+
+syntax = "proto3";
+
+package api.v1;
+
+// Block enumeration direction.
+enum Direction {
+	// Enumerate in ascending order (from child to parent).
+	Ascending = 0;
+	// Enumerate in descending order (from parent to canonical child).
+	Descending = 1;
+}
+
+// Request block data from a peer.
+message BlockRequest {
+	// Bits of block data to request.
+	uint32 fields = 1;
+	// Start from this block.
+	oneof from_block {
+		// Start with given hash.
+		bytes hash = 2;
+		// Start with given block number.
+		bytes number = 3;
+	}
+	// Sequence direction.
+	// If missing, should be interpreted as "Ascending".
+	Direction direction = 5;
+	// Maximum number of blocks to return. An implementation defined maximum is used when unspecified.
+	uint32 max_blocks = 6; // optional
+	// Indicate to the receiver that we support multiple justifications. If the responder also
+	// supports this it will populate the multiple justifications field in `BlockData` instead of
+	// the single justification field.
+	bool support_multiple_justifications = 7; // optional
+}
+
+// Response to `BlockRequest`
+message BlockResponse {
+	// Block data for the requested sequence.
+	repeated BlockData blocks = 1;
+}
+
+// Block data sent in the response.
+message BlockData {
+	// Block header hash.
+	bytes hash = 1;
+	// Block header if requested.
+	bytes header = 2; // optional
+	// Block body if requested.
+	repeated bytes body = 3; // optional
+	// Block receipt if requested.
+	bytes receipt = 4; // optional
+	// Block message queue if requested.
+	bytes message_queue = 5; // optional
+	// Justification if requested.
+	bytes justification = 6; // optional
+	// True if justification should be treated as present but empty.
+	// This hack is unfortunately necessary because shortcomings in the protobuf format otherwise
+	// doesn't make in possible to differentiate between a lack of justification and an empty
+	// justification.
+	bool is_empty_justification = 7; // optional, false if absent
+	// Justifications if requested.
+	// Unlike the field for a single justification, this field does not required an associated
+	// boolean to differentiate between the lack of justifications and empty justification(s). This
+	// is because empty justifications, like all justifications, are paired with a non-empty
+	// consensus engine ID.
+	bytes justifications = 8; // optional
+	// Indexed block body if requestd.
+	repeated bytes indexed_body = 9; // optional
+}
+
+// Request storage data from a peer.
+message StateRequest {
+	// Block header hash.
+	bytes block = 1;
+	// Start from this key.
+	// Multiple keys used for nested state start.
+	repeated bytes start = 2; // optional
+	// if 'true' indicates that response should contain raw key-values, rather than proof.
+	bool no_proof = 3;
+}
+
+message StateResponse {
+	// A collection of keys-values states. Only populated if `no_proof` is `true`
+	repeated KeyValueStateEntry entries = 1;
+	// If `no_proof` is false in request, this contains proof nodes.
+	bytes proof = 2;
+}
+
+// A key value state.
+message KeyValueStateEntry {
+	// Root of for this level, empty length bytes
+	// if top level.
+	bytes state_root = 1;
+	// A collection of keys-values.
+	repeated StateEntry entries = 2;
+	// Set to true when there are no more keys to return.
+	bool complete = 3;
+}
+
+// A key-value pair.
+message StateEntry {
+	bytes key = 1;
+	bytes value = 2;
+}
+
diff --git a/substrate/client/network/sync/src/service/chain_sync.rs b/substrate/client/network/sync/src/service/chain_sync.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f9e0e401fdf8fad5054cd1b8bb0dfe806e4ee3ea
--- /dev/null
+++ b/substrate/client/network/sync/src/service/chain_sync.rs
@@ -0,0 +1,258 @@
+// 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 futures::{channel::oneshot, Stream};
+use libp2p::PeerId;
+
+use sc_consensus::{BlockImportError, BlockImportStatus, JustificationSyncLink, Link};
+use sc_network::{NetworkBlock, NetworkSyncForkRequest};
+use sc_network_common::sync::{
+	ExtendedPeerInfo, SyncEvent, SyncEventStream, SyncStatus, SyncStatusProvider,
+};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use std::{
+	pin::Pin,
+	sync::{
+		atomic::{AtomicBool, AtomicUsize, Ordering},
+		Arc,
+	},
+};
+
+/// Commands send to `ChainSync`
+pub enum ToServiceCommand<B: BlockT> {
+	SetSyncForkRequest(Vec<PeerId>, B::Hash, NumberFor<B>),
+	RequestJustification(B::Hash, NumberFor<B>),
+	ClearJustificationRequests,
+	BlocksProcessed(
+		usize,
+		usize,
+		Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>,
+	),
+	JustificationImported(PeerId, B::Hash, NumberFor<B>, bool),
+	AnnounceBlock(B::Hash, Option<Vec<u8>>),
+	NewBestBlockImported(B::Hash, NumberFor<B>),
+	EventStream(TracingUnboundedSender<SyncEvent>),
+	Status(oneshot::Sender<SyncStatus<B>>),
+	NumActivePeers(oneshot::Sender<usize>),
+	SyncState(oneshot::Sender<SyncStatus<B>>),
+	BestSeenBlock(oneshot::Sender<Option<NumberFor<B>>>),
+	NumSyncPeers(oneshot::Sender<u32>),
+	NumQueuedBlocks(oneshot::Sender<u32>),
+	NumDownloadedBlocks(oneshot::Sender<usize>),
+	NumSyncRequests(oneshot::Sender<usize>),
+	PeersInfo(oneshot::Sender<Vec<(PeerId, ExtendedPeerInfo<B>)>>),
+	OnBlockFinalized(B::Hash, B::Header),
+	// Status {
+	// 	pending_response: oneshot::Sender<SyncStatus<B>>,
+	// },
+}
+
+/// Handle for communicating with `ChainSync` asynchronously
+#[derive(Clone)]
+pub struct SyncingService<B: BlockT> {
+	tx: TracingUnboundedSender<ToServiceCommand<B>>,
+	/// Number of peers we're connected to.
+	num_connected: Arc<AtomicUsize>,
+	/// Are we actively catching up with the chain?
+	is_major_syncing: Arc<AtomicBool>,
+}
+
+impl<B: BlockT> SyncingService<B> {
+	/// Create new handle
+	pub fn new(
+		tx: TracingUnboundedSender<ToServiceCommand<B>>,
+		num_connected: Arc<AtomicUsize>,
+		is_major_syncing: Arc<AtomicBool>,
+	) -> Self {
+		Self { tx, num_connected, is_major_syncing }
+	}
+
+	/// Get the number of active peers.
+	pub async fn num_active_peers(&self) -> Result<usize, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumActivePeers(tx));
+
+		rx.await
+	}
+
+	/// Get best seen block.
+	pub async fn best_seen_block(&self) -> Result<Option<NumberFor<B>>, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::BestSeenBlock(tx));
+
+		rx.await
+	}
+
+	/// Get the number of sync peers.
+	pub async fn num_sync_peers(&self) -> Result<u32, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumSyncPeers(tx));
+
+		rx.await
+	}
+
+	/// Get the number of queued blocks.
+	pub async fn num_queued_blocks(&self) -> Result<u32, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumQueuedBlocks(tx));
+
+		rx.await
+	}
+
+	/// Get the number of downloaded blocks.
+	pub async fn num_downloaded_blocks(&self) -> Result<usize, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumDownloadedBlocks(tx));
+
+		rx.await
+	}
+
+	/// Get the number of sync requests.
+	pub async fn num_sync_requests(&self) -> Result<usize, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::NumSyncRequests(tx));
+
+		rx.await
+	}
+
+	/// Get peer information.
+	pub async fn peers_info(
+		&self,
+	) -> Result<Vec<(PeerId, ExtendedPeerInfo<B>)>, oneshot::Canceled> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::PeersInfo(tx));
+
+		rx.await
+	}
+
+	/// Notify the `SyncingEngine` that a block has been finalized.
+	pub fn on_block_finalized(&self, hash: B::Hash, header: B::Header) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::OnBlockFinalized(hash, header));
+	}
+
+	/// Get sync status
+	///
+	/// Returns an error if `ChainSync` has terminated.
+	pub async fn status(&self) -> Result<SyncStatus<B>, ()> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.tx.unbounded_send(ToServiceCommand::Status(tx));
+
+		rx.await.map_err(|_| ())
+	}
+}
+
+impl<B: BlockT + 'static> NetworkSyncForkRequest<B::Hash, NumberFor<B>> for SyncingService<B> {
+	/// Configure an explicit fork sync request.
+	///
+	/// Note that this function should not be used for recent blocks.
+	/// Sync should be able to download all the recent forks normally.
+	/// `set_sync_fork_request` should only be used if external code detects that there's
+	/// a stale fork missing.
+	///
+	/// Passing empty `peers` set effectively removes the sync request.
+	fn set_sync_fork_request(&self, peers: Vec<PeerId>, hash: B::Hash, number: NumberFor<B>) {
+		let _ = self
+			.tx
+			.unbounded_send(ToServiceCommand::SetSyncForkRequest(peers, hash, number));
+	}
+}
+
+impl<B: BlockT> JustificationSyncLink<B> for SyncingService<B> {
+	/// Request a justification for the given block from the network.
+	///
+	/// On success, the justification will be passed to the import queue that was part at
+	/// initialization as part of the configuration.
+	fn request_justification(&self, hash: &B::Hash, number: NumberFor<B>) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::RequestJustification(*hash, number));
+	}
+
+	fn clear_justification_requests(&self) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::ClearJustificationRequests);
+	}
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT> SyncStatusProvider<B> for SyncingService<B> {
+	/// Get high-level view of the syncing status.
+	async fn status(&self) -> Result<SyncStatus<B>, ()> {
+		let (rtx, rrx) = oneshot::channel();
+
+		let _ = self.tx.unbounded_send(ToServiceCommand::Status(rtx));
+		rrx.await.map_err(|_| ())
+	}
+}
+
+impl<B: BlockT> Link<B> for SyncingService<B> {
+	fn blocks_processed(
+		&mut self,
+		imported: usize,
+		count: usize,
+		results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>,
+	) {
+		let _ = self
+			.tx
+			.unbounded_send(ToServiceCommand::BlocksProcessed(imported, count, results));
+	}
+
+	fn justification_imported(
+		&mut self,
+		who: PeerId,
+		hash: &B::Hash,
+		number: NumberFor<B>,
+		success: bool,
+	) {
+		let _ = self
+			.tx
+			.unbounded_send(ToServiceCommand::JustificationImported(who, *hash, number, success));
+	}
+
+	fn request_justification(&mut self, hash: &B::Hash, number: NumberFor<B>) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::RequestJustification(*hash, number));
+	}
+}
+
+impl<B: BlockT> SyncEventStream for SyncingService<B> {
+	/// Get syncing event stream.
+	fn event_stream(&self, name: &'static str) -> Pin<Box<dyn Stream<Item = SyncEvent> + Send>> {
+		let (tx, rx) = tracing_unbounded(name, 100_000);
+		let _ = self.tx.unbounded_send(ToServiceCommand::EventStream(tx));
+		Box::pin(rx)
+	}
+}
+
+impl<B: BlockT> NetworkBlock<B::Hash, NumberFor<B>> for SyncingService<B> {
+	fn announce_block(&self, hash: B::Hash, data: Option<Vec<u8>>) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::AnnounceBlock(hash, data));
+	}
+
+	fn new_best_block_imported(&self, hash: B::Hash, number: NumberFor<B>) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::NewBestBlockImported(hash, number));
+	}
+}
+
+impl<B: BlockT> sp_consensus::SyncOracle for SyncingService<B> {
+	fn is_major_syncing(&self) -> bool {
+		self.is_major_syncing.load(Ordering::Relaxed)
+	}
+
+	fn is_offline(&self) -> bool {
+		self.num_connected.load(Ordering::Relaxed) == 0
+	}
+}
diff --git a/substrate/client/network/sync/src/service/mock.rs b/substrate/client/network/sync/src/service/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..885eb1f8da593e1315b0c9ac97842b7adb265810
--- /dev/null
+++ b/substrate/client/network/sync/src/service/mock.rs
@@ -0,0 +1,138 @@
+// 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 futures::channel::oneshot;
+use libp2p::{Multiaddr, PeerId};
+
+use sc_consensus::{BlockImportError, BlockImportStatus};
+use sc_network::{
+	config::MultiaddrWithPeerId,
+	request_responses::{IfDisconnected, RequestFailure},
+	types::ProtocolName,
+	NetworkNotification, NetworkPeers, NetworkRequest, NetworkSyncForkRequest,
+	NotificationSenderError, NotificationSenderT, ReputationChange,
+};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use std::collections::HashSet;
+
+mockall::mock! {
+	pub ChainSyncInterface<B: BlockT> {
+		pub fn justification_sync_link_request_justification(&self, hash: &B::Hash, number: NumberFor<B>);
+		pub fn justification_sync_link_clear_justification_requests(&self);
+	}
+
+	impl<B: BlockT + 'static> NetworkSyncForkRequest<B::Hash, NumberFor<B>>
+		for ChainSyncInterface<B>
+	{
+		fn set_sync_fork_request(&self, peers: Vec<PeerId>, hash: B::Hash, number: NumberFor<B>);
+	}
+
+	impl<B: BlockT> sc_consensus::Link<B> for ChainSyncInterface<B> {
+		fn blocks_processed(
+			&mut self,
+			imported: usize,
+			count: usize,
+			results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>,
+		);
+		fn justification_imported(
+			&mut self,
+			who: PeerId,
+			hash: &B::Hash,
+			number: NumberFor<B>,
+			success: bool,
+		);
+		fn request_justification(&mut self, hash: &B::Hash, number: NumberFor<B>);
+	}
+}
+
+impl<B: BlockT> sc_consensus::JustificationSyncLink<B> for MockChainSyncInterface<B> {
+	fn request_justification(&self, hash: &B::Hash, number: NumberFor<B>) {
+		self.justification_sync_link_request_justification(hash, number);
+	}
+
+	fn clear_justification_requests(&self) {
+		self.justification_sync_link_clear_justification_requests();
+	}
+}
+
+mockall::mock! {
+	pub NetworkServiceHandle {}
+}
+
+// Mocked `Network` for `ChainSync`-related tests
+mockall::mock! {
+	pub Network {}
+
+	impl NetworkPeers for Network {
+		fn set_authorized_peers(&self, peers: HashSet<PeerId>);
+		fn set_authorized_only(&self, reserved_only: bool);
+		fn add_known_address(&self, peer_id: PeerId, addr: Multiaddr);
+		fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange);
+		fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName);
+		fn accept_unreserved_peers(&self);
+		fn deny_unreserved_peers(&self);
+		fn add_reserved_peer(&self, peer: MultiaddrWithPeerId) -> Result<(), String>;
+		fn remove_reserved_peer(&self, peer_id: PeerId);
+		fn set_reserved_peers(
+			&self,
+			protocol: ProtocolName,
+			peers: HashSet<Multiaddr>,
+		) -> Result<(), String>;
+		fn add_peers_to_reserved_set(
+			&self,
+			protocol: ProtocolName,
+			peers: HashSet<Multiaddr>,
+		) -> Result<(), String>;
+		fn remove_peers_from_reserved_set(
+			&self,
+			protocol: ProtocolName,
+			peers: Vec<PeerId>
+		) -> Result<(), String>;
+		fn sync_num_connected(&self) -> usize;
+	}
+
+	#[async_trait::async_trait]
+	impl NetworkRequest for Network {
+		async fn request(
+			&self,
+			target: PeerId,
+			protocol: ProtocolName,
+			request: Vec<u8>,
+			connect: IfDisconnected,
+		) -> Result<Vec<u8>, RequestFailure>;
+		fn start_request(
+			&self,
+			target: PeerId,
+			protocol: ProtocolName,
+			request: Vec<u8>,
+			tx: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+			connect: IfDisconnected,
+		);
+	}
+
+	impl NetworkNotification for Network {
+		fn write_notification(&self, target: PeerId, protocol: ProtocolName, message: Vec<u8>);
+		fn notification_sender(
+			&self,
+			target: PeerId,
+			protocol: ProtocolName,
+		) -> Result<Box<dyn NotificationSenderT>, NotificationSenderError>;
+		fn set_notification_handshake(&self, protocol: ProtocolName, handshake: Vec<u8>);
+	}
+}
diff --git a/substrate/client/network/sync/src/service/mod.rs b/substrate/client/network/sync/src/service/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..18331d63ed29f76f383c928107b6753d7ca25d16
--- /dev/null
+++ b/substrate/client/network/sync/src/service/mod.rs
@@ -0,0 +1,23 @@
+// 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/>.
+
+//! `ChainSync`-related service code
+
+pub mod chain_sync;
+pub mod mock;
+pub mod network;
diff --git a/substrate/client/network/sync/src/service/network.rs b/substrate/client/network/sync/src/service/network.rs
new file mode 100644
index 0000000000000000000000000000000000000000..12a47d6a9b54415dcc6385840332f914bf77b7b4
--- /dev/null
+++ b/substrate/client/network/sync/src/service/network.rs
@@ -0,0 +1,182 @@
+// 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 futures::{channel::oneshot, StreamExt};
+use libp2p::PeerId;
+
+use sc_network::{
+	request_responses::{IfDisconnected, RequestFailure},
+	types::ProtocolName,
+	NetworkNotification, NetworkPeers, NetworkRequest, ReputationChange,
+};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+
+use std::sync::Arc;
+
+/// Network-related services required by `sc-network-sync`
+pub trait Network: NetworkPeers + NetworkRequest + NetworkNotification {}
+
+impl<T> Network for T where T: NetworkPeers + NetworkRequest + NetworkNotification {}
+
+/// Network service provider for `ChainSync`
+///
+/// It runs as an asynchronous task and listens to commands coming from `ChainSync` and
+/// calls the `NetworkService` on its behalf.
+pub struct NetworkServiceProvider {
+	rx: TracingUnboundedReceiver<ToServiceCommand>,
+}
+
+/// Commands that `ChainSync` wishes to send to `NetworkService`
+pub enum ToServiceCommand {
+	/// Call `NetworkPeers::disconnect_peer()`
+	DisconnectPeer(PeerId, ProtocolName),
+
+	/// Call `NetworkPeers::report_peer()`
+	ReportPeer(PeerId, ReputationChange),
+
+	/// Call `NetworkRequest::start_request()`
+	StartRequest(
+		PeerId,
+		ProtocolName,
+		Vec<u8>,
+		oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		IfDisconnected,
+	),
+
+	/// Call `NetworkNotification::write_notification()`
+	WriteNotification(PeerId, ProtocolName, Vec<u8>),
+
+	/// Call `NetworkNotification::set_notification_handshake()`
+	SetNotificationHandshake(ProtocolName, Vec<u8>),
+}
+
+/// Handle that is (temporarily) passed to `ChainSync` so it can
+/// communicate with `NetworkService` through `SyncingEngine`
+#[derive(Clone)]
+pub struct NetworkServiceHandle {
+	tx: TracingUnboundedSender<ToServiceCommand>,
+}
+
+impl NetworkServiceHandle {
+	/// Create new service handle
+	pub fn new(tx: TracingUnboundedSender<ToServiceCommand>) -> NetworkServiceHandle {
+		Self { tx }
+	}
+
+	/// Report peer
+	pub fn report_peer(&self, who: PeerId, cost_benefit: ReputationChange) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::ReportPeer(who, cost_benefit));
+	}
+
+	/// Disconnect peer
+	pub fn disconnect_peer(&self, who: PeerId, protocol: ProtocolName) {
+		let _ = self.tx.unbounded_send(ToServiceCommand::DisconnectPeer(who, protocol));
+	}
+
+	/// Send request to peer
+	pub fn start_request(
+		&self,
+		who: PeerId,
+		protocol: ProtocolName,
+		request: Vec<u8>,
+		tx: oneshot::Sender<Result<Vec<u8>, RequestFailure>>,
+		connect: IfDisconnected,
+	) {
+		let _ = self
+			.tx
+			.unbounded_send(ToServiceCommand::StartRequest(who, protocol, request, tx, connect));
+	}
+
+	/// Send notification to peer
+	pub fn write_notification(&self, who: PeerId, protocol: ProtocolName, message: Vec<u8>) {
+		let _ = self
+			.tx
+			.unbounded_send(ToServiceCommand::WriteNotification(who, protocol, message));
+	}
+
+	/// Set handshake for the notification protocol.
+	pub fn set_notification_handshake(&self, protocol: ProtocolName, handshake: Vec<u8>) {
+		let _ = self
+			.tx
+			.unbounded_send(ToServiceCommand::SetNotificationHandshake(protocol, handshake));
+	}
+}
+
+impl NetworkServiceProvider {
+	/// Create new `NetworkServiceProvider`
+	pub fn new() -> (Self, NetworkServiceHandle) {
+		let (tx, rx) = tracing_unbounded("mpsc_network_service_provider", 100_000);
+
+		(Self { rx }, NetworkServiceHandle::new(tx))
+	}
+
+	/// Run the `NetworkServiceProvider`
+	pub async fn run(mut self, service: Arc<dyn Network + Send + Sync>) {
+		while let Some(inner) = self.rx.next().await {
+			match inner {
+				ToServiceCommand::DisconnectPeer(peer, protocol_name) =>
+					service.disconnect_peer(peer, protocol_name),
+				ToServiceCommand::ReportPeer(peer, reputation_change) =>
+					service.report_peer(peer, reputation_change),
+				ToServiceCommand::StartRequest(peer, protocol, request, tx, connect) =>
+					service.start_request(peer, protocol, request, tx, connect),
+				ToServiceCommand::WriteNotification(peer, protocol, message) =>
+					service.write_notification(peer, protocol, message),
+				ToServiceCommand::SetNotificationHandshake(protocol, handshake) =>
+					service.set_notification_handshake(protocol, handshake),
+			}
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::service::mock::MockNetwork;
+
+	// typical pattern in `Protocol` code where peer is disconnected
+	// and then reported
+	#[tokio::test]
+	async fn disconnect_and_report_peer() {
+		let (provider, handle) = NetworkServiceProvider::new();
+
+		let peer = PeerId::random();
+		let proto = ProtocolName::from("test-protocol");
+		let proto_clone = proto.clone();
+		let change = sc_network::ReputationChange::new_fatal("test-change");
+
+		let mut mock_network = MockNetwork::new();
+		mock_network
+			.expect_disconnect_peer()
+			.withf(move |in_peer, in_proto| &peer == in_peer && &proto == in_proto)
+			.once()
+			.returning(|_, _| ());
+		mock_network
+			.expect_report_peer()
+			.withf(move |in_peer, in_change| &peer == in_peer && &change == in_change)
+			.once()
+			.returning(|_, _| ());
+
+		tokio::spawn(async move {
+			provider.run(Arc::new(mock_network)).await;
+		});
+
+		handle.disconnect_peer(peer, proto_clone);
+		handle.report_peer(peer, change);
+	}
+}
diff --git a/substrate/client/network/sync/src/state.rs b/substrate/client/network/sync/src/state.rs
new file mode 100644
index 0000000000000000000000000000000000000000..305f0ee6838a296b5e6f73902360069318232c88
--- /dev/null
+++ b/substrate/client/network/sync/src/state.rs
@@ -0,0 +1,267 @@
+// 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/>.
+
+//! State sync support.
+
+use crate::schema::v1::{StateEntry, StateRequest, StateResponse};
+use codec::{Decode, Encode};
+use log::debug;
+use sc_client_api::{CompactProof, ProofProvider};
+use sc_consensus::ImportedState;
+use sc_network_common::sync::StateDownloadProgress;
+use smallvec::SmallVec;
+use sp_core::storage::well_known_keys;
+use sp_runtime::{
+	traits::{Block as BlockT, Header, NumberFor},
+	Justifications,
+};
+use std::{collections::HashMap, sync::Arc};
+
+/// State sync state machine. Accumulates partial state data until it
+/// is ready to be imported.
+pub struct StateSync<B: BlockT, Client> {
+	target_block: B::Hash,
+	target_header: B::Header,
+	target_root: B::Hash,
+	target_body: Option<Vec<B::Extrinsic>>,
+	target_justifications: Option<Justifications>,
+	last_key: SmallVec<[Vec<u8>; 2]>,
+	state: HashMap<Vec<u8>, (Vec<(Vec<u8>, Vec<u8>)>, Vec<Vec<u8>>)>,
+	complete: bool,
+	client: Arc<Client>,
+	imported_bytes: u64,
+	skip_proof: bool,
+}
+
+/// Import state chunk result.
+pub enum ImportResult<B: BlockT> {
+	/// State is complete and ready for import.
+	Import(B::Hash, B::Header, ImportedState<B>, Option<Vec<B::Extrinsic>>, Option<Justifications>),
+	/// Continue downloading.
+	Continue,
+	/// Bad state chunk.
+	BadResponse,
+}
+
+impl<B, Client> StateSync<B, Client>
+where
+	B: BlockT,
+	Client: ProofProvider<B> + Send + Sync + 'static,
+{
+	///  Create a new instance.
+	pub fn new(
+		client: Arc<Client>,
+		target_header: B::Header,
+		target_body: Option<Vec<B::Extrinsic>>,
+		target_justifications: Option<Justifications>,
+		skip_proof: bool,
+	) -> Self {
+		Self {
+			client,
+			target_block: target_header.hash(),
+			target_root: *target_header.state_root(),
+			target_header,
+			target_body,
+			target_justifications,
+			last_key: SmallVec::default(),
+			state: HashMap::default(),
+			complete: false,
+			imported_bytes: 0,
+			skip_proof,
+		}
+	}
+
+	///  Validate and import a state response.
+	pub fn import(&mut self, response: StateResponse) -> ImportResult<B> {
+		if response.entries.is_empty() && response.proof.is_empty() {
+			debug!(target: "sync", "Bad state response");
+			return ImportResult::BadResponse
+		}
+		if !self.skip_proof && response.proof.is_empty() {
+			debug!(target: "sync", "Missing proof");
+			return ImportResult::BadResponse
+		}
+		let complete = if !self.skip_proof {
+			debug!(target: "sync", "Importing state from {} trie nodes", response.proof.len());
+			let proof_size = response.proof.len() as u64;
+			let proof = match CompactProof::decode(&mut response.proof.as_ref()) {
+				Ok(proof) => proof,
+				Err(e) => {
+					debug!(target: "sync", "Error decoding proof: {:?}", e);
+					return ImportResult::BadResponse
+				},
+			};
+			let (values, completed) = match self.client.verify_range_proof(
+				self.target_root,
+				proof,
+				self.last_key.as_slice(),
+			) {
+				Err(e) => {
+					debug!(
+						target: "sync",
+						"StateResponse failed proof verification: {}",
+						e,
+					);
+					return ImportResult::BadResponse
+				},
+				Ok(values) => values,
+			};
+			debug!(target: "sync", "Imported with {} keys", values.len());
+
+			let complete = completed == 0;
+			if !complete && !values.update_last_key(completed, &mut self.last_key) {
+				debug!(target: "sync", "Error updating key cursor, depth: {}", completed);
+			};
+
+			for values in values.0 {
+				let key_values = if values.state_root.is_empty() {
+					// Read child trie roots.
+					values
+						.key_values
+						.into_iter()
+						.filter(|key_value| {
+							if well_known_keys::is_child_storage_key(key_value.0.as_slice()) {
+								self.state
+									.entry(key_value.1.clone())
+									.or_default()
+									.1
+									.push(key_value.0.clone());
+								false
+							} else {
+								true
+							}
+						})
+						.collect()
+				} else {
+					values.key_values
+				};
+				let entry = self.state.entry(values.state_root).or_default();
+				if entry.0.len() > 0 && entry.1.len() > 1 {
+					// Already imported child_trie with same root.
+					// Warning this will not work with parallel download.
+				} else if entry.0.is_empty() {
+					for (key, _value) in key_values.iter() {
+						self.imported_bytes += key.len() as u64;
+					}
+
+					entry.0 = key_values;
+				} else {
+					for (key, value) in key_values {
+						self.imported_bytes += key.len() as u64;
+						entry.0.push((key, value))
+					}
+				}
+			}
+			self.imported_bytes += proof_size;
+			complete
+		} else {
+			let mut complete = true;
+			// if the trie is a child trie and one of its parent trie is empty,
+			// the parent cursor stays valid.
+			// Empty parent trie content only happens when all the response content
+			// is part of a single child trie.
+			if self.last_key.len() == 2 && response.entries[0].entries.is_empty() {
+				// Do not remove the parent trie position.
+				self.last_key.pop();
+			} else {
+				self.last_key.clear();
+			}
+			for state in response.entries {
+				debug!(
+					target: "sync",
+					"Importing state from {:?} to {:?}",
+					state.entries.last().map(|e| sp_core::hexdisplay::HexDisplay::from(&e.key)),
+					state.entries.first().map(|e| sp_core::hexdisplay::HexDisplay::from(&e.key)),
+				);
+
+				if !state.complete {
+					if let Some(e) = state.entries.last() {
+						self.last_key.push(e.key.clone());
+					}
+					complete = false;
+				}
+				let is_top = state.state_root.is_empty();
+				let entry = self.state.entry(state.state_root).or_default();
+				if entry.0.len() > 0 && entry.1.len() > 1 {
+					// Already imported child trie with same root.
+				} else {
+					let mut child_roots = Vec::new();
+					for StateEntry { key, value } in state.entries {
+						// Skip all child key root (will be recalculated on import).
+						if is_top && well_known_keys::is_child_storage_key(key.as_slice()) {
+							child_roots.push((value, key));
+						} else {
+							self.imported_bytes += key.len() as u64;
+							entry.0.push((key, value))
+						}
+					}
+					for (root, storage_key) in child_roots {
+						self.state.entry(root).or_default().1.push(storage_key);
+					}
+				}
+			}
+			complete
+		};
+		if complete {
+			self.complete = true;
+			ImportResult::Import(
+				self.target_block,
+				self.target_header.clone(),
+				ImportedState {
+					block: self.target_block,
+					state: std::mem::take(&mut self.state).into(),
+				},
+				self.target_body.clone(),
+				self.target_justifications.clone(),
+			)
+		} else {
+			ImportResult::Continue
+		}
+	}
+
+	/// Produce next state request.
+	pub fn next_request(&self) -> StateRequest {
+		StateRequest {
+			block: self.target_block.encode(),
+			start: self.last_key.clone().into_vec(),
+			no_proof: self.skip_proof,
+		}
+	}
+
+	/// Check if the state is complete.
+	pub fn is_complete(&self) -> bool {
+		self.complete
+	}
+
+	/// Returns target block number.
+	pub fn target_block_num(&self) -> NumberFor<B> {
+		*self.target_header.number()
+	}
+
+	/// Returns target block hash.
+	pub fn target(&self) -> B::Hash {
+		self.target_block
+	}
+
+	/// Returns state sync estimated progress.
+	pub fn progress(&self) -> StateDownloadProgress {
+		let cursor = *self.last_key.get(0).and_then(|last| last.get(0)).unwrap_or(&0u8);
+		let percent_done = cursor as u32 * 100 / 256;
+		StateDownloadProgress { percentage: percent_done, size: self.imported_bytes }
+	}
+}
diff --git a/substrate/client/network/sync/src/state_request_handler.rs b/substrate/client/network/sync/src/state_request_handler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ed14b889cbb54d18cc421e6f812b11334cbe87c3
--- /dev/null
+++ b/substrate/client/network/sync/src/state_request_handler.rs
@@ -0,0 +1,286 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Helper for handling (i.e. answering) state requests from a remote peer via the
+//! `crate::request_responses::RequestResponsesBehaviour`.
+
+use crate::schema::v1::{KeyValueStateEntry, StateEntry, StateRequest, StateResponse};
+
+use codec::{Decode, Encode};
+use futures::{channel::oneshot, stream::StreamExt};
+use libp2p::PeerId;
+use log::{debug, trace};
+use prost::Message;
+use schnellru::{ByLength, LruMap};
+
+use sc_client_api::{BlockBackend, ProofProvider};
+use sc_network::{
+	config::ProtocolId,
+	request_responses::{IncomingRequest, OutgoingResponse, ProtocolConfig},
+};
+use sp_runtime::traits::Block as BlockT;
+
+use std::{
+	hash::{Hash, Hasher},
+	sync::Arc,
+	time::Duration,
+};
+
+const LOG_TARGET: &str = "sync";
+const MAX_RESPONSE_BYTES: usize = 2 * 1024 * 1024; // Actual reponse may be bigger.
+const MAX_NUMBER_OF_SAME_REQUESTS_PER_PEER: usize = 2;
+
+mod rep {
+	use sc_network::ReputationChange as Rep;
+
+	/// Reputation change when a peer sent us the same request multiple times.
+	pub const SAME_REQUEST: Rep = Rep::new(i32::MIN, "Same state request multiple times");
+}
+
+/// Generates a [`ProtocolConfig`] for the state request protocol, refusing incoming requests.
+pub fn generate_protocol_config<Hash: AsRef<[u8]>>(
+	protocol_id: &ProtocolId,
+	genesis_hash: Hash,
+	fork_id: Option<&str>,
+) -> ProtocolConfig {
+	ProtocolConfig {
+		name: generate_protocol_name(genesis_hash, fork_id).into(),
+		fallback_names: std::iter::once(generate_legacy_protocol_name(protocol_id).into())
+			.collect(),
+		max_request_size: 1024 * 1024,
+		max_response_size: 16 * 1024 * 1024,
+		request_timeout: Duration::from_secs(40),
+		inbound_queue: None,
+	}
+}
+
+/// Generate the state protocol name from the genesis hash and fork id.
+fn generate_protocol_name<Hash: AsRef<[u8]>>(genesis_hash: Hash, fork_id: Option<&str>) -> String {
+	let genesis_hash = genesis_hash.as_ref();
+	if let Some(fork_id) = fork_id {
+		format!("/{}/{}/state/2", array_bytes::bytes2hex("", genesis_hash), fork_id)
+	} else {
+		format!("/{}/state/2", array_bytes::bytes2hex("", genesis_hash))
+	}
+}
+
+/// Generate the legacy state protocol name from chain specific protocol identifier.
+fn generate_legacy_protocol_name(protocol_id: &ProtocolId) -> String {
+	format!("/{}/state/2", protocol_id.as_ref())
+}
+
+/// The key of [`BlockRequestHandler::seen_requests`].
+#[derive(Eq, PartialEq, Clone)]
+struct SeenRequestsKey<B: BlockT> {
+	peer: PeerId,
+	block: B::Hash,
+	start: Vec<Vec<u8>>,
+}
+
+#[allow(clippy::derived_hash_with_manual_eq)]
+impl<B: BlockT> Hash for SeenRequestsKey<B> {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		self.peer.hash(state);
+		self.block.hash(state);
+		self.start.hash(state);
+	}
+}
+
+/// The value of [`StateRequestHandler::seen_requests`].
+enum SeenRequestsValue {
+	/// First time we have seen the request.
+	First,
+	/// We have fulfilled the request `n` times.
+	Fulfilled(usize),
+}
+
+/// Handler for incoming block requests from a remote peer.
+pub struct StateRequestHandler<B: BlockT, Client> {
+	client: Arc<Client>,
+	request_receiver: async_channel::Receiver<IncomingRequest>,
+	/// Maps from request to number of times we have seen this request.
+	///
+	/// This is used to check if a peer is spamming us with the same request.
+	seen_requests: LruMap<SeenRequestsKey<B>, SeenRequestsValue>,
+}
+
+impl<B, Client> StateRequestHandler<B, Client>
+where
+	B: BlockT,
+	Client: BlockBackend<B> + ProofProvider<B> + Send + Sync + 'static,
+{
+	/// Create a new [`StateRequestHandler`].
+	pub fn new(
+		protocol_id: &ProtocolId,
+		fork_id: Option<&str>,
+		client: Arc<Client>,
+		num_peer_hint: usize,
+	) -> (Self, ProtocolConfig) {
+		// Reserve enough request slots for one request per peer when we are at the maximum
+		// number of peers.
+		let capacity = std::cmp::max(num_peer_hint, 1);
+		let (tx, request_receiver) = async_channel::bounded(capacity);
+
+		let mut protocol_config = generate_protocol_config(
+			protocol_id,
+			client
+				.block_hash(0u32.into())
+				.ok()
+				.flatten()
+				.expect("Genesis block exists; qed"),
+			fork_id,
+		);
+		protocol_config.inbound_queue = Some(tx);
+
+		let capacity = ByLength::new(num_peer_hint.max(1) as u32 * 2);
+		let seen_requests = LruMap::new(capacity);
+
+		(Self { client, request_receiver, seen_requests }, protocol_config)
+	}
+
+	/// Run [`StateRequestHandler`].
+	pub async fn run(mut self) {
+		while let Some(request) = self.request_receiver.next().await {
+			let IncomingRequest { peer, payload, pending_response } = request;
+
+			match self.handle_request(payload, pending_response, &peer) {
+				Ok(()) => debug!(target: LOG_TARGET, "Handled block request from {}.", peer),
+				Err(e) => debug!(
+					target: LOG_TARGET,
+					"Failed to handle state request from {}: {}", peer, e,
+				),
+			}
+		}
+	}
+
+	fn handle_request(
+		&mut self,
+		payload: Vec<u8>,
+		pending_response: oneshot::Sender<OutgoingResponse>,
+		peer: &PeerId,
+	) -> Result<(), HandleRequestError> {
+		let request = StateRequest::decode(&payload[..])?;
+		let block: B::Hash = Decode::decode(&mut request.block.as_ref())?;
+
+		let key = SeenRequestsKey { peer: *peer, block, start: request.start.clone() };
+
+		let mut reputation_changes = Vec::new();
+
+		match self.seen_requests.get(&key) {
+			Some(SeenRequestsValue::First) => {},
+			Some(SeenRequestsValue::Fulfilled(ref mut requests)) => {
+				*requests = requests.saturating_add(1);
+
+				if *requests > MAX_NUMBER_OF_SAME_REQUESTS_PER_PEER {
+					reputation_changes.push(rep::SAME_REQUEST);
+				}
+			},
+			None => {
+				self.seen_requests.insert(key.clone(), SeenRequestsValue::First);
+			},
+		}
+
+		trace!(
+			target: LOG_TARGET,
+			"Handling state request from {}: Block {:?}, Starting at {:x?}, no_proof={}",
+			peer,
+			request.block,
+			&request.start,
+			request.no_proof,
+		);
+
+		let result = if reputation_changes.is_empty() {
+			let mut response = StateResponse::default();
+
+			if !request.no_proof {
+				let (proof, _count) = self.client.read_proof_collection(
+					block,
+					request.start.as_slice(),
+					MAX_RESPONSE_BYTES,
+				)?;
+				response.proof = proof.encode();
+			} else {
+				let entries = self.client.storage_collection(
+					block,
+					request.start.as_slice(),
+					MAX_RESPONSE_BYTES,
+				)?;
+				response.entries = entries
+					.into_iter()
+					.map(|(state, complete)| KeyValueStateEntry {
+						state_root: state.state_root,
+						entries: state
+							.key_values
+							.into_iter()
+							.map(|(key, value)| StateEntry { key, value })
+							.collect(),
+						complete,
+					})
+					.collect();
+			}
+
+			trace!(
+				target: LOG_TARGET,
+				"StateResponse contains {} keys, {}, proof nodes, from {:?} to {:?}",
+				response.entries.len(),
+				response.proof.len(),
+				response.entries.get(0).and_then(|top| top
+					.entries
+					.first()
+					.map(|e| sp_core::hexdisplay::HexDisplay::from(&e.key))),
+				response.entries.get(0).and_then(|top| top
+					.entries
+					.last()
+					.map(|e| sp_core::hexdisplay::HexDisplay::from(&e.key))),
+			);
+			if let Some(value) = self.seen_requests.get(&key) {
+				// If this is the first time we have processed this request, we need to change
+				// it to `Fulfilled`.
+				if let SeenRequestsValue::First = value {
+					*value = SeenRequestsValue::Fulfilled(1);
+				}
+			}
+
+			let mut data = Vec::with_capacity(response.encoded_len());
+			response.encode(&mut data)?;
+			Ok(data)
+		} else {
+			Err(())
+		};
+
+		pending_response
+			.send(OutgoingResponse { result, reputation_changes, sent_feedback: None })
+			.map_err(|_| HandleRequestError::SendResponse)
+	}
+}
+
+#[derive(Debug, thiserror::Error)]
+enum HandleRequestError {
+	#[error("Failed to decode request: {0}.")]
+	DecodeProto(#[from] prost::DecodeError),
+
+	#[error("Failed to encode response: {0}.")]
+	EncodeProto(#[from] prost::EncodeError),
+
+	#[error("Failed to decode block hash: {0}.")]
+	InvalidHash(#[from] codec::Error),
+
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+
+	#[error("Failed to send response.")]
+	SendResponse,
+}
diff --git a/substrate/client/network/sync/src/warp.rs b/substrate/client/network/sync/src/warp.rs
new file mode 100644
index 0000000000000000000000000000000000000000..912ad78dfdd0800db1233786cd2cd8ebed064394
--- /dev/null
+++ b/substrate/client/network/sync/src/warp.rs
@@ -0,0 +1,299 @@
+// 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/>.
+
+//! Warp sync support.
+
+use crate::{
+	oneshot,
+	schema::v1::{StateRequest, StateResponse},
+	state::{ImportResult, StateSync},
+};
+use futures::FutureExt;
+use log::error;
+use sc_client_api::ProofProvider;
+use sc_network_common::sync::{
+	message::{BlockAttributes, BlockData, BlockRequest, Direction, FromBlock},
+	warp::{
+		EncodedProof, VerificationResult, WarpProofRequest, WarpSyncParams, WarpSyncPhase,
+		WarpSyncProgress, WarpSyncProvider,
+	},
+};
+use sp_blockchain::HeaderBackend;
+use sp_consensus_grandpa::{AuthorityList, SetId};
+use sp_runtime::traits::{Block as BlockT, Header, NumberFor, Zero};
+use std::{sync::Arc, task::Poll};
+
+enum Phase<B: BlockT, Client> {
+	WarpProof {
+		set_id: SetId,
+		authorities: AuthorityList,
+		last_hash: B::Hash,
+		warp_sync_provider: Arc<dyn WarpSyncProvider<B>>,
+	},
+	PendingTargetBlock {
+		target_block: Option<oneshot::Receiver<B::Header>>,
+	},
+	TargetBlock(B::Header),
+	State(StateSync<B, Client>),
+}
+
+/// Import warp proof result.
+pub enum WarpProofImportResult {
+	/// Import was successful.
+	Success,
+	/// Bad proof.
+	BadResponse,
+}
+
+/// Import target block result.
+pub enum TargetBlockImportResult {
+	/// Import was successful.
+	Success,
+	/// Invalid block.
+	BadResponse,
+}
+
+/// Warp sync state machine. Accumulates warp proofs and state.
+pub struct WarpSync<B: BlockT, Client> {
+	phase: Phase<B, Client>,
+	client: Arc<Client>,
+	total_proof_bytes: u64,
+}
+
+impl<B, Client> WarpSync<B, Client>
+where
+	B: BlockT,
+	Client: HeaderBackend<B> + ProofProvider<B> + 'static,
+{
+	/// Create a new instance. When passing a warp sync provider we will be checking for proof and
+	/// authorities. Alternatively we can pass a target block when we want to skip downloading
+	/// proofs, in this case we will continue polling until the target block is known.
+	pub fn new(client: Arc<Client>, warp_sync_params: WarpSyncParams<B>) -> Self {
+		let last_hash = client.hash(Zero::zero()).unwrap().expect("Genesis header always exists");
+		match warp_sync_params {
+			WarpSyncParams::WithProvider(warp_sync_provider) => {
+				let phase = Phase::WarpProof {
+					set_id: 0,
+					authorities: warp_sync_provider.current_authorities(),
+					last_hash,
+					warp_sync_provider: warp_sync_provider.clone(),
+				};
+				Self { client, phase, total_proof_bytes: 0 }
+			},
+			WarpSyncParams::WaitForTarget(block) => Self {
+				client,
+				phase: Phase::PendingTargetBlock { target_block: Some(block) },
+				total_proof_bytes: 0,
+			},
+		}
+	}
+
+	/// Poll to make progress.
+	///
+	/// This only makes progress when `phase = Phase::PendingTargetBlock` and the pending block was
+	/// sent.
+	pub fn poll(&mut self, cx: &mut std::task::Context) {
+		let new_phase = if let Phase::PendingTargetBlock { target_block: Some(target_block) } =
+			&mut self.phase
+		{
+			match target_block.poll_unpin(cx) {
+				Poll::Ready(Ok(target)) => Phase::TargetBlock(target),
+				Poll::Ready(Err(e)) => {
+					error!(target: "sync", "Failed to get target block. Error: {:?}",e);
+					Phase::PendingTargetBlock { target_block: None }
+				},
+				_ => return,
+			}
+		} else {
+			return
+		};
+
+		self.phase = new_phase;
+	}
+
+	///  Validate and import a state response.
+	pub fn import_state(&mut self, response: StateResponse) -> ImportResult<B> {
+		match &mut self.phase {
+			Phase::WarpProof { .. } | Phase::TargetBlock(_) | Phase::PendingTargetBlock { .. } => {
+				log::debug!(target: "sync", "Unexpected state response");
+				ImportResult::BadResponse
+			},
+			Phase::State(sync) => sync.import(response),
+		}
+	}
+
+	///  Validate and import a warp proof response.
+	pub fn import_warp_proof(&mut self, response: EncodedProof) -> WarpProofImportResult {
+		match &mut self.phase {
+			Phase::State(_) | Phase::TargetBlock(_) | Phase::PendingTargetBlock { .. } => {
+				log::debug!(target: "sync", "Unexpected warp proof response");
+				WarpProofImportResult::BadResponse
+			},
+			Phase::WarpProof { set_id, authorities, last_hash, warp_sync_provider } =>
+				match warp_sync_provider.verify(&response, *set_id, authorities.clone()) {
+					Err(e) => {
+						log::debug!(target: "sync", "Bad warp proof response: {}", e);
+						WarpProofImportResult::BadResponse
+					},
+					Ok(VerificationResult::Partial(new_set_id, new_authorities, new_last_hash)) => {
+						log::debug!(target: "sync", "Verified partial proof, set_id={:?}", new_set_id);
+						*set_id = new_set_id;
+						*authorities = new_authorities;
+						*last_hash = new_last_hash;
+						self.total_proof_bytes += response.0.len() as u64;
+						WarpProofImportResult::Success
+					},
+					Ok(VerificationResult::Complete(new_set_id, _, header)) => {
+						log::debug!(target: "sync", "Verified complete proof, set_id={:?}", new_set_id);
+						self.total_proof_bytes += response.0.len() as u64;
+						self.phase = Phase::TargetBlock(header);
+						WarpProofImportResult::Success
+					},
+				},
+		}
+	}
+
+	/// Import the target block body.
+	pub fn import_target_block(&mut self, block: BlockData<B>) -> TargetBlockImportResult {
+		match &mut self.phase {
+			Phase::WarpProof { .. } | Phase::State(_) | Phase::PendingTargetBlock { .. } => {
+				log::debug!(target: "sync", "Unexpected target block response");
+				TargetBlockImportResult::BadResponse
+			},
+			Phase::TargetBlock(header) =>
+				if let Some(block_header) = &block.header {
+					if block_header == header {
+						if block.body.is_some() {
+							let state_sync = StateSync::new(
+								self.client.clone(),
+								header.clone(),
+								block.body,
+								block.justifications,
+								false,
+							);
+							self.phase = Phase::State(state_sync);
+							TargetBlockImportResult::Success
+						} else {
+							log::debug!(
+								target: "sync",
+								"Importing target block failed: missing body.",
+							);
+							TargetBlockImportResult::BadResponse
+						}
+					} else {
+						log::debug!(
+							target: "sync",
+							"Importing target block failed: different header.",
+						);
+						TargetBlockImportResult::BadResponse
+					}
+				} else {
+					log::debug!(target: "sync", "Importing target block failed: missing header.");
+					TargetBlockImportResult::BadResponse
+				},
+		}
+	}
+
+	/// Produce next state request.
+	pub fn next_state_request(&self) -> Option<StateRequest> {
+		match &self.phase {
+			Phase::WarpProof { .. } | Phase::TargetBlock(_) | Phase::PendingTargetBlock { .. } =>
+				None,
+			Phase::State(sync) => Some(sync.next_request()),
+		}
+	}
+
+	/// Produce next warp proof request.
+	pub fn next_warp_proof_request(&self) -> Option<WarpProofRequest<B>> {
+		match &self.phase {
+			Phase::WarpProof { last_hash, .. } => Some(WarpProofRequest { begin: *last_hash }),
+			Phase::TargetBlock(_) | Phase::State(_) | Phase::PendingTargetBlock { .. } => None,
+		}
+	}
+
+	/// Produce next target block request.
+	pub fn next_target_block_request(&self) -> Option<(NumberFor<B>, BlockRequest<B>)> {
+		match &self.phase {
+			Phase::WarpProof { .. } | Phase::State(_) | Phase::PendingTargetBlock { .. } => None,
+			Phase::TargetBlock(header) => {
+				let request = BlockRequest::<B> {
+					id: 0,
+					fields: BlockAttributes::HEADER |
+						BlockAttributes::BODY | BlockAttributes::JUSTIFICATION,
+					from: FromBlock::Hash(header.hash()),
+					direction: Direction::Ascending,
+					max: Some(1),
+				};
+				Some((*header.number(), request))
+			},
+		}
+	}
+
+	/// Return target block hash if it is known.
+	pub fn target_block_hash(&self) -> Option<B::Hash> {
+		match &self.phase {
+			Phase::WarpProof { .. } | Phase::TargetBlock(_) | Phase::PendingTargetBlock { .. } =>
+				None,
+			Phase::State(s) => Some(s.target()),
+		}
+	}
+
+	/// Return target block number if it is known.
+	pub fn target_block_number(&self) -> Option<NumberFor<B>> {
+		match &self.phase {
+			Phase::WarpProof { .. } | Phase::PendingTargetBlock { .. } => None,
+			Phase::TargetBlock(header) => Some(*header.number()),
+			Phase::State(s) => Some(s.target_block_num()),
+		}
+	}
+
+	/// Check if the state is complete.
+	pub fn is_complete(&self) -> bool {
+		match &self.phase {
+			Phase::WarpProof { .. } | Phase::TargetBlock(_) | Phase::PendingTargetBlock { .. } =>
+				false,
+			Phase::State(sync) => sync.is_complete(),
+		}
+	}
+
+	/// Returns state sync estimated progress (percentage, bytes)
+	pub fn progress(&self) -> WarpSyncProgress<B> {
+		match &self.phase {
+			Phase::WarpProof { .. } => WarpSyncProgress {
+				phase: WarpSyncPhase::DownloadingWarpProofs,
+				total_bytes: self.total_proof_bytes,
+			},
+			Phase::TargetBlock(_) => WarpSyncProgress {
+				phase: WarpSyncPhase::DownloadingTargetBlock,
+				total_bytes: self.total_proof_bytes,
+			},
+			Phase::PendingTargetBlock { .. } => WarpSyncProgress {
+				phase: WarpSyncPhase::AwaitingTargetBlock,
+				total_bytes: self.total_proof_bytes,
+			},
+			Phase::State(sync) => WarpSyncProgress {
+				phase: if self.is_complete() {
+					WarpSyncPhase::ImportingState
+				} else {
+					WarpSyncPhase::DownloadingState
+				},
+				total_bytes: self.total_proof_bytes + sync.progress().size,
+			},
+		}
+	}
+}
diff --git a/substrate/client/network/sync/src/warp_request_handler.rs b/substrate/client/network/sync/src/warp_request_handler.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a49a65af51d0ba363502194066f60afc6232cee5
--- /dev/null
+++ b/substrate/client/network/sync/src/warp_request_handler.rs
@@ -0,0 +1,154 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Helper for handling (i.e. answering) grandpa warp sync requests from a remote peer.
+
+use codec::Decode;
+use futures::{channel::oneshot, stream::StreamExt};
+use log::debug;
+
+use sc_network::{
+	config::ProtocolId,
+	request_responses::{
+		IncomingRequest, OutgoingResponse, ProtocolConfig as RequestResponseConfig,
+	},
+};
+use sc_network_common::sync::warp::{EncodedProof, WarpProofRequest, WarpSyncProvider};
+use sp_runtime::traits::Block as BlockT;
+
+use std::{sync::Arc, time::Duration};
+
+const MAX_RESPONSE_SIZE: u64 = 16 * 1024 * 1024;
+
+/// Incoming warp requests bounded queue size.
+const MAX_WARP_REQUEST_QUEUE: usize = 20;
+
+/// Generates a [`RequestResponseConfig`] for the grandpa warp sync request protocol, refusing
+/// incoming requests.
+pub fn generate_request_response_config<Hash: AsRef<[u8]>>(
+	protocol_id: ProtocolId,
+	genesis_hash: Hash,
+	fork_id: Option<&str>,
+) -> RequestResponseConfig {
+	RequestResponseConfig {
+		name: generate_protocol_name(genesis_hash, fork_id).into(),
+		fallback_names: std::iter::once(generate_legacy_protocol_name(protocol_id).into())
+			.collect(),
+		max_request_size: 32,
+		max_response_size: MAX_RESPONSE_SIZE,
+		request_timeout: Duration::from_secs(10),
+		inbound_queue: None,
+	}
+}
+
+/// Generate the grandpa warp sync protocol name from the genesi hash and fork id.
+fn generate_protocol_name<Hash: AsRef<[u8]>>(genesis_hash: Hash, fork_id: Option<&str>) -> String {
+	let genesis_hash = genesis_hash.as_ref();
+	if let Some(fork_id) = fork_id {
+		format!("/{}/{}/sync/warp", array_bytes::bytes2hex("", genesis_hash), fork_id)
+	} else {
+		format!("/{}/sync/warp", array_bytes::bytes2hex("", genesis_hash))
+	}
+}
+
+/// Generate the legacy grandpa warp sync protocol name from chain specific protocol identifier.
+fn generate_legacy_protocol_name(protocol_id: ProtocolId) -> String {
+	format!("/{}/sync/warp", protocol_id.as_ref())
+}
+
+/// Handler for incoming grandpa warp sync requests from a remote peer.
+pub struct RequestHandler<TBlock: BlockT> {
+	backend: Arc<dyn WarpSyncProvider<TBlock>>,
+	request_receiver: async_channel::Receiver<IncomingRequest>,
+}
+
+impl<TBlock: BlockT> RequestHandler<TBlock> {
+	/// Create a new [`RequestHandler`].
+	pub fn new<Hash: AsRef<[u8]>>(
+		protocol_id: ProtocolId,
+		genesis_hash: Hash,
+		fork_id: Option<&str>,
+		backend: Arc<dyn WarpSyncProvider<TBlock>>,
+	) -> (Self, RequestResponseConfig) {
+		let (tx, request_receiver) = async_channel::bounded(MAX_WARP_REQUEST_QUEUE);
+
+		let mut request_response_config =
+			generate_request_response_config(protocol_id, genesis_hash, fork_id);
+		request_response_config.inbound_queue = Some(tx);
+
+		(Self { backend, request_receiver }, request_response_config)
+	}
+
+	fn handle_request(
+		&self,
+		payload: Vec<u8>,
+		pending_response: oneshot::Sender<OutgoingResponse>,
+	) -> Result<(), HandleRequestError> {
+		let request = WarpProofRequest::<TBlock>::decode(&mut &payload[..])?;
+
+		let EncodedProof(proof) = self
+			.backend
+			.generate(request.begin)
+			.map_err(HandleRequestError::InvalidRequest)?;
+
+		pending_response
+			.send(OutgoingResponse {
+				result: Ok(proof),
+				reputation_changes: Vec::new(),
+				sent_feedback: None,
+			})
+			.map_err(|_| HandleRequestError::SendResponse)
+	}
+
+	/// Run [`RequestHandler`].
+	pub async fn run(mut self) {
+		while let Some(request) = self.request_receiver.next().await {
+			let IncomingRequest { peer, payload, pending_response } = request;
+
+			match self.handle_request(payload, pending_response) {
+				Ok(()) => {
+					debug!(target: "sync", "Handled grandpa warp sync request from {}.", peer)
+				},
+				Err(e) => debug!(
+					target: "sync",
+					"Failed to handle grandpa warp sync request from {}: {}",
+					peer, e,
+				),
+			}
+		}
+	}
+}
+
+#[derive(Debug, thiserror::Error)]
+enum HandleRequestError {
+	#[error("Failed to decode request: {0}.")]
+	DecodeProto(#[from] prost::DecodeError),
+
+	#[error("Failed to encode response: {0}.")]
+	EncodeProto(#[from] prost::EncodeError),
+
+	#[error("Failed to decode block hash: {0}.")]
+	DecodeScale(#[from] codec::Error),
+
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+
+	#[error("Invalid request {0}.")]
+	InvalidRequest(#[from] Box<dyn std::error::Error + Send + Sync>),
+
+	#[error("Failed to send response.")]
+	SendResponse,
+}
diff --git a/substrate/client/network/test/Cargo.toml b/substrate/client/network/test/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ddd218051c484edef804bd0437398ecc07ad1b3a
--- /dev/null
+++ b/substrate/client/network/test/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+description = "Integration tests for Substrate network protocol"
+name = "sc-network-test"
+version = "0.8.0"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+tokio = "1.22.0"
+async-trait = "0.1.57"
+futures = "0.3.21"
+futures-timer = "3.0.1"
+libp2p = "0.51.3"
+log = "0.4.17"
+parking_lot = "0.12.1"
+rand = "0.8.5"
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
+sc-network = { version = "0.10.0-dev", path = "../" }
+sc-network-common = { version = "0.10.0-dev", path = "../common" }
+sc-utils = { version = "4.0.0-dev", path = "../../utils" }
+sc-network-light = { version = "0.10.0-dev", path = "../light" }
+sc-network-sync = { version = "0.10.0-dev", path = "../sync" }
+sc-service = { version = "0.10.0-dev", default-features = false, features = ["test-helpers"], path = "../../service" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+substrate-test-runtime = { version = "2.0.0", path = "../../../test-utils/runtime" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/client/network/test/src/block_import.rs b/substrate/client/network/test/src/block_import.rs
new file mode 100644
index 0000000000000000000000000000000000000000..25e3b9bee87f1dc472f5af68d1dc0da393fff90b
--- /dev/null
+++ b/substrate/client/network/test/src/block_import.rs
@@ -0,0 +1,128 @@
+// 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/>.
+
+//! Testing block import logic.
+
+use super::*;
+use futures::executor::block_on;
+use sc_block_builder::BlockBuilderProvider;
+use sc_consensus::{
+	import_single_block, BasicQueue, BlockImportError, BlockImportStatus, ImportedAux,
+	IncomingBlock,
+};
+use sp_consensus::BlockOrigin;
+use substrate_test_runtime_client::{
+	self,
+	prelude::*,
+	runtime::{Block, Hash},
+};
+
+fn prepare_good_block() -> (TestClient, Hash, u64, PeerId, IncomingBlock<Block>) {
+	let mut client = substrate_test_runtime_client::new();
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::File, block)).unwrap();
+
+	let (hash, number) = (client.block_hash(1).unwrap().unwrap(), 1);
+	let header = client.header(hash).unwrap();
+	let justifications = client.justifications(hash).unwrap();
+	let peer_id = PeerId::random();
+	(
+		client,
+		hash,
+		number,
+		peer_id,
+		IncomingBlock {
+			hash,
+			header,
+			body: Some(Vec::new()),
+			indexed_body: None,
+			justifications,
+			origin: Some(peer_id),
+			allow_missing_state: false,
+			import_existing: false,
+			state: None,
+			skip_execution: false,
+		},
+	)
+}
+
+#[test]
+fn import_single_good_block_works() {
+	let (_, _hash, number, peer_id, block) = prepare_good_block();
+
+	let mut expected_aux = ImportedAux::default();
+	expected_aux.is_new_best = true;
+
+	match block_on(import_single_block(
+		&mut substrate_test_runtime_client::new(),
+		BlockOrigin::File,
+		block,
+		&mut PassThroughVerifier::new(true),
+	)) {
+		Ok(BlockImportStatus::ImportedUnknown(ref num, ref aux, ref org))
+			if *num == number && *aux == expected_aux && *org == Some(peer_id) => {},
+		r @ _ => panic!("{:?}", r),
+	}
+}
+
+#[test]
+fn import_single_good_known_block_is_ignored() {
+	let (mut client, _hash, number, _, block) = prepare_good_block();
+	match block_on(import_single_block(
+		&mut client,
+		BlockOrigin::File,
+		block,
+		&mut PassThroughVerifier::new(true),
+	)) {
+		Ok(BlockImportStatus::ImportedKnown(ref n, _)) if *n == number => {},
+		_ => panic!(),
+	}
+}
+
+#[test]
+fn import_single_good_block_without_header_fails() {
+	let (_, _, _, peer_id, mut block) = prepare_good_block();
+	block.header = None;
+	match block_on(import_single_block(
+		&mut substrate_test_runtime_client::new(),
+		BlockOrigin::File,
+		block,
+		&mut PassThroughVerifier::new(true),
+	)) {
+		Err(BlockImportError::IncompleteHeader(ref org)) if *org == Some(peer_id) => {},
+		_ => panic!(),
+	}
+}
+
+#[test]
+fn async_import_queue_drops() {
+	let executor = sp_core::testing::TaskExecutor::new();
+	// Perform this test multiple times since it exhibits non-deterministic behavior.
+	for _ in 0..100 {
+		let verifier = PassThroughVerifier::new(true);
+
+		let queue = BasicQueue::new(
+			verifier,
+			Box::new(substrate_test_runtime_client::new()),
+			None,
+			&executor,
+			None,
+		);
+		drop(queue);
+	}
+}
diff --git a/substrate/client/network/test/src/fuzz.rs b/substrate/client/network/test/src/fuzz.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2e288accd80bc4f43214db8d4d7fc74611b82a2e
--- /dev/null
+++ b/substrate/client/network/test/src/fuzz.rs
@@ -0,0 +1,418 @@
+// 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/>.
+
+//! Fuzz test emulates network events and peer connection handling by `ProtocolController`
+//! and `PeerStore` to discover possible inconsistencies in peer management.
+
+use futures::prelude::*;
+use libp2p::PeerId;
+use rand::{
+	distributions::{Distribution, Uniform, WeightedIndex},
+	seq::IteratorRandom,
+};
+use sc_network::{
+	peer_store::{PeerStore, PeerStoreProvider},
+	protocol_controller::{IncomingIndex, Message, ProtoSetConfig, ProtocolController, SetId},
+	ReputationChange,
+};
+use sc_utils::mpsc::tracing_unbounded;
+use std::collections::{HashMap, HashSet};
+
+/// Peer events as observed by `Notifications` / fuzz test.
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+enum Event {
+	/// Either API requested to disconnect from the peer, or the peer dropped.
+	Disconnected,
+	/// Incoming request.
+	Incoming,
+	/// Answer from PSM: accept.
+	PsmAccept,
+	/// Answer from PSM: reject.
+	PsmReject,
+	/// Command from PSM: connect.
+	PsmConnect,
+	/// Command from PSM: drop connection.
+	PsmDrop,
+}
+
+/// Simplified peer state as thought by `Notifications` / fuzz test.
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+enum State {
+	/// Peer is not connected.
+	Disconnected,
+	/// We have an inbound connection, but have not decided yet whether to accept it.
+	Incoming(IncomingIndex),
+	/// Peer is connected via an inbound connection.
+	Inbound,
+	/// Peer is connected via an outbound connection.
+	Outbound,
+}
+
+/// Bare simplified state without incoming index.
+#[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
+enum BareState {
+	/// Peer is not connected.
+	Disconnected,
+	/// We have an inbound connection, but have not decided yet whether to accept it.
+	Incoming,
+	/// Peer is connected via an inbound connection.
+	Inbound,
+	/// Peer is connected via an outbound connection.
+	Outbound,
+}
+
+fn discard_incoming_index(state: State) -> BareState {
+	match state {
+		State::Disconnected => BareState::Disconnected,
+		State::Incoming(_) => BareState::Incoming,
+		State::Inbound => BareState::Inbound,
+		State::Outbound => BareState::Outbound,
+	}
+}
+
+#[tokio::test]
+async fn run() {
+	sp_tracing::try_init_simple();
+
+	for _ in 0..50 {
+		test_once().await;
+	}
+}
+
+async fn test_once() {
+	// Allowed events that can be received in a specific state.
+	let allowed_events: HashMap<BareState, HashSet<Event>> = [
+		(
+			BareState::Disconnected,
+			[Event::Incoming, Event::PsmConnect, Event::PsmDrop /* must be ignored */]
+				.into_iter()
+				.collect::<HashSet<_>>(),
+		),
+		(
+			BareState::Incoming,
+			[Event::PsmAccept, Event::PsmReject].into_iter().collect::<HashSet<_>>(),
+		),
+		(
+			BareState::Inbound,
+			[Event::Disconnected, Event::PsmDrop, Event::PsmConnect /* must be ignored */]
+				.into_iter()
+				.collect::<HashSet<_>>(),
+		),
+		(
+			BareState::Outbound,
+			[Event::Disconnected, Event::PsmDrop, Event::PsmConnect /* must be ignored */]
+				.into_iter()
+				.collect::<HashSet<_>>(),
+		),
+	]
+	.into_iter()
+	.collect();
+
+	// PRNG to use.
+	let mut rng = rand::thread_rng();
+
+	// Nodes that the peerset knows about.
+	let mut known_nodes = HashMap::<PeerId, State>::new();
+	// Nodes that we have reserved. Always a subset of `known_nodes`.
+	let mut reserved_nodes = HashSet::<PeerId>::new();
+
+	// Bootnodes for `PeerStore` initialization.
+	let bootnodes = (0..Uniform::new_inclusive(0, 4).sample(&mut rng))
+		.map(|_| {
+			let id = PeerId::random();
+			known_nodes.insert(id, State::Disconnected);
+			id
+		})
+		.collect();
+
+	let peer_store = PeerStore::new(bootnodes);
+	let mut peer_store_handle = peer_store.handle();
+
+	let (to_notifications, mut from_controller) =
+		tracing_unbounded("test_to_notifications", 10_000);
+	let (protocol_handle, protocol_controller) = ProtocolController::new(
+		SetId::from(0),
+		ProtoSetConfig {
+			reserved_nodes: {
+				(0..Uniform::new_inclusive(0, 2).sample(&mut rng))
+					.map(|_| {
+						let id = PeerId::random();
+						known_nodes.insert(id, State::Disconnected);
+						reserved_nodes.insert(id);
+						id
+					})
+					.collect()
+			},
+			in_peers: Uniform::new_inclusive(0, 25).sample(&mut rng),
+			out_peers: Uniform::new_inclusive(0, 25).sample(&mut rng),
+			reserved_only: Uniform::new_inclusive(0, 10).sample(&mut rng) == 0,
+		},
+		to_notifications,
+		Box::new(peer_store_handle.clone()),
+	);
+
+	tokio::spawn(peer_store.run());
+	tokio::spawn(protocol_controller.run());
+
+	// List of nodes the user of `peerset` assumes it's connected to. Always a subset of
+	// `known_nodes`.
+	let mut connected_nodes = HashSet::<PeerId>::new();
+	// List of nodes the user of `peerset` called `incoming` with and that haven't been
+	// accepted or rejected yet.
+	let mut incoming_nodes = HashMap::<IncomingIndex, PeerId>::new();
+	// Next id for incoming connections.
+	let mut next_incoming_id = IncomingIndex(0);
+
+	// The loop below is effectively synchronous, so for `PeerStore` & `ProtocolController`
+	// runners, spawned above, to advance, we use `spawn_blocking`.
+	let _ = tokio::task::spawn_blocking(move || {
+		// PRNG to use in `spawn_blocking` context.
+		let mut rng = rand::thread_rng();
+
+		// Perform a certain number of actions while checking that the state is consistent. If we
+		// reach the end of the loop, the run has succeeded.
+		// Note that with the ACKing and event postponing mechanism in `ProtocolController`
+		// the test time grows quadratically with the number of iterations below.
+		for _ in 0..2500 {
+			// Peer we are working with.
+			let mut current_peer = None;
+			// Current event for state transition validation.
+			let mut current_event = None;
+			// Last peer state for allowed event validation.
+			let mut last_state = None;
+
+			// Each of these weights corresponds to an action that we may perform.
+			let action_weights = [150, 90, 90, 30, 30, 1, 1, 4, 4];
+
+			match WeightedIndex::new(&action_weights).unwrap().sample(&mut rng) {
+				// If we generate 0, try to grab the next message from `ProtocolController`.
+				0 => match from_controller.next().now_or_never() {
+					Some(Some(Message::Connect { peer_id, .. })) => {
+						log::info!("PSM: connecting to peer {}", peer_id);
+
+						let state = known_nodes.get_mut(&peer_id).unwrap();
+						if matches!(*state, State::Incoming(_)) {
+							log::info!(
+								"Awaiting incoming response, ignoring obsolete Connect from PSM for peer {}",
+								peer_id,
+							);
+							continue
+						}
+
+						last_state = Some(*state);
+
+						if *state != State::Inbound {
+							*state = State::Outbound;
+						}
+
+						if !connected_nodes.insert(peer_id) {
+							log::info!("Request to connect to an already connected node {peer_id}");
+						}
+
+						current_peer = Some(peer_id);
+						current_event = Some(Event::PsmConnect);
+					},
+					Some(Some(Message::Drop { peer_id, .. })) => {
+						log::info!("PSM: dropping peer {}", peer_id);
+
+						let state = known_nodes.get_mut(&peer_id).unwrap();
+						if matches!(*state, State::Incoming(_)) {
+							log::info!(
+								"Awaiting incoming response, ignoring obsolete Drop from PSM for peer {}",
+								peer_id,
+							);
+							continue
+						}
+
+						last_state = Some(*state);
+						*state = State::Disconnected;
+
+						if !connected_nodes.remove(&peer_id) {
+							log::info!("Ignoring attempt to drop a disconnected peer {}", peer_id);
+						}
+
+						current_peer = Some(peer_id);
+						current_event = Some(Event::PsmDrop);
+					},
+					Some(Some(Message::Accept(n))) => {
+						log::info!("PSM: accepting index {}", n.0);
+
+						let peer_id = incoming_nodes.remove(&n).unwrap();
+
+						let state = known_nodes.get_mut(&peer_id).unwrap();
+						match *state {
+							State::Incoming(incoming_index) =>
+								if n.0 < incoming_index.0 {
+									log::info!(
+										"Ignoring obsolete Accept for {:?} while awaiting {:?} for peer {}",
+										n, incoming_index, peer_id,
+									);
+									continue
+								} else if n.0 > incoming_index.0 {
+									panic!(
+										"Received {:?} while awaiting {:?} for peer {}",
+										n, incoming_index, peer_id,
+									);
+								},
+							_ => {},
+						}
+
+						last_state = Some(*state);
+						*state = State::Inbound;
+
+						assert!(connected_nodes.insert(peer_id));
+
+						current_peer = Some(peer_id);
+						current_event = Some(Event::PsmAccept);
+					},
+					Some(Some(Message::Reject(n))) => {
+						log::info!("PSM: rejecting index {}", n.0);
+
+						let peer_id = incoming_nodes.remove(&n).unwrap();
+
+						let state = known_nodes.get_mut(&peer_id).unwrap();
+						match *state {
+							State::Incoming(incoming_index) =>
+								if n.0 < incoming_index.0 {
+									log::info!(
+										"Ignoring obsolete Reject for {:?} while awaiting {:?} for peer {}",
+										n, incoming_index, peer_id,
+									);
+									continue
+								} else if n.0 > incoming_index.0 {
+									panic!(
+										"Received {:?} while awaiting {:?} for peer {}",
+										n, incoming_index, peer_id,
+									);
+								},
+							_ => {},
+						}
+
+						last_state = Some(*state);
+						*state = State::Disconnected;
+
+						assert!(!connected_nodes.contains(&peer_id));
+
+						current_peer = Some(peer_id);
+						current_event = Some(Event::PsmReject);
+					},
+					Some(None) => panic!(),
+					None => {},
+				},
+
+				// If we generate 1, discover a new node.
+				1 => {
+					let new_id = PeerId::random();
+					known_nodes.insert(new_id, State::Disconnected);
+					peer_store_handle.add_known_peer(new_id);
+				},
+
+				// If we generate 2, adjust a random reputation.
+				2 =>
+					if let Some(id) = known_nodes.keys().choose(&mut rng) {
+						let val = Uniform::new_inclusive(i32::MIN, i32::MAX).sample(&mut rng);
+						peer_store_handle.report_peer(*id, ReputationChange::new(val, ""));
+					},
+
+				// If we generate 3, disconnect from a random node.
+				3 =>
+					if let Some(id) = connected_nodes.iter().choose(&mut rng).cloned() {
+						log::info!("Disconnected from {}", id);
+						connected_nodes.remove(&id);
+
+						let state = known_nodes.get_mut(&id).unwrap();
+						last_state = Some(*state);
+						*state = State::Disconnected;
+
+						protocol_handle.dropped(id);
+
+						current_peer = Some(id);
+						current_event = Some(Event::Disconnected);
+					},
+
+				// If we generate 4, connect to a random node.
+				4 => {
+					if let Some(id) = known_nodes
+						.keys()
+						.filter(|n| {
+							incoming_nodes.values().all(|m| m != *n) &&
+								!connected_nodes.contains(*n)
+						})
+						.choose(&mut rng)
+						.cloned()
+					{
+						log::info!("Incoming connection from {}, index {}", id, next_incoming_id.0);
+						protocol_handle.incoming_connection(id, next_incoming_id);
+						incoming_nodes.insert(next_incoming_id, id);
+
+						let state = known_nodes.get_mut(&id).unwrap();
+						last_state = Some(*state);
+						*state = State::Incoming(next_incoming_id);
+
+						next_incoming_id.0 += 1;
+
+						current_peer = Some(id);
+						current_event = Some(Event::Incoming);
+					}
+				},
+
+				// 5 and 6 are the reserved-only mode.
+				5 => {
+					log::info!("Set reserved only");
+					protocol_handle.set_reserved_only(true);
+				},
+				6 => {
+					log::info!("Unset reserved only");
+					protocol_handle.set_reserved_only(false);
+				},
+
+				// 7 and 8 are about switching a random node in or out of reserved mode.
+				7 => {
+					if let Some(id) =
+						known_nodes.keys().filter(|n| !reserved_nodes.contains(*n)).choose(&mut rng)
+					{
+						log::info!("Add reserved: {}", id);
+						protocol_handle.add_reserved_peer(*id);
+						reserved_nodes.insert(*id);
+					}
+				},
+				8 =>
+					if let Some(id) = reserved_nodes.iter().choose(&mut rng).cloned() {
+						log::info!("Remove reserved: {}", id);
+						reserved_nodes.remove(&id);
+						protocol_handle.remove_reserved_peer(id);
+					},
+
+				_ => unreachable!(),
+			}
+
+			// Validate state transitions.
+			if let Some(peer_id) = current_peer {
+				let event = current_event.unwrap();
+				let last_state = discard_incoming_index(last_state.unwrap());
+				if !allowed_events.get(&last_state).unwrap().contains(&event) {
+					panic!(
+						"Invalid state transition: {:?} x {:?} for peer {}",
+						last_state, event, peer_id,
+					);
+				}
+			}
+		}
+	})
+	.await;
+}
diff --git a/substrate/client/network/test/src/lib.rs b/substrate/client/network/test/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a20da5a556b7398397cd9845acdc049961f0ce2
--- /dev/null
+++ b/substrate/client/network/test/src/lib.rs
@@ -0,0 +1,1208 @@
+// 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/>.
+#![allow(missing_docs)]
+
+#[cfg(test)]
+mod block_import;
+#[cfg(test)]
+mod fuzz;
+#[cfg(test)]
+mod service;
+#[cfg(test)]
+mod sync;
+
+use std::{
+	collections::HashMap,
+	pin::Pin,
+	sync::Arc,
+	task::{Context as FutureContext, Poll},
+	time::Duration,
+};
+
+use futures::{channel::oneshot, future::BoxFuture, pin_mut, prelude::*};
+use libp2p::{build_multiaddr, PeerId};
+use log::trace;
+use parking_lot::Mutex;
+use sc_block_builder::{BlockBuilder, BlockBuilderProvider};
+use sc_client_api::{
+	backend::{AuxStore, Backend, Finalizer},
+	BlockBackend, BlockImportNotification, BlockchainEvents, FinalityNotification,
+	FinalityNotifications, ImportNotifications,
+};
+use sc_consensus::{
+	BasicQueue, BlockCheckParams, BlockImport, BlockImportParams, BoxJustificationImport,
+	ForkChoiceStrategy, ImportQueue, ImportResult, JustificationImport, JustificationSyncLink,
+	LongestChain, Verifier,
+};
+use sc_network::{
+	config::{
+		FullNetworkConfiguration, MultiaddrWithPeerId, NetworkConfiguration, NonDefaultSetConfig,
+		NonReservedPeerMode, ProtocolId, Role, SyncMode, TransportConfig,
+	},
+	peer_store::PeerStore,
+	request_responses::ProtocolConfig as RequestResponseConfig,
+	types::ProtocolName,
+	Multiaddr, NetworkBlock, NetworkService, NetworkStateInfo, NetworkSyncForkRequest,
+	NetworkWorker,
+};
+use sc_network_common::{
+	role::Roles,
+	sync::warp::{
+		AuthorityList, EncodedProof, SetId, VerificationResult, WarpSyncParams, WarpSyncProvider,
+	},
+};
+use sc_network_light::light_client_requests::handler::LightClientRequestHandler;
+use sc_network_sync::{
+	block_request_handler::BlockRequestHandler,
+	service::{chain_sync::SyncingService, network::NetworkServiceProvider},
+	state_request_handler::StateRequestHandler,
+	warp_request_handler,
+};
+use sc_service::client::Client;
+use sp_blockchain::{
+	Backend as BlockchainBackend, HeaderBackend, Info as BlockchainInfo, Result as ClientResult,
+};
+use sp_consensus::{
+	block_validation::{BlockAnnounceValidator, DefaultBlockAnnounceValidator},
+	BlockOrigin, Error as ConsensusError, SyncOracle,
+};
+use sp_core::H256;
+use sp_runtime::{
+	codec::{Decode, Encode},
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor, Zero},
+	Justification, Justifications,
+};
+use substrate_test_runtime_client::AccountKeyring;
+pub use substrate_test_runtime_client::{
+	runtime::{Block, ExtrinsicBuilder, Hash, Header, Transfer},
+	TestClient, TestClientBuilder, TestClientBuilderExt,
+};
+use tokio::time::timeout;
+
+/// A Verifier that accepts all blocks and passes them on with the configured
+/// finality to be imported.
+#[derive(Clone)]
+pub struct PassThroughVerifier {
+	finalized: bool,
+}
+
+impl PassThroughVerifier {
+	/// Create a new instance.
+	///
+	/// Every verified block will use `finalized` for the `BlockImportParams`.
+	pub fn new(finalized: bool) -> Self {
+		Self { finalized }
+	}
+}
+
+/// This `Verifier` accepts all data as valid.
+#[async_trait::async_trait]
+impl<B: BlockT> Verifier<B> for PassThroughVerifier {
+	async fn verify(
+		&mut self,
+		mut block: BlockImportParams<B>,
+	) -> Result<BlockImportParams<B>, String> {
+		if block.fork_choice.is_none() {
+			block.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+		};
+		block.finalized = self.finalized;
+		Ok(block)
+	}
+}
+
+pub type PeersFullClient = Client<
+	substrate_test_runtime_client::Backend,
+	substrate_test_runtime_client::ExecutorDispatch,
+	Block,
+	substrate_test_runtime_client::runtime::RuntimeApi,
+>;
+
+#[derive(Clone)]
+pub struct PeersClient {
+	client: Arc<PeersFullClient>,
+	backend: Arc<substrate_test_runtime_client::Backend>,
+}
+
+impl PeersClient {
+	pub fn as_client(&self) -> Arc<PeersFullClient> {
+		self.client.clone()
+	}
+
+	pub fn as_backend(&self) -> Arc<substrate_test_runtime_client::Backend> {
+		self.backend.clone()
+	}
+
+	pub fn as_block_import(&self) -> BlockImportAdapter<Self> {
+		BlockImportAdapter::new(self.clone())
+	}
+
+	pub fn get_aux(&self, key: &[u8]) -> ClientResult<Option<Vec<u8>>> {
+		self.client.get_aux(key)
+	}
+
+	pub fn info(&self) -> BlockchainInfo<Block> {
+		self.client.info()
+	}
+
+	pub fn header(
+		&self,
+		hash: <Block as BlockT>::Hash,
+	) -> ClientResult<Option<<Block as BlockT>::Header>> {
+		self.client.header(hash)
+	}
+
+	pub fn has_state_at(&self, block: &BlockId<Block>) -> bool {
+		let (number, hash) = match *block {
+			BlockId::Hash(h) => match self.as_client().number(h) {
+				Ok(Some(n)) => (n, h),
+				_ => return false,
+			},
+			BlockId::Number(n) => match self.as_client().hash(n) {
+				Ok(Some(h)) => (n, h),
+				_ => return false,
+			},
+		};
+		self.backend.have_state_at(hash, number)
+	}
+
+	pub fn justifications(
+		&self,
+		hash: <Block as BlockT>::Hash,
+	) -> ClientResult<Option<Justifications>> {
+		self.client.justifications(hash)
+	}
+
+	pub fn finality_notification_stream(&self) -> FinalityNotifications<Block> {
+		self.client.finality_notification_stream()
+	}
+
+	pub fn import_notification_stream(&self) -> ImportNotifications<Block> {
+		self.client.import_notification_stream()
+	}
+
+	pub fn finalize_block(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		justification: Option<Justification>,
+		notify: bool,
+	) -> ClientResult<()> {
+		self.client.finalize_block(hash, justification, notify)
+	}
+}
+
+#[async_trait::async_trait]
+impl BlockImport<Block> for PeersClient {
+	type Error = ConsensusError;
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.client.check_block(block).await
+	}
+
+	async fn import_block(
+		&mut self,
+		block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.client.import_block(block).await
+	}
+}
+
+pub struct Peer<D, BlockImport> {
+	pub data: D,
+	client: PeersClient,
+	/// We keep a copy of the verifier so that we can invoke it for locally-generated blocks,
+	/// instead of going through the import queue.
+	verifier: VerifierAdapter<Block>,
+	/// We keep a copy of the block_import so that we can invoke it for locally-generated blocks,
+	/// instead of going through the import queue.
+	block_import: BlockImportAdapter<BlockImport>,
+	select_chain: Option<LongestChain<substrate_test_runtime_client::Backend, Block>>,
+	backend: Option<Arc<substrate_test_runtime_client::Backend>>,
+	network: NetworkWorker<Block, <Block as BlockT>::Hash>,
+	sync_service: Arc<SyncingService<Block>>,
+	imported_blocks_stream: Pin<Box<dyn Stream<Item = BlockImportNotification<Block>> + Send>>,
+	finality_notification_stream: Pin<Box<dyn Stream<Item = FinalityNotification<Block>> + Send>>,
+	listen_addr: Multiaddr,
+}
+
+impl<D, B> Peer<D, B>
+where
+	B: BlockImport<Block, Error = ConsensusError> + Send + Sync,
+{
+	/// Get this peer ID.
+	pub fn id(&self) -> PeerId {
+		self.network.service().local_peer_id()
+	}
+
+	/// Returns true if we're major syncing.
+	pub fn is_major_syncing(&self) -> bool {
+		self.sync_service.is_major_syncing()
+	}
+
+	// Returns a clone of the local SelectChain, only available on full nodes
+	pub fn select_chain(
+		&self,
+	) -> Option<LongestChain<substrate_test_runtime_client::Backend, Block>> {
+		self.select_chain.clone()
+	}
+
+	/// Returns the number of peers we're connected to.
+	pub fn num_peers(&self) -> usize {
+		self.network.num_connected_peers()
+	}
+
+	/// Returns the number of downloaded blocks.
+	pub async fn num_downloaded_blocks(&self) -> usize {
+		self.sync_service.num_downloaded_blocks().await.unwrap()
+	}
+
+	/// Returns true if we have no peer.
+	pub fn is_offline(&self) -> bool {
+		self.sync_service.is_offline()
+	}
+
+	/// Request a justification for the given block.
+	pub fn request_justification(&self, hash: &<Block as BlockT>::Hash, number: NumberFor<Block>) {
+		self.sync_service.request_justification(hash, number);
+	}
+
+	/// Announces an important block on the network.
+	pub fn announce_block(&self, hash: <Block as BlockT>::Hash, data: Option<Vec<u8>>) {
+		self.sync_service.announce_block(hash, data);
+	}
+
+	/// Request explicit fork sync.
+	pub fn set_sync_fork_request(
+		&self,
+		peers: Vec<PeerId>,
+		hash: <Block as BlockT>::Hash,
+		number: NumberFor<Block>,
+	) {
+		self.sync_service.set_sync_fork_request(peers, hash, number);
+	}
+
+	/// Add blocks to the peer -- edit the block before adding
+	pub fn generate_blocks<F>(
+		&mut self,
+		count: usize,
+		origin: BlockOrigin,
+		edit_block: F,
+	) -> Vec<H256>
+	where
+		F: FnMut(
+			BlockBuilder<Block, PeersFullClient, substrate_test_runtime_client::Backend>,
+		) -> Block,
+	{
+		let best_hash = self.client.info().best_hash;
+		self.generate_blocks_at(
+			BlockId::Hash(best_hash),
+			count,
+			origin,
+			edit_block,
+			false,
+			true,
+			true,
+			ForkChoiceStrategy::LongestChain,
+		)
+	}
+
+	/// Add blocks to the peer -- edit the block before adding and use custom fork choice rule.
+	pub fn generate_blocks_with_fork_choice<F>(
+		&mut self,
+		count: usize,
+		origin: BlockOrigin,
+		edit_block: F,
+		fork_choice: ForkChoiceStrategy,
+	) -> Vec<H256>
+	where
+		F: FnMut(
+			BlockBuilder<Block, PeersFullClient, substrate_test_runtime_client::Backend>,
+		) -> Block,
+	{
+		let best_hash = self.client.info().best_hash;
+		self.generate_blocks_at(
+			BlockId::Hash(best_hash),
+			count,
+			origin,
+			edit_block,
+			false,
+			true,
+			true,
+			fork_choice,
+		)
+	}
+
+	/// Add blocks to the peer -- edit the block before adding. The chain will
+	/// start at the given block iD.
+	pub fn generate_blocks_at<F>(
+		&mut self,
+		at: BlockId<Block>,
+		count: usize,
+		origin: BlockOrigin,
+		mut edit_block: F,
+		headers_only: bool,
+		inform_sync_about_new_best_block: bool,
+		announce_block: bool,
+		fork_choice: ForkChoiceStrategy,
+	) -> Vec<H256>
+	where
+		F: FnMut(
+			BlockBuilder<Block, PeersFullClient, substrate_test_runtime_client::Backend>,
+		) -> Block,
+	{
+		let mut hashes = Vec::with_capacity(count);
+		let full_client = self.client.as_client();
+		let mut at = full_client.block_hash_from_id(&at).unwrap().unwrap();
+		for _ in 0..count {
+			let builder = full_client.new_block_at(at, Default::default(), false).unwrap();
+			let block = edit_block(builder);
+			let hash = block.header.hash();
+			trace!(
+				target: "test_network",
+				"Generating {}, (#{}, parent={})",
+				hash,
+				block.header.number,
+				block.header.parent_hash,
+			);
+			let header = block.header.clone();
+			let mut import_block = BlockImportParams::new(origin, header.clone());
+			import_block.body = if headers_only { None } else { Some(block.extrinsics) };
+			import_block.fork_choice = Some(fork_choice);
+			let import_block =
+				futures::executor::block_on(self.verifier.verify(import_block)).unwrap();
+
+			futures::executor::block_on(self.block_import.import_block(import_block))
+				.expect("block_import failed");
+			if announce_block {
+				self.sync_service.announce_block(hash, None);
+			}
+			hashes.push(hash);
+			at = hash;
+		}
+
+		if inform_sync_about_new_best_block {
+			self.sync_service.new_best_block_imported(
+				at,
+				*full_client.header(at).ok().flatten().unwrap().number(),
+			);
+		}
+		hashes
+	}
+
+	/// Push blocks to the peer (simplified: with or without a TX)
+	pub fn push_blocks(&mut self, count: usize, with_tx: bool) -> Vec<H256> {
+		let best_hash = self.client.info().best_hash;
+		self.push_blocks_at(BlockId::Hash(best_hash), count, with_tx)
+	}
+
+	/// Push blocks to the peer (simplified: with or without a TX)
+	pub fn push_headers(&mut self, count: usize) -> Vec<H256> {
+		let best_hash = self.client.info().best_hash;
+		self.generate_tx_blocks_at(BlockId::Hash(best_hash), count, false, true, true, true)
+	}
+
+	/// Push blocks to the peer (simplified: with or without a TX) starting from
+	/// given hash.
+	pub fn push_blocks_at(&mut self, at: BlockId<Block>, count: usize, with_tx: bool) -> Vec<H256> {
+		self.generate_tx_blocks_at(at, count, with_tx, false, true, true)
+	}
+
+	/// Push blocks to the peer (simplified: with or without a TX) starting from
+	/// given hash without informing the sync protocol about the new best block.
+	pub fn push_blocks_at_without_informing_sync(
+		&mut self,
+		at: BlockId<Block>,
+		count: usize,
+		with_tx: bool,
+		announce_block: bool,
+	) -> Vec<H256> {
+		self.generate_tx_blocks_at(at, count, with_tx, false, false, announce_block)
+	}
+
+	/// Push blocks to the peer (simplified: with or without a TX) starting from
+	/// given hash without announcing the block.
+	pub fn push_blocks_at_without_announcing(
+		&mut self,
+		at: BlockId<Block>,
+		count: usize,
+		with_tx: bool,
+	) -> Vec<H256> {
+		self.generate_tx_blocks_at(at, count, with_tx, false, true, false)
+	}
+
+	/// Push blocks/headers to the peer (simplified: with or without a TX) starting from
+	/// given hash.
+	fn generate_tx_blocks_at(
+		&mut self,
+		at: BlockId<Block>,
+		count: usize,
+		with_tx: bool,
+		headers_only: bool,
+		inform_sync_about_new_best_block: bool,
+		announce_block: bool,
+	) -> Vec<H256> {
+		let mut nonce = 0;
+		if with_tx {
+			self.generate_blocks_at(
+				at,
+				count,
+				BlockOrigin::File,
+				|mut builder| {
+					let transfer = Transfer {
+						from: AccountKeyring::Alice.into(),
+						to: AccountKeyring::Alice.into(),
+						amount: 1,
+						nonce,
+					};
+					builder.push(transfer.into_unchecked_extrinsic()).unwrap();
+					nonce += 1;
+					builder.build().unwrap().block
+				},
+				headers_only,
+				inform_sync_about_new_best_block,
+				announce_block,
+				ForkChoiceStrategy::LongestChain,
+			)
+		} else {
+			self.generate_blocks_at(
+				at,
+				count,
+				BlockOrigin::File,
+				|builder| builder.build().unwrap().block,
+				headers_only,
+				inform_sync_about_new_best_block,
+				announce_block,
+				ForkChoiceStrategy::LongestChain,
+			)
+		}
+	}
+
+	/// Get a reference to the client.
+	pub fn client(&self) -> &PeersClient {
+		&self.client
+	}
+
+	/// Get a reference to the network service.
+	pub fn network_service(&self) -> &Arc<NetworkService<Block, <Block as BlockT>::Hash>> {
+		self.network.service()
+	}
+
+	pub fn sync_service(&self) -> &Arc<SyncingService<Block>> {
+		&self.sync_service
+	}
+
+	/// Get a reference to the network worker.
+	pub fn network(&self) -> &NetworkWorker<Block, <Block as BlockT>::Hash> {
+		&self.network
+	}
+
+	/// Test helper to compare the blockchain state of multiple (networked)
+	/// clients.
+	pub fn blockchain_canon_equals(&self, other: &Self) -> bool {
+		if let (Some(mine), Some(others)) = (self.backend.clone(), other.backend.clone()) {
+			mine.blockchain().info().best_hash == others.blockchain().info().best_hash
+		} else {
+			false
+		}
+	}
+
+	/// Count the total number of imported blocks.
+	pub fn blocks_count(&self) -> u64 {
+		self.backend
+			.as_ref()
+			.map(|backend| backend.blockchain().info().best_number)
+			.unwrap_or(0)
+	}
+
+	/// Return a collection of block hashes that failed verification
+	pub fn failed_verifications(&self) -> HashMap<<Block as BlockT>::Hash, String> {
+		self.verifier.failed_verifications.lock().clone()
+	}
+
+	pub fn has_block(&self, hash: H256) -> bool {
+		self.backend
+			.as_ref()
+			.map(|backend| backend.blockchain().header(hash).unwrap().is_some())
+			.unwrap_or(false)
+	}
+
+	pub fn has_body(&self, hash: H256) -> bool {
+		self.backend
+			.as_ref()
+			.map(|backend| backend.blockchain().body(hash).unwrap().is_some())
+			.unwrap_or(false)
+	}
+}
+
+pub trait BlockImportAdapterFull:
+	BlockImport<Block, Error = ConsensusError> + Send + Sync + Clone
+{
+}
+
+impl<T> BlockImportAdapterFull for T where
+	T: BlockImport<Block, Error = ConsensusError> + Send + Sync + Clone
+{
+}
+
+/// Implements `BlockImport` for any `Transaction`. Internally the transaction is
+/// "converted", aka the field is set to `None`.
+///
+/// This is required as the `TestNetFactory` trait does not distinguish between
+/// full and light nodes.
+#[derive(Clone)]
+pub struct BlockImportAdapter<I> {
+	inner: I,
+}
+
+impl<I> BlockImportAdapter<I> {
+	/// Create a new instance of `Self::Full`.
+	pub fn new(inner: I) -> Self {
+		Self { inner }
+	}
+}
+
+#[async_trait::async_trait]
+impl<I> BlockImport<Block> for BlockImportAdapter<I>
+where
+	I: BlockImport<Block, Error = ConsensusError> + Send + Sync,
+{
+	type Error = ConsensusError;
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.inner.check_block(block).await
+	}
+
+	async fn import_block(
+		&mut self,
+		block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		self.inner.import_block(block).await
+	}
+}
+
+/// Implements `Verifier` and keeps track of failed verifications.
+struct VerifierAdapter<B: BlockT> {
+	verifier: Arc<futures::lock::Mutex<Box<dyn Verifier<B>>>>,
+	failed_verifications: Arc<Mutex<HashMap<B::Hash, String>>>,
+}
+
+#[async_trait::async_trait]
+impl<B: BlockT> Verifier<B> for VerifierAdapter<B> {
+	async fn verify(
+		&mut self,
+		block: BlockImportParams<B>,
+	) -> Result<BlockImportParams<B>, String> {
+		let hash = block.header.hash();
+		self.verifier.lock().await.verify(block).await.map_err(|e| {
+			self.failed_verifications.lock().insert(hash, e.clone());
+			e
+		})
+	}
+}
+
+impl<B: BlockT> Clone for VerifierAdapter<B> {
+	fn clone(&self) -> Self {
+		Self {
+			verifier: self.verifier.clone(),
+			failed_verifications: self.failed_verifications.clone(),
+		}
+	}
+}
+
+impl<B: BlockT> VerifierAdapter<B> {
+	fn new(verifier: impl Verifier<B> + 'static) -> Self {
+		VerifierAdapter {
+			verifier: Arc::new(futures::lock::Mutex::new(Box::new(verifier))),
+			failed_verifications: Default::default(),
+		}
+	}
+}
+
+struct TestWarpSyncProvider<B: BlockT>(Arc<dyn HeaderBackend<B>>);
+
+impl<B: BlockT> WarpSyncProvider<B> for TestWarpSyncProvider<B> {
+	fn generate(
+		&self,
+		_start: B::Hash,
+	) -> Result<EncodedProof, Box<dyn std::error::Error + Send + Sync>> {
+		let info = self.0.info();
+		let best_header = self.0.header(info.best_hash).unwrap().unwrap();
+		Ok(EncodedProof(best_header.encode()))
+	}
+	fn verify(
+		&self,
+		proof: &EncodedProof,
+		_set_id: SetId,
+		_authorities: AuthorityList,
+	) -> Result<VerificationResult<B>, Box<dyn std::error::Error + Send + Sync>> {
+		let EncodedProof(encoded) = proof;
+		let header = B::Header::decode(&mut encoded.as_slice()).unwrap();
+		Ok(VerificationResult::Complete(0, Default::default(), header))
+	}
+	fn current_authorities(&self) -> AuthorityList {
+		Default::default()
+	}
+}
+
+/// Configuration for a full peer.
+#[derive(Default)]
+pub struct FullPeerConfig {
+	/// Pruning window size.
+	///
+	/// NOTE: only finalized blocks are subject for removal!
+	pub blocks_pruning: Option<u32>,
+	/// Block announce validator.
+	pub block_announce_validator: Option<Box<dyn BlockAnnounceValidator<Block> + Send + Sync>>,
+	/// List of notification protocols that the network must support.
+	pub notifications_protocols: Vec<ProtocolName>,
+	/// List of request-response protocols that the network must support.
+	pub request_response_protocols: Vec<RequestResponseConfig>,
+	/// The indices of the peers the peer should be connected to.
+	///
+	/// If `None`, it will be connected to all other peers.
+	pub connect_to_peers: Option<Vec<usize>>,
+	/// Whether the full peer should have the authority role.
+	pub is_authority: bool,
+	/// Syncing mode
+	pub sync_mode: SyncMode,
+	/// Extra genesis storage.
+	pub extra_storage: Option<sp_core::storage::Storage>,
+	/// Enable transaction indexing.
+	pub storage_chain: bool,
+	/// Optional target block header to sync to
+	pub target_block: Option<<Block as BlockT>::Header>,
+}
+
+#[async_trait::async_trait]
+pub trait TestNetFactory: Default + Sized + Send {
+	type Verifier: 'static + Verifier<Block>;
+	type BlockImport: BlockImport<Block, Error = ConsensusError> + Clone + Send + Sync + 'static;
+	type PeerData: Default + Send;
+
+	/// This one needs to be implemented!
+	fn make_verifier(&self, client: PeersClient, peer_data: &Self::PeerData) -> Self::Verifier;
+
+	/// Get reference to peer.
+	fn peer(&mut self, i: usize) -> &mut Peer<Self::PeerData, Self::BlockImport>;
+	fn peers(&self) -> &Vec<Peer<Self::PeerData, Self::BlockImport>>;
+	fn peers_mut(&mut self) -> &mut Vec<Peer<Self::PeerData, Self::BlockImport>>;
+	fn mut_peers<F: FnOnce(&mut Vec<Peer<Self::PeerData, Self::BlockImport>>)>(
+		&mut self,
+		closure: F,
+	);
+
+	/// Get custom block import handle for fresh client, along with peer data.
+	fn make_block_import(
+		&self,
+		client: PeersClient,
+	) -> (
+		BlockImportAdapter<Self::BlockImport>,
+		Option<BoxJustificationImport<Block>>,
+		Self::PeerData,
+	);
+
+	/// Create new test network with this many peers.
+	fn new(n: usize) -> Self {
+		trace!(target: "test_network", "Creating test network");
+		let mut net = Self::default();
+
+		for i in 0..n {
+			trace!(target: "test_network", "Adding peer {}", i);
+			net.add_full_peer();
+		}
+		net
+	}
+
+	fn add_full_peer(&mut self) {
+		self.add_full_peer_with_config(Default::default())
+	}
+
+	/// Add a full peer.
+	fn add_full_peer_with_config(&mut self, config: FullPeerConfig) {
+		let mut test_client_builder = match (config.blocks_pruning, config.storage_chain) {
+			(Some(blocks_pruning), true) => TestClientBuilder::with_tx_storage(blocks_pruning),
+			(None, true) => TestClientBuilder::with_tx_storage(u32::MAX),
+			(Some(blocks_pruning), false) => TestClientBuilder::with_pruning_window(blocks_pruning),
+			(None, false) => TestClientBuilder::with_default_backend(),
+		};
+		if let Some(storage) = config.extra_storage {
+			let genesis_extra_storage = test_client_builder.genesis_init_mut().extra_storage();
+			*genesis_extra_storage = storage;
+		}
+
+		if matches!(config.sync_mode, SyncMode::LightState { .. } | SyncMode::Warp) {
+			test_client_builder = test_client_builder.set_no_genesis();
+		}
+		let backend = test_client_builder.backend();
+		let (c, longest_chain) = test_client_builder.build_with_longest_chain();
+		let client = Arc::new(c);
+
+		let (block_import, justification_import, data) = self
+			.make_block_import(PeersClient { client: client.clone(), backend: backend.clone() });
+
+		let verifier = self
+			.make_verifier(PeersClient { client: client.clone(), backend: backend.clone() }, &data);
+		let verifier = VerifierAdapter::new(verifier);
+
+		let import_queue = Box::new(BasicQueue::new(
+			verifier.clone(),
+			Box::new(block_import.clone()),
+			justification_import,
+			&sp_core::testing::TaskExecutor::new(),
+			None,
+		));
+
+		let listen_addr = build_multiaddr![Memory(rand::random::<u64>())];
+
+		let mut network_config =
+			NetworkConfiguration::new("test-node", "test-client", Default::default(), None);
+		network_config.sync_mode = config.sync_mode;
+		network_config.transport = TransportConfig::MemoryOnly;
+		network_config.listen_addresses = vec![listen_addr.clone()];
+		network_config.allow_non_globals_in_dht = true;
+		if let Some(connect_to) = config.connect_to_peers {
+			let addrs = connect_to
+				.iter()
+				.map(|v| {
+					let peer_id = self.peer(*v).network_service().local_peer_id();
+					let multiaddr = self.peer(*v).listen_addr.clone();
+					MultiaddrWithPeerId { peer_id, multiaddr }
+				})
+				.collect();
+			network_config.default_peers_set.reserved_nodes = addrs;
+			network_config.default_peers_set.non_reserved_mode = NonReservedPeerMode::Deny;
+		}
+		let mut full_net_config = FullNetworkConfiguration::new(&network_config);
+
+		let protocol_id = ProtocolId::from("test-protocol-name");
+
+		let fork_id = Some(String::from("test-fork-id"));
+
+		let block_request_protocol_config = {
+			let (handler, protocol_config) =
+				BlockRequestHandler::new(&protocol_id, None, client.clone(), 50);
+			self.spawn_task(handler.run().boxed());
+			protocol_config
+		};
+
+		let state_request_protocol_config = {
+			let (handler, protocol_config) =
+				StateRequestHandler::new(&protocol_id, None, client.clone(), 50);
+			self.spawn_task(handler.run().boxed());
+			protocol_config
+		};
+
+		let light_client_request_protocol_config = {
+			let (handler, protocol_config) =
+				LightClientRequestHandler::new(&protocol_id, None, client.clone());
+			self.spawn_task(handler.run().boxed());
+			protocol_config
+		};
+
+		let warp_sync = Arc::new(TestWarpSyncProvider(client.clone()));
+
+		let warp_sync_params = match config.target_block {
+			Some(target_block) => {
+				let (sender, receiver) = oneshot::channel::<<Block as BlockT>::Header>();
+				let _ = sender.send(target_block);
+				WarpSyncParams::WaitForTarget(receiver)
+			},
+			_ => WarpSyncParams::WithProvider(warp_sync.clone()),
+		};
+
+		let warp_protocol_config = {
+			let (handler, protocol_config) = warp_request_handler::RequestHandler::new(
+				protocol_id.clone(),
+				client
+					.block_hash(0u32.into())
+					.ok()
+					.flatten()
+					.expect("Genesis block exists; qed"),
+				None,
+				warp_sync.clone(),
+			);
+			self.spawn_task(handler.run().boxed());
+			protocol_config
+		};
+
+		let block_announce_validator = config
+			.block_announce_validator
+			.unwrap_or_else(|| Box::new(DefaultBlockAnnounceValidator));
+		let (chain_sync_network_provider, chain_sync_network_handle) =
+			NetworkServiceProvider::new();
+
+		let (tx, rx) = sc_utils::mpsc::tracing_unbounded("mpsc_syncing_engine_protocol", 100_000);
+		let (engine, sync_service, block_announce_config) =
+			sc_network_sync::engine::SyncingEngine::new(
+				Roles::from(if config.is_authority { &Role::Authority } else { &Role::Full }),
+				client.clone(),
+				None,
+				&full_net_config,
+				protocol_id.clone(),
+				&fork_id,
+				block_announce_validator,
+				Some(warp_sync_params),
+				chain_sync_network_handle,
+				import_queue.service(),
+				block_request_protocol_config.name.clone(),
+				state_request_protocol_config.name.clone(),
+				Some(warp_protocol_config.name.clone()),
+				rx,
+			)
+			.unwrap();
+		let sync_service_import_queue = Box::new(sync_service.clone());
+		let sync_service = Arc::new(sync_service.clone());
+
+		for config in config.request_response_protocols {
+			full_net_config.add_request_response_protocol(config);
+		}
+		for config in [
+			block_request_protocol_config,
+			state_request_protocol_config,
+			light_client_request_protocol_config,
+			warp_protocol_config,
+		] {
+			full_net_config.add_request_response_protocol(config);
+		}
+
+		for protocol in config.notifications_protocols {
+			full_net_config.add_notification_protocol(NonDefaultSetConfig {
+				notifications_protocol: protocol,
+				fallback_names: Vec::new(),
+				max_notification_size: 1024 * 1024,
+				handshake: None,
+				set_config: Default::default(),
+			});
+		}
+
+		let peer_store = PeerStore::new(
+			network_config.boot_nodes.iter().map(|bootnode| bootnode.peer_id).collect(),
+		);
+		let peer_store_handle = peer_store.handle();
+		self.spawn_task(peer_store.run().boxed());
+
+		let genesis_hash =
+			client.hash(Zero::zero()).ok().flatten().expect("Genesis block exists; qed");
+		let network = NetworkWorker::new(sc_network::config::Params {
+			role: if config.is_authority { Role::Authority } else { Role::Full },
+			executor: Box::new(|f| {
+				tokio::spawn(f);
+			}),
+			network_config: full_net_config,
+			peer_store: peer_store_handle,
+			genesis_hash,
+			protocol_id,
+			fork_id,
+			metrics_registry: None,
+			block_announce_config,
+			tx,
+		})
+		.unwrap();
+
+		trace!(target: "test_network", "Peer identifier: {}", network.service().local_peer_id());
+
+		let service = network.service().clone();
+		tokio::spawn(async move {
+			chain_sync_network_provider.run(service).await;
+		});
+
+		tokio::spawn(async move {
+			import_queue.run(sync_service_import_queue).await;
+		});
+
+		tokio::spawn(async move {
+			engine.run().await;
+		});
+
+		self.mut_peers(move |peers| {
+			for peer in peers.iter_mut() {
+				peer.network
+					.add_known_address(network.service().local_peer_id(), listen_addr.clone());
+			}
+
+			let imported_blocks_stream = Box::pin(client.import_notification_stream().fuse());
+			let finality_notification_stream =
+				Box::pin(client.finality_notification_stream().fuse());
+
+			peers.push(Peer {
+				data,
+				client: PeersClient { client: client.clone(), backend: backend.clone() },
+				select_chain: Some(longest_chain),
+				backend: Some(backend),
+				imported_blocks_stream,
+				finality_notification_stream,
+				block_import,
+				verifier,
+				network,
+				sync_service,
+				listen_addr,
+			});
+		});
+	}
+
+	/// Used to spawn background tasks, e.g. the block request protocol handler.
+	fn spawn_task(&self, f: BoxFuture<'static, ()>) {
+		tokio::spawn(f);
+	}
+
+	/// Polls the testnet until all peers are connected to each other.
+	///
+	/// Must be executed in a task context.
+	fn poll_until_connected(&mut self, cx: &mut FutureContext) -> Poll<()> {
+		self.poll(cx);
+
+		let num_peers = self.peers().len();
+		if self.peers().iter().all(|p| p.num_peers() == num_peers - 1) {
+			return Poll::Ready(())
+		}
+
+		Poll::Pending
+	}
+
+	async fn is_in_sync(&mut self) -> bool {
+		let mut highest = None;
+		let peers = self.peers_mut();
+
+		for peer in peers {
+			if peer.sync_service.is_major_syncing() ||
+				peer.sync_service.num_queued_blocks().await.unwrap() != 0
+			{
+				return false
+			}
+			if peer.sync_service.num_sync_requests().await.unwrap() != 0 {
+				return false
+			}
+			match (highest, peer.client.info().best_hash) {
+				(None, b) => highest = Some(b),
+				(Some(ref a), ref b) if a == b => {},
+				(Some(_), _) => return false,
+			}
+		}
+
+		true
+	}
+
+	async fn is_idle(&mut self) -> bool {
+		let peers = self.peers_mut();
+		for peer in peers {
+			if peer.sync_service.num_queued_blocks().await.unwrap() != 0 {
+				return false
+			}
+			if peer.sync_service.num_sync_requests().await.unwrap() != 0 {
+				return false
+			}
+		}
+
+		true
+	}
+
+	/// Blocks the current thread until we are sync'ed.
+	/// Wait until we are sync'ed.
+	///
+	/// (If we've not synced within 10 mins then panic rather than hang.)
+	async fn run_until_sync(&mut self) {
+		timeout(Duration::from_secs(10 * 60), async {
+			loop {
+				futures::future::poll_fn::<(), _>(|cx| {
+					self.poll(cx);
+					Poll::Ready(())
+				})
+				.await;
+
+				if self.is_in_sync().await {
+					break
+				}
+			}
+		})
+		.await
+		.expect("sync didn't happen within 10 mins");
+	}
+
+	/// Run the network until there are no pending packets.
+	///
+	/// Calls `poll_until_idle` repeatedly with the runtime passed as parameter.
+	async fn run_until_idle(&mut self) {
+		loop {
+			futures::future::poll_fn::<(), _>(|cx| {
+				self.poll(cx);
+				Poll::Ready(())
+			})
+			.await;
+
+			if self.is_idle().await {
+				break
+			}
+		}
+	}
+
+	/// Run the network until all peers are connected to each other.
+	///
+	/// Calls `poll_until_connected` repeatedly with the runtime passed as parameter.
+	async fn run_until_connected(&mut self) {
+		futures::future::poll_fn::<(), _>(|cx| self.poll_until_connected(cx)).await;
+	}
+
+	/// Polls the testnet. Processes all the pending actions.
+	fn poll(&mut self, cx: &mut FutureContext) {
+		self.mut_peers(|peers| {
+			for (i, peer) in peers.iter_mut().enumerate() {
+				trace!(target: "sync", "-- Polling {}: {}", i, peer.id());
+				loop {
+					// The code below is not quite correct, because we are polling a different
+					// instance of the future every time. But as long as
+					// `NetworkWorker::next_action()` contains just streams polling not interleaved
+					// with other `.await`s, dropping the future and recreating it works the same as
+					// polling a single instance.
+					let net_poll_future = peer.network.next_action();
+					pin_mut!(net_poll_future);
+					if let Poll::Pending = net_poll_future.poll(cx) {
+						break
+					}
+				}
+				trace!(target: "sync", "-- Polling complete {}: {}", i, peer.id());
+
+				// We poll `imported_blocks_stream`.
+				while let Poll::Ready(Some(notification)) =
+					peer.imported_blocks_stream.as_mut().poll_next(cx)
+				{
+					peer.sync_service.announce_block(notification.hash, None);
+				}
+
+				// We poll `finality_notification_stream`.
+				while let Poll::Ready(Some(notification)) =
+					peer.finality_notification_stream.as_mut().poll_next(cx)
+				{
+					peer.sync_service.on_block_finalized(notification.hash, notification.header);
+				}
+			}
+		});
+	}
+}
+
+#[derive(Default)]
+pub struct TestNet {
+	peers: Vec<Peer<(), PeersClient>>,
+}
+
+impl TestNetFactory for TestNet {
+	type Verifier = PassThroughVerifier;
+	type PeerData = ();
+	type BlockImport = PeersClient;
+
+	fn make_verifier(&self, _client: PeersClient, _peer_data: &()) -> Self::Verifier {
+		PassThroughVerifier::new(false)
+	}
+
+	fn make_block_import(
+		&self,
+		client: PeersClient,
+	) -> (
+		BlockImportAdapter<Self::BlockImport>,
+		Option<BoxJustificationImport<Block>>,
+		Self::PeerData,
+	) {
+		(client.as_block_import(), None, ())
+	}
+
+	fn peer(&mut self, i: usize) -> &mut Peer<(), Self::BlockImport> {
+		&mut self.peers[i]
+	}
+
+	fn peers(&self) -> &Vec<Peer<(), Self::BlockImport>> {
+		&self.peers
+	}
+
+	fn peers_mut(&mut self) -> &mut Vec<Peer<(), Self::BlockImport>> {
+		&mut self.peers
+	}
+
+	fn mut_peers<F: FnOnce(&mut Vec<Peer<(), Self::BlockImport>>)>(&mut self, closure: F) {
+		closure(&mut self.peers);
+	}
+}
+
+pub struct ForceFinalized(PeersClient);
+
+#[async_trait::async_trait]
+impl JustificationImport<Block> for ForceFinalized {
+	type Error = ConsensusError;
+
+	async fn on_start(&mut self) -> Vec<(H256, NumberFor<Block>)> {
+		Vec::new()
+	}
+
+	async fn import_justification(
+		&mut self,
+		hash: H256,
+		_number: NumberFor<Block>,
+		justification: Justification,
+	) -> Result<(), Self::Error> {
+		self.0
+			.finalize_block(hash, Some(justification), true)
+			.map_err(|_| ConsensusError::InvalidJustification)
+	}
+}
+
+#[derive(Default)]
+pub struct JustificationTestNet(TestNet);
+
+impl TestNetFactory for JustificationTestNet {
+	type Verifier = PassThroughVerifier;
+	type PeerData = ();
+	type BlockImport = PeersClient;
+
+	fn make_verifier(&self, client: PeersClient, peer_data: &()) -> Self::Verifier {
+		self.0.make_verifier(client, peer_data)
+	}
+
+	fn peer(&mut self, i: usize) -> &mut Peer<Self::PeerData, Self::BlockImport> {
+		self.0.peer(i)
+	}
+
+	fn peers(&self) -> &Vec<Peer<Self::PeerData, Self::BlockImport>> {
+		self.0.peers()
+	}
+
+	fn peers_mut(&mut self) -> &mut Vec<Peer<Self::PeerData, Self::BlockImport>> {
+		self.0.peers_mut()
+	}
+
+	fn mut_peers<F: FnOnce(&mut Vec<Peer<Self::PeerData, Self::BlockImport>>)>(
+		&mut self,
+		closure: F,
+	) {
+		self.0.mut_peers(closure)
+	}
+
+	fn make_block_import(
+		&self,
+		client: PeersClient,
+	) -> (
+		BlockImportAdapter<Self::BlockImport>,
+		Option<BoxJustificationImport<Block>>,
+		Self::PeerData,
+	) {
+		(client.as_block_import(), Some(Box::new(ForceFinalized(client))), Default::default())
+	}
+}
diff --git a/substrate/client/network/test/src/service.rs b/substrate/client/network/test/src/service.rs
new file mode 100644
index 0000000000000000000000000000000000000000..68e780545bb173775fc49268a704e0e37b2fa8c3
--- /dev/null
+++ b/substrate/client/network/test/src/service.rs
@@ -0,0 +1,821 @@
+// 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 futures::prelude::*;
+use libp2p::{Multiaddr, PeerId};
+
+use sc_consensus::{ImportQueue, Link};
+use sc_network::{
+	config::{self, FullNetworkConfiguration, MultiaddrWithPeerId, ProtocolId, TransportConfig},
+	event::Event,
+	peer_store::PeerStore,
+	NetworkEventStream, NetworkNotification, NetworkPeers, NetworkService, NetworkStateInfo,
+	NetworkWorker,
+};
+use sc_network_common::role::Roles;
+use sc_network_light::light_client_requests::handler::LightClientRequestHandler;
+use sc_network_sync::{
+	block_request_handler::BlockRequestHandler,
+	engine::SyncingEngine,
+	service::network::{NetworkServiceHandle, NetworkServiceProvider},
+	state_request_handler::StateRequestHandler,
+};
+use sp_blockchain::HeaderBackend;
+use sp_runtime::traits::{Block as BlockT, Zero};
+use substrate_test_runtime_client::{
+	runtime::{Block as TestBlock, Hash as TestHash},
+	TestClientBuilder, TestClientBuilderExt as _,
+};
+
+use std::{sync::Arc, time::Duration};
+
+type TestNetworkWorker = NetworkWorker<TestBlock, TestHash>;
+type TestNetworkService = NetworkService<TestBlock, TestHash>;
+
+const PROTOCOL_NAME: &str = "/foo";
+
+struct TestNetwork {
+	network: TestNetworkWorker,
+}
+
+impl TestNetwork {
+	pub fn new(network: TestNetworkWorker) -> Self {
+		Self { network }
+	}
+
+	pub fn start_network(
+		self,
+	) -> (Arc<TestNetworkService>, (impl Stream<Item = Event> + std::marker::Unpin)) {
+		let worker = self.network;
+		let service = worker.service().clone();
+		let event_stream = service.event_stream("test");
+
+		tokio::spawn(worker.run());
+
+		(service, event_stream)
+	}
+}
+
+struct TestNetworkBuilder {
+	import_queue: Option<Box<dyn ImportQueue<TestBlock>>>,
+	link: Option<Box<dyn Link<TestBlock>>>,
+	client: Option<Arc<substrate_test_runtime_client::TestClient>>,
+	listen_addresses: Vec<Multiaddr>,
+	set_config: Option<config::SetConfig>,
+	chain_sync_network: Option<(NetworkServiceProvider, NetworkServiceHandle)>,
+	notification_protocols: Vec<config::NonDefaultSetConfig>,
+	config: Option<config::NetworkConfiguration>,
+}
+
+impl TestNetworkBuilder {
+	pub fn new() -> Self {
+		Self {
+			import_queue: None,
+			link: None,
+			client: None,
+			listen_addresses: Vec::new(),
+			set_config: None,
+			chain_sync_network: None,
+			notification_protocols: Vec::new(),
+			config: None,
+		}
+	}
+
+	pub fn with_config(mut self, config: config::NetworkConfiguration) -> Self {
+		self.config = Some(config);
+		self
+	}
+
+	pub fn with_notification_protocol(mut self, config: config::NonDefaultSetConfig) -> Self {
+		self.notification_protocols.push(config);
+		self
+	}
+
+	pub fn with_listen_addresses(mut self, addresses: Vec<Multiaddr>) -> Self {
+		self.listen_addresses = addresses;
+		self
+	}
+
+	pub fn with_set_config(mut self, set_config: config::SetConfig) -> Self {
+		self.set_config = Some(set_config);
+		self
+	}
+
+	pub fn build(mut self) -> TestNetwork {
+		let client = self.client.as_mut().map_or(
+			Arc::new(TestClientBuilder::with_default_backend().build_with_longest_chain().0),
+			|v| v.clone(),
+		);
+
+		let network_config = self.config.unwrap_or(config::NetworkConfiguration {
+			listen_addresses: self.listen_addresses,
+			transport: TransportConfig::MemoryOnly,
+			..config::NetworkConfiguration::new_local()
+		});
+
+		#[derive(Clone)]
+		struct PassThroughVerifier(bool);
+
+		#[async_trait::async_trait]
+		impl<B: BlockT> sc_consensus::Verifier<B> for PassThroughVerifier {
+			async fn verify(
+				&mut self,
+				mut block: sc_consensus::BlockImportParams<B>,
+			) -> Result<sc_consensus::BlockImportParams<B>, String> {
+				block.finalized = self.0;
+				block.fork_choice = Some(sc_consensus::ForkChoiceStrategy::LongestChain);
+				Ok(block)
+			}
+		}
+
+		let mut import_queue =
+			self.import_queue.unwrap_or(Box::new(sc_consensus::BasicQueue::new(
+				PassThroughVerifier(false),
+				Box::new(client.clone()),
+				None,
+				&sp_core::testing::TaskExecutor::new(),
+				None,
+			)));
+
+		let protocol_id = ProtocolId::from("test-protocol-name");
+		let fork_id = Some(String::from("test-fork-id"));
+		let mut full_net_config = FullNetworkConfiguration::new(&network_config);
+
+		let block_request_protocol_config = {
+			let (handler, protocol_config) =
+				BlockRequestHandler::new(&protocol_id, None, client.clone(), 50);
+			tokio::spawn(handler.run().boxed());
+			protocol_config
+		};
+
+		let state_request_protocol_config = {
+			let (handler, protocol_config) =
+				StateRequestHandler::new(&protocol_id, None, client.clone(), 50);
+			tokio::spawn(handler.run().boxed());
+			protocol_config
+		};
+
+		let light_client_request_protocol_config = {
+			let (handler, protocol_config) =
+				LightClientRequestHandler::new(&protocol_id, None, client.clone());
+			tokio::spawn(handler.run().boxed());
+			protocol_config
+		};
+
+		let (chain_sync_network_provider, chain_sync_network_handle) =
+			self.chain_sync_network.unwrap_or(NetworkServiceProvider::new());
+		let (tx, rx) = sc_utils::mpsc::tracing_unbounded("mpsc_syncing_engine_protocol", 100_000);
+		let (engine, chain_sync_service, block_announce_config) = SyncingEngine::new(
+			Roles::from(&config::Role::Full),
+			client.clone(),
+			None,
+			&full_net_config,
+			protocol_id.clone(),
+			&None,
+			Box::new(sp_consensus::block_validation::DefaultBlockAnnounceValidator),
+			None,
+			chain_sync_network_handle,
+			import_queue.service(),
+			block_request_protocol_config.name.clone(),
+			state_request_protocol_config.name.clone(),
+			None,
+			rx,
+		)
+		.unwrap();
+		let mut link = self.link.unwrap_or(Box::new(chain_sync_service.clone()));
+
+		if !self.notification_protocols.is_empty() {
+			for config in self.notification_protocols {
+				full_net_config.add_notification_protocol(config);
+			}
+		} else {
+			full_net_config.add_notification_protocol(config::NonDefaultSetConfig {
+				notifications_protocol: PROTOCOL_NAME.into(),
+				fallback_names: Vec::new(),
+				max_notification_size: 1024 * 1024,
+				handshake: None,
+				set_config: self.set_config.unwrap_or_default(),
+			});
+		}
+
+		for config in [
+			block_request_protocol_config,
+			state_request_protocol_config,
+			light_client_request_protocol_config,
+		] {
+			full_net_config.add_request_response_protocol(config);
+		}
+
+		let peer_store = PeerStore::new(
+			network_config.boot_nodes.iter().map(|bootnode| bootnode.peer_id).collect(),
+		);
+		let peer_store_handle = peer_store.handle();
+		tokio::spawn(peer_store.run().boxed());
+
+		let genesis_hash =
+			client.hash(Zero::zero()).ok().flatten().expect("Genesis block exists; qed");
+		let worker = NetworkWorker::<
+			substrate_test_runtime_client::runtime::Block,
+			substrate_test_runtime_client::runtime::Hash,
+		>::new(config::Params::<substrate_test_runtime_client::runtime::Block> {
+			block_announce_config,
+			role: config::Role::Full,
+			executor: Box::new(|f| {
+				tokio::spawn(f);
+			}),
+			genesis_hash,
+			network_config: full_net_config,
+			peer_store: peer_store_handle,
+			protocol_id,
+			fork_id,
+			metrics_registry: None,
+			tx,
+		})
+		.unwrap();
+
+		let service = worker.service().clone();
+		tokio::spawn(async move {
+			let _ = chain_sync_network_provider.run(service).await;
+		});
+		tokio::spawn(async move {
+			loop {
+				futures::future::poll_fn(|cx| {
+					import_queue.poll_actions(cx, &mut *link);
+					std::task::Poll::Ready(())
+				})
+				.await;
+				tokio::time::sleep(std::time::Duration::from_millis(250)).await;
+			}
+		});
+		tokio::spawn(engine.run());
+
+		TestNetwork::new(worker)
+	}
+}
+
+/// Builds two nodes and their associated events stream.
+/// The nodes are connected together and have the `PROTOCOL_NAME` protocol registered.
+fn build_nodes_one_proto() -> (
+	Arc<TestNetworkService>,
+	impl Stream<Item = Event>,
+	Arc<TestNetworkService>,
+	impl Stream<Item = Event>,
+) {
+	let listen_addr = config::build_multiaddr![Memory(rand::random::<u64>())];
+
+	let (node1, events_stream1) = TestNetworkBuilder::new()
+		.with_listen_addresses(vec![listen_addr.clone()])
+		.build()
+		.start_network();
+
+	let (node2, events_stream2) = TestNetworkBuilder::new()
+		.with_set_config(config::SetConfig {
+			reserved_nodes: vec![MultiaddrWithPeerId {
+				multiaddr: listen_addr,
+				peer_id: node1.local_peer_id(),
+			}],
+			..Default::default()
+		})
+		.build()
+		.start_network();
+
+	(node1, events_stream1, node2, events_stream2)
+}
+
+#[tokio::test]
+async fn notifications_state_consistent() {
+	// Runs two nodes and ensures that events are propagated out of the API in a consistent
+	// correct order, which means no notification received on a closed substream.
+
+	let (node1, mut events_stream1, node2, mut events_stream2) = build_nodes_one_proto();
+
+	// Write some initial notifications that shouldn't get through.
+	for _ in 0..(rand::random::<u8>() % 5) {
+		node1.write_notification(
+			node2.local_peer_id(),
+			PROTOCOL_NAME.into(),
+			b"hello world".to_vec(),
+		);
+	}
+	for _ in 0..(rand::random::<u8>() % 5) {
+		node2.write_notification(
+			node1.local_peer_id(),
+			PROTOCOL_NAME.into(),
+			b"hello world".to_vec(),
+		);
+	}
+
+	// True if we have an active substream from node1 to node2.
+	let mut node1_to_node2_open = false;
+	// True if we have an active substream from node2 to node1.
+	let mut node2_to_node1_open = false;
+	// We stop the test after a certain number of iterations.
+	let mut iterations = 0;
+	// Safe guard because we don't want the test to pass if no substream has been open.
+	let mut something_happened = false;
+
+	loop {
+		iterations += 1;
+		if iterations >= 1_000 {
+			assert!(something_happened);
+			break
+		}
+
+		// Start by sending a notification from node1 to node2 and vice-versa. Part of the
+		// test consists in ensuring that notifications get ignored if the stream isn't open.
+		if rand::random::<u8>() % 5 >= 3 {
+			node1.write_notification(
+				node2.local_peer_id(),
+				PROTOCOL_NAME.into(),
+				b"hello world".to_vec(),
+			);
+		}
+		if rand::random::<u8>() % 5 >= 3 {
+			node2.write_notification(
+				node1.local_peer_id(),
+				PROTOCOL_NAME.into(),
+				b"hello world".to_vec(),
+			);
+		}
+
+		// Also randomly disconnect the two nodes from time to time.
+		if rand::random::<u8>() % 20 == 0 {
+			node1.disconnect_peer(node2.local_peer_id(), PROTOCOL_NAME.into());
+		}
+		if rand::random::<u8>() % 20 == 0 {
+			node2.disconnect_peer(node1.local_peer_id(), PROTOCOL_NAME.into());
+		}
+
+		// Grab next event from either `events_stream1` or `events_stream2`.
+		let next_event = {
+			let next1 = events_stream1.next();
+			let next2 = events_stream2.next();
+			// We also await on a small timer, otherwise it is possible for the test to wait
+			// forever while nothing at all happens on the network.
+			let continue_test = futures_timer::Delay::new(Duration::from_millis(20));
+			match future::select(future::select(next1, next2), continue_test).await {
+				future::Either::Left((future::Either::Left((Some(ev), _)), _)) =>
+					future::Either::Left(ev),
+				future::Either::Left((future::Either::Right((Some(ev), _)), _)) =>
+					future::Either::Right(ev),
+				future::Either::Right(_) => continue,
+				_ => break,
+			}
+		};
+
+		match next_event {
+			future::Either::Left(Event::NotificationStreamOpened { remote, protocol, .. }) =>
+				if protocol == PROTOCOL_NAME.into() {
+					something_happened = true;
+					assert!(!node1_to_node2_open);
+					node1_to_node2_open = true;
+					assert_eq!(remote, node2.local_peer_id());
+				},
+			future::Either::Right(Event::NotificationStreamOpened { remote, protocol, .. }) =>
+				if protocol == PROTOCOL_NAME.into() {
+					something_happened = true;
+					assert!(!node2_to_node1_open);
+					node2_to_node1_open = true;
+					assert_eq!(remote, node1.local_peer_id());
+				},
+			future::Either::Left(Event::NotificationStreamClosed { remote, protocol, .. }) =>
+				if protocol == PROTOCOL_NAME.into() {
+					assert!(node1_to_node2_open);
+					node1_to_node2_open = false;
+					assert_eq!(remote, node2.local_peer_id());
+				},
+			future::Either::Right(Event::NotificationStreamClosed { remote, protocol, .. }) =>
+				if protocol == PROTOCOL_NAME.into() {
+					assert!(node2_to_node1_open);
+					node2_to_node1_open = false;
+					assert_eq!(remote, node1.local_peer_id());
+				},
+			future::Either::Left(Event::NotificationsReceived { remote, .. }) => {
+				assert!(node1_to_node2_open);
+				assert_eq!(remote, node2.local_peer_id());
+				if rand::random::<u8>() % 5 >= 4 {
+					node1.write_notification(
+						node2.local_peer_id(),
+						PROTOCOL_NAME.into(),
+						b"hello world".to_vec(),
+					);
+				}
+			},
+			future::Either::Right(Event::NotificationsReceived { remote, .. }) => {
+				assert!(node2_to_node1_open);
+				assert_eq!(remote, node1.local_peer_id());
+				if rand::random::<u8>() % 5 >= 4 {
+					node2.write_notification(
+						node1.local_peer_id(),
+						PROTOCOL_NAME.into(),
+						b"hello world".to_vec(),
+					);
+				}
+			},
+
+			// Add new events here.
+			future::Either::Left(Event::Dht(_)) => {},
+			future::Either::Right(Event::Dht(_)) => {},
+		};
+	}
+}
+
+#[tokio::test]
+async fn lots_of_incoming_peers_works() {
+	sp_tracing::try_init_simple();
+	let listen_addr = config::build_multiaddr![Memory(rand::random::<u64>())];
+
+	let (main_node, _) = TestNetworkBuilder::new()
+		.with_listen_addresses(vec![listen_addr.clone()])
+		.with_set_config(config::SetConfig { in_peers: u32::MAX, ..Default::default() })
+		.build()
+		.start_network();
+
+	let main_node_peer_id = main_node.local_peer_id();
+
+	// We spawn background tasks and push them in this `Vec`. They will all be waited upon before
+	// this test ends.
+	let mut background_tasks_to_wait = Vec::new();
+
+	for _ in 0..32 {
+		let (_dialing_node, event_stream) = TestNetworkBuilder::new()
+			.with_set_config(config::SetConfig {
+				reserved_nodes: vec![MultiaddrWithPeerId {
+					multiaddr: listen_addr.clone(),
+					peer_id: main_node_peer_id,
+				}],
+				..Default::default()
+			})
+			.build()
+			.start_network();
+
+		background_tasks_to_wait.push(tokio::spawn(async move {
+			// Create a dummy timer that will "never" fire, and that will be overwritten when we
+			// actually need the timer. Using an Option would be technically cleaner, but it would
+			// make the code below way more complicated.
+			let mut timer = futures_timer::Delay::new(Duration::from_secs(3600 * 24 * 7)).fuse();
+
+			let mut event_stream = event_stream.fuse();
+			let mut sync_protocol_name = None;
+			loop {
+				futures::select! {
+					_ = timer => {
+						// Test succeeds when timer fires.
+						return;
+					}
+					ev = event_stream.next() => {
+						match ev.unwrap() {
+							Event::NotificationStreamOpened { protocol, remote, .. } => {
+								if let None = sync_protocol_name {
+									sync_protocol_name = Some(protocol.clone());
+								}
+
+								assert_eq!(remote, main_node_peer_id);
+								// Test succeeds after 5 seconds. This timer is here in order to
+								// detect a potential problem after opening.
+								timer = futures_timer::Delay::new(Duration::from_secs(5)).fuse();
+							}
+							Event::NotificationStreamClosed { protocol, .. } => {
+								if Some(protocol) != sync_protocol_name {
+									// Test failed.
+									panic!();
+								}
+							}
+							_ => {}
+						}
+					}
+				}
+			}
+		}));
+	}
+
+	future::join_all(background_tasks_to_wait).await;
+}
+
+#[tokio::test]
+async fn notifications_back_pressure() {
+	// Node 1 floods node 2 with notifications. Random sleeps are done on node 2 to simulate the
+	// node being busy. We make sure that all notifications are received.
+
+	const TOTAL_NOTIFS: usize = 10_000;
+
+	let (node1, mut events_stream1, node2, mut events_stream2) = build_nodes_one_proto();
+	let node2_id = node2.local_peer_id();
+
+	let receiver = tokio::spawn(async move {
+		let mut received_notifications = 0;
+		let mut sync_protocol_name = None;
+
+		while received_notifications < TOTAL_NOTIFS {
+			match events_stream2.next().await.unwrap() {
+				Event::NotificationStreamOpened { protocol, .. } => {
+					if let None = sync_protocol_name {
+						sync_protocol_name = Some(protocol);
+					}
+				},
+				Event::NotificationStreamClosed { protocol, .. } => {
+					if Some(&protocol) != sync_protocol_name.as_ref() {
+						panic!()
+					}
+				},
+				Event::NotificationsReceived { messages, .. } =>
+					for message in messages {
+						assert_eq!(message.0, PROTOCOL_NAME.into());
+						assert_eq!(message.1, format!("hello #{}", received_notifications));
+						received_notifications += 1;
+					},
+				_ => {},
+			};
+
+			if rand::random::<u8>() < 2 {
+				tokio::time::sleep(Duration::from_millis(rand::random::<u64>() % 750)).await;
+			}
+		}
+	});
+
+	// Wait for the `NotificationStreamOpened`.
+	loop {
+		match events_stream1.next().await.unwrap() {
+			Event::NotificationStreamOpened { .. } => break,
+			_ => {},
+		};
+	}
+
+	// Sending!
+	for num in 0..TOTAL_NOTIFS {
+		let notif = node1.notification_sender(node2_id, PROTOCOL_NAME.into()).unwrap();
+		notif
+			.ready()
+			.await
+			.unwrap()
+			.send(format!("hello #{}", num).into_bytes())
+			.unwrap();
+	}
+
+	receiver.await.unwrap();
+}
+
+#[tokio::test]
+async fn fallback_name_working() {
+	// Node 1 supports the protocols "new" and "old". Node 2 only supports "old". Checks whether
+	// they can connect.
+	const NEW_PROTOCOL_NAME: &str = "/new-shiny-protocol-that-isnt-PROTOCOL_NAME";
+
+	let listen_addr = config::build_multiaddr![Memory(rand::random::<u64>())];
+	let (node1, mut events_stream1) = TestNetworkBuilder::new()
+		.with_notification_protocol(config::NonDefaultSetConfig {
+			notifications_protocol: NEW_PROTOCOL_NAME.into(),
+			fallback_names: vec![PROTOCOL_NAME.into()],
+			max_notification_size: 1024 * 1024,
+			handshake: None,
+			set_config: Default::default(),
+		})
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			transport: TransportConfig::MemoryOnly,
+			..config::NetworkConfiguration::new_local()
+		})
+		.build()
+		.start_network();
+
+	let (_, mut events_stream2) = TestNetworkBuilder::new()
+		.with_set_config(config::SetConfig {
+			reserved_nodes: vec![MultiaddrWithPeerId {
+				multiaddr: listen_addr,
+				peer_id: node1.local_peer_id(),
+			}],
+			..Default::default()
+		})
+		.build()
+		.start_network();
+
+	let receiver = tokio::spawn(async move {
+		// Wait for the `NotificationStreamOpened`.
+		loop {
+			match events_stream2.next().await.unwrap() {
+				Event::NotificationStreamOpened { protocol, negotiated_fallback, .. } => {
+					assert_eq!(protocol, PROTOCOL_NAME.into());
+					assert_eq!(negotiated_fallback, None);
+					break
+				},
+				_ => {},
+			};
+		}
+	});
+
+	// Wait for the `NotificationStreamOpened`.
+	loop {
+		match events_stream1.next().await.unwrap() {
+			Event::NotificationStreamOpened { protocol, negotiated_fallback, .. }
+				if protocol == NEW_PROTOCOL_NAME.into() =>
+			{
+				assert_eq!(negotiated_fallback, Some(PROTOCOL_NAME.into()));
+				break
+			},
+			_ => {},
+		};
+	}
+
+	receiver.await.unwrap();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_listen_addresses_consistent_with_transport_memory() {
+	let listen_addr = config::build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(0_u16)];
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			transport: TransportConfig::MemoryOnly,
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_listen_addresses_consistent_with_transport_not_memory() {
+	let listen_addr = config::build_multiaddr![Memory(rand::random::<u64>())];
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_boot_node_addresses_consistent_with_transport_memory() {
+	let listen_addr = config::build_multiaddr![Memory(rand::random::<u64>())];
+	let boot_node = MultiaddrWithPeerId {
+		multiaddr: config::build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(0_u16)],
+		peer_id: PeerId::random(),
+	};
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			transport: TransportConfig::MemoryOnly,
+			boot_nodes: vec![boot_node],
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_boot_node_addresses_consistent_with_transport_not_memory() {
+	let listen_addr = config::build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(0_u16)];
+	let boot_node = MultiaddrWithPeerId {
+		multiaddr: config::build_multiaddr![Memory(rand::random::<u64>())],
+		peer_id: PeerId::random(),
+	};
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			boot_nodes: vec![boot_node],
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_reserved_node_addresses_consistent_with_transport_memory() {
+	let listen_addr = config::build_multiaddr![Memory(rand::random::<u64>())];
+	let reserved_node = MultiaddrWithPeerId {
+		multiaddr: config::build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(0_u16)],
+		peer_id: PeerId::random(),
+	};
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			transport: TransportConfig::MemoryOnly,
+			default_peers_set: config::SetConfig {
+				reserved_nodes: vec![reserved_node],
+				..Default::default()
+			},
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_reserved_node_addresses_consistent_with_transport_not_memory() {
+	let listen_addr = config::build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(0_u16)];
+	let reserved_node = MultiaddrWithPeerId {
+		multiaddr: config::build_multiaddr![Memory(rand::random::<u64>())],
+		peer_id: PeerId::random(),
+	};
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			default_peers_set: config::SetConfig {
+				reserved_nodes: vec![reserved_node],
+				..Default::default()
+			},
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_public_addresses_consistent_with_transport_memory() {
+	let listen_addr = config::build_multiaddr![Memory(rand::random::<u64>())];
+	let public_address = config::build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(0_u16)];
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			transport: TransportConfig::MemoryOnly,
+			public_addresses: vec![public_address],
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
+
+#[tokio::test]
+#[should_panic(expected = "don't match the transport")]
+async fn ensure_public_addresses_consistent_with_transport_not_memory() {
+	let listen_addr = config::build_multiaddr![Ip4([127, 0, 0, 1]), Tcp(0_u16)];
+	let public_address = config::build_multiaddr![Memory(rand::random::<u64>())];
+
+	let _ = TestNetworkBuilder::new()
+		.with_config(config::NetworkConfiguration {
+			listen_addresses: vec![listen_addr.clone()],
+			public_addresses: vec![public_address],
+			..config::NetworkConfiguration::new(
+				"test-node",
+				"test-client",
+				Default::default(),
+				None,
+			)
+		})
+		.build()
+		.start_network();
+}
diff --git a/substrate/client/network/test/src/sync.rs b/substrate/client/network/test/src/sync.rs
new file mode 100644
index 0000000000000000000000000000000000000000..389177b4aaf1bc1ffb6219c598b508c8fa83963e
--- /dev/null
+++ b/substrate/client/network/test/src/sync.rs
@@ -0,0 +1,1325 @@
+// 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::*;
+use futures::Future;
+use sp_consensus::{block_validation::Validation, BlockOrigin};
+use sp_runtime::Justifications;
+use substrate_test_runtime::Header;
+
+async fn test_ancestor_search_when_common_is(n: usize) {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+
+	net.peer(0).push_blocks(n, false);
+	net.peer(1).push_blocks(n, false);
+	net.peer(2).push_blocks(n, false);
+
+	net.peer(0).push_blocks(10, true);
+	net.peer(1).push_blocks(100, false);
+	net.peer(2).push_blocks(100, false);
+
+	net.run_until_sync().await;
+	let peer1 = &net.peers()[1];
+	assert!(net.peers()[0].blockchain_canon_equals(peer1));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_peers_works() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		for peer in 0..3 {
+			if net.peer(peer).num_peers() != 2 {
+				return Poll::Pending
+			}
+		}
+		Poll::Ready(())
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_cycle_from_offline_to_syncing_to_offline() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+	for peer in 0..3 {
+		// Offline, and not major syncing.
+		assert!(net.peer(peer).is_offline());
+		assert!(!net.peer(peer).is_major_syncing());
+	}
+
+	// Generate blocks.
+	net.peer(2).push_blocks(100, false);
+
+	// Block until all nodes are online and nodes 0 and 1 and major syncing.
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		for peer in 0..3 {
+			// Online
+			if net.peer(peer).is_offline() {
+				return Poll::Pending
+			}
+			if peer < 2 {
+				// Major syncing.
+				if net.peer(peer).blocks_count() < 100 && !net.peer(peer).is_major_syncing() {
+					return Poll::Pending
+				}
+			}
+		}
+		Poll::Ready(())
+	})
+	.await;
+
+	// Block until all nodes are done syncing.
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		for peer in 0..3 {
+			if net.peer(peer).is_major_syncing() {
+				return Poll::Pending
+			}
+		}
+		Poll::Ready(())
+	})
+	.await;
+
+	// Now drop nodes 1 and 2, and check that node 0 is offline.
+	net.peers.remove(2);
+	net.peers.remove(1);
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if !net.peer(0).is_offline() {
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn syncing_node_not_major_syncing_when_disconnected() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+
+	// Generate blocks.
+	net.peer(2).push_blocks(100, false);
+
+	// Check that we're not major syncing when disconnected.
+	assert!(!net.peer(1).is_major_syncing());
+
+	// Check that we switch to major syncing.
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if !net.peer(1).is_major_syncing() {
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+
+	// Destroy two nodes, and check that we switch to non-major syncing.
+	net.peers.remove(2);
+	net.peers.remove(0);
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(0).is_major_syncing() {
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_from_two_peers_works() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+	net.peer(1).push_blocks(100, false);
+	net.peer(2).push_blocks(100, false);
+	net.run_until_sync().await;
+	let peer1 = &net.peers()[1];
+	assert!(net.peers()[0].blockchain_canon_equals(peer1));
+	assert!(!net.peer(0).is_major_syncing());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_from_two_peers_with_ancestry_search_works() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+	net.peer(0).push_blocks(10, true);
+	net.peer(1).push_blocks(100, false);
+	net.peer(2).push_blocks(100, false);
+	net.run_until_sync().await;
+	let peer1 = &net.peers()[1];
+	assert!(net.peers()[0].blockchain_canon_equals(peer1));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn ancestry_search_works_when_backoff_is_one() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+
+	net.peer(0).push_blocks(1, false);
+	net.peer(1).push_blocks(2, false);
+	net.peer(2).push_blocks(2, false);
+
+	net.run_until_sync().await;
+	let peer1 = &net.peers()[1];
+	assert!(net.peers()[0].blockchain_canon_equals(peer1));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn ancestry_search_works_when_ancestor_is_genesis() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+
+	net.peer(0).push_blocks(13, true);
+	net.peer(1).push_blocks(100, false);
+	net.peer(2).push_blocks(100, false);
+
+	net.run_until_sync().await;
+	let peer1 = &net.peers()[1];
+	assert!(net.peers()[0].blockchain_canon_equals(peer1));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn ancestry_search_works_when_common_is_one() {
+	test_ancestor_search_when_common_is(1).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn ancestry_search_works_when_common_is_two() {
+	test_ancestor_search_when_common_is(2).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn ancestry_search_works_when_common_is_hundred() {
+	test_ancestor_search_when_common_is(100).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_long_chain_works() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+	net.peer(1).push_blocks(500, false);
+	net.run_until_sync().await;
+	let peer1 = &net.peers()[1];
+	assert!(net.peers()[0].blockchain_canon_equals(peer1));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_no_common_longer_chain_fails() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+	net.peer(0).push_blocks(20, true);
+	net.peer(1).push_blocks(20, false);
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(0).is_major_syncing() {
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+	let peer1 = &net.peers()[1];
+	assert!(!net.peers()[0].blockchain_canon_equals(peer1));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_justifications() {
+	sp_tracing::try_init_simple();
+	let mut net = JustificationTestNet::new(3);
+	let hashes = net.peer(0).push_blocks(20, false);
+	net.run_until_sync().await;
+
+	let hashof10 = hashes[9];
+	let hashof15 = hashes[14];
+	let hashof20 = hashes[19];
+
+	// there's currently no justification for block #10
+	assert_eq!(net.peer(0).client().justifications(hashof10).unwrap(), None);
+	assert_eq!(net.peer(1).client().justifications(hashof10).unwrap(), None);
+
+	// we finalize block #10, #15 and #20 for peer 0 with a justification
+	let just = (*b"FRNK", Vec::new());
+	net.peer(0).client().finalize_block(hashof10, Some(just.clone()), true).unwrap();
+	net.peer(0).client().finalize_block(hashof15, Some(just.clone()), true).unwrap();
+	net.peer(0).client().finalize_block(hashof20, Some(just.clone()), true).unwrap();
+
+	let hashof10 = net.peer(1).client().as_client().hash(10).unwrap().unwrap();
+	let hashof15 = net.peer(1).client().as_client().hash(15).unwrap().unwrap();
+	let hashof20 = net.peer(1).client().as_client().hash(20).unwrap().unwrap();
+
+	// peer 1 should get the justifications from the network
+	net.peer(1).request_justification(&hashof10, 10);
+	net.peer(1).request_justification(&hashof15, 15);
+	net.peer(1).request_justification(&hashof20, 20);
+
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+
+		for height in (10..21).step_by(5) {
+			if net.peer(0).client().justifications(hashes[height - 1]).unwrap() !=
+				Some(Justifications::from((*b"FRNK", Vec::new())))
+			{
+				return Poll::Pending
+			}
+			if net.peer(1).client().justifications(hashes[height - 1]).unwrap() !=
+				Some(Justifications::from((*b"FRNK", Vec::new())))
+			{
+				return Poll::Pending
+			}
+		}
+
+		Poll::Ready(())
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_justifications_across_forks() {
+	sp_tracing::try_init_simple();
+	let mut net = JustificationTestNet::new(3);
+	// we push 5 blocks
+	net.peer(0).push_blocks(5, false);
+	// and then two forks 5 and 6 blocks long
+	let f1_best = net.peer(0).push_blocks_at(BlockId::Number(5), 5, false).pop().unwrap();
+	let f2_best = net.peer(0).push_blocks_at(BlockId::Number(5), 6, false).pop().unwrap();
+
+	// peer 1 will only see the longer fork. but we'll request justifications
+	// for both and finalize the small fork instead.
+	net.run_until_sync().await;
+
+	let just = (*b"FRNK", Vec::new());
+	net.peer(0).client().finalize_block(f1_best, Some(just), true).unwrap();
+
+	net.peer(1).request_justification(&f1_best, 10);
+	net.peer(1).request_justification(&f2_best, 11);
+
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+
+		if net.peer(0).client().justifications(f1_best).unwrap() ==
+			Some(Justifications::from((*b"FRNK", Vec::new()))) &&
+			net.peer(1).client().justifications(f1_best).unwrap() ==
+				Some(Justifications::from((*b"FRNK", Vec::new())))
+		{
+			Poll::Ready(())
+		} else {
+			Poll::Pending
+		}
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_after_fork_works() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+	net.peer(0).push_blocks(30, false);
+	net.peer(1).push_blocks(30, false);
+	net.peer(2).push_blocks(30, false);
+
+	net.peer(0).push_blocks(10, true);
+	net.peer(1).push_blocks(20, false);
+	net.peer(2).push_blocks(20, false);
+
+	net.peer(1).push_blocks(10, true);
+	net.peer(2).push_blocks(1, false);
+
+	// peer 1 has the best chain
+	net.run_until_sync().await;
+	let peer1 = &net.peers()[1];
+	assert!(net.peers()[0].blockchain_canon_equals(peer1));
+	(net.peers()[1].blockchain_canon_equals(peer1));
+	(net.peers()[2].blockchain_canon_equals(peer1));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn syncs_all_forks() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(4);
+	net.peer(0).push_blocks(2, false);
+	net.peer(1).push_blocks(2, false);
+
+	let b1 = net.peer(0).push_blocks(2, true).pop().unwrap();
+	let b2 = net.peer(1).push_blocks(4, false).pop().unwrap();
+
+	net.run_until_sync().await;
+	// Check that all peers have all of the branches.
+	assert!(net.peer(0).has_block(b1));
+	assert!(net.peer(0).has_block(b2));
+	assert!(net.peer(1).has_block(b1));
+	assert!(net.peer(1).has_block(b2));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn own_blocks_are_announced() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+	net.run_until_sync().await; // connect'em
+	net.peer(0)
+		.generate_blocks(1, BlockOrigin::Own, |builder| builder.build().unwrap().block);
+
+	net.run_until_sync().await;
+
+	assert_eq!(net.peer(0).client.info().best_number, 1);
+	assert_eq!(net.peer(1).client.info().best_number, 1);
+	let peer0 = &net.peers()[0];
+	assert!(net.peers()[1].blockchain_canon_equals(peer0));
+	(net.peers()[2].blockchain_canon_equals(peer0));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn can_sync_small_non_best_forks() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+	net.peer(0).push_blocks(30, false);
+	net.peer(1).push_blocks(30, false);
+
+	// small fork + reorg on peer 1.
+	net.peer(0).push_blocks_at(BlockId::Number(30), 2, true);
+	let small_hash = net.peer(0).client().info().best_hash;
+	net.peer(0).push_blocks_at(BlockId::Number(30), 10, false);
+	assert_eq!(net.peer(0).client().info().best_number, 40);
+
+	// peer 1 only ever had the long fork.
+	net.peer(1).push_blocks(10, false);
+	assert_eq!(net.peer(1).client().info().best_number, 40);
+
+	assert!(net.peer(0).client().header(small_hash).unwrap().is_some());
+	assert!(net.peer(1).client().header(small_hash).unwrap().is_none());
+
+	// poll until the two nodes connect, otherwise announcing the block will not work
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(0).num_peers() == 0 || net.peer(1).num_peers() == 0 {
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+
+	// synchronization: 0 synced to longer chain and 1 didn't sync to small chain.
+
+	assert_eq!(net.peer(0).client().info().best_number, 40);
+
+	assert!(net.peer(0).client().header(small_hash).unwrap().is_some());
+	assert!(!net.peer(1).client().header(small_hash).unwrap().is_some());
+
+	net.peer(0).announce_block(small_hash, None);
+
+	// after announcing, peer 1 downloads the block.
+
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+
+		assert!(net.peer(0).client().header(small_hash).unwrap().is_some());
+		if net.peer(1).client().header(small_hash).unwrap().is_none() {
+			return Poll::Pending
+		}
+		Poll::Ready(())
+	})
+	.await;
+	net.run_until_sync().await;
+
+	let another_fork = net.peer(0).push_blocks_at(BlockId::Number(35), 2, true).pop().unwrap();
+	net.peer(0).announce_block(another_fork, None);
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(1).client().header(another_fork).unwrap().is_none() {
+			return Poll::Pending
+		}
+		Poll::Ready(())
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn can_sync_forks_ahead_of_the_best_chain() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+	net.peer(0).push_blocks(1, false);
+	net.peer(1).push_blocks(1, false);
+
+	net.run_until_connected().await;
+	// Peer 0 is on 2-block fork which is announced with is_best=false
+	let fork_hash = net
+		.peer(0)
+		.generate_blocks_with_fork_choice(
+			2,
+			BlockOrigin::Own,
+			|builder| builder.build().unwrap().block,
+			ForkChoiceStrategy::Custom(false),
+		)
+		.pop()
+		.unwrap();
+	// Peer 1 is on 1-block fork
+	net.peer(1).push_blocks(1, false);
+	assert!(net.peer(0).client().header(fork_hash).unwrap().is_some());
+	assert_eq!(net.peer(0).client().info().best_number, 1);
+	assert_eq!(net.peer(1).client().info().best_number, 2);
+
+	// after announcing, peer 1 downloads the block.
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+
+		if net.peer(1).client().header(fork_hash).unwrap().is_none() {
+			return Poll::Pending
+		}
+		Poll::Ready(())
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn can_sync_explicit_forks() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+	net.peer(0).push_blocks(30, false);
+	net.peer(1).push_blocks(30, false);
+
+	// small fork + reorg on peer 1.
+	net.peer(0).push_blocks_at(BlockId::Number(30), 2, true);
+	let small_hash = net.peer(0).client().info().best_hash;
+	let small_number = net.peer(0).client().info().best_number;
+	net.peer(0).push_blocks_at(BlockId::Number(30), 10, false);
+	assert_eq!(net.peer(0).client().info().best_number, 40);
+
+	// peer 1 only ever had the long fork.
+	net.peer(1).push_blocks(10, false);
+	assert_eq!(net.peer(1).client().info().best_number, 40);
+
+	assert!(net.peer(0).client().header(small_hash).unwrap().is_some());
+	assert!(net.peer(1).client().header(small_hash).unwrap().is_none());
+
+	// poll until the two nodes connect, otherwise announcing the block will not work
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(0).num_peers() == 0 || net.peer(1).num_peers() == 0 {
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+
+	// synchronization: 0 synced to longer chain and 1 didn't sync to small chain.
+
+	assert_eq!(net.peer(0).client().info().best_number, 40);
+
+	assert!(net.peer(0).client().header(small_hash).unwrap().is_some());
+	assert!(!net.peer(1).client().header(small_hash).unwrap().is_some());
+
+	// request explicit sync
+	let first_peer_id = net.peer(0).id();
+	net.peer(1).set_sync_fork_request(vec![first_peer_id], small_hash, small_number);
+
+	// peer 1 downloads the block.
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+
+		assert!(net.peer(0).client().header(small_hash).unwrap().is_some());
+		if net.peer(1).client().header(small_hash).unwrap().is_none() {
+			return Poll::Pending
+		}
+		Poll::Ready(())
+	})
+	.await;
+}
+
+// TODO: for unknown reason, this test is flaky on a multithreaded runtime, so we run it
+//       in a single-threaded mode.
+//       See issue https://github.com/paritytech/substrate/issues/14622.
+#[tokio::test]
+async fn syncs_header_only_forks() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(0);
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(FullPeerConfig { blocks_pruning: Some(3), ..Default::default() });
+	net.peer(0).push_blocks(2, false);
+	net.peer(1).push_blocks(2, false);
+
+	net.peer(0).push_blocks(2, true);
+	let small_hash = net.peer(0).client().info().best_hash;
+	net.peer(1).push_blocks(4, false);
+
+	// Peer 1 will sync the small fork even though common block state is missing
+	while !net.peer(1).has_block(small_hash) {
+		net.run_until_idle().await;
+	}
+
+	net.run_until_sync().await;
+	assert_eq!(net.peer(0).client().info().best_hash, net.peer(1).client().info().best_hash);
+	assert_ne!(small_hash, net.peer(0).client().info().best_hash);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn does_not_sync_announced_old_best_block() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(3);
+
+	let old_hash = net.peer(0).push_blocks(1, false).pop().unwrap();
+	let old_hash_with_parent = net.peer(0).push_blocks(1, false).pop().unwrap();
+	net.peer(0).push_blocks(18, true);
+	net.peer(1).push_blocks(20, true);
+
+	net.peer(0).announce_block(old_hash, None);
+	futures::future::poll_fn::<(), _>(|cx| {
+		// poll once to import announcement
+		net.poll(cx);
+		Poll::Ready(())
+	})
+	.await;
+	assert!(!net.peer(1).is_major_syncing());
+
+	net.peer(0).announce_block(old_hash_with_parent, None);
+	futures::future::poll_fn::<(), _>(|cx| {
+		// poll once to import announcement
+		net.poll(cx);
+		Poll::Ready(())
+	})
+	.await;
+	assert!(!net.peer(1).is_major_syncing());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn full_sync_requires_block_body() {
+	// Check that we don't sync headers-only in full mode.
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+
+	net.peer(0).push_headers(1);
+	// Wait for nodes to connect
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(0).num_peers() == 0 || net.peer(1).num_peers() == 0 {
+			Poll::Pending
+		} else {
+			Poll::Ready(())
+		}
+	})
+	.await;
+	net.run_until_idle().await;
+	assert_eq!(net.peer(1).client.info().best_number, 0);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn imports_stale_once() {
+	sp_tracing::try_init_simple();
+
+	async fn import_with_announce(net: &mut TestNet, hash: H256) {
+		// Announce twice
+		net.peer(0).announce_block(hash, None);
+		net.peer(0).announce_block(hash, None);
+
+		futures::future::poll_fn::<(), _>(|cx| {
+			net.poll(cx);
+			if net.peer(1).client().header(hash).unwrap().is_some() {
+				Poll::Ready(())
+			} else {
+				Poll::Pending
+			}
+		})
+		.await;
+	}
+
+	// given the network with 2 full nodes
+	let mut net = TestNet::new(2);
+
+	// let them connect to each other
+	net.run_until_sync().await;
+
+	// check that NEW block is imported from announce message
+	let new_hash = net.peer(0).push_blocks(1, false).pop().unwrap();
+	import_with_announce(&mut net, new_hash).await;
+	assert_eq!(net.peer(1).num_downloaded_blocks().await, 1);
+
+	// check that KNOWN STALE block is imported from announce message
+	let known_stale_hash = net.peer(0).push_blocks_at(BlockId::Number(0), 1, true).pop().unwrap();
+	import_with_announce(&mut net, known_stale_hash).await;
+	assert_eq!(net.peer(1).num_downloaded_blocks().await, 2);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn can_sync_to_peers_with_wrong_common_block() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+
+	net.peer(0).push_blocks(2, true);
+	net.peer(1).push_blocks(2, true);
+	let fork_hash = net.peer(0).push_blocks_at(BlockId::Number(0), 2, false).pop().unwrap();
+	net.peer(1).push_blocks_at(BlockId::Number(0), 2, false);
+	// wait for connection
+	net.run_until_connected().await;
+
+	// both peers re-org to the same fork without notifying each other
+	let just = Some((*b"FRNK", Vec::new()));
+	net.peer(0).client().finalize_block(fork_hash, just.clone(), true).unwrap();
+	net.peer(1).client().finalize_block(fork_hash, just, true).unwrap();
+	let final_hash = net.peer(0).push_blocks(1, false).pop().unwrap();
+
+	net.run_until_sync().await;
+
+	assert!(net.peer(1).has_block(final_hash));
+}
+
+/// Returns `is_new_best = true` for each validated announcement.
+struct NewBestBlockAnnounceValidator;
+
+impl BlockAnnounceValidator<Block> for NewBestBlockAnnounceValidator {
+	fn validate(
+		&mut self,
+		_: &Header,
+		_: &[u8],
+	) -> Pin<Box<dyn Future<Output = Result<Validation, Box<dyn std::error::Error + Send>>> + Send>>
+	{
+		async { Ok(Validation::Success { is_new_best: true }) }.boxed()
+	}
+}
+
+/// Returns `Validation::Failure` for specified block number
+struct FailingBlockAnnounceValidator(u64);
+
+impl BlockAnnounceValidator<Block> for FailingBlockAnnounceValidator {
+	fn validate(
+		&mut self,
+		header: &Header,
+		_: &[u8],
+	) -> Pin<Box<dyn Future<Output = Result<Validation, Box<dyn std::error::Error + Send>>> + Send>>
+	{
+		let number = *header.number();
+		let target_number = self.0;
+		async move {
+			Ok(if number == target_number {
+				Validation::Failure { disconnect: false }
+			} else {
+				Validation::Success { is_new_best: true }
+			})
+		}
+		.boxed()
+	}
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_blocks_when_block_announce_validator_says_it_is_new_best() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(0);
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(FullPeerConfig {
+		block_announce_validator: Some(Box::new(NewBestBlockAnnounceValidator)),
+		..Default::default()
+	});
+
+	net.run_until_connected().await;
+
+	// Add blocks but don't set them as best
+	let block_hash = net
+		.peer(0)
+		.generate_blocks_with_fork_choice(
+			1,
+			BlockOrigin::Own,
+			|builder| builder.build().unwrap().block,
+			ForkChoiceStrategy::Custom(false),
+		)
+		.pop()
+		.unwrap();
+
+	while !net.peer(2).has_block(block_hash) {
+		net.run_until_idle().await;
+	}
+}
+
+/// Waits for some time until the validation is successfull.
+struct DeferredBlockAnnounceValidator;
+
+impl BlockAnnounceValidator<Block> for DeferredBlockAnnounceValidator {
+	fn validate(
+		&mut self,
+		_: &Header,
+		_: &[u8],
+	) -> Pin<Box<dyn Future<Output = Result<Validation, Box<dyn std::error::Error + Send>>> + Send>>
+	{
+		async {
+			futures_timer::Delay::new(std::time::Duration::from_millis(500)).await;
+			Ok(Validation::Success { is_new_best: false })
+		}
+		.boxed()
+	}
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn wait_until_deferred_block_announce_validation_is_ready() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(0);
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(FullPeerConfig {
+		block_announce_validator: Some(Box::new(NewBestBlockAnnounceValidator)),
+		..Default::default()
+	});
+
+	net.run_until_connected().await;
+
+	// Add blocks but don't set them as best
+	let block_hash = net
+		.peer(0)
+		.generate_blocks_with_fork_choice(
+			1,
+			BlockOrigin::Own,
+			|builder| builder.build().unwrap().block,
+			ForkChoiceStrategy::Custom(false),
+		)
+		.pop()
+		.unwrap();
+
+	while !net.peer(1).has_block(block_hash) {
+		net.run_until_idle().await;
+	}
+}
+
+/// When we don't inform the sync protocol about the best block, a node will not sync from us as the
+/// handshake is not does not contain our best block.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_to_tip_requires_that_sync_protocol_is_informed_about_best_block() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(1);
+
+	// Produce some blocks
+	let block_hash = net
+		.peer(0)
+		.push_blocks_at_without_informing_sync(BlockId::Number(0), 3, true, true)
+		.pop()
+		.unwrap();
+
+	// Add a node and wait until they are connected
+	net.add_full_peer_with_config(Default::default());
+	net.run_until_connected().await;
+	net.run_until_idle().await;
+
+	// The peer should not have synced the block.
+	assert!(!net.peer(1).has_block(block_hash));
+
+	// Make sync protocol aware of the best block
+	net.peer(0).sync_service().new_best_block_imported(block_hash, 3);
+	net.run_until_idle().await;
+
+	// Connect another node that should now sync to the tip
+	net.add_full_peer_with_config(FullPeerConfig {
+		connect_to_peers: Some(vec![0]),
+		..Default::default()
+	});
+
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(2).has_block(block_hash) {
+			Poll::Ready(())
+		} else {
+			Poll::Pending
+		}
+	})
+	.await;
+
+	// However peer 1 should still not have the block.
+	assert!(!net.peer(1).has_block(block_hash));
+}
+
+/// Ensures that if we as a syncing node sync to the tip while we are connected to another peer
+/// that is currently also doing a major sync.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn sync_to_tip_when_we_sync_together_with_multiple_peers() {
+	sp_tracing::try_init_simple();
+
+	let mut net = TestNet::new(3);
+
+	let block_hash = net
+		.peer(0)
+		.push_blocks_at_without_informing_sync(BlockId::Number(0), 10_000, false, false)
+		.pop()
+		.unwrap();
+
+	net.peer(1)
+		.push_blocks_at_without_informing_sync(BlockId::Number(0), 5_000, false, false);
+
+	net.run_until_connected().await;
+	net.run_until_idle().await;
+
+	assert!(!net.peer(2).has_block(block_hash));
+
+	net.peer(0).sync_service().new_best_block_imported(block_hash, 10_000);
+	net.peer(0).sync_service().announce_block(block_hash, None);
+
+	while !net.peer(2).has_block(block_hash) && !net.peer(1).has_block(block_hash) {
+		net.run_until_idle().await;
+	}
+}
+
+/// Ensures that when we receive a block announcement with some data attached, that we propagate
+/// this data when reannouncing the block.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn block_announce_data_is_propagated() {
+	struct TestBlockAnnounceValidator;
+
+	impl BlockAnnounceValidator<Block> for TestBlockAnnounceValidator {
+		fn validate(
+			&mut self,
+			_: &Header,
+			data: &[u8],
+		) -> Pin<
+			Box<dyn Future<Output = Result<Validation, Box<dyn std::error::Error + Send>>> + Send>,
+		> {
+			let correct = data.get(0) == Some(&137);
+			async move {
+				if correct {
+					Ok(Validation::Success { is_new_best: true })
+				} else {
+					Ok(Validation::Failure { disconnect: false })
+				}
+			}
+			.boxed()
+		}
+	}
+
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(1);
+
+	net.add_full_peer_with_config(FullPeerConfig {
+		block_announce_validator: Some(Box::new(TestBlockAnnounceValidator)),
+		..Default::default()
+	});
+
+	net.add_full_peer_with_config(FullPeerConfig {
+		block_announce_validator: Some(Box::new(TestBlockAnnounceValidator)),
+		connect_to_peers: Some(vec![1]),
+		..Default::default()
+	});
+
+	// Wait until peer 1 is connected to both nodes.
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(1).num_peers() == 2 &&
+			net.peer(0).num_peers() == 1 &&
+			net.peer(2).num_peers() == 1
+		{
+			Poll::Ready(())
+		} else {
+			Poll::Pending
+		}
+	})
+	.await;
+
+	let block_hash = net
+		.peer(0)
+		.push_blocks_at_without_announcing(BlockId::Number(0), 1, true)
+		.pop()
+		.unwrap();
+	net.peer(0).announce_block(block_hash, Some(vec![137]));
+
+	while !net.peer(1).has_block(block_hash) || !net.peer(2).has_block(block_hash) {
+		net.run_until_idle().await;
+	}
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn continue_to_sync_after_some_block_announcement_verifications_failed() {
+	struct TestBlockAnnounceValidator;
+
+	impl BlockAnnounceValidator<Block> for TestBlockAnnounceValidator {
+		fn validate(
+			&mut self,
+			header: &Header,
+			_: &[u8],
+		) -> Pin<
+			Box<dyn Future<Output = Result<Validation, Box<dyn std::error::Error + Send>>> + Send>,
+		> {
+			let number = *header.number();
+			async move {
+				if number < 100 {
+					Err(Box::<dyn std::error::Error + Send + Sync>::from(String::from("error"))
+						as Box<_>)
+				} else {
+					Ok(Validation::Success { is_new_best: false })
+				}
+			}
+			.boxed()
+		}
+	}
+
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(1);
+
+	net.add_full_peer_with_config(FullPeerConfig {
+		block_announce_validator: Some(Box::new(TestBlockAnnounceValidator)),
+		..Default::default()
+	});
+
+	net.run_until_connected().await;
+	net.run_until_idle().await;
+
+	let block_hash = net.peer(0).push_blocks(500, true).pop().unwrap();
+
+	net.run_until_sync().await;
+	assert!(net.peer(1).has_block(block_hash));
+}
+
+/// When being spammed by the same request of a peer, we ban this peer. However, we should only ban
+/// this peer if the request was successful. In the case of a justification request for example,
+/// we ask our peers multiple times until we got the requested justification. This test ensures that
+/// asking for the same justification multiple times doesn't ban a peer.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn multiple_requests_are_accepted_as_long_as_they_are_not_fulfilled() {
+	sp_tracing::try_init_simple();
+	let mut net = JustificationTestNet::new(2);
+	let hashes = net.peer(0).push_blocks(10, false);
+	net.run_until_sync().await;
+
+	// there's currently no justification for block #10
+	let hashof10 = hashes[9];
+	assert_eq!(net.peer(0).client().justifications(hashof10).unwrap(), None);
+	assert_eq!(net.peer(1).client().justifications(hashof10).unwrap(), None);
+
+	// Let's assume block 10 was finalized, but we still need the justification from the network.
+	net.peer(1).request_justification(&hashof10, 10);
+
+	// Let's build some more blocks and wait always for the network to have synced them
+	for _ in 0..5 {
+		// We need to sleep 10 seconds as this is the time we wait between sending a new
+		// justification request.
+		tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
+		net.peer(0).push_blocks(1, false);
+		net.run_until_sync().await;
+		assert_eq!(1, net.peer(0).num_peers());
+	}
+
+	let hashof10 = hashes[9];
+	// Finalize the 10th block and make the justification available.
+	net.peer(0)
+		.client()
+		.finalize_block(hashof10, Some((*b"FRNK", Vec::new())), true)
+		.unwrap();
+
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+
+		if net.peer(1).client().justifications(hashof10).unwrap() !=
+			Some(Justifications::from((*b"FRNK", Vec::new())))
+		{
+			return Poll::Pending
+		}
+
+		Poll::Ready(())
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn syncs_all_forks_from_single_peer() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+	net.peer(0).push_blocks(10, false);
+	net.peer(1).push_blocks(10, false);
+
+	// poll until the two nodes connect, otherwise announcing the block will not work
+	net.run_until_connected().await;
+
+	// Peer 0 produces new blocks and announces.
+	let branch1 = net.peer(0).push_blocks_at(BlockId::Number(10), 2, true).pop().unwrap();
+
+	// Wait till peer 1 starts downloading
+	loop {
+		futures::future::poll_fn::<(), _>(|cx| {
+			net.poll(cx);
+			Poll::Ready(())
+		})
+		.await;
+
+		if net.peer(1).sync_service().best_seen_block().await.unwrap() == Some(12) {
+			break
+		}
+	}
+
+	// Peer 0 produces and announces another fork
+	let branch2 = net.peer(0).push_blocks_at(BlockId::Number(10), 2, false).pop().unwrap();
+
+	net.run_until_sync().await;
+
+	// Peer 1 should have both branches,
+	assert!(net.peer(1).client().header(branch1).unwrap().is_some());
+	assert!(net.peer(1).client().header(branch2).unwrap().is_some());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn syncs_after_missing_announcement() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(0);
+	net.add_full_peer_with_config(Default::default());
+	// Set peer 1 to ignore announcement
+	net.add_full_peer_with_config(FullPeerConfig {
+		block_announce_validator: Some(Box::new(FailingBlockAnnounceValidator(11))),
+		..Default::default()
+	});
+	net.peer(0).push_blocks(10, false);
+	net.peer(1).push_blocks(10, false);
+
+	net.run_until_connected().await;
+
+	// Peer 0 produces a new block and announces. Peer 1 ignores announcement.
+	net.peer(0).push_blocks_at(BlockId::Number(10), 1, false);
+	// Peer 0 produces another block and announces.
+	let final_block = net.peer(0).push_blocks_at(BlockId::Number(11), 1, false).pop().unwrap();
+	net.peer(1).push_blocks_at(BlockId::Number(10), 1, true);
+	net.run_until_sync().await;
+	assert!(net.peer(1).client().header(final_block).unwrap().is_some());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn syncs_state() {
+	sp_tracing::try_init_simple();
+	for skip_proofs in &[false, true] {
+		let mut net = TestNet::new(0);
+		let mut genesis_storage: sp_core::storage::Storage = Default::default();
+		genesis_storage.top.insert(b"additional_key".to_vec(), vec![1]);
+		let mut child_data: std::collections::BTreeMap<Vec<u8>, Vec<u8>> = Default::default();
+		for i in 0u8..16 {
+			child_data.insert(vec![i; 5], vec![i; 33]);
+		}
+		let child1 = sp_core::storage::StorageChild {
+			data: child_data.clone(),
+			child_info: sp_core::storage::ChildInfo::new_default(b"child1"),
+		};
+		let child3 = sp_core::storage::StorageChild {
+			data: child_data.clone(),
+			child_info: sp_core::storage::ChildInfo::new_default(b"child3"),
+		};
+		for i in 22u8..33 {
+			child_data.insert(vec![i; 5], vec![i; 33]);
+		}
+		let child2 = sp_core::storage::StorageChild {
+			data: child_data.clone(),
+			child_info: sp_core::storage::ChildInfo::new_default(b"child2"),
+		};
+		genesis_storage
+			.children_default
+			.insert(child1.child_info.storage_key().to_vec(), child1);
+		genesis_storage
+			.children_default
+			.insert(child2.child_info.storage_key().to_vec(), child2);
+		genesis_storage
+			.children_default
+			.insert(child3.child_info.storage_key().to_vec(), child3);
+		let mut config_one = FullPeerConfig::default();
+		config_one.extra_storage = Some(genesis_storage.clone());
+		net.add_full_peer_with_config(config_one);
+		let mut config_two = FullPeerConfig::default();
+		config_two.extra_storage = Some(genesis_storage);
+		config_two.sync_mode =
+			SyncMode::LightState { skip_proofs: *skip_proofs, storage_chain_mode: false };
+		net.add_full_peer_with_config(config_two);
+		let hashes = net.peer(0).push_blocks(64, false);
+		// Wait for peer 1 to sync header chain.
+		net.run_until_sync().await;
+		assert!(!net.peer(1).client().has_state_at(&BlockId::Number(64)));
+
+		let just = (*b"FRNK", Vec::new());
+		let hashof60 = hashes[59];
+		net.peer(1).client().finalize_block(hashof60, Some(just), true).unwrap();
+		// Wait for state sync.
+		futures::future::poll_fn::<(), _>(|cx| {
+			net.poll(cx);
+			if net.peer(1).client.info().finalized_state.is_some() {
+				Poll::Ready(())
+			} else {
+				Poll::Pending
+			}
+		})
+		.await;
+		assert!(!net.peer(1).client().has_state_at(&BlockId::Number(64)));
+		// Wait for the rest of the states to be imported.
+		futures::future::poll_fn::<(), _>(|cx| {
+			net.poll(cx);
+			if net.peer(1).client().has_state_at(&BlockId::Number(64)) {
+				Poll::Ready(())
+			} else {
+				Poll::Pending
+			}
+		})
+		.await;
+	}
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn syncs_indexed_blocks() {
+	use sp_runtime::traits::Hash;
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(0);
+	let mut n: u64 = 0;
+	net.add_full_peer_with_config(FullPeerConfig { storage_chain: true, ..Default::default() });
+	net.add_full_peer_with_config(FullPeerConfig {
+		storage_chain: true,
+		sync_mode: SyncMode::LightState { skip_proofs: false, storage_chain_mode: true },
+		..Default::default()
+	});
+	net.peer(0).generate_blocks_at(
+		BlockId::number(0),
+		64,
+		BlockOrigin::Own,
+		|mut builder| {
+			let ex = ExtrinsicBuilder::new_indexed_call(n.to_le_bytes().to_vec()).nonce(n).build();
+			n += 1;
+			builder.push(ex).unwrap();
+			builder.build().unwrap().block
+		},
+		false,
+		true,
+		true,
+		ForkChoiceStrategy::LongestChain,
+	);
+	let indexed_key = sp_runtime::traits::BlakeTwo256::hash(&42u64.to_le_bytes());
+	assert!(net
+		.peer(0)
+		.client()
+		.as_client()
+		.indexed_transaction(indexed_key)
+		.unwrap()
+		.is_some());
+	assert!(net
+		.peer(1)
+		.client()
+		.as_client()
+		.indexed_transaction(indexed_key)
+		.unwrap()
+		.is_none());
+
+	net.run_until_sync().await;
+	assert!(net
+		.peer(1)
+		.client()
+		.as_client()
+		.indexed_transaction(indexed_key)
+		.unwrap()
+		.is_some());
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn warp_sync() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(0);
+	// Create 3 synced peers and 1 peer trying to warp sync.
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(FullPeerConfig {
+		sync_mode: SyncMode::Warp,
+		..Default::default()
+	});
+	let gap_end = net.peer(0).push_blocks(63, false).pop().unwrap();
+	let target = net.peer(0).push_blocks(1, false).pop().unwrap();
+	net.peer(1).push_blocks(64, false);
+	net.peer(2).push_blocks(64, false);
+	// Wait for peer 1 to sync state.
+	net.run_until_sync().await;
+	assert!(!net.peer(3).client().has_state_at(&BlockId::Number(1)));
+	assert!(net.peer(3).client().has_state_at(&BlockId::Number(64)));
+
+	// Wait for peer 1 download block history
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		if net.peer(3).has_body(gap_end) && net.peer(3).has_body(target) {
+			Poll::Ready(())
+		} else {
+			Poll::Pending
+		}
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn warp_sync_to_target_block() {
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(0);
+	// Create 3 synced peers and 1 peer trying to warp sync.
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(Default::default());
+	net.add_full_peer_with_config(Default::default());
+
+	let blocks = net.peer(0).push_blocks(64, false);
+	let target = blocks[63];
+	net.peer(1).push_blocks(64, false);
+	net.peer(2).push_blocks(64, false);
+
+	let target_block = net.peer(0).client.header(target).unwrap().unwrap();
+
+	net.add_full_peer_with_config(FullPeerConfig {
+		sync_mode: SyncMode::Warp,
+		target_block: Some(target_block),
+		..Default::default()
+	});
+
+	net.run_until_sync().await;
+	assert!(net.peer(3).client().has_state_at(&BlockId::Number(64)));
+
+	// Wait for peer 1 download block history
+	futures::future::poll_fn::<(), _>(|cx| {
+		net.poll(cx);
+		let peer = net.peer(3);
+		if blocks.iter().all(|b| peer.has_body(*b)) {
+			Poll::Ready(())
+		} else {
+			Poll::Pending
+		}
+	})
+	.await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn syncs_huge_blocks() {
+	use sp_core::storage::well_known_keys::HEAP_PAGES;
+	use sp_runtime::codec::Encode;
+	use substrate_test_runtime_client::BlockBuilderExt;
+
+	sp_tracing::try_init_simple();
+	let mut net = TestNet::new(2);
+
+	// Increase heap space for bigger blocks.
+	net.peer(0).generate_blocks(1, BlockOrigin::Own, |mut builder| {
+		builder.push_storage_change(HEAP_PAGES.to_vec(), Some(256u64.encode())).unwrap();
+		builder.build().unwrap().block
+	});
+
+	let mut nonce = 0;
+	net.peer(0).generate_blocks(32, BlockOrigin::Own, |mut builder| {
+		// Add 32 extrinsics 32k each = 1MiB total
+		for _ in 0..32u64 {
+			let ex = ExtrinsicBuilder::new_include_data(vec![42u8; 32 * 1024]).nonce(nonce).build();
+			builder.push(ex).unwrap();
+			nonce += 1;
+		}
+		builder.build().unwrap().block
+	});
+
+	net.run_until_sync().await;
+	assert_eq!(net.peer(0).client.info().best_number, 33);
+	assert_eq!(net.peer(1).client.info().best_number, 33);
+}
diff --git a/substrate/client/network/transactions/Cargo.toml b/substrate/client/network/transactions/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ce62c89e8a55aec4fdc34ffcaf3f456ae05de33b
--- /dev/null
+++ b/substrate/client/network/transactions/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+description = "Substrate transaction protocol"
+name = "sc-network-transactions"
+version = "0.10.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-network-transactions"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+futures = "0.3.21"
+libp2p = "0.51.3"
+log = "0.4.17"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../../utils/prometheus" }
+sc-network = { version = "0.10.0-dev", path = "../" }
+sc-network-common = { version = "0.10.0-dev", path = "../common" }
+sc-utils = { version = "4.0.0-dev", path = "../../utils" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
diff --git a/substrate/client/network/transactions/src/config.rs b/substrate/client/network/transactions/src/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fdf81fcd9ff47123b2cd07d1307158b755436a69
--- /dev/null
+++ b/substrate/client/network/transactions/src/config.rs
@@ -0,0 +1,98 @@
+// 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/>.
+
+//! Configuration of the transaction protocol
+
+use futures::prelude::*;
+use sc_network_common::ExHashT;
+use sp_runtime::traits::Block as BlockT;
+use std::{collections::HashMap, future::Future, pin::Pin, time};
+
+/// Interval at which we propagate transactions;
+pub(crate) const PROPAGATE_TIMEOUT: time::Duration = time::Duration::from_millis(2900);
+
+/// Maximum number of known transaction hashes to keep for a peer.
+///
+/// This should be approx. 2 blocks full of transactions for the network to function properly.
+pub(crate) const MAX_KNOWN_TRANSACTIONS: usize = 10240; // ~300kb per peer + overhead.
+
+/// Maximum allowed size for a transactions notification.
+pub(crate) const MAX_TRANSACTIONS_SIZE: u64 = 16 * 1024 * 1024;
+
+/// Maximum number of transaction validation request we keep at any moment.
+pub(crate) const MAX_PENDING_TRANSACTIONS: usize = 8192;
+
+/// Result of the transaction import.
+#[derive(Clone, Copy, Debug)]
+pub enum TransactionImport {
+	/// Transaction is good but already known by the transaction pool.
+	KnownGood,
+	/// Transaction is good and not yet known.
+	NewGood,
+	/// Transaction is invalid.
+	Bad,
+	/// Transaction import was not performed.
+	None,
+}
+
+/// Future resolving to transaction import result.
+pub type TransactionImportFuture = Pin<Box<dyn Future<Output = TransactionImport> + Send>>;
+
+/// Transaction pool interface
+pub trait TransactionPool<H: ExHashT, B: BlockT>: Send + Sync {
+	/// Get transactions from the pool that are ready to be propagated.
+	fn transactions(&self) -> Vec<(H, B::Extrinsic)>;
+	/// Get hash of transaction.
+	fn hash_of(&self, transaction: &B::Extrinsic) -> H;
+	/// Import a transaction into the pool.
+	///
+	/// This will return future.
+	fn import(&self, transaction: B::Extrinsic) -> TransactionImportFuture;
+	/// Notify the pool about transactions broadcast.
+	fn on_broadcasted(&self, propagations: HashMap<H, Vec<String>>);
+	/// Get transaction by hash.
+	fn transaction(&self, hash: &H) -> Option<B::Extrinsic>;
+}
+
+/// Dummy implementation of the [`TransactionPool`] trait for a transaction pool that is always
+/// empty and discards all incoming transactions.
+///
+/// Requires the "hash" type to implement the `Default` trait.
+///
+/// Useful for testing purposes.
+pub struct EmptyTransactionPool;
+
+impl<H: ExHashT + Default, B: BlockT> TransactionPool<H, B> for EmptyTransactionPool {
+	fn transactions(&self) -> Vec<(H, B::Extrinsic)> {
+		Vec::new()
+	}
+
+	fn hash_of(&self, _transaction: &B::Extrinsic) -> H {
+		Default::default()
+	}
+
+	fn import(&self, _transaction: B::Extrinsic) -> TransactionImportFuture {
+		Box::pin(future::ready(TransactionImport::KnownGood))
+	}
+
+	fn on_broadcasted(&self, _: HashMap<H, Vec<String>>) {}
+
+	fn transaction(&self, _h: &H) -> Option<B::Extrinsic> {
+		None
+	}
+}
diff --git a/substrate/client/network/transactions/src/lib.rs b/substrate/client/network/transactions/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b46733d427230e3a8e061ab427dd1a28114e247f
--- /dev/null
+++ b/substrate/client/network/transactions/src/lib.rs
@@ -0,0 +1,512 @@
+// 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/>.
+
+//! Transactions handling to plug on top of the network service.
+//!
+//! Usage:
+//!
+//! - Use [`TransactionsHandlerPrototype::new`] to create a prototype.
+//! - Pass the return value of [`TransactionsHandlerPrototype::set_config`] to the network
+//! configuration as an extra peers set.
+//! - Use [`TransactionsHandlerPrototype::build`] then [`TransactionsHandler::run`] to obtain a
+//! `Future` that processes transactions.
+
+use crate::config::*;
+
+use codec::{Decode, Encode};
+use futures::{prelude::*, stream::FuturesUnordered};
+use libp2p::{multiaddr, PeerId};
+use log::{debug, trace, warn};
+
+use prometheus_endpoint::{register, Counter, PrometheusError, Registry, U64};
+use sc_network::{
+	config::{NonDefaultSetConfig, NonReservedPeerMode, ProtocolId, SetConfig},
+	error,
+	event::Event,
+	types::ProtocolName,
+	utils::{interval, LruHashSet},
+	NetworkEventStream, NetworkNotification, NetworkPeers,
+};
+use sc_network_common::{
+	role::ObservedRole,
+	sync::{SyncEvent, SyncEventStream},
+	ExHashT,
+};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_runtime::traits::Block as BlockT;
+
+use std::{
+	collections::{hash_map::Entry, HashMap},
+	iter,
+	num::NonZeroUsize,
+	pin::Pin,
+	sync::Arc,
+	task::Poll,
+};
+
+pub mod config;
+
+/// A set of transactions.
+pub type Transactions<E> = Vec<E>;
+
+mod rep {
+	use sc_network::ReputationChange as Rep;
+	/// Reputation change when a peer sends us any transaction.
+	///
+	/// This forces node to verify it, thus the negative value here. Once transaction is verified,
+	/// reputation change should be refunded with `ANY_TRANSACTION_REFUND`
+	pub const ANY_TRANSACTION: Rep = Rep::new(-(1 << 4), "Any transaction");
+	/// Reputation change when a peer sends us any transaction that is not invalid.
+	pub const ANY_TRANSACTION_REFUND: Rep = Rep::new(1 << 4, "Any transaction (refund)");
+	/// Reputation change when a peer sends us an transaction that we didn't know about.
+	pub const GOOD_TRANSACTION: Rep = Rep::new(1 << 7, "Good transaction");
+	/// Reputation change when a peer sends us a bad transaction.
+	pub const BAD_TRANSACTION: Rep = Rep::new(-(1 << 12), "Bad transaction");
+}
+
+struct Metrics {
+	propagated_transactions: Counter<U64>,
+}
+
+impl Metrics {
+	fn register(r: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			propagated_transactions: register(
+				Counter::new(
+					"substrate_sync_propagated_transactions",
+					"Number of transactions propagated to at least one peer",
+				)?,
+				r,
+			)?,
+		})
+	}
+}
+
+struct PendingTransaction<H> {
+	validation: TransactionImportFuture,
+	tx_hash: H,
+}
+
+impl<H> Unpin for PendingTransaction<H> {}
+
+impl<H: ExHashT> Future for PendingTransaction<H> {
+	type Output = (H, TransactionImport);
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Self::Output> {
+		if let Poll::Ready(import_result) = self.validation.poll_unpin(cx) {
+			return Poll::Ready((self.tx_hash.clone(), import_result))
+		}
+
+		Poll::Pending
+	}
+}
+
+/// Prototype for a [`TransactionsHandler`].
+pub struct TransactionsHandlerPrototype {
+	protocol_name: ProtocolName,
+	fallback_protocol_names: Vec<ProtocolName>,
+}
+
+impl TransactionsHandlerPrototype {
+	/// Create a new instance.
+	pub fn new<Hash: AsRef<[u8]>>(
+		protocol_id: ProtocolId,
+		genesis_hash: Hash,
+		fork_id: Option<&str>,
+	) -> Self {
+		let genesis_hash = genesis_hash.as_ref();
+		let protocol_name = if let Some(fork_id) = fork_id {
+			format!("/{}/{}/transactions/1", array_bytes::bytes2hex("", genesis_hash), fork_id)
+		} else {
+			format!("/{}/transactions/1", array_bytes::bytes2hex("", genesis_hash))
+		};
+		let legacy_protocol_name = format!("/{}/transactions/1", protocol_id.as_ref());
+
+		Self {
+			protocol_name: protocol_name.into(),
+			fallback_protocol_names: iter::once(legacy_protocol_name.into()).collect(),
+		}
+	}
+
+	/// Returns the configuration of the set to put in the network configuration.
+	pub fn set_config(&self) -> NonDefaultSetConfig {
+		NonDefaultSetConfig {
+			notifications_protocol: self.protocol_name.clone(),
+			fallback_names: self.fallback_protocol_names.clone(),
+			max_notification_size: MAX_TRANSACTIONS_SIZE,
+			handshake: None,
+			set_config: SetConfig {
+				in_peers: 0,
+				out_peers: 0,
+				reserved_nodes: Vec::new(),
+				non_reserved_mode: NonReservedPeerMode::Deny,
+			},
+		}
+	}
+
+	/// Turns the prototype into the actual handler. Returns a controller that allows controlling
+	/// the behaviour of the handler while it's running.
+	///
+	/// Important: the transactions handler is initially disabled and doesn't gossip transactions.
+	/// Gossiping is enabled when major syncing is done.
+	pub fn build<
+		B: BlockT + 'static,
+		H: ExHashT,
+		N: NetworkPeers + NetworkEventStream + NetworkNotification,
+		S: SyncEventStream + sp_consensus::SyncOracle,
+	>(
+		self,
+		network: N,
+		sync: S,
+		transaction_pool: Arc<dyn TransactionPool<H, B>>,
+		metrics_registry: Option<&Registry>,
+	) -> error::Result<(TransactionsHandler<B, H, N, S>, TransactionsHandlerController<H>)> {
+		let net_event_stream = network.event_stream("transactions-handler-net");
+		let sync_event_stream = sync.event_stream("transactions-handler-sync");
+		let (to_handler, from_controller) = tracing_unbounded("mpsc_transactions_handler", 100_000);
+
+		let handler = TransactionsHandler {
+			protocol_name: self.protocol_name,
+			propagate_timeout: (Box::pin(interval(PROPAGATE_TIMEOUT))
+				as Pin<Box<dyn Stream<Item = ()> + Send>>)
+				.fuse(),
+			pending_transactions: FuturesUnordered::new(),
+			pending_transactions_peers: HashMap::new(),
+			network,
+			sync,
+			net_event_stream: net_event_stream.fuse(),
+			sync_event_stream: sync_event_stream.fuse(),
+			peers: HashMap::new(),
+			transaction_pool,
+			from_controller,
+			metrics: if let Some(r) = metrics_registry {
+				Some(Metrics::register(r)?)
+			} else {
+				None
+			},
+		};
+
+		let controller = TransactionsHandlerController { to_handler };
+
+		Ok((handler, controller))
+	}
+}
+
+/// Controls the behaviour of a [`TransactionsHandler`] it is connected to.
+pub struct TransactionsHandlerController<H: ExHashT> {
+	to_handler: TracingUnboundedSender<ToHandler<H>>,
+}
+
+impl<H: ExHashT> TransactionsHandlerController<H> {
+	/// You may call this when new transactions are imported by the transaction pool.
+	///
+	/// All transactions will be fetched from the `TransactionPool` that was passed at
+	/// initialization as part of the configuration and propagated to peers.
+	pub fn propagate_transactions(&self) {
+		let _ = self.to_handler.unbounded_send(ToHandler::PropagateTransactions);
+	}
+
+	/// You must call when new a transaction is imported by the transaction pool.
+	///
+	/// This transaction will be fetched from the `TransactionPool` that was passed at
+	/// initialization as part of the configuration and propagated to peers.
+	pub fn propagate_transaction(&self, hash: H) {
+		let _ = self.to_handler.unbounded_send(ToHandler::PropagateTransaction(hash));
+	}
+}
+
+enum ToHandler<H: ExHashT> {
+	PropagateTransactions,
+	PropagateTransaction(H),
+}
+
+/// Handler for transactions. Call [`TransactionsHandler::run`] to start the processing.
+pub struct TransactionsHandler<
+	B: BlockT + 'static,
+	H: ExHashT,
+	N: NetworkPeers + NetworkEventStream + NetworkNotification,
+	S: SyncEventStream + sp_consensus::SyncOracle,
+> {
+	protocol_name: ProtocolName,
+	/// Interval at which we call `propagate_transactions`.
+	propagate_timeout: stream::Fuse<Pin<Box<dyn Stream<Item = ()> + Send>>>,
+	/// Pending transactions verification tasks.
+	pending_transactions: FuturesUnordered<PendingTransaction<H>>,
+	/// As multiple peers can send us the same transaction, we group
+	/// these peers using the transaction hash while the transaction is
+	/// imported. This prevents that we import the same transaction
+	/// multiple times concurrently.
+	pending_transactions_peers: HashMap<H, Vec<PeerId>>,
+	/// Network service to use to send messages and manage peers.
+	network: N,
+	/// Syncing service.
+	sync: S,
+	/// Stream of networking events.
+	net_event_stream: stream::Fuse<Pin<Box<dyn Stream<Item = Event> + Send>>>,
+	/// Receiver for syncing-related events.
+	sync_event_stream: stream::Fuse<Pin<Box<dyn Stream<Item = SyncEvent> + Send>>>,
+	// All connected peers
+	peers: HashMap<PeerId, Peer<H>>,
+	transaction_pool: Arc<dyn TransactionPool<H, B>>,
+	from_controller: TracingUnboundedReceiver<ToHandler<H>>,
+	/// Prometheus metrics.
+	metrics: Option<Metrics>,
+}
+
+/// Peer information
+#[derive(Debug)]
+struct Peer<H: ExHashT> {
+	/// Holds a set of transactions known to this peer.
+	known_transactions: LruHashSet<H>,
+	role: ObservedRole,
+}
+
+impl<B, H, N, S> TransactionsHandler<B, H, N, S>
+where
+	B: BlockT + 'static,
+	H: ExHashT,
+	N: NetworkPeers + NetworkEventStream + NetworkNotification,
+	S: SyncEventStream + sp_consensus::SyncOracle,
+{
+	/// Turns the [`TransactionsHandler`] into a future that should run forever and not be
+	/// interrupted.
+	pub async fn run(mut self) {
+		loop {
+			futures::select! {
+				_ = self.propagate_timeout.next() => {
+					self.propagate_transactions();
+				},
+				(tx_hash, result) = self.pending_transactions.select_next_some() => {
+					if let Some(peers) = self.pending_transactions_peers.remove(&tx_hash) {
+						peers.into_iter().for_each(|p| self.on_handle_transaction_import(p, result));
+					} else {
+						warn!(target: "sub-libp2p", "Inconsistent state, no peers for pending transaction!");
+					}
+				},
+				network_event = self.net_event_stream.next() => {
+					if let Some(network_event) = network_event {
+						self.handle_network_event(network_event).await;
+					} else {
+						// Networking has seemingly closed. Closing as well.
+						return;
+					}
+				},
+				sync_event = self.sync_event_stream.next() => {
+					if let Some(sync_event) = sync_event {
+						self.handle_sync_event(sync_event);
+					} else {
+						// Syncing has seemingly closed. Closing as well.
+						return;
+					}
+				}
+				message = self.from_controller.select_next_some() => {
+					match message {
+						ToHandler::PropagateTransaction(hash) => self.propagate_transaction(&hash),
+						ToHandler::PropagateTransactions => self.propagate_transactions(),
+					}
+				},
+			}
+		}
+	}
+
+	fn handle_sync_event(&mut self, event: SyncEvent) {
+		match event {
+			SyncEvent::PeerConnected(remote) => {
+				let addr = iter::once(multiaddr::Protocol::P2p(remote.into()))
+					.collect::<multiaddr::Multiaddr>();
+				let result = self.network.add_peers_to_reserved_set(
+					self.protocol_name.clone(),
+					iter::once(addr).collect(),
+				);
+				if let Err(err) = result {
+					log::error!(target: "sync", "Add reserved peer failed: {}", err);
+				}
+			},
+			SyncEvent::PeerDisconnected(remote) => {
+				let result = self.network.remove_peers_from_reserved_set(
+					self.protocol_name.clone(),
+					iter::once(remote).collect(),
+				);
+				if let Err(err) = result {
+					log::error!(target: "sync", "Remove reserved peer failed: {}", err);
+				}
+			},
+		}
+	}
+
+	async fn handle_network_event(&mut self, event: Event) {
+		match event {
+			Event::Dht(_) => {},
+			Event::NotificationStreamOpened { remote, protocol, role, .. }
+				if protocol == self.protocol_name =>
+			{
+				let _was_in = self.peers.insert(
+					remote,
+					Peer {
+						known_transactions: LruHashSet::new(
+							NonZeroUsize::new(MAX_KNOWN_TRANSACTIONS).expect("Constant is nonzero"),
+						),
+						role,
+					},
+				);
+				debug_assert!(_was_in.is_none());
+			},
+			Event::NotificationStreamClosed { remote, protocol }
+				if protocol == self.protocol_name =>
+			{
+				let _peer = self.peers.remove(&remote);
+				debug_assert!(_peer.is_some());
+			},
+
+			Event::NotificationsReceived { remote, messages } => {
+				for (protocol, message) in messages {
+					if protocol != self.protocol_name {
+						continue
+					}
+
+					if let Ok(m) =
+						<Transactions<B::Extrinsic> as Decode>::decode(&mut message.as_ref())
+					{
+						self.on_transactions(remote, m);
+					} else {
+						warn!(target: "sub-libp2p", "Failed to decode transactions list");
+					}
+				}
+			},
+
+			// Not our concern.
+			Event::NotificationStreamOpened { .. } | Event::NotificationStreamClosed { .. } => {},
+		}
+	}
+
+	/// Called when peer sends us new transactions
+	fn on_transactions(&mut self, who: PeerId, transactions: Transactions<B::Extrinsic>) {
+		// Accept transactions only when node is not major syncing
+		if self.sync.is_major_syncing() {
+			trace!(target: "sync", "{} Ignoring transactions while major syncing", who);
+			return
+		}
+
+		trace!(target: "sync", "Received {} transactions from {}", transactions.len(), who);
+		if let Some(ref mut peer) = self.peers.get_mut(&who) {
+			for t in transactions {
+				if self.pending_transactions.len() > MAX_PENDING_TRANSACTIONS {
+					debug!(
+						target: "sync",
+						"Ignoring any further transactions that exceed `MAX_PENDING_TRANSACTIONS`({}) limit",
+						MAX_PENDING_TRANSACTIONS,
+					);
+					break
+				}
+
+				let hash = self.transaction_pool.hash_of(&t);
+				peer.known_transactions.insert(hash.clone());
+
+				self.network.report_peer(who, rep::ANY_TRANSACTION);
+
+				match self.pending_transactions_peers.entry(hash.clone()) {
+					Entry::Vacant(entry) => {
+						self.pending_transactions.push(PendingTransaction {
+							validation: self.transaction_pool.import(t),
+							tx_hash: hash,
+						});
+						entry.insert(vec![who]);
+					},
+					Entry::Occupied(mut entry) => {
+						entry.get_mut().push(who);
+					},
+				}
+			}
+		}
+	}
+
+	fn on_handle_transaction_import(&mut self, who: PeerId, import: TransactionImport) {
+		match import {
+			TransactionImport::KnownGood =>
+				self.network.report_peer(who, rep::ANY_TRANSACTION_REFUND),
+			TransactionImport::NewGood => self.network.report_peer(who, rep::GOOD_TRANSACTION),
+			TransactionImport::Bad => self.network.report_peer(who, rep::BAD_TRANSACTION),
+			TransactionImport::None => {},
+		}
+	}
+
+	/// Propagate one transaction.
+	pub fn propagate_transaction(&mut self, hash: &H) {
+		// Accept transactions only when node is not major syncing
+		if self.sync.is_major_syncing() {
+			return
+		}
+
+		debug!(target: "sync", "Propagating transaction [{:?}]", hash);
+		if let Some(transaction) = self.transaction_pool.transaction(hash) {
+			let propagated_to = self.do_propagate_transactions(&[(hash.clone(), transaction)]);
+			self.transaction_pool.on_broadcasted(propagated_to);
+		}
+	}
+
+	fn do_propagate_transactions(
+		&mut self,
+		transactions: &[(H, B::Extrinsic)],
+	) -> HashMap<H, Vec<String>> {
+		let mut propagated_to = HashMap::<_, Vec<_>>::new();
+		let mut propagated_transactions = 0;
+
+		for (who, peer) in self.peers.iter_mut() {
+			// never send transactions to the light node
+			if matches!(peer.role, ObservedRole::Light) {
+				continue
+			}
+
+			let (hashes, to_send): (Vec<_>, Vec<_>) = transactions
+				.iter()
+				.filter(|(hash, _)| peer.known_transactions.insert(hash.clone()))
+				.cloned()
+				.unzip();
+
+			propagated_transactions += hashes.len();
+
+			if !to_send.is_empty() {
+				for hash in hashes {
+					propagated_to.entry(hash).or_default().push(who.to_base58());
+				}
+				trace!(target: "sync", "Sending {} transactions to {}", to_send.len(), who);
+				self.network
+					.write_notification(*who, self.protocol_name.clone(), to_send.encode());
+			}
+		}
+
+		if let Some(ref metrics) = self.metrics {
+			metrics.propagated_transactions.inc_by(propagated_transactions as _)
+		}
+
+		propagated_to
+	}
+
+	/// Call when we must propagate ready transactions to peers.
+	fn propagate_transactions(&mut self) {
+		// Accept transactions only when node is not major syncing
+		if self.sync.is_major_syncing() {
+			return
+		}
+
+		debug!(target: "sync", "Propagating transactions");
+		let transactions = self.transaction_pool.transactions();
+		let propagated_to = self.do_propagate_transactions(&transactions);
+		self.transaction_pool.on_broadcasted(propagated_to);
+	}
+}
diff --git a/substrate/client/offchain/Cargo.toml b/substrate/client/offchain/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f52b0aa2878f62ac2ffdf3ebd0050e52c26cf91f
--- /dev/null
+++ b/substrate/client/offchain/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+description = "Substrate offchain workers"
+name = "sc-offchain"
+version = "4.0.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+bytes = "1.1"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+fnv = "1.0.6"
+futures = "0.3.21"
+futures-timer = "3.0.2"
+hyper = { version = "0.14.16", features = ["stream", "http2"] }
+hyper-rustls = { version = "0.24.0", features = ["http2"] }
+libp2p = "0.51.3"
+num_cpus = "1.13"
+once_cell = "1.8"
+parking_lot = "0.12.1"
+rand = "0.8.5"
+threadpool = "1.7"
+tracing = "0.1.29"
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-network = { version = "0.10.0-dev", path = "../network" }
+sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../transaction-pool/api" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-offchain = { version = "4.0.0-dev", path = "../../primitives/offchain" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+sp-externalities = { version = "0.19.0", path = "../../primitives/externalities" }
+log = "0.4.17"
+
+[dev-dependencies]
+lazy_static = "1.4.0"
+tokio = "1.22.0"
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sc-client-db = { version = "0.10.0-dev", default-features = true, path = "../db" }
+sc-transaction-pool = { version = "4.0.0-dev", path = "../transaction-pool" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../transaction-pool/api" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+
+[features]
+default = []
diff --git a/substrate/client/offchain/README.md b/substrate/client/offchain/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f7c097e8e0b2a9e3ac07bbf0a41359aadf4a758f
--- /dev/null
+++ b/substrate/client/offchain/README.md
@@ -0,0 +1,18 @@
+Substrate offchain workers.
+
+The offchain workers is a special function of the runtime that
+gets executed after block is imported. During execution
+it's able to asynchronously submit extrinsics that will either
+be propagated to other nodes or added to the next block
+produced by the node as unsigned transactions.
+
+Offchain workers can be used for computation-heavy tasks
+that are not feasible for execution during regular block processing.
+It can either be tasks that no consensus is required for,
+or some form of consensus over the data can be built on-chain
+for instance via:
+1. Challenge period for incorrect computations
+2. Majority voting for results
+3. etc
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/offchain/src/api.rs b/substrate/client/offchain/src/api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c7df5784d329eecd299619e89f1f4f0eb6f0d319
--- /dev/null
+++ b/substrate/client/offchain/src/api.rs
@@ -0,0 +1,438 @@
+// 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 std::{collections::HashSet, str::FromStr, sync::Arc, thread::sleep};
+
+use crate::NetworkProvider;
+use codec::{Decode, Encode};
+use futures::Future;
+pub use http::SharedClient;
+use libp2p::{Multiaddr, PeerId};
+use sp_core::{
+	offchain::{
+		self, HttpError, HttpRequestId, HttpRequestStatus, OpaqueMultiaddr, OpaqueNetworkState,
+		Timestamp,
+	},
+	OpaquePeerId,
+};
+pub use sp_offchain::STORAGE_PREFIX;
+
+mod http;
+
+mod timestamp;
+
+/// Asynchronous offchain API.
+///
+/// NOTE this is done to prevent recursive calls into the runtime
+/// (which are not supported currently).
+pub(crate) struct Api {
+	/// A provider for substrate networking.
+	network_provider: Arc<dyn NetworkProvider + Send + Sync>,
+	/// Is this node a potential validator?
+	is_validator: bool,
+	/// Everything HTTP-related is handled by a different struct.
+	http: http::HttpApi,
+}
+
+impl offchain::Externalities for Api {
+	fn is_validator(&self) -> bool {
+		self.is_validator
+	}
+
+	fn network_state(&self) -> Result<OpaqueNetworkState, ()> {
+		let external_addresses = self.network_provider.external_addresses();
+
+		let state = NetworkState::new(self.network_provider.local_peer_id(), external_addresses);
+		Ok(OpaqueNetworkState::from(state))
+	}
+
+	fn timestamp(&mut self) -> Timestamp {
+		timestamp::now()
+	}
+
+	fn sleep_until(&mut self, deadline: Timestamp) {
+		sleep(timestamp::timestamp_from_now(deadline));
+	}
+
+	fn random_seed(&mut self) -> [u8; 32] {
+		rand::random()
+	}
+
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		_meta: &[u8],
+	) -> Result<HttpRequestId, ()> {
+		self.http.request_start(method, uri)
+	}
+
+	fn http_request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
+		self.http.request_add_header(request_id, name, value)
+	}
+
+	fn http_request_write_body(
+		&mut self,
+		request_id: HttpRequestId,
+		chunk: &[u8],
+		deadline: Option<Timestamp>,
+	) -> Result<(), HttpError> {
+		self.http.request_write_body(request_id, chunk, deadline)
+	}
+
+	fn http_response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus> {
+		self.http.response_wait(ids, deadline)
+	}
+
+	fn http_response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
+		self.http.response_headers(request_id)
+	}
+
+	fn http_response_read_body(
+		&mut self,
+		request_id: HttpRequestId,
+		buffer: &mut [u8],
+		deadline: Option<Timestamp>,
+	) -> Result<usize, HttpError> {
+		self.http.response_read_body(request_id, buffer, deadline)
+	}
+
+	fn set_authorized_nodes(&mut self, nodes: Vec<OpaquePeerId>, authorized_only: bool) {
+		let peer_ids: HashSet<PeerId> =
+			nodes.into_iter().filter_map(|node| PeerId::from_bytes(&node.0).ok()).collect();
+
+		self.network_provider.set_authorized_peers(peer_ids);
+		self.network_provider.set_authorized_only(authorized_only);
+	}
+}
+
+/// Information about the local node's network state.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct NetworkState {
+	peer_id: PeerId,
+	external_addresses: Vec<Multiaddr>,
+}
+
+impl NetworkState {
+	fn new(peer_id: PeerId, external_addresses: Vec<Multiaddr>) -> Self {
+		NetworkState { peer_id, external_addresses }
+	}
+}
+
+impl From<NetworkState> for OpaqueNetworkState {
+	fn from(state: NetworkState) -> OpaqueNetworkState {
+		let enc = Encode::encode(&state.peer_id.to_bytes());
+		let peer_id = OpaquePeerId::new(enc);
+
+		let external_addresses: Vec<OpaqueMultiaddr> = state
+			.external_addresses
+			.iter()
+			.map(|multiaddr| {
+				let e = Encode::encode(&multiaddr.to_string());
+				OpaqueMultiaddr::new(e)
+			})
+			.collect();
+
+		OpaqueNetworkState { peer_id, external_addresses }
+	}
+}
+
+impl TryFrom<OpaqueNetworkState> for NetworkState {
+	type Error = ();
+
+	fn try_from(state: OpaqueNetworkState) -> Result<Self, Self::Error> {
+		let inner_vec = state.peer_id.0;
+
+		let bytes: Vec<u8> = Decode::decode(&mut &inner_vec[..]).map_err(|_| ())?;
+		let peer_id = PeerId::from_bytes(&bytes).map_err(|_| ())?;
+
+		let external_addresses: Result<Vec<Multiaddr>, Self::Error> = state
+			.external_addresses
+			.iter()
+			.map(|enc_multiaddr| -> Result<Multiaddr, Self::Error> {
+				let inner_vec = &enc_multiaddr.0;
+				let bytes = <Vec<u8>>::decode(&mut &inner_vec[..]).map_err(|_| ())?;
+				let multiaddr_str = String::from_utf8(bytes).map_err(|_| ())?;
+				let multiaddr = Multiaddr::from_str(&multiaddr_str).map_err(|_| ())?;
+				Ok(multiaddr)
+			})
+			.collect();
+		let external_addresses = external_addresses?;
+
+		Ok(NetworkState { peer_id, external_addresses })
+	}
+}
+
+/// Offchain extensions implementation API
+///
+/// This is the asynchronous processing part of the API.
+pub(crate) struct AsyncApi {
+	/// Everything HTTP-related is handled by a different struct.
+	http: Option<http::HttpWorker>,
+}
+
+impl AsyncApi {
+	/// Creates new Offchain extensions API implementation and the asynchronous processing part.
+	pub fn new(
+		network_provider: Arc<dyn NetworkProvider + Send + Sync>,
+		is_validator: bool,
+		shared_http_client: SharedClient,
+	) -> (Api, Self) {
+		let (http_api, http_worker) = http::http(shared_http_client);
+
+		let api = Api { network_provider, is_validator, http: http_api };
+
+		let async_api = Self { http: Some(http_worker) };
+
+		(api, async_api)
+	}
+
+	/// Run a processing task for the API
+	pub fn process(self) -> impl Future<Output = ()> {
+		self.http.expect("`process` is only called once; qed")
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_client_db::offchain::LocalStorage;
+	use sc_network::{
+		config::MultiaddrWithPeerId, types::ProtocolName, NetworkPeers, NetworkStateInfo,
+		ReputationChange,
+	};
+	use sp_core::offchain::{storage::OffchainDb, DbExternalities, Externalities, StorageKind};
+	use std::time::SystemTime;
+
+	pub(super) struct TestNetwork();
+
+	impl NetworkPeers for TestNetwork {
+		fn set_authorized_peers(&self, _peers: HashSet<PeerId>) {
+			unimplemented!();
+		}
+
+		fn set_authorized_only(&self, _reserved_only: bool) {
+			unimplemented!();
+		}
+
+		fn add_known_address(&self, _peer_id: PeerId, _addr: Multiaddr) {
+			unimplemented!();
+		}
+
+		fn report_peer(&self, _who: PeerId, _cost_benefit: ReputationChange) {
+			unimplemented!();
+		}
+
+		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+			unimplemented!();
+		}
+
+		fn accept_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn deny_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn add_reserved_peer(&self, _peer: MultiaddrWithPeerId) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_reserved_peer(&self, _peer_id: PeerId) {
+			unimplemented!();
+		}
+
+		fn set_reserved_peers(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn add_peers_to_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_peers_from_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: Vec<PeerId>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn sync_num_connected(&self) -> usize {
+			unimplemented!();
+		}
+	}
+
+	impl NetworkStateInfo for TestNetwork {
+		fn external_addresses(&self) -> Vec<Multiaddr> {
+			Vec::new()
+		}
+
+		fn local_peer_id(&self) -> PeerId {
+			PeerId::random()
+		}
+
+		fn listen_addresses(&self) -> Vec<Multiaddr> {
+			Vec::new()
+		}
+	}
+
+	fn offchain_api() -> (Api, AsyncApi) {
+		sp_tracing::try_init_simple();
+		let mock = Arc::new(TestNetwork());
+		let shared_client = SharedClient::new();
+
+		AsyncApi::new(mock, false, shared_client)
+	}
+
+	fn offchain_db() -> OffchainDb<LocalStorage> {
+		OffchainDb::new(LocalStorage::new_test())
+	}
+
+	#[test]
+	fn should_get_timestamp() {
+		let mut api = offchain_api().0;
+
+		// Get timestamp from std.
+		let now = SystemTime::now();
+		let d: u64 = now
+			.duration_since(SystemTime::UNIX_EPOCH)
+			.unwrap()
+			.as_millis()
+			.try_into()
+			.unwrap();
+
+		// Get timestamp from offchain api.
+		let timestamp = api.timestamp();
+
+		// Compare.
+		assert!(timestamp.unix_millis() > 0);
+		assert!(timestamp.unix_millis() >= d);
+	}
+
+	#[test]
+	fn should_sleep() {
+		let mut api = offchain_api().0;
+
+		// Arrange.
+		let now = api.timestamp();
+		let delta = sp_core::offchain::Duration::from_millis(100);
+		let deadline = now.add(delta);
+
+		// Act.
+		api.sleep_until(deadline);
+		let new_now = api.timestamp();
+
+		// Assert.
+		// The diff could be more than the sleep duration.
+		assert!(new_now.unix_millis() - 100 >= now.unix_millis());
+	}
+
+	#[test]
+	fn should_set_and_get_local_storage() {
+		// given
+		let kind = StorageKind::PERSISTENT;
+		let mut api = offchain_db();
+		let key = b"test";
+
+		// when
+		assert_eq!(api.local_storage_get(kind, key), None);
+		api.local_storage_set(kind, key, b"value");
+
+		// then
+		assert_eq!(api.local_storage_get(kind, key), Some(b"value".to_vec()));
+	}
+
+	#[test]
+	fn should_compare_and_set_local_storage() {
+		// given
+		let kind = StorageKind::PERSISTENT;
+		let mut api = offchain_db();
+		let key = b"test";
+		api.local_storage_set(kind, key, b"value");
+
+		// when
+		assert_eq!(api.local_storage_compare_and_set(kind, key, Some(b"val"), b"xxx"), false);
+		assert_eq!(api.local_storage_get(kind, key), Some(b"value".to_vec()));
+
+		// when
+		assert_eq!(api.local_storage_compare_and_set(kind, key, Some(b"value"), b"xxx"), true);
+		assert_eq!(api.local_storage_get(kind, key), Some(b"xxx".to_vec()));
+	}
+
+	#[test]
+	fn should_compare_and_set_local_storage_with_none() {
+		// given
+		let kind = StorageKind::PERSISTENT;
+		let mut api = offchain_db();
+		let key = b"test";
+
+		// when
+		let res = api.local_storage_compare_and_set(kind, key, None, b"value");
+
+		// then
+		assert_eq!(res, true);
+		assert_eq!(api.local_storage_get(kind, key), Some(b"value".to_vec()));
+	}
+
+	#[test]
+	fn should_convert_network_states() {
+		// given
+		let state = NetworkState::new(
+			PeerId::random(),
+			vec![
+				Multiaddr::try_from("/ip4/127.0.0.1/tcp/1234".to_string()).unwrap(),
+				Multiaddr::try_from("/ip6/2601:9:4f81:9700:803e:ca65:66e8:c21").unwrap(),
+			],
+		);
+
+		// when
+		let opaque_state = OpaqueNetworkState::from(state.clone());
+		let converted_back_state = NetworkState::try_from(opaque_state).unwrap();
+
+		// then
+		assert_eq!(state, converted_back_state);
+	}
+
+	#[test]
+	fn should_get_random_seed() {
+		// given
+		let mut api = offchain_api().0;
+		let seed = api.random_seed();
+		// then
+		assert_ne!(seed, [0; 32]);
+	}
+}
diff --git a/substrate/client/offchain/src/api/http.rs b/substrate/client/offchain/src/api/http.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7ca5e3fd13af788c7dee986202471a4ad2a9de6e
--- /dev/null
+++ b/substrate/client/offchain/src/api/http.rs
@@ -0,0 +1,1130 @@
+// 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/>.
+
+//! This module is composed of two structs: [`HttpApi`] and [`HttpWorker`]. Calling the [`http`]
+//! function returns a pair of [`HttpApi`] and [`HttpWorker`] that share some state.
+//!
+//! The [`HttpApi`] is (indirectly) passed to the runtime when calling an offchain worker, while
+//! the [`HttpWorker`] must be processed in the background. The [`HttpApi`] mimics the API of the
+//! HTTP-related methods available to offchain workers.
+//!
+//! The reason for this design is driven by the fact that HTTP requests should continue running
+//! (i.e.: the socket should continue being processed) in the background even if the runtime isn't
+//! actively calling any function.
+
+use crate::api::timestamp;
+use bytes::buf::{Buf, Reader};
+use fnv::FnvHashMap;
+use futures::{channel::mpsc, future, prelude::*};
+use hyper::{client, Body, Client as HyperClient};
+use hyper_rustls::{HttpsConnector, HttpsConnectorBuilder};
+use once_cell::sync::Lazy;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_core::offchain::{HttpError, HttpRequestId, HttpRequestStatus, Timestamp};
+use std::{
+	fmt,
+	io::Read as _,
+	pin::Pin,
+	sync::Arc,
+	task::{Context, Poll},
+};
+
+const LOG_TARGET: &str = "offchain-worker::http";
+
+/// Wrapper struct used for keeping the hyper_rustls client running.
+#[derive(Clone)]
+pub struct SharedClient(Arc<Lazy<HyperClient<HttpsConnector<client::HttpConnector>, Body>>>);
+
+impl SharedClient {
+	pub fn new() -> Self {
+		Self(Arc::new(Lazy::new(|| {
+			let connector = HttpsConnectorBuilder::new()
+				.with_native_roots()
+				.https_or_http()
+				.enable_http1()
+				.enable_http2()
+				.build();
+			HyperClient::builder().build(connector)
+		})))
+	}
+}
+
+/// Creates a pair of [`HttpApi`] and [`HttpWorker`].
+pub fn http(shared_client: SharedClient) -> (HttpApi, HttpWorker) {
+	let (to_worker, from_api) = tracing_unbounded("mpsc_ocw_to_worker", 100_000);
+	let (to_api, from_worker) = tracing_unbounded("mpsc_ocw_to_api", 100_000);
+
+	let api = HttpApi {
+		to_worker,
+		from_worker: from_worker.fuse(),
+		// We start with a random ID for the first HTTP request, to prevent mischievous people from
+		// writing runtime code with hardcoded IDs.
+		next_id: HttpRequestId(rand::random::<u16>() % 2000),
+		requests: FnvHashMap::default(),
+	};
+
+	let engine =
+		HttpWorker { to_api, from_api, http_client: shared_client.0, requests: Vec::new() };
+
+	(api, engine)
+}
+
+/// Provides HTTP capabilities.
+///
+/// Since this struct is a helper for offchain workers, its API is mimicking the API provided
+/// to offchain workers.
+pub struct HttpApi {
+	/// Used to sends messages to the worker.
+	to_worker: TracingUnboundedSender<ApiToWorker>,
+	/// Used to receive messages from the worker.
+	/// We use a `Fuse` in order to have an extra protection against panicking.
+	from_worker: stream::Fuse<TracingUnboundedReceiver<WorkerToApi>>,
+	/// Id to assign to the next HTTP request that is started.
+	next_id: HttpRequestId,
+	/// List of HTTP requests in preparation or in progress.
+	requests: FnvHashMap<HttpRequestId, HttpApiRequest>,
+}
+
+/// One active request within `HttpApi`.
+enum HttpApiRequest {
+	/// The request object is being constructed locally and not started yet.
+	NotDispatched(hyper::Request<hyper::Body>, hyper::body::Sender),
+	/// The request has been dispatched and we're in the process of sending out the body (if the
+	/// field is `Some`) or waiting for a response (if the field is `None`).
+	Dispatched(Option<hyper::body::Sender>),
+	/// Received a response.
+	Response(HttpApiRequestRp),
+	/// A request has been dispatched but the worker notified us of an error. We report this
+	/// failure to the user as an `IoError` and remove the request from the list as soon as
+	/// possible.
+	Fail(hyper::Error),
+}
+
+/// A request within `HttpApi` that has received a response.
+struct HttpApiRequestRp {
+	/// We might still be writing the request's body when the response comes.
+	/// This field allows to continue writing that body.
+	sending_body: Option<hyper::body::Sender>,
+	/// Status code of the response.
+	status_code: hyper::StatusCode,
+	/// Headers of the response.
+	headers: hyper::HeaderMap,
+	/// Body of the response, as a channel of `Chunk` objects.
+	/// While the code is designed to drop the `Receiver` once it ends, we wrap it within a
+	/// `Fuse` in order to be extra precautious about panics.
+	/// Elements extracted from the channel are first put into `current_read_chunk`.
+	/// If the channel produces an error, then that is translated into an `IoError` and the request
+	/// is removed from the list.
+	body: stream::Fuse<mpsc::Receiver<Result<hyper::body::Bytes, hyper::Error>>>,
+	/// Chunk that has been extracted from the channel and that is currently being read.
+	/// Reading data from the response should read from this field in priority.
+	current_read_chunk: Option<Reader<hyper::body::Bytes>>,
+}
+
+impl HttpApi {
+	/// Mimics the corresponding method in the offchain API.
+	pub fn request_start(&mut self, method: &str, uri: &str) -> Result<HttpRequestId, ()> {
+		// Start by building the prototype of the request.
+		// We do this first so that we don't touch anything in `self` if building the prototype
+		// fails.
+		let (body_sender, body) = hyper::Body::channel();
+		let mut request = hyper::Request::new(body);
+		*request.method_mut() = hyper::Method::from_bytes(method.as_bytes()).map_err(|_| ())?;
+		*request.uri_mut() = hyper::Uri::from_maybe_shared(uri.to_owned()).map_err(|_| ())?;
+
+		let new_id = self.next_id;
+		debug_assert!(!self.requests.contains_key(&new_id));
+		match self.next_id.0.checked_add(1) {
+			Some(new_id) => self.next_id.0 = new_id,
+			None => {
+				tracing::error!(
+					target: LOG_TARGET,
+					"Overflow in offchain worker HTTP request ID assignment"
+				);
+				return Err(())
+			},
+		};
+		self.requests
+			.insert(new_id, HttpApiRequest::NotDispatched(request, body_sender));
+
+		tracing::trace!(
+			target: LOG_TARGET,
+			id = %new_id.0,
+			%method,
+			%uri,
+			"Requested started",
+		);
+
+		Ok(new_id)
+	}
+
+	/// Mimics the corresponding method in the offchain API.
+	pub fn request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
+		let request = match self.requests.get_mut(&request_id) {
+			Some(&mut HttpApiRequest::NotDispatched(ref mut rq, _)) => rq,
+			_ => return Err(()),
+		};
+
+		let header_name = hyper::header::HeaderName::try_from(name).map_err(drop)?;
+		let header_value = hyper::header::HeaderValue::try_from(value).map_err(drop)?;
+		// Note that we're always appending headers and never replacing old values.
+		// We assume here that the user knows what they're doing.
+		request.headers_mut().append(header_name, header_value);
+
+		tracing::debug!(target: LOG_TARGET, id = %request_id.0, %name, %value, "Added header to request");
+
+		Ok(())
+	}
+
+	/// Mimics the corresponding method in the offchain API.
+	pub fn request_write_body(
+		&mut self,
+		request_id: HttpRequestId,
+		chunk: &[u8],
+		deadline: Option<Timestamp>,
+	) -> Result<(), HttpError> {
+		// Extract the request from the list.
+		// Don't forget to add it back if necessary when returning.
+		let mut request = self.requests.remove(&request_id).ok_or(HttpError::Invalid)?;
+
+		let mut deadline = timestamp::deadline_to_future(deadline);
+		// Closure that writes data to a sender, taking the deadline into account. Can return `Ok`
+		// (if the body has been written), or `DeadlineReached`, or `IoError`.
+		// If `IoError` is returned, don't forget to remove the request from the list.
+		let mut poll_sender = move |sender: &mut hyper::body::Sender| -> Result<(), HttpError> {
+			let mut when_ready = future::maybe_done(future::poll_fn(|cx| sender.poll_ready(cx)));
+			futures::executor::block_on(future::select(&mut when_ready, &mut deadline));
+			match when_ready {
+				future::MaybeDone::Done(Ok(())) => {},
+				future::MaybeDone::Done(Err(_)) => return Err(HttpError::IoError),
+				future::MaybeDone::Future(_) | future::MaybeDone::Gone => {
+					debug_assert!(matches!(deadline, future::MaybeDone::Done(..)));
+					return Err(HttpError::DeadlineReached)
+				},
+			};
+
+			futures::executor::block_on(
+				sender.send_data(hyper::body::Bytes::from(chunk.to_owned())),
+			)
+			.map_err(|_| {
+				tracing::error!(target: "offchain-worker::http", "HTTP sender refused data despite being ready");
+				HttpError::IoError
+			})
+		};
+
+		loop {
+			request = match request {
+				HttpApiRequest::NotDispatched(request, sender) => {
+					tracing::debug!(target: LOG_TARGET, id = %request_id.0, "Added new body chunk");
+					// If the request is not dispatched yet, dispatch it and loop again.
+					let _ = self
+						.to_worker
+						.unbounded_send(ApiToWorker::Dispatch { id: request_id, request });
+					HttpApiRequest::Dispatched(Some(sender))
+				},
+
+				HttpApiRequest::Dispatched(Some(mut sender)) => {
+					if !chunk.is_empty() {
+						match poll_sender(&mut sender) {
+							Err(HttpError::IoError) => {
+								tracing::debug!(target: LOG_TARGET, id = %request_id.0, "Encountered io error while trying to add new chunk to body");
+								return Err(HttpError::IoError)
+							},
+							other => {
+								tracing::debug!(target: LOG_TARGET, id = %request_id.0, res = ?other, "Added chunk to body");
+								self.requests
+									.insert(request_id, HttpApiRequest::Dispatched(Some(sender)));
+								return other
+							},
+						}
+					} else {
+						tracing::debug!(target: LOG_TARGET, id = %request_id.0, "Finished writing body");
+
+						// Writing an empty body is a hint that we should stop writing. Dropping
+						// the sender.
+						self.requests.insert(request_id, HttpApiRequest::Dispatched(None));
+						return Ok(())
+					}
+				},
+
+				HttpApiRequest::Response(
+					mut response @ HttpApiRequestRp { sending_body: Some(_), .. },
+				) => {
+					if !chunk.is_empty() {
+						match poll_sender(
+							response
+								.sending_body
+								.as_mut()
+								.expect("Can only enter this match branch if Some; qed"),
+						) {
+							Err(HttpError::IoError) => {
+								tracing::debug!(target: LOG_TARGET, id = %request_id.0, "Encountered io error while trying to add new chunk to body");
+								return Err(HttpError::IoError)
+							},
+							other => {
+								tracing::debug!(target: LOG_TARGET, id = %request_id.0, res = ?other, "Added chunk to body");
+								self.requests
+									.insert(request_id, HttpApiRequest::Response(response));
+								return other
+							},
+						}
+					} else {
+						tracing::debug!(target: LOG_TARGET, id = %request_id.0, "Finished writing body");
+
+						// Writing an empty body is a hint that we should stop writing. Dropping
+						// the sender.
+						self.requests.insert(
+							request_id,
+							HttpApiRequest::Response(HttpApiRequestRp {
+								sending_body: None,
+								..response
+							}),
+						);
+						return Ok(())
+					}
+				},
+
+				HttpApiRequest::Fail(error) => {
+					tracing::debug!(target: LOG_TARGET, id = %request_id.0, ?error, "Request failed");
+
+					// If the request has already failed, return without putting back the request
+					// in the list.
+					return Err(HttpError::IoError)
+				},
+
+				v @ HttpApiRequest::Dispatched(None) |
+				v @ HttpApiRequest::Response(HttpApiRequestRp { sending_body: None, .. }) => {
+					tracing::debug!(target: LOG_TARGET, id = %request_id.0, "Body sending already finished");
+
+					// We have already finished sending this body.
+					self.requests.insert(request_id, v);
+					return Err(HttpError::Invalid)
+				},
+			}
+		}
+	}
+
+	/// Mimics the corresponding method in the offchain API.
+	pub fn response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus> {
+		// First of all, dispatch all the non-dispatched requests and drop all senders so that the
+		// user can't write anymore data.
+		for id in ids {
+			match self.requests.get_mut(id) {
+				Some(HttpApiRequest::NotDispatched(_, _)) => {},
+				Some(HttpApiRequest::Dispatched(sending_body)) |
+				Some(HttpApiRequest::Response(HttpApiRequestRp { sending_body, .. })) => {
+					let _ = sending_body.take();
+					continue
+				},
+				_ => continue,
+			};
+
+			let (request, _sender) = match self.requests.remove(id) {
+				Some(HttpApiRequest::NotDispatched(rq, s)) => (rq, s),
+				_ => unreachable!("we checked for NotDispatched above; qed"),
+			};
+
+			let _ = self.to_worker.unbounded_send(ApiToWorker::Dispatch { id: *id, request });
+
+			// We also destroy the sender in order to forbid writing more data.
+			self.requests.insert(*id, HttpApiRequest::Dispatched(None));
+		}
+
+		let mut deadline = timestamp::deadline_to_future(deadline);
+
+		loop {
+			// Within that loop, first try to see if we have all the elements for a response.
+			// This includes the situation where the deadline is reached.
+			{
+				let mut output = Vec::with_capacity(ids.len());
+				let mut must_wait_more = false;
+				for id in ids {
+					output.push(match self.requests.get(id) {
+						None => HttpRequestStatus::Invalid,
+						Some(HttpApiRequest::NotDispatched(_, _)) => unreachable!(
+							"we replaced all the NotDispatched with Dispatched earlier; qed"
+						),
+						Some(HttpApiRequest::Dispatched(_)) => {
+							must_wait_more = true;
+							HttpRequestStatus::DeadlineReached
+						},
+						Some(HttpApiRequest::Fail(_)) => HttpRequestStatus::IoError,
+						Some(HttpApiRequest::Response(HttpApiRequestRp {
+							status_code, ..
+						})) => HttpRequestStatus::Finished(status_code.as_u16()),
+					});
+				}
+				debug_assert_eq!(output.len(), ids.len());
+
+				// Are we ready to call `return`?
+				let is_done =
+					if let future::MaybeDone::Done(_) = deadline { true } else { !must_wait_more };
+
+				if is_done {
+					// Requests in "fail" mode are purged before returning.
+					debug_assert_eq!(output.len(), ids.len());
+					for n in (0..ids.len()).rev() {
+						match output[n] {
+							HttpRequestStatus::IoError => {
+								self.requests.remove(&ids[n]);
+							},
+							HttpRequestStatus::Invalid => {
+								tracing::debug!(target: LOG_TARGET, id = %ids[n].0, "Unknown request");
+							},
+							HttpRequestStatus::DeadlineReached => {
+								tracing::debug!(target: LOG_TARGET, id = %ids[n].0, "Deadline reached");
+							},
+							HttpRequestStatus::Finished(_) => {
+								tracing::debug!(target: LOG_TARGET, id = %ids[n].0, "Request finished");
+							},
+						}
+					}
+					return output
+				}
+			}
+
+			// Grab next message from the worker. We call `continue` if deadline is reached so that
+			// we loop back and `return`.
+			let next_message = {
+				let mut next_msg = future::maybe_done(self.from_worker.next());
+				futures::executor::block_on(future::select(&mut next_msg, &mut deadline));
+				if let future::MaybeDone::Done(msg) = next_msg {
+					msg
+				} else {
+					debug_assert!(matches!(deadline, future::MaybeDone::Done(..)));
+					continue
+				}
+			};
+
+			// Update internal state based on received message.
+			match next_message {
+				Some(WorkerToApi::Response { id, status_code, headers, body }) => {
+					match self.requests.remove(&id) {
+						Some(HttpApiRequest::Dispatched(sending_body)) => {
+							self.requests.insert(
+								id,
+								HttpApiRequest::Response(HttpApiRequestRp {
+									sending_body,
+									status_code,
+									headers,
+									body: body.fuse(),
+									current_read_chunk: None,
+								}),
+							);
+						},
+						None => {}, // can happen if we detected an IO error when sending the body
+						_ => {
+							tracing::error!(target: "offchain-worker::http", "State mismatch between the API and worker")
+						},
+					}
+				},
+
+				Some(WorkerToApi::Fail { id, error }) => match self.requests.remove(&id) {
+					Some(HttpApiRequest::Dispatched(_)) => {
+						tracing::debug!(target: LOG_TARGET, id = %id.0, ?error, "Request failed");
+						self.requests.insert(id, HttpApiRequest::Fail(error));
+					},
+					None => {}, // can happen if we detected an IO error when sending the body
+					_ => {
+						tracing::error!(target: "offchain-worker::http", "State mismatch between the API and worker")
+					},
+				},
+
+				None => {
+					tracing::error!(target: "offchain-worker::http", "Worker has crashed");
+					return ids.iter().map(|_| HttpRequestStatus::IoError).collect()
+				},
+			}
+		}
+	}
+
+	/// Mimics the corresponding method in the offchain API.
+	pub fn response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
+		// Do an implicit non-blocking wait on the request.
+		let _ = self.response_wait(&[request_id], Some(timestamp::now()));
+
+		let headers = match self.requests.get(&request_id) {
+			Some(HttpApiRequest::Response(HttpApiRequestRp { headers, .. })) => headers,
+			_ => return Vec::new(),
+		};
+
+		headers
+			.iter()
+			.map(|(name, value)| (name.as_str().as_bytes().to_owned(), value.as_bytes().to_owned()))
+			.collect()
+	}
+
+	/// Mimics the corresponding method in the offchain API.
+	pub fn response_read_body(
+		&mut self,
+		request_id: HttpRequestId,
+		buffer: &mut [u8],
+		deadline: Option<Timestamp>,
+	) -> Result<usize, HttpError> {
+		// Do an implicit wait on the request.
+		let _ = self.response_wait(&[request_id], deadline);
+
+		// Remove the request from the list and handle situations where the request is invalid or
+		// in the wrong state.
+		let mut response = match self.requests.remove(&request_id) {
+			Some(HttpApiRequest::Response(r)) => r,
+			// Because we called `response_wait` above, we know that the deadline has been reached
+			// and we still haven't received a response.
+			Some(rq @ HttpApiRequest::Dispatched(_)) => {
+				self.requests.insert(request_id, rq);
+				return Err(HttpError::DeadlineReached)
+			},
+			// The request has failed.
+			Some(HttpApiRequest::Fail { .. }) => return Err(HttpError::IoError),
+			// Request hasn't been dispatched yet; reading the body is invalid.
+			Some(rq @ HttpApiRequest::NotDispatched(_, _)) => {
+				self.requests.insert(request_id, rq);
+				return Err(HttpError::Invalid)
+			},
+			None => return Err(HttpError::Invalid),
+		};
+
+		// Convert the deadline into a `Future` that resolves when the deadline is reached.
+		let mut deadline = timestamp::deadline_to_future(deadline);
+
+		loop {
+			// First read from `current_read_chunk`.
+			if let Some(mut current_read_chunk) = response.current_read_chunk.take() {
+				match current_read_chunk.read(buffer) {
+					Ok(0) => {},
+					Ok(n) => {
+						self.requests.insert(
+							request_id,
+							HttpApiRequest::Response(HttpApiRequestRp {
+								current_read_chunk: Some(current_read_chunk),
+								..response
+							}),
+						);
+						return Ok(n)
+					},
+					Err(err) => {
+						// This code should never be reached unless there's a logic error somewhere.
+						tracing::error!(target: "offchain-worker::http", "Failed to read from current read chunk: {:?}", err);
+						return Err(HttpError::IoError)
+					},
+				}
+			}
+
+			// If we reach here, that means the `current_read_chunk` is empty and needs to be
+			// filled with a new chunk from `body`. We block on either the next body or the
+			// deadline.
+			let mut next_body = future::maybe_done(response.body.next());
+			futures::executor::block_on(future::select(&mut next_body, &mut deadline));
+
+			if let future::MaybeDone::Done(next_body) = next_body {
+				match next_body {
+					Some(Ok(chunk)) => response.current_read_chunk = Some(chunk.reader()),
+					Some(Err(_)) => return Err(HttpError::IoError),
+					None => return Ok(0), // eof
+				}
+			}
+
+			if let future::MaybeDone::Done(_) = deadline {
+				self.requests.insert(request_id, HttpApiRequest::Response(response));
+				return Err(HttpError::DeadlineReached)
+			}
+		}
+	}
+}
+
+impl fmt::Debug for HttpApi {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.debug_list().entries(self.requests.iter()).finish()
+	}
+}
+
+impl fmt::Debug for HttpApiRequest {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			HttpApiRequest::NotDispatched(_, _) =>
+				f.debug_tuple("HttpApiRequest::NotDispatched").finish(),
+			HttpApiRequest::Dispatched(_) => f.debug_tuple("HttpApiRequest::Dispatched").finish(),
+			HttpApiRequest::Response(HttpApiRequestRp { status_code, headers, .. }) => f
+				.debug_tuple("HttpApiRequest::Response")
+				.field(status_code)
+				.field(headers)
+				.finish(),
+			HttpApiRequest::Fail(err) => f.debug_tuple("HttpApiRequest::Fail").field(err).finish(),
+		}
+	}
+}
+
+/// Message send from the API to the worker.
+enum ApiToWorker {
+	/// Dispatches a new HTTP request.
+	Dispatch {
+		/// ID to send back when the response comes back.
+		id: HttpRequestId,
+		/// Request to start executing.
+		request: hyper::Request<hyper::Body>,
+	},
+}
+
+/// Message send from the API to the worker.
+enum WorkerToApi {
+	/// A request has succeeded.
+	Response {
+		/// The ID that was passed to the worker.
+		id: HttpRequestId,
+		/// Status code of the response.
+		status_code: hyper::StatusCode,
+		/// Headers of the response.
+		headers: hyper::HeaderMap,
+		/// Body of the response, as a channel of `Chunk` objects.
+		/// We send the body back through a channel instead of returning the hyper `Body` object
+		/// because we don't want the `HttpApi` to have to drive the reading.
+		/// Instead, reading an item from the channel will notify the worker task, which will push
+		/// the next item.
+		/// Can also be used to send an error, in case an error happend on the HTTP socket. After
+		/// an error is sent, the channel will close.
+		body: mpsc::Receiver<Result<hyper::body::Bytes, hyper::Error>>,
+	},
+	/// A request has failed because of an error. The request is then no longer valid.
+	Fail {
+		/// The ID that was passed to the worker.
+		id: HttpRequestId,
+		/// Error that happened.
+		error: hyper::Error,
+	},
+}
+
+/// Must be continuously polled for the [`HttpApi`] to properly work.
+pub struct HttpWorker {
+	/// Used to sends messages to the `HttpApi`.
+	to_api: TracingUnboundedSender<WorkerToApi>,
+	/// Used to receive messages from the `HttpApi`.
+	from_api: TracingUnboundedReceiver<ApiToWorker>,
+	/// The engine that runs HTTP requests.
+	http_client: Arc<Lazy<HyperClient<HttpsConnector<client::HttpConnector>, Body>>>,
+	/// HTTP requests that are being worked on by the engine.
+	requests: Vec<(HttpRequestId, HttpWorkerRequest)>,
+}
+
+/// HTTP request being processed by the worker.
+enum HttpWorkerRequest {
+	/// Request has been dispatched and is waiting for a response from the Internet.
+	Dispatched(hyper::client::ResponseFuture),
+	/// Progressively reading the body of the response and sending it to the channel.
+	ReadBody {
+		/// Body to read `Chunk`s from. Only used if the channel is ready to accept data.
+		body: hyper::Body,
+		/// Channel to the [`HttpApi`] where we send the chunks to.
+		tx: mpsc::Sender<Result<hyper::body::Bytes, hyper::Error>>,
+	},
+}
+
+impl Future for HttpWorker {
+	type Output = ();
+
+	fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		// Reminder: this is continuously run in the background.
+
+		// We use a `me` variable because the compiler isn't smart enough to allow borrowing
+		// multiple fields at once through a `Deref`.
+		let me = &mut *self;
+
+		// We remove each element from `requests` one by one and add them back only if necessary.
+		for n in (0..me.requests.len()).rev() {
+			let (id, request) = me.requests.swap_remove(n);
+			match request {
+				HttpWorkerRequest::Dispatched(mut future) => {
+					// Check for an HTTP response from the Internet.
+					let response = match Future::poll(Pin::new(&mut future), cx) {
+						Poll::Pending => {
+							me.requests.push((id, HttpWorkerRequest::Dispatched(future)));
+							continue
+						},
+						Poll::Ready(Ok(response)) => response,
+						Poll::Ready(Err(error)) => {
+							let _ = me.to_api.unbounded_send(WorkerToApi::Fail { id, error });
+							continue // don't insert the request back
+						},
+					};
+
+					// We received a response! Decompose it into its parts.
+					let (head, body) = response.into_parts();
+					let (status_code, headers) = (head.status, head.headers);
+
+					let (body_tx, body_rx) = mpsc::channel(3);
+					let _ = me.to_api.unbounded_send(WorkerToApi::Response {
+						id,
+						status_code,
+						headers,
+						body: body_rx,
+					});
+
+					me.requests.push((id, HttpWorkerRequest::ReadBody { body, tx: body_tx }));
+					cx.waker().wake_by_ref(); // reschedule in order to poll the new future
+					continue
+				},
+
+				HttpWorkerRequest::ReadBody { mut body, mut tx } => {
+					// Before reading from the HTTP response, check that `tx` is ready to accept
+					// a new chunk.
+					match tx.poll_ready(cx) {
+						Poll::Ready(Ok(())) => {},
+						Poll::Ready(Err(_)) => continue, // don't insert the request back
+						Poll::Pending => {
+							me.requests.push((id, HttpWorkerRequest::ReadBody { body, tx }));
+							continue
+						},
+					}
+
+					// `tx` is ready. Read a chunk from the socket and send it to the channel.
+					match Stream::poll_next(Pin::new(&mut body), cx) {
+						Poll::Ready(Some(Ok(chunk))) => {
+							let _ = tx.start_send(Ok(chunk));
+							me.requests.push((id, HttpWorkerRequest::ReadBody { body, tx }));
+							cx.waker().wake_by_ref(); // reschedule in order to continue reading
+						},
+						Poll::Ready(Some(Err(err))) => {
+							let _ = tx.start_send(Err(err));
+							// don't insert the request back
+						},
+						Poll::Ready(None) => {}, // EOF; don't insert the request back
+						Poll::Pending => {
+							me.requests.push((id, HttpWorkerRequest::ReadBody { body, tx }));
+						},
+					}
+				},
+			}
+		}
+
+		// Check for messages coming from the [`HttpApi`].
+		match Stream::poll_next(Pin::new(&mut me.from_api), cx) {
+			Poll::Pending => {},
+			Poll::Ready(None) => return Poll::Ready(()), // stops the worker
+			Poll::Ready(Some(ApiToWorker::Dispatch { id, request })) => {
+				let future = me.http_client.request(request);
+				debug_assert!(me.requests.iter().all(|(i, _)| *i != id));
+				me.requests.push((id, HttpWorkerRequest::Dispatched(future)));
+				cx.waker().wake_by_ref(); // reschedule the task to poll the request
+			},
+		}
+
+		Poll::Pending
+	}
+}
+
+impl fmt::Debug for HttpWorker {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.debug_list().entries(self.requests.iter()).finish()
+	}
+}
+
+impl fmt::Debug for HttpWorkerRequest {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			HttpWorkerRequest::Dispatched(_) =>
+				f.debug_tuple("HttpWorkerRequest::Dispatched").finish(),
+			HttpWorkerRequest::ReadBody { .. } =>
+				f.debug_tuple("HttpWorkerRequest::Response").finish(),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{
+		super::{tests::TestNetwork, AsyncApi},
+		*,
+	};
+	use crate::api::timestamp;
+	use core::convert::Infallible;
+	use futures::{future, StreamExt};
+	use lazy_static::lazy_static;
+	use sp_core::offchain::{Duration, Externalities, HttpError, HttpRequestId, HttpRequestStatus};
+
+	// Using lazy_static to avoid spawning lots of different SharedClients,
+	// as spawning a SharedClient is CPU-intensive and opens lots of fds.
+	lazy_static! {
+		static ref SHARED_CLIENT: SharedClient = SharedClient::new();
+	}
+
+	// Returns an `HttpApi` whose worker is ran in the background, and a `SocketAddr` to an HTTP
+	// server that runs in the background as well.
+	macro_rules! build_api_server {
+		() => {
+			build_api_server!(hyper::Response::new(hyper::Body::from("Hello World!")))
+		};
+		( $response:expr ) => {{
+			let hyper_client = SHARED_CLIENT.clone();
+			let (api, worker) = http(hyper_client.clone());
+
+			let (addr_tx, addr_rx) = std::sync::mpsc::channel();
+			std::thread::spawn(move || {
+				let rt = tokio::runtime::Runtime::new().unwrap();
+				let worker = rt.spawn(worker);
+				let server = rt.spawn(async move {
+					let server = hyper::Server::bind(&"127.0.0.1:0".parse().unwrap()).serve(
+						hyper::service::make_service_fn(|_| async move {
+							Ok::<_, Infallible>(hyper::service::service_fn(
+								move |req: hyper::Request<hyper::Body>| async move {
+									// Wait until the complete request was received and processed,
+									// otherwise the tests are flaky.
+									let _ = req.into_body().collect::<Vec<_>>().await;
+
+									Ok::<_, Infallible>($response)
+								},
+							))
+						}),
+					);
+					let _ = addr_tx.send(server.local_addr());
+					server.await.map_err(drop)
+				});
+				let _ = rt.block_on(future::join(worker, server));
+			});
+			(api, addr_rx.recv().unwrap())
+		}};
+	}
+
+	#[test]
+	fn basic_localhost() {
+		let deadline = timestamp::now().add(Duration::from_millis(10_000));
+
+		// Performs an HTTP query to a background HTTP server.
+
+		let (mut api, addr) = build_api_server!();
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_write_body(id, &[], Some(deadline)).unwrap();
+
+		match api.response_wait(&[id], Some(deadline))[0] {
+			HttpRequestStatus::Finished(200) => {},
+			v => panic!("Connecting to localhost failed: {:?}", v),
+		}
+
+		let headers = api.response_headers(id);
+		assert!(headers.iter().any(|(h, _)| h.eq_ignore_ascii_case(b"Date")));
+
+		let mut buf = vec![0; 2048];
+		let n = api.response_read_body(id, &mut buf, Some(deadline)).unwrap();
+		assert_eq!(&buf[..n], b"Hello World!");
+	}
+
+	#[test]
+	fn basic_http2_localhost() {
+		let deadline = timestamp::now().add(Duration::from_millis(10_000));
+
+		// Performs an HTTP query to a background HTTP server.
+
+		let (mut api, addr) = build_api_server!(hyper::Response::builder()
+			.version(hyper::Version::HTTP_2)
+			.body(hyper::Body::from("Hello World!"))
+			.unwrap());
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_write_body(id, &[], Some(deadline)).unwrap();
+
+		match api.response_wait(&[id], Some(deadline))[0] {
+			HttpRequestStatus::Finished(200) => {},
+			v => panic!("Connecting to localhost failed: {:?}", v),
+		}
+
+		let headers = api.response_headers(id);
+		assert!(headers.iter().any(|(h, _)| h.eq_ignore_ascii_case(b"Date")));
+
+		let mut buf = vec![0; 2048];
+		let n = api.response_read_body(id, &mut buf, Some(deadline)).unwrap();
+		assert_eq!(&buf[..n], b"Hello World!");
+	}
+
+	#[test]
+	fn request_start_invalid_call() {
+		let (mut api, addr) = build_api_server!();
+
+		match api.request_start("\0", &format!("http://{}", addr)) {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+
+		match api.request_start("GET", "http://\0localhost") {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+	}
+
+	#[test]
+	fn request_add_header_invalid_call() {
+		let (mut api, addr) = build_api_server!();
+
+		match api.request_add_header(HttpRequestId(0xdead), "Foo", "bar") {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		match api.request_add_header(id, "\0", "bar") {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		match api.request_add_header(id, "Foo", "\0") {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_add_header(id, "Foo", "Bar").unwrap();
+		api.request_write_body(id, &[1, 2, 3, 4], None).unwrap();
+		match api.request_add_header(id, "Foo2", "Bar") {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		api.response_headers(id);
+		match api.request_add_header(id, "Foo2", "Bar") {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		api.response_read_body(id, &mut [], None).unwrap();
+		match api.request_add_header(id, "Foo2", "Bar") {
+			Err(()) => {},
+			Ok(_) => panic!(),
+		};
+	}
+
+	#[test]
+	fn request_write_body_invalid_call() {
+		let (mut api, addr) = build_api_server!();
+
+		match api.request_write_body(HttpRequestId(0xdead), &[1, 2, 3], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		match api.request_write_body(HttpRequestId(0xdead), &[], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_write_body(id, &[1, 2, 3, 4], None).unwrap();
+		api.request_write_body(id, &[1, 2, 3, 4], None).unwrap();
+		api.request_write_body(id, &[], None).unwrap();
+		match api.request_write_body(id, &[], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_write_body(id, &[1, 2, 3, 4], None).unwrap();
+		api.request_write_body(id, &[1, 2, 3, 4], None).unwrap();
+		api.request_write_body(id, &[], None).unwrap();
+		match api.request_write_body(id, &[1, 2, 3, 4], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_write_body(id, &[1, 2, 3, 4], None).unwrap();
+		api.response_wait(&[id], None);
+		match api.request_write_body(id, &[], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_write_body(id, &[1, 2, 3, 4], None).unwrap();
+		api.response_wait(&[id], None);
+		match api.request_write_body(id, &[1, 2, 3, 4], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.response_headers(id);
+		match api.request_write_body(id, &[1, 2, 3, 4], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		api.response_headers(id);
+		match api.request_write_body(id, &[], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.response_read_body(id, &mut [], None).unwrap();
+		match api.request_write_body(id, &[1, 2, 3, 4], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.response_read_body(id, &mut [], None).unwrap();
+		match api.request_write_body(id, &[], None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		};
+	}
+
+	#[test]
+	fn response_headers_invalid_call() {
+		let (mut api, addr) = build_api_server!();
+		assert_eq!(api.response_headers(HttpRequestId(0xdead)), &[]);
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		assert_eq!(api.response_headers(id), &[]);
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_write_body(id, &[], None).unwrap();
+		while api.response_headers(id).is_empty() {
+			std::thread::sleep(std::time::Duration::from_millis(100));
+		}
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		api.response_wait(&[id], None);
+		assert_ne!(api.response_headers(id), &[]);
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		let mut buf = [0; 128];
+		while api.response_read_body(id, &mut buf, None).unwrap() != 0 {}
+		assert_eq!(api.response_headers(id), &[]);
+	}
+
+	#[test]
+	fn response_header_invalid_call() {
+		let (mut api, addr) = build_api_server!();
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		assert_eq!(api.response_headers(id), &[]);
+
+		let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+		api.request_add_header(id, "Foo", "Bar").unwrap();
+		assert_eq!(api.response_headers(id), &[]);
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		api.request_add_header(id, "Foo", "Bar").unwrap();
+		api.request_write_body(id, &[], None).unwrap();
+		// Note: this test actually sends out the request, and is supposed to test a situation
+		// where we haven't received any response yet. This test can theoretically fail if the
+		// HTTP response comes back faster than the kernel schedules our thread, but that is highly
+		// unlikely.
+		assert_eq!(api.response_headers(id), &[]);
+	}
+
+	#[test]
+	fn response_read_body_invalid_call() {
+		let (mut api, addr) = build_api_server!();
+		let mut buf = [0; 512];
+
+		match api.response_read_body(HttpRequestId(0xdead), &mut buf, None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		}
+
+		let id = api.request_start("GET", &format!("http://{}", addr)).unwrap();
+		while api.response_read_body(id, &mut buf, None).unwrap() != 0 {}
+		match api.response_read_body(id, &mut buf, None) {
+			Err(HttpError::Invalid) => {},
+			_ => panic!(),
+		}
+	}
+
+	#[test]
+	fn fuzzing() {
+		// Uses the API in random ways to try to trigger panics.
+		// Doesn't test some paths, such as waiting for multiple requests. Also doesn't test what
+		// happens if the server force-closes our socket.
+
+		let (mut api, addr) = build_api_server!();
+
+		for _ in 0..50 {
+			let id = api.request_start("POST", &format!("http://{}", addr)).unwrap();
+
+			for _ in 0..250 {
+				match rand::random::<u8>() % 6 {
+					0 => {
+						let _ = api.request_add_header(id, "Foo", "Bar");
+					},
+					1 => {
+						let _ = api.request_write_body(id, &[1, 2, 3, 4], None);
+					},
+					2 => {
+						let _ = api.request_write_body(id, &[], None);
+					},
+					3 => {
+						let _ = api.response_wait(&[id], None);
+					},
+					4 => {
+						let _ = api.response_headers(id);
+					},
+					5 => {
+						let mut buf = [0; 512];
+						let _ = api.response_read_body(id, &mut buf, None);
+					},
+					6..=255 => unreachable!(),
+				}
+			}
+		}
+	}
+
+	#[test]
+	fn shared_http_client_is_only_initialized_on_access() {
+		let shared_client = SharedClient::new();
+
+		{
+			let mock = Arc::new(TestNetwork());
+			let (mut api, async_api) = AsyncApi::new(mock, false, shared_client.clone());
+			api.timestamp();
+
+			futures::executor::block_on(async move {
+				assert!(futures::poll!(async_api.process()).is_pending());
+			});
+		}
+
+		// Check that the http client wasn't initialized, because it wasn't used.
+		assert!(Lazy::into_value(Arc::try_unwrap(shared_client.0).unwrap()).is_err());
+
+		let shared_client = SharedClient::new();
+
+		{
+			let mock = Arc::new(TestNetwork());
+			let (mut api, async_api) = AsyncApi::new(mock, false, shared_client.clone());
+			let id = api.http_request_start("lol", "nope", &[]).unwrap();
+			api.http_request_write_body(id, &[], None).unwrap();
+			futures::executor::block_on(async move {
+				assert!(futures::poll!(async_api.process()).is_pending());
+			});
+		}
+
+		// Check that the http client initialized, because it was used.
+		assert!(Lazy::into_value(Arc::try_unwrap(shared_client.0).unwrap()).is_ok());
+	}
+}
diff --git a/substrate/client/offchain/src/api/timestamp.rs b/substrate/client/offchain/src/api/timestamp.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0087ff592e1fc36e4326d024299adc4e05466834
--- /dev/null
+++ b/substrate/client/offchain/src/api/timestamp.rs
@@ -0,0 +1,67 @@
+// 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/>.
+
+//! Helper methods dedicated to timestamps.
+
+use sp_core::offchain::Timestamp;
+use std::time::{Duration, SystemTime};
+
+/// Returns the current time as a `Timestamp`.
+pub fn now() -> Timestamp {
+	let now = SystemTime::now();
+	let epoch_duration = now.duration_since(SystemTime::UNIX_EPOCH);
+	match epoch_duration {
+		Err(_) => {
+			// Current time is earlier than UNIX_EPOCH.
+			Timestamp::from_unix_millis(0)
+		},
+		Ok(d) => {
+			let duration = d.as_millis();
+			// Assuming overflow won't happen for a few hundred years.
+			Timestamp::from_unix_millis(
+				duration
+					.try_into()
+					.expect("epoch milliseconds won't overflow u64 for hundreds of years; qed"),
+			)
+		},
+	}
+}
+
+/// Returns how a `Timestamp` compares to "now".
+///
+/// In other words, returns `timestamp - now()`.
+pub fn timestamp_from_now(timestamp: Timestamp) -> Duration {
+	Duration::from_millis(timestamp.diff(&now()).millis())
+}
+
+/// Converts the deadline into a `Future` that resolves when the deadline is reached.
+///
+/// If `None`, returns a never-ending `Future`.
+pub fn deadline_to_future(
+	deadline: Option<Timestamp>,
+) -> futures::future::MaybeDone<impl futures::Future<Output = ()>> {
+	use futures::future::{self, Either};
+
+	future::maybe_done(match deadline.map(timestamp_from_now) {
+		None => Either::Left(future::pending()),
+		// Only apply delay if we need to wait a non-zero duration
+		Some(duration) if duration <= Duration::from_secs(0) =>
+			Either::Right(Either::Left(future::ready(()))),
+		Some(duration) => Either::Right(Either::Right(futures_timer::Delay::new(duration))),
+	})
+}
diff --git a/substrate/client/offchain/src/lib.rs b/substrate/client/offchain/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a11ac7d86ecb8200502f4375c13a5f850096ee68
--- /dev/null
+++ b/substrate/client/offchain/src/lib.rs
@@ -0,0 +1,491 @@
+// 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/>.
+
+//! Substrate offchain workers.
+//!
+//! The offchain workers is a special function of the runtime that
+//! gets executed after block is imported. During execution
+//! it's able to asynchronously submit extrinsics that will either
+//! be propagated to other nodes or added to the next block
+//! produced by the node as unsigned transactions.
+//!
+//! Offchain workers can be used for computation-heavy tasks
+//! that are not feasible for execution during regular block processing.
+//! It can either be tasks that no consensus is required for,
+//! or some form of consensus over the data can be built on-chain
+//! for instance via:
+//! 1. Challenge period for incorrect computations
+//! 2. Majority voting for results
+//! 3. etc
+
+#![warn(missing_docs)]
+
+use std::{fmt, sync::Arc};
+
+use futures::{
+	future::{ready, Future},
+	prelude::*,
+};
+use parking_lot::Mutex;
+use sc_client_api::BlockchainEvents;
+use sc_network::{NetworkPeers, NetworkStateInfo};
+use sc_transaction_pool_api::OffchainTransactionPoolFactory;
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_core::{offchain, traits::SpawnNamed};
+use sp_externalities::Extension;
+use sp_keystore::{KeystoreExt, KeystorePtr};
+use sp_runtime::traits::{self, Header};
+use threadpool::ThreadPool;
+
+mod api;
+
+pub use sp_core::offchain::storage::OffchainDb;
+pub use sp_offchain::{OffchainWorkerApi, STORAGE_PREFIX};
+
+const LOG_TARGET: &str = "offchain-worker";
+
+/// NetworkProvider provides [`OffchainWorkers`] with all necessary hooks into the
+/// underlying Substrate networking.
+pub trait NetworkProvider: NetworkStateInfo + NetworkPeers {}
+
+impl<T> NetworkProvider for T where T: NetworkStateInfo + NetworkPeers {}
+
+/// Special type that implements [`OffchainStorage`](offchain::OffchainStorage).
+///
+/// This type can not be constructed and should only be used when passing `None` as `offchain_db` to
+/// [`OffchainWorkerOptions`] to make the compiler happy.
+#[derive(Clone)]
+pub enum NoOffchainStorage {}
+
+impl offchain::OffchainStorage for NoOffchainStorage {
+	fn set(&mut self, _: &[u8], _: &[u8], _: &[u8]) {
+		unimplemented!("`NoOffchainStorage` can not be constructed!")
+	}
+
+	fn remove(&mut self, _: &[u8], _: &[u8]) {
+		unimplemented!("`NoOffchainStorage` can not be constructed!")
+	}
+
+	fn get(&self, _: &[u8], _: &[u8]) -> Option<Vec<u8>> {
+		unimplemented!("`NoOffchainStorage` can not be constructed!")
+	}
+
+	fn compare_and_set(&mut self, _: &[u8], _: &[u8], _: Option<&[u8]>, _: &[u8]) -> bool {
+		unimplemented!("`NoOffchainStorage` can not be constructed!")
+	}
+}
+
+/// Options for [`OffchainWorkers`]
+pub struct OffchainWorkerOptions<RA, Block: traits::Block, Storage, CE> {
+	/// Provides access to the runtime api.
+	pub runtime_api_provider: Arc<RA>,
+	/// Provides access to the keystore.
+	pub keystore: Option<KeystorePtr>,
+	/// Provides access to the offchain database.
+	///
+	/// Use [`NoOffchainStorage`] as type when passing `None` to have some type that works.
+	pub offchain_db: Option<Storage>,
+	/// Provides access to the transaction pool.
+	pub transaction_pool: Option<OffchainTransactionPoolFactory<Block>>,
+	/// Provides access to network information.
+	pub network_provider: Arc<dyn NetworkProvider + Send + Sync>,
+	/// Is the node running as validator?
+	pub is_validator: bool,
+	/// Enable http requests from offchain workers?
+	///
+	/// If not enabled, any http request will panic.
+	pub enable_http_requests: bool,
+	/// Callback to create custom [`Extension`]s that should be registered for the
+	/// `offchain_worker` runtime call.
+	///
+	/// These [`Extension`]s are registered along-side the default extensions and are accessible in
+	/// the host functions.
+	///
+	/// # Example:
+	///
+	/// ```nocompile
+	/// custom_extensions: |block_hash| {
+	///     vec![MyCustomExtension::new()]
+	/// }
+	/// ```
+	pub custom_extensions: CE,
+}
+
+/// An offchain workers manager.
+pub struct OffchainWorkers<RA, Block: traits::Block, Storage> {
+	runtime_api_provider: Arc<RA>,
+	thread_pool: Mutex<ThreadPool>,
+	shared_http_client: api::SharedClient,
+	enable_http_requests: bool,
+	keystore: Option<KeystorePtr>,
+	offchain_db: Option<OffchainDb<Storage>>,
+	transaction_pool: Option<OffchainTransactionPoolFactory<Block>>,
+	network_provider: Arc<dyn NetworkProvider + Send + Sync>,
+	is_validator: bool,
+	custom_extensions: Box<dyn Fn(Block::Hash) -> Vec<Box<dyn Extension>> + Send>,
+}
+
+impl<RA, Block: traits::Block, Storage> OffchainWorkers<RA, Block, Storage> {
+	/// Creates new [`OffchainWorkers`].
+	pub fn new<CE: Fn(Block::Hash) -> Vec<Box<dyn Extension>> + Send + 'static>(
+		OffchainWorkerOptions {
+			runtime_api_provider,
+			keystore,
+			offchain_db,
+			transaction_pool,
+			network_provider,
+			is_validator,
+			enable_http_requests,
+			custom_extensions,
+		}: OffchainWorkerOptions<RA, Block, Storage, CE>,
+	) -> Self {
+		Self {
+			runtime_api_provider,
+			thread_pool: Mutex::new(ThreadPool::with_name(
+				"offchain-worker".into(),
+				num_cpus::get(),
+			)),
+			shared_http_client: api::SharedClient::new(),
+			enable_http_requests,
+			keystore,
+			offchain_db: offchain_db.map(OffchainDb::new),
+			transaction_pool,
+			is_validator,
+			network_provider,
+			custom_extensions: Box::new(custom_extensions),
+		}
+	}
+}
+
+impl<RA, Block: traits::Block, Storage: offchain::OffchainStorage> fmt::Debug
+	for OffchainWorkers<RA, Block, Storage>
+{
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		f.debug_tuple("OffchainWorkers").finish()
+	}
+}
+
+impl<RA, Block, Storage> OffchainWorkers<RA, Block, Storage>
+where
+	Block: traits::Block,
+	RA: ProvideRuntimeApi<Block> + Send + Sync + 'static,
+	RA::Api: OffchainWorkerApi<Block>,
+	Storage: offchain::OffchainStorage + 'static,
+{
+	/// Run the offchain workers on every block import.
+	pub async fn run<BE: BlockchainEvents<Block>>(
+		self,
+		import_events: Arc<BE>,
+		spawner: impl SpawnNamed,
+	) {
+		import_events
+			.import_notification_stream()
+			.for_each(move |n| {
+				if n.is_new_best {
+					spawner.spawn(
+						"offchain-on-block",
+						Some("offchain-worker"),
+						self.on_block_imported(&n.header).boxed(),
+					);
+				} else {
+					tracing::debug!(
+						target: LOG_TARGET,
+						"Skipping offchain workers for non-canon block: {:?}",
+						n.header,
+					)
+				}
+
+				ready(())
+			})
+			.await;
+	}
+
+	/// Start the offchain workers after given block.
+	#[must_use]
+	fn on_block_imported(&self, header: &Block::Header) -> impl Future<Output = ()> {
+		let runtime = self.runtime_api_provider.runtime_api();
+		let hash = header.hash();
+		let has_api_v1 = runtime.has_api_with::<dyn OffchainWorkerApi<Block>, _>(hash, |v| v == 1);
+		let has_api_v2 = runtime.has_api_with::<dyn OffchainWorkerApi<Block>, _>(hash, |v| v == 2);
+		let version = match (has_api_v1, has_api_v2) {
+			(_, Ok(true)) => 2,
+			(Ok(true), _) => 1,
+			err => {
+				let help =
+					"Consider turning off offchain workers if they are not part of your runtime.";
+				tracing::error!(
+					target: LOG_TARGET,
+					"Unsupported Offchain Worker API version: {:?}. {}.",
+					err,
+					help
+				);
+				0
+			},
+		};
+		tracing::debug!(
+			target: LOG_TARGET,
+			"Checking offchain workers at {hash:?}: version: {version}",
+		);
+
+		let process = (version > 0).then(|| {
+			let (api, runner) = api::AsyncApi::new(
+				self.network_provider.clone(),
+				self.is_validator,
+				self.shared_http_client.clone(),
+			);
+			tracing::debug!(target: LOG_TARGET, "Spawning offchain workers at {hash:?}");
+			let header = header.clone();
+			let client = self.runtime_api_provider.clone();
+
+			let mut capabilities = offchain::Capabilities::all();
+			capabilities.set(offchain::Capabilities::HTTP, self.enable_http_requests);
+
+			let keystore = self.keystore.clone();
+			let db = self.offchain_db.clone();
+			let tx_pool = self.transaction_pool.clone();
+			let custom_extensions = (*self.custom_extensions)(hash);
+
+			self.spawn_worker(move || {
+				let mut runtime = client.runtime_api();
+				let api = Box::new(api);
+				tracing::debug!(target: LOG_TARGET, "Running offchain workers at {hash:?}");
+
+				if let Some(keystore) = keystore {
+					runtime.register_extension(KeystoreExt(keystore.clone()));
+				}
+
+				if let Some(pool) = tx_pool {
+					runtime.register_extension(pool.offchain_transaction_pool(hash));
+				}
+
+				if let Some(offchain_db) = db {
+					runtime.register_extension(offchain::OffchainDbExt::new(
+						offchain::LimitedExternalities::new(capabilities, offchain_db.clone()),
+					));
+				}
+
+				runtime.register_extension(offchain::OffchainWorkerExt::new(
+					offchain::LimitedExternalities::new(capabilities, api),
+				));
+
+				custom_extensions.into_iter().for_each(|ext| runtime.register_extension(ext));
+
+				let run = if version == 2 {
+					runtime.offchain_worker(hash, &header)
+				} else {
+					#[allow(deprecated)]
+					runtime.offchain_worker_before_version_2(hash, *header.number())
+				};
+
+				if let Err(e) = run {
+					tracing::error!(
+						target: LOG_TARGET,
+						"Error running offchain workers at {:?}: {}",
+						hash,
+						e
+					);
+				}
+			});
+
+			runner.process()
+		});
+
+		async move {
+			futures::future::OptionFuture::from(process).await;
+		}
+	}
+
+	/// Spawns a new offchain worker.
+	///
+	/// We spawn offchain workers for each block in a separate thread,
+	/// since they can run for a significant amount of time
+	/// in a blocking fashion and we don't want to block the runtime.
+	///
+	/// Note that we should avoid that if we switch to future-based runtime in the future,
+	/// alternatively:
+	fn spawn_worker(&self, f: impl FnOnce() -> () + Send + 'static) {
+		self.thread_pool.lock().execute(f);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use futures::executor::block_on;
+	use libp2p::{Multiaddr, PeerId};
+	use sc_block_builder::BlockBuilderProvider as _;
+	use sc_client_api::Backend as _;
+	use sc_network::{config::MultiaddrWithPeerId, types::ProtocolName, ReputationChange};
+	use sc_transaction_pool::BasicPool;
+	use sc_transaction_pool_api::{InPoolTransaction, TransactionPool};
+	use sp_consensus::BlockOrigin;
+	use std::{collections::HashSet, sync::Arc};
+	use substrate_test_runtime_client::{
+		runtime::{
+			substrate_test_pallet::pallet::Call as PalletCall, ExtrinsicBuilder, RuntimeCall,
+		},
+		ClientBlockImportExt, DefaultTestClientBuilderExt, TestClientBuilderExt,
+	};
+
+	struct TestNetwork();
+
+	impl NetworkStateInfo for TestNetwork {
+		fn external_addresses(&self) -> Vec<Multiaddr> {
+			Vec::new()
+		}
+
+		fn local_peer_id(&self) -> PeerId {
+			PeerId::random()
+		}
+
+		fn listen_addresses(&self) -> Vec<Multiaddr> {
+			Vec::new()
+		}
+	}
+
+	impl NetworkPeers for TestNetwork {
+		fn set_authorized_peers(&self, _peers: HashSet<PeerId>) {
+			unimplemented!();
+		}
+
+		fn set_authorized_only(&self, _reserved_only: bool) {
+			unimplemented!();
+		}
+
+		fn add_known_address(&self, _peer_id: PeerId, _addr: Multiaddr) {
+			unimplemented!();
+		}
+
+		fn report_peer(&self, _who: PeerId, _cost_benefit: ReputationChange) {
+			unimplemented!();
+		}
+
+		fn disconnect_peer(&self, _who: PeerId, _protocol: ProtocolName) {
+			unimplemented!();
+		}
+
+		fn accept_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn deny_unreserved_peers(&self) {
+			unimplemented!();
+		}
+
+		fn add_reserved_peer(&self, _peer: MultiaddrWithPeerId) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_reserved_peer(&self, _peer_id: PeerId) {
+			unimplemented!();
+		}
+
+		fn set_reserved_peers(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn add_peers_to_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: HashSet<Multiaddr>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn remove_peers_from_reserved_set(
+			&self,
+			_protocol: ProtocolName,
+			_peers: Vec<PeerId>,
+		) -> Result<(), String> {
+			unimplemented!();
+		}
+
+		fn sync_num_connected(&self) -> usize {
+			unimplemented!();
+		}
+	}
+
+	#[test]
+	fn should_call_into_runtime_and_produce_extrinsic() {
+		sp_tracing::try_init_simple();
+
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let pool =
+			BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
+		let network = Arc::new(TestNetwork());
+		let header = client.header(client.chain_info().genesis_hash).unwrap().unwrap();
+
+		// when
+		let offchain = OffchainWorkers::new(OffchainWorkerOptions {
+			runtime_api_provider: client,
+			keystore: None,
+			offchain_db: None::<NoOffchainStorage>,
+			transaction_pool: Some(OffchainTransactionPoolFactory::new(pool.clone())),
+			network_provider: network,
+			is_validator: false,
+			enable_http_requests: false,
+			custom_extensions: |_| Vec::new(),
+		});
+		futures::executor::block_on(offchain.on_block_imported(&header));
+
+		// then
+		assert_eq!(pool.status().ready, 1);
+		assert!(matches!(
+			pool.ready().next().unwrap().data().function,
+			RuntimeCall::SubstrateTest(PalletCall::storage_change { .. })
+		));
+	}
+
+	#[test]
+	fn offchain_index_set_and_clear_works() {
+		use sp_core::offchain::OffchainStorage;
+
+		sp_tracing::try_init_simple();
+
+		let (client, backend) = substrate_test_runtime_client::TestClientBuilder::new()
+			.enable_offchain_indexing_api()
+			.build_with_backend();
+		let mut client = Arc::new(client);
+		let offchain_db = backend.offchain_storage().unwrap();
+
+		let key = &b"hello"[..];
+		let value = &b"world"[..];
+		let mut block_builder = client.new_block(Default::default()).unwrap();
+		let ext = ExtrinsicBuilder::new_offchain_index_set(key.to_vec(), value.to_vec()).build();
+		block_builder.push(ext).unwrap();
+
+		let block = block_builder.build().unwrap().block;
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+		assert_eq!(value, &offchain_db.get(sp_offchain::STORAGE_PREFIX, &key).unwrap());
+
+		let mut block_builder = client.new_block(Default::default()).unwrap();
+		let ext = ExtrinsicBuilder::new_offchain_index_clear(key.to_vec()).nonce(1).build();
+		block_builder.push(ext).unwrap();
+
+		let block = block_builder.build().unwrap().block;
+		block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+		assert!(offchain_db.get(sp_offchain::STORAGE_PREFIX, &key).is_none());
+	}
+}
diff --git a/substrate/client/proposer-metrics/Cargo.toml b/substrate/client/proposer-metrics/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..97a7c076bd9e789cbcc0de790685746f523168ff
--- /dev/null
+++ b/substrate/client/proposer-metrics/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "sc-proposer-metrics"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Basic metrics for block production."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+log = "0.4.17"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
diff --git a/substrate/client/proposer-metrics/README.md b/substrate/client/proposer-metrics/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9669c7d35191dc6dc6d4c6df5878c6b4c9bea30d
--- /dev/null
+++ b/substrate/client/proposer-metrics/README.md
@@ -0,0 +1,3 @@
+Prometheus basic proposer metrics.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/proposer-metrics/src/lib.rs b/substrate/client/proposer-metrics/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..012e8ca769a96cb51141c5a13ca7ba04d76a8123
--- /dev/null
+++ b/substrate/client/proposer-metrics/src/lib.rs
@@ -0,0 +1,119 @@
+// 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/>.
+
+//! Prometheus basic proposer metrics.
+
+use prometheus_endpoint::{
+	prometheus::CounterVec, register, Gauge, Histogram, HistogramOpts, Opts, PrometheusError,
+	Registry, U64,
+};
+
+/// Optional shareable link to basic authorship metrics.
+#[derive(Clone, Default)]
+pub struct MetricsLink(Option<Metrics>);
+
+impl MetricsLink {
+	pub fn new(registry: Option<&Registry>) -> Self {
+		Self(registry.and_then(|registry| {
+			Metrics::register(registry)
+				.map_err(|err| {
+					log::warn!("Failed to register proposer prometheus metrics: {}", err)
+				})
+				.ok()
+		}))
+	}
+
+	pub fn report<O>(&self, do_this: impl FnOnce(&Metrics) -> O) -> Option<O> {
+		self.0.as_ref().map(do_this)
+	}
+}
+
+/// The reason why proposing a block ended.
+pub enum EndProposingReason {
+	NoMoreTransactions,
+	HitDeadline,
+	HitBlockSizeLimit,
+	HitBlockWeightLimit,
+}
+
+/// Authorship metrics.
+#[derive(Clone)]
+pub struct Metrics {
+	pub block_constructed: Histogram,
+	pub number_of_transactions: Gauge<U64>,
+	pub end_proposing_reason: CounterVec,
+	pub create_inherents_time: Histogram,
+	pub create_block_proposal_time: Histogram,
+}
+
+impl Metrics {
+	pub fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			block_constructed: register(
+				Histogram::with_opts(HistogramOpts::new(
+					"substrate_proposer_block_constructed",
+					"Histogram of time taken to construct new block",
+				))?,
+				registry,
+			)?,
+			number_of_transactions: register(
+				Gauge::new(
+					"substrate_proposer_number_of_transactions",
+					"Number of transactions included in block",
+				)?,
+				registry,
+			)?,
+			create_inherents_time: register(
+				Histogram::with_opts(HistogramOpts::new(
+					"substrate_proposer_create_inherents_time",
+					"Histogram of time taken to execute create inherents",
+				))?,
+				registry,
+			)?,
+			create_block_proposal_time: register(
+				Histogram::with_opts(HistogramOpts::new(
+					"substrate_proposer_block_proposal_time",
+					"Histogram of time taken to construct a block and prepare it for proposal",
+				))?,
+				registry,
+			)?,
+			end_proposing_reason: register(
+				CounterVec::new(
+					Opts::new(
+						"substrate_proposer_end_proposal_reason",
+						"The reason why the block proposing was ended. This doesn't include errors.",
+					),
+					&["reason"],
+				)?,
+				registry,
+			)?,
+		})
+	}
+
+	/// Report the reason why the proposing ended.
+	pub fn report_end_proposing_reason(&self, reason: EndProposingReason) {
+		let reason = match reason {
+			EndProposingReason::HitDeadline => "hit_deadline",
+			EndProposingReason::NoMoreTransactions => "no_more_transactions",
+			EndProposingReason::HitBlockSizeLimit => "hit_block_size_limit",
+			EndProposingReason::HitBlockWeightLimit => "hit_block_weight_limit",
+		};
+
+		self.end_proposing_reason.with_label_values(&[reason]).inc();
+	}
+}
diff --git a/substrate/client/rpc-api/Cargo.toml b/substrate/client/rpc-api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5efb10f719c20dbad7561b8052b2b84ace4a8801
--- /dev/null
+++ b/substrate/client/rpc-api/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "sc-rpc-api"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate RPC interfaces."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive"] }
+serde_json = "1.0.85"
+thiserror = "1.0"
+sc-chain-spec = { version = "4.0.0-dev", path = "../chain-spec" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../transaction-pool/api" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-rpc = { version = "6.0.0", path = "../../primitives/rpc" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-version = { version = "22.0.0", path = "../../primitives/version" }
+jsonrpsee = { version = "0.16.2", features = ["server", "client-core", "macros"] }
diff --git a/substrate/client/rpc-api/README.md b/substrate/client/rpc-api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e860e0c2334da50e57bee241b14e2807b25bc7f3
--- /dev/null
+++ b/substrate/client/rpc-api/README.md
@@ -0,0 +1,5 @@
+Substrate RPC interfaces.
+
+A collection of RPC methods and subscriptions supported by all substrate clients.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/rpc-api/src/author/error.rs b/substrate/client/rpc-api/src/author/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..648dbb295d8d041d154e154e40cc8a1c53f699df
--- /dev/null
+++ b/substrate/client/rpc-api/src/author/error.rs
@@ -0,0 +1,183 @@
+// 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/>.
+
+//! Authoring RPC module errors.
+
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+use sp_runtime::transaction_validity::InvalidTransaction;
+
+/// Author RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Author RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Client error.
+	#[error("Client error: {}", .0)]
+	Client(Box<dyn std::error::Error + Send + Sync>),
+	/// Transaction pool error,
+	#[error("Transaction pool error: {}", .0)]
+	Pool(#[from] sc_transaction_pool_api::error::Error),
+	/// Verification error
+	#[error("Extrinsic verification error: {}", .0)]
+	Verification(Box<dyn std::error::Error + Send + Sync>),
+	/// Incorrect extrinsic format.
+	#[error("Invalid extrinsic format: {}", .0)]
+	BadFormat(#[from] codec::Error),
+	/// Key type ID has an unknown format.
+	#[error("Invalid key type ID format (should be of length four)")]
+	BadKeyType,
+	/// Some random issue with the key store. Shouldn't happen.
+	#[error("The key store is unavailable")]
+	KeystoreUnavailable,
+	/// Invalid session keys encoding.
+	#[error("Session keys are not encoded correctly")]
+	InvalidSessionKeys,
+	/// Call to an unsafe RPC was denied.
+	#[error(transparent)]
+	UnsafeRpcCalled(#[from] crate::policy::UnsafeRpcError),
+}
+
+/// Base code for all authorship errors.
+const BASE_ERROR: i32 = crate::error::base::AUTHOR;
+/// Extrinsic has an invalid format.
+const BAD_FORMAT: i32 = BASE_ERROR + 1;
+/// Error during transaction verification in runtime.
+const VERIFICATION_ERROR: i32 = BASE_ERROR + 2;
+
+/// Pool rejected the transaction as invalid
+const POOL_INVALID_TX: i32 = BASE_ERROR + 10;
+/// Cannot determine transaction validity.
+const POOL_UNKNOWN_VALIDITY: i32 = POOL_INVALID_TX + 1;
+/// The transaction is temporarily banned.
+const POOL_TEMPORARILY_BANNED: i32 = POOL_INVALID_TX + 2;
+/// The transaction is already in the pool
+const POOL_ALREADY_IMPORTED: i32 = POOL_INVALID_TX + 3;
+/// Transaction has too low priority to replace existing one in the pool.
+const POOL_TOO_LOW_PRIORITY: i32 = POOL_INVALID_TX + 4;
+/// Including this transaction would cause a dependency cycle.
+const POOL_CYCLE_DETECTED: i32 = POOL_INVALID_TX + 5;
+/// The transaction was not included to the pool because of the limits.
+const POOL_IMMEDIATELY_DROPPED: i32 = POOL_INVALID_TX + 6;
+/// The transaction was not included to the pool since it is unactionable,
+/// it is not propagable and the local node does not author blocks.
+const POOL_UNACTIONABLE: i32 = POOL_INVALID_TX + 8;
+/// Transaction does not provide any tags, so the pool can't identify it.
+const POOL_NO_TAGS: i32 = POOL_INVALID_TX + 9;
+/// Invalid block ID.
+const POOL_INVALID_BLOCK_ID: i32 = POOL_INVALID_TX + 10;
+/// The pool is not accepting future transactions.
+const POOL_FUTURE_TX: i32 = POOL_INVALID_TX + 11;
+
+impl From<Error> for JsonRpseeError {
+	fn from(e: Error) -> Self {
+		use sc_transaction_pool_api::error::Error as PoolError;
+
+		match e {
+			Error::BadFormat(e) => CallError::Custom(ErrorObject::owned(
+				BAD_FORMAT,
+				format!("Extrinsic has invalid format: {}", e),
+				None::<()>,
+			)),
+			Error::Verification(e) => CallError::Custom(ErrorObject::owned(
+				VERIFICATION_ERROR,
+				format!("Verification Error: {}", e),
+				Some(format!("{:?}", e)),
+			)),
+			Error::Pool(PoolError::InvalidTransaction(InvalidTransaction::Custom(e))) => {
+				CallError::Custom(ErrorObject::owned(
+					POOL_INVALID_TX,
+					"Invalid Transaction",
+					Some(format!("Custom error: {}", e)),
+				))
+			},
+			Error::Pool(PoolError::InvalidTransaction(e)) => {
+				let msg: &str = e.into();
+				CallError::Custom(ErrorObject::owned(
+					POOL_INVALID_TX,
+					"Invalid Transaction",
+					Some(msg),
+				))
+			},
+			Error::Pool(PoolError::UnknownTransaction(e)) => {
+				CallError::Custom(ErrorObject::owned(
+					POOL_UNKNOWN_VALIDITY,
+					"Unknown Transaction Validity",
+					Some(format!("{:?}", e)),
+				))
+			},
+			Error::Pool(PoolError::TemporarilyBanned) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_TEMPORARILY_BANNED,
+				"Transaction is temporarily banned",
+				None::<()>,
+			)),
+			Error::Pool(PoolError::AlreadyImported(hash)) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_ALREADY_IMPORTED,
+				"Transaction Already Imported",
+				Some(format!("{:?}", hash)),
+			)),
+			Error::Pool(PoolError::TooLowPriority { old, new }) => CallError::Custom(ErrorObject::owned(
+				POOL_TOO_LOW_PRIORITY,
+				format!("Priority is too low: ({} vs {})", old, new),
+				Some("The transaction has too low priority to replace another transaction already in the pool.")
+			)),
+			Error::Pool(PoolError::CycleDetected) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_CYCLE_DETECTED,
+				"Cycle Detected",
+				None::<()>
+			)),
+			Error::Pool(PoolError::ImmediatelyDropped) => CallError::Custom(ErrorObject::owned(
+				POOL_IMMEDIATELY_DROPPED,
+				"Immediately Dropped",
+				Some("The transaction couldn't enter the pool because of the limit"),
+			)),
+			Error::Pool(PoolError::Unactionable) => CallError::Custom(ErrorObject::owned(
+				POOL_UNACTIONABLE,
+				"Unactionable",
+				Some("The transaction is unactionable since it is not propagable and \
+				the local node does not author blocks")
+			)),
+			Error::Pool(PoolError::NoTagsProvided) => CallError::Custom(ErrorObject::owned(
+				POOL_NO_TAGS,
+				"No tags provided",
+				Some("Transaction does not provide any tags, so the pool can't identify it")
+			)),
+			Error::Pool(PoolError::InvalidBlockId(_)) =>
+				CallError::Custom(ErrorObject::owned(
+				POOL_INVALID_BLOCK_ID,
+				"The provided block ID is not valid",
+				None::<()>
+			)),
+			Error::Pool(PoolError::RejectedFutureTransaction) => {
+				CallError::Custom(ErrorObject::owned(
+					POOL_FUTURE_TX,
+					"The pool is not accepting future transactions",
+					None::<()>,
+				))
+			},
+			Error::UnsafeRpcCalled(e) => e.into(),
+			e => CallError::Failed(e.into()),
+		}.into()
+	}
+}
diff --git a/substrate/client/rpc-api/src/author/hash.rs b/substrate/client/rpc-api/src/author/hash.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5c9542ffedcd0018503b3fefe901b41dfb6457b0
--- /dev/null
+++ b/substrate/client/rpc-api/src/author/hash.rs
@@ -0,0 +1,34 @@
+// 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/>.
+
+//! Extrinsic helpers for author RPC module.
+
+use serde::{Deserialize, Serialize};
+use sp_core::Bytes;
+
+/// RPC Extrinsic or hash
+///
+/// Allows to refer to extrinsic either by its raw representation or its hash.
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ExtrinsicOrHash<Hash> {
+	/// The hash of the extrinsic.
+	Hash(Hash),
+	/// Raw extrinsic bytes.
+	Extrinsic(Bytes),
+}
diff --git a/substrate/client/rpc-api/src/author/mod.rs b/substrate/client/rpc-api/src/author/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..55881e62152e3dc573fadea006f0b845415cf3e3
--- /dev/null
+++ b/substrate/client/rpc-api/src/author/mod.rs
@@ -0,0 +1,78 @@
+// 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/>.
+
+//! Substrate block-author/full-node API.
+
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sc_transaction_pool_api::TransactionStatus;
+use sp_core::Bytes;
+
+pub mod error;
+pub mod hash;
+
+/// Substrate authoring RPC API
+#[rpc(client, server)]
+pub trait AuthorApi<Hash, BlockHash> {
+	/// Submit hex-encoded extrinsic for inclusion in block.
+	#[method(name = "author_submitExtrinsic")]
+	async fn submit_extrinsic(&self, extrinsic: Bytes) -> RpcResult<Hash>;
+
+	/// Insert a key into the keystore.
+	#[method(name = "author_insertKey")]
+	fn insert_key(&self, key_type: String, suri: String, public: Bytes) -> RpcResult<()>;
+
+	/// Generate new session keys and returns the corresponding public keys.
+	#[method(name = "author_rotateKeys")]
+	fn rotate_keys(&self) -> RpcResult<Bytes>;
+
+	/// Checks if the keystore has private keys for the given session public keys.
+	///
+	/// `session_keys` is the SCALE encoded session keys object from the runtime.
+	///
+	/// Returns `true` iff all private keys could be found.
+	#[method(name = "author_hasSessionKeys")]
+	fn has_session_keys(&self, session_keys: Bytes) -> RpcResult<bool>;
+
+	/// Checks if the keystore has private keys for the given public key and key type.
+	///
+	/// Returns `true` if a private key could be found.
+	#[method(name = "author_hasKey")]
+	fn has_key(&self, public_key: Bytes, key_type: String) -> RpcResult<bool>;
+
+	/// Returns all pending extrinsics, potentially grouped by sender.
+	#[method(name = "author_pendingExtrinsics")]
+	fn pending_extrinsics(&self) -> RpcResult<Vec<Bytes>>;
+
+	/// Remove given extrinsic from the pool and temporarily ban it to prevent reimporting.
+	#[method(name = "author_removeExtrinsic")]
+	fn remove_extrinsic(
+		&self,
+		bytes_or_hash: Vec<hash::ExtrinsicOrHash<Hash>>,
+	) -> RpcResult<Vec<Hash>>;
+
+	/// Submit an extrinsic to watch.
+	///
+	/// See [`TransactionStatus`](sc_transaction_pool_api::TransactionStatus) for details on
+	/// transaction life cycle.
+	#[subscription(
+		name = "author_submitAndWatchExtrinsic" => "author_extrinsicUpdate",
+		unsubscribe = "author_unwatchExtrinsic",
+		item = TransactionStatus<Hash, BlockHash>,
+	)]
+	fn watch_extrinsic(&self, bytes: Bytes);
+}
diff --git a/substrate/client/rpc-api/src/chain/error.rs b/substrate/client/rpc-api/src/chain/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..652192942588856209a37d18cfb6f1c3e22203b6
--- /dev/null
+++ b/substrate/client/rpc-api/src/chain/error.rs
@@ -0,0 +1,50 @@
+// 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/>.
+
+//! Error helpers for Chain RPC module.
+
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+/// Chain RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Chain RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Client error.
+	#[error("Client error: {}", .0)]
+	Client(#[from] Box<dyn std::error::Error + Send + Sync>),
+	/// Other error type.
+	#[error("{0}")]
+	Other(String),
+}
+
+/// Base error code for all chain errors.
+const BASE_ERROR: i32 = crate::error::base::CHAIN;
+
+impl From<Error> for JsonRpseeError {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::Other(message) =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 1, message, None::<()>)).into(),
+			e => e.into(),
+		}
+	}
+}
diff --git a/substrate/client/rpc-api/src/chain/mod.rs b/substrate/client/rpc-api/src/chain/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f215cd978f03a0c7d2b95b0c0043e35f63da43cc
--- /dev/null
+++ b/substrate/client/rpc-api/src/chain/mod.rs
@@ -0,0 +1,76 @@
+// 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/>.
+
+//! Substrate blockchain API.
+
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sp_rpc::{list::ListOrValue, number::NumberOrHex};
+
+pub mod error;
+
+#[rpc(client, server)]
+pub trait ChainApi<Number, Hash, Header, SignedBlock> {
+	/// Get header.
+	#[method(name = "chain_getHeader", blocking)]
+	fn header(&self, hash: Option<Hash>) -> RpcResult<Option<Header>>;
+
+	/// Get header and body of a block.
+	#[method(name = "chain_getBlock", blocking)]
+	fn block(&self, hash: Option<Hash>) -> RpcResult<Option<SignedBlock>>;
+
+	/// Get hash of the n-th block in the canon chain.
+	///
+	/// By default returns latest block hash.
+	#[method(name = "chain_getBlockHash", aliases = ["chain_getHead"], blocking)]
+	fn block_hash(
+		&self,
+		hash: Option<ListOrValue<NumberOrHex>>,
+	) -> RpcResult<ListOrValue<Option<Hash>>>;
+
+	/// Get hash of the last finalized block in the canon chain.
+	#[method(name = "chain_getFinalizedHead", aliases = ["chain_getFinalisedHead"], blocking)]
+	fn finalized_head(&self) -> RpcResult<Hash>;
+
+	/// All head subscription.
+	#[subscription(
+		name = "chain_subscribeAllHeads" => "chain_allHead",
+		unsubscribe = "chain_unsubscribeAllHeads",
+		item = Header
+	)]
+	fn subscribe_all_heads(&self);
+
+	/// New head subscription.
+	#[subscription(
+		name = "chain_subscribeNewHeads" => "chain_newHead",
+		aliases = ["subscribe_newHead", "chain_subscribeNewHead"],
+		unsubscribe = "chain_unsubscribeNewHeads",
+		unsubscribe_aliases = ["unsubscribe_newHead", "chain_unsubscribeNewHead"],
+		item = Header
+	)]
+	fn subscribe_new_heads(&self);
+
+	/// Finalized head subscription.
+	#[subscription(
+		name = "chain_subscribeFinalizedHeads" => "chain_finalizedHead",
+		aliases = ["chain_subscribeFinalisedHeads"],
+		unsubscribe = "chain_unsubscribeFinalizedHeads",
+		unsubscribe_aliases = ["chain_unsubscribeFinalisedHeads"],
+		item = Header
+	)]
+	fn subscribe_finalized_heads(&self);
+}
diff --git a/substrate/client/rpc-api/src/child_state/mod.rs b/substrate/client/rpc-api/src/child_state/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a184677a721b5f0f98585b0f97317872c1e4b670
--- /dev/null
+++ b/substrate/client/rpc-api/src/child_state/mod.rs
@@ -0,0 +1,97 @@
+// 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/>.
+
+//! Substrate child state API
+use crate::state::ReadProof;
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sp_core::storage::{PrefixedStorageKey, StorageData, StorageKey};
+
+/// Substrate child state API
+///
+/// Note that all `PrefixedStorageKey` are deserialized
+/// from json and not guaranteed valid.
+#[rpc(client, server)]
+pub trait ChildStateApi<Hash> {
+	/// Returns the keys with prefix from a child storage, leave empty to get all the keys
+	#[method(name = "childstate_getKeys", blocking)]
+	#[deprecated(since = "2.0.0", note = "Please use `getKeysPaged` with proper paging support")]
+	fn storage_keys(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		prefix: StorageKey,
+		hash: Option<Hash>,
+	) -> RpcResult<Vec<StorageKey>>;
+
+	/// Returns the keys with prefix from a child storage with pagination support.
+	/// Up to `count` keys will be returned.
+	/// If `start_key` is passed, return next keys in storage in lexicographic order.
+	#[method(name = "childstate_getKeysPaged", aliases = ["childstate_getKeysPagedAt"], blocking)]
+	fn storage_keys_paged(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+		hash: Option<Hash>,
+	) -> RpcResult<Vec<StorageKey>>;
+
+	/// Returns a child storage entry at a specific block's state.
+	#[method(name = "childstate_getStorage", blocking)]
+	fn storage(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		key: StorageKey,
+		hash: Option<Hash>,
+	) -> RpcResult<Option<StorageData>>;
+
+	/// Returns child storage entries for multiple keys at a specific block's state.
+	#[method(name = "childstate_getStorageEntries", blocking)]
+	fn storage_entries(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		hash: Option<Hash>,
+	) -> RpcResult<Vec<Option<StorageData>>>;
+
+	/// Returns the hash of a child storage entry at a block's state.
+	#[method(name = "childstate_getStorageHash", blocking)]
+	fn storage_hash(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		key: StorageKey,
+		hash: Option<Hash>,
+	) -> RpcResult<Option<Hash>>;
+
+	/// Returns the size of a child storage entry at a block's state.
+	#[method(name = "childstate_getStorageSize", blocking)]
+	fn storage_size(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		key: StorageKey,
+		hash: Option<Hash>,
+	) -> RpcResult<Option<u64>>;
+
+	/// Returns proof of storage for child key entries at a specific block's state.
+	#[method(name = "state_getChildReadProof", blocking)]
+	fn read_child_proof(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		hash: Option<Hash>,
+	) -> RpcResult<ReadProof<Hash>>;
+}
diff --git a/substrate/client/rpc-api/src/dev/error.rs b/substrate/client/rpc-api/src/dev/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8e4ddb55e35d77fee79cdb9411ab3b0647b12661
--- /dev/null
+++ b/substrate/client/rpc-api/src/dev/error.rs
@@ -0,0 +1,66 @@
+// 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/>.
+
+//! Error helpers for Dev RPC module.
+
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+
+/// Dev RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Failed to query specified block or its parent: Probably an invalid hash.
+	#[error("Error while querying block: {0}")]
+	BlockQueryError(Box<dyn std::error::Error + Send>),
+	/// The re-execution of the specified block failed.
+	#[error("Failed to re-execute the specified block")]
+	BlockExecutionFailed,
+	/// Failed to extract the proof.
+	#[error("Failed to extract the proof")]
+	ProofExtractionFailed,
+	/// The witness compaction failed.
+	#[error("Failed to create to compact the witness")]
+	WitnessCompactionFailed,
+	/// The method is marked as unsafe but unsafe flag wasn't supplied on the CLI.
+	#[error(transparent)]
+	UnsafeRpcCalled(#[from] crate::policy::UnsafeRpcError),
+}
+
+/// Base error code for all dev errors.
+const BASE_ERROR: i32 = crate::error::base::DEV;
+
+impl From<Error> for JsonRpseeError {
+	fn from(e: Error) -> Self {
+		let msg = e.to_string();
+
+		match e {
+			Error::BlockQueryError(_) =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 1, msg, None::<()>)),
+			Error::BlockExecutionFailed =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 3, msg, None::<()>)),
+			Error::WitnessCompactionFailed =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 4, msg, None::<()>)),
+			Error::ProofExtractionFailed =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 5, msg, None::<()>)),
+			Error::UnsafeRpcCalled(e) => e.into(),
+		}
+		.into()
+	}
+}
diff --git a/substrate/client/rpc-api/src/dev/mod.rs b/substrate/client/rpc-api/src/dev/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bc7216199dd747bb373fc691cdef4b9a32d08456
--- /dev/null
+++ b/substrate/client/rpc-api/src/dev/mod.rs
@@ -0,0 +1,63 @@
+// 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/>.
+
+//! Substrate dev API containing RPCs that are mainly meant for debugging and stats collection for
+//! developers. The endpoints in this RPC module are not meant to be available to non-local users
+//! and are all marked `unsafe`.
+
+pub mod error;
+
+use codec::{Decode, Encode};
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use scale_info::TypeInfo;
+use serde::{Deserialize, Serialize};
+
+/// Statistics of a block returned by the `dev_getBlockStats` RPC.
+#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BlockStats {
+	/// The length in bytes of the storage proof produced by executing the block.
+	pub witness_len: u64,
+	/// The length in bytes of the storage proof after compaction.
+	pub witness_compact_len: u64,
+	/// Length of the block in bytes.
+	///
+	/// This information can also be acquired by downloading the whole block. This merely
+	/// saves some complexity on the client side.
+	pub block_len: u64,
+	/// Number of extrinsics in the block.
+	///
+	/// This information can also be acquired by downloading the whole block. This merely
+	/// saves some complexity on the client side.
+	pub num_extrinsics: u64,
+}
+
+/// Substrate dev API.
+///
+/// This API contains unstable and unsafe methods only meant for development nodes. They
+/// are all flagged as unsafe for this reason.
+#[rpc(client, server)]
+pub trait DevApi<Hash> {
+	/// Reexecute the specified `block_hash` and gather statistics while doing so.
+	///
+	/// This function requires the specified block and its parent to be available
+	/// at the queried node. If either the specified block or the parent is pruned,
+	/// this function will return `None`.
+	#[method(name = "dev_getBlockStats")]
+	fn block_stats(&self, block_hash: Hash) -> RpcResult<Option<BlockStats>>;
+}
diff --git a/substrate/client/rpc-api/src/error.rs b/substrate/client/rpc-api/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..72941e3145b94424bc16fdd77d0dc2117e89eecb
--- /dev/null
+++ b/substrate/client/rpc-api/src/error.rs
@@ -0,0 +1,28 @@
+// 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/>.
+
+/// Base error code for RPC modules.
+pub mod base {
+	pub const AUTHOR: i32 = 1000;
+	pub const SYSTEM: i32 = 2000;
+	pub const CHAIN: i32 = 3000;
+	pub const STATE: i32 = 4000;
+	pub const OFFCHAIN: i32 = 5000;
+	pub const DEV: i32 = 6000;
+	pub const STATEMENT: i32 = 7000;
+}
diff --git a/substrate/client/rpc-api/src/lib.rs b/substrate/client/rpc-api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b99c237dc859bc1fd03a87c63b365956b7a6f5a1
--- /dev/null
+++ b/substrate/client/rpc-api/src/lib.rs
@@ -0,0 +1,37 @@
+// 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/>.
+
+//! Substrate RPC interfaces.
+//!
+//! A collection of RPC methods and subscriptions supported by all substrate clients.
+
+#![warn(missing_docs)]
+
+mod error;
+mod policy;
+
+pub use policy::DenyUnsafe;
+
+pub mod author;
+pub mod chain;
+pub mod child_state;
+pub mod dev;
+pub mod offchain;
+pub mod state;
+pub mod statement;
+pub mod system;
diff --git a/substrate/client/rpc-api/src/offchain/error.rs b/substrate/client/rpc-api/src/offchain/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..679e100089734357cb27580e43fecf6917985935
--- /dev/null
+++ b/substrate/client/rpc-api/src/offchain/error.rs
@@ -0,0 +1,55 @@
+// 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/>.
+
+//! Offchain RPC errors.
+
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+
+/// Offchain RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Offchain RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Unavailable storage kind error.
+	#[error("This storage kind is not available yet.")]
+	UnavailableStorageKind,
+	/// Call to an unsafe RPC was denied.
+	#[error(transparent)]
+	UnsafeRpcCalled(#[from] crate::policy::UnsafeRpcError),
+}
+
+/// Base error code for all offchain errors.
+const BASE_ERROR: i32 = crate::error::base::OFFCHAIN;
+
+impl From<Error> for JsonRpseeError {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::UnavailableStorageKind => CallError::Custom(ErrorObject::owned(
+				BASE_ERROR + 1,
+				"This storage kind is not available yet",
+				None::<()>,
+			))
+			.into(),
+			Error::UnsafeRpcCalled(e) => e.into(),
+		}
+	}
+}
diff --git a/substrate/client/rpc-api/src/offchain/mod.rs b/substrate/client/rpc-api/src/offchain/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cd42d6db350810a302af550fa7711eeef15e2995
--- /dev/null
+++ b/substrate/client/rpc-api/src/offchain/mod.rs
@@ -0,0 +1,36 @@
+// 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/>.
+
+//! Substrate offchain API.
+
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sp_core::{offchain::StorageKind, Bytes};
+
+pub mod error;
+
+/// Substrate offchain RPC API
+#[rpc(client, server)]
+pub trait OffchainApi {
+	/// Set offchain local storage under given key and prefix.
+	#[method(name = "offchain_localStorageSet")]
+	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> RpcResult<()>;
+
+	/// Get offchain local storage under given key and prefix.
+	#[method(name = "offchain_localStorageGet")]
+	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> RpcResult<Option<Bytes>>;
+}
diff --git a/substrate/client/rpc-api/src/policy.rs b/substrate/client/rpc-api/src/policy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..799898fb7cf5371c630c50e35b635ed2bd43da7c
--- /dev/null
+++ b/substrate/client/rpc-api/src/policy.rs
@@ -0,0 +1,78 @@
+// 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/>.
+
+//! Policy-related types.
+//!
+//! Contains a `DenyUnsafe` type that can be used to deny potentially unsafe
+//! RPC when accessed externally.
+
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::{
+		error::{CallError, ErrorCode},
+		ErrorObject,
+	},
+};
+
+/// Signifies whether a potentially unsafe RPC should be denied.
+#[derive(Clone, Copy, Debug)]
+pub enum DenyUnsafe {
+	/// Denies only potentially unsafe RPCs.
+	Yes,
+	/// Allows calling every RPCs.
+	No,
+}
+
+impl DenyUnsafe {
+	/// Returns `Ok(())` if the RPCs considered unsafe are safe to call,
+	/// otherwise returns `Err(UnsafeRpcError)`.
+	pub fn check_if_safe(self) -> Result<(), UnsafeRpcError> {
+		match self {
+			DenyUnsafe::Yes => Err(UnsafeRpcError),
+			DenyUnsafe::No => Ok(()),
+		}
+	}
+}
+
+/// Signifies whether an RPC considered unsafe is denied to be called externally.
+#[derive(Debug)]
+pub struct UnsafeRpcError;
+
+impl std::fmt::Display for UnsafeRpcError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "RPC call is unsafe to be called externally")
+	}
+}
+
+impl std::error::Error for UnsafeRpcError {}
+
+impl From<UnsafeRpcError> for CallError {
+	fn from(e: UnsafeRpcError) -> CallError {
+		CallError::Custom(ErrorObject::owned(
+			ErrorCode::MethodNotFound.code(),
+			e.to_string(),
+			None::<()>,
+		))
+	}
+}
+
+impl From<UnsafeRpcError> for JsonRpseeError {
+	fn from(e: UnsafeRpcError) -> JsonRpseeError {
+		JsonRpseeError::Call(e.into())
+	}
+}
diff --git a/substrate/client/rpc-api/src/state/error.rs b/substrate/client/rpc-api/src/state/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9857784e3545cdd3bf944293542c2a31a373cb60
--- /dev/null
+++ b/substrate/client/rpc-api/src/state/error.rs
@@ -0,0 +1,72 @@
+// 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/>.
+
+//! State RPC errors.
+
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+/// State RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// State RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Client error.
+	#[error("Client error: {}", .0)]
+	Client(#[from] Box<dyn std::error::Error + Send + Sync>),
+	/// Provided block range couldn't be resolved to a list of blocks.
+	#[error("Cannot resolve a block range ['{:?}' ... '{:?}]. {}", .from, .to, .details)]
+	InvalidBlockRange {
+		/// Beginning of the block range.
+		from: String,
+		/// End of the block range.
+		to: String,
+		/// Details of the error message.
+		details: String,
+	},
+	/// Provided count exceeds maximum value.
+	#[error("count exceeds maximum value. value: {}, max: {}", .value, .max)]
+	InvalidCount {
+		/// Provided value
+		value: u32,
+		/// Maximum allowed value
+		max: u32,
+	},
+	/// Call to an unsafe RPC was denied.
+	#[error(transparent)]
+	UnsafeRpcCalled(#[from] crate::policy::UnsafeRpcError),
+}
+
+/// Base code for all state errors.
+const BASE_ERROR: i32 = crate::error::base::STATE;
+
+impl From<Error> for JsonRpseeError {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::InvalidBlockRange { .. } =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 1, e.to_string(), None::<()>))
+					.into(),
+			Error::InvalidCount { .. } =>
+				CallError::Custom(ErrorObject::owned(BASE_ERROR + 2, e.to_string(), None::<()>))
+					.into(),
+			e => Self::to_call_error(e),
+		}
+	}
+}
diff --git a/substrate/client/rpc-api/src/state/helpers.rs b/substrate/client/rpc-api/src/state/helpers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..de20ee6f1bdfc4c66239854ef9fda051ff87a95b
--- /dev/null
+++ b/substrate/client/rpc-api/src/state/helpers.rs
@@ -0,0 +1,32 @@
+// 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/>.
+
+//! Substrate state API helpers.
+
+use serde::{Deserialize, Serialize};
+use sp_core::Bytes;
+
+/// ReadProof struct returned by the RPC
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReadProof<Hash> {
+	/// Block hash used to generate the proof
+	pub at: Hash,
+	/// A proof used to prove that storage entries are included in the storage trie
+	pub proof: Vec<Bytes>,
+}
diff --git a/substrate/client/rpc-api/src/state/mod.rs b/substrate/client/rpc-api/src/state/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dbc2a505456a50eca9df415314f49c0d799bcf5b
--- /dev/null
+++ b/substrate/client/rpc-api/src/state/mod.rs
@@ -0,0 +1,292 @@
+// 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/>.
+
+//! Substrate state API.
+
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sp_core::{
+	storage::{StorageChangeSet, StorageData, StorageKey},
+	Bytes,
+};
+use sp_version::RuntimeVersion;
+
+pub mod error;
+pub mod helpers;
+
+pub use self::helpers::ReadProof;
+
+/// Substrate state API
+#[rpc(client, server)]
+pub trait StateApi<Hash> {
+	/// Call a method from the runtime API at a block's state.
+	#[method(name = "state_call", aliases = ["state_callAt"], blocking)]
+	fn call(&self, name: String, bytes: Bytes, hash: Option<Hash>) -> RpcResult<Bytes>;
+
+	/// Returns the keys with prefix, leave empty to get all the keys.
+	#[method(name = "state_getKeys", blocking)]
+	#[deprecated(since = "2.0.0", note = "Please use `getKeysPaged` with proper paging support")]
+	fn storage_keys(&self, prefix: StorageKey, hash: Option<Hash>) -> RpcResult<Vec<StorageKey>>;
+
+	/// Returns the keys with prefix, leave empty to get all the keys
+	#[method(name = "state_getPairs", blocking)]
+	fn storage_pairs(
+		&self,
+		prefix: StorageKey,
+		hash: Option<Hash>,
+	) -> RpcResult<Vec<(StorageKey, StorageData)>>;
+
+	/// Returns the keys with prefix with pagination support.
+	/// Up to `count` keys will be returned.
+	/// If `start_key` is passed, return next keys in storage in lexicographic order.
+	#[method(name = "state_getKeysPaged", aliases = ["state_getKeysPagedAt"], blocking)]
+	fn storage_keys_paged(
+		&self,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+		hash: Option<Hash>,
+	) -> RpcResult<Vec<StorageKey>>;
+
+	/// Returns a storage entry at a specific block's state.
+	#[method(name = "state_getStorage", aliases = ["state_getStorageAt"], blocking)]
+	fn storage(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<StorageData>>;
+
+	/// Returns the hash of a storage entry at a block's state.
+	#[method(name = "state_getStorageHash", aliases = ["state_getStorageHashAt"], blocking)]
+	fn storage_hash(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<Hash>>;
+
+	/// Returns the size of a storage entry at a block's state.
+	#[method(name = "state_getStorageSize", aliases = ["state_getStorageSizeAt"])]
+	async fn storage_size(&self, key: StorageKey, hash: Option<Hash>) -> RpcResult<Option<u64>>;
+
+	/// Returns the runtime metadata as an opaque blob.
+	#[method(name = "state_getMetadata", blocking)]
+	fn metadata(&self, hash: Option<Hash>) -> RpcResult<Bytes>;
+
+	/// Get the runtime version.
+	#[method(name = "state_getRuntimeVersion", aliases = ["chain_getRuntimeVersion"], blocking)]
+	fn runtime_version(&self, hash: Option<Hash>) -> RpcResult<RuntimeVersion>;
+
+	/// Query historical storage entries (by key) starting from a block given as the second
+	/// parameter.
+	///
+	/// NOTE: The first returned result contains the initial state of storage for all keys.
+	/// Subsequent values in the vector represent changes to the previous state (diffs).
+	/// WARNING: The time complexity of this query is O(|keys|*dist(block, hash)), and the
+	/// memory complexity is O(dist(block, hash)) -- use with caution.
+	#[method(name = "state_queryStorage", blocking)]
+	fn query_storage(
+		&self,
+		keys: Vec<StorageKey>,
+		block: Hash,
+		hash: Option<Hash>,
+	) -> RpcResult<Vec<StorageChangeSet<Hash>>>;
+
+	/// Query storage entries (by key) at a block hash given as the second parameter.
+	/// NOTE: Each StorageChangeSet in the result corresponds to exactly one element --
+	/// the storage value under an input key at the input block hash.
+	#[method(name = "state_queryStorageAt", blocking)]
+	fn query_storage_at(
+		&self,
+		keys: Vec<StorageKey>,
+		at: Option<Hash>,
+	) -> RpcResult<Vec<StorageChangeSet<Hash>>>;
+
+	/// Returns proof of storage entries at a specific block's state.
+	#[method(name = "state_getReadProof", blocking)]
+	fn read_proof(&self, keys: Vec<StorageKey>, hash: Option<Hash>) -> RpcResult<ReadProof<Hash>>;
+
+	/// New runtime version subscription
+	#[subscription(
+		name = "state_subscribeRuntimeVersion" => "state_runtimeVersion",
+		unsubscribe = "state_unsubscribeRuntimeVersion",
+		aliases = ["chain_subscribeRuntimeVersion"],
+		unsubscribe_aliases = ["chain_unsubscribeRuntimeVersion"],
+		item = RuntimeVersion,
+	)]
+	fn subscribe_runtime_version(&self);
+
+	/// New storage subscription
+	#[subscription(
+		name = "state_subscribeStorage" => "state_storage",
+		unsubscribe = "state_unsubscribeStorage",
+		item = StorageChangeSet<Hash>,
+	)]
+	fn subscribe_storage(&self, keys: Option<Vec<StorageKey>>);
+
+	/// The `traceBlock` RPC provides a way to trace the re-execution of a single
+	/// block, collecting Spans and Events from both the client and the relevant WASM runtime.
+	/// The Spans and Events are conceptually equivalent to those from the [Tracing][1] crate.
+	///
+	/// The structure of the traces follows that of the block execution pipeline, so meaningful
+	/// interpretation of the traces requires an understanding of the Substrate chain's block
+	/// execution.
+	///
+	/// [Link to conceptual map of trace structure for Polkadot and Kusama block execution.][2]
+	///
+	/// [1]: https://crates.io/crates/tracing
+	/// [2]: https://docs.google.com/drawings/d/1vZoJo9jaXlz0LmrdTOgHck9_1LsfuQPRmTr-5g1tOis/edit?usp=sharing
+	///
+	/// ## Node requirements
+	///
+	/// - Fully synced archive node (i.e. a node that is not actively doing a "major" sync).
+	/// - [Tracing enabled WASM runtimes](#creating-tracing-enabled-wasm-runtimes) for all runtime
+	///   versions
+	/// for which tracing is desired.
+	///
+	/// ## Node recommendations
+	///
+	/// - Use fast SSD disk storage.
+	/// - Run node flags to increase DB read speed (i.e. `--state-cache-size`, `--db-cache`).
+	///
+	/// ## Creating tracing enabled WASM runtimes
+	///
+	/// - Checkout commit of chain version to compile with WASM traces
+	/// - [diener][1] can help to peg commit of substrate to what the chain expects.
+	/// - Navigate to the `runtime` folder/package of the chain
+	/// - Add feature `with-tracing = ["frame-executive/with-tracing", "sp-io/with-tracing"]`
+	/// under `[features]` to the `runtime` packages' `Cargo.toml`.
+	/// - Compile the runtime with `cargo build --release --features with-tracing`
+	/// - Tracing-enabled WASM runtime should be found in
+	///   `./target/release/wbuild/{{chain}}-runtime`
+	/// and be called something like `{{your_chain}}_runtime.compact.wasm`. This can be
+	/// renamed/modified however you like, as long as it retains the `.wasm` extension.
+	/// - Run the node with the wasm blob overrides by placing them in a folder with all your
+	///   runtimes,
+	/// and passing the path of this folder to your chain, e.g.:
+	/// - `./target/release/polkadot --wasm-runtime-overrides /home/user/my-custom-wasm-runtimes`
+	///
+	/// You can also find some pre-built tracing enabled wasm runtimes in [substrate-archive][2]
+	///
+	/// [Source.][3]
+	///
+	/// [1]: https://crates.io/crates/diener
+	/// [2]: https://github.com/paritytech/substrate-archive/tree/master/wasm-tracing
+	/// [3]: https://github.com/paritytech/substrate-archive/wiki
+	///
+	/// ## RPC Usage
+	///
+	/// The RPC allows for two filtering mechanisms: tracing targets and storage key prefixes.
+	/// The filtering of spans and events takes place after they are all collected; so while filters
+	/// do not reduce time for actual block re-execution, they reduce the response payload size.
+	///
+	/// Note: storage events primarily come from _primitives/state-machine/src/ext.rs_.
+	/// The default filters can be overridden, see the [params section](#params) for details.
+	///
+	/// ### `curl` example
+	///
+	/// - Get tracing spans and events
+	/// ```text
+	/// curl \
+	/// 	-H "Content-Type: application/json" \
+	/// 	-d '{"id":1, "jsonrpc":"2.0", "method": "state_traceBlock", \
+	/// 		"params": ["0xb246acf1adea1f801ce15c77a5fa7d8f2eb8fed466978bcee172cc02cf64e264", "pallet,frame,state", "", ""]}' \
+	/// 	http://localhost:9933/
+	/// ```
+	///
+	/// - Get tracing events with all `storage_keys`
+	/// ```text
+	/// curl \
+	/// 	-H "Content-Type: application/json" \
+	/// 	-d '{"id":1, "jsonrpc":"2.0", "method": "state_traceBlock", \
+	/// 		"params": ["0xb246acf1adea1f801ce15c77a5fa7d8f2eb8fed466978bcee172cc02cf64e264", "state", "", ""]}' \
+	/// 	http://localhost:9933/
+	/// ```
+	///
+	/// - Get tracing events with `storage_keys` ('f0c365c3cf59d671eb72da0e7a4113c4')
+	/// ```text
+	/// curl \
+	/// 	-H "Content-Type: application/json" \
+	/// 	-d '{"id":1, "jsonrpc":"2.0", "method": "state_traceBlock", \
+	/// 		"params": ["0xb246acf1adea1f801ce15c77a5fa7d8f2eb8fed466978bcee172cc02cf64e264", "state", "f0c365c3cf59d671eb72da0e7a4113c4", ""]}' \
+	/// 	http://localhost:9933/
+	/// ```
+	///
+	/// - Get tracing events with `storage_keys` ('f0c365c3cf59d671eb72da0e7a4113c4') and method
+	///   ('Put')
+	/// ```text
+	/// curl \
+	/// 	-H "Content-Type: application/json" \
+	/// 	-d '{"id":1, "jsonrpc":"2.0", "method": "state_traceBlock", \
+	/// 		"params": ["0xb246acf1adea1f801ce15c77a5fa7d8f2eb8fed466978bcee172cc02cf64e264", "state", "f0c365c3cf59d671eb72da0e7a4113c4", "Put"]}' \
+	/// 	http://localhost:9933/
+	/// ```
+	///
+	/// - Get tracing events with all `storage_keys` and method ('Put')
+	/// ```text
+	/// curl \
+	/// 	-H "Content-Type: application/json" \
+	/// 	-d '{"id":1, "jsonrpc":"2.0", "method": "state_traceBlock", \
+	/// 		"params": ["0xb246acf1adea1f801ce15c77a5fa7d8f2eb8fed466978bcee172cc02cf64e264", "state", "", "Put"]}' \
+	/// 	http://localhost:9933/
+	/// ```
+	///
+	/// ### Params
+	///
+	/// - `block` (param index 0): Hash of the block to trace.
+	/// - `targets` (param index 1): String of comma separated (no spaces) targets. Specified
+	/// targets match with trace targets by prefix (i.e if a target is in the beginning
+	/// of a trace target it is considered a match). If an empty string is specified no
+	/// targets will be filtered out. The majority of targets correspond to Rust module names,
+	/// and the ones that do not are typically "hardcoded" into span or event location
+	/// somewhere in the Substrate source code. ("Non-hardcoded" targets typically come from frame
+	/// support macros.)
+	/// - `storage_keys` (param index 2): String of comma separated (no spaces) hex encoded
+	/// (no `0x` prefix) storage keys. If an empty string is specified no events will
+	/// be filtered out. If anything other than an empty string is specified, events
+	/// will be filtered by storage key (so non-storage events will **not** show up).
+	/// You can specify any length of a storage key prefix (i.e. if a specified storage
+	/// key is in the beginning of an events storage key it is considered a match).
+	/// Example: for balance tracking on Polkadot & Kusama you would likely want
+	/// to track changes to account balances with the frame_system::Account storage item,
+	/// which is a map from `AccountId` to `AccountInfo`. The key filter for this would be
+	/// the storage prefix for the map:
+	/// `26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9`
+	/// - `methods` (param index 3): String of comma separated (no spaces) tracing event method.
+	/// If an empty string is specified no events will be filtered out. If anything other than
+	/// an empty string is specified, events will be filtered by method (so non-method events will
+	/// **not** show up).
+	///
+	/// Additionally you would want to track the extrinsic index, which is under the
+	/// `:extrinsic_index` key. The key for this would be the aforementioned string as bytes
+	/// in hex: `3a65787472696e7369635f696e646578`.
+	/// The following are some resources to learn more about storage keys in substrate:
+	/// [substrate storage][1], [transparent keys in substrate][2],
+	/// [querying substrate storage via rpc][3].
+	///
+	/// [1]: https://docs.substrate.io/main-docs/fundamentals/state-transitions-and-storage/
+	/// [2]: https://www.shawntabrizi.com/substrate/transparent-keys-in-substrate/
+	/// [3]: https://www.shawntabrizi.com/substrate/querying-substrate-storage-via-rpc/
+	///
+	/// ### Maximum payload size
+	///
+	/// The maximum payload size allowed is 15mb. Payloads over this size will return a
+	/// object with a simple error message. If you run into issues with payload size you can
+	/// narrow down the traces using a smaller set of targets and/or storage keys.
+	///
+	/// If you are having issues with maximum payload size you can use the flag
+	/// `-ltracing=trace` to get some logging during tracing.
+	#[method(name = "state_traceBlock", blocking)]
+	fn trace_block(
+		&self,
+		block: Hash,
+		targets: Option<String>,
+		storage_keys: Option<String>,
+		methods: Option<String>,
+	) -> RpcResult<sp_rpc::tracing::TraceBlockResponse>;
+}
diff --git a/substrate/client/rpc-api/src/statement/error.rs b/substrate/client/rpc-api/src/statement/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8438cc3ec9e940a9a023bd6510f337d9cc08f4f3
--- /dev/null
+++ b/substrate/client/rpc-api/src/statement/error.rs
@@ -0,0 +1,55 @@
+// 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/>.
+
+//! Statement RPC errors.
+
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+
+/// Statement RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Statement RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Statement store internal error.
+	#[error("Statement store error")]
+	StatementStore(String),
+	/// Call to an unsafe RPC was denied.
+	#[error(transparent)]
+	UnsafeRpcCalled(#[from] crate::policy::UnsafeRpcError),
+}
+
+/// Base error code for all statement errors.
+const BASE_ERROR: i32 = crate::error::base::STATEMENT;
+
+impl From<Error> for JsonRpseeError {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::StatementStore(message) => CallError::Custom(ErrorObject::owned(
+				BASE_ERROR + 1,
+				format!("Statement store error: {message}"),
+				None::<()>,
+			))
+			.into(),
+			Error::UnsafeRpcCalled(e) => e.into(),
+		}
+	}
+}
diff --git a/substrate/client/rpc-api/src/statement/mod.rs b/substrate/client/rpc-api/src/statement/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..39ec52cbea01321c813d197f22dc406f42c23538
--- /dev/null
+++ b/substrate/client/rpc-api/src/statement/mod.rs
@@ -0,0 +1,60 @@
+// 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/>.
+
+//! Substrate Statement Store RPC API.
+
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sp_core::Bytes;
+
+pub mod error;
+
+/// Substrate statement RPC API
+#[rpc(client, server)]
+pub trait StatementApi {
+	/// Return all statements, SCALE-encoded.
+	#[method(name = "statement_dump")]
+	fn dump(&self) -> RpcResult<Vec<Bytes>>;
+
+	/// Return the data of all known statements which include all topics and have no `DecryptionKey`
+	/// field.
+	#[method(name = "statement_broadcasts")]
+	fn broadcasts(&self, match_all_topics: Vec<[u8; 32]>) -> RpcResult<Vec<Bytes>>;
+
+	/// Return the data of all known statements whose decryption key is identified as `dest` (this
+	/// will generally be the public key or a hash thereof for symmetric ciphers, or a hash of the
+	/// private key for symmetric ciphers).
+	#[method(name = "statement_posted")]
+	fn posted(&self, match_all_topics: Vec<[u8; 32]>, dest: [u8; 32]) -> RpcResult<Vec<Bytes>>;
+
+	/// Return the decrypted data of all known statements whose decryption key is identified as
+	/// `dest`. The key must be available to the client.
+	#[method(name = "statement_postedClear")]
+	fn posted_clear(
+		&self,
+		match_all_topics: Vec<[u8; 32]>,
+		dest: [u8; 32],
+	) -> RpcResult<Vec<Bytes>>;
+
+	/// Submit a pre-encoded statement.
+	#[method(name = "statement_submit")]
+	fn submit(&self, encoded: Bytes) -> RpcResult<()>;
+
+	/// Remove a statement from the store.
+	#[method(name = "statement_remove")]
+	fn remove(&self, statement_hash: [u8; 32]) -> RpcResult<()>;
+}
diff --git a/substrate/client/rpc-api/src/system/error.rs b/substrate/client/rpc-api/src/system/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..713ade9210d328265c49f8d5d924f92b69e1d2a4
--- /dev/null
+++ b/substrate/client/rpc-api/src/system/error.rs
@@ -0,0 +1,61 @@
+// 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/>.
+
+//! System RPC module errors.
+
+use crate::system::helpers::Health;
+use jsonrpsee::{
+	core::Error as JsonRpseeError,
+	types::error::{CallError, ErrorObject},
+};
+
+/// System RPC Result type.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// System RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Provided block range couldn't be resolved to a list of blocks.
+	#[error("Node is not fully functional: {}", .0)]
+	NotHealthy(Health),
+	/// Peer argument is malformatted.
+	#[error("{0}")]
+	MalformattedPeerArg(String),
+}
+
+// Base code for all system errors.
+const BASE_ERROR: i32 = crate::error::base::SYSTEM;
+// Provided block range couldn't be resolved to a list of blocks.
+const NOT_HEALTHY_ERROR: i32 = BASE_ERROR + 1;
+// Peer argument is malformatted.
+const MALFORMATTED_PEER_ARG_ERROR: i32 = BASE_ERROR + 2;
+
+impl From<Error> for JsonRpseeError {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::NotHealthy(ref h) =>
+				CallError::Custom(ErrorObject::owned(NOT_HEALTHY_ERROR, e.to_string(), Some(h))),
+			Error::MalformattedPeerArg(e) => CallError::Custom(ErrorObject::owned(
+				MALFORMATTED_PEER_ARG_ERROR + 2,
+				e,
+				None::<()>,
+			)),
+		}
+		.into()
+	}
+}
diff --git a/substrate/client/rpc-api/src/system/helpers.rs b/substrate/client/rpc-api/src/system/helpers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ad56dc3850093eda9a44b98ec498b97612474964
--- /dev/null
+++ b/substrate/client/rpc-api/src/system/helpers.rs
@@ -0,0 +1,148 @@
+// 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/>.
+
+//! Substrate system API helpers.
+
+use sc_chain_spec::{ChainType, Properties};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+/// Running node's static details.
+#[derive(Clone, Debug)]
+pub struct SystemInfo {
+	/// Implementation name.
+	pub impl_name: String,
+	/// Implementation version.
+	pub impl_version: String,
+	/// Chain name.
+	pub chain_name: String,
+	/// A custom set of properties defined in the chain spec.
+	pub properties: Properties,
+	/// The type of this chain.
+	pub chain_type: ChainType,
+}
+
+/// Health struct returned by the RPC
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub 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,
+}
+
+impl fmt::Display for Health {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		write!(fmt, "{} peers ({})", self.peers, if self.is_syncing { "syncing" } else { "idle" })
+	}
+}
+
+/// Network Peer information
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PeerInfo<Hash, Number> {
+	/// Peer ID
+	pub peer_id: String,
+	/// Roles
+	pub roles: String,
+	/// Peer best block hash
+	pub best_hash: Hash,
+	/// Peer best block number
+	pub best_number: Number,
+}
+
+/// The role the node is running as
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub enum NodeRole {
+	/// The node is a full node
+	Full,
+	/// The node is an authority
+	Authority,
+}
+
+/// The state of the syncing of the node.
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SyncState<Number> {
+	/// Height of the block at which syncing started.
+	pub starting_block: Number,
+	/// Height of the current best block of the node.
+	pub current_block: Number,
+	/// Height of the highest block in the network.
+	pub highest_block: Number,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_serialize_health() {
+		assert_eq!(
+			::serde_json::to_string(&Health {
+				peers: 1,
+				is_syncing: false,
+				should_have_peers: true,
+			})
+			.unwrap(),
+			r#"{"peers":1,"isSyncing":false,"shouldHavePeers":true}"#,
+		);
+	}
+
+	#[test]
+	fn should_serialize_peer_info() {
+		assert_eq!(
+			::serde_json::to_string(&PeerInfo {
+				peer_id: "2".into(),
+				roles: "a".into(),
+				best_hash: 5u32,
+				best_number: 6u32,
+			})
+			.unwrap(),
+			r#"{"peerId":"2","roles":"a","bestHash":5,"bestNumber":6}"#,
+		);
+	}
+
+	#[test]
+	fn should_serialize_sync_state() {
+		assert_eq!(
+			::serde_json::to_string(&SyncState {
+				starting_block: 12u32,
+				current_block: 50u32,
+				highest_block: 128u32,
+			})
+			.unwrap(),
+			r#"{"startingBlock":12,"currentBlock":50,"highestBlock":128}"#,
+		);
+
+		assert_eq!(
+			::serde_json::to_string(&SyncState {
+				starting_block: 12u32,
+				current_block: 50u32,
+				highest_block: 50u32,
+			})
+			.unwrap(),
+			r#"{"startingBlock":12,"currentBlock":50,"highestBlock":50}"#,
+		);
+	}
+}
diff --git a/substrate/client/rpc-api/src/system/mod.rs b/substrate/client/rpc-api/src/system/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bf2e92bc27a015a7b569fbbb2fe4ee126e59e5a3
--- /dev/null
+++ b/substrate/client/rpc-api/src/system/mod.rs
@@ -0,0 +1,123 @@
+// 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/>.
+
+//! Substrate system API.
+
+use jsonrpsee::{
+	core::{JsonValue, RpcResult},
+	proc_macros::rpc,
+};
+
+pub use self::helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo};
+
+pub mod error;
+pub mod helpers;
+
+/// Substrate system RPC API
+#[rpc(client, server)]
+pub trait SystemApi<Hash, Number> {
+	/// Get the node's implementation name. Plain old string.
+	#[method(name = "system_name")]
+	fn system_name(&self) -> RpcResult<String>;
+
+	/// Get the node implementation's version. Should be a semver string.
+	#[method(name = "system_version")]
+	fn system_version(&self) -> RpcResult<String>;
+
+	/// Get the chain's name. Given as a string identifier.
+	#[method(name = "system_chain")]
+	fn system_chain(&self) -> RpcResult<String>;
+
+	/// Get the chain's type.
+	#[method(name = "system_chainType")]
+	fn system_type(&self) -> RpcResult<sc_chain_spec::ChainType>;
+
+	/// Get a custom set of properties as a JSON object, defined in the chain spec.
+	#[method(name = "system_properties")]
+	fn system_properties(&self) -> RpcResult<sc_chain_spec::Properties>;
+
+	/// Return health status of the node.
+	///
+	/// Node is considered healthy if it is:
+	/// - connected to some peers (unless running in dev mode)
+	/// - not performing a major sync
+	#[method(name = "system_health")]
+	async fn system_health(&self) -> RpcResult<Health>;
+
+	/// Returns the base58-encoded PeerId of the node.
+	#[method(name = "system_localPeerId")]
+	async fn system_local_peer_id(&self) -> RpcResult<String>;
+
+	/// Returns the multi-addresses that the local node is listening on
+	///
+	/// The addresses include a trailing `/p2p/` with the local PeerId, and are thus suitable to
+	/// be passed to `addReservedPeer` or as a bootnode address for example.
+	#[method(name = "system_localListenAddresses")]
+	async fn system_local_listen_addresses(&self) -> RpcResult<Vec<String>>;
+
+	/// Returns currently connected peers
+	#[method(name = "system_peers")]
+	async fn system_peers(&self) -> RpcResult<Vec<PeerInfo<Hash, Number>>>;
+
+	/// Returns current state of the network.
+	///
+	/// **Warning**: This API is not stable. Please do not programmatically interpret its output,
+	/// as its format might change at any time.
+	// TODO: the future of this call is uncertain: https://github.com/paritytech/substrate/issues/1890
+	// https://github.com/paritytech/substrate/issues/5541
+	#[method(name = "system_unstable_networkState")]
+	async fn system_network_state(&self) -> RpcResult<JsonValue>;
+
+	/// Adds a reserved peer. Returns the empty string or an error. The string
+	/// parameter should encode a `p2p` multiaddr.
+	///
+	/// `/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV`
+	/// is an example of a valid, passing multiaddr with PeerId attached.
+	#[method(name = "system_addReservedPeer")]
+	async fn system_add_reserved_peer(&self, peer: String) -> RpcResult<()>;
+
+	/// Remove a reserved peer. Returns the empty string or an error. The string
+	/// should encode only the PeerId e.g. `QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV`.
+	#[method(name = "system_removeReservedPeer")]
+	async fn system_remove_reserved_peer(&self, peer_id: String) -> RpcResult<()>;
+
+	/// Returns the list of reserved peers
+	#[method(name = "system_reservedPeers")]
+	async fn system_reserved_peers(&self) -> RpcResult<Vec<String>>;
+
+	/// Returns the roles the node is running as.
+	#[method(name = "system_nodeRoles")]
+	async fn system_node_roles(&self) -> RpcResult<Vec<NodeRole>>;
+
+	/// Returns the state of the syncing of the node: starting block, current best block, highest
+	/// known block.
+	#[method(name = "system_syncState")]
+	async fn system_sync_state(&self) -> RpcResult<SyncState<Number>>;
+
+	/// Adds the supplied directives to the current log filter
+	///
+	/// The syntax is identical to the CLI `<target>=<level>`:
+	///
+	/// `sync=debug,state=trace`
+	#[method(name = "system_addLogFilter")]
+	fn system_add_log_filter(&self, directives: String) -> RpcResult<()>;
+
+	/// Resets the log filter to Substrate defaults
+	#[method(name = "system_resetLogFilter")]
+	fn system_reset_log_filter(&self) -> RpcResult<()>;
+}
diff --git a/substrate/client/rpc-servers/Cargo.toml b/substrate/client/rpc-servers/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..704799112618421d09f97c3e4f2a6bf2fcd99a3e
--- /dev/null
+++ b/substrate/client/rpc-servers/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "sc-rpc-server"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate RPC servers."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["server"] }
+log = "0.4.17"
+serde_json = "1.0.85"
+tokio = { version = "1.22.0", features = ["parking_lot"] }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+tower-http = { version = "0.4.0", features = ["cors"] }
+tower = "0.4.13"
+http = "0.2.8"
diff --git a/substrate/client/rpc-servers/README.md b/substrate/client/rpc-servers/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cf00b3169a6276b048b5a132d02df7c77e21dbf0
--- /dev/null
+++ b/substrate/client/rpc-servers/README.md
@@ -0,0 +1,3 @@
+Substrate RPC servers.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/rpc-servers/src/lib.rs b/substrate/client/rpc-servers/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..92b31937a0cbb1e018cacf17c5e19f418293877b
--- /dev/null
+++ b/substrate/client/rpc-servers/src/lib.rs
@@ -0,0 +1,182 @@
+// 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/>.
+
+//! Substrate RPC servers.
+
+#![warn(missing_docs)]
+
+pub mod middleware;
+
+use http::header::HeaderValue;
+use jsonrpsee::{
+	server::{
+		middleware::proxy_get_request::ProxyGetRequestLayer, AllowHosts, ServerBuilder,
+		ServerHandle,
+	},
+	RpcModule,
+};
+use std::{error::Error as StdError, net::SocketAddr};
+use tower_http::cors::{AllowOrigin, CorsLayer};
+
+pub use crate::middleware::RpcMetrics;
+pub use jsonrpsee::core::{
+	id_providers::{RandomIntegerIdProvider, RandomStringIdProvider},
+	traits::IdProvider,
+};
+
+const MEGABYTE: u32 = 1024 * 1024;
+
+/// Type alias for the JSON-RPC server.
+pub type Server = ServerHandle;
+
+/// RPC server configuration.
+#[derive(Debug)]
+pub struct Config<'a, M: Send + Sync + 'static> {
+	/// Socket addresses.
+	pub addrs: [SocketAddr; 2],
+	/// CORS.
+	pub cors: Option<&'a Vec<String>>,
+	/// Maximum connections.
+	pub max_connections: u32,
+	/// Maximum subscriptions per connection.
+	pub max_subs_per_conn: u32,
+	/// Maximum rpc request payload size.
+	pub max_payload_in_mb: u32,
+	/// Maximum rpc response payload size.
+	pub max_payload_out_mb: u32,
+	/// Metrics.
+	pub metrics: Option<RpcMetrics>,
+	/// RPC API.
+	pub rpc_api: RpcModule<M>,
+	/// Subscription ID provider.
+	pub id_provider: Option<Box<dyn IdProvider>>,
+	/// Tokio runtime handle.
+	pub tokio_handle: tokio::runtime::Handle,
+}
+
+/// Start RPC server listening on given address.
+pub async fn start_server<M: Send + Sync + 'static>(
+	config: Config<'_, M>,
+) -> Result<ServerHandle, Box<dyn StdError + Send + Sync>> {
+	let Config {
+		addrs,
+		cors,
+		max_payload_in_mb,
+		max_payload_out_mb,
+		max_connections,
+		max_subs_per_conn,
+		metrics,
+		id_provider,
+		tokio_handle,
+		rpc_api,
+	} = config;
+
+	let host_filter = hosts_filtering(cors.is_some(), &addrs);
+
+	let middleware = tower::ServiceBuilder::new()
+		// Proxy `GET /health` requests to internal `system_health` method.
+		.layer(ProxyGetRequestLayer::new("/health", "system_health")?)
+		.layer(try_into_cors(cors)?);
+
+	let mut builder = ServerBuilder::new()
+		.max_request_body_size(max_payload_in_mb.saturating_mul(MEGABYTE))
+		.max_response_body_size(max_payload_out_mb.saturating_mul(MEGABYTE))
+		.max_connections(max_connections)
+		.max_subscriptions_per_connection(max_subs_per_conn)
+		.ping_interval(std::time::Duration::from_secs(30))
+		.set_host_filtering(host_filter)
+		.set_middleware(middleware)
+		.custom_tokio_runtime(tokio_handle);
+
+	if let Some(provider) = id_provider {
+		builder = builder.set_id_provider(provider);
+	} else {
+		builder = builder.set_id_provider(RandomStringIdProvider::new(16));
+	};
+
+	let rpc_api = build_rpc_api(rpc_api);
+	let (handle, addr) = if let Some(metrics) = metrics {
+		let server = builder.set_logger(metrics).build(&addrs[..]).await?;
+		let addr = server.local_addr();
+		(server.start(rpc_api)?, addr)
+	} else {
+		let server = builder.build(&addrs[..]).await?;
+		let addr = server.local_addr();
+		(server.start(rpc_api)?, addr)
+	};
+
+	log::info!(
+		"Running JSON-RPC server: addr={}, allowed origins={}",
+		addr.map_or_else(|_| "unknown".to_string(), |a| a.to_string()),
+		format_cors(cors)
+	);
+
+	Ok(handle)
+}
+
+fn hosts_filtering(enabled: bool, addrs: &[SocketAddr]) -> AllowHosts {
+	if enabled {
+		// NOTE The listening addresses are whitelisted by default.
+		let mut hosts = Vec::with_capacity(addrs.len() * 2);
+		for addr in addrs {
+			hosts.push(format!("localhost:{}", addr.port()).into());
+			hosts.push(format!("127.0.0.1:{}", addr.port()).into());
+		}
+		AllowHosts::Only(hosts)
+	} else {
+		AllowHosts::Any
+	}
+}
+
+fn build_rpc_api<M: Send + Sync + 'static>(mut rpc_api: RpcModule<M>) -> RpcModule<M> {
+	let mut available_methods = rpc_api.method_names().collect::<Vec<_>>();
+	available_methods.sort();
+
+	rpc_api
+		.register_method("rpc_methods", move |_, _| {
+			Ok(serde_json::json!({
+				"methods": available_methods,
+			}))
+		})
+		.expect("infallible all other methods have their own address space; qed");
+
+	rpc_api
+}
+
+fn try_into_cors(
+	maybe_cors: Option<&Vec<String>>,
+) -> Result<CorsLayer, Box<dyn StdError + Send + Sync>> {
+	if let Some(cors) = maybe_cors {
+		let mut list = Vec::new();
+		for origin in cors {
+			list.push(HeaderValue::from_str(origin)?);
+		}
+		Ok(CorsLayer::new().allow_origin(AllowOrigin::list(list)))
+	} else {
+		// allow all cors
+		Ok(CorsLayer::permissive())
+	}
+}
+
+fn format_cors(maybe_cors: Option<&Vec<String>>) -> String {
+	if let Some(cors) = maybe_cors {
+		format!("{:?}", cors)
+	} else {
+		format!("{:?}", ["*"])
+	}
+}
diff --git a/substrate/client/rpc-servers/src/middleware.rs b/substrate/client/rpc-servers/src/middleware.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3e17c7852f1078a4a301aeed0c90038beb8da49
--- /dev/null
+++ b/substrate/client/rpc-servers/src/middleware.rs
@@ -0,0 +1,224 @@
+// 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/>.
+
+//! RPC middleware to collect prometheus metrics on RPC calls.
+
+use jsonrpsee::server::logger::{HttpRequest, Logger, MethodKind, Params, TransportProtocol};
+use prometheus_endpoint::{
+	register, Counter, CounterVec, HistogramOpts, HistogramVec, Opts, PrometheusError, Registry,
+	U64,
+};
+use std::net::SocketAddr;
+
+/// Histogram time buckets in microseconds.
+const HISTOGRAM_BUCKETS: [f64; 11] = [
+	5.0,
+	25.0,
+	100.0,
+	500.0,
+	1_000.0,
+	2_500.0,
+	10_000.0,
+	25_000.0,
+	100_000.0,
+	1_000_000.0,
+	10_000_000.0,
+];
+
+/// Metrics for RPC middleware storing information about the number of requests started/completed,
+/// calls started/completed and their timings.
+#[derive(Debug, Clone)]
+pub struct RpcMetrics {
+	/// Number of RPC requests received since the server started.
+	requests_started: CounterVec<U64>,
+	/// Number of RPC requests completed since the server started.
+	requests_finished: CounterVec<U64>,
+	/// Histogram over RPC execution times.
+	calls_time: HistogramVec,
+	/// Number of calls started.
+	calls_started: CounterVec<U64>,
+	/// Number of calls completed.
+	calls_finished: CounterVec<U64>,
+	/// Number of Websocket sessions opened.
+	ws_sessions_opened: Option<Counter<U64>>,
+	/// Number of Websocket sessions closed.
+	ws_sessions_closed: Option<Counter<U64>>,
+}
+
+impl RpcMetrics {
+	/// Create an instance of metrics
+	pub fn new(metrics_registry: Option<&Registry>) -> Result<Option<Self>, PrometheusError> {
+		if let Some(metrics_registry) = metrics_registry {
+			Ok(Some(Self {
+				requests_started: register(
+					CounterVec::new(
+						Opts::new(
+							"substrate_rpc_requests_started",
+							"Number of RPC requests (not calls) received by the server.",
+						),
+						&["protocol"],
+					)?,
+					metrics_registry,
+				)?,
+				requests_finished: register(
+					CounterVec::new(
+						Opts::new(
+							"substrate_rpc_requests_finished",
+							"Number of RPC requests (not calls) processed by the server.",
+						),
+						&["protocol"],
+					)?,
+					metrics_registry,
+				)?,
+				calls_time: register(
+					HistogramVec::new(
+						HistogramOpts::new(
+							"substrate_rpc_calls_time",
+							"Total time [μs] of processed RPC calls",
+						)
+						.buckets(HISTOGRAM_BUCKETS.to_vec()),
+						&["protocol", "method"],
+					)?,
+					metrics_registry,
+				)?,
+				calls_started: register(
+					CounterVec::new(
+						Opts::new(
+							"substrate_rpc_calls_started",
+							"Number of received RPC calls (unique un-batched requests)",
+						),
+						&["protocol", "method"],
+					)?,
+					metrics_registry,
+				)?,
+				calls_finished: register(
+					CounterVec::new(
+						Opts::new(
+							"substrate_rpc_calls_finished",
+							"Number of processed RPC calls (unique un-batched requests)",
+						),
+						&["protocol", "method", "is_error"],
+					)?,
+					metrics_registry,
+				)?,
+				ws_sessions_opened: register(
+					Counter::new(
+						"substrate_rpc_sessions_opened",
+						"Number of persistent RPC sessions opened",
+					)?,
+					metrics_registry,
+				)?
+				.into(),
+				ws_sessions_closed: register(
+					Counter::new(
+						"substrate_rpc_sessions_closed",
+						"Number of persistent RPC sessions closed",
+					)?,
+					metrics_registry,
+				)?
+				.into(),
+			}))
+		} else {
+			Ok(None)
+		}
+	}
+}
+
+impl Logger for RpcMetrics {
+	type Instant = std::time::Instant;
+
+	fn on_connect(
+		&self,
+		_remote_addr: SocketAddr,
+		_request: &HttpRequest,
+		transport: TransportProtocol,
+	) {
+		if let TransportProtocol::WebSocket = transport {
+			self.ws_sessions_opened.as_ref().map(|counter| counter.inc());
+		}
+	}
+
+	fn on_request(&self, transport: TransportProtocol) -> Self::Instant {
+		let transport_label = transport_label_str(transport);
+		let now = std::time::Instant::now();
+		self.requests_started.with_label_values(&[transport_label]).inc();
+		now
+	}
+
+	fn on_call(&self, name: &str, params: Params, kind: MethodKind, transport: TransportProtocol) {
+		let transport_label = transport_label_str(transport);
+		log::trace!(
+			target: "rpc_metrics",
+			"[{}] on_call name={} params={:?} kind={}",
+			transport_label,
+			name,
+			params,
+			kind,
+		);
+		self.calls_started.with_label_values(&[transport_label, name]).inc();
+	}
+
+	fn on_result(
+		&self,
+		name: &str,
+		success: bool,
+		started_at: Self::Instant,
+		transport: TransportProtocol,
+	) {
+		let transport_label = transport_label_str(transport);
+		let micros = started_at.elapsed().as_micros();
+		log::debug!(
+			target: "rpc_metrics",
+			"[{}] {} call took {} μs",
+			transport_label,
+			name,
+			micros,
+		);
+		self.calls_time.with_label_values(&[transport_label, name]).observe(micros as _);
+
+		self.calls_finished
+			.with_label_values(&[
+				transport_label,
+				name,
+				// the label "is_error", so `success` should be regarded as false
+				// and vice-versa to be registrered correctly.
+				if success { "false" } else { "true" },
+			])
+			.inc();
+	}
+
+	fn on_response(&self, result: &str, started_at: Self::Instant, transport: TransportProtocol) {
+		let transport_label = transport_label_str(transport);
+		log::trace!(target: "rpc_metrics", "[{}] on_response started_at={:?}", transport_label, started_at);
+		log::trace!(target: "rpc_metrics::extra", "[{}] result={:?}", transport_label, result);
+		self.requests_finished.with_label_values(&[transport_label]).inc();
+	}
+
+	fn on_disconnect(&self, _remote_addr: SocketAddr, transport: TransportProtocol) {
+		if let TransportProtocol::WebSocket = transport {
+			self.ws_sessions_closed.as_ref().map(|counter| counter.inc());
+		}
+	}
+}
+
+fn transport_label_str(t: TransportProtocol) -> &'static str {
+	match t {
+		TransportProtocol::Http => "http",
+		TransportProtocol::WebSocket => "ws",
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/Cargo.toml b/substrate/client/rpc-spec-v2/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..599596777b7b62aa89ef5f71fe285b3fe49428cd
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/Cargo.toml
@@ -0,0 +1,50 @@
+[package]
+name = "sc-rpc-spec-v2"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate RPC interface v2."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+# Internal chain structures for "chain_spec".
+sc-chain-spec = { version = "4.0.0-dev", path = "../chain-spec" }
+# Pool for submitting extrinsics required by "transaction"
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../transaction-pool/api" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-version = { version = "22.0.0", path = "../../primitives/version" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+thiserror = "1.0"
+serde = "1.0"
+hex = "0.4"
+futures = "0.3.21"
+parking_lot = "0.12.1"
+tokio-stream = { version = "0.1", features = ["sync"] }
+tokio = { version = "1.22.0", features = ["sync"] }
+array-bytes = "6.1"
+log = "0.4.17"
+futures-util = { version = "0.3.19", default-features = false }
+
+[dev-dependencies]
+serde_json = "1.0"
+tokio = { version = "1.22.0", features = ["macros"] }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+sp-maybe-compressed-blob = { version = "4.1.0-dev", path = "../../primitives/maybe-compressed-blob" }
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sc-service = { version = "0.10.0-dev", features = ["test-helpers"], path = "../service" }
+assert_matches = "1.3.0"
+pretty_assertions = "1.2.1"
diff --git a/substrate/client/rpc-spec-v2/README.md b/substrate/client/rpc-spec-v2/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e860e0c2334da50e57bee241b14e2807b25bc7f3
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/README.md
@@ -0,0 +1,5 @@
+Substrate RPC interfaces.
+
+A collection of RPC methods and subscriptions supported by all substrate clients.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/api.rs b/substrate/client/rpc-spec-v2/src/chain_head/api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..682cd690dd10cf45bebfe73f1abbb680b87417e5
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/api.rs
@@ -0,0 +1,149 @@
+// 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/>.
+
+#![allow(non_snake_case)]
+
+//! API trait of the chain head.
+use crate::chain_head::event::{FollowEvent, MethodResponse, StorageQuery};
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+
+#[rpc(client, server)]
+pub trait ChainHeadApi<Hash> {
+	/// Track the state of the head of the chain: the finalized, non-finalized, and best blocks.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[subscription(
+		name = "chainHead_unstable_follow",
+		unsubscribe = "chainHead_unstable_unfollow",
+		item = FollowEvent<Hash>,
+	)]
+	fn chain_head_unstable_follow(&self, with_runtime: bool);
+
+	/// Retrieves the body (list of transactions) of a pinned block.
+	///
+	/// This method should be seen as a complement to `chainHead_unstable_follow`,
+	/// allowing the JSON-RPC client to retrieve more information about a block
+	/// that has been reported.
+	///
+	/// Use `archive_unstable_body` if instead you want to retrieve the body of an arbitrary block.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_body", blocking)]
+	fn chain_head_unstable_body(
+		&self,
+		follow_subscription: String,
+		hash: Hash,
+	) -> RpcResult<MethodResponse>;
+
+	/// Retrieves the header of a pinned block.
+	///
+	/// This method should be seen as a complement to `chainHead_unstable_follow`,
+	/// allowing the JSON-RPC client to retrieve more information about a block
+	/// that has been reported.
+	///
+	/// Use `archive_unstable_header` if instead you want to retrieve the header of an arbitrary
+	/// block.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_header", blocking)]
+	fn chain_head_unstable_header(
+		&self,
+		follow_subscription: String,
+		hash: Hash,
+	) -> RpcResult<Option<String>>;
+
+	/// Get the chain's genesis hash.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_genesisHash", blocking)]
+	fn chain_head_unstable_genesis_hash(&self) -> RpcResult<String>;
+
+	/// Returns storage entries at a specific block's state.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_storage", blocking)]
+	fn chain_head_unstable_storage(
+		&self,
+		follow_subscription: String,
+		hash: Hash,
+		items: Vec<StorageQuery<String>>,
+		child_trie: Option<String>,
+	) -> RpcResult<MethodResponse>;
+
+	/// Call into the Runtime API at a specified block's state.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_call", blocking)]
+	fn chain_head_unstable_call(
+		&self,
+		follow_subscription: String,
+		hash: Hash,
+		function: String,
+		call_parameters: String,
+	) -> RpcResult<MethodResponse>;
+
+	/// Unpin a block reported by the `follow` method.
+	///
+	/// Ongoing operations that require the provided block
+	/// will continue normally.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_unpin", blocking)]
+	fn chain_head_unstable_unpin(&self, follow_subscription: String, hash: Hash) -> RpcResult<()>;
+
+	/// Resumes a storage fetch started with `chainHead_storage` after it has generated an
+	/// `operationWaitingForContinue` event.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_continue", blocking)]
+	fn chain_head_unstable_continue(
+		&self,
+		follow_subscription: String,
+		operation_id: String,
+	) -> RpcResult<()>;
+
+	/// Stops an operation started with chainHead_unstable_body, chainHead_unstable_call, or
+	/// chainHead_unstable_storage. If the operation was still in progress, this interrupts it. If
+	/// the operation was already finished, this call has no effect.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainHead_unstable_stopOperation", blocking)]
+	fn chain_head_unstable_stop_operation(
+		&self,
+		follow_subscription: String,
+		operation_id: String,
+	) -> RpcResult<()>;
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/chain_head.rs b/substrate/client/rpc-spec-v2/src/chain_head/chain_head.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bae7c84df0ed915ebf8bb7a4add462c1905288d3
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/chain_head.rs
@@ -0,0 +1,490 @@
+// 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/>.
+
+//! API implementation for `chainHead`.
+
+use super::{
+	chain_head_storage::ChainHeadStorage,
+	event::{MethodResponseStarted, OperationBodyDone, OperationCallDone},
+};
+use crate::{
+	chain_head::{
+		api::ChainHeadApiServer,
+		chain_head_follow::ChainHeadFollower,
+		error::Error as ChainHeadRpcError,
+		event::{FollowEvent, MethodResponse, OperationError, StorageQuery, StorageQueryType},
+		hex_string,
+		subscription::{SubscriptionManagement, SubscriptionManagementError},
+	},
+	SubscriptionTaskExecutor,
+};
+use codec::Encode;
+use futures::future::FutureExt;
+use jsonrpsee::{
+	core::{async_trait, RpcResult},
+	types::{SubscriptionEmptyError, SubscriptionId, SubscriptionResult},
+	SubscriptionSink,
+};
+use log::debug;
+use sc_client_api::{
+	Backend, BlockBackend, BlockchainEvents, CallExecutor, ChildInfo, ExecutorProvider, StorageKey,
+	StorageProvider,
+};
+use sp_api::CallApiAt;
+use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
+use sp_core::{traits::CallContext, Bytes};
+use sp_runtime::traits::Block as BlockT;
+use std::{marker::PhantomData, sync::Arc, time::Duration};
+
+pub(crate) const LOG_TARGET: &str = "rpc-spec-v2";
+
+/// The configuration of [`ChainHead`].
+pub struct ChainHeadConfig {
+	/// The maximum number of pinned blocks across all subscriptions.
+	pub global_max_pinned_blocks: usize,
+	/// The maximum duration that a block is allowed to be pinned per subscription.
+	pub subscription_max_pinned_duration: Duration,
+	/// The maximum number of ongoing operations per subscription.
+	pub subscription_max_ongoing_operations: usize,
+	/// The maximum number of items reported by the `chainHead_storage` before
+	/// pagination is required.
+	pub operation_max_storage_items: usize,
+}
+
+/// Maximum pinned blocks across all connections.
+/// This number is large enough to consider immediate blocks.
+/// Note: This should never exceed the `PINNING_CACHE_SIZE` from client/db.
+const MAX_PINNED_BLOCKS: usize = 512;
+
+/// Any block of any subscription should not be pinned more than
+/// this constant. When a subscription contains a block older than this,
+/// the subscription becomes subject to termination.
+/// Note: This should be enough for immediate blocks.
+const MAX_PINNED_DURATION: Duration = Duration::from_secs(60);
+
+/// The maximum number of ongoing operations per subscription.
+/// Note: The lower limit imposed by the spec is 16.
+const MAX_ONGOING_OPERATIONS: usize = 16;
+
+/// The maximum number of items the `chainHead_storage` can return
+/// before paginations is required.
+const MAX_STORAGE_ITER_ITEMS: usize = 5;
+
+impl Default for ChainHeadConfig {
+	fn default() -> Self {
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: MAX_PINNED_DURATION,
+			subscription_max_ongoing_operations: MAX_ONGOING_OPERATIONS,
+			operation_max_storage_items: MAX_STORAGE_ITER_ITEMS,
+		}
+	}
+}
+
+/// An API for chain head RPC calls.
+pub struct ChainHead<BE: Backend<Block>, Block: BlockT, Client> {
+	/// Substrate client.
+	client: Arc<Client>,
+	/// Backend of the chain.
+	backend: Arc<BE>,
+	/// Executor to spawn subscriptions.
+	executor: SubscriptionTaskExecutor,
+	/// Keep track of the pinned blocks for each subscription.
+	subscriptions: Arc<SubscriptionManagement<Block, BE>>,
+	/// The hexadecimal encoded hash of the genesis block.
+	genesis_hash: String,
+	/// The maximum number of items reported by the `chainHead_storage` before
+	/// pagination is required.
+	operation_max_storage_items: usize,
+	/// Phantom member to pin the block type.
+	_phantom: PhantomData<Block>,
+}
+
+impl<BE: Backend<Block>, Block: BlockT, Client> ChainHead<BE, Block, Client> {
+	/// Create a new [`ChainHead`].
+	pub fn new<GenesisHash: AsRef<[u8]>>(
+		client: Arc<Client>,
+		backend: Arc<BE>,
+		executor: SubscriptionTaskExecutor,
+		genesis_hash: GenesisHash,
+		config: ChainHeadConfig,
+	) -> Self {
+		let genesis_hash = hex_string(&genesis_hash.as_ref());
+		Self {
+			client,
+			backend: backend.clone(),
+			executor,
+			subscriptions: Arc::new(SubscriptionManagement::new(
+				config.global_max_pinned_blocks,
+				config.subscription_max_pinned_duration,
+				config.subscription_max_ongoing_operations,
+				backend,
+			)),
+			operation_max_storage_items: config.operation_max_storage_items,
+			genesis_hash,
+			_phantom: PhantomData,
+		}
+	}
+
+	/// Accept the subscription and return the subscription ID on success.
+	fn accept_subscription(
+		&self,
+		sink: &mut SubscriptionSink,
+	) -> Result<String, SubscriptionEmptyError> {
+		// The subscription must be accepted before it can provide a valid subscription ID.
+		sink.accept()?;
+
+		let Some(sub_id) = sink.subscription_id() else {
+			// This can only happen if the subscription was not accepted.
+			return Err(SubscriptionEmptyError)
+		};
+
+		// Get the string representation for the subscription.
+		let sub_id = match sub_id {
+			SubscriptionId::Num(num) => num.to_string(),
+			SubscriptionId::Str(id) => id.into_owned().into(),
+		};
+
+		Ok(sub_id)
+	}
+}
+
+/// Parse hex-encoded string parameter as raw bytes.
+///
+/// If the parsing fails, returns an error propagated to the RPC method.
+fn parse_hex_param(param: String) -> Result<Vec<u8>, ChainHeadRpcError> {
+	// Methods can accept empty parameters.
+	if param.is_empty() {
+		return Ok(Default::default())
+	}
+
+	match array_bytes::hex2bytes(&param) {
+		Ok(bytes) => Ok(bytes),
+		Err(_) => Err(ChainHeadRpcError::InvalidParam(param)),
+	}
+}
+
+#[async_trait]
+impl<BE, Block, Client> ChainHeadApiServer<Block::Hash> for ChainHead<BE, Block, Client>
+where
+	Block: BlockT + 'static,
+	Block::Header: Unpin,
+	BE: Backend<Block> + 'static,
+	Client: BlockBackend<Block>
+		+ ExecutorProvider<Block>
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = BlockChainError>
+		+ BlockchainEvents<Block>
+		+ CallApiAt<Block>
+		+ StorageProvider<Block, BE>
+		+ 'static,
+{
+	fn chain_head_unstable_follow(
+		&self,
+		mut sink: SubscriptionSink,
+		with_runtime: bool,
+	) -> SubscriptionResult {
+		let sub_id = match self.accept_subscription(&mut sink) {
+			Ok(sub_id) => sub_id,
+			Err(err) => {
+				sink.close(ChainHeadRpcError::InvalidSubscriptionID);
+				return Err(err)
+			},
+		};
+		// Keep track of the subscription.
+		let Some(sub_data) = self.subscriptions.insert_subscription(sub_id.clone(), with_runtime)
+		else {
+			// Inserting the subscription can only fail if the JsonRPSee
+			// generated a duplicate subscription ID.
+			debug!(target: LOG_TARGET, "[follow][id={:?}] Subscription already accepted", sub_id);
+			let _ = sink.send(&FollowEvent::<Block::Hash>::Stop);
+			return Ok(())
+		};
+		debug!(target: LOG_TARGET, "[follow][id={:?}] Subscription accepted", sub_id);
+
+		let subscriptions = self.subscriptions.clone();
+		let backend = self.backend.clone();
+		let client = self.client.clone();
+		let fut = async move {
+			let mut chain_head_follow = ChainHeadFollower::new(
+				client,
+				backend,
+				subscriptions.clone(),
+				with_runtime,
+				sub_id.clone(),
+			);
+
+			chain_head_follow.generate_events(sink, sub_data).await;
+
+			subscriptions.remove_subscription(&sub_id);
+			debug!(target: LOG_TARGET, "[follow][id={:?}] Subscription removed", sub_id);
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+		Ok(())
+	}
+
+	fn chain_head_unstable_body(
+		&self,
+		follow_subscription: String,
+		hash: Block::Hash,
+	) -> RpcResult<MethodResponse> {
+		let mut block_guard = match self.subscriptions.lock_block(&follow_subscription, hash, 1) {
+			Ok(block) => block,
+			Err(SubscriptionManagementError::SubscriptionAbsent) |
+			Err(SubscriptionManagementError::ExceededLimits) => return Ok(MethodResponse::LimitReached),
+			Err(SubscriptionManagementError::BlockHashAbsent) => {
+				// Block is not part of the subscription.
+				return Err(ChainHeadRpcError::InvalidBlock.into())
+			},
+			Err(_) => return Err(ChainHeadRpcError::InvalidBlock.into()),
+		};
+
+		let operation_id = block_guard.operation().operation_id();
+
+		let event = match self.client.block(hash) {
+			Ok(Some(signed_block)) => {
+				let extrinsics = signed_block
+					.block
+					.extrinsics()
+					.iter()
+					.map(|extrinsic| hex_string(&extrinsic.encode()))
+					.collect();
+				FollowEvent::<Block::Hash>::OperationBodyDone(OperationBodyDone {
+					operation_id: operation_id.clone(),
+					value: extrinsics,
+				})
+			},
+			Ok(None) => {
+				// The block's body was pruned. This subscription ID has become invalid.
+				debug!(
+					target: LOG_TARGET,
+					"[body][id={:?}] Stopping subscription because hash={:?} was pruned",
+					&follow_subscription,
+					hash
+				);
+				self.subscriptions.remove_subscription(&follow_subscription);
+				return Err(ChainHeadRpcError::InvalidBlock.into())
+			},
+			Err(error) => FollowEvent::<Block::Hash>::OperationError(OperationError {
+				operation_id: operation_id.clone(),
+				error: error.to_string(),
+			}),
+		};
+
+		let _ = block_guard.response_sender().unbounded_send(event);
+		Ok(MethodResponse::Started(MethodResponseStarted { operation_id, discarded_items: None }))
+	}
+
+	fn chain_head_unstable_header(
+		&self,
+		follow_subscription: String,
+		hash: Block::Hash,
+	) -> RpcResult<Option<String>> {
+		let _block_guard = match self.subscriptions.lock_block(&follow_subscription, hash, 1) {
+			Ok(block) => block,
+			Err(SubscriptionManagementError::SubscriptionAbsent) |
+			Err(SubscriptionManagementError::ExceededLimits) => return Ok(None),
+			Err(SubscriptionManagementError::BlockHashAbsent) => {
+				// Block is not part of the subscription.
+				return Err(ChainHeadRpcError::InvalidBlock.into())
+			},
+			Err(_) => return Err(ChainHeadRpcError::InvalidBlock.into()),
+		};
+
+		self.client
+			.header(hash)
+			.map(|opt_header| opt_header.map(|h| hex_string(&h.encode())))
+			.map_err(ChainHeadRpcError::FetchBlockHeader)
+			.map_err(Into::into)
+	}
+
+	fn chain_head_unstable_genesis_hash(&self) -> RpcResult<String> {
+		Ok(self.genesis_hash.clone())
+	}
+
+	fn chain_head_unstable_storage(
+		&self,
+		follow_subscription: String,
+		hash: Block::Hash,
+		items: Vec<StorageQuery<String>>,
+		child_trie: Option<String>,
+	) -> RpcResult<MethodResponse> {
+		// Gain control over parameter parsing and returned error.
+		let items = items
+			.into_iter()
+			.map(|query| {
+				if query.query_type == StorageQueryType::ClosestDescendantMerkleValue {
+					// Note: remove this once all types are implemented.
+					return Err(ChainHeadRpcError::InvalidParam(
+						"Storage query type not supported".into(),
+					))
+				}
+
+				Ok(StorageQuery {
+					key: StorageKey(parse_hex_param(query.key)?),
+					query_type: query.query_type,
+				})
+			})
+			.collect::<Result<Vec<_>, _>>()?;
+
+		let child_trie = child_trie
+			.map(|child_trie| parse_hex_param(child_trie))
+			.transpose()?
+			.map(ChildInfo::new_default_from_vec);
+
+		let mut block_guard =
+			match self.subscriptions.lock_block(&follow_subscription, hash, items.len()) {
+				Ok(block) => block,
+				Err(SubscriptionManagementError::SubscriptionAbsent) |
+				Err(SubscriptionManagementError::ExceededLimits) => return Ok(MethodResponse::LimitReached),
+				Err(SubscriptionManagementError::BlockHashAbsent) => {
+					// Block is not part of the subscription.
+					return Err(ChainHeadRpcError::InvalidBlock.into())
+				},
+				Err(_) => return Err(ChainHeadRpcError::InvalidBlock.into()),
+			};
+
+		let mut storage_client = ChainHeadStorage::<Client, Block, BE>::new(
+			self.client.clone(),
+			self.operation_max_storage_items,
+		);
+		let operation = block_guard.operation();
+		let operation_id = operation.operation_id();
+
+		// The number of operations we are allowed to execute.
+		let num_operations = operation.num_reserved();
+		let discarded = items.len().saturating_sub(num_operations);
+		let mut items = items;
+		items.truncate(num_operations);
+
+		let fut = async move {
+			storage_client.generate_events(block_guard, hash, items, child_trie).await;
+		};
+
+		self.executor
+			.spawn_blocking("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+		Ok(MethodResponse::Started(MethodResponseStarted {
+			operation_id,
+			discarded_items: Some(discarded),
+		}))
+	}
+
+	fn chain_head_unstable_call(
+		&self,
+		follow_subscription: String,
+		hash: Block::Hash,
+		function: String,
+		call_parameters: String,
+	) -> RpcResult<MethodResponse> {
+		let call_parameters = Bytes::from(parse_hex_param(call_parameters)?);
+
+		let mut block_guard = match self.subscriptions.lock_block(&follow_subscription, hash, 1) {
+			Ok(block) => block,
+			Err(SubscriptionManagementError::SubscriptionAbsent) |
+			Err(SubscriptionManagementError::ExceededLimits) => {
+				// Invalid invalid subscription ID.
+				return Ok(MethodResponse::LimitReached)
+			},
+			Err(SubscriptionManagementError::BlockHashAbsent) => {
+				// Block is not part of the subscription.
+				return Err(ChainHeadRpcError::InvalidBlock.into())
+			},
+			Err(_) => return Err(ChainHeadRpcError::InvalidBlock.into()),
+		};
+
+		// Reject subscription if with_runtime is false.
+		if !block_guard.has_runtime() {
+			return Err(ChainHeadRpcError::InvalidParam(
+				"The runtime updates flag must be set".to_string(),
+			)
+			.into())
+		}
+
+		let operation_id = block_guard.operation().operation_id();
+		let event = self
+			.client
+			.executor()
+			.call(hash, &function, &call_parameters, CallContext::Offchain)
+			.map(|result| {
+				FollowEvent::<Block::Hash>::OperationCallDone(OperationCallDone {
+					operation_id: operation_id.clone(),
+					output: hex_string(&result),
+				})
+			})
+			.unwrap_or_else(|error| {
+				FollowEvent::<Block::Hash>::OperationError(OperationError {
+					operation_id: operation_id.clone(),
+					error: error.to_string(),
+				})
+			});
+
+		let _ = block_guard.response_sender().unbounded_send(event);
+		Ok(MethodResponse::Started(MethodResponseStarted { operation_id, discarded_items: None }))
+	}
+
+	fn chain_head_unstable_unpin(
+		&self,
+		follow_subscription: String,
+		hash: Block::Hash,
+	) -> RpcResult<()> {
+		match self.subscriptions.unpin_block(&follow_subscription, hash) {
+			Ok(()) => Ok(()),
+			Err(SubscriptionManagementError::SubscriptionAbsent) => {
+				// Invalid invalid subscription ID.
+				Ok(())
+			},
+			Err(SubscriptionManagementError::BlockHashAbsent) => {
+				// Block is not part of the subscription.
+				Err(ChainHeadRpcError::InvalidBlock.into())
+			},
+			Err(_) => Err(ChainHeadRpcError::InvalidBlock.into()),
+		}
+	}
+
+	fn chain_head_unstable_continue(
+		&self,
+		follow_subscription: String,
+		operation_id: String,
+	) -> RpcResult<()> {
+		let Some(operation) = self.subscriptions.get_operation(&follow_subscription, &operation_id) else {
+			return Ok(())
+		};
+
+		if !operation.submit_continue() {
+			// Continue called without generating a `WaitingForContinue` event.
+			Err(ChainHeadRpcError::InvalidContinue.into())
+		} else {
+			Ok(())
+		}
+	}
+
+	fn chain_head_unstable_stop_operation(
+		&self,
+		follow_subscription: String,
+		operation_id: String,
+	) -> RpcResult<()> {
+		let Some(operation) = self.subscriptions.get_operation(&follow_subscription, &operation_id) else {
+			return Ok(())
+		};
+
+		operation.stop_operation();
+
+		Ok(())
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/chain_head_follow.rs b/substrate/client/rpc-spec-v2/src/chain_head/chain_head_follow.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0fa995ce73a094f1fb9509847357d0712cbb3bbf
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/chain_head_follow.rs
@@ -0,0 +1,618 @@
+// 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/>.
+
+//! Implementation of the `chainHead_follow` method.
+
+use crate::chain_head::{
+	chain_head::LOG_TARGET,
+	event::{
+		BestBlockChanged, Finalized, FollowEvent, Initialized, NewBlock, RuntimeEvent,
+		RuntimeVersionEvent,
+	},
+	subscription::{InsertedSubscriptionData, SubscriptionManagement, SubscriptionManagementError},
+};
+use futures::{
+	channel::oneshot,
+	stream::{self, Stream, StreamExt},
+};
+use futures_util::future::Either;
+use jsonrpsee::SubscriptionSink;
+use log::{debug, error};
+use sc_client_api::{
+	Backend, BlockBackend, BlockImportNotification, BlockchainEvents, FinalityNotification,
+};
+use sp_api::CallApiAt;
+use sp_blockchain::{
+	Backend as BlockChainBackend, Error as BlockChainError, HeaderBackend, HeaderMetadata, Info,
+};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor};
+use std::{collections::HashSet, sync::Arc};
+
+/// Generates the events of the `chainHead_follow` method.
+pub struct ChainHeadFollower<BE: Backend<Block>, Block: BlockT, Client> {
+	/// Substrate client.
+	client: Arc<Client>,
+	/// Backend of the chain.
+	backend: Arc<BE>,
+	/// Subscriptions handle.
+	sub_handle: Arc<SubscriptionManagement<Block, BE>>,
+	/// Subscription was started with the runtime updates flag.
+	with_runtime: bool,
+	/// Subscription ID.
+	sub_id: String,
+	/// The best reported block by this subscription.
+	best_block_cache: Option<Block::Hash>,
+}
+
+impl<BE: Backend<Block>, Block: BlockT, Client> ChainHeadFollower<BE, Block, Client> {
+	/// Create a new [`ChainHeadFollower`].
+	pub fn new(
+		client: Arc<Client>,
+		backend: Arc<BE>,
+		sub_handle: Arc<SubscriptionManagement<Block, BE>>,
+		with_runtime: bool,
+		sub_id: String,
+	) -> Self {
+		Self { client, backend, sub_handle, with_runtime, sub_id, best_block_cache: None }
+	}
+}
+
+/// A block notification.
+enum NotificationType<Block: BlockT> {
+	/// The initial events generated from the node's memory.
+	InitialEvents(Vec<FollowEvent<Block::Hash>>),
+	/// The new block notification obtained from `import_notification_stream`.
+	NewBlock(BlockImportNotification<Block>),
+	/// The finalized block notification obtained from `finality_notification_stream`.
+	Finalized(FinalityNotification<Block>),
+	/// The response of `chainHead` method calls.
+	MethodResponse(FollowEvent<Block::Hash>),
+}
+
+/// The initial blocks that should be reported or ignored by the chainHead.
+#[derive(Clone, Debug)]
+struct InitialBlocks<Block: BlockT> {
+	/// Children of the latest finalized block, for which the `NewBlock`
+	/// event must be generated.
+	///
+	/// It is a tuple of (block hash, parent hash).
+	finalized_block_descendants: Vec<(Block::Hash, Block::Hash)>,
+	/// Blocks that should not be reported as pruned by the `Finalized` event.
+	///
+	/// Substrate database will perform the pruning of height N at
+	/// the finalization N + 1. We could have the following block tree
+	/// when the user subscribes to the `follow` method:
+	///   [A] - [A1] - [A2] - [A3]
+	///                 ^^ finalized
+	///       - [A1] - [B1]
+	///
+	/// When the A3 block is finalized, B1 is reported as pruned, however
+	/// B1 was never reported as `NewBlock` (and as such was never pinned).
+	/// This is because the `NewBlock` events are generated for children of
+	/// the finalized hash.
+	pruned_forks: HashSet<Block::Hash>,
+}
+
+/// The startup point from which chainHead started to generate events.
+struct StartupPoint<Block: BlockT> {
+	/// Best block hash.
+	pub best_hash: Block::Hash,
+	/// The head of the finalized chain.
+	pub finalized_hash: Block::Hash,
+	/// Last finalized block number.
+	pub finalized_number: NumberFor<Block>,
+}
+
+impl<Block: BlockT> From<Info<Block>> for StartupPoint<Block> {
+	fn from(info: Info<Block>) -> Self {
+		StartupPoint::<Block> {
+			best_hash: info.best_hash,
+			finalized_hash: info.finalized_hash,
+			finalized_number: info.finalized_number,
+		}
+	}
+}
+
+impl<BE, Block, Client> ChainHeadFollower<BE, Block, Client>
+where
+	Block: BlockT + 'static,
+	BE: Backend<Block> + 'static,
+	Client: BlockBackend<Block>
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = BlockChainError>
+		+ BlockchainEvents<Block>
+		+ CallApiAt<Block>
+		+ 'static,
+{
+	/// Conditionally generate the runtime event of the given block.
+	fn generate_runtime_event(
+		&self,
+		block: Block::Hash,
+		parent: Option<Block::Hash>,
+	) -> Option<RuntimeEvent> {
+		// No runtime versions should be reported.
+		if !self.with_runtime {
+			return None
+		}
+
+		let block_rt = match self.client.runtime_version_at(block) {
+			Ok(rt) => rt,
+			Err(err) => return Some(err.into()),
+		};
+
+		let parent = match parent {
+			Some(parent) => parent,
+			// Nothing to compare against, always report.
+			None => return Some(RuntimeEvent::Valid(RuntimeVersionEvent { spec: block_rt })),
+		};
+
+		let parent_rt = match self.client.runtime_version_at(parent) {
+			Ok(rt) => rt,
+			Err(err) => return Some(err.into()),
+		};
+
+		// Report the runtime version change.
+		if block_rt != parent_rt {
+			Some(RuntimeEvent::Valid(RuntimeVersionEvent { spec: block_rt }))
+		} else {
+			None
+		}
+	}
+
+	/// Get the in-memory blocks of the client, starting from the provided finalized hash.
+	fn get_init_blocks_with_forks(
+		&self,
+		startup_point: &StartupPoint<Block>,
+	) -> Result<InitialBlocks<Block>, SubscriptionManagementError> {
+		let blockchain = self.backend.blockchain();
+		let leaves = blockchain.leaves()?;
+		let finalized = startup_point.finalized_hash;
+		let mut pruned_forks = HashSet::new();
+		let mut finalized_block_descendants = Vec::new();
+		let mut unique_descendants = HashSet::new();
+		for leaf in leaves {
+			let tree_route = sp_blockchain::tree_route(blockchain, finalized, leaf)?;
+
+			let blocks = tree_route.enacted().iter().map(|block| block.hash);
+			if !tree_route.retracted().is_empty() {
+				pruned_forks.extend(blocks);
+			} else {
+				// Ensure a `NewBlock` event is generated for all children of the
+				// finalized block. Describe the tree route as (child_node, parent_node)
+				// Note: the order of elements matters here.
+				let parents = std::iter::once(finalized).chain(blocks.clone());
+
+				for pair in blocks.zip(parents) {
+					if unique_descendants.insert(pair) {
+						finalized_block_descendants.push(pair);
+					}
+				}
+			}
+		}
+
+		Ok(InitialBlocks { finalized_block_descendants, pruned_forks })
+	}
+
+	/// Generate the initial events reported by the RPC `follow` method.
+	///
+	/// Returns the initial events that should be reported directly, together with pruned
+	/// block hashes that should be ignored by the `Finalized` event.
+	fn generate_init_events(
+		&mut self,
+		startup_point: &StartupPoint<Block>,
+	) -> Result<(Vec<FollowEvent<Block::Hash>>, HashSet<Block::Hash>), SubscriptionManagementError>
+	{
+		let init = self.get_init_blocks_with_forks(startup_point)?;
+
+		let initial_blocks = init.finalized_block_descendants;
+
+		// The initialized event is the first one sent.
+		let finalized_block_hash = startup_point.finalized_hash;
+		self.sub_handle.pin_block(&self.sub_id, finalized_block_hash)?;
+
+		let finalized_block_runtime = self.generate_runtime_event(finalized_block_hash, None);
+
+		let initialized_event = FollowEvent::Initialized(Initialized {
+			finalized_block_hash,
+			finalized_block_runtime,
+			with_runtime: self.with_runtime,
+		});
+
+		let mut finalized_block_descendants = Vec::with_capacity(initial_blocks.len() + 1);
+
+		finalized_block_descendants.push(initialized_event);
+		for (child, parent) in initial_blocks.into_iter() {
+			self.sub_handle.pin_block(&self.sub_id, child)?;
+
+			let new_runtime = self.generate_runtime_event(child, Some(parent));
+
+			let event = FollowEvent::NewBlock(NewBlock {
+				block_hash: child,
+				parent_block_hash: parent,
+				new_runtime,
+				with_runtime: self.with_runtime,
+			});
+
+			finalized_block_descendants.push(event);
+		}
+
+		// Generate a new best block event.
+		let best_block_hash = startup_point.best_hash;
+		if best_block_hash != finalized_block_hash {
+			let best_block = FollowEvent::BestBlockChanged(BestBlockChanged { best_block_hash });
+			self.best_block_cache = Some(best_block_hash);
+			finalized_block_descendants.push(best_block);
+		};
+
+		Ok((finalized_block_descendants, init.pruned_forks))
+	}
+
+	/// Generate the "NewBlock" event and potentially the "BestBlockChanged" event for the
+	/// given block hash.
+	fn generate_import_events(
+		&mut self,
+		block_hash: Block::Hash,
+		parent_block_hash: Block::Hash,
+		is_best_block: bool,
+	) -> Vec<FollowEvent<Block::Hash>> {
+		let new_runtime = self.generate_runtime_event(block_hash, Some(parent_block_hash));
+
+		let new_block = FollowEvent::NewBlock(NewBlock {
+			block_hash,
+			parent_block_hash,
+			new_runtime,
+			with_runtime: self.with_runtime,
+		});
+
+		if !is_best_block {
+			return vec![new_block]
+		}
+
+		// If this is the new best block, then we need to generate two events.
+		let best_block_event =
+			FollowEvent::BestBlockChanged(BestBlockChanged { best_block_hash: block_hash });
+
+		match self.best_block_cache {
+			Some(block_cache) => {
+				// The RPC layer has not reported this block as best before.
+				// Note: This handles the race with the finalized branch.
+				if block_cache != block_hash {
+					self.best_block_cache = Some(block_hash);
+					vec![new_block, best_block_event]
+				} else {
+					vec![new_block]
+				}
+			},
+			None => {
+				self.best_block_cache = Some(block_hash);
+				vec![new_block, best_block_event]
+			},
+		}
+	}
+
+	/// Handle the import of new blocks by generating the appropriate events.
+	fn handle_import_blocks(
+		&mut self,
+		notification: BlockImportNotification<Block>,
+		startup_point: &StartupPoint<Block>,
+	) -> Result<Vec<FollowEvent<Block::Hash>>, SubscriptionManagementError> {
+		// The block was already pinned by the initial block events or by the finalized event.
+		if !self.sub_handle.pin_block(&self.sub_id, notification.hash)? {
+			return Ok(Default::default())
+		}
+
+		// Ensure we are only reporting blocks after the starting point.
+		if *notification.header.number() < startup_point.finalized_number {
+			return Ok(Default::default())
+		}
+
+		Ok(self.generate_import_events(
+			notification.hash,
+			*notification.header.parent_hash(),
+			notification.is_new_best,
+		))
+	}
+
+	/// Generates new block events from the given finalized hashes.
+	///
+	/// It may be possible that the `Finalized` event fired before the `NewBlock`
+	/// event. In that case, for each finalized hash that was not reported yet
+	/// generate the `NewBlock` event. For the final finalized hash we must also
+	/// generate one `BestBlock` event.
+	fn generate_finalized_events(
+		&mut self,
+		finalized_block_hashes: &[Block::Hash],
+	) -> Result<Vec<FollowEvent<Block::Hash>>, SubscriptionManagementError> {
+		let mut events = Vec::new();
+
+		// Nothing to be done if no finalized hashes are provided.
+		let Some(first_hash) = finalized_block_hashes.get(0) else { return Ok(Default::default()) };
+
+		// Find the parent header.
+		let Some(first_header) = self.client.header(*first_hash)? else {
+			return Err(SubscriptionManagementError::BlockHeaderAbsent)
+		};
+
+		let parents =
+			std::iter::once(first_header.parent_hash()).chain(finalized_block_hashes.iter());
+		for (i, (hash, parent)) in finalized_block_hashes.iter().zip(parents).enumerate() {
+			// Check if the block was already reported and thus, is already pinned.
+			if !self.sub_handle.pin_block(&self.sub_id, *hash)? {
+				continue
+			}
+
+			// Generate `NewBlock` events for all blocks beside the last block in the list
+			if i + 1 != finalized_block_hashes.len() {
+				// Generate only the `NewBlock` event for this block.
+				events.extend(self.generate_import_events(*hash, *parent, false));
+			} else {
+				// If we end up here and the `best_block` is a descendent of the finalized block
+				// (last block in the list), it means that there were skipped notifications.
+				// Otherwise `pin_block` would had returned `true`.
+				//
+				// When the node falls out of sync and then syncs up to the tip of the chain, it can
+				// happen that we skip notifications. Then it is better to terminate the connection
+				// instead of trying to send notifications for all missed blocks.
+				if let Some(best_block_hash) = self.best_block_cache {
+					let ancestor = sp_blockchain::lowest_common_ancestor(
+						&*self.client,
+						*hash,
+						best_block_hash,
+					)?;
+
+					if ancestor.hash == *hash {
+						return Err(SubscriptionManagementError::Custom(
+							"A descendent of the finalized block was already reported".into(),
+						))
+					}
+				}
+
+				// Let's generate the `NewBlock` and `NewBestBlock` events for the block.
+				events.extend(self.generate_import_events(*hash, *parent, true))
+			}
+		}
+
+		Ok(events)
+	}
+
+	/// Get all pruned block hashes from the provided stale heads.
+	///
+	/// The result does not include hashes from `to_ignore`.
+	fn get_pruned_hashes(
+		&self,
+		stale_heads: &[Block::Hash],
+		last_finalized: Block::Hash,
+		to_ignore: &mut HashSet<Block::Hash>,
+	) -> Result<Vec<Block::Hash>, SubscriptionManagementError> {
+		let blockchain = self.backend.blockchain();
+		let mut pruned = Vec::new();
+
+		for stale_head in stale_heads {
+			let tree_route = sp_blockchain::tree_route(blockchain, last_finalized, *stale_head)?;
+
+			// Collect only blocks that are not part of the canonical chain.
+			pruned.extend(tree_route.enacted().iter().filter_map(|block| {
+				if !to_ignore.remove(&block.hash) {
+					Some(block.hash)
+				} else {
+					None
+				}
+			}))
+		}
+
+		Ok(pruned)
+	}
+
+	/// Handle the finalization notification by generating the `Finalized` event.
+	///
+	/// If the block of the notification was not reported yet, this method also
+	/// generates the events similar to `handle_import_blocks`.
+	fn handle_finalized_blocks(
+		&mut self,
+		notification: FinalityNotification<Block>,
+		to_ignore: &mut HashSet<Block::Hash>,
+		startup_point: &StartupPoint<Block>,
+	) -> Result<Vec<FollowEvent<Block::Hash>>, SubscriptionManagementError> {
+		let last_finalized = notification.hash;
+
+		// Ensure we are only reporting blocks after the starting point.
+		if *notification.header.number() < startup_point.finalized_number {
+			return Ok(Default::default())
+		}
+
+		// The tree route contains the exclusive path from the last finalized block to the block
+		// reported by the notification. Ensure the finalized block is also reported.
+		let mut finalized_block_hashes = notification.tree_route.to_vec();
+		finalized_block_hashes.push(last_finalized);
+
+		// If the finalized hashes were not reported yet, generate the `NewBlock` events.
+		let mut events = self.generate_finalized_events(&finalized_block_hashes)?;
+
+		// Report all pruned blocks from the notification that are not
+		// part of the fork we need to ignore.
+		let pruned_block_hashes =
+			self.get_pruned_hashes(&notification.stale_heads, last_finalized, to_ignore)?;
+
+		let finalized_event = FollowEvent::Finalized(Finalized {
+			finalized_block_hashes,
+			pruned_block_hashes: pruned_block_hashes.clone(),
+		});
+
+		match self.best_block_cache {
+			Some(block_cache) => {
+				// If the best block wasn't pruned, we are done here.
+				if !pruned_block_hashes.iter().any(|hash| *hash == block_cache) {
+					events.push(finalized_event);
+					return Ok(events)
+				}
+
+				// The best block is reported as pruned. Therefore, we need to signal a new
+				// best block event before submitting the finalized event.
+				let best_block_hash = self.client.info().best_hash;
+				if best_block_hash == block_cache {
+					// The client doest not have any new information about the best block.
+					// The information from `.info()` is updated from the DB as the last
+					// step of the finalization and it should be up to date.
+					// If the info is outdated, there is nothing the RPC can do for now.
+					error!(
+						target: LOG_TARGET,
+						"[follow][id={:?}] Client does not contain different best block",
+						self.sub_id,
+					);
+					events.push(finalized_event);
+					Ok(events)
+				} else {
+					// The RPC needs to also submit a new best block changed before the
+					// finalized event.
+					self.best_block_cache = Some(best_block_hash);
+					let best_block_event =
+						FollowEvent::BestBlockChanged(BestBlockChanged { best_block_hash });
+					events.extend([best_block_event, finalized_event]);
+					Ok(events)
+				}
+			},
+			None => {
+				events.push(finalized_event);
+				Ok(events)
+			},
+		}
+	}
+
+	/// Submit the events from the provided stream to the RPC client
+	/// for as long as the `rx_stop` event was not called.
+	async fn submit_events<EventStream>(
+		&mut self,
+		startup_point: &StartupPoint<Block>,
+		mut stream: EventStream,
+		mut to_ignore: HashSet<Block::Hash>,
+		mut sink: SubscriptionSink,
+		rx_stop: oneshot::Receiver<()>,
+	) where
+		EventStream: Stream<Item = NotificationType<Block>> + Unpin,
+	{
+		let mut stream_item = stream.next();
+		let mut stop_event = rx_stop;
+
+		while let Either::Left((Some(event), next_stop_event)) =
+			futures_util::future::select(stream_item, stop_event).await
+		{
+			let events = match event {
+				NotificationType::InitialEvents(events) => Ok(events),
+				NotificationType::NewBlock(notification) =>
+					self.handle_import_blocks(notification, &startup_point),
+				NotificationType::Finalized(notification) =>
+					self.handle_finalized_blocks(notification, &mut to_ignore, &startup_point),
+				NotificationType::MethodResponse(notification) => Ok(vec![notification]),
+			};
+
+			let events = match events {
+				Ok(events) => events,
+				Err(err) => {
+					debug!(
+						target: LOG_TARGET,
+						"[follow][id={:?}] Failed to handle stream notification {:?}",
+						self.sub_id,
+						err
+					);
+					let _ = sink.send(&FollowEvent::<String>::Stop);
+					return
+				},
+			};
+
+			for event in events {
+				let result = sink.send(&event);
+
+				// Migration note: the new version of jsonrpsee returns Result<(), DisconnectError>
+				// The logic from `Err(err)` should be moved when building the new
+				// `SubscriptionMessage`.
+
+				// For now, jsonrpsee returns:
+				// Ok(true): message sent
+				// Ok(false): client disconnected or subscription closed
+				// Err(err): serder serialization error of the event
+				if let Err(err) = result {
+					// Failed to submit event.
+					debug!(
+						target: LOG_TARGET,
+						"[follow][id={:?}] Failed to send event {:?}", self.sub_id, err
+					);
+
+					let _ = sink.send(&FollowEvent::<String>::Stop);
+					return
+				}
+
+				if let Ok(false) = result {
+					// Client disconnected or subscription was closed.
+					return
+				}
+			}
+
+			stream_item = stream.next();
+			stop_event = next_stop_event;
+		}
+
+		// If we got here either the substrate streams have closed
+		// or the `Stop` receiver was triggered.
+		let _ = sink.send(&FollowEvent::<String>::Stop);
+	}
+
+	/// Generate the block events for the `chainHead_follow` method.
+	pub async fn generate_events(
+		&mut self,
+		mut sink: SubscriptionSink,
+		sub_data: InsertedSubscriptionData<Block>,
+	) {
+		// Register for the new block and finalized notifications.
+		let stream_import = self
+			.client
+			.import_notification_stream()
+			.map(|notification| NotificationType::NewBlock(notification));
+
+		let stream_finalized = self
+			.client
+			.finality_notification_stream()
+			.map(|notification| NotificationType::Finalized(notification));
+
+		let stream_responses = sub_data
+			.response_receiver
+			.map(|response| NotificationType::MethodResponse(response));
+
+		let startup_point = StartupPoint::from(self.client.info());
+		let (initial_events, pruned_forks) = match self.generate_init_events(&startup_point) {
+			Ok(blocks) => blocks,
+			Err(err) => {
+				debug!(
+					target: LOG_TARGET,
+					"[follow][id={:?}] Failed to generate the initial events {:?}",
+					self.sub_id,
+					err
+				);
+				let _ = sink.send(&FollowEvent::<Block::Hash>::Stop);
+				return
+			},
+		};
+
+		let initial = NotificationType::InitialEvents(initial_events);
+		let merged = tokio_stream::StreamExt::merge(stream_import, stream_finalized);
+		let merged = tokio_stream::StreamExt::merge(merged, stream_responses);
+		let stream = stream::once(futures::future::ready(initial)).chain(merged);
+
+		self.submit_events(&startup_point, stream.boxed(), pruned_forks, sink, sub_data.rx_stop)
+			.await;
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/chain_head_storage.rs b/substrate/client/rpc-spec-v2/src/chain_head/chain_head_storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5e1f38f9a99785cf085467fbf9d92876d1190812
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/chain_head_storage.rs
@@ -0,0 +1,324 @@
+// 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/>.
+
+//! Implementation of the `chainHead_storage` method.
+
+use std::{collections::VecDeque, marker::PhantomData, sync::Arc};
+
+use sc_client_api::{Backend, ChildInfo, StorageKey, StorageProvider};
+use sc_utils::mpsc::TracingUnboundedSender;
+use sp_api::BlockT;
+use sp_core::storage::well_known_keys;
+
+use crate::chain_head::event::OperationStorageItems;
+
+use super::{
+	event::{
+		OperationError, OperationId, StorageQuery, StorageQueryType, StorageResult,
+		StorageResultType,
+	},
+	hex_string,
+	subscription::BlockGuard,
+	FollowEvent,
+};
+
+/// The query type of an interation.
+enum IterQueryType {
+	/// Iterating over (key, value) pairs.
+	Value,
+	/// Iterating over (key, hash) pairs.
+	Hash,
+}
+
+/// Generates the events of the `chainHead_storage` method.
+pub struct ChainHeadStorage<Client, Block, BE> {
+	/// Substrate client.
+	client: Arc<Client>,
+	/// Queue of operations that may require pagination.
+	iter_operations: VecDeque<QueryIter>,
+	/// The maximum number of items reported by the `chainHead_storage` before
+	/// pagination is required.
+	operation_max_storage_items: usize,
+	_phandom: PhantomData<(BE, Block)>,
+}
+
+impl<Client, Block, BE> ChainHeadStorage<Client, Block, BE> {
+	/// Constructs a new [`ChainHeadStorage`].
+	pub fn new(client: Arc<Client>, operation_max_storage_items: usize) -> Self {
+		Self {
+			client,
+			iter_operations: VecDeque::new(),
+			operation_max_storage_items,
+			_phandom: PhantomData,
+		}
+	}
+}
+
+/// Query to iterate over storage.
+struct QueryIter {
+	/// The next key from which the iteration should continue.
+	next_key: StorageKey,
+	/// The type of the query (either value or hash).
+	ty: IterQueryType,
+}
+
+/// Checks if the provided key (main or child key) is valid
+/// for queries.
+///
+/// Keys that are identical to `:child_storage:` or `:child_storage:default:`
+/// are not queryable.
+fn is_key_queryable(key: &[u8]) -> bool {
+	!well_known_keys::is_default_child_storage_key(key) &&
+		!well_known_keys::is_child_storage_key(key)
+}
+
+/// The result of making a query call.
+type QueryResult = Result<Option<StorageResult>, String>;
+
+/// The result of iterating over keys.
+type QueryIterResult = Result<(Vec<StorageResult>, Option<QueryIter>), String>;
+
+impl<Client, Block, BE> ChainHeadStorage<Client, Block, BE>
+where
+	Block: BlockT + 'static,
+	BE: Backend<Block> + 'static,
+	Client: StorageProvider<Block, BE> + 'static,
+{
+	/// Fetch the value from storage.
+	fn query_storage_value(
+		&self,
+		hash: Block::Hash,
+		key: &StorageKey,
+		child_key: Option<&ChildInfo>,
+	) -> QueryResult {
+		let result = if let Some(child_key) = child_key {
+			self.client.child_storage(hash, child_key, key)
+		} else {
+			self.client.storage(hash, key)
+		};
+
+		result
+			.map(|opt| {
+				QueryResult::Ok(opt.map(|storage_data| StorageResult {
+					key: hex_string(&key.0),
+					result: StorageResultType::Value(hex_string(&storage_data.0)),
+				}))
+			})
+			.unwrap_or_else(|error| QueryResult::Err(error.to_string()))
+	}
+
+	/// Fetch the hash of a value from storage.
+	fn query_storage_hash(
+		&self,
+		hash: Block::Hash,
+		key: &StorageKey,
+		child_key: Option<&ChildInfo>,
+	) -> QueryResult {
+		let result = if let Some(child_key) = child_key {
+			self.client.child_storage_hash(hash, child_key, key)
+		} else {
+			self.client.storage_hash(hash, key)
+		};
+
+		result
+			.map(|opt| {
+				QueryResult::Ok(opt.map(|storage_data| StorageResult {
+					key: hex_string(&key.0),
+					result: StorageResultType::Hash(hex_string(&storage_data.as_ref())),
+				}))
+			})
+			.unwrap_or_else(|error| QueryResult::Err(error.to_string()))
+	}
+
+	/// Iterate over at most `operation_max_storage_items` keys.
+	///
+	/// Returns the storage result with a potential next key to resume iteration.
+	fn query_storage_iter_pagination(
+		&self,
+		query: QueryIter,
+		hash: Block::Hash,
+		child_key: Option<&ChildInfo>,
+	) -> QueryIterResult {
+		let QueryIter { next_key, ty } = query;
+
+		let mut keys_iter = if let Some(child_key) = child_key {
+			self.client
+				.child_storage_keys(hash, child_key.to_owned(), Some(&next_key), None)
+		} else {
+			self.client.storage_keys(hash, Some(&next_key), None)
+		}
+		.map_err(|err| err.to_string())?;
+
+		let mut ret = Vec::with_capacity(self.operation_max_storage_items);
+		for _ in 0..self.operation_max_storage_items {
+			let Some(key) = keys_iter.next() else {
+				break
+			};
+
+			let result = match ty {
+				IterQueryType::Value => self.query_storage_value(hash, &key, child_key),
+				IterQueryType::Hash => self.query_storage_hash(hash, &key, child_key),
+			}?;
+
+			if let Some(value) = result {
+				ret.push(value);
+			}
+		}
+
+		// Save the next key if any to continue the iteration.
+		let maybe_next_query = keys_iter.next().map(|next_key| QueryIter { next_key, ty });
+		Ok((ret, maybe_next_query))
+	}
+
+	/// Iterate over (key, hash) and (key, value) generating the `WaitingForContinue` event if
+	/// necessary.
+	async fn generate_storage_iter_events(
+		&mut self,
+		mut block_guard: BlockGuard<Block, BE>,
+		hash: Block::Hash,
+		child_key: Option<ChildInfo>,
+	) {
+		let sender = block_guard.response_sender();
+		let operation = block_guard.operation();
+
+		while let Some(query) = self.iter_operations.pop_front() {
+			if operation.was_stopped() {
+				return
+			}
+
+			let result = self.query_storage_iter_pagination(query, hash, child_key.as_ref());
+			let (events, maybe_next_query) = match result {
+				QueryIterResult::Ok(result) => result,
+				QueryIterResult::Err(error) => {
+					send_error::<Block>(&sender, operation.operation_id(), error.to_string());
+					return
+				},
+			};
+
+			if !events.is_empty() {
+				// Send back the results of the iteration produced so far.
+				let _ = sender.unbounded_send(FollowEvent::<Block::Hash>::OperationStorageItems(
+					OperationStorageItems { operation_id: operation.operation_id(), items: events },
+				));
+			}
+
+			if let Some(next_query) = maybe_next_query {
+				let _ =
+					sender.unbounded_send(FollowEvent::<Block::Hash>::OperationWaitingForContinue(
+						OperationId { operation_id: operation.operation_id() },
+					));
+
+				// The operation might be continued or cancelled only after the
+				// `OperationWaitingForContinue` is generated above.
+				operation.wait_for_continue().await;
+
+				// Give a chance for the other items to advance next time.
+				self.iter_operations.push_back(next_query);
+			}
+		}
+
+		if operation.was_stopped() {
+			return
+		}
+
+		let _ =
+			sender.unbounded_send(FollowEvent::<Block::Hash>::OperationStorageDone(OperationId {
+				operation_id: operation.operation_id(),
+			}));
+	}
+
+	/// Generate the block events for the `chainHead_storage` method.
+	pub async fn generate_events(
+		&mut self,
+		mut block_guard: BlockGuard<Block, BE>,
+		hash: Block::Hash,
+		items: Vec<StorageQuery<StorageKey>>,
+		child_key: Option<ChildInfo>,
+	) {
+		let sender = block_guard.response_sender();
+		let operation = block_guard.operation();
+
+		if let Some(child_key) = child_key.as_ref() {
+			if !is_key_queryable(child_key.storage_key()) {
+				let _ = sender.unbounded_send(FollowEvent::<Block::Hash>::OperationStorageDone(
+					OperationId { operation_id: operation.operation_id() },
+				));
+				return
+			}
+		}
+
+		let mut storage_results = Vec::with_capacity(items.len());
+		for item in items {
+			if !is_key_queryable(&item.key.0) {
+				continue
+			}
+
+			match item.query_type {
+				StorageQueryType::Value => {
+					match self.query_storage_value(hash, &item.key, child_key.as_ref()) {
+						Ok(Some(value)) => storage_results.push(value),
+						Ok(None) => continue,
+						Err(error) => {
+							send_error::<Block>(&sender, operation.operation_id(), error);
+							return
+						},
+					}
+				},
+				StorageQueryType::Hash =>
+					match self.query_storage_hash(hash, &item.key, child_key.as_ref()) {
+						Ok(Some(value)) => storage_results.push(value),
+						Ok(None) => continue,
+						Err(error) => {
+							send_error::<Block>(&sender, operation.operation_id(), error);
+							return
+						},
+					},
+				StorageQueryType::DescendantsValues => self
+					.iter_operations
+					.push_back(QueryIter { next_key: item.key, ty: IterQueryType::Value }),
+				StorageQueryType::DescendantsHashes => self
+					.iter_operations
+					.push_back(QueryIter { next_key: item.key, ty: IterQueryType::Hash }),
+				_ => continue,
+			};
+		}
+
+		if !storage_results.is_empty() {
+			let _ = sender.unbounded_send(FollowEvent::<Block::Hash>::OperationStorageItems(
+				OperationStorageItems {
+					operation_id: operation.operation_id(),
+					items: storage_results,
+				},
+			));
+		}
+
+		self.generate_storage_iter_events(block_guard, hash, child_key).await
+	}
+}
+
+/// Build and send the opaque error back to the `chainHead_follow` method.
+fn send_error<Block: BlockT>(
+	sender: &TracingUnboundedSender<FollowEvent<Block::Hash>>,
+	operation_id: String,
+	error: String,
+) {
+	let _ = sender.unbounded_send(FollowEvent::<Block::Hash>::OperationError(OperationError {
+		operation_id,
+		error,
+	}));
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/error.rs b/substrate/client/rpc-spec-v2/src/chain_head/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3b2edb2b00c8cd63bd85d84cd01576b10c2e4ce0
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/error.rs
@@ -0,0 +1,80 @@
+// 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/>.
+
+//! Error helpers for `chainHead` RPC module.
+
+use jsonrpsee::{
+	core::Error as RpcError,
+	types::error::{CallError, ErrorObject},
+};
+use sp_blockchain::Error as BlockchainError;
+
+/// ChainHead RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// The provided block hash is invalid.
+	#[error("Invalid block hash")]
+	InvalidBlock,
+	/// Fetch block header error.
+	#[error("Could not fetch block header: {0}")]
+	FetchBlockHeader(BlockchainError),
+	/// Invalid parameter provided to the RPC method.
+	#[error("Invalid parameter: {0}")]
+	InvalidParam(String),
+	/// Invalid subscription ID provided by the RPC server.
+	#[error("Invalid subscription ID")]
+	InvalidSubscriptionID,
+	/// Wait-for-continue event not generated.
+	#[error("Wait for continue event was not generated for the subscription")]
+	InvalidContinue,
+}
+
+// Base code for all `chainHead` errors.
+const BASE_ERROR: i32 = 2000;
+/// The provided block hash is invalid.
+const INVALID_BLOCK_ERROR: i32 = BASE_ERROR + 1;
+/// Fetch block header error.
+const FETCH_BLOCK_HEADER_ERROR: i32 = BASE_ERROR + 2;
+/// Invalid parameter error.
+const INVALID_PARAM_ERROR: i32 = BASE_ERROR + 3;
+/// Invalid subscription ID.
+const INVALID_SUB_ID: i32 = BASE_ERROR + 4;
+/// Wait-for-continue event not generated.
+const INVALID_CONTINUE: i32 = BASE_ERROR + 5;
+
+impl From<Error> for ErrorObject<'static> {
+	fn from(e: Error) -> Self {
+		let msg = e.to_string();
+
+		match e {
+			Error::InvalidBlock => ErrorObject::owned(INVALID_BLOCK_ERROR, msg, None::<()>),
+			Error::FetchBlockHeader(_) =>
+				ErrorObject::owned(FETCH_BLOCK_HEADER_ERROR, msg, None::<()>),
+			Error::InvalidParam(_) => ErrorObject::owned(INVALID_PARAM_ERROR, msg, None::<()>),
+			Error::InvalidSubscriptionID => ErrorObject::owned(INVALID_SUB_ID, msg, None::<()>),
+			Error::InvalidContinue => ErrorObject::owned(INVALID_CONTINUE, msg, None::<()>),
+		}
+		.into()
+	}
+}
+
+impl From<Error> for RpcError {
+	fn from(e: Error) -> Self {
+		CallError::Custom(e.into()).into()
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/event.rs b/substrate/client/rpc-spec-v2/src/chain_head/event.rs
new file mode 100644
index 0000000000000000000000000000000000000000..65bc8b247c880d392e1c1ab62272f5dfa3a53acb
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/event.rs
@@ -0,0 +1,754 @@
+// 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/>.
+
+//! The chain head's event returned as json compatible object.
+
+use serde::{ser::SerializeStruct, Deserialize, Serialize, Serializer};
+use sp_api::ApiError;
+use sp_version::RuntimeVersion;
+
+/// The operation could not be processed due to an error.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ErrorEvent {
+	/// Reason of the error.
+	pub error: String,
+}
+
+/// The runtime specification of the current block.
+///
+/// This event is generated for:
+///   - the first announced block by the follow subscription
+///   - blocks that suffered a change in runtime compared with their parents
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RuntimeVersionEvent {
+	/// The runtime version.
+	pub spec: RuntimeVersion,
+}
+
+/// The runtime event generated if the `follow` subscription
+/// has set the `with_runtime` flag.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(tag = "type")]
+pub enum RuntimeEvent {
+	/// The runtime version of this block.
+	Valid(RuntimeVersionEvent),
+	/// The runtime could not be obtained due to an error.
+	Invalid(ErrorEvent),
+}
+
+impl From<ApiError> for RuntimeEvent {
+	fn from(err: ApiError) -> Self {
+		RuntimeEvent::Invalid(ErrorEvent { error: format!("Api error: {}", err) })
+	}
+}
+
+/// Contain information about the latest finalized block.
+///
+/// # Note
+///
+/// This is the first event generated by the `follow` subscription
+/// and is submitted only once.
+///
+/// If the `with_runtime` flag is set, then this event contains
+/// the `RuntimeEvent`, otherwise the `RuntimeEvent` is not present.
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Initialized<Hash> {
+	/// The hash of the latest finalized block.
+	pub finalized_block_hash: Hash,
+	/// The runtime version of the finalized block.
+	///
+	/// # Note
+	///
+	/// This is present only if the `with_runtime` flag is set for
+	/// the `follow` subscription.
+	pub finalized_block_runtime: Option<RuntimeEvent>,
+	/// Privately keep track if the `finalized_block_runtime` should be
+	/// serialized.
+	#[serde(default)]
+	pub(crate) with_runtime: bool,
+}
+
+impl<Hash: Serialize> Serialize for Initialized<Hash> {
+	/// Custom serialize implementation to include the `RuntimeEvent` depending
+	/// on the internal `with_runtime` flag.
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		if self.with_runtime {
+			let mut state = serializer.serialize_struct("Initialized", 2)?;
+			state.serialize_field("finalizedBlockHash", &self.finalized_block_hash)?;
+			state.serialize_field("finalizedBlockRuntime", &self.finalized_block_runtime)?;
+			state.end()
+		} else {
+			let mut state = serializer.serialize_struct("Initialized", 1)?;
+			state.serialize_field("finalizedBlockHash", &self.finalized_block_hash)?;
+			state.end()
+		}
+	}
+}
+
+/// Indicate a new non-finalized block.
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NewBlock<Hash> {
+	/// The hash of the new block.
+	pub block_hash: Hash,
+	/// The parent hash of the new block.
+	pub parent_block_hash: Hash,
+	/// The runtime version of the new block.
+	///
+	/// # Note
+	///
+	/// This is present only if the `with_runtime` flag is set for
+	/// the `follow` subscription.
+	pub new_runtime: Option<RuntimeEvent>,
+	/// Privately keep track if the `finalized_block_runtime` should be
+	/// serialized.
+	#[serde(default)]
+	pub(crate) with_runtime: bool,
+}
+
+impl<Hash: Serialize> Serialize for NewBlock<Hash> {
+	/// Custom serialize implementation to include the `RuntimeEvent` depending
+	/// on the internal `with_runtime` flag.
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		if self.with_runtime {
+			let mut state = serializer.serialize_struct("NewBlock", 3)?;
+			state.serialize_field("blockHash", &self.block_hash)?;
+			state.serialize_field("parentBlockHash", &self.parent_block_hash)?;
+			state.serialize_field("newRuntime", &self.new_runtime)?;
+			state.end()
+		} else {
+			let mut state = serializer.serialize_struct("NewBlock", 2)?;
+			state.serialize_field("blockHash", &self.block_hash)?;
+			state.serialize_field("parentBlockHash", &self.parent_block_hash)?;
+			state.end()
+		}
+	}
+}
+
+/// Indicate the block hash of the new best block.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BestBlockChanged<Hash> {
+	/// The block hash of the new best block.
+	pub best_block_hash: Hash,
+}
+
+/// Indicate the finalized and pruned block hashes.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Finalized<Hash> {
+	/// Block hashes that are finalized.
+	pub finalized_block_hashes: Vec<Hash>,
+	/// Block hashes that are pruned (removed).
+	pub pruned_block_hashes: Vec<Hash>,
+}
+
+/// Indicate the operation id of the event.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OperationId {
+	/// The operation id of the event.
+	pub operation_id: String,
+}
+
+/// The response of the `chainHead_body` method.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OperationBodyDone {
+	/// The operation id of the event.
+	pub operation_id: String,
+	/// Array of hexadecimal-encoded scale-encoded extrinsics found in the block.
+	pub value: Vec<String>,
+}
+
+/// The response of the `chainHead_call` method.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OperationCallDone {
+	/// The operation id of the event.
+	pub operation_id: String,
+	/// Hexadecimal-encoded output of the runtime function call.
+	pub output: String,
+}
+
+/// The response of the `chainHead_call` method.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OperationStorageItems {
+	/// The operation id of the event.
+	pub operation_id: String,
+	/// The resulting items.
+	pub items: Vec<StorageResult>,
+}
+
+/// Indicate a problem during the operation.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OperationError {
+	/// The operation id of the event.
+	pub operation_id: String,
+	/// The reason of the error.
+	pub error: String,
+}
+
+/// The event generated by the `follow` method.
+///
+/// The block events are generated in the following order:
+/// 1. Initialized - generated only once to signal the latest finalized block
+/// 2. NewBlock - a new block was added.
+/// 3. BestBlockChanged - indicate that the best block is now the one from this event. The block was
+///    announced priorly with the `NewBlock` event.
+/// 4. Finalized - State the finalized and pruned blocks.
+///
+/// The following events are related to operations:
+/// - OperationBodyDone: The response of the `chianHead_body`
+/// - OperationCallDone: The response of the `chianHead_call`
+/// - OperationStorageItems: Items produced by the `chianHead_storage`
+/// - OperationWaitingForContinue: Generated after OperationStorageItems and requires the user to
+///   call `chainHead_continue`
+/// - OperationStorageDone: The `chianHead_storage` method has produced all the results
+/// - OperationInaccessible: The server was unable to provide the result, retries might succeed in
+///   the future
+/// - OperationError: The server encountered an error, retries will not succeed
+///
+/// The stop event indicates that the JSON-RPC server was unable to provide a consistent list of
+/// the blocks at the head of the chain.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(tag = "event")]
+pub enum FollowEvent<Hash> {
+	/// The latest finalized block.
+	///
+	/// This event is generated only once.
+	Initialized(Initialized<Hash>),
+	/// A new non-finalized block was added.
+	NewBlock(NewBlock<Hash>),
+	/// The best block of the chain.
+	BestBlockChanged(BestBlockChanged<Hash>),
+	/// A list of finalized and pruned blocks.
+	Finalized(Finalized<Hash>),
+	/// The response of the `chainHead_body` method.
+	OperationBodyDone(OperationBodyDone),
+	/// The response of the `chainHead_call` method.
+	OperationCallDone(OperationCallDone),
+	/// Yield one or more items found in the storage.
+	OperationStorageItems(OperationStorageItems),
+	/// Ask the user to call `chainHead_continue` to produce more events
+	/// regarding the operation id.
+	OperationWaitingForContinue(OperationId),
+	/// The responses of the `chainHead_storage` method have been produced.
+	OperationStorageDone(OperationId),
+	/// The RPC server was unable to provide the response of the following operation id.
+	///
+	/// Repeating the same operation in the future might succeed.
+	OperationInaccessible(OperationId),
+	/// The RPC server encountered an error while processing an operation id.
+	///
+	/// Repeating the same operation in the future will not succeed.
+	OperationError(OperationError),
+	/// The subscription is dropped and no further events
+	/// will be generated.
+	Stop,
+}
+
+/// The storage item received as paramter.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StorageQuery<Key> {
+	/// The provided key.
+	pub key: Key,
+	/// The type of the storage query.
+	#[serde(rename = "type")]
+	pub query_type: StorageQueryType,
+}
+
+/// The type of the storage query.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum StorageQueryType {
+	/// Fetch the value of the provided key.
+	Value,
+	/// Fetch the hash of the value of the provided key.
+	Hash,
+	/// Fetch the closest descendant merkle value.
+	ClosestDescendantMerkleValue,
+	/// Fetch the values of all descendants of they provided key.
+	DescendantsValues,
+	/// Fetch the hashes of the values of all descendants of they provided key.
+	DescendantsHashes,
+}
+
+/// The storage result.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StorageResult {
+	/// The hex-encoded key of the result.
+	pub key: String,
+	/// The result of the query.
+	#[serde(flatten)]
+	pub result: StorageResultType,
+}
+
+/// The type of the storage query.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum StorageResultType {
+	/// Fetch the value of the provided key.
+	Value(String),
+	/// Fetch the hash of the value of the provided key.
+	Hash(String),
+	/// Fetch the closest descendant merkle value.
+	ClosestDescendantMerkleValue(String),
+}
+
+/// The method respose of `chainHead_body`, `chainHead_call` and `chainHead_storage`.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(tag = "result")]
+pub enum MethodResponse {
+	/// The method has started.
+	Started(MethodResponseStarted),
+	/// The RPC server cannot handle the request at the moment.
+	LimitReached,
+}
+
+/// The `started` result of a method.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MethodResponseStarted {
+	/// The operation id of the response.
+	pub operation_id: String,
+	/// The number of items from the back of the `chainHead_storage` that have been discarded.
+	#[serde(skip_serializing_if = "Option::is_none")]
+	#[serde(default)]
+	pub discarded_items: Option<usize>,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn follow_initialized_event_no_updates() {
+		// Runtime flag is false.
+		let event: FollowEvent<String> = FollowEvent::Initialized(Initialized {
+			finalized_block_hash: "0x1".into(),
+			finalized_block_runtime: None,
+			with_runtime: false,
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"initialized","finalizedBlockHash":"0x1"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_initialized_event_with_updates() {
+		// Runtime flag is true, block runtime must always be reported for this event.
+		let runtime = RuntimeVersion {
+			spec_name: "ABC".into(),
+			impl_name: "Impl".into(),
+			spec_version: 1,
+			..Default::default()
+		};
+
+		let runtime_event = RuntimeEvent::Valid(RuntimeVersionEvent { spec: runtime });
+		let mut initialized = Initialized {
+			finalized_block_hash: "0x1".into(),
+			finalized_block_runtime: Some(runtime_event),
+			with_runtime: true,
+		};
+		let event: FollowEvent<String> = FollowEvent::Initialized(initialized.clone());
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = concat!(
+			r#"{"event":"initialized","finalizedBlockHash":"0x1","#,
+			r#""finalizedBlockRuntime":{"type":"valid","spec":{"specName":"ABC","implName":"Impl","authoringVersion":0,"#,
+			r#""specVersion":1,"implVersion":0,"apis":[],"transactionVersion":0,"stateVersion":0}}}"#,
+		);
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		// The `with_runtime` field is used for serialization purposes.
+		initialized.with_runtime = false;
+		assert!(matches!(
+			event_dec, FollowEvent::Initialized(ref dec) if dec == &initialized
+		));
+	}
+
+	#[test]
+	fn follow_new_block_event_no_updates() {
+		// Runtime flag is false.
+		let event: FollowEvent<String> = FollowEvent::NewBlock(NewBlock {
+			block_hash: "0x1".into(),
+			parent_block_hash: "0x2".into(),
+			new_runtime: None,
+			with_runtime: false,
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"newBlock","blockHash":"0x1","parentBlockHash":"0x2"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_new_block_event_with_updates() {
+		// Runtime flag is true, block runtime must always be reported for this event.
+		let runtime = RuntimeVersion {
+			spec_name: "ABC".into(),
+			impl_name: "Impl".into(),
+			spec_version: 1,
+			..Default::default()
+		};
+
+		let runtime_event = RuntimeEvent::Valid(RuntimeVersionEvent { spec: runtime });
+		let mut new_block = NewBlock {
+			block_hash: "0x1".into(),
+			parent_block_hash: "0x2".into(),
+			new_runtime: Some(runtime_event),
+			with_runtime: true,
+		};
+
+		let event: FollowEvent<String> = FollowEvent::NewBlock(new_block.clone());
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = concat!(
+			r#"{"event":"newBlock","blockHash":"0x1","parentBlockHash":"0x2","#,
+			r#""newRuntime":{"type":"valid","spec":{"specName":"ABC","implName":"Impl","authoringVersion":0,"#,
+			r#""specVersion":1,"implVersion":0,"apis":[],"transactionVersion":0,"stateVersion":0}}}"#,
+		);
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		// The `with_runtime` field is used for serialization purposes.
+		new_block.with_runtime = false;
+		assert!(matches!(
+			event_dec, FollowEvent::NewBlock(ref dec) if dec == &new_block
+		));
+
+		// Runtime flag is true, runtime didn't change compared to parent.
+		let mut new_block = NewBlock {
+			block_hash: "0x1".into(),
+			parent_block_hash: "0x2".into(),
+			new_runtime: None,
+			with_runtime: true,
+		};
+		let event: FollowEvent<String> = FollowEvent::NewBlock(new_block.clone());
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp =
+			r#"{"event":"newBlock","blockHash":"0x1","parentBlockHash":"0x2","newRuntime":null}"#;
+		assert_eq!(ser, exp);
+		new_block.with_runtime = false;
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert!(matches!(
+			event_dec, FollowEvent::NewBlock(ref dec) if dec == &new_block
+		));
+	}
+
+	#[test]
+	fn follow_best_block_changed_event() {
+		let event: FollowEvent<String> =
+			FollowEvent::BestBlockChanged(BestBlockChanged { best_block_hash: "0x1".into() });
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"bestBlockChanged","bestBlockHash":"0x1"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_finalized_event() {
+		let event: FollowEvent<String> = FollowEvent::Finalized(Finalized {
+			finalized_block_hashes: vec!["0x1".into()],
+			pruned_block_hashes: vec!["0x2".into()],
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp =
+			r#"{"event":"finalized","finalizedBlockHashes":["0x1"],"prunedBlockHashes":["0x2"]}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_op_body_event() {
+		let event: FollowEvent<String> = FollowEvent::OperationBodyDone(OperationBodyDone {
+			operation_id: "123".into(),
+			value: vec!["0x1".into()],
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"operationBodyDone","operationId":"123","value":["0x1"]}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_op_call_event() {
+		let event: FollowEvent<String> = FollowEvent::OperationCallDone(OperationCallDone {
+			operation_id: "123".into(),
+			output: "0x1".into(),
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"operationCallDone","operationId":"123","output":"0x1"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_op_storage_items_event() {
+		let event: FollowEvent<String> =
+			FollowEvent::OperationStorageItems(OperationStorageItems {
+				operation_id: "123".into(),
+				items: vec![StorageResult {
+					key: "0x1".into(),
+					result: StorageResultType::Value("0x123".to_string()),
+				}],
+			});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"operationStorageItems","operationId":"123","items":[{"key":"0x1","value":"0x123"}]}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_op_wait_event() {
+		let event: FollowEvent<String> =
+			FollowEvent::OperationWaitingForContinue(OperationId { operation_id: "123".into() });
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"operationWaitingForContinue","operationId":"123"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_op_storage_done_event() {
+		let event: FollowEvent<String> =
+			FollowEvent::OperationStorageDone(OperationId { operation_id: "123".into() });
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"operationStorageDone","operationId":"123"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_op_inaccessible_event() {
+		let event: FollowEvent<String> =
+			FollowEvent::OperationInaccessible(OperationId { operation_id: "123".into() });
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"operationInaccessible","operationId":"123"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_op_error_event() {
+		let event: FollowEvent<String> = FollowEvent::OperationError(OperationError {
+			operation_id: "123".into(),
+			error: "reason".into(),
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"operationError","operationId":"123","error":"reason"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn follow_stop_event() {
+		let event: FollowEvent<String> = FollowEvent::Stop;
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"event":"stop"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: FollowEvent<String> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn method_response() {
+		// Response of `call` and `body`
+		let event = MethodResponse::Started(MethodResponseStarted {
+			operation_id: "123".into(),
+			discarded_items: None,
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"result":"started","operationId":"123"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: MethodResponse = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+
+		// Response of `storage`
+		let event = MethodResponse::Started(MethodResponseStarted {
+			operation_id: "123".into(),
+			discarded_items: Some(1),
+		});
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"result":"started","operationId":"123","discardedItems":1}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: MethodResponse = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+
+		// Limit reached.
+		let event = MethodResponse::LimitReached;
+
+		let ser = serde_json::to_string(&event).unwrap();
+		let exp = r#"{"result":"limitReached"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: MethodResponse = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn chain_head_storage_query() {
+		// Item with Value.
+		let item = StorageQuery { key: "0x1", query_type: StorageQueryType::Value };
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","type":"value"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageQuery<&str> = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+
+		// Item with Hash.
+		let item = StorageQuery { key: "0x1", query_type: StorageQueryType::Hash };
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","type":"hash"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageQuery<&str> = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+
+		// Item with DescendantsValues.
+		let item = StorageQuery { key: "0x1", query_type: StorageQueryType::DescendantsValues };
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","type":"descendantsValues"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageQuery<&str> = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+
+		// Item with DescendantsHashes.
+		let item = StorageQuery { key: "0x1", query_type: StorageQueryType::DescendantsHashes };
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","type":"descendantsHashes"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageQuery<&str> = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+
+		// Item with Merkle.
+		let item =
+			StorageQuery { key: "0x1", query_type: StorageQueryType::ClosestDescendantMerkleValue };
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","type":"closestDescendantMerkleValue"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageQuery<&str> = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+	}
+
+	#[test]
+	fn chain_head_storage_result() {
+		// Item with Value.
+		let item =
+			StorageResult { key: "0x1".into(), result: StorageResultType::Value("res".into()) };
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","value":"res"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageResult = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+
+		// Item with Hash.
+		let item =
+			StorageResult { key: "0x1".into(), result: StorageResultType::Hash("res".into()) };
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","hash":"res"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageResult = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+
+		// Item with DescendantsValues.
+		let item = StorageResult {
+			key: "0x1".into(),
+			result: StorageResultType::ClosestDescendantMerkleValue("res".into()),
+		};
+		// Encode
+		let ser = serde_json::to_string(&item).unwrap();
+		let exp = r#"{"key":"0x1","closestDescendantMerkleValue":"res"}"#;
+		assert_eq!(ser, exp);
+		// Decode
+		let dec: StorageResult = serde_json::from_str(exp).unwrap();
+		assert_eq!(dec, item);
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/mod.rs b/substrate/client/rpc-spec-v2/src/chain_head/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1bd22885780251f66cfbb2779ee93a89c24ccbc7
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/mod.rs
@@ -0,0 +1,51 @@
+// 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/>.
+
+//! Substrate chain head API.
+//!
+//! # Note
+//!
+//! Methods are prefixed by `chainHead`.
+
+#[cfg(test)]
+mod test_utils;
+#[cfg(test)]
+mod tests;
+
+pub mod api;
+pub mod chain_head;
+pub mod error;
+pub mod event;
+
+mod chain_head_follow;
+mod chain_head_storage;
+mod subscription;
+
+pub use api::ChainHeadApiServer;
+pub use chain_head::{ChainHead, ChainHeadConfig};
+pub use event::{
+	BestBlockChanged, ErrorEvent, Finalized, FollowEvent, Initialized, NewBlock, RuntimeEvent,
+	RuntimeVersionEvent,
+};
+
+use sp_core::hexdisplay::{AsBytesRef, HexDisplay};
+
+/// Util function to print the results of `chianHead` as hex string
+pub(crate) fn hex_string<Data: AsBytesRef>(data: &Data) -> String {
+	format!("0x{:?}", HexDisplay::from(data))
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/subscription/error.rs b/substrate/client/rpc-spec-v2/src/chain_head/subscription/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..38e8fd7384fcbd222bbfc385de602a834613c07d
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/subscription/error.rs
@@ -0,0 +1,66 @@
+// 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 sp_blockchain::Error;
+
+/// Subscription management error.
+#[derive(Debug, thiserror::Error)]
+pub enum SubscriptionManagementError {
+	/// The subscription has exceeded the internal limits
+	/// regarding the number of pinned blocks in memory or
+	/// the number of ongoing operations.
+	#[error("Exceeded pinning or operation limits")]
+	ExceededLimits,
+	/// Error originated from the blockchain (client or backend).
+	#[error("Blockchain error {0}")]
+	Blockchain(Error),
+	/// The database does not contain a block hash.
+	#[error("Block hash is absent")]
+	BlockHashAbsent,
+	/// The database does not contain a block header.
+	#[error("Block header is absent")]
+	BlockHeaderAbsent,
+	/// The specified subscription ID is not present.
+	#[error("Subscription is absent")]
+	SubscriptionAbsent,
+	/// Custom error.
+	#[error("Subscription error {0}")]
+	Custom(String),
+}
+
+// Blockchain error does not implement `PartialEq` needed for testing.
+impl PartialEq for SubscriptionManagementError {
+	fn eq(&self, other: &SubscriptionManagementError) -> bool {
+		match (self, other) {
+			(Self::ExceededLimits, Self::ExceededLimits) |
+			// Not needed for testing.
+			(Self::Blockchain(_), Self::Blockchain(_)) |
+			(Self::BlockHashAbsent, Self::BlockHashAbsent) |
+			(Self::BlockHeaderAbsent, Self::BlockHeaderAbsent) |
+			(Self::SubscriptionAbsent, Self::SubscriptionAbsent) => true,
+			(Self::Custom(lhs), Self::Custom(rhs)) => lhs == rhs,
+			_ => false,
+		}
+	}
+}
+
+impl From<Error> for SubscriptionManagementError {
+	fn from(err: Error) -> Self {
+		SubscriptionManagementError::Blockchain(err)
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/subscription/inner.rs b/substrate/client/rpc-spec-v2/src/chain_head/subscription/inner.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d6f64acd63f5f2f22584e965f5ba5f5abd3e2f33
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/subscription/inner.rs
@@ -0,0 +1,1281 @@
+// 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 futures::channel::oneshot;
+use parking_lot::Mutex;
+use sc_client_api::Backend;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_runtime::traits::Block as BlockT;
+use std::{
+	collections::{hash_map::Entry, HashMap},
+	sync::{atomic::AtomicBool, Arc},
+	time::{Duration, Instant},
+};
+
+use crate::chain_head::{subscription::SubscriptionManagementError, FollowEvent};
+
+/// The queue size after which the `sc_utils::mpsc::tracing_unbounded` would produce warnings.
+const QUEUE_SIZE_WARNING: usize = 512;
+
+/// The state machine of a block of a single subscription ID.
+///
+/// # Motivation
+///
+/// Each block is registered twice: once from the `BestBlock` event
+/// and once from the `Finalized` event.
+///
+/// The state of a block must be tracked until both events register the
+/// block and the user calls `unpin`.
+///
+/// Otherwise, the following race might happen:
+///  T0. BestBlock event: hash is tracked and pinned in backend.
+///  T1. User calls unpin: hash is untracked and unpinned in backend.
+///  T2. Finalized event: hash is tracked (no previous history) and pinned again.
+///
+/// # State Machine Transition
+///
+/// ```ignore
+///                   (register)
+/// [ REGISTERED ]  ---------------> [ FULLY REGISTERED ]
+///       |                              |
+///       | (unpin)                      | (unpin)
+///       |                              |
+///       V           (register)         V
+/// [ UNPINNED ]  -----------------> [ FULLY UNPINNED ]
+/// ```
+#[derive(Debug, Clone, PartialEq)]
+enum BlockStateMachine {
+	/// The block was registered by one event (either `Finalized` or `BestBlock` event).
+	///
+	/// Unpin was not called.
+	Registered,
+	/// The block was registered by both events (`Finalized` and `BestBlock` events).
+	///
+	/// Unpin was not called.
+	FullyRegistered,
+	/// The block was registered by one event (either `Finalized` or `BestBlock` event),
+	///
+	/// Unpin __was__ called.
+	Unpinned,
+	/// The block was registered by both events (`Finalized` and `BestBlock` events).
+	///
+	/// Unpin __was__ called.
+	FullyUnpinned,
+}
+
+impl BlockStateMachine {
+	fn new() -> Self {
+		BlockStateMachine::Registered
+	}
+
+	fn advance_register(&mut self) {
+		match self {
+			BlockStateMachine::Registered => *self = BlockStateMachine::FullyRegistered,
+			BlockStateMachine::Unpinned => *self = BlockStateMachine::FullyUnpinned,
+			_ => (),
+		}
+	}
+
+	fn advance_unpin(&mut self) {
+		match self {
+			BlockStateMachine::Registered => *self = BlockStateMachine::Unpinned,
+			BlockStateMachine::FullyRegistered => *self = BlockStateMachine::FullyUnpinned,
+			_ => (),
+		}
+	}
+
+	fn was_unpinned(&self) -> bool {
+		match self {
+			BlockStateMachine::Unpinned => true,
+			BlockStateMachine::FullyUnpinned => true,
+			_ => false,
+		}
+	}
+}
+
+/// Limit the number of ongoing operations across methods.
+struct LimitOperations {
+	/// Limit the number of ongoing operations for this subscription.
+	semaphore: Arc<tokio::sync::Semaphore>,
+}
+
+impl LimitOperations {
+	/// Constructs a new [`LimitOperations`].
+	fn new(max_operations: usize) -> Self {
+		LimitOperations { semaphore: Arc::new(tokio::sync::Semaphore::new(max_operations)) }
+	}
+
+	/// Reserves capacity to execute at least one operation and at most the requested items.
+	///
+	/// Dropping [`PermitOperations`] without executing an operation will release
+	/// the reserved capacity.
+	///
+	/// Returns nothing if there's no space available, else returns a permit
+	/// that guarantees that at least one operation can be executed.
+	fn reserve_at_most(&self, to_reserve: usize) -> Option<PermitOperations> {
+		let num_ops = std::cmp::min(self.semaphore.available_permits(), to_reserve);
+
+		if num_ops == 0 {
+			return None
+		}
+
+		let permits = Arc::clone(&self.semaphore)
+			.try_acquire_many_owned(num_ops.try_into().ok()?)
+			.ok()?;
+
+		Some(PermitOperations { num_ops, _permit: permits })
+	}
+}
+
+/// Permits a number of operations to be executed.
+///
+/// [`PermitOperations`] are returned by [`LimitOperations::reserve()`] and are used
+/// to guarantee the RPC server can execute the number of operations.
+///
+/// The number of reserved items are given back to the [`LimitOperations`] on drop.
+struct PermitOperations {
+	/// The number of operations permitted (reserved).
+	num_ops: usize,
+	/// The permit for these operations.
+	_permit: tokio::sync::OwnedSemaphorePermit,
+}
+
+/// The state of one operation.
+///
+/// This is directly exposed to users via `chain_head_unstable_continue` and
+/// `chain_head_unstable_stop_operation`.
+#[derive(Clone)]
+pub struct OperationState {
+	/// The shared operation state that holds information about the
+	/// `waitingForContinue` event and cancellation.
+	shared_state: Arc<SharedOperationState>,
+	/// Send notifications when the user calls `chainHead_continue` method.
+	send_continue: tokio::sync::mpsc::Sender<()>,
+}
+
+impl OperationState {
+	/// Returns true if `chainHead_continue` is called after the
+	/// `waitingForContinue` event was emitted for the associated
+	/// operation ID.
+	pub fn submit_continue(&self) -> bool {
+		// `waitingForContinue` not generated.
+		if !self.shared_state.requested_continue.load(std::sync::atomic::Ordering::Acquire) {
+			return false
+		}
+
+		// Has enough capacity for 1 message.
+		// Can fail if the `stop_operation` propagated the stop first.
+		self.send_continue.try_send(()).is_ok()
+	}
+
+	/// Stops the operation if `waitingForContinue` event was emitted for the associated
+	/// operation ID.
+	///
+	/// Returns nothing in accordance with `chainHead_unstable_stopOperation`.
+	pub fn stop_operation(&self) {
+		// `waitingForContinue` not generated.
+		if !self.shared_state.requested_continue.load(std::sync::atomic::Ordering::Acquire) {
+			return
+		}
+
+		self.shared_state
+			.operation_stopped
+			.store(true, std::sync::atomic::Ordering::Release);
+
+		// Send might not have enough capacity if `submit_continue` was sent first.
+		// However, the `operation_stopped` boolean was set.
+		let _ = self.send_continue.try_send(());
+	}
+}
+
+/// The shared operation state between the backend [`RegisteredOperation`] and frontend
+/// [`RegisteredOperation`].
+struct SharedOperationState {
+	/// True if the `chainHead` generated `waitingForContinue` event.
+	requested_continue: AtomicBool,
+	/// True if the operation was cancelled by the user.
+	operation_stopped: AtomicBool,
+}
+
+impl SharedOperationState {
+	/// Constructs a new [`SharedOperationState`].
+	///
+	/// This is efficiently cloned under a single heap allocation.
+	fn new() -> Arc<Self> {
+		Arc::new(SharedOperationState {
+			requested_continue: AtomicBool::new(false),
+			operation_stopped: AtomicBool::new(false),
+		})
+	}
+}
+
+/// The registered operation passed to the `chainHead` methods.
+///
+/// This is used internally by the `chainHead` methods.
+pub struct RegisteredOperation {
+	/// The shared operation state that holds information about the
+	/// `waitingForContinue` event and cancellation.
+	shared_state: Arc<SharedOperationState>,
+	/// Receive notifications when the user calls `chainHead_continue` method.
+	recv_continue: tokio::sync::mpsc::Receiver<()>,
+	/// The operation ID of the request.
+	operation_id: String,
+	/// Track the operations ID of this subscription.
+	operations: Arc<Mutex<HashMap<String, OperationState>>>,
+	/// Permit a number of items to be executed by this operation.
+	permit: PermitOperations,
+}
+
+impl RegisteredOperation {
+	/// Wait until the user calls `chainHead_continue` or the operation
+	/// is cancelled via `chainHead_stopOperation`.
+	pub async fn wait_for_continue(&mut self) {
+		self.shared_state
+			.requested_continue
+			.store(true, std::sync::atomic::Ordering::Release);
+
+		// The sender part of this channel is around for as long as this object exists,
+		// because it is stored in the `OperationState` of the `operations` field.
+		// The sender part is removed from tracking when this object is dropped.
+		let _ = self.recv_continue.recv().await;
+
+		self.shared_state
+			.requested_continue
+			.store(false, std::sync::atomic::Ordering::Release);
+	}
+
+	/// Returns true if the current operation was stopped.
+	pub fn was_stopped(&self) -> bool {
+		self.shared_state.operation_stopped.load(std::sync::atomic::Ordering::Acquire)
+	}
+
+	/// Get the operation ID.
+	pub fn operation_id(&self) -> String {
+		self.operation_id.clone()
+	}
+
+	/// Returns the number of reserved elements for this permit.
+	///
+	/// This can be smaller than the number of items requested via [`LimitOperations::reserve()`].
+	pub fn num_reserved(&self) -> usize {
+		self.permit.num_ops
+	}
+}
+
+impl Drop for RegisteredOperation {
+	fn drop(&mut self) {
+		let mut operations = self.operations.lock();
+		operations.remove(&self.operation_id);
+	}
+}
+
+/// The ongoing operations of a subscription.
+struct Operations {
+	/// The next operation ID to be generated.
+	next_operation_id: usize,
+	/// Limit the number of ongoing operations.
+	limits: LimitOperations,
+	/// Track the operations ID of this subscription.
+	operations: Arc<Mutex<HashMap<String, OperationState>>>,
+}
+
+impl Operations {
+	/// Constructs a new [`Operations`].
+	fn new(max_operations: usize) -> Self {
+		Operations {
+			next_operation_id: 0,
+			limits: LimitOperations::new(max_operations),
+			operations: Default::default(),
+		}
+	}
+
+	/// Register a new operation.
+	pub fn register_operation(&mut self, to_reserve: usize) -> Option<RegisteredOperation> {
+		let permit = self.limits.reserve_at_most(to_reserve)?;
+
+		let operation_id = self.next_operation_id();
+
+		// At most one message can be sent.
+		let (send_continue, recv_continue) = tokio::sync::mpsc::channel(1);
+		let shared_state = SharedOperationState::new();
+
+		let state = OperationState { send_continue, shared_state: shared_state.clone() };
+
+		// Cloned operations for removing the current ID on drop.
+		let operations = self.operations.clone();
+		operations.lock().insert(operation_id.clone(), state);
+
+		Some(RegisteredOperation { shared_state, operation_id, recv_continue, operations, permit })
+	}
+
+	/// Get the associated operation state with the ID.
+	pub fn get_operation(&self, id: &str) -> Option<OperationState> {
+		self.operations.lock().get(id).map(|state| state.clone())
+	}
+
+	/// Generate the next operation ID for this subscription.
+	fn next_operation_id(&mut self) -> String {
+		let op_id = self.next_operation_id;
+		self.next_operation_id += 1;
+		op_id.to_string()
+	}
+}
+
+struct BlockState {
+	/// The state machine of this block.
+	state_machine: BlockStateMachine,
+	/// The timestamp when the block was inserted.
+	timestamp: Instant,
+}
+
+/// The state of a single subscription ID.
+struct SubscriptionState<Block: BlockT> {
+	/// The `with_runtime` parameter flag of the subscription.
+	with_runtime: bool,
+	/// Signals the "Stop" event.
+	tx_stop: Option<oneshot::Sender<()>>,
+	/// The sender of message responses to the `chainHead_follow` events.
+	///
+	/// This object is cloned between methods.
+	response_sender: TracingUnboundedSender<FollowEvent<Block::Hash>>,
+	/// The ongoing operations of a subscription.
+	operations: Operations,
+	/// Track the block hashes available for this subscription.
+	///
+	/// This implementation assumes:
+	/// - most of the time subscriptions keep a few blocks of the chain's head pinned
+	/// - iteration through the blocks happens only when the hard limit is exceeded.
+	///
+	/// Considering the assumption, iterating (in the unlike case) the hashmap O(N) is
+	/// more time efficient and code friendly than paying for:
+	/// - extra space: an extra BTreeMap<Instant, Hash> to older hashes by oldest insertion
+	/// - extra time: O(log(N)) for insert/remove/find each `pin` block time per subscriptions
+	blocks: HashMap<Block::Hash, BlockState>,
+}
+
+impl<Block: BlockT> SubscriptionState<Block> {
+	/// Trigger the stop event for the current subscription.
+	///
+	/// This can happen on internal failure (ie, the pruning deleted the block from memory)
+	/// or if the subscription exceeded the available pinned blocks.
+	fn stop(&mut self) {
+		if let Some(tx_stop) = self.tx_stop.take() {
+			let _ = tx_stop.send(());
+		}
+	}
+
+	/// Keep track of the given block hash for this subscription.
+	///
+	/// This does not handle pinning in the backend.
+	///
+	/// Returns:
+	/// - true if this is the first time that the block is registered
+	/// - false if the block was already registered
+	fn register_block(&mut self, hash: Block::Hash) -> bool {
+		match self.blocks.entry(hash) {
+			Entry::Occupied(mut occupied) => {
+				let block_state = occupied.get_mut();
+
+				block_state.state_machine.advance_register();
+				// Block was registered twice and unpin was called.
+				if block_state.state_machine == BlockStateMachine::FullyUnpinned {
+					occupied.remove();
+				}
+
+				// Second time we register this block.
+				false
+			},
+			Entry::Vacant(vacant) => {
+				vacant.insert(BlockState {
+					state_machine: BlockStateMachine::new(),
+					timestamp: Instant::now(),
+				});
+
+				// First time we register this block.
+				true
+			},
+		}
+	}
+
+	/// A block is unregistered when the user calls `unpin`.
+	///
+	/// Returns:
+	/// - true if the block can be unpinned.
+	/// - false if the subscription does not contain the block or it was unpinned.
+	fn unregister_block(&mut self, hash: Block::Hash) -> bool {
+		match self.blocks.entry(hash) {
+			Entry::Occupied(mut occupied) => {
+				let block_state = occupied.get_mut();
+
+				// Cannot unpin a block twice.
+				if block_state.state_machine.was_unpinned() {
+					return false
+				}
+
+				block_state.state_machine.advance_unpin();
+				// Block was registered twice and unpin was called.
+				if block_state.state_machine == BlockStateMachine::FullyUnpinned {
+					occupied.remove();
+				}
+
+				true
+			},
+			// Block was not tracked.
+			Entry::Vacant(_) => false,
+		}
+	}
+
+	/// A subscription contains a block when the block was
+	/// registered (`pin` was called) and the block was not `unpinned` yet.
+	///
+	/// Returns `true` if the subscription contains the block.
+	fn contains_block(&self, hash: Block::Hash) -> bool {
+		let Some(state) = self.blocks.get(&hash) else {
+			// Block was not tracked.
+			return false
+		};
+
+		// Subscription no longer contains the block if `unpin` was called.
+		!state.state_machine.was_unpinned()
+	}
+
+	/// Get the timestamp of the oldest inserted block.
+	///
+	/// # Note
+	///
+	/// This iterates over all the blocks of the subscription.
+	fn find_oldest_block_timestamp(&self) -> Instant {
+		let mut timestamp = Instant::now();
+		for (_, state) in self.blocks.iter() {
+			timestamp = std::cmp::min(timestamp, state.timestamp);
+		}
+		timestamp
+	}
+
+	/// Register a new operation.
+	///
+	/// The registered operation can execute at least one item and at most the requested items.
+	fn register_operation(&mut self, to_reserve: usize) -> Option<RegisteredOperation> {
+		self.operations.register_operation(to_reserve)
+	}
+
+	/// Get the associated operation state with the ID.
+	pub fn get_operation(&self, id: &str) -> Option<OperationState> {
+		self.operations.get_operation(id)
+	}
+}
+
+/// Keeps a specific block pinned while the handle is alive.
+/// This object ensures that the block is not unpinned while
+/// executing an RPC method call.
+pub struct BlockGuard<Block: BlockT, BE: Backend<Block>> {
+	hash: Block::Hash,
+	with_runtime: bool,
+	response_sender: TracingUnboundedSender<FollowEvent<Block::Hash>>,
+	operation: RegisteredOperation,
+	backend: Arc<BE>,
+}
+
+// Custom implementation of Debug to avoid bounds on `backend: Debug` for `unwrap_err()` needed for
+// testing.
+impl<Block: BlockT, BE: Backend<Block>> std::fmt::Debug for BlockGuard<Block, BE> {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "BlockGuard hash {:?} with_runtime {:?}", self.hash, self.with_runtime)
+	}
+}
+
+impl<Block: BlockT, BE: Backend<Block>> BlockGuard<Block, BE> {
+	/// Construct a new [`BlockGuard`] .
+	fn new(
+		hash: Block::Hash,
+		with_runtime: bool,
+		response_sender: TracingUnboundedSender<FollowEvent<Block::Hash>>,
+		operation: RegisteredOperation,
+		backend: Arc<BE>,
+	) -> Result<Self, SubscriptionManagementError> {
+		backend
+			.pin_block(hash)
+			.map_err(|err| SubscriptionManagementError::Custom(err.to_string()))?;
+
+		Ok(Self { hash, with_runtime, response_sender, operation, backend })
+	}
+
+	/// The `with_runtime` flag of the subscription.
+	pub fn has_runtime(&self) -> bool {
+		self.with_runtime
+	}
+
+	/// Send message responses from the `chainHead` methods to `chainHead_follow`.
+	pub fn response_sender(&self) -> TracingUnboundedSender<FollowEvent<Block::Hash>> {
+		self.response_sender.clone()
+	}
+
+	/// Get the details of the registered operation.
+	pub fn operation(&mut self) -> &mut RegisteredOperation {
+		&mut self.operation
+	}
+}
+
+impl<Block: BlockT, BE: Backend<Block>> Drop for BlockGuard<Block, BE> {
+	fn drop(&mut self) {
+		self.backend.unpin_block(self.hash);
+	}
+}
+
+/// The data propagated back to the `chainHead_follow` method after
+/// the subscription is successfully inserted.
+pub struct InsertedSubscriptionData<Block: BlockT> {
+	/// Signal that the subscription must stop.
+	pub rx_stop: oneshot::Receiver<()>,
+	/// Receive message responses from the `chainHead` methods.
+	pub response_receiver: TracingUnboundedReceiver<FollowEvent<Block::Hash>>,
+}
+
+pub struct SubscriptionsInner<Block: BlockT, BE: Backend<Block>> {
+	/// Reference count the block hashes across all subscriptions.
+	///
+	/// The pinned blocks cannot exceed the [`Self::global_limit`] limit.
+	/// When the limit is exceeded subscriptions are stopped via the `Stop` event.
+	global_blocks: HashMap<Block::Hash, usize>,
+	/// The maximum number of pinned blocks across all subscriptions.
+	global_max_pinned_blocks: usize,
+	/// The maximum duration that a block is allowed to be pinned per subscription.
+	local_max_pin_duration: Duration,
+	/// The maximum number of ongoing operations per subscription.
+	max_ongoing_operations: usize,
+	/// Map the subscription ID to internal details of the subscription.
+	subs: HashMap<String, SubscriptionState<Block>>,
+	/// Backend pinning / unpinning blocks.
+	///
+	/// The `Arc` is handled one level-above, but substrate exposes the backend as Arc<T>.
+	backend: Arc<BE>,
+}
+
+impl<Block: BlockT, BE: Backend<Block>> SubscriptionsInner<Block, BE> {
+	/// Construct a new [`SubscriptionsInner`] from the specified limits.
+	pub fn new(
+		global_max_pinned_blocks: usize,
+		local_max_pin_duration: Duration,
+		max_ongoing_operations: usize,
+		backend: Arc<BE>,
+	) -> Self {
+		SubscriptionsInner {
+			global_blocks: Default::default(),
+			global_max_pinned_blocks,
+			local_max_pin_duration,
+			max_ongoing_operations,
+			subs: Default::default(),
+			backend,
+		}
+	}
+
+	/// Insert a new subscription ID.
+	pub fn insert_subscription(
+		&mut self,
+		sub_id: String,
+		with_runtime: bool,
+	) -> Option<InsertedSubscriptionData<Block>> {
+		if let Entry::Vacant(entry) = self.subs.entry(sub_id) {
+			let (tx_stop, rx_stop) = oneshot::channel();
+			let (response_sender, response_receiver) =
+				tracing_unbounded("chain-head-method-responses", QUEUE_SIZE_WARNING);
+			let state = SubscriptionState::<Block> {
+				with_runtime,
+				tx_stop: Some(tx_stop),
+				response_sender,
+				blocks: Default::default(),
+				operations: Operations::new(self.max_ongoing_operations),
+			};
+			entry.insert(state);
+
+			Some(InsertedSubscriptionData { rx_stop, response_receiver })
+		} else {
+			None
+		}
+	}
+
+	/// Remove the subscription ID with associated pinned blocks.
+	pub fn remove_subscription(&mut self, sub_id: &str) {
+		let Some(mut sub) = self.subs.remove(sub_id) else { return };
+
+		// The `Stop` event can be generated only once.
+		sub.stop();
+
+		for (hash, state) in sub.blocks.iter() {
+			if !state.state_machine.was_unpinned() {
+				self.global_unregister_block(*hash);
+			}
+		}
+	}
+
+	/// Ensure that a new block could be pinned.
+	///
+	/// If the global number of blocks has been reached this method
+	/// will remove all subscriptions that have blocks older than the
+	/// specified pin duration.
+	///
+	/// If after removing all subscriptions that exceed the pin duration
+	/// there is no space for pinning a new block, then all subscriptions
+	/// are terminated.
+	///
+	/// Returns true if the given subscription is also terminated.
+	fn ensure_block_space(&mut self, request_sub_id: &str) -> bool {
+		if self.global_blocks.len() < self.global_max_pinned_blocks {
+			return false
+		}
+
+		// Terminate all subscriptions that have blocks older than
+		// the specified pin duration.
+		let now = Instant::now();
+
+		let to_remove: Vec<_> = self
+			.subs
+			.iter_mut()
+			.filter_map(|(sub_id, sub)| {
+				let sub_time = sub.find_oldest_block_timestamp();
+				// Subscriptions older than the specified pin duration should be removed.
+				let should_remove = match now.checked_duration_since(sub_time) {
+					Some(duration) => duration > self.local_max_pin_duration,
+					None => true,
+				};
+				should_remove.then(|| sub_id.clone())
+			})
+			.collect();
+
+		let mut is_terminated = false;
+		for sub_id in to_remove {
+			if sub_id == request_sub_id {
+				is_terminated = true;
+			}
+			self.remove_subscription(&sub_id);
+		}
+
+		// Make sure we have enough space after first pass of terminating subscriptions.
+		if self.global_blocks.len() < self.global_max_pinned_blocks {
+			return is_terminated
+		}
+
+		// Sanity check: cannot uphold `chainHead` guarantees anymore. We have not
+		// found any subscriptions that have older pinned blocks to terminate.
+		let to_remove: Vec<_> = self.subs.keys().map(|sub_id| sub_id.clone()).collect();
+		for sub_id in to_remove {
+			if sub_id == request_sub_id {
+				is_terminated = true;
+			}
+			self.remove_subscription(&sub_id);
+		}
+		return is_terminated
+	}
+
+	pub fn pin_block(
+		&mut self,
+		sub_id: &str,
+		hash: Block::Hash,
+	) -> Result<bool, SubscriptionManagementError> {
+		let Some(sub) = self.subs.get_mut(sub_id) else {
+			return Err(SubscriptionManagementError::SubscriptionAbsent)
+		};
+
+		// Block was already registered for this subscription and therefore
+		// globally tracked.
+		if !sub.register_block(hash) {
+			return Ok(false)
+		}
+
+		// Ensure we have enough space only if the hash is not globally registered.
+		if !self.global_blocks.contains_key(&hash) {
+			// Subscription ID was terminated while ensuring enough space.
+			if self.ensure_block_space(sub_id) {
+				return Err(SubscriptionManagementError::ExceededLimits)
+			}
+		}
+
+		self.global_register_block(hash)?;
+		Ok(true)
+	}
+
+	/// Register the block internally.
+	///
+	/// If the block is present the reference counter is increased.
+	/// If this is a new block, the block is pinned in the backend.
+	fn global_register_block(
+		&mut self,
+		hash: Block::Hash,
+	) -> Result<(), SubscriptionManagementError> {
+		match self.global_blocks.entry(hash) {
+			Entry::Occupied(mut occupied) => {
+				*occupied.get_mut() += 1;
+			},
+			Entry::Vacant(vacant) => {
+				self.backend
+					.pin_block(hash)
+					.map_err(|err| SubscriptionManagementError::Custom(err.to_string()))?;
+
+				vacant.insert(1);
+			},
+		};
+		Ok(())
+	}
+
+	/// Unregister the block internally.
+	///
+	/// If the block is present the reference counter is decreased.
+	/// If this is the last reference of the block, the block
+	/// is unpinned from the backend and removed from internal tracking.
+	fn global_unregister_block(&mut self, hash: Block::Hash) {
+		if let Entry::Occupied(mut occupied) = self.global_blocks.entry(hash) {
+			let counter = occupied.get_mut();
+			if *counter == 1 {
+				// Unpin the block from the backend.
+				self.backend.unpin_block(hash);
+				occupied.remove();
+			} else {
+				*counter -= 1;
+			}
+		}
+	}
+
+	pub fn unpin_block(
+		&mut self,
+		sub_id: &str,
+		hash: Block::Hash,
+	) -> Result<(), SubscriptionManagementError> {
+		let Some(sub) = self.subs.get_mut(sub_id) else {
+			return Err(SubscriptionManagementError::SubscriptionAbsent)
+		};
+
+		// Check that unpin was not called before and the block was pinned
+		// for this subscription.
+		if !sub.unregister_block(hash) {
+			return Err(SubscriptionManagementError::BlockHashAbsent)
+		}
+
+		self.global_unregister_block(hash);
+		Ok(())
+	}
+
+	pub fn lock_block(
+		&mut self,
+		sub_id: &str,
+		hash: Block::Hash,
+		to_reserve: usize,
+	) -> Result<BlockGuard<Block, BE>, SubscriptionManagementError> {
+		let Some(sub) = self.subs.get_mut(sub_id) else {
+			return Err(SubscriptionManagementError::SubscriptionAbsent)
+		};
+
+		if !sub.contains_block(hash) {
+			return Err(SubscriptionManagementError::BlockHashAbsent)
+		}
+
+		let Some(operation) = sub.register_operation(to_reserve) else {
+			// Error when the server cannot execute at least one operation.
+			return Err(SubscriptionManagementError::ExceededLimits)
+		};
+
+		BlockGuard::new(
+			hash,
+			sub.with_runtime,
+			sub.response_sender.clone(),
+			operation,
+			self.backend.clone(),
+		)
+	}
+
+	pub fn get_operation(&mut self, sub_id: &str, id: &str) -> Option<OperationState> {
+		let state = self.subs.get(sub_id)?;
+		state.get_operation(id)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_block_builder::BlockBuilderProvider;
+	use sc_service::client::new_in_mem;
+	use sp_consensus::BlockOrigin;
+	use sp_core::{testing::TaskExecutor, H256};
+	use substrate_test_runtime_client::{
+		prelude::*,
+		runtime::{Block, RuntimeApi},
+		Client, ClientBlockImportExt, GenesisInit,
+	};
+
+	/// Maximum number of ongoing operations per subscription ID.
+	const MAX_OPERATIONS_PER_SUB: usize = 16;
+
+	fn init_backend() -> (
+		Arc<sc_client_api::in_mem::Backend<Block>>,
+		Arc<Client<sc_client_api::in_mem::Backend<Block>>>,
+	) {
+		let backend = Arc::new(sc_client_api::in_mem::Backend::new());
+		let executor = substrate_test_runtime_client::new_native_or_wasm_executor();
+		let client_config = sc_service::ClientConfig::default();
+		let genesis_block_builder = sc_service::GenesisBlockBuilder::new(
+			&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
+			!client_config.no_genesis,
+			backend.clone(),
+			executor.clone(),
+		)
+		.unwrap();
+		let client = Arc::new(
+			new_in_mem::<_, Block, _, RuntimeApi>(
+				backend.clone(),
+				executor,
+				genesis_block_builder,
+				None,
+				None,
+				Box::new(TaskExecutor::new()),
+				client_config,
+			)
+			.unwrap(),
+		);
+		(backend, client)
+	}
+
+	#[test]
+	fn block_state_machine_register_unpin() {
+		let mut state = BlockStateMachine::new();
+		// Starts in `Registered` state.
+		assert_eq!(state, BlockStateMachine::Registered);
+
+		state.advance_register();
+		assert_eq!(state, BlockStateMachine::FullyRegistered);
+
+		// Can call register multiple times.
+		state.advance_register();
+		assert_eq!(state, BlockStateMachine::FullyRegistered);
+
+		assert!(!state.was_unpinned());
+		state.advance_unpin();
+		assert_eq!(state, BlockStateMachine::FullyUnpinned);
+		assert!(state.was_unpinned());
+
+		// Can call unpin multiple times.
+		state.advance_unpin();
+		assert_eq!(state, BlockStateMachine::FullyUnpinned);
+		assert!(state.was_unpinned());
+
+		// Nothing to advance.
+		state.advance_register();
+		assert_eq!(state, BlockStateMachine::FullyUnpinned);
+	}
+
+	#[test]
+	fn block_state_machine_unpin_register() {
+		let mut state = BlockStateMachine::new();
+		// Starts in `Registered` state.
+		assert_eq!(state, BlockStateMachine::Registered);
+
+		assert!(!state.was_unpinned());
+		state.advance_unpin();
+		assert_eq!(state, BlockStateMachine::Unpinned);
+		assert!(state.was_unpinned());
+
+		// Can call unpin multiple times.
+		state.advance_unpin();
+		assert_eq!(state, BlockStateMachine::Unpinned);
+		assert!(state.was_unpinned());
+
+		state.advance_register();
+		assert_eq!(state, BlockStateMachine::FullyUnpinned);
+		assert!(state.was_unpinned());
+
+		// Nothing to advance.
+		state.advance_register();
+		assert_eq!(state, BlockStateMachine::FullyUnpinned);
+		// Nothing to unpin.
+		state.advance_unpin();
+		assert_eq!(state, BlockStateMachine::FullyUnpinned);
+		assert!(state.was_unpinned());
+	}
+
+	#[test]
+	fn sub_state_register_twice() {
+		let (response_sender, _response_receiver) =
+			tracing_unbounded("test-chain-head-method-responses", QUEUE_SIZE_WARNING);
+		let mut sub_state = SubscriptionState::<Block> {
+			with_runtime: false,
+			tx_stop: None,
+			response_sender,
+			operations: Operations::new(MAX_OPERATIONS_PER_SUB),
+			blocks: Default::default(),
+		};
+
+		let hash = H256::random();
+		assert_eq!(sub_state.register_block(hash), true);
+		let block_state = sub_state.blocks.get(&hash).unwrap();
+		// Did not call `register_block` twice.
+		assert_eq!(block_state.state_machine, BlockStateMachine::Registered);
+
+		assert_eq!(sub_state.register_block(hash), false);
+		let block_state = sub_state.blocks.get(&hash).unwrap();
+		assert_eq!(block_state.state_machine, BlockStateMachine::FullyRegistered);
+
+		// Block is no longer tracked when: `register_block` is called twice and
+		// `unregister_block` is called once.
+		assert_eq!(sub_state.unregister_block(hash), true);
+		let block_state = sub_state.blocks.get(&hash);
+		assert!(block_state.is_none());
+	}
+
+	#[test]
+	fn sub_state_register_unregister() {
+		let (response_sender, _response_receiver) =
+			tracing_unbounded("test-chain-head-method-responses", QUEUE_SIZE_WARNING);
+		let mut sub_state = SubscriptionState::<Block> {
+			with_runtime: false,
+			tx_stop: None,
+			response_sender,
+			blocks: Default::default(),
+			operations: Operations::new(MAX_OPERATIONS_PER_SUB),
+		};
+
+		let hash = H256::random();
+		// Block was not registered before.
+		assert_eq!(sub_state.unregister_block(hash), false);
+
+		assert_eq!(sub_state.register_block(hash), true);
+		let block_state = sub_state.blocks.get(&hash).unwrap();
+		// Did not call `register_block` twice.
+		assert_eq!(block_state.state_machine, BlockStateMachine::Registered);
+
+		// Unregister block before the second `register_block`.
+		assert_eq!(sub_state.unregister_block(hash), true);
+		let block_state = sub_state.blocks.get(&hash).unwrap();
+		assert_eq!(block_state.state_machine, BlockStateMachine::Unpinned);
+
+		assert_eq!(sub_state.register_block(hash), false);
+		let block_state = sub_state.blocks.get(&hash);
+		assert!(block_state.is_none());
+
+		// Block is no longer tracked when: `register_block` is called twice and
+		// `unregister_block` is called once.
+		assert_eq!(sub_state.unregister_block(hash), false);
+		let block_state = sub_state.blocks.get(&hash);
+		assert!(block_state.is_none());
+	}
+
+	#[test]
+	fn subscription_lock_block() {
+		let builder = TestClientBuilder::new();
+		let backend = builder.backend();
+		let mut subs =
+			SubscriptionsInner::new(10, Duration::from_secs(10), MAX_OPERATIONS_PER_SUB, backend);
+
+		let id = "abc".to_string();
+		let hash = H256::random();
+
+		// Subscription not inserted.
+		let err = subs.lock_block(&id, hash, 1).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::SubscriptionAbsent);
+
+		let _stop = subs.insert_subscription(id.clone(), true).unwrap();
+		// Cannot insert the same subscription ID twice.
+		assert!(subs.insert_subscription(id.clone(), true).is_none());
+
+		// No block hash.
+		let err = subs.lock_block(&id, hash, 1).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::BlockHashAbsent);
+
+		subs.remove_subscription(&id);
+
+		// No subscription.
+		let err = subs.lock_block(&id, hash, 1).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::SubscriptionAbsent);
+	}
+
+	#[test]
+	fn subscription_check_block() {
+		let (backend, mut client) = init_backend();
+
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+
+		let mut subs =
+			SubscriptionsInner::new(10, Duration::from_secs(10), MAX_OPERATIONS_PER_SUB, backend);
+		let id = "abc".to_string();
+
+		let _stop = subs.insert_subscription(id.clone(), true).unwrap();
+
+		// First time we are pinning the block.
+		assert_eq!(subs.pin_block(&id, hash).unwrap(), true);
+
+		let block = subs.lock_block(&id, hash, 1).unwrap();
+		// Subscription started with runtime updates
+		assert_eq!(block.has_runtime(), true);
+
+		let invalid_id = "abc-invalid".to_string();
+		let err = subs.unpin_block(&invalid_id, hash).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::SubscriptionAbsent);
+
+		// Unpin the block.
+		subs.unpin_block(&id, hash).unwrap();
+		let err = subs.lock_block(&id, hash, 1).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::BlockHashAbsent);
+	}
+
+	#[test]
+	fn subscription_ref_count() {
+		let (backend, mut client) = init_backend();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+
+		let mut subs =
+			SubscriptionsInner::new(10, Duration::from_secs(10), MAX_OPERATIONS_PER_SUB, backend);
+		let id = "abc".to_string();
+
+		let _stop = subs.insert_subscription(id.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id, hash).unwrap(), true);
+		// Check the global ref count.
+		assert_eq!(*subs.global_blocks.get(&hash).unwrap(), 1);
+		// Ensure the block propagated to the subscription.
+		subs.subs.get(&id).unwrap().blocks.get(&hash).unwrap();
+
+		// Insert the block for the same subscription again (simulate NewBlock + Finalized pinning)
+		assert_eq!(subs.pin_block(&id, hash).unwrap(), false);
+		// Check the global ref count should not get incremented.
+		assert_eq!(*subs.global_blocks.get(&hash).unwrap(), 1);
+
+		// Ensure the hash propagates for the second subscription.
+		let id_second = "abcd".to_string();
+		let _stop = subs.insert_subscription(id_second.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id_second, hash).unwrap(), true);
+		// Check the global ref count.
+		assert_eq!(*subs.global_blocks.get(&hash).unwrap(), 2);
+		// Ensure the block propagated to the subscription.
+		subs.subs.get(&id_second).unwrap().blocks.get(&hash).unwrap();
+
+		subs.unpin_block(&id, hash).unwrap();
+		assert_eq!(*subs.global_blocks.get(&hash).unwrap(), 1);
+		// Cannot unpin a block twice for the same subscription.
+		let err = subs.unpin_block(&id, hash).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::BlockHashAbsent);
+
+		subs.unpin_block(&id_second, hash).unwrap();
+		// Block unregistered from the memory.
+		assert!(subs.global_blocks.get(&hash).is_none());
+	}
+
+	#[test]
+	fn subscription_remove_subscription() {
+		let (backend, mut client) = init_backend();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_1 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_2 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_3 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+
+		let mut subs =
+			SubscriptionsInner::new(10, Duration::from_secs(10), MAX_OPERATIONS_PER_SUB, backend);
+		let id_1 = "abc".to_string();
+		let id_2 = "abcd".to_string();
+
+		// Pin all blocks for the first subscription.
+		let _stop = subs.insert_subscription(id_1.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id_1, hash_1).unwrap(), true);
+		assert_eq!(subs.pin_block(&id_1, hash_2).unwrap(), true);
+		assert_eq!(subs.pin_block(&id_1, hash_3).unwrap(), true);
+
+		// Pin only block 2 for the second subscription.
+		let _stop = subs.insert_subscription(id_2.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id_2, hash_2).unwrap(), true);
+
+		// Check reference count.
+		assert_eq!(*subs.global_blocks.get(&hash_1).unwrap(), 1);
+		assert_eq!(*subs.global_blocks.get(&hash_2).unwrap(), 2);
+		assert_eq!(*subs.global_blocks.get(&hash_3).unwrap(), 1);
+
+		subs.remove_subscription(&id_1);
+
+		assert!(subs.global_blocks.get(&hash_1).is_none());
+		assert_eq!(*subs.global_blocks.get(&hash_2).unwrap(), 1);
+		assert!(subs.global_blocks.get(&hash_3).is_none());
+
+		subs.remove_subscription(&id_2);
+
+		assert!(subs.global_blocks.get(&hash_2).is_none());
+		assert_eq!(subs.global_blocks.len(), 0);
+	}
+
+	#[test]
+	fn subscription_check_limits() {
+		let (backend, mut client) = init_backend();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_1 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_2 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_3 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+
+		// Maximum number of pinned blocks is 2.
+		let mut subs =
+			SubscriptionsInner::new(2, Duration::from_secs(10), MAX_OPERATIONS_PER_SUB, backend);
+		let id_1 = "abc".to_string();
+		let id_2 = "abcd".to_string();
+
+		// Both subscriptions can pin the maximum limit.
+		let _stop = subs.insert_subscription(id_1.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id_1, hash_1).unwrap(), true);
+		assert_eq!(subs.pin_block(&id_1, hash_2).unwrap(), true);
+
+		let _stop = subs.insert_subscription(id_2.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id_2, hash_1).unwrap(), true);
+		assert_eq!(subs.pin_block(&id_2, hash_2).unwrap(), true);
+
+		// Check reference count.
+		assert_eq!(*subs.global_blocks.get(&hash_1).unwrap(), 2);
+		assert_eq!(*subs.global_blocks.get(&hash_2).unwrap(), 2);
+
+		// Block 3 pinning will exceed the limit and both subscriptions
+		// are terminated because no subscription with older blocks than 10
+		// seconds are present.
+		let err = subs.pin_block(&id_1, hash_3).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::ExceededLimits);
+
+		// Ensure both subscriptions are removed.
+		let err = subs.lock_block(&id_1, hash_1, 1).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::SubscriptionAbsent);
+
+		let err = subs.lock_block(&id_2, hash_1, 1).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::SubscriptionAbsent);
+
+		assert!(subs.global_blocks.get(&hash_1).is_none());
+		assert!(subs.global_blocks.get(&hash_2).is_none());
+		assert!(subs.global_blocks.get(&hash_3).is_none());
+		assert_eq!(subs.global_blocks.len(), 0);
+	}
+
+	#[test]
+	fn subscription_check_limits_with_duration() {
+		let (backend, mut client) = init_backend();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_1 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_2 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash_3 = block.header.hash();
+		futures::executor::block_on(client.import(BlockOrigin::Own, block.clone())).unwrap();
+
+		// Maximum number of pinned blocks is 2 and maximum pin duration is 5 second.
+		let mut subs =
+			SubscriptionsInner::new(2, Duration::from_secs(5), MAX_OPERATIONS_PER_SUB, backend);
+		let id_1 = "abc".to_string();
+		let id_2 = "abcd".to_string();
+
+		let _stop = subs.insert_subscription(id_1.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id_1, hash_1).unwrap(), true);
+		assert_eq!(subs.pin_block(&id_1, hash_2).unwrap(), true);
+
+		// Maximum pin duration is 5 second, sleep 5 seconds to ensure we clean up
+		// the first subscription.
+		std::thread::sleep(std::time::Duration::from_secs(5));
+
+		let _stop = subs.insert_subscription(id_2.clone(), true).unwrap();
+		assert_eq!(subs.pin_block(&id_2, hash_1).unwrap(), true);
+
+		// Check reference count.
+		assert_eq!(*subs.global_blocks.get(&hash_1).unwrap(), 2);
+		assert_eq!(*subs.global_blocks.get(&hash_2).unwrap(), 1);
+
+		// Second subscription has only 1 block pinned. Only the first subscription is terminated.
+		let err = subs.pin_block(&id_1, hash_3).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::ExceededLimits);
+
+		// Ensure both subscriptions are removed.
+		let err = subs.lock_block(&id_1, hash_1, 1).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::SubscriptionAbsent);
+
+		let _block_guard = subs.lock_block(&id_2, hash_1, 1).unwrap();
+
+		assert_eq!(*subs.global_blocks.get(&hash_1).unwrap(), 1);
+		assert!(subs.global_blocks.get(&hash_2).is_none());
+		assert!(subs.global_blocks.get(&hash_3).is_none());
+		assert_eq!(subs.global_blocks.len(), 1);
+
+		// Force second subscription to get terminated.
+		assert_eq!(subs.pin_block(&id_2, hash_2).unwrap(), true);
+		let err = subs.pin_block(&id_2, hash_3).unwrap_err();
+		assert_eq!(err, SubscriptionManagementError::ExceededLimits);
+
+		assert!(subs.global_blocks.get(&hash_1).is_none());
+		assert!(subs.global_blocks.get(&hash_2).is_none());
+		assert!(subs.global_blocks.get(&hash_3).is_none());
+		assert_eq!(subs.global_blocks.len(), 0);
+	}
+
+	#[test]
+	fn subscription_check_stop_event() {
+		let builder = TestClientBuilder::new();
+		let backend = builder.backend();
+		let mut subs =
+			SubscriptionsInner::new(10, Duration::from_secs(10), MAX_OPERATIONS_PER_SUB, backend);
+
+		let id = "abc".to_string();
+
+		let mut sub_data = subs.insert_subscription(id.clone(), true).unwrap();
+
+		// Check the stop signal was not received.
+		let res = sub_data.rx_stop.try_recv().unwrap();
+		assert!(res.is_none());
+
+		let sub = subs.subs.get_mut(&id).unwrap();
+		sub.stop();
+
+		// Check the signal was received.
+		let res = sub_data.rx_stop.try_recv().unwrap();
+		assert!(res.is_some());
+	}
+
+	#[test]
+	fn ongoing_operations() {
+		// The object can hold at most 2 operations.
+		let ops = LimitOperations::new(2);
+
+		// One operation is reserved.
+		let permit_one = ops.reserve_at_most(1).unwrap();
+		assert_eq!(permit_one.num_ops, 1);
+
+		// Request 2 operations, however there is capacity only for one.
+		let permit_two = ops.reserve_at_most(2).unwrap();
+		// Number of reserved permits is smaller than provided.
+		assert_eq!(permit_two.num_ops, 1);
+
+		// Try to reserve operations when there's no space.
+		let permit = ops.reserve_at_most(1);
+		assert!(permit.is_none());
+
+		// Release capacity.
+		drop(permit_two);
+
+		// Can reserve again
+		let permit_three = ops.reserve_at_most(1).unwrap();
+		assert_eq!(permit_three.num_ops, 1);
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/subscription/mod.rs b/substrate/client/rpc-spec-v2/src/chain_head/subscription/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b25b1a4913b49f52035b17190f77df99f701c504
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/subscription/mod.rs
@@ -0,0 +1,137 @@
+// 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 parking_lot::RwLock;
+use sc_client_api::Backend;
+use sp_runtime::traits::Block as BlockT;
+use std::{sync::Arc, time::Duration};
+
+mod error;
+mod inner;
+
+use self::inner::SubscriptionsInner;
+
+pub use self::inner::OperationState;
+pub use error::SubscriptionManagementError;
+pub use inner::{BlockGuard, InsertedSubscriptionData};
+
+/// Manage block pinning / unpinning for subscription IDs.
+pub struct SubscriptionManagement<Block: BlockT, BE: Backend<Block>> {
+	/// Manage subscription by mapping the subscription ID
+	/// to a set of block hashes.
+	inner: RwLock<SubscriptionsInner<Block, BE>>,
+}
+
+impl<Block: BlockT, BE: Backend<Block>> SubscriptionManagement<Block, BE> {
+	/// Construct a new [`SubscriptionManagement`].
+	pub fn new(
+		global_max_pinned_blocks: usize,
+		local_max_pin_duration: Duration,
+		max_ongoing_operations: usize,
+		backend: Arc<BE>,
+	) -> Self {
+		SubscriptionManagement {
+			inner: RwLock::new(SubscriptionsInner::new(
+				global_max_pinned_blocks,
+				local_max_pin_duration,
+				max_ongoing_operations,
+				backend,
+			)),
+		}
+	}
+
+	/// Insert a new subscription ID.
+	///
+	/// If the subscription was not previously inserted, returns the receiver that is
+	/// triggered upon the "Stop" event. Otherwise, if the subscription ID was already
+	/// inserted returns none.
+	pub fn insert_subscription(
+		&self,
+		sub_id: String,
+		runtime_updates: bool,
+	) -> Option<InsertedSubscriptionData<Block>> {
+		let mut inner = self.inner.write();
+		inner.insert_subscription(sub_id, runtime_updates)
+	}
+
+	/// Remove the subscription ID with associated pinned blocks.
+	pub fn remove_subscription(&self, sub_id: &str) {
+		let mut inner = self.inner.write();
+		inner.remove_subscription(sub_id)
+	}
+
+	/// The block is pinned in the backend only once when the block's hash is first encountered.
+	///
+	/// Each subscription is expected to call this method twice:
+	/// - once from the `NewBlock` import
+	/// - once from the `Finalized` import
+	///
+	/// Returns
+	/// - Ok(true) if the subscription did not previously contain this block
+	/// - Ok(false) if the subscription already contained this this
+	/// - Error if the backend failed to pin the block or the subscription ID is invalid
+	pub fn pin_block(
+		&self,
+		sub_id: &str,
+		hash: Block::Hash,
+	) -> Result<bool, SubscriptionManagementError> {
+		let mut inner = self.inner.write();
+		inner.pin_block(sub_id, hash)
+	}
+
+	/// Unpin the block from the subscription.
+	///
+	/// The last subscription that unpins the block is also unpinning the block
+	/// from the backend.
+	///
+	/// This method is called only once per subscription.
+	///
+	/// Returns an error if the block is not pinned for the subscription or
+	/// the subscription ID is invalid.
+	pub fn unpin_block(
+		&self,
+		sub_id: &str,
+		hash: Block::Hash,
+	) -> Result<(), SubscriptionManagementError> {
+		let mut inner = self.inner.write();
+		inner.unpin_block(sub_id, hash)
+	}
+
+	/// Ensure the block remains pinned until the return object is dropped.
+	///
+	/// Returns a [`BlockGuard`] that pins and unpins the block hash in RAII manner
+	/// and reserves capacity for ogoing operations.
+	///
+	/// Returns an error if the block hash is not pinned for the subscription,
+	/// the subscription ID is invalid or the limit of ongoing operations was exceeded.
+	pub fn lock_block(
+		&self,
+		sub_id: &str,
+		hash: Block::Hash,
+		to_reserve: usize,
+	) -> Result<BlockGuard<Block, BE>, SubscriptionManagementError> {
+		let mut inner = self.inner.write();
+		inner.lock_block(sub_id, hash, to_reserve)
+	}
+
+	/// Get the operation state.
+	pub fn get_operation(&self, sub_id: &str, operation_id: &str) -> Option<OperationState> {
+		let mut inner = self.inner.write();
+		inner.get_operation(sub_id, operation_id)
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/test_utils.rs b/substrate/client/rpc-spec-v2/src/chain_head/test_utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6e92e87608b44abab9a4133e456e4f4f7272819c
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/test_utils.rs
@@ -0,0 +1,325 @@
+// 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 parking_lot::Mutex;
+use sc_client_api::{
+	execution_extensions::ExecutionExtensions, BlockBackend, BlockImportNotification,
+	BlockchainEvents, CallExecutor, ChildInfo, ExecutorProvider, FinalityNotification,
+	FinalityNotifications, FinalizeSummary, ImportNotifications, KeysIter, PairsIter, StorageData,
+	StorageEventStream, StorageKey, StorageProvider,
+};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
+use sp_api::{CallApiAt, CallApiAtParams, NumberFor, RuntimeVersion};
+use sp_blockchain::{BlockStatus, CachedHeaderMetadata, HeaderBackend, HeaderMetadata, Info};
+use sp_consensus::BlockOrigin;
+use sp_runtime::{
+	generic::SignedBlock,
+	traits::{Block as BlockT, Header as HeaderT},
+	Justifications,
+};
+use std::sync::Arc;
+use substrate_test_runtime::{Block, Hash, Header};
+
+pub struct ChainHeadMockClient<Client> {
+	client: Arc<Client>,
+	import_sinks: Mutex<Vec<TracingUnboundedSender<BlockImportNotification<Block>>>>,
+	finality_sinks: Mutex<Vec<TracingUnboundedSender<FinalityNotification<Block>>>>,
+}
+
+impl<Client> ChainHeadMockClient<Client> {
+	pub fn new(client: Arc<Client>) -> Self {
+		ChainHeadMockClient {
+			client,
+			import_sinks: Default::default(),
+			finality_sinks: Default::default(),
+		}
+	}
+
+	pub async fn trigger_import_stream(&self, header: Header) {
+		// Ensure the client called the `import_notification_stream`.
+		while self.import_sinks.lock().is_empty() {
+			tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+		}
+
+		// Build the notification.
+		let (sink, _stream) = tracing_unbounded("test_sink", 100_000);
+		let notification =
+			BlockImportNotification::new(header.hash(), BlockOrigin::Own, header, true, None, sink);
+
+		for sink in self.import_sinks.lock().iter_mut() {
+			sink.unbounded_send(notification.clone()).unwrap();
+		}
+	}
+
+	pub async fn trigger_finality_stream(&self, header: Header) {
+		// Ensure the client called the `finality_notification_stream`.
+		while self.finality_sinks.lock().is_empty() {
+			tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+		}
+
+		// Build the notification.
+		let (sink, _stream) = tracing_unbounded("test_sink", 100_000);
+		let summary = FinalizeSummary {
+			header: header.clone(),
+			finalized: vec![header.hash()],
+			stale_heads: vec![],
+		};
+		let notification = FinalityNotification::from_summary(summary, sink);
+
+		for sink in self.finality_sinks.lock().iter_mut() {
+			sink.unbounded_send(notification.clone()).unwrap();
+		}
+	}
+}
+
+// ChainHead calls `import_notification_stream` and `finality_notification_stream` in order to
+// subscribe to block events.
+impl<Client> BlockchainEvents<Block> for ChainHeadMockClient<Client> {
+	fn import_notification_stream(&self) -> ImportNotifications<Block> {
+		let (sink, stream) = tracing_unbounded("import_notification_stream", 1024);
+		self.import_sinks.lock().push(sink);
+		stream
+	}
+
+	fn every_import_notification_stream(&self) -> ImportNotifications<Block> {
+		unimplemented!()
+	}
+
+	fn finality_notification_stream(&self) -> FinalityNotifications<Block> {
+		let (sink, stream) = tracing_unbounded("finality_notification_stream", 1024);
+		self.finality_sinks.lock().push(sink);
+		stream
+	}
+
+	fn storage_changes_notification_stream(
+		&self,
+		_filter_keys: Option<&[StorageKey]>,
+		_child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+	) -> sp_blockchain::Result<StorageEventStream<Hash>> {
+		unimplemented!()
+	}
+}
+
+// The following implementations are imposed by the `chainHead` trait bounds.
+
+impl<Block: BlockT, E: CallExecutor<Block>, Client: ExecutorProvider<Block, Executor = E>>
+	ExecutorProvider<Block> for ChainHeadMockClient<Client>
+{
+	type Executor = <Client as ExecutorProvider<Block>>::Executor;
+
+	fn executor(&self) -> &Self::Executor {
+		self.client.executor()
+	}
+
+	fn execution_extensions(&self) -> &ExecutionExtensions<Block> {
+		self.client.execution_extensions()
+	}
+}
+
+impl<
+		BE: sc_client_api::backend::Backend<Block> + Send + Sync + 'static,
+		Block: BlockT,
+		Client: StorageProvider<Block, BE>,
+	> StorageProvider<Block, BE> for ChainHeadMockClient<Client>
+{
+	fn storage(
+		&self,
+		hash: Block::Hash,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<StorageData>> {
+		self.client.storage(hash, key)
+	}
+
+	fn storage_hash(
+		&self,
+		hash: Block::Hash,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.client.storage_hash(hash, key)
+	}
+
+	fn storage_keys(
+		&self,
+		hash: Block::Hash,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<KeysIter<BE::State, Block>> {
+		self.client.storage_keys(hash, prefix, start_key)
+	}
+
+	fn storage_pairs(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<PairsIter<BE::State, Block>> {
+		self.client.storage_pairs(hash, prefix, start_key)
+	}
+
+	fn child_storage(
+		&self,
+		hash: Block::Hash,
+		child_info: &ChildInfo,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<StorageData>> {
+		self.client.child_storage(hash, child_info, key)
+	}
+
+	fn child_storage_keys(
+		&self,
+		hash: Block::Hash,
+		child_info: ChildInfo,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<KeysIter<BE::State, Block>> {
+		self.client.child_storage_keys(hash, child_info, prefix, start_key)
+	}
+
+	fn child_storage_hash(
+		&self,
+		hash: Block::Hash,
+		child_info: &ChildInfo,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.client.child_storage_hash(hash, child_info, key)
+	}
+}
+
+impl<Block: BlockT, Client: CallApiAt<Block>> CallApiAt<Block> for ChainHeadMockClient<Client> {
+	type StateBackend = <Client as CallApiAt<Block>>::StateBackend;
+
+	fn call_api_at(&self, params: CallApiAtParams<Block>) -> Result<Vec<u8>, sp_api::ApiError> {
+		self.client.call_api_at(params)
+	}
+
+	fn runtime_version_at(&self, hash: Block::Hash) -> Result<RuntimeVersion, sp_api::ApiError> {
+		self.client.runtime_version_at(hash)
+	}
+
+	fn state_at(&self, at: Block::Hash) -> Result<Self::StateBackend, sp_api::ApiError> {
+		self.client.state_at(at)
+	}
+
+	fn initialize_extensions(
+		&self,
+		at: <Block as BlockT>::Hash,
+		extensions: &mut sp_api::Extensions,
+	) -> Result<(), sp_api::ApiError> {
+		self.client.initialize_extensions(at, extensions)
+	}
+}
+
+impl<Block: BlockT, Client: BlockBackend<Block>> BlockBackend<Block>
+	for ChainHeadMockClient<Client>
+{
+	fn block_body(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
+		self.client.block_body(hash)
+	}
+
+	fn block(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<SignedBlock<Block>>> {
+		self.client.block(hash)
+	}
+
+	fn block_status(&self, hash: Block::Hash) -> sp_blockchain::Result<sp_consensus::BlockStatus> {
+		self.client.block_status(hash)
+	}
+
+	fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
+		self.client.justifications(hash)
+	}
+
+	fn block_hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.client.block_hash(number)
+	}
+
+	fn indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		self.client.indexed_transaction(hash)
+	}
+
+	fn has_indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<bool> {
+		self.client.has_indexed_transaction(hash)
+	}
+
+	fn block_indexed_body(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>> {
+		self.client.block_indexed_body(hash)
+	}
+	fn requires_full_sync(&self) -> bool {
+		self.client.requires_full_sync()
+	}
+}
+
+impl<Block: BlockT, Client: HeaderMetadata<Block> + Send + Sync> HeaderMetadata<Block>
+	for ChainHeadMockClient<Client>
+{
+	type Error = <Client as HeaderMetadata<Block>>::Error;
+
+	fn header_metadata(
+		&self,
+		hash: Block::Hash,
+	) -> Result<CachedHeaderMetadata<Block>, Self::Error> {
+		self.client.header_metadata(hash)
+	}
+
+	fn insert_header_metadata(
+		&self,
+		hash: Block::Hash,
+		header_metadata: CachedHeaderMetadata<Block>,
+	) {
+		self.client.insert_header_metadata(hash, header_metadata)
+	}
+
+	fn remove_header_metadata(&self, hash: Block::Hash) {
+		self.client.remove_header_metadata(hash)
+	}
+}
+
+impl<Block: BlockT, Client: HeaderBackend<Block> + Send + Sync> HeaderBackend<Block>
+	for ChainHeadMockClient<Client>
+{
+	fn header(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<<Block as BlockT>::Header>> {
+		self.client.header(hash)
+	}
+
+	fn info(&self) -> Info<Block> {
+		self.client.info()
+	}
+
+	fn status(&self, hash: Block::Hash) -> sc_client_api::blockchain::Result<BlockStatus> {
+		self.client.status(hash)
+	}
+
+	fn number(
+		&self,
+		hash: Block::Hash,
+	) -> sc_client_api::blockchain::Result<Option<<<Block as BlockT>::Header as HeaderT>::Number>> {
+		self.client.number(hash)
+	}
+
+	fn hash(
+		&self,
+		number: <<Block as BlockT>::Header as HeaderT>::Number,
+	) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.client.hash(number)
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_head/tests.rs b/substrate/client/rpc-spec-v2/src/chain_head/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..00ed9089058eeb2b364d84b9722ae6d97728d1e9
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_head/tests.rs
@@ -0,0 +1,2567 @@
+use crate::chain_head::{
+	event::{MethodResponse, StorageQuery, StorageQueryType, StorageResultType},
+	test_utils::ChainHeadMockClient,
+};
+
+use super::*;
+use assert_matches::assert_matches;
+use codec::{Decode, Encode};
+use futures::Future;
+use jsonrpsee::{
+	core::{error::Error, server::rpc_module::Subscription as RpcSubscription},
+	rpc_params,
+	types::{error::CallError, EmptyServerParams as EmptyParams},
+	RpcModule,
+};
+use sc_block_builder::BlockBuilderProvider;
+use sc_client_api::ChildInfo;
+use sc_service::client::new_in_mem;
+use sp_api::BlockT;
+use sp_blockchain::HeaderBackend;
+use sp_consensus::BlockOrigin;
+use sp_core::{
+	storage::well_known_keys::{self, CODE},
+	testing::TaskExecutor,
+	Blake2Hasher, Hasher,
+};
+use sp_version::RuntimeVersion;
+use std::{collections::HashSet, fmt::Debug, sync::Arc, time::Duration};
+use substrate_test_runtime::Transfer;
+use substrate_test_runtime_client::{
+	prelude::*, runtime, runtime::RuntimeApi, Backend, BlockBuilderExt, Client,
+	ClientBlockImportExt, GenesisInit,
+};
+
+type Header = substrate_test_runtime_client::runtime::Header;
+type Block = substrate_test_runtime_client::runtime::Block;
+const MAX_PINNED_BLOCKS: usize = 32;
+const MAX_PINNED_SECS: u64 = 60;
+const MAX_OPERATIONS: usize = 16;
+const MAX_PAGINATION_LIMIT: usize = 5;
+const CHAIN_GENESIS: [u8; 32] = [0; 32];
+const INVALID_HASH: [u8; 32] = [1; 32];
+const KEY: &[u8] = b":mock";
+const VALUE: &[u8] = b"hello world";
+const CHILD_STORAGE_KEY: &[u8] = b"child";
+const CHILD_VALUE: &[u8] = b"child value";
+const DOES_NOT_PRODUCE_EVENTS_SECONDS: u64 = 10;
+
+async fn get_next_event<T: serde::de::DeserializeOwned>(sub: &mut RpcSubscription) -> T {
+	let (event, _sub_id) = tokio::time::timeout(std::time::Duration::from_secs(60), sub.next())
+		.await
+		.unwrap()
+		.unwrap()
+		.unwrap();
+	event
+}
+
+async fn does_not_produce_event<T: serde::de::DeserializeOwned + Debug>(
+	sub: &mut RpcSubscription,
+	duration: std::time::Duration,
+) {
+	tokio::time::timeout(duration, sub.next::<T>()).await.unwrap_err();
+}
+
+async fn run_with_timeout<F: Future>(future: F) -> <F as Future>::Output {
+	tokio::time::timeout(std::time::Duration::from_secs(60 * 10), future)
+		.await
+		.unwrap()
+}
+
+async fn setup_api() -> (
+	Arc<Client<Backend>>,
+	RpcModule<ChainHead<Backend, Block, Client<Backend>>>,
+	RpcSubscription,
+	String,
+	Block,
+) {
+	let child_info = ChildInfo::new_default(CHILD_STORAGE_KEY);
+	let builder = TestClientBuilder::new().add_extra_child_storage(
+		&child_info,
+		KEY.to_vec(),
+		CHILD_VALUE.to_vec(),
+	);
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [true]).await.unwrap();
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	(client, api, sub, sub_id, block)
+}
+
+#[tokio::test]
+async fn follow_subscription_produces_blocks() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let finalized_hash = client.info().finalized_hash;
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+
+	// Initialized must always be reported first.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Initialized(Initialized {
+		finalized_block_hash: format!("{:?}", finalized_hash),
+		finalized_block_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+
+	let best_hash = block.header.hash();
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", best_hash),
+		parent_block_hash: format!("{:?}", finalized_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", best_hash),
+	});
+	assert_eq!(event, expected);
+
+	client.finalize_block(best_hash, None).unwrap();
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![format!("{:?}", best_hash)],
+		pruned_block_hashes: vec![],
+	});
+	assert_eq!(event, expected);
+}
+
+#[tokio::test]
+async fn follow_with_runtime() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let finalized_hash = client.info().finalized_hash;
+	let mut sub = api.subscribe("chainHead_unstable_follow", [true]).await.unwrap();
+
+	// Initialized must always be reported first.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+
+	// it is basically json-encoded substrate_test_runtime_client::runtime::VERSION
+	let runtime_str = "{\"specName\":\"test\",\"implName\":\"parity-test\",\"authoringVersion\":1,\
+		\"specVersion\":2,\"implVersion\":2,\"apis\":[[\"0xdf6acb689907609b\",4],\
+		[\"0x37e397fc7c91f5e4\",2],[\"0xd2bc9897eed08f15\",3],[\"0x40fe3ad401f8959a\",6],\
+		[\"0xbc9d89904f5b923f\",1],[\"0xc6e9a76309f39b09\",2],[\"0xdd718d5cc53262d4\",1],\
+		[\"0xcbca25e39f142387\",2],[\"0xf78b278be53f454c\",2],[\"0xab3c0572291feb8b\",1],\
+		[\"0xed99c5acb25eedf5\",3],[\"0xfbc577b9d747efd6\",1]],\"transactionVersion\":1,\"stateVersion\":1}";
+
+	let runtime: RuntimeVersion = serde_json::from_str(runtime_str).unwrap();
+
+	let finalized_block_runtime =
+		Some(RuntimeEvent::Valid(RuntimeVersionEvent { spec: runtime.clone() }));
+	// Runtime must always be reported with the first event.
+	let expected = FollowEvent::Initialized(Initialized {
+		finalized_block_hash: format!("{:?}", finalized_hash),
+		finalized_block_runtime,
+		with_runtime: false,
+	});
+	pretty_assertions::assert_eq!(event, expected);
+
+	// Import a new block without runtime changes.
+	// The runtime field must be None in this case.
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let best_hash = block.header.hash();
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", best_hash),
+		parent_block_hash: format!("{:?}", finalized_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", best_hash),
+	});
+	assert_eq!(event, expected);
+
+	client.finalize_block(best_hash, None).unwrap();
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![format!("{:?}", best_hash)],
+		pruned_block_hashes: vec![],
+	});
+	assert_eq!(event, expected);
+
+	let finalized_hash = best_hash;
+	// The `RuntimeVersion` is embedded into the WASM blob at the `runtime_version`
+	// section. Modify the `RuntimeVersion` and commit the changes to a new block.
+	// The RPC must notify the runtime event change.
+	let wasm = sp_maybe_compressed_blob::decompress(
+		runtime::wasm_binary_unwrap(),
+		sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT,
+	)
+	.unwrap();
+	// Update the runtime spec version.
+	let mut runtime = runtime;
+	runtime.spec_version += 1;
+	let embedded = sp_version::embed::embed_runtime_version(&wasm, runtime.clone()).unwrap();
+	let wasm = sp_maybe_compressed_blob::compress(
+		&embedded,
+		sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT,
+	)
+	.unwrap();
+
+	let mut builder = client.new_block(Default::default()).unwrap();
+	builder.push_storage_change(CODE.to_vec(), Some(wasm)).unwrap();
+	let block = builder.build().unwrap().block;
+	let best_hash = block.header.hash();
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	let new_runtime = Some(RuntimeEvent::Valid(RuntimeVersionEvent { spec: runtime.clone() }));
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", best_hash),
+		parent_block_hash: format!("{:?}", finalized_hash),
+		new_runtime,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+}
+
+#[tokio::test]
+async fn get_genesis() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let genesis: String =
+		api.call("chainHead_unstable_genesisHash", EmptyParams::new()).await.unwrap();
+	assert_eq!(genesis, hex_string(&CHAIN_GENESIS));
+}
+
+#[tokio::test]
+async fn get_header() {
+	let (_client, api, _sub, sub_id, block) = setup_api().await;
+	let block_hash = format!("{:?}", block.header.hash());
+	let invalid_hash = hex_string(&INVALID_HASH);
+
+	// Invalid subscription ID must produce no results.
+	let res: Option<String> = api
+		.call("chainHead_unstable_header", ["invalid_sub_id", &invalid_hash])
+		.await
+		.unwrap();
+	assert!(res.is_none());
+
+	// Valid subscription with invalid block hash will error.
+	let err = api
+		.call::<_, serde_json::Value>("chainHead_unstable_header", [&sub_id, &invalid_hash])
+		.await
+		.unwrap_err();
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2001 && err.message() == "Invalid block hash"
+	);
+
+	// Obtain the valid header.
+	let res: String = api.call("chainHead_unstable_header", [&sub_id, &block_hash]).await.unwrap();
+	let bytes = array_bytes::hex2bytes(&res).unwrap();
+	let header: Header = Decode::decode(&mut &bytes[..]).unwrap();
+	assert_eq!(header, block.header);
+}
+
+#[tokio::test]
+async fn get_body() {
+	let (mut client, api, mut block_sub, sub_id, block) = setup_api().await;
+	let block_hash = format!("{:?}", block.header.hash());
+	let invalid_hash = hex_string(&INVALID_HASH);
+
+	// Subscription ID is invalid.
+	let response: MethodResponse = api
+		.call("chainHead_unstable_body", ["invalid_sub_id", &invalid_hash])
+		.await
+		.unwrap();
+	assert_matches!(response, MethodResponse::LimitReached);
+
+	// Block hash is invalid.
+	let err = api
+		.call::<_, serde_json::Value>("chainHead_unstable_body", [&sub_id, &invalid_hash])
+		.await
+		.unwrap_err();
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2001 && err.message() == "Invalid block hash"
+	);
+
+	// Valid call.
+	let response: MethodResponse =
+		api.call("chainHead_unstable_body", [&sub_id, &block_hash]).await.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	// Response propagated to `chainHead_follow`.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationBodyDone(done) if done.operation_id == operation_id && done.value.is_empty()
+	);
+
+	// Import a block with extrinsics.
+	let mut builder = client.new_block(Default::default()).unwrap();
+	builder
+		.push_transfer(runtime::Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 42,
+			nonce: 0,
+		})
+		.unwrap();
+	let block = builder.build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Valid call to a block with extrinsics.
+	let response: MethodResponse =
+		api.call("chainHead_unstable_body", [&sub_id, &block_hash]).await.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	// Response propagated to `chainHead_follow`.
+	let expected_tx = hex_string(&block.extrinsics[0].encode());
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationBodyDone(done) if done.operation_id == operation_id && done.value == vec![expected_tx]
+	);
+}
+
+#[tokio::test]
+async fn call_runtime() {
+	let (_client, api, mut block_sub, sub_id, block) = setup_api().await;
+	let block_hash = format!("{:?}", block.header.hash());
+	let invalid_hash = hex_string(&INVALID_HASH);
+
+	// Subscription ID is invalid.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_call",
+			["invalid_sub_id", &block_hash, "BabeApi_current_epoch", "0x00"],
+		)
+		.await
+		.unwrap();
+	assert_matches!(response, MethodResponse::LimitReached);
+
+	// Block hash is invalid.
+	let err = api
+		.call::<_, serde_json::Value>(
+			"chainHead_unstable_call",
+			[&sub_id, &invalid_hash, "BabeApi_current_epoch", "0x00"],
+		)
+		.await
+		.unwrap_err();
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2001 && err.message() == "Invalid block hash"
+	);
+
+	// Pass an invalid parameters that cannot be decode.
+	let err = api
+		.call::<_, serde_json::Value>(
+			"chainHead_unstable_call",
+			// 0x0 is invalid.
+			[&sub_id, &block_hash, "BabeApi_current_epoch", "0x0"],
+		)
+		.await
+		.unwrap_err();
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2003 && err.message().contains("Invalid parameter")
+	);
+
+	// Valid call.
+	let alice_id = AccountKeyring::Alice.to_account_id();
+	// Hex encoded scale encoded bytes representing the call parameters.
+	let call_parameters = hex_string(&alice_id.encode());
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_call",
+			[&sub_id, &block_hash, "AccountNonceApi_account_nonce", &call_parameters],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	// Response propagated to `chainHead_follow`.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationCallDone(done) if done.operation_id == operation_id && done.output == "0x0000000000000000"
+	);
+
+	// The `current_epoch` takes no parameters and not draining the input buffer
+	// will cause the execution to fail.
+	let response: MethodResponse = api
+		.call("chainHead_unstable_call", [&sub_id, &block_hash, "BabeApi_current_epoch", "0x00"])
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	// Error propagated to `chainHead_follow`.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationError(error) if error.operation_id == operation_id && error.error.contains("Execution failed")
+	);
+}
+
+#[tokio::test]
+async fn call_runtime_without_flag() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Valid runtime call on a subscription started with `with_runtime` false.
+	let alice_id = AccountKeyring::Alice.to_account_id();
+	let call_parameters = hex_string(&alice_id.encode());
+	let err = api
+		.call::<_, serde_json::Value>(
+			"chainHead_unstable_call",
+			[&sub_id, &block_hash, "AccountNonceApi_account_nonce", &call_parameters],
+		)
+		.await
+		.unwrap_err();
+
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2003 && err.message().contains("The runtime updates flag must be set")
+	);
+}
+
+#[tokio::test]
+async fn get_storage_hash() {
+	let (mut client, api, mut block_sub, sub_id, block) = setup_api().await;
+	let block_hash = format!("{:?}", block.header.hash());
+	let invalid_hash = hex_string(&INVALID_HASH);
+	let key = hex_string(&KEY);
+
+	// Subscription ID is invalid.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				"invalid_sub_id",
+				&invalid_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Hash }]
+			],
+		)
+		.await
+		.unwrap();
+	assert_matches!(response, MethodResponse::LimitReached);
+
+	// Block hash is invalid.
+	let err = api
+		.call::<_, serde_json::Value>(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&invalid_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Hash }]
+			],
+		)
+		.await
+		.unwrap_err();
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2001 && err.message() == "Invalid block hash"
+	);
+
+	// Valid call without storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Hash }]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// The `Done` event is generated directly since the key does not have any value associated.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Import a new block with storage changes.
+	let mut builder = client.new_block(Default::default()).unwrap();
+	builder.push_storage_change(KEY.to_vec(), Some(VALUE.to_vec())).unwrap();
+	let block = builder.build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Valid call with storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Hash }]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	let expected_hash = format!("{:?}", Blake2Hasher::hash(&VALUE));
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+				res.items.len() == 1 &&
+				res.items[0].key == key && res.items[0].result == StorageResultType::Hash(expected_hash)
+	);
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Child value set in `setup_api`.
+	let child_info = hex_string(&CHILD_STORAGE_KEY);
+	let genesis_hash = format!("{:?}", client.genesis_hash());
+
+	// Valid call with storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&genesis_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Hash }],
+				&child_info
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	let expected_hash = format!("{:?}", Blake2Hasher::hash(&CHILD_VALUE));
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+				res.items.len() == 1 &&
+				res.items[0].key == key && res.items[0].result == StorageResultType::Hash(expected_hash)
+	);
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+}
+
+#[tokio::test]
+async fn get_storage_multi_query_iter() {
+	let (mut client, api, mut block_sub, sub_id, _) = setup_api().await;
+	let key = hex_string(&KEY);
+
+	// Import a new block with storage changes.
+	let mut builder = client.new_block(Default::default()).unwrap();
+	builder.push_storage_change(KEY.to_vec(), Some(VALUE.to_vec())).unwrap();
+	let block = builder.build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Valid call with storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![
+					StorageQuery {
+						key: key.clone(),
+						query_type: StorageQueryType::DescendantsHashes
+					},
+					StorageQuery {
+						key: key.clone(),
+						query_type: StorageQueryType::DescendantsValues
+					}
+				]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	let expected_hash = format!("{:?}", Blake2Hasher::hash(&VALUE));
+	let expected_value = hex_string(&VALUE);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == key &&
+			res.items[0].result == StorageResultType::Hash(expected_hash)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == key &&
+			res.items[0].result == StorageResultType::Value(expected_value)
+	);
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Child value set in `setup_api`.
+	let child_info = hex_string(&CHILD_STORAGE_KEY);
+	let genesis_hash = format!("{:?}", client.genesis_hash());
+	let expected_hash = format!("{:?}", Blake2Hasher::hash(&CHILD_VALUE));
+	let expected_value = hex_string(&CHILD_VALUE);
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&genesis_hash,
+				vec![
+					StorageQuery {
+						key: key.clone(),
+						query_type: StorageQueryType::DescendantsHashes
+					},
+					StorageQuery {
+						key: key.clone(),
+						query_type: StorageQueryType::DescendantsValues
+					}
+				],
+				&child_info
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == key &&
+			res.items[0].result == StorageResultType::Hash(expected_hash)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == key &&
+			res.items[0].result == StorageResultType::Value(expected_value)
+	);
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+}
+
+#[tokio::test]
+async fn get_storage_value() {
+	let (mut client, api, mut block_sub, sub_id, block) = setup_api().await;
+	let block_hash = format!("{:?}", block.header.hash());
+	let invalid_hash = hex_string(&INVALID_HASH);
+	let key = hex_string(&KEY);
+
+	// Subscription ID is invalid.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				"invalid_sub_id",
+				&invalid_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Value }]
+			],
+		)
+		.await
+		.unwrap();
+	assert_matches!(response, MethodResponse::LimitReached);
+
+	// Block hash is invalid.
+	let err = api
+		.call::<_, serde_json::Value>(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&invalid_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Value }]
+			],
+		)
+		.await
+		.unwrap_err();
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2001 && err.message() == "Invalid block hash"
+	);
+
+	// Valid call without storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Value }]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// The `Done` event is generated directly since the key does not have any value associated.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Import a new block with storage changes.
+	let mut builder = client.new_block(Default::default()).unwrap();
+	builder.push_storage_change(KEY.to_vec(), Some(VALUE.to_vec())).unwrap();
+	let block = builder.build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Valid call with storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Value }]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	let expected_value = hex_string(&VALUE);
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+				res.items.len() == 1 &&
+				res.items[0].key == key && res.items[0].result == StorageResultType::Value(expected_value)
+	);
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Child value set in `setup_api`.
+	let child_info = hex_string(&CHILD_STORAGE_KEY);
+	let genesis_hash = format!("{:?}", client.genesis_hash());
+
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&genesis_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Value }],
+				&child_info
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	let expected_value = hex_string(&CHILD_VALUE);
+
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+				res.items.len() == 1 &&
+				res.items[0].key == key && res.items[0].result == StorageResultType::Value(expected_value)
+	);
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+}
+
+#[tokio::test]
+async fn get_storage_non_queryable_key() {
+	let (mut _client, api, mut block_sub, sub_id, block) = setup_api().await;
+	let block_hash = format!("{:?}", block.header.hash());
+	let key = hex_string(&KEY);
+
+	// Key is prefixed by CHILD_STORAGE_KEY_PREFIX.
+	let mut prefixed_key = well_known_keys::CHILD_STORAGE_KEY_PREFIX.to_vec();
+	prefixed_key.extend_from_slice(&KEY);
+	let prefixed_key = hex_string(&prefixed_key);
+
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key: prefixed_key, query_type: StorageQueryType::Value }]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// The `Done` event is generated directly since the key is not queryable.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Key is prefixed by DEFAULT_CHILD_STORAGE_KEY_PREFIX.
+	let mut prefixed_key = well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX.to_vec();
+	prefixed_key.extend_from_slice(&KEY);
+	let prefixed_key = hex_string(&prefixed_key);
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key: prefixed_key, query_type: StorageQueryType::Value }]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// The `Done` event is generated directly since the key is not queryable.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Child key is prefixed by CHILD_STORAGE_KEY_PREFIX.
+	let mut prefixed_key = well_known_keys::CHILD_STORAGE_KEY_PREFIX.to_vec();
+	prefixed_key.extend_from_slice(CHILD_STORAGE_KEY);
+	let prefixed_key = hex_string(&prefixed_key);
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Value }],
+				&prefixed_key
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// The `Done` event is generated directly since the key is not queryable.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// Child key is prefixed by DEFAULT_CHILD_STORAGE_KEY_PREFIX.
+	let mut prefixed_key = well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX.to_vec();
+	prefixed_key.extend_from_slice(CHILD_STORAGE_KEY);
+	let prefixed_key = hex_string(&prefixed_key);
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery { key, query_type: StorageQueryType::Value }],
+				&prefixed_key
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// The `Done` event is generated directly since the key is not queryable.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+}
+
+#[tokio::test]
+async fn unique_operation_ids() {
+	let (mut _client, api, mut block_sub, sub_id, block) = setup_api().await;
+	let block_hash = format!("{:?}", block.header.hash());
+
+	let mut op_ids = HashSet::new();
+
+	// Ensure that operation IDs are unique for multiple method calls.
+	for _ in 0..5 {
+		// Valid `chainHead_unstable_body` call.
+		let response: MethodResponse =
+			api.call("chainHead_unstable_body", [&sub_id, &block_hash]).await.unwrap();
+		let operation_id = match response {
+			MethodResponse::Started(started) => started.operation_id,
+			MethodResponse::LimitReached => panic!("Expected started response"),
+		};
+		assert_matches!(
+				get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+				FollowEvent::OperationBodyDone(done) if done.operation_id == operation_id && done.value.is_empty()
+		);
+		// Ensure uniqueness.
+		assert!(op_ids.insert(operation_id));
+
+		// Valid `chainHead_unstable_storage` call.
+		let key = hex_string(&KEY);
+		let response: MethodResponse = api
+			.call(
+				"chainHead_unstable_storage",
+				rpc_params![
+					&sub_id,
+					&block_hash,
+					vec![StorageQuery { key: key.clone(), query_type: StorageQueryType::Value }]
+				],
+			)
+			.await
+			.unwrap();
+		let operation_id = match response {
+			MethodResponse::Started(started) => started.operation_id,
+			MethodResponse::LimitReached => panic!("Expected started response"),
+		};
+		// The `Done` event is generated directly since the key does not have any value associated.
+		assert_matches!(
+				get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+				FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+		);
+		// Ensure uniqueness.
+		assert!(op_ids.insert(operation_id));
+
+		// Valid `chainHead_unstable_call` call.
+		let alice_id = AccountKeyring::Alice.to_account_id();
+		let call_parameters = hex_string(&alice_id.encode());
+		let response: MethodResponse = api
+			.call(
+				"chainHead_unstable_call",
+				[&sub_id, &block_hash, "AccountNonceApi_account_nonce", &call_parameters],
+			)
+			.await
+			.unwrap();
+		let operation_id = match response {
+			MethodResponse::Started(started) => started.operation_id,
+			MethodResponse::LimitReached => panic!("Expected started response"),
+		};
+		// Response propagated to `chainHead_follow`.
+		assert_matches!(
+				get_next_event::<FollowEvent<String>>(&mut block_sub).await,
+				FollowEvent::OperationCallDone(done) if done.operation_id == operation_id && done.output == "0x0000000000000000"
+		);
+		// Ensure uniqueness.
+		assert!(op_ids.insert(operation_id));
+	}
+}
+
+#[tokio::test]
+async fn separate_operation_ids_for_subscriptions() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	// Create two separate subscriptions.
+	let mut sub_first = api.subscribe("chainHead_unstable_follow", [true]).await.unwrap();
+	let sub_id_first = sub_first.subscription_id();
+	let sub_id_first = serde_json::to_string(&sub_id_first).unwrap();
+
+	let mut sub_second = api.subscribe("chainHead_unstable_follow", [true]).await.unwrap();
+	let sub_id_second = sub_second.subscription_id();
+	let sub_id_second = serde_json::to_string(&sub_id_second).unwrap();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+	let block_hash = format!("{:?}", block.header.hash());
+
+	// Ensure the imported block is propagated and pinned.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub_first).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub_first).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub_first).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub_second).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub_second).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub_second).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Each `chainHead_follow` subscription receives a separate operation ID.
+	let response: MethodResponse =
+		api.call("chainHead_unstable_body", [&sub_id_first, &block_hash]).await.unwrap();
+	let operation_id: String = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	assert_eq!(operation_id, "0");
+
+	let response: MethodResponse = api
+		.call("chainHead_unstable_body", [&sub_id_second, &block_hash])
+		.await
+		.unwrap();
+	let operation_id_second: String = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// The second subscription does not increment the operation ID of the first one.
+	assert_eq!(operation_id_second, "0");
+}
+
+#[tokio::test]
+async fn follow_generates_initial_blocks() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let finalized_hash = client.info().finalized_hash;
+
+	// Block tree:
+	// finalized -> block 1 -> block 2 -> block 4
+	//           -> block 1 -> block 3
+	let block_1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_1_hash = block_1.header.hash();
+	client.import(BlockOrigin::Own, block_1.clone()).await.unwrap();
+
+	let block_2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_2_hash = block_2.header.hash();
+	client.import(BlockOrigin::Own, block_2.clone()).await.unwrap();
+
+	let mut block_builder =
+		client.new_block_at(block_1.header.hash(), Default::default(), false).unwrap();
+	// This push is required as otherwise block 3 has the same hash as block 2 and won't get
+	// imported
+	block_builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let block_3 = block_builder.build().unwrap().block;
+	let block_3_hash = block_3.header.hash();
+	client.import(BlockOrigin::Own, block_3.clone()).await.unwrap();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+
+	// Initialized must always be reported first.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Initialized(Initialized {
+		finalized_block_hash: format!("{:?}", finalized_hash),
+		finalized_block_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	// Check block 1.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_1_hash),
+		parent_block_hash: format!("{:?}", finalized_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	// Check block 2.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_2_hash),
+		parent_block_hash: format!("{:?}", block_1_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+	// Check block 3.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_3_hash),
+		parent_block_hash: format!("{:?}", block_1_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_2_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Import block 4.
+	let block_4 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_4_hash = block_4.header.hash();
+	client.import(BlockOrigin::Own, block_4.clone()).await.unwrap();
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_4_hash),
+		parent_block_hash: format!("{:?}", block_2_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_4_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Check the finalized event:
+	//  - blocks 1, 2, 4 from canonical chain are finalized
+	//  - block 3 from the fork is pruned
+	client.finalize_block(block_4_hash, None).unwrap();
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![
+			format!("{:?}", block_1_hash),
+			format!("{:?}", block_2_hash),
+			format!("{:?}", block_4_hash),
+		],
+		pruned_block_hashes: vec![format!("{:?}", block_3_hash)],
+	});
+	assert_eq!(event, expected);
+}
+
+#[tokio::test]
+async fn follow_exceeding_pinned_blocks() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: 2,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Block tree:
+	//   finalized_block -> block -> block2
+	// The first 2 blocks are pinned into the subscription, but the block2 will exceed the limit (2
+	// blocks).
+	let block2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block2.clone()).await.unwrap();
+
+	assert_matches!(get_next_event::<FollowEvent<String>>(&mut sub).await, FollowEvent::Stop);
+
+	// Subscription will not produce any more event for further blocks.
+	let block3 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block3.clone()).await.unwrap();
+
+	assert!(sub.next::<FollowEvent<String>>().await.is_none());
+}
+
+#[tokio::test]
+async fn follow_with_unpin() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: 2,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// Unpin an invalid subscription ID must return Ok(()).
+	let invalid_hash = hex_string(&INVALID_HASH);
+	let _res: () = api
+		.call("chainHead_unstable_unpin", ["invalid_sub_id", &invalid_hash])
+		.await
+		.unwrap();
+
+	// Valid subscription with invalid block hash.
+	let invalid_hash = hex_string(&INVALID_HASH);
+	let err = api
+		.call::<_, serde_json::Value>("chainHead_unstable_unpin", [&sub_id, &invalid_hash])
+		.await
+		.unwrap_err();
+	assert_matches!(err,
+		Error::Call(CallError::Custom(ref err)) if err.code() == 2001 && err.message() == "Invalid block hash"
+	);
+
+	// To not exceed the number of pinned blocks, we need to unpin before the next import.
+	let _res: () = api.call("chainHead_unstable_unpin", [&sub_id, &block_hash]).await.unwrap();
+
+	// Block tree:
+	//   finalized_block -> block -> block2
+	//                      ^ has been unpinned
+	let block2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block2.clone()).await.unwrap();
+
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	let block3 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block3.clone()).await.unwrap();
+
+	assert_matches!(get_next_event::<FollowEvent<String>>(&mut sub).await, FollowEvent::Stop);
+	assert!(sub.next::<FollowEvent<String>>().await.is_none());
+}
+
+#[tokio::test]
+async fn follow_prune_best_block() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let finalized_hash = client.info().finalized_hash;
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+
+	// Initialized must always be reported first.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Initialized(Initialized {
+		finalized_block_hash: format!("{:?}", finalized_hash),
+		finalized_block_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	// Block tree:
+	//
+	// finalized -> block 1 -> block 2
+	//                         ^^^ best block reported
+	//
+	//           -> block 1 -> block 3 -> block 4
+	//                                    ^^^ finalized
+	//
+	// The block 4 is needed on the longest chain because we want the
+	// best block 2 to be reported as pruned. Pruning is happening at
+	// height (N - 1), where N is the finalized block number.
+
+	let block_1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_1_hash = block_1.header.hash();
+	client.import(BlockOrigin::Own, block_1.clone()).await.unwrap();
+
+	let block_3 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_3_hash = block_3.header.hash();
+	client.import(BlockOrigin::Own, block_3.clone()).await.unwrap();
+
+	let block_4 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_4_hash = block_4.header.hash();
+	client.import(BlockOrigin::Own, block_4.clone()).await.unwrap();
+
+	// Import block 2 as best on the fork.
+	let mut block_builder = client.new_block_at(block_1_hash, Default::default(), false).unwrap();
+	// This push is required as otherwise block 3 has the same hash as block 2 and won't get
+	// imported
+	block_builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let block_2 = block_builder.build().unwrap().block;
+	let block_2_hash = block_2.header.hash();
+	client.import_as_best(BlockOrigin::Own, block_2.clone()).await.unwrap();
+
+	// Check block 1.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_1_hash),
+		parent_block_hash: format!("{:?}", finalized_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_1_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Check block 3.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_3_hash),
+		parent_block_hash: format!("{:?}", block_1_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_3_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Check block 4.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_4_hash),
+		parent_block_hash: format!("{:?}", block_3_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_4_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Check block 2, that we imported as custom best.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_2_hash),
+		parent_block_hash: format!("{:?}", block_1_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_2_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Finalize the block 4 from the fork.
+	client.finalize_block(block_4_hash, None).unwrap();
+
+	// Expect to report the best block changed before the finalized event.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_4_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Block 2 must be reported as pruned, even if it was the previous best.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![
+			format!("{:?}", block_1_hash),
+			format!("{:?}", block_3_hash),
+			format!("{:?}", block_4_hash),
+		],
+		pruned_block_hashes: vec![format!("{:?}", block_2_hash)],
+	});
+	assert_eq!(event, expected);
+
+	// Pruned hash can be unpinned.
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+	let hash = format!("{:?}", block_2_hash);
+	let _res: () = api.call("chainHead_unstable_unpin", [&sub_id, &hash]).await.unwrap();
+}
+
+#[tokio::test]
+async fn follow_forks_pruned_block() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	// Block tree before the subscription:
+	//
+	// finalized -> block 1 -> block 2 -> block 3
+	//                                        ^^^ finalized
+	//           -> block 1 -> block 4 -> block 5
+	//
+
+	let block_1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block_1.clone()).await.unwrap();
+
+	let block_2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block_2.clone()).await.unwrap();
+
+	let block_3 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_3_hash = block_3.header.hash();
+	client.import(BlockOrigin::Own, block_3.clone()).await.unwrap();
+
+	// Block 4 with parent Block 1 is not the best imported.
+	let mut block_builder =
+		client.new_block_at(block_1.header.hash(), Default::default(), false).unwrap();
+	// This push is required as otherwise block 4 has the same hash as block 2 and won't get
+	// imported
+	block_builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let block_4 = block_builder.build().unwrap().block;
+	client.import(BlockOrigin::Own, block_4.clone()).await.unwrap();
+
+	let mut block_builder =
+		client.new_block_at(block_4.header.hash(), Default::default(), false).unwrap();
+	block_builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Bob.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let block_5 = block_builder.build().unwrap().block;
+	client.import(BlockOrigin::Own, block_5.clone()).await.unwrap();
+
+	// Block 4 and 5 are not pruned, pruning happens at height (N - 1).
+	client.finalize_block(block_3_hash, None).unwrap();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+
+	// Initialized must always be reported first.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Initialized(Initialized {
+		finalized_block_hash: format!("{:?}", block_3_hash),
+		finalized_block_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	// Block tree:
+	//
+	// finalized -> block 1 -> block 2 -> block 3 -> block 6
+	//                                                  ^^^ finalized
+	//           -> block 1 -> block 4 -> block 5
+	//
+	// Mark block 6 as finalized to force block 4 and 5 to get pruned.
+
+	let block_6 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_6_hash = block_6.header.hash();
+	client.import(BlockOrigin::Own, block_6.clone()).await.unwrap();
+
+	client.finalize_block(block_6_hash, None).unwrap();
+
+	// Check block 6.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_6_hash),
+		parent_block_hash: format!("{:?}", block_3_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_6_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Block 4 and 5 must not be reported as pruned.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![format!("{:?}", block_6_hash)],
+		pruned_block_hashes: vec![],
+	});
+	assert_eq!(event, expected);
+}
+
+#[tokio::test]
+async fn follow_report_multiple_pruned_block() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	// Block tree:
+	//
+	// finalized -> block 1 -> block 2 -> block 3
+	//                                        ^^^ finalized after subscription
+	//           -> block 1 -> block 4 -> block 5
+
+	let finalized_hash = client.info().finalized_hash;
+
+	let block_1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_1_hash = block_1.header.hash();
+	client.import(BlockOrigin::Own, block_1.clone()).await.unwrap();
+
+	let block_2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_2_hash = block_2.header.hash();
+	client.import(BlockOrigin::Own, block_2.clone()).await.unwrap();
+
+	let block_3 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_3_hash = block_3.header.hash();
+	client.import(BlockOrigin::Own, block_3.clone()).await.unwrap();
+
+	// Block 4 with parent Block 1 is not the best imported.
+	let mut block_builder =
+		client.new_block_at(block_1.header.hash(), Default::default(), false).unwrap();
+	// This push is required as otherwise block 4 has the same hash as block 2 and won't get
+	// imported
+	block_builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let block_4 = block_builder.build().unwrap().block;
+	let block_4_hash = block_4.header.hash();
+	client.import(BlockOrigin::Own, block_4.clone()).await.unwrap();
+
+	let mut block_builder =
+		client.new_block_at(block_4.header.hash(), Default::default(), false).unwrap();
+	block_builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Bob.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let block_5 = block_builder.build().unwrap().block;
+	let block_5_hash = block_5.header.hash();
+	client.import(BlockOrigin::Own, block_5.clone()).await.unwrap();
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+
+	// Initialized must always be reported first.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Initialized(Initialized {
+		finalized_block_hash: format!("{:?}", finalized_hash),
+		finalized_block_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_1_hash),
+		parent_block_hash: format!("{:?}", finalized_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_2_hash),
+		parent_block_hash: format!("{:?}", block_1_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_3_hash),
+		parent_block_hash: format!("{:?}", block_2_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	// The fork must also be reported.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_4_hash),
+		parent_block_hash: format!("{:?}", block_1_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_5_hash),
+		parent_block_hash: format!("{:?}", block_4_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	// The best block of the chain must also be reported.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_3_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Block 4 and 5 are not pruned, pruning happens at height (N - 1).
+	client.finalize_block(block_3_hash, None).unwrap();
+
+	// Finalizing block 3 directly will also result in block 1 and 2 being finalized.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![
+			format!("{:?}", block_1_hash),
+			format!("{:?}", block_2_hash),
+			format!("{:?}", block_3_hash),
+		],
+		pruned_block_hashes: vec![],
+	});
+	assert_eq!(event, expected);
+
+	// Block tree:
+	//
+	// finalized -> block 1 -> block 2 -> block 3 -> block 6
+	//                                                  ^^^ finalized
+	//           -> block 1 -> block 4 -> block 5
+	//
+	// Mark block 6 as finalized to force block 4 and 5 to get pruned.
+
+	let block_6 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_6_hash = block_6.header.hash();
+	client.import(BlockOrigin::Own, block_6.clone()).await.unwrap();
+
+	client.finalize_block(block_6_hash, None).unwrap();
+
+	// Check block 6.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_6_hash),
+		parent_block_hash: format!("{:?}", block_3_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_6_hash),
+	});
+	assert_eq!(event, expected);
+
+	// Block 4 and 5 be reported as pruned, not just the stale head (block 5).
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![format!("{:?}", block_6_hash)],
+		pruned_block_hashes: vec![format!("{:?}", block_4_hash), format!("{:?}", block_5_hash)],
+	});
+	assert_eq!(event, expected);
+}
+
+#[tokio::test]
+async fn pin_block_references() {
+	// Manually construct an in-memory backend and client.
+	let backend = Arc::new(sc_client_api::in_mem::Backend::new());
+	let executor = substrate_test_runtime_client::new_native_or_wasm_executor();
+	let client_config = sc_service::ClientConfig::default();
+
+	let genesis_block_builder = sc_service::GenesisBlockBuilder::new(
+		&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
+		!client_config.no_genesis,
+		backend.clone(),
+		executor.clone(),
+	)
+	.unwrap();
+
+	let mut client = Arc::new(
+		new_in_mem::<_, Block, _, RuntimeApi>(
+			backend.clone(),
+			executor,
+			genesis_block_builder,
+			None,
+			None,
+			Box::new(TaskExecutor::new()),
+			client_config,
+		)
+		.unwrap(),
+	);
+
+	let api = ChainHead::new(
+		client.clone(),
+		backend.clone(),
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: 3,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	async fn wait_pinned_references<Block: BlockT>(
+		backend: &Arc<sc_client_api::in_mem::Backend<Block>>,
+		hash: &Block::Hash,
+		target: i64,
+	) {
+		// Retry for at most 2 minutes.
+		let mut retries = 120;
+		while backend.pin_refs(hash).unwrap() != target {
+			if retries == 0 {
+				panic!("Expected target={} pinned references for hash={:?}", target, hash);
+			}
+			retries -= 1;
+
+			tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+		}
+	}
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let hash = block.header.hash();
+	let block_hash = format!("{:?}", hash);
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	// We need to wait a bit for:
+	// 1. `NewBlock` and `BestBlockChanged` notifications to propagate to the chainHead
+	// subscription. (pin_refs == 2)
+	// 2. The chainHead to call `pin_blocks` only once for the `NewBlock`
+	// notification (pin_refs == 3)
+	// 3. Both notifications to go out of scope (pin_refs ==  1 (total 3 - dropped 2)).
+	wait_pinned_references(&backend, &hash, 1).await;
+
+	// To not exceed the number of pinned blocks, we need to unpin before the next import.
+	let _res: () = api.call("chainHead_unstable_unpin", [&sub_id, &block_hash]).await.unwrap();
+
+	// Make sure unpin clears out the reference.
+	let refs = backend.pin_refs(&hash).unwrap();
+	assert_eq!(refs, 0);
+
+	// Add another 2 blocks and make sure we drop the subscription with the blocks pinned.
+	let mut hashes = Vec::new();
+	for _ in 0..2 {
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let hash = block.header.hash();
+		client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+		// Ensure the imported block is propagated for this subscription.
+		assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut sub).await,
+			FollowEvent::NewBlock(_)
+		);
+		assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut sub).await,
+			FollowEvent::BestBlockChanged(_)
+		);
+
+		hashes.push(hash);
+	}
+
+	// Make sure the pin was propagated.
+	for hash in &hashes {
+		wait_pinned_references(&backend, hash, 1).await;
+	}
+
+	// Drop the subscription and expect the pinned blocks to be released.
+	drop(sub);
+	// The `chainHead` detects the subscription was terminated when it tries
+	// to send another block.
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	for hash in &hashes {
+		wait_pinned_references(&backend, &hash, 0).await;
+	}
+}
+
+#[tokio::test]
+async fn follow_finalized_before_new_block() {
+	let builder = TestClientBuilder::new();
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	let client_mock = Arc::new(ChainHeadMockClient::new(client.clone()));
+
+	let api = ChainHead::new(
+		client_mock.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	// Make sure the block is imported for it to be pinned.
+	let block_1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_1_hash = block_1.header.hash();
+	client.import(BlockOrigin::Own, block_1.clone()).await.unwrap();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [false]).await.unwrap();
+
+	// Trigger the `FinalizedNotification` for block 1 before the `BlockImportNotification`, and
+	// expect for the `chainHead` to generate `NewBlock`, `BestBlock` and `Finalized` events.
+
+	// Trigger the Finalized notification before the NewBlock one.
+	run_with_timeout(client_mock.trigger_finality_stream(block_1.header.clone())).await;
+
+	// Initialized must always be reported first.
+	let finalized_hash = client.info().finalized_hash;
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Initialized(Initialized {
+		finalized_block_hash: format!("{:?}", finalized_hash),
+		finalized_block_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	// Block 1 must be reported because we triggered the finalized notification.
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_1_hash),
+		parent_block_hash: format!("{:?}", finalized_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_1_hash),
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::Finalized(Finalized {
+		finalized_block_hashes: vec![format!("{:?}", block_1_hash)],
+		pruned_block_hashes: vec![],
+	});
+	assert_eq!(event, expected);
+
+	let block_2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_2_hash = block_2.header.hash();
+	client.import(BlockOrigin::Own, block_2.clone()).await.unwrap();
+
+	// Triggering the `BlockImportNotification` notification for block 1 should have no effect
+	// on the notification because the events were handled by the `FinalizedNotification`.
+	// Also trigger the `BlockImportNotification` notification for block 2 to ensure
+	// `NewBlock and `BestBlock` events are generated.
+
+	// Trigger NewBlock notification for block 1 and block 2.
+	run_with_timeout(client_mock.trigger_import_stream(block_1.header)).await;
+	run_with_timeout(client_mock.trigger_import_stream(block_2.header)).await;
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::NewBlock(NewBlock {
+		block_hash: format!("{:?}", block_2_hash),
+		parent_block_hash: format!("{:?}", block_1_hash),
+		new_runtime: None,
+		with_runtime: false,
+	});
+	assert_eq!(event, expected);
+
+	let event: FollowEvent<String> = get_next_event(&mut sub).await;
+	let expected = FollowEvent::BestBlockChanged(BestBlockChanged {
+		best_block_hash: format!("{:?}", block_2_hash),
+	});
+	assert_eq!(event, expected);
+}
+
+#[tokio::test]
+async fn ensure_operation_limits_works() {
+	let child_info = ChildInfo::new_default(CHILD_STORAGE_KEY);
+	let builder = TestClientBuilder::new().add_extra_child_storage(
+		&child_info,
+		KEY.to_vec(),
+		CHILD_VALUE.to_vec(),
+	);
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	// Configure the chainHead with maximum 1 ongoing operations.
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: 1,
+			operation_max_storage_items: MAX_PAGINATION_LIMIT,
+		},
+	)
+	.into_rpc();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [true]).await.unwrap();
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	let block_hash = format!("{:?}", block.header.hash());
+	let key = hex_string(&KEY);
+
+	let items = vec![
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsHashes },
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsHashes },
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsValues },
+		StorageQuery { key: key.clone(), query_type: StorageQueryType::DescendantsValues },
+	];
+
+	let response: MethodResponse = api
+		.call("chainHead_unstable_storage", rpc_params![&sub_id, &block_hash, items])
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => {
+			// Check discarded items.
+			assert_eq!(started.discarded_items.unwrap(), 3);
+			started.operation_id
+		},
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+	// No value associated with the provided key.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+
+	// The storage is finished and capactiy must be released.
+	let alice_id = AccountKeyring::Alice.to_account_id();
+	// Hex encoded scale encoded bytes representing the call parameters.
+	let call_parameters = hex_string(&alice_id.encode());
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_call",
+			[&sub_id, &block_hash, "AccountNonceApi_account_nonce", &call_parameters],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	// Response propagated to `chainHead_follow`.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut sub).await,
+			FollowEvent::OperationCallDone(done) if done.operation_id == operation_id && done.output == "0x0000000000000000"
+	);
+}
+
+#[tokio::test]
+async fn check_continue_operation() {
+	let child_info = ChildInfo::new_default(CHILD_STORAGE_KEY);
+	let builder = TestClientBuilder::new().add_extra_child_storage(
+		&child_info,
+		KEY.to_vec(),
+		CHILD_VALUE.to_vec(),
+	);
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	// Configure the chainHead with maximum 1 item before asking for pagination.
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: 1,
+		},
+	)
+	.into_rpc();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [true]).await.unwrap();
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+
+	// Import a new block with storage changes.
+	let mut builder = client.new_block(Default::default()).unwrap();
+	builder.push_storage_change(b":m".to_vec(), Some(b"a".to_vec())).unwrap();
+	builder.push_storage_change(b":mo".to_vec(), Some(b"ab".to_vec())).unwrap();
+	builder.push_storage_change(b":moc".to_vec(), Some(b"abc".to_vec())).unwrap();
+	builder.push_storage_change(b":mock".to_vec(), Some(b"abcd".to_vec())).unwrap();
+	let block = builder.build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	let invalid_hash = hex_string(&INVALID_HASH);
+
+	// Invalid subscription ID must produce no results.
+	let _res: () = api
+		.call("chainHead_unstable_continue", ["invalid_sub_id", &invalid_hash])
+		.await
+		.unwrap();
+
+	// Invalid operation ID must produce no results.
+	let _res: () = api.call("chainHead_unstable_continue", [&sub_id, &invalid_hash]).await.unwrap();
+
+	// Valid call with storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery {
+					key: hex_string(b":m"),
+					query_type: StorageQueryType::DescendantsValues
+				}]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == hex_string(b":m") &&
+			res.items[0].result == StorageResultType::Value(hex_string(b"a"))
+	);
+
+	// Pagination event.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationWaitingForContinue(res) if res.operation_id == operation_id
+	);
+
+	does_not_produce_event::<FollowEvent<String>>(
+		&mut sub,
+		std::time::Duration::from_secs(DOES_NOT_PRODUCE_EVENTS_SECONDS),
+	)
+	.await;
+	let _res: () = api.call("chainHead_unstable_continue", [&sub_id, &operation_id]).await.unwrap();
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == hex_string(b":mo") &&
+			res.items[0].result == StorageResultType::Value(hex_string(b"ab"))
+	);
+
+	// Pagination event.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationWaitingForContinue(res) if res.operation_id == operation_id
+	);
+
+	does_not_produce_event::<FollowEvent<String>>(
+		&mut sub,
+		std::time::Duration::from_secs(DOES_NOT_PRODUCE_EVENTS_SECONDS),
+	)
+	.await;
+	let _res: () = api.call("chainHead_unstable_continue", [&sub_id, &operation_id]).await.unwrap();
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == hex_string(b":moc") &&
+			res.items[0].result == StorageResultType::Value(hex_string(b"abc"))
+	);
+
+	// Pagination event.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationWaitingForContinue(res) if res.operation_id == operation_id
+	);
+	does_not_produce_event::<FollowEvent<String>>(
+		&mut sub,
+		std::time::Duration::from_secs(DOES_NOT_PRODUCE_EVENTS_SECONDS),
+	)
+	.await;
+	let _res: () = api.call("chainHead_unstable_continue", [&sub_id, &operation_id]).await.unwrap();
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == hex_string(b":mock") &&
+			res.items[0].result == StorageResultType::Value(hex_string(b"abcd"))
+	);
+
+	// Finished.
+	assert_matches!(
+			get_next_event::<FollowEvent<String>>(&mut sub).await,
+			FollowEvent::OperationStorageDone(done) if done.operation_id == operation_id
+	);
+}
+
+#[tokio::test]
+async fn stop_storage_operation() {
+	let child_info = ChildInfo::new_default(CHILD_STORAGE_KEY);
+	let builder = TestClientBuilder::new().add_extra_child_storage(
+		&child_info,
+		KEY.to_vec(),
+		CHILD_VALUE.to_vec(),
+	);
+	let backend = builder.backend();
+	let mut client = Arc::new(builder.build());
+
+	// Configure the chainHead with maximum 1 item before asking for pagination.
+	let api = ChainHead::new(
+		client.clone(),
+		backend,
+		Arc::new(TaskExecutor::default()),
+		CHAIN_GENESIS,
+		ChainHeadConfig {
+			global_max_pinned_blocks: MAX_PINNED_BLOCKS,
+			subscription_max_pinned_duration: Duration::from_secs(MAX_PINNED_SECS),
+			subscription_max_ongoing_operations: MAX_OPERATIONS,
+			operation_max_storage_items: 1,
+		},
+	)
+	.into_rpc();
+
+	let mut sub = api.subscribe("chainHead_unstable_follow", [true]).await.unwrap();
+	let sub_id = sub.subscription_id();
+	let sub_id = serde_json::to_string(&sub_id).unwrap();
+
+	// Import a new block with storage changes.
+	let mut builder = client.new_block(Default::default()).unwrap();
+	builder.push_storage_change(b":m".to_vec(), Some(b"a".to_vec())).unwrap();
+	builder.push_storage_change(b":mo".to_vec(), Some(b"ab".to_vec())).unwrap();
+	let block = builder.build().unwrap().block;
+	let block_hash = format!("{:?}", block.header.hash());
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	// Ensure the imported block is propagated and pinned for this subscription.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::Initialized(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::NewBlock(_)
+	);
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::BestBlockChanged(_)
+	);
+
+	let invalid_hash = hex_string(&INVALID_HASH);
+
+	// Invalid subscription ID must produce no results.
+	let _res: () = api
+		.call("chainHead_unstable_stopOperation", ["invalid_sub_id", &invalid_hash])
+		.await
+		.unwrap();
+
+	// Invalid operation ID must produce no results.
+	let _res: () = api
+		.call("chainHead_unstable_stopOperation", [&sub_id, &invalid_hash])
+		.await
+		.unwrap();
+
+	// Valid call with storage at the key.
+	let response: MethodResponse = api
+		.call(
+			"chainHead_unstable_storage",
+			rpc_params![
+				&sub_id,
+				&block_hash,
+				vec![StorageQuery {
+					key: hex_string(b":m"),
+					query_type: StorageQueryType::DescendantsValues
+				}]
+			],
+		)
+		.await
+		.unwrap();
+	let operation_id = match response {
+		MethodResponse::Started(started) => started.operation_id,
+		MethodResponse::LimitReached => panic!("Expected started response"),
+	};
+
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationStorageItems(res) if res.operation_id == operation_id &&
+			res.items.len() == 1 &&
+			res.items[0].key == hex_string(b":m") &&
+			res.items[0].result == StorageResultType::Value(hex_string(b"a"))
+	);
+
+	// Pagination event.
+	assert_matches!(
+		get_next_event::<FollowEvent<String>>(&mut sub).await,
+		FollowEvent::OperationWaitingForContinue(res) if res.operation_id == operation_id
+	);
+
+	// Stop the operation.
+	let _res: () = api
+		.call("chainHead_unstable_stopOperation", [&sub_id, &operation_id])
+		.await
+		.unwrap();
+
+	does_not_produce_event::<FollowEvent<String>>(
+		&mut sub,
+		std::time::Duration::from_secs(DOES_NOT_PRODUCE_EVENTS_SECONDS),
+	)
+	.await;
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_spec/api.rs b/substrate/client/rpc-spec-v2/src/chain_spec/api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..66c9f868047ce411fdb9050572234e911231155d
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_spec/api.rs
@@ -0,0 +1,53 @@
+// 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/>.
+
+//! API trait of the chain spec.
+
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use sc_chain_spec::Properties;
+
+#[rpc(client, server)]
+pub trait ChainSpecApi {
+	/// Get the chain name, as present in the chain specification.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainSpec_unstable_chainName")]
+	fn chain_spec_unstable_chain_name(&self) -> RpcResult<String>;
+
+	/// Get the chain's genesis hash.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainSpec_unstable_genesisHash")]
+	fn chain_spec_unstable_genesis_hash(&self) -> RpcResult<String>;
+
+	/// Get the properties of the chain, as present in the chain specification.
+	///
+	/// # Note
+	///
+	/// The json whitespaces are not guaranteed to persist.
+	///
+	/// # Unstable
+	///
+	/// This method is unstable and subject to change in the future.
+	#[method(name = "chainSpec_unstable_properties")]
+	fn chain_spec_unstable_properties(&self) -> RpcResult<Properties>;
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_spec/chain_spec.rs b/substrate/client/rpc-spec-v2/src/chain_spec/chain_spec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..99ea34521f586cec7e9fa7890938171f34f83b70
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_spec/chain_spec.rs
@@ -0,0 +1,60 @@
+// 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/>.
+
+//! API implementation for the specification of a chain.
+
+use crate::chain_spec::api::ChainSpecApiServer;
+use jsonrpsee::core::RpcResult;
+use sc_chain_spec::Properties;
+
+/// An API for chain spec RPC calls.
+pub struct ChainSpec {
+	/// The name of the chain.
+	name: String,
+	/// The hexadecimal encoded hash of the genesis block.
+	genesis_hash: String,
+	/// Chain properties.
+	properties: Properties,
+}
+
+impl ChainSpec {
+	/// Creates a new [`ChainSpec`].
+	pub fn new<Hash: AsRef<[u8]>>(
+		name: String,
+		genesis_hash: Hash,
+		properties: Properties,
+	) -> Self {
+		let genesis_hash = format!("0x{}", hex::encode(genesis_hash));
+
+		Self { name, properties, genesis_hash }
+	}
+}
+
+impl ChainSpecApiServer for ChainSpec {
+	fn chain_spec_unstable_chain_name(&self) -> RpcResult<String> {
+		Ok(self.name.clone())
+	}
+
+	fn chain_spec_unstable_genesis_hash(&self) -> RpcResult<String> {
+		Ok(self.genesis_hash.clone())
+	}
+
+	fn chain_spec_unstable_properties(&self) -> RpcResult<Properties> {
+		Ok(self.properties.clone())
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/chain_spec/mod.rs b/substrate/client/rpc-spec-v2/src/chain_spec/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0dfbdf1b10cc3d2e6975561f52f590881e8c237b
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_spec/mod.rs
@@ -0,0 +1,38 @@
+// 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/>.
+
+//! Substrate chain specification API.
+//!
+//! The *chain spec* (short for *chain specification*) allows inspecting the content of
+//! the specification of the chain that a JSON-RPC server is targeting.
+//!
+//! The values returned by the API are guaranteed to never change during the lifetime of the
+//! JSON-RPC server.
+//!
+//! # Note
+//!
+//! Methods are prefixed by `chainSpec`.
+
+#[cfg(test)]
+mod tests;
+
+pub mod api;
+pub mod chain_spec;
+
+pub use api::ChainSpecApiServer;
+pub use chain_spec::ChainSpec;
diff --git a/substrate/client/rpc-spec-v2/src/chain_spec/tests.rs b/substrate/client/rpc-spec-v2/src/chain_spec/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74aec01a2113ee8918368c7b088484ea32f15fd9
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/chain_spec/tests.rs
@@ -0,0 +1,61 @@
+// 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::*;
+use jsonrpsee::{types::EmptyServerParams as EmptyParams, RpcModule};
+use sc_chain_spec::Properties;
+
+const CHAIN_NAME: &'static str = "TEST_CHAIN_NAME";
+const CHAIN_GENESIS: [u8; 32] = [0; 32];
+const CHAIN_PROPERTIES: &'static str = r#"{"three": "123", "one": 1, "two": 12}"#;
+
+fn api() -> RpcModule<ChainSpec> {
+	ChainSpec::new(
+		CHAIN_NAME.to_string(),
+		CHAIN_GENESIS,
+		serde_json::from_str(CHAIN_PROPERTIES).unwrap(),
+	)
+	.into_rpc()
+}
+
+#[tokio::test]
+async fn chain_spec_chain_name_works() {
+	let name = api()
+		.call::<_, String>("chainSpec_unstable_chainName", EmptyParams::new())
+		.await
+		.unwrap();
+	assert_eq!(name, CHAIN_NAME);
+}
+
+#[tokio::test]
+async fn chain_spec_genesis_hash_works() {
+	let genesis = api()
+		.call::<_, String>("chainSpec_unstable_genesisHash", EmptyParams::new())
+		.await
+		.unwrap();
+	assert_eq!(genesis, format!("0x{}", hex::encode(CHAIN_GENESIS)));
+}
+
+#[tokio::test]
+async fn chain_spec_properties_works() {
+	let properties = api()
+		.call::<_, Properties>("chainSpec_unstable_properties", EmptyParams::new())
+		.await
+		.unwrap();
+	assert_eq!(properties, serde_json::from_str(CHAIN_PROPERTIES).unwrap());
+}
diff --git a/substrate/client/rpc-spec-v2/src/lib.rs b/substrate/client/rpc-spec-v2/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c22ef5d523189f5a2d49b150c786976bf64c5a8
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/lib.rs
@@ -0,0 +1,31 @@
+// 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/>.
+
+//! Substrate JSON-RPC interface v2.
+//!
+//! Specification [document](https://paritytech.github.io/json-rpc-interface-spec/).
+
+#![warn(missing_docs)]
+#![deny(unused_crate_dependencies)]
+
+pub mod chain_head;
+pub mod chain_spec;
+pub mod transaction;
+
+/// Task executor that is being used by RPC subscriptions.
+pub type SubscriptionTaskExecutor = std::sync::Arc<dyn sp_core::traits::SpawnNamed>;
diff --git a/substrate/client/rpc-spec-v2/src/transaction/api.rs b/substrate/client/rpc-spec-v2/src/transaction/api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c226ab86787e9880438fbc780d0b604a816a1848
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/transaction/api.rs
@@ -0,0 +1,37 @@
+// 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/>.
+
+//! API trait for transactions.
+
+use crate::transaction::event::TransactionEvent;
+use jsonrpsee::proc_macros::rpc;
+use sp_core::Bytes;
+
+#[rpc(client, server)]
+pub trait TransactionApi<Hash: Clone> {
+	/// Submit an extrinsic to watch.
+	///
+	/// See [`TransactionEvent`](crate::transaction::event::TransactionEvent) for details on
+	/// transaction life cycle.
+	#[subscription(
+		name = "transaction_unstable_submitAndWatch" => "transaction_unstable_submitExtrinsic",
+		unsubscribe = "transaction_unstable_unwatch",
+		item = TransactionEvent<Hash>,
+	)]
+	fn submit_and_watch(&self, bytes: Bytes);
+}
diff --git a/substrate/client/rpc-spec-v2/src/transaction/error.rs b/substrate/client/rpc-spec-v2/src/transaction/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d2de07afd5955cd2d41148bab0119384b117bf42
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/transaction/error.rs
@@ -0,0 +1,100 @@
+// 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/>.
+
+//! Transaction RPC errors.
+//!
+//! Errors are interpreted as transaction events for subscriptions.
+
+use crate::transaction::event::{TransactionError, TransactionEvent};
+use sc_transaction_pool_api::error::Error as PoolError;
+use sp_runtime::transaction_validity::InvalidTransaction;
+
+/// Transaction RPC errors.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Transaction pool error.
+	#[error("Transaction pool error: {}", .0)]
+	Pool(#[from] PoolError),
+	/// Verification error.
+	#[error("Extrinsic verification error: {}", .0)]
+	Verification(Box<dyn std::error::Error + Send + Sync>),
+}
+
+impl<Hash> From<Error> for TransactionEvent<Hash> {
+	fn from(e: Error) -> Self {
+		match e {
+			Error::Verification(e) => TransactionEvent::Invalid(TransactionError {
+				error: format!("Verification error: {}", e),
+			}),
+			Error::Pool(PoolError::InvalidTransaction(InvalidTransaction::Custom(e))) =>
+				TransactionEvent::Invalid(TransactionError {
+					error: format!("Invalid transaction with custom error: {}", e),
+				}),
+			Error::Pool(PoolError::InvalidTransaction(e)) => {
+				let msg: &str = e.into();
+				TransactionEvent::Invalid(TransactionError {
+					error: format!("Invalid transaction: {}", msg),
+				})
+			},
+			Error::Pool(PoolError::UnknownTransaction(e)) => {
+				let msg: &str = e.into();
+				TransactionEvent::Invalid(TransactionError {
+					error: format!("Unknown transaction validity: {}", msg),
+				})
+			},
+			Error::Pool(PoolError::TemporarilyBanned) =>
+				TransactionEvent::Invalid(TransactionError {
+					error: "Transaction is temporarily banned".into(),
+				}),
+			Error::Pool(PoolError::AlreadyImported(_)) =>
+				TransactionEvent::Invalid(TransactionError {
+					error: "Transaction is already imported".into(),
+				}),
+			Error::Pool(PoolError::TooLowPriority { old, new }) =>
+				TransactionEvent::Invalid(TransactionError {
+					error: format!(
+						"The priority of the transaction is too low (pool {} > current {})",
+						old, new
+					),
+				}),
+			Error::Pool(PoolError::CycleDetected) => TransactionEvent::Invalid(TransactionError {
+				error: "The transaction contains a cyclic dependency".into(),
+			}),
+			Error::Pool(PoolError::ImmediatelyDropped) =>
+				TransactionEvent::Invalid(TransactionError {
+					error: "The transaction could not enter the pool because of the limit".into(),
+				}),
+			Error::Pool(PoolError::Unactionable) => TransactionEvent::Invalid(TransactionError {
+				error: "Transaction cannot be propagated and the local node does not author blocks"
+					.into(),
+			}),
+			Error::Pool(PoolError::NoTagsProvided) => TransactionEvent::Invalid(TransactionError {
+				error: "Transaction does not provide any tags, so the pool cannot identify it"
+					.into(),
+			}),
+			Error::Pool(PoolError::InvalidBlockId(_)) =>
+				TransactionEvent::Invalid(TransactionError {
+					error: "The provided block ID is not valid".into(),
+				}),
+			Error::Pool(PoolError::RejectedFutureTransaction) =>
+				TransactionEvent::Invalid(TransactionError {
+					error: "The pool is not accepting future transactions".into(),
+				}),
+		}
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/transaction/event.rs b/substrate/client/rpc-spec-v2/src/transaction/event.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bdc126366fb9249bdb5e9b8e577f8cc2c2ae010f
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/transaction/event.rs
@@ -0,0 +1,353 @@
+// 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/>.
+
+//! The transaction's event returned as json compatible object.
+
+use serde::{Deserialize, Serialize};
+
+/// The transaction was broadcasted to a number of peers.
+///
+/// # Note
+///
+/// The RPC does not guarantee that the peers have received the
+/// transaction.
+///
+/// When the number of peers is zero, the event guarantees that
+/// shutting down the local node will lead to the transaction
+/// not being included in the chain.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionBroadcasted {
+	/// The number of peers the transaction was broadcasted to.
+	#[serde(with = "as_string")]
+	pub num_peers: usize,
+}
+
+/// The transaction was included in a block of the chain.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionBlock<Hash> {
+	/// The hash of the block the transaction was included into.
+	pub hash: Hash,
+	/// The index (zero-based) of the transaction within the body of the block.
+	#[serde(with = "as_string")]
+	pub index: usize,
+}
+
+/// The transaction could not be processed due to an error.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionError {
+	/// Reason of the error.
+	pub error: String,
+}
+
+/// The transaction was dropped because of exceeding limits.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransactionDropped {
+	/// True if the transaction was broadcasted to other peers and
+	/// may still be included in the block.
+	pub broadcasted: bool,
+	/// Reason of the event.
+	pub error: String,
+}
+
+/// Possible transaction status events.
+///
+/// The status events can be grouped based on their kinds as:
+///
+/// 1. Runtime validated the transaction:
+/// 		- `Validated`
+///
+/// 2. Inside the `Ready` queue:
+/// 		- `Broadcast`
+///
+/// 3. Leaving the pool:
+/// 		- `BestChainBlockIncluded`
+/// 		- `Invalid`
+///
+/// 4. Block finalized:
+/// 		- `Finalized`
+///
+/// 5. At any time:
+/// 		- `Dropped`
+/// 		- `Error`
+///
+/// The subscription's stream is considered finished whenever the following events are
+/// received: `Finalized`, `Error`, `Invalid` or `Dropped`. However, the user is allowed
+/// to unsubscribe at any moment.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+// We need to manually specify the trait bounds for the `Hash` trait to ensure `into` and
+// `from` still work.
+#[serde(bound(
+	serialize = "Hash: Serialize + Clone",
+	deserialize = "Hash: Deserialize<'de> + Clone"
+))]
+#[serde(into = "TransactionEventIR<Hash>", from = "TransactionEventIR<Hash>")]
+pub enum TransactionEvent<Hash> {
+	/// The transaction was validated by the runtime.
+	Validated,
+	/// The transaction was broadcasted to a number of peers.
+	Broadcasted(TransactionBroadcasted),
+	/// The transaction was included in a best block of the chain.
+	///
+	/// # Note
+	///
+	/// This may contain `None` if the block is no longer a best
+	/// block of the chain.
+	BestChainBlockIncluded(Option<TransactionBlock<Hash>>),
+	/// The transaction was included in a finalized block.
+	Finalized(TransactionBlock<Hash>),
+	/// The transaction could not be processed due to an error.
+	Error(TransactionError),
+	/// The transaction is marked as invalid.
+	Invalid(TransactionError),
+	/// The client was not capable of keeping track of this transaction.
+	Dropped(TransactionDropped),
+}
+
+/// Intermediate representation (IR) for the transaction events
+/// that handles block events only.
+///
+/// The block events require a JSON compatible interpretation similar to:
+///
+/// ```json
+/// { event: "EVENT", block: { hash: "0xFF", index: 0 } }
+/// ```
+///
+/// This IR is introduced to circumvent that the block events need to
+/// be serialized/deserialized with "tag" and "content", while other
+/// events only require "tag".
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(tag = "event", content = "block")]
+enum TransactionEventBlockIR<Hash> {
+	/// The transaction was included in the best block of the chain.
+	BestChainBlockIncluded(Option<TransactionBlock<Hash>>),
+	/// The transaction was included in a finalized block of the chain.
+	Finalized(TransactionBlock<Hash>),
+}
+
+/// Intermediate representation (IR) for the transaction events
+/// that handles non-block events only.
+///
+/// The non-block events require a JSON compatible interpretation similar to:
+///
+/// ```json
+/// { event: "EVENT", num_peers: 0 }
+/// ```
+///
+/// This IR is introduced to circumvent that the block events need to
+/// be serialized/deserialized with "tag" and "content", while other
+/// events only require "tag".
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(tag = "event")]
+enum TransactionEventNonBlockIR {
+	Validated,
+	Broadcasted(TransactionBroadcasted),
+	Error(TransactionError),
+	Invalid(TransactionError),
+	Dropped(TransactionDropped),
+}
+
+/// Intermediate representation (IR) used for serialization/deserialization of the
+/// [`TransactionEvent`] in a JSON compatible format.
+///
+/// Serde cannot mix `#[serde(tag = "event")]` with `#[serde(tag = "event", content = "block")]`
+/// for specific enum variants. Therefore, this IR is introduced to circumvent this
+/// restriction, while exposing a simplified [`TransactionEvent`] for users of the
+/// rust ecosystem.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(bound(serialize = "Hash: Serialize", deserialize = "Hash: Deserialize<'de>"))]
+#[serde(rename_all = "camelCase")]
+#[serde(untagged)]
+enum TransactionEventIR<Hash> {
+	Block(TransactionEventBlockIR<Hash>),
+	NonBlock(TransactionEventNonBlockIR),
+}
+
+impl<Hash> From<TransactionEvent<Hash>> for TransactionEventIR<Hash> {
+	fn from(value: TransactionEvent<Hash>) -> Self {
+		match value {
+			TransactionEvent::Validated =>
+				TransactionEventIR::NonBlock(TransactionEventNonBlockIR::Validated),
+			TransactionEvent::Broadcasted(event) =>
+				TransactionEventIR::NonBlock(TransactionEventNonBlockIR::Broadcasted(event)),
+			TransactionEvent::BestChainBlockIncluded(event) =>
+				TransactionEventIR::Block(TransactionEventBlockIR::BestChainBlockIncluded(event)),
+			TransactionEvent::Finalized(event) =>
+				TransactionEventIR::Block(TransactionEventBlockIR::Finalized(event)),
+			TransactionEvent::Error(event) =>
+				TransactionEventIR::NonBlock(TransactionEventNonBlockIR::Error(event)),
+			TransactionEvent::Invalid(event) =>
+				TransactionEventIR::NonBlock(TransactionEventNonBlockIR::Invalid(event)),
+			TransactionEvent::Dropped(event) =>
+				TransactionEventIR::NonBlock(TransactionEventNonBlockIR::Dropped(event)),
+		}
+	}
+}
+
+impl<Hash> From<TransactionEventIR<Hash>> for TransactionEvent<Hash> {
+	fn from(value: TransactionEventIR<Hash>) -> Self {
+		match value {
+			TransactionEventIR::NonBlock(status) => match status {
+				TransactionEventNonBlockIR::Validated => TransactionEvent::Validated,
+				TransactionEventNonBlockIR::Broadcasted(event) =>
+					TransactionEvent::Broadcasted(event),
+				TransactionEventNonBlockIR::Error(event) => TransactionEvent::Error(event),
+				TransactionEventNonBlockIR::Invalid(event) => TransactionEvent::Invalid(event),
+				TransactionEventNonBlockIR::Dropped(event) => TransactionEvent::Dropped(event),
+			},
+			TransactionEventIR::Block(block) => match block {
+				TransactionEventBlockIR::Finalized(event) => TransactionEvent::Finalized(event),
+				TransactionEventBlockIR::BestChainBlockIncluded(event) =>
+					TransactionEvent::BestChainBlockIncluded(event),
+			},
+		}
+	}
+}
+
+/// Serialize and deserialize helper as string.
+mod as_string {
+	use super::*;
+	use serde::{Deserializer, Serializer};
+
+	pub fn serialize<S: Serializer>(data: &usize, serializer: S) -> Result<S::Ok, S::Error> {
+		data.to_string().serialize(serializer)
+	}
+
+	pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<usize, D::Error> {
+		String::deserialize(deserializer)?
+			.parse()
+			.map_err(|e| serde::de::Error::custom(format!("Parsing failed: {}", e)))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::H256;
+
+	#[test]
+	fn validated_event() {
+		let event: TransactionEvent<()> = TransactionEvent::Validated;
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"validated"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<()> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn broadcasted_event() {
+		let event: TransactionEvent<()> =
+			TransactionEvent::Broadcasted(TransactionBroadcasted { num_peers: 2 });
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"broadcasted","numPeers":"2"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<()> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn best_chain_event() {
+		let event: TransactionEvent<()> = TransactionEvent::BestChainBlockIncluded(None);
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"bestChainBlockIncluded","block":null}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<()> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+
+		let event: TransactionEvent<H256> =
+			TransactionEvent::BestChainBlockIncluded(Some(TransactionBlock {
+				hash: H256::from_low_u64_be(1),
+				index: 2,
+			}));
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"bestChainBlockIncluded","block":{"hash":"0x0000000000000000000000000000000000000000000000000000000000000001","index":"2"}}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<H256> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn finalized_event() {
+		let event: TransactionEvent<H256> = TransactionEvent::Finalized(TransactionBlock {
+			hash: H256::from_low_u64_be(1),
+			index: 10,
+		});
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"finalized","block":{"hash":"0x0000000000000000000000000000000000000000000000000000000000000001","index":"10"}}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<H256> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn error_event() {
+		let event: TransactionEvent<()> =
+			TransactionEvent::Error(TransactionError { error: "abc".to_string() });
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"error","error":"abc"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<()> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn invalid_event() {
+		let event: TransactionEvent<()> =
+			TransactionEvent::Invalid(TransactionError { error: "abc".to_string() });
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"invalid","error":"abc"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<()> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+
+	#[test]
+	fn dropped_event() {
+		let event: TransactionEvent<()> = TransactionEvent::Dropped(TransactionDropped {
+			broadcasted: true,
+			error: "abc".to_string(),
+		});
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"event":"dropped","broadcasted":true,"error":"abc"}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionEvent<()> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, event);
+	}
+}
diff --git a/substrate/client/rpc-spec-v2/src/transaction/mod.rs b/substrate/client/rpc-spec-v2/src/transaction/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..212912ba1c728feb5e01614a74fcab09ce5bc079
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/transaction/mod.rs
@@ -0,0 +1,38 @@
+// 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/>.
+
+//! Substrate transaction API.
+//!
+//! The transaction methods allow submitting a transaction and subscribing to
+//! its status updates generated by the chain.
+//!
+//! # Note
+//!
+//! Methods are prefixed by `transaction`.
+
+pub mod api;
+pub mod error;
+pub mod event;
+pub mod transaction;
+
+pub use api::TransactionApiServer;
+pub use event::{
+	TransactionBlock, TransactionBroadcasted, TransactionDropped, TransactionError,
+	TransactionEvent,
+};
+pub use transaction::Transaction;
diff --git a/substrate/client/rpc-spec-v2/src/transaction/transaction.rs b/substrate/client/rpc-spec-v2/src/transaction/transaction.rs
new file mode 100644
index 0000000000000000000000000000000000000000..44f4bd36c8b8b655d9207f8687c5ad41144a8cda
--- /dev/null
+++ b/substrate/client/rpc-spec-v2/src/transaction/transaction.rs
@@ -0,0 +1,208 @@
+// 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/>.
+
+//! API implementation for submitting transactions.
+
+use crate::{
+	transaction::{
+		api::TransactionApiServer,
+		error::Error,
+		event::{
+			TransactionBlock, TransactionBroadcasted, TransactionDropped, TransactionError,
+			TransactionEvent,
+		},
+	},
+	SubscriptionTaskExecutor,
+};
+use jsonrpsee::{
+	core::async_trait,
+	types::{
+		error::{CallError, ErrorObject},
+		SubscriptionResult,
+	},
+	SubscriptionSink,
+};
+use sc_transaction_pool_api::{
+	error::IntoPoolError, BlockHash, TransactionFor, TransactionPool, TransactionSource,
+	TransactionStatus,
+};
+use std::sync::Arc;
+
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::HeaderBackend;
+use sp_core::Bytes;
+use sp_runtime::{generic, traits::Block as BlockT};
+
+use codec::Decode;
+use futures::{FutureExt, StreamExt, TryFutureExt};
+
+/// An API for transaction RPC calls.
+pub struct Transaction<Pool, Client> {
+	/// Substrate client.
+	client: Arc<Client>,
+	/// Transactions pool.
+	pool: Arc<Pool>,
+	/// Executor to spawn subscriptions.
+	executor: SubscriptionTaskExecutor,
+}
+
+impl<Pool, Client> Transaction<Pool, Client> {
+	/// Creates a new [`Transaction`].
+	pub fn new(client: Arc<Client>, pool: Arc<Pool>, executor: SubscriptionTaskExecutor) -> Self {
+		Transaction { client, pool, executor }
+	}
+}
+
+/// Currently we treat all RPC transactions as externals.
+///
+/// Possibly in the future we could allow opt-in for special treatment
+/// of such transactions, so that the block authors can inject
+/// some unique transactions via RPC and have them included in the pool.
+const TX_SOURCE: TransactionSource = TransactionSource::External;
+
+/// Extrinsic has an invalid format.
+///
+/// # Note
+///
+/// This is similar to the old `author` API error code.
+const BAD_FORMAT: i32 = 1001;
+
+#[async_trait]
+impl<Pool, Client> TransactionApiServer<BlockHash<Pool>> for Transaction<Pool, Client>
+where
+	Pool: TransactionPool + Sync + Send + 'static,
+	Pool::Hash: Unpin,
+	<Pool::Block as BlockT>::Hash: Unpin,
+	Client: HeaderBackend<Pool::Block> + ProvideRuntimeApi<Pool::Block> + Send + Sync + 'static,
+{
+	fn submit_and_watch(&self, mut sink: SubscriptionSink, xt: Bytes) -> SubscriptionResult {
+		// This is the only place where the RPC server can return an error for this
+		// subscription. Other defects must be signaled as events to the sink.
+		let decoded_extrinsic = match TransactionFor::<Pool>::decode(&mut &xt[..]) {
+			Ok(decoded_extrinsic) => decoded_extrinsic,
+			Err(e) => {
+				let err = CallError::Custom(ErrorObject::owned(
+					BAD_FORMAT,
+					format!("Extrinsic has invalid format: {}", e),
+					None::<()>,
+				));
+				let _ = sink.reject(err);
+				return Ok(())
+			},
+		};
+
+		let best_block_hash = self.client.info().best_hash;
+
+		let submit = self
+			.pool
+			.submit_and_watch(
+				&generic::BlockId::hash(best_block_hash),
+				TX_SOURCE,
+				decoded_extrinsic,
+			)
+			.map_err(|e| {
+				e.into_pool_error()
+					.map(Error::from)
+					.unwrap_or_else(|e| Error::Verification(Box::new(e)))
+			});
+
+		let fut = async move {
+			match submit.await {
+				Ok(stream) => {
+					let mut state = TransactionState::new();
+					let stream =
+						stream.filter_map(|event| async move { state.handle_event(event) });
+					sink.pipe_from_stream(stream.boxed()).await;
+				},
+				Err(err) => {
+					// We have not created an `Watcher` for the tx. Make sure the
+					// error is still propagated as an event.
+					let event: TransactionEvent<<Pool::Block as BlockT>::Hash> = err.into();
+					sink.pipe_from_stream(futures::stream::once(async { event }).boxed()).await;
+				},
+			};
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+		Ok(())
+	}
+}
+
+/// The transaction's state that needs to be preserved between
+/// multiple events generated by the transaction-pool.
+///
+/// # Note
+///
+/// In the future, the RPC server can submit only the last event when multiple
+/// identical events happen in a row.
+#[derive(Clone, Copy)]
+struct TransactionState {
+	/// True if the transaction was previously broadcasted.
+	broadcasted: bool,
+}
+
+impl TransactionState {
+	/// Construct a new [`TransactionState`].
+	pub fn new() -> Self {
+		TransactionState { broadcasted: false }
+	}
+
+	/// Handle events generated by the transaction-pool and convert them
+	/// to the new API expected state.
+	#[inline]
+	pub fn handle_event<Hash: Clone, BlockHash: Clone>(
+		&mut self,
+		event: TransactionStatus<Hash, BlockHash>,
+	) -> Option<TransactionEvent<BlockHash>> {
+		match event {
+			TransactionStatus::Ready | TransactionStatus::Future =>
+				Some(TransactionEvent::<BlockHash>::Validated),
+			TransactionStatus::Broadcast(peers) => {
+				// Set the broadcasted flag once if we submitted the transaction to
+				// at least one peer.
+				self.broadcasted = self.broadcasted || !peers.is_empty();
+
+				Some(TransactionEvent::Broadcasted(TransactionBroadcasted {
+					num_peers: peers.len(),
+				}))
+			},
+			TransactionStatus::InBlock((hash, index)) =>
+				Some(TransactionEvent::BestChainBlockIncluded(Some(TransactionBlock {
+					hash,
+					index,
+				}))),
+			TransactionStatus::Retracted(_) => Some(TransactionEvent::BestChainBlockIncluded(None)),
+			TransactionStatus::FinalityTimeout(_) =>
+				Some(TransactionEvent::Dropped(TransactionDropped {
+					broadcasted: self.broadcasted,
+					error: "Maximum number of finality watchers has been reached".into(),
+				})),
+			TransactionStatus::Finalized((hash, index)) =>
+				Some(TransactionEvent::Finalized(TransactionBlock { hash, index })),
+			TransactionStatus::Usurped(_) => Some(TransactionEvent::Invalid(TransactionError {
+				error: "Extrinsic was rendered invalid by another extrinsic".into(),
+			})),
+			TransactionStatus::Dropped => Some(TransactionEvent::Invalid(TransactionError {
+				error: "Extrinsic dropped from the pool due to exceeding limits".into(),
+			})),
+			TransactionStatus::Invalid => Some(TransactionEvent::Invalid(TransactionError {
+				error: "Extrinsic marked as invalid".into(),
+			})),
+		}
+	}
+}
diff --git a/substrate/client/rpc/Cargo.toml b/substrate/client/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a3574ed84d0114eb3ab6050a25480585ceb89231
--- /dev/null
+++ b/substrate/client/rpc/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "sc-rpc"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate Client RPC"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+jsonrpsee = { version = "0.16.2", features = ["server"] }
+log = "0.4.17"
+parking_lot = "0.12.1"
+serde_json = "1.0.85"
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sc-chain-spec = { version = "4.0.0-dev", path = "../chain-spec" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-rpc-api = { version = "0.10.0-dev", path = "../rpc-api" }
+sc-tracing = { version = "4.0.0-dev", path = "../tracing" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../transaction-pool/api" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+sp-offchain = { version = "4.0.0-dev", path = "../../primitives/offchain" }
+sp-rpc = { version = "6.0.0", path = "../../primitives/rpc" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-session = { version = "4.0.0-dev", path = "../../primitives/session" }
+sp-version = { version = "22.0.0", path = "../../primitives/version" }
+sp-statement-store = { version = "4.0.0-dev", path = "../../primitives/statement-store" }
+
+tokio = "1.22.0"
+
+[dev-dependencies]
+env_logger = "0.9"
+assert_matches = "1.3.0"
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sc-network = { version = "0.10.0-dev", path = "../network" }
+sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
+sc-transaction-pool = { version = "4.0.0-dev", path = "../transaction-pool" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+tokio = "1.22.0"
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+pretty_assertions = "1.2.1"
+
+[features]
+test-helpers = []
diff --git a/substrate/client/rpc/README.md b/substrate/client/rpc/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6066af4da71a36ed2748f1cce2c360592e2b51ab
--- /dev/null
+++ b/substrate/client/rpc/README.md
@@ -0,0 +1,5 @@
+Substrate RPC implementation.
+
+A core implementation of Substrate RPC interfaces.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/rpc/src/author/mod.rs b/substrate/client/rpc/src/author/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..feee22641ef3469fa23d8b5bc048e985bf1f7bd7
--- /dev/null
+++ b/substrate/client/rpc/src/author/mod.rs
@@ -0,0 +1,218 @@
+// 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/>.
+
+//! Substrate block-author/full-node API.
+
+#[cfg(test)]
+mod tests;
+
+use std::sync::Arc;
+
+use crate::SubscriptionTaskExecutor;
+
+use codec::{Decode, Encode};
+use futures::{FutureExt, TryFutureExt};
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError, RpcResult},
+	types::SubscriptionResult,
+	SubscriptionSink,
+};
+use sc_rpc_api::DenyUnsafe;
+use sc_transaction_pool_api::{
+	error::IntoPoolError, BlockHash, InPoolTransaction, TransactionFor, TransactionPool,
+	TransactionSource, TxHash,
+};
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_blockchain::HeaderBackend;
+use sp_core::Bytes;
+use sp_keystore::{KeystoreExt, KeystorePtr};
+use sp_runtime::{generic, traits::Block as BlockT};
+use sp_session::SessionKeys;
+
+use self::error::{Error, Result};
+/// Re-export the API for backward compatibility.
+pub use sc_rpc_api::author::*;
+
+/// Authoring API
+pub struct Author<P, Client> {
+	/// Substrate client
+	client: Arc<Client>,
+	/// Transactions pool
+	pool: Arc<P>,
+	/// The key store.
+	keystore: KeystorePtr,
+	/// Whether to deny unsafe calls
+	deny_unsafe: DenyUnsafe,
+	/// Executor to spawn subscriptions.
+	executor: SubscriptionTaskExecutor,
+}
+
+impl<P, Client> Author<P, Client> {
+	/// Create new instance of Authoring API.
+	pub fn new(
+		client: Arc<Client>,
+		pool: Arc<P>,
+		keystore: KeystorePtr,
+		deny_unsafe: DenyUnsafe,
+		executor: SubscriptionTaskExecutor,
+	) -> Self {
+		Author { client, pool, keystore, deny_unsafe, executor }
+	}
+}
+
+/// Currently we treat all RPC transactions as externals.
+///
+/// Possibly in the future we could allow opt-in for special treatment
+/// of such transactions, so that the block authors can inject
+/// some unique transactions via RPC and have them included in the pool.
+const TX_SOURCE: TransactionSource = TransactionSource::External;
+
+#[async_trait]
+impl<P, Client> AuthorApiServer<TxHash<P>, BlockHash<P>> for Author<P, Client>
+where
+	P: TransactionPool + Sync + Send + 'static,
+	Client: HeaderBackend<P::Block> + ProvideRuntimeApi<P::Block> + Send + Sync + 'static,
+	Client::Api: SessionKeys<P::Block>,
+	P::Hash: Unpin,
+	<P::Block as BlockT>::Hash: Unpin,
+{
+	async fn submit_extrinsic(&self, ext: Bytes) -> RpcResult<TxHash<P>> {
+		let xt = match Decode::decode(&mut &ext[..]) {
+			Ok(xt) => xt,
+			Err(err) => return Err(Error::Client(Box::new(err)).into()),
+		};
+		let best_block_hash = self.client.info().best_hash;
+		self.pool
+			.submit_one(&generic::BlockId::hash(best_block_hash), TX_SOURCE, xt)
+			.await
+			.map_err(|e| {
+				e.into_pool_error()
+					.map(|e| Error::Pool(e))
+					.unwrap_or_else(|e| Error::Verification(Box::new(e)))
+					.into()
+			})
+	}
+
+	fn insert_key(&self, key_type: String, suri: String, public: Bytes) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let key_type = key_type.as_str().try_into().map_err(|_| Error::BadKeyType)?;
+		self.keystore
+			.insert(key_type, &suri, &public[..])
+			.map_err(|_| Error::KeystoreUnavailable)?;
+		Ok(())
+	}
+
+	fn rotate_keys(&self) -> RpcResult<Bytes> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let best_block_hash = self.client.info().best_hash;
+		let mut runtime_api = self.client.runtime_api();
+
+		runtime_api.register_extension(KeystoreExt::from(self.keystore.clone()));
+
+		runtime_api
+			.generate_session_keys(best_block_hash, None)
+			.map(Into::into)
+			.map_err(|api_err| Error::Client(Box::new(api_err)).into())
+	}
+
+	fn has_session_keys(&self, session_keys: Bytes) -> RpcResult<bool> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let best_block_hash = self.client.info().best_hash;
+		let keys = self
+			.client
+			.runtime_api()
+			.decode_session_keys(best_block_hash, session_keys.to_vec())
+			.map_err(|e| Error::Client(Box::new(e)))?
+			.ok_or(Error::InvalidSessionKeys)?;
+
+		Ok(self.keystore.has_keys(&keys))
+	}
+
+	fn has_key(&self, public_key: Bytes, key_type: String) -> RpcResult<bool> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let key_type = key_type.as_str().try_into().map_err(|_| Error::BadKeyType)?;
+		Ok(self.keystore.has_keys(&[(public_key.to_vec(), key_type)]))
+	}
+
+	fn pending_extrinsics(&self) -> RpcResult<Vec<Bytes>> {
+		Ok(self.pool.ready().map(|tx| tx.data().encode().into()).collect())
+	}
+
+	fn remove_extrinsic(
+		&self,
+		bytes_or_hash: Vec<hash::ExtrinsicOrHash<TxHash<P>>>,
+	) -> RpcResult<Vec<TxHash<P>>> {
+		self.deny_unsafe.check_if_safe()?;
+		let hashes = bytes_or_hash
+			.into_iter()
+			.map(|x| match x {
+				hash::ExtrinsicOrHash::Hash(h) => Ok(h),
+				hash::ExtrinsicOrHash::Extrinsic(bytes) => {
+					let xt = Decode::decode(&mut &bytes[..])?;
+					Ok(self.pool.hash_of(&xt))
+				},
+			})
+			.collect::<Result<Vec<_>>>()?;
+
+		Ok(self
+			.pool
+			.remove_invalid(&hashes)
+			.into_iter()
+			.map(|tx| tx.hash().clone())
+			.collect())
+	}
+
+	fn watch_extrinsic(&self, mut sink: SubscriptionSink, xt: Bytes) -> SubscriptionResult {
+		let best_block_hash = self.client.info().best_hash;
+		let dxt = match TransactionFor::<P>::decode(&mut &xt[..]).map_err(|e| Error::from(e)) {
+			Ok(dxt) => dxt,
+			Err(e) => {
+				let _ = sink.reject(JsonRpseeError::from(e));
+				return Ok(())
+			},
+		};
+
+		let submit = self
+			.pool
+			.submit_and_watch(&generic::BlockId::hash(best_block_hash), TX_SOURCE, dxt)
+			.map_err(|e| {
+				e.into_pool_error()
+					.map(error::Error::from)
+					.unwrap_or_else(|e| error::Error::Verification(Box::new(e)))
+			});
+
+		let fut = async move {
+			let stream = match submit.await {
+				Ok(stream) => stream,
+				Err(err) => {
+					let _ = sink.reject(JsonRpseeError::from(err));
+					return
+				},
+			};
+
+			sink.pipe_from_stream(stream).await;
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+		Ok(())
+	}
+}
diff --git a/substrate/client/rpc/src/author/tests.rs b/substrate/client/rpc/src/author/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f48b2f9571428a8415e9a4a106704f2d662de88c
--- /dev/null
+++ b/substrate/client/rpc/src/author/tests.rs
@@ -0,0 +1,330 @@
+// 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::*;
+
+use crate::testing::{test_executor, timeout_secs};
+use assert_matches::assert_matches;
+use codec::Encode;
+use jsonrpsee::{
+	core::Error as RpcError,
+	types::{error::CallError, EmptyServerParams as EmptyParams},
+	RpcModule,
+};
+use sc_transaction_pool::{BasicPool, FullChainApi};
+use sc_transaction_pool_api::TransactionStatus;
+use sp_core::{
+	blake2_256,
+	bytes::to_hex,
+	crypto::{ByteArray, Pair},
+	ed25519,
+	testing::{ED25519, SR25519},
+	H256,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore};
+use sp_runtime::Perbill;
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	self,
+	runtime::{Block, Extrinsic, ExtrinsicBuilder, SessionKeys, Transfer},
+	AccountKeyring, Backend, Client, DefaultTestClientBuilderExt, TestClientBuilderExt,
+};
+
+fn uxt(sender: AccountKeyring, nonce: u64) -> Extrinsic {
+	let tx = Transfer {
+		amount: Default::default(),
+		nonce,
+		from: sender.into(),
+		to: AccountKeyring::Bob.into(),
+	};
+	ExtrinsicBuilder::new_transfer(tx).build()
+}
+
+type FullTransactionPool = BasicPool<FullChainApi<Client<Backend>, Block>, Block>;
+
+struct TestSetup {
+	pub client: Arc<Client<Backend>>,
+	pub keystore: Arc<MemoryKeystore>,
+	pub pool: Arc<FullTransactionPool>,
+}
+
+impl Default for TestSetup {
+	fn default() -> Self {
+		let keystore = Arc::new(MemoryKeystore::new());
+		let client = Arc::new(substrate_test_runtime_client::TestClientBuilder::new().build());
+
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let pool =
+			BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
+		TestSetup { client, keystore, pool }
+	}
+}
+
+impl TestSetup {
+	fn author(&self) -> Author<FullTransactionPool, Client<Backend>> {
+		Author {
+			client: self.client.clone(),
+			pool: self.pool.clone(),
+			keystore: self.keystore.clone(),
+			deny_unsafe: DenyUnsafe::No,
+			executor: test_executor(),
+		}
+	}
+
+	fn into_rpc() -> RpcModule<Author<FullTransactionPool, Client<Backend>>> {
+		Self::default().author().into_rpc()
+	}
+}
+
+#[tokio::test]
+async fn author_submit_transaction_should_not_cause_error() {
+	let _ = env_logger::try_init();
+	let author = TestSetup::default().author();
+	let api = author.into_rpc();
+	let xt: Bytes = uxt(AccountKeyring::Alice, 1).encode().into();
+	let extrinsic_hash: H256 = blake2_256(&xt).into();
+	let response: H256 = api.call("author_submitExtrinsic", [xt.clone()]).await.unwrap();
+
+	assert_eq!(response, extrinsic_hash);
+
+	assert_matches!(
+		api.call::<_, H256>("author_submitExtrinsic", [xt]).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Already Imported") && err.code() == 1013
+	);
+}
+
+#[tokio::test]
+async fn author_should_watch_extrinsic() {
+	let api = TestSetup::into_rpc();
+	let xt = to_hex(
+		&ExtrinsicBuilder::new_call_with_priority(0)
+			.signer(AccountKeyring::Alice.into())
+			.build()
+			.encode(),
+		true,
+	);
+
+	let mut sub = api.subscribe("author_submitAndWatchExtrinsic", [xt]).await.unwrap();
+	let (tx, sub_id) = timeout_secs(10, sub.next::<TransactionStatus<H256, Block>>())
+		.await
+		.unwrap()
+		.unwrap()
+		.unwrap();
+
+	assert_matches!(tx, TransactionStatus::Ready);
+	assert_eq!(&sub_id, sub.subscription_id());
+
+	// Replace the extrinsic and observe the subscription is notified.
+	let (xt_replacement, xt_hash) = {
+		let tx = ExtrinsicBuilder::new_call_with_priority(1)
+			.signer(AccountKeyring::Alice.into())
+			.build()
+			.encode();
+		let hash = blake2_256(&tx);
+		(to_hex(&tx, true), hash)
+	};
+
+	let _ = api.call::<_, H256>("author_submitExtrinsic", [xt_replacement]).await.unwrap();
+
+	let (tx, sub_id) = timeout_secs(10, sub.next::<TransactionStatus<H256, Block>>())
+		.await
+		.unwrap()
+		.unwrap()
+		.unwrap();
+	assert_eq!(tx, TransactionStatus::Usurped(xt_hash.into()));
+	assert_eq!(&sub_id, sub.subscription_id());
+}
+
+#[tokio::test]
+async fn author_should_return_watch_validation_error() {
+	const METHOD: &'static str = "author_submitAndWatchExtrinsic";
+
+	let invalid_xt = ExtrinsicBuilder::new_fill_block(Perbill::from_percent(100)).build();
+
+	let api = TestSetup::into_rpc();
+	let failed_sub = api.subscribe(METHOD, [to_hex(&invalid_xt.encode(), true)]).await;
+
+	assert_matches!(
+		failed_sub,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Invalid Transaction") && err.code() == 1010
+	);
+}
+
+#[tokio::test]
+async fn author_should_return_pending_extrinsics() {
+	let api = TestSetup::into_rpc();
+
+	let xt_bytes: Bytes = uxt(AccountKeyring::Alice, 0).encode().into();
+	api.call::<_, H256>("author_submitExtrinsic", [to_hex(&xt_bytes, true)])
+		.await
+		.unwrap();
+
+	let pending: Vec<Bytes> =
+		api.call("author_pendingExtrinsics", EmptyParams::new()).await.unwrap();
+	assert_eq!(pending, vec![xt_bytes]);
+}
+
+#[tokio::test]
+async fn author_should_remove_extrinsics() {
+	const METHOD: &'static str = "author_removeExtrinsic";
+	let setup = TestSetup::default();
+	let api = setup.author().into_rpc();
+
+	// Submit three extrinsics, then remove two of them (will cause the third to be removed as well,
+	// having a higher nonce)
+	let xt1_bytes = uxt(AccountKeyring::Alice, 0).encode();
+	let xt1 = to_hex(&xt1_bytes, true);
+	let xt1_hash: H256 = api.call("author_submitExtrinsic", [xt1]).await.unwrap();
+
+	let xt2 = to_hex(&uxt(AccountKeyring::Alice, 1).encode(), true);
+	let xt2_hash: H256 = api.call("author_submitExtrinsic", [xt2]).await.unwrap();
+
+	let xt3 = to_hex(&uxt(AccountKeyring::Bob, 0).encode(), true);
+	let xt3_hash: H256 = api.call("author_submitExtrinsic", [xt3]).await.unwrap();
+	assert_eq!(setup.pool.status().ready, 3);
+
+	// Now remove all three.
+	// Notice how we need an extra `Vec` wrapping the `Vec` we want to submit as params.
+	let removed: Vec<H256> = api
+		.call(
+			METHOD,
+			vec![vec![
+				hash::ExtrinsicOrHash::Hash(xt3_hash),
+				// Removing this one will also remove xt2
+				hash::ExtrinsicOrHash::Extrinsic(xt1_bytes.into()),
+			]],
+		)
+		.await
+		.unwrap();
+
+	assert_eq!(removed, vec![xt1_hash, xt2_hash, xt3_hash]);
+}
+
+#[tokio::test]
+async fn author_should_insert_key() {
+	let setup = TestSetup::default();
+	let api = setup.author().into_rpc();
+	let suri = "//Alice";
+	let keypair = ed25519::Pair::from_string(suri, None).expect("generates keypair");
+	let params: (String, String, Bytes) = (
+		String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
+		suri.to_string(),
+		keypair.public().0.to_vec().into(),
+	);
+	api.call::<_, ()>("author_insertKey", params).await.unwrap();
+	let pubkeys = setup.keystore.keys(ED25519).unwrap();
+
+	assert!(pubkeys.contains(&keypair.public().to_raw_vec()));
+}
+
+#[tokio::test]
+async fn author_should_rotate_keys() {
+	let setup = TestSetup::default();
+	let api = setup.author().into_rpc();
+
+	let new_pubkeys: Bytes = api.call("author_rotateKeys", EmptyParams::new()).await.unwrap();
+	let session_keys =
+		SessionKeys::decode(&mut &new_pubkeys[..]).expect("SessionKeys decode successfully");
+	let ed25519_pubkeys = setup.keystore.keys(ED25519).unwrap();
+	let sr25519_pubkeys = setup.keystore.keys(SR25519).unwrap();
+	assert!(ed25519_pubkeys.contains(&session_keys.ed25519.to_raw_vec()));
+	assert!(sr25519_pubkeys.contains(&session_keys.sr25519.to_raw_vec()));
+}
+
+#[tokio::test]
+async fn author_has_session_keys() {
+	// Setup
+	let api = TestSetup::into_rpc();
+
+	// Add a valid session key
+	let pubkeys: Bytes = api
+		.call("author_rotateKeys", EmptyParams::new())
+		.await
+		.expect("Rotates the keys");
+
+	// Add a session key in a different keystore
+	let non_existent_pubkeys: Bytes = {
+		let api2 = TestSetup::default().author().into_rpc();
+		api2.call("author_rotateKeys", EmptyParams::new())
+			.await
+			.expect("Rotates the keys")
+	};
+
+	// Then…
+	let existing = api.call::<_, bool>("author_hasSessionKeys", vec![pubkeys]).await.unwrap();
+	assert!(existing, "Existing key is in the session keys");
+
+	let inexistent = api
+		.call::<_, bool>("author_hasSessionKeys", vec![non_existent_pubkeys])
+		.await
+		.unwrap();
+	assert_eq!(inexistent, false, "Inexistent key is not in the session keys");
+
+	assert_matches!(
+		api.call::<_, bool>("author_hasSessionKeys", vec![Bytes::from(vec![1, 2, 3])]).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Session keys are not encoded correctly")
+	);
+}
+
+#[tokio::test]
+async fn author_has_key() {
+	let _ = env_logger::try_init();
+
+	let api = TestSetup::into_rpc();
+	let suri = "//Alice";
+	let alice_keypair = ed25519::Pair::from_string(suri, None).expect("Generates keypair");
+	let params = (
+		String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
+		suri.to_string(),
+		Bytes::from(alice_keypair.public().0.to_vec()),
+	);
+
+	api.call::<_, ()>("author_insertKey", params).await.expect("insertKey works");
+
+	let bob_keypair = ed25519::Pair::from_string("//Bob", None).expect("Generates keypair");
+
+	// Alice's ED25519 key is there
+	let has_alice_ed: bool = {
+		let params = (
+			Bytes::from(alice_keypair.public().to_raw_vec()),
+			String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
+		);
+		api.call("author_hasKey", params).await.unwrap()
+	};
+	assert!(has_alice_ed);
+
+	// Alice's SR25519 key is not there
+	let has_alice_sr: bool = {
+		let params = (
+			Bytes::from(alice_keypair.public().to_raw_vec()),
+			String::from_utf8(SR25519.0.to_vec()).expect("Keytype is a valid string"),
+		);
+		api.call("author_hasKey", params).await.unwrap()
+	};
+	assert!(!has_alice_sr);
+
+	// Bob's ED25519 key is not there
+	let has_bob_ed: bool = {
+		let params = (
+			Bytes::from(bob_keypair.public().to_raw_vec()),
+			String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
+		);
+		api.call("author_hasKey", params).await.unwrap()
+	};
+	assert!(!has_bob_ed);
+}
diff --git a/substrate/client/rpc/src/chain/chain_full.rs b/substrate/client/rpc/src/chain/chain_full.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a88291eb7bd350763239a3dec7e0010fbc71c71e
--- /dev/null
+++ b/substrate/client/rpc/src/chain/chain_full.rs
@@ -0,0 +1,147 @@
+// 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/>.
+
+//! Blockchain API backend for full nodes.
+
+use super::{client_err, ChainBackend, Error};
+use crate::SubscriptionTaskExecutor;
+use std::{marker::PhantomData, sync::Arc};
+
+use futures::{
+	future::{self, FutureExt},
+	stream::{self, Stream, StreamExt},
+};
+use jsonrpsee::SubscriptionSink;
+use sc_client_api::{BlockBackend, BlockchainEvents};
+use sp_blockchain::HeaderBackend;
+use sp_runtime::{generic::SignedBlock, traits::Block as BlockT};
+
+/// Blockchain API backend for full nodes. Reads all the data from local database.
+pub struct FullChain<Block: BlockT, Client> {
+	/// Substrate client.
+	client: Arc<Client>,
+	/// phantom member to pin the block type
+	_phantom: PhantomData<Block>,
+	/// Subscription executor.
+	executor: SubscriptionTaskExecutor,
+}
+
+impl<Block: BlockT, Client> FullChain<Block, Client> {
+	/// Create new Chain API RPC handler.
+	pub fn new(client: Arc<Client>, executor: SubscriptionTaskExecutor) -> Self {
+		Self { client, executor, _phantom: PhantomData }
+	}
+}
+
+impl<Block, Client> ChainBackend<Client, Block> for FullChain<Block, Client>
+where
+	Block: BlockT + 'static,
+	Block::Header: Unpin,
+	Client: BlockBackend<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
+{
+	fn client(&self) -> &Arc<Client> {
+		&self.client
+	}
+
+	fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error> {
+		self.client.header(self.unwrap_or_best(hash)).map_err(client_err)
+	}
+
+	fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error> {
+		self.client.block(self.unwrap_or_best(hash)).map_err(client_err)
+	}
+
+	fn subscribe_all_heads(&self, sink: SubscriptionSink) {
+		subscribe_headers(
+			&self.client,
+			&self.executor,
+			sink,
+			|| self.client().info().best_hash,
+			|| {
+				self.client()
+					.import_notification_stream()
+					.map(|notification| notification.header)
+			},
+		)
+	}
+
+	fn subscribe_new_heads(&self, sink: SubscriptionSink) {
+		subscribe_headers(
+			&self.client,
+			&self.executor,
+			sink,
+			|| self.client().info().best_hash,
+			|| {
+				self.client()
+					.import_notification_stream()
+					.filter(|notification| future::ready(notification.is_new_best))
+					.map(|notification| notification.header)
+			},
+		)
+	}
+
+	fn subscribe_finalized_heads(&self, sink: SubscriptionSink) {
+		subscribe_headers(
+			&self.client,
+			&self.executor,
+			sink,
+			|| self.client().info().finalized_hash,
+			|| {
+				self.client()
+					.finality_notification_stream()
+					.map(|notification| notification.header)
+			},
+		)
+	}
+}
+
+/// Subscribe to new headers.
+fn subscribe_headers<Block, Client, F, G, S>(
+	client: &Arc<Client>,
+	executor: &SubscriptionTaskExecutor,
+	mut sink: SubscriptionSink,
+	best_block_hash: G,
+	stream: F,
+) where
+	Block: BlockT + 'static,
+	Block::Header: Unpin,
+	Client: HeaderBackend<Block> + 'static,
+	F: FnOnce() -> S,
+	G: FnOnce() -> Block::Hash,
+	S: Stream<Item = Block::Header> + Send + Unpin + 'static,
+{
+	// send current head right at the start.
+	let maybe_header = client
+		.header(best_block_hash())
+		.map_err(client_err)
+		.and_then(|header| header.ok_or_else(|| Error::Other("Best header missing.".into())))
+		.map_err(|e| log::warn!("Best header error {:?}", e))
+		.ok();
+
+	// NOTE: by the time we set up the stream there might be a new best block and so there is a risk
+	// that the stream has a hole in it. The alternative would be to look up the best block *after*
+	// we set up the stream and chain it to the stream. Consuming code would need to handle
+	// duplicates at the beginning of the stream though.
+	let stream = stream::iter(maybe_header).chain(stream());
+
+	let fut = async move {
+		sink.pipe_from_stream(stream).await;
+	};
+
+	executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+}
diff --git a/substrate/client/rpc/src/chain/mod.rs b/substrate/client/rpc/src/chain/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2b5994f217df3d9c6baea3b1364f7f6b62d4ad71
--- /dev/null
+++ b/substrate/client/rpc/src/chain/mod.rs
@@ -0,0 +1,177 @@
+// 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/>.
+
+//! Substrate blockchain API.
+
+mod chain_full;
+
+#[cfg(test)]
+mod tests;
+
+use std::sync::Arc;
+
+use crate::SubscriptionTaskExecutor;
+
+use jsonrpsee::{core::RpcResult, types::SubscriptionResult, SubscriptionSink};
+use sc_client_api::BlockchainEvents;
+use sp_rpc::{list::ListOrValue, number::NumberOrHex};
+use sp_runtime::{
+	generic::SignedBlock,
+	traits::{Block as BlockT, NumberFor},
+};
+
+use self::error::Error;
+
+use sc_client_api::BlockBackend;
+pub use sc_rpc_api::chain::*;
+use sp_blockchain::HeaderBackend;
+
+/// Blockchain backend API
+trait ChainBackend<Client, Block: BlockT>: Send + Sync + 'static
+where
+	Block: BlockT + 'static,
+	Block::Header: Unpin,
+	Client: HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
+{
+	/// Get client reference.
+	fn client(&self) -> &Arc<Client>;
+
+	/// Tries to unwrap passed block hash, or uses best block hash otherwise.
+	fn unwrap_or_best(&self, hash: Option<Block::Hash>) -> Block::Hash {
+		match hash {
+			None => self.client().info().best_hash,
+			Some(hash) => hash,
+		}
+	}
+
+	/// Get header of a block.
+	fn header(&self, hash: Option<Block::Hash>) -> Result<Option<Block::Header>, Error>;
+
+	/// Get header and body of a block.
+	fn block(&self, hash: Option<Block::Hash>) -> Result<Option<SignedBlock<Block>>, Error>;
+
+	/// Get hash of the n-th block in the canon chain.
+	///
+	/// By default returns latest block hash.
+	fn block_hash(&self, number: Option<NumberOrHex>) -> Result<Option<Block::Hash>, Error> {
+		match number {
+			None => Ok(Some(self.client().info().best_hash)),
+			Some(num_or_hex) => {
+				// FIXME <2329>: Database seems to limit the block number to u32 for no reason
+				let block_num: u32 = num_or_hex.try_into().map_err(|_| {
+					Error::Other(format!(
+						"`{:?}` > u32::MAX, the max block number is u32.",
+						num_or_hex
+					))
+				})?;
+				let block_num = <NumberFor<Block>>::from(block_num);
+				self.client().hash(block_num).map_err(client_err)
+			},
+		}
+	}
+
+	/// Get hash of the last finalized block in the canon chain.
+	fn finalized_head(&self) -> Result<Block::Hash, Error> {
+		Ok(self.client().info().finalized_hash)
+	}
+
+	/// All new head subscription
+	fn subscribe_all_heads(&self, sink: SubscriptionSink);
+
+	/// New best head subscription
+	fn subscribe_new_heads(&self, sink: SubscriptionSink);
+
+	/// Finalized head subscription
+	fn subscribe_finalized_heads(&self, sink: SubscriptionSink);
+}
+
+/// Create new state API that works on full node.
+pub fn new_full<Block: BlockT, Client>(
+	client: Arc<Client>,
+	executor: SubscriptionTaskExecutor,
+) -> Chain<Block, Client>
+where
+	Block: BlockT + 'static,
+	Block::Header: Unpin,
+	Client: BlockBackend<Block> + HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
+{
+	Chain { backend: Box::new(self::chain_full::FullChain::new(client, executor)) }
+}
+
+/// Chain API with subscriptions support.
+pub struct Chain<Block: BlockT, Client> {
+	backend: Box<dyn ChainBackend<Client, Block>>,
+}
+
+impl<Block, Client> ChainApiServer<NumberFor<Block>, Block::Hash, Block::Header, SignedBlock<Block>>
+	for Chain<Block, Client>
+where
+	Block: BlockT + 'static,
+	Block::Header: Unpin,
+	Client: HeaderBackend<Block> + BlockchainEvents<Block> + 'static,
+{
+	fn header(&self, hash: Option<Block::Hash>) -> RpcResult<Option<Block::Header>> {
+		self.backend.header(hash).map_err(Into::into)
+	}
+
+	fn block(&self, hash: Option<Block::Hash>) -> RpcResult<Option<SignedBlock<Block>>> {
+		self.backend.block(hash).map_err(Into::into)
+	}
+
+	fn block_hash(
+		&self,
+		number: Option<ListOrValue<NumberOrHex>>,
+	) -> RpcResult<ListOrValue<Option<Block::Hash>>> {
+		match number {
+			None => self.backend.block_hash(None).map(ListOrValue::Value).map_err(Into::into),
+			Some(ListOrValue::Value(number)) => self
+				.backend
+				.block_hash(Some(number))
+				.map(ListOrValue::Value)
+				.map_err(Into::into),
+			Some(ListOrValue::List(list)) => Ok(ListOrValue::List(
+				list.into_iter()
+					.map(|number| self.backend.block_hash(Some(number)))
+					.collect::<Result<_, _>>()?,
+			)),
+		}
+	}
+
+	fn finalized_head(&self) -> RpcResult<Block::Hash> {
+		self.backend.finalized_head().map_err(Into::into)
+	}
+
+	fn subscribe_all_heads(&self, sink: SubscriptionSink) -> SubscriptionResult {
+		self.backend.subscribe_all_heads(sink);
+		Ok(())
+	}
+
+	fn subscribe_new_heads(&self, sink: SubscriptionSink) -> SubscriptionResult {
+		self.backend.subscribe_new_heads(sink);
+		Ok(())
+	}
+
+	fn subscribe_finalized_heads(&self, sink: SubscriptionSink) -> SubscriptionResult {
+		self.backend.subscribe_finalized_heads(sink);
+		Ok(())
+	}
+}
+
+fn client_err(err: sp_blockchain::Error) -> Error {
+	Error::Client(Box::new(err))
+}
diff --git a/substrate/client/rpc/src/chain/tests.rs b/substrate/client/rpc/src/chain/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..75211a43bd9f1f5a5aa5e5cbb6bbd6e54e205728
--- /dev/null
+++ b/substrate/client/rpc/src/chain/tests.rs
@@ -0,0 +1,247 @@
+// 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::*;
+use crate::testing::{test_executor, timeout_secs};
+use assert_matches::assert_matches;
+use jsonrpsee::types::EmptyServerParams as EmptyParams;
+use sc_block_builder::BlockBuilderProvider;
+use sp_consensus::BlockOrigin;
+use sp_rpc::list::ListOrValue;
+use substrate_test_runtime_client::{
+	prelude::*,
+	runtime::{Block, Header, H256},
+};
+
+#[tokio::test]
+async fn should_return_header() {
+	let client = Arc::new(substrate_test_runtime_client::new());
+	let api = new_full(client.clone(), test_executor()).into_rpc();
+
+	let res: Header =
+		api.call("chain_getHeader", [H256::from(client.genesis_hash())]).await.unwrap();
+	assert_eq!(
+		res,
+		Header {
+			parent_hash: H256::from_low_u64_be(0),
+			number: 0,
+			state_root: res.state_root,
+			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+				.parse()
+				.unwrap(),
+			digest: Default::default(),
+		}
+	);
+
+	let res: Header = api.call("chain_getHeader", EmptyParams::new()).await.unwrap();
+	assert_eq!(
+		res,
+		Header {
+			parent_hash: H256::from_low_u64_be(0),
+			number: 0,
+			state_root: res.state_root,
+			extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+				.parse()
+				.unwrap(),
+			digest: Default::default(),
+		}
+	);
+
+	assert_matches!(
+		api.call::<_, Option<Header>>("chain_getHeader", [H256::from_low_u64_be(5)])
+			.await
+			.unwrap(),
+		None
+	);
+}
+
+#[tokio::test]
+async fn should_return_a_block() {
+	let mut client = Arc::new(substrate_test_runtime_client::new());
+	let api = new_full(client.clone(), test_executor()).into_rpc();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_hash = block.hash();
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
+	let res: SignedBlock<Block> =
+		api.call("chain_getBlock", [H256::from(client.genesis_hash())]).await.unwrap();
+
+	// Genesis block is not justified
+	assert!(res.justifications.is_none());
+
+	let res: SignedBlock<Block> =
+		api.call("chain_getBlock", [H256::from(block_hash)]).await.unwrap();
+	assert_eq!(
+		res.block,
+		Block {
+			header: Header {
+				parent_hash: client.genesis_hash(),
+				number: 1,
+				state_root: res.block.header.state_root,
+				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+					.parse()
+					.unwrap(),
+				digest: Default::default(),
+			},
+			extrinsics: vec![],
+		}
+	);
+
+	let res: SignedBlock<Block> = api.call("chain_getBlock", Vec::<H256>::new()).await.unwrap();
+	assert_eq!(
+		res.block,
+		Block {
+			header: Header {
+				parent_hash: client.genesis_hash(),
+				number: 1,
+				state_root: res.block.header.state_root,
+				extrinsics_root: "03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314"
+					.parse()
+					.unwrap(),
+				digest: Default::default(),
+			},
+			extrinsics: vec![],
+		}
+	);
+
+	assert_matches!(
+		api.call::<_, Option<Header>>("chain_getBlock", [H256::from_low_u64_be(5)])
+			.await
+			.unwrap(),
+		None
+	);
+}
+
+#[tokio::test]
+async fn should_return_block_hash() {
+	let mut client = Arc::new(substrate_test_runtime_client::new());
+	let api = new_full(client.clone(), test_executor()).into_rpc();
+
+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", EmptyParams::new()).await.unwrap();
+
+	assert_matches!(
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &client.genesis_hash()
+	);
+
+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(0_u64)]).await.unwrap();
+	assert_matches!(
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &client.genesis_hash()
+	);
+
+	let res: Option<ListOrValue<Option<H256>>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(1_u64)]).await.unwrap();
+	assert_matches!(res, None);
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block.clone()).await.unwrap();
+
+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(0_u64)]).await.unwrap();
+	assert_matches!(
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &client.genesis_hash()
+	);
+
+	let res: ListOrValue<Option<H256>> =
+		api.call("chain_getBlockHash", [ListOrValue::from(1_u64)]).await.unwrap();
+	assert_matches!(
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &block.hash()
+	);
+
+	let res: ListOrValue<Option<H256>> = api
+		.call("chain_getBlockHash", [ListOrValue::Value(sp_core::U256::from(1_u64))])
+		.await
+		.unwrap();
+	assert_matches!(
+		res,
+		ListOrValue::Value(Some(ref x)) if x == &block.hash()
+	);
+
+	let res: ListOrValue<Option<H256>> = api
+		.call("chain_getBlockHash", [ListOrValue::List(vec![0_u64, 1_u64, 2_u64])])
+		.await
+		.unwrap();
+	assert_matches!(
+		res,
+		ListOrValue::List(list) if list == &[client.genesis_hash().into(), block.hash().into(), None]
+	);
+}
+
+#[tokio::test]
+async fn should_return_finalized_hash() {
+	let mut client = Arc::new(substrate_test_runtime_client::new());
+	let api = new_full(client.clone(), test_executor()).into_rpc();
+
+	let res: H256 = api.call("chain_getFinalizedHead", EmptyParams::new()).await.unwrap();
+	assert_eq!(res, client.genesis_hash());
+
+	// import new block
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	let block_hash = block.hash();
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
+	// no finalization yet
+	let res: H256 = api.call("chain_getFinalizedHead", EmptyParams::new()).await.unwrap();
+	assert_eq!(res, client.genesis_hash());
+
+	// finalize
+	client.finalize_block(block_hash, None).unwrap();
+	let res: H256 = api.call("chain_getFinalizedHead", EmptyParams::new()).await.unwrap();
+	assert_eq!(res, block_hash);
+}
+
+#[tokio::test]
+async fn should_notify_about_latest_block() {
+	test_head_subscription("chain_subscribeAllHeads").await;
+}
+
+#[tokio::test]
+async fn should_notify_about_best_block() {
+	test_head_subscription("chain_subscribeNewHeads").await;
+}
+
+#[tokio::test]
+async fn should_notify_about_finalized_block() {
+	test_head_subscription("chain_subscribeFinalizedHeads").await;
+}
+
+async fn test_head_subscription(method: &str) {
+	let mut client = Arc::new(substrate_test_runtime_client::new());
+
+	let mut sub = {
+		let api = new_full(client.clone(), test_executor()).into_rpc();
+		let sub = api.subscribe(method, EmptyParams::new()).await.unwrap();
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+		let block_hash = block.hash();
+		client.import(BlockOrigin::Own, block).await.unwrap();
+		client.finalize_block(block_hash, None).unwrap();
+		sub
+	};
+
+	assert_matches!(timeout_secs(10, sub.next::<Header>()).await, Ok(Some(_)));
+	assert_matches!(timeout_secs(10, sub.next::<Header>()).await, Ok(Some(_)));
+
+	sub.close();
+	assert_matches!(timeout_secs(10, sub.next::<Header>()).await, Ok(None));
+}
diff --git a/substrate/client/rpc/src/dev/mod.rs b/substrate/client/rpc/src/dev/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d2e8618d553ac27d78b0437f8f1ccfa0af86902
--- /dev/null
+++ b/substrate/client/rpc/src/dev/mod.rs
@@ -0,0 +1,113 @@
+// 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/>.
+
+//! Implementation of the [`DevApiServer`] trait providing debug utilities for Substrate based
+//! blockchains.
+
+#[cfg(test)]
+mod tests;
+
+use jsonrpsee::core::RpcResult;
+use sc_client_api::{BlockBackend, HeaderBackend};
+use sc_rpc_api::{dev::error::Error, DenyUnsafe};
+use sp_api::{ApiExt, Core, ProvideRuntimeApi};
+use sp_core::Encode;
+use sp_runtime::{
+	generic::DigestItem,
+	traits::{Block as BlockT, Header},
+};
+use std::{
+	marker::{PhantomData, Send, Sync},
+	sync::Arc,
+};
+
+pub use sc_rpc_api::dev::{BlockStats, DevApiServer};
+
+type HasherOf<Block> = <<Block as BlockT>::Header as Header>::Hashing;
+
+/// The Dev API. All methods are unsafe.
+pub struct Dev<Block: BlockT, Client> {
+	client: Arc<Client>,
+	deny_unsafe: DenyUnsafe,
+	_phantom: PhantomData<Block>,
+}
+
+impl<Block: BlockT, Client> Dev<Block, Client> {
+	/// Create a new Dev API.
+	pub fn new(client: Arc<Client>, deny_unsafe: DenyUnsafe) -> Self {
+		Self { client, deny_unsafe, _phantom: PhantomData::default() }
+	}
+}
+
+impl<Block, Client> DevApiServer<Block::Hash> for Dev<Block, Client>
+where
+	Block: BlockT + 'static,
+	Client: BlockBackend<Block>
+		+ HeaderBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: Core<Block>,
+{
+	fn block_stats(&self, hash: Block::Hash) -> RpcResult<Option<BlockStats>> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let block = {
+			let block = self.client.block(hash).map_err(|e| Error::BlockQueryError(Box::new(e)))?;
+			if let Some(block) = block {
+				let (mut header, body) = block.block.deconstruct();
+				// Remove the `Seal` to ensure we have the number of digests as expected by the
+				// runtime.
+				header.digest_mut().logs.retain(|item| !matches!(item, DigestItem::Seal(_, _)));
+				Block::new(header, body)
+			} else {
+				return Ok(None)
+			}
+		};
+		let parent_header = {
+			let parent_hash = *block.header().parent_hash();
+			let parent_header = self
+				.client
+				.header(parent_hash)
+				.map_err(|e| Error::BlockQueryError(Box::new(e)))?;
+			if let Some(header) = parent_header {
+				header
+			} else {
+				return Ok(None)
+			}
+		};
+		let block_len = block.encoded_size() as u64;
+		let num_extrinsics = block.extrinsics().len() as u64;
+		let pre_root = *parent_header.state_root();
+		let mut runtime_api = self.client.runtime_api();
+		runtime_api.record_proof();
+		runtime_api
+			.execute_block(parent_header.hash(), block)
+			.map_err(|_| Error::BlockExecutionFailed)?;
+		let witness = runtime_api
+			.extract_proof()
+			.expect("We enabled proof recording. A proof must be available; qed");
+		let witness_len = witness.encoded_size() as u64;
+		let witness_compact_len = witness
+			.into_compact_proof::<HasherOf<Block>>(pre_root)
+			.map_err(|_| Error::WitnessCompactionFailed)?
+			.encoded_size() as u64;
+		Ok(Some(BlockStats { witness_len, witness_compact_len, block_len, num_extrinsics }))
+	}
+}
diff --git a/substrate/client/rpc/src/dev/tests.rs b/substrate/client/rpc/src/dev/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..db6a9a119da0a152e9c338c994e1fb724f621776
--- /dev/null
+++ b/substrate/client/rpc/src/dev/tests.rs
@@ -0,0 +1,92 @@
+// 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::*;
+use sc_block_builder::BlockBuilderProvider;
+use sp_blockchain::HeaderBackend;
+use sp_consensus::BlockOrigin;
+use substrate_test_runtime_client::{prelude::*, runtime::Block};
+
+#[tokio::test]
+async fn block_stats_work() {
+	let mut client = Arc::new(substrate_test_runtime_client::new());
+	let api = <Dev<Block, _>>::new(client.clone(), DenyUnsafe::No).into_rpc();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+
+	let (expected_witness_len, expected_witness_compact_len, expected_block_len) = {
+		let genesis_hash = client.chain_info().genesis_hash;
+		let mut runtime_api = client.runtime_api();
+		runtime_api.record_proof();
+		runtime_api.execute_block(genesis_hash, block.clone()).unwrap();
+		let witness = runtime_api.extract_proof().unwrap();
+		let pre_root = *client.header(genesis_hash).unwrap().unwrap().state_root();
+
+		(
+			witness.clone().encoded_size() as u64,
+			witness.into_compact_proof::<HasherOf<Block>>(pre_root).unwrap().encoded_size() as u64,
+			block.encoded_size() as u64,
+		)
+	};
+
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
+	// Can't gather stats for a block without a parent.
+	assert_eq!(
+		api.call::<_, Option<BlockStats>>("dev_getBlockStats", [client.genesis_hash()])
+			.await
+			.unwrap(),
+		None
+	);
+
+	assert_eq!(
+		api.call::<_, Option<BlockStats>>("dev_getBlockStats", [client.info().best_hash])
+			.await
+			.unwrap(),
+		Some(BlockStats {
+			witness_len: expected_witness_len,
+			witness_compact_len: expected_witness_compact_len,
+			block_len: expected_block_len,
+			num_extrinsics: 0,
+		}),
+	);
+}
+
+#[tokio::test]
+async fn deny_unsafe_works() {
+	let mut client = Arc::new(substrate_test_runtime_client::new());
+	let api = <Dev<Block, _>>::new(client.clone(), DenyUnsafe::Yes).into_rpc();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	client.import(BlockOrigin::Own, block).await.unwrap();
+
+	let best_hash = client.info().best_hash;
+	let best_hash_param =
+		serde_json::to_string(&best_hash).expect("To string must always succeed for block hashes");
+
+	let request = format!(
+		"{{\"jsonrpc\":\"2.0\",\"method\":\"dev_getBlockStats\",\"params\":[{}],\"id\":1}}",
+		best_hash_param
+	);
+	let (resp, _) = api.raw_json_request(&request).await.expect("Raw calls should succeed");
+
+	assert_eq!(
+		resp.result,
+		r#"{"jsonrpc":"2.0","error":{"code":-32601,"message":"RPC call is unsafe to be called externally"},"id":1}"#
+	);
+}
diff --git a/substrate/client/rpc/src/lib.rs b/substrate/client/rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..475fc77a9b5bd37bbe9b271287e8bb806a826bd9
--- /dev/null
+++ b/substrate/client/rpc/src/lib.rs
@@ -0,0 +1,46 @@
+// 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/>.
+
+//! Substrate RPC implementation.
+//!
+//! A core implementation of Substrate RPC interfaces.
+
+#![warn(missing_docs)]
+
+pub use jsonrpsee::core::{
+	id_providers::{
+		RandomIntegerIdProvider as RandomIntegerSubscriptionId,
+		RandomStringIdProvider as RandomStringSubscriptionId,
+	},
+	traits::IdProvider as RpcSubscriptionIdProvider,
+};
+pub use sc_rpc_api::DenyUnsafe;
+
+pub mod author;
+pub mod chain;
+pub mod dev;
+pub mod offchain;
+pub mod state;
+pub mod statement;
+pub mod system;
+
+#[cfg(any(test, feature = "test-helpers"))]
+pub mod testing;
+
+/// Task executor that is being used by RPC subscriptions.
+pub type SubscriptionTaskExecutor = std::sync::Arc<dyn sp_core::traits::SpawnNamed>;
diff --git a/substrate/client/rpc/src/offchain/mod.rs b/substrate/client/rpc/src/offchain/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..de711accdcc12083a2d37b5c2949fddb5fa0be66
--- /dev/null
+++ b/substrate/client/rpc/src/offchain/mod.rs
@@ -0,0 +1,74 @@
+// 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/>.
+
+//! Substrate offchain API.
+
+#[cfg(test)]
+mod tests;
+
+use self::error::Error;
+use jsonrpsee::core::{async_trait, Error as JsonRpseeError, RpcResult};
+use parking_lot::RwLock;
+/// Re-export the API for backward compatibility.
+pub use sc_rpc_api::offchain::*;
+use sc_rpc_api::DenyUnsafe;
+use sp_core::{
+	offchain::{OffchainStorage, StorageKind},
+	Bytes,
+};
+use std::sync::Arc;
+
+/// Offchain API
+#[derive(Debug)]
+pub struct Offchain<T: OffchainStorage> {
+	/// Offchain storage
+	storage: Arc<RwLock<T>>,
+	deny_unsafe: DenyUnsafe,
+}
+
+impl<T: OffchainStorage> Offchain<T> {
+	/// Create new instance of Offchain API.
+	pub fn new(storage: T, deny_unsafe: DenyUnsafe) -> Self {
+		Offchain { storage: Arc::new(RwLock::new(storage)), deny_unsafe }
+	}
+}
+
+#[async_trait]
+impl<T: OffchainStorage + 'static> OffchainApiServer for Offchain<T> {
+	fn set_local_storage(&self, kind: StorageKind, key: Bytes, value: Bytes) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let prefix = match kind {
+			StorageKind::PERSISTENT => sp_offchain::STORAGE_PREFIX,
+			StorageKind::LOCAL => return Err(JsonRpseeError::from(Error::UnavailableStorageKind)),
+		};
+		self.storage.write().set(prefix, &key, &value);
+		Ok(())
+	}
+
+	fn get_local_storage(&self, kind: StorageKind, key: Bytes) -> RpcResult<Option<Bytes>> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let prefix = match kind {
+			StorageKind::PERSISTENT => sp_offchain::STORAGE_PREFIX,
+			StorageKind::LOCAL => return Err(JsonRpseeError::from(Error::UnavailableStorageKind)),
+		};
+
+		Ok(self.storage.read().get(prefix, &key).map(Into::into))
+	}
+}
diff --git a/substrate/client/rpc/src/offchain/tests.rs b/substrate/client/rpc/src/offchain/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..62a846d0887cd4e78f2312b5ffed18ea3c215955
--- /dev/null
+++ b/substrate/client/rpc/src/offchain/tests.rs
@@ -0,0 +1,60 @@
+// 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::*;
+use assert_matches::assert_matches;
+use sp_core::{offchain::storage::InMemOffchainStorage, Bytes};
+
+#[test]
+fn local_storage_should_work() {
+	let storage = InMemOffchainStorage::default();
+	let offchain = Offchain::new(storage, DenyUnsafe::No);
+	let key = Bytes(b"offchain_storage".to_vec());
+	let value = Bytes(b"offchain_value".to_vec());
+
+	assert_matches!(
+		offchain.set_local_storage(StorageKind::PERSISTENT, key.clone(), value.clone()),
+		Ok(())
+	);
+	assert_matches!(
+		offchain.get_local_storage(StorageKind::PERSISTENT, key),
+		Ok(Some(ref v)) if *v == value
+	);
+}
+
+#[test]
+fn offchain_calls_considered_unsafe() {
+	use jsonrpsee::types::error::CallError;
+	let storage = InMemOffchainStorage::default();
+	let offchain = Offchain::new(storage, DenyUnsafe::Yes);
+	let key = Bytes(b"offchain_storage".to_vec());
+	let value = Bytes(b"offchain_value".to_vec());
+
+	assert_matches!(
+		offchain.set_local_storage(StorageKind::PERSISTENT, key.clone(), value.clone()),
+		Err(JsonRpseeError::Call(CallError::Custom(err))) => {
+			assert_eq!(err.message(), "RPC call is unsafe to be called externally")
+		}
+	);
+	assert_matches!(
+		offchain.get_local_storage(StorageKind::PERSISTENT, key),
+		Err(JsonRpseeError::Call(CallError::Custom(err))) => {
+			assert_eq!(err.message(), "RPC call is unsafe to be called externally")
+		}
+	);
+}
diff --git a/substrate/client/rpc/src/state/mod.rs b/substrate/client/rpc/src/state/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..057661d6ec7f56336ade8c2c9fe2da3186d5e661
--- /dev/null
+++ b/substrate/client/rpc/src/state/mod.rs
@@ -0,0 +1,500 @@
+// 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/>.
+
+//! Substrate state API.
+
+mod state_full;
+mod utils;
+
+#[cfg(test)]
+mod tests;
+
+use std::sync::Arc;
+
+use crate::SubscriptionTaskExecutor;
+
+use jsonrpsee::{
+	core::{async_trait, server::rpc_module::SubscriptionSink, Error as JsonRpseeError, RpcResult},
+	types::SubscriptionResult,
+};
+
+use sc_rpc_api::DenyUnsafe;
+use sp_core::{
+	storage::{PrefixedStorageKey, StorageChangeSet, StorageData, StorageKey},
+	Bytes,
+};
+use sp_runtime::traits::Block as BlockT;
+use sp_version::RuntimeVersion;
+
+use sp_api::{CallApiAt, Metadata, ProvideRuntimeApi};
+
+use self::error::Error;
+
+use sc_client_api::{
+	Backend, BlockBackend, BlockchainEvents, ExecutorProvider, ProofProvider, StorageProvider,
+};
+pub use sc_rpc_api::{child_state::*, state::*};
+use sp_blockchain::{HeaderBackend, HeaderMetadata};
+
+const STORAGE_KEYS_PAGED_MAX_COUNT: u32 = 1000;
+
+/// State backend API.
+#[async_trait]
+pub trait StateBackend<Block: BlockT, Client>: Send + Sync + 'static
+where
+	Block: BlockT + 'static,
+	Client: Send + Sync + 'static,
+{
+	/// Call runtime method at given block.
+	fn call(
+		&self,
+		block: Option<Block::Hash>,
+		method: String,
+		call_data: Bytes,
+	) -> Result<Bytes, Error>;
+
+	/// Returns the keys with prefix, leave empty to get all the keys.
+	fn storage_keys(
+		&self,
+		block: Option<Block::Hash>,
+		prefix: StorageKey,
+	) -> Result<Vec<StorageKey>, Error>;
+
+	/// Returns the keys with prefix along with their values, leave empty to get all the pairs.
+	fn storage_pairs(
+		&self,
+		block: Option<Block::Hash>,
+		prefix: StorageKey,
+	) -> Result<Vec<(StorageKey, StorageData)>, Error>;
+
+	/// Returns the keys with prefix with pagination support.
+	fn storage_keys_paged(
+		&self,
+		block: Option<Block::Hash>,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+	) -> Result<Vec<StorageKey>, Error>;
+
+	/// Returns a storage entry at a specific block's state.
+	fn storage(
+		&self,
+		block: Option<Block::Hash>,
+		key: StorageKey,
+	) -> Result<Option<StorageData>, Error>;
+
+	/// Returns the hash of a storage entry at a block's state.
+	fn storage_hash(
+		&self,
+		block: Option<Block::Hash>,
+		key: StorageKey,
+	) -> Result<Option<Block::Hash>, Error>;
+
+	/// Returns the size of a storage entry at a block's state.
+	///
+	/// If data is available at `key`, it is returned. Else, the sum of values who's key has `key`
+	/// prefix is returned, i.e. all the storage (double) maps that have this prefix.
+	async fn storage_size(
+		&self,
+		block: Option<Block::Hash>,
+		key: StorageKey,
+		deny_unsafe: DenyUnsafe,
+	) -> Result<Option<u64>, Error>;
+
+	/// Returns the runtime metadata as an opaque blob.
+	fn metadata(&self, block: Option<Block::Hash>) -> Result<Bytes, Error>;
+
+	/// Get the runtime version.
+	fn runtime_version(&self, block: Option<Block::Hash>) -> Result<RuntimeVersion, Error>;
+
+	/// Query historical storage entries (by key) starting from a block given as the second
+	/// parameter.
+	///
+	/// NOTE This first returned result contains the initial state of storage for all keys.
+	/// Subsequent values in the vector represent changes to the previous state (diffs).
+	fn query_storage(
+		&self,
+		from: Block::Hash,
+		to: Option<Block::Hash>,
+		keys: Vec<StorageKey>,
+	) -> Result<Vec<StorageChangeSet<Block::Hash>>, Error>;
+
+	/// Query storage entries (by key) starting at block hash given as the second parameter.
+	fn query_storage_at(
+		&self,
+		keys: Vec<StorageKey>,
+		at: Option<Block::Hash>,
+	) -> Result<Vec<StorageChangeSet<Block::Hash>>, Error>;
+
+	/// Returns proof of storage entries at a specific block's state.
+	fn read_proof(
+		&self,
+		block: Option<Block::Hash>,
+		keys: Vec<StorageKey>,
+	) -> Result<ReadProof<Block::Hash>, Error>;
+
+	/// Trace storage changes for block
+	fn trace_block(
+		&self,
+		block: Block::Hash,
+		targets: Option<String>,
+		storage_keys: Option<String>,
+		methods: Option<String>,
+	) -> Result<sp_rpc::tracing::TraceBlockResponse, Error>;
+
+	/// New runtime version subscription
+	fn subscribe_runtime_version(&self, sink: SubscriptionSink);
+
+	/// New storage subscription
+	fn subscribe_storage(&self, sink: SubscriptionSink, keys: Option<Vec<StorageKey>>);
+}
+
+/// Create new state API that works on full node.
+pub fn new_full<BE, Block: BlockT, Client>(
+	client: Arc<Client>,
+	executor: SubscriptionTaskExecutor,
+	deny_unsafe: DenyUnsafe,
+) -> (State<Block, Client>, ChildState<Block, Client>)
+where
+	Block: BlockT + 'static,
+	Block::Hash: Unpin,
+	BE: Backend<Block> + 'static,
+	Client: ExecutorProvider<Block>
+		+ StorageProvider<Block, BE>
+		+ ProofProvider<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ BlockchainEvents<Block>
+		+ CallApiAt<Block>
+		+ HeaderBackend<Block>
+		+ BlockBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: Metadata<Block>,
+{
+	let child_backend =
+		Box::new(self::state_full::FullState::new(client.clone(), executor.clone()));
+	let backend = Box::new(self::state_full::FullState::new(client, executor));
+	(State { backend, deny_unsafe }, ChildState { backend: child_backend })
+}
+
+/// State API with subscriptions support.
+pub struct State<Block, Client> {
+	backend: Box<dyn StateBackend<Block, Client>>,
+	/// Whether to deny unsafe calls
+	deny_unsafe: DenyUnsafe,
+}
+
+#[async_trait]
+impl<Block, Client> StateApiServer<Block::Hash> for State<Block, Client>
+where
+	Block: BlockT + 'static,
+	Client: Send + Sync + 'static,
+{
+	fn call(&self, method: String, data: Bytes, block: Option<Block::Hash>) -> RpcResult<Bytes> {
+		self.backend.call(block, method, data).map_err(Into::into)
+	}
+
+	fn storage_keys(
+		&self,
+		key_prefix: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Vec<StorageKey>> {
+		self.backend.storage_keys(block, key_prefix).map_err(Into::into)
+	}
+
+	fn storage_pairs(
+		&self,
+		key_prefix: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Vec<(StorageKey, StorageData)>> {
+		self.deny_unsafe.check_if_safe()?;
+		self.backend.storage_pairs(block, key_prefix).map_err(Into::into)
+	}
+
+	fn storage_keys_paged(
+		&self,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Vec<StorageKey>> {
+		if count > STORAGE_KEYS_PAGED_MAX_COUNT {
+			return Err(JsonRpseeError::from(Error::InvalidCount {
+				value: count,
+				max: STORAGE_KEYS_PAGED_MAX_COUNT,
+			}))
+		}
+		self.backend
+			.storage_keys_paged(block, prefix, count, start_key)
+			.map_err(Into::into)
+	}
+
+	fn storage(
+		&self,
+		key: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Option<StorageData>> {
+		self.backend.storage(block, key).map_err(Into::into)
+	}
+
+	fn storage_hash(
+		&self,
+		key: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Option<Block::Hash>> {
+		self.backend.storage_hash(block, key).map_err(Into::into)
+	}
+
+	async fn storage_size(
+		&self,
+		key: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Option<u64>> {
+		self.backend
+			.storage_size(block, key, self.deny_unsafe)
+			.await
+			.map_err(Into::into)
+	}
+
+	fn metadata(&self, block: Option<Block::Hash>) -> RpcResult<Bytes> {
+		self.backend.metadata(block).map_err(Into::into)
+	}
+
+	fn runtime_version(&self, at: Option<Block::Hash>) -> RpcResult<RuntimeVersion> {
+		self.backend.runtime_version(at).map_err(Into::into)
+	}
+
+	fn query_storage(
+		&self,
+		keys: Vec<StorageKey>,
+		from: Block::Hash,
+		to: Option<Block::Hash>,
+	) -> RpcResult<Vec<StorageChangeSet<Block::Hash>>> {
+		self.deny_unsafe.check_if_safe()?;
+		self.backend.query_storage(from, to, keys).map_err(Into::into)
+	}
+
+	fn query_storage_at(
+		&self,
+		keys: Vec<StorageKey>,
+		at: Option<Block::Hash>,
+	) -> RpcResult<Vec<StorageChangeSet<Block::Hash>>> {
+		self.backend.query_storage_at(keys, at).map_err(Into::into)
+	}
+
+	fn read_proof(
+		&self,
+		keys: Vec<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> RpcResult<ReadProof<Block::Hash>> {
+		self.backend.read_proof(block, keys).map_err(Into::into)
+	}
+
+	/// Re-execute the given block with the tracing targets given in `targets`
+	/// and capture all state changes.
+	///
+	/// Note: requires the node to run with `--rpc-methods=Unsafe`.
+	/// Note: requires runtimes compiled with wasm tracing support, `--features with-tracing`.
+	fn trace_block(
+		&self,
+		block: Block::Hash,
+		targets: Option<String>,
+		storage_keys: Option<String>,
+		methods: Option<String>,
+	) -> RpcResult<sp_rpc::tracing::TraceBlockResponse> {
+		self.deny_unsafe.check_if_safe()?;
+		self.backend
+			.trace_block(block, targets, storage_keys, methods)
+			.map_err(Into::into)
+	}
+
+	fn subscribe_runtime_version(&self, sink: SubscriptionSink) -> SubscriptionResult {
+		self.backend.subscribe_runtime_version(sink);
+		Ok(())
+	}
+
+	fn subscribe_storage(
+		&self,
+		mut sink: SubscriptionSink,
+		keys: Option<Vec<StorageKey>>,
+	) -> SubscriptionResult {
+		if keys.is_none() {
+			if let Err(err) = self.deny_unsafe.check_if_safe() {
+				let _ = sink.reject(JsonRpseeError::from(err));
+				return Ok(())
+			}
+		}
+
+		self.backend.subscribe_storage(sink, keys);
+		Ok(())
+	}
+}
+
+/// Child state backend API.
+pub trait ChildStateBackend<Block: BlockT, Client>: Send + Sync + 'static
+where
+	Block: BlockT + 'static,
+	Client: Send + Sync + 'static,
+{
+	/// Returns proof of storage for a child key entries at a specific block's state.
+	fn read_child_proof(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+	) -> Result<ReadProof<Block::Hash>, Error>;
+
+	/// Returns the keys with prefix from a child storage,
+	/// leave prefix empty to get all the keys.
+	fn storage_keys(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		prefix: StorageKey,
+	) -> Result<Vec<StorageKey>, Error>;
+
+	/// Returns the keys with prefix from a child storage with pagination support.
+	fn storage_keys_paged(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+	) -> Result<Vec<StorageKey>, Error>;
+
+	/// Returns a child storage entry at a specific block's state.
+	fn storage(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+	) -> Result<Option<StorageData>, Error>;
+
+	/// Returns child storage entries at a specific block's state.
+	fn storage_entries(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+	) -> Result<Vec<Option<StorageData>>, Error>;
+
+	/// Returns the hash of a child storage entry at a block's state.
+	fn storage_hash(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+	) -> Result<Option<Block::Hash>, Error>;
+
+	/// Returns the size of a child storage entry at a block's state.
+	fn storage_size(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+	) -> Result<Option<u64>, Error> {
+		self.storage(block, storage_key, key).map(|x| x.map(|x| x.0.len() as u64))
+	}
+}
+
+/// Child state API with subscriptions support.
+pub struct ChildState<Block, Client> {
+	backend: Box<dyn ChildStateBackend<Block, Client>>,
+}
+
+impl<Block, Client> ChildStateApiServer<Block::Hash> for ChildState<Block, Client>
+where
+	Block: BlockT + 'static,
+	Client: Send + Sync + 'static,
+{
+	fn storage_keys(
+		&self,
+		storage_key: PrefixedStorageKey,
+		key_prefix: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Vec<StorageKey>> {
+		self.backend.storage_keys(block, storage_key, key_prefix).map_err(Into::into)
+	}
+
+	fn storage_keys_paged(
+		&self,
+		storage_key: PrefixedStorageKey,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Vec<StorageKey>> {
+		self.backend
+			.storage_keys_paged(block, storage_key, prefix, count, start_key)
+			.map_err(Into::into)
+	}
+
+	fn storage(
+		&self,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Option<StorageData>> {
+		self.backend.storage(block, storage_key, key).map_err(Into::into)
+	}
+
+	fn storage_entries(
+		&self,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Vec<Option<StorageData>>> {
+		self.backend.storage_entries(block, storage_key, keys).map_err(Into::into)
+	}
+
+	fn storage_hash(
+		&self,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Option<Block::Hash>> {
+		self.backend.storage_hash(block, storage_key, key).map_err(Into::into)
+	}
+
+	fn storage_size(
+		&self,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+		block: Option<Block::Hash>,
+	) -> RpcResult<Option<u64>> {
+		self.backend.storage_size(block, storage_key, key).map_err(Into::into)
+	}
+
+	fn read_child_proof(
+		&self,
+		child_storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+		block: Option<Block::Hash>,
+	) -> RpcResult<ReadProof<Block::Hash>> {
+		self.backend
+			.read_child_proof(block, child_storage_key, keys)
+			.map_err(Into::into)
+	}
+}
+
+fn client_err(err: sp_blockchain::Error) -> Error {
+	Error::Client(Box::new(err))
+}
diff --git a/substrate/client/rpc/src/state/state_full.rs b/substrate/client/rpc/src/state/state_full.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9604d9165f987aed66474ca58fcf31f3dcd5c549
--- /dev/null
+++ b/substrate/client/rpc/src/state/state_full.rs
@@ -0,0 +1,640 @@
+// 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/>.
+
+//! State API backend for full nodes.
+
+use std::{collections::HashMap, marker::PhantomData, sync::Arc, time::Duration};
+
+use super::{
+	client_err,
+	error::{Error, Result},
+	ChildStateBackend, StateBackend,
+};
+use crate::{DenyUnsafe, SubscriptionTaskExecutor};
+
+use futures::{future, stream, FutureExt, StreamExt};
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError},
+	SubscriptionSink,
+};
+use sc_client_api::{
+	Backend, BlockBackend, BlockchainEvents, CallExecutor, ExecutorProvider, ProofProvider,
+	StorageProvider,
+};
+use sc_rpc_api::state::ReadProof;
+use sp_api::{CallApiAt, Metadata, ProvideRuntimeApi};
+use sp_blockchain::{
+	CachedHeaderMetadata, Error as ClientError, HeaderBackend, HeaderMetadata,
+	Result as ClientResult,
+};
+use sp_core::{
+	storage::{
+		ChildInfo, ChildType, PrefixedStorageKey, StorageChangeSet, StorageData, StorageKey,
+	},
+	traits::CallContext,
+	Bytes,
+};
+use sp_runtime::traits::Block as BlockT;
+use sp_version::RuntimeVersion;
+
+/// The maximum time allowed for an RPC call when running without unsafe RPC enabled.
+const MAXIMUM_SAFE_RPC_CALL_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Ranges to query in state_queryStorage.
+struct QueryStorageRange<Block: BlockT> {
+	/// Hashes of all the blocks in the range.
+	pub hashes: Vec<Block::Hash>,
+}
+
+/// State API backend for full nodes.
+pub struct FullState<BE, Block: BlockT, Client> {
+	client: Arc<Client>,
+	executor: SubscriptionTaskExecutor,
+	_phantom: PhantomData<(BE, Block)>,
+}
+
+impl<BE, Block: BlockT, Client> FullState<BE, Block, Client>
+where
+	BE: Backend<Block>,
+	Client: StorageProvider<Block, BE>
+		+ HeaderBackend<Block>
+		+ BlockBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>,
+	Block: BlockT + 'static,
+{
+	/// Create new state API backend for full nodes.
+	pub fn new(client: Arc<Client>, executor: SubscriptionTaskExecutor) -> Self {
+		Self { client, executor, _phantom: PhantomData }
+	}
+
+	/// Returns given block hash or best block hash if None is passed.
+	fn block_or_best(&self, hash: Option<Block::Hash>) -> ClientResult<Block::Hash> {
+		Ok(hash.unwrap_or_else(|| self.client.info().best_hash))
+	}
+
+	/// Validates block range.
+	fn query_storage_range(
+		&self,
+		from: Block::Hash,
+		to: Option<Block::Hash>,
+	) -> Result<QueryStorageRange<Block>> {
+		let to = self
+			.block_or_best(to)
+			.map_err(|e| invalid_block::<Block>(from, to, e.to_string()))?;
+
+		let invalid_block_err =
+			|e: ClientError| invalid_block::<Block>(from, Some(to), e.to_string());
+		let from_meta = self.client.header_metadata(from).map_err(invalid_block_err)?;
+		let to_meta = self.client.header_metadata(to).map_err(invalid_block_err)?;
+
+		if from_meta.number > to_meta.number {
+			return Err(invalid_block_range(
+				&from_meta,
+				&to_meta,
+				"from number > to number".to_owned(),
+			))
+		}
+
+		// check if we can get from `to` to `from` by going through parent_hashes.
+		let from_number = from_meta.number;
+		let hashes = {
+			let mut hashes = vec![to_meta.hash];
+			let mut last = to_meta.clone();
+			while last.number > from_number {
+				let header_metadata = self
+					.client
+					.header_metadata(last.parent)
+					.map_err(|e| invalid_block_range::<Block>(&last, &to_meta, e.to_string()))?;
+				hashes.push(header_metadata.hash);
+				last = header_metadata;
+			}
+			if last.hash != from_meta.hash {
+				return Err(invalid_block_range(
+					&from_meta,
+					&to_meta,
+					"from and to are on different forks".to_owned(),
+				))
+			}
+			hashes.reverse();
+			hashes
+		};
+
+		Ok(QueryStorageRange { hashes })
+	}
+
+	/// Iterates through range.unfiltered_range and check each block for changes of keys' values.
+	fn query_storage_unfiltered(
+		&self,
+		range: &QueryStorageRange<Block>,
+		keys: &[StorageKey],
+		last_values: &mut HashMap<StorageKey, Option<StorageData>>,
+		changes: &mut Vec<StorageChangeSet<Block::Hash>>,
+	) -> Result<()> {
+		for block_hash in &range.hashes {
+			let mut block_changes = StorageChangeSet { block: *block_hash, changes: Vec::new() };
+			for key in keys {
+				let (has_changed, data) = {
+					let curr_data = self.client.storage(*block_hash, key).map_err(client_err)?;
+					match last_values.get(key) {
+						Some(prev_data) => (curr_data != *prev_data, curr_data),
+						None => (true, curr_data),
+					}
+				};
+				if has_changed {
+					block_changes.changes.push((key.clone(), data.clone()));
+				}
+				last_values.insert(key.clone(), data);
+			}
+			if !block_changes.changes.is_empty() {
+				changes.push(block_changes);
+			}
+		}
+		Ok(())
+	}
+}
+
+#[async_trait]
+impl<BE, Block, Client> StateBackend<Block, Client> for FullState<BE, Block, Client>
+where
+	Block: BlockT + 'static,
+	Block::Hash: Unpin,
+	BE: Backend<Block> + 'static,
+	Client: ExecutorProvider<Block>
+		+ StorageProvider<Block, BE>
+		+ ProofProvider<Block>
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ BlockchainEvents<Block>
+		+ CallApiAt<Block>
+		+ ProvideRuntimeApi<Block>
+		+ BlockBackend<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: Metadata<Block>,
+{
+	fn call(
+		&self,
+		block: Option<Block::Hash>,
+		method: String,
+		call_data: Bytes,
+	) -> std::result::Result<Bytes, Error> {
+		self.block_or_best(block)
+			.and_then(|block| {
+				self.client
+					.executor()
+					.call(block, &method, &call_data, CallContext::Offchain)
+					.map(Into::into)
+			})
+			.map_err(client_err)
+	}
+
+	// TODO: This is horribly broken; either remove it, or make it streaming.
+	fn storage_keys(
+		&self,
+		block: Option<Block::Hash>,
+		prefix: StorageKey,
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		// TODO: Remove the `.collect`.
+		self.block_or_best(block)
+			.and_then(|block| self.client.storage_keys(block, Some(&prefix), None))
+			.map(|iter| iter.collect())
+			.map_err(client_err)
+	}
+
+	// TODO: This is horribly broken; either remove it, or make it streaming.
+	fn storage_pairs(
+		&self,
+		block: Option<Block::Hash>,
+		prefix: StorageKey,
+	) -> std::result::Result<Vec<(StorageKey, StorageData)>, Error> {
+		// TODO: Remove the `.collect`.
+		self.block_or_best(block)
+			.and_then(|block| self.client.storage_pairs(block, Some(&prefix), None))
+			.map(|iter| iter.collect())
+			.map_err(client_err)
+	}
+
+	fn storage_keys_paged(
+		&self,
+		block: Option<Block::Hash>,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| self.client.storage_keys(block, prefix.as_ref(), start_key.as_ref()))
+			.map(|iter| iter.take(count as usize).collect())
+			.map_err(client_err)
+	}
+
+	fn storage(
+		&self,
+		block: Option<Block::Hash>,
+		key: StorageKey,
+	) -> std::result::Result<Option<StorageData>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| self.client.storage(block, &key))
+			.map_err(client_err)
+	}
+
+	async fn storage_size(
+		&self,
+		block: Option<Block::Hash>,
+		key: StorageKey,
+		deny_unsafe: DenyUnsafe,
+	) -> std::result::Result<Option<u64>, Error> {
+		let block = match self.block_or_best(block) {
+			Ok(b) => b,
+			Err(e) => return Err(client_err(e)),
+		};
+
+		let client = self.client.clone();
+		let timeout = match deny_unsafe {
+			DenyUnsafe::Yes => Some(MAXIMUM_SAFE_RPC_CALL_TIMEOUT),
+			DenyUnsafe::No => None,
+		};
+
+		super::utils::spawn_blocking_with_timeout(timeout, move |is_timed_out| {
+			// Does the key point to a concrete entry in the database?
+			match client.storage(block, &key) {
+				Ok(Some(d)) => return Ok(Ok(Some(d.0.len() as u64))),
+				Err(e) => return Ok(Err(client_err(e))),
+				Ok(None) => {},
+			}
+
+			// The key doesn't point to anything, so it's probably a prefix.
+			let iter = match client.storage_keys(block, Some(&key), None).map_err(client_err) {
+				Ok(iter) => iter,
+				Err(e) => return Ok(Err(e)),
+			};
+
+			let mut sum = 0;
+			for storage_key in iter {
+				let value = client.storage(block, &storage_key).ok().flatten().unwrap_or_default();
+				sum += value.0.len() as u64;
+
+				is_timed_out.check_if_timed_out()?;
+			}
+
+			if sum > 0 {
+				Ok(Ok(Some(sum)))
+			} else {
+				Ok(Ok(None))
+			}
+		})
+		.await
+		.map_err(|error| Error::Client(Box::new(error)))?
+	}
+
+	fn storage_hash(
+		&self,
+		block: Option<Block::Hash>,
+		key: StorageKey,
+	) -> std::result::Result<Option<Block::Hash>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| self.client.storage_hash(block, &key))
+			.map_err(client_err)
+	}
+
+	fn metadata(&self, block: Option<Block::Hash>) -> std::result::Result<Bytes, Error> {
+		self.block_or_best(block).map_err(client_err).and_then(|block| {
+			self.client
+				.runtime_api()
+				.metadata(block)
+				.map(Into::into)
+				.map_err(|e| Error::Client(Box::new(e)))
+		})
+	}
+
+	fn runtime_version(
+		&self,
+		block: Option<Block::Hash>,
+	) -> std::result::Result<RuntimeVersion, Error> {
+		self.block_or_best(block).map_err(client_err).and_then(|block| {
+			self.client.runtime_version_at(block).map_err(|e| Error::Client(Box::new(e)))
+		})
+	}
+
+	fn query_storage(
+		&self,
+		from: Block::Hash,
+		to: Option<Block::Hash>,
+		keys: Vec<StorageKey>,
+	) -> std::result::Result<Vec<StorageChangeSet<Block::Hash>>, Error> {
+		let call_fn = move || {
+			let range = self.query_storage_range(from, to)?;
+			let mut changes = Vec::new();
+			let mut last_values = HashMap::new();
+			self.query_storage_unfiltered(&range, &keys, &mut last_values, &mut changes)?;
+			Ok(changes)
+		};
+		call_fn()
+	}
+
+	fn query_storage_at(
+		&self,
+		keys: Vec<StorageKey>,
+		at: Option<Block::Hash>,
+	) -> std::result::Result<Vec<StorageChangeSet<Block::Hash>>, Error> {
+		let at = at.unwrap_or_else(|| self.client.info().best_hash);
+		self.query_storage(at, Some(at), keys)
+	}
+
+	fn read_proof(
+		&self,
+		block: Option<Block::Hash>,
+		keys: Vec<StorageKey>,
+	) -> std::result::Result<ReadProof<Block::Hash>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| {
+				self.client
+					.read_proof(block, &mut keys.iter().map(|key| key.0.as_ref()))
+					.map(|proof| proof.into_iter_nodes().map(|node| node.into()).collect())
+					.map(|proof| ReadProof { at: block, proof })
+			})
+			.map_err(client_err)
+	}
+
+	fn subscribe_runtime_version(&self, mut sink: SubscriptionSink) {
+		let client = self.client.clone();
+
+		let initial = match self
+			.block_or_best(None)
+			.and_then(|block| self.client.runtime_version_at(block).map_err(Into::into))
+			.map_err(|e| Error::Client(Box::new(e)))
+		{
+			Ok(initial) => initial,
+			Err(e) => {
+				let _ = sink.reject(JsonRpseeError::from(e));
+				return
+			},
+		};
+
+		let mut previous_version = initial.clone();
+
+		// A stream of new versions
+		let version_stream = client
+			.import_notification_stream()
+			.filter(|n| future::ready(n.is_new_best))
+			.filter_map(move |n| {
+				let version =
+					client.runtime_version_at(n.hash).map_err(|e| Error::Client(Box::new(e)));
+
+				match version {
+					Ok(version) if version != previous_version => {
+						previous_version = version.clone();
+						future::ready(Some(version))
+					},
+					_ => future::ready(None),
+				}
+			});
+
+		let stream = futures::stream::once(future::ready(initial)).chain(version_stream);
+
+		let fut = async move {
+			sink.pipe_from_stream(stream).await;
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+	}
+
+	fn subscribe_storage(&self, mut sink: SubscriptionSink, keys: Option<Vec<StorageKey>>) {
+		let stream = match self.client.storage_changes_notification_stream(keys.as_deref(), None) {
+			Ok(stream) => stream,
+			Err(blockchain_err) => {
+				let _ = sink.reject(JsonRpseeError::from(Error::Client(Box::new(blockchain_err))));
+				return
+			},
+		};
+
+		// initial values
+		let initial = stream::iter(keys.map(|keys| {
+			let block = self.client.info().best_hash;
+			let changes = keys
+				.into_iter()
+				.map(|key| {
+					let v = self.client.storage(block, &key).ok().flatten();
+					(key, v)
+				})
+				.collect();
+			StorageChangeSet { block, changes }
+		}));
+
+		// let storage_stream = stream.map(|(block, changes)| StorageChangeSet {
+		let storage_stream = stream.map(|storage_notif| StorageChangeSet {
+			block: storage_notif.block,
+			changes: storage_notif
+				.changes
+				.iter()
+				.filter_map(|(o_sk, k, v)| o_sk.is_none().then(|| (k.clone(), v.cloned())))
+				.collect(),
+		});
+
+		let stream = initial
+			.chain(storage_stream)
+			.filter(|storage| future::ready(!storage.changes.is_empty()));
+
+		let fut = async move {
+			sink.pipe_from_stream(stream).await;
+		};
+
+		self.executor.spawn("substrate-rpc-subscription", Some("rpc"), fut.boxed());
+	}
+
+	fn trace_block(
+		&self,
+		block: Block::Hash,
+		targets: Option<String>,
+		storage_keys: Option<String>,
+		methods: Option<String>,
+	) -> std::result::Result<sp_rpc::tracing::TraceBlockResponse, Error> {
+		sc_tracing::block::BlockExecutor::new(
+			self.client.clone(),
+			block,
+			targets,
+			storage_keys,
+			methods,
+		)
+		.trace_block()
+		.map_err(|e| invalid_block::<Block>(block, None, e.to_string()))
+	}
+}
+
+impl<BE, Block, Client> ChildStateBackend<Block, Client> for FullState<BE, Block, Client>
+where
+	Block: BlockT + 'static,
+	BE: Backend<Block> + 'static,
+	Client: ExecutorProvider<Block>
+		+ StorageProvider<Block, BE>
+		+ ProofProvider<Block>
+		+ HeaderBackend<Block>
+		+ BlockBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ BlockchainEvents<Block>
+		+ CallApiAt<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: Metadata<Block>,
+{
+	fn read_child_proof(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+	) -> std::result::Result<ReadProof<Block::Hash>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| {
+				let child_info = match ChildType::from_prefixed_key(&storage_key) {
+					Some((ChildType::ParentKeyId, storage_key)) =>
+						ChildInfo::new_default(storage_key),
+					None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
+				};
+				self.client
+					.read_child_proof(
+						block,
+						&child_info,
+						&mut keys.iter().map(|key| key.0.as_ref()),
+					)
+					.map(|proof| proof.into_iter_nodes().map(|node| node.into()).collect())
+					.map(|proof| ReadProof { at: block, proof })
+			})
+			.map_err(client_err)
+	}
+
+	fn storage_keys(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		prefix: StorageKey,
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		// TODO: Remove the `.collect`.
+		self.block_or_best(block)
+			.and_then(|block| {
+				let child_info = match ChildType::from_prefixed_key(&storage_key) {
+					Some((ChildType::ParentKeyId, storage_key)) =>
+						ChildInfo::new_default(storage_key),
+					None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
+				};
+				self.client.child_storage_keys(block, child_info, Some(&prefix), None)
+			})
+			.map(|iter| iter.collect())
+			.map_err(client_err)
+	}
+
+	fn storage_keys_paged(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		prefix: Option<StorageKey>,
+		count: u32,
+		start_key: Option<StorageKey>,
+	) -> std::result::Result<Vec<StorageKey>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| {
+				let child_info = match ChildType::from_prefixed_key(&storage_key) {
+					Some((ChildType::ParentKeyId, storage_key)) =>
+						ChildInfo::new_default(storage_key),
+					None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
+				};
+				self.client.child_storage_keys(
+					block,
+					child_info,
+					prefix.as_ref(),
+					start_key.as_ref(),
+				)
+			})
+			.map(|iter| iter.take(count as usize).collect())
+			.map_err(client_err)
+	}
+
+	fn storage(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+	) -> std::result::Result<Option<StorageData>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| {
+				let child_info = match ChildType::from_prefixed_key(&storage_key) {
+					Some((ChildType::ParentKeyId, storage_key)) =>
+						ChildInfo::new_default(storage_key),
+					None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
+				};
+				self.client.child_storage(block, &child_info, &key)
+			})
+			.map_err(client_err)
+	}
+
+	fn storage_entries(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		keys: Vec<StorageKey>,
+	) -> std::result::Result<Vec<Option<StorageData>>, Error> {
+		let child_info = if let Some((ChildType::ParentKeyId, storage_key)) =
+			ChildType::from_prefixed_key(&storage_key)
+		{
+			Arc::new(ChildInfo::new_default(storage_key))
+		} else {
+			return Err(client_err(sp_blockchain::Error::InvalidChildStorageKey))
+		};
+		let block = self.block_or_best(block).map_err(client_err)?;
+		let client = self.client.clone();
+
+		keys.into_iter()
+			.map(move |key| {
+				client.clone().child_storage(block, &child_info, &key).map_err(client_err)
+			})
+			.collect()
+	}
+
+	fn storage_hash(
+		&self,
+		block: Option<Block::Hash>,
+		storage_key: PrefixedStorageKey,
+		key: StorageKey,
+	) -> std::result::Result<Option<Block::Hash>, Error> {
+		self.block_or_best(block)
+			.and_then(|block| {
+				let child_info = match ChildType::from_prefixed_key(&storage_key) {
+					Some((ChildType::ParentKeyId, storage_key)) =>
+						ChildInfo::new_default(storage_key),
+					None => return Err(sp_blockchain::Error::InvalidChildStorageKey),
+				};
+				self.client.child_storage_hash(block, &child_info, &key)
+			})
+			.map_err(client_err)
+	}
+}
+
+fn invalid_block_range<B: BlockT>(
+	from: &CachedHeaderMetadata<B>,
+	to: &CachedHeaderMetadata<B>,
+	details: String,
+) -> Error {
+	let to_string = |h: &CachedHeaderMetadata<B>| format!("{} ({:?})", h.number, h.hash);
+
+	Error::InvalidBlockRange { from: to_string(from), to: to_string(to), details }
+}
+
+fn invalid_block<B: BlockT>(from: B::Hash, to: Option<B::Hash>, details: String) -> Error {
+	Error::InvalidBlockRange { from: format!("{:?}", from), to: format!("{:?}", to), details }
+}
diff --git a/substrate/client/rpc/src/state/tests.rs b/substrate/client/rpc/src/state/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..35352f6d890ed0a14fb0e74d529347f17753844a
--- /dev/null
+++ b/substrate/client/rpc/src/state/tests.rs
@@ -0,0 +1,581 @@
+// 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 self::error::Error;
+use super::*;
+use crate::testing::{test_executor, timeout_secs};
+use assert_matches::assert_matches;
+use futures::executor;
+use jsonrpsee::{
+	core::Error as RpcError,
+	types::{error::CallError as RpcCallError, EmptyServerParams as EmptyParams, ErrorObject},
+};
+use sc_block_builder::BlockBuilderProvider;
+use sc_rpc_api::DenyUnsafe;
+use sp_consensus::BlockOrigin;
+use sp_core::{hash::H256, storage::ChildInfo};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	prelude::*,
+	runtime::{ExtrinsicBuilder, Transfer},
+};
+
+const STORAGE_KEY: &[u8] = b"child";
+
+fn prefixed_storage_key() -> PrefixedStorageKey {
+	let child_info = ChildInfo::new_default(STORAGE_KEY);
+	child_info.prefixed_storage_key()
+}
+
+#[tokio::test]
+async fn should_return_storage() {
+	const KEY: &[u8] = b":mock";
+	const VALUE: &[u8] = b"hello world";
+	const CHILD_VALUE: &[u8] = b"hello world !";
+
+	let child_info = ChildInfo::new_default(STORAGE_KEY);
+	let client = TestClientBuilder::new()
+		.add_extra_storage(KEY.to_vec(), VALUE.to_vec())
+		.add_extra_child_storage(&child_info, KEY.to_vec(), CHILD_VALUE.to_vec())
+		// similar to a map with two keys
+		.add_extra_storage(b":map:acc1".to_vec(), vec![1, 2])
+		.add_extra_storage(b":map:acc2".to_vec(), vec![1, 2, 3])
+		.build();
+	let genesis_hash = client.genesis_hash();
+	let (client, child) = new_full(Arc::new(client), test_executor(), DenyUnsafe::No);
+	let key = StorageKey(KEY.to_vec());
+
+	assert_eq!(
+		client
+			.storage(key.clone(), Some(genesis_hash).into())
+			.map(|x| x.map(|x| x.0.len()))
+			.unwrap()
+			.unwrap() as usize,
+		VALUE.len(),
+	);
+	assert_matches!(
+		client.storage_hash(key.clone(), Some(genesis_hash).into()).map(|x| x.is_some()),
+		Ok(true)
+	);
+	assert_eq!(
+		client.storage_size(key.clone(), None).await.unwrap().unwrap() as usize,
+		VALUE.len(),
+	);
+	assert_eq!(
+		client.storage_size(StorageKey(b":map".to_vec()), None).await.unwrap().unwrap() as usize,
+		2 + 3,
+	);
+	assert_eq!(
+		child
+			.storage(prefixed_storage_key(), key, Some(genesis_hash).into())
+			.map(|x| x.map(|x| x.0.len()))
+			.unwrap()
+			.unwrap() as usize,
+		CHILD_VALUE.len(),
+	);
+}
+
+#[tokio::test]
+async fn should_return_storage_entries() {
+	const KEY1: &[u8] = b":mock";
+	const KEY2: &[u8] = b":turtle";
+	const VALUE: &[u8] = b"hello world";
+	const CHILD_VALUE1: &[u8] = b"hello world !";
+	const CHILD_VALUE2: &[u8] = b"hello world    !";
+
+	let child_info = ChildInfo::new_default(STORAGE_KEY);
+	let client = TestClientBuilder::new()
+		.add_extra_storage(KEY1.to_vec(), VALUE.to_vec())
+		.add_extra_child_storage(&child_info, KEY1.to_vec(), CHILD_VALUE1.to_vec())
+		.add_extra_child_storage(&child_info, KEY2.to_vec(), CHILD_VALUE2.to_vec())
+		.build();
+	let genesis_hash = client.genesis_hash();
+	let (_client, child) = new_full(Arc::new(client), test_executor(), DenyUnsafe::No);
+
+	let keys = &[StorageKey(KEY1.to_vec()), StorageKey(KEY2.to_vec())];
+	assert_eq!(
+		child
+			.storage_entries(prefixed_storage_key(), keys.to_vec(), Some(genesis_hash).into())
+			.map(|x| x.into_iter().map(|x| x.map(|x| x.0.len()).unwrap()).sum::<usize>())
+			.unwrap(),
+		CHILD_VALUE1.len() + CHILD_VALUE2.len()
+	);
+
+	// should fail if not all keys exist.
+	let mut failing_keys = vec![StorageKey(b":soup".to_vec())];
+	failing_keys.extend_from_slice(keys);
+	assert_matches!(
+		child
+			.storage_entries(prefixed_storage_key(), failing_keys, Some(genesis_hash).into())
+			.map(|x| x.iter().all(|x| x.is_some())),
+		Ok(false)
+	);
+}
+
+#[tokio::test]
+async fn should_return_child_storage() {
+	let child_info = ChildInfo::new_default(STORAGE_KEY);
+	let client = Arc::new(
+		substrate_test_runtime_client::TestClientBuilder::new()
+			.add_child_storage(&child_info, "key", vec![42_u8])
+			.build(),
+	);
+	let genesis_hash = client.genesis_hash();
+	let (_client, child) = new_full(client, test_executor(), DenyUnsafe::No);
+	let child_key = prefixed_storage_key();
+	let key = StorageKey(b"key".to_vec());
+
+	assert_matches!(
+		child.storage(
+			child_key.clone(),
+			key.clone(),
+			Some(genesis_hash).into(),
+		),
+		Ok(Some(StorageData(ref d))) if d[0] == 42 && d.len() == 1
+	);
+	assert_matches!(
+		child
+			.storage_hash(child_key.clone(), key.clone(), Some(genesis_hash).into(),)
+			.map(|x| x.is_some()),
+		Ok(true)
+	);
+	assert_matches!(child.storage_size(child_key.clone(), key.clone(), None), Ok(Some(1)));
+}
+
+#[tokio::test]
+async fn should_return_child_storage_entries() {
+	let child_info = ChildInfo::new_default(STORAGE_KEY);
+	let client = Arc::new(
+		substrate_test_runtime_client::TestClientBuilder::new()
+			.add_child_storage(&child_info, "key1", vec![42_u8])
+			.add_child_storage(&child_info, "key2", vec![43_u8, 44])
+			.build(),
+	);
+	let genesis_hash = client.genesis_hash();
+	let (_client, child) = new_full(client, test_executor(), DenyUnsafe::No);
+	let child_key = prefixed_storage_key();
+	let keys = vec![StorageKey(b"key1".to_vec()), StorageKey(b"key2".to_vec())];
+
+	let res = child
+		.storage_entries(child_key.clone(), keys.clone(), Some(genesis_hash).into())
+		.unwrap();
+
+	assert_matches!(
+		res[0],
+		Some(StorageData(ref d))
+			if d[0] == 42 && d.len() == 1
+	);
+	assert_matches!(
+		res[1],
+		Some(StorageData(ref d))
+			if d[0] == 43 && d[1] == 44 && d.len() == 2
+	);
+	assert_matches!(
+		child
+			.storage_hash(child_key.clone(), keys[0].clone(), Some(genesis_hash).into())
+			.map(|x| x.is_some()),
+		Ok(true)
+	);
+	assert_matches!(child.storage_size(child_key.clone(), keys[0].clone(), None), Ok(Some(1)));
+}
+
+#[tokio::test]
+async fn should_call_contract() {
+	let client = Arc::new(substrate_test_runtime_client::new());
+	let genesis_hash = client.genesis_hash();
+	let (client, _child) = new_full(client, test_executor(), DenyUnsafe::No);
+
+	use jsonrpsee::{core::Error, types::error::CallError};
+
+	assert_matches!(
+		client.call("balanceOf".into(), Bytes(vec![1, 2, 3]), Some(genesis_hash).into()),
+		Err(Error::Call(CallError::Failed(_)))
+	)
+}
+
+#[tokio::test]
+async fn should_notify_about_storage_changes() {
+	let mut sub = {
+		let mut client = Arc::new(substrate_test_runtime_client::new());
+		let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No);
+
+		let api_rpc = api.into_rpc();
+		let sub = api_rpc.subscribe("state_subscribeStorage", EmptyParams::new()).await.unwrap();
+
+		// Cause a change:
+		let mut builder = client.new_block(Default::default()).unwrap();
+		builder
+			.push_transfer(Transfer {
+				from: AccountKeyring::Alice.into(),
+				to: AccountKeyring::Ferdie.into(),
+				amount: 42,
+				nonce: 0,
+			})
+			.unwrap();
+		let block = builder.build().unwrap().block;
+		client.import(BlockOrigin::Own, block).await.unwrap();
+
+		sub
+	};
+
+	// We should get a message back on our subscription about the storage change:
+	// NOTE: previous versions of the subscription code used to return an empty value for the
+	// "initial" storage change here
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(Some(_)));
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(None));
+}
+
+#[tokio::test]
+async fn should_send_initial_storage_changes_and_notifications() {
+	let mut sub = {
+		let mut client = Arc::new(substrate_test_runtime_client::new());
+		let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No);
+
+		let alice_balance_key = [
+			sp_core::hashing::twox_128(b"System"),
+			sp_core::hashing::twox_128(b"Account"),
+			sp_core::hashing::blake2_128(&AccountKeyring::Alice.public()),
+		]
+		.concat()
+		.iter()
+		.chain(AccountKeyring::Alice.public().0.iter())
+		.cloned()
+		.collect::<Vec<u8>>();
+
+		let api_rpc = api.into_rpc();
+		let sub = api_rpc
+			.subscribe("state_subscribeStorage", [[StorageKey(alice_balance_key)]])
+			.await
+			.unwrap();
+
+		let mut builder = client.new_block(Default::default()).unwrap();
+		builder
+			.push_transfer(Transfer {
+				from: AccountKeyring::Alice.into(),
+				to: AccountKeyring::Ferdie.into(),
+				amount: 42,
+				nonce: 0,
+			})
+			.unwrap();
+		let block = builder.build().unwrap().block;
+		client.import(BlockOrigin::Own, block).await.unwrap();
+
+		sub
+	};
+
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(Some(_)));
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(Some(_)));
+
+	// No more messages to follow
+	assert_matches!(timeout_secs(1, sub.next::<StorageChangeSet<H256>>()).await, Ok(None));
+}
+
+#[tokio::test]
+async fn should_query_storage() {
+	async fn run_tests(mut client: Arc<TestClient>) {
+		let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No);
+
+		let mut add_block = |index| {
+			let mut builder = client.new_block(Default::default()).unwrap();
+			// fake change: None -> None -> None
+			builder
+				.push(ExtrinsicBuilder::new_storage_change(vec![1], None).build())
+				.unwrap();
+			// fake change: None -> Some(value) -> Some(value)
+			builder
+				.push(ExtrinsicBuilder::new_storage_change(vec![2], Some(vec![2])).build())
+				.unwrap();
+			// actual change: None -> Some(value) -> None
+			builder
+				.push(
+					ExtrinsicBuilder::new_storage_change(
+						vec![3],
+						if index == 0 { Some(vec![3]) } else { None },
+					)
+					.build(),
+				)
+				.unwrap();
+			// actual change: None -> Some(value)
+			builder
+				.push(
+					ExtrinsicBuilder::new_storage_change(
+						vec![4],
+						if index == 0 { None } else { Some(vec![4]) },
+					)
+					.build(),
+				)
+				.unwrap();
+			// actual change: Some(value1) -> Some(value2)
+			builder
+				.push(
+					ExtrinsicBuilder::new_storage_change(vec![5], Some(vec![index as u8])).build(),
+				)
+				.unwrap();
+			let block = builder.build().unwrap().block;
+			let hash = block.header.hash();
+			executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+			hash
+		};
+		let block1_hash = add_block(0);
+		let block2_hash = add_block(1);
+		let genesis_hash = client.genesis_hash();
+
+		let mut expected = vec![
+			StorageChangeSet {
+				block: genesis_hash,
+				changes: vec![
+					(StorageKey(vec![1]), None),
+					(StorageKey(vec![2]), None),
+					(StorageKey(vec![3]), None),
+					(StorageKey(vec![4]), None),
+					(StorageKey(vec![5]), None),
+				],
+			},
+			StorageChangeSet {
+				block: block1_hash,
+				changes: vec![
+					(StorageKey(vec![2]), Some(StorageData(vec![2]))),
+					(StorageKey(vec![3]), Some(StorageData(vec![3]))),
+					(StorageKey(vec![5]), Some(StorageData(vec![0]))),
+				],
+			},
+		];
+
+		// Query changes only up to block1
+		let keys = (1..6).map(|k| StorageKey(vec![k])).collect::<Vec<_>>();
+		let result = api.query_storage(keys.clone(), genesis_hash, Some(block1_hash).into());
+
+		assert_eq!(result.unwrap(), expected);
+
+		// Query all changes
+		let result = api.query_storage(keys.clone(), genesis_hash, None.into());
+
+		expected.push(StorageChangeSet {
+			block: block2_hash,
+			changes: vec![
+				(StorageKey(vec![3]), None),
+				(StorageKey(vec![4]), Some(StorageData(vec![4]))),
+				(StorageKey(vec![5]), Some(StorageData(vec![1]))),
+			],
+		});
+		assert_eq!(result.unwrap(), expected);
+
+		// Query changes up to block2.
+		let result = api.query_storage(keys.clone(), genesis_hash, Some(block2_hash));
+
+		assert_eq!(result.unwrap(), expected);
+
+		// Inverted range.
+		let result = api.query_storage(keys.clone(), block1_hash, Some(genesis_hash));
+
+		assert_eq!(
+			result.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("1 ({:?})", block1_hash),
+					to: format!("0 ({:?})", genesis_hash),
+					details: "from number > to number".to_owned(),
+				}
+				.to_string(),
+				None::<()>,
+			))))
+			.map_err(|e| e.to_string())
+		);
+
+		let random_hash1 = H256::random();
+		let random_hash2 = H256::random();
+
+		// Invalid second hash.
+		let result = api.query_storage(keys.clone(), genesis_hash, Some(random_hash1));
+
+		assert_eq!(
+			result.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", genesis_hash),
+					to: format!("{:?}", Some(random_hash1)),
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>,
+			))))
+			.map_err(|e| e.to_string())
+		);
+
+		// Invalid first hash with Some other hash.
+		let result = api.query_storage(keys.clone(), random_hash1, Some(genesis_hash));
+
+		assert_eq!(
+			result.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", random_hash1),
+					to: format!("{:?}", Some(genesis_hash)),
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>,
+			))))
+			.map_err(|e| e.to_string()),
+		);
+
+		// Invalid first hash with None.
+		let result = api.query_storage(keys.clone(), random_hash1, None);
+
+		assert_eq!(
+			result.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", random_hash1),
+					to: format!("{:?}", Some(block2_hash)), // Best block hash.
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>,
+			))))
+			.map_err(|e| e.to_string()),
+		);
+
+		// Both hashes invalid.
+		let result = api.query_storage(keys.clone(), random_hash1, Some(random_hash2));
+
+		assert_eq!(
+			result.map_err(|e| e.to_string()),
+			Err(RpcError::Call(RpcCallError::Custom(ErrorObject::owned(
+				4001,
+				Error::InvalidBlockRange {
+					from: format!("{:?}", random_hash1), // First hash not found.
+					to: format!("{:?}", Some(random_hash2)),
+					details: format!(
+						"UnknownBlock: Header was not found in the database: {:?}",
+						random_hash1
+					),
+				}
+				.to_string(),
+				None::<()>
+			))))
+			.map_err(|e| e.to_string()),
+		);
+
+		// single block range
+		let result = api.query_storage_at(keys.clone(), Some(block1_hash));
+
+		assert_eq!(
+			result.unwrap(),
+			vec![StorageChangeSet {
+				block: block1_hash,
+				changes: vec![
+					(StorageKey(vec![1_u8]), None),
+					(StorageKey(vec![2_u8]), Some(StorageData(vec![2_u8]))),
+					(StorageKey(vec![3_u8]), Some(StorageData(vec![3_u8]))),
+					(StorageKey(vec![4_u8]), None),
+					(StorageKey(vec![5_u8]), Some(StorageData(vec![0_u8]))),
+				]
+			}]
+		);
+	}
+
+	run_tests(Arc::new(substrate_test_runtime_client::new())).await;
+	run_tests(Arc::new(TestClientBuilder::new().build())).await;
+}
+
+#[tokio::test]
+async fn should_return_runtime_version() {
+	let client = Arc::new(substrate_test_runtime_client::new());
+	let (api, _child) = new_full(client.clone(), test_executor(), DenyUnsafe::No);
+
+	// it is basically json-encoded substrate_test_runtime_client::runtime::VERSION
+	let result = "{\"specName\":\"test\",\"implName\":\"parity-test\",\"authoringVersion\":1,\
+		\"specVersion\":2,\"implVersion\":2,\"apis\":[[\"0xdf6acb689907609b\",4],\
+		[\"0x37e397fc7c91f5e4\",2],[\"0xd2bc9897eed08f15\",3],[\"0x40fe3ad401f8959a\",6],\
+		[\"0xbc9d89904f5b923f\",1],[\"0xc6e9a76309f39b09\",2],[\"0xdd718d5cc53262d4\",1],\
+		[\"0xcbca25e39f142387\",2],[\"0xf78b278be53f454c\",2],[\"0xab3c0572291feb8b\",1],\
+		[\"0xed99c5acb25eedf5\",3],[\"0xfbc577b9d747efd6\",1]],\"transactionVersion\":1,\"stateVersion\":1}";
+
+	let runtime_version = api.runtime_version(None.into()).unwrap();
+	let serialized = serde_json::to_string(&runtime_version).unwrap();
+	pretty_assertions::assert_eq!(serialized, result);
+
+	let deserialized: RuntimeVersion = serde_json::from_str(result).unwrap();
+	assert_eq!(deserialized, runtime_version);
+}
+
+#[tokio::test]
+async fn should_notify_on_runtime_version_initially() {
+	let mut sub = {
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let (api, _child) = new_full(client, test_executor(), DenyUnsafe::No);
+
+		let api_rpc = api.into_rpc();
+		let sub = api_rpc
+			.subscribe("state_subscribeRuntimeVersion", EmptyParams::new())
+			.await
+			.unwrap();
+
+		sub
+	};
+
+	// assert initial version sent.
+	assert_matches!(timeout_secs(10, sub.next::<RuntimeVersion>()).await, Ok(Some(_)));
+
+	sub.close();
+	assert_matches!(timeout_secs(10, sub.next::<RuntimeVersion>()).await, Ok(None));
+}
+
+#[test]
+fn should_deserialize_storage_key() {
+	let k = "\"0x7f864e18e3dd8b58386310d2fe0919eef27c6e558564b7f67f22d99d20f587b\"";
+	let k: StorageKey = serde_json::from_str(k).unwrap();
+
+	assert_eq!(k.0.len(), 32);
+}
+
+#[tokio::test]
+async fn wildcard_storage_subscriptions_are_rpc_unsafe() {
+	let client = Arc::new(substrate_test_runtime_client::new());
+	let (api, _child) = new_full(client, test_executor(), DenyUnsafe::Yes);
+
+	let api_rpc = api.into_rpc();
+	let err = api_rpc.subscribe("state_subscribeStorage", EmptyParams::new()).await;
+	assert_matches!(err, Err(RpcError::Call(RpcCallError::Custom(e))) if e.message() == "RPC call is unsafe to be called externally");
+}
+
+#[tokio::test]
+async fn concrete_storage_subscriptions_are_rpc_safe() {
+	let client = Arc::new(substrate_test_runtime_client::new());
+	let (api, _child) = new_full(client, test_executor(), DenyUnsafe::Yes);
+	let api_rpc = api.into_rpc();
+
+	let key = StorageKey(STORAGE_KEY.to_vec());
+	let sub = api_rpc.subscribe("state_subscribeStorage", [[key]]).await;
+
+	assert!(sub.is_ok());
+}
diff --git a/substrate/client/rpc/src/state/utils.rs b/substrate/client/rpc/src/state/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9fc21b72b81e745be0b63dd3bd53aa8812c360ee
--- /dev/null
+++ b/substrate/client/rpc/src/state/utils.rs
@@ -0,0 +1,140 @@
+// 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 std::{
+	sync::{
+		atomic::{AtomicBool, Ordering},
+		Arc,
+	},
+	time::Duration,
+};
+
+/// An error signifying that a task has been cancelled due to a timeout.
+#[derive(Debug)]
+pub struct Timeout;
+
+impl std::error::Error for Timeout {}
+impl std::fmt::Display for Timeout {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.write_str("task has been running too long")
+	}
+}
+
+/// A handle which can be used to check whether the task has been cancelled due to a timeout.
+#[repr(transparent)]
+pub struct IsTimedOut(Arc<AtomicBool>);
+
+impl IsTimedOut {
+	#[must_use]
+	pub fn check_if_timed_out(&self) -> std::result::Result<(), Timeout> {
+		if self.0.load(Ordering::Relaxed) {
+			Err(Timeout)
+		} else {
+			Ok(())
+		}
+	}
+}
+
+/// An error for a task which either panicked, or has been cancelled due to a timeout.
+#[derive(Debug)]
+pub enum SpawnWithTimeoutError {
+	JoinError(tokio::task::JoinError),
+	Timeout,
+}
+
+impl std::error::Error for SpawnWithTimeoutError {}
+impl std::fmt::Display for SpawnWithTimeoutError {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		match self {
+			SpawnWithTimeoutError::JoinError(error) => error.fmt(fmt),
+			SpawnWithTimeoutError::Timeout => Timeout.fmt(fmt),
+		}
+	}
+}
+
+struct CancelOnDrop(Arc<AtomicBool>);
+impl Drop for CancelOnDrop {
+	fn drop(&mut self) {
+		self.0.store(true, Ordering::Relaxed)
+	}
+}
+
+/// Spawns a new blocking task with a given `timeout`.
+///
+/// The `callback` should continuously call [`IsTimedOut::check_if_timed_out`],
+/// which will return an error once the task runs for longer than `timeout`.
+///
+/// If `timeout` is `None` then this works just as a regular `spawn_blocking`.
+pub async fn spawn_blocking_with_timeout<R>(
+	timeout: Option<Duration>,
+	callback: impl FnOnce(IsTimedOut) -> std::result::Result<R, Timeout> + Send + 'static,
+) -> Result<R, SpawnWithTimeoutError>
+where
+	R: Send + 'static,
+{
+	let is_timed_out_arc = Arc::new(AtomicBool::new(false));
+	let is_timed_out = IsTimedOut(is_timed_out_arc.clone());
+	let _cancel_on_drop = CancelOnDrop(is_timed_out_arc);
+	let task = tokio::task::spawn_blocking(move || callback(is_timed_out));
+
+	let result = if let Some(timeout) = timeout {
+		tokio::select! {
+			// Shouldn't really matter, but make sure the task is polled before the timeout,
+			// in case the task finishes after the timeout and the timeout is really short.
+			biased;
+
+			task_result = task => task_result,
+			_ = tokio::time::sleep(timeout) => Ok(Err(Timeout))
+		}
+	} else {
+		task.await
+	};
+
+	match result {
+		Ok(Ok(result)) => Ok(result),
+		Ok(Err(Timeout)) => Err(SpawnWithTimeoutError::Timeout),
+		Err(error) => Err(SpawnWithTimeoutError::JoinError(error)),
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[tokio::test]
+	async fn spawn_blocking_with_timeout_works() {
+		let task: Result<(), SpawnWithTimeoutError> =
+			spawn_blocking_with_timeout(Some(Duration::from_millis(100)), |is_timed_out| {
+				std::thread::sleep(Duration::from_millis(200));
+				is_timed_out.check_if_timed_out()?;
+				unreachable!();
+			})
+			.await;
+
+		assert_matches::assert_matches!(task, Err(SpawnWithTimeoutError::Timeout));
+
+		let task = spawn_blocking_with_timeout(Some(Duration::from_millis(100)), |is_timed_out| {
+			std::thread::sleep(Duration::from_millis(20));
+			is_timed_out.check_if_timed_out()?;
+			Ok(())
+		})
+		.await;
+
+		assert_matches::assert_matches!(task, Ok(()));
+	}
+}
diff --git a/substrate/client/rpc/src/statement/mod.rs b/substrate/client/rpc/src/statement/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b4f432bbbb0e3485a67447fb34669bf980602868
--- /dev/null
+++ b/substrate/client/rpc/src/statement/mod.rs
@@ -0,0 +1,108 @@
+// 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/>.
+
+//! Substrate statement store API.
+
+use codec::{Decode, Encode};
+use jsonrpsee::core::{async_trait, RpcResult};
+/// Re-export the API for backward compatibility.
+pub use sc_rpc_api::statement::{error::Error, StatementApiServer};
+use sc_rpc_api::DenyUnsafe;
+use sp_core::Bytes;
+use sp_statement_store::{StatementSource, SubmitResult};
+use std::sync::Arc;
+
+/// Statement store API
+pub struct StatementStore {
+	store: Arc<dyn sp_statement_store::StatementStore>,
+	deny_unsafe: DenyUnsafe,
+}
+
+impl StatementStore {
+	/// Create new instance of Offchain API.
+	pub fn new(
+		store: Arc<dyn sp_statement_store::StatementStore>,
+		deny_unsafe: DenyUnsafe,
+	) -> Self {
+		StatementStore { store, deny_unsafe }
+	}
+}
+
+#[async_trait]
+impl StatementApiServer for StatementStore {
+	fn dump(&self) -> RpcResult<Vec<Bytes>> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let statements =
+			self.store.statements().map_err(|e| Error::StatementStore(e.to_string()))?;
+		Ok(statements.into_iter().map(|(_, s)| s.encode().into()).collect())
+	}
+
+	fn broadcasts(&self, match_all_topics: Vec<[u8; 32]>) -> RpcResult<Vec<Bytes>> {
+		Ok(self
+			.store
+			.broadcasts(&match_all_topics)
+			.map_err(|e| Error::StatementStore(e.to_string()))?
+			.into_iter()
+			.map(Into::into)
+			.collect())
+	}
+
+	fn posted(&self, match_all_topics: Vec<[u8; 32]>, dest: [u8; 32]) -> RpcResult<Vec<Bytes>> {
+		Ok(self
+			.store
+			.posted(&match_all_topics, dest)
+			.map_err(|e| Error::StatementStore(e.to_string()))?
+			.into_iter()
+			.map(Into::into)
+			.collect())
+	}
+
+	fn posted_clear(
+		&self,
+		match_all_topics: Vec<[u8; 32]>,
+		dest: [u8; 32],
+	) -> RpcResult<Vec<Bytes>> {
+		Ok(self
+			.store
+			.posted_clear(&match_all_topics, dest)
+			.map_err(|e| Error::StatementStore(e.to_string()))?
+			.into_iter()
+			.map(Into::into)
+			.collect())
+	}
+
+	fn submit(&self, encoded: Bytes) -> RpcResult<()> {
+		let statement = Decode::decode(&mut &*encoded)
+			.map_err(|e| Error::StatementStore(format!("Eror decoding statement: {:?}", e)))?;
+		match self.store.submit(statement, StatementSource::Local) {
+			SubmitResult::New(_) | SubmitResult::Known => Ok(()),
+			// `KnownExpired` should not happen. Expired statements submitted with
+			// `StatementSource::Rpc` should be renewed.
+			SubmitResult::KnownExpired =>
+				Err(Error::StatementStore("Submitted an expired statement.".into()).into()),
+			SubmitResult::Bad(e) => Err(Error::StatementStore(e.into()).into()),
+			SubmitResult::Ignored => Err(Error::StatementStore("Store is full.".into()).into()),
+			SubmitResult::InternalError(e) => Err(Error::StatementStore(e.to_string()).into()),
+		}
+	}
+
+	fn remove(&self, hash: [u8; 32]) -> RpcResult<()> {
+		Ok(self.store.remove(&hash).map_err(|e| Error::StatementStore(e.to_string()))?)
+	}
+}
diff --git a/substrate/client/rpc/src/system/mod.rs b/substrate/client/rpc/src/system/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0da4f8d0e211c729a8ebe7eaaac7d6bb735bd5df
--- /dev/null
+++ b/substrate/client/rpc/src/system/mod.rs
@@ -0,0 +1,204 @@
+// 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/>.
+
+//! Substrate system API.
+
+#[cfg(test)]
+mod tests;
+
+use futures::channel::oneshot;
+use jsonrpsee::{
+	core::{async_trait, error::Error as JsonRpseeError, JsonValue, RpcResult},
+	types::error::{CallError, ErrorCode, ErrorObject},
+};
+use sc_rpc_api::DenyUnsafe;
+use sc_tracing::logging;
+use sc_utils::mpsc::TracingUnboundedSender;
+use sp_runtime::traits::{self, Header as HeaderT};
+
+use self::error::Result;
+
+pub use self::helpers::{Health, NodeRole, PeerInfo, SyncState, SystemInfo};
+pub use sc_rpc_api::system::*;
+
+/// System API implementation
+pub struct System<B: traits::Block> {
+	info: SystemInfo,
+	send_back: TracingUnboundedSender<Request<B>>,
+	deny_unsafe: DenyUnsafe,
+}
+
+/// Request to be processed.
+pub enum Request<B: traits::Block> {
+	/// Must return the health of the network.
+	Health(oneshot::Sender<Health>),
+	/// Must return the base58-encoded local `PeerId`.
+	LocalPeerId(oneshot::Sender<String>),
+	/// Must return the string representation of the addresses we listen on, including the
+	/// trailing `/p2p/`.
+	LocalListenAddresses(oneshot::Sender<Vec<String>>),
+	/// Must return information about the peers we are connected to.
+	Peers(oneshot::Sender<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>>),
+	/// Must return the state of the network.
+	NetworkState(oneshot::Sender<serde_json::Value>),
+	/// Must return any potential parse error.
+	NetworkAddReservedPeer(String, oneshot::Sender<Result<()>>),
+	/// Must return any potential parse error.
+	NetworkRemoveReservedPeer(String, oneshot::Sender<Result<()>>),
+	/// Must return the list of reserved peers
+	NetworkReservedPeers(oneshot::Sender<Vec<String>>),
+	/// Must return the node role.
+	NodeRoles(oneshot::Sender<Vec<NodeRole>>),
+	/// Must return the state of the node syncing.
+	SyncState(oneshot::Sender<SyncState<<B::Header as HeaderT>::Number>>),
+}
+
+impl<B: traits::Block> System<B> {
+	/// Creates new `System`.
+	///
+	/// The `send_back` will be used to transmit some of the requests. The user is responsible for
+	/// reading from that channel and answering the requests.
+	pub fn new(
+		info: SystemInfo,
+		send_back: TracingUnboundedSender<Request<B>>,
+		deny_unsafe: DenyUnsafe,
+	) -> Self {
+		System { info, send_back, deny_unsafe }
+	}
+}
+
+#[async_trait]
+impl<B: traits::Block> SystemApiServer<B::Hash, <B::Header as HeaderT>::Number> for System<B> {
+	fn system_name(&self) -> RpcResult<String> {
+		Ok(self.info.impl_name.clone())
+	}
+
+	fn system_version(&self) -> RpcResult<String> {
+		Ok(self.info.impl_version.clone())
+	}
+
+	fn system_chain(&self) -> RpcResult<String> {
+		Ok(self.info.chain_name.clone())
+	}
+
+	fn system_type(&self) -> RpcResult<sc_chain_spec::ChainType> {
+		Ok(self.info.chain_type.clone())
+	}
+
+	fn system_properties(&self) -> RpcResult<sc_chain_spec::Properties> {
+		Ok(self.info.properties.clone())
+	}
+
+	async fn system_health(&self) -> RpcResult<Health> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::Health(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	async fn system_local_peer_id(&self) -> RpcResult<String> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::LocalPeerId(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	async fn system_local_listen_addresses(&self) -> RpcResult<Vec<String>> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::LocalListenAddresses(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	async fn system_peers(
+		&self,
+	) -> RpcResult<Vec<PeerInfo<B::Hash, <B::Header as HeaderT>::Number>>> {
+		self.deny_unsafe.check_if_safe()?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::Peers(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	async fn system_network_state(&self) -> RpcResult<JsonValue> {
+		self.deny_unsafe.check_if_safe()?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkState(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	async fn system_add_reserved_peer(&self, peer: String) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkAddReservedPeer(peer, tx));
+		match rx.await {
+			Ok(Ok(())) => Ok(()),
+			Ok(Err(e)) => Err(JsonRpseeError::from(e)),
+			Err(e) => Err(JsonRpseeError::to_call_error(e)),
+		}
+	}
+
+	async fn system_remove_reserved_peer(&self, peer: String) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkRemoveReservedPeer(peer, tx));
+		match rx.await {
+			Ok(Ok(())) => Ok(()),
+			Ok(Err(e)) => Err(JsonRpseeError::from(e)),
+			Err(e) => Err(JsonRpseeError::to_call_error(e)),
+		}
+	}
+
+	async fn system_reserved_peers(&self) -> RpcResult<Vec<String>> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NetworkReservedPeers(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	async fn system_node_roles(&self) -> RpcResult<Vec<NodeRole>> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::NodeRoles(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	async fn system_sync_state(&self) -> RpcResult<SyncState<<B::Header as HeaderT>::Number>> {
+		let (tx, rx) = oneshot::channel();
+		let _ = self.send_back.unbounded_send(Request::SyncState(tx));
+		rx.await.map_err(|e| JsonRpseeError::to_call_error(e))
+	}
+
+	fn system_add_log_filter(&self, directives: String) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
+
+		logging::add_directives(&directives);
+		logging::reload_filter().map_err(|e| {
+			JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+				ErrorCode::InternalError.code(),
+				e,
+				None::<()>,
+			)))
+		})
+	}
+
+	fn system_reset_log_filter(&self) -> RpcResult<()> {
+		self.deny_unsafe.check_if_safe()?;
+		logging::reset_log_filter().map_err(|e| {
+			JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+				ErrorCode::InternalError.code(),
+				e,
+				None::<()>,
+			)))
+		})
+	}
+}
diff --git a/substrate/client/rpc/src/system/tests.rs b/substrate/client/rpc/src/system/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b6bfec7736b088f8b42192de10bc07614fb5bd86
--- /dev/null
+++ b/substrate/client/rpc/src/system/tests.rs
@@ -0,0 +1,424 @@
+// 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::{helpers::SyncState, *};
+use assert_matches::assert_matches;
+use futures::prelude::*;
+use jsonrpsee::{
+	core::Error as RpcError,
+	types::{error::CallError, EmptyServerParams as EmptyParams},
+	RpcModule,
+};
+use sc_network::{self, config::Role, PeerId};
+use sc_rpc_api::system::helpers::PeerInfo;
+use sc_utils::mpsc::tracing_unbounded;
+use sp_core::H256;
+use std::{
+	env,
+	io::{BufRead, BufReader, Write},
+	process::{Command, Stdio},
+	thread,
+};
+use substrate_test_runtime_client::runtime::Block;
+
+struct Status {
+	pub peers: usize,
+	pub is_syncing: bool,
+	pub is_dev: bool,
+	pub peer_id: PeerId,
+}
+
+impl Default for Status {
+	fn default() -> Status {
+		Status { peer_id: PeerId::random(), peers: 0, is_syncing: false, is_dev: false }
+	}
+}
+
+fn api<T: Into<Option<Status>>>(sync: T) -> RpcModule<System<Block>> {
+	let status = sync.into().unwrap_or_default();
+	let should_have_peers = !status.is_dev;
+	let (tx, rx) = tracing_unbounded("rpc_system_tests", 10_000);
+	thread::spawn(move || {
+		futures::executor::block_on(rx.for_each(move |request| {
+			match request {
+				Request::Health(sender) => {
+					let _ = sender.send(Health {
+						peers: status.peers,
+						is_syncing: status.is_syncing,
+						should_have_peers,
+					});
+				},
+				Request::LocalPeerId(sender) => {
+					let _ =
+						sender.send("QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string());
+				},
+				Request::LocalListenAddresses(sender) => {
+					let _ = sender.send(vec![
+						"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string(),
+						"/ip4/127.0.0.1/tcp/30334/ws/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string(),
+					]);
+				},
+				Request::Peers(sender) => {
+					let mut peers = vec![];
+					for _peer in 0..status.peers {
+						peers.push(PeerInfo {
+							peer_id: status.peer_id.to_base58(),
+							roles: format!("{}", Role::Full),
+							best_hash: Default::default(),
+							best_number: 1,
+						});
+					}
+					let _ = sender.send(peers);
+				},
+				Request::NetworkState(sender) => {
+					let _ = sender.send(
+						serde_json::to_value(&sc_network::network_state::NetworkState {
+							peer_id: String::new(),
+							listened_addresses: Default::default(),
+							external_addresses: Default::default(),
+							connected_peers: Default::default(),
+							not_connected_peers: Default::default(),
+							peerset: serde_json::Value::Null,
+						})
+						.unwrap(),
+					);
+				},
+				Request::NetworkAddReservedPeer(peer, sender) => {
+					let _ = match sc_network::config::parse_str_addr(&peer) {
+						Ok(_) => sender.send(Ok(())),
+						Err(s) =>
+							sender.send(Err(error::Error::MalformattedPeerArg(s.to_string()))),
+					};
+				},
+				Request::NetworkRemoveReservedPeer(peer, sender) => {
+					let _ = match peer.parse::<PeerId>() {
+						Ok(_) => sender.send(Ok(())),
+						Err(s) =>
+							sender.send(Err(error::Error::MalformattedPeerArg(s.to_string()))),
+					};
+				},
+				Request::NetworkReservedPeers(sender) => {
+					let _ = sender
+						.send(vec!["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string()]);
+				},
+				Request::NodeRoles(sender) => {
+					let _ = sender.send(vec![NodeRole::Authority]);
+				},
+				Request::SyncState(sender) => {
+					let _ = sender.send(SyncState {
+						starting_block: 1,
+						current_block: 2,
+						highest_block: 3,
+					});
+				},
+			};
+
+			future::ready(())
+		}))
+	});
+	System::new(
+		SystemInfo {
+			impl_name: "testclient".into(),
+			impl_version: "0.2.0".into(),
+			chain_name: "testchain".into(),
+			properties: Default::default(),
+			chain_type: Default::default(),
+		},
+		tx,
+		sc_rpc_api::DenyUnsafe::No,
+	)
+	.into_rpc()
+}
+
+#[tokio::test]
+async fn system_name_works() {
+	assert_eq!(
+		api(None).call::<_, String>("system_name", EmptyParams::new()).await.unwrap(),
+		"testclient".to_string(),
+	);
+}
+
+#[tokio::test]
+async fn system_version_works() {
+	assert_eq!(
+		api(None).call::<_, String>("system_version", EmptyParams::new()).await.unwrap(),
+		"0.2.0".to_string(),
+	);
+}
+
+#[tokio::test]
+async fn system_chain_works() {
+	assert_eq!(
+		api(None).call::<_, String>("system_chain", EmptyParams::new()).await.unwrap(),
+		"testchain".to_string(),
+	);
+}
+
+#[tokio::test]
+async fn system_properties_works() {
+	type Map = serde_json::map::Map<String, serde_json::Value>;
+
+	assert_eq!(
+		api(None).call::<_, Map>("system_properties", EmptyParams::new()).await.unwrap(),
+		Map::new()
+	);
+}
+
+#[tokio::test]
+async fn system_type_works() {
+	assert_eq!(
+		api(None)
+			.call::<_, String>("system_chainType", EmptyParams::new())
+			.await
+			.unwrap(),
+		"Live".to_owned(),
+	);
+}
+
+#[tokio::test]
+async fn system_health() {
+	assert_eq!(
+		api(None).call::<_, Health>("system_health", EmptyParams::new()).await.unwrap(),
+		Health { peers: 0, is_syncing: false, should_have_peers: true },
+	);
+
+	assert_eq!(
+		api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: true, is_dev: true })
+			.call::<_, Health>("system_health", EmptyParams::new())
+			.await
+			.unwrap(),
+		Health { peers: 5, is_syncing: true, should_have_peers: false },
+	);
+
+	assert_eq!(
+		api(Status { peer_id: PeerId::random(), peers: 5, is_syncing: false, is_dev: false })
+			.call::<_, Health>("system_health", EmptyParams::new())
+			.await
+			.unwrap(),
+		Health { peers: 5, is_syncing: false, should_have_peers: true },
+	);
+
+	assert_eq!(
+		api(Status { peer_id: PeerId::random(), peers: 0, is_syncing: false, is_dev: true })
+			.call::<_, Health>("system_health", EmptyParams::new())
+			.await
+			.unwrap(),
+		Health { peers: 0, is_syncing: false, should_have_peers: false },
+	);
+}
+
+#[tokio::test]
+async fn system_local_peer_id_works() {
+	assert_eq!(
+		api(None)
+			.call::<_, String>("system_localPeerId", EmptyParams::new())
+			.await
+			.unwrap(),
+		"QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_owned()
+	);
+}
+
+#[tokio::test]
+async fn system_local_listen_addresses_works() {
+	assert_eq!(
+		api(None)
+			.call::<_, Vec<String>>("system_localListenAddresses", EmptyParams::new())
+			.await
+			.unwrap(),
+		vec![
+			"/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV",
+			"/ip4/127.0.0.1/tcp/30334/ws/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"
+		]
+	);
+}
+
+#[tokio::test]
+async fn system_peers() {
+	let peer_id = PeerId::random();
+	let peer_info: Vec<PeerInfo<H256, u64>> =
+		api(Status { peer_id, peers: 1, is_syncing: false, is_dev: true })
+			.call("system_peers", EmptyParams::new())
+			.await
+			.unwrap();
+
+	assert_eq!(
+		peer_info,
+		vec![PeerInfo {
+			peer_id: peer_id.to_base58(),
+			roles: "FULL".into(),
+			best_hash: Default::default(),
+			best_number: 1u64,
+		}]
+	);
+}
+
+#[tokio::test]
+async fn system_network_state() {
+	use sc_network::network_state::NetworkState;
+	let network_state: NetworkState = api(None)
+		.call("system_unstable_networkState", EmptyParams::new())
+		.await
+		.unwrap();
+	assert_eq!(
+		network_state,
+		NetworkState {
+			peer_id: String::new(),
+			listened_addresses: Default::default(),
+			external_addresses: Default::default(),
+			connected_peers: Default::default(),
+			not_connected_peers: Default::default(),
+			peerset: serde_json::Value::Null,
+		}
+	);
+}
+
+#[tokio::test]
+async fn system_node_roles() {
+	let node_roles: Vec<NodeRole> =
+		api(None).call("system_nodeRoles", EmptyParams::new()).await.unwrap();
+	assert_eq!(node_roles, vec![NodeRole::Authority]);
+}
+#[tokio::test]
+async fn system_sync_state() {
+	let sync_state: SyncState<i32> =
+		api(None).call("system_syncState", EmptyParams::new()).await.unwrap();
+	assert_eq!(sync_state, SyncState { starting_block: 1, current_block: 2, highest_block: 3 });
+}
+
+#[tokio::test]
+async fn system_network_add_reserved() {
+	let good_peer_id =
+		["/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"];
+	let _good: () = api(None)
+		.call("system_addReservedPeer", good_peer_id)
+		.await
+		.expect("good peer id works");
+
+	let bad_peer_id = ["/ip4/198.51.100.19/tcp/30333"];
+	assert_matches!(
+		api(None).call::<_, ()>("system_addReservedPeer", bad_peer_id).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("Peer id is missing from the address")
+	);
+}
+
+#[tokio::test]
+async fn system_network_remove_reserved() {
+	let _good_peer: () = api(None)
+		.call("system_removeReservedPeer", ["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"])
+		.await
+		.expect("call with good peer id works");
+
+	let bad_peer_id =
+		["/ip4/198.51.100.19/tcp/30333/p2p/QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV"];
+
+	assert_matches!(
+		api(None).call::<_, String>("system_removeReservedPeer", bad_peer_id).await,
+		Err(RpcError::Call(CallError::Custom(err))) if err.message().contains("base-58 decode error: provided string contained invalid character '/' at byte 0")
+	);
+}
+#[tokio::test]
+async fn system_network_reserved_peers() {
+	let reserved_peers: Vec<String> =
+		api(None).call("system_reservedPeers", EmptyParams::new()).await.unwrap();
+	assert_eq!(reserved_peers, vec!["QmSk5HQbn6LhUwDiNMseVUjuRYhEtYj4aUZ6WfWoGURpdV".to_string()],);
+}
+
+#[test]
+fn test_add_reset_log_filter() {
+	const EXPECTED_BEFORE_ADD: &'static str = "EXPECTED_BEFORE_ADD";
+	const EXPECTED_AFTER_ADD: &'static str = "EXPECTED_AFTER_ADD";
+	const EXPECTED_WITH_TRACE: &'static str = "EXPECTED_WITH_TRACE";
+
+	// Enter log generation / filter reload
+	if std::env::var("TEST_LOG_FILTER").is_ok() {
+		let mut builder = sc_tracing::logging::LoggerBuilder::new("test_before_add=debug");
+		builder.with_log_reloading(true);
+		builder.init().unwrap();
+
+		for line in std::io::stdin().lock().lines() {
+			let line = line.expect("Failed to read bytes");
+			if line.contains("add_reload") {
+				let filter = "test_after_add";
+				let fut =
+					async move { api(None).call::<_, ()>("system_addLogFilter", [filter]).await };
+				futures::executor::block_on(fut).expect("`system_addLogFilter` failed");
+			} else if line.contains("add_trace") {
+				let filter = "test_before_add=trace";
+				let fut =
+					async move { api(None).call::<_, ()>("system_addLogFilter", [filter]).await };
+				futures::executor::block_on(fut).expect("`system_addLogFilter (trace)` failed");
+			} else if line.contains("reset") {
+				let fut = async move {
+					api(None).call::<_, ()>("system_resetLogFilter", EmptyParams::new()).await
+				};
+				futures::executor::block_on(fut).expect("`system_resetLogFilter` failed");
+			} else if line.contains("exit") {
+				return
+			}
+			log::trace!(target: "test_before_add", "{}", EXPECTED_WITH_TRACE);
+			log::debug!(target: "test_before_add", "{}", EXPECTED_BEFORE_ADD);
+			log::debug!(target: "test_after_add", "{}", EXPECTED_AFTER_ADD);
+		}
+	}
+
+	// Call this test again to enter the log generation / filter reload block
+	let test_executable = env::current_exe().expect("Unable to get current executable!");
+	let mut child_process = Command::new(test_executable)
+		.env("TEST_LOG_FILTER", "1")
+		.args(&["--nocapture", "test_add_reset_log_filter"])
+		.stdin(Stdio::piped())
+		.stderr(Stdio::piped())
+		.spawn()
+		.unwrap();
+
+	let child_stderr = child_process.stderr.take().expect("Could not get child stderr");
+	let mut child_out = BufReader::new(child_stderr);
+	let mut child_in = child_process.stdin.take().expect("Could not get child stdin");
+
+	let mut read_line = || {
+		let mut line = String::new();
+		child_out.read_line(&mut line).expect("Reading a line");
+		line
+	};
+
+	// Initiate logs loop in child process
+	child_in.write_all(b"\n").unwrap();
+	assert!(read_line().contains(EXPECTED_BEFORE_ADD));
+
+	// Initiate add directive & reload in child process
+	child_in.write_all(b"add_reload\n").unwrap();
+	assert!(read_line().contains(EXPECTED_BEFORE_ADD));
+	assert!(read_line().contains(EXPECTED_AFTER_ADD));
+
+	// Check that increasing the max log level works
+	child_in.write_all(b"add_trace\n").unwrap();
+	assert!(read_line().contains(EXPECTED_WITH_TRACE));
+	assert!(read_line().contains(EXPECTED_BEFORE_ADD));
+	assert!(read_line().contains(EXPECTED_AFTER_ADD));
+
+	// Initiate logs filter reset in child process
+	child_in.write_all(b"reset\n").unwrap();
+	assert!(read_line().contains(EXPECTED_BEFORE_ADD));
+
+	// Return from child process
+	child_in.write_all(b"exit\n").unwrap();
+	assert!(child_process.wait().expect("Error waiting for child process").success());
+
+	// Check for EOF
+	assert_eq!(child_out.read_line(&mut String::new()).unwrap(), 0);
+}
diff --git a/substrate/client/rpc/src/testing.rs b/substrate/client/rpc/src/testing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6b6e1906d44d1f259016b0d98725ded2645e7a70
--- /dev/null
+++ b/substrate/client/rpc/src/testing.rs
@@ -0,0 +1,33 @@
+// 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/>.
+
+//! Testing utils used by the RPC tests.
+
+use std::{future::Future, sync::Arc};
+
+use sp_core::testing::TaskExecutor;
+
+/// Executor for testing.
+pub fn test_executor() -> Arc<sp_core::testing::TaskExecutor> {
+	Arc::new(TaskExecutor::default())
+}
+
+/// Wrap a future in a timeout a little more concisely
+pub fn timeout_secs<I, F: Future<Output = I>>(s: u64, f: F) -> tokio::time::Timeout<F> {
+	tokio::time::timeout(std::time::Duration::from_secs(s), f)
+}
diff --git a/substrate/client/service/Cargo.toml b/substrate/client/service/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6dcd8b8e4baced2a82f31ca9c63d2879c48fe364
--- /dev/null
+++ b/substrate/client/service/Cargo.toml
@@ -0,0 +1,88 @@
+[package]
+name = "sc-service"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate service. Starts a thread that spins up the network, client, and extrinsic pool. Manages communication between them."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[features]
+default = [ "rocksdb" ]
+# The RocksDB feature activates the RocksDB database backend. If it is not activated, and you pass
+# a path to a database, an error will be produced at runtime.
+rocksdb = [ "sc-client-db/rocksdb" ]
+# exposes the client type
+test-helpers = []
+runtime-benchmarks = [
+	"sc-client-db/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["server"] }
+thiserror = "1.0.30"
+futures = "0.3.21"
+rand = "0.8.5"
+parking_lot = "0.12.1"
+log = "0.4.17"
+futures-timer = "3.0.1"
+exit-future = "0.2.0"
+pin-project = "1.0.12"
+serde = "1.0.163"
+serde_json = "1.0.85"
+sc-keystore = { version = "4.0.0-dev", path = "../keystore" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-trie = { version = "22.0.0", path = "../../primitives/trie" }
+sp-externalities = { version = "0.19.0", path = "../../primitives/externalities" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+sp-version = { version = "22.0.0", path = "../../primitives/version" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+sp-session = { version = "4.0.0-dev", path = "../../primitives/session" }
+sp-state-machine = { version = "0.28.0", path = "../../primitives/state-machine" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+sc-consensus = { version = "0.10.0-dev", path = "../../client/consensus/common" }
+sp-storage = { version = "13.0.0", path = "../../primitives/storage" }
+sc-network = { version = "0.10.0-dev", path = "../network" }
+sc-network-bitswap = { version = "0.10.0-dev", path = "../network/bitswap" }
+sc-network-common = { version = "0.10.0-dev", path = "../network/common" }
+sc-network-light = { version = "0.10.0-dev", path = "../network/light" }
+sc-network-sync = { version = "0.10.0-dev", path = "../network/sync" }
+sc-network-transactions = { version = "0.10.0-dev", path = "../network/transactions" }
+sc-chain-spec = { version = "4.0.0-dev", path = "../chain-spec" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sc-client-db = { version = "0.10.0-dev", default-features = false, path = "../db" }
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+sc-executor = { version = "0.10.0-dev", path = "../executor" }
+sc-transaction-pool = { version = "4.0.0-dev", path = "../transaction-pool" }
+sp-transaction-pool = { version = "4.0.0-dev", path = "../../primitives/transaction-pool" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../transaction-pool/api" }
+sp-transaction-storage-proof = { version = "4.0.0-dev", path = "../../primitives/transaction-storage-proof" }
+sc-rpc-server = { version = "4.0.0-dev", path = "../rpc-servers" }
+sc-rpc = { version = "4.0.0-dev", path = "../rpc" }
+sc-rpc-spec-v2 = { version = "0.10.0-dev", path = "../rpc-spec-v2" }
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sc-informant = { version = "0.10.0-dev", path = "../informant" }
+sc-telemetry = { version = "4.0.0-dev", path = "../telemetry" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../utils/prometheus", version = "0.10.0-dev" }
+sc-tracing = { version = "4.0.0-dev", path = "../tracing" }
+sc-sysinfo = { version = "6.0.0-dev", path = "../sysinfo" }
+tracing = "0.1.29"
+tracing-futures = { version = "0.2.4" }
+async-trait = "0.1.57"
+tokio = { version = "1.22.0", features = ["time", "rt-multi-thread", "parking_lot"] }
+tempfile = "3.1.0"
+directories = "4.0.1"
+static_init = "1.0.3"
+
+[dev-dependencies]
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime/" }
diff --git a/substrate/client/service/README.md b/substrate/client/service/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..26f940f16df02328ad03e728e2a033ce3013acc6
--- /dev/null
+++ b/substrate/client/service/README.md
@@ -0,0 +1,4 @@
+Substrate service. Starts a thread that spins up the network, client, and extrinsic pool.
+Manages communication between them.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/service/src/builder.rs b/substrate/client/service/src/builder.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe18d1d002d56c9a6ab7ae6a3175be488f660c90
--- /dev/null
+++ b/substrate/client/service/src/builder.rs
@@ -0,0 +1,999 @@
+// 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::{
+	build_network_future, build_system_rpc_future,
+	client::{Client, ClientConfig},
+	config::{Configuration, KeystoreConfig, PrometheusConfig},
+	error::Error,
+	metrics::MetricsService,
+	start_rpc_servers, BuildGenesisBlock, GenesisBlockBuilder, RpcHandlers, SpawnTaskHandle,
+	TaskManager, TransactionPoolAdapter,
+};
+use futures::{channel::oneshot, future::ready, FutureExt, StreamExt};
+use jsonrpsee::RpcModule;
+use log::info;
+use prometheus_endpoint::Registry;
+use sc_chain_spec::get_extension;
+use sc_client_api::{
+	execution_extensions::ExecutionExtensions, proof_provider::ProofProvider, BadBlocks,
+	BlockBackend, BlockchainEvents, ExecutorProvider, ForkBlocks, StorageProvider, UsageProvider,
+};
+use sc_client_db::{Backend, DatabaseSettings};
+use sc_consensus::import_queue::ImportQueue;
+use sc_executor::{
+	sp_wasm_interface::HostFunctions, HeapAllocStrategy, NativeElseWasmExecutor,
+	NativeExecutionDispatch, RuntimeVersionOf, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY,
+};
+use sc_keystore::LocalKeystore;
+use sc_network::{
+	config::{FullNetworkConfiguration, SyncMode},
+	peer_store::PeerStore,
+	NetworkService, NetworkStateInfo, NetworkStatusProvider,
+};
+use sc_network_bitswap::BitswapRequestHandler;
+use sc_network_common::{role::Roles, sync::warp::WarpSyncParams};
+use sc_network_light::light_client_requests::handler::LightClientRequestHandler;
+use sc_network_sync::{
+	block_request_handler::BlockRequestHandler, engine::SyncingEngine,
+	service::network::NetworkServiceProvider, state_request_handler::StateRequestHandler,
+	warp_request_handler::RequestHandler as WarpSyncRequestHandler, SyncingService,
+};
+use sc_rpc::{
+	author::AuthorApiServer,
+	chain::ChainApiServer,
+	offchain::OffchainApiServer,
+	state::{ChildStateApiServer, StateApiServer},
+	system::SystemApiServer,
+	DenyUnsafe, SubscriptionTaskExecutor,
+};
+use sc_rpc_spec_v2::{chain_head::ChainHeadApiServer, transaction::TransactionApiServer};
+use sc_telemetry::{telemetry, ConnectionMessage, Telemetry, TelemetryHandle, SUBSTRATE_INFO};
+use sc_transaction_pool_api::{MaintainedTransactionPool, TransactionPool};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedSender};
+use sp_api::{CallApiAt, ProvideRuntimeApi};
+use sp_blockchain::{HeaderBackend, HeaderMetadata};
+use sp_consensus::block_validation::{
+	BlockAnnounceValidator, Chain, DefaultBlockAnnounceValidator,
+};
+use sp_core::traits::{CodeExecutor, SpawnNamed};
+use sp_keystore::KeystorePtr;
+use sp_runtime::traits::{Block as BlockT, BlockIdTo, NumberFor, Zero};
+use std::{str::FromStr, sync::Arc, time::SystemTime};
+
+/// Full client type.
+pub type TFullClient<TBl, TRtApi, TExec> =
+	Client<TFullBackend<TBl>, TFullCallExecutor<TBl, TExec>, TBl, TRtApi>;
+
+/// Full client backend type.
+pub type TFullBackend<TBl> = Backend<TBl>;
+
+/// Full client call executor type.
+pub type TFullCallExecutor<TBl, TExec> = crate::client::LocalCallExecutor<TBl, Backend<TBl>, TExec>;
+
+type TFullParts<TBl, TRtApi, TExec> =
+	(TFullClient<TBl, TRtApi, TExec>, Arc<TFullBackend<TBl>>, KeystoreContainer, TaskManager);
+
+/// Construct a local keystore shareable container
+pub struct KeystoreContainer(Arc<LocalKeystore>);
+
+impl KeystoreContainer {
+	/// Construct KeystoreContainer
+	pub fn new(config: &KeystoreConfig) -> Result<Self, Error> {
+		let keystore = Arc::new(match config {
+			KeystoreConfig::Path { path, password } =>
+				LocalKeystore::open(path.clone(), password.clone())?,
+			KeystoreConfig::InMemory => LocalKeystore::in_memory(),
+		});
+
+		Ok(Self(keystore))
+	}
+
+	/// Returns a shared reference to a dynamic `Keystore` trait implementation.
+	pub fn keystore(&self) -> KeystorePtr {
+		self.0.clone()
+	}
+
+	/// Returns a shared reference to the local keystore .
+	pub fn local_keystore(&self) -> Arc<LocalKeystore> {
+		self.0.clone()
+	}
+}
+
+/// Creates a new full client for the given config.
+pub fn new_full_client<TBl, TRtApi, TExec>(
+	config: &Configuration,
+	telemetry: Option<TelemetryHandle>,
+	executor: TExec,
+) -> Result<TFullClient<TBl, TRtApi, TExec>, Error>
+where
+	TBl: BlockT,
+	TExec: CodeExecutor + RuntimeVersionOf + Clone,
+{
+	new_full_parts(config, telemetry, executor).map(|parts| parts.0)
+}
+
+/// Create the initial parts of a full node with the default genesis block builder.
+pub fn new_full_parts<TBl, TRtApi, TExec>(
+	config: &Configuration,
+	telemetry: Option<TelemetryHandle>,
+	executor: TExec,
+) -> Result<TFullParts<TBl, TRtApi, TExec>, Error>
+where
+	TBl: BlockT,
+	TExec: CodeExecutor + RuntimeVersionOf + Clone,
+{
+	let backend = new_db_backend(config.db_config())?;
+
+	let genesis_block_builder = GenesisBlockBuilder::new(
+		config.chain_spec.as_storage_builder(),
+		!config.no_genesis(),
+		backend.clone(),
+		executor.clone(),
+	)?;
+
+	new_full_parts_with_genesis_builder(config, telemetry, executor, backend, genesis_block_builder)
+}
+
+/// Create the initial parts of a full node.
+pub fn new_full_parts_with_genesis_builder<TBl, TRtApi, TExec, TBuildGenesisBlock>(
+	config: &Configuration,
+	telemetry: Option<TelemetryHandle>,
+	executor: TExec,
+	backend: Arc<TFullBackend<TBl>>,
+	genesis_block_builder: TBuildGenesisBlock,
+) -> Result<TFullParts<TBl, TRtApi, TExec>, Error>
+where
+	TBl: BlockT,
+	TExec: CodeExecutor + RuntimeVersionOf + Clone,
+	TBuildGenesisBlock: BuildGenesisBlock<
+		TBl,
+		BlockImportOperation = <Backend<TBl> as sc_client_api::backend::Backend<TBl>>::BlockImportOperation
+	>,
+{
+	let keystore_container = KeystoreContainer::new(&config.keystore)?;
+
+	let task_manager = {
+		let registry = config.prometheus_config.as_ref().map(|cfg| &cfg.registry);
+		TaskManager::new(config.tokio_handle.clone(), registry)?
+	};
+
+	let chain_spec = &config.chain_spec;
+	let fork_blocks = get_extension::<ForkBlocks<TBl>>(chain_spec.extensions())
+		.cloned()
+		.unwrap_or_default();
+
+	let bad_blocks = get_extension::<BadBlocks<TBl>>(chain_spec.extensions())
+		.cloned()
+		.unwrap_or_default();
+
+	let client = {
+		let extensions = sc_client_api::execution_extensions::ExecutionExtensions::new(
+			None,
+			Arc::new(executor.clone()),
+		);
+
+		let wasm_runtime_substitutes = config
+			.chain_spec
+			.code_substitutes()
+			.into_iter()
+			.map(|(n, c)| {
+				let number = NumberFor::<TBl>::from_str(&n).map_err(|_| {
+					Error::Application(Box::from(format!(
+						"Failed to parse `{}` as block number for code substitutes. \
+						 In an old version the key for code substitute was a block hash. \
+						 Please update the chain spec to a version that is compatible with your node.",
+						n
+					)))
+				})?;
+				Ok((number, c))
+			})
+			.collect::<Result<std::collections::HashMap<_, _>, Error>>()?;
+
+		let client = new_client(
+			backend.clone(),
+			executor,
+			genesis_block_builder,
+			fork_blocks,
+			bad_blocks,
+			extensions,
+			Box::new(task_manager.spawn_handle()),
+			config.prometheus_config.as_ref().map(|config| config.registry.clone()),
+			telemetry,
+			ClientConfig {
+				offchain_worker_enabled: config.offchain_worker.enabled,
+				offchain_indexing_api: config.offchain_worker.indexing_enabled,
+				wasm_runtime_overrides: config.wasm_runtime_overrides.clone(),
+				no_genesis: matches!(
+					config.network.sync_mode,
+					SyncMode::LightState { .. } | SyncMode::Warp { .. }
+				),
+				wasm_runtime_substitutes,
+			},
+		)?;
+
+		client
+	};
+
+	Ok((client, backend, keystore_container, task_manager))
+}
+
+/// Creates a [`NativeElseWasmExecutor`] according to [`Configuration`].
+pub fn new_native_or_wasm_executor<D: NativeExecutionDispatch>(
+	config: &Configuration,
+) -> NativeElseWasmExecutor<D> {
+	NativeElseWasmExecutor::new_with_wasm_executor(new_wasm_executor(config))
+}
+
+/// Creates a [`WasmExecutor`] according to [`Configuration`].
+pub fn new_wasm_executor<H: HostFunctions>(config: &Configuration) -> WasmExecutor<H> {
+	let strategy = config
+		.default_heap_pages
+		.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |p| HeapAllocStrategy::Static { extra_pages: p as _ });
+	WasmExecutor::<H>::builder()
+		.with_execution_method(config.wasm_method)
+		.with_onchain_heap_alloc_strategy(strategy)
+		.with_offchain_heap_alloc_strategy(strategy)
+		.with_max_runtime_instances(config.max_runtime_instances)
+		.with_runtime_cache_size(config.runtime_cache_size)
+		.build()
+}
+
+/// Create an instance of default DB-backend backend.
+pub fn new_db_backend<Block>(
+	settings: DatabaseSettings,
+) -> Result<Arc<Backend<Block>>, sp_blockchain::Error>
+where
+	Block: BlockT,
+{
+	const CANONICALIZATION_DELAY: u64 = 4096;
+
+	Ok(Arc::new(Backend::new(settings, CANONICALIZATION_DELAY)?))
+}
+
+/// Create an instance of client backed by given backend.
+pub fn new_client<E, Block, RA, G>(
+	backend: Arc<Backend<Block>>,
+	executor: E,
+	genesis_block_builder: G,
+	fork_blocks: ForkBlocks<Block>,
+	bad_blocks: BadBlocks<Block>,
+	execution_extensions: ExecutionExtensions<Block>,
+	spawn_handle: Box<dyn SpawnNamed>,
+	prometheus_registry: Option<Registry>,
+	telemetry: Option<TelemetryHandle>,
+	config: ClientConfig<Block>,
+) -> Result<
+	Client<
+		Backend<Block>,
+		crate::client::LocalCallExecutor<Block, Backend<Block>, E>,
+		Block,
+		RA,
+	>,
+	sp_blockchain::Error,
+>
+where
+	Block: BlockT,
+	E: CodeExecutor + RuntimeVersionOf,
+	G: BuildGenesisBlock<
+		Block,
+		BlockImportOperation = <Backend<Block> as sc_client_api::backend::Backend<Block>>::BlockImportOperation
+	>,
+{
+	let executor = crate::client::LocalCallExecutor::new(
+		backend.clone(),
+		executor,
+		config.clone(),
+		execution_extensions,
+	)?;
+
+	Client::new(
+		backend,
+		executor,
+		spawn_handle,
+		genesis_block_builder,
+		fork_blocks,
+		bad_blocks,
+		prometheus_registry,
+		telemetry,
+		config,
+	)
+}
+
+/// Shared network instance implementing a set of mandatory traits.
+pub trait SpawnTaskNetwork<Block: BlockT>:
+	NetworkStateInfo + NetworkStatusProvider + Send + Sync + 'static
+{
+}
+
+impl<T, Block> SpawnTaskNetwork<Block> for T
+where
+	Block: BlockT,
+	T: NetworkStateInfo + NetworkStatusProvider + Send + Sync + 'static,
+{
+}
+
+/// Parameters to pass into `build`.
+pub struct SpawnTasksParams<'a, TBl: BlockT, TCl, TExPool, TRpc, Backend> {
+	/// The service configuration.
+	pub config: Configuration,
+	/// A shared client returned by `new_full_parts`.
+	pub client: Arc<TCl>,
+	/// A shared backend returned by `new_full_parts`.
+	pub backend: Arc<Backend>,
+	/// A task manager returned by `new_full_parts`.
+	pub task_manager: &'a mut TaskManager,
+	/// A shared keystore returned by `new_full_parts`.
+	pub keystore: KeystorePtr,
+	/// A shared transaction pool.
+	pub transaction_pool: Arc<TExPool>,
+	/// Builds additional [`RpcModule`]s that should be added to the server
+	pub rpc_builder:
+		Box<dyn Fn(DenyUnsafe, SubscriptionTaskExecutor) -> Result<RpcModule<TRpc>, Error>>,
+	/// A shared network instance.
+	pub network: Arc<dyn SpawnTaskNetwork<TBl>>,
+	/// A Sender for RPC requests.
+	pub system_rpc_tx: TracingUnboundedSender<sc_rpc::system::Request<TBl>>,
+	/// Controller for transactions handlers
+	pub tx_handler_controller:
+		sc_network_transactions::TransactionsHandlerController<<TBl as BlockT>::Hash>,
+	/// Syncing service.
+	pub sync_service: Arc<SyncingService<TBl>>,
+	/// Telemetry instance for this node.
+	pub telemetry: Option<&'a mut Telemetry>,
+}
+
+/// Spawn the tasks that are required to run a node.
+pub fn spawn_tasks<TBl, TBackend, TExPool, TRpc, TCl>(
+	params: SpawnTasksParams<TBl, TCl, TExPool, TRpc, TBackend>,
+) -> Result<RpcHandlers, Error>
+where
+	TCl: ProvideRuntimeApi<TBl>
+		+ HeaderMetadata<TBl, Error = sp_blockchain::Error>
+		+ Chain<TBl>
+		+ BlockBackend<TBl>
+		+ BlockIdTo<TBl, Error = sp_blockchain::Error>
+		+ ProofProvider<TBl>
+		+ HeaderBackend<TBl>
+		+ BlockchainEvents<TBl>
+		+ ExecutorProvider<TBl>
+		+ UsageProvider<TBl>
+		+ StorageProvider<TBl, TBackend>
+		+ CallApiAt<TBl>
+		+ Send
+		+ 'static,
+	<TCl as ProvideRuntimeApi<TBl>>::Api: sp_api::Metadata<TBl>
+		+ sp_transaction_pool::runtime_api::TaggedTransactionQueue<TBl>
+		+ sp_session::SessionKeys<TBl>
+		+ sp_api::ApiExt<TBl>,
+	TBl: BlockT,
+	TBl::Hash: Unpin,
+	TBl::Header: Unpin,
+	TBackend: 'static + sc_client_api::backend::Backend<TBl> + Send,
+	TExPool: MaintainedTransactionPool<Block = TBl, Hash = <TBl as BlockT>::Hash> + 'static,
+{
+	let SpawnTasksParams {
+		mut config,
+		task_manager,
+		client,
+		backend,
+		keystore,
+		transaction_pool,
+		rpc_builder,
+		network,
+		system_rpc_tx,
+		tx_handler_controller,
+		sync_service,
+		telemetry,
+	} = params;
+
+	let chain_info = client.usage_info().chain;
+
+	sp_session::generate_initial_session_keys(
+		client.clone(),
+		chain_info.best_hash,
+		config.dev_key_seed.clone().map(|s| vec![s]).unwrap_or_default(),
+		keystore.clone(),
+	)
+	.map_err(|e| Error::Application(Box::new(e)))?;
+
+	let sysinfo = sc_sysinfo::gather_sysinfo();
+	sc_sysinfo::print_sysinfo(&sysinfo);
+
+	let telemetry = telemetry
+		.map(|telemetry| {
+			init_telemetry(&mut config, network.clone(), client.clone(), telemetry, Some(sysinfo))
+		})
+		.transpose()?;
+
+	info!("📦 Highest known block at #{}", chain_info.best_number);
+
+	let spawn_handle = task_manager.spawn_handle();
+
+	// Inform the tx pool about imported and finalized blocks.
+	spawn_handle.spawn(
+		"txpool-notifications",
+		Some("transaction-pool"),
+		sc_transaction_pool::notification_future(client.clone(), transaction_pool.clone()),
+	);
+
+	spawn_handle.spawn(
+		"on-transaction-imported",
+		Some("transaction-pool"),
+		transaction_notifications(
+			transaction_pool.clone(),
+			tx_handler_controller,
+			telemetry.clone(),
+		),
+	);
+
+	// Prometheus metrics.
+	let metrics_service =
+		if let Some(PrometheusConfig { port, registry }) = config.prometheus_config.clone() {
+			// Set static metrics.
+			let metrics = MetricsService::with_prometheus(telemetry, &registry, &config)?;
+			spawn_handle.spawn(
+				"prometheus-endpoint",
+				None,
+				prometheus_endpoint::init_prometheus(port, registry).map(drop),
+			);
+
+			metrics
+		} else {
+			MetricsService::new(telemetry)
+		};
+
+	// Periodically updated metrics and telemetry updates.
+	spawn_handle.spawn(
+		"telemetry-periodic-send",
+		None,
+		metrics_service.run(
+			client.clone(),
+			transaction_pool.clone(),
+			network.clone(),
+			sync_service.clone(),
+		),
+	);
+
+	let rpc_id_provider = config.rpc_id_provider.take();
+
+	// jsonrpsee RPC
+	let gen_rpc_module = |deny_unsafe: DenyUnsafe| {
+		gen_rpc_module(
+			deny_unsafe,
+			task_manager.spawn_handle(),
+			client.clone(),
+			transaction_pool.clone(),
+			keystore.clone(),
+			system_rpc_tx.clone(),
+			&config,
+			backend.clone(),
+			&*rpc_builder,
+		)
+	};
+
+	let rpc = start_rpc_servers(&config, gen_rpc_module, rpc_id_provider)?;
+	let rpc_handlers = RpcHandlers(Arc::new(gen_rpc_module(sc_rpc::DenyUnsafe::No)?.into()));
+
+	// Spawn informant task
+	spawn_handle.spawn(
+		"informant",
+		None,
+		sc_informant::build(
+			client.clone(),
+			network,
+			sync_service.clone(),
+			config.informant_output_format,
+		),
+	);
+
+	task_manager.keep_alive((config.base_path, rpc));
+
+	Ok(rpc_handlers)
+}
+
+async fn transaction_notifications<Block, ExPool>(
+	transaction_pool: Arc<ExPool>,
+	tx_handler_controller: sc_network_transactions::TransactionsHandlerController<
+		<Block as BlockT>::Hash,
+	>,
+	telemetry: Option<TelemetryHandle>,
+) where
+	Block: BlockT,
+	ExPool: MaintainedTransactionPool<Block = Block, Hash = <Block as BlockT>::Hash>,
+{
+	// transaction notifications
+	transaction_pool
+		.import_notification_stream()
+		.for_each(move |hash| {
+			tx_handler_controller.propagate_transaction(hash);
+			let status = transaction_pool.status();
+			telemetry!(
+				telemetry;
+				SUBSTRATE_INFO;
+				"txpool.import";
+				"ready" => status.ready,
+				"future" => status.future,
+			);
+			ready(())
+		})
+		.await;
+}
+
+fn init_telemetry<Block, Client, Network>(
+	config: &mut Configuration,
+	network: Network,
+	client: Arc<Client>,
+	telemetry: &mut Telemetry,
+	sysinfo: Option<sc_telemetry::SysInfo>,
+) -> sc_telemetry::Result<TelemetryHandle>
+where
+	Block: BlockT,
+	Client: BlockBackend<Block>,
+	Network: NetworkStateInfo,
+{
+	let genesis_hash = client.block_hash(Zero::zero()).ok().flatten().unwrap_or_default();
+	let connection_message = ConnectionMessage {
+		name: config.network.node_name.to_owned(),
+		implementation: config.impl_name.to_owned(),
+		version: config.impl_version.to_owned(),
+		target_os: sc_sysinfo::TARGET_OS.into(),
+		target_arch: sc_sysinfo::TARGET_ARCH.into(),
+		target_env: sc_sysinfo::TARGET_ENV.into(),
+		config: String::new(),
+		chain: config.chain_spec.name().to_owned(),
+		genesis_hash: format!("{:?}", genesis_hash),
+		authority: config.role.is_authority(),
+		startup_time: SystemTime::UNIX_EPOCH
+			.elapsed()
+			.map(|dur| dur.as_millis())
+			.unwrap_or(0)
+			.to_string(),
+		network_id: network.local_peer_id().to_base58(),
+		sysinfo,
+	};
+
+	telemetry.start_telemetry(connection_message)?;
+
+	Ok(telemetry.handle())
+}
+
+fn gen_rpc_module<TBl, TBackend, TCl, TRpc, TExPool>(
+	deny_unsafe: DenyUnsafe,
+	spawn_handle: SpawnTaskHandle,
+	client: Arc<TCl>,
+	transaction_pool: Arc<TExPool>,
+	keystore: KeystorePtr,
+	system_rpc_tx: TracingUnboundedSender<sc_rpc::system::Request<TBl>>,
+	config: &Configuration,
+	backend: Arc<TBackend>,
+	rpc_builder: &(dyn Fn(DenyUnsafe, SubscriptionTaskExecutor) -> Result<RpcModule<TRpc>, Error>),
+) -> Result<RpcModule<()>, Error>
+where
+	TBl: BlockT,
+	TCl: ProvideRuntimeApi<TBl>
+		+ BlockchainEvents<TBl>
+		+ HeaderBackend<TBl>
+		+ HeaderMetadata<TBl, Error = sp_blockchain::Error>
+		+ ExecutorProvider<TBl>
+		+ CallApiAt<TBl>
+		+ ProofProvider<TBl>
+		+ StorageProvider<TBl, TBackend>
+		+ BlockBackend<TBl>
+		+ Send
+		+ Sync
+		+ 'static,
+	TBackend: sc_client_api::backend::Backend<TBl> + 'static,
+	<TCl as ProvideRuntimeApi<TBl>>::Api: sp_session::SessionKeys<TBl> + sp_api::Metadata<TBl>,
+	TExPool: MaintainedTransactionPool<Block = TBl, Hash = <TBl as BlockT>::Hash> + 'static,
+	TBl::Hash: Unpin,
+	TBl::Header: Unpin,
+{
+	let system_info = sc_rpc::system::SystemInfo {
+		chain_name: config.chain_spec.name().into(),
+		impl_name: config.impl_name.clone(),
+		impl_version: config.impl_version.clone(),
+		properties: config.chain_spec.properties(),
+		chain_type: config.chain_spec.chain_type(),
+	};
+
+	let mut rpc_api = RpcModule::new(());
+	let task_executor = Arc::new(spawn_handle);
+
+	let (chain, state, child_state) = {
+		let chain = sc_rpc::chain::new_full(client.clone(), task_executor.clone()).into_rpc();
+		let (state, child_state) =
+			sc_rpc::state::new_full(client.clone(), task_executor.clone(), deny_unsafe);
+		let state = state.into_rpc();
+		let child_state = child_state.into_rpc();
+
+		(chain, state, child_state)
+	};
+
+	let transaction_v2 = sc_rpc_spec_v2::transaction::Transaction::new(
+		client.clone(),
+		transaction_pool.clone(),
+		task_executor.clone(),
+	)
+	.into_rpc();
+
+	let chain_head_v2 = sc_rpc_spec_v2::chain_head::ChainHead::new(
+		client.clone(),
+		backend.clone(),
+		task_executor.clone(),
+		client.info().genesis_hash,
+		// Defaults to sensible limits for the `ChainHead`.
+		sc_rpc_spec_v2::chain_head::ChainHeadConfig::default(),
+	)
+	.into_rpc();
+
+	let author = sc_rpc::author::Author::new(
+		client.clone(),
+		transaction_pool,
+		keystore,
+		deny_unsafe,
+		task_executor.clone(),
+	)
+	.into_rpc();
+
+	let system = sc_rpc::system::System::new(system_info, system_rpc_tx, deny_unsafe).into_rpc();
+
+	if let Some(storage) = backend.offchain_storage() {
+		let offchain = sc_rpc::offchain::Offchain::new(storage, deny_unsafe).into_rpc();
+
+		rpc_api.merge(offchain).map_err(|e| Error::Application(e.into()))?;
+	}
+
+	// Part of the RPC v2 spec.
+	rpc_api.merge(transaction_v2).map_err(|e| Error::Application(e.into()))?;
+	rpc_api.merge(chain_head_v2).map_err(|e| Error::Application(e.into()))?;
+
+	// Part of the old RPC spec.
+	rpc_api.merge(chain).map_err(|e| Error::Application(e.into()))?;
+	rpc_api.merge(author).map_err(|e| Error::Application(e.into()))?;
+	rpc_api.merge(system).map_err(|e| Error::Application(e.into()))?;
+	rpc_api.merge(state).map_err(|e| Error::Application(e.into()))?;
+	rpc_api.merge(child_state).map_err(|e| Error::Application(e.into()))?;
+	// Additional [`RpcModule`]s defined in the node to fit the specific blockchain
+	let extra_rpcs = rpc_builder(deny_unsafe, task_executor.clone())?;
+	rpc_api.merge(extra_rpcs).map_err(|e| Error::Application(e.into()))?;
+
+	Ok(rpc_api)
+}
+
+/// Parameters to pass into `build_network`.
+pub struct BuildNetworkParams<'a, TBl: BlockT, TExPool, TImpQu, TCl> {
+	/// The service configuration.
+	pub config: &'a Configuration,
+	/// Full network configuration.
+	pub net_config: FullNetworkConfiguration,
+	/// A shared client returned by `new_full_parts`.
+	pub client: Arc<TCl>,
+	/// A shared transaction pool.
+	pub transaction_pool: Arc<TExPool>,
+	/// A handle for spawning tasks.
+	pub spawn_handle: SpawnTaskHandle,
+	/// An import queue.
+	pub import_queue: TImpQu,
+	/// A block announce validator builder.
+	pub block_announce_validator_builder:
+		Option<Box<dyn FnOnce(Arc<TCl>) -> Box<dyn BlockAnnounceValidator<TBl> + Send> + Send>>,
+	/// Optional warp sync params.
+	pub warp_sync_params: Option<WarpSyncParams<TBl>>,
+}
+
+/// Build the network service, the network status sinks and an RPC sender.
+pub fn build_network<TBl, TExPool, TImpQu, TCl>(
+	params: BuildNetworkParams<TBl, TExPool, TImpQu, TCl>,
+) -> Result<
+	(
+		Arc<NetworkService<TBl, <TBl as BlockT>::Hash>>,
+		TracingUnboundedSender<sc_rpc::system::Request<TBl>>,
+		sc_network_transactions::TransactionsHandlerController<<TBl as BlockT>::Hash>,
+		NetworkStarter,
+		Arc<SyncingService<TBl>>,
+	),
+	Error,
+>
+where
+	TBl: BlockT,
+	TCl: ProvideRuntimeApi<TBl>
+		+ HeaderMetadata<TBl, Error = sp_blockchain::Error>
+		+ Chain<TBl>
+		+ BlockBackend<TBl>
+		+ BlockIdTo<TBl, Error = sp_blockchain::Error>
+		+ ProofProvider<TBl>
+		+ HeaderBackend<TBl>
+		+ BlockchainEvents<TBl>
+		+ 'static,
+	TExPool: TransactionPool<Block = TBl, Hash = <TBl as BlockT>::Hash> + 'static,
+	TImpQu: ImportQueue<TBl> + 'static,
+{
+	let BuildNetworkParams {
+		config,
+		mut net_config,
+		client,
+		transaction_pool,
+		spawn_handle,
+		import_queue,
+		block_announce_validator_builder,
+		warp_sync_params,
+	} = params;
+
+	if warp_sync_params.is_none() && config.network.sync_mode.is_warp() {
+		return Err("Warp sync enabled, but no warp sync provider configured.".into())
+	}
+
+	if client.requires_full_sync() {
+		match config.network.sync_mode {
+			SyncMode::LightState { .. } =>
+				return Err("Fast sync doesn't work for archive nodes".into()),
+			SyncMode::Warp => return Err("Warp sync doesn't work for archive nodes".into()),
+			SyncMode::Full => {},
+		}
+	}
+
+	let protocol_id = config.protocol_id();
+
+	let block_announce_validator = if let Some(f) = block_announce_validator_builder {
+		f(client.clone())
+	} else {
+		Box::new(DefaultBlockAnnounceValidator)
+	};
+
+	let (block_request_protocol_config, block_request_protocol_name) = {
+		// Allow both outgoing and incoming requests.
+		let (handler, protocol_config) = BlockRequestHandler::new(
+			&protocol_id,
+			config.chain_spec.fork_id(),
+			client.clone(),
+			net_config.network_config.default_peers_set.in_peers as usize +
+				net_config.network_config.default_peers_set.out_peers as usize,
+		);
+		let config_name = protocol_config.name.clone();
+		spawn_handle.spawn("block-request-handler", Some("networking"), handler.run());
+		(protocol_config, config_name)
+	};
+
+	let (state_request_protocol_config, state_request_protocol_name) = {
+		let num_peer_hint = net_config.network_config.default_peers_set_num_full as usize +
+			net_config.network_config.default_peers_set.reserved_nodes.len();
+		// Allow both outgoing and incoming requests.
+		let (handler, protocol_config) = StateRequestHandler::new(
+			&protocol_id,
+			config.chain_spec.fork_id(),
+			client.clone(),
+			num_peer_hint,
+		);
+		let config_name = protocol_config.name.clone();
+
+		spawn_handle.spawn("state-request-handler", Some("networking"), handler.run());
+		(protocol_config, config_name)
+	};
+
+	let (warp_sync_protocol_config, warp_request_protocol_name) = match warp_sync_params.as_ref() {
+		Some(WarpSyncParams::WithProvider(warp_with_provider)) => {
+			// Allow both outgoing and incoming requests.
+			let (handler, protocol_config) = WarpSyncRequestHandler::new(
+				protocol_id.clone(),
+				client
+					.block_hash(0u32.into())
+					.ok()
+					.flatten()
+					.expect("Genesis block exists; qed"),
+				config.chain_spec.fork_id(),
+				warp_with_provider.clone(),
+			);
+			let config_name = protocol_config.name.clone();
+
+			spawn_handle.spawn("warp-sync-request-handler", Some("networking"), handler.run());
+			(Some(protocol_config), Some(config_name))
+		},
+		_ => (None, None),
+	};
+
+	let light_client_request_protocol_config = {
+		// Allow both outgoing and incoming requests.
+		let (handler, protocol_config) = LightClientRequestHandler::new(
+			&protocol_id,
+			config.chain_spec.fork_id(),
+			client.clone(),
+		);
+		spawn_handle.spawn("light-client-request-handler", Some("networking"), handler.run());
+		protocol_config
+	};
+
+	// install request handlers to `FullNetworkConfiguration`
+	net_config.add_request_response_protocol(block_request_protocol_config);
+	net_config.add_request_response_protocol(state_request_protocol_config);
+	net_config.add_request_response_protocol(light_client_request_protocol_config);
+
+	if let Some(config) = warp_sync_protocol_config {
+		net_config.add_request_response_protocol(config);
+	}
+
+	if config.network.ipfs_server {
+		let (handler, protocol_config) = BitswapRequestHandler::new(client.clone());
+		spawn_handle.spawn("bitswap-request-handler", Some("networking"), handler.run());
+		net_config.add_request_response_protocol(protocol_config);
+	}
+
+	// create transactions protocol and add it to the list of supported protocols of
+	// `network_params`
+	let transactions_handler_proto = sc_network_transactions::TransactionsHandlerPrototype::new(
+		protocol_id.clone(),
+		client
+			.block_hash(0u32.into())
+			.ok()
+			.flatten()
+			.expect("Genesis block exists; qed"),
+		config.chain_spec.fork_id(),
+	);
+	net_config.add_notification_protocol(transactions_handler_proto.set_config());
+
+	// Create `PeerStore` and initialize it with bootnode peer ids.
+	let peer_store = PeerStore::new(
+		net_config
+			.network_config
+			.boot_nodes
+			.iter()
+			.map(|bootnode| bootnode.peer_id)
+			.collect(),
+	);
+	let peer_store_handle = peer_store.handle();
+	spawn_handle.spawn("peer-store", Some("networking"), peer_store.run());
+
+	let (tx, rx) = sc_utils::mpsc::tracing_unbounded("mpsc_syncing_engine_protocol", 100_000);
+	let (chain_sync_network_provider, chain_sync_network_handle) = NetworkServiceProvider::new();
+	let (engine, sync_service, block_announce_config) = SyncingEngine::new(
+		Roles::from(&config.role),
+		client.clone(),
+		config.prometheus_config.as_ref().map(|config| config.registry.clone()).as_ref(),
+		&net_config,
+		protocol_id.clone(),
+		&config.chain_spec.fork_id().map(ToOwned::to_owned),
+		block_announce_validator,
+		warp_sync_params,
+		chain_sync_network_handle,
+		import_queue.service(),
+		block_request_protocol_name,
+		state_request_protocol_name,
+		warp_request_protocol_name,
+		rx,
+	)?;
+	let sync_service_import_queue = sync_service.clone();
+	let sync_service = Arc::new(sync_service);
+
+	let genesis_hash = client.hash(Zero::zero()).ok().flatten().expect("Genesis block exists; qed");
+	let network_params = sc_network::config::Params::<TBl> {
+		role: config.role.clone(),
+		executor: {
+			let spawn_handle = Clone::clone(&spawn_handle);
+			Box::new(move |fut| {
+				spawn_handle.spawn("libp2p-node", Some("networking"), fut);
+			})
+		},
+		network_config: net_config,
+		peer_store: peer_store_handle,
+		genesis_hash,
+		protocol_id: protocol_id.clone(),
+		fork_id: config.chain_spec.fork_id().map(ToOwned::to_owned),
+		metrics_registry: config.prometheus_config.as_ref().map(|config| config.registry.clone()),
+		block_announce_config,
+		tx,
+	};
+
+	let has_bootnodes = !network_params.network_config.network_config.boot_nodes.is_empty();
+	let network_mut = sc_network::NetworkWorker::new(network_params)?;
+	let network = network_mut.service().clone();
+
+	let (tx_handler, tx_handler_controller) = transactions_handler_proto.build(
+		network.clone(),
+		sync_service.clone(),
+		Arc::new(TransactionPoolAdapter { pool: transaction_pool, client: client.clone() }),
+		config.prometheus_config.as_ref().map(|config| &config.registry),
+	)?;
+	spawn_handle.spawn("network-transactions-handler", Some("networking"), tx_handler.run());
+
+	spawn_handle.spawn_blocking(
+		"chain-sync-network-service-provider",
+		Some("networking"),
+		chain_sync_network_provider.run(network.clone()),
+	);
+	spawn_handle.spawn("import-queue", None, import_queue.run(Box::new(sync_service_import_queue)));
+	spawn_handle.spawn_blocking("syncing", None, engine.run());
+
+	let (system_rpc_tx, system_rpc_rx) = tracing_unbounded("mpsc_system_rpc", 10_000);
+	spawn_handle.spawn(
+		"system-rpc-handler",
+		Some("networking"),
+		build_system_rpc_future(
+			config.role.clone(),
+			network_mut.service().clone(),
+			sync_service.clone(),
+			client.clone(),
+			system_rpc_rx,
+			has_bootnodes,
+		),
+	);
+
+	let future =
+		build_network_future(network_mut, client, sync_service.clone(), config.announce_block);
+
+	// TODO: Normally, one is supposed to pass a list of notifications protocols supported by the
+	// node through the `NetworkConfiguration` struct. But because this function doesn't know in
+	// advance which components, such as GrandPa or Polkadot, will be plugged on top of the
+	// service, it is unfortunately not possible to do so without some deep refactoring. To bypass
+	// this problem, the `NetworkService` provides a `register_notifications_protocol` method that
+	// can be called even after the network has been initialized. However, we want to avoid the
+	// situation where `register_notifications_protocol` is called *after* the network actually
+	// connects to other peers. For this reason, we delay the process of the network future until
+	// the user calls `NetworkStarter::start_network`.
+	//
+	// This entire hack should eventually be removed in favour of passing the list of protocols
+	// through the configuration.
+	//
+	// See also https://github.com/paritytech/substrate/issues/6827
+	let (network_start_tx, network_start_rx) = oneshot::channel();
+
+	// The network worker is responsible for gathering all network messages and processing
+	// them. This is quite a heavy task, and at the time of the writing of this comment it
+	// frequently happens that this future takes several seconds or in some situations
+	// even more than a minute until it has processed its entire queue. This is clearly an
+	// issue, and ideally we would like to fix the network future to take as little time as
+	// possible, but we also take the extra harm-prevention measure to execute the networking
+	// future using `spawn_blocking`.
+	spawn_handle.spawn_blocking("network-worker", Some("networking"), async move {
+		if network_start_rx.await.is_err() {
+			log::warn!(
+				"The NetworkStart returned as part of `build_network` has been silently dropped"
+			);
+			// This `return` might seem unnecessary, but we don't want to make it look like
+			// everything is working as normal even though the user is clearly misusing the API.
+			return
+		}
+
+		future.await
+	});
+
+	Ok((
+		network,
+		system_rpc_tx,
+		tx_handler_controller,
+		NetworkStarter(network_start_tx),
+		sync_service.clone(),
+	))
+}
+
+/// Object used to start the network.
+#[must_use]
+pub struct NetworkStarter(oneshot::Sender<()>);
+
+impl NetworkStarter {
+	/// Create a new NetworkStarter
+	pub fn new(sender: oneshot::Sender<()>) -> Self {
+		NetworkStarter(sender)
+	}
+
+	/// Start the network. Call this after all sub-components have been initialized.
+	///
+	/// > **Note**: If you don't call this function, the networking will not work.
+	pub fn start_network(self) {
+		let _ = self.0.send(());
+	}
+}
diff --git a/substrate/client/service/src/chain_ops/check_block.rs b/substrate/client/service/src/chain_ops/check_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a14f535b9b367e548c6f5f64d27bdb7499d07e02
--- /dev/null
+++ b/substrate/client/service/src/chain_ops/check_block.rs
@@ -0,0 +1,54 @@
+// 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::error::Error;
+use codec::Encode;
+use sc_client_api::{BlockBackend, HeaderBackend};
+use sc_consensus::import_queue::ImportQueue;
+use sp_runtime::{generic::BlockId, traits::Block as BlockT};
+
+use crate::chain_ops::import_blocks;
+use std::sync::Arc;
+
+/// Re-validate known block.
+pub async fn check_block<B, IQ, C>(
+	client: Arc<C>,
+	import_queue: IQ,
+	block_id: BlockId<B>,
+) -> Result<(), Error>
+where
+	C: BlockBackend<B> + HeaderBackend<B> + Send + Sync + 'static,
+	B: BlockT + for<'de> serde::Deserialize<'de>,
+	IQ: ImportQueue<B> + 'static,
+{
+	let maybe_block = client
+		.block_hash_from_id(&block_id)?
+		.map(|hash| client.block(hash))
+		.transpose()?
+		.flatten();
+	match maybe_block {
+		Some(block) => {
+			let mut buf = Vec::new();
+			1u64.encode_to(&mut buf);
+			block.encode_to(&mut buf);
+			let reader = std::io::Cursor::new(buf);
+			import_blocks(client, import_queue, reader, true, true).await
+		},
+		None => Err("Unknown block")?,
+	}
+}
diff --git a/substrate/client/service/src/chain_ops/export_blocks.rs b/substrate/client/service/src/chain_ops/export_blocks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8d66f1f96baf360476d044635208a792df287a32
--- /dev/null
+++ b/substrate/client/service/src/chain_ops/export_blocks.rs
@@ -0,0 +1,107 @@
+// 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::error::Error;
+use codec::Encode;
+use futures::{future, prelude::*};
+use log::info;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, NumberFor, One, SaturatedConversion, Zero},
+};
+
+use sc_client_api::{BlockBackend, HeaderBackend, UsageProvider};
+use std::{io::Write, pin::Pin, sync::Arc, task::Poll};
+
+/// Performs the blocks export.
+pub fn export_blocks<B, C>(
+	client: Arc<C>,
+	mut output: impl Write + 'static,
+	from: NumberFor<B>,
+	to: Option<NumberFor<B>>,
+	binary: bool,
+) -> Pin<Box<dyn Future<Output = Result<(), Error>>>>
+where
+	C: HeaderBackend<B> + BlockBackend<B> + UsageProvider<B> + 'static,
+	B: BlockT,
+{
+	let mut block = from;
+
+	let last = match to {
+		Some(v) if v.is_zero() => One::one(),
+		Some(v) => v,
+		None => client.usage_info().chain.best_number,
+	};
+
+	let mut wrote_header = false;
+
+	// Exporting blocks is implemented as a future, because we want the operation to be
+	// interruptible.
+	//
+	// Every time we write a block to the output, the `Future` re-schedules itself and returns
+	// `Poll::Pending`.
+	// This makes it possible either to interleave other operations in-between the block exports,
+	// or to stop the operation completely.
+	let export = future::poll_fn(move |cx| {
+		let client = &client;
+
+		if last < block {
+			return Poll::Ready(Err("Invalid block range specified".into()))
+		}
+
+		if !wrote_header {
+			info!("Exporting blocks from #{} to #{}", block, last);
+			if binary {
+				let last_: u64 = last.saturated_into::<u64>();
+				let block_: u64 = block.saturated_into::<u64>();
+				let len: u64 = last_ - block_ + 1;
+				output.write_all(&len.encode())?;
+			}
+			wrote_header = true;
+		}
+
+		match client
+			.block_hash_from_id(&BlockId::number(block))?
+			.map(|hash| client.block(hash))
+			.transpose()?
+			.flatten()
+		{
+			Some(block) =>
+				if binary {
+					output.write_all(&block.encode())?;
+				} else {
+					serde_json::to_writer(&mut output, &block)
+						.map_err(|e| format!("Error writing JSON: {}", e))?;
+				},
+			None => return Poll::Ready(Ok(())),
+		}
+		if (block % 10000u32.into()).is_zero() {
+			info!("#{}", block);
+		}
+		if block == last {
+			return Poll::Ready(Ok(()))
+		}
+		block += One::one();
+
+		// Re-schedule the task in order to continue the operation.
+		cx.waker().wake_by_ref();
+		Poll::Pending
+	});
+
+	Box::pin(export)
+}
diff --git a/substrate/client/service/src/chain_ops/export_raw_state.rs b/substrate/client/service/src/chain_ops/export_raw_state.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fde2c5617cb415591ff8a84feab288ea5036df9a
--- /dev/null
+++ b/substrate/client/service/src/chain_ops/export_raw_state.rs
@@ -0,0 +1,63 @@
+// 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::error::Error;
+use sc_client_api::{StorageProvider, UsageProvider};
+use sp_core::storage::{well_known_keys, ChildInfo, Storage, StorageChild, StorageKey, StorageMap};
+use sp_runtime::traits::Block as BlockT;
+
+use std::{
+	collections::{BTreeMap, HashMap},
+	sync::Arc,
+};
+
+/// Export the raw state at the given `block`. If `block` is `None`, the
+/// best block will be used.
+pub fn export_raw_state<B, BA, C>(client: Arc<C>, hash: B::Hash) -> Result<Storage, Error>
+where
+	C: UsageProvider<B> + StorageProvider<B, BA>,
+	B: BlockT,
+	BA: sc_client_api::backend::Backend<B>,
+{
+	let mut top = BTreeMap::new();
+	let mut children_default = HashMap::new();
+
+	for (key, value) in client.storage_pairs(hash, None, None)? {
+		// Remove all default child storage roots from the top storage and collect the child storage
+		// pairs.
+		if key.0.starts_with(well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX) {
+			let child_root_key = StorageKey(
+				key.0[well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX.len()..].to_vec(),
+			);
+			let child_info = ChildInfo::new_default(&child_root_key.0);
+			let mut pairs = StorageMap::new();
+			for child_key in client.child_storage_keys(hash, child_info.clone(), None, None)? {
+				if let Some(child_value) = client.child_storage(hash, &child_info, &child_key)? {
+					pairs.insert(child_key.0, child_value.0);
+				}
+			}
+
+			children_default.insert(child_root_key.0, StorageChild { child_info, data: pairs });
+			continue
+		}
+
+		top.insert(key.0, value.0);
+	}
+
+	Ok(Storage { top, children_default })
+}
diff --git a/substrate/client/service/src/chain_ops/import_blocks.rs b/substrate/client/service/src/chain_ops/import_blocks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..34f7669d0106e2065c3b08f7816a002c9d1175ae
--- /dev/null
+++ b/substrate/client/service/src/chain_ops/import_blocks.rs
@@ -0,0 +1,486 @@
+// 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::{error, error::Error};
+use codec::{Decode, IoReader as CodecIoReader};
+use futures::{future, prelude::*};
+use futures_timer::Delay;
+use log::{info, warn};
+use sc_chain_spec::ChainSpec;
+use sc_client_api::HeaderBackend;
+use sc_consensus::import_queue::{
+	BlockImportError, BlockImportStatus, ImportQueue, IncomingBlock, Link,
+};
+use serde_json::{de::IoRead as JsonIoRead, Deserializer, StreamDeserializer};
+use sp_consensus::BlockOrigin;
+use sp_runtime::{
+	generic::SignedBlock,
+	traits::{
+		Block as BlockT, CheckedDiv, Header, MaybeSerializeDeserialize, NumberFor, Saturating, Zero,
+	},
+};
+use std::{
+	io::Read,
+	pin::Pin,
+	task::Poll,
+	time::{Duration, Instant},
+};
+
+/// Number of blocks we will add to the queue before waiting for the queue to catch up.
+const MAX_PENDING_BLOCKS: u64 = 10_000;
+
+/// Number of milliseconds to wait until next poll.
+const DELAY_TIME: u64 = 200;
+
+/// Number of milliseconds that must have passed between two updates.
+const TIME_BETWEEN_UPDATES: u64 = 3_000;
+
+use std::sync::Arc;
+
+/// Build a chain spec json
+pub fn build_spec(spec: &dyn ChainSpec, raw: bool) -> error::Result<String> {
+	spec.as_json(raw).map_err(Into::into)
+}
+
+/// Helper enum that wraps either a binary decoder (from parity-scale-codec), or a JSON decoder
+/// (from serde_json). Implements the Iterator Trait, calling `next()` will decode the next
+/// SignedBlock and return it.
+enum BlockIter<R, B>
+where
+	R: std::io::Read,
+{
+	Binary {
+		// Total number of blocks we are expecting to decode.
+		num_expected_blocks: u64,
+		// Number of blocks we have decoded thus far.
+		read_block_count: u64,
+		// Reader to the data, used for decoding new blocks.
+		reader: CodecIoReader<R>,
+	},
+	Json {
+		// Nubmer of blocks we have decoded thus far.
+		read_block_count: u64,
+		// Stream to the data, used for decoding new blocks.
+		reader: StreamDeserializer<'static, JsonIoRead<R>, SignedBlock<B>>,
+	},
+}
+
+impl<R, B> BlockIter<R, B>
+where
+	R: Read + 'static,
+	B: BlockT + MaybeSerializeDeserialize,
+{
+	fn new(input: R, binary: bool) -> Result<Self, String> {
+		if binary {
+			let mut reader = CodecIoReader(input);
+			// If the file is encoded in binary format, it is expected to first specify the number
+			// of blocks that are going to be decoded. We read it and add it to our enum struct.
+			let num_expected_blocks: u64 = Decode::decode(&mut reader)
+				.map_err(|e| format!("Failed to decode the number of blocks: {:?}", e))?;
+			Ok(BlockIter::Binary { num_expected_blocks, read_block_count: 0, reader })
+		} else {
+			let stream_deser = Deserializer::from_reader(input).into_iter::<SignedBlock<B>>();
+			Ok(BlockIter::Json { reader: stream_deser, read_block_count: 0 })
+		}
+	}
+
+	/// Returns the number of blocks read thus far.
+	fn read_block_count(&self) -> u64 {
+		match self {
+			BlockIter::Binary { read_block_count, .. } |
+			BlockIter::Json { read_block_count, .. } => *read_block_count,
+		}
+	}
+
+	/// Returns the total number of blocks to be imported, if possible.
+	fn num_expected_blocks(&self) -> Option<u64> {
+		match self {
+			BlockIter::Binary { num_expected_blocks, .. } => Some(*num_expected_blocks),
+			BlockIter::Json { .. } => None,
+		}
+	}
+}
+
+impl<R, B> Iterator for BlockIter<R, B>
+where
+	R: Read + 'static,
+	B: BlockT + MaybeSerializeDeserialize,
+{
+	type Item = Result<SignedBlock<B>, String>;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		match self {
+			BlockIter::Binary { num_expected_blocks, read_block_count, reader } => {
+				if read_block_count < num_expected_blocks {
+					let block_result: Result<SignedBlock<B>, _> =
+						SignedBlock::<B>::decode(reader).map_err(|e| e.to_string());
+					*read_block_count += 1;
+					Some(block_result)
+				} else {
+					// `read_block_count` == `num_expected_blocks` so we've read enough blocks.
+					None
+				}
+			},
+			BlockIter::Json { reader, read_block_count } => {
+				let res = Some(reader.next()?.map_err(|e| e.to_string()));
+				*read_block_count += 1;
+				res
+			},
+		}
+	}
+}
+
+/// Imports the SignedBlock to the queue.
+fn import_block_to_queue<TBl, TImpQu>(
+	signed_block: SignedBlock<TBl>,
+	queue: &mut TImpQu,
+	force: bool,
+) where
+	TBl: BlockT + MaybeSerializeDeserialize,
+	TImpQu: 'static + ImportQueue<TBl>,
+{
+	let (header, extrinsics) = signed_block.block.deconstruct();
+	let hash = header.hash();
+	// import queue handles verification and importing it into the client.
+	queue.service_ref().import_blocks(
+		BlockOrigin::File,
+		vec![IncomingBlock::<TBl> {
+			hash,
+			header: Some(header),
+			body: Some(extrinsics),
+			indexed_body: None,
+			justifications: signed_block.justifications,
+			origin: None,
+			allow_missing_state: false,
+			import_existing: force,
+			state: None,
+			skip_execution: false,
+		}],
+	);
+}
+
+/// Returns true if we have imported every block we were supposed to import, else returns false.
+fn importing_is_done(
+	num_expected_blocks: Option<u64>,
+	read_block_count: u64,
+	imported_blocks: u64,
+) -> bool {
+	if let Some(num_expected_blocks) = num_expected_blocks {
+		imported_blocks >= num_expected_blocks
+	} else {
+		imported_blocks >= read_block_count
+	}
+}
+
+/// Structure used to log the block importing speed.
+struct Speedometer<B: BlockT> {
+	best_number: NumberFor<B>,
+	last_number: Option<NumberFor<B>>,
+	last_update: Instant,
+}
+
+impl<B: BlockT> Speedometer<B> {
+	/// Creates a fresh Speedometer.
+	fn new() -> Self {
+		Self {
+			best_number: NumberFor::<B>::from(0u32),
+			last_number: None,
+			last_update: Instant::now(),
+		}
+	}
+
+	/// Calculates `(best_number - last_number) / (now - last_update)` and
+	/// logs the speed of import.
+	fn display_speed(&self) {
+		// Number of milliseconds elapsed since last time.
+		let elapsed_ms = {
+			let elapsed = self.last_update.elapsed();
+			let since_last_millis = elapsed.as_secs() * 1000;
+			let since_last_subsec_millis = elapsed.subsec_millis() as u64;
+			since_last_millis + since_last_subsec_millis
+		};
+
+		// Number of blocks that have been imported since last time.
+		let diff = match self.last_number {
+			None => return,
+			Some(n) => self.best_number.saturating_sub(n),
+		};
+
+		if let Ok(diff) = TryInto::<u128>::try_into(diff) {
+			// If the number of blocks can be converted to a regular integer, then it's easy: just
+			// do the math and turn it into a `f64`.
+			let speed = diff
+				.saturating_mul(10_000)
+				.checked_div(u128::from(elapsed_ms))
+				.map_or(0.0, |s| s as f64) /
+				10.0;
+			info!("📦 Current best block: {} ({:4.1} bps)", self.best_number, speed);
+		} else {
+			// If the number of blocks can't be converted to a regular integer, then we need a more
+			// algebraic approach and we stay within the realm of integers.
+			let one_thousand = NumberFor::<B>::from(1_000u32);
+			let elapsed =
+				NumberFor::<B>::from(<u32 as TryFrom<_>>::try_from(elapsed_ms).unwrap_or(u32::MAX));
+
+			let speed = diff
+				.saturating_mul(one_thousand)
+				.checked_div(&elapsed)
+				.unwrap_or_else(Zero::zero);
+			info!("📦 Current best block: {} ({} bps)", self.best_number, speed)
+		}
+	}
+
+	/// Updates the Speedometer.
+	fn update(&mut self, best_number: NumberFor<B>) {
+		self.last_number = Some(self.best_number);
+		self.best_number = best_number;
+		self.last_update = Instant::now();
+	}
+
+	// If more than TIME_BETWEEN_UPDATES has elapsed since last update,
+	// then print and update the speedometer.
+	fn notify_user(&mut self, best_number: NumberFor<B>) {
+		let delta = Duration::from_millis(TIME_BETWEEN_UPDATES);
+		if Instant::now().duration_since(self.last_update) >= delta {
+			self.display_speed();
+			self.update(best_number);
+		}
+	}
+}
+
+/// Different State that the `import_blocks` future could be in.
+enum ImportState<R, B>
+where
+	R: Read + 'static,
+	B: BlockT + MaybeSerializeDeserialize,
+{
+	/// We are reading from the [`BlockIter`] structure, adding those blocks to the queue if
+	/// possible.
+	Reading { block_iter: BlockIter<R, B> },
+	/// The queue is full (contains at least MAX_PENDING_BLOCKS blocks) and we are waiting for it
+	/// to catch up.
+	WaitingForImportQueueToCatchUp {
+		block_iter: BlockIter<R, B>,
+		delay: Delay,
+		block: SignedBlock<B>,
+	},
+	// We have added all the blocks to the queue but they are still being processed.
+	WaitingForImportQueueToFinish {
+		num_expected_blocks: Option<u64>,
+		read_block_count: u64,
+		delay: Delay,
+	},
+}
+
+/// Starts the process of importing blocks.
+pub fn import_blocks<B, IQ, C>(
+	client: Arc<C>,
+	mut import_queue: IQ,
+	input: impl Read + Send + 'static,
+	force: bool,
+	binary: bool,
+) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send>>
+where
+	C: HeaderBackend<B> + Send + Sync + 'static,
+	B: BlockT + for<'de> serde::Deserialize<'de>,
+	IQ: ImportQueue<B> + 'static,
+{
+	struct WaitLink {
+		imported_blocks: u64,
+		has_error: bool,
+	}
+
+	impl WaitLink {
+		fn new() -> WaitLink {
+			WaitLink { imported_blocks: 0, has_error: false }
+		}
+	}
+
+	impl<B: BlockT> Link<B> for WaitLink {
+		fn blocks_processed(
+			&mut self,
+			imported: usize,
+			_num_expected_blocks: usize,
+			results: Vec<(Result<BlockImportStatus<NumberFor<B>>, BlockImportError>, B::Hash)>,
+		) {
+			self.imported_blocks += imported as u64;
+
+			for result in results {
+				if let (Err(err), hash) = result {
+					warn!("There was an error importing block with hash {:?}: {}", hash, err);
+					self.has_error = true;
+					break
+				}
+			}
+		}
+	}
+
+	let mut link = WaitLink::new();
+	let block_iter_res: Result<BlockIter<_, B>, String> = BlockIter::new(input, binary);
+
+	let block_iter = match block_iter_res {
+		Ok(block_iter) => block_iter,
+		Err(e) => {
+			// We've encountered an error while creating the block iterator
+			// so we can just return a future that returns an error.
+			return future::ready(Err(Error::Other(e))).boxed()
+		},
+	};
+
+	let mut state = Some(ImportState::Reading { block_iter });
+	let mut speedometer = Speedometer::<B>::new();
+
+	// Importing blocks is implemented as a future, because we want the operation to be
+	// interruptible.
+	//
+	// Every time we read a block from the input or import a bunch of blocks from the import
+	// queue, the `Future` re-schedules itself and returns `Poll::Pending`.
+	// This makes it possible either to interleave other operations in-between the block imports,
+	// or to stop the operation completely.
+	let import = future::poll_fn(move |cx| {
+		let client = &client;
+		let queue = &mut import_queue;
+		match state.take().expect("state should never be None; qed") {
+			ImportState::Reading { mut block_iter } => {
+				match block_iter.next() {
+					None => {
+						// The iterator is over: we now need to wait for the import queue to finish.
+						let num_expected_blocks = block_iter.num_expected_blocks();
+						let read_block_count = block_iter.read_block_count();
+						let delay = Delay::new(Duration::from_millis(DELAY_TIME));
+						state = Some(ImportState::WaitingForImportQueueToFinish {
+							num_expected_blocks,
+							read_block_count,
+							delay,
+						});
+					},
+					Some(block_result) => {
+						let read_block_count = block_iter.read_block_count();
+						match block_result {
+							Ok(block) => {
+								if read_block_count - link.imported_blocks >= MAX_PENDING_BLOCKS {
+									// The queue is full, so do not add this block and simply wait
+									// until the queue has made some progress.
+									let delay = Delay::new(Duration::from_millis(DELAY_TIME));
+									state = Some(ImportState::WaitingForImportQueueToCatchUp {
+										block_iter,
+										delay,
+										block,
+									});
+								} else {
+									// Queue is not full, we can keep on adding blocks to the queue.
+									import_block_to_queue(block, queue, force);
+									state = Some(ImportState::Reading { block_iter });
+								}
+							},
+							Err(e) =>
+								return Poll::Ready(Err(Error::Other(format!(
+									"Error reading block #{}: {}",
+									read_block_count, e
+								)))),
+						}
+					},
+				}
+			},
+			ImportState::WaitingForImportQueueToCatchUp { block_iter, mut delay, block } => {
+				let read_block_count = block_iter.read_block_count();
+				if read_block_count - link.imported_blocks >= MAX_PENDING_BLOCKS {
+					// Queue is still full, so wait until there is room to insert our block.
+					match Pin::new(&mut delay).poll(cx) {
+						Poll::Pending => {
+							state = Some(ImportState::WaitingForImportQueueToCatchUp {
+								block_iter,
+								delay,
+								block,
+							});
+							return Poll::Pending
+						},
+						Poll::Ready(_) => {
+							delay.reset(Duration::from_millis(DELAY_TIME));
+						},
+					}
+					state = Some(ImportState::WaitingForImportQueueToCatchUp {
+						block_iter,
+						delay,
+						block,
+					});
+				} else {
+					// Queue is no longer full, so we can add our block to the queue.
+					import_block_to_queue(block, queue, force);
+					// Switch back to Reading state.
+					state = Some(ImportState::Reading { block_iter });
+				}
+			},
+			ImportState::WaitingForImportQueueToFinish {
+				num_expected_blocks,
+				read_block_count,
+				mut delay,
+			} => {
+				// All the blocks have been added to the queue, which doesn't mean they
+				// have all been properly imported.
+				if importing_is_done(num_expected_blocks, read_block_count, link.imported_blocks) {
+					// Importing is done, we can log the result and return.
+					info!(
+						"🎉 Imported {} blocks. Best: #{}",
+						read_block_count,
+						client.info().best_number
+					);
+					return Poll::Ready(Ok(()))
+				} else {
+					// Importing is not done, we still have to wait for the queue to finish.
+					// Wait for the delay, because we know the queue is lagging behind.
+					match Pin::new(&mut delay).poll(cx) {
+						Poll::Pending => {
+							state = Some(ImportState::WaitingForImportQueueToFinish {
+								num_expected_blocks,
+								read_block_count,
+								delay,
+							});
+							return Poll::Pending
+						},
+						Poll::Ready(_) => {
+							delay.reset(Duration::from_millis(DELAY_TIME));
+						},
+					}
+
+					state = Some(ImportState::WaitingForImportQueueToFinish {
+						num_expected_blocks,
+						read_block_count,
+						delay,
+					});
+				}
+			},
+		}
+
+		queue.poll_actions(cx, &mut link);
+
+		let best_number = client.info().best_number;
+		speedometer.notify_user(best_number);
+
+		if link.has_error {
+			return Poll::Ready(Err(Error::Other(format!(
+				"Stopping after #{} blocks because of an error",
+				link.imported_blocks
+			))))
+		}
+
+		cx.waker().wake_by_ref();
+		Poll::Pending
+	});
+	Box::pin(import)
+}
diff --git a/substrate/client/service/src/chain_ops/mod.rs b/substrate/client/service/src/chain_ops/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9ee6848ad4b1fe1b380eb7979f307703a1cc6311
--- /dev/null
+++ b/substrate/client/service/src/chain_ops/mod.rs
@@ -0,0 +1,31 @@
+// 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/>.
+
+//! Chain utilities.
+
+mod check_block;
+mod export_blocks;
+mod export_raw_state;
+mod import_blocks;
+mod revert_chain;
+
+pub use check_block::*;
+pub use export_blocks::*;
+pub use export_raw_state::*;
+pub use import_blocks::*;
+pub use revert_chain::*;
diff --git a/substrate/client/service/src/chain_ops/revert_chain.rs b/substrate/client/service/src/chain_ops/revert_chain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f3c344a75c5b081d12c68471ed6470e4254fa456
--- /dev/null
+++ b/substrate/client/service/src/chain_ops/revert_chain.rs
@@ -0,0 +1,52 @@
+// 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::error::Error;
+use log::info;
+use sc_client_api::{Backend, UsageProvider};
+use sp_runtime::traits::{Block as BlockT, NumberFor, Zero};
+use std::sync::Arc;
+
+/// Performs a revert of `blocks` blocks.
+pub fn revert_chain<B, BA, C>(
+	client: Arc<C>,
+	backend: Arc<BA>,
+	blocks: NumberFor<B>,
+) -> Result<(), Error>
+where
+	B: BlockT,
+	C: UsageProvider<B>,
+	BA: Backend<B>,
+{
+	let reverted = backend.revert(blocks, false)?;
+	let info = client.usage_info().chain;
+
+	if reverted.0.is_zero() {
+		info!("There aren't any non-finalized blocks to revert.");
+	} else {
+		info!("Reverted {} blocks. Best: #{} ({})", reverted.0, info.best_number, info.best_hash);
+
+		if reverted.0 > blocks {
+			info!(
+				"Number of reverted blocks is higher than requested \
+				because of reverted leaves higher than the best block."
+			)
+		}
+	}
+	Ok(())
+}
diff --git a/substrate/client/service/src/client/block_rules.rs b/substrate/client/service/src/client/block_rules.rs
new file mode 100644
index 0000000000000000000000000000000000000000..532cde1ae78f030a3af3d3560b7dba8d220bf269
--- /dev/null
+++ b/substrate/client/service/src/client/block_rules.rs
@@ -0,0 +1,74 @@
+// 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/>.
+
+//! Client fixed chain specification rules
+
+use std::collections::{HashMap, HashSet};
+
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+use sc_client_api::{BadBlocks, ForkBlocks};
+
+/// Chain specification rules lookup result.
+pub enum LookupResult<B: BlockT> {
+	/// Specification rules do not contain any special rules about this block
+	NotSpecial,
+	/// The block is known to be bad and should not be imported
+	KnownBad,
+	/// There is a specified canonical block hash for the given height
+	Expected(B::Hash),
+}
+
+/// Chain-specific block filtering rules.
+///
+/// This holds known bad blocks and known good forks, and
+/// is usually part of the chain spec.
+pub struct BlockRules<B: BlockT> {
+	bad: HashSet<B::Hash>,
+	forks: HashMap<NumberFor<B>, B::Hash>,
+}
+
+impl<B: BlockT> BlockRules<B> {
+	/// New block rules with provided black and white lists.
+	pub fn new(fork_blocks: ForkBlocks<B>, bad_blocks: BadBlocks<B>) -> Self {
+		Self {
+			bad: bad_blocks.unwrap_or_default(),
+			forks: fork_blocks.unwrap_or_default().into_iter().collect(),
+		}
+	}
+
+	/// Mark a new block as bad.
+	pub fn mark_bad(&mut self, hash: B::Hash) {
+		self.bad.insert(hash);
+	}
+
+	/// Check if there's any rule affecting the given block.
+	pub fn lookup(&self, number: NumberFor<B>, hash: &B::Hash) -> LookupResult<B> {
+		if let Some(hash_for_height) = self.forks.get(&number) {
+			if hash_for_height != hash {
+				return LookupResult::Expected(*hash_for_height)
+			}
+		}
+
+		if self.bad.contains(hash) {
+			return LookupResult::KnownBad
+		}
+
+		LookupResult::NotSpecial
+	}
+}
diff --git a/substrate/client/service/src/client/call_executor.rs b/substrate/client/service/src/client/call_executor.rs
new file mode 100644
index 0000000000000000000000000000000000000000..86b5c7c61fcd2cbe062784fe53f8e9ba30adf6e0
--- /dev/null
+++ b/substrate/client/service/src/client/call_executor.rs
@@ -0,0 +1,472 @@
+// 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, 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_externalities::Extensions;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, HashingFor},
+};
+use sp_state_machine::{backend::AsTrieBackend, Ext, OverlayedChanges, StateMachine, StorageProof};
+use std::{cell::RefCell, sync::Arc};
+
+/// Call executor that executes methods locally, querying all required
+/// data from local backend.
+pub struct LocalCallExecutor<Block: BlockT, B, E> {
+	backend: Arc<B>,
+	executor: E,
+	wasm_override: Arc<Option<WasmOverride>>,
+	wasm_substitutes: WasmSubstitutes<Block, E, B>,
+	execution_extensions: Arc<ExecutionExtensions<Block>>,
+}
+
+impl<Block: BlockT, B, E> LocalCallExecutor<Block, B, E>
+where
+	E: CodeExecutor + RuntimeVersionOf + Clone + 'static,
+	B: backend::Backend<Block>,
+{
+	/// Creates new instance of local call executor.
+	pub fn new(
+		backend: Arc<B>,
+		executor: E,
+		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(),
+		)?;
+
+		Ok(LocalCallExecutor {
+			backend,
+			executor,
+			wasm_override: Arc::new(wasm_override),
+			wasm_substitutes,
+			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>
+where
+	E: Clone,
+{
+	fn clone(&self) -> Self {
+		LocalCallExecutor {
+			backend: self.backend.clone(),
+			executor: self.executor.clone(),
+			wasm_override: self.wasm_override.clone(),
+			wasm_substitutes: self.wasm_substitutes.clone(),
+			execution_extensions: self.execution_extensions.clone(),
+		}
+	}
+}
+
+impl<B, E, Block> CallExecutor<Block> for LocalCallExecutor<Block, B, E>
+where
+	B: backend::Backend<Block>,
+	E: CodeExecutor + RuntimeVersionOf + Clone + 'static,
+	Block: BlockT,
+{
+	type Error = E::Error;
+
+	type Backend = B;
+
+	fn execution_extensions(&self) -> &ExecutionExtensions<Block> {
+		&self.execution_extensions
+	}
+
+	fn call(
+		&self,
+		at_hash: Block::Hash,
+		method: &str,
+		call_data: &[u8],
+		context: CallContext,
+	) -> sp_blockchain::Result<Vec<u8>> {
+		let mut changes = OverlayedChanges::default();
+		let at_number =
+			self.backend.blockchain().expect_block_number_from_id(&BlockId::Hash(at_hash))?;
+		let state = self.backend.state_at(at_hash)?;
+
+		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)?;
+
+		let runtime_code = self.check_override(runtime_code, &state, at_hash)?.0;
+
+		let mut extensions = self.execution_extensions.extensions(at_hash, at_number);
+
+		let mut sm = StateMachine::new(
+			&state,
+			&mut changes,
+			&self.executor,
+			method,
+			call_data,
+			&mut extensions,
+			&runtime_code,
+			context,
+		)
+		.set_parent_hash(at_hash);
+
+		sm.execute().map_err(Into::into)
+	}
+
+	fn contextual_call(
+		&self,
+		at_hash: Block::Hash,
+		method: &str,
+		call_data: &[u8],
+		changes: &RefCell<OverlayedChanges<HashingFor<Block>>>,
+		recorder: &Option<ProofRecorder<Block>>,
+		call_context: CallContext,
+		extensions: &RefCell<Extensions>,
+	) -> Result<Vec<u8>, sp_blockchain::Error> {
+		let state = self.backend.state_at(at_hash)?;
+
+		let changes = &mut *changes.borrow_mut();
+
+		// It is important to extract the runtime code here before we create the proof
+		// recorder to not record it. We also need to fetch the runtime code from `state` to
+		// make sure we use the caching layers.
+		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)?;
+		let runtime_code = self.check_override(runtime_code, &state, at_hash)?.0;
+		let mut extensions = extensions.borrow_mut();
+
+		match recorder {
+			Some(recorder) => {
+				let trie_state = state.as_trie_backend();
+
+				let backend = sp_state_machine::TrieBackendBuilder::wrap(&trie_state)
+					.with_recorder(recorder.clone())
+					.build();
+
+				let mut state_machine = StateMachine::new(
+					&backend,
+					changes,
+					&self.executor,
+					method,
+					call_data,
+					&mut extensions,
+					&runtime_code,
+					call_context,
+				)
+				.set_parent_hash(at_hash);
+				state_machine.execute()
+			},
+			None => {
+				let mut state_machine = StateMachine::new(
+					&state,
+					changes,
+					&self.executor,
+					method,
+					call_data,
+					&mut extensions,
+					&runtime_code,
+					call_context,
+				)
+				.set_parent_hash(at_hash);
+				state_machine.execute()
+			},
+		}
+		.map_err(Into::into)
+	}
+
+	fn runtime_version(&self, at_hash: Block::Hash) -> sp_blockchain::Result<RuntimeVersion> {
+		let state = self.backend.state_at(at_hash)?;
+		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.check_override(runtime_code, &state, at_hash).map(|(_, v)| v)
+	}
+
+	fn prove_execution(
+		&self,
+		at_hash: Block::Hash,
+		method: &str,
+		call_data: &[u8],
+	) -> sp_blockchain::Result<(Vec<u8>, StorageProof)> {
+		let at_number =
+			self.backend.blockchain().expect_block_number_from_id(&BlockId::Hash(at_hash))?;
+		let state = self.backend.state_at(at_hash)?;
+
+		let trie_backend = state.as_trie_backend();
+
+		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;
+
+		sp_state_machine::prove_execution_on_trie_backend(
+			trie_backend,
+			&mut Default::default(),
+			&self.executor,
+			method,
+			call_data,
+			&runtime_code,
+			&mut self.execution_extensions.extensions(at_hash, at_number),
+		)
+		.map_err(Into::into)
+	}
+}
+
+impl<B, E, Block> RuntimeVersionOf for LocalCallExecutor<Block, B, E>
+where
+	E: RuntimeVersionOf,
+	Block: BlockT,
+{
+	fn runtime_version(
+		&self,
+		ext: &mut dyn sp_externalities::Externalities,
+		runtime_code: &sp_core::traits::RuntimeCode,
+	) -> Result<sp_version::RuntimeVersion, sc_executor::error::Error> {
+		RuntimeVersionOf::runtime_version(&self.executor, ext, runtime_code)
+	}
+}
+
+impl<Block, B, E> sp_version::GetRuntimeVersionAt<Block> for LocalCallExecutor<Block, B, E>
+where
+	B: backend::Backend<Block>,
+	E: CodeExecutor + RuntimeVersionOf + Clone + 'static,
+	Block: BlockT,
+{
+	fn runtime_version(&self, at: Block::Hash) -> Result<sp_version::RuntimeVersion, String> {
+		CallExecutor::runtime_version(self, at).map_err(|e| e.to_string())
+	}
+}
+
+impl<Block, B, E> sp_version::GetNativeVersion for LocalCallExecutor<Block, B, E>
+where
+	B: backend::Backend<Block>,
+	E: CodeExecutor + sp_version::GetNativeVersion + Clone + 'static,
+	Block: BlockT,
+{
+	fn native_version(&self) -> &sp_version::NativeVersion {
+		self.executor.native_version()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use backend::Backend;
+	use sc_client_api::in_mem;
+	use sc_executor::{NativeElseWasmExecutor, WasmExecutor};
+	use sp_core::{
+		testing::TaskExecutor,
+		traits::{FetchRuntimeCode, WrappedRuntimeCode},
+	};
+	use std::collections::HashMap;
+	use substrate_test_runtime_client::{runtime, GenesisInit, LocalExecutorDispatch};
+
+	fn executor() -> NativeElseWasmExecutor<LocalExecutorDispatch> {
+		NativeElseWasmExecutor::new_with_wasm_executor(
+			WasmExecutor::builder()
+				.with_max_runtime_instances(1)
+				.with_runtime_cache_size(2)
+				.build(),
+		)
+	}
+
+	#[test]
+	fn should_get_override_if_exists() {
+		let executor = executor();
+
+		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 = executor();
+
+		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
new file mode 100644
index 0000000000000000000000000000000000000000..a0983d823e5b19a5758e281e91499085f9d813da
--- /dev/null
+++ b/substrate/client/service/src/client/client.rs
@@ -0,0 +1,2135 @@
+// 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/>.
+
+//! Substrate Client
+
+use super::block_rules::{BlockRules, LookupResult as BlockLookupResult};
+use futures::{FutureExt, StreamExt};
+use log::{error, info, trace, warn};
+use parking_lot::{Mutex, RwLock};
+use prometheus_endpoint::Registry;
+use rand::Rng;
+use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider, RecordProof};
+use sc_chain_spec::{resolve_state_version_from_wasm, BuildGenesisBlock};
+use sc_client_api::{
+	backend::{
+		self, apply_aux, BlockImportOperation, ClientImportOperation, FinalizeSummary, Finalizer,
+		ImportNotificationAction, ImportSummary, LockImportRun, NewBlockState, StorageProvider,
+	},
+	client::{
+		BadBlocks, BlockBackend, BlockImportNotification, BlockOf, BlockchainEvents, ClientInfo,
+		FinalityNotification, FinalityNotifications, ForkBlocks, ImportNotifications,
+		PreCommitActions, ProvideUncles,
+	},
+	execution_extensions::ExecutionExtensions,
+	notifications::{StorageEventStream, StorageNotifications},
+	CallExecutor, ExecutorProvider, KeysIter, OnFinalityAction, OnImportAction, PairsIter,
+	ProofProvider, UsageProvider,
+};
+use sc_consensus::{
+	BlockCheckParams, BlockImportParams, ForkChoiceStrategy, ImportResult, StateAction,
+};
+use sc_executor::RuntimeVersion;
+use sc_telemetry::{telemetry, TelemetryHandle, SUBSTRATE_INFO};
+use sp_api::{
+	ApiExt, ApiRef, CallApiAt, CallApiAtParams, ConstructRuntimeApi, Core as CoreApi,
+	ProvideRuntimeApi,
+};
+use sp_blockchain::{
+	self as blockchain, Backend as ChainBackend, CachedHeaderMetadata, Error,
+	HeaderBackend as ChainHeaderBackend, HeaderMetadata, Info as BlockchainInfo,
+};
+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,
+	},
+	traits::{CallContext, SpawnNamed},
+};
+use sp_runtime::{
+	generic::{BlockId, SignedBlock},
+	traits::{
+		Block as BlockT, BlockIdTo, HashingFor, Header as HeaderT, NumberFor, One,
+		SaturatedConversion, Zero,
+	},
+	Digest, Justification, Justifications, StateVersion,
+};
+use sp_state_machine::{
+	prove_child_read, prove_range_read_with_child_with_size, prove_read,
+	read_range_proof_check_with_child_on_proving_backend, Backend as StateBackend,
+	ChildStorageCollection, KeyValueStates, KeyValueStorageLevel, StorageCollection,
+	MAX_NESTED_TRIE_DEPTH,
+};
+use sp_trie::{CompactProof, StorageProof};
+use std::{
+	collections::{HashMap, HashSet},
+	marker::PhantomData,
+	path::PathBuf,
+	sync::Arc,
+};
+
+#[cfg(feature = "test-helpers")]
+use {
+	super::call_executor::LocalCallExecutor, sc_client_api::in_mem, sp_core::traits::CodeExecutor,
+};
+
+type NotificationSinks<T> = Mutex<Vec<TracingUnboundedSender<T>>>;
+
+/// Substrate Client
+pub struct Client<B, E, Block, RA>
+where
+	Block: BlockT,
+{
+	backend: Arc<B>,
+	executor: E,
+	storage_notifications: StorageNotifications<Block>,
+	import_notification_sinks: NotificationSinks<BlockImportNotification<Block>>,
+	every_import_notification_sinks: NotificationSinks<BlockImportNotification<Block>>,
+	finality_notification_sinks: NotificationSinks<FinalityNotification<Block>>,
+	// Collects auxiliary operations to be performed atomically together with
+	// block import operations.
+	import_actions: Mutex<Vec<OnImportAction<Block>>>,
+	// Collects auxiliary operations to be performed atomically together with
+	// block finalization operations.
+	finality_actions: Mutex<Vec<OnFinalityAction<Block>>>,
+	// Holds the block hash currently being imported. TODO: replace this with block queue.
+	importing_block: RwLock<Option<Block::Hash>>,
+	block_rules: BlockRules<Block>,
+	config: ClientConfig<Block>,
+	telemetry: Option<TelemetryHandle>,
+	unpin_worker_sender: TracingUnboundedSender<Block::Hash>,
+	_phantom: PhantomData<RA>,
+}
+
+/// Used in importing a block, where additional changes are made after the runtime
+/// executed.
+enum PrePostHeader<H> {
+	/// they are the same: no post-runtime digest items.
+	Same(H),
+	/// different headers (pre, post).
+	Different(H, H),
+}
+
+impl<H> PrePostHeader<H> {
+	/// get a reference to the "post-header" -- the header as it should be
+	/// after all changes are applied.
+	fn post(&self) -> &H {
+		match *self {
+			PrePostHeader::Same(ref h) => h,
+			PrePostHeader::Different(_, ref h) => h,
+		}
+	}
+
+	/// convert to the "post-header" -- the header as it should be after
+	/// all changes are applied.
+	fn into_post(self) -> H {
+		match self {
+			PrePostHeader::Same(h) => h,
+			PrePostHeader::Different(_, h) => h,
+		}
+	}
+}
+
+enum PrepareStorageChangesResult<Block: BlockT> {
+	Discard(ImportResult),
+	Import(Option<sc_consensus::StorageChanges<Block>>),
+}
+
+/// Create an instance of in-memory client.
+#[cfg(feature = "test-helpers")]
+pub fn new_in_mem<E, Block, G, RA>(
+	backend: Arc<in_mem::Backend<Block>>,
+	executor: E,
+	genesis_block_builder: G,
+	prometheus_registry: Option<Registry>,
+	telemetry: Option<TelemetryHandle>,
+	spawn_handle: Box<dyn SpawnNamed>,
+	config: ClientConfig<Block>,
+) -> sp_blockchain::Result<
+	Client<in_mem::Backend<Block>, LocalCallExecutor<Block, in_mem::Backend<Block>, E>, Block, RA>,
+>
+where
+	E: CodeExecutor + sc_executor::RuntimeVersionOf,
+	Block: BlockT,
+	G: BuildGenesisBlock<
+			Block,
+			BlockImportOperation = <in_mem::Backend<Block> as backend::Backend<Block>>::BlockImportOperation,
+		>,
+{
+	new_with_backend(
+		backend,
+		executor,
+		genesis_block_builder,
+		spawn_handle,
+		prometheus_registry,
+		telemetry,
+		config,
+	)
+}
+
+/// Relevant client configuration items relevant for the client.
+#[derive(Debug, Clone)]
+pub struct ClientConfig<Block: BlockT> {
+	/// Enable the offchain worker db.
+	pub offchain_worker_enabled: bool,
+	/// If true, allows access from the runtime to write into offchain worker db.
+	pub offchain_indexing_api: bool,
+	/// Path where WASM files exist to override the on-chain WASM.
+	pub wasm_runtime_overrides: Option<PathBuf>,
+	/// Skip writing genesis state on first start.
+	pub no_genesis: bool,
+	/// Map of WASM runtime substitute starting at the child of the given block until the runtime
+	/// version doesn't match anymore.
+	pub wasm_runtime_substitutes: HashMap<NumberFor<Block>, Vec<u8>>,
+}
+
+impl<Block: BlockT> Default for ClientConfig<Block> {
+	fn default() -> Self {
+		Self {
+			offchain_worker_enabled: false,
+			offchain_indexing_api: false,
+			wasm_runtime_overrides: None,
+			no_genesis: false,
+			wasm_runtime_substitutes: HashMap::new(),
+		}
+	}
+}
+
+/// Create a client with the explicitly provided backend.
+/// This is useful for testing backend implementations.
+#[cfg(feature = "test-helpers")]
+pub fn new_with_backend<B, E, Block, G, RA>(
+	backend: Arc<B>,
+	executor: E,
+	genesis_block_builder: G,
+	spawn_handle: Box<dyn SpawnNamed>,
+	prometheus_registry: Option<Registry>,
+	telemetry: Option<TelemetryHandle>,
+	config: ClientConfig<Block>,
+) -> sp_blockchain::Result<Client<B, LocalCallExecutor<Block, B, E>, Block, RA>>
+where
+	E: CodeExecutor + sc_executor::RuntimeVersionOf,
+	G: BuildGenesisBlock<
+		Block,
+		BlockImportOperation = <B as backend::Backend<Block>>::BlockImportOperation,
+	>,
+	Block: BlockT,
+	B: backend::LocalBackend<Block> + 'static,
+{
+	let extensions = ExecutionExtensions::new(None, Arc::new(executor.clone()));
+
+	let call_executor =
+		LocalCallExecutor::new(backend.clone(), executor, config.clone(), extensions)?;
+
+	Client::new(
+		backend,
+		call_executor,
+		spawn_handle,
+		genesis_block_builder,
+		Default::default(),
+		Default::default(),
+		prometheus_registry,
+		telemetry,
+		config,
+	)
+}
+
+impl<B, E, Block, RA> BlockOf for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	type Type = Block;
+}
+
+impl<B, E, Block, RA> LockImportRun<Block, B> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err>
+	where
+		F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>,
+		Err: From<sp_blockchain::Error>,
+	{
+		let inner = || {
+			let _import_lock = self.backend.get_import_lock().write();
+
+			let mut op = ClientImportOperation {
+				op: self.backend.begin_operation()?,
+				notify_imported: None,
+				notify_finalized: None,
+			};
+
+			let r = f(&mut op)?;
+
+			let ClientImportOperation { mut op, notify_imported, notify_finalized } = op;
+
+			let finality_notification = notify_finalized.map(|summary| {
+				FinalityNotification::from_summary(summary, self.unpin_worker_sender.clone())
+			});
+
+			let (import_notification, storage_changes, import_notification_action) =
+				match notify_imported {
+					Some(mut summary) => {
+						let import_notification_action = summary.import_notification_action;
+						let storage_changes = summary.storage_changes.take();
+						(
+							Some(BlockImportNotification::from_summary(
+								summary,
+								self.unpin_worker_sender.clone(),
+							)),
+							storage_changes,
+							import_notification_action,
+						)
+					},
+					None => (None, None, ImportNotificationAction::None),
+				};
+
+			if let Some(ref notification) = finality_notification {
+				for action in self.finality_actions.lock().iter_mut() {
+					op.insert_aux(action(notification))?;
+				}
+			}
+			if let Some(ref notification) = import_notification {
+				for action in self.import_actions.lock().iter_mut() {
+					op.insert_aux(action(notification))?;
+				}
+			}
+
+			self.backend.commit_operation(op)?;
+
+			// We need to pin the block in the backend once
+			// for each notification. Once all notifications are
+			// dropped, the block will be unpinned automatically.
+			if let Some(ref notification) = finality_notification {
+				if let Err(err) = self.backend.pin_block(notification.hash) {
+					error!(
+						"Unable to pin block for finality notification. hash: {}, Error: {}",
+						notification.hash, err
+					);
+				};
+			}
+
+			if let Some(ref notification) = import_notification {
+				if let Err(err) = self.backend.pin_block(notification.hash) {
+					error!(
+						"Unable to pin block for import notification. hash: {}, Error: {}",
+						notification.hash, err
+					);
+				};
+			}
+
+			self.notify_finalized(finality_notification)?;
+			self.notify_imported(import_notification, import_notification_action, storage_changes)?;
+
+			Ok(r)
+		};
+
+		let result = inner();
+		*self.importing_block.write() = None;
+
+		result
+	}
+}
+
+impl<B, E, Block, RA> LockImportRun<Block, B> for &Client<B, E, Block, RA>
+where
+	Block: BlockT,
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+{
+	fn lock_import_and_run<R, Err, F>(&self, f: F) -> Result<R, Err>
+	where
+		F: FnOnce(&mut ClientImportOperation<Block, B>) -> Result<R, Err>,
+		Err: From<sp_blockchain::Error>,
+	{
+		(**self).lock_import_and_run(f)
+	}
+}
+
+impl<B, E, Block, RA> Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+	Block::Header: Clone,
+{
+	/// Creates new Substrate Client with given blockchain and code executor.
+	pub fn new<G>(
+		backend: Arc<B>,
+		executor: E,
+		spawn_handle: Box<dyn SpawnNamed>,
+		genesis_block_builder: G,
+		fork_blocks: ForkBlocks<Block>,
+		bad_blocks: BadBlocks<Block>,
+		prometheus_registry: Option<Registry>,
+		telemetry: Option<TelemetryHandle>,
+		config: ClientConfig<Block>,
+	) -> sp_blockchain::Result<Self>
+	where
+		G: BuildGenesisBlock<
+			Block,
+			BlockImportOperation = <B as backend::Backend<Block>>::BlockImportOperation,
+		>,
+		B: 'static,
+	{
+		let info = backend.blockchain().info();
+		if info.finalized_state.is_none() {
+			let (genesis_block, mut op) = genesis_block_builder.build_genesis_block()?;
+			info!(
+				"🔨 Initializing Genesis block/state (state: {}, header-hash: {})",
+				genesis_block.header().state_root(),
+				genesis_block.header().hash()
+			);
+			// Genesis may be written after some blocks have been imported and finalized.
+			// So we only finalize it when the database is empty.
+			let block_state = if info.best_hash == Default::default() {
+				NewBlockState::Final
+			} else {
+				NewBlockState::Normal
+			};
+			let (header, body) = genesis_block.deconstruct();
+			op.set_block_data(header, Some(body), None, None, block_state)?;
+			backend.commit_operation(op)?;
+		}
+
+		let (unpin_worker_sender, mut rx) =
+			tracing_unbounded::<Block::Hash>("unpin-worker-channel", 10_000);
+		let task_backend = Arc::downgrade(&backend);
+		spawn_handle.spawn(
+			"unpin-worker",
+			None,
+			async move {
+				while let Some(message) = rx.next().await {
+					if let Some(backend) = task_backend.upgrade() {
+						backend.unpin_block(message);
+					} else {
+						log::debug!("Terminating unpin-worker, backend reference was dropped.");
+						return
+					}
+				}
+				log::debug!("Terminating unpin-worker, stream terminated.")
+			}
+			.boxed(),
+		);
+
+		Ok(Client {
+			backend,
+			executor,
+			storage_notifications: StorageNotifications::new(prometheus_registry),
+			import_notification_sinks: Default::default(),
+			every_import_notification_sinks: Default::default(),
+			finality_notification_sinks: Default::default(),
+			import_actions: Default::default(),
+			finality_actions: Default::default(),
+			importing_block: Default::default(),
+			block_rules: BlockRules::new(fork_blocks, bad_blocks),
+			config,
+			telemetry,
+			unpin_worker_sender,
+			_phantom: Default::default(),
+		})
+	}
+
+	/// returns a reference to the block import notification sinks
+	/// useful for test environments.
+	pub fn import_notification_sinks(&self) -> &NotificationSinks<BlockImportNotification<Block>> {
+		&self.import_notification_sinks
+	}
+
+	/// returns a reference to the finality notification sinks
+	/// useful for test environments.
+	pub fn finality_notification_sinks(&self) -> &NotificationSinks<FinalityNotification<Block>> {
+		&self.finality_notification_sinks
+	}
+
+	/// Get a reference to the state at a given block.
+	pub fn state_at(&self, hash: Block::Hash) -> sp_blockchain::Result<B::State> {
+		self.backend.state_at(hash)
+	}
+
+	/// Get the code at a given block.
+	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)
+	}
+
+	/// Get the RuntimeVersion at a given block.
+	pub fn runtime_version_at(&self, hash: Block::Hash) -> sp_blockchain::Result<RuntimeVersion> {
+		CallExecutor::runtime_version(&self.executor, hash)
+	}
+
+	/// Apply a checked and validated block to an operation. If a justification is provided
+	/// then `finalized` *must* be true.
+	fn apply_block(
+		&self,
+		operation: &mut ClientImportOperation<Block, B>,
+		import_block: BlockImportParams<Block>,
+		storage_changes: Option<sc_consensus::StorageChanges<Block>>,
+	) -> sp_blockchain::Result<ImportResult>
+	where
+		Self: ProvideRuntimeApi<Block>,
+		<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> + ApiExt<Block>,
+	{
+		let BlockImportParams {
+			origin,
+			header,
+			justifications,
+			post_digests,
+			body,
+			indexed_body,
+			finalized,
+			auxiliary,
+			fork_choice,
+			intermediates,
+			import_existing,
+			..
+		} = import_block;
+
+		if !intermediates.is_empty() {
+			return Err(Error::IncompletePipeline)
+		}
+
+		let fork_choice = fork_choice.ok_or(Error::IncompletePipeline)?;
+
+		let import_headers = if post_digests.is_empty() {
+			PrePostHeader::Same(header)
+		} else {
+			let mut post_header = header.clone();
+			for item in post_digests {
+				post_header.digest_mut().push(item);
+			}
+			PrePostHeader::Different(header, post_header)
+		};
+
+		let hash = import_headers.post().hash();
+		let height = (*import_headers.post().number()).saturated_into::<u64>();
+
+		*self.importing_block.write() = Some(hash);
+
+		let result = self.execute_and_import_block(
+			operation,
+			origin,
+			hash,
+			import_headers,
+			justifications,
+			body,
+			indexed_body,
+			storage_changes,
+			finalized,
+			auxiliary,
+			fork_choice,
+			import_existing,
+		);
+
+		if let Ok(ImportResult::Imported(ref aux)) = result {
+			if aux.is_new_best {
+				// don't send telemetry block import events during initial sync for every
+				// block to avoid spamming the telemetry server, these events will be randomly
+				// sent at a rate of 1/10.
+				if origin != BlockOrigin::NetworkInitialSync || rand::thread_rng().gen_bool(0.1) {
+					telemetry!(
+						self.telemetry;
+						SUBSTRATE_INFO;
+						"block.import";
+						"height" => height,
+						"best" => ?hash,
+						"origin" => ?origin
+					);
+				}
+			}
+		}
+
+		result
+	}
+
+	fn execute_and_import_block(
+		&self,
+		operation: &mut ClientImportOperation<Block, B>,
+		origin: BlockOrigin,
+		hash: Block::Hash,
+		import_headers: PrePostHeader<Block::Header>,
+		justifications: Option<Justifications>,
+		body: Option<Vec<Block::Extrinsic>>,
+		indexed_body: Option<Vec<Vec<u8>>>,
+		storage_changes: Option<sc_consensus::StorageChanges<Block>>,
+		finalized: bool,
+		aux: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+		fork_choice: ForkChoiceStrategy,
+		import_existing: bool,
+	) -> sp_blockchain::Result<ImportResult>
+	where
+		Self: ProvideRuntimeApi<Block>,
+		<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> + ApiExt<Block>,
+	{
+		let parent_hash = *import_headers.post().parent_hash();
+		let status = self.backend.blockchain().status(hash)?;
+		let parent_exists =
+			self.backend.blockchain().status(parent_hash)? == blockchain::BlockStatus::InChain;
+		match (import_existing, status) {
+			(false, blockchain::BlockStatus::InChain) => return Ok(ImportResult::AlreadyInChain),
+			(false, blockchain::BlockStatus::Unknown) => {},
+			(true, blockchain::BlockStatus::InChain) => {},
+			(true, blockchain::BlockStatus::Unknown) => {},
+		}
+
+		let info = self.backend.blockchain().info();
+		let gap_block = info
+			.block_gap
+			.map_or(false, |(start, _)| *import_headers.post().number() == start);
+
+		assert!(justifications.is_some() && finalized || justifications.is_none() || gap_block);
+
+		// the block is lower than our last finalized block so it must revert
+		// finality, refusing import.
+		if status == blockchain::BlockStatus::Unknown &&
+			*import_headers.post().number() <= info.finalized_number &&
+			!gap_block
+		{
+			return Err(sp_blockchain::Error::NotInFinalizedChain)
+		}
+
+		// this is a fairly arbitrary choice of where to draw the line on making notifications,
+		// but the general goal is to only make notifications when we are already fully synced
+		// and get a new chain head.
+		let make_notifications = match origin {
+			BlockOrigin::NetworkBroadcast | BlockOrigin::Own | BlockOrigin::ConsensusBroadcast =>
+				true,
+			BlockOrigin::Genesis | BlockOrigin::NetworkInitialSync | BlockOrigin::File => false,
+		};
+
+		let storage_changes = match storage_changes {
+			Some(storage_changes) => {
+				let storage_changes = match storage_changes {
+					sc_consensus::StorageChanges::Changes(storage_changes) => {
+						self.backend.begin_state_operation(&mut operation.op, parent_hash)?;
+						let (main_sc, child_sc, offchain_sc, tx, _, tx_index) =
+							storage_changes.into_inner();
+
+						if self.config.offchain_indexing_api {
+							operation.op.update_offchain_storage(offchain_sc)?;
+						}
+
+						operation.op.update_db_storage(tx)?;
+						operation.op.update_storage(main_sc.clone(), child_sc.clone())?;
+						operation.op.update_transaction_index(tx_index)?;
+
+						Some((main_sc, child_sc))
+					},
+					sc_consensus::StorageChanges::Import(changes) => {
+						let mut storage = sp_storage::Storage::default();
+						for state in changes.state.0.into_iter() {
+							if state.parent_storage_keys.is_empty() && state.state_root.is_empty() {
+								for (key, value) in state.key_values.into_iter() {
+									storage.top.insert(key, value);
+								}
+							} else {
+								for parent_storage in state.parent_storage_keys {
+									let storage_key = PrefixedStorageKey::new_ref(&parent_storage);
+									let storage_key =
+										match ChildType::from_prefixed_key(storage_key) {
+											Some((ChildType::ParentKeyId, storage_key)) =>
+												storage_key,
+											None =>
+												return Err(Error::Backend(
+													"Invalid child storage key.".to_string(),
+												)),
+										};
+									let entry = storage
+										.children_default
+										.entry(storage_key.to_vec())
+										.or_insert_with(|| StorageChild {
+											data: Default::default(),
+											child_info: ChildInfo::new_default(storage_key),
+										});
+									for (key, value) in state.key_values.iter() {
+										entry.data.insert(key.clone(), value.clone());
+									}
+								}
+							}
+						}
+
+						// This is use by fast sync for runtime version to be resolvable from
+						// changes.
+						let state_version =
+							resolve_state_version_from_wasm(&storage, &self.executor)?;
+						let state_root = operation.op.reset_storage(storage, state_version)?;
+						if state_root != *import_headers.post().state_root() {
+							// State root mismatch when importing state. This should not happen in
+							// safe fast sync mode, but may happen in unsafe mode.
+							warn!("Error importing state: State root mismatch.");
+							return Err(Error::InvalidStateRoot)
+						}
+						None
+					},
+				};
+
+				storage_changes
+			},
+			None => None,
+		};
+
+		// Ensure parent chain is finalized to maintain invariant that finality is called
+		// sequentially.
+		if finalized && parent_exists && info.finalized_hash != parent_hash {
+			self.apply_finality_with_block_hash(
+				operation,
+				parent_hash,
+				None,
+				&info,
+				make_notifications,
+			)?;
+		}
+
+		let is_new_best = !gap_block &&
+			(finalized ||
+				match fork_choice {
+					ForkChoiceStrategy::LongestChain =>
+						import_headers.post().number() > &info.best_number,
+					ForkChoiceStrategy::Custom(v) => v,
+				});
+
+		let leaf_state = if finalized {
+			NewBlockState::Final
+		} else if is_new_best {
+			NewBlockState::Best
+		} else {
+			NewBlockState::Normal
+		};
+
+		let tree_route = if is_new_best && info.best_hash != parent_hash && parent_exists {
+			let route_from_best =
+				sp_blockchain::tree_route(self.backend.blockchain(), info.best_hash, parent_hash)?;
+			Some(route_from_best)
+		} else {
+			None
+		};
+
+		trace!(
+			"Imported {}, (#{}), best={}, origin={:?}",
+			hash,
+			import_headers.post().number(),
+			is_new_best,
+			origin,
+		);
+
+		operation.op.set_block_data(
+			import_headers.post().clone(),
+			body,
+			indexed_body,
+			justifications,
+			leaf_state,
+		)?;
+
+		operation.op.insert_aux(aux)?;
+
+		let should_notify_every_block = !self.every_import_notification_sinks.lock().is_empty();
+
+		// Notify when we are already synced to the tip of the chain
+		// or if this import triggers a re-org
+		let should_notify_recent_block = make_notifications || tree_route.is_some();
+
+		if should_notify_every_block || should_notify_recent_block {
+			let header = import_headers.into_post();
+			if finalized && should_notify_recent_block {
+				let mut summary = match operation.notify_finalized.take() {
+					Some(mut summary) => {
+						summary.header = header.clone();
+						summary.finalized.push(hash);
+						summary
+					},
+					None => FinalizeSummary {
+						header: header.clone(),
+						finalized: vec![hash],
+						stale_heads: Vec::new(),
+					},
+				};
+
+				if parent_exists {
+					// Add to the stale list all heads that are branching from parent besides our
+					// current `head`.
+					for head in self
+						.backend
+						.blockchain()
+						.leaves()?
+						.into_iter()
+						.filter(|h| *h != parent_hash)
+					{
+						let route_from_parent = sp_blockchain::tree_route(
+							self.backend.blockchain(),
+							parent_hash,
+							head,
+						)?;
+						if route_from_parent.retracted().is_empty() {
+							summary.stale_heads.push(head);
+						}
+					}
+				}
+				operation.notify_finalized = Some(summary);
+			}
+
+			let import_notification_action = if should_notify_every_block {
+				if should_notify_recent_block {
+					ImportNotificationAction::Both
+				} else {
+					ImportNotificationAction::EveryBlock
+				}
+			} else {
+				ImportNotificationAction::RecentBlock
+			};
+
+			operation.notify_imported = Some(ImportSummary {
+				hash,
+				origin,
+				header,
+				is_new_best,
+				storage_changes,
+				tree_route,
+				import_notification_action,
+			})
+		}
+
+		Ok(ImportResult::imported(is_new_best))
+	}
+
+	/// Prepares the storage changes for a block.
+	///
+	/// It checks if the state should be enacted and if the `import_block` maybe already provides
+	/// the required storage changes. If the state should be enacted and the storage changes are not
+	/// provided, the block is re-executed to get the storage changes.
+	fn prepare_block_storage_changes(
+		&self,
+		import_block: &mut BlockImportParams<Block>,
+	) -> sp_blockchain::Result<PrepareStorageChangesResult<Block>>
+	where
+		Self: ProvideRuntimeApi<Block>,
+		<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> + ApiExt<Block>,
+	{
+		let parent_hash = import_block.header.parent_hash();
+		let state_action = std::mem::replace(&mut import_block.state_action, StateAction::Skip);
+		let (enact_state, storage_changes) = match (self.block_status(*parent_hash)?, state_action)
+		{
+			(BlockStatus::KnownBad, _) =>
+				return Ok(PrepareStorageChangesResult::Discard(ImportResult::KnownBad)),
+			(
+				BlockStatus::InChainPruned,
+				StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(_)),
+			) => return Ok(PrepareStorageChangesResult::Discard(ImportResult::MissingState)),
+			(_, StateAction::ApplyChanges(changes)) => (true, Some(changes)),
+			(BlockStatus::Unknown, _) =>
+				return Ok(PrepareStorageChangesResult::Discard(ImportResult::UnknownParent)),
+			(_, StateAction::Skip) => (false, None),
+			(BlockStatus::InChainPruned, StateAction::Execute) =>
+				return Ok(PrepareStorageChangesResult::Discard(ImportResult::MissingState)),
+			(BlockStatus::InChainPruned, StateAction::ExecuteIfPossible) => (false, None),
+			(_, StateAction::Execute) => (true, None),
+			(_, StateAction::ExecuteIfPossible) => (true, None),
+		};
+
+		let storage_changes = match (enact_state, storage_changes, &import_block.body) {
+			// We have storage changes and should enact the state, so we don't need to do anything
+			// here
+			(true, changes @ Some(_), _) => changes,
+			// We should enact state, but don't have any storage changes, so we need to execute the
+			// block.
+			(true, None, Some(ref body)) => {
+				let mut runtime_api = self.runtime_api();
+
+				runtime_api.set_call_context(CallContext::Onchain);
+
+				runtime_api.execute_block(
+					*parent_hash,
+					Block::new(import_block.header.clone(), body.clone()),
+				)?;
+
+				let state = self.backend.state_at(*parent_hash)?;
+				let gen_storage_changes = runtime_api
+					.into_storage_changes(&state, *parent_hash)
+					.map_err(sp_blockchain::Error::Storage)?;
+
+				if import_block.header.state_root() != &gen_storage_changes.transaction_storage_root
+				{
+					return Err(Error::InvalidStateRoot)
+				}
+				Some(sc_consensus::StorageChanges::Changes(gen_storage_changes))
+			},
+			// No block body, no storage changes
+			(true, None, None) => None,
+			// We should not enact the state, so we set the storage changes to `None`.
+			(false, _, _) => None,
+		};
+
+		Ok(PrepareStorageChangesResult::Import(storage_changes))
+	}
+
+	fn apply_finality_with_block_hash(
+		&self,
+		operation: &mut ClientImportOperation<Block, B>,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+		info: &BlockchainInfo<Block>,
+		notify: bool,
+	) -> sp_blockchain::Result<()> {
+		if hash == info.finalized_hash {
+			warn!(
+				"Possible safety violation: attempted to re-finalize last finalized block {:?} ",
+				hash,
+			);
+			return Ok(())
+		}
+
+		// Find tree route from last finalized to given block.
+		let route_from_finalized =
+			sp_blockchain::tree_route(self.backend.blockchain(), info.finalized_hash, hash)?;
+
+		if let Some(retracted) = route_from_finalized.retracted().get(0) {
+			warn!(
+				"Safety violation: attempted to revert finalized block {:?} which is not in the \
+				same chain as last finalized {:?}",
+				retracted, info.finalized_hash
+			);
+
+			return Err(sp_blockchain::Error::NotInFinalizedChain)
+		}
+
+		// We may need to coercively update the best block if there is more than one
+		// leaf or if the finalized block number is greater than last best number recorded
+		// by the backend. This last condition may apply in case of consensus implementations
+		// not always checking this condition.
+		let block_number = self
+			.backend
+			.blockchain()
+			.number(hash)?
+			.ok_or(Error::MissingHeader(format!("{hash:?}")))?;
+		if self.backend.blockchain().leaves()?.len() > 1 || info.best_number < block_number {
+			let route_from_best =
+				sp_blockchain::tree_route(self.backend.blockchain(), info.best_hash, hash)?;
+
+			// If the block is not a direct ancestor of the current best chain,
+			// then some other block is the common ancestor.
+			if route_from_best.common_block().hash != hash {
+				// NOTE: we're setting the finalized block as best block, this might
+				// be slightly inaccurate since we might have a "better" block
+				// further along this chain, but since best chain selection logic is
+				// plugable we cannot make a better choice here. usages that need
+				// an accurate "best" block need to go through `SelectChain`
+				// instead.
+				operation.op.mark_head(hash)?;
+			}
+		}
+
+		let enacted = route_from_finalized.enacted();
+		assert!(enacted.len() > 0);
+		for finalize_new in &enacted[..enacted.len() - 1] {
+			operation.op.mark_finalized(finalize_new.hash, None)?;
+		}
+
+		assert_eq!(enacted.last().map(|e| e.hash), Some(hash));
+		operation.op.mark_finalized(hash, justification)?;
+
+		if notify {
+			let finalized =
+				route_from_finalized.enacted().iter().map(|elem| elem.hash).collect::<Vec<_>>();
+
+			let block_number = route_from_finalized
+				.last()
+				.expect(
+					"The block to finalize is always the latest \
+						block in the route to the finalized block; qed",
+				)
+				.number;
+
+			// The stale heads are the leaves that will be displaced after the
+			// block is finalized.
+			let stale_heads =
+				self.backend.blockchain().displaced_leaves_after_finalizing(block_number)?;
+
+			let header = self
+				.backend
+				.blockchain()
+				.header(hash)?
+				.expect("Block to finalize expected to be onchain; qed");
+
+			operation.notify_finalized = Some(FinalizeSummary { header, finalized, stale_heads });
+		}
+
+		Ok(())
+	}
+
+	fn notify_finalized(
+		&self,
+		notification: Option<FinalityNotification<Block>>,
+	) -> sp_blockchain::Result<()> {
+		let mut sinks = self.finality_notification_sinks.lock();
+
+		let notification = match notification {
+			Some(notify_finalized) => notify_finalized,
+			None => {
+				// Cleanup any closed finality notification sinks
+				// since we won't be running the loop below which
+				// would also remove any closed sinks.
+				sinks.retain(|sink| !sink.is_closed());
+				return Ok(())
+			},
+		};
+
+		telemetry!(
+			self.telemetry;
+			SUBSTRATE_INFO;
+			"notify.finalized";
+			"height" => format!("{}", notification.header.number()),
+			"best" => ?notification.hash,
+		);
+
+		sinks.retain(|sink| sink.unbounded_send(notification.clone()).is_ok());
+
+		Ok(())
+	}
+
+	fn notify_imported(
+		&self,
+		notification: Option<BlockImportNotification<Block>>,
+		import_notification_action: ImportNotificationAction,
+		storage_changes: Option<(StorageCollection, ChildStorageCollection)>,
+	) -> sp_blockchain::Result<()> {
+		let notification = match notification {
+			Some(notify_import) => notify_import,
+			None => {
+				// Cleanup any closed import notification sinks since we won't
+				// be sending any notifications below which would remove any
+				// closed sinks. this is necessary since during initial sync we
+				// won't send any import notifications which could lead to a
+				// temporary leak of closed/discarded notification sinks (e.g.
+				// from consensus code).
+				self.import_notification_sinks.lock().retain(|sink| !sink.is_closed());
+
+				self.every_import_notification_sinks.lock().retain(|sink| !sink.is_closed());
+
+				return Ok(())
+			},
+		};
+
+		let trigger_storage_changes_notification = || {
+			if let Some(storage_changes) = storage_changes {
+				// TODO [ToDr] How to handle re-orgs? Should we re-emit all storage changes?
+				self.storage_notifications.trigger(
+					&notification.hash,
+					storage_changes.0.into_iter(),
+					storage_changes.1.into_iter().map(|(sk, v)| (sk, v.into_iter())),
+				);
+			}
+		};
+
+		match import_notification_action {
+			ImportNotificationAction::Both => {
+				trigger_storage_changes_notification();
+				self.import_notification_sinks
+					.lock()
+					.retain(|sink| sink.unbounded_send(notification.clone()).is_ok());
+
+				self.every_import_notification_sinks
+					.lock()
+					.retain(|sink| sink.unbounded_send(notification.clone()).is_ok());
+			},
+			ImportNotificationAction::RecentBlock => {
+				trigger_storage_changes_notification();
+				self.import_notification_sinks
+					.lock()
+					.retain(|sink| sink.unbounded_send(notification.clone()).is_ok());
+
+				self.every_import_notification_sinks.lock().retain(|sink| !sink.is_closed());
+			},
+			ImportNotificationAction::EveryBlock => {
+				self.every_import_notification_sinks
+					.lock()
+					.retain(|sink| sink.unbounded_send(notification.clone()).is_ok());
+
+				self.import_notification_sinks.lock().retain(|sink| !sink.is_closed());
+			},
+			ImportNotificationAction::None => {
+				// This branch is unreachable in fact because the block import notification must be
+				// Some(_) instead of None (it's already handled at the beginning of this function)
+				// at this point.
+				self.import_notification_sinks.lock().retain(|sink| !sink.is_closed());
+
+				self.every_import_notification_sinks.lock().retain(|sink| !sink.is_closed());
+			},
+		}
+
+		Ok(())
+	}
+
+	/// Attempts to revert the chain by `n` blocks guaranteeing that no block is
+	/// reverted past the last finalized block. Returns the number of blocks
+	/// that were successfully reverted.
+	pub fn revert(&self, n: NumberFor<Block>) -> sp_blockchain::Result<NumberFor<Block>> {
+		let (number, _) = self.backend.revert(n, false)?;
+		Ok(number)
+	}
+
+	/// Attempts to revert the chain by `n` blocks disregarding finality. This method will revert
+	/// any finalized blocks as requested and can potentially leave the node in an inconsistent
+	/// state. Other modules in the system that persist data and that rely on finality
+	/// (e.g. consensus parts) will be unaffected by the revert. Use this method with caution and
+	/// making sure that no other data needs to be reverted for consistency aside from the block
+	/// data. If `blacklist` is set to true, will also blacklist reverted blocks from finalizing
+	/// again. The blacklist is reset upon client restart.
+	///
+	/// Returns the number of blocks that were successfully reverted.
+	pub fn unsafe_revert(
+		&mut self,
+		n: NumberFor<Block>,
+		blacklist: bool,
+	) -> sp_blockchain::Result<NumberFor<Block>> {
+		let (number, reverted) = self.backend.revert(n, true)?;
+		if blacklist {
+			for b in reverted {
+				self.block_rules.mark_bad(b);
+			}
+		}
+		Ok(number)
+	}
+
+	/// Get blockchain info.
+	pub fn chain_info(&self) -> BlockchainInfo<Block> {
+		self.backend.blockchain().info()
+	}
+
+	/// Get block status.
+	pub fn block_status(&self, hash: Block::Hash) -> sp_blockchain::Result<BlockStatus> {
+		// this can probably be implemented more efficiently
+		if self
+			.importing_block
+			.read()
+			.as_ref()
+			.map_or(false, |importing| &hash == importing)
+		{
+			return Ok(BlockStatus::Queued)
+		}
+
+		let hash_and_number = self.backend.blockchain().number(hash)?.map(|n| (hash, n));
+		match hash_and_number {
+			Some((hash, number)) =>
+				if self.backend.have_state_at(hash, number) {
+					Ok(BlockStatus::InChainWithState)
+				} else {
+					Ok(BlockStatus::InChainPruned)
+				},
+			None => Ok(BlockStatus::Unknown),
+		}
+	}
+
+	/// Get block header by id.
+	pub fn header(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<<Block as BlockT>::Header>> {
+		self.backend.blockchain().header(hash)
+	}
+
+	/// Get block body by id.
+	pub fn body(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
+		self.backend.blockchain().body(hash)
+	}
+
+	/// Gets the uncles of the block with `target_hash` going back `max_generation` ancestors.
+	pub fn uncles(
+		&self,
+		target_hash: Block::Hash,
+		max_generation: NumberFor<Block>,
+	) -> sp_blockchain::Result<Vec<Block::Hash>> {
+		let load_header = |hash: Block::Hash| -> sp_blockchain::Result<Block::Header> {
+			self.backend
+				.blockchain()
+				.header(hash)?
+				.ok_or_else(|| Error::UnknownBlock(format!("{:?}", hash)))
+		};
+
+		let genesis_hash = self.backend.blockchain().info().genesis_hash;
+		if genesis_hash == target_hash {
+			return Ok(Vec::new())
+		}
+
+		let mut current_hash = target_hash;
+		let mut current = load_header(current_hash)?;
+		let mut ancestor_hash = *current.parent_hash();
+		let mut ancestor = load_header(ancestor_hash)?;
+		let mut uncles = Vec::new();
+
+		let mut generation: NumberFor<Block> = Zero::zero();
+		while generation < max_generation {
+			let children = self.backend.blockchain().children(ancestor_hash)?;
+			uncles.extend(children.into_iter().filter(|h| h != &current_hash));
+			current_hash = ancestor_hash;
+
+			if genesis_hash == current_hash {
+				break
+			}
+
+			current = ancestor;
+			ancestor_hash = *current.parent_hash();
+			ancestor = load_header(ancestor_hash)?;
+			generation += One::one();
+		}
+		trace!("Collected {} uncles", uncles.len());
+		Ok(uncles)
+	}
+}
+
+impl<B, E, Block, RA> UsageProvider<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	/// Get usage info about current client.
+	fn usage_info(&self) -> ClientInfo<Block> {
+		ClientInfo { chain: self.chain_info(), usage: self.backend.usage_info() }
+	}
+}
+
+impl<B, E, Block, RA> ProofProvider<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	fn read_proof(
+		&self,
+		hash: Block::Hash,
+		keys: &mut dyn Iterator<Item = &[u8]>,
+	) -> sp_blockchain::Result<StorageProof> {
+		self.state_at(hash)
+			.and_then(|state| prove_read(state, keys).map_err(Into::into))
+	}
+
+	fn read_child_proof(
+		&self,
+		hash: Block::Hash,
+		child_info: &ChildInfo,
+		keys: &mut dyn Iterator<Item = &[u8]>,
+	) -> sp_blockchain::Result<StorageProof> {
+		self.state_at(hash)
+			.and_then(|state| prove_child_read(state, child_info, keys).map_err(Into::into))
+	}
+
+	fn execution_proof(
+		&self,
+		hash: Block::Hash,
+		method: &str,
+		call_data: &[u8],
+	) -> sp_blockchain::Result<(Vec<u8>, StorageProof)> {
+		self.executor.prove_execution(hash, method, call_data)
+	}
+
+	fn read_proof_collection(
+		&self,
+		hash: Block::Hash,
+		start_key: &[Vec<u8>],
+		size_limit: usize,
+	) -> sp_blockchain::Result<(CompactProof, u32)> {
+		let state = self.state_at(hash)?;
+		// this is a read proof, using version V0 or V1 is equivalent.
+		let root = state.storage_root(std::iter::empty(), StateVersion::V0).0;
+
+		let (proof, count) = prove_range_read_with_child_with_size::<_, HashingFor<Block>>(
+			state, size_limit, start_key,
+		)?;
+		let proof = proof
+			.into_compact_proof::<HashingFor<Block>>(root)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?;
+		Ok((proof, count))
+	}
+
+	fn storage_collection(
+		&self,
+		hash: Block::Hash,
+		start_key: &[Vec<u8>],
+		size_limit: usize,
+	) -> sp_blockchain::Result<Vec<(KeyValueStorageLevel, bool)>> {
+		if start_key.len() > MAX_NESTED_TRIE_DEPTH {
+			return Err(Error::Backend("Invalid start key.".to_string()))
+		}
+		let state = self.state_at(hash)?;
+		let child_info = |storage_key: &Vec<u8>| -> sp_blockchain::Result<ChildInfo> {
+			let storage_key = PrefixedStorageKey::new_ref(storage_key);
+			match ChildType::from_prefixed_key(storage_key) {
+				Some((ChildType::ParentKeyId, storage_key)) =>
+					Ok(ChildInfo::new_default(storage_key)),
+				None => Err(Error::Backend("Invalid child storage key.".to_string())),
+			}
+		};
+		let mut current_child = if start_key.len() == 2 {
+			let start_key = start_key.get(0).expect("checked len");
+			if let Some(child_root) = state
+				.storage(start_key)
+				.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
+			{
+				Some((child_info(start_key)?, child_root))
+			} else {
+				return Err(Error::Backend("Invalid root start key.".to_string()))
+			}
+		} else {
+			None
+		};
+		let mut current_key = start_key.last().map(Clone::clone).unwrap_or_default();
+		let mut total_size = 0;
+		let mut result = vec![(
+			KeyValueStorageLevel {
+				state_root: Vec::new(),
+				key_values: Vec::new(),
+				parent_storage_keys: Vec::new(),
+			},
+			false,
+		)];
+
+		let mut child_roots = HashSet::new();
+		loop {
+			let mut entries = Vec::new();
+			let mut complete = true;
+			let mut switch_child_key = None;
+			while let Some(next_key) = if let Some(child) = current_child.as_ref() {
+				state
+					.next_child_storage_key(&child.0, &current_key)
+					.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
+			} else {
+				state
+					.next_storage_key(&current_key)
+					.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
+			} {
+				let value = if let Some(child) = current_child.as_ref() {
+					state
+						.child_storage(&child.0, next_key.as_ref())
+						.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
+						.unwrap_or_default()
+				} else {
+					state
+						.storage(next_key.as_ref())
+						.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
+						.unwrap_or_default()
+				};
+				let size = value.len() + next_key.len();
+				if total_size + size > size_limit && !entries.is_empty() {
+					complete = false;
+					break
+				}
+				total_size += size;
+
+				if current_child.is_none() &&
+					sp_core::storage::well_known_keys::is_child_storage_key(next_key.as_slice()) &&
+					!child_roots.contains(value.as_slice())
+				{
+					child_roots.insert(value.clone());
+					switch_child_key = Some((next_key.clone(), value.clone()));
+					entries.push((next_key.clone(), value));
+					break
+				}
+				entries.push((next_key.clone(), value));
+				current_key = next_key;
+			}
+			if let Some((child, child_root)) = switch_child_key.take() {
+				result[0].0.key_values.extend(entries.into_iter());
+				current_child = Some((child_info(&child)?, child_root));
+				current_key = Vec::new();
+			} else if let Some((child, child_root)) = current_child.take() {
+				current_key = child.into_prefixed_storage_key().into_inner();
+				result.push((
+					KeyValueStorageLevel {
+						state_root: child_root,
+						key_values: entries,
+						parent_storage_keys: Vec::new(),
+					},
+					complete,
+				));
+				if !complete {
+					break
+				}
+			} else {
+				result[0].0.key_values.extend(entries.into_iter());
+				result[0].1 = complete;
+				break
+			}
+		}
+		Ok(result)
+	}
+
+	fn verify_range_proof(
+		&self,
+		root: Block::Hash,
+		proof: CompactProof,
+		start_key: &[Vec<u8>],
+	) -> sp_blockchain::Result<(KeyValueStates, usize)> {
+		let mut db = sp_state_machine::MemoryDB::<HashingFor<Block>>::new(&[]);
+		// Compact encoding
+		let _ = sp_trie::decode_compact::<sp_state_machine::LayoutV0<HashingFor<Block>>, _, _>(
+			&mut db,
+			proof.iter_compact_encoded_nodes(),
+			Some(&root),
+		)
+		.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?;
+		let proving_backend = sp_state_machine::TrieBackendBuilder::new(db, root).build();
+		let state = read_range_proof_check_with_child_on_proving_backend::<HashingFor<Block>>(
+			&proving_backend,
+			start_key,
+		)?;
+
+		Ok(state)
+	}
+}
+
+impl<B, E, Block, RA> BlockBuilderProvider<B, Block, Self> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block> + Send + Sync + 'static,
+	E: CallExecutor<Block> + Send + Sync + 'static,
+	Block: BlockT,
+	Self: ChainHeaderBackend<Block> + ProvideRuntimeApi<Block>,
+	<Self as ProvideRuntimeApi<Block>>::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+{
+	fn new_block_at<R: Into<RecordProof>>(
+		&self,
+		parent: Block::Hash,
+		inherent_digests: Digest,
+		record_proof: R,
+	) -> sp_blockchain::Result<sc_block_builder::BlockBuilder<Block, Self, B>> {
+		sc_block_builder::BlockBuilder::new(
+			self,
+			parent,
+			self.expect_block_number_from_id(&BlockId::Hash(parent))?,
+			record_proof.into(),
+			inherent_digests,
+			&self.backend,
+		)
+	}
+
+	fn new_block(
+		&self,
+		inherent_digests: Digest,
+	) -> sp_blockchain::Result<sc_block_builder::BlockBuilder<Block, Self, B>> {
+		let info = self.chain_info();
+		sc_block_builder::BlockBuilder::new(
+			self,
+			info.best_hash,
+			info.best_number,
+			RecordProof::No,
+			inherent_digests,
+			&self.backend,
+		)
+	}
+}
+
+impl<B, E, Block, RA> ExecutorProvider<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	type Executor = E;
+
+	fn executor(&self) -> &Self::Executor {
+		&self.executor
+	}
+
+	fn execution_extensions(&self) -> &ExecutionExtensions<Block> {
+		self.executor.execution_extensions()
+	}
+}
+
+impl<B, E, Block, RA> StorageProvider<Block, B> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	fn storage_keys(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<KeysIter<B::State, Block>> {
+		let state = self.state_at(hash)?;
+		KeysIter::new(state, prefix, start_key)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))
+	}
+
+	fn child_storage_keys(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		child_info: ChildInfo,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<KeysIter<B::State, Block>> {
+		let state = self.state_at(hash)?;
+		KeysIter::new_child(state, child_info, prefix, start_key)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))
+	}
+
+	fn storage_pairs(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		prefix: Option<&StorageKey>,
+		start_key: Option<&StorageKey>,
+	) -> sp_blockchain::Result<PairsIter<B::State, Block>> {
+		let state = self.state_at(hash)?;
+		PairsIter::new(state, prefix, start_key)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))
+	}
+
+	fn storage(
+		&self,
+		hash: Block::Hash,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<StorageData>> {
+		Ok(self
+			.state_at(hash)?
+			.storage(&key.0)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
+			.map(StorageData))
+	}
+
+	fn storage_hash(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.state_at(hash)?
+			.storage_hash(&key.0)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))
+	}
+
+	fn child_storage(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		child_info: &ChildInfo,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<StorageData>> {
+		Ok(self
+			.state_at(hash)?
+			.child_storage(child_info, &key.0)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))?
+			.map(StorageData))
+	}
+
+	fn child_storage_hash(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		child_info: &ChildInfo,
+		key: &StorageKey,
+	) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.state_at(hash)?
+			.child_storage_hash(child_info, &key.0)
+			.map_err(|e| sp_blockchain::Error::from_state(Box::new(e)))
+	}
+}
+
+impl<B, E, Block, RA> HeaderMetadata<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	type Error = sp_blockchain::Error;
+
+	fn header_metadata(
+		&self,
+		hash: Block::Hash,
+	) -> Result<CachedHeaderMetadata<Block>, Self::Error> {
+		self.backend.blockchain().header_metadata(hash)
+	}
+
+	fn insert_header_metadata(&self, hash: Block::Hash, metadata: CachedHeaderMetadata<Block>) {
+		self.backend.blockchain().insert_header_metadata(hash, metadata)
+	}
+
+	fn remove_header_metadata(&self, hash: Block::Hash) {
+		self.backend.blockchain().remove_header_metadata(hash)
+	}
+}
+
+impl<B, E, Block, RA> ProvideUncles<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	fn uncles(
+		&self,
+		target_hash: Block::Hash,
+		max_generation: NumberFor<Block>,
+	) -> sp_blockchain::Result<Vec<Block::Header>> {
+		Ok(Client::uncles(self, target_hash, max_generation)?
+			.into_iter()
+			.filter_map(|hash| Client::header(self, hash).unwrap_or(None))
+			.collect())
+	}
+}
+
+impl<B, E, Block, RA> ChainHeaderBackend<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block> + Send + Sync,
+	Block: BlockT,
+	RA: Send + Sync,
+{
+	fn header(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Block::Header>> {
+		self.backend.blockchain().header(hash)
+	}
+
+	fn info(&self) -> blockchain::Info<Block> {
+		self.backend.blockchain().info()
+	}
+
+	fn status(&self, hash: Block::Hash) -> sp_blockchain::Result<blockchain::BlockStatus> {
+		self.backend.blockchain().status(hash)
+	}
+
+	fn number(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<<<Block as BlockT>::Header as HeaderT>::Number>> {
+		self.backend.blockchain().number(hash)
+	}
+
+	fn hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.backend.blockchain().hash(number)
+	}
+}
+
+impl<B, E, Block, RA> BlockIdTo<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block> + Send + Sync,
+	Block: BlockT,
+	RA: Send + Sync,
+{
+	type Error = Error;
+
+	fn to_hash(&self, block_id: &BlockId<Block>) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.block_hash_from_id(block_id)
+	}
+
+	fn to_number(
+		&self,
+		block_id: &BlockId<Block>,
+	) -> sp_blockchain::Result<Option<NumberFor<Block>>> {
+		self.block_number_from_id(block_id)
+	}
+}
+
+impl<B, E, Block, RA> ChainHeaderBackend<Block> for &Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block> + Send + Sync,
+	Block: BlockT,
+	RA: Send + Sync,
+{
+	fn header(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Block::Header>> {
+		self.backend.blockchain().header(hash)
+	}
+
+	fn info(&self) -> blockchain::Info<Block> {
+		self.backend.blockchain().info()
+	}
+
+	fn status(&self, hash: Block::Hash) -> sp_blockchain::Result<blockchain::BlockStatus> {
+		(**self).status(hash)
+	}
+
+	fn number(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<<<Block as BlockT>::Header as HeaderT>::Number>> {
+		(**self).number(hash)
+	}
+
+	fn hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>> {
+		(**self).hash(number)
+	}
+}
+
+impl<B, E, Block, RA> ProvideRuntimeApi<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block, Backend = B> + Send + Sync,
+	Block: BlockT,
+	RA: ConstructRuntimeApi<Block, Self> + Send + Sync,
+{
+	type Api = <RA as ConstructRuntimeApi<Block, Self>>::RuntimeApi;
+
+	fn runtime_api(&self) -> ApiRef<Self::Api> {
+		RA::construct_runtime_api(self)
+	}
+}
+
+impl<B, E, Block, RA> CallApiAt<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block, Backend = B> + Send + Sync,
+	Block: BlockT,
+	RA: Send + Sync,
+{
+	type StateBackend = B::State;
+
+	fn call_api_at(&self, params: CallApiAtParams<Block>) -> Result<Vec<u8>, sp_api::ApiError> {
+		self.executor
+			.contextual_call(
+				params.at,
+				params.function,
+				&params.arguments,
+				params.overlayed_changes,
+				params.recorder,
+				params.call_context,
+				params.extensions,
+			)
+			.map_err(Into::into)
+	}
+
+	fn runtime_version_at(&self, hash: Block::Hash) -> Result<RuntimeVersion, sp_api::ApiError> {
+		CallExecutor::runtime_version(&self.executor, hash).map_err(Into::into)
+	}
+
+	fn state_at(&self, at: Block::Hash) -> Result<Self::StateBackend, sp_api::ApiError> {
+		self.state_at(at).map_err(Into::into)
+	}
+
+	fn initialize_extensions(
+		&self,
+		at: Block::Hash,
+		extensions: &mut sp_externalities::Extensions,
+	) -> Result<(), sp_api::ApiError> {
+		let block_number = self.expect_block_number_from_id(&BlockId::Hash(at))?;
+
+		extensions.merge(self.executor.execution_extensions().extensions(at, block_number));
+
+		Ok(())
+	}
+}
+
+/// NOTE: only use this implementation when you are sure there are NO consensus-level BlockImport
+/// objects. Otherwise, importing blocks directly into the client would be bypassing
+/// important verification work.
+#[async_trait::async_trait]
+impl<B, E, Block, RA> sc_consensus::BlockImport<Block> for &Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block> + Send + Sync,
+	Block: BlockT,
+	Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
+	<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> + ApiExt<Block>,
+	RA: Sync + Send,
+{
+	type Error = ConsensusError;
+
+	/// Import a checked and validated block. If a justification is provided in
+	/// `BlockImportParams` then `finalized` *must* be true.
+	///
+	/// NOTE: only use this implementation when there are NO consensus-level BlockImport
+	/// objects. Otherwise, importing blocks directly into the client would be bypassing
+	/// important verification work.
+	///
+	/// If you are not sure that there are no BlockImport objects provided by the consensus
+	/// algorithm, don't use this function.
+	async fn import_block(
+		&mut self,
+		mut import_block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		let span = tracing::span!(tracing::Level::DEBUG, "import_block");
+		let _enter = span.enter();
+
+		let storage_changes =
+			match self.prepare_block_storage_changes(&mut import_block).map_err(|e| {
+				warn!("Block prepare storage changes error: {}", e);
+				ConsensusError::ClientImport(e.to_string())
+			})? {
+				PrepareStorageChangesResult::Discard(res) => return Ok(res),
+				PrepareStorageChangesResult::Import(storage_changes) => storage_changes,
+			};
+
+		self.lock_import_and_run(|operation| {
+			self.apply_block(operation, import_block, storage_changes)
+		})
+		.map_err(|e| {
+			warn!("Block import error: {}", e);
+			ConsensusError::ClientImport(e.to_string())
+		})
+	}
+
+	/// Check block preconditions.
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		let BlockCheckParams {
+			hash,
+			number,
+			parent_hash,
+			allow_missing_state,
+			import_existing,
+			allow_missing_parent,
+		} = block;
+
+		// Check the block against white and black lists if any are defined
+		// (i.e. fork blocks and bad blocks respectively)
+		match self.block_rules.lookup(number, &hash) {
+			BlockLookupResult::KnownBad => {
+				trace!("Rejecting known bad block: #{} {:?}", number, hash);
+				return Ok(ImportResult::KnownBad)
+			},
+			BlockLookupResult::Expected(expected_hash) => {
+				trace!(
+					"Rejecting block from known invalid fork. Got {:?}, expected: {:?} at height {}",
+					hash,
+					expected_hash,
+					number
+				);
+				return Ok(ImportResult::KnownBad)
+			},
+			BlockLookupResult::NotSpecial => {},
+		}
+
+		// Own status must be checked first. If the block and ancestry is pruned
+		// this function must return `AlreadyInChain` rather than `MissingState`
+		match self
+			.block_status(hash)
+			.map_err(|e| ConsensusError::ClientImport(e.to_string()))?
+		{
+			BlockStatus::InChainWithState | BlockStatus::Queued =>
+				return Ok(ImportResult::AlreadyInChain),
+			BlockStatus::InChainPruned if !import_existing =>
+				return Ok(ImportResult::AlreadyInChain),
+			BlockStatus::InChainPruned => {},
+			BlockStatus::Unknown => {},
+			BlockStatus::KnownBad => return Ok(ImportResult::KnownBad),
+		}
+
+		match self
+			.block_status(parent_hash)
+			.map_err(|e| ConsensusError::ClientImport(e.to_string()))?
+		{
+			BlockStatus::InChainWithState | BlockStatus::Queued => {},
+			BlockStatus::Unknown if allow_missing_parent => {},
+			BlockStatus::Unknown => return Ok(ImportResult::UnknownParent),
+			BlockStatus::InChainPruned if allow_missing_state => {},
+			BlockStatus::InChainPruned => return Ok(ImportResult::MissingState),
+			BlockStatus::KnownBad => return Ok(ImportResult::KnownBad),
+		}
+
+		Ok(ImportResult::imported(false))
+	}
+}
+
+#[async_trait::async_trait]
+impl<B, E, Block, RA> sc_consensus::BlockImport<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block> + Send + Sync,
+	Block: BlockT,
+	Self: ProvideRuntimeApi<Block>,
+	<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block> + ApiExt<Block>,
+	RA: Sync + Send,
+{
+	type Error = ConsensusError;
+
+	async fn import_block(
+		&mut self,
+		import_block: BlockImportParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		(&*self).import_block(import_block).await
+	}
+
+	async fn check_block(
+		&mut self,
+		block: BlockCheckParams<Block>,
+	) -> Result<ImportResult, Self::Error> {
+		(&*self).check_block(block).await
+	}
+}
+
+impl<B, E, Block, RA> Finalizer<Block, B> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	fn apply_finality(
+		&self,
+		operation: &mut ClientImportOperation<Block, B>,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+		notify: bool,
+	) -> sp_blockchain::Result<()> {
+		let info = self.backend.blockchain().info();
+		self.apply_finality_with_block_hash(operation, hash, justification, &info, notify)
+	}
+
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+		notify: bool,
+	) -> sp_blockchain::Result<()> {
+		self.lock_import_and_run(|operation| {
+			self.apply_finality(operation, hash, justification, notify)
+		})
+	}
+}
+
+impl<B, E, Block, RA> Finalizer<Block, B> for &Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	fn apply_finality(
+		&self,
+		operation: &mut ClientImportOperation<Block, B>,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+		notify: bool,
+	) -> sp_blockchain::Result<()> {
+		(**self).apply_finality(operation, hash, justification, notify)
+	}
+
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+		notify: bool,
+	) -> sp_blockchain::Result<()> {
+		(**self).finalize_block(hash, justification, notify)
+	}
+}
+
+impl<B, E, Block, RA> PreCommitActions<Block> for Client<B, E, Block, RA>
+where
+	Block: BlockT,
+{
+	fn register_import_action(&self, action: OnImportAction<Block>) {
+		self.import_actions.lock().push(action);
+	}
+
+	fn register_finality_action(&self, action: OnFinalityAction<Block>) {
+		self.finality_actions.lock().push(action);
+	}
+}
+
+impl<B, E, Block, RA> BlockchainEvents<Block> for Client<B, E, Block, RA>
+where
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	/// Get block import event stream.
+	fn import_notification_stream(&self) -> ImportNotifications<Block> {
+		let (sink, stream) = tracing_unbounded("mpsc_import_notification_stream", 100_000);
+		self.import_notification_sinks.lock().push(sink);
+		stream
+	}
+
+	fn every_import_notification_stream(&self) -> ImportNotifications<Block> {
+		let (sink, stream) = tracing_unbounded("mpsc_every_import_notification_stream", 100_000);
+		self.every_import_notification_sinks.lock().push(sink);
+		stream
+	}
+
+	fn finality_notification_stream(&self) -> FinalityNotifications<Block> {
+		let (sink, stream) = tracing_unbounded("mpsc_finality_notification_stream", 100_000);
+		self.finality_notification_sinks.lock().push(sink);
+		stream
+	}
+
+	/// Get storage changes event stream.
+	fn storage_changes_notification_stream(
+		&self,
+		filter_keys: Option<&[StorageKey]>,
+		child_filter_keys: Option<&[(StorageKey, Option<Vec<StorageKey>>)]>,
+	) -> sp_blockchain::Result<StorageEventStream<Block::Hash>> {
+		Ok(self.storage_notifications.listen(filter_keys, child_filter_keys))
+	}
+}
+
+impl<B, E, Block, RA> BlockBackend<Block> for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+{
+	fn block_body(
+		&self,
+		hash: Block::Hash,
+	) -> sp_blockchain::Result<Option<Vec<<Block as BlockT>::Extrinsic>>> {
+		self.body(hash)
+	}
+
+	fn block(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<SignedBlock<Block>>> {
+		Ok(match (self.header(hash)?, self.body(hash)?, self.justifications(hash)?) {
+			(Some(header), Some(extrinsics), justifications) =>
+				Some(SignedBlock { block: Block::new(header, extrinsics), justifications }),
+			_ => None,
+		})
+	}
+
+	fn block_status(&self, hash: Block::Hash) -> sp_blockchain::Result<BlockStatus> {
+		Client::block_status(self, hash)
+	}
+
+	fn justifications(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Justifications>> {
+		self.backend.blockchain().justifications(hash)
+	}
+
+	fn block_hash(&self, number: NumberFor<Block>) -> sp_blockchain::Result<Option<Block::Hash>> {
+		self.backend.blockchain().hash(number)
+	}
+
+	fn indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		self.backend.blockchain().indexed_transaction(hash)
+	}
+
+	fn has_indexed_transaction(&self, hash: Block::Hash) -> sp_blockchain::Result<bool> {
+		self.backend.blockchain().has_indexed_transaction(hash)
+	}
+
+	fn block_indexed_body(&self, hash: Block::Hash) -> sp_blockchain::Result<Option<Vec<Vec<u8>>>> {
+		self.backend.blockchain().block_indexed_body(hash)
+	}
+
+	fn requires_full_sync(&self) -> bool {
+		self.backend.requires_full_sync()
+	}
+}
+
+impl<B, E, Block, RA> backend::AuxStore for Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+	Self: ProvideRuntimeApi<Block>,
+	<Self as ProvideRuntimeApi<Block>>::Api: CoreApi<Block>,
+{
+	/// Insert auxiliary data into key-value store.
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item = &'a &'b [u8]>,
+	>(
+		&self,
+		insert: I,
+		delete: D,
+	) -> sp_blockchain::Result<()> {
+		// Import is locked here because we may have other block import
+		// operations that tries to set aux data. Note that for consensus
+		// layer, one can always use atomic operations to make sure
+		// import is only locked once.
+		self.lock_import_and_run(|operation| apply_aux(operation, insert, delete))
+	}
+	/// Query auxiliary data from key-value store.
+	fn get_aux(&self, key: &[u8]) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		backend::AuxStore::get_aux(&*self.backend, key)
+	}
+}
+
+impl<B, E, Block, RA> backend::AuxStore for &Client<B, E, Block, RA>
+where
+	B: backend::Backend<Block>,
+	E: CallExecutor<Block>,
+	Block: BlockT,
+	Client<B, E, Block, RA>: ProvideRuntimeApi<Block>,
+	<Client<B, E, Block, RA> as ProvideRuntimeApi<Block>>::Api: CoreApi<Block>,
+{
+	fn insert_aux<
+		'a,
+		'b: 'a,
+		'c: 'a,
+		I: IntoIterator<Item = &'a (&'c [u8], &'c [u8])>,
+		D: IntoIterator<Item = &'a &'b [u8]>,
+	>(
+		&self,
+		insert: I,
+		delete: D,
+	) -> sp_blockchain::Result<()> {
+		(**self).insert_aux(insert, delete)
+	}
+
+	fn get_aux(&self, key: &[u8]) -> sp_blockchain::Result<Option<Vec<u8>>> {
+		(**self).get_aux(key)
+	}
+}
+
+impl<BE, E, B, RA> sp_consensus::block_validation::Chain<B> for Client<BE, E, B, RA>
+where
+	BE: backend::Backend<B>,
+	E: CallExecutor<B>,
+	B: BlockT,
+{
+	fn block_status(
+		&self,
+		hash: B::Hash,
+	) -> Result<BlockStatus, Box<dyn std::error::Error + Send>> {
+		Client::block_status(self, hash).map_err(|e| Box::new(e) as Box<_>)
+	}
+}
+
+impl<BE, E, B, RA> sp_transaction_storage_proof::IndexedBody<B> for Client<BE, E, B, RA>
+where
+	BE: backend::Backend<B>,
+	E: CallExecutor<B>,
+	B: BlockT,
+{
+	fn block_indexed_body(
+		&self,
+		number: NumberFor<B>,
+	) -> Result<Option<Vec<Vec<u8>>>, sp_transaction_storage_proof::Error> {
+		let hash = match self
+			.backend
+			.blockchain()
+			.block_hash_from_id(&BlockId::Number(number))
+			.map_err(|e| sp_transaction_storage_proof::Error::Application(Box::new(e)))?
+		{
+			Some(hash) => hash,
+			None => return Ok(None),
+		};
+
+		self.backend
+			.blockchain()
+			.block_indexed_body(hash)
+			.map_err(|e| sp_transaction_storage_proof::Error::Application(Box::new(e)))
+	}
+
+	fn number(
+		&self,
+		hash: B::Hash,
+	) -> Result<Option<NumberFor<B>>, sp_transaction_storage_proof::Error> {
+		self.backend
+			.blockchain()
+			.number(hash)
+			.map_err(|e| sp_transaction_storage_proof::Error::Application(Box::new(e)))
+	}
+}
diff --git a/substrate/client/service/src/client/mod.rs b/substrate/client/service/src/client/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a13fd4317e1553d379ea068c516e74072d3c8c95
--- /dev/null
+++ b/substrate/client/service/src/client/mod.rs
@@ -0,0 +1,59 @@
+// 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/>.
+
+//! Substrate Client and associated logic.
+//!
+//! The [`Client`] is one of the most important components of Substrate. It mainly comprises two
+//! parts:
+//!
+//! - A database containing the blocks and chain state, generally referred to as
+//! the [`Backend`](sc_client_api::backend::Backend).
+//! - A runtime environment, generally referred to as the
+//! [`Executor`](sc_client_api::call_executor::CallExecutor).
+//!
+//! # Initialization
+//!
+//! Creating a [`Client`] is done by calling the `new` method and passing to it a
+//! [`Backend`](sc_client_api::backend::Backend) and an
+//! [`Executor`](sc_client_api::call_executor::CallExecutor).
+//!
+//! The former is typically provided by the `sc-client-db` crate.
+//!
+//! The latter typically requires passing one of:
+//!
+//! - A [`LocalCallExecutor`] running the runtime locally.
+//! - A `RemoteCallExecutor` that will ask a third-party to perform the executions.
+//! - A `RemoteOrLocalCallExecutor` combination of the two.
+//!
+//! Additionally, the fourth generic parameter of the `Client` is a marker type representing
+//! the ways in which the runtime can interface with the outside. Any code that builds a `Client`
+//! is responsible for putting the right marker.
+
+mod block_rules;
+mod call_executor;
+mod client;
+mod wasm_override;
+mod wasm_substitutes;
+
+pub use self::{
+	call_executor::LocalCallExecutor,
+	client::{Client, ClientConfig},
+};
+
+#[cfg(feature = "test-helpers")]
+pub use self::client::{new_in_mem, new_with_backend};
diff --git a/substrate/client/service/src/client/wasm_override.rs b/substrate/client/service/src/client/wasm_override.rs
new file mode 100644
index 0000000000000000000000000000000000000000..725c8ab9429aca18998c4e94c467ff5851348a7c
--- /dev/null
+++ b/substrate/client/service/src/client/wasm_override.rs
@@ -0,0 +1,350 @@
+// 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/>.
+
+//! # WASM Local Blob-Override
+//!
+//! WASM Local blob override provides tools to replace on-chain WASM with custom WASM.
+//! These customized WASM blobs may include functionality that is not included in the
+//! on-chain WASM, such as tracing or debugging information. This extra information is especially
+//! useful in external scenarios, like exchanges or archive nodes.
+//!
+//! ## Usage
+//!
+//! WASM overrides may be enabled with the `--wasm-runtime-overrides` argument. The argument
+//! expects a path to a directory that holds custom WASM.
+//!
+//! Any file ending in '.wasm' will be scraped and instantiated as a WASM blob. WASM can be built by
+//! compiling the required runtime with the changes needed. For example, compiling a runtime with
+//! tracing enabled would produce a WASM blob that can used.
+//!
+//! A custom WASM blob will override on-chain WASM if the spec version matches. If it is
+//! required to overrides multiple runtimes, multiple WASM blobs matching each of the spec versions
+//! needed must be provided in the given directory.
+
+use sc_executor::RuntimeVersionOf;
+use sp_blockchain::Result;
+use sp_core::traits::{FetchRuntimeCode, RuntimeCode, WrappedRuntimeCode};
+use sp_state_machine::BasicExternalities;
+use sp_version::RuntimeVersion;
+use std::{
+	collections::{hash_map::DefaultHasher, HashMap},
+	fs,
+	hash::Hasher as _,
+	path::{Path, PathBuf},
+	time::{Duration, Instant},
+};
+
+/// The interval in that we will print a warning when a wasm blob `spec_name`
+/// doesn't match with the on-chain `spec_name`.
+const WARN_INTERVAL: Duration = Duration::from_secs(30);
+
+/// Auxiliary structure that holds a wasm blob and its hash.
+#[derive(Debug)]
+struct WasmBlob {
+	/// The actual wasm blob, aka the code.
+	code: Vec<u8>,
+	/// The hash of [`Self::code`].
+	hash: Vec<u8>,
+	/// The path where this blob was found.
+	path: PathBuf,
+	/// The runtime version of this blob.
+	version: RuntimeVersion,
+	/// When was the last time we have warned about the wasm blob having
+	/// a wrong `spec_name`?
+	last_warn: parking_lot::Mutex<Option<Instant>>,
+}
+
+impl WasmBlob {
+	fn new(code: Vec<u8>, hash: Vec<u8>, path: PathBuf, version: RuntimeVersion) -> Self {
+		Self { code, hash, path, version, last_warn: Default::default() }
+	}
+
+	fn runtime_code(&self, heap_pages: Option<u64>) -> RuntimeCode {
+		RuntimeCode { code_fetcher: self, hash: self.hash.clone(), heap_pages }
+	}
+}
+
+/// Make a hash out of a byte string using the default rust hasher
+fn make_hash<K: std::hash::Hash + ?Sized>(val: &K) -> Vec<u8> {
+	let mut state = DefaultHasher::new();
+	val.hash(&mut state);
+	state.finish().to_le_bytes().to_vec()
+}
+
+impl FetchRuntimeCode for WasmBlob {
+	fn fetch_runtime_code(&self) -> Option<std::borrow::Cow<[u8]>> {
+		Some(self.code.as_slice().into())
+	}
+}
+
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum WasmOverrideError {
+	#[error("Failed to get runtime version: {0}")]
+	VersionInvalid(String),
+
+	#[error("WASM override IO error")]
+	Io(PathBuf, #[source] std::io::Error),
+
+	#[error("Overwriting WASM requires a directory where local \
+	WASM is stored. {} is not a directory", .0.display())]
+	NotADirectory(PathBuf),
+
+	#[error("Duplicate WASM Runtimes found: \n{}\n", .0.join("\n") )]
+	DuplicateRuntime(Vec<String>),
+}
+
+impl From<WasmOverrideError> for sp_blockchain::Error {
+	fn from(err: WasmOverrideError) -> Self {
+		Self::Application(Box::new(err))
+	}
+}
+
+/// Scrapes WASM from a folder and returns WASM from that folder
+/// if the runtime spec version matches.
+#[derive(Debug)]
+pub struct WasmOverride {
+	// Map of runtime spec version -> Wasm Blob
+	overrides: HashMap<u32, WasmBlob>,
+}
+
+impl WasmOverride {
+	pub fn new<P, E>(path: P, executor: &E) -> Result<Self>
+	where
+		P: AsRef<Path>,
+		E: RuntimeVersionOf,
+	{
+		let overrides = Self::scrape_overrides(path.as_ref(), executor)?;
+		Ok(Self { overrides })
+	}
+
+	/// Gets an override by it's runtime spec version.
+	///
+	/// Returns `None` if an override for a spec version does not exist.
+	pub fn get<'a, 'b: 'a>(
+		&'b self,
+		spec: &u32,
+		pages: Option<u64>,
+		spec_name: &str,
+	) -> Option<(RuntimeCode<'a>, RuntimeVersion)> {
+		self.overrides.get(spec).and_then(|w| {
+			if spec_name == &*w.version.spec_name {
+				Some((w.runtime_code(pages), w.version.clone()))
+			} else {
+				let mut last_warn = w.last_warn.lock();
+				let now = Instant::now();
+
+				if last_warn.map_or(true, |l| l + WARN_INTERVAL <= now) {
+					*last_warn = Some(now);
+
+					tracing::warn!(
+						target = "wasm_overrides",
+						on_chain_spec_name = %spec_name,
+						override_spec_name = %w.version,
+						spec_version = %spec,
+						wasm_file = %w.path.display(),
+						"On chain and override `spec_name` do not match! Ignoring override.",
+					);
+				}
+
+				None
+			}
+		})
+	}
+
+	/// Scrapes a folder for WASM runtimes.
+	/// Returns a hashmap of the runtime version and wasm runtime code.
+	fn scrape_overrides<E>(dir: &Path, executor: &E) -> Result<HashMap<u32, WasmBlob>>
+	where
+		E: RuntimeVersionOf,
+	{
+		let handle_err = |e: std::io::Error| -> sp_blockchain::Error {
+			WasmOverrideError::Io(dir.to_owned(), e).into()
+		};
+
+		if !dir.is_dir() {
+			return Err(WasmOverrideError::NotADirectory(dir.to_owned()).into())
+		}
+
+		let mut overrides = HashMap::new();
+		let mut duplicates = Vec::new();
+		for entry in fs::read_dir(dir).map_err(handle_err)? {
+			let entry = entry.map_err(handle_err)?;
+			let path = entry.path();
+			if let Some("wasm") = path.extension().and_then(|e| e.to_str()) {
+				let code = fs::read(&path).map_err(handle_err)?;
+				let code_hash = make_hash(&code);
+				let version = Self::runtime_version(executor, &code, &code_hash, Some(128))?;
+				tracing::info!(
+					target: "wasm_overrides",
+					version = %version,
+					file = %path.display(),
+					"Found wasm override.",
+				);
+
+				let wasm = WasmBlob::new(code, code_hash, path.clone(), version.clone());
+
+				if let Some(other) = overrides.insert(version.spec_version, wasm) {
+					tracing::info!(
+						target: "wasm_overrides",
+						first = %other.path.display(),
+						second = %path.display(),
+						%version,
+						"Found duplicate spec version for runtime.",
+					);
+					duplicates.push(path.display().to_string());
+				}
+			}
+		}
+
+		if !duplicates.is_empty() {
+			return Err(WasmOverrideError::DuplicateRuntime(duplicates).into())
+		}
+
+		Ok(overrides)
+	}
+
+	fn runtime_version<E>(
+		executor: &E,
+		code: &[u8],
+		code_hash: &[u8],
+		heap_pages: Option<u64>,
+	) -> Result<RuntimeVersion>
+	where
+		E: RuntimeVersionOf,
+	{
+		let mut ext = BasicExternalities::default();
+		executor
+			.runtime_version(
+				&mut ext,
+				&RuntimeCode {
+					code_fetcher: &WrappedRuntimeCode(code.into()),
+					heap_pages,
+					hash: code_hash.into(),
+				},
+			)
+			.map_err(|e| WasmOverrideError::VersionInvalid(e.to_string()).into())
+	}
+}
+
+/// Returns a WasmOverride struct filled with dummy data for testing.
+#[cfg(test)]
+pub fn dummy_overrides() -> WasmOverride {
+	let version = RuntimeVersion { spec_name: "test".into(), ..Default::default() };
+	let mut overrides = HashMap::new();
+	overrides.insert(
+		0,
+		WasmBlob::new(vec![0, 0, 0, 0, 0, 0, 0, 0], vec![0], PathBuf::new(), version.clone()),
+	);
+	overrides.insert(
+		1,
+		WasmBlob::new(vec![1, 1, 1, 1, 1, 1, 1, 1], vec![1], PathBuf::new(), version.clone()),
+	);
+	overrides
+		.insert(2, WasmBlob::new(vec![2, 2, 2, 2, 2, 2, 2, 2], vec![2], PathBuf::new(), version));
+
+	WasmOverride { overrides }
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_executor::{HeapAllocStrategy, NativeElseWasmExecutor, WasmExecutor};
+	use std::fs::{self, File};
+	use substrate_test_runtime_client::LocalExecutorDispatch;
+
+	fn executor() -> NativeElseWasmExecutor<substrate_test_runtime_client::LocalExecutorDispatch> {
+		NativeElseWasmExecutor::<substrate_test_runtime_client::LocalExecutorDispatch>::new_with_wasm_executor(
+			WasmExecutor::builder()
+				.with_onchain_heap_alloc_strategy(HeapAllocStrategy::Static {extra_pages: 128})
+				.with_offchain_heap_alloc_strategy(HeapAllocStrategy::Static {extra_pages: 128})
+				.with_max_runtime_instances(1)
+				.with_runtime_cache_size(2)
+				.build()
+		)
+	}
+
+	fn wasm_test<F>(fun: F)
+	where
+		F: Fn(&Path, &[u8], &NativeElseWasmExecutor<LocalExecutorDispatch>),
+	{
+		let exec = executor();
+		let bytes = substrate_test_runtime::wasm_binary_unwrap();
+		let dir = tempfile::tempdir().expect("Create a temporary directory");
+		fun(dir.path(), bytes, &exec);
+		dir.close().expect("Temporary Directory should close");
+	}
+
+	#[test]
+	fn should_get_runtime_version() {
+		let executor = executor();
+
+		let version = WasmOverride::runtime_version(
+			&executor,
+			substrate_test_runtime::wasm_binary_unwrap(),
+			&[1],
+			Some(128),
+		)
+		.expect("should get the `RuntimeVersion` of the test-runtime wasm blob");
+		assert_eq!(version.spec_version, 2);
+	}
+
+	#[test]
+	fn should_scrape_wasm() {
+		wasm_test(|dir, wasm_bytes, exec| {
+			fs::write(dir.join("test.wasm"), wasm_bytes).expect("Create test file");
+			let overrides =
+				WasmOverride::scrape_overrides(dir, exec).expect("HashMap of u32 and WasmBlob");
+			let wasm = overrides.get(&2).expect("WASM binary");
+			assert_eq!(wasm.code, substrate_test_runtime::wasm_binary_unwrap().to_vec())
+		});
+	}
+
+	#[test]
+	fn should_check_for_duplicates() {
+		wasm_test(|dir, wasm_bytes, exec| {
+			fs::write(dir.join("test0.wasm"), wasm_bytes).expect("Create test file");
+			fs::write(dir.join("test1.wasm"), wasm_bytes).expect("Create test file");
+			let scraped = WasmOverride::scrape_overrides(dir, exec);
+
+			match scraped {
+				Err(sp_blockchain::Error::Application(e)) => {
+					match e.downcast_ref::<WasmOverrideError>() {
+						Some(WasmOverrideError::DuplicateRuntime(duplicates)) => {
+							assert_eq!(duplicates.len(), 1);
+						},
+						_ => panic!("Test should end with Msg Error Variant"),
+					}
+				},
+				_ => panic!("Test should end in error"),
+			}
+		});
+	}
+
+	#[test]
+	fn should_ignore_non_wasm() {
+		wasm_test(|dir, wasm_bytes, exec| {
+			File::create(dir.join("README.md")).expect("Create test file");
+			File::create(dir.join("LICENSE")).expect("Create a test file");
+			fs::write(dir.join("test0.wasm"), wasm_bytes).expect("Create test file");
+			let scraped =
+				WasmOverride::scrape_overrides(dir, exec).expect("HashMap of u32 and WasmBlob");
+			assert_eq!(scraped.len(), 1);
+		});
+	}
+}
diff --git a/substrate/client/service/src/client/wasm_substitutes.rs b/substrate/client/service/src/client/wasm_substitutes.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a792ab87e771bd0b1652e5d7f4b5708f945b4346
--- /dev/null
+++ b/substrate/client/service/src/client/wasm_substitutes.rs
@@ -0,0 +1,163 @@
+// 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/>.
+
+//! # WASM substitutes
+
+use sc_client_api::backend;
+use sc_executor::RuntimeVersionOf;
+use sp_blockchain::{HeaderBackend, Result};
+use sp_core::traits::{FetchRuntimeCode, RuntimeCode, WrappedRuntimeCode};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use sp_state_machine::BasicExternalities;
+use sp_version::RuntimeVersion;
+use std::{
+	collections::{hash_map::DefaultHasher, HashMap},
+	hash::Hasher as _,
+	sync::Arc,
+};
+
+/// A wasm substitute for the on chain wasm.
+#[derive(Debug)]
+struct WasmSubstitute<Block: BlockT> {
+	code: Vec<u8>,
+	hash: Vec<u8>,
+	/// The block number on which we should start using the substitute.
+	block_number: NumberFor<Block>,
+	version: RuntimeVersion,
+}
+
+impl<Block: BlockT> WasmSubstitute<Block> {
+	fn new(code: Vec<u8>, block_number: NumberFor<Block>, version: RuntimeVersion) -> Self {
+		let hash = make_hash(&code);
+		Self { code, hash, block_number, version }
+	}
+
+	fn runtime_code(&self, heap_pages: Option<u64>) -> RuntimeCode {
+		RuntimeCode { code_fetcher: self, hash: self.hash.clone(), heap_pages }
+	}
+
+	/// Returns `true` when the substitute matches for the given `hash`.
+	fn matches(
+		&self,
+		hash: <Block as BlockT>::Hash,
+		backend: &impl backend::Backend<Block>,
+	) -> bool {
+		let requested_block_number = backend.blockchain().number(hash).ok().flatten();
+
+		Some(self.block_number) <= requested_block_number
+	}
+}
+
+/// Make a hash out of a byte string using the default rust hasher
+fn make_hash<K: std::hash::Hash + ?Sized>(val: &K) -> Vec<u8> {
+	let mut state = DefaultHasher::new();
+	val.hash(&mut state);
+	state.finish().to_le_bytes().to_vec()
+}
+
+impl<Block: BlockT> FetchRuntimeCode for WasmSubstitute<Block> {
+	fn fetch_runtime_code(&self) -> Option<std::borrow::Cow<[u8]>> {
+		Some(self.code.as_slice().into())
+	}
+}
+
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum WasmSubstituteError {
+	#[error("Failed to get runtime version: {0}")]
+	VersionInvalid(String),
+}
+
+impl From<WasmSubstituteError> for sp_blockchain::Error {
+	fn from(err: WasmSubstituteError) -> Self {
+		Self::Application(Box::new(err))
+	}
+}
+
+/// Substitutes the on-chain wasm with some hard coded blobs.
+#[derive(Debug)]
+pub struct WasmSubstitutes<Block: BlockT, Executor, Backend> {
+	/// spec_version -> WasmSubstitute
+	substitutes: Arc<HashMap<u32, WasmSubstitute<Block>>>,
+	executor: Executor,
+	backend: Arc<Backend>,
+}
+
+impl<Block: BlockT, Executor: Clone, Backend> Clone for WasmSubstitutes<Block, Executor, Backend> {
+	fn clone(&self) -> Self {
+		Self {
+			substitutes: self.substitutes.clone(),
+			executor: self.executor.clone(),
+			backend: self.backend.clone(),
+		}
+	}
+}
+
+impl<Executor, Backend, Block> WasmSubstitutes<Block, Executor, Backend>
+where
+	Executor: RuntimeVersionOf + Clone + 'static,
+	Backend: backend::Backend<Block>,
+	Block: BlockT,
+{
+	/// Create a new instance.
+	pub fn new(
+		substitutes: HashMap<NumberFor<Block>, Vec<u8>>,
+		executor: Executor,
+		backend: Arc<Backend>,
+	) -> Result<Self> {
+		let substitutes = substitutes
+			.into_iter()
+			.map(|(block_number, code)| {
+				let runtime_code = RuntimeCode {
+					code_fetcher: &WrappedRuntimeCode((&code).into()),
+					heap_pages: None,
+					hash: Vec::new(),
+				};
+				let version = Self::runtime_version(&executor, &runtime_code)?;
+				let spec_version = version.spec_version;
+
+				let substitute = WasmSubstitute::new(code, block_number, version);
+
+				Ok((spec_version, substitute))
+			})
+			.collect::<Result<HashMap<_, _>>>()?;
+
+		Ok(Self { executor, substitutes: Arc::new(substitutes), backend })
+	}
+
+	/// Get a substitute.
+	///
+	/// Returns `None` if there isn't any substitute required.
+	pub fn get(
+		&self,
+		spec: u32,
+		pages: Option<u64>,
+		hash: Block::Hash,
+	) -> Option<(RuntimeCode<'_>, RuntimeVersion)> {
+		let s = self.substitutes.get(&spec)?;
+		s.matches(hash, &*self.backend)
+			.then(|| (s.runtime_code(pages), s.version.clone()))
+	}
+
+	fn runtime_version(executor: &Executor, code: &RuntimeCode) -> Result<RuntimeVersion> {
+		let mut ext = BasicExternalities::default();
+		executor
+			.runtime_version(&mut ext, code)
+			.map_err(|e| WasmSubstituteError::VersionInvalid(e.to_string()).into())
+	}
+}
diff --git a/substrate/client/service/src/config.rs b/substrate/client/service/src/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..39b7ee0507906d66732d157b93dc56fba2993bfa
--- /dev/null
+++ b/substrate/client/service/src/config.rs
@@ -0,0 +1,331 @@
+// 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/>.
+
+//! Service configuration.
+
+pub use sc_client_db::{BlocksPruning, Database, DatabaseSource, PruningMode};
+pub use sc_executor::{WasmExecutionMethod, WasmtimeInstantiationStrategy};
+pub use sc_network::{
+	config::{
+		MultiaddrWithPeerId, NetworkConfiguration, NodeKeyConfig, NonDefaultSetConfig, ProtocolId,
+		Role, SetConfig, SyncMode, TransportConfig,
+	},
+	request_responses::{
+		IncomingRequest, OutgoingResponse, ProtocolConfig as RequestResponseConfig,
+	},
+	Multiaddr,
+};
+
+use prometheus_endpoint::Registry;
+use sc_chain_spec::ChainSpec;
+pub use sc_telemetry::TelemetryEndpoints;
+pub use sc_transaction_pool::Options as TransactionPoolOptions;
+use sp_core::crypto::SecretString;
+use std::{
+	io, iter,
+	net::SocketAddr,
+	path::{Path, PathBuf},
+};
+use tempfile::TempDir;
+
+/// Service configuration.
+#[derive(Debug)]
+pub struct Configuration {
+	/// Implementation name
+	pub impl_name: String,
+	/// Implementation version (see sc-cli to see an example of format)
+	pub impl_version: String,
+	/// Node role.
+	pub role: Role,
+	/// Handle to the tokio runtime. Will be used to spawn futures by the task manager.
+	pub tokio_handle: tokio::runtime::Handle,
+	/// Extrinsic pool configuration.
+	pub transaction_pool: TransactionPoolOptions,
+	/// Network configuration.
+	pub network: NetworkConfiguration,
+	/// Configuration for the keystore.
+	pub keystore: KeystoreConfig,
+	/// Configuration for the database.
+	pub database: DatabaseSource,
+	/// Maximum size of internal trie cache in bytes.
+	///
+	/// If `None` is given the cache is disabled.
+	pub trie_cache_maximum_size: Option<usize>,
+	/// State pruning settings.
+	pub state_pruning: Option<PruningMode>,
+	/// Number of blocks to keep in the db.
+	///
+	/// NOTE: only finalized blocks are subject for removal!
+	pub blocks_pruning: BlocksPruning,
+	/// Chain configuration.
+	pub chain_spec: Box<dyn ChainSpec>,
+	/// Wasm execution method.
+	pub wasm_method: WasmExecutionMethod,
+	/// Directory where local WASM runtimes live. These runtimes take precedence
+	/// over on-chain runtimes when the spec version matches. Set to `None` to
+	/// disable overrides (default).
+	pub wasm_runtime_overrides: Option<PathBuf>,
+	/// JSON-RPC server binding address.
+	pub rpc_addr: Option<SocketAddr>,
+	/// Maximum number of connections for JSON-RPC server.
+	pub rpc_max_connections: u32,
+	/// CORS settings for HTTP & WS servers. `None` if all origins are allowed.
+	pub rpc_cors: Option<Vec<String>>,
+	/// RPC methods to expose (by default only a safe subset or all of them).
+	pub rpc_methods: RpcMethods,
+	/// Maximum payload of a rpc request
+	pub rpc_max_request_size: u32,
+	/// Maximum payload of a rpc response.
+	pub rpc_max_response_size: u32,
+	/// Custom JSON-RPC subscription ID provider.
+	///
+	/// Default: [`crate::RandomStringSubscriptionId`].
+	pub rpc_id_provider: Option<Box<dyn crate::RpcSubscriptionIdProvider>>,
+	/// Maximum allowed subscriptions per rpc connection
+	pub rpc_max_subs_per_conn: u32,
+	/// JSON-RPC server default port.
+	pub rpc_port: u16,
+	/// Prometheus endpoint configuration. `None` if disabled.
+	pub prometheus_config: Option<PrometheusConfig>,
+	/// Telemetry service URL. `None` if disabled.
+	pub telemetry_endpoints: Option<TelemetryEndpoints>,
+	/// The default number of 64KB pages to allocate for Wasm execution
+	pub default_heap_pages: Option<u64>,
+	/// Should offchain workers be executed.
+	pub offchain_worker: OffchainWorkerConfig,
+	/// Enable authoring even when offline.
+	pub force_authoring: bool,
+	/// Disable GRANDPA when running in validator mode
+	pub disable_grandpa: bool,
+	/// Development key seed.
+	///
+	/// When running in development mode, the seed will be used to generate authority keys by the
+	/// keystore.
+	///
+	/// Should only be set when `node` is running development mode.
+	pub dev_key_seed: Option<String>,
+	/// Tracing targets
+	pub tracing_targets: Option<String>,
+	/// Tracing receiver
+	pub tracing_receiver: sc_tracing::TracingReceiver,
+	/// The size of the instances cache.
+	///
+	/// The default value is 8.
+	pub max_runtime_instances: usize,
+	/// Announce block automatically after they have been imported
+	pub announce_block: bool,
+	/// Data path root for the configured chain.
+	pub data_path: PathBuf,
+	/// Base path of the configuration. This is shared between chains.
+	pub base_path: BasePath,
+	/// Configuration of the output format that the informant uses.
+	pub informant_output_format: sc_informant::OutputFormat,
+	/// Maximum number of different runtime versions that can be cached.
+	pub runtime_cache_size: u8,
+}
+
+/// Type for tasks spawned by the executor.
+#[derive(PartialEq)]
+pub enum TaskType {
+	/// Regular non-blocking futures. Polling the task is expected to be a lightweight operation.
+	Async,
+	/// The task might perform a lot of expensive CPU operations and/or call `thread::sleep`.
+	Blocking,
+}
+
+/// Configuration of the client keystore.
+#[derive(Debug, Clone)]
+pub enum KeystoreConfig {
+	/// Keystore at a path on-disk. Recommended for native nodes.
+	Path {
+		/// The path of the keystore.
+		path: PathBuf,
+		/// Node keystore's password.
+		password: Option<SecretString>,
+	},
+	/// In-memory keystore. Recommended for in-browser nodes.
+	InMemory,
+}
+
+impl KeystoreConfig {
+	/// Returns the path for the keystore.
+	pub fn path(&self) -> Option<&Path> {
+		match self {
+			Self::Path { path, .. } => Some(path),
+			Self::InMemory => None,
+		}
+	}
+}
+/// Configuration of the database of the client.
+#[derive(Debug, Clone, Default)]
+pub struct OffchainWorkerConfig {
+	/// If this is allowed.
+	pub enabled: bool,
+	/// allow writes from the runtime to the offchain worker database.
+	pub indexing_enabled: bool,
+}
+
+/// Configuration of the Prometheus endpoint.
+#[derive(Debug, Clone)]
+pub struct PrometheusConfig {
+	/// Port to use.
+	pub port: SocketAddr,
+	/// A metrics registry to use. Useful for setting the metric prefix.
+	pub registry: Registry,
+}
+
+impl PrometheusConfig {
+	/// Create a new config using the default registry.
+	pub fn new_with_default_registry(port: SocketAddr, chain_id: String) -> Self {
+		let param = iter::once((String::from("chain"), chain_id)).collect();
+		Self {
+			port,
+			registry: Registry::new_custom(None, Some(param))
+				.expect("this can only fail if the prefix is empty"),
+		}
+	}
+}
+
+impl Configuration {
+	/// Returns a string displaying the node role.
+	pub fn display_role(&self) -> String {
+		self.role.to_string()
+	}
+
+	/// Returns the prometheus metrics registry, if available.
+	pub fn prometheus_registry(&self) -> Option<&Registry> {
+		self.prometheus_config.as_ref().map(|config| &config.registry)
+	}
+
+	/// Returns the network protocol id from the chain spec, or the default.
+	pub fn protocol_id(&self) -> ProtocolId {
+		let protocol_id_full = match self.chain_spec.protocol_id() {
+			Some(pid) => pid,
+			None => {
+				log::warn!(
+					"Using default protocol ID {:?} because none is configured in the \
+					chain specs",
+					crate::DEFAULT_PROTOCOL_ID
+				);
+				crate::DEFAULT_PROTOCOL_ID
+			},
+		};
+		ProtocolId::from(protocol_id_full)
+	}
+
+	/// Returns true if the genesis state writting will be skipped while initializing the genesis
+	/// block.
+	pub fn no_genesis(&self) -> bool {
+		matches!(self.network.sync_mode, SyncMode::LightState { .. } | SyncMode::Warp { .. })
+	}
+
+	/// Returns the database config for creating the backend.
+	pub fn db_config(&self) -> sc_client_db::DatabaseSettings {
+		sc_client_db::DatabaseSettings {
+			trie_cache_maximum_size: self.trie_cache_maximum_size,
+			state_pruning: self.state_pruning.clone(),
+			source: self.database.clone(),
+			blocks_pruning: self.blocks_pruning,
+		}
+	}
+}
+
+/// Available RPC methods.
+#[derive(Debug, Copy, Clone)]
+pub enum RpcMethods {
+	/// Expose every RPC method only when RPC is listening on `localhost`,
+	/// otherwise serve only safe RPC methods.
+	Auto,
+	/// Allow only a safe subset of RPC methods.
+	Safe,
+	/// Expose every RPC method (even potentially unsafe ones).
+	Unsafe,
+}
+
+impl Default for RpcMethods {
+	fn default() -> RpcMethods {
+		RpcMethods::Auto
+	}
+}
+
+#[static_init::dynamic(drop, lazy)]
+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)]
+pub struct BasePath {
+	path: PathBuf,
+}
+
+impl BasePath {
+	/// Create a `BasePath` instance using a temporary directory prefixed with "substrate" and use
+	/// it as base path.
+	///
+	/// Note: The temporary directory will be created automatically and deleted when the program
+	/// exits. Every call to this function will return the same path for the lifetime of the
+	/// program.
+	pub fn new_temp_dir() -> io::Result<BasePath> {
+		let mut temp = BASE_PATH_TEMP.write();
+
+		match &*temp {
+			Some(p) => Ok(Self::new(p.path())),
+			None => {
+				let temp_dir = tempfile::Builder::new().prefix("substrate").tempdir()?;
+				let path = PathBuf::from(temp_dir.path());
+
+				*temp = Some(temp_dir);
+				Ok(Self::new(path))
+			},
+		}
+	}
+
+	/// Create a `BasePath` instance based on an existing path on disk.
+	///
+	/// Note: this function will not ensure that the directory exist nor create the directory. It
+	/// will also not delete the directory when the instance is dropped.
+	pub fn new<P: Into<PathBuf>>(path: P) -> BasePath {
+		Self { path: path.into() }
+	}
+
+	/// Create a base path from values describing the project.
+	pub fn from_project(qualifier: &str, organization: &str, application: &str) -> BasePath {
+		BasePath::new(
+			directories::ProjectDirs::from(qualifier, organization, application)
+				.expect("app directories exist on all supported platforms; qed")
+				.data_local_dir(),
+		)
+	}
+
+	/// Retrieve the base path.
+	pub fn path(&self) -> &Path {
+		&self.path
+	}
+
+	/// Returns the configuration directory inside this base path.
+	///
+	/// The path looks like `$base_path/chains/$chain_id`
+	pub fn config_dir(&self, chain_id: &str) -> PathBuf {
+		self.path().join("chains").join(chain_id)
+	}
+}
+
+impl From<PathBuf> for BasePath {
+	fn from(path: PathBuf) -> Self {
+		BasePath::new(path)
+	}
+}
diff --git a/substrate/client/service/src/error.rs b/substrate/client/service/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c871342c771ebfb91ea90032b85dd745ba49dee6
--- /dev/null
+++ b/substrate/client/service/src/error.rs
@@ -0,0 +1,77 @@
+// 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/>.
+
+//! Errors that can occur during the service operation.
+
+use sc_keystore;
+use sp_blockchain;
+use sp_consensus;
+
+/// Service Result typedef.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Service errors.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+#[non_exhaustive]
+pub enum Error {
+	#[error(transparent)]
+	Client(#[from] sp_blockchain::Error),
+
+	#[error(transparent)]
+	Io(#[from] std::io::Error),
+
+	#[error(transparent)]
+	Consensus(#[from] sp_consensus::Error),
+
+	#[error(transparent)]
+	Network(#[from] sc_network::error::Error),
+
+	#[error(transparent)]
+	Keystore(#[from] sc_keystore::Error),
+
+	#[error(transparent)]
+	Telemetry(#[from] sc_telemetry::Error),
+
+	#[error("Best chain selection strategy (SelectChain) is not provided.")]
+	SelectChainRequired,
+
+	#[error("Tasks executor hasn't been provided.")]
+	TaskExecutorRequired,
+
+	#[error("Prometheus metrics error")]
+	Prometheus(#[from] prometheus_endpoint::PrometheusError),
+
+	#[error("Application")]
+	Application(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
+
+	#[error("Other: {0}")]
+	Other(String),
+}
+
+impl<'a> From<&'a str> for Error {
+	fn from(s: &'a str) -> Self {
+		Error::Other(s.into())
+	}
+}
+
+impl From<String> for Error {
+	fn from(s: String) -> Self {
+		Error::Other(s)
+	}
+}
diff --git a/substrate/client/service/src/lib.rs b/substrate/client/service/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0961967f9ca20a039e12b560b3ba6cb6cea24659
--- /dev/null
+++ b/substrate/client/service/src/lib.rs
@@ -0,0 +1,569 @@
+// 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/>.
+
+//! Substrate service. Starts a thread that spins up the network, client, and extrinsic pool.
+//! Manages communication between them.
+
+#![warn(missing_docs)]
+#![recursion_limit = "1024"]
+
+pub mod chain_ops;
+pub mod config;
+pub mod error;
+
+mod builder;
+#[cfg(feature = "test-helpers")]
+pub mod client;
+#[cfg(not(feature = "test-helpers"))]
+mod client;
+mod metrics;
+mod task_manager;
+
+use std::{collections::HashMap, net::SocketAddr};
+
+use codec::{Decode, Encode};
+use futures::{channel::mpsc, pin_mut, FutureExt, StreamExt};
+use jsonrpsee::{core::Error as JsonRpseeError, RpcModule};
+use log::{debug, error, warn};
+use sc_client_api::{blockchain::HeaderBackend, BlockBackend, BlockchainEvents, ProofProvider};
+use sc_network::{
+	config::MultiaddrWithPeerId, NetworkBlock, NetworkPeers, NetworkStateInfo, PeerId,
+};
+use sc_network_sync::SyncingService;
+use sc_utils::mpsc::TracingUnboundedReceiver;
+use sp_blockchain::HeaderMetadata;
+use sp_consensus::SyncOracle;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT},
+};
+
+pub use self::{
+	builder::{
+		build_network, new_client, new_db_backend, new_full_client, new_full_parts,
+		new_full_parts_with_genesis_builder, new_native_or_wasm_executor, new_wasm_executor,
+		spawn_tasks, BuildNetworkParams, KeystoreContainer, NetworkStarter, SpawnTasksParams,
+		TFullBackend, TFullCallExecutor, TFullClient,
+	},
+	client::{ClientConfig, LocalCallExecutor},
+	error::Error,
+};
+
+pub use sc_chain_spec::{
+	construct_genesis_block, resolve_state_version_from_wasm, BuildGenesisBlock,
+	GenesisBlockBuilder,
+};
+
+pub use config::{
+	BasePath, BlocksPruning, Configuration, DatabaseSource, PruningMode, Role, RpcMethods, TaskType,
+};
+pub use sc_chain_spec::{
+	ChainSpec, ChainType, Extension as ChainSpecExtension, GenericChainSpec, NoExtension,
+	Properties, RuntimeGenesis,
+};
+
+pub use sc_consensus::ImportQueue;
+pub use sc_executor::NativeExecutionDispatch;
+pub use sc_network_common::sync::warp::WarpSyncParams;
+#[doc(hidden)]
+pub use sc_network_transactions::config::{TransactionImport, TransactionImportFuture};
+pub use sc_rpc::{
+	RandomIntegerSubscriptionId, RandomStringSubscriptionId, RpcSubscriptionIdProvider,
+};
+pub use sc_tracing::TracingReceiver;
+pub use sc_transaction_pool::Options as TransactionPoolOptions;
+pub use sc_transaction_pool_api::{error::IntoPoolError, InPoolTransaction, TransactionPool};
+#[doc(hidden)]
+pub use std::{ops::Deref, result::Result, sync::Arc};
+pub use task_manager::{SpawnTaskHandle, Task, TaskManager, TaskRegistry, DEFAULT_GROUP_NAME};
+
+const DEFAULT_PROTOCOL_ID: &str = "sup";
+
+/// RPC handlers that can perform RPC queries.
+#[derive(Clone)]
+pub struct RpcHandlers(Arc<RpcModule<()>>);
+
+impl RpcHandlers {
+	/// Starts an RPC query.
+	///
+	/// The query is passed as a string and must be valid JSON-RPC request object.
+	///
+	/// Returns a response and a stream if the call successful, fails if the
+	/// query could not be decoded as a JSON-RPC request object.
+	///
+	/// If the request subscribes you to events, the `stream` can be used to
+	/// retrieve the events.
+	pub async fn rpc_query(
+		&self,
+		json_query: &str,
+	) -> Result<(String, mpsc::UnboundedReceiver<String>), JsonRpseeError> {
+		self.0
+			.raw_json_request(json_query)
+			.await
+			.map(|(method_res, recv)| (method_res.result, recv))
+	}
+
+	/// Provides access to the underlying `RpcModule`
+	pub fn handle(&self) -> Arc<RpcModule<()>> {
+		self.0.clone()
+	}
+}
+
+/// An incomplete set of chain components, but enough to run the chain ops subcommands.
+pub struct PartialComponents<Client, Backend, SelectChain, ImportQueue, TransactionPool, Other> {
+	/// A shared client instance.
+	pub client: Arc<Client>,
+	/// A shared backend instance.
+	pub backend: Arc<Backend>,
+	/// The chain task manager.
+	pub task_manager: TaskManager,
+	/// A keystore container instance..
+	pub keystore_container: KeystoreContainer,
+	/// A chain selection algorithm instance.
+	pub select_chain: SelectChain,
+	/// An import queue.
+	pub import_queue: ImportQueue,
+	/// A shared transaction pool.
+	pub transaction_pool: Arc<TransactionPool>,
+	/// Everything else that needs to be passed into the main build function.
+	pub other: Other,
+}
+
+/// Builds a future that continuously polls the network.
+async fn build_network_future<
+	B: BlockT,
+	C: BlockchainEvents<B>
+		+ HeaderBackend<B>
+		+ BlockBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ ProofProvider<B>
+		+ Send
+		+ Sync
+		+ 'static,
+	H: sc_network_common::ExHashT,
+>(
+	network: sc_network::NetworkWorker<B, H>,
+	client: Arc<C>,
+	sync_service: Arc<SyncingService<B>>,
+	announce_imported_blocks: bool,
+) {
+	let mut imported_blocks_stream = client.import_notification_stream().fuse();
+
+	// Stream of finalized blocks reported by the client.
+	let mut finality_notification_stream = client.finality_notification_stream().fuse();
+
+	let network_run = network.run().fuse();
+	pin_mut!(network_run);
+
+	loop {
+		futures::select! {
+			// List of blocks that the client has imported.
+			notification = imported_blocks_stream.next() => {
+				let notification = match notification {
+					Some(n) => n,
+					// If this stream is shut down, that means the client has shut down, and the
+					// most appropriate thing to do for the network future is to shut down too.
+					None => {
+						debug!("Block import stream has terminated, shutting down the network future.");
+						return
+					},
+				};
+
+				if announce_imported_blocks {
+					sync_service.announce_block(notification.hash, None);
+				}
+
+				if notification.is_new_best {
+					sync_service.new_best_block_imported(
+						notification.hash,
+						*notification.header.number(),
+					);
+				}
+			}
+
+			// List of blocks that the client has finalized.
+			notification = finality_notification_stream.select_next_some() => {
+				sync_service.on_block_finalized(notification.hash, notification.header);
+			}
+
+			// Drive the network. Shut down the network future if `NetworkWorker` has terminated.
+			_ = network_run => {
+				debug!("`NetworkWorker` has terminated, shutting down the network future.");
+				return
+			}
+		}
+	}
+}
+
+/// Builds a future that processes system RPC requests.
+pub async fn build_system_rpc_future<
+	B: BlockT,
+	C: BlockchainEvents<B>
+		+ HeaderBackend<B>
+		+ BlockBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ ProofProvider<B>
+		+ Send
+		+ Sync
+		+ 'static,
+	H: sc_network_common::ExHashT,
+>(
+	role: Role,
+	network_service: Arc<sc_network::NetworkService<B, H>>,
+	sync_service: Arc<SyncingService<B>>,
+	client: Arc<C>,
+	mut rpc_rx: TracingUnboundedReceiver<sc_rpc::system::Request<B>>,
+	should_have_peers: bool,
+) {
+	// Current best block at initialization, to report to the RPC layer.
+	let starting_block = client.info().best_number;
+
+	loop {
+		// Answer incoming RPC requests.
+		let Some(req) = rpc_rx.next().await else {
+			debug!("RPC requests stream has terminated, shutting down the system RPC future.");
+			return
+		};
+
+		match req {
+			sc_rpc::system::Request::Health(sender) => match sync_service.peers_info().await {
+				Ok(info) => {
+					let _ = sender.send(sc_rpc::system::Health {
+						peers: info.len(),
+						is_syncing: sync_service.is_major_syncing(),
+						should_have_peers,
+					});
+				},
+				Err(_) => log::error!("`SyncingEngine` shut down"),
+			},
+			sc_rpc::system::Request::LocalPeerId(sender) => {
+				let _ = sender.send(network_service.local_peer_id().to_base58());
+			},
+			sc_rpc::system::Request::LocalListenAddresses(sender) => {
+				let peer_id = (network_service.local_peer_id()).into();
+				let p2p_proto_suffix = sc_network::multiaddr::Protocol::P2p(peer_id);
+				let addresses = network_service
+					.listen_addresses()
+					.iter()
+					.map(|addr| addr.clone().with(p2p_proto_suffix.clone()).to_string())
+					.collect();
+				let _ = sender.send(addresses);
+			},
+			sc_rpc::system::Request::Peers(sender) => match sync_service.peers_info().await {
+				Ok(info) => {
+					let _ = sender.send(
+						info.into_iter()
+							.map(|(peer_id, p)| sc_rpc::system::PeerInfo {
+								peer_id: peer_id.to_base58(),
+								roles: format!("{:?}", p.roles),
+								best_hash: p.best_hash,
+								best_number: p.best_number,
+							})
+							.collect(),
+					);
+				},
+				Err(_) => log::error!("`SyncingEngine` shut down"),
+			},
+			sc_rpc::system::Request::NetworkState(sender) => {
+				let network_state = network_service.network_state().await;
+				if let Ok(network_state) = network_state {
+					if let Ok(network_state) = serde_json::to_value(network_state) {
+						let _ = sender.send(network_state);
+					}
+				} else {
+					break
+				}
+			},
+			sc_rpc::system::Request::NetworkAddReservedPeer(peer_addr, sender) => {
+				let result = match MultiaddrWithPeerId::try_from(peer_addr) {
+					Ok(peer) => network_service.add_reserved_peer(peer),
+					Err(err) => Err(err.to_string()),
+				};
+				let x = result.map_err(sc_rpc::system::error::Error::MalformattedPeerArg);
+				let _ = sender.send(x);
+			},
+			sc_rpc::system::Request::NetworkRemoveReservedPeer(peer_id, sender) => {
+				let _ = match peer_id.parse::<PeerId>() {
+					Ok(peer_id) => {
+						network_service.remove_reserved_peer(peer_id);
+						sender.send(Ok(()))
+					},
+					Err(e) => sender.send(Err(sc_rpc::system::error::Error::MalformattedPeerArg(
+						e.to_string(),
+					))),
+				};
+			},
+			sc_rpc::system::Request::NetworkReservedPeers(sender) => {
+				let reserved_peers = network_service.reserved_peers().await;
+				if let Ok(reserved_peers) = reserved_peers {
+					let reserved_peers =
+						reserved_peers.iter().map(|peer_id| peer_id.to_base58()).collect();
+					let _ = sender.send(reserved_peers);
+				} else {
+					break
+				}
+			},
+			sc_rpc::system::Request::NodeRoles(sender) => {
+				use sc_rpc::system::NodeRole;
+
+				let node_role = match role {
+					Role::Authority { .. } => NodeRole::Authority,
+					Role::Full => NodeRole::Full,
+				};
+
+				let _ = sender.send(vec![node_role]);
+			},
+			sc_rpc::system::Request::SyncState(sender) => {
+				use sc_rpc::system::SyncState;
+
+				match sync_service.best_seen_block().await {
+					Ok(best_seen_block) => {
+						let best_number = client.info().best_number;
+						let _ = sender.send(SyncState {
+							starting_block,
+							current_block: best_number,
+							highest_block: best_seen_block.unwrap_or(best_number),
+						});
+					},
+					Err(_) => log::error!("`SyncingEngine` shut down"),
+				}
+			},
+		}
+	}
+
+	debug!("`NetworkWorker` has terminated, shutting down the system RPC future.");
+}
+
+// Wrapper for HTTP and WS servers that makes sure they are properly shut down.
+mod waiting {
+	pub struct Server(pub Option<sc_rpc_server::Server>);
+
+	impl Drop for Server {
+		fn drop(&mut self) {
+			if let Some(server) = self.0.take() {
+				// This doesn't not wait for the server to be stopped but fires the signal.
+				let _ = server.stop();
+			}
+		}
+	}
+}
+
+/// Starts RPC servers.
+fn start_rpc_servers<R>(
+	config: &Configuration,
+	gen_rpc_module: R,
+	rpc_id_provider: Option<Box<dyn RpcSubscriptionIdProvider>>,
+) -> Result<Box<dyn std::any::Any + Send + Sync>, error::Error>
+where
+	R: Fn(sc_rpc::DenyUnsafe) -> Result<RpcModule<()>, Error>,
+{
+	fn deny_unsafe(addr: SocketAddr, methods: &RpcMethods) -> sc_rpc::DenyUnsafe {
+		let is_exposed_addr = !addr.ip().is_loopback();
+		match (is_exposed_addr, methods) {
+			| (_, RpcMethods::Unsafe) | (false, RpcMethods::Auto) => sc_rpc::DenyUnsafe::No,
+			_ => sc_rpc::DenyUnsafe::Yes,
+		}
+	}
+
+	// if binding the specified port failed then a random port is assigned by the OS.
+	let backup_port = |mut addr: SocketAddr| {
+		addr.set_port(0);
+		addr
+	};
+
+	let addr = config.rpc_addr.unwrap_or_else(|| ([127, 0, 0, 1], config.rpc_port).into());
+	let backup_addr = backup_port(addr);
+	let metrics = sc_rpc_server::RpcMetrics::new(config.prometheus_registry())?;
+
+	let server_config = sc_rpc_server::Config {
+		addrs: [addr, backup_addr],
+		max_connections: config.rpc_max_connections,
+		max_payload_in_mb: config.rpc_max_request_size,
+		max_payload_out_mb: config.rpc_max_response_size,
+		max_subs_per_conn: config.rpc_max_subs_per_conn,
+		rpc_api: gen_rpc_module(deny_unsafe(addr, &config.rpc_methods))?,
+		metrics,
+		id_provider: rpc_id_provider,
+		cors: config.rpc_cors.as_ref(),
+		tokio_handle: config.tokio_handle.clone(),
+	};
+
+	// TODO: https://github.com/paritytech/substrate/issues/13773
+	//
+	// `block_in_place` is a hack to allow callers to call `block_on` prior to
+	// calling `start_rpc_servers`.
+	match tokio::task::block_in_place(|| {
+		config.tokio_handle.block_on(sc_rpc_server::start_server(server_config))
+	}) {
+		Ok(server) => Ok(Box::new(waiting::Server(Some(server)))),
+		Err(e) => Err(Error::Application(e)),
+	}
+}
+
+/// Transaction pool adapter.
+pub struct TransactionPoolAdapter<C, P> {
+	pool: Arc<P>,
+	client: Arc<C>,
+}
+
+impl<C, P> TransactionPoolAdapter<C, P> {
+	/// Constructs a new instance of [`TransactionPoolAdapter`].
+	pub fn new(pool: Arc<P>, client: Arc<C>) -> Self {
+		Self { pool, client }
+	}
+}
+
+/// Get transactions for propagation.
+///
+/// Function extracted to simplify the test and prevent creating `ServiceFactory`.
+fn transactions_to_propagate<Pool, B, H, E>(pool: &Pool) -> Vec<(H, B::Extrinsic)>
+where
+	Pool: TransactionPool<Block = B, Hash = H, Error = E>,
+	B: BlockT,
+	H: std::hash::Hash + Eq + sp_runtime::traits::Member + sp_runtime::traits::MaybeSerialize,
+	E: IntoPoolError + From<sc_transaction_pool_api::error::Error>,
+{
+	pool.ready()
+		.filter(|t| t.is_propagable())
+		.map(|t| {
+			let hash = t.hash().clone();
+			let ex: B::Extrinsic = t.data().clone();
+			(hash, ex)
+		})
+		.collect()
+}
+
+impl<B, H, C, Pool, E> sc_network_transactions::config::TransactionPool<H, B>
+	for TransactionPoolAdapter<C, Pool>
+where
+	C: HeaderBackend<B>
+		+ BlockBackend<B>
+		+ HeaderMetadata<B, Error = sp_blockchain::Error>
+		+ ProofProvider<B>
+		+ Send
+		+ Sync
+		+ 'static,
+	Pool: 'static + TransactionPool<Block = B, Hash = H, Error = E>,
+	B: BlockT,
+	H: std::hash::Hash + Eq + sp_runtime::traits::Member + sp_runtime::traits::MaybeSerialize,
+	E: 'static + IntoPoolError + From<sc_transaction_pool_api::error::Error>,
+{
+	fn transactions(&self) -> Vec<(H, B::Extrinsic)> {
+		transactions_to_propagate(&*self.pool)
+	}
+
+	fn hash_of(&self, transaction: &B::Extrinsic) -> H {
+		self.pool.hash_of(transaction)
+	}
+
+	fn import(&self, transaction: B::Extrinsic) -> TransactionImportFuture {
+		let encoded = transaction.encode();
+		let uxt = match Decode::decode(&mut &encoded[..]) {
+			Ok(uxt) => uxt,
+			Err(e) => {
+				debug!("Transaction invalid: {:?}", e);
+				return Box::pin(futures::future::ready(TransactionImport::Bad))
+			},
+		};
+
+		let best_block_id = BlockId::hash(self.client.info().best_hash);
+
+		let import_future = self.pool.submit_one(
+			&best_block_id,
+			sc_transaction_pool_api::TransactionSource::External,
+			uxt,
+		);
+		Box::pin(async move {
+			match import_future.await {
+				Ok(_) => TransactionImport::NewGood,
+				Err(e) => match e.into_pool_error() {
+					Ok(sc_transaction_pool_api::error::Error::AlreadyImported(_)) =>
+						TransactionImport::KnownGood,
+					Ok(e) => {
+						debug!("Error adding transaction to the pool: {:?}", e);
+						TransactionImport::Bad
+					},
+					Err(e) => {
+						debug!("Error converting pool error: {}", e);
+						// it is not bad at least, just some internal node logic error, so peer is
+						// innocent.
+						TransactionImport::KnownGood
+					},
+				},
+			}
+		})
+	}
+
+	fn on_broadcasted(&self, propagations: HashMap<H, Vec<String>>) {
+		self.pool.on_broadcasted(propagations)
+	}
+
+	fn transaction(&self, hash: &H) -> Option<B::Extrinsic> {
+		self.pool.ready_transaction(hash).and_then(
+			// Only propagable transactions should be resolved for network service.
+			|tx| if tx.is_propagable() { Some(tx.data().clone()) } else { None },
+		)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use futures::executor::block_on;
+	use sc_transaction_pool::BasicPool;
+	use sp_consensus::SelectChain;
+	use substrate_test_runtime_client::{
+		prelude::*,
+		runtime::{ExtrinsicBuilder, Transfer, TransferData},
+	};
+
+	#[test]
+	fn should_not_propagate_transactions_that_are_marked_as_such() {
+		// given
+		let (client, longest_chain) = TestClientBuilder::new().build_with_longest_chain();
+		let client = Arc::new(client);
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let pool =
+			BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
+		let source = sp_runtime::transaction_validity::TransactionSource::External;
+		let best = block_on(longest_chain.best_chain()).unwrap();
+		let transaction = Transfer {
+			amount: 5,
+			nonce: 0,
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Bob.into(),
+		}
+		.into_unchecked_extrinsic();
+		block_on(pool.submit_one(&BlockId::hash(best.hash()), source, transaction.clone()))
+			.unwrap();
+		block_on(pool.submit_one(
+			&BlockId::hash(best.hash()),
+			source,
+			ExtrinsicBuilder::new_call_do_not_propagate().nonce(1).build(),
+		))
+		.unwrap();
+		assert_eq!(pool.status().ready, 2);
+
+		// when
+		let transactions = transactions_to_propagate(&*pool);
+
+		// then
+		assert_eq!(transactions.len(), 1);
+		assert!(TransferData::try_from(&transactions[0].1).is_ok());
+	}
+}
diff --git a/substrate/client/service/src/metrics.rs b/substrate/client/service/src/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ece5758be771881bbac5940375ec6d7b5a8180de
--- /dev/null
+++ b/substrate/client/service/src/metrics.rs
@@ -0,0 +1,298 @@
+// 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 std::time::SystemTime;
+
+use crate::config::Configuration;
+use futures_timer::Delay;
+use prometheus_endpoint::{register, Gauge, GaugeVec, Opts, PrometheusError, Registry, U64};
+use sc_client_api::{ClientInfo, UsageProvider};
+use sc_network::{config::Role, NetworkStatus, NetworkStatusProvider};
+use sc_network_common::sync::{SyncStatus, SyncStatusProvider};
+use sc_telemetry::{telemetry, TelemetryHandle, SUBSTRATE_INFO};
+use sc_transaction_pool_api::{MaintainedTransactionPool, PoolStatus};
+use sc_utils::metrics::register_globals;
+use sp_api::ProvideRuntimeApi;
+use sp_runtime::traits::{Block, NumberFor, SaturatedConversion, UniqueSaturatedInto};
+use std::{
+	sync::Arc,
+	time::{Duration, Instant},
+};
+
+struct PrometheusMetrics {
+	// generic info
+	block_height: GaugeVec<U64>,
+	number_leaves: Gauge<U64>,
+	ready_transactions_number: Gauge<U64>,
+
+	// I/O
+	database_cache: Gauge<U64>,
+	state_cache: Gauge<U64>,
+}
+
+impl PrometheusMetrics {
+	fn setup(
+		registry: &Registry,
+		name: &str,
+		version: &str,
+		roles: u64,
+	) -> Result<Self, PrometheusError> {
+		register(
+			Gauge::<U64>::with_opts(
+				Opts::new(
+					"substrate_build_info",
+					"A metric with a constant '1' value labeled by name, version",
+				)
+				.const_label("name", name)
+				.const_label("version", version),
+			)?,
+			registry,
+		)?
+		.set(1);
+
+		register(
+			Gauge::<U64>::new("substrate_node_roles", "The roles the node is running as")?,
+			registry,
+		)?
+		.set(roles);
+
+		register_globals(registry)?;
+
+		let start_time_since_epoch =
+			SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap_or_default();
+		register(
+			Gauge::<U64>::new(
+				"substrate_process_start_time_seconds",
+				"Number of seconds between the UNIX epoch and the moment the process started",
+			)?,
+			registry,
+		)?
+		.set(start_time_since_epoch.as_secs());
+
+		Ok(Self {
+			// generic internals
+			block_height: register(
+				GaugeVec::new(
+					Opts::new("substrate_block_height", "Block height info of the chain"),
+					&["status"],
+				)?,
+				registry,
+			)?,
+
+			number_leaves: register(
+				Gauge::new("substrate_number_leaves", "Number of known chain leaves (aka forks)")?,
+				registry,
+			)?,
+
+			ready_transactions_number: register(
+				Gauge::new(
+					"substrate_ready_transactions_number",
+					"Number of transactions in the ready queue",
+				)?,
+				registry,
+			)?,
+
+			// I/ O
+			database_cache: register(
+				Gauge::new("substrate_database_cache_bytes", "RocksDB cache size in bytes")?,
+				registry,
+			)?,
+			state_cache: register(
+				Gauge::new("substrate_state_cache_bytes", "State cache size in bytes")?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// A `MetricsService` periodically sends general client and
+/// network state to the telemetry as well as (optionally)
+/// a Prometheus endpoint.
+pub struct MetricsService {
+	metrics: Option<PrometheusMetrics>,
+	last_update: Instant,
+	last_total_bytes_inbound: u64,
+	last_total_bytes_outbound: u64,
+	telemetry: Option<TelemetryHandle>,
+}
+
+impl MetricsService {
+	/// Creates a `MetricsService` that only sends information
+	/// to the telemetry.
+	pub fn new(telemetry: Option<TelemetryHandle>) -> Self {
+		MetricsService {
+			metrics: None,
+			last_total_bytes_inbound: 0,
+			last_total_bytes_outbound: 0,
+			last_update: Instant::now(),
+			telemetry,
+		}
+	}
+
+	/// Creates a `MetricsService` that sends metrics
+	/// to prometheus alongside the telemetry.
+	pub fn with_prometheus(
+		telemetry: Option<TelemetryHandle>,
+		registry: &Registry,
+		config: &Configuration,
+	) -> Result<Self, PrometheusError> {
+		let role_bits = match config.role {
+			Role::Full => 1u64,
+			// 2u64 used to represent light client role
+			Role::Authority { .. } => 4u64,
+		};
+
+		PrometheusMetrics::setup(
+			registry,
+			&config.network.node_name,
+			&config.impl_version,
+			role_bits,
+		)
+		.map(|p| MetricsService {
+			metrics: Some(p),
+			last_total_bytes_inbound: 0,
+			last_total_bytes_outbound: 0,
+			last_update: Instant::now(),
+			telemetry,
+		})
+	}
+
+	/// Returns a never-ending `Future` that performs the
+	/// metric and telemetry updates with information from
+	/// the given sources.
+	pub async fn run<TBl, TExPool, TCl, TNet, TSync>(
+		mut self,
+		client: Arc<TCl>,
+		transactions: Arc<TExPool>,
+		network: TNet,
+		syncing: TSync,
+	) where
+		TBl: Block,
+		TCl: ProvideRuntimeApi<TBl> + UsageProvider<TBl>,
+		TExPool: MaintainedTransactionPool<Block = TBl, Hash = <TBl as Block>::Hash>,
+		TNet: NetworkStatusProvider,
+		TSync: SyncStatusProvider<TBl>,
+	{
+		let mut timer = Delay::new(Duration::from_secs(0));
+		let timer_interval = Duration::from_secs(5);
+
+		loop {
+			// Wait for the next tick of the timer.
+			(&mut timer).await;
+
+			// Try to get the latest network information.
+			let net_status = network.status().await.ok();
+
+			// Try to get the latest syncing information.
+			let sync_status = syncing.status().await.ok();
+
+			// Update / Send the metrics.
+			self.update(&client.usage_info(), &transactions.status(), net_status, sync_status);
+
+			// Schedule next tick.
+			timer.reset(timer_interval);
+		}
+	}
+
+	fn update<T: Block>(
+		&mut self,
+		info: &ClientInfo<T>,
+		txpool_status: &PoolStatus,
+		net_status: Option<NetworkStatus>,
+		sync_status: Option<SyncStatus<T>>,
+	) {
+		let now = Instant::now();
+		let elapsed = (now - self.last_update).as_secs();
+		self.last_update = now;
+
+		let best_number = info.chain.best_number.saturated_into::<u64>();
+		let best_hash = info.chain.best_hash;
+		let finalized_number: u64 = info.chain.finalized_number.saturated_into::<u64>();
+
+		// Update/send metrics that are always available.
+		telemetry!(
+			self.telemetry;
+			SUBSTRATE_INFO;
+			"system.interval";
+			"height" => best_number,
+			"best" => ?best_hash,
+			"txcount" => txpool_status.ready,
+			"finalized_height" => finalized_number,
+			"finalized_hash" => ?info.chain.finalized_hash,
+			"used_state_cache_size" => info.usage.as_ref()
+				.map(|usage| usage.memory.state_cache.as_bytes())
+				.unwrap_or(0),
+		);
+
+		if let Some(metrics) = self.metrics.as_ref() {
+			metrics.block_height.with_label_values(&["finalized"]).set(finalized_number);
+			metrics.block_height.with_label_values(&["best"]).set(best_number);
+
+			if let Ok(leaves) = u64::try_from(info.chain.number_leaves) {
+				metrics.number_leaves.set(leaves);
+			}
+
+			metrics.ready_transactions_number.set(txpool_status.ready as u64);
+
+			if let Some(info) = info.usage.as_ref() {
+				metrics.database_cache.set(info.memory.database_cache.as_bytes() as u64);
+				metrics.state_cache.set(info.memory.state_cache.as_bytes() as u64);
+			}
+		}
+
+		// Update/send network status information, if any.
+		if let Some(net_status) = net_status {
+			let num_peers = net_status.num_connected_peers;
+			let total_bytes_inbound = net_status.total_bytes_inbound;
+			let total_bytes_outbound = net_status.total_bytes_outbound;
+
+			let diff_bytes_inbound = total_bytes_inbound - self.last_total_bytes_inbound;
+			let diff_bytes_outbound = total_bytes_outbound - self.last_total_bytes_outbound;
+			let (avg_bytes_per_sec_inbound, avg_bytes_per_sec_outbound) = if elapsed > 0 {
+				self.last_total_bytes_inbound = total_bytes_inbound;
+				self.last_total_bytes_outbound = total_bytes_outbound;
+				(diff_bytes_inbound / elapsed, diff_bytes_outbound / elapsed)
+			} else {
+				(diff_bytes_inbound, diff_bytes_outbound)
+			};
+
+			telemetry!(
+				self.telemetry;
+				SUBSTRATE_INFO;
+				"system.interval";
+				"peers" => num_peers,
+				"bandwidth_download" => avg_bytes_per_sec_inbound,
+				"bandwidth_upload" => avg_bytes_per_sec_outbound,
+			);
+		}
+
+		if let Some(sync_status) = sync_status {
+			if let Some(metrics) = self.metrics.as_ref() {
+				let best_seen_block: Option<u64> =
+					sync_status.best_seen_block.map(|num: NumberFor<T>| {
+						UniqueSaturatedInto::<u64>::unique_saturated_into(num)
+					});
+
+				metrics
+					.block_height
+					.with_label_values(&["sync_target"])
+					.set(best_seen_block.unwrap_or(best_number));
+			}
+		}
+	}
+}
diff --git a/substrate/client/service/src/task_manager/mod.rs b/substrate/client/service/src/task_manager/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..afccee9033e36f14e29d8a0c4a81f48ccdf0b4d5
--- /dev/null
+++ b/substrate/client/service/src/task_manager/mod.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/>.
+
+//! Substrate service tasks management module.
+
+use crate::{config::TaskType, Error};
+use exit_future::Signal;
+use futures::{
+	future::{pending, select, try_join_all, BoxFuture, Either},
+	Future, FutureExt, StreamExt,
+};
+use parking_lot::Mutex;
+use prometheus_endpoint::{
+	exponential_buckets, register, CounterVec, HistogramOpts, HistogramVec, Opts, PrometheusError,
+	Registry, U64,
+};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use std::{
+	collections::{hash_map::Entry, HashMap},
+	panic,
+	pin::Pin,
+	result::Result,
+	sync::Arc,
+};
+use tokio::runtime::Handle;
+use tracing_futures::Instrument;
+
+mod prometheus_future;
+#[cfg(test)]
+mod tests;
+
+/// Default task group name.
+pub const DEFAULT_GROUP_NAME: &str = "default";
+
+/// The name of a group a task belongs to.
+///
+/// This name is passed belong-side the task name to the prometheus metrics and can be used
+/// to group tasks.
+pub enum GroupName {
+	/// Sets the group name to `default`.
+	Default,
+	/// Use the specifically given name as group name.
+	Specific(&'static str),
+}
+
+impl From<Option<&'static str>> for GroupName {
+	fn from(name: Option<&'static str>) -> Self {
+		match name {
+			Some(name) => Self::Specific(name),
+			None => Self::Default,
+		}
+	}
+}
+
+impl From<&'static str> for GroupName {
+	fn from(name: &'static str) -> Self {
+		Self::Specific(name)
+	}
+}
+
+/// An handle for spawning tasks in the service.
+#[derive(Clone)]
+pub struct SpawnTaskHandle {
+	on_exit: exit_future::Exit,
+	tokio_handle: Handle,
+	metrics: Option<Metrics>,
+	task_registry: TaskRegistry,
+}
+
+impl SpawnTaskHandle {
+	/// Spawns the given task with the given name and a group name.
+	/// If group is not specified `DEFAULT_GROUP_NAME` will be used.
+	///
+	/// Note that the `name` is a `&'static str`. The reason for this choice is that
+	/// statistics about this task are getting reported to the Prometheus endpoint (if enabled), and
+	/// that therefore the set of possible task names must be bounded.
+	///
+	/// In other words, it would be a bad idea for someone to do for example
+	/// `spawn(format!("{:?}", some_public_key))`.
+	pub fn spawn(
+		&self,
+		name: &'static str,
+		group: impl Into<GroupName>,
+		task: impl Future<Output = ()> + Send + 'static,
+	) {
+		self.spawn_inner(name, group, task, TaskType::Async)
+	}
+
+	/// Spawns the blocking task with the given name. See also `spawn`.
+	pub fn spawn_blocking(
+		&self,
+		name: &'static str,
+		group: impl Into<GroupName>,
+		task: impl Future<Output = ()> + Send + 'static,
+	) {
+		self.spawn_inner(name, group, task, TaskType::Blocking)
+	}
+
+	/// Helper function that implements the spawning logic. See `spawn` and `spawn_blocking`.
+	fn spawn_inner(
+		&self,
+		name: &'static str,
+		group: impl Into<GroupName>,
+		task: impl Future<Output = ()> + Send + 'static,
+		task_type: TaskType,
+	) {
+		let on_exit = self.on_exit.clone();
+		let metrics = self.metrics.clone();
+		let registry = self.task_registry.clone();
+
+		let group = match group.into() {
+			GroupName::Specific(var) => var,
+			// If no group is specified use default.
+			GroupName::Default => DEFAULT_GROUP_NAME,
+		};
+
+		let task_type_label = match task_type {
+			TaskType::Blocking => "blocking",
+			TaskType::Async => "async",
+		};
+
+		// Note that we increase the started counter here and not within the future. This way,
+		// we could properly visualize on Prometheus situations where the spawning doesn't work.
+		if let Some(metrics) = &self.metrics {
+			metrics.tasks_spawned.with_label_values(&[name, group, task_type_label]).inc();
+			// We do a dummy increase in order for the task to show up in metrics.
+			metrics
+				.tasks_ended
+				.with_label_values(&[name, "finished", group, task_type_label])
+				.inc_by(0);
+		}
+
+		let future = async move {
+			// Register the task and keep the "token" alive until the task is ended. Then this
+			// "token" will unregister this task.
+			let _registry_token = registry.register_task(name, group);
+
+			if let Some(metrics) = metrics {
+				// Add some wrappers around `task`.
+				let task = {
+					let poll_duration =
+						metrics.poll_duration.with_label_values(&[name, group, task_type_label]);
+					let poll_start =
+						metrics.poll_start.with_label_values(&[name, group, task_type_label]);
+					let inner =
+						prometheus_future::with_poll_durations(poll_duration, poll_start, task);
+					// The logic of `AssertUnwindSafe` here is ok considering that we throw
+					// away the `Future` after it has panicked.
+					panic::AssertUnwindSafe(inner).catch_unwind()
+				};
+				futures::pin_mut!(task);
+
+				match select(on_exit, task).await {
+					Either::Right((Err(payload), _)) => {
+						metrics
+							.tasks_ended
+							.with_label_values(&[name, "panic", group, task_type_label])
+							.inc();
+						panic::resume_unwind(payload)
+					},
+					Either::Right((Ok(()), _)) => {
+						metrics
+							.tasks_ended
+							.with_label_values(&[name, "finished", group, task_type_label])
+							.inc();
+					},
+					Either::Left(((), _)) => {
+						// The `on_exit` has triggered.
+						metrics
+							.tasks_ended
+							.with_label_values(&[name, "interrupted", group, task_type_label])
+							.inc();
+					},
+				}
+			} else {
+				futures::pin_mut!(task);
+				let _ = select(on_exit, task).await;
+			}
+		}
+		.in_current_span();
+
+		match task_type {
+			TaskType::Async => {
+				self.tokio_handle.spawn(future);
+			},
+			TaskType::Blocking => {
+				let handle = self.tokio_handle.clone();
+				self.tokio_handle.spawn_blocking(move || {
+					handle.block_on(future);
+				});
+			},
+		}
+	}
+}
+
+impl sp_core::traits::SpawnNamed for SpawnTaskHandle {
+	fn spawn_blocking(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: BoxFuture<'static, ()>,
+	) {
+		self.spawn_inner(name, group, future, TaskType::Blocking)
+	}
+
+	fn spawn(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: BoxFuture<'static, ()>,
+	) {
+		self.spawn_inner(name, group, future, TaskType::Async)
+	}
+}
+
+/// A wrapper over `SpawnTaskHandle` that will notify a receiver whenever any
+/// task spawned through it fails. The service should be on the receiver side
+/// and will shut itself down whenever it receives any message, i.e. an
+/// essential task has failed.
+#[derive(Clone)]
+pub struct SpawnEssentialTaskHandle {
+	essential_failed_tx: TracingUnboundedSender<()>,
+	inner: SpawnTaskHandle,
+}
+
+impl SpawnEssentialTaskHandle {
+	/// Creates a new `SpawnEssentialTaskHandle`.
+	pub fn new(
+		essential_failed_tx: TracingUnboundedSender<()>,
+		spawn_task_handle: SpawnTaskHandle,
+	) -> SpawnEssentialTaskHandle {
+		SpawnEssentialTaskHandle { essential_failed_tx, inner: spawn_task_handle }
+	}
+
+	/// Spawns the given task with the given name.
+	///
+	/// See also [`SpawnTaskHandle::spawn`].
+	pub fn spawn(
+		&self,
+		name: &'static str,
+		group: impl Into<GroupName>,
+		task: impl Future<Output = ()> + Send + 'static,
+	) {
+		self.spawn_inner(name, group, task, TaskType::Async)
+	}
+
+	/// Spawns the blocking task with the given name.
+	///
+	/// See also [`SpawnTaskHandle::spawn_blocking`].
+	pub fn spawn_blocking(
+		&self,
+		name: &'static str,
+		group: impl Into<GroupName>,
+		task: impl Future<Output = ()> + Send + 'static,
+	) {
+		self.spawn_inner(name, group, task, TaskType::Blocking)
+	}
+
+	fn spawn_inner(
+		&self,
+		name: &'static str,
+		group: impl Into<GroupName>,
+		task: impl Future<Output = ()> + Send + 'static,
+		task_type: TaskType,
+	) {
+		let essential_failed = self.essential_failed_tx.clone();
+		let essential_task = std::panic::AssertUnwindSafe(task).catch_unwind().map(move |_| {
+			log::error!("Essential task `{}` failed. Shutting down service.", name);
+			let _ = essential_failed.close();
+		});
+
+		let _ = self.inner.spawn_inner(name, group, essential_task, task_type);
+	}
+}
+
+impl sp_core::traits::SpawnEssentialNamed for SpawnEssentialTaskHandle {
+	fn spawn_essential_blocking(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: BoxFuture<'static, ()>,
+	) {
+		self.spawn_blocking(name, group, future);
+	}
+
+	fn spawn_essential(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: BoxFuture<'static, ()>,
+	) {
+		self.spawn(name, group, future);
+	}
+}
+
+/// Helper struct to manage background/async tasks in Service.
+pub struct TaskManager {
+	/// A future that resolves when the service has exited, this is useful to
+	/// make sure any internally spawned futures stop when the service does.
+	on_exit: exit_future::Exit,
+	/// A signal that makes the exit future above resolve, fired on drop.
+	_signal: Signal,
+	/// Tokio runtime handle that is used to spawn futures.
+	tokio_handle: Handle,
+	/// Prometheus metric where to report the polling times.
+	metrics: Option<Metrics>,
+	/// Send a signal when a spawned essential task has concluded. The next time
+	/// the service future is polled it should complete with an error.
+	essential_failed_tx: TracingUnboundedSender<()>,
+	/// A receiver for spawned essential-tasks concluding.
+	essential_failed_rx: TracingUnboundedReceiver<()>,
+	/// Things to keep alive until the task manager is dropped.
+	keep_alive: Box<dyn std::any::Any + Send>,
+	/// A list of other `TaskManager`'s to terminate and gracefully shutdown when the parent
+	/// terminates and gracefully shutdown. Also ends the parent `future()` if a child's essential
+	/// task fails.
+	children: Vec<TaskManager>,
+	/// The registry of all running tasks.
+	task_registry: TaskRegistry,
+}
+
+impl TaskManager {
+	/// If a Prometheus registry is passed, it will be used to report statistics about the
+	/// service tasks.
+	pub fn new(
+		tokio_handle: Handle,
+		prometheus_registry: Option<&Registry>,
+	) -> Result<Self, PrometheusError> {
+		let (signal, on_exit) = exit_future::signal();
+
+		// A side-channel for essential tasks to communicate shutdown.
+		let (essential_failed_tx, essential_failed_rx) =
+			tracing_unbounded("mpsc_essential_tasks", 100);
+
+		let metrics = prometheus_registry.map(Metrics::register).transpose()?;
+
+		Ok(Self {
+			on_exit,
+			_signal: signal,
+			tokio_handle,
+			metrics,
+			essential_failed_tx,
+			essential_failed_rx,
+			keep_alive: Box::new(()),
+			children: Vec::new(),
+			task_registry: Default::default(),
+		})
+	}
+
+	/// Get a handle for spawning tasks.
+	pub fn spawn_handle(&self) -> SpawnTaskHandle {
+		SpawnTaskHandle {
+			on_exit: self.on_exit.clone(),
+			tokio_handle: self.tokio_handle.clone(),
+			metrics: self.metrics.clone(),
+			task_registry: self.task_registry.clone(),
+		}
+	}
+
+	/// Get a handle for spawning essential tasks.
+	pub fn spawn_essential_handle(&self) -> SpawnEssentialTaskHandle {
+		SpawnEssentialTaskHandle::new(self.essential_failed_tx.clone(), self.spawn_handle())
+	}
+
+	/// Return a future that will end with success if the signal to terminate was sent
+	/// (`self.terminate()`) or with an error if an essential task fails.
+	///
+	/// # Warning
+	///
+	/// This function will not wait until the end of the remaining task.
+	pub fn future<'a>(
+		&'a mut self,
+	) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>> {
+		Box::pin(async move {
+			let mut t1 = self.essential_failed_rx.next().fuse();
+			let mut t2 = self.on_exit.clone().fuse();
+			let mut t3 = try_join_all(
+				self.children
+					.iter_mut()
+					.map(|x| x.future())
+					// Never end this future if there is no error because if there is no children,
+					// it must not stop
+					.chain(std::iter::once(pending().boxed())),
+			)
+			.fuse();
+
+			futures::select! {
+				_ = t1 => Err(Error::Other("Essential task failed.".into())),
+				_ = t2 => Ok(()),
+				res = t3 => Err(res.map(|_| ()).expect_err("this future never ends; qed")),
+			}
+		})
+	}
+
+	/// Set what the task manager should keep alive, can be called multiple times.
+	pub fn keep_alive<T: 'static + Send>(&mut self, to_keep_alive: T) {
+		// allows this fn to safely called multiple times.
+		use std::mem;
+		let old = mem::replace(&mut self.keep_alive, Box::new(()));
+		self.keep_alive = Box::new((to_keep_alive, old));
+	}
+
+	/// Register another TaskManager to terminate and gracefully shutdown when the parent
+	/// terminates and gracefully shutdown. Also ends the parent `future()` if a child's essential
+	/// task fails. (But don't end the parent if a child's normal task fails.)
+	pub fn add_child(&mut self, child: TaskManager) {
+		self.children.push(child);
+	}
+
+	/// Consume `self` and return the [`TaskRegistry`].
+	///
+	/// This [`TaskRegistry`] can be used to check for still running tasks after this task manager
+	/// was dropped.
+	pub fn into_task_registry(self) -> TaskRegistry {
+		self.task_registry
+	}
+}
+
+#[derive(Clone)]
+struct Metrics {
+	// This list is ordered alphabetically
+	poll_duration: HistogramVec,
+	poll_start: CounterVec<U64>,
+	tasks_spawned: CounterVec<U64>,
+	tasks_ended: CounterVec<U64>,
+}
+
+impl Metrics {
+	fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			poll_duration: register(HistogramVec::new(
+				HistogramOpts {
+					common_opts: Opts::new(
+						"substrate_tasks_polling_duration",
+						"Duration in seconds of each invocation of Future::poll"
+					),
+					buckets: exponential_buckets(0.001, 4.0, 9)
+						.expect("function parameters are constant and always valid; qed"),
+				},
+				&["task_name", "task_group", "kind"]
+			)?, registry)?,
+			poll_start: register(CounterVec::new(
+				Opts::new(
+					"substrate_tasks_polling_started_total",
+					"Total number of times we started invoking Future::poll"
+				),
+				&["task_name", "task_group", "kind"]
+			)?, registry)?,
+			tasks_spawned: register(CounterVec::new(
+				Opts::new(
+					"substrate_tasks_spawned_total",
+					"Total number of tasks that have been spawned on the Service"
+				),
+				&["task_name", "task_group", "kind"]
+			)?, registry)?,
+			tasks_ended: register(CounterVec::new(
+				Opts::new(
+					"substrate_tasks_ended_total",
+					"Total number of tasks for which Future::poll has returned Ready(()) or panicked"
+				),
+				&["task_name", "reason", "task_group", "kind"]
+			)?, registry)?,
+		})
+	}
+}
+
+/// Ensures that a [`Task`] is unregistered when this object is dropped.
+struct UnregisterOnDrop {
+	task: Task,
+	registry: TaskRegistry,
+}
+
+impl Drop for UnregisterOnDrop {
+	fn drop(&mut self) {
+		let mut tasks = self.registry.tasks.lock();
+
+		if let Entry::Occupied(mut entry) = (*tasks).entry(self.task.clone()) {
+			*entry.get_mut() -= 1;
+
+			if *entry.get() == 0 {
+				entry.remove();
+			}
+		}
+	}
+}
+
+/// Represents a running async task in the [`TaskManager`].
+///
+/// As a task is identified by a name and a group, it is totally valid that there exists multiple
+/// tasks with the same name and group.
+#[derive(Clone, Hash, Eq, PartialEq)]
+pub struct Task {
+	/// The name of the task.
+	pub name: &'static str,
+	/// The group this task is associated to.
+	pub group: &'static str,
+}
+
+impl Task {
+	/// Returns if the `group` is the [`DEFAULT_GROUP_NAME`].
+	pub fn is_default_group(&self) -> bool {
+		self.group == DEFAULT_GROUP_NAME
+	}
+}
+
+/// Keeps track of all running [`Task`]s in [`TaskManager`].
+#[derive(Clone, Default)]
+pub struct TaskRegistry {
+	tasks: Arc<Mutex<HashMap<Task, usize>>>,
+}
+
+impl TaskRegistry {
+	/// Register a task with the given `name` and `group`.
+	///
+	/// Returns [`UnregisterOnDrop`] that ensures that the task is unregistered when this value is
+	/// dropped.
+	fn register_task(&self, name: &'static str, group: &'static str) -> UnregisterOnDrop {
+		let task = Task { name, group };
+
+		{
+			let mut tasks = self.tasks.lock();
+
+			*(*tasks).entry(task.clone()).or_default() += 1;
+		}
+
+		UnregisterOnDrop { task, registry: self.clone() }
+	}
+
+	/// Returns the running tasks.
+	///
+	/// As a task is only identified by its `name` and `group`, there can be duplicate tasks. The
+	/// number per task represents the concurrently running tasks with the same identifier.
+	pub fn running_tasks(&self) -> HashMap<Task, usize> {
+		(*self.tasks.lock()).clone()
+	}
+}
diff --git a/substrate/client/service/src/task_manager/prometheus_future.rs b/substrate/client/service/src/task_manager/prometheus_future.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51bf7fea496a70b87fa1bdeb88ff2a61a575ee93
--- /dev/null
+++ b/substrate/client/service/src/task_manager/prometheus_future.rs
@@ -0,0 +1,74 @@
+// 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/>.
+
+//! Wrapper around a `Future` that reports statistics about when the `Future` is polled.
+
+use futures::prelude::*;
+use prometheus_endpoint::{Counter, Histogram, U64};
+use std::{
+	fmt,
+	pin::Pin,
+	task::{Context, Poll},
+};
+
+/// Wraps around a `Future`. Report the polling duration to the `Histogram` and when the polling
+/// starts to the `Counter`.
+pub fn with_poll_durations<T>(
+	poll_duration: Histogram,
+	poll_start: Counter<U64>,
+	inner: T,
+) -> PrometheusFuture<T> {
+	PrometheusFuture { inner, poll_duration, poll_start }
+}
+
+/// Wraps around `Future` and adds diagnostics to it.
+#[pin_project::pin_project]
+#[derive(Clone)]
+pub struct PrometheusFuture<T> {
+	/// The inner future doing the actual work.
+	#[pin]
+	inner: T,
+	poll_duration: Histogram,
+	poll_start: Counter<U64>,
+}
+
+impl<T> Future for PrometheusFuture<T>
+where
+	T: Future,
+{
+	type Output = T::Output;
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		let this = self.project();
+
+		this.poll_start.inc();
+		let _timer = this.poll_duration.start_timer();
+		Future::poll(this.inner, cx)
+
+		// `_timer` is dropped here and will observe the duration
+	}
+}
+
+impl<T> fmt::Debug for PrometheusFuture<T>
+where
+	T: fmt::Debug,
+{
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		fmt::Debug::fmt(&self.inner, f)
+	}
+}
diff --git a/substrate/client/service/src/task_manager/tests.rs b/substrate/client/service/src/task_manager/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..27be4f9a8a26e8a06588ac18d8a64cf8bd12c42f
--- /dev/null
+++ b/substrate/client/service/src/task_manager/tests.rs
@@ -0,0 +1,252 @@
+// 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::task_manager::TaskManager;
+use futures::{future::FutureExt, pin_mut, select};
+use parking_lot::Mutex;
+use std::{any::Any, sync::Arc, time::Duration};
+
+#[derive(Clone, Debug)]
+struct DropTester(Arc<Mutex<usize>>);
+
+struct DropTesterRef(DropTester);
+
+impl DropTester {
+	fn new() -> DropTester {
+		DropTester(Arc::new(Mutex::new(0)))
+	}
+
+	fn new_ref(&self) -> DropTesterRef {
+		*self.0.lock() += 1;
+		DropTesterRef(self.clone())
+	}
+
+	fn wait_on_drop(&self) {
+		while *self != 0 {
+			std::thread::sleep(std::time::Duration::from_millis(10));
+		}
+	}
+}
+
+impl PartialEq<usize> for DropTester {
+	fn eq(&self, other: &usize) -> bool {
+		&*self.0.lock() == other
+	}
+}
+
+impl Drop for DropTesterRef {
+	fn drop(&mut self) {
+		*(self.0).0.lock() -= 1;
+	}
+}
+
+#[test]
+fn ensure_drop_tester_working() {
+	let drop_tester = DropTester::new();
+	assert_eq!(drop_tester, 0);
+	let drop_tester_ref_1 = drop_tester.new_ref();
+	assert_eq!(drop_tester, 1);
+	let drop_tester_ref_2 = drop_tester.new_ref();
+	assert_eq!(drop_tester, 2);
+	drop(drop_tester_ref_1);
+	assert_eq!(drop_tester, 1);
+	drop(drop_tester_ref_2);
+	assert_eq!(drop_tester, 0);
+}
+
+async fn run_background_task(_keep_alive: impl Any) {
+	loop {
+		tokio::time::sleep(Duration::from_secs(1)).await;
+	}
+}
+
+async fn run_background_task_blocking(duration: Duration, _keep_alive: impl Any) {
+	loop {
+		// block for X sec (not interruptible)
+		std::thread::sleep(duration);
+		// await for 1 sec (interruptible)
+		tokio::time::sleep(Duration::from_secs(1)).await;
+	}
+}
+
+fn new_task_manager(tokio_handle: tokio::runtime::Handle) -> TaskManager {
+	TaskManager::new(tokio_handle, None).unwrap()
+}
+
+#[test]
+fn ensure_tasks_are_awaited_on_shutdown() {
+	let drop_tester = DropTester::new();
+	{
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let handle = runtime.handle().clone();
+
+		let task_manager = new_task_manager(handle);
+		let spawn_handle = task_manager.spawn_handle();
+		spawn_handle.spawn("task1", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle.spawn("task2", None, run_background_task(drop_tester.new_ref()));
+		assert_eq!(drop_tester, 2);
+		// allow the tasks to even start
+		runtime.block_on(async { tokio::time::sleep(Duration::from_secs(1)).await });
+		assert_eq!(drop_tester, 2);
+	}
+	drop_tester.wait_on_drop();
+}
+
+#[test]
+fn ensure_keep_alive_during_shutdown() {
+	let drop_tester = DropTester::new();
+	{
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let handle = runtime.handle().clone();
+
+		let mut task_manager = new_task_manager(handle);
+		let spawn_handle = task_manager.spawn_handle();
+		task_manager.keep_alive(drop_tester.new_ref());
+		spawn_handle.spawn("task1", None, run_background_task(()));
+		assert_eq!(drop_tester, 1);
+		// allow the tasks to even start
+		runtime.block_on(async { tokio::time::sleep(Duration::from_secs(1)).await });
+		assert_eq!(drop_tester, 1);
+	}
+	drop_tester.wait_on_drop();
+}
+
+#[test]
+fn ensure_blocking_futures_are_awaited_on_shutdown() {
+	let drop_tester = DropTester::new();
+	{
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let handle = runtime.handle().clone();
+
+		let task_manager = new_task_manager(handle);
+		let spawn_handle = task_manager.spawn_handle();
+		spawn_handle.spawn(
+			"task1",
+			None,
+			run_background_task_blocking(Duration::from_secs(3), drop_tester.new_ref()),
+		);
+		spawn_handle.spawn(
+			"task2",
+			None,
+			run_background_task_blocking(Duration::from_secs(3), drop_tester.new_ref()),
+		);
+		assert_eq!(drop_tester, 2);
+		// allow the tasks to even start
+		runtime.block_on(async { tokio::time::sleep(Duration::from_secs(1)).await });
+		assert_eq!(drop_tester, 2);
+	}
+	assert_eq!(drop_tester, 0);
+}
+
+#[test]
+fn ensure_task_manager_future_ends_with_error_when_essential_task_fails() {
+	let drop_tester = DropTester::new();
+	{
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let handle = runtime.handle().clone();
+
+		let mut task_manager = new_task_manager(handle);
+		let spawn_handle = task_manager.spawn_handle();
+		let spawn_essential_handle = task_manager.spawn_essential_handle();
+		spawn_handle.spawn("task1", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle.spawn("task2", None, run_background_task(drop_tester.new_ref()));
+		assert_eq!(drop_tester, 2);
+		// allow the tasks to even start
+		runtime.block_on(async { tokio::time::sleep(Duration::from_secs(1)).await });
+		assert_eq!(drop_tester, 2);
+		spawn_essential_handle.spawn("task3", None, async { panic!("task failed") });
+		runtime
+			.block_on(task_manager.future())
+			.expect_err("future()'s Result must be Err");
+		assert_eq!(drop_tester, 2);
+	}
+	drop_tester.wait_on_drop();
+}
+
+#[test]
+fn ensure_task_manager_future_ends_with_error_when_childs_essential_task_fails() {
+	let drop_tester = DropTester::new();
+	{
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let handle = runtime.handle().clone();
+
+		let mut task_manager = new_task_manager(handle.clone());
+		let child_1 = new_task_manager(handle.clone());
+		let spawn_handle_child_1 = child_1.spawn_handle();
+		let spawn_essential_handle_child_1 = child_1.spawn_essential_handle();
+		let child_2 = new_task_manager(handle.clone());
+		let spawn_handle_child_2 = child_2.spawn_handle();
+		task_manager.add_child(child_1);
+		task_manager.add_child(child_2);
+		let spawn_handle = task_manager.spawn_handle();
+		spawn_handle.spawn("task1", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle.spawn("task2", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle_child_1.spawn("task3", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle_child_2.spawn("task4", None, run_background_task(drop_tester.new_ref()));
+		assert_eq!(drop_tester, 4);
+		// allow the tasks to even start
+		runtime.block_on(async { tokio::time::sleep(Duration::from_secs(1)).await });
+		assert_eq!(drop_tester, 4);
+		spawn_essential_handle_child_1.spawn("task5", None, async { panic!("task failed") });
+		runtime
+			.block_on(task_manager.future())
+			.expect_err("future()'s Result must be Err");
+		assert_eq!(drop_tester, 4);
+	}
+	drop_tester.wait_on_drop();
+}
+
+#[test]
+fn ensure_task_manager_future_continues_when_childs_not_essential_task_fails() {
+	let drop_tester = DropTester::new();
+	{
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let handle = runtime.handle().clone();
+
+		let mut task_manager = new_task_manager(handle.clone());
+		let child_1 = new_task_manager(handle.clone());
+		let spawn_handle_child_1 = child_1.spawn_handle();
+		let child_2 = new_task_manager(handle.clone());
+		let spawn_handle_child_2 = child_2.spawn_handle();
+		task_manager.add_child(child_1);
+		task_manager.add_child(child_2);
+		let spawn_handle = task_manager.spawn_handle();
+		spawn_handle.spawn("task1", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle.spawn("task2", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle_child_1.spawn("task3", None, run_background_task(drop_tester.new_ref()));
+		spawn_handle_child_2.spawn("task4", None, run_background_task(drop_tester.new_ref()));
+		assert_eq!(drop_tester, 4);
+		// allow the tasks to even start
+		runtime.block_on(async { tokio::time::sleep(Duration::from_secs(1)).await });
+		assert_eq!(drop_tester, 4);
+		spawn_handle_child_1.spawn("task5", None, async { panic!("task failed") });
+		runtime.block_on(async {
+			let t1 = task_manager.future().fuse();
+			let t2 = tokio::time::sleep(Duration::from_secs(3)).fuse();
+
+			pin_mut!(t1, t2);
+
+			select! {
+				res = t1 => panic!("task should not have stopped: {:?}", res),
+				_ = t2 => {},
+			}
+		});
+		assert_eq!(drop_tester, 4);
+	}
+	drop_tester.wait_on_drop();
+}
diff --git a/substrate/client/service/test/Cargo.toml b/substrate/client/service/test/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..dea7bfaa5b7d8db0af548e35e27fc35a95e4bb2e
--- /dev/null
+++ b/substrate/client/service/test/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "sc-service-test"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-channel = "1.8.0"
+array-bytes = "6.1"
+fdlimit = "0.2.1"
+futures = "0.3.21"
+log = "0.4.17"
+parity-scale-codec = "3.6.1"
+parking_lot = "0.12.1"
+tempfile = "3.1.0"
+tokio = { version = "1.22.0", features = ["time"] }
+sc-block-builder = { version = "0.10.0-dev", path = "../../block-builder" }
+sc-client-api = { version = "4.0.0-dev", path = "../../api" }
+sc-client-db = { version = "0.10.0-dev", default-features = false, path = "../../db" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sc-executor = { version = "0.10.0-dev", path = "../../executor" }
+sc-network = { version = "0.10.0-dev", path = "../../network" }
+sc-network-sync = { version = "0.10.0-dev", path = "../../network/sync" }
+sc-service = { version = "0.10.0-dev", features = ["test-helpers"], path = "../../service" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../client/transaction-pool/api" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../../primitives/state-machine" }
+sp-storage = { version = "13.0.0", path = "../../../primitives/storage" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+sp-trie = { version = "22.0.0", path = "../../../primitives/trie" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+substrate-test-runtime = { version = "2.0.0", path = "../../../test-utils/runtime" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/client/service/test/src/client/db.rs b/substrate/client/service/test/src/client/db.rs
new file mode 100644
index 0000000000000000000000000000000000000000..def1a41e62bb58ad0e99bf5427deb88d5f0b265e
--- /dev/null
+++ b/substrate/client/service/test/src/client/db.rs
@@ -0,0 +1,58 @@
+// 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 sp_core::offchain::{storage::InMemOffchainStorage, OffchainStorage};
+use std::sync::Arc;
+
+type TestBackend = sc_client_api::in_mem::Backend<substrate_test_runtime::Block>;
+
+#[test]
+fn test_leaves_with_complex_block_tree() {
+	let backend = Arc::new(TestBackend::new());
+
+	substrate_test_runtime_client::trait_tests::test_leaves_for_backend(backend);
+}
+
+#[test]
+fn test_blockchain_query_by_number_gets_canonical() {
+	let backend = Arc::new(TestBackend::new());
+
+	substrate_test_runtime_client::trait_tests::test_blockchain_query_by_number_gets_canonical(
+		backend,
+	);
+}
+
+#[test]
+fn in_memory_offchain_storage() {
+	let mut storage = InMemOffchainStorage::default();
+	assert_eq!(storage.get(b"A", b"B"), None);
+	assert_eq!(storage.get(b"B", b"A"), None);
+
+	storage.set(b"A", b"B", b"C");
+	assert_eq!(storage.get(b"A", b"B"), Some(b"C".to_vec()));
+	assert_eq!(storage.get(b"B", b"A"), None);
+
+	storage.compare_and_set(b"A", b"B", Some(b"X"), b"D");
+	assert_eq!(storage.get(b"A", b"B"), Some(b"C".to_vec()));
+	storage.compare_and_set(b"A", b"B", Some(b"C"), b"D");
+	assert_eq!(storage.get(b"A", b"B"), Some(b"D".to_vec()));
+
+	assert!(!storage.compare_and_set(b"B", b"A", Some(b""), b"Y"));
+	assert!(storage.compare_and_set(b"B", b"A", None, b"X"));
+	assert_eq!(storage.get(b"B", b"A"), Some(b"X".to_vec()));
+}
diff --git a/substrate/client/service/test/src/client/mod.rs b/substrate/client/service/test/src/client/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c40ac33da4bb9a7fe7f8f1dc512bd87426fa5ac7
--- /dev/null
+++ b/substrate/client/service/test/src/client/mod.rs
@@ -0,0 +1,2031 @@
+// 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 async_channel::TryRecvError;
+use futures::executor::block_on;
+use parity_scale_codec::{Decode, Encode, Joiner};
+use sc_block_builder::BlockBuilderProvider;
+use sc_client_api::{
+	in_mem, BlockBackend, BlockchainEvents, ExecutorProvider, FinalityNotifications, HeaderBackend,
+	StorageProvider,
+};
+use sc_client_db::{Backend, BlocksPruning, DatabaseSettings, DatabaseSource, PruningMode};
+use sc_consensus::{
+	BlockCheckParams, BlockImport, BlockImportParams, ForkChoiceStrategy, ImportResult,
+};
+use sc_service::client::{new_in_mem, Client, LocalCallExecutor};
+use sp_api::ProvideRuntimeApi;
+use sp_consensus::{BlockOrigin, Error as ConsensusError, SelectChain};
+use sp_core::{testing::TaskExecutor, traits::CallContext, H256};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{BlakeTwo256, Block as BlockT, Header as HeaderT},
+	ConsensusEngineId, Justifications, StateVersion,
+};
+use sp_state_machine::{backend::Backend as _, InMemoryBackend, OverlayedChanges, StateMachine};
+use sp_storage::{ChildInfo, StorageKey};
+use sp_trie::{LayoutV0, TrieConfiguration};
+use std::{collections::HashSet, sync::Arc};
+use substrate_test_runtime::TestAPI;
+use substrate_test_runtime_client::{
+	new_native_or_wasm_executor,
+	prelude::*,
+	runtime::{
+		currency::DOLLARS,
+		genesismap::{insert_genesis_block, GenesisStorageBuilder},
+		Block, BlockNumber, Digest, Hash, Header, RuntimeApi, Transfer,
+	},
+	AccountKeyring, BlockBuilderExt, ClientBlockImportExt, ClientExt, DefaultTestClientBuilderExt,
+	Sr25519Keyring, TestClientBuilder, TestClientBuilderExt,
+};
+
+mod db;
+
+const TEST_ENGINE_ID: ConsensusEngineId = *b"TEST";
+
+fn construct_block(
+	backend: &InMemoryBackend<BlakeTwo256>,
+	number: BlockNumber,
+	parent_hash: Hash,
+	state_root: Hash,
+	txs: Vec<Transfer>,
+) -> (Vec<u8>, Hash) {
+	let transactions = txs.into_iter().map(|tx| tx.into_unchecked_extrinsic()).collect::<Vec<_>>();
+
+	let iter = transactions.iter().map(Encode::encode);
+	let extrinsics_root = LayoutV0::<BlakeTwo256>::ordered_trie_root(iter).into();
+
+	let mut header = Header {
+		parent_hash,
+		number,
+		state_root,
+		extrinsics_root,
+		digest: Digest { logs: vec![] },
+	};
+	let hash = header.hash();
+	let mut overlay = OverlayedChanges::default();
+	let backend_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(backend);
+	let runtime_code = backend_runtime_code.runtime_code().expect("Code is part of the backend");
+
+	StateMachine::new(
+		backend,
+		&mut overlay,
+		&new_native_or_wasm_executor(),
+		"Core_initialize_block",
+		&header.encode(),
+		&mut Default::default(),
+		&runtime_code,
+		CallContext::Onchain,
+	)
+	.execute()
+	.unwrap();
+
+	for tx in transactions.iter() {
+		StateMachine::new(
+			backend,
+			&mut overlay,
+			&new_native_or_wasm_executor(),
+			"BlockBuilder_apply_extrinsic",
+			&tx.encode(),
+			&mut Default::default(),
+			&runtime_code,
+			CallContext::Onchain,
+		)
+		.execute()
+		.unwrap();
+	}
+
+	let ret_data = StateMachine::new(
+		backend,
+		&mut overlay,
+		&new_native_or_wasm_executor(),
+		"BlockBuilder_finalize_block",
+		&[],
+		&mut Default::default(),
+		&runtime_code,
+		CallContext::Onchain,
+	)
+	.execute()
+	.unwrap();
+	header = Header::decode(&mut &ret_data[..]).unwrap();
+
+	(vec![].and(&Block { header, extrinsics: transactions }), hash)
+}
+
+fn block1(genesis_hash: Hash, backend: &InMemoryBackend<BlakeTwo256>) -> (Vec<u8>, Hash) {
+	construct_block(
+		backend,
+		1,
+		genesis_hash,
+		array_bytes::hex_n_into_unchecked(
+			"25e5b37074063ab75c889326246640729b40d0c86932edc527bc80db0e04fe5c",
+		),
+		vec![Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Two.into(),
+			amount: 69 * DOLLARS,
+			nonce: 0,
+		}],
+	)
+}
+
+fn finality_notification_check(
+	notifications: &mut FinalityNotifications<Block>,
+	finalized: &[Hash],
+	stale_heads: &[Hash],
+) {
+	match notifications.try_recv() {
+		Ok(notif) => {
+			let stale_heads_expected: HashSet<_> = stale_heads.iter().collect();
+			let stale_heads: HashSet<_> = notif.stale_heads.iter().collect();
+			assert_eq!(notif.tree_route.as_ref(), &finalized[..finalized.len() - 1]);
+			assert_eq!(notif.hash, *finalized.last().unwrap());
+			assert_eq!(stale_heads, stale_heads_expected);
+		},
+		Err(TryRecvError::Closed) => {
+			panic!("unexpected notification result, client send channel was closed")
+		},
+		Err(TryRecvError::Empty) => assert!(finalized.is_empty()),
+	}
+}
+
+#[test]
+fn construct_genesis_should_work_with_native() {
+	let mut storage = GenesisStorageBuilder::new(
+		vec![Sr25519Keyring::One.public().into(), Sr25519Keyring::Two.public().into()],
+		vec![AccountKeyring::One.into(), AccountKeyring::Two.into()],
+		1000 * DOLLARS,
+	)
+	.build();
+	let genesis_hash = insert_genesis_block(&mut storage);
+
+	let backend = InMemoryBackend::from((storage, StateVersion::default()));
+	let (b1data, _b1hash) = block1(genesis_hash, &backend);
+	let backend_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(&backend);
+	let runtime_code = backend_runtime_code.runtime_code().expect("Code is part of the backend");
+
+	let mut overlay = OverlayedChanges::default();
+
+	let _ = StateMachine::new(
+		&backend,
+		&mut overlay,
+		&new_native_or_wasm_executor(),
+		"Core_execute_block",
+		&b1data,
+		&mut Default::default(),
+		&runtime_code,
+		CallContext::Onchain,
+	)
+	.execute()
+	.unwrap();
+}
+
+#[test]
+fn construct_genesis_should_work_with_wasm() {
+	let mut storage = GenesisStorageBuilder::new(
+		vec![Sr25519Keyring::One.public().into(), Sr25519Keyring::Two.public().into()],
+		vec![AccountKeyring::One.into(), AccountKeyring::Two.into()],
+		1000 * DOLLARS,
+	)
+	.build();
+	let genesis_hash = insert_genesis_block(&mut storage);
+
+	let backend = InMemoryBackend::from((storage, StateVersion::default()));
+	let (b1data, _b1hash) = block1(genesis_hash, &backend);
+	let backend_runtime_code = sp_state_machine::backend::BackendRuntimeCode::new(&backend);
+	let runtime_code = backend_runtime_code.runtime_code().expect("Code is part of the backend");
+
+	let mut overlay = OverlayedChanges::default();
+
+	let _ = StateMachine::new(
+		&backend,
+		&mut overlay,
+		&new_native_or_wasm_executor(),
+		"Core_execute_block",
+		&b1data,
+		&mut Default::default(),
+		&runtime_code,
+		CallContext::Onchain,
+	)
+	.execute()
+	.unwrap();
+}
+
+#[test]
+fn client_initializes_from_genesis_ok() {
+	let client = substrate_test_runtime_client::new();
+
+	assert_eq!(
+		client
+			.runtime_api()
+			.balance_of(client.chain_info().best_hash, AccountKeyring::Alice.into())
+			.unwrap(),
+		1000 * DOLLARS
+	);
+	assert_eq!(
+		client
+			.runtime_api()
+			.balance_of(client.chain_info().best_hash, AccountKeyring::Ferdie.into())
+			.unwrap(),
+		0 * DOLLARS
+	);
+}
+
+#[test]
+fn block_builder_works_with_no_transactions() {
+	let mut client = substrate_test_runtime_client::new();
+
+	let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+
+	block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+	assert_eq!(client.chain_info().best_number, 1);
+}
+
+#[test]
+fn block_builder_works_with_transactions() {
+	let mut client = substrate_test_runtime_client::new();
+
+	let mut builder = client.new_block(Default::default()).unwrap();
+
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 42 * DOLLARS,
+			nonce: 0,
+		})
+		.unwrap();
+
+	let block = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+	let hash0 = client
+		.expect_block_hash_from_id(&BlockId::Number(0))
+		.expect("block 0 was just imported. qed");
+	let hash1 = client
+		.expect_block_hash_from_id(&BlockId::Number(1))
+		.expect("block 1 was just imported. qed");
+
+	assert_eq!(client.chain_info().best_number, 1);
+	assert_ne!(
+		client
+			.state_at(hash1)
+			.unwrap()
+			.pairs(Default::default())
+			.unwrap()
+			.collect::<Vec<_>>(),
+		client
+			.state_at(hash0)
+			.unwrap()
+			.pairs(Default::default())
+			.unwrap()
+			.collect::<Vec<_>>()
+	);
+	assert_eq!(
+		client
+			.runtime_api()
+			.balance_of(client.chain_info().best_hash, AccountKeyring::Alice.into())
+			.unwrap(),
+		958 * DOLLARS
+	);
+	assert_eq!(
+		client
+			.runtime_api()
+			.balance_of(client.chain_info().best_hash, AccountKeyring::Ferdie.into())
+			.unwrap(),
+		42 * DOLLARS
+	);
+}
+
+#[test]
+fn block_builder_does_not_include_invalid() {
+	let mut client = substrate_test_runtime_client::new();
+	let mut builder = client.new_block(Default::default()).unwrap();
+
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 42 * DOLLARS,
+			nonce: 0,
+		})
+		.unwrap();
+
+	assert!(builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 30 * DOLLARS,
+			nonce: 0,
+		})
+		.is_err());
+
+	let block = builder.build().unwrap().block;
+	//transfer from Eve should not be included
+	assert_eq!(block.extrinsics.len(), 1);
+	block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+	let hashof0 = client
+		.expect_block_hash_from_id(&BlockId::Number(0))
+		.expect("block 0 was just imported. qed");
+	let hashof1 = client
+		.expect_block_hash_from_id(&BlockId::Number(1))
+		.expect("block 1 was just imported. qed");
+
+	assert_eq!(client.chain_info().best_number, 1);
+	assert_ne!(
+		client
+			.state_at(hashof1)
+			.unwrap()
+			.pairs(Default::default())
+			.unwrap()
+			.collect::<Vec<_>>(),
+		client
+			.state_at(hashof0)
+			.unwrap()
+			.pairs(Default::default())
+			.unwrap()
+			.collect::<Vec<_>>()
+	);
+	assert_eq!(client.body(hashof1).unwrap().unwrap().len(), 1)
+}
+
+#[test]
+fn best_containing_with_genesis_block() {
+	// block tree:
+	// G
+
+	let (client, longest_chain_select) = TestClientBuilder::new().build_with_longest_chain();
+
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	assert_eq!(
+		genesis_hash.clone(),
+		block_on(longest_chain_select.finality_target(genesis_hash, None)).unwrap(),
+	);
+}
+
+#[test]
+fn uncles_with_only_ancestors() {
+	// block tree:
+	// G -> A1 -> A2
+	let mut client = substrate_test_runtime_client::new();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+	let v: Vec<H256> = Vec::new();
+	assert_eq!(v, client.uncles(a2.hash(), 3).unwrap());
+}
+
+#[test]
+fn uncles_with_multiple_forks() {
+	// block tree:
+	// G -> A1 -> A2 -> A3 -> A4 -> A5
+	//      A1 -> B2 -> B3 -> B4
+	//	          B2 -> C3
+	//	    A1 -> D2
+	let mut client = substrate_test_runtime_client::new();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	// A2 -> A3
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+
+	// A3 -> A4
+	let a4 = client
+		.new_block_at(a3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
+
+	// A4 -> A5
+	let a5 = client
+		.new_block_at(a4.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
+
+	// A1 -> B2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise B2 has the same hash as A2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41 * DOLLARS,
+			nonce: 0,
+		})
+		.unwrap();
+	let b2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	// B2 -> B3
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
+
+	// B3 -> B4
+	let b4 = client
+		.new_block_at(b3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
+
+	// // B2 -> C3
+	let mut builder = client.new_block_at(b2.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise C3 has the same hash as B3 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1 * DOLLARS,
+			nonce: 1,
+		})
+		.unwrap();
+	let c3 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
+
+	// A1 -> D2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise D2 has the same hash as B2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1 * DOLLARS,
+			nonce: 0,
+		})
+		.unwrap();
+	let d2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
+
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	let uncles1 = client.uncles(a4.hash(), 10).unwrap();
+	assert_eq!(vec![b2.hash(), d2.hash()], uncles1);
+
+	let uncles2 = client.uncles(a4.hash(), 0).unwrap();
+	assert_eq!(0, uncles2.len());
+
+	let uncles3 = client.uncles(a1.hash(), 10).unwrap();
+	assert_eq!(0, uncles3.len());
+
+	let uncles4 = client.uncles(genesis_hash, 10).unwrap();
+	assert_eq!(0, uncles4.len());
+
+	let uncles5 = client.uncles(d2.hash(), 10).unwrap();
+	assert_eq!(vec![a2.hash(), b2.hash()], uncles5);
+
+	let uncles6 = client.uncles(b3.hash(), 1).unwrap();
+	assert_eq!(vec![c3.hash()], uncles6);
+}
+
+#[test]
+fn finality_target_on_longest_chain_with_single_chain_3_blocks() {
+	// block tree:
+	// G -> A1 -> A2
+
+	let (mut client, longest_chain_select) = TestClientBuilder::new().build_with_longest_chain();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	assert_eq!(
+		a2.hash(),
+		block_on(longest_chain_select.finality_target(genesis_hash, None)).unwrap()
+	);
+	assert_eq!(a2.hash(), block_on(longest_chain_select.finality_target(a1.hash(), None)).unwrap());
+	assert_eq!(a2.hash(), block_on(longest_chain_select.finality_target(a2.hash(), None)).unwrap());
+}
+
+#[test]
+fn finality_target_on_longest_chain_with_multiple_forks() {
+	// block tree:
+	// G -> A1 -> A2 -> A3 -> A4 -> A5
+	//      A1 -> B2 -> B3 -> B4
+	// 	          B2 -> C3
+	// 	    A1 -> D2
+	let (mut client, longest_chain_select) = TestClientBuilder::new().build_with_longest_chain();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	// A2 -> A3
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+
+	// A3 -> A4
+	let a4 = client
+		.new_block_at(a3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
+
+	// A4 -> A5
+	let a5 = client
+		.new_block_at(a4.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
+
+	// A1 -> B2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise B2 has the same hash as A2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41 * DOLLARS,
+			nonce: 0,
+		})
+		.unwrap();
+	let b2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	// B2 -> B3
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
+
+	// B3 -> B4
+	let b4 = client
+		.new_block_at(b3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
+
+	// B2 -> C3
+	let mut builder = client.new_block_at(b2.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise C3 has the same hash as B3 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1 * DOLLARS,
+			nonce: 1,
+		})
+		.unwrap();
+	let c3 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
+
+	// A1 -> D2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise D2 has the same hash as B2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1 * DOLLARS,
+			nonce: 0,
+		})
+		.unwrap();
+	let d2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
+
+	assert_eq!(client.chain_info().best_hash, a5.hash());
+
+	let genesis_hash = client.chain_info().genesis_hash;
+	let leaves = block_on(longest_chain_select.leaves()).unwrap();
+
+	assert!(leaves.contains(&a5.hash()));
+	assert!(leaves.contains(&b4.hash()));
+	assert!(leaves.contains(&c3.hash()));
+	assert!(leaves.contains(&d2.hash()));
+	assert_eq!(leaves.len(), 4);
+
+	// On error we return a quite improbable hash
+	let error_hash = Hash::from([0xff; 32]);
+	let finality_target = |target_hash, number| match block_on(
+		longest_chain_select.finality_target(target_hash, number),
+	) {
+		Ok(hash) => hash,
+		Err(_) => error_hash,
+	};
+
+	// search without restriction
+	assert_eq!(a5.hash(), finality_target(genesis_hash, None));
+	assert_eq!(a5.hash(), finality_target(a1.hash(), None));
+	assert_eq!(a5.hash(), finality_target(a2.hash(), None));
+	assert_eq!(a5.hash(), finality_target(a3.hash(), None));
+	assert_eq!(a5.hash(), finality_target(a4.hash(), None));
+	assert_eq!(a5.hash(), finality_target(a5.hash(), None));
+	assert_eq!(error_hash, finality_target(b2.hash(), None));
+	assert_eq!(error_hash, finality_target(b3.hash(), None));
+	assert_eq!(error_hash, finality_target(b4.hash(), None));
+	assert_eq!(error_hash, finality_target(c3.hash(), None));
+	assert_eq!(error_hash, finality_target(d2.hash(), None));
+
+	// search only blocks with number <= 5. equivalent to without restriction for this scenario
+	assert_eq!(a5.hash(), finality_target(genesis_hash, Some(5)));
+	assert_eq!(a5.hash(), finality_target(a1.hash(), Some(5)));
+	assert_eq!(a5.hash(), finality_target(a2.hash(), Some(5)));
+	assert_eq!(a5.hash(), finality_target(a3.hash(), Some(5)));
+	assert_eq!(a5.hash(), finality_target(a4.hash(), Some(5)));
+	assert_eq!(a5.hash(), finality_target(a5.hash(), Some(5)));
+	assert_eq!(error_hash, finality_target(b2.hash(), Some(5)));
+	assert_eq!(error_hash, finality_target(b3.hash(), Some(5)));
+	assert_eq!(error_hash, finality_target(b4.hash(), Some(5)));
+	assert_eq!(error_hash, finality_target(c3.hash(), Some(5)));
+	assert_eq!(error_hash, finality_target(d2.hash(), Some(5)));
+
+	// search only blocks with number <= 4
+	assert_eq!(a4.hash(), finality_target(genesis_hash, Some(4)));
+	assert_eq!(a4.hash(), finality_target(a1.hash(), Some(4)));
+	assert_eq!(a4.hash(), finality_target(a2.hash(), Some(4)));
+	assert_eq!(a4.hash(), finality_target(a3.hash(), Some(4)));
+	assert_eq!(a4.hash(), finality_target(a4.hash(), Some(4)));
+	assert_eq!(error_hash, finality_target(a5.hash(), Some(4)));
+	assert_eq!(error_hash, finality_target(b2.hash(), Some(4)));
+	assert_eq!(error_hash, finality_target(b3.hash(), Some(4)));
+	assert_eq!(error_hash, finality_target(b4.hash(), Some(4)));
+	assert_eq!(error_hash, finality_target(c3.hash(), Some(4)));
+	assert_eq!(error_hash, finality_target(d2.hash(), Some(4)));
+
+	// search only blocks with number <= 3
+	assert_eq!(a3.hash(), finality_target(genesis_hash, Some(3)));
+	assert_eq!(a3.hash(), finality_target(a1.hash(), Some(3)));
+	assert_eq!(a3.hash(), finality_target(a2.hash(), Some(3)));
+	assert_eq!(a3.hash(), finality_target(a3.hash(), Some(3)));
+	assert_eq!(error_hash, finality_target(a4.hash(), Some(3)));
+	assert_eq!(error_hash, finality_target(a5.hash(), Some(3)));
+	assert_eq!(error_hash, finality_target(b2.hash(), Some(3)));
+	assert_eq!(error_hash, finality_target(b3.hash(), Some(3)));
+	assert_eq!(error_hash, finality_target(b4.hash(), Some(3)));
+	assert_eq!(error_hash, finality_target(c3.hash(), Some(3)));
+	assert_eq!(error_hash, finality_target(d2.hash(), Some(3)));
+
+	// search only blocks with number <= 2
+	assert_eq!(a2.hash(), finality_target(genesis_hash, Some(2)));
+	assert_eq!(a2.hash(), finality_target(a1.hash(), Some(2)));
+	assert_eq!(a2.hash(), finality_target(a2.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(a3.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(a4.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(a5.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(b2.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(b3.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(b4.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(c3.hash(), Some(2)));
+	assert_eq!(error_hash, finality_target(d2.hash(), Some(2)));
+
+	// search only blocks with number <= 1
+	assert_eq!(a1.hash(), finality_target(genesis_hash, Some(1)));
+	assert_eq!(a1.hash(), finality_target(a1.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(a2.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(a3.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(a4.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(a5.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(b2.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(b3.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(b4.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(c3.hash(), Some(1)));
+	assert_eq!(error_hash, finality_target(d2.hash(), Some(1)));
+
+	// search only blocks with number <= 0
+	assert_eq!(genesis_hash, finality_target(genesis_hash, Some(0)));
+	assert_eq!(error_hash, finality_target(a1.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(a2.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(a3.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(a4.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(a5.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(b2.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(b3.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(b4.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(c3.hash(), Some(0)));
+	assert_eq!(error_hash, finality_target(d2.hash(), Some(0)));
+}
+
+#[test]
+fn finality_target_on_longest_chain_with_max_depth_higher_than_best() {
+	// block tree:
+	// G -> A1 -> A2
+
+	let (mut client, chain_select) = TestClientBuilder::new().build_with_longest_chain();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	assert_eq!(a2.hash(), block_on(chain_select.finality_target(genesis_hash, Some(10))).unwrap(),);
+}
+
+#[test]
+fn finality_target_with_best_not_on_longest_chain() {
+	// block tree:
+	// G -> A1 -> A2 ->  A3  -> A4 -> A5
+	//         -> B2 -> (B3) -> B4
+	//                   ^best
+
+	let (mut client, chain_select) = TestClientBuilder::new().build_with_longest_chain();
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	// A2 -> A3
+	let a3 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+
+	// A3 -> A4
+	let a4 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
+
+	// A3 -> A5
+	let a5 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
+
+	// A1 -> B2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise B2 has the same hash as A2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41 * DOLLARS,
+			nonce: 0,
+		})
+		.unwrap();
+	let b2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	assert_eq!(a5.hash(), block_on(chain_select.finality_target(genesis_hash, None)).unwrap());
+	assert_eq!(a5.hash(), block_on(chain_select.finality_target(a1.hash(), None)).unwrap());
+	assert_eq!(a5.hash(), block_on(chain_select.finality_target(a2.hash(), None)).unwrap());
+	assert_eq!(a5.hash(), block_on(chain_select.finality_target(a3.hash(), None)).unwrap());
+	assert_eq!(a5.hash(), block_on(chain_select.finality_target(a4.hash(), None)).unwrap());
+	assert_eq!(a5.hash(), block_on(chain_select.finality_target(a5.hash(), None)).unwrap());
+
+	// B2 -> B3
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import_as_best(BlockOrigin::Own, b3.clone())).unwrap();
+
+	// B3 -> B4
+	let b4 = client
+		.new_block_at(b3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	let (header, extrinsics) = b4.clone().deconstruct();
+	let mut import_params = BlockImportParams::new(BlockOrigin::Own, header);
+	import_params.body = Some(extrinsics);
+	import_params.fork_choice = Some(ForkChoiceStrategy::Custom(false));
+	block_on(client.import_block(import_params)).unwrap();
+
+	// double check that B3 is still the best...
+	assert_eq!(client.info().best_hash, b3.hash());
+
+	assert_eq!(b4.hash(), block_on(chain_select.finality_target(genesis_hash, None)).unwrap());
+	assert_eq!(b4.hash(), block_on(chain_select.finality_target(a1.hash(), None)).unwrap());
+	assert!(block_on(chain_select.finality_target(a2.hash(), None)).is_err());
+	assert_eq!(b4.hash(), block_on(chain_select.finality_target(b2.hash(), None)).unwrap());
+	assert_eq!(b4.hash(), block_on(chain_select.finality_target(b3.hash(), None)).unwrap());
+	assert_eq!(b4.hash(), block_on(chain_select.finality_target(b4.hash(), None)).unwrap());
+}
+
+#[test]
+fn import_with_justification() {
+	// block tree:
+	// G -> A1 -> A2 -> A3
+	let mut client = substrate_test_runtime_client::new();
+
+	let mut finality_notifications = client.finality_notification_stream();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+	client.finalize_block(a2.hash(), None).unwrap();
+
+	// A2 -> A3
+	let justification = Justifications::from((TEST_ENGINE_ID, vec![1, 2, 3]));
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import_justified(BlockOrigin::Own, a3.clone(), justification.clone())).unwrap();
+
+	assert_eq!(client.chain_info().finalized_hash, a3.hash());
+
+	assert_eq!(client.justifications(a3.hash()).unwrap(), Some(justification));
+
+	assert_eq!(client.justifications(a1.hash()).unwrap(), None);
+
+	assert_eq!(client.justifications(a2.hash()).unwrap(), None);
+
+	finality_notification_check(&mut finality_notifications, &[a1.hash(), a2.hash()], &[]);
+	finality_notification_check(&mut finality_notifications, &[a3.hash()], &[]);
+	assert!(matches!(finality_notifications.try_recv().unwrap_err(), TryRecvError::Empty));
+}
+
+#[test]
+fn importing_diverged_finalized_block_should_trigger_reorg() {
+	let mut client = substrate_test_runtime_client::new();
+
+	// G -> A1 -> A2
+	//   \
+	//    -> B1
+
+	let mut finality_notifications = client.finality_notification_stream();
+
+	let a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	let mut b1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	// needed to make sure B1 gets a different hash from A1
+	b1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 1 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	// create but don't import B1 just yet
+	let b1 = b1.build().unwrap().block;
+
+	// A2 is the current best since it's the longest chain
+	assert_eq!(client.chain_info().best_hash, a2.hash());
+
+	// importing B1 as finalized should trigger a re-org and set it as new best
+	let justification = Justifications::from((TEST_ENGINE_ID, vec![1, 2, 3]));
+	block_on(client.import_justified(BlockOrigin::Own, b1.clone(), justification)).unwrap();
+
+	assert_eq!(client.chain_info().best_hash, b1.hash());
+
+	assert_eq!(client.chain_info().finalized_hash, b1.hash());
+
+	finality_notification_check(&mut finality_notifications, &[b1.hash()], &[a2.hash()]);
+	assert!(matches!(finality_notifications.try_recv().unwrap_err(), TryRecvError::Empty));
+}
+
+#[test]
+fn finalizing_diverged_block_should_trigger_reorg() {
+	let (mut client, select_chain) = TestClientBuilder::new().build_with_longest_chain();
+
+	// G -> A1 -> A2
+	//   \
+	//    -> B1 -> B2
+
+	let mut finality_notifications = client.finality_notification_stream();
+
+	let a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	let mut b1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	// needed to make sure B1 gets a different hash from A1
+	b1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 1 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let b1 = b1.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b1.clone())).unwrap();
+
+	let b2 = client
+		.new_block_at(b1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	// A2 is the current best since it's the (first) longest chain
+	assert_eq!(client.chain_info().best_hash, a2.hash());
+
+	// we finalize block B1 which is on a different branch from current best
+	// which should trigger a re-org.
+	ClientExt::finalize_block(&client, b1.hash(), None).unwrap();
+
+	// B1 should now be the latest finalized
+	assert_eq!(client.chain_info().finalized_hash, b1.hash());
+
+	// and B1 should be the new best block (`finalize_block` as no way of
+	// knowing about B2)
+	assert_eq!(client.chain_info().best_hash, b1.hash());
+
+	// `SelectChain` should report B2 as best block though
+	assert_eq!(block_on(select_chain.best_chain()).unwrap().hash(), b2.hash());
+
+	// after we build B3 on top of B2 and import it, it should be the new best block
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
+
+	// `SelectChain` should report B3 as best block though
+	assert_eq!(block_on(select_chain.best_chain()).unwrap().hash(), b3.hash());
+
+	assert_eq!(client.chain_info().best_hash, b3.hash());
+
+	ClientExt::finalize_block(&client, b3.hash(), None).unwrap();
+
+	finality_notification_check(&mut finality_notifications, &[b1.hash()], &[]);
+	finality_notification_check(&mut finality_notifications, &[b2.hash(), b3.hash()], &[a2.hash()]);
+	assert!(matches!(finality_notifications.try_recv().unwrap_err(), TryRecvError::Empty));
+}
+
+#[test]
+fn finality_notifications_content() {
+	sp_tracing::try_init_simple();
+	let (mut client, _select_chain) = TestClientBuilder::new().build_with_longest_chain();
+
+	//               -> D3 -> D4
+	// G -> A1 -> A2 -> A3
+	//   -> B1 -> B2
+	//   -> C1
+
+	let mut finality_notifications = client.finality_notification_stream();
+
+	let a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+
+	let mut b1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	// needed to make sure B1 gets a different hash from A1
+	b1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 1,
+		nonce: 0,
+	})
+	.unwrap();
+	let b1 = b1.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b1.clone())).unwrap();
+
+	let b2 = client
+		.new_block_at(b1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	let mut c1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	// needed to make sure B1 gets a different hash from A1
+	c1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 2 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let c1 = c1.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, c1.clone())).unwrap();
+
+	let mut d3 = client.new_block_at(a2.hash(), Default::default(), false).unwrap();
+	// needed to make sure D3 gets a different hash from A3
+	d3.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 2 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let d3 = d3.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, d3.clone())).unwrap();
+
+	let d4 = client
+		.new_block_at(d3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	// Postpone import to test behavior of import of finalized block.
+
+	ClientExt::finalize_block(&client, a2.hash(), None).unwrap();
+
+	// Import and finalize D4
+	block_on(client.import_as_final(BlockOrigin::Own, d4.clone())).unwrap();
+
+	finality_notification_check(&mut finality_notifications, &[a1.hash(), a2.hash()], &[c1.hash()]);
+	finality_notification_check(&mut finality_notifications, &[d3.hash(), d4.hash()], &[b2.hash()]);
+	assert!(matches!(finality_notifications.try_recv().unwrap_err(), TryRecvError::Empty));
+}
+
+#[test]
+fn get_block_by_bad_block_hash_returns_none() {
+	let client = substrate_test_runtime_client::new();
+
+	let hash = H256::from_low_u64_be(5);
+	assert!(client.block(hash).unwrap().is_none());
+}
+
+#[test]
+fn expect_block_hash_by_block_number_doesnt_panic() {
+	let client = substrate_test_runtime_client::new();
+
+	// backend uses u32 for block numbers, make sure we don't panic when
+	// trying to convert
+	let id = BlockId::<Block>::Number(72340207214430721);
+	client.block_hash_from_id(&id).expect_err("invalid block number overflows u32");
+}
+
+#[test]
+fn get_hash_by_block_number_doesnt_panic() {
+	let client = substrate_test_runtime_client::new();
+
+	// backend uses u32 for block numbers, make sure we don't panic when
+	// trying to convert
+	client.hash(72340207214430721).expect_err("invalid block number overflows u32");
+}
+
+#[test]
+fn state_reverted_on_reorg() {
+	sp_tracing::try_init_simple();
+	let mut client = substrate_test_runtime_client::new();
+
+	let current_balance = |client: &substrate_test_runtime_client::TestClient| {
+		client
+			.runtime_api()
+			.balance_of(client.chain_info().best_hash, AccountKeyring::Alice.into())
+			.unwrap()
+	};
+
+	// G -> A1 -> A2
+	//   \
+	//    -> B1
+	let mut a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	a1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Bob.into(),
+		amount: 10 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let a1 = a1.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	let mut b1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	b1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 50 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let b1 = b1.build().unwrap().block;
+	// Reorg to B1
+	block_on(client.import_as_best(BlockOrigin::Own, b1.clone())).unwrap();
+
+	assert_eq!(950 * DOLLARS, current_balance(&client));
+	let mut a2 = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	a2.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Charlie.into(),
+		amount: 10 * DOLLARS,
+		nonce: 1,
+	})
+	.unwrap();
+	let a2 = a2.build().unwrap().block;
+	// Re-org to A2
+	block_on(client.import_as_best(BlockOrigin::Own, a2)).unwrap();
+	assert_eq!(980 * DOLLARS, current_balance(&client));
+}
+
+#[test]
+fn doesnt_import_blocks_that_revert_finality() {
+	sp_tracing::try_init_simple();
+	let tmp = tempfile::tempdir().unwrap();
+
+	// we need to run with archive pruning to avoid pruning non-canonical
+	// states
+	let backend = Arc::new(
+		Backend::new(
+			DatabaseSettings {
+				trie_cache_maximum_size: Some(1 << 20),
+				state_pruning: Some(PruningMode::ArchiveAll),
+				blocks_pruning: BlocksPruning::KeepAll,
+				source: DatabaseSource::RocksDb { path: tmp.path().into(), cache_size: 1024 },
+			},
+			u64::MAX,
+		)
+		.unwrap(),
+	);
+
+	let mut client = TestClientBuilder::with_backend(backend).build();
+
+	let mut finality_notifications = client.finality_notification_stream();
+
+	//    -> C1
+	//   /
+	// G -> A1 -> A2 -> A3
+	//   \
+	//    -> B1 -> B2 -> B3
+
+	let a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	let mut b1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+
+	// needed to make sure B1 gets a different hash from A1
+	b1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 1 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let b1 = b1.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b1.clone())).unwrap();
+
+	let b2 = client
+		.new_block_at(b1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	// prepare B3 before we finalize A2, because otherwise we won't be able to
+	// read changes trie configuration after A2 is finalized
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	// we will finalize A2 which should make it impossible to import a new
+	// B3 at the same height but that doesn't include it
+	ClientExt::finalize_block(&client, a2.hash(), None).unwrap();
+
+	let import_err = block_on(client.import(BlockOrigin::Own, b3)).err().unwrap();
+	let expected_err =
+		ConsensusError::ClientImport(sp_blockchain::Error::NotInFinalizedChain.to_string());
+
+	assert_eq!(import_err.to_string(), expected_err.to_string());
+
+	// adding a C1 block which is lower than the last finalized should also
+	// fail (with a cheaper check that doesn't require checking ancestry).
+	let mut c1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+
+	// needed to make sure C1 gets a different hash from A1 and B1
+	c1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 2 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let c1 = c1.build().unwrap().block;
+
+	let import_err = block_on(client.import(BlockOrigin::Own, c1)).err().unwrap();
+	let expected_err =
+		ConsensusError::ClientImport(sp_blockchain::Error::NotInFinalizedChain.to_string());
+
+	assert_eq!(import_err.to_string(), expected_err.to_string());
+
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+	ClientExt::finalize_block(&client, a3.hash(), None).unwrap();
+
+	finality_notification_check(&mut finality_notifications, &[a1.hash(), a2.hash()], &[]);
+
+	finality_notification_check(&mut finality_notifications, &[a3.hash()], &[b2.hash()]);
+
+	assert!(matches!(finality_notifications.try_recv().unwrap_err(), TryRecvError::Empty));
+}
+
+#[test]
+fn respects_block_rules() {
+	fn run_test(
+		record_only: bool,
+		known_bad: &mut HashSet<H256>,
+		fork_rules: &mut Vec<(u64, H256)>,
+	) {
+		let mut client = if record_only {
+			TestClientBuilder::new().build()
+		} else {
+			TestClientBuilder::new()
+				.set_block_rules(Some(fork_rules.clone()), Some(known_bad.clone()))
+				.build()
+		};
+
+		// test modus operandi:
+		//
+		//            B[2]
+		//           /
+		// G[0]--B[1]
+		//     \     \
+		//      \     B'[2]
+		//       \
+		//        B'[1]
+		//
+		// B[1]  - block ok
+		// B'[1] - block not ok, added to block_rules::bad
+		//
+		// B[2]  - block ok, correct fork for block height==2, added to block_rules::forks
+		// B'[2] - block not ok, (incorrect fork)
+
+		// build B[1]
+		let block_ok = client
+			.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+			.unwrap()
+			.build()
+			.unwrap()
+			.block;
+		let block_ok_1_hash = block_ok.hash();
+
+		let params = BlockCheckParams {
+			hash: block_ok.hash(),
+			number: 1,
+			parent_hash: *block_ok.header().parent_hash(),
+			allow_missing_state: false,
+			allow_missing_parent: false,
+			import_existing: false,
+		};
+		assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::imported(false));
+
+		// build B'[1]
+		let mut block_not_ok = client
+			.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+			.unwrap();
+		block_not_ok.push_storage_change(vec![0], Some(vec![1])).unwrap();
+		let block_not_ok = block_not_ok.build().unwrap().block;
+
+		let params = BlockCheckParams {
+			hash: block_not_ok.hash(),
+			number: 1,
+			parent_hash: *block_not_ok.header().parent_hash(),
+			allow_missing_state: false,
+			allow_missing_parent: false,
+			import_existing: false,
+		};
+		if record_only {
+			known_bad.insert(block_not_ok.hash());
+		} else {
+			assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::KnownBad);
+		}
+
+		// Now going to the fork
+		block_on(client.import_as_final(BlockOrigin::Own, block_ok)).unwrap();
+
+		// And check good fork (build B[2])
+		let mut block_ok = client.new_block_at(block_ok_1_hash, Default::default(), false).unwrap();
+		block_ok.push_storage_change(vec![0], Some(vec![2])).unwrap();
+		let block_ok = block_ok.build().unwrap().block;
+		assert_eq!(*block_ok.header().number(), 2);
+
+		let params = BlockCheckParams {
+			hash: block_ok.hash(),
+			number: 2,
+			parent_hash: *block_ok.header().parent_hash(),
+			allow_missing_state: false,
+			allow_missing_parent: false,
+			import_existing: false,
+		};
+		if record_only {
+			fork_rules.push((2, block_ok.hash()));
+		}
+		assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::imported(false));
+
+		// And now try bad fork (build B'[2])
+		let mut block_not_ok =
+			client.new_block_at(block_ok_1_hash, Default::default(), false).unwrap();
+		block_not_ok.push_storage_change(vec![0], Some(vec![3])).unwrap();
+		let block_not_ok = block_not_ok.build().unwrap().block;
+		assert_eq!(*block_not_ok.header().number(), 2);
+
+		let params = BlockCheckParams {
+			hash: block_not_ok.hash(),
+			number: 2,
+			parent_hash: *block_not_ok.header().parent_hash(),
+			allow_missing_state: false,
+			allow_missing_parent: false,
+			import_existing: false,
+		};
+
+		if !record_only {
+			assert_eq!(block_on(client.check_block(params)).unwrap(), ImportResult::KnownBad);
+		}
+	}
+
+	let mut known_bad = HashSet::new();
+	let mut fork_rules = Vec::new();
+
+	// records what bad_blocks and fork_blocks hashes should be
+	run_test(true, &mut known_bad, &mut fork_rules);
+
+	// enforces rules and actually makes assertions
+	run_test(false, &mut known_bad, &mut fork_rules);
+}
+
+#[test]
+#[cfg(disable_flaky)]
+#[allow(dead_code)]
+// FIXME: https://github.com/paritytech/substrate/issues/11321
+fn returns_status_for_pruned_blocks() {
+	use sc_consensus::BlockStatus;
+	sp_tracing::try_init_simple();
+	let tmp = tempfile::tempdir().unwrap();
+
+	// set to prune after 1 block
+	// states
+	let backend = Arc::new(
+		Backend::new(
+			DatabaseSettings {
+				trie_cache_maximum_size: Some(1 << 20),
+				state_pruning: Some(PruningMode::blocks_pruning(1)),
+				blocks_pruning: BlocksPruning::KeepFinalized,
+				source: DatabaseSource::RocksDb { path: tmp.path().into(), cache_size: 1024 },
+			},
+			u64::MAX,
+		)
+		.unwrap(),
+	);
+
+	let mut client = TestClientBuilder::with_backend(backend).build();
+
+	let a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	let mut b1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+
+	// b1 is created, but not imported
+	b1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 1 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let b1 = b1.build().unwrap().block;
+
+	let check_block_a1 = BlockCheckParams {
+		hash: a1.hash(),
+		number: 0,
+		parent_hash: *a1.header().parent_hash(),
+		allow_missing_state: false,
+		allow_missing_parent: false,
+		import_existing: false,
+	};
+
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::imported(false),
+	);
+	assert_eq!(client.block_status(check_block_a1.hash).unwrap(), BlockStatus::Unknown);
+
+	block_on(client.import_as_final(BlockOrigin::Own, a1.clone())).unwrap();
+
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(client.block_status(check_block_a1.hash).unwrap(), BlockStatus::InChainWithState);
+
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import_as_final(BlockOrigin::Own, a2.clone())).unwrap();
+
+	let check_block_a2 = BlockCheckParams {
+		hash: a2.hash(),
+		number: 1,
+		parent_hash: *a1.header().parent_hash(),
+		allow_missing_state: false,
+		allow_missing_parent: false,
+		import_existing: false,
+	};
+
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(client.block_status(check_block_a1.hash).unwrap(), BlockStatus::InChainPruned);
+	assert_eq!(
+		block_on(client.check_block(check_block_a2.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(client.block_status(check_block_a2.hash).unwrap(), BlockStatus::InChainWithState);
+
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	block_on(client.import_as_final(BlockOrigin::Own, a3.clone())).unwrap();
+	let check_block_a3 = BlockCheckParams {
+		hash: a3.hash(),
+		number: 2,
+		parent_hash: *a2.header().parent_hash(),
+		allow_missing_state: false,
+		allow_missing_parent: false,
+		import_existing: false,
+	};
+
+	// a1 and a2 are both pruned at this point
+	assert_eq!(
+		block_on(client.check_block(check_block_a1.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(client.block_status(check_block_a1.hash).unwrap(), BlockStatus::InChainPruned);
+	assert_eq!(
+		block_on(client.check_block(check_block_a2.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(client.block_status(check_block_a2.hash).unwrap(), BlockStatus::InChainPruned);
+	assert_eq!(
+		block_on(client.check_block(check_block_a3.clone())).unwrap(),
+		ImportResult::AlreadyInChain,
+	);
+	assert_eq!(client.block_status(check_block_a3.hash).unwrap(), BlockStatus::InChainWithState);
+
+	let mut check_block_b1 = BlockCheckParams {
+		hash: b1.hash(),
+		number: 0,
+		parent_hash: *b1.header().parent_hash(),
+		allow_missing_state: false,
+		allow_missing_parent: false,
+		import_existing: false,
+	};
+	assert_eq!(
+		block_on(client.check_block(check_block_b1.clone())).unwrap(),
+		ImportResult::MissingState,
+	);
+	check_block_b1.allow_missing_state = true;
+	assert_eq!(
+		block_on(client.check_block(check_block_b1.clone())).unwrap(),
+		ImportResult::imported(false),
+	);
+	check_block_b1.parent_hash = H256::random();
+	assert_eq!(
+		block_on(client.check_block(check_block_b1.clone())).unwrap(),
+		ImportResult::UnknownParent,
+	);
+}
+
+#[test]
+fn storage_keys_prefix_and_start_key_works() {
+	let child_info = ChildInfo::new_default(b"child");
+	let client = TestClientBuilder::new()
+		.add_extra_child_storage(&child_info, b"first".to_vec(), vec![0u8; 32])
+		.add_extra_child_storage(&child_info, b"second".to_vec(), vec![0u8; 32])
+		.add_extra_child_storage(&child_info, b"third".to_vec(), vec![0u8; 32])
+		.build();
+
+	let block_hash = client.info().best_hash;
+
+	let child_root = array_bytes::bytes2hex("", b":child_storage:default:child");
+	let prefix = StorageKey(array_bytes::hex2bytes_unchecked("3a"));
+	let child_prefix = StorageKey(b"sec".to_vec());
+
+	let res: Vec<_> = client
+		.storage_keys(block_hash, Some(&prefix), None)
+		.unwrap()
+		.map(|x| array_bytes::bytes2hex("", &x.0))
+		.collect();
+	assert_eq!(
+		res,
+		[
+			&child_root,
+			"3a636f6465",                       //":code"
+			"3a65787472696e7369635f696e646578", //":extrinsic_index"
+		]
+	);
+
+	let res: Vec<_> = client
+		.storage_keys(
+			block_hash,
+			Some(&prefix),
+			Some(&StorageKey(array_bytes::hex2bytes_unchecked("3a636f6465"))),
+		)
+		.unwrap()
+		.map(|x| array_bytes::bytes2hex("", &x.0))
+		.collect();
+	assert_eq!(res, ["3a65787472696e7369635f696e646578",]);
+
+	let res: Vec<_> = client
+		.storage_keys(
+			block_hash,
+			Some(&prefix),
+			Some(&StorageKey(array_bytes::hex2bytes_unchecked("3a686561707061676573"))),
+		)
+		.unwrap()
+		.map(|x| x.0)
+		.collect();
+	assert_eq!(res, Vec::<Vec<u8>>::new());
+
+	let res: Vec<_> = client
+		.child_storage_keys(block_hash, child_info.clone(), Some(&child_prefix), None)
+		.unwrap()
+		.map(|x| x.0)
+		.collect();
+	assert_eq!(res, [b"second".to_vec()]);
+
+	let res: Vec<_> = client
+		.child_storage_keys(block_hash, child_info, None, Some(&StorageKey(b"second".to_vec())))
+		.unwrap()
+		.map(|x| x.0)
+		.collect();
+	assert_eq!(res, [b"third".to_vec()]);
+}
+
+#[test]
+fn storage_keys_works() {
+	sp_tracing::try_init_simple();
+
+	let expected_keys =
+		substrate_test_runtime::storage_key_generator::get_expected_storage_hashed_keys(false);
+
+	let client = substrate_test_runtime_client::new();
+	let block_hash = client.info().best_hash;
+	let prefix = StorageKey(array_bytes::hex2bytes_unchecked(""));
+
+	let res: Vec<_> = client
+		.storage_keys(block_hash, Some(&prefix), None)
+		.unwrap()
+		.take(19)
+		.map(|x| array_bytes::bytes2hex("", &x.0))
+		.collect();
+
+	assert_eq!(res, expected_keys[0..19],);
+
+	// Starting at an empty key nothing gets skipped.
+	let res: Vec<_> = client
+		.storage_keys(block_hash, Some(&prefix), Some(&StorageKey("".into())))
+		.unwrap()
+		.take(19)
+		.map(|x| array_bytes::bytes2hex("", &x.0))
+		.collect();
+	assert_eq!(res, expected_keys[0..19],);
+
+	// Starting at an incomplete key nothing gets skipped.
+	let res: Vec<_> = client
+		.storage_keys(
+			block_hash,
+			Some(&prefix),
+			Some(&StorageKey(array_bytes::hex2bytes_unchecked("3a636f64"))),
+		)
+		.unwrap()
+		.take(8)
+		.map(|x| array_bytes::bytes2hex("", &x.0))
+		.collect();
+	assert_eq!(
+		res,
+		expected_keys
+			.iter()
+			.filter(|&i| *i > "3a636f64")
+			.take(8)
+			.cloned()
+			.collect::<Vec<_>>()
+	);
+
+	// Starting at a complete key the first key is skipped.
+	let res: Vec<_> = client
+		.storage_keys(
+			block_hash,
+			Some(&prefix),
+			Some(&StorageKey(array_bytes::hex2bytes_unchecked("3a636f6465"))),
+		)
+		.unwrap()
+		.take(7)
+		.map(|x| array_bytes::bytes2hex("", &x.0))
+		.collect();
+	assert_eq!(
+		res,
+		expected_keys
+			.iter()
+			.filter(|&i| *i > "3a636f6465")
+			.take(8)
+			.cloned()
+			.collect::<Vec<_>>()
+	);
+
+	const SOME_BALANCE_KEY : &str = "26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9e2c1dc507e2035edbbd8776c440d870460c57f0008067cc01c5ff9eb2e2f9b3a94299a915a91198bd1021a6c55596f57";
+	let res: Vec<_> = client
+		.storage_keys(
+			block_hash,
+			Some(&prefix),
+			Some(&StorageKey(array_bytes::hex2bytes_unchecked(SOME_BALANCE_KEY))),
+		)
+		.unwrap()
+		.take(8)
+		.map(|x| array_bytes::bytes2hex("", &x.0))
+		.collect();
+	assert_eq!(
+		res,
+		expected_keys
+			.iter()
+			.filter(|&i| *i > SOME_BALANCE_KEY)
+			.take(8)
+			.cloned()
+			.collect::<Vec<_>>()
+	);
+}
+
+#[test]
+fn cleans_up_closed_notification_sinks_on_block_import() {
+	use substrate_test_runtime_client::GenesisInit;
+
+	let backend = Arc::new(sc_client_api::in_mem::Backend::new());
+	let executor = new_native_or_wasm_executor();
+	let client_config = sc_service::ClientConfig::default();
+
+	let genesis_block_builder = sc_service::GenesisBlockBuilder::new(
+		&substrate_test_runtime_client::GenesisParameters::default().genesis_storage(),
+		!client_config.no_genesis,
+		backend.clone(),
+		executor.clone(),
+	)
+	.unwrap();
+
+	// NOTE: we need to build the client here instead of using the client
+	// provided by test_runtime_client otherwise we can't access the private
+	// `import_notification_sinks` and `finality_notification_sinks` fields.
+	let mut client = new_in_mem::<_, Block, _, RuntimeApi>(
+		backend,
+		executor,
+		genesis_block_builder,
+		None,
+		None,
+		Box::new(TaskExecutor::new()),
+		client_config,
+	)
+	.unwrap();
+
+	type TestClient = Client<
+		in_mem::Backend<Block>,
+		LocalCallExecutor<
+			Block,
+			in_mem::Backend<Block>,
+			sc_executor::NativeElseWasmExecutor<LocalExecutorDispatch>,
+		>,
+		Block,
+		RuntimeApi,
+	>;
+
+	let import_notif1 = client.import_notification_stream();
+	let import_notif2 = client.import_notification_stream();
+	let finality_notif1 = client.finality_notification_stream();
+	let finality_notif2 = client.finality_notification_stream();
+
+	// for some reason I can't seem to use `ClientBlockImportExt`
+	let bake_and_import_block = |client: &mut TestClient, origin| {
+		let block = client.new_block(Default::default()).unwrap().build().unwrap().block;
+
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.body = Some(extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+		block_on(client.import_block(import)).unwrap();
+	};
+
+	// after importing a block we should still have 4 notification sinks
+	// (2 import + 2 finality)
+	bake_and_import_block(&mut client, BlockOrigin::Own);
+	assert_eq!(client.import_notification_sinks().lock().len(), 2);
+	assert_eq!(client.finality_notification_sinks().lock().len(), 2);
+
+	// if we drop one import notification receiver and one finality
+	// notification receiver
+	drop(import_notif2);
+	drop(finality_notif2);
+
+	// the sinks should be cleaned up after block import
+	bake_and_import_block(&mut client, BlockOrigin::Own);
+	assert_eq!(client.import_notification_sinks().lock().len(), 1);
+	assert_eq!(client.finality_notification_sinks().lock().len(), 1);
+
+	// the same thing should happen if block import happens during initial
+	// sync
+	drop(import_notif1);
+	drop(finality_notif1);
+
+	bake_and_import_block(&mut client, BlockOrigin::NetworkInitialSync);
+	assert_eq!(client.import_notification_sinks().lock().len(), 0);
+	assert_eq!(client.finality_notification_sinks().lock().len(), 0);
+}
+
+/// Test that ensures that we always send an import notification for re-orgs.
+#[test]
+fn reorg_triggers_a_notification_even_for_sources_that_should_not_trigger_notifications() {
+	let mut client = TestClientBuilder::new().build();
+
+	let mut notification_stream =
+		futures::executor::block_on_stream(client.import_notification_stream());
+
+	let a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::NetworkInitialSync, a1.clone())).unwrap();
+
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::NetworkInitialSync, a2.clone())).unwrap();
+
+	let mut b1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap();
+	// needed to make sure B1 gets a different hash from A1
+	b1.push_transfer(Transfer {
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Ferdie.into(),
+		amount: 1 * DOLLARS,
+		nonce: 0,
+	})
+	.unwrap();
+	let b1 = b1.build().unwrap().block;
+	block_on(client.import(BlockOrigin::NetworkInitialSync, b1.clone())).unwrap();
+
+	let b2 = client
+		.new_block_at(b1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	// Should trigger a notification because we reorg
+	block_on(client.import_as_best(BlockOrigin::NetworkInitialSync, b2.clone())).unwrap();
+
+	// There should be one notification
+	let notification = notification_stream.next().unwrap();
+
+	// We should have a tree route of the re-org
+	let tree_route = notification.tree_route.unwrap();
+	assert_eq!(tree_route.enacted()[0].hash, b1.hash());
+}
+
+#[test]
+fn use_dalek_ext_works() {
+	fn zero_ed_pub() -> sp_core::ed25519::Public {
+		sp_core::ed25519::Public([0u8; 32])
+	}
+
+	fn zero_ed_sig() -> sp_core::ed25519::Signature {
+		sp_core::ed25519::Signature::from_raw([0u8; 64])
+	}
+
+	let mut client = TestClientBuilder::new().build();
+
+	client.execution_extensions().set_extensions_factory(
+		sc_client_api::execution_extensions::ExtensionBeforeBlock::<Block, sp_io::UseDalekExt>::new(
+			1,
+		),
+	);
+
+	let a1 = client
+		.new_block_at(client.chain_info().genesis_hash, Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::NetworkInitialSync, a1.clone())).unwrap();
+
+	// On block zero it will use dalek and then on block 1 it will use zebra
+	assert!(!client
+		.runtime_api()
+		.verify_ed25519(client.chain_info().genesis_hash, zero_ed_sig(), zero_ed_pub(), vec![])
+		.unwrap());
+	assert!(client
+		.runtime_api()
+		.verify_ed25519(a1.hash(), zero_ed_sig(), zero_ed_pub(), vec![])
+		.unwrap());
+}
+
+#[test]
+fn finalize_after_best_block_updates_best() {
+	let mut client = substrate_test_runtime_client::new();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	// A2 -> A3
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	let (header, extrinsics) = a3.clone().deconstruct();
+	let mut import_params = BlockImportParams::new(BlockOrigin::Own, header);
+	import_params.body = Some(extrinsics);
+	import_params.fork_choice = Some(ForkChoiceStrategy::Custom(false));
+	block_on(client.import_block(import_params)).unwrap();
+
+	assert_eq!(client.chain_info().best_hash, a2.hash());
+
+	client.finalize_block(a3.hash(), None).unwrap();
+
+	assert_eq!(client.chain_info().finalized_hash, a3.hash());
+	assert_eq!(client.chain_info().best_hash, a3.hash());
+}
diff --git a/substrate/client/service/test/src/lib.rs b/substrate/client/service/test/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..38a811acc7401986f3f4b1f07d53fae8f32d0e98
--- /dev/null
+++ b/substrate/client/service/test/src/lib.rs
@@ -0,0 +1,577 @@
+// 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/>.
+
+//! Service integration test utils.
+
+use futures::{task::Poll, Future, TryFutureExt as _};
+use log::{debug, info};
+use parking_lot::Mutex;
+use sc_client_api::{Backend, CallExecutor};
+use sc_network::{
+	config::{MultiaddrWithPeerId, NetworkConfiguration, TransportConfig},
+	multiaddr, NetworkBlock, NetworkPeers, NetworkStateInfo,
+};
+use sc_network_sync::SyncingService;
+use sc_service::{
+	client::Client,
+	config::{BasePath, DatabaseSource, KeystoreConfig},
+	BlocksPruning, ChainSpecExtension, Configuration, Error, GenericChainSpec, Role,
+	RuntimeGenesis, SpawnTaskHandle, TaskManager,
+};
+use sc_transaction_pool_api::TransactionPool;
+use sp_api::BlockId;
+use sp_blockchain::HeaderBackend;
+use sp_runtime::traits::Block as BlockT;
+use std::{iter, net::Ipv4Addr, pin::Pin, sync::Arc, task::Context, time::Duration};
+use tempfile::TempDir;
+use tokio::{runtime::Runtime, time};
+
+#[cfg(test)]
+mod client;
+
+/// Maximum duration of single wait call.
+const MAX_WAIT_TIME: Duration = Duration::from_secs(60 * 3);
+
+struct TestNet<G, E, F, U> {
+	runtime: Runtime,
+	authority_nodes: Vec<(usize, F, U, MultiaddrWithPeerId)>,
+	full_nodes: Vec<(usize, F, U, MultiaddrWithPeerId)>,
+	chain_spec: GenericChainSpec<G, E>,
+	base_port: u16,
+	nodes: usize,
+}
+
+impl<G, E, F, U> Drop for TestNet<G, 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.
+		self.full_nodes.drain(..);
+		self.authority_nodes.drain(..);
+	}
+}
+
+pub trait TestNetNode: Clone + Future<Output = Result<(), Error>> + Send + 'static {
+	type Block: BlockT;
+	type Backend: Backend<Self::Block>;
+	type Executor: CallExecutor<Self::Block> + Send + Sync;
+	type RuntimeApi: Send + Sync;
+	type TransactionPool: TransactionPool<Block = Self::Block>;
+
+	fn client(&self) -> Arc<Client<Self::Backend, Self::Executor, Self::Block, Self::RuntimeApi>>;
+	fn transaction_pool(&self) -> Arc<Self::TransactionPool>;
+	fn network(
+		&self,
+	) -> Arc<sc_network::NetworkService<Self::Block, <Self::Block as BlockT>::Hash>>;
+	fn sync(&self) -> &Arc<SyncingService<Self::Block>>;
+	fn spawn_handle(&self) -> SpawnTaskHandle;
+}
+
+pub struct TestNetComponents<TBl: BlockT, TBackend, TExec, TRtApi, TExPool> {
+	task_manager: Arc<Mutex<TaskManager>>,
+	client: Arc<Client<TBackend, TExec, TBl, TRtApi>>,
+	transaction_pool: Arc<TExPool>,
+	network: Arc<sc_network::NetworkService<TBl, <TBl as BlockT>::Hash>>,
+	sync: Arc<SyncingService<TBl>>,
+}
+
+impl<TBl: BlockT, TBackend, TExec, TRtApi, TExPool>
+	TestNetComponents<TBl, TBackend, TExec, TRtApi, TExPool>
+{
+	pub fn new(
+		task_manager: TaskManager,
+		client: Arc<Client<TBackend, TExec, TBl, TRtApi>>,
+		network: Arc<sc_network::NetworkService<TBl, <TBl as BlockT>::Hash>>,
+		sync: Arc<SyncingService<TBl>>,
+		transaction_pool: Arc<TExPool>,
+	) -> Self {
+		Self {
+			client,
+			sync,
+			transaction_pool,
+			network,
+			task_manager: Arc::new(Mutex::new(task_manager)),
+		}
+	}
+}
+
+impl<TBl: BlockT, TBackend, TExec, TRtApi, TExPool> Clone
+	for TestNetComponents<TBl, TBackend, TExec, TRtApi, TExPool>
+{
+	fn clone(&self) -> Self {
+		Self {
+			task_manager: self.task_manager.clone(),
+			client: self.client.clone(),
+			transaction_pool: self.transaction_pool.clone(),
+			network: self.network.clone(),
+			sync: self.sync.clone(),
+		}
+	}
+}
+
+impl<TBl: BlockT, TBackend, TExec, TRtApi, TExPool> Future
+	for TestNetComponents<TBl, TBackend, TExec, TRtApi, TExPool>
+{
+	type Output = Result<(), Error>;
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		Pin::new(&mut self.task_manager.lock().future()).poll(cx)
+	}
+}
+
+impl<TBl, TBackend, TExec, TRtApi, TExPool> TestNetNode
+	for TestNetComponents<TBl, TBackend, TExec, TRtApi, TExPool>
+where
+	TBl: BlockT,
+	TBackend: sc_client_api::Backend<TBl> + Send + Sync + 'static,
+	TExec: CallExecutor<TBl> + Send + Sync + 'static,
+	TRtApi: Send + Sync + 'static,
+	TExPool: TransactionPool<Block = TBl> + Send + Sync + 'static,
+{
+	type Block = TBl;
+	type Backend = TBackend;
+	type Executor = TExec;
+	type RuntimeApi = TRtApi;
+	type TransactionPool = TExPool;
+
+	fn client(&self) -> Arc<Client<Self::Backend, Self::Executor, Self::Block, Self::RuntimeApi>> {
+		self.client.clone()
+	}
+	fn transaction_pool(&self) -> Arc<Self::TransactionPool> {
+		self.transaction_pool.clone()
+	}
+	fn network(
+		&self,
+	) -> Arc<sc_network::NetworkService<Self::Block, <Self::Block as BlockT>::Hash>> {
+		self.network.clone()
+	}
+	fn sync(&self) -> &Arc<SyncingService<Self::Block>> {
+		&self.sync
+	}
+	fn spawn_handle(&self) -> SpawnTaskHandle {
+		self.task_manager.lock().spawn_handle()
+	}
+}
+
+impl<G, E, F, U> TestNet<G, E, F, U>
+where
+	F: Clone + Send + 'static,
+	U: Clone + Send + 'static,
+{
+	pub fn run_until_all_full<FP>(&mut self, full_predicate: FP)
+	where
+		FP: Send + Fn(usize, &F) -> bool + 'static,
+	{
+		let full_nodes = self.full_nodes.clone();
+		let future = async move {
+			let mut interval = time::interval(Duration::from_millis(100));
+			loop {
+				interval.tick().await;
+
+				if full_nodes.iter().all(|(id, service, _, _)| full_predicate(*id, service)) {
+					break
+				}
+			}
+		};
+
+		if self
+			.runtime
+			.block_on(async move { time::timeout(MAX_WAIT_TIME, future).await })
+			.is_err()
+		{
+			panic!("Waited for too long");
+		}
+	}
+}
+
+fn node_config<
+	G: RuntimeGenesis + 'static,
+	E: ChainSpecExtension + Clone + 'static + Send + Sync,
+>(
+	index: usize,
+	spec: &GenericChainSpec<G, E>,
+	role: Role,
+	tokio_handle: tokio::runtime::Handle,
+	key_seed: Option<String>,
+	base_port: u16,
+	root: &TempDir,
+) -> Configuration {
+	let root = root.path().join(format!("node-{}", index));
+
+	let mut network_config = NetworkConfiguration::new(
+		format!("Node {}", index),
+		"network/test/0.1",
+		Default::default(),
+		None,
+	);
+
+	network_config.allow_non_globals_in_dht = true;
+
+	network_config.listen_addresses.push(
+		iter::once(multiaddr::Protocol::Ip4(Ipv4Addr::new(127, 0, 0, 1)))
+			.chain(iter::once(multiaddr::Protocol::Tcp(base_port + index as u16)))
+			.collect(),
+	);
+
+	network_config.transport =
+		TransportConfig::Normal { enable_mdns: false, allow_private_ip: true };
+
+	Configuration {
+		impl_name: String::from("network-test-impl"),
+		impl_version: String::from("0.1"),
+		role,
+		tokio_handle,
+		transaction_pool: Default::default(),
+		network: network_config,
+		keystore: KeystoreConfig::Path { path: root.join("key"), password: None },
+		database: DatabaseSource::RocksDb { path: root.join("db"), cache_size: 128 },
+		trie_cache_maximum_size: Some(16 * 1024 * 1024),
+		state_pruning: Default::default(),
+		blocks_pruning: BlocksPruning::KeepFinalized,
+		chain_spec: Box::new((*spec).clone()),
+		wasm_method: Default::default(),
+		wasm_runtime_overrides: Default::default(),
+		rpc_addr: Default::default(),
+		rpc_max_connections: Default::default(),
+		rpc_cors: None,
+		rpc_methods: Default::default(),
+		rpc_max_request_size: Default::default(),
+		rpc_max_response_size: Default::default(),
+		rpc_id_provider: Default::default(),
+		rpc_max_subs_per_conn: Default::default(),
+		rpc_port: 9944,
+		prometheus_config: None,
+		telemetry_endpoints: None,
+		default_heap_pages: None,
+		offchain_worker: Default::default(),
+		force_authoring: false,
+		disable_grandpa: false,
+		dev_key_seed: key_seed,
+		tracing_targets: None,
+		tracing_receiver: Default::default(),
+		max_runtime_instances: 8,
+		announce_block: true,
+		base_path: BasePath::new(root.clone()),
+		data_path: root,
+		informant_output_format: Default::default(),
+		runtime_cache_size: 2,
+	}
+}
+
+impl<G, E, F, U> TestNet<G, E, F, U>
+where
+	F: TestNetNode,
+	E: ChainSpecExtension + Clone + 'static + Send + Sync,
+	G: RuntimeGenesis + 'static,
+{
+	fn new(
+		temp: &TempDir,
+		spec: GenericChainSpec<G, 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> {
+		sp_tracing::try_init_simple();
+		fdlimit::raise_fd_limit();
+		let runtime = Runtime::new().expect("Error creating tokio runtime");
+		let mut net = TestNet {
+			runtime,
+			authority_nodes: Default::default(),
+			full_nodes: Default::default(),
+			chain_spec: spec,
+			base_port,
+			nodes: 0,
+		};
+		net.insert_nodes(temp, full, authorities);
+		net
+	}
+
+	fn insert_nodes(
+		&mut self,
+		temp: &TempDir,
+		full: impl Iterator<Item = impl FnOnce(Configuration) -> Result<(F, U), Error>>,
+		authorities: impl Iterator<Item = (String, impl FnOnce(Configuration) -> Result<(F, U), Error>)>,
+	) {
+		self.runtime.block_on(async {
+			let handle = self.runtime.handle().clone();
+
+			for (key, authority) in authorities {
+				let node_config = node_config(
+					self.nodes,
+					&self.chain_spec,
+					Role::Authority,
+					handle.clone(),
+					Some(key),
+					self.base_port,
+					temp,
+				);
+				let addr = node_config.network.listen_addresses.first().unwrap().clone();
+				let (service, user_data) =
+					authority(node_config).expect("Error creating test node service");
+
+				handle.spawn(service.clone().map_err(|_| ()));
+				let addr = MultiaddrWithPeerId {
+					multiaddr: addr,
+					peer_id: service.network().local_peer_id(),
+				};
+				self.authority_nodes.push((self.nodes, service, user_data, addr));
+				self.nodes += 1;
+			}
+
+			for full in full {
+				let node_config = node_config(
+					self.nodes,
+					&self.chain_spec,
+					Role::Full,
+					handle.clone(),
+					None,
+					self.base_port,
+					temp,
+				);
+				let addr = node_config.network.listen_addresses.first().unwrap().clone();
+				let (service, user_data) =
+					full(node_config).expect("Error creating test node service");
+
+				handle.spawn(service.clone().map_err(|_| ()));
+				let addr = MultiaddrWithPeerId {
+					multiaddr: addr,
+					peer_id: service.network().local_peer_id(),
+				};
+				self.full_nodes.push((self.nodes, service, user_data, addr));
+				self.nodes += 1;
+			}
+		});
+	}
+}
+
+fn tempdir_with_prefix(prefix: &str) -> TempDir {
+	tempfile::Builder::new()
+		.prefix(prefix)
+		.tempdir()
+		.expect("Error creating test dir")
+}
+
+pub fn connectivity<G, E, Fb, F>(spec: GenericChainSpec<G, E>, full_builder: Fb)
+where
+	E: ChainSpecExtension + Clone + 'static + Send + Sync,
+	G: RuntimeGenesis + 'static,
+	Fb: Fn(Configuration) -> Result<F, Error>,
+	F: TestNetNode,
+{
+	const NUM_FULL_NODES: usize = 5;
+
+	let expected_full_connections = NUM_FULL_NODES - 1;
+
+	{
+		let temp = tempdir_with_prefix("substrate-connectivity-test");
+		{
+			let mut network = TestNet::new(
+				&temp,
+				spec.clone(),
+				(0..NUM_FULL_NODES).map(|_| |cfg| full_builder(cfg).map(|s| (s, ()))),
+				// Note: this iterator is empty but we can't just use `iter::empty()`, otherwise
+				// the type of the closure cannot be inferred.
+				(0..0).map(|_| (String::new(), { |cfg| full_builder(cfg).map(|s| (s, ())) })),
+				30400,
+			);
+			info!("Checking star topology");
+			let first_address = network.full_nodes[0].3.clone();
+			for (_, service, _, _) in network.full_nodes.iter().skip(1) {
+				service
+					.network()
+					.add_reserved_peer(first_address.clone())
+					.expect("Error adding reserved peer");
+			}
+
+			network.run_until_all_full(move |_index, service| {
+				let connected = service.network().sync_num_connected();
+				debug!("Got {}/{} full connections...", connected, expected_full_connections);
+				connected == expected_full_connections
+			});
+		};
+
+		temp.close().expect("Error removing temp dir");
+	}
+	{
+		let temp = tempdir_with_prefix("substrate-connectivity-test");
+		{
+			let mut network = TestNet::new(
+				&temp,
+				spec,
+				(0..NUM_FULL_NODES).map(|_| |cfg| full_builder(cfg).map(|s| (s, ()))),
+				// Note: this iterator is empty but we can't just use `iter::empty()`, otherwise
+				// the type of the closure cannot be inferred.
+				(0..0).map(|_| (String::new(), { |cfg| full_builder(cfg).map(|s| (s, ())) })),
+				30400,
+			);
+			info!("Checking linked topology");
+			let mut address = network.full_nodes[0].3.clone();
+			for i in 0..NUM_FULL_NODES {
+				if i != 0 {
+					if let Some((_, service, _, node_id)) = network.full_nodes.get(i) {
+						service
+							.network()
+							.add_reserved_peer(address)
+							.expect("Error adding reserved peer");
+						address = node_id.clone();
+					}
+				}
+			}
+
+			network.run_until_all_full(move |_index, service| {
+				let connected = service.network().sync_num_connected();
+				debug!("Got {}/{} full connections...", connected, expected_full_connections);
+				connected == expected_full_connections
+			});
+		}
+		temp.close().expect("Error removing temp dir");
+	}
+}
+
+pub fn sync<G, E, Fb, F, B, ExF, U>(
+	spec: GenericChainSpec<G, E>,
+	full_builder: Fb,
+	mut make_block_and_import: B,
+	mut extrinsic_factory: ExF,
+) where
+	Fb: Fn(Configuration) -> Result<(F, U), Error>,
+	F: TestNetNode,
+	B: FnMut(&F, &mut 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;
+	let temp = tempdir_with_prefix("substrate-sync-test");
+	let mut network = TestNet::new(
+		&temp,
+		spec,
+		(0..NUM_FULL_NODES).map(|_| |cfg| full_builder(cfg)),
+		// Note: this iterator is empty but we can't just use `iter::empty()`, otherwise
+		// the type of the closure cannot be inferred.
+		(0..0).map(|_| (String::new(), { |cfg| full_builder(cfg) })),
+		30500,
+	);
+	info!("Checking block sync");
+	let first_address = {
+		let &mut (_, ref first_service, ref mut first_user_data, _) = &mut network.full_nodes[0];
+		for i in 0..NUM_BLOCKS {
+			if i % 128 == 0 {
+				info!("Generating #{}", i + 1);
+			}
+
+			make_block_and_import(first_service, first_user_data);
+		}
+		let info = network.full_nodes[0].1.client().info();
+		network.full_nodes[0]
+			.1
+			.sync()
+			.new_best_block_imported(info.best_hash, info.best_number);
+		network.full_nodes[0].3.clone()
+	};
+
+	info!("Running sync");
+	for (_, service, _, _) in network.full_nodes.iter().skip(1) {
+		service
+			.network()
+			.add_reserved_peer(first_address.clone())
+			.expect("Error adding reserved peer");
+	}
+
+	network.run_until_all_full(|_index, service| {
+		service.client().info().best_number == (NUM_BLOCKS as u32).into()
+	});
+
+	info!("Checking extrinsic propagation");
+	let first_service = network.full_nodes[0].1.clone();
+	let first_user_data = &network.full_nodes[0].2;
+	let best_block = BlockId::number(first_service.client().info().best_number);
+	let extrinsic = extrinsic_factory(&first_service, first_user_data);
+	let source = sc_transaction_pool_api::TransactionSource::External;
+
+	futures::executor::block_on(first_service.transaction_pool().submit_one(
+		&best_block,
+		source,
+		extrinsic,
+	))
+	.expect("failed to submit extrinsic");
+
+	network.run_until_all_full(|_index, service| service.transaction_pool().ready().count() == 1);
+}
+
+pub fn consensus<G, E, Fb, F>(
+	spec: GenericChainSpec<G, 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
+	let temp = tempdir_with_prefix("substrate-consensus-test");
+	let mut network = TestNet::new(
+		&temp,
+		spec,
+		(0..NUM_FULL_NODES / 2).map(|_| |cfg| full_builder(cfg).map(|s| (s, ()))),
+		authorities
+			.into_iter()
+			.map(|key| (key, { |cfg| full_builder(cfg).map(|s| (s, ())) })),
+		30600,
+	);
+
+	info!("Checking consensus");
+	let first_address = network.authority_nodes[0].3.clone();
+	for (_, service, _, _) in network.full_nodes.iter() {
+		service
+			.network()
+			.add_reserved_peer(first_address.clone())
+			.expect("Error adding reserved peer");
+	}
+	for (_, service, _, _) in network.authority_nodes.iter().skip(1) {
+		service
+			.network()
+			.add_reserved_peer(first_address.clone())
+			.expect("Error adding reserved peer");
+	}
+	network.run_until_all_full(|_index, service| {
+		service.client().info().finalized_number >= (NUM_BLOCKS as u32 / 2).into()
+	});
+
+	info!("Adding more peers");
+	network.insert_nodes(
+		&temp,
+		(0..NUM_FULL_NODES / 2).map(|_| |cfg| full_builder(cfg).map(|s| (s, ()))),
+		// Note: this iterator is empty but we can't just use `iter::empty()`, otherwise
+		// the type of the closure cannot be inferred.
+		(0..0).map(|_| (String::new(), { |cfg| full_builder(cfg).map(|s| (s, ())) })),
+	);
+	for (_, service, _, _) in network.full_nodes.iter() {
+		service
+			.network()
+			.add_reserved_peer(first_address.clone())
+			.expect("Error adding reserved peer");
+	}
+
+	network.run_until_all_full(|_index, service| {
+		service.client().info().finalized_number >= (NUM_BLOCKS as u32).into()
+	});
+}
diff --git a/substrate/client/state-db/Cargo.toml b/substrate/client/state-db/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f7df4e9c8ce3f8885abd8a127c6cfc1d737f89af
--- /dev/null
+++ b/substrate/client/state-db/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "sc-state-db"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "State database maintenance. Handles canonicalization and pruning in the database."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+log = "0.4.17"
+parking_lot = "0.12.1"
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
diff --git a/substrate/client/state-db/README.md b/substrate/client/state-db/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a02b3929088fc8289a22d4a372101ca703cb6876
--- /dev/null
+++ b/substrate/client/state-db/README.md
@@ -0,0 +1,16 @@
+State database maintenance. Handles canonicalization and pruning in the database. The input to
+this module is a `ChangeSet` which is basically a list of key-value pairs (trie nodes) that
+were added or deleted during block execution.
+
+# Canonicalization.
+Canonicalization window tracks a tree of blocks identified by header hash. The in-memory
+overlay allows to get any node that was inserted in any of the blocks within the window.
+The tree is journaled to the backing database and rebuilt on startup.
+Canonicalization function selects one root from the top of the tree and discards all other roots and
+their subtrees.
+
+# Pruning.
+See `RefWindow` for pruning algorithm details. `StateDb` prunes on each canonicalization until pruning
+constraints are satisfied.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/state-db/src/lib.rs b/substrate/client/state-db/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c656f126ae6eba9c070d137d234ed1af73214158
--- /dev/null
+++ b/substrate/client/state-db/src/lib.rs
@@ -0,0 +1,949 @@
+// 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/>.
+
+//! State database maintenance. Handles canonicalization and pruning in the database.
+//!
+//! # Canonicalization.
+//! Canonicalization window tracks a tree of blocks identified by header hash. The in-memory
+//! overlay allows to get any trie node that was inserted in any of the blocks within the window.
+//! The overlay is journaled to the backing database and rebuilt on startup.
+//! There's a limit of 32 blocks that may have the same block number in the canonicalization window.
+//!
+//! Canonicalization function selects one root from the top of the tree and discards all other roots
+//! and their subtrees. Upon canonicalization all trie nodes that were inserted in the block are
+//! added to the backing DB and block tracking is moved to the pruning window, where no forks are
+//! allowed.
+//!
+//! # Canonicalization vs Finality
+//! Database engine uses a notion of canonicality, rather then finality. A canonical block may not
+//! be yet finalized from the perspective of the consensus engine, but it still can't be reverted in
+//! the database. Most of the time during normal operation last canonical block is the same as last
+//! finalized. However if finality stall for a long duration for some reason, there's only a certain
+//! number of blocks that can fit in the non-canonical overlay, so canonicalization of an
+//! unfinalized block may be forced.
+//!
+//! # Pruning.
+//! See `RefWindow` for pruning algorithm details. `StateDb` prunes on each canonicalization until
+//! pruning constraints are satisfied.
+
+mod noncanonical;
+mod pruning;
+#[cfg(test)]
+mod test;
+
+use codec::Codec;
+use log::trace;
+use noncanonical::NonCanonicalOverlay;
+use parking_lot::RwLock;
+use pruning::{HaveBlock, RefWindow};
+use std::{
+	collections::{hash_map::Entry, HashMap},
+	fmt,
+};
+
+const LOG_TARGET: &str = "state-db";
+const LOG_TARGET_PIN: &str = "state-db::pin";
+const PRUNING_MODE: &[u8] = b"mode";
+const PRUNING_MODE_ARCHIVE: &[u8] = b"archive";
+const PRUNING_MODE_ARCHIVE_CANON: &[u8] = b"archive_canonical";
+const PRUNING_MODE_CONSTRAINED: &[u8] = b"constrained";
+pub(crate) const DEFAULT_MAX_BLOCK_CONSTRAINT: u32 = 256;
+
+/// Database value type.
+pub type DBValue = Vec<u8>;
+
+/// Basic set of requirements for the Block hash and node key types.
+pub trait Hash:
+	Send
+	+ Sync
+	+ Sized
+	+ Eq
+	+ PartialEq
+	+ Clone
+	+ Default
+	+ fmt::Debug
+	+ Codec
+	+ std::hash::Hash
+	+ 'static
+{
+}
+impl<
+		T: Send
+			+ Sync
+			+ Sized
+			+ Eq
+			+ PartialEq
+			+ Clone
+			+ Default
+			+ fmt::Debug
+			+ Codec
+			+ std::hash::Hash
+			+ 'static,
+	> Hash for T
+{
+}
+
+/// Backend database trait. Read-only.
+pub trait MetaDb {
+	type Error: fmt::Debug;
+
+	/// Get meta value, such as the journal.
+	fn get_meta(&self, key: &[u8]) -> Result<Option<DBValue>, Self::Error>;
+}
+
+/// Backend database trait. Read-only.
+pub trait NodeDb {
+	type Key: ?Sized;
+	type Error: fmt::Debug;
+
+	/// Get state trie node.
+	fn get(&self, key: &Self::Key) -> Result<Option<DBValue>, Self::Error>;
+}
+
+/// Error type.
+#[derive(Eq, PartialEq)]
+pub enum Error<E> {
+	/// Database backend error.
+	Db(E),
+	StateDb(StateDbError),
+}
+
+#[derive(Eq, PartialEq)]
+pub enum StateDbError {
+	/// `Codec` decoding error.
+	Decoding(codec::Error),
+	/// Trying to canonicalize invalid block.
+	InvalidBlock,
+	/// Trying to insert block with invalid number.
+	InvalidBlockNumber,
+	/// Trying to insert block with unknown parent.
+	InvalidParent,
+	/// Invalid pruning mode specified. Contains expected mode.
+	IncompatiblePruningModes { stored: PruningMode, requested: PruningMode },
+	/// Too many unfinalized sibling blocks inserted.
+	TooManySiblingBlocks { number: u64 },
+	/// Trying to insert existing block.
+	BlockAlreadyExists,
+	/// Invalid metadata
+	Metadata(String),
+	/// Trying to get a block record from db while it is not commit to db yet
+	BlockUnavailable,
+	/// Block record is missing from the pruning window
+	BlockMissing,
+}
+
+impl<E> From<StateDbError> for Error<E> {
+	fn from(inner: StateDbError) -> Self {
+		Self::StateDb(inner)
+	}
+}
+
+/// Pinning error type.
+#[derive(Debug)]
+pub enum PinError {
+	/// Trying to pin invalid block.
+	InvalidBlock,
+}
+
+impl<E: fmt::Debug> From<codec::Error> for Error<E> {
+	fn from(x: codec::Error) -> Self {
+		StateDbError::Decoding(x).into()
+	}
+}
+
+impl<E: fmt::Debug> fmt::Debug for Error<E> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			Self::Db(e) => e.fmt(f),
+			Self::StateDb(e) => e.fmt(f),
+		}
+	}
+}
+
+impl fmt::Debug for StateDbError {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		match self {
+			Self::Decoding(e) => write!(f, "Error decoding sliceable value: {}", e),
+			Self::InvalidBlock => write!(f, "Trying to canonicalize invalid block"),
+			Self::InvalidBlockNumber => write!(f, "Trying to insert block with invalid number"),
+			Self::InvalidParent => write!(f, "Trying to insert block with unknown parent"),
+			Self::IncompatiblePruningModes { stored, requested } => write!(
+				f,
+				"Incompatible pruning modes [stored: {:?}; requested: {:?}]",
+				stored, requested
+			),
+			Self::TooManySiblingBlocks { number } => {
+				write!(f, "Too many sibling blocks at #{number} inserted")
+			},
+			Self::BlockAlreadyExists => write!(f, "Block already exists"),
+			Self::Metadata(message) => write!(f, "Invalid metadata: {}", message),
+			Self::BlockUnavailable => {
+				write!(f, "Trying to get a block record from db while it is not commit to db yet")
+			},
+			Self::BlockMissing => write!(f, "Block record is missing from the pruning window"),
+		}
+	}
+}
+
+/// A set of state node changes.
+#[derive(Default, Debug, Clone)]
+pub struct ChangeSet<H: Hash> {
+	/// Inserted nodes.
+	pub inserted: Vec<(H, DBValue)>,
+	/// Deleted nodes.
+	pub deleted: Vec<H>,
+}
+
+/// A set of changes to the backing database.
+#[derive(Default, Debug, Clone)]
+pub struct CommitSet<H: Hash> {
+	/// State node changes.
+	pub data: ChangeSet<H>,
+	/// Metadata changes.
+	pub meta: ChangeSet<Vec<u8>>,
+}
+
+/// Pruning constraints. If none are specified pruning is
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Constraints {
+	/// Maximum blocks. Defaults to 0 when unspecified, effectively keeping only non-canonical
+	/// states.
+	pub max_blocks: Option<u32>,
+}
+
+/// Pruning mode.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum PruningMode {
+	/// Maintain a pruning window.
+	Constrained(Constraints),
+	/// No pruning. Canonicalization is a no-op.
+	ArchiveAll,
+	/// Canonicalization discards non-canonical nodes. All the canonical nodes are kept in the DB.
+	ArchiveCanonical,
+}
+
+impl PruningMode {
+	/// Create a mode that keeps given number of blocks.
+	pub fn blocks_pruning(n: u32) -> PruningMode {
+		PruningMode::Constrained(Constraints { max_blocks: Some(n) })
+	}
+
+	/// Is this an archive (either ArchiveAll or ArchiveCanonical) pruning mode?
+	pub fn is_archive(&self) -> bool {
+		match *self {
+			PruningMode::ArchiveAll | PruningMode::ArchiveCanonical => true,
+			PruningMode::Constrained(_) => false,
+		}
+	}
+
+	/// Returns the pruning mode
+	pub fn id(&self) -> &[u8] {
+		match self {
+			PruningMode::ArchiveAll => PRUNING_MODE_ARCHIVE,
+			PruningMode::ArchiveCanonical => PRUNING_MODE_ARCHIVE_CANON,
+			PruningMode::Constrained(_) => PRUNING_MODE_CONSTRAINED,
+		}
+	}
+
+	pub fn from_id(id: &[u8]) -> Option<Self> {
+		match id {
+			PRUNING_MODE_ARCHIVE => Some(Self::ArchiveAll),
+			PRUNING_MODE_ARCHIVE_CANON => Some(Self::ArchiveCanonical),
+			PRUNING_MODE_CONSTRAINED => Some(Self::Constrained(Default::default())),
+			_ => None,
+		}
+	}
+}
+
+impl Default for PruningMode {
+	fn default() -> Self {
+		PruningMode::Constrained(Default::default())
+	}
+}
+
+impl Default for Constraints {
+	fn default() -> Self {
+		Self { max_blocks: Some(DEFAULT_MAX_BLOCK_CONSTRAINT) }
+	}
+}
+
+fn to_meta_key<S: Codec>(suffix: &[u8], data: &S) -> Vec<u8> {
+	let mut buffer = data.encode();
+	buffer.extend(suffix);
+	buffer
+}
+
+/// Status information about the last canonicalized block.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum LastCanonicalized {
+	/// Not yet have canonicalized any block.
+	None,
+	/// The given block number is the last canonicalized block.
+	Block(u64),
+	/// No canonicalization is happening (pruning mode is archive all).
+	NotCanonicalizing,
+}
+
+pub struct StateDbSync<BlockHash: Hash, Key: Hash, D: MetaDb> {
+	mode: PruningMode,
+	non_canonical: NonCanonicalOverlay<BlockHash, Key>,
+	pruning: Option<RefWindow<BlockHash, Key, D>>,
+	pinned: HashMap<BlockHash, u32>,
+	ref_counting: bool,
+}
+
+impl<BlockHash: Hash, Key: Hash, D: MetaDb> StateDbSync<BlockHash, Key, D> {
+	fn new(
+		mode: PruningMode,
+		ref_counting: bool,
+		db: D,
+	) -> Result<StateDbSync<BlockHash, Key, D>, Error<D::Error>> {
+		trace!(target: LOG_TARGET, "StateDb settings: {:?}. Ref-counting: {}", mode, ref_counting);
+
+		let non_canonical: NonCanonicalOverlay<BlockHash, Key> = NonCanonicalOverlay::new(&db)?;
+		let pruning: Option<RefWindow<BlockHash, Key, D>> = match mode {
+			PruningMode::Constrained(Constraints { max_blocks }) =>
+				Some(RefWindow::new(db, max_blocks.unwrap_or(0), ref_counting)?),
+			PruningMode::ArchiveAll | PruningMode::ArchiveCanonical => None,
+		};
+
+		Ok(StateDbSync { mode, non_canonical, pruning, pinned: Default::default(), ref_counting })
+	}
+
+	fn insert_block(
+		&mut self,
+		hash: &BlockHash,
+		number: u64,
+		parent_hash: &BlockHash,
+		mut changeset: ChangeSet<Key>,
+	) -> Result<CommitSet<Key>, Error<D::Error>> {
+		match self.mode {
+			PruningMode::ArchiveAll => {
+				changeset.deleted.clear();
+				// write changes immediately
+				Ok(CommitSet { data: changeset, meta: Default::default() })
+			},
+			PruningMode::Constrained(_) | PruningMode::ArchiveCanonical => self
+				.non_canonical
+				.insert(hash, number, parent_hash, changeset)
+				.map_err(Into::into),
+		}
+	}
+
+	fn canonicalize_block(&mut self, hash: &BlockHash) -> Result<CommitSet<Key>, Error<D::Error>> {
+		// NOTE: it is important that the change to `LAST_CANONICAL` (emit from
+		// `non_canonical.canonicalize`) and the insert of the new pruning journal (emit from
+		// `pruning.note_canonical`) are collected into the same `CommitSet` and are committed to
+		// the database atomically to keep their consistency when restarting the node
+		let mut commit = CommitSet::default();
+		if self.mode == PruningMode::ArchiveAll {
+			return Ok(commit)
+		}
+		let number = self.non_canonical.canonicalize(hash, &mut commit)?;
+		if self.mode == PruningMode::ArchiveCanonical {
+			commit.data.deleted.clear();
+		}
+		if let Some(ref mut pruning) = self.pruning {
+			pruning.note_canonical(hash, number, &mut commit)?;
+		}
+		self.prune(&mut commit)?;
+		Ok(commit)
+	}
+
+	/// Returns the block number of the last canonicalized block.
+	fn last_canonicalized(&self) -> LastCanonicalized {
+		if self.mode == PruningMode::ArchiveAll {
+			LastCanonicalized::NotCanonicalizing
+		} else {
+			self.non_canonical
+				.last_canonicalized_block_number()
+				.map(LastCanonicalized::Block)
+				.unwrap_or_else(|| LastCanonicalized::None)
+		}
+	}
+
+	fn is_pruned(&self, hash: &BlockHash, number: u64) -> IsPruned {
+		match self.mode {
+			PruningMode::ArchiveAll => IsPruned::NotPruned,
+			PruningMode::ArchiveCanonical | PruningMode::Constrained(_) => {
+				if self
+					.non_canonical
+					.last_canonicalized_block_number()
+					.map(|c| number > c)
+					.unwrap_or(true)
+				{
+					if self.non_canonical.have_block(hash) {
+						IsPruned::NotPruned
+					} else {
+						IsPruned::Pruned
+					}
+				} else {
+					match self.pruning.as_ref() {
+						// We don't know for sure.
+						None => IsPruned::MaybePruned,
+						Some(pruning) => match pruning.have_block(hash, number) {
+							HaveBlock::No => IsPruned::Pruned,
+							HaveBlock::Yes => IsPruned::NotPruned,
+							HaveBlock::Maybe => IsPruned::MaybePruned,
+						},
+					}
+				}
+			},
+		}
+	}
+
+	fn prune(&mut self, commit: &mut CommitSet<Key>) -> Result<(), Error<D::Error>> {
+		if let (&mut Some(ref mut pruning), PruningMode::Constrained(constraints)) =
+			(&mut self.pruning, &self.mode)
+		{
+			loop {
+				if pruning.window_size() <= constraints.max_blocks.unwrap_or(0) as u64 {
+					break
+				}
+
+				let pinned = &self.pinned;
+				match pruning.next_hash() {
+					// the block record is temporary unavailable, break and try next time
+					Err(Error::StateDb(StateDbError::BlockUnavailable)) => break,
+					res =>
+						if res?.map_or(false, |h| pinned.contains_key(&h)) {
+							break
+						},
+				}
+				match pruning.prune_one(commit) {
+					// this branch should not reach as previous `next_hash` don't return error
+					// keeping it for robustness
+					Err(Error::StateDb(StateDbError::BlockUnavailable)) => break,
+					res => res?,
+				}
+			}
+		}
+		Ok(())
+	}
+
+	/// Revert all non-canonical blocks with the best block number.
+	/// Returns a database commit or `None` if not possible.
+	/// For archive an empty commit set is returned.
+	fn revert_one(&mut self) -> Option<CommitSet<Key>> {
+		match self.mode {
+			PruningMode::ArchiveAll => Some(CommitSet::default()),
+			PruningMode::ArchiveCanonical | PruningMode::Constrained(_) =>
+				self.non_canonical.revert_one(),
+		}
+	}
+
+	fn remove(&mut self, hash: &BlockHash) -> Option<CommitSet<Key>> {
+		match self.mode {
+			PruningMode::ArchiveAll => Some(CommitSet::default()),
+			PruningMode::ArchiveCanonical | PruningMode::Constrained(_) =>
+				self.non_canonical.remove(hash),
+		}
+	}
+
+	fn pin<F>(&mut self, hash: &BlockHash, number: u64, hint: F) -> Result<(), PinError>
+	where
+		F: Fn() -> bool,
+	{
+		match self.mode {
+			PruningMode::ArchiveAll => Ok(()),
+			PruningMode::ArchiveCanonical | PruningMode::Constrained(_) => {
+				let have_block = self.non_canonical.have_block(hash) ||
+					self.pruning.as_ref().map_or_else(
+						|| hint(),
+						|pruning| match pruning.have_block(hash, number) {
+							HaveBlock::No => false,
+							HaveBlock::Yes => true,
+							HaveBlock::Maybe => hint(),
+						},
+					);
+				if have_block {
+					let refs = self.pinned.entry(hash.clone()).or_default();
+					if *refs == 0 {
+						trace!(target: "state-db-pin", "Pinned block: {:?}", hash);
+						self.non_canonical.pin(hash);
+					}
+					*refs += 1;
+					Ok(())
+				} else {
+					Err(PinError::InvalidBlock)
+				}
+			},
+		}
+	}
+
+	fn unpin(&mut self, hash: &BlockHash) {
+		match self.pinned.entry(hash.clone()) {
+			Entry::Occupied(mut entry) => {
+				*entry.get_mut() -= 1;
+				if *entry.get() == 0 {
+					trace!(target: "state-db-pin", "Unpinned block: {:?}", hash);
+					entry.remove();
+					self.non_canonical.unpin(hash);
+				} else {
+					trace!(target: "state-db-pin", "Releasing reference for {:?}", hash);
+				}
+			},
+			Entry::Vacant(_) => {},
+		}
+	}
+
+	fn sync(&mut self) {
+		self.non_canonical.sync();
+	}
+
+	pub fn get<DB: NodeDb, Q: ?Sized>(
+		&self,
+		key: &Q,
+		db: &DB,
+	) -> Result<Option<DBValue>, Error<DB::Error>>
+	where
+		Q: AsRef<DB::Key>,
+		Key: std::borrow::Borrow<Q>,
+		Q: std::hash::Hash + Eq,
+	{
+		if let Some(value) = self.non_canonical.get(key) {
+			return Ok(Some(value))
+		}
+		db.get(key.as_ref()).map_err(Error::Db)
+	}
+}
+
+/// State DB maintenance. See module description.
+/// Can be shared across threads.
+pub struct StateDb<BlockHash: Hash, Key: Hash, D: MetaDb> {
+	db: RwLock<StateDbSync<BlockHash, Key, D>>,
+}
+
+impl<BlockHash: Hash, Key: Hash, D: MetaDb> StateDb<BlockHash, Key, D> {
+	/// Create an instance of [`StateDb`].
+	pub fn open(
+		db: D,
+		requested_mode: Option<PruningMode>,
+		ref_counting: bool,
+		should_init: bool,
+	) -> Result<(CommitSet<Key>, StateDb<BlockHash, Key, D>), Error<D::Error>> {
+		let stored_mode = fetch_stored_pruning_mode(&db)?;
+
+		let selected_mode = match (should_init, stored_mode, requested_mode) {
+			(true, stored_mode, requested_mode) => {
+				assert!(stored_mode.is_none(), "The storage has just been initialized. No meta-data is expected to be found in it.");
+				requested_mode.unwrap_or_default()
+			},
+
+			(false, None, _) =>
+				return Err(StateDbError::Metadata(
+					"An existing StateDb does not have PRUNING_MODE stored in its meta-data".into(),
+				)
+				.into()),
+
+			(false, Some(stored), None) => stored,
+
+			(false, Some(stored), Some(requested)) => choose_pruning_mode(stored, requested)?,
+		};
+
+		let db_init_commit_set = if should_init {
+			let mut cs: CommitSet<Key> = Default::default();
+
+			let key = to_meta_key(PRUNING_MODE, &());
+			let value = selected_mode.id().to_owned();
+
+			cs.meta.inserted.push((key, value));
+
+			cs
+		} else {
+			Default::default()
+		};
+
+		let state_db =
+			StateDb { db: RwLock::new(StateDbSync::new(selected_mode, ref_counting, db)?) };
+
+		Ok((db_init_commit_set, state_db))
+	}
+
+	pub fn pruning_mode(&self) -> PruningMode {
+		self.db.read().mode.clone()
+	}
+
+	/// Add a new non-canonical block.
+	pub fn insert_block(
+		&self,
+		hash: &BlockHash,
+		number: u64,
+		parent_hash: &BlockHash,
+		changeset: ChangeSet<Key>,
+	) -> Result<CommitSet<Key>, Error<D::Error>> {
+		self.db.write().insert_block(hash, number, parent_hash, changeset)
+	}
+
+	/// Finalize a previously inserted block.
+	pub fn canonicalize_block(&self, hash: &BlockHash) -> Result<CommitSet<Key>, Error<D::Error>> {
+		self.db.write().canonicalize_block(hash)
+	}
+
+	/// Prevents pruning of specified block and its descendants.
+	/// `hint` used for further checking if the given block exists
+	pub fn pin<F>(&self, hash: &BlockHash, number: u64, hint: F) -> Result<(), PinError>
+	where
+		F: Fn() -> bool,
+	{
+		self.db.write().pin(hash, number, hint)
+	}
+
+	/// Allows pruning of specified block.
+	pub fn unpin(&self, hash: &BlockHash) {
+		self.db.write().unpin(hash)
+	}
+
+	/// Confirm that all changes made to commit sets are on disk. Allows for temporarily pinned
+	/// blocks to be released.
+	pub fn sync(&self) {
+		self.db.write().sync()
+	}
+
+	/// Get a value from non-canonical/pruning overlay or the backing DB.
+	pub fn get<DB: NodeDb, Q: ?Sized>(
+		&self,
+		key: &Q,
+		db: &DB,
+	) -> Result<Option<DBValue>, Error<DB::Error>>
+	where
+		Q: AsRef<DB::Key>,
+		Key: std::borrow::Borrow<Q>,
+		Q: std::hash::Hash + Eq,
+	{
+		self.db.read().get(key, db)
+	}
+
+	/// Revert all non-canonical blocks with the best block number.
+	/// Returns a database commit or `None` if not possible.
+	/// For archive an empty commit set is returned.
+	pub fn revert_one(&self) -> Option<CommitSet<Key>> {
+		self.db.write().revert_one()
+	}
+
+	/// Remove specified non-canonical block.
+	/// Returns a database commit or `None` if not possible.
+	pub fn remove(&self, hash: &BlockHash) -> Option<CommitSet<Key>> {
+		self.db.write().remove(hash)
+	}
+
+	/// Returns last canonicalized block.
+	pub fn last_canonicalized(&self) -> LastCanonicalized {
+		self.db.read().last_canonicalized()
+	}
+
+	/// Check if block is pruned away.
+	pub fn is_pruned(&self, hash: &BlockHash, number: u64) -> IsPruned {
+		self.db.read().is_pruned(hash, number)
+	}
+
+	/// Reset in-memory changes to the last disk-backed state.
+	pub fn reset(&self, db: D) -> Result<(), Error<D::Error>> {
+		let mut state_db = self.db.write();
+		*state_db = StateDbSync::new(state_db.mode.clone(), state_db.ref_counting, db)?;
+		Ok(())
+	}
+}
+
+/// The result return by `StateDb::is_pruned`
+#[derive(Debug, PartialEq, Eq)]
+pub enum IsPruned {
+	/// Definitely pruned
+	Pruned,
+	/// Definitely not pruned
+	NotPruned,
+	/// May or may not pruned, need further checking
+	MaybePruned,
+}
+
+fn fetch_stored_pruning_mode<D: MetaDb>(db: &D) -> Result<Option<PruningMode>, Error<D::Error>> {
+	let meta_key_mode = to_meta_key(PRUNING_MODE, &());
+	if let Some(stored_mode) = db.get_meta(&meta_key_mode).map_err(Error::Db)? {
+		if let Some(mode) = PruningMode::from_id(&stored_mode) {
+			Ok(Some(mode))
+		} else {
+			Err(StateDbError::Metadata(format!(
+				"Invalid value stored for PRUNING_MODE: {:02x?}",
+				stored_mode
+			))
+			.into())
+		}
+	} else {
+		Ok(None)
+	}
+}
+
+fn choose_pruning_mode(
+	stored: PruningMode,
+	requested: PruningMode,
+) -> Result<PruningMode, StateDbError> {
+	match (stored, requested) {
+		(PruningMode::ArchiveAll, PruningMode::ArchiveAll) => Ok(PruningMode::ArchiveAll),
+		(PruningMode::ArchiveCanonical, PruningMode::ArchiveCanonical) =>
+			Ok(PruningMode::ArchiveCanonical),
+		(PruningMode::Constrained(_), PruningMode::Constrained(requested)) =>
+			Ok(PruningMode::Constrained(requested)),
+		(stored, requested) => Err(StateDbError::IncompatiblePruningModes { requested, stored }),
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::{
+		test::{make_changeset, make_db, TestDb},
+		Constraints, Error, IsPruned, PruningMode, StateDb, StateDbError,
+	};
+	use sp_core::H256;
+
+	fn make_test_db(settings: PruningMode) -> (TestDb, StateDb<H256, H256, TestDb>) {
+		let mut db = make_db(&[91, 921, 922, 93, 94]);
+		let (state_db_init, state_db) =
+			StateDb::open(db.clone(), Some(settings), false, true).unwrap();
+		db.commit(&state_db_init);
+
+		db.commit(
+			&state_db
+				.insert_block(
+					&H256::from_low_u64_be(1),
+					1,
+					&H256::from_low_u64_be(0),
+					make_changeset(&[1], &[91]),
+				)
+				.unwrap(),
+		);
+		db.commit(
+			&state_db
+				.insert_block(
+					&H256::from_low_u64_be(21),
+					2,
+					&H256::from_low_u64_be(1),
+					make_changeset(&[21], &[921, 1]),
+				)
+				.unwrap(),
+		);
+		db.commit(
+			&state_db
+				.insert_block(
+					&H256::from_low_u64_be(22),
+					2,
+					&H256::from_low_u64_be(1),
+					make_changeset(&[22], &[922]),
+				)
+				.unwrap(),
+		);
+		db.commit(
+			&state_db
+				.insert_block(
+					&H256::from_low_u64_be(3),
+					3,
+					&H256::from_low_u64_be(21),
+					make_changeset(&[3], &[93]),
+				)
+				.unwrap(),
+		);
+		db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(1)).unwrap());
+		db.commit(
+			&state_db
+				.insert_block(
+					&H256::from_low_u64_be(4),
+					4,
+					&H256::from_low_u64_be(3),
+					make_changeset(&[4], &[94]),
+				)
+				.unwrap(),
+		);
+		db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(21)).unwrap());
+		db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(3)).unwrap());
+
+		(db, state_db)
+	}
+
+	#[test]
+	fn full_archive_keeps_everything() {
+		let (db, sdb) = make_test_db(PruningMode::ArchiveAll);
+		assert!(db.data_eq(&make_db(&[1, 21, 22, 3, 4, 91, 921, 922, 93, 94])));
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(0), 0), IsPruned::NotPruned);
+	}
+
+	#[test]
+	fn canonical_archive_keeps_canonical() {
+		let (db, _) = make_test_db(PruningMode::ArchiveCanonical);
+		assert!(db.data_eq(&make_db(&[1, 21, 3, 91, 921, 922, 93, 94])));
+	}
+
+	#[test]
+	fn block_record_unavailable() {
+		let (mut db, state_db) =
+			make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(1) }));
+		// import 2 blocks
+		for i in &[5, 6] {
+			db.commit(
+				&state_db
+					.insert_block(
+						&H256::from_low_u64_be(*i),
+						*i,
+						&H256::from_low_u64_be(*i - 1),
+						make_changeset(&[], &[]),
+					)
+					.unwrap(),
+			);
+		}
+		// canonicalize block 4 but not commit it to db
+		let c1 = state_db.canonicalize_block(&H256::from_low_u64_be(4)).unwrap();
+		assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(3), 3), IsPruned::Pruned);
+
+		// canonicalize block 5 but not commit it to db, block 4 is not pruned due to it is not
+		// commit to db yet (unavailable), return `MaybePruned` here because `apply_pending` is not
+		// called and block 3 is still in cache
+		let c2 = state_db.canonicalize_block(&H256::from_low_u64_be(5)).unwrap();
+		assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(4), 4), IsPruned::MaybePruned);
+
+		// commit block 4 and 5 to db, and import a new block will prune both block 4 and 5
+		db.commit(&c1);
+		db.commit(&c2);
+		db.commit(&state_db.canonicalize_block(&H256::from_low_u64_be(6)).unwrap());
+		assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(4), 4), IsPruned::Pruned);
+		assert_eq!(state_db.is_pruned(&H256::from_low_u64_be(5), 5), IsPruned::Pruned);
+	}
+
+	#[test]
+	fn prune_window_0() {
+		let (db, _) = make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(0) }));
+		assert!(db.data_eq(&make_db(&[21, 3, 922, 94])));
+	}
+
+	#[test]
+	fn prune_window_1() {
+		let (db, sdb) = make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(1) }));
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(0), 0), IsPruned::Pruned);
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(1), 1), IsPruned::Pruned);
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(21), 2), IsPruned::Pruned);
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(22), 2), IsPruned::Pruned);
+		assert!(db.data_eq(&make_db(&[21, 3, 922, 93, 94])));
+	}
+
+	#[test]
+	fn prune_window_2() {
+		let (db, sdb) = make_test_db(PruningMode::Constrained(Constraints { max_blocks: Some(2) }));
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(0), 0), IsPruned::Pruned);
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(1), 1), IsPruned::Pruned);
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(21), 2), IsPruned::NotPruned);
+		assert_eq!(sdb.is_pruned(&H256::from_low_u64_be(22), 2), IsPruned::Pruned);
+		assert!(db.data_eq(&make_db(&[1, 21, 3, 921, 922, 93, 94])));
+	}
+
+	#[test]
+	fn detects_incompatible_mode() {
+		let mut db = make_db(&[]);
+		let (state_db_init, state_db) =
+			StateDb::open(db.clone(), Some(PruningMode::ArchiveAll), false, true).unwrap();
+		db.commit(&state_db_init);
+		db.commit(
+			&state_db
+				.insert_block(
+					&H256::from_low_u64_be(0),
+					0,
+					&H256::from_low_u64_be(0),
+					make_changeset(&[], &[]),
+				)
+				.unwrap(),
+		);
+		let new_mode = PruningMode::Constrained(Constraints { max_blocks: Some(2) });
+		let state_db_open_result: Result<(_, StateDb<H256, H256, TestDb>), _> =
+			StateDb::open(db.clone(), Some(new_mode), false, false);
+		assert!(state_db_open_result.is_err());
+	}
+
+	fn check_stored_and_requested_mode_compatibility(
+		mode_when_created: Option<PruningMode>,
+		mode_when_reopened: Option<PruningMode>,
+		expected_effective_mode_when_reopenned: Result<PruningMode, ()>,
+	) {
+		let mut db = make_db(&[]);
+		let (state_db_init, state_db) =
+			StateDb::<H256, H256, TestDb>::open(db.clone(), mode_when_created, false, true)
+				.unwrap();
+		db.commit(&state_db_init);
+		std::mem::drop(state_db);
+
+		let state_db_reopen_result =
+			StateDb::<H256, H256, TestDb>::open(db.clone(), mode_when_reopened, false, false);
+		if let Ok(expected_mode) = expected_effective_mode_when_reopenned {
+			let (state_db_init, state_db_reopened) = state_db_reopen_result.unwrap();
+			db.commit(&state_db_init);
+			assert_eq!(state_db_reopened.pruning_mode(), expected_mode,)
+		} else {
+			assert!(matches!(
+				state_db_reopen_result,
+				Err(Error::StateDb(StateDbError::IncompatiblePruningModes { .. }))
+			));
+		}
+	}
+
+	#[test]
+	fn pruning_mode_compatibility() {
+		for (created, reopened, expected) in [
+			(None, None, Ok(PruningMode::blocks_pruning(256))),
+			(None, Some(PruningMode::blocks_pruning(256)), Ok(PruningMode::blocks_pruning(256))),
+			(None, Some(PruningMode::blocks_pruning(128)), Ok(PruningMode::blocks_pruning(128))),
+			(None, Some(PruningMode::blocks_pruning(512)), Ok(PruningMode::blocks_pruning(512))),
+			(None, Some(PruningMode::ArchiveAll), Err(())),
+			(None, Some(PruningMode::ArchiveCanonical), Err(())),
+			(Some(PruningMode::blocks_pruning(256)), None, Ok(PruningMode::blocks_pruning(256))),
+			(
+				Some(PruningMode::blocks_pruning(256)),
+				Some(PruningMode::blocks_pruning(256)),
+				Ok(PruningMode::blocks_pruning(256)),
+			),
+			(
+				Some(PruningMode::blocks_pruning(256)),
+				Some(PruningMode::blocks_pruning(128)),
+				Ok(PruningMode::blocks_pruning(128)),
+			),
+			(
+				Some(PruningMode::blocks_pruning(256)),
+				Some(PruningMode::blocks_pruning(512)),
+				Ok(PruningMode::blocks_pruning(512)),
+			),
+			(Some(PruningMode::blocks_pruning(256)), Some(PruningMode::ArchiveAll), Err(())),
+			(Some(PruningMode::blocks_pruning(256)), Some(PruningMode::ArchiveCanonical), Err(())),
+			(Some(PruningMode::ArchiveAll), None, Ok(PruningMode::ArchiveAll)),
+			(Some(PruningMode::ArchiveAll), Some(PruningMode::blocks_pruning(256)), Err(())),
+			(Some(PruningMode::ArchiveAll), Some(PruningMode::blocks_pruning(128)), Err(())),
+			(Some(PruningMode::ArchiveAll), Some(PruningMode::blocks_pruning(512)), Err(())),
+			(
+				Some(PruningMode::ArchiveAll),
+				Some(PruningMode::ArchiveAll),
+				Ok(PruningMode::ArchiveAll),
+			),
+			(Some(PruningMode::ArchiveAll), Some(PruningMode::ArchiveCanonical), Err(())),
+			(Some(PruningMode::ArchiveCanonical), None, Ok(PruningMode::ArchiveCanonical)),
+			(Some(PruningMode::ArchiveCanonical), Some(PruningMode::blocks_pruning(256)), Err(())),
+			(Some(PruningMode::ArchiveCanonical), Some(PruningMode::blocks_pruning(128)), Err(())),
+			(Some(PruningMode::ArchiveCanonical), Some(PruningMode::blocks_pruning(512)), Err(())),
+			(Some(PruningMode::ArchiveCanonical), Some(PruningMode::ArchiveAll), Err(())),
+			(
+				Some(PruningMode::ArchiveCanonical),
+				Some(PruningMode::ArchiveCanonical),
+				Ok(PruningMode::ArchiveCanonical),
+			),
+		] {
+			check_stored_and_requested_mode_compatibility(created, reopened, expected);
+		}
+	}
+}
diff --git a/substrate/client/state-db/src/noncanonical.rs b/substrate/client/state-db/src/noncanonical.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bdbe8318371ce8239158f4f728a7313e107db879
--- /dev/null
+++ b/substrate/client/state-db/src/noncanonical.rs
@@ -0,0 +1,1131 @@
+// 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/>.
+
+//! Canonicalization window.
+//! Maintains trees of block overlays and allows discarding trees/roots
+//! The overlays are added in `insert` and removed in `canonicalize`.
+
+use crate::{LOG_TARGET, LOG_TARGET_PIN};
+
+use super::{to_meta_key, ChangeSet, CommitSet, DBValue, Error, Hash, MetaDb, StateDbError};
+use codec::{Decode, Encode};
+use log::trace;
+use std::collections::{hash_map::Entry, HashMap, VecDeque};
+
+const NON_CANONICAL_JOURNAL: &[u8] = b"noncanonical_journal";
+pub(crate) const LAST_CANONICAL: &[u8] = b"last_canonical";
+const MAX_BLOCKS_PER_LEVEL: u64 = 32;
+
+/// See module documentation.
+pub struct NonCanonicalOverlay<BlockHash: Hash, Key: Hash> {
+	last_canonicalized: Option<(BlockHash, u64)>,
+	levels: VecDeque<OverlayLevel<BlockHash, Key>>,
+	parents: HashMap<BlockHash, BlockHash>,
+	values: HashMap<Key, (u32, DBValue)>, // ref counted
+	// would be deleted but kept around because block is pinned, ref counted.
+	pinned: HashMap<BlockHash, u32>,
+	pinned_insertions: HashMap<BlockHash, (Vec<Key>, u32)>,
+	pinned_canonincalized: Vec<BlockHash>,
+}
+
+#[cfg_attr(test, derive(PartialEq, Debug))]
+struct OverlayLevel<BlockHash: Hash, Key: Hash> {
+	blocks: Vec<BlockOverlay<BlockHash, Key>>,
+	used_indicies: u64, // Bitmask of available journal indicies.
+}
+
+impl<BlockHash: Hash, Key: Hash> OverlayLevel<BlockHash, Key> {
+	fn push(&mut self, overlay: BlockOverlay<BlockHash, Key>) {
+		self.used_indicies |= 1 << overlay.journal_index;
+		self.blocks.push(overlay)
+	}
+
+	fn available_index(&self) -> u64 {
+		self.used_indicies.trailing_ones() as u64
+	}
+
+	fn remove(&mut self, index: usize) -> BlockOverlay<BlockHash, Key> {
+		self.used_indicies &= !(1 << self.blocks[index].journal_index);
+		self.blocks.remove(index)
+	}
+
+	fn new() -> OverlayLevel<BlockHash, Key> {
+		OverlayLevel { blocks: Vec::new(), used_indicies: 0 }
+	}
+}
+
+#[derive(Encode, Decode)]
+struct JournalRecord<BlockHash: Hash, Key: Hash> {
+	hash: BlockHash,
+	parent_hash: BlockHash,
+	inserted: Vec<(Key, DBValue)>,
+	deleted: Vec<Key>,
+}
+
+fn to_journal_key(block: u64, index: u64) -> Vec<u8> {
+	to_meta_key(NON_CANONICAL_JOURNAL, &(block, index))
+}
+
+#[cfg_attr(test, derive(PartialEq, Debug))]
+struct BlockOverlay<BlockHash: Hash, Key: Hash> {
+	hash: BlockHash,
+	journal_index: u64,
+	journal_key: Vec<u8>,
+	inserted: Vec<Key>,
+	deleted: Vec<Key>,
+}
+
+fn insert_values<Key: Hash>(
+	values: &mut HashMap<Key, (u32, DBValue)>,
+	inserted: Vec<(Key, DBValue)>,
+) {
+	for (k, v) in inserted {
+		debug_assert!(values.get(&k).map_or(true, |(_, value)| *value == v));
+		let (ref mut counter, _) = values.entry(k).or_insert_with(|| (0, v));
+		*counter += 1;
+	}
+}
+
+fn discard_values<Key: Hash>(values: &mut HashMap<Key, (u32, DBValue)>, inserted: Vec<Key>) {
+	for k in inserted {
+		match values.entry(k) {
+			Entry::Occupied(mut e) => {
+				let (ref mut counter, _) = e.get_mut();
+				*counter -= 1;
+				if *counter == 0 {
+					e.remove_entry();
+				}
+			},
+			Entry::Vacant(_) => {
+				debug_assert!(false, "Trying to discard missing value");
+			},
+		}
+	}
+}
+
+fn discard_descendants<BlockHash: Hash, Key: Hash>(
+	levels: &mut (&mut [OverlayLevel<BlockHash, Key>], &mut [OverlayLevel<BlockHash, Key>]),
+	values: &mut HashMap<Key, (u32, DBValue)>,
+	parents: &mut HashMap<BlockHash, BlockHash>,
+	pinned: &HashMap<BlockHash, u32>,
+	pinned_insertions: &mut HashMap<BlockHash, (Vec<Key>, u32)>,
+	hash: &BlockHash,
+) -> u32 {
+	let (first, mut remainder) = if let Some((first, rest)) = levels.0.split_first_mut() {
+		(Some(first), (rest, &mut *levels.1))
+	} else if let Some((first, rest)) = levels.1.split_first_mut() {
+		(Some(first), (&mut *levels.0, rest))
+	} else {
+		(None, (&mut *levels.0, &mut *levels.1))
+	};
+	let mut pinned_children = 0;
+	if let Some(level) = first {
+		while let Some(i) = level.blocks.iter().position(|overlay| {
+			parents
+				.get(&overlay.hash)
+				.expect("there is a parent entry for each entry in levels; qed") ==
+				hash
+		}) {
+			let overlay = level.remove(i);
+			let mut num_pinned = discard_descendants(
+				&mut remainder,
+				values,
+				parents,
+				pinned,
+				pinned_insertions,
+				&overlay.hash,
+			);
+			if pinned.contains_key(&overlay.hash) {
+				num_pinned += 1;
+			}
+			if num_pinned != 0 {
+				// save to be discarded later.
+				pinned_insertions.insert(overlay.hash.clone(), (overlay.inserted, num_pinned));
+				pinned_children += num_pinned;
+			} else {
+				// discard immediately.
+				parents.remove(&overlay.hash);
+				discard_values(values, overlay.inserted);
+			}
+		}
+	}
+	pinned_children
+}
+
+impl<BlockHash: Hash, Key: Hash> NonCanonicalOverlay<BlockHash, Key> {
+	/// Creates a new instance. Does not expect any metadata to be present in the DB.
+	pub fn new<D: MetaDb>(db: &D) -> Result<NonCanonicalOverlay<BlockHash, Key>, Error<D::Error>> {
+		let last_canonicalized =
+			db.get_meta(&to_meta_key(LAST_CANONICAL, &())).map_err(Error::Db)?;
+		let last_canonicalized = last_canonicalized
+			.map(|buffer| <(BlockHash, u64)>::decode(&mut buffer.as_slice()))
+			.transpose()?;
+		let mut levels = VecDeque::new();
+		let mut parents = HashMap::new();
+		let mut values = HashMap::new();
+		if let Some((ref hash, mut block)) = last_canonicalized {
+			// read the journal
+			trace!(
+				target: LOG_TARGET,
+				"Reading uncanonicalized journal. Last canonicalized #{} ({:?})",
+				block,
+				hash
+			);
+			let mut total: u64 = 0;
+			block += 1;
+			loop {
+				let mut level = OverlayLevel::new();
+				for index in 0..MAX_BLOCKS_PER_LEVEL {
+					let journal_key = to_journal_key(block, index);
+					if let Some(record) = db.get_meta(&journal_key).map_err(Error::Db)? {
+						let record: JournalRecord<BlockHash, Key> =
+							Decode::decode(&mut record.as_slice())?;
+						let inserted = record.inserted.iter().map(|(k, _)| k.clone()).collect();
+						let overlay = BlockOverlay {
+							hash: record.hash.clone(),
+							journal_index: index,
+							journal_key,
+							inserted,
+							deleted: record.deleted,
+						};
+						insert_values(&mut values, record.inserted);
+						trace!(
+							target: LOG_TARGET,
+							"Uncanonicalized journal entry {}.{} ({:?}) ({} inserted, {} deleted)",
+							block,
+							index,
+							record.hash,
+							overlay.inserted.len(),
+							overlay.deleted.len()
+						);
+						level.push(overlay);
+						parents.insert(record.hash, record.parent_hash);
+						total += 1;
+					}
+				}
+				if level.blocks.is_empty() {
+					break
+				}
+				levels.push_back(level);
+				block += 1;
+			}
+			trace!(
+				target: LOG_TARGET,
+				"Finished reading uncanonicalized journal, {} entries",
+				total
+			);
+		}
+		Ok(NonCanonicalOverlay {
+			last_canonicalized,
+			levels,
+			parents,
+			pinned: Default::default(),
+			pinned_insertions: Default::default(),
+			values,
+			pinned_canonincalized: Default::default(),
+		})
+	}
+
+	/// Insert a new block into the overlay. If inserted on the second level or lover expects parent
+	/// to be present in the window.
+	pub fn insert(
+		&mut self,
+		hash: &BlockHash,
+		number: u64,
+		parent_hash: &BlockHash,
+		changeset: ChangeSet<Key>,
+	) -> Result<CommitSet<Key>, StateDbError> {
+		let mut commit = CommitSet::default();
+		let front_block_number = self.front_block_number();
+		if self.levels.is_empty() && self.last_canonicalized.is_none() && number > 0 {
+			// assume that parent was canonicalized
+			let last_canonicalized = (parent_hash.clone(), number - 1);
+			commit
+				.meta
+				.inserted
+				.push((to_meta_key(LAST_CANONICAL, &()), last_canonicalized.encode()));
+			self.last_canonicalized = Some(last_canonicalized);
+		} else if self.last_canonicalized.is_some() {
+			if number < front_block_number || number > front_block_number + self.levels.len() as u64
+			{
+				trace!(
+					target: LOG_TARGET,
+					"Failed to insert block {}, current is {} .. {})",
+					number,
+					front_block_number,
+					front_block_number + self.levels.len() as u64,
+				);
+				return Err(StateDbError::InvalidBlockNumber)
+			}
+			// check for valid parent if inserting on second level or higher
+			if number == front_block_number {
+				if !self
+					.last_canonicalized
+					.as_ref()
+					.map_or(false, |&(ref h, n)| h == parent_hash && n == number - 1)
+				{
+					return Err(StateDbError::InvalidParent)
+				}
+			} else if !self.parents.contains_key(parent_hash) {
+				return Err(StateDbError::InvalidParent)
+			}
+		}
+		let level = if self.levels.is_empty() ||
+			number == front_block_number + self.levels.len() as u64
+		{
+			self.levels.push_back(OverlayLevel::new());
+			self.levels.back_mut().expect("can't be empty after insertion; qed")
+		} else {
+			self.levels.get_mut((number - front_block_number) as usize)
+				.expect("number is [front_block_number .. front_block_number + levels.len()) is asserted in precondition; qed")
+		};
+
+		if level.blocks.len() >= MAX_BLOCKS_PER_LEVEL as usize {
+			trace!(
+				target: LOG_TARGET,
+				"Too many sibling blocks at #{number}: {:?}",
+				level.blocks.iter().map(|b| &b.hash).collect::<Vec<_>>()
+			);
+			return Err(StateDbError::TooManySiblingBlocks { number })
+		}
+		if level.blocks.iter().any(|b| b.hash == *hash) {
+			return Err(StateDbError::BlockAlreadyExists)
+		}
+
+		let index = level.available_index();
+		let journal_key = to_journal_key(number, index);
+
+		let inserted = changeset.inserted.iter().map(|(k, _)| k.clone()).collect();
+		let overlay = BlockOverlay {
+			hash: hash.clone(),
+			journal_index: index,
+			journal_key: journal_key.clone(),
+			inserted,
+			deleted: changeset.deleted.clone(),
+		};
+		level.push(overlay);
+		self.parents.insert(hash.clone(), parent_hash.clone());
+		let journal_record = JournalRecord {
+			hash: hash.clone(),
+			parent_hash: parent_hash.clone(),
+			inserted: changeset.inserted,
+			deleted: changeset.deleted,
+		};
+		commit.meta.inserted.push((journal_key, journal_record.encode()));
+		trace!(
+			target: LOG_TARGET,
+			"Inserted uncanonicalized changeset {}.{} {:?} ({} inserted, {} deleted)",
+			number,
+			index,
+			hash,
+			journal_record.inserted.len(),
+			journal_record.deleted.len()
+		);
+		insert_values(&mut self.values, journal_record.inserted);
+		Ok(commit)
+	}
+
+	fn discard_journals(
+		&self,
+		level_index: usize,
+		discarded_journals: &mut Vec<Vec<u8>>,
+		hash: &BlockHash,
+	) {
+		if let Some(level) = self.levels.get(level_index) {
+			level.blocks.iter().for_each(|overlay| {
+				let parent = self
+					.parents
+					.get(&overlay.hash)
+					.expect("there is a parent entry for each entry in levels; qed")
+					.clone();
+				if parent == *hash {
+					discarded_journals.push(overlay.journal_key.clone());
+					self.discard_journals(level_index + 1, discarded_journals, &overlay.hash);
+				}
+			});
+		}
+	}
+
+	fn front_block_number(&self) -> u64 {
+		self.last_canonicalized.as_ref().map(|&(_, n)| n + 1).unwrap_or(0)
+	}
+
+	pub fn last_canonicalized_block_number(&self) -> Option<u64> {
+		self.last_canonicalized.as_ref().map(|&(_, n)| n)
+	}
+
+	/// Confirm that all changes made to commit sets are on disk. Allows for temporarily pinned
+	/// blocks to be released.
+	pub fn sync(&mut self) {
+		let mut pinned = std::mem::take(&mut self.pinned_canonincalized);
+		for hash in pinned.iter() {
+			self.unpin(hash)
+		}
+		pinned.clear();
+		// Reuse the same memory buffer
+		self.pinned_canonincalized = pinned;
+	}
+
+	/// Select a top-level root and canonicalized it. Discards all sibling subtrees and the root.
+	/// Add a set of changes of the canonicalized block to `CommitSet`
+	/// Return the block number of the canonicalized block
+	pub fn canonicalize(
+		&mut self,
+		hash: &BlockHash,
+		commit: &mut CommitSet<Key>,
+	) -> Result<u64, StateDbError> {
+		trace!(target: LOG_TARGET, "Canonicalizing {:?}", hash);
+		let level = match self.levels.pop_front() {
+			Some(level) => level,
+			None => return Err(StateDbError::InvalidBlock),
+		};
+		let index = level
+			.blocks
+			.iter()
+			.position(|overlay| overlay.hash == *hash)
+			.ok_or(StateDbError::InvalidBlock)?;
+
+		// No failures are possible beyond this point.
+
+		// Force pin canonicalized block so that it is no discarded immediately
+		self.pin(hash);
+		self.pinned_canonincalized.push(hash.clone());
+
+		let mut discarded_journals = Vec::new();
+		for (i, overlay) in level.blocks.into_iter().enumerate() {
+			let mut pinned_children = 0;
+			// That's the one we need to canonicalize
+			if i == index {
+				commit.data.inserted.extend(overlay.inserted.iter().map(|k| {
+					(
+						k.clone(),
+						self.values
+							.get(k)
+							.expect("For each key in overlays there's a value in values")
+							.1
+							.clone(),
+					)
+				}));
+				commit.data.deleted.extend(overlay.deleted.clone());
+			} else {
+				// Discard this overlay
+				self.discard_journals(0, &mut discarded_journals, &overlay.hash);
+				pinned_children = discard_descendants(
+					&mut self.levels.as_mut_slices(),
+					&mut self.values,
+					&mut self.parents,
+					&self.pinned,
+					&mut self.pinned_insertions,
+					&overlay.hash,
+				);
+			}
+			if self.pinned.contains_key(&overlay.hash) {
+				pinned_children += 1;
+			}
+			if pinned_children != 0 {
+				self.pinned_insertions
+					.insert(overlay.hash.clone(), (overlay.inserted, pinned_children));
+			} else {
+				self.parents.remove(&overlay.hash);
+				discard_values(&mut self.values, overlay.inserted);
+			}
+			discarded_journals.push(overlay.journal_key.clone());
+		}
+		commit.meta.deleted.append(&mut discarded_journals);
+
+		let canonicalized = (hash.clone(), self.front_block_number());
+		commit
+			.meta
+			.inserted
+			.push((to_meta_key(LAST_CANONICAL, &()), canonicalized.encode()));
+		trace!(target: LOG_TARGET, "Discarding {} records", commit.meta.deleted.len());
+
+		let num = canonicalized.1;
+		self.last_canonicalized = Some(canonicalized);
+		Ok(num)
+	}
+
+	/// Get a value from the node overlay. This searches in every existing changeset.
+	pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<DBValue>
+	where
+		Key: std::borrow::Borrow<Q>,
+		Q: std::hash::Hash + Eq,
+	{
+		self.values.get(key).map(|v| v.1.clone())
+	}
+
+	/// Check if the block is in the canonicalization queue.
+	pub fn have_block(&self, hash: &BlockHash) -> bool {
+		self.parents.contains_key(hash)
+	}
+
+	/// Revert a single level. Returns commit set that deletes the journal or `None` if not
+	/// possible.
+	pub fn revert_one(&mut self) -> Option<CommitSet<Key>> {
+		self.levels.pop_back().map(|level| {
+			let mut commit = CommitSet::default();
+			for overlay in level.blocks.into_iter() {
+				commit.meta.deleted.push(overlay.journal_key);
+				self.parents.remove(&overlay.hash);
+				discard_values(&mut self.values, overlay.inserted);
+			}
+			commit
+		})
+	}
+
+	/// Revert a single block. Returns commit set that deletes the journal or `None` if not
+	/// possible.
+	pub fn remove(&mut self, hash: &BlockHash) -> Option<CommitSet<Key>> {
+		let mut commit = CommitSet::default();
+		let level_count = self.levels.len();
+		for (level_index, level) in self.levels.iter_mut().enumerate().rev() {
+			let index = match level.blocks.iter().position(|overlay| &overlay.hash == hash) {
+				Some(index) => index,
+				None => continue,
+			};
+			// Check that it does not have any children
+			if (level_index != level_count - 1) && self.parents.values().any(|h| h == hash) {
+				log::debug!(target: LOG_TARGET, "Trying to remove block {:?} with children", hash);
+				return None
+			}
+			let overlay = level.remove(index);
+			commit.meta.deleted.push(overlay.journal_key);
+			self.parents.remove(&overlay.hash);
+			discard_values(&mut self.values, overlay.inserted);
+			break
+		}
+		if self.levels.back().map_or(false, |l| l.blocks.is_empty()) {
+			self.levels.pop_back();
+		}
+		if !commit.meta.deleted.is_empty() {
+			Some(commit)
+		} else {
+			None
+		}
+	}
+
+	/// Pin state values in memory
+	pub fn pin(&mut self, hash: &BlockHash) {
+		let refs = self.pinned.entry(hash.clone()).or_default();
+		if *refs == 0 {
+			trace!(target: LOG_TARGET_PIN, "Pinned non-canon block: {:?}", hash);
+		}
+		*refs += 1;
+	}
+
+	/// Discard pinned state
+	pub fn unpin(&mut self, hash: &BlockHash) {
+		let removed = match self.pinned.entry(hash.clone()) {
+			Entry::Occupied(mut entry) => {
+				*entry.get_mut() -= 1;
+				if *entry.get() == 0 {
+					entry.remove();
+					true
+				} else {
+					false
+				}
+			},
+			Entry::Vacant(_) => false,
+		};
+
+		if removed {
+			let mut parent = Some(hash.clone());
+			while let Some(hash) = parent {
+				parent = self.parents.get(&hash).cloned();
+				match self.pinned_insertions.entry(hash.clone()) {
+					Entry::Occupied(mut entry) => {
+						entry.get_mut().1 -= 1;
+						if entry.get().1 == 0 {
+							let (inserted, _) = entry.remove();
+							trace!(
+								target: LOG_TARGET_PIN,
+								"Discarding unpinned non-canon block: {:?}",
+								hash
+							);
+							discard_values(&mut self.values, inserted);
+							self.parents.remove(&hash);
+						}
+					},
+					Entry::Vacant(_) => break,
+				};
+			}
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{to_journal_key, NonCanonicalOverlay};
+	use crate::{
+		test::{make_changeset, make_db},
+		ChangeSet, CommitSet, MetaDb, StateDbError,
+	};
+	use sp_core::H256;
+
+	fn contains(overlay: &NonCanonicalOverlay<H256, H256>, key: u64) -> bool {
+		overlay.get(&H256::from_low_u64_be(key)) ==
+			Some(H256::from_low_u64_be(key).as_bytes().to_vec())
+	}
+
+	#[test]
+	fn created_from_empty_db() {
+		let db = make_db(&[]);
+		let overlay: NonCanonicalOverlay<H256, H256> = NonCanonicalOverlay::new(&db).unwrap();
+		assert_eq!(overlay.last_canonicalized, None);
+		assert!(overlay.levels.is_empty());
+		assert!(overlay.parents.is_empty());
+	}
+
+	#[test]
+	#[should_panic]
+	fn canonicalize_empty_panics() {
+		let db = make_db(&[]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&H256::default(), &mut commit).unwrap();
+	}
+
+	#[test]
+	#[should_panic]
+	fn insert_ahead_panics() {
+		let db = make_db(&[]);
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		overlay.insert(&h1, 2, &H256::default(), ChangeSet::default()).unwrap();
+		overlay.insert(&h2, 1, &h1, ChangeSet::default()).unwrap();
+	}
+
+	#[test]
+	#[should_panic]
+	fn insert_behind_panics() {
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let db = make_db(&[]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		overlay.insert(&h1, 1, &H256::default(), ChangeSet::default()).unwrap();
+		overlay.insert(&h2, 3, &h1, ChangeSet::default()).unwrap();
+	}
+
+	#[test]
+	#[should_panic]
+	fn insert_unknown_parent_panics() {
+		let db = make_db(&[]);
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		overlay.insert(&h1, 1, &H256::default(), ChangeSet::default()).unwrap();
+		overlay.insert(&h2, 2, &H256::default(), ChangeSet::default()).unwrap();
+	}
+
+	#[test]
+	fn insert_existing_fails() {
+		let db = make_db(&[]);
+		let h1 = H256::random();
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		overlay.insert(&h1, 2, &H256::default(), ChangeSet::default()).unwrap();
+		assert!(matches!(
+			overlay.insert(&h1, 2, &H256::default(), ChangeSet::default()),
+			Err(StateDbError::BlockAlreadyExists)
+		));
+	}
+
+	#[test]
+	#[should_panic]
+	fn canonicalize_unknown_panics() {
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let db = make_db(&[]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		overlay.insert(&h1, 1, &H256::default(), ChangeSet::default()).unwrap();
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h2, &mut commit).unwrap();
+	}
+
+	#[test]
+	fn insert_canonicalize_one() {
+		let h1 = H256::random();
+		let mut db = make_db(&[1, 2]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		let changeset = make_changeset(&[3, 4], &[2]);
+		let insertion = overlay.insert(&h1, 1, &H256::default(), changeset.clone()).unwrap();
+		assert_eq!(insertion.data.inserted.len(), 0);
+		assert_eq!(insertion.data.deleted.len(), 0);
+		assert_eq!(insertion.meta.inserted.len(), 2);
+		assert_eq!(insertion.meta.deleted.len(), 0);
+		db.commit(&insertion);
+		let mut finalization = CommitSet::default();
+		overlay.canonicalize(&h1, &mut finalization).unwrap();
+		assert_eq!(finalization.data.inserted.len(), changeset.inserted.len());
+		assert_eq!(finalization.data.deleted.len(), changeset.deleted.len());
+		assert_eq!(finalization.meta.inserted.len(), 1);
+		assert_eq!(finalization.meta.deleted.len(), 1);
+		db.commit(&finalization);
+		assert!(db.data_eq(&make_db(&[1, 3, 4])));
+	}
+
+	#[test]
+	fn restore_from_journal() {
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let mut db = make_db(&[1, 2]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(
+			&overlay
+				.insert(&h1, 10, &H256::default(), make_changeset(&[3, 4], &[2]))
+				.unwrap(),
+		);
+		db.commit(&overlay.insert(&h2, 11, &h1, make_changeset(&[5], &[3])).unwrap());
+		assert_eq!(db.meta_len(), 3);
+
+		let overlay2 = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		assert_eq!(overlay.levels, overlay2.levels);
+		assert_eq!(overlay.parents, overlay2.parents);
+		assert_eq!(overlay.last_canonicalized, overlay2.last_canonicalized);
+	}
+
+	#[test]
+	fn restore_from_journal_after_canonicalize() {
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let mut db = make_db(&[1, 2]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(
+			&overlay
+				.insert(&h1, 10, &H256::default(), make_changeset(&[3, 4], &[2]))
+				.unwrap(),
+		);
+		db.commit(&overlay.insert(&h2, 11, &h1, make_changeset(&[5], &[3])).unwrap());
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h1, &mut commit).unwrap();
+		overlay.unpin(&h1);
+		db.commit(&commit);
+		assert_eq!(overlay.levels.len(), 1);
+
+		let overlay2 = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		assert_eq!(overlay.levels, overlay2.levels);
+		assert_eq!(overlay.parents, overlay2.parents);
+		assert_eq!(overlay.last_canonicalized, overlay2.last_canonicalized);
+	}
+
+	#[test]
+	fn insert_canonicalize_two() {
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let mut db = make_db(&[1, 2, 3, 4]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		let changeset1 = make_changeset(&[5, 6], &[2]);
+		let changeset2 = make_changeset(&[7, 8], &[5, 3]);
+		db.commit(&overlay.insert(&h1, 1, &H256::default(), changeset1).unwrap());
+		assert!(contains(&overlay, 5));
+		db.commit(&overlay.insert(&h2, 2, &h1, changeset2).unwrap());
+		assert!(contains(&overlay, 7));
+		assert!(contains(&overlay, 5));
+		assert_eq!(overlay.levels.len(), 2);
+		assert_eq!(overlay.parents.len(), 2);
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h1, &mut commit).unwrap();
+		db.commit(&commit);
+		overlay.sync();
+		assert!(!contains(&overlay, 5));
+		assert!(contains(&overlay, 7));
+		assert_eq!(overlay.levels.len(), 1);
+		assert_eq!(overlay.parents.len(), 1);
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h2, &mut commit).unwrap();
+		db.commit(&commit);
+		overlay.sync();
+		assert_eq!(overlay.levels.len(), 0);
+		assert_eq!(overlay.parents.len(), 0);
+		assert!(db.data_eq(&make_db(&[1, 4, 6, 7, 8])));
+	}
+
+	#[test]
+	fn insert_same_key() {
+		let mut db = make_db(&[]);
+		let (h_1, c_1) = (H256::random(), make_changeset(&[1], &[]));
+		let (h_2, c_2) = (H256::random(), make_changeset(&[1], &[]));
+
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&h_1, 1, &H256::default(), c_1).unwrap());
+		db.commit(&overlay.insert(&h_2, 1, &H256::default(), c_2).unwrap());
+		assert!(contains(&overlay, 1));
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_1, &mut commit).unwrap();
+		db.commit(&commit);
+		overlay.sync();
+		assert!(!contains(&overlay, 1));
+	}
+
+	#[test]
+	fn insert_and_canonicalize() {
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let h3 = H256::random();
+		let mut db = make_db(&[]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		let changeset = make_changeset(&[], &[]);
+		db.commit(&overlay.insert(&h1, 1, &H256::default(), changeset.clone()).unwrap());
+		db.commit(&overlay.insert(&h2, 2, &h1, changeset.clone()).unwrap());
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h1, &mut commit).unwrap();
+		overlay.canonicalize(&h2, &mut commit).unwrap();
+		db.commit(&commit);
+		db.commit(&overlay.insert(&h3, 3, &h2, changeset.clone()).unwrap());
+		assert_eq!(overlay.levels.len(), 1);
+	}
+
+	#[test]
+	fn complex_tree() {
+		let mut db = make_db(&[]);
+
+		#[rustfmt::skip]
+		// - 1 - 1_1 - 1_1_1
+		//     \ 1_2 - 1_2_1
+		//           \ 1_2_2
+		//           \ 1_2_3
+		//
+		// - 2 - 2_1 - 2_1_1
+		//     \ 2_2
+		//
+		// 1_2_2 is the winner
+
+		let (h_1, c_1) = (H256::random(), make_changeset(&[1], &[]));
+		let (h_2, c_2) = (H256::random(), make_changeset(&[2], &[]));
+
+		let (h_1_1, c_1_1) = (H256::random(), make_changeset(&[11], &[]));
+		let (h_1_2, c_1_2) = (H256::random(), make_changeset(&[12], &[]));
+		let (h_2_1, c_2_1) = (H256::random(), make_changeset(&[21], &[]));
+		let (h_2_2, c_2_2) = (H256::random(), make_changeset(&[22], &[]));
+
+		let (h_1_1_1, c_1_1_1) = (H256::random(), make_changeset(&[111], &[]));
+		let (h_1_2_1, c_1_2_1) = (H256::random(), make_changeset(&[121], &[]));
+		let (h_1_2_2, c_1_2_2) = (H256::random(), make_changeset(&[122], &[]));
+		let (h_1_2_3, c_1_2_3) = (H256::random(), make_changeset(&[123], &[]));
+		let (h_2_1_1, c_2_1_1) = (H256::random(), make_changeset(&[211], &[]));
+
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&h_1, 1, &H256::default(), c_1).unwrap());
+
+		db.commit(&overlay.insert(&h_1_1, 2, &h_1, c_1_1).unwrap());
+		db.commit(&overlay.insert(&h_1_2, 2, &h_1, c_1_2).unwrap());
+
+		db.commit(&overlay.insert(&h_2, 1, &H256::default(), c_2).unwrap());
+
+		db.commit(&overlay.insert(&h_2_1, 2, &h_2, c_2_1).unwrap());
+		db.commit(&overlay.insert(&h_2_2, 2, &h_2, c_2_2).unwrap());
+
+		db.commit(&overlay.insert(&h_1_1_1, 3, &h_1_1, c_1_1_1).unwrap());
+		db.commit(&overlay.insert(&h_1_2_1, 3, &h_1_2, c_1_2_1).unwrap());
+		db.commit(&overlay.insert(&h_1_2_2, 3, &h_1_2, c_1_2_2).unwrap());
+		db.commit(&overlay.insert(&h_1_2_3, 3, &h_1_2, c_1_2_3).unwrap());
+		db.commit(&overlay.insert(&h_2_1_1, 3, &h_2_1, c_2_1_1).unwrap());
+
+		assert!(contains(&overlay, 2));
+		assert!(contains(&overlay, 11));
+		assert!(contains(&overlay, 21));
+		assert!(contains(&overlay, 111));
+		assert!(contains(&overlay, 122));
+		assert!(contains(&overlay, 211));
+		assert_eq!(overlay.levels.len(), 3);
+		assert_eq!(overlay.parents.len(), 11);
+		assert_eq!(overlay.last_canonicalized, Some((H256::default(), 0)));
+
+		// check if restoration from journal results in the same tree
+		let overlay2 = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		assert_eq!(overlay.levels, overlay2.levels);
+		assert_eq!(overlay.parents, overlay2.parents);
+		assert_eq!(overlay.last_canonicalized, overlay2.last_canonicalized);
+
+		// canonicalize 1. 2 and all its children should be discarded
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_1, &mut commit).unwrap();
+		db.commit(&commit);
+		overlay.sync();
+		assert_eq!(overlay.levels.len(), 2);
+		assert_eq!(overlay.parents.len(), 6);
+		assert!(!contains(&overlay, 1));
+		assert!(!contains(&overlay, 2));
+		assert!(!contains(&overlay, 21));
+		assert!(!contains(&overlay, 22));
+		assert!(!contains(&overlay, 211));
+		assert!(contains(&overlay, 111));
+		assert!(!contains(&overlay, 211));
+		// check that journals are deleted
+		assert!(db.get_meta(&to_journal_key(1, 0)).unwrap().is_none());
+		assert!(db.get_meta(&to_journal_key(1, 1)).unwrap().is_none());
+		assert!(db.get_meta(&to_journal_key(2, 1)).unwrap().is_some());
+		assert!(db.get_meta(&to_journal_key(2, 2)).unwrap().is_none());
+		assert!(db.get_meta(&to_journal_key(2, 3)).unwrap().is_none());
+
+		// canonicalize 1_2. 1_1 and all its children should be discarded
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_1_2, &mut commit).unwrap();
+		db.commit(&commit);
+		overlay.sync();
+		assert_eq!(overlay.levels.len(), 1);
+		assert_eq!(overlay.parents.len(), 3);
+		assert!(!contains(&overlay, 11));
+		assert!(!contains(&overlay, 111));
+		assert!(contains(&overlay, 121));
+		assert!(contains(&overlay, 122));
+		assert!(contains(&overlay, 123));
+		assert!(overlay.have_block(&h_1_2_1));
+		assert!(!overlay.have_block(&h_1_2));
+		assert!(!overlay.have_block(&h_1_1));
+		assert!(!overlay.have_block(&h_1_1_1));
+
+		// canonicalize 1_2_2
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_1_2_2, &mut commit).unwrap();
+		db.commit(&commit);
+		overlay.sync();
+		assert_eq!(overlay.levels.len(), 0);
+		assert_eq!(overlay.parents.len(), 0);
+		assert!(db.data_eq(&make_db(&[1, 12, 122])));
+		assert_eq!(overlay.last_canonicalized, Some((h_1_2_2, 3)));
+	}
+
+	#[test]
+	fn insert_revert() {
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let mut db = make_db(&[1, 2, 3, 4]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		assert!(overlay.revert_one().is_none());
+		let changeset1 = make_changeset(&[5, 6], &[2]);
+		let changeset2 = make_changeset(&[7, 8], &[5, 3]);
+		db.commit(&overlay.insert(&h1, 1, &H256::default(), changeset1).unwrap());
+		db.commit(&overlay.insert(&h2, 2, &h1, changeset2).unwrap());
+		assert!(contains(&overlay, 7));
+		db.commit(&overlay.revert_one().unwrap());
+		assert_eq!(overlay.parents.len(), 1);
+		assert!(contains(&overlay, 5));
+		assert!(!contains(&overlay, 7));
+		db.commit(&overlay.revert_one().unwrap());
+		assert_eq!(overlay.levels.len(), 0);
+		assert_eq!(overlay.parents.len(), 0);
+		assert!(overlay.revert_one().is_none());
+	}
+
+	#[test]
+	fn keeps_pinned() {
+		let mut db = make_db(&[]);
+
+		#[rustfmt::skip]
+		// - 0 - 1_1
+		//     \ 1_2
+
+		let (h_1, c_1) = (H256::random(), make_changeset(&[1], &[]));
+		let (h_2, c_2) = (H256::random(), make_changeset(&[2], &[]));
+
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&h_1, 1, &H256::default(), c_1).unwrap());
+		db.commit(&overlay.insert(&h_2, 1, &H256::default(), c_2).unwrap());
+
+		overlay.pin(&h_1);
+
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_2, &mut commit).unwrap();
+		db.commit(&commit);
+		assert!(contains(&overlay, 1));
+		overlay.unpin(&h_1);
+		assert!(!contains(&overlay, 1));
+	}
+
+	#[test]
+	fn keeps_pinned_ref_count() {
+		let mut db = make_db(&[]);
+
+		#[rustfmt::skip]
+		// - 0 - 1_1
+		//     \ 1_2
+		//     \ 1_3
+
+		// 1_1 and 1_2 both make the same change
+		let (h_1, c_1) = (H256::random(), make_changeset(&[1], &[]));
+		let (h_2, c_2) = (H256::random(), make_changeset(&[1], &[]));
+		let (h_3, c_3) = (H256::random(), make_changeset(&[], &[]));
+
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&h_1, 1, &H256::default(), c_1).unwrap());
+		db.commit(&overlay.insert(&h_2, 1, &H256::default(), c_2).unwrap());
+		db.commit(&overlay.insert(&h_3, 1, &H256::default(), c_3).unwrap());
+
+		overlay.pin(&h_1);
+
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_3, &mut commit).unwrap();
+		db.commit(&commit);
+
+		assert!(contains(&overlay, 1));
+		overlay.unpin(&h_1);
+		assert!(!contains(&overlay, 1));
+	}
+
+	#[test]
+	fn pins_canonicalized() {
+		let mut db = make_db(&[]);
+
+		let (h_1, c_1) = (H256::random(), make_changeset(&[1], &[]));
+		let (h_2, c_2) = (H256::random(), make_changeset(&[2], &[]));
+
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&h_1, 1, &H256::default(), c_1).unwrap());
+		db.commit(&overlay.insert(&h_2, 2, &h_1, c_2).unwrap());
+
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_1, &mut commit).unwrap();
+		overlay.canonicalize(&h_2, &mut commit).unwrap();
+		assert!(contains(&overlay, 1));
+		assert!(contains(&overlay, 2));
+		db.commit(&commit);
+		overlay.sync();
+		assert!(!contains(&overlay, 1));
+		assert!(!contains(&overlay, 2));
+	}
+
+	#[test]
+	fn pin_keeps_parent() {
+		let mut db = make_db(&[]);
+
+		#[rustfmt::skip]
+		// - 0 - 1_1 - 2_1
+		//     \ 1_2
+
+		let (h_11, c_11) = (H256::random(), make_changeset(&[1], &[]));
+		let (h_12, c_12) = (H256::random(), make_changeset(&[], &[]));
+		let (h_21, c_21) = (H256::random(), make_changeset(&[], &[]));
+
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&h_11, 1, &H256::default(), c_11).unwrap());
+		db.commit(&overlay.insert(&h_12, 1, &H256::default(), c_12).unwrap());
+		db.commit(&overlay.insert(&h_21, 2, &h_11, c_21).unwrap());
+
+		overlay.pin(&h_21);
+
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h_12, &mut commit).unwrap();
+		db.commit(&commit);
+
+		assert!(contains(&overlay, 1));
+		overlay.unpin(&h_21);
+		assert!(!contains(&overlay, 1));
+		overlay.unpin(&h_12);
+		assert!(overlay.pinned.is_empty());
+	}
+
+	#[test]
+	fn restore_from_journal_after_canonicalize_no_first() {
+		// This test discards a branch that is journaled under a non-zero index on level 1,
+		// making sure all journals are loaded for each level even if some of them are missing.
+		let root = H256::random();
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let h11 = H256::random();
+		let h21 = H256::random();
+		let mut db = make_db(&[]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&root, 10, &H256::default(), make_changeset(&[], &[])).unwrap());
+		db.commit(&overlay.insert(&h1, 11, &root, make_changeset(&[1], &[])).unwrap());
+		db.commit(&overlay.insert(&h2, 11, &root, make_changeset(&[2], &[])).unwrap());
+		db.commit(&overlay.insert(&h11, 12, &h1, make_changeset(&[11], &[])).unwrap());
+		db.commit(&overlay.insert(&h21, 12, &h2, make_changeset(&[21], &[])).unwrap());
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&root, &mut commit).unwrap();
+		overlay.canonicalize(&h2, &mut commit).unwrap(); // h11 should stay in the DB
+		db.commit(&commit);
+		assert_eq!(overlay.levels.len(), 1);
+		assert!(contains(&overlay, 21));
+		assert!(!contains(&overlay, 11));
+		assert!(db.get_meta(&to_journal_key(12, 1)).unwrap().is_some());
+
+		// Restore into a new overlay and check that journaled value exists.
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		assert!(contains(&overlay, 21));
+
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&h21, &mut commit).unwrap(); // h11 should stay in the DB
+		db.commit(&commit);
+		overlay.sync();
+		assert!(!contains(&overlay, 21));
+	}
+
+	#[test]
+	fn index_reuse() {
+		// This test discards a branch that is journaled under a non-zero index on level 1,
+		// making sure all journals are loaded for each level even if some of them are missing.
+		let root = H256::random();
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let h11 = H256::random();
+		let h21 = H256::random();
+		let mut db = make_db(&[]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&root, 10, &H256::default(), make_changeset(&[], &[])).unwrap());
+		db.commit(&overlay.insert(&h1, 11, &root, make_changeset(&[1], &[])).unwrap());
+		db.commit(&overlay.insert(&h2, 11, &root, make_changeset(&[2], &[])).unwrap());
+		db.commit(&overlay.insert(&h11, 12, &h1, make_changeset(&[11], &[])).unwrap());
+		db.commit(&overlay.insert(&h21, 12, &h2, make_changeset(&[21], &[])).unwrap());
+		let mut commit = CommitSet::default();
+		overlay.canonicalize(&root, &mut commit).unwrap();
+		overlay.canonicalize(&h2, &mut commit).unwrap(); // h11 should stay in the DB
+		db.commit(&commit);
+
+		// add another block at top level. It should reuse journal index 0 of previously discarded
+		// block
+		let h22 = H256::random();
+		db.commit(&overlay.insert(&h22, 12, &h2, make_changeset(&[22], &[])).unwrap());
+		assert_eq!(overlay.levels[0].blocks[0].journal_index, 1);
+		assert_eq!(overlay.levels[0].blocks[1].journal_index, 0);
+
+		// Restore into a new overlay and check that journaled value exists.
+		let overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		assert_eq!(overlay.parents.len(), 2);
+		assert!(contains(&overlay, 21));
+		assert!(contains(&overlay, 22));
+	}
+
+	#[test]
+	fn remove_works() {
+		let root = H256::random();
+		let h1 = H256::random();
+		let h2 = H256::random();
+		let h11 = H256::random();
+		let h21 = H256::random();
+		let mut db = make_db(&[]);
+		let mut overlay = NonCanonicalOverlay::<H256, H256>::new(&db).unwrap();
+		db.commit(&overlay.insert(&root, 10, &H256::default(), make_changeset(&[], &[])).unwrap());
+		db.commit(&overlay.insert(&h1, 11, &root, make_changeset(&[1], &[])).unwrap());
+		db.commit(&overlay.insert(&h2, 11, &root, make_changeset(&[2], &[])).unwrap());
+		db.commit(&overlay.insert(&h11, 12, &h1, make_changeset(&[11], &[])).unwrap());
+		db.commit(&overlay.insert(&h21, 12, &h2, make_changeset(&[21], &[])).unwrap());
+		assert!(overlay.remove(&h1).is_none());
+		assert!(overlay.remove(&h2).is_none());
+		assert_eq!(overlay.levels.len(), 3);
+
+		db.commit(&overlay.remove(&h11).unwrap());
+		assert!(!contains(&overlay, 11));
+
+		db.commit(&overlay.remove(&h21).unwrap());
+		assert_eq!(overlay.levels.len(), 2);
+
+		db.commit(&overlay.remove(&h2).unwrap());
+		assert!(!contains(&overlay, 2));
+	}
+}
diff --git a/substrate/client/state-db/src/pruning.rs b/substrate/client/state-db/src/pruning.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7bee2b1d99a34edd9516b924c54d56897117a053
--- /dev/null
+++ b/substrate/client/state-db/src/pruning.rs
@@ -0,0 +1,872 @@
+// 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/>.
+
+//! Pruning window.
+//!
+//! For each block we maintain a list of nodes pending deletion.
+//! There is also a global index of node key to block number.
+//! If a node is re-inserted into the window it gets removed from
+//! the death list.
+//! The changes are journaled in the DB.
+
+use crate::{
+	noncanonical::LAST_CANONICAL, to_meta_key, CommitSet, Error, Hash, MetaDb, StateDbError,
+	DEFAULT_MAX_BLOCK_CONSTRAINT, LOG_TARGET,
+};
+use codec::{Decode, Encode};
+use log::trace;
+use std::collections::{HashMap, HashSet, VecDeque};
+
+pub(crate) const LAST_PRUNED: &[u8] = b"last_pruned";
+const PRUNING_JOURNAL: &[u8] = b"pruning_journal";
+
+/// See module documentation.
+pub struct RefWindow<BlockHash: Hash, Key: Hash, D: MetaDb> {
+	/// A queue of blocks keep tracking keys that should be deleted for each block in the
+	/// pruning window.
+	queue: DeathRowQueue<BlockHash, Key, D>,
+	/// Block number that is next to be pruned.
+	base: u64,
+}
+
+/// `DeathRowQueue` used to keep track of blocks in the pruning window, there are two flavors:
+/// - `Mem`, used when the backend database do not supports reference counting, keep all
+/// 	blocks in memory, and keep track of re-inserted keys to not delete them when pruning
+/// - `DbBacked`, used when the backend database supports reference counting, only keep
+/// 	a few number of blocks in memory and load more blocks on demand
+enum DeathRowQueue<BlockHash: Hash, Key: Hash, D: MetaDb> {
+	Mem {
+		/// A queue of keys that should be deleted for each block in the pruning window.
+		death_rows: VecDeque<DeathRow<BlockHash, Key>>,
+		/// An index that maps each key from `death_rows` to block number.
+		death_index: HashMap<Key, u64>,
+	},
+	DbBacked {
+		// The backend database
+		db: D,
+		/// A queue of keys that should be deleted for each block in the pruning window.
+		/// Only caching the first few blocks of the pruning window, blocks inside are
+		/// successive and ordered by block number
+		cache: VecDeque<DeathRow<BlockHash, Key>>,
+		/// A soft limit of the cache's size
+		cache_capacity: usize,
+		/// Last block number added to the window
+		last: Option<u64>,
+	},
+}
+
+impl<BlockHash: Hash, Key: Hash, D: MetaDb> DeathRowQueue<BlockHash, Key, D> {
+	/// Return a `DeathRowQueue` that all blocks are keep in memory
+	fn new_mem(db: &D, base: u64) -> Result<DeathRowQueue<BlockHash, Key, D>, Error<D::Error>> {
+		let mut block = base;
+		let mut queue = DeathRowQueue::<BlockHash, Key, D>::Mem {
+			death_rows: VecDeque::new(),
+			death_index: HashMap::new(),
+		};
+		// read the journal
+		trace!(
+			target: LOG_TARGET,
+			"Reading pruning journal for the memory queue. Pending #{}",
+			base,
+		);
+		loop {
+			let journal_key = to_journal_key(block);
+			match db.get_meta(&journal_key).map_err(Error::Db)? {
+				Some(record) => {
+					let record: JournalRecord<BlockHash, Key> =
+						Decode::decode(&mut record.as_slice())?;
+					trace!(
+						target: LOG_TARGET,
+						"Pruning journal entry {} ({} inserted, {} deleted)",
+						block,
+						record.inserted.len(),
+						record.deleted.len(),
+					);
+					queue.import(base, block, record);
+				},
+				None => break,
+			}
+			block += 1;
+		}
+		Ok(queue)
+	}
+
+	/// Return a `DeathRowQueue` that backed by an database, and only keep a few number
+	/// of blocks in memory
+	fn new_db_backed(
+		db: D,
+		base: u64,
+		last: Option<u64>,
+		window_size: u32,
+	) -> Result<DeathRowQueue<BlockHash, Key, D>, Error<D::Error>> {
+		// limit the cache capacity from 1 to `DEFAULT_MAX_BLOCK_CONSTRAINT`
+		let cache_capacity = window_size.clamp(1, DEFAULT_MAX_BLOCK_CONSTRAINT) as usize;
+		let mut cache = VecDeque::with_capacity(cache_capacity);
+		trace!(
+			target: LOG_TARGET,
+			"Reading pruning journal for the database-backed queue. Pending #{}",
+			base
+		);
+		DeathRowQueue::load_batch_from_db(&db, &mut cache, base, cache_capacity)?;
+		Ok(DeathRowQueue::DbBacked { db, cache, cache_capacity, last })
+	}
+
+	/// import a new block to the back of the queue
+	fn import(&mut self, base: u64, num: u64, journal_record: JournalRecord<BlockHash, Key>) {
+		let JournalRecord { hash, inserted, deleted } = journal_record;
+		trace!(target: LOG_TARGET, "Importing {}, base={}", num, base);
+		match self {
+			DeathRowQueue::DbBacked { cache, cache_capacity, last, .. } => {
+				// If the new block continues cached range and there is space, load it directly into
+				// cache.
+				if num == base + cache.len() as u64 && cache.len() < *cache_capacity {
+					trace!(target: LOG_TARGET, "Adding to DB backed cache {:?} (#{})", hash, num);
+					cache.push_back(DeathRow { hash, deleted: deleted.into_iter().collect() });
+				}
+				*last = Some(num);
+			},
+			DeathRowQueue::Mem { death_rows, death_index } => {
+				// remove all re-inserted keys from death rows
+				for k in inserted {
+					if let Some(block) = death_index.remove(&k) {
+						death_rows[(block - base) as usize].deleted.remove(&k);
+					}
+				}
+				// add new keys
+				let imported_block = base + death_rows.len() as u64;
+				for k in deleted.iter() {
+					death_index.insert(k.clone(), imported_block);
+				}
+				death_rows.push_back(DeathRow { hash, deleted: deleted.into_iter().collect() });
+			},
+		}
+	}
+
+	/// Pop out one block from the front of the queue, `base` is the block number
+	/// of the first block of the queue
+	fn pop_front(
+		&mut self,
+		base: u64,
+	) -> Result<Option<DeathRow<BlockHash, Key>>, Error<D::Error>> {
+		match self {
+			DeathRowQueue::DbBacked { db, cache, cache_capacity, .. } => {
+				if cache.is_empty() {
+					DeathRowQueue::load_batch_from_db(db, cache, base, *cache_capacity)?;
+				}
+				Ok(cache.pop_front())
+			},
+			DeathRowQueue::Mem { death_rows, death_index } => match death_rows.pop_front() {
+				Some(row) => {
+					for k in row.deleted.iter() {
+						death_index.remove(k);
+					}
+					Ok(Some(row))
+				},
+				None => Ok(None),
+			},
+		}
+	}
+
+	/// Load a batch of blocks from the backend database into `cache`, starting from `base` and up
+	/// to `base + cache_capacity`
+	fn load_batch_from_db(
+		db: &D,
+		cache: &mut VecDeque<DeathRow<BlockHash, Key>>,
+		base: u64,
+		cache_capacity: usize,
+	) -> Result<(), Error<D::Error>> {
+		let start = base + cache.len() as u64;
+		let batch_size = cache_capacity;
+		for i in 0..batch_size as u64 {
+			match load_death_row_from_db::<BlockHash, Key, D>(db, start + i)? {
+				Some(row) => {
+					cache.push_back(row);
+				},
+				None => break,
+			}
+		}
+		Ok(())
+	}
+
+	/// Check if the block at the given `index` of the queue exist
+	/// it is the caller's responsibility to ensure `index` won't be out of bounds
+	fn have_block(&self, hash: &BlockHash, index: usize) -> HaveBlock {
+		match self {
+			DeathRowQueue::DbBacked { cache, .. } => {
+				if cache.len() > index {
+					(cache[index].hash == *hash).into()
+				} else {
+					// The block is not in the cache but it still may exist on disk.
+					HaveBlock::Maybe
+				}
+			},
+			DeathRowQueue::Mem { death_rows, .. } => (death_rows[index].hash == *hash).into(),
+		}
+	}
+
+	/// Return the number of block in the pruning window
+	fn len(&self, base: u64) -> u64 {
+		match self {
+			DeathRowQueue::DbBacked { last, .. } => last.map_or(0, |l| l + 1 - base),
+			DeathRowQueue::Mem { death_rows, .. } => death_rows.len() as u64,
+		}
+	}
+
+	#[cfg(test)]
+	fn get_mem_queue_state(
+		&self,
+	) -> Option<(&VecDeque<DeathRow<BlockHash, Key>>, &HashMap<Key, u64>)> {
+		match self {
+			DeathRowQueue::DbBacked { .. } => None,
+			DeathRowQueue::Mem { death_rows, death_index } => Some((death_rows, death_index)),
+		}
+	}
+
+	#[cfg(test)]
+	fn get_db_backed_queue_state(
+		&self,
+	) -> Option<(&VecDeque<DeathRow<BlockHash, Key>>, Option<u64>)> {
+		match self {
+			DeathRowQueue::DbBacked { cache, last, .. } => Some((cache, *last)),
+			DeathRowQueue::Mem { .. } => None,
+		}
+	}
+}
+
+fn load_death_row_from_db<BlockHash: Hash, Key: Hash, D: MetaDb>(
+	db: &D,
+	block: u64,
+) -> Result<Option<DeathRow<BlockHash, Key>>, Error<D::Error>> {
+	let journal_key = to_journal_key(block);
+	match db.get_meta(&journal_key).map_err(Error::Db)? {
+		Some(record) => {
+			let JournalRecord { hash, deleted, .. } = Decode::decode(&mut record.as_slice())?;
+			Ok(Some(DeathRow { hash, deleted: deleted.into_iter().collect() }))
+		},
+		None => Ok(None),
+	}
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct DeathRow<BlockHash: Hash, Key: Hash> {
+	hash: BlockHash,
+	deleted: HashSet<Key>,
+}
+
+#[derive(Encode, Decode, Default)]
+struct JournalRecord<BlockHash: Hash, Key: Hash> {
+	hash: BlockHash,
+	inserted: Vec<Key>,
+	deleted: Vec<Key>,
+}
+
+fn to_journal_key(block: u64) -> Vec<u8> {
+	to_meta_key(PRUNING_JOURNAL, &block)
+}
+
+/// The result return by `RefWindow::have_block`
+#[derive(Debug, PartialEq, Eq)]
+pub enum HaveBlock {
+	/// Definitely don't have this block.
+	No,
+	/// May or may not have this block, need further checking
+	Maybe,
+	/// Definitely has this block
+	Yes,
+}
+
+impl From<bool> for HaveBlock {
+	fn from(have: bool) -> Self {
+		if have {
+			HaveBlock::Yes
+		} else {
+			HaveBlock::No
+		}
+	}
+}
+
+impl<BlockHash: Hash, Key: Hash, D: MetaDb> RefWindow<BlockHash, Key, D> {
+	pub fn new(
+		db: D,
+		window_size: u32,
+		count_insertions: bool,
+	) -> Result<RefWindow<BlockHash, Key, D>, Error<D::Error>> {
+		// the block number of the first block in the queue or the next block number if the queue is
+		// empty
+		let base = match db.get_meta(&to_meta_key(LAST_PRUNED, &())).map_err(Error::Db)? {
+			Some(buffer) => u64::decode(&mut buffer.as_slice())? + 1,
+			None => 0,
+		};
+		// the block number of the last block in the queue
+		let last_canonicalized_number =
+			match db.get_meta(&to_meta_key(LAST_CANONICAL, &())).map_err(Error::Db)? {
+				Some(buffer) => Some(<(BlockHash, u64)>::decode(&mut buffer.as_slice())?.1),
+				None => None,
+			};
+
+		let queue = if count_insertions {
+			// Highly scientific crafted number for deciding when to print the warning!
+			//
+			// Rocksdb doesn't support refcounting and requires that we load the entire pruning
+			// window into the memory.
+			if window_size > 1000 {
+				log::warn!(
+					target: LOG_TARGET,
+					"Large pruning window of {window_size} detected! THIS CAN LEAD TO HIGH MEMORY USAGE AND CRASHES. \
+					Reduce the pruning window or switch your database to paritydb."
+				);
+			}
+
+			DeathRowQueue::new_mem(&db, base)?
+		} else {
+			let last = match last_canonicalized_number {
+				Some(last_canonicalized_number) => {
+					debug_assert!(last_canonicalized_number + 1 >= base);
+					Some(last_canonicalized_number)
+				},
+				// None means `LAST_CANONICAL` is never been wrote, since the pruning journals are
+				// in the same `CommitSet` as `LAST_CANONICAL`, it means no pruning journal have
+				// ever been committed to the db, thus set `unload` to zero
+				None => None,
+			};
+			DeathRowQueue::new_db_backed(db, base, last, window_size)?
+		};
+
+		Ok(RefWindow { queue, base })
+	}
+
+	pub fn window_size(&self) -> u64 {
+		self.queue.len(self.base) as u64
+	}
+
+	/// Get the hash of the next pruning block
+	pub fn next_hash(&mut self) -> Result<Option<BlockHash>, Error<D::Error>> {
+		let res = match &mut self.queue {
+			DeathRowQueue::DbBacked { db, cache, cache_capacity, .. } => {
+				if cache.is_empty() {
+					DeathRowQueue::load_batch_from_db(db, cache, self.base, *cache_capacity)?;
+				}
+				cache.front().map(|r| r.hash.clone())
+			},
+			DeathRowQueue::Mem { death_rows, .. } => death_rows.front().map(|r| r.hash.clone()),
+		};
+		Ok(res)
+	}
+
+	fn is_empty(&self) -> bool {
+		self.window_size() == 0
+	}
+
+	// Check if a block is in the pruning window and not be pruned yet
+	pub fn have_block(&self, hash: &BlockHash, number: u64) -> HaveBlock {
+		// if the queue is empty or the block number exceed the pruning window, we definitely
+		// do not have this block
+		if self.is_empty() || number < self.base || number >= self.base + self.window_size() {
+			return HaveBlock::No
+		}
+		self.queue.have_block(hash, (number - self.base) as usize)
+	}
+
+	/// Prune next block. Expects at least one block in the window. Adds changes to `commit`.
+	pub fn prune_one(&mut self, commit: &mut CommitSet<Key>) -> Result<(), Error<D::Error>> {
+		if let Some(pruned) = self.queue.pop_front(self.base)? {
+			trace!(target: "state-db", "Pruning {:?} ({} deleted)", pruned.hash, pruned.deleted.len());
+			let index = self.base;
+			commit.data.deleted.extend(pruned.deleted.into_iter());
+			commit.meta.inserted.push((to_meta_key(LAST_PRUNED, &()), index.encode()));
+			commit.meta.deleted.push(to_journal_key(self.base));
+			self.base += 1;
+			Ok(())
+		} else {
+			trace!(target: "state-db", "Trying to prune when there's nothing to prune");
+			Err(Error::StateDb(StateDbError::BlockUnavailable))
+		}
+	}
+
+	/// Add a change set to the window. Creates a journal record and pushes it to `commit`
+	pub fn note_canonical(
+		&mut self,
+		hash: &BlockHash,
+		number: u64,
+		commit: &mut CommitSet<Key>,
+	) -> Result<(), Error<D::Error>> {
+		if self.base == 0 && self.is_empty() && number > 0 {
+			// assume that parent was canonicalized
+			self.base = number;
+		} else if (self.base + self.window_size()) != number {
+			return Err(Error::StateDb(StateDbError::InvalidBlockNumber))
+		}
+		trace!(target: "state-db", "Adding to pruning window: {:?} ({} inserted, {} deleted)", hash, commit.data.inserted.len(), commit.data.deleted.len());
+		let inserted = if matches!(self.queue, DeathRowQueue::Mem { .. }) {
+			commit.data.inserted.iter().map(|(k, _)| k.clone()).collect()
+		} else {
+			Default::default()
+		};
+		let deleted = std::mem::take(&mut commit.data.deleted);
+		let journal_record = JournalRecord { hash: hash.clone(), inserted, deleted };
+		commit.meta.inserted.push((to_journal_key(number), journal_record.encode()));
+		self.queue.import(self.base, number, journal_record);
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{to_journal_key, DeathRowQueue, HaveBlock, JournalRecord, RefWindow, LAST_PRUNED};
+	use crate::{
+		noncanonical::LAST_CANONICAL,
+		test::{make_commit, make_db, TestDb},
+		to_meta_key, CommitSet, Error, Hash, StateDbError, DEFAULT_MAX_BLOCK_CONSTRAINT,
+	};
+	use codec::Encode;
+	use sp_core::H256;
+
+	fn check_journal(pruning: &RefWindow<H256, H256, TestDb>, db: &TestDb) {
+		let count_insertions = matches!(pruning.queue, DeathRowQueue::Mem { .. });
+		let restored: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, count_insertions).unwrap();
+		assert_eq!(pruning.base, restored.base);
+		assert_eq!(pruning.queue.get_mem_queue_state(), restored.queue.get_mem_queue_state());
+	}
+
+	#[test]
+	fn created_from_empty_db() {
+		let db = make_db(&[]);
+		let pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db, DEFAULT_MAX_BLOCK_CONSTRAINT, true).unwrap();
+		assert_eq!(pruning.base, 0);
+		let (death_rows, death_index) = pruning.queue.get_mem_queue_state().unwrap();
+		assert!(death_rows.is_empty());
+		assert!(death_index.is_empty());
+	}
+
+	#[test]
+	fn prune_empty() {
+		let db = make_db(&[]);
+		let mut pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db, DEFAULT_MAX_BLOCK_CONSTRAINT, true).unwrap();
+		let mut commit = CommitSet::default();
+		assert_eq!(
+			Err(Error::StateDb(StateDbError::BlockUnavailable)),
+			pruning.prune_one(&mut commit)
+		);
+		assert_eq!(pruning.base, 0);
+		let (death_rows, death_index) = pruning.queue.get_mem_queue_state().unwrap();
+		assert!(death_rows.is_empty());
+		assert!(death_index.is_empty());
+	}
+
+	#[test]
+	fn prune_one() {
+		let mut db = make_db(&[1, 2, 3]);
+		let mut pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, true).unwrap();
+		let mut commit = make_commit(&[4, 5], &[1, 3]);
+		let hash = H256::random();
+		pruning.note_canonical(&hash, 0, &mut commit).unwrap();
+		db.commit(&commit);
+		assert_eq!(pruning.have_block(&hash, 0), HaveBlock::Yes);
+		assert_eq!(pruning.have_block(&hash, 0), HaveBlock::Yes);
+		assert!(commit.data.deleted.is_empty());
+		let (death_rows, death_index) = pruning.queue.get_mem_queue_state().unwrap();
+		assert_eq!(death_rows.len(), 1);
+		assert_eq!(death_index.len(), 2);
+		assert!(db.data_eq(&make_db(&[1, 2, 3, 4, 5])));
+		check_journal(&pruning, &db);
+
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		assert_eq!(pruning.have_block(&hash, 0), HaveBlock::No);
+		db.commit(&commit);
+		assert_eq!(pruning.have_block(&hash, 0), HaveBlock::No);
+		assert!(db.data_eq(&make_db(&[2, 4, 5])));
+		let (death_rows, death_index) = pruning.queue.get_mem_queue_state().unwrap();
+		assert!(death_rows.is_empty());
+		assert!(death_index.is_empty());
+		assert_eq!(pruning.base, 1);
+	}
+
+	#[test]
+	fn prune_two() {
+		let mut db = make_db(&[1, 2, 3]);
+		let mut pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, true).unwrap();
+		let mut commit = make_commit(&[4], &[1]);
+		pruning.note_canonical(&H256::random(), 0, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[5], &[2]);
+		pruning.note_canonical(&H256::random(), 1, &mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3, 4, 5])));
+
+		check_journal(&pruning, &db);
+
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[2, 3, 4, 5])));
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[3, 4, 5])));
+		assert_eq!(pruning.base, 2);
+	}
+
+	#[test]
+	fn prune_two_pending() {
+		let mut db = make_db(&[1, 2, 3]);
+		let mut pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, true).unwrap();
+		let mut commit = make_commit(&[4], &[1]);
+		pruning.note_canonical(&H256::random(), 0, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[5], &[2]);
+		pruning.note_canonical(&H256::random(), 1, &mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3, 4, 5])));
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[2, 3, 4, 5])));
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[3, 4, 5])));
+		assert_eq!(pruning.base, 2);
+	}
+
+	#[test]
+	fn reinserted_survives() {
+		let mut db = make_db(&[1, 2, 3]);
+		let mut pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, true).unwrap();
+		let mut commit = make_commit(&[], &[2]);
+		pruning.note_canonical(&H256::random(), 0, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[2], &[]);
+		pruning.note_canonical(&H256::random(), 1, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[], &[2]);
+		pruning.note_canonical(&H256::random(), 2, &mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3])));
+
+		check_journal(&pruning, &db);
+
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3])));
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3])));
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 3])));
+		assert_eq!(pruning.base, 3);
+	}
+
+	#[test]
+	fn reinserted_survive_pending() {
+		let mut db = make_db(&[1, 2, 3]);
+		let mut pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, true).unwrap();
+		let mut commit = make_commit(&[], &[2]);
+		pruning.note_canonical(&H256::random(), 0, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[2], &[]);
+		pruning.note_canonical(&H256::random(), 1, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[], &[2]);
+		pruning.note_canonical(&H256::random(), 2, &mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3])));
+
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3])));
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3])));
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 3])));
+		assert_eq!(pruning.base, 3);
+	}
+
+	#[test]
+	fn reinserted_ignores() {
+		let mut db = make_db(&[1, 2, 3]);
+		let mut pruning: RefWindow<H256, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+		let mut commit = make_commit(&[], &[2]);
+		pruning.note_canonical(&H256::random(), 0, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[2], &[]);
+		pruning.note_canonical(&H256::random(), 1, &mut commit).unwrap();
+		db.commit(&commit);
+		let mut commit = make_commit(&[], &[2]);
+		pruning.note_canonical(&H256::random(), 2, &mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 2, 3])));
+
+		check_journal(&pruning, &db);
+
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert!(db.data_eq(&make_db(&[1, 3])));
+	}
+
+	fn push_last_canonicalized<H: Hash>(block: u64, commit: &mut CommitSet<H>) {
+		commit
+			.meta
+			.inserted
+			.push((to_meta_key(LAST_CANONICAL, &()), (block, block).encode()));
+	}
+
+	fn push_last_pruned<H: Hash>(block: u64, commit: &mut CommitSet<H>) {
+		commit.meta.inserted.push((to_meta_key(LAST_PRUNED, &()), block.encode()));
+	}
+
+	#[test]
+	fn init_db_backed_queue() {
+		let mut db = make_db(&[]);
+		let mut commit = CommitSet::default();
+
+		fn load_pruning_from_db(db: TestDb) -> (usize, u64) {
+			let pruning: RefWindow<u64, H256, TestDb> =
+				RefWindow::new(db, DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+			let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+			(cache.len(), pruning.base)
+		}
+
+		fn push_record(block: u64, commit: &mut CommitSet<H256>) {
+			commit
+				.meta
+				.inserted
+				.push((to_journal_key(block), JournalRecord::<u64, H256>::default().encode()));
+		}
+
+		// empty database
+		let (loaded_blocks, base) = load_pruning_from_db(db.clone());
+		assert_eq!(loaded_blocks, 0);
+		assert_eq!(base, 0);
+
+		// canonicalized the genesis block but no pruning
+		push_last_canonicalized(0, &mut commit);
+		push_record(0, &mut commit);
+		db.commit(&commit);
+		let (loaded_blocks, base) = load_pruning_from_db(db.clone());
+		assert_eq!(loaded_blocks, 1);
+		assert_eq!(base, 0);
+
+		// pruned the genesis block
+		push_last_pruned(0, &mut commit);
+		db.commit(&commit);
+		let (loaded_blocks, base) = load_pruning_from_db(db.clone());
+		assert_eq!(loaded_blocks, 0);
+		assert_eq!(base, 1);
+
+		// canonicalize more blocks
+		push_last_canonicalized(10, &mut commit);
+		for i in 1..=10 {
+			push_record(i, &mut commit);
+		}
+		db.commit(&commit);
+		let (loaded_blocks, base) = load_pruning_from_db(db.clone());
+		assert_eq!(loaded_blocks, 10);
+		assert_eq!(base, 1);
+
+		// pruned all blocks
+		push_last_pruned(10, &mut commit);
+		db.commit(&commit);
+		let (loaded_blocks, base) = load_pruning_from_db(db.clone());
+		assert_eq!(loaded_blocks, 0);
+		assert_eq!(base, 11);
+	}
+
+	#[test]
+	fn db_backed_queue() {
+		let mut db = make_db(&[]);
+		let mut pruning: RefWindow<u64, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+		let cache_capacity = DEFAULT_MAX_BLOCK_CONSTRAINT as usize;
+
+		// start as an empty queue
+		let (cache, last) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), 0);
+		assert_eq!(last, None);
+
+		// import blocks
+		// queue size and content should match
+		for i in 0..(cache_capacity + 10) {
+			let mut commit = make_commit(&[], &[]);
+			pruning.note_canonical(&(i as u64), i as u64, &mut commit).unwrap();
+			push_last_canonicalized(i as u64, &mut commit);
+			db.commit(&commit);
+			// blocks will fill the cache first
+			let (cache, last) = pruning.queue.get_db_backed_queue_state().unwrap();
+			if i < cache_capacity {
+				assert_eq!(cache.len(), i + 1);
+			} else {
+				assert_eq!(cache.len(), cache_capacity);
+			}
+			assert_eq!(last, Some(i as u64));
+		}
+		assert_eq!(pruning.window_size(), cache_capacity as u64 + 10);
+		let (cache, last) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), cache_capacity);
+		assert_eq!(last, Some(cache_capacity as u64 + 10 - 1));
+		for i in 0..cache_capacity {
+			assert_eq!(cache[i].hash, i as u64);
+		}
+
+		// import a new block to the end of the queue
+		// won't keep the new block in memory
+		let mut commit = CommitSet::default();
+		pruning
+			.note_canonical(&(cache_capacity as u64 + 10), cache_capacity as u64 + 10, &mut commit)
+			.unwrap();
+		assert_eq!(pruning.window_size(), cache_capacity as u64 + 11);
+		let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), cache_capacity);
+
+		// revert the last add that no apply yet
+		// NOTE: do not commit the previous `CommitSet` to db
+		pruning = RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+		let cache_capacity = DEFAULT_MAX_BLOCK_CONSTRAINT as usize;
+		assert_eq!(pruning.window_size(), cache_capacity as u64 + 10);
+		let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), cache_capacity);
+
+		// remove one block from the start of the queue
+		// block is removed from the head of cache
+		let mut commit = CommitSet::default();
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+		assert_eq!(pruning.window_size(), cache_capacity as u64 + 9);
+		let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), cache_capacity - 1);
+		for i in 0..(cache_capacity - 1) {
+			assert_eq!(cache[i].hash, (i + 1) as u64);
+		}
+
+		// load a new queue from db
+		// `cache` is full again but the content of the queue should be the same
+		let pruning: RefWindow<u64, H256, TestDb> =
+			RefWindow::new(db, DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+		assert_eq!(pruning.window_size(), cache_capacity as u64 + 9);
+		let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), cache_capacity);
+		for i in 0..cache_capacity {
+			assert_eq!(cache[i].hash, (i + 1) as u64);
+		}
+	}
+
+	#[test]
+	fn load_block_from_db() {
+		let mut db = make_db(&[]);
+		let mut pruning: RefWindow<u64, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+		let cache_capacity = DEFAULT_MAX_BLOCK_CONSTRAINT as usize;
+
+		// import blocks
+		for i in 0..(cache_capacity as u64 * 2 + 10) {
+			let mut commit = make_commit(&[], &[]);
+			pruning.note_canonical(&i, i, &mut commit).unwrap();
+			push_last_canonicalized(i as u64, &mut commit);
+			db.commit(&commit);
+		}
+
+		// the following operations won't trigger loading block from db:
+		// - getting block in cache
+		// - getting block not in the queue
+		assert_eq!(pruning.next_hash().unwrap().unwrap(), 0);
+		let (cache, last) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), cache_capacity);
+		assert_eq!(last, Some(cache_capacity as u64 * 2 + 10 - 1));
+
+		// clear all block loaded in cache
+		for _ in 0..cache_capacity * 2 {
+			let mut commit = CommitSet::default();
+			pruning.prune_one(&mut commit).unwrap();
+			db.commit(&commit);
+		}
+		let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert!(cache.is_empty());
+
+		// getting the hash of block that not in cache will also trigger loading
+		// the remaining blocks from db
+		assert_eq!(pruning.next_hash().unwrap().unwrap(), (cache_capacity * 2) as u64);
+		let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), 10);
+
+		// load a new queue from db
+		// `cache` should be the same
+		let pruning: RefWindow<u64, H256, TestDb> =
+			RefWindow::new(db, DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+		assert_eq!(pruning.window_size(), 10);
+		let (cache, _) = pruning.queue.get_db_backed_queue_state().unwrap();
+		assert_eq!(cache.len(), 10);
+		for i in 0..10 {
+			assert_eq!(cache[i].hash, (cache_capacity * 2 + i) as u64);
+		}
+	}
+
+	#[test]
+	fn get_block_from_queue() {
+		let mut db = make_db(&[]);
+		let mut pruning: RefWindow<u64, H256, TestDb> =
+			RefWindow::new(db.clone(), DEFAULT_MAX_BLOCK_CONSTRAINT, false).unwrap();
+		let cache_capacity = DEFAULT_MAX_BLOCK_CONSTRAINT as u64;
+
+		// import blocks and commit to db
+		let mut commit = make_commit(&[], &[]);
+		for i in 0..(cache_capacity + 10) {
+			pruning.note_canonical(&i, i, &mut commit).unwrap();
+		}
+		db.commit(&commit);
+
+		// import a block but not commit to db yet
+		let mut pending_commit = make_commit(&[], &[]);
+		let index = cache_capacity + 10;
+		pruning.note_canonical(&index, index, &mut pending_commit).unwrap();
+
+		let mut commit = make_commit(&[], &[]);
+		// prune blocks that had committed to db
+		for i in 0..(cache_capacity + 10) {
+			assert_eq!(pruning.next_hash().unwrap(), Some(i));
+			pruning.prune_one(&mut commit).unwrap();
+		}
+		// return `None` for block that did not commit to db
+		assert_eq!(pruning.next_hash().unwrap(), None);
+		assert_eq!(
+			pruning.prune_one(&mut commit).unwrap_err(),
+			Error::StateDb(StateDbError::BlockUnavailable)
+		);
+		// commit block to db and no error return
+		db.commit(&pending_commit);
+		assert_eq!(pruning.next_hash().unwrap(), Some(index));
+		pruning.prune_one(&mut commit).unwrap();
+		db.commit(&commit);
+	}
+}
diff --git a/substrate/client/state-db/src/test.rs b/substrate/client/state-db/src/test.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74571145b52a383dfb2234d7302cd668d3a8c2b4
--- /dev/null
+++ b/substrate/client/state-db/src/test.rs
@@ -0,0 +1,98 @@
+// 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/>.
+
+//! Test utils
+
+use crate::{ChangeSet, CommitSet, DBValue, MetaDb, NodeDb};
+use sp_core::H256;
+use std::{
+	collections::HashMap,
+	sync::{Arc, RwLock},
+};
+
+#[derive(Default, Debug, Clone)]
+pub struct TestDb(Arc<RwLock<TestDbInner>>);
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+struct TestDbInner {
+	pub data: HashMap<H256, DBValue>,
+	pub meta: HashMap<Vec<u8>, DBValue>,
+}
+
+impl MetaDb for TestDb {
+	type Error = ();
+
+	fn get_meta(&self, key: &[u8]) -> Result<Option<DBValue>, ()> {
+		Ok(self.0.read().unwrap().meta.get(key).cloned())
+	}
+}
+
+impl NodeDb for TestDb {
+	type Error = ();
+	type Key = H256;
+
+	fn get(&self, key: &H256) -> Result<Option<DBValue>, ()> {
+		Ok(self.0.read().unwrap().data.get(key).cloned())
+	}
+}
+
+impl TestDb {
+	pub fn commit(&mut self, commit: &CommitSet<H256>) {
+		self.0.write().unwrap().data.extend(commit.data.inserted.iter().cloned());
+		self.0.write().unwrap().meta.extend(commit.meta.inserted.iter().cloned());
+		for k in commit.data.deleted.iter() {
+			self.0.write().unwrap().data.remove(k);
+		}
+		self.0.write().unwrap().meta.extend(commit.meta.inserted.iter().cloned());
+		for k in commit.meta.deleted.iter() {
+			self.0.write().unwrap().meta.remove(k);
+		}
+	}
+
+	pub fn data_eq(&self, other: &TestDb) -> bool {
+		self.0.read().unwrap().data == other.0.read().unwrap().data
+	}
+
+	pub fn meta_len(&self) -> usize {
+		self.0.read().unwrap().meta.len()
+	}
+}
+
+pub fn make_changeset(inserted: &[u64], deleted: &[u64]) -> ChangeSet<H256> {
+	ChangeSet {
+		inserted: inserted
+			.iter()
+			.map(|v| (H256::from_low_u64_be(*v), H256::from_low_u64_be(*v).as_bytes().to_vec()))
+			.collect(),
+		deleted: deleted.iter().map(|v| H256::from_low_u64_be(*v)).collect(),
+	}
+}
+
+pub fn make_commit(inserted: &[u64], deleted: &[u64]) -> CommitSet<H256> {
+	CommitSet { data: make_changeset(inserted, deleted), meta: ChangeSet::default() }
+}
+
+pub fn make_db(inserted: &[u64]) -> TestDb {
+	TestDb(Arc::new(RwLock::new(TestDbInner {
+		data: inserted
+			.iter()
+			.map(|v| (H256::from_low_u64_be(*v), H256::from_low_u64_be(*v).as_bytes().to_vec()))
+			.collect(),
+		meta: Default::default(),
+	})))
+}
diff --git a/substrate/client/statement-store/Cargo.toml b/substrate/client/statement-store/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8668dbfa8ba03a2e6e514507ba8089b6b9233d77
--- /dev/null
+++ b/substrate/client/statement-store/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "sc-statement-store"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate statement store."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+log = "0.4.17"
+parking_lot = "0.12.1"
+parity-db = "0.4.8"
+tokio = { version = "1.22.0", features = ["time"] }
+sp-statement-store = { version = "4.0.0-dev", path = "../../primitives/statement-store" }
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-keystore = { version = "4.0.0-dev", path = "../../client/keystore" }
+
+[dev-dependencies]
+tempfile = "3.1.0"
+env_logger = "0.9"
+
diff --git a/substrate/client/statement-store/README.md b/substrate/client/statement-store/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..41e268f4ece0d3d71ab2bba0960294fd2be72d07
--- /dev/null
+++ b/substrate/client/statement-store/README.md
@@ -0,0 +1,4 @@
+Substrate statement store implementation.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
+
diff --git a/substrate/client/statement-store/src/lib.rs b/substrate/client/statement-store/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da0af08b45402a9e2df83dbd6f9f91e4d4d99311
--- /dev/null
+++ b/substrate/client/statement-store/src/lib.rs
@@ -0,0 +1,1296 @@
+// 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/>.
+
+//! Disk-backed statement store.
+//!
+//! This module contains an implementation of `sp_statement_store::StatementStore` which is backed
+//! by a database.
+//!
+//! Constraint management.
+//!
+//! Each time a new statement is inserted into the store, it is first validated with the runtime
+//! Validation function computes `global_priority`, 'max_count' and `max_size` for a statement.
+//! The following constraints are then checked:
+//! * For a given account id, there may be at most `max_count` statements with `max_size` total data
+//!   size. To satisfy this, statements for this account ID are removed from the store starting with
+//!   the lowest priority until a constraint is satisfied.
+//! * There may not be more than `MAX_TOTAL_STATEMENTS` total statements with `MAX_TOTAL_SIZE` size.
+//!   To satisfy this, statements are removed from the store starting with the lowest
+//!   `global_priority` until a constraint is satisfied.
+//!
+//! When a new statement is inserted that would not satisfy constraints in the first place, no
+//! statements are deleted and `Ignored` result is returned.
+//! The order in which statements with the same priority are deleted is unspecified.
+//!
+//! Statement expiration.
+//!
+//! Each time a statement is removed from the store (Either evicted by higher priority statement or
+//! explicitly with the `remove` function) the statement is marked as expired. Expired statements
+//! can't be added to the store for `Options::purge_after_sec` seconds. This is to prevent old
+//! statements from being propagated on the network.
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+mod metrics;
+
+pub use sp_statement_store::{Error, StatementStore, MAX_TOPICS};
+
+use metrics::MetricsLink as PrometheusMetrics;
+use parking_lot::RwLock;
+use prometheus_endpoint::Registry as PrometheusRegistry;
+use sc_keystore::LocalKeystore;
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::HeaderBackend;
+use sp_core::{crypto::UncheckedFrom, hexdisplay::HexDisplay, traits::SpawnNamed, Decode, Encode};
+use sp_runtime::traits::Block as BlockT;
+use sp_statement_store::{
+	runtime_api::{
+		InvalidStatement, StatementSource, StatementStoreExt, ValidStatement, ValidateStatement,
+	},
+	AccountId, BlockHash, Channel, DecryptionKey, Hash, NetworkPriority, Proof, Result, Statement,
+	SubmitResult, Topic,
+};
+use std::{
+	collections::{BTreeMap, HashMap, HashSet},
+	sync::Arc,
+};
+
+const KEY_VERSION: &[u8] = b"version".as_slice();
+const CURRENT_VERSION: u32 = 1;
+
+const LOG_TARGET: &str = "statement-store";
+
+const DEFAULT_PURGE_AFTER_SEC: u64 = 2 * 24 * 60 * 60; //48h
+const DEFAULT_MAX_TOTAL_STATEMENTS: usize = 8192;
+const DEFAULT_MAX_TOTAL_SIZE: usize = 64 * 1024 * 1024;
+
+const MAINTENANCE_PERIOD: std::time::Duration = std::time::Duration::from_secs(30);
+
+mod col {
+	pub const META: u8 = 0;
+	pub const STATEMENTS: u8 = 1;
+	pub const EXPIRED: u8 = 2;
+
+	pub const COUNT: u8 = 3;
+}
+
+#[derive(Eq, PartialEq, Debug, Ord, PartialOrd, Clone, Copy)]
+struct Priority(u32);
+
+#[derive(PartialEq, Eq)]
+struct PriorityKey {
+	hash: Hash,
+	priority: Priority,
+}
+
+impl PartialOrd for PriorityKey {
+	fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl Ord for PriorityKey {
+	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+		self.priority.cmp(&other.priority).then_with(|| self.hash.cmp(&other.hash))
+	}
+}
+
+#[derive(PartialEq, Eq)]
+struct ChannelEntry {
+	hash: Hash,
+	priority: Priority,
+}
+
+#[derive(Default)]
+struct StatementsForAccount {
+	// Statements ordered by priority.
+	by_priority: BTreeMap<PriorityKey, (Option<Channel>, usize)>,
+	// Channel to statement map. Only one statement per channel is allowed.
+	channels: HashMap<Channel, ChannelEntry>,
+	// Sum of all `Data` field sizes.
+	data_size: usize,
+}
+
+/// Store configuration
+pub struct Options {
+	/// Maximum statement allowed in the store. Once this limit is reached lower-priority
+	/// statements may be evicted.
+	max_total_statements: usize,
+	/// Maximum total data size allowed in the store. Once this limit is reached lower-priority
+	/// statements may be evicted.
+	max_total_size: usize,
+	/// Number of seconds for which removed statements won't be allowed to be added back in.
+	purge_after_sec: u64,
+}
+
+impl Default for Options {
+	fn default() -> Self {
+		Options {
+			max_total_statements: DEFAULT_MAX_TOTAL_STATEMENTS,
+			max_total_size: DEFAULT_MAX_TOTAL_SIZE,
+			purge_after_sec: DEFAULT_PURGE_AFTER_SEC,
+		}
+	}
+}
+
+#[derive(Default)]
+struct Index {
+	by_topic: HashMap<Topic, HashSet<Hash>>,
+	by_dec_key: HashMap<Option<DecryptionKey>, HashSet<Hash>>,
+	topics_and_keys: HashMap<Hash, ([Option<Topic>; MAX_TOPICS], Option<DecryptionKey>)>,
+	entries: HashMap<Hash, (AccountId, Priority, usize)>,
+	expired: HashMap<Hash, u64>, // Value is expiration timestamp.
+	accounts: HashMap<AccountId, StatementsForAccount>,
+	options: Options,
+	total_size: usize,
+}
+
+struct ClientWrapper<Block, Client> {
+	client: Arc<Client>,
+	_block: std::marker::PhantomData<Block>,
+}
+
+impl<Block, Client> ClientWrapper<Block, Client>
+where
+	Block: BlockT,
+	Block::Hash: From<BlockHash>,
+	Client: ProvideRuntimeApi<Block> + HeaderBackend<Block> + Send + Sync + 'static,
+	Client::Api: ValidateStatement<Block>,
+{
+	fn validate_statement(
+		&self,
+		block: Option<BlockHash>,
+		source: StatementSource,
+		statement: Statement,
+	) -> std::result::Result<ValidStatement, InvalidStatement> {
+		let api = self.client.runtime_api();
+		let block = block.map(Into::into).unwrap_or_else(|| {
+			// Validate against the finalized state.
+			self.client.info().finalized_hash
+		});
+		api.validate_statement(block, source, statement)
+			.map_err(|_| InvalidStatement::InternalError)?
+	}
+}
+
+/// Statement store.
+pub struct Store {
+	db: parity_db::Db,
+	index: RwLock<Index>,
+	validate_fn: Box<
+		dyn Fn(
+				Option<BlockHash>,
+				StatementSource,
+				Statement,
+			) -> std::result::Result<ValidStatement, InvalidStatement>
+			+ Send
+			+ Sync,
+	>,
+	keystore: Arc<LocalKeystore>,
+	// Used for testing
+	time_override: Option<u64>,
+	metrics: PrometheusMetrics,
+}
+
+enum IndexQuery {
+	Unknown,
+	Exists,
+	Expired,
+}
+
+enum MaybeInserted {
+	Inserted(HashSet<Hash>),
+	Ignored,
+}
+
+impl Index {
+	fn new(options: Options) -> Index {
+		Index { options, ..Default::default() }
+	}
+
+	fn insert_new(&mut self, hash: Hash, account: AccountId, statement: &Statement) {
+		let mut all_topics = [None; MAX_TOPICS];
+		let mut nt = 0;
+		while let Some(t) = statement.topic(nt) {
+			self.by_topic.entry(t).or_default().insert(hash);
+			all_topics[nt] = Some(t);
+			nt += 1;
+		}
+		let key = statement.decryption_key();
+		self.by_dec_key.entry(key).or_default().insert(hash);
+		if nt > 0 || key.is_some() {
+			self.topics_and_keys.insert(hash, (all_topics, key));
+		}
+		let priority = Priority(statement.priority().unwrap_or(0));
+		self.entries.insert(hash, (account, priority, statement.data_len()));
+		self.total_size += statement.data_len();
+		let account_info = self.accounts.entry(account).or_default();
+		account_info.data_size += statement.data_len();
+		if let Some(channel) = statement.channel() {
+			account_info.channels.insert(channel, ChannelEntry { hash, priority });
+		}
+		account_info
+			.by_priority
+			.insert(PriorityKey { hash, priority }, (statement.channel(), statement.data_len()));
+	}
+
+	fn query(&self, hash: &Hash) -> IndexQuery {
+		if self.entries.contains_key(hash) {
+			return IndexQuery::Exists
+		}
+		if self.expired.contains_key(hash) {
+			return IndexQuery::Expired
+		}
+		IndexQuery::Unknown
+	}
+
+	fn insert_expired(&mut self, hash: Hash, timestamp: u64) {
+		self.expired.insert(hash, timestamp);
+	}
+
+	fn iterate_with(
+		&self,
+		key: Option<DecryptionKey>,
+		match_all_topics: &[Topic],
+		mut f: impl FnMut(&Hash) -> Result<()>,
+	) -> Result<()> {
+		let empty = HashSet::new();
+		let mut sets: [&HashSet<Hash>; MAX_TOPICS + 1] = [&empty; MAX_TOPICS + 1];
+		if match_all_topics.len() > MAX_TOPICS {
+			return Ok(())
+		}
+		let key_set = self.by_dec_key.get(&key);
+		if key_set.map_or(0, |s| s.len()) == 0 {
+			// Key does not exist in the index.
+			return Ok(())
+		}
+		sets[0] = key_set.expect("Function returns if key_set is None");
+		for (i, t) in match_all_topics.iter().enumerate() {
+			let set = self.by_topic.get(t);
+			if set.map_or(0, |s| s.len()) == 0 {
+				// At least one of the match_all_topics does not exist in the index.
+				return Ok(())
+			}
+			sets[i + 1] = set.expect("Function returns if set is None");
+		}
+		let sets = &mut sets[0..match_all_topics.len() + 1];
+		// Start with the smallest topic set or the key set.
+		sets.sort_by_key(|s| s.len());
+		for item in sets[0] {
+			if sets[1..].iter().all(|set| set.contains(item)) {
+				log::trace!(
+					target: LOG_TARGET,
+					"Iterating by topic/key: statement {:?}",
+					HexDisplay::from(item)
+				);
+				f(item)?
+			}
+		}
+		Ok(())
+	}
+
+	fn maintain(&mut self, current_time: u64) -> Vec<Hash> {
+		// Purge previously expired messages.
+		let mut purged = Vec::new();
+		self.expired.retain(|hash, timestamp| {
+			if *timestamp + self.options.purge_after_sec <= current_time {
+				purged.push(*hash);
+				log::trace!(target: LOG_TARGET, "Purged statement {:?}", HexDisplay::from(hash));
+				false
+			} else {
+				true
+			}
+		});
+		purged
+	}
+
+	fn make_expired(&mut self, hash: &Hash, current_time: u64) -> bool {
+		if let Some((account, priority, len)) = self.entries.remove(hash) {
+			self.total_size -= len;
+			if let Some((topics, key)) = self.topics_and_keys.remove(hash) {
+				for t in topics.into_iter().flatten() {
+					if let std::collections::hash_map::Entry::Occupied(mut set) =
+						self.by_topic.entry(t)
+					{
+						set.get_mut().remove(hash);
+						if set.get().is_empty() {
+							set.remove_entry();
+						}
+					}
+				}
+				if let std::collections::hash_map::Entry::Occupied(mut set) =
+					self.by_dec_key.entry(key)
+				{
+					set.get_mut().remove(hash);
+					if set.get().is_empty() {
+						set.remove_entry();
+					}
+				}
+			}
+			self.expired.insert(*hash, current_time);
+			if let std::collections::hash_map::Entry::Occupied(mut account_rec) =
+				self.accounts.entry(account)
+			{
+				let key = PriorityKey { hash: *hash, priority };
+				if let Some((channel, len)) = account_rec.get_mut().by_priority.remove(&key) {
+					account_rec.get_mut().data_size -= len;
+					if let Some(channel) = channel {
+						account_rec.get_mut().channels.remove(&channel);
+					}
+				}
+				if account_rec.get().by_priority.is_empty() {
+					account_rec.remove_entry();
+				}
+			}
+			log::trace!(target: LOG_TARGET, "Expired statement {:?}", HexDisplay::from(hash));
+			true
+		} else {
+			false
+		}
+	}
+
+	fn insert(
+		&mut self,
+		hash: Hash,
+		statement: &Statement,
+		account: &AccountId,
+		validation: &ValidStatement,
+		current_time: u64,
+	) -> MaybeInserted {
+		let statement_len = statement.data_len();
+		if statement_len > validation.max_size as usize {
+			log::debug!(
+				target: LOG_TARGET,
+				"Ignored oversize message: {:?} ({} bytes)",
+				HexDisplay::from(&hash),
+				statement_len,
+			);
+			return MaybeInserted::Ignored
+		}
+
+		let mut evicted = HashSet::new();
+		let mut would_free_size = 0;
+		let priority = Priority(statement.priority().unwrap_or(0));
+		let (max_size, max_count) = (validation.max_size as usize, validation.max_count as usize);
+		// It may happen that we can't delete enough lower priority messages
+		// to satisfy size constraints. We check for that before deleting anything,
+		// taking into account channel message replacement.
+		if let Some(account_rec) = self.accounts.get(account) {
+			if let Some(channel) = statement.channel() {
+				if let Some(channel_record) = account_rec.channels.get(&channel) {
+					if priority <= channel_record.priority {
+						// Trying to replace channel message with lower priority
+						log::debug!(
+							target: LOG_TARGET,
+							"Ignored lower priority channel message: {:?} {:?} <= {:?}",
+							HexDisplay::from(&hash),
+							priority,
+							channel_record.priority,
+						);
+						return MaybeInserted::Ignored
+					} else {
+						// Would replace channel message. Still need to check for size constraints
+						// below.
+						log::debug!(
+							target: LOG_TARGET,
+							"Replacing higher priority channel message: {:?} ({:?}) > {:?} ({:?})",
+							HexDisplay::from(&hash),
+							priority,
+							HexDisplay::from(&channel_record.hash),
+							channel_record.priority,
+						);
+						let key = PriorityKey {
+							hash: channel_record.hash,
+							priority: channel_record.priority,
+						};
+						if let Some((_channel, len)) = account_rec.by_priority.get(&key) {
+							would_free_size += *len;
+							evicted.insert(channel_record.hash);
+						}
+					}
+				}
+			}
+			// Check if we can evict enough lower priority statements to satisfy constraints
+			for (entry, (_, len)) in account_rec.by_priority.iter() {
+				if (account_rec.data_size - would_free_size + statement_len <= max_size) &&
+					account_rec.by_priority.len() + 1 - evicted.len() <= max_count
+				{
+					// Satisfied
+					break
+				}
+				if evicted.contains(&entry.hash) {
+					// Already accounted for above
+					continue
+				}
+				if entry.priority >= priority {
+					log::debug!(
+						target: LOG_TARGET,
+						"Ignored message due to constraints {:?} {:?} < {:?}",
+						HexDisplay::from(&hash),
+						priority,
+						entry.priority,
+					);
+					return MaybeInserted::Ignored
+				}
+				evicted.insert(entry.hash);
+				would_free_size += len;
+			}
+		}
+		// Now check global constraints as well.
+		if !((self.total_size - would_free_size + statement_len <= self.options.max_total_size) &&
+			self.entries.len() + 1 - evicted.len() <= self.options.max_total_statements)
+		{
+			log::debug!(
+				target: LOG_TARGET,
+				"Ignored statement {} because the store is full (size={}, count={})",
+				HexDisplay::from(&hash),
+				self.total_size,
+				self.entries.len(),
+			);
+			return MaybeInserted::Ignored
+		}
+
+		for h in &evicted {
+			self.make_expired(h, current_time);
+		}
+		self.insert_new(hash, *account, statement);
+		MaybeInserted::Inserted(evicted)
+	}
+}
+
+impl Store {
+	/// Create a new shared store instance. There should only be one per process.
+	/// `path` will be used to open a statement database or create a new one if it does not exist.
+	pub fn new_shared<Block, Client>(
+		path: &std::path::Path,
+		options: Options,
+		client: Arc<Client>,
+		keystore: Arc<LocalKeystore>,
+		prometheus: Option<&PrometheusRegistry>,
+		task_spawner: &dyn SpawnNamed,
+	) -> Result<Arc<Store>>
+	where
+		Block: BlockT,
+		Block::Hash: From<BlockHash>,
+		Client: ProvideRuntimeApi<Block>
+			+ HeaderBackend<Block>
+			+ sc_client_api::ExecutorProvider<Block>
+			+ Send
+			+ Sync
+			+ 'static,
+		Client::Api: ValidateStatement<Block>,
+	{
+		let store = Arc::new(Self::new(path, options, client, keystore, prometheus)?);
+
+		// Perform periodic statement store maintenance
+		let worker_store = store.clone();
+		task_spawner.spawn(
+			"statement-store-maintenance",
+			Some("statement-store"),
+			Box::pin(async move {
+				let mut interval = tokio::time::interval(MAINTENANCE_PERIOD);
+				loop {
+					interval.tick().await;
+					worker_store.maintain();
+				}
+			}),
+		);
+
+		Ok(store)
+	}
+
+	/// Create a new instance.
+	/// `path` will be used to open a statement database or create a new one if it does not exist.
+	fn new<Block, Client>(
+		path: &std::path::Path,
+		options: Options,
+		client: Arc<Client>,
+		keystore: Arc<LocalKeystore>,
+		prometheus: Option<&PrometheusRegistry>,
+	) -> Result<Store>
+	where
+		Block: BlockT,
+		Block::Hash: From<BlockHash>,
+		Client: ProvideRuntimeApi<Block> + HeaderBackend<Block> + Send + Sync + 'static,
+		Client::Api: ValidateStatement<Block>,
+	{
+		let mut path: std::path::PathBuf = path.into();
+		path.push("statements");
+
+		let mut config = parity_db::Options::with_columns(&path, col::COUNT);
+
+		let statement_col = &mut config.columns[col::STATEMENTS as usize];
+		statement_col.ref_counted = false;
+		statement_col.preimage = true;
+		statement_col.uniform = true;
+		let db = parity_db::Db::open_or_create(&config).map_err(|e| Error::Db(e.to_string()))?;
+		match db.get(col::META, &KEY_VERSION).map_err(|e| Error::Db(e.to_string()))? {
+			Some(version) => {
+				let version = u32::from_le_bytes(
+					version
+						.try_into()
+						.map_err(|_| Error::Db("Error reading database version".into()))?,
+				);
+				if version != CURRENT_VERSION {
+					return Err(Error::Db(format!("Unsupported database version: {version}")))
+				}
+			},
+			None => {
+				db.commit([(
+					col::META,
+					KEY_VERSION.to_vec(),
+					Some(CURRENT_VERSION.to_le_bytes().to_vec()),
+				)])
+				.map_err(|e| Error::Db(e.to_string()))?;
+			},
+		}
+
+		let validator = ClientWrapper { client, _block: Default::default() };
+		let validate_fn = Box::new(move |block, source, statement| {
+			validator.validate_statement(block, source, statement)
+		});
+
+		let store = Store {
+			db,
+			index: RwLock::new(Index::new(options)),
+			validate_fn,
+			keystore,
+			time_override: None,
+			metrics: PrometheusMetrics::new(prometheus),
+		};
+		store.populate()?;
+		Ok(store)
+	}
+
+	/// Create memory index from the data.
+	// This may be moved to a background thread if it slows startup too much.
+	// This function should only be used on startup. There should be no other DB operations when
+	// iterating the index.
+	fn populate(&self) -> Result<()> {
+		{
+			let mut index = self.index.write();
+			self.db
+				.iter_column_while(col::STATEMENTS, |item| {
+					let statement = item.value;
+					if let Ok(statement) = Statement::decode(&mut statement.as_slice()) {
+						let hash = statement.hash();
+						log::trace!(
+							target: LOG_TARGET,
+							"Statement loaded {:?}",
+							HexDisplay::from(&hash)
+						);
+						if let Some(account_id) = statement.account_id() {
+							index.insert_new(hash, account_id, &statement);
+						} else {
+							log::debug!(
+								target: LOG_TARGET,
+								"Error decoding statement loaded from the DB: {:?}",
+								HexDisplay::from(&hash)
+							);
+						}
+					}
+					true
+				})
+				.map_err(|e| Error::Db(e.to_string()))?;
+			self.db
+				.iter_column_while(col::EXPIRED, |item| {
+					let expired_info = item.value;
+					if let Ok((hash, timestamp)) =
+						<(Hash, u64)>::decode(&mut expired_info.as_slice())
+					{
+						log::trace!(
+							target: LOG_TARGET,
+							"Statement loaded (expired): {:?}",
+							HexDisplay::from(&hash)
+						);
+						index.insert_expired(hash, timestamp);
+					}
+					true
+				})
+				.map_err(|e| Error::Db(e.to_string()))?;
+		}
+
+		self.maintain();
+		Ok(())
+	}
+
+	fn collect_statements<R>(
+		&self,
+		key: Option<DecryptionKey>,
+		match_all_topics: &[Topic],
+		mut f: impl FnMut(Statement) -> Option<R>,
+	) -> Result<Vec<R>> {
+		let mut result = Vec::new();
+		let index = self.index.read();
+		index.iterate_with(key, match_all_topics, |hash| {
+			match self.db.get(col::STATEMENTS, hash).map_err(|e| Error::Db(e.to_string()))? {
+				Some(entry) => {
+					if let Ok(statement) = Statement::decode(&mut entry.as_slice()) {
+						if let Some(data) = f(statement) {
+							result.push(data);
+						}
+					} else {
+						// DB inconsistency
+						log::warn!(
+							target: LOG_TARGET,
+							"Corrupt statement {:?}",
+							HexDisplay::from(hash)
+						);
+					}
+				},
+				None => {
+					// DB inconsistency
+					log::warn!(
+						target: LOG_TARGET,
+						"Missing statement {:?}",
+						HexDisplay::from(hash)
+					);
+				},
+			}
+			Ok(())
+		})?;
+		Ok(result)
+	}
+
+	/// Perform periodic store maintenance
+	pub fn maintain(&self) {
+		log::trace!(target: LOG_TARGET, "Started store maintenance");
+		let deleted = self.index.write().maintain(self.timestamp());
+		let deleted: Vec<_> =
+			deleted.into_iter().map(|hash| (col::EXPIRED, hash.to_vec(), None)).collect();
+		let count = deleted.len() as u64;
+		if let Err(e) = self.db.commit(deleted) {
+			log::warn!(target: LOG_TARGET, "Error writing to the statement database: {:?}", e);
+		} else {
+			self.metrics.report(|metrics| metrics.statements_pruned.inc_by(count));
+		}
+		log::trace!(
+			target: LOG_TARGET,
+			"Completed store maintenance. Purged: {}, Active: {}, Expired: {}",
+			count,
+			self.index.read().entries.len(),
+			self.index.read().expired.len()
+		);
+	}
+
+	fn timestamp(&self) -> u64 {
+		self.time_override.unwrap_or_else(|| {
+			std::time::SystemTime::now()
+				.duration_since(std::time::UNIX_EPOCH)
+				.unwrap_or_default()
+				.as_secs()
+		})
+	}
+
+	#[cfg(test)]
+	fn set_time(&mut self, time: u64) {
+		self.time_override = Some(time);
+	}
+
+	/// Returns `self` as [`StatementStoreExt`].
+	pub fn as_statement_store_ext(self: Arc<Self>) -> StatementStoreExt {
+		StatementStoreExt::new(self)
+	}
+}
+
+impl StatementStore for Store {
+	/// Return all statements.
+	fn statements(&self) -> Result<Vec<(Hash, Statement)>> {
+		let index = self.index.read();
+		let mut result = Vec::with_capacity(index.entries.len());
+		for h in self.index.read().entries.keys() {
+			let encoded = self.db.get(col::STATEMENTS, h).map_err(|e| Error::Db(e.to_string()))?;
+			if let Some(encoded) = encoded {
+				if let Ok(statement) = Statement::decode(&mut encoded.as_slice()) {
+					let hash = statement.hash();
+					result.push((hash, statement));
+				}
+			}
+		}
+		Ok(result)
+	}
+
+	/// Returns a statement by hash.
+	fn statement(&self, hash: &Hash) -> Result<Option<Statement>> {
+		Ok(
+			match self
+				.db
+				.get(col::STATEMENTS, hash.as_slice())
+				.map_err(|e| Error::Db(e.to_string()))?
+			{
+				Some(entry) => {
+					log::trace!(
+						target: LOG_TARGET,
+						"Queried statement {:?}",
+						HexDisplay::from(hash)
+					);
+					Some(
+						Statement::decode(&mut entry.as_slice())
+							.map_err(|e| Error::Decode(e.to_string()))?,
+					)
+				},
+				None => {
+					log::trace!(
+						target: LOG_TARGET,
+						"Queried missing statement {:?}",
+						HexDisplay::from(hash)
+					);
+					None
+				},
+			},
+		)
+	}
+
+	/// Return the data of all known statements which include all topics and have no `DecryptionKey`
+	/// field.
+	fn broadcasts(&self, match_all_topics: &[Topic]) -> Result<Vec<Vec<u8>>> {
+		self.collect_statements(None, match_all_topics, |statement| statement.into_data())
+	}
+
+	/// Return the data of all known statements whose decryption key is identified as `dest` (this
+	/// will generally be the public key or a hash thereof for symmetric ciphers, or a hash of the
+	/// private key for symmetric ciphers).
+	fn posted(&self, match_all_topics: &[Topic], dest: [u8; 32]) -> Result<Vec<Vec<u8>>> {
+		self.collect_statements(Some(dest), match_all_topics, |statement| statement.into_data())
+	}
+
+	/// Return the decrypted data of all known statements whose decryption key is identified as
+	/// `dest`. The key must be available to the client.
+	fn posted_clear(&self, match_all_topics: &[Topic], dest: [u8; 32]) -> Result<Vec<Vec<u8>>> {
+		self.collect_statements(Some(dest), match_all_topics, |statement| {
+			if let (Some(key), Some(_)) = (statement.decryption_key(), statement.data()) {
+				let public: sp_core::ed25519::Public = UncheckedFrom::unchecked_from(key);
+				let public: sp_statement_store::ed25519::Public = public.into();
+				match self.keystore.key_pair::<sp_statement_store::ed25519::Pair>(&public) {
+					Err(e) => {
+						log::debug!(
+							target: LOG_TARGET,
+							"Keystore error: {:?}, for statement {:?}",
+							e,
+							HexDisplay::from(&statement.hash())
+						);
+						None
+					},
+					Ok(None) => {
+						log::debug!(
+							target: LOG_TARGET,
+							"Keystore is missing key for statement {:?}",
+							HexDisplay::from(&statement.hash())
+						);
+						None
+					},
+					Ok(Some(pair)) => match statement.decrypt_private(&pair.into_inner()) {
+						Ok(r) => r,
+						Err(e) => {
+							log::debug!(
+								target: LOG_TARGET,
+								"Decryption error: {:?}, for statement {:?}",
+								e,
+								HexDisplay::from(&statement.hash())
+							);
+							None
+						},
+					},
+				}
+			} else {
+				None
+			}
+		})
+	}
+
+	/// Submit a statement to the store. Validates the statement and returns validation result.
+	fn submit(&self, statement: Statement, source: StatementSource) -> SubmitResult {
+		let hash = statement.hash();
+		match self.index.read().query(&hash) {
+			IndexQuery::Expired =>
+				if !source.can_be_resubmitted() {
+					return SubmitResult::KnownExpired
+				},
+			IndexQuery::Exists =>
+				if !source.can_be_resubmitted() {
+					return SubmitResult::Known
+				},
+			IndexQuery::Unknown => {},
+		}
+
+		let Some(account_id) = statement.account_id() else {
+			log::debug!(
+				target: LOG_TARGET,
+				"Statement validation failed: Missing proof ({:?})",
+				HexDisplay::from(&hash),
+			);
+			self.metrics.report(|metrics| metrics.validations_invalid.inc());
+			return SubmitResult::Bad("No statement proof")
+		};
+
+		// Validate.
+		let at_block = if let Some(Proof::OnChain { block_hash, .. }) = statement.proof() {
+			Some(*block_hash)
+		} else {
+			None
+		};
+		let validation_result = (self.validate_fn)(at_block, source, statement.clone());
+		let validation = match validation_result {
+			Ok(validation) => validation,
+			Err(InvalidStatement::BadProof) => {
+				log::debug!(
+					target: LOG_TARGET,
+					"Statement validation failed: BadProof, {:?}",
+					HexDisplay::from(&hash),
+				);
+				self.metrics.report(|metrics| metrics.validations_invalid.inc());
+				return SubmitResult::Bad("Bad statement proof")
+			},
+			Err(InvalidStatement::NoProof) => {
+				log::debug!(
+					target: LOG_TARGET,
+					"Statement validation failed: NoProof, {:?}",
+					HexDisplay::from(&hash),
+				);
+				self.metrics.report(|metrics| metrics.validations_invalid.inc());
+				return SubmitResult::Bad("Missing statement proof")
+			},
+			Err(InvalidStatement::InternalError) =>
+				return SubmitResult::InternalError(Error::Runtime),
+		};
+
+		let current_time = self.timestamp();
+		let mut commit = Vec::new();
+		{
+			let mut index = self.index.write();
+
+			let evicted =
+				match index.insert(hash, &statement, &account_id, &validation, current_time) {
+					MaybeInserted::Ignored => return SubmitResult::Ignored,
+					MaybeInserted::Inserted(evicted) => evicted,
+				};
+
+			commit.push((col::STATEMENTS, hash.to_vec(), Some(statement.encode())));
+			for hash in evicted {
+				commit.push((col::STATEMENTS, hash.to_vec(), None));
+				commit.push((col::EXPIRED, hash.to_vec(), Some((hash, current_time).encode())));
+			}
+			if let Err(e) = self.db.commit(commit) {
+				log::debug!(
+					target: LOG_TARGET,
+					"Statement validation failed: database error {}, {:?}",
+					e,
+					statement
+				);
+				return SubmitResult::InternalError(Error::Db(e.to_string()))
+			}
+		} // Release index lock
+		self.metrics.report(|metrics| metrics.submitted_statements.inc());
+		let network_priority = NetworkPriority::High;
+		log::trace!(target: LOG_TARGET, "Statement submitted: {:?}", HexDisplay::from(&hash));
+		SubmitResult::New(network_priority)
+	}
+
+	/// Remove a statement by hash.
+	fn remove(&self, hash: &Hash) -> Result<()> {
+		let current_time = self.timestamp();
+		{
+			let mut index = self.index.write();
+			if index.make_expired(hash, current_time) {
+				let commit = [
+					(col::STATEMENTS, hash.to_vec(), None),
+					(col::EXPIRED, hash.to_vec(), Some((hash, current_time).encode())),
+				];
+				if let Err(e) = self.db.commit(commit) {
+					log::debug!(
+						target: LOG_TARGET,
+						"Error removing statement: database error {}, {:?}",
+						e,
+						HexDisplay::from(hash),
+					);
+					return Err(Error::Db(e.to_string()))
+				}
+			}
+		}
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::Store;
+	use sc_keystore::Keystore;
+	use sp_core::Pair;
+	use sp_statement_store::{
+		runtime_api::{InvalidStatement, ValidStatement, ValidateStatement},
+		AccountId, Channel, DecryptionKey, NetworkPriority, Proof, SignatureVerificationResult,
+		Statement, StatementSource, StatementStore, SubmitResult, Topic,
+	};
+
+	type Extrinsic = sp_runtime::OpaqueExtrinsic;
+	type Hash = sp_core::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type BlockNumber = u64;
+	type Header = sp_runtime::generic::Header<BlockNumber, Hashing>;
+	type Block = sp_runtime::generic::Block<Header, Extrinsic>;
+
+	const CORRECT_BLOCK_HASH: [u8; 32] = [1u8; 32];
+
+	#[derive(Clone)]
+	pub(crate) struct TestClient;
+
+	pub(crate) struct RuntimeApi {
+		_inner: TestClient,
+	}
+
+	impl sp_api::ProvideRuntimeApi<Block> for TestClient {
+		type Api = RuntimeApi;
+		fn runtime_api(&self) -> sp_api::ApiRef<Self::Api> {
+			RuntimeApi { _inner: self.clone() }.into()
+		}
+	}
+
+	sp_api::mock_impl_runtime_apis! {
+		impl ValidateStatement<Block> for RuntimeApi {
+			fn validate_statement(
+				_source: StatementSource,
+				statement: Statement,
+			) -> std::result::Result<ValidStatement, InvalidStatement> {
+				use crate::tests::account;
+				match statement.verify_signature() {
+					SignatureVerificationResult::Valid(_) => Ok(ValidStatement{max_count: 100, max_size: 1000}),
+					SignatureVerificationResult::Invalid => Err(InvalidStatement::BadProof),
+					SignatureVerificationResult::NoSignature => {
+						if let Some(Proof::OnChain { block_hash, .. }) = statement.proof() {
+							if block_hash == &CORRECT_BLOCK_HASH {
+								let (max_count, max_size) = match statement.account_id() {
+									Some(a) if a == account(1) => (1, 1000),
+									Some(a) if a == account(2) => (2, 1000),
+									Some(a) if a == account(3) => (3, 1000),
+									Some(a) if a == account(4) => (4, 1000),
+									_ => (2, 2000),
+								};
+								Ok(ValidStatement{ max_count, max_size })
+							} else {
+								Err(InvalidStatement::BadProof)
+							}
+						} else {
+							Err(InvalidStatement::BadProof)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	impl sp_blockchain::HeaderBackend<Block> for TestClient {
+		fn header(&self, _hash: Hash) -> sp_blockchain::Result<Option<Header>> {
+			unimplemented!()
+		}
+		fn info(&self) -> sp_blockchain::Info<Block> {
+			sp_blockchain::Info {
+				best_hash: CORRECT_BLOCK_HASH.into(),
+				best_number: 0,
+				genesis_hash: Default::default(),
+				finalized_hash: CORRECT_BLOCK_HASH.into(),
+				finalized_number: 1,
+				finalized_state: None,
+				number_leaves: 0,
+				block_gap: None,
+			}
+		}
+		fn status(&self, _hash: Hash) -> sp_blockchain::Result<sp_blockchain::BlockStatus> {
+			unimplemented!()
+		}
+		fn number(&self, _hash: Hash) -> sp_blockchain::Result<Option<BlockNumber>> {
+			unimplemented!()
+		}
+		fn hash(&self, _number: BlockNumber) -> sp_blockchain::Result<Option<Hash>> {
+			unimplemented!()
+		}
+	}
+
+	fn test_store() -> (Store, tempfile::TempDir) {
+		let _ = env_logger::try_init();
+		let temp_dir = tempfile::Builder::new().tempdir().expect("Error creating test dir");
+
+		let client = std::sync::Arc::new(TestClient);
+		let mut path: std::path::PathBuf = temp_dir.path().into();
+		path.push("db");
+		let keystore = std::sync::Arc::new(sc_keystore::LocalKeystore::in_memory());
+		let store = Store::new(&path, Default::default(), client, keystore, None).unwrap();
+		(store, temp_dir) // return order is important. Store must be dropped before TempDir
+	}
+
+	fn signed_statement(data: u8) -> Statement {
+		signed_statement_with_topics(data, &[], None)
+	}
+
+	fn signed_statement_with_topics(
+		data: u8,
+		topics: &[Topic],
+		dec_key: Option<DecryptionKey>,
+	) -> Statement {
+		let mut statement = Statement::new();
+		statement.set_plain_data(vec![data]);
+		for i in 0..topics.len() {
+			statement.set_topic(i, topics[i]);
+		}
+		if let Some(key) = dec_key {
+			statement.set_decryption_key(key);
+		}
+		let kp = sp_core::ed25519::Pair::from_string("//Alice", None).unwrap();
+		statement.sign_ed25519_private(&kp);
+		statement
+	}
+
+	fn topic(data: u64) -> Topic {
+		let mut topic: Topic = Default::default();
+		topic[0..8].copy_from_slice(&data.to_le_bytes());
+		topic
+	}
+
+	fn dec_key(data: u64) -> DecryptionKey {
+		let mut dec_key: DecryptionKey = Default::default();
+		dec_key[0..8].copy_from_slice(&data.to_le_bytes());
+		dec_key
+	}
+
+	fn account(id: u64) -> AccountId {
+		let mut account: AccountId = Default::default();
+		account[0..8].copy_from_slice(&id.to_le_bytes());
+		account
+	}
+
+	fn channel(id: u64) -> Channel {
+		let mut channel: Channel = Default::default();
+		channel[0..8].copy_from_slice(&id.to_le_bytes());
+		channel
+	}
+
+	fn statement(account_id: u64, priority: u32, c: Option<u64>, data_len: usize) -> Statement {
+		let mut statement = Statement::new();
+		let mut data = Vec::new();
+		data.resize(data_len, 0);
+		statement.set_plain_data(data);
+		statement.set_priority(priority);
+		if let Some(c) = c {
+			statement.set_channel(channel(c));
+		}
+		statement.set_proof(Proof::OnChain {
+			block_hash: CORRECT_BLOCK_HASH,
+			who: account(account_id),
+			event_index: 0,
+		});
+		statement
+	}
+
+	#[test]
+	fn submit_one() {
+		let (store, _temp) = test_store();
+		let statement0 = signed_statement(0);
+		assert_eq!(
+			store.submit(statement0, StatementSource::Network),
+			SubmitResult::New(NetworkPriority::High)
+		);
+		let unsigned = statement(0, 1, None, 0);
+		assert_eq!(
+			store.submit(unsigned, StatementSource::Network),
+			SubmitResult::New(NetworkPriority::High)
+		);
+	}
+
+	#[test]
+	fn save_and_load_statements() {
+		let (store, temp) = test_store();
+		let statement0 = signed_statement(0);
+		let statement1 = signed_statement(1);
+		let statement2 = signed_statement(2);
+		assert_eq!(
+			store.submit(statement0.clone(), StatementSource::Network),
+			SubmitResult::New(NetworkPriority::High)
+		);
+		assert_eq!(
+			store.submit(statement1.clone(), StatementSource::Network),
+			SubmitResult::New(NetworkPriority::High)
+		);
+		assert_eq!(
+			store.submit(statement2.clone(), StatementSource::Network),
+			SubmitResult::New(NetworkPriority::High)
+		);
+		assert_eq!(store.statements().unwrap().len(), 3);
+		assert_eq!(store.broadcasts(&[]).unwrap().len(), 3);
+		assert_eq!(store.statement(&statement1.hash()).unwrap(), Some(statement1.clone()));
+		let keystore = store.keystore.clone();
+		drop(store);
+
+		let client = std::sync::Arc::new(TestClient);
+		let mut path: std::path::PathBuf = temp.path().into();
+		path.push("db");
+		let store = Store::new(&path, Default::default(), client, keystore, None).unwrap();
+		assert_eq!(store.statements().unwrap().len(), 3);
+		assert_eq!(store.broadcasts(&[]).unwrap().len(), 3);
+		assert_eq!(store.statement(&statement1.hash()).unwrap(), Some(statement1));
+	}
+
+	#[test]
+	fn search_by_topic_and_key() {
+		let (store, _temp) = test_store();
+		let statement0 = signed_statement(0);
+		let statement1 = signed_statement_with_topics(1, &[topic(0)], None);
+		let statement2 = signed_statement_with_topics(2, &[topic(0), topic(1)], Some(dec_key(2)));
+		let statement3 = signed_statement_with_topics(3, &[topic(0), topic(1), topic(2)], None);
+		let statement4 =
+			signed_statement_with_topics(4, &[topic(0), topic(42), topic(2), topic(3)], None);
+		let statements = vec![statement0, statement1, statement2, statement3, statement4];
+		for s in &statements {
+			store.submit(s.clone(), StatementSource::Network);
+		}
+
+		let assert_topics = |topics: &[u64], key: Option<u64>, expected: &[u8]| {
+			let key = key.map(dec_key);
+			let topics: Vec<_> = topics.iter().map(|t| topic(*t)).collect();
+			let mut got_vals: Vec<_> = if let Some(key) = key {
+				store.posted(&topics, key).unwrap().into_iter().map(|d| d[0]).collect()
+			} else {
+				store.broadcasts(&topics).unwrap().into_iter().map(|d| d[0]).collect()
+			};
+			got_vals.sort();
+			assert_eq!(expected.to_vec(), got_vals);
+		};
+
+		assert_topics(&[], None, &[0, 1, 3, 4]);
+		assert_topics(&[], Some(2), &[2]);
+		assert_topics(&[0], None, &[1, 3, 4]);
+		assert_topics(&[1], None, &[3]);
+		assert_topics(&[2], None, &[3, 4]);
+		assert_topics(&[3], None, &[4]);
+		assert_topics(&[42], None, &[4]);
+
+		assert_topics(&[0, 1], None, &[3]);
+		assert_topics(&[0, 1], Some(2), &[2]);
+		assert_topics(&[0, 1, 99], Some(2), &[]);
+		assert_topics(&[1, 2], None, &[3]);
+		assert_topics(&[99], None, &[]);
+		assert_topics(&[0, 99], None, &[]);
+		assert_topics(&[0, 1, 2, 3, 42], None, &[]);
+	}
+
+	#[test]
+	fn constraints() {
+		let (store, _temp) = test_store();
+
+		store.index.write().options.max_total_size = 3000;
+		let source = StatementSource::Network;
+		let ok = SubmitResult::New(NetworkPriority::High);
+		let ignored = SubmitResult::Ignored;
+
+		// Account 1 (limit = 1 msg, 1000 bytes)
+
+		// Oversized statement is not allowed. Limit for account 1 is 1 msg, 1000 bytes
+		assert_eq!(store.submit(statement(1, 1, Some(1), 2000), source), ignored);
+		assert_eq!(store.submit(statement(1, 1, Some(1), 500), source), ok);
+		// Would not replace channel message with same priority
+		assert_eq!(store.submit(statement(1, 1, Some(1), 200), source), ignored);
+		assert_eq!(store.submit(statement(1, 2, Some(1), 600), source), ok);
+		// Submit another message to another channel with lower priority. Should not be allowed
+		// because msg count limit is 1
+		assert_eq!(store.submit(statement(1, 1, Some(2), 100), source), ignored);
+		assert_eq!(store.index.read().expired.len(), 1);
+
+		// Account 2 (limit = 2 msg, 1000 bytes)
+
+		assert_eq!(store.submit(statement(2, 1, None, 500), source), ok);
+		assert_eq!(store.submit(statement(2, 2, None, 100), source), ok);
+		// Should evict priority 1
+		assert_eq!(store.submit(statement(2, 3, None, 500), source), ok);
+		assert_eq!(store.index.read().expired.len(), 2);
+		// Should evict all
+		assert_eq!(store.submit(statement(2, 4, None, 1000), source), ok);
+		assert_eq!(store.index.read().expired.len(), 4);
+
+		// Account 3 (limit = 3 msg, 1000 bytes)
+
+		assert_eq!(store.submit(statement(3, 2, Some(1), 300), source), ok);
+		assert_eq!(store.submit(statement(3, 3, Some(2), 300), source), ok);
+		assert_eq!(store.submit(statement(3, 4, Some(3), 300), source), ok);
+		// Should evict 2 and 3
+		assert_eq!(store.submit(statement(3, 5, None, 500), source), ok);
+		assert_eq!(store.index.read().expired.len(), 6);
+
+		assert_eq!(store.index.read().total_size, 2400);
+		assert_eq!(store.index.read().entries.len(), 4);
+
+		// Should be over the global size limit
+		assert_eq!(store.submit(statement(1, 1, None, 700), source), ignored);
+		// Should be over the global count limit
+		store.index.write().options.max_total_statements = 4;
+		assert_eq!(store.submit(statement(1, 1, None, 100), source), ignored);
+
+		let mut expected_statements = vec![
+			statement(1, 2, Some(1), 600).hash(),
+			statement(2, 4, None, 1000).hash(),
+			statement(3, 4, Some(3), 300).hash(),
+			statement(3, 5, None, 500).hash(),
+		];
+		expected_statements.sort();
+		let mut statements: Vec<_> =
+			store.statements().unwrap().into_iter().map(|(hash, _)| hash).collect();
+		statements.sort();
+		assert_eq!(expected_statements, statements);
+	}
+
+	#[test]
+	fn expired_statements_are_purged() {
+		use super::DEFAULT_PURGE_AFTER_SEC;
+		let (mut store, temp) = test_store();
+		let mut statement = statement(1, 1, Some(3), 100);
+		store.set_time(0);
+		statement.set_topic(0, topic(4));
+		store.submit(statement.clone(), StatementSource::Network);
+		assert_eq!(store.index.read().entries.len(), 1);
+		store.remove(&statement.hash()).unwrap();
+		assert_eq!(store.index.read().entries.len(), 0);
+		assert_eq!(store.index.read().accounts.len(), 0);
+		store.set_time(DEFAULT_PURGE_AFTER_SEC + 1);
+		store.maintain();
+		assert_eq!(store.index.read().expired.len(), 0);
+		let keystore = store.keystore.clone();
+		drop(store);
+
+		let client = std::sync::Arc::new(TestClient);
+		let mut path: std::path::PathBuf = temp.path().into();
+		path.push("db");
+		let store = Store::new(&path, Default::default(), client, keystore, None).unwrap();
+		assert_eq!(store.statements().unwrap().len(), 0);
+		assert_eq!(store.index.read().expired.len(), 0);
+	}
+
+	#[test]
+	fn posted_clear_decrypts() {
+		let (store, _temp) = test_store();
+		let public = store
+			.keystore
+			.ed25519_generate_new(sp_core::crypto::key_types::STATEMENT, None)
+			.unwrap();
+		let statement1 = statement(1, 1, None, 100);
+		let mut statement2 = statement(1, 2, None, 0);
+		let plain = b"The most valuable secret".to_vec();
+		statement2.encrypt(&plain, &public).unwrap();
+		store.submit(statement1, StatementSource::Network);
+		store.submit(statement2, StatementSource::Network);
+		let posted_clear = store.posted_clear(&[], public.into()).unwrap();
+		assert_eq!(posted_clear, vec![plain]);
+	}
+}
diff --git a/substrate/client/statement-store/src/metrics.rs b/substrate/client/statement-store/src/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cf191b79757edb217a3e2dc4b10a45cf5b0a211b
--- /dev/null
+++ b/substrate/client/statement-store/src/metrics.rs
@@ -0,0 +1,79 @@
+// 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/>.
+
+//! Statement store Prometheus metrics.
+
+use std::sync::Arc;
+
+use prometheus_endpoint::{register, Counter, PrometheusError, Registry, U64};
+
+#[derive(Clone, Default)]
+pub struct MetricsLink(Arc<Option<Metrics>>);
+
+impl MetricsLink {
+	pub fn new(registry: Option<&Registry>) -> Self {
+		Self(Arc::new(registry.and_then(|registry| {
+			Metrics::register(registry)
+				.map_err(|err| {
+					log::warn!("Failed to register prometheus metrics: {}", err);
+				})
+				.ok()
+		})))
+	}
+
+	pub fn report(&self, do_this: impl FnOnce(&Metrics)) {
+		if let Some(metrics) = self.0.as_ref() {
+			do_this(metrics);
+		}
+	}
+}
+
+/// Statement store Prometheus metrics.
+pub struct Metrics {
+	pub submitted_statements: Counter<U64>,
+	pub validations_invalid: Counter<U64>,
+	pub statements_pruned: Counter<U64>,
+}
+
+impl Metrics {
+	pub fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			submitted_statements: register(
+				Counter::new(
+					"substrate_sub_statement_store_submitted_statements",
+					"Total number of statements submitted",
+				)?,
+				registry,
+			)?,
+			validations_invalid: register(
+				Counter::new(
+					"substrate_sub_statement_store_validations_invalid",
+					"Total number of statements that were removed from the pool as invalid",
+				)?,
+				registry,
+			)?,
+			statements_pruned: register(
+				Counter::new(
+					"substrate_sub_statement_store_block_statements",
+					"Total number of statements that was requested to be pruned by block events",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
diff --git a/substrate/client/storage-monitor/Cargo.toml b/substrate/client/storage-monitor/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..02c67dedc59cc6db1df882a8685a4733dd93611a
--- /dev/null
+++ b/substrate/client/storage-monitor/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "sc-storage-monitor"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+repository = "https://github.com/paritytech/substrate"
+description = "Storage monitor service for substrate"
+homepage = "https://substrate.io"
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive", "string"] }
+log = "0.4.17"
+fs4 = "0.6.3"
+sc-client-db = { version = "0.10.0-dev", default-features = false, path = "../db" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+tokio = "1.22.0"
+thiserror = "1.0.30"
diff --git a/substrate/client/storage-monitor/src/lib.rs b/substrate/client/storage-monitor/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..655b940e8bedc0175c44464fd024a1b4ea0b37b4
--- /dev/null
+++ b/substrate/client/storage-monitor/src/lib.rs
@@ -0,0 +1,149 @@
+// 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 clap::Args;
+use sc_client_db::DatabaseSource;
+use sp_core::traits::SpawnEssentialNamed;
+use std::{
+	io,
+	path::{Path, PathBuf},
+	time::Duration,
+};
+
+const LOG_TARGET: &str = "storage-monitor";
+
+/// Result type used in this crate.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Error type used in this crate.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	#[error("IO Error")]
+	IOError(#[from] io::Error),
+	#[error("Out of storage space: available {0}MiB, required {1}MiB")]
+	StorageOutOfSpace(u64, u64),
+}
+
+/// Parameters used to create the storage monitor.
+#[derive(Default, Debug, Clone, Args)]
+pub struct StorageMonitorParams {
+	/// Required available space on database storage. If available space for DB storage drops below
+	/// the given threshold, node will be gracefully terminated. If `0` is given monitoring will be
+	/// disabled.
+	#[arg(long = "db-storage-threshold", value_name = "MiB", default_value_t = 1024)]
+	pub threshold: u64,
+
+	/// How often available space is polled.
+	#[arg(long = "db-storage-polling-period", value_name = "SECONDS", default_value_t = 5, value_parser = clap::value_parser!(u32).range(1..))]
+	pub polling_period: u32,
+}
+
+/// Storage monitor service: checks the available space for the filesystem for given path.
+pub struct StorageMonitorService {
+	/// watched path
+	path: PathBuf,
+	/// number of megabytes that shall be free on the filesystem for watched path
+	threshold: u64,
+	/// storage space polling period
+	polling_period: Duration,
+}
+
+impl StorageMonitorService {
+	/// Creates new StorageMonitorService for given client config
+	pub fn try_spawn(
+		parameters: StorageMonitorParams,
+		database: DatabaseSource,
+		spawner: &impl SpawnEssentialNamed,
+	) -> Result<()> {
+		Ok(match (parameters.threshold, database.path()) {
+			(0, _) => {
+				log::info!(
+					target: LOG_TARGET,
+					"StorageMonitorService: threshold `0` given, storage monitoring disabled",
+				);
+			},
+			(_, None) => {
+				log::warn!(
+					target: LOG_TARGET,
+					"StorageMonitorService: no database path to observe",
+				);
+			},
+			(threshold, Some(path)) => {
+				log::debug!(
+					target: LOG_TARGET,
+					"Initializing StorageMonitorService for db path: {path:?}",
+				);
+
+				Self::check_free_space(&path, threshold)?;
+
+				let storage_monitor_service = StorageMonitorService {
+					path: path.to_path_buf(),
+					threshold,
+					polling_period: Duration::from_secs(parameters.polling_period.into()),
+				};
+
+				spawner.spawn_essential(
+					"storage-monitor",
+					None,
+					Box::pin(storage_monitor_service.run()),
+				);
+			},
+		})
+	}
+
+	/// Main monitoring loop, intended to be spawned as essential task. Quits if free space drop
+	/// below threshold.
+	async fn run(self) {
+		loop {
+			tokio::time::sleep(self.polling_period).await;
+			if Self::check_free_space(&self.path, self.threshold).is_err() {
+				break
+			};
+		}
+	}
+
+	/// Returns free space in MiB, or error if statvfs failed.
+	fn free_space(path: &Path) -> Result<u64> {
+		Ok(fs4::available_space(path).map(|s| s / 1024 / 1024)?)
+	}
+
+	/// Checks if the amount of free space for given `path` is above given `threshold` in MiB.
+	/// If it dropped below, error is returned.
+	/// System errors are silently ignored.
+	fn check_free_space(path: &Path, threshold: u64) -> Result<()> {
+		match StorageMonitorService::free_space(path) {
+			Ok(available_space) => {
+				log::trace!(
+					target: LOG_TARGET,
+					"free: {available_space} , threshold: {threshold}.",
+				);
+
+				if available_space < threshold {
+					log::error!(target: LOG_TARGET, "Available space {available_space}MiB for path `{}` dropped below threshold: {threshold}MiB , terminating...", path.display());
+					Err(Error::StorageOutOfSpace(available_space, threshold))
+				} else {
+					Ok(())
+				}
+			},
+			Err(e) => {
+				log::error!(target: LOG_TARGET, "Could not read available space: {e:?}.");
+				Err(e)
+			},
+		}
+	}
+}
diff --git a/substrate/client/sync-state-rpc/Cargo.toml b/substrate/client/sync-state-rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..79013cbd5b33a00ec63abef65b8e8b2e7ad9657b
--- /dev/null
+++ b/substrate/client/sync-state-rpc/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "sc-sync-state-rpc"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "A RPC handler to create sync states for light clients."
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+serde = { version = "1.0.163", features = ["derive"] }
+serde_json = "1.0.85"
+thiserror = "1.0.30"
+sc-chain-spec = { version = "4.0.0-dev", path = "../chain-spec" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-consensus-babe = { version = "0.10.0-dev", path = "../consensus/babe" }
+sc-consensus-epochs = { version = "0.10.0-dev", path = "../consensus/epochs" }
+sc-consensus-grandpa = { version = "0.10.0-dev", path = "../consensus/grandpa" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
diff --git a/substrate/client/sync-state-rpc/src/lib.rs b/substrate/client/sync-state-rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dda8a7edfa9bba1838efa34f96e4a3e6470d1fe4
--- /dev/null
+++ b/substrate/client/sync-state-rpc/src/lib.rs
@@ -0,0 +1,211 @@
+// 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/>.
+
+//! A RPC handler to create sync states for light clients.
+//!
+//! Currently only usable with BABE + GRANDPA.
+//!
+//! # Usage
+//!
+//! To use the light sync state, it needs to be added as an extension to the chain spec:
+//!
+//! ```
+//! use sc_sync_state_rpc::LightSyncStateExtension;
+//!
+//! #[derive(Default, Clone, serde::Serialize, serde::Deserialize, sc_chain_spec::ChainSpecExtension)]
+//! #[serde(rename_all = "camelCase")]
+//! pub struct Extensions {
+//!    light_sync_state: LightSyncStateExtension,
+//! }
+//!
+//! type ChainSpec = sc_chain_spec::GenericChainSpec<(), Extensions>;
+//! ```
+//!
+//! If the [`LightSyncStateExtension`] is not added as an extension to the chain spec,
+//! the [`SyncState`] will fail at instantiation.
+
+#![deny(unused_crate_dependencies)]
+
+use std::sync::Arc;
+
+use jsonrpsee::{
+	core::{async_trait, Error as JsonRpseeError, RpcResult},
+	proc_macros::rpc,
+	types::{error::CallError, ErrorObject},
+};
+
+use sc_client_api::StorageData;
+use sc_consensus_babe::{BabeWorkerHandle, Error as BabeError};
+use sp_blockchain::HeaderBackend;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+type SharedAuthoritySet<TBl> =
+	sc_consensus_grandpa::SharedAuthoritySet<<TBl as BlockT>::Hash, NumberFor<TBl>>;
+
+/// Error type used by this crate.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error<Block: BlockT> {
+	#[error(transparent)]
+	Blockchain(#[from] sp_blockchain::Error),
+
+	#[error("Failed to load the block weight for block {0:?}")]
+	LoadingBlockWeightFailed(Block::Hash),
+
+	#[error("Failed to load the BABE epoch data: {0}")]
+	LoadingEpochDataFailed(BabeError<Block>),
+
+	#[error("JsonRpc error: {0}")]
+	JsonRpc(String),
+
+	#[error(
+		"The light sync state extension is not provided by the chain spec. \
+		Read the `sc-sync-state-rpc` crate docs on how to do this!"
+	)]
+	LightSyncStateExtensionNotFound,
+}
+
+impl<Block: BlockT> From<Error<Block>> for JsonRpseeError {
+	fn from(error: Error<Block>) -> Self {
+		let message = match error {
+			Error::JsonRpc(s) => s,
+			_ => error.to_string(),
+		};
+		CallError::Custom(ErrorObject::owned(1, message, None::<()>)).into()
+	}
+}
+
+/// Serialize the given `val` by encoding it with SCALE codec and serializing it as hex.
+fn serialize_encoded<S: serde::Serializer, T: codec::Encode>(
+	val: &T,
+	s: S,
+) -> Result<S::Ok, S::Error> {
+	let encoded = StorageData(val.encode());
+	serde::Serialize::serialize(&encoded, s)
+}
+
+/// The light sync state extension.
+///
+/// This represents a JSON serialized [`LightSyncState`]. It is required to be added to the
+/// chain-spec as an extension.
+pub type LightSyncStateExtension = Option<serde_json::Value>;
+
+/// Hardcoded information that allows light clients to sync quickly.
+#[derive(serde::Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
+pub struct LightSyncState<Block: BlockT> {
+	/// The header of the best finalized block.
+	#[serde(serialize_with = "serialize_encoded")]
+	pub finalized_block_header: <Block as BlockT>::Header,
+	/// The epoch changes tree for babe.
+	#[serde(serialize_with = "serialize_encoded")]
+	pub babe_epoch_changes: sc_consensus_epochs::EpochChangesFor<Block, sc_consensus_babe::Epoch>,
+	/// The babe weight of the finalized block.
+	pub babe_finalized_block_weight: sc_consensus_babe::BabeBlockWeight,
+	/// The authority set for grandpa.
+	#[serde(serialize_with = "serialize_encoded")]
+	pub grandpa_authority_set:
+		sc_consensus_grandpa::AuthoritySet<<Block as BlockT>::Hash, NumberFor<Block>>,
+}
+
+/// An api for sync state RPC calls.
+#[rpc(client, server)]
+pub trait SyncStateApi {
+	/// Returns the JSON serialized chainspec running the node, with a sync state.
+	#[method(name = "sync_state_genSyncSpec")]
+	async fn system_gen_sync_spec(&self, raw: bool) -> RpcResult<serde_json::Value>;
+}
+
+/// An api for sync state RPC calls.
+pub struct SyncState<Block: BlockT, Client> {
+	chain_spec: Box<dyn sc_chain_spec::ChainSpec>,
+	client: Arc<Client>,
+	shared_authority_set: SharedAuthoritySet<Block>,
+	babe_worker_handle: BabeWorkerHandle<Block>,
+}
+
+impl<Block, Client> SyncState<Block, Client>
+where
+	Block: BlockT,
+	Client: HeaderBackend<Block> + sc_client_api::AuxStore + 'static,
+{
+	/// Create a new sync state RPC helper.
+	pub fn new(
+		chain_spec: Box<dyn sc_chain_spec::ChainSpec>,
+		client: Arc<Client>,
+		shared_authority_set: SharedAuthoritySet<Block>,
+		babe_worker_handle: BabeWorkerHandle<Block>,
+	) -> Result<Self, Error<Block>> {
+		if sc_chain_spec::get_extension::<LightSyncStateExtension>(chain_spec.extensions())
+			.is_some()
+		{
+			Ok(Self { chain_spec, client, shared_authority_set, babe_worker_handle })
+		} else {
+			Err(Error::<Block>::LightSyncStateExtensionNotFound)
+		}
+	}
+
+	async fn build_sync_state(&self) -> Result<LightSyncState<Block>, Error<Block>> {
+		let epoch_changes = self
+			.babe_worker_handle
+			.epoch_data()
+			.await
+			.map_err(Error::LoadingEpochDataFailed)?;
+
+		let finalized_hash = self.client.info().finalized_hash;
+		let finalized_header = self
+			.client
+			.header(finalized_hash)?
+			.ok_or_else(|| sp_blockchain::Error::MissingHeader(finalized_hash.to_string()))?;
+
+		let finalized_block_weight =
+			sc_consensus_babe::aux_schema::load_block_weight(&*self.client, finalized_hash)?
+				.ok_or(Error::LoadingBlockWeightFailed(finalized_hash))?;
+
+		Ok(LightSyncState {
+			finalized_block_header: finalized_header,
+			babe_epoch_changes: epoch_changes,
+			babe_finalized_block_weight: finalized_block_weight,
+			grandpa_authority_set: self.shared_authority_set.clone_inner(),
+		})
+	}
+}
+
+#[async_trait]
+impl<Block, Backend> SyncStateApiServer for SyncState<Block, Backend>
+where
+	Block: BlockT,
+	Backend: HeaderBackend<Block> + sc_client_api::AuxStore + 'static,
+{
+	async fn system_gen_sync_spec(&self, raw: bool) -> RpcResult<serde_json::Value> {
+		let current_sync_state = self.build_sync_state().await?;
+		let mut chain_spec = self.chain_spec.cloned_box();
+
+		let extension = sc_chain_spec::get_extension_mut::<LightSyncStateExtension>(
+			chain_spec.extensions_mut(),
+		)
+		.ok_or(Error::<Block>::LightSyncStateExtensionNotFound)?;
+
+		let val = serde_json::to_value(&current_sync_state)?;
+		*extension = Some(val);
+
+		let json_str = chain_spec.as_json(raw).map_err(|e| Error::<Block>::JsonRpc(e))?;
+		serde_json::from_str(&json_str).map_err(Into::into)
+	}
+}
diff --git a/substrate/client/sysinfo/Cargo.toml b/substrate/client/sysinfo/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1435511915732b311158a5412e86e946eba855f6
--- /dev/null
+++ b/substrate/client/sysinfo/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "sc-sysinfo"
+version = "6.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "A crate that provides basic hardware and software telemetry information."
+documentation = "https://docs.rs/sc-sysinfo"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+futures = "0.3.19"
+libc = "0.2"
+log = "0.4.17"
+rand = "0.8.5"
+rand_pcg = "0.3.1"
+regex = "1"
+serde = { version = "1.0.163", features = ["derive"] }
+serde_json = "1.0.85"
+sc-telemetry = { version = "4.0.0-dev", path = "../telemetry" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-std = { version = "8.0.0", path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
diff --git a/substrate/client/sysinfo/README.md b/substrate/client/sysinfo/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a2189c5ed8db7a1f40f9726a525baca4d07e0f0
--- /dev/null
+++ b/substrate/client/sysinfo/README.md
@@ -0,0 +1,4 @@
+This crate contains the code necessary to gather basic hardware
+and software telemetry information about the node on which we're running.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
diff --git a/substrate/client/sysinfo/build.rs b/substrate/client/sysinfo/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d267f3670608c1ed7ff4ef2eb6f14bb1090a2822
--- /dev/null
+++ b/substrate/client/sysinfo/build.rs
@@ -0,0 +1,31 @@
+// 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/>.
+
+fn main() {
+	let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR is always set in build scripts; qed");
+	let out_dir = std::path::PathBuf::from(out_dir);
+	let target_os = std::env::var("CARGO_CFG_TARGET_OS")
+		.expect("CARGO_CFG_TARGET_OS is always set in build scripts; qed");
+	let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH")
+		.expect("CARGO_CFG_TARGET_ARCH is always set in build scripts; qed");
+	let target_env = std::env::var("CARGO_CFG_TARGET_ENV")
+		.expect("CARGO_CFG_TARGET_ENV is always set in build scripts; qed");
+	std::fs::write(out_dir.join("target_os.txt"), target_os).unwrap();
+	std::fs::write(out_dir.join("target_arch.txt"), target_arch).unwrap();
+	std::fs::write(out_dir.join("target_env.txt"), target_env).unwrap();
+}
diff --git a/substrate/client/sysinfo/src/lib.rs b/substrate/client/sysinfo/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7065c9b997e72c0d5d2e65ab53ec640ada6b38b5
--- /dev/null
+++ b/substrate/client/sysinfo/src/lib.rs
@@ -0,0 +1,164 @@
+// 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/>.
+
+//! This crate contains the code necessary to gather basic hardware
+//! and software telemetry information about the node on which we're running.
+
+use futures::prelude::*;
+use std::time::Duration;
+
+mod sysinfo;
+#[cfg(target_os = "linux")]
+mod sysinfo_linux;
+
+pub use sysinfo::{
+	benchmark_cpu, benchmark_disk_random_writes, benchmark_disk_sequential_writes,
+	benchmark_memory, benchmark_sr25519_verify, gather_hwbench, gather_sysinfo,
+	serialize_throughput, serialize_throughput_option, Metric, Requirement, Requirements,
+	Throughput,
+};
+
+/// The operating system part of the current target triplet.
+pub const TARGET_OS: &str = include_str!(concat!(env!("OUT_DIR"), "/target_os.txt"));
+
+/// The CPU ISA architecture part of the current target triplet.
+pub const TARGET_ARCH: &str = include_str!(concat!(env!("OUT_DIR"), "/target_arch.txt"));
+
+/// The environment part of the current target triplet.
+pub const TARGET_ENV: &str = include_str!(concat!(env!("OUT_DIR"), "/target_env.txt"));
+
+/// Hardware benchmark results for the node.
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct HwBench {
+	/// The CPU speed, as measured in how many MB/s it can hash using the BLAKE2b-256 hash.
+	#[serde(serialize_with = "serialize_throughput")]
+	pub cpu_hashrate_score: Throughput,
+	/// Memory bandwidth in MB/s, calculated by measuring the throughput of `memcpy`.
+	#[serde(serialize_with = "serialize_throughput")]
+	pub memory_memcpy_score: Throughput,
+	/// Sequential disk write speed in MB/s.
+	#[serde(
+		serialize_with = "serialize_throughput_option",
+		skip_serializing_if = "Option::is_none"
+	)]
+	pub disk_sequential_write_score: Option<Throughput>,
+	/// Random disk write speed in MB/s.
+	#[serde(
+		serialize_with = "serialize_throughput_option",
+		skip_serializing_if = "Option::is_none"
+	)]
+	pub disk_random_write_score: Option<Throughput>,
+}
+
+/// Limit the execution time of a benchmark.
+pub enum ExecutionLimit {
+	/// Limit by the maximal duration.
+	MaxDuration(Duration),
+
+	/// Limit by the maximal number of iterations.
+	MaxIterations(usize),
+
+	/// Limit by the maximal duration and maximal number of iterations.
+	Both { max_iterations: usize, max_duration: Duration },
+}
+
+impl ExecutionLimit {
+	/// Creates a new execution limit with the passed seconds as duration limit.
+	pub fn from_secs_f32(secs: f32) -> Self {
+		Self::MaxDuration(Duration::from_secs_f32(secs))
+	}
+
+	/// Returns the duration limit or `MAX` if none is present.
+	pub fn max_duration(&self) -> Duration {
+		match self {
+			Self::MaxDuration(d) => *d,
+			Self::Both { max_duration, .. } => *max_duration,
+			_ => Duration::from_secs(u64::MAX),
+		}
+	}
+
+	/// Returns the iterations limit or `MAX` if none is present.
+	pub fn max_iterations(&self) -> usize {
+		match self {
+			Self::MaxIterations(d) => *d,
+			Self::Both { max_iterations, .. } => *max_iterations,
+			_ => usize::MAX,
+		}
+	}
+}
+
+/// Prints out the system software/hardware information in the logs.
+pub fn print_sysinfo(sysinfo: &sc_telemetry::SysInfo) {
+	log::info!("💻 Operating system: {}", TARGET_OS);
+	log::info!("💻 CPU architecture: {}", TARGET_ARCH);
+	if !TARGET_ENV.is_empty() {
+		log::info!("💻 Target environment: {}", TARGET_ENV);
+	}
+
+	if let Some(ref cpu) = sysinfo.cpu {
+		log::info!("💻 CPU: {}", cpu);
+	}
+	if let Some(core_count) = sysinfo.core_count {
+		log::info!("💻 CPU cores: {}", core_count);
+	}
+	if let Some(memory) = sysinfo.memory {
+		log::info!("💻 Memory: {}MB", memory / (1024 * 1024));
+	}
+	if let Some(ref linux_kernel) = sysinfo.linux_kernel {
+		log::info!("💻 Kernel: {}", linux_kernel);
+	}
+	if let Some(ref linux_distro) = sysinfo.linux_distro {
+		log::info!("💻 Linux distribution: {}", linux_distro);
+	}
+	if let Some(is_virtual_machine) = sysinfo.is_virtual_machine {
+		log::info!("💻 Virtual machine: {}", if is_virtual_machine { "yes" } else { "no" });
+	}
+}
+
+/// Prints out the results of the hardware benchmarks in the logs.
+pub fn print_hwbench(hwbench: &HwBench) {
+	log::info!("� CPU score: {}", hwbench.cpu_hashrate_score);
+	log::info!("� Memory score: {}", hwbench.memory_memcpy_score);
+
+	if let Some(score) = hwbench.disk_sequential_write_score {
+		log::info!("� Disk score (seq. writes): {}", score);
+	}
+	if let Some(score) = hwbench.disk_random_write_score {
+		log::info!("� Disk score (rand. writes): {}", score);
+	}
+}
+
+/// Initializes the hardware benchmarks telemetry.
+pub fn initialize_hwbench_telemetry(
+	telemetry_handle: sc_telemetry::TelemetryHandle,
+	hwbench: HwBench,
+) -> impl std::future::Future<Output = ()> {
+	let mut connect_stream = telemetry_handle.on_connect_stream();
+	async move {
+		let payload = serde_json::to_value(&hwbench)
+			.expect("the `HwBench` can always be serialized into a JSON object; qed");
+		let mut payload = match payload {
+			serde_json::Value::Object(map) => map,
+			_ => unreachable!("the `HwBench` always serializes into a JSON object; qed"),
+		};
+		payload.insert("msg".into(), "sysinfo.hwbench".into());
+		while connect_stream.next().await.is_some() {
+			telemetry_handle.send_telemetry(sc_telemetry::SUBSTRATE_INFO, payload.clone());
+		}
+	}
+}
diff --git a/substrate/client/sysinfo/src/sysinfo.rs b/substrate/client/sysinfo/src/sysinfo.rs
new file mode 100644
index 0000000000000000000000000000000000000000..41161fc685d3196d691e8cff2976415007fe8344
--- /dev/null
+++ b/substrate/client/sysinfo/src/sysinfo.rs
@@ -0,0 +1,739 @@
+// 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::{ExecutionLimit, HwBench};
+
+use sc_telemetry::SysInfo;
+use sp_core::{sr25519, Pair};
+use sp_io::crypto::sr25519_verify;
+use sp_std::{fmt, fmt::Formatter, prelude::*};
+
+use rand::{seq::SliceRandom, Rng, RngCore};
+use serde::{de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
+use std::{
+	fs::File,
+	io::{Seek, SeekFrom, Write},
+	ops::{Deref, DerefMut},
+	path::{Path, PathBuf},
+	time::{Duration, Instant},
+};
+
+/// A single hardware metric.
+#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]
+pub enum Metric {
+	/// SR25519 signature verification.
+	Sr25519Verify,
+	/// Blake2-256 hashing algorithm.
+	Blake2256,
+	/// Copying data in RAM.
+	MemCopy,
+	/// Disk sequential write.
+	DiskSeqWrite,
+	/// Disk random write.
+	DiskRndWrite,
+}
+
+impl Metric {
+	/// The category of the metric.
+	pub fn category(&self) -> &'static str {
+		match self {
+			Self::Sr25519Verify | Self::Blake2256 => "CPU",
+			Self::MemCopy => "Memory",
+			Self::DiskSeqWrite | Self::DiskRndWrite => "Disk",
+		}
+	}
+
+	/// The name of the metric. It is always prefixed by the [`self.category()`].
+	pub fn name(&self) -> &'static str {
+		match self {
+			Self::Sr25519Verify => "SR25519-Verify",
+			Self::Blake2256 => "BLAKE2-256",
+			Self::MemCopy => "Copy",
+			Self::DiskSeqWrite => "Seq Write",
+			Self::DiskRndWrite => "Rnd Write",
+		}
+	}
+}
+
+/// The unit in which the [`Throughput`] (bytes per second) is denoted.
+pub enum Unit {
+	GiBs,
+	MiBs,
+	KiBs,
+}
+
+impl fmt::Display for Unit {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.write_str(match self {
+			Unit::GiBs => "GiBs",
+			Unit::MiBs => "MiBs",
+			Unit::KiBs => "KiBs",
+		})
+	}
+}
+
+/// Throughput as measured in bytes per second.
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
+pub struct Throughput(f64);
+
+const KIBIBYTE: f64 = (1 << 10) as f64;
+const MEBIBYTE: f64 = (1 << 20) as f64;
+const GIBIBYTE: f64 = (1 << 30) as f64;
+
+impl Throughput {
+	/// Construct [`Self`] from kibibyte/s.
+	pub fn from_kibs(kibs: f64) -> Throughput {
+		Throughput(kibs * KIBIBYTE)
+	}
+
+	/// Construct [`Self`] from mebibyte/s.
+	pub fn from_mibs(mibs: f64) -> Throughput {
+		Throughput(mibs * MEBIBYTE)
+	}
+
+	/// Construct [`Self`] from gibibyte/s.
+	pub fn from_gibs(gibs: f64) -> Throughput {
+		Throughput(gibs * GIBIBYTE)
+	}
+
+	/// [`Self`] as number of byte/s.
+	pub fn as_bytes(&self) -> f64 {
+		self.0
+	}
+
+	/// [`Self`] as number of kibibyte/s.
+	pub fn as_kibs(&self) -> f64 {
+		self.0 / KIBIBYTE
+	}
+
+	/// [`Self`] as number of mebibyte/s.
+	pub fn as_mibs(&self) -> f64 {
+		self.0 / MEBIBYTE
+	}
+
+	/// [`Self`] as number of gibibyte/s.
+	pub fn as_gibs(&self) -> f64 {
+		self.0 / GIBIBYTE
+	}
+
+	/// Normalizes [`Self`] to use the largest unit possible.
+	pub fn normalize(&self) -> (f64, Unit) {
+		let bs = self.0;
+
+		if bs >= GIBIBYTE {
+			(self.as_gibs(), Unit::GiBs)
+		} else if bs >= MEBIBYTE {
+			(self.as_mibs(), Unit::MiBs)
+		} else {
+			(self.as_kibs(), Unit::KiBs)
+		}
+	}
+}
+
+impl fmt::Display for Throughput {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let (value, unit) = self.normalize();
+		write!(f, "{:.2?} {}", value, unit)
+	}
+}
+
+/// Serializes `Throughput` and uses MiBs as the unit.
+pub fn serialize_throughput<S>(throughput: &Throughput, serializer: S) -> Result<S::Ok, S::Error>
+where
+	S: Serializer,
+{
+	serializer.serialize_u64(throughput.as_mibs() as u64)
+}
+
+/// Serializes `Option<Throughput>` and uses MiBs as the unit.
+pub fn serialize_throughput_option<S>(
+	maybe_throughput: &Option<Throughput>,
+	serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+	S: Serializer,
+{
+	if let Some(throughput) = maybe_throughput {
+		return serializer.serialize_some(&(throughput.as_mibs() as u64))
+	}
+	serializer.serialize_none()
+}
+
+/// Serializes throughput into MiBs and represents it as `f64`.
+fn serialize_throughput_as_f64<S>(throughput: &Throughput, serializer: S) -> Result<S::Ok, S::Error>
+where
+	S: Serializer,
+{
+	serializer.serialize_f64(throughput.as_mibs())
+}
+
+struct ThroughputVisitor;
+impl<'de> Visitor<'de> for ThroughputVisitor {
+	type Value = Throughput;
+
+	fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
+		formatter.write_str("A value that is a f64.")
+	}
+
+	fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
+	where
+		E: serde::de::Error,
+	{
+		Ok(Throughput::from_mibs(value))
+	}
+}
+
+fn deserialize_throughput<'de, D>(deserializer: D) -> Result<Throughput, D::Error>
+where
+	D: Deserializer<'de>,
+{
+	Ok(deserializer.deserialize_f64(ThroughputVisitor))?
+}
+
+/// Multiple requirements for the hardware.
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+pub struct Requirements(pub Vec<Requirement>);
+
+/// A single requirement for the hardware.
+#[derive(Deserialize, Serialize, Debug, Clone, Copy, PartialEq)]
+pub struct Requirement {
+	/// The metric to measure.
+	pub metric: Metric,
+	/// The minimal throughput that needs to be archived for this requirement.
+	#[serde(
+		serialize_with = "serialize_throughput_as_f64",
+		deserialize_with = "deserialize_throughput"
+	)]
+	pub minimum: Throughput,
+}
+
+#[inline(always)]
+pub(crate) fn benchmark<E>(
+	name: &str,
+	size: usize,
+	max_iterations: usize,
+	max_duration: Duration,
+	mut run: impl FnMut() -> Result<(), E>,
+) -> Result<Throughput, E> {
+	// Run the benchmark once as a warmup to get the code into the L1 cache.
+	run()?;
+
+	// Then run it multiple times and average the result.
+	let timestamp = Instant::now();
+	let mut elapsed = Duration::default();
+	let mut count = 0;
+	for _ in 0..max_iterations {
+		run()?;
+
+		count += 1;
+		elapsed = timestamp.elapsed();
+
+		if elapsed >= max_duration {
+			break
+		}
+	}
+
+	let score = Throughput::from_kibs((size * count) as f64 / (elapsed.as_secs_f64() * 1024.0));
+	log::trace!(
+		"Calculated {} of {} in {} iterations in {}ms",
+		name,
+		score,
+		count,
+		elapsed.as_millis()
+	);
+	Ok(score)
+}
+
+/// Gathers information about node's hardware and software.
+pub fn gather_sysinfo() -> SysInfo {
+	#[allow(unused_mut)]
+	let mut sysinfo = SysInfo {
+		cpu: None,
+		memory: None,
+		core_count: None,
+		linux_kernel: None,
+		linux_distro: None,
+		is_virtual_machine: None,
+	};
+
+	#[cfg(target_os = "linux")]
+	crate::sysinfo_linux::gather_linux_sysinfo(&mut sysinfo);
+
+	sysinfo
+}
+
+#[inline(never)]
+fn clobber_slice<T>(slice: &mut [T]) {
+	assert!(!slice.is_empty());
+
+	// Discourage the compiler from optimizing out our benchmarks.
+	//
+	// Volatile reads and writes are guaranteed to not be elided nor reordered,
+	// so we can use them to effectively clobber a piece of memory and prevent
+	// the compiler from optimizing out our technically unnecessary code.
+	//
+	// This is not totally bulletproof in theory, but should work in practice.
+	//
+	// SAFETY: We've checked that the slice is not empty, so reading and writing
+	//         its first element is always safe.
+	unsafe {
+		let value = std::ptr::read_volatile(slice.as_ptr());
+		std::ptr::write_volatile(slice.as_mut_ptr(), value);
+	}
+}
+
+#[inline(never)]
+fn clobber_value<T>(input: &mut T) {
+	// Look into `clobber_slice` for a comment.
+	unsafe {
+		let value = std::ptr::read_volatile(input);
+		std::ptr::write_volatile(input, value);
+	}
+}
+
+/// A default [`ExecutionLimit`] that can be used to call [`benchmark_cpu`].
+pub const DEFAULT_CPU_EXECUTION_LIMIT: ExecutionLimit =
+	ExecutionLimit::Both { max_iterations: 4 * 1024, max_duration: Duration::from_millis(100) };
+
+// This benchmarks the CPU speed as measured by calculating BLAKE2b-256 hashes, in bytes per second.
+pub fn benchmark_cpu(limit: ExecutionLimit) -> Throughput {
+	// In general the results of this benchmark are somewhat sensitive to how much
+	// data we hash at the time. The smaller this is the *less* B/s we can hash,
+	// the bigger this is the *more* B/s we can hash, up until a certain point
+	// where we can achieve roughly ~100% of what the hasher can do. If we'd plot
+	// this on a graph with the number of bytes we want to hash on the X axis
+	// and the speed in B/s on the Y axis then we'd essentially see it grow
+	// logarithmically.
+	//
+	// In practice however we might not always have enough data to hit the maximum
+	// possible speed that the hasher can achieve, so the size set here should be
+	// picked in such a way as to still measure how fast the hasher is at hashing,
+	// but without hitting its theoretical maximum speed.
+	const SIZE: usize = 32 * 1024;
+
+	let mut buffer = Vec::new();
+	buffer.resize(SIZE, 0x66);
+	let mut hash = Default::default();
+
+	let run = || -> Result<(), ()> {
+		clobber_slice(&mut buffer);
+		hash = sp_core::hashing::blake2_256(&buffer);
+		clobber_slice(&mut hash);
+
+		Ok(())
+	};
+
+	benchmark("CPU score", SIZE, limit.max_iterations(), limit.max_duration(), run)
+		.expect("benchmark cannot fail; qed")
+}
+
+/// A default [`ExecutionLimit`] that can be used to call [`benchmark_memory`].
+pub const DEFAULT_MEMORY_EXECUTION_LIMIT: ExecutionLimit =
+	ExecutionLimit::Both { max_iterations: 32, max_duration: Duration::from_millis(100) };
+
+// This benchmarks the effective `memcpy` memory bandwidth available in bytes per second.
+//
+// It doesn't technically measure the absolute maximum memory bandwidth available,
+// but that's fine, because real code most of the time isn't optimized to take
+// advantage of the full memory bandwidth either.
+pub fn benchmark_memory(limit: ExecutionLimit) -> Throughput {
+	// Ideally this should be at least as big as the CPU's L3 cache,
+	// and it should be big enough so that the `memcpy` takes enough
+	// time to be actually measurable.
+	//
+	// As long as it's big enough increasing it further won't change
+	// the benchmark's results.
+	const SIZE: usize = 64 * 1024 * 1024;
+
+	let mut src = Vec::new();
+	let mut dst = Vec::new();
+
+	// Prefault the pages; we want to measure the memory bandwidth,
+	// not how fast the kernel can supply us with fresh memory pages.
+	src.resize(SIZE, 0x66);
+	dst.resize(SIZE, 0x77);
+
+	let run = || -> Result<(), ()> {
+		clobber_slice(&mut src);
+		clobber_slice(&mut dst);
+
+		// SAFETY: Both vectors are of the same type and of the same size,
+		//         so copying data between them is safe.
+		unsafe {
+			// We use `memcpy` directly here since `copy_from_slice` isn't actually
+			// guaranteed to be turned into a `memcpy`.
+			libc::memcpy(dst.as_mut_ptr().cast(), src.as_ptr().cast(), SIZE);
+		}
+
+		clobber_slice(&mut dst);
+		clobber_slice(&mut src);
+
+		Ok(())
+	};
+
+	benchmark("memory score", SIZE, limit.max_iterations(), limit.max_duration(), run)
+		.expect("benchmark cannot fail; qed")
+}
+
+struct TemporaryFile {
+	fp: Option<File>,
+	path: PathBuf,
+}
+
+impl Drop for TemporaryFile {
+	fn drop(&mut self) {
+		let _ = self.fp.take();
+
+		// Remove the file.
+		//
+		// This has to be done *after* the benchmark,
+		// otherwise it changes the results as the data
+		// doesn't actually get properly flushed to the disk,
+		// since the file's not there anymore.
+		if let Err(error) = std::fs::remove_file(&self.path) {
+			log::warn!("Failed to remove the file used for the disk benchmark: {}", error);
+		}
+	}
+}
+
+impl Deref for TemporaryFile {
+	type Target = File;
+	fn deref(&self) -> &Self::Target {
+		self.fp.as_ref().expect("`fp` is None only during `drop`")
+	}
+}
+
+impl DerefMut for TemporaryFile {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		self.fp.as_mut().expect("`fp` is None only during `drop`")
+	}
+}
+
+fn rng() -> rand_pcg::Pcg64 {
+	rand_pcg::Pcg64::new(0xcafef00dd15ea5e5, 0xa02bdbf7bb3c0a7ac28fa16a64abf96)
+}
+
+fn random_data(size: usize) -> Vec<u8> {
+	let mut buffer = Vec::new();
+	buffer.resize(size, 0);
+	rng().fill(&mut buffer[..]);
+	buffer
+}
+
+/// A default [`ExecutionLimit`] that can be used to call [`benchmark_disk_sequential_writes`]
+/// and [`benchmark_disk_random_writes`].
+pub const DEFAULT_DISK_EXECUTION_LIMIT: ExecutionLimit =
+	ExecutionLimit::Both { max_iterations: 32, max_duration: Duration::from_millis(300) };
+
+pub fn benchmark_disk_sequential_writes(
+	limit: ExecutionLimit,
+	directory: &Path,
+) -> Result<Throughput, String> {
+	const SIZE: usize = 64 * 1024 * 1024;
+
+	let buffer = random_data(SIZE);
+	let path = directory.join(".disk_bench_seq_wr.tmp");
+
+	let fp =
+		File::create(&path).map_err(|error| format!("failed to create a test file: {}", error))?;
+
+	let mut fp = TemporaryFile { fp: Some(fp), path };
+
+	fp.sync_all()
+		.map_err(|error| format!("failed to fsync the test file: {}", error))?;
+
+	let run = || {
+		// Just dump everything to the disk in one go.
+		fp.write_all(&buffer)
+			.map_err(|error| format!("failed to write to the test file: {}", error))?;
+
+		// And then make sure it was actually written to disk.
+		fp.sync_all()
+			.map_err(|error| format!("failed to fsync the test file: {}", error))?;
+
+		// Rewind to the beginning for the next iteration of the benchmark.
+		fp.seek(SeekFrom::Start(0))
+			.map_err(|error| format!("failed to seek to the start of the test file: {}", error))?;
+
+		Ok(())
+	};
+
+	benchmark(
+		"disk sequential write score",
+		SIZE,
+		limit.max_iterations(),
+		limit.max_duration(),
+		run,
+	)
+}
+
+pub fn benchmark_disk_random_writes(
+	limit: ExecutionLimit,
+	directory: &Path,
+) -> Result<Throughput, String> {
+	const SIZE: usize = 64 * 1024 * 1024;
+
+	let buffer = random_data(SIZE);
+	let path = directory.join(".disk_bench_rand_wr.tmp");
+
+	let fp =
+		File::create(&path).map_err(|error| format!("failed to create a test file: {}", error))?;
+
+	let mut fp = TemporaryFile { fp: Some(fp), path };
+
+	// Since we want to test random writes we need an existing file
+	// through which we can seek, so here we just populate it with some data.
+	fp.write_all(&buffer)
+		.map_err(|error| format!("failed to write to the test file: {}", error))?;
+
+	fp.sync_all()
+		.map_err(|error| format!("failed to fsync the test file: {}", error))?;
+
+	// Generate a list of random positions at which we'll issue writes.
+	let mut positions = Vec::with_capacity(SIZE / 4096);
+	{
+		let mut position = 0;
+		while position < SIZE {
+			positions.push(position);
+			position += 4096;
+		}
+	}
+
+	positions.shuffle(&mut rng());
+
+	let run = || {
+		for &position in &positions {
+			fp.seek(SeekFrom::Start(position as u64))
+				.map_err(|error| format!("failed to seek in the test file: {}", error))?;
+
+			// Here we deliberately only write half of the chunk since we don't
+			// want the OS' disk scheduler to coalesce our writes into one single
+			// sequential write.
+			//
+			// Also the chunk's size is deliberately exactly half of a modern disk's
+			// sector size to trigger an RMW cycle.
+			let chunk = &buffer[position..position + 2048];
+			fp.write_all(&chunk)
+				.map_err(|error| format!("failed to write to the test file: {}", error))?;
+		}
+
+		fp.sync_all()
+			.map_err(|error| format!("failed to fsync the test file: {}", error))?;
+
+		Ok(())
+	};
+
+	// We only wrote half of the bytes hence `SIZE / 2`.
+	benchmark(
+		"disk random write score",
+		SIZE / 2,
+		limit.max_iterations(),
+		limit.max_duration(),
+		run,
+	)
+}
+
+/// Benchmarks the verification speed of sr25519 signatures.
+///
+/// Returns the throughput in B/s by convention.
+/// The values are rather small (0.4-0.8) so it is advised to convert them into KB/s.
+pub fn benchmark_sr25519_verify(limit: ExecutionLimit) -> Throughput {
+	const INPUT_SIZE: usize = 32;
+	const ITERATION_SIZE: usize = 2048;
+	let pair = sr25519::Pair::from_string("//Alice", None).unwrap();
+
+	let mut rng = rng();
+	let mut msgs = Vec::new();
+	let mut sigs = Vec::new();
+
+	for _ in 0..ITERATION_SIZE {
+		let mut msg = vec![0u8; INPUT_SIZE];
+		rng.fill_bytes(&mut msg[..]);
+
+		sigs.push(pair.sign(&msg));
+		msgs.push(msg);
+	}
+
+	let run = || -> Result<(), String> {
+		for (sig, msg) in sigs.iter().zip(msgs.iter()) {
+			let mut ok = sr25519_verify(&sig, &msg[..], &pair.public());
+			clobber_value(&mut ok);
+		}
+		Ok(())
+	};
+	benchmark(
+		"sr25519 verification score",
+		INPUT_SIZE * ITERATION_SIZE,
+		limit.max_iterations(),
+		limit.max_duration(),
+		run,
+	)
+	.expect("sr25519 verification cannot fail; qed")
+}
+
+/// Benchmarks the hardware and returns the results of those benchmarks.
+///
+/// Optionally accepts a path to a `scratch_directory` to use to benchmark the
+/// disk. Also accepts the `requirements` for the hardware benchmark and a
+/// boolean to specify if the node is an authority.
+pub fn gather_hwbench(scratch_directory: Option<&Path>) -> HwBench {
+	#[allow(unused_mut)]
+	let mut hwbench = HwBench {
+		cpu_hashrate_score: benchmark_cpu(DEFAULT_CPU_EXECUTION_LIMIT),
+		memory_memcpy_score: benchmark_memory(DEFAULT_MEMORY_EXECUTION_LIMIT),
+		disk_sequential_write_score: None,
+		disk_random_write_score: None,
+	};
+
+	if let Some(scratch_directory) = scratch_directory {
+		hwbench.disk_sequential_write_score =
+			match benchmark_disk_sequential_writes(DEFAULT_DISK_EXECUTION_LIMIT, scratch_directory)
+			{
+				Ok(score) => Some(score),
+				Err(error) => {
+					log::warn!("Failed to run the sequential write disk benchmark: {}", error);
+					None
+				},
+			};
+
+		hwbench.disk_random_write_score =
+			match benchmark_disk_random_writes(DEFAULT_DISK_EXECUTION_LIMIT, scratch_directory) {
+				Ok(score) => Some(score),
+				Err(error) => {
+					log::warn!("Failed to run the random write disk benchmark: {}", error);
+					None
+				},
+			};
+	}
+
+	hwbench
+}
+
+impl Requirements {
+	/// Whether the hardware requirements are met by the provided benchmark results.
+	pub fn check_hardware(&self, hwbench: &HwBench) -> bool {
+		for requirement in self.0.iter() {
+			match requirement.metric {
+				Metric::Blake2256 =>
+					if requirement.minimum > hwbench.cpu_hashrate_score {
+						return false
+					},
+				Metric::MemCopy =>
+					if requirement.minimum > hwbench.memory_memcpy_score {
+						return false
+					},
+				Metric::DiskSeqWrite =>
+					if let Some(score) = hwbench.disk_sequential_write_score {
+						if requirement.minimum > score {
+							return false
+						}
+					},
+				Metric::DiskRndWrite =>
+					if let Some(score) = hwbench.disk_random_write_score {
+						if requirement.minimum > score {
+							return false
+						}
+					},
+				Metric::Sr25519Verify => {},
+			}
+		}
+		true
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_runtime::assert_eq_error_rate_float;
+
+	#[cfg(target_os = "linux")]
+	#[test]
+	fn test_gather_sysinfo_linux() {
+		let sysinfo = gather_sysinfo();
+		assert!(sysinfo.cpu.unwrap().len() > 0);
+		assert!(sysinfo.core_count.unwrap() > 0);
+		assert!(sysinfo.memory.unwrap() > 0);
+		assert_ne!(sysinfo.is_virtual_machine, None);
+		assert_ne!(sysinfo.linux_kernel, None);
+		assert_ne!(sysinfo.linux_distro, None);
+	}
+
+	#[test]
+	fn test_benchmark_cpu() {
+		assert!(benchmark_cpu(DEFAULT_CPU_EXECUTION_LIMIT) > Throughput::from_mibs(0.0));
+	}
+
+	#[test]
+	fn test_benchmark_memory() {
+		assert!(benchmark_memory(DEFAULT_MEMORY_EXECUTION_LIMIT) > Throughput::from_mibs(0.0));
+	}
+
+	#[test]
+	fn test_benchmark_disk_sequential_writes() {
+		assert!(
+			benchmark_disk_sequential_writes(DEFAULT_DISK_EXECUTION_LIMIT, "./".as_ref()).unwrap() >
+				Throughput::from_mibs(0.0)
+		);
+	}
+
+	#[test]
+	fn test_benchmark_disk_random_writes() {
+		assert!(
+			benchmark_disk_random_writes(DEFAULT_DISK_EXECUTION_LIMIT, "./".as_ref()).unwrap() >
+				Throughput::from_mibs(0.0)
+		);
+	}
+
+	#[test]
+	fn test_benchmark_sr25519_verify() {
+		assert!(
+			benchmark_sr25519_verify(ExecutionLimit::MaxIterations(1)) > Throughput::from_mibs(0.0)
+		);
+	}
+
+	/// Test the [`Throughput`].
+	#[test]
+	fn throughput_works() {
+		/// Float precision.
+		const EPS: f64 = 0.1;
+		let gib = Throughput::from_gibs(14.324);
+
+		assert_eq_error_rate_float!(14.324, gib.as_gibs(), EPS);
+		assert_eq_error_rate_float!(14667.776, gib.as_mibs(), EPS);
+		assert_eq_error_rate_float!(14667.776 * 1024.0, gib.as_kibs(), EPS);
+		assert_eq!("14.32 GiBs", gib.to_string());
+
+		let mib = Throughput::from_mibs(1029.0);
+		assert_eq!("1.00 GiBs", mib.to_string());
+	}
+
+	/// Test the [`HwBench`] serialization.
+	#[test]
+	fn hwbench_serialize_works() {
+		let hwbench = HwBench {
+			cpu_hashrate_score: Throughput::from_gibs(1.32),
+			memory_memcpy_score: Throughput::from_kibs(9342.432),
+			disk_sequential_write_score: Some(Throughput::from_kibs(4332.12)),
+			disk_random_write_score: None,
+		};
+
+		let serialized = serde_json::to_string(&hwbench).unwrap();
+		// Throughput from all of the benchmarks should be converted to MiBs.
+		assert_eq!(serialized, "{\"cpu_hashrate_score\":1351,\"memory_memcpy_score\":9,\"disk_sequential_write_score\":4}");
+	}
+}
diff --git a/substrate/client/sysinfo/src/sysinfo_linux.rs b/substrate/client/sysinfo/src/sysinfo_linux.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ae678e07661ef12ab15d404be22d1e677d2aca48
--- /dev/null
+++ b/substrate/client/sysinfo/src/sysinfo_linux.rs
@@ -0,0 +1,101 @@
+// 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 regex::Regex;
+use sc_telemetry::SysInfo;
+use std::collections::HashSet;
+
+fn read_file(path: &str) -> Option<String> {
+	match std::fs::read_to_string(path) {
+		Ok(data) => Some(data),
+		Err(error) => {
+			log::warn!("Failed to read '{}': {}", path, error);
+			None
+		},
+	}
+}
+
+fn extract<T>(data: &str, regex: &str) -> Option<T>
+where
+	T: std::str::FromStr,
+{
+	Regex::new(regex)
+		.expect("regex is correct; qed")
+		.captures(&data)?
+		.get(1)?
+		.as_str()
+		.parse()
+		.ok()
+}
+
+const LINUX_REGEX_CPU: &str = r#"(?m)^model name\s*:\s*([^\n]+)"#;
+const LINUX_REGEX_PHYSICAL_ID: &str = r#"(?m)^physical id\s*:\s*(\d+)"#;
+const LINUX_REGEX_CORE_ID: &str = r#"(?m)^core id\s*:\s*(\d+)"#;
+const LINUX_REGEX_HYPERVISOR: &str = r#"(?m)^flags\s*:.+?\bhypervisor\b"#;
+const LINUX_REGEX_MEMORY: &str = r#"(?m)^MemTotal:\s*(\d+) kB"#;
+const LINUX_REGEX_DISTRO: &str = r#"(?m)^PRETTY_NAME\s*=\s*"?(.+?)"?$"#;
+
+pub fn gather_linux_sysinfo(sysinfo: &mut SysInfo) {
+	if let Some(data) = read_file("/proc/cpuinfo") {
+		sysinfo.cpu = extract(&data, LINUX_REGEX_CPU);
+		sysinfo.is_virtual_machine =
+			Some(Regex::new(LINUX_REGEX_HYPERVISOR).unwrap().is_match(&data));
+
+		// The /proc/cpuinfo returns a list of all of the hardware threads.
+		//
+		// Here we extract all of the unique {CPU ID, core ID} pairs to get
+		// the total number of cores.
+		let mut set: HashSet<(u32, u32)> = HashSet::new();
+		for chunk in data.split("\n\n") {
+			let pid = extract(chunk, LINUX_REGEX_PHYSICAL_ID);
+			let cid = extract(chunk, LINUX_REGEX_CORE_ID);
+			if let (Some(pid), Some(cid)) = (pid, cid) {
+				set.insert((pid, cid));
+			}
+		}
+
+		if !set.is_empty() {
+			sysinfo.core_count = Some(set.len() as u32);
+		}
+	}
+
+	if let Some(data) = read_file("/proc/meminfo") {
+		sysinfo.memory = extract(&data, LINUX_REGEX_MEMORY).map(|memory: u64| memory * 1024);
+	}
+
+	if let Some(data) = read_file("/etc/os-release") {
+		sysinfo.linux_distro = extract(&data, LINUX_REGEX_DISTRO);
+	}
+
+	// NOTE: We don't use the `nix` crate to call this since it doesn't
+	//       currently check for errors.
+	unsafe {
+		// SAFETY: The `utsname` is full of byte arrays, so this is safe.
+		let mut uname: libc::utsname = std::mem::zeroed();
+		if libc::uname(&mut uname) < 0 {
+			log::warn!("uname failed: {}", std::io::Error::last_os_error());
+		} else {
+			let length =
+				uname.release.iter().position(|&byte| byte == 0).unwrap_or(uname.release.len());
+			let release = std::slice::from_raw_parts(uname.release.as_ptr().cast(), length);
+			if let Ok(release) = std::str::from_utf8(release) {
+				sysinfo.linux_kernel = Some(release.into());
+			}
+		}
+	}
+}
diff --git a/substrate/client/telemetry/Cargo.toml b/substrate/client/telemetry/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f138557c8c2290f7a0e1e5d5a1e002c5c1b38e19
--- /dev/null
+++ b/substrate/client/telemetry/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "sc-telemetry"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Telemetry utils"
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sc-telemetry"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+chrono = "0.4.19"
+futures = "0.3.21"
+libp2p = { version = "0.51.3", features = ["dns", "tcp", "tokio", "wasm-ext", "websocket"] }
+log = "0.4.17"
+parking_lot = "0.12.1"
+pin-project = "1.0.12"
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+rand = "0.8.5"
+serde = { version = "1.0.163", features = ["derive"] }
+serde_json = "1.0.85"
+thiserror = "1.0.30"
+wasm-timer = "0.2.5"
diff --git a/substrate/client/telemetry/README.md b/substrate/client/telemetry/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e3e19bd2f628565dc22b6f18e24397fb4315f55
--- /dev/null
+++ b/substrate/client/telemetry/README.md
@@ -0,0 +1,21 @@
+# sc-telemetry
+
+Substrate's client telemetry is a part of substrate that allows ingesting telemetry data
+with for example [Polkadot telemetry](https://github.com/paritytech/substrate-telemetry).
+
+It works using Tokio's [tracing](https://github.com/tokio-rs/tracing/) library. The telemetry
+information uses tracing's logging to report the telemetry data which is then retrieved by a
+tracing `Layer`. This layer will then send the data through an asynchronous channel to a
+background task called [`TelemetryWorker`] which will send the information to the configured
+remote telemetry servers.
+
+If multiple substrate nodes are running in the same process, it uses a `tracing::Span` to
+identify which substrate node is reporting the telemetry. Every task spawned using sc-service's
+`TaskManager` automatically inherit this span.
+
+Substrate's nodes initialize/register with the [`TelemetryWorker`] using a [`TelemetryHandle`].
+This handle can be cloned and passed around. It uses an asynchronous channel to communicate with
+the running [`TelemetryWorker`] dedicated to registration. Registering can happen at any point
+in time during the process execution.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
diff --git a/substrate/client/telemetry/src/endpoints.rs b/substrate/client/telemetry/src/endpoints.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a4f0d0f83d617c2108a0bd3130c2229db7c5b209
--- /dev/null
+++ b/substrate/client/telemetry/src/endpoints.rs
@@ -0,0 +1,115 @@
+// 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 libp2p::Multiaddr;
+use serde::{Deserialize, Deserializer, Serialize};
+
+/// List of telemetry servers we want to talk to. Contains the URL of the server, and the
+/// maximum verbosity level.
+///
+/// The URL string can be either a URL or a multiaddress.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct TelemetryEndpoints(
+	#[serde(deserialize_with = "url_or_multiaddr_deser")] pub(crate) Vec<(Multiaddr, u8)>,
+);
+
+/// Custom deserializer for TelemetryEndpoints, used to convert urls or multiaddr to multiaddr.
+fn url_or_multiaddr_deser<'de, D>(deserializer: D) -> Result<Vec<(Multiaddr, u8)>, D::Error>
+where
+	D: Deserializer<'de>,
+{
+	Vec::<(String, u8)>::deserialize(deserializer)?
+		.iter()
+		.map(|e| url_to_multiaddr(&e.0).map_err(serde::de::Error::custom).map(|m| (m, e.1)))
+		.collect()
+}
+
+impl TelemetryEndpoints {
+	/// Create a `TelemetryEndpoints` based on a list of `(String, u8)`.
+	pub fn new(endpoints: Vec<(String, u8)>) -> Result<Self, libp2p::multiaddr::Error> {
+		let endpoints: Result<Vec<(Multiaddr, u8)>, libp2p::multiaddr::Error> =
+			endpoints.iter().map(|e| Ok((url_to_multiaddr(&e.0)?, e.1))).collect();
+		endpoints.map(Self)
+	}
+}
+
+impl TelemetryEndpoints {
+	/// Return `true` if there are no telemetry endpoints, `false` otherwise.
+	pub fn is_empty(&self) -> bool {
+		self.0.is_empty()
+	}
+}
+
+/// Parses a WebSocket URL into a libp2p `Multiaddr`.
+fn url_to_multiaddr(url: &str) -> Result<Multiaddr, libp2p::multiaddr::Error> {
+	// First, assume that we have a `Multiaddr`.
+	let parse_error = match url.parse() {
+		Ok(ma) => return Ok(ma),
+		Err(err) => err,
+	};
+
+	// If not, try the `ws://path/url` format.
+	if let Ok(ma) = libp2p::multiaddr::from_url(url) {
+		return Ok(ma)
+	}
+
+	// If we have no clue about the format of that string, assume that we were expecting a
+	// `Multiaddr`.
+	Err(parse_error)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{url_to_multiaddr, TelemetryEndpoints};
+	use libp2p::Multiaddr;
+
+	#[test]
+	fn valid_endpoints() {
+		let endp = vec![
+			("wss://telemetry.polkadot.io/submit/".into(), 3),
+			("/ip4/80.123.90.4/tcp/5432".into(), 4),
+		];
+		let telem =
+			TelemetryEndpoints::new(endp.clone()).expect("Telemetry endpoint should be valid");
+		let mut res: Vec<(Multiaddr, u8)> = vec![];
+		for (a, b) in endp.iter() {
+			res.push((url_to_multiaddr(a).expect("provided url should be valid"), *b))
+		}
+		assert_eq!(telem.0, res);
+	}
+
+	#[test]
+	fn invalid_endpoints() {
+		let endp = vec![
+			("/ip4/...80.123.90.4/tcp/5432".into(), 3),
+			("/ip4/no:!?;rlkqre;;::::///tcp/5432".into(), 4),
+		];
+		let telem = TelemetryEndpoints::new(endp);
+		assert!(telem.is_err());
+	}
+
+	#[test]
+	fn valid_and_invalid_endpoints() {
+		let endp = vec![
+			("/ip4/80.123.90.4/tcp/5432".into(), 3),
+			("/ip4/no:!?;rlkqre;;::::///tcp/5432".into(), 4),
+		];
+		let telem = TelemetryEndpoints::new(endp);
+		assert!(telem.is_err());
+	}
+}
diff --git a/substrate/client/telemetry/src/error.rs b/substrate/client/telemetry/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b8e3d28751d9899730832791816ddefb8d27da7e
--- /dev/null
+++ b/substrate/client/telemetry/src/error.rs
@@ -0,0 +1,31 @@
+// 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/>.
+
+#[allow(missing_docs)]
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	#[error("IO Error")]
+	IoError(#[from] std::io::Error),
+	#[error("This telemetry instance has already been initialized!")]
+	TelemetryAlreadyInitialized,
+	#[error("The telemetry worker has been dropped already.")]
+	TelemetryWorkerDropped,
+}
+
+#[allow(missing_docs)]
+pub type Result<T> = std::result::Result<T, Error>;
diff --git a/substrate/client/telemetry/src/lib.rs b/substrate/client/telemetry/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..113d8303a20f6fedcf8f3c75108896bbbb8f8756
--- /dev/null
+++ b/substrate/client/telemetry/src/lib.rs
@@ -0,0 +1,572 @@
+// 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/>.
+
+//! Substrate's client telemetry is a part of substrate that allows ingesting telemetry data
+//! with for example [Polkadot telemetry](https://github.com/paritytech/substrate-telemetry).
+//!
+//! It works using Tokio's [tracing](https://github.com/tokio-rs/tracing/) library. The telemetry
+//! information uses tracing's logging to report the telemetry data which is then retrieved by a
+//! tracing `Layer`. This layer will then send the data through an asynchronous channel to a
+//! background task called [`TelemetryWorker`] which will send the information to the configured
+//! remote telemetry servers.
+//!
+//! If multiple substrate nodes are running in the same process, it uses a `tracing::Span` to
+//! identify which substrate node is reporting the telemetry. Every task spawned using sc-service's
+//! `TaskManager` automatically inherit this span.
+//!
+//! Substrate's nodes initialize/register with the [`TelemetryWorker`] using a
+//! [`TelemetryWorkerHandle`]. This handle can be cloned and passed around. It uses an asynchronous
+//! channel to communicate with the running [`TelemetryWorker`] dedicated to registration.
+//! Registering can happen at any point in time during the process execution.
+
+#![warn(missing_docs)]
+
+use futures::{channel::mpsc, prelude::*};
+use libp2p::Multiaddr;
+use log::{error, warn};
+use parking_lot::Mutex;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use serde::Serialize;
+use std::{
+	collections::{
+		hash_map::Entry::{Occupied, Vacant},
+		HashMap,
+	},
+	sync::{atomic, Arc},
+};
+
+pub use log;
+pub use serde_json;
+
+mod endpoints;
+mod error;
+mod node;
+mod transport;
+
+pub use endpoints::*;
+pub use error::*;
+use node::*;
+use transport::*;
+
+/// Substrate DEBUG log level.
+pub const SUBSTRATE_DEBUG: VerbosityLevel = 9;
+/// Substrate INFO log level.
+pub const SUBSTRATE_INFO: VerbosityLevel = 0;
+
+/// Consensus TRACE log level.
+pub const CONSENSUS_TRACE: VerbosityLevel = 9;
+/// Consensus DEBUG log level.
+pub const CONSENSUS_DEBUG: VerbosityLevel = 5;
+/// Consensus WARN log level.
+pub const CONSENSUS_WARN: VerbosityLevel = 4;
+/// Consensus INFO log level.
+pub const CONSENSUS_INFO: VerbosityLevel = 1;
+
+/// Telemetry message verbosity.
+pub type VerbosityLevel = u8;
+
+pub(crate) type Id = u64;
+pub(crate) type TelemetryPayload = serde_json::Map<String, serde_json::Value>;
+pub(crate) type TelemetryMessage = (Id, VerbosityLevel, TelemetryPayload);
+
+/// Message sent when the connection (re-)establishes.
+#[derive(Debug, Serialize)]
+pub struct ConnectionMessage {
+	/// Node's name.
+	pub name: String,
+	/// Node's implementation.
+	pub implementation: String,
+	/// Node's version.
+	pub version: String,
+	/// Node's configuration.
+	pub config: String,
+	/// Node's chain.
+	pub chain: String,
+	/// Node's genesis hash.
+	pub genesis_hash: String,
+	/// Node is an authority.
+	pub authority: bool,
+	/// Node's startup time.
+	pub startup_time: String,
+	/// Node's network ID.
+	pub network_id: String,
+
+	/// Node's OS.
+	pub target_os: String,
+
+	/// Node's ISA.
+	pub target_arch: String,
+
+	/// Node's target platform ABI or libc.
+	pub target_env: String,
+
+	/// Node's software and hardware information.
+	pub sysinfo: Option<SysInfo>,
+}
+
+/// Hardware and software information for the node.
+///
+/// Gathering most of this information is highly OS-specific,
+/// so most of the fields here are optional.
+#[derive(Debug, Serialize)]
+pub struct SysInfo {
+	/// The exact CPU model.
+	pub cpu: Option<String>,
+	/// The total amount of memory, in bytes.
+	pub memory: Option<u64>,
+	/// The number of physical CPU cores.
+	pub core_count: Option<u32>,
+	/// The Linux kernel version.
+	pub linux_kernel: Option<String>,
+	/// The exact Linux distribution used.
+	pub linux_distro: Option<String>,
+	/// Whether the node's running under a virtual machine.
+	pub is_virtual_machine: Option<bool>,
+}
+
+/// Telemetry worker.
+///
+/// It should run as a background task using the [`TelemetryWorker::run`] method. This method
+/// will consume the object and any further attempts of initializing a new telemetry through its
+/// handle will fail (without being fatal).
+#[derive(Debug)]
+pub struct TelemetryWorker {
+	message_receiver: mpsc::Receiver<TelemetryMessage>,
+	message_sender: mpsc::Sender<TelemetryMessage>,
+	register_receiver: TracingUnboundedReceiver<Register>,
+	register_sender: TracingUnboundedSender<Register>,
+	id_counter: Arc<atomic::AtomicU64>,
+}
+
+impl TelemetryWorker {
+	/// Instantiate a new [`TelemetryWorker`] which can run in background.
+	///
+	/// Only one is needed per process.
+	pub fn new(buffer_size: usize) -> Result<Self> {
+		// Let's try to initialize a transport to get an early return.
+		// Later transport will be initialized multiple times in
+		// `::process_register`, so it's a convenient way to get an
+		// error as early as possible.
+		let _transport = initialize_transport()?;
+		let (message_sender, message_receiver) = mpsc::channel(buffer_size);
+		let (register_sender, register_receiver) =
+			tracing_unbounded("mpsc_telemetry_register", 10_000);
+
+		Ok(Self {
+			message_receiver,
+			message_sender,
+			register_receiver,
+			register_sender,
+			id_counter: Arc::new(atomic::AtomicU64::new(1)),
+		})
+	}
+
+	/// Get a new [`TelemetryWorkerHandle`].
+	///
+	/// This is used when you want to register with the [`TelemetryWorker`].
+	pub fn handle(&self) -> TelemetryWorkerHandle {
+		TelemetryWorkerHandle {
+			message_sender: self.message_sender.clone(),
+			register_sender: self.register_sender.clone(),
+			id_counter: self.id_counter.clone(),
+		}
+	}
+
+	/// Run the telemetry worker.
+	///
+	/// This should be run in a background task.
+	pub async fn run(mut self) {
+		let mut node_map: HashMap<Id, Vec<(VerbosityLevel, Multiaddr)>> = HashMap::new();
+		let mut node_pool: HashMap<Multiaddr, _> = HashMap::new();
+		let mut pending_connection_notifications: Vec<_> = Vec::new();
+
+		loop {
+			futures::select! {
+				message = self.message_receiver.next() => Self::process_message(
+					message,
+					&mut node_pool,
+					&node_map,
+				).await,
+				init_payload = self.register_receiver.next() => Self::process_register(
+					init_payload,
+					&mut node_pool,
+					&mut node_map,
+					&mut pending_connection_notifications,
+				).await,
+			}
+		}
+	}
+
+	async fn process_register(
+		input: Option<Register>,
+		node_pool: &mut HashMap<Multiaddr, Node<WsTrans>>,
+		node_map: &mut HashMap<Id, Vec<(VerbosityLevel, Multiaddr)>>,
+		pending_connection_notifications: &mut Vec<(Multiaddr, ConnectionNotifierSender)>,
+	) {
+		let input = input.expect("the stream is never closed; qed");
+
+		match input {
+			Register::Telemetry { id, endpoints, connection_message } => {
+				let endpoints = endpoints.0;
+
+				let connection_message = match serde_json::to_value(&connection_message) {
+					Ok(serde_json::Value::Object(mut value)) => {
+						value.insert("msg".into(), "system.connected".into());
+						let mut obj = serde_json::Map::new();
+						obj.insert("id".to_string(), id.into());
+						obj.insert("payload".to_string(), value.into());
+						Some(obj)
+					},
+					Ok(_) => {
+						unreachable!("ConnectionMessage always serialize to an object; qed")
+					},
+					Err(err) => {
+						log::error!(
+							target: "telemetry",
+							"Could not serialize connection message: {}",
+							err,
+						);
+						None
+					},
+				};
+
+				for (addr, verbosity) in endpoints {
+					log::trace!(
+						target: "telemetry",
+						"Initializing telemetry for: {:?}",
+						addr,
+					);
+					node_map.entry(id).or_default().push((verbosity, addr.clone()));
+
+					let node = match node_pool.entry(addr.clone()) {
+						Occupied(entry) => entry.into_mut(),
+						Vacant(entry) => {
+							let transport = initialize_transport();
+							let transport = match transport {
+								Ok(t) => t,
+								Err(err) => {
+									log::error!(
+										target: "telemetry",
+										"Could not initialise transport: {}",
+										err,
+									);
+									continue
+								},
+							};
+							entry.insert(Node::new(transport, addr.clone(), Vec::new(), Vec::new()))
+						},
+					};
+
+					node.connection_messages.extend(connection_message.clone());
+
+					pending_connection_notifications.retain(|(addr_b, connection_message)| {
+						if *addr_b == addr {
+							node.telemetry_connection_notifier.push(connection_message.clone());
+							false
+						} else {
+							true
+						}
+					});
+				}
+			},
+			Register::Notifier { addresses, connection_notifier } => {
+				for addr in addresses {
+					// If the Node has been initialized, we directly push the connection_notifier.
+					// Otherwise we push it to a queue that will be consumed when the connection
+					// initializes, thus ensuring that the connection notifier will be sent to the
+					// Node when it becomes available.
+					if let Some(node) = node_pool.get_mut(&addr) {
+						node.telemetry_connection_notifier.push(connection_notifier.clone());
+					} else {
+						pending_connection_notifications.push((addr, connection_notifier.clone()));
+					}
+				}
+			},
+		}
+	}
+
+	// dispatch messages to the telemetry nodes
+	async fn process_message(
+		input: Option<TelemetryMessage>,
+		node_pool: &mut HashMap<Multiaddr, Node<WsTrans>>,
+		node_map: &HashMap<Id, Vec<(VerbosityLevel, Multiaddr)>>,
+	) {
+		let (id, verbosity, payload) = input.expect("the stream is never closed; qed");
+
+		let ts = chrono::Local::now().to_rfc3339();
+		let mut message = serde_json::Map::new();
+		message.insert("id".into(), id.into());
+		message.insert("ts".into(), ts.into());
+		message.insert("payload".into(), payload.into());
+
+		let nodes = if let Some(nodes) = node_map.get(&id) {
+			nodes
+		} else {
+			// This is a normal error because the telemetry ID exists before the telemetry is
+			// initialized.
+			log::trace!(
+				target: "telemetry",
+				"Received telemetry log for unknown id ({:?}): {}",
+				id,
+				serde_json::to_string(&message)
+					.unwrap_or_else(|err| format!(
+						"could not be serialized ({}): {:?}",
+						err,
+						message,
+					)),
+			);
+			return
+		};
+
+		for (node_max_verbosity, addr) in nodes {
+			if verbosity > *node_max_verbosity {
+				continue
+			}
+
+			if let Some(node) = node_pool.get_mut(addr) {
+				let _ = node.send(message.clone()).await;
+			} else {
+				log::debug!(
+					target: "telemetry",
+					"Received message for unknown node ({}). This is a bug. \
+					Message sent: {}",
+					addr,
+					serde_json::to_string(&message)
+						.unwrap_or_else(|err| format!(
+							"could not be serialized ({}): {:?}",
+							err,
+							message,
+						)),
+				);
+			}
+		}
+	}
+}
+
+/// Handle to the [`TelemetryWorker`] thats allows initializing the telemetry for a Substrate node.
+#[derive(Debug, Clone)]
+pub struct TelemetryWorkerHandle {
+	message_sender: mpsc::Sender<TelemetryMessage>,
+	register_sender: TracingUnboundedSender<Register>,
+	id_counter: Arc<atomic::AtomicU64>,
+}
+
+impl TelemetryWorkerHandle {
+	/// Instantiate a new [`Telemetry`] object.
+	pub fn new_telemetry(&mut self, endpoints: TelemetryEndpoints) -> Telemetry {
+		let addresses = endpoints.0.iter().map(|(addr, _)| addr.clone()).collect();
+
+		Telemetry {
+			message_sender: self.message_sender.clone(),
+			register_sender: self.register_sender.clone(),
+			id: self.id_counter.fetch_add(1, atomic::Ordering::Relaxed),
+			connection_notifier: TelemetryConnectionNotifier {
+				register_sender: self.register_sender.clone(),
+				addresses,
+			},
+			endpoints: Some(endpoints),
+		}
+	}
+}
+
+/// A telemetry instance that can be used to send telemetry messages.
+#[derive(Debug)]
+pub struct Telemetry {
+	message_sender: mpsc::Sender<TelemetryMessage>,
+	register_sender: TracingUnboundedSender<Register>,
+	id: Id,
+	connection_notifier: TelemetryConnectionNotifier,
+	endpoints: Option<TelemetryEndpoints>,
+}
+
+impl Telemetry {
+	/// Initialize the telemetry with the endpoints provided in argument for the current substrate
+	/// node.
+	///
+	/// This method must be called during the substrate node initialization.
+	///
+	/// The `endpoints` argument is a collection of telemetry WebSocket servers with a corresponding
+	/// verbosity level.
+	///
+	/// The `connection_message` argument is a JSON object that is sent every time the connection
+	/// (re-)establishes.
+	pub fn start_telemetry(&mut self, connection_message: ConnectionMessage) -> Result<()> {
+		let endpoints = self.endpoints.take().ok_or(Error::TelemetryAlreadyInitialized)?;
+
+		self.register_sender
+			.unbounded_send(Register::Telemetry { id: self.id, endpoints, connection_message })
+			.map_err(|_| Error::TelemetryWorkerDropped)
+	}
+
+	/// Make a new cloneable handle to this [`Telemetry`]. This is used for reporting telemetries.
+	pub fn handle(&self) -> TelemetryHandle {
+		TelemetryHandle {
+			message_sender: Arc::new(Mutex::new(self.message_sender.clone())),
+			id: self.id,
+			connection_notifier: self.connection_notifier.clone(),
+		}
+	}
+}
+
+/// Handle to a [`Telemetry`].
+///
+/// Used to report telemetry messages.
+#[derive(Debug, Clone)]
+pub struct TelemetryHandle {
+	message_sender: Arc<Mutex<mpsc::Sender<TelemetryMessage>>>,
+	id: Id,
+	connection_notifier: TelemetryConnectionNotifier,
+}
+
+impl TelemetryHandle {
+	/// Send telemetry messages.
+	pub fn send_telemetry(&self, verbosity: VerbosityLevel, payload: TelemetryPayload) {
+		match self.message_sender.lock().try_send((self.id, verbosity, payload)) {
+			Ok(()) => {},
+			Err(err) if err.is_full() => log::trace!(
+				target: "telemetry",
+				"Telemetry channel full.",
+			),
+			Err(_) => log::trace!(
+				target: "telemetry",
+				"Telemetry channel closed.",
+			),
+		}
+	}
+
+	/// Get event stream for telemetry connection established events.
+	///
+	/// This function will return an error if the telemetry has already been started by
+	/// [`Telemetry::start_telemetry`].
+	pub fn on_connect_stream(&self) -> ConnectionNotifierReceiver {
+		self.connection_notifier.on_connect_stream()
+	}
+}
+
+/// Used to create a stream of events with only one event: when a telemetry connection
+/// (re-)establishes.
+#[derive(Clone, Debug)]
+pub struct TelemetryConnectionNotifier {
+	register_sender: TracingUnboundedSender<Register>,
+	addresses: Vec<Multiaddr>,
+}
+
+impl TelemetryConnectionNotifier {
+	fn on_connect_stream(&self) -> ConnectionNotifierReceiver {
+		let (message_sender, message_receiver) = connection_notifier_channel();
+		if let Err(err) = self.register_sender.unbounded_send(Register::Notifier {
+			addresses: self.addresses.clone(),
+			connection_notifier: message_sender,
+		}) {
+			error!(
+				target: "telemetry",
+				"Could not create a telemetry connection notifier: \
+				the telemetry is probably already running: {}",
+				err,
+			);
+		}
+		message_receiver
+	}
+}
+
+#[derive(Debug)]
+enum Register {
+	Telemetry { id: Id, endpoints: TelemetryEndpoints, connection_message: ConnectionMessage },
+	Notifier { addresses: Vec<Multiaddr>, connection_notifier: ConnectionNotifierSender },
+}
+
+/// Report a telemetry.
+///
+/// Translates to `tracing::info`, but contains an additional verbosity parameter which the log
+/// record is tagged with. Additionally the verbosity parameter is added to the record as a
+/// key-value pair.
+///
+/// # Example
+///
+/// ```no_run
+/// # use sc_telemetry::*;
+/// # let authority_id = 42_u64;
+/// # let set_id = (43_u64, 44_u64);
+/// # let authorities = vec![45_u64];
+/// # let telemetry: Option<TelemetryHandle> = None;
+/// telemetry!(
+///     telemetry;      // an `Option<TelemetryHandle>`
+///     CONSENSUS_INFO;
+///     "afg.authority_set";
+///     "authority_id" => authority_id.to_string(),
+///     "authority_set_id" => ?set_id,
+///     "authorities" => authorities,
+/// );
+/// ```
+#[macro_export(local_inner_macros)]
+macro_rules! telemetry {
+	( $telemetry:expr; $verbosity:expr; $msg:expr; $( $t:tt )* ) => {{
+		if let Some(telemetry) = $telemetry.as_ref() {
+			let verbosity: $crate::VerbosityLevel = $verbosity;
+			match format_fields_to_json!($($t)*) {
+				Err(err) => {
+					$crate::log::debug!(
+						target: "telemetry",
+						"Could not serialize value for telemetry: {}",
+						err,
+					);
+				},
+				Ok(mut json) => {
+					json.insert("msg".into(), $msg.into());
+					telemetry.send_telemetry(verbosity, json);
+				},
+			}
+		}
+	}};
+}
+
+#[macro_export(local_inner_macros)]
+#[doc(hidden)]
+macro_rules! format_fields_to_json {
+	( $k:literal => $v:expr $(,)? $(, $($t:tt)+ )? ) => {{
+		$crate::serde_json::to_value(&$v)
+			.map(|value| {
+				let mut map = $crate::serde_json::Map::new();
+				map.insert($k.into(), value);
+				map
+			})
+			$(
+				.and_then(|mut prev_map| {
+					format_fields_to_json!($($t)*)
+						.map(move |mut other_map| {
+							prev_map.append(&mut other_map);
+							prev_map
+						})
+				})
+			)*
+	}};
+	( $k:literal => ? $v:expr $(,)? $(, $($t:tt)+ )? ) => {{
+		let mut map = $crate::serde_json::Map::new();
+		map.insert($k.into(), std::format!("{:?}", &$v).into());
+		$crate::serde_json::Result::Ok(map)
+		$(
+			.and_then(|mut prev_map| {
+				format_fields_to_json!($($t)*)
+					.map(move |mut other_map| {
+						prev_map.append(&mut other_map);
+						prev_map
+					})
+			})
+		)*
+	}};
+}
diff --git a/substrate/client/telemetry/src/node.rs b/substrate/client/telemetry/src/node.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0bbdbfb622ef1ba478b62174d277e49ac836ff64
--- /dev/null
+++ b/substrate/client/telemetry/src/node.rs
@@ -0,0 +1,327 @@
+// 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::TelemetryPayload;
+use futures::{channel::mpsc, prelude::*};
+use libp2p::{core::transport::Transport, Multiaddr};
+use rand::Rng as _;
+use std::{
+	fmt, mem,
+	pin::Pin,
+	task::{Context, Poll},
+	time::Duration,
+};
+use wasm_timer::Delay;
+
+pub(crate) type ConnectionNotifierSender = mpsc::Sender<()>;
+pub(crate) type ConnectionNotifierReceiver = mpsc::Receiver<()>;
+
+pub(crate) fn connection_notifier_channel() -> (ConnectionNotifierSender, ConnectionNotifierReceiver)
+{
+	mpsc::channel(0)
+}
+
+/// Handler for a single telemetry node.
+///
+/// This is a wrapper `Sink` around a network `Sink` with 3 particularities:
+///  - It is infallible: if the connection stops, it will reconnect automatically when the server
+///    becomes available again.
+///  - It holds a list of "connection messages" which are sent automatically when the connection is
+///    (re-)established. This is used for the "system.connected" message that needs to be send for
+///    every substrate node that connects.
+///  - It doesn't stay in pending while waiting for connection. Instead, it moves data into the void
+///    if the connection could not be established. This is important for the `Dispatcher` `Sink`
+///    which we don't want to block if one connection is broken.
+#[derive(Debug)]
+pub(crate) struct Node<TTrans: Transport> {
+	/// Address of the node.
+	addr: Multiaddr,
+	/// State of the connection.
+	socket: NodeSocket<TTrans>,
+	/// Transport used to establish new connections.
+	transport: TTrans,
+	/// Messages that are sent when the connection (re-)establishes.
+	pub(crate) connection_messages: Vec<TelemetryPayload>,
+	/// Notifier for when the connection (re-)establishes.
+	pub(crate) telemetry_connection_notifier: Vec<ConnectionNotifierSender>,
+}
+
+enum NodeSocket<TTrans: Transport> {
+	/// We're connected to the node. This is the normal state.
+	Connected(NodeSocketConnected<TTrans>),
+	/// We are currently dialing the node.
+	Dialing(TTrans::Dial),
+	/// A new connection should be started as soon as possible.
+	ReconnectNow,
+	/// Waiting before attempting to dial again.
+	WaitingReconnect(Delay),
+	/// Temporary transition state.
+	Poisoned,
+}
+
+impl<TTrans: Transport> NodeSocket<TTrans> {
+	fn wait_reconnect() -> NodeSocket<TTrans> {
+		let random_delay = rand::thread_rng().gen_range(10..20);
+		let delay = Delay::new(Duration::from_secs(random_delay));
+		log::trace!(target: "telemetry", "Pausing for {} secs before reconnecting", random_delay);
+		NodeSocket::WaitingReconnect(delay)
+	}
+}
+
+struct NodeSocketConnected<TTrans: Transport> {
+	/// Where to send data.
+	sink: TTrans::Output,
+	/// Queue of packets to send before accepting new packets.
+	buf: Vec<Vec<u8>>,
+}
+
+impl<TTrans: Transport> Node<TTrans> {
+	/// Builds a new node handler.
+	pub(crate) fn new(
+		transport: TTrans,
+		addr: Multiaddr,
+		connection_messages: Vec<serde_json::Map<String, serde_json::Value>>,
+		telemetry_connection_notifier: Vec<ConnectionNotifierSender>,
+	) -> Self {
+		Node {
+			addr,
+			socket: NodeSocket::ReconnectNow,
+			transport,
+			connection_messages,
+			telemetry_connection_notifier,
+		}
+	}
+}
+
+impl<TTrans: Transport, TSinkErr> Node<TTrans>
+where
+	TTrans::Dial: Unpin,
+	TTrans::Output:
+		Sink<Vec<u8>, Error = TSinkErr> + Stream<Item = Result<Vec<u8>, TSinkErr>> + Unpin,
+	TSinkErr: fmt::Debug,
+{
+	// NOTE: this code has been inspired from `Buffer` (`futures_util::sink::Buffer`).
+	//       https://docs.rs/futures-util/0.3.8/src/futures_util/sink/buffer.rs.html#32
+	fn try_send_connection_messages(
+		self: Pin<&mut Self>,
+		cx: &mut Context<'_>,
+		conn: &mut NodeSocketConnected<TTrans>,
+	) -> Poll<Result<(), TSinkErr>> {
+		while let Some(item) = conn.buf.pop() {
+			if let Err(e) = conn.sink.start_send_unpin(item) {
+				return Poll::Ready(Err(e))
+			}
+			futures::ready!(conn.sink.poll_ready_unpin(cx))?;
+		}
+		Poll::Ready(Ok(()))
+	}
+}
+
+pub(crate) enum Infallible {}
+
+impl<TTrans: Transport, TSinkErr> Sink<TelemetryPayload> for Node<TTrans>
+where
+	TTrans: Unpin,
+	TTrans::Dial: Unpin,
+	TTrans::Output:
+		Sink<Vec<u8>, Error = TSinkErr> + Stream<Item = Result<Vec<u8>, TSinkErr>> + Unpin,
+	TSinkErr: fmt::Debug,
+{
+	type Error = Infallible;
+
+	fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		let mut socket = mem::replace(&mut self.socket, NodeSocket::Poisoned);
+		self.socket = loop {
+			match socket {
+				NodeSocket::Connected(mut conn) => match conn.sink.poll_ready_unpin(cx) {
+					Poll::Ready(Ok(())) => {
+						match self.as_mut().try_send_connection_messages(cx, &mut conn) {
+							Poll::Ready(Err(err)) => {
+								log::warn!(target: "telemetry", "⚠�  Disconnected from {}: {:?}", self.addr, err);
+								socket = NodeSocket::wait_reconnect();
+							},
+							Poll::Ready(Ok(())) => {
+								self.socket = NodeSocket::Connected(conn);
+								return Poll::Ready(Ok(()))
+							},
+							Poll::Pending => {
+								self.socket = NodeSocket::Connected(conn);
+								return Poll::Pending
+							},
+						}
+					},
+					Poll::Ready(Err(err)) => {
+						log::warn!(target: "telemetry", "⚠�  Disconnected from {}: {:?}", self.addr, err);
+						socket = NodeSocket::wait_reconnect();
+					},
+					Poll::Pending => {
+						self.socket = NodeSocket::Connected(conn);
+						return Poll::Pending
+					},
+				},
+				NodeSocket::Dialing(mut s) => match Future::poll(Pin::new(&mut s), cx) {
+					Poll::Ready(Ok(sink)) => {
+						log::debug!(target: "telemetry", "✅ Connected to {}", self.addr);
+
+						{
+							let mut index = 0;
+							while index < self.telemetry_connection_notifier.len() {
+								let sender = &mut self.telemetry_connection_notifier[index];
+								if let Err(error) = sender.try_send(()) {
+									if !error.is_disconnected() {
+										log::debug!(target: "telemetry", "Failed to send a telemetry connection notification: {}", error);
+									} else {
+										self.telemetry_connection_notifier.swap_remove(index);
+										continue
+									}
+								}
+								index += 1;
+							}
+						}
+
+						let buf = self
+							.connection_messages
+							.iter()
+							.map(|json| {
+								let mut json = json.clone();
+								json.insert(
+									"ts".to_string(),
+									chrono::Local::now().to_rfc3339().into(),
+								);
+								json
+							})
+							.filter_map(|json| match serde_json::to_vec(&json) {
+								Ok(message) => Some(message),
+								Err(err) => {
+									log::error!(
+										target: "telemetry",
+										"An error occurred while generating new connection \
+										messages: {}",
+										err,
+									);
+									None
+								},
+							})
+							.collect();
+
+						socket = NodeSocket::Connected(NodeSocketConnected { sink, buf });
+					},
+					Poll::Pending => break NodeSocket::Dialing(s),
+					Poll::Ready(Err(err)) => {
+						log::warn!(target: "telemetry", "� Error while dialing {}: {:?}", self.addr, err);
+						socket = NodeSocket::wait_reconnect();
+					},
+				},
+				NodeSocket::ReconnectNow => {
+					let addr = self.addr.clone();
+					match self.transport.dial(addr) {
+						Ok(d) => {
+							log::trace!(target: "telemetry", "Re-dialing {}", self.addr);
+							socket = NodeSocket::Dialing(d);
+						},
+						Err(err) => {
+							log::warn!(target: "telemetry", "� Error while re-dialing {}: {:?}", self.addr, err);
+							socket = NodeSocket::wait_reconnect();
+						},
+					}
+				},
+				NodeSocket::WaitingReconnect(mut s) => {
+					if Future::poll(Pin::new(&mut s), cx).is_ready() {
+						socket = NodeSocket::ReconnectNow;
+					} else {
+						break NodeSocket::WaitingReconnect(s)
+					}
+				},
+				NodeSocket::Poisoned => {
+					log::error!(target: "telemetry", "‼� Poisoned connection with {}", self.addr);
+					break NodeSocket::Poisoned
+				},
+			}
+		};
+
+		// The Dispatcher blocks when the Node syncs blocks. This is why it is important that the
+		// Node sinks don't go into "Pending" state while waiting for reconnection but rather
+		// discard the excess of telemetry messages.
+		Poll::Ready(Ok(()))
+	}
+
+	fn start_send(mut self: Pin<&mut Self>, item: TelemetryPayload) -> Result<(), Self::Error> {
+		// Any buffered outgoing telemetry messages are discarded while (re-)connecting.
+		match &mut self.socket {
+			NodeSocket::Connected(conn) => match serde_json::to_vec(&item) {
+				Ok(data) => {
+					log::trace!(target: "telemetry", "Sending {} bytes", data.len());
+					let _ = conn.sink.start_send_unpin(data);
+				},
+				Err(err) => log::debug!(
+					target: "telemetry",
+					"Could not serialize payload: {}",
+					err,
+				),
+			},
+			// We are currently dialing the node.
+			NodeSocket::Dialing(_) => log::trace!(target: "telemetry", "Dialing"),
+			// A new connection should be started as soon as possible.
+			NodeSocket::ReconnectNow => log::trace!(target: "telemetry", "Reconnecting"),
+			// Waiting before attempting to dial again.
+			NodeSocket::WaitingReconnect(_) => {},
+			// Temporary transition state.
+			NodeSocket::Poisoned => log::trace!(target: "telemetry", "Poisoned"),
+		}
+		Ok(())
+	}
+
+	fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+		match &mut self.socket {
+			NodeSocket::Connected(conn) => match conn.sink.poll_flush_unpin(cx) {
+				Poll::Ready(Err(e)) => {
+					// When `telemetry` closes the websocket connection we end
+					// up here, which is sub-optimal. See
+					// https://github.com/libp2p/rust-libp2p/issues/2021 for
+					// what we could do to improve this.
+					log::trace!(target: "telemetry", "[poll_flush] Error: {:?}", e);
+					self.socket = NodeSocket::wait_reconnect();
+					Poll::Ready(Ok(()))
+				},
+				Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
+				Poll::Pending => Poll::Pending,
+			},
+			_ => Poll::Ready(Ok(())),
+		}
+	}
+
+	fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+		match &mut self.socket {
+			NodeSocket::Connected(conn) => conn.sink.poll_close_unpin(cx).map(|_| Ok(())),
+			_ => Poll::Ready(Ok(())),
+		}
+	}
+}
+
+impl<TTrans: Transport> fmt::Debug for NodeSocket<TTrans> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		use NodeSocket::*;
+		f.write_str(match self {
+			Connected(_) => "Connected",
+			Dialing(_) => "Dialing",
+			ReconnectNow => "ReconnectNow",
+			WaitingReconnect(_) => "WaitingReconnect",
+			Poisoned => "Poisoned",
+		})
+	}
+}
diff --git a/substrate/client/telemetry/src/transport.rs b/substrate/client/telemetry/src/transport.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a82626caac2d340bfcee90dd7c1f06ac4a6edccd
--- /dev/null
+++ b/substrate/client/telemetry/src/transport.rs
@@ -0,0 +1,149 @@
+// 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 futures::{
+	prelude::*,
+	ready,
+	task::{Context, Poll},
+};
+use libp2p::{core::transport::timeout::TransportTimeout, Transport};
+use std::{io, pin::Pin, time::Duration};
+
+/// Timeout after which a connection attempt is considered failed. Includes the WebSocket HTTP
+/// upgrading.
+const CONNECT_TIMEOUT: Duration = Duration::from_secs(20);
+
+pub(crate) fn initialize_transport() -> Result<WsTrans, io::Error> {
+	let transport = {
+		let tcp_transport = libp2p::tcp::tokio::Transport::new(libp2p::tcp::Config::new());
+		let inner = libp2p::dns::TokioDnsConfig::system(tcp_transport)?;
+		libp2p::websocket::framed::WsConfig::new(inner).and_then(|connec, _| {
+			let connec = connec
+				.with(|item| {
+					let item = libp2p::websocket::framed::OutgoingData::Binary(item);
+					future::ready(Ok::<_, io::Error>(item))
+				})
+				.try_filter_map(|item| async move {
+					if let libp2p::websocket::framed::Incoming::Data(data) = item {
+						Ok(Some(data.into_bytes()))
+					} else {
+						Ok(None)
+					}
+				});
+			future::ready(Ok::<_, io::Error>(connec))
+		})
+	};
+
+	Ok(TransportTimeout::new(
+		transport.map(|out, _| {
+			let out = out
+				.map_err(|err| io::Error::new(io::ErrorKind::Other, err))
+				.sink_map_err(|err| io::Error::new(io::ErrorKind::Other, err));
+			Box::pin(out) as Pin<Box<_>>
+		}),
+		CONNECT_TIMEOUT,
+	)
+	.boxed())
+}
+
+/// A trait that implements `Stream` and `Sink`.
+pub(crate) trait StreamAndSink<I>: Stream + Sink<I> {}
+impl<T: ?Sized + Stream + Sink<I>, I> StreamAndSink<I> for T {}
+
+/// A type alias for the WebSocket transport.
+pub(crate) type WsTrans = libp2p::core::transport::Boxed<
+	Pin<
+		Box<
+			dyn StreamAndSink<Vec<u8>, Item = Result<Vec<u8>, io::Error>, Error = io::Error> + Send,
+		>,
+	>,
+>;
+
+/// Wraps around an `AsyncWrite` and implements `Sink`. Guarantees that each item being sent maps
+/// to one call of `write`.
+#[pin_project::pin_project]
+pub(crate) struct StreamSink<T>(#[pin] T, Option<Vec<u8>>);
+
+impl<T> From<T> for StreamSink<T> {
+	fn from(inner: T) -> StreamSink<T> {
+		StreamSink(inner, None)
+	}
+}
+
+impl<T: AsyncRead> Stream for StreamSink<T> {
+	type Item = Result<Vec<u8>, io::Error>;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+		let this = self.project();
+		let mut buf = vec![0; 128];
+		match ready!(AsyncRead::poll_read(this.0, cx, &mut buf)) {
+			Ok(0) => Poll::Ready(None),
+			Ok(n) => {
+				buf.truncate(n);
+				Poll::Ready(Some(Ok(buf)))
+			},
+			Err(err) => Poll::Ready(Some(Err(err))),
+		}
+	}
+}
+
+impl<T: AsyncWrite> StreamSink<T> {
+	fn poll_flush_buffer(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
+		let this = self.project();
+
+		if let Some(buffer) = this.1 {
+			if ready!(this.0.poll_write(cx, &buffer[..]))? != buffer.len() {
+				log::error!(target: "telemetry",
+					"Detected some internal buffering happening in the telemetry");
+				let err = io::Error::new(io::ErrorKind::Other, "Internal buffering detected");
+				return Poll::Ready(Err(err))
+			}
+		}
+
+		*this.1 = None;
+		Poll::Ready(Ok(()))
+	}
+}
+
+impl<T: AsyncWrite> Sink<Vec<u8>> for StreamSink<T> {
+	type Error = io::Error;
+
+	fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		ready!(StreamSink::poll_flush_buffer(self, cx))?;
+		Poll::Ready(Ok(()))
+	}
+
+	fn start_send(self: Pin<&mut Self>, item: Vec<u8>) -> Result<(), Self::Error> {
+		let this = self.project();
+		debug_assert!(this.1.is_none());
+		*this.1 = Some(item);
+		Ok(())
+	}
+
+	fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		ready!(self.as_mut().poll_flush_buffer(cx))?;
+		let this = self.project();
+		AsyncWrite::poll_flush(this.0, cx)
+	}
+
+	fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
+		ready!(self.as_mut().poll_flush_buffer(cx))?;
+		let this = self.project();
+		AsyncWrite::poll_close(this.0, cx)
+	}
+}
diff --git a/substrate/client/tracing/Cargo.toml b/substrate/client/tracing/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fa229782a781e28743671767806f914294364ecd
--- /dev/null
+++ b/substrate/client/tracing/Cargo.toml
@@ -0,0 +1,44 @@
+[package]
+name = "sc-tracing"
+version = "4.0.0-dev"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Instrumentation implementation for substrate."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+ansi_term = "0.12.1"
+atty = "0.2.13"
+chrono = "0.4.19"
+lazy_static = "1.4.0"
+libc = "0.2.121"
+log = { version = "0.4.17" }
+parking_lot = "0.12.1"
+regex = "1.6.0"
+rustc-hash = "1.1.0"
+serde = "1.0.163"
+thiserror = "1.0.30"
+tracing = "0.1.29"
+tracing-log = "0.1.3"
+tracing-subscriber = { version = "0.2.25", features = ["parking_lot"] }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-tracing-proc-macro = { version = "4.0.0-dev", path = "./proc-macro" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-rpc = { version = "6.0.0", path = "../../primitives/rpc" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+
+[dev-dependencies]
+criterion = "0.4.0"
+
+[[bench]]
+name = "bench"
+harness = false
diff --git a/substrate/client/tracing/README.md b/substrate/client/tracing/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b008436df9bbedd136f79be15c10ec5a7c7b9a07
--- /dev/null
+++ b/substrate/client/tracing/README.md
@@ -0,0 +1,11 @@
+Instrumentation implementation for substrate.
+
+This crate is unstable and the API and usage may change.
+
+# Usage
+
+See `sp-tracing` for examples on how to use tracing.
+
+Currently we provide `Log` (default), `Telemetry` variants for `Receiver`
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
\ No newline at end of file
diff --git a/substrate/client/tracing/benches/bench.rs b/substrate/client/tracing/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1379023ddfa6c14c4ae33aa7bf869c5434191091
--- /dev/null
+++ b/substrate/client/tracing/benches/bench.rs
@@ -0,0 +1,49 @@
+// 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 criterion::{criterion_group, criterion_main, Criterion};
+use tracing_subscriber::fmt::time::{ChronoLocal, FormatTime};
+
+fn bench_fast_local_time(c: &mut Criterion) {
+	c.bench_function("fast_local_time", |b| {
+		let mut buffer = String::new();
+		let t = sc_tracing::logging::FastLocalTime { with_fractional: true };
+		b.iter(|| {
+			buffer.clear();
+			t.format_time(&mut buffer).unwrap();
+		})
+	});
+}
+
+// This is here just as a point of comparison.
+fn bench_chrono_local(c: &mut Criterion) {
+	c.bench_function("chrono_local", |b| {
+		let mut buffer = String::new();
+		let t = ChronoLocal::with_format("%Y-%m-%d %H:%M:%S%.3f".to_string());
+		b.iter(|| {
+			buffer.clear();
+			t.format_time(&mut buffer).unwrap();
+		})
+	});
+}
+
+criterion_group! {
+	name = benches;
+	config = Criterion::default();
+	targets = bench_fast_local_time, bench_chrono_local
+}
+criterion_main!(benches);
diff --git a/substrate/client/tracing/proc-macro/Cargo.toml b/substrate/client/tracing/proc-macro/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4ae836e608367a57ae38cdf8359fad87806a1888
--- /dev/null
+++ b/substrate/client/tracing/proc-macro/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "sc-tracing-proc-macro"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Helper macros for Substrate's client CLI"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro-crate = "1.1.3"
+proc-macro2 = "1.0.56"
+quote = { version = "1.0.28", features = ["proc-macro"] }
+syn = { version = "2.0.16", features = ["proc-macro", "full", "extra-traits", "parsing"] }
diff --git a/substrate/client/tracing/proc-macro/src/lib.rs b/substrate/client/tracing/proc-macro/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8fb01de4036863af50e3a92ca7624500fc98549a
--- /dev/null
+++ b/substrate/client/tracing/proc-macro/src/lib.rs
@@ -0,0 +1,142 @@
+// 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 proc_macro::TokenStream;
+use proc_macro2::Span;
+use proc_macro_crate::{crate_name, FoundCrate};
+use quote::quote;
+use syn::{Error, Expr, Ident, ItemFn};
+
+/// Add a log prefix to the function.
+///
+/// This prefixes all the log lines with `[<name>]` (after the timestamp). It works by making a
+/// tracing's span that is propagated to all the child calls and child tasks (futures) if they are
+/// spawned properly with the `SpawnHandle` (see `TaskManager` in sc-cli) or if the futures use
+/// `.in_current_span()` (see tracing-futures).
+///
+/// See Tokio's [tracing documentation](https://docs.rs/tracing-core/) and
+/// [tracing-futures documentation](https://docs.rs/tracing-futures/) for more details.
+///
+/// # Implementation notes
+///
+/// If there are multiple spans with a log prefix, only the latest will be shown.
+///
+/// # Example with a literal
+///
+/// ```ignore
+/// Builds a new service for a light client.
+/// #[sc_cli::prefix_logs_with("light")]
+/// pub fn new_light(config: Configuration) -> Result<TaskManager, ServiceError> {
+///     let (client, backend, keystore, mut task_manager, on_demand) =
+///         sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
+///
+///        ...
+/// }
+/// ```
+///
+/// Will produce logs that look like this:
+///
+/// ```text
+/// 2020-10-16 08:03:14  Substrate Node
+/// 2020-10-16 08:03:14  ✌�  version 2.0.0-47f7d3f2e-x86_64-linux-gnu
+/// 2020-10-16 08:03:14  ��  by Anonymous, 2017-2020
+/// 2020-10-16 08:03:14  📋 Chain specification: Local Testnet
+/// 2020-10-16 08:03:14  �  Node name: nice-glove-1401
+/// 2020-10-16 08:03:14  👤 Role: LIGHT
+/// 2020-10-16 08:03:14  💾 Database: RocksDb at /tmp/substrate95w2Dk/chains/local_testnet/db
+/// 2020-10-16 08:03:14  ⛓  Native runtime: node-template-1 (node-template-1.tx1.au1)
+/// 2020-10-16 08:03:14  [light] 🔨 Initializing Genesis block/state (state: 0x121d…8e36, header-hash: 0x24ef…8ff6)
+/// 2020-10-16 08:03:14  [light] Loading GRANDPA authorities from genesis on what appears to be first startup.
+/// 2020-10-16 08:03:15  [light] �  Loaded block-time = 6000 milliseconds from genesis on first-launch
+/// 2020-10-16 08:03:15  [light] Using default protocol ID "sup" because none is configured in the chain specs
+/// 2020-10-16 08:03:15  [light] �  Local node identity is: 12D3KooWHX4rkWT6a6N55Km7ZnvenGdShSKPkzJ3yj9DU5nqDtWR
+/// 2020-10-16 08:03:15  [light] 📦 Highest known block at #0
+/// 2020-10-16 08:03:15  [light] 〽� Prometheus server started at 127.0.0.1:9615
+/// 2020-10-16 08:03:15  [light] Listening for new connections on 127.0.0.1:9944.
+/// ```
+///
+/// # Example using the actual node name
+///
+/// ```ignore
+/// Builds a new service for a light client.
+/// #[sc_cli::prefix_logs_with(config.network.node_name.as_str())]
+/// pub fn new_light(config: Configuration) -> Result<TaskManager, ServiceError> {
+///     let (client, backend, keystore, mut task_manager, on_demand) =
+///         sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
+///
+///        ...
+/// }
+/// ```
+///
+/// Will produce logs that look like this:
+///
+/// ```text
+/// 2020-10-16 08:12:57  Substrate Node
+/// 2020-10-16 08:12:57  ✌�  version 2.0.0-efb9b822a-x86_64-linux-gnu
+/// 2020-10-16 08:12:57  ��  by Anonymous, 2017-2020
+/// 2020-10-16 08:12:57  📋 Chain specification: Local Testnet
+/// 2020-10-16 08:12:57  �  Node name: open-harbor-1619
+/// 2020-10-16 08:12:57  👤 Role: LIGHT
+/// 2020-10-16 08:12:57  💾 Database: RocksDb at /tmp/substrate9T9Mtb/chains/local_testnet/db
+/// 2020-10-16 08:12:57  ⛓  Native runtime: node-template-1 (node-template-1.tx1.au1)
+/// 2020-10-16 08:12:58  [open-harbor-1619] 🔨 Initializing Genesis block/state (state: 0x121d…8e36, header-hash: 0x24ef…8ff6)
+/// 2020-10-16 08:12:58  [open-harbor-1619] Loading GRANDPA authorities from genesis on what appears to be first startup.
+/// 2020-10-16 08:12:58  [open-harbor-1619] �  Loaded block-time = 6000 milliseconds from genesis on first-launch
+/// 2020-10-16 08:12:58  [open-harbor-1619] Using default protocol ID "sup" because none is configured in the chain specs
+/// 2020-10-16 08:12:58  [open-harbor-1619] �  Local node identity is: 12D3KooWRzmYC8QTK1Pm8Cfvid3skTS4Hn54jc4AUtje8Rqbfgtp
+/// 2020-10-16 08:12:58  [open-harbor-1619] 📦 Highest known block at #0
+/// 2020-10-16 08:12:58  [open-harbor-1619] 〽� Prometheus server started at 127.0.0.1:9615
+/// 2020-10-16 08:12:58  [open-harbor-1619] Listening for new connections on 127.0.0.1:9944.
+/// ```
+#[proc_macro_attribute]
+pub fn prefix_logs_with(arg: TokenStream, item: TokenStream) -> TokenStream {
+	let item_fn = syn::parse_macro_input!(item as ItemFn);
+
+	if arg.is_empty() {
+		return Error::new(
+			Span::call_site(),
+			"missing argument: name of the node. Example: sc_cli::prefix_logs_with(<expr>)",
+		)
+		.to_compile_error()
+		.into()
+	}
+
+	let name = syn::parse_macro_input!(arg as Expr);
+
+	let crate_name = match crate_name("sc-tracing") {
+		Ok(FoundCrate::Itself) => Ident::new("sc_tracing", Span::call_site()),
+		Ok(FoundCrate::Name(crate_name)) => Ident::new(&crate_name, Span::call_site()),
+		Err(e) => return Error::new(Span::call_site(), e).to_compile_error().into(),
+	};
+
+	let ItemFn { attrs, vis, sig, block } = item_fn;
+
+	(quote! {
+		#(#attrs)*
+		#vis #sig {
+			let span = #crate_name::tracing::info_span!(
+				#crate_name::logging::PREFIX_LOG_SPAN,
+				name = #name,
+			);
+			let _enter = span.enter();
+
+			#block
+		}
+	})
+	.into()
+}
diff --git a/substrate/client/tracing/src/block/mod.rs b/substrate/client/tracing/src/block/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c0442abc125b939851fab146806733302d9f72fc
--- /dev/null
+++ b/substrate/client/tracing/src/block/mod.rs
@@ -0,0 +1,330 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Utilities for tracing block execution
+
+use std::{
+	collections::HashMap,
+	sync::{
+		atomic::{AtomicU64, Ordering},
+		Arc,
+	},
+	time::Instant,
+};
+
+use parking_lot::Mutex;
+use tracing::{
+	dispatcher,
+	span::{Attributes, Id, Record},
+	Dispatch, Level, Subscriber,
+};
+
+use crate::{SpanDatum, TraceEvent, Values};
+use sc_client_api::BlockBackend;
+use sp_api::{Core, Encode, Metadata, ProvideRuntimeApi};
+use sp_blockchain::HeaderBackend;
+use sp_core::hexdisplay::HexDisplay;
+use sp_rpc::tracing::{BlockTrace, Span, TraceBlockResponse};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header},
+};
+use sp_tracing::{WASM_NAME_KEY, WASM_TARGET_KEY, WASM_TRACE_IDENTIFIER};
+
+// Default to only pallet, frame support and state related traces
+const DEFAULT_TARGETS: &str = "pallet,frame,state";
+const TRACE_TARGET: &str = "block_trace";
+// The name of a field required for all events.
+const REQUIRED_EVENT_FIELD: &str = "method";
+
+/// Tracing Block Result type alias
+pub type TraceBlockResult<T> = Result<T, Error>;
+
+/// Tracing Block error
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+#[non_exhaustive]
+pub enum Error {
+	#[error("Invalid block Id: {0}")]
+	InvalidBlockId(#[from] sp_blockchain::Error),
+	#[error("Missing block component: {0}")]
+	MissingBlockComponent(String),
+	#[error("Dispatch error: {0}")]
+	Dispatch(String),
+}
+
+struct BlockSubscriber {
+	targets: Vec<(String, Level)>,
+	next_id: AtomicU64,
+	spans: Mutex<HashMap<Id, SpanDatum>>,
+	events: Mutex<Vec<TraceEvent>>,
+}
+
+impl BlockSubscriber {
+	fn new(targets: &str) -> Self {
+		let next_id = AtomicU64::new(1);
+		let mut targets: Vec<_> = targets.split(',').map(crate::parse_target).collect();
+		// Ensure that WASM traces are always enabled
+		// Filtering happens when decoding the actual target / level
+		targets.push((WASM_TRACE_IDENTIFIER.to_owned(), Level::TRACE));
+		BlockSubscriber {
+			targets,
+			next_id,
+			spans: Mutex::new(HashMap::new()),
+			events: Mutex::new(Vec::new()),
+		}
+	}
+}
+
+impl Subscriber for BlockSubscriber {
+	fn enabled(&self, metadata: &tracing::Metadata<'_>) -> bool {
+		if !metadata.is_span() && metadata.fields().field(REQUIRED_EVENT_FIELD).is_none() {
+			return false
+		}
+		for (target, level) in &self.targets {
+			if metadata.level() <= level && metadata.target().starts_with(target) {
+				return true
+			}
+		}
+		false
+	}
+
+	fn new_span(&self, attrs: &Attributes<'_>) -> Id {
+		let id = Id::from_u64(self.next_id.fetch_add(1, Ordering::Relaxed));
+		let mut values = Values::default();
+		attrs.record(&mut values);
+		let parent_id = attrs.parent().cloned();
+		let span = SpanDatum {
+			id: id.clone(),
+			parent_id,
+			name: attrs.metadata().name().to_owned(),
+			target: attrs.metadata().target().to_owned(),
+			level: *attrs.metadata().level(),
+			line: attrs.metadata().line().unwrap_or(0),
+			start_time: Instant::now(),
+			values,
+			overall_time: Default::default(),
+		};
+
+		self.spans.lock().insert(id.clone(), span);
+		id
+	}
+
+	fn record(&self, span: &Id, values: &Record<'_>) {
+		let mut span_data = self.spans.lock();
+		if let Some(s) = span_data.get_mut(span) {
+			values.record(&mut s.values);
+		}
+	}
+
+	fn record_follows_from(&self, _span: &Id, _follows: &Id) {
+		// Not currently used
+		unimplemented!("record_follows_from is not implemented");
+	}
+
+	fn event(&self, event: &tracing::Event<'_>) {
+		let mut values = crate::Values::default();
+		event.record(&mut values);
+		let parent_id = event.parent().cloned();
+		let trace_event = TraceEvent {
+			name: event.metadata().name().to_owned(),
+			target: event.metadata().target().to_owned(),
+			level: *event.metadata().level(),
+			values,
+			parent_id,
+		};
+		self.events.lock().push(trace_event);
+	}
+
+	fn enter(&self, _id: &Id) {}
+
+	fn exit(&self, _span: &Id) {}
+}
+
+/// Holds a reference to the client in order to execute the given block.
+/// Records spans & events for the supplied targets (eg. "pallet,frame,state") and
+/// only records events with the specified hex encoded storage key prefixes.
+/// Note: if `targets` or `storage_keys` is an empty string then nothing is
+/// filtered out.
+pub struct BlockExecutor<Block: BlockT, Client> {
+	client: Arc<Client>,
+	block: Block::Hash,
+	targets: Option<String>,
+	storage_keys: Option<String>,
+	methods: Option<String>,
+}
+
+impl<Block, Client> BlockExecutor<Block, Client>
+where
+	Block: BlockT + 'static,
+	Client: HeaderBackend<Block>
+		+ BlockBackend<Block>
+		+ ProvideRuntimeApi<Block>
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: Metadata<Block>,
+{
+	/// Create a new `BlockExecutor`
+	pub fn new(
+		client: Arc<Client>,
+		block: Block::Hash,
+		targets: Option<String>,
+		storage_keys: Option<String>,
+		methods: Option<String>,
+	) -> Self {
+		Self { client, block, targets, storage_keys, methods }
+	}
+
+	/// Execute block, record all spans and events belonging to `Self::targets`
+	/// and filter out events which do not have keys starting with one of the
+	/// prefixes in `Self::storage_keys`.
+	pub fn trace_block(&self) -> TraceBlockResult<TraceBlockResponse> {
+		tracing::debug!(target: "state_tracing", "Tracing block: {}", self.block);
+		// Prepare the block
+		let mut header = self
+			.client
+			.header(self.block)
+			.map_err(Error::InvalidBlockId)?
+			.ok_or_else(|| Error::MissingBlockComponent("Header not found".to_string()))?;
+		let extrinsics = self
+			.client
+			.block_body(self.block)
+			.map_err(Error::InvalidBlockId)?
+			.ok_or_else(|| Error::MissingBlockComponent("Extrinsics not found".to_string()))?;
+		tracing::debug!(target: "state_tracing", "Found {} extrinsics", extrinsics.len());
+		let parent_hash = *header.parent_hash();
+		// Remove all `Seal`s as they are added by the consensus engines after building the block.
+		// On import they are normally removed by the consensus engine.
+		header.digest_mut().logs.retain(|d| d.as_seal().is_none());
+		let block = Block::new(header, extrinsics);
+
+		let targets = if let Some(t) = &self.targets { t } else { DEFAULT_TARGETS };
+		let block_subscriber = BlockSubscriber::new(targets);
+		let dispatch = Dispatch::new(block_subscriber);
+
+		{
+			let dispatcher_span = tracing::debug_span!(
+				target: "state_tracing",
+				"execute_block",
+				extrinsics_len = block.extrinsics().len(),
+			);
+			let _guard = dispatcher_span.enter();
+			if let Err(e) = dispatcher::with_default(&dispatch, || {
+				let span = tracing::info_span!(target: TRACE_TARGET, "trace_block");
+				let _enter = span.enter();
+				self.client.runtime_api().execute_block(parent_hash, block)
+			}) {
+				return Err(Error::Dispatch(format!(
+					"Failed to collect traces and execute block: {}",
+					e
+				)))
+			}
+		}
+
+		let block_subscriber = dispatch.downcast_ref::<BlockSubscriber>().ok_or_else(|| {
+			Error::Dispatch(
+				"Cannot downcast Dispatch to BlockSubscriber after tracing block".to_string(),
+			)
+		})?;
+		let spans: Vec<_> = block_subscriber
+			.spans
+			.lock()
+			.drain()
+			// Patch wasm identifiers
+			.filter_map(|(_, s)| patch_and_filter(s, targets))
+			.collect();
+		let events: Vec<_> = block_subscriber
+			.events
+			.lock()
+			.drain(..)
+			.filter(|e| {
+				self.storage_keys
+					.as_ref()
+					.map(|keys| event_values_filter(e, "key", keys))
+					.unwrap_or(false)
+			})
+			.filter(|e| {
+				self.methods
+					.as_ref()
+					.map(|methods| event_values_filter(e, "method", methods))
+					.unwrap_or(false)
+			})
+			.map(|s| s.into())
+			.collect();
+		tracing::debug!(target: "state_tracing", "Captured {} spans and {} events", spans.len(), events.len());
+
+		Ok(TraceBlockResponse::BlockTrace(BlockTrace {
+			block_hash: block_id_as_string(BlockId::<Block>::Hash(self.block)),
+			parent_hash: block_id_as_string(BlockId::<Block>::Hash(parent_hash)),
+			tracing_targets: targets.to_string(),
+			storage_keys: self.storage_keys.clone().unwrap_or_default(),
+			methods: self.methods.clone().unwrap_or_default(),
+			spans,
+			events,
+		}))
+	}
+}
+
+fn event_values_filter(event: &TraceEvent, filter_kind: &str, values: &str) -> bool {
+	event
+		.values
+		.string_values
+		.get(filter_kind)
+		.map(|value| check_target(values, value, &event.level))
+		.unwrap_or(false)
+}
+
+/// Filter out spans that do not match our targets and if the span is from WASM update its `name`
+/// and `target` fields to the WASM values for those fields.
+// The `tracing` crate requires trace metadata to be static. This does not work for wasm code in
+// substrate, as it is regularly updated with new code from on-chain events. The workaround for this
+// is for substrate's WASM tracing wrappers to put the `name` and `target` data in the `values` map
+// (normally they would be in the static metadata assembled at compile time). Here, if a special
+// WASM `name` or `target` key is found in the `values` we remove it and put the key value pair in
+// the span's metadata, making it consistent with spans that come from native code.
+fn patch_and_filter(mut span: SpanDatum, targets: &str) -> Option<Span> {
+	if span.name == WASM_TRACE_IDENTIFIER {
+		span.values.bool_values.insert("wasm".to_owned(), true);
+		if let Some(n) = span.values.string_values.remove(WASM_NAME_KEY) {
+			span.name = n;
+		}
+		if let Some(t) = span.values.string_values.remove(WASM_TARGET_KEY) {
+			span.target = t;
+		}
+		if !check_target(targets, &span.target, &span.level) {
+			return None
+		}
+	}
+	Some(span.into())
+}
+
+/// Check if a `target` matches any `targets` by prefix
+fn check_target(targets: &str, target: &str, level: &Level) -> bool {
+	for (t, l) in targets.split(',').map(crate::parse_target) {
+		if target.starts_with(t.as_str()) && level <= &l {
+			return true
+		}
+	}
+	false
+}
+
+fn block_id_as_string<T: BlockT>(block_id: BlockId<T>) -> String {
+	match block_id {
+		BlockId::Hash(h) => HexDisplay::from(&h.encode()).to_string(),
+		BlockId::Number(n) => HexDisplay::from(&n.encode()).to_string(),
+	}
+}
diff --git a/substrate/client/tracing/src/lib.rs b/substrate/client/tracing/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2107943cf6a5a9029e20ff2b9690155775bdbf83
--- /dev/null
+++ b/substrate/client/tracing/src/lib.rs
@@ -0,0 +1,675 @@
+// 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/>.
+
+//! Instrumentation implementation for substrate.
+//!
+//! This crate is unstable and the API and usage may change.
+//!
+//! # Usage
+//!
+//! See `sp-tracing` for examples on how to use tracing.
+//!
+//! Currently we only provide `Log` (default).
+
+#![warn(missing_docs)]
+
+pub mod block;
+pub mod logging;
+
+use rustc_hash::FxHashMap;
+use serde::ser::{Serialize, SerializeMap, Serializer};
+use sp_tracing::{WASM_NAME_KEY, WASM_TARGET_KEY, WASM_TRACE_IDENTIFIER};
+use std::{
+	fmt,
+	time::{Duration, Instant},
+};
+use tracing::{
+	event::Event,
+	field::{Field, Visit},
+	span::{Attributes, Id, Record},
+	subscriber::Subscriber,
+	Level,
+};
+use tracing_subscriber::{
+	layer::{Context, Layer},
+	registry::LookupSpan,
+};
+
+#[doc(hidden)]
+pub use tracing;
+
+const ZERO_DURATION: Duration = Duration::from_nanos(0);
+
+/// Responsible for assigning ids to new spans, which are not re-used.
+pub struct ProfilingLayer {
+	targets: Vec<(String, Level)>,
+	trace_handlers: Vec<Box<dyn TraceHandler>>,
+}
+
+/// Used to configure how to receive the metrics
+#[derive(Debug, Clone)]
+pub enum TracingReceiver {
+	/// Output to logger
+	Log,
+}
+
+impl Default for TracingReceiver {
+	fn default() -> Self {
+		Self::Log
+	}
+}
+
+/// A handler for tracing `SpanDatum`
+pub trait TraceHandler: Send + Sync {
+	/// Process a `SpanDatum`.
+	fn handle_span(&self, span: &SpanDatum);
+	/// Process a `TraceEvent`.
+	fn handle_event(&self, event: &TraceEvent);
+}
+
+/// Represents a tracing event, complete with values
+#[derive(Debug, Clone)]
+pub struct TraceEvent {
+	/// Name of the event.
+	pub name: String,
+	/// Target of the event.
+	pub target: String,
+	/// Level of the event.
+	pub level: Level,
+	/// Values for this event.
+	pub values: Values,
+	/// Id of the parent tracing event, if any.
+	pub parent_id: Option<Id>,
+}
+
+/// Represents a single instance of a tracing span
+#[derive(Debug, Clone)]
+pub struct SpanDatum {
+	/// id for this span
+	pub id: Id,
+	/// id of the parent span, if any
+	pub parent_id: Option<Id>,
+	/// Name of this span
+	pub name: String,
+	/// Target, typically module
+	pub target: String,
+	/// Tracing Level - ERROR, WARN, INFO, DEBUG or TRACE
+	pub level: Level,
+	/// Line number in source
+	pub line: u32,
+	/// Time that the span was last entered
+	pub start_time: Instant,
+	/// Total duration of span while entered
+	pub overall_time: Duration,
+	/// Values recorded to this span
+	pub values: Values,
+}
+
+/// Holds associated values for a tracing span
+#[derive(Default, Clone, Debug)]
+pub struct Values {
+	/// FxHashMap of `bool` values
+	pub bool_values: FxHashMap<String, bool>,
+	/// FxHashMap of `i64` values
+	pub i64_values: FxHashMap<String, i64>,
+	/// FxHashMap of `u64` values
+	pub u64_values: FxHashMap<String, u64>,
+	/// FxHashMap of `String` values
+	pub string_values: FxHashMap<String, String>,
+}
+
+impl Values {
+	/// Returns a new instance of Values
+	pub fn new() -> Self {
+		Default::default()
+	}
+
+	/// Checks if all individual collections are empty
+	pub fn is_empty(&self) -> bool {
+		self.bool_values.is_empty() &&
+			self.i64_values.is_empty() &&
+			self.u64_values.is_empty() &&
+			self.string_values.is_empty()
+	}
+}
+
+impl Visit for Values {
+	fn record_i64(&mut self, field: &Field, value: i64) {
+		self.i64_values.insert(field.name().to_string(), value);
+	}
+
+	fn record_u64(&mut self, field: &Field, value: u64) {
+		self.u64_values.insert(field.name().to_string(), value);
+	}
+
+	fn record_bool(&mut self, field: &Field, value: bool) {
+		self.bool_values.insert(field.name().to_string(), value);
+	}
+
+	fn record_str(&mut self, field: &Field, value: &str) {
+		self.string_values.insert(field.name().to_string(), value.to_owned());
+	}
+
+	fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
+		self.string_values.insert(field.name().to_string(), format!("{:?}", value));
+	}
+}
+
+impl Serialize for Values {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let len = self.bool_values.len() +
+			self.i64_values.len() +
+			self.u64_values.len() +
+			self.string_values.len();
+		let mut map = serializer.serialize_map(Some(len))?;
+		for (k, v) in &self.bool_values {
+			map.serialize_entry(k, v)?;
+		}
+		for (k, v) in &self.i64_values {
+			map.serialize_entry(k, v)?;
+		}
+		for (k, v) in &self.u64_values {
+			map.serialize_entry(k, v)?;
+		}
+		for (k, v) in &self.string_values {
+			map.serialize_entry(k, v)?;
+		}
+		map.end()
+	}
+}
+
+impl fmt::Display for Values {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		let bool_iter = self.bool_values.iter().map(|(k, v)| format!("{}={}", k, v));
+		let i64_iter = self.i64_values.iter().map(|(k, v)| format!("{}={}", k, v));
+		let u64_iter = self.u64_values.iter().map(|(k, v)| format!("{}={}", k, v));
+		let string_iter = self.string_values.iter().map(|(k, v)| format!("{}=\"{}\"", k, v));
+		let values = bool_iter
+			.chain(i64_iter)
+			.chain(u64_iter)
+			.chain(string_iter)
+			.collect::<Vec<String>>()
+			.join(", ");
+		write!(f, "{}", values)
+	}
+}
+
+/// Trace handler event types.
+#[derive(Debug)]
+pub enum TraceHandlerEvents {
+	/// An event.
+	Event(TraceEvent),
+	/// A span.
+	Span(SpanDatum),
+}
+
+impl ProfilingLayer {
+	/// Takes a `TracingReceiver` and a comma separated list of targets,
+	/// either with a level: "pallet=trace,frame=debug"
+	/// or without: "pallet,frame" in which case the level defaults to `trace`.
+	/// wasm_tracing indicates whether to enable wasm traces
+	pub fn new(receiver: TracingReceiver, targets: &str) -> Self {
+		match receiver {
+			TracingReceiver::Log => Self::new_with_handler(Box::new(LogTraceHandler), targets),
+		}
+	}
+
+	/// Allows use of a custom TraceHandler to create a new instance of ProfilingSubscriber.
+	/// Takes a comma separated list of targets,
+	/// either with a level, eg: "pallet=trace"
+	/// or without: "pallet" in which case the level defaults to `trace`.
+	/// wasm_tracing indicates whether to enable wasm traces
+	pub fn new_with_handler(trace_handler: Box<dyn TraceHandler>, targets: &str) -> Self {
+		let targets: Vec<_> = targets.split(',').map(parse_target).collect();
+		Self { targets, trace_handlers: vec![trace_handler] }
+	}
+
+	/// Attach additional handlers to allow handling of custom events/spans.
+	pub fn add_handler(&mut self, trace_handler: Box<dyn TraceHandler>) {
+		self.trace_handlers.push(trace_handler);
+	}
+
+	fn check_target(&self, target: &str, level: &Level) -> bool {
+		for t in &self.targets {
+			if target.starts_with(t.0.as_str()) && level <= &t.1 {
+				return true
+			}
+		}
+		false
+	}
+
+	/// Sequentially dispatch a trace event to all handlers.
+	fn dispatch_event(&self, event: TraceHandlerEvents) {
+		match &event {
+			TraceHandlerEvents::Span(span_datum) => {
+				self.trace_handlers.iter().for_each(|handler| handler.handle_span(span_datum));
+			},
+			TraceHandlerEvents::Event(event) => {
+				self.trace_handlers.iter().for_each(|handler| handler.handle_event(event));
+			},
+		}
+	}
+}
+
+// Default to TRACE if no level given or unable to parse Level
+// We do not support a global `Level` currently
+fn parse_target(s: &str) -> (String, Level) {
+	match s.find('=') {
+		Some(i) => {
+			let target = s[0..i].to_string();
+			if s.len() > i {
+				let level = s[i + 1..].parse::<Level>().unwrap_or(Level::TRACE);
+				(target, level)
+			} else {
+				(target, Level::TRACE)
+			}
+		},
+		None => (s.to_string(), Level::TRACE),
+	}
+}
+
+impl<S> Layer<S> for ProfilingLayer
+where
+	S: Subscriber + for<'span> LookupSpan<'span>,
+{
+	fn new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<S>) {
+		if let Some(span) = ctx.span(id) {
+			let mut extension = span.extensions_mut();
+			let parent_id = attrs.parent().cloned().or_else(|| {
+				if attrs.is_contextual() {
+					ctx.lookup_current().map(|span| span.id())
+				} else {
+					None
+				}
+			});
+
+			let mut values = Values::default();
+			attrs.record(&mut values);
+			let span_datum = SpanDatum {
+				id: id.clone(),
+				parent_id,
+				name: attrs.metadata().name().to_owned(),
+				target: attrs.metadata().target().to_owned(),
+				level: *attrs.metadata().level(),
+				line: attrs.metadata().line().unwrap_or(0),
+				start_time: Instant::now(),
+				overall_time: ZERO_DURATION,
+				values,
+			};
+			extension.insert(span_datum);
+		}
+	}
+
+	fn on_record(&self, id: &Id, values: &Record<'_>, ctx: Context<S>) {
+		if let Some(span) = ctx.span(id) {
+			let mut extensions = span.extensions_mut();
+			if let Some(s) = extensions.get_mut::<SpanDatum>() {
+				values.record(&mut s.values);
+			}
+		}
+	}
+
+	fn on_event(&self, event: &Event<'_>, ctx: Context<S>) {
+		if !self.check_target(event.metadata().target(), &event.metadata().level()) {
+			return
+		}
+
+		let parent_id = event.parent().cloned().or_else(|| {
+			if event.is_contextual() {
+				ctx.lookup_current().map(|span| span.id())
+			} else {
+				None
+			}
+		});
+
+		let mut values = Values::default();
+		event.record(&mut values);
+		let trace_event = TraceEvent {
+			name: event.metadata().name().to_owned(),
+			target: event.metadata().target().to_owned(),
+			level: *event.metadata().level(),
+			values,
+			parent_id,
+		};
+		self.dispatch_event(TraceHandlerEvents::Event(trace_event));
+	}
+
+	fn on_enter(&self, span: &Id, ctx: Context<S>) {
+		if let Some(span) = ctx.span(span) {
+			let mut extensions = span.extensions_mut();
+			if let Some(s) = extensions.get_mut::<SpanDatum>() {
+				let start_time = Instant::now();
+				s.start_time = start_time;
+			}
+		}
+	}
+
+	fn on_exit(&self, span: &Id, ctx: Context<S>) {
+		if let Some(span) = ctx.span(span) {
+			let end_time = Instant::now();
+			let mut extensions = span.extensions_mut();
+			if let Some(mut span_datum) = extensions.remove::<SpanDatum>() {
+				span_datum.overall_time += end_time - span_datum.start_time;
+				if span_datum.name == WASM_TRACE_IDENTIFIER {
+					span_datum.values.bool_values.insert("wasm".to_owned(), true);
+					if let Some(n) = span_datum.values.string_values.remove(WASM_NAME_KEY) {
+						span_datum.name = n;
+					}
+					if let Some(t) = span_datum.values.string_values.remove(WASM_TARGET_KEY) {
+						span_datum.target = t;
+					}
+					if self.check_target(&span_datum.target, &span_datum.level) {
+						self.dispatch_event(TraceHandlerEvents::Span(span_datum));
+					}
+				} else {
+					self.dispatch_event(TraceHandlerEvents::Span(span_datum));
+				}
+			}
+		}
+	}
+
+	fn on_close(&self, _span: Id, _ctx: Context<S>) {}
+}
+
+/// TraceHandler for sending span data to the logger
+pub struct LogTraceHandler;
+
+fn log_level(level: Level) -> log::Level {
+	match level {
+		Level::TRACE => log::Level::Trace,
+		Level::DEBUG => log::Level::Debug,
+		Level::INFO => log::Level::Info,
+		Level::WARN => log::Level::Warn,
+		Level::ERROR => log::Level::Error,
+	}
+}
+
+impl TraceHandler for LogTraceHandler {
+	fn handle_span(&self, span_datum: &SpanDatum) {
+		if span_datum.values.is_empty() {
+			log::log!(
+				log_level(span_datum.level),
+				"{}: {}, time: {}, id: {}, parent_id: {:?}",
+				span_datum.target,
+				span_datum.name,
+				span_datum.overall_time.as_nanos(),
+				span_datum.id.into_u64(),
+				span_datum.parent_id.as_ref().map(|s| s.into_u64()),
+			);
+		} else {
+			log::log!(
+				log_level(span_datum.level),
+				"{}: {}, time: {}, id: {}, parent_id: {:?}, values: {}",
+				span_datum.target,
+				span_datum.name,
+				span_datum.overall_time.as_nanos(),
+				span_datum.id.into_u64(),
+				span_datum.parent_id.as_ref().map(|s| s.into_u64()),
+				span_datum.values,
+			);
+		}
+	}
+
+	fn handle_event(&self, event: &TraceEvent) {
+		log::log!(
+			log_level(event.level),
+			"{}, parent_id: {:?}, {}",
+			event.target,
+			event.parent_id.as_ref().map(|s| s.into_u64()),
+			event.values,
+		);
+	}
+}
+
+impl From<TraceEvent> for sp_rpc::tracing::Event {
+	fn from(trace_event: TraceEvent) -> Self {
+		let data = sp_rpc::tracing::Data { string_values: trace_event.values.string_values };
+		sp_rpc::tracing::Event {
+			target: trace_event.target,
+			data,
+			parent_id: trace_event.parent_id.map(|id| id.into_u64()),
+		}
+	}
+}
+
+impl From<SpanDatum> for sp_rpc::tracing::Span {
+	fn from(span_datum: SpanDatum) -> Self {
+		let wasm = span_datum.values.bool_values.get("wasm").is_some();
+		sp_rpc::tracing::Span {
+			id: span_datum.id.into_u64(),
+			parent_id: span_datum.parent_id.map(|id| id.into_u64()),
+			name: span_datum.name,
+			target: span_datum.target,
+			wasm,
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use parking_lot::Mutex;
+	use std::sync::{
+		mpsc::{Receiver, Sender},
+		Arc,
+	};
+	use tracing_subscriber::layer::SubscriberExt;
+
+	struct TestTraceHandler {
+		spans: Arc<Mutex<Vec<SpanDatum>>>,
+		events: Arc<Mutex<Vec<TraceEvent>>>,
+	}
+
+	impl TraceHandler for TestTraceHandler {
+		fn handle_span(&self, sd: &SpanDatum) {
+			self.spans.lock().push(sd.clone());
+		}
+
+		fn handle_event(&self, event: &TraceEvent) {
+			self.events.lock().push(event.clone());
+		}
+	}
+
+	fn setup_subscriber() -> (
+		impl tracing::Subscriber + Send + Sync,
+		Arc<Mutex<Vec<SpanDatum>>>,
+		Arc<Mutex<Vec<TraceEvent>>>,
+	) {
+		let spans = Arc::new(Mutex::new(Vec::new()));
+		let events = Arc::new(Mutex::new(Vec::new()));
+		let handler = TestTraceHandler { spans: spans.clone(), events: events.clone() };
+		let layer = ProfilingLayer::new_with_handler(Box::new(handler), "test_target");
+		let subscriber = tracing_subscriber::fmt().with_writer(std::io::sink).finish().with(layer);
+		(subscriber, spans, events)
+	}
+
+	#[test]
+	fn test_span() {
+		let (sub, spans, events) = setup_subscriber();
+		let _sub_guard = tracing::subscriber::set_default(sub);
+		let span = tracing::info_span!(target: "test_target", "test_span1");
+		assert_eq!(spans.lock().len(), 0);
+		assert_eq!(events.lock().len(), 0);
+		let _guard = span.enter();
+		assert_eq!(spans.lock().len(), 0);
+		assert_eq!(events.lock().len(), 0);
+		drop(_guard);
+		drop(span);
+		assert_eq!(spans.lock().len(), 1);
+		assert_eq!(events.lock().len(), 0);
+		let sd = spans.lock().remove(0);
+		assert_eq!(sd.name, "test_span1");
+		assert_eq!(sd.target, "test_target");
+		let time: u128 = sd.overall_time.as_nanos();
+		assert!(time > 0);
+	}
+
+	#[test]
+	fn test_span_parent_id() {
+		let (sub, spans, _events) = setup_subscriber();
+		let _sub_guard = tracing::subscriber::set_default(sub);
+		let span1 = tracing::info_span!(target: "test_target", "test_span1");
+		let _guard1 = span1.enter();
+		let span2 = tracing::info_span!(target: "test_target", "test_span2");
+		let _guard2 = span2.enter();
+		drop(_guard2);
+		drop(span2);
+		let sd2 = spans.lock().remove(0);
+		drop(_guard1);
+		drop(span1);
+		let sd1 = spans.lock().remove(0);
+		assert_eq!(sd1.id, sd2.parent_id.unwrap())
+	}
+
+	#[test]
+	fn test_span_values() {
+		let (sub, spans, _events) = setup_subscriber();
+		let _sub_guard = tracing::subscriber::set_default(sub);
+		let test_bool = true;
+		let test_u64 = 1u64;
+		let test_i64 = 2i64;
+		let test_str = "test_str";
+		let span = tracing::info_span!(
+			target: "test_target",
+			"test_span1",
+			test_bool,
+			test_u64,
+			test_i64,
+			test_str
+		);
+		let _guard = span.enter();
+		drop(_guard);
+		drop(span);
+		let sd = spans.lock().remove(0);
+		assert_eq!(sd.name, "test_span1");
+		assert_eq!(sd.target, "test_target");
+		let values = sd.values;
+		assert_eq!(values.bool_values.get("test_bool").unwrap(), &test_bool);
+		assert_eq!(values.u64_values.get("test_u64").unwrap(), &test_u64);
+		assert_eq!(values.i64_values.get("test_i64").unwrap(), &test_i64);
+		assert_eq!(values.string_values.get("test_str").unwrap(), &test_str.to_owned());
+	}
+
+	#[test]
+	fn test_event() {
+		let (sub, _spans, events) = setup_subscriber();
+		let _sub_guard = tracing::subscriber::set_default(sub);
+		tracing::event!(target: "test_target", tracing::Level::INFO, "test_event");
+		let mut te1 = events.lock().remove(0);
+		assert_eq!(
+			te1.values.string_values.remove(&"message".to_owned()).unwrap(),
+			"test_event".to_owned()
+		);
+	}
+
+	#[test]
+	fn test_event_parent_id() {
+		let (sub, spans, events) = setup_subscriber();
+		let _sub_guard = tracing::subscriber::set_default(sub);
+
+		// enter span
+		let span1 = tracing::info_span!(target: "test_target", "test_span1");
+		let _guard1 = span1.enter();
+
+		// emit event
+		tracing::event!(target: "test_target", tracing::Level::INFO, "test_event");
+
+		// exit span
+		drop(_guard1);
+		drop(span1);
+
+		let sd1 = spans.lock().remove(0);
+		let te1 = events.lock().remove(0);
+
+		assert_eq!(sd1.id, te1.parent_id.unwrap());
+	}
+
+	#[test]
+	fn test_parent_id_with_threads() {
+		use std::{sync::mpsc, thread};
+
+		if std::env::var("RUN_TEST_PARENT_ID_WITH_THREADS").is_err() {
+			let executable = std::env::current_exe().unwrap();
+			let mut command = std::process::Command::new(executable);
+
+			let res = command
+				.env("RUN_TEST_PARENT_ID_WITH_THREADS", "1")
+				.args(&["--nocapture", "test_parent_id_with_threads"])
+				.output()
+				.unwrap()
+				.status;
+			assert!(res.success());
+		} else {
+			let (sub, spans, events) = setup_subscriber();
+			let _sub_guard = tracing::subscriber::set_global_default(sub);
+			let span1 = tracing::info_span!(target: "test_target", "test_span1");
+			let _guard1 = span1.enter();
+
+			let (tx, rx): (Sender<bool>, Receiver<bool>) = mpsc::channel();
+			let handle = thread::spawn(move || {
+				let span2 = tracing::info_span!(target: "test_target", "test_span2");
+				let _guard2 = span2.enter();
+				// emit event
+				tracing::event!(target: "test_target", tracing::Level::INFO, "test_event1");
+				let _ = rx.recv();
+				// guard2 and span2 dropped / exited
+			});
+
+			// wait for Event to be dispatched and stored
+			while events.lock().is_empty() {
+				thread::sleep(Duration::from_millis(1));
+			}
+
+			// emit new event (will be second item in Vec) while span2 still active in other thread
+			tracing::event!(target: "test_target", tracing::Level::INFO, "test_event2");
+
+			// stop thread and drop span
+			let _ = tx.send(false);
+			let _ = handle.join();
+
+			// wait for Span to be dispatched and stored
+			while spans.lock().is_empty() {
+				thread::sleep(Duration::from_millis(1));
+			}
+			let span2 = spans.lock().remove(0);
+			let event1 = events.lock().remove(0);
+			drop(_guard1);
+			drop(span1);
+
+			// emit event with no parent
+			tracing::event!(target: "test_target", tracing::Level::INFO, "test_event3");
+
+			let span1 = spans.lock().remove(0);
+			let event2 = events.lock().remove(0);
+
+			assert_eq!(event1.values.string_values.get("message").unwrap(), "test_event1");
+			assert_eq!(event2.values.string_values.get("message").unwrap(), "test_event2");
+			assert!(span1.parent_id.is_none());
+			assert!(span2.parent_id.is_none());
+			assert_eq!(span2.id, event1.parent_id.unwrap());
+			assert_eq!(span1.id, event2.parent_id.unwrap());
+			assert_ne!(span2.id, span1.id);
+
+			let event3 = events.lock().remove(0);
+			assert!(event3.parent_id.is_none());
+		}
+	}
+}
diff --git a/substrate/client/tracing/src/logging/directives.rs b/substrate/client/tracing/src/logging/directives.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f1caf1a13a2def082ccba51d5a37aa162034f782
--- /dev/null
+++ b/substrate/client/tracing/src/logging/directives.rs
@@ -0,0 +1,113 @@
+// Copyright Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate 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.
+
+// Substrate 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 Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+use parking_lot::Mutex;
+use std::sync::OnceLock;
+use tracing_subscriber::{
+	filter::Directive, fmt as tracing_fmt, layer, reload::Handle, EnvFilter, Registry,
+};
+
+// Handle to reload the tracing log filter
+static FILTER_RELOAD_HANDLE: OnceLock<Handle<EnvFilter, SCSubscriber>> = OnceLock::new();
+// Directives that are defaulted to when resetting the log filter
+static DEFAULT_DIRECTIVES: OnceLock<Mutex<Vec<String>>> = OnceLock::new();
+// Current state of log filter
+static CURRENT_DIRECTIVES: OnceLock<Mutex<Vec<String>>> = OnceLock::new();
+
+/// Add log filter directive(s) to the defaults
+///
+/// The syntax is identical to the CLI `<target>=<level>`:
+///
+/// `sync=debug,state=trace`
+pub(crate) fn add_default_directives(directives: &str) {
+	DEFAULT_DIRECTIVES
+		.get_or_init(|| Mutex::new(Vec::new()))
+		.lock()
+		.push(directives.to_owned());
+	add_directives(directives);
+}
+
+/// Add directives to current directives
+pub fn add_directives(directives: &str) {
+	CURRENT_DIRECTIVES
+		.get_or_init(|| Mutex::new(Vec::new()))
+		.lock()
+		.push(directives.to_owned());
+}
+
+/// Parse `Directive` and add to default directives if successful.
+///
+/// Ensures the supplied directive will be restored when resetting the log filter.
+pub(crate) fn parse_default_directive(directive: &str) -> super::Result<Directive> {
+	let dir = directive.parse()?;
+	add_default_directives(directive);
+	Ok(dir)
+}
+
+/// Reload the logging filter with the supplied directives added to the existing directives
+pub fn reload_filter() -> Result<(), String> {
+	let mut env_filter = EnvFilter::default();
+	if let Some(current_directives) = CURRENT_DIRECTIVES.get() {
+		// Use join and then split in case any directives added together
+		for directive in current_directives.lock().join(",").split(',').map(|d| d.parse()) {
+			match directive {
+				Ok(dir) => env_filter = env_filter.add_directive(dir),
+				Err(invalid_directive) => {
+					log::warn!(
+						target: "tracing",
+						"Unable to parse directive while setting log filter: {:?}",
+						invalid_directive,
+					);
+				},
+			}
+		}
+	}
+
+	// Set the max logging level for the `log` macros.
+	let max_level_hint =
+		tracing_subscriber::Layer::<tracing_subscriber::FmtSubscriber>::max_level_hint(&env_filter);
+	log::set_max_level(super::to_log_level_filter(max_level_hint));
+
+	log::debug!(target: "tracing", "Reloading log filter with: {}", env_filter);
+	FILTER_RELOAD_HANDLE
+		.get()
+		.ok_or("No reload handle present")?
+		.reload(env_filter)
+		.map_err(|e| format!("{}", e))
+}
+
+/// Resets the log filter back to the original state when the node was started.
+///
+/// Includes substrate defaults and CLI supplied directives.
+pub fn reset_log_filter() -> Result<(), String> {
+	let directive = DEFAULT_DIRECTIVES.get_or_init(|| Mutex::new(Vec::new())).lock().clone();
+
+	*CURRENT_DIRECTIVES.get_or_init(|| Mutex::new(Vec::new())).lock() = directive;
+	reload_filter()
+}
+
+/// Initialize FILTER_RELOAD_HANDLE, only possible once
+pub(crate) fn set_reload_handle(handle: Handle<EnvFilter, SCSubscriber>) {
+	let _ = FILTER_RELOAD_HANDLE.set(handle);
+}
+
+// The layered Subscriber as built up in `LoggerBuilder::init()`.
+// Used in the reload `Handle`.
+type SCSubscriber<
+	N = tracing_fmt::format::DefaultFields,
+	E = crate::logging::EventFormat,
+	W = crate::logging::DefaultLogger,
+> = layer::Layered<tracing_fmt::Layer<Registry, N, E, W>, Registry>;
diff --git a/substrate/client/tracing/src/logging/event_format.rs b/substrate/client/tracing/src/logging/event_format.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f4579f006c25d5510f8489a6dd337e08ee7eafa0
--- /dev/null
+++ b/substrate/client/tracing/src/logging/event_format.rs
@@ -0,0 +1,361 @@
+// 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::logging::fast_local_time::FastLocalTime;
+use ansi_term::Colour;
+use regex::Regex;
+use std::fmt::{self, Write};
+use tracing::{Event, Level, Subscriber};
+use tracing_log::NormalizeEvent;
+use tracing_subscriber::{
+	field::RecordFields,
+	fmt::{time::FormatTime, FmtContext, FormatEvent, FormatFields},
+	layer::Context,
+	registry::{LookupSpan, SpanRef},
+};
+
+/// A pre-configured event formatter.
+pub struct EventFormat<T = FastLocalTime> {
+	/// Use the given timer for log message timestamps.
+	pub timer: T,
+	/// Sets whether or not an event's target is displayed.
+	pub display_target: bool,
+	/// Sets whether or not an event's level is displayed.
+	pub display_level: bool,
+	/// Sets whether or not the name of the current thread is displayed when formatting events.
+	pub display_thread_name: bool,
+	/// Enable ANSI terminal colors for formatted output.
+	pub enable_color: bool,
+	/// Duplicate INFO, WARN and ERROR messages to stdout.
+	pub dup_to_stdout: bool,
+}
+
+impl<T> EventFormat<T>
+where
+	T: FormatTime,
+{
+	// NOTE: the following code took inspiration from tracing-subscriber
+	//
+	//       https://github.com/tokio-rs/tracing/blob/2f59b32/tracing-subscriber/src/fmt/format/mod.rs#L449
+	pub(crate) fn format_event_custom<'b, S, N>(
+		&self,
+		ctx: CustomFmtContext<'b, S, N>,
+		writer: &mut dyn fmt::Write,
+		event: &Event,
+	) -> fmt::Result
+	where
+		S: Subscriber + for<'a> LookupSpan<'a>,
+		N: for<'a> FormatFields<'a> + 'static,
+	{
+		let writer = &mut ControlCodeSanitizer::new(!self.enable_color, writer);
+		let normalized_meta = event.normalized_metadata();
+		let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
+		time::write(&self.timer, writer, self.enable_color)?;
+
+		if self.display_level {
+			let fmt_level = { FmtLevel::new(meta.level(), self.enable_color) };
+			write!(writer, "{} ", fmt_level)?;
+		}
+
+		if self.display_thread_name {
+			let current_thread = std::thread::current();
+			match current_thread.name() {
+				Some(name) => {
+					write!(writer, "{} ", FmtThreadName::new(name))?;
+				},
+				// fall-back to thread id when name is absent and ids are not enabled
+				None => {
+					write!(writer, "{:0>2?} ", current_thread.id())?;
+				},
+			}
+		}
+
+		if self.display_target {
+			write!(writer, "{}: ", meta.target())?;
+		}
+
+		// Custom code to display node name
+		if let Some(span) = ctx.lookup_current() {
+			for span in span.scope() {
+				let exts = span.extensions();
+				if let Some(prefix) = exts.get::<super::layers::Prefix>() {
+					write!(writer, "{}", prefix.as_str())?;
+					break
+				}
+			}
+		}
+
+		// The writer only sanitizes its output once it's flushed, so if we don't actually need
+		// to sanitize everything we need to flush out what was already buffered as-is and only
+		// force-sanitize what follows.
+		if !writer.sanitize {
+			writer.flush()?;
+			writer.sanitize = true;
+		}
+
+		ctx.format_fields(writer, event)?;
+		writeln!(writer)?;
+
+		writer.flush()
+	}
+}
+
+// NOTE: the following code took inspiration from tracing-subscriber
+//
+//       https://github.com/tokio-rs/tracing/blob/2f59b32/tracing-subscriber/src/fmt/format/mod.rs#L449
+impl<S, N, T> FormatEvent<S, N> for EventFormat<T>
+where
+	S: Subscriber + for<'a> LookupSpan<'a>,
+	N: for<'a> FormatFields<'a> + 'static,
+	T: FormatTime,
+{
+	fn format_event(
+		&self,
+		ctx: &FmtContext<S, N>,
+		writer: &mut dyn fmt::Write,
+		event: &Event,
+	) -> fmt::Result {
+		if self.dup_to_stdout &&
+			(event.metadata().level() == &Level::INFO ||
+				event.metadata().level() == &Level::WARN ||
+				event.metadata().level() == &Level::ERROR)
+		{
+			let mut out = String::new();
+			self.format_event_custom(CustomFmtContext::FmtContext(ctx), &mut out, event)?;
+			writer.write_str(&out)?;
+			print!("{}", out);
+			Ok(())
+		} else {
+			self.format_event_custom(CustomFmtContext::FmtContext(ctx), writer, event)
+		}
+	}
+}
+
+struct FmtLevel<'a> {
+	level: &'a Level,
+	ansi: bool,
+}
+
+impl<'a> FmtLevel<'a> {
+	pub(crate) fn new(level: &'a Level, ansi: bool) -> Self {
+		Self { level, ansi }
+	}
+}
+
+const TRACE_STR: &str = "TRACE";
+const DEBUG_STR: &str = "DEBUG";
+const INFO_STR: &str = " INFO";
+const WARN_STR: &str = " WARN";
+const ERROR_STR: &str = "ERROR";
+
+impl<'a> fmt::Display for FmtLevel<'a> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		if self.ansi {
+			match *self.level {
+				Level::TRACE => write!(f, "{}", Colour::Purple.paint(TRACE_STR)),
+				Level::DEBUG => write!(f, "{}", Colour::Blue.paint(DEBUG_STR)),
+				Level::INFO => write!(f, "{}", Colour::Green.paint(INFO_STR)),
+				Level::WARN => write!(f, "{}", Colour::Yellow.paint(WARN_STR)),
+				Level::ERROR => write!(f, "{}", Colour::Red.paint(ERROR_STR)),
+			}
+		} else {
+			match *self.level {
+				Level::TRACE => f.pad(TRACE_STR),
+				Level::DEBUG => f.pad(DEBUG_STR),
+				Level::INFO => f.pad(INFO_STR),
+				Level::WARN => f.pad(WARN_STR),
+				Level::ERROR => f.pad(ERROR_STR),
+			}
+		}
+	}
+}
+
+struct FmtThreadName<'a> {
+	name: &'a str,
+}
+
+impl<'a> FmtThreadName<'a> {
+	pub(crate) fn new(name: &'a str) -> Self {
+		Self { name }
+	}
+}
+
+// NOTE: the following code has been duplicated from tracing-subscriber
+//
+//       https://github.com/tokio-rs/tracing/blob/2f59b32/tracing-subscriber/src/fmt/format/mod.rs#L845
+impl<'a> fmt::Display for FmtThreadName<'a> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		use std::sync::atomic::{
+			AtomicUsize,
+			Ordering::{AcqRel, Acquire, Relaxed},
+		};
+
+		// Track the longest thread name length we've seen so far in an atomic,
+		// so that it can be updated by any thread.
+		static MAX_LEN: AtomicUsize = AtomicUsize::new(0);
+		let len = self.name.len();
+		// Snapshot the current max thread name length.
+		let mut max_len = MAX_LEN.load(Relaxed);
+
+		while len > max_len {
+			// Try to set a new max length, if it is still the value we took a
+			// snapshot of.
+			match MAX_LEN.compare_exchange(max_len, len, AcqRel, Acquire) {
+				// We successfully set the new max value
+				Ok(_) => break,
+				// Another thread set a new max value since we last observed
+				// it! It's possible that the new length is actually longer than
+				// ours, so we'll loop again and check whether our length is
+				// still the longest. If not, we'll just use the newer value.
+				Err(actual) => max_len = actual,
+			}
+		}
+
+		// pad thread name using `max_len`
+		write!(f, "{:>width$}", self.name, width = max_len)
+	}
+}
+
+// NOTE: the following code has been duplicated from tracing-subscriber
+//
+//       https://github.com/tokio-rs/tracing/blob/2f59b32/tracing-subscriber/src/fmt/time/mod.rs#L252
+mod time {
+	use ansi_term::Style;
+	use std::fmt;
+	use tracing_subscriber::fmt::time::FormatTime;
+
+	pub(crate) fn write<T>(timer: T, writer: &mut dyn fmt::Write, with_ansi: bool) -> fmt::Result
+	where
+		T: FormatTime,
+	{
+		if with_ansi {
+			let style = Style::new().dimmed();
+			write!(writer, "{}", style.prefix())?;
+			timer.format_time(writer)?;
+			write!(writer, "{}", style.suffix())?;
+		} else {
+			timer.format_time(writer)?;
+		}
+		writer.write_char(' ')?;
+		Ok(())
+	}
+}
+
+// NOTE: `FmtContext`'s fields are private. This enum allows us to make a `format_event` function
+//       that works with `FmtContext` or `Context` with `FormatFields`
+#[allow(dead_code)]
+pub(crate) enum CustomFmtContext<'a, S, N> {
+	FmtContext(&'a FmtContext<'a, S, N>),
+	ContextWithFormatFields(&'a Context<'a, S>, &'a N),
+}
+
+impl<'a, S, N> FormatFields<'a> for CustomFmtContext<'a, S, N>
+where
+	S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+	N: for<'writer> FormatFields<'writer> + 'static,
+{
+	fn format_fields<R: RecordFields>(
+		&self,
+		writer: &'a mut dyn fmt::Write,
+		fields: R,
+	) -> fmt::Result {
+		match self {
+			CustomFmtContext::FmtContext(fmt_ctx) => fmt_ctx.format_fields(writer, fields),
+			CustomFmtContext::ContextWithFormatFields(_ctx, fmt_fields) =>
+				fmt_fields.format_fields(writer, fields),
+		}
+	}
+}
+
+// NOTE: the following code has been duplicated from tracing-subscriber
+//
+//       https://github.com/tokio-rs/tracing/blob/2f59b32/tracing-subscriber/src/fmt/fmt_layer.rs#L788
+impl<'a, S, N> CustomFmtContext<'a, S, N>
+where
+	S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+	N: for<'writer> FormatFields<'writer> + 'static,
+{
+	#[inline]
+	pub fn lookup_current(&self) -> Option<SpanRef<'_, S>>
+	where
+		S: for<'lookup> LookupSpan<'lookup>,
+	{
+		match self {
+			CustomFmtContext::FmtContext(fmt_ctx) => fmt_ctx.lookup_current(),
+			CustomFmtContext::ContextWithFormatFields(ctx, _) => ctx.lookup_current(),
+		}
+	}
+}
+
+/// A writer which (optionally) strips out terminal control codes from the logs.
+///
+/// This is used by [`EventFormat`] to sanitize the log messages.
+///
+/// It is required to call [`ControlCodeSanitizer::flush`] after all writes are done,
+/// because the content of these writes is buffered and will only be written to the
+/// `inner_writer` at that point.
+struct ControlCodeSanitizer<'a> {
+	sanitize: bool,
+	buffer: String,
+	inner_writer: &'a mut dyn fmt::Write,
+}
+
+impl<'a> fmt::Write for ControlCodeSanitizer<'a> {
+	fn write_str(&mut self, buf: &str) -> fmt::Result {
+		self.buffer.push_str(buf);
+		Ok(())
+	}
+}
+
+// NOTE: When making any changes here make sure to also change this function in `sp-panic-handler`.
+fn strip_control_codes(input: &str) -> std::borrow::Cow<str> {
+	lazy_static::lazy_static! {
+		static ref RE: Regex = Regex::new(r#"(?x)
+			\x1b\[[^m]+m|        # VT100 escape codes
+			[
+			  \x00-\x09\x0B-\x1F # ASCII control codes / Unicode C0 control codes, except \n
+			  \x7F               # ASCII delete
+			  \u{80}-\u{9F}      # Unicode C1 control codes
+			  \u{202A}-\u{202E}  # Unicode left-to-right / right-to-left control characters
+			  \u{2066}-\u{2069}  # Same as above
+			]
+		"#).expect("regex parsing doesn't fail; qed");
+	}
+
+	RE.replace_all(input, "")
+}
+
+impl<'a> ControlCodeSanitizer<'a> {
+	/// Creates a new instance.
+	fn new(sanitize: bool, inner_writer: &'a mut dyn fmt::Write) -> Self {
+		Self { sanitize, inner_writer, buffer: String::new() }
+	}
+
+	/// Write the buffered content to the `inner_writer`.
+	fn flush(&mut self) -> fmt::Result {
+		if self.sanitize {
+			let replaced = strip_control_codes(&self.buffer);
+			self.inner_writer.write_str(&replaced)?
+		} else {
+			self.inner_writer.write_str(&self.buffer)?
+		}
+
+		self.buffer.clear();
+		Ok(())
+	}
+}
diff --git a/substrate/client/tracing/src/logging/fast_local_time.rs b/substrate/client/tracing/src/logging/fast_local_time.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7be7bec8364aaccc47a9a23ca1d35864ea5cee76
--- /dev/null
+++ b/substrate/client/tracing/src/logging/fast_local_time.rs
@@ -0,0 +1,160 @@
+// 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 chrono::{Datelike, Timelike};
+use std::{cell::RefCell, fmt::Write, time::SystemTime};
+use tracing_subscriber::fmt::time::FormatTime;
+
+/// A structure which, when `Display`d, will print out the current local time.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+pub struct FastLocalTime {
+	/// Decides whenever the fractional timestamp with be included in the output.
+	///
+	/// If `false` the output will match the following `chrono` format string:
+	///   `%Y-%m-%d %H:%M:%S`
+	///
+	/// If `true` the output will match the following `chrono` format string:
+	///   `%Y-%m-%d %H:%M:%S%.3f`
+	pub with_fractional: bool,
+}
+
+// This is deliberately slightly larger than we actually need, just in case.
+const TIMESTAMP_MAXIMUM_LENGTH: usize = 32;
+
+#[derive(Default)]
+struct InlineString {
+	buffer: [u8; TIMESTAMP_MAXIMUM_LENGTH],
+	length: usize,
+}
+
+impl Write for InlineString {
+	fn write_str(&mut self, s: &str) -> std::fmt::Result {
+		let new_length = self.length + s.len();
+		assert!(
+			new_length <= TIMESTAMP_MAXIMUM_LENGTH,
+			"buffer overflow when formatting the current timestamp"
+		);
+
+		self.buffer[self.length..new_length].copy_from_slice(s.as_bytes());
+		self.length = new_length;
+		Ok(())
+	}
+}
+
+impl InlineString {
+	fn as_str(&self) -> &str {
+		// SAFETY: this is safe since the only place we append to the buffer
+		//         is in `write_str` from an `&str`
+		unsafe { std::str::from_utf8_unchecked(&self.buffer[..self.length]) }
+	}
+}
+
+#[derive(Default)]
+struct CachedTimestamp {
+	buffer: InlineString,
+	last_regenerated_at: u64,
+	last_fractional: u32,
+}
+
+thread_local! {
+	static TIMESTAMP: RefCell<CachedTimestamp> = Default::default();
+}
+
+impl FormatTime for FastLocalTime {
+	fn format_time(&self, w: &mut dyn Write) -> std::fmt::Result {
+		const TIMESTAMP_PARTIAL_LENGTH: usize = "0000-00-00 00:00:00".len();
+
+		let elapsed = SystemTime::now()
+			.duration_since(SystemTime::UNIX_EPOCH)
+			.expect("system time is never before UNIX epoch; qed");
+		let unix_time = elapsed.as_secs();
+
+		TIMESTAMP.with(|cache| {
+			let mut cache = cache.borrow_mut();
+
+			// Regenerate the timestamp only at most once each second.
+			if cache.last_regenerated_at != unix_time {
+				let ts = chrono::Local::now();
+				let fractional = (ts.nanosecond() % 1_000_000_000) / 1_000_000;
+				cache.last_regenerated_at = unix_time;
+				cache.last_fractional = fractional;
+				cache.buffer.length = 0;
+
+				write!(
+					&mut cache.buffer,
+					"{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}",
+					ts.year(),
+					ts.month(),
+					ts.day(),
+					ts.hour(),
+					ts.minute(),
+					ts.second(),
+					fractional
+				)?;
+			} else if self.with_fractional {
+				let fractional = elapsed.subsec_millis();
+
+				// Regenerate the fractional part at most once each millisecond.
+				if cache.last_fractional != fractional {
+					cache.last_fractional = fractional;
+					cache.buffer.length = TIMESTAMP_PARTIAL_LENGTH + 1;
+					write!(&mut cache.buffer, "{:03}", fractional)?;
+				}
+			}
+
+			let mut slice = cache.buffer.as_str();
+			if !self.with_fractional {
+				slice = &slice[..TIMESTAMP_PARTIAL_LENGTH];
+			}
+
+			w.write_str(slice)
+		})
+	}
+}
+
+impl std::fmt::Display for FastLocalTime {
+	fn fmt(&self, w: &mut std::fmt::Formatter) -> std::fmt::Result {
+		self.format_time(w)
+	}
+}
+
+#[test]
+fn test_format_fast_local_time() {
+	assert_eq!(
+		chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string().len(),
+		FastLocalTime { with_fractional: false }.to_string().len()
+	);
+	assert_eq!(
+		chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f").to_string().len(),
+		FastLocalTime { with_fractional: true }.to_string().len()
+	);
+
+	// A simple trick to make sure this test won't randomly fail if we so happen
+	// to land on the exact moment when we tick over to the next second.
+	let now_1 = FastLocalTime { with_fractional: false }.to_string();
+	let expected = chrono::Local::now().format("%Y-%m-%d %H:%M:%S").to_string();
+	let now_2 = FastLocalTime { with_fractional: false }.to_string();
+
+	assert!(
+		now_1 == expected || now_2 == expected,
+		"'{}' or '{}' should have been equal to '{}'",
+		now_1,
+		now_2,
+		expected
+	);
+}
diff --git a/substrate/client/tracing/src/logging/layers/mod.rs b/substrate/client/tracing/src/logging/layers/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b39320975f86fcf63b8553544223a1d677da97b5
--- /dev/null
+++ b/substrate/client/tracing/src/logging/layers/mod.rs
@@ -0,0 +1,21 @@
+// 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/>.
+
+mod prefix_layer;
+
+pub use prefix_layer::*;
diff --git a/substrate/client/tracing/src/logging/layers/prefix_layer.rs b/substrate/client/tracing/src/logging/layers/prefix_layer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fc444257bde04d7a8b2d03e2ed92ca5b6e79adcf
--- /dev/null
+++ b/substrate/client/tracing/src/logging/layers/prefix_layer.rs
@@ -0,0 +1,95 @@
+// 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 tracing::{span::Attributes, Id, Subscriber};
+use tracing_subscriber::{layer::Context, registry::LookupSpan, Layer};
+
+/// Span name used for the logging prefix. See macro `sc_tracing::logging::prefix_logs_with!`
+pub const PREFIX_LOG_SPAN: &str = "substrate-log-prefix";
+
+/// A `Layer` that captures the prefix span ([`PREFIX_LOG_SPAN`]) which is then used by
+/// [`crate::logging::EventFormat`] to prefix the log lines by customizable string.
+///
+/// See the macro `sc_cli::prefix_logs_with!` for more details.
+pub struct PrefixLayer;
+
+impl<S> Layer<S> for PrefixLayer
+where
+	S: Subscriber + for<'a> LookupSpan<'a>,
+{
+	fn new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>) {
+		let span = match ctx.span(id) {
+			Some(span) => span,
+			None => {
+				// this shouldn't happen!
+				debug_assert!(
+					false,
+					"newly created span with ID {:?} did not exist in the registry; this is a bug!",
+					id
+				);
+				return
+			},
+		};
+
+		if span.name() != PREFIX_LOG_SPAN {
+			return
+		}
+
+		let mut extensions = span.extensions_mut();
+
+		if extensions.get_mut::<Prefix>().is_none() {
+			let mut s = String::new();
+			let mut v = PrefixVisitor(&mut s);
+			attrs.record(&mut v);
+
+			if !s.is_empty() {
+				let fmt_fields = Prefix(s);
+				extensions.insert(fmt_fields);
+			}
+		}
+	}
+}
+
+struct PrefixVisitor<'a, W: std::fmt::Write>(&'a mut W);
+
+macro_rules! write_node_name {
+	($method:ident, $type:ty, $format:expr) => {
+		fn $method(&mut self, field: &tracing::field::Field, value: $type) {
+			if field.name() == "name" {
+				let _ = write!(self.0, $format, value);
+			}
+		}
+	};
+}
+
+impl<'a, W: std::fmt::Write> tracing::field::Visit for PrefixVisitor<'a, W> {
+	write_node_name!(record_debug, &dyn std::fmt::Debug, "[{:?}] ");
+	write_node_name!(record_str, &str, "[{}] ");
+	write_node_name!(record_i64, i64, "[{}] ");
+	write_node_name!(record_u64, u64, "[{}] ");
+	write_node_name!(record_bool, bool, "[{}] ");
+}
+
+#[derive(Debug)]
+pub(crate) struct Prefix(String);
+
+impl Prefix {
+	pub(crate) fn as_str(&self) -> &str {
+		self.0.as_str()
+	}
+}
diff --git a/substrate/client/tracing/src/logging/mod.rs b/substrate/client/tracing/src/logging/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a3cf277fbd5010ff636679d3a43249e52746725e
--- /dev/null
+++ b/substrate/client/tracing/src/logging/mod.rs
@@ -0,0 +1,678 @@
+// 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/>.
+
+//! Substrate logging library.
+//!
+//! This crate uses tokio's [tracing](https://github.com/tokio-rs/tracing/) library for logging.
+
+#![warn(missing_docs)]
+
+mod directives;
+mod event_format;
+mod fast_local_time;
+mod layers;
+mod stderr_writer;
+
+pub(crate) type DefaultLogger = stderr_writer::MakeStderrWriter;
+
+pub use directives::*;
+pub use sc_tracing_proc_macro::*;
+
+use std::io;
+use tracing::Subscriber;
+use tracing_subscriber::{
+	filter::LevelFilter,
+	fmt::{
+		format, FormatEvent, FormatFields, Formatter, Layer as FmtLayer, MakeWriter,
+		SubscriberBuilder,
+	},
+	layer::{self, SubscriberExt},
+	registry::LookupSpan,
+	EnvFilter, FmtSubscriber, Layer, Registry,
+};
+
+pub use event_format::*;
+pub use fast_local_time::FastLocalTime;
+pub use layers::*;
+
+use stderr_writer::MakeStderrWriter;
+
+/// Logging Result typedef.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Logging errors.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+#[non_exhaustive]
+#[error(transparent)]
+pub enum Error {
+	IoError(#[from] io::Error),
+	SetGlobalDefaultError(#[from] tracing::subscriber::SetGlobalDefaultError),
+	DirectiveParseError(#[from] tracing_subscriber::filter::ParseError),
+	SetLoggerError(#[from] tracing_log::log_tracer::SetLoggerError),
+}
+
+macro_rules! enable_log_reloading {
+	($builder:expr) => {{
+		let builder = $builder.with_filter_reloading();
+		let handle = builder.reload_handle();
+		set_reload_handle(handle);
+		builder
+	}};
+}
+
+/// Convert a `Option<LevelFilter>` to a [`log::LevelFilter`].
+///
+/// `None` is interpreted as `Info`.
+fn to_log_level_filter(level_filter: Option<LevelFilter>) -> log::LevelFilter {
+	match level_filter {
+		Some(LevelFilter::INFO) | None => log::LevelFilter::Info,
+		Some(LevelFilter::TRACE) => log::LevelFilter::Trace,
+		Some(LevelFilter::WARN) => log::LevelFilter::Warn,
+		Some(LevelFilter::ERROR) => log::LevelFilter::Error,
+		Some(LevelFilter::DEBUG) => log::LevelFilter::Debug,
+		Some(LevelFilter::OFF) => log::LevelFilter::Off,
+	}
+}
+
+/// Common implementation to get the subscriber.
+fn prepare_subscriber<N, E, F, W>(
+	directives: &str,
+	profiling_targets: Option<&str>,
+	force_colors: Option<bool>,
+	detailed_output: bool,
+	builder_hook: impl Fn(
+		SubscriberBuilder<format::DefaultFields, EventFormat, EnvFilter, DefaultLogger>,
+	) -> SubscriberBuilder<N, E, F, W>,
+) -> Result<impl Subscriber + for<'a> LookupSpan<'a>>
+where
+	N: for<'writer> FormatFields<'writer> + 'static,
+	E: FormatEvent<Registry, N> + 'static,
+	W: MakeWriter + 'static,
+	F: layer::Layer<Formatter<N, E, W>> + Send + Sync + 'static,
+	FmtLayer<Registry, N, E, W>: layer::Layer<Registry> + Send + Sync + 'static,
+{
+	// Accept all valid directives and print invalid ones
+	fn parse_user_directives(mut env_filter: EnvFilter, dirs: &str) -> Result<EnvFilter> {
+		for dir in dirs.split(',') {
+			env_filter = env_filter.add_directive(parse_default_directive(dir)?);
+		}
+		Ok(env_filter)
+	}
+
+	// Initialize filter - ensure to use `parse_default_directive` for any defaults to persist
+	// after log filter reloading by RPC
+	let mut env_filter = EnvFilter::default()
+		// Enable info
+		.add_directive(parse_default_directive("info").expect("provided directive is valid"))
+		// Disable info logging by default for some modules.
+		.add_directive(parse_default_directive("ws=off").expect("provided directive is valid"))
+		.add_directive(parse_default_directive("yamux=off").expect("provided directive is valid"))
+		.add_directive(
+			parse_default_directive("regalloc=off").expect("provided directive is valid"),
+		)
+		.add_directive(
+			parse_default_directive("cranelift_codegen=off").expect("provided directive is valid"),
+		)
+		// Set warn logging by default for some modules.
+		.add_directive(
+			parse_default_directive("cranelift_wasm=warn").expect("provided directive is valid"),
+		)
+		.add_directive(parse_default_directive("hyper=warn").expect("provided directive is valid"))
+		.add_directive(
+			parse_default_directive("trust_dns_proto=off").expect("provided directive is valid"),
+		)
+		.add_directive(
+			parse_default_directive("libp2p_mdns::behaviour::iface=off")
+				.expect("provided directive is valid"),
+		);
+
+	if let Ok(lvl) = std::env::var("RUST_LOG") {
+		if lvl != "" {
+			env_filter = parse_user_directives(env_filter, &lvl)?;
+		}
+	}
+
+	if directives != "" {
+		env_filter = parse_user_directives(env_filter, directives)?;
+	}
+
+	if let Some(profiling_targets) = profiling_targets {
+		env_filter = parse_user_directives(env_filter, profiling_targets)?;
+		env_filter = env_filter.add_directive(
+			parse_default_directive("sc_tracing=trace").expect("provided directive is valid"),
+		);
+	}
+
+	let max_level_hint = Layer::<FmtSubscriber>::max_level_hint(&env_filter);
+	let max_level = to_log_level_filter(max_level_hint);
+
+	tracing_log::LogTracer::builder().with_max_level(max_level).init()?;
+
+	// If we're only logging `INFO` entries then we'll use a simplified logging format.
+	let detailed_output = match max_level_hint {
+		Some(level) if level <= tracing_subscriber::filter::LevelFilter::INFO => false,
+		_ => true,
+	} || detailed_output;
+
+	let enable_color = force_colors.unwrap_or_else(|| atty::is(atty::Stream::Stderr));
+	let timer = fast_local_time::FastLocalTime { with_fractional: detailed_output };
+
+	let event_format = EventFormat {
+		timer,
+		display_target: detailed_output,
+		display_level: detailed_output,
+		display_thread_name: detailed_output,
+		enable_color,
+		dup_to_stdout: !atty::is(atty::Stream::Stderr) && atty::is(atty::Stream::Stdout),
+	};
+	let builder = FmtSubscriber::builder().with_env_filter(env_filter);
+
+	let builder = builder.with_span_events(format::FmtSpan::NONE);
+
+	let builder = builder.with_writer(MakeStderrWriter::default());
+
+	let builder = builder.event_format(event_format);
+
+	let builder = builder_hook(builder);
+
+	let subscriber = builder.finish().with(PrefixLayer);
+
+	Ok(subscriber)
+}
+
+/// A builder that is used to initialize the global logger.
+pub struct LoggerBuilder {
+	directives: String,
+	profiling: Option<(crate::TracingReceiver, String)>,
+	custom_profiler: Option<Box<dyn crate::TraceHandler>>,
+	log_reloading: bool,
+	force_colors: Option<bool>,
+	detailed_output: bool,
+}
+
+impl LoggerBuilder {
+	/// Create a new [`LoggerBuilder`] which can be used to initialize the global logger.
+	pub fn new<S: Into<String>>(directives: S) -> Self {
+		Self {
+			directives: directives.into(),
+			profiling: None,
+			custom_profiler: None,
+			log_reloading: false,
+			force_colors: None,
+			detailed_output: false,
+		}
+	}
+
+	/// Set up the profiling.
+	pub fn with_profiling<S: Into<String>>(
+		&mut self,
+		tracing_receiver: crate::TracingReceiver,
+		profiling_targets: S,
+	) -> &mut Self {
+		self.profiling = Some((tracing_receiver, profiling_targets.into()));
+		self
+	}
+
+	/// Add a custom profiler.
+	pub fn with_custom_profiling(
+		&mut self,
+		custom_profiler: Box<dyn crate::TraceHandler>,
+	) -> &mut Self {
+		self.custom_profiler = Some(custom_profiler);
+		self
+	}
+
+	/// Wether or not to disable log reloading.
+	pub fn with_log_reloading(&mut self, enabled: bool) -> &mut Self {
+		self.log_reloading = enabled;
+		self
+	}
+
+	/// Whether detailed log output should be enabled.
+	///
+	/// This includes showing the log target, log level and thread name.
+	///
+	/// This will be automatically enabled when there is a log level enabled that is higher than
+	/// `info`.
+	pub fn with_detailed_output(&mut self, detailed: bool) -> &mut Self {
+		self.detailed_output = detailed;
+		self
+	}
+
+	/// Force enable/disable colors.
+	pub fn with_colors(&mut self, enable: bool) -> &mut Self {
+		self.force_colors = Some(enable);
+		self
+	}
+
+	/// Initialize the global logger
+	///
+	/// This sets various global logging and tracing instances and thus may only be called once.
+	pub fn init(self) -> Result<()> {
+		if let Some((tracing_receiver, profiling_targets)) = self.profiling {
+			if self.log_reloading {
+				let subscriber = prepare_subscriber(
+					&self.directives,
+					Some(&profiling_targets),
+					self.force_colors,
+					self.detailed_output,
+					|builder| enable_log_reloading!(builder),
+				)?;
+				let mut profiling =
+					crate::ProfilingLayer::new(tracing_receiver, &profiling_targets);
+
+				self.custom_profiler
+					.into_iter()
+					.for_each(|profiler| profiling.add_handler(profiler));
+
+				tracing::subscriber::set_global_default(subscriber.with(profiling))?;
+
+				Ok(())
+			} else {
+				let subscriber = prepare_subscriber(
+					&self.directives,
+					Some(&profiling_targets),
+					self.force_colors,
+					self.detailed_output,
+					|builder| builder,
+				)?;
+				let mut profiling =
+					crate::ProfilingLayer::new(tracing_receiver, &profiling_targets);
+
+				self.custom_profiler
+					.into_iter()
+					.for_each(|profiler| profiling.add_handler(profiler));
+
+				tracing::subscriber::set_global_default(subscriber.with(profiling))?;
+
+				Ok(())
+			}
+		} else if self.log_reloading {
+			let subscriber = prepare_subscriber(
+				&self.directives,
+				None,
+				self.force_colors,
+				self.detailed_output,
+				|builder| enable_log_reloading!(builder),
+			)?;
+
+			tracing::subscriber::set_global_default(subscriber)?;
+
+			Ok(())
+		} else {
+			let subscriber = prepare_subscriber(
+				&self.directives,
+				None,
+				self.force_colors,
+				self.detailed_output,
+				|builder| builder,
+			)?;
+
+			tracing::subscriber::set_global_default(subscriber)?;
+
+			Ok(())
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate as sc_tracing;
+	use log::info;
+	use std::{
+		collections::BTreeMap,
+		env,
+		process::Command,
+		sync::{
+			atomic::{AtomicBool, AtomicUsize, Ordering},
+			Arc,
+		},
+	};
+	use tracing::{metadata::Kind, subscriber::Interest, Callsite, Level, Metadata};
+
+	const EXPECTED_LOG_MESSAGE: &'static str = "yeah logging works as expected";
+	const EXPECTED_NODE_NAME: &'static str = "THE_NODE";
+
+	fn init_logger(directives: &str) {
+		let _ = LoggerBuilder::new(directives).init().unwrap();
+	}
+
+	fn run_test_in_another_process(
+		test_name: &str,
+		test_body: impl FnOnce(),
+	) -> Option<std::process::Output> {
+		if env::var("RUN_FORKED_TEST").is_ok() {
+			test_body();
+			None
+		} else {
+			let output = Command::new(env::current_exe().unwrap())
+				.arg(test_name)
+				.env("RUN_FORKED_TEST", "1")
+				.output()
+				.unwrap();
+
+			assert!(output.status.success());
+			Some(output)
+		}
+	}
+
+	#[test]
+	fn test_logger_filters() {
+		run_test_in_another_process("test_logger_filters", || {
+			let test_directives =
+				"grandpa=debug,sync=trace,client=warn,telemetry,something-with-dash=error";
+			init_logger(&test_directives);
+
+			tracing::dispatcher::get_default(|dispatcher| {
+				let test_filter = |target, level| {
+					struct DummyCallSite;
+					impl Callsite for DummyCallSite {
+						fn set_interest(&self, _: Interest) {}
+						fn metadata(&self) -> &Metadata<'_> {
+							unreachable!();
+						}
+					}
+
+					let metadata = tracing::metadata!(
+						name: "",
+						target: target,
+						level: level,
+						fields: &[],
+						callsite: &DummyCallSite,
+						kind: Kind::SPAN,
+					);
+
+					dispatcher.enabled(&metadata)
+				};
+
+				assert!(test_filter("grandpa", Level::INFO));
+				assert!(test_filter("grandpa", Level::DEBUG));
+				assert!(!test_filter("grandpa", Level::TRACE));
+
+				assert!(test_filter("sync", Level::TRACE));
+				assert!(test_filter("client", Level::WARN));
+
+				assert!(test_filter("telemetry", Level::TRACE));
+				assert!(test_filter("something-with-dash", Level::ERROR));
+			});
+		});
+	}
+
+	/// This test ensures that using dash (`-`) in the target name in logs and directives actually
+	/// work.
+	#[test]
+	fn dash_in_target_name_works() {
+		let executable = env::current_exe().unwrap();
+		let output = Command::new(executable)
+			.env("ENABLE_LOGGING", "1")
+			.args(&["--nocapture", "log_something_with_dash_target_name"])
+			.output()
+			.unwrap();
+
+		let output = String::from_utf8(output.stderr).unwrap();
+		assert!(output.contains(EXPECTED_LOG_MESSAGE));
+	}
+
+	/// This is not an actual test, it is used by the `dash_in_target_name_works` test.
+	/// The given test will call the test executable and only execute this one test that
+	/// only prints `EXPECTED_LOG_MESSAGE` through logging while using a target
+	/// name that contains a dash. This ensures that target names with dashes work.
+	#[test]
+	fn log_something_with_dash_target_name() {
+		if env::var("ENABLE_LOGGING").is_ok() {
+			let test_directives = "test-target=info";
+			let _guard = init_logger(&test_directives);
+
+			log::info!(target: "test-target", "{}", EXPECTED_LOG_MESSAGE);
+		}
+	}
+
+	#[test]
+	fn prefix_in_log_lines() {
+		let re = regex::Regex::new(&format!(
+			r"^\d{{4}}-\d{{2}}-\d{{2}} \d{{2}}:\d{{2}}:\d{{2}} \[{}\] {}$",
+			EXPECTED_NODE_NAME, EXPECTED_LOG_MESSAGE,
+		))
+		.unwrap();
+		let executable = env::current_exe().unwrap();
+		let output = Command::new(executable)
+			.env("ENABLE_LOGGING", "1")
+			.args(&["--nocapture", "prefix_in_log_lines_entrypoint"])
+			.output()
+			.unwrap();
+
+		let output = String::from_utf8(output.stderr).unwrap();
+		assert!(re.is_match(output.trim()), "Expected:\n{}\nGot:\n{}", re, output);
+	}
+
+	/// This is not an actual test, it is used by the `prefix_in_log_lines` test.
+	/// The given test will call the test executable and only execute this one test that
+	/// only prints a log line prefixed by the node name `EXPECTED_NODE_NAME`.
+	#[test]
+	fn prefix_in_log_lines_entrypoint() {
+		if env::var("ENABLE_LOGGING").is_ok() {
+			let _guard = init_logger("");
+			prefix_in_log_lines_process();
+		}
+	}
+
+	#[crate::logging::prefix_logs_with(EXPECTED_NODE_NAME)]
+	fn prefix_in_log_lines_process() {
+		log::info!("{}", EXPECTED_LOG_MESSAGE);
+	}
+
+	/// This is not an actual test, it is used by the `do_not_write_with_colors_on_tty` test.
+	/// The given test will call the test executable and only execute this one test that
+	/// only prints a log line with some colors in it.
+	#[test]
+	fn do_not_write_with_colors_on_tty_entrypoint() {
+		if env::var("ENABLE_LOGGING").is_ok() {
+			let _guard = init_logger("");
+			log::info!("{}", ansi_term::Colour::Yellow.paint(EXPECTED_LOG_MESSAGE));
+		}
+	}
+
+	#[test]
+	fn do_not_write_with_colors_on_tty() {
+		let re = regex::Regex::new(&format!(
+			r"^\d{{4}}-\d{{2}}-\d{{2}} \d{{2}}:\d{{2}}:\d{{2}} {}$",
+			EXPECTED_LOG_MESSAGE,
+		))
+		.unwrap();
+		let executable = env::current_exe().unwrap();
+		let output = Command::new(executable)
+			.env("ENABLE_LOGGING", "1")
+			.args(&["--nocapture", "do_not_write_with_colors_on_tty_entrypoint"])
+			.output()
+			.unwrap();
+
+		let output = String::from_utf8(output.stderr).unwrap();
+		assert!(re.is_match(output.trim()), "Expected:\n{}\nGot:\n{}", re, output);
+	}
+
+	#[test]
+	fn log_max_level_is_set_properly() {
+		fn run_test(rust_log: Option<String>, tracing_targets: Option<String>) -> String {
+			let executable = env::current_exe().unwrap();
+			let mut command = Command::new(executable);
+
+			command
+				.env("PRINT_MAX_LOG_LEVEL", "1")
+				.args(&["--nocapture", "log_max_level_is_set_properly"]);
+
+			if let Some(rust_log) = rust_log {
+				command.env("RUST_LOG", rust_log);
+			}
+
+			if let Some(tracing_targets) = tracing_targets {
+				command.env("TRACING_TARGETS", tracing_targets);
+			}
+
+			let output = command.output().unwrap();
+
+			dbg!(String::from_utf8(output.stderr)).unwrap()
+		}
+
+		if env::var("PRINT_MAX_LOG_LEVEL").is_ok() {
+			let mut builder = LoggerBuilder::new("");
+
+			if let Ok(targets) = env::var("TRACING_TARGETS") {
+				builder.with_profiling(crate::TracingReceiver::Log, targets);
+			}
+
+			builder.init().unwrap();
+
+			eprint!("MAX_LOG_LEVEL={:?}", log::max_level());
+		} else {
+			assert_eq!("MAX_LOG_LEVEL=Info", run_test(None, None));
+			assert_eq!("MAX_LOG_LEVEL=Trace", run_test(Some("test=trace".into()), None));
+			assert_eq!("MAX_LOG_LEVEL=Debug", run_test(Some("test=debug".into()), None));
+			assert_eq!("MAX_LOG_LEVEL=Trace", run_test(None, Some("test=info".into())));
+		}
+	}
+
+	// This creates a bunch of threads and makes sure they start executing
+	// a given callback almost exactly at the same time.
+	fn run_on_many_threads(thread_count: usize, callback: impl Fn(usize) + 'static + Send + Clone) {
+		let started_count = Arc::new(AtomicUsize::new(0));
+		let barrier = Arc::new(AtomicBool::new(false));
+		let threads: Vec<_> = (0..thread_count)
+			.map(|nth_thread| {
+				let started_count = started_count.clone();
+				let barrier = barrier.clone();
+				let callback = callback.clone();
+
+				std::thread::spawn(move || {
+					started_count.fetch_add(1, Ordering::SeqCst);
+					while !barrier.load(Ordering::SeqCst) {
+						std::thread::yield_now();
+					}
+
+					callback(nth_thread);
+				})
+			})
+			.collect();
+
+		while started_count.load(Ordering::SeqCst) != thread_count {
+			std::thread::yield_now();
+		}
+		barrier.store(true, Ordering::SeqCst);
+
+		for thread in threads {
+			if let Err(error) = thread.join() {
+				println!("error: failed to join thread: {:?}", error);
+				unsafe { libc::abort() }
+			}
+		}
+	}
+
+	#[test]
+	fn parallel_logs_from_multiple_threads_are_properly_gathered() {
+		const THREAD_COUNT: usize = 128;
+		const LOGS_PER_THREAD: usize = 1024;
+
+		let output = run_test_in_another_process(
+			"parallel_logs_from_multiple_threads_are_properly_gathered",
+			|| {
+				let builder = LoggerBuilder::new("");
+				builder.init().unwrap();
+
+				run_on_many_threads(THREAD_COUNT, |nth_thread| {
+					for _ in 0..LOGS_PER_THREAD {
+						info!("Thread <<{}>>", nth_thread);
+					}
+				});
+			},
+		);
+
+		if let Some(output) = output {
+			let stderr = String::from_utf8(output.stderr).unwrap();
+			let mut count_per_thread = BTreeMap::new();
+			for line in stderr.split("\n") {
+				if let Some(index_s) = line.find("Thread <<") {
+					let index_s = index_s + "Thread <<".len();
+					let index_e = line.find(">>").unwrap();
+					let nth_thread: usize = line[index_s..index_e].parse().unwrap();
+					*count_per_thread.entry(nth_thread).or_insert(0) += 1;
+				}
+			}
+
+			assert_eq!(count_per_thread.len(), THREAD_COUNT);
+			for (_, count) in count_per_thread {
+				assert_eq!(count, LOGS_PER_THREAD);
+			}
+		}
+	}
+
+	#[test]
+	fn huge_single_line_log_is_properly_printed_out() {
+		let mut line = String::new();
+		line.push_str("$$START$$");
+		for n in 0..16 * 1024 * 1024 {
+			let ch = b'a' + (n as u8 % (b'z' - b'a'));
+			line.push(char::from(ch));
+		}
+		line.push_str("$$END$$");
+
+		let output =
+			run_test_in_another_process("huge_single_line_log_is_properly_printed_out", || {
+				let builder = LoggerBuilder::new("");
+				builder.init().unwrap();
+				info!("{}", line);
+			});
+
+		if let Some(output) = output {
+			let stderr = String::from_utf8(output.stderr).unwrap();
+			assert!(stderr.contains(&line));
+		}
+	}
+
+	#[test]
+	fn control_characters_are_always_stripped_out_from_the_log_messages() {
+		const RAW_LINE: &str = "$$START$$\x1B[1;32mIn\u{202a}\u{202e}\u{2066}\u{2069}ner\n\r\x7ftext!\u{80}\u{9f}\x1B[0m$$END$$";
+		const SANITIZED_LINE: &str = "$$START$$Inner\ntext!$$END$$";
+
+		let output = run_test_in_another_process(
+			"control_characters_are_always_stripped_out_from_the_log_messages",
+			|| {
+				std::env::set_var("RUST_LOG", "trace");
+				let mut builder = LoggerBuilder::new("");
+				builder.with_colors(true);
+				builder.init().unwrap();
+				log::error!("{}", RAW_LINE);
+			},
+		);
+
+		if let Some(output) = output {
+			let stderr = String::from_utf8(output.stderr).unwrap();
+			// The log messages should always be sanitized.
+			assert!(!stderr.contains(RAW_LINE));
+			assert!(stderr.contains(SANITIZED_LINE));
+
+			// The part where the timestamp, the logging level, etc. is printed out doesn't
+			// always have to be sanitized unless it's necessary, and here it shouldn't be.
+			assert!(stderr.contains("\x1B[31mERROR\x1B[0m"));
+
+			// Make sure the logs aren't being duplicated.
+			assert_eq!(stderr.find("ERROR"), stderr.rfind("ERROR"));
+			assert_eq!(stderr.find(SANITIZED_LINE), stderr.rfind(SANITIZED_LINE));
+		}
+	}
+}
diff --git a/substrate/client/tracing/src/logging/stderr_writer.rs b/substrate/client/tracing/src/logging/stderr_writer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..80df2f1fe7cdfc4ada63f12eabe96eb8c18bfd19
--- /dev/null
+++ b/substrate/client/tracing/src/logging/stderr_writer.rs
@@ -0,0 +1,228 @@
+// 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/>.
+
+//! This module contains a buffered semi-asynchronous stderr writer.
+//!
+//! Depending on how we were started writing to stderr can take a surprisingly long time.
+//!
+//! If the other side takes their sweet sweet time reading whatever we send them then writing
+//! to stderr might block for a long time, since it is effectively a synchronous operation.
+//! And every time we write to stderr we need to grab a global lock, which affects every thread
+//! which also tries to log something at the same time.
+//!
+//! Of course we *will* be ultimately limited by how fast the recipient can ingest our logs,
+//! but it's not like logging is the only thing we're doing. And we still can't entirely
+//! avoid the problem of multiple threads contending for the same lock. (Well, technically
+//! we could employ something like a lock-free circular buffer, but that might be like
+//! killing a fly with a sledgehammer considering the complexity involved; this is only
+//! a logger after all.)
+//!
+//! But we can try to make things a little better. We can offload actually writing to stderr
+//! to another thread and flush the logs in bulk instead of doing it per-line, which should
+//! reduce the amount of CPU time we waste on making syscalls and on spinning waiting for locks.
+//!
+//! How much this helps depends on a multitude of factors, including the hardware we're running on,
+//! how much we're logging, from how many threads, which exact set of threads are logging, to what
+//! stderr is actually connected to (is it a terminal emulator? a file? an UDP socket?), etc.
+//!
+//! In general this can reduce the real time execution time as much as 75% in certain cases, or it
+//! can make absolutely no difference in others.
+
+use parking_lot::{Condvar, Mutex, Once};
+use std::{
+	io::Write,
+	sync::atomic::{AtomicBool, Ordering},
+	time::Duration,
+};
+use tracing::{Level, Metadata};
+
+/// How many bytes of buffered logs will trigger an async flush on another thread?
+const ASYNC_FLUSH_THRESHOLD: usize = 16 * 1024;
+
+/// How many bytes of buffered logs will trigger a sync flush on the current thread?
+const SYNC_FLUSH_THRESHOLD: usize = 768 * 1024;
+
+/// How many bytes can be buffered at maximum?
+const EMERGENCY_FLUSH_THRESHOLD: usize = 2 * 1024 * 1024;
+
+/// If there isn't enough printed out this is how often the logs will be automatically flushed.
+const AUTOFLUSH_EVERY: Duration = Duration::from_millis(50);
+
+/// The least serious level at which a synchronous flush will be triggered.
+const SYNC_FLUSH_LEVEL_THRESHOLD: Level = Level::ERROR;
+
+/// The amount of time we'll block until the buffer is fully flushed on exit.
+///
+/// This should be completely unnecessary in normal circumstances.
+const ON_EXIT_FLUSH_TIMEOUT: Duration = Duration::from_secs(5);
+
+/// A global buffer to which we'll append all of our logs before flushing them out to stderr.
+static BUFFER: Mutex<Vec<u8>> = parking_lot::const_mutex(Vec::new());
+
+/// A spare buffer which we'll swap with the main buffer on each flush to minimize lock contention.
+static SPARE_BUFFER: Mutex<Vec<u8>> = parking_lot::const_mutex(Vec::new());
+
+/// A conditional variable used to forcefully trigger asynchronous flushes.
+static ASYNC_FLUSH_CONDVAR: Condvar = Condvar::new();
+
+static ENABLE_ASYNC_LOGGING: AtomicBool = AtomicBool::new(true);
+
+fn flush_logs(mut buffer: parking_lot::lock_api::MutexGuard<parking_lot::RawMutex, Vec<u8>>) {
+	let mut spare_buffer = SPARE_BUFFER.lock();
+	std::mem::swap(&mut *spare_buffer, &mut *buffer);
+	std::mem::drop(buffer);
+
+	let stderr = std::io::stderr();
+	let mut stderr_lock = stderr.lock();
+	let _ = stderr_lock.write_all(&spare_buffer);
+	std::mem::drop(stderr_lock);
+
+	spare_buffer.clear();
+}
+
+fn log_autoflush_thread() {
+	let mut buffer = BUFFER.lock();
+	loop {
+		ASYNC_FLUSH_CONDVAR.wait_for(&mut buffer, AUTOFLUSH_EVERY);
+		loop {
+			flush_logs(buffer);
+
+			buffer = BUFFER.lock();
+			if buffer.len() >= ASYNC_FLUSH_THRESHOLD {
+				// While we were busy flushing we picked up enough logs to do another flush.
+				continue
+			} else {
+				break
+			}
+		}
+	}
+}
+
+#[cold]
+fn initialize() {
+	std::thread::Builder::new()
+		.name("log-autoflush".to_owned())
+		.spawn(log_autoflush_thread)
+		.expect("thread spawning doesn't normally fail; qed");
+
+	// SAFETY: This is safe since we pass a valid pointer to `atexit`.
+	let errcode = unsafe { libc::atexit(on_exit) };
+	assert_eq!(errcode, 0, "atexit failed while setting up the logger: {}", errcode);
+}
+
+extern "C" fn on_exit() {
+	ENABLE_ASYNC_LOGGING.store(false, Ordering::SeqCst);
+
+	if let Some(buffer) = BUFFER.try_lock_for(ON_EXIT_FLUSH_TIMEOUT) {
+		flush_logs(buffer);
+	}
+}
+
+/// A drop-in replacement for [`std::io::stderr`] for use anywhere
+/// a [`tracing_subscriber::fmt::MakeWriter`] is accepted.
+pub struct MakeStderrWriter {
+	// A dummy field so that the structure is not publicly constructible.
+	_dummy: (),
+}
+
+impl Default for MakeStderrWriter {
+	fn default() -> Self {
+		static ONCE: Once = Once::new();
+		ONCE.call_once(initialize);
+		MakeStderrWriter { _dummy: () }
+	}
+}
+
+impl tracing_subscriber::fmt::MakeWriter for MakeStderrWriter {
+	type Writer = StderrWriter;
+
+	fn make_writer(&self) -> Self::Writer {
+		StderrWriter::new(false)
+	}
+
+	// The `tracing-subscriber` crate calls this for every line logged.
+	fn make_writer_for(&self, meta: &Metadata<'_>) -> Self::Writer {
+		StderrWriter::new(*meta.level() <= SYNC_FLUSH_LEVEL_THRESHOLD)
+	}
+}
+
+pub struct StderrWriter {
+	buffer: Option<parking_lot::lock_api::MutexGuard<'static, parking_lot::RawMutex, Vec<u8>>>,
+	sync_flush_on_drop: bool,
+	original_len: usize,
+}
+
+impl StderrWriter {
+	fn new(mut sync_flush_on_drop: bool) -> Self {
+		if !ENABLE_ASYNC_LOGGING.load(Ordering::Relaxed) {
+			sync_flush_on_drop = true;
+		}
+
+		// This lock isn't as expensive as it might look, since this is only called once the full
+		// line to be logged is already serialized into a thread-local buffer inside of the
+		// `tracing-subscriber` crate, and basically the only thing we'll do when holding this lock
+		// is to copy that over to our global shared buffer in one go in `Write::write_all` and be
+		// immediately dropped.
+		let buffer = BUFFER.lock();
+		StderrWriter { original_len: buffer.len(), buffer: Some(buffer), sync_flush_on_drop }
+	}
+}
+
+#[cold]
+fn emergency_flush(buffer: &mut Vec<u8>, input: &[u8]) {
+	let stderr = std::io::stderr();
+	let mut stderr_lock = stderr.lock();
+	let _ = stderr_lock.write_all(buffer);
+	buffer.clear();
+
+	let _ = stderr_lock.write_all(input);
+}
+
+impl Write for StderrWriter {
+	fn write(&mut self, input: &[u8]) -> Result<usize, std::io::Error> {
+		let buffer = self.buffer.as_mut().expect("buffer is only None after `drop`; qed");
+		if buffer.len() + input.len() >= EMERGENCY_FLUSH_THRESHOLD {
+			// Make sure we don't blow our memory budget. Normally this should never happen,
+			// but there are cases where we directly print out untrusted user input which
+			// can potentially be megabytes in size.
+			emergency_flush(buffer, input);
+		} else {
+			buffer.extend_from_slice(input);
+		}
+		Ok(input.len())
+	}
+
+	fn write_all(&mut self, input: &[u8]) -> Result<(), std::io::Error> {
+		self.write(input).map(|_| ())
+	}
+
+	fn flush(&mut self) -> Result<(), std::io::Error> {
+		Ok(())
+	}
+}
+
+impl Drop for StderrWriter {
+	fn drop(&mut self) {
+		let buf = self.buffer.take().expect("buffer is only None after `drop`; qed");
+		if self.sync_flush_on_drop || buf.len() >= SYNC_FLUSH_THRESHOLD {
+			flush_logs(buf);
+		} else if self.original_len < ASYNC_FLUSH_THRESHOLD && buf.len() >= ASYNC_FLUSH_THRESHOLD {
+			ASYNC_FLUSH_CONDVAR.notify_one();
+		}
+	}
+}
diff --git a/substrate/client/transaction-pool/Cargo.toml b/substrate/client/transaction-pool/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1718751e6d83c693c6088f79fd072c776eff02ae
--- /dev/null
+++ b/substrate/client/transaction-pool/Cargo.toml
@@ -0,0 +1,48 @@
+[package]
+name = "sc-transaction-pool"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate transaction pool implementation."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+futures-timer = "3.0.2"
+linked-hash-map = "0.5.4"
+log = "0.4.17"
+parking_lot = "0.12.1"
+serde = { version = "1.0.163", features = ["derive"] }
+thiserror = "1.0.30"
+prometheus-endpoint = { package = "substrate-prometheus-endpoint", version = "0.10.0-dev", path = "../../utils/prometheus" }
+sc-client-api = { version = "4.0.0-dev", path = "../api" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "./api" }
+sc-utils = { version = "4.0.0-dev", path = "../utils" }
+sp-api = { version = "4.0.0-dev", path = "../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+sp-transaction-pool = { version = "4.0.0-dev", path = "../../primitives/transaction-pool" }
+
+[dev-dependencies]
+array-bytes = "6.1"
+assert_matches = "1.3.0"
+criterion = "0.4.0"
+sc-block-builder = { version = "0.10.0-dev", path = "../block-builder" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+substrate-test-runtime = { version = "2.0.0", path = "../../test-utils/runtime" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+substrate-test-runtime-transaction-pool = { version = "2.0.0", path = "../../test-utils/runtime/transaction-pool" }
+
+[[bench]]
+name = "basics"
+harness = false
diff --git a/substrate/client/transaction-pool/README.md b/substrate/client/transaction-pool/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a2bbb8838f9c8e2b654c938365cedc65201f36d
--- /dev/null
+++ b/substrate/client/transaction-pool/README.md
@@ -0,0 +1,368 @@
+Substrate transaction pool implementation.
+
+License: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+# Problem Statement
+
+The transaction pool is responsible for maintaining a set of transactions that
+possible to include by block authors in upcoming blocks. Transactions are received
+either from networking (gossiped by other peers) or RPC (submitted locally).
+
+The main task of the pool is to prepare an ordered list of transactions for block
+authorship module. The same list is useful for gossiping to other peers, but note
+that it's not a hard requirement for the gossiped transactions to be exactly the
+same (see implementation notes below).
+
+It's within block author incentives to have the transactions stored and ordered in
+such a way to:
+
+1. Maximize block author's profits (value of the produced block)
+2. Minimize block author's amount of work (time to produce block)
+
+In the case of FRAME the first property is simply making sure that the fee per weight
+unit is the highest (high `tip` values), the second is about avoiding feeding
+transactions that cannot be part of the next block (they are invalid, obsolete, etc).
+
+From the transaction pool PoV, transactions are simply opaque blob of bytes,
+it's required to query the runtime (via `TaggedTransactionQueue` Runtime API) to
+verify transaction's mere correctness and extract any information about how the
+transaction relates to other transactions in the pool and current on-chain state.
+Only valid transactions should be stored in the pool.
+
+Each imported block can affect validity of transactions already in the pool. Block
+authors expect from the pool to get most up to date information about transactions
+that can be included in the block that they are going to build on top of the just
+imported one. The process of ensuring this property is called *pruning*. During
+pruning the pool should remove transactions which are considered invalid by the
+runtime (queried at current best imported block).
+
+Since the blockchain is not always linear, forks need to be correctly handled by
+the transaction pool as well. In case of a fork, some blocks are *retracted*
+from the canonical chain, and some other blocks get *enacted* on top of some
+common ancestor. The transactions from retracted blocks could simply be discarded,
+but it's desirable to make sure they are still considered for inclusion in case they
+are deemed valid by the runtime state at best, recently enacted block (fork the
+chain re-organized to).
+
+Transaction pool should also offer a way of tracking transaction lifecycle in the
+pool, it's broadcasting status, block inclusion, finality, etc.
+
+## Transaction Validity details
+
+Information retrieved from the the runtime are encapsulated in the `TransactionValidity`
+type.
+
+```rust
+pub type TransactionValidity = Result<ValidTransaction, TransactionValidityError>;
+
+pub struct ValidTransaction {
+  pub requires: Vec<TransactionTag>,
+  pub provides: Vec<TransactionTag>,
+  pub priority: TransactionPriority,
+  pub longevity: TransactionLongevity,
+  pub propagate: bool,
+}
+
+pub enum TransactionValidityError {
+  Invalid(/* details */),
+  Unknown(/* details */),
+}
+```
+
+We will go through each of the parameter now to understand the requirements they
+create for transaction ordering.
+
+The runtime is expected to return these values in a deterministic fashion. Calling
+the API multiple times given exactly the same state must return same results.
+Field-specific rules are described below.
+
+### `requires` / `provides`
+
+These two fields contain a set of `TransactionTag`s (opaque blobs) associated with
+a given transaction. This is a mechanism for the runtime to be able to
+express dependencies between transactions (that this transaction pool can take
+account of). By looking at these fields we can establish a transaction's readiness
+for block inclusion.
+
+The `provides` set contains properties that will be *satisfied* in case the transaction
+is successfully added to a block. Only a transaction in a block may provide a specific
+tag. `requires` contains properties that must be satisfied **before** the transaction
+can be included to a block.
+
+Note that a transaction with empty `requires` set can be added to a block immediately,
+there are no other transactions that it expects to be included before.
+
+For some given series of transactions the `provides` and `requires` fields will create
+a (simple) directed acyclic graph. The *sources* in such graph, if they don't have
+any extra `requires` tags (i.e. they have their all dependencies *satisfied*), should
+be considered for block inclusion first. Multiple transactions that are ready for
+block inclusion should be ordered by `priority` (see below).
+
+Note the process of including transactions to a block is basically building the graph,
+then selecting "the best" source vertex (transaction) with all tags satisfied and
+removing it from that graph.
+
+#### Examples
+
+- A transaction in Bitcoin-like chain will `provide` generated UTXOs and will `require`
+  UTXOs it is still awaiting for (note that it's not necessarily all require inputs,
+  since some of them might already be spendable (i.e. the UTXO is in state))
+
+- A transaction in account-based chain will `provide` a `(sender, transaction_index/nonce)`
+  (as one tag), and will `require` `(sender, nonce - 1)` in case
+  `on_chain_nonce < nonce - 1`.
+
+#### Rules & caveats
+
+- `provides` must not be empty
+- transactions with an overlap in `provides` tags are mutually exclusive
+- checking validity of transaction that `requires` tag `A` after including
+  transaction that provides that tag must not return `A` in `requires` again
+- runtime developers should avoid re-using `provides` tag (i.e. it should be unique)
+- there should be no cycles in transaction dependencies
+- caveat: on-chain state conditions may render transaction invalid despite no
+  `requires` tags
+- caveat: on-chain state conditions may render transaction valid despite some
+  `requires` tags
+- caveat: including transactions to a chain might make them valid again right away
+  (for instance UTXO transaction gets in, but since we don't store spent outputs
+  it will be valid again, awaiting the same inputs/tags to be satisfied)
+
+### `priority`
+
+Transaction priority describes importance of the transaction relative to other transactions
+in the pool. Block authors can expect benefiting from including such transactions
+before others.
+
+Note that we can't simply order transactions in the pool by `priority`, because first
+we need to make sure that all of the transaction requirements are satisfied (see
+`requires/provides` section). However if we consider a set of transactions
+which all have their requirements (tags) satisfied, the block author should be
+choosing the ones with highest priority to include to the next block first.
+
+`priority` can be any number between `0` (lowest inclusion priority) to `u64::MAX`
+(highest inclusion priority).
+
+#### Rules & caveats
+
+- `priority` of transaction may change over time
+- on-chain conditions may affect `priority`
+- given two transactions with overlapping `provides` tags, the one with higher
+  `priority` should be preferred. However we can also look at the total priority
+  of a subtree rooted at that transaction and compare that instead (i.e. even though
+  the transaction itself has lower `priority` it "unlocks" other high priority transactions).
+
+### `longevity`
+
+Longevity describes how long (in blocks) the transaction is expected to be
+valid. This parameter only gives a hint to the transaction pool how long
+current transaction may still be valid. Note that it does not guarantee
+the transaction is valid all that time though.
+
+#### Rules & caveats
+
+- `longevity` of transaction may change over time
+- on-chain conditions may affect `longevity`
+- after `longevity` lapses, the transaction may still be valid
+
+### `propagate`
+
+This parameter instructs the pool propagate/gossip a transaction to node peers.
+By default this should be `true`, however in some cases it might be undesirable
+to propagate transactions further. Examples might include heavy transactions
+produced by block authors in offchain workers (DoS) or risking being front
+runned by someone else after finding some non trivial solution or equivocation,
+etc.
+
+### 'TransactionSource`
+
+To make it possible for the runtime to distinguish if the transaction that is
+being validated was received over the network or submitted using local RPC or
+maybe it's simply part of a block that is being imported, the transaction pool
+should pass additional `TransactionSource` parameter to the validity function
+runtime call.
+
+This can be used by runtime developers to quickly reject transactions that for
+instance are not expected to be gossiped in the network.
+
+
+### `Invalid` transaction
+
+In case the runtime returns an `Invalid` error it means the transaction cannot
+be added to a block at all. Extracting the actual reason of invalidity gives
+more details about the source. For instance `Stale` transaction just indicates
+the transaction was already included in a block, while `BadProof` signifies
+invalid signature.
+Invalidity might also be temporary. In case of `ExhaustsResources` the
+transaction does not fit to the current block, but it might be okay for the next
+one.
+
+### `Unknown` transaction
+
+In case of `Unknown` validity, the runtime cannot determine if the transaction
+is valid or not in current block. However this situation might be temporary, so
+it is expected for the transaction to be retried in the future.
+
+# Implementation
+
+An ideal transaction pool should be storing only transactions that are considered
+valid by the runtime at current best imported block.
+After every block is imported, the pool should:
+
+1. Revalidate all transactions in the pool and remove the invalid ones.
+1. Construct the transaction inclusion graph based on `provides/requires` tags.
+   Some transactions might not be reachable (have unsatisfied dependencies),
+   they should be just left out in the pool.
+1. On block author request, the graph should be copied and transactions should
+   be removed one-by-one from the graph starting from the one with highest
+   priority and all conditions satisfied.
+
+With current gossip protocol, networking should propagate transactions in the
+same order as block author would include them. Most likely it's fine if we
+propagate transactions with cumulative weight not exceeding upcoming `N`
+blocks (choosing `N` is subject to networking conditions and block times).
+
+Note that it's not a strict requirement though to propagate exactly the same
+transactions that are prepared for block inclusion. Propagation is best
+effort, especially for block authors and is not directly incentivised.
+However the networking protocol might penalise peers that send invalid or
+useless transactions so we should be nice to others. Also see below a proposal
+to instead of gossiping everyting have other peers request transactions they
+are interested in.
+
+Since the pool is expected to store more transactions than what can fit
+in a single block, validating the entire pool on every block might not be
+feasible. This means that the actual implementation might need to take some 
+shortcuts.
+
+## Suggestions & caveats
+
+1. The validity of a transaction should not change significantly from block to
+   block. I.e. changes in validity should happen predictably, e.g. `longevity`
+   decrements by 1, `priority` stays the same, `requires` changes if transaction
+   that provided a tag was included in block, `provides` does not change, etc.
+
+1. That means we don't have to revalidate every transaction after every block
+   import, but we need to take care of removing potentially stale transactions.
+
+1. Transactions with exactly the same bytes are most likely going to give the
+   same validity results. We can essentially treat them as identical.
+
+1. Watch out for re-organisations and re-importing transactions from retracted
+   blocks.
+
+1. In the past there were many issues found when running small networks with a
+   lot of re-orgs. Make sure that transactions are never lost.
+
+1. The UTXO model is quite challenging. A transaction becomes valid right after
+   it's included in a block, however it is waiting for exactly the same inputs 
+   to be spent, so it will never really be included again.
+
+1. Note that in a non-ideal implementation the state of the pool will most
+   likely always be a bit off, i.e. some transactions might be still in the pool,
+   but they are invalid. The hard decision is about trade-offs you take.
+
+1. Note that import notification is not reliable - you might not receive a
+   notification about every imported block.
+
+## Potential implementation ideas
+
+1. Block authors remove transactions from the pool when they author a block. We
+   still store them around to re-import in case the block does not end up
+   canonical. This only works if the block is actively authoring blocks (also
+   see below).
+
+1. We don't prune, but rather remove a fixed amount of transactions from the front
+   of the pool (number based on average/max transactions per block from the
+   past) and re-validate them, reimporting the ones that are still valid.
+
+1. We periodically validate all transactions in the pool in batches.
+
+1. To minimize runtime calls, we introduce the batch-verify call. Note it should 
+   reset the state (overlay) after every verification.
+
+1. Consider leveraging finality. Maybe we could verify against latest finalised
+   block instead. With this the pool in different nodes can be more similar
+   which might help with gossiping (see set reconciliation). Note that finality
+   is not a strict requirement for a Substrate chain to have though.
+
+1. Perhaps we could avoid maintaining ready/future queues as currently, but
+   rather if a transaction doesn't have all requirements satisfied by existing
+   transactions we attempt to re-import it in the future.
+
+1. Instead of maintaining a full pool with total ordering we attempt to maintain
+   a set of next (couple of) blocks. We could introduce batch-validate runtime
+   api method that pretty much attempts to simulate actual block inclusion of
+   a set of such transactions (without necessarily fully running/dispatching
+   them). Importing a transaction would consist of figuring out which next block
+   this transaction has a chance to be included in and then attempting to
+   either push it back or replace some existing transactions.
+
+1. Perhaps we could use some immutable graph structure to easily add/remove
+   transactions. We need some traversal method that takes priority and
+   reachability into account.
+
+1. It was discussed in the past to use set reconciliation strategies instead of
+simply broadcasting all/some transactions to all/selected peers. An Ethereum's
+[EIP-2464](https://github.com/ethereum/EIPs/blob/5b9685bb9c7ba0f5f921e4d3f23504f7ef08d5b1/EIPS/eip-2464.md)
+might be a good first approach to reduce transaction gossip.
+
+# Current implementation
+
+Current implementation of the pool is a result of experiences from Ethereum's
+pool implementation, but also has some warts coming from the learning process of
+Substrate's generic nature and light client support.
+
+The pool consists of basically two independent parts:
+
+1. The transaction pool itself.
+2. Maintenance background task.
+
+The pool is split into `ready` pool and `future` pool. The latter contains
+transactions that don't have their requirements satisfied, and the former holds
+transactions that can be used to build a graph of dependencies. Note that the
+graph is built ad-hoc during the traversal process (using the `ready`
+iterator). This makes the importing process cheaper (we don't need to find the
+exact position in the queue or graph), but traversal process slower
+(logarithmic). However most of the time we will only need the beginning of the
+total ordering of transactions for block inclusion or network propagation, hence
+the decision.
+
+The maintenance task is responsible for:
+
+1. Periodically revalidating pool's transactions (revalidation queue).
+1. Handling block import notifications and doing pruning + re-importing of
+   transactions from retracted blocks.
+1. Handling finality notifications and relaying that to transaction-specific
+   listeners.
+
+Additionally we maintain a list of recently included/rejected transactions
+(`PoolRotator`) to quickly reject transactions that are unlikely to be valid
+to limit number of runtime verification calls.
+
+Each time a transaction is imported, we first verify it's validity and later
+find if the tags it `requires` can be satisfied by transactions already in
+`ready` pool. In case the transaction is imported to the `ready` pool we
+additionally *promote* transactions from the `future` pool if the transaction
+happened to fulfill their requirements.
+Note we need to cater for cases where a transaction might replace an already
+existing transaction in the pool. In such case we check the entire sub-tree of
+transactions that we are about to replace, compare their cumulative priority to
+determine which subtree to keep.
+
+After a block is imported we kick-off the pruning procedure. We first attempt to
+figure out what tags were satisfied by a transaction in that block. For each block
+transaction we either call into the runtime to get it's `ValidTransaction` object,
+or we check the pool if that transaction is already known to spare the runtime
+call. From this we gather the full set of `provides` tags and perform pruning of
+the `ready` pool based on that. Also, we promote all transactions from `future` 
+that have their tags satisfied.
+
+In case we remove transactions that we are unsure if they were already included
+in the current block or some block in the past, it gets added to the revalidation
+queue and attempts to be re-imported by the background task in the future.
+
+Runtime calls to verify transactions are performed from a separate (limited)
+thread pool to avoid interfering too much with other subsystems of the node. We
+definitely don't want to have all cores validating network transactions, because
+all of these transactions need to be considered untrusted (potentially DoS).
diff --git a/substrate/client/transaction-pool/api/Cargo.toml b/substrate/client/transaction-pool/api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..93efa05415d18f0ba76f25ffce52d1ced2a5da53
--- /dev/null
+++ b/substrate/client/transaction-pool/api/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "sc-transaction-pool-api"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Transaction pool client facing API."
+
+[dependencies]
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+log = "0.4.17"
+serde = { version = "1.0.163", features = ["derive"] }
+thiserror = "1.0.30"
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+
+[dev-dependencies]
+serde_json = "1.0"
diff --git a/substrate/client/transaction-pool/api/src/error.rs b/substrate/client/transaction-pool/api/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e521502f66fb1cbd3e85ef4b85ec9839d83e8d9f
--- /dev/null
+++ b/substrate/client/transaction-pool/api/src/error.rs
@@ -0,0 +1,90 @@
+// 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/>.
+
+//! Transaction pool errors.
+
+use sp_runtime::transaction_validity::{
+	InvalidTransaction, TransactionPriority as Priority, UnknownTransaction,
+};
+
+/// Transaction pool result.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Transaction pool error type.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+	#[error("Unknown transaction validity: {0:?}")]
+	UnknownTransaction(UnknownTransaction),
+
+	#[error("Invalid transaction validity: {0:?}")]
+	InvalidTransaction(InvalidTransaction),
+
+	/// The transaction validity returned no "provides" tag.
+	///
+	/// Such transactions are not accepted to the pool, since we use those tags
+	/// to define identity of transactions (occupance of the same "slot").
+	#[error("Transaction does not provide any tags, so the pool can't identify it")]
+	NoTagsProvided,
+
+	#[error("Transaction temporarily Banned")]
+	TemporarilyBanned,
+
+	#[error("[{0:?}] Already imported")]
+	AlreadyImported(Box<dyn std::any::Any + Send + Sync>),
+
+	#[error("Too low priority ({} > {})", old, new)]
+	TooLowPriority {
+		/// Transaction already in the pool.
+		old: Priority,
+		/// Transaction entering the pool.
+		new: Priority,
+	},
+	#[error("Transaction with cyclic dependency")]
+	CycleDetected,
+
+	#[error("Transaction couldn't enter the pool because of the limit")]
+	ImmediatelyDropped,
+
+	#[error("Transaction cannot be propagated and the local node does not author blocks")]
+	Unactionable,
+
+	#[error("{0}")]
+	InvalidBlockId(String),
+
+	#[error("The pool is not accepting future transactions")]
+	RejectedFutureTransaction,
+}
+
+/// Transaction pool error conversion.
+pub trait IntoPoolError: std::error::Error + Send + Sized + Sync {
+	/// Try to extract original `Error`
+	///
+	/// This implementation is optional and used only to
+	/// provide more descriptive error messages for end users
+	/// of RPC API.
+	fn into_pool_error(self) -> std::result::Result<Error, Self> {
+		Err(self)
+	}
+}
+
+impl IntoPoolError for Error {
+	fn into_pool_error(self) -> std::result::Result<Error, Self> {
+		Ok(self)
+	}
+}
diff --git a/substrate/client/transaction-pool/api/src/lib.rs b/substrate/client/transaction-pool/api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..32fe30f4584f0cabb9b0cc834a9d90c632bcc7ca
--- /dev/null
+++ b/substrate/client/transaction-pool/api/src/lib.rs
@@ -0,0 +1,522 @@
+// 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/>.
+
+//! Transaction pool client facing API.
+#![warn(missing_docs)]
+
+pub mod error;
+
+use async_trait::async_trait;
+use futures::{Future, Stream};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use sp_core::offchain::TransactionPoolExt;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Member, NumberFor},
+};
+use std::{collections::HashMap, hash::Hash, marker::PhantomData, pin::Pin, sync::Arc};
+
+const LOG_TARGET: &str = "txpool::api";
+
+pub use sp_runtime::transaction_validity::{
+	TransactionLongevity, TransactionPriority, TransactionSource, TransactionTag,
+};
+
+/// Transaction pool status.
+#[derive(Debug)]
+pub struct PoolStatus {
+	/// Number of transactions in the ready queue.
+	pub ready: usize,
+	/// Sum of bytes of ready transaction encodings.
+	pub ready_bytes: usize,
+	/// Number of transactions in the future queue.
+	pub future: usize,
+	/// Sum of bytes of ready transaction encodings.
+	pub future_bytes: usize,
+}
+
+impl PoolStatus {
+	/// Returns true if the are no transactions in the pool.
+	pub fn is_empty(&self) -> bool {
+		self.ready == 0 && self.future == 0
+	}
+}
+
+/// Possible transaction status events.
+///
+/// This events are being emitted by `TransactionPool` watchers,
+/// which are also exposed over RPC.
+///
+/// The status events can be grouped based on their kinds as:
+/// 1. Entering/Moving within the pool:
+/// 		- `Future`
+/// 		- `Ready`
+/// 2. Inside `Ready` queue:
+/// 		- `Broadcast`
+/// 3. Leaving the pool:
+/// 		- `InBlock`
+/// 		- `Invalid`
+/// 		- `Usurped`
+/// 		- `Dropped`
+/// 	4. Re-entering the pool:
+/// 		- `Retracted`
+/// 	5. Block finalized:
+/// 		- `Finalized`
+/// 		- `FinalityTimeout`
+///
+/// The events will always be received in the order described above, however
+/// there might be cases where transactions alternate between `Future` and `Ready`
+/// pool, and are `Broadcast` in the meantime.
+///
+/// There is also only single event causing the transaction to leave the pool.
+/// I.e. only one of the listed ones should be triggered.
+///
+/// Note that there are conditions that may cause transactions to reappear in the pool.
+/// 1. Due to possible forks, the transaction that ends up being in included
+/// in one block, may later re-enter the pool or be marked as invalid.
+/// 2. Transaction `Dropped` at one point, may later re-enter the pool if some other
+/// transactions are removed.
+/// 3. `Invalid` transaction may become valid at some point in the future.
+/// (Note that runtimes are encouraged to use `UnknownValidity` to inform the pool about
+/// such case).
+/// 4. `Retracted` transactions might be included in some next block.
+///
+/// The stream is considered finished only when either `Finalized` or `FinalityTimeout`
+/// event is triggered. You are however free to unsubscribe from notifications at any point.
+/// The first one will be emitted when the block, in which transaction was included gets
+/// finalized. The `FinalityTimeout` event will be emitted when the block did not reach finality
+/// within 512 blocks. This either indicates that finality is not available for your chain,
+/// or that finality gadget is lagging behind. If you choose to wait for finality longer, you can
+/// re-subscribe for a particular transaction hash manually again.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TransactionStatus<Hash, BlockHash> {
+	/// Transaction is part of the future queue.
+	Future,
+	/// Transaction is part of the ready queue.
+	Ready,
+	/// The transaction has been broadcast to the given peers.
+	Broadcast(Vec<String>),
+	/// Transaction has been included in block with given hash
+	/// at the given position.
+	#[serde(with = "v1_compatible")]
+	InBlock((BlockHash, TxIndex)),
+	/// The block this transaction was included in has been retracted.
+	Retracted(BlockHash),
+	/// Maximum number of finality watchers has been reached,
+	/// old watchers are being removed.
+	FinalityTimeout(BlockHash),
+	/// Transaction has been finalized by a finality-gadget, e.g GRANDPA.
+	#[serde(with = "v1_compatible")]
+	Finalized((BlockHash, TxIndex)),
+	/// Transaction has been replaced in the pool, by another transaction
+	/// that provides the same tags. (e.g. same (sender, nonce)).
+	Usurped(Hash),
+	/// Transaction has been dropped from the pool because of the limit.
+	Dropped,
+	/// Transaction is no longer valid in the current state.
+	Invalid,
+}
+
+/// The stream of transaction events.
+pub type TransactionStatusStream<Hash, BlockHash> =
+	dyn Stream<Item = TransactionStatus<Hash, BlockHash>> + Send;
+
+/// The import notification event stream.
+pub type ImportNotificationStream<H> = futures::channel::mpsc::Receiver<H>;
+
+/// Transaction hash type for a pool.
+pub type TxHash<P> = <P as TransactionPool>::Hash;
+/// Block hash type for a pool.
+pub type BlockHash<P> = <<P as TransactionPool>::Block as BlockT>::Hash;
+/// Transaction type for a pool.
+pub type TransactionFor<P> = <<P as TransactionPool>::Block as BlockT>::Extrinsic;
+/// Type of transactions event stream for a pool.
+pub type TransactionStatusStreamFor<P> = TransactionStatusStream<TxHash<P>, BlockHash<P>>;
+/// Transaction type for a local pool.
+pub type LocalTransactionFor<P> = <<P as LocalTransactionPool>::Block as BlockT>::Extrinsic;
+/// Transaction's index within the block in which it was included.
+pub type TxIndex = usize;
+
+/// Typical future type used in transaction pool api.
+pub type PoolFuture<T, E> = std::pin::Pin<Box<dyn Future<Output = Result<T, E>> + Send>>;
+
+/// In-pool transaction interface.
+///
+/// The pool is container of transactions that are implementing this trait.
+/// See `sp_runtime::ValidTransaction` for details about every field.
+pub trait InPoolTransaction {
+	/// Transaction type.
+	type Transaction;
+	/// Transaction hash type.
+	type Hash;
+
+	/// Get the reference to the transaction data.
+	fn data(&self) -> &Self::Transaction;
+	/// Get hash of the transaction.
+	fn hash(&self) -> &Self::Hash;
+	/// Get priority of the transaction.
+	fn priority(&self) -> &TransactionPriority;
+	/// Get longevity of the transaction.
+	fn longevity(&self) -> &TransactionLongevity;
+	/// Get transaction dependencies.
+	fn requires(&self) -> &[TransactionTag];
+	/// Get tags that transaction provides.
+	fn provides(&self) -> &[TransactionTag];
+	/// Return a flag indicating if the transaction should be propagated to other peers.
+	fn is_propagable(&self) -> bool;
+}
+
+/// Transaction pool interface.
+pub trait TransactionPool: Send + Sync {
+	/// Block type.
+	type Block: BlockT;
+	/// Transaction hash type.
+	type Hash: Hash + Eq + Member + Serialize + DeserializeOwned;
+	/// In-pool transaction type.
+	type InPoolTransaction: InPoolTransaction<
+		Transaction = TransactionFor<Self>,
+		Hash = TxHash<Self>,
+	>;
+	/// Error type.
+	type Error: From<crate::error::Error> + crate::error::IntoPoolError;
+
+	// *** RPC
+
+	/// Returns a future that imports a bunch of unverified transactions to the pool.
+	fn submit_at(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		xts: Vec<TransactionFor<Self>>,
+	) -> PoolFuture<Vec<Result<TxHash<Self>, Self::Error>>, Self::Error>;
+
+	/// Returns a future that imports one unverified transaction to the pool.
+	fn submit_one(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		xt: TransactionFor<Self>,
+	) -> PoolFuture<TxHash<Self>, Self::Error>;
+
+	/// Returns a future that import a single transaction and starts to watch their progress in the
+	/// pool.
+	fn submit_and_watch(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		xt: TransactionFor<Self>,
+	) -> PoolFuture<Pin<Box<TransactionStatusStreamFor<Self>>>, Self::Error>;
+
+	// *** Block production / Networking
+	/// Get an iterator for ready transactions ordered by priority.
+	///
+	/// Guarantees to return only when transaction pool got updated at `at` block.
+	/// Guarantees to return immediately when `None` is passed.
+	fn ready_at(
+		&self,
+		at: NumberFor<Self::Block>,
+	) -> Pin<
+		Box<
+			dyn Future<
+					Output = Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>,
+				> + Send,
+		>,
+	>;
+
+	/// Get an iterator for ready transactions ordered by priority.
+	fn ready(&self) -> Box<dyn ReadyTransactions<Item = Arc<Self::InPoolTransaction>> + Send>;
+
+	// *** Block production
+	/// Remove transactions identified by given hashes (and dependent transactions) from the pool.
+	fn remove_invalid(&self, hashes: &[TxHash<Self>]) -> Vec<Arc<Self::InPoolTransaction>>;
+
+	// *** logging
+	/// Returns pool status.
+	fn status(&self) -> PoolStatus;
+
+	// *** logging / RPC / networking
+	/// Return an event stream of transactions imported to the pool.
+	fn import_notification_stream(&self) -> ImportNotificationStream<TxHash<Self>>;
+
+	// *** networking
+	/// Notify the pool about transactions broadcast.
+	fn on_broadcasted(&self, propagations: HashMap<TxHash<Self>, Vec<String>>);
+
+	/// Returns transaction hash
+	fn hash_of(&self, xt: &TransactionFor<Self>) -> TxHash<Self>;
+
+	/// Return specific ready transaction by hash, if there is one.
+	fn ready_transaction(&self, hash: &TxHash<Self>) -> Option<Arc<Self::InPoolTransaction>>;
+}
+
+/// An iterator of ready transactions.
+///
+/// The trait extends regular [`std::iter::Iterator`] trait and allows reporting
+/// last-returned element as invalid.
+///
+/// The implementation is then allowed, for performance reasons, to change the elements
+/// returned next, by e.g.  skipping elements that are known to depend on the reported
+/// transaction, which yields them invalid as well.
+pub trait ReadyTransactions: Iterator {
+	/// Report given transaction as invalid.
+	///
+	/// This might affect subsequent elements returned by the iterator, so dependent transactions
+	/// are skipped for performance reasons.
+	fn report_invalid(&mut self, _tx: &Self::Item);
+}
+
+/// A no-op implementation for an empty iterator.
+impl<T> ReadyTransactions for std::iter::Empty<T> {
+	fn report_invalid(&mut self, _tx: &T) {}
+}
+
+/// Events that the transaction pool listens for.
+pub enum ChainEvent<B: BlockT> {
+	/// New best block have been added to the chain.
+	NewBestBlock {
+		/// Hash of the block.
+		hash: B::Hash,
+		/// Tree route from old best to new best parent that was calculated on import.
+		///
+		/// If `None`, no re-org happened on import.
+		tree_route: Option<Arc<sp_blockchain::TreeRoute<B>>>,
+	},
+	/// An existing block has been finalized.
+	Finalized {
+		/// Hash of just finalized block.
+		hash: B::Hash,
+		/// Path from old finalized to new finalized parent.
+		tree_route: Arc<[B::Hash]>,
+	},
+}
+
+impl<B: BlockT> ChainEvent<B> {
+	/// Returns the block hash associated to the event.
+	pub fn hash(&self) -> B::Hash {
+		match self {
+			Self::NewBestBlock { hash, .. } | Self::Finalized { hash, .. } => *hash,
+		}
+	}
+
+	/// Is `self == Self::Finalized`?
+	pub fn is_finalized(&self) -> bool {
+		matches!(self, Self::Finalized { .. })
+	}
+}
+
+/// Trait for transaction pool maintenance.
+#[async_trait]
+pub trait MaintainedTransactionPool: TransactionPool {
+	/// Perform maintenance
+	async fn maintain(&self, event: ChainEvent<Self::Block>);
+}
+
+/// Transaction pool interface for submitting local transactions that exposes a
+/// blocking interface for submission.
+pub trait LocalTransactionPool: Send + Sync {
+	/// Block type.
+	type Block: BlockT;
+	/// Transaction hash type.
+	type Hash: Hash + Eq + Member + Serialize;
+	/// Error type.
+	type Error: From<crate::error::Error> + crate::error::IntoPoolError;
+
+	/// Submits the given local unverified transaction to the pool blocking the
+	/// current thread for any necessary pre-verification.
+	/// NOTE: It MUST NOT be used for transactions that originate from the
+	/// network or RPC, since the validation is performed with
+	/// `TransactionSource::Local`.
+	fn submit_local(
+		&self,
+		at: <Self::Block as BlockT>::Hash,
+		xt: LocalTransactionFor<Self>,
+	) -> Result<Self::Hash, Self::Error>;
+}
+
+impl<T: LocalTransactionPool> LocalTransactionPool for Arc<T> {
+	type Block = T::Block;
+
+	type Hash = T::Hash;
+
+	type Error = T::Error;
+
+	fn submit_local(
+		&self,
+		at: <Self::Block as BlockT>::Hash,
+		xt: LocalTransactionFor<Self>,
+	) -> Result<Self::Hash, Self::Error> {
+		(**self).submit_local(at, xt)
+	}
+}
+
+/// An abstraction for [`LocalTransactionPool`]
+///
+/// We want to use a transaction pool in [`OffchainTransactionPoolFactory`] in a `Arc` without
+/// bleeding the associated types besides the `Block`. Thus, this abstraction here exists to achieve
+/// the wrapping in a `Arc`.
+trait OffchainSubmitTransaction<Block: BlockT>: Send + Sync {
+	/// Submit transaction.
+	///
+	/// The transaction will end up in the pool and be propagated to others.
+	fn submit_at(&self, at: Block::Hash, extrinsic: Block::Extrinsic) -> Result<(), ()>;
+}
+
+impl<TPool: LocalTransactionPool> OffchainSubmitTransaction<TPool::Block> for TPool {
+	fn submit_at(
+		&self,
+		at: <TPool::Block as BlockT>::Hash,
+		extrinsic: <TPool::Block as BlockT>::Extrinsic,
+	) -> Result<(), ()> {
+		log::debug!(
+			target: LOG_TARGET,
+			"(offchain call) Submitting a transaction to the pool: {:?}",
+			extrinsic
+		);
+
+		let result = self.submit_local(at, extrinsic);
+
+		result.map(|_| ()).map_err(|e| {
+			log::warn!(
+				target: LOG_TARGET,
+				"(offchain call) Error submitting a transaction to the pool: {}",
+				e
+			)
+		})
+	}
+}
+
+/// Factory for creating [`TransactionPoolExt`]s.
+///
+/// This provides an easy way for creating [`TransactionPoolExt`] extensions for registering them in
+/// the wasm execution environment to send transactions from an offchain call to the  runtime.
+#[derive(Clone)]
+pub struct OffchainTransactionPoolFactory<Block: BlockT> {
+	pool: Arc<dyn OffchainSubmitTransaction<Block>>,
+}
+
+impl<Block: BlockT> OffchainTransactionPoolFactory<Block> {
+	/// Creates a new instance using the given `tx_pool`.
+	pub fn new<T: LocalTransactionPool<Block = Block> + 'static>(tx_pool: T) -> Self {
+		Self { pool: Arc::new(tx_pool) as Arc<_> }
+	}
+
+	/// Returns an instance of [`TransactionPoolExt`] bound to the given `block_hash`.
+	///
+	/// Transactions that are being submitted by this instance will be submitted with `block_hash`
+	/// as context for validation.
+	pub fn offchain_transaction_pool(&self, block_hash: Block::Hash) -> TransactionPoolExt {
+		TransactionPoolExt::new(OffchainTransactionPool { pool: self.pool.clone(), block_hash })
+	}
+}
+
+/// Wraps a `pool` and `block_hash` to implement [`sp_core::offchain::TransactionPool`].
+struct OffchainTransactionPool<Block: BlockT> {
+	block_hash: Block::Hash,
+	pool: Arc<dyn OffchainSubmitTransaction<Block>>,
+}
+
+impl<Block: BlockT> sp_core::offchain::TransactionPool for OffchainTransactionPool<Block> {
+	fn submit_transaction(&mut self, extrinsic: Vec<u8>) -> Result<(), ()> {
+		let extrinsic = match codec::Decode::decode(&mut &extrinsic[..]) {
+			Ok(t) => t,
+			Err(e) => {
+				log::error!(
+					target: LOG_TARGET,
+					"Failed to decode extrinsic in `OffchainTransactionPool::submit_transaction`: {e:?}"
+				);
+
+				return Err(())
+			},
+		};
+
+		self.pool.submit_at(self.block_hash, extrinsic)
+	}
+}
+
+/// Wrapper functions to keep the API backwards compatible over the wire for the old RPC spec.
+mod v1_compatible {
+	use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+	pub fn serialize<S, H>(data: &(H, usize), serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+		H: Serialize,
+	{
+		let (hash, _) = data;
+		serde::Serialize::serialize(&hash, serializer)
+	}
+
+	pub fn deserialize<'de, D, H>(deserializer: D) -> Result<(H, usize), D::Error>
+	where
+		D: Deserializer<'de>,
+		H: Deserialize<'de>,
+	{
+		let hash: H = serde::Deserialize::deserialize(deserializer)?;
+		Ok((hash, 0))
+	}
+}
+
+/// Transaction pool that rejects all submitted transactions.
+///
+/// Could be used for example in tests.
+pub struct RejectAllTxPool<Block>(PhantomData<Block>);
+
+impl<Block> Default for RejectAllTxPool<Block> {
+	fn default() -> Self {
+		Self(PhantomData)
+	}
+}
+
+impl<Block: BlockT> LocalTransactionPool for RejectAllTxPool<Block> {
+	type Block = Block;
+
+	type Hash = Block::Hash;
+
+	type Error = error::Error;
+
+	fn submit_local(&self, _: Block::Hash, _: Block::Extrinsic) -> Result<Self::Hash, Self::Error> {
+		Err(error::Error::ImmediatelyDropped)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn tx_status_compatibility() {
+		let event: TransactionStatus<u8, u8> = TransactionStatus::InBlock((1, 2));
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"inBlock":1}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionStatus<u8, u8> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, TransactionStatus::InBlock((1, 0)));
+
+		let event: TransactionStatus<u8, u8> = TransactionStatus::Finalized((1, 2));
+		let ser = serde_json::to_string(&event).unwrap();
+
+		let exp = r#"{"finalized":1}"#;
+		assert_eq!(ser, exp);
+
+		let event_dec: TransactionStatus<u8, u8> = serde_json::from_str(exp).unwrap();
+		assert_eq!(event_dec, TransactionStatus::Finalized((1, 0)));
+	}
+}
diff --git a/substrate/client/transaction-pool/benches/basics.rs b/substrate/client/transaction-pool/benches/basics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d114acc343d500909ac3c64cae8580bcad922c66
--- /dev/null
+++ b/substrate/client/transaction-pool/benches/basics.rs
@@ -0,0 +1,193 @@
+// 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 criterion::{criterion_group, criterion_main, Criterion};
+
+use codec::Encode;
+use futures::{
+	executor::block_on,
+	future::{ready, Ready},
+};
+use sc_transaction_pool::*;
+use sp_core::blake2_256;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, NumberFor},
+	transaction_validity::{
+		InvalidTransaction, TransactionSource, TransactionTag as Tag, TransactionValidity,
+		ValidTransaction,
+	},
+};
+use substrate_test_runtime::{AccountId, Block, Extrinsic, ExtrinsicBuilder, TransferData, H256};
+
+#[derive(Clone, Debug, Default)]
+struct TestApi {
+	nonce_dependant: bool,
+}
+
+impl TestApi {
+	fn new_dependant() -> Self {
+		TestApi { nonce_dependant: true }
+	}
+}
+
+fn to_tag(nonce: u64, from: AccountId) -> Tag {
+	let mut data = [0u8; 40];
+	data[..8].copy_from_slice(&nonce.to_le_bytes()[..]);
+	data[8..].copy_from_slice(&from.0[..]);
+	data.to_vec()
+}
+
+impl ChainApi for TestApi {
+	type Block = Block;
+	type Error = sc_transaction_pool_api::error::Error;
+	type ValidationFuture = Ready<sc_transaction_pool_api::error::Result<TransactionValidity>>;
+	type BodyFuture = Ready<sc_transaction_pool_api::error::Result<Option<Vec<Extrinsic>>>>;
+
+	fn validate_transaction(
+		&self,
+		at: &BlockId<Self::Block>,
+		_source: TransactionSource,
+		uxt: <Self::Block as BlockT>::Extrinsic,
+	) -> Self::ValidationFuture {
+		let transfer = TransferData::try_from(&uxt)
+			.expect("uxt is expected to be bench_call (carrying TransferData)");
+		let nonce = transfer.nonce;
+		let from = transfer.from;
+
+		match self.block_id_to_number(at) {
+			Ok(Some(num)) if num > 5 => return ready(Ok(Err(InvalidTransaction::Stale.into()))),
+			_ => {},
+		}
+
+		ready(Ok(Ok(ValidTransaction {
+			priority: 4,
+			requires: if nonce > 1 && self.nonce_dependant {
+				vec![to_tag(nonce - 1, from)]
+			} else {
+				vec![]
+			},
+			provides: vec![to_tag(nonce, from)],
+			longevity: 10,
+			propagate: true,
+		})))
+	}
+
+	fn block_id_to_number(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<NumberFor<Self::Block>>, Self::Error> {
+		Ok(match at {
+			BlockId::Number(num) => Some(*num),
+			BlockId::Hash(_) => None,
+		})
+	}
+
+	fn block_id_to_hash(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<<Self::Block as BlockT>::Hash>, Self::Error> {
+		Ok(match at {
+			BlockId::Number(num) => Some(H256::from_low_u64_be(*num)).into(),
+			BlockId::Hash(_) => None,
+		})
+	}
+
+	fn hash_and_length(&self, uxt: &<Self::Block as BlockT>::Extrinsic) -> (H256, usize) {
+		let encoded = uxt.encode();
+		(blake2_256(&encoded).into(), encoded.len())
+	}
+
+	fn block_body(&self, _id: <Self::Block as BlockT>::Hash) -> Self::BodyFuture {
+		ready(Ok(None))
+	}
+
+	fn block_header(
+		&self,
+		_: <Self::Block as BlockT>::Hash,
+	) -> Result<Option<<Self::Block as BlockT>::Header>, Self::Error> {
+		Ok(None)
+	}
+
+	fn tree_route(
+		&self,
+		_from: <Self::Block as BlockT>::Hash,
+		_to: <Self::Block as BlockT>::Hash,
+	) -> Result<sp_blockchain::TreeRoute<Self::Block>, Self::Error> {
+		unimplemented!()
+	}
+}
+
+fn uxt(transfer: TransferData) -> Extrinsic {
+	ExtrinsicBuilder::new_bench_call(transfer).build()
+}
+
+fn bench_configured(pool: Pool<TestApi>, number: u64) {
+	let source = TransactionSource::External;
+	let mut futures = Vec::new();
+	let mut tags = Vec::new();
+
+	for nonce in 1..=number {
+		let xt = uxt(TransferData {
+			from: AccountId::from_h256(H256::from_low_u64_be(1)),
+			to: AccountId::from_h256(H256::from_low_u64_be(2)),
+			amount: 5,
+			nonce,
+		});
+
+		tags.push(to_tag(nonce, AccountId::from_h256(H256::from_low_u64_be(1))));
+		futures.push(pool.submit_one(&BlockId::Number(1), source, xt));
+	}
+
+	let res = block_on(futures::future::join_all(futures.into_iter()));
+	assert!(res.iter().all(Result::is_ok));
+
+	assert_eq!(pool.validated_pool().status().future, 0);
+	assert_eq!(pool.validated_pool().status().ready, number as usize);
+
+	// Prune all transactions.
+	let block_num = 6;
+	block_on(pool.prune_tags(&BlockId::Number(block_num), tags, vec![])).expect("Prune failed");
+
+	// pool is empty
+	assert_eq!(pool.validated_pool().status().ready, 0);
+	assert_eq!(pool.validated_pool().status().future, 0);
+}
+
+fn benchmark_main(c: &mut Criterion) {
+	c.bench_function("sequential 50 tx", |b| {
+		b.iter(|| {
+			bench_configured(
+				Pool::new(Default::default(), true.into(), TestApi::new_dependant().into()),
+				50,
+			);
+		});
+	});
+
+	c.bench_function("random 100 tx", |b| {
+		b.iter(|| {
+			bench_configured(
+				Pool::new(Default::default(), true.into(), TestApi::default().into()),
+				100,
+			);
+		});
+	});
+}
+
+criterion_group!(benches, benchmark_main);
+criterion_main!(benches);
diff --git a/substrate/client/transaction-pool/src/api.rs b/substrate/client/transaction-pool/src/api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..871d8e9c81707b9fd3454ce201f898de692f76df
--- /dev/null
+++ b/substrate/client/transaction-pool/src/api.rs
@@ -0,0 +1,303 @@
+// 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/>.
+
+//! Chain api required for the transaction pool.
+
+use crate::LOG_TARGET;
+use codec::Encode;
+use futures::{
+	channel::{mpsc, oneshot},
+	future::{ready, Future, FutureExt, Ready},
+	lock::Mutex,
+	SinkExt, StreamExt,
+};
+use std::{marker::PhantomData, pin::Pin, sync::Arc};
+
+use prometheus_endpoint::Registry as PrometheusRegistry;
+use sc_client_api::{blockchain::HeaderBackend, BlockBackend};
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_blockchain::{HeaderMetadata, TreeRoute};
+use sp_core::traits::SpawnEssentialNamed;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{self, Block as BlockT, BlockIdTo},
+	transaction_validity::{TransactionSource, TransactionValidity},
+};
+use sp_transaction_pool::runtime_api::TaggedTransactionQueue;
+
+use crate::{
+	error::{self, Error},
+	graph,
+	metrics::{ApiMetrics, ApiMetricsExt},
+};
+
+/// The transaction pool logic for full client.
+pub struct FullChainApi<Client, Block> {
+	client: Arc<Client>,
+	_marker: PhantomData<Block>,
+	metrics: Option<Arc<ApiMetrics>>,
+	validation_pool: Arc<Mutex<mpsc::Sender<Pin<Box<dyn Future<Output = ()> + Send>>>>>,
+}
+
+/// Spawn a validation task that will be used by the transaction pool to validate transactions.
+fn spawn_validation_pool_task(
+	name: &'static str,
+	receiver: Arc<Mutex<mpsc::Receiver<Pin<Box<dyn Future<Output = ()> + Send>>>>>,
+	spawner: &impl SpawnEssentialNamed,
+) {
+	spawner.spawn_essential_blocking(
+		name,
+		Some("transaction-pool"),
+		async move {
+			loop {
+				let task = receiver.lock().await.next().await;
+				match task {
+					None => return,
+					Some(task) => task.await,
+				}
+			}
+		}
+		.boxed(),
+	);
+}
+
+impl<Client, Block> FullChainApi<Client, Block> {
+	/// Create new transaction pool logic.
+	pub fn new(
+		client: Arc<Client>,
+		prometheus: Option<&PrometheusRegistry>,
+		spawner: &impl SpawnEssentialNamed,
+	) -> Self {
+		let metrics = prometheus.map(ApiMetrics::register).and_then(|r| match r {
+			Err(err) => {
+				log::warn!(
+					target: LOG_TARGET,
+					"Failed to register transaction pool api prometheus metrics: {:?}",
+					err,
+				);
+				None
+			},
+			Ok(api) => Some(Arc::new(api)),
+		});
+
+		let (sender, receiver) = mpsc::channel(0);
+
+		let receiver = Arc::new(Mutex::new(receiver));
+		spawn_validation_pool_task("transaction-pool-task-0", receiver.clone(), spawner);
+		spawn_validation_pool_task("transaction-pool-task-1", receiver, spawner);
+
+		FullChainApi {
+			client,
+			validation_pool: Arc::new(Mutex::new(sender)),
+			_marker: Default::default(),
+			metrics,
+		}
+	}
+}
+
+impl<Client, Block> graph::ChainApi for FullChainApi<Client, Block>
+where
+	Block: BlockT,
+	Client: ProvideRuntimeApi<Block>
+		+ BlockBackend<Block>
+		+ BlockIdTo<Block>
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>,
+	Client: Send + Sync + 'static,
+	Client::Api: TaggedTransactionQueue<Block>,
+{
+	type Block = Block;
+	type Error = error::Error;
+	type ValidationFuture =
+		Pin<Box<dyn Future<Output = error::Result<TransactionValidity>> + Send>>;
+	type BodyFuture = Ready<error::Result<Option<Vec<<Self::Block as BlockT>::Extrinsic>>>>;
+
+	fn block_body(&self, hash: Block::Hash) -> Self::BodyFuture {
+		ready(self.client.block_body(hash).map_err(error::Error::from))
+	}
+
+	fn validate_transaction(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		uxt: graph::ExtrinsicFor<Self>,
+	) -> Self::ValidationFuture {
+		let (tx, rx) = oneshot::channel();
+		let client = self.client.clone();
+		let at = *at;
+		let validation_pool = self.validation_pool.clone();
+		let metrics = self.metrics.clone();
+
+		async move {
+			metrics.report(|m| m.validations_scheduled.inc());
+
+			validation_pool
+				.lock()
+				.await
+				.send(
+					async move {
+						let res = validate_transaction_blocking(&*client, &at, source, uxt);
+						let _ = tx.send(res);
+						metrics.report(|m| m.validations_finished.inc());
+					}
+					.boxed(),
+				)
+				.await
+				.map_err(|e| Error::RuntimeApi(format!("Validation pool down: {:?}", e)))?;
+
+			match rx.await {
+				Ok(r) => r,
+				Err(_) => Err(Error::RuntimeApi("Validation was canceled".into())),
+			}
+		}
+		.boxed()
+	}
+
+	fn block_id_to_number(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> error::Result<Option<graph::NumberFor<Self>>> {
+		self.client.to_number(at).map_err(|e| Error::BlockIdConversion(e.to_string()))
+	}
+
+	fn block_id_to_hash(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> error::Result<Option<graph::BlockHash<Self>>> {
+		self.client.to_hash(at).map_err(|e| Error::BlockIdConversion(e.to_string()))
+	}
+
+	fn hash_and_length(
+		&self,
+		ex: &graph::ExtrinsicFor<Self>,
+	) -> (graph::ExtrinsicHash<Self>, usize) {
+		ex.using_encoded(|x| (<traits::HashingFor<Block> as traits::Hash>::hash(x), x.len()))
+	}
+
+	fn block_header(
+		&self,
+		hash: <Self::Block as BlockT>::Hash,
+	) -> Result<Option<<Self::Block as BlockT>::Header>, Self::Error> {
+		self.client.header(hash).map_err(Into::into)
+	}
+
+	fn tree_route(
+		&self,
+		from: <Self::Block as BlockT>::Hash,
+		to: <Self::Block as BlockT>::Hash,
+	) -> Result<TreeRoute<Self::Block>, Self::Error> {
+		sp_blockchain::tree_route::<Block, Client>(&*self.client, from, to).map_err(Into::into)
+	}
+}
+
+/// Helper function to validate a transaction using a full chain API.
+/// This method will call into the runtime to perform the validation.
+fn validate_transaction_blocking<Client, Block>(
+	client: &Client,
+	at: &BlockId<Block>,
+	source: TransactionSource,
+	uxt: graph::ExtrinsicFor<FullChainApi<Client, Block>>,
+) -> error::Result<TransactionValidity>
+where
+	Block: BlockT,
+	Client: ProvideRuntimeApi<Block>
+		+ BlockBackend<Block>
+		+ BlockIdTo<Block>
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>,
+	Client: Send + Sync + 'static,
+	Client::Api: TaggedTransactionQueue<Block>,
+{
+	sp_tracing::within_span!(sp_tracing::Level::TRACE, "validate_transaction";
+	{
+		let block_hash = client.to_hash(at)
+			.map_err(|e| Error::RuntimeApi(e.to_string()))?
+			.ok_or_else(|| Error::RuntimeApi(format!("Could not get hash for block `{:?}`.", at)))?;
+
+		let runtime_api = client.runtime_api();
+		let api_version = sp_tracing::within_span! { sp_tracing::Level::TRACE, "check_version";
+			runtime_api
+				.api_version::<dyn TaggedTransactionQueue<Block>>(block_hash)
+				.map_err(|e| Error::RuntimeApi(e.to_string()))?
+				.ok_or_else(|| Error::RuntimeApi(
+					format!("Could not find `TaggedTransactionQueue` api for block `{:?}`.", at)
+				))
+		}?;
+
+		use sp_api::Core;
+
+		sp_tracing::within_span!(
+			sp_tracing::Level::TRACE, "runtime::validate_transaction";
+		{
+			if api_version >= 3 {
+				runtime_api.validate_transaction(block_hash, source, uxt, block_hash)
+					.map_err(|e| Error::RuntimeApi(e.to_string()))
+			} else {
+				let block_number = client.to_number(at)
+					.map_err(|e| Error::RuntimeApi(e.to_string()))?
+					.ok_or_else(||
+						Error::RuntimeApi(format!("Could not get number for block `{:?}`.", at))
+					)?;
+
+				// The old versions require us to call `initialize_block` before.
+				runtime_api.initialize_block(block_hash, &sp_runtime::traits::Header::new(
+					block_number + sp_runtime::traits::One::one(),
+					Default::default(),
+					Default::default(),
+					block_hash,
+					Default::default()),
+				).map_err(|e| Error::RuntimeApi(e.to_string()))?;
+
+				if api_version == 2 {
+					#[allow(deprecated)] // old validate_transaction
+					runtime_api.validate_transaction_before_version_3(block_hash, source, uxt)
+						.map_err(|e| Error::RuntimeApi(e.to_string()))
+				} else {
+					#[allow(deprecated)] // old validate_transaction
+					runtime_api.validate_transaction_before_version_2(block_hash, uxt)
+						.map_err(|e| Error::RuntimeApi(e.to_string()))
+				}
+			}
+		})
+	})
+}
+
+impl<Client, Block> FullChainApi<Client, Block>
+where
+	Block: BlockT,
+	Client: ProvideRuntimeApi<Block>
+		+ BlockBackend<Block>
+		+ BlockIdTo<Block>
+		+ HeaderBackend<Block>
+		+ HeaderMetadata<Block, Error = sp_blockchain::Error>,
+	Client: Send + Sync + 'static,
+	Client::Api: TaggedTransactionQueue<Block>,
+{
+	/// Validates a transaction by calling into the runtime, same as
+	/// `validate_transaction` but blocks the current thread when performing
+	/// validation. Only implemented for `FullChainApi` since we can call into
+	/// the runtime locally.
+	pub fn validate_transaction_blocking(
+		&self,
+		at: &BlockId<Block>,
+		source: TransactionSource,
+		uxt: graph::ExtrinsicFor<Self>,
+	) -> error::Result<TransactionValidity> {
+		validate_transaction_blocking(&*self.client, at, source, uxt)
+	}
+}
diff --git a/substrate/client/transaction-pool/src/enactment_state.rs b/substrate/client/transaction-pool/src/enactment_state.rs
new file mode 100644
index 0000000000000000000000000000000000000000..85c572c127e84688ba68cee0329efffbb78043f3
--- /dev/null
+++ b/substrate/client/transaction-pool/src/enactment_state.rs
@@ -0,0 +1,703 @@
+// 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/>.
+
+//! Substrate transaction pool implementation.
+
+use crate::LOG_TARGET;
+use sc_transaction_pool_api::ChainEvent;
+use sp_blockchain::TreeRoute;
+use sp_runtime::traits::{Block as BlockT, NumberFor, Saturating};
+
+/// The threshold since the last update where we will skip any maintenance for blocks.
+///
+/// This includes tracking re-orgs and sending out certain notifications. In general this shouldn't
+/// happen and may only happen when the node is doing a full sync.
+const SKIP_MAINTENANCE_THRESHOLD: u16 = 20;
+
+/// Helper struct for keeping track of the current state of processed new best
+/// block and finalized events. The main purpose of keeping track of this state
+/// is to figure out which phases (enactment / finalization) of transaction pool
+/// maintenance are needed.
+///
+/// Given the following chain:
+///
+///   B1-C1-D1-E1
+///  /
+/// A
+///  \
+///   B2-C2-D2-E2
+///
+/// Some scenarios and expected behavior for sequence of `NewBestBlock` (`nbb`) and `Finalized`
+/// (`f`) events:
+///
+/// - `nbb(C1)`, `f(C1)` -> false (enactment was already performed in `nbb(C1))`
+/// - `f(C1)`, `nbb(C1)` -> false (enactment was already performed in `f(C1))`
+/// - `f(C1)`, `nbb(D2)` -> false (enactment was already performed in `f(C1)`,
+/// we should not retract finalized block)
+/// - `f(C1)`, `f(C2)`, `nbb(C1)` -> false
+/// - `nbb(C1)`, `nbb(C2)` -> true (switching fork is OK)
+/// - `nbb(B1)`, `nbb(B2)` -> true
+/// - `nbb(B1)`, `nbb(C1)`, `f(C1)` -> false (enactment was already performed in `nbb(B1)`)
+/// - `nbb(C1)`, `f(B1)` -> false (enactment was already performed in `nbb(B2)`)
+pub struct EnactmentState<Block>
+where
+	Block: BlockT,
+{
+	recent_best_block: Block::Hash,
+	recent_finalized_block: Block::Hash,
+}
+
+/// Enactment action that should be performed after processing the `ChainEvent`
+#[derive(Debug)]
+pub enum EnactmentAction<Block: BlockT> {
+	/// Both phases of maintenance shall be skipped
+	Skip,
+	/// Both phases of maintenance shall be performed
+	HandleEnactment(TreeRoute<Block>),
+	/// Enactment phase of maintenance shall be skipped
+	HandleFinalization,
+}
+
+impl<Block> EnactmentState<Block>
+where
+	Block: BlockT,
+{
+	/// Returns a new `EnactmentState` initialized with the given parameters.
+	pub fn new(recent_best_block: Block::Hash, recent_finalized_block: Block::Hash) -> Self {
+		EnactmentState { recent_best_block, recent_finalized_block }
+	}
+
+	/// Returns the recently finalized block.
+	pub fn recent_finalized_block(&self) -> Block::Hash {
+		self.recent_finalized_block
+	}
+
+	/// Updates the state according to the given `ChainEvent`, returning
+	/// `Some(tree_route)` with a tree route including the blocks that need to
+	/// be enacted/retracted. If no enactment is needed then `None` is returned.
+	pub fn update<TreeRouteF, BlockNumberF>(
+		&mut self,
+		event: &ChainEvent<Block>,
+		tree_route: &TreeRouteF,
+		hash_to_number: &BlockNumberF,
+	) -> Result<EnactmentAction<Block>, String>
+	where
+		TreeRouteF: Fn(Block::Hash, Block::Hash) -> Result<TreeRoute<Block>, String>,
+		BlockNumberF: Fn(Block::Hash) -> Result<Option<NumberFor<Block>>, String>,
+	{
+		let new_hash = event.hash();
+		let finalized = event.is_finalized();
+
+		// do not proceed with txpool maintain if block distance is to high
+		let skip_maintenance =
+			match (hash_to_number(new_hash), hash_to_number(self.recent_best_block)) {
+				(Ok(Some(new)), Ok(Some(current))) =>
+					new.saturating_sub(current) > SKIP_MAINTENANCE_THRESHOLD.into(),
+				_ => true,
+			};
+
+		if skip_maintenance {
+			log::debug!(target: LOG_TARGET, "skip maintain: tree_route would be too long");
+			self.force_update(event);
+			return Ok(EnactmentAction::Skip)
+		}
+
+		// block was already finalized
+		if self.recent_finalized_block == new_hash {
+			log::debug!(target: LOG_TARGET, "handle_enactment: block already finalized");
+			return Ok(EnactmentAction::Skip)
+		}
+
+		// compute actual tree route from best_block to notified block, and use
+		// it instead of tree_route provided with event
+		let tree_route = tree_route(self.recent_best_block, new_hash)?;
+
+		log::debug!(
+			target: LOG_TARGET,
+			"resolve hash: {new_hash:?} finalized: {finalized:?} \
+			 tree_route: (common {:?}, last {:?}) best_block: {:?} finalized_block:{:?}",
+			tree_route.common_block(),
+			tree_route.last(),
+			self.recent_best_block,
+			self.recent_finalized_block
+		);
+
+		// check if recently finalized block is on retracted path. this could be
+		// happening if we first received a finalization event and then a new
+		// best event for some old stale best head.
+		if tree_route.retracted().iter().any(|x| x.hash == self.recent_finalized_block) {
+			log::debug!(
+				target: LOG_TARGET,
+				"Recently finalized block {} would be retracted by ChainEvent {}, skipping",
+				self.recent_finalized_block,
+				new_hash
+			);
+			return Ok(EnactmentAction::Skip)
+		}
+
+		if finalized {
+			self.recent_finalized_block = new_hash;
+
+			// if there are no enacted blocks in best_block -> hash tree_route,
+			// it means that block being finalized was already enacted (this
+			// case also covers best_block == new_hash), recent_best_block
+			// remains valid.
+			if tree_route.enacted().is_empty() {
+				log::trace!(
+					target: LOG_TARGET,
+					"handle_enactment: no newly enacted blocks since recent best block"
+				);
+				return Ok(EnactmentAction::HandleFinalization)
+			}
+
+			// otherwise enacted finalized block becomes best block...
+		}
+
+		self.recent_best_block = new_hash;
+
+		Ok(EnactmentAction::HandleEnactment(tree_route))
+	}
+
+	/// Forces update of the state according to the given `ChainEvent`. Intended to be used as a
+	/// fallback when tree_route cannot be computed.
+	pub fn force_update(&mut self, event: &ChainEvent<Block>) {
+		match event {
+			ChainEvent::NewBestBlock { hash, .. } => self.recent_best_block = *hash,
+			ChainEvent::Finalized { hash, .. } => self.recent_finalized_block = *hash,
+		};
+		log::debug!(
+			target: LOG_TARGET,
+			"forced update: {:?}, {:?}",
+			self.recent_best_block,
+			self.recent_finalized_block,
+		);
+	}
+}
+
+#[cfg(test)]
+mod enactment_state_tests {
+	use super::{EnactmentAction, EnactmentState};
+	use sc_transaction_pool_api::ChainEvent;
+	use sp_blockchain::{HashAndNumber, TreeRoute};
+	use sp_runtime::traits::NumberFor;
+	use std::sync::Arc;
+	use substrate_test_runtime_client::runtime::{Block, Hash};
+
+	// some helpers for convenient blocks' hash naming
+	fn a() -> HashAndNumber<Block> {
+		HashAndNumber { number: 1, hash: Hash::from([0xAA; 32]) }
+	}
+	fn b1() -> HashAndNumber<Block> {
+		HashAndNumber { number: 2, hash: Hash::from([0xB1; 32]) }
+	}
+	fn c1() -> HashAndNumber<Block> {
+		HashAndNumber { number: 3, hash: Hash::from([0xC1; 32]) }
+	}
+	fn d1() -> HashAndNumber<Block> {
+		HashAndNumber { number: 4, hash: Hash::from([0xD1; 32]) }
+	}
+	fn e1() -> HashAndNumber<Block> {
+		HashAndNumber { number: 5, hash: Hash::from([0xE1; 32]) }
+	}
+	fn x1() -> HashAndNumber<Block> {
+		HashAndNumber { number: 22, hash: Hash::from([0x1E; 32]) }
+	}
+	fn b2() -> HashAndNumber<Block> {
+		HashAndNumber { number: 2, hash: Hash::from([0xB2; 32]) }
+	}
+	fn c2() -> HashAndNumber<Block> {
+		HashAndNumber { number: 3, hash: Hash::from([0xC2; 32]) }
+	}
+	fn d2() -> HashAndNumber<Block> {
+		HashAndNumber { number: 4, hash: Hash::from([0xD2; 32]) }
+	}
+	fn e2() -> HashAndNumber<Block> {
+		HashAndNumber { number: 5, hash: Hash::from([0xE2; 32]) }
+	}
+	fn x2() -> HashAndNumber<Block> {
+		HashAndNumber { number: 22, hash: Hash::from([0x2E; 32]) }
+	}
+
+	fn test_chain() -> Vec<HashAndNumber<Block>> {
+		vec![x1(), e1(), d1(), c1(), b1(), a(), b2(), c2(), d2(), e2(), x2()]
+	}
+
+	fn block_hash_to_block_number(hash: Hash) -> Result<Option<NumberFor<Block>>, String> {
+		Ok(test_chain().iter().find(|x| x.hash == hash).map(|x| x.number))
+	}
+
+	/// mock tree_route computing function for simple two-forks chain
+	fn tree_route(from: Hash, to: Hash) -> Result<TreeRoute<Block>, String> {
+		let chain = test_chain();
+		let pivot = chain.iter().position(|x| x.number == a().number).unwrap();
+
+		let from = chain
+			.iter()
+			.position(|bn| bn.hash == from)
+			.ok_or("existing block should be given")?;
+		let to = chain
+			.iter()
+			.position(|bn| bn.hash == to)
+			.ok_or("existing block should be given")?;
+
+		//    B1-C1-D1-E1-..-X1
+		//   /
+		//  A
+		//   \
+		//    B2-C2-D2-E2-..-X2
+		//
+		//  [X1 E1 D1 C1 B1 A B2 C2 D2 E2 X2]
+
+		let vec: Vec<HashAndNumber<Block>> = if from < to {
+			chain.into_iter().skip(from).take(to - from + 1).collect()
+		} else {
+			chain.into_iter().skip(to).take(from - to + 1).rev().collect()
+		};
+
+		let pivot = if from <= pivot && to <= pivot {
+			if from < to {
+				to - from
+			} else {
+				0
+			}
+		} else if from >= pivot && to >= pivot {
+			if from < to {
+				0
+			} else {
+				from - to
+			}
+		} else {
+			if from < to {
+				pivot - from
+			} else {
+				from - pivot
+			}
+		};
+
+		TreeRoute::new(vec, pivot)
+	}
+
+	mod mock_tree_route_tests {
+		use super::*;
+
+		/// asserts that tree routes are equal
+		fn assert_treeroute_eq(
+			expected: Result<TreeRoute<Block>, String>,
+			result: Result<TreeRoute<Block>, String>,
+		) {
+			let expected = expected.unwrap();
+			let result = result.unwrap();
+			assert_eq!(result.common_block().hash, expected.common_block().hash);
+			assert_eq!(result.enacted().len(), expected.enacted().len());
+			assert_eq!(result.retracted().len(), expected.retracted().len());
+			assert!(result
+				.enacted()
+				.iter()
+				.zip(expected.enacted().iter())
+				.all(|(a, b)| a.hash == b.hash));
+			assert!(result
+				.retracted()
+				.iter()
+				.zip(expected.retracted().iter())
+				.all(|(a, b)| a.hash == b.hash));
+		}
+
+		// some tests for mock tree_route function
+
+		#[test]
+		fn tree_route_mock_test_01() {
+			let result = tree_route(b1().hash, a().hash);
+			let expected = TreeRoute::new(vec![b1(), a()], 1);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_02() {
+			let result = tree_route(a().hash, b1().hash);
+			let expected = TreeRoute::new(vec![a(), b1()], 0);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_03() {
+			let result = tree_route(a().hash, c2().hash);
+			let expected = TreeRoute::new(vec![a(), b2(), c2()], 0);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_04() {
+			let result = tree_route(e2().hash, a().hash);
+			let expected = TreeRoute::new(vec![e2(), d2(), c2(), b2(), a()], 4);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_05() {
+			let result = tree_route(d1().hash, b1().hash);
+			let expected = TreeRoute::new(vec![d1(), c1(), b1()], 2);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_06() {
+			let result = tree_route(d2().hash, b2().hash);
+			let expected = TreeRoute::new(vec![d2(), c2(), b2()], 2);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_07() {
+			let result = tree_route(b1().hash, d1().hash);
+			let expected = TreeRoute::new(vec![b1(), c1(), d1()], 0);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_08() {
+			let result = tree_route(b2().hash, d2().hash);
+			let expected = TreeRoute::new(vec![b2(), c2(), d2()], 0);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_09() {
+			let result = tree_route(e2().hash, e1().hash);
+			let expected =
+				TreeRoute::new(vec![e2(), d2(), c2(), b2(), a(), b1(), c1(), d1(), e1()], 4);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_10() {
+			let result = tree_route(e1().hash, e2().hash);
+			let expected =
+				TreeRoute::new(vec![e1(), d1(), c1(), b1(), a(), b2(), c2(), d2(), e2()], 4);
+			assert_treeroute_eq(result, expected);
+		}
+		#[test]
+		fn tree_route_mock_test_11() {
+			let result = tree_route(b1().hash, c2().hash);
+			let expected = TreeRoute::new(vec![b1(), a(), b2(), c2()], 1);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_12() {
+			let result = tree_route(d2().hash, b1().hash);
+			let expected = TreeRoute::new(vec![d2(), c2(), b2(), a(), b1()], 3);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_13() {
+			let result = tree_route(c2().hash, e1().hash);
+			let expected = TreeRoute::new(vec![c2(), b2(), a(), b1(), c1(), d1(), e1()], 2);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_14() {
+			let result = tree_route(b1().hash, b1().hash);
+			let expected = TreeRoute::new(vec![b1()], 0);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_15() {
+			let result = tree_route(b2().hash, b2().hash);
+			let expected = TreeRoute::new(vec![b2()], 0);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_16() {
+			let result = tree_route(a().hash, a().hash);
+			let expected = TreeRoute::new(vec![a()], 0);
+			assert_treeroute_eq(result, expected);
+		}
+
+		#[test]
+		fn tree_route_mock_test_17() {
+			let result = tree_route(x2().hash, b1().hash);
+			let expected = TreeRoute::new(vec![x2(), e2(), d2(), c2(), b2(), a(), b1()], 5);
+			assert_treeroute_eq(result, expected);
+		}
+	}
+
+	fn trigger_new_best_block(
+		state: &mut EnactmentState<Block>,
+		from: HashAndNumber<Block>,
+		acted_on: HashAndNumber<Block>,
+	) -> EnactmentAction<Block> {
+		let (from, acted_on) = (from.hash, acted_on.hash);
+
+		let event_tree_route = tree_route(from, acted_on).expect("Tree route exists");
+
+		state
+			.update(
+				&ChainEvent::NewBestBlock {
+					hash: acted_on,
+					tree_route: Some(Arc::new(event_tree_route)),
+				},
+				&tree_route,
+				&block_hash_to_block_number,
+			)
+			.unwrap()
+	}
+
+	fn trigger_finalized(
+		state: &mut EnactmentState<Block>,
+		from: HashAndNumber<Block>,
+		acted_on: HashAndNumber<Block>,
+	) -> EnactmentAction<Block> {
+		let (from, acted_on) = (from.hash, acted_on.hash);
+
+		let v = tree_route(from, acted_on)
+			.expect("Tree route exists")
+			.enacted()
+			.iter()
+			.map(|h| h.hash)
+			.collect::<Vec<_>>();
+
+		state
+			.update(
+				&ChainEvent::Finalized { hash: acted_on, tree_route: v.into() },
+				&tree_route,
+				&block_hash_to_block_number,
+			)
+			.unwrap()
+	}
+
+	fn assert_es_eq(
+		es: &EnactmentState<Block>,
+		expected_best_block: HashAndNumber<Block>,
+		expected_finalized_block: HashAndNumber<Block>,
+	) {
+		assert_eq!(es.recent_best_block, expected_best_block.hash);
+		assert_eq!(es.recent_finalized_block, expected_finalized_block.hash);
+	}
+
+	#[test]
+	fn test_enactment_helper() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		//   B1-C1-D1-E1
+		//  /
+		// A
+		//  \
+		//   B2-C2-D2-E2
+
+		let result = trigger_new_best_block(&mut es, a(), d1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, d1(), a());
+
+		let result = trigger_new_best_block(&mut es, d1(), e1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, e1(), a());
+
+		let result = trigger_finalized(&mut es, a(), d2());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_new_best_block(&mut es, d2(), e1());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_finalized(&mut es, a(), b2());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_finalized(&mut es, a(), b1());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_new_best_block(&mut es, a(), d2());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_finalized(&mut es, a(), d2());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_new_best_block(&mut es, a(), c2());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_new_best_block(&mut es, a(), c1());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, d2(), d2());
+
+		let result = trigger_new_best_block(&mut es, d2(), e2());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, e2(), d2());
+
+		let result = trigger_finalized(&mut es, d2(), e2());
+		assert!(matches!(result, EnactmentAction::HandleFinalization));
+		assert_es_eq(&es, e2(), e2());
+	}
+
+	#[test]
+	fn test_enactment_helper_2() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		// A-B1-C1-D1-E1
+
+		let result = trigger_new_best_block(&mut es, a(), b1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, b1(), a());
+
+		let result = trigger_new_best_block(&mut es, b1(), c1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, c1(), a());
+
+		let result = trigger_new_best_block(&mut es, c1(), d1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, d1(), a());
+
+		let result = trigger_new_best_block(&mut es, d1(), e1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, e1(), a());
+
+		let result = trigger_finalized(&mut es, a(), c1());
+		assert!(matches!(result, EnactmentAction::HandleFinalization));
+		assert_es_eq(&es, e1(), c1());
+
+		let result = trigger_finalized(&mut es, c1(), e1());
+		assert!(matches!(result, EnactmentAction::HandleFinalization));
+		assert_es_eq(&es, e1(), e1());
+	}
+
+	#[test]
+	fn test_enactment_helper_3() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		// A-B1-C1-D1-E1
+
+		let result = trigger_new_best_block(&mut es, a(), e1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, e1(), a());
+
+		let result = trigger_finalized(&mut es, a(), b1());
+		assert!(matches!(result, EnactmentAction::HandleFinalization));
+		assert_es_eq(&es, e1(), b1());
+	}
+
+	#[test]
+	fn test_enactment_helper_4() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		// A-B1-C1-D1-E1
+
+		let result = trigger_finalized(&mut es, a(), e1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, e1(), e1());
+
+		let result = trigger_finalized(&mut es, e1(), b1());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, e1(), e1());
+	}
+
+	#[test]
+	fn test_enactment_helper_5() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		//   B1-C1-D1-E1
+		//  /
+		// A
+		//  \
+		//   B2-C2-D2-E2
+
+		let result = trigger_finalized(&mut es, a(), e1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, e1(), e1());
+
+		let result = trigger_finalized(&mut es, e1(), e2());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, e1(), e1());
+	}
+
+	#[test]
+	fn test_enactment_helper_6() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		// A-B1-C1-D1-E1
+
+		let result = trigger_new_best_block(&mut es, a(), b1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, b1(), a());
+
+		let result = trigger_finalized(&mut es, a(), d1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, d1(), d1());
+
+		let result = trigger_new_best_block(&mut es, a(), e1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, e1(), d1());
+
+		let result = trigger_new_best_block(&mut es, a(), c1());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, e1(), d1());
+	}
+
+	#[test]
+	fn test_enactment_forced_update_best_block() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		es.force_update(&ChainEvent::NewBestBlock { hash: b1().hash, tree_route: None });
+		assert_es_eq(&es, b1(), a());
+	}
+
+	#[test]
+	fn test_enactment_forced_update_finalize() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		es.force_update(&ChainEvent::Finalized { hash: b1().hash, tree_route: Arc::from([]) });
+		assert_es_eq(&es, a(), b1());
+	}
+
+	#[test]
+	fn test_enactment_skip_long_enacted_path() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(a().hash, a().hash);
+
+		// A-B1-C1-..-X1
+		let result = trigger_new_best_block(&mut es, a(), x1());
+		assert!(matches!(result, EnactmentAction::Skip));
+		assert_es_eq(&es, x1(), a());
+	}
+
+	#[test]
+	fn test_enactment_proceed_with_enacted_path_at_threshold() {
+		sp_tracing::try_init_simple();
+		let mut es = EnactmentState::new(b1().hash, b1().hash);
+
+		// A-B1-C1-..-X1
+		let result = trigger_new_best_block(&mut es, b1(), x1());
+		assert!(matches!(result, EnactmentAction::HandleEnactment { .. }));
+		assert_es_eq(&es, x1(), b1());
+	}
+}
diff --git a/substrate/client/transaction-pool/src/error.rs b/substrate/client/transaction-pool/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d93872d6c67629f6bab0a2b54fec395070c3e0d1
--- /dev/null
+++ b/substrate/client/transaction-pool/src/error.rs
@@ -0,0 +1,50 @@
+// 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/>.
+
+//! Transaction pool error.
+
+use sc_transaction_pool_api::error::Error as TxPoolError;
+
+/// Transaction pool result.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Transaction pool error type.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+	#[error("Transaction pool error: {0}")]
+	Pool(#[from] TxPoolError),
+
+	#[error("Blockchain error: {0}")]
+	Blockchain(#[from] sp_blockchain::Error),
+
+	#[error("Block conversion error: {0}")]
+	BlockIdConversion(String),
+
+	#[error("Runtime error: {0}")]
+	RuntimeApi(String),
+}
+
+impl sc_transaction_pool_api::error::IntoPoolError for Error {
+	fn into_pool_error(self) -> std::result::Result<TxPoolError, Self> {
+		match self {
+			Error::Pool(e) => Ok(e),
+			e => Err(e),
+		}
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/base_pool.rs b/substrate/client/transaction-pool/src/graph/base_pool.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a9d2d6c825f61bf62b03556d1b5ec58fc6541e8e
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/base_pool.rs
@@ -0,0 +1,1046 @@
+// 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/>.
+
+//! A basic version of the dependency graph.
+//!
+//! For a more full-featured pool, have a look at the `pool` module.
+
+use std::{cmp::Ordering, collections::HashSet, fmt, hash, sync::Arc};
+
+use crate::LOG_TARGET;
+use log::{debug, trace, warn};
+use sc_transaction_pool_api::{error, InPoolTransaction, PoolStatus};
+use serde::Serialize;
+use sp_core::hexdisplay::HexDisplay;
+use sp_runtime::{
+	traits::Member,
+	transaction_validity::{
+		TransactionLongevity as Longevity, TransactionPriority as Priority,
+		TransactionSource as Source, TransactionTag as Tag,
+	},
+};
+
+use super::{
+	future::{FutureTransactions, WaitingTransaction},
+	ready::{BestIterator, ReadyTransactions, TransactionRef},
+};
+
+/// Successful import result.
+#[derive(Debug, PartialEq, Eq)]
+pub enum Imported<Hash, Ex> {
+	/// Transaction was successfully imported to Ready queue.
+	Ready {
+		/// Hash of transaction that was successfully imported.
+		hash: Hash,
+		/// Transactions that got promoted from the Future queue.
+		promoted: Vec<Hash>,
+		/// Transactions that failed to be promoted from the Future queue and are now discarded.
+		failed: Vec<Hash>,
+		/// Transactions removed from the Ready pool (replaced).
+		removed: Vec<Arc<Transaction<Hash, Ex>>>,
+	},
+	/// Transaction was successfully imported to Future queue.
+	Future {
+		/// Hash of transaction that was successfully imported.
+		hash: Hash,
+	},
+}
+
+impl<Hash, Ex> Imported<Hash, Ex> {
+	/// Returns the hash of imported transaction.
+	pub fn hash(&self) -> &Hash {
+		use self::Imported::*;
+		match *self {
+			Ready { ref hash, .. } => hash,
+			Future { ref hash, .. } => hash,
+		}
+	}
+}
+
+/// Status of pruning the queue.
+#[derive(Debug)]
+pub struct PruneStatus<Hash, Ex> {
+	/// A list of imports that satisfying the tag triggered.
+	pub promoted: Vec<Imported<Hash, Ex>>,
+	/// A list of transactions that failed to be promoted and now are discarded.
+	pub failed: Vec<Hash>,
+	/// A list of transactions that got pruned from the ready queue.
+	pub pruned: Vec<Arc<Transaction<Hash, Ex>>>,
+}
+
+/// Immutable transaction
+#[cfg_attr(test, derive(Clone))]
+#[derive(PartialEq, Eq)]
+pub struct Transaction<Hash, Extrinsic> {
+	/// Raw extrinsic representing that transaction.
+	pub data: Extrinsic,
+	/// Number of bytes encoding of the transaction requires.
+	pub bytes: usize,
+	/// Transaction hash (unique)
+	pub hash: Hash,
+	/// Transaction priority (higher = better)
+	pub priority: Priority,
+	/// At which block the transaction becomes invalid?
+	pub valid_till: Longevity,
+	/// Tags required by the transaction.
+	pub requires: Vec<Tag>,
+	/// Tags that this transaction provides.
+	pub provides: Vec<Tag>,
+	/// Should that transaction be propagated.
+	pub propagate: bool,
+	/// Source of that transaction.
+	pub source: Source,
+}
+
+impl<Hash, Extrinsic> AsRef<Extrinsic> for Transaction<Hash, Extrinsic> {
+	fn as_ref(&self) -> &Extrinsic {
+		&self.data
+	}
+}
+
+impl<Hash, Extrinsic> InPoolTransaction for Transaction<Hash, Extrinsic> {
+	type Transaction = Extrinsic;
+	type Hash = Hash;
+
+	fn data(&self) -> &Extrinsic {
+		&self.data
+	}
+
+	fn hash(&self) -> &Hash {
+		&self.hash
+	}
+
+	fn priority(&self) -> &Priority {
+		&self.priority
+	}
+
+	fn longevity(&self) -> &Longevity {
+		&self.valid_till
+	}
+
+	fn requires(&self) -> &[Tag] {
+		&self.requires
+	}
+
+	fn provides(&self) -> &[Tag] {
+		&self.provides
+	}
+
+	fn is_propagable(&self) -> bool {
+		self.propagate
+	}
+}
+
+impl<Hash: Clone, Extrinsic: Clone> Transaction<Hash, Extrinsic> {
+	/// Explicit transaction clone.
+	///
+	/// Transaction should be cloned only if absolutely necessary && we want
+	/// every reason to be commented. That's why we `Transaction` is not `Clone`,
+	/// but there's explicit `duplicate` method.
+	pub fn duplicate(&self) -> Self {
+		Self {
+			data: self.data.clone(),
+			bytes: self.bytes,
+			hash: self.hash.clone(),
+			priority: self.priority,
+			source: self.source,
+			valid_till: self.valid_till,
+			requires: self.requires.clone(),
+			provides: self.provides.clone(),
+			propagate: self.propagate,
+		}
+	}
+}
+
+impl<Hash, Extrinsic> fmt::Debug for Transaction<Hash, Extrinsic>
+where
+	Hash: fmt::Debug,
+	Extrinsic: fmt::Debug,
+{
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		let join_tags = |tags: &[Tag]| {
+			tags.iter()
+				.map(|tag| HexDisplay::from(tag).to_string())
+				.collect::<Vec<_>>()
+				.join(", ")
+		};
+
+		write!(fmt, "Transaction {{ ")?;
+		write!(fmt, "hash: {:?}, ", &self.hash)?;
+		write!(fmt, "priority: {:?}, ", &self.priority)?;
+		write!(fmt, "valid_till: {:?}, ", &self.valid_till)?;
+		write!(fmt, "bytes: {:?}, ", &self.bytes)?;
+		write!(fmt, "propagate: {:?}, ", &self.propagate)?;
+		write!(fmt, "source: {:?}, ", &self.source)?;
+		write!(fmt, "requires: [{}], ", join_tags(&self.requires))?;
+		write!(fmt, "provides: [{}], ", join_tags(&self.provides))?;
+		write!(fmt, "data: {:?}", &self.data)?;
+		write!(fmt, "}}")?;
+		Ok(())
+	}
+}
+
+/// Store last pruned tags for given number of invocations.
+const RECENTLY_PRUNED_TAGS: usize = 2;
+
+/// Transaction pool.
+///
+/// Builds a dependency graph for all transactions in the pool and returns
+/// the ones that are currently ready to be executed.
+///
+/// General note:
+/// If function returns some transactions it usually means that importing them
+/// as-is for the second time will fail or produce unwanted results.
+/// Most likely it is required to revalidate them and recompute set of
+/// required tags.
+#[derive(Debug)]
+pub struct BasePool<Hash: hash::Hash + Eq, Ex> {
+	reject_future_transactions: bool,
+	future: FutureTransactions<Hash, Ex>,
+	ready: ReadyTransactions<Hash, Ex>,
+	/// Store recently pruned tags (for last two invocations).
+	///
+	/// This is used to make sure we don't accidentally put
+	/// transactions to future in case they were just stuck in verification.
+	recently_pruned: [HashSet<Tag>; RECENTLY_PRUNED_TAGS],
+	recently_pruned_index: usize,
+}
+
+impl<Hash: hash::Hash + Member + Serialize, Ex: std::fmt::Debug> Default for BasePool<Hash, Ex> {
+	fn default() -> Self {
+		Self::new(false)
+	}
+}
+
+impl<Hash: hash::Hash + Member + Serialize, Ex: std::fmt::Debug> BasePool<Hash, Ex> {
+	/// Create new pool given reject_future_transactions flag.
+	pub fn new(reject_future_transactions: bool) -> Self {
+		Self {
+			reject_future_transactions,
+			future: Default::default(),
+			ready: Default::default(),
+			recently_pruned: Default::default(),
+			recently_pruned_index: 0,
+		}
+	}
+
+	/// Temporary enables future transactions, runs closure and then restores
+	/// `reject_future_transactions` flag back to previous value.
+	///
+	/// The closure accepts the mutable reference to the pool and original value
+	/// of the `reject_future_transactions` flag.
+	pub(crate) fn with_futures_enabled<T>(
+		&mut self,
+		closure: impl FnOnce(&mut Self, bool) -> T,
+	) -> T {
+		let previous = self.reject_future_transactions;
+		self.reject_future_transactions = false;
+		let return_value = closure(self, previous);
+		self.reject_future_transactions = previous;
+		return_value
+	}
+
+	/// Returns if the transaction for the given hash is already imported.
+	pub fn is_imported(&self, tx_hash: &Hash) -> bool {
+		self.future.contains(tx_hash) || self.ready.contains(tx_hash)
+	}
+
+	/// Imports transaction to the pool.
+	///
+	/// The pool consists of two parts: Future and Ready.
+	/// The former contains transactions that require some tags that are not yet provided by
+	/// other transactions in the pool.
+	/// The latter contains transactions that have all the requirements satisfied and are
+	/// ready to be included in the block.
+	pub fn import(&mut self, tx: Transaction<Hash, Ex>) -> error::Result<Imported<Hash, Ex>> {
+		if self.is_imported(&tx.hash) {
+			return Err(error::Error::AlreadyImported(Box::new(tx.hash)))
+		}
+
+		let tx = WaitingTransaction::new(tx, self.ready.provided_tags(), &self.recently_pruned);
+		trace!(target: LOG_TARGET, "[{:?}] {:?}", tx.transaction.hash, tx);
+		debug!(
+			target: LOG_TARGET,
+			"[{:?}] Importing to {}",
+			tx.transaction.hash,
+			if tx.is_ready() { "ready" } else { "future" }
+		);
+
+		// If all tags are not satisfied import to future.
+		if !tx.is_ready() {
+			if self.reject_future_transactions {
+				return Err(error::Error::RejectedFutureTransaction)
+			}
+
+			let hash = tx.transaction.hash.clone();
+			self.future.import(tx);
+			return Ok(Imported::Future { hash })
+		}
+
+		self.import_to_ready(tx)
+	}
+
+	/// Imports transaction to ready queue.
+	///
+	/// NOTE the transaction has to have all requirements satisfied.
+	fn import_to_ready(
+		&mut self,
+		tx: WaitingTransaction<Hash, Ex>,
+	) -> error::Result<Imported<Hash, Ex>> {
+		let hash = tx.transaction.hash.clone();
+		let mut promoted = vec![];
+		let mut failed = vec![];
+		let mut removed = vec![];
+
+		let mut first = true;
+		let mut to_import = vec![tx];
+
+		// take first transaction from the list
+		while let Some(tx) = to_import.pop() {
+			// find transactions in Future that it unlocks
+			to_import.append(&mut self.future.satisfy_tags(&tx.transaction.provides));
+
+			// import this transaction
+			let current_hash = tx.transaction.hash.clone();
+			match self.ready.import(tx) {
+				Ok(mut replaced) => {
+					if !first {
+						promoted.push(current_hash);
+					}
+					// The transactions were removed from the ready pool. We might attempt to
+					// re-import them.
+					removed.append(&mut replaced);
+				},
+				// transaction failed to be imported.
+				Err(e) =>
+					if first {
+						debug!(target: LOG_TARGET, "[{:?}] Error importing: {:?}", current_hash, e);
+						return Err(e)
+					} else {
+						failed.push(current_hash);
+					},
+			}
+			first = false;
+		}
+
+		// An edge case when importing transaction caused
+		// some future transactions to be imported and that
+		// future transactions pushed out current transaction.
+		// This means that there is a cycle and the transactions should
+		// be moved back to future, since we can't resolve it.
+		if removed.iter().any(|tx| tx.hash == hash) {
+			// We still need to remove all transactions that we promoted
+			// since they depend on each other and will never get to the best iterator.
+			self.ready.remove_subtree(&promoted);
+
+			debug!(target: LOG_TARGET, "[{:?}] Cycle detected, bailing.", hash);
+			return Err(error::Error::CycleDetected)
+		}
+
+		Ok(Imported::Ready { hash, promoted, failed, removed })
+	}
+
+	/// Returns an iterator over ready transactions in the pool.
+	pub fn ready(&self) -> BestIterator<Hash, Ex> {
+		self.ready.get()
+	}
+
+	/// Returns an iterator over future transactions in the pool.
+	pub fn futures(&self) -> impl Iterator<Item = &Transaction<Hash, Ex>> {
+		self.future.all()
+	}
+
+	/// Returns pool transactions given list of hashes.
+	///
+	/// Includes both ready and future pool. For every hash in the `hashes`
+	/// iterator an `Option` is produced (so the resulting `Vec` always have the same length).
+	pub fn by_hashes(&self, hashes: &[Hash]) -> Vec<Option<Arc<Transaction<Hash, Ex>>>> {
+		let ready = self.ready.by_hashes(hashes);
+		let future = self.future.by_hashes(hashes);
+
+		ready.into_iter().zip(future).map(|(a, b)| a.or(b)).collect()
+	}
+
+	/// Returns pool transaction by hash.
+	pub fn ready_by_hash(&self, hash: &Hash) -> Option<Arc<Transaction<Hash, Ex>>> {
+		self.ready.by_hash(hash)
+	}
+
+	/// Makes sure that the transactions in the queues stay within provided limits.
+	///
+	/// Removes and returns worst transactions from the queues and all transactions that depend on
+	/// them. Technically the worst transaction should be evaluated by computing the entire pending
+	/// set. We use a simplified approach to remove transactions with the lowest priority first or
+	/// those that occupy the pool for the longest time in case priority is the same.
+	pub fn enforce_limits(
+		&mut self,
+		ready: &Limit,
+		future: &Limit,
+	) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		let mut removed = vec![];
+
+		while ready.is_exceeded(self.ready.len(), self.ready.bytes()) {
+			// find the worst transaction
+			let worst = self.ready.fold::<TransactionRef<Hash, Ex>, _>(|worst, current| {
+				let transaction = &current.transaction;
+				worst
+					.map(|worst| {
+						// Here we don't use `TransactionRef`'s ordering implementation because
+						// while it prefers priority like need here, it also prefers older
+						// transactions for inclusion purposes and limit enforcement needs to prefer
+						// newer transactions instead and drop the older ones.
+						match worst.transaction.priority.cmp(&transaction.transaction.priority) {
+							Ordering::Less => worst,
+							Ordering::Equal =>
+								if worst.insertion_id > transaction.insertion_id {
+									transaction.clone()
+								} else {
+									worst
+								},
+							Ordering::Greater => transaction.clone(),
+						}
+					})
+					.or_else(|| Some(transaction.clone()))
+			});
+
+			if let Some(worst) = worst {
+				removed.append(&mut self.remove_subtree(&[worst.transaction.hash.clone()]))
+			} else {
+				break
+			}
+		}
+
+		while future.is_exceeded(self.future.len(), self.future.bytes()) {
+			// find the worst transaction
+			let worst = self.future.fold(|worst, current| match worst {
+				None => Some(current.clone()),
+				Some(ref tx) if tx.imported_at > current.imported_at => Some(current.clone()),
+				other => other,
+			});
+
+			if let Some(worst) = worst {
+				removed.append(&mut self.remove_subtree(&[worst.transaction.hash.clone()]))
+			} else {
+				break
+			}
+		}
+
+		removed
+	}
+
+	/// Removes all transactions represented by the hashes and all other transactions
+	/// that depend on them.
+	///
+	/// Returns a list of actually removed transactions.
+	/// NOTE some transactions might still be valid, but were just removed because
+	/// they were part of a chain, you may attempt to re-import them later.
+	/// NOTE If you want to remove ready transactions that were already used
+	/// and you don't want them to be stored in the pool use `prune_tags` method.
+	pub fn remove_subtree(&mut self, hashes: &[Hash]) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		let mut removed = self.ready.remove_subtree(hashes);
+		removed.extend(self.future.remove(hashes));
+		removed
+	}
+
+	/// Removes and returns all transactions from the future queue.
+	pub fn clear_future(&mut self) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		self.future.clear()
+	}
+
+	/// Prunes transactions that provide given list of tags.
+	///
+	/// This will cause all transactions that provide these tags to be removed from the pool,
+	/// but unlike `remove_subtree`, dependent transactions are not touched.
+	/// Additional transactions from future queue might be promoted to ready if you satisfy tags
+	/// that the pool didn't previously know about.
+	pub fn prune_tags(&mut self, tags: impl IntoIterator<Item = Tag>) -> PruneStatus<Hash, Ex> {
+		let mut to_import = vec![];
+		let mut pruned = vec![];
+		let recently_pruned = &mut self.recently_pruned[self.recently_pruned_index];
+		self.recently_pruned_index = (self.recently_pruned_index + 1) % RECENTLY_PRUNED_TAGS;
+		recently_pruned.clear();
+
+		for tag in tags {
+			// make sure to promote any future transactions that could be unlocked
+			to_import.append(&mut self.future.satisfy_tags(std::iter::once(&tag)));
+			// and actually prune transactions in ready queue
+			pruned.append(&mut self.ready.prune_tags(tag.clone()));
+			// store the tags for next submission
+			recently_pruned.insert(tag);
+		}
+
+		let mut promoted = vec![];
+		let mut failed = vec![];
+		for tx in to_import {
+			let hash = tx.transaction.hash.clone();
+			match self.import_to_ready(tx) {
+				Ok(res) => promoted.push(res),
+				Err(e) => {
+					warn!(
+						target: LOG_TARGET,
+						"[{:?}] Failed to promote during pruning: {:?}", hash, e,
+					);
+					failed.push(hash)
+				},
+			}
+		}
+
+		PruneStatus { pruned, failed, promoted }
+	}
+
+	/// Get pool status.
+	pub fn status(&self) -> PoolStatus {
+		PoolStatus {
+			ready: self.ready.len(),
+			ready_bytes: self.ready.bytes(),
+			future: self.future.len(),
+			future_bytes: self.future.bytes(),
+		}
+	}
+}
+
+/// Queue limits
+#[derive(Debug, Clone)]
+pub struct Limit {
+	/// Maximal number of transactions in the queue.
+	pub count: usize,
+	/// Maximal size of encodings of all transactions in the queue.
+	pub total_bytes: usize,
+}
+
+impl Limit {
+	/// Returns true if any of the provided values exceeds the limit.
+	pub fn is_exceeded(&self, count: usize, bytes: usize) -> bool {
+		self.count < count || self.total_bytes < bytes
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	type Hash = u64;
+
+	fn pool() -> BasePool<Hash, Vec<u8>> {
+		BasePool::default()
+	}
+
+	const DEFAULT_TX: Transaction<Hash, Vec<u8>> = Transaction {
+		data: vec![],
+		bytes: 1,
+		hash: 1u64,
+		priority: 5u64,
+		valid_till: 64u64,
+		requires: vec![],
+		provides: vec![],
+		propagate: true,
+		source: Source::External,
+	};
+
+	#[test]
+	fn should_import_transaction_to_ready() {
+		// given
+		let mut pool = pool();
+
+		// when
+		pool.import(Transaction { data: vec![1u8], provides: vec![vec![1]], ..DEFAULT_TX.clone() })
+			.unwrap();
+
+		// then
+		assert_eq!(pool.ready().count(), 1);
+		assert_eq!(pool.ready.len(), 1);
+	}
+
+	#[test]
+	fn should_not_import_same_transaction_twice() {
+		// given
+		let mut pool = pool();
+
+		// when
+		pool.import(Transaction { data: vec![1u8], provides: vec![vec![1]], ..DEFAULT_TX.clone() })
+			.unwrap();
+		pool.import(Transaction { data: vec![1u8], provides: vec![vec![1]], ..DEFAULT_TX.clone() })
+			.unwrap_err();
+
+		// then
+		assert_eq!(pool.ready().count(), 1);
+		assert_eq!(pool.ready.len(), 1);
+	}
+
+	#[test]
+	fn should_import_transaction_to_future_and_promote_it_later() {
+		// given
+		let mut pool = pool();
+
+		// when
+		pool.import(Transaction {
+			data: vec![1u8],
+			requires: vec![vec![0]],
+			provides: vec![vec![1]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		assert_eq!(pool.ready().count(), 0);
+		assert_eq!(pool.ready.len(), 0);
+		pool.import(Transaction {
+			data: vec![2u8],
+			hash: 2,
+			provides: vec![vec![0]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+
+		// then
+		assert_eq!(pool.ready().count(), 2);
+		assert_eq!(pool.ready.len(), 2);
+	}
+
+	#[test]
+	fn should_promote_a_subgraph() {
+		// given
+		let mut pool = pool();
+
+		// when
+		pool.import(Transaction {
+			data: vec![1u8],
+			requires: vec![vec![0]],
+			provides: vec![vec![1]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![3u8],
+			hash: 3,
+			requires: vec![vec![2]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![2u8],
+			hash: 2,
+			requires: vec![vec![1]],
+			provides: vec![vec![3], vec![2]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![4u8],
+			hash: 4,
+			priority: 1_000u64,
+			requires: vec![vec![3], vec![4]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		assert_eq!(pool.ready().count(), 0);
+		assert_eq!(pool.ready.len(), 0);
+
+		let res = pool
+			.import(Transaction {
+				data: vec![5u8],
+				hash: 5,
+				provides: vec![vec![0], vec![4]],
+				..DEFAULT_TX.clone()
+			})
+			.unwrap();
+
+		// then
+		let mut it = pool.ready().into_iter().map(|tx| tx.data[0]);
+
+		assert_eq!(it.next(), Some(5));
+		assert_eq!(it.next(), Some(1));
+		assert_eq!(it.next(), Some(2));
+		assert_eq!(it.next(), Some(4));
+		assert_eq!(it.next(), Some(3));
+		assert_eq!(it.next(), None);
+		assert_eq!(
+			res,
+			Imported::Ready {
+				hash: 5,
+				promoted: vec![1, 2, 3, 4],
+				failed: vec![],
+				removed: vec![],
+			}
+		);
+	}
+
+	#[test]
+	fn should_handle_a_cycle() {
+		// given
+		let mut pool = pool();
+		pool.import(Transaction {
+			data: vec![1u8],
+			requires: vec![vec![0]],
+			provides: vec![vec![1]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![3u8],
+			hash: 3,
+			requires: vec![vec![1]],
+			provides: vec![vec![2]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		assert_eq!(pool.ready().count(), 0);
+		assert_eq!(pool.ready.len(), 0);
+
+		// when
+		pool.import(Transaction {
+			data: vec![2u8],
+			hash: 2,
+			requires: vec![vec![2]],
+			provides: vec![vec![0]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+
+		// then
+		{
+			let mut it = pool.ready().into_iter().map(|tx| tx.data[0]);
+			assert_eq!(it.next(), None);
+		}
+		// all transactions occupy the Future queue - it's fine
+		assert_eq!(pool.future.len(), 3);
+
+		// let's close the cycle with one additional transaction
+		let res = pool
+			.import(Transaction {
+				data: vec![4u8],
+				hash: 4,
+				priority: 50u64,
+				provides: vec![vec![0]],
+				..DEFAULT_TX.clone()
+			})
+			.unwrap();
+		let mut it = pool.ready().into_iter().map(|tx| tx.data[0]);
+		assert_eq!(it.next(), Some(4));
+		assert_eq!(it.next(), Some(1));
+		assert_eq!(it.next(), Some(3));
+		assert_eq!(it.next(), None);
+		assert_eq!(
+			res,
+			Imported::Ready { hash: 4, promoted: vec![1, 3], failed: vec![2], removed: vec![] }
+		);
+		assert_eq!(pool.future.len(), 0);
+	}
+
+	#[test]
+	fn should_handle_a_cycle_with_low_priority() {
+		// given
+		let mut pool = pool();
+		pool.import(Transaction {
+			data: vec![1u8],
+			requires: vec![vec![0]],
+			provides: vec![vec![1]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![3u8],
+			hash: 3,
+			requires: vec![vec![1]],
+			provides: vec![vec![2]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		assert_eq!(pool.ready().count(), 0);
+		assert_eq!(pool.ready.len(), 0);
+
+		// when
+		pool.import(Transaction {
+			data: vec![2u8],
+			hash: 2,
+			requires: vec![vec![2]],
+			provides: vec![vec![0]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+
+		// then
+		{
+			let mut it = pool.ready().into_iter().map(|tx| tx.data[0]);
+			assert_eq!(it.next(), None);
+		}
+		// all transactions occupy the Future queue - it's fine
+		assert_eq!(pool.future.len(), 3);
+
+		// let's close the cycle with one additional transaction
+		let err = pool
+			.import(Transaction {
+				data: vec![4u8],
+				hash: 4,
+				priority: 1u64, // lower priority than Tx(2)
+				provides: vec![vec![0]],
+				..DEFAULT_TX.clone()
+			})
+			.unwrap_err();
+		let mut it = pool.ready().into_iter().map(|tx| tx.data[0]);
+		assert_eq!(it.next(), None);
+		assert_eq!(pool.ready.len(), 0);
+		assert_eq!(pool.future.len(), 0);
+		if let error::Error::CycleDetected = err {
+		} else {
+			assert!(false, "Invalid error kind: {:?}", err);
+		}
+	}
+
+	#[test]
+	fn should_remove_invalid_transactions() {
+		// given
+		let mut pool = pool();
+		pool.import(Transaction {
+			data: vec![5u8],
+			hash: 5,
+			provides: vec![vec![0], vec![4]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![1u8],
+			requires: vec![vec![0]],
+			provides: vec![vec![1]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![3u8],
+			hash: 3,
+			requires: vec![vec![2]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![2u8],
+			hash: 2,
+			requires: vec![vec![1]],
+			provides: vec![vec![3], vec![2]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![4u8],
+			hash: 4,
+			priority: 1_000u64,
+			requires: vec![vec![3], vec![4]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		// future
+		pool.import(Transaction {
+			data: vec![6u8],
+			hash: 6,
+			priority: 1_000u64,
+			requires: vec![vec![11]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		assert_eq!(pool.ready().count(), 5);
+		assert_eq!(pool.future.len(), 1);
+
+		// when
+		pool.remove_subtree(&[6, 1]);
+
+		// then
+		assert_eq!(pool.ready().count(), 1);
+		assert_eq!(pool.future.len(), 0);
+	}
+
+	#[test]
+	fn should_prune_ready_transactions() {
+		// given
+		let mut pool = pool();
+		// future (waiting for 0)
+		pool.import(Transaction {
+			data: vec![5u8],
+			hash: 5,
+			requires: vec![vec![0]],
+			provides: vec![vec![100]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		// ready
+		pool.import(Transaction { data: vec![1u8], provides: vec![vec![1]], ..DEFAULT_TX.clone() })
+			.unwrap();
+		pool.import(Transaction {
+			data: vec![2u8],
+			hash: 2,
+			requires: vec![vec![2]],
+			provides: vec![vec![3]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![3u8],
+			hash: 3,
+			requires: vec![vec![1]],
+			provides: vec![vec![2]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+		pool.import(Transaction {
+			data: vec![4u8],
+			hash: 4,
+			priority: 1_000u64,
+			requires: vec![vec![3], vec![2]],
+			provides: vec![vec![4]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+
+		assert_eq!(pool.ready().count(), 4);
+		assert_eq!(pool.future.len(), 1);
+
+		// when
+		let result = pool.prune_tags(vec![vec![0], vec![2]]);
+
+		// then
+		assert_eq!(result.pruned.len(), 2);
+		assert_eq!(result.failed.len(), 0);
+		assert_eq!(
+			result.promoted[0],
+			Imported::Ready { hash: 5, promoted: vec![], failed: vec![], removed: vec![] }
+		);
+		assert_eq!(result.promoted.len(), 1);
+		assert_eq!(pool.future.len(), 0);
+		assert_eq!(pool.ready.len(), 3);
+		assert_eq!(pool.ready().count(), 3);
+	}
+
+	#[test]
+	fn transaction_debug() {
+		assert_eq!(
+			format!(
+				"{:?}",
+				Transaction {
+					data: vec![4u8],
+					hash: 4,
+					priority: 1_000u64,
+					requires: vec![vec![3], vec![2]],
+					provides: vec![vec![4]],
+					..DEFAULT_TX.clone()
+				}
+			),
+			"Transaction { \
+hash: 4, priority: 1000, valid_till: 64, bytes: 1, propagate: true, \
+source: TransactionSource::External, requires: [03, 02], provides: [04], data: [4]}"
+				.to_owned()
+		);
+	}
+
+	#[test]
+	fn transaction_propagation() {
+		assert_eq!(
+			Transaction {
+				data: vec![4u8],
+				hash: 4,
+				priority: 1_000u64,
+				requires: vec![vec![3], vec![2]],
+				provides: vec![vec![4]],
+				..DEFAULT_TX.clone()
+			}
+			.is_propagable(),
+			true
+		);
+
+		assert_eq!(
+			Transaction {
+				data: vec![4u8],
+				hash: 4,
+				priority: 1_000u64,
+				requires: vec![vec![3], vec![2]],
+				provides: vec![vec![4]],
+				propagate: false,
+				..DEFAULT_TX.clone()
+			}
+			.is_propagable(),
+			false
+		);
+	}
+
+	#[test]
+	fn should_reject_future_transactions() {
+		// given
+		let mut pool = pool();
+
+		// when
+		pool.reject_future_transactions = true;
+
+		// then
+		let err = pool.import(Transaction {
+			data: vec![5u8],
+			hash: 5,
+			requires: vec![vec![0]],
+			..DEFAULT_TX.clone()
+		});
+
+		if let Err(error::Error::RejectedFutureTransaction) = err {
+		} else {
+			assert!(false, "Invalid error kind: {:?}", err);
+		}
+	}
+
+	#[test]
+	fn should_clear_future_queue() {
+		// given
+		let mut pool = pool();
+
+		// when
+		pool.import(Transaction {
+			data: vec![5u8],
+			hash: 5,
+			requires: vec![vec![0]],
+			..DEFAULT_TX.clone()
+		})
+		.unwrap();
+
+		// then
+		assert_eq!(pool.future.len(), 1);
+
+		// and then when
+		assert_eq!(pool.clear_future().len(), 1);
+
+		// then
+		assert_eq!(pool.future.len(), 0);
+	}
+
+	#[test]
+	fn should_accept_future_transactions_when_explicitly_asked_to() {
+		// given
+		let mut pool = pool();
+		pool.reject_future_transactions = true;
+
+		// when
+		let flag_value = pool.with_futures_enabled(|pool, flag| {
+			pool.import(Transaction {
+				data: vec![5u8],
+				hash: 5,
+				requires: vec![vec![0]],
+				..DEFAULT_TX.clone()
+			})
+			.unwrap();
+
+			flag
+		});
+
+		// then
+		assert_eq!(flag_value, true);
+		assert_eq!(pool.reject_future_transactions, true);
+		assert_eq!(pool.future.len(), 1);
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/future.rs b/substrate/client/transaction-pool/src/graph/future.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bad4663184854b3dd08072281eff98c717f6832d
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/future.rs
@@ -0,0 +1,252 @@
+// 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 std::{
+	collections::{HashMap, HashSet},
+	fmt, hash,
+	sync::Arc,
+};
+
+use sp_core::hexdisplay::HexDisplay;
+use sp_runtime::transaction_validity::TransactionTag as Tag;
+use std::time::Instant;
+
+use super::base_pool::Transaction;
+
+/// Transaction with partially satisfied dependencies.
+pub struct WaitingTransaction<Hash, Ex> {
+	/// Transaction details.
+	pub transaction: Arc<Transaction<Hash, Ex>>,
+	/// Tags that are required and have not been satisfied yet by other transactions in the pool.
+	pub missing_tags: HashSet<Tag>,
+	/// Time of import to the Future Queue.
+	pub imported_at: Instant,
+}
+
+impl<Hash: fmt::Debug, Ex: fmt::Debug> fmt::Debug for WaitingTransaction<Hash, Ex> {
+	fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		write!(fmt, "WaitingTransaction {{ ")?;
+		write!(fmt, "imported_at: {:?}, ", self.imported_at)?;
+		write!(fmt, "transaction: {:?}, ", self.transaction)?;
+		write!(
+			fmt,
+			"missing_tags: {{{}}}",
+			self.missing_tags
+				.iter()
+				.map(|tag| HexDisplay::from(tag).to_string())
+				.collect::<Vec<_>>()
+				.join(", "),
+		)?;
+		write!(fmt, "}}")
+	}
+}
+
+impl<Hash, Ex> Clone for WaitingTransaction<Hash, Ex> {
+	fn clone(&self) -> Self {
+		Self {
+			transaction: self.transaction.clone(),
+			missing_tags: self.missing_tags.clone(),
+			imported_at: self.imported_at,
+		}
+	}
+}
+
+impl<Hash, Ex> WaitingTransaction<Hash, Ex> {
+	/// Creates a new `WaitingTransaction`.
+	///
+	/// Computes the set of missing tags based on the requirements and tags that
+	/// are provided by all transactions in the ready queue.
+	pub fn new(
+		transaction: Transaction<Hash, Ex>,
+		provided: &HashMap<Tag, Hash>,
+		recently_pruned: &[HashSet<Tag>],
+	) -> Self {
+		let missing_tags = transaction
+			.requires
+			.iter()
+			.filter(|tag| {
+				// is true if the tag is already satisfied either via transaction in the pool
+				// or one that was recently included.
+				let is_provided = provided.contains_key(&**tag) ||
+					recently_pruned.iter().any(|x| x.contains(&**tag));
+				!is_provided
+			})
+			.cloned()
+			.collect();
+
+		Self { transaction: Arc::new(transaction), missing_tags, imported_at: Instant::now() }
+	}
+
+	/// Marks the tag as satisfied.
+	pub fn satisfy_tag(&mut self, tag: &Tag) {
+		self.missing_tags.remove(tag);
+	}
+
+	/// Returns true if transaction has all requirements satisfied.
+	pub fn is_ready(&self) -> bool {
+		self.missing_tags.is_empty()
+	}
+}
+
+/// A pool of transactions that are not yet ready to be included in the block.
+///
+/// Contains transactions that are still awaiting for some other transactions that
+/// could provide a tag that they require.
+#[derive(Debug)]
+pub struct FutureTransactions<Hash: hash::Hash + Eq, Ex> {
+	/// tags that are not yet provided by any transaction and we await for them
+	wanted_tags: HashMap<Tag, HashSet<Hash>>,
+	/// Transactions waiting for a particular other transaction
+	waiting: HashMap<Hash, WaitingTransaction<Hash, Ex>>,
+}
+
+impl<Hash: hash::Hash + Eq, Ex> Default for FutureTransactions<Hash, Ex> {
+	fn default() -> Self {
+		Self { wanted_tags: Default::default(), waiting: Default::default() }
+	}
+}
+
+const WAITING_PROOF: &str = r"#
+In import we always insert to `waiting` if we push to `wanted_tags`;
+when removing from `waiting` we always clear `wanted_tags`;
+every hash from `wanted_tags` is always present in `waiting`;
+qed
+#";
+
+impl<Hash: hash::Hash + Eq + Clone, Ex> FutureTransactions<Hash, Ex> {
+	/// Import transaction to Future queue.
+	///
+	/// Only transactions that don't have all their tags satisfied should occupy
+	/// the Future queue.
+	/// As soon as required tags are provided by some other transactions that are ready
+	/// we should remove the transactions from here and move them to the Ready queue.
+	pub fn import(&mut self, tx: WaitingTransaction<Hash, Ex>) {
+		assert!(!tx.is_ready(), "Transaction is ready.");
+		assert!(
+			!self.waiting.contains_key(&tx.transaction.hash),
+			"Transaction is already imported."
+		);
+
+		// Add all tags that are missing
+		for tag in &tx.missing_tags {
+			let entry = self.wanted_tags.entry(tag.clone()).or_insert_with(HashSet::new);
+			entry.insert(tx.transaction.hash.clone());
+		}
+
+		// Add the transaction to a by-hash waiting map
+		self.waiting.insert(tx.transaction.hash.clone(), tx);
+	}
+
+	/// Returns true if given hash is part of the queue.
+	pub fn contains(&self, hash: &Hash) -> bool {
+		self.waiting.contains_key(hash)
+	}
+
+	/// Returns a list of known transactions
+	pub fn by_hashes(&self, hashes: &[Hash]) -> Vec<Option<Arc<Transaction<Hash, Ex>>>> {
+		hashes
+			.iter()
+			.map(|h| self.waiting.get(h).map(|x| x.transaction.clone()))
+			.collect()
+	}
+
+	/// Satisfies provided tags in transactions that are waiting for them.
+	///
+	/// Returns (and removes) transactions that became ready after their last tag got
+	/// satisfied and now we can remove them from Future and move to Ready queue.
+	pub fn satisfy_tags<T: AsRef<Tag>>(
+		&mut self,
+		tags: impl IntoIterator<Item = T>,
+	) -> Vec<WaitingTransaction<Hash, Ex>> {
+		let mut became_ready = vec![];
+
+		for tag in tags {
+			if let Some(hashes) = self.wanted_tags.remove(tag.as_ref()) {
+				for hash in hashes {
+					let is_ready = {
+						let tx = self.waiting.get_mut(&hash).expect(WAITING_PROOF);
+						tx.satisfy_tag(tag.as_ref());
+						tx.is_ready()
+					};
+
+					if is_ready {
+						let tx = self.waiting.remove(&hash).expect(WAITING_PROOF);
+						became_ready.push(tx);
+					}
+				}
+			}
+		}
+
+		became_ready
+	}
+
+	/// Removes transactions for given list of hashes.
+	///
+	/// Returns a list of actually removed transactions.
+	pub fn remove(&mut self, hashes: &[Hash]) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		let mut removed = vec![];
+		for hash in hashes {
+			if let Some(waiting_tx) = self.waiting.remove(hash) {
+				// remove from wanted_tags as well
+				for tag in waiting_tx.missing_tags {
+					let remove = if let Some(wanted) = self.wanted_tags.get_mut(&tag) {
+						wanted.remove(hash);
+						wanted.is_empty()
+					} else {
+						false
+					};
+					if remove {
+						self.wanted_tags.remove(&tag);
+					}
+				}
+				// add to result
+				removed.push(waiting_tx.transaction)
+			}
+		}
+		removed
+	}
+
+	/// Fold a list of future transactions to compute a single value.
+	pub fn fold<R, F: FnMut(Option<R>, &WaitingTransaction<Hash, Ex>) -> Option<R>>(
+		&mut self,
+		f: F,
+	) -> Option<R> {
+		self.waiting.values().fold(None, f)
+	}
+
+	/// Returns iterator over all future transactions
+	pub fn all(&self) -> impl Iterator<Item = &Transaction<Hash, Ex>> {
+		self.waiting.values().map(|waiting| &*waiting.transaction)
+	}
+
+	/// Removes and returns all future transactions.
+	pub fn clear(&mut self) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		self.wanted_tags.clear();
+		self.waiting.drain().map(|(_, tx)| tx.transaction).collect()
+	}
+
+	/// Returns number of transactions in the Future queue.
+	pub fn len(&self) -> usize {
+		self.waiting.len()
+	}
+
+	/// Returns sum of encoding lengths of all transactions in this queue.
+	pub fn bytes(&self) -> usize {
+		self.waiting.values().fold(0, |acc, tx| acc + tx.transaction.bytes)
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/listener.rs b/substrate/client/transaction-pool/src/graph/listener.rs
new file mode 100644
index 0000000000000000000000000000000000000000..46b7957e0b31b2b8a79b60a40e2d5f25ae88fa99
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/listener.rs
@@ -0,0 +1,148 @@
+// 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 std::{collections::HashMap, fmt::Debug, hash};
+
+use crate::LOG_TARGET;
+use linked_hash_map::LinkedHashMap;
+use log::{debug, trace};
+use serde::Serialize;
+use sp_runtime::traits;
+
+use super::{watcher, BlockHash, ChainApi, ExtrinsicHash};
+
+/// Extrinsic pool default listener.
+pub struct Listener<H: hash::Hash + Eq, C: ChainApi> {
+	watchers: HashMap<H, watcher::Sender<H, ExtrinsicHash<C>>>,
+	finality_watchers: LinkedHashMap<ExtrinsicHash<C>, Vec<H>>,
+}
+
+/// Maximum number of blocks awaiting finality at any time.
+const MAX_FINALITY_WATCHERS: usize = 512;
+
+impl<H: hash::Hash + Eq + Debug, C: ChainApi> Default for Listener<H, C> {
+	fn default() -> Self {
+		Self { watchers: Default::default(), finality_watchers: Default::default() }
+	}
+}
+
+impl<H: hash::Hash + traits::Member + Serialize, C: ChainApi> Listener<H, C> {
+	fn fire<F>(&mut self, hash: &H, fun: F)
+	where
+		F: FnOnce(&mut watcher::Sender<H, ExtrinsicHash<C>>),
+	{
+		let clean = if let Some(h) = self.watchers.get_mut(hash) {
+			fun(h);
+			h.is_done()
+		} else {
+			false
+		};
+
+		if clean {
+			self.watchers.remove(hash);
+		}
+	}
+
+	/// Creates a new watcher for given verified extrinsic.
+	///
+	/// The watcher can be used to subscribe to life-cycle events of that extrinsic.
+	pub fn create_watcher(&mut self, hash: H) -> watcher::Watcher<H, ExtrinsicHash<C>> {
+		let sender = self.watchers.entry(hash.clone()).or_insert_with(watcher::Sender::default);
+		sender.new_watcher(hash)
+	}
+
+	/// Notify the listeners about extrinsic broadcast.
+	pub fn broadcasted(&mut self, hash: &H, peers: Vec<String>) {
+		trace!(target: LOG_TARGET, "[{:?}] Broadcasted", hash);
+		self.fire(hash, |watcher| watcher.broadcast(peers));
+	}
+
+	/// New transaction was added to the ready pool or promoted from the future pool.
+	pub fn ready(&mut self, tx: &H, old: Option<&H>) {
+		trace!(target: LOG_TARGET, "[{:?}] Ready (replaced with {:?})", tx, old);
+		self.fire(tx, |watcher| watcher.ready());
+		if let Some(old) = old {
+			self.fire(old, |watcher| watcher.usurped(tx.clone()));
+		}
+	}
+
+	/// New transaction was added to the future pool.
+	pub fn future(&mut self, tx: &H) {
+		trace!(target: LOG_TARGET, "[{:?}] Future", tx);
+		self.fire(tx, |watcher| watcher.future());
+	}
+
+	/// Transaction was dropped from the pool because of the limit.
+	pub fn dropped(&mut self, tx: &H, by: Option<&H>) {
+		trace!(target: LOG_TARGET, "[{:?}] Dropped (replaced with {:?})", tx, by);
+		self.fire(tx, |watcher| match by {
+			Some(t) => watcher.usurped(t.clone()),
+			None => watcher.dropped(),
+		})
+	}
+
+	/// Transaction was removed as invalid.
+	pub fn invalid(&mut self, tx: &H) {
+		debug!(target: LOG_TARGET, "[{:?}] Extrinsic invalid", tx);
+		self.fire(tx, |watcher| watcher.invalid());
+	}
+
+	/// Transaction was pruned from the pool.
+	pub fn pruned(&mut self, block_hash: BlockHash<C>, tx: &H) {
+		debug!(target: LOG_TARGET, "[{:?}] Pruned at {:?}", tx, block_hash);
+		// Get the transactions included in the given block hash.
+		let txs = self.finality_watchers.entry(block_hash).or_insert(vec![]);
+		txs.push(tx.clone());
+		// Current transaction is the last one included.
+		let tx_index = txs.len() - 1;
+
+		self.fire(tx, |watcher| watcher.in_block(block_hash, tx_index));
+
+		while self.finality_watchers.len() > MAX_FINALITY_WATCHERS {
+			if let Some((hash, txs)) = self.finality_watchers.pop_front() {
+				for tx in txs {
+					self.fire(&tx, |watcher| watcher.finality_timeout(hash));
+				}
+			}
+		}
+	}
+
+	/// The block this transaction was included in has been retracted.
+	pub fn retracted(&mut self, block_hash: BlockHash<C>) {
+		if let Some(hashes) = self.finality_watchers.remove(&block_hash) {
+			for hash in hashes {
+				self.fire(&hash, |watcher| watcher.retracted(block_hash))
+			}
+		}
+	}
+
+	/// Notify all watchers that transactions have been finalized
+	pub fn finalized(&mut self, block_hash: BlockHash<C>) {
+		if let Some(hashes) = self.finality_watchers.remove(&block_hash) {
+			for (tx_index, hash) in hashes.into_iter().enumerate() {
+				log::debug!(
+					target: LOG_TARGET,
+					"[{:?}] Sent finalization event (block {:?})",
+					hash,
+					block_hash,
+				);
+				self.fire(&hash, |watcher| watcher.finalized(block_hash, tx_index))
+			}
+		}
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/mod.rs b/substrate/client/transaction-pool/src/graph/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5afdddb7402d163284cfe3279b280c0fecb026a7
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/mod.rs
@@ -0,0 +1,47 @@
+// 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/>.
+
+//! Generic Transaction Pool
+//!
+//! The pool is based on dependency graph between transactions
+//! and their priority.
+//! The pool is able to return an iterator that traverses transaction
+//! graph in the correct order taking into account priorities and dependencies.
+
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+mod future;
+mod listener;
+mod pool;
+mod ready;
+mod rotator;
+mod tracked_map;
+mod validated_pool;
+
+pub mod base_pool;
+pub mod watcher;
+
+pub use self::{
+	base_pool::Transaction,
+	pool::{
+		BlockHash, ChainApi, EventStream, ExtrinsicFor, ExtrinsicHash, NumberFor, Options, Pool,
+		TransactionFor,
+	},
+};
+pub use validated_pool::{IsValidator, ValidatedTransaction};
diff --git a/substrate/client/transaction-pool/src/graph/pool.rs b/substrate/client/transaction-pool/src/graph/pool.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d34737a7ba704d72aaad67de60f6925499db6c3
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/pool.rs
@@ -0,0 +1,1070 @@
+// 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 std::{collections::HashMap, sync::Arc, time::Duration};
+
+use crate::LOG_TARGET;
+use futures::{channel::mpsc::Receiver, Future};
+use sc_transaction_pool_api::error;
+use sp_blockchain::TreeRoute;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{self, Block as BlockT, SaturatedConversion},
+	transaction_validity::{
+		TransactionSource, TransactionTag as Tag, TransactionValidity, TransactionValidityError,
+	},
+};
+use std::time::Instant;
+
+use super::{
+	base_pool as base,
+	validated_pool::{IsValidator, ValidatedPool, ValidatedTransaction},
+	watcher::Watcher,
+};
+
+/// Modification notification event stream type;
+pub type EventStream<H> = Receiver<H>;
+
+/// Block hash type for a pool.
+pub type BlockHash<A> = <<A as ChainApi>::Block as traits::Block>::Hash;
+/// Extrinsic hash type for a pool.
+pub type ExtrinsicHash<A> = <<A as ChainApi>::Block as traits::Block>::Hash;
+/// Extrinsic type for a pool.
+pub type ExtrinsicFor<A> = <<A as ChainApi>::Block as traits::Block>::Extrinsic;
+/// Block number type for the ChainApi
+pub type NumberFor<A> = traits::NumberFor<<A as ChainApi>::Block>;
+/// A type of transaction stored in the pool
+pub type TransactionFor<A> = Arc<base::Transaction<ExtrinsicHash<A>, ExtrinsicFor<A>>>;
+/// A type of validated transaction stored in the pool.
+pub type ValidatedTransactionFor<A> =
+	ValidatedTransaction<ExtrinsicHash<A>, ExtrinsicFor<A>, <A as ChainApi>::Error>;
+
+/// Concrete extrinsic validation and query logic.
+pub trait ChainApi: Send + Sync {
+	/// Block type.
+	type Block: BlockT;
+	/// Error type.
+	type Error: From<error::Error> + error::IntoPoolError;
+	/// Validate transaction future.
+	type ValidationFuture: Future<Output = Result<TransactionValidity, Self::Error>> + Send + Unpin;
+	/// Body future (since block body might be remote)
+	type BodyFuture: Future<Output = Result<Option<Vec<<Self::Block as traits::Block>::Extrinsic>>, Self::Error>>
+		+ Unpin
+		+ Send
+		+ 'static;
+
+	/// Verify extrinsic at given block.
+	fn validate_transaction(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		uxt: ExtrinsicFor<Self>,
+	) -> Self::ValidationFuture;
+
+	/// Returns a block number given the block id.
+	fn block_id_to_number(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<NumberFor<Self>>, Self::Error>;
+
+	/// Returns a block hash given the block id.
+	fn block_id_to_hash(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<<Self::Block as BlockT>::Hash>, Self::Error>;
+
+	/// Returns hash and encoding length of the extrinsic.
+	fn hash_and_length(&self, uxt: &ExtrinsicFor<Self>) -> (ExtrinsicHash<Self>, usize);
+
+	/// Returns a block body given the block.
+	fn block_body(&self, at: <Self::Block as BlockT>::Hash) -> Self::BodyFuture;
+
+	/// Returns a block header given the block id.
+	fn block_header(
+		&self,
+		at: <Self::Block as BlockT>::Hash,
+	) -> Result<Option<<Self::Block as BlockT>::Header>, Self::Error>;
+
+	/// Compute a tree-route between two blocks. See [`TreeRoute`] for more details.
+	fn tree_route(
+		&self,
+		from: <Self::Block as BlockT>::Hash,
+		to: <Self::Block as BlockT>::Hash,
+	) -> Result<TreeRoute<Self::Block>, Self::Error>;
+}
+
+/// Pool configuration options.
+#[derive(Debug, Clone)]
+pub struct Options {
+	/// Ready queue limits.
+	pub ready: base::Limit,
+	/// Future queue limits.
+	pub future: base::Limit,
+	/// Reject future transactions.
+	pub reject_future_transactions: bool,
+	/// How long the extrinsic is banned for.
+	pub ban_time: Duration,
+}
+
+impl Default for Options {
+	fn default() -> Self {
+		Self {
+			ready: base::Limit { count: 8192, total_bytes: 20 * 1024 * 1024 },
+			future: base::Limit { count: 512, total_bytes: 1 * 1024 * 1024 },
+			reject_future_transactions: false,
+			ban_time: Duration::from_secs(60 * 30),
+		}
+	}
+}
+
+/// Should we check that the transaction is banned
+/// in the pool, before we verify it?
+#[derive(Copy, Clone)]
+enum CheckBannedBeforeVerify {
+	Yes,
+	No,
+}
+
+/// Extrinsics pool that performs validation.
+pub struct Pool<B: ChainApi> {
+	validated_pool: Arc<ValidatedPool<B>>,
+}
+
+impl<B: ChainApi> Pool<B> {
+	/// Create a new transaction pool.
+	pub fn new(options: Options, is_validator: IsValidator, api: Arc<B>) -> Self {
+		Self { validated_pool: Arc::new(ValidatedPool::new(options, is_validator, api)) }
+	}
+
+	/// Imports a bunch of unverified extrinsics to the pool
+	pub async fn submit_at(
+		&self,
+		at: &BlockId<B::Block>,
+		source: TransactionSource,
+		xts: impl IntoIterator<Item = ExtrinsicFor<B>>,
+	) -> Result<Vec<Result<ExtrinsicHash<B>, B::Error>>, B::Error> {
+		let xts = xts.into_iter().map(|xt| (source, xt));
+		let validated_transactions = self.verify(at, xts, CheckBannedBeforeVerify::Yes).await?;
+		Ok(self.validated_pool.submit(validated_transactions.into_values()))
+	}
+
+	/// Resubmit the given extrinsics to the pool.
+	///
+	/// This does not check if a transaction is banned, before we verify it again.
+	pub async fn resubmit_at(
+		&self,
+		at: &BlockId<B::Block>,
+		source: TransactionSource,
+		xts: impl IntoIterator<Item = ExtrinsicFor<B>>,
+	) -> Result<Vec<Result<ExtrinsicHash<B>, B::Error>>, B::Error> {
+		let xts = xts.into_iter().map(|xt| (source, xt));
+		let validated_transactions = self.verify(at, xts, CheckBannedBeforeVerify::No).await?;
+		Ok(self.validated_pool.submit(validated_transactions.into_values()))
+	}
+
+	/// Imports one unverified extrinsic to the pool
+	pub async fn submit_one(
+		&self,
+		at: &BlockId<B::Block>,
+		source: TransactionSource,
+		xt: ExtrinsicFor<B>,
+	) -> Result<ExtrinsicHash<B>, B::Error> {
+		let res = self.submit_at(at, source, std::iter::once(xt)).await?.pop();
+		res.expect("One extrinsic passed; one result returned; qed")
+	}
+
+	/// Import a single extrinsic and starts to watch its progress in the pool.
+	pub async fn submit_and_watch(
+		&self,
+		at: &BlockId<B::Block>,
+		source: TransactionSource,
+		xt: ExtrinsicFor<B>,
+	) -> Result<Watcher<ExtrinsicHash<B>, ExtrinsicHash<B>>, B::Error> {
+		let block_number = self.resolve_block_number(at)?;
+		let (_, tx) = self
+			.verify_one(at, block_number, source, xt, CheckBannedBeforeVerify::Yes)
+			.await;
+		self.validated_pool.submit_and_watch(tx)
+	}
+
+	/// Resubmit some transaction that were validated elsewhere.
+	pub fn resubmit(
+		&self,
+		revalidated_transactions: HashMap<ExtrinsicHash<B>, ValidatedTransactionFor<B>>,
+	) {
+		let now = Instant::now();
+		self.validated_pool.resubmit(revalidated_transactions);
+		log::debug!(
+			target: LOG_TARGET,
+			"Resubmitted. Took {} ms. Status: {:?}",
+			now.elapsed().as_millis(),
+			self.validated_pool.status()
+		);
+	}
+
+	/// Prunes known ready transactions.
+	///
+	/// Used to clear the pool from transactions that were part of recently imported block.
+	/// The main difference from the `prune` is that we do not revalidate any transactions
+	/// and ignore unknown passed hashes.
+	pub fn prune_known(
+		&self,
+		at: &BlockId<B::Block>,
+		hashes: &[ExtrinsicHash<B>],
+	) -> Result<(), B::Error> {
+		// Get details of all extrinsics that are already in the pool
+		let in_pool_tags =
+			self.validated_pool.extrinsics_tags(hashes).into_iter().flatten().flatten();
+
+		// Prune all transactions that provide given tags
+		let prune_status = self.validated_pool.prune_tags(in_pool_tags)?;
+		let pruned_transactions =
+			hashes.iter().cloned().chain(prune_status.pruned.iter().map(|tx| tx.hash));
+		self.validated_pool.fire_pruned(at, pruned_transactions)
+	}
+
+	/// Prunes ready transactions.
+	///
+	/// Used to clear the pool from transactions that were part of recently imported block.
+	/// To perform pruning we need the tags that each extrinsic provides and to avoid calling
+	/// into runtime too often we first lookup all extrinsics that are in the pool and get
+	/// their provided tags from there. Otherwise we query the runtime at the `parent` block.
+	pub async fn prune(
+		&self,
+		at: &BlockId<B::Block>,
+		parent: &BlockId<B::Block>,
+		extrinsics: &[ExtrinsicFor<B>],
+	) -> Result<(), B::Error> {
+		log::debug!(
+			target: LOG_TARGET,
+			"Starting pruning of block {:?} (extrinsics: {})",
+			at,
+			extrinsics.len()
+		);
+		// Get details of all extrinsics that are already in the pool
+		let in_pool_hashes =
+			extrinsics.iter().map(|extrinsic| self.hash_of(extrinsic)).collect::<Vec<_>>();
+		let in_pool_tags = self.validated_pool.extrinsics_tags(&in_pool_hashes);
+
+		// Zip the ones from the pool with the full list (we get pairs `(Extrinsic,
+		// Option<Vec<Tag>>)`)
+		let all = extrinsics.iter().zip(in_pool_tags.into_iter());
+
+		let mut future_tags = Vec::new();
+		for (extrinsic, in_pool_tags) in all {
+			match in_pool_tags {
+				// reuse the tags for extrinsics that were found in the pool
+				Some(tags) => future_tags.extend(tags),
+				// if it's not found in the pool query the runtime at parent block
+				// to get validity info and tags that the extrinsic provides.
+				None => {
+					// Avoid validating block txs if the pool is empty
+					if !self.validated_pool.status().is_empty() {
+						let validity = self
+							.validated_pool
+							.api()
+							.validate_transaction(
+								parent,
+								TransactionSource::InBlock,
+								extrinsic.clone(),
+							)
+							.await;
+
+						if let Ok(Ok(validity)) = validity {
+							future_tags.extend(validity.provides);
+						}
+					} else {
+						log::trace!(
+							target: LOG_TARGET,
+							"txpool is empty, skipping validation for block {at:?}",
+						);
+					}
+				},
+			}
+		}
+
+		self.prune_tags(at, future_tags, in_pool_hashes).await
+	}
+
+	/// Prunes ready transactions that provide given list of tags.
+	///
+	/// Given tags are assumed to be always provided now, so all transactions
+	/// in the Future Queue that require that particular tag (and have other
+	/// requirements satisfied) are promoted to Ready Queue.
+	///
+	/// Moreover for each provided tag we remove transactions in the pool that:
+	/// 1. Provide that tag directly
+	/// 2. Are a dependency of pruned transaction.
+	///
+	/// Returns transactions that have been removed from the pool and must be reverified
+	/// before reinserting to the pool.
+	///
+	/// By removing predecessor transactions as well we might actually end up
+	/// pruning too much, so all removed transactions are reverified against
+	/// the runtime (`validate_transaction`) to make sure they are invalid.
+	///
+	/// However we avoid revalidating transactions that are contained within
+	/// the second parameter of `known_imported_hashes`. These transactions
+	/// (if pruned) are not revalidated and become temporarily banned to
+	/// prevent importing them in the (near) future.
+	pub async fn prune_tags(
+		&self,
+		at: &BlockId<B::Block>,
+		tags: impl IntoIterator<Item = Tag>,
+		known_imported_hashes: impl IntoIterator<Item = ExtrinsicHash<B>> + Clone,
+	) -> Result<(), B::Error> {
+		log::debug!(target: LOG_TARGET, "Pruning at {:?}", at);
+		// Prune all transactions that provide given tags
+		let prune_status = self.validated_pool.prune_tags(tags)?;
+
+		// Make sure that we don't revalidate extrinsics that were part of the recently
+		// imported block. This is especially important for UTXO-like chains cause the
+		// inputs are pruned so such transaction would go to future again.
+		self.validated_pool
+			.ban(&Instant::now(), known_imported_hashes.clone().into_iter());
+
+		// Try to re-validate pruned transactions since some of them might be still valid.
+		// note that `known_imported_hashes` will be rejected here due to temporary ban.
+		let pruned_hashes = prune_status.pruned.iter().map(|tx| tx.hash).collect::<Vec<_>>();
+		let pruned_transactions =
+			prune_status.pruned.into_iter().map(|tx| (tx.source, tx.data.clone()));
+
+		let reverified_transactions =
+			self.verify(at, pruned_transactions, CheckBannedBeforeVerify::Yes).await?;
+
+		log::trace!(target: LOG_TARGET, "Pruning at {:?}. Resubmitting transactions.", at);
+		// And finally - submit reverified transactions back to the pool
+
+		self.validated_pool.resubmit_pruned(
+			at,
+			known_imported_hashes,
+			pruned_hashes,
+			reverified_transactions.into_values().collect(),
+		)
+	}
+
+	/// Returns transaction hash
+	pub fn hash_of(&self, xt: &ExtrinsicFor<B>) -> ExtrinsicHash<B> {
+		self.validated_pool.api().hash_and_length(xt).0
+	}
+
+	/// Resolves block number by id.
+	fn resolve_block_number(&self, at: &BlockId<B::Block>) -> Result<NumberFor<B>, B::Error> {
+		self.validated_pool.api().block_id_to_number(at).and_then(|number| {
+			number.ok_or_else(|| error::Error::InvalidBlockId(format!("{:?}", at)).into())
+		})
+	}
+
+	/// Returns future that validates a bunch of transactions at given block.
+	async fn verify(
+		&self,
+		at: &BlockId<B::Block>,
+		xts: impl IntoIterator<Item = (TransactionSource, ExtrinsicFor<B>)>,
+		check: CheckBannedBeforeVerify,
+	) -> Result<HashMap<ExtrinsicHash<B>, ValidatedTransactionFor<B>>, B::Error> {
+		// we need a block number to compute tx validity
+		let block_number = self.resolve_block_number(at)?;
+
+		let res = futures::future::join_all(
+			xts.into_iter()
+				.map(|(source, xt)| self.verify_one(at, block_number, source, xt, check)),
+		)
+		.await
+		.into_iter()
+		.collect::<HashMap<_, _>>();
+
+		Ok(res)
+	}
+
+	/// Returns future that validates single transaction at given block.
+	async fn verify_one(
+		&self,
+		block_id: &BlockId<B::Block>,
+		block_number: NumberFor<B>,
+		source: TransactionSource,
+		xt: ExtrinsicFor<B>,
+		check: CheckBannedBeforeVerify,
+	) -> (ExtrinsicHash<B>, ValidatedTransactionFor<B>) {
+		let (hash, bytes) = self.validated_pool.api().hash_and_length(&xt);
+
+		let ignore_banned = matches!(check, CheckBannedBeforeVerify::No);
+		if let Err(err) = self.validated_pool.check_is_known(&hash, ignore_banned) {
+			return (hash, ValidatedTransaction::Invalid(hash, err))
+		}
+
+		let validation_result = self
+			.validated_pool
+			.api()
+			.validate_transaction(block_id, source, xt.clone())
+			.await;
+
+		let status = match validation_result {
+			Ok(status) => status,
+			Err(e) => return (hash, ValidatedTransaction::Invalid(hash, e)),
+		};
+
+		let validity = match status {
+			Ok(validity) =>
+				if validity.provides.is_empty() {
+					ValidatedTransaction::Invalid(hash, error::Error::NoTagsProvided.into())
+				} else {
+					ValidatedTransaction::valid_at(
+						block_number.saturated_into::<u64>(),
+						hash,
+						source,
+						xt,
+						bytes,
+						validity,
+					)
+				},
+			Err(TransactionValidityError::Invalid(e)) =>
+				ValidatedTransaction::Invalid(hash, error::Error::InvalidTransaction(e).into()),
+			Err(TransactionValidityError::Unknown(e)) =>
+				ValidatedTransaction::Unknown(hash, error::Error::UnknownTransaction(e).into()),
+		};
+
+		(hash, validity)
+	}
+
+	/// get a reference to the underlying validated pool.
+	pub fn validated_pool(&self) -> &ValidatedPool<B> {
+		&self.validated_pool
+	}
+}
+
+impl<B: ChainApi> Clone for Pool<B> {
+	fn clone(&self) -> Self {
+		Self { validated_pool: self.validated_pool.clone() }
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{super::base_pool::Limit, *};
+	use crate::tests::{pool, uxt, TestApi, INVALID_NONCE};
+	use assert_matches::assert_matches;
+	use futures::executor::block_on;
+	use parking_lot::Mutex;
+	use sc_transaction_pool_api::TransactionStatus;
+	use sp_runtime::transaction_validity::TransactionSource;
+	use std::{collections::HashMap, time::Instant};
+	use substrate_test_runtime::{AccountId, ExtrinsicBuilder, Transfer, H256};
+	use substrate_test_runtime_client::AccountKeyring::{Alice, Bob};
+
+	const SOURCE: TransactionSource = TransactionSource::External;
+
+	#[test]
+	fn should_validate_and_import_transaction() {
+		// given
+		let pool = pool();
+
+		// when
+		let hash = block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 0,
+			}),
+		))
+		.unwrap();
+
+		// then
+		assert_eq!(pool.validated_pool().ready().map(|v| v.hash).collect::<Vec<_>>(), vec![hash]);
+	}
+
+	#[test]
+	fn should_reject_if_temporarily_banned() {
+		// given
+		let pool = pool();
+		let uxt = uxt(Transfer {
+			from: Alice.into(),
+			to: AccountId::from_h256(H256::from_low_u64_be(2)),
+			amount: 5,
+			nonce: 0,
+		});
+
+		// when
+		pool.validated_pool.ban(&Instant::now(), vec![pool.hash_of(&uxt)]);
+		let res = block_on(pool.submit_one(&BlockId::Number(0), SOURCE, uxt));
+		assert_eq!(pool.validated_pool().status().ready, 0);
+		assert_eq!(pool.validated_pool().status().future, 0);
+
+		// then
+		assert_matches!(res.unwrap_err(), error::Error::TemporarilyBanned);
+	}
+
+	#[test]
+	fn should_reject_unactionable_transactions() {
+		// given
+		let pool = Pool::new(
+			Default::default(),
+			// the node does not author blocks
+			false.into(),
+			TestApi::default().into(),
+		);
+
+		// after validation `IncludeData` will be set to non-propagable (validate_transaction mock)
+		let uxt = ExtrinsicBuilder::new_include_data(vec![42]).build();
+
+		// when
+		let res = block_on(pool.submit_one(&BlockId::Number(0), SOURCE, uxt));
+
+		// then
+		assert_matches!(res.unwrap_err(), error::Error::Unactionable);
+	}
+
+	#[test]
+	fn should_notify_about_pool_events() {
+		let (stream, hash0, hash1) = {
+			// given
+			let pool = pool();
+			let stream = pool.validated_pool().import_notification_stream();
+
+			// when
+			let hash0 = block_on(pool.submit_one(
+				&BlockId::Number(0),
+				SOURCE,
+				uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 0,
+				}),
+			))
+			.unwrap();
+			let hash1 = block_on(pool.submit_one(
+				&BlockId::Number(0),
+				SOURCE,
+				uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 1,
+				}),
+			))
+			.unwrap();
+			// future doesn't count
+			let _hash = block_on(pool.submit_one(
+				&BlockId::Number(0),
+				SOURCE,
+				uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 3,
+				}),
+			))
+			.unwrap();
+
+			assert_eq!(pool.validated_pool().status().ready, 2);
+			assert_eq!(pool.validated_pool().status().future, 1);
+
+			(stream, hash0, hash1)
+		};
+
+		// then
+		let mut it = futures::executor::block_on_stream(stream);
+		assert_eq!(it.next(), Some(hash0));
+		assert_eq!(it.next(), Some(hash1));
+		assert_eq!(it.next(), None);
+	}
+
+	#[test]
+	fn should_clear_stale_transactions() {
+		// given
+		let pool = pool();
+		let hash1 = block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 0,
+			}),
+		))
+		.unwrap();
+		let hash2 = block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 1,
+			}),
+		))
+		.unwrap();
+		let hash3 = block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 3,
+			}),
+		))
+		.unwrap();
+
+		// when
+		pool.validated_pool.clear_stale(&BlockId::Number(5)).unwrap();
+
+		// then
+		assert_eq!(pool.validated_pool().ready().count(), 0);
+		assert_eq!(pool.validated_pool().status().future, 0);
+		assert_eq!(pool.validated_pool().status().ready, 0);
+		// make sure they are temporarily banned as well
+		assert!(pool.validated_pool.is_banned(&hash1));
+		assert!(pool.validated_pool.is_banned(&hash2));
+		assert!(pool.validated_pool.is_banned(&hash3));
+	}
+
+	#[test]
+	fn should_ban_mined_transactions() {
+		// given
+		let pool = pool();
+		let hash1 = block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 0,
+			}),
+		))
+		.unwrap();
+
+		// when
+		block_on(pool.prune_tags(&BlockId::Number(1), vec![vec![0]], vec![hash1])).unwrap();
+
+		// then
+		assert!(pool.validated_pool.is_banned(&hash1));
+	}
+	use codec::Encode;
+
+	#[test]
+	fn should_limit_futures() {
+		sp_tracing::try_init_simple();
+
+		let xt = uxt(Transfer {
+			from: Alice.into(),
+			to: AccountId::from_h256(H256::from_low_u64_be(2)),
+			amount: 5,
+			nonce: 1,
+		});
+
+		// given
+		let limit = Limit { count: 100, total_bytes: xt.encoded_size() };
+
+		let options = Options { ready: limit.clone(), future: limit.clone(), ..Default::default() };
+
+		let pool = Pool::new(options, true.into(), TestApi::default().into());
+
+		let hash1 = block_on(pool.submit_one(&BlockId::Number(0), SOURCE, xt)).unwrap();
+		assert_eq!(pool.validated_pool().status().future, 1);
+
+		// when
+		let hash2 = block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Bob.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 10,
+			}),
+		))
+		.unwrap();
+
+		// then
+		assert_eq!(pool.validated_pool().status().future, 1);
+		assert!(pool.validated_pool.is_banned(&hash1));
+		assert!(!pool.validated_pool.is_banned(&hash2));
+	}
+
+	#[test]
+	fn should_error_if_reject_immediately() {
+		// given
+		let limit = Limit { count: 100, total_bytes: 10 };
+
+		let options = Options { ready: limit.clone(), future: limit.clone(), ..Default::default() };
+
+		let pool = Pool::new(options, true.into(), TestApi::default().into());
+
+		// when
+		block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 1,
+			}),
+		))
+		.unwrap_err();
+
+		// then
+		assert_eq!(pool.validated_pool().status().ready, 0);
+		assert_eq!(pool.validated_pool().status().future, 0);
+	}
+
+	#[test]
+	fn should_reject_transactions_with_no_provides() {
+		// given
+		let pool = pool();
+
+		// when
+		let err = block_on(pool.submit_one(
+			&BlockId::Number(0),
+			SOURCE,
+			uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: INVALID_NONCE,
+			}),
+		))
+		.unwrap_err();
+
+		// then
+		assert_eq!(pool.validated_pool().status().ready, 0);
+		assert_eq!(pool.validated_pool().status().future, 0);
+		assert_matches!(err, error::Error::NoTagsProvided);
+	}
+
+	mod listener {
+		use super::*;
+
+		#[test]
+		fn should_trigger_ready_and_finalized() {
+			// given
+			let pool = pool();
+			let watcher = block_on(pool.submit_and_watch(
+				&BlockId::Number(0),
+				SOURCE,
+				uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 0,
+				}),
+			))
+			.unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 1);
+			assert_eq!(pool.validated_pool().status().future, 0);
+
+			// when
+			block_on(pool.prune_tags(&BlockId::Number(2), vec![vec![0u8]], vec![])).unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 0);
+			assert_eq!(pool.validated_pool().status().future, 0);
+
+			// then
+			let mut stream = futures::executor::block_on_stream(watcher.into_stream());
+			assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+			assert_eq!(
+				stream.next(),
+				Some(TransactionStatus::InBlock((H256::from_low_u64_be(2).into(), 0))),
+			);
+		}
+
+		#[test]
+		fn should_trigger_ready_and_finalized_when_pruning_via_hash() {
+			// given
+			let pool = pool();
+			let watcher = block_on(pool.submit_and_watch(
+				&BlockId::Number(0),
+				SOURCE,
+				uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 0,
+				}),
+			))
+			.unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 1);
+			assert_eq!(pool.validated_pool().status().future, 0);
+
+			// when
+			block_on(pool.prune_tags(&BlockId::Number(2), vec![vec![0u8]], vec![*watcher.hash()]))
+				.unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 0);
+			assert_eq!(pool.validated_pool().status().future, 0);
+
+			// then
+			let mut stream = futures::executor::block_on_stream(watcher.into_stream());
+			assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+			assert_eq!(
+				stream.next(),
+				Some(TransactionStatus::InBlock((H256::from_low_u64_be(2).into(), 0))),
+			);
+		}
+
+		#[test]
+		fn should_trigger_future_and_ready_after_promoted() {
+			// given
+			let pool = pool();
+			let watcher = block_on(pool.submit_and_watch(
+				&BlockId::Number(0),
+				SOURCE,
+				uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 1,
+				}),
+			))
+			.unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 0);
+			assert_eq!(pool.validated_pool().status().future, 1);
+
+			// when
+			block_on(pool.submit_one(
+				&BlockId::Number(0),
+				SOURCE,
+				uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 0,
+				}),
+			))
+			.unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 2);
+
+			// then
+			let mut stream = futures::executor::block_on_stream(watcher.into_stream());
+			assert_eq!(stream.next(), Some(TransactionStatus::Future));
+			assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		}
+
+		#[test]
+		fn should_trigger_invalid_and_ban() {
+			// given
+			let pool = pool();
+			let uxt = uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 0,
+			});
+			let watcher =
+				block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, uxt)).unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 1);
+
+			// when
+			pool.validated_pool.remove_invalid(&[*watcher.hash()]);
+
+			// then
+			let mut stream = futures::executor::block_on_stream(watcher.into_stream());
+			assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+			assert_eq!(stream.next(), Some(TransactionStatus::Invalid));
+			assert_eq!(stream.next(), None);
+		}
+
+		#[test]
+		fn should_trigger_broadcasted() {
+			// given
+			let pool = pool();
+			let uxt = uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 0,
+			});
+			let watcher =
+				block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, uxt)).unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 1);
+
+			// when
+			let mut map = HashMap::new();
+			let peers = vec!["a".into(), "b".into(), "c".into()];
+			map.insert(*watcher.hash(), peers.clone());
+			pool.validated_pool().on_broadcasted(map);
+
+			// then
+			let mut stream = futures::executor::block_on_stream(watcher.into_stream());
+			assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+			assert_eq!(stream.next(), Some(TransactionStatus::Broadcast(peers)));
+		}
+
+		#[test]
+		fn should_trigger_dropped_older() {
+			// given
+			let limit = Limit { count: 1, total_bytes: 1000 };
+			let options =
+				Options { ready: limit.clone(), future: limit.clone(), ..Default::default() };
+
+			let pool = Pool::new(options, true.into(), TestApi::default().into());
+
+			let xt = uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 0,
+			});
+			let watcher = block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, xt)).unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 1);
+
+			// when
+			let xt = uxt(Transfer {
+				from: Bob.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(1)),
+				amount: 4,
+				nonce: 1,
+			});
+			block_on(pool.submit_one(&BlockId::Number(1), SOURCE, xt)).unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 1);
+
+			// then
+			let mut stream = futures::executor::block_on_stream(watcher.into_stream());
+			assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+			assert_eq!(stream.next(), Some(TransactionStatus::Dropped));
+		}
+
+		#[test]
+		fn should_trigger_dropped_lower_priority() {
+			{
+				// given
+				let limit = Limit { count: 1, total_bytes: 1000 };
+				let options =
+					Options { ready: limit.clone(), future: limit.clone(), ..Default::default() };
+
+				let pool = Pool::new(options, true.into(), TestApi::default().into());
+
+				// after validation `IncludeData` will have priority set to 9001
+				// (validate_transaction mock)
+				let xt = ExtrinsicBuilder::new_include_data(Vec::new()).build();
+				block_on(pool.submit_one(&BlockId::Number(0), SOURCE, xt)).unwrap();
+				assert_eq!(pool.validated_pool().status().ready, 1);
+
+				// then
+				// after validation `Transfer` will have priority set to 4 (validate_transaction
+				// mock)
+				let xt = uxt(Transfer {
+					from: Bob.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(1)),
+					amount: 4,
+					nonce: 1,
+				});
+				let result = block_on(pool.submit_one(&BlockId::Number(1), SOURCE, xt));
+				assert!(matches!(
+					result,
+					Err(sc_transaction_pool_api::error::Error::ImmediatelyDropped)
+				));
+			}
+			{
+				// given
+				let limit = Limit { count: 2, total_bytes: 1000 };
+				let options =
+					Options { ready: limit.clone(), future: limit.clone(), ..Default::default() };
+
+				let pool = Pool::new(options, true.into(), TestApi::default().into());
+
+				// after validation `IncludeData` will have priority set to 9001
+				// (validate_transaction mock)
+				let xt = ExtrinsicBuilder::new_include_data(Vec::new()).build();
+				block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, xt)).unwrap();
+				assert_eq!(pool.validated_pool().status().ready, 1);
+
+				// after validation `Transfer` will have priority set to 4 (validate_transaction
+				// mock)
+				let xt = uxt(Transfer {
+					from: Alice.into(),
+					to: AccountId::from_h256(H256::from_low_u64_be(2)),
+					amount: 5,
+					nonce: 0,
+				});
+				let watcher =
+					block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, xt)).unwrap();
+				assert_eq!(pool.validated_pool().status().ready, 2);
+
+				// when
+				// after validation `Store` will have priority set to 9001 (validate_transaction
+				// mock)
+				let xt = ExtrinsicBuilder::new_indexed_call(Vec::new()).build();
+				block_on(pool.submit_one(&BlockId::Number(1), SOURCE, xt)).unwrap();
+				assert_eq!(pool.validated_pool().status().ready, 2);
+
+				// then
+				let mut stream = futures::executor::block_on_stream(watcher.into_stream());
+				assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+				assert_eq!(stream.next(), Some(TransactionStatus::Dropped));
+			}
+		}
+
+		#[test]
+		fn should_handle_pruning_in_the_middle_of_import() {
+			// given
+			let (ready, is_ready) = std::sync::mpsc::sync_channel(0);
+			let (tx, rx) = std::sync::mpsc::sync_channel(1);
+			let mut api = TestApi::default();
+			api.delay = Arc::new(Mutex::new(rx.into()));
+			let pool = Arc::new(Pool::new(Default::default(), true.into(), api.into()));
+
+			// when
+			let xt = uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 5,
+				nonce: 1,
+			});
+
+			// This transaction should go to future, since we use `nonce: 1`
+			let pool2 = pool.clone();
+			std::thread::spawn(move || {
+				block_on(pool2.submit_one(&BlockId::Number(0), SOURCE, xt)).unwrap();
+				ready.send(()).unwrap();
+			});
+
+			// But now before the previous one is imported we import
+			// the one that it depends on.
+			let xt = uxt(Transfer {
+				from: Alice.into(),
+				to: AccountId::from_h256(H256::from_low_u64_be(2)),
+				amount: 4,
+				nonce: 0,
+			});
+			// The tag the above transaction provides (TestApi is using just nonce as u8)
+			let provides = vec![0_u8];
+			block_on(pool.submit_one(&BlockId::Number(0), SOURCE, xt)).unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 1);
+
+			// Now block import happens before the second transaction is able to finish
+			// verification.
+			block_on(pool.prune_tags(&BlockId::Number(1), vec![provides], vec![])).unwrap();
+			assert_eq!(pool.validated_pool().status().ready, 0);
+
+			// so when we release the verification of the previous one it will have
+			// something in `requires`, but should go to ready directly, since the previous
+			// transaction was imported correctly.
+			tx.send(()).unwrap();
+
+			// then
+			is_ready.recv().unwrap(); // wait for finish
+			assert_eq!(pool.validated_pool().status().ready, 1);
+			assert_eq!(pool.validated_pool().status().future, 0);
+		}
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/ready.rs b/substrate/client/transaction-pool/src/graph/ready.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b4a5d9e3ba7196a21a7f316522c766294838aceb
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/ready.rs
@@ -0,0 +1,793 @@
+// 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 std::{
+	cmp,
+	collections::{BTreeSet, HashMap, HashSet},
+	hash,
+	sync::Arc,
+};
+
+use crate::LOG_TARGET;
+use log::{debug, trace};
+use sc_transaction_pool_api::error;
+use serde::Serialize;
+use sp_runtime::{traits::Member, transaction_validity::TransactionTag as Tag};
+
+use super::{
+	base_pool::Transaction,
+	future::WaitingTransaction,
+	tracked_map::{self, TrackedMap},
+};
+
+/// An in-pool transaction reference.
+///
+/// Should be cheap to clone.
+#[derive(Debug)]
+pub struct TransactionRef<Hash, Ex> {
+	/// The actual transaction data.
+	pub transaction: Arc<Transaction<Hash, Ex>>,
+	/// Unique id when transaction was inserted into the pool.
+	pub insertion_id: u64,
+}
+
+impl<Hash, Ex> Clone for TransactionRef<Hash, Ex> {
+	fn clone(&self) -> Self {
+		Self { transaction: self.transaction.clone(), insertion_id: self.insertion_id }
+	}
+}
+
+impl<Hash, Ex> Ord for TransactionRef<Hash, Ex> {
+	fn cmp(&self, other: &Self) -> cmp::Ordering {
+		self.transaction
+			.priority
+			.cmp(&other.transaction.priority)
+			.then_with(|| other.transaction.valid_till.cmp(&self.transaction.valid_till))
+			.then_with(|| other.insertion_id.cmp(&self.insertion_id))
+	}
+}
+
+impl<Hash, Ex> PartialOrd for TransactionRef<Hash, Ex> {
+	fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl<Hash, Ex> PartialEq for TransactionRef<Hash, Ex> {
+	fn eq(&self, other: &Self) -> bool {
+		self.cmp(other) == cmp::Ordering::Equal
+	}
+}
+impl<Hash, Ex> Eq for TransactionRef<Hash, Ex> {}
+
+#[derive(Debug)]
+pub struct ReadyTx<Hash, Ex> {
+	/// A reference to a transaction
+	pub transaction: TransactionRef<Hash, Ex>,
+	/// A list of transactions that get unlocked by this one
+	pub unlocks: Vec<Hash>,
+	/// How many required tags are provided inherently
+	///
+	/// Some transactions might be already pruned from the queue,
+	/// so when we compute ready set we may consider this transactions ready earlier.
+	pub requires_offset: usize,
+}
+
+impl<Hash: Clone, Ex> Clone for ReadyTx<Hash, Ex> {
+	fn clone(&self) -> Self {
+		Self {
+			transaction: self.transaction.clone(),
+			unlocks: self.unlocks.clone(),
+			requires_offset: self.requires_offset,
+		}
+	}
+}
+
+const HASH_READY: &str = r#"
+Every time transaction is imported its hash is placed in `ready` map and tags in `provided_tags`;
+Every time transaction is removed from the queue we remove the hash from `ready` map and from `provided_tags`;
+Hence every hash retrieved from `provided_tags` is always present in `ready`;
+qed
+"#;
+
+/// Validated transactions that are block ready with all their dependencies met.
+#[derive(Debug)]
+pub struct ReadyTransactions<Hash: hash::Hash + Eq, Ex> {
+	/// Next free insertion id (used to indicate when a transaction was inserted into the pool).
+	insertion_id: u64,
+	/// tags that are provided by Ready transactions
+	/// (only a single transaction can provide a specific tag)
+	provided_tags: HashMap<Tag, Hash>,
+	/// Transactions that are ready (i.e. don't have any requirements external to the pool)
+	ready: TrackedMap<Hash, ReadyTx<Hash, Ex>>,
+	/// Best transactions that are ready to be included to the block without any other previous
+	/// transaction.
+	best: BTreeSet<TransactionRef<Hash, Ex>>,
+}
+
+impl<Hash, Ex> tracked_map::Size for ReadyTx<Hash, Ex> {
+	fn size(&self) -> usize {
+		self.transaction.transaction.bytes
+	}
+}
+
+impl<Hash: hash::Hash + Eq, Ex> Default for ReadyTransactions<Hash, Ex> {
+	fn default() -> Self {
+		Self {
+			insertion_id: Default::default(),
+			provided_tags: Default::default(),
+			ready: Default::default(),
+			best: Default::default(),
+		}
+	}
+}
+
+impl<Hash: hash::Hash + Member + Serialize, Ex> ReadyTransactions<Hash, Ex> {
+	/// Borrows a map of tags that are provided by transactions in this queue.
+	pub fn provided_tags(&self) -> &HashMap<Tag, Hash> {
+		&self.provided_tags
+	}
+
+	/// Returns an iterator of ready transactions.
+	///
+	/// Transactions are returned in order:
+	/// 1. First by the dependencies:
+	/// 	- never return transaction that requires a tag, which was not provided by one of the
+	///    previously
+	/// returned transactions
+	/// 2. Then by priority:
+	/// - If there are two transactions with all requirements satisfied the one with higher priority
+	///   goes first.
+	/// 3. Then by the ttl that's left
+	/// - transactions that are valid for a shorter time go first
+	/// 4. Lastly we sort by the time in the queue
+	/// - transactions that are longer in the queue go first
+	///
+	/// The iterator is providing a way to report transactions that the receiver considers invalid.
+	/// In such case the entire subgraph of transactions that depend on the reported one will be
+	/// skipped.
+	pub fn get(&self) -> BestIterator<Hash, Ex> {
+		BestIterator {
+			all: self.ready.clone_map(),
+			best: self.best.clone(),
+			awaiting: Default::default(),
+			invalid: Default::default(),
+		}
+	}
+
+	/// Imports transactions to the pool of ready transactions.
+	///
+	/// The transaction needs to have all tags satisfied (be ready) by transactions
+	/// that are in this queue.
+	/// Returns transactions that were replaced by the one imported.
+	pub fn import(
+		&mut self,
+		tx: WaitingTransaction<Hash, Ex>,
+	) -> error::Result<Vec<Arc<Transaction<Hash, Ex>>>> {
+		assert!(
+			tx.is_ready(),
+			"Only ready transactions can be imported. Missing: {:?}",
+			tx.missing_tags
+		);
+		assert!(
+			!self.ready.read().contains_key(&tx.transaction.hash),
+			"Transaction is already imported."
+		);
+
+		self.insertion_id += 1;
+		let insertion_id = self.insertion_id;
+		let hash = tx.transaction.hash.clone();
+		let transaction = tx.transaction;
+
+		let (replaced, unlocks) = self.replace_previous(&transaction)?;
+
+		let mut goes_to_best = true;
+		let mut ready = self.ready.write();
+		let mut requires_offset = 0;
+		// Add links to transactions that unlock the current one
+		for tag in &transaction.requires {
+			// Check if the transaction that satisfies the tag is still in the queue.
+			if let Some(other) = self.provided_tags.get(tag) {
+				let tx = ready.get_mut(other).expect(HASH_READY);
+				tx.unlocks.push(hash.clone());
+				// this transaction depends on some other, so it doesn't go to best directly.
+				goes_to_best = false;
+			} else {
+				requires_offset += 1;
+			}
+		}
+
+		// update provided_tags
+		// call to replace_previous guarantees that we will be overwriting
+		// only entries that have been removed.
+		for tag in &transaction.provides {
+			self.provided_tags.insert(tag.clone(), hash.clone());
+		}
+
+		let transaction = TransactionRef { insertion_id, transaction };
+
+		// insert to best if it doesn't require any other transaction to be included before it
+		if goes_to_best {
+			self.best.insert(transaction.clone());
+		}
+
+		// insert to Ready
+		ready.insert(hash, ReadyTx { transaction, unlocks, requires_offset });
+
+		Ok(replaced)
+	}
+
+	/// Fold a list of ready transactions to compute a single value.
+	pub fn fold<R, F: FnMut(Option<R>, &ReadyTx<Hash, Ex>) -> Option<R>>(
+		&mut self,
+		f: F,
+	) -> Option<R> {
+		self.ready.read().values().fold(None, f)
+	}
+
+	/// Returns true if given transaction is part of the queue.
+	pub fn contains(&self, hash: &Hash) -> bool {
+		self.ready.read().contains_key(hash)
+	}
+
+	/// Retrieve transaction by hash
+	pub fn by_hash(&self, hash: &Hash) -> Option<Arc<Transaction<Hash, Ex>>> {
+		self.by_hashes(&[hash.clone()]).into_iter().next().unwrap_or(None)
+	}
+
+	/// Retrieve transactions by hash
+	pub fn by_hashes(&self, hashes: &[Hash]) -> Vec<Option<Arc<Transaction<Hash, Ex>>>> {
+		let ready = self.ready.read();
+		hashes
+			.iter()
+			.map(|hash| ready.get(hash).map(|x| x.transaction.transaction.clone()))
+			.collect()
+	}
+
+	/// Removes a subtree of transactions from the ready pool.
+	///
+	/// NOTE removing a transaction will also cause a removal of all transactions that depend on
+	/// that one (i.e. the entire subgraph that this transaction is a start of will be removed).
+	/// All removed transactions are returned.
+	pub fn remove_subtree(&mut self, hashes: &[Hash]) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		let to_remove = hashes.to_vec();
+		self.remove_subtree_with_tag_filter(to_remove, None)
+	}
+
+	/// Removes a subtrees of transactions trees starting from roots given in `to_remove`.
+	///
+	/// We proceed with a particular branch only if there is at least one provided tag
+	/// that is not part of `provides_tag_filter`. I.e. the filter contains tags
+	/// that will stay in the pool, so that we can early exit and avoid descending.
+	fn remove_subtree_with_tag_filter(
+		&mut self,
+		mut to_remove: Vec<Hash>,
+		provides_tag_filter: Option<HashSet<Tag>>,
+	) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		let mut removed = vec![];
+		let mut ready = self.ready.write();
+		while let Some(hash) = to_remove.pop() {
+			if let Some(mut tx) = ready.remove(&hash) {
+				let invalidated = tx.transaction.transaction.provides.iter().filter(|tag| {
+					provides_tag_filter
+						.as_ref()
+						.map(|filter| !filter.contains(&**tag))
+						.unwrap_or(true)
+				});
+
+				let mut removed_some_tags = false;
+				// remove entries from provided_tags
+				for tag in invalidated {
+					removed_some_tags = true;
+					self.provided_tags.remove(tag);
+				}
+
+				// remove from unlocks
+				for tag in &tx.transaction.transaction.requires {
+					if let Some(hash) = self.provided_tags.get(tag) {
+						if let Some(tx) = ready.get_mut(hash) {
+							remove_item(&mut tx.unlocks, hash);
+						}
+					}
+				}
+
+				// remove from best
+				self.best.remove(&tx.transaction);
+
+				if removed_some_tags {
+					// remove all transactions that the current one unlocks
+					to_remove.append(&mut tx.unlocks);
+				}
+
+				// add to removed
+				trace!(target: LOG_TARGET, "[{:?}] Removed as part of the subtree.", hash);
+				removed.push(tx.transaction.transaction);
+			}
+		}
+
+		removed
+	}
+
+	/// Removes transactions that provide given tag.
+	///
+	/// All transactions that lead to a transaction, which provides this tag
+	/// are going to be removed from the queue, but no other transactions are touched -
+	/// i.e. all other subgraphs starting from given tag are still considered valid & ready.
+	pub fn prune_tags(&mut self, tag: Tag) -> Vec<Arc<Transaction<Hash, Ex>>> {
+		let mut removed = vec![];
+		let mut to_remove = vec![tag];
+
+		while let Some(tag) = to_remove.pop() {
+			let res = self
+				.provided_tags
+				.remove(&tag)
+				.and_then(|hash| self.ready.write().remove(&hash));
+
+			if let Some(tx) = res {
+				let unlocks = tx.unlocks;
+
+				// Make sure we remove it from best txs
+				self.best.remove(&tx.transaction);
+
+				let tx = tx.transaction.transaction;
+
+				// prune previous transactions as well
+				{
+					let hash = &tx.hash;
+					let mut ready = self.ready.write();
+					let mut find_previous = |tag| -> Option<Vec<Tag>> {
+						let prev_hash = self.provided_tags.get(tag)?;
+						let tx2 = ready.get_mut(prev_hash)?;
+						remove_item(&mut tx2.unlocks, hash);
+						// We eagerly prune previous transactions as well.
+						// But it might not always be good.
+						// Possible edge case:
+						// - tx provides two tags
+						// - the second tag enables some subgraph we don't know of yet
+						// - we will prune the transaction
+						// - when we learn about the subgraph it will go to future
+						// - we will have to wait for re-propagation of that transaction
+						// Alternatively the caller may attempt to re-import these transactions.
+						if tx2.unlocks.is_empty() {
+							Some(tx2.transaction.transaction.provides.clone())
+						} else {
+							None
+						}
+					};
+
+					// find previous transactions
+					for tag in &tx.requires {
+						if let Some(mut tags_to_remove) = find_previous(tag) {
+							to_remove.append(&mut tags_to_remove);
+						}
+					}
+				}
+
+				// add the transactions that just got unlocked to `best`
+				for hash in unlocks {
+					if let Some(tx) = self.ready.write().get_mut(&hash) {
+						tx.requires_offset += 1;
+						// this transaction is ready
+						if tx.requires_offset == tx.transaction.transaction.requires.len() {
+							self.best.insert(tx.transaction.clone());
+						}
+					}
+				}
+
+				// we also need to remove all other tags that this transaction provides,
+				// but since all the hard work is done, we only clear the provided_tag -> hash
+				// mapping.
+				let current_tag = &tag;
+				for tag in &tx.provides {
+					let removed = self.provided_tags.remove(tag);
+					assert_eq!(
+						removed.as_ref(),
+						if current_tag == tag { None } else { Some(&tx.hash) },
+						"The pool contains exactly one transaction providing given tag; the removed transaction
+						claims to provide that tag, so it has to be mapped to it's hash; qed"
+					);
+				}
+
+				removed.push(tx);
+			}
+		}
+
+		removed
+	}
+
+	/// Checks if the transaction is providing the same tags as other transactions.
+	///
+	/// In case that's true it determines if the priority of transactions that
+	/// we are about to replace is lower than the priority of the replacement transaction.
+	/// We remove/replace old transactions in case they have lower priority.
+	///
+	/// In case replacement is successful returns a list of removed transactions
+	/// and a list of hashes that are still in pool and gets unlocked by the new transaction.
+	fn replace_previous(
+		&mut self,
+		tx: &Transaction<Hash, Ex>,
+	) -> error::Result<(Vec<Arc<Transaction<Hash, Ex>>>, Vec<Hash>)> {
+		let (to_remove, unlocks) = {
+			// check if we are replacing a transaction
+			let replace_hashes = tx
+				.provides
+				.iter()
+				.filter_map(|tag| self.provided_tags.get(tag))
+				.collect::<HashSet<_>>();
+
+			// early exit if we are not replacing anything.
+			if replace_hashes.is_empty() {
+				return Ok((vec![], vec![]))
+			}
+
+			// now check if collective priority is lower than the replacement transaction.
+			let old_priority = {
+				let ready = self.ready.read();
+				replace_hashes
+					.iter()
+					.filter_map(|hash| ready.get(hash))
+					.fold(0u64, |total, tx| {
+						total.saturating_add(tx.transaction.transaction.priority)
+					})
+			};
+
+			// bail - the transaction has too low priority to replace the old ones
+			if old_priority >= tx.priority {
+				return Err(error::Error::TooLowPriority { old: old_priority, new: tx.priority })
+			}
+
+			// construct a list of unlocked transactions
+			let unlocks = {
+				let ready = self.ready.read();
+				replace_hashes.iter().filter_map(|hash| ready.get(hash)).fold(
+					vec![],
+					|mut list, tx| {
+						list.extend(tx.unlocks.iter().cloned());
+						list
+					},
+				)
+			};
+
+			(replace_hashes.into_iter().cloned().collect::<Vec<_>>(), unlocks)
+		};
+
+		let new_provides = tx.provides.iter().cloned().collect::<HashSet<_>>();
+		let removed = self.remove_subtree_with_tag_filter(to_remove, Some(new_provides));
+
+		Ok((removed, unlocks))
+	}
+
+	/// Returns number of transactions in this queue.
+	pub fn len(&self) -> usize {
+		self.ready.len()
+	}
+
+	/// Returns sum of encoding lengths of all transactions in this queue.
+	pub fn bytes(&self) -> usize {
+		self.ready.bytes()
+	}
+}
+
+/// Iterator of ready transactions ordered by priority.
+pub struct BestIterator<Hash, Ex> {
+	all: HashMap<Hash, ReadyTx<Hash, Ex>>,
+	awaiting: HashMap<Hash, (usize, TransactionRef<Hash, Ex>)>,
+	best: BTreeSet<TransactionRef<Hash, Ex>>,
+	invalid: HashSet<Hash>,
+}
+
+impl<Hash: hash::Hash + Member, Ex> BestIterator<Hash, Ex> {
+	/// Depending on number of satisfied requirements insert given ref
+	/// either to awaiting set or to best set.
+	fn best_or_awaiting(&mut self, satisfied: usize, tx_ref: TransactionRef<Hash, Ex>) {
+		if satisfied >= tx_ref.transaction.requires.len() {
+			// If we have satisfied all deps insert to best
+			self.best.insert(tx_ref);
+		} else {
+			// otherwise we're still awaiting for some deps
+			self.awaiting.insert(tx_ref.transaction.hash.clone(), (satisfied, tx_ref));
+		}
+	}
+}
+
+impl<Hash: hash::Hash + Member, Ex> sc_transaction_pool_api::ReadyTransactions
+	for BestIterator<Hash, Ex>
+{
+	fn report_invalid(&mut self, tx: &Self::Item) {
+		BestIterator::report_invalid(self, tx)
+	}
+}
+
+impl<Hash: hash::Hash + Member, Ex> BestIterator<Hash, Ex> {
+	/// Report given transaction as invalid.
+	///
+	/// As a consequence, all values that depend on the invalid one will be skipped.
+	/// When given transaction is not in the pool it has no effect.
+	/// When invoked on a fully drained iterator it has no effect either.
+	pub fn report_invalid(&mut self, tx: &Arc<Transaction<Hash, Ex>>) {
+		if let Some(to_report) = self.all.get(&tx.hash) {
+			debug!(
+				target: LOG_TARGET,
+				"[{:?}] Reported as invalid. Will skip sub-chains while iterating.",
+				to_report.transaction.transaction.hash
+			);
+			for hash in &to_report.unlocks {
+				self.invalid.insert(hash.clone());
+			}
+		}
+	}
+}
+
+impl<Hash: hash::Hash + Member, Ex> Iterator for BestIterator<Hash, Ex> {
+	type Item = Arc<Transaction<Hash, Ex>>;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		loop {
+			let best = self.best.iter().next_back()?.clone();
+			let best = self.best.take(&best)?;
+			let hash = &best.transaction.hash;
+
+			// Check if the transaction was marked invalid.
+			if self.invalid.contains(hash) {
+				debug!(
+					target: LOG_TARGET,
+					"[{:?}] Skipping invalid child transaction while iterating.", hash,
+				);
+				continue
+			}
+
+			let ready = match self.all.get(hash).cloned() {
+				Some(ready) => ready,
+				// The transaction is not in all, maybe it was removed in the meantime?
+				None => continue,
+			};
+
+			// Insert transactions that just got unlocked.
+			for hash in &ready.unlocks {
+				// first check local awaiting transactions
+				let res = if let Some((mut satisfied, tx_ref)) = self.awaiting.remove(hash) {
+					satisfied += 1;
+					Some((satisfied, tx_ref))
+				// then get from the pool
+				} else {
+					self.all
+						.get(hash)
+						.map(|next| (next.requires_offset + 1, next.transaction.clone()))
+				};
+				if let Some((satisfied, tx_ref)) = res {
+					self.best_or_awaiting(satisfied, tx_ref)
+				}
+			}
+
+			return Some(best.transaction)
+		}
+	}
+}
+
+// See: https://github.com/rust-lang/rust/issues/40062
+fn remove_item<T: PartialEq>(vec: &mut Vec<T>, item: &T) {
+	if let Some(idx) = vec.iter().position(|i| i == item) {
+		vec.swap_remove(idx);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_runtime::transaction_validity::TransactionSource as Source;
+
+	fn tx(id: u8) -> Transaction<u64, Vec<u8>> {
+		Transaction {
+			data: vec![id],
+			bytes: 1,
+			hash: id as u64,
+			priority: 1,
+			valid_till: 2,
+			requires: vec![vec![1], vec![2]],
+			provides: vec![vec![3], vec![4]],
+			propagate: true,
+			source: Source::External,
+		}
+	}
+
+	fn import<H: hash::Hash + Eq + Member + Serialize, Ex>(
+		ready: &mut ReadyTransactions<H, Ex>,
+		tx: Transaction<H, Ex>,
+	) -> error::Result<Vec<Arc<Transaction<H, Ex>>>> {
+		let x = WaitingTransaction::new(tx, ready.provided_tags(), &[]);
+		ready.import(x)
+	}
+
+	#[test]
+	fn should_replace_transaction_that_provides_the_same_tag() {
+		// given
+		let mut ready = ReadyTransactions::default();
+		let mut tx1 = tx(1);
+		tx1.requires.clear();
+		let mut tx2 = tx(2);
+		tx2.requires.clear();
+		tx2.provides = vec![vec![3]];
+		let mut tx3 = tx(3);
+		tx3.requires.clear();
+		tx3.provides = vec![vec![4]];
+
+		// when
+		import(&mut ready, tx2).unwrap();
+		import(&mut ready, tx3).unwrap();
+		assert_eq!(ready.get().count(), 2);
+
+		// too low priority
+		import(&mut ready, tx1.clone()).unwrap_err();
+
+		tx1.priority = 10;
+		import(&mut ready, tx1).unwrap();
+
+		// then
+		assert_eq!(ready.get().count(), 1);
+	}
+
+	#[test]
+	fn should_replace_multiple_transactions_correctly() {
+		// given
+		let mut ready = ReadyTransactions::default();
+		let mut tx0 = tx(0);
+		tx0.requires = vec![];
+		tx0.provides = vec![vec![0]];
+		let mut tx1 = tx(1);
+		tx1.requires = vec![];
+		tx1.provides = vec![vec![1]];
+		let mut tx2 = tx(2);
+		tx2.requires = vec![vec![0], vec![1]];
+		tx2.provides = vec![vec![2], vec![3]];
+		let mut tx3 = tx(3);
+		tx3.requires = vec![vec![2]];
+		tx3.provides = vec![vec![4]];
+		let mut tx4 = tx(4);
+		tx4.requires = vec![vec![3]];
+		tx4.provides = vec![vec![5]];
+		// replacement
+		let mut tx2_2 = tx(5);
+		tx2_2.requires = vec![vec![0], vec![1]];
+		tx2_2.provides = vec![vec![2]];
+		tx2_2.priority = 10;
+
+		for tx in vec![tx0, tx1, tx2, tx3, tx4] {
+			import(&mut ready, tx).unwrap();
+		}
+		assert_eq!(ready.get().count(), 5);
+
+		// when
+		import(&mut ready, tx2_2).unwrap();
+
+		// then
+		assert_eq!(ready.get().count(), 3);
+	}
+
+	/// Populate the pool, with a graph that looks like so:
+	///
+	/// tx1 -> tx2 \
+	///     ->  ->  tx3
+	///     -> tx4 -> tx5 -> tx6
+	///     -> tx7
+	fn populate_pool(ready: &mut ReadyTransactions<u64, Vec<u8>>) {
+		let mut tx1 = tx(1);
+		tx1.requires.clear();
+		let mut tx2 = tx(2);
+		tx2.requires = tx1.provides.clone();
+		tx2.provides = vec![vec![106]];
+		let mut tx3 = tx(3);
+		tx3.requires = vec![tx1.provides[0].clone(), vec![106]];
+		tx3.provides = vec![];
+		let mut tx4 = tx(4);
+		tx4.requires = vec![tx1.provides[0].clone()];
+		tx4.provides = vec![vec![107]];
+		let mut tx5 = tx(5);
+		tx5.requires = vec![tx4.provides[0].clone()];
+		tx5.provides = vec![vec![108]];
+		let mut tx6 = tx(6);
+		tx6.requires = vec![tx5.provides[0].clone()];
+		tx6.provides = vec![];
+		let tx7 = Transaction {
+			data: vec![7],
+			bytes: 1,
+			hash: 7,
+			priority: 1,
+			valid_till: u64::MAX, // use the max here for testing.
+			requires: vec![tx1.provides[0].clone()],
+			provides: vec![],
+			propagate: true,
+			source: Source::External,
+		};
+
+		// when
+		for tx in vec![tx1, tx2, tx3, tx7, tx4, tx5, tx6] {
+			import(ready, tx).unwrap();
+		}
+
+		assert_eq!(ready.best.len(), 1);
+	}
+
+	#[test]
+	fn should_return_best_transactions_in_correct_order() {
+		// given
+		let mut ready = ReadyTransactions::default();
+		populate_pool(&mut ready);
+
+		// when
+		let mut it = ready.get().map(|tx| tx.data[0]);
+
+		// then
+		assert_eq!(it.next(), Some(1));
+		assert_eq!(it.next(), Some(2));
+		assert_eq!(it.next(), Some(3));
+		assert_eq!(it.next(), Some(4));
+		assert_eq!(it.next(), Some(5));
+		assert_eq!(it.next(), Some(6));
+		assert_eq!(it.next(), Some(7));
+		assert_eq!(it.next(), None);
+	}
+
+	#[test]
+	fn should_order_refs() {
+		let mut id = 1;
+		let mut with_priority = |priority, longevity| {
+			id += 1;
+			let mut tx = tx(id);
+			tx.priority = priority;
+			tx.valid_till = longevity;
+			tx
+		};
+		// higher priority = better
+		assert!(
+			TransactionRef { transaction: Arc::new(with_priority(3, 3)), insertion_id: 1 } >
+				TransactionRef { transaction: Arc::new(with_priority(2, 3)), insertion_id: 2 }
+		);
+		// lower validity = better
+		assert!(
+			TransactionRef { transaction: Arc::new(with_priority(3, 2)), insertion_id: 1 } >
+				TransactionRef { transaction: Arc::new(with_priority(3, 3)), insertion_id: 2 }
+		);
+		// lower insertion_id = better
+		assert!(
+			TransactionRef { transaction: Arc::new(with_priority(3, 3)), insertion_id: 1 } >
+				TransactionRef { transaction: Arc::new(with_priority(3, 3)), insertion_id: 2 }
+		);
+	}
+
+	#[test]
+	fn should_skip_invalid_transactions_while_iterating() {
+		// given
+		let mut ready = ReadyTransactions::default();
+		populate_pool(&mut ready);
+
+		// when
+		let mut it = ready.get();
+		let data = |tx: &Arc<Transaction<u64, Vec<u8>>>| tx.data[0];
+
+		// then
+		assert_eq!(it.next().as_ref().map(data), Some(1));
+		assert_eq!(it.next().as_ref().map(data), Some(2));
+		assert_eq!(it.next().as_ref().map(data), Some(3));
+		let tx4 = it.next();
+		assert_eq!(tx4.as_ref().map(data), Some(4));
+		// report 4 as invalid, which should skip 5 & 6.
+		it.report_invalid(&tx4.unwrap());
+		assert_eq!(it.next().as_ref().map(data), Some(7));
+		assert_eq!(it.next().as_ref().map(data), None);
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/rotator.rs b/substrate/client/transaction-pool/src/graph/rotator.rs
new file mode 100644
index 0000000000000000000000000000000000000000..61a26fb4138cac966bb78214c2e57b80db8aaa91
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/rotator.rs
@@ -0,0 +1,217 @@
+// 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/>.
+
+//! Rotate extrinsic inside the pool.
+//!
+//! Keeps only recent extrinsic and discard the ones kept for a significant amount of time.
+//! Discarded extrinsics are banned so that they don't get re-imported again.
+
+use parking_lot::RwLock;
+use std::{
+	collections::HashMap,
+	hash, iter,
+	time::{Duration, Instant},
+};
+
+use super::base_pool::Transaction;
+
+/// Expected size of the banned extrinsics cache.
+const EXPECTED_SIZE: usize = 2048;
+
+/// Pool rotator is responsible to only keep fresh extrinsics in the pool.
+///
+/// Extrinsics that occupy the pool for too long are culled and temporarily banned from entering
+/// the pool again.
+pub struct PoolRotator<Hash> {
+	/// How long the extrinsic is banned for.
+	ban_time: Duration,
+	/// Currently banned extrinsics.
+	banned_until: RwLock<HashMap<Hash, Instant>>,
+}
+
+impl<Hash: hash::Hash + Eq> Default for PoolRotator<Hash> {
+	fn default() -> Self {
+		Self { ban_time: Duration::from_secs(60 * 30), banned_until: Default::default() }
+	}
+}
+
+impl<Hash: hash::Hash + Eq + Clone> PoolRotator<Hash> {
+	/// New rotator instance with specified ban time.
+	pub fn new(ban_time: Duration) -> Self {
+		Self { ban_time, banned_until: Default::default() }
+	}
+
+	/// Returns `true` if extrinsic hash is currently banned.
+	pub fn is_banned(&self, hash: &Hash) -> bool {
+		self.banned_until.read().contains_key(hash)
+	}
+
+	/// Bans given set of hashes.
+	pub fn ban(&self, now: &Instant, hashes: impl IntoIterator<Item = Hash>) {
+		let mut banned = self.banned_until.write();
+
+		for hash in hashes {
+			banned.insert(hash, *now + self.ban_time);
+		}
+
+		if banned.len() > 2 * EXPECTED_SIZE {
+			while banned.len() > EXPECTED_SIZE {
+				if let Some(key) = banned.keys().next().cloned() {
+					banned.remove(&key);
+				}
+			}
+		}
+	}
+
+	/// Bans extrinsic if it's stale.
+	///
+	/// Returns `true` if extrinsic is stale and got banned.
+	pub fn ban_if_stale<Ex>(
+		&self,
+		now: &Instant,
+		current_block: u64,
+		xt: &Transaction<Hash, Ex>,
+	) -> bool {
+		if xt.valid_till > current_block {
+			return false
+		}
+
+		self.ban(now, iter::once(xt.hash.clone()));
+		true
+	}
+
+	/// Removes timed bans.
+	pub fn clear_timeouts(&self, now: &Instant) {
+		let mut banned = self.banned_until.write();
+
+		banned.retain(|_, &mut v| v >= *now);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_runtime::transaction_validity::TransactionSource;
+
+	type Hash = u64;
+	type Ex = ();
+
+	fn rotator() -> PoolRotator<Hash> {
+		PoolRotator { ban_time: Duration::from_millis(10), ..Default::default() }
+	}
+
+	fn tx() -> (Hash, Transaction<Hash, Ex>) {
+		let hash = 5u64;
+		let tx = Transaction {
+			data: (),
+			bytes: 1,
+			hash,
+			priority: 5,
+			valid_till: 1,
+			requires: vec![],
+			provides: vec![],
+			propagate: true,
+			source: TransactionSource::External,
+		};
+
+		(hash, tx)
+	}
+
+	#[test]
+	fn should_not_ban_if_not_stale() {
+		// given
+		let (hash, tx) = tx();
+		let rotator = rotator();
+		assert!(!rotator.is_banned(&hash));
+		let now = Instant::now();
+		let past_block = 0;
+
+		// when
+		assert!(!rotator.ban_if_stale(&now, past_block, &tx));
+
+		// then
+		assert!(!rotator.is_banned(&hash));
+	}
+
+	#[test]
+	fn should_ban_stale_extrinsic() {
+		// given
+		let (hash, tx) = tx();
+		let rotator = rotator();
+		assert!(!rotator.is_banned(&hash));
+
+		// when
+		assert!(rotator.ban_if_stale(&Instant::now(), 1, &tx));
+
+		// then
+		assert!(rotator.is_banned(&hash));
+	}
+
+	#[test]
+	fn should_clear_banned() {
+		// given
+		let (hash, tx) = tx();
+		let rotator = rotator();
+		assert!(rotator.ban_if_stale(&Instant::now(), 1, &tx));
+		assert!(rotator.is_banned(&hash));
+
+		// when
+		let future = Instant::now() + rotator.ban_time + rotator.ban_time;
+		rotator.clear_timeouts(&future);
+
+		// then
+		assert!(!rotator.is_banned(&hash));
+	}
+
+	#[test]
+	fn should_garbage_collect() {
+		// given
+		fn tx_with(i: u64, valid_till: u64) -> Transaction<Hash, Ex> {
+			let hash = i;
+			Transaction {
+				data: (),
+				bytes: 2,
+				hash,
+				priority: 5,
+				valid_till,
+				requires: vec![],
+				provides: vec![],
+				propagate: true,
+				source: TransactionSource::External,
+			}
+		}
+
+		let rotator = rotator();
+
+		let now = Instant::now();
+		let past_block = 0;
+
+		// when
+		for i in 0..2 * EXPECTED_SIZE {
+			let tx = tx_with(i as u64, past_block);
+			assert!(rotator.ban_if_stale(&now, past_block, &tx));
+		}
+		assert_eq!(rotator.banned_until.read().len(), 2 * EXPECTED_SIZE);
+
+		// then
+		let tx = tx_with(2 * EXPECTED_SIZE as u64, past_block);
+		// trigger a garbage collection
+		assert!(rotator.ban_if_stale(&now, past_block, &tx));
+		assert_eq!(rotator.banned_until.read().len(), EXPECTED_SIZE);
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/tracked_map.rs b/substrate/client/transaction-pool/src/graph/tracked_map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..47ad22603e469c297bd1a5f9f133f7d1997adaee
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/tracked_map.rs
@@ -0,0 +1,174 @@
+// 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 parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::{
+	collections::HashMap,
+	sync::{
+		atomic::{AtomicIsize, Ordering as AtomicOrdering},
+		Arc,
+	},
+};
+
+/// Something that can report its size.
+pub trait Size {
+	fn size(&self) -> usize;
+}
+
+/// Map with size tracking.
+///
+/// Size reported might be slightly off and only approximately true.
+#[derive(Debug)]
+pub struct TrackedMap<K, V> {
+	index: Arc<RwLock<HashMap<K, V>>>,
+	bytes: AtomicIsize,
+	length: AtomicIsize,
+}
+
+impl<K, V> Default for TrackedMap<K, V> {
+	fn default() -> Self {
+		Self { index: Arc::new(HashMap::default().into()), bytes: 0.into(), length: 0.into() }
+	}
+}
+
+impl<K, V> TrackedMap<K, V> {
+	/// Current tracked length of the content.
+	pub fn len(&self) -> usize {
+		std::cmp::max(self.length.load(AtomicOrdering::Relaxed), 0) as usize
+	}
+
+	/// Current sum of content length.
+	pub fn bytes(&self) -> usize {
+		std::cmp::max(self.bytes.load(AtomicOrdering::Relaxed), 0) as usize
+	}
+
+	/// Lock map for read.
+	pub fn read(&self) -> TrackedMapReadAccess<K, V> {
+		TrackedMapReadAccess { inner_guard: self.index.read() }
+	}
+
+	/// Lock map for write.
+	pub fn write(&self) -> TrackedMapWriteAccess<K, V> {
+		TrackedMapWriteAccess {
+			inner_guard: self.index.write(),
+			bytes: &self.bytes,
+			length: &self.length,
+		}
+	}
+}
+
+impl<K: Clone, V: Clone> TrackedMap<K, V> {
+	/// Clone the inner map.
+	pub fn clone_map(&self) -> HashMap<K, V> {
+		self.index.read().clone()
+	}
+}
+
+pub struct TrackedMapReadAccess<'a, K, V> {
+	inner_guard: RwLockReadGuard<'a, HashMap<K, V>>,
+}
+
+impl<'a, K, V> TrackedMapReadAccess<'a, K, V>
+where
+	K: Eq + std::hash::Hash,
+{
+	/// Returns true if map contains key.
+	pub fn contains_key(&self, key: &K) -> bool {
+		self.inner_guard.contains_key(key)
+	}
+
+	/// Returns reference to the contained value by key, if exists.
+	pub fn get(&self, key: &K) -> Option<&V> {
+		self.inner_guard.get(key)
+	}
+
+	/// Returns iterator over all values.
+	pub fn values(&self) -> std::collections::hash_map::Values<K, V> {
+		self.inner_guard.values()
+	}
+}
+
+pub struct TrackedMapWriteAccess<'a, K, V> {
+	bytes: &'a AtomicIsize,
+	length: &'a AtomicIsize,
+	inner_guard: RwLockWriteGuard<'a, HashMap<K, V>>,
+}
+
+impl<'a, K, V> TrackedMapWriteAccess<'a, K, V>
+where
+	K: Eq + std::hash::Hash,
+	V: Size,
+{
+	/// Insert value and return previous (if any).
+	pub fn insert(&mut self, key: K, val: V) -> Option<V> {
+		let new_bytes = val.size();
+		self.bytes.fetch_add(new_bytes as isize, AtomicOrdering::Relaxed);
+		self.length.fetch_add(1, AtomicOrdering::Relaxed);
+		self.inner_guard.insert(key, val).map(|old_val| {
+			self.bytes.fetch_sub(old_val.size() as isize, AtomicOrdering::Relaxed);
+			self.length.fetch_sub(1, AtomicOrdering::Relaxed);
+			old_val
+		})
+	}
+
+	/// Remove value by key.
+	pub fn remove(&mut self, key: &K) -> Option<V> {
+		let val = self.inner_guard.remove(key);
+		if let Some(size) = val.as_ref().map(Size::size) {
+			self.bytes.fetch_sub(size as isize, AtomicOrdering::Relaxed);
+			self.length.fetch_sub(1, AtomicOrdering::Relaxed);
+		}
+		val
+	}
+
+	/// Returns mutable reference to the contained value by key, if exists.
+	pub fn get_mut(&mut self, key: &K) -> Option<&mut V> {
+		self.inner_guard.get_mut(key)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+
+	use super::*;
+
+	impl Size for i32 {
+		fn size(&self) -> usize {
+			*self as usize / 10
+		}
+	}
+
+	#[test]
+	fn basic() {
+		let map = TrackedMap::default();
+		map.write().insert(5, 10);
+		map.write().insert(6, 20);
+
+		assert_eq!(map.bytes(), 3);
+		assert_eq!(map.len(), 2);
+
+		map.write().insert(6, 30);
+
+		assert_eq!(map.bytes(), 4);
+		assert_eq!(map.len(), 2);
+
+		map.write().remove(&6);
+		assert_eq!(map.bytes(), 1);
+		assert_eq!(map.len(), 1);
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/validated_pool.rs b/substrate/client/transaction-pool/src/graph/validated_pool.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ed76d439ae71d1b42222964461274af1a11ba7fa
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/validated_pool.rs
@@ -0,0 +1,664 @@
+// 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 std::{
+	collections::{HashMap, HashSet},
+	hash,
+	sync::Arc,
+};
+
+use crate::LOG_TARGET;
+use futures::channel::mpsc::{channel, Sender};
+use parking_lot::{Mutex, RwLock};
+use sc_transaction_pool_api::{error, PoolStatus, ReadyTransactions};
+use serde::Serialize;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{self, SaturatedConversion},
+	transaction_validity::{TransactionSource, TransactionTag as Tag, ValidTransaction},
+};
+use std::time::Instant;
+
+use super::{
+	base_pool::{self as base, PruneStatus},
+	listener::Listener,
+	pool::{
+		BlockHash, ChainApi, EventStream, ExtrinsicFor, ExtrinsicHash, Options, TransactionFor,
+	},
+	rotator::PoolRotator,
+	watcher::Watcher,
+};
+
+/// Pre-validated transaction. Validated pool only accepts transactions wrapped in this enum.
+#[derive(Debug)]
+pub enum ValidatedTransaction<Hash, Ex, Error> {
+	/// Transaction that has been validated successfully.
+	Valid(base::Transaction<Hash, Ex>),
+	/// Transaction that is invalid.
+	Invalid(Hash, Error),
+	/// Transaction which validity can't be determined.
+	///
+	/// We're notifying watchers about failure, if 'unknown' transaction is submitted.
+	Unknown(Hash, Error),
+}
+
+impl<Hash, Ex, Error> ValidatedTransaction<Hash, Ex, Error> {
+	/// Consume validity result, transaction data and produce ValidTransaction.
+	pub fn valid_at(
+		at: u64,
+		hash: Hash,
+		source: TransactionSource,
+		data: Ex,
+		bytes: usize,
+		validity: ValidTransaction,
+	) -> Self {
+		Self::Valid(base::Transaction {
+			data,
+			bytes,
+			hash,
+			source,
+			priority: validity.priority,
+			requires: validity.requires,
+			provides: validity.provides,
+			propagate: validity.propagate,
+			valid_till: at.saturated_into::<u64>().saturating_add(validity.longevity),
+		})
+	}
+}
+
+/// A type of validated transaction stored in the pool.
+pub type ValidatedTransactionFor<B> =
+	ValidatedTransaction<ExtrinsicHash<B>, ExtrinsicFor<B>, <B as ChainApi>::Error>;
+
+/// A closure that returns true if the local node is a validator that can author blocks.
+pub struct IsValidator(Box<dyn Fn() -> bool + Send + Sync>);
+
+impl From<bool> for IsValidator {
+	fn from(is_validator: bool) -> Self {
+		Self(Box::new(move || is_validator))
+	}
+}
+
+impl From<Box<dyn Fn() -> bool + Send + Sync>> for IsValidator {
+	fn from(is_validator: Box<dyn Fn() -> bool + Send + Sync>) -> Self {
+		Self(is_validator)
+	}
+}
+
+/// Pool that deals with validated transactions.
+pub struct ValidatedPool<B: ChainApi> {
+	api: Arc<B>,
+	is_validator: IsValidator,
+	options: Options,
+	listener: RwLock<Listener<ExtrinsicHash<B>, B>>,
+	pool: RwLock<base::BasePool<ExtrinsicHash<B>, ExtrinsicFor<B>>>,
+	import_notification_sinks: Mutex<Vec<Sender<ExtrinsicHash<B>>>>,
+	rotator: PoolRotator<ExtrinsicHash<B>>,
+}
+
+impl<B: ChainApi> ValidatedPool<B> {
+	/// Create a new transaction pool.
+	pub fn new(options: Options, is_validator: IsValidator, api: Arc<B>) -> Self {
+		let base_pool = base::BasePool::new(options.reject_future_transactions);
+		let ban_time = options.ban_time;
+		Self {
+			is_validator,
+			options,
+			listener: Default::default(),
+			api,
+			pool: RwLock::new(base_pool),
+			import_notification_sinks: Default::default(),
+			rotator: PoolRotator::new(ban_time),
+		}
+	}
+
+	/// Bans given set of hashes.
+	pub fn ban(&self, now: &Instant, hashes: impl IntoIterator<Item = ExtrinsicHash<B>>) {
+		self.rotator.ban(now, hashes)
+	}
+
+	/// Returns true if transaction with given hash is currently banned from the pool.
+	pub fn is_banned(&self, hash: &ExtrinsicHash<B>) -> bool {
+		self.rotator.is_banned(hash)
+	}
+
+	/// A fast check before doing any further processing of a transaction, like validation.
+	///
+	/// If `ignore_banned` is `true`, it will not check if the transaction is banned.
+	///
+	/// It checks if the transaction is already imported or banned. If so, it returns an error.
+	pub fn check_is_known(
+		&self,
+		tx_hash: &ExtrinsicHash<B>,
+		ignore_banned: bool,
+	) -> Result<(), B::Error> {
+		if !ignore_banned && self.is_banned(tx_hash) {
+			Err(error::Error::TemporarilyBanned.into())
+		} else if self.pool.read().is_imported(tx_hash) {
+			Err(error::Error::AlreadyImported(Box::new(*tx_hash)).into())
+		} else {
+			Ok(())
+		}
+	}
+
+	/// Imports a bunch of pre-validated transactions to the pool.
+	pub fn submit(
+		&self,
+		txs: impl IntoIterator<Item = ValidatedTransactionFor<B>>,
+	) -> Vec<Result<ExtrinsicHash<B>, B::Error>> {
+		let results = txs
+			.into_iter()
+			.map(|validated_tx| self.submit_one(validated_tx))
+			.collect::<Vec<_>>();
+
+		// only enforce limits if there is at least one imported transaction
+		let removed = if results.iter().any(|res| res.is_ok()) {
+			self.enforce_limits()
+		} else {
+			Default::default()
+		};
+
+		results
+			.into_iter()
+			.map(|res| match res {
+				Ok(ref hash) if removed.contains(hash) =>
+					Err(error::Error::ImmediatelyDropped.into()),
+				other => other,
+			})
+			.collect()
+	}
+
+	/// Submit single pre-validated transaction to the pool.
+	fn submit_one(&self, tx: ValidatedTransactionFor<B>) -> Result<ExtrinsicHash<B>, B::Error> {
+		match tx {
+			ValidatedTransaction::Valid(tx) => {
+				if !tx.propagate && !(self.is_validator.0)() {
+					return Err(error::Error::Unactionable.into())
+				}
+
+				let imported = self.pool.write().import(tx)?;
+
+				if let base::Imported::Ready { ref hash, .. } = imported {
+					let sinks = &mut self.import_notification_sinks.lock();
+					sinks.retain_mut(|sink| match sink.try_send(*hash) {
+						Ok(()) => true,
+						Err(e) =>
+							if e.is_full() {
+								log::warn!(
+									target: LOG_TARGET,
+									"[{:?}] Trying to notify an import but the channel is full",
+									hash,
+								);
+								true
+							} else {
+								false
+							},
+					});
+				}
+
+				let mut listener = self.listener.write();
+				fire_events(&mut *listener, &imported);
+				Ok(*imported.hash())
+			},
+			ValidatedTransaction::Invalid(hash, err) => {
+				self.rotator.ban(&Instant::now(), std::iter::once(hash));
+				Err(err)
+			},
+			ValidatedTransaction::Unknown(hash, err) => {
+				self.listener.write().invalid(&hash);
+				Err(err)
+			},
+		}
+	}
+
+	fn enforce_limits(&self) -> HashSet<ExtrinsicHash<B>> {
+		let status = self.pool.read().status();
+		let ready_limit = &self.options.ready;
+		let future_limit = &self.options.future;
+
+		log::debug!(target: LOG_TARGET, "Pool Status: {:?}", status);
+		if ready_limit.is_exceeded(status.ready, status.ready_bytes) ||
+			future_limit.is_exceeded(status.future, status.future_bytes)
+		{
+			log::debug!(
+				target: LOG_TARGET,
+				"Enforcing limits ({}/{}kB ready, {}/{}kB future",
+				ready_limit.count,
+				ready_limit.total_bytes / 1024,
+				future_limit.count,
+				future_limit.total_bytes / 1024,
+			);
+
+			// clean up the pool
+			let removed = {
+				let mut pool = self.pool.write();
+				let removed = pool
+					.enforce_limits(ready_limit, future_limit)
+					.into_iter()
+					.map(|x| x.hash)
+					.collect::<HashSet<_>>();
+				// ban all removed transactions
+				self.rotator.ban(&Instant::now(), removed.iter().copied());
+				removed
+			};
+			if !removed.is_empty() {
+				log::debug!(target: LOG_TARGET, "Enforcing limits: {} dropped", removed.len());
+			}
+
+			// run notifications
+			let mut listener = self.listener.write();
+			for h in &removed {
+				listener.dropped(h, None);
+			}
+
+			removed
+		} else {
+			Default::default()
+		}
+	}
+
+	/// Import a single extrinsic and starts to watch their progress in the pool.
+	pub fn submit_and_watch(
+		&self,
+		tx: ValidatedTransactionFor<B>,
+	) -> Result<Watcher<ExtrinsicHash<B>, ExtrinsicHash<B>>, B::Error> {
+		match tx {
+			ValidatedTransaction::Valid(tx) => {
+				let hash = self.api.hash_and_length(&tx.data).0;
+				let watcher = self.listener.write().create_watcher(hash);
+				self.submit(std::iter::once(ValidatedTransaction::Valid(tx)))
+					.pop()
+					.expect("One extrinsic passed; one result returned; qed")
+					.map(|_| watcher)
+			},
+			ValidatedTransaction::Invalid(hash, err) => {
+				self.rotator.ban(&Instant::now(), std::iter::once(hash));
+				Err(err)
+			},
+			ValidatedTransaction::Unknown(_, err) => Err(err),
+		}
+	}
+
+	/// Resubmits revalidated transactions back to the pool.
+	///
+	/// Removes and then submits passed transactions and all dependent transactions.
+	/// Transactions that are missing from the pool are not submitted.
+	pub fn resubmit(
+		&self,
+		mut updated_transactions: HashMap<ExtrinsicHash<B>, ValidatedTransactionFor<B>>,
+	) {
+		#[derive(Debug, Clone, Copy, PartialEq)]
+		enum Status {
+			Future,
+			Ready,
+			Failed,
+			Dropped,
+		}
+
+		let (mut initial_statuses, final_statuses) = {
+			let mut pool = self.pool.write();
+
+			// remove all passed transactions from the ready/future queues
+			// (this may remove additional transactions as well)
+			//
+			// for every transaction that has an entry in the `updated_transactions`,
+			// we store updated validation result in txs_to_resubmit
+			// for every transaction that has no entry in the `updated_transactions`,
+			// we store last validation result (i.e. the pool entry) in txs_to_resubmit
+			let mut initial_statuses = HashMap::new();
+			let mut txs_to_resubmit = Vec::with_capacity(updated_transactions.len());
+			while !updated_transactions.is_empty() {
+				let hash = updated_transactions
+					.keys()
+					.next()
+					.cloned()
+					.expect("transactions is not empty; qed");
+
+				// note we are not considering tx with hash invalid here - we just want
+				// to remove it along with dependent transactions and `remove_subtree()`
+				// does exactly what we need
+				let removed = pool.remove_subtree(&[hash]);
+				for removed_tx in removed {
+					let removed_hash = removed_tx.hash;
+					let updated_transaction = updated_transactions.remove(&removed_hash);
+					let tx_to_resubmit = if let Some(updated_tx) = updated_transaction {
+						updated_tx
+					} else {
+						// in most cases we'll end up in successful `try_unwrap`, but if not
+						// we still need to reinsert transaction back to the pool => duplicate call
+						let transaction = match Arc::try_unwrap(removed_tx) {
+							Ok(transaction) => transaction,
+							Err(transaction) => transaction.duplicate(),
+						};
+						ValidatedTransaction::Valid(transaction)
+					};
+
+					initial_statuses.insert(removed_hash, Status::Ready);
+					txs_to_resubmit.push((removed_hash, tx_to_resubmit));
+				}
+				// make sure to remove the hash even if it's not present in the pool any more.
+				updated_transactions.remove(&hash);
+			}
+
+			// if we're rejecting future transactions, then insertion order matters here:
+			// if tx1 depends on tx2, then if tx1 is inserted before tx2, then it goes
+			// to the future queue and gets rejected immediately
+			// => let's temporary stop rejection and clear future queue before return
+			pool.with_futures_enabled(|pool, reject_future_transactions| {
+				// now resubmit all removed transactions back to the pool
+				let mut final_statuses = HashMap::new();
+				for (hash, tx_to_resubmit) in txs_to_resubmit {
+					match tx_to_resubmit {
+						ValidatedTransaction::Valid(tx) => match pool.import(tx) {
+							Ok(imported) => match imported {
+								base::Imported::Ready { promoted, failed, removed, .. } => {
+									final_statuses.insert(hash, Status::Ready);
+									for hash in promoted {
+										final_statuses.insert(hash, Status::Ready);
+									}
+									for hash in failed {
+										final_statuses.insert(hash, Status::Failed);
+									}
+									for tx in removed {
+										final_statuses.insert(tx.hash, Status::Dropped);
+									}
+								},
+								base::Imported::Future { .. } => {
+									final_statuses.insert(hash, Status::Future);
+								},
+							},
+							Err(err) => {
+								// we do not want to fail if single transaction import has failed
+								// nor we do want to propagate this error, because it could tx
+								// unknown to caller => let's just notify listeners (and issue debug
+								// message)
+								log::warn!(
+									target: LOG_TARGET,
+									"[{:?}] Removing invalid transaction from update: {}",
+									hash,
+									err,
+								);
+								final_statuses.insert(hash, Status::Failed);
+							},
+						},
+						ValidatedTransaction::Invalid(_, _) |
+						ValidatedTransaction::Unknown(_, _) => {
+							final_statuses.insert(hash, Status::Failed);
+						},
+					}
+				}
+
+				// if the pool is configured to reject future transactions, let's clear the future
+				// queue, updating final statuses as required
+				if reject_future_transactions {
+					for future_tx in pool.clear_future() {
+						final_statuses.insert(future_tx.hash, Status::Dropped);
+					}
+				}
+
+				(initial_statuses, final_statuses)
+			})
+		};
+
+		// and now let's notify listeners about status changes
+		let mut listener = self.listener.write();
+		for (hash, final_status) in final_statuses {
+			let initial_status = initial_statuses.remove(&hash);
+			if initial_status.is_none() || Some(final_status) != initial_status {
+				match final_status {
+					Status::Future => listener.future(&hash),
+					Status::Ready => listener.ready(&hash, None),
+					Status::Dropped => listener.dropped(&hash, None),
+					Status::Failed => listener.invalid(&hash),
+				}
+			}
+		}
+	}
+
+	/// For each extrinsic, returns tags that it provides (if known), or None (if it is unknown).
+	pub fn extrinsics_tags(&self, hashes: &[ExtrinsicHash<B>]) -> Vec<Option<Vec<Tag>>> {
+		self.pool
+			.read()
+			.by_hashes(hashes)
+			.into_iter()
+			.map(|existing_in_pool| {
+				existing_in_pool.map(|transaction| transaction.provides.to_vec())
+			})
+			.collect()
+	}
+
+	/// Get ready transaction by hash
+	pub fn ready_by_hash(&self, hash: &ExtrinsicHash<B>) -> Option<TransactionFor<B>> {
+		self.pool.read().ready_by_hash(hash)
+	}
+
+	/// Prunes ready transactions that provide given list of tags.
+	pub fn prune_tags(
+		&self,
+		tags: impl IntoIterator<Item = Tag>,
+	) -> Result<PruneStatus<ExtrinsicHash<B>, ExtrinsicFor<B>>, B::Error> {
+		// Perform tag-based pruning in the base pool
+		let status = self.pool.write().prune_tags(tags);
+		// Notify event listeners of all transactions
+		// that were promoted to `Ready` or were dropped.
+		{
+			let mut listener = self.listener.write();
+			for promoted in &status.promoted {
+				fire_events(&mut *listener, promoted);
+			}
+			for f in &status.failed {
+				listener.dropped(f, None);
+			}
+		}
+
+		Ok(status)
+	}
+
+	/// Resubmit transactions that have been revalidated after prune_tags call.
+	pub fn resubmit_pruned(
+		&self,
+		at: &BlockId<B::Block>,
+		known_imported_hashes: impl IntoIterator<Item = ExtrinsicHash<B>> + Clone,
+		pruned_hashes: Vec<ExtrinsicHash<B>>,
+		pruned_xts: Vec<ValidatedTransactionFor<B>>,
+	) -> Result<(), B::Error> {
+		debug_assert_eq!(pruned_hashes.len(), pruned_xts.len());
+
+		// Resubmit pruned transactions
+		let results = self.submit(pruned_xts);
+
+		// Collect the hashes of transactions that now became invalid (meaning that they are
+		// successfully pruned).
+		let hashes = results.into_iter().enumerate().filter_map(|(idx, r)| {
+			match r.map_err(error::IntoPoolError::into_pool_error) {
+				Err(Ok(error::Error::InvalidTransaction(_))) => Some(pruned_hashes[idx]),
+				_ => None,
+			}
+		});
+		// Fire `pruned` notifications for collected hashes and make sure to include
+		// `known_imported_hashes` since they were just imported as part of the block.
+		let hashes = hashes.chain(known_imported_hashes.into_iter());
+		self.fire_pruned(at, hashes)?;
+
+		// perform regular cleanup of old transactions in the pool
+		// and update temporary bans.
+		self.clear_stale(at)?;
+		Ok(())
+	}
+
+	/// Fire notifications for pruned transactions.
+	pub fn fire_pruned(
+		&self,
+		at: &BlockId<B::Block>,
+		hashes: impl Iterator<Item = ExtrinsicHash<B>>,
+	) -> Result<(), B::Error> {
+		let header_hash = self
+			.api
+			.block_id_to_hash(at)?
+			.ok_or_else(|| error::Error::InvalidBlockId(format!("{:?}", at)))?;
+		let mut listener = self.listener.write();
+		let mut set = HashSet::with_capacity(hashes.size_hint().0);
+		for h in hashes {
+			// `hashes` has possibly duplicate hashes.
+			// we'd like to send out the `InBlock` notification only once.
+			if !set.contains(&h) {
+				listener.pruned(header_hash, &h);
+				set.insert(h);
+			}
+		}
+		Ok(())
+	}
+
+	/// Removes stale transactions from the pool.
+	///
+	/// Stale transactions are transaction beyond their longevity period.
+	/// Note this function does not remove transactions that are already included in the chain.
+	/// See `prune_tags` if you want this.
+	pub fn clear_stale(&self, at: &BlockId<B::Block>) -> Result<(), B::Error> {
+		let block_number = self
+			.api
+			.block_id_to_number(at)?
+			.ok_or_else(|| error::Error::InvalidBlockId(format!("{:?}", at)))?
+			.saturated_into::<u64>();
+		let now = Instant::now();
+		let to_remove = {
+			self.ready()
+				.filter(|tx| self.rotator.ban_if_stale(&now, block_number, tx))
+				.map(|tx| tx.hash)
+				.collect::<Vec<_>>()
+		};
+		let futures_to_remove: Vec<ExtrinsicHash<B>> = {
+			let p = self.pool.read();
+			let mut hashes = Vec::new();
+			for tx in p.futures() {
+				if self.rotator.ban_if_stale(&now, block_number, tx) {
+					hashes.push(tx.hash);
+				}
+			}
+			hashes
+		};
+		// removing old transactions
+		self.remove_invalid(&to_remove);
+		self.remove_invalid(&futures_to_remove);
+		// clear banned transactions timeouts
+		self.rotator.clear_timeouts(&now);
+
+		Ok(())
+	}
+
+	/// Get api reference.
+	pub fn api(&self) -> &B {
+		&self.api
+	}
+
+	/// Return an event stream of notifications for when transactions are imported to the pool.
+	///
+	/// Consumers of this stream should use the `ready` method to actually get the
+	/// pending transactions in the right order.
+	pub fn import_notification_stream(&self) -> EventStream<ExtrinsicHash<B>> {
+		const CHANNEL_BUFFER_SIZE: usize = 1024;
+
+		let (sink, stream) = channel(CHANNEL_BUFFER_SIZE);
+		self.import_notification_sinks.lock().push(sink);
+		stream
+	}
+
+	/// Invoked when extrinsics are broadcasted.
+	pub fn on_broadcasted(&self, propagated: HashMap<ExtrinsicHash<B>, Vec<String>>) {
+		let mut listener = self.listener.write();
+		for (hash, peers) in propagated.into_iter() {
+			listener.broadcasted(&hash, peers);
+		}
+	}
+
+	/// Remove a subtree of transactions from the pool and mark them invalid.
+	///
+	/// The transactions passed as an argument will be additionally banned
+	/// to prevent them from entering the pool right away.
+	/// Note this is not the case for the dependent transactions - those may
+	/// still be valid so we want to be able to re-import them.
+	pub fn remove_invalid(&self, hashes: &[ExtrinsicHash<B>]) -> Vec<TransactionFor<B>> {
+		// early exit in case there is no invalid transactions.
+		if hashes.is_empty() {
+			return vec![]
+		}
+
+		log::debug!(target: LOG_TARGET, "Removing invalid transactions: {:?}", hashes);
+
+		// temporarily ban invalid transactions
+		self.rotator.ban(&Instant::now(), hashes.iter().cloned());
+
+		let invalid = self.pool.write().remove_subtree(hashes);
+
+		log::debug!(target: LOG_TARGET, "Removed invalid transactions: {:?}", invalid);
+
+		let mut listener = self.listener.write();
+		for tx in &invalid {
+			listener.invalid(&tx.hash);
+		}
+
+		invalid
+	}
+
+	/// Get an iterator for ready transactions ordered by priority
+	pub fn ready(&self) -> impl ReadyTransactions<Item = TransactionFor<B>> + Send {
+		self.pool.read().ready()
+	}
+
+	/// Returns a Vec of hashes and extrinsics in the future pool.
+	pub fn futures(&self) -> Vec<(ExtrinsicHash<B>, ExtrinsicFor<B>)> {
+		self.pool.read().futures().map(|tx| (tx.hash, tx.data.clone())).collect()
+	}
+
+	/// Returns pool status.
+	pub fn status(&self) -> PoolStatus {
+		self.pool.read().status()
+	}
+
+	/// Notify all watchers that transactions in the block with hash have been finalized
+	pub async fn on_block_finalized(&self, block_hash: BlockHash<B>) -> Result<(), B::Error> {
+		log::trace!(
+			target: LOG_TARGET,
+			"Attempting to notify watchers of finalization for {}",
+			block_hash,
+		);
+		self.listener.write().finalized(block_hash);
+		Ok(())
+	}
+
+	/// Notify the listener of retracted blocks
+	pub fn on_block_retracted(&self, block_hash: BlockHash<B>) {
+		self.listener.write().retracted(block_hash)
+	}
+}
+
+fn fire_events<H, B, Ex>(listener: &mut Listener<H, B>, imported: &base::Imported<H, Ex>)
+where
+	H: hash::Hash + Eq + traits::Member + Serialize,
+	B: ChainApi,
+{
+	match *imported {
+		base::Imported::Ready { ref promoted, ref failed, ref removed, ref hash } => {
+			listener.ready(hash, None);
+			failed.iter().for_each(|f| listener.invalid(f));
+			removed.iter().for_each(|r| listener.dropped(&r.hash, Some(hash)));
+			promoted.iter().for_each(|p| listener.ready(p, None));
+		},
+		base::Imported::Future { ref hash } => listener.future(hash),
+	}
+}
diff --git a/substrate/client/transaction-pool/src/graph/watcher.rs b/substrate/client/transaction-pool/src/graph/watcher.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fc440771d7bbccf951a672bece221885215f4c1d
--- /dev/null
+++ b/substrate/client/transaction-pool/src/graph/watcher.rs
@@ -0,0 +1,134 @@
+// 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/>.
+
+//! Extrinsics status updates.
+
+use futures::Stream;
+use sc_transaction_pool_api::TransactionStatus;
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+
+/// Extrinsic watcher.
+///
+/// Represents a stream of status updates for a particular extrinsic.
+#[derive(Debug)]
+pub struct Watcher<H, BH> {
+	receiver: TracingUnboundedReceiver<TransactionStatus<H, BH>>,
+	/// transaction hash of watched extrinsic
+	hash: H,
+}
+
+impl<H, BH> Watcher<H, BH> {
+	/// Returns the transaction hash.
+	pub fn hash(&self) -> &H {
+		&self.hash
+	}
+
+	/// Pipe the notifications to given sink.
+	///
+	/// Make sure to drive the future to completion.
+	pub fn into_stream(self) -> impl Stream<Item = TransactionStatus<H, BH>> {
+		self.receiver
+	}
+}
+
+/// Sender part of the watcher. Exposed only for testing purposes.
+#[derive(Debug)]
+pub struct Sender<H, BH> {
+	receivers: Vec<TracingUnboundedSender<TransactionStatus<H, BH>>>,
+	is_finalized: bool,
+}
+
+impl<H, BH> Default for Sender<H, BH> {
+	fn default() -> Self {
+		Sender { receivers: Default::default(), is_finalized: false }
+	}
+}
+
+impl<H: Clone, BH: Clone> Sender<H, BH> {
+	/// Add a new watcher to this sender object.
+	pub fn new_watcher(&mut self, hash: H) -> Watcher<H, BH> {
+		let (tx, receiver) = tracing_unbounded("mpsc_txpool_watcher", 100_000);
+		self.receivers.push(tx);
+		Watcher { receiver, hash }
+	}
+
+	/// Transaction became ready.
+	pub fn ready(&mut self) {
+		self.send(TransactionStatus::Ready)
+	}
+
+	/// Transaction was moved to future.
+	pub fn future(&mut self) {
+		self.send(TransactionStatus::Future)
+	}
+
+	/// Some state change (perhaps another extrinsic was included) rendered this extrinsic invalid.
+	pub fn usurped(&mut self, hash: H) {
+		self.send(TransactionStatus::Usurped(hash));
+		self.is_finalized = true;
+	}
+
+	/// Extrinsic has been included in block with given hash.
+	pub fn in_block(&mut self, hash: BH, index: usize) {
+		self.send(TransactionStatus::InBlock((hash, index)));
+	}
+
+	/// Extrinsic has been finalized by a finality gadget.
+	pub fn finalized(&mut self, hash: BH, index: usize) {
+		self.send(TransactionStatus::Finalized((hash, index)));
+		self.is_finalized = true;
+	}
+
+	/// The block this extrinsic was included in has been retracted
+	pub fn finality_timeout(&mut self, hash: BH) {
+		self.send(TransactionStatus::FinalityTimeout(hash));
+		self.is_finalized = true;
+	}
+
+	/// The block this extrinsic was included in has been retracted
+	pub fn retracted(&mut self, hash: BH) {
+		self.send(TransactionStatus::Retracted(hash));
+	}
+
+	/// Extrinsic has been marked as invalid by the block builder.
+	pub fn invalid(&mut self) {
+		self.send(TransactionStatus::Invalid);
+		// we mark as finalized as there are no more notifications
+		self.is_finalized = true;
+	}
+
+	/// Transaction has been dropped from the pool because of the limit.
+	pub fn dropped(&mut self) {
+		self.send(TransactionStatus::Dropped);
+		self.is_finalized = true;
+	}
+
+	/// The extrinsic has been broadcast to the given peers.
+	pub fn broadcast(&mut self, peers: Vec<String>) {
+		self.send(TransactionStatus::Broadcast(peers))
+	}
+
+	/// Returns true if the are no more listeners for this extrinsic or it was finalized.
+	pub fn is_done(&self) -> bool {
+		self.is_finalized || self.receivers.is_empty()
+	}
+
+	fn send(&mut self, status: TransactionStatus<H, BH>) {
+		self.receivers.retain(|sender| sender.unbounded_send(status.clone()).is_ok())
+	}
+}
diff --git a/substrate/client/transaction-pool/src/lib.rs b/substrate/client/transaction-pool/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..80e5925194c6848291c275d7e7c80c4e239f7494
--- /dev/null
+++ b/substrate/client/transaction-pool/src/lib.rs
@@ -0,0 +1,794 @@
+// 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/>.
+
+//! Substrate transaction pool implementation.
+
+#![recursion_limit = "256"]
+#![warn(missing_docs)]
+#![warn(unused_extern_crates)]
+
+mod api;
+mod enactment_state;
+pub mod error;
+mod graph;
+mod metrics;
+mod revalidation;
+#[cfg(test)]
+mod tests;
+
+pub use crate::api::FullChainApi;
+use async_trait::async_trait;
+use enactment_state::{EnactmentAction, EnactmentState};
+use futures::{
+	channel::oneshot,
+	future::{self, ready},
+	prelude::*,
+};
+pub use graph::{
+	base_pool::Limit as PoolLimit, ChainApi, Options, Pool, Transaction, ValidatedTransaction,
+};
+use parking_lot::Mutex;
+use std::{
+	collections::{HashMap, HashSet},
+	pin::Pin,
+	sync::Arc,
+};
+
+use graph::{ExtrinsicHash, IsValidator};
+use sc_transaction_pool_api::{
+	error::Error as TxPoolError, ChainEvent, ImportNotificationStream, MaintainedTransactionPool,
+	PoolFuture, PoolStatus, ReadyTransactions, TransactionFor, TransactionPool, TransactionSource,
+	TransactionStatusStreamFor, TxHash,
+};
+use sp_core::traits::SpawnEssentialNamed;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{AtLeast32Bit, Block as BlockT, Extrinsic, Header as HeaderT, NumberFor, Zero},
+};
+use std::time::Instant;
+
+use crate::metrics::MetricsLink as PrometheusMetrics;
+use prometheus_endpoint::Registry as PrometheusRegistry;
+
+use sp_blockchain::{HashAndNumber, TreeRoute};
+
+pub(crate) const LOG_TARGET: &str = "txpool";
+
+type BoxedReadyIterator<Hash, Data> =
+	Box<dyn ReadyTransactions<Item = Arc<graph::base_pool::Transaction<Hash, Data>>> + Send>;
+
+type ReadyIteratorFor<PoolApi> =
+	BoxedReadyIterator<graph::ExtrinsicHash<PoolApi>, graph::ExtrinsicFor<PoolApi>>;
+
+type PolledIterator<PoolApi> = Pin<Box<dyn Future<Output = ReadyIteratorFor<PoolApi>> + Send>>;
+
+/// A transaction pool for a full node.
+pub type FullPool<Block, Client> = BasicPool<FullChainApi<Client, Block>, Block>;
+
+/// Basic implementation of transaction pool that can be customized by providing PoolApi.
+pub struct BasicPool<PoolApi, Block>
+where
+	Block: BlockT,
+	PoolApi: graph::ChainApi<Block = Block>,
+{
+	pool: Arc<graph::Pool<PoolApi>>,
+	api: Arc<PoolApi>,
+	revalidation_strategy: Arc<Mutex<RevalidationStrategy<NumberFor<Block>>>>,
+	revalidation_queue: Arc<revalidation::RevalidationQueue<PoolApi>>,
+	ready_poll: Arc<Mutex<ReadyPoll<ReadyIteratorFor<PoolApi>, Block>>>,
+	metrics: PrometheusMetrics,
+	enactment_state: Arc<Mutex<EnactmentState<Block>>>,
+}
+
+struct ReadyPoll<T, Block: BlockT> {
+	updated_at: NumberFor<Block>,
+	pollers: Vec<(NumberFor<Block>, oneshot::Sender<T>)>,
+}
+
+impl<T, Block: BlockT> Default for ReadyPoll<T, Block> {
+	fn default() -> Self {
+		Self { updated_at: NumberFor::<Block>::zero(), pollers: Default::default() }
+	}
+}
+
+impl<T, Block: BlockT> ReadyPoll<T, Block> {
+	fn new(best_block_number: NumberFor<Block>) -> Self {
+		Self { updated_at: best_block_number, pollers: Default::default() }
+	}
+
+	fn trigger(&mut self, number: NumberFor<Block>, iterator_factory: impl Fn() -> T) {
+		self.updated_at = number;
+
+		let mut idx = 0;
+		while idx < self.pollers.len() {
+			if self.pollers[idx].0 <= number {
+				let poller_sender = self.pollers.swap_remove(idx);
+				log::debug!(target: LOG_TARGET, "Sending ready signal at block {}", number);
+				let _ = poller_sender.1.send(iterator_factory());
+			} else {
+				idx += 1;
+			}
+		}
+	}
+
+	fn add(&mut self, number: NumberFor<Block>) -> oneshot::Receiver<T> {
+		let (sender, receiver) = oneshot::channel();
+		self.pollers.push((number, sender));
+		receiver
+	}
+
+	fn updated_at(&self) -> NumberFor<Block> {
+		self.updated_at
+	}
+}
+
+/// Type of revalidation.
+pub enum RevalidationType {
+	/// Light revalidation type.
+	///
+	/// During maintenance, transaction pool makes periodic revalidation
+	/// of all transactions depending on number of blocks or time passed.
+	/// Also this kind of revalidation does not resubmit transactions from
+	/// retracted blocks, since it is too expensive.
+	Light,
+
+	/// Full revalidation type.
+	///
+	/// During maintenance, transaction pool revalidates some fixed amount of
+	/// transactions from the pool of valid transactions.
+	Full,
+}
+
+impl<PoolApi, Block> BasicPool<PoolApi, Block>
+where
+	Block: BlockT,
+	PoolApi: graph::ChainApi<Block = Block> + 'static,
+{
+	/// Create new basic transaction pool with provided api, for tests.
+	pub fn new_test(
+		pool_api: Arc<PoolApi>,
+		best_block_hash: Block::Hash,
+		finalized_hash: Block::Hash,
+	) -> (Self, Pin<Box<dyn Future<Output = ()> + Send>>) {
+		let pool = Arc::new(graph::Pool::new(Default::default(), true.into(), pool_api.clone()));
+		let (revalidation_queue, background_task) =
+			revalidation::RevalidationQueue::new_background(pool_api.clone(), pool.clone());
+		(
+			Self {
+				api: pool_api,
+				pool,
+				revalidation_queue: Arc::new(revalidation_queue),
+				revalidation_strategy: Arc::new(Mutex::new(RevalidationStrategy::Always)),
+				ready_poll: Default::default(),
+				metrics: Default::default(),
+				enactment_state: Arc::new(Mutex::new(EnactmentState::new(
+					best_block_hash,
+					finalized_hash,
+				))),
+			},
+			background_task,
+		)
+	}
+
+	/// Create new basic transaction pool with provided api and custom
+	/// revalidation type.
+	pub fn with_revalidation_type(
+		options: graph::Options,
+		is_validator: IsValidator,
+		pool_api: Arc<PoolApi>,
+		prometheus: Option<&PrometheusRegistry>,
+		revalidation_type: RevalidationType,
+		spawner: impl SpawnEssentialNamed,
+		best_block_number: NumberFor<Block>,
+		best_block_hash: Block::Hash,
+		finalized_hash: Block::Hash,
+	) -> Self {
+		let pool = Arc::new(graph::Pool::new(options, is_validator, pool_api.clone()));
+		let (revalidation_queue, background_task) = match revalidation_type {
+			RevalidationType::Light =>
+				(revalidation::RevalidationQueue::new(pool_api.clone(), pool.clone()), None),
+			RevalidationType::Full => {
+				let (queue, background) =
+					revalidation::RevalidationQueue::new_background(pool_api.clone(), pool.clone());
+				(queue, Some(background))
+			},
+		};
+
+		if let Some(background_task) = background_task {
+			spawner.spawn_essential("txpool-background", Some("transaction-pool"), background_task);
+		}
+
+		Self {
+			api: pool_api,
+			pool,
+			revalidation_queue: Arc::new(revalidation_queue),
+			revalidation_strategy: Arc::new(Mutex::new(match revalidation_type {
+				RevalidationType::Light =>
+					RevalidationStrategy::Light(RevalidationStatus::NotScheduled),
+				RevalidationType::Full => RevalidationStrategy::Always,
+			})),
+			ready_poll: Arc::new(Mutex::new(ReadyPoll::new(best_block_number))),
+			metrics: PrometheusMetrics::new(prometheus),
+			enactment_state: Arc::new(Mutex::new(EnactmentState::new(
+				best_block_hash,
+				finalized_hash,
+			))),
+		}
+	}
+
+	/// Gets shared reference to the underlying pool.
+	pub fn pool(&self) -> &Arc<graph::Pool<PoolApi>> {
+		&self.pool
+	}
+
+	/// Get access to the underlying api
+	pub fn api(&self) -> &PoolApi {
+		&self.api
+	}
+}
+
+impl<PoolApi, Block> TransactionPool for BasicPool<PoolApi, Block>
+where
+	Block: BlockT,
+	PoolApi: 'static + graph::ChainApi<Block = Block>,
+{
+	type Block = PoolApi::Block;
+	type Hash = graph::ExtrinsicHash<PoolApi>;
+	type InPoolTransaction = graph::base_pool::Transaction<TxHash<Self>, TransactionFor<Self>>;
+	type Error = PoolApi::Error;
+
+	fn submit_at(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		xts: Vec<TransactionFor<Self>>,
+	) -> PoolFuture<Vec<Result<TxHash<Self>, Self::Error>>, Self::Error> {
+		let pool = self.pool.clone();
+		let at = *at;
+
+		self.metrics
+			.report(|metrics| metrics.submitted_transactions.inc_by(xts.len() as u64));
+
+		async move { pool.submit_at(&at, source, xts).await }.boxed()
+	}
+
+	fn submit_one(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		xt: TransactionFor<Self>,
+	) -> PoolFuture<TxHash<Self>, Self::Error> {
+		let pool = self.pool.clone();
+		let at = *at;
+
+		self.metrics.report(|metrics| metrics.submitted_transactions.inc());
+
+		async move { pool.submit_one(&at, source, xt).await }.boxed()
+	}
+
+	fn submit_and_watch(
+		&self,
+		at: &BlockId<Self::Block>,
+		source: TransactionSource,
+		xt: TransactionFor<Self>,
+	) -> PoolFuture<Pin<Box<TransactionStatusStreamFor<Self>>>, Self::Error> {
+		let at = *at;
+		let pool = self.pool.clone();
+
+		self.metrics.report(|metrics| metrics.submitted_transactions.inc());
+
+		async move {
+			let watcher = pool.submit_and_watch(&at, source, xt).await?;
+
+			Ok(watcher.into_stream().boxed())
+		}
+		.boxed()
+	}
+
+	fn remove_invalid(&self, hashes: &[TxHash<Self>]) -> Vec<Arc<Self::InPoolTransaction>> {
+		let removed = self.pool.validated_pool().remove_invalid(hashes);
+		self.metrics
+			.report(|metrics| metrics.validations_invalid.inc_by(removed.len() as u64));
+		removed
+	}
+
+	fn status(&self) -> PoolStatus {
+		self.pool.validated_pool().status()
+	}
+
+	fn import_notification_stream(&self) -> ImportNotificationStream<TxHash<Self>> {
+		self.pool.validated_pool().import_notification_stream()
+	}
+
+	fn hash_of(&self, xt: &TransactionFor<Self>) -> TxHash<Self> {
+		self.pool.hash_of(xt)
+	}
+
+	fn on_broadcasted(&self, propagations: HashMap<TxHash<Self>, Vec<String>>) {
+		self.pool.validated_pool().on_broadcasted(propagations)
+	}
+
+	fn ready_transaction(&self, hash: &TxHash<Self>) -> Option<Arc<Self::InPoolTransaction>> {
+		self.pool.validated_pool().ready_by_hash(hash)
+	}
+
+	fn ready_at(&self, at: NumberFor<Self::Block>) -> PolledIterator<PoolApi> {
+		let status = self.status();
+		// If there are no transactions in the pool, it is fine to return early.
+		//
+		// There could be transaction being added because of some re-org happening at the relevant
+		// block, but this is relative unlikely.
+		if status.ready == 0 && status.future == 0 {
+			return async { Box::new(std::iter::empty()) as Box<_> }.boxed()
+		}
+
+		if self.ready_poll.lock().updated_at() >= at {
+			log::trace!(target: LOG_TARGET, "Transaction pool already processed block  #{}", at);
+			let iterator: ReadyIteratorFor<PoolApi> = Box::new(self.pool.validated_pool().ready());
+			return async move { iterator }.boxed()
+		}
+
+		self.ready_poll
+			.lock()
+			.add(at)
+			.map(|received| {
+				received.unwrap_or_else(|e| {
+					log::warn!("Error receiving pending set: {:?}", e);
+					Box::new(std::iter::empty())
+				})
+			})
+			.boxed()
+	}
+
+	fn ready(&self) -> ReadyIteratorFor<PoolApi> {
+		Box::new(self.pool.validated_pool().ready())
+	}
+}
+
+impl<Block, Client> FullPool<Block, Client>
+where
+	Block: BlockT,
+	Client: sp_api::ProvideRuntimeApi<Block>
+		+ sc_client_api::BlockBackend<Block>
+		+ sc_client_api::blockchain::HeaderBackend<Block>
+		+ sp_runtime::traits::BlockIdTo<Block>
+		+ sc_client_api::ExecutorProvider<Block>
+		+ sc_client_api::UsageProvider<Block>
+		+ sp_blockchain::HeaderMetadata<Block, Error = sp_blockchain::Error>
+		+ Send
+		+ Sync
+		+ 'static,
+	Client::Api: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>,
+{
+	/// Create new basic transaction pool for a full node with the provided api.
+	pub fn new_full(
+		options: graph::Options,
+		is_validator: IsValidator,
+		prometheus: Option<&PrometheusRegistry>,
+		spawner: impl SpawnEssentialNamed,
+		client: Arc<Client>,
+	) -> Arc<Self> {
+		let pool_api = Arc::new(FullChainApi::new(client.clone(), prometheus, &spawner));
+		let pool = Arc::new(Self::with_revalidation_type(
+			options,
+			is_validator,
+			pool_api,
+			prometheus,
+			RevalidationType::Full,
+			spawner,
+			client.usage_info().chain.best_number,
+			client.usage_info().chain.best_hash,
+			client.usage_info().chain.finalized_hash,
+		));
+
+		pool
+	}
+}
+
+impl<Block, Client> sc_transaction_pool_api::LocalTransactionPool
+	for BasicPool<FullChainApi<Client, Block>, Block>
+where
+	Block: BlockT,
+	Client: sp_api::ProvideRuntimeApi<Block>
+		+ sc_client_api::BlockBackend<Block>
+		+ sc_client_api::blockchain::HeaderBackend<Block>
+		+ sp_runtime::traits::BlockIdTo<Block>
+		+ sp_blockchain::HeaderMetadata<Block, Error = sp_blockchain::Error>,
+	Client: Send + Sync + 'static,
+	Client::Api: sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block>,
+{
+	type Block = Block;
+	type Hash = graph::ExtrinsicHash<FullChainApi<Client, Block>>;
+	type Error = <FullChainApi<Client, Block> as graph::ChainApi>::Error;
+
+	fn submit_local(
+		&self,
+		at: Block::Hash,
+		xt: sc_transaction_pool_api::LocalTransactionFor<Self>,
+	) -> Result<Self::Hash, Self::Error> {
+		use sp_runtime::{
+			traits::SaturatedConversion, transaction_validity::TransactionValidityError,
+		};
+
+		let validity = self
+			.api
+			.validate_transaction_blocking(
+				&BlockId::hash(at),
+				TransactionSource::Local,
+				xt.clone(),
+			)?
+			.map_err(|e| {
+				Self::Error::Pool(match e {
+					TransactionValidityError::Invalid(i) => TxPoolError::InvalidTransaction(i),
+					TransactionValidityError::Unknown(u) => TxPoolError::UnknownTransaction(u),
+				})
+			})?;
+
+		let (hash, bytes) = self.pool.validated_pool().api().hash_and_length(&xt);
+		let block_number = self
+			.api
+			.block_id_to_number(&BlockId::hash(at))?
+			.ok_or_else(|| error::Error::BlockIdConversion(format!("{:?}", at)))?;
+
+		let validated = ValidatedTransaction::valid_at(
+			block_number.saturated_into::<u64>(),
+			hash,
+			TransactionSource::Local,
+			xt,
+			bytes,
+			validity,
+		);
+
+		self.pool.validated_pool().submit(vec![validated]).remove(0)
+	}
+}
+
+#[cfg_attr(test, derive(Debug))]
+enum RevalidationStatus<N> {
+	/// The revalidation has never been completed.
+	NotScheduled,
+	/// The revalidation is scheduled.
+	Scheduled(Option<Instant>, Option<N>),
+	/// The revalidation is in progress.
+	InProgress,
+}
+
+enum RevalidationStrategy<N> {
+	Always,
+	Light(RevalidationStatus<N>),
+}
+
+struct RevalidationAction {
+	revalidate: bool,
+	resubmit: bool,
+}
+
+impl<N: Clone + Copy + AtLeast32Bit> RevalidationStrategy<N> {
+	pub fn clear(&mut self) {
+		if let Self::Light(status) = self {
+			status.clear()
+		}
+	}
+
+	pub fn next(
+		&mut self,
+		block: N,
+		revalidate_time_period: Option<std::time::Duration>,
+		revalidate_block_period: Option<N>,
+	) -> RevalidationAction {
+		match self {
+			Self::Light(status) => RevalidationAction {
+				revalidate: status.next_required(
+					block,
+					revalidate_time_period,
+					revalidate_block_period,
+				),
+				resubmit: false,
+			},
+			Self::Always => RevalidationAction { revalidate: true, resubmit: true },
+		}
+	}
+}
+
+impl<N: Clone + Copy + AtLeast32Bit> RevalidationStatus<N> {
+	/// Called when revalidation is completed.
+	pub fn clear(&mut self) {
+		*self = Self::NotScheduled;
+	}
+
+	/// Returns true if revalidation is required.
+	pub fn next_required(
+		&mut self,
+		block: N,
+		revalidate_time_period: Option<std::time::Duration>,
+		revalidate_block_period: Option<N>,
+	) -> bool {
+		match *self {
+			Self::NotScheduled => {
+				*self = Self::Scheduled(
+					revalidate_time_period.map(|period| Instant::now() + period),
+					revalidate_block_period.map(|period| block + period),
+				);
+				false
+			},
+			Self::Scheduled(revalidate_at_time, revalidate_at_block) => {
+				let is_required =
+					revalidate_at_time.map(|at| Instant::now() >= at).unwrap_or(false) ||
+						revalidate_at_block.map(|at| block >= at).unwrap_or(false);
+				if is_required {
+					*self = Self::InProgress;
+				}
+				is_required
+			},
+			Self::InProgress => false,
+		}
+	}
+}
+
+/// Prune the known txs for the given block.
+async fn prune_known_txs_for_block<Block: BlockT, Api: graph::ChainApi<Block = Block>>(
+	block_hash: Block::Hash,
+	api: &Api,
+	pool: &graph::Pool<Api>,
+) -> Vec<ExtrinsicHash<Api>> {
+	let extrinsics = api
+		.block_body(block_hash)
+		.await
+		.unwrap_or_else(|e| {
+			log::warn!("Prune known transactions: error request: {}", e);
+			None
+		})
+		.unwrap_or_default();
+
+	let hashes = extrinsics.iter().map(|tx| pool.hash_of(tx)).collect::<Vec<_>>();
+
+	log::trace!(target: LOG_TARGET, "Pruning transactions: {:?}", hashes);
+
+	let header = match api.block_header(block_hash) {
+		Ok(Some(h)) => h,
+		Ok(None) => {
+			log::debug!(target: LOG_TARGET, "Could not find header for {:?}.", block_hash);
+			return hashes
+		},
+		Err(e) => {
+			log::debug!(target: LOG_TARGET, "Error retrieving header for {:?}: {}", block_hash, e);
+			return hashes
+		},
+	};
+
+	if let Err(e) = pool
+		.prune(&BlockId::Hash(block_hash), &BlockId::hash(*header.parent_hash()), &extrinsics)
+		.await
+	{
+		log::error!("Cannot prune known in the pool: {}", e);
+	}
+
+	hashes
+}
+
+impl<PoolApi, Block> BasicPool<PoolApi, Block>
+where
+	Block: BlockT,
+	PoolApi: 'static + graph::ChainApi<Block = Block>,
+{
+	/// Handles enactment and retraction of blocks, prunes stale transactions
+	/// (that have already been enacted) and resubmits transactions that were
+	/// retracted.
+	async fn handle_enactment(&self, tree_route: TreeRoute<Block>) {
+		log::trace!(target: LOG_TARGET, "handle_enactment tree_route: {tree_route:?}");
+		let pool = self.pool.clone();
+		let api = self.api.clone();
+
+		let (hash, block_number) = match tree_route.last() {
+			Some(HashAndNumber { hash, number }) => (hash, number),
+			None => {
+				log::warn!(
+					target: LOG_TARGET,
+					"Skipping ChainEvent - no last block in tree route {:?}",
+					tree_route,
+				);
+				return
+			},
+		};
+
+		let next_action = self.revalidation_strategy.lock().next(
+			*block_number,
+			Some(std::time::Duration::from_secs(60)),
+			Some(20u32.into()),
+		);
+
+		// We keep track of everything we prune so that later we won't add
+		// transactions with those hashes from the retracted blocks.
+		let mut pruned_log = HashSet::<ExtrinsicHash<PoolApi>>::new();
+
+		// If there is a tree route, we use this to prune known tx based on the enacted
+		// blocks. Before pruning enacted transactions, we inform the listeners about
+		// retracted blocks and their transactions. This order is important, because
+		// if we enact and retract the same transaction at the same time, we want to
+		// send first the retract and than the prune event.
+		for retracted in tree_route.retracted() {
+			// notify txs awaiting finality that it has been retracted
+			pool.validated_pool().on_block_retracted(retracted.hash);
+		}
+
+		future::join_all(
+			tree_route
+				.enacted()
+				.iter()
+				.map(|h| prune_known_txs_for_block(h.hash, &*api, &*pool)),
+		)
+		.await
+		.into_iter()
+		.for_each(|enacted_log| {
+			pruned_log.extend(enacted_log);
+		});
+
+		self.metrics
+			.report(|metrics| metrics.block_transactions_pruned.inc_by(pruned_log.len() as u64));
+
+		if next_action.resubmit {
+			let mut resubmit_transactions = Vec::new();
+
+			for retracted in tree_route.retracted() {
+				let hash = retracted.hash;
+
+				let block_transactions = api
+					.block_body(hash)
+					.await
+					.unwrap_or_else(|e| {
+						log::warn!("Failed to fetch block body: {}", e);
+						None
+					})
+					.unwrap_or_default()
+					.into_iter()
+					.filter(|tx| tx.is_signed().unwrap_or(true));
+
+				let mut resubmitted_to_report = 0;
+
+				resubmit_transactions.extend(block_transactions.into_iter().filter(|tx| {
+					let tx_hash = pool.hash_of(tx);
+					let contains = pruned_log.contains(&tx_hash);
+
+					// need to count all transactions, not just filtered, here
+					resubmitted_to_report += 1;
+
+					if !contains {
+						log::debug!(
+							target: LOG_TARGET,
+							"[{:?}]: Resubmitting from retracted block {:?}",
+							tx_hash,
+							hash,
+						);
+					}
+					!contains
+				}));
+
+				self.metrics.report(|metrics| {
+					metrics.block_transactions_resubmitted.inc_by(resubmitted_to_report)
+				});
+			}
+
+			if let Err(e) = pool
+				.resubmit_at(
+					&BlockId::Hash(*hash),
+					// These transactions are coming from retracted blocks, we should
+					// simply consider them external.
+					TransactionSource::External,
+					resubmit_transactions,
+				)
+				.await
+			{
+				log::debug!(
+					target: LOG_TARGET,
+					"[{:?}] Error re-submitting transactions: {}",
+					hash,
+					e,
+				)
+			}
+		}
+
+		let extra_pool = pool.clone();
+		// After #5200 lands, this arguably might be moved to the
+		// handler of "all blocks notification".
+		self.ready_poll
+			.lock()
+			.trigger(*block_number, move || Box::new(extra_pool.validated_pool().ready()));
+
+		if next_action.revalidate {
+			let hashes = pool.validated_pool().ready().map(|tx| tx.hash).collect();
+			self.revalidation_queue.revalidate_later(*block_number, hashes).await;
+
+			self.revalidation_strategy.lock().clear();
+		}
+	}
+}
+
+#[async_trait]
+impl<PoolApi, Block> MaintainedTransactionPool for BasicPool<PoolApi, Block>
+where
+	Block: BlockT,
+	PoolApi: 'static + graph::ChainApi<Block = Block>,
+{
+	async fn maintain(&self, event: ChainEvent<Self::Block>) {
+		let prev_finalized_block = self.enactment_state.lock().recent_finalized_block();
+		let compute_tree_route = |from, to| -> Result<TreeRoute<Block>, String> {
+			match self.api.tree_route(from, to) {
+				Ok(tree_route) => Ok(tree_route),
+				Err(e) =>
+					return Err(format!(
+						"Error occurred while computing tree_route from {from:?} to {to:?}: {e}"
+					)),
+			}
+		};
+		let block_id_to_number =
+			|hash| self.api.block_id_to_number(&BlockId::Hash(hash)).map_err(|e| format!("{}", e));
+
+		let result =
+			self.enactment_state
+				.lock()
+				.update(&event, &compute_tree_route, &block_id_to_number);
+
+		match result {
+			Err(msg) => {
+				log::debug!(target: LOG_TARGET, "{msg}");
+				self.enactment_state.lock().force_update(&event);
+			},
+			Ok(EnactmentAction::Skip) => return,
+			Ok(EnactmentAction::HandleFinalization) => {},
+			Ok(EnactmentAction::HandleEnactment(tree_route)) => {
+				self.handle_enactment(tree_route).await;
+			},
+		};
+
+		if let ChainEvent::Finalized { hash, tree_route } = event {
+			log::trace!(
+				target: LOG_TARGET,
+				"on-finalized enacted: {tree_route:?}, previously finalized: \
+				{prev_finalized_block:?}",
+			);
+
+			for hash in tree_route.iter().chain(std::iter::once(&hash)) {
+				if let Err(e) = self.pool.validated_pool().on_block_finalized(*hash).await {
+					log::warn!(
+						target: LOG_TARGET,
+						"Error occurred while attempting to notify watchers about finalization {}: {}",
+						hash, e
+					)
+				}
+			}
+		}
+	}
+}
+
+/// Inform the transaction pool about imported and finalized blocks.
+pub async fn notification_future<Client, Pool, Block>(client: Arc<Client>, txpool: Arc<Pool>)
+where
+	Block: BlockT,
+	Client: sc_client_api::BlockchainEvents<Block>,
+	Pool: MaintainedTransactionPool<Block = Block>,
+{
+	let import_stream = client
+		.import_notification_stream()
+		.filter_map(|n| ready(n.try_into().ok()))
+		.fuse();
+	let finality_stream = client.finality_notification_stream().map(Into::into).fuse();
+
+	futures::stream::select(import_stream, finality_stream)
+		.for_each(|evt| txpool.maintain(evt))
+		.await
+}
diff --git a/substrate/client/transaction-pool/src/metrics.rs b/substrate/client/transaction-pool/src/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..170bface96477e2ea69fe05eb182b600ef5ee03d
--- /dev/null
+++ b/substrate/client/transaction-pool/src/metrics.rs
@@ -0,0 +1,129 @@
+// 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/>.
+
+//! Transaction pool Prometheus metrics.
+
+use std::sync::Arc;
+
+use prometheus_endpoint::{register, Counter, PrometheusError, Registry, U64};
+
+#[derive(Clone, Default)]
+pub struct MetricsLink(Arc<Option<Metrics>>);
+
+impl MetricsLink {
+	pub fn new(registry: Option<&Registry>) -> Self {
+		Self(Arc::new(registry.and_then(|registry| {
+			Metrics::register(registry)
+				.map_err(|err| {
+					log::warn!("Failed to register prometheus metrics: {}", err);
+				})
+				.ok()
+		})))
+	}
+
+	pub fn report(&self, do_this: impl FnOnce(&Metrics)) {
+		if let Some(metrics) = self.0.as_ref() {
+			do_this(metrics);
+		}
+	}
+}
+
+/// Transaction pool Prometheus metrics.
+pub struct Metrics {
+	pub submitted_transactions: Counter<U64>,
+	pub validations_invalid: Counter<U64>,
+	pub block_transactions_pruned: Counter<U64>,
+	pub block_transactions_resubmitted: Counter<U64>,
+}
+
+impl Metrics {
+	pub fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			submitted_transactions: register(
+				Counter::new(
+					"substrate_sub_txpool_submitted_transactions",
+					"Total number of transactions submitted",
+				)?,
+				registry,
+			)?,
+			validations_invalid: register(
+				Counter::new(
+					"substrate_sub_txpool_validations_invalid",
+					"Total number of transactions that were removed from the pool as invalid",
+				)?,
+				registry,
+			)?,
+			block_transactions_pruned: register(
+				Counter::new(
+					"substrate_sub_txpool_block_transactions_pruned",
+					"Total number of transactions that was requested to be pruned by block events",
+				)?,
+				registry,
+			)?,
+			block_transactions_resubmitted: register(
+				Counter::new(
+					"substrate_sub_txpool_block_transactions_resubmitted",
+					"Total number of transactions that was requested to be resubmitted by block events",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// Transaction pool api Prometheus metrics.
+pub struct ApiMetrics {
+	pub validations_scheduled: Counter<U64>,
+	pub validations_finished: Counter<U64>,
+}
+
+impl ApiMetrics {
+	/// Register the metrics at the given Prometheus registry.
+	pub fn register(registry: &Registry) -> Result<Self, PrometheusError> {
+		Ok(Self {
+			validations_scheduled: register(
+				Counter::new(
+					"substrate_sub_txpool_validations_scheduled",
+					"Total number of transactions scheduled for validation",
+				)?,
+				registry,
+			)?,
+			validations_finished: register(
+				Counter::new(
+					"substrate_sub_txpool_validations_finished",
+					"Total number of transactions that finished validation",
+				)?,
+				registry,
+			)?,
+		})
+	}
+}
+
+/// An extension trait for [`ApiMetrics`].
+pub trait ApiMetricsExt {
+	/// Report an event to the metrics.
+	fn report(&self, report: impl FnOnce(&ApiMetrics));
+}
+
+impl ApiMetricsExt for Option<Arc<ApiMetrics>> {
+	fn report(&self, report: impl FnOnce(&ApiMetrics)) {
+		if let Some(metrics) = self.as_ref() {
+			report(metrics)
+		}
+	}
+}
diff --git a/substrate/client/transaction-pool/src/revalidation.rs b/substrate/client/transaction-pool/src/revalidation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b2c41be92eea3cdbe55bf2db5ddfe5d23d91d8bd
--- /dev/null
+++ b/substrate/client/transaction-pool/src/revalidation.rs
@@ -0,0 +1,393 @@
+// 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/>.
+
+//! Pool periodic revalidation.
+
+use std::{
+	collections::{BTreeMap, HashMap, HashSet},
+	pin::Pin,
+	sync::Arc,
+};
+
+use crate::{
+	graph::{ChainApi, ExtrinsicHash, NumberFor, Pool, ValidatedTransaction},
+	LOG_TARGET,
+};
+use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use sp_runtime::{
+	generic::BlockId,
+	traits::{SaturatedConversion, Zero},
+	transaction_validity::TransactionValidityError,
+};
+
+use futures::prelude::*;
+use std::time::Duration;
+
+const BACKGROUND_REVALIDATION_INTERVAL: Duration = Duration::from_millis(200);
+
+const MIN_BACKGROUND_REVALIDATION_BATCH_SIZE: usize = 20;
+
+/// Payload from queue to worker.
+struct WorkerPayload<Api: ChainApi> {
+	at: NumberFor<Api>,
+	transactions: Vec<ExtrinsicHash<Api>>,
+}
+
+/// Async revalidation worker.
+///
+/// Implements future and can be spawned in place or in background.
+struct RevalidationWorker<Api: ChainApi> {
+	api: Arc<Api>,
+	pool: Arc<Pool<Api>>,
+	best_block: NumberFor<Api>,
+	block_ordered: BTreeMap<NumberFor<Api>, HashSet<ExtrinsicHash<Api>>>,
+	members: HashMap<ExtrinsicHash<Api>, NumberFor<Api>>,
+}
+
+impl<Api: ChainApi> Unpin for RevalidationWorker<Api> {}
+
+/// Revalidate batch of transaction.
+///
+/// Each transaction is validated  against chain, and invalid are
+/// removed from the `pool`, while valid are resubmitted.
+async fn batch_revalidate<Api: ChainApi>(
+	pool: Arc<Pool<Api>>,
+	api: Arc<Api>,
+	at: NumberFor<Api>,
+	batch: impl IntoIterator<Item = ExtrinsicHash<Api>>,
+) {
+	let mut invalid_hashes = Vec::new();
+	let mut revalidated = HashMap::new();
+
+	let validation_results = futures::future::join_all(batch.into_iter().filter_map(|ext_hash| {
+		pool.validated_pool().ready_by_hash(&ext_hash).map(|ext| {
+			api.validate_transaction(&BlockId::Number(at), ext.source, ext.data.clone())
+				.map(move |validation_result| (validation_result, ext_hash, ext))
+		})
+	}))
+	.await;
+
+	for (validation_result, ext_hash, ext) in validation_results {
+		match validation_result {
+			Ok(Err(TransactionValidityError::Invalid(err))) => {
+				log::debug!(
+					target: LOG_TARGET,
+					"[{:?}]: Revalidation: invalid {:?}",
+					ext_hash,
+					err,
+				);
+				invalid_hashes.push(ext_hash);
+			},
+			Ok(Err(TransactionValidityError::Unknown(err))) => {
+				// skipping unknown, they might be pushed by valid or invalid transaction
+				// when latter resubmitted.
+				log::trace!(
+					target: LOG_TARGET,
+					"[{:?}]: Unknown during revalidation: {:?}",
+					ext_hash,
+					err,
+				);
+			},
+			Ok(Ok(validity)) => {
+				revalidated.insert(
+					ext_hash,
+					ValidatedTransaction::valid_at(
+						at.saturated_into::<u64>(),
+						ext_hash,
+						ext.source,
+						ext.data.clone(),
+						api.hash_and_length(&ext.data).1,
+						validity,
+					),
+				);
+			},
+			Err(validation_err) => {
+				log::debug!(
+					target: LOG_TARGET,
+					"[{:?}]: Removing due to error during revalidation: {}",
+					ext_hash,
+					validation_err
+				);
+				invalid_hashes.push(ext_hash);
+			},
+		}
+	}
+
+	pool.validated_pool().remove_invalid(&invalid_hashes);
+	if revalidated.len() > 0 {
+		pool.resubmit(revalidated);
+	}
+}
+
+impl<Api: ChainApi> RevalidationWorker<Api> {
+	fn new(api: Arc<Api>, pool: Arc<Pool<Api>>) -> Self {
+		Self {
+			api,
+			pool,
+			block_ordered: Default::default(),
+			members: Default::default(),
+			best_block: Zero::zero(),
+		}
+	}
+
+	fn prepare_batch(&mut self) -> Vec<ExtrinsicHash<Api>> {
+		let mut queued_exts = Vec::new();
+		let mut left =
+			std::cmp::max(MIN_BACKGROUND_REVALIDATION_BATCH_SIZE, self.members.len() / 4);
+
+		// Take maximum of count transaction by order
+		// which they got into the pool
+		while left > 0 {
+			let first_block = match self.block_ordered.keys().next().cloned() {
+				Some(bn) => bn,
+				None => break,
+			};
+			let mut block_drained = false;
+			if let Some(extrinsics) = self.block_ordered.get_mut(&first_block) {
+				let to_queue = extrinsics.iter().take(left).cloned().collect::<Vec<_>>();
+				if to_queue.len() == extrinsics.len() {
+					block_drained = true;
+				} else {
+					for xt in &to_queue {
+						extrinsics.remove(xt);
+					}
+				}
+				left -= to_queue.len();
+				queued_exts.extend(to_queue);
+			}
+
+			if block_drained {
+				self.block_ordered.remove(&first_block);
+			}
+		}
+
+		for hash in queued_exts.iter() {
+			self.members.remove(hash);
+		}
+
+		queued_exts
+	}
+
+	fn len(&self) -> usize {
+		self.block_ordered.iter().map(|b| b.1.len()).sum()
+	}
+
+	fn push(&mut self, worker_payload: WorkerPayload<Api>) {
+		// we don't add something that already scheduled for revalidation
+		let transactions = worker_payload.transactions;
+		let block_number = worker_payload.at;
+
+		for ext_hash in transactions {
+			// we don't add something that already scheduled for revalidation
+			if self.members.contains_key(&ext_hash) {
+				log::trace!(
+					target: LOG_TARGET,
+					"[{:?}] Skipped adding for revalidation: Already there.",
+					ext_hash,
+				);
+
+				continue
+			}
+
+			self.block_ordered
+				.entry(block_number)
+				.and_modify(|value| {
+					value.insert(ext_hash);
+				})
+				.or_insert_with(|| {
+					let mut bt = HashSet::new();
+					bt.insert(ext_hash);
+					bt
+				});
+			self.members.insert(ext_hash, block_number);
+		}
+	}
+
+	/// Background worker main loop.
+	///
+	/// It does two things: periodically tries to process some transactions
+	/// from the queue and also accepts messages to enqueue some more
+	/// transactions from the pool.
+	pub async fn run(
+		mut self,
+		from_queue: TracingUnboundedReceiver<WorkerPayload<Api>>,
+		interval: Duration,
+	) {
+		let interval_fut = futures_timer::Delay::new(interval);
+		let from_queue = from_queue.fuse();
+		futures::pin_mut!(interval_fut, from_queue);
+		let this = &mut self;
+
+		loop {
+			futures::select! {
+				// Using `fuse()` in here is okay, because we reset the interval when it has fired.
+				_ = (&mut interval_fut).fuse() => {
+					let next_batch = this.prepare_batch();
+					let batch_len = next_batch.len();
+
+					batch_revalidate(this.pool.clone(), this.api.clone(), this.best_block, next_batch).await;
+
+					if batch_len > 0 || this.len() > 0 {
+						log::debug!(
+							target: LOG_TARGET,
+							"Revalidated {} transactions. Left in the queue for revalidation: {}.",
+							batch_len,
+							this.len(),
+						);
+					}
+
+					interval_fut.reset(interval);
+				},
+				workload = from_queue.next() => {
+					match workload {
+						Some(worker_payload) => {
+							this.best_block = worker_payload.at;
+							this.push(worker_payload);
+
+							if this.members.len() > 0 {
+								log::debug!(
+									target: LOG_TARGET,
+									"Updated revalidation queue at {:?}. Transactions: {:?}",
+									this.best_block,
+									this.members,
+								);
+							}
+
+							continue;
+						},
+						// R.I.P. worker!
+						None => break,
+					}
+				}
+			}
+		}
+	}
+}
+
+/// Revalidation queue.
+///
+/// Can be configured background (`new_background`)
+/// or immediate (just `new`).
+pub struct RevalidationQueue<Api: ChainApi> {
+	pool: Arc<Pool<Api>>,
+	api: Arc<Api>,
+	background: Option<TracingUnboundedSender<WorkerPayload<Api>>>,
+}
+
+impl<Api: ChainApi> RevalidationQueue<Api>
+where
+	Api: 'static,
+{
+	/// New revalidation queue without background worker.
+	pub fn new(api: Arc<Api>, pool: Arc<Pool<Api>>) -> Self {
+		Self { api, pool, background: None }
+	}
+
+	/// New revalidation queue with background worker.
+	pub fn new_with_interval(
+		api: Arc<Api>,
+		pool: Arc<Pool<Api>>,
+		interval: Duration,
+	) -> (Self, Pin<Box<dyn Future<Output = ()> + Send>>) {
+		let (to_worker, from_queue) = tracing_unbounded("mpsc_revalidation_queue", 100_000);
+
+		let worker = RevalidationWorker::new(api.clone(), pool.clone());
+
+		let queue = Self { api, pool, background: Some(to_worker) };
+
+		(queue, worker.run(from_queue, interval).boxed())
+	}
+
+	/// New revalidation queue with background worker.
+	pub fn new_background(
+		api: Arc<Api>,
+		pool: Arc<Pool<Api>>,
+	) -> (Self, Pin<Box<dyn Future<Output = ()> + Send>>) {
+		Self::new_with_interval(api, pool, BACKGROUND_REVALIDATION_INTERVAL)
+	}
+
+	/// Queue some transaction for later revalidation.
+	///
+	/// If queue configured with background worker, this will return immediately.
+	/// If queue configured without background worker, this will resolve after
+	/// revalidation is actually done.
+	pub async fn revalidate_later(
+		&self,
+		at: NumberFor<Api>,
+		transactions: Vec<ExtrinsicHash<Api>>,
+	) {
+		if transactions.len() > 0 {
+			log::debug!(
+				target: LOG_TARGET,
+				"Sent {} transactions to revalidation queue",
+				transactions.len(),
+			);
+		}
+
+		if let Some(ref to_worker) = self.background {
+			if let Err(e) = to_worker.unbounded_send(WorkerPayload { at, transactions }) {
+				log::warn!(target: LOG_TARGET, "Failed to update background worker: {:?}", e);
+			}
+		} else {
+			let pool = self.pool.clone();
+			let api = self.api.clone();
+			batch_revalidate(pool, api, at, transactions).await
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		graph::Pool,
+		tests::{uxt, TestApi},
+	};
+	use futures::executor::block_on;
+	use sc_transaction_pool_api::TransactionSource;
+	use sp_runtime::generic::BlockId;
+	use substrate_test_runtime::{AccountId, Transfer, H256};
+	use substrate_test_runtime_client::AccountKeyring::Alice;
+
+	#[test]
+	fn revalidation_queue_works() {
+		let api = Arc::new(TestApi::default());
+		let pool = Arc::new(Pool::new(Default::default(), true.into(), api.clone()));
+		let queue = Arc::new(RevalidationQueue::new(api.clone(), pool.clone()));
+
+		let uxt = uxt(Transfer {
+			from: Alice.into(),
+			to: AccountId::from_h256(H256::from_low_u64_be(2)),
+			amount: 5,
+			nonce: 0,
+		});
+		let uxt_hash = block_on(pool.submit_one(
+			&BlockId::number(0),
+			TransactionSource::External,
+			uxt.clone(),
+		))
+		.expect("Should be valid");
+
+		block_on(queue.revalidate_later(0, vec![uxt_hash]));
+
+		// revalidated in sync offload 2nd time
+		assert_eq!(api.validation_requests().len(), 2);
+		// number of ready
+		assert_eq!(pool.validated_pool().status().ready, 1);
+	}
+}
diff --git a/substrate/client/transaction-pool/src/tests.rs b/substrate/client/transaction-pool/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..62911d5cbb471e37f7075d5506d98b60f8f46b83
--- /dev/null
+++ b/substrate/client/transaction-pool/src/tests.rs
@@ -0,0 +1,204 @@
+// 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/>.
+
+//! Testing related primitives for internal usage in this crate.
+
+use crate::graph::{BlockHash, ChainApi, ExtrinsicFor, NumberFor, Pool};
+use codec::Encode;
+use parking_lot::Mutex;
+use sc_transaction_pool_api::error;
+use sp_blockchain::TreeRoute;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Hash},
+	transaction_validity::{
+		InvalidTransaction, TransactionSource, TransactionValidity, ValidTransaction,
+	},
+};
+use std::{collections::HashSet, sync::Arc};
+use substrate_test_runtime::{
+	substrate_test_pallet::pallet::Call as PalletCall, BalancesCall, Block, Extrinsic,
+	ExtrinsicBuilder, Hashing, RuntimeCall, Transfer, TransferData, H256,
+};
+
+pub(crate) const INVALID_NONCE: u64 = 254;
+
+/// Test api that implements [`ChainApi`].
+#[derive(Clone, Debug, Default)]
+pub(crate) struct TestApi {
+	pub delay: Arc<Mutex<Option<std::sync::mpsc::Receiver<()>>>>,
+	pub invalidate: Arc<Mutex<HashSet<H256>>>,
+	pub clear_requirements: Arc<Mutex<HashSet<H256>>>,
+	pub add_requirements: Arc<Mutex<HashSet<H256>>>,
+	pub validation_requests: Arc<Mutex<Vec<Extrinsic>>>,
+}
+
+impl TestApi {
+	/// Query validation requests received.
+	pub fn validation_requests(&self) -> Vec<Extrinsic> {
+		self.validation_requests.lock().clone()
+	}
+}
+
+impl ChainApi for TestApi {
+	type Block = Block;
+	type Error = error::Error;
+	type ValidationFuture = futures::future::Ready<error::Result<TransactionValidity>>;
+	type BodyFuture = futures::future::Ready<error::Result<Option<Vec<Extrinsic>>>>;
+
+	/// Verify extrinsic at given block.
+	fn validate_transaction(
+		&self,
+		at: &BlockId<Self::Block>,
+		_source: TransactionSource,
+		uxt: ExtrinsicFor<Self>,
+	) -> Self::ValidationFuture {
+		self.validation_requests.lock().push(uxt.clone());
+		let hash = self.hash_and_length(&uxt).0;
+		let block_number = self.block_id_to_number(at).unwrap().unwrap();
+
+		let res = match uxt {
+			Extrinsic {
+				function: RuntimeCall::Balances(BalancesCall::transfer_allow_death { .. }),
+				..
+			} => {
+				let TransferData { nonce, .. } = (&uxt).try_into().unwrap();
+				// This is used to control the test flow.
+				if nonce > 0 {
+					let opt = self.delay.lock().take();
+					if let Some(delay) = opt {
+						if delay.recv().is_err() {
+							println!("Error waiting for delay!");
+						}
+					}
+				}
+
+				if self.invalidate.lock().contains(&hash) {
+					InvalidTransaction::Custom(0).into()
+				} else if nonce < block_number {
+					InvalidTransaction::Stale.into()
+				} else {
+					let mut transaction = ValidTransaction {
+						priority: 4,
+						requires: if nonce > block_number {
+							vec![vec![nonce as u8 - 1]]
+						} else {
+							vec![]
+						},
+						provides: if nonce == INVALID_NONCE {
+							vec![]
+						} else {
+							vec![vec![nonce as u8]]
+						},
+						longevity: 3,
+						propagate: true,
+					};
+
+					if self.clear_requirements.lock().contains(&hash) {
+						transaction.requires.clear();
+					}
+
+					if self.add_requirements.lock().contains(&hash) {
+						transaction.requires.push(vec![128]);
+					}
+
+					Ok(transaction)
+				}
+			},
+			Extrinsic {
+				function: RuntimeCall::SubstrateTest(PalletCall::include_data { .. }),
+				..
+			} => Ok(ValidTransaction {
+				priority: 9001,
+				requires: vec![],
+				provides: vec![vec![42]],
+				longevity: 9001,
+				propagate: false,
+			}),
+			Extrinsic {
+				function: RuntimeCall::SubstrateTest(PalletCall::indexed_call { .. }),
+				..
+			} => Ok(ValidTransaction {
+				priority: 9001,
+				requires: vec![],
+				provides: vec![vec![43]],
+				longevity: 9001,
+				propagate: false,
+			}),
+			_ => unimplemented!(),
+		};
+
+		futures::future::ready(Ok(res))
+	}
+
+	/// Returns a block number given the block id.
+	fn block_id_to_number(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<NumberFor<Self>>, Self::Error> {
+		Ok(match at {
+			BlockId::Number(num) => Some(*num),
+			BlockId::Hash(_) => None,
+		})
+	}
+
+	/// Returns a block hash given the block id.
+	fn block_id_to_hash(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<<Self::Block as BlockT>::Hash>, Self::Error> {
+		Ok(match at {
+			BlockId::Number(num) => Some(H256::from_low_u64_be(*num)).into(),
+			BlockId::Hash(_) => None,
+		})
+	}
+
+	/// Hash the extrinsic.
+	fn hash_and_length(&self, uxt: &ExtrinsicFor<Self>) -> (BlockHash<Self>, usize) {
+		let encoded = uxt.encode();
+		let len = encoded.len();
+		(Hashing::hash(&encoded), len)
+	}
+
+	fn block_body(&self, _id: <Self::Block as BlockT>::Hash) -> Self::BodyFuture {
+		futures::future::ready(Ok(None))
+	}
+
+	fn block_header(
+		&self,
+		_: <Self::Block as BlockT>::Hash,
+	) -> Result<Option<<Self::Block as BlockT>::Header>, Self::Error> {
+		Ok(None)
+	}
+
+	fn tree_route(
+		&self,
+		_from: <Self::Block as BlockT>::Hash,
+		_to: <Self::Block as BlockT>::Hash,
+	) -> Result<TreeRoute<Self::Block>, Self::Error> {
+		unimplemented!()
+	}
+}
+
+pub(crate) fn uxt(transfer: Transfer) -> Extrinsic {
+	ExtrinsicBuilder::new_transfer(transfer).build()
+}
+
+pub(crate) fn pool() -> Pool<TestApi> {
+	Pool::new(Default::default(), true.into(), TestApi::default().into())
+}
diff --git a/substrate/client/transaction-pool/tests/pool.rs b/substrate/client/transaction-pool/tests/pool.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4adf811b42521c165bcb777f45cc43e674940146
--- /dev/null
+++ b/substrate/client/transaction-pool/tests/pool.rs
@@ -0,0 +1,1569 @@
+// 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/>.
+
+//! Tests for top-level transaction pool api
+
+use codec::Encode;
+use futures::{
+	executor::{block_on, block_on_stream},
+	prelude::*,
+	task::Poll,
+};
+use sc_block_builder::BlockBuilderProvider;
+use sc_client_api::client::BlockchainEvents;
+use sc_transaction_pool::*;
+use sc_transaction_pool_api::{
+	ChainEvent, MaintainedTransactionPool, TransactionPool, TransactionStatus,
+};
+use sp_blockchain::HeaderBackend;
+use sp_consensus::BlockOrigin;
+use sp_runtime::{
+	generic::BlockId,
+	traits::Block as _,
+	transaction_validity::{TransactionSource, ValidTransaction},
+};
+use std::{collections::BTreeSet, pin::Pin, sync::Arc};
+use substrate_test_runtime_client::{
+	runtime::{Block, Extrinsic, ExtrinsicBuilder, Hash, Header, Nonce, Transfer, TransferData},
+	AccountKeyring::*,
+	ClientBlockImportExt,
+};
+use substrate_test_runtime_transaction_pool::{uxt, TestApi};
+
+const LOG_TARGET: &str = "txpool";
+
+fn pool() -> Pool<TestApi> {
+	Pool::new(Default::default(), true.into(), TestApi::with_alice_nonce(209).into())
+}
+
+fn maintained_pool() -> (BasicPool<TestApi, Block>, Arc<TestApi>, futures::executor::ThreadPool) {
+	let api = Arc::new(TestApi::with_alice_nonce(209));
+	let (pool, background_task) = create_basic_pool_with_genesis(api.clone());
+
+	let thread_pool = futures::executor::ThreadPool::new().unwrap();
+	thread_pool.spawn_ok(background_task);
+	(pool, api, thread_pool)
+}
+
+fn create_basic_pool_with_genesis(
+	test_api: Arc<TestApi>,
+) -> (BasicPool<TestApi, Block>, Pin<Box<dyn Future<Output = ()> + Send>>) {
+	let genesis_hash = {
+		test_api
+			.chain()
+			.read()
+			.block_by_number
+			.get(&0)
+			.map(|blocks| blocks[0].0.header.hash())
+			.expect("there is block 0. qed")
+	};
+	BasicPool::new_test(test_api, genesis_hash, genesis_hash)
+}
+
+fn create_basic_pool(test_api: TestApi) -> BasicPool<TestApi, Block> {
+	create_basic_pool_with_genesis(Arc::from(test_api)).0
+}
+
+const SOURCE: TransactionSource = TransactionSource::External;
+
+#[test]
+fn submission_should_work() {
+	let pool = pool();
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 209))).unwrap();
+
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, vec![209]);
+}
+
+#[test]
+fn multiple_submission_should_work() {
+	let pool = pool();
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 209))).unwrap();
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 210))).unwrap();
+
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, vec![209, 210]);
+}
+
+#[test]
+fn early_nonce_should_be_culled() {
+	sp_tracing::try_init_simple();
+	let pool = pool();
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 208))).unwrap();
+
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, Vec::<Nonce>::new());
+}
+
+#[test]
+fn late_nonce_should_be_queued() {
+	let pool = pool();
+
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 210))).unwrap();
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, Vec::<Nonce>::new());
+
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 209))).unwrap();
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, vec![209, 210]);
+}
+
+#[test]
+fn prune_tags_should_work() {
+	let pool = pool();
+	let hash209 = block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 209))).unwrap();
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt(Alice, 210))).unwrap();
+
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, vec![209, 210]);
+
+	pool.validated_pool().api().push_block(1, Vec::new(), true);
+	block_on(pool.prune_tags(&BlockId::number(1), vec![vec![209]], vec![hash209]))
+		.expect("Prune tags");
+
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, vec![210]);
+}
+
+#[test]
+fn should_ban_invalid_transactions() {
+	let pool = pool();
+	let uxt = uxt(Alice, 209);
+	let hash = block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt.clone())).unwrap();
+	pool.validated_pool().remove_invalid(&[hash]);
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt.clone())).unwrap_err();
+
+	// when
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, Vec::<Nonce>::new());
+
+	// then
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, uxt.clone())).unwrap_err();
+}
+
+#[test]
+fn only_prune_on_new_best() {
+	let (pool, api, _) = maintained_pool();
+	let uxt = uxt(Alice, 209);
+
+	let _ = block_on(pool.submit_and_watch(&BlockId::number(0), SOURCE, uxt.clone()))
+		.expect("1. Imported");
+	pool.api().push_block(1, vec![uxt.clone()], true);
+	assert_eq!(pool.status().ready, 1);
+
+	let header = api.push_block(2, vec![uxt], true);
+	let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+	block_on(pool.maintain(event));
+	assert_eq!(pool.status().ready, 0);
+}
+
+#[test]
+fn should_correctly_prune_transactions_providing_more_than_one_tag() {
+	let api = Arc::new(TestApi::with_alice_nonce(209));
+	api.set_valid_modifier(Box::new(|v: &mut ValidTransaction| {
+		v.provides.push(vec![155]);
+	}));
+	let pool = Pool::new(Default::default(), true.into(), api.clone());
+	let xt = uxt(Alice, 209);
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt.clone())).expect("1. Imported");
+	assert_eq!(pool.validated_pool().status().ready, 1);
+
+	// remove the transaction that just got imported.
+	api.increment_nonce(Alice.into());
+	api.push_block(1, Vec::new(), true);
+	block_on(pool.prune_tags(&BlockId::number(1), vec![vec![209]], vec![])).expect("1. Pruned");
+	assert_eq!(pool.validated_pool().status().ready, 0);
+	// it's re-imported to future
+	assert_eq!(pool.validated_pool().status().future, 1);
+
+	// so now let's insert another transaction that also provides the 155
+	api.increment_nonce(Alice.into());
+	api.push_block(2, Vec::new(), true);
+	let xt = uxt(Alice, 211);
+	block_on(pool.submit_one(&BlockId::number(2), SOURCE, xt.clone())).expect("2. Imported");
+	assert_eq!(pool.validated_pool().status().ready, 1);
+	assert_eq!(pool.validated_pool().status().future, 1);
+	let pending: Vec<_> = pool
+		.validated_pool()
+		.ready()
+		.map(|a| TransferData::try_from(&a.data).unwrap().nonce)
+		.collect();
+	assert_eq!(pending, vec![211]);
+
+	// prune it and make sure the pool is empty
+	api.increment_nonce(Alice.into());
+	api.push_block(3, Vec::new(), true);
+	block_on(pool.prune_tags(&BlockId::number(3), vec![vec![155]], vec![])).expect("2. Pruned");
+	assert_eq!(pool.validated_pool().status().ready, 0);
+	assert_eq!(pool.validated_pool().status().future, 2);
+}
+
+fn block_event(header: Header) -> ChainEvent<Block> {
+	ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None }
+}
+
+fn block_event_with_retracted(
+	new_best_block_header: Header,
+	retracted_start: Hash,
+	api: &TestApi,
+) -> ChainEvent<Block> {
+	let tree_route = api
+		.tree_route(retracted_start, new_best_block_header.parent_hash)
+		.expect("Tree route exists");
+
+	ChainEvent::NewBestBlock {
+		hash: new_best_block_header.hash(),
+		tree_route: Some(Arc::new(tree_route)),
+	}
+}
+
+#[test]
+fn should_prune_old_during_maintenance() {
+	let xt = uxt(Alice, 209);
+
+	let (pool, api, _guard) = maintained_pool();
+
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	let header = api.push_block(1, vec![xt.clone()], true);
+
+	block_on(pool.maintain(block_event(header)));
+	assert_eq!(pool.status().ready, 0);
+}
+
+#[test]
+fn should_revalidate_during_maintenance() {
+	let xt1 = uxt(Alice, 209);
+	let xt2 = uxt(Alice, 210);
+
+	let (pool, api, _guard) = maintained_pool();
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt1.clone())).expect("1. Imported");
+	let watcher = block_on(pool.submit_and_watch(&BlockId::number(0), SOURCE, xt2.clone()))
+		.expect("2. Imported");
+	assert_eq!(pool.status().ready, 2);
+	assert_eq!(api.validation_requests().len(), 2);
+
+	let header = api.push_block(1, vec![xt1.clone()], true);
+
+	api.add_invalid(&xt2);
+
+	block_on(pool.maintain(block_event(header)));
+	assert_eq!(pool.status().ready, 1);
+
+	// test that pool revalidated transaction that left ready and not included in the block
+	assert_eq!(
+		futures::executor::block_on_stream(watcher).collect::<Vec<_>>(),
+		vec![TransactionStatus::Ready, TransactionStatus::Invalid],
+	);
+}
+
+#[test]
+fn should_resubmit_from_retracted_during_maintenance() {
+	let xt = uxt(Alice, 209);
+
+	let (pool, api, _guard) = maintained_pool();
+
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	let header = api.push_block(1, vec![], true);
+	let fork_header = api.push_block(1, vec![], true);
+
+	let event = block_event_with_retracted(header, fork_header.hash(), pool.api());
+
+	block_on(pool.maintain(event));
+	assert_eq!(pool.status().ready, 1);
+}
+
+#[test]
+fn should_not_resubmit_from_retracted_during_maintenance_if_tx_is_also_in_enacted() {
+	let xt = uxt(Alice, 209);
+
+	let (pool, api, _guard) = maintained_pool();
+
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	let header = api.push_block(1, vec![xt.clone()], true);
+	let fork_header = api.push_block(1, vec![xt], true);
+
+	let event = block_event_with_retracted(header, fork_header.hash(), pool.api());
+
+	block_on(pool.maintain(event));
+	assert_eq!(pool.status().ready, 0);
+}
+
+#[test]
+fn should_not_retain_invalid_hashes_from_retracted() {
+	let xt = uxt(Alice, 209);
+
+	let (pool, api, _guard) = maintained_pool();
+
+	let watcher = block_on(pool.submit_and_watch(&BlockId::number(0), SOURCE, xt.clone()))
+		.expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	let header = api.push_block(1, vec![], true);
+	let fork_header = api.push_block(1, vec![xt.clone()], true);
+	api.add_invalid(&xt);
+
+	let event = block_event_with_retracted(header, fork_header.hash(), pool.api());
+	block_on(pool.maintain(event));
+
+	assert_eq!(
+		futures::executor::block_on_stream(watcher).collect::<Vec<_>>(),
+		vec![TransactionStatus::Ready, TransactionStatus::Invalid],
+	);
+
+	assert_eq!(pool.status().ready, 0);
+}
+
+#[test]
+fn should_revalidate_across_many_blocks() {
+	let xt1 = uxt(Alice, 209);
+	let xt2 = uxt(Alice, 210);
+	let xt3 = uxt(Alice, 211);
+
+	let (pool, api, _guard) = maintained_pool();
+
+	let watcher1 = block_on(pool.submit_and_watch(&BlockId::number(0), SOURCE, xt1.clone()))
+		.expect("1. Imported");
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt2.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 2);
+
+	let header = api.push_block(1, vec![], true);
+	block_on(pool.maintain(block_event(header)));
+
+	block_on(pool.submit_one(&BlockId::number(1), SOURCE, xt3.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 3);
+
+	let header = api.push_block(2, vec![xt1.clone()], true);
+	let block_hash = header.hash();
+	block_on(pool.maintain(block_event(header.clone())));
+
+	block_on(
+		watcher1
+			.take_while(|s| future::ready(*s != TransactionStatus::InBlock((block_hash, 0))))
+			.collect::<Vec<_>>(),
+	);
+
+	assert_eq!(pool.status().ready, 2);
+}
+
+#[test]
+fn should_push_watchers_during_maintenance() {
+	fn alice_uxt(nonce: u64) -> Extrinsic {
+		uxt(Alice, 209 + nonce)
+	}
+
+	// given
+	let (pool, api, _guard) = maintained_pool();
+
+	let tx0 = alice_uxt(0);
+	let watcher0 =
+		block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, tx0.clone())).unwrap();
+	let tx1 = alice_uxt(1);
+	let watcher1 =
+		block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, tx1.clone())).unwrap();
+	let tx2 = alice_uxt(2);
+	let watcher2 =
+		block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, tx2.clone())).unwrap();
+	let tx3 = alice_uxt(3);
+	let watcher3 =
+		block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, tx3.clone())).unwrap();
+	let tx4 = alice_uxt(4);
+	let watcher4 =
+		block_on(pool.submit_and_watch(&BlockId::Number(0), SOURCE, tx4.clone())).unwrap();
+	assert_eq!(pool.status().ready, 5);
+
+	// when
+	api.add_invalid(&tx3);
+	api.add_invalid(&tx4);
+
+	// clear timer events if any
+	let header = api.push_block(1, vec![], true);
+	block_on(pool.maintain(block_event(header)));
+
+	// then
+	// hash3 is now invalid
+	// hash4 is now invalid
+	assert_eq!(
+		futures::executor::block_on_stream(watcher3).collect::<Vec<_>>(),
+		vec![TransactionStatus::Ready, TransactionStatus::Invalid],
+	);
+	assert_eq!(
+		futures::executor::block_on_stream(watcher4).collect::<Vec<_>>(),
+		vec![TransactionStatus::Ready, TransactionStatus::Invalid],
+	);
+	assert_eq!(pool.status().ready, 3);
+
+	// when
+	let header = api.push_block(2, vec![tx0, tx1, tx2], true);
+	let header_hash = header.hash();
+	block_on(pool.maintain(block_event(header)));
+
+	let event = ChainEvent::Finalized { hash: header_hash, tree_route: Arc::from(vec![]) };
+	block_on(pool.maintain(event));
+
+	// then
+	// events for hash0 are: Ready, InBlock
+	// events for hash1 are: Ready, InBlock
+	// events for hash2 are: Ready, InBlock
+	assert_eq!(
+		futures::executor::block_on_stream(watcher0).collect::<Vec<_>>(),
+		vec![
+			TransactionStatus::Ready,
+			TransactionStatus::InBlock((header_hash, 0)),
+			TransactionStatus::Finalized((header_hash, 0))
+		],
+	);
+	assert_eq!(
+		futures::executor::block_on_stream(watcher1).collect::<Vec<_>>(),
+		vec![
+			TransactionStatus::Ready,
+			TransactionStatus::InBlock((header_hash, 1)),
+			TransactionStatus::Finalized((header_hash, 1))
+		],
+	);
+	assert_eq!(
+		futures::executor::block_on_stream(watcher2).collect::<Vec<_>>(),
+		vec![
+			TransactionStatus::Ready,
+			TransactionStatus::InBlock((header_hash, 2)),
+			TransactionStatus::Finalized((header_hash, 2))
+		],
+	);
+}
+
+#[test]
+fn finalization() {
+	let xt = uxt(Alice, 209);
+	let api = TestApi::with_alice_nonce(209);
+	api.push_block(1, vec![], true);
+	let pool = create_basic_pool(api);
+	let watcher = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, xt.clone()))
+		.expect("1. Imported");
+	pool.api().push_block(2, vec![xt.clone()], true);
+
+	let header = pool.api().chain().read().block_by_number.get(&2).unwrap()[0].0.header().clone();
+	let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+	block_on(pool.maintain(event));
+
+	let event = ChainEvent::Finalized { hash: header.hash(), tree_route: Arc::from(vec![]) };
+	block_on(pool.maintain(event));
+
+	let mut stream = futures::executor::block_on_stream(watcher);
+	assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+	assert_eq!(stream.next(), Some(TransactionStatus::InBlock((header.hash(), 0))));
+	assert_eq!(stream.next(), Some(TransactionStatus::Finalized((header.hash(), 0))));
+	assert_eq!(stream.next(), None);
+}
+
+#[test]
+fn fork_aware_finalization() {
+	sp_tracing::try_init_simple();
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	let a_header = api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+	let mut canon_watchers = vec![];
+
+	let from_alice = uxt(Alice, 1);
+	let from_dave = uxt(Dave, 2);
+	let from_bob = uxt(Bob, 1);
+	let from_charlie = uxt(Charlie, 1);
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Dave.into());
+	pool.api().increment_nonce(Charlie.into());
+	pool.api().increment_nonce(Bob.into());
+
+	let from_dave_watcher;
+	let from_bob_watcher;
+	let b1;
+	let c1;
+	let d1;
+	let c2;
+	let d2;
+
+	block_on(pool.maintain(block_event(a_header)));
+
+	// block B1
+	{
+		let watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_alice.clone()))
+				.expect("1. Imported");
+		let header = pool.api().push_block(2, vec![from_alice.clone()], true);
+		canon_watchers.push((watcher, header.hash()));
+		assert_eq!(pool.status().ready, 1);
+
+		log::trace!(target: LOG_TARGET, ">> B1: {:?} {:?}", header.hash(), header);
+		let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+		b1 = header.hash();
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+		let event = ChainEvent::Finalized { hash: b1, tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	// block C2
+	{
+		let header = pool.api().push_block_with_parent(b1, vec![from_dave.clone()], true);
+		from_dave_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_dave.clone()))
+				.expect("1. Imported");
+		assert_eq!(pool.status().ready, 1);
+		log::trace!(target: LOG_TARGET, ">> C2: {:?} {:?}", header.hash(), header);
+		let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+		c2 = header.hash();
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	// block D2
+	{
+		from_bob_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_bob.clone()))
+				.expect("1. Imported");
+		assert_eq!(pool.status().ready, 1);
+		let header = pool.api().push_block_with_parent(c2, vec![from_bob.clone()], true);
+
+		log::trace!(target: LOG_TARGET, ">> D2: {:?} {:?}", header.hash(), header);
+		let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+		d2 = header.hash();
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	// block C1
+	{
+		let watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_charlie.clone()))
+				.expect("1.Imported");
+		assert_eq!(pool.status().ready, 1);
+		let header = pool.api().push_block_with_parent(b1, vec![from_charlie.clone()], true);
+		log::trace!(target: LOG_TARGET, ">> C1: {:?} {:?}", header.hash(), header);
+		c1 = header.hash();
+		canon_watchers.push((watcher, header.hash()));
+		let event = block_event_with_retracted(header.clone(), d2, pool.api());
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 2);
+
+		let event = ChainEvent::Finalized { hash: header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	// block D1
+	{
+		let xt = uxt(Eve, 0);
+		let w = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, xt.clone()))
+			.expect("1. Imported");
+		assert_eq!(pool.status().ready, 3);
+		let header = pool.api().push_block_with_parent(c1, vec![xt.clone()], true);
+		log::trace!(target: LOG_TARGET, ">> D1: {:?} {:?}", header.hash(), header);
+		d1 = header.hash();
+		canon_watchers.push((w, header.hash()));
+
+		let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 2);
+		let event = ChainEvent::Finalized { hash: d1, tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	let e1;
+
+	// block E1
+	{
+		let header = pool.api().push_block_with_parent(d1, vec![from_dave, from_bob], true);
+		log::trace!(target: LOG_TARGET, ">> E1: {:?} {:?}", header.hash(), header);
+		e1 = header.hash();
+		let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+		block_on(pool.maintain(ChainEvent::Finalized { hash: e1, tree_route: Arc::from(vec![]) }));
+	}
+
+	for (canon_watcher, h) in canon_watchers {
+		let mut stream = futures::executor::block_on_stream(canon_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((h, 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((h, 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_dave_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((c2, 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(c2)));
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((e1, 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((e1, 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_bob_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((d2, 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(d2)));
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		// In block e1 we submitted: [dave, bob] xts in this order.
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((e1, 1))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((e1, 1))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+/// Tests that when pruning and retracing a tx by the same event, we generate
+/// the correct events in the correct order.
+#[test]
+fn prune_and_retract_tx_at_same_time() {
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let from_alice = uxt(Alice, 1);
+	pool.api().increment_nonce(Alice.into());
+
+	let watcher = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_alice.clone()))
+		.expect("1. Imported");
+
+	// Block B1
+	let b1 = {
+		let header = pool.api().push_block(2, vec![from_alice.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+
+		let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+		header.hash()
+	};
+
+	// Block B2
+	let b2 = {
+		let header = pool.api().push_block(2, vec![from_alice.clone()], true);
+		assert_eq!(pool.status().ready, 0);
+
+		let event = block_event_with_retracted(header.clone(), b1, pool.api());
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+
+		let event = ChainEvent::Finalized { hash: header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+
+		header.hash()
+	};
+
+	{
+		let mut stream = futures::executor::block_on_stream(watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b1, 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(b1)));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b2, 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b2, 0))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+/// This test ensures that transactions from a fork are re-submitted if
+/// the forked block is not part of the retracted blocks. This happens as the
+/// retracted block list only contains the route from the old best to the new
+/// best, without any further forks.
+///
+/// Given the following:
+///
+///     -> D0 (old best, tx0)
+///    /
+/// C - -> D1 (tx1)
+///    \
+///     -> D2 (new best)
+///
+/// Retracted will contain `D0`, but we need to re-submit `tx0` and `tx1` as both
+/// blocks are not part of the canonical chain.
+#[test]
+fn resubmit_tx_of_fork_that_is_not_part_of_retracted() {
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let tx0 = uxt(Alice, 1);
+	let tx1 = uxt(Dave, 2);
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Dave.into());
+
+	let d0;
+
+	// Block D0
+	{
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx0.clone()))
+			.expect("1. Imported");
+		let header = pool.api().push_block(2, vec![tx0.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+
+		let event = ChainEvent::NewBestBlock { hash: header.hash(), tree_route: None };
+		d0 = header.hash();
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	// Block D1
+	{
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx1.clone()))
+			.expect("1. Imported");
+		pool.api().push_block(2, vec![tx1.clone()], false);
+		assert_eq!(pool.status().ready, 1);
+	}
+
+	// Block D2
+	{
+		//push new best block
+		let header = pool.api().push_block(2, vec![], true);
+		let event = block_event_with_retracted(header, d0, pool.api());
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 2);
+	}
+}
+
+#[test]
+fn resubmit_from_retracted_fork() {
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let tx0 = uxt(Alice, 1);
+	let tx1 = uxt(Dave, 2);
+	let tx2 = uxt(Bob, 3);
+
+	// Transactions of the fork that will be enacted later
+	let tx3 = uxt(Eve, 1);
+	let tx4 = uxt(Ferdie, 2);
+	let tx5 = uxt(One, 3);
+
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Dave.into());
+	pool.api().increment_nonce(Bob.into());
+	pool.api().increment_nonce(Eve.into());
+	pool.api().increment_nonce(Ferdie.into());
+	pool.api().increment_nonce(One.into());
+
+	// Block D0
+	{
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx0.clone()))
+			.expect("1. Imported");
+		let header = pool.api().push_block(2, vec![tx0.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+
+		block_on(pool.maintain(block_event(header)));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	// Block E0
+	{
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx1.clone()))
+			.expect("1. Imported");
+		let header = pool.api().push_block(3, vec![tx1.clone()], true);
+		block_on(pool.maintain(block_event(header)));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	// Block F0
+	let f0 = {
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx2.clone()))
+			.expect("1. Imported");
+		let header = pool.api().push_block(4, vec![tx2.clone()], true);
+		block_on(pool.maintain(block_event(header.clone())));
+		assert_eq!(pool.status().ready, 0);
+		header.hash()
+	};
+
+	// Block D1
+	let d1 = {
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx3.clone()))
+			.expect("1. Imported");
+		let header = pool.api().push_block(2, vec![tx3.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+		header.hash()
+	};
+
+	// Block E1
+	let e1 = {
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx4.clone()))
+			.expect("1. Imported");
+		let header = pool.api().push_block_with_parent(d1, vec![tx4.clone()], true);
+		assert_eq!(pool.status().ready, 2);
+		header.hash()
+	};
+
+	// Block F1
+	let f1_header = {
+		let _ = block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, tx5.clone()))
+			.expect("1. Imported");
+		let header = pool.api().push_block_with_parent(e1, vec![tx5.clone()], true);
+		// Don't announce the block event to the pool directly, because we will
+		// re-org to this block.
+		assert_eq!(pool.status().ready, 3);
+		header
+	};
+
+	let ready = pool.ready().map(|t| t.data.encode()).collect::<BTreeSet<_>>();
+	let expected_ready = vec![tx3, tx4, tx5].iter().map(Encode::encode).collect::<BTreeSet<_>>();
+	assert_eq!(expected_ready, ready);
+
+	let event = block_event_with_retracted(f1_header, f0, pool.api());
+	block_on(pool.maintain(event));
+
+	assert_eq!(pool.status().ready, 3);
+	let ready = pool.ready().map(|t| t.data.encode()).collect::<BTreeSet<_>>();
+	let expected_ready = vec![tx0, tx1, tx2].iter().map(Encode::encode).collect::<BTreeSet<_>>();
+	assert_eq!(expected_ready, ready);
+}
+
+#[test]
+fn ready_set_should_not_resolve_before_block_update() {
+	let (pool, _api, _guard) = maintained_pool();
+	let xt1 = uxt(Alice, 209);
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt1.clone())).expect("1. Imported");
+
+	assert!(pool.ready_at(1).now_or_never().is_none());
+}
+
+#[test]
+fn ready_set_should_resolve_after_block_update() {
+	let (pool, api, _guard) = maintained_pool();
+	let header = api.push_block(1, vec![], true);
+
+	let xt1 = uxt(Alice, 209);
+
+	block_on(pool.submit_one(&BlockId::number(1), SOURCE, xt1.clone())).expect("1. Imported");
+	block_on(pool.maintain(block_event(header)));
+
+	assert!(pool.ready_at(1).now_or_never().is_some());
+}
+
+#[test]
+fn ready_set_should_eventually_resolve_when_block_update_arrives() {
+	let (pool, api, _guard) = maintained_pool();
+	let header = api.push_block(1, vec![], true);
+
+	let xt1 = uxt(Alice, 209);
+
+	block_on(pool.submit_one(&BlockId::number(1), SOURCE, xt1.clone())).expect("1. Imported");
+
+	let noop_waker = futures::task::noop_waker();
+	let mut context = futures::task::Context::from_waker(&noop_waker);
+
+	let mut ready_set_future = pool.ready_at(1);
+	if ready_set_future.poll_unpin(&mut context).is_ready() {
+		panic!("Ready set should not be ready before block update!");
+	}
+
+	block_on(pool.maintain(block_event(header)));
+
+	match ready_set_future.poll_unpin(&mut context) {
+		Poll::Pending => {
+			panic!("Ready set should become ready after block update!");
+		},
+		Poll::Ready(iterator) => {
+			let data = iterator.collect::<Vec<_>>();
+			assert_eq!(data.len(), 1);
+		},
+	}
+}
+
+#[test]
+fn import_notification_to_pool_maintain_works() {
+	let mut client = Arc::new(substrate_test_runtime_client::new());
+
+	let best_hash = client.info().best_hash;
+	let finalized_hash = client.info().finalized_hash;
+
+	let pool = Arc::new(
+		BasicPool::new_test(
+			Arc::new(FullChainApi::new(
+				client.clone(),
+				None,
+				&sp_core::testing::TaskExecutor::new(),
+			)),
+			best_hash,
+			finalized_hash,
+		)
+		.0,
+	);
+
+	// Prepare the extrisic, push it to the pool and check that it was added.
+	let xt = uxt(Alice, 0);
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	let mut import_stream = block_on_stream(client.import_notification_stream());
+
+	// Build the block with the transaction included
+	let mut block_builder = client.new_block(Default::default()).unwrap();
+	block_builder.push(xt).unwrap();
+	let block = block_builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+	// Get the notification of the block import and maintain the pool with it,
+	// Now, the pool should not contain any transactions.
+	let evt = import_stream.next().expect("Importing a block leads to an event");
+	block_on(pool.maintain(evt.try_into().expect("Imported as new best block")));
+	assert_eq!(pool.status().ready, 0);
+}
+
+// When we prune transactions, we need to make sure that we remove
+#[test]
+fn pruning_a_transaction_should_remove_it_from_best_transaction() {
+	let (pool, api, _guard) = maintained_pool();
+
+	let xt1 = ExtrinsicBuilder::new_include_data(Vec::new()).build();
+
+	block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt1.clone())).expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+	let header = api.push_block(1, vec![xt1.clone()], true);
+
+	// This will prune `xt1`.
+	block_on(pool.maintain(block_event(header)));
+
+	assert_eq!(pool.status().ready, 0);
+}
+
+#[test]
+fn stale_transactions_are_pruned() {
+	sp_tracing::try_init_simple();
+
+	// Our initial transactions
+	let xts = vec![
+		Transfer { from: Alice.into(), to: Bob.into(), nonce: 1, amount: 1 },
+		Transfer { from: Alice.into(), to: Bob.into(), nonce: 2, amount: 1 },
+		Transfer { from: Alice.into(), to: Bob.into(), nonce: 3, amount: 1 },
+	];
+
+	let (pool, api, _guard) = maintained_pool();
+
+	xts.into_iter().for_each(|xt| {
+		block_on(pool.submit_one(&BlockId::number(0), SOURCE, xt.into_unchecked_extrinsic()))
+			.expect("1. Imported");
+	});
+	assert_eq!(pool.status().ready, 0);
+	assert_eq!(pool.status().future, 3);
+
+	// Almost the same as our initial transactions, but with some different `amount`s to make them
+	// generate a different hash
+	let xts = vec![
+		Transfer { from: Alice.into(), to: Bob.into(), nonce: 1, amount: 2 }
+			.into_unchecked_extrinsic(),
+		Transfer { from: Alice.into(), to: Bob.into(), nonce: 2, amount: 2 }
+			.into_unchecked_extrinsic(),
+		Transfer { from: Alice.into(), to: Bob.into(), nonce: 3, amount: 2 }
+			.into_unchecked_extrinsic(),
+	];
+
+	// Import block
+	let header = api.push_block(1, xts, true);
+	block_on(pool.maintain(block_event(header)));
+	// The imported transactions have a different hash and should not evict our initial
+	// transactions.
+	assert_eq!(pool.status().future, 3);
+
+	// Import enough blocks to make our transactions stale
+	for n in 1..66 {
+		let header = api.push_block(n, vec![], true);
+		block_on(pool.maintain(block_event(header)));
+	}
+
+	assert_eq!(pool.status().future, 0);
+	assert_eq!(pool.status().ready, 0);
+}
+
+#[test]
+fn finalized_only_handled_correctly() {
+	sp_tracing::try_init_simple();
+	let xt = uxt(Alice, 209);
+
+	let (pool, api, _guard) = maintained_pool();
+
+	let watcher = block_on(pool.submit_and_watch(&BlockId::number(0), SOURCE, xt.clone()))
+		.expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	let header = api.push_block(1, vec![xt], true);
+
+	let event =
+		ChainEvent::Finalized { hash: header.clone().hash(), tree_route: Arc::from(vec![]) };
+	block_on(pool.maintain(event));
+
+	assert_eq!(pool.status().ready, 0);
+
+	{
+		let mut stream = futures::executor::block_on_stream(watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((header.clone().hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+#[test]
+fn best_block_after_finalized_handled_correctly() {
+	sp_tracing::try_init_simple();
+	let xt = uxt(Alice, 209);
+
+	let (pool, api, _guard) = maintained_pool();
+
+	let watcher = block_on(pool.submit_and_watch(&BlockId::number(0), SOURCE, xt.clone()))
+		.expect("1. Imported");
+	assert_eq!(pool.status().ready, 1);
+
+	let header = api.push_block(1, vec![xt], true);
+
+	let event =
+		ChainEvent::Finalized { hash: header.clone().hash(), tree_route: Arc::from(vec![]) };
+	block_on(pool.maintain(event));
+	block_on(pool.maintain(block_event(header.clone())));
+
+	assert_eq!(pool.status().ready, 0);
+
+	{
+		let mut stream = futures::executor::block_on_stream(watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((header.clone().hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+#[test]
+fn switching_fork_with_finalized_works() {
+	sp_tracing::try_init_simple();
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	let a_header = api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let from_alice = uxt(Alice, 1);
+	let from_bob = uxt(Bob, 2);
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Bob.into());
+
+	let from_alice_watcher;
+	let from_bob_watcher;
+	let b1_header;
+	let b2_header;
+
+	// block B1
+	{
+		from_alice_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_alice.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(a_header.hash(), vec![from_alice.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+		log::trace!(target: LOG_TARGET, ">> B1: {:?} {:?}", header.hash(), header);
+		b1_header = header;
+	}
+
+	// block B2
+	{
+		from_bob_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_bob.clone()))
+				.expect("1. Imported");
+		let header = pool.api().push_block_with_parent(
+			a_header.hash(),
+			vec![from_alice.clone(), from_bob.clone()],
+			true,
+		);
+		assert_eq!(pool.status().ready, 2);
+
+		log::trace!(target: LOG_TARGET, ">> B2: {:?} {:?}", header.hash(), header);
+		b2_header = header;
+	}
+
+	{
+		let event = ChainEvent::NewBestBlock { hash: b1_header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 1);
+	}
+
+	{
+		let event = ChainEvent::Finalized { hash: b2_header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_alice_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b1_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(b1_header.hash())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b2_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b2_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_bob_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b2_header.hash(), 1))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b2_header.hash(), 1))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+#[test]
+fn switching_fork_multiple_times_works() {
+	sp_tracing::try_init_simple();
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	let a_header = api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let from_alice = uxt(Alice, 1);
+	let from_bob = uxt(Bob, 2);
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Bob.into());
+
+	let from_alice_watcher;
+	let from_bob_watcher;
+	let b1_header;
+	let b2_header;
+
+	// block B1
+	{
+		from_alice_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_alice.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(a_header.hash(), vec![from_alice.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+		log::trace!(target: LOG_TARGET, ">> B1: {:?} {:?}", header.hash(), header);
+		b1_header = header;
+	}
+
+	// block B2
+	{
+		from_bob_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_bob.clone()))
+				.expect("1. Imported");
+		let header = pool.api().push_block_with_parent(
+			a_header.hash(),
+			vec![from_alice.clone(), from_bob.clone()],
+			true,
+		);
+		assert_eq!(pool.status().ready, 2);
+
+		log::trace!(target: LOG_TARGET, ">> B2: {:?} {:?}", header.hash(), header);
+		b2_header = header;
+	}
+
+	{
+		// phase-0
+		let event = ChainEvent::NewBestBlock { hash: b1_header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 1);
+	}
+
+	{
+		// phase-1
+		let event = block_event_with_retracted(b2_header.clone(), b1_header.hash(), pool.api());
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	{
+		// phase-2
+		let event = block_event_with_retracted(b1_header.clone(), b2_header.hash(), pool.api());
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 1);
+	}
+
+	{
+		// phase-3
+		let event = ChainEvent::Finalized { hash: b2_header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_alice_watcher);
+		//phase-0
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b1_header.hash(), 0))));
+		//phase-1
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(b1_header.hash())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b2_header.hash(), 0))));
+		//phase-2
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(b2_header.hash())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b1_header.hash(), 0))));
+		//phase-3
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(b1_header.hash())));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b2_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b2_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_bob_watcher);
+		//phase-1
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b2_header.hash(), 1))));
+		//phase-2
+		assert_eq!(stream.next(), Some(TransactionStatus::Retracted(b2_header.hash())));
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		//phase-3
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b2_header.hash(), 1))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b2_header.hash(), 1))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+#[test]
+fn two_blocks_delayed_finalization_works() {
+	sp_tracing::try_init_simple();
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	let a_header = api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let from_alice = uxt(Alice, 1);
+	let from_bob = uxt(Bob, 2);
+	let from_charlie = uxt(Charlie, 3);
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Bob.into());
+	pool.api().increment_nonce(Charlie.into());
+
+	let from_alice_watcher;
+	let from_bob_watcher;
+	let from_charlie_watcher;
+	let b1_header;
+	let c1_header;
+	let d1_header;
+
+	// block B1
+	{
+		from_alice_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_alice.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(a_header.hash(), vec![from_alice.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+
+		log::trace!(target: LOG_TARGET, ">> B1: {:?} {:?}", header.hash(), header);
+		b1_header = header;
+	}
+
+	// block C1
+	{
+		from_bob_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_bob.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(b1_header.hash(), vec![from_bob.clone()], true);
+		assert_eq!(pool.status().ready, 2);
+
+		log::trace!(target: LOG_TARGET, ">> C1: {:?} {:?}", header.hash(), header);
+		c1_header = header;
+	}
+
+	// block D1
+	{
+		from_charlie_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_charlie.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(c1_header.hash(), vec![from_charlie.clone()], true);
+		assert_eq!(pool.status().ready, 3);
+
+		log::trace!(target: LOG_TARGET, ">> D1: {:?} {:?}", header.hash(), header);
+		d1_header = header;
+	}
+
+	{
+		let event = ChainEvent::Finalized { hash: a_header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 3);
+	}
+
+	{
+		let event = ChainEvent::NewBestBlock { hash: d1_header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	{
+		let event = ChainEvent::Finalized {
+			hash: c1_header.hash(),
+			tree_route: Arc::from(vec![b1_header.hash()]),
+		};
+		block_on(pool.maintain(event));
+	}
+
+	// this is to collect events from_charlie_watcher and make sure nothing was retracted
+	{
+		let event = ChainEvent::Finalized { hash: d1_header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_alice_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b1_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b1_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_bob_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((c1_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((c1_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_charlie_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((d1_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((d1_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+#[test]
+fn delayed_finalization_does_not_retract() {
+	sp_tracing::try_init_simple();
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	let a_header = api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let from_alice = uxt(Alice, 1);
+	let from_bob = uxt(Bob, 2);
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Bob.into());
+
+	let from_alice_watcher;
+	let from_bob_watcher;
+	let b1_header;
+	let c1_header;
+
+	// block B1
+	{
+		from_alice_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_alice.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(a_header.hash(), vec![from_alice.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+
+		log::trace!(target: LOG_TARGET, ">> B1: {:?} {:?}", header.hash(), header);
+		b1_header = header;
+	}
+
+	// block C1
+	{
+		from_bob_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_bob.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(b1_header.hash(), vec![from_bob.clone()], true);
+		assert_eq!(pool.status().ready, 2);
+
+		log::trace!(target: LOG_TARGET, ">> C1: {:?} {:?}", header.hash(), header);
+		c1_header = header;
+	}
+
+	{
+		// phase-0
+		let event = ChainEvent::NewBestBlock { hash: b1_header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 1);
+	}
+
+	{
+		// phase-1
+		let event = ChainEvent::NewBestBlock { hash: c1_header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	{
+		// phase-2
+		let event = ChainEvent::Finalized { hash: b1_header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	{
+		// phase-3
+		let event = ChainEvent::Finalized { hash: c1_header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_alice_watcher);
+		//phase-0
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b1_header.hash(), 0))));
+		//phase-2
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b1_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_bob_watcher);
+		//phase-0
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		//phase-1
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((c1_header.hash(), 0))));
+		//phase-3
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((c1_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+}
+
+#[test]
+fn best_block_after_finalization_does_not_retract() {
+	sp_tracing::try_init_simple();
+	let api = TestApi::empty();
+	// starting block A1 (last finalized.)
+	let a_header = api.push_block(1, vec![], true);
+
+	let pool = create_basic_pool(api);
+
+	let from_alice = uxt(Alice, 1);
+	let from_bob = uxt(Bob, 2);
+	pool.api().increment_nonce(Alice.into());
+	pool.api().increment_nonce(Bob.into());
+
+	let from_alice_watcher;
+	let from_bob_watcher;
+	let b1_header;
+	let c1_header;
+
+	// block B1
+	{
+		from_alice_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_alice.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(a_header.hash(), vec![from_alice.clone()], true);
+		assert_eq!(pool.status().ready, 1);
+
+		log::trace!(target: LOG_TARGET, ">> B1: {:?} {:?}", header.hash(), header);
+		b1_header = header;
+	}
+
+	// block C1
+	{
+		from_bob_watcher =
+			block_on(pool.submit_and_watch(&BlockId::number(1), SOURCE, from_bob.clone()))
+				.expect("1. Imported");
+		let header =
+			pool.api()
+				.push_block_with_parent(b1_header.hash(), vec![from_bob.clone()], true);
+		assert_eq!(pool.status().ready, 2);
+
+		log::trace!(target: LOG_TARGET, ">> C1: {:?} {:?}", header.hash(), header);
+		c1_header = header;
+	}
+
+	{
+		let event = ChainEvent::Finalized { hash: a_header.hash(), tree_route: Arc::from(vec![]) };
+		block_on(pool.maintain(event));
+	}
+
+	{
+		let event = ChainEvent::Finalized {
+			hash: c1_header.hash(),
+			tree_route: Arc::from(vec![a_header.hash(), b1_header.hash()]),
+		};
+		block_on(pool.maintain(event));
+		assert_eq!(pool.status().ready, 0);
+	}
+
+	{
+		let event = ChainEvent::NewBestBlock { hash: b1_header.hash(), tree_route: None };
+		block_on(pool.maintain(event));
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_alice_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((b1_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((b1_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+
+	{
+		let mut stream = futures::executor::block_on_stream(from_bob_watcher);
+		assert_eq!(stream.next(), Some(TransactionStatus::Ready));
+		assert_eq!(stream.next(), Some(TransactionStatus::InBlock((c1_header.hash(), 0))));
+		assert_eq!(stream.next(), Some(TransactionStatus::Finalized((c1_header.hash(), 0))));
+		assert_eq!(stream.next(), None);
+	}
+}
diff --git a/substrate/client/utils/Cargo.toml b/substrate/client/utils/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..21b082a35fd6e6752b8881a7428b03a79b46f3a6
--- /dev/null
+++ b/substrate/client/utils/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "sc-utils"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "I/O for Substrate runtimes"
+readme = "README.md"
+
+[dependencies]
+async-channel = "1.8.0"
+futures = "0.3.21"
+futures-timer = "3.0.2"
+lazy_static = "1.4.0"
+log = "0.4"
+parking_lot = "0.12.1"
+prometheus = { version = "0.13.0", default-features = false }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+
+[features]
+default = [ "metered" ]
+metered = []
+
+[dev-dependencies]
+tokio-test = "0.4.2"
diff --git a/substrate/client/utils/README.md b/substrate/client/utils/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d20fe69efc5acbe4a80d384f744243d8dbd319ab
--- /dev/null
+++ b/substrate/client/utils/README.md
@@ -0,0 +1,15 @@
+# Utilities Primitives for Substrate
+
+This crate provides `mpsc::tracing_unbounded` function that returns wrapper types to
+`async_channel::Sender<T>` and `async_channel::Receiver<T>`, which register every
+`send`/`received`/`dropped` action happened on the channel.
+
+Also this wrapper creates and registers a prometheus vector with name `unbounded_channel_len`
+and labels:
+
+| Label        | Description                                   |
+| ------------ | --------------------------------------------- |
+| entity       | Name of channel passed to `tracing_unbounded` |
+| action       | One of `send`/`received`/`dropped`            |
+
+License: Apache-2.0
diff --git a/substrate/client/utils/src/id_sequence.rs b/substrate/client/utils/src/id_sequence.rs
new file mode 100644
index 0000000000000000000000000000000000000000..abb1271c72a0062edfcac00c988ca346735add94
--- /dev/null
+++ b/substrate/client/utils/src/id_sequence.rs
@@ -0,0 +1,54 @@
+// 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/>.
+
+//! Produce opaque sequential IDs.
+
+/// A Sequence of IDs.
+#[derive(Debug, Default)]
+// The `Clone` trait is intentionally not defined on this type.
+pub struct IDSequence {
+	next_id: u64,
+}
+
+/// A Sequential ID.
+///
+/// Its integer value is intentionally not public: it is supposed to be instantiated from within
+/// this module only.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct SeqID(u64);
+
+impl std::fmt::Display for SeqID {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.0)
+	}
+}
+
+impl IDSequence {
+	/// Create a new ID-sequence.
+	pub fn new() -> Self {
+		Default::default()
+	}
+
+	/// Obtain another ID from this sequence.
+	pub fn next_id(&mut self) -> SeqID {
+		let id = SeqID(self.next_id);
+		self.next_id += 1;
+
+		id
+	}
+}
diff --git a/substrate/client/utils/src/lib.rs b/substrate/client/utils/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..017fc76207d27c004dbb78e3c1d7c4eef427659f
--- /dev/null
+++ b/substrate/client/utils/src/lib.rs
@@ -0,0 +1,38 @@
+// 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/>.
+
+//! Utilities Primitives for Substrate
+//!
+//! This crate provides `mpsc::tracing_unbounded` function that returns wrapper types to
+//! `async_channel::Sender<T>` and `async_channel::Receiver<T>`, which register every
+//! `send`/`received`/`dropped` action happened on the channel.
+//!
+//! Also this wrapper creates and registers a prometheus vector with name `unbounded_channel_len`
+//! and labels:
+//!
+//! | Label        | Description                                   |
+//! | ------------ | --------------------------------------------- |
+//! | entity       | Name of channel passed to `tracing_unbounded` |
+//! | action       | One of `send`/`received`/`dropped`            |
+
+pub mod id_sequence;
+pub mod metrics;
+pub mod mpsc;
+pub mod notification;
+pub mod pubsub;
+pub mod status_sinks;
diff --git a/substrate/client/utils/src/metrics.rs b/substrate/client/utils/src/metrics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6bbdbe2e2e59954669c9bee51aafb6f1c25592ac
--- /dev/null
+++ b/substrate/client/utils/src/metrics.rs
@@ -0,0 +1,53 @@
+// 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/>.
+
+//! Metering primitives and globals
+
+use lazy_static::lazy_static;
+use prometheus::{
+	core::{AtomicU64, GenericCounter, GenericGauge},
+	Error as PrometheusError, Registry,
+};
+
+use prometheus::{core::GenericCounterVec, Opts};
+
+lazy_static! {
+	pub static ref TOKIO_THREADS_TOTAL: GenericCounter<AtomicU64> =
+		GenericCounter::new("substrate_tokio_threads_total", "Total number of threads created")
+			.expect("Creating of statics doesn't fail. qed");
+	pub static ref TOKIO_THREADS_ALIVE: GenericGauge<AtomicU64> =
+		GenericGauge::new("substrate_tokio_threads_alive", "Number of threads alive right now")
+			.expect("Creating of statics doesn't fail. qed");
+}
+
+lazy_static! {
+	pub static ref UNBOUNDED_CHANNELS_COUNTER : GenericCounterVec<AtomicU64> = GenericCounterVec::new(
+		Opts::new("substrate_unbounded_channel_len", "Items in each mpsc::unbounded instance"),
+		&["entity", "action"] // 'name of channel, send|received|dropped
+	).expect("Creating of statics doesn't fail. qed");
+
+}
+
+/// Register the statics to report to registry
+pub fn register_globals(registry: &Registry) -> Result<(), PrometheusError> {
+	registry.register(Box::new(TOKIO_THREADS_ALIVE.clone()))?;
+	registry.register(Box::new(TOKIO_THREADS_TOTAL.clone()))?;
+	registry.register(Box::new(UNBOUNDED_CHANNELS_COUNTER.clone()))?;
+
+	Ok(())
+}
diff --git a/substrate/client/utils/src/mpsc.rs b/substrate/client/utils/src/mpsc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..36e44be5e29507d1d3445f9e35f141a7df9a4adb
--- /dev/null
+++ b/substrate/client/utils/src/mpsc.rs
@@ -0,0 +1,205 @@
+// 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/>.
+
+//! Code to meter unbounded channels.
+
+pub use async_channel::{TryRecvError, TrySendError};
+
+use crate::metrics::UNBOUNDED_CHANNELS_COUNTER;
+use async_channel::{Receiver, Sender};
+use futures::{
+	stream::{FusedStream, Stream},
+	task::{Context, Poll},
+};
+use log::error;
+use sp_arithmetic::traits::SaturatedConversion;
+use std::{
+	backtrace::Backtrace,
+	pin::Pin,
+	sync::{
+		atomic::{AtomicBool, Ordering},
+		Arc,
+	},
+};
+
+/// Wrapper Type around [`async_channel::Sender`] that increases the global
+/// measure when a message is added.
+#[derive(Debug)]
+pub struct TracingUnboundedSender<T> {
+	inner: Sender<T>,
+	name: &'static str,
+	queue_size_warning: usize,
+	warning_fired: Arc<AtomicBool>,
+	creation_backtrace: Arc<Backtrace>,
+}
+
+// Strangely, deriving `Clone` requires that `T` is also `Clone`.
+impl<T> Clone for TracingUnboundedSender<T> {
+	fn clone(&self) -> Self {
+		Self {
+			inner: self.inner.clone(),
+			name: self.name,
+			queue_size_warning: self.queue_size_warning,
+			warning_fired: self.warning_fired.clone(),
+			creation_backtrace: self.creation_backtrace.clone(),
+		}
+	}
+}
+
+/// Wrapper Type around [`async_channel::Receiver`] that decreases the global
+/// measure when a message is polled.
+#[derive(Debug)]
+pub struct TracingUnboundedReceiver<T> {
+	inner: Receiver<T>,
+	name: &'static str,
+}
+
+/// Wrapper around [`async_channel::unbounded`] that tracks the in- and outflow via
+/// `UNBOUNDED_CHANNELS_COUNTER` and warns if the message queue grows
+/// above the warning threshold.
+pub fn tracing_unbounded<T>(
+	name: &'static str,
+	queue_size_warning: usize,
+) -> (TracingUnboundedSender<T>, TracingUnboundedReceiver<T>) {
+	let (s, r) = async_channel::unbounded();
+	let sender = TracingUnboundedSender {
+		inner: s,
+		name,
+		queue_size_warning,
+		warning_fired: Arc::new(AtomicBool::new(false)),
+		creation_backtrace: Arc::new(Backtrace::force_capture()),
+	};
+	let receiver = TracingUnboundedReceiver { inner: r, name };
+	(sender, receiver)
+}
+
+impl<T> TracingUnboundedSender<T> {
+	/// Proxy function to [`async_channel::Sender`].
+	pub fn is_closed(&self) -> bool {
+		self.inner.is_closed()
+	}
+
+	/// Proxy function to [`async_channel::Sender`].
+	pub fn close(&self) -> bool {
+		self.inner.close()
+	}
+
+	/// Proxy function to `async_channel::Sender::try_send`.
+	pub fn unbounded_send(&self, msg: T) -> Result<(), TrySendError<T>> {
+		self.inner.try_send(msg).map(|s| {
+			UNBOUNDED_CHANNELS_COUNTER.with_label_values(&[self.name, "send"]).inc();
+
+			if self.inner.len() >= self.queue_size_warning &&
+				self.warning_fired
+					.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+					.is_ok()
+			{
+				error!(
+					"The number of unprocessed messages in channel `{}` exceeded {}.\n\
+					 The channel was created at:\n{}\n
+					 Last message was sent from:\n{}",
+					self.name,
+					self.queue_size_warning,
+					self.creation_backtrace,
+					Backtrace::force_capture(),
+				);
+			}
+
+			s
+		})
+	}
+}
+
+impl<T> TracingUnboundedReceiver<T> {
+	/// Proxy function to [`async_channel::Receiver`].
+	pub fn close(&mut self) -> bool {
+		self.inner.close()
+	}
+
+	/// Proxy function to [`async_channel::Receiver`]
+	/// that discounts the messages taken out.
+	pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
+		self.inner.try_recv().map(|s| {
+			UNBOUNDED_CHANNELS_COUNTER.with_label_values(&[self.name, "received"]).inc();
+			s
+		})
+	}
+}
+
+impl<T> Drop for TracingUnboundedReceiver<T> {
+	fn drop(&mut self) {
+		// Close the channel to prevent any further messages to be sent into the channel
+		self.close();
+		// the number of messages about to be dropped
+		let count = self.inner.len();
+		// discount the messages
+		if count > 0 {
+			UNBOUNDED_CHANNELS_COUNTER
+				.with_label_values(&[self.name, "dropped"])
+				.inc_by(count.saturated_into());
+		}
+		// Drain all the pending messages in the channel since they can never be accessed,
+		// this can be removed once https://github.com/smol-rs/async-channel/issues/23 is
+		// resolved
+		while let Ok(_) = self.inner.try_recv() {}
+	}
+}
+
+impl<T> Unpin for TracingUnboundedReceiver<T> {}
+
+impl<T> Stream for TracingUnboundedReceiver<T> {
+	type Item = T;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<T>> {
+		let s = self.get_mut();
+		match Pin::new(&mut s.inner).poll_next(cx) {
+			Poll::Ready(msg) => {
+				if msg.is_some() {
+					UNBOUNDED_CHANNELS_COUNTER.with_label_values(&[s.name, "received"]).inc();
+				}
+				Poll::Ready(msg)
+			},
+			Poll::Pending => Poll::Pending,
+		}
+	}
+}
+
+impl<T> FusedStream for TracingUnboundedReceiver<T> {
+	fn is_terminated(&self) -> bool {
+		self.inner.is_terminated()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::tracing_unbounded;
+	use async_channel::{self, RecvError, TryRecvError};
+
+	#[test]
+	fn test_tracing_unbounded_receiver_drop() {
+		let (tracing_unbounded_sender, tracing_unbounded_receiver) =
+			tracing_unbounded("test-receiver-drop", 10);
+		let (tx, rx) = async_channel::unbounded::<usize>();
+
+		tracing_unbounded_sender.unbounded_send(tx).unwrap();
+		drop(tracing_unbounded_receiver);
+
+		assert_eq!(rx.try_recv(), Err(TryRecvError::Closed));
+		assert_eq!(rx.recv_blocking(), Err(RecvError));
+	}
+}
diff --git a/substrate/client/utils/src/notification.rs b/substrate/client/utils/src/notification.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dabb85d613cc97e1a95133a5de130b505f5050e4
--- /dev/null
+++ b/substrate/client/utils/src/notification.rs
@@ -0,0 +1,122 @@
+// 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/>.
+
+//! Provides mpsc notification channel that can be instantiated
+//! _after_ it's been shared to the consumer and producers entities.
+//!
+//! Useful when building RPC extensions where, at service definition time, we
+//! don't know whether the specific interface where the RPC extension will be
+//! exposed is safe or not and we want to lazily build the RPC extension
+//! whenever we bind the service to an interface.
+//!
+//! See [`sc-service::builder::RpcExtensionBuilder`] for more details.
+
+use futures::stream::{FusedStream, Stream};
+use std::{
+	pin::Pin,
+	task::{Context, Poll},
+};
+
+use crate::pubsub::{Hub, Receiver};
+
+mod registry;
+use registry::Registry;
+
+#[cfg(test)]
+mod tests;
+
+/// Trait used to define the "tracing key" string used to tag
+/// and identify the mpsc channels.
+pub trait TracingKeyStr {
+	/// Const `str` representing the "tracing key" used to tag and identify
+	/// the mpsc channels owned by the object implemeting this trait.
+	const TRACING_KEY: &'static str;
+}
+
+/// The receiving half of the notifications channel.
+///
+/// The [`NotificationStream`] entity stores the [`Hub`] so it can be
+/// used to add more subscriptions.
+#[derive(Clone)]
+pub struct NotificationStream<Payload, TK: TracingKeyStr> {
+	hub: Hub<Payload, Registry>,
+	_pd: std::marker::PhantomData<TK>,
+}
+
+/// The receiving half of the notifications channel(s).
+#[derive(Debug)]
+pub struct NotificationReceiver<Payload> {
+	receiver: Receiver<Payload, Registry>,
+}
+
+/// The sending half of the notifications channel(s).
+pub struct NotificationSender<Payload> {
+	hub: Hub<Payload, Registry>,
+}
+
+impl<Payload, TK: TracingKeyStr> NotificationStream<Payload, TK> {
+	/// Creates a new pair of receiver and sender of `Payload` notifications.
+	pub fn channel() -> (NotificationSender<Payload>, Self) {
+		let hub = Hub::new(TK::TRACING_KEY);
+		let sender = NotificationSender { hub: hub.clone() };
+		let receiver = NotificationStream { hub, _pd: Default::default() };
+		(sender, receiver)
+	}
+
+	/// Subscribe to a channel through which the generic payload can be received.
+	pub fn subscribe(&self, queue_size_warning: usize) -> NotificationReceiver<Payload> {
+		let receiver = self.hub.subscribe((), queue_size_warning);
+		NotificationReceiver { receiver }
+	}
+}
+
+impl<Payload> NotificationSender<Payload> {
+	/// Send out a notification to all subscribers that a new payload is available for a
+	/// block.
+	pub fn notify<Error>(
+		&self,
+		payload: impl FnOnce() -> Result<Payload, Error>,
+	) -> Result<(), Error>
+	where
+		Payload: Clone,
+	{
+		self.hub.send(payload)
+	}
+}
+
+impl<Payload> Clone for NotificationSender<Payload> {
+	fn clone(&self) -> Self {
+		Self { hub: self.hub.clone() }
+	}
+}
+
+impl<Payload> Unpin for NotificationReceiver<Payload> {}
+
+impl<Payload> Stream for NotificationReceiver<Payload> {
+	type Item = Payload;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Payload>> {
+		Pin::new(&mut self.get_mut().receiver).poll_next(cx)
+	}
+}
+
+impl<Payload> FusedStream for NotificationReceiver<Payload> {
+	fn is_terminated(&self) -> bool {
+		self.receiver.is_terminated()
+	}
+}
diff --git a/substrate/client/utils/src/notification/registry.rs b/substrate/client/utils/src/notification/registry.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f0960ea918bea103ae9325b83a87d4cb9daf589
--- /dev/null
+++ b/substrate/client/utils/src/notification/registry.rs
@@ -0,0 +1,63 @@
+// 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 std::collections::HashSet;
+
+use crate::{
+	id_sequence::SeqID,
+	pubsub::{Dispatch, Subscribe, Unsubscribe},
+};
+
+/// The shared structure to keep track on subscribers.
+#[derive(Debug, Default)]
+pub(super) struct Registry {
+	pub(super) subscribers: HashSet<SeqID>,
+}
+
+impl Subscribe<()> for Registry {
+	fn subscribe(&mut self, _subs_key: (), subs_id: SeqID) {
+		self.subscribers.insert(subs_id);
+	}
+}
+impl Unsubscribe for Registry {
+	fn unsubscribe(&mut self, subs_id: SeqID) {
+		self.subscribers.remove(&subs_id);
+	}
+}
+
+impl<MakePayload, Payload, Error> Dispatch<MakePayload> for Registry
+where
+	MakePayload: FnOnce() -> Result<Payload, Error>,
+	Payload: Clone,
+{
+	type Item = Payload;
+	type Ret = Result<(), Error>;
+
+	fn dispatch<F>(&mut self, make_payload: MakePayload, mut dispatch: F) -> Self::Ret
+	where
+		F: FnMut(&SeqID, Self::Item),
+	{
+		if !self.subscribers.is_empty() {
+			let payload = make_payload()?;
+			for subs_id in &self.subscribers {
+				dispatch(subs_id, payload.clone());
+			}
+		}
+		Ok(())
+	}
+}
diff --git a/substrate/client/utils/src/notification/tests.rs b/substrate/client/utils/src/notification/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1afc2307e7b3037e9faf7c22bc3b8db3f18deb7b
--- /dev/null
+++ b/substrate/client/utils/src/notification/tests.rs
@@ -0,0 +1,52 @@
+// 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::*;
+use futures::StreamExt;
+
+#[derive(Clone)]
+pub struct DummyTracingKey;
+impl TracingKeyStr for DummyTracingKey {
+	const TRACING_KEY: &'static str = "test_notification_stream";
+}
+
+type StringStream = NotificationStream<String, DummyTracingKey>;
+
+#[test]
+fn notification_channel_simple() {
+	let (sender, stream) = StringStream::channel();
+
+	let test_payload = String::from("test payload");
+	let closure_payload = test_payload.clone();
+
+	// Create a future to receive a single notification
+	// from the stream and verify its payload.
+	let future = stream.subscribe(100_000).take(1).for_each(move |payload| {
+		let test_payload = closure_payload.clone();
+		async move {
+			assert_eq!(payload, test_payload);
+		}
+	});
+
+	// Send notification.
+	let r: std::result::Result<(), ()> = sender.notify(|| Ok(test_payload));
+	r.unwrap();
+
+	// Run receiver future.
+	tokio_test::block_on(future);
+}
diff --git a/substrate/client/utils/src/pubsub.rs b/substrate/client/utils/src/pubsub.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5293fa42ed94c94c5f8dd6f65dccbe1079c71d1d
--- /dev/null
+++ b/substrate/client/utils/src/pubsub.rs
@@ -0,0 +1,261 @@
+// 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/>.
+
+//! Provides means to implement a typical Pub/Sub mechanism.
+//!
+//! This module provides a type [`Hub`] which can be used both to subscribe,
+//! and to send the broadcast messages.
+//!
+//! The [`Hub`] type is parametrized by two other types:
+//! - `Message` — the type of a message that shall be delivered to the subscribers;
+//! - `Registry` — implementation of the subscription/dispatch logic.
+//!
+//! A Registry is implemented by defining the following traits:
+//! - [`Subscribe<K>`];
+//! - [`Dispatch<M>`];
+//! - [`Unsubscribe`].
+//!
+//! As a result of subscription `Hub::subscribe` method returns an instance of
+//! [`Receiver<Message,Registry>`]. That can be used as a [`Stream`] to receive the messages.
+//! Upon drop the [`Receiver<Message, Registry>`] shall unregister itself from the `Hub`.
+
+use std::{
+	collections::HashMap,
+	pin::Pin,
+	sync::{Arc, Weak},
+	task::{Context, Poll},
+};
+
+use futures::stream::{FusedStream, Stream};
+// use parking_lot::Mutex;
+use parking_lot::ReentrantMutex;
+use std::cell::RefCell;
+
+use crate::{
+	id_sequence::SeqID,
+	mpsc::{TracingUnboundedReceiver, TracingUnboundedSender},
+};
+
+#[cfg(test)]
+mod tests;
+
+/// Unsubscribe: unregisters a previously created subscription.
+pub trait Unsubscribe {
+	/// Remove all registrations of the subscriber with ID `subs_id`.
+	fn unsubscribe(&mut self, subs_id: SeqID);
+}
+
+/// Subscribe using a key of type `K`
+pub trait Subscribe<K> {
+	/// Register subscriber with the ID `subs_id` as having interest to the key `K`.
+	fn subscribe(&mut self, subs_key: K, subs_id: SeqID);
+}
+
+/// Dispatch a message of type `M`.
+pub trait Dispatch<M> {
+	/// The type of the that shall be sent through the channel as a result of such dispatch.
+	type Item;
+	/// The type returned by the `dispatch`-method.
+	type Ret;
+
+	/// Dispatch the message of type `M`.
+	///
+	/// The implementation is given an instance of `M` and is supposed to invoke `dispatch` for
+	/// each matching subscriber, with an argument of type `Self::Item` matching that subscriber.
+	///
+	/// Note that this does not have to be of the same type with the item that will be sent through
+	/// to the subscribers. The subscribers will receive a message of type `Self::Item`.
+	fn dispatch<F>(&mut self, message: M, dispatch: F) -> Self::Ret
+	where
+		F: FnMut(&SeqID, Self::Item);
+}
+
+/// A subscription hub.
+///
+/// Does the subscription and dispatch.
+/// The exact subscription and routing behaviour is to be implemented by the Registry (of type `R`).
+/// The Hub under the hood uses the channel defined in `crate::mpsc` module.
+#[derive(Debug)]
+pub struct Hub<M, R> {
+	tracing_key: &'static str,
+	shared: Arc<ReentrantMutex<RefCell<Shared<M, R>>>>,
+}
+
+/// The receiving side of the subscription.
+///
+/// The messages are delivered as items of a [`Stream`].
+/// Upon drop this receiver unsubscribes itself from the [`Hub<M, R>`].
+#[derive(Debug)]
+pub struct Receiver<M, R>
+where
+	R: Unsubscribe,
+{
+	rx: TracingUnboundedReceiver<M>,
+
+	shared: Weak<ReentrantMutex<RefCell<Shared<M, R>>>>,
+	subs_id: SeqID,
+}
+
+#[derive(Debug)]
+struct Shared<M, R> {
+	id_sequence: crate::id_sequence::IDSequence,
+	registry: R,
+	sinks: HashMap<SeqID, TracingUnboundedSender<M>>,
+}
+
+impl<M, R> Hub<M, R>
+where
+	R: Unsubscribe,
+{
+	/// Provide access to the registry (for test purposes).
+	pub fn map_registry_for_tests<MapF, Ret>(&self, map: MapF) -> Ret
+	where
+		MapF: FnOnce(&R) -> Ret,
+	{
+		let shared_locked = self.shared.lock();
+		let shared_borrowed = shared_locked.borrow();
+		map(&shared_borrowed.registry)
+	}
+}
+
+impl<M, R> Drop for Receiver<M, R>
+where
+	R: Unsubscribe,
+{
+	fn drop(&mut self) {
+		if let Some(shared) = self.shared.upgrade() {
+			shared.lock().borrow_mut().unsubscribe(self.subs_id);
+		}
+	}
+}
+
+impl<M, R> Hub<M, R> {
+	/// Create a new instance of Hub (with default value for the Registry).
+	pub fn new(tracing_key: &'static str) -> Self
+	where
+		R: Default,
+	{
+		Self::new_with_registry(tracing_key, Default::default())
+	}
+
+	/// Create a new instance of Hub over the initialized Registry.
+	pub fn new_with_registry(tracing_key: &'static str, registry: R) -> Self {
+		let shared =
+			Shared { registry, sinks: Default::default(), id_sequence: Default::default() };
+		let shared = Arc::new(ReentrantMutex::new(RefCell::new(shared)));
+		Self { tracing_key, shared }
+	}
+
+	/// Subscribe to this Hub using the `subs_key: K`.
+	///
+	/// A subscription with a key `K` is possible if the Registry implements `Subscribe<K>`.
+	pub fn subscribe<K>(&self, subs_key: K, queue_size_warning: usize) -> Receiver<M, R>
+	where
+		R: Subscribe<K> + Unsubscribe,
+	{
+		let shared_locked = self.shared.lock();
+		let mut shared_borrowed = shared_locked.borrow_mut();
+
+		let subs_id = shared_borrowed.id_sequence.next_id();
+
+		// The order (registry.subscribe then sinks.insert) is important here:
+		// assuming that `Subscribe<K>::subscribe` can panic, it is better to at least
+		// have the sink disposed.
+		shared_borrowed.registry.subscribe(subs_key, subs_id);
+
+		let (tx, rx) = crate::mpsc::tracing_unbounded(self.tracing_key, queue_size_warning);
+		assert!(shared_borrowed.sinks.insert(subs_id, tx).is_none(), "Used IDSequence to create another ID. Should be unique until u64 is overflowed. Should be unique.");
+
+		Receiver { shared: Arc::downgrade(&self.shared), subs_id, rx }
+	}
+
+	/// Send the message produced with `Trigger`.
+	///
+	/// This is possible if the registry implements `Dispatch<Trigger, Item = M>`.
+	pub fn send<Trigger>(&self, trigger: Trigger) -> <R as Dispatch<Trigger>>::Ret
+	where
+		R: Dispatch<Trigger, Item = M>,
+	{
+		let shared_locked = self.shared.lock();
+		let mut shared_borrowed = shared_locked.borrow_mut();
+		let (registry, sinks) = shared_borrowed.get_mut();
+
+		registry.dispatch(trigger, |subs_id, item| {
+			if let Some(tx) = sinks.get_mut(subs_id) {
+				if let Err(send_err) = tx.unbounded_send(item) {
+					log::warn!("Sink with SubsID = {} failed to perform unbounded_send: {} ({} as Dispatch<{}, Item = {}>::dispatch(...))", subs_id, send_err, std::any::type_name::<R>(),
+					std::any::type_name::<Trigger>(),
+					std::any::type_name::<M>());
+				}
+			} else {
+				log::warn!(
+					"No Sink for SubsID = {} ({} as Dispatch<{}, Item = {}>::dispatch(...))",
+					subs_id,
+					std::any::type_name::<R>(),
+					std::any::type_name::<Trigger>(),
+					std::any::type_name::<M>(),
+				);
+			}
+		})
+	}
+}
+
+impl<M, R> Shared<M, R> {
+	fn get_mut(&mut self) -> (&mut R, &mut HashMap<SeqID, TracingUnboundedSender<M>>) {
+		(&mut self.registry, &mut self.sinks)
+	}
+
+	fn unsubscribe(&mut self, subs_id: SeqID)
+	where
+		R: Unsubscribe,
+	{
+		// The order (sinks.remove then registry.unsubscribe) is important here:
+		// assuming that `Unsubscribe::unsubscribe` can panic, it is better to at least
+		// have the sink disposed.
+		self.sinks.remove(&subs_id);
+		self.registry.unsubscribe(subs_id);
+	}
+}
+
+impl<M, R> Clone for Hub<M, R> {
+	fn clone(&self) -> Self {
+		Self { tracing_key: self.tracing_key, shared: self.shared.clone() }
+	}
+}
+
+impl<M, R> Unpin for Receiver<M, R> where R: Unsubscribe {}
+
+impl<M, R> Stream for Receiver<M, R>
+where
+	R: Unsubscribe,
+{
+	type Item = M;
+
+	fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+		Pin::new(&mut self.get_mut().rx).poll_next(cx)
+	}
+}
+
+impl<Ch, R> FusedStream for Receiver<Ch, R>
+where
+	R: Unsubscribe,
+{
+	fn is_terminated(&self) -> bool {
+		self.rx.is_terminated()
+	}
+}
diff --git a/substrate/client/utils/src/pubsub/tests.rs b/substrate/client/utils/src/pubsub/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d832c7dbd872a06638bb522cafb88292455cb12
--- /dev/null
+++ b/substrate/client/utils/src/pubsub/tests.rs
@@ -0,0 +1,123 @@
+// 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 futures::StreamExt;
+use tokio_test::block_on;
+
+use super::*;
+
+mod normal_operation;
+mod panicking_registry;
+
+const TK: &str = "a_tracing_key";
+
+type Message = u64;
+type TestHub = Hub<Message, Registry>;
+type TestReceiver = Receiver<Message, Registry>;
+
+#[derive(Default)]
+struct Registry {
+	subscribers: HashMap<SeqID, SubsKey>,
+}
+
+struct SubsKey {
+	_receiver: Option<TestReceiver>,
+	panic: SubsKeyPanic,
+}
+
+impl SubsKey {
+	fn new() -> Self {
+		Self { _receiver: None, panic: SubsKeyPanic::None }
+	}
+	fn with_receiver(self, receiver: TestReceiver) -> Self {
+		Self { _receiver: Some(receiver), ..self }
+	}
+	fn with_panic(self, panic: SubsKeyPanic) -> Self {
+		Self { panic, ..self }
+	}
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SubsKeyPanic {
+	None,
+
+	OnSubscribePanicBefore,
+	OnSubscribePanicAfter,
+
+	OnUnsubscribePanicBefore,
+	OnUnsubscribePanicAfter,
+
+	OnDispatchPanicBefore,
+	OnDispatchPanicAfter,
+}
+
+impl<M> Hub<M, Registry> {
+	fn subs_count(&self) -> usize {
+		self.map_registry_for_tests(|r| r.subscribers.len())
+	}
+	fn sink_count(&self) -> usize {
+		self.shared.lock().borrow().sinks.len()
+	}
+}
+
+impl Subscribe<SubsKey> for Registry {
+	fn subscribe(&mut self, subs_key: SubsKey, subs_id: SeqID) {
+		let sk_panic = subs_key.panic;
+
+		if sk_panic == SubsKeyPanic::OnSubscribePanicBefore {
+			panic!("on-subscribe-panic-before")
+		}
+		self.subscribers.insert(subs_id, subs_key);
+		if sk_panic == SubsKeyPanic::OnSubscribePanicAfter {
+			panic!("on-subscribe-panic-after")
+		}
+	}
+}
+impl Unsubscribe for Registry {
+	fn unsubscribe(&mut self, subs_id: SeqID) {
+		let sk_panic =
+			self.subscribers.get(&subs_id).map(|sk| sk.panic).unwrap_or(SubsKeyPanic::None);
+
+		if sk_panic == SubsKeyPanic::OnUnsubscribePanicBefore {
+			panic!("on-unsubscribe-panic-before")
+		}
+		self.subscribers.remove(&subs_id);
+		if sk_panic == SubsKeyPanic::OnUnsubscribePanicAfter {
+			panic!("on-unsubscribe-panic-after")
+		}
+	}
+}
+impl Dispatch<Message> for Registry {
+	type Item = Message;
+	type Ret = ();
+
+	fn dispatch<F>(&mut self, message: Message, mut dispatch: F) -> Self::Ret
+	where
+		F: FnMut(&SeqID, Self::Item),
+	{
+		self.subscribers.iter().for_each(|(id, subs_key)| {
+			if subs_key.panic == SubsKeyPanic::OnDispatchPanicBefore {
+				panic!("on-dispatch-panic-before")
+			}
+			dispatch(id, message);
+			if subs_key.panic == SubsKeyPanic::OnDispatchPanicAfter {
+				panic!("on-dispatch-panic-after")
+			}
+		});
+	}
+}
diff --git a/substrate/client/utils/src/pubsub/tests/normal_operation.rs b/substrate/client/utils/src/pubsub/tests/normal_operation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a3ea4f7ddee695e5badba93cec8da10da98bf351
--- /dev/null
+++ b/substrate/client/utils/src/pubsub/tests/normal_operation.rs
@@ -0,0 +1,87 @@
+// 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::*;
+
+#[test]
+fn positive_rx_receives_relevant_messages_and_terminates_upon_hub_drop() {
+	block_on(async {
+		let hub = TestHub::new(TK);
+		assert_eq!(hub.subs_count(), 0);
+
+		// No subscribers yet. That message is not supposed to get to anyone.
+		hub.send(0);
+
+		let mut rx_01 = hub.subscribe(SubsKey::new(), 100_000);
+		assert_eq!(hub.subs_count(), 1);
+
+		// That message is sent after subscription. Should be delivered into rx_01.
+		hub.send(1);
+		assert_eq!(Some(1), rx_01.next().await);
+
+		// Hub is disposed. The rx_01 should be over after that.
+		std::mem::drop(hub);
+
+		assert!(rx_01.is_terminated());
+		assert_eq!(None, rx_01.next().await);
+	});
+}
+
+#[test]
+fn positive_subs_count_is_correct_upon_drop_of_rxs() {
+	block_on(async {
+		let hub = TestHub::new(TK);
+		assert_eq!(hub.subs_count(), 0);
+
+		let rx_01 = hub.subscribe(SubsKey::new(), 100_000);
+		assert_eq!(hub.subs_count(), 1);
+		let rx_02 = hub.subscribe(SubsKey::new(), 100_000);
+		assert_eq!(hub.subs_count(), 2);
+
+		std::mem::drop(rx_01);
+		assert_eq!(hub.subs_count(), 1);
+		std::mem::drop(rx_02);
+		assert_eq!(hub.subs_count(), 0);
+	});
+}
+
+#[test]
+fn positive_subs_count_is_correct_upon_drop_of_rxs_on_cloned_hubs() {
+	block_on(async {
+		let hub_01 = TestHub::new(TK);
+		let hub_02 = hub_01.clone();
+		assert_eq!(hub_01.subs_count(), 0);
+		assert_eq!(hub_02.subs_count(), 0);
+
+		let rx_01 = hub_02.subscribe(SubsKey::new(), 100_000);
+		assert_eq!(hub_01.subs_count(), 1);
+		assert_eq!(hub_02.subs_count(), 1);
+
+		let rx_02 = hub_02.subscribe(SubsKey::new(), 100_000);
+		assert_eq!(hub_01.subs_count(), 2);
+		assert_eq!(hub_02.subs_count(), 2);
+
+		std::mem::drop(rx_01);
+		assert_eq!(hub_01.subs_count(), 1);
+		assert_eq!(hub_02.subs_count(), 1);
+
+		std::mem::drop(rx_02);
+		assert_eq!(hub_01.subs_count(), 0);
+		assert_eq!(hub_02.subs_count(), 0);
+	});
+}
diff --git a/substrate/client/utils/src/pubsub/tests/panicking_registry.rs b/substrate/client/utils/src/pubsub/tests/panicking_registry.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9f7579e79f479e5ff58bc322ad220ae8f877e7bd
--- /dev/null
+++ b/substrate/client/utils/src/pubsub/tests/panicking_registry.rs
@@ -0,0 +1,249 @@
+// 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::*;
+
+use std::panic::{catch_unwind, AssertUnwindSafe};
+
+fn assert_hub_props(hub: &TestHub, sinks_count: usize, subs_count: usize) {
+	assert_eq!(hub.sink_count(), sinks_count);
+	assert_eq!(hub.subs_count(), subs_count);
+}
+
+#[test]
+fn t01() {
+	let hub = TestHub::new(TK);
+	assert_hub_props(&hub, 0, 0);
+
+	let rx_01 = hub.subscribe(SubsKey::new(), 100_000);
+	assert_hub_props(&hub, 1, 1);
+
+	std::mem::drop(rx_01);
+	assert_hub_props(&hub, 0, 0);
+}
+
+#[test]
+fn t02() {
+	block_on(async {
+		// Create a Hub
+		let hub = TestHub::new(TK);
+		assert_hub_props(&hub, 0, 0);
+
+		// Subscribe rx-01
+		let rx_01 = hub.subscribe(SubsKey::new(), 100_000);
+		assert_hub_props(&hub, 1, 1);
+
+		// Subscribe rx-02 so that its unsubscription will lead to an attempt to drop rx-01 in the
+		// middle of unsubscription of rx-02
+		let rx_02 = hub.subscribe(SubsKey::new().with_receiver(rx_01), 100_000);
+		assert_hub_props(&hub, 2, 2);
+
+		// Subscribe rx-03 in order to see that it will receive messages after the unclean
+		// unsubscription
+		let mut rx_03 = hub.subscribe(SubsKey::new(), 100_000);
+		assert_hub_props(&hub, 3, 3);
+
+		// drop rx-02 leads to an attempt to unsubscribe rx-01
+		assert!(catch_unwind(AssertUnwindSafe(move || {
+			std::mem::drop(rx_02);
+		}))
+		.is_err());
+
+		// One of the rxes could not unsubscribe
+		assert_hub_props(&hub, 2, 2);
+
+		// Subscribe rx-04 in order to see that it will receive messages after the unclean
+		// unsubscription
+		let mut rx_04 = hub.subscribe(SubsKey::new(), 100_000);
+		assert_hub_props(&hub, 3, 3);
+
+		hub.send(2);
+
+		// The messages are still received
+		assert_eq!(rx_03.next().await, Some(2));
+		assert_eq!(rx_04.next().await, Some(2));
+
+		// Perform a clean unsubscription
+		std::mem::drop(rx_04);
+
+		hub.send(3);
+
+		// The messages are still received
+		assert_eq!(rx_03.next().await, Some(3));
+
+		std::mem::drop(rx_03);
+
+		hub.send(4);
+
+		// The stuck subscription is still there
+		assert_hub_props(&hub, 1, 1);
+	});
+}
+
+async fn add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(hub: &TestHub) {
+	let rx_01 = hub.subscribe(SubsKey::new(), 100_000);
+	let rx_02 = hub.subscribe(SubsKey::new(), 100_000);
+
+	hub.send(1);
+	hub.send(2);
+	hub.send(3);
+
+	assert_eq!(rx_01.take(3).collect::<Vec<_>>().await, vec![1, 2, 3]);
+
+	hub.send(4);
+	hub.send(5);
+	hub.send(6);
+
+	assert_eq!(rx_02.take(6).collect::<Vec<_>>().await, vec![1, 2, 3, 4, 5, 6]);
+}
+
+#[test]
+fn t03() {
+	block_on(async {
+		// Create a Hub
+		let hub = TestHub::new(TK);
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+
+		assert!(catch_unwind(AssertUnwindSafe(|| hub
+			.subscribe(SubsKey::new().with_panic(SubsKeyPanic::OnSubscribePanicBefore), 100_000)))
+		.is_err());
+
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+	});
+}
+
+#[test]
+fn t04() {
+	block_on(async {
+		let hub = TestHub::new(TK);
+
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+
+		assert!(catch_unwind(AssertUnwindSafe(|| hub
+			.subscribe(SubsKey::new().with_panic(SubsKeyPanic::OnSubscribePanicAfter), 100_000)))
+		.is_err());
+
+		// the registry has panicked after it has added a subs-id into its internal storage — the
+		// sinks do not leak, although the subscriptions storage contains some garbage
+		assert_hub_props(&hub, 0, 1);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 1);
+	})
+}
+
+#[test]
+fn t05() {
+	block_on(async {
+		let hub = TestHub::new(TK);
+
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+
+		let rx_01 = hub
+			.subscribe(SubsKey::new().with_panic(SubsKeyPanic::OnUnsubscribePanicBefore), 100_000);
+
+		assert_hub_props(&hub, 1, 1);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 1, 1);
+
+		assert!(catch_unwind(AssertUnwindSafe(move || std::mem::drop(rx_01))).is_err());
+
+		// the registry has panicked on-unsubscribe before it removed the subs-id from its internal
+		// storage — the sinks do not leak, although the subscriptions storage contains some garbage
+		assert_hub_props(&hub, 0, 1);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 1);
+	})
+}
+
+#[test]
+fn t06() {
+	block_on(async {
+		let hub = TestHub::new(TK);
+
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+
+		let rx_01 = hub
+			.subscribe(SubsKey::new().with_panic(SubsKeyPanic::OnUnsubscribePanicAfter), 100_000);
+
+		assert_hub_props(&hub, 1, 1);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 1, 1);
+
+		assert!(catch_unwind(AssertUnwindSafe(move || std::mem::drop(rx_01))).is_err());
+
+		// the registry has panicked on-unsubscribe after it removed the subs-id from its internal
+		// storage — the sinks do not leak, the subscriptions storage does not contain any garbage
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+	})
+}
+
+#[test]
+fn t07() {
+	block_on(async {
+		let hub = TestHub::new(TK);
+
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+
+		let rx_01 =
+			hub.subscribe(SubsKey::new().with_panic(SubsKeyPanic::OnDispatchPanicBefore), 100_000);
+		assert_hub_props(&hub, 1, 1);
+		assert!(catch_unwind(AssertUnwindSafe(|| hub.send(1))).is_err());
+		assert_hub_props(&hub, 1, 1);
+
+		std::mem::drop(rx_01);
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+	})
+}
+
+#[test]
+fn t08() {
+	block_on(async {
+		let hub = TestHub::new(TK);
+
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+
+		let rx_01 =
+			hub.subscribe(SubsKey::new().with_panic(SubsKeyPanic::OnDispatchPanicAfter), 100_000);
+		assert_hub_props(&hub, 1, 1);
+		assert!(catch_unwind(AssertUnwindSafe(|| hub.send(1))).is_err());
+		assert_hub_props(&hub, 1, 1);
+
+		std::mem::drop(rx_01);
+		assert_hub_props(&hub, 0, 0);
+		add_some_subscribers_see_that_messages_are_delivered_and_unsubscribe(&hub).await;
+		assert_hub_props(&hub, 0, 0);
+	})
+}
diff --git a/substrate/client/utils/src/status_sinks.rs b/substrate/client/utils/src/status_sinks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51d78aa4977520dc367fd69d07bb0680ce4946c7
--- /dev/null
+++ b/substrate/client/utils/src/status_sinks.rs
@@ -0,0 +1,218 @@
+// 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::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
+use futures::{lock::Mutex, prelude::*};
+use futures_timer::Delay;
+use std::{
+	pin::Pin,
+	task::{Context, Poll},
+	time::Duration,
+};
+
+/// Holds a list of `UnboundedSender`s, each associated with a certain time period. Every time the
+/// period elapses, we push an element on the sender.
+///
+/// Senders are removed only when they are closed.
+pub struct StatusSinks<T> {
+	/// Should only be locked by `next`.
+	inner: Mutex<Inner<T>>,
+	/// Sending side of `Inner::entries_rx`.
+	entries_tx: TracingUnboundedSender<YieldAfter<T>>,
+}
+
+struct Inner<T> {
+	/// The actual entries of the list.
+	entries: stream::FuturesUnordered<YieldAfter<T>>,
+	/// Receives new entries and puts them in `entries`.
+	entries_rx: TracingUnboundedReceiver<YieldAfter<T>>,
+}
+
+struct YieldAfter<T> {
+	delay: Delay,
+	interval: Duration,
+	sender: Option<TracingUnboundedSender<T>>,
+}
+
+impl<T> Default for StatusSinks<T> {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+impl<T> StatusSinks<T> {
+	/// Builds a new empty collection.
+	pub fn new() -> StatusSinks<T> {
+		let (entries_tx, entries_rx) = tracing_unbounded("status-sinks-entries", 100_000);
+
+		StatusSinks {
+			inner: Mutex::new(Inner { entries: stream::FuturesUnordered::new(), entries_rx }),
+			entries_tx,
+		}
+	}
+
+	/// Adds a sender to the collection.
+	///
+	/// The `interval` is the time period between two pushes on the sender.
+	pub fn push(&self, interval: Duration, sender: TracingUnboundedSender<T>) {
+		let _ = self.entries_tx.unbounded_send(YieldAfter {
+			delay: Delay::new(interval),
+			interval,
+			sender: Some(sender),
+		});
+	}
+
+	/// Waits until one of the sinks is ready, then returns an object that can be used to send
+	/// an element on said sink.
+	///
+	/// If the object isn't used to send an element, the slot is skipped.
+	pub async fn next(&self) -> ReadySinkEvent<'_, T> {
+		// This is only ever locked by `next`, which means that one `next` at a time can run.
+		let mut inner = self.inner.lock().await;
+		let inner = &mut *inner;
+
+		loop {
+			// Future that produces the next ready entry in `entries`, or doesn't produce anything
+			// if the list is empty.
+			let next_ready_entry = {
+				let entries = &mut inner.entries;
+				async move {
+					if let Some(v) = entries.next().await {
+						v
+					} else {
+						loop {
+							futures::pending!()
+						}
+					}
+				}
+			};
+
+			futures::select! {
+				new_entry = inner.entries_rx.next() => {
+					if let Some(new_entry) = new_entry {
+						inner.entries.push(new_entry);
+					}
+				},
+				(sender, interval) = next_ready_entry.fuse() => {
+					return ReadySinkEvent {
+						sinks: self,
+						sender: Some(sender),
+						interval,
+					}
+				}
+			}
+		}
+	}
+}
+
+/// One of the sinks is ready.
+#[must_use]
+pub struct ReadySinkEvent<'a, T> {
+	sinks: &'a StatusSinks<T>,
+	sender: Option<TracingUnboundedSender<T>>,
+	interval: Duration,
+}
+
+impl<'a, T> ReadySinkEvent<'a, T> {
+	/// Sends an element on the sender.
+	pub fn send(mut self, element: T) {
+		if let Some(sender) = self.sender.take() {
+			if sender.unbounded_send(element).is_ok() {
+				let _ = self.sinks.entries_tx.unbounded_send(YieldAfter {
+					// Note that since there's a small delay between the moment a task is
+					// woken up and the moment it is polled, the period is actually not
+					// `interval` but `interval + <delay>`. We ignore this problem in
+					// practice.
+					delay: Delay::new(self.interval),
+					interval: self.interval,
+					sender: Some(sender),
+				});
+			}
+		}
+	}
+}
+
+impl<'a, T> Drop for ReadySinkEvent<'a, T> {
+	fn drop(&mut self) {
+		if let Some(sender) = self.sender.take() {
+			if sender.is_closed() {
+				return
+			}
+
+			let _ = self.sinks.entries_tx.unbounded_send(YieldAfter {
+				delay: Delay::new(self.interval),
+				interval: self.interval,
+				sender: Some(sender),
+			});
+		}
+	}
+}
+
+impl<T> futures::Future for YieldAfter<T> {
+	type Output = (TracingUnboundedSender<T>, Duration);
+
+	fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+		let this = Pin::into_inner(self);
+
+		match Pin::new(&mut this.delay).poll(cx) {
+			Poll::Pending => Poll::Pending,
+			Poll::Ready(()) => {
+				let sender = this
+					.sender
+					.take()
+					.expect("sender is always Some unless the future is finished; qed");
+				Poll::Ready((sender, this.interval))
+			},
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::StatusSinks;
+	use crate::mpsc::tracing_unbounded;
+	use futures::prelude::*;
+	use std::time::Duration;
+
+	#[test]
+	fn works() {
+		// We're not testing that the `StatusSink` properly enforces an order in the intervals, as
+		// this easily causes test failures on busy CPUs.
+
+		let status_sinks = StatusSinks::new();
+
+		let (tx, rx) = tracing_unbounded("test", 100_000);
+		status_sinks.push(Duration::from_millis(100), tx);
+
+		let mut val_order = 5;
+
+		futures::executor::block_on(futures::future::select(
+			Box::pin(async move {
+				loop {
+					let ev = status_sinks.next().await;
+					val_order += 1;
+					ev.send(val_order);
+				}
+			}),
+			Box::pin(async {
+				let items: Vec<i32> = rx.take(3).collect().await;
+				assert_eq!(items, [6, 7, 8]);
+			}),
+		));
+	}
+}
diff --git a/substrate/docker/README.md b/substrate/docker/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..71ddb2dffd1bbe575f67d71e51db728a920ab265
--- /dev/null
+++ b/substrate/docker/README.md
@@ -0,0 +1,53 @@
+# Substrate Builder Docker Image
+
+The Docker image in this folder is a `builder` image. It is self contained and allows users to build the binaries themselves.
+There is no requirement on having Rust or any other toolchain installed but a working Docker environment.
+
+Unlike the `parity/polkadot` image which contains a single binary (`polkadot`!) used by default, the image in this folder builds and contains several binaries and you need to provide the name of the binary to be called.
+
+You should refer to the [.Dockerfile](./substrate_builder.Dockerfile) for the actual list. At the time of editing, the list of included binaries is:
+
+- substrate
+- subkey
+- node-template
+- chain-spec-builder
+
+First, install [Docker](https://docs.docker.com/get-docker/).
+
+Then to generate the latest parity/substrate image. Please run:
+```sh
+./build.sh
+```
+
+> If you wish to create a debug build rather than a production build, then you may modify the [.Dockerfile](./substrate_builder.Dockerfile) replacing `cargo build --locked --release` with just `cargo build --locked` and replacing `target/release` with `target/debug`. 
+
+> If you get an error that a tcp port address is already in use then find an available port to use for the host port in the [.Dockerfile](./substrate_builder.Dockerfile).
+
+The image can be used by passing the selected binary followed by the appropriate tags for this binary.
+
+Your best guess to get started is to pass the `--help flag`. Here are a few examples:
+
+- `./run.sh substrate --version`
+- `./run.sh subkey --help`
+- `./run.sh node-template --version`
+- `./run.sh chain-spec-builder --help`
+
+Then try running the following command to start a single node development chain using the Substrate Node Template binary `node-template`:
+
+```sh
+./run.sh node-template --dev --ws-external
+```
+
+Note: It is recommended to provide a custom `--base-path` to store the chain database. For example:
+
+```sh
+# Run Substrate Node Template without re-compiling
+./run.sh node-template --dev --ws-external --base-path=/data
+```
+
+> To print logs follow the [Substrate debugging instructions](https://docs.substrate.io/test/debug/).
+
+```sh
+# Purge the local dev chain
+./run.sh node-template purge-chain --dev --base-path=/data -y
+```
diff --git a/substrate/docker/build.sh b/substrate/docker/build.sh
new file mode 100755
index 0000000000000000000000000000000000000000..d4befd864e4e828c9d734223ed8d4a6559fefbf0
--- /dev/null
+++ b/substrate/docker/build.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -e
+
+pushd .
+
+# Change to the project root and supports calls from symlinks
+cd $(dirname "$(dirname "$(realpath "${BASH_SOURCE[0]}")")")
+
+# Find the current version from Cargo.toml
+VERSION=`grep "^version" ./bin/node/cli/Cargo.toml | egrep -o "([0-9\.]+)"`
+GITUSER=parity
+GITREPO=substrate
+
+# Build the image
+echo "Building ${GITUSER}/${GITREPO}:latest docker image, hang on!"
+time DOCKER_BUILDKIT=1 docker build -f ./docker/substrate_builder.Dockerfile -t ${GITUSER}/${GITREPO}:latest .
+docker tag ${GITUSER}/${GITREPO}:latest ${GITUSER}/${GITREPO}:v${VERSION}
+
+# Show the list of available images for this repo
+echo "Image is ready"
+docker images | grep ${GITREPO}
+
+popd
diff --git a/substrate/docker/run.sh b/substrate/docker/run.sh
new file mode 100755
index 0000000000000000000000000000000000000000..43510bee07f5887449da299dae7d9e73becd074d
--- /dev/null
+++ b/substrate/docker/run.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+
+args=$@
+
+# handle when arguments not provided. run arguments provided to script.
+if [ "$args" = "" ] ; then
+    printf "Note: Please try providing an argument to the script.\n\n"
+    exit 1
+else
+    printf "*** Running Substrate Docker container with provided arguments: $args\n\n"
+    docker run --rm -it parity/substrate $args
+fi
+
diff --git a/substrate/docker/substrate_builder.Dockerfile b/substrate/docker/substrate_builder.Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..03b6b46caf41f31c7e290741e4da67b585cd0b4c
--- /dev/null
+++ b/substrate/docker/substrate_builder.Dockerfile
@@ -0,0 +1,35 @@
+# This is the build stage for Substrate. Here we create the binary.
+FROM docker.io/paritytech/ci-linux:production as builder
+
+WORKDIR /substrate
+COPY . /substrate
+RUN cargo build --locked --release
+
+# This is the 2nd stage: a very small image where we copy the Substrate binary."
+FROM docker.io/library/ubuntu:20.04
+LABEL description="Multistage Docker image for Substrate: a platform for web3" \
+	io.parity.image.type="builder" \
+	io.parity.image.authors="chevdor@gmail.com, devops-team@parity.io" \
+	io.parity.image.vendor="Parity Technologies" \
+	io.parity.image.description="Substrate is a next-generation framework for blockchain innovation 🚀" \
+	io.parity.image.source="https://github.com/paritytech/polkadot/blob/${VCS_REF}/docker/substrate_builder.Dockerfile" \
+	io.parity.image.documentation="https://github.com/paritytech/polkadot/"
+
+COPY --from=builder /substrate/target/release/substrate /usr/local/bin
+COPY --from=builder /substrate/target/release/subkey /usr/local/bin
+COPY --from=builder /substrate/target/release/node-template /usr/local/bin
+COPY --from=builder /substrate/target/release/chain-spec-builder /usr/local/bin
+
+RUN useradd -m -u 1000 -U -s /bin/sh -d /substrate substrate && \
+	mkdir -p /data /substrate/.local/share/substrate && \
+	chown -R substrate:substrate /data && \
+	ln -s /data /substrate/.local/share/substrate && \
+# Sanity checks
+	ldd /usr/local/bin/substrate && \
+# unclutter and minimize the attack surface
+	rm -rf /usr/bin /usr/sbin && \
+	/usr/local/bin/substrate --version
+
+USER substrate
+EXPOSE 30333 9933 9944 9615
+VOLUME ["/data"]
diff --git a/substrate/docker/substrate_builder.Dockerfile.dockerignore b/substrate/docker/substrate_builder.Dockerfile.dockerignore
new file mode 100644
index 0000000000000000000000000000000000000000..dccfeb651ad8d2603dfc0568aaa349cacd53a6b0
--- /dev/null
+++ b/substrate/docker/substrate_builder.Dockerfile.dockerignore
@@ -0,0 +1,11 @@
+doc
+**target*
+.idea/
+.git/
+.github/
+Dockerfile
+.dockerignore
+.local
+.env*
+HEADER-GPL3
+LICENSE-GPL3
diff --git a/substrate/docs/CHANGELOG.md b/substrate/docs/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..25f8e582c78fc01f3b5ca46d8f57f70413f3c2b6
--- /dev/null
+++ b/substrate/docs/CHANGELOG.md
@@ -0,0 +1,547 @@
+# Changelog
+
+The format is based on [Keep a Changelog].
+
+[Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
+
+## Unreleased
+
+## 2.0.1-> 3.0.0 - Apollo 14
+
+Most notably, this is the first release of the new FRAME (2.0) with its new macro-syntax and some changes in types, and pallet versioning. This release also incorporates the faster and improve version 2.0 of the parity-scale-codec and upgraded dependencies all-around. While the `FinalityTracker` pallet has been dropped, this release marks the first public appearance of a few new pallets, too;Bounties, Lottery, Tips (extracted from the `Treasury`-pallet, see #7536) and Merkle-Mountain-Ranges (MMR).
+
+On the client side, the most notable changes are around the keystore, making it async and switching to a different signing model allowing for remote-signing to be implemented; and various changes to improve networking and light-client support, like adding the Grandpa warp sync request-response protocol (#7711).
+
+_Contracts_: Please note that the contracts pallet _is not part_ of this release. The pallet is not yet ready and will be released separately in the coming weeks. The currently released contracts pallet _is not compatible_ with the new FRAME, thus if you need the contracts pallet, we recommend you wait with the upgrade until it has been released, too.
+### Upgrade instructions
+
+Not too much has changed on the top and API level for developing Substrate between 2.0 and 3.0. The easiest and quickest path for upgrading is just to take the latest node-template and try applying your changes to it:
+1. take a diff between 2.0 and your changes
+2. store that diff
+3. remove everything, copy over the 3.0 node-template
+4. try re-applying your diff, manually, a hunk at a time.
+
+If that doesn't work for you, we are working on an in-depth-guide for all major changes that took place and how you need to adapt your code for it. [You can find the upgrade guide under `docs/` in the repo](https://github.com/paritytech/substrate/blob/master/docs/Upgrading-2.0-to-3.0.md), if you have further questions or problem, please [feel free to ask in the github discussion board](https://github.com/paritytech/substrate/discussions).
+
+
+Runtime
+-------
+
+* contracts: Charge rent for code storage (#7935)
+* contracts: Emit event on contract termination (#8014)
+* Fix elections-phragmen and proxy issue (#7040)
+* Allow validators to block and kick their nominator set. (#7930)
+* Decouple Staking and Election - Part1: Support traits (#7908)
+* Introduces account existence providers reference counting (#7363)
+* contracts: Cap the surcharge reward by the amount of rent that way payed by a contract (#7870)
+* Use checked math when calculating storage size (#7885)
+* Fix clear prefix check to avoid erasing child trie roots. (#7848)
+* contracts: Collect rent for the first block during deployment (#7847)
+* contracts: Add configurable per-storage item cost (#7819)
+* babe: expose next epoch data (#7829)
+* fix : remove `_{ }` syntax from benchmark macro (#7822)
+* Define ss58 prefix inside the runtime (#7810)
+* Allow council to slash treasury tip (#7753)
+* Don't allow self proxies (#7803)
+* add a `current_epoch` to BabeApi (#7789)
+* Add `pallet` attribute macro to declare pallets (#6877)
+* Make it possible to calculate the storage root as often as you want (#7714)
+* Issue 7143 | Refactor Treasury Pallet into Bounties, Tips, and Proposals (#7536)
+* Participating in Council Governance is Free for First Time Voters and Successful Closing (#7661)
+* Streamline frame_system weight parametrization (#6629)
+* Features needed for reserve-backed stablecoins (#7152)
+* `sudo_as` should return a result (#7620)
+* More Extensible Multiaddress Format (#7380)
+* Fix `on_runtime_upgrade` weight recording (#7480)
+* Implement batch_all and update Utility pallet for weight refunds (#7188)
+* Fix wrong outgoing calculation in election (#7384)
+* Implements pallet versioning (#7208)
+* Runtime worker threads (#7089)
+* Allow `schedule_after(0, ...)` to work (#7284)
+* Fix offchain election to respect the weight (#7215)
+* Fix weight for inner call with new origin (#7196)
+* Move proxies migration (#7205)
+* Introduce `cancel_proposal` to rid us of those pesky proposals (#7111)
+
+Client
+------
+
+* Remove backwards-compatibility networking hack (#8068)
+* Extend SS58 network identifiers (#8039)
+* Update dependencies ahead of next release (#8015)
+* Storage chains: serve transactions over IPFS/bitswap (#7963)
+* Add a send_request function to NetworkService (#8008)
+* Rename system_networkState to system_unstable_networkState (#8001)
+* Allow transaction for offchain indexing (#7290)
+* Grandpa warp sync request-response protocol (#7711)
+* Add explicit limits to notifications sizes and adjust yamux buffer size (#7925)
+* Rework priority groups, take 2 (#7700)
+* Define ss58 prefix inside the runtime (#7810)
+* Expand remote keystore interface to allow for hybrid mode (#7628)
+* Allow capping the amount of work performed when deleting a child trie (#7671)
+* RPC to allow setting the log filter (#7474)
+* Remove sc_network::NetworkService::register_notifications_protocol and partially refactor Grandpa tests (#7646)
+* minor fix and improvements on localkeystore (#7626)
+* contracts: Add `salt` argument to contract instantiation (#7482)
+* contracts: Rework contracts_call RPC (#7468)
+* Make sure to use the optimized method instead of reading the storage. (#7445)
+* WASM Local-blob override (#7317)
+* client/network: Allow configuring Kademlia's disjoint query paths (#7356)
+* client/network: Remove option to disable yamux flow control (#7358)
+* Make `queryStorage` and `storagePairs` unsafe RPC functions (#7342)
+* No longer actively open legacy substreams (#7076)
+* Make `run_node_until_exit` take a future (#7318)
+* Add an system_syncState RPC method (#7315)
+* Async keystore + Authority-Discovery async/await (#7000)
+* Fixes logging of target names with dashes (#7281)
+* Refactor CurrencyToVote (#6896)
+* client/network: Stop sending noise legacy handshake (#7211)
+
+API
+---
+
+* pallet macro: easier syntax for `#[pallet::pallet]` with `struct Pallet<T>(_)` (#8091)
+* WasmExecutor takes a cache directory (#8057)
+* Remove PalletInfo impl for () (#8090)
+* Migrate assets pallet to new macros (#7984)
+* contracts: Make ChainExtension trait generic over the runtime (#8003)
+* Decouple the session validators from im-online (#7127)
+* Update parity-scale-codec to 2.0 (#7994)
+* Merkle Mountain Range pallet improvements (#7891)
+* Cleaner GRANDPA RPC API for proving finality (#7339)
+* Migrate frame-system to pallet attribute macro (#7898)
+* Introduces account existence providers reference counting (#7363)
+* contracts: Lazy storage removal (#7740)
+* contracts: Allow runtime authors to define a chain extension (#7548)
+* Define ss58 prefix inside the runtime (#7810)
+* Add `pallet` attribute macro to declare pallets (#6877)
+* Add keccak-512 to host functions. (#7531)
+* Merkle Mountain Range pallet (#7312)
+* Allow capping the amount of work performed when deleting a child trie (#7671)
+* add an upgrade_keys method for pallet-session (#7688)
+* Streamline frame_system weight parametrization (#6629)
+* Rename pallet trait `Trait` to `Config` (#7599)
+* contracts: Add `salt` argument to contract instantiation (#7482)
+* pallet-evm: move to Frontier (Part IV) (#7573)
+* refactor subtrait/elevated trait as not needed (#7497)
+* Allow BabeConsensusDataProvider fork existing chain (#7078)
+* decouple transaction payment and currency (#6912)
+* contracts: Refactor the runtime API in order to simplify node integration (#7409)
+* client/authority-discovery: Remove sentry node logic (#7368)
+* client/network: Make NetworkService::set_priority_group async (#7352)
+* *: Bump async-std to v1.6.5 (#7306)
+* babe: make secondary slot randomness available on-chain (#7053)
+* allow where clause in decl_error (#7324)
+* reschedule (#6860)
+* SystemOrigin trait (#7226)
+* permit setting treasury pallet initial funding through genesis (#7214)
+
+Runtime Migrations
+------------------
+
+* Migrate assets pallet to new macros (#7984)
+* Fix elections-phragmen and proxy issue (#7040)
+* Allow validators to block and kick their nominator set. (#7930)
+* Migrate frame-system to pallet attribute macro (#7898)
+* Implements pallet versioning (#7208)
+* Move proxies migration (#7205)
+
+
+## 2.0.0-> 2.0.1
+
+Patch release with backports to fix broken nightly builds.
+Namely contains backports of
+
+* [#7381: Make Substrate compile with latest nightly](https://github.com/paritytech/substrate/pull/7381)
+* [#7238: Fix compilation with environmental on latest nightly](https://github.com/paritytech/substrate/pull/7238)
+* [#7395: Make benchmarks compile with latest nightly](https://github.com/paritytech/substrate/pull/7395)
+* [#7838: Fix incorrect use of syn::exports](https://github.com/paritytech/substrate/pull/7838) (partially)
+* [#7854: Update to futures 0.3.9](https://github.com/paritytech/substrate/pull/7854)
+
+
+## 2.0.0-rc6 -> 2.0.0 – two dot 😮
+
+Runtime
+-------
+
+* Rename `ModuleToIndex` to `PalletRuntimeSetup` (#7148)
+* Bounties (#5715)
+* pallet-collective: allow customized default vote (#6984)
+* add instantiable support for treasury pallet (#7058)
+* frame/authority-discovery: Have authorities() return both current and next (#6788)
+* add generated weight info for pallet-collective (#6789)
+* Support Staking Payout to Any Account (#6832)
+* Time-delay proxies (#6770)
+* Refcounts are now u32 (#7164)
+
+Client
+------
+
+* Rename `inspect-key` to `inspect` (#7160)
+* Send import notification always for re-orgs (#7118)
+* Allow remotes to not open a legacy substream (#7075)
+* Fix `storage::read` (#7084)
+* Support hex encoded secret key for `--node-key` (#7052)
+* Update the service tasks Grafana dashboard (#7038)
+* manual seal is now consensus agnostic (#7010)
+* Move subcommands from sc-cli to nodes (#6948)
+* Implement request-responses protocols (#6634)
+* fix bench db wipe (#6965)
+* Fix benchmark read/write key tracker for keys in child storages. (#6905)
+* *: Update to next libp2p version 0.24.0 (#6891)
+
+API
+---
+
+* grandpa-rpc: use FinalityProofProvider to check finality for rpc (#6215)
+* pow: replace the thread-base mining loop with a future-based mining worker (#7060)
+* Tracing for wasm with bridging to native (#6916)
+* Frame-support storage: make iterations and translate consistent (#5470)
+* pow: support uniform tie breaking in fork choice (#7073)
+* Make decoding of `compact<perthing>` saturating instead of invalid (#7062)
+* Set reserved nodes with offchain worker. (#6996)
+* client/*: Treat protocol name as str and not [u8] (#6967)
+* Add a `LightSyncState` field to the chain spec (#6894)
+* *: Update to next libp2p version 0.24.0 (#6891)
+
+Runtime Migrations
+------------------
+
+* Time-delay proxies (#6770)
+
+
+## 2.0.0-rc5 -> 2.0.0-rc6 – Rock Hyrax
+
+Runtime
+-------
+
+* Custom Codec Implementation for NPoS Election (#6720)
+* Successful `note_imminent_preimage` is free (#6793)
+* pallet-democracy use of weightinfo (#6783)
+* Update Balances Pallet to use `WeightInfo` (#6610)
+* pallet-evm: add builtin support for the four basic Ethereum precompiles (#6743)
+* Allow `PostDispatchInfo` to disable fees (#6749)
+* pallet-evm: add support for tuple-based precompile declarations (#6681)
+* grandpa: allow noting that the set has stalled (#6725)
+
+Client
+------
+
+* Merge Subkey into sc-cli (#4954)
+* RpcHandlers Refactorings (#6846)
+* client/authority-discovery: Introduce AuthorityDiscoveryService (#6760)
+* Implement tracing::Event handling & parent_id for spans and events (#6672)
+* Move to upstream wasmtime, refactor globals snapshot  (#6759)
+* Revalidate transactions only on latest best block (#6824)
+* Allow task manager to have children (#6771)
+* client/network: Expose DHT query duration to Prometheus (#6784)
+* client/network: Add peers to DHT only if protocols match (#6549)
+* Name all the tasks! (#6726)
+* Child nodes can be handled by adding a child `TaskManager` to the parent's `TaskManager` (#6771)
+
+API
+---
+
+* pow: add access to pre-digest for algorithm verifiers (#6900)
+* babe, aura, pow: only call check_inherents if authoring version is compatible (#6862)
+* Implement 'transactional' annotation for runtime functions. (#6763)
+* seal: Change prefix and module name from "ext_" to "seal_" for contract callable functions (#6798)
+* Add Subscription RPC for Grandpa Finality (#5732)
+* seal: Fix and improve error reporting (#6773)
+* Allow blacklisting blocks from being finalized again after block revert (#6301)
+* BABE slot and epoch event notifications (#6563)
+* Add `memory-tracker` feature to `sp-trie` to fix wasm panic (#6745)
+
+## 2.0.0-rc4 -> 2.0.0-rc5 – River Dolphin
+
+Runtime
+-------
+
+* Support using system storage directly for EVM balance and nonce (#6659)
+* Properly filter out duplicate voters in elections. (#6693)
+* Treasury burning can be directed (#6671)
+* identity: Don't let subs be re-registered (#6667)
+* Regression test to ensure we don't break deterministic builds in wasm (#6597)
+* allow to specify schedule time as a relative value (#6578)
+* Make signature batching use specialized methods (#6616)
+* Rename `CheckEra` to `CheckMortality` (#6619)
+* Add `WeightInfo` to all pallets with benchmarks. (#6575)
+* Don't require module name in inherents (#6576)
+* pallet-evm: return Ok(()) when EVM execution fails (#6493)
+* Make the encoded-Call Vec<u8> explicitly so in metadata (#6566)
+* Allow specify schedule dispatch origin (#6387)
+* pallet-evm: customizable chain id (#6537)
+* Refactor as_sub to make things clearer. (#6503)
+
+Client
+------
+
+* Update wasmtime to (almost) latest master (#6662)
+* Update to latest sysinfo prevents leaking fd-handlers (#6708)
+* Tracing values (#6679)
+* Graceful shutdown for the task manager (#6654)
+* Update substrate-networking Grafana dashboard (#6649)
+* *: Update to libp2p v0.21.1 (#6559)
+* Send Status message on all newly-opened legacy substreams (#6593)
+* babe: report equivocations (#6362)
+* Support synching of blocks that are not `new_best` (#6508)
+* Remove the service, replacing it with a struct of individual chain components (#6352)
+* Fix tx-pool returning the same transaction multiple times (#6535)
+
+API
+---
+
+* Better handling of stable-only build (#6569)
+* Remove the service builder (#6557)
+* seal: Prevent contracts from going below subsistence (#6623)
+* seal: Rework contracts API (#6573)
+* Make evm errors public (#6598)
+* Add log rotation (#6564)
+* decl_module! macro: use 'frame_system' instead of `system` as default ident (#6500)
+* Restrict `Protected` to some heap types. (#6471)
+
+## 2.0.0-rc3 -> 2.0.0-rc4 (Rhinoceros)
+
+Runtime
+-------
+
+* Staking Payout Creates Controller (#6496)
+* `pallet-scheduler`: Check that `when` is not in the past (#6480)
+* Fix `sp-api` handling of multiple arguments (#6484)
+* Fix issues with `Operational` transactions validity and prioritization. (#6435)
+* pallet-atomic-swap: generalized swap action (#6421)
+* Avoid multisig reentrancy (#6445)
+* Root origin use no filter by default. Scheduler and Democracy dispatch without asserting BaseCallFilter (#6408)
+* Scale and increase validator count (#6417)
+* Pallet: Atomic Swap (#6349)
+* Restrict remove_proxies (#6383)
+* Stored call in multisig (#6319)
+* Allow Sudo to do anything (#6375)
+* vesting: Force Vested Transfer (#6368)
+* Add events for balance reserve and unreserve functions (#6330)
+* Introduce frozen indices. (#6307)
+
+Client
+------
+
+* client/network/service: Add primary dimension to connection metrics (#6472)
+* Fix Babe secondary plain slots claiming (#6451)
+* add network propagated metrics (#6438)
+* client/authority-discovery: Compare PeerIds and not Multihashes (#6414)
+* Update sync chain info on own block import (#6424)
+* Remove --legacy-network-protocol CLI flag (#6411)
+* Runtime interface to add support for tracing from wasm (#6381)
+* Remove penalty on duplicate Status message (#6377)
+* Fix the broken weight multiplier update function (#6334)
+* client/authority-discovery: Don't add own address to priority group (#6370)
+* Split the service initialisation up into separate functions (#6332)
+* Fix transaction pool event sending (#6341)
+* Add a [prefix]_process_start_time_seconds metric (#6315)
+* new crate sc-light (#6235)
+* Allow adding a prefix to the informant (#6174)
+
+API
+---
+
+* seal: Remove ext_dispatch_call and ext_get_runtime_storage (#6464)
+* seal: Refactor ext_gas_price (#6478)
+* Implement nested storage transactions (#6269)
+* Allow empty values in the storage (#6364)
+* add system_dryRun (#6300)
+* Introduce in-origin filtering (#6318)
+* add extend_lock for StorageLock (#6323)
+* Deprecate FunctionOf and remove its users (#6340)
+* transaction-pool: expose blocking api for tx submission (#6325)
+
+
+## 2.0.0-rc2 -> 2.0.0-rc3
+
+Runtime
+-------
+
+* Introduce stacked filtering (#6273)
+* Allow "pure" proxied accounts (#6236)
+* Allow over-weight collective proposals to be closed (#6163)
+* Fix Election when ForceNone V1 (#6166)
+
+Client
+------
+
+* Make transaction pool prune transactions only of canonical blocks (#6123)
+* Rename all the election operations (#6245)
+* Sentry nodes and validator nodes also imply reserved (#6251)
+* Fix peerset not filtering incoming connections in reserved-only (#6249)
+* Use Subscription Manager from `jsonrpc-pubsub` (#6208)
+* Add a Substrate networking Grafana dashboard template (#6171)
+* Add subkey inspect-node-key (#6153)
+
+## 2.0.0-rc1 -> 2.0.0-rc2
+
+(nothing of note)
+
+## 2.0.0-alpha.8 -> 2.0.0-rc1
+
+Runtime
+-------
+
+* Allow operational recovery path if on_initialize use fullblock. (#6089)
+* Maximum extrinsic weight limit (#6067)
+
+Client
+------
+
+* Add JSON format to import blocks and set it as default (#5816)
+* Upgrade to libp2p v0.19 - Changes the default PeerId representation (#6064)
+
+
+## 2.0.0-alpha.7 -> 2.0.0-alpha.8
+
+**License Changed**
+From this release forward, the code is released under a new – more relaxed – license scheme: Client (`sc-*`) is released under "GPL 3.0 or newer with the Classpath Exception", while primitives, FRAME, the pallets, utils and test-utils are released under "Apache 2.0". More details in the [Relax licensing scheme PR](https://github.com/paritytech/substrate/pull/5947).
+
+Runtime
+-------
+
+* Democracy weight (#5828)
+* Make `Digest` support `StorageAppend` (#5922)
+
+Client
+------
+
+* Meter block import results via prometheus (#6025)
+* Added RuntimePublic for ecdsa public key. (#6029)
+* Benchmarks for elections-phragmen pallet (#5845)
+* Monitor transactions rejected from the pool as invalid (#5992)
+* client/network: Remove default Kademlia DHT in favor of per protocol DHT (#5993)
+* Allow passing multiple --log CLI options (#5982)
+* client: Replace `unsafe_rpc_expose` with an `RpcMethods` enum (#5729)
+
+## 2.0.0-alpha.6 -> 2.0.0-alpha.7
+
+Runtime
+-------
+
+* Use `storage::append` in the implementation of the storage types (#5889)
+* pallet-sudo: Store `DispatchResult` in `Sudid` event (#5804)
+* Enable Offchain Equalise (#5683)
+* Add support for custom runtime upgrade logic (#5782)
+* Require `fn` token in `decl_storage` `get` (#5717)
+* Child trie api changes BREAKING (#4857)
+* Pass max-total to RewardRemainder on end_era (#5697)
+* Transaction versioning in the RuntimeVersion (#5582)
+* emit TipClosed event on success tip payout (#5656)
+
+Client
+------
+
+* Adds `export-state` subcommand (#5842)
+* Drop ClientProvider (#5823)
+* Move spawning tasks from thread pools to Service's TaskManager for block importing (#5647)
+* Reputation penalty for sending empty block response (#5814)
+* Move sc-client into sc-service (#5502)
+* Use new block requests protocol (#5760)
+* Fix leak in stream notifications (#5739)
+* network: Only insert global addresses into the DHT. (#5735)
+* enum Pays for PaysFee (#5733)
+* Migrate away from `SimpleDispatchInfo` (#5686)
+* Child trie api changes BREAKING (#4857)
+* subkey: compute and inspect a moduleid (#5676)
+* Listen on ipv6 by default as well (#5677)
+* Adjustments to Kademlia-related metrics (#5660)
+* client/authority-discovery: Allow to be run by sentry node (#5568)
+* Add alternative RPC methods to system_networkState (#5643)
+* Several tweaks to networking Prometheus metrics (#5636)
+* Use a Kademlia instance per `ProtocolId`. (#5045)
+* Report tasks metrics to Prometheus (#5619)
+
+API
+---
+
+* Child trie api changes BREAKING (#4857)
+* Pass max-total to RewardRemainder on end_era (#5697)
+* Implement iter for doublemap (#5504)
+
+## 2.0.0-alpha.5 -> 2.0.0-alpha.6
+
+Runtime
+-------
+
+* Unsigned Validation best practices (#5563)
+* Generate Unit Tests for Benchmarks (#5527)
+* Mandate weight annotation  (#5357)
+* Make Staking pallet using a proper Time module. (#4662)
+* Pass transaction source to validate_transaction (#5366)
+* on_initialize return weight consumed and default cost to default DispatchInfo instead of zero (#5382)
+
+Client
+------
+
+* Add new RPC method to get the chain type (#5576)
+* Reuse wasmtime instances, the PR (#5567)
+* Prometheus Metrics: Turn notifications_total counter into notifications_sizes histogram (#5535)
+* Make verbosity level mandatory with telemetry opt (#5057)
+* Additional Metrics collected and exposed via prometheus (#5414)
+* Switch to new light client protocol (#5472)
+* client/finality-grandpa: Instrument until-imported queue (#5438)
+* Batch benchmarks together with `*` notation. (#5436)
+* src/service/src/builder: Fix memory metric exposed in bytes not KiB (#5459)
+* Make transactions and block announces use notifications substre… (#5360)
+* Adds state_queryStorageAt (#5362)
+* Offchain Phragmén BREAKING. (#4517)
+* `sc_rpc::system::SystemInfo.impl_version` now returns the full version (2.0.0-alpha.2-b950f731c-x86_64-linux-gnu) instead of the short version (1.0.0) (#5271)
+
+API
+---
+
+* Unsigned Validation best practices (#5563)
+* Split the Roles in three types (#5520)
+* Pass transaction source to validate_transaction (#5366)
+* on_initialize return weight consumed and default cost to default DispatchInfo instead of zero (#5382)
+
+
+## 2.0.0-alpha.4 -> 2.0.0-alpha.5
+
+Runtime
+-------
+
+* pallet-evm: configurable gasometer config (#5320)
+* Adds new event phase `Initialization` (#5302)
+
+## 2.0.0-alpha.3 -> 2.0.0-alpha.4
+
+Runtime
+-------
+
+* Move runtime upgrade to `frame-executive` (#5197)
+* Split fees and tips between author and treasury independently (#5207)
+* Refactor session away from needless double_maps (#5202)
+* Remove `secp256k1` from WASM build (#5187)
+* Introduce default-setting prime for collective (#5137)
+* Adds `vested_transfer` to Vesting pallet (#5029)
+* Change extrinsic_count to extrinsic_index in pallet-utility (#5044)
+
+Client
+------
+
+* client/finality-grandpa: Add Prometheus metrics to GossipValidator (#5237)
+* removes use of sc_client::Client from node-transaction-factory (#5158)
+* removes use of sc_client::Client from sc_network (#5147)
+* Use CLI to configure max instances cache (#5177)
+* client/service/src/builder.rs: Add build_info metric (#5192)
+* Remove substrate-ui.parity.io from CORS whitelist (#5142)
+* removes use of sc_client::Client from sc-rpc (#5063)
+* Use 128mb for db cache default (#5134)
+* Drop db-cache default from 1gig to 32mb (#5128)
+* Add more metrics to prometheus (#5034)
+
+API
+---
+
+* Produce block always on updated transaction pool state (#5227)
+* Add `ext_terminate` (#5234)
+* Add ext_transfer call (#5169)
+* ChainSpec trait (#5185)
+* client/authority-discovery: Instrument code with Prometheus (#5195)
+* Don't include `:code` by default in storage proofs (#5179)
+* client/network-gossip: Merge GossipEngine and GossipEngineInner (#5042)
+* Introduce `on_runtime_upgrade` (#5058)
diff --git a/substrate/docs/CODEOWNERS b/substrate/docs/CODEOWNERS
new file mode 100644
index 0000000000000000000000000000000000000000..63294d90e9d069949614bc1c703078f6828dd70d
--- /dev/null
+++ b/substrate/docs/CODEOWNERS
@@ -0,0 +1,74 @@
+# Lists some code owners.
+#
+# A codeowner just oversees some part of the codebase. If an owned file is changed then the
+# corresponding codeowner receives a review request. An approval of the codeowner is
+# not required for merging a PR though.
+#
+# **This is pretty much an experiment at the moment**. Feel free to remove yourself at any time if
+# you do not want to receive review requests any longer.
+#
+# For details about syntax, see:
+# https://help.github.com/en/articles/about-code-owners
+# But here are some important notes:
+#
+# - Glob syntax is git-like, e.g. `/core` means the core directory in the root, unlike `core` which
+#   can be everywhere.
+# - Multiple owners are supported.
+# - Either handle (e.g, @pepyakin) or email can be used. Keep in mind, that handles might work better because they
+#   are more recognizable on GitHub, you can use them for mentioning unlike an email.
+# - The latest matching rule, if multiple, takes precedence.
+
+# CI
+/.github/ @paritytech/ci
+/.gitlab-ci.yml @paritytech/ci
+/scripts/ci/ @paritytech/ci
+
+# WASM executor, low-level client <-> WASM interface and other WASM-related code
+/client/allocator/ @koute
+/client/executor/ @koute
+/primitives/panic-handler/ @koute
+/primitives/runtime-interface/ @koute
+/primitives/wasm-interface/ @koute
+/utils/wasm-builder/ @koute
+
+# Systems-related bits and bobs on the client side
+/client/sysinfo/ @koute
+/client/tracing/ @koute
+
+# Documentation audit
+/primitives/runtime @paritytech/docs-audit
+/primitives/arithmetic @paritytech/docs-audit
+# /primitives/core (to be added later)
+# /primitives/io (to be added later)
+
+# FRAME
+/frame/ @paritytech/frame-coders @paritytech/docs-audit
+/frame/nfts/ @jsidorenko @paritytech/docs-audit
+/frame/state-trie-migration/ @paritytech/frame-coders @cheme
+/frame/uniques/ @jsidorenko @paritytech/docs-audit
+
+# GRANDPA, BABE, consensus stuff
+/client/consensus/babe/ @andresilva
+/client/consensus/grandpa/ @andresilva
+/client/consensus/pow/ @sorpaas
+/client/consensus/slots/ @andresilva
+/frame/babe/ @andresilva
+/frame/grandpa/ @andresilva
+/primitives/consensus/pow/ @sorpaas
+
+# BEEFY, MMR
+/frame/beefy/ @acatangiu
+/frame/beefy-mmr/ @acatangiu
+/frame/merkle-mountain-range/ @acatangiu
+/primitives/merkle-mountain-range/ @acatangiu
+
+# Contracts
+/frame/contracts/ @athei @paritytech/docs-audit
+
+# NPoS and election
+/frame/election-provider-multi-phase/ @paritytech/staking-core @paritytech/docs-audit
+/frame/election-provider-support/ @paritytech/staking-core @paritytech/docs-audit
+/frame/elections-phragmen/ @paritytech/staking-core @paritytech/docs-audit
+/frame/nomination-pools/ @paritytech/staking-core @paritytech/docs-audit
+/frame/staking/ @paritytech/staking-core @paritytech/docs-audit
+/primitives/npos-elections/ @paritytech/staking-core @paritytech/docs-audit
diff --git a/substrate/docs/CODE_OF_CONDUCT.md b/substrate/docs/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000000000000000000000000000000000..400c9b3901e26a7e5a1840816897ed31927156f5
--- /dev/null
+++ b/substrate/docs/CODE_OF_CONDUCT.md
@@ -0,0 +1,52 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+### Facilitation, Not Strongarming
+
+We recognise that this software is merely a tool for users to create and maintain their blockchain of preference. We see that blockchains are naturally community platforms with users being the ultimate decision makers. We assert that good software will maximise user agency by facilitate user-expression on the network. As such:
+
+* This project will strive to give users as much choice as is both reasonable and possible over what protocol they adhere to; but
+* use of the project's technical forums, commenting systems, pull requests and issue trackers as a means to express individual protocol preferences is forbidden.
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at <admin@parity.io>. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at https://contributor-covenant.org/version/1/4
+
+[homepage]: https://contributor-covenant.org
diff --git a/substrate/docs/CONTRIBUTING.md b/substrate/docs/CONTRIBUTING.md
new file mode 100644
index 0000000000000000000000000000000000000000..cbaf6206e78f2a8f170dcc1e6bad721455700733
--- /dev/null
+++ b/substrate/docs/CONTRIBUTING.md
@@ -0,0 +1,134 @@
+# Contributing
+
+The `Substrate` project is an ***OPENISH Open Source Project***
+
+Contributors are invited to our `#frame-contributors` channel on the Polkadot Discord for support and coordination:  
+[![Discord](https://img.shields.io/discord/722223075629727774?style=for-the-badge&logo=discord&label=Discord)](https://dot.li/discord)
+
+## What?
+
+Individuals making significant and valuable contributions are given commit-access to a project to contribute as they see fit. A project is more like an open wiki than a standard guarded open source project.
+
+## Rules
+
+There are a few basic ground-rules for contributors (including the maintainer(s) of the project):
+
+1. ***No `--force` pushes*** or modifying the master branch history in any way. If you need to rebase, ensure you do it in your own repo. No rewriting of the history after the code has been shared (e.g. through a Pull-Request).
+2. ***Non-master branches***, prefixed with a short name moniker (e.g. `gav-my-feature`) must be used for ongoing work.
+3. ***All modifications*** must be made in a ***pull-request*** to solicit feedback from other contributors.
+4. A pull-request **must not be merged until CI** has finished successfully.
+5. Contributors should adhere to the [house coding style](STYLE_GUIDE.md).
+6. Contributors should adhere to the [house documenting style](DOCUMENTATION_GUIDELINES.md), when applicable.
+
+## Merge Process
+
+**In General**
+
+A Pull Request (PR) needs to be reviewed and approved by project maintainers unless:
+
+* it does not alter any logic (e.g. comments, dependencies, docs), then it may be tagged [`insubstantial`](https://github.com/paritytech/substrate/pulls?utf8=%E2%9C%93&q=is%3Apr+is%3Aopen+label%3AA2-insubstantial) and merged by its author once CI is complete.
+* it is an urgent fix with no large change to logic, then it may be merged after a non-author contributor has approved the review once CI is complete.
+
+**Labels TLDR:**
+
+* `A-*` Pull request status. ONE REQUIRED.
+* `B-*` Changelog and/or Runtime-upgrade post composition markers. ONE REQUIRED. (used by automation)
+* `C-*` Release notes release-criticality markers. EXACTLY ONE REQUIRED. (used by automation)
+* `D-*` Audit tags denoting auditing requirements on the PR.
+
+**Process:**
+
+1. Please tag each PR with exactly one `A`, `B`, `C` and `D` label at the minimum.
+2. When tagging a PR, it should be done while keeping all downstream users in mind. Downstream users are not just Polkadot or system parachains, but also all the other parachains and solo chains that are using Substrate. The labels are used by downstream users to track changes and to include these changes properly into their own releases.
+3. Once a PR is ready for review please add the [`A0-please_review`](https://github.com/paritytech/substrate/pulls?q=is%3Apr+is%3Aopen+label%3AA0-please_review+) label. Generally PRs should sit with this label for 48 hours in order to garner feedback. It may be merged before if all relevant parties had a look at it.
+4. If the first review is not an approval, swap `A0-please_review` to any label `[A3, A5]` to indicate that the PR has received some feedback, but needs further work. For example. [`A3-in_progress`](https://github.com/paritytech/substrate/labels/A3-in_progress) is a general indicator that the PR is work in progress.
+5. PRs must be tagged with `B*` labels to signal if a change is note worthy for downstream users. The respective `T*` labels should be added to signal the component that was changed. `B0-silent` must only be used for changes that don’t require any attention by downstream users.
+6. PRs must be tagged with their release importance via the `C1-C7` labels. The release importance is only informing about how important it is to apply a release that contains the change.
+7. PRs must be tagged with their audit requirements via the `D1-D9` labels.
+8. PRs that introduce runtime migrations must be tagged with [`E0-runtime_migration`](https://github.com/paritytech/substrate/labels/E0-runtime_migration). See the [Migration Best Practices here](https://github.com/paritytech/substrate/blob/master/utils/frame/try-runtime/cli/src/lib.rs#L18) for more info about how to test runtime migrations.
+9. PRs that introduce irreversible database migrations must be tagged with [`E1-database_migration`](https://github.com/paritytech/substrate/labels/E1-database_migration).
+10. PRs that add host functions must be tagged with with [`E3-host_functions`](https://github.com/paritytech/substrate/labels/E3-host_functions).
+11. PRs that break the external API must be tagged with [`F3-breaks_API`](https://github.com/paritytech/substrate/labels/F3-breaks_API).
+12. PRs that change the mechanism for block authoring in a backwards-incompatible way must be tagged with [`F1-breaks_authoring`](https://github.com/paritytech/substrate/labels/F1-breaks_authoring).
+13. PRs that "break everything" must be tagged with [`F0-breaks_everything`](https://github.com/paritytech/substrate/labels/F0-breaks_everything).
+14. PRs should be categorized into projects.
+15. No PR should be merged until all reviews' comments are addressed and CI is successful.
+
+**Noting relevant changes:**
+
+When breaking APIs, it should be mentioned on what was changed in the PR description alongside some examples on how to change the code to make it work/compile.
+
+The PR description should also mention potential storage migrations and if they require some special setup aside adding it to the list of migrations in the runtime.
+
+**Reviewing pull requests:**
+
+When reviewing a pull request, the end-goal is to suggest useful changes to the author. Reviews should finish with approval unless there are issues that would result in:
+
+1. Buggy behavior.
+2. Undue maintenance burden.
+3. Breaking with house coding style.
+4. Pessimization (i.e. reduction of speed as measured in the projects benchmarks).
+5. Feature reduction (i.e. it removes some aspect of functionality that a significant minority of users rely on).
+6. Uselessness (i.e. it does not strictly add a feature or fix a known issue).
+
+**Reviews may not be used as an effective veto for a PR because**:
+
+1. There exists a somewhat cleaner/better/faster way of accomplishing the same feature/fix.
+2. It does not fit well with some other contributors' longer-term vision for the project.
+
+### Updating Polkadot as well
+
+***All pull requests will be checked against either Polkadot master, or your provided Polkadot companion PR***. That is, If your PR changes the external APIs or interfaces used by Polkadot. If you tagged the PR with `breaksapi` or `breaksconsensus` this is most certainly the case, in all other cases check for it by running step 1 below.
+
+To create a Polkadot companion PR:
+
+1. Pull latest Polkadot master (or clone it, if you haven’t yet).
+2. Override substrate deps to point to your local path or branch using https://github.com/bkchr/diener. (E.g. from the Polkadot clone dir run `diener patch --crates-to-patch ../substrate --substrate` assuming substrate clone is in a sibling dir. If you do use diener, ensure that you _do not_ commit the changes diener makes to the Cargo.tomls.)
+3. Make the changes required and build Polkadot locally.
+4. Submit all this as a PR against the Polkadot Repo.
+5. In the _description_ of your _Substrate_ PR add "Polkadot companion: [Polkadot_PR_URL]"
+6. Now you should see that the `check_polkadot` CI job will build your Substrate PR against the mentioned Polkadot branch in your PR description.
+7. Someone will need to approve the Polkadot PR before the Substrate CI will go green. (The Polkadot CI failing can be ignored as long as the Polkadot job in the _substrate_ PR is green).
+8. Wait for reviews on both the Substrate and the Polkadot PRs.
+9. Once the Substrate PR runs green, a member of the `parity` Github group can comment on the Substrate PR with `bot merge` which will:
+   * Merge the Substrate PR.
+   * The bot will push a commit to the Polkadot PR updating its Substrate reference. (effectively doing `cargo update -p sp-io`)
+   * If the Polkadot PR origins from a fork then a project member may need to press `approve run` on the Polkadot PR.
+   * The bot will merge the Polkadot PR once all its CI `{"build_allow_failure":false}` checks are green.
+       Note: The merge-bot currently doesn’t work with forks on org accounts, only individual accounts.
+   	(Hint: it’s recommended to use `bot merge` to merge all substrate PRs, not just ones with a Polkadot companion.)
+
+If your PR is reviewed well, but a Polkadot PR is missing, signal it with [`E6-needs_polkadot_pr`](https://github.com/paritytech/substrate/labels/E6-needs_polkadot_pr) to prevent it from getting automatically merged. In most cases the CI will add this label automatically.
+
+As there might be multiple pending PRs that might conflict with one another, a) you should not merge the substrate PR until the Polkadot PR has also been reviewed and b) both should be merged pretty quickly after another to not block others.
+
+## Helping out
+
+We use [labels](https://paritytech.github.io/labels/doc_substrate.html) to manage PRs and issues and communicate state of a PR. Please familiarize yourself with them. The best way to get started is to a pick a ticket tagged [`easy`](https://github.com/paritytech/substrate/issues?q=is%3Aissue+is%3Aopen+label%3AZ1-easy) or [`medium`](https://github.com/paritytech/substrate/issues?q=is%3Aissue+is%3Aopen+label%3AZ2-medium) and get going or [`mentor`](https://github.com/paritytech/substrate/issues?q=is%3Aissue+is%3Aopen+label%3AZ6-mentor) and get in contact with the mentor offering their support on that larger task.
+
+## Issues
+Please label issues with the following labels:
+
+1. `I-**` or `J-**` Issue severity and type. EXACTLY ONE REQUIRED.
+2. `U-*` Issue urgency, suggesting in what time manner does this issue need to be resolved. AT MOST ONE ALLOWED.
+3. `Z-*` Issue difficulty. AT MOST ONE ALLOWED.
+
+## Releases
+
+Declaring formal releases remains the prerogative of the project maintainer(s).
+
+## UI tests
+
+UI tests are used for macros to ensure that the output of a macro doesn’t change and is in the expected format. These UI tests are sensible to any changes
+in the macro generated code or to switching the rust stable version. The tests are only run when the `RUN_UI_TESTS` environment variable is set. So, when
+the CI is for example complaining about failing UI tests and it is expected that they fail these tests need to be executed locally. To simplify the updating
+of the UI test output there is the `.maintain/update-rust-stable.sh` script. This can be run with `.maintain/update-rust-stable.sh CURRENT_STABLE_VERSION`
+and then it will run all UI tests to update the expected output.
+
+## Changes to this arrangement
+
+This is an experiment and feedback is welcome! This document may also be subject to pull-requests or changes by contributors where you believe you have something valuable to add or change.
+
+## Heritage
+
+These contributing guidelines are modified from the "OPEN Open Source Project" guidelines for the Level project: https://github.com/Level/community/blob/master/CONTRIBUTING.md
diff --git a/substrate/docs/DOCUMENTATION_GUIDELINES.md b/substrate/docs/DOCUMENTATION_GUIDELINES.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f83f5e6445d5e6606f70dd4e0822ef8ee1e4e0b
--- /dev/null
+++ b/substrate/docs/DOCUMENTATION_GUIDELINES.md
@@ -0,0 +1,264 @@
+# Substrate Documentation Guidelines
+
+This document is only focused on documenting parts of substrate that relates to its external API. The list of such crates can be found in [CODEOWNERS](./CODEOWNERS). Search for the crates that are auto-assigned to a team called `docs-audit`.
+
+These are crates that are often used by external developers and need more thorough documentation. These are the crates most concerned with FRAME development.
+
+- [Substrate Documentation Guidelines](#substrate-documentation-guidelines)
+  - [General/Non-Pallet Crates](#generalnon-pallet-crates)
+    - [What to Document?](#what-to-document)
+      - [Rust Docs vs. Code Comments](#rust-docs-vs-code-comments)
+    - [How to Document?](#how-to-document)
+      - [TLDR](#tldr)
+      - [Proc-Macros](#proc-macros)
+    - [Other Guidelines](#other-guidelines)
+      - [Document Through Code](#document-through-code)
+      - [Formatting Matters](#formatting-matters)
+  - [Pallet Crates](#pallet-crates)
+    - [Top Level Pallet Docs (`lib.rs`)](#top-level-pallet-docs-librs)
+      - [Polkadot and Substrate](#polkadot-and-substrate)
+    - [Dispatchables](#dispatchables)
+    - [Storage Items](#storage-items)
+    - [Errors and Events](#errors-and-events)
+
+
+## General/Non-Pallet Crates
+
+First, consider the case for all such crates, except for those that are pallets.
+
+### What to Document?
+
+The first question is, what should you document? Use the following filter:
+
+1. In the crates assigned to `docs-audit` in [CODEOWNERS](./CODEOWNERS),
+2. All `pub` item need to be documented. If it is not `pub`, it does not appear in the rust-docs, and is not public facing.
+    * Within `pub` items, sometimes they are only `pub` in order to be used by another internal crate, and you can foresee that this will not be used by anyone else other than you. These need **not** be documented thoroughly, and are left to your discretion to identify.
+    * Reminder: `trait` items are public by definition, if the trait is public.
+3. All public modules (`mod`) should have reasonable module-level documentation (`//!`).
+
+
+#### Rust Docs vs. Code Comments
+
+Note that anything starting with `///` is an external rust-doc, and everything starting with `//` does not appear in the rust-docs. It's important to not confuse the two in your documentation.
+
+```rust
+/// Computes the square root of the input, returning `Ok(_)` if successful.
+///
+/// # Errors
+/// ...
+///
+// Details about the complexity, how you implemented this, and some quirks that
+// are NOT relevant to the external interface, so it starts with '//'.
+// This can also be moved inside the function.
+pub fn sqrt(x: u32) -> Result<u32, ()> {
+    todo!();
+}
+```
+
+### How to Document?
+
+There are a few very good sources that you can look into:
+
+- https://doc.rust-lang.org/rustdoc/how-to-write-documentation.html
+- https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/documentation.html
+- https://blog.guillaume-gomez.fr/articles/2020-03-12+Guide+on+how+to+write+documentation+for+a+Rust+crate
+
+As mentioned [here](https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/documentation.html#writing-documentation-comments) and [here](https://blog.guillaume-gomez.fr/articles/2020-03-12+Guide+on+how+to+write+documentation+for+a+Rust+crate), always start with a **single sentence** demonstrating what is being documented. All additional documentation should be added *after a newline*. Strive to make the first sentence succinct and short. The reason for this is the first paragraph of docs about an item (everything before the first newline) is used as the excerpt that rust doc displays about this item when it appears in tables, such as the table listing all functions in a module. If this excerpt is too long, the module docs will be very difficult to read.
+
+About [special sections](https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/documentation.html#special-sections), we will most likely not need to think about panic and safety in any runtime related code. Our code is never `unsafe`, and will (almost) never panic.
+
+Use `# Examples as much as possible. These are great ways to further demonstrate what your APIs are doing, and add free test coverage. As an additional benefit, any code in rust-docs is treated as an "integration tests", not unit tests, which tests your crate in a different way than unit tests. So, it is both a win for "more documentation" and a win for "more test coverage".
+
+You can also consider having an `# Error` section optionally. Of course, this only applies if there is a `Result` being returned, and if the `Error` variants are overly complicated.
+
+Strive to include correct links to other items in your written docs as much as possible. In other words, avoid `` `some_func` `` and instead use ``[`some_func`]``.
+Read more about how to correctly use links in your rust-docs [here](https://doc.rust-lang.org/rustdoc/write-documentation/linking-to-items-by-name.html#valid-links) and [here](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html#additions-to-the-documentation-syntax).
+
+
+> While you are linking, you might become conscious of the fact that you are in need of linking to (too many) foreign items in order to explain your API. This is leaning more towards API-Design rather than documentation, but it is a warning that the subject API might be slightly wrong. For example, most "glue" traits[^1] in `frame/support` should be designed and documented without making hard assumptions about particular pallets that implement them.
+
+#### TLDR
+
+0. Have the goal of enforcing `#![deny(missing_docs)]` mentally, even if it is not enforced by the compiler 🙈.
+1. Start with a single, clear and concise sentence. Follow up with more context, after a newline, if needed.
+2. Use examples as much as reasonably possible.
+3. Use links as much as possible.
+4. Think about context. If you are explaining a lot of foreign topics while documenting a trait that should not explicitly depend on them, you have likely not designed it properly.
+
+#### Proc-Macros
+
+Note that there are special considerations when documenting proc macros. Doc links will appear to function _within_ your proc macro crate, but often will no longer function when these proc macros are re-exported elsewhere in your project. The exception is doc links to _other proc macros_ which will function just fine if they are also being re-exported. It is also often necessary to disambiguate between a proc macro and a function of the same name, which can be done using the `macro@my_macro_name` syntax in your link. Read more about how to correctly use links in your rust-docs [here](https://doc.rust-lang.org/rustdoc/write-documentation/linking-to-items-by-name.html#valid-links) and [here](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html#additions-to-the-documentation-syntax).
+
+
+### Other Guidelines
+
+The above five guidelines must always be reasonably respected in the documentation.
+
+The following are a set of notes that may not necessarily hold in all circumstances:
+
+
+#### Document Through Code
+
+You should make sure that your code is properly-named and well-organized so that your code functions as a form of documentation. However, within the complexity of our projects in Polkadot/Substrate that is not enough. Particularly, things like examples, errors and panics cannot be documented only through properly-named and well-organized code.
+
+> Our north star is self-documenting code that also happens to be well-documented and littered with examples.
+
+
+* Your written documents should *complement* the code, not *repeat* it. As an example, a documentation on top of a code example should never look like the following:
+
+ ```rust
+ /// Sends request and handles the response.
+ trait SendRequestAndHandleResponse {
+
+ }
+ ```
+
+In the above example, the documentation has added no useful information not already contained within the properly-named trait and is redundant.
+
+
+#### Formatting Matters
+
+The way you format your documents (newlines, heading and so on) makes a difference. Consider the below examples:
+
+```rust
+/// This function works with input u32 x and multiplies it by two. If
+/// we optimize the other variant of it, we would be able to achieve more
+/// efficiency but I have to think about it. Probably can panic if the input
+/// overflows u32.
+fn multiply_by_2(x: u32) -> u32 { .. }
+```
+
+```rust
+/// Multiplies an input of type [`u32`] by two.
+///
+/// # Panics
+///
+/// Panics if the input overflows.
+///
+/// # Complexity
+///
+/// Is implemented using some algorithm that yields complexity of O(1).
+// More efficiency can be achieved if we improve this via such and such.
+fn multiply_by_2(x: u32) -> u32 { .. }
+```
+
+They are both roughly conveying the same set of facts, but one is easier to follow because it was formatted cleanly. Especially for traits and types that you can foresee will be seen and used a lot, try and write a well formatted version.
+
+Similarly, make sure your comments are wrapped at 100 characters line-width (as defined by our [`rustfmt.toml`](../rustfmt.toml)), no **more and no less**! The more is fixed by `rustfmt` and our CI, but if you (for some unknown reason) wrap your lines at 59 characters, it will pass the CI, and it will not look good 🫣. Consider using a plugin like [rewrap](https://marketplace.visualstudio.com/items?itemName=stkb.rewrap) (for Visual Studio Code) to properly do this.
+
+[^1]: Those that help two pallets talk to each other.
+
+## Pallet Crates
+
+The guidelines so far have been general in nature, and are applicable to crates that are pallets and crates that're not pallets.
+
+The following is relevant to how to document parts of a crate that is a pallet. See [`pallet-fast-unstake`](../frame/fast-unstake/src/lib.rs) as one examples of adhering these guidelines.
+
+### Top Level Pallet Docs (`lib.rs`)
+
+For the top-level pallet docs, consider the following template:
+
+```
+//! # <Pallet Name>
+//!
+//! <single-liner about the pallet>.
+//!
+//! ## Overview
+//!
+//! <should be high-level details that are relevant to the most broad audience>
+//!
+//! <The audience here is potentially non-coders who just want to know what this pallet does, not how it does it>
+//!
+//! <potentially a few paragraphs, focus on what external folks should know about the pallet>
+//!
+//! ### Example
+//!
+//! <Your pallet must have a few tests that cover important user journeys. Use https://crates.io/crates/docify to reuse these as examples>.
+//!
+//! ## Pallet API
+//!
+//! <Reminder: inside the [`pallet`] module, a template that leads the reader to the relevant items is auto-generated. There is no need to repeat things like "See Config trait for ...", which are generated inside [`pallet`] here anyways. You can use the below line as-is:>
+//!
+//! See the [`pallet`] module for more information about the interfaces this pallet exposes, including its configuration trait, dispatchables, storage items, events and errors.
+//!
+//! <The audience of this is those who want to know how this pallet works, to the extent of being able to build something on top of it, like a DApp or another pallet>
+//!
+//! This section can most often be left as-is.
+//!
+//! ## Low Level / Implementation Details
+//!
+//! <The format of this section is up to you, but we suggest the Design-oriented approach that follows>
+//!
+//! <The audience of this would be your future self, or anyone who wants to gain a deep understanding of how the pallet works so that they can eventually propose optimizations to it>
+//!
+//! ### Design Goals (optional)
+//!
+//! <Describe your goals with the pallet design.>
+//!
+//! ### Design (optional)
+//!
+//! <Describe how you've reached those goals. This should describe the storage layout of your pallet and what was your approach in designing it that way.>
+//!
+//! ### Terminology (optional)
+//!
+//! <Optionally, explain any non-obvious terminology here. You can link to it if you want to use the terminology further up>
+```
+
+This template's details (heading 3s and beyond) are left flexible, and at the discretion of the developer to make the best final choice about. For example, you might want to include `### Terminology` or not. Moreover, you might find it more useful to include it in `## Overview`.
+
+Nonetheless, the high level flow of going from the most high level explanation to the most low level explanation is important to follow.
+
+As a rule of thumb, the Heading 2s (`##`) in this template can be considered a strict rule, while the Heading 3s (`###`) and beyond are flexible.
+
+#### Polkadot and Substrate
+
+Optionally, in order to demonstrate the relation between the two, you can start the pallet documentation with:
+
+```
+//! > Made with *Substrate*, for *Polkadot*.
+//!
+//! [![github]](https://github.com/paritytech/substrate/frame/fast-unstake) -
+//! [![polkadot]](https://polkadot.network)
+//!
+//! [polkadot]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+```
+
+### Dispatchables
+
+For each dispatchable (`fn` item inside `#[pallet::call]`), consider the following template:
+
+```
+/// <One-liner explaining what the dispatchable does>
+///
+/// ## Dispatch Origin
+///
+/// The dispatch origin of this call must be <details (e.g. Root, Signed, Unsigned)>
+///
+/// ## Details
+///
+/// <All other details, namely any errors that could occur within this dispatch and the events this dispatch could emit>
+///
+/// ## Errors (optional)
+///
+/// <If an extensive list of errors can be returned, list them individually instead of mentioning them in the section above>
+///
+/// ## Events (optional)
+///
+/// <Events are akin to the "return type" of dispatchables, optionally mention them>
+pub fn name_of_dispatchable(origin: OriginFor<T>, ...) -> DispatchResult {}
+```
+
+Consider the fact that these docs will be part of the metadata of the associated dispatchable, and might be used by wallets and explorers.
+
+### Storage Items
+
+1. If a map-like type is being used, always note the choice of your hashers as private code docs (`// Hasher X chosen because ...`). Recall that this is not relevant information to external people, so it must be documented as `//`.
+2. Consider explaining the crypto-economics of how a deposit is being taken in return of the storage being used.
+3. Consider explaining why it is safe for the storage item to be unbounded, if `#[pallet::unbounded]` or `#[pallet::without_storage_info]` is being used.
+
+### Errors and Events
+
+Consider the fact that, similar to dispatchables, these docs will be part of the metadata of the associated event/error, and might be used by wallets and explorers.
+
+Specifically for `error`, explain why the error has happened, and what can be done in order to avoid it.
diff --git a/substrate/docs/PULL_REQUEST_TEMPLATE.md b/substrate/docs/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000000000000000000000000000000000000..d2bb22f6e245a31ca7a9392b424a6ef38cc27cbd
--- /dev/null
+++ b/substrate/docs/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,35 @@
+
+
+✄ -----------------------------------------------------------------------------
+
+Thank you for your Pull Request! � Please make sure it follows the contribution guidelines outlined in [this document](https://github.com/paritytech/substrate/blob/master/docs/CONTRIBUTING.md) and fill out the sections below. Once you're ready to submit your PR for review, please delete this section and leave only the text under the "Description" heading.
+
+# Description
+
+*Please include a summary of the changes and the related issue. Please also include relevant motivation and context, including:*
+
+- What does this PR do?
+- Why are these changes needed?
+- How were these changes implemented and what do they affect?
+
+*Use [Github semantic linking](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword) to address any open issues this PR relates to or closes.*
+
+Fixes # (issue number, *if applicable*) 
+
+Closes # (issue number, *if applicable*) 
+
+Polkadot companion: (*if applicable*)
+
+Cumulus companion: (*if applicable*)
+
+# Checklist
+
+- [ ] My PR includes a detailed description as outlined in the "Description" section above
+- [ ] My PR follows the [labeling requirements](https://github.com/paritytech/substrate/blob/master/docs/CONTRIBUTING.md#merge-process) of this project (at minimum one label for each `A`, `B`, `C` and `D` required)
+- [ ] I have made corresponding changes to the documentation (if applicable)
+- [ ] I have added tests that prove my fix is effective or that my feature works (if applicable)
+- [ ] If this PR alters any external APIs or interfaces used by Polkadot, the corresponding Polkadot PR is ready as well as the corresponding Cumulus PR (optional)
+
+You can remove the "Checklist" section once all have been checked. Thank you for your contribution!
+
+✄ -----------------------------------------------------------------------------
diff --git a/substrate/docs/README.adoc b/substrate/docs/README.adoc
new file mode 100644
index 0000000000000000000000000000000000000000..3537e346a66e1697004f2e114491c03b51ffd356
--- /dev/null
+++ b/substrate/docs/README.adoc
@@ -0,0 +1,522 @@
+= Substrate
+:Author: Substrate developers
+:Revision: 0.2.0
+:toc:
+:sectnums:
+
+== Intro in one sentence
+
+Substrate is a next-generation framework for blockchain innovation.
+
+== Description
+
+At its heart, Substrate is a combination of three technologies: https://webassembly.org/[WebAssembly], https://libp2p.io/[Libp2p] and GRANDPA Consensus. About GRANDPA, see this https://hackmd.io/Jd0byWX0RiqFiXUVC78Bdw?view#GRANDPA[definition], https://medium.com/polkadot-network/grandpa-block-finality-in-polkadot-an-introduction-part-1-d08a24a021b5[introduction] and https://github.com/w3f/consensus/blob/master/pdf/grandpa.pdf[formal specification]. It is both a library for building new blockchains and a "skeleton key" of a blockchain client, able to synchronize to any Substrate-based chain.
+
+Substrate chains have three distinct features that make them "next-generation": a dynamic, self-defining state-transition function; light-client functionality from day one; and a progressive consensus algorithm with fast block production and adaptive, definite finality. The STF, encoded in WebAssembly, is known as the "runtime". This defines the `execute_block` function, and can specify everything from the staking algorithm, transaction semantics, logging mechanisms and procedures for replacing any aspect of itself or of the blockchain's state ("governance"). Because the runtime is entirely dynamic all of these can be switched out or upgraded at any time. A Substrate chain is very much a "living organism".
+
+See also https://www.parity.io/what-is-substrate/.
+
+== Usage
+
+Substrate is still an early stage project, and while it has already been used as the basis of major projects like Polkadot, using it is still a significant undertaking. In particular, you should have a good knowledge of blockchain concepts and basic cryptography. Terminology like header, block, client, hash, transaction and signature should be familiar. At present you will need a working knowledge of Rust to be able to do anything interesting (though eventually, we aim for this not to be the case).
+
+Substrate is designed for use in one of three ways:
+
+**1. Trivial**: By running the Substrate binary `substrate` and configuring it with a genesis block that includes the current demonstration runtime. In this case, you just build Substrate, configure a JSON file, and launch your own blockchain. This affords you the least amount of customizability, primarily allowing you to change the genesis parameters of the various included runtime modules such as balances, staking, block-period, fees, and governance.
+
+**2. Modular**: By hacking together pallets built with Substrate FRAME into a new runtime and possibly altering or reconfiguring the Substrate client's block authoring logic. This affords you a very large amount of freedom over your blockchain's logic, letting you change data types, add or remove modules, and crucially, add your own modules. Much can be changed without touching the block authoring logic (since it is generic). If this is the case, then the existing Substrate binary can be used for block authoring and syncing. If the block authoring logic needs to be tweaked, then a new, altered block authoring binary must be built as a separate project and used by validators. This is how the Polkadot relay chain is built and should suffice for almost all circumstances in the near to mid-term.
+
+**3. Generic**: The entire FRAME can be ignored and the entire runtime designed and implemented from scratch. If desired, this can be done in a language other than Rust, provided it can target WebAssembly. If the runtime can be made compatible with the existing client's block authoring logic, then you can simply construct a new genesis block from your Wasm blob and launch your chain with the existing Rust-based Substrate client. If not, then you'll need to alter the client's block authoring logic accordingly. This is probably a useless option for most projects right now, but provides complete flexibility allowing for a long-term, far-reaching upgrade path for the Substrate paradigm.
+
+=== The Basics of Substrate
+
+Substrate is a blockchain platform with a completely generic state transition function. That said, it does come with both standards and conventions (particularly regarding the Runtime Module Library) regarding underlying data structures. Roughly speaking, these core data types correspond to +trait+s in terms of the actual non-negotiable standard and generic +struct+s in terms of the convention.
+
+```
+Header := Parent + ExtrinsicsRoot + StorageRoot + Digest
+Block := Header + Extrinsics + Justifications
+```
+
+=== Extrinsics
+
+Extrinsics in Substrate are pieces of information from "the outside world" that are contained in the blocks of the chain. You might think "ahh, that means *transactions*": in fact, no. Extrinsics fall into two broad categories of which only one is *transactions*. The other is known as *inherents*. The difference between these two is that transactions are signed and gossiped on the network and can be deemed useful *per se*. This fits the mold of what you would call transactions in Bitcoin or Ethereum.
+
+Inherents, meanwhile, are not passed on the network and are not signed. They represent data which describes the environment but which cannot call upon anything to prove it such as a signature. Rather they are assumed to be "true" simply because a sufficiently large number of validators have agreed on them being reasonable.
+
+To give an example, there is the timestamp inherent, which sets the current timestamp of the block. This is not a fixed part of Substrate, but does come as part of FRAME to be used as desired. No signature could fundamentally prove that a block were authored at a given time in quite the same way that a signature can "prove" the desire to spend some particular funds. Rather, it is the business of each validator to ensure that they believe the timestamp is set to something reasonable before they agree that the block candidate is valid.
+
+Other examples include the parachain-heads extrinsic in Polkadot and the "note-missed-proposal" extrinsic used in FRAME to determine and punish or deactivate offline validators.
+
+
+=== Runtime and API
+
+Substrate chains all have a runtime. The runtime is a WebAssembly "blob" that includes a number of entry-points. Some entry-points are required as part of the underlying Substrate specification. Others are merely convention and required for the default implementation of the Substrate client to be able to author blocks.
+
+If you want to develop a chain with Substrate, you will need to implement the `Core` trait. This `Core` trait generates an API with the minimum necessary functionality to interact with your runtime. A special macro is provided called `impl_runtime_apis!` that help you implement runtime API traits. All runtime API trait implementations need to be done in one call of the `impl_runtime_apis!` macro. All parameters and return values need to implement https://crates.io/crates/parity-codec[`parity-codec`] to be encodable and decodable.
+
+Here's a snippet of the Polkadot API implementation as of PoC-3:
+
+```rust
+impl_runtime_apis! {
+	impl client_api::Core<Block> for Runtime {
+		fn version() -> RuntimeVersion {
+			VERSION
+		}
+
+		fn execute_block(block: Block) {
+			Executive::execute_block(block)
+		}
+
+		fn initialize_block(header: <Block as BlockT>::Header) {
+			Executive::initialize_block(&header)
+		}
+	}
+	// ---snip---
+}
+```
+
+
+=== Inherent Extrinsics
+
+Substrate FRAME includes functionality for timestamps and slashing. If used, these rely on "trusted" external information being passed in via inherent extrinsics. The Substrate reference block authoring client software will expect to be able to call into the runtime API with collated data (in the case of the reference Substrate authoring client, this is merely the current timestamp and which nodes were offline) in order to return the appropriate extrinsics ready for inclusion. If new inherent extrinsic types and data are to be used in a modified runtime, then it is this function (and its argument type) that would change.
+
+=== Block-authoring Logic
+
+In Substrate, there is a major distinction between blockchain *syncing* and block *authoring* ("authoring" is a more general term for what is called "mining" in Bitcoin). The first case might be referred to as a "full node" (or "light node" - Substrate supports both): authoring necessarily requires a synced node and, therefore, all authoring clients must necessarily be able to synchronize. However, the reverse is not true. The primary functionality that authoring nodes have which is not in "sync nodes" is threefold: transaction queue logic, inherent transaction knowledge and BFT consensus logic. BFT consensus logic is provided as a core element of Substrate and can be ignored since it is only exposed in the SDK under the `authorities()` API entry.
+
+Transaction queue logic in Substrate is designed to be as generic as possible, allowing a runtime to express which transactions are fit for inclusion in a block through the `initialize_block` and `apply_extrinsic` calls. However, more subtle aspects like prioritization and replacement policy must currently be expressed "hard coded" as part of the blockchain's authoring code. That said, Substrate's reference implementation for a transaction queue should be sufficient for an initial chain implementation.
+
+Inherent extrinsic knowledge is again somewhat generic, and the actual construction of the extrinsics is, by convention, delegated to the "soft code" in the runtime. If ever there needs to be additional extrinsic information in the chain, then both the block authoring logic will need to be altered to provide it into the runtime and the runtime's `inherent_extrinsics` call will need to use this extra information in order to construct any additional extrinsic transactions for inclusion in the block.
+
+== Roadmap
+
+=== So far
+
+- 0.1 "PoC-1": PBFT consensus, Wasm runtime engine, basic runtime modules.
+- 0.2 "PoC-2": Libp2p
+
+=== In progress
+
+- AfG consensus
+- Improved PoS
+- Smart contract runtime module
+
+=== The future
+
+- Splitting out runtime modules into separate repo
+- Introduce substrate executable (the skeleton-key runtime)
+- Introduce basic but extensible transaction queue and block-builder and place them in the executable.
+- DAO runtime module
+- Audit
+
+== Trying out Substrate Node
+
+Substrate Node is Substrate's pre-baked blockchain client. You can run a development node locally or configure a new chain and launch your own global testnet.
+
+=== On Mac and Ubuntu
+
+To get going as fast as possible, there is a simple script that installs all required dependencies and installs Substrate into your path. Just open a terminal and run:
+
+[source, shell]
+----
+curl https://getsubstrate.io -sSf | bash
+----
+
+You can start a local Substrate development chain with running `substrate --dev`.
+
+To create your own global network/cryptocurrency, you'll need to make a new Substrate Node chain specification file ("chainspec").
+
+First let's get a template chainspec that you can edit. We'll use the "staging" chain, a sort of default chain that the node comes pre-configured with:
+
+[source, shell]
+----
+substrate build-spec --chain=staging > ~/chainspec.json
+----
+
+Now, edit `~/chainspec.json` in your editor. There are a lot of individual fields for each module, and one very large one which contains the WebAssembly code blob for this chain. The easiest field to edit is the block `period`. Change it to 10 (seconds):
+
+[source, json]
+----
+     "timestamp": {
+        "minimumPeriod": 10
+      },
+----
+
+Now with this new chainspec file, you can build a "raw" chain definition for your new chain:
+
+[source, shell]
+----
+substrate build-spec --chain ~/chainspec.json --raw > ~/mychain.json
+----
+
+This can be fed into Substrate:
+
+[source, shell]
+----
+substrate --chain ~/mychain.json
+----
+
+It won't do much until you start producing blocks though, so to do that you'll need to use the `--validator` option together with passing the seed for the account(s) that is configured to be the initial authorities:
+
+[source, shell]
+----
+substrate --chain ~/mychain.json --validator
+----
+
+You can distribute `mychain.json` so that everyone can synchronize and (depending on your authorities list) validate on your chain.
+
+
+== Building
+
+=== Hacking on Substrate
+
+If you'd actually like to hack on Substrate, you can just grab the source code and
+build it. Ensure you have Rust and the support software installed:
+
+==== Linux and Mac
+
+For Unix-based operating systems, you should run the following commands:
+
+[source, shell]
+----
+curl https://sh.rustup.rs -sSf | sh
+
+rustup update nightly
+rustup target add wasm32-unknown-unknown --toolchain nightly
+rustup update stable
+----
+
+You will also need to install the following packages:
+
+ - Linux:
+[source, shell]
+sudo apt install cmake pkg-config libssl-dev git clang libclang-dev llvm
+
+- Linux on ARM:
+`rust-lld` is required for linking wasm, but is missing on non Tier 1 platforms.
+So, use this https://github.com/Plume-org/Plume/blob/master/script/wasm-deps.sh[script]
+to build `lld` and create the symlink `/usr/bin/rust-lld` to the build binary.
+
+ - Mac:
+[source, shell]
+brew install cmake pkg-config openssl git llvm
+
+To finish installation of Substrate, jump down to <<shared-steps,shared steps>>.
+
+==== Windows
+
+If you are trying to set up Substrate on Windows, you should do the following:
+
+1. First, you will need to download and install "Build Tools for Visual Studio:"
+
+    * You can get it at this link: https://aka.ms/buildtools
+    * Run the installation file: `vs_buildtools.exe`
+    * Please ensure the Windows 10 SDK component is included when installing the Visual C++ Build Tools.
+    * image:https://i.imgur.com/zayVLmu.png[image]
+    * Restart your computer.
+
+2. Next, you need to install Rust:
+
+    * Detailed instructions are provided by the https://doc.rust-lang.org/book/ch01-01-installation.html#installing-rustup-on-windows[Rust Book].
+        * Download from: https://www.rust-lang.org/tools/install
+        * Run the installation file: `rustup-init.exe`
+        > Note that it should not prompt you to install vs_buildtools since you did it in step 1.
+        * Choose "Default Installation."
+        * To get started, you need Cargo's bin directory (%USERPROFILE%\.cargo\bin) in your PATH environment variable. Future applications will automatically have the correct environment, but you may need to restart your current shell.
+
+3. Then, you will need to run some commands in CMD to set up your Wasm Build Environment:
+
+	rustup update nightly
+	rustup update stable
+	rustup target add wasm32-unknown-unknown --toolchain nightly
+
+4. Then, you need to install LLVM: https://releases.llvm.org/download.html
+
+5. Next, you need to install OpenSSL, which we will do with `vcpkg`:
+
+	mkdir \Tools
+	cd \Tools
+	git clone https://github.com/Microsoft/vcpkg.git
+	cd vcpkg
+	.\bootstrap-vcpkg.bat
+	.\vcpkg.exe install openssl:x64-windows-static
+
+6. After, you need to add OpenSSL to your System Variables. Note that in order for the following commands to work, you need to use Windows Powershell:
+
+	$env:OPENSSL_DIR = 'C:\Tools\vcpkg\installed\x64-windows-static'
+	$env:OPENSSL_STATIC = 'Yes'
+	[System.Environment]::SetEnvironmentVariable('OPENSSL_DIR', $env:OPENSSL_DIR, [System.EnvironmentVariableTarget]::User)
+	[System.Environment]::SetEnvironmentVariable('OPENSSL_STATIC', $env:OPENSSL_STATIC, [System.EnvironmentVariableTarget]::User)
+
+7. Finally, you need to install `cmake`: https://cmake.org/download/
+
+==== Docker
+
+You can use https://github.com/paritytech/scripts/tree/master/dockerfiles/ci-linux[Parity CI docker image] with all necessary dependencies to build Substrate:
+
+[source, shell]
+----
+#run it in the folder with the Substrate source code
+docker run --rm -it -w /shellhere/substrate \
+                    -v $(pwd):/shellhere/substrate \
+                    paritytech/ci-linux:production <cargo commands>
+----
+
+You can find necessary cargo commands in <<shared-steps,shared steps>>
+
+==== Shared Steps
+
+Then, grab the Substrate source code:
+
+[source, shell]
+----
+git clone https://github.com/paritytech/substrate.git
+cd substrate
+----
+
+Then build the code:
+
+[source, shell]
+----
+cargo build                 # Builds all native code
+----
+
+You can run all the tests if you like:
+
+[source, shell]
+cargo test --all
+
+Or just run the tests of a specific package (i.e. `cargo test -p pallet-assets`)
+
+You can start a development chain with:
+
+[source, shell]
+cargo run --release -- --dev
+
+Detailed logs may be shown by running the node with the following environment variables set: `RUST_LOG=debug RUST_BACKTRACE=1 cargo run --release \-- --dev`.
+
+If you want to see the multi-node consensus algorithm in action locally, then you can create a local testnet with two validator nodes for Alice and Bob, who are the initial authorities of the genesis chain specification that have been endowed with a testnet DOTs. We'll give each node a name and expose them so they are listed on link:https://telemetry.polkadot.io/#/Local%20Testnet[Telemetry]. You'll need two terminal windows open.
+
+We'll start Alice's Substrate node first on default TCP port 30333 with their chain database stored locally at `/tmp/alice`. The Bootnode ID of Alice's node is `QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR`, which is generated from the `--node-key` value that we specify below:
+
+[source, shell]
+cargo run --release \-- \
+  --base-path /tmp/alice \
+  --chain=local \
+  --alice \
+  --node-key 0000000000000000000000000000000000000000000000000000000000000001 \
+  --telemetry-url 'ws://telemetry.polkadot.io:1024 0' \
+  --validator
+
+In the second terminal, we'll run the following to start Bob's Substrate node on a different TCP port of 30334, and with their chain database stored locally at `/tmp/bob`. We'll specify a value for the `--bootnodes` option that will connect Bob's node to Alice's Bootnode ID on TCP port 30333:
+
+[source, shell]
+cargo run --release \-- \
+  --base-path /tmp/bob \
+  --bootnodes /ip4/127.0.0.1/tcp/30333/p2p/QmRpheLN4JWdAnY7HGJfWFNbfkQCb6tFf4vvA6hgjMZKrR \
+  --chain=local \
+  --bob \
+  --port 30334 \
+  --telemetry-url 'ws://telemetry.polkadot.io:1024 0' \
+  --validator
+
+Additional Substrate CLI usage options are available and may be shown by running `cargo run \-- --help`.
+
+[[flaming-fir]]
+=== Joining the Flaming Fir Testnet
+
+Flaming Fir is the new testnet for Substrate master (2.0) to test the latest development features. Please note that master is not compatible with the BBQ Birch, Charred Cherry, Dried Danta or Emberic Elm testnets. Ensure you have the dependencies listed above before compiling.
+
+Since Flaming Fir is targeting the master branch we make absolutely no guarantees of stability and/or persistence of the network. We might reset the chain at any time if it is necessary to deploy new changes. Currently, the validators are running with a client built from `d013bd900`, if you build from this commit you should be able to successfully sync, later commits may not work as new breaking changes may be introduced in master.
+
+Latest known working version: `a2a0eb5398d6223e531455b4c155ef053a4a3a2b`
+
+[source, shell]
+----
+git clone https://github.com/paritytech/substrate.git
+cd substrate
+git checkout -b flaming-fir a2a0eb5398d6223e531455b4c155ef053a4a3a2b
+----
+
+You can run the tests if you like:
+
+[source, shell]
+cargo test --all
+
+Start your node:
+
+[source, shell]
+cargo run --release \--
+
+To see a list of command line options, enter:
+
+[source, shell]
+cargo run --release \-- --help
+
+For example, you can choose a custom node name:
+
+[source, shell]
+cargo run --release \-- --name my_custom_name
+
+If you are successful, you will see your node syncing at https://telemetry.polkadot.io/#/Flaming%20Fir
+
+=== Joining the Emberic Elm Testnet
+
+Emberic Elm is the testnet for Substrate 1.0. Please note that 1.0 is not compatible with the BBQ Birch, Charred Cherry, Dried Danta or Flaming Fir testnets.
+In order to join the Emberic Elm testnet you should build from the `v1.0` branch. Ensure you have the dependencies listed above before compiling.
+
+[source, shell]
+----
+git clone https://github.com/paritytech/substrate.git
+cd substrate
+git checkout -b v1.0 origin/v1.0
+----
+
+You can then follow the same steps for building and running as described above in <<flaming-fir>>.
+
+== Key management
+
+Keys in Substrate are stored in the keystore in the file system. To store keys into this keystore,
+you need to use one of the two provided RPC calls. If your keys are encrypted or should be encrypted
+by the keystore, you need to provide the key using one of the cli arguments `--password`,
+`--password-interactive` or `--password-filename`.
+
+=== Recommended RPC call
+
+For most users who want to run a validator node, the `author_rotateKeys` RPC call is sufficient.
+The RPC call will generate `N` Session keys for you and return their public keys. `N` is the number
+of session keys configured in the runtime. The output of the RPC call can be used as input for the
+`session::set_keys` transaction.
+
+```
+curl -H 'Content-Type: application/json' --data '{ "jsonrpc":"2.0", "method":"author_rotateKeys", "id":1 }' localhost:9933
+```
+
+=== Advanced RPC call
+
+If the Session keys need to match a fixed seed, they can be set individually key by key. The RPC call
+expects the key seed and the key type. The key types supported by default in Substrate are listed
+https://github.com/paritytech/substrate/blob/master/core/primitives/src/crypto.rs#L767[here], but the
+user can declare any key type.
+
+```
+curl -H 'Content-Type: application/json' --data '{ "jsonrpc":"2.0", "method":"author_insertKey", "params":["KEY_TYPE", "SEED", "PUBLIC"],"id":1 }' localhost:9933
+```
+
+`KEY_TYPE` - needs to be replaced with the 4-character key type identifier.
+`SEED` - is the seed of the key.
+`PUBLIC` - public key for the given key.
+
+== Documentation
+
+=== Viewing documentation for Substrate packages
+
+You can generate documentation for a Substrate Rust package and have it automatically open in your web browser using https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html#using-rustdoc-with-cargo[rustdoc with Cargo],
+(of the The Rustdoc Book), by running the following command:
+
+```
+cargo doc --package <spec> --open
+```
+
+Replacing `<spec>` with one of the following (i.e. `cargo doc --package substrate --open`):
+
+* All Substrate Packages
+[source, shell]
+substrate
+* Substrate Core
+[source, shell]
+substrate, substrate-cli, substrate-client, substrate-client-db,
+substrate-consensus-common, substrate-consensus-rhd,
+substrate-executor, substrate-finality-grandpa, substrate-keyring, substrate-keystore, substrate-network,
+substrate-network-libp2p, substrate-primitives, substrate-rpc, substrate-rpc-servers,
+substrate-serializer, substrate-service, substrate-service-test, substrate-state-db,
+substrate-state-machine, substrate-telemetry, substrate-test-client,
+substrate-test-runtime, substrate-transaction-graph, sp-transaction-pool,
+substrate-trie
+* Substrate Runtime
+[source, shell]
+sr-api, sr-io, sr-primitives, sr-sandbox, sr-std, sr-version
+* FRAME Core
+[source, shell]
+frame-metadata, frame-support, frame-system
+* FRAME Pallets
+[source, shell]
+pallet-assets, pallet-balances, pallet-consensus, pallet-contracts, pallet-council, pallet-democracy, pallet-example,
+frame-executive,  pallet-session, pallet-staking, pallet-timestamp, pallet-treasury
+* Node
+[source, shell]
+node-cli, node-consensus, node-executor, node-network, node-primitives, kitchensink-runtime
+* Subkey
+[source, shell]
+subkey
+
+=== Contributing to documentation for Substrate packages
+
+https://doc.rust-lang.org/1.9.0/book/documentation.html[Document source code] for Substrate packages by annotating the source code with documentation comments.
+
+Example (generic):
+```markdown
+/// Summary
+///
+/// Description
+///
+/// # Panics
+///
+/// # Errors
+///
+/// # Safety
+///
+/// # Examples
+///
+/// Summary of Example 1
+///
+/// ```rust
+/// // insert example 1 code here
+/// ```
+///
+```
+
+* Important notes:
+** Documentation comments must use annotations with a triple slash `///`
+** Modules are documented using `//!`
+```
+//! Summary (of module)
+//!
+//! Description (of module)
+```
+* Special section header is indicated with a hash `#`.
+** `Panics` section requires an explanation if the function triggers a panic
+** `Errors` section is for describing conditions under which a function of method returns `Err(E)` if it returns a `Result<T, E>`
+** `Safety` section requires an explanation if the function is `unsafe`
+** `Examples` section includes examples of using the function or method
+* Code block annotations for examples are included between triple graves, as shown above.
+Instead of including the programming language to use for syntax highlighting as the annotation
+after the triple graves, alternative annotations include the `ignore`, `text`, `should_panic`, or `no_run`.
+* Summary sentence is a short high level single sentence of its functionality
+* Description paragraph is for details additional to the summary sentence
+* Missing documentation annotations may be used to identify where to generate warnings with `#![warn(missing_docs)]`
+or errors `#![deny(missing_docs)]`
+* Hide documentation for items with `#[doc(hidden)]`
+
+=== Contributing to documentation (tests, extended examples, macros) for Substrate packages
+
+The code block annotations in the `# Example` section may be used as https://doc.rust-lang.org/1.9.0/book/documentation.html#documentation-as-tests[documentation as tests and for extended examples].
+
+* Important notes:
+** Rustdoc will automatically add a `main()` wrapper around the code block to test it
+** https://doc.rust-lang.org/1.9.0/book/documentation.html#documenting-macros[Documenting macros].
+** Documentation as tests examples are included when running `cargo test`
+
+== Contributing
+
+=== Contributing Guidelines
+
+include::CONTRIBUTING.md[]
+
+=== Contributor Code of Conduct
+
+include::CODE_OF_CONDUCT.md[]
+
+== License
+
+https://github.com/paritytech/substrate/blob/master/LICENSE[LICENSE]
diff --git a/substrate/docs/SECURITY.md b/substrate/docs/SECURITY.md
new file mode 100644
index 0000000000000000000000000000000000000000..19f5b145feb5eb30447c0f8755aa19cabb081570
--- /dev/null
+++ b/substrate/docs/SECURITY.md
@@ -0,0 +1,102 @@
+<!-- markdown-link-check-disable -->
+# Security Policy
+
+Parity Technologies is committed to resolving security vulnerabilities in our software quickly and carefully. We take the necessary steps to minimize risk, provide timely information, and deliver vulnerability fixes and mitigations required to address security issues.
+
+## Reporting a Vulnerability
+
+Security vulnerabilities in Parity software should be reported by email to security@parity.io. If you think your report might be eligible for the Parity Bug Bounty Program, your email should be send to bugbounty@parity.io.
+
+Your report should include the following:
+
+- your name
+- description of the vulnerability
+- attack scenario (if any)
+- components
+- reproduction
+- other details
+
+Try to include as much information in your report as you can, including a description of the vulnerability, its potential impact, and steps for reproducing it. Be sure to use a descriptive subject line.
+
+You'll receive a response to your email within two business days indicating the next steps in handling your report. We encourage finders to use encrypted communication channels to protect the confidentiality of vulnerability reports. You can encrypt your report using our public key. This key is [on MIT's key server](https://pgp.mit.edu/pks/lookup?op=get&search=0x5D0F03018D07DE73) server and reproduced below.
+
+After the initial reply to your report, our team will endeavor to keep you informed of the progress being made towards a fix. These updates will be sent at least every five business days.
+
+Thank you for taking the time to responsibly disclose any vulnerabilities you find.
+
+## Responsible Investigation and Reporting
+
+Responsible investigation and reporting includes, but isn't limited to, the following:
+
+- Don't violate the privacy of other users, destroy data, etc.
+- Don’t defraud or harm Parity Technologies Ltd or its users during your research; you should make a good faith effort to not interrupt or degrade our services.
+- Don't target our physical security measures, or attempt to use social engineering, spam, distributed denial of service (DDOS) attacks, etc.
+- Initially report the bug only to us and not to anyone else.
+- Give us a reasonable amount of time to fix the bug before disclosing it to anyone else, and give us adequate written warning before disclosing it to anyone else.
+- In general, please investigate and report bugs in a way that makes a reasonable, good faith effort not to be disruptive or harmful to us or our users. Otherwise your actions might be interpreted as an attack rather than an effort to be helpful.
+
+## Bug Bounty Program
+
+Our Bug Bounty Program allows us to recognize and reward members of the Parity community for helping us find and address significant bugs, in accordance with the terms of the Parity Bug Bounty Program. A detailed description on eligibility, rewards, legal information and terms & conditions for contributors can be found on [our website](https://paritytech.io/bug-bounty.html).
+
+
+
+
+
+
+## Plaintext PGP Key
+
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=yKcB
+-----END PGP PUBLIC KEY BLOCK-----
+```
diff --git a/substrate/docs/STYLE_GUIDE.md b/substrate/docs/STYLE_GUIDE.md
new file mode 100644
index 0000000000000000000000000000000000000000..a89dcf52ffc0b7778cd3b2257b8470b307ae9c6e
--- /dev/null
+++ b/substrate/docs/STYLE_GUIDE.md
@@ -0,0 +1,172 @@
+---
+title: Style Guide for Rust in Substrate
+---
+
+Where possible these styles are enforced by settings in `rustfmt.toml` so if you run `cargo fmt` 
+then you will adhere to most of these style guidelines automatically.
+
+# Code Formatting
+
+-   Indent using tabs.
+-   Lines should be longer than 100 characters long only in exceptional circumstances and certainly
+    no longer than 120. For this purpose, tabs are considered 4 characters wide.
+-   Indent levels should be greater than 5 only in exceptional circumstances and certainly no
+    greater than 8. If they are greater than 5, then consider using `let` or auxiliary functions in
+    order to strip out complex inline expressions.
+-   Never have spaces on a line prior to a non-whitespace character
+-   Follow-on lines are only ever a single indent from the original line.
+
+```rust
+fn calculation(some_long_variable_a: i8, some_long_variable_b: i8) -> bool {
+	let x = some_long_variable_a * some_long_variable_b
+		- some_long_variable_b / some_long_variable_a
+		+ sqrt(some_long_variable_a) - sqrt(some_long_variable_b);
+	x > 10
+}
+```
+
+-   Indent level should follow open parens/brackets, but should be collapsed to the smallest number
+    of levels actually used:
+
+```rust
+fn calculate(
+	some_long_variable_a: f32,
+	some_long_variable_b: f32,
+	some_long_variable_c: f32,
+) -> f32 {
+	(-some_long_variable_b + sqrt(
+		// two parens open, but since we open & close them both on the
+		// same line, only one indent level is used
+		some_long_variable_b * some_long_variable_b
+		- 4 * some_long_variable_a * some_long_variable_c
+	// both closed here at beginning of line, so back to the original indent
+	// level
+	)) / (2 * some_long_variable_a)
+}
+```
+
+-   `where` is indented, and its items are indented one further.
+-   Argument lists or function invocations that are too long to fit on one line are indented
+    similarly to code blocks, and once one param is indented in such a way, all others should be,
+    too. Run-on parameter lists are also acceptable for single-line run-ons of basic function calls.
+
+```rust
+// OK
+fn foo(
+	really_long_parameter_name_1: SomeLongTypeName,
+	really_long_parameter_name_2: SomeLongTypeName,
+	shrt_nm_1: u8,
+	shrt_nm_2: u8,
+) {
+   ...
+}
+
+// NOT OK
+fn foo(really_long_parameter_name_1: SomeLongTypeName, really_long_parameter_name_2: SomeLongTypeName,
+	shrt_nm_1: u8, shrt_nm_2: u8) {
+	...
+}
+```
+
+```rust
+{
+	// Complex line (not just a function call, also a let statement). Full
+	// structure.
+	let (a, b) = bar(
+		really_long_parameter_name_1,
+		really_long_parameter_name_2,
+		shrt_nm_1,
+		shrt_nm_2,
+	);
+
+	// Long, simple function call.
+	waz(
+		really_long_parameter_name_1,
+		really_long_parameter_name_2,
+		shrt_nm_1,
+		shrt_nm_2,
+	);
+
+	// Short function call. Inline.
+	baz(a, b);
+}
+```
+
+-   Always end last item of a multi-line comma-delimited set with `,` when legal:
+
+```rust
+struct Point<T> {
+	x: T,
+	y: T,    // <-- Multiline comma-delimited lists end with a trailing ,
+}
+
+// Single line comma-delimited items do not have a trailing `,`
+enum Meal { Breakfast, Lunch, Dinner };
+```
+
+-   Avoid trailing `;`s where unneeded.
+
+```rust
+if condition {
+	return 1    // <-- no ; here
+}
+```
+
+-   `match` arms may be either blocks or have a trailing `,` but not both.
+-   Blocks should not be used unnecessarily.
+
+```rust
+match meal {
+	Meal::Breakfast => "eggs",
+	Meal::Lunch => { check_diet(); recipe() },
+//	Meal::Dinner => { return Err("Fasting") }   // WRONG
+	Meal::Dinner => return Err("Fasting"),
+}
+```
+
+# Style
+
+-   Panickers require explicit proofs they don't trigger. Calling `unwrap` is discouraged. The
+    exception to this rule is test code. Avoiding panickers by restructuring code is preferred if
+    feasible.
+
+```rust
+let mut target_path =
+	self.path().expect(
+		"self is instance of DiskDirectory;\
+		DiskDirectory always returns path;\
+		qed"
+	);
+```
+
+-   Unsafe code requires explicit proofs just as panickers do. When introducing unsafe code,
+    consider trade-offs between efficiency on one hand and reliability, maintenance costs, and
+    security on the other. Here is a list of questions that may help evaluating the trade-off while
+    preparing or reviewing a PR:
+    -   how much more performant or compact the resulting code will be using unsafe code,
+    -   how likely is it that invariants could be violated,
+    -   are issues stemming from the use of unsafe code caught by existing tests/tooling,
+    -   what are the consequences if the problems slip into production.
+
+# Manifest Formatting
+
+> **TLDR**
+> You can use the CLI tool [Zepter](https://crates.io/crates/zepter) to format the files: `zepter format features`
+
+Rust `Cargo.toml` files need to respect certain formatting rules. All entries need to be alphabetically sorted. This makes it easier to read them and insert new entries. The exhaustive list of rules is enforced by the CI. The general format looks like this:
+
+- The feature is written as a single line if it fits within 80 chars:
+```toml
+[features]
+default = [ "std" ]
+```
+
+- Otherwise the feature is broken down into multiple lines with one entry per line. Each line is padded with one tab and no trailing spaces but a trailing comma.
+```toml
+[features]
+default = [
+	"loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong",
+	# Comments go here as well ;)
+	"std",
+]
+```
diff --git a/substrate/docs/Structure.adoc b/substrate/docs/Structure.adoc
new file mode 100644
index 0000000000000000000000000000000000000000..6c810a83c51b91367203ba67b532935e36c85146
--- /dev/null
+++ b/substrate/docs/Structure.adoc
@@ -0,0 +1,121 @@
+= Structure
+:Author: Substrate developers
+:Revision: 0.3.0
+:toc:
+:sectnums:
+
+
+== Overview
+
+Substrate is split into multiple levels with increasing opinion and decreasing flexibility:
+
+* primitives
+* client
+* FRAME (formerly `srml`)
+
+Putting all these components together we have:
+
+* Integration Tests
+* Node
+* Node template
+* Subkey
+
+=== Runtime
+
+* _found in_: `/primitives`
+* _crates prefix_: `sp-`
+* _constraints_:
+** must be `[no_std]`
+** crates may not (dev-)depend on crates in other subfolders of this repo
+
+In the lowest level, Substrate defines primitives, interfaces and traits to implement any on-chain Substrate transition system and its interactions with the outside world. This is the lowest level of abstraction and opinion that everything else builds upon.
+
+=== Client
+
+* _found in_: `/client`
+* _crates prefix_: `sc-`
+* _constraints_:
+** crates may not (dev-)depend on any `frame-`-crates
+
+In the client you can find a set of crates to construct the outer substrate-node, implementing outer runtime interfaces, thus it depends on `runtime`. It provides the outer building blocks like transaction queue, networking layer, database backend, full* and light-client support.
+
+=== FRAME (formerly `srml`)
+
+* _found in_: `/frame`
+* _crates prefix_: `frame-` and `pallet-`
+* _constraints_:
+** all crates that go on chain must be `[no_std]`
+** must not (dev-)depend on anything in `/client`
+
+FRAME is a set of modules that implement specific transition functions and features one might want to have in their runtime.
+
+_Pallets_ are individual modules within _FRAME._ These are containers that host domain-specific logic. They have the `pallet-` prefix. For example, `pallet-staking` contains logic for staking tokens.
+
+There are a few crates with the `frame-` prefix. These do not contain domain-specific logic. Rather, they are the main FRAME support infrastructure. These are:
+
+- Executive
+- Metadata
+- Support
+- System
+- Utility
+
+=== Integration Tests
+
+* _found in_: `/test`
+* _crates prefix_: `substrate-test`
+* _constraints_:
+** only helpers may be published
+** purely testing crates must be `publish = false`
+
+All tests that have to pull (dev)-dependencies out of their subtree and would thus break the dependency rules are considered integration tests and should be stored in here. Only helper-crates in here shall be published, everything else is expected to be non-publish.
+
+=== Binaries and template
+
+* _found in_: `/bin`
+
+We also provide some binaries pulling from the components creating full applications.
+
+==== Node
+
+* _found in_: `/bin/node`
+
+The default (testing) application pulling together our recommended setup of substrate-client with a wasm-contracts-supporting frame-runtime.  The node pulls it all together, constructs the (upgradable) runtime, and wires up the client around it. You can find an example client, which includes a full wasm-contracts chain in  `node`. This is also what is being built and run if you do `cargo run`.
+
+==== Node Template
+
+* _found in_: `/bin/node-template`
+
+We also provide a template to get you started building your own node.
+
+==== Utils
+
+* _found in_: `/bin/utils`
+
+- **subkey**
+  Subkey is a client library to generate keys and sign transactions to send to a substrate node.
+- **chain-spec-builder**
+  The chain spec builder builds a chain specification that includes a Substrate runtime compiled as WASM. To ensure proper functioning of the included runtime compile (or run) the chain spec builder binary in `--release` mode.
+
+== Internal Dependency Tree
+
+[ditaa]
+....
++---------------+       +----------------+
+|               |       |                |
+|    runtime    +<------+   frame        |
+|               |       |                |
++------+-----+--+       +-------------+--+
+       ^     ^                        ^
+       |     +----------------+       |
+       |                      |       |
++------+--------+             |       |
+|               |             |       |
+|   client      |          +--+-------+--------+
+|               +<---------+                   |
++---------------+          |                   |
+                           |   test  /bin/*    |
+                           |                   |
+                           |                   |
+                           +-------------------+
+
+....
diff --git a/substrate/docs/Upgrade.md b/substrate/docs/Upgrade.md
new file mode 100644
index 0000000000000000000000000000000000000000..4908d53f579e4028bff5615947a86b285f8f8039
--- /dev/null
+++ b/substrate/docs/Upgrade.md
@@ -0,0 +1,5 @@
+# Upgrade path for you building on substrate
+
+## master
+ - crate rename has been fixed `sp-application-crypto` (was `sc-application-crypto`);  `.maintain/rename-crates-for-2.0.sh` has been updated accordingly, you can use it to upgrade to latest naming convention
+ - crates have been renamed, run `bash .maintain/rename-crates-for-2.0.sh`
\ No newline at end of file
diff --git a/substrate/docs/Upgrading-2.0-to-3.0.md b/substrate/docs/Upgrading-2.0-to-3.0.md
new file mode 100644
index 0000000000000000000000000000000000000000..906018db9a707b094b6bc051dedc3aa0be4d9ff3
--- /dev/null
+++ b/substrate/docs/Upgrading-2.0-to-3.0.md
@@ -0,0 +1,1058 @@
+# Upgrading from Substrate 2.0 to 3.0
+
+An incomplete guide.
+
+## Refreshing the node-template
+
+Not much has changed on the top and API level for developing Substrate between 2.0 and 3.0. If you've made only small changes to the node-template, we recommend to do the following - it is easiest and quickest path forward:
+1. take a diff between 2.0 and your changes
+2. store that diff
+3. remove everything, copy over the 3.0 node-template
+4. try re-applying your diff, manually, a hunk at a time.
+
+## In-Depth guide on the changes
+
+If you've made significant changes or diverted from the node-template a lot, starting out with that is probably not helping. For that case, we'll take a look at all changes between 2.0 and 3.0 to the fully-implemented node and explain them one by one, so you can follow up, what needs to be changing for your node.
+
+_Note_: Of course, step 1 is to upgrade your `Cargo.toml`'s to use the latest version of Substrate and all dependencies.
+
+We'll be taking the diff from 2.0.1 to 3.0.0 on `bin/node` as the baseline of what has changed between these two versions in terms of adapting ones code base. We will not be covering the changes made on the tests and bench-marking as they are mostly reactions to the other changes.
+
+### Versions upgrade
+
+First and foremost you have to upgrade the version pf the dependencies of course, that's `0.8.x -> 0.9.0` and `2.0.x -> 3.0.0` for all `sc-`, `sp-`, `frame-`, and `pallet-` coming from Parity. Further more this release also upgraded its own dependencies, most notably, we are now using `parity-scale-codec 2.0`, `parking_lot 0.11` and `substrate-wasm-builder 3.0.0` (as build dependency). All other dependency upgrades should resolve automatically or are just internal. However you might see some error that another dependency/type you have as a dependency and one of our upgraded crates don't match up, if so please check the version of said dependency - we've probably upgraded it.
+
+### WASM-Builder
+
+The new version of wasm-builder has gotten a bit smarter and a lot faster (you should definitely switch). Once you've upgraded the dependency, in most cases you just have to remove the now obsolete `with_wasm_builder_from_crates_or_path`-function and you are good to go:
+
+```diff: rust
+--- a/bin/node/runtime/build.rs
++++ b/bin/node/runtime/build.rs
+@@ -15,12 +15,11 @@
+ // See the License for the specific language governing permissions and
+ // limitations under the License.
+
+-use wasm_builder_runner::WasmBuilder;
++use substrate_wasm_builder::WasmBuilder;
+
+ fn main() {
+ 	WasmBuilder::new()
+ 		.with_current_project()
+-		.with_wasm_builder_from_crates_or_path("2.0.0", "../../../utils/wasm-builder")
+ 		.export_heap_base()
+ 		.import_memory()
+ 		.build()
+```
+
+### Runtime
+
+#### FRAME 2.0
+
+The new FRAME 2.0 macros are a lot nicer to use and easier to read. While we were on that change though, we also cleaned up some mainly internal names and traits. The old `macro`'s still work and also produce the new structure, however, when plugging all that together as a Runtime, there's some things we have to adapt now:
+
+##### `::Trait for Runtime` becomes `::Config for Runtime`
+
+The most visible and significant change is that the macros no longer generate the `$pallet::Trait` but now a much more aptly named `$pallet::Config`. Thus, we need to rename all `::Trait for Runtime` into`::Config for Runtime`, e.g. for the `sudo` pallet we must do:
+
+```diff
+-impl pallet_sudo::Trait for Runtime {
++impl pallet_sudo::Config for Runtime {
+```
+
+The same goes for all `<Self as frame_system::Trait>` and alike, which simply becomes `<Self as frame_system::Config>`.
+
+#### SS58 Prefix is now a runtime param
+
+
+Since [#7810](https://github.com/paritytech/substrate/pull/7810) we don't define the ss58 prefix in the chainspec anymore but moved it into the runtime. Namely, `frame_system` now needs a new `SS58Prefix`, which in substrate node we have defined for ourselves as: `pub const SS58Prefix: u8 = 42;`. Use your own chain-specific value there.
+
+#### Weight Definition
+
+`type WeightInfo` has changed and instead on `weights::pallet_$name::WeightInfo` is now bound to the Runtime as `pallet_$name::weights::SubstrateWeight<Runtime>`. As a result we have to the change the type definitions everywhere in our Runtime accordingly:
+
+```diff
+-	type WeightInfo = weights::pallet_$name::WeightInfo;
++	type WeightInfo = pallet_$name::weights::SubstrateWeight<Runtime>;
+```
+
+e.g.
+```diff
+-	type WeightInfo = weights::pallet_collective::WeightInfo;
++	type WeightInfo = pallet_collective::weights::SubstrateWeight<Runtime>;
+```
+and
+
+```diff
+-	type WeightInfo = weights::pallet_proxy::WeightInfo;
++	type WeightInfo = pallet_proxy::weights::SubstrateWeight<Runtime>;
+```
+
+And update the overall definition for weights on frame and a few related types and runtime parameters:
+
+```diff=
+
+-const AVERAGE_ON_INITIALIZE_WEIGHT: Perbill = Perbill::from_percent(10);
++/// We assume that ~10% of the block weight is consumed by `on_initalize` handlers.
++/// This is used to limit the maximal weight of a single extrinsic.
++const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);
++/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used
++/// by  Operational  extrinsics.
++const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
++/// We allow for 2 seconds of compute with a 6 second average block time.
++const MAXIMUM_BLOCK_WEIGHT: Weight = Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX);
++
+ parameter_types! {
+ 	pub const BlockHashCount: BlockNumber = 2400;
+-	/// We allow for 2 seconds of compute with a 6 second average block time.
+-	pub const MaximumBlockWeight: Weight = Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX);
+-	pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);
+-	/// Assume 10% of weight for average on_initialize calls.
+-	pub MaximumExtrinsicWeight: Weight =
+-		AvailableBlockRatio::get().saturating_sub(AVERAGE_ON_INITIALIZE_WEIGHT)
+-		* MaximumBlockWeight::get();
+-	pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;
+ 	pub const Version: RuntimeVersion = VERSION;
+-}
+-
+-const_assert!(AvailableBlockRatio::get().deconstruct() >= AVERAGE_ON_INITIALIZE_WEIGHT.deconstruct());
+-
+-impl frame_system::Trait for Runtime {
++	pub RuntimeBlockLength: BlockLength =
++		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
++	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()
++		.base_block(BlockExecutionWeight::get())
++		.for_class(DispatchClass::all(), |weights| {
++			weights.base_extrinsic = ExtrinsicBaseWeight::get();
++		})
++		.for_class(DispatchClass::Normal, |weights| {
++			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
++		})
++		.for_class(DispatchClass::Operational, |weights| {
++			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);
++			// Operational transactions have some extra reserved space, so that they
++			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.
++			weights.reserved = Some(
++				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT
++			);
++		})
++		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)
++		.build_or_panic();
++}
++
++const_assert!(NORMAL_DISPATCH_RATIO.deconstruct() >= AVERAGE_ON_INITIALIZE_RATIO.deconstruct());
++
++impl frame_system::Config for Runtime {
+ 	type BaseCallFilter = frame_support::traits::AllowAll;
++	type BlockWeights = RuntimeBlockWeights;
++	type BlockLength = RuntimeBlockLength;
++	type DbWeight = RocksDbWeight;
+ 	type RuntimeOrigin = RuntimeOrigin;
+ 	type RuntimeCall = RuntimeCall;
+ 	type Index = Index;
+@@ -171,25 +198,19 @@ impl frame_system::Trait for Runtime {
+ 	type Header = generic::Header<BlockNumber, BlakeTwo256>;
+ 	type Event = Event;
+ 	type BlockHashCount = BlockHashCount;
+-	type MaximumBlockWeight = MaximumBlockWeight;
+-	type DbWeight = RocksDbWeight;
+-	type BlockExecutionWeight = BlockExecutionWeight;
+-	type ExtrinsicBaseWeight = ExtrinsicBaseWeight;
+-	type MaximumExtrinsicWeight = MaximumExtrinsicWeight;
+-	type MaximumBlockLength = MaximumBlockLength;
+-	type AvailableBlockRatio = AvailableBlockRatio;
+ 	type Version = Version;
+ 	type PalletInfo = PalletInfo;
+ 	type AccountData = pallet_balances::AccountData<Balance>;
+ 	type OnNewAccount = ();
+ 	type OnKilledAccount = ();
+-	type SystemWeightInfo = weights::frame_system::WeightInfo;
++	type SystemWeightInfo = frame_system::weights::SubstrateWeight<Runtime>;
+```
+
+#### Pallets:
+
+##### Assets
+
+The assets pallet has seen a variety of changes:
+- [Features needed for reserve-backed stablecoins #7152 ](https://github.com/paritytech/substrate/pull/7152)
+- [Freeze Assets and Asset Metadata #7346 ](https://github.com/paritytech/substrate/pull/7346)
+- [Introduces account existence providers reference counting #7363 ]((https://github.com/paritytech/substrate/pull/7363))
+
+have all altered the feature set and changed the concepts. However, it has some of the best documentation and explains the current state very well. If you are using the assets pallet and need to upgrade from an earlier version, we recommend you use the current docs to guide your way!
+
+##### Contracts
+
+As noted in the changelog, the `contracts`-pallet is still undergoing massive changes and is not yet part of this release. We are expecting for it to be released a few weeks after. If your chain is dependent on this pallet, we recommend to wait until it has been released as the currently released version is not compatible with FRAME 2.0.
+
+#### (changes) Treasury
+
+As mentioned above, Bounties, Tips and Lottery have been extracted out of treasury into their own pallets - removing these options here. Secondly we must now specify the `BurnDestination`  and `SpendFunds`, which now go the `Bounties`.
+
+```diff
+-	type Tippers = Elections;
+-	type TipCountdown = TipCountdown;
+-	type TipFindersFee = TipFindersFee;
+-	type TipReportDepositBase = TipReportDepositBase;
+-	type DataDepositPerByte = DataDepositPerByte;
+ 	type Event = Event;
+ 	type OnSlash = ();
+ 	type ProposalBond = ProposalBond;
+ 	type ProposalBondMinimum = ProposalBondMinimum;
+	type ProposalBondMaximum = ();
+ 	type SpendPeriod = SpendPeriod;
+ 	type Burn = Burn;
++	type BurnDestination = ();
++	type SpendFunds = Bounties;
+```
+
+Factoring out Bounties and Tips means most of these definitions have now moved there, while the parameter types can be left as they were:
+
+###### 🆕 Bounties
+
+```rust=
+impl pallet_bounties::Config for Runtime {
+	type Event = Event;
+ 	type BountyDepositBase = BountyDepositBase;
+ 	type BountyDepositPayoutDelay = BountyDepositPayoutDelay;
+ 	type BountyUpdatePeriod = BountyUpdatePeriod;
+ 	type BountyCuratorDeposit = BountyCuratorDeposit;
+ 	type BountyValueMinimum = BountyValueMinimum;
+	type DataDepositPerByte = DataDepositPerByte;
+ 	type MaximumReasonLength = MaximumReasonLength;
+	type WeightInfo = pallet_bounties::weights::SubstrateWeight<Runtime>;
+ }
+```
+
+###### 🆕 Tips
+
+```rust=
+impl pallet_tips::Config for Runtime {
+	type Event = Event;
+	type DataDepositPerByte = DataDepositPerByte;
+	type MaximumReasonLength = MaximumReasonLength;
+	type Tippers = Elections;
+	type TipCountdown = TipCountdown;
+	type TipFindersFee = TipFindersFee;
+	type TipReportDepositBase = TipReportDepositBase;
+	type WeightInfo = pallet_tips::weights::SubstrateWeight<Runtime>;
+ }
+```
+
+#### `FinalityTracker` removed
+
+Finality Tracker has been removed in favor of a different approach to handle the issue in GRANDPA, [see #7228 for details](https://github.com/paritytech/substrate/pull/7228). With latest GRANDPA this is not needed anymore and can be removed without worry.
+
+#### (changes) Elections Phragmen
+
+The pallet has been moved to a new system in which the exact amount of deposit for each voter, candidate, member, or runner-up is now deposited on-chain. Moreover, the concept of a `defunct_voter` is removed, since votes now have adequate deposit associated with them. A number of configuration parameters has changed to reflect this, as shown below:
+
+```diff=
+ parameter_types! {
+ 	pub const CandidacyBond: Balance = 10 * DOLLARS;
+-	pub const VotingBond: Balance = 1 * DOLLARS;
++	// 1 storage item created, key size is 32 bytes, value size is 16+16.
++	pub const VotingBondBase: Balance = deposit(1, 64);
++	// additional data per vote is 32 bytes (account id).
++	pub const VotingBondFactor: Balance = deposit(0, 32);
+ 	pub const TermDuration: BlockNumber = 7 * DAYS;
+ 	pub const DesiredMembers: u32 = 13;
+ 	pub const DesiredRunnersUp: u32 = 7;
+
+@@ -559,16 +600,16 @@ impl pallet_elections_phragmen::Trait for Runtime {
+ 	// NOTE: this implies that council's genesis members cannot be set directly and must come from
+ 	// this module.
+ 	type InitializeMembers = Council;
+-	type CurrencyToVote = CurrencyToVoteHandler;
++	type CurrencyToVote = U128CurrencyToVote;
+ 	type CandidacyBond = CandidacyBond;
+-	type VotingBond = VotingBond;
++	type VotingBondBase = VotingBondBase;
++	type VotingBondFactor = VotingBondFactor;
+ 	type LoserCandidate = ();
+-	type BadReport = ();
+ 	type KickedMember = ();
+ 	type DesiredMembers = DesiredMembers;
+ 	type DesiredRunnersUp = DesiredRunnersUp;
+ 	type TermDuration = TermDuration;
+ ```
+
+ **This upgrade requires storage [migration](https://github.com/paritytech/substrate/blob/master/frame/elections-phragmen/src/migrations_3_0_0.rs)**. Further details can be found in the [pallet-specific changelog](https://github.com/paritytech/substrate/blob/master/frame/elections-phragmen/CHANGELOG.md#security).
+
+#### (changes) Democracy
+
+Democracy brings three new settings with this release, all to allow for better influx- and spam-control. Namely these allow to specify the maximum number of proposals at a time, who can blacklist and who can cancel proposals. This diff acts as a good starting point:
+
+```diff=
+@@ -508,6 +537,14 @@ impl pallet_democracy::Trait for Runtime {
+ 	type FastTrackVotingPeriod = FastTrackVotingPeriod;
+ 	// To cancel a proposal which has been passed, 2/3 of the council must agree to it.
+ 	type CancellationOrigin = pallet_collective::EnsureProportionAtLeast<_2, _3, AccountId, CouncilCollective>;
++	// To cancel a proposal before it has been passed, the technical committee must be unanimous or
++	// Root must agree.
++	type CancelProposalOrigin = EitherOfDiverse<
++		AccountId,
++		EnsureRoot<AccountId>,
++		pallet_collective::EnsureProportionAtLeast<_1, _1, AccountId, TechnicalCollective>,
++	>;
++	type BlacklistOrigin = EnsureRoot<AccountId>;
+ 	// Any single technical committee member may veto a coming council proposal, however they can
+ 	// only do it once and it lasts only for the cooloff period.
+ 	type VetoOrigin = pallet_collective::EnsureMember<AccountId, TechnicalCollective>;
+@@ -518,7 +555,8 @@ impl pallet_democracy::Trait for Runtime {
+ 	type Scheduler = Scheduler;
+ 	type PalletsOrigin = OriginCaller;
+ 	type MaxVotes = MaxVotes;
++	type MaxProposals = MaxProposals;
+ }
+```
+
+----
+
+### Primitives
+
+The shared primitives define the API between Client and Runtime. Usually, you don't have to touch nor directly interact with them, unless you created your own client or frame-less runtime. Therefore we'd expect you to understand whether you are effected by changes and how to update your code yourself.
+
+----
+
+### Client
+
+#### CLI
+
+A few minor things have changed in the `cli` (compared to 2.0.1):
+
+1. we've [replaced the newly added `BuildSyncSpec` subcommand with an RPC API](https://github.com/paritytech/substrate/commit/65cc9af9b8df8d36928f6144ee7474cefbd70454#diff-c57da6fbeff8c46ce15f55ea42fedaa5a4684d79578006ce4af01ae04fd6b8f8) in an on-going effort to make light-client-support smoother, see below
+2. we've [removed double accounts from our chainspec-builder](https://github.com/paritytech/substrate/commit/31499cd29ed30df932fb71b7459796f7160d0272)
+3. we [don't fallback to `--chain flaming-fir` anymore](https://github.com/paritytech/substrate/commit/13cdf1c8cd2ee62d411f82b64dc7eba860c9c6c6), if no chain is given our substrate-node will error.
+4. [the `subkey`-integration has seen a fix to the `insert`-command](https://github.com/paritytech/substrate/commit/54bde60cfd2c544c54e9e8623b6b8725b99557f8) that requires you to now add the `&cli` as a param.
+    ```diff=
+    --- a/bin/node/cli/src/command.rs
+    +++ b/bin/node/cli/src/command.rs
+    @@ -92,7 +97,7 @@ pub fn run() -> Result<()> {
+                    You can enable it with `--features runtime-benchmarks`.".into())
+                }
+            }
+    -		Some(Subcommand::Key(cmd)) => cmd.run(),
+    +		Some(Subcommand::Key(cmd)) => cmd.run(&cli),
+            Some(Subcommand::Sign(cmd)) => cmd.run(),
+            Some(Subcommand::Verify(cmd)) => cmd.run(),
+            Some(Subcommand::Vanity(cmd)) => cmd.run(),
+    ```
+
+
+#### Service Builder Upgrades
+
+##### Light client support
+
+As said, we've added a new optional RPC service for improved light client support. For that to work, we need to pass the `chain_spec` and give access  to the `AuxStore` to our `rpc`:
+
+
+```diff=
+
+--- a/bin/node/rpc/src/lib.rs
++++ b/bin/node/rpc/src/lib.rs
+@@ -49,6 +49,7 @@ use sp_consensus::SelectChain;
+ use sp_consensus_babe::BabeApi;
+ use sc_rpc::SubscriptionTaskExecutor;
+ use sp_transaction_pool::TransactionPool;
++use sc_client_api::AuxStore;
+
+ /// Light client extra dependencies.
+ pub struct LightDeps<C, F, P> {
+@@ -94,6 +95,8 @@ pub struct FullDeps<C, P, SC, B> {
+ 	pub pool: Arc<P>,
+ 	/// The SelectChain Strategy
+ 	pub select_chain: SC,
++	/// A copy of the chain spec.
++	pub chain_spec: Box<dyn sc_chain_spec::ChainSpec>,
+ 	/// Whether to deny unsafe calls
+ 	pub deny_unsafe: DenyUnsafe,
+ 	/// BABE specific dependencies.
+@@ -109,9 +112,8 @@ pub type IoHandler = jsonrpc_core::IoHandler<sc_rpc::Metadata>;
+ pub fn create_full<C, P, SC, B>(
+ 	deps: FullDeps<C, P, SC, B>,
+ ) -> jsonrpc_core::IoHandler<sc_rpc_api::Metadata> where
+-	C: ProvideRuntimeApi<Block>,
+-	C: HeaderBackend<Block> + HeaderMetadata<Block, Error=BlockChainError> + 'static,
+-	C: Send + Sync + 'static,
++	C: ProvideRuntimeApi<Block> + HeaderBackend<Block> + AuxStore +
++		HeaderMetadata<Block, Error=BlockChainError> + Sync + Send + 'static,
+ 	C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Index>,
+ 	C::Api: pallet_contracts_rpc::ContractsRuntimeApi<Block, AccountId, Balance, BlockNumber>,
+ 	C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>,
+@@ -131,6 +133,7 @@ pub fn create_full<C, P, SC, B>(
+ 		client,
+ 		pool,
+ 		select_chain,
++		chain_spec,
+ 		deny_unsafe,
+ 		babe,
+ 		grandpa,
+@@ -164,8 +167,8 @@ pub fn create_full<C, P, SC, B>(
+ 	io.extend_with(
+ 		sc_consensus_babe_rpc::BabeApi::to_delegate(
+ 			BabeRpcHandler::new(
+-				client,
+-				shared_epoch_changes,
++				client.clone(),
++				shared_epoch_changes.clone(),
+ 				keystore,
+ 				babe_config,
+ 				select_chain,
+@@ -176,7 +179,7 @@ pub fn create_full<C, P, SC, B>(
+ 	io.extend_with(
+ 		sc_finality_grandpa_rpc::GrandpaApi::to_delegate(
+ 			GrandpaRpcHandler::new(
+-				shared_authority_set,
++				shared_authority_set.clone(),
+ 				shared_voter_state,
+ 				justification_stream,
+ 				subscription_executor,
+
+```
+
+and add the new service:
+
+```diff=
+--- a/bin/node/rpc/src/lib.rs
++++ b/bin/node/rpc/src/lib.rs
+@@ -185,6 +188,18 @@ pub fn create_full<C, P, SC, B>(
+ 		)
+ 	);
+
++	io.extend_with(
++		sc_sync_state_rpc::SyncStateRpcApi::to_delegate(
++			sc_sync_state_rpc::SyncStateRpcHandler::new(
++				chain_spec,
++				client,
++				shared_authority_set,
++				shared_epoch_changes,
++				deny_unsafe,
++			)
++		)
++	);
++
+ 	io
+ }
+```
+
+##### Telemetry
+
+The telemetry subsystem has seen a few fixes and refactorings to allow for a more flexible handling, in particular in regards to parachains. Most notably `sc_service::spawn_tasks` now returns the `telemetry_connection_notifier` as the second member of the tuple, (`let (_rpc_handlers, telemetry_connection_notifier) = sc_service::spawn_tasks(`), which should be passed to `telemetry_on_connect` of `new_full_base` now: `telemetry_on_connect: telemetry_connection_notifier.map(|x| x.on_connect_stream()),` (see the service-section below for a full diff).
+
+##### Async & Remote Keystore support
+
+In order to allow for remote-keystores, the keystore-subsystem has been reworked to support async operations and generally refactored to not provide the keys itself but only sign on request. This allows for remote-keystore to never hand out keys and thus to operate any substrate-based node in a manner without ever having the private keys in the local system memory.
+
+There are some operations, however, that the keystore must be local for performance reasons and for which a remote keystore won't work (in particular around parachains). As such, the keystore has both a slot for remote but also always a local instance, where some operations hard bind to the local variant, while most subsystems just ask the generic keystore which prefers a remote signer if given. To reflect this change, `sc_service::new_full_parts` now returns a `KeystoreContainer` rather than the keystore, and the other subsystems (e.g. `sc_service::PartialComponents`) expect to be given that.
+
+###### on RPC:
+
+This has most visible changes for the rpc, where we are switching from the previous `KeyStorePtr` to the new `SyncCryptoStorePtr`:
+
+```diff
+
+--- a/bin/node/rpc/src/lib.rs
++++ b/bin/node/rpc/src/lib.rs
+@@ -32,6 +32,7 @@
+
+ use std::sync::Arc;
+
++use sp_keystore::SyncCryptoStorePtr;
+ use node_primitives::{Block, BlockNumber, AccountId, Index, Balance, Hash};
+ use sc_consensus_babe::{Config, Epoch};
+ use sc_consensus_babe_rpc::BabeRpcHandler;
+@@ -40,7 +41,6 @@ use sc_finality_grandpa::{
+ 	SharedVoterState, SharedAuthoritySet, FinalityProofProvider, GrandpaJustificationStream
+ };
+ use sc_finality_grandpa_rpc::GrandpaRpcHandler;
+-use sc_keystore::KeyStorePtr;
+ pub use sc_rpc_api::DenyUnsafe;
+ use sp_api::ProvideRuntimeApi;
+ use sp_block_builder::BlockBuilder;
+ pub struct LightDeps<C, F, P> {
+@@ -69,7 +70,7 @@ pub struct BabeDeps {
+ 	/// BABE pending epoch changes.
+ 	pub shared_epoch_changes: SharedEpochChanges<Block, Epoch>,
+ 	/// The keystore that manages the keys of the node.
+-	pub keystore: KeyStorePtr,
++	pub keystore: SyncCryptoStorePtr,
+ }
+
+```
+
+##### GRANDPA
+
+As already in the changelog, a few things significant things have changed in regards to GRANDPA: the finality tracker has been replaced, an RPC command has been added and WARP-sync-support for faster light client startup has been implemented. All this means we have to do a few changes to our GRANDPA setup procedures in the client.
+
+First and foremost, grandpa internalised a few aspects, and thus `new_partial` doesn't expect a tuple but only the `grandpa::SharedVoterState` as input now, and unpacking that again later is not needed anymore either. On the opposite side `grandpa::FinalityProofProvider::new_for_service` now requires the `Some(shared_authority_set)` to be passed as a new third parameter. This set also becomes relevant when adding warp-sync-support, which is added as an extra-protocol-layer to the networking as:
+```diff=
+
++	config.network.extra_sets.push(grandpa::grandpa_peers_set_config());
++
++	#[cfg(feature = "cli")]
++	config.network.request_response_protocols.push(sc_finality_grandpa_warp_sync::request_response_config_for_chain(
++		&config, task_manager.spawn_handle(), backend.clone(),
++	));
+```
+
+As these changes pull through the entirety of `cli/src/service.rs`, we recommend looking at the final diff below for guidance.
+
+##### In a nutshell
+
+Altogether this accumulates to the following diff for `node/cli/src/service.rs`. If you want these features and have modified your chain you should probably try to apply these patches:
+
+
+```diff=
+--- a/bin/node/cli/src/service.rs
++++ b/bin/node/cli/src/service.rs
+@@ -22,11 +22,10 @@
+
+ use std::sync::Arc;
+ use sc_consensus_babe;
+-use grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider};
+ use node_primitives::Block;
+ use node_runtime::RuntimeApi;
+ use sc_service::{
+-	config::{Role, Configuration}, error::{Error as ServiceError},
++	config::{Configuration}, error::{Error as ServiceError},
+ 	RpcHandlers, TaskManager,
+ };
+ use sp_inherents::InherentDataProviders;
+@@ -34,8 +33,8 @@ use sc_network::{Event, NetworkService};
+ use sp_runtime::traits::Block as BlockT;
+ use futures::prelude::*;
+ use sc_client_api::{ExecutorProvider, RemoteBackend};
+-use sp_core::traits::BareCryptoStorePtr;
+ use node_executor::Executor;
++use sc_telemetry::TelemetryConnectionNotifier;
+
+ type FullClient = sc_service::TFullClient<Block, RuntimeApi, Executor>;
+ type FullBackend = sc_service::TFullBackend<Block>;
+@@ -58,13 +57,10 @@ pub fn new_partial(config: &Configuration) -> Result<sc_service::PartialComponen
+ 			grandpa::LinkHalf<Block, FullClient, FullSelectChain>,
+ 			sc_consensus_babe::BabeLink<Block>,
+ 		),
+-		(
+-			grandpa::SharedVoterState,
+-			Arc<GrandpaFinalityProofProvider<FullBackend, Block>>,
+-		),
++		grandpa::SharedVoterState,
+ 	)
+ >, ServiceError> {
+-	let (client, backend, keystore, task_manager) =
++	let (client, backend, keystore_container, task_manager) =
+ 		sc_service::new_full_parts::<Block, RuntimeApi, Executor>(&config)?;
+ 	let client = Arc::new(client);
+
+@@ -94,7 +90,6 @@ pub fn new_partial(config: &Configuration) -> Result<sc_service::PartialComponen
+ 		babe_link.clone(),
+ 		block_import.clone(),
+ 		Some(Box::new(justification_import)),
+-		None,
+ 		client.clone(),
+ 		select_chain.clone(),
+ 		inherent_data_providers.clone(),
+@@ -111,10 +106,12 @@ pub fn new_partial(config: &Configuration) -> Result<sc_service::PartialComponen
+ 		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 finality_proof_provider =
+-			GrandpaFinalityProofProvider::new_for_service(backend.clone(), client.clone());
++		let rpc_setup = shared_voter_state.clone();
+
+-		let rpc_setup = (shared_voter_state.clone(), finality_proof_provider.clone());
++		let finality_proof_provider = grandpa::FinalityProofProvider::new_for_service(
++			backend.clone(),
++			Some(shared_authority_set.clone()),
++		);
+
+ 		let babe_config = babe_link.config().clone();
+ 		let shared_epoch_changes = babe_link.epoch_changes().clone();
+@@ -122,13 +119,15 @@ pub fn new_partial(config: &Configuration) -> Result<sc_service::PartialComponen
+ 		let client = client.clone();
+ 		let pool = transaction_pool.clone();
+ 		let select_chain = select_chain.clone();
+-		let keystore = keystore.clone();
++		let keystore = keystore_container.sync_keystore();
++		let chain_spec = config.chain_spec.cloned_box();
+
+ 		let rpc_extensions_builder = move |deny_unsafe, subscription_executor| {
+ 			let deps = node_rpc::FullDeps {
+ 				client: client.clone(),
+ 				pool: pool.clone(),
+ 				select_chain: select_chain.clone(),
++				chain_spec: chain_spec.cloned_box(),
+ 				deny_unsafe,
+ 				babe: node_rpc::BabeDeps {
+ 					babe_config: babe_config.clone(),
+@@ -151,9 +150,15 @@ pub fn new_partial(config: &Configuration) -> Result<sc_service::PartialComponen
+ 	};
+
+ 	Ok(sc_service::PartialComponents {
+-		client, backend, task_manager, keystore, select_chain, import_queue, transaction_pool,
++		client,
++		backend,
++		task_manager,
++		keystore_container,
++		select_chain,
++		import_queue,
++		transaction_pool,
+ 		inherent_data_providers,
+-		other: (rpc_extensions_builder, import_setup, rpc_setup)
++		other: (rpc_extensions_builder, import_setup, rpc_setup),
+ 	})
+ }
+
+@@ -168,19 +173,32 @@ pub struct NewFullBase {
+
+ /// Creates a full service from the configuration.
+ pub fn new_full_base(
+-	config: Configuration,
++	mut config: Configuration,
+ 	with_startup_data: impl FnOnce(
+ 		&sc_consensus_babe::BabeBlockImport<Block, FullClient, FullGrandpaBlockImport>,
+ 		&sc_consensus_babe::BabeLink<Block>,
+ 	)
+ ) -> Result<NewFullBase, ServiceError> {
+ 	let sc_service::PartialComponents {
+-		client, backend, mut task_manager, import_queue, keystore, select_chain, transaction_pool,
++		client,
++		backend,
++		mut task_manager,
++		import_queue,
++		keystore_container,
++		select_chain,
++		transaction_pool,
+ 		inherent_data_providers,
+ 		other: (rpc_extensions_builder, import_setup, rpc_setup),
+ 	} = new_partial(&config)?;
+
+-	let (shared_voter_state, finality_proof_provider) = rpc_setup;
++	let shared_voter_state = rpc_setup;
++
++	config.network.extra_sets.push(grandpa::grandpa_peers_set_config());
++
++	#[cfg(feature = "cli")]
++	config.network.request_response_protocols.push(sc_finality_grandpa_warp_sync::request_response_config_for_chain(
++		&config, task_manager.spawn_handle(), backend.clone(),
++	));
+
+ 	let (network, network_status_sinks, system_rpc_tx, network_starter) =
+ 		sc_service::build_network(sc_service::BuildNetworkParams {
+@@ -191,8 +209,6 @@ pub fn new_full_base(
+ 			import_queue,
+ 			on_demand: None,
+ 			block_announce_validator_builder: None,
+-			finality_proof_request_builder: None,
+-			finality_proof_provider: Some(finality_proof_provider.clone()),
+ 		})?;
+
+ 	if config.offchain_worker.enabled {
+@@ -203,26 +219,28 @@ pub fn new_full_base(
+
+ 	let role = config.role.clone();
+ 	let force_authoring = config.force_authoring;
++	let backoff_authoring_blocks =
++		Some(sc_consensus_slots::BackoffAuthoringOnFinalizedHeadLagging::default());
+ 	let name = config.network.node_name.clone();
+ 	let enable_grandpa = !config.disable_grandpa;
+ 	let prometheus_registry = config.prometheus_registry().cloned();
+-	let telemetry_connection_sinks = sc_service::TelemetryConnectionSinks::default();
+
+-	sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+-		config,
+-		backend: backend.clone(),
+-		client: client.clone(),
+-		keystore: keystore.clone(),
+-		network: network.clone(),
+-		rpc_extensions_builder: Box::new(rpc_extensions_builder),
+-		transaction_pool: transaction_pool.clone(),
+-		task_manager: &mut task_manager,
+-		on_demand: None,
+-		remote_blockchain: None,
+-		telemetry_connection_sinks: telemetry_connection_sinks.clone(),
+-		network_status_sinks: network_status_sinks.clone(),
+-		system_rpc_tx,
+-	})?;
++	let (_rpc_handlers, telemetry_connection_notifier) = sc_service::spawn_tasks(
++		sc_service::SpawnTasksParams {
++			config,
++			backend: backend.clone(),
++			client: client.clone(),
++			keystore: keystore_container.sync_keystore(),
++			network: network.clone(),
++			rpc_extensions_builder: Box::new(rpc_extensions_builder),
++			transaction_pool: transaction_pool.clone(),
++			task_manager: &mut task_manager,
++			on_demand: None,
++			remote_blockchain: None,
++			network_status_sinks: network_status_sinks.clone(),
++			system_rpc_tx,
++		},
++	)?;
+
+ 	let (block_import, grandpa_link, babe_link) = import_setup;
+
+@@ -230,6 +248,7 @@ pub fn new_full_base(
+
+ 	if let sc_service::config::Role::Authority { .. } = &role {
+ 		let proposer = sc_basic_authorship::ProposerFactory::new(
++			task_manager.spawn_handle(),
+ 			client.clone(),
+ 			transaction_pool.clone(),
+ 			prometheus_registry.as_ref(),
+@@ -239,7 +258,7 @@ pub fn new_full_base(
+ 			sp_consensus::CanAuthorWithNativeVersion::new(client.executor().clone());
+
+ 		let babe_config = sc_consensus_babe::BabeParams {
+-			keystore: keystore.clone(),
++			keystore: keystore_container.sync_keystore(),
+ 			client: client.clone(),
+ 			select_chain,
+ 			env: proposer,
+@@ -247,6 +266,7 @@ pub fn new_full_base(
+ 			sync_oracle: network.clone(),
+ 			inherent_data_providers: inherent_data_providers.clone(),
+ 			force_authoring,
++			backoff_authoring_blocks,
+ 			babe_link,
+ 			can_author_with,
+ 		};
+@@ -256,42 +276,30 @@ pub fn new_full_base(
+ 	}
+
+ 	// Spawn authority discovery module.
+-	if matches!(role, Role::Authority{..} | Role::Sentry {..}) {
+-		let (sentries, authority_discovery_role) = match role {
+-			sc_service::config::Role::Authority { ref sentry_nodes } => (
+-				sentry_nodes.clone(),
+-				sc_authority_discovery::Role::Authority (
+-					keystore.clone(),
+-				),
+-			),
+-			sc_service::config::Role::Sentry {..} => (
+-				vec![],
+-				sc_authority_discovery::Role::Sentry,
+-			),
+-			_ => unreachable!("Due to outer matches! constraint; qed.")
+-		};
+-
++	if role.is_authority() {
++		let authority_discovery_role = sc_authority_discovery::Role::PublishAndDiscover(
++			keystore_container.keystore(),
++		);
+ 		let dht_event_stream = network.event_stream("authority-discovery")
+ 			.filter_map(|e| async move { match e {
+ 				Event::Dht(e) => Some(e),
+ 				_ => None,
+-			}}).boxed();
++			}});
+ 		let (authority_discovery_worker, _service) = sc_authority_discovery::new_worker_and_service(
+ 			client.clone(),
+ 			network.clone(),
+-			sentries,
+-			dht_event_stream,
++			Box::pin(dht_event_stream),
+ 			authority_discovery_role,
+ 			prometheus_registry.clone(),
+ 		);
+
+-		task_manager.spawn_handle().spawn("authority-discovery-worker", authority_discovery_worker);
++		task_manager.spawn_handle().spawn("authority-discovery-worker", authority_discovery_worker.run());
+ 	}
+
+ 	// if the node isn't actively participating in consensus then it doesn't
+ 	// need a keystore, regardless of which protocol we use below.
+ 	let keystore = if role.is_authority() {
+-		Some(keystore as BareCryptoStorePtr)
++		Some(keystore_container.sync_keystore())
+ 	} else {
+ 		None
+ 	};
+@@ -317,8 +325,7 @@ pub fn new_full_base(
+ 			config,
+ 			link: grandpa_link,
+ 			network: network.clone(),
+-			inherent_data_providers: inherent_data_providers.clone(),
+-			telemetry_on_connect: Some(telemetry_connection_sinks.on_connect_stream()),
++			telemetry_on_connect: telemetry_connection_notifier.map(|x| x.on_connect_stream()),
+ 			voting_rule: grandpa::VotingRulesBuilder::default().build(),
+ 			prometheus_registry,
+ 			shared_voter_state,
+@@ -330,17 +337,15 @@ pub fn new_full_base(
+ 			"grandpa-voter",
+ 			grandpa::run_grandpa_voter(grandpa_config)?
+ 		);
+-	} else {
+-		grandpa::setup_disabled_grandpa(
+-			client.clone(),
+-			&inherent_data_providers,
+-			network.clone(),
+-		)?;
+ 	}
+
+ 	network_starter.start_network();
+ 	Ok(NewFullBase {
+-		task_manager, inherent_data_providers, client, network, network_status_sinks,
++		task_manager,
++		inherent_data_providers,
++		client,
++		network,
++		network_status_sinks,
+ 		transaction_pool,
+ 	})
+ }
+@@ -353,14 +358,16 @@ pub fn new_full(config: Configuration)
+ 	})
+ }
+
+-pub fn new_light_base(config: Configuration) -> Result<(
+-	TaskManager, RpcHandlers, Arc<LightClient>,
++pub fn new_light_base(mut config: Configuration) -> Result<(
++	TaskManager, RpcHandlers, Option<TelemetryConnectionNotifier>, Arc<LightClient>,
+ 	Arc<NetworkService<Block, <Block as BlockT>::Hash>>,
+ 	Arc<sc_transaction_pool::LightPool<Block, LightClient, sc_network::config::OnDemand<Block>>>
+ ), ServiceError> {
+-	let (client, backend, keystore, mut task_manager, on_demand) =
++	let (client, backend, keystore_container, mut task_manager, on_demand) =
+ 		sc_service::new_light_parts::<Block, RuntimeApi, Executor>(&config)?;
+
++	config.network.extra_sets.push(grandpa::grandpa_peers_set_config());
++
+ 	let select_chain = sc_consensus::LongestChain::new(backend.clone());
+
+ 	let transaction_pool = Arc::new(sc_transaction_pool::BasicPool::new_light(
+@@ -371,14 +378,12 @@ pub fn new_light_base(config: Configuration) -> Result<(
+ 		on_demand.clone(),
+ 	));
+
+-	let grandpa_block_import = grandpa::light_block_import(
+-		client.clone(), backend.clone(), &(client.clone() as Arc<_>),
+-		Arc::new(on_demand.checker().clone()),
++	let (grandpa_block_import, _) = grandpa::block_import(
++		client.clone(),
++		&(client.clone() as Arc<_>),
++		select_chain.clone(),
+ 	)?;
+-
+-	let finality_proof_import = grandpa_block_import.clone();
+-	let finality_proof_request_builder =
+-		finality_proof_import.create_finality_proof_request_builder();
++	let justification_import = grandpa_block_import.clone();
+
+ 	let (babe_block_import, babe_link) = sc_consensus_babe::block_import(
+ 		sc_consensus_babe::Config::get_or_compute(&*client)?,
+@@ -391,8 +396,7 @@ pub fn new_light_base(config: Configuration) -> Result<(
+ 	let import_queue = sc_consensus_babe::import_queue(
+ 		babe_link,
+ 		babe_block_import,
+-		None,
+-		Some(Box::new(finality_proof_import)),
++		Some(Box::new(justification_import)),
+ 		client.clone(),
+ 		select_chain.clone(),
+ 		inherent_data_providers.clone(),
+@@ -401,9 +405,6 @@ pub fn new_light_base(config: Configuration) -> Result<(
+ 		sp_consensus::NeverCanAuthor,
+ 	)?;
+
+-	let finality_proof_provider =
+-		GrandpaFinalityProofProvider::new_for_service(backend.clone(), client.clone());
+-
+ 	let (network, network_status_sinks, system_rpc_tx, network_starter) =
+ 		sc_service::build_network(sc_service::BuildNetworkParams {
+ 			config: &config,
+@@ -413,8 +414,6 @@ pub fn new_light_base(config: Configuration) -> Result<(
+ 			import_queue,
+ 			on_demand: Some(on_demand.clone()),
+ 			block_announce_validator_builder: None,
+-			finality_proof_request_builder: Some(finality_proof_request_builder),
+-			finality_proof_provider: Some(finality_proof_provider),
+ 		})?;
+ 	network_starter.start_network();
+
+@@ -433,32 +432,39 @@ pub fn new_light_base(config: Configuration) -> Result<(
+
+ 	let rpc_extensions = node_rpc::create_light(light_deps);
+
+-	let rpc_handlers =
++	let (rpc_handlers, telemetry_connection_notifier) =
+ 		sc_service::spawn_tasks(sc_service::SpawnTasksParams {
+ 			on_demand: Some(on_demand),
+ 			remote_blockchain: Some(backend.remote_blockchain()),
+ 			rpc_extensions_builder: Box::new(sc_service::NoopRpcExtensionBuilder(rpc_extensions)),
+ 			client: client.clone(),
+ 			transaction_pool: transaction_pool.clone(),
+-			config, keystore, backend, network_status_sinks, system_rpc_tx,
++			keystore: keystore_container.sync_keystore(),
++			config, backend, network_status_sinks, system_rpc_tx,
+ 			network: network.clone(),
+-			telemetry_connection_sinks: sc_service::TelemetryConnectionSinks::default(),
+ 			task_manager: &mut task_manager,
+ 		})?;
+
+-	Ok((task_manager, rpc_handlers, client, network, transaction_pool))
++	Ok((
++		task_manager,
++		rpc_handlers,
++		telemetry_connection_notifier,
++		client,
++		network,
++		transaction_pool,
++	))
+ }
+
+ /// Builds a new service for a light client.
+ pub fn new_light(config: Configuration) -> Result<TaskManager, ServiceError> {
+-	new_light_base(config).map(|(task_manager, _, _, _, _)| {
++	new_light_base(config).map(|(task_manager, _, _, _, _, _)| {
+ 		task_manager
+ 	})
+ }
+
+ #[cfg(test)]
+ mod tests {
+-	use std::{sync::Arc, borrow::Cow, any::Any};
++	use std::{sync::Arc, borrow::Cow, any::Any, convert::TryInto};
+ 	use sc_consensus_babe::{CompatibleDigestItem, BabeIntermediate, INTERMEDIATE_KEY};
+ 	use sc_consensus_epochs::descendent_query;
+ 	use sp_consensus::{
+@@ -469,20 +475,25 @@ mod tests {
+ 	use node_runtime::{BalancesCall, Call, UncheckedExtrinsic, Address};
+ 	use node_runtime::constants::{currency::CENTS, time::SLOT_DURATION};
+ 	use codec::Encode;
+-	use sp_core::{crypto::Pair as CryptoPair, H256};
++	use sp_core::{
++		crypto::Pair as CryptoPair,
++		H256,
++		Public
++	};
++	use sp_keystore::{SyncCryptoStorePtr, SyncCryptoStore};
+ 	use sp_runtime::{
+ 		generic::{BlockId, Era, Digest, SignedPayload},
+ 		traits::{Block as BlockT, Header as HeaderT},
+ 		traits::Verify,
+ 	};
+ 	use sp_timestamp;
+-	use sp_finality_tracker;
+ 	use sp_keyring::AccountKeyring;
+ 	use sc_service_test::TestNetNode;
+ 	use crate::service::{new_full_base, new_light_base, NewFullBase};
+-	use sp_runtime::traits::IdentifyAccount;
++	use sp_runtime::{key_types::BABE, traits::IdentifyAccount, RuntimeAppPublic};
+ 	use sp_transaction_pool::{MaintainedTransactionPool, ChainEvent};
+ 	use sc_client_api::BlockBackend;
++	use sc_keystore::LocalKeystore;
+
+ 	type AccountPublic = <Signature as Verify>::Signer;
+
+@@ -492,15 +503,15 @@ mod tests {
+ 	#[ignore]
+ 	fn test_sync() {
+ 		let keystore_path = tempfile::tempdir().expect("Creates keystore path");
+-		let keystore = sc_keystore::Store::open(keystore_path.path(), None)
+-			.expect("Creates keystore");
+-		let alice = keystore.write().insert_ephemeral_from_seed::<sc_consensus_babe::AuthorityPair>("//Alice")
+-			.expect("Creates authority pair");
++		let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::open(keystore_path.path(), None)
++			.expect("Creates keystore"));
++		let alice: sp_consensus_babe::AuthorityId = SyncCryptoStore::sr25519_generate_new(&*keystore, BABE, Some("//Alice"))
++			.expect("Creates authority pair").into();
+
+ 		let chain_spec = crate::chain_spec::tests::integration_test_config_with_single_authority();
+
+ 		// For the block factory
+-		let mut slot_num = 1u64;
++		let mut slot = 1u64;
+
+ 		// For the extrinsics factory
+ 		let bob = Arc::new(AccountKeyring::Bob.pair());
+@@ -528,14 +539,13 @@ mod tests {
+ 				Ok((node, (inherent_data_providers, setup_handles.unwrap())))
+ 			},
+ 			|config| {
+-				let (keep_alive, _, client, network, transaction_pool) = new_light_base(config)?;
++				let (keep_alive, _, _, client, network, transaction_pool) = new_light_base(config)?;
+ 				Ok(sc_service_test::TestNetComponents::new(keep_alive, client, network, transaction_pool))
+ 			},
+ 			|service, &mut (ref inherent_data_providers, (ref mut block_import, ref babe_link))| {
+ 				let mut inherent_data = inherent_data_providers
+ 					.create_inherent_data()
+ 					.expect("Creates inherent data.");
+-				inherent_data.replace_data(sp_finality_tracker::INHERENT_IDENTIFIER, &1u64);
+
+ 				let parent_id = BlockId::number(service.client().chain_info().best_number);
+ 				let parent_header = service.client().header(&parent_id).unwrap().unwrap();
+@@ -552,6 +562,7 @@ mod tests {
+ 				);
+
+ 				let mut proposer_factory = sc_basic_authorship::ProposerFactory::new(
++					service.spawn_handle(),
+ 					service.client(),
+ 					service.transaction_pool(),
+ 					None,
+@@ -561,7 +572,7 @@ mod tests {
+ 					descendent_query(&*service.client()),
+ 					&parent_hash,
+ 					parent_number,
+-					slot_num,
++					slot.into(),
+ 				).unwrap().unwrap();
+
+ 				let mut digest = Digest::<H256>::default();
+@@ -569,18 +580,18 @@ mod tests {
+ 				// even though there's only one authority some slots might be empty,
+ 				// so we must keep trying the next slots until we can claim one.
+ 				let babe_pre_digest = loop {
+-					inherent_data.replace_data(sp_timestamp::INHERENT_IDENTIFIER, &(slot_num * SLOT_DURATION));
++					inherent_data.replace_data(sp_timestamp::INHERENT_IDENTIFIER, &(slot * SLOT_DURATION));
+ 					if let Some(babe_pre_digest) = sc_consensus_babe::test_helpers::claim_slot(
+-						slot_num,
++						slot.into(),
+ 						&parent_header,
+ 						&*service.client(),
+-						&keystore,
++						keystore.clone(),
+ 						&babe_link,
+ 					) {
+ 						break babe_pre_digest;
+ 					}
+
+-					slot_num += 1;
++					slot += 1;
+ 				};
+
+ 				digest.push(<DigestItem as CompatibleDigestItem>::babe_pre_digest(babe_pre_digest));
+@@ -600,11 +611,18 @@ mod tests {
+ 				// sign the pre-sealed hash of the block and then
+ 				// add it to a digest item.
+ 				let to_sign = pre_hash.encode();
+-				let signature = alice.sign(&to_sign[..]);
++				let signature = SyncCryptoStore::sign_with(
++					&*keystore,
++					sp_consensus_babe::AuthorityId::ID,
++					&alice.to_public_crypto_pair(),
++					&to_sign,
++				).unwrap()
++				 .try_into()
++				 .unwrap();
+ 				let item = <DigestItem as CompatibleDigestItem>::babe_seal(
+-					signature.into(),
++					signature,
+ 				);
+-				slot_num += 1;
++				slot += 1;
+
+ 				let mut params = BlockImportParams::new(BlockOrigin::File, new_header);
+ 				params.post_digests.push(item);
+@@ -679,7 +697,7 @@ mod tests {
+ 				Ok(sc_service_test::TestNetComponents::new(task_manager, client, network, transaction_pool))
+ 			},
+ 			|config| {
+-				let (keep_alive, _, client, network, transaction_pool) = new_light_base(config)?;
++				let (keep_alive, _, _, client, network, transaction_pool) = new_light_base(config)?;
+ 				Ok(sc_service_test::TestNetComponents::new(keep_alive, client, network, transaction_pool))
+ 			},
+ 			vec![
+```
diff --git a/substrate/docs/media/sub.gif b/substrate/docs/media/sub.gif
new file mode 100644
index 0000000000000000000000000000000000000000..d8d73d9171aac0751961206256cf1d219416814e
Binary files /dev/null and b/substrate/docs/media/sub.gif differ
diff --git a/substrate/docs/node-template-release.md b/substrate/docs/node-template-release.md
new file mode 100644
index 0000000000000000000000000000000000000000..911e6a2bbe71aa370f34648d75f77c62ccc5a795
--- /dev/null
+++ b/substrate/docs/node-template-release.md
@@ -0,0 +1,71 @@
+# Substrate Node Template Release Process
+
+1. This release process has to be run in a github checkout Substrate directory with your work
+committed into `https://github.com/paritytech/substrate/`, because the build script will check
+the existence of your current git commit ID in the remote repository.
+
+	Assume you are in root directory of Substrate. Run:
+
+	```bash
+	cd scripts/ci/
+	./node-template-release.sh <output tar.gz file>
+	```
+
+2. Expand the output tar gzipped file and replace files in current Substrate Node Template
+by running the following command.
+
+	```bash
+	# This is where the tar.gz file uncompressed
+	cd substrate-node-template
+	# rsync with force copying. Note the slash at the destination directory is important
+	rsync -avh * <destination node-template directory>/
+	# For dry-running add `-n` argument
+	# rsync -avhn * <destination node-template directory>/
+	```
+
+	The above command only copies existing files from the source to the destination, but does not
+	delete files/directories that are removed from the source. So you need to manually check and
+	remove them in the destination.
+
+3. There is a `Cargo.toml` file in the root directory. Inside, dependencies are listed form and
+linked to a certain git commit in Substrate remote repository, such as:
+
+	```toml
+	sp-core = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", rev = "de80d0107336a9c7a2efdc0199015e4d67fcbdb5", default-features = false }
+	```
+
+	We will update each of them to link to the Rust	[crate registry](https://crates.io/).
+After confirming the versioned package is published in the crate, the above will become:
+
+	```toml
+	[workspace.dependencies]
+	sp-core = { version = "7.0.0", default-features = false }
+	```
+
+	P.S: This step can be automated if we update `node-template-release` package in
+	`scripts/ci/node-template-release`.
+
+4. Once the `Cargo.toml` is updated, compile and confirm that the Node Template builds. Then commit
+the changes to a new branch in [Substrate Node Template](https://github.com/substrate-developer-hub/substrate-node-template), and make a PR.
+
+	> Note that there is a chance the code in Substrate Node Template works with the linked Substrate git
+	commit but not with published packages due to the latest (as yet) unpublished features. In this case,
+	rollback that section of the Node Template to its previous version to ensure the Node Template builds.
+
+5. Once the PR is merged, tag the merged commit in master branch with the version number
+`vX.Y.Z+A` (e.g. `v3.0.0+1`). The `X`(major), `Y`(minor), and `Z`(patch) version number should
+follow Substrate release version. The last digit is any significant fixes made in the Substrate
+Node Template apart from Substrate. When the Substrate version is updated, this digit is reset to 0.
+
+## Troubleshooting
+
+- Running the script `./node-template-release.sh <output tar.gz file>`, after all tests passed
+	successfully, seeing the following error message:
+
+	```
+	thread 'main' panicked at 'Creates output file: Os { code: 2, kind: NotFound, message: "No such file or directory" }', src/main.rs:250:10
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+	```
+
+	This is likely due to that your output path is not a valid `tar.gz` filename or you don't have write
+	permission to the destination. Try with a simple output path such as `~/node-tpl.tar.gz`.
diff --git a/substrate/docs/rustdocs-release.md b/substrate/docs/rustdocs-release.md
new file mode 100644
index 0000000000000000000000000000000000000000..5c7e2db40a2cd3b5d3c7c3b1c92d73adbe1be32e
--- /dev/null
+++ b/substrate/docs/rustdocs-release.md
@@ -0,0 +1,20 @@
+# Rustdocs Release Process
+
+There is [a script in place](../.maintain/rustdocs-release.sh) to manage the deployment of Substrate rustdocs at
+https://paritytech.github.io/substrate, which is pushing the rustdocs file in `gh-pages` branch of
+https://github.com/paritytech/substrate.
+
+The documentation at the top of the `rustdocs-release.sh` explains most of the mechanics of the script.
+
+Manage the rustdocs deployment with one of the following commands.
+
+```bash
+# Deploy rustdocs of `monthly-2021-10` tag
+.maintain/rustdocs-release.sh deploy monthly-2021-10
+
+# In addition to the above, the `latest` symlink will point to this version of rustdocs
+.maintain/rustdocs-release.sh deploy -l monthly-2021-10
+
+# Remove the rustdocs of `monthly-2021-10` from `gh-pages`.
+.maintain/rustdocs-release.sh remove monthly-2021-10
+```
diff --git a/substrate/frame/README.md b/substrate/frame/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..47a7892c2c8d0bb702453cbecf153f62dc1d5b9d
--- /dev/null
+++ b/substrate/frame/README.md
@@ -0,0 +1,11 @@
+# FRAME
+
+The FRAME development environment provides modules (called "pallets") and support libraries that you can use, modify, and extend to build the runtime logic to suit the needs of your blockchain.
+
+### Documentation
+
+https://docs.substrate.io/reference/frame-pallets/
+
+### Issues
+
+https://github.com/orgs/paritytech/projects/40
diff --git a/substrate/frame/alliance/Cargo.toml b/substrate/frame/alliance/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..77703a7739d6e7faff61c6d64005b537bb4b08ea
--- /dev/null
+++ b/substrate/frame/alliance/Cargo.toml
@@ -0,0 +1,77 @@
+[package]
+name = "pallet-alliance"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://docs.substrate.io/"
+repository = "https://github.com/paritytech/substrate/"
+description = "The Alliance pallet provides a collective for standard-setting industry collaboration."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = { version = "6.1", optional = true }
+log = { version = "0.4.14", default-features = false }
+
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-core-hashing = { version = "9.0.0", default-features = false, path = "../../primitives/core/hashing", optional = true }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+
+pallet-identity = { version = "4.0.0-dev", path = "../identity", default-features = false }
+pallet-collective = { version = "4.0.0-dev", path = "../collective", default-features = false, optional = true }
+
+[dev-dependencies]
+array-bytes = "6.1"
+sp-core-hashing = { version = "9.0.0", default-features = false, path = "../../primitives/core/hashing" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-collective = { version = "4.0.0-dev", path = "../collective" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-collective?/std",
+	"pallet-identity/std",
+	"scale-info/std",
+	"sp-core-hashing?/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"array-bytes",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-collective/runtime-benchmarks",
+	"pallet-identity/runtime-benchmarks",
+	"sp-core-hashing",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-collective?/try-runtime",
+	"pallet-identity/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/alliance/README.md b/substrate/frame/alliance/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9930008e2d63558a9f83d906da92ecbf29f11a7a
--- /dev/null
+++ b/substrate/frame/alliance/README.md
@@ -0,0 +1,66 @@
+# Alliance Pallet
+
+The Alliance Pallet provides a collective that curates a list of accounts and URLs, deemed by
+the voting members to be unscrupulous actors. The Alliance
+
+- provides a set of ethics against bad behavior, and
+- provides recognition and influence for those teams that contribute something back to the
+  ecosystem.
+
+## Overview
+
+The network initializes the Alliance via a Root call. After that, anyone with an approved
+identity and website can join as an Ally. The `MembershipManager` origin can elevate Allies to
+Fellows, giving them voting rights within the Alliance.
+
+Voting members of the Alliance maintain a list of accounts and websites. Members can also vote
+to update the Alliance's rule and make announcements.
+
+### Terminology
+
+- Rule: The IPFS CID (hash) of the Alliance rules for the community to read and the Alliance
+  members to enforce. Similar to a Charter or Code of Conduct.
+- Announcement: An IPFS CID of some content that the Alliance want to announce.
+- Member: An account that is already in the group of the Alliance, including three types:
+  Fellow, or Ally. A member can also be kicked by the `MembershipManager` origin
+  or retire by itself.
+- Fellow: An account who is elevated from Ally by other Fellows.
+- Ally: An account who would like to join the Alliance. To become a voting member (Fellow), it
+  will need approval from the `MembershipManager` origin. Any account can join as an Ally either
+  by placing a deposit or by nomination from a voting member.
+- Unscrupulous List: A list of bad websites and addresses; items can be added or removed by
+  voting members.
+
+## Interface
+
+### Dispatchable Functions
+
+#### For General Users
+
+- `join_alliance` - Join the Alliance as an Ally. This requires a slashable deposit.
+
+#### For Members (All)
+
+- `give_retirement_notice` - Give a retirement notice and start a retirement period required to
+  pass in order to retire.
+- `retire` - Retire from the Alliance and release the caller's deposit.
+
+#### For Voting Members
+
+- `propose` - Propose a motion.
+- `vote` - Vote on a motion.
+- `close` - Close a motion with enough votes or that has expired.
+- `set_rule` - Initialize or update the Alliance's rule by IPFS CID.
+- `announce` - Make announcement by IPFS CID.
+- `nominate_ally` - Nominate a non-member to become an Ally, without deposit.
+- `elevate_ally` - Approve an ally to become a Fellow.
+- `kick_member` - Kick a member and slash its deposit.
+- `add_unscrupulous_items` - Add some items, either accounts or websites, to the list of
+  unscrupulous items.
+- `remove_unscrupulous_items` - Remove some items from the list of unscrupulous items.
+- `abdicate_fellow_status` - Abdicate one's voting rights, demoting themself to Ally.
+
+#### Root Calls
+
+- `init_members` - Initialize the Alliance, onboard fellows and allies.
+- `disband` - Disband the Alliance, remove all active members and unreserve deposits.
diff --git a/substrate/frame/alliance/src/benchmarking.rs b/substrate/frame/alliance/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb32c6c466c91a9ae1ef5b9b380025af2c6731ce
--- /dev/null
+++ b/substrate/frame/alliance/src/benchmarking.rs
@@ -0,0 +1,811 @@
+// 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.
+
+//! Alliance pallet benchmarking.
+
+use sp_runtime::traits::{Bounded, Hash, StaticLookup};
+use sp_std::{
+	cmp,
+	convert::{TryFrom, TryInto},
+	mem::size_of,
+	prelude::*,
+};
+
+use frame_benchmarking::v1::{account, benchmarks_instance_pallet, BenchmarkError};
+use frame_support::traits::{EnsureOrigin, Get, UnfilteredDispatchable};
+use frame_system::{pallet_prelude::BlockNumberFor, Pallet as System, RawOrigin as SystemOrigin};
+
+use super::{Call as AllianceCall, Pallet as Alliance, *};
+
+const SEED: u32 = 0;
+
+const MAX_BYTES: u32 = 1_024;
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn cid(input: impl AsRef<[u8]>) -> Cid {
+	let result = sp_core_hashing::sha2_256(input.as_ref());
+	Cid::new_v0(result)
+}
+
+fn rule(input: impl AsRef<[u8]>) -> Cid {
+	cid(input)
+}
+
+fn announcement(input: impl AsRef<[u8]>) -> Cid {
+	cid(input)
+}
+
+fn funded_account<T: Config<I>, I: 'static>(name: &'static str, index: u32) -> T::AccountId {
+	let account: T::AccountId = account(name, index, SEED);
+	T::Currency::make_free_balance_be(&account, BalanceOf::<T, I>::max_value() / 100u8.into());
+	account
+}
+
+fn fellow<T: Config<I>, I: 'static>(index: u32) -> T::AccountId {
+	funded_account::<T, I>("fellow", index)
+}
+
+fn ally<T: Config<I>, I: 'static>(index: u32) -> T::AccountId {
+	funded_account::<T, I>("ally", index)
+}
+
+fn outsider<T: Config<I>, I: 'static>(index: u32) -> T::AccountId {
+	funded_account::<T, I>("outsider", index)
+}
+
+fn generate_unscrupulous_account<T: Config<I>, I: 'static>(index: u32) -> T::AccountId {
+	funded_account::<T, I>("unscrupulous", index)
+}
+
+fn set_members<T: Config<I>, I: 'static>() {
+	let fellows: BoundedVec<_, T::MaxMembersCount> =
+		BoundedVec::try_from(vec![fellow::<T, I>(1), fellow::<T, I>(2)]).unwrap();
+	fellows.iter().for_each(|who| {
+		T::Currency::reserve(&who, T::AllyDeposit::get()).unwrap();
+		<DepositOf<T, I>>::insert(&who, T::AllyDeposit::get());
+	});
+	Members::<T, I>::insert(MemberRole::Fellow, fellows.clone());
+
+	let allies: BoundedVec<_, T::MaxMembersCount> =
+		BoundedVec::try_from(vec![ally::<T, I>(1)]).unwrap();
+	allies.iter().for_each(|who| {
+		T::Currency::reserve(&who, T::AllyDeposit::get()).unwrap();
+		<DepositOf<T, I>>::insert(&who, T::AllyDeposit::get());
+	});
+	Members::<T, I>::insert(MemberRole::Ally, allies);
+
+	T::InitializeMembers::initialize_members(&[fellows.as_slice()].concat());
+}
+
+benchmarks_instance_pallet! {
+	// This tests when proposal is created and queued as "proposed"
+	propose_proposed {
+		let b in 1 .. MAX_BYTES;
+		let m in 2 .. T::MaxFellows::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes_in_storage = b + size_of::<Cid>() as u32 + 32;
+
+		// Construct `members`.
+		let fellows = (0 .. m).map(fellow::<T, I>).collect::<Vec<_>>();
+		let proposer = fellows[0].clone();
+
+		Alliance::<T, I>::init_members(
+			SystemOrigin::Root.into(),
+			fellows,
+			vec![],
+		)?;
+
+		let threshold = m;
+		// Add previous proposals.
+		for i in 0 .. p - 1 {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = AllianceCall::<T, I>::set_rule {
+				rule: rule(vec![i as u8; b as usize])
+			}.into();
+			Alliance::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal),
+				bytes_in_storage,
+			)?;
+		}
+
+		let proposal: T::Proposal = AllianceCall::<T, I>::set_rule { rule: rule(vec![p as u8; b as usize]) }.into();
+
+	}: propose(SystemOrigin::Signed(proposer.clone()), threshold, Box::new(proposal.clone()), bytes_in_storage)
+	verify {
+		// New proposal is recorded
+		let proposal_hash = T::Hashing::hash_of(&proposal);
+		assert_eq!(T::ProposalProvider::proposal_of(proposal_hash), Some(proposal));
+	}
+
+	vote {
+		// We choose 5 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 5 .. T::MaxFellows::get();
+
+		let p = T::MaxProposals::get();
+		let b = MAX_BYTES;
+		let bytes_in_storage = b + size_of::<Cid>() as u32 + 32;
+
+		// Construct `members`.
+		let fellows = (0 .. m).map(fellow::<T, I>).collect::<Vec<_>>();
+		let proposer = fellows[0].clone();
+
+		let members = fellows.clone();
+
+		Alliance::<T, I>::init_members(
+			SystemOrigin::Root.into(),
+			fellows,
+			vec![],
+		)?;
+
+		// Threshold is 1 less than the number of members so that one person can vote nay
+		let threshold = m - 1;
+
+		// Add previous proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = AllianceCall::<T, I>::set_rule {
+				rule: rule(vec![i as u8; b as usize])
+			}.into();
+			Alliance::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				b,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+		}
+
+		let index = p - 1;
+		// Have almost everyone vote aye on last proposal, while keeping it from passing.
+		for j in 0 .. m - 3 {
+			let voter = &members[j as usize];
+			Alliance::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash.clone(),
+				index,
+				true,
+			)?;
+		}
+
+		let voter = members[m as usize - 3].clone();
+		// Voter votes aye without resolving the vote.
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash.clone(),
+			index,
+			true,
+		)?;
+
+		// Voter switches vote to nay, but does not kill the vote, just updates + inserts
+		let approve = false;
+
+		// Whitelist voter account from further DB operations.
+		let voter_key = frame_system::Account::<T>::hashed_key_for(&voter);
+		frame_benchmarking::benchmarking::add_to_whitelist(voter_key.into());
+	}: _(SystemOrigin::Signed(voter), last_hash.clone(), index, approve)
+	verify {
+	}
+
+	close_early_disapproved {
+		// We choose 4 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 4 .. T::MaxFellows::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes = 100;
+		let bytes_in_storage = bytes + size_of::<Cid>() as u32 + 32;
+
+		// Construct `members`.
+		let fellows = (0 .. m).map(fellow::<T, I>).collect::<Vec<_>>();
+
+		let members = fellows.clone();
+
+		Alliance::<T, I>::init_members(
+			SystemOrigin::Root.into(),
+			fellows,
+			vec![],
+		)?;
+
+		let proposer = members[0].clone();
+		let voter = members[1].clone();
+
+		// Threshold is total members so that one nay will disapprove the vote
+		let threshold = m;
+
+		// Add previous proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = AllianceCall::<T, I>::set_rule {
+				rule: rule(vec![i as u8; bytes as usize])
+			}.into();
+			Alliance::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+			assert_eq!(T::ProposalProvider::proposal_of(last_hash), Some(proposal));
+		}
+
+		let index = p - 1;
+		// Have most everyone vote aye on last proposal, while keeping it from passing.
+		for j in 2 .. m - 1 {
+			let voter = &members[j as usize];
+			Alliance::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash.clone(),
+				index,
+				true,
+			)?;
+		}
+
+		// Voter votes aye without resolving the vote.
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash.clone(),
+			index,
+			true,
+		)?;
+
+		// Voter switches vote to nay, which kills the vote
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash.clone(),
+			index,
+			false,
+		)?;
+
+		// Whitelist voter account from further DB operations.
+		let voter_key = frame_system::Account::<T>::hashed_key_for(&voter);
+		frame_benchmarking::benchmarking::add_to_whitelist(voter_key.into());
+	}: close(SystemOrigin::Signed(voter), last_hash.clone(), index, Weight::MAX, bytes_in_storage)
+	verify {
+		// The last proposal is removed.
+		assert_eq!(T::ProposalProvider::proposal_of(last_hash), None);
+	}
+
+	close_early_approved {
+		let b in 1 .. MAX_BYTES;
+		// We choose 4 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 4 .. T::MaxFellows::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes_in_storage = b + size_of::<Cid>() as u32 + 32;
+
+		// Construct `members`.
+		let fellows = (0 .. m).map(fellow::<T, I>).collect::<Vec<_>>();
+
+		let members = fellows.clone();
+
+		Alliance::<T, I>::init_members(
+			SystemOrigin::Root.into(),
+			fellows,
+			vec![],
+		)?;
+
+		let proposer = members[0].clone();
+		let voter = members[1].clone();
+
+		// Threshold is 2 so any two ayes will approve the vote
+		let threshold = 2;
+
+		// Add previous proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = AllianceCall::<T, I>::set_rule {
+				rule: rule(vec![i as u8; b as usize])
+			}.into();
+			Alliance::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+			assert_eq!(T::ProposalProvider::proposal_of(last_hash), Some(proposal));
+		}
+
+		let index = p - 1;
+		// Caller switches vote to nay on their own proposal, allowing them to be the deciding approval vote
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(proposer.clone()).into(),
+			last_hash.clone(),
+			index,
+			false,
+		)?;
+
+		// Have almost everyone vote nay on last proposal, while keeping it from failing.
+		for j in 2 .. m - 1 {
+			let voter = &members[j as usize];
+			Alliance::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash.clone(),
+				index,
+				false,
+			)?;
+		}
+
+		// Member zero is the first aye
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(members[0].clone()).into(),
+			last_hash.clone(),
+			index,
+			true,
+		)?;
+
+		let voter = members[1].clone();
+		// Caller switches vote to aye, which passes the vote
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash.clone(),
+			index,
+			true,
+		)?;
+	}: close(SystemOrigin::Signed(voter), last_hash.clone(), index, Weight::MAX, bytes_in_storage)
+	verify {
+		// The last proposal is removed.
+		assert_eq!(T::ProposalProvider::proposal_of(last_hash), None);
+	}
+
+	close_disapproved {
+		// We choose 4 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 2 .. T::MaxFellows::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes = 100;
+		let bytes_in_storage = bytes + size_of::<Cid>() as u32 + 32;
+
+		// Construct `members`.
+		let fellows = (0 .. m).map(fellow::<T, I>).collect::<Vec<_>>();
+
+		let members = fellows.clone();
+
+		Alliance::<T, I>::init_members(
+			SystemOrigin::Root.into(),
+			fellows,
+			vec![],
+		)?;
+
+		let proposer = members[0].clone();
+		let voter = members[1].clone();
+
+		// Threshold is one less than total members so that two nays will disapprove the vote
+		let threshold = m - 1;
+
+		// Add proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = AllianceCall::<T, I>::set_rule {
+				rule: rule(vec![i as u8; bytes as usize])
+			}.into();
+			Alliance::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+			assert_eq!(T::ProposalProvider::proposal_of(last_hash), Some(proposal));
+		}
+
+		let index = p - 1;
+		// Have almost everyone vote aye on last proposal, while keeping it from passing.
+		// A few abstainers will be the nay votes needed to fail the vote.
+		for j in 2 .. m - 1 {
+			let voter = &members[j as usize];
+			Alliance::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash.clone(),
+				index,
+				true,
+			)?;
+		}
+
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash.clone(),
+			index,
+			false,
+		)?;
+
+		System::<T>::set_block_number(BlockNumberFor::<T>::max_value());
+
+	}: close(SystemOrigin::Signed(voter), last_hash.clone(), index, Weight::MAX, bytes_in_storage)
+	verify {
+		// The last proposal is removed.
+		assert_eq!(T::ProposalProvider::proposal_of(last_hash), None);
+	}
+
+	close_approved {
+		let b in 1 .. MAX_BYTES;
+		// We choose 4 fellows as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 5 .. T::MaxFellows::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes_in_storage = b + size_of::<Cid>() as u32 + 32;
+
+		// Construct `members`.
+		let fellows = (0 .. m).map(fellow::<T, I>).collect::<Vec<_>>();
+
+		let members = fellows.clone();
+
+		Alliance::<T, I>::init_members(
+			SystemOrigin::Root.into(),
+			fellows,
+			vec![],
+		)?;
+
+		let proposer = members[0].clone();
+		let voter = members[1].clone();
+
+		// Threshold is two, so any two ayes will pass the vote
+		let threshold = 2;
+
+		// Add proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = AllianceCall::<T, I>::set_rule {
+				rule: rule(vec![i as u8; b as usize])
+			}.into();
+			Alliance::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+			assert_eq!(T::ProposalProvider::proposal_of(last_hash), Some(proposal));
+		}
+
+		// The prime member votes aye, so abstentions default to aye.
+		Alliance::<T, I>::vote(
+			SystemOrigin::Signed(proposer.clone()).into(),
+			last_hash.clone(),
+			p - 1,
+			true // Vote aye.
+		)?;
+
+		let index = p - 1;
+		// Have almost everyone vote nay on last proposal, while keeping it from failing.
+		// A few abstainers will be the aye votes needed to pass the vote.
+		for j in 2 .. m - 1 {
+			let voter = &members[j as usize];
+			Alliance::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash.clone(),
+				index,
+				false
+			)?;
+		}
+
+		// caller is prime, prime already votes aye by creating the proposal
+		System::<T>::set_block_number(BlockNumberFor::<T>::max_value());
+
+	}: close(SystemOrigin::Signed(voter), last_hash.clone(), index, Weight::MAX, bytes_in_storage)
+	verify {
+		// The last proposal is removed.
+		assert_eq!(T::ProposalProvider::proposal_of(last_hash), None);
+	}
+
+	init_members {
+		// at least 1 fellow
+		let m in 1 .. T::MaxFellows::get();
+		let z in 0 .. T::MaxAllies::get();
+
+		let mut fellows = (0 .. m).map(fellow::<T, I>).collect::<Vec<_>>();
+		let mut allies = (0 .. z).map(ally::<T, I>).collect::<Vec<_>>();
+
+	}: _(SystemOrigin::Root, fellows.clone(), allies.clone())
+	verify {
+		fellows.sort();
+		allies.sort();
+		assert_last_event::<T, I>(Event::MembersInitialized {
+			fellows: fellows.clone(),
+			allies: allies.clone(),
+		}.into());
+		assert_eq!(Alliance::<T, I>::members(MemberRole::Fellow), fellows);
+		assert_eq!(Alliance::<T, I>::members(MemberRole::Ally), allies);
+	}
+
+	disband {
+		// at least 1 founders
+		let x in 1 .. T::MaxFellows::get();
+		let y in 0 .. T::MaxAllies::get();
+		let z in 0 .. T::MaxMembersCount::get() / 2;
+
+		let fellows = (0 .. x).map(fellow::<T, I>).collect::<Vec<_>>();
+		let allies = (0 .. y).map(ally::<T, I>).collect::<Vec<_>>();
+		let witness = DisbandWitness{
+			fellow_members: x,
+			ally_members: y,
+		};
+
+		// setting the Alliance to disband on the benchmark call
+		Alliance::<T, I>::init_members(
+			SystemOrigin::Root.into(),
+			fellows.clone(),
+			allies.clone(),
+		)?;
+
+		// reserve deposits
+		let deposit = T::AllyDeposit::get();
+		for member in fellows.iter().chain(allies.iter()).take(z as usize) {
+			T::Currency::reserve(&member, deposit)?;
+			<DepositOf<T, I>>::insert(&member, deposit);
+		}
+
+		assert_eq!(Alliance::<T, I>::voting_members_count(), x);
+		assert_eq!(Alliance::<T, I>::ally_members_count(), y);
+	}: _(SystemOrigin::Root, witness)
+	verify {
+		assert_last_event::<T, I>(Event::AllianceDisbanded {
+			fellow_members: x,
+			ally_members: y,
+			unreserved: cmp::min(z, x + y),
+		}.into());
+
+		assert!(!Alliance::<T, I>::is_initialized());
+	}
+
+	set_rule {
+		set_members::<T, I>();
+
+		let rule = rule(b"hello world");
+
+		let call = Call::<T, I>::set_rule { rule: rule.clone() };
+		let origin =
+			T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_eq!(Alliance::<T, I>::rule(), Some(rule.clone()));
+		assert_last_event::<T, I>(Event::NewRuleSet { rule }.into());
+	}
+
+	announce {
+		set_members::<T, I>();
+
+		let announcement = announcement(b"hello world");
+
+		let call = Call::<T, I>::announce { announcement: announcement.clone() };
+		let origin =
+			T::AnnouncementOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert!(Alliance::<T, I>::announcements().contains(&announcement));
+		assert_last_event::<T, I>(Event::Announced { announcement }.into());
+	}
+
+	remove_announcement {
+		set_members::<T, I>();
+
+		let announcement = announcement(b"hello world");
+		let announcements: BoundedVec<_, T::MaxAnnouncementsCount> = BoundedVec::try_from(vec![announcement.clone()]).unwrap();
+		Announcements::<T, I>::put(announcements);
+
+		let call = Call::<T, I>::remove_announcement { announcement: announcement.clone() };
+		let origin =
+			T::AnnouncementOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert!(Alliance::<T, I>::announcements().is_empty());
+		assert_last_event::<T, I>(Event::AnnouncementRemoved { announcement }.into());
+	}
+
+	join_alliance {
+		set_members::<T, I>();
+
+		let outsider = outsider::<T, I>(1);
+		assert!(!Alliance::<T, I>::is_member(&outsider));
+		assert_eq!(DepositOf::<T, I>::get(&outsider), None);
+	}: _(SystemOrigin::Signed(outsider.clone()))
+	verify {
+		assert!(Alliance::<T, I>::is_member_of(&outsider, MemberRole::Ally)); // outsider is now an ally
+		assert_eq!(DepositOf::<T, I>::get(&outsider), Some(T::AllyDeposit::get())); // with a deposit
+		assert!(!Alliance::<T, I>::has_voting_rights(&outsider)); // allies don't have voting rights
+		assert_last_event::<T, I>(Event::NewAllyJoined {
+			ally: outsider,
+			nominator: None,
+			reserved: Some(T::AllyDeposit::get())
+		}.into());
+	}
+
+	nominate_ally {
+		set_members::<T, I>();
+
+		let fellow1 = fellow::<T, I>(1);
+		assert!(Alliance::<T, I>::is_member_of(&fellow1, MemberRole::Fellow));
+
+		let outsider = outsider::<T, I>(1);
+		assert!(!Alliance::<T, I>::is_member(&outsider));
+		assert_eq!(DepositOf::<T, I>::get(&outsider), None);
+
+		let outsider_lookup = T::Lookup::unlookup(outsider.clone());
+	}: _(SystemOrigin::Signed(fellow1.clone()), outsider_lookup)
+	verify {
+		assert!(Alliance::<T, I>::is_member_of(&outsider, MemberRole::Ally)); // outsider is now an ally
+		assert_eq!(DepositOf::<T, I>::get(&outsider), None); // without a deposit
+		assert!(!Alliance::<T, I>::has_voting_rights(&outsider)); // allies don't have voting rights
+		assert_last_event::<T, I>(Event::NewAllyJoined {
+			ally: outsider,
+			nominator: Some(fellow1),
+			reserved: None
+		}.into());
+	}
+
+	elevate_ally {
+		set_members::<T, I>();
+
+		let ally1 = ally::<T, I>(1);
+		assert!(Alliance::<T, I>::is_ally(&ally1));
+
+		let ally1_lookup = T::Lookup::unlookup(ally1.clone());
+		let call = Call::<T, I>::elevate_ally { ally: ally1_lookup };
+		let origin =
+			T::MembershipManager::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert!(!Alliance::<T, I>::is_ally(&ally1));
+		assert!(Alliance::<T, I>::has_voting_rights(&ally1));
+		assert_last_event::<T, I>(Event::AllyElevated { ally: ally1 }.into());
+	}
+
+	give_retirement_notice {
+		set_members::<T, I>();
+		let fellow2 = fellow::<T, I>(2);
+
+		assert!(Alliance::<T, I>::has_voting_rights(&fellow2));
+	}: _(SystemOrigin::Signed(fellow2.clone()))
+	verify {
+		assert!(Alliance::<T, I>::is_member_of(&fellow2, MemberRole::Retiring));
+
+		assert_eq!(
+			RetiringMembers::<T, I>::get(&fellow2),
+			Some(System::<T>::block_number() + T::RetirementPeriod::get())
+		);
+		assert_last_event::<T, I>(
+			Event::MemberRetirementPeriodStarted {member: fellow2}.into()
+		);
+	}
+
+	retire {
+		set_members::<T, I>();
+
+		let fellow2 = fellow::<T, I>(2);
+		assert!(Alliance::<T, I>::has_voting_rights(&fellow2));
+
+		assert_eq!(
+			Alliance::<T, I>::give_retirement_notice(
+				SystemOrigin::Signed(fellow2.clone()).into()
+			),
+			Ok(())
+		);
+		System::<T>::set_block_number(System::<T>::block_number() + T::RetirementPeriod::get());
+
+		assert_eq!(DepositOf::<T, I>::get(&fellow2), Some(T::AllyDeposit::get()));
+	}: _(SystemOrigin::Signed(fellow2.clone()))
+	verify {
+		assert!(!Alliance::<T, I>::is_member(&fellow2));
+		assert_eq!(DepositOf::<T, I>::get(&fellow2), None);
+		assert_last_event::<T, I>(Event::MemberRetired {
+			member: fellow2,
+			unreserved: Some(T::AllyDeposit::get())
+		}.into());
+	}
+
+	kick_member {
+		set_members::<T, I>();
+
+		let fellow2 = fellow::<T, I>(2);
+		assert!(Alliance::<T, I>::is_member_of(&fellow2, MemberRole::Fellow));
+		assert_eq!(DepositOf::<T, I>::get(&fellow2), Some(T::AllyDeposit::get()));
+
+		let fellow2_lookup = T::Lookup::unlookup(fellow2.clone());
+		let call = Call::<T, I>::kick_member { who: fellow2_lookup };
+		let origin =
+			T::MembershipManager::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert!(!Alliance::<T, I>::is_member(&fellow2));
+		assert_eq!(DepositOf::<T, I>::get(&fellow2), None);
+		assert_last_event::<T, I>(Event::MemberKicked {
+			member: fellow2,
+			slashed: Some(T::AllyDeposit::get())
+		}.into());
+	}
+
+	add_unscrupulous_items {
+		let n in 0 .. T::MaxUnscrupulousItems::get();
+		let l in 0 .. T::MaxWebsiteUrlLength::get();
+
+		set_members::<T, I>();
+
+		let accounts = (0 .. n)
+			.map(|i| generate_unscrupulous_account::<T, I>(i))
+			.collect::<Vec<_>>();
+		let websites = (0 .. n).map(|i| -> BoundedVec<u8, T::MaxWebsiteUrlLength> {
+			BoundedVec::try_from(vec![i as u8; l as usize]).unwrap()
+		}).collect::<Vec<_>>();
+
+		let mut unscrupulous_list = Vec::with_capacity(accounts.len() + websites.len());
+		unscrupulous_list.extend(accounts.into_iter().map(UnscrupulousItem::AccountId));
+		unscrupulous_list.extend(websites.into_iter().map(UnscrupulousItem::Website));
+
+		let call = Call::<T, I>::add_unscrupulous_items { items: unscrupulous_list.clone() };
+		let origin =
+			T::AnnouncementOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::UnscrupulousItemAdded { items: unscrupulous_list }.into());
+	}
+
+	remove_unscrupulous_items {
+		let n in 0 .. T::MaxUnscrupulousItems::get();
+		let l in 0 .. T::MaxWebsiteUrlLength::get();
+
+		set_members::<T, I>();
+
+		let mut accounts = (0 .. n)
+			.map(|i| generate_unscrupulous_account::<T, I>(i))
+			.collect::<Vec<_>>();
+		accounts.sort();
+		let accounts: BoundedVec<_, T::MaxUnscrupulousItems> = accounts.try_into().unwrap();
+		UnscrupulousAccounts::<T, I>::put(accounts.clone());
+
+		let mut websites = (0 .. n).map(|i| -> BoundedVec<_, T::MaxWebsiteUrlLength>
+			{ BoundedVec::try_from(vec![i as u8; l as usize]).unwrap() }).collect::<Vec<_>>();
+		websites.sort();
+		let websites: BoundedVec<_, T::MaxUnscrupulousItems> = websites.try_into().unwrap();
+		UnscrupulousWebsites::<T, I>::put(websites.clone());
+
+		let mut unscrupulous_list = Vec::with_capacity(accounts.len() + websites.len());
+		unscrupulous_list.extend(accounts.into_iter().map(UnscrupulousItem::AccountId));
+		unscrupulous_list.extend(websites.into_iter().map(UnscrupulousItem::Website));
+
+		let call = Call::<T, I>::remove_unscrupulous_items { items: unscrupulous_list.clone() };
+		let origin =
+			T::AnnouncementOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::UnscrupulousItemRemoved { items: unscrupulous_list }.into());
+	}
+
+	abdicate_fellow_status {
+		set_members::<T, I>();
+		let fellow2 = fellow::<T, I>(2);
+		assert!(Alliance::<T, I>::has_voting_rights(&fellow2));
+	}: _(SystemOrigin::Signed(fellow2.clone()))
+	verify {
+		assert!(Alliance::<T, I>::is_member_of(&fellow2, MemberRole::Ally));
+
+		assert_last_event::<T, I>(
+			Event::FellowAbdicated {fellow: fellow2}.into()
+		);
+	}
+
+	impl_benchmark_test_suite!(Alliance, crate::mock::new_bench_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/alliance/src/lib.rs b/substrate/frame/alliance/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1986354a0941c6659d72a190edc8c48805e1d3e8
--- /dev/null
+++ b/substrate/frame/alliance/src/lib.rs
@@ -0,0 +1,1126 @@
+// 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.
+
+//! # Alliance Pallet
+//!
+//! The Alliance Pallet provides a collective that curates a list of accounts and URLs, deemed by
+//! the voting members to be unscrupulous actors. The Alliance
+//!
+//! - provides a set of ethics against bad behavior, and
+//! - provides recognition and influence for those teams that contribute something back to the
+//!   ecosystem.
+//!
+//! ## Overview
+//!
+//! The network initializes the Alliance via a Root call. After that, anyone with an approved
+//! identity and website can join as an Ally. The `MembershipManager` origin can elevate Allies to
+//! Fellows, giving them voting rights within the Alliance.
+//!
+//! Voting members of the Alliance maintain a list of accounts and websites. Members can also vote
+//! to update the Alliance's rule and make announcements.
+//!
+//! ### Terminology
+//!
+//! - Rule: The IPFS CID (hash) of the Alliance rules for the community to read and the Alliance
+//!   members to enforce. Similar to a Charter or Code of Conduct.
+//! - Announcement: An IPFS CID of some content that the Alliance want to announce.
+//! - Member: An account that is already in the group of the Alliance, including two types: Fellow,
+//!   or Ally. A member can also be kicked by the `MembershipManager` origin or retire by itself.
+//! - Fellow: An account who is elevated from Ally by other Fellows.
+//! - Ally: An account who would like to join the Alliance. To become a voting member (Fellow), it
+//!   will need approval from the `MembershipManager` origin. Any account can join as an Ally either
+//!   by placing a deposit or by nomination from a voting member.
+//! - Unscrupulous List: A list of bad websites and addresses; items can be added or removed by
+//!   voting members.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! #### For General Users
+//!
+//! - `join_alliance` - Join the Alliance as an Ally. This requires a slashable deposit.
+//!
+//! #### For Members (All)
+//!
+//! - `give_retirement_notice` - Give a retirement notice and start a retirement period required to
+//!   pass in order to retire.
+//! - `retire` - Retire from the Alliance and release the caller's deposit.
+//!
+//! #### For Voting Members
+//!
+//! - `propose` - Propose a motion.
+//! - `vote` - Vote on a motion.
+//! - `close` - Close a motion with enough votes or that has expired.
+//! - `set_rule` - Initialize or update the Alliance's rule by IPFS CID.
+//! - `announce` - Make announcement by IPFS CID.
+//! - `nominate_ally` - Nominate a non-member to become an Ally, without deposit.
+//! - `elevate_ally` - Approve an ally to become a Fellow.
+//! - `kick_member` - Kick a member and slash its deposit.
+//! - `add_unscrupulous_items` - Add some items, either accounts or websites, to the list of
+//!   unscrupulous items.
+//! - `remove_unscrupulous_items` - Remove some items from the list of unscrupulous items.
+//! - `abdicate_fellow_status` - Abdicate one's voting rights, demoting themself to Ally.
+//!
+//! #### Root Calls
+//!
+//! - `init_members` - Initialize the Alliance, onboard fellows and allies.
+//! - `disband` - Disband the Alliance, remove all active members and unreserve deposits.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod migration;
+mod types;
+pub mod weights;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+use sp_runtime::{
+	traits::{Saturating, StaticLookup, Zero},
+	RuntimeDebug,
+};
+use sp_std::{convert::TryInto, prelude::*};
+
+use frame_support::{
+	dispatch::{
+		DispatchError, DispatchResult, DispatchResultWithPostInfo, Dispatchable, GetDispatchInfo,
+		PostDispatchInfo,
+	},
+	ensure,
+	traits::{
+		ChangeMembers, Currency, Get, InitializeMembers, IsSubType, OnUnbalanced,
+		ReservableCurrency,
+	},
+	weights::Weight,
+};
+use pallet_identity::IdentityField;
+use scale_info::TypeInfo;
+
+pub use pallet::*;
+pub use types::*;
+pub use weights::*;
+
+/// The log target of this pallet.
+pub const LOG_TARGET: &str = "runtime::alliance";
+
+/// Simple index type for proposal counting.
+pub type ProposalIndex = u32;
+
+type UrlOf<T, I> = BoundedVec<u8, <T as pallet::Config<I>>::MaxWebsiteUrlLength>;
+
+type BalanceOf<T, I> =
+	<<T as Config<I>>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type NegativeImbalanceOf<T, I> = <<T as Config<I>>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+
+/// Interface required for identity verification.
+pub trait IdentityVerifier<AccountId> {
+	/// Function that returns whether an account has an identity registered with the identity
+	/// provider.
+	fn has_identity(who: &AccountId, fields: u64) -> bool;
+
+	/// Whether an account has been deemed "good" by the provider.
+	fn has_good_judgement(who: &AccountId) -> bool;
+
+	/// If the identity provider allows sub-accounts, provide the super of an account. Should
+	/// return `None` if the provider does not allow sub-accounts or if the account is not a sub.
+	fn super_account_id(who: &AccountId) -> Option<AccountId>;
+}
+
+/// The non-provider. Imposes no restrictions on account identity.
+impl<AccountId> IdentityVerifier<AccountId> for () {
+	fn has_identity(_who: &AccountId, _fields: u64) -> bool {
+		true
+	}
+
+	fn has_good_judgement(_who: &AccountId) -> bool {
+		true
+	}
+
+	fn super_account_id(_who: &AccountId) -> Option<AccountId> {
+		None
+	}
+}
+
+/// The provider of a collective action interface, for example an instance of `pallet-collective`.
+pub trait ProposalProvider<AccountId, Hash, Proposal> {
+	/// Add a new proposal.
+	/// Returns a proposal length and active proposals count if successful.
+	fn propose_proposal(
+		who: AccountId,
+		threshold: u32,
+		proposal: Box<Proposal>,
+		length_bound: u32,
+	) -> Result<(u32, u32), DispatchError>;
+
+	/// Add an aye or nay vote for the sender to the given proposal.
+	/// Returns true if the sender votes first time if successful.
+	fn vote_proposal(
+		who: AccountId,
+		proposal: Hash,
+		index: ProposalIndex,
+		approve: bool,
+	) -> Result<bool, DispatchError>;
+
+	/// Close a proposal that is either approved, disapproved, or whose voting period has ended.
+	fn close_proposal(
+		proposal_hash: Hash,
+		index: ProposalIndex,
+		proposal_weight_bound: Weight,
+		length_bound: u32,
+	) -> DispatchResultWithPostInfo;
+
+	/// Return a proposal of the given hash.
+	fn proposal_of(proposal_hash: Hash) -> Option<Proposal>;
+}
+
+/// The various roles that a member can hold.
+#[derive(Copy, Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub enum MemberRole {
+	Fellow,
+	Ally,
+	Retiring,
+}
+
+/// The type of item that may be deemed unscrupulous.
+#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub enum UnscrupulousItem<AccountId, Url> {
+	AccountId(AccountId),
+	Website(Url),
+}
+
+type UnscrupulousItemOf<T, I> =
+	UnscrupulousItem<<T as frame_system::Config>::AccountId, UrlOf<T, I>>;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::pallet]
+	#[pallet::storage_version(migration::STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The runtime call dispatch type.
+		type Proposal: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ From<frame_system::Call<Self>>
+			+ From<Call<Self, I>>
+			+ GetDispatchInfo
+			+ IsSubType<Call<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+
+		/// Origin for admin-level operations, like setting the Alliance's rules.
+		type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin that manages entry and forcible discharge from the Alliance.
+		type MembershipManager: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin for making announcements and adding/removing unscrupulous items.
+		type AnnouncementOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The currency used for deposits.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// What to do with slashed funds.
+		type Slashed: OnUnbalanced<NegativeImbalanceOf<Self, I>>;
+
+		/// What to do with initial voting members of the Alliance.
+		type InitializeMembers: InitializeMembers<Self::AccountId>;
+
+		/// What to do when a member has been added or removed.
+		type MembershipChanged: ChangeMembers<Self::AccountId>;
+
+		/// The identity verifier of an Alliance member.
+		type IdentityVerifier: IdentityVerifier<Self::AccountId>;
+
+		/// The provider of the proposal operation.
+		type ProposalProvider: ProposalProvider<Self::AccountId, Self::Hash, Self::Proposal>;
+
+		/// Maximum number of proposals allowed to be active in parallel.
+		type MaxProposals: Get<ProposalIndex>;
+
+		/// The maximum number of Fellows supported by the pallet. Used for weight estimation.
+		///
+		/// NOTE:
+		/// + Benchmarks will need to be re-run and weights adjusted if this changes.
+		/// + This pallet assumes that dependencies keep to the limit without enforcing it.
+		type MaxFellows: Get<u32>;
+
+		/// The maximum number of Allies supported by the pallet. Used for weight estimation.
+		///
+		/// NOTE:
+		/// + Benchmarks will need to be re-run and weights adjusted if this changes.
+		/// + This pallet assumes that dependencies keep to the limit without enforcing it.
+		type MaxAllies: Get<u32>;
+
+		/// The maximum number of the unscrupulous items supported by the pallet.
+		#[pallet::constant]
+		type MaxUnscrupulousItems: Get<u32>;
+
+		/// The maximum length of a website URL.
+		#[pallet::constant]
+		type MaxWebsiteUrlLength: Get<u32>;
+
+		/// The deposit required for submitting candidacy.
+		#[pallet::constant]
+		type AllyDeposit: Get<BalanceOf<Self, I>>;
+
+		/// The maximum number of announcements.
+		#[pallet::constant]
+		type MaxAnnouncementsCount: Get<u32>;
+
+		/// The maximum number of members per member role.
+		#[pallet::constant]
+		type MaxMembersCount: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The number of blocks a member must wait between giving a retirement notice and retiring.
+		/// Supposed to be greater than time required to `kick_member`.
+		type RetirementPeriod: Get<BlockNumberFor<Self>>;
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// The Alliance has not been initialized yet, therefore accounts cannot join it.
+		AllianceNotYetInitialized,
+		/// The Alliance has been initialized, therefore cannot be initialized again.
+		AllianceAlreadyInitialized,
+		/// Account is already a member.
+		AlreadyMember,
+		/// Account is not a member.
+		NotMember,
+		/// Account is not an ally.
+		NotAlly,
+		/// Account does not have voting rights.
+		NoVotingRights,
+		/// Account is already an elevated (fellow) member.
+		AlreadyElevated,
+		/// Item is already listed as unscrupulous.
+		AlreadyUnscrupulous,
+		/// Account has been deemed unscrupulous by the Alliance and is not welcome to join or be
+		/// nominated.
+		AccountNonGrata,
+		/// Item has not been deemed unscrupulous.
+		NotListedAsUnscrupulous,
+		/// The number of unscrupulous items exceeds `MaxUnscrupulousItems`.
+		TooManyUnscrupulousItems,
+		/// Length of website URL exceeds `MaxWebsiteUrlLength`.
+		TooLongWebsiteUrl,
+		/// Balance is insufficient for the required deposit.
+		InsufficientFunds,
+		/// The account's identity does not have display field and website field.
+		WithoutIdentityDisplayAndWebsite,
+		/// The account's identity has no good judgement.
+		WithoutGoodIdentityJudgement,
+		/// The proposal hash is not found.
+		MissingProposalHash,
+		/// The announcement is not found.
+		MissingAnnouncement,
+		/// Number of members exceeds `MaxMembersCount`.
+		TooManyMembers,
+		/// Number of announcements exceeds `MaxAnnouncementsCount`.
+		TooManyAnnouncements,
+		/// Invalid witness data given.
+		BadWitness,
+		/// Account already gave retirement notice
+		AlreadyRetiring,
+		/// Account did not give a retirement notice required to retire.
+		RetirementNoticeNotGiven,
+		/// Retirement period has not passed.
+		RetirementPeriodNotPassed,
+		/// Fellows must be provided to initialize the Alliance.
+		FellowsMissing,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A new rule has been set.
+		NewRuleSet { rule: Cid },
+		/// A new announcement has been proposed.
+		Announced { announcement: Cid },
+		/// An on-chain announcement has been removed.
+		AnnouncementRemoved { announcement: Cid },
+		/// Some accounts have been initialized as members (fellows/allies).
+		MembersInitialized { fellows: Vec<T::AccountId>, allies: Vec<T::AccountId> },
+		/// An account has been added as an Ally and reserved its deposit.
+		NewAllyJoined {
+			ally: T::AccountId,
+			nominator: Option<T::AccountId>,
+			reserved: Option<BalanceOf<T, I>>,
+		},
+		/// An ally has been elevated to Fellow.
+		AllyElevated { ally: T::AccountId },
+		/// A member gave retirement notice and their retirement period started.
+		MemberRetirementPeriodStarted { member: T::AccountId },
+		/// A member has retired with its deposit unreserved.
+		MemberRetired { member: T::AccountId, unreserved: Option<BalanceOf<T, I>> },
+		/// A member has been kicked out with its deposit slashed.
+		MemberKicked { member: T::AccountId, slashed: Option<BalanceOf<T, I>> },
+		/// Accounts or websites have been added into the list of unscrupulous items.
+		UnscrupulousItemAdded { items: Vec<UnscrupulousItemOf<T, I>> },
+		/// Accounts or websites have been removed from the list of unscrupulous items.
+		UnscrupulousItemRemoved { items: Vec<UnscrupulousItemOf<T, I>> },
+		/// Alliance disbanded. Includes number deleted members and unreserved deposits.
+		AllianceDisbanded { fellow_members: u32, ally_members: u32, unreserved: u32 },
+		/// A Fellow abdicated their voting rights. They are now an Ally.
+		FellowAbdicated { fellow: T::AccountId },
+	}
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub fellows: Vec<T::AccountId>,
+		pub allies: Vec<T::AccountId>,
+		#[serde(skip)]
+		pub phantom: PhantomData<(T, I)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			for m in self.fellows.iter().chain(self.allies.iter()) {
+				assert!(Pallet::<T, I>::has_identity(m).is_ok(), "Member does not set identity!");
+			}
+
+			if !self.fellows.is_empty() {
+				assert!(
+					!Pallet::<T, I>::has_member(MemberRole::Fellow),
+					"Fellows are already initialized!"
+				);
+				let members: BoundedVec<T::AccountId, T::MaxMembersCount> =
+					self.fellows.clone().try_into().expect("Too many genesis fellows");
+				Members::<T, I>::insert(MemberRole::Fellow, members);
+			}
+			if !self.allies.is_empty() {
+				assert!(
+					!Pallet::<T, I>::has_member(MemberRole::Ally),
+					"Allies are already initialized!"
+				);
+				assert!(
+					!self.fellows.is_empty(),
+					"Fellows must be provided to initialize the Alliance"
+				);
+				let members: BoundedVec<T::AccountId, T::MaxMembersCount> =
+					self.allies.clone().try_into().expect("Too many genesis allies");
+				Members::<T, I>::insert(MemberRole::Ally, members);
+			}
+
+			T::InitializeMembers::initialize_members(self.fellows.as_slice())
+		}
+	}
+
+	/// The IPFS CID of the alliance rule.
+	/// Fellows can propose a new rule with a super-majority.
+	#[pallet::storage]
+	#[pallet::getter(fn rule)]
+	pub type Rule<T: Config<I>, I: 'static = ()> = StorageValue<_, Cid, OptionQuery>;
+
+	/// The current IPFS CIDs of any announcements.
+	#[pallet::storage]
+	#[pallet::getter(fn announcements)]
+	pub type Announcements<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<Cid, T::MaxAnnouncementsCount>, ValueQuery>;
+
+	/// Maps members to their candidacy deposit.
+	#[pallet::storage]
+	#[pallet::getter(fn deposit_of)]
+	pub type DepositOf<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, BalanceOf<T, I>, OptionQuery>;
+
+	/// Maps member type to members of each type.
+	#[pallet::storage]
+	#[pallet::getter(fn members)]
+	pub type Members<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Twox64Concat,
+		MemberRole,
+		BoundedVec<T::AccountId, T::MaxMembersCount>,
+		ValueQuery,
+	>;
+
+	/// A set of members who gave a retirement notice. They can retire after the end of retirement
+	/// period stored as a future block number.
+	#[pallet::storage]
+	#[pallet::getter(fn retiring_members)]
+	pub type RetiringMembers<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, BlockNumberFor<T>, OptionQuery>;
+
+	/// The current list of accounts deemed unscrupulous. These accounts non grata cannot submit
+	/// candidacy.
+	#[pallet::storage]
+	#[pallet::getter(fn unscrupulous_accounts)]
+	pub type UnscrupulousAccounts<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<T::AccountId, T::MaxUnscrupulousItems>, ValueQuery>;
+
+	/// The current list of websites deemed unscrupulous.
+	#[pallet::storage]
+	#[pallet::getter(fn unscrupulous_websites)]
+	pub type UnscrupulousWebsites<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<UrlOf<T, I>, T::MaxUnscrupulousItems>, ValueQuery>;
+
+	#[pallet::call(weight(<T as Config<I>>::WeightInfo))]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Add a new proposal to be voted on.
+		///
+		/// Must be called by a Fellow.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::propose_proposed(
+			*length_bound, // B
+			T::MaxFellows::get(), // M
+			T::MaxProposals::get(), // P2
+		))]
+		pub fn propose(
+			origin: OriginFor<T>,
+			#[pallet::compact] threshold: u32,
+			proposal: Box<<T as Config<I>>::Proposal>,
+			#[pallet::compact] length_bound: u32,
+		) -> DispatchResult {
+			let proposor = ensure_signed(origin)?;
+			ensure!(Self::has_voting_rights(&proposor), Error::<T, I>::NoVotingRights);
+
+			T::ProposalProvider::propose_proposal(proposor, threshold, proposal, length_bound)?;
+			Ok(())
+		}
+
+		/// Add an aye or nay vote for the sender to the given proposal.
+		///
+		/// Must be called by a Fellow.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::vote(T::MaxFellows::get()))]
+		pub fn vote(
+			origin: OriginFor<T>,
+			proposal: T::Hash,
+			#[pallet::compact] index: ProposalIndex,
+			approve: bool,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			ensure!(Self::has_voting_rights(&who), Error::<T, I>::NoVotingRights);
+
+			T::ProposalProvider::vote_proposal(who, proposal, index, approve)?;
+			Ok(())
+		}
+
+		// Index 2 was `close_old_weight`; it was removed due to weights v1 deprecation.
+
+		/// Initialize the Alliance, onboard fellows and allies.
+		///
+		/// The Alliance must be empty, and the call must provide some founding members.
+		///
+		/// Must be called by the Root origin.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::init_members(
+			fellows.len() as u32,
+			allies.len() as u32,
+		))]
+		pub fn init_members(
+			origin: OriginFor<T>,
+			fellows: Vec<T::AccountId>,
+			allies: Vec<T::AccountId>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			ensure!(!fellows.is_empty(), Error::<T, I>::FellowsMissing);
+			ensure!(!Self::is_initialized(), Error::<T, I>::AllianceAlreadyInitialized);
+
+			let mut fellows: BoundedVec<T::AccountId, T::MaxMembersCount> =
+				fellows.try_into().map_err(|_| Error::<T, I>::TooManyMembers)?;
+			let mut allies: BoundedVec<T::AccountId, T::MaxMembersCount> =
+				allies.try_into().map_err(|_| Error::<T, I>::TooManyMembers)?;
+
+			for member in fellows.iter().chain(allies.iter()) {
+				Self::has_identity(member)?;
+			}
+
+			fellows.sort();
+			Members::<T, I>::insert(&MemberRole::Fellow, fellows.clone());
+			allies.sort();
+			Members::<T, I>::insert(&MemberRole::Ally, allies.clone());
+
+			let mut voteable_members = fellows.clone();
+			voteable_members.sort();
+
+			T::InitializeMembers::initialize_members(&voteable_members);
+
+			log::debug!(
+				target: LOG_TARGET,
+				"Initialize alliance fellows: {:?}, allies: {:?}",
+				fellows,
+				allies
+			);
+
+			Self::deposit_event(Event::MembersInitialized {
+				fellows: fellows.into(),
+				allies: allies.into(),
+			});
+			Ok(())
+		}
+
+		/// Disband the Alliance, remove all active members and unreserve deposits.
+		///
+		/// Witness data must be set.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::disband(
+			witness.fellow_members,
+			witness.ally_members,
+			witness.fellow_members.saturating_add(witness.ally_members),
+		))]
+		pub fn disband(
+			origin: OriginFor<T>,
+			witness: DisbandWitness,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+
+			ensure!(!witness.is_zero(), Error::<T, I>::BadWitness);
+			ensure!(
+				Self::voting_members_count() <= witness.fellow_members,
+				Error::<T, I>::BadWitness
+			);
+			ensure!(Self::ally_members_count() <= witness.ally_members, Error::<T, I>::BadWitness);
+			ensure!(Self::is_initialized(), Error::<T, I>::AllianceNotYetInitialized);
+
+			let voting_members = Self::voting_members();
+			T::MembershipChanged::change_members_sorted(&[], &voting_members, &[]);
+
+			let ally_members = Self::members_of(MemberRole::Ally);
+			let mut unreserve_count: u32 = 0;
+			for member in voting_members.iter().chain(ally_members.iter()) {
+				if let Some(deposit) = DepositOf::<T, I>::take(&member) {
+					let err_amount = T::Currency::unreserve(&member, deposit);
+					debug_assert!(err_amount.is_zero());
+					unreserve_count += 1;
+				}
+			}
+
+			Members::<T, I>::remove(&MemberRole::Fellow);
+			Members::<T, I>::remove(&MemberRole::Ally);
+
+			Self::deposit_event(Event::AllianceDisbanded {
+				fellow_members: voting_members.len() as u32,
+				ally_members: ally_members.len() as u32,
+				unreserved: unreserve_count,
+			});
+
+			Ok(Some(T::WeightInfo::disband(
+				voting_members.len() as u32,
+				ally_members.len() as u32,
+				unreserve_count,
+			))
+			.into())
+		}
+
+		/// Set a new IPFS CID to the alliance rule.
+		#[pallet::call_index(5)]
+		pub fn set_rule(origin: OriginFor<T>, rule: Cid) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+
+			Rule::<T, I>::put(&rule);
+
+			Self::deposit_event(Event::NewRuleSet { rule });
+			Ok(())
+		}
+
+		/// Make an announcement of a new IPFS CID about alliance issues.
+		#[pallet::call_index(6)]
+		pub fn announce(origin: OriginFor<T>, announcement: Cid) -> DispatchResult {
+			T::AnnouncementOrigin::ensure_origin(origin)?;
+
+			let mut announcements = <Announcements<T, I>>::get();
+			announcements
+				.try_push(announcement.clone())
+				.map_err(|_| Error::<T, I>::TooManyAnnouncements)?;
+			<Announcements<T, I>>::put(announcements);
+
+			Self::deposit_event(Event::Announced { announcement });
+			Ok(())
+		}
+
+		/// Remove an announcement.
+		#[pallet::call_index(7)]
+		pub fn remove_announcement(origin: OriginFor<T>, announcement: Cid) -> DispatchResult {
+			T::AnnouncementOrigin::ensure_origin(origin)?;
+
+			let mut announcements = <Announcements<T, I>>::get();
+			let pos = announcements
+				.binary_search(&announcement)
+				.ok()
+				.ok_or(Error::<T, I>::MissingAnnouncement)?;
+			announcements.remove(pos);
+			<Announcements<T, I>>::put(announcements);
+
+			Self::deposit_event(Event::AnnouncementRemoved { announcement });
+			Ok(())
+		}
+
+		/// Submit oneself for candidacy. A fixed deposit is reserved.
+		#[pallet::call_index(8)]
+		pub fn join_alliance(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			// We don't want anyone to join as an Ally before the Alliance has been initialized via
+			// Root call. The reasons are two-fold:
+			//
+			// 1. There is no `Rule` or admission criteria, so the joiner would be an ally to
+			//    nought, and
+			// 2. It adds complexity to the initialization, namely deciding to overwrite accounts
+			//    that already joined as an Ally.
+			ensure!(Self::is_initialized(), Error::<T, I>::AllianceNotYetInitialized);
+
+			// Unscrupulous accounts are non grata.
+			ensure!(!Self::is_unscrupulous_account(&who), Error::<T, I>::AccountNonGrata);
+			ensure!(!Self::is_member(&who), Error::<T, I>::AlreadyMember);
+			// check user self or parent should has verified identity to reuse display name and
+			// website.
+			Self::has_identity(&who)?;
+
+			let deposit = T::AllyDeposit::get();
+			T::Currency::reserve(&who, deposit).map_err(|_| Error::<T, I>::InsufficientFunds)?;
+			<DepositOf<T, I>>::insert(&who, deposit);
+
+			Self::add_member(&who, MemberRole::Ally)?;
+
+			Self::deposit_event(Event::NewAllyJoined {
+				ally: who,
+				nominator: None,
+				reserved: Some(deposit),
+			});
+			Ok(())
+		}
+
+		/// A Fellow can nominate someone to join the alliance as an Ally. There is no deposit
+		/// required from the nominator or nominee.
+		#[pallet::call_index(9)]
+		pub fn nominate_ally(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			let nominator = ensure_signed(origin)?;
+			ensure!(Self::has_voting_rights(&nominator), Error::<T, I>::NoVotingRights);
+			let who = T::Lookup::lookup(who)?;
+
+			// Individual voting members cannot nominate accounts non grata.
+			ensure!(!Self::is_unscrupulous_account(&who), Error::<T, I>::AccountNonGrata);
+			ensure!(!Self::is_member(&who), Error::<T, I>::AlreadyMember);
+			// check user self or parent should has verified identity to reuse display name and
+			// website.
+			Self::has_identity(&who)?;
+
+			Self::add_member(&who, MemberRole::Ally)?;
+
+			Self::deposit_event(Event::NewAllyJoined {
+				ally: who,
+				nominator: Some(nominator),
+				reserved: None,
+			});
+			Ok(())
+		}
+
+		/// Elevate an Ally to Fellow.
+		#[pallet::call_index(10)]
+		pub fn elevate_ally(origin: OriginFor<T>, ally: AccountIdLookupOf<T>) -> DispatchResult {
+			T::MembershipManager::ensure_origin(origin)?;
+			let ally = T::Lookup::lookup(ally)?;
+			ensure!(Self::is_ally(&ally), Error::<T, I>::NotAlly);
+			ensure!(!Self::has_voting_rights(&ally), Error::<T, I>::AlreadyElevated);
+
+			Self::remove_member(&ally, MemberRole::Ally)?;
+			Self::add_member(&ally, MemberRole::Fellow)?;
+
+			Self::deposit_event(Event::AllyElevated { ally });
+			Ok(())
+		}
+
+		/// As a member, give a retirement notice and start a retirement period required to pass in
+		/// order to retire.
+		#[pallet::call_index(11)]
+		pub fn give_retirement_notice(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let role = Self::member_role_of(&who).ok_or(Error::<T, I>::NotMember)?;
+			ensure!(role.ne(&MemberRole::Retiring), Error::<T, I>::AlreadyRetiring);
+
+			Self::remove_member(&who, role)?;
+			Self::add_member(&who, MemberRole::Retiring)?;
+			<RetiringMembers<T, I>>::insert(
+				&who,
+				frame_system::Pallet::<T>::block_number()
+					.saturating_add(T::RetirementPeriod::get()),
+			);
+
+			Self::deposit_event(Event::MemberRetirementPeriodStarted { member: who });
+			Ok(())
+		}
+
+		/// As a member, retire from the Alliance and unreserve the deposit.
+		///
+		/// This can only be done once you have called `give_retirement_notice` and the
+		/// `RetirementPeriod` has passed.
+		#[pallet::call_index(12)]
+		pub fn retire(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let retirement_period_end = RetiringMembers::<T, I>::get(&who)
+				.ok_or(Error::<T, I>::RetirementNoticeNotGiven)?;
+			ensure!(
+				frame_system::Pallet::<T>::block_number() >= retirement_period_end,
+				Error::<T, I>::RetirementPeriodNotPassed
+			);
+
+			Self::remove_member(&who, MemberRole::Retiring)?;
+			<RetiringMembers<T, I>>::remove(&who);
+			let deposit = DepositOf::<T, I>::take(&who);
+			if let Some(deposit) = deposit {
+				let err_amount = T::Currency::unreserve(&who, deposit);
+				debug_assert!(err_amount.is_zero());
+			}
+			Self::deposit_event(Event::MemberRetired { member: who, unreserved: deposit });
+			Ok(())
+		}
+
+		/// Kick a member from the Alliance and slash its deposit.
+		#[pallet::call_index(13)]
+		pub fn kick_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			T::MembershipManager::ensure_origin(origin)?;
+			let member = T::Lookup::lookup(who)?;
+
+			let role = Self::member_role_of(&member).ok_or(Error::<T, I>::NotMember)?;
+			Self::remove_member(&member, role)?;
+			let deposit = DepositOf::<T, I>::take(member.clone());
+			if let Some(deposit) = deposit {
+				T::Slashed::on_unbalanced(T::Currency::slash_reserved(&member, deposit).0);
+			}
+
+			Self::deposit_event(Event::MemberKicked { member, slashed: deposit });
+			Ok(())
+		}
+
+		/// Add accounts or websites to the list of unscrupulous items.
+		#[pallet::call_index(14)]
+		#[pallet::weight(T::WeightInfo::add_unscrupulous_items(items.len() as u32, T::MaxWebsiteUrlLength::get()))]
+		pub fn add_unscrupulous_items(
+			origin: OriginFor<T>,
+			items: Vec<UnscrupulousItemOf<T, I>>,
+		) -> DispatchResult {
+			T::AnnouncementOrigin::ensure_origin(origin)?;
+
+			let mut accounts = vec![];
+			let mut webs = vec![];
+			for info in items.iter() {
+				ensure!(!Self::is_unscrupulous(info), Error::<T, I>::AlreadyUnscrupulous);
+				match info {
+					UnscrupulousItem::AccountId(who) => accounts.push(who.clone()),
+					UnscrupulousItem::Website(url) => {
+						ensure!(
+							url.len() as u32 <= T::MaxWebsiteUrlLength::get(),
+							Error::<T, I>::TooLongWebsiteUrl
+						);
+						webs.push(url.clone());
+					},
+				}
+			}
+
+			Self::do_add_unscrupulous_items(&mut accounts, &mut webs)?;
+			Self::deposit_event(Event::UnscrupulousItemAdded { items });
+			Ok(())
+		}
+
+		/// Deem some items no longer unscrupulous.
+		#[pallet::call_index(15)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::remove_unscrupulous_items(
+			items.len() as u32, T::MaxWebsiteUrlLength::get()
+		))]
+		pub fn remove_unscrupulous_items(
+			origin: OriginFor<T>,
+			items: Vec<UnscrupulousItemOf<T, I>>,
+		) -> DispatchResult {
+			T::AnnouncementOrigin::ensure_origin(origin)?;
+			let mut accounts = vec![];
+			let mut webs = vec![];
+			for info in items.iter() {
+				ensure!(Self::is_unscrupulous(info), Error::<T, I>::NotListedAsUnscrupulous);
+				match info {
+					UnscrupulousItem::AccountId(who) => accounts.push(who.clone()),
+					UnscrupulousItem::Website(url) => webs.push(url.clone()),
+				}
+			}
+			Self::do_remove_unscrupulous_items(&mut accounts, &mut webs)?;
+			Self::deposit_event(Event::UnscrupulousItemRemoved { items });
+			Ok(())
+		}
+
+		/// Close a vote that is either approved, disapproved, or whose voting period has ended.
+		///
+		/// Must be called by a Fellow.
+		#[pallet::call_index(16)]
+		#[pallet::weight({
+			let b = *length_bound;
+			let m = T::MaxFellows::get();
+			let p1 = *proposal_weight_bound;
+			let p2 = T::MaxProposals::get();
+			T::WeightInfo::close_early_approved(b, m, p2)
+				.max(T::WeightInfo::close_early_disapproved(m, p2))
+				.max(T::WeightInfo::close_approved(b, m, p2))
+				.max(T::WeightInfo::close_disapproved(m, p2))
+				.saturating_add(p1)
+		})]
+		pub fn close(
+			origin: OriginFor<T>,
+			proposal_hash: T::Hash,
+			#[pallet::compact] index: ProposalIndex,
+			proposal_weight_bound: Weight,
+			#[pallet::compact] length_bound: u32,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			ensure!(Self::has_voting_rights(&who), Error::<T, I>::NoVotingRights);
+
+			Self::do_close(proposal_hash, index, proposal_weight_bound, length_bound)
+		}
+
+		/// Abdicate one's position as a voting member and just be an Ally. May be used by Fellows
+		/// who do not want to leave the Alliance but do not have the capacity to participate
+		/// operationally for some time.
+		#[pallet::call_index(17)]
+		pub fn abdicate_fellow_status(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let role = Self::member_role_of(&who).ok_or(Error::<T, I>::NotMember)?;
+			// Not applicable to members who are retiring or who are already Allies.
+			ensure!(Self::has_voting_rights(&who), Error::<T, I>::NoVotingRights);
+
+			Self::remove_member(&who, role)?;
+			Self::add_member(&who, MemberRole::Ally)?;
+
+			Self::deposit_event(Event::FellowAbdicated { fellow: who });
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Check if the Alliance has been initialized.
+	fn is_initialized() -> bool {
+		Self::has_member(MemberRole::Fellow) || Self::has_member(MemberRole::Ally)
+	}
+
+	/// Check if a given role has any members.
+	fn has_member(role: MemberRole) -> bool {
+		Members::<T, I>::decode_len(role).unwrap_or_default() > 0
+	}
+
+	/// Look up the role, if any, of an account.
+	fn member_role_of(who: &T::AccountId) -> Option<MemberRole> {
+		Members::<T, I>::iter()
+			.find_map(|(r, members)| if members.contains(who) { Some(r) } else { None })
+	}
+
+	/// Check if a user is a alliance member.
+	pub fn is_member(who: &T::AccountId) -> bool {
+		Self::member_role_of(who).is_some()
+	}
+
+	/// Check if an account has a given role.
+	pub fn is_member_of(who: &T::AccountId, role: MemberRole) -> bool {
+		Members::<T, I>::get(role).contains(&who)
+	}
+
+	/// Check if an account is an Ally.
+	fn is_ally(who: &T::AccountId) -> bool {
+		Self::is_member_of(who, MemberRole::Ally)
+	}
+
+	/// Check if a member has voting rights.
+	fn has_voting_rights(who: &T::AccountId) -> bool {
+		Self::is_member_of(who, MemberRole::Fellow)
+	}
+
+	/// Count of ally members.
+	fn ally_members_count() -> u32 {
+		Members::<T, I>::decode_len(MemberRole::Ally).unwrap_or(0) as u32
+	}
+
+	/// Count of all members who have voting rights.
+	fn voting_members_count() -> u32 {
+		Members::<T, I>::decode_len(MemberRole::Fellow).unwrap_or(0) as u32
+	}
+
+	/// Get all members of a given role.
+	fn members_of(role: MemberRole) -> Vec<T::AccountId> {
+		Members::<T, I>::get(role).into_inner()
+	}
+
+	/// Collect all members who have voting rights into one list.
+	fn voting_members() -> Vec<T::AccountId> {
+		Self::members_of(MemberRole::Fellow)
+	}
+
+	/// Add a user to the sorted alliance member set.
+	fn add_member(who: &T::AccountId, role: MemberRole) -> DispatchResult {
+		<Members<T, I>>::try_mutate(role, |members| -> DispatchResult {
+			let pos = members.binary_search(who).err().ok_or(Error::<T, I>::AlreadyMember)?;
+			members
+				.try_insert(pos, who.clone())
+				.map_err(|_| Error::<T, I>::TooManyMembers)?;
+			Ok(())
+		})?;
+
+		if role == MemberRole::Fellow {
+			let members = Self::voting_members();
+			T::MembershipChanged::change_members_sorted(&[who.clone()], &[], &members[..]);
+		}
+		Ok(())
+	}
+
+	/// Remove a user from the alliance member set.
+	fn remove_member(who: &T::AccountId, role: MemberRole) -> DispatchResult {
+		<Members<T, I>>::try_mutate(role, |members| -> DispatchResult {
+			let pos = members.binary_search(who).ok().ok_or(Error::<T, I>::NotMember)?;
+			members.remove(pos);
+			Ok(())
+		})?;
+
+		if role == MemberRole::Fellow {
+			let members = Self::voting_members();
+			T::MembershipChanged::change_members_sorted(&[], &[who.clone()], &members[..]);
+		}
+		Ok(())
+	}
+
+	/// Check if an item is listed as unscrupulous.
+	fn is_unscrupulous(info: &UnscrupulousItemOf<T, I>) -> bool {
+		match info {
+			UnscrupulousItem::Website(url) => <UnscrupulousWebsites<T, I>>::get().contains(url),
+			UnscrupulousItem::AccountId(who) => <UnscrupulousAccounts<T, I>>::get().contains(who),
+		}
+	}
+
+	/// Check if an account is listed as unscrupulous.
+	fn is_unscrupulous_account(who: &T::AccountId) -> bool {
+		<UnscrupulousAccounts<T, I>>::get().contains(who)
+	}
+
+	/// Add item to the unscrupulous list.
+	fn do_add_unscrupulous_items(
+		new_accounts: &mut Vec<T::AccountId>,
+		new_webs: &mut Vec<UrlOf<T, I>>,
+	) -> DispatchResult {
+		if !new_accounts.is_empty() {
+			<UnscrupulousAccounts<T, I>>::try_mutate(|accounts| -> DispatchResult {
+				accounts
+					.try_append(new_accounts)
+					.map_err(|_| Error::<T, I>::TooManyUnscrupulousItems)?;
+				accounts.sort();
+
+				Ok(())
+			})?;
+		}
+		if !new_webs.is_empty() {
+			<UnscrupulousWebsites<T, I>>::try_mutate(|webs| -> DispatchResult {
+				webs.try_append(new_webs).map_err(|_| Error::<T, I>::TooManyUnscrupulousItems)?;
+				webs.sort();
+
+				Ok(())
+			})?;
+		}
+
+		Ok(())
+	}
+
+	/// Remove item from the unscrupulous list.
+	fn do_remove_unscrupulous_items(
+		out_accounts: &mut Vec<T::AccountId>,
+		out_webs: &mut Vec<UrlOf<T, I>>,
+	) -> DispatchResult {
+		if !out_accounts.is_empty() {
+			<UnscrupulousAccounts<T, I>>::try_mutate(|accounts| -> DispatchResult {
+				for who in out_accounts.iter() {
+					let pos = accounts
+						.binary_search(who)
+						.ok()
+						.ok_or(Error::<T, I>::NotListedAsUnscrupulous)?;
+					accounts.remove(pos);
+				}
+				Ok(())
+			})?;
+		}
+		if !out_webs.is_empty() {
+			<UnscrupulousWebsites<T, I>>::try_mutate(|webs| -> DispatchResult {
+				for web in out_webs.iter() {
+					let pos = webs
+						.binary_search(web)
+						.ok()
+						.ok_or(Error::<T, I>::NotListedAsUnscrupulous)?;
+					webs.remove(pos);
+				}
+				Ok(())
+			})?;
+		}
+		Ok(())
+	}
+
+	fn has_identity(who: &T::AccountId) -> DispatchResult {
+		const IDENTITY_FIELD_DISPLAY: u64 = IdentityField::Display as u64;
+		const IDENTITY_FIELD_WEB: u64 = IdentityField::Web as u64;
+
+		let judgement = |who: &T::AccountId| -> DispatchResult {
+			ensure!(
+				T::IdentityVerifier::has_identity(who, IDENTITY_FIELD_DISPLAY | IDENTITY_FIELD_WEB),
+				Error::<T, I>::WithoutIdentityDisplayAndWebsite
+			);
+			ensure!(
+				T::IdentityVerifier::has_good_judgement(who),
+				Error::<T, I>::WithoutGoodIdentityJudgement
+			);
+			Ok(())
+		};
+
+		let res = judgement(who);
+		if res.is_err() {
+			if let Some(parent) = T::IdentityVerifier::super_account_id(who) {
+				return judgement(&parent)
+			}
+		}
+		res
+	}
+
+	fn do_close(
+		proposal_hash: T::Hash,
+		index: ProposalIndex,
+		proposal_weight_bound: Weight,
+		length_bound: u32,
+	) -> DispatchResultWithPostInfo {
+		let info = T::ProposalProvider::close_proposal(
+			proposal_hash,
+			index,
+			proposal_weight_bound,
+			length_bound,
+		)?;
+		Ok(info.into())
+	}
+}
diff --git a/substrate/frame/alliance/src/migration.rs b/substrate/frame/alliance/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e3a44a7887e976cfa6c5d0cfd48c251348edb26b
--- /dev/null
+++ b/substrate/frame/alliance/src/migration.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::{Config, Pallet, Weight, LOG_TARGET};
+use frame_support::{pallet_prelude::*, storage::migration, traits::OnRuntimeUpgrade};
+use log;
+
+/// The current storage version.
+pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
+
+/// Wrapper for all migrations of this pallet.
+pub fn migrate<T: Config<I>, I: 'static>() -> Weight {
+	let onchain_version = Pallet::<T, I>::on_chain_storage_version();
+	let mut weight: Weight = Weight::zero();
+
+	if onchain_version < 1 {
+		weight = weight.saturating_add(v0_to_v1::migrate::<T, I>());
+	}
+
+	if onchain_version < 2 {
+		weight = weight.saturating_add(v1_to_v2::migrate::<T, I>());
+	}
+
+	STORAGE_VERSION.put::<Pallet<T, I>>();
+	weight = weight.saturating_add(T::DbWeight::get().writes(1));
+
+	weight
+}
+
+/// Implements `OnRuntimeUpgrade` trait.
+pub struct Migration<T, I = ()>(PhantomData<(T, I)>);
+
+impl<T: Config<I>, I: 'static> OnRuntimeUpgrade for Migration<T, I> {
+	fn on_runtime_upgrade() -> Weight {
+		migrate::<T, I>()
+	}
+}
+
+/// v0_to_v1: `UpForKicking` is replaced by a retirement period.
+mod v0_to_v1 {
+	use super::*;
+
+	pub fn migrate<T: Config<I>, I: 'static>() -> Weight {
+		log::info!(target: LOG_TARGET, "Running migration v0_to_v1.");
+
+		let res = migration::clear_storage_prefix(
+			<Pallet<T, I>>::name().as_bytes(),
+			b"UpForKicking",
+			b"",
+			None,
+			None,
+		);
+
+		log::info!(
+			target: LOG_TARGET,
+			"Cleared '{}' entries from 'UpForKicking' storage prefix",
+			res.unique
+		);
+
+		if res.maybe_cursor.is_some() {
+			log::error!(
+				target: LOG_TARGET,
+				"Storage prefix 'UpForKicking' is not completely cleared."
+			);
+		}
+
+		T::DbWeight::get().writes(res.unique.into())
+	}
+}
+
+/// v1_to_v2: `Members` storage map collapses `Founder` and `Fellow` keys into one `Fellow`.
+/// Total number of `Founder`s and `Fellow`s must not be higher than `T::MaxMembersCount`.
+pub(crate) mod v1_to_v2 {
+	use super::*;
+	use crate::{MemberRole, Members};
+
+	/// V1 Role set.
+	#[derive(Copy, Clone, PartialEq, Eq, Encode, Decode, TypeInfo, MaxEncodedLen)]
+	pub enum MemberRoleV1 {
+		Founder,
+		Fellow,
+		Ally,
+		Retiring,
+	}
+
+	pub fn migrate<T: Config<I>, I: 'static>() -> Weight {
+		log::info!(target: LOG_TARGET, "Running migration v1_to_v2: `Members` storage map collapses `Founder` and `Fellow` keys into one `Fellow`.");
+		// fetch into the scope all members.
+		let founders_vec = take_members::<T, I>(MemberRoleV1::Founder).into_inner();
+		let mut fellows_vec = take_members::<T, I>(MemberRoleV1::Fellow).into_inner();
+		let allies = take_members::<T, I>(MemberRoleV1::Ally);
+		let retiring = take_members::<T, I>(MemberRoleV1::Retiring);
+		if founders_vec
+			.len()
+			.saturating_add(fellows_vec.len())
+			.saturating_add(allies.len())
+			.saturating_add(retiring.len()) ==
+			0
+		{
+			return T::DbWeight::get().reads(4)
+		}
+		log::info!(
+			target: LOG_TARGET,
+			"Members storage v1 contains, '{}' founders, '{}' fellows, '{}' allies, '{}' retiring members.",
+			founders_vec.len(),
+			fellows_vec.len(),
+			allies.len(),
+			retiring.len(),
+		);
+		// merge founders with fellows and sort.
+		fellows_vec.extend(founders_vec);
+		fellows_vec.sort();
+		if fellows_vec.len() as u32 > T::MaxMembersCount::get() {
+			log::error!(
+				target: LOG_TARGET,
+				"Merged list of founders and fellows do not fit into `T::MaxMembersCount` bound. Truncating the merged set into max members count."
+			);
+			fellows_vec.truncate(T::MaxMembersCount::get() as usize);
+		}
+		let fellows: BoundedVec<T::AccountId, T::MaxMembersCount> =
+			fellows_vec.try_into().unwrap_or_default();
+		// insert members with new storage map key.
+		Members::<T, I>::insert(&MemberRole::Fellow, fellows.clone());
+		Members::<T, I>::insert(&MemberRole::Ally, allies.clone());
+		Members::<T, I>::insert(&MemberRole::Retiring, retiring.clone());
+		log::info!(
+			target: LOG_TARGET,
+			"Members storage updated with, '{}' fellows, '{}' allies, '{}' retiring members.",
+			fellows.len(),
+			allies.len(),
+			retiring.len(),
+		);
+		T::DbWeight::get().reads_writes(4, 4)
+	}
+
+	fn take_members<T: Config<I>, I: 'static>(
+		role: MemberRoleV1,
+	) -> BoundedVec<T::AccountId, T::MaxMembersCount> {
+		migration::take_storage_item::<
+			MemberRoleV1,
+			BoundedVec<T::AccountId, T::MaxMembersCount>,
+			Twox64Concat,
+		>(<Pallet<T, I>>::name().as_bytes(), b"Members", role)
+		.unwrap_or_default()
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{mock::*, MemberRole};
+
+	#[test]
+	fn migration_v1_to_v2_works() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Alliance::join_alliance(RuntimeOrigin::signed(4)));
+			assert_eq!(Alliance::members(MemberRole::Ally), vec![4]);
+			assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3]);
+			v1_to_v2::migrate::<Test, ()>();
+			assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3, 4]);
+			assert_eq!(Alliance::members(MemberRole::Ally), vec![]);
+			assert_eq!(Alliance::members(MemberRole::Retiring), vec![]);
+		});
+	}
+}
diff --git a/substrate/frame/alliance/src/mock.rs b/substrate/frame/alliance/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f04e7e414ed94dbaa930580189272cfb169c8d96
--- /dev/null
+++ b/substrate/frame/alliance/src/mock.rs
@@ -0,0 +1,391 @@
+// 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.
+
+//! Test utilities
+
+pub use sp_core::H256;
+use sp_runtime::traits::Hash;
+pub use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+use sp_std::convert::{TryFrom, TryInto};
+
+pub use frame_support::{
+	assert_noop, assert_ok, ord_parameter_types, parameter_types,
+	traits::{EitherOfDiverse, SortedMembers},
+	BoundedVec,
+};
+use frame_system::{EnsureRoot, EnsureSignedBy};
+use pallet_identity::{Data, IdentityInfo, Judgement};
+
+pub use crate as pallet_alliance;
+
+use super::*;
+
+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);
+}
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = BlockWeights;
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = BlockHashCount;
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<AccountId>;
+	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;
+}
+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 MaxHolds = ();
+}
+
+const MOTION_DURATION_IN_BLOCKS: BlockNumber = 3;
+
+parameter_types! {
+	pub const MotionDuration: BlockNumber = MOTION_DURATION_IN_BLOCKS;
+	pub const MaxProposals: u32 = 100;
+	pub const MaxMembers: u32 = 100;
+	pub MaxProposalWeight: Weight = sp_runtime::Perbill::from_percent(50) * BlockWeights::get().max_block;
+}
+type AllianceCollective = pallet_collective::Instance1;
+impl pallet_collective::Config<AllianceCollective> for Test {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = MotionDuration;
+	type MaxProposals = MaxProposals;
+	type MaxMembers = MaxMembers;
+	type DefaultVote = pallet_collective::PrimeDefaultVote;
+	type WeightInfo = ();
+	type SetMembersOrigin = EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxProposalWeight;
+}
+
+parameter_types! {
+	pub const BasicDeposit: u64 = 10;
+	pub const FieldDeposit: u64 = 10;
+	pub const SubAccountDeposit: u64 = 10;
+	pub const MaxSubAccounts: u32 = 2;
+	pub const MaxAdditionalFields: u32 = 2;
+	pub const MaxRegistrars: u32 = 20;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+	pub const Two: u64 = 2;
+	pub const Three: u64 = 3;
+	pub const Four: u64 = 4;
+	pub const Five: u64 = 5;
+}
+type EnsureOneOrRoot = EitherOfDiverse<EnsureRoot<AccountId>, EnsureSignedBy<One, AccountId>>;
+type EnsureTwoOrRoot = EitherOfDiverse<EnsureRoot<AccountId>, EnsureSignedBy<Two, AccountId>>;
+
+impl pallet_identity::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type BasicDeposit = BasicDeposit;
+	type FieldDeposit = FieldDeposit;
+	type SubAccountDeposit = SubAccountDeposit;
+	type MaxSubAccounts = MaxSubAccounts;
+	type MaxAdditionalFields = MaxAdditionalFields;
+	type MaxRegistrars = MaxRegistrars;
+	type Slashed = ();
+	type RegistrarOrigin = EnsureOneOrRoot;
+	type ForceOrigin = EnsureTwoOrRoot;
+	type WeightInfo = ();
+}
+
+pub struct AllianceIdentityVerifier;
+impl IdentityVerifier<AccountId> for AllianceIdentityVerifier {
+	fn has_identity(who: &AccountId, fields: u64) -> bool {
+		Identity::has_identity(who, fields)
+	}
+
+	fn has_good_judgement(who: &AccountId) -> bool {
+		if let Some(judgements) =
+			Identity::identity(who).map(|registration| registration.judgements)
+		{
+			judgements
+				.iter()
+				.any(|(_, j)| matches!(j, Judgement::KnownGood | Judgement::Reasonable))
+		} else {
+			false
+		}
+	}
+
+	fn super_account_id(who: &AccountId) -> Option<AccountId> {
+		Identity::super_of(who).map(|parent| parent.0)
+	}
+}
+
+pub struct AllianceProposalProvider;
+impl ProposalProvider<AccountId, H256, RuntimeCall> for AllianceProposalProvider {
+	fn propose_proposal(
+		who: AccountId,
+		threshold: u32,
+		proposal: Box<RuntimeCall>,
+		length_bound: u32,
+	) -> Result<(u32, u32), DispatchError> {
+		AllianceMotion::do_propose_proposed(who, threshold, proposal, length_bound)
+	}
+
+	fn vote_proposal(
+		who: AccountId,
+		proposal: H256,
+		index: ProposalIndex,
+		approve: bool,
+	) -> Result<bool, DispatchError> {
+		AllianceMotion::do_vote(who, proposal, index, approve)
+	}
+
+	fn close_proposal(
+		proposal_hash: H256,
+		proposal_index: ProposalIndex,
+		proposal_weight_bound: Weight,
+		length_bound: u32,
+	) -> DispatchResultWithPostInfo {
+		AllianceMotion::do_close(proposal_hash, proposal_index, proposal_weight_bound, length_bound)
+	}
+
+	fn proposal_of(proposal_hash: H256) -> Option<RuntimeCall> {
+		AllianceMotion::proposal_of(proposal_hash)
+	}
+}
+
+parameter_types! {
+	pub const MaxFellows: u32 = MaxMembers::get();
+	pub const MaxAllies: u32 = 100;
+	pub const AllyDeposit: u64 = 25;
+	pub const RetirementPeriod: BlockNumber = MOTION_DURATION_IN_BLOCKS + 1;
+}
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Proposal = RuntimeCall;
+	type AdminOrigin = EnsureSignedBy<One, AccountId>;
+	type MembershipManager = EnsureSignedBy<Two, AccountId>;
+	type AnnouncementOrigin = EnsureSignedBy<Three, AccountId>;
+	type Currency = Balances;
+	type Slashed = ();
+	type InitializeMembers = AllianceMotion;
+	type MembershipChanged = AllianceMotion;
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	type IdentityVerifier = AllianceIdentityVerifier;
+	#[cfg(feature = "runtime-benchmarks")]
+	type IdentityVerifier = ();
+	type ProposalProvider = AllianceProposalProvider;
+	type MaxProposals = MaxProposals;
+	type MaxFellows = MaxFellows;
+	type MaxAllies = MaxAllies;
+	type MaxUnscrupulousItems = ConstU32<100>;
+	type MaxWebsiteUrlLength = ConstU32<255>;
+	type MaxAnnouncementsCount = ConstU32<100>;
+	type MaxMembersCount = MaxMembers;
+	type AllyDeposit = AllyDeposit;
+	type WeightInfo = ();
+	type RetirementPeriod = RetirementPeriod;
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Identity: pallet_identity,
+		AllianceMotion: pallet_collective::<Instance1>,
+		Alliance: pallet_alliance,
+	}
+);
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![
+			(1, 50),
+			(2, 50),
+			(3, 50),
+			(4, 50),
+			(5, 30),
+			(6, 50),
+			(7, 50),
+			(8, 50),
+			(9, 50),
+		],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	pallet_alliance::GenesisConfig::<Test> {
+		fellows: vec![],
+		allies: vec![],
+		phantom: Default::default(),
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 1));
+
+		let info = IdentityInfo {
+			additional: BoundedVec::default(),
+			display: Data::Raw(b"name".to_vec().try_into().unwrap()),
+			legal: Data::default(),
+			web: Data::Raw(b"website".to_vec().try_into().unwrap()),
+			riot: Data::default(),
+			email: Data::default(),
+			pgp_fingerprint: None,
+			image: Data::default(),
+			twitter: Data::default(),
+		};
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(1), Box::new(info.clone())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(1),
+			0,
+			1,
+			Judgement::KnownGood,
+			BlakeTwo256::hash_of(&info)
+		));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(2), Box::new(info.clone())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(1),
+			0,
+			2,
+			Judgement::KnownGood,
+			BlakeTwo256::hash_of(&info)
+		));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(3), Box::new(info.clone())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(1),
+			0,
+			3,
+			Judgement::KnownGood,
+			BlakeTwo256::hash_of(&info)
+		));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(4), Box::new(info.clone())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(1),
+			0,
+			4,
+			Judgement::KnownGood,
+			BlakeTwo256::hash_of(&info)
+		));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(5), Box::new(info.clone())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(1),
+			0,
+			5,
+			Judgement::KnownGood,
+			BlakeTwo256::hash_of(&info)
+		));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(6), Box::new(info.clone())));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(8), Box::new(info.clone())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(1),
+			0,
+			8,
+			Judgement::KnownGood,
+			BlakeTwo256::hash_of(&info)
+		));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(9), Box::new(info.clone())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(1),
+			0,
+			9,
+			Judgement::KnownGood,
+			BlakeTwo256::hash_of(&info)
+		));
+
+		// Joining before init should fail.
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(1)),
+			Error::<Test, ()>::AllianceNotYetInitialized
+		);
+
+		assert_ok!(Alliance::init_members(RuntimeOrigin::root(), vec![1, 2, 3], vec![]));
+
+		System::set_block_number(1);
+	});
+	ext
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn new_bench_ext() -> sp_io::TestExternalities {
+	RuntimeGenesisConfig::default().build_storage().unwrap().into()
+}
+
+pub fn test_cid() -> Cid {
+	let result = sp_core_hashing::sha2_256(b"hello world");
+	Cid::new_v0(result)
+}
+
+pub fn make_remark_proposal(value: u64) -> (RuntimeCall, u32, H256) {
+	make_proposal(RuntimeCall::System(frame_system::Call::remark { remark: value.encode() }))
+}
+
+pub fn make_kick_member_proposal(who: AccountId) -> (RuntimeCall, u32, H256) {
+	make_proposal(RuntimeCall::Alliance(pallet_alliance::Call::kick_member { who }))
+}
+
+pub fn make_proposal(proposal: RuntimeCall) -> (RuntimeCall, u32, H256) {
+	let len: u32 = proposal.using_encoded(|p| p.len() as u32);
+	let hash = BlakeTwo256::hash_of(&proposal);
+	(proposal, len, hash)
+}
+
+pub fn is_fellow(who: &AccountId) -> bool {
+	Alliance::is_member_of(who, MemberRole::Fellow)
+}
diff --git a/substrate/frame/alliance/src/tests.rs b/substrate/frame/alliance/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..098fd86bbae1ec6ed6d2abbd2c24430e690a6e93
--- /dev/null
+++ b/substrate/frame/alliance/src/tests.rs
@@ -0,0 +1,640 @@
+// 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 the alliance pallet.
+
+use frame_support::{assert_noop, assert_ok, error::BadOrigin};
+use frame_system::{EventRecord, Phase};
+
+use super::*;
+use crate::mock::*;
+
+type AllianceMotionEvent = pallet_collective::Event<Test, pallet_collective::Instance1>;
+
+fn assert_powerless(user: RuntimeOrigin, user_is_member: bool) {
+	//vote / veto with a valid propsal
+	let cid = test_cid();
+	let (proposal, _, _) = make_kick_member_proposal(42);
+
+	assert_noop!(Alliance::init_members(user.clone(), vec![], vec![],), BadOrigin);
+
+	assert_noop!(
+		Alliance::disband(user.clone(), DisbandWitness { fellow_members: 3, ..Default::default() }),
+		BadOrigin
+	);
+
+	assert_noop!(Alliance::set_rule(user.clone(), cid.clone()), BadOrigin);
+
+	assert_noop!(Alliance::retire(user.clone()), Error::<Test, ()>::RetirementNoticeNotGiven);
+
+	// Allies should be able to give retirement notice.
+	if !user_is_member {
+		assert_noop!(Alliance::give_retirement_notice(user.clone()), Error::<Test, ()>::NotMember);
+	}
+
+	assert_noop!(Alliance::elevate_ally(user.clone(), 4), BadOrigin);
+
+	assert_noop!(Alliance::kick_member(user.clone(), 1), BadOrigin);
+
+	assert_noop!(Alliance::nominate_ally(user.clone(), 4), Error::<Test, ()>::NoVotingRights);
+
+	assert_noop!(
+		Alliance::propose(user.clone(), 5, Box::new(proposal), 1000),
+		Error::<Test, ()>::NoVotingRights
+	);
+}
+
+#[test]
+fn init_members_works() {
+	new_test_ext().execute_with(|| {
+		// alliance must be reset first, no witness data
+		assert_noop!(
+			Alliance::init_members(RuntimeOrigin::root(), vec![8], vec![],),
+			Error::<Test, ()>::AllianceAlreadyInitialized,
+		);
+
+		// give a retirement notice to check later a retiring member not removed
+		assert_ok!(Alliance::give_retirement_notice(RuntimeOrigin::signed(2)));
+		assert!(Alliance::is_member_of(&2, MemberRole::Retiring));
+
+		// disband the Alliance to init new
+		assert_ok!(Alliance::disband(RuntimeOrigin::root(), DisbandWitness::new(2, 0)));
+
+		// fails without root
+		assert_noop!(Alliance::init_members(RuntimeOrigin::signed(1), vec![], vec![]), BadOrigin);
+
+		// fellows missing, other members given
+		assert_noop!(
+			Alliance::init_members(RuntimeOrigin::root(), vec![], vec![2],),
+			Error::<Test, ()>::FellowsMissing,
+		);
+
+		// success call
+		assert_ok!(Alliance::init_members(RuntimeOrigin::root(), vec![8, 5], vec![2],));
+
+		// assert new set of voting members
+		assert_eq!(Alliance::voting_members(), vec![5, 8]);
+		// assert new members member
+		assert!(is_fellow(&8));
+		assert!(is_fellow(&5));
+		assert!(Alliance::is_ally(&2));
+		// assert a retiring member from previous Alliance not removed
+		assert!(Alliance::is_member_of(&2, MemberRole::Retiring));
+
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::MembersInitialized {
+			fellows: vec![5, 8],
+			allies: vec![2],
+		}));
+	})
+}
+
+#[test]
+fn disband_works() {
+	new_test_ext().execute_with(|| {
+		// ensure alliance is set
+		assert_eq!(Alliance::voting_members(), vec![1, 2, 3]);
+
+		// give a retirement notice to check later a retiring member not removed
+		assert_ok!(Alliance::give_retirement_notice(RuntimeOrigin::signed(2)));
+		assert!(Alliance::is_member_of(&2, MemberRole::Retiring));
+
+		// join alliance and reserve funds
+		assert_eq!(Balances::free_balance(9), 40);
+		assert_ok!(Alliance::join_alliance(RuntimeOrigin::signed(9)));
+		assert_eq!(Alliance::deposit_of(9), Some(25));
+		assert_eq!(Balances::free_balance(9), 15);
+		assert!(Alliance::is_member_of(&9, MemberRole::Ally));
+
+		// fails without root
+		assert_noop!(Alliance::disband(RuntimeOrigin::signed(1), Default::default()), BadOrigin);
+
+		// bad witness data checks
+		assert_noop!(
+			Alliance::disband(RuntimeOrigin::root(), Default::default(),),
+			Error::<Test, ()>::BadWitness
+		);
+
+		assert_noop!(
+			Alliance::disband(RuntimeOrigin::root(), DisbandWitness::new(1, 1)),
+			Error::<Test, ()>::BadWitness,
+		);
+		assert_noop!(
+			Alliance::disband(RuntimeOrigin::root(), DisbandWitness::new(2, 0)),
+			Error::<Test, ()>::BadWitness,
+		);
+
+		// success call
+		assert_ok!(Alliance::disband(RuntimeOrigin::root(), DisbandWitness::new(2, 1)));
+
+		// assert members disband
+		assert!(!Alliance::is_member(&1));
+		assert!(!Alliance::is_initialized());
+		// assert a retiring member from the previous Alliance not removed
+		assert!(Alliance::is_member_of(&2, MemberRole::Retiring));
+		// deposit unreserved
+		assert_eq!(Balances::free_balance(9), 40);
+
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::AllianceDisbanded {
+			fellow_members: 2,
+			ally_members: 1,
+			unreserved: 1,
+		}));
+
+		// the Alliance must be set first
+		assert_noop!(
+			Alliance::disband(RuntimeOrigin::root(), DisbandWitness::new(100, 100)),
+			Error::<Test, ()>::AllianceNotYetInitialized,
+		);
+	})
+}
+
+#[test]
+fn propose_works() {
+	new_test_ext().execute_with(|| {
+		let (proposal, proposal_len, hash) = make_remark_proposal(42);
+
+		// only voting member can propose proposal, 4 is ally not have vote rights
+		assert_noop!(
+			Alliance::propose(
+				RuntimeOrigin::signed(4),
+				3,
+				Box::new(proposal.clone()),
+				proposal_len
+			),
+			Error::<Test, ()>::NoVotingRights
+		);
+
+		assert_ok!(Alliance::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_eq!(*AllianceMotion::proposals(), vec![hash]);
+		assert_eq!(AllianceMotion::proposal_of(&hash), Some(proposal));
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Initialization,
+				event: mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 3,
+				}),
+				topics: vec![],
+			}]
+		);
+	});
+}
+
+#[test]
+fn vote_works() {
+	new_test_ext().execute_with(|| {
+		let (proposal, proposal_len, hash) = make_remark_proposal(42);
+		assert_ok!(Alliance::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Alliance::vote(RuntimeOrigin::signed(2), hash, 0, true));
+
+		let record = |event| EventRecord { phase: Phase::Initialization, event, topics: vec![] };
+		assert_eq!(
+			System::events(),
+			vec![
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 3
+				})),
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0,
+				})),
+			]
+		);
+	});
+}
+
+#[test]
+fn close_works() {
+	new_test_ext().execute_with(|| {
+		let (proposal, proposal_len, hash) = make_remark_proposal(42);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		assert_ok!(Alliance::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Alliance::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Alliance::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_ok!(Alliance::vote(RuntimeOrigin::signed(3), hash, 0, true));
+		assert_ok!(Alliance::close(
+			RuntimeOrigin::signed(1),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		let record = |event| EventRecord { phase: Phase::Initialization, event, topics: vec![] };
+		assert_eq!(
+			System::events(),
+			vec![
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 3
+				})),
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0,
+				})),
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0,
+				})),
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Voted {
+					account: 3,
+					proposal_hash: hash,
+					voted: true,
+					yes: 3,
+					no: 0,
+				})),
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Closed {
+					proposal_hash: hash,
+					yes: 3,
+					no: 0,
+				})),
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Approved {
+					proposal_hash: hash
+				})),
+				record(mock::RuntimeEvent::AllianceMotion(AllianceMotionEvent::Executed {
+					proposal_hash: hash,
+					result: Ok(()),
+				}))
+			]
+		);
+	});
+}
+
+#[test]
+fn set_rule_works() {
+	new_test_ext().execute_with(|| {
+		let cid = test_cid();
+		assert_ok!(Alliance::set_rule(RuntimeOrigin::signed(1), cid.clone()));
+		assert_eq!(Alliance::rule(), Some(cid.clone()));
+
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::NewRuleSet {
+			rule: cid,
+		}));
+	});
+}
+
+#[test]
+fn announce_works() {
+	new_test_ext().execute_with(|| {
+		let cid = test_cid();
+
+		assert_noop!(Alliance::announce(RuntimeOrigin::signed(2), cid.clone()), BadOrigin);
+
+		assert_ok!(Alliance::announce(RuntimeOrigin::signed(3), cid.clone()));
+		assert_eq!(Alliance::announcements(), vec![cid.clone()]);
+
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::Announced {
+			announcement: cid,
+		}));
+	});
+}
+
+#[test]
+fn remove_announcement_works() {
+	new_test_ext().execute_with(|| {
+		let cid = test_cid();
+		assert_ok!(Alliance::announce(RuntimeOrigin::signed(3), cid.clone()));
+		assert_eq!(Alliance::announcements(), vec![cid.clone()]);
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::Announced {
+			announcement: cid.clone(),
+		}));
+
+		System::set_block_number(2);
+
+		assert_ok!(Alliance::remove_announcement(RuntimeOrigin::signed(3), cid.clone()));
+		assert_eq!(Alliance::announcements(), vec![]);
+		System::assert_last_event(mock::RuntimeEvent::Alliance(
+			crate::Event::AnnouncementRemoved { announcement: cid },
+		));
+	});
+}
+
+#[test]
+fn join_alliance_works() {
+	new_test_ext().execute_with(|| {
+		// check already member
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(1)),
+			Error::<Test, ()>::AlreadyMember
+		);
+
+		// check already listed as unscrupulous
+		assert_ok!(Alliance::add_unscrupulous_items(
+			RuntimeOrigin::signed(3),
+			vec![UnscrupulousItem::AccountId(4)]
+		));
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(4)),
+			Error::<Test, ()>::AccountNonGrata
+		);
+		assert_ok!(Alliance::remove_unscrupulous_items(
+			RuntimeOrigin::signed(3),
+			vec![UnscrupulousItem::AccountId(4)]
+		));
+
+		// check deposit funds
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(5)),
+			Error::<Test, ()>::InsufficientFunds
+		);
+
+		// success to submit
+		assert_ok!(Alliance::join_alliance(RuntimeOrigin::signed(4)));
+		assert_eq!(Alliance::deposit_of(4), Some(25));
+		assert_eq!(Alliance::members(MemberRole::Ally), vec![4]);
+
+		// check already member
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(4)),
+			Error::<Test, ()>::AlreadyMember
+		);
+
+		// check missing identity judgement
+		#[cfg(not(feature = "runtime-benchmarks"))]
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(6)),
+			Error::<Test, ()>::WithoutGoodIdentityJudgement
+		);
+		// check missing identity info
+		#[cfg(not(feature = "runtime-benchmarks"))]
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(7)),
+			Error::<Test, ()>::WithoutIdentityDisplayAndWebsite
+		);
+	});
+}
+
+#[test]
+fn nominate_ally_works() {
+	new_test_ext().execute_with(|| {
+		// check already member
+		assert_noop!(
+			Alliance::nominate_ally(RuntimeOrigin::signed(1), 2),
+			Error::<Test, ()>::AlreadyMember
+		);
+
+		// only voting members (Fellows) have nominate right
+		assert_noop!(
+			Alliance::nominate_ally(RuntimeOrigin::signed(5), 4),
+			Error::<Test, ()>::NoVotingRights
+		);
+
+		// check already listed as unscrupulous
+		assert_ok!(Alliance::add_unscrupulous_items(
+			RuntimeOrigin::signed(3),
+			vec![UnscrupulousItem::AccountId(4)]
+		));
+		assert_noop!(
+			Alliance::nominate_ally(RuntimeOrigin::signed(1), 4),
+			Error::<Test, ()>::AccountNonGrata
+		);
+		assert_ok!(Alliance::remove_unscrupulous_items(
+			RuntimeOrigin::signed(3),
+			vec![UnscrupulousItem::AccountId(4)]
+		));
+
+		// success to nominate
+		assert_ok!(Alliance::nominate_ally(RuntimeOrigin::signed(1), 4));
+		assert_eq!(Alliance::deposit_of(4), None);
+		assert_eq!(Alliance::members(MemberRole::Ally), vec![4]);
+
+		// check already member
+		assert_noop!(
+			Alliance::nominate_ally(RuntimeOrigin::signed(1), 4),
+			Error::<Test, ()>::AlreadyMember
+		);
+
+		// check missing identity judgement
+		#[cfg(not(feature = "runtime-benchmarks"))]
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(6)),
+			Error::<Test, ()>::WithoutGoodIdentityJudgement
+		);
+		// check missing identity info
+		#[cfg(not(feature = "runtime-benchmarks"))]
+		assert_noop!(
+			Alliance::join_alliance(RuntimeOrigin::signed(7)),
+			Error::<Test, ()>::WithoutIdentityDisplayAndWebsite
+		);
+	});
+}
+
+#[test]
+fn elevate_ally_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Alliance::elevate_ally(RuntimeOrigin::signed(2), 4),
+			Error::<Test, ()>::NotAlly
+		);
+
+		assert_ok!(Alliance::join_alliance(RuntimeOrigin::signed(4)));
+		assert_eq!(Alliance::members(MemberRole::Ally), vec![4]);
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3]);
+
+		assert_ok!(Alliance::elevate_ally(RuntimeOrigin::signed(2), 4));
+		assert_eq!(Alliance::members(MemberRole::Ally), Vec::<u64>::new());
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3, 4]);
+	});
+}
+
+#[test]
+fn give_retirement_notice_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Alliance::give_retirement_notice(RuntimeOrigin::signed(4)),
+			Error::<Test, ()>::NotMember
+		);
+
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3]);
+		assert_ok!(Alliance::give_retirement_notice(RuntimeOrigin::signed(3)));
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2]);
+		assert_eq!(Alliance::members(MemberRole::Retiring), vec![3]);
+		System::assert_last_event(mock::RuntimeEvent::Alliance(
+			crate::Event::MemberRetirementPeriodStarted { member: (3) },
+		));
+
+		assert_noop!(
+			Alliance::give_retirement_notice(RuntimeOrigin::signed(3)),
+			Error::<Test, ()>::AlreadyRetiring
+		);
+	});
+}
+
+#[test]
+fn retire_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Alliance::retire(RuntimeOrigin::signed(2)),
+			Error::<Test, ()>::RetirementNoticeNotGiven
+		);
+
+		assert_noop!(
+			Alliance::retire(RuntimeOrigin::signed(4)),
+			Error::<Test, ()>::RetirementNoticeNotGiven
+		);
+
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3]);
+		assert_ok!(Alliance::give_retirement_notice(RuntimeOrigin::signed(3)));
+		assert_noop!(
+			Alliance::retire(RuntimeOrigin::signed(3)),
+			Error::<Test, ()>::RetirementPeriodNotPassed
+		);
+		System::set_block_number(System::block_number() + RetirementPeriod::get());
+		assert_ok!(Alliance::retire(RuntimeOrigin::signed(3)));
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2]);
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::MemberRetired {
+			member: (3),
+			unreserved: None,
+		}));
+
+		// Move time on:
+		System::set_block_number(System::block_number() + RetirementPeriod::get());
+
+		assert_powerless(RuntimeOrigin::signed(3), false);
+	});
+}
+
+#[test]
+fn abdicate_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3]);
+		assert_ok!(Alliance::abdicate_fellow_status(RuntimeOrigin::signed(3)));
+
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::FellowAbdicated {
+			fellow: (3),
+		}));
+
+		assert_powerless(RuntimeOrigin::signed(3), true);
+	});
+}
+
+#[test]
+fn kick_member_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Alliance::kick_member(RuntimeOrigin::signed(4), 4), BadOrigin);
+
+		assert_noop!(
+			Alliance::kick_member(RuntimeOrigin::signed(2), 4),
+			Error::<Test, ()>::NotMember
+		);
+
+		<DepositOf<Test, ()>>::insert(2, 25);
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 2, 3]);
+		assert_ok!(Alliance::kick_member(RuntimeOrigin::signed(2), 2));
+		assert_eq!(Alliance::members(MemberRole::Fellow), vec![1, 3]);
+		assert_eq!(<DepositOf<Test, ()>>::get(2), None);
+		System::assert_last_event(mock::RuntimeEvent::Alliance(crate::Event::MemberKicked {
+			member: (2),
+			slashed: Some(25),
+		}));
+	});
+}
+
+#[test]
+fn add_unscrupulous_items_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Alliance::add_unscrupulous_items(RuntimeOrigin::signed(2), vec![]), BadOrigin);
+
+		assert_ok!(Alliance::add_unscrupulous_items(
+			RuntimeOrigin::signed(3),
+			vec![
+				UnscrupulousItem::AccountId(3),
+				UnscrupulousItem::Website("abc".as_bytes().to_vec().try_into().unwrap())
+			]
+		));
+		assert_eq!(Alliance::unscrupulous_accounts().into_inner(), vec![3]);
+		assert_eq!(Alliance::unscrupulous_websites().into_inner(), vec!["abc".as_bytes().to_vec()]);
+
+		assert_noop!(
+			Alliance::add_unscrupulous_items(
+				RuntimeOrigin::signed(3),
+				vec![UnscrupulousItem::AccountId(3)]
+			),
+			Error::<Test, ()>::AlreadyUnscrupulous
+		);
+	});
+}
+
+#[test]
+fn remove_unscrupulous_items_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Alliance::remove_unscrupulous_items(RuntimeOrigin::signed(2), vec![]),
+			BadOrigin
+		);
+
+		assert_noop!(
+			Alliance::remove_unscrupulous_items(
+				RuntimeOrigin::signed(3),
+				vec![UnscrupulousItem::AccountId(3)]
+			),
+			Error::<Test, ()>::NotListedAsUnscrupulous
+		);
+
+		assert_ok!(Alliance::add_unscrupulous_items(
+			RuntimeOrigin::signed(3),
+			vec![UnscrupulousItem::AccountId(3)]
+		));
+		assert_eq!(Alliance::unscrupulous_accounts(), vec![3]);
+		assert_ok!(Alliance::remove_unscrupulous_items(
+			RuntimeOrigin::signed(3),
+			vec![UnscrupulousItem::AccountId(3)]
+		));
+		assert_eq!(Alliance::unscrupulous_accounts(), Vec::<u64>::new());
+	});
+}
+
+#[test]
+fn weights_sane() {
+	let info = crate::Call::<Test>::join_alliance {}.get_dispatch_info();
+	assert_eq!(<() as crate::WeightInfo>::join_alliance(), info.weight);
+
+	let info = crate::Call::<Test>::nominate_ally { who: 10 }.get_dispatch_info();
+	assert_eq!(<() as crate::WeightInfo>::nominate_ally(), info.weight);
+}
diff --git a/substrate/frame/alliance/src/types.rs b/substrate/frame/alliance/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..784993b2bc1334a26bd7430661e3481d7b6041d8
--- /dev/null
+++ b/substrate/frame/alliance/src/types.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.
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{traits::ConstU32, BoundedVec};
+use scale_info::TypeInfo;
+use sp_runtime::RuntimeDebug;
+use sp_std::{convert::TryInto, prelude::*};
+
+/// A Multihash instance that only supports the basic functionality and no hashing.
+#[derive(
+	Clone, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen,
+)]
+pub struct Multihash {
+	/// The code of the Multihash.
+	pub code: u64,
+	/// The digest.
+	pub digest: BoundedVec<u8, ConstU32<68>>, // 4 byte dig size + 64 bytes hash digest
+}
+
+impl Multihash {
+	/// Returns the size of the digest.
+	pub fn size(&self) -> usize {
+		self.digest.len()
+	}
+}
+
+/// The version of the CID.
+#[derive(
+	Clone,
+	Copy,
+	PartialEq,
+	Eq,
+	PartialOrd,
+	Ord,
+	RuntimeDebug,
+	Encode,
+	Decode,
+	TypeInfo,
+	MaxEncodedLen,
+)]
+pub enum Version {
+	/// CID version 0.
+	V0,
+	/// CID version 1.
+	V1,
+}
+
+/// Representation of a CID.
+///
+/// The generic is about the allocated size of the multihash.
+#[derive(
+	Clone, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen,
+)]
+pub struct Cid {
+	/// The version of CID.
+	pub version: Version,
+	/// The codec of CID.
+	pub codec: u64,
+	/// The multihash of CID.
+	pub hash: Multihash,
+}
+
+impl Cid {
+	/// Creates a new CIDv0.
+	pub fn new_v0(sha2_256_digest: impl Into<Vec<u8>>) -> Self {
+		/// DAG-PB multicodec code
+		const DAG_PB: u64 = 0x70;
+		/// The SHA_256 multicodec code
+		const SHA2_256: u64 = 0x12;
+
+		let digest = sha2_256_digest.into();
+		assert_eq!(digest.len(), 32);
+
+		Self {
+			version: Version::V0,
+			codec: DAG_PB,
+			hash: Multihash { code: SHA2_256, digest: digest.try_into().expect("msg") },
+		}
+	}
+}
+
+/// Witness data for the `disband` call.
+#[derive(
+	Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo, Default,
+)]
+pub struct DisbandWitness {
+	/// Total number of fellow members in the current Alliance.
+	#[codec(compact)]
+	pub(super) fellow_members: u32,
+	/// Total number of ally members in the current Alliance.
+	#[codec(compact)]
+	pub(super) ally_members: u32,
+}
+
+#[cfg(test)]
+impl DisbandWitness {
+	// Creates new DisbandWitness.
+	pub(super) fn new(fellow_members: u32, ally_members: u32) -> Self {
+		Self { fellow_members, ally_members }
+	}
+}
+
+impl DisbandWitness {
+	pub(super) fn is_zero(self) -> bool {
+		self == Self::default()
+	}
+}
diff --git a/substrate/frame/alliance/src/weights.rs b/substrate/frame/alliance/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b5bb50957207f6c75cbca0479d97127ffcca572a
--- /dev/null
+++ b/substrate/frame/alliance/src/weights.rs
@@ -0,0 +1,908 @@
+// 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.
+
+//! Autogenerated weights for pallet_alliance
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_alliance
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/alliance/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_alliance.
+pub trait WeightInfo {
+	fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight;
+	fn vote(m: u32, ) -> Weight;
+	fn close_early_disapproved(m: u32, p: u32, ) -> Weight;
+	fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight;
+	fn close_disapproved(m: u32, p: u32, ) -> Weight;
+	fn close_approved(b: u32, m: u32, p: u32, ) -> Weight;
+	fn init_members(m: u32, z: u32, ) -> Weight;
+	fn disband(x: u32, y: u32, z: u32, ) -> Weight;
+	fn set_rule() -> Weight;
+	fn announce() -> Weight;
+	fn remove_announcement() -> Weight;
+	fn join_alliance() -> Weight;
+	fn nominate_ally() -> Weight;
+	fn elevate_ally() -> Weight;
+	fn give_retirement_notice() -> Weight;
+	fn retire() -> Weight;
+	fn kick_member() -> Weight;
+	fn add_unscrupulous_items(n: u32, l: u32, ) -> Weight;
+	fn remove_unscrupulous_items(n: u32, l: u32, ) -> Weight;
+	fn abdicate_fellow_status() -> Weight;
+}
+
+/// Weights for pallet_alliance using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion ProposalOf (r:1 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalCount (r:1 w:1)
+	/// Proof Skipped: AllianceMotion ProposalCount (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Voting (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[1, 1024]`.
+	/// The range of component `m` is `[2, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `653 + m * (32 ±0) + p * (35 ±0)`
+		//  Estimated: `6676 + m * (32 ±0) + p * (36 ±0)`
+		// Minimum execution time: 36_908_000 picoseconds.
+		Weight::from_parts(39_040_304, 6676)
+			// Standard Error: 131
+			.saturating_add(Weight::from_parts(781, 0).saturating_mul(b.into()))
+			// Standard Error: 1_375
+			.saturating_add(Weight::from_parts(48_745, 0).saturating_mul(m.into()))
+			// Standard Error: 1_358
+			.saturating_add(Weight::from_parts(148_047, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[5, 100]`.
+	fn vote(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1042 + m * (64 ±0)`
+		//  Estimated: `6676 + m * (64 ±0)`
+		// Minimum execution time: 30_166_000 picoseconds.
+		Weight::from_parts(32_798_454, 6676)
+			// Standard Error: 1_432
+			.saturating_add(Weight::from_parts(83_001, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:0 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `576 + m * (96 ±0) + p * (36 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (36 ±0)`
+		// Minimum execution time: 45_173_000 picoseconds.
+		Weight::from_parts(42_192_020, 6676)
+			// Standard Error: 1_456
+			.saturating_add(Weight::from_parts(66_751, 0).saturating_mul(m.into()))
+			// Standard Error: 1_420
+			.saturating_add(Weight::from_parts(158_161, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:1 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[1, 1024]`.
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1087 + m * (96 ±0) + p * (39 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (40 ±0)`
+		// Minimum execution time: 58_290_000 picoseconds.
+		Weight::from_parts(54_924_919, 6676)
+			// Standard Error: 157
+			.saturating_add(Weight::from_parts(464, 0).saturating_mul(b.into()))
+			// Standard Error: 1_665
+			.saturating_add(Weight::from_parts(73_183, 0).saturating_mul(m.into()))
+			// Standard Error: 1_623
+			.saturating_add(Weight::from_parts(168_318, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:0 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[2, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `577 + m * (96 ±0) + p * (36 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (36 ±0)`
+		// Minimum execution time: 46_794_000 picoseconds.
+		Weight::from_parts(43_092_958, 6676)
+			// Standard Error: 1_273
+			.saturating_add(Weight::from_parts(71_054, 0).saturating_mul(m.into()))
+			// Standard Error: 1_257
+			.saturating_add(Weight::from_parts(152_820, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:0 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[1, 1024]`.
+	/// The range of component `m` is `[5, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `684 + m * (96 ±0) + p * (35 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (36 ±0)`
+		// Minimum execution time: 47_338_000 picoseconds.
+		Weight::from_parts(41_257_479, 6676)
+			// Standard Error: 119
+			.saturating_add(Weight::from_parts(1_019, 0).saturating_mul(b.into()))
+			// Standard Error: 1_277
+			.saturating_add(Weight::from_parts(78_453, 0).saturating_mul(m.into()))
+			// Standard Error: 1_231
+			.saturating_add(Weight::from_parts(150_991, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:2 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Members (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	/// The range of component `z` is `[0, 100]`.
+	fn init_members(m: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `217`
+		//  Estimated: `12362`
+		// Minimum execution time: 35_012_000 picoseconds.
+		Weight::from_parts(24_288_079, 12362)
+			// Standard Error: 878
+			.saturating_add(Weight::from_parts(153_615, 0).saturating_mul(m.into()))
+			// Standard Error: 867
+			.saturating_add(Weight::from_parts(129_307, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Alliance Members (r:2 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Alliance DepositOf (r:200 w:50)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	/// Storage: System Account (r:50 w:50)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `x` is `[1, 100]`.
+	/// The range of component `y` is `[0, 100]`.
+	/// The range of component `z` is `[0, 50]`.
+	fn disband(x: u32, y: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + x * (50 ±0) + y * (51 ±0) + z * (251 ±0)`
+		//  Estimated: `12362 + x * (2539 ±0) + y * (2539 ±0) + z * (2603 ±1)`
+		// Minimum execution time: 309_235_000 picoseconds.
+		Weight::from_parts(311_279_000, 12362)
+			// Standard Error: 26_510
+			.saturating_add(Weight::from_parts(543_475, 0).saturating_mul(x.into()))
+			// Standard Error: 26_382
+			.saturating_add(Weight::from_parts(603_169, 0).saturating_mul(y.into()))
+			// Standard Error: 52_716
+			.saturating_add(Weight::from_parts(16_264_836, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(y.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(z.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(z.into())))
+			.saturating_add(Weight::from_parts(0, 2539).saturating_mul(x.into()))
+			.saturating_add(Weight::from_parts(0, 2539).saturating_mul(y.into()))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(z.into()))
+	}
+	/// Storage: Alliance Rule (r:0 w:1)
+	/// Proof: Alliance Rule (max_values: Some(1), max_size: Some(87), added: 582, mode: MaxEncodedLen)
+	fn set_rule() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_833_000 picoseconds.
+		Weight::from_parts(9_313_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Announcements (r:1 w:1)
+	/// Proof: Alliance Announcements (max_values: Some(1), max_size: Some(8702), added: 9197, mode: MaxEncodedLen)
+	fn announce() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `246`
+		//  Estimated: `10187`
+		// Minimum execution time: 12_231_000 picoseconds.
+		Weight::from_parts(12_761_000, 10187)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Announcements (r:1 w:1)
+	/// Proof: Alliance Announcements (max_values: Some(1), max_size: Some(8702), added: 9197, mode: MaxEncodedLen)
+	fn remove_announcement() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `319`
+		//  Estimated: `10187`
+		// Minimum execution time: 13_079_000 picoseconds.
+		Weight::from_parts(13_612_000, 10187)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:0)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Alliance DepositOf (r:0 w:1)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	fn join_alliance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `468`
+		//  Estimated: `18048`
+		// Minimum execution time: 44_574_000 picoseconds.
+		Weight::from_parts(46_157_000, 18048)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:0)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	fn nominate_ally() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `367`
+		//  Estimated: `18048`
+		// Minimum execution time: 26_114_000 picoseconds.
+		Weight::from_parts(27_069_000, 18048)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Members (r:2 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	fn elevate_ally() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `443`
+		//  Estimated: `12362`
+		// Minimum execution time: 25_882_000 picoseconds.
+		Weight::from_parts(26_923_000, 12362)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Alliance Members (r:4 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Alliance RetiringMembers (r:0 w:1)
+	/// Proof: Alliance RetiringMembers (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn give_retirement_notice() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `443`
+		//  Estimated: `23734`
+		// Minimum execution time: 34_112_000 picoseconds.
+		Weight::from_parts(35_499_000, 23734)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Alliance RetiringMembers (r:1 w:1)
+	/// Proof: Alliance RetiringMembers (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	/// Storage: Alliance Members (r:1 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: Alliance DepositOf (r:1 w:1)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn retire() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `687`
+		//  Estimated: `6676`
+		// Minimum execution time: 41_239_000 picoseconds.
+		Weight::from_parts(42_764_000, 6676)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Alliance DepositOf (r:1 w:1)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	fn kick_member() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `707`
+		//  Estimated: `18048`
+		// Minimum execution time: 68_071_000 picoseconds.
+		Weight::from_parts(71_808_000, 18048)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:1)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousWebsites (r:1 w:1)
+	/// Proof: Alliance UnscrupulousWebsites (max_values: Some(1), max_size: Some(25702), added: 26197, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `l` is `[0, 255]`.
+	fn add_unscrupulous_items(n: u32, l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `246`
+		//  Estimated: `27187`
+		// Minimum execution time: 7_006_000 picoseconds.
+		Weight::from_parts(7_253_000, 27187)
+			// Standard Error: 3_403
+			.saturating_add(Weight::from_parts(1_680_082, 0).saturating_mul(n.into()))
+			// Standard Error: 1_333
+			.saturating_add(Weight::from_parts(72_943, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:1)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousWebsites (r:1 w:1)
+	/// Proof: Alliance UnscrupulousWebsites (max_values: Some(1), max_size: Some(25702), added: 26197, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `l` is `[0, 255]`.
+	fn remove_unscrupulous_items(n: u32, l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + l * (100 ±0) + n * (289 ±0)`
+		//  Estimated: `27187`
+		// Minimum execution time: 7_292_000 picoseconds.
+		Weight::from_parts(7_629_000, 27187)
+			// Standard Error: 176_225
+			.saturating_add(Weight::from_parts(16_646_429, 0).saturating_mul(n.into()))
+			// Standard Error: 69_017
+			.saturating_add(Weight::from_parts(310_978, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	fn abdicate_fellow_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `443`
+		//  Estimated: `18048`
+		// Minimum execution time: 31_798_000 picoseconds.
+		Weight::from_parts(33_463_000, 18048)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion ProposalOf (r:1 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalCount (r:1 w:1)
+	/// Proof Skipped: AllianceMotion ProposalCount (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Voting (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[1, 1024]`.
+	/// The range of component `m` is `[2, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `653 + m * (32 ±0) + p * (35 ±0)`
+		//  Estimated: `6676 + m * (32 ±0) + p * (36 ±0)`
+		// Minimum execution time: 36_908_000 picoseconds.
+		Weight::from_parts(39_040_304, 6676)
+			// Standard Error: 131
+			.saturating_add(Weight::from_parts(781, 0).saturating_mul(b.into()))
+			// Standard Error: 1_375
+			.saturating_add(Weight::from_parts(48_745, 0).saturating_mul(m.into()))
+			// Standard Error: 1_358
+			.saturating_add(Weight::from_parts(148_047, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[5, 100]`.
+	fn vote(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1042 + m * (64 ±0)`
+		//  Estimated: `6676 + m * (64 ±0)`
+		// Minimum execution time: 30_166_000 picoseconds.
+		Weight::from_parts(32_798_454, 6676)
+			// Standard Error: 1_432
+			.saturating_add(Weight::from_parts(83_001, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:0 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `576 + m * (96 ±0) + p * (36 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (36 ±0)`
+		// Minimum execution time: 45_173_000 picoseconds.
+		Weight::from_parts(42_192_020, 6676)
+			// Standard Error: 1_456
+			.saturating_add(Weight::from_parts(66_751, 0).saturating_mul(m.into()))
+			// Standard Error: 1_420
+			.saturating_add(Weight::from_parts(158_161, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:1 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[1, 1024]`.
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1087 + m * (96 ±0) + p * (39 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (40 ±0)`
+		// Minimum execution time: 58_290_000 picoseconds.
+		Weight::from_parts(54_924_919, 6676)
+			// Standard Error: 157
+			.saturating_add(Weight::from_parts(464, 0).saturating_mul(b.into()))
+			// Standard Error: 1_665
+			.saturating_add(Weight::from_parts(73_183, 0).saturating_mul(m.into()))
+			// Standard Error: 1_623
+			.saturating_add(Weight::from_parts(168_318, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:0 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[2, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `577 + m * (96 ±0) + p * (36 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (36 ±0)`
+		// Minimum execution time: 46_794_000 picoseconds.
+		Weight::from_parts(43_092_958, 6676)
+			// Standard Error: 1_273
+			.saturating_add(Weight::from_parts(71_054, 0).saturating_mul(m.into()))
+			// Standard Error: 1_257
+			.saturating_add(Weight::from_parts(152_820, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:1 w:0)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Voting (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Proposals (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion ProposalOf (r:0 w:1)
+	/// Proof Skipped: AllianceMotion ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[1, 1024]`.
+	/// The range of component `m` is `[5, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `684 + m * (96 ±0) + p * (35 ±0)`
+		//  Estimated: `6676 + m * (97 ±0) + p * (36 ±0)`
+		// Minimum execution time: 47_338_000 picoseconds.
+		Weight::from_parts(41_257_479, 6676)
+			// Standard Error: 119
+			.saturating_add(Weight::from_parts(1_019, 0).saturating_mul(b.into()))
+			// Standard Error: 1_277
+			.saturating_add(Weight::from_parts(78_453, 0).saturating_mul(m.into()))
+			// Standard Error: 1_231
+			.saturating_add(Weight::from_parts(150_991, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 97).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Alliance Members (r:2 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Members (r:1 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	/// The range of component `z` is `[0, 100]`.
+	fn init_members(m: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `217`
+		//  Estimated: `12362`
+		// Minimum execution time: 35_012_000 picoseconds.
+		Weight::from_parts(24_288_079, 12362)
+			// Standard Error: 878
+			.saturating_add(Weight::from_parts(153_615, 0).saturating_mul(m.into()))
+			// Standard Error: 867
+			.saturating_add(Weight::from_parts(129_307, 0).saturating_mul(z.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Alliance Members (r:2 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Alliance DepositOf (r:200 w:50)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	/// Storage: System Account (r:50 w:50)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `x` is `[1, 100]`.
+	/// The range of component `y` is `[0, 100]`.
+	/// The range of component `z` is `[0, 50]`.
+	fn disband(x: u32, y: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + x * (50 ±0) + y * (51 ±0) + z * (251 ±0)`
+		//  Estimated: `12362 + x * (2539 ±0) + y * (2539 ±0) + z * (2603 ±1)`
+		// Minimum execution time: 309_235_000 picoseconds.
+		Weight::from_parts(311_279_000, 12362)
+			// Standard Error: 26_510
+			.saturating_add(Weight::from_parts(543_475, 0).saturating_mul(x.into()))
+			// Standard Error: 26_382
+			.saturating_add(Weight::from_parts(603_169, 0).saturating_mul(y.into()))
+			// Standard Error: 52_716
+			.saturating_add(Weight::from_parts(16_264_836, 0).saturating_mul(z.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(y.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(z.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(z.into())))
+			.saturating_add(Weight::from_parts(0, 2539).saturating_mul(x.into()))
+			.saturating_add(Weight::from_parts(0, 2539).saturating_mul(y.into()))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(z.into()))
+	}
+	/// Storage: Alliance Rule (r:0 w:1)
+	/// Proof: Alliance Rule (max_values: Some(1), max_size: Some(87), added: 582, mode: MaxEncodedLen)
+	fn set_rule() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_833_000 picoseconds.
+		Weight::from_parts(9_313_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Announcements (r:1 w:1)
+	/// Proof: Alliance Announcements (max_values: Some(1), max_size: Some(8702), added: 9197, mode: MaxEncodedLen)
+	fn announce() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `246`
+		//  Estimated: `10187`
+		// Minimum execution time: 12_231_000 picoseconds.
+		Weight::from_parts(12_761_000, 10187)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Announcements (r:1 w:1)
+	/// Proof: Alliance Announcements (max_values: Some(1), max_size: Some(8702), added: 9197, mode: MaxEncodedLen)
+	fn remove_announcement() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `319`
+		//  Estimated: `10187`
+		// Minimum execution time: 13_079_000 picoseconds.
+		Weight::from_parts(13_612_000, 10187)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:0)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Alliance DepositOf (r:0 w:1)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	fn join_alliance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `468`
+		//  Estimated: `18048`
+		// Minimum execution time: 44_574_000 picoseconds.
+		Weight::from_parts(46_157_000, 18048)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:0)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	fn nominate_ally() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `367`
+		//  Estimated: `18048`
+		// Minimum execution time: 26_114_000 picoseconds.
+		Weight::from_parts(27_069_000, 18048)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Alliance Members (r:2 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	fn elevate_ally() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `443`
+		//  Estimated: `12362`
+		// Minimum execution time: 25_882_000 picoseconds.
+		Weight::from_parts(26_923_000, 12362)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Alliance Members (r:4 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Alliance RetiringMembers (r:0 w:1)
+	/// Proof: Alliance RetiringMembers (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn give_retirement_notice() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `443`
+		//  Estimated: `23734`
+		// Minimum execution time: 34_112_000 picoseconds.
+		Weight::from_parts(35_499_000, 23734)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Alliance RetiringMembers (r:1 w:1)
+	/// Proof: Alliance RetiringMembers (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	/// Storage: Alliance Members (r:1 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: Alliance DepositOf (r:1 w:1)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn retire() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `687`
+		//  Estimated: `6676`
+		// Minimum execution time: 41_239_000 picoseconds.
+		Weight::from_parts(42_764_000, 6676)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:1)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Alliance DepositOf (r:1 w:1)
+	/// Proof: Alliance DepositOf (max_values: None, max_size: Some(64), added: 2539, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	fn kick_member() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `707`
+		//  Estimated: `18048`
+		// Minimum execution time: 68_071_000 picoseconds.
+		Weight::from_parts(71_808_000, 18048)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:1)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousWebsites (r:1 w:1)
+	/// Proof: Alliance UnscrupulousWebsites (max_values: Some(1), max_size: Some(25702), added: 26197, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `l` is `[0, 255]`.
+	fn add_unscrupulous_items(n: u32, l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `246`
+		//  Estimated: `27187`
+		// Minimum execution time: 7_006_000 picoseconds.
+		Weight::from_parts(7_253_000, 27187)
+			// Standard Error: 3_403
+			.saturating_add(Weight::from_parts(1_680_082, 0).saturating_mul(n.into()))
+			// Standard Error: 1_333
+			.saturating_add(Weight::from_parts(72_943, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Alliance UnscrupulousAccounts (r:1 w:1)
+	/// Proof: Alliance UnscrupulousAccounts (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: Alliance UnscrupulousWebsites (r:1 w:1)
+	/// Proof: Alliance UnscrupulousWebsites (max_values: Some(1), max_size: Some(25702), added: 26197, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `l` is `[0, 255]`.
+	fn remove_unscrupulous_items(n: u32, l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + l * (100 ±0) + n * (289 ±0)`
+		//  Estimated: `27187`
+		// Minimum execution time: 7_292_000 picoseconds.
+		Weight::from_parts(7_629_000, 27187)
+			// Standard Error: 176_225
+			.saturating_add(Weight::from_parts(16_646_429, 0).saturating_mul(n.into()))
+			// Standard Error: 69_017
+			.saturating_add(Weight::from_parts(310_978, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Alliance Members (r:3 w:2)
+	/// Proof: Alliance Members (max_values: None, max_size: Some(3211), added: 5686, mode: MaxEncodedLen)
+	/// Storage: AllianceMotion Proposals (r:1 w:0)
+	/// Proof Skipped: AllianceMotion Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Members (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: AllianceMotion Prime (r:0 w:1)
+	/// Proof Skipped: AllianceMotion Prime (max_values: Some(1), max_size: None, mode: Measured)
+	fn abdicate_fellow_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `443`
+		//  Estimated: `18048`
+		// Minimum execution time: 31_798_000 picoseconds.
+		Weight::from_parts(33_463_000, 18048)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+}
diff --git a/substrate/frame/asset-conversion/Cargo.toml b/substrate/frame/asset-conversion/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2ad8d9d473e055918a6318070a1a0c6eda434362
--- /dev/null
+++ b/substrate/frame/asset-conversion/Cargo.toml
@@ -0,0 +1,64 @@
+[package]
+name = "pallet-asset-conversion"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME asset conversion pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-assets = { version = "4.0.0-dev", path = "../assets" }
+primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "scale-info", "num-traits"] }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-assets/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/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/asset-conversion/README.md b/substrate/frame/asset-conversion/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e895db5e83adfd8c35be12ad42e731a4c9eb71fb
--- /dev/null
+++ b/substrate/frame/asset-conversion/README.md
@@ -0,0 +1,25 @@
+# asset-conversion
+
+## A swap pallet
+
+This pallet allows assets to be converted from one type to another by means of a constant product formula.
+The pallet based is based on [Uniswap V2](https://github.com/Uniswap/v2-core) logic.
+
+### Overview
+
+This pallet allows you to:
+
+  - create a liquidity pool for 2 assets
+  - provide the liquidity and receive back an LP token
+  - exchange the LP token back to assets
+  - swap 2 assets if there is a pool created
+  - query for an exchange price via a new runtime call endpoint
+  - query the size of a liquidity pool.
+
+Please see the rust module documentation for full details:
+
+`cargo doc -p pallet-asset-conversion --open`
+
+### License
+
+License: Apache-2.0
diff --git a/substrate/frame/asset-conversion/src/benchmarking.rs b/substrate/frame/asset-conversion/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..87b541cd4744d1be32cd0908492b470c86d0f604
--- /dev/null
+++ b/substrate/frame/asset-conversion/src/benchmarking.rs
@@ -0,0 +1,338 @@
+// 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.
+
+//! Asset Conversion pallet benchmarking.
+
+use super::*;
+use frame_benchmarking::{benchmarks, whitelisted_caller};
+use frame_support::{
+	assert_ok,
+	storage::bounded_vec::BoundedVec,
+	traits::{
+		fungible::{Inspect as InspectFungible, Mutate as MutateFungible, Unbalanced},
+		fungibles::{Create, Inspect, Mutate},
+	},
+};
+use frame_system::RawOrigin as SystemOrigin;
+use sp_core::Get;
+use sp_runtime::traits::{Bounded, StaticLookup};
+use sp_std::{ops::Div, prelude::*};
+
+use crate::Pallet as AssetConversion;
+
+const INITIAL_ASSET_BALANCE: u128 = 1_000_000_000_000;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+type BalanceOf<T> =
+	<<T as Config>::Currency as InspectFungible<<T as frame_system::Config>::AccountId>>::Balance;
+
+fn get_lp_token_id<T: Config>() -> T::PoolAssetId
+where
+	T::PoolAssetId: Into<u32>,
+{
+	let next_id: u32 = AssetConversion::<T>::get_next_pool_asset_id().into();
+	(next_id - 1).into()
+}
+
+fn create_asset<T: Config>(asset: &T::MultiAssetId) -> (T::AccountId, AccountIdLookupOf<T>)
+where
+	T::AssetBalance: From<u128>,
+	T::Currency: Unbalanced<T::AccountId>,
+	T::Assets: Create<T::AccountId> + Mutate<T::AccountId>,
+{
+	let caller: T::AccountId = whitelisted_caller();
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	if let MultiAssetIdConversionResult::Converted(asset_id) =
+		T::MultiAssetIdConverter::try_convert(asset)
+	{
+		T::Currency::set_balance(&caller, BalanceOf::<T>::max_value().div(1000u32.into()));
+		assert_ok!(T::Assets::create(asset_id.clone(), caller.clone(), true, 1.into()));
+		assert_ok!(T::Assets::mint_into(asset_id, &caller, INITIAL_ASSET_BALANCE.into()));
+	}
+	(caller, caller_lookup)
+}
+
+fn create_asset_and_pool<T: Config>(
+	asset1: &T::MultiAssetId,
+	asset2: &T::MultiAssetId,
+) -> (T::PoolAssetId, T::AccountId, AccountIdLookupOf<T>)
+where
+	T::AssetBalance: From<u128>,
+	T::Currency: Unbalanced<T::AccountId>,
+	T::Assets: Create<T::AccountId> + Mutate<T::AccountId>,
+	T::PoolAssetId: Into<u32>,
+{
+	let (_, _) = create_asset::<T>(asset1);
+	let (caller, caller_lookup) = create_asset::<T>(asset2);
+
+	assert_ok!(AssetConversion::<T>::create_pool(
+		SystemOrigin::Signed(caller.clone()).into(),
+		asset1.clone(),
+		asset2.clone()
+	));
+	let lp_token = get_lp_token_id::<T>();
+
+	(lp_token, caller, caller_lookup)
+}
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+benchmarks! {
+	where_clause {
+		where
+			T::AssetBalance: From<u128> + Into<u128>,
+			T::Currency: Unbalanced<T::AccountId>,
+			T::Balance: From<u128> + Into<u128>,
+			T::Assets: Create<T::AccountId> + Mutate<T::AccountId>,
+			T::PoolAssetId: Into<u32>,
+	}
+
+	create_pool {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::BenchmarkHelper::multiasset_id(0);
+		let (caller, _) = create_asset::<T>(&asset2);
+	}: _(SystemOrigin::Signed(caller.clone()), asset1.clone(), asset2.clone())
+	verify {
+		let lp_token = get_lp_token_id::<T>();
+		let pool_id = (asset1.clone(), asset2.clone());
+		assert_last_event::<T>(Event::PoolCreated {
+			creator: caller.clone(),
+			pool_account: AssetConversion::<T>::get_pool_account(&pool_id),
+			pool_id,
+			lp_token,
+		}.into());
+	}
+
+	add_liquidity {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::BenchmarkHelper::multiasset_id(0);
+		let (lp_token, caller, _) = create_asset_and_pool::<T>(&asset1, &asset2);
+		let ed: u128 = T::Currency::minimum_balance().into();
+		let add_amount = 1000 + ed;
+	}: _(SystemOrigin::Signed(caller.clone()), asset1.clone(), asset2.clone(), add_amount.into(), 1000.into(), 0.into(), 0.into(), caller.clone())
+	verify {
+		let pool_id = (asset1.clone(), asset2.clone());
+		let lp_minted = AssetConversion::<T>::calc_lp_amount_for_zero_supply(&add_amount.into(), &1000.into()).unwrap().into();
+		assert_eq!(
+			T::PoolAssets::balance(lp_token, &caller),
+			lp_minted.into()
+		);
+		assert_eq!(
+			T::Currency::balance(&AssetConversion::<T>::get_pool_account(&pool_id)),
+			add_amount.into()
+		);
+		assert_eq!(
+			T::Assets::balance(T::BenchmarkHelper::asset_id(0), &AssetConversion::<T>::get_pool_account(&pool_id)),
+			1000.into()
+		);
+	}
+
+	remove_liquidity {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::BenchmarkHelper::multiasset_id(0);
+		let (lp_token, caller, _) = create_asset_and_pool::<T>(&asset1, &asset2);
+		let ed: u128 = T::Currency::minimum_balance().into();
+		let add_amount = 100 * ed;
+		let lp_minted = AssetConversion::<T>::calc_lp_amount_for_zero_supply(&add_amount.into(), &1000.into()).unwrap().into();
+		let remove_lp_amount = lp_minted.checked_div(10).unwrap();
+
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset1.clone(),
+			asset2.clone(),
+			add_amount.into(),
+			1000.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		let total_supply = <T::PoolAssets as Inspect<T::AccountId>>::total_issuance(lp_token.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), asset1, asset2, remove_lp_amount.into(), 0.into(), 0.into(), caller.clone())
+	verify {
+		let new_total_supply = <T::PoolAssets as Inspect<T::AccountId>>::total_issuance(lp_token.clone());
+		assert_eq!(
+			new_total_supply,
+			total_supply - remove_lp_amount.into()
+		);
+	}
+
+	swap_exact_tokens_for_tokens {
+		let native = T::MultiAssetIdConverter::get_native();
+		let asset1 = T::BenchmarkHelper::multiasset_id(1);
+		let asset2 = T::BenchmarkHelper::multiasset_id(2);
+		let (_, caller, _) = create_asset_and_pool::<T>(&native, &asset1);
+		let (_, _) = create_asset::<T>(&asset2);
+		let ed: u128 = T::Currency::minimum_balance().into();
+
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			native.clone(),
+			asset1.clone(),
+			(100 * ed).into(),
+			200.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+
+		let path;
+		let swap_amount;
+		// if we only allow the native-asset pools, then the worst case scenario would be to swap
+		// asset1-native-asset2
+		if !T::AllowMultiAssetPools::get() {
+			AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), native.clone(), asset2.clone())?;
+			AssetConversion::<T>::add_liquidity(
+				SystemOrigin::Signed(caller.clone()).into(),
+				native.clone(),
+				asset2.clone(),
+				(500 * ed).into(),
+				1000.into(),
+				0.into(),
+				0.into(),
+				caller.clone(),
+			)?;
+			path = vec![asset1.clone(), native.clone(), asset2.clone()];
+			swap_amount = 100.into();
+		} else {
+			let asset3 = T::BenchmarkHelper::multiasset_id(3);
+			AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset1.clone(), asset2.clone())?;
+			let (_, _) = create_asset::<T>(&asset3);
+			AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset2.clone(), asset3.clone())?;
+
+			AssetConversion::<T>::add_liquidity(
+				SystemOrigin::Signed(caller.clone()).into(),
+				asset1.clone(),
+				asset2.clone(),
+				200.into(),
+				2000.into(),
+				0.into(),
+				0.into(),
+				caller.clone(),
+			)?;
+			AssetConversion::<T>::add_liquidity(
+				SystemOrigin::Signed(caller.clone()).into(),
+				asset2.clone(),
+				asset3.clone(),
+				2000.into(),
+				2000.into(),
+				0.into(),
+				0.into(),
+				caller.clone(),
+			)?;
+			path = vec![native.clone(), asset1.clone(), asset2.clone(), asset3.clone()];
+			swap_amount = ed.into();
+		}
+
+		let path: BoundedVec<_, T::MaxSwapPathLength> = BoundedVec::try_from(path).unwrap();
+		let native_balance = T::Currency::balance(&caller);
+		let asset1_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(1), &caller);
+	}: _(SystemOrigin::Signed(caller.clone()), path, swap_amount, 1.into(), caller.clone(), false)
+	verify {
+		if !T::AllowMultiAssetPools::get() {
+			let new_asset1_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(1), &caller);
+			assert_eq!(new_asset1_balance, asset1_balance - 100.into());
+		} else {
+			let new_native_balance = T::Currency::balance(&caller);
+			assert_eq!(new_native_balance, native_balance - ed.into());
+		}
+	}
+
+	swap_tokens_for_exact_tokens {
+		let native = T::MultiAssetIdConverter::get_native();
+		let asset1 = T::BenchmarkHelper::multiasset_id(1);
+		let asset2 = T::BenchmarkHelper::multiasset_id(2);
+		let (_, caller, _) = create_asset_and_pool::<T>(&native, &asset1);
+		let (_, _) = create_asset::<T>(&asset2);
+		let ed: u128 = T::Currency::minimum_balance().into();
+
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			native.clone(),
+			asset1.clone(),
+			(1000 * ed).into(),
+			500.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+
+		let path;
+		// if we only allow the native-asset pools, then the worst case scenario would be to swap
+		// asset1-native-asset2
+		if !T::AllowMultiAssetPools::get() {
+			AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), native.clone(), asset2.clone())?;
+			AssetConversion::<T>::add_liquidity(
+				SystemOrigin::Signed(caller.clone()).into(),
+				native.clone(),
+				asset2.clone(),
+				(500 * ed).into(),
+				1000.into(),
+				0.into(),
+				0.into(),
+				caller.clone(),
+			)?;
+			path = vec![asset1.clone(), native.clone(), asset2.clone()];
+		} else {
+			AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset1.clone(), asset2.clone())?;
+			let asset3 = T::BenchmarkHelper::multiasset_id(3);
+			let (_, _) = create_asset::<T>(&asset3);
+			AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset2.clone(), asset3.clone())?;
+
+			AssetConversion::<T>::add_liquidity(
+				SystemOrigin::Signed(caller.clone()).into(),
+				asset1.clone(),
+				asset2.clone(),
+				2000.into(),
+				2000.into(),
+				0.into(),
+				0.into(),
+				caller.clone(),
+			)?;
+			AssetConversion::<T>::add_liquidity(
+				SystemOrigin::Signed(caller.clone()).into(),
+				asset2.clone(),
+				asset3.clone(),
+				2000.into(),
+				2000.into(),
+				0.into(),
+				0.into(),
+				caller.clone(),
+			)?;
+			path = vec![native.clone(), asset1.clone(), asset2.clone(), asset3.clone()];
+		}
+
+		let path: BoundedVec<_, T::MaxSwapPathLength> = BoundedVec::try_from(path).unwrap();
+		let asset2_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(2), &caller);
+		let asset3_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(3), &caller);
+	}: _(SystemOrigin::Signed(caller.clone()), path.clone(), 100.into(), (1000 * ed).into(), caller.clone(), false)
+	verify {
+		if !T::AllowMultiAssetPools::get() {
+			let new_asset2_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(2), &caller);
+			assert_eq!(new_asset2_balance, asset2_balance + 100.into());
+		} else {
+			let new_asset3_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(3), &caller);
+			assert_eq!(new_asset3_balance, asset3_balance + 100.into());
+		}
+	}
+
+	impl_benchmark_test_suite!(AssetConversion, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/asset-conversion/src/lib.rs b/substrate/frame/asset-conversion/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d1d68f3e10fbb477c3ad2654836d7352d1d85dd1
--- /dev/null
+++ b/substrate/frame/asset-conversion/src/lib.rs
@@ -0,0 +1,1310 @@
+// 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.
+
+//! # Substrate Asset Conversion pallet
+//!
+//! Substrate Asset Conversion pallet based on the [Uniswap V2](https://github.com/Uniswap/v2-core) logic.
+//!
+//! ## Overview
+//!
+//! This pallet allows you to:
+//!
+//!  - [create a liquidity pool](`Pallet::create_pool()`) for 2 assets
+//!  - [provide the liquidity](`Pallet::add_liquidity()`) and receive back an LP token
+//!  - [exchange the LP token back to assets](`Pallet::remove_liquidity()`)
+//!  - [swap a specific amount of assets for another](`Pallet::swap_exact_tokens_for_tokens()`) if
+//!    there is a pool created, or
+//!  - [swap some assets for a specific amount of
+//!    another](`Pallet::swap_tokens_for_exact_tokens()`).
+//!  - [query for an exchange price](`AssetConversionApi::quote_price_exact_tokens_for_tokens`) via
+//!    a runtime call endpoint
+//!  - [query the size of a liquidity pool](`AssetConversionApi::get_reserves`) via a runtime api
+//!    endpoint.
+//!
+//! The `quote_price_exact_tokens_for_tokens` and `quote_price_tokens_for_exact_tokens` functions
+//! both take a path parameter of the route to take. If you want to swap from native asset to
+//! non-native asset 1, you would pass in a path of `[DOT, 1]` or `[1, DOT]`. If you want to swap
+//! from non-native asset 1 to non-native asset 2, you would pass in a path of `[1, DOT, 2]`.
+//!
+//! (For an example of configuring this pallet to use `MultiLocation` as an asset id, see the
+//! cumulus repo).
+//!
+//! Here is an example `state_call` that asks for a quote of a pool of native versus asset 1:
+//!
+//! ```text
+//! curl -sS -H "Content-Type: application/json" -d \
+//! '{"id":1, "jsonrpc":"2.0", "method": "state_call", "params": ["AssetConversionApi_quote_price_tokens_for_exact_tokens", "0x0101000000000000000000000011000000000000000000"]}' \
+//! http://localhost:9933/
+//! ```
+//! (This can be run against the kitchen sync node in the `node` folder of this repo.)
+#![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+use frame_support::traits::{DefensiveOption, Incrementable};
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+mod types;
+pub mod weights;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(test)]
+mod mock;
+
+use codec::Codec;
+use frame_support::{
+	ensure,
+	traits::tokens::{AssetId, Balance},
+};
+use frame_system::{
+	ensure_signed,
+	pallet_prelude::{BlockNumberFor, OriginFor},
+};
+pub use pallet::*;
+use sp_arithmetic::traits::Unsigned;
+use sp_runtime::{
+	traits::{
+		CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Ensure, MaybeDisplay, TrailingZeroInput,
+	},
+	DispatchError,
+};
+use sp_std::prelude::*;
+pub use types::*;
+pub use weights::WeightInfo;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{
+		pallet_prelude::*,
+		traits::{
+			fungible::{Inspect as InspectFungible, Mutate as MutateFungible},
+			fungibles::{Create, Inspect, Mutate},
+			tokens::{
+				Fortitude::Polite,
+				Precision::Exact,
+				Preservation::{Expendable, Preserve},
+			},
+			AccountTouch, ContainsPair,
+		},
+		BoundedBTreeSet, PalletId,
+	};
+	use sp_arithmetic::Permill;
+	use sp_runtime::{
+		traits::{IntegerSquareRoot, One, Zero},
+		Saturating,
+	};
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Currency type that this works on.
+		type Currency: InspectFungible<Self::AccountId, Balance = Self::Balance>
+			+ MutateFungible<Self::AccountId>;
+
+		/// The `Currency::Balance` type of the native currency.
+		type Balance: Balance;
+
+		/// The type used to describe the amount of fractions converted into assets.
+		type AssetBalance: Balance;
+
+		/// A type used for conversions between `Balance` and `AssetBalance`.
+		type HigherPrecisionBalance: IntegerSquareRoot
+			+ One
+			+ Ensure
+			+ Unsigned
+			+ From<u32>
+			+ From<Self::AssetBalance>
+			+ From<Self::Balance>
+			+ TryInto<Self::AssetBalance>
+			+ TryInto<Self::Balance>;
+
+		/// Identifier for the class of non-native asset.
+		/// Note: A `From<u32>` bound here would prevent `MultiLocation` from being used as an
+		/// `AssetId`.
+		type AssetId: AssetId;
+
+		/// Type that identifies either the native currency or a token class from `Assets`.
+		/// `Ord` is added because of `get_pool_id`.
+		///
+		/// The pool's `AccountId` is derived from this type. Any changes to the type may
+		/// necessitate a migration.
+		type MultiAssetId: AssetId + Ord + From<Self::AssetId>;
+
+		/// Type to convert an `AssetId` into `MultiAssetId`.
+		type MultiAssetIdConverter: MultiAssetIdConverter<Self::MultiAssetId, Self::AssetId>;
+
+		/// `AssetId` to address the lp tokens by.
+		type PoolAssetId: AssetId + PartialOrd + Incrementable + From<u32>;
+
+		/// Registry for the assets.
+		type Assets: Inspect<Self::AccountId, AssetId = Self::AssetId, Balance = Self::AssetBalance>
+			+ Mutate<Self::AccountId>
+			+ AccountTouch<Self::AssetId, Self::AccountId>
+			+ ContainsPair<Self::AssetId, Self::AccountId>;
+
+		/// Registry for the lp tokens. Ideally only this pallet should have create permissions on
+		/// the assets.
+		type PoolAssets: Inspect<Self::AccountId, AssetId = Self::PoolAssetId, Balance = Self::AssetBalance>
+			+ Create<Self::AccountId>
+			+ Mutate<Self::AccountId>
+			+ AccountTouch<Self::PoolAssetId, Self::AccountId>;
+
+		/// A % the liquidity providers will take of every swap. Represents 10ths of a percent.
+		#[pallet::constant]
+		type LPFee: Get<u32>;
+
+		/// A one-time fee to setup the pool.
+		#[pallet::constant]
+		type PoolSetupFee: Get<Self::Balance>;
+
+		/// An account that receives the pool setup fee.
+		type PoolSetupFeeReceiver: Get<Self::AccountId>;
+
+		/// A fee to withdraw the liquidity.
+		#[pallet::constant]
+		type LiquidityWithdrawalFee: Get<Permill>;
+
+		/// The minimum LP token amount that could be minted. Ameliorates rounding errors.
+		#[pallet::constant]
+		type MintMinLiquidity: Get<Self::AssetBalance>;
+
+		/// The max number of hops in a swap.
+		#[pallet::constant]
+		type MaxSwapPathLength: Get<u32>;
+
+		/// The pallet's id, used for deriving its sovereign account ID.
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// A setting to allow creating pools with both non-native assets.
+		#[pallet::constant]
+		type AllowMultiAssetPools: Get<bool>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The benchmarks need a way to create asset ids from u32s.
+		#[cfg(feature = "runtime-benchmarks")]
+		type BenchmarkHelper: BenchmarkHelper<Self::AssetId, Self::MultiAssetId>;
+	}
+
+	/// Map from `PoolAssetId` to `PoolInfo`. This establishes whether a pool has been officially
+	/// created rather than people sending tokens directly to a pool's public account.
+	#[pallet::storage]
+	pub type Pools<T: Config> =
+		StorageMap<_, Blake2_128Concat, PoolIdOf<T>, PoolInfo<T::PoolAssetId>, OptionQuery>;
+
+	/// Stores the `PoolAssetId` that is going to be used for the next lp token.
+	/// This gets incremented whenever a new lp pool is created.
+	#[pallet::storage]
+	pub type NextPoolAssetId<T: Config> = StorageValue<_, T::PoolAssetId, OptionQuery>;
+
+	// Pallet's events.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A successful call of the `CretaPool` extrinsic will create this event.
+		PoolCreated {
+			/// The account that created the pool.
+			creator: T::AccountId,
+			/// The pool id associated with the pool. Note that the order of the assets may not be
+			/// the same as the order specified in the create pool extrinsic.
+			pool_id: PoolIdOf<T>,
+			/// The account ID of the pool.
+			pool_account: T::AccountId,
+			/// The id of the liquidity tokens that will be minted when assets are added to this
+			/// pool.
+			lp_token: T::PoolAssetId,
+		},
+
+		/// A successful call of the `AddLiquidity` extrinsic will create this event.
+		LiquidityAdded {
+			/// The account that the liquidity was taken from.
+			who: T::AccountId,
+			/// The account that the liquidity tokens were minted to.
+			mint_to: T::AccountId,
+			/// The pool id of the pool that the liquidity was added to.
+			pool_id: PoolIdOf<T>,
+			/// The amount of the first asset that was added to the pool.
+			amount1_provided: T::AssetBalance,
+			/// The amount of the second asset that was added to the pool.
+			amount2_provided: T::AssetBalance,
+			/// The id of the lp token that was minted.
+			lp_token: T::PoolAssetId,
+			/// The amount of lp tokens that were minted of that id.
+			lp_token_minted: T::AssetBalance,
+		},
+
+		/// A successful call of the `RemoveLiquidity` extrinsic will create this event.
+		LiquidityRemoved {
+			/// The account that the liquidity tokens were burned from.
+			who: T::AccountId,
+			/// The account that the assets were transferred to.
+			withdraw_to: T::AccountId,
+			/// The pool id that the liquidity was removed from.
+			pool_id: PoolIdOf<T>,
+			/// The amount of the first asset that was removed from the pool.
+			amount1: T::AssetBalance,
+			/// The amount of the second asset that was removed from the pool.
+			amount2: T::AssetBalance,
+			/// The id of the lp token that was burned.
+			lp_token: T::PoolAssetId,
+			/// The amount of lp tokens that were burned of that id.
+			lp_token_burned: T::AssetBalance,
+			/// Liquidity withdrawal fee (%).
+			withdrawal_fee: Permill,
+		},
+		/// Assets have been converted from one to another. Both `SwapExactTokenForToken`
+		/// and `SwapTokenForExactToken` will generate this event.
+		SwapExecuted {
+			/// Which account was the instigator of the swap.
+			who: T::AccountId,
+			/// The account that the assets were transferred to.
+			send_to: T::AccountId,
+			/// The route of asset ids that the swap went through.
+			/// E.g. A -> Dot -> B
+			path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+			/// The amount of the first asset that was swapped.
+			amount_in: T::AssetBalance,
+			/// The amount of the second asset that was received.
+			amount_out: T::AssetBalance,
+		},
+		/// An amount has been transferred from one account to another.
+		Transfer {
+			/// The account that the assets were transferred from.
+			from: T::AccountId,
+			/// The account that the assets were transferred to.
+			to: T::AccountId,
+			/// The asset that was transferred.
+			asset: T::MultiAssetId,
+			/// The amount of the asset that was transferred.
+			amount: T::AssetBalance,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Provided assets are equal.
+		EqualAssets,
+		/// Provided asset is not supported for pool.
+		UnsupportedAsset,
+		/// Pool already exists.
+		PoolExists,
+		/// Desired amount can't be zero.
+		WrongDesiredAmount,
+		/// Provided amount should be greater than or equal to the existential deposit/asset's
+		/// minimal amount.
+		AmountOneLessThanMinimal,
+		/// Provided amount should be greater than or equal to the existential deposit/asset's
+		/// minimal amount.
+		AmountTwoLessThanMinimal,
+		/// Reserve needs to always be greater than or equal to the existential deposit/asset's
+		/// minimal amount.
+		ReserveLeftLessThanMinimal,
+		/// Desired amount can't be equal to the pool reserve.
+		AmountOutTooHigh,
+		/// The pool doesn't exist.
+		PoolNotFound,
+		/// An overflow happened.
+		Overflow,
+		/// The minimal amount requirement for the first token in the pair wasn't met.
+		AssetOneDepositDidNotMeetMinimum,
+		/// The minimal amount requirement for the second token in the pair wasn't met.
+		AssetTwoDepositDidNotMeetMinimum,
+		/// The minimal amount requirement for the first token in the pair wasn't met.
+		AssetOneWithdrawalDidNotMeetMinimum,
+		/// The minimal amount requirement for the second token in the pair wasn't met.
+		AssetTwoWithdrawalDidNotMeetMinimum,
+		/// Optimal calculated amount is less than desired.
+		OptimalAmountLessThanDesired,
+		/// Insufficient liquidity minted.
+		InsufficientLiquidityMinted,
+		/// Requested liquidity can't be zero.
+		ZeroLiquidity,
+		/// Amount can't be zero.
+		ZeroAmount,
+		/// Insufficient liquidity in the pool.
+		InsufficientLiquidity,
+		/// Calculated amount out is less than provided minimum amount.
+		ProvidedMinimumNotSufficientForSwap,
+		/// Provided maximum amount is not sufficient for swap.
+		ProvidedMaximumNotSufficientForSwap,
+		/// Only pools with native on one side are valid.
+		PoolMustContainNativeCurrency,
+		/// The provided path must consists of 2 assets at least.
+		InvalidPath,
+		/// It was not possible to calculate path data.
+		PathError,
+		/// The provided path must consists of unique assets.
+		NonUniquePath,
+		/// It was not possible to get or increment the Id of the pool.
+		IncorrectPoolAssetId,
+		/// Unable to find an element in an array/vec that should have one-to-one correspondence
+		/// with another. For example, an array of assets constituting a `path` should have a
+		/// corresponding array of `amounts` along the path.
+		CorrespondenceError,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn integrity_test() {
+			assert!(
+				T::MaxSwapPathLength::get() > 1,
+				"the `MaxSwapPathLength` should be greater than 1",
+			);
+		}
+	}
+
+	/// Pallet's callable functions.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Creates an empty liquidity pool and an associated new `lp_token` asset
+		/// (the id of which is returned in the `Event::PoolCreated` event).
+		///
+		/// Once a pool is created, someone may [`Pallet::add_liquidity`] to it.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::create_pool())]
+		pub fn create_pool(
+			origin: OriginFor<T>,
+			asset1: T::MultiAssetId,
+			asset2: T::MultiAssetId,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			ensure!(asset1 != asset2, Error::<T>::EqualAssets);
+
+			// prepare pool_id
+			let pool_id = Self::get_pool_id(asset1, asset2);
+			ensure!(!Pools::<T>::contains_key(&pool_id), Error::<T>::PoolExists);
+			let (asset1, asset2) = &pool_id;
+			if !T::AllowMultiAssetPools::get() && !T::MultiAssetIdConverter::is_native(asset1) {
+				Err(Error::<T>::PoolMustContainNativeCurrency)?;
+			}
+
+			let pool_account = Self::get_pool_account(&pool_id);
+			frame_system::Pallet::<T>::inc_providers(&pool_account);
+
+			// pay the setup fee
+			T::Currency::transfer(
+				&sender,
+				&T::PoolSetupFeeReceiver::get(),
+				T::PoolSetupFee::get(),
+				Preserve,
+			)?;
+
+			// try to convert both assets
+			match T::MultiAssetIdConverter::try_convert(asset1) {
+				MultiAssetIdConversionResult::Converted(asset) =>
+					if !T::Assets::contains(&asset, &pool_account) {
+						T::Assets::touch(asset, pool_account.clone(), sender.clone())?
+					},
+				MultiAssetIdConversionResult::Unsupported(_) => Err(Error::<T>::UnsupportedAsset)?,
+				MultiAssetIdConversionResult::Native => (),
+			}
+			match T::MultiAssetIdConverter::try_convert(asset2) {
+				MultiAssetIdConversionResult::Converted(asset) =>
+					if !T::Assets::contains(&asset, &pool_account) {
+						T::Assets::touch(asset, pool_account.clone(), sender.clone())?
+					},
+				MultiAssetIdConversionResult::Unsupported(_) => Err(Error::<T>::UnsupportedAsset)?,
+				MultiAssetIdConversionResult::Native => (),
+			}
+
+			let lp_token = NextPoolAssetId::<T>::get()
+				.or(T::PoolAssetId::initial_value())
+				.ok_or(Error::<T>::IncorrectPoolAssetId)?;
+			let next_lp_token_id = lp_token.increment().ok_or(Error::<T>::IncorrectPoolAssetId)?;
+			NextPoolAssetId::<T>::set(Some(next_lp_token_id));
+
+			T::PoolAssets::create(lp_token.clone(), pool_account.clone(), false, 1u32.into())?;
+			T::PoolAssets::touch(lp_token.clone(), pool_account.clone(), sender.clone())?;
+
+			let pool_info = PoolInfo { lp_token: lp_token.clone() };
+			Pools::<T>::insert(pool_id.clone(), pool_info);
+
+			Self::deposit_event(Event::PoolCreated {
+				creator: sender,
+				pool_id,
+				pool_account,
+				lp_token,
+			});
+
+			Ok(())
+		}
+
+		/// Provide liquidity into the pool of `asset1` and `asset2`.
+		/// NOTE: an optimal amount of asset1 and asset2 will be calculated and
+		/// might be different than the provided `amount1_desired`/`amount2_desired`
+		/// thus you should provide the min amount you're happy to provide.
+		/// Params `amount1_min`/`amount2_min` represent that.
+		/// `mint_to` will be sent the liquidity tokens that represent this share of the pool.
+		///
+		/// Once liquidity is added, someone may successfully call
+		/// [`Pallet::swap_exact_tokens_for_tokens`] successfully.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::add_liquidity())]
+		pub fn add_liquidity(
+			origin: OriginFor<T>,
+			asset1: T::MultiAssetId,
+			asset2: T::MultiAssetId,
+			amount1_desired: T::AssetBalance,
+			amount2_desired: T::AssetBalance,
+			amount1_min: T::AssetBalance,
+			amount2_min: T::AssetBalance,
+			mint_to: T::AccountId,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+			// swap params if needed
+			let (amount1_desired, amount2_desired, amount1_min, amount2_min) =
+				if pool_id.0 == asset1 {
+					(amount1_desired, amount2_desired, amount1_min, amount2_min)
+				} else {
+					(amount2_desired, amount1_desired, amount2_min, amount1_min)
+				};
+			ensure!(
+				amount1_desired > Zero::zero() && amount2_desired > Zero::zero(),
+				Error::<T>::WrongDesiredAmount
+			);
+
+			let maybe_pool = Pools::<T>::get(&pool_id);
+			let pool = maybe_pool.as_ref().ok_or(Error::<T>::PoolNotFound)?;
+			let pool_account = Self::get_pool_account(&pool_id);
+
+			let (asset1, asset2) = &pool_id;
+			let reserve1 = Self::get_balance(&pool_account, asset1)?;
+			let reserve2 = Self::get_balance(&pool_account, asset2)?;
+
+			let amount1: T::AssetBalance;
+			let amount2: T::AssetBalance;
+			if reserve1.is_zero() || reserve2.is_zero() {
+				amount1 = amount1_desired;
+				amount2 = amount2_desired;
+			} else {
+				let amount2_optimal = Self::quote(&amount1_desired, &reserve1, &reserve2)?;
+
+				if amount2_optimal <= amount2_desired {
+					ensure!(
+						amount2_optimal >= amount2_min,
+						Error::<T>::AssetTwoDepositDidNotMeetMinimum
+					);
+					amount1 = amount1_desired;
+					amount2 = amount2_optimal;
+				} else {
+					let amount1_optimal = Self::quote(&amount2_desired, &reserve2, &reserve1)?;
+					ensure!(
+						amount1_optimal <= amount1_desired,
+						Error::<T>::OptimalAmountLessThanDesired
+					);
+					ensure!(
+						amount1_optimal >= amount1_min,
+						Error::<T>::AssetOneDepositDidNotMeetMinimum
+					);
+					amount1 = amount1_optimal;
+					amount2 = amount2_desired;
+				}
+			}
+
+			Self::validate_minimal_amount(amount1.saturating_add(reserve1), asset1)
+				.map_err(|_| Error::<T>::AmountOneLessThanMinimal)?;
+			Self::validate_minimal_amount(amount2.saturating_add(reserve2), asset2)
+				.map_err(|_| Error::<T>::AmountTwoLessThanMinimal)?;
+
+			Self::transfer(asset1, &sender, &pool_account, amount1, true)?;
+			Self::transfer(asset2, &sender, &pool_account, amount2, true)?;
+
+			let total_supply = T::PoolAssets::total_issuance(pool.lp_token.clone());
+
+			let lp_token_amount: T::AssetBalance;
+			if total_supply.is_zero() {
+				lp_token_amount = Self::calc_lp_amount_for_zero_supply(&amount1, &amount2)?;
+				T::PoolAssets::mint_into(
+					pool.lp_token.clone(),
+					&pool_account,
+					T::MintMinLiquidity::get(),
+				)?;
+			} else {
+				let side1 = Self::mul_div(&amount1, &total_supply, &reserve1)?;
+				let side2 = Self::mul_div(&amount2, &total_supply, &reserve2)?;
+				lp_token_amount = side1.min(side2);
+			}
+
+			ensure!(
+				lp_token_amount > T::MintMinLiquidity::get(),
+				Error::<T>::InsufficientLiquidityMinted
+			);
+
+			T::PoolAssets::mint_into(pool.lp_token.clone(), &mint_to, lp_token_amount)?;
+
+			Self::deposit_event(Event::LiquidityAdded {
+				who: sender,
+				mint_to,
+				pool_id,
+				amount1_provided: amount1,
+				amount2_provided: amount2,
+				lp_token: pool.lp_token.clone(),
+				lp_token_minted: lp_token_amount,
+			});
+
+			Ok(())
+		}
+
+		/// Allows you to remove liquidity by providing the `lp_token_burn` tokens that will be
+		/// burned in the process. With the usage of `amount1_min_receive`/`amount2_min_receive`
+		/// it's possible to control the min amount of returned tokens you're happy with.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::remove_liquidity())]
+		pub fn remove_liquidity(
+			origin: OriginFor<T>,
+			asset1: T::MultiAssetId,
+			asset2: T::MultiAssetId,
+			lp_token_burn: T::AssetBalance,
+			amount1_min_receive: T::AssetBalance,
+			amount2_min_receive: T::AssetBalance,
+			withdraw_to: T::AccountId,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+			// swap params if needed
+			let (amount1_min_receive, amount2_min_receive) = if pool_id.0 == asset1 {
+				(amount1_min_receive, amount2_min_receive)
+			} else {
+				(amount2_min_receive, amount1_min_receive)
+			};
+			let (asset1, asset2) = pool_id.clone();
+
+			ensure!(lp_token_burn > Zero::zero(), Error::<T>::ZeroLiquidity);
+
+			let maybe_pool = Pools::<T>::get(&pool_id);
+			let pool = maybe_pool.as_ref().ok_or(Error::<T>::PoolNotFound)?;
+
+			let pool_account = Self::get_pool_account(&pool_id);
+			let reserve1 = Self::get_balance(&pool_account, &asset1)?;
+			let reserve2 = Self::get_balance(&pool_account, &asset2)?;
+
+			let total_supply = T::PoolAssets::total_issuance(pool.lp_token.clone());
+			let withdrawal_fee_amount = T::LiquidityWithdrawalFee::get() * lp_token_burn;
+			let lp_redeem_amount = lp_token_burn.saturating_sub(withdrawal_fee_amount);
+
+			let amount1 = Self::mul_div(&lp_redeem_amount, &reserve1, &total_supply)?;
+			let amount2 = Self::mul_div(&lp_redeem_amount, &reserve2, &total_supply)?;
+
+			ensure!(
+				!amount1.is_zero() && amount1 >= amount1_min_receive,
+				Error::<T>::AssetOneWithdrawalDidNotMeetMinimum
+			);
+			ensure!(
+				!amount2.is_zero() && amount2 >= amount2_min_receive,
+				Error::<T>::AssetTwoWithdrawalDidNotMeetMinimum
+			);
+			let reserve1_left = reserve1.saturating_sub(amount1);
+			let reserve2_left = reserve2.saturating_sub(amount2);
+			Self::validate_minimal_amount(reserve1_left, &asset1)
+				.map_err(|_| Error::<T>::ReserveLeftLessThanMinimal)?;
+			Self::validate_minimal_amount(reserve2_left, &asset2)
+				.map_err(|_| Error::<T>::ReserveLeftLessThanMinimal)?;
+
+			// burn the provided lp token amount that includes the fee
+			T::PoolAssets::burn_from(pool.lp_token.clone(), &sender, lp_token_burn, Exact, Polite)?;
+
+			Self::transfer(&asset1, &pool_account, &withdraw_to, amount1, false)?;
+			Self::transfer(&asset2, &pool_account, &withdraw_to, amount2, false)?;
+
+			Self::deposit_event(Event::LiquidityRemoved {
+				who: sender,
+				withdraw_to,
+				pool_id,
+				amount1,
+				amount2,
+				lp_token: pool.lp_token.clone(),
+				lp_token_burned: lp_token_burn,
+				withdrawal_fee: T::LiquidityWithdrawalFee::get(),
+			});
+
+			Ok(())
+		}
+
+		/// Swap the exact amount of `asset1` into `asset2`.
+		/// `amount_out_min` param allows you to specify the min amount of the `asset2`
+		/// you're happy to receive.
+		///
+		/// [`AssetConversionApi::quote_price_exact_tokens_for_tokens`] runtime call can be called
+		/// for a quote.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::swap_exact_tokens_for_tokens())]
+		pub fn swap_exact_tokens_for_tokens(
+			origin: OriginFor<T>,
+			path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+			amount_in: T::AssetBalance,
+			amount_out_min: T::AssetBalance,
+			send_to: T::AccountId,
+			keep_alive: bool,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			Self::do_swap_exact_tokens_for_tokens(
+				sender,
+				path,
+				amount_in,
+				Some(amount_out_min),
+				send_to,
+				keep_alive,
+			)?;
+			Ok(())
+		}
+
+		/// Swap any amount of `asset1` to get the exact amount of `asset2`.
+		/// `amount_in_max` param allows to specify the max amount of the `asset1`
+		/// you're happy to provide.
+		///
+		/// [`AssetConversionApi::quote_price_tokens_for_exact_tokens`] runtime call can be called
+		/// for a quote.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::swap_tokens_for_exact_tokens())]
+		pub fn swap_tokens_for_exact_tokens(
+			origin: OriginFor<T>,
+			path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+			amount_out: T::AssetBalance,
+			amount_in_max: T::AssetBalance,
+			send_to: T::AccountId,
+			keep_alive: bool,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			Self::do_swap_tokens_for_exact_tokens(
+				sender,
+				path,
+				amount_out,
+				Some(amount_in_max),
+				send_to,
+				keep_alive,
+			)?;
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// Swap exactly `amount_in` of asset `path[0]` for asset `path[1]`.
+		/// If an `amount_out_min` is specified, it will return an error if it is unable to acquire
+		/// the amount desired.
+		///
+		/// Withdraws the `path[0]` asset from `sender`, deposits the `path[1]` asset to `send_to`,
+		/// respecting `keep_alive`.
+		///
+		/// If successful, returns the amount of `path[1]` acquired for the `amount_in`.
+		pub fn do_swap_exact_tokens_for_tokens(
+			sender: T::AccountId,
+			path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+			amount_in: T::AssetBalance,
+			amount_out_min: Option<T::AssetBalance>,
+			send_to: T::AccountId,
+			keep_alive: bool,
+		) -> Result<T::AssetBalance, DispatchError> {
+			ensure!(amount_in > Zero::zero(), Error::<T>::ZeroAmount);
+			if let Some(amount_out_min) = amount_out_min {
+				ensure!(amount_out_min > Zero::zero(), Error::<T>::ZeroAmount);
+			}
+
+			Self::validate_swap_path(&path)?;
+
+			let amounts = Self::get_amounts_out(&amount_in, &path)?;
+			let amount_out =
+				*amounts.last().defensive_ok_or("get_amounts_out() returned an empty result")?;
+
+			if let Some(amount_out_min) = amount_out_min {
+				ensure!(
+					amount_out >= amount_out_min,
+					Error::<T>::ProvidedMinimumNotSufficientForSwap
+				);
+			}
+
+			Self::do_swap(sender, &amounts, path, send_to, keep_alive)?;
+			Ok(amount_out)
+		}
+
+		/// Take the `path[0]` asset and swap some amount for `amount_out` of the `path[1]`. If an
+		/// `amount_in_max` is specified, it will return an error if acquiring `amount_out` would be
+		/// too costly.
+		///
+		/// Withdraws `path[0]` asset from `sender`, deposits the `path[1]` asset to `send_to`,
+		/// respecting `keep_alive`.
+		///
+		/// If successful returns the amount of the `path[0]` taken to provide `path[1]`.
+		pub fn do_swap_tokens_for_exact_tokens(
+			sender: T::AccountId,
+			path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+			amount_out: T::AssetBalance,
+			amount_in_max: Option<T::AssetBalance>,
+			send_to: T::AccountId,
+			keep_alive: bool,
+		) -> Result<T::AssetBalance, DispatchError> {
+			ensure!(amount_out > Zero::zero(), Error::<T>::ZeroAmount);
+			if let Some(amount_in_max) = amount_in_max {
+				ensure!(amount_in_max > Zero::zero(), Error::<T>::ZeroAmount);
+			}
+
+			Self::validate_swap_path(&path)?;
+
+			let amounts = Self::get_amounts_in(&amount_out, &path)?;
+			let amount_in =
+				*amounts.first().defensive_ok_or("get_amounts_in() returned an empty result")?;
+
+			if let Some(amount_in_max) = amount_in_max {
+				ensure!(
+					amount_in <= amount_in_max,
+					Error::<T>::ProvidedMaximumNotSufficientForSwap
+				);
+			}
+
+			Self::do_swap(sender, &amounts, path, send_to, keep_alive)?;
+			Ok(amount_in)
+		}
+
+		/// Transfer an `amount` of `asset_id`, respecting the `keep_alive` requirements.
+		fn transfer(
+			asset_id: &T::MultiAssetId,
+			from: &T::AccountId,
+			to: &T::AccountId,
+			amount: T::AssetBalance,
+			keep_alive: bool,
+		) -> Result<T::AssetBalance, DispatchError> {
+			let result = match T::MultiAssetIdConverter::try_convert(asset_id) {
+				MultiAssetIdConversionResult::Converted(asset_id) =>
+					T::Assets::transfer(asset_id, from, to, amount, Expendable),
+				MultiAssetIdConversionResult::Native => {
+					let preservation = match keep_alive {
+						true => Preserve,
+						false => Expendable,
+					};
+					let amount = Self::convert_asset_balance_to_native_balance(amount)?;
+					Ok(Self::convert_native_balance_to_asset_balance(T::Currency::transfer(
+						from,
+						to,
+						amount,
+						preservation,
+					)?)?)
+				},
+				MultiAssetIdConversionResult::Unsupported(_) =>
+					Err(Error::<T>::UnsupportedAsset.into()),
+			};
+
+			if result.is_ok() {
+				Self::deposit_event(Event::Transfer {
+					from: from.clone(),
+					to: to.clone(),
+					asset: (*asset_id).clone(),
+					amount,
+				});
+			}
+			result
+		}
+
+		/// Convert a `Balance` type to an `AssetBalance`.
+		pub(crate) fn convert_native_balance_to_asset_balance(
+			amount: T::Balance,
+		) -> Result<T::AssetBalance, Error<T>> {
+			T::HigherPrecisionBalance::from(amount)
+				.try_into()
+				.map_err(|_| Error::<T>::Overflow)
+		}
+
+		/// Convert an `AssetBalance` type to a `Balance`.
+		pub(crate) fn convert_asset_balance_to_native_balance(
+			amount: T::AssetBalance,
+		) -> Result<T::Balance, Error<T>> {
+			T::HigherPrecisionBalance::from(amount)
+				.try_into()
+				.map_err(|_| Error::<T>::Overflow)
+		}
+
+		/// Convert a `HigherPrecisionBalance` type to an `AssetBalance`.
+		pub(crate) fn convert_hpb_to_asset_balance(
+			amount: T::HigherPrecisionBalance,
+		) -> Result<T::AssetBalance, Error<T>> {
+			amount.try_into().map_err(|_| Error::<T>::Overflow)
+		}
+
+		/// Swap assets along a `path`, depositing in `send_to`.
+		pub(crate) fn do_swap(
+			sender: T::AccountId,
+			amounts: &Vec<T::AssetBalance>,
+			path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+			send_to: T::AccountId,
+			keep_alive: bool,
+		) -> Result<(), DispatchError> {
+			ensure!(amounts.len() > 1, Error::<T>::CorrespondenceError);
+			if let Some([asset1, asset2]) = &path.get(0..2) {
+				let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+				let pool_account = Self::get_pool_account(&pool_id);
+				// amounts should always contain a corresponding element to path.
+				let first_amount = amounts.first().ok_or(Error::<T>::CorrespondenceError)?;
+
+				Self::transfer(asset1, &sender, &pool_account, *first_amount, keep_alive)?;
+
+				let mut i = 0;
+				let path_len = path.len() as u32;
+				for assets_pair in path.windows(2) {
+					if let [asset1, asset2] = assets_pair {
+						let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+						let pool_account = Self::get_pool_account(&pool_id);
+
+						let amount_out =
+							amounts.get((i + 1) as usize).ok_or(Error::<T>::CorrespondenceError)?;
+
+						let to = if i < path_len - 2 {
+							let asset3 = path.get((i + 2) as usize).ok_or(Error::<T>::PathError)?;
+							Self::get_pool_account(&Self::get_pool_id(
+								asset2.clone(),
+								asset3.clone(),
+							))
+						} else {
+							send_to.clone()
+						};
+
+						let reserve = Self::get_balance(&pool_account, asset2)?;
+						let reserve_left = reserve.saturating_sub(*amount_out);
+						Self::validate_minimal_amount(reserve_left, asset2)
+							.map_err(|_| Error::<T>::ReserveLeftLessThanMinimal)?;
+
+						Self::transfer(asset2, &pool_account, &to, *amount_out, true)?;
+					}
+					i.saturating_inc();
+				}
+				Self::deposit_event(Event::SwapExecuted {
+					who: sender,
+					send_to,
+					path,
+					amount_in: *first_amount,
+					amount_out: *amounts.last().expect("Always has more than 1 element"),
+				});
+			} else {
+				return Err(Error::<T>::InvalidPath.into())
+			}
+			Ok(())
+		}
+
+		/// The account ID of the pool.
+		///
+		/// This actually does computation. If you need to keep using it, then make sure you cache
+		/// the value and only call this once.
+		pub fn get_pool_account(pool_id: &PoolIdOf<T>) -> T::AccountId {
+			let encoded_pool_id = sp_io::hashing::blake2_256(&Encode::encode(pool_id)[..]);
+
+			Decode::decode(&mut TrailingZeroInput::new(encoded_pool_id.as_ref()))
+				.expect("infinite length input; no invalid inputs for type; qed")
+		}
+
+		/// Get the `owner`'s balance of `asset`, which could be the chain's native asset or another
+		/// fungible. Returns a value in the form of an `AssetBalance`.
+		fn get_balance(
+			owner: &T::AccountId,
+			asset: &T::MultiAssetId,
+		) -> Result<T::AssetBalance, Error<T>> {
+			match T::MultiAssetIdConverter::try_convert(asset) {
+				MultiAssetIdConversionResult::Converted(asset_id) => Ok(
+					<<T as Config>::Assets>::reducible_balance(asset_id, owner, Expendable, Polite),
+				),
+				MultiAssetIdConversionResult::Native =>
+					Self::convert_native_balance_to_asset_balance(
+						<<T as Config>::Currency>::reducible_balance(owner, Expendable, Polite),
+					),
+				MultiAssetIdConversionResult::Unsupported(_) =>
+					Err(Error::<T>::UnsupportedAsset.into()),
+			}
+		}
+
+		/// Returns a pool id constructed from 2 assets.
+		/// 1. Native asset should be lower than the other asset ids.
+		/// 2. Two native or two non-native assets are compared by their `Ord` implementation.
+		///
+		/// We expect deterministic order, so (asset1, asset2) or (asset2, asset1) returns the same
+		/// result.
+		pub fn get_pool_id(asset1: T::MultiAssetId, asset2: T::MultiAssetId) -> PoolIdOf<T> {
+			match (
+				T::MultiAssetIdConverter::is_native(&asset1),
+				T::MultiAssetIdConverter::is_native(&asset2),
+			) {
+				(true, false) => return (asset1, asset2),
+				(false, true) => return (asset2, asset1),
+				_ => {
+					// else we want to be deterministic based on `Ord` implementation
+					if asset1 <= asset2 {
+						(asset1, asset2)
+					} else {
+						(asset2, asset1)
+					}
+				},
+			}
+		}
+
+		/// Returns the balance of each asset in the pool.
+		/// The tuple result is in the order requested (not necessarily the same as pool order).
+		pub fn get_reserves(
+			asset1: &T::MultiAssetId,
+			asset2: &T::MultiAssetId,
+		) -> Result<(T::AssetBalance, T::AssetBalance), Error<T>> {
+			let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+			let pool_account = Self::get_pool_account(&pool_id);
+
+			let balance1 = Self::get_balance(&pool_account, asset1)?;
+			let balance2 = Self::get_balance(&pool_account, asset2)?;
+
+			if balance1.is_zero() || balance2.is_zero() {
+				Err(Error::<T>::PoolNotFound)?;
+			}
+
+			Ok((balance1, balance2))
+		}
+
+		/// Leading to an amount at the end of a `path`, get the required amounts in.
+		pub(crate) fn get_amounts_in(
+			amount_out: &T::AssetBalance,
+			path: &BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+		) -> Result<Vec<T::AssetBalance>, DispatchError> {
+			let mut amounts: Vec<T::AssetBalance> = vec![*amount_out];
+
+			for assets_pair in path.windows(2).rev() {
+				if let [asset1, asset2] = assets_pair {
+					let (reserve_in, reserve_out) = Self::get_reserves(asset1, asset2)?;
+					let prev_amount = amounts.last().expect("Always has at least one element");
+					let amount_in = Self::get_amount_in(prev_amount, &reserve_in, &reserve_out)?;
+					amounts.push(amount_in);
+				}
+			}
+
+			amounts.reverse();
+			Ok(amounts)
+		}
+
+		/// Following an amount into a `path`, get the corresponding amounts out.
+		pub(crate) fn get_amounts_out(
+			amount_in: &T::AssetBalance,
+			path: &BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+		) -> Result<Vec<T::AssetBalance>, DispatchError> {
+			let mut amounts: Vec<T::AssetBalance> = vec![*amount_in];
+
+			for assets_pair in path.windows(2) {
+				if let [asset1, asset2] = assets_pair {
+					let (reserve_in, reserve_out) = Self::get_reserves(asset1, asset2)?;
+					let prev_amount = amounts.last().expect("Always has at least one element");
+					let amount_out = Self::get_amount_out(prev_amount, &reserve_in, &reserve_out)?;
+					amounts.push(amount_out);
+				}
+			}
+
+			Ok(amounts)
+		}
+
+		/// Used by the RPC service to provide current prices.
+		pub fn quote_price_exact_tokens_for_tokens(
+			asset1: T::MultiAssetId,
+			asset2: T::MultiAssetId,
+			amount: T::AssetBalance,
+			include_fee: bool,
+		) -> Option<T::AssetBalance> {
+			let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+			let pool_account = Self::get_pool_account(&pool_id);
+
+			let balance1 = Self::get_balance(&pool_account, &asset1).ok()?;
+			let balance2 = Self::get_balance(&pool_account, &asset2).ok()?;
+			if !balance1.is_zero() {
+				if include_fee {
+					Self::get_amount_out(&amount, &balance1, &balance2).ok()
+				} else {
+					Self::quote(&amount, &balance1, &balance2).ok()
+				}
+			} else {
+				None
+			}
+		}
+
+		/// Used by the RPC service to provide current prices.
+		pub fn quote_price_tokens_for_exact_tokens(
+			asset1: T::MultiAssetId,
+			asset2: T::MultiAssetId,
+			amount: T::AssetBalance,
+			include_fee: bool,
+		) -> Option<T::AssetBalance> {
+			let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+			let pool_account = Self::get_pool_account(&pool_id);
+
+			let balance1 = Self::get_balance(&pool_account, &asset1).ok()?;
+			let balance2 = Self::get_balance(&pool_account, &asset2).ok()?;
+			if !balance1.is_zero() {
+				if include_fee {
+					Self::get_amount_in(&amount, &balance1, &balance2).ok()
+				} else {
+					Self::quote(&amount, &balance2, &balance1).ok()
+				}
+			} else {
+				None
+			}
+		}
+
+		/// Calculates the optimal amount from the reserves.
+		pub fn quote(
+			amount: &T::AssetBalance,
+			reserve1: &T::AssetBalance,
+			reserve2: &T::AssetBalance,
+		) -> Result<T::AssetBalance, Error<T>> {
+			// amount * reserve2 / reserve1
+			Self::mul_div(amount, reserve2, reserve1)
+		}
+
+		pub(super) fn calc_lp_amount_for_zero_supply(
+			amount1: &T::AssetBalance,
+			amount2: &T::AssetBalance,
+		) -> Result<T::AssetBalance, Error<T>> {
+			let amount1 = T::HigherPrecisionBalance::from(*amount1);
+			let amount2 = T::HigherPrecisionBalance::from(*amount2);
+
+			let result = amount1
+				.checked_mul(&amount2)
+				.ok_or(Error::<T>::Overflow)?
+				.integer_sqrt()
+				.checked_sub(&T::MintMinLiquidity::get().into())
+				.ok_or(Error::<T>::InsufficientLiquidityMinted)?;
+
+			result.try_into().map_err(|_| Error::<T>::Overflow)
+		}
+
+		fn mul_div(
+			a: &T::AssetBalance,
+			b: &T::AssetBalance,
+			c: &T::AssetBalance,
+		) -> Result<T::AssetBalance, Error<T>> {
+			let a = T::HigherPrecisionBalance::from(*a);
+			let b = T::HigherPrecisionBalance::from(*b);
+			let c = T::HigherPrecisionBalance::from(*c);
+
+			let result = a
+				.checked_mul(&b)
+				.ok_or(Error::<T>::Overflow)?
+				.checked_div(&c)
+				.ok_or(Error::<T>::Overflow)?;
+
+			result.try_into().map_err(|_| Error::<T>::Overflow)
+		}
+
+		/// Calculates amount out.
+		///
+		/// Given an input amount of an asset and pair reserves, returns the maximum output amount
+		/// of the other asset.
+		pub fn get_amount_out(
+			amount_in: &T::AssetBalance,
+			reserve_in: &T::AssetBalance,
+			reserve_out: &T::AssetBalance,
+		) -> Result<T::AssetBalance, Error<T>> {
+			let amount_in = T::HigherPrecisionBalance::from(*amount_in);
+			let reserve_in = T::HigherPrecisionBalance::from(*reserve_in);
+			let reserve_out = T::HigherPrecisionBalance::from(*reserve_out);
+
+			if reserve_in.is_zero() || reserve_out.is_zero() {
+				return Err(Error::<T>::ZeroLiquidity.into())
+			}
+
+			let amount_in_with_fee = amount_in
+				.checked_mul(&(T::HigherPrecisionBalance::from(1000u32) - (T::LPFee::get().into())))
+				.ok_or(Error::<T>::Overflow)?;
+
+			let numerator =
+				amount_in_with_fee.checked_mul(&reserve_out).ok_or(Error::<T>::Overflow)?;
+
+			let denominator = reserve_in
+				.checked_mul(&1000u32.into())
+				.ok_or(Error::<T>::Overflow)?
+				.checked_add(&amount_in_with_fee)
+				.ok_or(Error::<T>::Overflow)?;
+
+			let result = numerator.checked_div(&denominator).ok_or(Error::<T>::Overflow)?;
+
+			result.try_into().map_err(|_| Error::<T>::Overflow)
+		}
+
+		/// Calculates amount in.
+		///
+		/// Given an output amount of an asset and pair reserves, returns a required input amount
+		/// of the other asset.
+		pub fn get_amount_in(
+			amount_out: &T::AssetBalance,
+			reserve_in: &T::AssetBalance,
+			reserve_out: &T::AssetBalance,
+		) -> Result<T::AssetBalance, Error<T>> {
+			let amount_out = T::HigherPrecisionBalance::from(*amount_out);
+			let reserve_in = T::HigherPrecisionBalance::from(*reserve_in);
+			let reserve_out = T::HigherPrecisionBalance::from(*reserve_out);
+
+			if reserve_in.is_zero() || reserve_out.is_zero() {
+				Err(Error::<T>::ZeroLiquidity.into())?
+			}
+
+			if amount_out >= reserve_out {
+				Err(Error::<T>::AmountOutTooHigh.into())?
+			}
+
+			let numerator = reserve_in
+				.checked_mul(&amount_out)
+				.ok_or(Error::<T>::Overflow)?
+				.checked_mul(&1000u32.into())
+				.ok_or(Error::<T>::Overflow)?;
+
+			let denominator = reserve_out
+				.checked_sub(&amount_out)
+				.ok_or(Error::<T>::Overflow)?
+				.checked_mul(&(T::HigherPrecisionBalance::from(1000u32) - T::LPFee::get().into()))
+				.ok_or(Error::<T>::Overflow)?;
+
+			let result = numerator
+				.checked_div(&denominator)
+				.ok_or(Error::<T>::Overflow)?
+				.checked_add(&One::one())
+				.ok_or(Error::<T>::Overflow)?;
+
+			result.try_into().map_err(|_| Error::<T>::Overflow)
+		}
+
+		/// Ensure that a `value` meets the minimum balance requirements of an `asset` class.
+		fn validate_minimal_amount(
+			value: T::AssetBalance,
+			asset: &T::MultiAssetId,
+		) -> Result<(), ()> {
+			if T::MultiAssetIdConverter::is_native(asset) {
+				let ed = T::Currency::minimum_balance();
+				ensure!(
+					T::HigherPrecisionBalance::from(value) >= T::HigherPrecisionBalance::from(ed),
+					()
+				);
+			} else {
+				let MultiAssetIdConversionResult::Converted(asset_id) =
+					T::MultiAssetIdConverter::try_convert(asset)
+				else {
+					return Err(())
+				};
+				let minimal = T::Assets::minimum_balance(asset_id);
+				ensure!(value >= minimal, ());
+			}
+			Ok(())
+		}
+
+		/// Ensure that a path is valid.
+		fn validate_swap_path(
+			path: &BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>,
+		) -> Result<(), DispatchError> {
+			ensure!(path.len() >= 2, Error::<T>::InvalidPath);
+
+			// validate all the pools in the path are unique
+			let mut pools = BoundedBTreeSet::<PoolIdOf<T>, T::MaxSwapPathLength>::new();
+			for assets_pair in path.windows(2) {
+				if let [asset1, asset2] = assets_pair {
+					let pool_id = Self::get_pool_id(asset1.clone(), asset2.clone());
+					let new_element =
+						pools.try_insert(pool_id).map_err(|_| Error::<T>::Overflow)?;
+					if !new_element {
+						return Err(Error::<T>::NonUniquePath.into())
+					}
+				}
+			}
+			Ok(())
+		}
+
+		/// Returns the next pool asset id for benchmark purposes only.
+		#[cfg(any(test, feature = "runtime-benchmarks"))]
+		pub fn get_next_pool_asset_id() -> T::PoolAssetId {
+			NextPoolAssetId::<T>::get()
+				.or(T::PoolAssetId::initial_value())
+				.expect("Next pool asset ID can not be None")
+		}
+	}
+}
+
+impl<T: Config> Swap<T::AccountId, T::HigherPrecisionBalance, T::MultiAssetId> for Pallet<T> {
+	fn swap_exact_tokens_for_tokens(
+		sender: T::AccountId,
+		path: Vec<T::MultiAssetId>,
+		amount_in: T::HigherPrecisionBalance,
+		amount_out_min: Option<T::HigherPrecisionBalance>,
+		send_to: T::AccountId,
+		keep_alive: bool,
+	) -> Result<T::HigherPrecisionBalance, DispatchError> {
+		let path = path.try_into().map_err(|_| Error::<T>::PathError)?;
+		let amount_out_min = amount_out_min.map(Self::convert_hpb_to_asset_balance).transpose()?;
+		let amount_out = Self::do_swap_exact_tokens_for_tokens(
+			sender,
+			path,
+			Self::convert_hpb_to_asset_balance(amount_in)?,
+			amount_out_min,
+			send_to,
+			keep_alive,
+		)?;
+		Ok(amount_out.into())
+	}
+
+	fn swap_tokens_for_exact_tokens(
+		sender: T::AccountId,
+		path: Vec<T::MultiAssetId>,
+		amount_out: T::HigherPrecisionBalance,
+		amount_in_max: Option<T::HigherPrecisionBalance>,
+		send_to: T::AccountId,
+		keep_alive: bool,
+	) -> Result<T::HigherPrecisionBalance, DispatchError> {
+		let path = path.try_into().map_err(|_| Error::<T>::PathError)?;
+		let amount_in_max = amount_in_max.map(Self::convert_hpb_to_asset_balance).transpose()?;
+		let amount_in = Self::do_swap_tokens_for_exact_tokens(
+			sender,
+			path,
+			Self::convert_hpb_to_asset_balance(amount_out)?,
+			amount_in_max,
+			send_to,
+			keep_alive,
+		)?;
+		Ok(amount_in.into())
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// This runtime api allows people to query the size of the liquidity pools
+	/// and quote prices for swaps.
+	pub trait AssetConversionApi<Balance, AssetBalance, AssetId> where
+		Balance: Codec + MaybeDisplay,
+		AssetBalance: frame_support::traits::tokens::Balance,
+		AssetId: Codec
+	{
+		/// Provides a quote for [`Pallet::swap_tokens_for_exact_tokens`].
+		///
+		/// Note that the price may have changed by the time the transaction is executed.
+		/// (Use `amount_in_max` to control slippage.)
+		fn quote_price_tokens_for_exact_tokens(asset1: AssetId, asset2: AssetId, amount: AssetBalance, include_fee: bool) -> Option<Balance>;
+
+		/// Provides a quote for [`Pallet::swap_exact_tokens_for_tokens`].
+		///
+		/// Note that the price may have changed by the time the transaction is executed.
+		/// (Use `amount_out_min` to control slippage.)
+		fn quote_price_exact_tokens_for_tokens(asset1: AssetId, asset2: AssetId, amount: AssetBalance, include_fee: bool) -> Option<Balance>;
+
+		/// Returns the size of the liquidity pool for the given asset pair.
+		fn get_reserves(asset1: AssetId, asset2: AssetId) -> Option<(Balance, Balance)>;
+	}
+}
+
+sp_core::generate_feature_enabled_macro!(runtime_benchmarks_enabled, feature = "runtime-benchmarks", $);
diff --git a/substrate/frame/asset-conversion/src/mock.rs b/substrate/frame/asset-conversion/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7fe81b814047d652f526168007a2fd136b50927a
--- /dev/null
+++ b/substrate/frame/asset-conversion/src/mock.rs
@@ -0,0 +1,192 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! Test environment for Asset Conversion pallet.
+
+use super::*;
+use crate as pallet_asset_conversion;
+
+use frame_support::{
+	construct_runtime,
+	instances::{Instance1, Instance2},
+	ord_parameter_types, parameter_types,
+	traits::{AsEnsureOriginWithArg, ConstU128, ConstU32, ConstU64},
+	PalletId,
+};
+use frame_system::{EnsureSigned, EnsureSignedBy};
+use sp_arithmetic::Permill;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{AccountIdConversion, BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Assets: pallet_assets::<Instance1>,
+		PoolAssets: pallet_assets::<Instance2>,
+		AssetConversion: pallet_asset_conversion,
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = u128;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u128>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+impl pallet_assets::Config<Instance1> for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u128;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<Self::AccountId>>;
+	type ForceOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type AssetDeposit = ConstU128<1>;
+	type AssetAccountDeposit = ConstU128<10>;
+	type MetadataDepositBase = ConstU128<1>;
+	type MetadataDepositPerByte = ConstU128<1>;
+	type ApprovalDeposit = ConstU128<1>;
+	type StringLimit = ConstU32<50>;
+	type Freezer = ();
+	type Extra = ();
+	type WeightInfo = ();
+	type CallbackHandle = ();
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+impl pallet_assets::Config<Instance2> for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u128;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type Currency = Balances;
+	type CreateOrigin =
+		AsEnsureOriginWithArg<EnsureSignedBy<AssetConversionOrigin, Self::AccountId>>;
+	type ForceOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type AssetDeposit = ConstU128<0>;
+	type AssetAccountDeposit = ConstU128<0>;
+	type MetadataDepositBase = ConstU128<0>;
+	type MetadataDepositPerByte = ConstU128<0>;
+	type ApprovalDeposit = ConstU128<0>;
+	type StringLimit = ConstU32<50>;
+	type Freezer = ();
+	type Extra = ();
+	type WeightInfo = ();
+	type CallbackHandle = ();
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+parameter_types! {
+	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
+	pub storage AllowMultiAssetPools: bool = true;
+	pub storage LiquidityWithdrawalFee: Permill = Permill::from_percent(0); // should be non-zero if AllowMultiAssetPools is true, otherwise can be zero
+}
+
+ord_parameter_types! {
+	pub const AssetConversionOrigin: u128 = AccountIdConversion::<u128>::into_account_truncating(&AssetConversionPalletId::get());
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type AssetBalance = <Self as pallet_balances::Config>::Balance;
+	type AssetId = u32;
+	type PoolAssetId = u32;
+	type Assets = Assets;
+	type PoolAssets = PoolAssets;
+	type PalletId = AssetConversionPalletId;
+	type WeightInfo = ();
+	type LPFee = ConstU32<3>; // means 0.3%
+	type PoolSetupFee = ConstU128<100>; // should be more or equal to the existential deposit
+	type PoolSetupFeeReceiver = AssetConversionOrigin;
+	type LiquidityWithdrawalFee = LiquidityWithdrawalFee;
+	type AllowMultiAssetPools = AllowMultiAssetPools;
+	type MaxSwapPathLength = ConstU32<4>;
+	type MintMinLiquidity = ConstU128<100>; // 100 is good enough when the main currency has 12 decimals.
+
+	type Balance = u128;
+	type HigherPrecisionBalance = sp_core::U256;
+
+	type MultiAssetId = NativeOrAssetId<u32>;
+	type MultiAssetIdConverter = NativeOrAssetIdConverter<u32>;
+
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10000), (2, 20000), (3, 30000), (4, 40000)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
diff --git a/substrate/frame/asset-conversion/src/tests.rs b/substrate/frame/asset-conversion/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..450a074ec36757a95e351862ac28c1ffd39cf335
--- /dev/null
+++ b/substrate/frame/asset-conversion/src/tests.rs
@@ -0,0 +1,1422 @@
+// 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.
+
+use crate::{mock::*, *};
+use frame_support::{
+	assert_noop, assert_ok,
+	instances::Instance1,
+	traits::{fungible::Inspect, fungibles::InspectEnumerable, Get},
+};
+use sp_arithmetic::Permill;
+use sp_runtime::{DispatchError, TokenError};
+
+fn events() -> Vec<Event<Test>> {
+	let result = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| {
+			if let mock::RuntimeEvent::AssetConversion(inner) = e {
+				Some(inner)
+			} else {
+				None
+			}
+		})
+		.collect();
+
+	System::reset_events();
+
+	result
+}
+
+fn pools() -> Vec<PoolIdOf<Test>> {
+	let mut s: Vec<_> = Pools::<Test>::iter().map(|x| x.0).collect();
+	s.sort();
+	s
+}
+
+fn assets() -> Vec<NativeOrAssetId<u32>> {
+	// if the storage would be public:
+	// let mut s: Vec<_> = pallet_assets::pallet::Asset::<Test>::iter().map(|x| x.0).collect();
+	let mut s: Vec<_> = <<Test as Config>::Assets>::asset_ids()
+		.map(|id| NativeOrAssetId::Asset(id))
+		.collect();
+	s.sort();
+	s
+}
+
+fn pool_assets() -> Vec<u32> {
+	let mut s: Vec<_> = <<Test as Config>::PoolAssets>::asset_ids().collect();
+	s.sort();
+	s
+}
+
+fn create_tokens(owner: u128, tokens: Vec<NativeOrAssetId<u32>>) {
+	for token_id in tokens {
+		let MultiAssetIdConversionResult::Converted(asset_id) =
+			NativeOrAssetIdConverter::try_convert(&token_id)
+		else {
+			unreachable!("invalid token")
+		};
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), asset_id, owner, false, 1));
+	}
+}
+
+fn balance(owner: u128, token_id: NativeOrAssetId<u32>) -> u128 {
+	match token_id {
+		NativeOrAssetId::Native => <<Test as Config>::Currency>::free_balance(owner),
+		NativeOrAssetId::Asset(token_id) => <<Test as Config>::Assets>::balance(token_id, owner),
+	}
+}
+
+fn pool_balance(owner: u128, token_id: u32) -> u128 {
+	<<Test as Config>::PoolAssets>::balance(token_id, owner)
+}
+
+fn get_ed() -> u128 {
+	<<Test as Config>::Currency>::minimum_balance()
+}
+
+macro_rules! bvec {
+	($( $x:tt )*) => {
+		vec![$( $x )*].try_into().unwrap()
+	}
+}
+
+#[test]
+fn check_pool_accounts_dont_collide() {
+	use std::collections::HashSet;
+	let mut map = HashSet::new();
+
+	for i in 0..1_000_000u32 {
+		let account = AssetConversion::get_pool_account(&(
+			NativeOrAssetId::Native,
+			NativeOrAssetId::Asset(i),
+		));
+		if map.contains(&account) {
+			panic!("Collision at {}", i);
+		}
+		map.insert(account);
+	}
+}
+
+#[test]
+fn check_max_numbers() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(AssetConversion::quote(&3u128, &u128::MAX, &u128::MAX).ok().unwrap(), 3);
+		assert!(AssetConversion::quote(&u128::MAX, &3u128, &u128::MAX).is_err());
+		assert_eq!(AssetConversion::quote(&u128::MAX, &u128::MAX, &1u128).ok().unwrap(), 1);
+
+		assert_eq!(
+			AssetConversion::get_amount_out(&100u128, &u128::MAX, &u128::MAX).ok().unwrap(),
+			99
+		);
+		assert_eq!(
+			AssetConversion::get_amount_in(&100u128, &u128::MAX, &u128::MAX).ok().unwrap(),
+			101
+		);
+	});
+}
+
+#[test]
+fn can_create_pool() {
+	new_test_ext().execute_with(|| {
+		let asset_account_deposit: u128 =
+			<mock::Test as pallet_assets::Config<Instance1>>::AssetAccountDeposit::get();
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let pool_id = (token_1, token_2);
+
+		create_tokens(user, vec![token_2]);
+
+		let lp_token = AssetConversion::get_next_pool_asset_id();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 1000));
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_2, token_1));
+
+		let setup_fee = <<Test as Config>::PoolSetupFee as Get<<Test as Config>::Balance>>::get();
+		let pool_account = <<Test as Config>::PoolSetupFeeReceiver as Get<u128>>::get();
+		assert_eq!(
+			balance(user, NativeOrAssetId::Native),
+			1000 - (setup_fee + asset_account_deposit)
+		);
+		assert_eq!(balance(pool_account, NativeOrAssetId::Native), setup_fee);
+		assert_eq!(lp_token + 1, AssetConversion::get_next_pool_asset_id());
+
+		assert_eq!(
+			events(),
+			[Event::<Test>::PoolCreated {
+				creator: user,
+				pool_id,
+				pool_account: AssetConversion::get_pool_account(&pool_id),
+				lp_token
+			}]
+		);
+		assert_eq!(pools(), vec![pool_id]);
+		assert_eq!(assets(), vec![token_2]);
+		assert_eq!(pool_assets(), vec![lp_token]);
+
+		assert_noop!(
+			AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_1),
+			Error::<Test>::EqualAssets
+		);
+		assert_noop!(
+			AssetConversion::create_pool(RuntimeOrigin::signed(user), token_2, token_2),
+			Error::<Test>::EqualAssets
+		);
+
+		// validate we can create Asset(1)/Asset(2) pool
+		let token_1 = NativeOrAssetId::Asset(1);
+		create_tokens(user, vec![token_1]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		// validate we can force the first asset to be the Native currency only
+		AllowMultiAssetPools::set(&false);
+		let token_1 = NativeOrAssetId::Asset(3);
+		assert_noop!(
+			AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2),
+			Error::<Test>::PoolMustContainNativeCurrency
+		);
+	});
+}
+
+#[test]
+fn create_same_pool_twice_should_fail() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		create_tokens(user, vec![token_2]);
+
+		let lp_token = AssetConversion::get_next_pool_asset_id();
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_2, token_1));
+		let expected_free = lp_token + 1;
+		assert_eq!(expected_free, AssetConversion::get_next_pool_asset_id());
+
+		assert_noop!(
+			AssetConversion::create_pool(RuntimeOrigin::signed(user), token_2, token_1),
+			Error::<Test>::PoolExists
+		);
+		assert_eq!(expected_free, AssetConversion::get_next_pool_asset_id());
+
+		// Try switching the same tokens around:
+		assert_noop!(
+			AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2),
+			Error::<Test>::PoolExists
+		);
+		assert_eq!(expected_free, AssetConversion::get_next_pool_asset_id());
+	});
+}
+
+#[test]
+fn different_pools_should_have_different_lp_tokens() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let token_3 = NativeOrAssetId::Asset(3);
+		let pool_id_1_2 = (token_1, token_2);
+		let pool_id_1_3 = (token_1, token_3);
+
+		create_tokens(user, vec![token_2, token_3]);
+
+		let lp_token2_1 = AssetConversion::get_next_pool_asset_id();
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_2, token_1));
+		let lp_token3_1 = AssetConversion::get_next_pool_asset_id();
+
+		assert_eq!(
+			events(),
+			[Event::<Test>::PoolCreated {
+				creator: user,
+				pool_id: pool_id_1_2,
+				pool_account: AssetConversion::get_pool_account(&pool_id_1_2),
+				lp_token: lp_token2_1
+			}]
+		);
+
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_3, token_1));
+		assert_eq!(
+			events(),
+			[Event::<Test>::PoolCreated {
+				creator: user,
+				pool_id: pool_id_1_3,
+				pool_account: AssetConversion::get_pool_account(&pool_id_1_3),
+				lp_token: lp_token3_1,
+			}]
+		);
+
+		assert_ne!(lp_token2_1, lp_token3_1);
+	});
+}
+
+#[test]
+fn can_add_liquidity() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let token_3 = NativeOrAssetId::Asset(3);
+
+		create_tokens(user, vec![token_2, token_3]);
+		let lp_token1 = AssetConversion::get_next_pool_asset_id();
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+		let lp_token2 = AssetConversion::get_next_pool_asset_id();
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_3));
+
+		let ed = get_ed();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000 * 2 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 3, user, 1000));
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			10000,
+			10,
+			10000,
+			10,
+			user,
+		));
+
+		let pool_id = (token_1, token_2);
+		assert!(events().contains(&Event::<Test>::LiquidityAdded {
+			who: user,
+			mint_to: user,
+			pool_id,
+			amount1_provided: 10000,
+			amount2_provided: 10,
+			lp_token: lp_token1,
+			lp_token_minted: 216,
+		}));
+		let pallet_account = AssetConversion::get_pool_account(&pool_id);
+		assert_eq!(balance(pallet_account, token_1), 10000);
+		assert_eq!(balance(pallet_account, token_2), 10);
+		assert_eq!(balance(user, token_1), 10000 + ed);
+		assert_eq!(balance(user, token_2), 1000 - 10);
+		assert_eq!(pool_balance(user, lp_token1), 216);
+
+		// try to pass the non-native - native assets, the result should be the same
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_3,
+			token_1,
+			10,
+			10000,
+			10,
+			10000,
+			user,
+		));
+
+		let pool_id = (token_1, token_3);
+		assert!(events().contains(&Event::<Test>::LiquidityAdded {
+			who: user,
+			mint_to: user,
+			pool_id,
+			amount1_provided: 10000,
+			amount2_provided: 10,
+			lp_token: lp_token2,
+			lp_token_minted: 216,
+		}));
+		let pallet_account = AssetConversion::get_pool_account(&pool_id);
+		assert_eq!(balance(pallet_account, token_1), 10000);
+		assert_eq!(balance(pallet_account, token_3), 10);
+		assert_eq!(balance(user, token_1), ed);
+		assert_eq!(balance(user, token_3), 1000 - 10);
+		assert_eq!(pool_balance(user, lp_token2), 216);
+	});
+}
+
+#[test]
+fn add_tiny_liquidity_leads_to_insufficient_liquidity_minted_error() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 1000));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		assert_noop!(
+			AssetConversion::add_liquidity(
+				RuntimeOrigin::signed(user),
+				token_1,
+				token_2,
+				1,
+				1,
+				1,
+				1,
+				user
+			),
+			Error::<Test>::AmountOneLessThanMinimal
+		);
+
+		assert_noop!(
+			AssetConversion::add_liquidity(
+				RuntimeOrigin::signed(user),
+				token_1,
+				token_2,
+				get_ed(),
+				1,
+				1,
+				1,
+				user
+			),
+			Error::<Test>::InsufficientLiquidityMinted
+		);
+	});
+}
+
+#[test]
+fn add_tiny_liquidity_directly_to_pool_address() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let token_3 = NativeOrAssetId::Asset(3);
+
+		create_tokens(user, vec![token_2, token_3]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_3));
+
+		let ed = get_ed();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000 * 2 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 3, user, 1000));
+
+		// check we're still able to add the liquidity even when the pool already has some token_1
+		let pallet_account = AssetConversion::get_pool_account(&(token_1, token_2));
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), pallet_account, 1000));
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			10000,
+			10,
+			10000,
+			10,
+			user,
+		));
+
+		// check the same but for token_3 (non-native token)
+		let pallet_account = AssetConversion::get_pool_account(&(token_1, token_3));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, pallet_account, 1));
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_3,
+			10000,
+			10,
+			10000,
+			10,
+			user,
+		));
+	});
+}
+
+#[test]
+fn can_remove_liquidity() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let pool_id = (token_1, token_2);
+
+		create_tokens(user, vec![token_2]);
+		let lp_token = AssetConversion::get_next_pool_asset_id();
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000000000));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 100000));
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			1000000000,
+			100000,
+			1000000000,
+			100000,
+			user,
+		));
+
+		let total_lp_received = pool_balance(user, lp_token);
+		LiquidityWithdrawalFee::set(&Permill::from_percent(10));
+
+		assert_ok!(AssetConversion::remove_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			total_lp_received,
+			0,
+			0,
+			user,
+		));
+
+		assert!(events().contains(&Event::<Test>::LiquidityRemoved {
+			who: user,
+			withdraw_to: user,
+			pool_id,
+			amount1: 899991000,
+			amount2: 89999,
+			lp_token,
+			lp_token_burned: total_lp_received,
+			withdrawal_fee: <Test as Config>::LiquidityWithdrawalFee::get()
+		}));
+
+		let pool_account = AssetConversion::get_pool_account(&pool_id);
+		assert_eq!(balance(pool_account, token_1), 100009000);
+		assert_eq!(balance(pool_account, token_2), 10001);
+		assert_eq!(pool_balance(pool_account, lp_token), 100);
+
+		assert_eq!(balance(user, token_1), 10000000000 - 1000000000 + 899991000);
+		assert_eq!(balance(user, token_2), 89999);
+		assert_eq!(pool_balance(user, lp_token), 0);
+	});
+}
+
+#[test]
+fn can_not_redeem_more_lp_tokens_than_were_minted() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let lp_token = AssetConversion::get_next_pool_asset_id();
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000 + get_ed()));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			10000,
+			10,
+			10000,
+			10,
+			user,
+		));
+
+		// Only 216 lp_tokens_minted
+		assert_eq!(pool_balance(user, lp_token), 216);
+
+		assert_noop!(
+			AssetConversion::remove_liquidity(
+				RuntimeOrigin::signed(user),
+				token_1,
+				token_2,
+				216 + 1, // Try and redeem 10 lp tokens while only 9 minted.
+				0,
+				0,
+				user,
+			),
+			DispatchError::Token(TokenError::FundsUnavailable)
+		);
+	});
+}
+
+#[test]
+fn can_quote_price() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 100000));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			10000,
+			200,
+			1,
+			1,
+			user,
+		));
+
+		assert_eq!(
+			AssetConversion::quote_price_exact_tokens_for_tokens(
+				NativeOrAssetId::Native,
+				NativeOrAssetId::Asset(2),
+				3000,
+				false,
+			),
+			Some(60)
+		);
+		// Check it still gives same price:
+		// (if the above accidentally exchanged then it would not give same quote as before)
+		assert_eq!(
+			AssetConversion::quote_price_exact_tokens_for_tokens(
+				NativeOrAssetId::Native,
+				NativeOrAssetId::Asset(2),
+				3000,
+				false,
+			),
+			Some(60)
+		);
+
+		// Check inverse:
+		assert_eq!(
+			AssetConversion::quote_price_exact_tokens_for_tokens(
+				NativeOrAssetId::Asset(2),
+				NativeOrAssetId::Native,
+				60,
+				false,
+			),
+			Some(3000)
+		);
+	});
+}
+
+#[test]
+fn can_swap_with_native() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let pool_id = (token_1, token_2);
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		let ed = get_ed();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user,
+		));
+
+		let input_amount = 100;
+		let expect_receive =
+			AssetConversion::get_amount_out(&input_amount, &liquidity2, &liquidity1)
+				.ok()
+				.unwrap();
+
+		assert_ok!(AssetConversion::swap_exact_tokens_for_tokens(
+			RuntimeOrigin::signed(user),
+			bvec![token_2, token_1],
+			input_amount,
+			1,
+			user,
+			false,
+		));
+
+		let pallet_account = AssetConversion::get_pool_account(&pool_id);
+		assert_eq!(balance(user, token_1), expect_receive + ed);
+		assert_eq!(balance(user, token_2), 1000 - liquidity2 - input_amount);
+		assert_eq!(balance(pallet_account, token_1), liquidity1 - expect_receive);
+		assert_eq!(balance(pallet_account, token_2), liquidity2 + input_amount);
+	});
+}
+
+#[test]
+fn can_swap_with_realistic_values() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let dot = NativeOrAssetId::Native;
+		let usd = NativeOrAssetId::Asset(2);
+		create_tokens(user, vec![usd]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), dot, usd));
+
+		const UNIT: u128 = 1_000_000_000;
+
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 300_000 * UNIT));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1_100_000 * UNIT));
+
+		let liquidity_dot = 200_000 * UNIT; // ratio for a 5$ price
+		let liquidity_usd = 1_000_000 * UNIT;
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			dot,
+			usd,
+			liquidity_dot,
+			liquidity_usd,
+			1,
+			1,
+			user,
+		));
+
+		let input_amount = 10 * UNIT; // usd
+
+		assert_ok!(AssetConversion::swap_exact_tokens_for_tokens(
+			RuntimeOrigin::signed(user),
+			bvec![usd, dot],
+			input_amount,
+			1,
+			user,
+			false,
+		));
+
+		assert!(events().contains(&Event::<Test>::SwapExecuted {
+			who: user,
+			send_to: user,
+			path: bvec![usd, dot],
+			amount_in: 10 * UNIT,      // usd
+			amount_out: 1_993_980_120, // About 2 dot after div by UNIT.
+		}));
+	});
+}
+
+#[test]
+fn can_not_swap_in_pool_with_no_liquidity_added_yet() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		// Check can't swap an empty pool
+		assert_noop!(
+			AssetConversion::swap_exact_tokens_for_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_2, token_1],
+				10,
+				1,
+				user,
+				false,
+			),
+			Error::<Test>::PoolNotFound
+		);
+	});
+}
+
+#[test]
+fn check_no_panic_when_try_swap_close_to_empty_pool() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let pool_id = (token_1, token_2);
+		let lp_token = AssetConversion::get_next_pool_asset_id();
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		let ed = get_ed();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user,
+		));
+
+		let lp_token_minted = pool_balance(user, lp_token);
+		assert!(events().contains(&Event::<Test>::LiquidityAdded {
+			who: user,
+			mint_to: user,
+			pool_id,
+			amount1_provided: liquidity1,
+			amount2_provided: liquidity2,
+			lp_token,
+			lp_token_minted,
+		}));
+
+		let pallet_account = AssetConversion::get_pool_account(&pool_id);
+		assert_eq!(balance(pallet_account, token_1), liquidity1);
+		assert_eq!(balance(pallet_account, token_2), liquidity2);
+
+		assert_ok!(AssetConversion::remove_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			lp_token_minted,
+			1,
+			1,
+			user,
+		));
+
+		// Now, the pool should exist but be almost empty.
+		// Let's try and drain it.
+		assert_eq!(balance(pallet_account, token_1), 708);
+		assert_eq!(balance(pallet_account, token_2), 15);
+
+		// validate the reserve should always stay above the ED
+		assert_noop!(
+			AssetConversion::swap_tokens_for_exact_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_2, token_1],
+				708 - ed + 1, // amount_out
+				500,          // amount_in_max
+				user,
+				false,
+			),
+			Error::<Test>::ReserveLeftLessThanMinimal
+		);
+
+		assert_ok!(AssetConversion::swap_tokens_for_exact_tokens(
+			RuntimeOrigin::signed(user),
+			bvec![token_2, token_1],
+			608, // amount_out
+			500, // amount_in_max
+			user,
+			false,
+		));
+
+		let token_1_left = balance(pallet_account, token_1);
+		let token_2_left = balance(pallet_account, token_2);
+		assert_eq!(token_1_left, 708 - 608);
+
+		// The price for the last tokens should be very high
+		assert_eq!(
+			AssetConversion::get_amount_in(&(token_1_left - 1), &token_2_left, &token_1_left)
+				.ok()
+				.unwrap(),
+			10625
+		);
+
+		assert_noop!(
+			AssetConversion::swap_tokens_for_exact_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_2, token_1],
+				token_1_left - 1, // amount_out
+				1000,             // amount_in_max
+				user,
+				false,
+			),
+			Error::<Test>::ProvidedMaximumNotSufficientForSwap
+		);
+
+		// Try to swap what's left in the pool
+		assert_noop!(
+			AssetConversion::swap_tokens_for_exact_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_2, token_1],
+				token_1_left, // amount_out
+				1000,         // amount_in_max
+				user,
+				false,
+			),
+			Error::<Test>::AmountOutTooHigh
+		);
+	});
+}
+
+#[test]
+fn swap_should_not_work_if_too_much_slippage() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000 + get_ed()));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user,
+		));
+
+		let exchange_amount = 100;
+
+		assert_noop!(
+			AssetConversion::swap_exact_tokens_for_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_2, token_1],
+				exchange_amount, // amount_in
+				4000,            // amount_out_min
+				user,
+				false,
+			),
+			Error::<Test>::ProvidedMinimumNotSufficientForSwap
+		);
+	});
+}
+
+#[test]
+fn can_swap_tokens_for_exact_tokens() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let pool_id = (token_1, token_2);
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		let ed = get_ed();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 20000 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		let pallet_account = AssetConversion::get_pool_account(&pool_id);
+		let before1 = balance(pallet_account, token_1) + balance(user, token_1);
+		let before2 = balance(pallet_account, token_2) + balance(user, token_2);
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user,
+		));
+
+		let exchange_out = 50;
+		let expect_in = AssetConversion::get_amount_in(&exchange_out, &liquidity1, &liquidity2)
+			.ok()
+			.unwrap();
+
+		assert_ok!(AssetConversion::swap_tokens_for_exact_tokens(
+			RuntimeOrigin::signed(user),
+			bvec![token_1, token_2],
+			exchange_out, // amount_out
+			3500,         // amount_in_max
+			user,
+			true,
+		));
+
+		assert_eq!(balance(user, token_1), 10000 + ed - expect_in);
+		assert_eq!(balance(user, token_2), 1000 - liquidity2 + exchange_out);
+		assert_eq!(balance(pallet_account, token_1), liquidity1 + expect_in);
+		assert_eq!(balance(pallet_account, token_2), liquidity2 - exchange_out);
+
+		// check invariants:
+
+		// native and asset totals should be preserved.
+		assert_eq!(before1, balance(pallet_account, token_1) + balance(user, token_1));
+		assert_eq!(before2, balance(pallet_account, token_2) + balance(user, token_2));
+	});
+}
+
+#[test]
+fn can_swap_tokens_for_exact_tokens_when_not_liquidity_provider() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let user2 = 2;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let pool_id = (token_1, token_2);
+		let lp_token = AssetConversion::get_next_pool_asset_id();
+
+		create_tokens(user2, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user2), token_1, token_2));
+
+		let ed = get_ed();
+		let base1 = 10000;
+		let base2 = 1000;
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, base1 + ed));
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user2, base1 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user2), 2, user2, base2));
+
+		let pallet_account = AssetConversion::get_pool_account(&pool_id);
+		let before1 =
+			balance(pallet_account, token_1) + balance(user, token_1) + balance(user2, token_1);
+		let before2 =
+			balance(pallet_account, token_2) + balance(user, token_2) + balance(user2, token_2);
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user2),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user2,
+		));
+
+		assert_eq!(balance(user, token_1), base1 + ed);
+		assert_eq!(balance(user, token_2), 0);
+
+		let exchange_out = 50;
+		let expect_in = AssetConversion::get_amount_in(&exchange_out, &liquidity1, &liquidity2)
+			.ok()
+			.unwrap();
+
+		assert_ok!(AssetConversion::swap_tokens_for_exact_tokens(
+			RuntimeOrigin::signed(user),
+			bvec![token_1, token_2],
+			exchange_out, // amount_out
+			3500,         // amount_in_max
+			user,
+			true,
+		));
+
+		assert_eq!(balance(user, token_1), base1 + ed - expect_in);
+		assert_eq!(balance(pallet_account, token_1), liquidity1 + expect_in);
+		assert_eq!(balance(user, token_2), exchange_out);
+		assert_eq!(balance(pallet_account, token_2), liquidity2 - exchange_out);
+
+		// check invariants:
+
+		// native and asset totals should be preserved.
+		assert_eq!(
+			before1,
+			balance(pallet_account, token_1) + balance(user, token_1) + balance(user2, token_1)
+		);
+		assert_eq!(
+			before2,
+			balance(pallet_account, token_2) + balance(user, token_2) + balance(user2, token_2)
+		);
+
+		let lp_token_minted = pool_balance(user2, lp_token);
+		assert_eq!(lp_token_minted, 1314);
+
+		assert_ok!(AssetConversion::remove_liquidity(
+			RuntimeOrigin::signed(user2),
+			token_1,
+			token_2,
+			lp_token_minted,
+			0,
+			0,
+			user2,
+		));
+	});
+}
+
+#[test]
+fn swap_when_existential_deposit_would_cause_reaping_but_keep_alive_set() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let user2 = 2;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		create_tokens(user2, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user2), token_1, token_2));
+
+		let ed = get_ed();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 101));
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user2, 10000 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user2), 2, user2, 1000));
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user2),
+			token_1,
+			token_2,
+			10000,
+			200,
+			1,
+			1,
+			user2,
+		));
+
+		assert_noop!(
+			AssetConversion::swap_tokens_for_exact_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_1, token_2],
+				1,   // amount_out
+				101, // amount_in_max
+				user,
+				true,
+			),
+			DispatchError::Token(TokenError::NotExpendable)
+		);
+
+		assert_noop!(
+			AssetConversion::swap_exact_tokens_for_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_1, token_2],
+				51, // amount_in
+				1,  // amount_out_min
+				user,
+				true,
+			),
+			DispatchError::Token(TokenError::NotExpendable)
+		);
+	});
+}
+
+#[test]
+fn swap_tokens_for_exact_tokens_should_not_work_if_too_much_slippage() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 20000 + get_ed()));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 1000));
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user,
+		));
+
+		let exchange_out = 1;
+
+		assert_noop!(
+			AssetConversion::swap_tokens_for_exact_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_1, token_2],
+				exchange_out, // amount_out
+				50,           // amount_in_max just greater than slippage.
+				user,
+				true
+			),
+			Error::<Test>::ProvidedMaximumNotSufficientForSwap
+		);
+	});
+}
+
+#[test]
+fn swap_exact_tokens_for_tokens_in_multi_hops() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let token_3 = NativeOrAssetId::Asset(3);
+
+		create_tokens(user, vec![token_2, token_3]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_2, token_3));
+
+		let ed = get_ed();
+		let base1 = 10000;
+		let base2 = 10000;
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, base1 * 2 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, base2));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 3, user, base2));
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+		let liquidity3 = 2000;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user,
+		));
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_2,
+			token_3,
+			liquidity2,
+			liquidity3,
+			1,
+			1,
+			user,
+		));
+
+		let input_amount = 500;
+		let expect_out2 = AssetConversion::get_amount_out(&input_amount, &liquidity1, &liquidity2)
+			.ok()
+			.unwrap();
+		let expect_out3 = AssetConversion::get_amount_out(&expect_out2, &liquidity2, &liquidity3)
+			.ok()
+			.unwrap();
+
+		assert_noop!(
+			AssetConversion::swap_exact_tokens_for_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_1],
+				input_amount,
+				80,
+				user,
+				true,
+			),
+			Error::<Test>::InvalidPath
+		);
+
+		assert_noop!(
+			AssetConversion::swap_exact_tokens_for_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_1, token_2, token_3, token_2],
+				input_amount,
+				80,
+				user,
+				true,
+			),
+			Error::<Test>::NonUniquePath
+		);
+
+		assert_ok!(AssetConversion::swap_exact_tokens_for_tokens(
+			RuntimeOrigin::signed(user),
+			bvec![token_1, token_2, token_3],
+			input_amount, // amount_in
+			80,           // amount_out_min
+			user,
+			true,
+		));
+
+		let pool_id1 = (token_1, token_2);
+		let pool_id2 = (token_2, token_3);
+		let pallet_account1 = AssetConversion::get_pool_account(&pool_id1);
+		let pallet_account2 = AssetConversion::get_pool_account(&pool_id2);
+
+		assert_eq!(balance(user, token_1), base1 + ed - input_amount);
+		assert_eq!(balance(pallet_account1, token_1), liquidity1 + input_amount);
+		assert_eq!(balance(pallet_account1, token_2), liquidity2 - expect_out2);
+		assert_eq!(balance(pallet_account2, token_2), liquidity2 + expect_out2);
+		assert_eq!(balance(pallet_account2, token_3), liquidity3 - expect_out3);
+		assert_eq!(balance(user, token_3), 10000 - liquidity3 + expect_out3);
+	});
+}
+
+#[test]
+fn swap_tokens_for_exact_tokens_in_multi_hops() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+		let token_3 = NativeOrAssetId::Asset(3);
+
+		create_tokens(user, vec![token_2, token_3]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_2, token_3));
+
+		let ed = get_ed();
+		let base1 = 10000;
+		let base2 = 10000;
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, base1 * 2 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, base2));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 3, user, base2));
+
+		let liquidity1 = 10000;
+		let liquidity2 = 200;
+		let liquidity3 = 2000;
+
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			liquidity1,
+			liquidity2,
+			1,
+			1,
+			user,
+		));
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_2,
+			token_3,
+			liquidity2,
+			liquidity3,
+			1,
+			1,
+			user,
+		));
+
+		let exchange_out3 = 100;
+		let expect_in2 = AssetConversion::get_amount_in(&exchange_out3, &liquidity2, &liquidity3)
+			.ok()
+			.unwrap();
+		let expect_in1 = AssetConversion::get_amount_in(&expect_in2, &liquidity1, &liquidity2)
+			.ok()
+			.unwrap();
+
+		assert_ok!(AssetConversion::swap_tokens_for_exact_tokens(
+			RuntimeOrigin::signed(user),
+			bvec![token_1, token_2, token_3],
+			exchange_out3, // amount_out
+			1000,          // amount_in_max
+			user,
+			true,
+		));
+
+		let pool_id1 = (token_1, token_2);
+		let pool_id2 = (token_2, token_3);
+		let pallet_account1 = AssetConversion::get_pool_account(&pool_id1);
+		let pallet_account2 = AssetConversion::get_pool_account(&pool_id2);
+
+		assert_eq!(balance(user, token_1), base1 + ed - expect_in1);
+		assert_eq!(balance(pallet_account1, token_1), liquidity1 + expect_in1);
+		assert_eq!(balance(pallet_account1, token_2), liquidity2 - expect_in2);
+		assert_eq!(balance(pallet_account2, token_2), liquidity2 + expect_in2);
+		assert_eq!(balance(pallet_account2, token_3), liquidity3 - exchange_out3);
+		assert_eq!(balance(user, token_3), 10000 - liquidity3 + exchange_out3);
+	});
+}
+
+#[test]
+fn can_not_swap_same_asset() {
+	new_test_ext().execute_with(|| {
+		let user = 1;
+		let token_1 = NativeOrAssetId::Asset(1);
+
+		create_tokens(user, vec![token_1]);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 1, user, 1000));
+
+		let liquidity1 = 1000;
+		let liquidity2 = 20;
+		assert_noop!(
+			AssetConversion::add_liquidity(
+				RuntimeOrigin::signed(user),
+				token_1,
+				token_1,
+				liquidity1,
+				liquidity2,
+				1,
+				1,
+				user,
+			),
+			Error::<Test>::PoolNotFound
+		);
+
+		let exchange_amount = 10;
+		assert_noop!(
+			AssetConversion::swap_exact_tokens_for_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![token_1, token_1],
+				exchange_amount,
+				1,
+				user,
+				true,
+			),
+			Error::<Test>::PoolNotFound
+		);
+
+		assert_noop!(
+			AssetConversion::swap_exact_tokens_for_tokens(
+				RuntimeOrigin::signed(user),
+				bvec![NativeOrAssetId::Native, NativeOrAssetId::Native],
+				exchange_amount,
+				1,
+				user,
+				true,
+			),
+			Error::<Test>::PoolNotFound
+		);
+	});
+}
+
+#[test]
+fn validate_pool_id_sorting() {
+	new_test_ext().execute_with(|| {
+		use crate::NativeOrAssetId::{Asset, Native};
+		assert_eq!(AssetConversion::get_pool_id(Native, Asset(2)), (Native, Asset(2)));
+		assert_eq!(AssetConversion::get_pool_id(Asset(2), Native), (Native, Asset(2)));
+		assert_eq!(AssetConversion::get_pool_id(Native, Native), (Native, Native));
+		assert_eq!(AssetConversion::get_pool_id(Asset(2), Asset(1)), (Asset(1), Asset(2)));
+		assert!(Asset(2) > Asset(1));
+		assert!(Asset(1) <= Asset(1));
+		assert_eq!(Asset(1), Asset(1));
+		assert_eq!(Native::<u32>, Native::<u32>);
+		assert!(Native < Asset(1));
+	});
+}
+
+#[test]
+fn cannot_block_pool_creation() {
+	new_test_ext().execute_with(|| {
+		// User 1 is the pool creator
+		let user = 1;
+		// User 2 is the attacker
+		let attacker = 2;
+
+		let ed = get_ed();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), attacker, 10000 + ed));
+
+		// The target pool the user wants to create is Native <=> Asset(2)
+		let token_1 = NativeOrAssetId::Native;
+		let token_2 = NativeOrAssetId::Asset(2);
+
+		// Attacker computes the still non-existing pool account for the target pair
+		let pool_account =
+			AssetConversion::get_pool_account(&AssetConversion::get_pool_id(token_2, token_1));
+		// And transfers the ED to that pool account
+		assert_ok!(Balances::transfer(RuntimeOrigin::signed(attacker), pool_account, ed));
+		// Then, the attacker creates 14 tokens and sends one of each to the pool account
+		for i in 10..25 {
+			create_tokens(attacker, vec![NativeOrAssetId::Asset(i)]);
+			assert_ok!(Assets::mint(RuntimeOrigin::signed(attacker), i, attacker, 1000));
+			assert_ok!(Assets::transfer(RuntimeOrigin::signed(attacker), i, pool_account, 1));
+		}
+
+		// User can still create the pool
+		create_tokens(user, vec![token_2]);
+		assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(user), token_1, token_2));
+
+		// User has to transfer one Asset(2) token to the pool account (otherwise add_liquidity will
+		// fail with `AssetTwoDepositDidNotMeetMinimum`)
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), user, 10000 + ed));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(user), 2, user, 10000));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(user), 2, pool_account, 1));
+
+		// add_liquidity shouldn't fail because of the number of consumers
+		assert_ok!(AssetConversion::add_liquidity(
+			RuntimeOrigin::signed(user),
+			token_1,
+			token_2,
+			10000,
+			100,
+			10000,
+			10,
+			user,
+		));
+	});
+}
diff --git a/substrate/frame/asset-conversion/src/types.rs b/substrate/frame/asset-conversion/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9c28bd7666b7128dcf5a37d5a98ca6a963d118c2
--- /dev/null
+++ b/substrate/frame/asset-conversion/src/types.rs
@@ -0,0 +1,188 @@
+// 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.
+
+use super::*;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_std::{cmp::Ordering, marker::PhantomData};
+
+/// Pool ID.
+///
+/// The pool's `AccountId` is derived from this type. Any changes to the type may necessitate a
+/// migration.
+pub(super) type PoolIdOf<T> = (<T as Config>::MultiAssetId, <T as Config>::MultiAssetId);
+
+/// Stores the lp_token asset id a particular pool has been assigned.
+#[derive(Decode, Encode, Default, PartialEq, Eq, MaxEncodedLen, TypeInfo)]
+pub struct PoolInfo<PoolAssetId> {
+	/// Liquidity pool asset
+	pub lp_token: PoolAssetId,
+}
+
+/// A trait that converts between a MultiAssetId and either the native currency or an AssetId.
+pub trait MultiAssetIdConverter<MultiAssetId, AssetId> {
+	/// Returns the MultiAssetId representing the native currency of the chain.
+	fn get_native() -> MultiAssetId;
+
+	/// Returns true if the given MultiAssetId is the native currency.
+	fn is_native(asset: &MultiAssetId) -> bool;
+
+	/// If it's not native, returns the AssetId for the given MultiAssetId.
+	fn try_convert(asset: &MultiAssetId) -> MultiAssetIdConversionResult<MultiAssetId, AssetId>;
+}
+
+/// Result of `MultiAssetIdConverter::try_convert`.
+#[cfg_attr(feature = "std", derive(PartialEq, Debug))]
+pub enum MultiAssetIdConversionResult<MultiAssetId, AssetId> {
+	/// Input asset is successfully converted. Means that converted asset is supported.
+	Converted(AssetId),
+	/// Means that input asset is the chain's native asset, if it has one, so no conversion (see
+	/// `MultiAssetIdConverter::get_native`).
+	Native,
+	/// Means input asset is not supported for pool.
+	Unsupported(MultiAssetId),
+}
+
+/// Benchmark Helper
+#[cfg(feature = "runtime-benchmarks")]
+pub trait BenchmarkHelper<AssetId, MultiAssetId> {
+	/// Returns an `AssetId` from a given integer.
+	fn asset_id(asset_id: u32) -> AssetId;
+
+	/// Returns a `MultiAssetId` from a given integer.
+	fn multiasset_id(asset_id: u32) -> MultiAssetId;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<AssetId, MultiAssetId> BenchmarkHelper<AssetId, MultiAssetId> for ()
+where
+	AssetId: From<u32>,
+	MultiAssetId: From<u32>,
+{
+	fn asset_id(asset_id: u32) -> AssetId {
+		asset_id.into()
+	}
+
+	fn multiasset_id(asset_id: u32) -> MultiAssetId {
+		asset_id.into()
+	}
+}
+
+/// Trait for providing methods to swap between the various asset classes.
+pub trait Swap<AccountId, Balance, MultiAssetId> {
+	/// Swap exactly `amount_in` of asset `path[0]` for asset `path[1]`.
+	/// If an `amount_out_min` is specified, it will return an error if it is unable to acquire
+	/// the amount desired.
+	///
+	/// Withdraws the `path[0]` asset from `sender`, deposits the `path[1]` asset to `send_to`,
+	/// respecting `keep_alive`.
+	///
+	/// If successful, returns the amount of `path[1]` acquired for the `amount_in`.
+	fn swap_exact_tokens_for_tokens(
+		sender: AccountId,
+		path: Vec<MultiAssetId>,
+		amount_in: Balance,
+		amount_out_min: Option<Balance>,
+		send_to: AccountId,
+		keep_alive: bool,
+	) -> Result<Balance, DispatchError>;
+
+	/// Take the `path[0]` asset and swap some amount for `amount_out` of the `path[1]`. If an
+	/// `amount_in_max` is specified, it will return an error if acquiring `amount_out` would be
+	/// too costly.
+	///
+	/// Withdraws `path[0]` asset from `sender`, deposits `path[1]` asset to `send_to`,
+	/// respecting `keep_alive`.
+	///
+	/// If successful returns the amount of the `path[0]` taken to provide `path[1]`.
+	fn swap_tokens_for_exact_tokens(
+		sender: AccountId,
+		path: Vec<MultiAssetId>,
+		amount_out: Balance,
+		amount_in_max: Option<Balance>,
+		send_to: AccountId,
+		keep_alive: bool,
+	) -> Result<Balance, DispatchError>;
+}
+
+/// An implementation of MultiAssetId that can be either Native or an asset.
+#[derive(Decode, Encode, Default, MaxEncodedLen, TypeInfo, Clone, Copy, Debug)]
+pub enum NativeOrAssetId<AssetId>
+where
+	AssetId: Ord,
+{
+	/// Native asset. For example, on the Polkadot Asset Hub this would be DOT.
+	#[default]
+	Native,
+	/// A non-native asset id.
+	Asset(AssetId),
+}
+
+impl<AssetId: Ord> From<AssetId> for NativeOrAssetId<AssetId> {
+	fn from(asset: AssetId) -> Self {
+		Self::Asset(asset)
+	}
+}
+
+impl<AssetId: Ord> Ord for NativeOrAssetId<AssetId> {
+	fn cmp(&self, other: &Self) -> Ordering {
+		match (self, other) {
+			(Self::Native, Self::Native) => Ordering::Equal,
+			(Self::Native, Self::Asset(_)) => Ordering::Less,
+			(Self::Asset(_), Self::Native) => Ordering::Greater,
+			(Self::Asset(id1), Self::Asset(id2)) => <AssetId as Ord>::cmp(id1, id2),
+		}
+	}
+}
+impl<AssetId: Ord> PartialOrd for NativeOrAssetId<AssetId> {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(<Self as Ord>::cmp(self, other))
+	}
+}
+impl<AssetId: Ord> PartialEq for NativeOrAssetId<AssetId> {
+	fn eq(&self, other: &Self) -> bool {
+		self.cmp(other) == Ordering::Equal
+	}
+}
+impl<AssetId: Ord> Eq for NativeOrAssetId<AssetId> {}
+
+/// Converts between a MultiAssetId and an AssetId (or the native currency).
+pub struct NativeOrAssetIdConverter<AssetId> {
+	_phantom: PhantomData<AssetId>,
+}
+
+impl<AssetId: Ord + Clone> MultiAssetIdConverter<NativeOrAssetId<AssetId>, AssetId>
+	for NativeOrAssetIdConverter<AssetId>
+{
+	fn get_native() -> NativeOrAssetId<AssetId> {
+		NativeOrAssetId::Native
+	}
+
+	fn is_native(asset: &NativeOrAssetId<AssetId>) -> bool {
+		*asset == Self::get_native()
+	}
+
+	fn try_convert(
+		asset: &NativeOrAssetId<AssetId>,
+	) -> MultiAssetIdConversionResult<NativeOrAssetId<AssetId>, AssetId> {
+		match asset {
+			NativeOrAssetId::Asset(asset) => MultiAssetIdConversionResult::Converted(asset.clone()),
+			NativeOrAssetId::Native => MultiAssetIdConversionResult::Native,
+		}
+	}
+}
diff --git a/substrate/frame/asset-conversion/src/weights.rs b/substrate/frame/asset-conversion/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..550878ba0be96ba13e0dc2aef6d685cd3ec257b7
--- /dev/null
+++ b/substrate/frame/asset-conversion/src/weights.rs
@@ -0,0 +1,256 @@
+// 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.
+
+//! Autogenerated weights for pallet_asset_conversion
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-07-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-gghbxkbs-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: ``, WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
+
+// Executed Command:
+// target/production/substrate
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_asset_conversion
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/asset-conversion/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_asset_conversion.
+pub trait WeightInfo {
+	fn create_pool() -> Weight;
+	fn add_liquidity() -> Weight;
+	fn remove_liquidity() -> Weight;
+	fn swap_exact_tokens_for_tokens() -> Weight;
+	fn swap_tokens_for_exact_tokens() -> Weight;
+}
+
+/// Weights for pallet_asset_conversion using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `AssetConversion::Pools` (r:1 w:1)
+	/// Proof: `AssetConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `AssetConversion::NextPoolAssetId` (r:1 w:1)
+	/// Proof: `AssetConversion::NextPoolAssetId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Asset` (r:1 w:1)
+	/// Proof: `PoolAssets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Account` (r:1 w:1)
+	/// Proof: `PoolAssets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn create_pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `729`
+		//  Estimated: `6196`
+		// Minimum execution time: 131_688_000 picoseconds.
+		Weight::from_parts(134_092_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(8_u64))
+	}
+	/// Storage: `AssetConversion::Pools` (r:1 w:0)
+	/// Proof: `AssetConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Asset` (r:1 w:1)
+	/// Proof: `PoolAssets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Account` (r:2 w:2)
+	/// Proof: `PoolAssets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn add_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1382`
+		//  Estimated: `6208`
+		// Minimum execution time: 157_310_000 picoseconds.
+		Weight::from_parts(161_547_000, 6208)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: `AssetConversion::Pools` (r:1 w:0)
+	/// Proof: `AssetConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Asset` (r:1 w:1)
+	/// Proof: `PoolAssets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Account` (r:1 w:1)
+	/// Proof: `PoolAssets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn remove_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1371`
+		//  Estimated: `6208`
+		// Minimum execution time: 142_769_000 picoseconds.
+		Weight::from_parts(145_139_000, 6208)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:3 w:3)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:6 w:6)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn swap_exact_tokens_for_tokens() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1738`
+		//  Estimated: `16644`
+		// Minimum execution time: 213_186_000 picoseconds.
+		Weight::from_parts(217_471_000, 16644)
+			.saturating_add(T::DbWeight::get().reads(10_u64))
+			.saturating_add(T::DbWeight::get().writes(10_u64))
+	}
+	/// Storage: `Assets::Asset` (r:3 w:3)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:6 w:6)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn swap_tokens_for_exact_tokens() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1738`
+		//  Estimated: `16644`
+		// Minimum execution time: 213_793_000 picoseconds.
+		Weight::from_parts(218_584_000, 16644)
+			.saturating_add(T::DbWeight::get().reads(10_u64))
+			.saturating_add(T::DbWeight::get().writes(10_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `AssetConversion::Pools` (r:1 w:1)
+	/// Proof: `AssetConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:1 w:1)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `AssetConversion::NextPoolAssetId` (r:1 w:1)
+	/// Proof: `AssetConversion::NextPoolAssetId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Asset` (r:1 w:1)
+	/// Proof: `PoolAssets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Account` (r:1 w:1)
+	/// Proof: `PoolAssets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn create_pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `729`
+		//  Estimated: `6196`
+		// Minimum execution time: 131_688_000 picoseconds.
+		Weight::from_parts(134_092_000, 6196)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(8_u64))
+	}
+	/// Storage: `AssetConversion::Pools` (r:1 w:0)
+	/// Proof: `AssetConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Asset` (r:1 w:1)
+	/// Proof: `PoolAssets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Account` (r:2 w:2)
+	/// Proof: `PoolAssets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn add_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1382`
+		//  Estimated: `6208`
+		// Minimum execution time: 157_310_000 picoseconds.
+		Weight::from_parts(161_547_000, 6208)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: `AssetConversion::Pools` (r:1 w:0)
+	/// Proof: `AssetConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:1 w:1)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:2 w:2)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Asset` (r:1 w:1)
+	/// Proof: `PoolAssets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `PoolAssets::Account` (r:1 w:1)
+	/// Proof: `PoolAssets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn remove_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1371`
+		//  Estimated: `6208`
+		// Minimum execution time: 142_769_000 picoseconds.
+		Weight::from_parts(145_139_000, 6208)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Asset` (r:3 w:3)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:6 w:6)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	fn swap_exact_tokens_for_tokens() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1738`
+		//  Estimated: `16644`
+		// Minimum execution time: 213_186_000 picoseconds.
+		Weight::from_parts(217_471_000, 16644)
+			.saturating_add(RocksDbWeight::get().reads(10_u64))
+			.saturating_add(RocksDbWeight::get().writes(10_u64))
+	}
+	/// Storage: `Assets::Asset` (r:3 w:3)
+	/// Proof: `Assets::Asset` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
+	/// Storage: `Assets::Account` (r:6 w:6)
+	/// Proof: `Assets::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn swap_tokens_for_exact_tokens() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1738`
+		//  Estimated: `16644`
+		// Minimum execution time: 213_793_000 picoseconds.
+		Weight::from_parts(218_584_000, 16644)
+			.saturating_add(RocksDbWeight::get().reads(10_u64))
+			.saturating_add(RocksDbWeight::get().writes(10_u64))
+	}
+}
diff --git a/substrate/frame/asset-rate/Cargo.toml b/substrate/frame/asset-rate/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4a37be8c452b140541cf02a4e24d711fefe16a39
--- /dev/null
+++ b/substrate/frame/asset-rate/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-asset-rate"
+version = "4.0.0-dev"
+description = "Whitelist non-native assets for treasury spending and provide conversion to native balance"
+authors = ["William Freudenberger <w.freude@icloud.com>"]
+homepage = "https://substrate.io"
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-core = { version = "21.0.0", default-features = false, optional = true, path = "../../primitives/core" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core?/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-core",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/asset-rate/src/benchmarking.rs b/substrate/frame/asset-rate/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..12edcf5aee025c8d88601c67583bf02affac6bbd
--- /dev/null
+++ b/substrate/frame/asset-rate/src/benchmarking.rs
@@ -0,0 +1,102 @@
+// 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.
+
+//! The crate's benchmarks.
+
+use super::*;
+use crate::{pallet as pallet_asset_rate, Pallet as AssetRate};
+
+use codec::Encode;
+use frame_benchmarking::v2::*;
+use frame_support::assert_ok;
+use frame_system::RawOrigin;
+use sp_core::crypto::FromEntropy;
+use sp_std::vec;
+
+/// Trait describing the factory function for the `AssetKind` parameter.
+pub trait AssetKindFactory<AssetKind> {
+	fn create_asset_kind(seed: u32) -> AssetKind;
+}
+impl<AssetKind> AssetKindFactory<AssetKind> for ()
+where
+	AssetKind: FromEntropy,
+{
+	fn create_asset_kind(seed: u32) -> AssetKind {
+		AssetKind::from_entropy(&mut seed.encode().as_slice()).unwrap()
+	}
+}
+
+const SEED: u32 = 1;
+
+fn default_conversion_rate() -> FixedU128 {
+	FixedU128::from_u32(1u32)
+}
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn create() -> Result<(), BenchmarkError> {
+		let asset_kind: T::AssetKind = T::BenchmarkHelper::create_asset_kind(SEED);
+		#[extrinsic_call]
+		_(RawOrigin::Root, asset_kind.clone(), default_conversion_rate());
+
+		assert_eq!(
+			pallet_asset_rate::ConversionRateToNative::<T>::get(asset_kind),
+			Some(default_conversion_rate())
+		);
+		Ok(())
+	}
+
+	#[benchmark]
+	fn update() -> Result<(), BenchmarkError> {
+		let asset_kind: T::AssetKind = T::BenchmarkHelper::create_asset_kind(SEED);
+		assert_ok!(AssetRate::<T>::create(
+			RawOrigin::Root.into(),
+			asset_kind.clone(),
+			default_conversion_rate()
+		));
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, asset_kind.clone(), FixedU128::from_u32(2));
+
+		assert_eq!(
+			pallet_asset_rate::ConversionRateToNative::<T>::get(asset_kind),
+			Some(FixedU128::from_u32(2))
+		);
+		Ok(())
+	}
+
+	#[benchmark]
+	fn remove() -> Result<(), BenchmarkError> {
+		let asset_kind: T::AssetKind = T::BenchmarkHelper::create_asset_kind(SEED);
+		assert_ok!(AssetRate::<T>::create(
+			RawOrigin::Root.into(),
+			asset_kind.clone(),
+			default_conversion_rate()
+		));
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, asset_kind.clone());
+
+		assert!(pallet_asset_rate::ConversionRateToNative::<T>::get(asset_kind).is_none());
+		Ok(())
+	}
+
+	impl_benchmark_test_suite! { AssetRate, crate::mock::new_test_ext(), crate::mock::Test }
+}
diff --git a/substrate/frame/asset-rate/src/lib.rs b/substrate/frame/asset-rate/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8b55f3d1d40296fb064aa8c2f450232d7eb02465
--- /dev/null
+++ b/substrate/frame/asset-rate/src/lib.rs
@@ -0,0 +1,238 @@
+// 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.
+
+//! # Asset Rate Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! The AssetRate pallet provides means of setting conversion rates for some asset to native
+//! balance.
+//!
+//! The supported dispatchable functions are documented in the [`Call`] enum.
+//!
+//! ### Terminology
+//!
+//! * **Asset balance**: The balance type of an arbitrary asset. The network might only know about
+//!   the identifier of the asset and nothing more.
+//! * **Native balance**: The balance type of the network's native currency.
+//!
+//! ### Goals
+//!
+//! The asset-rate system in Substrate is designed to make the following possible:
+//!
+//! * Providing a soft conversion for the balance of supported assets to a default asset class.
+//! * Updating existing conversion rates.
+//!
+//! ## Interface
+//!
+//! ### Permissioned Functions
+//!
+//! * `create`: Creates a new asset conversion rate.
+//! * `remove`: Removes an existing asset conversion rate.
+//! * `update`: Overwrites an existing assert conversion rate.
+//!
+//! Please refer to the [`Call`] enum and its associated variants for documentation on each
+//! function.
+//!
+//! ### Assumptions
+//!
+//! * Conversion rates are only used as estimates, and are not designed to be precise or closely
+//!   tracking real world values.
+//! * All conversion rates reflect the ration of some asset to native, e.g. native = asset * rate.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::traits::{fungible::Inspect, tokens::ConversionFromAssetBalance};
+use sp_runtime::{traits::Zero, FixedPointNumber, FixedU128};
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+#[cfg(feature = "runtime-benchmarks")]
+pub use benchmarking::AssetKindFactory;
+
+// Type alias for `frame_system`'s account id.
+type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
+// This pallet's asset kind and balance type.
+type AssetKindOf<T> = <T as Config>::AssetKind;
+// Generic fungible balance type.
+type BalanceOf<T> = <<T as Config>::Currency as Inspect<AccountIdOf<T>>>::Balance;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The runtime event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The origin permissioned to create a conversion rate for an asset.
+		type CreateOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin permissioned to remove an existing conversion rate for an asset.
+		type RemoveOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin permissioned to update an existiing conversion rate for an asset.
+		type UpdateOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The currency mechanism for this pallet.
+		type Currency: Inspect<Self::AccountId>;
+
+		/// The type for asset kinds for which the conversion rate to native balance is set.
+		type AssetKind: Parameter + MaxEncodedLen;
+
+		/// Helper type for benchmarks.
+		#[cfg(feature = "runtime-benchmarks")]
+		type BenchmarkHelper: crate::AssetKindFactory<Self::AssetKind>;
+	}
+
+	/// Maps an asset to its fixed point representation in the native balance.
+	///
+	/// E.g. `native_amount = asset_amount * ConversionRateToNative::<T>::get(asset_kind)`
+	#[pallet::storage]
+	pub type ConversionRateToNative<T: Config> =
+		StorageMap<_, Blake2_128Concat, T::AssetKind, FixedU128, OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		// Some `asset_kind` conversion rate was created.
+		AssetRateCreated { asset_kind: T::AssetKind, rate: FixedU128 },
+		// Some `asset_kind` conversion rate was removed.
+		AssetRateRemoved { asset_kind: T::AssetKind },
+		// Some existing `asset_kind` conversion rate was updated from `old` to `new`.
+		AssetRateUpdated { asset_kind: T::AssetKind, old: FixedU128, new: FixedU128 },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The given asset ID is unknown.
+		UnknownAssetKind,
+		/// The given asset ID already has an assigned conversion rate and cannot be re-created.
+		AlreadyExists,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Initialize a conversion rate to native balance for the given asset.
+		///
+		/// ## Complexity
+		/// - O(1)
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::create())]
+		pub fn create(
+			origin: OriginFor<T>,
+			asset_kind: T::AssetKind,
+			rate: FixedU128,
+		) -> DispatchResult {
+			T::CreateOrigin::ensure_origin(origin)?;
+
+			ensure!(
+				!ConversionRateToNative::<T>::contains_key(asset_kind.clone()),
+				Error::<T>::AlreadyExists
+			);
+			ConversionRateToNative::<T>::set(asset_kind.clone(), Some(rate));
+
+			Self::deposit_event(Event::AssetRateCreated { asset_kind, rate });
+			Ok(())
+		}
+
+		/// Update the conversion rate to native balance for the given asset.
+		///
+		/// ## Complexity
+		/// - O(1)
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::update())]
+		pub fn update(
+			origin: OriginFor<T>,
+			asset_kind: T::AssetKind,
+			rate: FixedU128,
+		) -> DispatchResult {
+			T::UpdateOrigin::ensure_origin(origin)?;
+
+			let mut old = FixedU128::zero();
+			ConversionRateToNative::<T>::mutate(asset_kind.clone(), |maybe_rate| {
+				if let Some(r) = maybe_rate {
+					old = *r;
+					*r = rate;
+
+					Ok(())
+				} else {
+					Err(Error::<T>::UnknownAssetKind)
+				}
+			})?;
+
+			Self::deposit_event(Event::AssetRateUpdated { asset_kind, old, new: rate });
+			Ok(())
+		}
+
+		/// Remove an existing conversion rate to native balance for the given asset.
+		///
+		/// ## Complexity
+		/// - O(1)
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::remove())]
+		pub fn remove(origin: OriginFor<T>, asset_kind: T::AssetKind) -> DispatchResult {
+			T::RemoveOrigin::ensure_origin(origin)?;
+
+			ensure!(
+				ConversionRateToNative::<T>::contains_key(asset_kind.clone()),
+				Error::<T>::UnknownAssetKind
+			);
+			ConversionRateToNative::<T>::remove(asset_kind.clone());
+
+			Self::deposit_event(Event::AssetRateRemoved { asset_kind });
+			Ok(())
+		}
+	}
+}
+
+/// Exposes conversion of an arbitrary balance of an asset to native balance.
+impl<T> ConversionFromAssetBalance<BalanceOf<T>, AssetKindOf<T>, BalanceOf<T>> for Pallet<T>
+where
+	T: Config,
+{
+	type Error = pallet::Error<T>;
+
+	fn from_asset_balance(
+		balance: BalanceOf<T>,
+		asset_kind: AssetKindOf<T>,
+	) -> Result<BalanceOf<T>, pallet::Error<T>> {
+		let rate = pallet::ConversionRateToNative::<T>::get(asset_kind)
+			.ok_or(pallet::Error::<T>::UnknownAssetKind.into())?;
+		Ok(rate.saturating_mul_int(balance))
+	}
+}
diff --git a/substrate/frame/asset-rate/src/mock.rs b/substrate/frame/asset-rate/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5fe0d4240af585b0383aea47a47fed5ae92afc34
--- /dev/null
+++ b/substrate/frame/asset-rate/src/mock.rs
@@ -0,0 +1,96 @@
+// 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.
+
+//! The crate's mock.
+
+use crate as pallet_asset_rate;
+use frame_support::traits::{ConstU16, ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		AssetRate: pallet_asset_rate,
+		Balances: pallet_balances,
+	}
+);
+
+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 = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ConstU16<42>;
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+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 FreezeIdentifier = ();
+	type MaxHolds = ();
+	type MaxFreezes = ();
+}
+
+impl pallet_asset_rate::Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type CreateOrigin = frame_system::EnsureRoot<u64>;
+	type RemoveOrigin = frame_system::EnsureRoot<u64>;
+	type UpdateOrigin = frame_system::EnsureRoot<u64>;
+	type Currency = Balances;
+	type AssetKind = u32;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+// Build genesis storage according to the mock runtime.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
diff --git a/substrate/frame/asset-rate/src/tests.rs b/substrate/frame/asset-rate/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8990ba9fc28d658bfab2b2bf1e3f73a6373232e1
--- /dev/null
+++ b/substrate/frame/asset-rate/src/tests.rs
@@ -0,0 +1,121 @@
+// 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.
+
+//! The crate's tests.
+
+use super::*;
+use crate::pallet as pallet_asset_rate;
+use frame_support::{assert_noop, assert_ok};
+use mock::{new_test_ext, AssetRate, RuntimeOrigin, Test};
+use sp_runtime::FixedU128;
+
+const ASSET_ID: u32 = 42;
+
+#[test]
+fn create_works() {
+	new_test_ext().execute_with(|| {
+		assert!(pallet_asset_rate::ConversionRateToNative::<Test>::get(ASSET_ID).is_none());
+		assert_ok!(AssetRate::create(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(0.1)));
+
+		assert_eq!(
+			pallet_asset_rate::ConversionRateToNative::<Test>::get(ASSET_ID),
+			Some(FixedU128::from_float(0.1))
+		);
+	});
+}
+
+#[test]
+fn create_existing_throws() {
+	new_test_ext().execute_with(|| {
+		assert!(pallet_asset_rate::ConversionRateToNative::<Test>::get(ASSET_ID).is_none());
+		assert_ok!(AssetRate::create(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(0.1)));
+
+		assert_noop!(
+			AssetRate::create(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(0.1)),
+			Error::<Test>::AlreadyExists
+		);
+	});
+}
+
+#[test]
+fn remove_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(AssetRate::create(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(0.1)));
+
+		assert_ok!(AssetRate::remove(RuntimeOrigin::root(), ASSET_ID,));
+		assert!(pallet_asset_rate::ConversionRateToNative::<Test>::get(ASSET_ID).is_none());
+	});
+}
+
+#[test]
+fn remove_unknown_throws() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			AssetRate::remove(RuntimeOrigin::root(), ASSET_ID,),
+			Error::<Test>::UnknownAssetKind
+		);
+	});
+}
+
+#[test]
+fn update_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(AssetRate::create(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(0.1)));
+		assert_ok!(AssetRate::update(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(0.5)));
+
+		assert_eq!(
+			pallet_asset_rate::ConversionRateToNative::<Test>::get(ASSET_ID),
+			Some(FixedU128::from_float(0.5))
+		);
+	});
+}
+
+#[test]
+fn update_unknown_throws() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			AssetRate::update(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(0.5)),
+			Error::<Test>::UnknownAssetKind
+		);
+	});
+}
+
+#[test]
+fn convert_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(AssetRate::create(RuntimeOrigin::root(), ASSET_ID, FixedU128::from_float(2.51)));
+
+		let conversion = <AssetRate as ConversionFromAssetBalance<
+			BalanceOf<Test>,
+			<Test as pallet_asset_rate::Config>::AssetKind,
+			BalanceOf<Test>,
+		>>::from_asset_balance(10, ASSET_ID);
+		assert_eq!(conversion.expect("Conversion rate exists for asset"), 25);
+	});
+}
+
+#[test]
+fn convert_unknown_throws() {
+	new_test_ext().execute_with(|| {
+		let conversion = <AssetRate as ConversionFromAssetBalance<
+			BalanceOf<Test>,
+			<Test as pallet_asset_rate::Config>::AssetKind,
+			BalanceOf<Test>,
+		>>::from_asset_balance(10, ASSET_ID);
+		assert!(conversion.is_err());
+	});
+}
diff --git a/substrate/frame/asset-rate/src/weights.rs b/substrate/frame/asset-rate/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..582e20e56d7dc7f40a0cbb3838622b309e8223d4
--- /dev/null
+++ b/substrate/frame/asset-rate/src/weights.rs
@@ -0,0 +1,133 @@
+// 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.
+
+//! Autogenerated weights for pallet_asset_rate
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_asset_rate
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/asset-rate/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_asset_rate.
+pub trait WeightInfo {
+	fn create() -> Weight;
+	fn update() -> Weight;
+	fn remove() -> Weight;
+}
+
+/// Weights for pallet_asset_rate using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: AssetRate ConversionRateToNative (r:1 w:1)
+	/// Proof: AssetRate ConversionRateToNative (max_values: None, max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3501`
+		// Minimum execution time: 11_700_000 picoseconds.
+		Weight::from_parts(12_158_000, 3501)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: AssetRate ConversionRateToNative (r:1 w:1)
+	/// Proof: AssetRate ConversionRateToNative (max_values: None, max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	fn update() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `137`
+		//  Estimated: `3501`
+		// Minimum execution time: 12_119_000 picoseconds.
+		Weight::from_parts(12_548_000, 3501)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: AssetRate ConversionRateToNative (r:1 w:1)
+	/// Proof: AssetRate ConversionRateToNative (max_values: None, max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	fn remove() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `137`
+		//  Estimated: `3501`
+		// Minimum execution time: 12_541_000 picoseconds.
+		Weight::from_parts(12_956_000, 3501)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: AssetRate ConversionRateToNative (r:1 w:1)
+	/// Proof: AssetRate ConversionRateToNative (max_values: None, max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3501`
+		// Minimum execution time: 11_700_000 picoseconds.
+		Weight::from_parts(12_158_000, 3501)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: AssetRate ConversionRateToNative (r:1 w:1)
+	/// Proof: AssetRate ConversionRateToNative (max_values: None, max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	fn update() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `137`
+		//  Estimated: `3501`
+		// Minimum execution time: 12_119_000 picoseconds.
+		Weight::from_parts(12_548_000, 3501)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: AssetRate ConversionRateToNative (r:1 w:1)
+	/// Proof: AssetRate ConversionRateToNative (max_values: None, max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	fn remove() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `137`
+		//  Estimated: `3501`
+		// Minimum execution time: 12_541_000 picoseconds.
+		Weight::from_parts(12_956_000, 3501)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/assets/Cargo.toml b/substrate/frame/assets/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5795bbb228625284cc5bb98ee47457817db931d4
--- /dev/null
+++ b/substrate/frame/assets/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "pallet-assets"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME asset management pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+# Needed for various traits. In our case, `OnFinalize`.
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+# Needed for type-safe access to storage DB.
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+# `system` module provides us with all sorts of useful stuff and macros depend on it being around.
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+
+[dev-dependencies]
+sp-std = { version = "8.0.0", path = "../../primitives/std" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/assets/README.md b/substrate/frame/assets/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..aae5244953e50638510569af075ca45cbe4539f0
--- /dev/null
+++ b/substrate/frame/assets/README.md
@@ -0,0 +1,125 @@
+# Assets Module
+
+A simple, secure module for dealing with fungible assets.
+
+## Overview
+
+The Assets module provides functionality for asset management of fungible asset classes
+with a fixed supply, including:
+
+* Asset Issuance
+* Asset Transfer
+* Asset Destruction
+
+To use it in your runtime, you need to implement the assets [`assets::Config`](https://docs.rs/pallet-assets/latest/pallet_assets/pallet/trait.Config.html).
+
+The supported dispatchable functions are documented in the [`assets::Call`](https://docs.rs/pallet-assets/latest/pallet_assets/pallet/enum.Call.html) enum.
+
+### Terminology
+
+* **Asset issuance:** The creation of a new asset, whose total supply will belong to the
+  account that issues the asset.
+* **Asset transfer:** The action of transferring assets from one account to another.
+* **Asset destruction:** The process of an account removing its entire holding of an asset.
+* **Fungible asset:** An asset whose units are interchangeable.
+* **Non-fungible asset:** An asset for which each unit has unique characteristics.
+
+### Goals
+
+The assets system in Substrate is designed to make the following possible:
+
+* Issue a unique asset to its creator's account.
+* Move assets between accounts.
+* Remove an account's balance of an asset when requested by that account's owner and update
+  the asset's total supply.
+
+## Interface
+
+### Dispatchable Functions
+
+* `issue` - Issues the total supply of a new fungible asset to the account of the caller of the function.
+* `transfer` - Transfers an `amount` of units of fungible asset `id` from the balance of
+the function caller's account (`origin`) to a `target` account.
+* `destroy` - Destroys the entire holding of a fungible asset `id` associated with the account
+that called the function.
+
+Please refer to the [`Call`](https://docs.rs/pallet-assets/latest/pallet_assets/enum.Call.html) enum and its associated variants for documentation on each function.
+
+### Public Functions
+<!-- Original author of descriptions: @gavofyork -->
+
+* `balance` - Get the asset `id` balance of `who`.
+* `total_supply` - Get the total supply of an asset `id`.
+
+Please refer to the [`Pallet`](https://docs.rs/pallet-assets/latest/pallet_assets/pallet/struct.Pallet.html) struct for details on publicly available functions.
+
+## Usage
+
+The following example shows how to use the Assets module in your runtime by exposing public functions to:
+
+* Issue a new fungible asset for a token distribution event (airdrop).
+* Query the fungible asset holding balance of an account.
+* Query the total supply of a fungible asset that has been issued.
+
+### Prerequisites
+
+Import the Assets module and types and derive your runtime's configuration traits from the Assets module trait.
+
+### Simple Code Snippet
+
+```rust
+use pallet_assets as assets;
+use sp_runtime::ArithmeticError;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config + assets::Config {}
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        pub fn issue_token_airdrop(origin: OriginFor<T>) -> DispatchResult {
+            let sender = ensure_signed(origin)?;
+
+            const ACCOUNT_ALICE: u64 = 1;
+            const ACCOUNT_BOB: u64 = 2;
+            const COUNT_AIRDROP_RECIPIENTS: u64 = 2;
+            const TOKENS_FIXED_SUPPLY: u64 = 100;
+
+            ensure!(!COUNT_AIRDROP_RECIPIENTS.is_zero(), ArithmeticError::DivisionByZero);
+
+            let asset_id = Self::next_asset_id();
+
+            <NextAssetId<T>>::mutate(|asset_id| *asset_id += 1);
+            <Balances<T>>::insert((asset_id, &ACCOUNT_ALICE), TOKENS_FIXED_SUPPLY / COUNT_AIRDROP_RECIPIENTS);
+            <Balances<T>>::insert((asset_id, &ACCOUNT_BOB), TOKENS_FIXED_SUPPLY / COUNT_AIRDROP_RECIPIENTS);
+            <TotalSupply<T>>::insert(asset_id, TOKENS_FIXED_SUPPLY);
+
+            Self::deposit_event(Event::Issued(asset_id, sender, TOKENS_FIXED_SUPPLY));
+            Ok(())
+        }
+    }
+}
+```
+
+## Assumptions
+
+Below are assumptions that must be held when using this module.  If any of
+them are violated, the behavior of this module is undefined.
+
+* The total count of assets should be less than
+  `Config::AssetId::max_value()`.
+
+## Related Modules
+
+* [`System`](https://docs.rs/frame-system/latest/frame_system/)
+* [`Support`](https://docs.rs/frame-support/latest/frame_support/)
+
+License: Apache-2.0
diff --git a/substrate/frame/assets/src/benchmarking.rs b/substrate/frame/assets/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..376f19139ab9b6dca29fcbb4bd6427baaffc6bd4
--- /dev/null
+++ b/substrate/frame/assets/src/benchmarking.rs
@@ -0,0 +1,555 @@
+// 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 pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelist_account, whitelisted_caller, BenchmarkError,
+};
+use frame_support::{
+	dispatch::UnfilteredDispatchable,
+	traits::{EnsureOrigin, Get},
+};
+use frame_system::RawOrigin as SystemOrigin;
+use sp_runtime::traits::Bounded;
+use sp_std::prelude::*;
+
+use crate::Pallet as Assets;
+
+const SEED: u32 = 0;
+
+fn default_asset_id<T: Config<I>, I: 'static>() -> T::AssetIdParameter {
+	T::BenchmarkHelper::create_asset_id_parameter(0)
+}
+
+fn create_default_asset<T: Config<I>, I: 'static>(
+	is_sufficient: bool,
+) -> (T::AssetIdParameter, T::AccountId, AccountIdLookupOf<T>) {
+	let asset_id = default_asset_id::<T, I>();
+	let caller: T::AccountId = whitelisted_caller();
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let root = SystemOrigin::Root.into();
+	assert!(Assets::<T, I>::force_create(
+		root,
+		asset_id,
+		caller_lookup.clone(),
+		is_sufficient,
+		1u32.into(),
+	)
+	.is_ok());
+	(asset_id, caller, caller_lookup)
+}
+
+fn create_default_minted_asset<T: Config<I>, I: 'static>(
+	is_sufficient: bool,
+	amount: T::Balance,
+) -> (T::AssetIdParameter, T::AccountId, AccountIdLookupOf<T>) {
+	let (asset_id, caller, caller_lookup) = create_default_asset::<T, I>(is_sufficient);
+	if !is_sufficient {
+		T::Currency::make_free_balance_be(&caller, T::Currency::minimum_balance());
+	}
+	assert!(Assets::<T, I>::mint(
+		SystemOrigin::Signed(caller.clone()).into(),
+		asset_id,
+		caller_lookup.clone(),
+		amount,
+	)
+	.is_ok());
+	(asset_id, caller, caller_lookup)
+}
+
+fn swap_is_sufficient<T: Config<I>, I: 'static>(s: &mut bool) {
+	let asset_id = default_asset_id::<T, I>();
+	Asset::<T, I>::mutate(&asset_id.into(), |maybe_a| {
+		if let Some(ref mut a) = maybe_a {
+			sp_std::mem::swap(s, &mut a.is_sufficient)
+		}
+	});
+}
+
+fn add_sufficients<T: Config<I>, I: 'static>(minter: T::AccountId, n: u32) {
+	let asset_id = default_asset_id::<T, I>();
+	let origin = SystemOrigin::Signed(minter);
+	let mut s = true;
+	swap_is_sufficient::<T, I>(&mut s);
+	for i in 0..n {
+		let target = account("sufficient", i, SEED);
+		let target_lookup = T::Lookup::unlookup(target);
+		assert!(Assets::<T, I>::mint(
+			origin.clone().into(),
+			asset_id,
+			target_lookup,
+			100u32.into()
+		)
+		.is_ok());
+	}
+	swap_is_sufficient::<T, I>(&mut s);
+}
+
+fn add_approvals<T: Config<I>, I: 'static>(minter: T::AccountId, n: u32) {
+	let asset_id = default_asset_id::<T, I>();
+	T::Currency::deposit_creating(
+		&minter,
+		T::ApprovalDeposit::get() * n.into() + T::Currency::minimum_balance(),
+	);
+	let minter_lookup = T::Lookup::unlookup(minter.clone());
+	let origin = SystemOrigin::Signed(minter);
+	Assets::<T, I>::mint(origin.clone().into(), asset_id, minter_lookup, (100 * (n + 1)).into())
+		.unwrap();
+	let enough = T::Currency::minimum_balance();
+	for i in 0..n {
+		let target = account("approval", i, SEED);
+		T::Currency::make_free_balance_be(&target, enough);
+		let target_lookup = T::Lookup::unlookup(target);
+		Assets::<T, I>::approve_transfer(
+			origin.clone().into(),
+			asset_id,
+			target_lookup,
+			100u32.into(),
+		)
+		.unwrap();
+	}
+}
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn assert_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_has_event(generic_event.into());
+}
+
+benchmarks_instance_pallet! {
+	create {
+		let asset_id = default_asset_id::<T, I>();
+		let origin = T::CreateOrigin::try_successful_origin(&asset_id.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let caller = T::CreateOrigin::ensure_origin(origin.clone(), &asset_id.into()).unwrap();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+	}: _<T::RuntimeOrigin>(origin, asset_id, caller_lookup, 1u32.into())
+	verify {
+		assert_last_event::<T, I>(Event::Created { asset_id: asset_id.into(), creator: caller.clone(), owner: caller }.into());
+	}
+
+	force_create {
+		let asset_id = default_asset_id::<T, I>();
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+	}: _(SystemOrigin::Root, asset_id, caller_lookup, true, 1u32.into())
+	verify {
+		assert_last_event::<T, I>(Event::ForceCreated { asset_id: asset_id.into(), owner: caller }.into());
+	}
+
+	start_destroy {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		Assets::<T, I>::freeze_asset(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset_id,
+		)?;
+	}:_(SystemOrigin::Signed(caller), asset_id)
+	verify {
+		assert_last_event::<T, I>(Event::DestructionStarted { asset_id: asset_id.into() }.into());
+	}
+
+	destroy_accounts {
+		let c in 0 .. T::RemoveItemsLimit::get();
+		let (asset_id, caller, _) = create_default_asset::<T, I>(true);
+		add_sufficients::<T, I>(caller.clone(), c);
+		Assets::<T, I>::freeze_asset(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset_id,
+		)?;
+		Assets::<T,I>::start_destroy(SystemOrigin::Signed(caller.clone()).into(), asset_id)?;
+	}:_(SystemOrigin::Signed(caller), asset_id)
+	verify {
+		assert_last_event::<T, I>(Event::AccountsDestroyed {
+			asset_id: asset_id.into(),
+			accounts_destroyed: c,
+			accounts_remaining: 0,
+		}.into());
+	}
+
+	destroy_approvals {
+		let a in 0 .. T::RemoveItemsLimit::get();
+		let (asset_id, caller, _) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		add_approvals::<T, I>(caller.clone(), a);
+		Assets::<T, I>::freeze_asset(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset_id,
+		)?;
+		Assets::<T,I>::start_destroy(SystemOrigin::Signed(caller.clone()).into(), asset_id)?;
+	}:_(SystemOrigin::Signed(caller), asset_id)
+	verify {
+		assert_last_event::<T, I>(Event::ApprovalsDestroyed {
+			asset_id: asset_id.into(),
+			approvals_destroyed: a,
+			approvals_remaining: 0,
+		}.into());
+	}
+
+	finish_destroy {
+		let (asset_id, caller, caller_lookup) = create_default_asset::<T, I>(true);
+		Assets::<T, I>::freeze_asset(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset_id,
+		)?;
+		Assets::<T,I>::start_destroy(SystemOrigin::Signed(caller.clone()).into(), asset_id)?;
+	}:_(SystemOrigin::Signed(caller), asset_id)
+	verify {
+		assert_last_event::<T, I>(Event::Destroyed {
+			asset_id: asset_id.into(),
+		}.into()
+		);
+	}
+
+	mint {
+		let (asset_id, caller, caller_lookup) = create_default_asset::<T, I>(true);
+		let amount = T::Balance::from(100u32);
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, caller_lookup, amount)
+	verify {
+		assert_last_event::<T, I>(Event::Issued { asset_id: asset_id.into(), owner: caller, amount }.into());
+	}
+
+	burn {
+		let amount = T::Balance::from(100u32);
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, amount);
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, caller_lookup, amount)
+	verify {
+		assert_last_event::<T, I>(Event::Burned { asset_id: asset_id.into(), owner: caller, balance: amount }.into());
+	}
+
+	transfer {
+		let amount = T::Balance::from(100u32);
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, amount);
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, target_lookup, amount)
+	verify {
+		assert_last_event::<T, I>(Event::Transferred { asset_id: asset_id.into(), from: caller, to: target, amount }.into());
+	}
+
+	transfer_keep_alive {
+		let mint_amount = T::Balance::from(200u32);
+		let amount = T::Balance::from(100u32);
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, mint_amount);
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, target_lookup, amount)
+	verify {
+		assert!(frame_system::Pallet::<T>::account_exists(&caller));
+		assert_last_event::<T, I>(Event::Transferred { asset_id: asset_id.into(), from: caller, to: target, amount }.into());
+	}
+
+	force_transfer {
+		let amount = T::Balance::from(100u32);
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, amount);
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, caller_lookup, target_lookup, amount)
+	verify {
+		assert_last_event::<T, I>(
+			Event::Transferred { asset_id: asset_id.into(), from: caller, to: target, amount }.into()
+		);
+	}
+
+	freeze {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, caller_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::Frozen { asset_id: asset_id.into(), who: caller }.into());
+	}
+
+	thaw {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		Assets::<T, I>::freeze(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset_id,
+			caller_lookup.clone(),
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, caller_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::Thawed { asset_id: asset_id.into(), who: caller }.into());
+	}
+
+	freeze_asset {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id)
+	verify {
+		assert_last_event::<T, I>(Event::AssetFrozen { asset_id: asset_id.into() }.into());
+	}
+
+	thaw_asset {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		Assets::<T, I>::freeze_asset(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset_id,
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id)
+	verify {
+		assert_last_event::<T, I>(Event::AssetThawed { asset_id: asset_id.into() }.into());
+	}
+
+	transfer_ownership {
+		let (asset_id, caller, _) = create_default_asset::<T, I>(true);
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+	}: _(SystemOrigin::Signed(caller), asset_id, target_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::OwnerChanged { asset_id: asset_id.into(), owner: target }.into());
+	}
+
+	set_team {
+		let (asset_id, caller, _) = create_default_asset::<T, I>(true);
+		let target0 = T::Lookup::unlookup(account("target", 0, SEED));
+		let target1 = T::Lookup::unlookup(account("target", 1, SEED));
+		let target2 = T::Lookup::unlookup(account("target", 2, SEED));
+	}: _(SystemOrigin::Signed(caller), asset_id, target0, target1, target2)
+	verify {
+		assert_last_event::<T, I>(Event::TeamChanged {
+			asset_id: asset_id.into(),
+			issuer: account("target", 0, SEED),
+			admin: account("target", 1, SEED),
+			freezer: account("target", 2, SEED),
+		}.into());
+	}
+
+	set_metadata {
+		let n in 0 .. T::StringLimit::get();
+		let s in 0 .. T::StringLimit::get();
+
+		let name = vec![0u8; n as usize];
+		let symbol = vec![0u8; s as usize];
+		let decimals = 12;
+
+		let (asset_id, caller, _) = create_default_asset::<T, I>(true);
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+	}: _(SystemOrigin::Signed(caller), asset_id, name.clone(), symbol.clone(), decimals)
+	verify {
+		assert_last_event::<T, I>(Event::MetadataSet { asset_id: asset_id.into(), name, symbol, decimals, is_frozen: false }.into());
+	}
+
+	clear_metadata {
+		let (asset_id, caller, _) = create_default_asset::<T, I>(true);
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+		let dummy = vec![0u8; T::StringLimit::get() as usize];
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		Assets::<T, I>::set_metadata(origin, asset_id, dummy.clone(), dummy, 12)?;
+	}: _(SystemOrigin::Signed(caller), asset_id)
+	verify {
+		assert_last_event::<T, I>(Event::MetadataCleared { asset_id: asset_id.into() }.into());
+	}
+
+	force_set_metadata {
+		let n in 0 .. T::StringLimit::get();
+		let s in 0 .. T::StringLimit::get();
+
+		let name = vec![0u8; n as usize];
+		let symbol = vec![0u8; s as usize];
+		let decimals = 12;
+
+		let (asset_id, _, _) = create_default_asset::<T, I>(true);
+
+		let origin =
+			T::ForceOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::force_set_metadata {
+			id: asset_id,
+			name: name.clone(),
+			symbol: symbol.clone(),
+			decimals,
+			is_frozen: false,
+		};
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::MetadataSet { asset_id: asset_id.into(), name, symbol, decimals, is_frozen: false }.into());
+	}
+
+	force_clear_metadata {
+		let (asset_id, caller, _) = create_default_asset::<T, I>(true);
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+		let dummy = vec![0u8; T::StringLimit::get() as usize];
+		let origin = SystemOrigin::Signed(caller).into();
+		Assets::<T, I>::set_metadata(origin, asset_id, dummy.clone(), dummy, 12)?;
+
+		let origin =
+			T::ForceOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::force_clear_metadata { id: asset_id };
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::MetadataCleared { asset_id: asset_id.into() }.into());
+	}
+
+	force_asset_status {
+		let (asset_id, caller, caller_lookup) = create_default_asset::<T, I>(true);
+
+		let origin =
+			T::ForceOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::force_asset_status {
+			id: asset_id,
+			owner: caller_lookup.clone(),
+			issuer: caller_lookup.clone(),
+			admin: caller_lookup.clone(),
+			freezer: caller_lookup,
+			min_balance: 100u32.into(),
+			is_sufficient: true,
+			is_frozen: false,
+		};
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::AssetStatusChanged { asset_id: asset_id.into() }.into());
+	}
+
+	approve_transfer {
+		let (asset_id, caller, _) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let amount = 100u32.into();
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, delegate_lookup, amount)
+	verify {
+		assert_last_event::<T, I>(Event::ApprovedTransfer { asset_id: asset_id.into(), source: caller, delegate, amount }.into());
+	}
+
+	transfer_approved {
+		let (asset_id, owner, owner_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		T::Currency::make_free_balance_be(&owner, DepositBalanceOf::<T, I>::max_value());
+
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		whitelist_account!(delegate);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let amount = 100u32.into();
+		let origin = SystemOrigin::Signed(owner.clone()).into();
+		Assets::<T, I>::approve_transfer(origin, asset_id, delegate_lookup, amount)?;
+
+		let dest: T::AccountId = account("dest", 0, SEED);
+		let dest_lookup = T::Lookup::unlookup(dest.clone());
+	}: _(SystemOrigin::Signed(delegate.clone()), asset_id, owner_lookup, dest_lookup, amount)
+	verify {
+		assert!(T::Currency::reserved_balance(&owner).is_zero());
+		assert_event::<T, I>(Event::Transferred { asset_id: asset_id.into(), from: owner, to: dest, amount }.into());
+	}
+
+	cancel_approval {
+		let (asset_id, caller, _) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let amount = 100u32.into();
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		Assets::<T, I>::approve_transfer(origin, asset_id, delegate_lookup.clone(), amount)?;
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, delegate_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::ApprovalCancelled { asset_id: asset_id.into(), owner: caller, delegate }.into());
+	}
+
+	force_cancel_approval {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let amount = 100u32.into();
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		Assets::<T, I>::approve_transfer(origin, asset_id, delegate_lookup.clone(), amount)?;
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, caller_lookup, delegate_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::ApprovalCancelled { asset_id: asset_id.into(), owner: caller, delegate }.into());
+	}
+
+	set_min_balance {
+		let (asset_id, caller, caller_lookup) = create_default_asset::<T, I>(false);
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, 50u32.into())
+	verify {
+		assert_last_event::<T, I>(Event::AssetMinBalanceChanged { asset_id: asset_id.into(), new_min_balance: 50u32.into() }.into());
+	}
+
+	touch {
+		let (asset_id, asset_owner, asset_owner_lookup) = create_default_asset::<T, I>(false);
+		let new_account: T::AccountId = account("newaccount", 1, SEED);
+		T::Currency::make_free_balance_be(&new_account, DepositBalanceOf::<T, I>::max_value());
+		assert_ne!(asset_owner, new_account);
+		assert!(!Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}: _(SystemOrigin::Signed(new_account.clone()), asset_id)
+	verify {
+		assert!(Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}
+
+	touch_other {
+		let (asset_id, asset_owner, asset_owner_lookup) = create_default_asset::<T, I>(false);
+		let new_account: T::AccountId = account("newaccount", 1, SEED);
+		let new_account_lookup = T::Lookup::unlookup(new_account.clone());
+		T::Currency::make_free_balance_be(&asset_owner, DepositBalanceOf::<T, I>::max_value());
+		assert_ne!(asset_owner, new_account);
+		assert!(!Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}: _(SystemOrigin::Signed(asset_owner.clone()), asset_id, new_account_lookup)
+	verify {
+		assert!(Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}
+
+	refund {
+		let (asset_id, asset_owner, asset_owner_lookup) = create_default_asset::<T, I>(false);
+		let new_account: T::AccountId = account("newaccount", 1, SEED);
+		T::Currency::make_free_balance_be(&new_account, DepositBalanceOf::<T, I>::max_value());
+		assert_ne!(asset_owner, new_account);
+		assert!(Assets::<T, I>::touch(
+			SystemOrigin::Signed(new_account.clone()).into(),
+			asset_id
+		).is_ok());
+		// `touch` should reserve balance of the caller according to the `AssetAccountDeposit` amount...
+		assert_eq!(T::Currency::reserved_balance(&new_account), T::AssetAccountDeposit::get());
+		// ...and also create an `Account` entry.
+		assert!(Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}: _(SystemOrigin::Signed(new_account.clone()), asset_id, true)
+	verify {
+		// `refund`ing should of course repatriate the reserve
+		assert!(T::Currency::reserved_balance(&new_account).is_zero());
+	}
+
+	refund_other {
+		let (asset_id, asset_owner, asset_owner_lookup) = create_default_asset::<T, I>(false);
+		let new_account: T::AccountId = account("newaccount", 1, SEED);
+		let new_account_lookup = T::Lookup::unlookup(new_account.clone());
+		T::Currency::make_free_balance_be(&asset_owner, DepositBalanceOf::<T, I>::max_value());
+		assert_ne!(asset_owner, new_account);
+		assert!(Assets::<T, I>::touch_other(
+			SystemOrigin::Signed(asset_owner.clone()).into(),
+			asset_id,
+			new_account_lookup.clone()
+		).is_ok());
+		// `touch` should reserve balance of the caller according to the `AssetAccountDeposit` amount...
+		assert_eq!(T::Currency::reserved_balance(&asset_owner), T::AssetAccountDeposit::get());
+		assert!(Account::<T, I>::contains_key(asset_id.into(), &new_account));
+	}: _(SystemOrigin::Signed(asset_owner.clone()), asset_id, new_account_lookup.clone())
+	verify {
+		// this should repatriate the reserved balance of the freezer
+		assert!(T::Currency::reserved_balance(&asset_owner).is_zero());
+	}
+
+	block {
+		let (asset_id, caller, caller_lookup) = create_default_minted_asset::<T, I>(true, 100u32.into());
+	}: _(SystemOrigin::Signed(caller.clone()), asset_id, caller_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::Blocked { asset_id: asset_id.into(), who: caller }.into());
+	}
+
+	impl_benchmark_test_suite!(Assets, crate::mock::new_test_ext(), crate::mock::Test)
+}
diff --git a/substrate/frame/assets/src/extra_mutator.rs b/substrate/frame/assets/src/extra_mutator.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a44df5f0c661ffc83b0f9c0df68d14bcfa0bcab
--- /dev/null
+++ b/substrate/frame/assets/src/extra_mutator.rs
@@ -0,0 +1,98 @@
+// 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.
+
+//! Datatype for easy mutation of the extra "sidecar" data.
+
+use super::*;
+
+/// A mutator type allowing inspection and possible modification of the extra "sidecar" data.
+///
+/// This may be used as a `Deref` for the pallet's extra data. If mutated (using `DerefMut`), then
+/// any uncommitted changes (see `commit` function) will be automatically committed to storage when
+/// dropped. Changes, even after committed, may be reverted to their original values with the
+/// `revert` function.
+pub struct ExtraMutator<T: Config<I>, I: 'static = ()> {
+	id: T::AssetId,
+	who: T::AccountId,
+	original: T::Extra,
+	pending: Option<T::Extra>,
+}
+
+impl<T: Config<I>, I: 'static> Drop for ExtraMutator<T, I> {
+	fn drop(&mut self) {
+		debug_assert!(self.commit().is_ok(), "attempt to write to non-existent asset account");
+	}
+}
+
+impl<T: Config<I>, I: 'static> sp_std::ops::Deref for ExtraMutator<T, I> {
+	type Target = T::Extra;
+	fn deref(&self) -> &T::Extra {
+		match self.pending {
+			Some(ref value) => value,
+			None => &self.original,
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> sp_std::ops::DerefMut for ExtraMutator<T, I> {
+	fn deref_mut(&mut self) -> &mut T::Extra {
+		if self.pending.is_none() {
+			self.pending = Some(self.original.clone());
+		}
+		self.pending.as_mut().unwrap()
+	}
+}
+
+impl<T: Config<I>, I: 'static> ExtraMutator<T, I> {
+	pub(super) fn maybe_new(
+		id: T::AssetId,
+		who: impl sp_std::borrow::Borrow<T::AccountId>,
+	) -> Option<ExtraMutator<T, I>> {
+		if let Some(a) = Account::<T, I>::get(&id, who.borrow()) {
+			Some(ExtraMutator::<T, I> {
+				id,
+				who: who.borrow().clone(),
+				original: a.extra,
+				pending: None,
+			})
+		} else {
+			None
+		}
+	}
+
+	/// Commit any changes to storage.
+	pub fn commit(&mut self) -> Result<(), ()> {
+		if let Some(extra) = self.pending.take() {
+			Account::<T, I>::try_mutate(&self.id, &self.who, |maybe_account| {
+				maybe_account.as_mut().ok_or(()).map(|account| account.extra = extra)
+			})
+		} else {
+			Ok(())
+		}
+	}
+
+	/// Revert any changes, even those already committed by `self` and drop self.
+	pub fn revert(mut self) -> Result<(), ()> {
+		self.pending = None;
+		Account::<T, I>::try_mutate(&self.id, &self.who, |maybe_account| {
+			maybe_account
+				.as_mut()
+				.ok_or(())
+				.map(|account| account.extra = self.original.clone())
+		})
+	}
+}
diff --git a/substrate/frame/assets/src/functions.rs b/substrate/frame/assets/src/functions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c2c1b6839060e91fc8f50537d09db8b6f9c50a71
--- /dev/null
+++ b/substrate/frame/assets/src/functions.rs
@@ -0,0 +1,1016 @@
+// 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.
+
+//! Functions for the Assets pallet.
+
+use super::*;
+use frame_support::{defensive, traits::Get, BoundedVec};
+
+#[must_use]
+pub(super) enum DeadConsequence {
+	Remove,
+	Keep,
+}
+
+use DeadConsequence::*;
+
+// The main implementation block for the module.
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	// Public immutables
+
+	/// Return the extra "sid-car" data for `id`/`who`, or `None` if the account doesn't exist.
+	pub fn adjust_extra(
+		id: T::AssetId,
+		who: impl sp_std::borrow::Borrow<T::AccountId>,
+	) -> Option<ExtraMutator<T, I>> {
+		ExtraMutator::maybe_new(id, who)
+	}
+
+	/// Get the asset `id` balance of `who`, or zero if the asset-account doesn't exist.
+	pub fn balance(id: T::AssetId, who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
+		Self::maybe_balance(id, who).unwrap_or_default()
+	}
+
+	/// Get the asset `id` balance of `who` if the asset-account exists.
+	pub fn maybe_balance(
+		id: T::AssetId,
+		who: impl sp_std::borrow::Borrow<T::AccountId>,
+	) -> Option<T::Balance> {
+		Account::<T, I>::get(id, who.borrow()).map(|a| a.balance)
+	}
+
+	/// Get the total supply of an asset `id`.
+	pub fn total_supply(id: T::AssetId) -> T::Balance {
+		Self::maybe_total_supply(id).unwrap_or_default()
+	}
+
+	/// Get the total supply of an asset `id` if the asset exists.
+	pub fn maybe_total_supply(id: T::AssetId) -> Option<T::Balance> {
+		Asset::<T, I>::get(id).map(|x| x.supply)
+	}
+
+	pub(super) fn new_account(
+		who: &T::AccountId,
+		d: &mut AssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T, I>>,
+		maybe_deposit: Option<(&T::AccountId, DepositBalanceOf<T, I>)>,
+	) -> Result<ExistenceReasonOf<T, I>, DispatchError> {
+		let accounts = d.accounts.checked_add(1).ok_or(ArithmeticError::Overflow)?;
+		let reason = if let Some((depositor, deposit)) = maybe_deposit {
+			if depositor == who {
+				ExistenceReason::DepositHeld(deposit)
+			} else {
+				ExistenceReason::DepositFrom(depositor.clone(), deposit)
+			}
+		} else if d.is_sufficient {
+			frame_system::Pallet::<T>::inc_sufficients(who);
+			d.sufficients += 1;
+			ExistenceReason::Sufficient
+		} else {
+			frame_system::Pallet::<T>::inc_consumers(who)
+				.map_err(|_| Error::<T, I>::UnavailableConsumer)?;
+			// We ensure that we can still increment consumers once more because we could otherwise
+			// allow accidental usage of all consumer references which could cause grief.
+			if !frame_system::Pallet::<T>::can_inc_consumer(who) {
+				frame_system::Pallet::<T>::dec_consumers(who);
+				return Err(Error::<T, I>::UnavailableConsumer.into())
+			}
+			ExistenceReason::Consumer
+		};
+		d.accounts = accounts;
+		Ok(reason)
+	}
+
+	pub(super) fn dead_account(
+		who: &T::AccountId,
+		d: &mut AssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T, I>>,
+		reason: &ExistenceReasonOf<T, I>,
+		force: bool,
+	) -> DeadConsequence {
+		use ExistenceReason::*;
+		match *reason {
+			Consumer => frame_system::Pallet::<T>::dec_consumers(who),
+			Sufficient => {
+				d.sufficients = d.sufficients.saturating_sub(1);
+				frame_system::Pallet::<T>::dec_sufficients(who);
+			},
+			DepositRefunded => {},
+			DepositHeld(_) | DepositFrom(..) if !force => return Keep,
+			DepositHeld(_) | DepositFrom(..) => {},
+		}
+		d.accounts = d.accounts.saturating_sub(1);
+		Remove
+	}
+
+	/// Returns `true` when the balance of `account` can be increased by `amount`.
+	///
+	/// - `id`: The id of the asset that should be increased.
+	/// - `who`: The account of which the balance should be increased.
+	/// - `amount`: The amount by which the balance should be increased.
+	/// - `increase_supply`: Will the supply of the asset be increased by `amount` at the same time
+	///   as crediting the `account`.
+	pub(super) fn can_increase(
+		id: T::AssetId,
+		who: &T::AccountId,
+		amount: T::Balance,
+		increase_supply: bool,
+	) -> DepositConsequence {
+		let details = match Asset::<T, I>::get(&id) {
+			Some(details) => details,
+			None => return DepositConsequence::UnknownAsset,
+		};
+		if increase_supply && details.supply.checked_add(&amount).is_none() {
+			return DepositConsequence::Overflow
+		}
+		if let Some(account) = Account::<T, I>::get(id, who) {
+			if account.status.is_blocked() {
+				return DepositConsequence::Blocked
+			}
+			if account.balance.checked_add(&amount).is_none() {
+				return DepositConsequence::Overflow
+			}
+		} else {
+			if amount < details.min_balance {
+				return DepositConsequence::BelowMinimum
+			}
+			if !details.is_sufficient && !frame_system::Pallet::<T>::can_accrue_consumers(who, 2) {
+				return DepositConsequence::CannotCreate
+			}
+			if details.is_sufficient && details.sufficients.checked_add(1).is_none() {
+				return DepositConsequence::Overflow
+			}
+		}
+
+		DepositConsequence::Success
+	}
+
+	/// Return the consequence of a withdraw.
+	pub(super) fn can_decrease(
+		id: T::AssetId,
+		who: &T::AccountId,
+		amount: T::Balance,
+		keep_alive: bool,
+	) -> WithdrawConsequence<T::Balance> {
+		use WithdrawConsequence::*;
+		let details = match Asset::<T, I>::get(&id) {
+			Some(details) => details,
+			None => return UnknownAsset,
+		};
+		if details.supply.checked_sub(&amount).is_none() {
+			return Underflow
+		}
+		if details.status == AssetStatus::Frozen {
+			return Frozen
+		}
+		if amount.is_zero() {
+			return Success
+		}
+		let account = match Account::<T, I>::get(&id, who) {
+			Some(a) => a,
+			None => return BalanceLow,
+		};
+		if account.status.is_frozen() {
+			return Frozen
+		}
+		if let Some(rest) = account.balance.checked_sub(&amount) {
+			if let Some(frozen) = T::Freezer::frozen_balance(id.clone(), who) {
+				match frozen.checked_add(&details.min_balance) {
+					Some(required) if rest < required => return Frozen,
+					None => return Overflow,
+					_ => {},
+				}
+			}
+
+			if rest < details.min_balance {
+				if keep_alive {
+					WouldDie
+				} else {
+					ReducedToZero(rest)
+				}
+			} else {
+				Success
+			}
+		} else {
+			BalanceLow
+		}
+	}
+
+	// Maximum `amount` that can be passed into `can_withdraw` to result in a `WithdrawConsequence`
+	// of `Success`.
+	pub(super) fn reducible_balance(
+		id: T::AssetId,
+		who: &T::AccountId,
+		keep_alive: bool,
+	) -> Result<T::Balance, DispatchError> {
+		let details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+
+		let account = Account::<T, I>::get(&id, who).ok_or(Error::<T, I>::NoAccount)?;
+		ensure!(!account.status.is_frozen(), Error::<T, I>::Frozen);
+
+		let amount = if let Some(frozen) = T::Freezer::frozen_balance(id, who) {
+			// Frozen balance: account CANNOT be deleted
+			let required =
+				frozen.checked_add(&details.min_balance).ok_or(ArithmeticError::Overflow)?;
+			account.balance.saturating_sub(required)
+		} else {
+			if keep_alive {
+				// We want to keep the account around.
+				account.balance.saturating_sub(details.min_balance)
+			} else {
+				// Don't care if the account dies
+				account.balance
+			}
+		};
+		Ok(amount.min(details.supply))
+	}
+
+	/// Make preparatory checks for debiting some funds from an account. Flags indicate requirements
+	/// of the debit.
+	///
+	/// - `amount`: The amount desired to be debited. The actual amount returned for debit may be
+	///   less (in the case of `best_effort` being `true`) or greater by up to the minimum balance
+	///   less one.
+	/// - `keep_alive`: Require that `target` must stay alive.
+	/// - `respect_freezer`: Respect any freezes on the account or token (or not).
+	/// - `best_effort`: The debit amount may be less than `amount`.
+	///
+	/// On success, the amount which should be debited (this will always be at least `amount` unless
+	/// `best_effort` is `true`) together with an optional value indicating the argument which must
+	/// be passed into the `melted` function of the `T::Freezer` if `Some`.
+	///
+	/// If no valid debit can be made then return an `Err`.
+	pub(super) fn prep_debit(
+		id: T::AssetId,
+		target: &T::AccountId,
+		amount: T::Balance,
+		f: DebitFlags,
+	) -> Result<T::Balance, DispatchError> {
+		let actual = Self::reducible_balance(id.clone(), target, f.keep_alive)?.min(amount);
+		ensure!(f.best_effort || actual >= amount, Error::<T, I>::BalanceLow);
+
+		let conseq = Self::can_decrease(id, target, actual, f.keep_alive);
+		let actual = match conseq.into_result(f.keep_alive) {
+			Ok(dust) => actual.saturating_add(dust), //< guaranteed by reducible_balance
+			Err(e) => {
+				debug_assert!(false, "passed from reducible_balance; qed");
+				return Err(e)
+			},
+		};
+
+		Ok(actual)
+	}
+
+	/// Make preparatory checks for crediting some funds from an account. Flags indicate
+	/// requirements of the credit.
+	///
+	/// - `amount`: The amount desired to be credited.
+	/// - `debit`: The amount by which some other account has been debited. If this is greater than
+	///   `amount`, then the `burn_dust` parameter takes effect.
+	/// - `burn_dust`: Indicates that in the case of debit being greater than amount, the additional
+	///   (dust) value should be burned, rather than credited.
+	///
+	/// On success, the amount which should be credited (this will always be at least `amount`)
+	/// together with an optional value indicating the value which should be burned. The latter
+	/// will always be `None` as long as `burn_dust` is `false` or `debit` is no greater than
+	/// `amount`.
+	///
+	/// If no valid credit can be made then return an `Err`.
+	pub(super) fn prep_credit(
+		id: T::AssetId,
+		dest: &T::AccountId,
+		amount: T::Balance,
+		debit: T::Balance,
+		burn_dust: bool,
+	) -> Result<(T::Balance, Option<T::Balance>), DispatchError> {
+		let (credit, maybe_burn) = match (burn_dust, debit.checked_sub(&amount)) {
+			(true, Some(dust)) => (amount, Some(dust)),
+			_ => (debit, None),
+		};
+		Self::can_increase(id, dest, credit, false).into_result()?;
+		Ok((credit, maybe_burn))
+	}
+
+	/// Creates an account for `who` to hold asset `id` with a zero balance and takes a deposit.
+	///
+	/// When `check_depositor` is set to true, the depositor must be either the asset's Admin or
+	/// Freezer, otherwise the depositor can be any account.
+	pub(super) fn do_touch(
+		id: T::AssetId,
+		who: T::AccountId,
+		depositor: T::AccountId,
+		check_depositor: bool,
+	) -> DispatchResult {
+		ensure!(!Account::<T, I>::contains_key(&id, &who), Error::<T, I>::AlreadyExists);
+		let deposit = T::AssetAccountDeposit::get();
+		let mut details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+		ensure!(
+			!check_depositor || &depositor == &details.admin || &depositor == &details.freezer,
+			Error::<T, I>::NoPermission
+		);
+		let reason = Self::new_account(&who, &mut details, Some((&depositor, deposit)))?;
+		T::Currency::reserve(&depositor, deposit)?;
+		Asset::<T, I>::insert(&id, details);
+		Account::<T, I>::insert(
+			&id,
+			&who,
+			AssetAccountOf::<T, I> {
+				balance: Zero::zero(),
+				status: AccountStatus::Liquid,
+				reason,
+				extra: T::Extra::default(),
+			},
+		);
+		Self::deposit_event(Event::Touched { asset_id: id, who, depositor });
+		Ok(())
+	}
+
+	/// Returns a deposit or a consumer reference, destroying an asset-account.
+	/// Non-zero balance accounts refunded and destroyed only if `allow_burn` is true.
+	pub(super) fn do_refund(id: T::AssetId, who: T::AccountId, allow_burn: bool) -> DispatchResult {
+		use AssetStatus::*;
+		use ExistenceReason::*;
+		let mut account = Account::<T, I>::get(&id, &who).ok_or(Error::<T, I>::NoDeposit)?;
+		ensure!(matches!(account.reason, Consumer | DepositHeld(..)), Error::<T, I>::NoDeposit);
+		let mut details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(matches!(details.status, Live | Frozen), Error::<T, I>::IncorrectStatus);
+		ensure!(account.balance.is_zero() || allow_burn, Error::<T, I>::WouldBurn);
+
+		if let Some(deposit) = account.reason.take_deposit() {
+			T::Currency::unreserve(&who, deposit);
+		}
+
+		if let Remove = Self::dead_account(&who, &mut details, &account.reason, false) {
+			Account::<T, I>::remove(&id, &who);
+		} else {
+			debug_assert!(false, "refund did not result in dead account?!");
+			// deposit may have been refunded, need to update `Account`
+			Account::<T, I>::insert(id, &who, account);
+			return Ok(())
+		}
+		Asset::<T, I>::insert(&id, details);
+		// Executing a hook here is safe, since it is not in a `mutate`.
+		T::Freezer::died(id, &who);
+		Ok(())
+	}
+
+	/// Returns a `DepositFrom` of an account only if balance is zero.
+	pub(super) fn do_refund_other(
+		id: T::AssetId,
+		who: &T::AccountId,
+		caller: &T::AccountId,
+	) -> DispatchResult {
+		let mut account = Account::<T, I>::get(&id, &who).ok_or(Error::<T, I>::NoDeposit)?;
+		let (depositor, deposit) =
+			account.reason.take_deposit_from().ok_or(Error::<T, I>::NoDeposit)?;
+		let mut details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+		ensure!(!account.status.is_frozen(), Error::<T, I>::Frozen);
+		ensure!(caller == &depositor || caller == &details.admin, Error::<T, I>::NoPermission);
+		ensure!(account.balance.is_zero(), Error::<T, I>::WouldBurn);
+
+		T::Currency::unreserve(&depositor, deposit);
+
+		if let Remove = Self::dead_account(&who, &mut details, &account.reason, false) {
+			Account::<T, I>::remove(&id, &who);
+		} else {
+			debug_assert!(false, "refund did not result in dead account?!");
+			// deposit may have been refunded, need to update `Account`
+			Account::<T, I>::insert(&id, &who, account);
+			return Ok(())
+		}
+		Asset::<T, I>::insert(&id, details);
+		// Executing a hook here is safe, since it is not in a `mutate`.
+		T::Freezer::died(id, &who);
+		return Ok(())
+	}
+
+	/// Increases the asset `id` balance of `beneficiary` by `amount`.
+	///
+	/// This alters the registered supply of the asset and emits an event.
+	///
+	/// Will return an error or will increase the amount by exactly `amount`.
+	pub(super) fn do_mint(
+		id: T::AssetId,
+		beneficiary: &T::AccountId,
+		amount: T::Balance,
+		maybe_check_issuer: Option<T::AccountId>,
+	) -> DispatchResult {
+		Self::increase_balance(id.clone(), beneficiary, amount, |details| -> DispatchResult {
+			if let Some(check_issuer) = maybe_check_issuer {
+				ensure!(check_issuer == details.issuer, Error::<T, I>::NoPermission);
+			}
+			debug_assert!(details.supply.checked_add(&amount).is_some(), "checked in prep; qed");
+
+			details.supply = details.supply.saturating_add(amount);
+
+			Ok(())
+		})?;
+
+		Self::deposit_event(Event::Issued { asset_id: id, owner: beneficiary.clone(), amount });
+
+		Ok(())
+	}
+
+	/// Increases the asset `id` balance of `beneficiary` by `amount`.
+	///
+	/// LOW-LEVEL: Does not alter the supply of asset or emit an event. Use `do_mint` if you need
+	/// that. This is not intended to be used alone.
+	///
+	/// Will return an error or will increase the amount by exactly `amount`.
+	pub(super) fn increase_balance(
+		id: T::AssetId,
+		beneficiary: &T::AccountId,
+		amount: T::Balance,
+		check: impl FnOnce(
+			&mut AssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T, I>>,
+		) -> DispatchResult,
+	) -> DispatchResult {
+		if amount.is_zero() {
+			return Ok(())
+		}
+
+		Self::can_increase(id.clone(), beneficiary, amount, true).into_result()?;
+		Asset::<T, I>::try_mutate(&id, |maybe_details| -> DispatchResult {
+			let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+			ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+			check(details)?;
+
+			Account::<T, I>::try_mutate(&id, beneficiary, |maybe_account| -> DispatchResult {
+				match maybe_account {
+					Some(ref mut account) => {
+						account.balance.saturating_accrue(amount);
+					},
+					maybe_account @ None => {
+						// Note this should never fail as it's already checked by
+						// `can_increase`.
+						ensure!(amount >= details.min_balance, TokenError::BelowMinimum);
+						*maybe_account = Some(AssetAccountOf::<T, I> {
+							balance: amount,
+							reason: Self::new_account(beneficiary, details, None)?,
+							status: AccountStatus::Liquid,
+							extra: T::Extra::default(),
+						});
+					},
+				}
+				Ok(())
+			})?;
+			Ok(())
+		})?;
+		Ok(())
+	}
+
+	/// Reduces asset `id` balance of `target` by `amount`. Flags `f` can be given to alter whether
+	/// it attempts a `best_effort` or makes sure to `keep_alive` the account.
+	///
+	/// This alters the registered supply of the asset and emits an event.
+	///
+	/// Will return an error and do nothing or will decrease the amount and return the amount
+	/// reduced by.
+	pub(super) fn do_burn(
+		id: T::AssetId,
+		target: &T::AccountId,
+		amount: T::Balance,
+		maybe_check_admin: Option<T::AccountId>,
+		f: DebitFlags,
+	) -> Result<T::Balance, DispatchError> {
+		let d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(
+			d.status == AssetStatus::Live || d.status == AssetStatus::Frozen,
+			Error::<T, I>::AssetNotLive
+		);
+
+		let actual = Self::decrease_balance(id.clone(), target, amount, f, |actual, details| {
+			// Check admin rights.
+			if let Some(check_admin) = maybe_check_admin {
+				ensure!(check_admin == details.admin, Error::<T, I>::NoPermission);
+			}
+
+			debug_assert!(details.supply >= actual, "checked in prep; qed");
+			details.supply = details.supply.saturating_sub(actual);
+
+			Ok(())
+		})?;
+		Self::deposit_event(Event::Burned { asset_id: id, owner: target.clone(), balance: actual });
+		Ok(actual)
+	}
+
+	/// Reduces asset `id` balance of `target` by `amount`. Flags `f` can be given to alter whether
+	/// it attempts a `best_effort` or makes sure to `keep_alive` the account.
+	///
+	/// LOW-LEVEL: Does not alter the supply of asset or emit an event. Use `do_burn` if you need
+	/// that. This is not intended to be used alone.
+	///
+	/// Will return an error and do nothing or will decrease the amount and return the amount
+	/// reduced by.
+	pub(super) fn decrease_balance(
+		id: T::AssetId,
+		target: &T::AccountId,
+		amount: T::Balance,
+		f: DebitFlags,
+		check: impl FnOnce(
+			T::Balance,
+			&mut AssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T, I>>,
+		) -> DispatchResult,
+	) -> Result<T::Balance, DispatchError> {
+		if amount.is_zero() {
+			return Ok(amount)
+		}
+
+		let details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+
+		let actual = Self::prep_debit(id.clone(), target, amount, f)?;
+		let mut target_died: Option<DeadConsequence> = None;
+
+		Asset::<T, I>::try_mutate(&id, |maybe_details| -> DispatchResult {
+			let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+			check(actual, details)?;
+
+			Account::<T, I>::try_mutate(&id, target, |maybe_account| -> DispatchResult {
+				let mut account = maybe_account.take().ok_or(Error::<T, I>::NoAccount)?;
+				debug_assert!(account.balance >= actual, "checked in prep; qed");
+
+				// Make the debit.
+				account.balance = account.balance.saturating_sub(actual);
+				if account.balance < details.min_balance {
+					debug_assert!(account.balance.is_zero(), "checked in prep; qed");
+					target_died = Some(Self::dead_account(target, details, &account.reason, false));
+					if let Some(Remove) = target_died {
+						return Ok(())
+					}
+				};
+				*maybe_account = Some(account);
+				Ok(())
+			})?;
+
+			Ok(())
+		})?;
+
+		// Execute hook outside of `mutate`.
+		if let Some(Remove) = target_died {
+			T::Freezer::died(id, target);
+		}
+		Ok(actual)
+	}
+
+	/// Reduces the asset `id` balance of `source` by some `amount` and increases the balance of
+	/// `dest` by (similar) amount.
+	///
+	/// Returns the actual amount placed into `dest`. Exact semantics are determined by the flags
+	/// `f`.
+	///
+	/// Will fail if the amount transferred is so small that it cannot create the destination due
+	/// to minimum balance requirements.
+	pub(super) fn do_transfer(
+		id: T::AssetId,
+		source: &T::AccountId,
+		dest: &T::AccountId,
+		amount: T::Balance,
+		maybe_need_admin: Option<T::AccountId>,
+		f: TransferFlags,
+	) -> Result<T::Balance, DispatchError> {
+		let (balance, died) =
+			Self::transfer_and_die(id.clone(), source, dest, amount, maybe_need_admin, f)?;
+		if let Some(Remove) = died {
+			T::Freezer::died(id, source);
+		}
+		Ok(balance)
+	}
+
+	/// Same as `do_transfer` but it does not execute the `FrozenBalance::died` hook and
+	/// instead returns whether and how the `source` account died in this operation.
+	fn transfer_and_die(
+		id: T::AssetId,
+		source: &T::AccountId,
+		dest: &T::AccountId,
+		amount: T::Balance,
+		maybe_need_admin: Option<T::AccountId>,
+		f: TransferFlags,
+	) -> Result<(T::Balance, Option<DeadConsequence>), DispatchError> {
+		// Early exit if no-op.
+		if amount.is_zero() {
+			return Ok((amount, None))
+		}
+		let details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+
+		// Figure out the debit and credit, together with side-effects.
+		let debit = Self::prep_debit(id.clone(), source, amount, f.into())?;
+		let (credit, maybe_burn) = Self::prep_credit(id.clone(), dest, amount, debit, f.burn_dust)?;
+
+		let mut source_account =
+			Account::<T, I>::get(&id, &source).ok_or(Error::<T, I>::NoAccount)?;
+		let mut source_died: Option<DeadConsequence> = None;
+
+		Asset::<T, I>::try_mutate(&id, |maybe_details| -> DispatchResult {
+			let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+
+			// Check admin rights.
+			if let Some(need_admin) = maybe_need_admin {
+				ensure!(need_admin == details.admin, Error::<T, I>::NoPermission);
+			}
+
+			// Skip if source == dest
+			if source == dest {
+				return Ok(())
+			}
+
+			// Burn any dust if needed.
+			if let Some(burn) = maybe_burn {
+				// Debit dust from supply; this will not saturate since it's already checked in
+				// prep.
+				debug_assert!(details.supply >= burn, "checked in prep; qed");
+				details.supply = details.supply.saturating_sub(burn);
+			}
+
+			// Debit balance from source; this will not saturate since it's already checked in prep.
+			debug_assert!(source_account.balance >= debit, "checked in prep; qed");
+			source_account.balance = source_account.balance.saturating_sub(debit);
+
+			Account::<T, I>::try_mutate(&id, &dest, |maybe_account| -> DispatchResult {
+				match maybe_account {
+					Some(ref mut account) => {
+						// Calculate new balance; this will not saturate since it's already checked
+						// in prep.
+						debug_assert!(
+							account.balance.checked_add(&credit).is_some(),
+							"checked in prep; qed"
+						);
+						account.balance.saturating_accrue(credit);
+					},
+					maybe_account @ None => {
+						*maybe_account = Some(AssetAccountOf::<T, I> {
+							balance: credit,
+							status: AccountStatus::Liquid,
+							reason: Self::new_account(dest, details, None)?,
+							extra: T::Extra::default(),
+						});
+					},
+				}
+				Ok(())
+			})?;
+
+			// Remove source account if it's now dead.
+			if source_account.balance < details.min_balance {
+				debug_assert!(source_account.balance.is_zero(), "checked in prep; qed");
+				source_died =
+					Some(Self::dead_account(source, details, &source_account.reason, false));
+				if let Some(Remove) = source_died {
+					Account::<T, I>::remove(&id, &source);
+					return Ok(())
+				}
+			}
+			Account::<T, I>::insert(&id, &source, &source_account);
+			Ok(())
+		})?;
+
+		Self::deposit_event(Event::Transferred {
+			asset_id: id,
+			from: source.clone(),
+			to: dest.clone(),
+			amount: credit,
+		});
+		Ok((credit, source_died))
+	}
+
+	/// Create a new asset without taking a deposit.
+	///
+	/// * `id`: The `AssetId` you want the new asset to have. Must not already be in use.
+	/// * `owner`: The owner, issuer, admin, and freezer of this asset upon creation.
+	/// * `is_sufficient`: Whether this asset needs users to have an existential deposit to hold
+	///   this asset.
+	/// * `min_balance`: The minimum balance a user is allowed to have of this asset before they are
+	///   considered dust and cleaned up.
+	pub(super) fn do_force_create(
+		id: T::AssetId,
+		owner: T::AccountId,
+		is_sufficient: bool,
+		min_balance: T::Balance,
+	) -> DispatchResult {
+		ensure!(!Asset::<T, I>::contains_key(&id), Error::<T, I>::InUse);
+		ensure!(!min_balance.is_zero(), Error::<T, I>::MinBalanceZero);
+
+		Asset::<T, I>::insert(
+			&id,
+			AssetDetails {
+				owner: owner.clone(),
+				issuer: owner.clone(),
+				admin: owner.clone(),
+				freezer: owner.clone(),
+				supply: Zero::zero(),
+				deposit: Zero::zero(),
+				min_balance,
+				is_sufficient,
+				accounts: 0,
+				sufficients: 0,
+				approvals: 0,
+				status: AssetStatus::Live,
+			},
+		);
+		ensure!(T::CallbackHandle::created(&id, &owner).is_ok(), Error::<T, I>::CallbackFailed);
+		Self::deposit_event(Event::ForceCreated { asset_id: id, owner: owner.clone() });
+		Ok(())
+	}
+
+	/// Start the process of destroying an asset, by setting the asset status to `Destroying`, and
+	/// emitting the `DestructionStarted` event.
+	pub(super) fn do_start_destroy(
+		id: T::AssetId,
+		maybe_check_owner: Option<T::AccountId>,
+	) -> DispatchResult {
+		Asset::<T, I>::try_mutate_exists(id.clone(), |maybe_details| -> Result<(), DispatchError> {
+			let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+			if let Some(check_owner) = maybe_check_owner {
+				ensure!(details.owner == check_owner, Error::<T, I>::NoPermission);
+			}
+			details.status = AssetStatus::Destroying;
+
+			Self::deposit_event(Event::DestructionStarted { asset_id: id });
+			Ok(())
+		})
+	}
+
+	/// Destroy accounts associated with a given asset up to the max (T::RemoveItemsLimit).
+	///
+	/// Each call emits the `Event::DestroyedAccounts` event.
+	/// Returns the number of destroyed accounts.
+	pub(super) fn do_destroy_accounts(
+		id: T::AssetId,
+		max_items: u32,
+	) -> Result<u32, DispatchError> {
+		let mut dead_accounts: Vec<T::AccountId> = vec![];
+		let mut remaining_accounts = 0;
+		let _ =
+			Asset::<T, I>::try_mutate_exists(&id, |maybe_details| -> Result<(), DispatchError> {
+				let mut details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+				// Should only destroy accounts while the asset is in a destroying state
+				ensure!(details.status == AssetStatus::Destroying, Error::<T, I>::IncorrectStatus);
+				for (i, (who, mut v)) in Account::<T, I>::iter_prefix(&id).enumerate() {
+					// unreserve the existence deposit if any
+					if let Some((depositor, deposit)) = v.reason.take_deposit_from() {
+						T::Currency::unreserve(&depositor, deposit);
+					} else if let Some(deposit) = v.reason.take_deposit() {
+						T::Currency::unreserve(&who, deposit);
+					}
+					if let Remove = Self::dead_account(&who, &mut details, &v.reason, false) {
+						Account::<T, I>::remove(&id, &who);
+						dead_accounts.push(who);
+					} else {
+						// deposit may have been released, need to update `Account`
+						Account::<T, I>::insert(&id, &who, v);
+						defensive!("destroy did not result in dead account?!");
+					}
+					if i + 1 >= (max_items as usize) {
+						break
+					}
+				}
+				remaining_accounts = details.accounts;
+				Ok(())
+			})?;
+
+		for who in &dead_accounts {
+			T::Freezer::died(id.clone(), &who);
+		}
+
+		Self::deposit_event(Event::AccountsDestroyed {
+			asset_id: id,
+			accounts_destroyed: dead_accounts.len() as u32,
+			accounts_remaining: remaining_accounts as u32,
+		});
+		Ok(dead_accounts.len() as u32)
+	}
+
+	/// Destroy approvals associated with a given asset up to the max (T::RemoveItemsLimit).
+	///
+	/// Each call emits the `Event::DestroyedApprovals` event
+	/// Returns the number of destroyed approvals.
+	pub(super) fn do_destroy_approvals(
+		id: T::AssetId,
+		max_items: u32,
+	) -> Result<u32, DispatchError> {
+		let mut removed_approvals = 0;
+		let _ = Asset::<T, I>::try_mutate_exists(
+			id.clone(),
+			|maybe_details| -> Result<(), DispatchError> {
+				let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+
+				// Should only destroy accounts while the asset is in a destroying state.
+				ensure!(details.status == AssetStatus::Destroying, Error::<T, I>::IncorrectStatus);
+
+				for ((owner, _), approval) in Approvals::<T, I>::drain_prefix((id.clone(),)) {
+					T::Currency::unreserve(&owner, approval.deposit);
+					removed_approvals = removed_approvals.saturating_add(1);
+					details.approvals = details.approvals.saturating_sub(1);
+					if removed_approvals >= max_items {
+						break
+					}
+				}
+				Self::deposit_event(Event::ApprovalsDestroyed {
+					asset_id: id,
+					approvals_destroyed: removed_approvals as u32,
+					approvals_remaining: details.approvals as u32,
+				});
+				Ok(())
+			},
+		)?;
+		Ok(removed_approvals)
+	}
+
+	/// Complete destroying an asset and unreserve the deposit.
+	///
+	/// On success, the `Event::Destroyed` event is emitted.
+	pub(super) fn do_finish_destroy(id: T::AssetId) -> DispatchResult {
+		Asset::<T, I>::try_mutate_exists(id.clone(), |maybe_details| -> Result<(), DispatchError> {
+			let details = maybe_details.take().ok_or(Error::<T, I>::Unknown)?;
+			ensure!(details.status == AssetStatus::Destroying, Error::<T, I>::IncorrectStatus);
+			ensure!(details.accounts == 0, Error::<T, I>::InUse);
+			ensure!(details.approvals == 0, Error::<T, I>::InUse);
+			ensure!(T::CallbackHandle::destroyed(&id).is_ok(), Error::<T, I>::CallbackFailed);
+
+			let metadata = Metadata::<T, I>::take(&id);
+			T::Currency::unreserve(
+				&details.owner,
+				details.deposit.saturating_add(metadata.deposit),
+			);
+			Self::deposit_event(Event::Destroyed { asset_id: id });
+
+			Ok(())
+		})
+	}
+
+	/// Creates an approval from `owner` to spend `amount` of asset `id` tokens by 'delegate'
+	/// while reserving `T::ApprovalDeposit` from owner
+	///
+	/// If an approval already exists, the new amount is added to such existing approval
+	pub(super) fn do_approve_transfer(
+		id: T::AssetId,
+		owner: &T::AccountId,
+		delegate: &T::AccountId,
+		amount: T::Balance,
+	) -> DispatchResult {
+		let mut d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(d.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+		Approvals::<T, I>::try_mutate(
+			(id.clone(), &owner, &delegate),
+			|maybe_approved| -> DispatchResult {
+				let mut approved = match maybe_approved.take() {
+					// an approval already exists and is being updated
+					Some(a) => a,
+					// a new approval is created
+					None => {
+						d.approvals.saturating_inc();
+						Default::default()
+					},
+				};
+				let deposit_required = T::ApprovalDeposit::get();
+				if approved.deposit < deposit_required {
+					T::Currency::reserve(owner, deposit_required - approved.deposit)?;
+					approved.deposit = deposit_required;
+				}
+				approved.amount = approved.amount.saturating_add(amount);
+				*maybe_approved = Some(approved);
+				Ok(())
+			},
+		)?;
+		Asset::<T, I>::insert(&id, d);
+		Self::deposit_event(Event::ApprovedTransfer {
+			asset_id: id,
+			source: owner.clone(),
+			delegate: delegate.clone(),
+			amount,
+		});
+
+		Ok(())
+	}
+
+	/// Reduces the asset `id` balance of `owner` by some `amount` and increases the balance of
+	/// `dest` by (similar) amount, checking that 'delegate' has an existing approval from `owner`
+	/// to spend`amount`.
+	///
+	/// Will fail if `amount` is greater than the approval from `owner` to 'delegate'
+	/// Will unreserve the deposit from `owner` if the entire approved `amount` is spent by
+	/// 'delegate'
+	pub(super) fn do_transfer_approved(
+		id: T::AssetId,
+		owner: &T::AccountId,
+		delegate: &T::AccountId,
+		destination: &T::AccountId,
+		amount: T::Balance,
+	) -> DispatchResult {
+		let mut owner_died: Option<DeadConsequence> = None;
+
+		let d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(d.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+
+		Approvals::<T, I>::try_mutate_exists(
+			(id.clone(), &owner, delegate),
+			|maybe_approved| -> DispatchResult {
+				let mut approved = maybe_approved.take().ok_or(Error::<T, I>::Unapproved)?;
+				let remaining =
+					approved.amount.checked_sub(&amount).ok_or(Error::<T, I>::Unapproved)?;
+
+				let f = TransferFlags { keep_alive: false, best_effort: false, burn_dust: false };
+				owner_died =
+					Self::transfer_and_die(id.clone(), owner, destination, amount, None, f)?.1;
+
+				if remaining.is_zero() {
+					T::Currency::unreserve(owner, approved.deposit);
+					Asset::<T, I>::mutate(id.clone(), |maybe_details| {
+						if let Some(details) = maybe_details {
+							details.approvals.saturating_dec();
+						}
+					});
+				} else {
+					approved.amount = remaining;
+					*maybe_approved = Some(approved);
+				}
+				Ok(())
+			},
+		)?;
+
+		// Execute hook outside of `mutate`.
+		if let Some(Remove) = owner_died {
+			T::Freezer::died(id, owner);
+		}
+		Ok(())
+	}
+
+	/// Do set metadata
+	pub(super) fn do_set_metadata(
+		id: T::AssetId,
+		from: &T::AccountId,
+		name: Vec<u8>,
+		symbol: Vec<u8>,
+		decimals: u8,
+	) -> DispatchResult {
+		let bounded_name: BoundedVec<u8, T::StringLimit> =
+			name.clone().try_into().map_err(|_| Error::<T, I>::BadMetadata)?;
+		let bounded_symbol: BoundedVec<u8, T::StringLimit> =
+			symbol.clone().try_into().map_err(|_| Error::<T, I>::BadMetadata)?;
+
+		let d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+		ensure!(d.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+		ensure!(from == &d.owner, Error::<T, I>::NoPermission);
+
+		Metadata::<T, I>::try_mutate_exists(id.clone(), |metadata| {
+			ensure!(metadata.as_ref().map_or(true, |m| !m.is_frozen), Error::<T, I>::NoPermission);
+
+			let old_deposit = metadata.take().map_or(Zero::zero(), |m| m.deposit);
+			let new_deposit = Self::calc_metadata_deposit(&name, &symbol);
+
+			if new_deposit > old_deposit {
+				T::Currency::reserve(from, new_deposit - old_deposit)?;
+			} else {
+				T::Currency::unreserve(from, old_deposit - new_deposit);
+			}
+
+			*metadata = Some(AssetMetadata {
+				deposit: new_deposit,
+				name: bounded_name,
+				symbol: bounded_symbol,
+				decimals,
+				is_frozen: false,
+			});
+
+			Self::deposit_event(Event::MetadataSet {
+				asset_id: id,
+				name,
+				symbol,
+				decimals,
+				is_frozen: false,
+			});
+			Ok(())
+		})
+	}
+
+	/// Calculate the metadata deposit for the provided data.
+	pub(super) fn calc_metadata_deposit(name: &[u8], symbol: &[u8]) -> DepositBalanceOf<T, I> {
+		T::MetadataDepositPerByte::get()
+			.saturating_mul(((name.len() + symbol.len()) as u32).into())
+			.saturating_add(T::MetadataDepositBase::get())
+	}
+
+	/// Returns all the non-zero balances for all assets of the given `account`.
+	pub fn account_balances(account: T::AccountId) -> Vec<(T::AssetId, T::Balance)> {
+		Asset::<T, I>::iter_keys()
+			.filter_map(|id| {
+				Self::maybe_balance(id.clone(), account.clone()).map(|balance| (id, balance))
+			})
+			.collect::<Vec<_>>()
+	}
+}
diff --git a/substrate/frame/assets/src/impl_fungibles.rs b/substrate/frame/assets/src/impl_fungibles.rs
new file mode 100644
index 0000000000000000000000000000000000000000..123abeba8283fce8300521a80acead12c1616933
--- /dev/null
+++ b/substrate/frame/assets/src/impl_fungibles.rs
@@ -0,0 +1,310 @@
+// 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.
+
+//! Implementations for fungibles trait.
+
+use frame_support::{
+	defensive,
+	traits::tokens::{
+		Fortitude,
+		Precision::{self, BestEffort},
+		Preservation::{self, Expendable},
+		Provenance::{self, Minted},
+	},
+};
+
+use super::*;
+
+impl<T: Config<I>, I: 'static> fungibles::Inspect<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	type AssetId = T::AssetId;
+	type Balance = T::Balance;
+
+	fn total_issuance(asset: Self::AssetId) -> Self::Balance {
+		Asset::<T, I>::get(asset).map(|x| x.supply).unwrap_or_else(Zero::zero)
+	}
+
+	fn minimum_balance(asset: Self::AssetId) -> Self::Balance {
+		Asset::<T, I>::get(asset).map(|x| x.min_balance).unwrap_or_else(Zero::zero)
+	}
+
+	fn balance(asset: Self::AssetId, who: &<T as SystemConfig>::AccountId) -> Self::Balance {
+		Pallet::<T, I>::balance(asset, who)
+	}
+
+	fn total_balance(asset: Self::AssetId, who: &<T as SystemConfig>::AccountId) -> Self::Balance {
+		Pallet::<T, I>::balance(asset, who)
+	}
+
+	fn reducible_balance(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		preservation: Preservation,
+		_: Fortitude,
+	) -> Self::Balance {
+		Pallet::<T, I>::reducible_balance(asset, who, !matches!(preservation, Expendable))
+			.unwrap_or(Zero::zero())
+	}
+
+	fn can_deposit(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence {
+		Pallet::<T, I>::can_increase(asset, who, amount, provenance == Minted)
+	}
+
+	fn can_withdraw(
+		asset: Self::AssetId,
+		who: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance> {
+		Pallet::<T, I>::can_decrease(asset, who, amount, false)
+	}
+
+	fn asset_exists(asset: Self::AssetId) -> bool {
+		Asset::<T, I>::contains_key(asset)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::Mutate<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	fn done_mint_into(
+		asset_id: Self::AssetId,
+		beneficiary: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+	) {
+		Self::deposit_event(Event::Issued { asset_id, owner: beneficiary.clone(), amount })
+	}
+
+	fn done_burn_from(
+		asset_id: Self::AssetId,
+		target: &<T as SystemConfig>::AccountId,
+		balance: Self::Balance,
+	) {
+		Self::deposit_event(Event::Burned { asset_id, owner: target.clone(), balance });
+	}
+
+	fn done_transfer(
+		asset_id: Self::AssetId,
+		source: &<T as SystemConfig>::AccountId,
+		dest: &<T as SystemConfig>::AccountId,
+		amount: Self::Balance,
+	) {
+		Self::deposit_event(Event::Transferred {
+			asset_id,
+			from: source.clone(),
+			to: dest.clone(),
+			amount,
+		});
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::Balanced<<T as SystemConfig>::AccountId>
+	for Pallet<T, I>
+{
+	type OnDropCredit = fungibles::DecreaseIssuance<T::AccountId, Self>;
+	type OnDropDebt = fungibles::IncreaseIssuance<T::AccountId, Self>;
+}
+
+impl<T: Config<I>, I: 'static> fungibles::Unbalanced<T::AccountId> for Pallet<T, I> {
+	fn handle_raw_dust(_: Self::AssetId, _: Self::Balance) {}
+	fn handle_dust(_: fungibles::Dust<T::AccountId, Self>) {
+		defensive!("`decrease_balance` and `increase_balance` have non-default impls; nothing else calls this; qed");
+	}
+	fn write_balance(
+		_: Self::AssetId,
+		_: &T::AccountId,
+		_: Self::Balance,
+	) -> Result<Option<Self::Balance>, DispatchError> {
+		defensive!("write_balance is not used if other functions are impl'd");
+		Err(DispatchError::Unavailable)
+	}
+	fn set_total_issuance(id: T::AssetId, amount: Self::Balance) {
+		Asset::<T, I>::mutate_exists(id, |maybe_asset| {
+			if let Some(ref mut asset) = maybe_asset {
+				asset.supply = amount
+			}
+		});
+	}
+	fn decrease_balance(
+		asset: T::AssetId,
+		who: &T::AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		_: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		let f = DebitFlags {
+			keep_alive: preservation != Expendable,
+			best_effort: precision == BestEffort,
+		};
+		Self::decrease_balance(asset, who, amount, f, |_, _| Ok(()))
+	}
+	fn increase_balance(
+		asset: T::AssetId,
+		who: &T::AccountId,
+		amount: Self::Balance,
+		_: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		Self::increase_balance(asset, who, amount, |_| Ok(()))?;
+		Ok(amount)
+	}
+
+	// TODO: #13196 implement deactivate/reactivate once we have inactive balance tracking.
+}
+
+impl<T: Config<I>, I: 'static> fungibles::Create<T::AccountId> for Pallet<T, I> {
+	fn create(
+		id: T::AssetId,
+		admin: T::AccountId,
+		is_sufficient: bool,
+		min_balance: Self::Balance,
+	) -> DispatchResult {
+		Self::do_force_create(id, admin, is_sufficient, min_balance)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::Destroy<T::AccountId> for Pallet<T, I> {
+	fn start_destroy(id: T::AssetId, maybe_check_owner: Option<T::AccountId>) -> DispatchResult {
+		Self::do_start_destroy(id, maybe_check_owner)
+	}
+
+	fn destroy_accounts(id: T::AssetId, max_items: u32) -> Result<u32, DispatchError> {
+		Self::do_destroy_accounts(id, max_items)
+	}
+
+	fn destroy_approvals(id: T::AssetId, max_items: u32) -> Result<u32, DispatchError> {
+		Self::do_destroy_approvals(id, max_items)
+	}
+
+	fn finish_destroy(id: T::AssetId) -> DispatchResult {
+		Self::do_finish_destroy(id)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::metadata::Inspect<<T as SystemConfig>::AccountId>
+	for Pallet<T, I>
+{
+	fn name(asset: T::AssetId) -> Vec<u8> {
+		Metadata::<T, I>::get(asset).name.to_vec()
+	}
+
+	fn symbol(asset: T::AssetId) -> Vec<u8> {
+		Metadata::<T, I>::get(asset).symbol.to_vec()
+	}
+
+	fn decimals(asset: T::AssetId) -> u8 {
+		Metadata::<T, I>::get(asset).decimals
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::metadata::Mutate<<T as SystemConfig>::AccountId>
+	for Pallet<T, I>
+{
+	fn set(
+		asset: T::AssetId,
+		from: &<T as SystemConfig>::AccountId,
+		name: Vec<u8>,
+		symbol: Vec<u8>,
+		decimals: u8,
+	) -> DispatchResult {
+		Self::do_set_metadata(asset, from, name, symbol, decimals)
+	}
+}
+
+impl<T: Config<I>, I: 'static>
+	fungibles::metadata::MetadataDeposit<
+		<T::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance,
+	> for Pallet<T, I>
+{
+	fn calc_metadata_deposit(
+		name: &[u8],
+		symbol: &[u8],
+	) -> <T::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance {
+		Self::calc_metadata_deposit(&name, &symbol)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::approvals::Inspect<<T as SystemConfig>::AccountId>
+	for Pallet<T, I>
+{
+	// Check the amount approved to be spent by an owner to a delegate
+	fn allowance(
+		asset: T::AssetId,
+		owner: &<T as SystemConfig>::AccountId,
+		delegate: &<T as SystemConfig>::AccountId,
+	) -> T::Balance {
+		Approvals::<T, I>::get((asset, &owner, &delegate))
+			.map(|x| x.amount)
+			.unwrap_or_else(Zero::zero)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::approvals::Mutate<<T as SystemConfig>::AccountId>
+	for Pallet<T, I>
+{
+	// Approve spending tokens from a given account
+	fn approve(
+		asset: T::AssetId,
+		owner: &<T as SystemConfig>::AccountId,
+		delegate: &<T as SystemConfig>::AccountId,
+		amount: T::Balance,
+	) -> DispatchResult {
+		Self::do_approve_transfer(asset, owner, delegate, amount)
+	}
+
+	fn transfer_from(
+		asset: T::AssetId,
+		owner: &<T as SystemConfig>::AccountId,
+		delegate: &<T as SystemConfig>::AccountId,
+		dest: &<T as SystemConfig>::AccountId,
+		amount: T::Balance,
+	) -> DispatchResult {
+		Self::do_transfer_approved(asset, owner, delegate, dest, amount)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::roles::Inspect<<T as SystemConfig>::AccountId>
+	for Pallet<T, I>
+{
+	fn owner(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
+		Asset::<T, I>::get(asset).map(|x| x.owner)
+	}
+
+	fn issuer(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
+		Asset::<T, I>::get(asset).map(|x| x.issuer)
+	}
+
+	fn admin(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
+		Asset::<T, I>::get(asset).map(|x| x.admin)
+	}
+
+	fn freezer(asset: T::AssetId) -> Option<<T as SystemConfig>::AccountId> {
+		Asset::<T, I>::get(asset).map(|x| x.freezer)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungibles::InspectEnumerable<T::AccountId> for Pallet<T, I> {
+	type AssetsIterator = KeyPrefixIterator<<T as Config<I>>::AssetId>;
+
+	/// Returns an iterator of the assets in existence.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn asset_ids() -> Self::AssetsIterator {
+		Asset::<T, I>::iter_keys()
+	}
+}
diff --git a/substrate/frame/assets/src/impl_stored_map.rs b/substrate/frame/assets/src/impl_stored_map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a7a5a0859f701fe45380a22a5ceac09951eabb66
--- /dev/null
+++ b/substrate/frame/assets/src/impl_stored_map.rs
@@ -0,0 +1,54 @@
+// 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 pallet's `StoredMap` implementation.
+
+use super::*;
+
+impl<T: Config<I>, I: 'static> StoredMap<(T::AssetId, T::AccountId), T::Extra> for Pallet<T, I> {
+	fn get(id_who: &(T::AssetId, T::AccountId)) -> T::Extra {
+		let (id, who) = id_who;
+		Account::<T, I>::get(id, who).map(|a| a.extra).unwrap_or_default()
+	}
+
+	fn try_mutate_exists<R, E: From<DispatchError>>(
+		id_who: &(T::AssetId, T::AccountId),
+		f: impl FnOnce(&mut Option<T::Extra>) -> Result<R, E>,
+	) -> Result<R, E> {
+		let (id, who) = id_who;
+		let mut maybe_extra = Account::<T, I>::get(id, who).map(|a| a.extra);
+		let r = f(&mut maybe_extra)?;
+		// They want to write some value or delete it.
+		// If the account existed and they want to write a value, then we write.
+		// If the account didn't exist and they want to delete it, then we let it pass.
+		// Otherwise, we fail.
+		Account::<T, I>::try_mutate(id, who, |maybe_account| {
+			if let Some(extra) = maybe_extra {
+				// They want to write a value. Let this happen only if the account actually exists.
+				if let Some(ref mut account) = maybe_account {
+					account.extra = extra;
+				} else {
+					return Err(DispatchError::NoProviders.into())
+				}
+			} else {
+				// They want to delete it. Let this pass if the item never existed anyway.
+				ensure!(maybe_account.is_none(), DispatchError::ConsumerRemaining);
+			}
+			Ok(r)
+		})
+	}
+}
diff --git a/substrate/frame/assets/src/lib.rs b/substrate/frame/assets/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..363a99701b56a1aff4178dd551a104efba7e337f
--- /dev/null
+++ b/substrate/frame/assets/src/lib.rs
@@ -0,0 +1,1665 @@
+// 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 Pallet
+//!
+//! A simple, secure module for dealing with fungible assets.
+//!
+//! ## Overview
+//!
+//! The Assets module provides functionality for asset management of fungible asset classes
+//! with a fixed supply, including:
+//!
+//! * Asset Issuance (Minting)
+//! * Asset Transferal
+//! * Asset Freezing
+//! * Asset Destruction (Burning)
+//! * Delegated Asset Transfers ("Approval API")
+//!
+//! To use it in your runtime, you need to implement the assets [`Config`].
+//!
+//! The supported dispatchable functions are documented in the [`Call`] enum.
+//!
+//! ### Terminology
+//!
+//! * **Admin**: An account ID uniquely privileged to be able to unfreeze (thaw) an account and its
+//!   assets, as well as forcibly transfer a particular class of assets between arbitrary accounts
+//!   and reduce the balance of a particular class of assets of arbitrary accounts.
+//! * **Asset issuance/minting**: The creation of a new asset, whose total supply will belong to the
+//!   account designated as the beneficiary of the asset. This is a privileged operation.
+//! * **Asset transfer**: The reduction of the balance of an asset of one account with the
+//!   corresponding increase in the balance of another.
+//! * **Asset destruction**: The process of reducing the balance of an asset of one account. This is
+//!   a privileged operation.
+//! * **Fungible asset**: An asset whose units are interchangeable.
+//! * **Issuer**: An account ID uniquely privileged to be able to mint a particular class of assets.
+//! * **Freezer**: An account ID uniquely privileged to be able to freeze an account from
+//!   transferring a particular class of assets.
+//! * **Freezing**: Removing the possibility of an unpermissioned transfer of an asset from a
+//!   particular account.
+//! * **Non-fungible asset**: An asset for which each unit has unique characteristics.
+//! * **Owner**: An account ID uniquely privileged to be able to destroy a particular asset class,
+//!   or to set the Issuer, Freezer or Admin of that asset class.
+//! * **Approval**: The act of allowing an account the permission to transfer some balance of asset
+//!   from the approving account into some third-party destination account.
+//! * **Sufficiency**: The idea of a minimum-balance of an asset being sufficient to allow the
+//!   account's existence on the system without requiring any other existential-deposit.
+//!
+//! ### Goals
+//!
+//! The assets system in Substrate is designed to make the following possible:
+//!
+//! * Issue new assets in a permissioned or permissionless way, if permissionless, then with a
+//!   deposit required.
+//! * Allow accounts to be delegated the ability to transfer assets without otherwise existing
+//!   on-chain (*approvals*).
+//! * Move assets between accounts.
+//! * Update an asset class's total supply.
+//! * Allow administrative activities by specially privileged accounts including freezing account
+//!   balances and minting/burning assets.
+//!
+//! ## Interface
+//!
+//! ### Permissionless Functions
+//!
+//! * `create`: Creates a new asset class, taking the required deposit.
+//! * `transfer`: Transfer sender's assets to another account.
+//! * `transfer_keep_alive`: Transfer sender's assets to another account, keeping the sender alive.
+//! * `approve_transfer`: Create or increase an delegated transfer.
+//! * `cancel_approval`: Rescind a previous approval.
+//! * `transfer_approved`: Transfer third-party's assets to another account.
+//! * `touch`: Create an asset account for non-provider assets. Caller must place a deposit.
+//! * `refund`: Return the deposit (if any) of the caller's asset account or a consumer reference
+//!   (if any) of the caller's account.
+//! * `refund_other`: Return the deposit (if any) of a specified asset account.
+//!
+//! ### Permissioned Functions
+//!
+//! * `force_create`: Creates a new asset class without taking any deposit.
+//! * `force_set_metadata`: Set the metadata of an asset class.
+//! * `force_clear_metadata`: Remove the metadata of an asset class.
+//! * `force_asset_status`: Alter an asset class's attributes.
+//! * `force_cancel_approval`: Rescind a previous approval.
+//!
+//! ### Privileged Functions
+//!
+//! * `destroy`: Destroys an entire asset class; called by the asset class's Owner.
+//! * `mint`: Increases the asset balance of an account; called by the asset class's Issuer.
+//! * `burn`: Decreases the asset balance of an account; called by the asset class's Admin.
+//! * `force_transfer`: Transfers between arbitrary accounts; called by the asset class's Admin.
+//! * `freeze`: Disallows further `transfer`s from an account; called by the asset class's Freezer.
+//! * `thaw`: Allows further `transfer`s to and from an account; called by the asset class's Admin.
+//! * `transfer_ownership`: Changes an asset class's Owner; called by the asset class's Owner.
+//! * `set_team`: Changes an asset class's Admin, Freezer and Issuer; called by the asset class's
+//!   Owner.
+//! * `set_metadata`: Set the metadata of an asset class; called by the asset class's Owner.
+//! * `clear_metadata`: Remove the metadata of an asset class; called by the asset class's Owner.
+//! * `touch_other`: Create an asset account for specified account. Caller must place a deposit;
+//!   called by the asset class's Freezer or Admin.
+//! * `block`: Disallows further `transfer`s to and from an account; called by the asset class's
+//!   Freezer.
+//!
+//! Please refer to the [`Call`] enum and its associated variants for documentation on each
+//! function.
+//!
+//! ### Public Functions
+//! <!-- Original author of descriptions: @gavofyork -->
+//!
+//! * `balance` - Get the asset `id` balance of `who`.
+//! * `total_supply` - Get the total supply of an asset `id`.
+//!
+//! Please refer to the [`Pallet`] struct for details on publicly available functions.
+//!
+//! ### Callbacks
+//!
+//! Using `CallbackHandle` associated type, user can configure custom callback functions which are
+//! executed when new asset is created or an existing asset is destroyed.
+//!
+//! ## Related Modules
+//!
+//! * [`System`](../frame_system/index.html)
+//! * [`Support`](../frame_support/index.html)
+
+// This recursion limit is needed because we have too many benchmarks and benchmarking will fail if
+// we add more without this limit.
+#![recursion_limit = "1024"]
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod migration;
+#[cfg(test)]
+pub mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+mod extra_mutator;
+pub use extra_mutator::*;
+mod functions;
+mod impl_fungibles;
+mod impl_stored_map;
+mod types;
+pub use types::*;
+
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{AtLeast32BitUnsigned, CheckedAdd, CheckedSub, Saturating, StaticLookup, Zero},
+	ArithmeticError, TokenError,
+};
+use sp_std::prelude::*;
+
+use frame_support::{
+	dispatch::{DispatchError, DispatchResult},
+	ensure,
+	pallet_prelude::DispatchResultWithPostInfo,
+	storage::KeyPrefixIterator,
+	traits::{
+		tokens::{fungibles, DepositConsequence, WithdrawConsequence},
+		BalanceStatus::Reserved,
+		Currency, EnsureOriginWithArg, ReservableCurrency, StoredMap,
+	},
+};
+use frame_system::Config as SystemConfig;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+const LOG_TARGET: &str = "runtime::assets";
+
+/// Trait with callbacks that are executed after successfull asset creation or destruction.
+pub trait AssetsCallback<AssetId, AccountId> {
+	/// Indicates that asset with `id` was successfully created by the `owner`
+	fn created(_id: &AssetId, _owner: &AccountId) -> Result<(), ()> {
+		Ok(())
+	}
+
+	/// Indicates that asset with `id` has just been destroyed
+	fn destroyed(_id: &AssetId) -> Result<(), ()> {
+		Ok(())
+	}
+}
+
+/// Empty implementation in case no callbacks are required.
+impl<AssetId, AccountId> AssetsCallback<AssetId, AccountId> for () {}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{
+		pallet_prelude::*,
+		traits::{AccountTouch, ContainsPair},
+	};
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[cfg(feature = "runtime-benchmarks")]
+	pub trait BenchmarkHelper<AssetIdParameter> {
+		fn create_asset_id_parameter(id: u32) -> AssetIdParameter;
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	impl<AssetIdParameter: From<u32>> BenchmarkHelper<AssetIdParameter> for () {
+		fn create_asset_id_parameter(id: u32) -> AssetIdParameter {
+			id.into()
+		}
+	}
+
+	#[pallet::config]
+	/// The module configuration trait.
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The units in which we record balances.
+		type Balance: Member
+			+ Parameter
+			+ AtLeast32BitUnsigned
+			+ Default
+			+ Copy
+			+ MaybeSerializeDeserialize
+			+ MaxEncodedLen
+			+ TypeInfo;
+
+		/// Max number of items to destroy per `destroy_accounts` and `destroy_approvals` call.
+		///
+		/// Must be configured to result in a weight that makes each call fit in a block.
+		#[pallet::constant]
+		type RemoveItemsLimit: Get<u32>;
+
+		/// Identifier for the class of asset.
+		type AssetId: Member + Parameter + Clone + MaybeSerializeDeserialize + MaxEncodedLen;
+
+		/// Wrapper around `Self::AssetId` to use in dispatchable call signatures. Allows the use
+		/// of compact encoding in instances of the pallet, which will prevent breaking changes
+		/// resulting from the removal of `HasCompact` from `Self::AssetId`.
+		///
+		/// This type includes the `From<Self::AssetId>` bound, since tightly coupled pallets may
+		/// want to convert an `AssetId` into a parameter for calling dispatchable functions
+		/// directly.
+		type AssetIdParameter: Parameter
+			+ Copy
+			+ From<Self::AssetId>
+			+ Into<Self::AssetId>
+			+ MaxEncodedLen;
+
+		/// The currency mechanism.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// Standard asset class creation is only allowed if the origin attempting it and the
+		/// asset class are in this set.
+		type CreateOrigin: EnsureOriginWithArg<
+			Self::RuntimeOrigin,
+			Self::AssetId,
+			Success = Self::AccountId,
+		>;
+
+		/// The origin which may forcibly create or destroy an asset or otherwise alter privileged
+		/// attributes.
+		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The basic amount of funds that must be reserved for an asset.
+		#[pallet::constant]
+		type AssetDeposit: Get<DepositBalanceOf<Self, I>>;
+
+		/// The amount of funds that must be reserved for a non-provider asset account to be
+		/// maintained.
+		#[pallet::constant]
+		type AssetAccountDeposit: Get<DepositBalanceOf<Self, I>>;
+
+		/// The basic amount of funds that must be reserved when adding metadata to your asset.
+		#[pallet::constant]
+		type MetadataDepositBase: Get<DepositBalanceOf<Self, I>>;
+
+		/// The additional funds that must be reserved for the number of bytes you store in your
+		/// metadata.
+		#[pallet::constant]
+		type MetadataDepositPerByte: Get<DepositBalanceOf<Self, I>>;
+
+		/// The amount of funds that must be reserved when creating a new approval.
+		#[pallet::constant]
+		type ApprovalDeposit: Get<DepositBalanceOf<Self, I>>;
+
+		/// The maximum length of a name or symbol stored on-chain.
+		#[pallet::constant]
+		type StringLimit: Get<u32>;
+
+		/// A hook to allow a per-asset, per-account minimum balance to be enforced. This must be
+		/// respected in all permissionless operations.
+		type Freezer: FrozenBalance<Self::AssetId, Self::AccountId, Self::Balance>;
+
+		/// Additional data to be stored with an account's asset balance.
+		type Extra: Member + Parameter + Default + MaxEncodedLen;
+
+		/// Callback methods for asset state change (e.g. asset created or destroyed)
+		type CallbackHandle: AssetsCallback<Self::AssetId, Self::AccountId>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Helper trait for benchmarks.
+		#[cfg(feature = "runtime-benchmarks")]
+		type BenchmarkHelper: BenchmarkHelper<Self::AssetIdParameter>;
+	}
+
+	#[pallet::storage]
+	/// Details of an asset.
+	pub(super) type Asset<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AssetId,
+		AssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T, I>>,
+	>;
+
+	#[pallet::storage]
+	/// The holdings of a specific account for a specific asset.
+	pub(super) type Account<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::AssetId,
+		Blake2_128Concat,
+		T::AccountId,
+		AssetAccountOf<T, I>,
+	>;
+
+	#[pallet::storage]
+	/// Approved balance transfers. First balance is the amount approved for transfer. Second
+	/// is the amount of `T::Currency` reserved for storing this.
+	/// First key is the asset ID, second key is the owner and third key is the delegate.
+	pub(super) type Approvals<T: Config<I>, I: 'static = ()> = StorageNMap<
+		_,
+		(
+			NMapKey<Blake2_128Concat, T::AssetId>,
+			NMapKey<Blake2_128Concat, T::AccountId>, // owner
+			NMapKey<Blake2_128Concat, T::AccountId>, // delegate
+		),
+		Approval<T::Balance, DepositBalanceOf<T, I>>,
+	>;
+
+	#[pallet::storage]
+	/// Metadata of an asset.
+	pub(super) type Metadata<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AssetId,
+		AssetMetadata<DepositBalanceOf<T, I>, BoundedVec<u8, T::StringLimit>>,
+		ValueQuery,
+	>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		/// Genesis assets: id, owner, is_sufficient, min_balance
+		pub assets: Vec<(T::AssetId, T::AccountId, bool, T::Balance)>,
+		/// Genesis metadata: id, name, symbol, decimals
+		pub metadata: Vec<(T::AssetId, Vec<u8>, Vec<u8>, u8)>,
+		/// Genesis accounts: id, account_id, balance
+		pub accounts: Vec<(T::AssetId, T::AccountId, T::Balance)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			for (id, owner, is_sufficient, min_balance) in &self.assets {
+				assert!(!Asset::<T, I>::contains_key(id), "Asset id already in use");
+				assert!(!min_balance.is_zero(), "Min balance should not be zero");
+				Asset::<T, I>::insert(
+					id,
+					AssetDetails {
+						owner: owner.clone(),
+						issuer: owner.clone(),
+						admin: owner.clone(),
+						freezer: owner.clone(),
+						supply: Zero::zero(),
+						deposit: Zero::zero(),
+						min_balance: *min_balance,
+						is_sufficient: *is_sufficient,
+						accounts: 0,
+						sufficients: 0,
+						approvals: 0,
+						status: AssetStatus::Live,
+					},
+				);
+			}
+
+			for (id, name, symbol, decimals) in &self.metadata {
+				assert!(Asset::<T, I>::contains_key(id), "Asset does not exist");
+
+				let bounded_name: BoundedVec<u8, T::StringLimit> =
+					name.clone().try_into().expect("asset name is too long");
+				let bounded_symbol: BoundedVec<u8, T::StringLimit> =
+					symbol.clone().try_into().expect("asset symbol is too long");
+
+				let metadata = AssetMetadata {
+					deposit: Zero::zero(),
+					name: bounded_name,
+					symbol: bounded_symbol,
+					decimals: *decimals,
+					is_frozen: false,
+				};
+				Metadata::<T, I>::insert(id, metadata);
+			}
+
+			for (id, account_id, amount) in &self.accounts {
+				let result = <Pallet<T, I>>::increase_balance(
+					id.clone(),
+					account_id,
+					*amount,
+					|details| -> DispatchResult {
+						debug_assert!(
+							details.supply.checked_add(&amount).is_some(),
+							"checked in prep; qed"
+						);
+						details.supply = details.supply.saturating_add(*amount);
+						Ok(())
+					},
+				);
+				assert!(result.is_ok());
+			}
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// Some asset class was created.
+		Created { asset_id: T::AssetId, creator: T::AccountId, owner: T::AccountId },
+		/// Some assets were issued.
+		Issued { asset_id: T::AssetId, owner: T::AccountId, amount: T::Balance },
+		/// Some assets were transferred.
+		Transferred {
+			asset_id: T::AssetId,
+			from: T::AccountId,
+			to: T::AccountId,
+			amount: T::Balance,
+		},
+		/// Some assets were destroyed.
+		Burned { asset_id: T::AssetId, owner: T::AccountId, balance: T::Balance },
+		/// The management team changed.
+		TeamChanged {
+			asset_id: T::AssetId,
+			issuer: T::AccountId,
+			admin: T::AccountId,
+			freezer: T::AccountId,
+		},
+		/// The owner changed.
+		OwnerChanged { asset_id: T::AssetId, owner: T::AccountId },
+		/// Some account `who` was frozen.
+		Frozen { asset_id: T::AssetId, who: T::AccountId },
+		/// Some account `who` was thawed.
+		Thawed { asset_id: T::AssetId, who: T::AccountId },
+		/// Some asset `asset_id` was frozen.
+		AssetFrozen { asset_id: T::AssetId },
+		/// Some asset `asset_id` was thawed.
+		AssetThawed { asset_id: T::AssetId },
+		/// Accounts were destroyed for given asset.
+		AccountsDestroyed { asset_id: T::AssetId, accounts_destroyed: u32, accounts_remaining: u32 },
+		/// Approvals were destroyed for given asset.
+		ApprovalsDestroyed {
+			asset_id: T::AssetId,
+			approvals_destroyed: u32,
+			approvals_remaining: u32,
+		},
+		/// An asset class is in the process of being destroyed.
+		DestructionStarted { asset_id: T::AssetId },
+		/// An asset class was destroyed.
+		Destroyed { asset_id: T::AssetId },
+		/// Some asset class was force-created.
+		ForceCreated { asset_id: T::AssetId, owner: T::AccountId },
+		/// New metadata has been set for an asset.
+		MetadataSet {
+			asset_id: T::AssetId,
+			name: Vec<u8>,
+			symbol: Vec<u8>,
+			decimals: u8,
+			is_frozen: bool,
+		},
+		/// Metadata has been cleared for an asset.
+		MetadataCleared { asset_id: T::AssetId },
+		/// (Additional) funds have been approved for transfer to a destination account.
+		ApprovedTransfer {
+			asset_id: T::AssetId,
+			source: T::AccountId,
+			delegate: T::AccountId,
+			amount: T::Balance,
+		},
+		/// An approval for account `delegate` was cancelled by `owner`.
+		ApprovalCancelled { asset_id: T::AssetId, owner: T::AccountId, delegate: T::AccountId },
+		/// An `amount` was transferred in its entirety from `owner` to `destination` by
+		/// the approved `delegate`.
+		TransferredApproved {
+			asset_id: T::AssetId,
+			owner: T::AccountId,
+			delegate: T::AccountId,
+			destination: T::AccountId,
+			amount: T::Balance,
+		},
+		/// An asset has had its attributes changed by the `Force` origin.
+		AssetStatusChanged { asset_id: T::AssetId },
+		/// The min_balance of an asset has been updated by the asset owner.
+		AssetMinBalanceChanged { asset_id: T::AssetId, new_min_balance: T::Balance },
+		/// Some account `who` was created with a deposit from `depositor`.
+		Touched { asset_id: T::AssetId, who: T::AccountId, depositor: T::AccountId },
+		/// Some account `who` was blocked.
+		Blocked { asset_id: T::AssetId, who: T::AccountId },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Account balance must be greater than or equal to the transfer amount.
+		BalanceLow,
+		/// The account to alter does not exist.
+		NoAccount,
+		/// The signing account has no permission to do the operation.
+		NoPermission,
+		/// The given asset ID is unknown.
+		Unknown,
+		/// The origin account is frozen.
+		Frozen,
+		/// The asset ID is already taken.
+		InUse,
+		/// Invalid witness data given.
+		BadWitness,
+		/// Minimum balance should be non-zero.
+		MinBalanceZero,
+		/// Unable to increment the consumer reference counters on the account. Either no provider
+		/// reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
+		/// fewer then the maximum number of consumers has been reached.
+		UnavailableConsumer,
+		/// Invalid metadata given.
+		BadMetadata,
+		/// No approval exists that would allow the transfer.
+		Unapproved,
+		/// The source account would not survive the transfer and it needs to stay alive.
+		WouldDie,
+		/// The asset-account already exists.
+		AlreadyExists,
+		/// The asset-account doesn't have an associated deposit.
+		NoDeposit,
+		/// The operation would result in funds being burned.
+		WouldBurn,
+		/// The asset is a live asset and is actively being used. Usually emit for operations such
+		/// as `start_destroy` which require the asset to be in a destroying state.
+		LiveAsset,
+		/// The asset is not live, and likely being destroyed.
+		AssetNotLive,
+		/// The asset status is not the expected status.
+		IncorrectStatus,
+		/// The asset should be frozen before the given operation.
+		NotFrozen,
+		/// Callback action resulted in error
+		CallbackFailed,
+	}
+
+	#[pallet::call(weight(<T as Config<I>>::WeightInfo))]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Issue a new class of fungible assets from a public origin.
+		///
+		/// This new asset class has no assets initially and its owner is the origin.
+		///
+		/// The origin must conform to the configured `CreateOrigin` and have sufficient funds free.
+		///
+		/// Funds of sender are reserved by `AssetDeposit`.
+		///
+		/// Parameters:
+		/// - `id`: The identifier of the new asset. This must not be currently in use to identify
+		/// an existing asset.
+		/// - `admin`: The admin of this class of assets. The admin is the initial address of each
+		/// member of the asset class's admin team.
+		/// - `min_balance`: The minimum balance of this new asset that any single account must
+		/// have. If an account's balance is reduced below this, then it collapses to zero.
+		///
+		/// Emits `Created` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(0)]
+		pub fn create(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			admin: AccountIdLookupOf<T>,
+			min_balance: T::Balance,
+		) -> DispatchResult {
+			let id: T::AssetId = id.into();
+			let owner = T::CreateOrigin::ensure_origin(origin, &id)?;
+			let admin = T::Lookup::lookup(admin)?;
+
+			ensure!(!Asset::<T, I>::contains_key(&id), Error::<T, I>::InUse);
+			ensure!(!min_balance.is_zero(), Error::<T, I>::MinBalanceZero);
+
+			let deposit = T::AssetDeposit::get();
+			T::Currency::reserve(&owner, deposit)?;
+
+			Asset::<T, I>::insert(
+				id.clone(),
+				AssetDetails {
+					owner: owner.clone(),
+					issuer: admin.clone(),
+					admin: admin.clone(),
+					freezer: admin.clone(),
+					supply: Zero::zero(),
+					deposit,
+					min_balance,
+					is_sufficient: false,
+					accounts: 0,
+					sufficients: 0,
+					approvals: 0,
+					status: AssetStatus::Live,
+				},
+			);
+			ensure!(T::CallbackHandle::created(&id, &owner).is_ok(), Error::<T, I>::CallbackFailed);
+			Self::deposit_event(Event::Created {
+				asset_id: id,
+				creator: owner.clone(),
+				owner: admin,
+			});
+
+			Ok(())
+		}
+
+		/// Issue a new class of fungible assets from a privileged origin.
+		///
+		/// This new asset class has no assets initially.
+		///
+		/// The origin must conform to `ForceOrigin`.
+		///
+		/// Unlike `create`, no funds are reserved.
+		///
+		/// - `id`: The identifier of the new asset. This must not be currently in use to identify
+		/// an existing asset.
+		/// - `owner`: The owner of this class of assets. The owner has full superuser permissions
+		/// over this asset, but may later change and configure the permissions using
+		/// `transfer_ownership` and `set_team`.
+		/// - `min_balance`: The minimum balance of this new asset that any single account must
+		/// have. If an account's balance is reduced below this, then it collapses to zero.
+		///
+		/// Emits `ForceCreated` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(1)]
+		pub fn force_create(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			owner: AccountIdLookupOf<T>,
+			is_sufficient: bool,
+			#[pallet::compact] min_balance: T::Balance,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+			let id: T::AssetId = id.into();
+			Self::do_force_create(id, owner, is_sufficient, min_balance)
+		}
+
+		/// Start the process of destroying a fungible asset class.
+		///
+		/// `start_destroy` is the first in a series of extrinsics that should be called, to allow
+		/// destruction of an asset class.
+		///
+		/// The origin must conform to `ForceOrigin` or must be `Signed` by the asset's `owner`.
+		///
+		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing
+		///   asset.
+		///
+		/// The asset class must be frozen before calling `start_destroy`.
+		#[pallet::call_index(2)]
+		pub fn start_destroy(origin: OriginFor<T>, id: T::AssetIdParameter) -> DispatchResult {
+			let maybe_check_owner = match T::ForceOrigin::try_origin(origin) {
+				Ok(_) => None,
+				Err(origin) => Some(ensure_signed(origin)?),
+			};
+			let id: T::AssetId = id.into();
+			Self::do_start_destroy(id, maybe_check_owner)
+		}
+
+		/// Destroy all accounts associated with a given asset.
+		///
+		/// `destroy_accounts` should only be called after `start_destroy` has been called, and the
+		/// asset is in a `Destroying` state.
+		///
+		/// Due to weight restrictions, this function may need to be called multiple times to fully
+		/// destroy all accounts. It will destroy `RemoveItemsLimit` accounts at a time.
+		///
+		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing
+		///   asset.
+		///
+		/// Each call emits the `Event::DestroyedAccounts` event.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::destroy_accounts(T::RemoveItemsLimit::get()))]
+		pub fn destroy_accounts(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+			let removed_accounts = Self::do_destroy_accounts(id, T::RemoveItemsLimit::get())?;
+			Ok(Some(T::WeightInfo::destroy_accounts(removed_accounts)).into())
+		}
+
+		/// Destroy all approvals associated with a given asset up to the max (T::RemoveItemsLimit).
+		///
+		/// `destroy_approvals` should only be called after `start_destroy` has been called, and the
+		/// asset is in a `Destroying` state.
+		///
+		/// Due to weight restrictions, this function may need to be called multiple times to fully
+		/// destroy all approvals. It will destroy `RemoveItemsLimit` approvals at a time.
+		///
+		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing
+		///   asset.
+		///
+		/// Each call emits the `Event::DestroyedApprovals` event.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::destroy_approvals(T::RemoveItemsLimit::get()))]
+		pub fn destroy_approvals(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+			let removed_approvals = Self::do_destroy_approvals(id, T::RemoveItemsLimit::get())?;
+			Ok(Some(T::WeightInfo::destroy_approvals(removed_approvals)).into())
+		}
+
+		/// Complete destroying asset and unreserve currency.
+		///
+		/// `finish_destroy` should only be called after `start_destroy` has been called, and the
+		/// asset is in a `Destroying` state. All accounts or approvals should be destroyed before
+		/// hand.
+		///
+		/// - `id`: The identifier of the asset to be destroyed. This must identify an existing
+		///   asset.
+		///
+		/// Each successful call emits the `Event::Destroyed` event.
+		#[pallet::call_index(5)]
+		pub fn finish_destroy(origin: OriginFor<T>, id: T::AssetIdParameter) -> DispatchResult {
+			let _ = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+			Self::do_finish_destroy(id)
+		}
+
+		/// Mint assets of a particular class.
+		///
+		/// The origin must be Signed and the sender must be the Issuer of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to have some amount minted.
+		/// - `beneficiary`: The account to be credited with the minted assets.
+		/// - `amount`: The amount of the asset to be minted.
+		///
+		/// Emits `Issued` event when successful.
+		///
+		/// Weight: `O(1)`
+		/// Modes: Pre-existing balance of `beneficiary`; Account pre-existence of `beneficiary`.
+		#[pallet::call_index(6)]
+		pub fn mint(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			beneficiary: AccountIdLookupOf<T>,
+			#[pallet::compact] amount: T::Balance,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+			let id: T::AssetId = id.into();
+			Self::do_mint(id, &beneficiary, amount, Some(origin))?;
+			Ok(())
+		}
+
+		/// Reduce the balance of `who` by as much as possible up to `amount` assets of `id`.
+		///
+		/// Origin must be Signed and the sender should be the Manager of the asset `id`.
+		///
+		/// Bails with `NoAccount` if the `who` is already dead.
+		///
+		/// - `id`: The identifier of the asset to have some amount burned.
+		/// - `who`: The account to be debited from.
+		/// - `amount`: The maximum amount by which `who`'s balance should be reduced.
+		///
+		/// Emits `Burned` with the actual amount burned. If this takes the balance to below the
+		/// minimum for the asset, then the amount burned is increased to take it to zero.
+		///
+		/// Weight: `O(1)`
+		/// Modes: Post-existence of `who`; Pre & post Zombie-status of `who`.
+		#[pallet::call_index(7)]
+		pub fn burn(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: AccountIdLookupOf<T>,
+			#[pallet::compact] amount: T::Balance,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let id: T::AssetId = id.into();
+
+			let f = DebitFlags { keep_alive: false, best_effort: true };
+			let _ = Self::do_burn(id, &who, amount, Some(origin), f)?;
+			Ok(())
+		}
+
+		/// Move some assets from the sender account to another.
+		///
+		/// Origin must be Signed.
+		///
+		/// - `id`: The identifier of the asset to have some amount transferred.
+		/// - `target`: The account to be credited.
+		/// - `amount`: The amount by which the sender's balance of assets should be reduced and
+		/// `target`'s balance increased. The amount actually transferred may be slightly greater in
+		/// the case that the transfer would otherwise take the sender balance above zero but below
+		/// the minimum balance. Must be greater than zero.
+		///
+		/// Emits `Transferred` with the actual amount transferred. If this takes the source balance
+		/// to below the minimum for the asset, then the amount transferred is increased to take it
+		/// to zero.
+		///
+		/// Weight: `O(1)`
+		/// Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of
+		/// `target`.
+		#[pallet::call_index(8)]
+		pub fn transfer(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			target: AccountIdLookupOf<T>,
+			#[pallet::compact] amount: T::Balance,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let dest = T::Lookup::lookup(target)?;
+			let id: T::AssetId = id.into();
+
+			let f = TransferFlags { keep_alive: false, best_effort: false, burn_dust: false };
+			Self::do_transfer(id, &origin, &dest, amount, None, f).map(|_| ())
+		}
+
+		/// Move some assets from the sender account to another, keeping the sender account alive.
+		///
+		/// Origin must be Signed.
+		///
+		/// - `id`: The identifier of the asset to have some amount transferred.
+		/// - `target`: The account to be credited.
+		/// - `amount`: The amount by which the sender's balance of assets should be reduced and
+		/// `target`'s balance increased. The amount actually transferred may be slightly greater in
+		/// the case that the transfer would otherwise take the sender balance above zero but below
+		/// the minimum balance. Must be greater than zero.
+		///
+		/// Emits `Transferred` with the actual amount transferred. If this takes the source balance
+		/// to below the minimum for the asset, then the amount transferred is increased to take it
+		/// to zero.
+		///
+		/// Weight: `O(1)`
+		/// Modes: Pre-existence of `target`; Post-existence of sender; Account pre-existence of
+		/// `target`.
+		#[pallet::call_index(9)]
+		pub fn transfer_keep_alive(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			target: AccountIdLookupOf<T>,
+			#[pallet::compact] amount: T::Balance,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			let dest = T::Lookup::lookup(target)?;
+			let id: T::AssetId = id.into();
+
+			let f = TransferFlags { keep_alive: true, best_effort: false, burn_dust: false };
+			Self::do_transfer(id, &source, &dest, amount, None, f).map(|_| ())
+		}
+
+		/// Move some assets from one account to another.
+		///
+		/// Origin must be Signed and the sender should be the Admin of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to have some amount transferred.
+		/// - `source`: The account to be debited.
+		/// - `dest`: The account to be credited.
+		/// - `amount`: The amount by which the `source`'s balance of assets should be reduced and
+		/// `dest`'s balance increased. The amount actually transferred may be slightly greater in
+		/// the case that the transfer would otherwise take the `source` balance above zero but
+		/// below the minimum balance. Must be greater than zero.
+		///
+		/// Emits `Transferred` with the actual amount transferred. If this takes the source balance
+		/// to below the minimum for the asset, then the amount transferred is increased to take it
+		/// to zero.
+		///
+		/// Weight: `O(1)`
+		/// Modes: Pre-existence of `dest`; Post-existence of `source`; Account pre-existence of
+		/// `dest`.
+		#[pallet::call_index(10)]
+		pub fn force_transfer(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			source: AccountIdLookupOf<T>,
+			dest: AccountIdLookupOf<T>,
+			#[pallet::compact] amount: T::Balance,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let source = T::Lookup::lookup(source)?;
+			let dest = T::Lookup::lookup(dest)?;
+			let id: T::AssetId = id.into();
+
+			let f = TransferFlags { keep_alive: false, best_effort: false, burn_dust: false };
+			Self::do_transfer(id, &source, &dest, amount, Some(origin), f).map(|_| ())
+		}
+
+		/// Disallow further unprivileged transfers of an asset `id` from an account `who`. `who`
+		/// must already exist as an entry in `Account`s of the asset. If you want to freeze an
+		/// account that does not have an entry, use `touch_other` first.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to be frozen.
+		/// - `who`: The account to be frozen.
+		///
+		/// Emits `Frozen`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(11)]
+		pub fn freeze(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+
+			let d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			ensure!(
+				d.status == AssetStatus::Live || d.status == AssetStatus::Frozen,
+				Error::<T, I>::AssetNotLive
+			);
+			ensure!(origin == d.freezer, Error::<T, I>::NoPermission);
+			let who = T::Lookup::lookup(who)?;
+
+			Account::<T, I>::try_mutate(&id, &who, |maybe_account| -> DispatchResult {
+				maybe_account.as_mut().ok_or(Error::<T, I>::NoAccount)?.status =
+					AccountStatus::Frozen;
+				Ok(())
+			})?;
+
+			Self::deposit_event(Event::<T, I>::Frozen { asset_id: id, who });
+			Ok(())
+		}
+
+		/// Allow unprivileged transfers to and from an account again.
+		///
+		/// Origin must be Signed and the sender should be the Admin of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to be frozen.
+		/// - `who`: The account to be unfrozen.
+		///
+		/// Emits `Thawed`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(12)]
+		pub fn thaw(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+
+			let details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			ensure!(
+				details.status == AssetStatus::Live || details.status == AssetStatus::Frozen,
+				Error::<T, I>::AssetNotLive
+			);
+			ensure!(origin == details.admin, Error::<T, I>::NoPermission);
+			let who = T::Lookup::lookup(who)?;
+
+			Account::<T, I>::try_mutate(&id, &who, |maybe_account| -> DispatchResult {
+				maybe_account.as_mut().ok_or(Error::<T, I>::NoAccount)?.status =
+					AccountStatus::Liquid;
+				Ok(())
+			})?;
+
+			Self::deposit_event(Event::<T, I>::Thawed { asset_id: id, who });
+			Ok(())
+		}
+
+		/// Disallow further unprivileged transfers for the asset class.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to be frozen.
+		///
+		/// Emits `Frozen`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(13)]
+		pub fn freeze_asset(origin: OriginFor<T>, id: T::AssetIdParameter) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+
+			Asset::<T, I>::try_mutate(id.clone(), |maybe_details| {
+				let d = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+				ensure!(d.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+				ensure!(origin == d.freezer, Error::<T, I>::NoPermission);
+
+				d.status = AssetStatus::Frozen;
+
+				Self::deposit_event(Event::<T, I>::AssetFrozen { asset_id: id });
+				Ok(())
+			})
+		}
+
+		/// Allow unprivileged transfers for the asset again.
+		///
+		/// Origin must be Signed and the sender should be the Admin of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to be thawed.
+		///
+		/// Emits `Thawed`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(14)]
+		pub fn thaw_asset(origin: OriginFor<T>, id: T::AssetIdParameter) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+
+			Asset::<T, I>::try_mutate(id.clone(), |maybe_details| {
+				let d = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+				ensure!(origin == d.admin, Error::<T, I>::NoPermission);
+				ensure!(d.status == AssetStatus::Frozen, Error::<T, I>::NotFrozen);
+
+				d.status = AssetStatus::Live;
+
+				Self::deposit_event(Event::<T, I>::AssetThawed { asset_id: id });
+				Ok(())
+			})
+		}
+
+		/// Change the Owner of an asset.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset.
+		/// - `owner`: The new Owner of this asset.
+		///
+		/// Emits `OwnerChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(15)]
+		pub fn transfer_ownership(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			owner: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+			let id: T::AssetId = id.into();
+
+			Asset::<T, I>::try_mutate(id.clone(), |maybe_details| {
+				let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+				ensure!(details.status == AssetStatus::Live, Error::<T, I>::LiveAsset);
+				ensure!(origin == details.owner, Error::<T, I>::NoPermission);
+				if details.owner == owner {
+					return Ok(())
+				}
+
+				let metadata_deposit = Metadata::<T, I>::get(&id).deposit;
+				let deposit = details.deposit + metadata_deposit;
+
+				// Move the deposit to the new owner.
+				T::Currency::repatriate_reserved(&details.owner, &owner, deposit, Reserved)?;
+
+				details.owner = owner.clone();
+
+				Self::deposit_event(Event::OwnerChanged { asset_id: id, owner });
+				Ok(())
+			})
+		}
+
+		/// Change the Issuer, Admin and Freezer of an asset.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the asset `id`.
+		///
+		/// - `id`: The identifier of the asset to be frozen.
+		/// - `issuer`: The new Issuer of this asset.
+		/// - `admin`: The new Admin of this asset.
+		/// - `freezer`: The new Freezer of this asset.
+		///
+		/// Emits `TeamChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(16)]
+		pub fn set_team(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			issuer: AccountIdLookupOf<T>,
+			admin: AccountIdLookupOf<T>,
+			freezer: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let issuer = T::Lookup::lookup(issuer)?;
+			let admin = T::Lookup::lookup(admin)?;
+			let freezer = T::Lookup::lookup(freezer)?;
+			let id: T::AssetId = id.into();
+
+			Asset::<T, I>::try_mutate(id.clone(), |maybe_details| {
+				let details = maybe_details.as_mut().ok_or(Error::<T, I>::Unknown)?;
+				ensure!(details.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+				ensure!(origin == details.owner, Error::<T, I>::NoPermission);
+
+				details.issuer = issuer.clone();
+				details.admin = admin.clone();
+				details.freezer = freezer.clone();
+
+				Self::deposit_event(Event::TeamChanged { asset_id: id, issuer, admin, freezer });
+				Ok(())
+			})
+		}
+
+		/// Set the metadata for an asset.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the asset `id`.
+		///
+		/// Funds of sender are reserved according to the formula:
+		/// `MetadataDepositBase + MetadataDepositPerByte * (name.len + symbol.len)` taking into
+		/// account any already reserved funds.
+		///
+		/// - `id`: The identifier of the asset to update.
+		/// - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.
+		/// - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
+		/// - `decimals`: The number of decimals this asset uses to represent one unit.
+		///
+		/// Emits `MetadataSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(17)]
+		#[pallet::weight(T::WeightInfo::set_metadata(name.len() as u32, symbol.len() as u32))]
+		pub fn set_metadata(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			name: Vec<u8>,
+			symbol: Vec<u8>,
+			decimals: u8,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+			Self::do_set_metadata(id, &origin, name, symbol, decimals)
+		}
+
+		/// Clear the metadata for an asset.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the asset `id`.
+		///
+		/// Any deposit is freed for the asset owner.
+		///
+		/// - `id`: The identifier of the asset to clear.
+		///
+		/// Emits `MetadataCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(18)]
+		pub fn clear_metadata(origin: OriginFor<T>, id: T::AssetIdParameter) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+
+			let d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			ensure!(d.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+			ensure!(origin == d.owner, Error::<T, I>::NoPermission);
+
+			Metadata::<T, I>::try_mutate_exists(id.clone(), |metadata| {
+				let deposit = metadata.take().ok_or(Error::<T, I>::Unknown)?.deposit;
+				T::Currency::unreserve(&d.owner, deposit);
+				Self::deposit_event(Event::MetadataCleared { asset_id: id });
+				Ok(())
+			})
+		}
+
+		/// Force the metadata for an asset to some value.
+		///
+		/// Origin must be ForceOrigin.
+		///
+		/// Any deposit is left alone.
+		///
+		/// - `id`: The identifier of the asset to update.
+		/// - `name`: The user friendly name of this asset. Limited in length by `StringLimit`.
+		/// - `symbol`: The exchange symbol for this asset. Limited in length by `StringLimit`.
+		/// - `decimals`: The number of decimals this asset uses to represent one unit.
+		///
+		/// Emits `MetadataSet`.
+		///
+		/// Weight: `O(N + S)` where N and S are the length of the name and symbol respectively.
+		#[pallet::call_index(19)]
+		#[pallet::weight(T::WeightInfo::force_set_metadata(name.len() as u32, symbol.len() as u32))]
+		pub fn force_set_metadata(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			name: Vec<u8>,
+			symbol: Vec<u8>,
+			decimals: u8,
+			is_frozen: bool,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			let id: T::AssetId = id.into();
+
+			let bounded_name: BoundedVec<u8, T::StringLimit> =
+				name.clone().try_into().map_err(|_| Error::<T, I>::BadMetadata)?;
+
+			let bounded_symbol: BoundedVec<u8, T::StringLimit> =
+				symbol.clone().try_into().map_err(|_| Error::<T, I>::BadMetadata)?;
+
+			ensure!(Asset::<T, I>::contains_key(&id), Error::<T, I>::Unknown);
+			Metadata::<T, I>::try_mutate_exists(id.clone(), |metadata| {
+				let deposit = metadata.take().map_or(Zero::zero(), |m| m.deposit);
+				*metadata = Some(AssetMetadata {
+					deposit,
+					name: bounded_name,
+					symbol: bounded_symbol,
+					decimals,
+					is_frozen,
+				});
+
+				Self::deposit_event(Event::MetadataSet {
+					asset_id: id,
+					name,
+					symbol,
+					decimals,
+					is_frozen,
+				});
+				Ok(())
+			})
+		}
+
+		/// Clear the metadata for an asset.
+		///
+		/// Origin must be ForceOrigin.
+		///
+		/// Any deposit is returned.
+		///
+		/// - `id`: The identifier of the asset to clear.
+		///
+		/// Emits `MetadataCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(20)]
+		pub fn force_clear_metadata(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			let id: T::AssetId = id.into();
+
+			let d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			Metadata::<T, I>::try_mutate_exists(id.clone(), |metadata| {
+				let deposit = metadata.take().ok_or(Error::<T, I>::Unknown)?.deposit;
+				T::Currency::unreserve(&d.owner, deposit);
+				Self::deposit_event(Event::MetadataCleared { asset_id: id });
+				Ok(())
+			})
+		}
+
+		/// Alter the attributes of a given asset.
+		///
+		/// Origin must be `ForceOrigin`.
+		///
+		/// - `id`: The identifier of the asset.
+		/// - `owner`: The new Owner of this asset.
+		/// - `issuer`: The new Issuer of this asset.
+		/// - `admin`: The new Admin of this asset.
+		/// - `freezer`: The new Freezer of this asset.
+		/// - `min_balance`: The minimum balance of this new asset that any single account must
+		/// have. If an account's balance is reduced below this, then it collapses to zero.
+		/// - `is_sufficient`: Whether a non-zero balance of this asset is deposit of sufficient
+		/// value to account for the state bloat associated with its balance storage. If set to
+		/// `true`, then non-zero balances may be stored without a `consumer` reference (and thus
+		/// an ED in the Balances pallet or whatever else is used to control user-account state
+		/// growth).
+		/// - `is_frozen`: Whether this asset class is frozen except for permissioned/admin
+		/// instructions.
+		///
+		/// Emits `AssetStatusChanged` with the identity of the asset.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(21)]
+		pub fn force_asset_status(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			owner: AccountIdLookupOf<T>,
+			issuer: AccountIdLookupOf<T>,
+			admin: AccountIdLookupOf<T>,
+			freezer: AccountIdLookupOf<T>,
+			#[pallet::compact] min_balance: T::Balance,
+			is_sufficient: bool,
+			is_frozen: bool,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			let id: T::AssetId = id.into();
+
+			Asset::<T, I>::try_mutate(id.clone(), |maybe_asset| {
+				let mut asset = maybe_asset.take().ok_or(Error::<T, I>::Unknown)?;
+				ensure!(asset.status != AssetStatus::Destroying, Error::<T, I>::AssetNotLive);
+				asset.owner = T::Lookup::lookup(owner)?;
+				asset.issuer = T::Lookup::lookup(issuer)?;
+				asset.admin = T::Lookup::lookup(admin)?;
+				asset.freezer = T::Lookup::lookup(freezer)?;
+				asset.min_balance = min_balance;
+				asset.is_sufficient = is_sufficient;
+				if is_frozen {
+					asset.status = AssetStatus::Frozen;
+				} else {
+					asset.status = AssetStatus::Live;
+				}
+				*maybe_asset = Some(asset);
+
+				Self::deposit_event(Event::AssetStatusChanged { asset_id: id });
+				Ok(())
+			})
+		}
+
+		/// Approve an amount of asset for transfer by a delegated third-party account.
+		///
+		/// Origin must be Signed.
+		///
+		/// Ensures that `ApprovalDeposit` worth of `Currency` is reserved from signing account
+		/// for the purpose of holding the approval. If some non-zero amount of assets is already
+		/// approved from signing account to `delegate`, then it is topped up or unreserved to
+		/// meet the right value.
+		///
+		/// NOTE: The signing account does not need to own `amount` of assets at the point of
+		/// making this call.
+		///
+		/// - `id`: The identifier of the asset.
+		/// - `delegate`: The account to delegate permission to transfer asset.
+		/// - `amount`: The amount of asset that may be transferred by `delegate`. If there is
+		/// already an approval in place, then this acts additively.
+		///
+		/// Emits `ApprovedTransfer` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(22)]
+		pub fn approve_transfer(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			delegate: AccountIdLookupOf<T>,
+			#[pallet::compact] amount: T::Balance,
+		) -> DispatchResult {
+			let owner = ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			let id: T::AssetId = id.into();
+			Self::do_approve_transfer(id, &owner, &delegate, amount)
+		}
+
+		/// Cancel all of some asset approved for delegated transfer by a third-party account.
+		///
+		/// Origin must be Signed and there must be an approval in place between signer and
+		/// `delegate`.
+		///
+		/// Unreserves any deposit previously reserved by `approve_transfer` for the approval.
+		///
+		/// - `id`: The identifier of the asset.
+		/// - `delegate`: The account delegated permission to transfer asset.
+		///
+		/// Emits `ApprovalCancelled` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(23)]
+		pub fn cancel_approval(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			delegate: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let owner = ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			let id: T::AssetId = id.into();
+			let mut d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			ensure!(d.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+
+			let approval = Approvals::<T, I>::take((id.clone(), &owner, &delegate))
+				.ok_or(Error::<T, I>::Unknown)?;
+			T::Currency::unreserve(&owner, approval.deposit);
+
+			d.approvals.saturating_dec();
+			Asset::<T, I>::insert(id.clone(), d);
+
+			Self::deposit_event(Event::ApprovalCancelled { asset_id: id, owner, delegate });
+			Ok(())
+		}
+
+		/// Cancel all of some asset approved for delegated transfer by a third-party account.
+		///
+		/// Origin must be either ForceOrigin or Signed origin with the signer being the Admin
+		/// account of the asset `id`.
+		///
+		/// Unreserves any deposit previously reserved by `approve_transfer` for the approval.
+		///
+		/// - `id`: The identifier of the asset.
+		/// - `delegate`: The account delegated permission to transfer asset.
+		///
+		/// Emits `ApprovalCancelled` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(24)]
+		pub fn force_cancel_approval(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			owner: AccountIdLookupOf<T>,
+			delegate: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let id: T::AssetId = id.into();
+			let mut d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			ensure!(d.status == AssetStatus::Live, Error::<T, I>::AssetNotLive);
+			T::ForceOrigin::try_origin(origin)
+				.map(|_| ())
+				.or_else(|origin| -> DispatchResult {
+					let origin = ensure_signed(origin)?;
+					ensure!(origin == d.admin, Error::<T, I>::NoPermission);
+					Ok(())
+				})?;
+
+			let owner = T::Lookup::lookup(owner)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+
+			let approval = Approvals::<T, I>::take((id.clone(), &owner, &delegate))
+				.ok_or(Error::<T, I>::Unknown)?;
+			T::Currency::unreserve(&owner, approval.deposit);
+			d.approvals.saturating_dec();
+			Asset::<T, I>::insert(id.clone(), d);
+
+			Self::deposit_event(Event::ApprovalCancelled { asset_id: id, owner, delegate });
+			Ok(())
+		}
+
+		/// Transfer some asset balance from a previously delegated account to some third-party
+		/// account.
+		///
+		/// Origin must be Signed and there must be an approval in place by the `owner` to the
+		/// signer.
+		///
+		/// If the entire amount approved for transfer is transferred, then any deposit previously
+		/// reserved by `approve_transfer` is unreserved.
+		///
+		/// - `id`: The identifier of the asset.
+		/// - `owner`: The account which previously approved for a transfer of at least `amount` and
+		/// from which the asset balance will be withdrawn.
+		/// - `destination`: The account to which the asset balance of `amount` will be transferred.
+		/// - `amount`: The amount of assets to transfer.
+		///
+		/// Emits `TransferredApproved` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(25)]
+		pub fn transfer_approved(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			owner: AccountIdLookupOf<T>,
+			destination: AccountIdLookupOf<T>,
+			#[pallet::compact] amount: T::Balance,
+		) -> DispatchResult {
+			let delegate = ensure_signed(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+			let destination = T::Lookup::lookup(destination)?;
+			let id: T::AssetId = id.into();
+			Self::do_transfer_approved(id, &owner, &delegate, &destination, amount)
+		}
+
+		/// Create an asset account for non-provider assets.
+		///
+		/// A deposit will be taken from the signer account.
+		///
+		/// - `origin`: Must be Signed; the signer account must have sufficient funds for a deposit
+		///   to be taken.
+		/// - `id`: The identifier of the asset for the account to be created.
+		///
+		/// Emits `Touched` event when successful.
+		#[pallet::call_index(26)]
+		#[pallet::weight(T::WeightInfo::touch())]
+		pub fn touch(origin: OriginFor<T>, id: T::AssetIdParameter) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+			Self::do_touch(id, who.clone(), who, false)
+		}
+
+		/// Return the deposit (if any) of an asset account or a consumer reference (if any) of an
+		/// account.
+		///
+		/// The origin must be Signed.
+		///
+		/// - `id`: The identifier of the asset for which the caller would like the deposit
+		///   refunded.
+		/// - `allow_burn`: If `true` then assets may be destroyed in order to complete the refund.
+		///
+		/// Emits `Refunded` event when successful.
+		#[pallet::call_index(27)]
+		#[pallet::weight(T::WeightInfo::refund())]
+		pub fn refund(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			allow_burn: bool,
+		) -> DispatchResult {
+			let id: T::AssetId = id.into();
+			Self::do_refund(id, ensure_signed(origin)?, allow_burn)
+		}
+
+		/// Sets the minimum balance of an asset.
+		///
+		/// Only works if there aren't any accounts that are holding the asset or if
+		/// the new value of `min_balance` is less than the old one.
+		///
+		/// Origin must be Signed and the sender has to be the Owner of the
+		/// asset `id`.
+		///
+		/// - `id`: The identifier of the asset.
+		/// - `min_balance`: The new value of `min_balance`.
+		///
+		/// Emits `AssetMinBalanceChanged` event when successful.
+		#[pallet::call_index(28)]
+		pub fn set_min_balance(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			min_balance: T::Balance,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+
+			let mut details = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			ensure!(origin == details.owner, Error::<T, I>::NoPermission);
+
+			let old_min_balance = details.min_balance;
+			// If the asset is marked as sufficient it won't be allowed to
+			// change the min_balance.
+			ensure!(!details.is_sufficient, Error::<T, I>::NoPermission);
+
+			// Ensure that either the new min_balance is less than old
+			// min_balance or there aren't any accounts holding the asset.
+			ensure!(
+				min_balance < old_min_balance || details.accounts == 0,
+				Error::<T, I>::NoPermission
+			);
+
+			details.min_balance = min_balance;
+			Asset::<T, I>::insert(&id, details);
+
+			Self::deposit_event(Event::AssetMinBalanceChanged {
+				asset_id: id,
+				new_min_balance: min_balance,
+			});
+			Ok(())
+		}
+
+		/// Create an asset account for `who`.
+		///
+		/// A deposit will be taken from the signer account.
+		///
+		/// - `origin`: Must be Signed by `Freezer` or `Admin` of the asset `id`; the signer account
+		///   must have sufficient funds for a deposit to be taken.
+		/// - `id`: The identifier of the asset for the account to be created.
+		/// - `who`: The account to be created.
+		///
+		/// Emits `Touched` event when successful.
+		#[pallet::call_index(29)]
+		#[pallet::weight(T::WeightInfo::touch_other())]
+		pub fn touch_other(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let id: T::AssetId = id.into();
+			Self::do_touch(id, who, origin, true)
+		}
+
+		/// Return the deposit (if any) of a target asset account. Useful if you are the depositor.
+		///
+		/// The origin must be Signed and either the account owner, depositor, or asset `Admin`. In
+		/// order to burn a non-zero balance of the asset, the caller must be the account and should
+		/// use `refund`.
+		///
+		/// - `id`: The identifier of the asset for the account holding a deposit.
+		/// - `who`: The account to refund.
+		///
+		/// Emits `Refunded` event when successful.
+		#[pallet::call_index(30)]
+		#[pallet::weight(T::WeightInfo::refund_other())]
+		pub fn refund_other(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let id: T::AssetId = id.into();
+			Self::do_refund_other(id, &who, &origin)
+		}
+
+		/// Disallow further unprivileged transfers of an asset `id` to and from an account `who`.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the asset `id`.
+		///
+		/// - `id`: The identifier of the account's asset.
+		/// - `who`: The account to be unblocked.
+		///
+		/// Emits `Blocked`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(31)]
+		pub fn block(
+			origin: OriginFor<T>,
+			id: T::AssetIdParameter,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let id: T::AssetId = id.into();
+
+			let d = Asset::<T, I>::get(&id).ok_or(Error::<T, I>::Unknown)?;
+			ensure!(
+				d.status == AssetStatus::Live || d.status == AssetStatus::Frozen,
+				Error::<T, I>::AssetNotLive
+			);
+			ensure!(origin == d.freezer, Error::<T, I>::NoPermission);
+			let who = T::Lookup::lookup(who)?;
+
+			Account::<T, I>::try_mutate(&id, &who, |maybe_account| -> DispatchResult {
+				maybe_account.as_mut().ok_or(Error::<T, I>::NoAccount)?.status =
+					AccountStatus::Blocked;
+				Ok(())
+			})?;
+
+			Self::deposit_event(Event::<T, I>::Blocked { asset_id: id, who });
+			Ok(())
+		}
+	}
+
+	/// Implements [`AccountTouch`] trait.
+	/// Note that a depositor can be any account, without any specific privilege.
+	/// This implementation is supposed to be used only for creation of system accounts.
+	impl<T: Config<I>, I: 'static> AccountTouch<T::AssetId, T::AccountId> for Pallet<T, I> {
+		type Balance = DepositBalanceOf<T, I>;
+
+		fn deposit_required(_: T::AssetId) -> Self::Balance {
+			T::AssetAccountDeposit::get()
+		}
+
+		fn touch(asset: T::AssetId, who: T::AccountId, depositor: T::AccountId) -> DispatchResult {
+			Self::do_touch(asset, who, depositor, false)
+		}
+	}
+
+	/// Implements [`ContainsPair`] trait for a pair of asset and account IDs.
+	impl<T: Config<I>, I: 'static> ContainsPair<T::AssetId, T::AccountId> for Pallet<T, I> {
+		/// Check if an account with the given asset ID and account address exists.
+		fn contains(asset: &T::AssetId, who: &T::AccountId) -> bool {
+			Account::<T, I>::contains_key(asset, who)
+		}
+	}
+}
+
+sp_core::generate_feature_enabled_macro!(runtime_benchmarks_enabled, feature = "runtime-benchmarks", $);
diff --git a/substrate/frame/assets/src/migration.rs b/substrate/frame/assets/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..efe77714c524d38e9dd822652e39762848fe5367
--- /dev/null
+++ b/substrate/frame/assets/src/migration.rs
@@ -0,0 +1,138 @@
+// 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::OnRuntimeUpgrade;
+use log;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+pub mod v1 {
+	use frame_support::{pallet_prelude::*, weights::Weight};
+
+	use super::*;
+
+	#[derive(Decode)]
+	pub struct OldAssetDetails<Balance, AccountId, DepositBalance> {
+		pub owner: AccountId,
+		pub issuer: AccountId,
+		pub admin: AccountId,
+		pub freezer: AccountId,
+		pub supply: Balance,
+		pub deposit: DepositBalance,
+		pub min_balance: Balance,
+		pub is_sufficient: bool,
+		pub accounts: u32,
+		pub sufficients: u32,
+		pub approvals: u32,
+		pub is_frozen: bool,
+	}
+
+	impl<Balance, AccountId, DepositBalance> OldAssetDetails<Balance, AccountId, DepositBalance> {
+		fn migrate_to_v1(self) -> AssetDetails<Balance, AccountId, DepositBalance> {
+			let status = if self.is_frozen { AssetStatus::Frozen } else { AssetStatus::Live };
+
+			AssetDetails {
+				owner: self.owner,
+				issuer: self.issuer,
+				admin: self.admin,
+				freezer: self.freezer,
+				supply: self.supply,
+				deposit: self.deposit,
+				min_balance: self.min_balance,
+				is_sufficient: self.is_sufficient,
+				accounts: self.accounts,
+				sufficients: self.sufficients,
+				approvals: self.approvals,
+				status,
+			}
+		}
+	}
+
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current_version = Pallet::<T>::current_storage_version();
+			let onchain_version = Pallet::<T>::on_chain_storage_version();
+			if onchain_version == 0 && current_version == 1 {
+				let mut translated = 0u64;
+				Asset::<T>::translate::<
+					OldAssetDetails<T::Balance, T::AccountId, DepositBalanceOf<T>>,
+					_,
+				>(|_key, old_value| {
+					translated.saturating_inc();
+					Some(old_value.migrate_to_v1())
+				});
+				current_version.put::<Pallet<T>>();
+				log::info!(
+					target: LOG_TARGET,
+					"Upgraded {} pools, storage to version {:?}",
+					translated,
+					current_version
+				);
+				T::DbWeight::get().reads_writes(translated + 1, translated + 1)
+			} else {
+				log::info!(
+					target: LOG_TARGET,
+					"Migration did not execute. This probably should be removed"
+				);
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			frame_support::ensure!(
+				Pallet::<T>::on_chain_storage_version() == 0,
+				"must upgrade linearly"
+			);
+			let prev_count = Asset::<T>::iter().count();
+			Ok((prev_count as u32).encode())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(prev_count: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let prev_count: u32 = Decode::decode(&mut prev_count.as_slice()).expect(
+				"the state parameter should be something that was generated by pre_upgrade",
+			);
+			let post_count = Asset::<T>::iter().count() as u32;
+			ensure!(
+				prev_count == post_count,
+				"the asset count before and after the migration should be the same"
+			);
+
+			let current_version = Pallet::<T>::current_storage_version();
+			let onchain_version = Pallet::<T>::on_chain_storage_version();
+
+			frame_support::ensure!(current_version == 1, "must_upgrade");
+			ensure!(
+				current_version == onchain_version,
+				"after migration, the current_version and onchain_version should be the same"
+			);
+
+			Asset::<T>::iter().try_for_each(|(_id, asset)| -> Result<(), TryRuntimeError> {
+				ensure!(
+					asset.status == AssetStatus::Live || asset.status == AssetStatus::Frozen,
+					 "assets should only be live or frozen. None should be in destroying status, or undefined state"
+				);
+				Ok(())
+			})?;
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/assets/src/mock.rs b/substrate/frame/assets/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..32ad02da9041207cce23227f3fb6212790e95601
--- /dev/null
+++ b/substrate/frame/assets/src/mock.rs
@@ -0,0 +1,227 @@
+// 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.
+
+//! Test environment for Assets pallet.
+
+use super::*;
+use crate as pallet_assets;
+
+use codec::Encode;
+use frame_support::{
+	construct_runtime, parameter_types,
+	traits::{AsEnsureOriginWithArg, ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_io::storage;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Assets: pallet_assets::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+type AccountId = u64;
+type AssetId = u32;
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	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 DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<3>;
+}
+
+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 FreezeIdentifier = ();
+	type MaxHolds = ();
+	type MaxFreezes = ();
+}
+
+pub struct AssetsCallbackHandle;
+impl AssetsCallback<AssetId, AccountId> for AssetsCallbackHandle {
+	fn created(_id: &AssetId, _owner: &AccountId) -> Result<(), ()> {
+		if Self::should_err() {
+			Err(())
+		} else {
+			storage::set(Self::CREATED.as_bytes(), &().encode());
+			Ok(())
+		}
+	}
+
+	fn destroyed(_id: &AssetId) -> Result<(), ()> {
+		if Self::should_err() {
+			Err(())
+		} else {
+			storage::set(Self::DESTROYED.as_bytes(), &().encode());
+			Ok(())
+		}
+	}
+}
+
+impl AssetsCallbackHandle {
+	pub const CREATED: &'static str = "asset_created";
+	pub const DESTROYED: &'static str = "asset_destroyed";
+
+	const RETURN_ERROR: &'static str = "return_error";
+
+	// Configures `Self` to return `Ok` when callbacks are invoked
+	pub fn set_return_ok() {
+		storage::clear(Self::RETURN_ERROR.as_bytes());
+	}
+
+	// Configures `Self` to return `Err` when callbacks are invoked
+	pub fn set_return_error() {
+		storage::set(Self::RETURN_ERROR.as_bytes(), &().encode());
+	}
+
+	// If `true`, callback should return `Err`, `Ok` otherwise.
+	fn should_err() -> bool {
+		storage::exists(Self::RETURN_ERROR.as_bytes())
+	}
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u64;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<u64>>;
+	type ForceOrigin = frame_system::EnsureRoot<u64>;
+	type AssetDeposit = ConstU64<1>;
+	type AssetAccountDeposit = ConstU64<10>;
+	type MetadataDepositBase = ConstU64<1>;
+	type MetadataDepositPerByte = ConstU64<1>;
+	type ApprovalDeposit = ConstU64<1>;
+	type StringLimit = ConstU32<50>;
+	type Freezer = TestFreezer;
+	type WeightInfo = ();
+	type CallbackHandle = AssetsCallbackHandle;
+	type Extra = ();
+	type RemoveItemsLimit = ConstU32<5>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+use std::collections::HashMap;
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub enum Hook {
+	Died(u32, u64),
+}
+parameter_types! {
+	static Frozen: HashMap<(u32, u64), u64> = Default::default();
+	static Hooks: Vec<Hook> = Default::default();
+}
+
+pub struct TestFreezer;
+impl FrozenBalance<u32, u64, u64> for TestFreezer {
+	fn frozen_balance(asset: u32, who: &u64) -> Option<u64> {
+		Frozen::get().get(&(asset, *who)).cloned()
+	}
+
+	fn died(asset: u32, who: &u64) {
+		Hooks::mutate(|v| v.push(Hook::Died(asset, *who)));
+
+		// Sanity check: dead accounts have no balance.
+		assert!(Assets::balance(asset, *who).is_zero());
+	}
+}
+
+pub(crate) fn set_frozen_balance(asset: u32, who: u64, amount: u64) {
+	Frozen::mutate(|v| {
+		v.insert((asset, who), amount);
+	});
+}
+
+pub(crate) fn clear_frozen_balance(asset: u32, who: u64) {
+	Frozen::mutate(|v| {
+		v.remove(&(asset, who));
+	});
+}
+
+pub(crate) fn hooks() -> Vec<Hook> {
+	Hooks::get().clone()
+}
+
+pub(crate) fn take_hooks() -> Vec<Hook> {
+	Hooks::take()
+}
+
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	let mut storage = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let config: pallet_assets::GenesisConfig<Test> = pallet_assets::GenesisConfig {
+		assets: vec![
+			// id, owner, is_sufficient, min_balance
+			(999, 0, true, 1),
+		],
+		metadata: vec![
+			// id, name, symbol, decimals
+			(999, "Token Name".into(), "TOKEN".into(), 10),
+		],
+		accounts: vec![
+			// id, account_id, balance
+			(999, 1, 100),
+		],
+	};
+
+	config.assimilate_storage(&mut storage).unwrap();
+
+	let mut ext: sp_io::TestExternalities = storage.into();
+	// Clear thread local vars for https://github.com/paritytech/substrate/issues/10479.
+	ext.execute_with(|| take_hooks());
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
diff --git a/substrate/frame/assets/src/tests.rs b/substrate/frame/assets/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..06d4ec1211737f368937a27141c21c5b562c1c0e
--- /dev/null
+++ b/substrate/frame/assets/src/tests.rs
@@ -0,0 +1,1777 @@
+// 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 Assets pallet.
+
+use super::*;
+use crate::{mock::*, Error};
+use frame_support::{
+	assert_noop, assert_ok,
+	dispatch::GetDispatchInfo,
+	traits::{fungibles::InspectEnumerable, tokens::Preservation::Protect, Currency},
+};
+use pallet_balances::Error as BalancesError;
+use sp_io::storage;
+use sp_runtime::{traits::ConvertInto, TokenError};
+
+fn asset_ids() -> Vec<u32> {
+	let mut s: Vec<_> = Assets::asset_ids().collect();
+	s.sort();
+	s
+}
+
+/// returns tuple of asset's account and sufficient counts
+fn asset_account_counts(asset_id: u32) -> (u32, u32) {
+	let asset = Asset::<Test>::get(asset_id).unwrap();
+	(asset.accounts, asset.sufficients)
+}
+
+#[test]
+fn transfer_should_never_burn() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+
+		while System::inc_consumers(&2).is_ok() {}
+		let _ = System::dec_consumers(&2);
+		let _ = System::dec_consumers(&2);
+		// Exactly one consumer ref remaining.
+		assert_eq!(System::consumers(&2), 1);
+
+		let _ = <Assets as fungibles::Mutate<_>>::transfer(0, &1, &2, 50, Protect);
+		System::assert_has_event(RuntimeEvent::Assets(crate::Event::Transferred {
+			asset_id: 0,
+			from: 1,
+			to: 2,
+			amount: 50,
+		}));
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 1) + Assets::balance(0, 2), 100);
+	});
+}
+
+#[test]
+fn basic_minting_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 1, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		System::assert_last_event(RuntimeEvent::Assets(crate::Event::Issued {
+			asset_id: 0,
+			owner: 1,
+			amount: 100,
+		}));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 2, 100));
+		System::assert_last_event(RuntimeEvent::Assets(crate::Event::Issued {
+			asset_id: 0,
+			owner: 2,
+			amount: 100,
+		}));
+		assert_eq!(Assets::balance(0, 2), 100);
+		assert_eq!(asset_ids(), vec![0, 1, 999]);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 1, 1, 100));
+		System::assert_last_event(RuntimeEvent::Assets(crate::Event::Issued {
+			asset_id: 1,
+			owner: 1,
+			amount: 100,
+		}));
+		assert_eq!(Assets::account_balances(1), vec![(0, 100), (999, 100), (1, 100)]);
+	});
+}
+
+#[test]
+fn minting_too_many_insufficient_assets_fails() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 1, 1, false, 1));
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 2, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 1, 1, 100));
+		assert_noop!(Assets::mint(RuntimeOrigin::signed(1), 2, 1, 100), TokenError::CannotCreate);
+
+		Balances::make_free_balance_be(&2, 1);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 100));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 2, 1, 100));
+		assert_eq!(asset_ids(), vec![0, 1, 2, 999]);
+	});
+}
+
+#[test]
+fn minting_insufficient_asset_with_deposit_should_work_when_consumers_exhausted() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 1, 1, false, 1));
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 2, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 1, 1, 100));
+		assert_noop!(Assets::mint(RuntimeOrigin::signed(1), 2, 1, 100), TokenError::CannotCreate);
+
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(1), 2));
+		assert_eq!(Balances::reserved_balance(&1), 10);
+
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 2, 1, 100));
+	});
+}
+
+#[test]
+fn minting_insufficient_assets_with_deposit_without_consumer_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_noop!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100), TokenError::CannotCreate);
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Balances::reserved_balance(&1), 10);
+		assert_eq!(System::consumers(&1), 1);
+	});
+}
+
+#[test]
+fn refunding_asset_deposit_with_burn_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_ok!(Assets::refund(RuntimeOrigin::signed(1), 0, true));
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert_eq!(Assets::balance(1, 0), 0);
+	});
+}
+
+#[test]
+fn refunding_asset_deposit_with_burn_disallowed_should_fail() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_noop!(Assets::refund(RuntimeOrigin::signed(1), 0, false), Error::<Test>::WouldBurn);
+	});
+}
+
+#[test]
+fn refunding_asset_deposit_without_burn_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_noop!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100), TokenError::CannotCreate);
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 100));
+		assert_eq!(Assets::balance(0, 2), 100);
+		assert_eq!(Assets::balance(0, 1), 0);
+		assert_eq!(Balances::reserved_balance(&1), 10);
+		assert_eq!(asset_account_counts(0), (2, 0));
+		assert_ok!(Assets::refund(RuntimeOrigin::signed(1), 0, false));
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert_eq!(Assets::balance(1, 0), 0);
+		assert_eq!(asset_account_counts(0), (1, 0));
+	});
+}
+
+/// Refunding reaps an account and calls the `FrozenBalance::died` hook.
+#[test]
+fn refunding_calls_died_hook() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_ok!(Assets::refund(RuntimeOrigin::signed(1), 0, true));
+
+		assert_eq!(Asset::<Test>::get(0).unwrap().accounts, 0);
+		assert_eq!(hooks(), vec![Hook::Died(0, 1)]);
+		assert_eq!(asset_ids(), vec![0, 999]);
+	});
+}
+
+#[test]
+fn refunding_with_sufficient_existence_reason_should_fail() {
+	new_test_ext().execute_with(|| {
+		// create sufficient asset
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		// create an asset account with sufficient existence reason
+		// by transferring some sufficient assets
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+		assert_eq!(asset_account_counts(0), (2, 2));
+		// fails to refund
+		assert_noop!(Assets::refund(RuntimeOrigin::signed(2), 0, true), Error::<Test>::NoDeposit);
+	});
+}
+
+#[test]
+fn refunding_with_deposit_from_should_fail() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		// create asset account `2` with deposit from `1`
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(1), 0, 2));
+		assert_eq!(Balances::reserved_balance(&1), 10);
+		// fails to refund
+		assert_noop!(Assets::refund(RuntimeOrigin::signed(2), 0, true), Error::<Test>::NoDeposit);
+		assert!(Account::<Test>::contains_key(0, &2));
+	});
+}
+
+#[test]
+fn refunding_frozen_with_consumer_ref_works() {
+	new_test_ext().execute_with(|| {
+		// 1 will be an admin
+		// 2 will be a frozen account
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		// create non-sufficient asset
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(System::consumers(&2), 0);
+		// create asset account `2` with a consumer reference by transferring
+		// non-sufficient funds into
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(System::consumers(&2), 1);
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+		assert_eq!(asset_account_counts(0), (2, 0));
+		// freeze asset account `2` and asset `0`
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(1), 0, 2));
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		// refund works
+		assert_ok!(Assets::refund(RuntimeOrigin::signed(2), 0, true));
+		assert!(!Account::<Test>::contains_key(0, &2));
+		assert_eq!(System::consumers(&2), 0);
+		assert_eq!(asset_account_counts(0), (1, 0));
+	});
+}
+
+#[test]
+fn refunding_frozen_with_deposit_works() {
+	new_test_ext().execute_with(|| {
+		// 1 will be an asset admin
+		// 2 will be a frozen account
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(System::consumers(&2), 0);
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(2), 0));
+		// reserve deposit holds one consumer ref
+		assert_eq!(System::consumers(&2), 1);
+		assert_eq!(Balances::reserved_balance(&2), 10);
+		assert!(Account::<Test>::contains_key(0, &2));
+		// transfer some assets to `2`
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(System::consumers(&2), 1);
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+		assert_eq!(asset_account_counts(0), (2, 0));
+		// ensure refundable even if asset account and asset is frozen
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(1), 0, 2));
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		// success
+		assert_ok!(Assets::refund(RuntimeOrigin::signed(2), 0, true));
+		assert!(!Account::<Test>::contains_key(0, &2));
+		assert_eq!(Balances::reserved_balance(&2), 0);
+		assert_eq!(System::consumers(&2), 0);
+		assert_eq!(asset_account_counts(0), (1, 0));
+	});
+}
+
+#[test]
+fn approval_lifecycle_works() {
+	new_test_ext().execute_with(|| {
+		// can't approve non-existent token
+		assert_noop!(
+			Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50),
+			Error::<Test>::Unknown
+		);
+		// so we create it :)
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 1);
+		assert_eq!(Balances::reserved_balance(&1), 1);
+		assert_ok!(Assets::transfer_approved(RuntimeOrigin::signed(2), 0, 1, 3, 40));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 1);
+		assert_ok!(Assets::cancel_approval(RuntimeOrigin::signed(1), 0, 2));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 0);
+		assert_eq!(Assets::balance(0, 1), 60);
+		assert_eq!(Assets::balance(0, 3), 40);
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert_eq!(asset_ids(), vec![0, 999]);
+	});
+}
+
+#[test]
+fn transfer_approved_all_funds() {
+	new_test_ext().execute_with(|| {
+		// can't approve non-existent token
+		assert_noop!(
+			Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50),
+			Error::<Test>::Unknown
+		);
+		// so we create it :)
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 1);
+		assert_eq!(Balances::reserved_balance(&1), 1);
+
+		// transfer the full amount, which should trigger auto-cleanup
+		assert_ok!(Assets::transfer_approved(RuntimeOrigin::signed(2), 0, 1, 3, 50));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 0);
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 3), 50);
+		assert_eq!(Balances::reserved_balance(&1), 0);
+	});
+}
+
+#[test]
+fn approval_deposits_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		let e = BalancesError::<Test>::InsufficientBalance;
+		assert_noop!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50), e);
+
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Balances::reserved_balance(&1), 1);
+
+		assert_ok!(Assets::transfer_approved(RuntimeOrigin::signed(2), 0, 1, 3, 50));
+		assert_eq!(Balances::reserved_balance(&1), 0);
+
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_ok!(Assets::cancel_approval(RuntimeOrigin::signed(1), 0, 2));
+		assert_eq!(Balances::reserved_balance(&1), 0);
+	});
+}
+
+#[test]
+fn cannot_transfer_more_than_approved() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		let e = Error::<Test>::Unapproved;
+		assert_noop!(Assets::transfer_approved(RuntimeOrigin::signed(2), 0, 1, 3, 51), e);
+	});
+}
+
+#[test]
+fn cannot_transfer_more_than_exists() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 101));
+		let e = Error::<Test>::BalanceLow;
+		assert_noop!(Assets::transfer_approved(RuntimeOrigin::signed(2), 0, 1, 3, 101), e);
+	});
+}
+
+#[test]
+fn cancel_approval_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 1);
+		assert_noop!(
+			Assets::cancel_approval(RuntimeOrigin::signed(1), 1, 2),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Assets::cancel_approval(RuntimeOrigin::signed(2), 0, 2),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Assets::cancel_approval(RuntimeOrigin::signed(1), 0, 3),
+			Error::<Test>::Unknown
+		);
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 1);
+		assert_ok!(Assets::cancel_approval(RuntimeOrigin::signed(1), 0, 2));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 0);
+		assert_noop!(
+			Assets::cancel_approval(RuntimeOrigin::signed(1), 0, 2),
+			Error::<Test>::Unknown
+		);
+	});
+}
+
+#[test]
+fn force_cancel_approval_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 1);
+		let e = Error::<Test>::NoPermission;
+		assert_noop!(Assets::force_cancel_approval(RuntimeOrigin::signed(2), 0, 1, 2), e);
+		assert_noop!(
+			Assets::force_cancel_approval(RuntimeOrigin::signed(1), 1, 1, 2),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Assets::force_cancel_approval(RuntimeOrigin::signed(1), 0, 2, 2),
+			Error::<Test>::Unknown
+		);
+		assert_noop!(
+			Assets::force_cancel_approval(RuntimeOrigin::signed(1), 0, 1, 3),
+			Error::<Test>::Unknown
+		);
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 1);
+		assert_ok!(Assets::force_cancel_approval(RuntimeOrigin::signed(1), 0, 1, 2));
+		assert_eq!(Asset::<Test>::get(0).unwrap().approvals, 0);
+		assert_noop!(
+			Assets::force_cancel_approval(RuntimeOrigin::signed(1), 0, 1, 2),
+			Error::<Test>::Unknown
+		);
+	});
+}
+
+#[test]
+fn lifecycle_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::create(RuntimeOrigin::signed(1), 0, 1, 1));
+		assert_eq!(Balances::reserved_balance(&1), 1);
+		assert!(Asset::<Test>::contains_key(0));
+
+		assert_ok!(Assets::set_metadata(RuntimeOrigin::signed(1), 0, vec![0], vec![0], 12));
+		assert_eq!(Balances::reserved_balance(&1), 4);
+		assert!(Metadata::<Test>::contains_key(0));
+
+		Balances::make_free_balance_be(&10, 100);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 10, 100));
+		Balances::make_free_balance_be(&20, 100);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 20, 100));
+		assert_eq!(Account::<Test>::iter_prefix(0).count(), 2);
+
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::finish_destroy(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(Balances::reserved_balance(&1), 0);
+
+		assert!(!Asset::<Test>::contains_key(0));
+		assert!(!Metadata::<Test>::contains_key(0));
+		assert_eq!(Account::<Test>::iter_prefix(0).count(), 0);
+
+		assert_ok!(Assets::create(RuntimeOrigin::signed(1), 0, 1, 1));
+		assert_eq!(Balances::reserved_balance(&1), 1);
+		assert!(Asset::<Test>::contains_key(0));
+
+		assert_ok!(Assets::set_metadata(RuntimeOrigin::signed(1), 0, vec![0], vec![0], 12));
+		assert_eq!(Balances::reserved_balance(&1), 4);
+		assert!(Metadata::<Test>::contains_key(0));
+
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 10, 100));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 20, 100));
+		assert_eq!(Account::<Test>::iter_prefix(0).count(), 2);
+
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::finish_destroy(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(Balances::reserved_balance(&1), 0);
+
+		assert!(!Asset::<Test>::contains_key(0));
+		assert!(!Metadata::<Test>::contains_key(0));
+		assert_eq!(Account::<Test>::iter_prefix(0).count(), 0);
+	});
+}
+
+#[test]
+fn destroy_should_refund_approvals() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 10, 100));
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 3, 50));
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 4, 50));
+		assert_eq!(Balances::reserved_balance(&1), 3);
+		assert_eq!(asset_ids(), vec![0, 999]);
+
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::finish_destroy(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert_eq!(asset_ids(), vec![999]);
+
+		// all approvals are removed
+		assert!(Approvals::<Test>::iter().count().is_zero())
+	});
+}
+
+#[test]
+fn partial_destroy_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 2, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 3, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 4, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 5, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 6, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 7, 10));
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		// Asset is in use, as all the accounts have not yet been destroyed.
+		// We need to call destroy_accounts or destroy_approvals again until asset is completely
+		// cleaned up.
+		assert_noop!(Assets::finish_destroy(RuntimeOrigin::signed(1), 0), Error::<Test>::InUse);
+
+		System::assert_has_event(RuntimeEvent::Assets(crate::Event::AccountsDestroyed {
+			asset_id: 0,
+			accounts_destroyed: 5,
+			accounts_remaining: 2,
+		}));
+		System::assert_has_event(RuntimeEvent::Assets(crate::Event::ApprovalsDestroyed {
+			asset_id: 0,
+			approvals_destroyed: 0,
+			approvals_remaining: 0,
+		}));
+		// Partially destroyed Asset should continue to exist
+		assert!(Asset::<Test>::contains_key(0));
+
+		// Second call to destroy on PartiallyDestroyed asset
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+		System::assert_has_event(RuntimeEvent::Assets(crate::Event::AccountsDestroyed {
+			asset_id: 0,
+			accounts_destroyed: 2,
+			accounts_remaining: 0,
+		}));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::finish_destroy(RuntimeOrigin::signed(1), 0));
+
+		System::assert_has_event(RuntimeEvent::Assets(crate::Event::Destroyed { asset_id: 0 }));
+
+		// Destroyed Asset should not exist
+		assert!(!Asset::<Test>::contains_key(0));
+	})
+}
+
+#[test]
+fn non_providing_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+
+		Balances::make_free_balance_be(&0, 100);
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 0, 100));
+
+		// Cannot mint into account 2 since it doesn't (yet) exist...
+		assert_noop!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100), TokenError::CannotCreate);
+		// ...or transfer...
+		assert_noop!(
+			Assets::transfer(RuntimeOrigin::signed(0), 0, 1, 50),
+			TokenError::CannotCreate
+		);
+		// ...or force-transfer
+		assert_noop!(
+			Assets::force_transfer(RuntimeOrigin::signed(1), 0, 0, 1, 50),
+			TokenError::CannotCreate
+		);
+
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(0), 0, 1, 25));
+		assert_ok!(Assets::force_transfer(RuntimeOrigin::signed(1), 0, 0, 2, 25));
+		assert_eq!(asset_ids(), vec![0, 999]);
+	});
+}
+
+#[test]
+fn min_balance_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Asset::<Test>::get(0).unwrap().accounts, 1);
+
+		// Cannot create a new account with a balance that is below minimum...
+		assert_noop!(Assets::mint(RuntimeOrigin::signed(1), 0, 2, 9), TokenError::BelowMinimum);
+		assert_noop!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 9), TokenError::BelowMinimum);
+		assert_noop!(
+			Assets::force_transfer(RuntimeOrigin::signed(1), 0, 1, 2, 9),
+			TokenError::BelowMinimum
+		);
+
+		// When deducting from an account to below minimum, it should be reaped.
+		// Death by `transfer`.
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 91));
+		assert!(Assets::maybe_balance(0, 1).is_none());
+		assert_eq!(Assets::balance(0, 2), 100);
+		assert_eq!(Asset::<Test>::get(0).unwrap().accounts, 1);
+		assert_eq!(take_hooks(), vec![Hook::Died(0, 1)]);
+
+		// Death by `force_transfer`.
+		assert_ok!(Assets::force_transfer(RuntimeOrigin::signed(1), 0, 2, 1, 91));
+		assert!(Assets::maybe_balance(0, 2).is_none());
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_eq!(Asset::<Test>::get(0).unwrap().accounts, 1);
+		assert_eq!(take_hooks(), vec![Hook::Died(0, 2)]);
+
+		// Death by `burn`.
+		assert_ok!(Assets::burn(RuntimeOrigin::signed(1), 0, 1, 91));
+		assert!(Assets::maybe_balance(0, 1).is_none());
+		assert_eq!(Asset::<Test>::get(0).unwrap().accounts, 0);
+		assert_eq!(take_hooks(), vec![Hook::Died(0, 1)]);
+
+		// Death by `transfer_approved`.
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 100));
+		assert_ok!(Assets::transfer_approved(RuntimeOrigin::signed(2), 0, 1, 3, 91));
+		assert_eq!(take_hooks(), vec![Hook::Died(0, 1)]);
+	});
+}
+
+#[test]
+fn querying_total_supply_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(2), 0, 3, 31));
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 19);
+		assert_eq!(Assets::balance(0, 3), 31);
+		assert_ok!(Assets::burn(RuntimeOrigin::signed(1), 0, 3, u64::MAX));
+		assert_eq!(Assets::total_supply(0), 69);
+	});
+}
+
+#[test]
+fn transferring_amount_below_available_balance_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+	});
+}
+
+#[test]
+fn transferring_enough_to_kill_source_when_keep_alive_should_fail() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_noop!(
+			Assets::transfer_keep_alive(RuntimeOrigin::signed(1), 0, 2, 91),
+			Error::<Test>::BalanceLow
+		);
+		assert_ok!(Assets::transfer_keep_alive(RuntimeOrigin::signed(1), 0, 2, 90));
+		assert_eq!(Assets::balance(0, 1), 10);
+		assert_eq!(Assets::balance(0, 2), 90);
+		assert!(hooks().is_empty());
+		assert_eq!(asset_ids(), vec![0, 999]);
+	});
+}
+
+#[test]
+fn transferring_frozen_user_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(1), 0, 1));
+		assert_noop!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50), Error::<Test>::Frozen);
+		assert_ok!(Assets::thaw(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+	});
+}
+
+#[test]
+fn transferring_frozen_asset_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		assert_noop!(
+			Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50),
+			Error::<Test>::AssetNotLive
+		);
+		assert_ok!(Assets::thaw_asset(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+	});
+}
+
+#[test]
+fn approve_transfer_frozen_asset_should_not_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		assert_noop!(
+			Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50),
+			Error::<Test>::AssetNotLive
+		);
+		assert_ok!(Assets::thaw_asset(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+	});
+}
+
+#[test]
+fn transferring_from_blocked_account_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::block(RuntimeOrigin::signed(1), 0, 1));
+		// behaves as frozen when transferring from blocked
+		assert_noop!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50), Error::<Test>::Frozen);
+		assert_ok!(Assets::thaw(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 50));
+	});
+}
+
+#[test]
+fn transferring_to_blocked_account_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 2, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_eq!(Assets::balance(0, 2), 100);
+		assert_ok!(Assets::block(RuntimeOrigin::signed(1), 0, 1));
+		assert_noop!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 50), TokenError::Blocked);
+		assert_ok!(Assets::thaw(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 50));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+	});
+}
+
+#[test]
+fn origin_guards_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_noop!(
+			Assets::transfer_ownership(RuntimeOrigin::signed(2), 0, 2),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Assets::set_team(RuntimeOrigin::signed(2), 0, 2, 2, 2),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(Assets::freeze(RuntimeOrigin::signed(2), 0, 1), Error::<Test>::NoPermission);
+		assert_noop!(Assets::thaw(RuntimeOrigin::signed(2), 0, 2), Error::<Test>::NoPermission);
+		assert_noop!(
+			Assets::mint(RuntimeOrigin::signed(2), 0, 2, 100),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Assets::burn(RuntimeOrigin::signed(2), 0, 1, 100),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Assets::force_transfer(RuntimeOrigin::signed(2), 0, 1, 2, 100),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Assets::start_destroy(RuntimeOrigin::signed(2), 0),
+			Error::<Test>::NoPermission
+		);
+	});
+}
+
+#[test]
+fn transfer_owner_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Assets::create(RuntimeOrigin::signed(1), 0, 1, 1));
+		assert_eq!(asset_ids(), vec![0, 999]);
+
+		assert_eq!(Balances::reserved_balance(&1), 1);
+
+		assert_ok!(Assets::transfer_ownership(RuntimeOrigin::signed(1), 0, 2));
+		assert_eq!(Balances::reserved_balance(&2), 1);
+		assert_eq!(Balances::reserved_balance(&1), 0);
+
+		assert_noop!(
+			Assets::transfer_ownership(RuntimeOrigin::signed(1), 0, 1),
+			Error::<Test>::NoPermission
+		);
+
+		// Set metadata now and make sure that deposit gets transferred back.
+		assert_ok!(Assets::set_metadata(
+			RuntimeOrigin::signed(2),
+			0,
+			vec![0u8; 10],
+			vec![0u8; 10],
+			12
+		));
+		assert_ok!(Assets::transfer_ownership(RuntimeOrigin::signed(2), 0, 1));
+		assert_eq!(Balances::reserved_balance(&1), 22);
+		assert_eq!(Balances::reserved_balance(&2), 0);
+	});
+}
+
+#[test]
+fn set_team_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::set_team(RuntimeOrigin::signed(1), 0, 2, 3, 4));
+
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(2), 0, 2, 100));
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(4), 0, 2));
+		assert_ok!(Assets::thaw(RuntimeOrigin::signed(3), 0, 2));
+		assert_ok!(Assets::force_transfer(RuntimeOrigin::signed(3), 0, 2, 3, 100));
+		assert_ok!(Assets::burn(RuntimeOrigin::signed(3), 0, 3, 100));
+	});
+}
+
+#[test]
+fn transferring_from_frozen_account_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 2, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_eq!(Assets::balance(0, 2), 100);
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(1), 0, 2));
+		// can transfer to `2`
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		// cannot transfer from `2`
+		assert_noop!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 25), Error::<Test>::Frozen);
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 150);
+	});
+}
+
+#[test]
+fn touching_and_freezing_account_with_zero_asset_balance_should_work() {
+	new_test_ext().execute_with(|| {
+		// need some deposit for the touch
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_eq!(Assets::balance(0, 2), 0);
+		// cannot freeze an account that doesn't have an `Assets` entry
+		assert_noop!(Assets::freeze(RuntimeOrigin::signed(1), 0, 2), Error::<Test>::NoAccount);
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(2), 0));
+		// now it can be frozen
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(1), 0, 2));
+		// can transfer to `2` even though its frozen
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		// cannot transfer from `2`
+		assert_noop!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 25), Error::<Test>::Frozen);
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+	});
+}
+
+#[test]
+fn touch_other_works() {
+	new_test_ext().execute_with(|| {
+		// 1 will be admin
+		// 2 will be freezer
+		// 4 will be an account attempting to execute `touch_other`
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		Balances::make_free_balance_be(&4, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_ok!(Assets::set_team(RuntimeOrigin::signed(1), 0, 1, 1, 2));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		// account `3` does not exist
+		assert!(!Account::<Test>::contains_key(0, &3));
+		// creation of asset account `3` by account `4` fails
+		assert_noop!(
+			Assets::touch_other(RuntimeOrigin::signed(4), 0, 3),
+			Error::<Test>::NoPermission
+		);
+		// creation of asset account `3` by admin `1` works
+		assert!(!Account::<Test>::contains_key(0, &3));
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(1), 0, 3));
+		assert!(Account::<Test>::contains_key(0, &3));
+		// creation of asset account `4` by freezer `2` works
+		assert!(!Account::<Test>::contains_key(0, &4));
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(2), 0, 4));
+		assert!(Account::<Test>::contains_key(0, &4));
+	});
+}
+
+#[test]
+fn touch_other_and_freeze_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		// account `2` does not exist
+		assert!(!Account::<Test>::contains_key(0, &2));
+		// create account `2` with touch_other
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(1), 0, 2));
+		assert!(Account::<Test>::contains_key(0, &2));
+		// now it can be frozen
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(1), 0, 2));
+		// can transfer to `2` even though its frozen
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		// cannot transfer from `2`
+		assert_noop!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 25), Error::<Test>::Frozen);
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+	});
+}
+
+#[test]
+fn account_with_deposit_not_destroyed() {
+	new_test_ext().execute_with(|| {
+		// 1 will be the asset admin
+		// 2 will exist without balance but with deposit
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_eq!(Assets::balance(0, 2), 0);
+		// case 1; account `2` not destroyed with a holder's deposit
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(2), 0));
+		assert_eq!(Balances::reserved_balance(&2), 10);
+		assert!(Account::<Test>::contains_key(0, &2));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 50));
+		assert_eq!(Assets::balance(0, 2), 0);
+		assert!(Account::<Test>::contains_key(0, &2));
+
+		// destroy account `2`
+		assert_ok!(Assets::refund(RuntimeOrigin::signed(2), 0, false));
+		assert!(!Account::<Test>::contains_key(0, &2));
+
+		// case 2; account `2` not destroyed with a deposit from `1`
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(1), 0, 2));
+		assert_eq!(Balances::reserved_balance(&1), 10);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 50));
+		assert!(Account::<Test>::contains_key(0, &2));
+	});
+}
+
+#[test]
+fn refund_other_should_fails() {
+	new_test_ext().execute_with(|| {
+		// 1 will be the asset admin
+		// 2 will be the asset freezer
+		// 3 will be created with deposit of 2
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		Balances::make_free_balance_be(&3, 0);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::set_team(RuntimeOrigin::signed(1), 0, 1, 1, 2));
+		assert!(!Account::<Test>::contains_key(0, &3));
+
+		// create asset account `3` with a deposit from freezer `2`
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(2), 0, 3));
+		assert_eq!(Balances::reserved_balance(&2), 10);
+
+		// fail case; non-existing asset account `10`
+		assert_noop!(
+			Assets::refund_other(RuntimeOrigin::signed(2), 0, 10),
+			Error::<Test>::NoDeposit
+		);
+		// fail case; non-existing asset `3`
+		assert_noop!(
+			Assets::refund_other(RuntimeOrigin::signed(2), 1, 3),
+			Error::<Test>::NoDeposit
+		);
+		// fail case; no `DepositFrom` for asset account `1`
+		assert_noop!(
+			Assets::refund_other(RuntimeOrigin::signed(2), 0, 1),
+			Error::<Test>::NoDeposit
+		);
+		// fail case; asset `0` is frozen
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(2), 0));
+		assert_noop!(
+			Assets::refund_other(RuntimeOrigin::signed(2), 0, 3),
+			Error::<Test>::AssetNotLive
+		);
+		assert_ok!(Assets::thaw_asset(RuntimeOrigin::signed(1), 0));
+		// fail case; asset `1` is being destroyed
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 10, 1, true, 1));
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(1), 10, 3));
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 10));
+		assert_noop!(
+			Assets::refund_other(RuntimeOrigin::signed(2), 10, 3),
+			Error::<Test>::AssetNotLive
+		);
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 10));
+		assert_ok!(Assets::finish_destroy(RuntimeOrigin::signed(1), 10));
+		// fail case; account is frozen
+		assert_ok!(Assets::freeze(RuntimeOrigin::signed(2), 0, 3));
+		assert_noop!(Assets::refund_other(RuntimeOrigin::signed(2), 0, 3), Error::<Test>::Frozen);
+		assert_ok!(Assets::thaw(RuntimeOrigin::signed(1), 0, 3));
+		// fail case; not a freezer or an admin
+		assert_noop!(
+			Assets::refund_other(RuntimeOrigin::signed(4), 0, 3),
+			Error::<Test>::NoPermission
+		);
+		// fail case; would burn
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 3, 100));
+		assert_noop!(
+			Assets::refund_other(RuntimeOrigin::signed(1), 0, 3),
+			Error::<Test>::WouldBurn
+		);
+		assert_ok!(Assets::burn(RuntimeOrigin::signed(1), 0, 3, 100));
+	})
+}
+
+#[test]
+fn refund_other_works() {
+	new_test_ext().execute_with(|| {
+		// 1 will be the asset admin
+		// 2 will be the asset freezer
+		// 3 will be created with deposit of 2
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::set_team(RuntimeOrigin::signed(1), 0, 1, 1, 2));
+		assert!(!Account::<Test>::contains_key(0, &3));
+		assert_eq!(asset_account_counts(0), (0, 0));
+
+		// success case; freezer is depositor
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(2), 0, 3));
+		assert_eq!(Balances::reserved_balance(&2), 10);
+		assert_eq!(asset_account_counts(0), (1, 0));
+		assert_ok!(Assets::refund_other(RuntimeOrigin::signed(2), 0, 3));
+		assert_eq!(Balances::reserved_balance(&2), 0);
+		assert!(!Account::<Test>::contains_key(0, &3));
+		assert_eq!(asset_account_counts(0), (0, 0));
+
+		// success case; admin is depositor
+		assert_ok!(Assets::touch_other(RuntimeOrigin::signed(1), 0, 3));
+		assert_eq!(Balances::reserved_balance(&1), 10);
+		assert_eq!(asset_account_counts(0), (1, 0));
+		assert_ok!(Assets::refund_other(RuntimeOrigin::signed(1), 0, 3));
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert!(!Account::<Test>::contains_key(0, &3));
+		assert_eq!(asset_account_counts(0), (0, 0));
+	})
+}
+
+#[test]
+fn transferring_amount_more_than_available_balance_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(Assets::balance(0, 1), 50);
+		assert_eq!(Assets::balance(0, 2), 50);
+		assert_ok!(Assets::burn(RuntimeOrigin::signed(1), 0, 1, u64::MAX));
+		assert_eq!(Assets::balance(0, 1), 0);
+		assert_noop!(
+			Assets::transfer(RuntimeOrigin::signed(1), 0, 1, 50),
+			Error::<Test>::NoAccount
+		);
+		assert_noop!(
+			Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 51),
+			Error::<Test>::BalanceLow
+		);
+	});
+}
+
+#[test]
+fn transferring_less_than_one_unit_is_fine() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 0));
+		// `ForceCreated` and `Issued` but no `Transferred` event.
+		assert_eq!(System::events().len(), 2);
+	});
+}
+
+#[test]
+fn transferring_more_units_than_total_supply_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_noop!(
+			Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 101),
+			Error::<Test>::BalanceLow
+		);
+	});
+}
+
+#[test]
+fn burning_asset_balance_with_positive_balance_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+		assert_ok!(Assets::burn(RuntimeOrigin::signed(1), 0, 1, u64::MAX));
+		System::assert_last_event(RuntimeEvent::Assets(crate::Event::Burned {
+			asset_id: 0,
+			owner: 1,
+			balance: 100,
+		}));
+		assert_eq!(Assets::balance(0, 1), 0);
+	});
+}
+
+#[test]
+fn burning_asset_balance_with_zero_balance_does_nothing() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 2), 0);
+		assert_noop!(
+			Assets::burn(RuntimeOrigin::signed(1), 0, 2, u64::MAX),
+			Error::<Test>::NoAccount
+		);
+		assert_eq!(Assets::balance(0, 2), 0);
+		assert_eq!(Assets::total_supply(0), 100);
+	});
+}
+
+#[test]
+fn set_metadata_should_work() {
+	new_test_ext().execute_with(|| {
+		// Cannot add metadata to unknown asset
+		assert_noop!(
+			Assets::set_metadata(RuntimeOrigin::signed(1), 0, vec![0u8; 10], vec![0u8; 10], 12),
+			Error::<Test>::Unknown,
+		);
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		// Cannot add metadata to unowned asset
+		assert_noop!(
+			Assets::set_metadata(RuntimeOrigin::signed(2), 0, vec![0u8; 10], vec![0u8; 10], 12),
+			Error::<Test>::NoPermission,
+		);
+
+		// Cannot add oversized metadata
+		assert_noop!(
+			Assets::set_metadata(RuntimeOrigin::signed(1), 0, vec![0u8; 100], vec![0u8; 10], 12),
+			Error::<Test>::BadMetadata,
+		);
+		assert_noop!(
+			Assets::set_metadata(RuntimeOrigin::signed(1), 0, vec![0u8; 10], vec![0u8; 100], 12),
+			Error::<Test>::BadMetadata,
+		);
+
+		// Successfully add metadata and take deposit
+		Balances::make_free_balance_be(&1, 30);
+		assert_ok!(Assets::set_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			vec![0u8; 10],
+			vec![0u8; 10],
+			12
+		));
+		assert_eq!(Balances::free_balance(&1), 9);
+
+		// Update deposit
+		assert_ok!(Assets::set_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			vec![0u8; 10],
+			vec![0u8; 5],
+			12
+		));
+		assert_eq!(Balances::free_balance(&1), 14);
+		assert_ok!(Assets::set_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			vec![0u8; 10],
+			vec![0u8; 15],
+			12
+		));
+		assert_eq!(Balances::free_balance(&1), 4);
+
+		// Cannot over-reserve
+		assert_noop!(
+			Assets::set_metadata(RuntimeOrigin::signed(1), 0, vec![0u8; 20], vec![0u8; 20], 12),
+			BalancesError::<Test, _>::InsufficientBalance,
+		);
+
+		// Clear Metadata
+		assert!(Metadata::<Test>::contains_key(0));
+		assert_noop!(
+			Assets::clear_metadata(RuntimeOrigin::signed(2), 0),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(Assets::clear_metadata(RuntimeOrigin::signed(1), 1), Error::<Test>::Unknown);
+		assert_ok!(Assets::clear_metadata(RuntimeOrigin::signed(1), 0));
+		assert!(!Metadata::<Test>::contains_key(0));
+	});
+}
+
+/// Destroying an asset calls the `FrozenBalance::died` hooks of all accounts.
+#[test]
+fn destroy_accounts_calls_died_hooks() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 50));
+		// Create account 1 and 2.
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 2, 100));
+		// Destroy the accounts.
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+
+		// Accounts 1 and 2 died.
+		assert_eq!(hooks(), vec![Hook::Died(0, 1), Hook::Died(0, 2)]);
+	})
+}
+
+/// Destroying an asset calls the `FrozenBalance::died` hooks of all accounts.
+#[test]
+fn finish_destroy_asset_destroys_asset() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 50));
+		// Destroy the accounts.
+		assert_ok!(Assets::freeze_asset(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::finish_destroy(RuntimeOrigin::signed(1), 0));
+
+		// Asset is gone
+		assert!(Asset::<Test>::get(0).is_none());
+	})
+}
+
+#[test]
+fn freezer_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 10));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		assert_eq!(Assets::balance(0, 1), 100);
+
+		// freeze 50 of it.
+		set_frozen_balance(0, 1, 50);
+
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 20));
+		// cannot transfer another 21 away as this would take the non-frozen balance (30) to below
+		// the minimum balance (10).
+		assert_noop!(
+			Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 21),
+			Error::<Test>::BalanceLow
+		);
+
+		// create an approved transfer...
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::approve_transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		let e = Error::<Test>::BalanceLow;
+		// ...but that wont work either:
+		assert_noop!(Assets::transfer_approved(RuntimeOrigin::signed(2), 0, 1, 2, 21), e);
+		// a force transfer won't work also.
+		let e = Error::<Test>::BalanceLow;
+		assert_noop!(Assets::force_transfer(RuntimeOrigin::signed(1), 0, 1, 2, 21), e);
+
+		// reduce it to only 49 frozen...
+		set_frozen_balance(0, 1, 49);
+		// ...and it's all good:
+		assert_ok!(Assets::force_transfer(RuntimeOrigin::signed(1), 0, 1, 2, 21));
+
+		// and if we clear it, we can remove the account completely.
+		clear_frozen_balance(0, 1);
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 50));
+		assert_eq!(hooks(), vec![Hook::Died(0, 1)]);
+	});
+}
+
+#[test]
+fn imbalances_should_work() {
+	use frame_support::traits::tokens::fungibles::Balanced;
+
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+
+		let imb = Assets::issue(0, 100);
+		assert_eq!(Assets::total_supply(0), 100);
+		assert_eq!(imb.peek(), 100);
+
+		let (imb1, imb2) = imb.split(30);
+		assert_eq!(imb1.peek(), 30);
+		assert_eq!(imb2.peek(), 70);
+
+		drop(imb2);
+		assert_eq!(Assets::total_supply(0), 30);
+
+		assert!(Assets::resolve(&1, imb1).is_ok());
+		assert_eq!(Assets::balance(0, 1), 30);
+		assert_eq!(Assets::total_supply(0), 30);
+	});
+}
+
+#[test]
+fn force_metadata_should_work() {
+	new_test_ext().execute_with(|| {
+		// force set metadata works
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::force_set_metadata(
+			RuntimeOrigin::root(),
+			0,
+			vec![0u8; 10],
+			vec![0u8; 10],
+			8,
+			false
+		));
+		assert!(Metadata::<Test>::contains_key(0));
+
+		// overwrites existing metadata
+		let asset_original_metadata = Metadata::<Test>::get(0);
+		assert_ok!(Assets::force_set_metadata(
+			RuntimeOrigin::root(),
+			0,
+			vec![1u8; 10],
+			vec![1u8; 10],
+			8,
+			false
+		));
+		assert_ne!(Metadata::<Test>::get(0), asset_original_metadata);
+
+		// attempt to set metadata for non-existent asset class
+		assert_noop!(
+			Assets::force_set_metadata(
+				RuntimeOrigin::root(),
+				1,
+				vec![0u8; 10],
+				vec![0u8; 10],
+				8,
+				false
+			),
+			Error::<Test>::Unknown
+		);
+
+		// string length limit check
+		let limit = 50usize;
+		assert_noop!(
+			Assets::force_set_metadata(
+				RuntimeOrigin::root(),
+				0,
+				vec![0u8; limit + 1],
+				vec![0u8; 10],
+				8,
+				false
+			),
+			Error::<Test>::BadMetadata
+		);
+		assert_noop!(
+			Assets::force_set_metadata(
+				RuntimeOrigin::root(),
+				0,
+				vec![0u8; 10],
+				vec![0u8; limit + 1],
+				8,
+				false
+			),
+			Error::<Test>::BadMetadata
+		);
+
+		// force clear metadata works
+		assert!(Metadata::<Test>::contains_key(0));
+		assert_ok!(Assets::force_clear_metadata(RuntimeOrigin::root(), 0));
+		assert!(!Metadata::<Test>::contains_key(0));
+
+		// Error handles clearing non-existent asset class
+		assert_noop!(
+			Assets::force_clear_metadata(RuntimeOrigin::root(), 1),
+			Error::<Test>::Unknown
+		);
+	});
+}
+
+#[test]
+fn force_asset_status_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 10);
+		Balances::make_free_balance_be(&2, 10);
+		assert_ok!(Assets::create(RuntimeOrigin::signed(1), 0, 1, 30));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 50));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 2, 150));
+
+		// force asset status to change min_balance > balance
+		assert_ok!(Assets::force_asset_status(
+			RuntimeOrigin::root(),
+			0,
+			1,
+			1,
+			1,
+			1,
+			100,
+			true,
+			false
+		));
+		assert_eq!(Assets::balance(0, 1), 50);
+
+		// account can recieve assets for balance < min_balance
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 1));
+		assert_eq!(Assets::balance(0, 1), 51);
+
+		// account on outbound transfer will cleanup for balance < min_balance
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, 1));
+		assert_eq!(Assets::balance(0, 1), 0);
+
+		// won't create new account with balance below min_balance
+		assert_noop!(
+			Assets::transfer(RuntimeOrigin::signed(2), 0, 3, 50),
+			TokenError::BelowMinimum
+		);
+
+		// force asset status will not execute for non-existent class
+		assert_noop!(
+			Assets::force_asset_status(RuntimeOrigin::root(), 1, 1, 1, 1, 1, 90, true, false),
+			Error::<Test>::Unknown
+		);
+
+		// account drains to completion when funds dip below min_balance
+		assert_ok!(Assets::force_asset_status(
+			RuntimeOrigin::root(),
+			0,
+			1,
+			1,
+			1,
+			1,
+			110,
+			true,
+			false
+		));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(2), 0, 1, 110));
+		assert_eq!(Assets::balance(0, 1), 200);
+		assert_eq!(Assets::balance(0, 2), 0);
+		assert_eq!(Assets::total_supply(0), 200);
+	});
+}
+
+#[test]
+fn set_min_balance_should_work() {
+	new_test_ext().execute_with(|| {
+		let id = 42;
+		Balances::make_free_balance_be(&1, 10);
+		assert_ok!(Assets::create(RuntimeOrigin::signed(1), id, 1, 30));
+
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), id, 1, 100));
+		// Won't execute because there is an asset holder.
+		assert_noop!(
+			Assets::set_min_balance(RuntimeOrigin::signed(1), id, 50),
+			Error::<Test>::NoPermission
+		);
+
+		// Force asset status to make this a sufficient asset.
+		assert_ok!(Assets::force_asset_status(
+			RuntimeOrigin::root(),
+			id,
+			1,
+			1,
+			1,
+			1,
+			30,
+			true,
+			false
+		));
+
+		// Won't execute because there is an account holding the asset and the asset is marked as
+		// sufficient.
+		assert_noop!(
+			Assets::set_min_balance(RuntimeOrigin::signed(1), id, 10),
+			Error::<Test>::NoPermission
+		);
+
+		// Make the asset not sufficient.
+		assert_ok!(Assets::force_asset_status(
+			RuntimeOrigin::root(),
+			id,
+			1,
+			1,
+			1,
+			1,
+			60,
+			false,
+			false
+		));
+
+		// Will execute because the new value of min_balance is less than the
+		// old value. 10 < 30
+		assert_ok!(Assets::set_min_balance(RuntimeOrigin::signed(1), id, 10));
+		assert_eq!(Asset::<Test>::get(id).unwrap().min_balance, 10);
+
+		assert_ok!(Assets::burn(RuntimeOrigin::signed(1), id, 1, 100));
+
+		assert_ok!(Assets::set_min_balance(RuntimeOrigin::signed(1), id, 50));
+		assert_eq!(Asset::<Test>::get(id).unwrap().min_balance, 50);
+	});
+}
+
+#[test]
+fn balance_conversion_should_work() {
+	new_test_ext().execute_with(|| {
+		use frame_support::traits::tokens::ConversionToAssetBalance;
+
+		let id = 42;
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), id, 1, true, 10));
+		let not_sufficient = 23;
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), not_sufficient, 1, false, 10));
+		assert_eq!(asset_ids(), vec![23, 42, 999]);
+		assert_eq!(
+			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(100, 1234),
+			Err(ConversionError::AssetMissing)
+		);
+		assert_eq!(
+			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(
+				100,
+				not_sufficient
+			),
+			Err(ConversionError::AssetNotSufficient)
+		);
+		// 10 / 1 == 10 -> the conversion should 10x the value
+		assert_eq!(
+			BalanceToAssetBalance::<Balances, Test, ConvertInto>::to_asset_balance(100, id),
+			Ok(100 * 10)
+		);
+	});
+}
+
+#[test]
+fn assets_from_genesis_should_exist() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(asset_ids(), vec![999]);
+		assert!(Metadata::<Test>::contains_key(999));
+		assert_eq!(Assets::balance(999, 1), 100);
+		assert_eq!(Assets::total_supply(999), 100);
+	});
+}
+
+#[test]
+fn querying_name_symbol_and_decimals_should_work() {
+	new_test_ext().execute_with(|| {
+		use frame_support::traits::tokens::fungibles::metadata::Inspect;
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::force_set_metadata(
+			RuntimeOrigin::root(),
+			0,
+			vec![0u8; 10],
+			vec![1u8; 10],
+			12,
+			false
+		));
+		assert_eq!(Assets::name(0), vec![0u8; 10]);
+		assert_eq!(Assets::symbol(0), vec![1u8; 10]);
+		assert_eq!(Assets::decimals(0), 12);
+	});
+}
+
+#[test]
+fn querying_allowance_should_work() {
+	new_test_ext().execute_with(|| {
+		use frame_support::traits::tokens::fungibles::approvals::{Inspect, Mutate};
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		Balances::make_free_balance_be(&1, 2);
+		assert_ok!(Assets::approve(0, &1, &2, 50));
+		assert_eq!(Assets::allowance(0, &1, &2), 50);
+		// Transfer asset 0, from owner 1 and delegate 2 to destination 3
+		assert_ok!(Assets::transfer_from(0, &1, &2, &3, 50));
+		assert_eq!(Assets::allowance(0, &1, &2), 0);
+	});
+}
+
+#[test]
+fn transfer_large_asset() {
+	new_test_ext().execute_with(|| {
+		let amount = u64::pow(2, 63) + 2;
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, amount));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(1), 0, 2, amount - 1));
+	})
+}
+
+#[test]
+fn querying_roles_should_work() {
+	new_test_ext().execute_with(|| {
+		use frame_support::traits::tokens::fungibles::roles::Inspect;
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::set_team(
+			RuntimeOrigin::signed(1),
+			0,
+			// Issuer
+			2,
+			// Admin
+			3,
+			// Freezer
+			4,
+		));
+		assert_eq!(Assets::owner(0), Some(1));
+		assert_eq!(Assets::issuer(0), Some(2));
+		assert_eq!(Assets::admin(0), Some(3));
+		assert_eq!(Assets::freezer(0), Some(4));
+	});
+}
+
+#[test]
+fn normal_asset_create_and_destroy_callbacks_should_work() {
+	new_test_ext().execute_with(|| {
+		assert!(storage::get(AssetsCallbackHandle::CREATED.as_bytes()).is_none());
+		assert!(storage::get(AssetsCallbackHandle::DESTROYED.as_bytes()).is_none());
+
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Assets::create(RuntimeOrigin::signed(1), 0, 1, 1));
+		assert!(storage::get(AssetsCallbackHandle::CREATED.as_bytes()).is_some());
+		assert!(storage::get(AssetsCallbackHandle::DESTROYED.as_bytes()).is_none());
+
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		// Callback still hasn't been invoked
+		assert!(storage::get(AssetsCallbackHandle::DESTROYED.as_bytes()).is_none());
+
+		assert_ok!(Assets::finish_destroy(RuntimeOrigin::signed(1), 0));
+		assert!(storage::get(AssetsCallbackHandle::DESTROYED.as_bytes()).is_some());
+	});
+}
+
+#[test]
+fn root_asset_create_should_work() {
+	new_test_ext().execute_with(|| {
+		assert!(storage::get(AssetsCallbackHandle::CREATED.as_bytes()).is_none());
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert!(storage::get(AssetsCallbackHandle::CREATED.as_bytes()).is_some());
+		assert!(storage::get(AssetsCallbackHandle::DESTROYED.as_bytes()).is_none());
+	});
+}
+
+#[test]
+fn asset_create_and_destroy_is_reverted_if_callback_fails() {
+	new_test_ext().execute_with(|| {
+		// Asset creation fails due to callback failure
+		AssetsCallbackHandle::set_return_error();
+		Balances::make_free_balance_be(&1, 100);
+		assert_noop!(
+			Assets::create(RuntimeOrigin::signed(1), 0, 1, 1),
+			Error::<Test>::CallbackFailed
+		);
+
+		// Callback succeeds, so asset creation succeeds
+		AssetsCallbackHandle::set_return_ok();
+		assert_ok!(Assets::create(RuntimeOrigin::signed(1), 0, 1, 1));
+
+		// Asset destroy should fail due to callback failure
+		AssetsCallbackHandle::set_return_error();
+		assert_ok!(Assets::start_destroy(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_accounts(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Assets::destroy_approvals(RuntimeOrigin::signed(1), 0));
+		assert_noop!(
+			Assets::finish_destroy(RuntimeOrigin::signed(1), 0),
+			Error::<Test>::CallbackFailed
+		);
+	});
+}
+
+#[test]
+fn multiple_transfer_alls_work_ok() {
+	new_test_ext().execute_with(|| {
+		// Only run PoC when the system pallet is enabled, since the underlying bug is in the
+		// system pallet it won't work with BalancesAccountStore
+		// Start with a balance of 100
+		Balances::force_set_balance(RuntimeOrigin::root(), 1, 100).unwrap();
+		// Emulate a sufficient, in reality this could be reached by transferring a sufficient
+		// asset to the account
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, true, 1));
+		assert_ok!(Assets::mint(RuntimeOrigin::signed(1), 0, 1, 100));
+		// Spend the same balance multiple times
+		assert_ok!(Balances::transfer_all(RuntimeOrigin::signed(1), 1337, false));
+		assert_ok!(Balances::transfer_all(RuntimeOrigin::signed(1), 1337, false));
+
+		assert_eq!(Balances::free_balance(&1), 0);
+		assert_eq!(Balances::free_balance(&1337), 100);
+	});
+}
+
+#[test]
+fn weights_sane() {
+	let info = crate::Call::<Test>::create { id: 10, admin: 4, min_balance: 3 }.get_dispatch_info();
+	assert_eq!(<() as crate::WeightInfo>::create(), info.weight);
+
+	let info = crate::Call::<Test>::finish_destroy { id: 10 }.get_dispatch_info();
+	assert_eq!(<() as crate::WeightInfo>::finish_destroy(), info.weight);
+}
+
+#[test]
+fn asset_destroy_refund_existence_deposit() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Assets::force_create(RuntimeOrigin::root(), 0, 1, false, 1));
+		Balances::make_free_balance_be(&1, 100);
+		let admin = 1;
+		let admin_origin = RuntimeOrigin::signed(admin);
+
+		let account2 = 2; // account with own deposit
+		let account3 = 3; // account with admin's deposit
+		Balances::make_free_balance_be(&account2, 100);
+
+		assert_eq!(Balances::reserved_balance(&account2), 0);
+		assert_eq!(Balances::reserved_balance(&account3), 0);
+		assert_eq!(Balances::reserved_balance(&admin), 0);
+
+		assert_ok!(Assets::touch(RuntimeOrigin::signed(account2), 0));
+		assert_ok!(Assets::touch_other(admin_origin.clone(), 0, account3));
+
+		assert_eq!(Balances::reserved_balance(&account2), 10);
+		assert_eq!(Balances::reserved_balance(&account3), 0);
+		assert_eq!(Balances::reserved_balance(&admin), 10);
+
+		assert_ok!(Assets::start_destroy(admin_origin.clone(), 0));
+		assert_ok!(Assets::destroy_accounts(admin_origin.clone(), 0));
+		assert_ok!(Assets::destroy_approvals(admin_origin.clone(), 0));
+		assert_ok!(Assets::finish_destroy(admin_origin.clone(), 0));
+
+		assert_eq!(Balances::reserved_balance(&account2), 0);
+		assert_eq!(Balances::reserved_balance(&account3), 0);
+		assert_eq!(Balances::reserved_balance(&admin), 0);
+	});
+}
diff --git a/substrate/frame/assets/src/types.rs b/substrate/frame/assets/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..67f9bf07f5e7e2dfe1edc1f0a8236d06cd56ef61
--- /dev/null
+++ b/substrate/frame/assets/src/types.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.
+
+//! Various basic types for use in the assets pallet.
+
+use super::*;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{fungible, tokens::ConversionToAssetBalance},
+};
+use sp_runtime::{traits::Convert, FixedPointNumber, FixedU128};
+
+pub(super) type DepositBalanceOf<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance;
+pub(super) type AssetAccountOf<T, I> = AssetAccount<
+	<T as Config<I>>::Balance,
+	DepositBalanceOf<T, I>,
+	<T as Config<I>>::Extra,
+	<T as SystemConfig>::AccountId,
+>;
+pub(super) type ExistenceReasonOf<T, I> =
+	ExistenceReason<DepositBalanceOf<T, I>, <T as SystemConfig>::AccountId>;
+
+/// AssetStatus holds the current state of the asset. It could either be Live and available for use,
+/// or in a Destroying state.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub(super) enum AssetStatus {
+	/// The asset is active and able to be used.
+	Live,
+	/// Whether the asset is frozen for non-admin transfers.
+	Frozen,
+	/// The asset is currently being destroyed, and all actions are no longer permitted on the
+	/// asset. Once set to `Destroying`, the asset can never transition back to a `Live` state.
+	Destroying,
+}
+
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct AssetDetails<Balance, AccountId, DepositBalance> {
+	/// Can change `owner`, `issuer`, `freezer` and `admin` accounts.
+	pub(super) owner: AccountId,
+	/// Can mint tokens.
+	pub(super) issuer: AccountId,
+	/// Can thaw tokens, force transfers and burn tokens from any account.
+	pub(super) admin: AccountId,
+	/// Can freeze tokens.
+	pub(super) freezer: AccountId,
+	/// The total supply across all accounts.
+	pub(super) supply: Balance,
+	/// The balance deposited for this asset. This pays for the data stored here.
+	pub(super) deposit: DepositBalance,
+	/// The ED for virtual accounts.
+	pub(super) min_balance: Balance,
+	/// If `true`, then any account with this asset is given a provider reference. Otherwise, it
+	/// requires a consumer reference.
+	pub(super) is_sufficient: bool,
+	/// The total number of accounts.
+	pub(super) accounts: u32,
+	/// The total number of accounts for which we have placed a self-sufficient reference.
+	pub(super) sufficients: u32,
+	/// The total number of approvals.
+	pub(super) approvals: u32,
+	/// The status of the asset
+	pub(super) status: AssetStatus,
+}
+
+/// Data concerning an approval.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, MaxEncodedLen, TypeInfo)]
+pub struct Approval<Balance, DepositBalance> {
+	/// The amount of funds approved for the balance transfer from the owner to some delegated
+	/// target.
+	pub(super) amount: Balance,
+	/// The amount reserved on the owner's account to hold this item in storage.
+	pub(super) deposit: DepositBalance,
+}
+
+#[test]
+fn ensure_bool_decodes_to_consumer_or_sufficient() {
+	assert_eq!(false.encode(), ExistenceReason::<(), ()>::Consumer.encode());
+	assert_eq!(true.encode(), ExistenceReason::<(), ()>::Sufficient.encode());
+}
+
+/// The reason for an account's existence within an asset class.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub enum ExistenceReason<Balance, AccountId> {
+	/// A consumer reference was used to create this account.
+	#[codec(index = 0)]
+	Consumer,
+	/// The asset class is `sufficient` for account existence.
+	#[codec(index = 1)]
+	Sufficient,
+	/// The account holder has placed a deposit to exist within an asset class.
+	#[codec(index = 2)]
+	DepositHeld(Balance),
+	/// A deposit was placed for this account to exist, but it has been refunded.
+	#[codec(index = 3)]
+	DepositRefunded,
+	/// Some other `AccountId` has placed a deposit to make this account exist.
+	/// An account with such a reason might not be referenced in `system`.
+	#[codec(index = 4)]
+	DepositFrom(AccountId, Balance),
+}
+
+impl<Balance, AccountId> ExistenceReason<Balance, AccountId>
+where
+	AccountId: Clone,
+{
+	pub(crate) fn take_deposit(&mut self) -> Option<Balance> {
+		if !matches!(self, ExistenceReason::DepositHeld(_)) {
+			return None
+		}
+		if let ExistenceReason::DepositHeld(deposit) =
+			sp_std::mem::replace(self, ExistenceReason::DepositRefunded)
+		{
+			Some(deposit)
+		} else {
+			None
+		}
+	}
+
+	pub(crate) fn take_deposit_from(&mut self) -> Option<(AccountId, Balance)> {
+		if !matches!(self, ExistenceReason::DepositFrom(..)) {
+			return None
+		}
+		if let ExistenceReason::DepositFrom(depositor, deposit) =
+			sp_std::mem::replace(self, ExistenceReason::DepositRefunded)
+		{
+			Some((depositor, deposit))
+		} else {
+			None
+		}
+	}
+}
+
+#[test]
+fn ensure_bool_decodes_to_liquid_or_frozen() {
+	assert_eq!(false.encode(), AccountStatus::Liquid.encode());
+	assert_eq!(true.encode(), AccountStatus::Frozen.encode());
+}
+
+/// The status of an asset account.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub enum AccountStatus {
+	/// Asset account can receive and transfer the assets.
+	Liquid,
+	/// Asset account cannot transfer the assets.
+	Frozen,
+	/// Asset account cannot receive and transfer the assets.
+	Blocked,
+}
+impl AccountStatus {
+	/// Returns `true` if frozen or blocked.
+	pub(crate) fn is_frozen(&self) -> bool {
+		matches!(self, AccountStatus::Frozen | AccountStatus::Blocked)
+	}
+	/// Returns `true` if blocked.
+	pub(crate) fn is_blocked(&self) -> bool {
+		matches!(self, AccountStatus::Blocked)
+	}
+}
+
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct AssetAccount<Balance, DepositBalance, Extra, AccountId> {
+	/// The balance.
+	pub(super) balance: Balance,
+	/// The status of the account.
+	pub(super) status: AccountStatus,
+	/// The reason for the existence of the account.
+	pub(super) reason: ExistenceReason<DepositBalance, AccountId>,
+	/// Additional "sidecar" data, in case some other pallet wants to use this storage item.
+	pub(super) extra: Extra,
+}
+
+#[derive(Clone, Encode, Decode, Eq, PartialEq, Default, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct AssetMetadata<DepositBalance, BoundedString> {
+	/// The balance deposited for this metadata.
+	///
+	/// This pays for the data stored in this struct.
+	pub(super) deposit: DepositBalance,
+	/// The user friendly name of this asset. Limited in length by `StringLimit`.
+	pub(super) name: BoundedString,
+	/// The ticker symbol for this asset. Limited in length by `StringLimit`.
+	pub(super) symbol: BoundedString,
+	/// The number of decimals this asset uses to represent one unit.
+	pub(super) decimals: u8,
+	/// Whether the asset metadata may be changed by a non Force origin.
+	pub(super) is_frozen: bool,
+}
+
+/// Trait for allowing a minimum balance on the account to be specified, beyond the
+/// `minimum_balance` of the asset. This is additive - the `minimum_balance` of the asset must be
+/// met *and then* anything here in addition.
+pub trait FrozenBalance<AssetId, AccountId, Balance> {
+	/// Return the frozen balance.
+	///
+	/// Generally, the balance of every account must be at least the sum of this (if `Some`) and
+	/// the asset's `minimum_balance` (the latter since there may be complications to destroying an
+	/// asset's account completely).
+	///
+	/// Under normal behaviour, the account balance should not go below the sum of this (if `Some`)
+	/// and the asset's minimum balance. However, the account balance may reasonably begin below
+	/// this sum (e.g. if less than the sum had ever been transferred into the account).
+	///
+	/// In special cases (privileged intervention) the account balance may also go below the sum.
+	///
+	/// If `None` is returned, then nothing special is enforced.
+	fn frozen_balance(asset: AssetId, who: &AccountId) -> Option<Balance>;
+
+	/// Called after an account has been removed.
+	///
+	/// NOTE: It is possible that the asset does no longer exist when this hook is called.
+	fn died(asset: AssetId, who: &AccountId);
+}
+
+impl<AssetId, AccountId, Balance> FrozenBalance<AssetId, AccountId, Balance> for () {
+	fn frozen_balance(_: AssetId, _: &AccountId) -> Option<Balance> {
+		None
+	}
+	fn died(_: AssetId, _: &AccountId) {}
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub(super) struct TransferFlags {
+	/// The debited account must stay alive at the end of the operation; an error is returned if
+	/// this cannot be achieved legally.
+	pub(super) keep_alive: bool,
+	/// Less than the amount specified needs be debited by the operation for it to be considered
+	/// successful. If `false`, then the amount debited will always be at least the amount
+	/// specified.
+	pub(super) best_effort: bool,
+	/// Any additional funds debited (due to minimum balance requirements) should be burned rather
+	/// than credited to the destination account.
+	pub(super) burn_dust: bool,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub(super) struct DebitFlags {
+	/// The debited account must stay alive at the end of the operation; an error is returned if
+	/// this cannot be achieved legally.
+	pub(super) keep_alive: bool,
+	/// Less than the amount specified needs be debited by the operation for it to be considered
+	/// successful. If `false`, then the amount debited will always be at least the amount
+	/// specified.
+	pub(super) best_effort: bool,
+}
+
+impl From<TransferFlags> for DebitFlags {
+	fn from(f: TransferFlags) -> Self {
+		Self { keep_alive: f.keep_alive, best_effort: f.best_effort }
+	}
+}
+
+/// Possible errors when converting between external and asset balances.
+#[derive(Eq, PartialEq, Copy, Clone, RuntimeDebug, Encode, Decode)]
+pub enum ConversionError {
+	/// The external minimum balance must not be zero.
+	MinBalanceZero,
+	/// The asset is not present in storage.
+	AssetMissing,
+	/// The asset is not sufficient and thus does not have a reliable `min_balance` so it cannot be
+	/// converted.
+	AssetNotSufficient,
+}
+
+// Type alias for `frame_system`'s account id.
+type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
+// This pallet's asset id and balance type.
+type AssetIdOf<T, I> = <T as Config<I>>::AssetId;
+type AssetBalanceOf<T, I> = <T as Config<I>>::Balance;
+// Generic fungible balance type.
+type BalanceOf<F, T> = <F as fungible::Inspect<AccountIdOf<T>>>::Balance;
+
+/// Converts a balance value into an asset balance based on the ratio between the fungible's
+/// minimum balance and the minimum asset balance.
+pub struct BalanceToAssetBalance<F, T, CON, I = ()>(PhantomData<(F, T, CON, I)>);
+impl<F, T, CON, I> ConversionToAssetBalance<BalanceOf<F, T>, AssetIdOf<T, I>, AssetBalanceOf<T, I>>
+	for BalanceToAssetBalance<F, T, CON, I>
+where
+	F: fungible::Inspect<AccountIdOf<T>>,
+	T: Config<I>,
+	I: 'static,
+	CON: Convert<BalanceOf<F, T>, AssetBalanceOf<T, I>>,
+{
+	type Error = ConversionError;
+
+	/// Convert the given balance value into an asset balance based on the ratio between the
+	/// fungible's minimum balance and the minimum asset balance.
+	///
+	/// Will return `Err` if the asset is not found, not sufficient or the fungible's minimum
+	/// balance is zero.
+	fn to_asset_balance(
+		balance: BalanceOf<F, T>,
+		asset_id: AssetIdOf<T, I>,
+	) -> Result<AssetBalanceOf<T, I>, ConversionError> {
+		let asset = Asset::<T, I>::get(asset_id).ok_or(ConversionError::AssetMissing)?;
+		// only sufficient assets have a min balance with reliable value
+		ensure!(asset.is_sufficient, ConversionError::AssetNotSufficient);
+		let min_balance = CON::convert(F::minimum_balance());
+		// make sure we don't divide by zero
+		ensure!(!min_balance.is_zero(), ConversionError::MinBalanceZero);
+		let balance = CON::convert(balance);
+		// balance * asset.min_balance / min_balance
+		Ok(FixedU128::saturating_from_rational(asset.min_balance, min_balance)
+			.saturating_mul_int(balance))
+	}
+}
diff --git a/substrate/frame/assets/src/weights.rs b/substrate/frame/assets/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f20f7e317cff7c32d280b2e6fa9eaa9aa0fdbd57
--- /dev/null
+++ b/substrate/frame/assets/src/weights.rs
@@ -0,0 +1,968 @@
+// 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.
+
+//! Autogenerated weights for pallet_assets
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_assets
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/assets/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_assets.
+pub trait WeightInfo {
+	fn create() -> Weight;
+	fn force_create() -> Weight;
+	fn start_destroy() -> Weight;
+	fn destroy_accounts(c: u32, ) -> Weight;
+	fn destroy_approvals(a: u32, ) -> Weight;
+	fn finish_destroy() -> Weight;
+	fn mint() -> Weight;
+	fn burn() -> Weight;
+	fn transfer() -> Weight;
+	fn transfer_keep_alive() -> Weight;
+	fn force_transfer() -> Weight;
+	fn freeze() -> Weight;
+	fn thaw() -> Weight;
+	fn freeze_asset() -> Weight;
+	fn thaw_asset() -> Weight;
+	fn transfer_ownership() -> Weight;
+	fn set_team() -> Weight;
+	fn set_metadata(n: u32, s: u32, ) -> Weight;
+	fn clear_metadata() -> Weight;
+	fn force_set_metadata(n: u32, s: u32, ) -> Weight;
+	fn force_clear_metadata() -> Weight;
+	fn force_asset_status() -> Weight;
+	fn approve_transfer() -> Weight;
+	fn transfer_approved() -> Weight;
+	fn cancel_approval() -> Weight;
+	fn force_cancel_approval() -> Weight;
+	fn set_min_balance() -> Weight;
+	fn touch() -> Weight;
+	fn touch_other() -> Weight;
+	fn refund() -> Weight;
+	fn refund_other() -> Weight;
+	fn block() -> Weight;
+}
+
+/// Weights for pallet_assets using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `293`
+		//  Estimated: `3675`
+		// Minimum execution time: 31_340_000 picoseconds.
+		Weight::from_parts(31_977_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn force_create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `153`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_342_000 picoseconds.
+		Weight::from_parts(13_782_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn start_destroy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_437_000 picoseconds.
+		Weight::from_parts(14_833_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1001 w:1000)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1000 w:1000)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `c` is `[0, 1000]`.
+	fn destroy_accounts(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + c * (208 ±0)`
+		//  Estimated: `3675 + c * (2609 ±0)`
+		// Minimum execution time: 18_728_000 picoseconds.
+		Weight::from_parts(18_982_000, 3675)
+			// Standard Error: 11_708
+			.saturating_add(Weight::from_parts(14_363_570, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(c.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(c.into())))
+			.saturating_add(Weight::from_parts(0, 2609).saturating_mul(c.into()))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1001 w:1000)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 1000]`.
+	fn destroy_approvals(a: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `522 + a * (86 ±0)`
+		//  Estimated: `3675 + a * (2623 ±0)`
+		// Minimum execution time: 18_611_000 picoseconds.
+		Weight::from_parts(18_970_000, 3675)
+			// Standard Error: 13_224
+			.saturating_add(Weight::from_parts(16_397_299, 0).saturating_mul(a.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(a.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(a.into())))
+			.saturating_add(Weight::from_parts(0, 2623).saturating_mul(a.into()))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:0)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn finish_destroy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_504_000 picoseconds.
+		Weight::from_parts(14_906_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 26_653_000 picoseconds.
+		Weight::from_parts(27_260_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn burn() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 33_625_000 picoseconds.
+		Weight::from_parts(34_474_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `498`
+		//  Estimated: `6208`
+		// Minimum execution time: 47_609_000 picoseconds.
+		Weight::from_parts(48_476_000, 6208)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer_keep_alive() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `498`
+		//  Estimated: `6208`
+		// Minimum execution time: 41_625_000 picoseconds.
+		Weight::from_parts(43_030_000, 6208)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `498`
+		//  Estimated: `6208`
+		// Minimum execution time: 47_661_000 picoseconds.
+		Weight::from_parts(48_469_000, 6208)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn freeze() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 17_727_000 picoseconds.
+		Weight::from_parts(18_384_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn thaw() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 17_657_000 picoseconds.
+		Weight::from_parts(18_282_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn freeze_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_743_000 picoseconds.
+		Weight::from_parts(14_193_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn thaw_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_653_000 picoseconds.
+		Weight::from_parts(14_263_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:0)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn transfer_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 15_328_000 picoseconds.
+		Weight::from_parts(16_042_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn set_team() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_097_000 picoseconds.
+		Weight::from_parts(14_641_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	fn set_metadata(_n: u32, _s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 29_535_000 picoseconds.
+		Weight::from_parts(31_456_892, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515`
+		//  Estimated: `3675`
+		// Minimum execution time: 30_680_000 picoseconds.
+		Weight::from_parts(31_930_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	fn force_set_metadata(_n: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `190`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_660_000 picoseconds.
+		Weight::from_parts(15_718_387, 3675)
+			// Standard Error: 622
+			.saturating_add(Weight::from_parts(2_640, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn force_clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515`
+		//  Estimated: `3675`
+		// Minimum execution time: 30_853_000 picoseconds.
+		Weight::from_parts(31_483_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn force_asset_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_632_000 picoseconds.
+		Weight::from_parts(14_077_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 33_780_000 picoseconds.
+		Weight::from_parts(34_533_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer_approved() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `668`
+		//  Estimated: `6208`
+		// Minimum execution time: 67_712_000 picoseconds.
+		Weight::from_parts(69_946_000, 6208)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `555`
+		//  Estimated: `3675`
+		// Minimum execution time: 36_668_000 picoseconds.
+		Weight::from_parts(37_637_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	fn force_cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `555`
+		//  Estimated: `3675`
+		// Minimum execution time: 36_685_000 picoseconds.
+		Weight::from_parts(37_950_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn set_min_balance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_466_000 picoseconds.
+		Weight::from_parts(14_924_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn touch() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `453`
+		//  Estimated: `3675`
+		// Minimum execution time: 34_874_000 picoseconds.
+		Weight::from_parts(36_330_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn touch_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 33_278_000 picoseconds.
+		Weight::from_parts(34_104_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn refund() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `579`
+		//  Estimated: `3675`
+		// Minimum execution time: 32_898_000 picoseconds.
+		Weight::from_parts(33_489_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn refund_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `510`
+		//  Estimated: `3675`
+		// Minimum execution time: 31_243_000 picoseconds.
+		Weight::from_parts(31_909_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn block() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 17_692_000 picoseconds.
+		Weight::from_parts(18_253_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `293`
+		//  Estimated: `3675`
+		// Minimum execution time: 31_340_000 picoseconds.
+		Weight::from_parts(31_977_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn force_create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `153`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_342_000 picoseconds.
+		Weight::from_parts(13_782_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn start_destroy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_437_000 picoseconds.
+		Weight::from_parts(14_833_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1001 w:1000)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1000 w:1000)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `c` is `[0, 1000]`.
+	fn destroy_accounts(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + c * (208 ±0)`
+		//  Estimated: `3675 + c * (2609 ±0)`
+		// Minimum execution time: 18_728_000 picoseconds.
+		Weight::from_parts(18_982_000, 3675)
+			// Standard Error: 11_708
+			.saturating_add(Weight::from_parts(14_363_570, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(c.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(c.into())))
+			.saturating_add(Weight::from_parts(0, 2609).saturating_mul(c.into()))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1001 w:1000)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 1000]`.
+	fn destroy_approvals(a: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `522 + a * (86 ±0)`
+		//  Estimated: `3675 + a * (2623 ±0)`
+		// Minimum execution time: 18_611_000 picoseconds.
+		Weight::from_parts(18_970_000, 3675)
+			// Standard Error: 13_224
+			.saturating_add(Weight::from_parts(16_397_299, 0).saturating_mul(a.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(a.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(a.into())))
+			.saturating_add(Weight::from_parts(0, 2623).saturating_mul(a.into()))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:0)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn finish_destroy() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_504_000 picoseconds.
+		Weight::from_parts(14_906_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 26_653_000 picoseconds.
+		Weight::from_parts(27_260_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn burn() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 33_625_000 picoseconds.
+		Weight::from_parts(34_474_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `498`
+		//  Estimated: `6208`
+		// Minimum execution time: 47_609_000 picoseconds.
+		Weight::from_parts(48_476_000, 6208)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer_keep_alive() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `498`
+		//  Estimated: `6208`
+		// Minimum execution time: 41_625_000 picoseconds.
+		Weight::from_parts(43_030_000, 6208)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `498`
+		//  Estimated: `6208`
+		// Minimum execution time: 47_661_000 picoseconds.
+		Weight::from_parts(48_469_000, 6208)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn freeze() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 17_727_000 picoseconds.
+		Weight::from_parts(18_384_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn thaw() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 17_657_000 picoseconds.
+		Weight::from_parts(18_282_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn freeze_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_743_000 picoseconds.
+		Weight::from_parts(14_193_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn thaw_asset() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_653_000 picoseconds.
+		Weight::from_parts(14_263_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:0)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn transfer_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 15_328_000 picoseconds.
+		Weight::from_parts(16_042_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn set_team() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_097_000 picoseconds.
+		Weight::from_parts(14_641_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	fn set_metadata(_n: u32, _s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 29_535_000 picoseconds.
+		Weight::from_parts(31_456_892, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515`
+		//  Estimated: `3675`
+		// Minimum execution time: 30_680_000 picoseconds.
+		Weight::from_parts(31_930_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 50]`.
+	/// The range of component `s` is `[0, 50]`.
+	fn force_set_metadata(_n: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `190`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_660_000 picoseconds.
+		Weight::from_parts(15_718_387, 3675)
+			// Standard Error: 622
+			.saturating_add(Weight::from_parts(2_640, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn force_clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515`
+		//  Estimated: `3675`
+		// Minimum execution time: 30_853_000 picoseconds.
+		Weight::from_parts(31_483_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn force_asset_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 13_632_000 picoseconds.
+		Weight::from_parts(14_077_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `385`
+		//  Estimated: `3675`
+		// Minimum execution time: 33_780_000 picoseconds.
+		Weight::from_parts(34_533_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer_approved() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `668`
+		//  Estimated: `6208`
+		// Minimum execution time: 67_712_000 picoseconds.
+		Weight::from_parts(69_946_000, 6208)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `555`
+		//  Estimated: `3675`
+		// Minimum execution time: 36_668_000 picoseconds.
+		Weight::from_parts(37_637_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Approvals (r:1 w:1)
+	/// Proof: Assets Approvals (max_values: None, max_size: Some(148), added: 2623, mode: MaxEncodedLen)
+	fn force_cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `555`
+		//  Estimated: `3675`
+		// Minimum execution time: 36_685_000 picoseconds.
+		Weight::from_parts(37_950_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn set_min_balance() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 14_466_000 picoseconds.
+		Weight::from_parts(14_924_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn touch() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `453`
+		//  Estimated: `3675`
+		// Minimum execution time: 34_874_000 picoseconds.
+		Weight::from_parts(36_330_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn touch_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3675`
+		// Minimum execution time: 33_278_000 picoseconds.
+		Weight::from_parts(34_104_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn refund() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `579`
+		//  Estimated: `3675`
+		// Minimum execution time: 32_898_000 picoseconds.
+		Weight::from_parts(33_489_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn refund_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `510`
+		//  Estimated: `3675`
+		// Minimum execution time: 31_243_000 picoseconds.
+		Weight::from_parts(31_909_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Assets Asset (r:1 w:0)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn block() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `459`
+		//  Estimated: `3675`
+		// Minimum execution time: 17_692_000 picoseconds.
+		Weight::from_parts(18_253_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/atomic-swap/Cargo.toml b/substrate/frame/atomic-swap/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..da154d4421f3c6febb7a3f8d719ddfaf270c6b33
--- /dev/null
+++ b/substrate/frame/atomic-swap/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "pallet-atomic-swap"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME atomic swap pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/atomic-swap/README.md b/substrate/frame/atomic-swap/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..888a64ec7e0658e8cb6ffc6a95f59a300a8ae1aa
--- /dev/null
+++ b/substrate/frame/atomic-swap/README.md
@@ -0,0 +1,23 @@
+# Atomic Swap
+
+A module for atomically sending funds.
+
+- [`atomic_swap::Config`](https://docs.rs/pallet-atomic-swap/latest/pallet_atomic_swap/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-atomic-swap/latest/pallet_atomic_swap/enum.Call.html)
+- [`Module`](https://docs.rs/pallet-atomic-swap/latest/pallet_atomic_swap/struct.Module.html)
+
+## Overview
+
+A module for atomically sending funds from an origin to a target. A proof
+is used to allow the target to approve (claim) the swap. If the swap is not
+claimed within a specified duration of time, the sender may cancel it.
+
+## Interface
+
+### Dispatchable Functions
+
+* `create_swap` - called by a sender to register a new atomic swap
+* `claim_swap` - called by the target to approve a swap
+* `cancel_swap` - may be called by a sender after a specified duration
+
+License: Apache-2.0
diff --git a/substrate/frame/atomic-swap/src/lib.rs b/substrate/frame/atomic-swap/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8094c06030120c9a7583aed3f64dc2a5de7260d4
--- /dev/null
+++ b/substrate/frame/atomic-swap/src/lib.rs
@@ -0,0 +1,347 @@
+// 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.
+
+//! # Atomic Swap
+//!
+//! A pallet for atomically sending funds.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! A pallet for atomically sending funds from an origin to a target. A proof
+//! is used to allow the target to approve (claim) the swap. If the swap is not
+//! claimed within a specified duration of time, the sender may cancel it.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! * [`create_swap`](Call::create_swap) - called by a sender to register a new atomic swap
+//! * [`claim_swap`](Call::claim_swap) - called by the target to approve a swap
+//! * [`cancel_swap`](Call::cancel_swap) - may be called by a sender after a specified duration
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod tests;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::DispatchResult,
+	pallet_prelude::MaxEncodedLen,
+	traits::{BalanceStatus, Currency, Get, ReservableCurrency},
+	weights::Weight,
+	RuntimeDebugNoBound,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use scale_info::TypeInfo;
+use sp_io::hashing::blake2_256;
+use sp_runtime::RuntimeDebug;
+use sp_std::{
+	marker::PhantomData,
+	ops::{Deref, DerefMut},
+	prelude::*,
+};
+
+/// Pending atomic swap operation.
+#[derive(Clone, Eq, PartialEq, RuntimeDebugNoBound, Encode, Decode, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(T))]
+#[codec(mel_bound())]
+pub struct PendingSwap<T: Config> {
+	/// Source of the swap.
+	pub source: T::AccountId,
+	/// Action of this swap.
+	pub action: T::SwapAction,
+	/// End block of the lock.
+	pub end_block: BlockNumberFor<T>,
+}
+
+/// Hashed proof type.
+pub type HashedProof = [u8; 32];
+
+/// Definition of a pending atomic swap action. It contains the following three phrases:
+///
+/// - **Reserve**: reserve the resources needed for a swap. This is to make sure that **Claim**
+/// succeeds with best efforts.
+/// - **Claim**: claim any resources reserved in the first phrase.
+/// - **Cancel**: cancel any resources reserved in the first phrase.
+pub trait SwapAction<AccountId, T: Config> {
+	/// Reserve the resources needed for the swap, from the given `source`. The reservation is
+	/// allowed to fail. If that is the case, the the full swap creation operation is cancelled.
+	fn reserve(&self, source: &AccountId) -> DispatchResult;
+	/// Claim the reserved resources, with `source` and `target`. Returns whether the claim
+	/// succeeds.
+	fn claim(&self, source: &AccountId, target: &AccountId) -> bool;
+	/// Weight for executing the operation.
+	fn weight(&self) -> Weight;
+	/// Cancel the resources reserved in `source`.
+	fn cancel(&self, source: &AccountId);
+}
+
+/// A swap action that only allows transferring balances.
+#[derive(Clone, RuntimeDebug, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(C))]
+#[codec(mel_bound())]
+pub struct BalanceSwapAction<AccountId, C: ReservableCurrency<AccountId>> {
+	value: <C as Currency<AccountId>>::Balance,
+	_marker: PhantomData<C>,
+}
+
+impl<AccountId, C> BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	/// Create a new swap action value of balance.
+	pub fn new(value: <C as Currency<AccountId>>::Balance) -> Self {
+		Self { value, _marker: PhantomData }
+	}
+}
+
+impl<AccountId, C> Deref for BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	type Target = <C as Currency<AccountId>>::Balance;
+
+	fn deref(&self) -> &Self::Target {
+		&self.value
+	}
+}
+
+impl<AccountId, C> DerefMut for BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.value
+	}
+}
+
+impl<T: Config, AccountId, C> SwapAction<AccountId, T> for BalanceSwapAction<AccountId, C>
+where
+	C: ReservableCurrency<AccountId>,
+{
+	fn reserve(&self, source: &AccountId) -> DispatchResult {
+		C::reserve(source, self.value)
+	}
+
+	fn claim(&self, source: &AccountId, target: &AccountId) -> bool {
+		C::repatriate_reserved(source, target, self.value, BalanceStatus::Free).is_ok()
+	}
+
+	fn weight(&self) -> Weight {
+		T::DbWeight::get().reads_writes(1, 1)
+	}
+
+	fn cancel(&self, source: &AccountId) {
+		C::unreserve(source, self.value);
+	}
+}
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// Atomic swap's pallet configuration trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// Swap action.
+		type SwapAction: SwapAction<Self::AccountId, Self> + Parameter + MaxEncodedLen;
+		/// Limit of proof size.
+		///
+		/// Atomic swap is only atomic if once the proof is revealed, both parties can submit the
+		/// proofs on-chain. If A is the one that generates the proof, then it requires that either:
+		/// - A's blockchain has the same proof length limit as B's blockchain.
+		/// - Or A's blockchain has shorter proof length limit as B's blockchain.
+		///
+		/// If B sees A is on a blockchain with larger proof length limit, then it should kindly
+		/// refuse to accept the atomic swap request if A generates the proof, and asks that B
+		/// generates the proof instead.
+		#[pallet::constant]
+		type ProofLimit: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	pub type PendingSwaps<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Blake2_128Concat,
+		HashedProof,
+		PendingSwap<T>,
+	>;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Swap already exists.
+		AlreadyExist,
+		/// Swap proof is invalid.
+		InvalidProof,
+		/// Proof is too large.
+		ProofTooLarge,
+		/// Source does not match.
+		SourceMismatch,
+		/// Swap has already been claimed.
+		AlreadyClaimed,
+		/// Swap does not exist.
+		NotExist,
+		/// Claim action mismatch.
+		ClaimActionMismatch,
+		/// Duration has not yet passed for the swap to be cancelled.
+		DurationNotPassed,
+	}
+
+	/// Event of atomic swap pallet.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Swap created.
+		NewSwap { account: T::AccountId, proof: HashedProof, swap: PendingSwap<T> },
+		/// Swap claimed. The last parameter indicates whether the execution succeeds.
+		SwapClaimed { account: T::AccountId, proof: HashedProof, success: bool },
+		/// Swap cancelled.
+		SwapCancelled { account: T::AccountId, proof: HashedProof },
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Register a new atomic swap, declaring an intention to send funds from origin to target
+		/// on the current blockchain. The target can claim the fund using the revealed proof. If
+		/// the fund is not claimed after `duration` blocks, then the sender can cancel the swap.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `target`: Receiver of the atomic swap.
+		/// - `hashed_proof`: The blake2_256 hash of the secret proof.
+		/// - `balance`: Funds to be sent from origin.
+		/// - `duration`: Locked duration of the atomic swap. For safety reasons, it is recommended
+		///   that the revealer uses a shorter duration than the counterparty, to prevent the
+		///   situation where the revealer reveals the proof too late around the end block.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1).ref_time().saturating_add(40_000_000))]
+		pub fn create_swap(
+			origin: OriginFor<T>,
+			target: T::AccountId,
+			hashed_proof: HashedProof,
+			action: T::SwapAction,
+			duration: BlockNumberFor<T>,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			ensure!(
+				!PendingSwaps::<T>::contains_key(&target, hashed_proof),
+				Error::<T>::AlreadyExist
+			);
+
+			action.reserve(&source)?;
+
+			let swap = PendingSwap {
+				source,
+				action,
+				end_block: frame_system::Pallet::<T>::block_number() + duration,
+			};
+			PendingSwaps::<T>::insert(target.clone(), hashed_proof, swap.clone());
+
+			Self::deposit_event(Event::NewSwap { account: target, proof: hashed_proof, swap });
+
+			Ok(())
+		}
+
+		/// Claim an atomic swap.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `proof`: Revealed proof of the claim.
+		/// - `action`: Action defined in the swap, it must match the entry in blockchain. Otherwise
+		///   the operation fails. This is used for weight calculation.
+		#[pallet::call_index(1)]
+		#[pallet::weight(
+			T::DbWeight::get().reads_writes(1, 1)
+				.saturating_add(action.weight())
+				.ref_time()
+				.saturating_add(40_000_000)
+				.saturating_add((proof.len() as u64).saturating_mul(100))
+		)]
+		pub fn claim_swap(
+			origin: OriginFor<T>,
+			proof: Vec<u8>,
+			action: T::SwapAction,
+		) -> DispatchResult {
+			ensure!(proof.len() <= T::ProofLimit::get() as usize, Error::<T>::ProofTooLarge);
+
+			let target = ensure_signed(origin)?;
+			let hashed_proof = blake2_256(&proof);
+
+			let swap =
+				PendingSwaps::<T>::get(&target, hashed_proof).ok_or(Error::<T>::InvalidProof)?;
+			ensure!(swap.action == action, Error::<T>::ClaimActionMismatch);
+
+			let succeeded = swap.action.claim(&swap.source, &target);
+
+			PendingSwaps::<T>::remove(target.clone(), hashed_proof);
+
+			Self::deposit_event(Event::SwapClaimed {
+				account: target,
+				proof: hashed_proof,
+				success: succeeded,
+			});
+
+			Ok(())
+		}
+
+		/// Cancel an atomic swap. Only possible after the originally set duration has passed.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `target`: Target of the original atomic swap.
+		/// - `hashed_proof`: Hashed proof of the original atomic swap.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1).ref_time().saturating_add(40_000_000))]
+		pub fn cancel_swap(
+			origin: OriginFor<T>,
+			target: T::AccountId,
+			hashed_proof: HashedProof,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+
+			let swap = PendingSwaps::<T>::get(&target, hashed_proof).ok_or(Error::<T>::NotExist)?;
+			ensure!(swap.source == source, Error::<T>::SourceMismatch);
+			ensure!(
+				frame_system::Pallet::<T>::block_number() >= swap.end_block,
+				Error::<T>::DurationNotPassed,
+			);
+
+			swap.action.cancel(&swap.source);
+			PendingSwaps::<T>::remove(&target, hashed_proof);
+
+			Self::deposit_event(Event::SwapCancelled { account: target, proof: hashed_proof });
+
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/atomic-swap/src/tests.rs b/substrate/frame/atomic-swap/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..858417e8007fb8bfbf7847fa62fb67598eab0f6a
--- /dev/null
+++ b/substrate/frame/atomic-swap/src/tests.rs
@@ -0,0 +1,147 @@
+#![cfg(test)]
+
+use super::*;
+use crate as pallet_atomic_swap;
+
+use frame_support::traits::{ConstU32, ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		AtomicSwap: pallet_atomic_swap::{Pallet, Call, Event<T>},
+	}
+);
+
+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 = 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 = frame_support::traits::ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type SwapAction = BalanceSwapAction<u64, Balances>;
+	type ProofLimit = ConstU32<1024>;
+}
+
+const A: u64 = 1;
+const B: u64 = 2;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let genesis = pallet_balances::GenesisConfig::<Test> { balances: vec![(A, 100), (B, 200)] };
+	genesis.assimilate_storage(&mut t).unwrap();
+	t.into()
+}
+
+#[test]
+fn two_party_successful_swap() {
+	let mut chain1 = new_test_ext();
+	let mut chain2 = new_test_ext();
+
+	// A generates a random proof. Keep it secret.
+	let proof: [u8; 2] = [4, 2];
+	// The hashed proof is the blake2_256 hash of the proof. This is public.
+	let hashed_proof = blake2_256(&proof);
+
+	// A creates the swap on chain1.
+	chain1.execute_with(|| {
+		AtomicSwap::create_swap(
+			RuntimeOrigin::signed(A),
+			B,
+			hashed_proof,
+			BalanceSwapAction::new(50),
+			1000,
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100 - 50);
+		assert_eq!(Balances::free_balance(B), 200);
+	});
+
+	// B creates the swap on chain2.
+	chain2.execute_with(|| {
+		AtomicSwap::create_swap(
+			RuntimeOrigin::signed(B),
+			A,
+			hashed_proof,
+			BalanceSwapAction::new(75),
+			1000,
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100);
+		assert_eq!(Balances::free_balance(B), 200 - 75);
+	});
+
+	// A reveals the proof and claims the swap on chain2.
+	chain2.execute_with(|| {
+		AtomicSwap::claim_swap(
+			RuntimeOrigin::signed(A),
+			proof.to_vec(),
+			BalanceSwapAction::new(75),
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100 + 75);
+		assert_eq!(Balances::free_balance(B), 200 - 75);
+	});
+
+	// B use the revealed proof to claim the swap on chain1.
+	chain1.execute_with(|| {
+		AtomicSwap::claim_swap(
+			RuntimeOrigin::signed(B),
+			proof.to_vec(),
+			BalanceSwapAction::new(50),
+		)
+		.unwrap();
+
+		assert_eq!(Balances::free_balance(A), 100 - 50);
+		assert_eq!(Balances::free_balance(B), 200 + 50);
+	});
+}
diff --git a/substrate/frame/aura/Cargo.toml b/substrate/frame/aura/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..67eb99fcd5fbe9c8407406e51ff876a96d2127d5
--- /dev/null
+++ b/substrate/frame/aura/Cargo.toml
@@ -0,0 +1,53 @@
+[package]
+name = "pallet-aura"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME AURA consensus pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-timestamp = { version = "4.0.0-dev", default-features = false, path = "../timestamp" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto" }
+sp-consensus-aura = { version = "0.10.0-dev", default-features = false, path = "../../primitives/consensus/aura" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-application-crypto/std",
+	"sp-consensus-aura/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
+experimental = []
diff --git a/substrate/frame/aura/README.md b/substrate/frame/aura/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..263f158d790686aa34fb2a238aad1999e4934011
--- /dev/null
+++ b/substrate/frame/aura/README.md
@@ -0,0 +1,28 @@
+# Aura Module
+
+- [`aura::Config`](https://docs.rs/pallet-aura/latest/pallet_aura/pallet/trait.Config.html)
+- [`Pallet`](https://docs.rs/pallet-aura/latest/pallet_aura/pallet/struct.Pallet.html)
+
+## Overview
+
+The Aura module extends Aura consensus by managing offline reporting.
+
+## Interface
+
+### Public Functions
+
+- `slot_duration` - Determine the Aura slot-duration based on the Timestamp module configuration.
+
+## Related Modules
+
+- [Timestamp](https://docs.rs/pallet-timestamp/latest/pallet_timestamp/): The Timestamp module is used in Aura to track
+consensus rounds (via `slots`).
+
+## References
+
+If you're interested in hacking on this module, it is useful to understand the interaction with
+`substrate/primitives/inherents/src/lib.rs` and, specifically, the required implementation of
+[`ProvideInherent`](https://docs.rs/sp-inherents/latest/sp_inherents/trait.ProvideInherent.html) and
+[`ProvideInherentData`](https://docs.rs/sp-inherents/latest/sp_inherents/trait.ProvideInherentData.html) to create and check inherents.
+
+License: Apache-2.0
diff --git a/substrate/frame/aura/src/lib.rs b/substrate/frame/aura/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b314a3601e15f123c162d50230172c59f04c6fc5
--- /dev/null
+++ b/substrate/frame/aura/src/lib.rs
@@ -0,0 +1,416 @@
+// 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.
+
+//! # Aura Module
+//!
+//! - [`Config`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! The Aura module extends Aura consensus by managing offline reporting.
+//!
+//! ## Interface
+//!
+//! ### Public Functions
+//!
+//! - `slot_duration` - Determine the Aura slot-duration based on the Timestamp module
+//!   configuration.
+//!
+//! ## Related Modules
+//!
+//! - [Timestamp](../pallet_timestamp/index.html): The Timestamp module is used in Aura to track
+//! consensus rounds (via `slots`).
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	traits::{DisabledValidators, FindAuthor, Get, OnTimestampSet, OneSessionHandler},
+	BoundedSlice, BoundedVec, ConsensusEngineId, Parameter,
+};
+use log;
+use sp_consensus_aura::{AuthorityIndex, ConsensusLog, Slot, AURA_ENGINE_ID};
+use sp_runtime::{
+	generic::DigestItem,
+	traits::{IsMember, Member, SaturatedConversion, Saturating, Zero},
+	RuntimeAppPublic,
+};
+use sp_std::prelude::*;
+
+pub mod migrations;
+mod mock;
+mod tests;
+
+pub use pallet::*;
+
+const LOG_TARGET: &str = "runtime::aura";
+
+/// A slot duration provider which infers the slot duration from the
+/// [`pallet_timestamp::Config::MinimumPeriod`] by multiplying it by two, to ensure
+/// that authors have the majority of their slot to author within.
+///
+/// This was the default behavior of the Aura pallet and may be used for
+/// backwards compatibility.
+///
+/// Note that this type is likely not useful without the `experimental`
+/// feature.
+pub struct MinimumPeriodTimesTwo<T>(sp_std::marker::PhantomData<T>);
+
+impl<T: pallet_timestamp::Config> Get<T::Moment> for MinimumPeriodTimesTwo<T> {
+	fn get() -> T::Moment {
+		<T as pallet_timestamp::Config>::MinimumPeriod::get().saturating_mul(2u32.into())
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: pallet_timestamp::Config + frame_system::Config {
+		/// The identifier type for an authority.
+		type AuthorityId: Member
+			+ Parameter
+			+ RuntimeAppPublic
+			+ MaybeSerializeDeserialize
+			+ MaxEncodedLen;
+		/// The maximum number of authorities that the pallet can hold.
+		type MaxAuthorities: Get<u32>;
+
+		/// A way to check whether a given validator is disabled and should not be authoring blocks.
+		/// Blocks authored by a disabled validator will lead to a panic as part of this module's
+		/// initialization.
+		type DisabledValidators: DisabledValidators;
+
+		/// Whether to allow block authors to create multiple blocks per slot.
+		///
+		/// If this is `true`, the pallet will allow slots to stay the same across sequential
+		/// blocks. If this is `false`, the pallet will require that subsequent blocks always have
+		/// higher slots than previous ones.
+		///
+		/// Regardless of the setting of this storage value, the pallet will always enforce the
+		/// invariant that slots don't move backwards as the chain progresses.
+		///
+		/// The typical value for this should be 'false' unless this pallet is being augmented by
+		/// another pallet which enforces some limitation on the number of blocks authors can create
+		/// using the same slot.
+		type AllowMultipleBlocksPerSlot: Get<bool>;
+
+		/// The slot duration Aura should run with, expressed in milliseconds.
+		/// The effective value of this type should not change while the chain is running.
+		///
+		/// For backwards compatibility either use [`MinimumPeriodTimesTwo`] or a const.
+		///
+		/// This associated type is only present when compiled with the `experimental`
+		/// feature.
+		#[cfg(feature = "experimental")]
+		type SlotDuration: Get<<Self as pallet_timestamp::Config>::Moment>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(sp_std::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
+			if let Some(new_slot) = Self::current_slot_from_digests() {
+				let current_slot = CurrentSlot::<T>::get();
+
+				if T::AllowMultipleBlocksPerSlot::get() {
+					assert!(current_slot <= new_slot, "Slot must not decrease");
+				} else {
+					assert!(current_slot < new_slot, "Slot must increase");
+				}
+
+				CurrentSlot::<T>::put(new_slot);
+
+				if let Some(n_authorities) = <Authorities<T>>::decode_len() {
+					let authority_index = *new_slot % n_authorities as u64;
+					if T::DisabledValidators::is_disabled(authority_index as u32) {
+						panic!(
+							"Validator with index {:?} is disabled and should not be attempting to author blocks.",
+							authority_index,
+						);
+					}
+				}
+
+				// TODO [#3398] Generate offence report for all authorities that skipped their
+				// slots.
+
+				T::DbWeight::get().reads_writes(2, 1)
+			} else {
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
+			Self::do_try_state()
+		}
+	}
+
+	/// The current authority set.
+	#[pallet::storage]
+	#[pallet::getter(fn authorities)]
+	pub(super) type Authorities<T: Config> =
+		StorageValue<_, BoundedVec<T::AuthorityId, T::MaxAuthorities>, ValueQuery>;
+
+	/// The current slot of this block.
+	///
+	/// This will be set in `on_initialize`.
+	#[pallet::storage]
+	#[pallet::getter(fn current_slot)]
+	pub(super) type CurrentSlot<T: Config> = StorageValue<_, Slot, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub authorities: Vec<T::AuthorityId>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			Pallet::<T>::initialize_authorities(&self.authorities);
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Change authorities.
+	///
+	/// The storage will be applied immediately.
+	/// And aura consensus log will be appended to block's log.
+	///
+	/// This is a no-op if `new` is empty.
+	pub fn change_authorities(new: BoundedVec<T::AuthorityId, T::MaxAuthorities>) {
+		if new.is_empty() {
+			log::warn!(target: LOG_TARGET, "Ignoring empty authority change.");
+
+			return
+		}
+
+		<Authorities<T>>::put(&new);
+
+		let log = DigestItem::Consensus(
+			AURA_ENGINE_ID,
+			ConsensusLog::AuthoritiesChange(new.into_inner()).encode(),
+		);
+		<frame_system::Pallet<T>>::deposit_log(log);
+	}
+
+	/// Initial authorities.
+	///
+	/// The storage will be applied immediately.
+	///
+	/// The authorities length must be equal or less than T::MaxAuthorities.
+	pub fn initialize_authorities(authorities: &[T::AuthorityId]) {
+		if !authorities.is_empty() {
+			assert!(<Authorities<T>>::get().is_empty(), "Authorities are already initialized!");
+			let bounded = <BoundedSlice<'_, _, T::MaxAuthorities>>::try_from(authorities)
+				.expect("Initial authority set must be less than T::MaxAuthorities");
+			<Authorities<T>>::put(bounded);
+		}
+	}
+
+	/// Get the current slot from the pre-runtime digests.
+	fn current_slot_from_digests() -> Option<Slot> {
+		let digest = frame_system::Pallet::<T>::digest();
+		let pre_runtime_digests = digest.logs.iter().filter_map(|d| d.as_pre_runtime());
+		for (id, mut data) in pre_runtime_digests {
+			if id == AURA_ENGINE_ID {
+				return Slot::decode(&mut data).ok()
+			}
+		}
+
+		None
+	}
+
+	/// Determine the Aura slot-duration based on the Timestamp module configuration.
+	pub fn slot_duration() -> T::Moment {
+		#[cfg(feature = "experimental")]
+		{
+			T::SlotDuration::get()
+		}
+
+		#[cfg(not(feature = "experimental"))]
+		{
+			// we double the minimum block-period so each author can always propose within
+			// the majority of its slot.
+			<T as pallet_timestamp::Config>::MinimumPeriod::get().saturating_mul(2u32.into())
+		}
+	}
+
+	/// Ensure the correctness of the state of this pallet.
+	///
+	/// This should be valid before or after each state transition of this pallet.
+	///
+	/// # Invariants
+	///
+	/// ## `CurrentSlot`
+	///
+	/// If we don't allow for multiple blocks per slot, then the current slot must be less than the
+	/// maximal slot number. Otherwise, it can be arbitrary.
+	///
+	/// ## `Authorities`
+	///
+	/// * The authorities must be non-empty.
+	/// * The current authority cannot be disabled.
+	/// * The number of authorities must be less than or equal to `T::MaxAuthorities`. This however,
+	///   is guarded by the type system.
+	#[cfg(any(test, feature = "try-runtime"))]
+	pub fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> {
+		// We don't have any guarantee that we are already after `on_initialize` and thus we have to
+		// check the current slot from the digest or take the last known slot.
+		let current_slot =
+			Self::current_slot_from_digests().unwrap_or_else(|| CurrentSlot::<T>::get());
+
+		// Check that the current slot is less than the maximal slot number, unless we allow for
+		// multiple blocks per slot.
+		if !T::AllowMultipleBlocksPerSlot::get() {
+			frame_support::ensure!(
+				current_slot < u64::MAX,
+				"Current slot has reached maximum value and cannot be incremented further.",
+			);
+		}
+
+		let authorities_len =
+			<Authorities<T>>::decode_len().ok_or("Failed to decode authorities length")?;
+
+		// Check that the authorities are non-empty.
+		frame_support::ensure!(!authorities_len.is_zero(), "Authorities must be non-empty.");
+
+		// Check that the current authority is not disabled.
+		let authority_index = *current_slot % authorities_len as u64;
+		frame_support::ensure!(
+			!T::DisabledValidators::is_disabled(authority_index as u32),
+			"Current validator is disabled and should not be attempting to author blocks.",
+		);
+
+		Ok(())
+	}
+}
+
+impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
+	type Public = T::AuthorityId;
+}
+
+impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
+	type Key = T::AuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
+	{
+		let authorities = validators.map(|(_, k)| k).collect::<Vec<_>>();
+		Self::initialize_authorities(&authorities);
+	}
+
+	fn on_new_session<'a, I: 'a>(changed: bool, validators: I, _queued_validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
+	{
+		// instant changes
+		if changed {
+			let next_authorities = validators.map(|(_, k)| k).collect::<Vec<_>>();
+			let last_authorities = Self::authorities();
+			if last_authorities != next_authorities {
+				if next_authorities.len() as u32 > T::MaxAuthorities::get() {
+					log::warn!(
+						target: LOG_TARGET,
+						"next authorities list larger than {}, truncating",
+						T::MaxAuthorities::get(),
+					);
+				}
+				let bounded = <BoundedVec<_, T::MaxAuthorities>>::truncate_from(next_authorities);
+				Self::change_authorities(bounded);
+			}
+		}
+	}
+
+	fn on_disabled(i: u32) {
+		let log = DigestItem::Consensus(
+			AURA_ENGINE_ID,
+			ConsensusLog::<T::AuthorityId>::OnDisabled(i as AuthorityIndex).encode(),
+		);
+
+		<frame_system::Pallet<T>>::deposit_log(log);
+	}
+}
+
+impl<T: Config> FindAuthor<u32> for Pallet<T> {
+	fn find_author<'a, I>(digests: I) -> Option<u32>
+	where
+		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+	{
+		for (id, mut data) in digests.into_iter() {
+			if id == AURA_ENGINE_ID {
+				let slot = Slot::decode(&mut data).ok()?;
+				let author_index = *slot % Self::authorities().len() as u64;
+				return Some(author_index as u32)
+			}
+		}
+
+		None
+	}
+}
+
+/// We can not implement `FindAuthor` twice, because the compiler does not know if
+/// `u32 == T::AuthorityId` and thus, prevents us to implement the trait twice.
+#[doc(hidden)]
+pub struct FindAccountFromAuthorIndex<T, Inner>(sp_std::marker::PhantomData<(T, Inner)>);
+
+impl<T: Config, Inner: FindAuthor<u32>> FindAuthor<T::AuthorityId>
+	for FindAccountFromAuthorIndex<T, Inner>
+{
+	fn find_author<'a, I>(digests: I) -> Option<T::AuthorityId>
+	where
+		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+	{
+		let i = Inner::find_author(digests)?;
+
+		let validators = <Pallet<T>>::authorities();
+		validators.get(i as usize).cloned()
+	}
+}
+
+/// Find the authority ID of the Aura authority who authored the current block.
+pub type AuraAuthorId<T> = FindAccountFromAuthorIndex<T, Pallet<T>>;
+
+impl<T: Config> IsMember<T::AuthorityId> for Pallet<T> {
+	fn is_member(authority_id: &T::AuthorityId) -> bool {
+		Self::authorities().iter().any(|id| id == authority_id)
+	}
+}
+
+impl<T: Config> OnTimestampSet<T::Moment> for Pallet<T> {
+	fn on_timestamp_set(moment: T::Moment) {
+		let slot_duration = Self::slot_duration();
+		assert!(!slot_duration.is_zero(), "Aura slot duration cannot be zero.");
+
+		let timestamp_slot = moment / slot_duration;
+		let timestamp_slot = Slot::from(timestamp_slot.saturated_into::<u64>());
+
+		assert!(
+			CurrentSlot::<T>::get() == timestamp_slot,
+			"Timestamp slot must match `CurrentSlot`"
+		);
+	}
+}
diff --git a/substrate/frame/aura/src/migrations.rs b/substrate/frame/aura/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b45e4eb7cb5c866920a72601b5db4baa22d16d87
--- /dev/null
+++ b/substrate/frame/aura/src/migrations.rs
@@ -0,0 +1,45 @@
+// 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.
+
+//! Migrations for the AURA pallet.
+
+use frame_support::{pallet_prelude::*, traits::Get, weights::Weight};
+
+struct __LastTimestamp<T>(sp_std::marker::PhantomData<T>);
+impl<T: RemoveLastTimestamp> frame_support::traits::StorageInstance for __LastTimestamp<T> {
+	fn pallet_prefix() -> &'static str {
+		T::PalletPrefix::get()
+	}
+	const STORAGE_PREFIX: &'static str = "LastTimestamp";
+}
+
+type LastTimestamp<T> = StorageValue<__LastTimestamp<T>, (), ValueQuery>;
+
+pub trait RemoveLastTimestamp: super::Config {
+	type PalletPrefix: Get<&'static str>;
+}
+
+/// Remove the `LastTimestamp` storage value.
+///
+/// This storage value was removed and replaced by `CurrentSlot`. As we only remove this storage
+/// value, it is safe to call this method multiple times.
+///
+/// This migration requires a type `T` that implements [`RemoveLastTimestamp`].
+pub fn remove_last_timestamp<T: RemoveLastTimestamp>() -> Weight {
+	LastTimestamp::<T>::kill();
+	T::DbWeight::get().writes(1)
+}
diff --git a/substrate/frame/aura/src/mock.rs b/substrate/frame/aura/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..39b798c2f6841a98e34cc8dce3704be945ae54f7
--- /dev/null
+++ b/substrate/frame/aura/src/mock.rs
@@ -0,0 +1,126 @@
+// 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.
+
+//! Test utilities
+
+#![cfg(test)]
+
+use crate as pallet_aura;
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64, DisabledValidators},
+};
+use sp_consensus_aura::{ed25519::AuthorityId, AuthorityIndex};
+use sp_core::H256;
+use sp_runtime::{testing::UintAuthorityId, traits::IdentityLookup, BuildStorage};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+const SLOT_DURATION: u64 = 2;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+		Aura: pallet_aura::{Pallet, Storage, Config<T>},
+	}
+);
+
+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 RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Hashing = ::sp_runtime::traits::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 = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = Aura;
+	type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	static DisabledValidatorTestValue: Vec<AuthorityIndex> = Default::default();
+	pub static AllowMultipleBlocksPerSlot: bool = false;
+}
+
+pub struct MockDisabledValidators;
+
+impl MockDisabledValidators {
+	pub fn disable_validator(index: AuthorityIndex) {
+		DisabledValidatorTestValue::mutate(|v| {
+			if let Err(i) = v.binary_search(&index) {
+				v.insert(i, index);
+			}
+		})
+	}
+}
+
+impl DisabledValidators for MockDisabledValidators {
+	fn is_disabled(index: AuthorityIndex) -> bool {
+		DisabledValidatorTestValue::get().binary_search(&index).is_ok()
+	}
+}
+
+impl pallet_aura::Config for Test {
+	type AuthorityId = AuthorityId;
+	type DisabledValidators = MockDisabledValidators;
+	type MaxAuthorities = ConstU32<10>;
+	type AllowMultipleBlocksPerSlot = AllowMultipleBlocksPerSlot;
+
+	#[cfg(feature = "experimental")]
+	type SlotDuration = ConstU64<SLOT_DURATION>;
+}
+
+fn build_ext(authorities: Vec<u64>) -> sp_io::TestExternalities {
+	let mut storage = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_aura::GenesisConfig::<Test> {
+		authorities: authorities.into_iter().map(|a| UintAuthorityId(a).to_public_key()).collect(),
+	}
+	.assimilate_storage(&mut storage)
+	.unwrap();
+	storage.into()
+}
+
+pub fn build_ext_and_execute_test(authorities: Vec<u64>, test: impl FnOnce() -> ()) {
+	let mut ext = build_ext(authorities);
+	ext.execute_with(|| {
+		test();
+		Aura::do_try_state().expect("Storage invariants should hold")
+	});
+}
diff --git a/substrate/frame/aura/src/tests.rs b/substrate/frame/aura/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d3ce877d3e60dd6fe67fcf4ab67b747c5db8f719
--- /dev/null
+++ b/substrate/frame/aura/src/tests.rs
@@ -0,0 +1,117 @@
+// 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 the module.
+
+#![cfg(test)]
+
+use crate::mock::{build_ext_and_execute_test, Aura, MockDisabledValidators, System};
+use codec::Encode;
+use frame_support::traits::OnInitialize;
+use sp_consensus_aura::{Slot, AURA_ENGINE_ID};
+use sp_runtime::{Digest, DigestItem};
+
+#[test]
+fn initial_values() {
+	build_ext_and_execute_test(vec![0, 1, 2, 3], || {
+		assert_eq!(Aura::current_slot(), 0u64);
+		assert_eq!(Aura::authorities().len(), 4);
+	});
+}
+
+#[test]
+#[should_panic(
+	expected = "Validator with index 1 is disabled and should not be attempting to author blocks."
+)]
+fn disabled_validators_cannot_author_blocks() {
+	build_ext_and_execute_test(vec![0, 1, 2, 3], || {
+		// slot 1 should be authored by validator at index 1
+		let slot = Slot::from(1);
+		let pre_digest =
+			Digest { logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())] };
+
+		System::reset_events();
+		System::initialize(&42, &System::parent_hash(), &pre_digest);
+
+		// let's disable the validator
+		MockDisabledValidators::disable_validator(1);
+
+		// and we should not be able to initialize the block
+		Aura::on_initialize(42);
+	});
+}
+
+#[test]
+#[should_panic(expected = "Slot must increase")]
+fn pallet_requires_slot_to_increase_unless_allowed() {
+	build_ext_and_execute_test(vec![0, 1, 2, 3], || {
+		crate::mock::AllowMultipleBlocksPerSlot::set(false);
+
+		let slot = Slot::from(1);
+		let pre_digest =
+			Digest { logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())] };
+
+		System::reset_events();
+		System::initialize(&42, &System::parent_hash(), &pre_digest);
+
+		// and we should not be able to initialize the block with the same slot a second time.
+		Aura::on_initialize(42);
+		Aura::on_initialize(42);
+	});
+}
+
+#[test]
+fn pallet_can_allow_unchanged_slot() {
+	build_ext_and_execute_test(vec![0, 1, 2, 3], || {
+		let slot = Slot::from(1);
+		let pre_digest =
+			Digest { logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())] };
+
+		System::reset_events();
+		System::initialize(&42, &System::parent_hash(), &pre_digest);
+
+		crate::mock::AllowMultipleBlocksPerSlot::set(true);
+
+		// and we should be able to initialize the block with the same slot a second time.
+		Aura::on_initialize(42);
+		Aura::on_initialize(42);
+	});
+}
+
+#[test]
+#[should_panic(expected = "Slot must not decrease")]
+fn pallet_always_rejects_decreasing_slot() {
+	build_ext_and_execute_test(vec![0, 1, 2, 3], || {
+		let slot = Slot::from(2);
+		let pre_digest =
+			Digest { logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())] };
+
+		System::reset_events();
+		System::initialize(&42, &System::parent_hash(), &pre_digest);
+
+		crate::mock::AllowMultipleBlocksPerSlot::set(true);
+
+		Aura::on_initialize(42);
+		System::finalize();
+
+		let earlier_slot = Slot::from(1);
+		let pre_digest =
+			Digest { logs: vec![DigestItem::PreRuntime(AURA_ENGINE_ID, earlier_slot.encode())] };
+		System::initialize(&43, &System::parent_hash(), &pre_digest);
+		Aura::on_initialize(43);
+	});
+}
diff --git a/substrate/frame/authority-discovery/Cargo.toml b/substrate/frame/authority-discovery/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4096e2bbd548d03f105b32d8fbfa5b1d29584b01
--- /dev/null
+++ b/substrate/frame/authority-discovery/Cargo.toml
@@ -0,0 +1,54 @@
+[package]
+name = "pallet-authority-discovery"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for authority discovery"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-session = { version = "4.0.0-dev", default-features = false, features = [
+	"historical",
+], path = "../session" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto" }
+sp-authority-discovery = { version = "4.0.0-dev", default-features = false, path = "../../primitives/authority-discovery" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-session/std",
+	"scale-info/std",
+	"sp-application-crypto/std",
+	"sp-authority-discovery/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-session/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/authority-discovery/README.md b/substrate/frame/authority-discovery/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9a534dcbeb6f8f98ec2260176ca4075f81179194
--- /dev/null
+++ b/substrate/frame/authority-discovery/README.md
@@ -0,0 +1,6 @@
+# Authority discovery module.
+
+This module is used by the `client/authority-discovery` to retrieve the
+current set of authorities.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/authority-discovery/src/lib.rs b/substrate/frame/authority-discovery/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..87b743ae1967705f894dfbeacf840d1ac40c9122
--- /dev/null
+++ b/substrate/frame/authority-discovery/src/lib.rs
@@ -0,0 +1,373 @@
+// 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.
+
+//! # Authority discovery pallet.
+//!
+//! This pallet is used by the `client/authority-discovery` and by polkadot's parachain logic
+//! to retrieve the current and the next set of authorities.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{
+	traits::{Get, OneSessionHandler},
+	WeakBoundedVec,
+};
+use sp_authority_discovery::AuthorityId;
+use sp_std::prelude::*;
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	/// The pallet's config trait.
+	pub trait Config: frame_system::Config + pallet_session::Config {
+		/// The maximum number of authorities that can be added.
+		type MaxAuthorities: Get<u32>;
+	}
+
+	#[pallet::storage]
+	#[pallet::getter(fn keys)]
+	/// Keys of the current authority set.
+	pub(super) type Keys<T: Config> =
+		StorageValue<_, WeakBoundedVec<AuthorityId, T::MaxAuthorities>, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn next_keys)]
+	/// Keys of the next authority set.
+	pub(super) type NextKeys<T: Config> =
+		StorageValue<_, WeakBoundedVec<AuthorityId, T::MaxAuthorities>, ValueQuery>;
+
+	#[derive(frame_support::DefaultNoBound)]
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub keys: Vec<AuthorityId>,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			Pallet::<T>::initialize_keys(&self.keys)
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Retrieve authority identifiers of the current and next authority set
+	/// sorted and deduplicated.
+	pub fn authorities() -> Vec<AuthorityId> {
+		let mut keys = Keys::<T>::get().to_vec();
+		let next = NextKeys::<T>::get().to_vec();
+
+		keys.extend(next);
+		keys.sort();
+		keys.dedup();
+
+		keys.to_vec()
+	}
+
+	/// Retrieve authority identifiers of the current authority set in the original order.
+	pub fn current_authorities() -> WeakBoundedVec<AuthorityId, T::MaxAuthorities> {
+		Keys::<T>::get()
+	}
+
+	/// Retrieve authority identifiers of the next authority set in the original order.
+	pub fn next_authorities() -> WeakBoundedVec<AuthorityId, T::MaxAuthorities> {
+		NextKeys::<T>::get()
+	}
+
+	fn initialize_keys(keys: &Vec<AuthorityId>) {
+		if !keys.is_empty() {
+			assert!(Keys::<T>::get().is_empty(), "Keys are already initialized!");
+
+			let bounded_keys =
+				WeakBoundedVec::<AuthorityId, T::MaxAuthorities>::try_from((*keys).clone())
+					.expect("Keys vec too big");
+
+			Keys::<T>::put(&bounded_keys);
+			NextKeys::<T>::put(&bounded_keys);
+		}
+	}
+}
+
+impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
+	type Public = AuthorityId;
+}
+
+impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
+	type Key = AuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(authorities: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, Self::Key)>,
+	{
+		Self::initialize_keys(&authorities.map(|x| x.1).collect::<Vec<_>>());
+	}
+
+	fn on_new_session<'a, I: 'a>(changed: bool, validators: I, queued_validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, Self::Key)>,
+	{
+		// Remember who the authorities are for the new and next session.
+		if changed {
+			let keys = validators.map(|x| x.1).collect::<Vec<_>>();
+
+			let bounded_keys = WeakBoundedVec::<_, T::MaxAuthorities>::force_from(
+				keys,
+				Some(
+					"Warning: The session has more validators than expected. \
+				A runtime configuration adjustment may be needed.",
+				),
+			);
+
+			Keys::<T>::put(bounded_keys);
+
+			let next_keys = queued_validators.map(|x| x.1).collect::<Vec<_>>();
+
+			let next_bounded_keys = WeakBoundedVec::<_, T::MaxAuthorities>::force_from(
+				next_keys,
+				Some(
+					"Warning: The session has more queued validators than expected. \
+				A runtime configuration adjustment may be needed.",
+				),
+			);
+
+			NextKeys::<T>::put(next_bounded_keys);
+		}
+	}
+
+	fn on_disabled(_i: u32) {
+		// ignore
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate as pallet_authority_discovery;
+	use frame_support::{
+		parameter_types,
+		traits::{ConstU32, ConstU64},
+	};
+	use sp_application_crypto::Pair;
+	use sp_authority_discovery::AuthorityPair;
+	use sp_core::{crypto::key_types, H256};
+	use sp_io::TestExternalities;
+	use sp_runtime::{
+		testing::UintAuthorityId,
+		traits::{ConvertInto, IdentityLookup, OpaqueKeys},
+		BuildStorage, KeyTypeId, Perbill,
+	};
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+			Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+			AuthorityDiscovery: pallet_authority_discovery::{Pallet, Config<T>},
+		}
+	);
+
+	parameter_types! {
+		pub const DisabledValidatorsThreshold: Perbill = Perbill::from_percent(33);
+	}
+
+	impl Config for Test {
+		type MaxAuthorities = ConstU32<100>;
+	}
+
+	impl pallet_session::Config for Test {
+		type SessionManager = ();
+		type Keys = UintAuthorityId;
+		type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+		type SessionHandler = TestSessionHandler;
+		type RuntimeEvent = RuntimeEvent;
+		type ValidatorId = AuthorityId;
+		type ValidatorIdOf = ConvertInto;
+		type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+		type WeightInfo = ();
+	}
+
+	impl pallet_session::historical::Config for Test {
+		type FullIdentification = ();
+		type FullIdentificationOf = ();
+	}
+
+	pub type BlockNumber = u64;
+
+	parameter_types! {
+		pub const Period: BlockNumber = 1;
+		pub const Offset: BlockNumber = 0;
+	}
+
+	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 RuntimeCall = RuntimeCall;
+		type Hash = H256;
+		type Hashing = ::sp_runtime::traits::BlakeTwo256;
+		type AccountId = AuthorityId;
+		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>;
+	}
+
+	pub struct TestSessionHandler;
+	impl pallet_session::SessionHandler<AuthorityId> for TestSessionHandler {
+		const KEY_TYPE_IDS: &'static [KeyTypeId] = &[key_types::DUMMY];
+
+		fn on_new_session<Ks: OpaqueKeys>(
+			_changed: bool,
+			_validators: &[(AuthorityId, Ks)],
+			_queued_validators: &[(AuthorityId, Ks)],
+		) {
+		}
+
+		fn on_disabled(_validator_index: u32) {}
+
+		fn on_genesis_session<Ks: OpaqueKeys>(_validators: &[(AuthorityId, Ks)]) {}
+	}
+
+	#[test]
+	fn authorities_returns_current_and_next_authority_set() {
+		// The whole authority discovery pallet ignores account ids, but we still need them for
+		// `pallet_session::OneSessionHandler::on_new_session`, thus its safe to use the same value
+		// everywhere.
+		let account_id = AuthorityPair::from_seed_slice(vec![10; 32].as_ref()).unwrap().public();
+
+		let mut first_authorities: Vec<AuthorityId> = vec![0, 1]
+			.into_iter()
+			.map(|i| AuthorityPair::from_seed_slice(vec![i; 32].as_ref()).unwrap().public())
+			.map(AuthorityId::from)
+			.collect();
+
+		let second_authorities: Vec<AuthorityId> = vec![2, 3]
+			.into_iter()
+			.map(|i| AuthorityPair::from_seed_slice(vec![i; 32].as_ref()).unwrap().public())
+			.map(AuthorityId::from)
+			.collect();
+		// Needed for `pallet_session::OneSessionHandler::on_new_session`.
+		let second_authorities_and_account_ids = second_authorities
+			.clone()
+			.into_iter()
+			.map(|id| (&account_id, id))
+			.collect::<Vec<(&AuthorityId, AuthorityId)>>();
+
+		let mut third_authorities: Vec<AuthorityId> = vec![4, 5]
+			.into_iter()
+			.map(|i| AuthorityPair::from_seed_slice(vec![i; 32].as_ref()).unwrap().public())
+			.map(AuthorityId::from)
+			.collect();
+		// Needed for `pallet_session::OneSessionHandler::on_new_session`.
+		let third_authorities_and_account_ids = third_authorities
+			.clone()
+			.into_iter()
+			.map(|id| (&account_id, id))
+			.collect::<Vec<(&AuthorityId, AuthorityId)>>();
+
+		// Build genesis.
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+		pallet_authority_discovery::GenesisConfig::<Test> { keys: vec![], ..Default::default() }
+			.assimilate_storage(&mut t)
+			.unwrap();
+
+		// Create externalities.
+		let mut externalities = TestExternalities::new(t);
+
+		externalities.execute_with(|| {
+			use frame_support::traits::OneSessionHandler;
+
+			AuthorityDiscovery::on_genesis_session(
+				first_authorities.iter().map(|id| (id, id.clone())),
+			);
+			first_authorities.sort();
+			let mut authorities_returned = AuthorityDiscovery::authorities();
+			authorities_returned.sort();
+			assert_eq!(first_authorities, authorities_returned);
+
+			// When `changed` set to false, the authority set should not be updated.
+			AuthorityDiscovery::on_new_session(
+				false,
+				second_authorities_and_account_ids.clone().into_iter(),
+				third_authorities_and_account_ids.clone().into_iter(),
+			);
+			let authorities_returned = AuthorityDiscovery::authorities();
+			assert_eq!(
+				first_authorities, authorities_returned,
+				"Expected authority set not to change as `changed` was set to false.",
+			);
+
+			// When `changed` set to true, the authority set should be updated.
+			AuthorityDiscovery::on_new_session(
+				true,
+				second_authorities_and_account_ids.into_iter(),
+				third_authorities_and_account_ids.clone().into_iter(),
+			);
+			let mut second_and_third_authorities = second_authorities
+				.iter()
+				.chain(third_authorities.iter())
+				.cloned()
+				.collect::<Vec<AuthorityId>>();
+			second_and_third_authorities.sort();
+			assert_eq!(
+				second_and_third_authorities,
+				AuthorityDiscovery::authorities(),
+				"Expected authority set to contain both the authorities of the new as well as the \
+				 next session."
+			);
+
+			// With overlapping authority sets, `authorities()` should return a deduplicated set.
+			AuthorityDiscovery::on_new_session(
+				true,
+				third_authorities_and_account_ids.clone().into_iter(),
+				third_authorities_and_account_ids.clone().into_iter(),
+			);
+			third_authorities.sort();
+			assert_eq!(
+				third_authorities,
+				AuthorityDiscovery::authorities(),
+				"Expected authority set to be deduplicated."
+			);
+		});
+	}
+}
diff --git a/substrate/frame/authorship/Cargo.toml b/substrate/frame/authorship/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3dadb1bed3c7491e489280d39019700e9bacae72
--- /dev/null
+++ b/substrate/frame/authorship/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "pallet-authorship"
+version = "4.0.0-dev"
+description = "Block and Uncle Author tracking for the FRAME"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+impl-trait-for-tuples = "0.2.2"
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/authorship/README.md b/substrate/frame/authorship/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d61747da3e101b4989b517a77c166cf98cbce6fe
--- /dev/null
+++ b/substrate/frame/authorship/README.md
@@ -0,0 +1,5 @@
+Authorship tracking for FRAME runtimes.
+
+This tracks the current author of the block and recent uncles.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/authorship/src/lib.rs b/substrate/frame/authorship/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a9bd0c38cb67c0a84b142a50e3ca857fb84d0f25
--- /dev/null
+++ b/substrate/frame/authorship/src/lib.rs
@@ -0,0 +1,205 @@
+// 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.
+
+//! Authorship tracking for FRAME runtimes.
+//!
+//! This tracks the current author of the block.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::traits::FindAuthor;
+use sp_std::prelude::*;
+
+pub use pallet::*;
+
+/// An event handler for the authorship pallet. There is a dummy implementation
+/// for `()`, which does nothing.
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+pub trait EventHandler<Author, BlockNumber> {
+	/// Note that the given account ID is the author of the current block.
+	fn note_author(author: Author);
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Find the author of a block.
+		type FindAuthor: FindAuthor<Self::AccountId>;
+		/// An event handler for authored blocks.
+		type EventHandler: EventHandler<Self::AccountId, BlockNumberFor<Self>>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
+			if let Some(author) = Self::author() {
+				T::EventHandler::note_author(author);
+			}
+
+			Weight::zero()
+		}
+
+		fn on_finalize(_: BlockNumberFor<T>) {
+			// ensure we never go to trie with these values.
+			<Author<T>>::kill();
+		}
+	}
+
+	#[pallet::storage]
+	/// Author of current block.
+	pub(super) type Author<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;
+}
+
+impl<T: Config> Pallet<T> {
+	/// Fetch the author of the block.
+	///
+	/// This is safe to invoke in `on_initialize` implementations, as well
+	/// as afterwards.
+	pub fn author() -> Option<T::AccountId> {
+		// Check the memorized storage value.
+		if let Some(author) = <Author<T>>::get() {
+			return Some(author)
+		}
+
+		let digest = <frame_system::Pallet<T>>::digest();
+		let pre_runtime_digests = digest.logs.iter().filter_map(|d| d.as_pre_runtime());
+		T::FindAuthor::find_author(pre_runtime_digests).map(|a| {
+			<Author<T>>::put(&a);
+			a
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate as pallet_authorship;
+	use codec::{Decode, Encode};
+	use frame_support::{
+		traits::{ConstU32, ConstU64},
+		ConsensusEngineId,
+	};
+	use sp_core::H256;
+	use sp_runtime::{
+		generic::DigestItem,
+		testing::Header,
+		traits::{BlakeTwo256, Header as HeaderT, IdentityLookup},
+		BuildStorage,
+	};
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+			Authorship: pallet_authorship::{Pallet, Storage},
+		}
+	);
+
+	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 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 pallet::Config for Test {
+		type FindAuthor = AuthorGiven;
+		type EventHandler = ();
+	}
+
+	const TEST_ID: ConsensusEngineId = [1, 2, 3, 4];
+
+	pub struct AuthorGiven;
+
+	impl FindAuthor<u64> for AuthorGiven {
+		fn find_author<'a, I>(digests: I) -> Option<u64>
+		where
+			I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+		{
+			for (id, mut data) in digests {
+				if id == TEST_ID {
+					return u64::decode(&mut data).ok()
+				}
+			}
+
+			None
+		}
+	}
+
+	fn seal_header(mut header: Header, author: u64) -> Header {
+		{
+			let digest = header.digest_mut();
+			digest.logs.push(DigestItem::PreRuntime(TEST_ID, author.encode()));
+			digest.logs.push(DigestItem::Seal(TEST_ID, author.encode()));
+		}
+
+		header
+	}
+
+	fn create_header(number: u64, parent_hash: H256, state_root: H256) -> Header {
+		Header::new(number, Default::default(), state_root, parent_hash, Default::default())
+	}
+
+	fn new_test_ext() -> sp_io::TestExternalities {
+		let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		t.into()
+	}
+
+	#[test]
+	fn sets_author_lazily() {
+		new_test_ext().execute_with(|| {
+			let author = 42;
+			let mut header =
+				seal_header(create_header(1, Default::default(), [1; 32].into()), author);
+
+			header.digest_mut().pop(); // pop the seal off.
+			System::reset_events();
+			System::initialize(&1, &Default::default(), header.digest());
+
+			assert_eq!(Authorship::author(), Some(author));
+		});
+	}
+}
diff --git a/substrate/frame/babe/Cargo.toml b/substrate/frame/babe/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..75032fd128d101d09bced7a050dcf8ddce636e9b
--- /dev/null
+++ b/substrate/frame/babe/Cargo.toml
@@ -0,0 +1,90 @@
+[package]
+name = "pallet-babe"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Consensus extension module for BABE consensus. Collects on-chain randomness from VRF outputs and manages epoch transitions."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-authorship = { version = "4.0.0-dev", default-features = false, path = "../authorship" }
+pallet-session = { version = "4.0.0-dev", default-features = false, path = "../session" }
+pallet-timestamp = { version = "4.0.0-dev", default-features = false, path = "../timestamp" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto", features = ["serde"] }
+sp-consensus-babe = { version = "0.10.0-dev", default-features = false, path = "../../primitives/consensus/babe", features = ["serde"] }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core", features = ["serde"] }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../primitives/session" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-offences = { version = "4.0.0-dev", path = "../offences" }
+pallet-staking = { version = "4.0.0-dev", path = "../staking" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../staking/reward-curve" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-authorship/std",
+	"pallet-balances/std",
+	"pallet-offences/std",
+	"pallet-session/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-application-crypto/std",
+	"sp-consensus-babe/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-offences/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-authorship/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-offences/try-runtime",
+	"pallet-session/try-runtime",
+	"pallet-staking/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/babe/README.md b/substrate/frame/babe/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f20be89efc0cd57bcf4ab1a082f1f5198e42fa7
--- /dev/null
+++ b/substrate/frame/babe/README.md
@@ -0,0 +1,4 @@
+Consensus extension module for BABE consensus. Collects on-chain randomness
+from VRF outputs and manages epoch transitions.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/babe/src/benchmarking.rs b/substrate/frame/babe/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..92f55665913e24b8f254cf0d1610bc87c737a6e4
--- /dev/null
+++ b/substrate/frame/babe/src/benchmarking.rs
@@ -0,0 +1,74 @@
+// 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.
+
+//! Benchmarks for the BABE Pallet.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::benchmarks;
+
+type Header = sp_runtime::generic::Header<u64, sp_runtime::traits::BlakeTwo256>;
+
+benchmarks! {
+	check_equivocation_proof {
+		let x in 0 .. 1;
+
+		// NOTE: generated with the test below `test_generate_equivocation_report_blob`.
+		// the output is not deterministic since keys are generated randomly (and therefore
+		// signature content changes). it should not affect the benchmark.
+		// with the current benchmark setup it is not possible to generate this programatically
+		// from the benchmark setup.
+		const EQUIVOCATION_PROOF_BLOB: [u8; 416] = [
+			222, 241, 46, 66, 243, 228, 135, 233, 177, 64, 149, 170, 141, 92, 193, 106, 51, 73, 31,
+			27, 80, 218, 220, 248, 129, 29, 20, 128, 243, 250, 134, 39, 11, 0, 0, 0, 0, 0, 0, 0,
+			158, 4, 7, 240, 67, 153, 134, 190, 251, 196, 229, 95, 136, 165, 234, 228, 255, 18, 2,
+			187, 76, 125, 108, 50, 67, 33, 196, 108, 38, 115, 179, 86, 40, 36, 27, 5, 105, 58, 228,
+			94, 198, 65, 212, 218, 213, 61, 170, 21, 51, 249, 182, 121, 101, 91, 204, 25, 31, 87,
+			219, 208, 43, 119, 211, 185, 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 6, 66, 65, 66, 69, 52, 2, 0, 0, 0, 0, 11,
+			0, 0, 0, 0, 0, 0, 0, 5, 66, 65, 66, 69, 1, 1, 188, 192, 217, 91, 138, 78, 217, 80, 8,
+			29, 140, 55, 242, 210, 170, 184, 73, 98, 135, 212, 236, 209, 115, 52, 200, 79, 175,
+			172, 242, 161, 199, 47, 236, 93, 101, 95, 43, 34, 141, 16, 247, 220, 33, 59, 31, 197,
+			27, 7, 196, 62, 12, 238, 236, 124, 136, 191, 29, 36, 22, 238, 242, 202, 57, 139, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 40, 23, 175, 153, 83, 6, 33, 65, 123, 51, 80, 223, 126, 186, 226, 225, 240, 105, 28,
+			169, 9, 54, 11, 138, 46, 194, 201, 250, 48, 242, 125, 117, 116, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 6, 66, 65,
+			66, 69, 52, 2, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 5, 66, 65, 66, 69, 1, 1, 142, 12,
+			124, 11, 167, 227, 103, 88, 78, 23, 228, 33, 96, 41, 207, 183, 227, 189, 114, 70, 254,
+			30, 128, 243, 233, 83, 214, 45, 74, 182, 120, 119, 64, 243, 219, 119, 63, 240, 205,
+			123, 231, 82, 205, 174, 143, 70, 2, 86, 182, 20, 16, 141, 145, 91, 116, 195, 58, 223,
+			175, 145, 255, 7, 121, 133
+		];
+
+		let equivocation_proof1: sp_consensus_babe::EquivocationProof<Header> =
+			Decode::decode(&mut &EQUIVOCATION_PROOF_BLOB[..]).unwrap();
+
+		let equivocation_proof2 = equivocation_proof1.clone();
+	}: {
+		sp_consensus_babe::check_equivocation_proof::<Header>(equivocation_proof1);
+	} verify {
+		assert!(sp_consensus_babe::check_equivocation_proof::<Header>(equivocation_proof2));
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		crate::mock::new_test_ext(3),
+		crate::mock::Test,
+	)
+}
diff --git a/substrate/frame/babe/src/default_weights.rs b/substrate/frame/babe/src/default_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f7de2b28c2522b52f9a9a0c0723c613d3c80e62
--- /dev/null
+++ b/substrate/frame/babe/src/default_weights.rs
@@ -0,0 +1,54 @@
+// 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.
+
+//! Default weights for the Babe Pallet
+//! This file was not auto-generated.
+
+use frame_support::weights::{
+	constants::{RocksDbWeight as DbWeight, WEIGHT_REF_TIME_PER_MICROS, WEIGHT_REF_TIME_PER_NANOS},
+	Weight,
+};
+
+impl crate::WeightInfo for () {
+	fn plan_config_change() -> Weight {
+		DbWeight::get().writes(1)
+	}
+
+	fn report_equivocation(validator_count: u32, max_nominators_per_validator: u32) -> Weight {
+		// we take the validator set count from the membership proof to
+		// calculate the weight but we set a floor of 100 validators.
+		let validator_count = validator_count.max(100) as u64;
+
+		// checking membership proof
+		Weight::from_parts(35u64 * WEIGHT_REF_TIME_PER_MICROS, 0)
+			.saturating_add(
+				Weight::from_parts(175u64 * WEIGHT_REF_TIME_PER_NANOS, 0)
+					.saturating_mul(validator_count),
+			)
+			.saturating_add(DbWeight::get().reads(5))
+			// check equivocation proof
+			.saturating_add(Weight::from_parts(110u64 * WEIGHT_REF_TIME_PER_MICROS, 0))
+			// report offence
+			.saturating_add(Weight::from_parts(110u64 * WEIGHT_REF_TIME_PER_MICROS, 0))
+			.saturating_add(Weight::from_parts(
+				25u64 * WEIGHT_REF_TIME_PER_MICROS * max_nominators_per_validator as u64,
+				0,
+			))
+			.saturating_add(DbWeight::get().reads(14 + 3 * max_nominators_per_validator as u64))
+			.saturating_add(DbWeight::get().writes(10 + 3 * max_nominators_per_validator as u64))
+	}
+}
diff --git a/substrate/frame/babe/src/equivocation.rs b/substrate/frame/babe/src/equivocation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ed1df640583b26db4d07462618da92f324c59e4e
--- /dev/null
+++ b/substrate/frame/babe/src/equivocation.rs
@@ -0,0 +1,249 @@
+// 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.
+
+//! An opt-in utility module for reporting equivocations.
+//!
+//! This module defines an offence type for BABE equivocations
+//! and some utility traits to wire together:
+//! - a system for reporting offences;
+//! - a system for submitting unsigned transactions;
+//! - a way to get the current block author;
+//!
+//! These can be used in an offchain context in order to submit equivocation
+//! reporting extrinsics (from the client that's import BABE blocks).
+//! And in a runtime context, so that the BABE pallet can validate the
+//! equivocation proofs in the extrinsic and report the offences.
+//!
+//! IMPORTANT:
+//! When using this module for enabling equivocation reporting it is required
+//! that the `ValidateUnsigned` for the BABE pallet is used in the runtime
+//! definition.
+
+use frame_support::traits::{Get, KeyOwnerProofSystem};
+use frame_system::pallet_prelude::HeaderFor;
+use log::{error, info};
+
+use sp_consensus_babe::{AuthorityId, EquivocationProof, Slot, KEY_TYPE};
+use sp_runtime::{
+	transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
+		TransactionValidityError, ValidTransaction,
+	},
+	DispatchError, KeyTypeId, Perbill,
+};
+use sp_session::{GetSessionNumber, GetValidatorCount};
+use sp_staking::{
+	offence::{Kind, Offence, OffenceReportSystem, ReportOffence},
+	SessionIndex,
+};
+use sp_std::prelude::*;
+
+use crate::{Call, Config, Error, Pallet, LOG_TARGET};
+
+/// BABE equivocation offence report.
+///
+/// When a validator released two or more blocks at the same slot.
+pub struct EquivocationOffence<Offender> {
+	/// A babe slot in which this incident happened.
+	pub slot: Slot,
+	/// The session index in which the incident happened.
+	pub session_index: SessionIndex,
+	/// The size of the validator set at the time of the offence.
+	pub validator_set_count: u32,
+	/// The authority that produced the equivocation.
+	pub offender: Offender,
+}
+
+impl<Offender: Clone> Offence<Offender> for EquivocationOffence<Offender> {
+	const ID: Kind = *b"babe:equivocatio";
+	type TimeSlot = Slot;
+
+	fn offenders(&self) -> Vec<Offender> {
+		vec![self.offender.clone()]
+	}
+
+	fn session_index(&self) -> SessionIndex {
+		self.session_index
+	}
+
+	fn validator_set_count(&self) -> u32 {
+		self.validator_set_count
+	}
+
+	fn time_slot(&self) -> Self::TimeSlot {
+		self.slot
+	}
+
+	// The formula is min((3k / n)^2, 1)
+	// where k = offenders_number and n = validators_number
+	fn slash_fraction(&self, offenders_count: u32) -> Perbill {
+		// Perbill type domain is [0, 1] by definition
+		Perbill::from_rational(3 * offenders_count, self.validator_set_count).square()
+	}
+}
+
+/// BABE equivocation offence report system.
+///
+/// This type implements `OffenceReportSystem` such that:
+/// - Equivocation reports are published on-chain as unsigned extrinsic via
+///   `offchain::SendTransactionTypes`.
+/// - On-chain validity checks and processing are mostly delegated to the user provided generic
+///   types implementing `KeyOwnerProofSystem` and `ReportOffence` traits.
+/// - Offence reporter for unsigned transactions is fetched via the the authorship pallet.
+pub struct EquivocationReportSystem<T, R, P, L>(sp_std::marker::PhantomData<(T, R, P, L)>);
+
+impl<T, R, P, L>
+	OffenceReportSystem<Option<T::AccountId>, (EquivocationProof<HeaderFor<T>>, T::KeyOwnerProof)>
+	for EquivocationReportSystem<T, R, P, L>
+where
+	T: Config + pallet_authorship::Config + frame_system::offchain::SendTransactionTypes<Call<T>>,
+	R: ReportOffence<
+		T::AccountId,
+		P::IdentificationTuple,
+		EquivocationOffence<P::IdentificationTuple>,
+	>,
+	P: KeyOwnerProofSystem<(KeyTypeId, AuthorityId), Proof = T::KeyOwnerProof>,
+	P::IdentificationTuple: Clone,
+	L: Get<u64>,
+{
+	type Longevity = L;
+
+	fn publish_evidence(
+		evidence: (EquivocationProof<HeaderFor<T>>, T::KeyOwnerProof),
+	) -> Result<(), ()> {
+		use frame_system::offchain::SubmitTransaction;
+		let (equivocation_proof, key_owner_proof) = evidence;
+
+		let call = Call::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof),
+			key_owner_proof,
+		};
+		let res = SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into());
+		match res {
+			Ok(_) => info!(target: LOG_TARGET, "Submitted equivocation report"),
+			Err(e) => error!(target: LOG_TARGET, "Error submitting equivocation report: {:?}", e),
+		}
+		res
+	}
+
+	fn check_evidence(
+		evidence: (EquivocationProof<HeaderFor<T>>, T::KeyOwnerProof),
+	) -> Result<(), TransactionValidityError> {
+		let (equivocation_proof, key_owner_proof) = evidence;
+
+		// Check the membership proof to extract the offender's id
+		let key = (sp_consensus_babe::KEY_TYPE, equivocation_proof.offender.clone());
+		let offender =
+			P::check_proof(key, key_owner_proof.clone()).ok_or(InvalidTransaction::BadProof)?;
+
+		// Check if the offence has already been reported, and if so then we can discard the report.
+		if R::is_known_offence(&[offender], &equivocation_proof.slot) {
+			Err(InvalidTransaction::Stale.into())
+		} else {
+			Ok(())
+		}
+	}
+
+	fn process_evidence(
+		reporter: Option<T::AccountId>,
+		evidence: (EquivocationProof<HeaderFor<T>>, T::KeyOwnerProof),
+	) -> Result<(), DispatchError> {
+		let (equivocation_proof, key_owner_proof) = evidence;
+		let reporter = reporter.or_else(|| <pallet_authorship::Pallet<T>>::author());
+		let offender = equivocation_proof.offender.clone();
+		let slot = equivocation_proof.slot;
+
+		// Validate the equivocation proof (check votes are different and signatures are valid)
+		if !sp_consensus_babe::check_equivocation_proof(equivocation_proof) {
+			return Err(Error::<T>::InvalidEquivocationProof.into())
+		}
+
+		let validator_set_count = key_owner_proof.validator_count();
+		let session_index = key_owner_proof.session();
+
+		let epoch_index =
+			*slot.saturating_sub(crate::GenesisSlot::<T>::get()) / T::EpochDuration::get();
+
+		// Check that the slot number is consistent with the session index
+		// in the key ownership proof (i.e. slot is for that epoch)
+		if Pallet::<T>::session_index_for_epoch(epoch_index) != session_index {
+			return Err(Error::<T>::InvalidKeyOwnershipProof.into())
+		}
+
+		// Check the membership proof and extract the offender's id
+		let offender = P::check_proof((KEY_TYPE, offender), key_owner_proof)
+			.ok_or(Error::<T>::InvalidKeyOwnershipProof)?;
+
+		let offence = EquivocationOffence { slot, validator_set_count, offender, session_index };
+
+		R::report_offence(reporter.into_iter().collect(), offence)
+			.map_err(|_| Error::<T>::DuplicateOffenceReport)?;
+
+		Ok(())
+	}
+}
+
+/// Methods for the `ValidateUnsigned` implementation:
+/// It restricts calls to `report_equivocation_unsigned` to local calls (i.e. extrinsics generated
+/// on this node) or that already in a block. This guarantees that only block authors can include
+/// unsigned equivocation reports.
+impl<T: Config> Pallet<T> {
+	pub fn validate_unsigned(source: TransactionSource, call: &Call<T>) -> TransactionValidity {
+		if let Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } = call {
+			// discard equivocation report not coming from the local node
+			match source {
+				TransactionSource::Local | TransactionSource::InBlock => { /* allowed */ },
+				_ => {
+					log::warn!(
+						target: LOG_TARGET,
+						"rejecting unsigned report equivocation transaction because it is not local/in-block.",
+					);
+
+					return InvalidTransaction::Call.into()
+				},
+			}
+
+			// Check report validity
+			let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
+			T::EquivocationReportSystem::check_evidence(evidence)?;
+
+			let longevity =
+				<T::EquivocationReportSystem as OffenceReportSystem<_, _>>::Longevity::get();
+
+			ValidTransaction::with_tag_prefix("BabeEquivocation")
+				// We assign the maximum priority for any equivocation report.
+				.priority(TransactionPriority::max_value())
+				// Only one equivocation report for the same offender at the same slot.
+				.and_provides((equivocation_proof.offender.clone(), *equivocation_proof.slot))
+				.longevity(longevity)
+				// We don't propagate this. This can never be included on a remote node.
+				.propagate(false)
+				.build()
+		} else {
+			InvalidTransaction::Call.into()
+		}
+	}
+
+	pub fn pre_dispatch(call: &Call<T>) -> Result<(), TransactionValidityError> {
+		if let Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } = call {
+			let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
+			T::EquivocationReportSystem::check_evidence(evidence)
+		} else {
+			Err(InvalidTransaction::Call.into())
+		}
+	}
+}
diff --git a/substrate/frame/babe/src/lib.rs b/substrate/frame/babe/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9549fac9fe2b629ce3968b80c8d2e424ae252dd5
--- /dev/null
+++ b/substrate/frame/babe/src/lib.rs
@@ -0,0 +1,1061 @@
+// 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.
+
+//! Consensus extension module for BABE consensus. Collects on-chain randomness
+//! from VRF outputs and manages epoch transitions.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![warn(unused_must_use, unsafe_code, unused_variables, unused_must_use)]
+
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{DispatchResultWithPostInfo, Pays},
+	ensure,
+	traits::{ConstU32, DisabledValidators, FindAuthor, Get, OnTimestampSet, OneSessionHandler},
+	weights::Weight,
+	BoundedVec, WeakBoundedVec,
+};
+use frame_system::pallet_prelude::{BlockNumberFor, HeaderFor};
+use sp_consensus_babe::{
+	digests::{NextConfigDescriptor, NextEpochDescriptor, PreDigest},
+	AllowedSlots, BabeAuthorityWeight, BabeEpochConfiguration, ConsensusLog, Epoch,
+	EquivocationProof, Randomness as BabeRandomness, Slot, BABE_ENGINE_ID, RANDOMNESS_LENGTH,
+	RANDOMNESS_VRF_CONTEXT,
+};
+use sp_core::crypto::Wraps;
+use sp_runtime::{
+	generic::DigestItem,
+	traits::{IsMember, One, SaturatedConversion, Saturating, Zero},
+	ConsensusEngineId, Permill,
+};
+use sp_session::{GetSessionNumber, GetValidatorCount};
+use sp_staking::{offence::OffenceReportSystem, SessionIndex};
+use sp_std::prelude::*;
+
+pub use sp_consensus_babe::AuthorityId;
+
+const LOG_TARGET: &str = "runtime::babe";
+
+mod default_weights;
+mod equivocation;
+mod randomness;
+
+#[cfg(any(feature = "runtime-benchmarks", test))]
+mod benchmarking;
+#[cfg(all(feature = "std", test))]
+mod mock;
+#[cfg(all(feature = "std", test))]
+mod tests;
+
+pub use equivocation::{EquivocationOffence, EquivocationReportSystem};
+#[allow(deprecated)]
+pub use randomness::CurrentBlockRandomness;
+pub use randomness::{
+	ParentBlockRandomness, RandomnessFromOneEpochAgo, RandomnessFromTwoEpochsAgo,
+};
+
+pub use pallet::*;
+
+pub trait WeightInfo {
+	fn plan_config_change() -> Weight;
+	fn report_equivocation(validator_count: u32, max_nominators_per_validator: u32) -> Weight;
+}
+
+/// Trigger an epoch change, if any should take place.
+pub trait EpochChangeTrigger {
+	/// Trigger an epoch change, if any should take place. This should be called
+	/// during every block, after initialization is done.
+	fn trigger<T: Config>(now: BlockNumberFor<T>);
+}
+
+/// A type signifying to BABE that an external trigger
+/// for epoch changes (e.g. pallet-session) is used.
+pub struct ExternalTrigger;
+
+impl EpochChangeTrigger for ExternalTrigger {
+	fn trigger<T: Config>(_: BlockNumberFor<T>) {} // nothing - trigger is external.
+}
+
+/// A type signifying to BABE that it should perform epoch changes
+/// with an internal trigger, recycling the same authorities forever.
+pub struct SameAuthoritiesForever;
+
+impl EpochChangeTrigger for SameAuthoritiesForever {
+	fn trigger<T: Config>(now: BlockNumberFor<T>) {
+		if <Pallet<T>>::should_epoch_change(now) {
+			let authorities = <Pallet<T>>::authorities();
+			let next_authorities = authorities.clone();
+
+			<Pallet<T>>::enact_epoch_change(authorities, next_authorities, None);
+		}
+	}
+}
+
+const UNDER_CONSTRUCTION_SEGMENT_LENGTH: u32 = 256;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The BABE Pallet
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	#[pallet::disable_frame_system_supertrait_check]
+	pub trait Config: pallet_timestamp::Config {
+		/// The amount of time, in slots, that each epoch should last.
+		/// NOTE: Currently it is not possible to change the epoch duration after
+		/// the chain has started. Attempting to do so will brick block production.
+		#[pallet::constant]
+		type EpochDuration: Get<u64>;
+
+		/// The expected average block time at which BABE should be creating
+		/// blocks. Since BABE is probabilistic it is not trivial to figure out
+		/// what the expected average block time should be based on the slot
+		/// duration and the security parameter `c` (where `1 - c` represents
+		/// the probability of a slot being empty).
+		#[pallet::constant]
+		type ExpectedBlockTime: Get<Self::Moment>;
+
+		/// BABE requires some logic to be triggered on every block to query for whether an epoch
+		/// has ended and to perform the transition to the next epoch.
+		///
+		/// Typically, the `ExternalTrigger` type should be used. An internal trigger should only be
+		/// used when no other module is responsible for changing authority set.
+		type EpochChangeTrigger: EpochChangeTrigger;
+
+		/// A way to check whether a given validator is disabled and should not be authoring blocks.
+		/// Blocks authored by a disabled validator will lead to a panic as part of this module's
+		/// initialization.
+		type DisabledValidators: DisabledValidators;
+
+		/// Helper for weights computations
+		type WeightInfo: WeightInfo;
+
+		/// Max number of authorities allowed
+		#[pallet::constant]
+		type MaxAuthorities: Get<u32>;
+
+		/// The maximum number of nominators for each validator.
+		#[pallet::constant]
+		type MaxNominators: Get<u32>;
+
+		/// The proof of key ownership, used for validating equivocation reports.
+		/// The proof must include the session index and validator count of the
+		/// session at which the equivocation occurred.
+		type KeyOwnerProof: Parameter + GetSessionNumber + GetValidatorCount;
+
+		/// The equivocation handling subsystem, defines methods to check/report an
+		/// offence and for submitting a transaction to report an equivocation
+		/// (from an offchain context).
+		type EquivocationReportSystem: OffenceReportSystem<
+			Option<Self::AccountId>,
+			(EquivocationProof<HeaderFor<Self>>, Self::KeyOwnerProof),
+		>;
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// An equivocation proof provided as part of an equivocation report is invalid.
+		InvalidEquivocationProof,
+		/// A key ownership proof provided as part of an equivocation report is invalid.
+		InvalidKeyOwnershipProof,
+		/// A given equivocation report is valid but already previously reported.
+		DuplicateOffenceReport,
+		/// Submitted configuration is invalid.
+		InvalidConfiguration,
+	}
+
+	/// Current epoch index.
+	#[pallet::storage]
+	#[pallet::getter(fn epoch_index)]
+	pub type EpochIndex<T> = StorageValue<_, u64, ValueQuery>;
+
+	/// Current epoch authorities.
+	#[pallet::storage]
+	#[pallet::getter(fn authorities)]
+	pub type Authorities<T: Config> = StorageValue<
+		_,
+		WeakBoundedVec<(AuthorityId, BabeAuthorityWeight), T::MaxAuthorities>,
+		ValueQuery,
+	>;
+
+	/// The slot at which the first epoch actually started. This is 0
+	/// until the first block of the chain.
+	#[pallet::storage]
+	#[pallet::getter(fn genesis_slot)]
+	pub type GenesisSlot<T> = StorageValue<_, Slot, ValueQuery>;
+
+	/// Current slot number.
+	#[pallet::storage]
+	#[pallet::getter(fn current_slot)]
+	pub type CurrentSlot<T> = StorageValue<_, Slot, ValueQuery>;
+
+	/// The epoch randomness for the *current* epoch.
+	///
+	/// # Security
+	///
+	/// This MUST NOT be used for gambling, as it can be influenced by a
+	/// malicious validator in the short term. It MAY be used in many
+	/// cryptographic protocols, however, so long as one remembers that this
+	/// (like everything else on-chain) it is public. For example, it can be
+	/// used where a number is needed that cannot have been chosen by an
+	/// adversary, for purposes such as public-coin zero-knowledge proofs.
+	// NOTE: the following fields don't use the constants to define the
+	// array size because the metadata API currently doesn't resolve the
+	// variable to its underlying value.
+	#[pallet::storage]
+	#[pallet::getter(fn randomness)]
+	pub type Randomness<T> = StorageValue<_, BabeRandomness, ValueQuery>;
+
+	/// Pending epoch configuration change that will be applied when the next epoch is enacted.
+	#[pallet::storage]
+	pub(super) type PendingEpochConfigChange<T> = StorageValue<_, NextConfigDescriptor>;
+
+	/// Next epoch randomness.
+	#[pallet::storage]
+	pub(super) type NextRandomness<T> = StorageValue<_, BabeRandomness, ValueQuery>;
+
+	/// Next epoch authorities.
+	#[pallet::storage]
+	pub(super) type NextAuthorities<T: Config> = StorageValue<
+		_,
+		WeakBoundedVec<(AuthorityId, BabeAuthorityWeight), T::MaxAuthorities>,
+		ValueQuery,
+	>;
+
+	/// Randomness under construction.
+	///
+	/// We make a trade-off between storage accesses and list length.
+	/// We store the under-construction randomness in segments of up to
+	/// `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.
+	///
+	/// Once a segment reaches this length, we begin the next one.
+	/// We reset all segments and return to `0` at the beginning of every
+	/// epoch.
+	#[pallet::storage]
+	pub(super) type SegmentIndex<T> = StorageValue<_, u32, ValueQuery>;
+
+	/// TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
+	#[pallet::storage]
+	pub(super) type UnderConstruction<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		u32,
+		BoundedVec<BabeRandomness, ConstU32<UNDER_CONSTRUCTION_SEGMENT_LENGTH>>,
+		ValueQuery,
+	>;
+
+	/// Temporary value (cleared at block finalization) which is `Some`
+	/// if per-block initialization has already been called for current block.
+	#[pallet::storage]
+	#[pallet::getter(fn initialized)]
+	pub(super) type Initialized<T> = StorageValue<_, Option<PreDigest>>;
+
+	/// This field should always be populated during block processing unless
+	/// secondary plain slots are enabled (which don't contain a VRF output).
+	///
+	/// It is set in `on_finalize`, before it will contain the value from the last block.
+	#[pallet::storage]
+	#[pallet::getter(fn author_vrf_randomness)]
+	pub(super) type AuthorVrfRandomness<T> = StorageValue<_, Option<BabeRandomness>, ValueQuery>;
+
+	/// The block numbers when the last and current epoch have started, respectively `N-1` and
+	/// `N`.
+	/// NOTE: We track this is in order to annotate the block number when a given pool of
+	/// entropy was fixed (i.e. it was known to chain observers). Since epochs are defined in
+	/// slots, which may be skipped, the block numbers may not line up with the slot numbers.
+	#[pallet::storage]
+	pub(super) type EpochStart<T: Config> =
+		StorageValue<_, (BlockNumberFor<T>, BlockNumberFor<T>), ValueQuery>;
+
+	/// How late the current block is compared to its parent.
+	///
+	/// This entry is populated as part of block execution and is cleaned up
+	/// on block finalization. Querying this storage entry outside of block
+	/// execution context should always yield zero.
+	#[pallet::storage]
+	#[pallet::getter(fn lateness)]
+	pub(super) type Lateness<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;
+
+	/// The configuration for the current epoch. Should never be `None` as it is initialized in
+	/// genesis.
+	#[pallet::storage]
+	#[pallet::getter(fn epoch_config)]
+	pub(super) type EpochConfig<T> = StorageValue<_, BabeEpochConfiguration>;
+
+	/// The configuration for the next epoch, `None` if the config will not change
+	/// (you can fallback to `EpochConfig` instead in that case).
+	#[pallet::storage]
+	pub(super) type NextEpochConfig<T> = StorageValue<_, BabeEpochConfiguration>;
+
+	/// A list of the last 100 skipped epochs and the corresponding session index
+	/// when the epoch was skipped.
+	///
+	/// This is only used for validating equivocation proofs. An equivocation proof
+	/// must contains a key-ownership proof for a given session, therefore we need a
+	/// way to tie together sessions and epoch indices, i.e. we need to validate that
+	/// a validator was the owner of a given key on a given session, and what the
+	/// active epoch index was during that session.
+	#[pallet::storage]
+	#[pallet::getter(fn skipped_epochs)]
+	pub(super) type SkippedEpochs<T> =
+		StorageValue<_, BoundedVec<(u64, SessionIndex), ConstU32<100>>, ValueQuery>;
+
+	#[derive(frame_support::DefaultNoBound)]
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+		pub epoch_config: Option<BabeEpochConfiguration>,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			SegmentIndex::<T>::put(0);
+			Pallet::<T>::initialize_genesis_authorities(&self.authorities);
+			EpochConfig::<T>::put(
+				self.epoch_config.clone().expect("epoch_config must not be None"),
+			);
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// Initialization
+		fn on_initialize(now: BlockNumberFor<T>) -> Weight {
+			Self::initialize(now);
+			Weight::zero()
+		}
+
+		/// Block finalization
+		fn on_finalize(_now: BlockNumberFor<T>) {
+			// at the end of the block, we can safely include the new VRF output
+			// from this block into the under-construction randomness. If we've determined
+			// that this block was the first in a new epoch, the changeover logic has
+			// already occurred at this point, so the under-construction randomness
+			// will only contain outputs from the right epoch.
+			if let Some(pre_digest) = Initialized::<T>::take().flatten() {
+				let authority_index = pre_digest.authority_index();
+
+				if T::DisabledValidators::is_disabled(authority_index) {
+					panic!(
+						"Validator with index {:?} is disabled and should not be attempting to author blocks.",
+						authority_index,
+					);
+				}
+
+				if let Some(signature) = pre_digest.vrf_signature() {
+					let randomness: Option<BabeRandomness> = Authorities::<T>::get()
+						.get(authority_index as usize)
+						.and_then(|(authority, _)| {
+							let public = authority.as_inner_ref();
+							let transcript = sp_consensus_babe::make_vrf_transcript(
+								&Self::randomness(),
+								CurrentSlot::<T>::get(),
+								EpochIndex::<T>::get(),
+							);
+
+							// NOTE: this is verified by the client when importing the block, before
+							// execution. We don't run the verification again here to avoid slowing
+							// down the runtime.
+							debug_assert!({
+								use sp_core::crypto::VrfPublic;
+								public.vrf_verify(&transcript.clone().into_sign_data(), &signature)
+							});
+
+							public
+								.make_bytes(RANDOMNESS_VRF_CONTEXT, &transcript, &signature.output)
+								.ok()
+						});
+
+					if let Some(randomness) = pre_digest.is_primary().then(|| randomness).flatten()
+					{
+						Self::deposit_randomness(&randomness);
+					}
+
+					AuthorVrfRandomness::<T>::put(randomness);
+				}
+			}
+
+			// remove temporary "environment" entry from storage
+			Lateness::<T>::kill();
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Report authority equivocation/misbehavior. This method will verify
+		/// the equivocation proof and validate the given key ownership proof
+		/// against the extracted offender. If both are valid, the offence will
+		/// be reported.
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config>::WeightInfo::report_equivocation(
+			key_owner_proof.validator_count(),
+			T::MaxNominators::get(),
+		))]
+		pub fn report_equivocation(
+			origin: OriginFor<T>,
+			equivocation_proof: Box<EquivocationProof<HeaderFor<T>>>,
+			key_owner_proof: T::KeyOwnerProof,
+		) -> DispatchResultWithPostInfo {
+			let reporter = ensure_signed(origin)?;
+			T::EquivocationReportSystem::process_evidence(
+				Some(reporter),
+				(*equivocation_proof, key_owner_proof),
+			)?;
+			// Waive the fee since the report is valid and beneficial
+			Ok(Pays::No.into())
+		}
+
+		/// Report authority equivocation/misbehavior. This method will verify
+		/// the equivocation proof and validate the given key ownership proof
+		/// against the extracted offender. If both are valid, the offence will
+		/// be reported.
+		/// This extrinsic must be called unsigned and it is expected that only
+		/// block authors will call it (validated in `ValidateUnsigned`), as such
+		/// if the block author is defined it will be defined as the equivocation
+		/// reporter.
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as Config>::WeightInfo::report_equivocation(
+			key_owner_proof.validator_count(),
+			T::MaxNominators::get(),
+		))]
+		pub fn report_equivocation_unsigned(
+			origin: OriginFor<T>,
+			equivocation_proof: Box<EquivocationProof<HeaderFor<T>>>,
+			key_owner_proof: T::KeyOwnerProof,
+		) -> DispatchResultWithPostInfo {
+			ensure_none(origin)?;
+			T::EquivocationReportSystem::process_evidence(
+				None,
+				(*equivocation_proof, key_owner_proof),
+			)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Plan an epoch config change. The epoch config change is recorded and will be enacted on
+		/// the next call to `enact_epoch_change`. The config will be activated one epoch after.
+		/// Multiple calls to this method will replace any existing planned config change that had
+		/// not been enacted yet.
+		#[pallet::call_index(2)]
+		#[pallet::weight(<T as Config>::WeightInfo::plan_config_change())]
+		pub fn plan_config_change(
+			origin: OriginFor<T>,
+			config: NextConfigDescriptor,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			match config {
+				NextConfigDescriptor::V1 { c, allowed_slots } => {
+					ensure!(
+						(c.0 != 0 || allowed_slots != AllowedSlots::PrimarySlots) && c.1 != 0,
+						Error::<T>::InvalidConfiguration
+					);
+				},
+			}
+			PendingEpochConfigChange::<T>::put(config);
+			Ok(())
+		}
+	}
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+		fn validate_unsigned(source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			Self::validate_unsigned(source, call)
+		}
+
+		fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError> {
+			Self::pre_dispatch(call)
+		}
+	}
+}
+
+impl<T: Config> FindAuthor<u32> for Pallet<T> {
+	fn find_author<'a, I>(digests: I) -> Option<u32>
+	where
+		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+	{
+		for (id, mut data) in digests.into_iter() {
+			if id == BABE_ENGINE_ID {
+				let pre_digest: PreDigest = PreDigest::decode(&mut data).ok()?;
+				return Some(pre_digest.authority_index())
+			}
+		}
+
+		None
+	}
+}
+
+impl<T: Config> IsMember<AuthorityId> for Pallet<T> {
+	fn is_member(authority_id: &AuthorityId) -> bool {
+		<Pallet<T>>::authorities().iter().any(|id| &id.0 == authority_id)
+	}
+}
+
+impl<T: Config> pallet_session::ShouldEndSession<BlockNumberFor<T>> for Pallet<T> {
+	fn should_end_session(now: BlockNumberFor<T>) -> bool {
+		// it might be (and it is in current implementation) that session module is calling
+		// `should_end_session` from it's own `on_initialize` handler, in which case it's
+		// possible that babe's own `on_initialize` has not run yet, so let's ensure that we
+		// have initialized the pallet and updated the current slot.
+		Self::initialize(now);
+		Self::should_epoch_change(now)
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Determine the BABE slot duration based on the Timestamp module configuration.
+	pub fn slot_duration() -> T::Moment {
+		// we double the minimum block-period so each author can always propose within
+		// the majority of their slot.
+		<T as pallet_timestamp::Config>::MinimumPeriod::get().saturating_mul(2u32.into())
+	}
+
+	/// Determine whether an epoch change should take place at this block.
+	/// Assumes that initialization has already taken place.
+	pub fn should_epoch_change(now: BlockNumberFor<T>) -> bool {
+		// The epoch has technically ended during the passage of time
+		// between this block and the last, but we have to "end" the epoch now,
+		// since there is no earlier possible block we could have done it.
+		//
+		// The exception is for block 1: the genesis has slot 0, so we treat
+		// epoch 0 as having started at the slot of block 1. We want to use
+		// the same randomness and validator set as signalled in the genesis,
+		// so we don't rotate the epoch.
+		now != One::one() && {
+			let diff = CurrentSlot::<T>::get().saturating_sub(Self::current_epoch_start());
+			*diff >= T::EpochDuration::get()
+		}
+	}
+
+	/// Return the _best guess_ block number, at which the next epoch change is predicted to happen.
+	///
+	/// Returns None if the prediction is in the past; This implies an error internally in the Babe
+	/// and should not happen under normal circumstances.
+	///
+	/// In other word, this is only accurate if no slots are missed. Given missed slots, the slot
+	/// number will grow while the block number will not. Hence, the result can be interpreted as an
+	/// upper bound.
+	// ## IMPORTANT NOTE
+	//
+	// This implementation is linked to how [`should_epoch_change`] is working. This might need to
+	// be updated accordingly, if the underlying mechanics of slot and epochs change.
+	//
+	// WEIGHT NOTE: This function is tied to the weight of `EstimateNextSessionRotation`. If you
+	// update this function, you must also update the corresponding weight.
+	pub fn next_expected_epoch_change(now: BlockNumberFor<T>) -> Option<BlockNumberFor<T>> {
+		let next_slot = Self::current_epoch_start().saturating_add(T::EpochDuration::get());
+		next_slot.checked_sub(*CurrentSlot::<T>::get()).map(|slots_remaining| {
+			// This is a best effort guess. Drifts in the slot/block ratio will cause errors here.
+			let blocks_remaining: BlockNumberFor<T> = slots_remaining.saturated_into();
+			now.saturating_add(blocks_remaining)
+		})
+	}
+
+	/// DANGEROUS: Enact an epoch change. Should be done on every block where `should_epoch_change`
+	/// has returned `true`, and the caller is the only caller of this function.
+	///
+	/// Typically, this is not handled directly by the user, but by higher-level validator-set
+	/// manager logic like `pallet-session`.
+	///
+	/// This doesn't do anything if `authorities` is empty.
+	pub fn enact_epoch_change(
+		authorities: WeakBoundedVec<(AuthorityId, BabeAuthorityWeight), T::MaxAuthorities>,
+		next_authorities: WeakBoundedVec<(AuthorityId, BabeAuthorityWeight), T::MaxAuthorities>,
+		session_index: Option<SessionIndex>,
+	) {
+		// PRECONDITION: caller has done initialization and is guaranteed
+		// by the session module to be called before this.
+		debug_assert!(Self::initialized().is_some());
+
+		if authorities.is_empty() {
+			log::warn!(target: LOG_TARGET, "Ignoring empty epoch change.");
+
+			return
+		}
+
+		// Update epoch index.
+		//
+		// NOTE: we figure out the epoch index from the slot, which may not
+		// necessarily be contiguous if the chain was offline for more than
+		// `T::EpochDuration` slots. When skipping from epoch N to e.g. N+4, we
+		// will be using the randomness and authorities for that epoch that had
+		// been previously announced for epoch N+1, and the randomness collected
+		// during the current epoch (N) will be used for epoch N+5.
+		let epoch_index = sp_consensus_babe::epoch_index(
+			CurrentSlot::<T>::get(),
+			GenesisSlot::<T>::get(),
+			T::EpochDuration::get(),
+		);
+
+		let current_epoch_index = EpochIndex::<T>::get();
+		if current_epoch_index.saturating_add(1) != epoch_index {
+			// we are skipping epochs therefore we need to update the mapping
+			// of epochs to session
+			if let Some(session_index) = session_index {
+				SkippedEpochs::<T>::mutate(|skipped_epochs| {
+					if epoch_index < session_index as u64 {
+						log::warn!(
+							target: LOG_TARGET,
+							"Current epoch index {} is lower than session index {}.",
+							epoch_index,
+							session_index,
+						);
+
+						return
+					}
+
+					if skipped_epochs.is_full() {
+						// NOTE: this is O(n) but we currently don't have a bounded `VecDeque`.
+						// this vector is bounded to a small number of elements so performance
+						// shouldn't be an issue.
+						skipped_epochs.remove(0);
+					}
+
+					skipped_epochs.force_push((epoch_index, session_index));
+				})
+			}
+		}
+
+		EpochIndex::<T>::put(epoch_index);
+		Authorities::<T>::put(authorities);
+
+		// Update epoch randomness.
+		let next_epoch_index = epoch_index
+			.checked_add(1)
+			.expect("epoch indices will never reach 2^64 before the death of the universe; qed");
+
+		// Returns randomness for the current epoch and computes the *next*
+		// epoch randomness.
+		let randomness = Self::randomness_change_epoch(next_epoch_index);
+		Randomness::<T>::put(randomness);
+
+		// Update the next epoch authorities.
+		NextAuthorities::<T>::put(&next_authorities);
+
+		// Update the start blocks of the previous and new current epoch.
+		<EpochStart<T>>::mutate(|(previous_epoch_start_block, current_epoch_start_block)| {
+			*previous_epoch_start_block = sp_std::mem::take(current_epoch_start_block);
+			*current_epoch_start_block = <frame_system::Pallet<T>>::block_number();
+		});
+
+		// After we update the current epoch, we signal the *next* epoch change
+		// so that nodes can track changes.
+		let next_randomness = NextRandomness::<T>::get();
+
+		let next_epoch = NextEpochDescriptor {
+			authorities: next_authorities.to_vec(),
+			randomness: next_randomness,
+		};
+		Self::deposit_consensus(ConsensusLog::NextEpochData(next_epoch));
+
+		if let Some(next_config) = NextEpochConfig::<T>::get() {
+			EpochConfig::<T>::put(next_config);
+		}
+
+		if let Some(pending_epoch_config_change) = PendingEpochConfigChange::<T>::take() {
+			let next_epoch_config: BabeEpochConfiguration =
+				pending_epoch_config_change.clone().into();
+			NextEpochConfig::<T>::put(next_epoch_config);
+
+			Self::deposit_consensus(ConsensusLog::NextConfigData(pending_epoch_config_change));
+		}
+	}
+
+	/// Finds the start slot of the current epoch.
+	///
+	/// Only guaranteed to give correct results after `initialize` of the first
+	/// block in the chain (as its result is based off of `GenesisSlot`).
+	pub fn current_epoch_start() -> Slot {
+		sp_consensus_babe::epoch_start_slot(
+			EpochIndex::<T>::get(),
+			GenesisSlot::<T>::get(),
+			T::EpochDuration::get(),
+		)
+	}
+
+	/// Produces information about the current epoch.
+	pub fn current_epoch() -> Epoch {
+		Epoch {
+			epoch_index: EpochIndex::<T>::get(),
+			start_slot: Self::current_epoch_start(),
+			duration: T::EpochDuration::get(),
+			authorities: Self::authorities().to_vec(),
+			randomness: Self::randomness(),
+			config: EpochConfig::<T>::get()
+				.expect("EpochConfig is initialized in genesis; we never `take` or `kill` it; qed"),
+		}
+	}
+
+	/// Produces information about the next epoch (which was already previously
+	/// announced).
+	pub fn next_epoch() -> Epoch {
+		let next_epoch_index = EpochIndex::<T>::get().checked_add(1).expect(
+			"epoch index is u64; it is always only incremented by one; \
+			 if u64 is not enough we should crash for safety; qed.",
+		);
+
+		let start_slot = sp_consensus_babe::epoch_start_slot(
+			next_epoch_index,
+			GenesisSlot::<T>::get(),
+			T::EpochDuration::get(),
+		);
+
+		Epoch {
+			epoch_index: next_epoch_index,
+			start_slot,
+			duration: T::EpochDuration::get(),
+			authorities: NextAuthorities::<T>::get().to_vec(),
+			randomness: NextRandomness::<T>::get(),
+			config: NextEpochConfig::<T>::get().unwrap_or_else(|| {
+				EpochConfig::<T>::get().expect(
+					"EpochConfig is initialized in genesis; we never `take` or `kill` it; qed",
+				)
+			}),
+		}
+	}
+
+	fn deposit_consensus<U: Encode>(new: U) {
+		let log = DigestItem::Consensus(BABE_ENGINE_ID, new.encode());
+		<frame_system::Pallet<T>>::deposit_log(log)
+	}
+
+	fn deposit_randomness(randomness: &BabeRandomness) {
+		let segment_idx = SegmentIndex::<T>::get();
+		let mut segment = UnderConstruction::<T>::get(&segment_idx);
+		if segment.try_push(*randomness).is_ok() {
+			// push onto current segment: not full.
+			UnderConstruction::<T>::insert(&segment_idx, &segment);
+		} else {
+			// move onto the next segment and update the index.
+			let segment_idx = segment_idx + 1;
+			let bounded_randomness =
+				BoundedVec::<_, ConstU32<UNDER_CONSTRUCTION_SEGMENT_LENGTH>>::try_from(vec![
+					*randomness,
+				])
+				.expect("UNDER_CONSTRUCTION_SEGMENT_LENGTH >= 1");
+			UnderConstruction::<T>::insert(&segment_idx, bounded_randomness);
+			SegmentIndex::<T>::put(&segment_idx);
+		}
+	}
+
+	fn initialize_genesis_authorities(authorities: &[(AuthorityId, BabeAuthorityWeight)]) {
+		if !authorities.is_empty() {
+			assert!(Authorities::<T>::get().is_empty(), "Authorities are already initialized!");
+			let bounded_authorities =
+				WeakBoundedVec::<_, T::MaxAuthorities>::try_from(authorities.to_vec())
+					.expect("Initial number of authorities should be lower than T::MaxAuthorities");
+			Authorities::<T>::put(&bounded_authorities);
+			NextAuthorities::<T>::put(&bounded_authorities);
+		}
+	}
+
+	fn initialize_genesis_epoch(genesis_slot: Slot) {
+		GenesisSlot::<T>::put(genesis_slot);
+		debug_assert_ne!(*GenesisSlot::<T>::get(), 0);
+
+		// deposit a log because this is the first block in epoch #0
+		// we use the same values as genesis because we haven't collected any
+		// randomness yet.
+		let next = NextEpochDescriptor {
+			authorities: Self::authorities().to_vec(),
+			randomness: Self::randomness(),
+		};
+
+		Self::deposit_consensus(ConsensusLog::NextEpochData(next));
+	}
+
+	fn initialize(now: BlockNumberFor<T>) {
+		// since `initialize` can be called twice (e.g. if session module is present)
+		// let's ensure that we only do the initialization once per block
+		let initialized = Self::initialized().is_some();
+		if initialized {
+			return
+		}
+
+		let pre_digest =
+			<frame_system::Pallet<T>>::digest()
+				.logs
+				.iter()
+				.filter_map(|s| s.as_pre_runtime())
+				.filter_map(|(id, mut data)| {
+					if id == BABE_ENGINE_ID {
+						PreDigest::decode(&mut data).ok()
+					} else {
+						None
+					}
+				})
+				.next();
+
+		if let Some(ref pre_digest) = pre_digest {
+			// the slot number of the current block being initialized
+			let current_slot = pre_digest.slot();
+
+			// on the first non-zero block (i.e. block #1)
+			// this is where the first epoch (epoch #0) actually starts.
+			// we need to adjust internal storage accordingly.
+			if *GenesisSlot::<T>::get() == 0 {
+				Self::initialize_genesis_epoch(current_slot)
+			}
+
+			// how many slots were skipped between current and last block
+			let lateness = current_slot.saturating_sub(CurrentSlot::<T>::get() + 1);
+			let lateness = BlockNumberFor::<T>::from(*lateness as u32);
+
+			Lateness::<T>::put(lateness);
+			CurrentSlot::<T>::put(current_slot);
+		}
+
+		Initialized::<T>::put(pre_digest);
+
+		// enact epoch change, if necessary.
+		T::EpochChangeTrigger::trigger::<T>(now);
+	}
+
+	/// Call this function exactly once when an epoch changes, to update the
+	/// randomness. Returns the new randomness.
+	fn randomness_change_epoch(next_epoch_index: u64) -> BabeRandomness {
+		let this_randomness = NextRandomness::<T>::get();
+		let segment_idx: u32 = SegmentIndex::<T>::mutate(|s| sp_std::mem::replace(s, 0));
+
+		// overestimate to the segment being full.
+		let rho_size = (segment_idx.saturating_add(1) * UNDER_CONSTRUCTION_SEGMENT_LENGTH) as usize;
+
+		let next_randomness = compute_randomness(
+			this_randomness,
+			next_epoch_index,
+			(0..segment_idx).flat_map(|i| UnderConstruction::<T>::take(&i)),
+			Some(rho_size),
+		);
+		NextRandomness::<T>::put(&next_randomness);
+		this_randomness
+	}
+
+	/// Returns the session index that was live when the given epoch happened,
+	/// taking into account any skipped epochs.
+	///
+	/// This function is only well defined for epochs that actually existed,
+	/// e.g. if we skipped from epoch 10 to 20 then a call for epoch 15 (which
+	/// didn't exist) will return an incorrect session index.
+	pub(crate) fn session_index_for_epoch(epoch_index: u64) -> SessionIndex {
+		let skipped_epochs = SkippedEpochs::<T>::get();
+		match skipped_epochs.binary_search_by_key(&epoch_index, |(epoch_index, _)| *epoch_index) {
+			// we have an exact match so we just return the given session index
+			Ok(index) => skipped_epochs[index].1,
+			// we haven't found any skipped epoch before the given epoch,
+			// so the epoch index and session index should match
+			Err(0) => epoch_index.saturated_into::<u32>(),
+			// we have found a skipped epoch before the given epoch
+			Err(index) => {
+				// the element before the given index should give us the skipped epoch
+				// that's closest to the one we're trying to find the session index for
+				let closest_skipped_epoch = skipped_epochs[index - 1];
+
+				// calculate the number of skipped epochs at this point by checking the difference
+				// between the epoch and session indices. epoch index should always be greater or
+				// equal to session index, this is because epochs can be skipped whereas sessions
+				// can't (this is enforced when pushing into `SkippedEpochs`)
+				let skipped_epochs = closest_skipped_epoch.0 - closest_skipped_epoch.1 as u64;
+				epoch_index.saturating_sub(skipped_epochs).saturated_into::<u32>()
+			},
+		}
+	}
+
+	/// Submits an extrinsic to report an equivocation. This method will create
+	/// an unsigned extrinsic with a call to `report_equivocation_unsigned` and
+	/// will push the transaction to the pool. Only useful in an offchain
+	/// context.
+	pub fn submit_unsigned_equivocation_report(
+		equivocation_proof: EquivocationProof<HeaderFor<T>>,
+		key_owner_proof: T::KeyOwnerProof,
+	) -> Option<()> {
+		T::EquivocationReportSystem::publish_evidence((equivocation_proof, key_owner_proof)).ok()
+	}
+}
+
+impl<T: Config> OnTimestampSet<T::Moment> for Pallet<T> {
+	fn on_timestamp_set(moment: T::Moment) {
+		let slot_duration = Self::slot_duration();
+		assert!(!slot_duration.is_zero(), "Babe slot duration cannot be zero.");
+
+		let timestamp_slot = moment / slot_duration;
+		let timestamp_slot = Slot::from(timestamp_slot.saturated_into::<u64>());
+
+		assert!(
+			CurrentSlot::<T>::get() == timestamp_slot,
+			"Timestamp slot must match `CurrentSlot`"
+		);
+	}
+}
+
+impl<T: Config> frame_support::traits::EstimateNextSessionRotation<BlockNumberFor<T>>
+	for Pallet<T>
+{
+	fn average_session_length() -> BlockNumberFor<T> {
+		T::EpochDuration::get().saturated_into()
+	}
+
+	fn estimate_current_session_progress(_now: BlockNumberFor<T>) -> (Option<Permill>, Weight) {
+		let elapsed = CurrentSlot::<T>::get().saturating_sub(Self::current_epoch_start()) + 1;
+
+		(
+			Some(Permill::from_rational(*elapsed, T::EpochDuration::get())),
+			// Read: Current Slot, Epoch Index, Genesis Slot
+			T::DbWeight::get().reads(3),
+		)
+	}
+
+	fn estimate_next_session_rotation(
+		now: BlockNumberFor<T>,
+	) -> (Option<BlockNumberFor<T>>, Weight) {
+		(
+			Self::next_expected_epoch_change(now),
+			// Read: Current Slot, Epoch Index, Genesis Slot
+			T::DbWeight::get().reads(3),
+		)
+	}
+}
+
+impl<T: Config> frame_support::traits::Lateness<BlockNumberFor<T>> for Pallet<T> {
+	fn lateness(&self) -> BlockNumberFor<T> {
+		Self::lateness()
+	}
+}
+
+impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
+	type Public = AuthorityId;
+}
+
+impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T>
+where
+	T: pallet_session::Config,
+{
+	type Key = AuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, AuthorityId)>,
+	{
+		let authorities = validators.map(|(_, k)| (k, 1)).collect::<Vec<_>>();
+		Self::initialize_genesis_authorities(&authorities);
+	}
+
+	fn on_new_session<'a, I: 'a>(_changed: bool, validators: I, queued_validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, AuthorityId)>,
+	{
+		let authorities = validators.map(|(_account, k)| (k, 1)).collect::<Vec<_>>();
+		let bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::force_from(
+			authorities,
+			Some(
+				"Warning: The session has more validators than expected. \
+				A runtime configuration adjustment may be needed.",
+			),
+		);
+
+		let next_authorities = queued_validators.map(|(_account, k)| (k, 1)).collect::<Vec<_>>();
+		let next_bounded_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::force_from(
+			next_authorities,
+			Some(
+				"Warning: The session has more queued validators than expected. \
+				A runtime configuration adjustment may be needed.",
+			),
+		);
+
+		let session_index = <pallet_session::Pallet<T>>::current_index();
+
+		Self::enact_epoch_change(bounded_authorities, next_bounded_authorities, Some(session_index))
+	}
+
+	fn on_disabled(i: u32) {
+		Self::deposit_consensus(ConsensusLog::OnDisabled(i))
+	}
+}
+
+// compute randomness for a new epoch. rho is the concatenation of all
+// VRF outputs in the prior epoch.
+//
+// an optional size hint as to how many VRF outputs there were may be provided.
+fn compute_randomness(
+	last_epoch_randomness: BabeRandomness,
+	epoch_index: u64,
+	rho: impl Iterator<Item = BabeRandomness>,
+	rho_size_hint: Option<usize>,
+) -> BabeRandomness {
+	let mut s = Vec::with_capacity(40 + rho_size_hint.unwrap_or(0) * RANDOMNESS_LENGTH);
+	s.extend_from_slice(&last_epoch_randomness);
+	s.extend_from_slice(&epoch_index.to_le_bytes());
+
+	for vrf_output in rho {
+		s.extend_from_slice(&vrf_output[..]);
+	}
+
+	sp_io::hashing::blake2_256(&s)
+}
+
+pub mod migrations {
+	use super::*;
+	use frame_support::pallet_prelude::{StorageValue, ValueQuery};
+
+	/// Something that can return the storage prefix of the `Babe` pallet.
+	pub trait BabePalletPrefix: Config {
+		fn pallet_prefix() -> &'static str;
+	}
+
+	struct __OldNextEpochConfig<T>(sp_std::marker::PhantomData<T>);
+	impl<T: BabePalletPrefix> frame_support::traits::StorageInstance for __OldNextEpochConfig<T> {
+		fn pallet_prefix() -> &'static str {
+			T::pallet_prefix()
+		}
+		const STORAGE_PREFIX: &'static str = "NextEpochConfig";
+	}
+
+	type OldNextEpochConfig<T> =
+		StorageValue<__OldNextEpochConfig<T>, Option<NextConfigDescriptor>, ValueQuery>;
+
+	/// A storage migration that adds the current epoch configuration for Babe
+	/// to storage.
+	pub fn add_epoch_configuration<T: BabePalletPrefix>(
+		epoch_config: BabeEpochConfiguration,
+	) -> Weight {
+		let mut writes = 0;
+		let mut reads = 0;
+
+		if let Some(pending_change) = OldNextEpochConfig::<T>::get() {
+			PendingEpochConfigChange::<T>::put(pending_change);
+
+			writes += 1;
+		}
+
+		reads += 1;
+
+		OldNextEpochConfig::<T>::kill();
+
+		EpochConfig::<T>::put(epoch_config.clone());
+		NextEpochConfig::<T>::put(epoch_config);
+
+		writes += 3;
+
+		T::DbWeight::get().reads_writes(reads, writes)
+	}
+}
diff --git a/substrate/frame/babe/src/mock.rs b/substrate/frame/babe/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dbffe9f312e60a25adfa67fc13b0562ca52590d7
--- /dev/null
+++ b/substrate/frame/babe/src/mock.rs
@@ -0,0 +1,437 @@
+// 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.
+
+//! Test utilities
+
+use crate::{self as pallet_babe, Config, CurrentSlot};
+use codec::Encode;
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, SequentialPhragmen,
+};
+use frame_support::{
+	parameter_types,
+	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},
+	H256, U256,
+};
+use sp_io;
+use sp_runtime::{
+	curve::PiecewiseLinear,
+	impl_opaque_keys,
+	testing::{Digest, DigestItem, Header, TestXt},
+	traits::{Header as _, IdentityLookup, OpaqueKeys},
+	BuildStorage, Perbill,
+};
+use sp_staking::{EraIndex, SessionIndex};
+
+type DummyValidatorId = u64;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Authorship: pallet_authorship,
+		Balances: pallet_balances,
+		Historical: pallet_session_historical,
+		Offences: pallet_offences,
+		Babe: pallet_babe,
+		Staking: pallet_staking,
+		Session: pallet_session,
+		Timestamp: pallet_timestamp,
+	}
+);
+
+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 RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Version = ();
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = DummyValidatorId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u128>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl<C> frame_system::offchain::SendTransactionTypes<C> for Test
+where
+	RuntimeCall: From<C>,
+{
+	type OverarchingCall = RuntimeCall;
+	type Extrinsic = TestXt<RuntimeCall, ()>;
+}
+
+impl_opaque_keys! {
+	pub struct MockSessionKeys {
+		pub babe_authority: super::Pallet<Test>,
+	}
+}
+
+impl pallet_session::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = <Self as frame_system::Config>::AccountId;
+	type ValidatorIdOf = pallet_staking::StashOf<Self>;
+	type ShouldEndSession = Babe;
+	type NextSessionRotation = Babe;
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
+	type SessionHandler = <MockSessionKeys as OpaqueKeys>::KeyTypeIdProviders;
+	type Keys = MockSessionKeys;
+	type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Test {
+	type FullIdentification = pallet_staking::Exposure<u64, u128>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Self>;
+}
+
+impl pallet_authorship::Config for Test {
+	type FindAuthor = pallet_session::FindAccountFromAuthorIndex<Self, Babe>;
+	type EventHandler = ();
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = Babe;
+	type MinimumPeriod = ConstU64<1>;
+	type WeightInfo = ();
+}
+
+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 MaxHolds = ();
+}
+
+pallet_staking_reward_curve::build! {
+	const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
+		min_inflation: 0_025_000u64,
+		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 SessionsPerEra: SessionIndex = 3;
+	pub const BondingDuration: EraIndex = 3;
+	pub const SlashDeferDuration: EraIndex = 0;
+	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(16);
+	pub static ElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Test;
+	type Solver = SequentialPhragmen<DummyValidatorId, Perbill>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = ConstU32<100>;
+	type Bounds = ElectionsBounds;
+}
+
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+	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 HistoryDepth = ConstU32<84>;
+	type EventListeners = ();
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+impl pallet_offences::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
+	type OnOffenceHandler = Staking;
+}
+
+parameter_types! {
+	pub const EpochDuration: u64 = 3;
+	pub const ReportLongevity: u64 =
+		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * EpochDuration::get();
+}
+
+impl Config for Test {
+	type EpochDuration = EpochDuration;
+	type ExpectedBlockTime = ConstU64<1>;
+	type EpochChangeTrigger = crate::ExternalTrigger;
+	type DisabledValidators = Session;
+	type WeightInfo = ();
+	type MaxAuthorities = ConstU32<10>;
+	type MaxNominators = ConstU32<100>;
+	type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, AuthorityId)>>::Proof;
+	type EquivocationReportSystem =
+		super::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
+}
+
+pub fn go_to_block(n: u64, s: u64) {
+	use frame_support::traits::OnFinalize;
+
+	Babe::on_finalize(System::block_number());
+	Session::on_finalize(System::block_number());
+	Staking::on_finalize(System::block_number());
+
+	let parent_hash = if System::block_number() > 1 {
+		let hdr = System::finalize();
+		hdr.hash()
+	} else {
+		System::parent_hash()
+	};
+
+	let pre_digest = make_secondary_plain_pre_digest(0, s.into());
+
+	System::reset_events();
+	System::initialize(&n, &parent_hash, &pre_digest);
+
+	Babe::on_initialize(n);
+	Session::on_initialize(n);
+	Staking::on_initialize(n);
+}
+
+/// Slots will grow accordingly to blocks
+pub fn progress_to_block(n: u64) {
+	let mut slot = u64::from(Babe::current_slot()) + 1;
+	for i in System::block_number() + 1..=n {
+		go_to_block(i, slot);
+		slot += 1;
+	}
+}
+
+/// Progress to the first block at the given session
+pub fn start_session(session_index: SessionIndex) {
+	let missing = (session_index - Session::current_index()) * 3;
+	progress_to_block(System::block_number() + missing as u64 + 1);
+	assert_eq!(Session::current_index(), session_index);
+}
+
+/// Progress to the first block at the given era
+pub fn start_era(era_index: EraIndex) {
+	start_session((era_index * 3).into());
+	assert_eq!(Staking::current_era(), Some(era_index));
+}
+
+pub fn make_primary_pre_digest(
+	authority_index: sp_consensus_babe::AuthorityIndex,
+	slot: sp_consensus_babe::Slot,
+	vrf_signature: VrfSignature,
+) -> Digest {
+	let digest_data = sp_consensus_babe::digests::PreDigest::Primary(
+		sp_consensus_babe::digests::PrimaryPreDigest { authority_index, slot, vrf_signature },
+	);
+	let log = DigestItem::PreRuntime(sp_consensus_babe::BABE_ENGINE_ID, digest_data.encode());
+	Digest { logs: vec![log] }
+}
+
+pub fn make_secondary_plain_pre_digest(
+	authority_index: sp_consensus_babe::AuthorityIndex,
+	slot: sp_consensus_babe::Slot,
+) -> Digest {
+	let digest_data = sp_consensus_babe::digests::PreDigest::SecondaryPlain(
+		sp_consensus_babe::digests::SecondaryPlainPreDigest { authority_index, slot },
+	);
+	let log = DigestItem::PreRuntime(sp_consensus_babe::BABE_ENGINE_ID, digest_data.encode());
+	Digest { logs: vec![log] }
+}
+
+pub fn make_secondary_vrf_pre_digest(
+	authority_index: sp_consensus_babe::AuthorityIndex,
+	slot: sp_consensus_babe::Slot,
+	vrf_signature: VrfSignature,
+) -> Digest {
+	let digest_data = sp_consensus_babe::digests::PreDigest::SecondaryVRF(
+		sp_consensus_babe::digests::SecondaryVRFPreDigest { authority_index, slot, vrf_signature },
+	);
+	let log = DigestItem::PreRuntime(sp_consensus_babe::BABE_ENGINE_ID, digest_data.encode());
+	Digest { logs: vec![log] }
+}
+
+pub fn make_vrf_signature_and_randomness(
+	slot: Slot,
+	pair: &sp_consensus_babe::AuthorityPair,
+) -> (VrfSignature, Randomness) {
+	let transcript = sp_consensus_babe::make_vrf_transcript(&Babe::randomness(), slot, 0);
+
+	let randomness =
+		pair.as_ref().make_bytes(sp_consensus_babe::RANDOMNESS_VRF_CONTEXT, &transcript);
+
+	let signature = pair.as_ref().vrf_sign(&transcript.into());
+
+	(signature, randomness)
+}
+
+pub fn new_test_ext(authorities_len: usize) -> sp_io::TestExternalities {
+	new_test_ext_with_pairs(authorities_len).1
+}
+
+pub fn new_test_ext_with_pairs(
+	authorities_len: usize,
+) -> (Vec<AuthorityPair>, sp_io::TestExternalities) {
+	let pairs = (0..authorities_len)
+		.map(|i| AuthorityPair::from_seed(&U256::from(i).into()))
+		.collect::<Vec<_>>();
+
+	let public = pairs.iter().map(|p| p.public()).collect();
+
+	(pairs, new_test_ext_raw_authorities(public))
+}
+
+pub fn new_test_ext_raw_authorities(authorities: Vec<AuthorityId>) -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let balances: Vec<_> = (0..authorities.len()).map(|i| (i as u64, 10_000_000)).collect();
+
+	pallet_balances::GenesisConfig::<Test> { balances }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	// stashes are the index.
+	let session_keys: Vec<_> = authorities
+		.iter()
+		.enumerate()
+		.map(|(i, k)| {
+			(i as u64, i as u64, MockSessionKeys { babe_authority: AuthorityId::from(k.clone()) })
+		})
+		.collect();
+
+	// NOTE: this will initialize the babe authorities
+	// through OneSessionHandler::on_genesis_session
+	pallet_session::GenesisConfig::<Test> { keys: session_keys }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	// controllers are same as stash
+	let stakers: Vec<_> = (0..authorities.len())
+		.map(|i| (i as u64, i as u64, 10_000, pallet_staking::StakerStatus::<u64>::Validator))
+		.collect();
+
+	let staking_config = pallet_staking::GenesisConfig::<Test> {
+		stakers,
+		validator_count: 8,
+		force_era: pallet_staking::Forcing::ForceNew,
+		minimum_validator_count: 0,
+		invulnerables: vec![],
+		..Default::default()
+	};
+
+	staking_config.assimilate_storage(&mut t).unwrap();
+
+	t.into()
+}
+
+/// Creates an equivocation at the current block, by generating two headers.
+pub fn generate_equivocation_proof(
+	offender_authority_index: u32,
+	offender_authority_pair: &AuthorityPair,
+	slot: Slot,
+) -> sp_consensus_babe::EquivocationProof<Header> {
+	use sp_consensus_babe::digests::CompatibleDigestItem;
+
+	let current_block = System::block_number();
+	let current_slot = CurrentSlot::<Test>::get();
+
+	let make_header = || {
+		let parent_hash = System::parent_hash();
+		let pre_digest = make_secondary_plain_pre_digest(offender_authority_index, slot);
+		System::reset_events();
+		System::initialize(&current_block, &parent_hash, &pre_digest);
+		System::set_block_number(current_block);
+		Timestamp::set_timestamp(*current_slot * Babe::slot_duration());
+		System::finalize()
+	};
+
+	// sign the header prehash and sign it, adding it to the block as the seal
+	// digest item
+	let seal_header = |header: &mut Header| {
+		let prehash = header.hash();
+		let seal = <DigestItem as CompatibleDigestItem>::babe_seal(
+			offender_authority_pair.sign(prehash.as_ref()),
+		);
+		header.digest_mut().push(seal);
+	};
+
+	// generate two headers at the current block
+	let mut h1 = make_header();
+	let mut h2 = make_header();
+
+	seal_header(&mut h1);
+	seal_header(&mut h2);
+
+	// restore previous runtime state
+	go_to_block(current_block, *current_slot);
+
+	sp_consensus_babe::EquivocationProof {
+		slot,
+		offender: offender_authority_pair.public(),
+		first_header: h1,
+		second_header: h2,
+	}
+}
diff --git a/substrate/frame/babe/src/randomness.rs b/substrate/frame/babe/src/randomness.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d3d1bea2292da949dd1bac3aca20f6d33cb6d258
--- /dev/null
+++ b/substrate/frame/babe/src/randomness.rs
@@ -0,0 +1,173 @@
+// 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.
+
+//! Provides multiple implementations of the randomness trait based on the on-chain epoch
+//! randomness collected from VRF outputs.
+
+use super::{
+	AuthorVrfRandomness, Config, EpochStart, NextRandomness, Randomness, RANDOMNESS_LENGTH,
+};
+use frame_support::traits::Randomness as RandomnessT;
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_runtime::traits::{Hash, One, Saturating};
+
+/// Randomness usable by consensus protocols that **depend** upon finality and take action
+/// based upon on-chain commitments made during the epoch before the previous epoch.
+///
+/// An off-chain consensus protocol requires randomness be finalized before usage, but one
+/// extra epoch delay beyond `RandomnessFromOneEpochAgo` suffices, under the assumption
+/// that finality never stalls for longer than one epoch.
+///
+/// All randomness is relative to commitments to any other inputs to the computation: If
+/// Alice samples randomness near perfectly using radioactive decay, but then afterwards
+/// Eve selects an arbitrary value with which to xor Alice's randomness, then Eve always
+/// wins whatever game they play.
+///
+/// All input commitments used with `RandomnessFromTwoEpochsAgo` should come from at least
+/// three epochs ago. We require BABE session keys be registered at least three epochs
+/// before being used to derive `ParentBlockRandomness` for example.
+///
+/// All users learn `RandomnessFromTwoEpochsAgo` when epoch `current_epoch - 1` starts,
+/// although some learn it a few block earlier inside epoch `current_epoch - 2`.
+///
+/// Adversaries with enough block producers could bias this randomness by choosing upon
+/// what their block producers build at the end of epoch `current_epoch - 2` or the
+/// beginning epoch `current_epoch - 1`, or skipping slots at the end of epoch
+/// `current_epoch - 2`.
+///
+/// Adversaries should not possess many block production slots towards the beginning or
+/// end of every epoch, but they possess some influence over when they possess more slots.
+pub struct RandomnessFromTwoEpochsAgo<T>(sp_std::marker::PhantomData<T>);
+
+/// Randomness usable by on-chain code that **does not depend** upon finality and takes
+/// action based upon on-chain commitments made during the previous epoch.
+///
+/// All randomness is relative to commitments to any other inputs to the computation: If
+/// Alice samples randomness near perfectly using radioactive decay, but then afterwards
+/// Eve selects an arbitrary value with which to xor Alice's randomness, then Eve always
+/// wins whatever game they play.
+///
+/// All input commitments used with `RandomnessFromOneEpochAgo` should come from at least
+/// two epochs ago, although the previous epoch might work in special cases under
+/// additional assumption.
+///
+/// All users learn `RandomnessFromOneEpochAgo` at the end of the previous epoch, although
+/// some block producers learn it several block earlier.
+///
+/// Adversaries with enough block producers could bias this randomness by choosing upon
+/// what their block producers build at either the end of the previous epoch or the
+/// beginning of the current epoch, or electing to skipping some of their own block
+/// production slots towards the end of the previous epoch.
+///
+/// Adversaries should not possess many block production slots towards the beginning or
+/// end of every epoch, but they possess some influence over when they possess more slots.
+///
+/// As an example usage, we determine parachain auctions ending times in Polkadot using
+/// `RandomnessFromOneEpochAgo` because it reduces bias from `ParentBlockRandomness` and
+/// does not require the extra finality delay of `RandomnessFromTwoEpochsAgo`.
+pub struct RandomnessFromOneEpochAgo<T>(sp_std::marker::PhantomData<T>);
+
+/// Randomness produced semi-freshly with each block, but inherits limitations of
+/// `RandomnessFromTwoEpochsAgo` from which it derives.
+///
+/// All randomness is relative to commitments to any other inputs to the computation: If
+/// Alice samples randomness near perfectly using radioactive decay, but then afterwards
+/// Eve selects an arbitrary value with which to xor Alice's randomness, then Eve always
+/// wins whatever game they play.
+///
+/// As with `RandomnessFromTwoEpochsAgo`, all input commitments combined with
+/// `ParentBlockRandomness` should come from at least two epoch ago, except preferably
+/// not near epoch ending, and thus ideally three epochs ago.
+///
+/// Almost all users learn this randomness for a given block by the time they receive it's
+/// parent block, which makes this randomness appear fresh enough. Yet, the block producer
+/// themselves learned this randomness at the beginning of epoch `current_epoch - 2`, at
+/// the same time as they learn `RandomnessFromTwoEpochsAgo`.
+///
+/// Aside from just biasing `RandomnessFromTwoEpochsAgo`, adversaries could also bias
+/// `ParentBlockRandomness` by never announcing their block if doing so yields an
+/// unfavorable randomness. As such, `ParentBlockRandomness` should be considered weaker
+/// than both other randomness sources provided by BABE, but `ParentBlockRandomness`
+/// remains constrained by declared staking, while a randomness source like block hash is
+/// only constrained by adversaries' unknowable computational power.
+///
+/// As an example use, parachains could assign block production slots based upon the
+/// `ParentBlockRandomness` of their relay parent or relay parent's parent, provided the
+/// parachain registers collators but avoids censorship sensitive functionality like
+/// slashing. Any parachain with slashing could operate BABE itself or perhaps better yet
+/// a BABE-like approach that derives its `ParentBlockRandomness`, and authorizes block
+/// production, based upon the relay parent's `ParentBlockRandomness` or more likely the
+/// relay parent's `RandomnessFromTwoEpochsAgo`.
+///
+/// NOTE: there is some nuance here regarding what is current and parent randomness. If
+/// you are using this trait from within the runtime (i.e. as part of block execution)
+/// then the randomness provided here will always be generated from the parent block. If
+/// instead you are using this randomness externally, i.e. after block execution, then
+/// this randomness will be provided by the "current" block (this stems from the fact that
+/// we process VRF outputs on block execution finalization, i.e. `on_finalize`).
+pub struct ParentBlockRandomness<T>(sp_std::marker::PhantomData<T>);
+
+/// Randomness produced semi-freshly with each block, but inherits limitations of
+/// `RandomnessFromTwoEpochsAgo` from which it derives.
+///
+/// See [`ParentBlockRandomness`].
+#[deprecated(note = "Should not be relied upon for correctness, \
+					 will not provide fresh randomness for the current block. \
+					 Please use `ParentBlockRandomness` instead.")]
+pub struct CurrentBlockRandomness<T>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config> RandomnessT<T::Hash, BlockNumberFor<T>> for RandomnessFromTwoEpochsAgo<T> {
+	fn random(subject: &[u8]) -> (T::Hash, BlockNumberFor<T>) {
+		let mut subject = subject.to_vec();
+		subject.reserve(RANDOMNESS_LENGTH);
+		subject.extend_from_slice(&Randomness::<T>::get()[..]);
+
+		(T::Hashing::hash(&subject[..]), EpochStart::<T>::get().0)
+	}
+}
+
+impl<T: Config> RandomnessT<T::Hash, BlockNumberFor<T>> for RandomnessFromOneEpochAgo<T> {
+	fn random(subject: &[u8]) -> (T::Hash, BlockNumberFor<T>) {
+		let mut subject = subject.to_vec();
+		subject.reserve(RANDOMNESS_LENGTH);
+		subject.extend_from_slice(&NextRandomness::<T>::get()[..]);
+
+		(T::Hashing::hash(&subject[..]), EpochStart::<T>::get().1)
+	}
+}
+
+impl<T: Config> RandomnessT<Option<T::Hash>, BlockNumberFor<T>> for ParentBlockRandomness<T> {
+	fn random(subject: &[u8]) -> (Option<T::Hash>, BlockNumberFor<T>) {
+		let random = AuthorVrfRandomness::<T>::get().map(|random| {
+			let mut subject = subject.to_vec();
+			subject.reserve(RANDOMNESS_LENGTH);
+			subject.extend_from_slice(&random);
+
+			T::Hashing::hash(&subject[..])
+		});
+
+		(random, <frame_system::Pallet<T>>::block_number().saturating_sub(One::one()))
+	}
+}
+
+#[allow(deprecated)]
+impl<T: Config> RandomnessT<Option<T::Hash>, BlockNumberFor<T>> for CurrentBlockRandomness<T> {
+	fn random(subject: &[u8]) -> (Option<T::Hash>, BlockNumberFor<T>) {
+		let (random, _) = ParentBlockRandomness::<T>::random(subject);
+		(random, <frame_system::Pallet<T>>::block_number())
+	}
+}
diff --git a/substrate/frame/babe/src/tests.rs b/substrate/frame/babe/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ae0c3e3873c5023f25c6ab6c6d3f1e4bdceb6d39
--- /dev/null
+++ b/substrate/frame/babe/src/tests.rs
@@ -0,0 +1,1046 @@
+// 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.
+
+//! Consensus extension module tests for BABE consensus.
+
+use super::{Call, *};
+use frame_support::{
+	assert_err, assert_noop, assert_ok,
+	dispatch::{GetDispatchInfo, Pays},
+	traits::{Currency, EstimateNextSessionRotation, KeyOwnerProofSystem, OnFinalize},
+};
+use mock::*;
+use pallet_session::ShouldEndSession;
+use sp_consensus_babe::{
+	AllowedSlots, BabeEpochConfiguration, Slot, VrfSignature, RANDOMNESS_LENGTH,
+};
+use sp_core::crypto::Pair;
+
+const EMPTY_RANDOMNESS: [u8; RANDOMNESS_LENGTH] = [
+	74, 25, 49, 128, 53, 97, 244, 49, 222, 202, 176, 2, 231, 66, 95, 10, 133, 49, 213, 228, 86,
+	161, 164, 127, 217, 153, 138, 37, 48, 192, 248, 0,
+];
+
+#[test]
+fn empty_randomness_is_correct() {
+	let s = compute_randomness([0; RANDOMNESS_LENGTH], 0, std::iter::empty(), None);
+	assert_eq!(s, EMPTY_RANDOMNESS);
+}
+
+#[test]
+fn initial_values() {
+	new_test_ext(4).execute_with(|| assert_eq!(Babe::authorities().len(), 4))
+}
+
+#[test]
+fn check_module() {
+	new_test_ext(4).execute_with(|| {
+		assert!(!Babe::should_end_session(0), "Genesis does not change sessions");
+		assert!(
+			!Babe::should_end_session(200000),
+			"BABE does not include the block number in epoch calculations"
+		);
+	})
+}
+
+#[test]
+fn first_block_epoch_zero_start() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(4);
+
+	ext.execute_with(|| {
+		let genesis_slot = Slot::from(100);
+		let (vrf_signature, vrf_randomness) =
+			make_vrf_signature_and_randomness(genesis_slot, &pairs[0]);
+
+		let pre_digest = make_primary_pre_digest(0, genesis_slot, vrf_signature);
+
+		assert_eq!(Babe::genesis_slot(), Slot::from(0));
+		System::reset_events();
+		System::initialize(&1, &Default::default(), &pre_digest);
+
+		// see implementation of the function for details why: we issue an
+		// epoch-change digest but don't do it via the normal session mechanism.
+		assert!(!Babe::should_end_session(1));
+		assert_eq!(Babe::genesis_slot(), genesis_slot);
+		assert_eq!(Babe::current_slot(), genesis_slot);
+		assert_eq!(Babe::epoch_index(), 0);
+
+		Babe::on_finalize(1);
+		let header = System::finalize();
+
+		assert_eq!(Babe::author_vrf_randomness(), Some(vrf_randomness));
+		assert_eq!(SegmentIndex::<Test>::get(), 0);
+		assert_eq!(UnderConstruction::<Test>::get(0), vec![vrf_randomness]);
+		assert_eq!(Babe::randomness(), [0; 32]);
+		assert_eq!(Babe::author_vrf_randomness(), Some(vrf_randomness));
+		assert_eq!(NextRandomness::<Test>::get(), [0; 32]);
+
+		assert_eq!(header.digest.logs.len(), 2);
+		assert_eq!(pre_digest.logs.len(), 1);
+		assert_eq!(header.digest.logs[0], pre_digest.logs[0]);
+
+		let consensus_log = sp_consensus_babe::ConsensusLog::NextEpochData(
+			sp_consensus_babe::digests::NextEpochDescriptor {
+				authorities: Babe::authorities().to_vec(),
+				randomness: Babe::randomness(),
+			},
+		);
+		let consensus_digest = DigestItem::Consensus(BABE_ENGINE_ID, consensus_log.encode());
+
+		// first epoch descriptor has same info as last.
+		assert_eq!(header.digest.logs[1], consensus_digest.clone())
+	})
+}
+
+#[test]
+fn current_slot_is_processed_on_initialization() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(1);
+
+	ext.execute_with(|| {
+		let genesis_slot = Slot::from(10);
+		let (vrf_signature, vrf_randomness) =
+			make_vrf_signature_and_randomness(genesis_slot, &pairs[0]);
+		let pre_digest = make_primary_pre_digest(0, genesis_slot, vrf_signature);
+
+		System::reset_events();
+		System::initialize(&1, &Default::default(), &pre_digest);
+		assert_eq!(Babe::current_slot(), Slot::from(0));
+		assert!(Babe::initialized().is_none());
+
+		// current slot is updated on initialization
+		Babe::initialize(1);
+		assert_eq!(Babe::current_slot(), genesis_slot);
+		assert!(Babe::initialized().is_some());
+		// but author vrf randomness isn't
+		assert_eq!(Babe::author_vrf_randomness(), None);
+
+		// instead it is updated on block finalization
+		Babe::on_finalize(1);
+		assert_eq!(Babe::author_vrf_randomness(), Some(vrf_randomness));
+	})
+}
+
+fn test_author_vrf_output<F>(make_pre_digest: F)
+where
+	F: Fn(sp_consensus_babe::AuthorityIndex, Slot, VrfSignature) -> sp_runtime::Digest,
+{
+	let (pairs, mut ext) = new_test_ext_with_pairs(1);
+
+	ext.execute_with(|| {
+		let genesis_slot = Slot::from(10);
+		let (vrf_signature, vrf_randomness) =
+			make_vrf_signature_and_randomness(genesis_slot, &pairs[0]);
+		let pre_digest = make_pre_digest(0, genesis_slot, vrf_signature);
+
+		System::reset_events();
+		System::initialize(&1, &Default::default(), &pre_digest);
+
+		// author vrf randomness is not updated on initialization
+		Babe::initialize(1);
+		assert_eq!(Babe::author_vrf_randomness(), None);
+
+		// instead it is updated on block finalization to account for any
+		// epoch changes that might happen during the block
+		Babe::on_finalize(1);
+		assert_eq!(Babe::author_vrf_randomness(), Some(vrf_randomness));
+
+		// and it is kept after finalizing the block
+		System::finalize();
+		assert_eq!(Babe::author_vrf_randomness(), Some(vrf_randomness));
+	})
+}
+
+#[test]
+fn author_vrf_output_for_primary() {
+	test_author_vrf_output(make_primary_pre_digest);
+}
+
+#[test]
+fn author_vrf_output_for_secondary_vrf() {
+	test_author_vrf_output(make_secondary_vrf_pre_digest);
+}
+
+#[test]
+fn no_author_vrf_output_for_secondary_plain() {
+	new_test_ext(1).execute_with(|| {
+		let genesis_slot = Slot::from(10);
+		let secondary_plain_pre_digest = make_secondary_plain_pre_digest(0, genesis_slot);
+
+		System::reset_events();
+		System::initialize(&1, &Default::default(), &secondary_plain_pre_digest);
+		assert_eq!(Babe::author_vrf_randomness(), None);
+
+		Babe::initialize(1);
+		assert_eq!(Babe::author_vrf_randomness(), None);
+
+		Babe::on_finalize(1);
+		System::finalize();
+		assert_eq!(Babe::author_vrf_randomness(), None);
+	})
+}
+
+#[test]
+fn authority_index() {
+	new_test_ext(4).execute_with(|| {
+		assert_eq!(
+			Babe::find_author((&[(BABE_ENGINE_ID, &[][..])]).into_iter().cloned()),
+			None,
+			"Trivially invalid authorities are ignored"
+		)
+	})
+}
+
+#[test]
+fn can_predict_next_epoch_change() {
+	new_test_ext(1).execute_with(|| {
+		assert_eq!(<Test as Config>::EpochDuration::get(), 3);
+		// this sets the genesis slot to 6;
+		go_to_block(1, 6);
+		assert_eq!(*Babe::genesis_slot(), 6);
+		assert_eq!(*Babe::current_slot(), 6);
+		assert_eq!(Babe::epoch_index(), 0);
+
+		progress_to_block(5);
+
+		assert_eq!(Babe::epoch_index(), 5 / 3);
+		assert_eq!(*Babe::current_slot(), 10);
+
+		// next epoch change will be at
+		assert_eq!(*Babe::current_epoch_start(), 9); // next change will be 12, 2 slots from now
+		assert_eq!(Babe::next_expected_epoch_change(System::block_number()), Some(5 + 2));
+	})
+}
+
+#[test]
+fn can_estimate_current_epoch_progress() {
+	new_test_ext(1).execute_with(|| {
+		assert_eq!(<Test as Config>::EpochDuration::get(), 3);
+
+		// with BABE the genesis block is not part of any epoch, the first epoch starts at block #1,
+		// therefore its last block should be #3
+		for i in 1u64..4 {
+			progress_to_block(i);
+
+			assert_eq!(Babe::estimate_next_session_rotation(i).0.unwrap(), 4);
+
+			// the last block of the epoch must have 100% progress.
+			if Babe::estimate_next_session_rotation(i).0.unwrap() - 1 == i {
+				assert_eq!(
+					Babe::estimate_current_session_progress(i).0.unwrap(),
+					Permill::from_percent(100)
+				);
+			} else {
+				assert!(
+					Babe::estimate_current_session_progress(i).0.unwrap() <
+						Permill::from_percent(100)
+				);
+			}
+		}
+
+		// the first block of the new epoch counts towards the epoch progress as well
+		progress_to_block(4);
+		assert_eq!(
+			Babe::estimate_current_session_progress(4).0.unwrap(),
+			Permill::from_float(1.0 / 3.0),
+		);
+	})
+}
+
+#[test]
+fn can_enact_next_config() {
+	new_test_ext(1).execute_with(|| {
+		assert_eq!(<Test as Config>::EpochDuration::get(), 3);
+		// this sets the genesis slot to 6;
+		go_to_block(1, 6);
+		assert_eq!(*Babe::genesis_slot(), 6);
+		assert_eq!(*Babe::current_slot(), 6);
+		assert_eq!(Babe::epoch_index(), 0);
+		go_to_block(2, 7);
+
+		let current_config = BabeEpochConfiguration {
+			c: (0, 4),
+			allowed_slots: sp_consensus_babe::AllowedSlots::PrimarySlots,
+		};
+
+		let next_config = BabeEpochConfiguration {
+			c: (1, 4),
+			allowed_slots: sp_consensus_babe::AllowedSlots::PrimarySlots,
+		};
+
+		let next_next_config = BabeEpochConfiguration {
+			c: (2, 4),
+			allowed_slots: sp_consensus_babe::AllowedSlots::PrimarySlots,
+		};
+
+		EpochConfig::<Test>::put(current_config);
+		NextEpochConfig::<Test>::put(next_config.clone());
+
+		assert_eq!(NextEpochConfig::<Test>::get(), Some(next_config.clone()));
+
+		Babe::plan_config_change(
+			RuntimeOrigin::root(),
+			NextConfigDescriptor::V1 {
+				c: next_next_config.c,
+				allowed_slots: next_next_config.allowed_slots,
+			},
+		)
+		.unwrap();
+
+		progress_to_block(4);
+		Babe::on_finalize(9);
+		let header = System::finalize();
+
+		assert_eq!(EpochConfig::<Test>::get(), Some(next_config));
+		assert_eq!(NextEpochConfig::<Test>::get(), Some(next_next_config.clone()));
+
+		let consensus_log =
+			sp_consensus_babe::ConsensusLog::NextConfigData(NextConfigDescriptor::V1 {
+				c: next_next_config.c,
+				allowed_slots: next_next_config.allowed_slots,
+			});
+		let consensus_digest = DigestItem::Consensus(BABE_ENGINE_ID, consensus_log.encode());
+
+		assert_eq!(header.digest.logs[2], consensus_digest.clone())
+	});
+}
+
+#[test]
+fn only_root_can_enact_config_change() {
+	use sp_runtime::DispatchError;
+
+	new_test_ext(1).execute_with(|| {
+		let next_config =
+			NextConfigDescriptor::V1 { c: (1, 4), allowed_slots: AllowedSlots::PrimarySlots };
+
+		let res = Babe::plan_config_change(RuntimeOrigin::none(), next_config.clone());
+
+		assert_noop!(res, DispatchError::BadOrigin);
+
+		let res = Babe::plan_config_change(RuntimeOrigin::signed(1), next_config.clone());
+
+		assert_noop!(res, DispatchError::BadOrigin);
+
+		let res = Babe::plan_config_change(RuntimeOrigin::root(), next_config);
+
+		assert!(res.is_ok());
+	});
+}
+
+#[test]
+fn can_fetch_current_and_next_epoch_data() {
+	new_test_ext(5).execute_with(|| {
+		EpochConfig::<Test>::put(BabeEpochConfiguration {
+			c: (1, 4),
+			allowed_slots: sp_consensus_babe::AllowedSlots::PrimarySlots,
+		});
+
+		// genesis authorities should be used for the first and second epoch
+		assert_eq!(Babe::current_epoch().authorities, Babe::next_epoch().authorities);
+		// 1 era = 3 epochs
+		// 1 epoch = 3 slots
+		// Eras start from 0.
+		// Therefore at era 1 we should be starting epoch 3 with slot 10.
+		start_era(1);
+
+		let current_epoch = Babe::current_epoch();
+		assert_eq!(current_epoch.epoch_index, 3);
+		assert_eq!(*current_epoch.start_slot, 10);
+		assert_eq!(current_epoch.authorities.len(), 5);
+
+		let next_epoch = Babe::next_epoch();
+		assert_eq!(next_epoch.epoch_index, 4);
+		assert_eq!(*next_epoch.start_slot, 13);
+		assert_eq!(next_epoch.authorities.len(), 5);
+
+		// the on-chain randomness should always change across epochs
+		assert!(current_epoch.randomness != next_epoch.randomness);
+
+		// but in this case the authorities stay the same
+		assert!(current_epoch.authorities == next_epoch.authorities);
+	});
+}
+
+#[test]
+fn tracks_block_numbers_when_current_and_previous_epoch_started() {
+	new_test_ext(5).execute_with(|| {
+		// an epoch is 3 slots therefore at block 8 we should be in epoch #3
+		// with the previous epochs having the following blocks:
+		// epoch 1 - [1, 2, 3]
+		// epoch 2 - [4, 5, 6]
+		// epoch 3 - [7, 8, 9]
+		progress_to_block(8);
+
+		let (last_epoch, current_epoch) = EpochStart::<Test>::get();
+
+		assert_eq!(last_epoch, 4);
+		assert_eq!(current_epoch, 7);
+
+		// once we reach block 10 we switch to epoch #4
+		progress_to_block(10);
+
+		let (last_epoch, current_epoch) = EpochStart::<Test>::get();
+
+		assert_eq!(last_epoch, 7);
+		assert_eq!(current_epoch, 10);
+	});
+}
+
+#[test]
+#[should_panic(
+	expected = "Validator with index 0 is disabled and should not be attempting to author blocks."
+)]
+fn disabled_validators_cannot_author_blocks() {
+	new_test_ext(4).execute_with(|| {
+		start_era(1);
+
+		// let's disable the validator at index 1
+		Session::disable_index(1);
+
+		// the mocking infrastructure always authors all blocks using authority index 0,
+		// so we should still be able to author blocks
+		start_era(2);
+
+		assert_eq!(Staking::current_era().unwrap(), 2);
+
+		// let's disable the validator at index 0
+		Session::disable_index(0);
+
+		// this should now panic as the validator authoring blocks is disabled
+		start_era(3);
+	});
+}
+
+#[test]
+fn report_equivocation_current_session_works() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	ext.execute_with(|| {
+		start_era(1);
+
+		let authorities = Babe::authorities();
+		let validators = Session::validators();
+
+		// make sure that all authorities have the same balance
+		for validator in &validators {
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(1, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+
+		// we will use the validator at index 1 as the offending authority
+		let offending_validator_index = 1;
+		let offending_validator_id = Session::validators()[offending_validator_index];
+		let offending_authority_pair = pairs
+			.into_iter()
+			.find(|p| p.public() == authorities[offending_validator_index].0)
+			.unwrap();
+
+		// generate an equivocation proof. it creates two headers at the given
+		// slot with different block hashes and signed by the given key
+		let equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+
+		// create the key ownership proof
+		let key = (sp_consensus_babe::KEY_TYPE, &offending_authority_pair.public());
+		let key_owner_proof = Historical::prove(key).unwrap();
+
+		// report the equivocation
+		Babe::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.unwrap();
+
+		// start a new era so that the results of the offence report
+		// are applied at era end
+		start_era(2);
+
+		// check that the balance of offending validator is slashed 100%.
+		assert_eq!(Balances::total_balance(&offending_validator_id), 10_000_000 - 10_000);
+		assert_eq!(Staking::slashable_balance_of(&offending_validator_id), 0);
+		assert_eq!(
+			Staking::eras_stakers(2, offending_validator_id),
+			pallet_staking::Exposure { total: 0, own: 0, others: vec![] },
+		);
+
+		// check that the balances of all other validators are left intact.
+		for validator in &validators {
+			if *validator == offending_validator_id {
+				continue
+			}
+
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+			assert_eq!(
+				Staking::eras_stakers(2, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+	})
+}
+
+#[test]
+fn report_equivocation_old_session_works() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	ext.execute_with(|| {
+		start_era(1);
+
+		let authorities = Babe::authorities();
+
+		// we will use the validator at index 0 as the offending authority
+		let offending_validator_index = 1;
+		let offending_validator_id = Session::validators()[offending_validator_index];
+		let offending_authority_pair = pairs
+			.into_iter()
+			.find(|p| p.public() == authorities[offending_validator_index].0)
+			.unwrap();
+
+		// generate an equivocation proof at the current slot
+		let equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+
+		// create the key ownership proof
+		let key = (sp_consensus_babe::KEY_TYPE, &offending_authority_pair.public());
+		let key_owner_proof = Historical::prove(key).unwrap();
+
+		// start a new era and report the equivocation
+		// from the previous era
+		start_era(2);
+
+		// check the balance of the offending validator
+		assert_eq!(Balances::total_balance(&offending_validator_id), 10_000_000);
+		assert_eq!(Staking::slashable_balance_of(&offending_validator_id), 10_000);
+
+		// report the equivocation
+		Babe::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.unwrap();
+
+		// start a new era so that the results of the offence report
+		// are applied at era end
+		start_era(3);
+
+		// check that the balance of offending validator is slashed 100%.
+		assert_eq!(Balances::total_balance(&offending_validator_id), 10_000_000 - 10_000);
+		assert_eq!(Staking::slashable_balance_of(&offending_validator_id), 0);
+		assert_eq!(
+			Staking::eras_stakers(3, offending_validator_id),
+			pallet_staking::Exposure { total: 0, own: 0, others: vec![] },
+		);
+	})
+}
+
+#[test]
+fn report_equivocation_invalid_key_owner_proof() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	ext.execute_with(|| {
+		start_era(1);
+
+		let authorities = Babe::authorities();
+
+		// we will use the validator at index 0 as the offending authority
+		let offending_validator_index = 0;
+		let offending_authority_pair = pairs
+			.into_iter()
+			.find(|p| p.public() == authorities[offending_validator_index].0)
+			.unwrap();
+
+		// generate an equivocation proof at the current slot
+		let equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+
+		// create the key ownership proof
+		let key = (sp_consensus_babe::KEY_TYPE, &offending_authority_pair.public());
+		let mut key_owner_proof = Historical::prove(key).unwrap();
+
+		// we change the session index in the key ownership proof
+		// which should make it invalid
+		key_owner_proof.session = 0;
+		assert_err!(
+			Babe::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof.clone()),
+				key_owner_proof
+			),
+			Error::<Test>::InvalidKeyOwnershipProof,
+		);
+
+		// it should fail as well if we create a key owner proof
+		// for a different authority than the offender
+		let key = (sp_consensus_babe::KEY_TYPE, &authorities[1].0);
+		let key_owner_proof = Historical::prove(key).unwrap();
+
+		// we need to progress to a new era to make sure that the key
+		// ownership proof is properly checked, otherwise since the state
+		// is still available the historical module will just check
+		// against current session data.
+		start_era(2);
+
+		assert_err!(
+			Babe::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof),
+				key_owner_proof,
+			),
+			Error::<Test>::InvalidKeyOwnershipProof,
+		);
+	})
+}
+
+#[test]
+fn report_equivocation_invalid_equivocation_proof() {
+	use sp_runtime::traits::Header;
+
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	ext.execute_with(|| {
+		start_era(1);
+
+		let authorities = Babe::authorities();
+
+		// we will use the validator at index 0 as the offending authority
+		let offending_validator_index = 0;
+		let offending_authority_pair = pairs
+			.into_iter()
+			.find(|p| p.public() == authorities[offending_validator_index].0)
+			.unwrap();
+
+		// create the key ownership proof
+		let key = (sp_consensus_babe::KEY_TYPE, &offending_authority_pair.public());
+		let key_owner_proof = Historical::prove(key).unwrap();
+
+		let assert_invalid_equivocation = |equivocation_proof| {
+			assert_err!(
+				Babe::report_equivocation_unsigned(
+					RuntimeOrigin::none(),
+					Box::new(equivocation_proof),
+					key_owner_proof.clone(),
+				),
+				Error::<Test>::InvalidEquivocationProof,
+			)
+		};
+
+		// both headers have the same hash, no equivocation.
+		let mut equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+		equivocation_proof.second_header = equivocation_proof.first_header.clone();
+		assert_invalid_equivocation(equivocation_proof);
+
+		// missing pre-runtime digest from one header
+		let mut equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+		equivocation_proof.first_header.digest_mut().logs.remove(0);
+		assert_invalid_equivocation(equivocation_proof);
+
+		// missing seal from one header
+		let mut equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+		equivocation_proof.first_header.digest_mut().logs.remove(1);
+		assert_invalid_equivocation(equivocation_proof);
+
+		// invalid slot number in proof compared to runtime digest
+		let mut equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+		equivocation_proof.slot = Slot::from(0);
+		assert_invalid_equivocation(equivocation_proof.clone());
+
+		// different slot numbers in headers
+		let h1 = equivocation_proof.first_header;
+		let mut equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get() + 1,
+		);
+
+		// use the header from the previous equivocation generated
+		// at the previous slot
+		equivocation_proof.first_header = h1.clone();
+
+		assert_invalid_equivocation(equivocation_proof.clone());
+
+		// invalid seal signature
+		let mut equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get() + 1,
+		);
+
+		// replace the seal digest with the digest from the
+		// previous header at the previous slot
+		equivocation_proof.first_header.digest_mut().pop();
+		equivocation_proof
+			.first_header
+			.digest_mut()
+			.push(h1.digest().logs().last().unwrap().clone());
+
+		assert_invalid_equivocation(equivocation_proof.clone());
+	})
+}
+
+#[test]
+fn report_equivocation_validate_unsigned_prevents_duplicates() {
+	use sp_runtime::transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
+		ValidTransaction,
+	};
+
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	ext.execute_with(|| {
+		start_era(1);
+
+		let authorities = Babe::authorities();
+
+		// generate and report an equivocation for the validator at index 0
+		let offending_validator_index = 0;
+		let offending_authority_pair = pairs
+			.into_iter()
+			.find(|p| p.public() == authorities[offending_validator_index].0)
+			.unwrap();
+
+		let equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+
+		let key = (sp_consensus_babe::KEY_TYPE, &offending_authority_pair.public());
+		let key_owner_proof = Historical::prove(key).unwrap();
+
+		let inner = Call::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof.clone()),
+			key_owner_proof: key_owner_proof.clone(),
+		};
+
+		// only local/inblock reports are allowed
+		assert_eq!(
+			<Babe as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::External,
+				&inner,
+			),
+			InvalidTransaction::Call.into(),
+		);
+
+		// the transaction is valid when passed as local
+		let tx_tag = (offending_authority_pair.public(), CurrentSlot::<Test>::get());
+		assert_eq!(
+			<Babe as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&inner,
+			),
+			TransactionValidity::Ok(ValidTransaction {
+				priority: TransactionPriority::max_value(),
+				requires: vec![],
+				provides: vec![("BabeEquivocation", tx_tag).encode()],
+				longevity: ReportLongevity::get(),
+				propagate: false,
+			})
+		);
+
+		// the pre dispatch checks should also pass
+		assert_ok!(<Babe as sp_runtime::traits::ValidateUnsigned>::pre_dispatch(&inner));
+
+		// we submit the report
+		Babe::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.unwrap();
+
+		// the report should now be considered stale and the transaction is invalid.
+		// the check for staleness should be done on both `validate_unsigned` and on `pre_dispatch`
+		assert_err!(
+			<Babe as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&inner,
+			),
+			InvalidTransaction::Stale,
+		);
+
+		assert_err!(
+			<Babe as sp_runtime::traits::ValidateUnsigned>::pre_dispatch(&inner),
+			InvalidTransaction::Stale,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_has_valid_weight() {
+	// the weight depends on the size of the validator set,
+	// but there's a lower bound of 100 validators.
+	assert!((1..=100)
+		.map(|validators| <Test as Config>::WeightInfo::report_equivocation(validators, 1000))
+		.collect::<Vec<_>>()
+		.windows(2)
+		.all(|w| w[0] == w[1]));
+
+	// after 100 validators the weight should keep increasing
+	// with every extra validator.
+	assert!((100..=1000)
+		.map(|validators| <Test as Config>::WeightInfo::report_equivocation(validators, 1000))
+		.collect::<Vec<_>>()
+		.windows(2)
+		.all(|w| w[0].ref_time() < w[1].ref_time()));
+}
+
+#[test]
+fn report_equivocation_after_skipped_epochs_works() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	ext.execute_with(|| {
+		let epoch_duration: u64 = <Test as Config>::EpochDuration::get();
+
+		// this sets the genesis slot to 100;
+		let genesis_slot = 100;
+		go_to_block(1, genesis_slot);
+		assert_eq!(EpochIndex::<Test>::get(), 0);
+
+		// skip from epoch #0 to epoch #10
+		go_to_block(System::block_number() + 1, genesis_slot + epoch_duration * 10);
+
+		assert_eq!(EpochIndex::<Test>::get(), 10);
+		assert_eq!(SkippedEpochs::<Test>::get(), vec![(10, 1)]);
+
+		// generate an equivocation proof for validator at index 1
+		let authorities = Babe::authorities();
+		let offending_validator_index = 1;
+		let offending_authority_pair = pairs
+			.into_iter()
+			.find(|p| p.public() == authorities[offending_validator_index].0)
+			.unwrap();
+
+		let equivocation_proof = generate_equivocation_proof(
+			offending_validator_index as u32,
+			&offending_authority_pair,
+			CurrentSlot::<Test>::get(),
+		);
+
+		// create the key ownership proof
+		let key = (sp_consensus_babe::KEY_TYPE, &offending_authority_pair.public());
+		let key_owner_proof = Historical::prove(key).unwrap();
+
+		// which is for session index 1 (while current epoch index is 10)
+		assert_eq!(key_owner_proof.session, 1);
+
+		// report the equivocation, in order for the validation to pass the mapping
+		// between epoch index and session index must be checked.
+		assert!(Babe::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof
+		)
+		.is_ok());
+	})
+}
+
+#[test]
+fn valid_equivocation_reports_dont_pay_fees() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	ext.execute_with(|| {
+		start_era(1);
+
+		let offending_authority_pair = &pairs[0];
+
+		// generate an equivocation proof.
+		let equivocation_proof =
+			generate_equivocation_proof(0, &offending_authority_pair, CurrentSlot::<Test>::get());
+
+		// create the key ownership proof.
+		let key_owner_proof =
+			Historical::prove((sp_consensus_babe::KEY_TYPE, &offending_authority_pair.public()))
+				.unwrap();
+
+		// check the dispatch info for the call.
+		let info = Call::<Test>::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof.clone()),
+			key_owner_proof: key_owner_proof.clone(),
+		}
+		.get_dispatch_info();
+
+		// it should have non-zero weight and the fee has to be paid.
+		// TODO: account for proof size weight
+		assert!(info.weight.ref_time() > 0);
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// report the equivocation.
+		let post_info = Babe::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof.clone()),
+			key_owner_proof.clone(),
+		)
+		.unwrap();
+
+		// the original weight should be kept, but given that the report
+		// is valid the fee is waived.
+		assert!(post_info.actual_weight.is_none());
+		assert_eq!(post_info.pays_fee, Pays::No);
+
+		// report the equivocation again which is invalid now since it is
+		// duplicate.
+		let post_info = Babe::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.err()
+		.unwrap()
+		.post_info;
+
+		// the fee is not waived and the original weight is kept.
+		assert!(post_info.actual_weight.is_none());
+		assert_eq!(post_info.pays_fee, Pays::Yes);
+	})
+}
+
+#[test]
+fn add_epoch_configurations_migration_works() {
+	use frame_support::storage::migration::{get_storage_value, put_storage_value};
+
+	impl crate::migrations::BabePalletPrefix for Test {
+		fn pallet_prefix() -> &'static str {
+			"Babe"
+		}
+	}
+
+	new_test_ext(1).execute_with(|| {
+		let next_config_descriptor =
+			NextConfigDescriptor::V1 { c: (3, 4), allowed_slots: AllowedSlots::PrimarySlots };
+
+		put_storage_value(b"Babe", b"NextEpochConfig", &[], Some(next_config_descriptor.clone()));
+
+		assert!(get_storage_value::<Option<NextConfigDescriptor>>(
+			b"Babe",
+			b"NextEpochConfig",
+			&[],
+		)
+		.is_some());
+
+		let current_epoch = BabeEpochConfiguration {
+			c: (1, 4),
+			allowed_slots: sp_consensus_babe::AllowedSlots::PrimarySlots,
+		};
+
+		crate::migrations::add_epoch_configuration::<Test>(current_epoch.clone());
+
+		assert!(get_storage_value::<Option<NextConfigDescriptor>>(
+			b"Babe",
+			b"NextEpochConfig",
+			&[],
+		)
+		.is_none());
+
+		assert_eq!(EpochConfig::<Test>::get(), Some(current_epoch));
+		assert_eq!(PendingEpochConfigChange::<Test>::get(), Some(next_config_descriptor));
+	});
+}
+
+#[test]
+fn generate_equivocation_report_blob() {
+	let (pairs, mut ext) = new_test_ext_with_pairs(3);
+
+	let offending_authority_index = 0;
+	let offending_authority_pair = &pairs[0];
+
+	ext.execute_with(|| {
+		start_era(1);
+
+		let equivocation_proof = generate_equivocation_proof(
+			offending_authority_index,
+			offending_authority_pair,
+			CurrentSlot::<Test>::get() + 1,
+		);
+
+		println!("equivocation_proof: {:?}", equivocation_proof);
+		println!("equivocation_proof.encode(): {:?}", equivocation_proof.encode());
+	});
+}
+
+#[test]
+fn skipping_over_epochs_works() {
+	let mut ext = new_test_ext(3);
+
+	ext.execute_with(|| {
+		let epoch_duration: u64 = <Test as Config>::EpochDuration::get();
+
+		// this sets the genesis slot to 100;
+		let genesis_slot = 100;
+		go_to_block(1, genesis_slot);
+
+		// we will author all blocks from epoch #0 and arrive at a point where
+		// we are in epoch #1. we should already have the randomness ready that
+		// will be used in epoch #2
+		progress_to_block(epoch_duration + 1);
+		assert_eq!(EpochIndex::<Test>::get(), 1);
+
+		// genesis randomness is an array of zeros
+		let randomness_for_epoch_2 = NextRandomness::<Test>::get();
+		assert!(randomness_for_epoch_2 != [0; 32]);
+
+		// we will now create a block for a slot that is part of epoch #4.
+		// we should appropriately increment the epoch index as well as re-use
+		// the randomness from epoch #2 on epoch #4
+		go_to_block(System::block_number() + 1, genesis_slot + epoch_duration * 4);
+
+		assert_eq!(EpochIndex::<Test>::get(), 4);
+		assert_eq!(Randomness::<Test>::get(), randomness_for_epoch_2);
+
+		// after skipping epochs the information is registered on-chain so that
+		// we can map epochs to sessions
+		assert_eq!(SkippedEpochs::<Test>::get(), vec![(4, 2)]);
+
+		// before epochs are skipped the mapping should be one to one
+		assert_eq!(Babe::session_index_for_epoch(0), 0);
+		assert_eq!(Babe::session_index_for_epoch(1), 1);
+
+		// otherwise the session index is offset by the number of skipped epochs
+		assert_eq!(Babe::session_index_for_epoch(4), 2);
+		assert_eq!(Babe::session_index_for_epoch(5), 3);
+	});
+}
diff --git a/substrate/frame/bags-list/Cargo.toml b/substrate/frame/bags-list/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..aeb0a6c50b92267a1e96d3a957f4a75f18e90088
--- /dev/null
+++ b/substrate/frame/bags-list/Cargo.toml
@@ -0,0 +1,89 @@
+[package]
+name = "pallet-bags-list"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet bags list"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+# parity
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+# primitives
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+# FRAME
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+frame-election-provider-support = { version = "4.0.0-dev", default-features = false, path = "../election-provider-support" }
+
+# third party
+log = { version = "0.4.17", default-features = false }
+docify = "0.2.1"
+aquamarine = { version = "0.3.2" }
+
+# Optional imports for benchmarking
+frame-benchmarking = { version = "4.0.0-dev", path = "../benchmarking", optional = true, default-features = false }
+pallet-balances = { version = "4.0.0-dev", path = "../balances", optional = true, default-features = false }
+sp-core = { version = "21.0.0", path = "../../primitives/core", optional = true, default-features = false }
+sp-io = { version = "23.0.0", path = "../../primitives/io", optional = true, default-features = false }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing", optional = true, default-features = false }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core"}
+sp-io = { version = "23.0.0", path = "../../primitives/io"}
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
+frame-benchmarking = { version = "4.0.0-dev", path = "../benchmarking" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances?/std",
+	"scale-info/std",
+	"sp-core?/std",
+	"sp-io?/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-tracing?/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-core",
+	"sp-io",
+	"sp-runtime/runtime-benchmarks",
+	"sp-tracing",
+]
+fuzz = [
+	"frame-election-provider-support/fuzz",
+	"pallet-balances",
+	"sp-core",
+	"sp-io",
+	"sp-tracing",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances?/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/bags-list/fuzzer/.gitignore b/substrate/frame/bags-list/fuzzer/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3ebcb104d4a50a19959dc7ff2bc06ee6bb48b31f
--- /dev/null
+++ b/substrate/frame/bags-list/fuzzer/.gitignore
@@ -0,0 +1,2 @@
+hfuzz_target
+hfuzz_workspace
diff --git a/substrate/frame/bags-list/fuzzer/Cargo.toml b/substrate/frame/bags-list/fuzzer/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fc2334bea5ca71c446b87b4833296257d57a5b6e
--- /dev/null
+++ b/substrate/frame/bags-list/fuzzer/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "pallet-bags-list-fuzzer"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Fuzzer for FRAME pallet bags list"
+publish = false
+
+[dependencies]
+honggfuzz = "0.5"
+rand = { version = "0.8", features = ["std", "small_rng"] }
+frame-election-provider-support = { version = "4.0.0-dev", features = ["fuzz"], path = "../../election-provider-support" }
+pallet-bags-list = { version = "4.0.0-dev", features = ["fuzz"], path = ".." }
+
+[[bin]]
+name = "bags-list"
+path = "src/main.rs"
diff --git a/substrate/frame/bags-list/fuzzer/src/main.rs b/substrate/frame/bags-list/fuzzer/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..18391bbb3c9a538ffdb8b055f85078eacd858a3c
--- /dev/null
+++ b/substrate/frame/bags-list/fuzzer/src/main.rs
@@ -0,0 +1,94 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run bags-list`. `honggfuzz` CLI options can
+//! be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug fixed_point hfuzz_workspace/bags_list/*.fuzz`.
+//!
+//! # More information
+//! More information about `honggfuzz` can be found
+//! [here](https://docs.rs/honggfuzz/).
+
+use frame_election_provider_support::{SortedListProvider, VoteWeight};
+use honggfuzz::fuzz;
+use pallet_bags_list::mock::{AccountId, BagsList, ExtBuilder};
+
+const ID_RANGE: AccountId = 25_000;
+
+/// Actions of a `SortedListProvider` that we fuzz.
+enum Action {
+	Insert,
+	Update,
+	Remove,
+}
+
+impl From<u32> for Action {
+	fn from(v: u32) -> Self {
+		let num_variants = Self::Remove as u32 + 1;
+		match v % num_variants {
+			_x if _x == Action::Insert as u32 => Action::Insert,
+			_x if _x == Action::Update as u32 => Action::Update,
+			_x if _x == Action::Remove as u32 => Action::Remove,
+			_ => unreachable!(),
+		}
+	}
+}
+
+fn main() {
+	ExtBuilder::default().build_and_execute(|| loop {
+		fuzz!(|data: (AccountId, VoteWeight, u32)| {
+			let (account_id_seed, vote_weight, action_seed) = data;
+
+			let id = account_id_seed % ID_RANGE;
+			let action = Action::from(action_seed);
+
+			match action {
+				Action::Insert => {
+					if BagsList::on_insert(id, vote_weight).is_err() {
+						// this was a duplicate id, which is ok. We can just update it.
+						BagsList::on_update(&id, vote_weight).unwrap();
+					}
+					assert!(BagsList::contains(&id));
+				},
+				Action::Update => {
+					let already_contains = BagsList::contains(&id);
+					if already_contains {
+						BagsList::on_update(&id, vote_weight).unwrap();
+						assert!(BagsList::contains(&id));
+					} else {
+						BagsList::on_update(&id, vote_weight).unwrap_err();
+					}
+				},
+				Action::Remove => {
+					let already_contains = BagsList::contains(&id);
+					if already_contains {
+						BagsList::on_remove(&id).unwrap();
+					} else {
+						BagsList::on_remove(&id).unwrap_err();
+					}
+					assert!(!BagsList::contains(&id));
+				},
+			}
+
+			assert!(BagsList::do_try_state().is_ok());
+		})
+	});
+}
diff --git a/substrate/frame/bags-list/remote-tests/Cargo.toml b/substrate/frame/bags-list/remote-tests/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..832a11d29d89ea6e0614ff66fcc161d67df78cbd
--- /dev/null
+++ b/substrate/frame/bags-list/remote-tests/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "pallet-bags-list-remote-tests"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet bags list remote test"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+# frame
+pallet-staking = { path = "../../staking", version = "4.0.0-dev" }
+pallet-bags-list = { path = "../../bags-list", version = "4.0.0-dev", features = ["fuzz"] }
+frame-election-provider-support = { path = "../../election-provider-support", version = "4.0.0-dev" }
+frame-system = { path = "../../system", version = "4.0.0-dev" }
+frame-support = { path = "../../support", version = "4.0.0-dev" }
+
+# core
+sp-storage = { path = "../../../primitives/storage", version = "13.0.0" }
+sp-core = { path = "../../../primitives/core", version = "21.0.0" }
+sp-tracing = { path = "../../../primitives/tracing", version = "10.0.0" }
+sp-runtime = { path = "../../../primitives/runtime", version = "24.0.0" }
+sp-std = { path = "../../../primitives/std", version = "8.0.0" }
+
+# utils
+remote-externalities = { path = "../../../utils/frame/remote-externalities", version = "0.10.0-dev", package = "frame-remote-externalities" }
+
+# others
+log = "0.4.17"
diff --git a/substrate/frame/bags-list/remote-tests/src/lib.rs b/substrate/frame/bags-list/remote-tests/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9f7c22d99dad1edf798259b784e91f90fe339104
--- /dev/null
+++ b/substrate/frame/bags-list/remote-tests/src/lib.rs
@@ -0,0 +1,160 @@
+// 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.
+
+//! Utilities for remote-testing pallet-bags-list.
+
+use frame_election_provider_support::ScoreProvider;
+use pallet_bags_list::Instance1;
+use sp_std::prelude::*;
+
+/// A common log target to use.
+pub const LOG_TARGET: &str = "runtime::bags-list::remote-tests";
+
+pub mod migration;
+pub mod snapshot;
+pub mod try_state;
+
+/// A wrapper for a runtime that the functions of this crate expect.
+///
+/// For example, this can be the `Runtime` type of the Polkadot runtime.
+pub trait RuntimeT<I: 'static>:
+	pallet_staking::Config + pallet_bags_list::Config<I> + frame_system::Config
+{
+}
+impl<
+		I: 'static,
+		T: pallet_staking::Config + pallet_bags_list::Config<I> + frame_system::Config,
+	> RuntimeT<I> for T
+{
+}
+
+fn percent(portion: u32, total: u32) -> f64 {
+	(portion as f64 / total as f64) * 100f64
+}
+
+/// Display the number of nodes in each bag, while identifying those that need a rebag.
+pub fn display_and_check_bags<Runtime: RuntimeT<Instance1>>(
+	currency_unit: u64,
+	currency_name: &'static str,
+) {
+	use frame_election_provider_support::SortedListProvider;
+	use frame_support::traits::Get;
+
+	let min_nominator_bond = <pallet_staking::MinNominatorBond<Runtime>>::get();
+	log::info!(target: LOG_TARGET, "min nominator bond is {:?}", min_nominator_bond);
+
+	let voter_list_count = <Runtime as pallet_staking::Config>::VoterList::count();
+
+	// go through every bag to track the total number of voters within bags and log some info about
+	// how voters are distributed within the bags.
+	let mut seen_in_bags = 0;
+	let mut rebaggable = 0;
+	let mut active_bags = 0;
+	for vote_weight_thresh in <Runtime as pallet_bags_list::Config<Instance1>>::BagThresholds::get()
+	{
+		let vote_weight_thresh_u64: u64 = (*vote_weight_thresh)
+			.try_into()
+			.map_err(|_| "runtime must configure score to at most u64 to use this test")
+			.unwrap();
+		// threshold in terms of UNITS (e.g. KSM, DOT etc)
+		let vote_weight_thresh_as_unit = vote_weight_thresh_u64 as f64 / currency_unit as f64;
+		let pretty_thresh = format!("Threshold: {}. {}", vote_weight_thresh_as_unit, currency_name);
+
+		let bag = match pallet_bags_list::Pallet::<Runtime, Instance1>::list_bags_get(
+			*vote_weight_thresh,
+		) {
+			Some(bag) => bag,
+			None => {
+				log::info!(target: LOG_TARGET, "{} NO VOTERS.", pretty_thresh);
+				continue
+			},
+		};
+
+		active_bags += 1;
+
+		for id in bag.std_iter().map(|node| node.std_id().clone()) {
+			let vote_weight =
+				<Runtime as pallet_bags_list::Config<Instance1>>::ScoreProvider::score(&id);
+			let vote_weight_thresh_u64: u64 = (*vote_weight_thresh)
+				.try_into()
+				.map_err(|_| "runtime must configure score to at most u64 to use this test")
+				.unwrap();
+			let vote_weight_as_balance: pallet_staking::BalanceOf<Runtime> =
+				vote_weight_thresh_u64.try_into().map_err(|_| "can't convert").unwrap();
+
+			if vote_weight_as_balance < min_nominator_bond {
+				log::trace!(
+					target: LOG_TARGET,
+					"⚠� {} Account found below min bond: {:?}.",
+					pretty_thresh,
+					id
+				);
+			}
+
+			let node = pallet_bags_list::Node::<Runtime, Instance1>::get(&id)
+				.expect("node in bag must exist.");
+			if node.is_misplaced(vote_weight) {
+				rebaggable += 1;
+				let notional_bag = pallet_bags_list::notional_bag_for::<Runtime, _>(vote_weight);
+				let notional_bag_as_u64: u64 = notional_bag
+					.try_into()
+					.map_err(|_| "runtime must configure score to at most u64 to use this test")
+					.unwrap();
+				log::trace!(
+					target: LOG_TARGET,
+					"Account {:?} can be rebagged from {:?} to {:?}",
+					id,
+					vote_weight_thresh_as_unit,
+					notional_bag_as_u64 as f64 / currency_unit as f64
+				);
+			}
+		}
+
+		// update our overall counter
+		let voters_in_bag = bag.std_iter().count() as u32;
+		seen_in_bags += voters_in_bag;
+
+		// percentage of all nominators
+		let percent_of_voters = percent(voters_in_bag, voter_list_count);
+
+		log::info!(
+			target: LOG_TARGET,
+			"{} Nominators: {} [%{:.3}]",
+			pretty_thresh,
+			voters_in_bag,
+			percent_of_voters,
+		);
+	}
+
+	if seen_in_bags != voter_list_count {
+		log::error!(
+			target: LOG_TARGET,
+			"bags list population ({}) not on par whoever is voter_list ({})",
+			seen_in_bags,
+			voter_list_count,
+		)
+	}
+
+	log::info!(
+		target: LOG_TARGET,
+		"a total of {} nodes are in {} active bags [{} total bags], {} of which can be rebagged.",
+		voter_list_count,
+		active_bags,
+		<Runtime as pallet_bags_list::Config<Instance1>>::BagThresholds::get().len(),
+		rebaggable,
+	);
+}
diff --git a/substrate/frame/bags-list/remote-tests/src/migration.rs b/substrate/frame/bags-list/remote-tests/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7847fdc7591c0195ec1922b7f730ff18535ca03e
--- /dev/null
+++ b/substrate/frame/bags-list/remote-tests/src/migration.rs
@@ -0,0 +1,67 @@
+// Copyright 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/>.
+
+//! Test to check the migration of the voter bag.
+
+use crate::{RuntimeT, LOG_TARGET};
+use frame_support::traits::PalletInfoAccess;
+use pallet_staking::Nominators;
+use remote_externalities::{Builder, Mode, OnlineConfig};
+use sp_runtime::{traits::Block as BlockT, DeserializeOwned};
+
+/// Test voter bags migration. `currency_unit` is the number of planks per the the runtimes `UNITS`
+/// (i.e. number of decimal places per DOT, KSM etc)
+pub async fn execute<Runtime, Block>(
+	currency_unit: u64,
+	currency_name: &'static str,
+	ws_url: String,
+) where
+	Runtime: RuntimeT<pallet_bags_list::Instance1>,
+	Block: BlockT + DeserializeOwned,
+	Block::Header: DeserializeOwned,
+{
+	let mut ext = Builder::<Block>::new()
+		.mode(Mode::Online(OnlineConfig {
+			transport: ws_url.to_string().into(),
+			pallets: vec![pallet_staking::Pallet::<Runtime>::name().to_string()],
+			..Default::default()
+		}))
+		.build()
+		.await
+		.unwrap();
+
+	ext.execute_with(|| {
+		// get the nominator & validator count prior to migrating; these should be invariant.
+		let pre_migrate_nominator_count = <Nominators<Runtime>>::iter().count() as u32;
+		log::info!(target: LOG_TARGET, "Nominator count: {}", pre_migrate_nominator_count);
+
+		use frame_election_provider_support::SortedListProvider;
+		// run the actual migration
+		let moved = <Runtime as pallet_staking::Config>::VoterList::unsafe_regenerate(
+			pallet_staking::Nominators::<Runtime>::iter().map(|(n, _)| n),
+			pallet_staking::Pallet::<Runtime>::weight_of_fn(),
+		);
+		log::info!(target: LOG_TARGET, "Moved {} nominators", moved);
+
+		let voter_list_len = <Runtime as pallet_staking::Config>::VoterList::iter().count() as u32;
+		let voter_list_count = <Runtime as pallet_staking::Config>::VoterList::count();
+		// and confirm it is equal to the length of the `VoterList`.
+		assert_eq!(pre_migrate_nominator_count, voter_list_len);
+		assert_eq!(pre_migrate_nominator_count, voter_list_count);
+
+		crate::display_and_check_bags::<Runtime>(currency_unit, currency_name);
+	});
+}
diff --git a/substrate/frame/bags-list/remote-tests/src/snapshot.rs b/substrate/frame/bags-list/remote-tests/src/snapshot.rs
new file mode 100644
index 0000000000000000000000000000000000000000..78c5b4e1c7b6dbf3559543c2e776a4fd89422487
--- /dev/null
+++ b/substrate/frame/bags-list/remote-tests/src/snapshot.rs
@@ -0,0 +1,100 @@
+// Copyright 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/>.
+
+//! Test to execute the snapshot using the voter bag.
+
+use frame_election_provider_support::{
+	bounds::{CountBound, DataProviderBounds},
+	SortedListProvider,
+};
+use frame_support::traits::PalletInfoAccess;
+use remote_externalities::{Builder, Mode, OnlineConfig};
+use sp_runtime::{traits::Block as BlockT, DeserializeOwned};
+
+/// Execute create a snapshot from pallet-staking.
+pub async fn execute<Runtime, Block>(voter_limit: Option<usize>, currency_unit: u64, ws_url: String)
+where
+	Runtime: crate::RuntimeT<pallet_bags_list::Instance1>,
+	Block: BlockT + DeserializeOwned,
+	Block::Header: DeserializeOwned,
+{
+	use frame_support::storage::generator::StorageMap;
+
+	let mut ext = Builder::<Block>::new()
+		.mode(Mode::Online(OnlineConfig {
+			transport: ws_url.to_string().into(),
+			// NOTE: we don't scrape pallet-staking, this kinda ensures that the source of the data
+			// is bags-list.
+			pallets: vec![pallet_bags_list::Pallet::<Runtime, pallet_bags_list::Instance1>::name()
+				.to_string()],
+			at: None,
+			hashed_prefixes: vec![
+				<pallet_staking::Bonded<Runtime>>::prefix_hash(),
+				<pallet_staking::Ledger<Runtime>>::prefix_hash(),
+				<pallet_staking::Validators<Runtime>>::map_storage_final_prefix(),
+				<pallet_staking::Nominators<Runtime>>::map_storage_final_prefix(),
+			],
+			hashed_keys: vec![
+				<pallet_staking::Validators<Runtime>>::counter_storage_final_key().to_vec(),
+				<pallet_staking::Nominators<Runtime>>::counter_storage_final_key().to_vec(),
+			],
+			..Default::default()
+		}))
+		.build()
+		.await
+		.unwrap();
+
+	ext.execute_with(|| {
+		use frame_election_provider_support::ElectionDataProvider;
+		log::info!(
+			target: crate::LOG_TARGET,
+			"{} nodes in bags list.",
+			<Runtime as pallet_staking::Config>::VoterList::count(),
+		);
+
+		let bounds = match voter_limit {
+			None => DataProviderBounds::default(),
+			Some(v) => DataProviderBounds { count: Some(CountBound(v as u32)), size: None },
+		};
+
+		let voters =
+			<pallet_staking::Pallet<Runtime> as ElectionDataProvider>::electing_voters(bounds)
+				.unwrap();
+
+		let mut voters_nominator_only = voters
+			.iter()
+			.filter(|(v, _, _)| pallet_staking::Nominators::<Runtime>::contains_key(v))
+			.cloned()
+			.collect::<Vec<_>>();
+		voters_nominator_only.sort_by_key(|(_, w, _)| *w);
+
+		let currency_unit = currency_unit as f64;
+		let min_voter = voters_nominator_only
+			.first()
+			.map(|(x, y, _)| (x.clone(), *y as f64 / currency_unit));
+		let max_voter = voters_nominator_only
+			.last()
+			.map(|(x, y, _)| (x.clone(), *y as f64 / currency_unit));
+		log::info!(
+			target: crate::LOG_TARGET,
+			"a snapshot with limit {:?} has been created, {} voters are taken. min nominator: {:?}, max: {:?}",
+			voter_limit,
+			voters.len(),
+			min_voter,
+			max_voter
+		);
+	});
+}
diff --git a/substrate/frame/bags-list/remote-tests/src/try_state.rs b/substrate/frame/bags-list/remote-tests/src/try_state.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5bbac00bc75abd9610b95a4d2d44019c808201d5
--- /dev/null
+++ b/substrate/frame/bags-list/remote-tests/src/try_state.rs
@@ -0,0 +1,60 @@
+// Copyright 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/>.
+
+//! Test to execute the sanity-check of the voter bag.
+
+use frame_support::{
+	storage::generator::StorageMap,
+	traits::{Get, PalletInfoAccess},
+};
+use remote_externalities::{Builder, Mode, OnlineConfig};
+use sp_runtime::{traits::Block as BlockT, DeserializeOwned};
+
+/// Execute the sanity check of the bags-list.
+pub async fn execute<Runtime, Block>(
+	currency_unit: u64,
+	currency_name: &'static str,
+	ws_url: String,
+) where
+	Runtime: crate::RuntimeT<pallet_bags_list::Instance1>,
+	Block: BlockT + DeserializeOwned,
+	Block::Header: DeserializeOwned,
+{
+	let mut ext = Builder::<Block>::new()
+		.mode(Mode::Online(OnlineConfig {
+			transport: ws_url.to_string().into(),
+			pallets: vec![pallet_bags_list::Pallet::<Runtime, pallet_bags_list::Instance1>::name()
+				.to_string()],
+			hashed_prefixes: vec![
+				<pallet_staking::Bonded<Runtime>>::prefix_hash(),
+				<pallet_staking::Ledger<Runtime>>::prefix_hash(),
+			],
+			..Default::default()
+		}))
+		.build()
+		.await
+		.unwrap();
+
+	ext.execute_with(|| {
+		sp_core::crypto::set_default_ss58_version(Runtime::SS58Prefix::get().try_into().unwrap());
+
+		pallet_bags_list::Pallet::<Runtime, pallet_bags_list::Instance1>::do_try_state().unwrap();
+
+		log::info!(target: crate::LOG_TARGET, "executed bags-list sanity check with no errors.");
+
+		crate::display_and_check_bags::<Runtime>(currency_unit, currency_name);
+	});
+}
diff --git a/substrate/frame/bags-list/src/benchmarks.rs b/substrate/frame/bags-list/src/benchmarks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0c3955c0d7b79882b4fa97fe18ba0988fcc7d2af
--- /dev/null
+++ b/substrate/frame/bags-list/src/benchmarks.rs
@@ -0,0 +1,196 @@
+// 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.
+
+//! Benchmarks for the bags list pallet.
+
+use super::*;
+use crate::list::List;
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelist_account, whitelisted_caller,
+};
+use frame_election_provider_support::ScoreProvider;
+use frame_support::{assert_ok, traits::Get};
+use frame_system::RawOrigin as SystemOrigin;
+use sp_runtime::traits::One;
+
+benchmarks_instance_pallet! {
+	rebag_non_terminal {
+		// An expensive case for rebag-ing (rebag a non-terminal node):
+		//
+		// - The node to be rebagged, _R_, should exist as a non-terminal node in a bag with at
+		//   least 2 other nodes. Thus _R_ will have both its `prev` and `next` nodes updated when
+		//   it is removed. (3 W/R)
+		// - The destination bag is not empty, thus we need to update the `next` pointer of the last
+		//   node in the destination in addition to the work we do otherwise. (2 W/R)
+
+		// clear any pre-existing storage.
+		// NOTE: safe to call outside block production
+		List::<T, _>::unsafe_clear();
+
+		// define our origin and destination thresholds.
+		let origin_bag_thresh = T::BagThresholds::get()[0];
+		let dest_bag_thresh = T::BagThresholds::get()[1];
+
+		// seed items in the origin bag.
+		let origin_head: T::AccountId = account("origin_head", 0, 0);
+		assert_ok!(List::<T, _>::insert(origin_head.clone(), origin_bag_thresh));
+
+		let origin_middle: T::AccountId = account("origin_middle", 0, 0); // the node we rebag (_R_)
+		assert_ok!(List::<T, _>::insert(origin_middle.clone(), origin_bag_thresh));
+
+		let origin_tail: T::AccountId  = account("origin_tail", 0, 0);
+		assert_ok!(List::<T, _>::insert(origin_tail.clone(), origin_bag_thresh));
+
+		// seed items in the destination bag.
+		let dest_head: T::AccountId  = account("dest_head", 0, 0);
+		assert_ok!(List::<T, _>::insert(dest_head.clone(), dest_bag_thresh));
+
+		let origin_middle_lookup = T::Lookup::unlookup(origin_middle.clone());
+
+		// the bags are in the expected state after initial setup.
+		assert_eq!(
+			List::<T, _>::get_bags(),
+			vec![
+				(origin_bag_thresh, vec![origin_head.clone(), origin_middle.clone(), origin_tail.clone()]),
+				(dest_bag_thresh, vec![dest_head.clone()])
+			]
+		);
+
+		let caller = whitelisted_caller();
+		// update the weight of `origin_middle` to guarantee it will be rebagged into the destination.
+		T::ScoreProvider::set_score_of(&origin_middle, dest_bag_thresh);
+	}: rebag(SystemOrigin::Signed(caller), origin_middle_lookup.clone())
+	verify {
+		// check the bags have updated as expected.
+		assert_eq!(
+			List::<T, _>::get_bags(),
+			vec![
+				(
+					origin_bag_thresh,
+					vec![origin_head, origin_tail],
+				),
+				(
+					dest_bag_thresh,
+					vec![dest_head, origin_middle],
+				)
+			]
+		);
+	}
+
+	rebag_terminal {
+		// An expensive case for rebag-ing (rebag a terminal node):
+		//
+		// - The node to be rebagged, _R_, is a terminal node; so _R_, the node pointing to _R_ and
+		//   the origin bag itself will need to be updated. (3 W/R)
+		// - The destination bag is not empty, thus we need to update the `next` pointer of the last
+		//   node in the destination in addition to the work we do otherwise. (2 W/R)
+
+		// clear any pre-existing storage.
+		// NOTE: safe to call outside block production
+		List::<T, I>::unsafe_clear();
+
+		// define our origin and destination thresholds.
+		let origin_bag_thresh = T::BagThresholds::get()[0];
+		let dest_bag_thresh = T::BagThresholds::get()[1];
+
+		// seed items in the origin bag.
+		let origin_head: T::AccountId = account("origin_head", 0, 0);
+		assert_ok!(List::<T, _>::insert(origin_head.clone(), origin_bag_thresh));
+
+		let origin_tail: T::AccountId  = account("origin_tail", 0, 0); // the node we rebag (_R_)
+		assert_ok!(List::<T, _>::insert(origin_tail.clone(), origin_bag_thresh));
+
+		// seed items in the destination bag.
+		let dest_head: T::AccountId  = account("dest_head", 0, 0);
+		assert_ok!(List::<T, _>::insert(dest_head.clone(), dest_bag_thresh));
+
+		let origin_tail_lookup = T::Lookup::unlookup(origin_tail.clone());
+
+		// the bags are in the expected state after initial setup.
+		assert_eq!(
+			List::<T, _>::get_bags(),
+			vec![
+				(origin_bag_thresh, vec![origin_head.clone(), origin_tail.clone()]),
+				(dest_bag_thresh, vec![dest_head.clone()])
+			]
+		);
+
+		let caller = whitelisted_caller();
+		// update the weight of `origin_tail` to guarantee it will be rebagged into the destination.
+		T::ScoreProvider::set_score_of(&origin_tail, dest_bag_thresh);
+	}: rebag(SystemOrigin::Signed(caller), origin_tail_lookup.clone())
+	verify {
+		// check the bags have updated as expected.
+		assert_eq!(
+			List::<T, _>::get_bags(),
+			vec![
+				(origin_bag_thresh, vec![origin_head.clone()]),
+				(dest_bag_thresh, vec![dest_head.clone(), origin_tail])
+			]
+		);
+	}
+
+	put_in_front_of {
+		// The most expensive case for `put_in_front_of`:
+		//
+		// - both heavier's `prev` and `next` are nodes that will need to be read and written.
+		// - `lighter` is the bag's `head`, so the bag will need to be read and written.
+
+		// clear any pre-existing storage.
+		// NOTE: safe to call outside block production
+		List::<T, I>::unsafe_clear();
+
+		let bag_thresh = T::BagThresholds::get()[0];
+
+		// insert the nodes in order
+		let lighter: T::AccountId = account("lighter", 0, 0);
+		assert_ok!(List::<T, _>::insert(lighter.clone(), bag_thresh));
+
+		let heavier_prev: T::AccountId = account("heavier_prev", 0, 0);
+		assert_ok!(List::<T, _>::insert(heavier_prev.clone(), bag_thresh));
+
+		let heavier: T::AccountId = account("heavier", 0, 0);
+		assert_ok!(List::<T, _>::insert(heavier.clone(), bag_thresh));
+
+		let heavier_next: T::AccountId = account("heavier_next", 0, 0);
+		assert_ok!(List::<T, _>::insert(heavier_next.clone(), bag_thresh));
+
+		T::ScoreProvider::set_score_of(&lighter, bag_thresh - One::one());
+		T::ScoreProvider::set_score_of(&heavier, bag_thresh);
+
+		let lighter_lookup = T::Lookup::unlookup(lighter.clone());
+
+		assert_eq!(
+			List::<T, _>::iter().map(|n| n.id().clone()).collect::<Vec<_>>(),
+			vec![lighter.clone(), heavier_prev.clone(), heavier.clone(), heavier_next.clone()]
+		);
+
+		whitelist_account!(heavier);
+	}: _(SystemOrigin::Signed(heavier.clone()), lighter_lookup.clone())
+	verify {
+		assert_eq!(
+			List::<T, _>::iter().map(|n| n.id().clone()).collect::<Vec<_>>(),
+			vec![heavier, lighter, heavier_prev, heavier_next]
+		)
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		crate::mock::ExtBuilder::default().skip_genesis_ids().build(),
+		crate::mock::Runtime
+	);
+}
diff --git a/substrate/frame/bags-list/src/lib.rs b/substrate/frame/bags-list/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a5d3257b734bb644b06967540a2435eec0236aa2
--- /dev/null
+++ b/substrate/frame/bags-list/src/lib.rs
@@ -0,0 +1,503 @@
+// 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.
+
+//! > Made with *Substrate*, for *Polkadot*.
+//!
+//! [![github]](https://github.com/paritytech/substrate/frame/fast-unstake) -
+//! [![polkadot]](https://polkadot.network)
+//!
+//! [polkadot]:
+//!     https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
+//! [github]:
+//!     https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//!
+//!  # Bags-List Pallet
+//!
+//! An onchain implementation of a semi-sorted linked list, with permissionless sorting and update
+//! operations.
+//!
+//! ## 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.
+//!
+//! This pallet provides an implementation of
+//! [`frame_election_provider_support::SortedListProvider`] and it can typically be used by another
+//! pallet via this API.
+//!
+//! ## Overview
+//!
+//! This pallet splits `AccountId`s into different bags. Within a bag, these `AccountId`s are stored
+//! as nodes in a linked-list manner. This pallet then provides iteration over all bags, which
+//! basically allows an infinitely large list of items to be kept in a sorted manner.
+//!
+//! Each bags has a upper and lower range of scores, denoted by [`Config::BagThresholds`]. All nodes
+//! within a bag must be within the range of the bag. If not, the permissionless [`Pallet::rebag`]
+//! can be used to move any node to the right bag.
+//!
+//! Once a `rebag` happens, the order within a node is still not enforced. To move a node to the
+//! optimal position in a bag, the [`Pallet::put_in_front_of`] or [`Pallet::put_in_front_of_other`]
+//! can be used.
+//!
+//! Additional reading, about how this pallet is used in the context of Polkadot's staking system:
+//! <https://polkadot.network/blog/staking-update-september-2021/#bags-list-in-depth>
+//!
+//! ## Examples
+//!
+//! See [`example`] for a diagram of `rebag` and `put_in_front_of` operations.
+//!
+//! ## Low Level / Implementation Details
+//!
+//! The data structure exposed by this pallet aims to be optimized for:
+//!
+//! - insertions and removals.
+//! - iteration over the top* N items by score, where the precise ordering of items doesn't
+//!   particularly matter.
+//!
+//! ### Further Details
+//!
+//! - items are kept in bags, which are delineated by their range of score (See
+//!   [`Config::BagThresholds`]).
+//! - for iteration, bags are chained together from highest to lowest and elements within the bag
+//!   are iterated from head to tail.
+//! - items within a bag are iterated in order of insertion. Thus removing an item and re-inserting
+//!   it will worsen its position in list iteration; this reduces incentives for some types of spam
+//!   that involve consistently removing and inserting for better position. Further, ordering
+//!   granularity is thus dictated by range between each bag threshold.
+//! - if an item's score changes to a value no longer within the range of its current bag the item's
+//!   position will need to be updated by an external actor with rebag (update), or removal and
+//!   insertion.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(doc)]
+#[cfg_attr(doc, aquamarine::aquamarine)]
+///
+/// In this example, assuming each node has an equal id and score (eg. node 21 has a score of 21),
+/// the node 22 can be moved from bag 1 to bag 0 with the `rebag` operation.
+///
+/// Once the whole list is iterated, assuming the above above rebag happens, the order of iteration
+/// would be: `25, 21, 22, 12, 22, 5, 7, 3`.
+///
+/// Moreover, in bag2, node 7 can be moved to the front of node 5 with the `put_in_front_of`, as it
+/// has a higher score.
+///
+/// ```mermaid
+/// graph LR
+/// 	Bag0 --> Bag1 --> Bag2
+///
+/// 	subgraph Bag0[Bag 0: 21-30 DOT]
+/// 		direction LR
+/// 		25 --> 21 --> 22X[22]
+/// 	end
+///
+/// 	subgraph Bag1[Bag 1: 11-20 DOT]
+/// 		direction LR
+/// 		12 --> 22
+/// 	end
+///
+/// 	subgraph Bag2[Bag 2: 0-10 DOT]
+/// 		direction LR
+/// 		5 --> 7 --> 3
+/// 	end
+///
+/// 	style 22X stroke-dasharray: 5 5,opacity:50%
+/// ```
+///
+/// The equivalent of this in code would be:
+#[doc = docify::embed!("src/tests.rs", examples_work)]
+pub mod example {}
+
+use codec::FullCodec;
+use frame_election_provider_support::{ScoreProvider, SortedListProvider};
+use frame_system::ensure_signed;
+use sp_runtime::traits::{AtLeast32BitUnsigned, Bounded, StaticLookup};
+use sp_std::prelude::*;
+
+#[cfg(any(test, feature = "try-runtime", feature = "fuzz"))]
+use sp_runtime::TryRuntimeError;
+
+#[cfg(any(feature = "runtime-benchmarks", test))]
+mod benchmarks;
+
+mod list;
+pub mod migrations;
+#[cfg(any(test, feature = "fuzz"))]
+pub mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+pub use list::{notional_bag_for, Bag, List, ListError, Node};
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+pub(crate) const LOG_TARGET: &str = "runtime::bags_list";
+
+// syntactic sugar for logging.
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: crate::LOG_TARGET,
+			concat!("[{:?}] 👜 [{}]", $patter),
+			<frame_system::Pallet<T>>::block_number(),
+			<crate::Pallet::<T, I> as frame_support::traits::PalletInfoAccess>::name()
+			$(, $values)*
+		)
+	};
+}
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: weights::WeightInfo;
+
+		/// Something that provides the scores of ids.
+		type ScoreProvider: ScoreProvider<Self::AccountId, Score = Self::Score>;
+
+		/// The list of thresholds separating the various bags.
+		///
+		/// Ids are separated into unsorted bags according to their score. This specifies the
+		/// thresholds separating the bags. An id's bag is the largest bag for which the id's score
+		/// is less than or equal to its upper threshold.
+		///
+		/// When ids are iterated, higher bags are iterated completely before lower bags. This means
+		/// that iteration is _semi-sorted_: ids of higher score tend to come before ids of lower
+		/// score, but peer ids within a particular bag are sorted in insertion order.
+		///
+		/// # Expressing the constant
+		///
+		/// This constant must be sorted in strictly increasing order. Duplicate items are not
+		/// permitted.
+		///
+		/// There is an implied upper limit of `Score::MAX`; that value does not need to be
+		/// specified within the bag. For any two threshold lists, if one ends with
+		/// `Score::MAX`, the other one does not, and they are otherwise equal, the two
+		/// lists will behave identically.
+		///
+		/// # Calculation
+		///
+		/// It is recommended to generate the set of thresholds in a geometric series, such that
+		/// there exists some constant ratio such that `threshold[k + 1] == (threshold[k] *
+		/// constant_ratio).max(threshold[k] + 1)` for all `k`.
+		///
+		/// The helpers in the `/utils/frame/generate-bags` module can simplify this calculation.
+		///
+		/// # Examples
+		///
+		/// - If `BagThresholds::get().is_empty()`, then all ids are put into the same bag, and
+		///   iteration is strictly in insertion order.
+		/// - If `BagThresholds::get().len() == 64`, and the thresholds are determined according to
+		///   the procedure given above, then the constant ratio is equal to 2.
+		/// - If `BagThresholds::get().len() == 200`, and the thresholds are determined according to
+		///   the procedure given above, then the constant ratio is approximately equal to 1.248.
+		/// - If the threshold list begins `[1, 2, 3, ...]`, then an id with score 0 or 1 will fall
+		///   into bag 0, an id with score 2 will fall into bag 1, etc.
+		///
+		/// # Migration
+		///
+		/// In the event that this list ever changes, a copy of the old bags list must be retained.
+		/// With that `List::migrate` can be called, which will perform the appropriate migration.
+		#[pallet::constant]
+		type BagThresholds: Get<&'static [Self::Score]>;
+
+		/// The type used to dictate a node position relative to other nodes.
+		type Score: Clone
+			+ Default
+			+ PartialEq
+			+ Eq
+			+ Ord
+			+ PartialOrd
+			+ sp_std::fmt::Debug
+			+ Copy
+			+ AtLeast32BitUnsigned
+			+ Bounded
+			+ TypeInfo
+			+ FullCodec
+			+ MaxEncodedLen;
+	}
+
+	/// A single node, within some bag.
+	///
+	/// Nodes store links forward and back within their respective bags.
+	#[pallet::storage]
+	pub(crate) type ListNodes<T: Config<I>, I: 'static = ()> =
+		CountedStorageMap<_, Twox64Concat, T::AccountId, list::Node<T, I>>;
+
+	/// A bag stored in storage.
+	///
+	/// Stores a `Bag` struct, which stores head and tail pointers to itself.
+	#[pallet::storage]
+	pub(crate) type ListBags<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::Score, list::Bag<T, I>>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(crate) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// Moved an account from one bag to another.
+		Rebagged { who: T::AccountId, from: T::Score, to: T::Score },
+		/// Updated the score of some account to the given amount.
+		ScoreUpdated { who: T::AccountId, new_score: T::Score },
+	}
+
+	#[pallet::error]
+	#[cfg_attr(test, derive(PartialEq))]
+	pub enum Error<T, I = ()> {
+		/// A error in the list interface implementation.
+		List(ListError),
+	}
+
+	impl<T, I> From<ListError> for Error<T, I> {
+		fn from(t: ListError) -> Self {
+			Error::<T, I>::List(t)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Declare that some `dislocated` account has, through rewards or penalties, sufficiently
+		/// changed its score that it should properly fall into a different bag than its current
+		/// one.
+		///
+		/// Anyone can call this function about any potentially dislocated account.
+		///
+		/// Will always update the stored score of `dislocated` to the correct score, based on
+		/// `ScoreProvider`.
+		///
+		/// If `dislocated` does not exists, it returns an error.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::rebag_non_terminal().max(T::WeightInfo::rebag_terminal()))]
+		pub fn rebag(origin: OriginFor<T>, dislocated: AccountIdLookupOf<T>) -> DispatchResult {
+			ensure_signed(origin)?;
+			let dislocated = T::Lookup::lookup(dislocated)?;
+			let current_score = T::ScoreProvider::score(&dislocated);
+			let _ = Pallet::<T, I>::do_rebag(&dislocated, current_score)
+				.map_err::<Error<T, I>, _>(Into::into)?;
+			Ok(())
+		}
+
+		/// Move the caller's Id directly in front of `lighter`.
+		///
+		/// The dispatch origin for this call must be _Signed_ and can only be called by the Id of
+		/// the account going in front of `lighter`. Fee is payed by the origin under all
+		/// circumstances.
+		///
+		/// Only works if:
+		///
+		/// - both nodes are within the same bag,
+		/// - and `origin` has a greater `Score` than `lighter`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::put_in_front_of())]
+		pub fn put_in_front_of(
+			origin: OriginFor<T>,
+			lighter: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let heavier = ensure_signed(origin)?;
+			let lighter = T::Lookup::lookup(lighter)?;
+			List::<T, I>::put_in_front_of(&lighter, &heavier)
+				.map_err::<Error<T, I>, _>(Into::into)
+				.map_err::<DispatchError, _>(Into::into)
+		}
+
+		/// Same as [`Pallet::put_in_front_of`], but it can be called by anyone.
+		///
+		/// Fee is paid by the origin under all circumstances.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::put_in_front_of())]
+		pub fn put_in_front_of_other(
+			origin: OriginFor<T>,
+			heavier: AccountIdLookupOf<T>,
+			lighter: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let _ = ensure_signed(origin)?;
+			let lighter = T::Lookup::lookup(lighter)?;
+			let heavier = T::Lookup::lookup(heavier)?;
+			List::<T, I>::put_in_front_of(&lighter, &heavier)
+				.map_err::<Error<T, I>, _>(Into::into)
+				.map_err::<DispatchError, _>(Into::into)
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		fn integrity_test() {
+			// ensure they are strictly increasing, this also implies that duplicates are detected.
+			assert!(
+				T::BagThresholds::get().windows(2).all(|window| window[1] > window[0]),
+				"thresholds must strictly increase, and have no duplicates",
+			);
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+			<Self as SortedListProvider<T::AccountId>>::try_state()
+		}
+	}
+}
+
+#[cfg(any(test, feature = "try-runtime", feature = "fuzz"))]
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	pub fn do_try_state() -> Result<(), TryRuntimeError> {
+		List::<T, I>::do_try_state()
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Move an account from one bag to another, depositing an event on success.
+	///
+	/// If the account changed bags, returns `Ok(Some((from, to)))`.
+	pub fn do_rebag(
+		account: &T::AccountId,
+		new_score: T::Score,
+	) -> Result<Option<(T::Score, T::Score)>, ListError> {
+		// If no voter at that node, don't do anything. the caller just wasted the fee to call this.
+		let node = list::Node::<T, I>::get(&account).ok_or(ListError::NodeNotFound)?;
+		let maybe_movement = List::update_position_for(node, new_score);
+		if let Some((from, to)) = maybe_movement {
+			Self::deposit_event(Event::<T, I>::Rebagged { who: account.clone(), from, to });
+		};
+		Self::deposit_event(Event::<T, I>::ScoreUpdated { who: account.clone(), new_score });
+		Ok(maybe_movement)
+	}
+
+	/// Equivalent to `ListBags::get`, but public. Useful for tests in outside of this crate.
+	#[cfg(feature = "std")]
+	pub fn list_bags_get(score: T::Score) -> Option<list::Bag<T, I>> {
+		ListBags::get(score)
+	}
+}
+
+impl<T: Config<I>, I: 'static> SortedListProvider<T::AccountId> for Pallet<T, I> {
+	type Error = ListError;
+	type Score = T::Score;
+
+	fn iter() -> Box<dyn Iterator<Item = T::AccountId>> {
+		Box::new(List::<T, I>::iter().map(|n| n.id().clone()))
+	}
+
+	fn iter_from(
+		start: &T::AccountId,
+	) -> Result<Box<dyn Iterator<Item = T::AccountId>>, Self::Error> {
+		let iter = List::<T, I>::iter_from(start)?;
+		Ok(Box::new(iter.map(|n| n.id().clone())))
+	}
+
+	fn count() -> u32 {
+		ListNodes::<T, I>::count()
+	}
+
+	fn contains(id: &T::AccountId) -> bool {
+		List::<T, I>::contains(id)
+	}
+
+	fn on_insert(id: T::AccountId, score: T::Score) -> Result<(), ListError> {
+		List::<T, I>::insert(id, score)
+	}
+
+	fn get_score(id: &T::AccountId) -> Result<T::Score, ListError> {
+		List::<T, I>::get_score(id)
+	}
+
+	fn on_update(id: &T::AccountId, new_score: T::Score) -> Result<(), ListError> {
+		Pallet::<T, I>::do_rebag(id, new_score).map(|_| ())
+	}
+
+	fn on_remove(id: &T::AccountId) -> Result<(), ListError> {
+		List::<T, I>::remove(id)
+	}
+
+	fn unsafe_regenerate(
+		all: impl IntoIterator<Item = T::AccountId>,
+		score_of: Box<dyn Fn(&T::AccountId) -> T::Score>,
+	) -> u32 {
+		// NOTE: This call is unsafe for the same reason as SortedListProvider::unsafe_regenerate.
+		// I.e. because it can lead to many storage accesses.
+		// So it is ok to call it as caller must ensure the conditions.
+		List::<T, I>::unsafe_regenerate(all, score_of)
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn try_state() -> Result<(), TryRuntimeError> {
+		Self::do_try_state()
+	}
+
+	fn unsafe_clear() {
+		// NOTE: This call is unsafe for the same reason as SortedListProvider::unsafe_clear.
+		// I.e. because it can lead to many storage accesses.
+		// So it is ok to call it as caller must ensure the conditions.
+		List::<T, I>::unsafe_clear()
+	}
+
+	frame_election_provider_support::runtime_benchmarks_enabled! {
+		fn score_update_worst_case(who: &T::AccountId, is_increase: bool) -> Self::Score {
+			use frame_support::traits::Get as _;
+			let thresholds = T::BagThresholds::get();
+			let node = list::Node::<T, I>::get(who).unwrap();
+			let current_bag_idx = thresholds
+				.iter()
+				.chain(sp_std::iter::once(&T::Score::max_value()))
+				.position(|w| w == &node.bag_upper)
+				.unwrap();
+
+			if is_increase {
+				let next_threshold_idx = current_bag_idx + 1;
+				assert!(thresholds.len() > next_threshold_idx);
+				thresholds[next_threshold_idx]
+			} else {
+				assert!(current_bag_idx != 0);
+				let prev_threshold_idx = current_bag_idx - 1;
+				thresholds[prev_threshold_idx]
+			}
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> ScoreProvider<T::AccountId> for Pallet<T, I> {
+	type Score = <Pallet<T, I> as SortedListProvider<T::AccountId>>::Score;
+
+	fn score(id: &T::AccountId) -> T::Score {
+		Node::<T, I>::get(id).map(|node| node.score()).unwrap_or_default()
+	}
+
+	frame_election_provider_support::runtime_benchmarks_fuzz_or_std_enabled! {
+		fn set_score_of(id: &T::AccountId, new_score: T::Score) {
+			ListNodes::<T, I>::mutate(id, |maybe_node| {
+				if let Some(node) = maybe_node.as_mut() {
+					node.score = new_score;
+				} else {
+					panic!("trying to mutate {:?} which does not exists", id);
+				}
+			})
+		}
+	}
+}
diff --git a/substrate/frame/bags-list/src/list/mod.rs b/substrate/frame/bags-list/src/list/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d8626080e25239197b60c952aa35a51cf20f5cb1
--- /dev/null
+++ b/substrate/frame/bags-list/src/list/mod.rs
@@ -0,0 +1,920 @@
+// 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.
+
+//! Implementation of a "bags list": a semi-sorted list where ordering granularity is dictated by
+//! configurable thresholds that delineate the boundaries of bags. It uses a pattern of composite
+//! data structures, where multiple storage items are masked by one outer API. See
+//! [`crate::ListNodes`], [`crate::ListBags`] for more information.
+//!
+//! The outer API of this module is the [`List`] struct. It wraps all acceptable operations on top
+//! of the aggregate linked list. All operations with the bags list should happen through this
+//! interface.
+
+use crate::Config;
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_election_provider_support::ScoreProvider;
+use frame_support::{
+	defensive, ensure,
+	traits::{Defensive, DefensiveOption, Get},
+	DefaultNoBound, PalletError,
+};
+use scale_info::TypeInfo;
+use sp_runtime::traits::{Bounded, Zero};
+use sp_std::{
+	boxed::Box,
+	collections::{btree_map::BTreeMap, btree_set::BTreeSet},
+	iter,
+	marker::PhantomData,
+	prelude::*,
+};
+
+#[cfg(any(test, feature = "try-runtime", feature = "fuzz"))]
+use sp_runtime::TryRuntimeError;
+
+#[derive(Debug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo, PalletError)]
+pub enum ListError {
+	/// A duplicate id has been detected.
+	Duplicate,
+	/// An Id does not have a greater score than another Id.
+	NotHeavier,
+	/// Attempted to place node in front of a node in another bag.
+	NotInSameBag,
+	/// Given node id was not found.
+	NodeNotFound,
+}
+
+#[cfg(test)]
+mod tests;
+
+/// Given a certain score, to which bag does it belong to?
+///
+/// Bags are identified by their upper threshold; the value returned by this function is guaranteed
+/// to be a member of `T::BagThresholds`.
+///
+/// Note that even if the thresholds list does not have `T::Score::max_value()` as its final member,
+/// this function behaves as if it does.
+pub fn notional_bag_for<T: Config<I>, I: 'static>(score: T::Score) -> T::Score {
+	let thresholds = T::BagThresholds::get();
+	let idx = thresholds.partition_point(|&threshold| score > threshold);
+	thresholds.get(idx).copied().unwrap_or_else(T::Score::max_value)
+}
+
+/// The **ONLY** entry point of this module. All operations to the bags-list should happen through
+/// this interface. It is forbidden to access other module members directly.
+//
+// Data structure providing efficient mostly-accurate selection of the top N id by `Score`.
+//
+// It's implemented as a set of linked lists. Each linked list comprises a bag of ids of
+// arbitrary and unbounded length, all having a score within a particular constant range.
+// This structure means that ids can be added and removed in `O(1)` time.
+//
+// Iteration is accomplished by chaining the iteration of each bag, from greatest to least. While
+// the users within any particular bag are sorted in an entirely arbitrary order, the overall score
+// decreases as successive bags are reached. This means that it is valid to truncate
+// iteration at any desired point; only those ids in the lowest bag can be excluded. This
+// satisfies both the desire for fairness and the requirement for efficiency.
+pub struct List<T: Config<I>, I: 'static = ()>(PhantomData<(T, I)>);
+
+impl<T: Config<I>, I: 'static> List<T, I> {
+	/// Remove all data associated with the list from storage.
+	///
+	/// ## WARNING
+	///
+	/// this function should generally not be used in production as it could lead to a very large
+	/// number of storage accesses.
+	pub(crate) fn unsafe_clear() {
+		#[allow(deprecated)]
+		crate::ListBags::<T, I>::remove_all(None);
+		#[allow(deprecated)]
+		crate::ListNodes::<T, I>::remove_all();
+	}
+
+	/// Regenerate all of the data from the given ids.
+	///
+	/// WARNING: this is expensive and should only ever be performed when the list needs to be
+	/// generated from scratch. Care needs to be taken to ensure
+	///
+	/// This may or may not need to be called at genesis as well, based on the configuration of the
+	/// pallet using this `List`.
+	///
+	/// Returns the number of ids migrated.
+	pub fn unsafe_regenerate(
+		all: impl IntoIterator<Item = T::AccountId>,
+		score_of: Box<dyn Fn(&T::AccountId) -> T::Score>,
+	) -> u32 {
+		// NOTE: This call is unsafe for the same reason as SortedListProvider::unsafe_regenerate.
+		// I.e. because it can lead to many storage accesses.
+		// So it is ok to call it as caller must ensure the conditions.
+		Self::unsafe_clear();
+		Self::insert_many(all, score_of)
+	}
+
+	/// Migrate the list from one set of thresholds to another.
+	///
+	/// This should only be called as part of an intentional migration; it's fairly expensive.
+	///
+	/// Returns the number of accounts affected.
+	///
+	/// Preconditions:
+	///
+	/// - `old_thresholds` is the previous list of thresholds.
+	/// - All `bag_upper` currently in storage are members of `old_thresholds`.
+	/// - `T::BagThresholds` has already been updated and is the new set of thresholds.
+	///
+	/// Postconditions:
+	///
+	/// - All `bag_upper` currently in storage are members of `T::BagThresholds`.
+	/// - No id is changed unless required to by the difference between the old threshold list and
+	///   the new.
+	/// - ids whose bags change at all are implicitly rebagged into the appropriate bag in the new
+	///   threshold set.
+	#[allow(dead_code)]
+	pub fn migrate(old_thresholds: &[T::Score]) -> u32 {
+		let new_thresholds = T::BagThresholds::get();
+		if new_thresholds == old_thresholds {
+			return 0
+		}
+
+		// we can't check all preconditions, but we can check one
+		debug_assert!(
+			crate::ListBags::<T, I>::iter()
+				.all(|(threshold, _)| old_thresholds.contains(&threshold)),
+			"not all `bag_upper` currently in storage are members of `old_thresholds`",
+		);
+		debug_assert!(
+			crate::ListNodes::<T, I>::iter()
+				.all(|(_, node)| old_thresholds.contains(&node.bag_upper)),
+			"not all `node.bag_upper` currently in storage are members of `old_thresholds`",
+		);
+
+		let old_set: BTreeSet<_> = old_thresholds.iter().copied().collect();
+		let new_set: BTreeSet<_> = new_thresholds.iter().copied().collect();
+
+		// accounts that need to be rebagged
+		let mut affected_accounts = BTreeSet::new();
+		// track affected old bags to make sure we only iterate them once
+		let mut affected_old_bags = BTreeSet::new();
+
+		let new_bags = new_set.difference(&old_set).copied();
+		// a new bag means that all accounts previously using the old bag's threshold must now
+		// be rebagged
+		for inserted_bag in new_bags {
+			let affected_bag = {
+				// this recreates `notional_bag_for` logic, but with the old thresholds.
+				let idx = old_thresholds.partition_point(|&threshold| inserted_bag > threshold);
+				old_thresholds.get(idx).copied().unwrap_or_else(T::Score::max_value)
+			};
+			if !affected_old_bags.insert(affected_bag) {
+				// If the previous threshold list was [10, 20], and we insert [3, 5], then there's
+				// no point iterating through bag 10 twice.
+				continue
+			}
+
+			if let Some(bag) = Bag::<T, I>::get(affected_bag) {
+				affected_accounts.extend(bag.iter().map(|node| node.id));
+			}
+		}
+
+		let removed_bags = old_set.difference(&new_set).copied();
+		// a removed bag means that all members of that bag must be rebagged
+		for removed_bag in removed_bags.clone() {
+			if !affected_old_bags.insert(removed_bag) {
+				continue
+			}
+
+			if let Some(bag) = Bag::<T, I>::get(removed_bag) {
+				affected_accounts.extend(bag.iter().map(|node| node.id));
+			}
+		}
+
+		// migrate the voters whose bag has changed
+		let num_affected = affected_accounts.len() as u32;
+		let score_of = T::ScoreProvider::score;
+		let _removed = Self::remove_many(&affected_accounts);
+		debug_assert_eq!(_removed, num_affected);
+		let _inserted = Self::insert_many(affected_accounts.into_iter(), score_of);
+		debug_assert_eq!(_inserted, num_affected);
+
+		// we couldn't previously remove the old bags because both insertion and removal assume that
+		// it's always safe to add a bag if it's not present. Now that that's sorted, we can get rid
+		// of them.
+		//
+		// it's pretty cheap to iterate this again, because both sets are in-memory and require no
+		// lookups.
+		for removed_bag in removed_bags {
+			debug_assert!(
+				!crate::ListNodes::<T, I>::iter().any(|(_, node)| node.bag_upper == removed_bag),
+				"no id should be present in a removed bag",
+			);
+			crate::ListBags::<T, I>::remove(removed_bag);
+		}
+
+		num_affected
+	}
+
+	/// Returns `true` if the list contains `id`, otherwise returns `false`.
+	pub(crate) fn contains(id: &T::AccountId) -> bool {
+		crate::ListNodes::<T, I>::contains_key(id)
+	}
+
+	/// Get the score of the given node,
+	pub fn get_score(id: &T::AccountId) -> Result<T::Score, ListError> {
+		Node::<T, I>::get(id).map(|node| node.score()).ok_or(ListError::NodeNotFound)
+	}
+
+	/// Iterate over all nodes in all bags in the list.
+	///
+	/// Full iteration can be expensive; it's recommended to limit the number of items with
+	/// `.take(n)`.
+	pub(crate) fn iter() -> impl Iterator<Item = Node<T, I>> {
+		// We need a touch of special handling here: because we permit `T::BagThresholds` to
+		// omit the final bound, we need to ensure that we explicitly include that threshold in the
+		// list.
+		//
+		// It's important to retain the ability to omit the final bound because it makes tests much
+		// easier; they can just configure `type BagThresholds = ()`.
+		let thresholds = T::BagThresholds::get();
+		let iter = thresholds.iter().copied();
+		let iter: Box<dyn Iterator<Item = T::Score>> = if thresholds.last() ==
+			Some(&T::Score::max_value())
+		{
+			// in the event that they included it, we can just pass the iterator through unchanged.
+			Box::new(iter.rev())
+		} else {
+			// otherwise, insert it here.
+			Box::new(iter.chain(iter::once(T::Score::max_value())).rev())
+		};
+
+		iter.filter_map(Bag::get).flat_map(|bag| bag.iter())
+	}
+
+	/// Same as `iter`, but we start from a specific node.
+	///
+	/// All items after this node are returned, excluding `start` itself.
+	pub(crate) fn iter_from(
+		start: &T::AccountId,
+	) -> Result<impl Iterator<Item = Node<T, I>>, ListError> {
+		// We chain two iterators:
+		// 1. from the given `start` till the end of the bag
+		// 2. all the bags that come after `start`'s bag.
+
+		let start_node = Node::<T, I>::get(start).ok_or(ListError::NodeNotFound)?;
+		let start_node_upper = start_node.bag_upper;
+		let start_bag = sp_std::iter::successors(start_node.next(), |prev| prev.next());
+
+		let thresholds = T::BagThresholds::get();
+		let idx = thresholds.partition_point(|&threshold| start_node_upper > threshold);
+		let leftover_bags = thresholds
+			.into_iter()
+			.take(idx)
+			.copied()
+			.rev()
+			.filter_map(Bag::get)
+			.flat_map(|bag| bag.iter());
+
+		Ok(start_bag.chain(leftover_bags))
+	}
+
+	/// Insert several ids into the appropriate bags in the list. Continues with insertions
+	/// if duplicates are detected.
+	///
+	/// Returns the final count of number of ids inserted.
+	fn insert_many(
+		ids: impl IntoIterator<Item = T::AccountId>,
+		score_of: impl Fn(&T::AccountId) -> T::Score,
+	) -> u32 {
+		let mut count = 0;
+		ids.into_iter().for_each(|v| {
+			let score = score_of(&v);
+			if Self::insert(v, score).is_ok() {
+				count += 1;
+			}
+		});
+
+		count
+	}
+
+	/// Insert a new id into the appropriate bag in the list.
+	///
+	/// Returns an error if the list already contains `id`.
+	pub(crate) fn insert(id: T::AccountId, score: T::Score) -> Result<(), ListError> {
+		if Self::contains(&id) {
+			return Err(ListError::Duplicate)
+		}
+
+		let bag_score = notional_bag_for::<T, I>(score);
+		let mut bag = Bag::<T, I>::get_or_make(bag_score);
+		// unchecked insertion is okay; we just got the correct `notional_bag_for`.
+		bag.insert_unchecked(id.clone(), score);
+
+		// new inserts are always the tail, so we must write the bag.
+		bag.put();
+
+		crate::log!(
+			debug,
+			"inserted {:?} with score {:?} into bag {:?}, new count is {}",
+			id,
+			score,
+			bag_score,
+			crate::ListNodes::<T, I>::count(),
+		);
+
+		Ok(())
+	}
+
+	/// Remove an id from the list, returning an error if `id` does not exists.
+	pub(crate) fn remove(id: &T::AccountId) -> Result<(), ListError> {
+		if !Self::contains(id) {
+			return Err(ListError::NodeNotFound)
+		}
+		let _ = Self::remove_many(sp_std::iter::once(id));
+		Ok(())
+	}
+
+	/// Remove many ids from the list.
+	///
+	/// This is more efficient than repeated calls to `Self::remove`.
+	///
+	/// Returns the final count of number of ids removed.
+	fn remove_many<'a>(ids: impl IntoIterator<Item = &'a T::AccountId>) -> u32 {
+		let mut bags = BTreeMap::new();
+		let mut count = 0;
+
+		for id in ids.into_iter() {
+			let node = match Node::<T, I>::get(id) {
+				Some(node) => node,
+				None => continue,
+			};
+			count += 1;
+
+			if !node.is_terminal() {
+				// this node is not a head or a tail and thus the bag does not need to be updated
+				node.excise()
+			} else {
+				// this node is a head or tail, so the bag needs to be updated
+				let bag = bags
+					.entry(node.bag_upper)
+					.or_insert_with(|| Bag::<T, I>::get_or_make(node.bag_upper));
+				// node.bag_upper must be correct, therefore this bag will contain this node.
+				bag.remove_node_unchecked(&node);
+			}
+
+			// now get rid of the node itself
+			node.remove_from_storage_unchecked()
+		}
+
+		for (_, bag) in bags {
+			bag.put();
+		}
+
+		count
+	}
+
+	/// Update a node's position in the list.
+	///
+	/// If the node was in the correct bag, no effect. If the node was in the incorrect bag, they
+	/// are moved into the correct bag.
+	///
+	/// Returns `Some((old_idx, new_idx))` if the node moved, otherwise `None`. In both cases, the
+	/// node's score is written to the `score` field. Thus, this is not a noop, even if `None`.
+	///
+	/// This operation is somewhat more efficient than simply calling [`self.remove`] followed by
+	/// [`self.insert`]. However, given large quantities of nodes to move, it may be more efficient
+	/// to call [`self.remove_many`] followed by [`self.insert_many`].
+	pub(crate) fn update_position_for(
+		mut node: Node<T, I>,
+		new_score: T::Score,
+	) -> Option<(T::Score, T::Score)> {
+		node.score = new_score;
+		if node.is_misplaced(new_score) {
+			let old_bag_upper = node.bag_upper;
+
+			if !node.is_terminal() {
+				// this node is not a head or a tail, so we can just cut it out of the list. update
+				// and put the prev and next of this node, we do `node.put` inside `insert_note`.
+				node.excise();
+			} else if let Some(mut bag) = Bag::<T, I>::get(node.bag_upper) {
+				// this is a head or tail, so the bag must be updated.
+				bag.remove_node_unchecked(&node);
+				bag.put();
+			} else {
+				frame_support::defensive!(
+					"Node did not have a bag; BagsList is in an inconsistent state"
+				);
+			}
+
+			// put the node into the appropriate new bag.
+			let new_bag_upper = notional_bag_for::<T, I>(new_score);
+			let mut bag = Bag::<T, I>::get_or_make(new_bag_upper);
+			// prev, next, and bag_upper of the node are updated inside `insert_node`, also
+			// `node.put` is in there.
+			bag.insert_node_unchecked(node);
+			bag.put();
+
+			Some((old_bag_upper, new_bag_upper))
+		} else {
+			// just write the new score.
+			node.put();
+			None
+		}
+	}
+
+	/// Put `heavier_id` to the position directly in front of `lighter_id`. Both ids must be in the
+	/// same bag and the `score_of` `lighter_id` must be less than that of `heavier_id`.
+	pub(crate) fn put_in_front_of(
+		lighter_id: &T::AccountId,
+		heavier_id: &T::AccountId,
+	) -> Result<(), ListError> {
+		let lighter_node = Node::<T, I>::get(&lighter_id).ok_or(ListError::NodeNotFound)?;
+		let heavier_node = Node::<T, I>::get(&heavier_id).ok_or(ListError::NodeNotFound)?;
+
+		ensure!(lighter_node.bag_upper == heavier_node.bag_upper, ListError::NotInSameBag);
+
+		// this is the most expensive check, so we do it last.
+		ensure!(
+			T::ScoreProvider::score(&heavier_id) > T::ScoreProvider::score(&lighter_id),
+			ListError::NotHeavier
+		);
+
+		// remove the heavier node from this list. Note that this removes the node from storage and
+		// decrements the node counter.
+		let _ =
+			Self::remove(&heavier_id).defensive_proof("both nodes have been checked to exist; qed");
+
+		// re-fetch `lighter_node` from storage since it may have been updated when `heavier_node`
+		// was removed.
+		let lighter_node =
+			Node::<T, I>::get(lighter_id).defensive_ok_or_else(|| ListError::NodeNotFound)?;
+
+		// insert `heavier_node` directly in front of `lighter_node`. This will update both nodes
+		// in storage and update the node counter.
+		Self::insert_at_unchecked(lighter_node, heavier_node);
+
+		Ok(())
+	}
+
+	/// Insert `node` directly in front of `at`.
+	///
+	/// WARNINGS:
+	/// - this is a naive function in that it does not check if `node` belongs to the same bag as
+	/// `at`. It is expected that the call site will check preconditions.
+	/// - this will panic if `at.bag_upper` is not a bag that already exists in storage.
+	fn insert_at_unchecked(mut at: Node<T, I>, mut node: Node<T, I>) {
+		// connect `node` to its new `prev`.
+		node.prev = at.prev.clone();
+		if let Some(mut prev) = at.prev() {
+			prev.next = Some(node.id().clone());
+			prev.put()
+		}
+
+		// connect `node` and `at`.
+		node.next = Some(at.id().clone());
+		at.prev = Some(node.id().clone());
+
+		if node.is_terminal() {
+			// `node` is the new head, so we make sure the bag is updated. Note,
+			// since `node` is always in front of `at` we know that 1) there is always at least 2
+			// nodes in the bag, and 2) only `node` could be the head and only `at` could be the
+			// tail.
+			let mut bag = Bag::<T, I>::get(at.bag_upper)
+				.expect("given nodes must always have a valid bag. qed.");
+
+			if node.prev == None {
+				bag.head = Some(node.id().clone())
+			}
+
+			bag.put()
+		};
+
+		// write the updated nodes to storage.
+		at.put();
+		node.put();
+	}
+
+	/// Check the internal state of the list.
+	///
+	/// This should be called from the call-site, whenever one of the mutating apis (e.g. `insert`)
+	/// is being used, after all other staking data (such as counter) has been updated. It checks:
+	///
+	/// * there are no duplicate ids,
+	/// * length of this list is in sync with `ListNodes::count()`,
+	/// * and sanity-checks all bags and nodes. This will cascade down all the checks and makes sure
+	/// all bags and nodes are checked per *any* update to `List`.
+	#[cfg(any(test, feature = "try-runtime", feature = "fuzz"))]
+	pub(crate) fn do_try_state() -> Result<(), TryRuntimeError> {
+		let mut seen_in_list = BTreeSet::new();
+		ensure!(
+			Self::iter().map(|node| node.id).all(|id| seen_in_list.insert(id)),
+			"duplicate identified"
+		);
+
+		let iter_count = Self::iter().count() as u32;
+		let stored_count = crate::ListNodes::<T, I>::count();
+		let nodes_count = crate::ListNodes::<T, I>::iter().count() as u32;
+		ensure!(iter_count == stored_count, "iter_count != stored_count");
+		ensure!(stored_count == nodes_count, "stored_count != nodes_count");
+
+		crate::log!(trace, "count of nodes: {}", stored_count);
+
+		let active_bags = {
+			let thresholds = T::BagThresholds::get().iter().copied();
+			let thresholds: Vec<T::Score> =
+				if thresholds.clone().last() == Some(T::Score::max_value()) {
+					// in the event that they included it, we don't need to make any changes
+					thresholds.collect()
+				} else {
+					// otherwise, insert it here.
+					thresholds.chain(iter::once(T::Score::max_value())).collect()
+				};
+			thresholds.into_iter().filter_map(|t| Bag::<T, I>::get(t))
+		};
+
+		let _ = active_bags.clone().try_for_each(|b| b.do_try_state())?;
+
+		let nodes_in_bags_count =
+			active_bags.clone().fold(0u32, |acc, cur| acc + cur.iter().count() as u32);
+		ensure!(nodes_count == nodes_in_bags_count, "stored_count != nodes_in_bags_count");
+
+		crate::log!(trace, "count of active bags {}", active_bags.count());
+
+		// check that all nodes are sane. We check the `ListNodes` storage item directly in case we
+		// have some "stale" nodes that are not in a bag.
+		for (_id, node) in crate::ListNodes::<T, I>::iter() {
+			node.do_try_state()?
+		}
+
+		Ok(())
+	}
+
+	/// Returns the nodes of all non-empty bags. For testing and benchmarks.
+	#[cfg(any(feature = "std", feature = "runtime-benchmarks"))]
+	#[allow(dead_code)]
+	pub(crate) fn get_bags() -> Vec<(T::Score, Vec<T::AccountId>)> {
+		use frame_support::traits::Get as _;
+
+		let thresholds = T::BagThresholds::get();
+		let iter = thresholds.iter().copied();
+		let iter: Box<dyn Iterator<Item = T::Score>> = if thresholds.last() ==
+			Some(&T::Score::max_value())
+		{
+			// in the event that they included it, we can just pass the iterator through unchanged.
+			Box::new(iter)
+		} else {
+			// otherwise, insert it here.
+			Box::new(iter.chain(sp_std::iter::once(T::Score::max_value())))
+		};
+
+		iter.filter_map(|t| {
+			Bag::<T, I>::get(t)
+				.map(|bag| (t, bag.iter().map(|n| n.id().clone()).collect::<Vec<_>>()))
+		})
+		.collect::<Vec<_>>()
+	}
+}
+
+/// A Bag is a doubly-linked list of ids, where each id is mapped to a [`Node`].
+///
+/// Note that we maintain both head and tail pointers. While it would be possible to get away with
+/// maintaining only a head pointer and cons-ing elements onto the front of the list, it's more
+/// desirable to ensure that there is some element of first-come, first-serve to the list's
+/// iteration so that there's no incentive to churn ids positioning to improve the chances of
+/// appearing within the ids set.
+#[derive(DefaultNoBound, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[codec(mel_bound())]
+#[scale_info(skip_type_params(T, I))]
+#[cfg_attr(feature = "std", derive(frame_support::DebugNoBound, Clone, PartialEq))]
+pub struct Bag<T: Config<I>, I: 'static = ()> {
+	head: Option<T::AccountId>,
+	tail: Option<T::AccountId>,
+
+	#[codec(skip)]
+	bag_upper: T::Score,
+	#[codec(skip)]
+	_phantom: PhantomData<I>,
+}
+
+impl<T: Config<I>, I: 'static> Bag<T, I> {
+	#[cfg(test)]
+	pub(crate) fn new(
+		head: Option<T::AccountId>,
+		tail: Option<T::AccountId>,
+		bag_upper: T::Score,
+	) -> Self {
+		Self { head, tail, bag_upper, _phantom: PhantomData }
+	}
+
+	/// Get a bag by its upper score.
+	pub(crate) fn get(bag_upper: T::Score) -> Option<Bag<T, I>> {
+		crate::ListBags::<T, I>::try_get(bag_upper).ok().map(|mut bag| {
+			bag.bag_upper = bag_upper;
+			bag
+		})
+	}
+
+	/// Get a bag by its upper score or make it, appropriately initialized. Does not check if
+	/// if `bag_upper` is a valid threshold.
+	fn get_or_make(bag_upper: T::Score) -> Bag<T, I> {
+		Self::get(bag_upper).unwrap_or(Bag { bag_upper, ..Default::default() })
+	}
+
+	/// `True` if self is empty.
+	fn is_empty(&self) -> bool {
+		self.head.is_none() && self.tail.is_none()
+	}
+
+	/// Put the bag back into storage.
+	fn put(self) {
+		if self.is_empty() {
+			crate::ListBags::<T, I>::remove(self.bag_upper);
+		} else {
+			crate::ListBags::<T, I>::insert(self.bag_upper, self);
+		}
+	}
+
+	/// Get the head node in this bag.
+	fn head(&self) -> Option<Node<T, I>> {
+		self.head.as_ref().and_then(|id| Node::get(id))
+	}
+
+	/// Get the tail node in this bag.
+	fn tail(&self) -> Option<Node<T, I>> {
+		self.tail.as_ref().and_then(|id| Node::get(id))
+	}
+
+	/// Iterate over the nodes in this bag.
+	pub(crate) fn iter(&self) -> impl Iterator<Item = Node<T, I>> {
+		sp_std::iter::successors(self.head(), |prev| prev.next())
+	}
+
+	/// Insert a new id into this bag.
+	///
+	/// This is private on purpose because it's naive: it doesn't check whether this is the
+	/// appropriate bag for this id at all. Generally, use [`List::insert`] instead.
+	///
+	/// Storage note: this modifies storage, but only for the nodes. You still need to call
+	/// `self.put()` after use.
+	fn insert_unchecked(&mut self, id: T::AccountId, score: T::Score) {
+		// insert_node will overwrite `prev`, `next` and `bag_upper` to the proper values. As long
+		// as this bag is the correct one, we're good. All calls to this must come after getting the
+		// correct [`notional_bag_for`].
+		self.insert_node_unchecked(Node::<T, I> {
+			id,
+			prev: None,
+			next: None,
+			bag_upper: Zero::zero(),
+			score,
+			_phantom: PhantomData,
+		});
+	}
+
+	/// Insert a node into this bag.
+	///
+	/// This is private on purpose because it's naive; it doesn't check whether this is the
+	/// appropriate bag for this node at all. Generally, use [`List::insert`] instead.
+	///
+	/// Storage note: this modifies storage, but only for the node. You still need to call
+	/// `self.put()` after use.
+	fn insert_node_unchecked(&mut self, mut node: Node<T, I>) {
+		if let Some(tail) = &self.tail {
+			if *tail == node.id {
+				// this should never happen, but this check prevents one path to a worst case
+				// infinite loop.
+				defensive!("system logic error: inserting a node who has the id of tail");
+				return
+			};
+		}
+
+		// re-set the `bag_upper`. Regardless of whatever the node had previously, now it is going
+		// to be `self.bag_upper`.
+		node.bag_upper = self.bag_upper;
+
+		let id = node.id.clone();
+		// update this node now, treating it as the new tail.
+		node.prev = self.tail.clone();
+		node.next = None;
+		node.put();
+
+		// update the previous tail.
+		if let Some(mut old_tail) = self.tail() {
+			old_tail.next = Some(id.clone());
+			old_tail.put();
+		}
+		self.tail = Some(id.clone());
+
+		// ensure head exist. This is only set when the length of the bag is just 1, i.e. if this is
+		// the first insertion into the bag. In this case, both head and tail should point to the
+		// same node.
+		if self.head.is_none() {
+			self.head = Some(id);
+			debug_assert!(self.iter().count() == 1);
+		}
+	}
+
+	/// Remove a node from this bag.
+	///
+	/// This is private on purpose because it doesn't check whether this bag contains the node in
+	/// the first place. Generally, use [`List::remove`] instead, similar to `insert_unchecked`.
+	///
+	/// Storage note: this modifies storage, but only for adjacent nodes. You still need to call
+	/// `self.put()` and `ListNodes::remove(id)` to update storage for the bag and `node`.
+	fn remove_node_unchecked(&mut self, node: &Node<T, I>) {
+		// reassign neighboring nodes.
+		node.excise();
+
+		// clear the bag head/tail pointers as necessary.
+		if self.tail.as_ref() == Some(&node.id) {
+			self.tail = node.prev.clone();
+		}
+		if self.head.as_ref() == Some(&node.id) {
+			self.head = node.next.clone();
+		}
+	}
+
+	/// Check the internal state of the bag.
+	///
+	/// Should be called by the call-site, after any mutating operation on a bag. The call site of
+	/// this struct is always `List`.
+	///
+	/// * Ensures head has no prev.
+	/// * Ensures tail has no next.
+	/// * Ensures there are no loops, traversal from head to tail is correct.
+	#[cfg(any(test, feature = "try-runtime", feature = "fuzz"))]
+	fn do_try_state(&self) -> Result<(), TryRuntimeError> {
+		frame_support::ensure!(
+			self.head()
+				.map(|head| head.prev().is_none())
+				// if there is no head, then there must not be a tail, meaning that the bag is
+				// empty.
+				.unwrap_or_else(|| self.tail.is_none()),
+			"head has a prev"
+		);
+
+		frame_support::ensure!(
+			self.tail()
+				.map(|tail| tail.next().is_none())
+				// if there is no tail, then there must not be a head, meaning that the bag is
+				// empty.
+				.unwrap_or_else(|| self.head.is_none()),
+			"tail has a next"
+		);
+
+		let mut seen_in_bag = BTreeSet::new();
+		frame_support::ensure!(
+			self.iter()
+				.map(|node| node.id)
+				// each voter is only seen once, thus there is no cycle within a bag
+				.all(|voter| seen_in_bag.insert(voter)),
+			"duplicate found in bag"
+		);
+
+		Ok(())
+	}
+
+	/// Iterate over the nodes in this bag (public for tests).
+	#[cfg(feature = "std")]
+	#[allow(dead_code)]
+	pub fn std_iter(&self) -> impl Iterator<Item = Node<T, I>> {
+		sp_std::iter::successors(self.head(), |prev| prev.next())
+	}
+
+	/// Check if the bag contains a node with `id`.
+	#[cfg(any(test, feature = "try-runtime", feature = "fuzz"))]
+	fn contains(&self, id: &T::AccountId) -> bool {
+		self.iter().any(|n| n.id() == id)
+	}
+}
+
+/// A Node is the fundamental element comprising the doubly-linked list described by `Bag`.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[codec(mel_bound())]
+#[scale_info(skip_type_params(T, I))]
+#[cfg_attr(feature = "std", derive(frame_support::DebugNoBound, Clone, PartialEq))]
+pub struct Node<T: Config<I>, I: 'static = ()> {
+	pub(crate) id: T::AccountId,
+	pub(crate) prev: Option<T::AccountId>,
+	pub(crate) next: Option<T::AccountId>,
+	pub(crate) bag_upper: T::Score,
+	pub(crate) score: T::Score,
+	#[codec(skip)]
+	pub(crate) _phantom: PhantomData<I>,
+}
+
+impl<T: Config<I>, I: 'static> Node<T, I> {
+	/// Get a node by id.
+	pub fn get(id: &T::AccountId) -> Option<Node<T, I>> {
+		crate::ListNodes::<T, I>::try_get(id).ok()
+	}
+
+	/// Put the node back into storage.
+	fn put(self) {
+		crate::ListNodes::<T, I>::insert(self.id.clone(), self);
+	}
+
+	/// Update neighboring nodes to point to reach other.
+	///
+	/// Only updates storage for adjacent nodes, but not `self`; so the user may need to call
+	/// `self.put`.
+	fn excise(&self) {
+		// Update previous node.
+		if let Some(mut prev) = self.prev() {
+			prev.next = self.next.clone();
+			prev.put();
+		}
+		// Update next self.
+		if let Some(mut next) = self.next() {
+			next.prev = self.prev.clone();
+			next.put();
+		}
+	}
+
+	/// This is a naive function that removes a node from the `ListNodes` storage item.
+	///
+	/// It is naive because it does not check if the node has first been removed from its bag.
+	fn remove_from_storage_unchecked(&self) {
+		crate::ListNodes::<T, I>::remove(&self.id)
+	}
+
+	/// Get the previous node in the bag.
+	fn prev(&self) -> Option<Node<T, I>> {
+		self.prev.as_ref().and_then(|id| Node::get(id))
+	}
+
+	/// Get the next node in the bag.
+	fn next(&self) -> Option<Node<T, I>> {
+		self.next.as_ref().and_then(|id| Node::get(id))
+	}
+
+	/// `true` when this voter is in the wrong bag.
+	pub fn is_misplaced(&self, current_score: T::Score) -> bool {
+		notional_bag_for::<T, I>(current_score) != self.bag_upper
+	}
+
+	/// `true` when this voter is a bag head or tail.
+	fn is_terminal(&self) -> bool {
+		self.prev.is_none() || self.next.is_none()
+	}
+
+	/// Get the underlying voter.
+	pub(crate) fn id(&self) -> &T::AccountId {
+		&self.id
+	}
+
+	/// Get the current vote weight of the node.
+	pub(crate) fn score(&self) -> T::Score {
+		self.score
+	}
+
+	/// Get the underlying voter (public fo tests).
+	#[cfg(feature = "std")]
+	#[allow(dead_code)]
+	pub fn std_id(&self) -> &T::AccountId {
+		&self.id
+	}
+
+	#[cfg(any(feature = "runtime-benchmarks", feature = "fuzz", test))]
+	pub fn set_score(&mut self, s: T::Score) {
+		self.score = s
+	}
+
+	/// The bag this nodes belongs to (public for benchmarks).
+	#[cfg(feature = "runtime-benchmarks")]
+	#[allow(dead_code)]
+	pub fn bag_upper(&self) -> T::Score {
+		self.bag_upper
+	}
+
+	#[cfg(any(test, feature = "try-runtime", feature = "fuzz"))]
+	fn do_try_state(&self) -> Result<(), TryRuntimeError> {
+		let expected_bag = Bag::<T, I>::get(self.bag_upper).ok_or("bag not found for node")?;
+
+		let id = self.id();
+
+		frame_support::ensure!(expected_bag.contains(id), "node does not exist in the bag");
+
+		let non_terminal_check = !self.is_terminal() &&
+			expected_bag.head.as_ref() != Some(id) &&
+			expected_bag.tail.as_ref() != Some(id);
+		let terminal_check =
+			expected_bag.head.as_ref() == Some(id) || expected_bag.tail.as_ref() == Some(id);
+		frame_support::ensure!(
+			non_terminal_check || terminal_check,
+			"a terminal node is neither its bag head or tail"
+		);
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/bags-list/src/list/tests.rs b/substrate/frame/bags-list/src/list/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fd4ad8f893af38aa29fe0573eb4c22d13be97037
--- /dev/null
+++ b/substrate/frame/bags-list/src/list/tests.rs
@@ -0,0 +1,966 @@
+// 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 crate::{
+	mock::{test_utils::*, *},
+	ListBags, ListNodes,
+};
+use frame_election_provider_support::{SortedListProvider, VoteWeight};
+use frame_support::{assert_ok, assert_storage_noop};
+use sp_runtime::TryRuntimeError;
+
+fn node(
+	id: AccountId,
+	prev: Option<AccountId>,
+	next: Option<AccountId>,
+	bag_upper: VoteWeight,
+) -> Node<Runtime> {
+	Node::<Runtime> { id, prev, next, bag_upper, score: bag_upper, _phantom: PhantomData }
+}
+
+#[test]
+fn basic_setup_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(ListNodes::<Runtime>::count(), 4);
+		assert_eq!(ListNodes::<Runtime>::iter().count(), 4);
+		assert_eq!(ListBags::<Runtime>::iter().count(), 2);
+
+		assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+		// the state of the bags is as expected
+		assert_eq!(
+			ListBags::<Runtime>::get(10).unwrap(),
+			Bag::<Runtime> { head: Some(1), tail: Some(1), bag_upper: 0, _phantom: PhantomData }
+		);
+		assert_eq!(
+			ListBags::<Runtime>::get(1_000).unwrap(),
+			Bag::<Runtime> { head: Some(2), tail: Some(4), bag_upper: 0, _phantom: PhantomData }
+		);
+
+		assert_eq!(ListNodes::<Runtime>::get(2).unwrap(), node(2, None, Some(3), 1_000));
+		assert_eq!(ListNodes::<Runtime>::get(3).unwrap(), node(3, Some(2), Some(4), 1_000));
+		assert_eq!(ListNodes::<Runtime>::get(4).unwrap(), node(4, Some(3), None, 1_000));
+		assert_eq!(ListNodes::<Runtime>::get(1).unwrap(), node(1, None, None, 10));
+
+		// non-existent id does not have a storage footprint
+		assert_eq!(ListNodes::<Runtime>::get(42), None);
+
+		// iteration of the bags would yield:
+		assert_eq!(
+			List::<Runtime>::iter().map(|n| *n.id()).collect::<Vec<_>>(),
+			vec![2, 3, 4, 1],
+			//   ^^ note the order of insertion in genesis!
+		);
+	});
+}
+
+#[test]
+fn notional_bag_for_works() {
+	// under a threshold gives the next threshold.
+	assert_eq!(notional_bag_for::<Runtime, _>(0), 10);
+	assert_eq!(notional_bag_for::<Runtime, _>(9), 10);
+
+	// at a threshold gives that threshold.
+	assert_eq!(notional_bag_for::<Runtime, _>(10), 10);
+
+	// above the threshold, gives the next threshold.
+	assert_eq!(notional_bag_for::<Runtime, _>(11), 20);
+
+	let max_explicit_threshold = *<Runtime as Config>::BagThresholds::get().last().unwrap();
+	assert_eq!(max_explicit_threshold, 10_000);
+
+	// if the max explicit threshold is less than T::Score::max_value(),
+	assert!(VoteWeight::MAX > max_explicit_threshold);
+
+	// then anything above it will belong to the T::Score::max_value() bag.
+	assert_eq!(notional_bag_for::<Runtime, _>(max_explicit_threshold), max_explicit_threshold);
+	assert_eq!(notional_bag_for::<Runtime, _>(max_explicit_threshold + 1), VoteWeight::MAX);
+}
+
+#[test]
+fn remove_last_node_in_bags_cleans_bag() {
+	ExtBuilder::default().build_and_execute(|| {
+		// given
+		assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+		// bump 1 to a bigger bag
+		List::<Runtime>::remove(&1).unwrap();
+		assert_ok!(List::<Runtime>::insert(1, 10_000));
+
+		// then the bag with bound 10 is wiped from storage.
+		assert_eq!(List::<Runtime>::get_bags(), vec![(1_000, vec![2, 3, 4]), (10_000, vec![1])]);
+
+		// and can be recreated again as needed.
+		assert_ok!(List::<Runtime>::insert(77, 10));
+		assert_eq!(
+			List::<Runtime>::get_bags(),
+			vec![(10, vec![77]), (1_000, vec![2, 3, 4]), (10_000, vec![1])]
+		);
+	});
+}
+
+#[test]
+fn migrate_works() {
+	ExtBuilder::default()
+		.add_ids(vec![(710, 15), (711, 16), (712, 2_000)])
+		.build_and_execute(|| {
+			// given
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![
+					(10, vec![1]),
+					(20, vec![710, 711]),
+					(1_000, vec![2, 3, 4]),
+					(2_000, vec![712])
+				]
+			);
+			let old_thresholds = <Runtime as Config>::BagThresholds::get();
+			assert_eq!(old_thresholds, vec![10, 20, 30, 40, 50, 60, 1_000, 2_000, 10_000]);
+
+			// when the new thresholds adds `15` and removes `2_000`
+			const NEW_THRESHOLDS: &'static [VoteWeight] =
+				&[10, 15, 20, 30, 40, 50, 60, 1_000, 10_000];
+			BagThresholds::set(NEW_THRESHOLDS);
+			// and we call
+			List::<Runtime>::migrate(old_thresholds);
+			assert_eq!(List::<Runtime>::do_try_state(), Ok(()));
+
+			// then
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![
+					(10, vec![1]),
+					(15, vec![710]), // nodes in range 11 ..= 15 move from bag 20 to bag 15
+					(20, vec![711]),
+					(1_000, vec![2, 3, 4]),
+					// nodes in range 1_001 ..= 2_000 move from bag 2_000 to bag 10_000
+					(10_000, vec![712]),
+				]
+			);
+		});
+}
+
+mod list {
+	use frame_support::assert_noop;
+
+	use super::*;
+
+	#[test]
+	fn iteration_is_semi_sorted() {
+		ExtBuilder::default()
+			.add_ids(vec![(5, 2_000), (6, 2_000)])
+			.build_and_execute(|| {
+				// given
+				assert_eq!(
+					List::<Runtime>::get_bags(),
+					vec![(10, vec![1]), (1_000, vec![2, 3, 4]), (2_000, vec![5, 6])]
+				);
+				assert_eq!(
+					get_list_as_ids(),
+					vec![
+						5, 6, // best bag
+						2, 3, 4, // middle bag
+						1, // last bag.
+					]
+				);
+
+				// when adding an id that has a higher score than pre-existing ids in the bag
+				assert_ok!(List::<Runtime>::insert(7, 10));
+
+				// then
+				assert_eq!(
+					get_list_as_ids(),
+					vec![
+						5, 6, // best bag
+						2, 3, 4, // middle bag
+						1, 7, // last bag; new id is last.
+					]
+				);
+			})
+	}
+
+	/// we can `take` x ids, even if that quantity ends midway through a list.
+	#[test]
+	fn take_works() {
+		ExtBuilder::default()
+			.add_ids(vec![(5, 2_000), (6, 2_000)])
+			.build_and_execute(|| {
+				// given
+				assert_eq!(
+					List::<Runtime>::get_bags(),
+					vec![(10, vec![1]), (1_000, vec![2, 3, 4]), (2_000, vec![5, 6])]
+				);
+
+				// when
+				let iteration =
+					List::<Runtime>::iter().map(|node| *node.id()).take(4).collect::<Vec<_>>();
+
+				// then
+				assert_eq!(
+					iteration,
+					vec![
+						5, 6, // best bag, fully iterated
+						2, 3, // middle bag, partially iterated
+					]
+				);
+			})
+	}
+
+	#[test]
+	fn insert_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// when inserting into an existing bag
+			assert_ok!(List::<Runtime>::insert(5, 1_000));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4, 5])]);
+			assert_eq!(get_list_as_ids(), vec![2, 3, 4, 5, 1]);
+
+			// when inserting into a non-existent bag
+			assert_ok!(List::<Runtime>::insert(6, 1_001));
+
+			// then
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4, 5]), (2_000, vec![6])]
+			);
+			assert_eq!(get_list_as_ids(), vec![6, 2, 3, 4, 5, 1]);
+		});
+	}
+
+	#[test]
+	fn insert_errors_with_duplicate_id() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert!(get_list_as_ids().contains(&3));
+
+			// then
+			assert_noop!(List::<Runtime>::insert(3, 20), ListError::Duplicate);
+		});
+	}
+
+	#[test]
+	fn remove_works() {
+		use crate::{ListBags, ListNodes};
+		let ensure_left = |id, counter| {
+			assert!(!ListNodes::<Runtime>::contains_key(id));
+			assert_eq!(ListNodes::<Runtime>::count(), counter);
+			assert_eq!(ListNodes::<Runtime>::iter().count() as u32, counter);
+		};
+
+		ExtBuilder::default().build_and_execute(|| {
+			// removing a non-existent id is a noop
+			assert!(!ListNodes::<Runtime>::contains_key(42));
+			assert_noop!(List::<Runtime>::remove(&42), ListError::NodeNotFound);
+
+			// when removing a node from a bag with multiple nodes:
+			List::<Runtime>::remove(&2).unwrap();
+
+			// then
+			assert_eq!(get_list_as_ids(), vec![3, 4, 1]);
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![3, 4])]);
+			ensure_left(2, 3);
+
+			// when removing a node from a bag with only one node:
+			List::<Runtime>::remove(&1).unwrap();
+
+			// then
+			assert_eq!(get_list_as_ids(), vec![3, 4]);
+			assert_eq!(List::<Runtime>::get_bags(), vec![(1_000, vec![3, 4])]);
+			ensure_left(1, 2);
+			// bag 10 is removed
+			assert!(!ListBags::<Runtime>::contains_key(10));
+
+			// remove remaining ids to make sure storage cleans up as expected
+			List::<Runtime>::remove(&3).unwrap();
+			ensure_left(3, 1);
+			assert_eq!(get_list_as_ids(), vec![4]);
+
+			List::<Runtime>::remove(&4).unwrap();
+			ensure_left(4, 0);
+			assert_eq!(get_list_as_ids(), Vec::<AccountId>::new());
+
+			// bags are deleted via removals
+			assert_eq!(ListBags::<Runtime>::iter().count(), 0);
+		});
+	}
+
+	#[test]
+	fn remove_many_is_noop_with_non_existent_ids() {
+		ExtBuilder::default().build_and_execute(|| {
+			let non_existent_ids = vec![&42, &666, &13];
+
+			// when account ids don' exist in the list
+			assert!(non_existent_ids.iter().all(|id| !BagsList::contains(id)));
+
+			// then removing them is a noop
+			assert_storage_noop!(List::<Runtime>::remove_many(non_existent_ids));
+		});
+	}
+
+	#[test]
+	fn update_position_for_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given a correctly placed account 1 at bag 10.
+			let node = Node::<Runtime>::get(&1).unwrap();
+			assert_eq!(node.score, 10);
+			assert!(!node.is_misplaced(10));
+
+			// .. it is invalid with score 20
+			assert!(node.is_misplaced(20));
+
+			// move it to bag 20.
+			assert_eq!(List::<Runtime>::update_position_for(node.clone(), 20), Some((10, 20)));
+			assert_eq!(Node::<Runtime>::get(&1).unwrap().score, 20);
+
+			assert_eq!(List::<Runtime>::get_bags(), vec![(20, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// get the new updated node; try and update the position with no change in score.
+			let node = Node::<Runtime>::get(&1).unwrap();
+			assert_storage_noop!(assert_eq!(
+				List::<Runtime>::update_position_for(node.clone(), 20),
+				None
+			));
+
+			// then move it to bag 1_000 by giving it score 500.
+			assert_eq!(List::<Runtime>::update_position_for(node.clone(), 500), Some((20, 1_000)));
+			assert_eq!(Node::<Runtime>::get(&1).unwrap().score, 500);
+			assert_eq!(List::<Runtime>::get_bags(), vec![(1_000, vec![2, 3, 4, 1])]);
+
+			// moving within that bag again is a noop
+			let node = Node::<Runtime>::get(&1).unwrap();
+			assert_eq!(List::<Runtime>::update_position_for(node.clone(), 750), None);
+			assert_eq!(Node::<Runtime>::get(&1).unwrap().score, 750);
+			assert_eq!(List::<Runtime>::update_position_for(node.clone(), 1_000), None,);
+			assert_eq!(Node::<Runtime>::get(&1).unwrap().score, 1_000);
+		});
+	}
+
+	#[test]
+	fn try_state_works() {
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			assert_ok!(List::<Runtime>::do_try_state());
+		});
+
+		// make sure there are no duplicates.
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			Bag::<Runtime>::get(10).unwrap().insert_unchecked(2, 10);
+			assert_eq!(
+				List::<Runtime>::do_try_state(),
+				TryRuntimeError::Other("duplicate identified").into()
+			);
+		});
+
+		// ensure count is in sync with `ListNodes::count()`.
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			assert_eq!(crate::ListNodes::<Runtime>::count(), 4);
+			// we do some wacky stuff here to get access to the counter, since it is (reasonably)
+			// not exposed as mutable in any sense.
+			#[frame_support::storage_alias]
+			type CounterForListNodes<T: Config> =
+				StorageValue<crate::Pallet<T>, u32, frame_support::pallet_prelude::ValueQuery>;
+			CounterForListNodes::<Runtime>::mutate(|counter| *counter += 1);
+			assert_eq!(crate::ListNodes::<Runtime>::count(), 5);
+
+			assert_eq!(
+				List::<Runtime>::do_try_state(),
+				TryRuntimeError::Other("iter_count != stored_count").into()
+			);
+		});
+	}
+
+	#[test]
+	fn contains_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert!(GENESIS_IDS.iter().all(|(id, _)| List::<Runtime>::contains(id)));
+
+			let non_existent_ids = vec![&42, &666, &13];
+			assert!(non_existent_ids.iter().all(|id| !List::<Runtime>::contains(id)));
+		})
+	}
+
+	#[test]
+	#[should_panic = "given nodes must always have a valid bag. qed."]
+	fn put_in_front_of_panics_if_bag_not_found() {
+		ExtBuilder::default().skip_genesis_ids().build_and_execute_no_post_check(|| {
+			let node_10_no_bag = Node::<Runtime> {
+				id: 10,
+				prev: None,
+				next: None,
+				bag_upper: 15,
+				score: 15,
+				_phantom: PhantomData,
+			};
+			let node_11_no_bag = Node::<Runtime> {
+				id: 11,
+				prev: None,
+				next: None,
+				bag_upper: 15,
+				score: 15,
+				_phantom: PhantomData,
+			};
+
+			// given
+			ListNodes::<Runtime>::insert(10, node_10_no_bag);
+			ListNodes::<Runtime>::insert(11, node_11_no_bag);
+			StakingMock::set_score_of(&10, 14);
+			StakingMock::set_score_of(&11, 15);
+			assert!(!ListBags::<Runtime>::contains_key(15));
+			assert_eq!(List::<Runtime>::get_bags(), vec![]);
+
+			// then .. this panics
+			let _ = List::<Runtime>::put_in_front_of(&10, &11);
+		});
+	}
+
+	#[test]
+	fn insert_at_unchecked_at_is_only_node() {
+		// Note that this `insert_at_unchecked` test should fail post checks because node 42 does
+		// not get re-assigned the correct bagu pper. This is because `insert_at_unchecked` assumes
+		// both nodes are already in the same bag with the correct bag upper.
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// implicitly also test that `node`'s `prev`/`next` are correctly re-assigned.
+			let node_42 = Node::<Runtime> {
+				id: 42,
+				prev: Some(1),
+				next: Some(2),
+				bag_upper: 1_000,
+				score: 1_000,
+				_phantom: PhantomData,
+			};
+			assert!(!crate::ListNodes::<Runtime>::contains_key(42));
+
+			let node_1 = crate::ListNodes::<Runtime>::get(&1).unwrap();
+
+			// when
+			List::<Runtime>::insert_at_unchecked(node_1, node_42);
+
+			// then
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![42, 1]), (1_000, vec![2, 3, 4])]
+			);
+		})
+	}
+
+	#[test]
+	fn insert_at_unchecked_at_is_head() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// implicitly also test that `node`'s `prev`/`next` are correctly re-assigned.
+			let node_42 = Node::<Runtime> {
+				id: 42,
+				prev: Some(4),
+				next: None,
+				bag_upper: 1_000,
+				score: 1_000,
+				_phantom: PhantomData,
+			};
+			assert!(!crate::ListNodes::<Runtime>::contains_key(42));
+
+			let node_2 = crate::ListNodes::<Runtime>::get(&2).unwrap();
+
+			// when
+			List::<Runtime>::insert_at_unchecked(node_2, node_42);
+
+			// then
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![42, 2, 3, 4])]
+			);
+		})
+	}
+
+	#[test]
+	fn insert_at_unchecked_at_is_non_terminal() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// implicitly also test that `node`'s `prev`/`next` are correctly re-assigned.
+			let node_42 = Node::<Runtime> {
+				id: 42,
+				prev: None,
+				next: Some(2),
+				bag_upper: 1_000,
+				score: 1_000,
+				_phantom: PhantomData,
+			};
+			assert!(!crate::ListNodes::<Runtime>::contains_key(42));
+
+			let node_3 = crate::ListNodes::<Runtime>::get(&3).unwrap();
+
+			// when
+			List::<Runtime>::insert_at_unchecked(node_3, node_42);
+
+			// then
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 42, 3, 4])]
+			);
+		})
+	}
+
+	#[test]
+	fn insert_at_unchecked_at_is_tail() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// implicitly also test that `node`'s `prev`/`next` are correctly re-assigned.
+			let node_42 = Node::<Runtime> {
+				id: 42,
+				prev: Some(42),
+				next: Some(42),
+				bag_upper: 1_000,
+				score: 1_000,
+				_phantom: PhantomData,
+			};
+			assert!(!crate::ListNodes::<Runtime>::contains_key(42));
+
+			let node_4 = crate::ListNodes::<Runtime>::get(&4).unwrap();
+
+			// when
+			List::<Runtime>::insert_at_unchecked(node_4, node_42);
+
+			// then
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 42, 4])]
+			);
+		})
+	}
+}
+
+mod bags {
+	use super::*;
+
+	#[test]
+	fn get_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let check_bag = |bag_upper, head, tail, ids| {
+				let bag = Bag::<Runtime>::get(bag_upper).unwrap();
+				let bag_ids = bag.iter().map(|n| *n.id()).collect::<Vec<_>>();
+
+				assert_eq!(bag, Bag::<Runtime> { head, tail, bag_upper, _phantom: PhantomData });
+				assert_eq!(bag_ids, ids);
+			};
+
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// we can fetch them
+			check_bag(10, Some(1), Some(1), vec![1]);
+			check_bag(1_000, Some(2), Some(4), vec![2, 3, 4]);
+
+			// and all other bag thresholds don't get bags.
+			<Runtime as Config>::BagThresholds::get()
+				.iter()
+				.chain(iter::once(&VoteWeight::MAX))
+				.filter(|bag_upper| !vec![10, 1_000].contains(bag_upper))
+				.for_each(|bag_upper| {
+					assert_storage_noop!(assert_eq!(Bag::<Runtime>::get(*bag_upper), None));
+					assert!(!ListBags::<Runtime>::contains_key(*bag_upper));
+				});
+
+			// when we make a pre-existing bag empty
+			List::<Runtime>::remove(&1).unwrap();
+
+			// then
+			assert_eq!(Bag::<Runtime>::get(10), None)
+		});
+	}
+
+	#[test]
+	fn insert_node_sets_proper_bag() {
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			let node = |id, bag_upper| Node::<Runtime> {
+				id,
+				prev: None,
+				next: None,
+				bag_upper,
+				score: bag_upper,
+				_phantom: PhantomData,
+			};
+
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			let mut bag_10 = Bag::<Runtime>::get(10).unwrap();
+			bag_10.insert_node_unchecked(node(42, 5));
+
+			assert_eq!(
+				ListNodes::<Runtime>::get(&42).unwrap(),
+				Node {
+					bag_upper: 10,
+					score: 5,
+					prev: Some(1),
+					next: None,
+					id: 42,
+					_phantom: PhantomData
+				}
+			);
+		});
+	}
+
+	#[test]
+	fn insert_node_happy_paths_works() {
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			let node = |id, bag_upper| Node::<Runtime> {
+				id,
+				prev: None,
+				next: None,
+				bag_upper,
+				score: bag_upper,
+				_phantom: PhantomData,
+			};
+
+			// when inserting into a bag with 1 node
+			let mut bag_10 = Bag::<Runtime>::get(10).unwrap();
+			bag_10.insert_node_unchecked(node(42, bag_10.bag_upper));
+			// then
+			assert_eq!(bag_as_ids(&bag_10), vec![1, 42]);
+
+			// when inserting into a bag with 3 nodes
+			let mut bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+			bag_1000.insert_node_unchecked(node(52, bag_1000.bag_upper));
+			// then
+			assert_eq!(bag_as_ids(&bag_1000), vec![2, 3, 4, 52]);
+
+			// when inserting into a new bag
+			let mut bag_20 = Bag::<Runtime>::get_or_make(20);
+			bag_20.insert_node_unchecked(node(62, bag_20.bag_upper));
+			// then
+			assert_eq!(bag_as_ids(&bag_20), vec![62]);
+
+			// when inserting a node pointing to the accounts not in the bag
+			let node_61 = Node::<Runtime> {
+				id: 61,
+				prev: Some(21),
+				next: Some(101),
+				bag_upper: 20,
+				score: 20,
+				_phantom: PhantomData,
+			};
+			bag_20.insert_node_unchecked(node_61);
+			// then ids are in order
+			assert_eq!(bag_as_ids(&bag_20), vec![62, 61]);
+			// and when the node is re-fetched all the info is correct
+			assert_eq!(
+				Node::<Runtime>::get(&61).unwrap(),
+				Node::<Runtime> {
+					id: 61,
+					prev: Some(62),
+					next: None,
+					bag_upper: 20,
+					score: 20,
+					_phantom: PhantomData,
+				}
+			);
+
+			// state of all bags is as expected
+			bag_20.put(); // need to put this newly created bag so its in the storage map
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1, 42]), (20, vec![62, 61]), (1_000, vec![2, 3, 4, 52])]
+			);
+		});
+	}
+
+	// Document improper ways `insert_node` may be getting used.
+	#[test]
+	fn insert_node_bad_paths_documented() {
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			// when inserting a node with both prev & next pointing at an account in an incorrect
+			// bag.
+			let mut bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+			bag_1000.insert_node_unchecked(node(42, Some(1), Some(1), 500));
+
+			// then the proper prev and next is set.
+			assert_eq!(bag_as_ids(&bag_1000), vec![2, 3, 4, 42]);
+
+			// and when the node is re-fetched all the info is correct
+			assert_eq!(
+				Node::<Runtime>::get(&42).unwrap(),
+				Node::<Runtime> {
+					id: 42,
+					prev: Some(4),
+					next: None,
+					bag_upper: bag_1000.bag_upper,
+					score: 500,
+					_phantom: PhantomData
+				}
+			);
+		});
+
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			// given 3 is in bag_1000 (and not a tail node)
+			let mut bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+			assert_eq!(bag_as_ids(&bag_1000), vec![2, 3, 4]);
+
+			// when inserting a node with duplicate id 3
+			bag_1000.insert_node_unchecked(node(3, None, None, bag_1000.bag_upper));
+
+			// then all the nodes after the duplicate are lost (because it is set as the tail)
+			assert_eq!(bag_as_ids(&bag_1000), vec![2, 3]);
+			// also in the full iteration, 2 and 3 are from bag_1000 and 1 is from bag_10.
+			assert_eq!(get_list_as_ids(), vec![2, 3, 1]);
+
+			// and the last accessible node has an **incorrect** prev pointer.
+			assert_eq!(
+				Node::<Runtime>::get(&3).unwrap(),
+				node(3, Some(4), None, bag_1000.bag_upper)
+			);
+		});
+
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			// when inserting a duplicate id of the head
+			let mut bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+			assert_eq!(bag_as_ids(&bag_1000), vec![2, 3, 4]);
+			bag_1000.insert_node_unchecked(node(2, None, None, 0));
+
+			// then all nodes after the head are lost
+			assert_eq!(bag_as_ids(&bag_1000), vec![2]);
+
+			// and the re-fetched node has bad pointers
+			assert_eq!(
+				Node::<Runtime>::get(&2).unwrap(),
+				Node::<Runtime> {
+					id: 2,
+					prev: Some(4),
+					next: None,
+					bag_upper: bag_1000.bag_upper,
+					score: 0,
+					_phantom: PhantomData
+				},
+			);
+			//         ^^^ despite being the bags head, it has a prev
+
+			assert_eq!(
+				bag_1000,
+				Bag { head: Some(2), tail: Some(2), bag_upper: 1_000, _phantom: PhantomData }
+			)
+		});
+	}
+
+	// Panics in case of duplicate tail insert (which would result in an infinite loop).
+	#[test]
+	#[cfg_attr(
+		debug_assertions,
+		should_panic = "system logic error: inserting a node who has the id of tail"
+	)]
+	fn insert_node_duplicate_tail_panics_with_debug_assert() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])],);
+			let mut bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+
+			// when inserting a duplicate id that is already the tail
+			assert_eq!(bag_1000.tail, Some(4));
+			assert_eq!(bag_1000.iter().count(), 3);
+			bag_1000.insert_node_unchecked(node(4, None, None, bag_1000.bag_upper)); // panics in debug
+			assert_eq!(bag_1000.iter().count(), 3); // in release we expect it to silently ignore the request.
+		});
+	}
+
+	#[test]
+	fn remove_node_happy_paths_works() {
+		ExtBuilder::default()
+			.add_ids(vec![
+				(11, 10),
+				(12, 10),
+				(13, 1_000),
+				(14, 1_000),
+				(15, 2_000),
+				(16, 2_000),
+				(17, 2_000),
+				(18, 2_000),
+				(19, 2_000),
+			])
+			.build_and_execute_no_post_check(|| {
+				let mut bag_10 = Bag::<Runtime>::get(10).unwrap();
+				let mut bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+				let mut bag_2000 = Bag::<Runtime>::get(2_000).unwrap();
+
+				// given
+				assert_eq!(bag_as_ids(&bag_10), vec![1, 11, 12]);
+				assert_eq!(bag_as_ids(&bag_1000), vec![2, 3, 4, 13, 14]);
+				assert_eq!(bag_as_ids(&bag_2000), vec![15, 16, 17, 18, 19]);
+
+				// when removing a node that is not pointing at the head or tail
+				let node_4 = Node::<Runtime>::get(&4).unwrap();
+				let node_4_pre_remove = node_4.clone();
+				bag_1000.remove_node_unchecked(&node_4);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_1000), vec![2, 3, 13, 14]);
+				assert_ok!(bag_1000.do_try_state());
+				// and the node isn't mutated when its removed
+				assert_eq!(node_4, node_4_pre_remove);
+
+				// when removing a head that is not pointing at the tail
+				let node_2 = Node::<Runtime>::get(&2).unwrap();
+				bag_1000.remove_node_unchecked(&node_2);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_1000), vec![3, 13, 14]);
+				assert_ok!(bag_1000.do_try_state());
+
+				// when removing a tail that is not pointing at the head
+				let node_14 = Node::<Runtime>::get(&14).unwrap();
+				bag_1000.remove_node_unchecked(&node_14);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_1000), vec![3, 13]);
+				assert_ok!(bag_1000.do_try_state());
+
+				// when removing a tail that is pointing at the head
+				let node_13 = Node::<Runtime>::get(&13).unwrap();
+				bag_1000.remove_node_unchecked(&node_13);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_1000), vec![3]);
+				assert_ok!(bag_1000.do_try_state());
+
+				// when removing a node that is both the head & tail
+				let node_3 = Node::<Runtime>::get(&3).unwrap();
+				bag_1000.remove_node_unchecked(&node_3);
+				bag_1000.put(); // put into storage so `get` returns the updated bag
+
+				// then
+				assert_eq!(Bag::<Runtime>::get(1_000), None);
+
+				// when removing a node that is pointing at both the head & tail
+				let node_11 = Node::<Runtime>::get(&11).unwrap();
+				bag_10.remove_node_unchecked(&node_11);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_10), vec![1, 12]);
+				assert_ok!(bag_10.do_try_state());
+
+				// when removing a head that is pointing at the tail
+				let node_1 = Node::<Runtime>::get(&1).unwrap();
+				bag_10.remove_node_unchecked(&node_1);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_10), vec![12]);
+				assert_ok!(bag_10.do_try_state());
+				// and since we updated the bag's head/tail, we need to write this storage so we
+				// can correctly `get` it again in later checks
+				bag_10.put();
+
+				// when removing a node that is pointing at the head but not the tail
+				let node_16 = Node::<Runtime>::get(&16).unwrap();
+				bag_2000.remove_node_unchecked(&node_16);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_2000), vec![15, 17, 18, 19]);
+				assert_ok!(bag_2000.do_try_state());
+
+				// when removing a node that is pointing at tail, but not head
+				let node_18 = Node::<Runtime>::get(&18).unwrap();
+				bag_2000.remove_node_unchecked(&node_18);
+
+				// then
+				assert_eq!(bag_as_ids(&bag_2000), vec![15, 17, 19]);
+				assert_ok!(bag_2000.do_try_state());
+
+				// finally, when reading from storage, the state of all bags is as expected
+				assert_eq!(
+					List::<Runtime>::get_bags(),
+					vec![(10, vec![12]), (2_000, vec![15, 17, 19])]
+				);
+			});
+	}
+
+	#[test]
+	fn remove_node_bad_paths_documented() {
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			let bad_upper_node_2 = Node::<Runtime> {
+				id: 2,
+				prev: None,
+				next: Some(3),
+				bag_upper: 10, // should be 1_000
+				score: 10,
+				_phantom: PhantomData,
+			};
+			let mut bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+
+			// when removing a node that is in the bag but has the wrong upper
+			bag_1000.remove_node_unchecked(&bad_upper_node_2);
+			bag_1000.put();
+
+			// then the node is no longer in any bags
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![3, 4])]);
+			// .. and the bag it was removed from
+			let bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+			// is sane
+			assert_ok!(bag_1000.do_try_state());
+			// and has the correct head and tail.
+			assert_eq!(bag_1000.head, Some(3));
+			assert_eq!(bag_1000.tail, Some(4));
+		});
+
+		// Removing a node that is in another bag, will mess up that other bag.
+		ExtBuilder::default().build_and_execute_no_post_check(|| {
+			// given a tail node is in bag 1_000
+			let node_4 = Node::<Runtime>::get(&4).unwrap();
+
+			// when we remove it from bag 10
+			let mut bag_10 = Bag::<Runtime>::get(10).unwrap();
+			bag_10.remove_node_unchecked(&node_4);
+			bag_10.put();
+
+			// then bag remove was called on is ok,
+			let bag_10 = Bag::<Runtime>::get(10).unwrap();
+			assert_eq!(bag_10.tail, Some(1));
+			assert_eq!(bag_10.head, Some(1));
+
+			// but the bag that the node belonged to is in an invalid state
+			let bag_1000 = Bag::<Runtime>::get(1_000).unwrap();
+			// because it still has the removed node as its tail.
+			assert_eq!(bag_1000.tail, Some(4));
+			assert_eq!(bag_1000.head, Some(2));
+		});
+	}
+}
+
+mod node {
+	use super::*;
+
+	#[test]
+	fn is_misplaced_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let node = Node::<Runtime>::get(&1).unwrap();
+
+			// given
+			assert_eq!(node.bag_upper, 10);
+
+			// then within bag 10 its not misplaced,
+			assert!(!node.is_misplaced(0));
+			assert!(!node.is_misplaced(9));
+			assert!(!node.is_misplaced(10));
+
+			// and out of bag 10 it is misplaced
+			assert!(node.is_misplaced(11));
+		});
+	}
+}
diff --git a/substrate/frame/bags-list/src/migrations.rs b/substrate/frame/bags-list/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7df63a6a44c54ebaeae42a177ed0328766e53593
--- /dev/null
+++ b/substrate/frame/bags-list/src/migrations.rs
@@ -0,0 +1,141 @@
+// 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.
+
+//! The migrations of this pallet.
+
+use codec::{Decode, Encode};
+use core::marker::PhantomData;
+use frame_election_provider_support::ScoreProvider;
+use frame_support::traits::OnRuntimeUpgrade;
+
+#[cfg(feature = "try-runtime")]
+use frame_support::ensure;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+#[cfg(feature = "try-runtime")]
+use sp_std::vec::Vec;
+
+/// A struct that does not migration, but only checks that the counter prefix exists and is correct.
+pub struct CheckCounterPrefix<T: crate::Config<I>, I: 'static>(sp_std::marker::PhantomData<(T, I)>);
+impl<T: crate::Config<I>, I: 'static> OnRuntimeUpgrade for CheckCounterPrefix<T, I> {
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		frame_support::weights::Weight::zero()
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		// The old explicit storage item.
+		#[frame_support::storage_alias]
+		type CounterForListNodes<T: crate::Config<I>, I: 'static> =
+			StorageValue<crate::Pallet<T, I>, u32>;
+
+		// ensure that a value exists in the counter struct.
+		ensure!(
+			crate::ListNodes::<T, I>::count() == CounterForListNodes::<T, I>::get().unwrap(),
+			"wrong list node counter"
+		);
+
+		crate::log!(
+			info,
+			"checked bags-list prefix to be correct and have {} nodes",
+			crate::ListNodes::<T, I>::count()
+		);
+
+		Ok(Vec::new())
+	}
+}
+
+mod old {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[derive(Encode, Decode)]
+	pub struct PreScoreNode<T: crate::Config<I>, I: 'static = ()> {
+		pub id: T::AccountId,
+		pub prev: Option<T::AccountId>,
+		pub next: Option<T::AccountId>,
+		pub bag_upper: T::Score,
+		#[codec(skip)]
+		pub _phantom: PhantomData<I>,
+	}
+
+	#[frame_support::storage_alias]
+	pub type ListNodes<T: crate::Config<I>, I: 'static> = StorageMap<
+		crate::Pallet<T, I>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		PreScoreNode<T, I>,
+	>;
+
+	#[frame_support::storage_alias]
+	pub type CounterForListNodes<T: crate::Config<I>, I: 'static> =
+		StorageValue<crate::Pallet<T, I>, u32, ValueQuery>;
+}
+
+/// A struct that migrates all bags lists to contain a score value.
+pub struct AddScore<T: crate::Config<I>, I: 'static = ()>(sp_std::marker::PhantomData<(T, I)>);
+impl<T: crate::Config<I>, I: 'static> OnRuntimeUpgrade for AddScore<T, I> {
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		// The list node data should be corrupt at this point, so this is zero.
+		ensure!(crate::ListNodes::<T, I>::iter().count() == 0, "list node data is not corrupt");
+		// We can use the helper `old::ListNode` to get the existing data.
+		let iter_node_count: u32 = old::ListNodes::<T, I>::iter().count() as u32;
+		let tracked_node_count: u32 = old::CounterForListNodes::<T, I>::get();
+		crate::log!(info, "number of nodes before: {:?} {:?}", iter_node_count, tracked_node_count);
+		ensure!(iter_node_count == tracked_node_count, "Node count is wrong.");
+		Ok(iter_node_count.encode())
+	}
+
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		for (_key, node) in old::ListNodes::<T, I>::iter() {
+			let score = T::ScoreProvider::score(&node.id);
+
+			let new_node = crate::Node {
+				id: node.id.clone(),
+				prev: node.prev,
+				next: node.next,
+				bag_upper: node.bag_upper,
+				score,
+				_phantom: node._phantom,
+			};
+
+			crate::ListNodes::<T, I>::insert(node.id, new_node);
+		}
+
+		return frame_support::weights::Weight::MAX
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(node_count_before: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let node_count_before: u32 = Decode::decode(&mut node_count_before.as_slice())
+			.expect("the state parameter should be something that was generated by pre_upgrade");
+		// Now the list node data is not corrupt anymore.
+		let iter_node_count_after: u32 = crate::ListNodes::<T, I>::iter().count() as u32;
+		let tracked_node_count_after: u32 = crate::ListNodes::<T, I>::count();
+		crate::log!(
+			info,
+			"number of nodes after: {:?} {:?}",
+			iter_node_count_after,
+			tracked_node_count_after,
+		);
+		ensure!(iter_node_count_after == node_count_before, "Not all nodes were migrated.");
+		ensure!(tracked_node_count_after == iter_node_count_after, "Node count is wrong.");
+		Ok(())
+	}
+}
diff --git a/substrate/frame/bags-list/src/mock.rs b/substrate/frame/bags-list/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ae50adabd508a8c5e429c452e9fde28159ee9f53
--- /dev/null
+++ b/substrate/frame/bags-list/src/mock.rs
@@ -0,0 +1,172 @@
+// 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.
+
+//! Mock runtime for pallet-bags-lists tests.
+
+use super::*;
+use crate::{self as bags_list};
+use frame_election_provider_support::VoteWeight;
+use frame_support::parameter_types;
+use sp_runtime::BuildStorage;
+use std::collections::HashMap;
+
+pub type AccountId = u32;
+pub type Balance = u32;
+
+parameter_types! {
+	// Set the vote weight for any id who's weight has _not_ been set with `set_score_of`.
+	pub static NextVoteWeight: VoteWeight = 0;
+	pub static NextVoteWeightMap: HashMap<AccountId, VoteWeight> = Default::default();
+}
+
+pub struct StakingMock;
+impl frame_election_provider_support::ScoreProvider<AccountId> for StakingMock {
+	type Score = VoteWeight;
+
+	fn score(id: &AccountId) -> Self::Score {
+		*NextVoteWeightMap::get().get(id).unwrap_or(&NextVoteWeight::get())
+	}
+
+	frame_election_provider_support::runtime_benchmarks_fuzz_or_std_enabled! {
+		fn set_score_of(id: &AccountId, weight: Self::Score) {
+			NEXT_VOTE_WEIGHT_MAP.with(|m| m.borrow_mut().insert(*id, weight));
+		}
+	}
+}
+
+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 BagThresholds: &'static [VoteWeight] = &[10, 20, 30, 40, 50, 60, 1_000, 2_000, 10_000];
+}
+
+impl bags_list::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type BagThresholds = BagThresholds;
+	type ScoreProvider = StakingMock;
+	type Score = VoteWeight;
+}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Storage, Event<T>, Config<T>},
+		BagsList: bags_list::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+/// Default AccountIds and their weights.
+pub(crate) const GENESIS_IDS: [(AccountId, VoteWeight); 4] =
+	[(1, 10), (2, 1_000), (3, 1_000), (4, 1_000)];
+
+#[derive(Default)]
+pub struct ExtBuilder {
+	ids: Vec<(AccountId, VoteWeight)>,
+	skip_genesis_ids: bool,
+}
+
+#[cfg(any(feature = "runtime-benchmarks", feature = "fuzz", test))]
+impl ExtBuilder {
+	/// Skip adding the default genesis ids to the list.
+	#[cfg(test)]
+	pub(crate) fn skip_genesis_ids(mut self) -> Self {
+		self.skip_genesis_ids = true;
+		self
+	}
+
+	/// Add some AccountIds to insert into `List`.
+	#[cfg(test)]
+	pub(crate) fn add_ids(mut self, ids: Vec<(AccountId, VoteWeight)>) -> Self {
+		self.ids = ids;
+		self
+	}
+
+	pub(crate) fn build(self) -> sp_io::TestExternalities {
+		sp_tracing::try_init_simple();
+		let storage = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+		let ids_with_weight: Vec<_> = if self.skip_genesis_ids {
+			self.ids.iter().collect()
+		} else {
+			GENESIS_IDS.iter().chain(self.ids.iter()).collect()
+		};
+
+		let mut ext = sp_io::TestExternalities::from(storage);
+		ext.execute_with(|| {
+			for (id, weight) in ids_with_weight {
+				frame_support::assert_ok!(List::<Runtime>::insert(*id, *weight));
+				StakingMock::set_score_of(id, *weight);
+			}
+		});
+
+		ext
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		self.build().execute_with(|| {
+			test();
+			List::<Runtime>::do_try_state().expect("do_try_state post condition failed")
+		})
+	}
+
+	#[cfg(test)]
+	pub(crate) fn build_and_execute_no_post_check(self, test: impl FnOnce() -> ()) {
+		self.build().execute_with(test)
+	}
+}
+
+#[cfg(test)]
+pub(crate) mod test_utils {
+	use super::*;
+	use list::Bag;
+
+	/// Returns the ordered ids within the given bag.
+	pub(crate) fn bag_as_ids(bag: &Bag<Runtime>) -> Vec<AccountId> {
+		bag.iter().map(|n| *n.id()).collect::<Vec<_>>()
+	}
+
+	/// Returns the ordered ids from the list.
+	pub(crate) fn get_list_as_ids() -> Vec<AccountId> {
+		List::<Runtime>::iter().map(|n| *n.id()).collect::<Vec<_>>()
+	}
+}
diff --git a/substrate/frame/bags-list/src/tests.rs b/substrate/frame/bags-list/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9e8508698d8e8f613b1b78fb6472386d046d9c98
--- /dev/null
+++ b/substrate/frame/bags-list/src/tests.rs
@@ -0,0 +1,738 @@
+// 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_support::{assert_noop, assert_ok, assert_storage_noop, traits::IntegrityTest};
+
+use super::*;
+use frame_election_provider_support::{SortedListProvider, VoteWeight};
+use list::Bag;
+use mock::{test_utils::*, *};
+
+#[docify::export]
+#[test]
+fn examples_work() {
+	ExtBuilder::default()
+		.skip_genesis_ids()
+		// initially set the score of 11 for 22 to push it next to 12
+		.add_ids(vec![(25, 25), (21, 21), (12, 12), (22, 11), (5, 5), (7, 7), (3, 3)])
+		.build_and_execute(|| {
+			// initial bags
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![
+					// bag 0 -> 10
+					(10, vec![5, 7, 3]),
+					// bag 10 -> 20
+					(20, vec![12, 22]),
+					// bag 20 -> 30
+					(30, vec![25, 21])
+				]
+			);
+
+			// set score of 22 to 22
+			StakingMock::set_score_of(&22, 22);
+
+			// now we rebag 22 to the first bag
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(42), 22));
+
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![
+					// bag 0 -> 10
+					(10, vec![5, 7, 3]),
+					// bag 10 -> 20
+					(20, vec![12]),
+					// bag 20 -> 30
+					(30, vec![25, 21, 22])
+				]
+			);
+
+			// now we put 7 at the front of bag 0
+			assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(7), 5));
+
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![
+					// bag 0 -> 10
+					(10, vec![7, 5, 3]),
+					// bag 10 -> 20
+					(20, vec![12]),
+					// bag 20 -> 30
+					(30, vec![25, 21, 22])
+				]
+			);
+		})
+}
+
+mod pallet {
+	use super::*;
+
+	#[test]
+	fn rebag_works() {
+		ExtBuilder::default().add_ids(vec![(42, 20)]).build_and_execute(|| {
+			// given
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (20, vec![42]), (1_000, vec![2, 3, 4])]
+			);
+
+			// when increasing score to the level of non-existent bag
+			assert_eq!(List::<Runtime>::get_score(&42).unwrap(), 20);
+			StakingMock::set_score_of(&42, 2_000);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 42));
+			assert_eq!(List::<Runtime>::get_score(&42).unwrap(), 2_000);
+
+			// then a new bag is created and the id moves into it
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4]), (2_000, vec![42])]
+			);
+
+			// when decreasing score within the range of the current bag
+			StakingMock::set_score_of(&42, 1_001);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 42));
+
+			// then the id does not move
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4]), (2_000, vec![42])]
+			);
+			// but the score is updated
+			assert_eq!(List::<Runtime>::get_score(&42).unwrap(), 1_001);
+
+			// when reducing score to the level of a non-existent bag
+			StakingMock::set_score_of(&42, 30);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 42));
+
+			// then a new bag is created and the id moves into it
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (30, vec![42]), (1_000, vec![2, 3, 4])]
+			);
+			assert_eq!(List::<Runtime>::get_score(&42).unwrap(), 30);
+
+			// when increasing score to the level of a pre-existing bag
+			StakingMock::set_score_of(&42, 500);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 42));
+
+			// then the id moves into that bag
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4, 42])]
+			);
+			assert_eq!(List::<Runtime>::get_score(&42).unwrap(), 500);
+		});
+	}
+
+	// Rebagging the tail of a bag results in the old bag having a new tail and an overall correct
+	// state.
+	#[test]
+	fn rebag_tail_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// when
+			StakingMock::set_score_of(&4, 10);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 4));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1, 4]), (1_000, vec![2, 3])]);
+			assert_eq!(Bag::<Runtime>::get(1_000).unwrap(), Bag::new(Some(2), Some(3), 1_000));
+
+			// when
+			StakingMock::set_score_of(&3, 10);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 3));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1, 4, 3]), (1_000, vec![2])]);
+
+			assert_eq!(Bag::<Runtime>::get(10).unwrap(), Bag::new(Some(1), Some(3), 10));
+			assert_eq!(Bag::<Runtime>::get(1_000).unwrap(), Bag::new(Some(2), Some(2), 1_000));
+			assert_eq!(get_list_as_ids(), vec![2u32, 1, 4, 3]);
+
+			// when
+			StakingMock::set_score_of(&2, 10);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 2));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1, 4, 3, 2])]);
+			assert_eq!(Bag::<Runtime>::get(1_000), None);
+		});
+	}
+
+	// Rebagging the head of a bag results in the old bag having a new head and an overall correct
+	// state.
+	#[test]
+	fn rebag_head_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// when
+			StakingMock::set_score_of(&2, 10);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 2));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1, 2]), (1_000, vec![3, 4])]);
+			assert_eq!(Bag::<Runtime>::get(1_000).unwrap(), Bag::new(Some(3), Some(4), 1_000));
+
+			// when
+			StakingMock::set_score_of(&3, 10);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 3));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1, 2, 3]), (1_000, vec![4])]);
+			assert_eq!(Bag::<Runtime>::get(1_000).unwrap(), Bag::new(Some(4), Some(4), 1_000));
+
+			// when
+			StakingMock::set_score_of(&4, 10);
+			assert_ok!(BagsList::rebag(RuntimeOrigin::signed(0), 4));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1, 2, 3, 4])]);
+			assert_eq!(Bag::<Runtime>::get(1_000), None);
+		});
+	}
+
+	#[test]
+	fn wrong_rebag_errs() {
+		ExtBuilder::default().build_and_execute(|| {
+			let node_3 = list::Node::<Runtime>::get(&3).unwrap();
+			// when account 3 is _not_ misplaced with score 500
+			NextVoteWeight::set(500);
+			assert!(!node_3.is_misplaced(500));
+
+			// then calling rebag on account 3 with score 500 is a noop
+			assert_storage_noop!(assert_eq!(BagsList::rebag(RuntimeOrigin::signed(0), 3), Ok(())));
+
+			// when account 42 is not in the list
+			assert!(!BagsList::contains(&42));
+			// then rebag-ing account 42 is an error
+			assert_storage_noop!(assert!(matches!(
+				BagsList::rebag(RuntimeOrigin::signed(0), 42),
+				Err(_)
+			)));
+		});
+	}
+
+	#[test]
+	#[should_panic = "thresholds must strictly increase, and have no duplicates"]
+	fn duplicate_in_bags_threshold_panics() {
+		const DUPE_THRESH: &[VoteWeight; 4] = &[10, 20, 30, 30];
+		BagThresholds::set(DUPE_THRESH);
+		BagsList::integrity_test();
+	}
+
+	#[test]
+	#[should_panic = "thresholds must strictly increase, and have no duplicates"]
+	fn decreasing_in_bags_threshold_panics() {
+		const DECREASING_THRESH: &[VoteWeight; 4] = &[10, 30, 20, 40];
+		BagThresholds::set(DECREASING_THRESH);
+		BagsList::integrity_test();
+	}
+
+	#[test]
+	fn empty_threshold_works() {
+		BagThresholds::set(Default::default()); // which is the same as passing `()` to `Get<_>`.
+		ExtBuilder::default().build_and_execute(|| {
+			// everyone in the same bag.
+			assert_eq!(List::<Runtime>::get_bags(), vec![(VoteWeight::MAX, vec![1, 2, 3, 4])]);
+
+			// any insertion goes there as well.
+			assert_ok!(List::<Runtime>::insert(5, 999));
+			assert_ok!(List::<Runtime>::insert(6, 0));
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(VoteWeight::MAX, vec![1, 2, 3, 4, 5, 6])]
+			);
+
+			// any rebag is noop.
+			assert_storage_noop!(assert_eq!(BagsList::rebag(RuntimeOrigin::signed(0), 1), Ok(())));
+		})
+	}
+
+	#[test]
+	fn put_in_front_of_other_can_be_permissionless() {
+		ExtBuilder::default()
+			.skip_genesis_ids()
+			.add_ids(vec![(10, 15), (11, 16), (12, 19)])
+			.build_and_execute(|| {
+				// given
+				assert_eq!(List::<Runtime>::get_bags(), vec![(20, vec![10, 11, 12])]);
+				// 11 now has more weight than 10 and can be moved before it.
+				StakingMock::set_score_of(&11u32, 17);
+
+				// when
+				assert_ok!(BagsList::put_in_front_of_other(RuntimeOrigin::signed(42), 11u32, 10));
+
+				// then
+				assert_eq!(List::<Runtime>::get_bags(), vec![(20, vec![11, 10, 12])]);
+			});
+	}
+
+	#[test]
+	fn put_in_front_of_two_node_bag_heavier_is_tail() {
+		ExtBuilder::default()
+			.skip_genesis_ids()
+			.add_ids(vec![(10, 15), (11, 16)])
+			.build_and_execute(|| {
+				// given
+				assert_eq!(List::<Runtime>::get_bags(), vec![(20, vec![10, 11])]);
+
+				// when
+				assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(11), 10));
+
+				// then
+				assert_eq!(List::<Runtime>::get_bags(), vec![(20, vec![11, 10])]);
+			});
+	}
+
+	#[test]
+	fn put_in_front_of_two_node_bag_heavier_is_head() {
+		ExtBuilder::default()
+			.skip_genesis_ids()
+			.add_ids(vec![(11, 16), (10, 15)])
+			.build_and_execute(|| {
+				// given
+				assert_eq!(List::<Runtime>::get_bags(), vec![(20, vec![11, 10])]);
+
+				// when
+				assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(11), 10));
+
+				// then
+				assert_eq!(List::<Runtime>::get_bags(), vec![(20, vec![11, 10])]);
+			});
+	}
+
+	#[test]
+	fn put_in_front_of_non_terminal_nodes_heavier_behind() {
+		ExtBuilder::default().add_ids(vec![(5, 1_000)]).build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4, 5])]);
+
+			StakingMock::set_score_of(&3, 999);
+
+			// when
+			assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(4), 3));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 4, 3, 5])]);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_non_terminal_nodes_heavier_in_front() {
+		ExtBuilder::default()
+			.add_ids(vec![(5, 1_000), (6, 1_000)])
+			.build_and_execute(|| {
+				// given
+				assert_eq!(
+					List::<Runtime>::get_bags(),
+					vec![(10, vec![1]), (1_000, vec![2, 3, 4, 5, 6])]
+				);
+
+				StakingMock::set_score_of(&5, 999);
+
+				// when
+				assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(3), 5));
+
+				// then
+				assert_eq!(
+					List::<Runtime>::get_bags(),
+					vec![(10, vec![1]), (1_000, vec![2, 4, 3, 5, 6])]
+				);
+			});
+	}
+
+	#[test]
+	fn put_in_front_of_lighter_is_head_heavier_is_non_terminal() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			StakingMock::set_score_of(&2, 999);
+
+			// when
+			assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(3), 2));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![3, 2, 4])]);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_heavier_is_tail_lighter_is_non_terminal() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			StakingMock::set_score_of(&3, 999);
+
+			// when
+			assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(4), 3));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 4, 3])]);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_heavier_is_tail_lighter_is_head() {
+		ExtBuilder::default().add_ids(vec![(5, 1_000)]).build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4, 5])]);
+
+			StakingMock::set_score_of(&2, 999);
+
+			// when
+			assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(5), 2));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![5, 2, 3, 4])]);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_heavier_is_head_lighter_is_not_terminal() {
+		ExtBuilder::default().add_ids(vec![(5, 1_000)]).build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4, 5])]);
+
+			StakingMock::set_score_of(&4, 999);
+
+			// when
+			BagsList::put_in_front_of(RuntimeOrigin::signed(2), 4).unwrap();
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![3, 2, 4, 5])]);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_lighter_is_tail_heavier_is_not_terminal() {
+		ExtBuilder::default().add_ids(vec![(5, 900)]).build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4, 5])]);
+
+			// when
+			BagsList::put_in_front_of(RuntimeOrigin::signed(3), 5).unwrap();
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 4, 3, 5])]);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_lighter_is_tail_heavier_is_head() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			StakingMock::set_score_of(&4, 999);
+
+			// when
+			assert_ok!(BagsList::put_in_front_of(RuntimeOrigin::signed(2), 4));
+
+			// then
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![3, 2, 4])]);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_errors_if_heavier_is_less_than_lighter() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			StakingMock::set_score_of(&3, 999);
+
+			// then
+			assert_noop!(
+				BagsList::put_in_front_of(RuntimeOrigin::signed(3), 2),
+				crate::pallet::Error::<Runtime>::List(ListError::NotHeavier)
+			);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_errors_if_heavier_is_equal_weight_to_lighter() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// then
+			assert_noop!(
+				BagsList::put_in_front_of(RuntimeOrigin::signed(3), 4),
+				crate::pallet::Error::<Runtime>::List(ListError::NotHeavier)
+			);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_errors_if_nodes_not_found() {
+		// `heavier` not found
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			assert!(!ListNodes::<Runtime>::contains_key(5));
+
+			// then
+			assert_noop!(
+				BagsList::put_in_front_of(RuntimeOrigin::signed(5), 4),
+				crate::pallet::Error::<Runtime>::List(ListError::NodeNotFound)
+			);
+		});
+
+		// `lighter` not found
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			assert!(!ListNodes::<Runtime>::contains_key(5));
+
+			// then
+			assert_noop!(
+				BagsList::put_in_front_of(RuntimeOrigin::signed(4), 5),
+				crate::pallet::Error::<Runtime>::List(ListError::NodeNotFound)
+			);
+		});
+	}
+
+	#[test]
+	fn put_in_front_of_errors_if_nodes_not_in_same_bag() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4])]);
+
+			// then
+			assert_noop!(
+				BagsList::put_in_front_of(RuntimeOrigin::signed(4), 1),
+				crate::pallet::Error::<Runtime>::List(ListError::NotInSameBag)
+			);
+		});
+	}
+}
+
+mod sorted_list_provider {
+	use super::*;
+
+	#[test]
+	fn iter_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let expected = vec![2, 3, 4, 1];
+			for (i, id) in BagsList::iter().enumerate() {
+				assert_eq!(id, expected[i])
+			}
+		});
+	}
+
+	#[test]
+	fn iter_from_works() {
+		ExtBuilder::default().add_ids(vec![(5, 5), (6, 15)]).build_and_execute(|| {
+			// given
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1, 5]), (20, vec![6]), (1000, vec![2, 3, 4])]
+			);
+
+			assert_eq!(BagsList::iter_from(&2).unwrap().collect::<Vec<_>>(), vec![3, 4, 6, 1, 5]);
+			assert_eq!(BagsList::iter_from(&3).unwrap().collect::<Vec<_>>(), vec![4, 6, 1, 5]);
+			assert_eq!(BagsList::iter_from(&4).unwrap().collect::<Vec<_>>(), vec![6, 1, 5]);
+			assert_eq!(BagsList::iter_from(&6).unwrap().collect::<Vec<_>>(), vec![1, 5]);
+			assert_eq!(BagsList::iter_from(&1).unwrap().collect::<Vec<_>>(), vec![5]);
+			assert!(BagsList::iter_from(&5).unwrap().collect::<Vec<_>>().is_empty());
+			assert!(BagsList::iter_from(&7).is_err());
+
+			assert_storage_noop!(assert!(BagsList::iter_from(&8).is_err()));
+		});
+	}
+
+	#[test]
+	fn count_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert_eq!(BagsList::count(), 4);
+
+			// when inserting
+			assert_ok!(BagsList::on_insert(201, 0));
+			// then the count goes up
+			assert_eq!(BagsList::count(), 5);
+
+			// when removing
+			BagsList::on_remove(&201).unwrap();
+			// then the count goes down
+			assert_eq!(BagsList::count(), 4);
+
+			// when updating
+			assert_noop!(BagsList::on_update(&201, VoteWeight::MAX), ListError::NodeNotFound);
+			// then the count stays the same
+			assert_eq!(BagsList::count(), 4);
+		});
+	}
+
+	#[test]
+	fn on_insert_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// when
+			assert_ok!(BagsList::on_insert(6, 1_000));
+
+			// then the bags
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![2, 3, 4, 6])]);
+			// and list correctly include the new id,
+			assert_eq!(BagsList::iter().collect::<Vec<_>>(), vec![2, 3, 4, 6, 1]);
+			// and the count is incremented.
+			assert_eq!(BagsList::count(), 5);
+
+			// when
+			assert_ok!(BagsList::on_insert(7, 1_001));
+
+			// then the bags
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4, 6]), (2_000, vec![7])]
+			);
+			// and list correctly include the new id,
+			assert_eq!(BagsList::iter().collect::<Vec<_>>(), vec![7, 2, 3, 4, 6, 1]);
+			// and the count is incremented.
+			assert_eq!(BagsList::count(), 6);
+		})
+	}
+
+	#[test]
+	fn on_insert_errors_with_duplicate_id() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			assert!(get_list_as_ids().contains(&3));
+
+			// then
+			assert_storage_noop!(assert_eq!(
+				BagsList::on_insert(3, 20).unwrap_err(),
+				ListError::Duplicate
+			));
+		});
+	}
+
+	#[test]
+	fn on_update_works() {
+		ExtBuilder::default().add_ids(vec![(42, 20)]).build_and_execute(|| {
+			// given
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (20, vec![42]), (1_000, vec![2, 3, 4])]
+			);
+			assert_eq!(BagsList::count(), 5);
+
+			// when increasing score to the level of non-existent bag
+			BagsList::on_update(&42, 2_000).unwrap();
+
+			// then the bag is created with the id in it,
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4]), (2000, vec![42])]
+			);
+			// and the id position is updated in the list.
+			assert_eq!(BagsList::iter().collect::<Vec<_>>(), vec![42, 2, 3, 4, 1]);
+
+			// when decreasing score within the range of the current bag
+			BagsList::on_update(&42, 1_001).unwrap();
+
+			// then the id does not change bags,
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4]), (2000, vec![42])]
+			);
+			// or change position in the list.
+			assert_eq!(BagsList::iter().collect::<Vec<_>>(), vec![42, 2, 3, 4, 1]);
+
+			// when increasing score to the level of a non-existent bag with the max threshold
+			BagsList::on_update(&42, VoteWeight::MAX).unwrap();
+
+			// the the new bag is created with the id in it,
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4]), (VoteWeight::MAX, vec![42])]
+			);
+			// and the id position is updated in the list.
+			assert_eq!(BagsList::iter().collect::<Vec<_>>(), vec![42, 2, 3, 4, 1]);
+
+			// when decreasing the score to a pre-existing bag
+			BagsList::on_update(&42, 1_000).unwrap();
+
+			// then id is moved to the correct bag (as the last member),
+			assert_eq!(
+				List::<Runtime>::get_bags(),
+				vec![(10, vec![1]), (1_000, vec![2, 3, 4, 42])]
+			);
+			// and the id position is updated in the list.
+			assert_eq!(BagsList::iter().collect::<Vec<_>>(), vec![2, 3, 4, 42, 1]);
+
+			// since we have only called on_update, the `count` has not changed.
+			assert_eq!(BagsList::count(), 5);
+		});
+	}
+
+	#[test]
+	fn on_remove_works() {
+		let ensure_left = |id, counter| {
+			assert!(!ListNodes::<Runtime>::contains_key(id));
+			assert_eq!(BagsList::count(), counter);
+			assert_eq!(ListNodes::<Runtime>::count(), counter);
+			assert_eq!(ListNodes::<Runtime>::iter().count() as u32, counter);
+		};
+
+		ExtBuilder::default().build_and_execute(|| {
+			// it is a noop removing a non-existent id
+			assert!(!ListNodes::<Runtime>::contains_key(42));
+			assert_noop!(BagsList::on_remove(&42), ListError::NodeNotFound);
+
+			// when removing a node from a bag with multiple nodes
+			BagsList::on_remove(&2).unwrap();
+
+			// then
+			assert_eq!(get_list_as_ids(), vec![3, 4, 1]);
+			assert_eq!(List::<Runtime>::get_bags(), vec![(10, vec![1]), (1_000, vec![3, 4])]);
+			ensure_left(2, 3);
+
+			// when removing a node from a bag with only one node
+			BagsList::on_remove(&1).unwrap();
+
+			// then
+			assert_eq!(get_list_as_ids(), vec![3, 4]);
+			assert_eq!(List::<Runtime>::get_bags(), vec![(1_000, vec![3, 4])]);
+			ensure_left(1, 2);
+
+			// when removing all remaining ids
+			BagsList::on_remove(&4).unwrap();
+			assert_eq!(get_list_as_ids(), vec![3]);
+			ensure_left(4, 1);
+			BagsList::on_remove(&3).unwrap();
+
+			// then the storage is completely cleaned up
+			assert_eq!(get_list_as_ids(), Vec::<AccountId>::new());
+			ensure_left(3, 0);
+		});
+	}
+
+	#[test]
+	fn contains_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert!(GENESIS_IDS.iter().all(|(id, _)| BagsList::contains(id)));
+
+			let non_existent_ids = vec![&42, &666, &13];
+			assert!(non_existent_ids.iter().all(|id| !BagsList::contains(id)));
+		})
+	}
+}
diff --git a/substrate/frame/bags-list/src/weights.rs b/substrate/frame/bags-list/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d929c6bb95963c3eaee8ce0d16b127adcb64956e
--- /dev/null
+++ b/substrate/frame/bags-list/src/weights.rs
@@ -0,0 +1,173 @@
+// 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.
+
+//! Autogenerated weights for pallet_bags_list
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_bags_list
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/bags-list/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_bags_list.
+pub trait WeightInfo {
+	fn rebag_non_terminal() -> Weight;
+	fn rebag_terminal() -> Weight;
+	fn put_in_front_of() -> Weight;
+}
+
+/// Weights for pallet_bags_list using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// 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: VoterList ListNodes (r:4 w:4)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn rebag_non_terminal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1724`
+		//  Estimated: `11506`
+		// Minimum execution time: 62_137_000 picoseconds.
+		Weight::from_parts(64_050_000, 11506)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// 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: 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn rebag_terminal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1618`
+		//  Estimated: `8877`
+		// Minimum execution time: 60_880_000 picoseconds.
+		Weight::from_parts(62_078_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: VoterList ListNodes (r:4 w:4)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, 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:2 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn put_in_front_of() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1930`
+		//  Estimated: `11506`
+		// Minimum execution time: 68_911_000 picoseconds.
+		Weight::from_parts(70_592_000, 11506)
+			.saturating_add(T::DbWeight::get().reads(10_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// 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: VoterList ListNodes (r:4 w:4)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn rebag_non_terminal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1724`
+		//  Estimated: `11506`
+		// Minimum execution time: 62_137_000 picoseconds.
+		Weight::from_parts(64_050_000, 11506)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// 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: 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn rebag_terminal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1618`
+		//  Estimated: `8877`
+		// Minimum execution time: 60_880_000 picoseconds.
+		Weight::from_parts(62_078_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: VoterList ListNodes (r:4 w:4)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, 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:2 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn put_in_front_of() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1930`
+		//  Estimated: `11506`
+		// Minimum execution time: 68_911_000 picoseconds.
+		Weight::from_parts(70_592_000, 11506)
+			.saturating_add(RocksDbWeight::get().reads(10_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+}
diff --git a/substrate/frame/balances/Cargo.toml b/substrate/frame/balances/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..861843b88949a19536e73637d7fba8e492aff8ff
--- /dev/null
+++ b/substrate/frame/balances/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-balances"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to manage balances"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-transaction-payment = { version = "4.0.0-dev", path = "../transaction-payment" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+paste = "1.0.12"
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-transaction-payment/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+# Enable support for setting the existential deposit to zero.
+insecure_zero_ed = []
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-transaction-payment/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/balances/README.md b/substrate/frame/balances/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fa1ee622d48ce2858df0d3b9937d6645b290c7ac
--- /dev/null
+++ b/substrate/frame/balances/README.md
@@ -0,0 +1,122 @@
+# Balances Module
+
+The Balances module provides functionality for handling accounts and balances.
+
+- [`Config`](https://docs.rs/pallet-balances/latest/pallet_balances/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-balances/latest/pallet_balances/pallet/enum.Call.html)
+- [`Pallet`](https://docs.rs/pallet-balances/latest/pallet_balances/pallet/struct.Pallet.html)
+
+## Overview
+
+The Balances module provides functions for:
+
+- Getting and setting free balances.
+- Retrieving total, reserved and unreserved balances.
+- Repatriating a reserved balance to a beneficiary account that exists.
+- Transferring a balance between accounts (when not reserved).
+- Slashing an account balance.
+- Account creation and removal.
+- Managing total issuance.
+- Setting and managing locks.
+
+### Terminology
+
+- **Existential Deposit:** The minimum balance required to create or keep an account open. This prevents
+"dust accounts" from filling storage. When the free plus the reserved balance (i.e. the total balance)
+  fall below this, then the account is said to be dead; and it loses its functionality as well as any
+  prior history and all information on it is removed from the chain's state.
+  No account should ever have a total balance that is strictly between 0 and the existential
+  deposit (exclusive). If this ever happens, it indicates either a bug in this module or an
+  erroneous raw mutation of storage.
+
+- **Total Issuance:** The total number of units in existence in a system.
+
+- **Reaping an account:** The act of removing an account by resetting its nonce. Happens after its
+total balance has become zero (or, strictly speaking, less than the Existential Deposit).
+
+- **Free Balance:** The portion of a balance that is not reserved. The free balance is the only
+  balance that matters for most operations.
+
+- **Reserved Balance:** Reserved balance still belongs to the account holder, but is suspended.
+  Reserved balance can still be slashed, but only after all the free balance has been slashed.
+
+- **Imbalance:** A condition when some funds were credited or debited without equal and opposite accounting
+(i.e. a difference between total issuance and account balances). Functions that result in an imbalance will
+return an object of the `Imbalance` trait that can be managed within your runtime logic. (If an imbalance is
+simply dropped, it should automatically maintain any book-keeping such as total issuance.)
+
+- **Lock:** A freeze on a specified amount of an account's free balance until a specified block number. Multiple
+locks always operate over the same funds, so they "overlay" rather than "stack".
+
+### Implementations
+
+The Balances module provides implementations for the following traits. If these traits provide the functionality
+that you need, then you can avoid coupling with the Balances module.
+
+- [`Currency`](https://docs.rs/frame-support/latest/frame_support/traits/trait.Currency.html): Functions for dealing with a
+fungible assets system.
+- [`ReservableCurrency`](https://docs.rs/frame-support/latest/frame_support/traits/trait.ReservableCurrency.html):
+Functions for dealing with assets that can be reserved from an account.
+- [`LockableCurrency`](https://docs.rs/frame-support/latest/frame_support/traits/trait.LockableCurrency.html): Functions for
+dealing with accounts that allow liquidity restrictions.
+- [`Imbalance`](https://docs.rs/frame-support/latest/frame_support/traits/trait.Imbalance.html): Functions for handling
+imbalances between total issuance in the system and account balances. Must be used when a function
+creates new funds (e.g. a reward) or destroys some funds (e.g. a system fee).
+- [`IsDeadAccount`](https://docs.rs/frame-support/latest/frame_support/traits/trait.IsDeadAccount.html): Determiner to say whether a
+given account is unused.
+
+## Interface
+
+### Dispatchable Functions
+
+- `transfer` - Transfer some liquid free balance to another account.
+- `force_set_balance` - Set the balances of a given account. The origin of this call must be root.
+
+## Usage
+
+The following examples show how to use the Balances module in your custom module.
+
+### Examples from the FRAME
+
+The Contract module uses the `Currency` trait to handle gas payment, and its types inherit from `Currency`:
+
+```rust
+use frame_support::traits::Currency;
+
+pub type BalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+pub type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;
+
+```
+
+The Staking module uses the `LockableCurrency` trait to lock a stash account's funds:
+
+```rust
+use frame_support::traits::{WithdrawReasons, LockableCurrency};
+use sp_runtime::traits::Bounded;
+pub trait Config: frame_system::Config {
+	type Currency: LockableCurrency<Self::AccountId, Moment=frame_system::pallet_prelude::BlockNumberFor<Self>>;
+}
+
+fn update_ledger<T: Config>(
+	controller: &T::AccountId,
+	ledger: &StakingLedger<T>
+) {
+	T::Currency::set_lock(
+		STAKING_ID,
+		&ledger.stash,
+		ledger.total,
+		WithdrawReasons::all()
+	);
+	// <Ledger<T>>::insert(controller, ledger); // Commented out as we don't have access to Staking's storage here.
+}
+```
+
+## Genesis config
+
+The Balances module depends on the [`GenesisConfig`](https://docs.rs/pallet-balances/latest/pallet_balances/pallet/struct.GenesisConfig.html).
+
+## Assumptions
+
+* Total issued balanced of all accounts should be less than `Config::Balance::max_value()`.
+
+License: Apache-2.0
diff --git a/substrate/frame/balances/src/benchmarking.rs b/substrate/frame/balances/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5641c68516c28a9ad0115dc6decd9ad39904d653
--- /dev/null
+++ b/substrate/frame/balances/src/benchmarking.rs
@@ -0,0 +1,294 @@
+// 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.
+
+//! Balances pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use crate::Pallet as Balances;
+
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+use sp_runtime::traits::Bounded;
+use types::ExtraFlags;
+
+const SEED: u32 = 0;
+// existential deposit multiplier
+const ED_MULTIPLIER: u32 = 10;
+
+#[instance_benchmarks]
+mod benchmarks {
+	use super::*;
+
+	// Benchmark `transfer` extrinsic with the worst possible conditions:
+	// * Transfer will kill the sender account.
+	// * Transfer will create the recipient account.
+	#[benchmark]
+	fn transfer_allow_death() {
+		let existential_deposit = T::ExistentialDeposit::get();
+		let caller = whitelisted_caller();
+
+		// Give some multiple of the existential deposit
+		let balance = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&caller, balance);
+
+		// Transfer `e - 1` existential deposits + 1 unit, which guarantees to create one account,
+		// and reap this user.
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+		let transfer_amount =
+			existential_deposit.saturating_mul((ED_MULTIPLIER - 1).into()) + 1u32.into();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), recipient_lookup, transfer_amount);
+
+		assert_eq!(Balances::<T, I>::free_balance(&caller), Zero::zero());
+		assert_eq!(Balances::<T, I>::free_balance(&recipient), transfer_amount);
+	}
+
+	// Benchmark `transfer` with the best possible condition:
+	// * Both accounts exist and will continue to exist.
+	#[benchmark(extra)]
+	fn transfer_best_case() {
+		let caller = whitelisted_caller();
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+
+		// Give the sender account max funds for transfer (their account will never reasonably be
+		// killed).
+		let _ =
+			<Balances<T, I> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
+
+		// Give the recipient account existential deposit (thus their account already exists).
+		let existential_deposit = T::ExistentialDeposit::get();
+		let _ =
+			<Balances<T, I> as Currency<_>>::make_free_balance_be(&recipient, existential_deposit);
+		let transfer_amount = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+
+		#[extrinsic_call]
+		transfer_allow_death(RawOrigin::Signed(caller.clone()), recipient_lookup, transfer_amount);
+
+		assert!(!Balances::<T, I>::free_balance(&caller).is_zero());
+		assert!(!Balances::<T, I>::free_balance(&recipient).is_zero());
+	}
+
+	// Benchmark `transfer_keep_alive` with the worst possible condition:
+	// * The recipient account is created.
+	#[benchmark]
+	fn transfer_keep_alive() {
+		let caller = whitelisted_caller();
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+
+		// Give the sender account max funds, thus a transfer will not kill account.
+		let _ =
+			<Balances<T, I> as Currency<_>>::make_free_balance_be(&caller, T::Balance::max_value());
+		let existential_deposit = T::ExistentialDeposit::get();
+		let transfer_amount = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), recipient_lookup, transfer_amount);
+
+		assert!(!Balances::<T, I>::free_balance(&caller).is_zero());
+		assert_eq!(Balances::<T, I>::free_balance(&recipient), transfer_amount);
+	}
+
+	// Benchmark `force_set_balance` coming from ROOT account. This always creates an account.
+	#[benchmark]
+	fn force_set_balance_creating() {
+		let user: T::AccountId = account("user", 0, SEED);
+		let user_lookup = T::Lookup::unlookup(user.clone());
+
+		// Give the user some initial balance.
+		let existential_deposit = T::ExistentialDeposit::get();
+		let balance_amount = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&user, balance_amount);
+
+		#[extrinsic_call]
+		force_set_balance(RawOrigin::Root, user_lookup, balance_amount);
+
+		assert_eq!(Balances::<T, I>::free_balance(&user), balance_amount);
+	}
+
+	// Benchmark `force_set_balance` coming from ROOT account. This always kills an account.
+	#[benchmark]
+	fn force_set_balance_killing() {
+		let user: T::AccountId = account("user", 0, SEED);
+		let user_lookup = T::Lookup::unlookup(user.clone());
+
+		// Give the user some initial balance.
+		let existential_deposit = T::ExistentialDeposit::get();
+		let balance_amount = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&user, balance_amount);
+
+		#[extrinsic_call]
+		force_set_balance(RawOrigin::Root, user_lookup, Zero::zero());
+
+		assert!(Balances::<T, I>::free_balance(&user).is_zero());
+	}
+
+	// Benchmark `force_transfer` extrinsic with the worst possible conditions:
+	// * Transfer will kill the sender account.
+	// * Transfer will create the recipient account.
+	#[benchmark]
+	fn force_transfer() {
+		let existential_deposit = T::ExistentialDeposit::get();
+		let source: T::AccountId = account("source", 0, SEED);
+		let source_lookup = T::Lookup::unlookup(source.clone());
+
+		// Give some multiple of the existential deposit
+		let balance = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&source, balance);
+
+		// Transfer `e - 1` existential deposits + 1 unit, which guarantees to create one account,
+		// and reap this user.
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+		let transfer_amount =
+			existential_deposit.saturating_mul((ED_MULTIPLIER - 1).into()) + 1u32.into();
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, source_lookup, recipient_lookup, transfer_amount);
+
+		assert_eq!(Balances::<T, I>::free_balance(&source), Zero::zero());
+		assert_eq!(Balances::<T, I>::free_balance(&recipient), transfer_amount);
+	}
+
+	// This benchmark performs the same operation as `transfer` in the worst case scenario,
+	// but additionally introduces many new users into the storage, increasing the the merkle
+	// trie and PoV size.
+	#[benchmark(extra)]
+	fn transfer_increasing_users(u: Linear<0, 1_000>) {
+		// 1_000 is not very much, but this upper bound can be controlled by the CLI.
+		let existential_deposit = T::ExistentialDeposit::get();
+		let caller = whitelisted_caller();
+
+		// Give some multiple of the existential deposit
+		let balance = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&caller, balance);
+
+		// Transfer `e - 1` existential deposits + 1 unit, which guarantees to create one account,
+		// and reap this user.
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+		let transfer_amount =
+			existential_deposit.saturating_mul((ED_MULTIPLIER - 1).into()) + 1u32.into();
+
+		// Create a bunch of users in storage.
+		for i in 0..u {
+			// The `account` function uses `blake2_256` to generate unique accounts, so these
+			// should be quite random and evenly distributed in the trie.
+			let new_user: T::AccountId = account("new_user", i, SEED);
+			let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&new_user, balance);
+		}
+
+		#[extrinsic_call]
+		transfer_allow_death(RawOrigin::Signed(caller.clone()), recipient_lookup, transfer_amount);
+
+		assert_eq!(Balances::<T, I>::free_balance(&caller), Zero::zero());
+		assert_eq!(Balances::<T, I>::free_balance(&recipient), transfer_amount);
+	}
+
+	// Benchmark `transfer_all` with the worst possible condition:
+	// * The recipient account is created
+	// * The sender is killed
+	#[benchmark]
+	fn transfer_all() {
+		let caller = whitelisted_caller();
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+
+		// Give some multiple of the existential deposit
+		let existential_deposit = T::ExistentialDeposit::get();
+		let balance = existential_deposit.saturating_mul(ED_MULTIPLIER.into());
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&caller, balance);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), recipient_lookup, false);
+
+		assert!(Balances::<T, I>::free_balance(&caller).is_zero());
+		assert_eq!(Balances::<T, I>::free_balance(&recipient), balance);
+	}
+
+	#[benchmark]
+	fn force_unreserve() -> Result<(), BenchmarkError> {
+		let user: T::AccountId = account("user", 0, SEED);
+		let user_lookup = T::Lookup::unlookup(user.clone());
+
+		// Give some multiple of the existential deposit
+		let ed = T::ExistentialDeposit::get();
+		let balance = ed + ed;
+		let _ = <Balances<T, I> as Currency<_>>::make_free_balance_be(&user, balance);
+
+		// Reserve the balance
+		<Balances<T, I> as ReservableCurrency<_>>::reserve(&user, ed)?;
+		assert_eq!(Balances::<T, I>::reserved_balance(&user), ed);
+		assert_eq!(Balances::<T, I>::free_balance(&user), ed);
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, user_lookup, balance);
+
+		assert!(Balances::<T, I>::reserved_balance(&user).is_zero());
+		assert_eq!(Balances::<T, I>::free_balance(&user), ed + ed);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn upgrade_accounts(u: Linear<1, 1_000>) {
+		let caller: T::AccountId = whitelisted_caller();
+		let who = (0..u)
+			.into_iter()
+			.map(|i| -> T::AccountId {
+				let user = account("old_user", i, SEED);
+				let account = AccountData {
+					free: T::ExistentialDeposit::get(),
+					reserved: T::ExistentialDeposit::get(),
+					frozen: Zero::zero(),
+					flags: ExtraFlags::old_logic(),
+				};
+				frame_system::Pallet::<T>::inc_providers(&user);
+				assert!(T::AccountStore::try_mutate_exists(&user, |a| -> DispatchResult {
+					*a = Some(account);
+					Ok(())
+				})
+				.is_ok());
+				assert!(!Balances::<T, I>::account(&user).flags.is_new_logic());
+				assert_eq!(frame_system::Pallet::<T>::providers(&user), 1);
+				assert_eq!(frame_system::Pallet::<T>::consumers(&user), 0);
+				user
+			})
+			.collect();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), who);
+
+		for i in 0..u {
+			let user: T::AccountId = account("old_user", i, SEED);
+			assert!(Balances::<T, I>::account(&user).flags.is_new_logic());
+			assert_eq!(frame_system::Pallet::<T>::providers(&user), 1);
+			assert_eq!(frame_system::Pallet::<T>::consumers(&user), 1);
+		}
+	}
+
+	impl_benchmark_test_suite! {
+		Balances,
+		crate::tests::ExtBuilder::default().build(),
+		crate::tests::Test,
+	}
+}
diff --git a/substrate/frame/balances/src/impl_currency.rs b/substrate/frame/balances/src/impl_currency.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2cbe776c51297ae51fe6b429a5f4466764f1e934
--- /dev/null
+++ b/substrate/frame/balances/src/impl_currency.rs
@@ -0,0 +1,910 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Implementations for the `Currency` family of traits.
+//!
+//! Note that `WithdrawReasons` are intentionally not used for anything in this implementation and
+//! are expected to be removed in the near future, once migration to `fungible::*` traits is done.
+
+use super::*;
+use frame_support::{
+	ensure,
+	pallet_prelude::DispatchResult,
+	traits::{
+		tokens::{fungible, BalanceStatus as Status, Fortitude::Polite, Precision::BestEffort},
+		Currency, DefensiveSaturating, ExistenceRequirement,
+		ExistenceRequirement::AllowDeath,
+		Get, Imbalance, LockIdentifier, LockableCurrency, NamedReservableCurrency,
+		ReservableCurrency, SignedImbalance, TryDrop, WithdrawReasons,
+	},
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+pub use imbalances::{NegativeImbalance, PositiveImbalance};
+
+// wrapping these imbalances in a private module is necessary to ensure absolute privacy
+// of the inner member.
+mod imbalances {
+	use super::{result, Config, Imbalance, RuntimeDebug, Saturating, TryDrop, Zero};
+	use frame_support::traits::SameOrOther;
+	use sp_std::mem;
+
+	/// Opaque, move-only struct with private fields that serves as a token denoting that
+	/// funds have been created without any equal and opposite accounting.
+	#[must_use]
+	#[derive(RuntimeDebug, PartialEq, Eq)]
+	pub struct PositiveImbalance<T: Config<I>, I: 'static = ()>(T::Balance);
+
+	impl<T: Config<I>, I: 'static> PositiveImbalance<T, I> {
+		/// Create a new positive imbalance from a balance.
+		pub fn new(amount: T::Balance) -> Self {
+			PositiveImbalance(amount)
+		}
+	}
+
+	/// Opaque, move-only struct with private fields that serves as a token denoting that
+	/// funds have been destroyed without any equal and opposite accounting.
+	#[must_use]
+	#[derive(RuntimeDebug, PartialEq, Eq)]
+	pub struct NegativeImbalance<T: Config<I>, I: 'static = ()>(T::Balance);
+
+	impl<T: Config<I>, I: 'static> NegativeImbalance<T, I> {
+		/// Create a new negative imbalance from a balance.
+		pub fn new(amount: T::Balance) -> Self {
+			NegativeImbalance(amount)
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> TryDrop for PositiveImbalance<T, I> {
+		fn try_drop(self) -> result::Result<(), Self> {
+			self.drop_zero()
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Default for PositiveImbalance<T, I> {
+		fn default() -> Self {
+			Self::zero()
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Imbalance<T::Balance> for PositiveImbalance<T, I> {
+		type Opposite = NegativeImbalance<T, I>;
+
+		fn zero() -> Self {
+			Self(Zero::zero())
+		}
+		fn drop_zero(self) -> result::Result<(), Self> {
+			if self.0.is_zero() {
+				Ok(())
+			} else {
+				Err(self)
+			}
+		}
+		fn split(self, amount: T::Balance) -> (Self, Self) {
+			let first = self.0.min(amount);
+			let second = self.0 - first;
+
+			mem::forget(self);
+			(Self(first), Self(second))
+		}
+		fn merge(mut self, other: Self) -> Self {
+			self.0 = self.0.saturating_add(other.0);
+			mem::forget(other);
+
+			self
+		}
+		fn subsume(&mut self, other: Self) {
+			self.0 = self.0.saturating_add(other.0);
+			mem::forget(other);
+		}
+		fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
+			let (a, b) = (self.0, other.0);
+			mem::forget((self, other));
+
+			if a > b {
+				SameOrOther::Same(Self(a - b))
+			} else if b > a {
+				SameOrOther::Other(NegativeImbalance::new(b - a))
+			} else {
+				SameOrOther::None
+			}
+		}
+		fn peek(&self) -> T::Balance {
+			self.0
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> TryDrop for NegativeImbalance<T, I> {
+		fn try_drop(self) -> result::Result<(), Self> {
+			self.drop_zero()
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Default for NegativeImbalance<T, I> {
+		fn default() -> Self {
+			Self::zero()
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Imbalance<T::Balance> for NegativeImbalance<T, I> {
+		type Opposite = PositiveImbalance<T, I>;
+
+		fn zero() -> Self {
+			Self(Zero::zero())
+		}
+		fn drop_zero(self) -> result::Result<(), Self> {
+			if self.0.is_zero() {
+				Ok(())
+			} else {
+				Err(self)
+			}
+		}
+		fn split(self, amount: T::Balance) -> (Self, Self) {
+			let first = self.0.min(amount);
+			let second = self.0 - first;
+
+			mem::forget(self);
+			(Self(first), Self(second))
+		}
+		fn merge(mut self, other: Self) -> Self {
+			self.0 = self.0.saturating_add(other.0);
+			mem::forget(other);
+
+			self
+		}
+		fn subsume(&mut self, other: Self) {
+			self.0 = self.0.saturating_add(other.0);
+			mem::forget(other);
+		}
+		fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
+			let (a, b) = (self.0, other.0);
+			mem::forget((self, other));
+
+			if a > b {
+				SameOrOther::Same(Self(a - b))
+			} else if b > a {
+				SameOrOther::Other(PositiveImbalance::new(b - a))
+			} else {
+				SameOrOther::None
+			}
+		}
+		fn peek(&self) -> T::Balance {
+			self.0
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Drop for PositiveImbalance<T, I> {
+		/// Basic drop handler will just square up the total issuance.
+		fn drop(&mut self) {
+			<super::TotalIssuance<T, I>>::mutate(|v| *v = v.saturating_add(self.0));
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Drop for NegativeImbalance<T, I> {
+		/// Basic drop handler will just square up the total issuance.
+		fn drop(&mut self) {
+			<super::TotalIssuance<T, I>>::mutate(|v| *v = v.saturating_sub(self.0));
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Currency<T::AccountId> for Pallet<T, I>
+where
+	T::Balance: MaybeSerializeDeserialize + Debug,
+{
+	type Balance = T::Balance;
+	type PositiveImbalance = PositiveImbalance<T, I>;
+	type NegativeImbalance = NegativeImbalance<T, I>;
+
+	fn total_balance(who: &T::AccountId) -> Self::Balance {
+		Self::account(who).total()
+	}
+
+	// Check if `value` amount of free balance can be slashed from `who`.
+	fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool {
+		if value.is_zero() {
+			return true
+		}
+		Self::free_balance(who) >= value
+	}
+
+	fn total_issuance() -> Self::Balance {
+		TotalIssuance::<T, I>::get()
+	}
+
+	fn active_issuance() -> Self::Balance {
+		<Self as fungible::Inspect<_>>::active_issuance()
+	}
+
+	fn deactivate(amount: Self::Balance) {
+		<Self as fungible::Unbalanced<_>>::deactivate(amount);
+	}
+
+	fn reactivate(amount: Self::Balance) {
+		<Self as fungible::Unbalanced<_>>::reactivate(amount);
+	}
+
+	fn minimum_balance() -> Self::Balance {
+		T::ExistentialDeposit::get()
+	}
+
+	// Burn funds from the total issuance, returning a positive imbalance for the amount burned.
+	// Is a no-op if amount to be burned is zero.
+	fn burn(mut amount: Self::Balance) -> Self::PositiveImbalance {
+		if amount.is_zero() {
+			return PositiveImbalance::zero()
+		}
+		<TotalIssuance<T, I>>::mutate(|issued| {
+			*issued = issued.checked_sub(&amount).unwrap_or_else(|| {
+				amount = *issued;
+				Zero::zero()
+			});
+		});
+		PositiveImbalance::new(amount)
+	}
+
+	// Create new funds into the total issuance, returning a negative imbalance
+	// for the amount issued.
+	// Is a no-op if amount to be issued it zero.
+	fn issue(mut amount: Self::Balance) -> Self::NegativeImbalance {
+		if amount.is_zero() {
+			return NegativeImbalance::zero()
+		}
+		<TotalIssuance<T, I>>::mutate(|issued| {
+			*issued = issued.checked_add(&amount).unwrap_or_else(|| {
+				amount = Self::Balance::max_value() - *issued;
+				Self::Balance::max_value()
+			})
+		});
+		NegativeImbalance::new(amount)
+	}
+
+	fn free_balance(who: &T::AccountId) -> Self::Balance {
+		Self::account(who).free
+	}
+
+	// Ensure that an account can withdraw from their free balance given any existing withdrawal
+	// restrictions like locks and vesting balance.
+	// Is a no-op if amount to be withdrawn is zero.
+	fn ensure_can_withdraw(
+		who: &T::AccountId,
+		amount: T::Balance,
+		_reasons: WithdrawReasons,
+		new_balance: T::Balance,
+	) -> DispatchResult {
+		if amount.is_zero() {
+			return Ok(())
+		}
+		ensure!(new_balance >= Self::account(who).frozen, Error::<T, I>::LiquidityRestrictions);
+		Ok(())
+	}
+
+	// Transfer some free balance from `transactor` to `dest`, respecting existence requirements.
+	// Is a no-op if value to be transferred is zero or the `transactor` is the same as `dest`.
+	fn transfer(
+		transactor: &T::AccountId,
+		dest: &T::AccountId,
+		value: Self::Balance,
+		existence_requirement: ExistenceRequirement,
+	) -> DispatchResult {
+		if value.is_zero() || transactor == dest {
+			return Ok(())
+		}
+		let keep_alive = match existence_requirement {
+			ExistenceRequirement::KeepAlive => Preserve,
+			ExistenceRequirement::AllowDeath => Expendable,
+		};
+		<Self as fungible::Mutate<_>>::transfer(transactor, dest, value, keep_alive)?;
+		Ok(())
+	}
+
+	/// Slash a target account `who`, returning the negative imbalance created and any left over
+	/// amount that could not be slashed.
+	///
+	/// Is a no-op if `value` to be slashed is zero or the account does not exist.
+	///
+	/// NOTE: `slash()` prefers free balance, but assumes that reserve balance can be drawn
+	/// from in extreme circumstances. `can_slash()` should be used prior to `slash()` to avoid
+	/// having to draw from reserved funds, however we err on the side of punishment if things are
+	/// inconsistent or `can_slash` wasn't used appropriately.
+	fn slash(who: &T::AccountId, value: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) {
+		if value.is_zero() {
+			return (NegativeImbalance::zero(), Zero::zero())
+		}
+		if Self::total_balance(who).is_zero() {
+			return (NegativeImbalance::zero(), value)
+		}
+
+		let result = match Self::try_mutate_account_handling_dust(
+			who,
+			|account, _is_new| -> Result<(Self::NegativeImbalance, Self::Balance), DispatchError> {
+				// Best value is the most amount we can slash following liveness rules.
+				let ed = T::ExistentialDeposit::get();
+				let actual = match system::Pallet::<T>::can_dec_provider(who) {
+					true => value.min(account.free),
+					false => value.min(account.free.saturating_sub(ed)),
+				};
+				account.free.saturating_reduce(actual);
+				let remaining = value.saturating_sub(actual);
+				Ok((NegativeImbalance::new(actual), remaining))
+			},
+		) {
+			Ok((imbalance, remaining)) => {
+				Self::deposit_event(Event::Slashed {
+					who: who.clone(),
+					amount: value.saturating_sub(remaining),
+				});
+				(imbalance, remaining)
+			},
+			Err(_) => (Self::NegativeImbalance::zero(), value),
+		};
+		result
+	}
+
+	/// Deposit some `value` into the free balance of an existing target account `who`.
+	///
+	/// Is a no-op if the `value` to be deposited is zero.
+	fn deposit_into_existing(
+		who: &T::AccountId,
+		value: Self::Balance,
+	) -> Result<Self::PositiveImbalance, DispatchError> {
+		if value.is_zero() {
+			return Ok(PositiveImbalance::zero())
+		}
+
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
+				ensure!(!is_new, Error::<T, I>::DeadAccount);
+				account.free = account.free.checked_add(&value).ok_or(ArithmeticError::Overflow)?;
+				Self::deposit_event(Event::Deposit { who: who.clone(), amount: value });
+				Ok(PositiveImbalance::new(value))
+			},
+		)
+	}
+
+	/// Deposit some `value` into the free balance of `who`, possibly creating a new account.
+	///
+	/// This function is a no-op if:
+	/// - the `value` to be deposited is zero; or
+	/// - the `value` to be deposited is less than the required ED and the account does not yet
+	///   exist; or
+	/// - the deposit would necessitate the account to exist and there are no provider references;
+	///   or
+	/// - `value` is so large it would cause the balance of `who` to overflow.
+	fn deposit_creating(who: &T::AccountId, value: Self::Balance) -> Self::PositiveImbalance {
+		if value.is_zero() {
+			return Self::PositiveImbalance::zero()
+		}
+
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account, is_new| -> Result<Self::PositiveImbalance, DispatchError> {
+				let ed = T::ExistentialDeposit::get();
+				ensure!(value >= ed || !is_new, Error::<T, I>::ExistentialDeposit);
+
+				// defensive only: overflow should never happen, however in case it does, then this
+				// operation is a no-op.
+				account.free = match account.free.checked_add(&value) {
+					Some(x) => x,
+					None => return Ok(Self::PositiveImbalance::zero()),
+				};
+
+				Self::deposit_event(Event::Deposit { who: who.clone(), amount: value });
+				Ok(PositiveImbalance::new(value))
+			},
+		)
+		.unwrap_or_else(|_| Self::PositiveImbalance::zero())
+	}
+
+	/// Withdraw some free balance from an account, respecting existence requirements.
+	///
+	/// Is a no-op if value to be withdrawn is zero.
+	fn withdraw(
+		who: &T::AccountId,
+		value: Self::Balance,
+		reasons: WithdrawReasons,
+		liveness: ExistenceRequirement,
+	) -> result::Result<Self::NegativeImbalance, DispatchError> {
+		if value.is_zero() {
+			return Ok(NegativeImbalance::zero())
+		}
+
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account, _| -> Result<Self::NegativeImbalance, DispatchError> {
+				let new_free_account =
+					account.free.checked_sub(&value).ok_or(Error::<T, I>::InsufficientBalance)?;
+
+				// bail if we need to keep the account alive and this would kill it.
+				let ed = T::ExistentialDeposit::get();
+				let would_be_dead = new_free_account < ed;
+				let would_kill = would_be_dead && account.free >= ed;
+				ensure!(liveness == AllowDeath || !would_kill, Error::<T, I>::Expendability);
+
+				Self::ensure_can_withdraw(who, value, reasons, new_free_account)?;
+
+				account.free = new_free_account;
+
+				Self::deposit_event(Event::Withdraw { who: who.clone(), amount: value });
+				Ok(NegativeImbalance::new(value))
+			},
+		)
+	}
+
+	/// Force the new free balance of a target account `who` to some new value `balance`.
+	fn make_free_balance_be(
+		who: &T::AccountId,
+		value: Self::Balance,
+	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
+		Self::try_mutate_account_handling_dust(
+			who,
+			|account,
+			 is_new|
+			 -> Result<SignedImbalance<Self::Balance, Self::PositiveImbalance>, DispatchError> {
+				let ed = T::ExistentialDeposit::get();
+				// If we're attempting to set an existing account to less than ED, then
+				// bypass the entire operation. It's a no-op if you follow it through, but
+				// since this is an instance where we might account for a negative imbalance
+				// (in the dust cleaner of set_account) before we account for its actual
+				// equal and opposite cause (returned as an Imbalance), then in the
+				// instance that there's no other accounts on the system at all, we might
+				// underflow the issuance and our arithmetic will be off.
+				ensure!(value >= ed || !is_new, Error::<T, I>::ExistentialDeposit);
+
+				let imbalance = if account.free <= value {
+					SignedImbalance::Positive(PositiveImbalance::new(value - account.free))
+				} else {
+					SignedImbalance::Negative(NegativeImbalance::new(account.free - value))
+				};
+				account.free = value;
+				Self::deposit_event(Event::BalanceSet { who: who.clone(), free: account.free });
+				Ok(imbalance)
+			},
+		)
+		.unwrap_or_else(|_| SignedImbalance::Positive(Self::PositiveImbalance::zero()))
+	}
+}
+
+impl<T: Config<I>, I: 'static> ReservableCurrency<T::AccountId> for Pallet<T, I>
+where
+	T::Balance: MaybeSerializeDeserialize + Debug,
+{
+	/// Check if `who` can reserve `value` from their free balance.
+	///
+	/// Always `true` if value to be reserved is zero.
+	fn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool {
+		if value.is_zero() {
+			return true
+		}
+		Self::account(who).free.checked_sub(&value).map_or(false, |new_balance| {
+			new_balance >= T::ExistentialDeposit::get() &&
+				Self::ensure_can_withdraw(who, value, WithdrawReasons::RESERVE, new_balance)
+					.is_ok()
+		})
+	}
+
+	fn reserved_balance(who: &T::AccountId) -> Self::Balance {
+		Self::account(who).reserved
+	}
+
+	/// Move `value` from the free balance from `who` to their reserved balance.
+	///
+	/// Is a no-op if value to be reserved is zero.
+	fn reserve(who: &T::AccountId, value: Self::Balance) -> DispatchResult {
+		if value.is_zero() {
+			return Ok(())
+		}
+
+		Self::try_mutate_account_handling_dust(who, |account, _| -> DispatchResult {
+			account.free =
+				account.free.checked_sub(&value).ok_or(Error::<T, I>::InsufficientBalance)?;
+			account.reserved =
+				account.reserved.checked_add(&value).ok_or(ArithmeticError::Overflow)?;
+			Self::ensure_can_withdraw(&who, value, WithdrawReasons::RESERVE, account.free)
+		})?;
+
+		Self::deposit_event(Event::Reserved { who: who.clone(), amount: value });
+		Ok(())
+	}
+
+	/// Unreserve some funds, returning any amount that was unable to be unreserved.
+	///
+	/// Is a no-op if the value to be unreserved is zero or the account does not exist.
+	///
+	/// NOTE: returns amount value which wasn't successfully unreserved.
+	fn unreserve(who: &T::AccountId, value: Self::Balance) -> Self::Balance {
+		if value.is_zero() {
+			return Zero::zero()
+		}
+		if Self::total_balance(who).is_zero() {
+			return value
+		}
+
+		let actual = match Self::mutate_account_handling_dust(who, |account| {
+			let actual = cmp::min(account.reserved, value);
+			account.reserved -= actual;
+			// defensive only: this can never fail since total issuance which is at least
+			// free+reserved fits into the same data type.
+			account.free = account.free.defensive_saturating_add(actual);
+			actual
+		}) {
+			Ok(x) => x,
+			Err(_) => {
+				// This should never happen since we don't alter the total amount in the account.
+				// If it ever does, then we should fail gracefully though, indicating that nothing
+				// could be done.
+				return value
+			},
+		};
+
+		Self::deposit_event(Event::Unreserved { who: who.clone(), amount: actual });
+		value - actual
+	}
+
+	/// Slash from reserved balance, returning the negative imbalance created,
+	/// and any amount that was unable to be slashed.
+	///
+	/// Is a no-op if the value to be slashed is zero or the account does not exist.
+	fn slash_reserved(
+		who: &T::AccountId,
+		value: Self::Balance,
+	) -> (Self::NegativeImbalance, Self::Balance) {
+		if value.is_zero() {
+			return (NegativeImbalance::zero(), Zero::zero())
+		}
+		if Self::total_balance(who).is_zero() {
+			return (NegativeImbalance::zero(), value)
+		}
+
+		// NOTE: `mutate_account` may fail if it attempts to reduce the balance to the point that an
+		//   account is attempted to be illegally destroyed.
+
+		match Self::mutate_account_handling_dust(who, |account| {
+			let actual = value.min(account.reserved);
+			account.reserved.saturating_reduce(actual);
+
+			// underflow should never happen, but it if does, there's nothing to be done here.
+			(NegativeImbalance::new(actual), value.saturating_sub(actual))
+		}) {
+			Ok((imbalance, not_slashed)) => {
+				Self::deposit_event(Event::Slashed {
+					who: who.clone(),
+					amount: value.saturating_sub(not_slashed),
+				});
+				(imbalance, not_slashed)
+			},
+			Err(_) => (Self::NegativeImbalance::zero(), value),
+		}
+	}
+
+	/// Move the reserved balance of one account into the balance of another, according to `status`.
+	///
+	/// Is a no-op if:
+	/// - the value to be moved is zero; or
+	/// - the `slashed` id equal to `beneficiary` and the `status` is `Reserved`.
+	///
+	/// This is `Polite` and thus will not repatriate any funds which would lead the total balance
+	/// to be less than the frozen amount. Returns `Ok` with the actual amount of funds moved,
+	/// which may be less than `value` since the operation is done an a `BestEffort` basis.
+	fn repatriate_reserved(
+		slashed: &T::AccountId,
+		beneficiary: &T::AccountId,
+		value: Self::Balance,
+		status: Status,
+	) -> Result<Self::Balance, DispatchError> {
+		let actual =
+			Self::do_transfer_reserved(slashed, beneficiary, value, BestEffort, Polite, status)?;
+		Ok(value.saturating_sub(actual))
+	}
+}
+
+impl<T: Config<I>, I: 'static> NamedReservableCurrency<T::AccountId> for Pallet<T, I>
+where
+	T::Balance: MaybeSerializeDeserialize + Debug,
+{
+	type ReserveIdentifier = T::ReserveIdentifier;
+
+	fn reserved_balance_named(id: &Self::ReserveIdentifier, who: &T::AccountId) -> Self::Balance {
+		let reserves = Self::reserves(who);
+		reserves
+			.binary_search_by_key(id, |data| data.id)
+			.map(|index| reserves[index].amount)
+			.unwrap_or_default()
+	}
+
+	/// Move `value` from the free balance from `who` to a named reserve balance.
+	///
+	/// Is a no-op if value to be reserved is zero.
+	fn reserve_named(
+		id: &Self::ReserveIdentifier,
+		who: &T::AccountId,
+		value: Self::Balance,
+	) -> DispatchResult {
+		if value.is_zero() {
+			return Ok(())
+		}
+
+		Reserves::<T, I>::try_mutate(who, |reserves| -> DispatchResult {
+			match reserves.binary_search_by_key(id, |data| data.id) {
+				Ok(index) => {
+					// this add can't overflow but just to be defensive.
+					reserves[index].amount = reserves[index].amount.defensive_saturating_add(value);
+				},
+				Err(index) => {
+					reserves
+						.try_insert(index, ReserveData { id: *id, amount: value })
+						.map_err(|_| Error::<T, I>::TooManyReserves)?;
+				},
+			};
+			<Self as ReservableCurrency<_>>::reserve(who, value)?;
+			Ok(())
+		})
+	}
+
+	/// Unreserve some funds, returning any amount that was unable to be unreserved.
+	///
+	/// Is a no-op if the value to be unreserved is zero.
+	fn unreserve_named(
+		id: &Self::ReserveIdentifier,
+		who: &T::AccountId,
+		value: Self::Balance,
+	) -> Self::Balance {
+		if value.is_zero() {
+			return Zero::zero()
+		}
+
+		Reserves::<T, I>::mutate_exists(who, |maybe_reserves| -> Self::Balance {
+			if let Some(reserves) = maybe_reserves.as_mut() {
+				match reserves.binary_search_by_key(id, |data| data.id) {
+					Ok(index) => {
+						let to_change = cmp::min(reserves[index].amount, value);
+
+						let remain = <Self as ReservableCurrency<_>>::unreserve(who, to_change);
+
+						// remain should always be zero but just to be defensive here.
+						let actual = to_change.defensive_saturating_sub(remain);
+
+						// `actual <= to_change` and `to_change <= amount`; qed;
+						reserves[index].amount -= actual;
+
+						if reserves[index].amount.is_zero() {
+							if reserves.len() == 1 {
+								// no more named reserves
+								*maybe_reserves = None;
+							} else {
+								// remove this named reserve
+								reserves.remove(index);
+							}
+						}
+
+						value - actual
+					},
+					Err(_) => value,
+				}
+			} else {
+				value
+			}
+		})
+	}
+
+	/// Slash from reserved balance, returning the negative imbalance created,
+	/// and any amount that was unable to be slashed.
+	///
+	/// Is a no-op if the value to be slashed is zero.
+	fn slash_reserved_named(
+		id: &Self::ReserveIdentifier,
+		who: &T::AccountId,
+		value: Self::Balance,
+	) -> (Self::NegativeImbalance, Self::Balance) {
+		if value.is_zero() {
+			return (NegativeImbalance::zero(), Zero::zero())
+		}
+
+		Reserves::<T, I>::mutate(who, |reserves| -> (Self::NegativeImbalance, Self::Balance) {
+			match reserves.binary_search_by_key(id, |data| data.id) {
+				Ok(index) => {
+					let to_change = cmp::min(reserves[index].amount, value);
+
+					let (imb, remain) =
+						<Self as ReservableCurrency<_>>::slash_reserved(who, to_change);
+
+					// remain should always be zero but just to be defensive here.
+					let actual = to_change.defensive_saturating_sub(remain);
+
+					// `actual <= to_change` and `to_change <= amount`; qed;
+					reserves[index].amount -= actual;
+
+					Self::deposit_event(Event::Slashed { who: who.clone(), amount: actual });
+					(imb, value - actual)
+				},
+				Err(_) => (NegativeImbalance::zero(), value),
+			}
+		})
+	}
+
+	/// Move the reserved balance of one account into the balance of another, according to `status`.
+	/// If `status` is `Reserved`, the balance will be reserved with given `id`.
+	///
+	/// Is a no-op if:
+	/// - the value to be moved is zero; or
+	/// - the `slashed` id equal to `beneficiary` and the `status` is `Reserved`.
+	fn repatriate_reserved_named(
+		id: &Self::ReserveIdentifier,
+		slashed: &T::AccountId,
+		beneficiary: &T::AccountId,
+		value: Self::Balance,
+		status: Status,
+	) -> Result<Self::Balance, DispatchError> {
+		if value.is_zero() {
+			return Ok(Zero::zero())
+		}
+
+		if slashed == beneficiary {
+			return match status {
+				Status::Free => Ok(Self::unreserve_named(id, slashed, value)),
+				Status::Reserved =>
+					Ok(value.saturating_sub(Self::reserved_balance_named(id, slashed))),
+			}
+		}
+
+		Reserves::<T, I>::try_mutate(slashed, |reserves| -> Result<Self::Balance, DispatchError> {
+			match reserves.binary_search_by_key(id, |data| data.id) {
+				Ok(index) => {
+					let to_change = cmp::min(reserves[index].amount, value);
+
+					let actual = if status == Status::Reserved {
+						// make it the reserved under same identifier
+						Reserves::<T, I>::try_mutate(
+							beneficiary,
+							|reserves| -> Result<T::Balance, DispatchError> {
+								match reserves.binary_search_by_key(id, |data| data.id) {
+									Ok(index) => {
+										let remain =
+											<Self as ReservableCurrency<_>>::repatriate_reserved(
+												slashed,
+												beneficiary,
+												to_change,
+												status,
+											)?;
+
+										// remain should always be zero but just to be defensive
+										// here.
+										let actual = to_change.defensive_saturating_sub(remain);
+
+										// this add can't overflow but just to be defensive.
+										reserves[index].amount =
+											reserves[index].amount.defensive_saturating_add(actual);
+
+										Ok(actual)
+									},
+									Err(index) => {
+										let remain =
+											<Self as ReservableCurrency<_>>::repatriate_reserved(
+												slashed,
+												beneficiary,
+												to_change,
+												status,
+											)?;
+
+										// remain should always be zero but just to be defensive
+										// here
+										let actual = to_change.defensive_saturating_sub(remain);
+
+										reserves
+											.try_insert(
+												index,
+												ReserveData { id: *id, amount: actual },
+											)
+											.map_err(|_| Error::<T, I>::TooManyReserves)?;
+
+										Ok(actual)
+									},
+								}
+							},
+						)?
+					} else {
+						let remain = <Self as ReservableCurrency<_>>::repatriate_reserved(
+							slashed,
+							beneficiary,
+							to_change,
+							status,
+						)?;
+
+						// remain should always be zero but just to be defensive here
+						to_change.defensive_saturating_sub(remain)
+					};
+
+					// `actual <= to_change` and `to_change <= amount`; qed;
+					reserves[index].amount -= actual;
+
+					Ok(value - actual)
+				},
+				Err(_) => Ok(value),
+			}
+		})
+	}
+}
+
+impl<T: Config<I>, I: 'static> LockableCurrency<T::AccountId> for Pallet<T, I>
+where
+	T::Balance: MaybeSerializeDeserialize + Debug,
+{
+	type Moment = BlockNumberFor<T>;
+
+	type MaxLocks = T::MaxLocks;
+
+	// Set or alter a lock on the balance of `who`.
+	fn set_lock(
+		id: LockIdentifier,
+		who: &T::AccountId,
+		amount: T::Balance,
+		reasons: WithdrawReasons,
+	) {
+		if reasons.is_empty() || amount.is_zero() {
+			Self::remove_lock(id, who);
+			return
+		}
+
+		let mut new_lock = Some(BalanceLock { id, amount, reasons: reasons.into() });
+		let mut locks = Self::locks(who)
+			.into_iter()
+			.filter_map(|l| if l.id == id { new_lock.take() } else { Some(l) })
+			.collect::<Vec<_>>();
+		if let Some(lock) = new_lock {
+			locks.push(lock)
+		}
+		Self::update_locks(who, &locks[..]);
+	}
+
+	// Extend a lock on the balance of `who`.
+	// Is a no-op if lock amount is zero or `reasons` `is_none()`.
+	fn extend_lock(
+		id: LockIdentifier,
+		who: &T::AccountId,
+		amount: T::Balance,
+		reasons: WithdrawReasons,
+	) {
+		if amount.is_zero() || reasons.is_empty() {
+			return
+		}
+		let mut new_lock = Some(BalanceLock { id, amount, reasons: reasons.into() });
+		let mut locks = Self::locks(who)
+			.into_iter()
+			.filter_map(|l| {
+				if l.id == id {
+					new_lock.take().map(|nl| BalanceLock {
+						id: l.id,
+						amount: l.amount.max(nl.amount),
+						reasons: l.reasons | nl.reasons,
+					})
+				} else {
+					Some(l)
+				}
+			})
+			.collect::<Vec<_>>();
+		if let Some(lock) = new_lock {
+			locks.push(lock)
+		}
+		Self::update_locks(who, &locks[..]);
+	}
+
+	fn remove_lock(id: LockIdentifier, who: &T::AccountId) {
+		let mut locks = Self::locks(who);
+		locks.retain(|l| l.id != id);
+		Self::update_locks(who, &locks[..]);
+	}
+}
diff --git a/substrate/frame/balances/src/impl_fungible.rs b/substrate/frame/balances/src/impl_fungible.rs
new file mode 100644
index 0000000000000000000000000000000000000000..03c40bb3a8401608c4c9ded644f984df962c0082
--- /dev/null
+++ b/substrate/frame/balances/src/impl_fungible.rs
@@ -0,0 +1,358 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Implementation of `fungible` traits for Balances pallet.
+use super::*;
+use frame_support::traits::tokens::{
+	Fortitude,
+	Preservation::{self, Preserve, Protect},
+	Provenance::{self, Minted},
+};
+
+impl<T: Config<I>, I: 'static> fungible::Inspect<T::AccountId> for Pallet<T, I> {
+	type Balance = T::Balance;
+
+	fn total_issuance() -> Self::Balance {
+		TotalIssuance::<T, I>::get()
+	}
+	fn active_issuance() -> Self::Balance {
+		TotalIssuance::<T, I>::get().saturating_sub(InactiveIssuance::<T, I>::get())
+	}
+	fn minimum_balance() -> Self::Balance {
+		T::ExistentialDeposit::get()
+	}
+	fn total_balance(who: &T::AccountId) -> Self::Balance {
+		Self::account(who).total()
+	}
+	fn balance(who: &T::AccountId) -> Self::Balance {
+		Self::account(who).free
+	}
+	fn reducible_balance(
+		who: &T::AccountId,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Self::Balance {
+		let a = Self::account(who);
+		let mut untouchable = Zero::zero();
+		if force == Polite {
+			// Frozen balance applies to total. Anything on hold therefore gets discounted from the
+			// limit given by the freezes.
+			untouchable = a.frozen.saturating_sub(a.reserved);
+		}
+		// If we want to keep our provider ref..
+		if preservation == Preserve
+			// ..or we don't want the account to die and our provider ref is needed for it to live..
+			|| preservation == Protect && !a.free.is_zero() &&
+				frame_system::Pallet::<T>::providers(who) == 1
+			// ..or we don't care about the account dying but our provider ref is required..
+			|| preservation == Expendable && !a.free.is_zero() &&
+				!frame_system::Pallet::<T>::can_dec_provider(who)
+		{
+			// ..then the ED needed..
+			untouchable = untouchable.max(T::ExistentialDeposit::get());
+		}
+		// Liquid balance is what is neither on hold nor frozen/required for provider.
+		a.free.saturating_sub(untouchable)
+	}
+	fn can_deposit(
+		who: &T::AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence {
+		if amount.is_zero() {
+			return DepositConsequence::Success
+		}
+
+		if provenance == Minted && TotalIssuance::<T, I>::get().checked_add(&amount).is_none() {
+			return DepositConsequence::Overflow
+		}
+
+		let account = Self::account(who);
+		let new_free = match account.free.checked_add(&amount) {
+			None => return DepositConsequence::Overflow,
+			Some(x) if x < T::ExistentialDeposit::get() => return DepositConsequence::BelowMinimum,
+			Some(x) => x,
+		};
+
+		match account.reserved.checked_add(&new_free) {
+			Some(_) => {},
+			None => return DepositConsequence::Overflow,
+		};
+
+		// NOTE: We assume that we are a provider, so don't need to do any checks in the
+		// case of account creation.
+
+		DepositConsequence::Success
+	}
+	fn can_withdraw(
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance> {
+		if amount.is_zero() {
+			return WithdrawConsequence::Success
+		}
+
+		if TotalIssuance::<T, I>::get().checked_sub(&amount).is_none() {
+			return WithdrawConsequence::Underflow
+		}
+
+		let account = Self::account(who);
+		let new_free_balance = match account.free.checked_sub(&amount) {
+			Some(x) => x,
+			None => return WithdrawConsequence::BalanceLow,
+		};
+
+		let liquid = Self::reducible_balance(who, Expendable, Polite);
+		if amount > liquid {
+			return WithdrawConsequence::Frozen
+		}
+
+		// Provider restriction - total account balance cannot be reduced to zero if it cannot
+		// sustain the loss of a provider reference.
+		// NOTE: This assumes that the pallet is a provider (which is true). Is this ever changes,
+		// then this will need to adapt accordingly.
+		let ed = T::ExistentialDeposit::get();
+		let success = if new_free_balance < ed {
+			if frame_system::Pallet::<T>::can_dec_provider(who) {
+				WithdrawConsequence::ReducedToZero(new_free_balance)
+			} else {
+				return WithdrawConsequence::WouldDie
+			}
+		} else {
+			WithdrawConsequence::Success
+		};
+
+		let new_total_balance = new_free_balance.saturating_add(account.reserved);
+
+		// Eventual free funds must be no less than the frozen balance.
+		if new_total_balance < account.frozen {
+			return WithdrawConsequence::Frozen
+		}
+
+		success
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::Unbalanced<T::AccountId> for Pallet<T, I> {
+	fn handle_dust(dust: fungible::Dust<T::AccountId, Self>) {
+		T::DustRemoval::on_unbalanced(dust.into_credit());
+	}
+	fn write_balance(
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> Result<Option<Self::Balance>, DispatchError> {
+		let max_reduction =
+			<Self as fungible::Inspect<_>>::reducible_balance(who, Expendable, Force);
+		let (result, maybe_dust) = Self::mutate_account(who, |account| -> DispatchResult {
+			// Make sure the reduction (if there is one) is no more than the maximum allowed.
+			let reduction = account.free.saturating_sub(amount);
+			ensure!(reduction <= max_reduction, Error::<T, I>::InsufficientBalance);
+
+			account.free = amount;
+			Ok(())
+		})?;
+		result?;
+		Ok(maybe_dust)
+	}
+
+	fn set_total_issuance(amount: Self::Balance) {
+		TotalIssuance::<T, I>::mutate(|t| *t = amount);
+	}
+
+	fn deactivate(amount: Self::Balance) {
+		InactiveIssuance::<T, I>::mutate(|b| b.saturating_accrue(amount));
+	}
+
+	fn reactivate(amount: Self::Balance) {
+		InactiveIssuance::<T, I>::mutate(|b| b.saturating_reduce(amount));
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::Mutate<T::AccountId> for Pallet<T, I> {
+	fn done_mint_into(who: &T::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Minted { who: who.clone(), amount });
+	}
+	fn done_burn_from(who: &T::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Burned { who: who.clone(), amount });
+	}
+	fn done_shelve(who: &T::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Suspended { who: who.clone(), amount });
+	}
+	fn done_restore(who: &T::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Restored { who: who.clone(), amount });
+	}
+	fn done_transfer(source: &T::AccountId, dest: &T::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Transfer {
+			from: source.clone(),
+			to: dest.clone(),
+			amount,
+		});
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::MutateHold<T::AccountId> for Pallet<T, I> {}
+
+impl<T: Config<I>, I: 'static> fungible::InspectHold<T::AccountId> for Pallet<T, I> {
+	type Reason = T::RuntimeHoldReason;
+
+	fn total_balance_on_hold(who: &T::AccountId) -> T::Balance {
+		Self::account(who).reserved
+	}
+	fn reducible_total_balance_on_hold(who: &T::AccountId, force: Fortitude) -> Self::Balance {
+		// The total balance must never drop below the freeze requirements if we're not forcing:
+		let a = Self::account(who);
+		let unavailable = if force == Force {
+			Self::Balance::zero()
+		} else {
+			// The freeze lock applies to the total balance, so we can discount the free balance
+			// from the amount which the total reserved balance must provide to satisfy it.
+			a.frozen.saturating_sub(a.free)
+		};
+		a.reserved.saturating_sub(unavailable)
+	}
+	fn balance_on_hold(reason: &Self::Reason, who: &T::AccountId) -> T::Balance {
+		Holds::<T, I>::get(who)
+			.iter()
+			.find(|x| &x.id == reason)
+			.map_or_else(Zero::zero, |x| x.amount)
+	}
+	fn hold_available(reason: &Self::Reason, who: &T::AccountId) -> bool {
+		if frame_system::Pallet::<T>::providers(who) == 0 {
+			return false
+		}
+		let holds = Holds::<T, I>::get(who);
+		if holds.is_full() && !holds.iter().any(|x| &x.id == reason) {
+			return false
+		}
+		true
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::UnbalancedHold<T::AccountId> for Pallet<T, I> {
+	fn set_balance_on_hold(
+		reason: &Self::Reason,
+		who: &T::AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult {
+		let mut new_account = Self::account(who);
+		let mut holds = Holds::<T, I>::get(who);
+		let mut increase = true;
+		let mut delta = amount;
+
+		if let Some(item) = holds.iter_mut().find(|x| &x.id == reason) {
+			delta = item.amount.max(amount) - item.amount.min(amount);
+			increase = amount > item.amount;
+			item.amount = amount;
+			holds.retain(|x| !x.amount.is_zero());
+		} else {
+			if !amount.is_zero() {
+				holds
+					.try_push(IdAmount { id: *reason, amount })
+					.map_err(|_| Error::<T, I>::TooManyHolds)?;
+			}
+		}
+
+		new_account.reserved = if increase {
+			new_account.reserved.checked_add(&delta).ok_or(ArithmeticError::Overflow)?
+		} else {
+			new_account.reserved.checked_sub(&delta).ok_or(ArithmeticError::Underflow)?
+		};
+
+		let (result, maybe_dust) = Self::try_mutate_account(who, |a, _| -> DispatchResult {
+			*a = new_account;
+			Ok(())
+		})?;
+		debug_assert!(
+			maybe_dust.is_none(),
+			"Does not alter main balance; dust only happens when it is altered; qed"
+		);
+		Holds::<T, I>::insert(who, holds);
+		Ok(result)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::InspectFreeze<T::AccountId> for Pallet<T, I> {
+	type Id = T::FreezeIdentifier;
+
+	fn balance_frozen(id: &Self::Id, who: &T::AccountId) -> Self::Balance {
+		let locks = Freezes::<T, I>::get(who);
+		locks.into_iter().find(|l| &l.id == id).map_or(Zero::zero(), |l| l.amount)
+	}
+
+	fn can_freeze(id: &Self::Id, who: &T::AccountId) -> bool {
+		let l = Freezes::<T, I>::get(who);
+		!l.is_full() || l.iter().any(|x| &x.id == id)
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::MutateFreeze<T::AccountId> for Pallet<T, I> {
+	fn set_freeze(id: &Self::Id, who: &T::AccountId, amount: Self::Balance) -> DispatchResult {
+		if amount.is_zero() {
+			return Self::thaw(id, who)
+		}
+		let mut locks = Freezes::<T, I>::get(who);
+		if let Some(i) = locks.iter_mut().find(|x| &x.id == id) {
+			i.amount = amount;
+		} else {
+			locks
+				.try_push(IdAmount { id: *id, amount })
+				.map_err(|_| Error::<T, I>::TooManyFreezes)?;
+		}
+		Self::update_freezes(who, locks.as_bounded_slice())
+	}
+
+	fn extend_freeze(id: &Self::Id, who: &T::AccountId, amount: Self::Balance) -> DispatchResult {
+		if amount.is_zero() {
+			return Ok(())
+		}
+		let mut locks = Freezes::<T, I>::get(who);
+		if let Some(i) = locks.iter_mut().find(|x| &x.id == id) {
+			i.amount = i.amount.max(amount);
+		} else {
+			locks
+				.try_push(IdAmount { id: *id, amount })
+				.map_err(|_| Error::<T, I>::TooManyFreezes)?;
+		}
+		Self::update_freezes(who, locks.as_bounded_slice())
+	}
+
+	fn thaw(id: &Self::Id, who: &T::AccountId) -> DispatchResult {
+		let mut locks = Freezes::<T, I>::get(who);
+		locks.retain(|l| &l.id != id);
+		Self::update_freezes(who, locks.as_bounded_slice())
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::Balanced<T::AccountId> for Pallet<T, I> {
+	type OnDropCredit = fungible::DecreaseIssuance<T::AccountId, Self>;
+	type OnDropDebt = fungible::IncreaseIssuance<T::AccountId, Self>;
+
+	fn done_deposit(who: &T::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Deposit { who: who.clone(), amount });
+	}
+	fn done_withdraw(who: &T::AccountId, amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Withdraw { who: who.clone(), amount });
+	}
+	fn done_issue(amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Issued { amount });
+	}
+	fn done_rescind(amount: Self::Balance) {
+		Self::deposit_event(Event::<T, I>::Rescinded { amount });
+	}
+}
+
+impl<T: Config<I>, I: 'static> fungible::BalancedHold<T::AccountId> for Pallet<T, I> {}
diff --git a/substrate/frame/balances/src/lib.rs b/substrate/frame/balances/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f94b3230b917b79a046ce8f1e8fcece8ab0473d7
--- /dev/null
+++ b/substrate/frame/balances/src/lib.rs
@@ -0,0 +1,1203 @@
+// 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.
+
+//! # Balances Pallet
+//!
+//! The Balances pallet provides functionality for handling accounts and balances.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! The Balances pallet provides functions for:
+//!
+//! - Getting and setting free balances.
+//! - Retrieving total, reserved and unreserved balances.
+//! - Repatriating a reserved balance to a beneficiary account that exists.
+//! - Transferring a balance between accounts (when not reserved).
+//! - Slashing an account balance.
+//! - Account creation and removal.
+//! - Managing total issuance.
+//! - Setting and managing locks.
+//!
+//! ### Terminology
+//!
+//! - **Existential Deposit:** The minimum balance required to create or keep an account open. This
+//!   prevents "dust accounts" from filling storage. When the free plus the reserved balance (i.e.
+//!   the total balance) fall below this, then the account is said to be dead; and it loses its
+//!   functionality as well as any prior history and all information on it is removed from the
+//!   chain's state. No account should ever have a total balance that is strictly between 0 and the
+//!   existential deposit (exclusive). If this ever happens, it indicates either a bug in this
+//!   pallet or an erroneous raw mutation of storage.
+//!
+//! - **Total Issuance:** The total number of units in existence in a system.
+//!
+//! - **Reaping an account:** The act of removing an account by resetting its nonce. Happens after
+//!   its
+//! total balance has become zero (or, strictly speaking, less than the Existential Deposit).
+//!
+//! - **Free Balance:** The portion of a balance that is not reserved. The free balance is the only
+//!   balance that matters for most operations.
+//!
+//! - **Reserved Balance:** Reserved balance still belongs to the account holder, but is suspended.
+//!   Reserved balance can still be slashed, but only after all the free balance has been slashed.
+//!
+//! - **Imbalance:** A condition when some funds were credited or debited without equal and opposite
+//!   accounting
+//! (i.e. a difference between total issuance and account balances). Functions that result in an
+//! imbalance will return an object of the `Imbalance` trait that can be managed within your runtime
+//! logic. (If an imbalance is simply dropped, it should automatically maintain any book-keeping
+//! such as total issuance.)
+//!
+//! - **Lock:** A freeze on a specified amount of an account's free balance until a specified block
+//!   number. Multiple
+//! locks always operate over the same funds, so they "overlay" rather than "stack".
+//!
+//! ### Implementations
+//!
+//! The Balances pallet provides implementations for the following traits. If these traits provide
+//! the functionality that you need, then you can avoid coupling with the Balances pallet.
+//!
+//! - [`Currency`](frame_support::traits::Currency): Functions for dealing with a
+//! fungible assets system.
+//! - [`ReservableCurrency`](frame_support::traits::ReservableCurrency):
+//! - [`NamedReservableCurrency`](frame_support::traits::NamedReservableCurrency):
+//! Functions for dealing with assets that can be reserved from an account.
+//! - [`LockableCurrency`](frame_support::traits::LockableCurrency): Functions for
+//! dealing with accounts that allow liquidity restrictions.
+//! - [`Imbalance`](frame_support::traits::Imbalance): Functions for handling
+//! imbalances between total issuance in the system and account balances. Must be used when a
+//! function creates new funds (e.g. a reward) or destroys some funds (e.g. a system fee).
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! - `transfer_allow_death` - Transfer some liquid free balance to another account.
+//! - `force_set_balance` - Set the balances of a given account. The origin of this call must be
+//!   root.
+//!
+//! ## Usage
+//!
+//! The following examples show how to use the Balances pallet in your custom pallet.
+//!
+//! ### Examples from the FRAME
+//!
+//! The Contract pallet uses the `Currency` trait to handle gas payment, and its types inherit from
+//! `Currency`:
+//!
+//! ```
+//! use frame_support::traits::Currency;
+//! # pub trait Config: frame_system::Config {
+//! # 	type Currency: Currency<Self::AccountId>;
+//! # }
+//!
+//! pub type BalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+//! pub type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;
+//!
+//! # fn main() {}
+//! ```
+//!
+//! The Staking pallet uses the `LockableCurrency` trait to lock a stash account's funds:
+//!
+//! ```
+//! use frame_support::traits::{WithdrawReasons, LockableCurrency};
+//! use sp_runtime::traits::Bounded;
+//! pub trait Config: frame_system::Config {
+//! 	type Currency: LockableCurrency<Self::AccountId, Moment=frame_system::pallet_prelude::BlockNumberFor<Self>>;
+//! }
+//! # struct StakingLedger<T: Config> {
+//! # 	stash: <T as frame_system::Config>::AccountId,
+//! # 	total: <<T as Config>::Currency as frame_support::traits::Currency<<T as frame_system::Config>::AccountId>>::Balance,
+//! # 	phantom: std::marker::PhantomData<T>,
+//! # }
+//! # const STAKING_ID: [u8; 8] = *b"staking ";
+//!
+//! fn update_ledger<T: Config>(
+//! 	controller: &T::AccountId,
+//! 	ledger: &StakingLedger<T>
+//! ) {
+//! 	T::Currency::set_lock(
+//! 		STAKING_ID,
+//! 		&ledger.stash,
+//! 		ledger.total,
+//! 		WithdrawReasons::all()
+//! 	);
+//! 	// <Ledger<T>>::insert(controller, ledger); // Commented out as we don't have access to Staking's storage here.
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! ## Genesis config
+//!
+//! The Balances pallet depends on the [`GenesisConfig`].
+//!
+//! ## Assumptions
+//!
+//! * Total issued balanced of all accounts should be less than `Config::Balance::max_value()`.
+//! * Existential Deposit is set to a value greater than zero.
+//!
+//! Note, you may find the Balances pallet still functions with an ED of zero in some circumstances,
+//! however this is not a configuration which is generally supported, nor will it be.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+mod benchmarking;
+mod impl_currency;
+mod impl_fungible;
+pub mod migration;
+mod tests;
+mod types;
+pub mod weights;
+
+use codec::{Codec, MaxEncodedLen};
+use frame_support::{
+	ensure,
+	pallet_prelude::DispatchResult,
+	traits::{
+		tokens::{
+			fungible, BalanceStatus as Status, DepositConsequence,
+			Fortitude::{self, Force, Polite},
+			Preservation::{Expendable, Preserve, Protect},
+			WithdrawConsequence,
+		},
+		Currency, Defensive, Get, OnUnbalanced, ReservableCurrency, StoredMap,
+	},
+	BoundedSlice, WeakBoundedVec,
+};
+use frame_system as system;
+pub use impl_currency::{NegativeImbalance, PositiveImbalance};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{
+		AtLeast32BitUnsigned, Bounded, CheckedAdd, CheckedSub, MaybeSerializeDeserialize,
+		Saturating, StaticLookup, Zero,
+	},
+	ArithmeticError, DispatchError, FixedPointOperand, Perbill, RuntimeDebug, TokenError,
+};
+use sp_std::{cmp, fmt::Debug, mem, prelude::*, result};
+pub use types::{
+	AccountData, BalanceLock, DustCleaner, ExtraFlags, IdAmount, Reasons, ReserveData,
+};
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+const LOG_TARGET: &str = "runtime::balances";
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{
+		pallet_prelude::*,
+		traits::{fungible::Credit, tokens::Precision},
+	};
+	use frame_system::pallet_prelude::*;
+
+	pub type CreditOf<T, I> = Credit<<T as frame_system::Config>::AccountId, Pallet<T, I>>;
+
+	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].
+	pub mod config_preludes {
+		use super::*;
+		use frame_support::derive_impl;
+
+		pub struct TestDefaultConfig;
+
+		#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig, no_aggregated_types)]
+		impl frame_system::DefaultConfig for TestDefaultConfig {}
+
+		#[frame_support::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			#[inject_runtime_type]
+			type RuntimeEvent = ();
+
+			type Balance = u64;
+
+			type ReserveIdentifier = ();
+			type FreezeIdentifier = ();
+
+			type MaxLocks = ();
+			type MaxReserves = ();
+			type MaxFreezes = ();
+			type MaxHolds = ();
+
+			type WeightInfo = ();
+		}
+	}
+
+	#[pallet::config(with_default)]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		#[pallet::no_default_bounds]
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The balance of an account.
+		type Balance: Parameter
+			+ Member
+			+ AtLeast32BitUnsigned
+			+ Codec
+			+ Default
+			+ Copy
+			+ MaybeSerializeDeserialize
+			+ Debug
+			+ MaxEncodedLen
+			+ TypeInfo
+			+ FixedPointOperand;
+
+		/// Handler for the unbalanced reduction when removing a dust account.
+		#[pallet::no_default]
+		type DustRemoval: OnUnbalanced<CreditOf<Self, I>>;
+
+		/// The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!
+		///
+		/// If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for
+		/// this pallet. However, you do so at your own risk: this will open up a major DoS vector.
+		/// In case you have multiple sources of provider references, you may also get unexpected
+		/// behaviour if you set this to zero.
+		///
+		/// Bottom line: Do yourself a favour and make it at least one!
+		#[pallet::constant]
+		#[pallet::no_default]
+		type ExistentialDeposit: Get<Self::Balance>;
+
+		/// The means of storing the balances of an account.
+		#[pallet::no_default]
+		type AccountStore: StoredMap<Self::AccountId, AccountData<Self::Balance>>;
+
+		/// The ID type for reserves.
+		///
+		/// Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`
+		type ReserveIdentifier: Parameter + Member + MaxEncodedLen + Ord + Copy;
+
+		/// The overarching hold reason.
+		#[pallet::no_default]
+		type RuntimeHoldReason: Parameter + Member + MaxEncodedLen + Ord + Copy;
+
+		/// The ID type for freezes.
+		type FreezeIdentifier: Parameter + Member + MaxEncodedLen + Ord + Copy;
+
+		/// The maximum number of locks that should exist on an account.
+		/// Not strictly enforced, but used for weight estimation.
+		#[pallet::constant]
+		type MaxLocks: Get<u32>;
+
+		/// The maximum number of named reserves that can exist on an account.
+		#[pallet::constant]
+		type MaxReserves: Get<u32>;
+
+		/// The maximum number of holds that can exist on an account at any time.
+		#[pallet::constant]
+		type MaxHolds: Get<u32>;
+
+		/// The maximum number of individual freeze locks that can exist on an account at any time.
+		#[pallet::constant]
+		type MaxFreezes: Get<u32>;
+	}
+
+	/// The current storage version.
+	const STORAGE_VERSION: frame_support::traits::StorageVersion =
+		frame_support::traits::StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// An account was created with some free balance.
+		Endowed { account: T::AccountId, free_balance: T::Balance },
+		/// An account was removed whose balance was non-zero but below ExistentialDeposit,
+		/// resulting in an outright loss.
+		DustLost { account: T::AccountId, amount: T::Balance },
+		/// Transfer succeeded.
+		Transfer { from: T::AccountId, to: T::AccountId, amount: T::Balance },
+		/// A balance was set by root.
+		BalanceSet { who: T::AccountId, free: T::Balance },
+		/// Some balance was reserved (moved from free to reserved).
+		Reserved { who: T::AccountId, amount: T::Balance },
+		/// Some balance was unreserved (moved from reserved to free).
+		Unreserved { who: T::AccountId, amount: T::Balance },
+		/// Some balance was moved from the reserve of the first account to the second account.
+		/// Final argument indicates the destination balance type.
+		ReserveRepatriated {
+			from: T::AccountId,
+			to: T::AccountId,
+			amount: T::Balance,
+			destination_status: Status,
+		},
+		/// Some amount was deposited (e.g. for transaction fees).
+		Deposit { who: T::AccountId, amount: T::Balance },
+		/// Some amount was withdrawn from the account (e.g. for transaction fees).
+		Withdraw { who: T::AccountId, amount: T::Balance },
+		/// Some amount was removed from the account (e.g. for misbehavior).
+		Slashed { who: T::AccountId, amount: T::Balance },
+		/// Some amount was minted into an account.
+		Minted { who: T::AccountId, amount: T::Balance },
+		/// Some amount was burned from an account.
+		Burned { who: T::AccountId, amount: T::Balance },
+		/// Some amount was suspended from an account (it can be restored later).
+		Suspended { who: T::AccountId, amount: T::Balance },
+		/// Some amount was restored into an account.
+		Restored { who: T::AccountId, amount: T::Balance },
+		/// An account was upgraded.
+		Upgraded { who: T::AccountId },
+		/// Total issuance was increased by `amount`, creating a credit to be balanced.
+		Issued { amount: T::Balance },
+		/// Total issuance was decreased by `amount`, creating a debt to be balanced.
+		Rescinded { amount: T::Balance },
+		/// Some balance was locked.
+		Locked { who: T::AccountId, amount: T::Balance },
+		/// Some balance was unlocked.
+		Unlocked { who: T::AccountId, amount: T::Balance },
+		/// Some balance was frozen.
+		Frozen { who: T::AccountId, amount: T::Balance },
+		/// Some balance was thawed.
+		Thawed { who: T::AccountId, amount: T::Balance },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Vesting balance too high to send value.
+		VestingBalance,
+		/// Account liquidity restrictions prevent withdrawal.
+		LiquidityRestrictions,
+		/// Balance too low to send value.
+		InsufficientBalance,
+		/// Value too low to create account due to existential deposit.
+		ExistentialDeposit,
+		/// Transfer/payment would kill account.
+		Expendability,
+		/// A vesting schedule already exists for this account.
+		ExistingVestingSchedule,
+		/// Beneficiary account must pre-exist.
+		DeadAccount,
+		/// Number of named reserves exceed `MaxReserves`.
+		TooManyReserves,
+		/// Number of holds exceed `MaxHolds`.
+		TooManyHolds,
+		/// Number of freezes exceed `MaxFreezes`.
+		TooManyFreezes,
+	}
+
+	/// The total units issued in the system.
+	#[pallet::storage]
+	#[pallet::getter(fn total_issuance)]
+	#[pallet::whitelist_storage]
+	pub type TotalIssuance<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Balance, ValueQuery>;
+
+	/// The total units of outstanding deactivated balance in the system.
+	#[pallet::storage]
+	#[pallet::getter(fn inactive_issuance)]
+	#[pallet::whitelist_storage]
+	pub type InactiveIssuance<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, T::Balance, ValueQuery>;
+
+	/// The Balances pallet example of storing the balance of an account.
+	///
+	/// # Example
+	///
+	/// ```nocompile
+	///  impl pallet_balances::Config for Runtime {
+	///    type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
+	///  }
+	/// ```
+	///
+	/// You can also store the balance of an account in the `System` pallet.
+	///
+	/// # Example
+	///
+	/// ```nocompile
+	///  impl pallet_balances::Config for Runtime {
+	///   type AccountStore = System
+	///  }
+	/// ```
+	///
+	/// But this comes with tradeoffs, storing account balances in the system pallet stores
+	/// `frame_system` data alongside the account data contrary to storing account balances in the
+	/// `Balances` pallet, which uses a `StorageMap` to store balances data only.
+	/// NOTE: This is only used in the case that this pallet is used to store balances.
+	#[pallet::storage]
+	pub type Account<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, AccountData<T::Balance>, ValueQuery>;
+
+	/// Any liquidity locks on some account balances.
+	/// NOTE: Should only be accessed when setting, changing and freeing a lock.
+	#[pallet::storage]
+	#[pallet::getter(fn locks)]
+	pub type Locks<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		WeakBoundedVec<BalanceLock<T::Balance>, T::MaxLocks>,
+		ValueQuery,
+	>;
+
+	/// Named reserves on some account balances.
+	#[pallet::storage]
+	#[pallet::getter(fn reserves)]
+	pub type Reserves<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		BoundedVec<ReserveData<T::ReserveIdentifier, T::Balance>, T::MaxReserves>,
+		ValueQuery,
+	>;
+
+	/// Holds on account balances.
+	#[pallet::storage]
+	pub type Holds<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		BoundedVec<IdAmount<T::RuntimeHoldReason, T::Balance>, T::MaxHolds>,
+		ValueQuery,
+	>;
+
+	/// Freeze locks on account balances.
+	#[pallet::storage]
+	pub type Freezes<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		BoundedVec<IdAmount<T::FreezeIdentifier, T::Balance>, T::MaxFreezes>,
+		ValueQuery,
+	>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub balances: Vec<(T::AccountId, T::Balance)>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			Self { balances: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			let total = self.balances.iter().fold(Zero::zero(), |acc: T::Balance, &(_, n)| acc + n);
+
+			<TotalIssuance<T, I>>::put(total);
+
+			for (_, balance) in &self.balances {
+				assert!(
+					*balance >= <T as Config<I>>::ExistentialDeposit::get(),
+					"the balance of any account should always be at least the existential deposit.",
+				)
+			}
+
+			// ensure no duplicates exist.
+			let endowed_accounts = self
+				.balances
+				.iter()
+				.map(|(x, _)| x)
+				.cloned()
+				.collect::<sp_std::collections::btree_set::BTreeSet<_>>();
+
+			assert!(
+				endowed_accounts.len() == self.balances.len(),
+				"duplicate balances in genesis."
+			);
+
+			for &(ref who, free) in self.balances.iter() {
+				frame_system::Pallet::<T>::inc_providers(who);
+				assert!(T::AccountStore::insert(who, AccountData { free, ..Default::default() })
+					.is_ok());
+			}
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		#[cfg(not(feature = "insecure_zero_ed"))]
+		fn integrity_test() {
+			assert!(
+				!<T as Config<I>>::ExistentialDeposit::get().is_zero(),
+				"The existential deposit must be greater than zero!"
+			);
+		}
+	}
+
+	#[pallet::call(weight(<T as Config<I>>::WeightInfo))]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Transfer some liquid free balance to another account.
+		///
+		/// `transfer_allow_death` will set the `FreeBalance` of the sender and receiver.
+		/// If the sender's account is below the existential deposit as a result
+		/// of the transfer, the account will be reaped.
+		///
+		/// The dispatch origin for this call must be `Signed` by the transactor.
+		#[pallet::call_index(0)]
+		pub fn transfer_allow_death(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			#[pallet::compact] value: T::Balance,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			let dest = T::Lookup::lookup(dest)?;
+			<Self as fungible::Mutate<_>>::transfer(&source, &dest, value, Expendable)?;
+			Ok(())
+		}
+
+		/// Set the regular balance of a given account; it also takes a reserved balance but this
+		/// must be the same as the account's current reserved balance.
+		///
+		/// The dispatch origin for this call is `root`.
+		///
+		/// WARNING: This call is DEPRECATED! Use `force_set_balance` instead.
+		#[pallet::call_index(1)]
+		#[pallet::weight(
+			T::WeightInfo::force_set_balance_creating() // Creates a new account.
+				.max(T::WeightInfo::force_set_balance_killing()) // Kills an existing account.
+		)]
+		pub fn set_balance_deprecated(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			#[pallet::compact] new_free: T::Balance,
+			#[pallet::compact] old_reserved: T::Balance,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let existential_deposit = Self::ed();
+
+			let wipeout = new_free < existential_deposit;
+			let new_free = if wipeout { Zero::zero() } else { new_free };
+
+			// First we try to modify the account's balance to the forced balance.
+			let old_free = Self::try_mutate_account_handling_dust(
+				&who,
+				|account, _is_new| -> Result<T::Balance, DispatchError> {
+					let old_free = account.free;
+					ensure!(account.reserved == old_reserved, TokenError::Unsupported);
+					account.free = new_free;
+					Ok(old_free)
+				},
+			)?;
+
+			// This will adjust the total issuance, which was not done by the `mutate_account`
+			// above.
+			if new_free > old_free {
+				mem::drop(PositiveImbalance::<T, I>::new(new_free - old_free));
+			} else if new_free < old_free {
+				mem::drop(NegativeImbalance::<T, I>::new(old_free - new_free));
+			}
+
+			Self::deposit_event(Event::BalanceSet { who, free: new_free });
+			Ok(())
+		}
+
+		/// Exactly as `transfer_allow_death`, except the origin must be root and the source account
+		/// may be specified.
+		#[pallet::call_index(2)]
+		pub fn force_transfer(
+			origin: OriginFor<T>,
+			source: AccountIdLookupOf<T>,
+			dest: AccountIdLookupOf<T>,
+			#[pallet::compact] value: T::Balance,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let source = T::Lookup::lookup(source)?;
+			let dest = T::Lookup::lookup(dest)?;
+			<Self as fungible::Mutate<_>>::transfer(&source, &dest, value, Expendable)?;
+			Ok(())
+		}
+
+		/// Same as the [`transfer_allow_death`] call, but with a check that the transfer will not
+		/// kill the origin account.
+		///
+		/// 99% of the time you want [`transfer_allow_death`] instead.
+		///
+		/// [`transfer_allow_death`]: struct.Pallet.html#method.transfer
+		#[pallet::call_index(3)]
+		pub fn transfer_keep_alive(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			#[pallet::compact] value: T::Balance,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			let dest = T::Lookup::lookup(dest)?;
+			<Self as fungible::Mutate<_>>::transfer(&source, &dest, value, Preserve)?;
+			Ok(())
+		}
+
+		/// Transfer the entire transferable balance from the caller account.
+		///
+		/// NOTE: This function only attempts to transfer _transferable_ balances. This means that
+		/// any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
+		/// transferred by this function. To ensure that this function results in a killed account,
+		/// you might need to prepare the account by removing any reference counters, storage
+		/// deposits, etc...
+		///
+		/// The dispatch origin of this call must be Signed.
+		///
+		/// - `dest`: The recipient of the transfer.
+		/// - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
+		///   of the funds the account has, causing the sender account to be killed (false), or
+		///   transfer everything except at least the existential deposit, which will guarantee to
+		///   keep the sender account alive (true).
+		#[pallet::call_index(4)]
+		pub fn transfer_all(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			keep_alive: bool,
+		) -> DispatchResult {
+			let transactor = ensure_signed(origin)?;
+			let keep_alive = if keep_alive { Preserve } else { Expendable };
+			let reducible_balance = <Self as fungible::Inspect<_>>::reducible_balance(
+				&transactor,
+				keep_alive,
+				Fortitude::Polite,
+			);
+			let dest = T::Lookup::lookup(dest)?;
+			<Self as fungible::Mutate<_>>::transfer(
+				&transactor,
+				&dest,
+				reducible_balance,
+				keep_alive,
+			)?;
+			Ok(())
+		}
+
+		/// Unreserve some balance from a user by force.
+		///
+		/// Can only be called by ROOT.
+		#[pallet::call_index(5)]
+		pub fn force_unreserve(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			amount: T::Balance,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let _leftover = <Self as ReservableCurrency<_>>::unreserve(&who, amount);
+			Ok(())
+		}
+
+		/// Upgrade a specified account.
+		///
+		/// - `origin`: Must be `Signed`.
+		/// - `who`: The account to be upgraded.
+		///
+		/// This will waive the transaction fee if at least all but 10% of the accounts needed to
+		/// be upgraded. (We let some not have to be upgraded just in order to allow for the
+		/// possibililty of churn).
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::upgrade_accounts(who.len() as u32))]
+		pub fn upgrade_accounts(
+			origin: OriginFor<T>,
+			who: Vec<T::AccountId>,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			if who.is_empty() {
+				return Ok(Pays::Yes.into())
+			}
+			let mut upgrade_count = 0;
+			for i in &who {
+				let upgraded = Self::ensure_upgraded(i);
+				if upgraded {
+					upgrade_count.saturating_inc();
+				}
+			}
+			let proportion_upgraded = Perbill::from_rational(upgrade_count, who.len() as u32);
+			if proportion_upgraded >= Perbill::from_percent(90) {
+				Ok(Pays::No.into())
+			} else {
+				Ok(Pays::Yes.into())
+			}
+		}
+
+		/// Alias for `transfer_allow_death`, provided only for name-wise compatibility.
+		///
+		/// WARNING: DEPRECATED! Will be released in approximately 3 months.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::transfer_allow_death())]
+		pub fn transfer(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			#[pallet::compact] value: T::Balance,
+		) -> DispatchResult {
+			let source = ensure_signed(origin)?;
+			let dest = T::Lookup::lookup(dest)?;
+			<Self as fungible::Mutate<_>>::transfer(&source, &dest, value, Expendable)?;
+			Ok(())
+		}
+
+		/// Set the regular balance of a given account.
+		///
+		/// The dispatch origin for this call is `root`.
+		#[pallet::call_index(8)]
+		#[pallet::weight(
+			T::WeightInfo::force_set_balance_creating() // Creates a new account.
+				.max(T::WeightInfo::force_set_balance_killing()) // Kills an existing account.
+		)]
+		pub fn force_set_balance(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			#[pallet::compact] new_free: T::Balance,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let existential_deposit = Self::ed();
+
+			let wipeout = new_free < existential_deposit;
+			let new_free = if wipeout { Zero::zero() } else { new_free };
+
+			// First we try to modify the account's balance to the forced balance.
+			let old_free = Self::mutate_account_handling_dust(&who, |account| {
+				let old_free = account.free;
+				account.free = new_free;
+				old_free
+			})?;
+
+			// This will adjust the total issuance, which was not done by the `mutate_account`
+			// above.
+			if new_free > old_free {
+				mem::drop(PositiveImbalance::<T, I>::new(new_free - old_free));
+			} else if new_free < old_free {
+				mem::drop(NegativeImbalance::<T, I>::new(old_free - new_free));
+			}
+
+			Self::deposit_event(Event::BalanceSet { who, free: new_free });
+			Ok(())
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		fn ed() -> T::Balance {
+			T::ExistentialDeposit::get()
+		}
+		/// Ensure the account `who` is using the new logic.
+		///
+		/// Returns `true` if the account did get upgraded, `false` if it didn't need upgrading.
+		pub fn ensure_upgraded(who: &T::AccountId) -> bool {
+			let mut a = T::AccountStore::get(who);
+			if a.flags.is_new_logic() {
+				return false
+			}
+			a.flags.set_new_logic();
+			if !a.reserved.is_zero() && a.frozen.is_zero() {
+				if system::Pallet::<T>::providers(who) == 0 {
+					// Gah!! We have no provider refs :(
+					// This shouldn't practically happen, but we need a failsafe anyway: let's give
+					// them enough for an ED.
+					log::warn!(
+						target: LOG_TARGET,
+						"account with a non-zero reserve balance has no provider refs, account_id: '{:?}'.",
+						who
+					);
+					a.free = a.free.max(Self::ed());
+					system::Pallet::<T>::inc_providers(who);
+				}
+				let _ = system::Pallet::<T>::inc_consumers_without_limit(who).defensive();
+			}
+			// Should never fail - we're only setting a bit.
+			let _ = T::AccountStore::try_mutate_exists(who, |account| -> DispatchResult {
+				*account = Some(a);
+				Ok(())
+			});
+			Self::deposit_event(Event::Upgraded { who: who.clone() });
+			return true
+		}
+
+		/// Get the free balance of an account.
+		pub fn free_balance(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
+			Self::account(who.borrow()).free
+		}
+
+		/// Get the balance of an account that can be used for transfers, reservations, or any other
+		/// non-locking, non-transaction-fee activity. Will be at most `free_balance`.
+		pub fn usable_balance(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
+			<Self as fungible::Inspect<_>>::reducible_balance(who.borrow(), Expendable, Polite)
+		}
+
+		/// Get the balance of an account that can be used for paying transaction fees (not tipping,
+		/// or any other kind of fees, though). Will be at most `free_balance`.
+		///
+		/// This requires that the account stays alive.
+		pub fn usable_balance_for_fees(
+			who: impl sp_std::borrow::Borrow<T::AccountId>,
+		) -> T::Balance {
+			<Self as fungible::Inspect<_>>::reducible_balance(who.borrow(), Protect, Polite)
+		}
+
+		/// Get the reserved balance of an account.
+		pub fn reserved_balance(who: impl sp_std::borrow::Borrow<T::AccountId>) -> T::Balance {
+			Self::account(who.borrow()).reserved
+		}
+
+		/// Get both the free and reserved balances of an account.
+		pub(crate) fn account(who: &T::AccountId) -> AccountData<T::Balance> {
+			T::AccountStore::get(who)
+		}
+
+		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
+		/// `ExistentialDeposit` law, annulling the account as needed.
+		///
+		/// It returns the result from the closure. Any dust is handled through the low-level
+		/// `fungible::Unbalanced` trap-door for legacy dust management.
+		///
+		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
+		/// when it is known that the account already exists.
+		///
+		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
+		/// the caller will do this.
+		pub(crate) fn mutate_account_handling_dust<R>(
+			who: &T::AccountId,
+			f: impl FnOnce(&mut AccountData<T::Balance>) -> R,
+		) -> Result<R, DispatchError> {
+			let (r, maybe_dust) = Self::mutate_account(who, f)?;
+			if let Some(dust) = maybe_dust {
+				<Self as fungible::Unbalanced<_>>::handle_raw_dust(dust);
+			}
+			Ok(r)
+		}
+
+		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
+		/// `ExistentialDeposit` law, annulling the account as needed.
+		///
+		/// It returns the result from the closure. Any dust is handled through the low-level
+		/// `fungible::Unbalanced` trap-door for legacy dust management.
+		///
+		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
+		/// when it is known that the account already exists.
+		///
+		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
+		/// the caller will do this.
+		pub(crate) fn try_mutate_account_handling_dust<R, E: From<DispatchError>>(
+			who: &T::AccountId,
+			f: impl FnOnce(&mut AccountData<T::Balance>, bool) -> Result<R, E>,
+		) -> Result<R, E> {
+			let (r, maybe_dust) = Self::try_mutate_account(who, f)?;
+			if let Some(dust) = maybe_dust {
+				<Self as fungible::Unbalanced<_>>::handle_raw_dust(dust);
+			}
+			Ok(r)
+		}
+
+		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
+		/// `ExistentialDeposit` law, annulling the account as needed.
+		///
+		/// It returns both the result from the closure, and an optional amount of dust
+		/// which should be handled once it is known that all nested mutates that could affect
+		/// storage items what the dust handler touches have completed.
+		///
+		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
+		/// when it is known that the account already exists.
+		///
+		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
+		/// the caller will do this.
+		pub(crate) fn mutate_account<R>(
+			who: &T::AccountId,
+			f: impl FnOnce(&mut AccountData<T::Balance>) -> R,
+		) -> Result<(R, Option<T::Balance>), DispatchError> {
+			Self::try_mutate_account(who, |a, _| -> Result<R, DispatchError> { Ok(f(a)) })
+		}
+
+		/// Returns `true` when `who` has some providers or `insecure_zero_ed` feature is disnabled.
+		/// Returns `false` otherwise.
+		#[cfg(not(feature = "insecure_zero_ed"))]
+		fn have_providers_or_no_zero_ed(_: &T::AccountId) -> bool {
+			true
+		}
+
+		/// Returns `true` when `who` has some providers or `insecure_zero_ed` feature is disnabled.
+		/// Returns `false` otherwise.
+		#[cfg(feature = "insecure_zero_ed")]
+		fn have_providers_or_no_zero_ed(who: &T::AccountId) -> bool {
+			frame_system::Pallet::<T>::providers(who) > 0
+		}
+
+		/// Mutate an account to some new value, or delete it entirely with `None`. Will enforce
+		/// `ExistentialDeposit` law, annulling the account as needed. This will do nothing if the
+		/// result of `f` is an `Err`.
+		///
+		/// It returns both the result from the closure, and an optional amount of dust
+		/// which should be handled once it is known that all nested mutates that could affect
+		/// storage items what the dust handler touches have completed.
+		///
+		/// NOTE: Doesn't do any preparatory work for creating a new account, so should only be used
+		/// when it is known that the account already exists.
+		///
+		/// NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that
+		/// the caller will do this.
+		pub(crate) fn try_mutate_account<R, E: From<DispatchError>>(
+			who: &T::AccountId,
+			f: impl FnOnce(&mut AccountData<T::Balance>, bool) -> Result<R, E>,
+		) -> Result<(R, Option<T::Balance>), E> {
+			Self::ensure_upgraded(who);
+			let result = T::AccountStore::try_mutate_exists(who, |maybe_account| {
+				let is_new = maybe_account.is_none();
+				let mut account = maybe_account.take().unwrap_or_default();
+				let did_provide =
+					account.free >= Self::ed() && Self::have_providers_or_no_zero_ed(who);
+				let did_consume =
+					!is_new && (!account.reserved.is_zero() || !account.frozen.is_zero());
+
+				let result = f(&mut account, is_new)?;
+
+				let does_provide = account.free >= Self::ed();
+				let does_consume = !account.reserved.is_zero() || !account.frozen.is_zero();
+
+				if !did_provide && does_provide {
+					frame_system::Pallet::<T>::inc_providers(who);
+				}
+				if did_consume && !does_consume {
+					frame_system::Pallet::<T>::dec_consumers(who);
+				}
+				if !did_consume && does_consume {
+					frame_system::Pallet::<T>::inc_consumers(who)?;
+				}
+				if did_provide && !does_provide {
+					// This could reap the account so must go last.
+					frame_system::Pallet::<T>::dec_providers(who).map_err(|r| {
+						if did_consume && !does_consume {
+							// best-effort revert consumer change.
+							let _ = frame_system::Pallet::<T>::inc_consumers(who).defensive();
+						}
+						if !did_consume && does_consume {
+							let _ = frame_system::Pallet::<T>::dec_consumers(who);
+						}
+						r
+					})?;
+				}
+
+				let maybe_endowed = if is_new { Some(account.free) } else { None };
+
+				// Handle any steps needed after mutating an account.
+				//
+				// This includes DustRemoval unbalancing, in the case than the `new` account's total
+				// balance is non-zero but below ED.
+				//
+				// Updates `maybe_account` to `Some` iff the account has sufficient balance.
+				// Evaluates `maybe_dust`, which is `Some` containing the dust to be dropped, iff
+				// some dust should be dropped.
+				//
+				// We should never be dropping if reserved is non-zero. Reserved being non-zero
+				// should imply that we have a consumer ref, so this is economically safe.
+				let ed = Self::ed();
+				let maybe_dust = if account.free < ed && account.reserved.is_zero() {
+					if account.free.is_zero() {
+						None
+					} else {
+						Some(account.free)
+					}
+				} else {
+					assert!(
+						account.free.is_zero() || account.free >= ed || !account.reserved.is_zero()
+					);
+					*maybe_account = Some(account);
+					None
+				};
+				Ok((maybe_endowed, maybe_dust, result))
+			});
+			result.map(|(maybe_endowed, maybe_dust, result)| {
+				if let Some(endowed) = maybe_endowed {
+					Self::deposit_event(Event::Endowed {
+						account: who.clone(),
+						free_balance: endowed,
+					});
+				}
+				if let Some(amount) = maybe_dust {
+					Pallet::<T, I>::deposit_event(Event::DustLost { account: who.clone(), amount });
+				}
+				(result, maybe_dust)
+			})
+		}
+
+		/// Update the account entry for `who`, given the locks.
+		pub(crate) fn update_locks(who: &T::AccountId, locks: &[BalanceLock<T::Balance>]) {
+			let bounded_locks = WeakBoundedVec::<_, T::MaxLocks>::force_from(
+				locks.to_vec(),
+				Some("Balances Update Locks"),
+			);
+
+			if locks.len() as u32 > T::MaxLocks::get() {
+				log::warn!(
+					target: LOG_TARGET,
+					"Warning: A user has more currency locks than expected. \
+					A runtime configuration adjustment may be needed."
+				);
+			}
+			let freezes = Freezes::<T, I>::get(who);
+			let mut prev_frozen = Zero::zero();
+			let mut after_frozen = Zero::zero();
+			// TODO: Revisit this assumption. We no manipulate consumer/provider refs.
+			// No way this can fail since we do not alter the existential balances.
+			let res = Self::mutate_account(who, |b| {
+				prev_frozen = b.frozen;
+				b.frozen = Zero::zero();
+				for l in locks.iter() {
+					b.frozen = b.frozen.max(l.amount);
+				}
+				for l in freezes.iter() {
+					b.frozen = b.frozen.max(l.amount);
+				}
+				after_frozen = b.frozen;
+			});
+			debug_assert!(res.is_ok());
+			if let Ok((_, maybe_dust)) = res {
+				debug_assert!(maybe_dust.is_none(), "Not altering main balance; qed");
+			}
+
+			let existed = Locks::<T, I>::contains_key(who);
+			if locks.is_empty() {
+				Locks::<T, I>::remove(who);
+				if existed {
+					// TODO: use Locks::<T, I>::hashed_key
+					// https://github.com/paritytech/substrate/issues/4969
+					system::Pallet::<T>::dec_consumers(who);
+				}
+			} else {
+				Locks::<T, I>::insert(who, bounded_locks);
+				if !existed && system::Pallet::<T>::inc_consumers_without_limit(who).is_err() {
+					// No providers for the locks. This is impossible under normal circumstances
+					// since the funds that are under the lock will themselves be stored in the
+					// account and therefore will need a reference.
+					log::warn!(
+						target: LOG_TARGET,
+						"Warning: Attempt to introduce lock consumer reference, yet no providers. \
+						This is unexpected but should be safe."
+					);
+				}
+			}
+
+			if prev_frozen > after_frozen {
+				let amount = prev_frozen.saturating_sub(after_frozen);
+				Self::deposit_event(Event::Unlocked { who: who.clone(), amount });
+			} else if after_frozen > prev_frozen {
+				let amount = after_frozen.saturating_sub(prev_frozen);
+				Self::deposit_event(Event::Locked { who: who.clone(), amount });
+			}
+		}
+
+		/// Update the account entry for `who`, given the locks.
+		pub(crate) fn update_freezes(
+			who: &T::AccountId,
+			freezes: BoundedSlice<IdAmount<T::FreezeIdentifier, T::Balance>, T::MaxFreezes>,
+		) -> DispatchResult {
+			let mut prev_frozen = Zero::zero();
+			let mut after_frozen = Zero::zero();
+			let (_, maybe_dust) = Self::mutate_account(who, |b| {
+				prev_frozen = b.frozen;
+				b.frozen = Zero::zero();
+				for l in Locks::<T, I>::get(who).iter() {
+					b.frozen = b.frozen.max(l.amount);
+				}
+				for l in freezes.iter() {
+					b.frozen = b.frozen.max(l.amount);
+				}
+				after_frozen = b.frozen;
+			})?;
+			debug_assert!(maybe_dust.is_none(), "Not altering main balance; qed");
+			if freezes.is_empty() {
+				Freezes::<T, I>::remove(who);
+			} else {
+				Freezes::<T, I>::insert(who, freezes);
+			}
+			if prev_frozen > after_frozen {
+				let amount = prev_frozen.saturating_sub(after_frozen);
+				Self::deposit_event(Event::Thawed { who: who.clone(), amount });
+			} else if after_frozen > prev_frozen {
+				let amount = after_frozen.saturating_sub(prev_frozen);
+				Self::deposit_event(Event::Frozen { who: who.clone(), amount });
+			}
+			Ok(())
+		}
+
+		/// Move the reserved balance of one account into the balance of another, according to
+		/// `status`. This will respect freezes/locks only if `fortitude` is `Polite`.
+		///
+		/// Is a no-op if the value to be moved is zero.
+		///
+		/// NOTE: returns actual amount of transferred value in `Ok` case.
+		pub(crate) fn do_transfer_reserved(
+			slashed: &T::AccountId,
+			beneficiary: &T::AccountId,
+			value: T::Balance,
+			precision: Precision,
+			fortitude: Fortitude,
+			status: Status,
+		) -> Result<T::Balance, DispatchError> {
+			if value.is_zero() {
+				return Ok(Zero::zero())
+			}
+
+			let max = <Self as fungible::InspectHold<_>>::reducible_total_balance_on_hold(
+				slashed, fortitude,
+			);
+			let actual = match precision {
+				Precision::BestEffort => value.min(max),
+				Precision::Exact => value,
+			};
+			ensure!(actual <= max, TokenError::FundsUnavailable);
+			if slashed == beneficiary {
+				return match status {
+					Status::Free => Ok(actual.saturating_sub(Self::unreserve(slashed, actual))),
+					Status::Reserved => Ok(actual),
+				}
+			}
+
+			let ((_, maybe_dust_1), maybe_dust_2) = Self::try_mutate_account(
+				beneficiary,
+				|to_account, is_new| -> Result<((), Option<T::Balance>), DispatchError> {
+					ensure!(!is_new, Error::<T, I>::DeadAccount);
+					Self::try_mutate_account(slashed, |from_account, _| -> DispatchResult {
+						match status {
+							Status::Free =>
+								to_account.free = to_account
+									.free
+									.checked_add(&actual)
+									.ok_or(ArithmeticError::Overflow)?,
+							Status::Reserved =>
+								to_account.reserved = to_account
+									.reserved
+									.checked_add(&actual)
+									.ok_or(ArithmeticError::Overflow)?,
+						}
+						from_account.reserved.saturating_reduce(actual);
+						Ok(())
+					})
+				},
+			)?;
+
+			if let Some(dust) = maybe_dust_1 {
+				<Self as fungible::Unbalanced<_>>::handle_raw_dust(dust);
+			}
+			if let Some(dust) = maybe_dust_2 {
+				<Self as fungible::Unbalanced<_>>::handle_raw_dust(dust);
+			}
+
+			Self::deposit_event(Event::ReserveRepatriated {
+				from: slashed.clone(),
+				to: beneficiary.clone(),
+				amount: actual,
+				destination_status: status,
+			});
+			Ok(actual)
+		}
+	}
+}
diff --git a/substrate/frame/balances/src/migration.rs b/substrate/frame/balances/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6a272a611c3f9c61d2cc687ffec5c66bea3b3b98
--- /dev/null
+++ b/substrate/frame/balances/src/migration.rs
@@ -0,0 +1,103 @@
+// Copyright 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 frame_support::{
+	pallet_prelude::*,
+	traits::{OnRuntimeUpgrade, PalletInfoAccess},
+	weights::Weight,
+};
+
+fn migrate_v0_to_v1<T: Config<I>, I: 'static>(accounts: &[T::AccountId]) -> Weight {
+	let onchain_version = Pallet::<T, I>::on_chain_storage_version();
+
+	if onchain_version == 0 {
+		let total = accounts
+			.iter()
+			.map(|a| Pallet::<T, I>::total_balance(a))
+			.fold(T::Balance::zero(), |a, e| a.saturating_add(e));
+		Pallet::<T, I>::deactivate(total);
+
+		// Remove the old `StorageVersion` type.
+		frame_support::storage::unhashed::kill(&frame_support::storage::storage_prefix(
+			Pallet::<T, I>::name().as_bytes(),
+			"StorageVersion".as_bytes(),
+		));
+
+		// Set storage version to `1`.
+		StorageVersion::new(1).put::<Pallet<T, I>>();
+
+		log::info!(target: LOG_TARGET, "Storage to version 1");
+		T::DbWeight::get().reads_writes(2 + accounts.len() as u64, 3)
+	} else {
+		log::info!(
+			target: LOG_TARGET,
+			"Migration did not execute. This probably should be removed"
+		);
+		T::DbWeight::get().reads(1)
+	}
+}
+
+// NOTE: This must be used alongside the account whose balance is expected to be inactive.
+// Generally this will be used for the XCM teleport checking account.
+pub struct MigrateToTrackInactive<T, A, I = ()>(PhantomData<(T, A, I)>);
+impl<T: Config<I>, A: Get<T::AccountId>, I: 'static> OnRuntimeUpgrade
+	for MigrateToTrackInactive<T, A, I>
+{
+	fn on_runtime_upgrade() -> Weight {
+		migrate_v0_to_v1::<T, I>(&[A::get()])
+	}
+}
+
+// NOTE: This must be used alongside the accounts whose balance is expected to be inactive.
+// Generally this will be used for the XCM teleport checking accounts.
+pub struct MigrateManyToTrackInactive<T, A, I = ()>(PhantomData<(T, A, I)>);
+impl<T: Config<I>, A: Get<Vec<T::AccountId>>, I: 'static> OnRuntimeUpgrade
+	for MigrateManyToTrackInactive<T, A, I>
+{
+	fn on_runtime_upgrade() -> Weight {
+		migrate_v0_to_v1::<T, I>(&A::get())
+	}
+}
+
+pub struct ResetInactive<T, I = ()>(PhantomData<(T, I)>);
+impl<T: Config<I>, I: 'static> OnRuntimeUpgrade for ResetInactive<T, I> {
+	fn on_runtime_upgrade() -> Weight {
+		let onchain_version = Pallet::<T, I>::on_chain_storage_version();
+
+		if onchain_version == 1 {
+			// Remove the old `StorageVersion` type.
+			frame_support::storage::unhashed::kill(&frame_support::storage::storage_prefix(
+				Pallet::<T, I>::name().as_bytes(),
+				"StorageVersion".as_bytes(),
+			));
+
+			InactiveIssuance::<T, I>::kill();
+
+			// Set storage version to `0`.
+			StorageVersion::new(0).put::<Pallet<T, I>>();
+
+			log::info!(target: LOG_TARGET, "Storage to version 0");
+			T::DbWeight::get().reads_writes(1, 2)
+		} else {
+			log::info!(
+				target: LOG_TARGET,
+				"Migration did not execute. This probably should be removed"
+			);
+			T::DbWeight::get().reads(1)
+		}
+	}
+}
diff --git a/substrate/frame/balances/src/tests/currency_tests.rs b/substrate/frame/balances/src/tests/currency_tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c9ad19f79e36dcabce1fee9d78a10e86fe186c43
--- /dev/null
+++ b/substrate/frame/balances/src/tests/currency_tests.rs
@@ -0,0 +1,1331 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Tests regarding the functionality of the `Currency` trait set implementations.
+
+use super::*;
+use crate::NegativeImbalance;
+use frame_support::traits::{
+	BalanceStatus::{Free, Reserved},
+	Currency,
+	ExistenceRequirement::{self, AllowDeath},
+	Hooks, LockIdentifier, LockableCurrency, NamedReservableCurrency, ReservableCurrency,
+	WithdrawReasons,
+};
+
+const ID_1: LockIdentifier = *b"1       ";
+const ID_2: LockIdentifier = *b"2       ";
+
+pub const CALL: &<Test as frame_system::Config>::RuntimeCall =
+	&RuntimeCall::Balances(crate::Call::transfer_allow_death { dest: 0, value: 0 });
+
+#[test]
+fn set_lock_with_amount_zero_removes_lock() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, u64::MAX, WithdrawReasons::all());
+			Balances::set_lock(ID_1, &1, 0, WithdrawReasons::all());
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath));
+		});
+}
+
+#[test]
+fn set_lock_with_withdraw_reasons_empty_removes_lock() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, u64::MAX, WithdrawReasons::all());
+			Balances::set_lock(ID_1, &1, u64::MAX, WithdrawReasons::empty());
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath));
+		});
+}
+
+#[test]
+fn basic_locking_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_eq!(Balances::free_balance(1), 10);
+			Balances::set_lock(ID_1, &1, 9, WithdrawReasons::all());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 5, AllowDeath),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn account_should_be_reaped() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_eq!(Balances::free_balance(1), 10);
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 10, AllowDeath));
+			assert_eq!(System::providers(&1), 0);
+			assert_eq!(System::consumers(&1), 0);
+			// Check that the account is dead.
+			assert!(!frame_system::Account::<Test>::contains_key(&1));
+		});
+}
+
+#[test]
+fn reap_failed_due_to_provider_and_consumer() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			// SCENARIO: only one provider and there are remaining consumers.
+			assert_ok!(System::inc_consumers(&1));
+			assert!(!System::can_dec_provider(&1));
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 10, AllowDeath),
+				TokenError::Frozen
+			);
+			assert!(System::account_exists(&1));
+			assert_eq!(Balances::free_balance(1), 10);
+
+			// SCENARIO: more than one provider, but will not kill account due to other provider.
+			assert_eq!(System::inc_providers(&1), frame_system::IncRefStatus::Existed);
+			assert_eq!(System::providers(&1), 2);
+			assert!(System::can_dec_provider(&1));
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 10, AllowDeath));
+			assert_eq!(System::providers(&1), 1);
+			assert!(System::account_exists(&1));
+			assert_eq!(Balances::free_balance(1), 0);
+		});
+}
+
+#[test]
+fn partial_locking_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, 5, WithdrawReasons::all());
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath));
+		});
+}
+
+#[test]
+fn lock_removal_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, u64::MAX, WithdrawReasons::all());
+			Balances::remove_lock(ID_1, &1);
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath));
+		});
+}
+
+#[test]
+fn lock_replacement_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, u64::MAX, WithdrawReasons::all());
+			Balances::set_lock(ID_1, &1, 5, WithdrawReasons::all());
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath));
+		});
+}
+
+#[test]
+fn double_locking_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, 5, WithdrawReasons::all());
+			Balances::set_lock(ID_2, &1, 5, WithdrawReasons::all());
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath));
+		});
+}
+
+#[test]
+fn combination_locking_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, u64::MAX, WithdrawReasons::empty());
+			Balances::set_lock(ID_2, &1, 0, WithdrawReasons::all());
+			assert_ok!(<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath));
+		});
+}
+
+#[test]
+fn lock_value_extension_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, 5, WithdrawReasons::all());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 6, AllowDeath),
+				TokenError::Frozen
+			);
+			Balances::extend_lock(ID_1, &1, 2, WithdrawReasons::all());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 6, AllowDeath),
+				TokenError::Frozen
+			);
+			Balances::extend_lock(ID_1, &1, 8, WithdrawReasons::all());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 3, AllowDeath),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn lock_should_work_reserve() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			pallet_transaction_payment::NextFeeMultiplier::<Test>::put(
+				Multiplier::saturating_from_integer(1),
+			);
+			Balances::set_lock(ID_1, &1, 10, WithdrawReasons::RESERVE);
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath),
+				TokenError::Frozen
+			);
+			assert_noop!(Balances::reserve(&1, 1), Error::<Test>::LiquidityRestrictions,);
+			assert!(<ChargeTransactionPayment<Test> as SignedExtension>::pre_dispatch(
+				ChargeTransactionPayment::from(1),
+				&1,
+				CALL,
+				&info_from_weight(Weight::from_parts(1, 0)),
+				1,
+			)
+			.is_err());
+			assert!(<ChargeTransactionPayment<Test> as SignedExtension>::pre_dispatch(
+				ChargeTransactionPayment::from(0),
+				&1,
+				CALL,
+				&info_from_weight(Weight::from_parts(1, 0)),
+				1,
+			)
+			.is_err());
+		});
+}
+
+#[test]
+fn lock_should_work_tx_fee() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, 10, WithdrawReasons::TRANSACTION_PAYMENT);
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 1, AllowDeath),
+				TokenError::Frozen
+			);
+			assert_noop!(Balances::reserve(&1, 1), Error::<Test>::LiquidityRestrictions,);
+			assert!(<ChargeTransactionPayment<Test> as SignedExtension>::pre_dispatch(
+				ChargeTransactionPayment::from(1),
+				&1,
+				CALL,
+				&info_from_weight(Weight::from_parts(1, 0)),
+				1,
+			)
+			.is_err());
+			assert!(<ChargeTransactionPayment<Test> as SignedExtension>::pre_dispatch(
+				ChargeTransactionPayment::from(0),
+				&1,
+				CALL,
+				&info_from_weight(Weight::from_parts(1, 0)),
+				1,
+			)
+			.is_err());
+		});
+}
+
+#[test]
+fn lock_block_number_extension_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, 10, WithdrawReasons::all());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 6, AllowDeath),
+				TokenError::Frozen
+			);
+			Balances::extend_lock(ID_1, &1, 10, WithdrawReasons::all());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 6, AllowDeath),
+				TokenError::Frozen
+			);
+			System::set_block_number(2);
+			Balances::extend_lock(ID_1, &1, 10, WithdrawReasons::all());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 3, AllowDeath),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn lock_reasons_extension_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			Balances::set_lock(ID_1, &1, 10, WithdrawReasons::TRANSFER);
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 6, AllowDeath),
+				TokenError::Frozen
+			);
+			Balances::extend_lock(ID_1, &1, 10, WithdrawReasons::empty());
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 6, AllowDeath),
+				TokenError::Frozen
+			);
+			Balances::extend_lock(ID_1, &1, 10, WithdrawReasons::RESERVE);
+			assert_noop!(
+				<Balances as Currency<_>>::transfer(&1, &2, 6, AllowDeath),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn reserved_balance_should_prevent_reclaim_count() {
+	ExtBuilder::default()
+		.existential_deposit(256 * 1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			System::inc_account_nonce(&2);
+			assert_eq!(Balances::total_balance(&2), 256 * 20);
+			assert_eq!(System::providers(&2), 1);
+			System::inc_providers(&2);
+			assert_eq!(System::providers(&2), 2);
+
+			assert_ok!(Balances::reserve(&2, 256 * 19 + 1)); // account 2 becomes mostly reserved
+			assert_eq!(System::providers(&2), 1);
+			assert_eq!(Balances::free_balance(2), 255); // "free" account would be deleted.
+			assert_eq!(Balances::total_balance(&2), 256 * 20); // reserve still exists.
+			assert_eq!(System::account_nonce(&2), 1);
+
+			// account 4 tries to take index 1 for account 5.
+			assert_ok!(Balances::transfer_allow_death(Some(4).into(), 5, 256 * 1 + 0x69));
+			assert_eq!(Balances::total_balance(&5), 256 * 1 + 0x69);
+
+			assert!(Balances::slash_reserved(&2, 256 * 19 + 1).1.is_zero()); // account 2 gets slashed
+
+			// "reserve" account reduced to 255 (below ED) so account no longer consuming
+			assert_ok!(System::dec_providers(&2));
+			assert_eq!(System::providers(&2), 0);
+			// account deleted
+			assert_eq!(System::account_nonce(&2), 0); // nonce zero
+			assert_eq!(Balances::total_balance(&2), 0);
+
+			// account 4 tries to take index 1 again for account 6.
+			assert_ok!(Balances::transfer_allow_death(Some(4).into(), 6, 256 * 1 + 0x69));
+			assert_eq!(Balances::total_balance(&6), 256 * 1 + 0x69);
+		});
+}
+
+#[test]
+fn reward_should_work() {
+	ExtBuilder::default().monied(true).build_and_execute_with(|| {
+		assert_eq!(Balances::total_balance(&1), 10);
+		assert_ok!(Balances::deposit_into_existing(&1, 10).map(drop));
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Deposit {
+			who: 1,
+			amount: 10,
+		}));
+		assert_eq!(Balances::total_balance(&1), 20);
+		assert_eq!(Balances::total_issuance(), 120);
+	});
+}
+
+#[test]
+fn balance_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 42);
+		System::assert_has_event(RuntimeEvent::Balances(crate::Event::Deposit {
+			who: 1,
+			amount: 42,
+		}));
+		assert_eq!(Balances::free_balance(1), 42);
+		assert_eq!(Balances::reserved_balance(1), 0);
+		assert_eq!(Balances::total_balance(&1), 42);
+		assert_eq!(Balances::free_balance(2), 0);
+		assert_eq!(Balances::reserved_balance(2), 0);
+		assert_eq!(Balances::total_balance(&2), 0);
+	});
+}
+
+#[test]
+fn reserving_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+
+		assert_eq!(Balances::total_balance(&1), 111);
+		assert_eq!(Balances::free_balance(1), 111);
+		assert_eq!(Balances::reserved_balance(1), 0);
+
+		assert_ok!(Balances::reserve(&1, 69));
+
+		assert_eq!(Balances::total_balance(&1), 111);
+		assert_eq!(Balances::free_balance(1), 42);
+		assert_eq!(Balances::reserved_balance(1), 69);
+	});
+}
+
+#[test]
+fn deducting_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+		assert_ok!(Balances::reserve(&1, 69));
+		assert_eq!(Balances::free_balance(1), 42);
+	});
+}
+
+#[test]
+fn refunding_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 42);
+		assert_ok!(Balances::mutate_account(&1, |a| a.reserved = 69));
+		Balances::unreserve(&1, 69);
+		assert_eq!(Balances::free_balance(1), 111);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn slashing_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 112);
+		assert_ok!(Balances::reserve(&1, 69));
+		assert!(Balances::slash(&1, 42).1.is_zero());
+		assert_eq!(Balances::free_balance(1), 1);
+		assert_eq!(Balances::reserved_balance(1), 69);
+		assert_eq!(Balances::total_issuance(), 70);
+	});
+}
+
+#[test]
+fn withdrawing_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&2, 111);
+		let _ =
+			Balances::withdraw(&2, 11, WithdrawReasons::TRANSFER, ExistenceRequirement::KeepAlive);
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Withdraw {
+			who: 2,
+			amount: 11,
+		}));
+		assert_eq!(Balances::free_balance(2), 100);
+		assert_eq!(Balances::total_issuance(), 100);
+	});
+}
+
+#[test]
+fn withdrawing_balance_should_fail_when_not_expendable() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		ExistentialDeposit::set(10);
+		let _ = Balances::deposit_creating(&2, 20);
+		assert_ok!(Balances::reserve(&2, 5));
+		assert_noop!(
+			Balances::withdraw(&2, 6, WithdrawReasons::TRANSFER, ExistenceRequirement::KeepAlive),
+			Error::<Test>::Expendability,
+		);
+		assert_ok!(Balances::withdraw(
+			&2,
+			5,
+			WithdrawReasons::TRANSFER,
+			ExistenceRequirement::KeepAlive
+		),);
+	});
+}
+
+#[test]
+fn slashing_incomplete_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 42);
+		assert_ok!(Balances::reserve(&1, 21));
+		assert_eq!(Balances::slash(&1, 69).1, 49);
+		assert_eq!(Balances::free_balance(1), 1);
+		assert_eq!(Balances::reserved_balance(1), 21);
+		assert_eq!(Balances::total_issuance(), 22);
+	});
+}
+
+#[test]
+fn unreserving_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+		assert_ok!(Balances::reserve(&1, 110));
+		Balances::unreserve(&1, 41);
+		assert_eq!(Balances::reserved_balance(1), 69);
+		assert_eq!(Balances::free_balance(1), 42);
+	});
+}
+
+#[test]
+fn slashing_reserved_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 112);
+		assert_ok!(Balances::reserve(&1, 111));
+		assert_eq!(Balances::slash_reserved(&1, 42).1, 0);
+		assert_eq!(Balances::reserved_balance(1), 69);
+		assert_eq!(Balances::free_balance(1), 1);
+		assert_eq!(Balances::total_issuance(), 70);
+	});
+}
+
+#[test]
+fn slashing_incomplete_reserved_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+		assert_ok!(Balances::reserve(&1, 42));
+		assert_eq!(Balances::slash_reserved(&1, 69).1, 27);
+		assert_eq!(Balances::free_balance(1), 69);
+		assert_eq!(Balances::reserved_balance(1), 0);
+		assert_eq!(Balances::total_issuance(), 69);
+	});
+}
+
+#[test]
+fn repatriating_reserved_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+		let _ = Balances::deposit_creating(&2, 1);
+		assert_ok!(Balances::reserve(&1, 110));
+		assert_ok!(Balances::repatriate_reserved(&1, &2, 41, Free), 0);
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::ReserveRepatriated {
+			from: 1,
+			to: 2,
+			amount: 41,
+			destination_status: Free,
+		}));
+		assert_eq!(Balances::reserved_balance(1), 69);
+		assert_eq!(Balances::free_balance(1), 1);
+		assert_eq!(Balances::reserved_balance(2), 0);
+		assert_eq!(Balances::free_balance(2), 42);
+	});
+}
+
+#[test]
+fn transferring_reserved_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+		let _ = Balances::deposit_creating(&2, 1);
+		assert_ok!(Balances::reserve(&1, 110));
+		assert_ok!(Balances::repatriate_reserved(&1, &2, 41, Reserved), 0);
+		assert_eq!(Balances::reserved_balance(1), 69);
+		assert_eq!(Balances::free_balance(1), 1);
+		assert_eq!(Balances::reserved_balance(2), 41);
+		assert_eq!(Balances::free_balance(2), 1);
+	});
+}
+
+#[test]
+fn transferring_reserved_balance_to_yourself_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 110);
+		assert_ok!(Balances::reserve(&1, 50));
+		assert_ok!(Balances::repatriate_reserved(&1, &1, 50, Free), 0);
+		assert_eq!(Balances::free_balance(1), 110);
+		assert_eq!(Balances::reserved_balance(1), 0);
+
+		assert_ok!(Balances::reserve(&1, 50));
+		assert_ok!(Balances::repatriate_reserved(&1, &1, 60, Free), 10);
+		assert_eq!(Balances::free_balance(1), 110);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn transferring_reserved_balance_to_nonexistent_should_fail() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+		assert_ok!(Balances::reserve(&1, 110));
+		assert_noop!(
+			Balances::repatriate_reserved(&1, &2, 42, Free),
+			Error::<Test, _>::DeadAccount
+		);
+	});
+}
+
+#[test]
+fn transferring_incomplete_reserved_balance_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 110);
+		let _ = Balances::deposit_creating(&2, 1);
+		assert_ok!(Balances::reserve(&1, 41));
+		assert_ok!(Balances::repatriate_reserved(&1, &2, 69, Free), 28);
+		assert_eq!(Balances::reserved_balance(1), 0);
+		assert_eq!(Balances::free_balance(1), 69);
+		assert_eq!(Balances::reserved_balance(2), 0);
+		assert_eq!(Balances::free_balance(2), 42);
+	});
+}
+
+#[test]
+fn transferring_too_high_value_should_not_panic() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, u64::MAX);
+		Balances::make_free_balance_be(&2, 1);
+
+		assert_err!(
+			<Balances as Currency<_>>::transfer(&1, &2, u64::MAX, AllowDeath),
+			ArithmeticError::Overflow,
+		);
+
+		assert_eq!(Balances::free_balance(1), u64::MAX);
+		assert_eq!(Balances::free_balance(2), 1);
+	});
+}
+
+#[test]
+fn account_create_on_free_too_low_with_other() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 100);
+		assert_eq!(Balances::total_issuance(), 100);
+
+		// No-op.
+		let _ = Balances::deposit_creating(&2, 50);
+		assert_eq!(Balances::free_balance(2), 0);
+		assert_eq!(Balances::total_issuance(), 100);
+	})
+}
+
+#[test]
+fn account_create_on_free_too_low() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		// No-op.
+		let _ = Balances::deposit_creating(&2, 50);
+		assert_eq!(Balances::free_balance(2), 0);
+		assert_eq!(Balances::total_issuance(), 0);
+	})
+}
+
+#[test]
+fn account_removal_on_free_too_low() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		assert_eq!(Balances::total_issuance(), 0);
+
+		// Setup two accounts with free balance above the existential threshold.
+		let _ = Balances::deposit_creating(&1, 110);
+		let _ = Balances::deposit_creating(&2, 110);
+
+		assert_eq!(Balances::free_balance(1), 110);
+		assert_eq!(Balances::free_balance(2), 110);
+		assert_eq!(Balances::total_issuance(), 220);
+
+		// Transfer funds from account 1 of such amount that after this transfer
+		// the balance of account 1 will be below the existential threshold.
+		// This should lead to the removal of all balance of this account.
+		assert_ok!(Balances::transfer_allow_death(Some(1).into(), 2, 20));
+
+		// Verify free balance removal of account 1.
+		assert_eq!(Balances::free_balance(1), 0);
+		assert_eq!(Balances::free_balance(2), 130);
+
+		// Verify that TotalIssuance tracks balance removal when free balance is too low.
+		assert_eq!(Balances::total_issuance(), 130);
+	});
+}
+
+#[test]
+fn burn_must_work() {
+	ExtBuilder::default().monied(true).build_and_execute_with(|| {
+		let init_total_issuance = Balances::total_issuance();
+		let imbalance = Balances::burn(10);
+		assert_eq!(Balances::total_issuance(), init_total_issuance - 10);
+		drop(imbalance);
+		assert_eq!(Balances::total_issuance(), init_total_issuance);
+	});
+}
+
+#[test]
+#[should_panic = "the balance of any account should always be at least the existential deposit."]
+fn cannot_set_genesis_value_below_ed() {
+	EXISTENTIAL_DEPOSIT.with(|v| *v.borrow_mut() = 11);
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let _ = crate::GenesisConfig::<Test> { balances: vec![(1, 10)] }
+		.assimilate_storage(&mut t)
+		.unwrap();
+}
+
+#[test]
+#[should_panic = "duplicate balances in genesis."]
+fn cannot_set_genesis_value_twice() {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let _ = crate::GenesisConfig::<Test> { balances: vec![(1, 10), (2, 20), (1, 15)] }
+		.assimilate_storage(&mut t)
+		.unwrap();
+}
+
+#[test]
+fn existential_deposit_respected_when_reserving() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		// Set balance to free and reserved at the existential deposit
+		assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 101));
+		// Check balance
+		assert_eq!(Balances::free_balance(1), 101);
+		assert_eq!(Balances::reserved_balance(1), 0);
+
+		// Reserve some free balance
+		assert_ok!(Balances::reserve(&1, 1));
+		// Check balance, the account should be ok.
+		assert_eq!(Balances::free_balance(1), 100);
+		assert_eq!(Balances::reserved_balance(1), 1);
+
+		// Cannot reserve any more of the free balance.
+		assert_noop!(Balances::reserve(&1, 1), DispatchError::ConsumerRemaining);
+	});
+}
+
+#[test]
+fn slash_fails_when_account_needed() {
+	ExtBuilder::default().existential_deposit(50).build_and_execute_with(|| {
+		// Set balance to free and reserved at the existential deposit
+		assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 52));
+		assert_ok!(Balances::reserve(&1, 1));
+		// Check balance
+		assert_eq!(Balances::free_balance(1), 51);
+		assert_eq!(Balances::reserved_balance(1), 1);
+
+		// Slash a small amount
+		let res = Balances::slash(&1, 1);
+		assert_eq!(res, (NegativeImbalance::new(1), 0));
+
+		// The account should be dead.
+		assert_eq!(Balances::free_balance(1), 50);
+		assert_eq!(Balances::reserved_balance(1), 1);
+
+		// Slashing again doesn't work since we require the ED
+		let res = Balances::slash(&1, 1);
+		assert_eq!(res, (NegativeImbalance::new(0), 1));
+
+		// The account should be dead.
+		assert_eq!(Balances::free_balance(1), 50);
+		assert_eq!(Balances::reserved_balance(1), 1);
+	});
+}
+
+#[test]
+fn account_deleted_when_just_dust() {
+	ExtBuilder::default().existential_deposit(50).build_and_execute_with(|| {
+		// Set balance to free and reserved at the existential deposit
+		assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 50));
+		// Check balance
+		assert_eq!(Balances::free_balance(1), 50);
+
+		// Slash a small amount
+		let res = Balances::slash(&1, 1);
+		assert_eq!(res, (NegativeImbalance::new(1), 0));
+
+		// The account should be dead.
+		assert_eq!(Balances::free_balance(1), 0);
+	});
+}
+
+#[test]
+fn emit_events_with_reserve_and_unreserve() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 100);
+
+		System::set_block_number(2);
+		assert_ok!(Balances::reserve(&1, 10));
+
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Reserved {
+			who: 1,
+			amount: 10,
+		}));
+
+		System::set_block_number(3);
+		assert!(Balances::unreserve(&1, 5).is_zero());
+
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Unreserved {
+			who: 1,
+			amount: 5,
+		}));
+
+		System::set_block_number(4);
+		assert_eq!(Balances::unreserve(&1, 6), 1);
+
+		// should only unreserve 5
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Unreserved {
+			who: 1,
+			amount: 5,
+		}));
+	});
+}
+
+#[test]
+fn emit_events_with_changing_locks() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 100);
+		System::reset_events();
+
+		// Locks = [] --> [10]
+		Balances::set_lock(*b"LOCK_000", &1, 10, WithdrawReasons::TRANSFER);
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Locked { who: 1, amount: 10 })]);
+
+		// Locks = [10] --> [15]
+		Balances::set_lock(*b"LOCK_000", &1, 15, WithdrawReasons::TRANSFER);
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Locked { who: 1, amount: 5 })]);
+
+		// Locks = [15] --> [15, 20]
+		Balances::set_lock(*b"LOCK_001", &1, 20, WithdrawReasons::TRANSACTION_PAYMENT);
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Locked { who: 1, amount: 5 })]);
+
+		// Locks = [15, 20] --> [17, 20]
+		Balances::set_lock(*b"LOCK_000", &1, 17, WithdrawReasons::TRANSACTION_PAYMENT);
+		for event in events() {
+			match event {
+				RuntimeEvent::Balances(crate::Event::Locked { .. }) => {
+					assert!(false, "unexpected lock event")
+				},
+				RuntimeEvent::Balances(crate::Event::Unlocked { .. }) => {
+					assert!(false, "unexpected unlock event")
+				},
+				_ => continue,
+			}
+		}
+
+		// Locks = [17, 20] --> [17, 15]
+		Balances::set_lock(*b"LOCK_001", &1, 15, WithdrawReasons::TRANSFER);
+		assert_eq!(
+			events(),
+			[RuntimeEvent::Balances(crate::Event::Unlocked { who: 1, amount: 3 })]
+		);
+
+		// Locks = [17, 15] --> [15]
+		Balances::remove_lock(*b"LOCK_000", &1);
+		assert_eq!(
+			events(),
+			[RuntimeEvent::Balances(crate::Event::Unlocked { who: 1, amount: 2 })]
+		);
+
+		// Locks = [15] --> []
+		Balances::remove_lock(*b"LOCK_001", &1);
+		assert_eq!(
+			events(),
+			[RuntimeEvent::Balances(crate::Event::Unlocked { who: 1, amount: 15 })]
+		);
+	});
+}
+
+#[test]
+fn emit_events_with_existential_deposit() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 100));
+
+		assert_eq!(
+			events(),
+			[
+				RuntimeEvent::System(system::Event::NewAccount { account: 1 }),
+				RuntimeEvent::Balances(crate::Event::Endowed { account: 1, free_balance: 100 }),
+				RuntimeEvent::Balances(crate::Event::BalanceSet { who: 1, free: 100 }),
+			]
+		);
+
+		let res = Balances::slash(&1, 1);
+		assert_eq!(res, (NegativeImbalance::new(1), 0));
+
+		assert_eq!(
+			events(),
+			[
+				RuntimeEvent::System(system::Event::KilledAccount { account: 1 }),
+				RuntimeEvent::Balances(crate::Event::DustLost { account: 1, amount: 99 }),
+				RuntimeEvent::Balances(crate::Event::Slashed { who: 1, amount: 1 }),
+			]
+		);
+	});
+}
+
+#[test]
+fn emit_events_with_no_existential_deposit_suicide() {
+	ExtBuilder::default().existential_deposit(1).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+
+		assert_eq!(
+			events(),
+			[
+				RuntimeEvent::Balances(crate::Event::BalanceSet { who: 1, free: 100 }),
+				RuntimeEvent::System(system::Event::NewAccount { account: 1 }),
+				RuntimeEvent::Balances(crate::Event::Endowed { account: 1, free_balance: 100 }),
+			]
+		);
+
+		let res = Balances::slash(&1, 100);
+		assert_eq!(res, (NegativeImbalance::new(100), 0));
+
+		assert_eq!(
+			events(),
+			[
+				RuntimeEvent::System(system::Event::KilledAccount { account: 1 }),
+				RuntimeEvent::Balances(crate::Event::Slashed { who: 1, amount: 100 }),
+			]
+		);
+	});
+}
+
+#[test]
+fn slash_over_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		// SCENARIO: Over-slash will kill account, and report missing slash amount.
+		Balances::make_free_balance_be(&1, 1_000);
+		// Slashed full free_balance, and reports 300 not slashed
+		assert_eq!(Balances::slash(&1, 1_300), (NegativeImbalance::new(1000), 300));
+		// Account is dead
+		assert!(!System::account_exists(&1));
+	});
+}
+
+#[test]
+fn slash_full_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		// Slashed completed in full
+		assert_eq!(Balances::slash(&1, 1_000), (NegativeImbalance::new(1000), 0));
+		// Account is still alive
+		assert!(!System::account_exists(&1));
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Slashed {
+			who: 1,
+			amount: 1000,
+		}));
+	});
+}
+
+#[test]
+fn slash_partial_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		// Slashed completed in full
+		assert_eq!(Balances::slash(&1, 900), (NegativeImbalance::new(900), 0));
+		// Account is still alive
+		assert!(System::account_exists(&1));
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Slashed {
+			who: 1,
+			amount: 900,
+		}));
+	});
+}
+
+#[test]
+fn slash_dusting_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		// Slashed completed in full
+		assert_eq!(Balances::slash(&1, 950), (NegativeImbalance::new(950), 0));
+		assert!(!System::account_exists(&1));
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Slashed {
+			who: 1,
+			amount: 950,
+		}));
+	});
+}
+
+#[test]
+fn slash_does_not_take_from_reserve() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		assert_ok!(Balances::reserve(&1, 100));
+		// Slashed completed in full
+		assert_eq!(Balances::slash(&1, 900), (NegativeImbalance::new(800), 100));
+		assert_eq!(Balances::reserved_balance(&1), 100);
+		System::assert_last_event(RuntimeEvent::Balances(crate::Event::Slashed {
+			who: 1,
+			amount: 800,
+		}));
+	});
+}
+
+#[test]
+fn slash_consumed_slash_full_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		assert_ok!(System::inc_consumers(&1)); // <-- Reference counter added here is enough for all tests
+									   // Slashed completed in full
+		assert_eq!(Balances::slash(&1, 900), (NegativeImbalance::new(900), 0));
+		// Account is still alive
+		assert!(System::account_exists(&1));
+	});
+}
+
+#[test]
+fn slash_consumed_slash_over_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		assert_ok!(System::inc_consumers(&1)); // <-- Reference counter added here is enough for all tests
+									   // Slashed completed in full
+		assert_eq!(Balances::slash(&1, 1_000), (NegativeImbalance::new(900), 100));
+		// Account is still alive
+		assert!(System::account_exists(&1));
+	});
+}
+
+#[test]
+fn slash_consumed_slash_partial_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		assert_ok!(System::inc_consumers(&1)); // <-- Reference counter added here is enough for all tests
+									   // Slashed completed in full
+		assert_eq!(Balances::slash(&1, 800), (NegativeImbalance::new(800), 0));
+		// Account is still alive
+		assert!(System::account_exists(&1));
+	});
+}
+
+#[test]
+fn slash_on_non_existant_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		// Slash on non-existent account is okay.
+		assert_eq!(Balances::slash(&12345, 1_300), (NegativeImbalance::new(0), 1300));
+	});
+}
+
+#[test]
+fn slash_reserved_slash_partial_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		assert_ok!(Balances::reserve(&1, 900));
+		// Slashed completed in full
+		assert_eq!(Balances::slash_reserved(&1, 800), (NegativeImbalance::new(800), 0));
+		assert_eq!(System::consumers(&1), 1);
+		assert_eq!(Balances::reserved_balance(&1), 100);
+		assert_eq!(Balances::free_balance(&1), 100);
+	});
+}
+
+#[test]
+fn slash_reserved_slash_everything_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		Balances::make_free_balance_be(&1, 1_000);
+		assert_ok!(Balances::reserve(&1, 900));
+		assert_eq!(System::consumers(&1), 1);
+		// Slashed completed in full
+		assert_eq!(Balances::slash_reserved(&1, 900), (NegativeImbalance::new(900), 0));
+		assert_eq!(System::consumers(&1), 0);
+		// Account is still alive
+		assert!(System::account_exists(&1));
+	});
+}
+
+#[test]
+fn slash_reserved_overslash_does_not_touch_free_balance() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		// SCENARIO: Over-slash doesn't touch free balance.
+		Balances::make_free_balance_be(&1, 1_000);
+		assert_ok!(Balances::reserve(&1, 800));
+		// Slashed done
+		assert_eq!(Balances::slash_reserved(&1, 900), (NegativeImbalance::new(800), 100));
+		assert_eq!(Balances::free_balance(&1), 200);
+	});
+}
+
+#[test]
+fn slash_reserved_on_non_existant_works() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		// Slash on non-existent account is okay.
+		assert_eq!(Balances::slash_reserved(&12345, 1_300), (NegativeImbalance::new(0), 1300));
+	});
+}
+
+#[test]
+fn operations_on_dead_account_should_not_change_state() {
+	// These functions all use `mutate_account` which may introduce a storage change when
+	// the account never existed to begin with, and shouldn't exist in the end.
+	ExtBuilder::default().existential_deposit(1).build_and_execute_with(|| {
+		assert!(!frame_system::Account::<Test>::contains_key(&1337));
+
+		// Unreserve
+		assert_storage_noop!(assert_eq!(Balances::unreserve(&1337, 42), 42));
+		// Reserve
+		assert_noop!(Balances::reserve(&1337, 42), Error::<Test, _>::InsufficientBalance);
+		// Slash Reserve
+		assert_storage_noop!(assert_eq!(Balances::slash_reserved(&1337, 42).1, 42));
+		// Repatriate Reserve
+		assert_noop!(
+			Balances::repatriate_reserved(&1337, &1338, 42, Free),
+			Error::<Test, _>::DeadAccount
+		);
+		// Slash
+		assert_storage_noop!(assert_eq!(Balances::slash(&1337, 42).1, 42));
+	});
+}
+
+#[test]
+#[should_panic = "The existential deposit must be greater than zero!"]
+fn zero_ed_is_prohibited() {
+	// These functions all use `mutate_account` which may introduce a storage change when
+	// the account never existed to begin with, and shouldn't exist in the end.
+	ExtBuilder::default().existential_deposit(0).build_and_execute_with(|| {
+		Balances::integrity_test();
+	});
+}
+
+#[test]
+fn named_reserve_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+
+		let id_1 = TestId::Foo;
+		let id_2 = TestId::Bar;
+		let id_3 = TestId::Baz;
+
+		// reserve
+
+		assert_noop!(
+			Balances::reserve_named(&id_1, &1, 112),
+			Error::<Test, _>::InsufficientBalance
+		);
+
+		assert_ok!(Balances::reserve_named(&id_1, &1, 12));
+
+		assert_eq!(Balances::reserved_balance(1), 12);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 12);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 0);
+
+		assert_ok!(Balances::reserve_named(&id_1, &1, 2));
+
+		assert_eq!(Balances::reserved_balance(1), 14);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 14);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 0);
+
+		assert_ok!(Balances::reserve_named(&id_2, &1, 23));
+
+		assert_eq!(Balances::reserved_balance(1), 37);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 14);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 23);
+
+		assert_ok!(Balances::reserve(&1, 34));
+
+		assert_eq!(Balances::reserved_balance(1), 71);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 14);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 23);
+
+		assert_eq!(Balances::total_balance(&1), 111);
+		assert_eq!(Balances::free_balance(1), 40);
+
+		assert_noop!(Balances::reserve_named(&id_3, &1, 2), Error::<Test, _>::TooManyReserves);
+
+		// unreserve
+
+		assert_eq!(Balances::unreserve_named(&id_1, &1, 10), 0);
+
+		assert_eq!(Balances::reserved_balance(1), 61);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 4);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 23);
+
+		assert_eq!(Balances::unreserve_named(&id_1, &1, 5), 1);
+
+		assert_eq!(Balances::reserved_balance(1), 57);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 0);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 23);
+
+		assert_eq!(Balances::unreserve_named(&id_2, &1, 3), 0);
+
+		assert_eq!(Balances::reserved_balance(1), 54);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 0);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 20);
+
+		assert_eq!(Balances::total_balance(&1), 111);
+		assert_eq!(Balances::free_balance(1), 57);
+
+		// slash_reserved_named
+
+		assert_ok!(Balances::reserve_named(&id_1, &1, 10));
+
+		assert_eq!(Balances::slash_reserved_named(&id_1, &1, 25).1, 15);
+
+		assert_eq!(Balances::reserved_balance(1), 54);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 0);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 20);
+		assert_eq!(Balances::total_balance(&1), 101);
+
+		assert_eq!(Balances::slash_reserved_named(&id_2, &1, 5).1, 0);
+
+		assert_eq!(Balances::reserved_balance(1), 49);
+		assert_eq!(Balances::reserved_balance_named(&id_1, &1), 0);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 15);
+		assert_eq!(Balances::total_balance(&1), 96);
+
+		// repatriate_reserved_named
+
+		let _ = Balances::deposit_creating(&2, 100);
+
+		assert_eq!(Balances::repatriate_reserved_named(&id_2, &1, &2, 10, Reserved).unwrap(), 0);
+
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 5);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &2), 10);
+		assert_eq!(Balances::reserved_balance(&2), 10);
+
+		assert_eq!(Balances::repatriate_reserved_named(&id_2, &2, &1, 11, Reserved).unwrap(), 1);
+
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 15);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &2), 0);
+		assert_eq!(Balances::reserved_balance(&2), 0);
+
+		assert_eq!(Balances::repatriate_reserved_named(&id_2, &1, &2, 10, Free).unwrap(), 0);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 5);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &2), 0);
+		assert_eq!(Balances::free_balance(&2), 110);
+
+		// repatriate_reserved_named to self
+
+		assert_eq!(Balances::repatriate_reserved_named(&id_2, &1, &1, 10, Reserved).unwrap(), 5);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 5);
+
+		assert_eq!(Balances::free_balance(&1), 47);
+
+		assert_eq!(Balances::repatriate_reserved_named(&id_2, &1, &1, 15, Free).unwrap(), 10);
+		assert_eq!(Balances::reserved_balance_named(&id_2, &1), 0);
+
+		assert_eq!(Balances::free_balance(&1), 52);
+	});
+}
+
+#[test]
+fn reserve_must_succeed_if_can_reserve_does() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 1);
+		let _ = Balances::deposit_creating(&2, 2);
+		assert!(Balances::can_reserve(&1, 1) == Balances::reserve(&1, 1).is_ok());
+		assert!(Balances::can_reserve(&2, 1) == Balances::reserve(&2, 1).is_ok());
+	});
+}
+
+#[test]
+fn reserved_named_to_yourself_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 110);
+
+		let id = TestId::Foo;
+
+		assert_ok!(Balances::reserve_named(&id, &1, 50));
+		assert_ok!(Balances::repatriate_reserved_named(&id, &1, &1, 50, Free), 0);
+		assert_eq!(Balances::free_balance(1), 110);
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 0);
+
+		assert_ok!(Balances::reserve_named(&id, &1, 50));
+		assert_ok!(Balances::repatriate_reserved_named(&id, &1, &1, 60, Free), 10);
+		assert_eq!(Balances::free_balance(1), 110);
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 0);
+	});
+}
+
+#[test]
+fn ensure_reserved_named_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+
+		let id = TestId::Foo;
+
+		assert_ok!(Balances::ensure_reserved_named(&id, &1, 15));
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 15);
+
+		assert_ok!(Balances::ensure_reserved_named(&id, &1, 10));
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 10);
+
+		assert_ok!(Balances::ensure_reserved_named(&id, &1, 20));
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 20);
+	});
+}
+
+#[test]
+fn unreserve_all_named_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+
+		let id = TestId::Foo;
+
+		assert_ok!(Balances::reserve_named(&id, &1, 15));
+
+		assert_eq!(Balances::unreserve_all_named(&id, &1), 15);
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 0);
+		assert_eq!(Balances::free_balance(&1), 111);
+
+		assert_eq!(Balances::unreserve_all_named(&id, &1), 0);
+	});
+}
+
+#[test]
+fn slash_all_reserved_named_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+
+		let id = TestId::Foo;
+
+		assert_ok!(Balances::reserve_named(&id, &1, 15));
+
+		assert_eq!(Balances::slash_all_reserved_named(&id, &1).peek(), 15);
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 0);
+		assert_eq!(Balances::free_balance(&1), 96);
+
+		assert_eq!(Balances::slash_all_reserved_named(&id, &1).peek(), 0);
+	});
+}
+
+#[test]
+fn repatriate_all_reserved_named_should_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::deposit_creating(&1, 111);
+		let _ = Balances::deposit_creating(&2, 10);
+		let _ = Balances::deposit_creating(&3, 10);
+
+		let id = TestId::Foo;
+
+		assert_ok!(Balances::reserve_named(&id, &1, 15));
+
+		assert_ok!(Balances::repatriate_all_reserved_named(&id, &1, &2, Reserved));
+		assert_eq!(Balances::reserved_balance_named(&id, &1), 0);
+		assert_eq!(Balances::reserved_balance_named(&id, &2), 15);
+
+		assert_ok!(Balances::repatriate_all_reserved_named(&id, &2, &3, Free));
+		assert_eq!(Balances::reserved_balance_named(&id, &2), 0);
+		assert_eq!(Balances::free_balance(&3), 25);
+	});
+}
+
+#[test]
+fn freezing_and_locking_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(<Balances as fungible::MutateFreeze<_>>::set_freeze(&TestId::Foo, &1, 4));
+			Balances::set_lock(ID_1, &1, 5, WithdrawReasons::all());
+			assert_eq!(System::consumers(&1), 2);
+			assert_eq!(Balances::account(&1).frozen, 5);
+			assert_ok!(<Balances as fungible::MutateFreeze<_>>::set_freeze(&TestId::Foo, &1, 6));
+			assert_eq!(Balances::account(&1).frozen, 6);
+			assert_ok!(<Balances as fungible::MutateFreeze<_>>::set_freeze(&TestId::Foo, &1, 4));
+			assert_eq!(Balances::account(&1).frozen, 5);
+			Balances::set_lock(ID_1, &1, 3, WithdrawReasons::all());
+			assert_eq!(Balances::account(&1).frozen, 4);
+			Balances::set_lock(ID_1, &1, 5, WithdrawReasons::all());
+			assert_eq!(Balances::account(&1).frozen, 5);
+			Balances::remove_lock(ID_1, &1);
+			assert_eq!(Balances::account(&1).frozen, 4);
+			assert_eq!(System::consumers(&1), 1);
+		});
+}
diff --git a/substrate/frame/balances/src/tests/dispatchable_tests.rs b/substrate/frame/balances/src/tests/dispatchable_tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76d0961e577d2dbec24643641558c2d3e5fcd66c
--- /dev/null
+++ b/substrate/frame/balances/src/tests/dispatchable_tests.rs
@@ -0,0 +1,224 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Tests regarding the functionality of the dispatchables/extrinsics.
+
+use super::*;
+use frame_support::traits::tokens::Preservation::Expendable;
+use fungible::{hold::Mutate as HoldMutate, Inspect, Mutate};
+
+#[test]
+fn default_indexing_on_new_accounts_should_not_work2() {
+	ExtBuilder::default()
+		.existential_deposit(10)
+		.monied(true)
+		.build_and_execute_with(|| {
+			// account 5 should not exist
+			// ext_deposit is 10, value is 9, not satisfies for ext_deposit
+			assert_noop!(
+				Balances::transfer_allow_death(Some(1).into(), 5, 9),
+				TokenError::BelowMinimum,
+			);
+			assert_eq!(Balances::free_balance(1), 100);
+		});
+}
+
+#[test]
+fn dust_account_removal_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(100)
+		.monied(true)
+		.build_and_execute_with(|| {
+			System::inc_account_nonce(&2);
+			assert_eq!(System::account_nonce(&2), 1);
+			assert_eq!(Balances::total_balance(&2), 2000);
+			// index 1 (account 2) becomes zombie
+			assert_ok!(Balances::transfer_allow_death(Some(2).into(), 5, 1901));
+			assert_eq!(Balances::total_balance(&2), 0);
+			assert_eq!(Balances::total_balance(&5), 1901);
+			assert_eq!(System::account_nonce(&2), 0);
+		});
+}
+
+#[test]
+fn balance_transfer_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::mint_into(&1, 111);
+		assert_ok!(Balances::transfer_allow_death(Some(1).into(), 2, 69));
+		assert_eq!(Balances::total_balance(&1), 42);
+		assert_eq!(Balances::total_balance(&2), 69);
+	});
+}
+
+#[test]
+fn force_transfer_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::mint_into(&1, 111);
+		assert_noop!(Balances::force_transfer(Some(2).into(), 1, 2, 69), BadOrigin,);
+		assert_ok!(Balances::force_transfer(RawOrigin::Root.into(), 1, 2, 69));
+		assert_eq!(Balances::total_balance(&1), 42);
+		assert_eq!(Balances::total_balance(&2), 69);
+	});
+}
+
+#[test]
+fn balance_transfer_when_on_hold_should_not_work() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::mint_into(&1, 111);
+		assert_ok!(Balances::hold(&TestId::Foo, &1, 69));
+		assert_noop!(
+			Balances::transfer_allow_death(Some(1).into(), 2, 69),
+			TokenError::FundsUnavailable,
+		);
+	});
+}
+
+#[test]
+fn transfer_keep_alive_works() {
+	ExtBuilder::default().existential_deposit(1).build_and_execute_with(|| {
+		let _ = Balances::mint_into(&1, 100);
+		assert_noop!(
+			Balances::transfer_keep_alive(Some(1).into(), 2, 100),
+			TokenError::NotExpendable
+		);
+		assert_eq!(Balances::total_balance(&1), 100);
+		assert_eq!(Balances::total_balance(&2), 0);
+	});
+}
+
+#[test]
+fn transfer_keep_alive_all_free_succeed() {
+	ExtBuilder::default().existential_deposit(100).build_and_execute_with(|| {
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1, 300));
+		assert_ok!(Balances::hold(&TestId::Foo, &1, 100));
+		assert_ok!(Balances::transfer_keep_alive(Some(1).into(), 2, 100));
+		assert_eq!(Balances::total_balance(&1), 200);
+		assert_eq!(Balances::total_balance(&2), 100);
+	});
+}
+
+#[test]
+fn transfer_all_works_1() {
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		// setup
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1, 200));
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 2, 0));
+		// transfer all and allow death
+		assert_ok!(Balances::transfer_all(Some(1).into(), 2, false));
+		assert_eq!(Balances::total_balance(&1), 0);
+		assert_eq!(Balances::total_balance(&2), 200);
+	});
+}
+
+#[test]
+fn transfer_all_works_2() {
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		// setup
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1, 200));
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 2, 0));
+		// transfer all and keep alive
+		assert_ok!(Balances::transfer_all(Some(1).into(), 2, true));
+		assert_eq!(Balances::total_balance(&1), 100);
+		assert_eq!(Balances::total_balance(&2), 100);
+	});
+}
+
+#[test]
+fn transfer_all_works_3() {
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		// setup
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1, 210));
+		assert_ok!(Balances::hold(&TestId::Foo, &1, 10));
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 2, 0));
+		// transfer all and allow death w/ reserved
+		assert_ok!(Balances::transfer_all(Some(1).into(), 2, false));
+		assert_eq!(Balances::total_balance(&1), 110);
+		assert_eq!(Balances::total_balance(&2), 100);
+	});
+}
+
+#[test]
+fn transfer_all_works_4() {
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		// setup
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1, 210));
+		assert_ok!(Balances::hold(&TestId::Foo, &1, 10));
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 2, 0));
+		// transfer all and keep alive w/ reserved
+		assert_ok!(Balances::transfer_all(Some(1).into(), 2, true));
+		assert_eq!(Balances::total_balance(&1), 110);
+		assert_eq!(Balances::total_balance(&2), 100);
+	});
+}
+
+#[test]
+fn set_balance_handles_killing_account() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::mint_into(&1, 111);
+		assert_ok!(frame_system::Pallet::<Test>::inc_consumers(&1));
+		assert_noop!(
+			Balances::force_set_balance(RuntimeOrigin::root(), 1, 0),
+			DispatchError::ConsumerRemaining,
+		);
+	});
+}
+
+#[test]
+fn set_balance_handles_total_issuance() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let old_total_issuance = Balances::total_issuance();
+		assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 1337, 69));
+		assert_eq!(Balances::total_issuance(), old_total_issuance + 69);
+		assert_eq!(Balances::total_balance(&1337), 69);
+		assert_eq!(Balances::free_balance(&1337), 69);
+	});
+}
+
+#[test]
+fn upgrade_accounts_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			System::inc_providers(&7);
+			assert_ok!(<Test as Config>::AccountStore::try_mutate_exists(
+				&7,
+				|a| -> DispatchResult {
+					*a = Some(AccountData {
+						free: 5,
+						reserved: 5,
+						frozen: Zero::zero(),
+						flags: crate::types::ExtraFlags::old_logic(),
+					});
+					Ok(())
+				}
+			));
+			assert!(!Balances::account(&7).flags.is_new_logic());
+			assert_eq!(System::providers(&7), 1);
+			assert_eq!(System::consumers(&7), 0);
+			assert_ok!(Balances::upgrade_accounts(Some(1).into(), vec![7]));
+			assert!(Balances::account(&7).flags.is_new_logic());
+			assert_eq!(System::providers(&7), 1);
+			assert_eq!(System::consumers(&7), 1);
+
+			<Balances as frame_support::traits::ReservableCurrency<_>>::unreserve(&7, 5);
+			assert_ok!(<Balances as fungible::Mutate<_>>::transfer(&7, &1, 10, Expendable));
+			assert_eq!(Balances::total_balance(&7), 0);
+			assert_eq!(System::providers(&7), 0);
+			assert_eq!(System::consumers(&7), 0);
+		});
+}
diff --git a/substrate/frame/balances/src/tests/fungible_conformance_tests.rs b/substrate/frame/balances/src/tests/fungible_conformance_tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6262aa04dc0882c52cd6ef5dc0924971d08826e2
--- /dev/null
+++ b/substrate/frame/balances/src/tests/fungible_conformance_tests.rs
@@ -0,0 +1,88 @@
+// 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::fungible::{conformance_tests, Inspect, Mutate};
+use paste::paste;
+
+macro_rules! run_tests {
+    ($path:path, $ext_deposit:expr, $($name:ident),*) => {
+		$(
+			paste! {
+				#[test]
+				fn [< $name _existential_deposit_ $ext_deposit _dust_trap_on >]() {
+					let trap_account = <Test as frame_system::Config>::AccountId::from(65174286u64);
+					let builder = ExtBuilder::default().existential_deposit($ext_deposit).dust_trap(trap_account);
+					builder.build_and_execute_with(|| {
+						Balances::set_balance(&trap_account, Balances::minimum_balance());
+						$path::$name::<
+							Balances,
+							<Test as frame_system::Config>::AccountId,
+						>(Some(trap_account));
+					});
+				}
+
+				#[test]
+				fn [< $name _existential_deposit_ $ext_deposit _dust_trap_off >]() {
+					let builder = ExtBuilder::default().existential_deposit($ext_deposit);
+					builder.build_and_execute_with(|| {
+						$path::$name::<
+							Balances,
+							<Test as frame_system::Config>::AccountId,
+						>(None);
+					});
+				}
+			}
+		)*
+	};
+	($path:path, $ext_deposit:expr) => {
+		run_tests!(
+			$path,
+			$ext_deposit,
+			mint_into_success,
+			mint_into_overflow,
+			mint_into_below_minimum,
+			burn_from_exact_success,
+			burn_from_best_effort_success,
+			burn_from_exact_insufficient_funds,
+			restore_success,
+			restore_overflow,
+			restore_below_minimum,
+			shelve_success,
+			shelve_insufficient_funds,
+			transfer_success,
+			transfer_expendable_all,
+			transfer_expendable_dust,
+			transfer_protect_preserve,
+			set_balance_mint_success,
+			set_balance_burn_success,
+			can_deposit_success,
+			can_deposit_below_minimum,
+			can_deposit_overflow,
+			can_withdraw_success,
+			can_withdraw_reduced_to_zero,
+			can_withdraw_balance_low,
+			reducible_balance_expendable,
+			reducible_balance_protect_preserve
+		);
+	};
+}
+
+run_tests!(conformance_tests::inspect_mutate, 1);
+run_tests!(conformance_tests::inspect_mutate, 2);
+run_tests!(conformance_tests::inspect_mutate, 5);
+run_tests!(conformance_tests::inspect_mutate, 1000);
diff --git a/substrate/frame/balances/src/tests/fungible_tests.rs b/substrate/frame/balances/src/tests/fungible_tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ab2606c53ff71ce13cba779dcf58e39bb2ee351d
--- /dev/null
+++ b/substrate/frame/balances/src/tests/fungible_tests.rs
@@ -0,0 +1,470 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! 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 fungible::{Inspect, InspectFreeze, InspectHold, Mutate, MutateFreeze, MutateHold, Unbalanced};
+
+#[test]
+fn inspect_trait_reducible_balance_basic_works() {
+	ExtBuilder::default().existential_deposit(10).build_and_execute_with(|| {
+		Balances::set_balance(&1, 100);
+		assert_eq!(Balances::reducible_balance(&1, Expendable, Polite), 100);
+		assert_eq!(Balances::reducible_balance(&1, Protect, Polite), 90);
+		assert_eq!(Balances::reducible_balance(&1, Preserve, Polite), 90);
+		assert_eq!(Balances::reducible_balance(&1, Expendable, Force), 100);
+		assert_eq!(Balances::reducible_balance(&1, Protect, Force), 90);
+		assert_eq!(Balances::reducible_balance(&1, Preserve, Force), 90);
+	});
+}
+
+#[test]
+fn inspect_trait_reducible_balance_other_provide_works() {
+	ExtBuilder::default().existential_deposit(10).build_and_execute_with(|| {
+		Balances::set_balance(&1, 100);
+		System::inc_providers(&1);
+		assert_eq!(Balances::reducible_balance(&1, Expendable, Polite), 100);
+		assert_eq!(Balances::reducible_balance(&1, Protect, Polite), 100);
+		assert_eq!(Balances::reducible_balance(&1, Preserve, Polite), 90);
+		assert_eq!(Balances::reducible_balance(&1, Expendable, Force), 100);
+		assert_eq!(Balances::reducible_balance(&1, Protect, Force), 100);
+		assert_eq!(Balances::reducible_balance(&1, Preserve, Force), 90);
+	});
+}
+
+#[test]
+fn inspect_trait_reducible_balance_frozen_works() {
+	ExtBuilder::default().existential_deposit(10).build_and_execute_with(|| {
+		Balances::set_balance(&1, 100);
+		assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 50));
+		assert_eq!(Balances::reducible_balance(&1, Expendable, Polite), 50);
+		assert_eq!(Balances::reducible_balance(&1, Protect, Polite), 50);
+		assert_eq!(Balances::reducible_balance(&1, Preserve, Polite), 50);
+		assert_eq!(Balances::reducible_balance(&1, Expendable, Force), 90);
+		assert_eq!(Balances::reducible_balance(&1, Protect, Force), 90);
+		assert_eq!(Balances::reducible_balance(&1, Preserve, Force), 90);
+	});
+}
+
+#[test]
+fn unbalanced_trait_set_balance_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 0);
+		assert_ok!(Balances::write_balance(&1337, 100));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 100);
+
+		assert_ok!(<Balances as fungible::MutateHold<_>>::hold(&TestId::Foo, &1337, 60));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 40);
+		assert_eq!(<Balances as fungible::InspectHold<_>>::total_balance_on_hold(&1337), 60);
+		assert_eq!(
+			<Balances as fungible::InspectHold<_>>::balance_on_hold(&TestId::Foo, &1337),
+			60
+		);
+
+		assert_noop!(Balances::write_balance(&1337, 0), Error::<Test>::InsufficientBalance);
+
+		assert_ok!(Balances::write_balance(&1337, 1));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 1);
+		assert_eq!(
+			<Balances as fungible::InspectHold<_>>::balance_on_hold(&TestId::Foo, &1337),
+			60
+		);
+
+		assert_ok!(<Balances as fungible::MutateHold<_>>::release(&TestId::Foo, &1337, 60, Exact));
+		assert_eq!(<Balances as fungible::InspectHold<_>>::balance_on_hold(&TestId::Foo, &1337), 0);
+		assert_eq!(<Balances as fungible::InspectHold<_>>::total_balance_on_hold(&1337), 0);
+	});
+}
+
+#[test]
+fn unbalanced_trait_set_total_issuance_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		assert_eq!(<Balances as fungible::Inspect<_>>::total_issuance(), 0);
+		Balances::set_total_issuance(100);
+		assert_eq!(<Balances as fungible::Inspect<_>>::total_issuance(), 100);
+	});
+}
+
+#[test]
+fn unbalanced_trait_decrease_balance_simple_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		// An Account that starts at 100
+		assert_ok!(Balances::write_balance(&1337, 100));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 100);
+		// and reserves 50
+		assert_ok!(<Balances as fungible::MutateHold<_>>::hold(&TestId::Foo, &1337, 50));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 50);
+		// and is decreased by 20
+		assert_ok!(Balances::decrease_balance(&1337, 20, Exact, Expendable, Polite));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 30);
+	});
+}
+
+#[test]
+fn unbalanced_trait_decrease_balance_works_1() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		assert_ok!(Balances::write_balance(&1337, 100));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 100);
+
+		assert_noop!(
+			Balances::decrease_balance(&1337, 101, Exact, Expendable, Polite),
+			TokenError::FundsUnavailable
+		);
+		assert_eq!(Balances::decrease_balance(&1337, 100, Exact, Expendable, Polite), Ok(100));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 0);
+	});
+}
+
+#[test]
+fn unbalanced_trait_decrease_balance_works_2() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		// free: 40, reserved: 60
+		assert_ok!(Balances::write_balance(&1337, 100));
+		assert_ok!(Balances::hold(&TestId::Foo, &1337, 60));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 40);
+		assert_eq!(Balances::total_balance_on_hold(&1337), 60);
+		assert_noop!(
+			Balances::decrease_balance(&1337, 40, Exact, Expendable, Polite),
+			Error::<Test>::InsufficientBalance
+		);
+		assert_eq!(Balances::decrease_balance(&1337, 39, Exact, Expendable, Polite), Ok(39));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 1);
+		assert_eq!(Balances::total_balance_on_hold(&1337), 60);
+	});
+}
+
+#[test]
+fn unbalanced_trait_decrease_balance_at_most_works_1() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		assert_ok!(Balances::write_balance(&1337, 100));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 100);
+
+		assert_eq!(Balances::decrease_balance(&1337, 101, BestEffort, Expendable, Polite), Ok(100));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 0);
+	});
+}
+
+#[test]
+fn unbalanced_trait_decrease_balance_at_most_works_2() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		assert_ok!(Balances::write_balance(&1337, 99));
+		assert_eq!(Balances::decrease_balance(&1337, 99, BestEffort, Expendable, Polite), Ok(99));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 0);
+	});
+}
+
+#[test]
+fn unbalanced_trait_decrease_balance_at_most_works_3() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		// free: 40, reserved: 60
+		assert_ok!(Balances::write_balance(&1337, 100));
+		assert_ok!(Balances::hold(&TestId::Foo, &1337, 60));
+		assert_eq!(Balances::free_balance(1337), 40);
+		assert_eq!(Balances::total_balance_on_hold(&1337), 60);
+		assert_eq!(Balances::decrease_balance(&1337, 0, BestEffort, Expendable, Polite), Ok(0));
+		assert_eq!(Balances::free_balance(1337), 40);
+		assert_eq!(Balances::total_balance_on_hold(&1337), 60);
+		assert_eq!(Balances::decrease_balance(&1337, 10, BestEffort, Expendable, Polite), Ok(10));
+		assert_eq!(Balances::free_balance(1337), 30);
+		assert_eq!(Balances::decrease_balance(&1337, 200, BestEffort, Expendable, Polite), Ok(29));
+		assert_eq!(<Balances as fungible::Inspect<_>>::balance(&1337), 1);
+		assert_eq!(Balances::free_balance(1337), 1);
+		assert_eq!(Balances::total_balance_on_hold(&1337), 60);
+	});
+}
+
+#[test]
+fn unbalanced_trait_increase_balance_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		assert_noop!(Balances::increase_balance(&1337, 0, Exact), TokenError::BelowMinimum);
+		assert_eq!(Balances::increase_balance(&1337, 1, Exact), Ok(1));
+		assert_noop!(Balances::increase_balance(&1337, u64::MAX, Exact), ArithmeticError::Overflow);
+	});
+}
+
+#[test]
+fn unbalanced_trait_increase_balance_at_most_works() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		assert_eq!(Balances::increase_balance(&1337, 0, BestEffort), Ok(0));
+		assert_eq!(Balances::increase_balance(&1337, 1, BestEffort), Ok(1));
+		assert_eq!(Balances::increase_balance(&1337, u64::MAX, BestEffort), Ok(u64::MAX - 1));
+	});
+}
+
+#[test]
+fn freezing_and_holds_should_overlap() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 10));
+			assert_ok!(Balances::hold(&TestId::Foo, &1, 9));
+			assert_eq!(Balances::account(&1).free, 1);
+			assert_eq!(System::consumers(&1), 1);
+			assert_eq!(Balances::account(&1).free, 1);
+			assert_eq!(Balances::account(&1).frozen, 10);
+			assert_eq!(Balances::account(&1).reserved, 9);
+			assert_eq!(Balances::total_balance_on_hold(&1), 9);
+		});
+}
+
+#[test]
+fn frozen_hold_balance_cannot_be_moved_without_force() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 10));
+			assert_ok!(Balances::hold(&TestId::Foo, &1, 9));
+			assert_eq!(Balances::reducible_total_balance_on_hold(&1, Force), 9);
+			assert_eq!(Balances::reducible_total_balance_on_hold(&1, Polite), 0);
+			let e = TokenError::Frozen;
+			assert_noop!(
+				Balances::transfer_on_hold(&TestId::Foo, &1, &2, 1, Exact, Free, Polite),
+				e
+			);
+			assert_ok!(Balances::transfer_on_hold(&TestId::Foo, &1, &2, 1, Exact, Free, Force));
+		});
+}
+
+#[test]
+fn frozen_hold_balance_best_effort_transfer_works() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 5));
+			assert_ok!(Balances::hold(&TestId::Foo, &1, 9));
+			assert_eq!(Balances::reducible_total_balance_on_hold(&1, Force), 9);
+			assert_eq!(Balances::reducible_total_balance_on_hold(&1, Polite), 5);
+			assert_ok!(Balances::transfer_on_hold(
+				&TestId::Foo,
+				&1,
+				&2,
+				10,
+				BestEffort,
+				Free,
+				Polite
+			));
+			assert_eq!(Balances::total_balance(&1), 5);
+			assert_eq!(Balances::total_balance(&2), 25);
+		});
+}
+
+#[test]
+fn partial_freezing_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 5));
+			assert_eq!(System::consumers(&1), 1);
+			assert_ok!(<Balances as fungible::Mutate<_>>::transfer(&1, &2, 5, Expendable));
+			assert_noop!(
+				<Balances as fungible::Mutate<_>>::transfer(&1, &2, 1, Expendable),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn thaw_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, u64::MAX));
+			assert_ok!(Balances::thaw(&TestId::Foo, &1));
+			assert_eq!(System::consumers(&1), 0);
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &1), 0);
+			assert_eq!(Balances::account(&1).frozen, 0);
+			assert_ok!(<Balances as fungible::Mutate<_>>::transfer(&1, &2, 10, Expendable));
+		});
+}
+
+#[test]
+fn set_freeze_zero_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, u64::MAX));
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 0));
+			assert_eq!(System::consumers(&1), 0);
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &1), 0);
+			assert_eq!(Balances::account(&1).frozen, 0);
+			assert_ok!(<Balances as fungible::Mutate<_>>::transfer(&1, &2, 10, Expendable));
+		});
+}
+
+#[test]
+fn set_freeze_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, u64::MAX));
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 5));
+			assert_ok!(<Balances as fungible::Mutate<_>>::transfer(&1, &2, 5, Expendable));
+			assert_noop!(
+				<Balances as fungible::Mutate<_>>::transfer(&1, &2, 1, Expendable),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn extend_freeze_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 5));
+			assert_ok!(Balances::extend_freeze(&TestId::Foo, &1, 10));
+			assert_eq!(Balances::account(&1).frozen, 10);
+			assert_eq!(Balances::balance_frozen(&TestId::Foo, &1), 10);
+			assert_noop!(
+				<Balances as fungible::Mutate<_>>::transfer(&1, &2, 1, Expendable),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn double_freezing_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 5));
+			assert_ok!(Balances::set_freeze(&TestId::Bar, &1, 5));
+			assert_eq!(System::consumers(&1), 1);
+			assert_ok!(<Balances as fungible::Mutate<_>>::transfer(&1, &2, 5, Expendable));
+			assert_noop!(
+				<Balances as fungible::Mutate<_>>::transfer(&1, &2, 1, Expendable),
+				TokenError::Frozen
+			);
+		});
+}
+
+#[test]
+fn can_hold_entire_balance_when_second_provider() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(false)
+		.build_and_execute_with(|| {
+			<Balances as fungible::Mutate<_>>::set_balance(&1, 100);
+			assert_noop!(Balances::hold(&TestId::Foo, &1, 100), TokenError::FundsUnavailable);
+			System::inc_providers(&1);
+			assert_eq!(System::providers(&1), 2);
+			assert_ok!(Balances::hold(&TestId::Foo, &1, 100));
+			assert_eq!(System::providers(&1), 1);
+			assert_noop!(System::dec_providers(&1), DispatchError::ConsumerRemaining);
+		});
+}
+
+#[test]
+fn unholding_frees_hold_slot() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(false)
+		.build_and_execute_with(|| {
+			<Balances as fungible::Mutate<_>>::set_balance(&1, 100);
+			assert_ok!(Balances::hold(&TestId::Foo, &1, 10));
+			assert_ok!(Balances::hold(&TestId::Bar, &1, 10));
+			assert_ok!(Balances::release(&TestId::Foo, &1, 10, Exact));
+			assert_ok!(Balances::hold(&TestId::Baz, &1, 10));
+		});
+}
+
+#[test]
+fn sufficients_work_properly_with_reference_counting() {
+	ExtBuilder::default()
+		.existential_deposit(1)
+		.monied(true)
+		.build_and_execute_with(|| {
+			// Only run PoC when the system pallet is enabled, since the underlying bug is in the
+			// system pallet it won't work with BalancesAccountStore
+			if UseSystem::get() {
+				// Start with a balance of 100
+				<Balances as fungible::Mutate<_>>::set_balance(&1, 100);
+				// Emulate a sufficient, in reality this could be reached by transferring a
+				// sufficient asset to the account
+				System::inc_sufficients(&1);
+				// Spend the same balance multiple times
+				assert_ok!(<Balances as fungible::Mutate<_>>::transfer(&1, &1337, 100, Expendable));
+				assert_eq!(Balances::free_balance(&1), 0);
+				assert_noop!(
+					<Balances as fungible::Mutate<_>>::transfer(&1, &1337, 100, Expendable),
+					TokenError::FundsUnavailable
+				);
+			}
+		});
+}
+
+#[test]
+fn emit_events_with_changing_freezes() {
+	ExtBuilder::default().build_and_execute_with(|| {
+		let _ = Balances::set_balance(&1, 100);
+		System::reset_events();
+
+		// Freeze = [] --> [10]
+		assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 10));
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Frozen { who: 1, amount: 10 })]);
+
+		// Freeze = [10] --> [15]
+		assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 15));
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Frozen { who: 1, amount: 5 })]);
+
+		// Freeze = [15] --> [15, 20]
+		assert_ok!(Balances::set_freeze(&TestId::Bar, &1, 20));
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Frozen { who: 1, amount: 5 })]);
+
+		// Freeze = [15, 20] --> [17, 20]
+		assert_ok!(Balances::set_freeze(&TestId::Foo, &1, 17));
+		for event in events() {
+			match event {
+				RuntimeEvent::Balances(crate::Event::Frozen { .. }) => {
+					assert!(false, "unexpected freeze event")
+				},
+				RuntimeEvent::Balances(crate::Event::Thawed { .. }) => {
+					assert!(false, "unexpected thaw event")
+				},
+				_ => continue,
+			}
+		}
+
+		// Freeze = [17, 20] --> [17, 15]
+		assert_ok!(Balances::set_freeze(&TestId::Bar, &1, 15));
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Thawed { who: 1, amount: 3 })]);
+
+		// Freeze = [17, 15] --> [15]
+		assert_ok!(Balances::thaw(&TestId::Foo, &1));
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Thawed { who: 1, amount: 2 })]);
+
+		// Freeze = [15] --> []
+		assert_ok!(Balances::thaw(&TestId::Bar, &1));
+		assert_eq!(events(), [RuntimeEvent::Balances(crate::Event::Thawed { who: 1, amount: 15 })]);
+	});
+}
diff --git a/substrate/frame/balances/src/tests/mod.rs b/substrate/frame/balances/src/tests/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cefc6e9e8f51f2bf9df24f14f90a6c8205457824
--- /dev/null
+++ b/substrate/frame/balances/src/tests/mod.rs
@@ -0,0 +1,313 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2018-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.
+
+//! Tests.
+
+#![cfg(test)]
+
+use crate::{self as pallet_balances, AccountData, Config, CreditOf, Error, Pallet};
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	assert_err, assert_noop, assert_ok, assert_storage_noop,
+	dispatch::{DispatchInfo, GetDispatchInfo},
+	parameter_types,
+	traits::{
+		tokens::fungible, ConstU32, ConstU64, ConstU8, Imbalance as ImbalanceT, OnUnbalanced,
+		StorageMapShim, StoredMap, WhitelistedStorageKeys,
+	},
+	weights::{IdentityFee, Weight},
+};
+use frame_system::{self as system, RawOrigin};
+use pallet_transaction_payment::{ChargeTransactionPayment, CurrencyAdapter, Multiplier};
+use scale_info::TypeInfo;
+use sp_core::{hexdisplay::HexDisplay, H256};
+use sp_io;
+use sp_runtime::{
+	traits::{BadOrigin, IdentityLookup, SignedExtension, Zero},
+	ArithmeticError, BuildStorage, DispatchError, DispatchResult, FixedPointNumber, RuntimeDebug,
+	TokenError,
+};
+use std::collections::BTreeSet;
+
+mod currency_tests;
+mod dispatchable_tests;
+mod fungible_conformance_tests;
+mod fungible_tests;
+mod reentrancy_tests;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+#[derive(
+	Encode,
+	Decode,
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	MaxEncodedLen,
+	TypeInfo,
+	RuntimeDebug,
+)]
+pub enum TestId {
+	Foo,
+	Bar,
+	Baz,
+}
+
+frame_support::construct_runtime!(
+	pub struct Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		TransactionPayment: pallet_transaction_payment::{Pallet, Storage, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(
+			frame_support::weights::Weight::from_parts(1024, u64::MAX),
+		);
+	pub static ExistentialDeposit: u64 = 1;
+}
+impl frame_system::Config for Test {
+	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 = ::sp_runtime::traits::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 = super::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl pallet_transaction_payment::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type OnChargeTransaction = CurrencyAdapter<Pallet<Test>, ()>;
+	type OperationalFeeMultiplier = ConstU8<5>;
+	type WeightToFee = IdentityFee<u64>;
+	type LengthToFee = IdentityFee<u64>;
+	type FeeMultiplierUpdate = ();
+}
+
+impl Config for Test {
+	type Balance = u64;
+	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 FreezeIdentifier = TestId;
+	type MaxFreezes = ConstU32<2>;
+	type MaxHolds = ConstU32<2>;
+}
+
+#[derive(Clone)]
+pub struct ExtBuilder {
+	existential_deposit: u64,
+	monied: bool,
+	dust_trap: Option<u64>,
+}
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self { existential_deposit: 1, monied: false, dust_trap: None }
+	}
+}
+impl ExtBuilder {
+	pub fn existential_deposit(mut self, existential_deposit: u64) -> Self {
+		self.existential_deposit = existential_deposit;
+		self
+	}
+	pub fn monied(mut self, monied: bool) -> Self {
+		self.monied = monied;
+		if self.existential_deposit == 0 {
+			self.existential_deposit = 1;
+		}
+		self
+	}
+	pub fn dust_trap(mut self, account: u64) -> Self {
+		self.dust_trap = Some(account);
+		self
+	}
+	pub fn set_associated_consts(&self) {
+		DUST_TRAP_TARGET.with(|v| v.replace(self.dust_trap));
+		EXISTENTIAL_DEPOSIT.with(|v| v.replace(self.existential_deposit));
+	}
+	pub fn build(self) -> sp_io::TestExternalities {
+		self.set_associated_consts();
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Test> {
+			balances: if self.monied {
+				vec![
+					(1, 10 * self.existential_deposit),
+					(2, 20 * self.existential_deposit),
+					(3, 30 * self.existential_deposit),
+					(4, 40 * self.existential_deposit),
+					(12, 10 * self.existential_deposit),
+				]
+			} else {
+				vec![]
+			},
+		}
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+		let mut ext = sp_io::TestExternalities::new(t);
+		ext.execute_with(|| System::set_block_number(1));
+		ext
+	}
+	pub fn build_and_execute_with(self, f: impl Fn()) {
+		let other = self.clone();
+		UseSystem::set(false);
+		other.build().execute_with(|| f());
+		UseSystem::set(true);
+		self.build().execute_with(|| f());
+	}
+}
+
+parameter_types! {
+	static DustTrapTarget: Option<u64> = None;
+}
+
+pub struct DustTrap;
+
+impl OnUnbalanced<CreditOf<Test, ()>> for DustTrap {
+	fn on_nonzero_unbalanced(amount: CreditOf<Test, ()>) {
+		match DustTrapTarget::get() {
+			None => drop(amount),
+			Some(a) => {
+				let result = <Balances as fungible::Balanced<_>>::resolve(&a, amount);
+				debug_assert!(result.is_ok());
+			},
+		}
+	}
+}
+
+parameter_types! {
+	pub static UseSystem: bool = false;
+}
+
+type BalancesAccountStore = StorageMapShim<super::Account<Test>, u64, super::AccountData<u64>>;
+type SystemAccountStore = frame_system::Pallet<Test>;
+
+pub struct TestAccountStore;
+impl StoredMap<u64, super::AccountData<u64>> for TestAccountStore {
+	fn get(k: &u64) -> super::AccountData<u64> {
+		if UseSystem::get() {
+			<SystemAccountStore as StoredMap<_, _>>::get(k)
+		} else {
+			<BalancesAccountStore as StoredMap<_, _>>::get(k)
+		}
+	}
+	fn try_mutate_exists<R, E: From<DispatchError>>(
+		k: &u64,
+		f: impl FnOnce(&mut Option<super::AccountData<u64>>) -> Result<R, E>,
+	) -> Result<R, E> {
+		if UseSystem::get() {
+			<SystemAccountStore as StoredMap<_, _>>::try_mutate_exists(k, f)
+		} else {
+			<BalancesAccountStore as StoredMap<_, _>>::try_mutate_exists(k, f)
+		}
+	}
+	fn mutate<R>(
+		k: &u64,
+		f: impl FnOnce(&mut super::AccountData<u64>) -> R,
+	) -> Result<R, DispatchError> {
+		if UseSystem::get() {
+			<SystemAccountStore as StoredMap<_, _>>::mutate(k, f)
+		} else {
+			<BalancesAccountStore as StoredMap<_, _>>::mutate(k, f)
+		}
+	}
+	fn mutate_exists<R>(
+		k: &u64,
+		f: impl FnOnce(&mut Option<super::AccountData<u64>>) -> R,
+	) -> Result<R, DispatchError> {
+		if UseSystem::get() {
+			<SystemAccountStore as StoredMap<_, _>>::mutate_exists(k, f)
+		} else {
+			<BalancesAccountStore as StoredMap<_, _>>::mutate_exists(k, f)
+		}
+	}
+	fn insert(k: &u64, t: super::AccountData<u64>) -> Result<(), DispatchError> {
+		if UseSystem::get() {
+			<SystemAccountStore as StoredMap<_, _>>::insert(k, t)
+		} else {
+			<BalancesAccountStore as StoredMap<_, _>>::insert(k, t)
+		}
+	}
+	fn remove(k: &u64) -> Result<(), DispatchError> {
+		if UseSystem::get() {
+			<SystemAccountStore as StoredMap<_, _>>::remove(k)
+		} else {
+			<BalancesAccountStore as StoredMap<_, _>>::remove(k)
+		}
+	}
+}
+
+pub fn events() -> Vec<RuntimeEvent> {
+	let evt = System::events().into_iter().map(|evt| evt.event).collect::<Vec<_>>();
+	System::reset_events();
+	evt
+}
+
+/// create a transaction info struct from weight. Handy to avoid building the whole struct.
+pub fn info_from_weight(w: Weight) -> DispatchInfo {
+	DispatchInfo { weight: w, ..Default::default() }
+}
+
+#[test]
+fn weights_sane() {
+	let info = crate::Call::<Test>::transfer_allow_death { dest: 10, value: 4 }.get_dispatch_info();
+	assert_eq!(<() as crate::WeightInfo>::transfer_allow_death(), info.weight);
+
+	let info = crate::Call::<Test>::force_unreserve { who: 10, amount: 4 }.get_dispatch_info();
+	assert_eq!(<() as crate::WeightInfo>::force_unreserve(), info.weight);
+}
+
+#[test]
+fn check_whitelist() {
+	let whitelist: BTreeSet<String> = AllPalletsWithSystem::whitelisted_storage_keys()
+		.iter()
+		.map(|s| HexDisplay::from(&s.key).to_string())
+		.collect();
+	// Inactive Issuance
+	assert!(whitelist.contains("c2261276cc9d1f8598ea4b6a74b15c2f1ccde6872881f893a21de93dfe970cd5"));
+	// Total Issuance
+	assert!(whitelist.contains("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80"));
+}
diff --git a/substrate/frame/balances/src/tests/reentrancy_tests.rs b/substrate/frame/balances/src/tests/reentrancy_tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e97bf2ed2b706d582fc672f2c62c5f66afc4f74f
--- /dev/null
+++ b/substrate/frame/balances/src/tests/reentrancy_tests.rs
@@ -0,0 +1,195 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Tests regarding the reentrancy functionality.
+
+use super::*;
+use frame_support::traits::tokens::{
+	Fortitude::Force,
+	Precision::BestEffort,
+	Preservation::{Expendable, Protect},
+};
+use fungible::Balanced;
+
+#[test]
+fn transfer_dust_removal_tst1_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(100)
+		.dust_trap(1)
+		.build_and_execute_with(|| {
+			// Verification of reentrancy in dust removal
+			assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 1000));
+			assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 2, 500));
+
+			// In this transaction, account 2 free balance
+			// drops below existential balance
+			// and dust balance is removed from account 2
+			assert_ok!(Balances::transfer_allow_death(RawOrigin::Signed(2).into(), 3, 450));
+
+			// As expected dust balance is removed.
+			assert_eq!(Balances::free_balance(&2), 0);
+
+			// As expected beneficiary account 3
+			// received the transfered fund.
+			assert_eq!(Balances::free_balance(&3), 450);
+
+			// Dust balance is deposited to account 1
+			// during the process of dust removal.
+			assert_eq!(Balances::free_balance(&1), 1050);
+
+			// Verify the events
+			assert_eq!(System::events().len(), 12);
+
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::Transfer {
+				from: 2,
+				to: 3,
+				amount: 450,
+			}));
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::DustLost {
+				account: 2,
+				amount: 50,
+			}));
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::Deposit {
+				who: 1,
+				amount: 50,
+			}));
+		});
+}
+
+#[test]
+fn transfer_dust_removal_tst2_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(100)
+		.dust_trap(1)
+		.build_and_execute_with(|| {
+			// Verification of reentrancy in dust removal
+			assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 1000));
+			assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 2, 500));
+
+			// In this transaction, account 2 free balance
+			// drops below existential balance
+			// and dust balance is removed from account 2
+			assert_ok!(Balances::transfer_allow_death(RawOrigin::Signed(2).into(), 1, 450));
+
+			// As expected dust balance is removed.
+			assert_eq!(Balances::free_balance(&2), 0);
+
+			// Dust balance is deposited to account 1
+			// during the process of dust removal.
+			assert_eq!(Balances::free_balance(&1), 1500);
+
+			// Verify the events
+			assert_eq!(System::events().len(), 10);
+
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::Transfer {
+				from: 2,
+				to: 1,
+				amount: 450,
+			}));
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::DustLost {
+				account: 2,
+				amount: 50,
+			}));
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::Deposit {
+				who: 1,
+				amount: 50,
+			}));
+		});
+}
+
+#[test]
+fn repatriating_reserved_balance_dust_removal_should_work() {
+	ExtBuilder::default()
+		.existential_deposit(100)
+		.dust_trap(1)
+		.build_and_execute_with(|| {
+			// Verification of reentrancy in dust removal
+			assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 1000));
+			assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 2, 500));
+
+			// Reserve a value on account 2,
+			// Such that free balance is lower than
+			// Exestintial deposit.
+			assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), 1, 450));
+
+			// Since free balance of account 2 is lower than
+			// existential deposit, dust amount is
+			// removed from the account 2
+			assert_eq!(Balances::reserved_balance(2), 0);
+			assert_eq!(Balances::free_balance(2), 0);
+
+			// account 1 is credited with reserved amount
+			// together with dust balance during dust
+			// removal.
+			assert_eq!(Balances::reserved_balance(1), 0);
+			assert_eq!(Balances::free_balance(1), 1500);
+
+			// Verify the events
+			assert_eq!(System::events().len(), 10);
+
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::Transfer {
+				from: 2,
+				to: 1,
+				amount: 450,
+			}));
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::DustLost {
+				account: 2,
+				amount: 50,
+			}));
+			System::assert_has_event(RuntimeEvent::Balances(crate::Event::Deposit {
+				who: 1,
+				amount: 50,
+			}));
+		});
+}
+
+#[test]
+fn emit_events_with_no_existential_deposit_suicide_with_dust() {
+	ExtBuilder::default().existential_deposit(2).build_and_execute_with(|| {
+		assert_ok!(Balances::force_set_balance(RawOrigin::Root.into(), 1, 100));
+
+		assert_eq!(
+			events(),
+			[
+				RuntimeEvent::System(system::Event::NewAccount { account: 1 }),
+				RuntimeEvent::Balances(crate::Event::Endowed { account: 1, free_balance: 100 }),
+				RuntimeEvent::Balances(crate::Event::BalanceSet { who: 1, free: 100 }),
+			]
+		);
+
+		let res = Balances::withdraw(&1, 98, BestEffort, Protect, Force);
+		assert_eq!(res.unwrap().peek(), 98);
+
+		// no events
+		assert_eq!(
+			events(),
+			[RuntimeEvent::Balances(crate::Event::Withdraw { who: 1, amount: 98 })]
+		);
+
+		let res = Balances::withdraw(&1, 1, BestEffort, Expendable, Force);
+		assert_eq!(res.unwrap().peek(), 1);
+
+		assert_eq!(
+			events(),
+			[
+				RuntimeEvent::System(system::Event::KilledAccount { account: 1 }),
+				RuntimeEvent::Balances(crate::Event::DustLost { account: 1, amount: 1 }),
+				RuntimeEvent::Balances(crate::Event::Withdraw { who: 1, amount: 1 })
+			]
+		);
+	});
+}
diff --git a/substrate/frame/balances/src/types.rs b/substrate/frame/balances/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cd100d0df6c6d4278b49696f3155fb9908d2f21e
--- /dev/null
+++ b/substrate/frame/balances/src/types.rs
@@ -0,0 +1,154 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Types used in the pallet.
+
+use crate::{Config, CreditOf, Event, Pallet};
+use codec::{Decode, Encode, MaxEncodedLen};
+use core::ops::BitOr;
+use frame_support::traits::{Imbalance, LockIdentifier, OnUnbalanced, WithdrawReasons};
+use scale_info::TypeInfo;
+use sp_runtime::{RuntimeDebug, Saturating};
+
+/// Simplified reasons for withdrawing balance.
+#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub enum Reasons {
+	/// Paying system transaction fees.
+	Fee = 0,
+	/// Any reason other than paying system transaction fees.
+	Misc = 1,
+	/// Any reason at all.
+	All = 2,
+}
+
+impl From<WithdrawReasons> for Reasons {
+	fn from(r: WithdrawReasons) -> Reasons {
+		if r == WithdrawReasons::TRANSACTION_PAYMENT {
+			Reasons::Fee
+		} else if r.contains(WithdrawReasons::TRANSACTION_PAYMENT) {
+			Reasons::All
+		} else {
+			Reasons::Misc
+		}
+	}
+}
+
+impl BitOr for Reasons {
+	type Output = Reasons;
+	fn bitor(self, other: Reasons) -> Reasons {
+		if self == other {
+			return self
+		}
+		Reasons::All
+	}
+}
+
+/// A single lock on a balance. There can be many of these on an account and they "overlap", so the
+/// same balance is frozen by multiple locks.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct BalanceLock<Balance> {
+	/// An identifier for this lock. Only one lock may be in existence for each identifier.
+	pub id: LockIdentifier,
+	/// The amount which the free balance may not drop below when this lock is in effect.
+	pub amount: Balance,
+	/// If true, then the lock remains in effect even for payment of transaction fees.
+	pub reasons: Reasons,
+}
+
+/// Store named reserved balance.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct ReserveData<ReserveIdentifier, Balance> {
+	/// The identifier for the named reserve.
+	pub id: ReserveIdentifier,
+	/// The amount of the named reserve.
+	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> {
+	/// Non-reserved part of the balance which the account holder may be able to control.
+	///
+	/// This is the only balance that matters in terms of most operations on tokens.
+	pub free: Balance,
+	/// Balance which is has active holds on it and may not be used at all.
+	///
+	/// This is the sum of all individual holds together with any sums still under the (deprecated)
+	/// reserves API.
+	pub reserved: Balance,
+	/// The amount that `free + reserved` may not drop below when reducing the balance, except for
+	/// actions where the account owner cannot reasonably benefit from the balance reduction, such
+	/// as slashing.
+	pub frozen: Balance,
+	/// Extra information about this account. The MSB is a flag indicating whether the new ref-
+	/// counting logic is in place for this account.
+	pub flags: ExtraFlags,
+}
+
+const IS_NEW_LOGIC: u128 = 0x80000000_00000000_00000000_00000000u128;
+
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct ExtraFlags(u128);
+impl Default for ExtraFlags {
+	fn default() -> Self {
+		Self(IS_NEW_LOGIC)
+	}
+}
+impl ExtraFlags {
+	pub fn old_logic() -> Self {
+		Self(0)
+	}
+	pub fn set_new_logic(&mut self) {
+		self.0 = self.0 | IS_NEW_LOGIC
+	}
+	pub fn is_new_logic(&self) -> bool {
+		(self.0 & IS_NEW_LOGIC) == IS_NEW_LOGIC
+	}
+}
+
+impl<Balance: Saturating + Copy + Ord> AccountData<Balance> {
+	pub fn usable(&self) -> Balance {
+		self.free.saturating_sub(self.frozen)
+	}
+
+	/// The total balance in this account including any that is reserved and ignoring any frozen.
+	pub fn total(&self) -> Balance {
+		self.free.saturating_add(self.reserved)
+	}
+}
+
+pub struct DustCleaner<T: Config<I>, I: 'static = ()>(
+	pub(crate) Option<(T::AccountId, CreditOf<T, I>)>,
+);
+
+impl<T: Config<I>, I: 'static> Drop for DustCleaner<T, I> {
+	fn drop(&mut self) {
+		if let Some((who, dust)) = self.0.take() {
+			Pallet::<T, I>::deposit_event(Event::DustLost { account: who, amount: dust.peek() });
+			T::DustRemoval::on_unbalanced(dust);
+		}
+	}
+}
diff --git a/substrate/frame/balances/src/weights.rs b/substrate/frame/balances/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5671374948cdfbd4cd6596dd84726f096598eb5f
--- /dev/null
+++ b/substrate/frame/balances/src/weights.rs
@@ -0,0 +1,253 @@
+// 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.
+
+//! Autogenerated weights for pallet_balances
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-07-14, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-o7yfgx5n-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: ``, WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
+
+// Executed Command:
+// target/production/substrate
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_balances
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/balances/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_balances.
+pub trait WeightInfo {
+	fn transfer_allow_death() -> Weight;
+	fn transfer_keep_alive() -> Weight;
+	fn force_set_balance_creating() -> Weight;
+	fn force_set_balance_killing() -> Weight;
+	fn force_transfer() -> Weight;
+	fn transfer_all() -> Weight;
+	fn force_unreserve() -> Weight;
+	fn upgrade_accounts(u: u32, ) -> Weight;
+}
+
+/// Weights for pallet_balances using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_allow_death() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 58_474_000 picoseconds.
+		Weight::from_parts(59_117_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_keep_alive() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 44_629_000 picoseconds.
+		Weight::from_parts(45_798_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_set_balance_creating() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 16_483_000 picoseconds.
+		Weight::from_parts(16_939_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_set_balance_killing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 24_638_000 picoseconds.
+		Weight::from_parts(25_487_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `6196`
+		// Minimum execution time: 60_041_000 picoseconds.
+		Weight::from_parts(63_365_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_all() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 54_445_000 picoseconds.
+		Weight::from_parts(55_623_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_unreserve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 19_309_000 picoseconds.
+		Weight::from_parts(19_953_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:999 w:999)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `u` is `[1, 1000]`.
+	fn upgrade_accounts(u: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + u * (135 ±0)`
+		//  Estimated: `990 + u * (2603 ±0)`
+		// Minimum execution time: 19_362_000 picoseconds.
+		Weight::from_parts(19_612_000, 990)
+			// Standard Error: 13_108
+			.saturating_add(Weight::from_parts(16_444_591, 0).saturating_mul(u.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(u.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(u.into())))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(u.into()))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_allow_death() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 58_474_000 picoseconds.
+		Weight::from_parts(59_117_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_keep_alive() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 44_629_000 picoseconds.
+		Weight::from_parts(45_798_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_set_balance_creating() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 16_483_000 picoseconds.
+		Weight::from_parts(16_939_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_set_balance_killing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 24_638_000 picoseconds.
+		Weight::from_parts(25_487_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:2 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `6196`
+		// Minimum execution time: 60_041_000 picoseconds.
+		Weight::from_parts(63_365_000, 6196)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn transfer_all() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `3593`
+		// Minimum execution time: 54_445_000 picoseconds.
+		Weight::from_parts(55_623_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn force_unreserve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 19_309_000 picoseconds.
+		Weight::from_parts(19_953_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `System::Account` (r:999 w:999)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `u` is `[1, 1000]`.
+	fn upgrade_accounts(u: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + u * (135 ±0)`
+		//  Estimated: `990 + u * (2603 ±0)`
+		// Minimum execution time: 19_362_000 picoseconds.
+		Weight::from_parts(19_612_000, 990)
+			// Standard Error: 13_108
+			.saturating_add(Weight::from_parts(16_444_591, 0).saturating_mul(u.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(u.into())))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(u.into())))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(u.into()))
+	}
+}
diff --git a/substrate/frame/beefy-mmr/Cargo.toml b/substrate/frame/beefy-mmr/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..af3ecf4d03b9abdcace52e84a81401a59ff740bb
--- /dev/null
+++ b/substrate/frame/beefy-mmr/Cargo.toml
@@ -0,0 +1,65 @@
+[package]
+name = "pallet-beefy-mmr"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+description = "BEEFY + MMR runtime utilities"
+repository = "https://github.com/paritytech/substrate"
+homepage = "https://substrate.io"
+
+[dependencies]
+array-bytes = { version = "6.1", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+binary-merkle-tree = { version = "4.0.0-dev", default-features = false, path = "../../utils/binary-merkle-tree" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-beefy = { version = "4.0.0-dev", default-features = false, path = "../beefy" }
+pallet-mmr = { version = "4.0.0-dev", default-features = false, path = "../merkle-mountain-range" }
+pallet-session = { version = "4.0.0-dev", default-features = false, path = "../session" }
+sp-consensus-beefy = { version = "4.0.0-dev", default-features = false, path = "../../primitives/consensus/beefy" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-state-machine = { version = "0.28.0", default-features = false, path = "../../primitives/state-machine" }
+
+[dev-dependencies]
+array-bytes = "6.1"
+sp-staking = { version = "4.0.0-dev", path = "../../primitives/staking" }
+
+[features]
+default = [ "std" ]
+std = [
+	"array-bytes",
+	"binary-merkle-tree/std",
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-beefy/std",
+	"pallet-mmr/std",
+	"pallet-session/std",
+	"scale-info/std",
+	"serde",
+	"sp-api/std",
+	"sp-consensus-beefy/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-beefy/try-runtime",
+	"pallet-mmr/try-runtime",
+	"pallet-session/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/beefy-mmr/src/lib.rs b/substrate/frame/beefy-mmr/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b12eb95f650f7b65771ba5fa7482d802f848cddd
--- /dev/null
+++ b/substrate/frame/beefy-mmr/src/lib.rs
@@ -0,0 +1,224 @@
+// 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)]
+#![warn(missing_docs)]
+
+//! A BEEFY+MMR pallet combo.
+//!
+//! While both BEEFY and Merkle Mountain Range (MMR) can be used separately,
+//! these tools were designed to work together in unison.
+//!
+//! The pallet provides a standardized MMR Leaf format that can be used
+//! to bridge BEEFY+MMR-based networks (both standalone and Polkadot-like).
+//!
+//! The MMR leaf contains:
+//! 1. Block number and parent block hash.
+//! 2. Merkle Tree Root Hash of next BEEFY validator set.
+//! 3. Arbitrary extra leaf data to be used by downstream pallets to include custom data.
+//!
+//! and thanks to versioning can be easily updated in the future.
+
+use sp_runtime::traits::{Convert, Member};
+use sp_std::prelude::*;
+
+use pallet_mmr::{LeafDataProvider, ParentNumberAndHash};
+use sp_consensus_beefy::{
+	mmr::{BeefyAuthoritySet, BeefyDataProvider, BeefyNextAuthoritySet, MmrLeaf, MmrLeafVersion},
+	ValidatorSet as BeefyValidatorSet,
+};
+
+use frame_support::{crypto::ecdsa::ECDSAExt, traits::Get};
+use frame_system::pallet_prelude::BlockNumberFor;
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+/// A BEEFY consensus digest item with MMR root hash.
+pub struct DepositBeefyDigest<T>(sp_std::marker::PhantomData<T>);
+
+impl<T> pallet_mmr::primitives::OnNewRoot<sp_consensus_beefy::MmrRootHash> for DepositBeefyDigest<T>
+where
+	T: pallet_mmr::Config<Hashing = sp_consensus_beefy::MmrHashing>,
+	T: pallet_beefy::Config,
+{
+	fn on_new_root(root: &sp_consensus_beefy::MmrRootHash) {
+		let digest = sp_runtime::generic::DigestItem::Consensus(
+			sp_consensus_beefy::BEEFY_ENGINE_ID,
+			codec::Encode::encode(&sp_consensus_beefy::ConsensusLog::<
+				<T as pallet_beefy::Config>::BeefyId,
+			>::MmrRoot(*root)),
+		);
+		<frame_system::Pallet<T>>::deposit_log(digest);
+	}
+}
+
+/// Convert BEEFY secp256k1 public keys into Ethereum addresses
+pub struct BeefyEcdsaToEthereum;
+impl Convert<sp_consensus_beefy::ecdsa_crypto::AuthorityId, Vec<u8>> for BeefyEcdsaToEthereum {
+	fn convert(beefy_id: sp_consensus_beefy::ecdsa_crypto::AuthorityId) -> Vec<u8> {
+		sp_core::ecdsa::Public::from(beefy_id)
+			.to_eth_address()
+			.map(|v| v.to_vec())
+			.map_err(|_| {
+				log::error!(target: "runtime::beefy", "Failed to convert BEEFY PublicKey to ETH address!");
+			})
+			.unwrap_or_default()
+	}
+}
+
+type MerkleRootOf<T> = <<T as pallet_mmr::Config>::Hashing as sp_runtime::traits::Hash>::Output;
+
+#[frame_support::pallet]
+pub mod pallet {
+	#![allow(missing_docs)]
+
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	/// BEEFY-MMR pallet.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// The module's configuration trait.
+	#[pallet::config]
+	#[pallet::disable_frame_system_supertrait_check]
+	pub trait Config: pallet_mmr::Config + pallet_beefy::Config {
+		/// Current leaf version.
+		///
+		/// Specifies the version number added to every leaf that get's appended to the MMR.
+		/// Read more in [`MmrLeafVersion`] docs about versioning leaves.
+		type LeafVersion: Get<MmrLeafVersion>;
+
+		/// Convert BEEFY AuthorityId to a form that would end up in the Merkle Tree.
+		///
+		/// For instance for ECDSA (secp256k1) we want to store uncompressed public keys (65 bytes)
+		/// and later to Ethereum Addresses (160 bits) to simplify using them on Ethereum chain,
+		/// but the rest of the Substrate codebase is storing them compressed (33 bytes) for
+		/// efficiency reasons.
+		type BeefyAuthorityToMerkleLeaf: Convert<<Self as pallet_beefy::Config>::BeefyId, Vec<u8>>;
+
+		/// The type expected for the leaf extra data
+		type LeafExtra: Member + codec::FullCodec;
+
+		/// Retrieve arbitrary data that should be added to the mmr leaf
+		type BeefyDataProvider: BeefyDataProvider<Self::LeafExtra>;
+	}
+
+	/// Details of current BEEFY authority set.
+	#[pallet::storage]
+	#[pallet::getter(fn beefy_authorities)]
+	pub type BeefyAuthorities<T: Config> =
+		StorageValue<_, BeefyAuthoritySet<MerkleRootOf<T>>, ValueQuery>;
+
+	/// Details of next BEEFY authority set.
+	///
+	/// This storage entry is used as cache for calls to `update_beefy_next_authority_set`.
+	#[pallet::storage]
+	#[pallet::getter(fn beefy_next_authorities)]
+	pub type BeefyNextAuthorities<T: Config> =
+		StorageValue<_, BeefyNextAuthoritySet<MerkleRootOf<T>>, ValueQuery>;
+}
+
+impl<T: Config> LeafDataProvider for Pallet<T> {
+	type LeafData = MmrLeaf<
+		BlockNumberFor<T>,
+		<T as frame_system::Config>::Hash,
+		MerkleRootOf<T>,
+		T::LeafExtra,
+	>;
+
+	fn leaf_data() -> Self::LeafData {
+		MmrLeaf {
+			version: T::LeafVersion::get(),
+			parent_number_and_hash: ParentNumberAndHash::<T>::leaf_data(),
+			leaf_extra: T::BeefyDataProvider::extra_data(),
+			beefy_next_authority_set: Pallet::<T>::beefy_next_authorities(),
+		}
+	}
+}
+
+impl<T> sp_consensus_beefy::OnNewValidatorSet<<T as pallet_beefy::Config>::BeefyId> for Pallet<T>
+where
+	T: pallet::Config,
+{
+	/// Compute and cache BEEFY authority sets based on updated BEEFY validator sets.
+	fn on_new_validator_set(
+		current_set: &BeefyValidatorSet<<T as pallet_beefy::Config>::BeefyId>,
+		next_set: &BeefyValidatorSet<<T as pallet_beefy::Config>::BeefyId>,
+	) {
+		let current = Pallet::<T>::compute_authority_set(current_set);
+		let next = Pallet::<T>::compute_authority_set(next_set);
+		// cache the result
+		BeefyAuthorities::<T>::put(&current);
+		BeefyNextAuthorities::<T>::put(&next);
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Return the currently active BEEFY authority set proof.
+	pub fn authority_set_proof() -> BeefyAuthoritySet<MerkleRootOf<T>> {
+		Pallet::<T>::beefy_authorities()
+	}
+
+	/// Return the next/queued BEEFY authority set proof.
+	pub fn next_authority_set_proof() -> BeefyNextAuthoritySet<MerkleRootOf<T>> {
+		Pallet::<T>::beefy_next_authorities()
+	}
+
+	/// Returns details of a BEEFY authority set.
+	///
+	/// Details contain authority set id, authority set length and a merkle root,
+	/// constructed from uncompressed secp256k1 public keys converted to Ethereum addresses
+	/// of the next BEEFY authority set.
+	fn compute_authority_set(
+		validator_set: &BeefyValidatorSet<<T as pallet_beefy::Config>::BeefyId>,
+	) -> BeefyAuthoritySet<MerkleRootOf<T>> {
+		let id = validator_set.id();
+		let beefy_addresses = validator_set
+			.validators()
+			.into_iter()
+			.cloned()
+			.map(T::BeefyAuthorityToMerkleLeaf::convert)
+			.collect::<Vec<_>>();
+		let len = beefy_addresses.len() as u32;
+		let keyset_commitment = binary_merkle_tree::merkle_root::<
+			<T as pallet_mmr::Config>::Hashing,
+			_,
+		>(beefy_addresses)
+		.into();
+		BeefyAuthoritySet { id, len, keyset_commitment }
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// API useful for BEEFY light clients.
+	pub trait BeefyMmrApi<H>
+	where
+		BeefyAuthoritySet<H>: sp_api::Decode,
+	{
+		/// Return the currently active BEEFY authority set proof.
+		fn authority_set_proof() -> BeefyAuthoritySet<H>;
+
+		/// Return the next/queued BEEFY authority set proof.
+		fn next_authority_set_proof() -> BeefyNextAuthoritySet<H>;
+	}
+}
diff --git a/substrate/frame/beefy-mmr/src/mock.rs b/substrate/frame/beefy-mmr/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b2d8758a04be6f74236d60488760292d1ac87ca8
--- /dev/null
+++ b/substrate/frame/beefy-mmr/src/mock.rs
@@ -0,0 +1,211 @@
+// 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 std::vec;
+
+use codec::Encode;
+use frame_support::{
+	construct_runtime, parameter_types,
+	traits::{ConstU16, ConstU32, ConstU64},
+};
+use sp_consensus_beefy::mmr::MmrLeafVersion;
+use sp_core::H256;
+use sp_io::TestExternalities;
+use sp_runtime::{
+	app_crypto::ecdsa::Public,
+	impl_opaque_keys,
+	traits::{BlakeTwo256, ConvertInto, IdentityLookup, Keccak256, OpaqueKeys},
+	BuildStorage,
+};
+use sp_state_machine::BasicExternalities;
+
+use crate as pallet_beefy_mmr;
+
+pub use sp_consensus_beefy::{
+	ecdsa_crypto::AuthorityId as BeefyId, mmr::BeefyDataProvider, ConsensusLog, BEEFY_ENGINE_ID,
+};
+
+impl_opaque_keys! {
+	pub struct MockSessionKeys {
+		pub dummy: pallet_beefy::Pallet<Test>,
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+		Mmr: pallet_mmr::{Pallet, Storage},
+		Beefy: pallet_beefy::{Pallet, Config<T>, Storage},
+		BeefyMmr: pallet_beefy_mmr::{Pallet, Storage},
+	}
+);
+
+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 = 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 = ConstU32<16>;
+}
+
+impl pallet_session::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = u64;
+	type ValidatorIdOf = ConvertInto;
+	type ShouldEndSession = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+	type SessionManager = MockSessionManager;
+	type SessionHandler = <MockSessionKeys as OpaqueKeys>::KeyTypeIdProviders;
+	type Keys = MockSessionKeys;
+	type WeightInfo = ();
+}
+
+pub type MmrLeaf = sp_consensus_beefy::mmr::MmrLeaf<
+	frame_system::pallet_prelude::BlockNumberFor<Test>,
+	<Test as frame_system::Config>::Hash,
+	crate::MerkleRootOf<Test>,
+	Vec<u8>,
+>;
+
+impl pallet_mmr::Config for Test {
+	const INDEXING_PREFIX: &'static [u8] = b"mmr";
+
+	type Hashing = Keccak256;
+
+	type LeafData = BeefyMmr;
+
+	type OnNewRoot = pallet_beefy_mmr::DepositBeefyDigest<Test>;
+
+	type WeightInfo = ();
+}
+
+impl pallet_beefy::Config for Test {
+	type BeefyId = BeefyId;
+	type MaxAuthorities = ConstU32<100>;
+	type MaxNominators = ConstU32<1000>;
+	type MaxSetIdSessionEntries = ConstU64<100>;
+	type OnNewValidatorSet = BeefyMmr;
+	type WeightInfo = ();
+	type KeyOwnerProof = sp_core::Void;
+	type EquivocationReportSystem = ();
+}
+
+parameter_types! {
+	pub LeafVersion: MmrLeafVersion = MmrLeafVersion::new(1, 5);
+}
+
+impl pallet_beefy_mmr::Config for Test {
+	type LeafVersion = LeafVersion;
+
+	type BeefyAuthorityToMerkleLeaf = pallet_beefy_mmr::BeefyEcdsaToEthereum;
+
+	type LeafExtra = Vec<u8>;
+
+	type BeefyDataProvider = DummyDataProvider;
+}
+
+pub struct DummyDataProvider;
+impl BeefyDataProvider<Vec<u8>> for DummyDataProvider {
+	fn extra_data() -> Vec<u8> {
+		let mut col = vec![(15, vec![1, 2, 3]), (5, vec![4, 5, 6])];
+		col.sort();
+		binary_merkle_tree::merkle_root::<<Test as pallet_mmr::Config>::Hashing, _>(
+			col.into_iter().map(|pair| pair.encode()),
+		)
+		.as_ref()
+		.to_vec()
+	}
+}
+
+pub struct MockSessionManager;
+impl pallet_session::SessionManager<u64> for MockSessionManager {
+	fn end_session(_: sp_staking::SessionIndex) {}
+	fn start_session(_: sp_staking::SessionIndex) {}
+	fn new_session(idx: sp_staking::SessionIndex) -> Option<Vec<u64>> {
+		if idx == 0 || idx == 1 {
+			Some(vec![1, 2])
+		} else if idx == 2 {
+			Some(vec![3, 4])
+		} else {
+			None
+		}
+	}
+}
+
+// Note, that we can't use `UintAuthorityId` here. Reason is that the implementation
+// of `to_public_key()` assumes, that a public key is 32 bytes long. This is true for
+// ed25519 and sr25519 but *not* for ecdsa. A compressed ecdsa public key is 33 bytes,
+// with the first one containing information to reconstruct the uncompressed key.
+pub fn mock_beefy_id(id: u8) -> BeefyId {
+	let mut buf: [u8; 33] = [id; 33];
+	// Set to something valid.
+	buf[0] = 0x02;
+	let pk = Public::from_raw(buf);
+	BeefyId::from(pk)
+}
+
+pub fn mock_authorities(vec: Vec<u8>) -> Vec<(u64, BeefyId)> {
+	vec.into_iter().map(|id| ((id as u64), mock_beefy_id(id))).collect()
+}
+
+pub fn new_test_ext(ids: Vec<u8>) -> TestExternalities {
+	new_test_ext_raw_authorities(mock_authorities(ids))
+}
+
+pub fn new_test_ext_raw_authorities(authorities: Vec<(u64, BeefyId)>) -> TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let session_keys: Vec<_> = authorities
+		.iter()
+		.enumerate()
+		.map(|(_, id)| (id.0 as u64, id.0 as u64, MockSessionKeys { dummy: id.1.clone() }))
+		.collect();
+
+	BasicExternalities::execute_with_storage(&mut t, || {
+		for (ref id, ..) in &session_keys {
+			frame_system::Pallet::<Test>::inc_providers(id);
+		}
+	});
+
+	pallet_session::GenesisConfig::<Test> { keys: session_keys }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	t.into()
+}
diff --git a/substrate/frame/beefy-mmr/src/tests.rs b/substrate/frame/beefy-mmr/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec756f83dffa41b51245dea38affc3dda8b871b5
--- /dev/null
+++ b/substrate/frame/beefy-mmr/src/tests.rs
@@ -0,0 +1,209 @@
+// 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 std::vec;
+
+use codec::{Decode, Encode};
+use sp_consensus_beefy::{
+	mmr::{BeefyNextAuthoritySet, MmrLeafVersion},
+	ValidatorSet,
+};
+
+use sp_core::H256;
+use sp_io::TestExternalities;
+use sp_runtime::{traits::Keccak256, DigestItem};
+
+use frame_support::traits::OnInitialize;
+
+use crate::mock::*;
+
+fn init_block(block: u64) {
+	System::set_block_number(block);
+	Session::on_initialize(block);
+	Mmr::on_initialize(block);
+	Beefy::on_initialize(block);
+	BeefyMmr::on_initialize(block);
+}
+
+pub fn beefy_log(log: ConsensusLog<BeefyId>) -> DigestItem {
+	DigestItem::Consensus(BEEFY_ENGINE_ID, log.encode())
+}
+
+fn read_mmr_leaf(ext: &mut TestExternalities, key: Vec<u8>) -> MmrLeaf {
+	type Node = pallet_mmr::primitives::DataOrHash<Keccak256, MmrLeaf>;
+	ext.persist_offchain_overlay();
+	let offchain_db = ext.offchain_db();
+	offchain_db
+		.get(&key)
+		.map(|d| Node::decode(&mut &*d).unwrap())
+		.map(|n| match n {
+			Node::Data(d) => d,
+			_ => panic!("Unexpected MMR node."),
+		})
+		.unwrap()
+}
+
+#[test]
+fn should_contain_mmr_digest() {
+	let mut ext = new_test_ext(vec![1, 2, 3, 4]);
+	ext.execute_with(|| {
+		init_block(1);
+
+		assert_eq!(
+			System::digest().logs,
+			vec![
+				beefy_log(ConsensusLog::AuthoritiesChange(
+					ValidatorSet::new(vec![mock_beefy_id(1), mock_beefy_id(2)], 1).unwrap()
+				)),
+				beefy_log(ConsensusLog::MmrRoot(array_bytes::hex_n_into_unchecked(
+					"95803defe6ea9f41e7ec6afa497064f21bfded027d8812efacbdf984e630cbdc"
+				)))
+			]
+		);
+
+		// unique every time
+		init_block(2);
+
+		assert_eq!(
+			System::digest().logs,
+			vec![
+				beefy_log(ConsensusLog::AuthoritiesChange(
+					ValidatorSet::new(vec![mock_beefy_id(1), mock_beefy_id(2)], 1).unwrap()
+				)),
+				beefy_log(ConsensusLog::MmrRoot(array_bytes::hex_n_into_unchecked(
+					"95803defe6ea9f41e7ec6afa497064f21bfded027d8812efacbdf984e630cbdc"
+				))),
+				beefy_log(ConsensusLog::AuthoritiesChange(
+					ValidatorSet::new(vec![mock_beefy_id(3), mock_beefy_id(4)], 2).unwrap()
+				)),
+				beefy_log(ConsensusLog::MmrRoot(array_bytes::hex_n_into_unchecked(
+					"a73271a0974f1e67d6e9b8dd58e506177a2e556519a330796721e98279a753e2"
+				))),
+			]
+		);
+	});
+}
+
+#[test]
+fn should_contain_valid_leaf_data() {
+	fn node_offchain_key(pos: usize, parent_hash: H256) -> Vec<u8> {
+		(<Test as pallet_mmr::Config>::INDEXING_PREFIX, pos as u64, parent_hash).encode()
+	}
+
+	let mut ext = new_test_ext(vec![1, 2, 3, 4]);
+	let parent_hash = ext.execute_with(|| {
+		init_block(1);
+		<frame_system::Pallet<Test>>::parent_hash()
+	});
+
+	let mmr_leaf = read_mmr_leaf(&mut ext, node_offchain_key(0, parent_hash));
+	assert_eq!(
+		mmr_leaf,
+		MmrLeaf {
+			version: MmrLeafVersion::new(1, 5),
+			parent_number_and_hash: (0_u64, H256::repeat_byte(0x45)),
+			beefy_next_authority_set: BeefyNextAuthoritySet {
+				id: 2,
+				len: 2,
+				keyset_commitment: array_bytes::hex_n_into_unchecked(
+					"9c6b2c1b0d0b25a008e6c882cc7b415f309965c72ad2b944ac0931048ca31cd5"
+				)
+			},
+			leaf_extra: array_bytes::hex2bytes_unchecked(
+				"55b8e9e1cc9f0db7776fac0ca66318ef8acfb8ec26db11e373120583e07ee648"
+			)
+		}
+	);
+
+	// build second block on top
+	let parent_hash = ext.execute_with(|| {
+		init_block(2);
+		<frame_system::Pallet<Test>>::parent_hash()
+	});
+
+	let mmr_leaf = read_mmr_leaf(&mut ext, node_offchain_key(1, parent_hash));
+	assert_eq!(
+		mmr_leaf,
+		MmrLeaf {
+			version: MmrLeafVersion::new(1, 5),
+			parent_number_and_hash: (1_u64, H256::repeat_byte(0x45)),
+			beefy_next_authority_set: BeefyNextAuthoritySet {
+				id: 3,
+				len: 2,
+				keyset_commitment: array_bytes::hex_n_into_unchecked(
+					"9c6b2c1b0d0b25a008e6c882cc7b415f309965c72ad2b944ac0931048ca31cd5"
+				)
+			},
+			leaf_extra: array_bytes::hex2bytes_unchecked(
+				"55b8e9e1cc9f0db7776fac0ca66318ef8acfb8ec26db11e373120583e07ee648"
+			)
+		}
+	);
+}
+
+#[test]
+fn should_update_authorities() {
+	new_test_ext(vec![1, 2, 3, 4]).execute_with(|| {
+		let auth_set = BeefyMmr::authority_set_proof();
+		let next_auth_set = BeefyMmr::next_authority_set_proof();
+
+		// check current authority set
+		assert_eq!(0, auth_set.id);
+		assert_eq!(2, auth_set.len);
+		let want = array_bytes::hex_n_into_unchecked::<_, H256, 32>(
+			"176e73f1bf656478b728e28dd1a7733c98621b8acf830bff585949763dca7a96",
+		);
+		assert_eq!(want, auth_set.keyset_commitment);
+
+		// next authority set should have same validators but different id
+		assert_eq!(1, next_auth_set.id);
+		assert_eq!(auth_set.len, next_auth_set.len);
+		assert_eq!(auth_set.keyset_commitment, next_auth_set.keyset_commitment);
+
+		let announced_set = next_auth_set;
+		init_block(1);
+		let auth_set = BeefyMmr::authority_set_proof();
+		let next_auth_set = BeefyMmr::next_authority_set_proof();
+
+		// check new auth are expected ones
+		assert_eq!(announced_set, auth_set);
+		assert_eq!(1, auth_set.id);
+		// check next auth set
+		assert_eq!(2, next_auth_set.id);
+		let want = array_bytes::hex_n_into_unchecked::<_, H256, 32>(
+			"9c6b2c1b0d0b25a008e6c882cc7b415f309965c72ad2b944ac0931048ca31cd5",
+		);
+		assert_eq!(2, next_auth_set.len);
+		assert_eq!(want, next_auth_set.keyset_commitment);
+
+		let announced_set = next_auth_set;
+		init_block(2);
+		let auth_set = BeefyMmr::authority_set_proof();
+		let next_auth_set = BeefyMmr::next_authority_set_proof();
+
+		// check new auth are expected ones
+		assert_eq!(announced_set, auth_set);
+		assert_eq!(2, auth_set.id);
+		// check next auth set
+		assert_eq!(3, next_auth_set.id);
+		let want = array_bytes::hex_n_into_unchecked::<_, H256, 32>(
+			"9c6b2c1b0d0b25a008e6c882cc7b415f309965c72ad2b944ac0931048ca31cd5",
+		);
+		assert_eq!(2, next_auth_set.len);
+		assert_eq!(want, next_auth_set.keyset_commitment);
+	});
+}
diff --git a/substrate/frame/beefy/Cargo.toml b/substrate/frame/beefy/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7196d8b7d55b197e2982d83198466160a8f3734c
--- /dev/null
+++ b/substrate/frame/beefy/Cargo.toml
@@ -0,0 +1,74 @@
+[package]
+name = "pallet-beefy"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/paritytech/substrate"
+description = "BEEFY FRAME pallet"
+homepage = "https://substrate.io"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+serde = { version = "1.0.163", optional = true }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-authorship = { version = "4.0.0-dev", default-features = false, path = "../authorship" }
+pallet-session = { version = "4.0.0-dev", default-features = false, path = "../session" }
+sp-consensus-beefy = { version = "4.0.0-dev", default-features = false, path = "../../primitives/consensus/beefy", features = ["serde"] }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../primitives/session" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-offences = { version = "4.0.0-dev", path = "../offences" }
+pallet-staking = { version = "4.0.0-dev", path = "../staking" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../staking/reward-curve" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../timestamp" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-staking = { version = "4.0.0-dev", path = "../../primitives/staking" }
+sp-state-machine = { version = "0.28.0", default-features = false, path = "../../primitives/state-machine" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-authorship/std",
+	"pallet-balances/std",
+	"pallet-offences/std",
+	"pallet-session/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-consensus-beefy/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-staking/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-authorship/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-offences/try-runtime",
+	"pallet-session/try-runtime",
+	"pallet-staking/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/beefy/src/default_weights.rs b/substrate/frame/beefy/src/default_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..091d58f47f97888b43259bcb62c44905fae568e3
--- /dev/null
+++ b/substrate/frame/beefy/src/default_weights.rs
@@ -0,0 +1,52 @@
+// 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.
+
+//! Default weights for the BEEFY Pallet
+//! This file was not auto-generated.
+
+use frame_support::weights::{
+	constants::{RocksDbWeight as DbWeight, WEIGHT_REF_TIME_PER_MICROS, WEIGHT_REF_TIME_PER_NANOS},
+	Weight,
+};
+
+impl crate::WeightInfo for () {
+	fn report_equivocation(validator_count: u32, max_nominators_per_validator: u32) -> Weight {
+		// we take the validator set count from the membership proof to
+		// calculate the weight but we set a floor of 100 validators.
+		let validator_count = validator_count.max(100) as u64;
+
+		// checking membership proof
+		Weight::from_parts(35u64 * WEIGHT_REF_TIME_PER_MICROS, 0)
+			.saturating_add(
+				Weight::from_parts(175u64 * WEIGHT_REF_TIME_PER_NANOS, 0)
+					.saturating_mul(validator_count),
+			)
+			.saturating_add(DbWeight::get().reads(5))
+			// check equivocation proof
+			.saturating_add(Weight::from_parts(95u64 * WEIGHT_REF_TIME_PER_MICROS, 0))
+			// report offence
+			.saturating_add(Weight::from_parts(110u64 * WEIGHT_REF_TIME_PER_MICROS, 0))
+			.saturating_add(Weight::from_parts(
+				25u64 * WEIGHT_REF_TIME_PER_MICROS * max_nominators_per_validator as u64,
+				0,
+			))
+			.saturating_add(DbWeight::get().reads(14 + 3 * max_nominators_per_validator as u64))
+			.saturating_add(DbWeight::get().writes(10 + 3 * max_nominators_per_validator as u64))
+			// fetching set id -> session index mappings
+			.saturating_add(DbWeight::get().reads(2))
+	}
+}
diff --git a/substrate/frame/beefy/src/equivocation.rs b/substrate/frame/beefy/src/equivocation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0a7ede327c9e672a6b455f724c6ed9852df21984
--- /dev/null
+++ b/substrate/frame/beefy/src/equivocation.rs
@@ -0,0 +1,287 @@
+// 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.
+
+//! An opt-in utility module for reporting equivocations.
+//!
+//! This module defines an offence type for BEEFY equivocations
+//! and some utility traits to wire together:
+//! - a key ownership proof system (e.g. to prove that a given authority was part of a session);
+//! - a system for reporting offences;
+//! - a system for signing and submitting transactions;
+//! - a way to get the current block author;
+//!
+//! These can be used in an offchain context in order to submit equivocation
+//! reporting extrinsics (from the client that's running the BEEFY protocol).
+//! And in a runtime context, so that the BEEFY pallet can validate the
+//! equivocation proofs in the extrinsic and report the offences.
+//!
+//! IMPORTANT:
+//! When using this module for enabling equivocation reporting it is required
+//! that the `ValidateUnsigned` for the BEEFY pallet is used in the runtime
+//! definition.
+
+use codec::{self as codec, Decode, Encode};
+use frame_support::traits::{Get, KeyOwnerProofSystem};
+use frame_system::pallet_prelude::BlockNumberFor;
+use log::{error, info};
+use sp_consensus_beefy::{EquivocationProof, ValidatorSetId, KEY_TYPE as BEEFY_KEY_TYPE};
+use sp_runtime::{
+	transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
+		TransactionValidityError, ValidTransaction,
+	},
+	DispatchError, KeyTypeId, Perbill, RuntimeAppPublic,
+};
+use sp_session::{GetSessionNumber, GetValidatorCount};
+use sp_staking::{
+	offence::{Kind, Offence, OffenceReportSystem, ReportOffence},
+	SessionIndex,
+};
+use sp_std::prelude::*;
+
+use super::{Call, Config, Error, Pallet, LOG_TARGET};
+
+/// A round number and set id which point on the time of an offence.
+#[derive(Copy, Clone, PartialOrd, Ord, Eq, PartialEq, Encode, Decode)]
+pub struct TimeSlot<N: Copy + Clone + PartialOrd + Ord + Eq + PartialEq + Encode + Decode> {
+	// The order of these matters for `derive(Ord)`.
+	/// BEEFY Set ID.
+	pub set_id: ValidatorSetId,
+	/// Round number.
+	pub round: N,
+}
+
+/// BEEFY equivocation offence report.
+pub struct EquivocationOffence<Offender, N>
+where
+	N: Copy + Clone + PartialOrd + Ord + Eq + PartialEq + Encode + Decode,
+{
+	/// Time slot at which this incident happened.
+	pub time_slot: TimeSlot<N>,
+	/// The session index in which the incident happened.
+	pub session_index: SessionIndex,
+	/// The size of the validator set at the time of the offence.
+	pub validator_set_count: u32,
+	/// The authority which produced this equivocation.
+	pub offender: Offender,
+}
+
+impl<Offender: Clone, N> Offence<Offender> for EquivocationOffence<Offender, N>
+where
+	N: Copy + Clone + PartialOrd + Ord + Eq + PartialEq + Encode + Decode,
+{
+	const ID: Kind = *b"beefy:equivocati";
+	type TimeSlot = TimeSlot<N>;
+
+	fn offenders(&self) -> Vec<Offender> {
+		vec![self.offender.clone()]
+	}
+
+	fn session_index(&self) -> SessionIndex {
+		self.session_index
+	}
+
+	fn validator_set_count(&self) -> u32 {
+		self.validator_set_count
+	}
+
+	fn time_slot(&self) -> Self::TimeSlot {
+		self.time_slot
+	}
+
+	// The formula is min((3k / n)^2, 1)
+	// where k = offenders_number and n = validators_number
+	fn slash_fraction(&self, offenders_count: u32) -> Perbill {
+		// Perbill type domain is [0, 1] by definition
+		Perbill::from_rational(3 * offenders_count, self.validator_set_count).square()
+	}
+}
+
+/// BEEFY equivocation offence report system.
+///
+/// This type implements `OffenceReportSystem` such that:
+/// - Equivocation reports are published on-chain as unsigned extrinsic via
+///   `offchain::SendTransactionTypes`.
+/// - On-chain validity checks and processing are mostly delegated to the user provided generic
+///   types implementing `KeyOwnerProofSystem` and `ReportOffence` traits.
+/// - Offence reporter for unsigned transactions is fetched via the the authorship pallet.
+pub struct EquivocationReportSystem<T, R, P, L>(sp_std::marker::PhantomData<(T, R, P, L)>);
+
+/// Equivocation evidence convenience alias.
+pub type EquivocationEvidenceFor<T> = (
+	EquivocationProof<
+		BlockNumberFor<T>,
+		<T as Config>::BeefyId,
+		<<T as Config>::BeefyId as RuntimeAppPublic>::Signature,
+	>,
+	<T as Config>::KeyOwnerProof,
+);
+
+impl<T, R, P, L> OffenceReportSystem<Option<T::AccountId>, EquivocationEvidenceFor<T>>
+	for EquivocationReportSystem<T, R, P, L>
+where
+	T: Config + pallet_authorship::Config + frame_system::offchain::SendTransactionTypes<Call<T>>,
+	R: ReportOffence<
+		T::AccountId,
+		P::IdentificationTuple,
+		EquivocationOffence<P::IdentificationTuple, BlockNumberFor<T>>,
+	>,
+	P: KeyOwnerProofSystem<(KeyTypeId, T::BeefyId), Proof = T::KeyOwnerProof>,
+	P::IdentificationTuple: Clone,
+	L: Get<u64>,
+{
+	type Longevity = L;
+
+	fn publish_evidence(evidence: EquivocationEvidenceFor<T>) -> Result<(), ()> {
+		use frame_system::offchain::SubmitTransaction;
+		let (equivocation_proof, key_owner_proof) = evidence;
+
+		let call = Call::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof),
+			key_owner_proof,
+		};
+
+		let res = SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into());
+		match res {
+			Ok(_) => info!(target: LOG_TARGET, "Submitted equivocation report."),
+			Err(e) => error!(target: LOG_TARGET, "Error submitting equivocation report: {:?}", e),
+		}
+		res
+	}
+
+	fn check_evidence(
+		evidence: EquivocationEvidenceFor<T>,
+	) -> Result<(), TransactionValidityError> {
+		let (equivocation_proof, key_owner_proof) = evidence;
+
+		// Check the membership proof to extract the offender's id
+		let key = (BEEFY_KEY_TYPE, equivocation_proof.offender_id().clone());
+		let offender = P::check_proof(key, key_owner_proof).ok_or(InvalidTransaction::BadProof)?;
+
+		// Check if the offence has already been reported, and if so then we can discard the report.
+		let time_slot = TimeSlot {
+			set_id: equivocation_proof.set_id(),
+			round: *equivocation_proof.round_number(),
+		};
+
+		if R::is_known_offence(&[offender], &time_slot) {
+			Err(InvalidTransaction::Stale.into())
+		} else {
+			Ok(())
+		}
+	}
+
+	fn process_evidence(
+		reporter: Option<T::AccountId>,
+		evidence: EquivocationEvidenceFor<T>,
+	) -> Result<(), DispatchError> {
+		let (equivocation_proof, key_owner_proof) = evidence;
+		let reporter = reporter.or_else(|| <pallet_authorship::Pallet<T>>::author());
+		let offender = equivocation_proof.offender_id().clone();
+
+		// We check the equivocation within the context of its set id (and
+		// associated session) and round. We also need to know the validator
+		// set count at the time of the offence since it is required to calculate
+		// the slash amount.
+		let set_id = equivocation_proof.set_id();
+		let round = *equivocation_proof.round_number();
+		let session_index = key_owner_proof.session();
+		let validator_set_count = key_owner_proof.validator_count();
+
+		// Validate the key ownership proof extracting the id of the offender.
+		let offender = P::check_proof((BEEFY_KEY_TYPE, offender), key_owner_proof)
+			.ok_or(Error::<T>::InvalidKeyOwnershipProof)?;
+
+		// Validate equivocation proof (check votes are different and signatures are valid).
+		if !sp_consensus_beefy::check_equivocation_proof(&equivocation_proof) {
+			return Err(Error::<T>::InvalidEquivocationProof.into())
+		}
+
+		// Check that the session id for the membership proof is within the
+		// bounds of the set id reported in the equivocation.
+		let set_id_session_index =
+			crate::SetIdSession::<T>::get(set_id).ok_or(Error::<T>::InvalidEquivocationProof)?;
+		if session_index != set_id_session_index {
+			return Err(Error::<T>::InvalidEquivocationProof.into())
+		}
+
+		let offence = EquivocationOffence {
+			time_slot: TimeSlot { set_id, round },
+			session_index,
+			validator_set_count,
+			offender,
+		};
+
+		R::report_offence(reporter.into_iter().collect(), offence)
+			.map_err(|_| Error::<T>::DuplicateOffenceReport)?;
+
+		Ok(())
+	}
+}
+
+/// Methods for the `ValidateUnsigned` implementation:
+/// It restricts calls to `report_equivocation_unsigned` to local calls (i.e. extrinsics generated
+/// on this node) or that already in a block. This guarantees that only block authors can include
+/// unsigned equivocation reports.
+impl<T: Config> Pallet<T> {
+	pub fn validate_unsigned(source: TransactionSource, call: &Call<T>) -> TransactionValidity {
+		if let Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } = call {
+			// discard equivocation report not coming from the local node
+			match source {
+				TransactionSource::Local | TransactionSource::InBlock => { /* allowed */ },
+				_ => {
+					log::warn!(
+						target: LOG_TARGET,
+						"rejecting unsigned report equivocation transaction because it is not local/in-block."
+					);
+					return InvalidTransaction::Call.into()
+				},
+			}
+
+			let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
+			T::EquivocationReportSystem::check_evidence(evidence)?;
+
+			let longevity =
+				<T::EquivocationReportSystem as OffenceReportSystem<_, _>>::Longevity::get();
+
+			ValidTransaction::with_tag_prefix("BeefyEquivocation")
+				// We assign the maximum priority for any equivocation report.
+				.priority(TransactionPriority::MAX)
+				// Only one equivocation report for the same offender at the same slot.
+				.and_provides((
+					equivocation_proof.offender_id().clone(),
+					equivocation_proof.set_id(),
+					*equivocation_proof.round_number(),
+				))
+				.longevity(longevity)
+				// We don't propagate this. This can never be included on a remote node.
+				.propagate(false)
+				.build()
+		} else {
+			InvalidTransaction::Call.into()
+		}
+	}
+
+	pub fn pre_dispatch(call: &Call<T>) -> Result<(), TransactionValidityError> {
+		if let Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } = call {
+			let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
+			T::EquivocationReportSystem::check_evidence(evidence)
+		} else {
+			Err(InvalidTransaction::Call.into())
+		}
+	}
+}
diff --git a/substrate/frame/beefy/src/lib.rs b/substrate/frame/beefy/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..77e74436dd6710416d7418f3dca2198dced68428
--- /dev/null
+++ b/substrate/frame/beefy/src/lib.rs
@@ -0,0 +1,455 @@
+// 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)]
+
+use codec::{Encode, MaxEncodedLen};
+
+use frame_support::{
+	dispatch::{DispatchResultWithPostInfo, Pays},
+	pallet_prelude::*,
+	traits::{Get, OneSessionHandler},
+	weights::Weight,
+	BoundedSlice, BoundedVec, Parameter,
+};
+use frame_system::{
+	ensure_none, ensure_signed,
+	pallet_prelude::{BlockNumberFor, OriginFor},
+};
+use log;
+use sp_runtime::{
+	generic::DigestItem,
+	traits::{IsMember, Member},
+	RuntimeAppPublic,
+};
+use sp_session::{GetSessionNumber, GetValidatorCount};
+use sp_staking::{offence::OffenceReportSystem, SessionIndex};
+use sp_std::prelude::*;
+
+use sp_consensus_beefy::{
+	AuthorityIndex, BeefyAuthorityId, ConsensusLog, EquivocationProof, OnNewValidatorSet,
+	ValidatorSet, BEEFY_ENGINE_ID, GENESIS_AUTHORITY_SET_ID,
+};
+
+mod default_weights;
+mod equivocation;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+pub use crate::equivocation::{EquivocationOffence, EquivocationReportSystem, TimeSlot};
+pub use pallet::*;
+
+use crate::equivocation::EquivocationEvidenceFor;
+
+const LOG_TARGET: &str = "runtime::beefy";
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Authority identifier type
+		type BeefyId: Member
+			+ Parameter
+			// todo: use custom signature hashing type instead of hardcoded `Keccak256`
+			+ BeefyAuthorityId<sp_runtime::traits::Keccak256>
+			+ MaybeSerializeDeserialize
+			+ MaxEncodedLen;
+
+		/// The maximum number of authorities that can be added.
+		#[pallet::constant]
+		type MaxAuthorities: Get<u32>;
+
+		/// The maximum number of nominators for each validator.
+		#[pallet::constant]
+		type MaxNominators: Get<u32>;
+
+		/// The maximum number of entries to keep in the set id to session index mapping.
+		///
+		/// Since the `SetIdSession` map is only used for validating equivocations this
+		/// value should relate to the bonding duration of whatever staking system is
+		/// being used (if any). If equivocation handling is not enabled then this value
+		/// can be zero.
+		#[pallet::constant]
+		type MaxSetIdSessionEntries: Get<u64>;
+
+		/// A hook to act on the new BEEFY validator set.
+		///
+		/// For some applications it might be beneficial to make the BEEFY validator set available
+		/// externally apart from having it in the storage. For instance you might cache a light
+		/// weight MMR root over validators and make it available for Light Clients.
+		type OnNewValidatorSet: OnNewValidatorSet<<Self as Config>::BeefyId>;
+
+		/// Weights for this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The proof of key ownership, used for validating equivocation reports
+		/// The proof must include the session index and validator count of the
+		/// session at which the equivocation occurred.
+		type KeyOwnerProof: Parameter + GetSessionNumber + GetValidatorCount;
+
+		/// The equivocation handling subsystem.
+		///
+		/// Defines methods to publish, check and process an equivocation offence.
+		type EquivocationReportSystem: OffenceReportSystem<
+			Option<Self::AccountId>,
+			EquivocationEvidenceFor<Self>,
+		>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// The current authorities set
+	#[pallet::storage]
+	#[pallet::getter(fn authorities)]
+	pub(super) type Authorities<T: Config> =
+		StorageValue<_, BoundedVec<T::BeefyId, T::MaxAuthorities>, ValueQuery>;
+
+	/// The current validator set id
+	#[pallet::storage]
+	#[pallet::getter(fn validator_set_id)]
+	pub(super) type ValidatorSetId<T: Config> =
+		StorageValue<_, sp_consensus_beefy::ValidatorSetId, ValueQuery>;
+
+	/// Authorities set scheduled to be used with the next session
+	#[pallet::storage]
+	#[pallet::getter(fn next_authorities)]
+	pub(super) type NextAuthorities<T: Config> =
+		StorageValue<_, BoundedVec<T::BeefyId, T::MaxAuthorities>, ValueQuery>;
+
+	/// A mapping from BEEFY set ID to the index of the *most recent* session for which its
+	/// members were responsible.
+	///
+	/// This is only used for validating equivocation proofs. An equivocation proof must
+	/// contains a key-ownership proof for a given session, therefore we need a way to tie
+	/// together sessions and BEEFY set ids, i.e. we need to validate that a validator
+	/// was the owner of a given key on a given session, and what the active set ID was
+	/// during that session.
+	///
+	/// TWOX-NOTE: `ValidatorSetId` is not under user control.
+	#[pallet::storage]
+	#[pallet::getter(fn session_for_set)]
+	pub(super) type SetIdSession<T: Config> =
+		StorageMap<_, Twox64Concat, sp_consensus_beefy::ValidatorSetId, SessionIndex>;
+
+	/// Block number where BEEFY consensus is enabled/started.
+	/// By changing this (through governance or sudo), BEEFY consensus is effectively
+	/// restarted from the new block number.
+	#[pallet::storage]
+	#[pallet::getter(fn genesis_block)]
+	pub(super) type GenesisBlock<T: Config> =
+		StorageValue<_, Option<BlockNumberFor<T>>, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		/// Initial set of BEEFY authorities.
+		pub authorities: Vec<T::BeefyId>,
+		/// Block number where BEEFY consensus should start.
+		/// Should match the session where initial authorities are active.
+		/// *Note:* Ideally use block number where GRANDPA authorities are changed,
+		/// to guarantee the client gets a finality notification for exactly this block.
+		pub genesis_block: Option<BlockNumberFor<T>>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			// BEEFY genesis will be first BEEFY-MANDATORY block,
+			// use block number one instead of chain-genesis.
+			let genesis_block = Some(sp_runtime::traits::One::one());
+			Self { authorities: Vec::new(), genesis_block }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			Pallet::<T>::initialize(&self.authorities)
+				// we panic here as runtime maintainers can simply reconfigure genesis and restart
+				// the chain easily
+				.expect("Authorities vec too big");
+			<GenesisBlock<T>>::put(&self.genesis_block);
+		}
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// A key ownership proof provided as part of an equivocation report is invalid.
+		InvalidKeyOwnershipProof,
+		/// An equivocation proof provided as part of an equivocation report is invalid.
+		InvalidEquivocationProof,
+		/// A given equivocation report is valid but already previously reported.
+		DuplicateOffenceReport,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Report voter equivocation/misbehavior. This method will verify the
+		/// equivocation proof and validate the given key ownership proof
+		/// against the extracted offender. If both are valid, the offence
+		/// will be reported.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::report_equivocation(
+			key_owner_proof.validator_count(),
+			T::MaxNominators::get(),
+		))]
+		pub fn report_equivocation(
+			origin: OriginFor<T>,
+			equivocation_proof: Box<
+				EquivocationProof<
+					BlockNumberFor<T>,
+					T::BeefyId,
+					<T::BeefyId as RuntimeAppPublic>::Signature,
+				>,
+			>,
+			key_owner_proof: T::KeyOwnerProof,
+		) -> DispatchResultWithPostInfo {
+			let reporter = ensure_signed(origin)?;
+
+			T::EquivocationReportSystem::process_evidence(
+				Some(reporter),
+				(*equivocation_proof, key_owner_proof),
+			)?;
+			// Waive the fee since the report is valid and beneficial
+			Ok(Pays::No.into())
+		}
+
+		/// Report voter equivocation/misbehavior. This method will verify the
+		/// equivocation proof and validate the given key ownership proof
+		/// against the extracted offender. If both are valid, the offence
+		/// will be reported.
+		///
+		/// This extrinsic must be called unsigned and it is expected that only
+		/// block authors will call it (validated in `ValidateUnsigned`), as such
+		/// if the block author is defined it will be defined as the equivocation
+		/// reporter.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::report_equivocation(
+			key_owner_proof.validator_count(),
+			T::MaxNominators::get(),
+		))]
+		pub fn report_equivocation_unsigned(
+			origin: OriginFor<T>,
+			equivocation_proof: Box<
+				EquivocationProof<
+					BlockNumberFor<T>,
+					T::BeefyId,
+					<T::BeefyId as RuntimeAppPublic>::Signature,
+				>,
+			>,
+			key_owner_proof: T::KeyOwnerProof,
+		) -> DispatchResultWithPostInfo {
+			ensure_none(origin)?;
+
+			T::EquivocationReportSystem::process_evidence(
+				None,
+				(*equivocation_proof, key_owner_proof),
+			)?;
+			Ok(Pays::No.into())
+		}
+	}
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+
+		fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError> {
+			Self::pre_dispatch(call)
+		}
+
+		fn validate_unsigned(source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			Self::validate_unsigned(source, call)
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Return the current active BEEFY validator set.
+	pub fn validator_set() -> Option<ValidatorSet<T::BeefyId>> {
+		let validators: BoundedVec<T::BeefyId, T::MaxAuthorities> = Self::authorities();
+		let id: sp_consensus_beefy::ValidatorSetId = Self::validator_set_id();
+		ValidatorSet::<T::BeefyId>::new(validators, id)
+	}
+
+	/// Submits an extrinsic to report an equivocation. This method will create
+	/// an unsigned extrinsic with a call to `report_equivocation_unsigned` and
+	/// will push the transaction to the pool. Only useful in an offchain context.
+	pub fn submit_unsigned_equivocation_report(
+		equivocation_proof: EquivocationProof<
+			BlockNumberFor<T>,
+			T::BeefyId,
+			<T::BeefyId as RuntimeAppPublic>::Signature,
+		>,
+		key_owner_proof: T::KeyOwnerProof,
+	) -> Option<()> {
+		T::EquivocationReportSystem::publish_evidence((equivocation_proof, key_owner_proof)).ok()
+	}
+
+	fn change_authorities(
+		new: BoundedVec<T::BeefyId, T::MaxAuthorities>,
+		queued: BoundedVec<T::BeefyId, T::MaxAuthorities>,
+	) {
+		<Authorities<T>>::put(&new);
+
+		let new_id = Self::validator_set_id() + 1u64;
+		<ValidatorSetId<T>>::put(new_id);
+
+		<NextAuthorities<T>>::put(&queued);
+
+		if let Some(validator_set) = ValidatorSet::<T::BeefyId>::new(new, new_id) {
+			let log = DigestItem::Consensus(
+				BEEFY_ENGINE_ID,
+				ConsensusLog::AuthoritiesChange(validator_set.clone()).encode(),
+			);
+			<frame_system::Pallet<T>>::deposit_log(log);
+
+			let next_id = new_id + 1;
+			if let Some(next_validator_set) = ValidatorSet::<T::BeefyId>::new(queued, next_id) {
+				<T::OnNewValidatorSet as OnNewValidatorSet<_>>::on_new_validator_set(
+					&validator_set,
+					&next_validator_set,
+				);
+			}
+		}
+	}
+
+	fn initialize(authorities: &Vec<T::BeefyId>) -> Result<(), ()> {
+		if authorities.is_empty() {
+			return Ok(())
+		}
+
+		if !<Authorities<T>>::get().is_empty() {
+			return Err(())
+		}
+
+		let bounded_authorities =
+			BoundedSlice::<T::BeefyId, T::MaxAuthorities>::try_from(authorities.as_slice())
+				.map_err(|_| ())?;
+
+		let id = GENESIS_AUTHORITY_SET_ID;
+		<Authorities<T>>::put(bounded_authorities);
+		<ValidatorSetId<T>>::put(id);
+		// Like `pallet_session`, initialize the next validator set as well.
+		<NextAuthorities<T>>::put(bounded_authorities);
+
+		if let Some(validator_set) = ValidatorSet::<T::BeefyId>::new(authorities.clone(), id) {
+			let next_id = id + 1;
+			if let Some(next_validator_set) =
+				ValidatorSet::<T::BeefyId>::new(authorities.clone(), next_id)
+			{
+				<T::OnNewValidatorSet as OnNewValidatorSet<_>>::on_new_validator_set(
+					&validator_set,
+					&next_validator_set,
+				);
+			}
+		}
+
+		// NOTE: initialize first session of first set. this is necessary for
+		// the genesis set and session since we only update the set -> session
+		// mapping whenever a new session starts, i.e. through `on_new_session`.
+		SetIdSession::<T>::insert(0, 0);
+
+		Ok(())
+	}
+}
+
+impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
+	type Public = T::BeefyId;
+}
+
+impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T>
+where
+	T: pallet_session::Config,
+{
+	type Key = T::BeefyId;
+
+	fn on_genesis_session<'a, I: 'a>(validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, T::BeefyId)>,
+	{
+		let authorities = validators.map(|(_, k)| k).collect::<Vec<_>>();
+		// we panic here as runtime maintainers can simply reconfigure genesis and restart the
+		// chain easily
+		Self::initialize(&authorities).expect("Authorities vec too big");
+	}
+
+	fn on_new_session<'a, I: 'a>(_changed: bool, validators: I, queued_validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, T::BeefyId)>,
+	{
+		let next_authorities = validators.map(|(_, k)| k).collect::<Vec<_>>();
+		if next_authorities.len() as u32 > T::MaxAuthorities::get() {
+			log::error!(
+				target: LOG_TARGET,
+				"authorities list {:?} truncated to length {}",
+				next_authorities,
+				T::MaxAuthorities::get(),
+			);
+		}
+		let bounded_next_authorities =
+			BoundedVec::<_, T::MaxAuthorities>::truncate_from(next_authorities);
+
+		let next_queued_authorities = queued_validators.map(|(_, k)| k).collect::<Vec<_>>();
+		if next_queued_authorities.len() as u32 > T::MaxAuthorities::get() {
+			log::error!(
+				target: LOG_TARGET,
+				"queued authorities list {:?} truncated to length {}",
+				next_queued_authorities,
+				T::MaxAuthorities::get(),
+			);
+		}
+		let bounded_next_queued_authorities =
+			BoundedVec::<_, T::MaxAuthorities>::truncate_from(next_queued_authorities);
+
+		// Always issue a change on each `session`, even if validator set hasn't changed.
+		// We want to have at least one BEEFY mandatory block per session.
+		Self::change_authorities(bounded_next_authorities, bounded_next_queued_authorities);
+
+		let validator_set_id = Self::validator_set_id();
+		// Update the mapping for the new set id that corresponds to the latest session (i.e. now).
+		let session_index = <pallet_session::Pallet<T>>::current_index();
+		SetIdSession::<T>::insert(validator_set_id, &session_index);
+		// Prune old entry if limit reached.
+		let max_set_id_session_entries = T::MaxSetIdSessionEntries::get().max(1);
+		if validator_set_id >= max_set_id_session_entries {
+			SetIdSession::<T>::remove(validator_set_id - max_set_id_session_entries);
+		}
+	}
+
+	fn on_disabled(i: u32) {
+		let log = DigestItem::Consensus(
+			BEEFY_ENGINE_ID,
+			ConsensusLog::<T::BeefyId>::OnDisabled(i as AuthorityIndex).encode(),
+		);
+
+		<frame_system::Pallet<T>>::deposit_log(log);
+	}
+}
+
+impl<T: Config> IsMember<T::BeefyId> for Pallet<T> {
+	fn is_member(authority_id: &T::BeefyId) -> bool {
+		Self::authorities().iter().any(|id| id == authority_id)
+	}
+}
+
+pub trait WeightInfo {
+	fn report_equivocation(validator_count: u32, max_nominators_per_validator: u32) -> Weight;
+}
diff --git a/substrate/frame/beefy/src/mock.rs b/substrate/frame/beefy/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b55a65dbd73aff5210dc6f74127aa8bbcea7c268
--- /dev/null
+++ b/substrate/frame/beefy/src/mock.rs
@@ -0,0 +1,334 @@
+// 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 std::vec;
+
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, SequentialPhragmen,
+};
+use frame_support::{
+	construct_runtime, parameter_types,
+	traits::{ConstU16, ConstU32, ConstU64, KeyOwnerProofSystem, OnFinalize, OnInitialize},
+};
+use pallet_session::historical as pallet_session_historical;
+use sp_core::{crypto::KeyTypeId, ConstU128, H256};
+use sp_io::TestExternalities;
+use sp_runtime::{
+	app_crypto::ecdsa::Public,
+	curve::PiecewiseLinear,
+	impl_opaque_keys,
+	testing::TestXt,
+	traits::{BlakeTwo256, IdentityLookup, OpaqueKeys},
+	BuildStorage, Perbill,
+};
+use sp_staking::{EraIndex, SessionIndex};
+use sp_state_machine::BasicExternalities;
+
+use crate as pallet_beefy;
+
+pub use sp_consensus_beefy::{
+	ecdsa_crypto::{AuthorityId as BeefyId, AuthoritySignature as BeefySignature},
+	ConsensusLog, EquivocationProof, BEEFY_ENGINE_ID,
+};
+
+impl_opaque_keys! {
+	pub struct MockSessionKeys {
+		pub dummy: pallet_beefy::Pallet<Test>,
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Authorship: pallet_authorship,
+		Timestamp: pallet_timestamp,
+		Balances: pallet_balances,
+		Beefy: pallet_beefy,
+		Staking: pallet_staking,
+		Session: pallet_session,
+		Offences: pallet_offences,
+		Historical: pallet_session_historical,
+	}
+);
+
+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 = 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<u128>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ConstU16<42>;
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl<C> frame_system::offchain::SendTransactionTypes<C> for Test
+where
+	RuntimeCall: From<C>,
+{
+	type OverarchingCall = RuntimeCall;
+	type Extrinsic = TestXt<RuntimeCall, ()>;
+}
+
+parameter_types! {
+	pub const Period: u64 = 1;
+	pub const ReportLongevity: u64 =
+		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * Period::get();
+	pub const MaxSetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();
+}
+
+impl pallet_beefy::Config for Test {
+	type BeefyId = BeefyId;
+	type MaxAuthorities = ConstU32<100>;
+	type MaxNominators = ConstU32<1000>;
+	type MaxSetIdSessionEntries = MaxSetIdSessionEntries;
+	type OnNewValidatorSet = ();
+	type WeightInfo = ();
+	type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, BeefyId)>>::Proof;
+	type EquivocationReportSystem =
+		super::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
+}
+
+parameter_types! {
+	pub const DisabledValidatorsThreshold: Perbill = Perbill::from_percent(33);
+}
+
+impl pallet_session::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = u64;
+	type ValidatorIdOf = pallet_staking::StashOf<Self>;
+	type ShouldEndSession = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
+	type SessionHandler = <MockSessionKeys as OpaqueKeys>::KeyTypeIdProviders;
+	type Keys = MockSessionKeys;
+	type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Test {
+	type FullIdentification = pallet_staking::Exposure<u64, u128>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Self>;
+}
+
+impl pallet_authorship::Config for Test {
+	type FindAuthor = ();
+	type EventHandler = ();
+}
+
+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 MaxHolds = ();
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<3>;
+	type WeightInfo = ();
+}
+
+pallet_staking_reward_curve::build! {
+	const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
+		min_inflation: 0_025_000u64,
+		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 SessionsPerEra: SessionIndex = 3;
+	pub const BondingDuration: EraIndex = 3;
+	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
+	pub static ElectionsBoundsOnChain: ElectionBounds = ElectionBoundsBuilder::default().build();
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Test;
+	type Solver = SequentialPhragmen<u64, Perbill>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = ConstU32<100>;
+	type Bounds = ElectionsBoundsOnChain;
+}
+
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+	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 HistoryDepth = ConstU32<84>;
+	type EventListeners = ();
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+impl pallet_offences::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
+	type OnOffenceHandler = Staking;
+}
+
+// Note, that we can't use `UintAuthorityId` here. Reason is that the implementation
+// of `to_public_key()` assumes, that a public key is 32 bytes long. This is true for
+// ed25519 and sr25519 but *not* for ecdsa. A compressed ecdsa public key is 33 bytes,
+// with the first one containing information to reconstruct the uncompressed key.
+pub fn mock_beefy_id(id: u8) -> BeefyId {
+	let mut buf: [u8; 33] = [id; 33];
+	// Set to something valid.
+	buf[0] = 0x02;
+	let pk = Public::from_raw(buf);
+	BeefyId::from(pk)
+}
+
+pub fn mock_authorities(vec: Vec<u8>) -> Vec<BeefyId> {
+	vec.into_iter().map(|id| mock_beefy_id(id)).collect()
+}
+
+pub fn new_test_ext(ids: Vec<u8>) -> TestExternalities {
+	new_test_ext_raw_authorities(mock_authorities(ids))
+}
+
+pub fn new_test_ext_raw_authorities(authorities: Vec<BeefyId>) -> TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let balances: Vec<_> = (0..authorities.len()).map(|i| (i as u64, 10_000_000)).collect();
+
+	pallet_balances::GenesisConfig::<Test> { balances }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	let session_keys: Vec<_> = authorities
+		.iter()
+		.enumerate()
+		.map(|(i, k)| (i as u64, i as u64, MockSessionKeys { dummy: k.clone() }))
+		.collect();
+
+	BasicExternalities::execute_with_storage(&mut t, || {
+		for (ref id, ..) in &session_keys {
+			frame_system::Pallet::<Test>::inc_providers(id);
+		}
+	});
+
+	pallet_session::GenesisConfig::<Test> { keys: session_keys }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	// controllers are same as stash
+	let stakers: Vec<_> = (0..authorities.len())
+		.map(|i| (i as u64, i as u64, 10_000, pallet_staking::StakerStatus::<u64>::Validator))
+		.collect();
+
+	let staking_config = pallet_staking::GenesisConfig::<Test> {
+		stakers,
+		validator_count: 2,
+		force_era: pallet_staking::Forcing::ForceNew,
+		minimum_validator_count: 0,
+		invulnerables: vec![],
+		..Default::default()
+	};
+
+	staking_config.assimilate_storage(&mut t).unwrap();
+
+	t.into()
+}
+
+pub fn start_session(session_index: SessionIndex) {
+	for i in Session::current_index()..session_index {
+		System::on_finalize(System::block_number());
+		Session::on_finalize(System::block_number());
+		Staking::on_finalize(System::block_number());
+		Beefy::on_finalize(System::block_number());
+
+		let parent_hash = if System::block_number() > 1 {
+			let hdr = System::finalize();
+			hdr.hash()
+		} else {
+			System::parent_hash()
+		};
+
+		System::reset_events();
+		System::initialize(&(i as u64 + 1), &parent_hash, &Default::default());
+		System::set_block_number((i + 1).into());
+		Timestamp::set_timestamp(System::block_number() * 6000);
+
+		System::on_initialize(System::block_number());
+		Session::on_initialize(System::block_number());
+		Staking::on_initialize(System::block_number());
+		Beefy::on_initialize(System::block_number());
+	}
+
+	assert_eq!(Session::current_index(), session_index);
+}
+
+pub fn start_era(era_index: EraIndex) {
+	start_session((era_index * 3).into());
+	assert_eq!(Staking::current_era(), Some(era_index));
+}
diff --git a/substrate/frame/beefy/src/tests.rs b/substrate/frame/beefy/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e04dc330d0c07cb7258323b34db0086c6226ffb2
--- /dev/null
+++ b/substrate/frame/beefy/src/tests.rs
@@ -0,0 +1,793 @@
+// 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 std::vec;
+
+use codec::Encode;
+use sp_consensus_beefy::{
+	check_equivocation_proof, generate_equivocation_proof, known_payloads::MMR_ROOT_ID,
+	Keyring as BeefyKeyring, Payload, ValidatorSet, KEY_TYPE as BEEFY_KEY_TYPE,
+};
+
+use sp_runtime::DigestItem;
+
+use frame_support::{
+	assert_err, assert_ok,
+	dispatch::{GetDispatchInfo, Pays},
+	traits::{Currency, KeyOwnerProofSystem, OnInitialize},
+};
+
+use crate::{mock::*, Call, Config, Error, Weight, WeightInfo};
+
+fn init_block(block: u64) {
+	System::set_block_number(block);
+	Session::on_initialize(block);
+}
+
+pub fn beefy_log(log: ConsensusLog<BeefyId>) -> DigestItem {
+	DigestItem::Consensus(BEEFY_ENGINE_ID, log.encode())
+}
+
+#[test]
+fn genesis_session_initializes_authorities() {
+	let authorities = mock_authorities(vec![1, 2, 3, 4]);
+	let want = authorities.clone();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		let authorities = Beefy::authorities();
+
+		assert_eq!(authorities.len(), 4);
+		assert_eq!(want[0], authorities[0]);
+		assert_eq!(want[1], authorities[1]);
+
+		assert!(Beefy::validator_set_id() == 0);
+
+		let next_authorities = Beefy::next_authorities();
+
+		assert_eq!(next_authorities.len(), 4);
+		assert_eq!(want[0], next_authorities[0]);
+		assert_eq!(want[1], next_authorities[1]);
+	});
+}
+
+#[test]
+fn session_change_updates_authorities() {
+	let authorities = mock_authorities(vec![1, 2, 3, 4]);
+	let want_validators = authorities.clone();
+
+	new_test_ext(vec![1, 2, 3, 4]).execute_with(|| {
+		assert!(0 == Beefy::validator_set_id());
+
+		init_block(1);
+
+		assert!(1 == Beefy::validator_set_id());
+
+		let want = beefy_log(ConsensusLog::AuthoritiesChange(
+			ValidatorSet::new(want_validators, 1).unwrap(),
+		));
+
+		let log = System::digest().logs[0].clone();
+		assert_eq!(want, log);
+
+		init_block(2);
+
+		assert!(2 == Beefy::validator_set_id());
+
+		let want = beefy_log(ConsensusLog::AuthoritiesChange(
+			ValidatorSet::new(vec![mock_beefy_id(2), mock_beefy_id(4)], 2).unwrap(),
+		));
+
+		let log = System::digest().logs[1].clone();
+		assert_eq!(want, log);
+	});
+}
+
+#[test]
+fn session_change_updates_next_authorities() {
+	let want = vec![mock_beefy_id(1), mock_beefy_id(2), mock_beefy_id(3), mock_beefy_id(4)];
+
+	new_test_ext(vec![1, 2, 3, 4]).execute_with(|| {
+		let next_authorities = Beefy::next_authorities();
+
+		assert_eq!(next_authorities.len(), 4);
+		assert_eq!(want[0], next_authorities[0]);
+		assert_eq!(want[1], next_authorities[1]);
+		assert_eq!(want[2], next_authorities[2]);
+		assert_eq!(want[3], next_authorities[3]);
+
+		init_block(1);
+
+		let next_authorities = Beefy::next_authorities();
+
+		assert_eq!(next_authorities.len(), 2);
+		assert_eq!(want[1], next_authorities[0]);
+		assert_eq!(want[3], next_authorities[1]);
+	});
+}
+
+#[test]
+fn validator_set_at_genesis() {
+	let want = vec![mock_beefy_id(1), mock_beefy_id(2)];
+
+	new_test_ext(vec![1, 2, 3, 4]).execute_with(|| {
+		let vs = Beefy::validator_set().unwrap();
+
+		assert_eq!(vs.id(), 0u64);
+		assert_eq!(vs.validators()[0], want[0]);
+		assert_eq!(vs.validators()[1], want[1]);
+	});
+}
+
+#[test]
+fn validator_set_updates_work() {
+	let want = vec![mock_beefy_id(1), mock_beefy_id(2), mock_beefy_id(3), mock_beefy_id(4)];
+
+	new_test_ext(vec![1, 2, 3, 4]).execute_with(|| {
+		let vs = Beefy::validator_set().unwrap();
+		assert_eq!(vs.id(), 0u64);
+		assert_eq!(want[0], vs.validators()[0]);
+		assert_eq!(want[1], vs.validators()[1]);
+		assert_eq!(want[2], vs.validators()[2]);
+		assert_eq!(want[3], vs.validators()[3]);
+
+		init_block(1);
+
+		let vs = Beefy::validator_set().unwrap();
+
+		assert_eq!(vs.id(), 1u64);
+		assert_eq!(want[0], vs.validators()[0]);
+		assert_eq!(want[1], vs.validators()[1]);
+
+		init_block(2);
+
+		let vs = Beefy::validator_set().unwrap();
+
+		assert_eq!(vs.id(), 2u64);
+		assert_eq!(want[1], vs.validators()[0]);
+		assert_eq!(want[3], vs.validators()[1]);
+	});
+}
+
+#[test]
+fn cleans_up_old_set_id_session_mappings() {
+	new_test_ext(vec![1, 2, 3, 4]).execute_with(|| {
+		let max_set_id_session_entries = MaxSetIdSessionEntries::get();
+
+		// we have 3 sessions per era
+		let era_limit = max_set_id_session_entries / 3;
+		// sanity check against division precision loss
+		assert_eq!(0, max_set_id_session_entries % 3);
+		// go through `max_set_id_session_entries` sessions
+		start_era(era_limit);
+
+		// we should have a session id mapping for all the set ids from
+		// `max_set_id_session_entries` eras we have observed
+		for i in 1..=max_set_id_session_entries {
+			assert!(Beefy::session_for_set(i as u64).is_some());
+		}
+
+		// go through another `max_set_id_session_entries` sessions
+		start_era(era_limit * 2);
+
+		// we should keep tracking the new mappings for new sessions
+		for i in max_set_id_session_entries + 1..=max_set_id_session_entries * 2 {
+			assert!(Beefy::session_for_set(i as u64).is_some());
+		}
+
+		// but the old ones should have been pruned by now
+		for i in 1..=max_set_id_session_entries {
+			assert!(Beefy::session_for_set(i as u64).is_none());
+		}
+	});
+}
+
+/// Returns a list with 3 authorities with known keys:
+/// Alice, Bob and Charlie.
+pub fn test_authorities() -> Vec<BeefyId> {
+	let authorities = vec![BeefyKeyring::Alice, BeefyKeyring::Bob, BeefyKeyring::Charlie];
+	authorities.into_iter().map(|id| id.public()).collect()
+}
+
+#[test]
+fn should_sign_and_verify() {
+	use sp_runtime::traits::Keccak256;
+
+	let set_id = 3;
+	let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+	let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+
+	// generate an equivocation proof, with two votes in the same round for
+	// same payload signed by the same key
+	let equivocation_proof = generate_equivocation_proof(
+		(1, payload1.clone(), set_id, &BeefyKeyring::Bob),
+		(1, payload1.clone(), set_id, &BeefyKeyring::Bob),
+	);
+	// expect invalid equivocation proof
+	assert!(!check_equivocation_proof::<_, _, Keccak256>(&equivocation_proof));
+
+	// generate an equivocation proof, with two votes in different rounds for
+	// different payloads signed by the same key
+	let equivocation_proof = generate_equivocation_proof(
+		(1, payload1.clone(), set_id, &BeefyKeyring::Bob),
+		(2, payload2.clone(), set_id, &BeefyKeyring::Bob),
+	);
+	// expect invalid equivocation proof
+	assert!(!check_equivocation_proof::<_, _, Keccak256>(&equivocation_proof));
+
+	// generate an equivocation proof, with two votes by different authorities
+	let equivocation_proof = generate_equivocation_proof(
+		(1, payload1.clone(), set_id, &BeefyKeyring::Alice),
+		(1, payload2.clone(), set_id, &BeefyKeyring::Bob),
+	);
+	// expect invalid equivocation proof
+	assert!(!check_equivocation_proof::<_, _, Keccak256>(&equivocation_proof));
+
+	// generate an equivocation proof, with two votes in different set ids
+	let equivocation_proof = generate_equivocation_proof(
+		(1, payload1.clone(), set_id, &BeefyKeyring::Bob),
+		(1, payload2.clone(), set_id + 1, &BeefyKeyring::Bob),
+	);
+	// expect invalid equivocation proof
+	assert!(!check_equivocation_proof::<_, _, Keccak256>(&equivocation_proof));
+
+	// generate an equivocation proof, with two votes in the same round for
+	// different payloads signed by the same key
+	let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+	let equivocation_proof = generate_equivocation_proof(
+		(1, payload1, set_id, &BeefyKeyring::Bob),
+		(1, payload2, set_id, &BeefyKeyring::Bob),
+	);
+	// expect valid equivocation proof
+	assert!(check_equivocation_proof::<_, _, Keccak256>(&equivocation_proof));
+}
+
+#[test]
+fn report_equivocation_current_set_works() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		assert_eq!(Staking::current_era(), Some(0));
+		assert_eq!(Session::current_index(), 0);
+
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+		let set_id = validator_set.id();
+		let validators = Session::validators();
+
+		// make sure that all validators have the same balance
+		for validator in &validators {
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(1, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+
+		assert_eq!(authorities.len(), 2);
+		let equivocation_authority_index = 1;
+		let equivocation_key = &authorities[equivocation_authority_index];
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+		// generate an equivocation proof, with two votes in the same round for
+		// different payloads signed by the same key
+		let equivocation_proof = generate_equivocation_proof(
+			(block_num, payload1, set_id, &equivocation_keyring),
+			(block_num, payload2, set_id, &equivocation_keyring),
+		);
+
+		// create the key ownership proof
+		let key_owner_proof = Historical::prove((BEEFY_KEY_TYPE, &equivocation_key)).unwrap();
+
+		// report the equivocation and the tx should be dispatched successfully
+		assert_ok!(Beefy::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		),);
+
+		start_era(2);
+
+		// check that the balance of 0-th validator is slashed 100%.
+		let equivocation_validator_id = validators[equivocation_authority_index];
+
+		assert_eq!(Balances::total_balance(&equivocation_validator_id), 10_000_000 - 10_000);
+		assert_eq!(Staking::slashable_balance_of(&equivocation_validator_id), 0);
+		assert_eq!(
+			Staking::eras_stakers(2, equivocation_validator_id),
+			pallet_staking::Exposure { total: 0, own: 0, others: vec![] },
+		);
+
+		// check that the balances of all other validators are left intact.
+		for validator in &validators {
+			if *validator == equivocation_validator_id {
+				continue
+			}
+
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(2, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+	});
+}
+
+#[test]
+fn report_equivocation_old_set_works() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+		let validators = Session::validators();
+		let old_set_id = validator_set.id();
+
+		assert_eq!(authorities.len(), 2);
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index];
+
+		// create the key ownership proof in the "old" set
+		let key_owner_proof = Historical::prove((BEEFY_KEY_TYPE, &equivocation_key)).unwrap();
+
+		start_era(2);
+
+		// make sure that all authorities have the same balance
+		for validator in &validators {
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(2, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+
+		let validator_set = Beefy::validator_set().unwrap();
+		let new_set_id = validator_set.id();
+		assert_eq!(old_set_id + 3, new_set_id);
+
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+		// generate an equivocation proof for the old set,
+		let equivocation_proof = generate_equivocation_proof(
+			(block_num, payload1, old_set_id, &equivocation_keyring),
+			(block_num, payload2, old_set_id, &equivocation_keyring),
+		);
+
+		// report the equivocation and the tx should be dispatched successfully
+		assert_ok!(Beefy::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		),);
+
+		start_era(3);
+
+		// check that the balance of 0-th validator is slashed 100%.
+		let equivocation_validator_id = validators[equivocation_authority_index];
+
+		assert_eq!(Balances::total_balance(&equivocation_validator_id), 10_000_000 - 10_000);
+		assert_eq!(Staking::slashable_balance_of(&equivocation_validator_id), 0);
+		assert_eq!(
+			Staking::eras_stakers(3, equivocation_validator_id),
+			pallet_staking::Exposure { total: 0, own: 0, others: vec![] },
+		);
+
+		// check that the balances of all other validators are left intact.
+		for validator in &validators {
+			if *validator == equivocation_validator_id {
+				continue
+			}
+
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(3, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_set_id() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+		let set_id = validator_set.id();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index];
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		let key_owner_proof = Historical::prove((BEEFY_KEY_TYPE, &equivocation_key)).unwrap();
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+		// generate an equivocation for a future set
+		let equivocation_proof = generate_equivocation_proof(
+			(block_num, payload1, set_id + 1, &equivocation_keyring),
+			(block_num, payload2, set_id + 1, &equivocation_keyring),
+		);
+
+		// the call for reporting the equivocation should error
+		assert_err!(
+			Beefy::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof),
+				key_owner_proof,
+			),
+			Error::<Test>::InvalidEquivocationProof,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_session() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index];
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		// generate a key ownership proof at current era set id
+		let key_owner_proof = Historical::prove((BEEFY_KEY_TYPE, &equivocation_key)).unwrap();
+
+		start_era(2);
+
+		let set_id = Beefy::validator_set().unwrap().id();
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+		// generate an equivocation proof at following era set id = 2
+		let equivocation_proof = generate_equivocation_proof(
+			(block_num, payload1, set_id, &equivocation_keyring),
+			(block_num, payload2, set_id, &equivocation_keyring),
+		);
+
+		// report an equivocation for the current set using an key ownership
+		// proof from the previous set, the session should be invalid.
+		assert_err!(
+			Beefy::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof),
+				key_owner_proof,
+			),
+			Error::<Test>::InvalidEquivocationProof,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_key_owner_proof() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+		let set_id = validator_set.id();
+
+		let invalid_owner_authority_index = 1;
+		let invalid_owner_key = &authorities[invalid_owner_authority_index];
+
+		// generate a key ownership proof for the authority at index 1
+		let invalid_key_owner_proof =
+			Historical::prove((BEEFY_KEY_TYPE, &invalid_owner_key)).unwrap();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index];
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+		// generate an equivocation proof for the authority at index 0
+		let equivocation_proof = generate_equivocation_proof(
+			(block_num, payload1, set_id + 1, &equivocation_keyring),
+			(block_num, payload2, set_id + 1, &equivocation_keyring),
+		);
+
+		// we need to start a new era otherwise the key ownership proof won't be
+		// checked since the authorities are part of the current session
+		start_era(2);
+
+		// report an equivocation for the current set using a key ownership
+		// proof for a different key than the one in the equivocation proof.
+		assert_err!(
+			Beefy::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof),
+				invalid_key_owner_proof,
+			),
+			Error::<Test>::InvalidKeyOwnershipProof,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_equivocation_proof() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+		let set_id = validator_set.id();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index];
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		// generate a key ownership proof at set id in era 1
+		let key_owner_proof = Historical::prove((BEEFY_KEY_TYPE, &equivocation_key)).unwrap();
+
+		let assert_invalid_equivocation_proof = |equivocation_proof| {
+			assert_err!(
+				Beefy::report_equivocation_unsigned(
+					RuntimeOrigin::none(),
+					Box::new(equivocation_proof),
+					key_owner_proof.clone(),
+				),
+				Error::<Test>::InvalidEquivocationProof,
+			);
+		};
+
+		start_era(2);
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+
+		// both votes target the same block number and payload,
+		// there is no equivocation.
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			(block_num, payload1.clone(), set_id, &equivocation_keyring),
+			(block_num, payload1.clone(), set_id, &equivocation_keyring),
+		));
+
+		// votes targeting different rounds, there is no equivocation.
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			(block_num, payload1.clone(), set_id, &equivocation_keyring),
+			(block_num + 1, payload2.clone(), set_id, &equivocation_keyring),
+		));
+
+		// votes signed with different authority keys
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			(block_num, payload1.clone(), set_id, &equivocation_keyring),
+			(block_num, payload1.clone(), set_id, &BeefyKeyring::Charlie),
+		));
+
+		// votes signed with a key that isn't part of the authority set
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			(block_num, payload1.clone(), set_id, &equivocation_keyring),
+			(block_num, payload1.clone(), set_id, &BeefyKeyring::Dave),
+		));
+
+		// votes targeting different set ids
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			(block_num, payload1, set_id, &equivocation_keyring),
+			(block_num, payload2, set_id + 1, &equivocation_keyring),
+		));
+	});
+}
+
+#[test]
+fn report_equivocation_validate_unsigned_prevents_duplicates() {
+	use sp_runtime::transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
+		ValidTransaction,
+	};
+
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+		let set_id = validator_set.id();
+
+		// generate and report an equivocation for the validator at index 0
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index];
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+		let equivocation_proof = generate_equivocation_proof(
+			(block_num, payload1, set_id, &equivocation_keyring),
+			(block_num, payload2, set_id, &equivocation_keyring),
+		);
+
+		let key_owner_proof = Historical::prove((BEEFY_KEY_TYPE, &equivocation_key)).unwrap();
+
+		let call = Call::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof.clone()),
+			key_owner_proof: key_owner_proof.clone(),
+		};
+
+		// only local/inblock reports are allowed
+		assert_eq!(
+			<Beefy as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::External,
+				&call,
+			),
+			InvalidTransaction::Call.into(),
+		);
+
+		// the transaction is valid when passed as local
+		let tx_tag = (equivocation_key, set_id, 3u64);
+
+		assert_eq!(
+			<Beefy as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&call,
+			),
+			TransactionValidity::Ok(ValidTransaction {
+				priority: TransactionPriority::max_value(),
+				requires: vec![],
+				provides: vec![("BeefyEquivocation", tx_tag).encode()],
+				longevity: ReportLongevity::get(),
+				propagate: false,
+			})
+		);
+
+		// the pre dispatch checks should also pass
+		assert_ok!(<Beefy as sp_runtime::traits::ValidateUnsigned>::pre_dispatch(&call));
+
+		// we submit the report
+		Beefy::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.unwrap();
+
+		// the report should now be considered stale and the transaction is invalid
+		// the check for staleness should be done on both `validate_unsigned` and on `pre_dispatch`
+		assert_err!(
+			<Beefy as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&call,
+			),
+			InvalidTransaction::Stale,
+		);
+
+		assert_err!(
+			<Beefy as sp_runtime::traits::ValidateUnsigned>::pre_dispatch(&call),
+			InvalidTransaction::Stale,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_has_valid_weight() {
+	// the weight depends on the size of the validator set,
+	// but there's a lower bound of 100 validators.
+	assert!((1..=100)
+		.map(|validators| <Test as Config>::WeightInfo::report_equivocation(validators, 1000))
+		.collect::<Vec<_>>()
+		.windows(2)
+		.all(|w| w[0] == w[1]));
+
+	// after 100 validators the weight should keep increasing
+	// with every extra validator.
+	assert!((100..=1000)
+		.map(|validators| <Test as Config>::WeightInfo::report_equivocation(validators, 1000))
+		.collect::<Vec<_>>()
+		.windows(2)
+		.all(|w| w[0].ref_time() < w[1].ref_time()));
+}
+
+#[test]
+fn valid_equivocation_reports_dont_pay_fees() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let block_num = System::block_number();
+		let validator_set = Beefy::validator_set().unwrap();
+		let authorities = validator_set.validators();
+		let set_id = validator_set.id();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index];
+		let equivocation_keyring = BeefyKeyring::from_public(equivocation_key).unwrap();
+
+		// generate equivocation proof
+		let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![42]);
+		let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]);
+		let equivocation_proof = generate_equivocation_proof(
+			(block_num, payload1, set_id, &equivocation_keyring),
+			(block_num, payload2, set_id, &equivocation_keyring),
+		);
+
+		// create the key ownership proof.
+		let key_owner_proof = Historical::prove((BEEFY_KEY_TYPE, &equivocation_key)).unwrap();
+
+		// check the dispatch info for the call.
+		let info = Call::<Test>::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof.clone()),
+			key_owner_proof: key_owner_proof.clone(),
+		}
+		.get_dispatch_info();
+
+		// it should have non-zero weight and the fee has to be paid.
+		assert!(info.weight.any_gt(Weight::zero()));
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// report the equivocation.
+		let post_info = Beefy::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof.clone()),
+			key_owner_proof.clone(),
+		)
+		.unwrap();
+
+		// the original weight should be kept, but given that the report
+		// is valid the fee is waived.
+		assert!(post_info.actual_weight.is_none());
+		assert_eq!(post_info.pays_fee, Pays::No);
+
+		// report the equivocation again which is invalid now since it is
+		// duplicate.
+		let post_info = Beefy::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.err()
+		.unwrap()
+		.post_info;
+
+		// the fee is not waived and the original weight is kept.
+		assert!(post_info.actual_weight.is_none());
+		assert_eq!(post_info.pays_fee, Pays::Yes);
+	})
+}
diff --git a/substrate/frame/benchmarking/Cargo.toml b/substrate/frame/benchmarking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6a089c230cfd55cd87cea11dc40bd7bb062116c2
--- /dev/null
+++ b/substrate/frame/benchmarking/Cargo.toml
@@ -0,0 +1,65 @@
+[package]
+name = "frame-benchmarking"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Macro for benchmarking a FRAME runtime."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+linregress = { version = "0.5.1", optional = true }
+log = { version = "0.4.17", default-features = false }
+paste = "1.0"
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-support-procedural = { version = "4.0.0-dev", default-features = false, path = "../support/procedural" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../../primitives/runtime-interface" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-storage = { version = "13.0.0", default-features = false, path = "../../primitives/storage" }
+static_assertions = "1.1.0"
+
+[dev-dependencies]
+array-bytes = "6.1"
+rusty-fork = { version = "0.3.0", default-features = false }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support-procedural/std",
+	"frame-support/std",
+	"frame-system/std",
+	"linregress",
+	"log/std",
+	"scale-info/std",
+	"serde",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-keystore/std",
+	"sp-runtime-interface/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-storage/std",
+]
+runtime-benchmarks = [
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
diff --git a/substrate/frame/benchmarking/README.md b/substrate/frame/benchmarking/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc6a184435df6e843ac81ab5746db9b48a0f4549
--- /dev/null
+++ b/substrate/frame/benchmarking/README.md
@@ -0,0 +1,211 @@
+# Substrate Runtime Benchmarking Framework
+
+This crate contains a set of utilities that can be used to benchmark and weigh FRAME pallets that
+you develop for your Substrate Runtime.
+
+## Overview
+
+Substrate's FRAME framework allows you to develop custom logic for your blockchain that can be
+included in your runtime. This flexibility is key to help you design complex and interactive
+pallets, but without accurate weights assigned to dispatchables, your blockchain may become
+vulnerable to denial of service (DoS) attacks by malicious actors.
+
+The Substrate Runtime Benchmarking Framework is a tool you can use to mitigate DoS attacks against
+your blockchain network by benchmarking the computational resources required to execute different
+functions in the runtime, for example extrinsics, `on_initialize`, `verify_unsigned`, etc...
+
+The general philosophy behind the benchmarking system is: If your node can know ahead of time how
+long it will take to execute an extrinsic, it can safely make decisions to include or exclude that
+extrinsic based on its available resources. By doing this, it can keep the block production and
+import process running smoothly.
+
+To achieve this, we need to model how long it takes to run each function in the runtime by:
+
+* Creating custom benchmarking logic that executes a specific code path of a function.
+* Executing the benchmark in the Wasm execution environment, on a specific set of hardware, with a
+  custom runtime configuration, etc...
+* Executing the benchmark across controlled ranges of possible values that may affect the result of
+  the benchmark (called "components").
+* Executing the benchmark multiple times at each point in order to isolate and remove outliers.
+* Using the results of the benchmark to create a linear model of the function across its components.
+
+With this linear model, we are able to estimate ahead of time how long it takes to execute some
+logic, and thus make informed decisions without actually spending any significant resources at
+runtime.
+
+Note that we assume that all extrinsics are assumed to be of linear complexity, which is why we are
+able to always fit them to a linear model. Quadratic or higher complexity functions are, in general,
+considered to be dangerous to the runtime as the weight of these functions may explode as the
+runtime state or input becomes too complex.
+
+The benchmarking framework comes with the following tools:
+
+* [A set of macros](./src/lib.rs) (`benchmarks!`, `add_benchmark!`, etc...) to make it easy to
+  write, test, and add runtime benchmarks.
+* [A set of linear regression analysis functions](./src/analysis.rs) for processing benchmark data.
+* [A CLI extension](../../utils/frame/benchmarking-cli/README.md) to make it easy to execute benchmarks on your
+  node.
+
+The end-to-end benchmarking pipeline is disabled by default when compiling a node. If you want to
+run benchmarks, you need to enable it by compiling with a Rust feature flag `runtime-benchmarks`.
+More details about this below.
+
+### Weight
+
+Substrate represents computational resources using a generic unit of measurement called "Weight". It
+defines 10^12 Weight as 1 second of computation on the physical machine used for benchmarking. This
+means that the weight of a function may change based on the specific hardware used to benchmark the
+runtime functions.
+
+By modeling the expected weight of each runtime function, the blockchain is able to calculate how
+many transactions or system level functions it will be able to execute within a certain period of
+time. Often, the limiting factor for a blockchain is the fixed block production time for the
+network.
+
+Within FRAME, each dispatchable function must have a `#[weight]` annotation with a function that can
+return the expected weight for the worst case scenario execution of that function given its inputs.
+This benchmarking framework will result in a file that automatically generates those formulas for
+you, which you can then use in your pallet.
+
+## Writing Benchmarks
+
+Writing a runtime benchmark is much like writing a unit test for your pallet. It needs to be
+carefully crafted to execute a certain logical path in your code. In tests you want to check for
+various success and failure conditions, but with benchmarks you specifically look for the **most
+computationally heavy** path, a.k.a the "worst case scenario".
+
+This means that if there are certain storage items or runtime state that may affect the complexity
+of the function, for example triggering more iterations in a `for` loop, to get an accurate result,
+you must set up your benchmark to trigger this.
+
+It may be that there are multiple paths your function can go down, and it is not clear which one is
+the heaviest. In this case, you should just create a benchmark for each scenario! You may find that
+there are paths in your code where complexity may become unbounded depending on user input. This may
+be a hint that you should enforce sane boundaries for how a user can use your pallet. For example:
+limiting the number of elements in a vector, limiting the number of iterations in a `for` loop,
+etc...
+
+Examples of end-to-end benchmarks can be found in the [pallets provided by Substrate](../), and the
+specific details on how to use the `benchmarks!` macro can be found in [its
+documentation](./src/lib.rs).
+
+## Testing Benchmarks
+
+You can test your benchmarks using the same test runtime that you created for your pallet's unit
+tests. By creating your benchmarks in the `benchmarks!` macro, it automatically generates test
+functions for you:
+
+```rust
+fn test_benchmark_[benchmark_name]<T>::() -> Result<(), &'static str>
+```
+
+Simply add these functions to a unit test and ensure that the result of the function is `Ok(())`.
+
+> **Note:** If your test runtime and production runtime have different configurations, you may get
+different results when testing your benchmark and actually running it.
+
+In general, benchmarks returning `Ok(())` is all you need to check for since it signals the executed
+extrinsic has completed successfully. However, you can optionally include a `verify` block with your
+benchmark, which can additionally verify any final conditions, such as the final state of your
+runtime.
+
+These additional `verify` blocks will not affect the results of your final benchmarking process.
+
+To run the tests, you need to enable the `runtime-benchmarks` feature flag. This may also mean you
+need to move into your node's binary folder. For example, with the Substrate repository, this is how
+you would test the Balances pallet's benchmarks:
+
+```bash
+cargo test -p pallet-balances --features runtime-benchmarks
+```
+
+> NOTE: Substrate uses a virtual workspace which does not allow you to compile with feature flags.
+> ```
+> error: --features is not allowed in the root of a virtual workspace`
+> ```
+> To solve this, navigate to the folder of the node (`cd bin/node/cli`) or pallet (`cd frame/pallet`) and run the command there.
+
+This will instance each linear component with different values. The number of values per component is set to six and can be changed with the `VALUES_PER_COMPONENT` environment variable.
+
+## Adding Benchmarks
+
+The benchmarks included with each pallet are not automatically added to your node. To actually
+execute these benchmarks, you need to implement the `frame_benchmarking::Benchmark` trait. You can
+see an example of how to do this in the [included Substrate
+node](../../bin/node/runtime/src/lib.rs).
+
+Assuming there are already some benchmarks set up on your node, you just need to add another
+instance of the `add_benchmark!` macro:
+
+```rust
+///  configuration for running benchmarks
+///               |    name of your pallet's crate (as imported)
+///               v                   v
+add_benchmark!(params, batches, pallet_balances, Balances);
+///                       ^                          ^
+///    where all benchmark results are saved         |
+///            the `struct` created for your pallet by `construct_runtime!`
+```
+
+Once you have done this, you will need to compile your node binary with the `runtime-benchmarks`
+feature flag:
+
+```bash
+cd bin/node/cli
+cargo build --profile=production --features runtime-benchmarks
+```
+
+The production profile applies various compiler optimizations.  
+These optimizations slow down the compilation process *a lot*.  
+If you are just testing things out and don't need final numbers, don't include `--profile=production`.
+
+## Running Benchmarks
+
+Finally, once you have a node binary with benchmarks enabled, you need to execute your various
+benchmarks.
+
+You can get a list of the available benchmarks by running:
+
+```bash
+./target/production/substrate benchmark pallet --chain dev --pallet "*" --extrinsic "*" --repeat 0
+```
+
+Then you can run a benchmark like so:
+
+```bash
+./target/production/substrate benchmark pallet \
+    --chain dev \                  # Configurable Chain Spec
+    --wasm-execution=compiled \    # Always used `wasm-time`
+    --pallet pallet_balances \     # Select the pallet
+    --extrinsic transfer \         # Select the extrinsic
+    --steps 50 \                   # Number of samples across component ranges
+    --repeat 20 \                  # Number of times we repeat a benchmark
+    --output <path> \              # Output benchmark results into a folder or file
+```
+
+This will output a file `pallet_name.rs` which implements the `WeightInfo` trait you should include
+in your pallet. Double colons `::` will be replaced with a `_` in the output name if you specify a directory. Each blockchain should generate their own benchmark file with their custom
+implementation of the `WeightInfo` trait. This means that you will be able to use these modular
+Substrate pallets while still keeping your network safe for your specific configuration and
+requirements.
+
+The benchmarking CLI uses a Handlebars template to format the final output file. You can optionally
+pass the flag `--template` pointing to a custom template that can be used instead. Within the
+template, you have access to all the data provided by the `TemplateData` struct in the
+[benchmarking CLI writer](../../utils/frame/benchmarking-cli/src/writer.rs). You can find the
+default template used [here](../../utils/frame/benchmarking-cli/src/template.hbs).
+
+There are some custom Handlebars helpers included with our output generation:
+
+* `underscore`: Add an underscore to every 3rd character from the right of a string. Primarily to be
+used for delimiting large numbers.
+* `join`: Join an array of strings into a space-separated string for the template. Primarily to be
+used for joining all the arguments passed to the CLI.
+
+To get a full list of available options when running benchmarks, run:
+
+```bash
+./target/production/substrate benchmark --help
+```
+
+License: Apache-2.0
diff --git a/substrate/frame/benchmarking/pov/Cargo.toml b/substrate/frame/benchmarking/pov/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2329565893bee5f1448809969491c53afa959aa5
--- /dev/null
+++ b/substrate/frame/benchmarking/pov/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "frame-benchmarking-pallet-pov"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Pallet for testing FRAME PoV benchmarking"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/benchmarking/pov/src/benchmarking.rs b/substrate/frame/benchmarking/pov/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..473947b171ac56b9501d2edba24c0108d91d7cc3
--- /dev/null
+++ b/substrate/frame/benchmarking/pov/src/benchmarking.rs
@@ -0,0 +1,390 @@
+// 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.
+
+//! All benchmarks in this file are just for debugging the PoV calculation logic, they are unused.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use frame_support::traits::UnfilteredDispatchable;
+use frame_system::{Pallet as System, RawOrigin};
+use sp_runtime::traits::Hash;
+
+frame_benchmarking::benchmarks! {
+	storage_single_value_read {
+		Value::<T>::put(123);
+	}: {
+		assert_eq!(Value::<T>::get(), Some(123));
+	}
+
+	#[pov_mode = Ignored]
+	storage_single_value_ignored_read {
+		Value::<T>::put(123);
+	}: {
+		assert_eq!(Value::<T>::get(), Some(123));
+	}
+
+	#[pov_mode = MaxEncodedLen {
+		Pov::Value2: Ignored
+	}]
+	storage_single_value_ignored_some_read {
+		Value::<T>::put(123);
+		Value2::<T>::put(123);
+	}: {
+		assert_eq!(Value::<T>::get(), Some(123));
+		assert_eq!(Value2::<T>::get(), Some(123));
+	}
+
+	storage_single_value_read_twice {
+		Value::<T>::put(123);
+	}: {
+		assert_eq!(Value::<T>::get(), Some(123));
+		assert_eq!(Value::<T>::get(), Some(123));
+	}
+
+	storage_single_value_write {
+	}: {
+		Value::<T>::put(123);
+	} verify {
+		assert_eq!(Value::<T>::get(), Some(123));
+	}
+
+	storage_single_value_kill {
+		Value::<T>::put(123);
+	}: {
+		Value::<T>::kill();
+	} verify {
+		assert!(!Value::<T>::exists());
+	}
+
+	// This benchmark and the following are testing a storage map with adjacent storage items.
+	//
+	// First a storage map is filled and a specific number of other storage items is
+	// created. Then the one value is read from the map. This demonstrates that the number of other
+	// nodes in the Trie influences the proof size. The number of inserted nodes can be interpreted
+	// as the number of `StorageMap`/`StorageValue` in the whole runtime.
+	#[pov_mode = Measured]
+	storage_1m_map_read_one_value_two_additional_layers {
+		(0..(1<<10)).for_each(|i| Map1M::<T>::insert(i, i));
+		// Assume there are 16-256 other storage items.
+		(0..(1u32<<4)).for_each(|i| {
+			let k = T::Hashing::hash(&i.to_be_bytes());
+			frame_support::storage::unhashed::put(k.as_ref(), &i);
+		});
+	}: {
+		assert_eq!(Map1M::<T>::get(1<<9), Some(1<<9));
+	}
+
+	#[pov_mode = Measured]
+	storage_1m_map_read_one_value_three_additional_layers {
+		(0..(1<<10)).for_each(|i| Map1M::<T>::insert(i, i));
+		// Assume there are 256-4096 other storage items.
+		(0..(1u32<<8)).for_each(|i| {
+			let k = T::Hashing::hash(&i.to_be_bytes());
+			frame_support::storage::unhashed::put(k.as_ref(), &i);
+		});
+	}: {
+		assert_eq!(Map1M::<T>::get(1<<9), Some(1<<9));
+	}
+
+	#[pov_mode = Measured]
+	storage_1m_map_read_one_value_four_additional_layers {
+		(0..(1<<10)).for_each(|i| Map1M::<T>::insert(i, i));
+		// Assume there are 4096-65536 other storage items.
+		(0..(1u32<<12)).for_each(|i| {
+			let k = T::Hashing::hash(&i.to_be_bytes());
+			frame_support::storage::unhashed::put(k.as_ref(), &i);
+		});
+	}: {
+		assert_eq!(Map1M::<T>::get(1<<9), Some(1<<9));
+	}
+
+	// Reads from both storage maps each `n` and `m` times. Should result in two linear components.
+	storage_map_read_per_component {
+		let n in 0 .. 100;
+		let m in 0 .. 100;
+
+		(0..m*10).for_each(|i| Map1M::<T>::insert(i, i));
+		(0..n*10).for_each(|i| Map16M::<T>::insert(i, i));
+	}: {
+		(0..m).for_each(|i|
+			assert_eq!(Map1M::<T>::get(i*10), Some(i*10)));
+		(0..n).for_each(|i|
+			assert_eq!(Map16M::<T>::get(i*10), Some(i*10)));
+	}
+
+	#[pov_mode = MaxEncodedLen {
+		Pov::Map1M: Ignored
+	}]
+	storage_map_read_per_component_one_ignored {
+		let n in 0 .. 100;
+		let m in 0 .. 100;
+
+		(0..m*10).for_each(|i| Map1M::<T>::insert(i, i));
+		(0..n*10).for_each(|i| Map16M::<T>::insert(i, i));
+	}: {
+		(0..m).for_each(|i|
+			assert_eq!(Map1M::<T>::get(i*10), Some(i*10)));
+		(0..n).for_each(|i|
+			assert_eq!(Map16M::<T>::get(i*10), Some(i*10)));
+	}
+
+	// Reads the same value from a storage map. Should not result in a component.
+	storage_1m_map_one_entry_repeated_read {
+		let n in 0 .. 100;
+		Map1M::<T>::insert(0, 0);
+	}: {
+		(0..n).for_each(|i|
+			assert_eq!(Map1M::<T>::get(0), Some(0)));
+	}
+
+	// Reads the same values from a storage map. Should result in a `1x` linear component.
+	storage_1m_map_multiple_entry_repeated_read {
+		let n in 0 .. 100;
+		(0..n).for_each(|i| Map1M::<T>::insert(i, i));
+	}: {
+		(0..n).for_each(|i| {
+			// Reading the same value 10 times does nothing.
+			(0..10).for_each(|j|
+				assert_eq!(Map1M::<T>::get(i), Some(i)));
+		});
+	}
+
+	storage_1m_double_map_read_per_component {
+		let n in 0 .. 1024;
+		(0..(1<<10)).for_each(|i| DoubleMap1M::<T>::insert(i, i, i));
+	}: {
+		(0..n).for_each(|i|
+			assert_eq!(DoubleMap1M::<T>::get(i, i), Some(i)));
+	}
+
+	storage_value_bounded_read {
+	}: {
+		assert!(BoundedValue::<T>::get().is_none());
+	}
+
+	// Reading unbounded values will produce no mathematical worst case PoV size for this component.
+	storage_value_unbounded_read {
+	}: {
+		assert!(UnboundedValue::<T>::get().is_none());
+	}
+
+	#[pov_mode = Ignored]
+	storage_value_unbounded_ignored_read {
+	}: {
+		assert!(UnboundedValue::<T>::get().is_none());
+	}
+
+	// Same as above, but we still expect a mathematical worst case PoV size for the bounded one.
+	storage_value_bounded_and_unbounded_read {
+		(0..1024).for_each(|i| Map1M::<T>::insert(i, i));
+	}: {
+		assert!(UnboundedValue::<T>::get().is_none());
+		assert!(BoundedValue::<T>::get().is_none());
+	}
+
+	#[pov_mode = Measured]
+	measured_storage_value_read_linear_size {
+		let l in 0 .. 1<<22;
+		let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+	}: {
+		assert!(LargeValue::<T>::get().is_some());
+	}
+
+	#[pov_mode = MaxEncodedLen]
+	mel_storage_value_read_linear_size {
+		let l in 0 .. 1<<22;
+		let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+	}: {
+		assert!(LargeValue::<T>::get().is_some());
+	}
+
+	#[pov_mode = Measured]
+	measured_storage_double_value_read_linear_size {
+		let l in 0 .. 1<<22;
+		let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+	}: {
+		assert!(LargeValue::<T>::get().is_some());
+		assert!(LargeValue2::<T>::get().is_some());
+	}
+
+	#[pov_mode = MaxEncodedLen]
+	mel_storage_double_value_read_linear_size {
+		let l in 0 .. 1<<22;
+		let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+	}: {
+		assert!(LargeValue::<T>::get().is_some());
+		assert!(LargeValue2::<T>::get().is_some());
+	}
+
+	#[pov_mode = MaxEncodedLen {
+		Pov::LargeValue2: Measured
+	}]
+	mel_mixed_storage_double_value_read_linear_size {
+		let l in 0 .. 1<<22;
+		let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+	}: {
+		assert!(LargeValue::<T>::get().is_some());
+		assert!(LargeValue2::<T>::get().is_some());
+	}
+
+	#[pov_mode = Measured {
+		Pov::LargeValue2: MaxEncodedLen
+	}]
+	measured_mixed_storage_double_value_read_linear_size {
+		let l in 0 .. 1<<22;
+		let v: sp_runtime::BoundedVec<u8, _> = sp_std::vec![0u8; l as usize].try_into().unwrap();
+		LargeValue::<T>::put(&v);
+		LargeValue2::<T>::put(&v);
+	}: {
+		assert!(LargeValue::<T>::get().is_some());
+		assert!(LargeValue2::<T>::get().is_some());
+	}
+
+	#[pov_mode = Measured]
+	storage_map_unbounded_both_measured_read {
+		let i in 0 .. 1000;
+
+		UnboundedMap::<T>::insert(i, sp_std::vec![0; i as usize]);
+		UnboundedMap2::<T>::insert(i, sp_std::vec![0; i as usize]);
+	}: {
+		assert!(UnboundedMap::<T>::get(i).is_some());
+		assert!(UnboundedMap2::<T>::get(i).is_some());
+	}
+
+	#[pov_mode = MaxEncodedLen {
+		Pov::UnboundedMap: Measured
+	}]
+	storage_map_partial_unbounded_read {
+		let i in 0 .. 1000;
+
+		Map1M::<T>::insert(i, 0);
+		UnboundedMap::<T>::insert(i, sp_std::vec![0; i as usize]);
+	}: {
+		assert!(Map1M::<T>::get(i).is_some());
+		assert!(UnboundedMap::<T>::get(i).is_some());
+	}
+
+	#[pov_mode = MaxEncodedLen {
+		Pov::UnboundedMap: Ignored
+	}]
+	storage_map_partial_unbounded_ignored_read {
+		let i in 0 .. 1000;
+
+		Map1M::<T>::insert(i, 0);
+		UnboundedMap::<T>::insert(i, sp_std::vec![0; i as usize]);
+	}: {
+		assert!(Map1M::<T>::get(i).is_some());
+		assert!(UnboundedMap::<T>::get(i).is_some());
+	}
+
+	// Emitting an event will not incur any PoV.
+	emit_event {
+		// Emit a single event.
+		let call = Call::<T>::emit_event {  };
+	}: { call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap(); }
+	verify {
+		assert_eq!(System::<T>::events().len(), 1);
+	}
+
+	// A No-OP will not incur any PoV.
+	noop {
+		let call = Call::<T>::noop { };
+	}: {
+		call.dispatch_bypass_filter(RawOrigin::Root.into()).unwrap();
+	}
+
+	storage_iteration {
+		for i in 0..65000 {
+			UnboundedMapTwox::<T>::insert(i, sp_std::vec![0; 64]);
+		}
+	}: {
+		for (key, value) in UnboundedMapTwox::<T>::iter() {
+			unsafe {
+				core::ptr::read_volatile(&key);
+				core::ptr::read_volatile(value.as_ptr());
+			}
+		}
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		mock::new_test_ext(),
+		mock::Test,
+	);
+}
+
+#[cfg(test)]
+mod mock {
+	use sp_runtime::{testing::H256, BuildStorage};
+
+	type AccountId = u64;
+	type Nonce = u32;
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+			Baseline: crate::{Pallet, Call, Storage, Event<T>},
+		}
+	);
+
+	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 = 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 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 {
+		type RuntimeEvent = RuntimeEvent;
+	}
+
+	pub fn new_test_ext() -> sp_io::TestExternalities {
+		frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+	}
+}
diff --git a/substrate/frame/benchmarking/pov/src/lib.rs b/substrate/frame/benchmarking/pov/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb02ccc983c09fd5084a174d07cdc10fd5ecac22
--- /dev/null
+++ b/substrate/frame/benchmarking/pov/src/lib.rs
@@ -0,0 +1,135 @@
+// 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.
+
+//! End-to-end testing pallet for PoV benchmarking. Should only be deployed in a  testing runtime.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod tests;
+mod weights;
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+	use sp_std::prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::storage]
+	pub(crate) type Value<T: Config> = StorageValue<Value = u32, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	pub(crate) type Value2<T: Config> = StorageValue<Value = u32, QueryKind = OptionQuery>;
+
+	/// A value without a MEL bound.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedValue<T: Config> =
+		StorageValue<Value = Vec<u8>, QueryKind = OptionQuery>;
+
+	/// A value with a MEL bound of 32 byte.
+	#[pallet::storage]
+	pub(crate) type BoundedValue<T: Config> =
+		StorageValue<Value = BoundedVec<u8, ConstU32<32>>, QueryKind = OptionQuery>;
+
+	/// 4MiB value.
+	#[pallet::storage]
+	pub(crate) type LargeValue<T: Config> =
+		StorageValue<Value = BoundedVec<u8, ConstU32<{ 1 << 22 }>>, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	pub(crate) type LargeValue2<T: Config> =
+		StorageValue<Value = BoundedVec<u8, ConstU32<{ 1 << 22 }>>, QueryKind = OptionQuery>;
+
+	/// A map with a maximum of 1M entries.
+	#[pallet::storage]
+	pub(crate) type Map1M<T: Config> = StorageMap<
+		Hasher = Blake2_256,
+		Key = u32,
+		Value = u32,
+		QueryKind = OptionQuery,
+		MaxValues = ConstU32<1_000_000>,
+	>;
+
+	/// A map with a maximum of 16M entries.
+	#[pallet::storage]
+	pub(crate) type Map16M<T: Config> = StorageMap<
+		Hasher = Blake2_256,
+		Key = u32,
+		Value = u32,
+		QueryKind = OptionQuery,
+		MaxValues = ConstU32<16_000_000>,
+	>;
+
+	#[pallet::storage]
+	pub(crate) type DoubleMap1M<T: Config> = StorageDoubleMap<
+		Hasher1 = Blake2_256,
+		Hasher2 = Blake2_256,
+		Key1 = u32,
+		Key2 = u32,
+		Value = u32,
+		QueryKind = OptionQuery,
+		MaxValues = ConstU32<1_000_000>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedMap<T: Config> =
+		StorageMap<Hasher = Blake2_256, Key = u32, Value = Vec<u32>, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedMap2<T: Config> =
+		StorageMap<Hasher = Blake2_256, Key = u32, Value = Vec<u32>, QueryKind = OptionQuery>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type UnboundedMapTwox<T: Config> =
+		StorageMap<Hasher = Twox64Concat, Key = u32, Value = Vec<u32>, QueryKind = OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		TestEvent,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight({0})]
+		pub fn emit_event(_origin: OriginFor<T>) -> DispatchResult {
+			Self::deposit_event(Event::TestEvent);
+			Ok(())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight({0})]
+		pub fn noop(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/benchmarking/pov/src/tests.rs b/substrate/frame/benchmarking/pov/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f09e37a5288a99da74076ee3183fe049d29690c4
--- /dev/null
+++ b/substrate/frame/benchmarking/pov/src/tests.rs
@@ -0,0 +1,206 @@
+// 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.
+
+//! Test the produces weight functions.
+
+#![cfg(test)]
+
+use super::weights::WeightInfo;
+use mock::Test as T;
+type W = crate::weights::SubstrateWeight<T>;
+
+#[test]
+fn writing_is_free() {
+	let w = W::storage_single_value_write().proof_size();
+	assert_eq!(w, 0, "Writing is free");
+}
+
+#[test]
+fn killing_is_free() {
+	// NOTE: This only applies to state version 1.
+	let w = W::storage_single_value_kill().proof_size();
+	assert_eq!(w, 0, "Killing is free");
+}
+
+#[test]
+fn reading_twice_is_the_same_as_once() {
+	let w = W::storage_single_value_read().proof_size();
+	let w2 = W::storage_single_value_read_twice().proof_size();
+	assert_eq!(w, w2, "Reading twice is the same as once");
+}
+
+#[test]
+fn storage_single_value_ignored_read_no_pov() {
+	let w = W::storage_single_value_ignored_read();
+	assert_eq!(w.proof_size(), 0, "Ignored PoV does not result in PoV");
+}
+
+#[test]
+fn storage_single_value_ignored_some_read_has_pov() {
+	let w = W::storage_single_value_ignored_some_read();
+	assert!(w.proof_size() != 0, "Ignored some does result in PoV");
+}
+
+/// Reading the same value from a map does not increase the PoV.
+#[test]
+fn storage_1m_map_one_entry_repeated_read_const() {
+	let weight = W::storage_1m_map_one_entry_repeated_read;
+	let w0 = weight(0).proof_size();
+	assert!(w0 > 0, "There is a base weight");
+
+	let w1 = weight(1).proof_size();
+	assert_eq!(w0, w1, "Component does not matter");
+}
+
+/// Reading multiple values multiple times from a map increases the PoV by the number of reads.
+#[test]
+fn storage_1m_map_multiple_entry_repeated_read_single_linear() {
+	let weight = W::storage_1m_map_multiple_entry_repeated_read;
+	let w0 = weight(0).proof_size();
+
+	let w1 = weight(1).proof_size() - w0;
+	assert!(w1 > 0, "Component matters");
+
+	let wm = weight(1000).proof_size();
+	assert_eq!(w1 * 1000 + w0, wm, "x scales linearly");
+}
+
+/// Check that reading two maps at once increases the PoV linearly per map.
+#[test]
+fn storage_map_read_per_component_double_linear() {
+	let weight = W::storage_map_read_per_component;
+	let w00 = weight(0, 0).proof_size();
+
+	let w10 = weight(1, 0).proof_size() - w00;
+	let w01 = weight(0, 1).proof_size() - w00;
+	assert!(w10 > 0 && w01 > 0, "Components matter");
+	assert!(w10 != w01, "Each map has its own component");
+
+	let wm0 = weight(1000, 0).proof_size();
+	let w0m = weight(0, 1000).proof_size();
+	assert_eq!(w00 + w10 * 1000, wm0, "x scales linearly");
+	assert_eq!(w00 + w01 * 1000, w0m, "y scales linearly");
+
+	let wmm = weight(1000, 1000).proof_size();
+	assert_eq!(wmm + w00, wm0 + w0m, "x + y scales linearly");
+}
+
+/// The proof size estimation takes the measured sizes into account and therefore increases with the
+/// number of layers.
+#[test]
+fn additional_layers_do_not_matter() {
+	let w2 = W::storage_1m_map_read_one_value_two_additional_layers().proof_size();
+	let w3 = W::storage_1m_map_read_one_value_three_additional_layers().proof_size();
+	let w4 = W::storage_1m_map_read_one_value_four_additional_layers().proof_size();
+	assert!(w3 > w2 && w4 > w3, "Additional layers do matter");
+}
+
+/// Check that the measured value size instead of the MEL is used.
+#[test]
+fn linear_measured_size_works() {
+	let weight = W::measured_storage_value_read_linear_size;
+
+	let w0 = weight(0).proof_size();
+	let w1 = weight(1).proof_size() - w0;
+
+	assert_eq!(w1, 1, "x scales with a factor of 1");
+	let wm = weight(1000).proof_size();
+	assert_eq!(w1 * 1000 + w0, wm, "x scales linearly");
+}
+
+// vice-versa of above `linear_measured_size_works`.
+#[test]
+fn linear_mel_size_works() {
+	let weight = W::mel_storage_value_read_linear_size;
+
+	let w1 = weight(1).proof_size();
+	let wm = weight(1000).proof_size();
+	assert_eq!(w1, wm, "PoV size is const");
+}
+
+/// Although there is no estimation possible, it uses the recorded proof size as best effort.
+#[test]
+fn unbounded_read_best_effort() {
+	let w = W::storage_value_unbounded_read().proof_size();
+	assert!(w > 0, "There is a weight");
+}
+
+/// For mixed unbounded and bounded reads, the bounded part still increases the PoV.
+#[test]
+fn partial_unbounded_read_best_effort() {
+	let w_unbounded = W::storage_value_unbounded_read().proof_size();
+	let w_bounded = W::storage_value_bounded_read().proof_size();
+	let w_both = W::storage_value_bounded_and_unbounded_read().proof_size();
+
+	assert!(w_both > w_bounded && w_both > w_unbounded, "The bounded part increases the PoV");
+}
+
+#[test]
+fn emit_event_is_free() {
+	let w = W::emit_event().proof_size();
+	assert_eq!(w, 0, "Emitting an event is free");
+}
+
+#[test]
+fn noop_is_free() {
+	let w = W::noop().proof_size();
+	assert_eq!(w, 0, "Noop is free");
+}
+
+mod mock {
+	use sp_runtime::testing::H256;
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+			Baseline: crate::{Pallet, Call, Storage, Event<T>},
+		}
+	);
+
+	impl frame_system::Config for Test {
+		type BaseCallFilter = frame_support::traits::Everything;
+		type BlockWeights = ();
+		type BlockLength = ();
+		type DbWeight = ();
+		type RuntimeOrigin = RuntimeOrigin;
+		type Nonce = u32;
+		type RuntimeCall = RuntimeCall;
+		type Hash = H256;
+		type Hashing = ::sp_runtime::traits::BlakeTwo256;
+		type AccountId = u32;
+		type Lookup = sp_runtime::traits::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 {
+		type RuntimeEvent = RuntimeEvent;
+	}
+}
diff --git a/substrate/frame/benchmarking/pov/src/weights.rs b/substrate/frame/benchmarking/pov/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f16ac7fbc2733c1064664e2cefb88128fb55b7ca
--- /dev/null
+++ b/substrate/frame/benchmarking/pov/src/weights.rs
@@ -0,0 +1,832 @@
+
+//! Autogenerated weights for frame_benchmarking_pallet_pov
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-04-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `i9`, CPU: `13th Gen Intel(R) Core(TM) i9-13900K`
+//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: None, DB CACHE: 1024
+
+// Executed Command:
+// ./target/release/substrate
+// benchmark
+// pallet
+// --dev
+// --pallet
+// frame-benchmarking-pallet-pov
+// --extrinsic
+// 
+// --steps
+// 50
+// --repeat
+// 20
+// --template=.maintain/frame-weight-template.hbs
+// --output=frame/benchmarking/pov/src/weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for frame_benchmarking_pallet_pov.
+pub trait WeightInfo {
+	fn storage_single_value_read() -> Weight;
+	fn storage_single_value_ignored_read() -> Weight;
+	fn storage_single_value_ignored_some_read() -> Weight;
+	fn storage_single_value_read_twice() -> Weight;
+	fn storage_single_value_write() -> Weight;
+	fn storage_single_value_kill() -> Weight;
+	fn storage_1m_map_read_one_value_two_additional_layers() -> Weight;
+	fn storage_1m_map_read_one_value_three_additional_layers() -> Weight;
+	fn storage_1m_map_read_one_value_four_additional_layers() -> Weight;
+	fn storage_map_read_per_component(n: u32, m: u32, ) -> Weight;
+	fn storage_map_read_per_component_one_ignored(n: u32, m: u32, ) -> Weight;
+	fn storage_1m_map_one_entry_repeated_read(n: u32, ) -> Weight;
+	fn storage_1m_map_multiple_entry_repeated_read(n: u32, ) -> Weight;
+	fn storage_1m_double_map_read_per_component(n: u32, ) -> Weight;
+	fn storage_value_bounded_read() -> Weight;
+	fn storage_value_unbounded_read() -> Weight;
+	fn storage_value_unbounded_ignored_read() -> Weight;
+	fn storage_value_bounded_and_unbounded_read() -> Weight;
+	fn measured_storage_value_read_linear_size(l: u32, ) -> Weight;
+	fn mel_storage_value_read_linear_size(l: u32, ) -> Weight;
+	fn measured_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn mel_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn mel_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn measured_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight;
+	fn storage_map_unbounded_both_measured_read(i: u32, ) -> Weight;
+	fn storage_map_partial_unbounded_read(i: u32, ) -> Weight;
+	fn storage_map_partial_unbounded_ignored_read(i: u32, ) -> Weight;
+	fn emit_event() -> Weight;
+	fn noop() -> Weight;
+	fn storage_iteration() -> Weight;
+}
+
+/// Weights for frame_benchmarking_pallet_pov using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `136`
+		//  Estimated: `1489`
+		// Minimum execution time: 1_706_000 picoseconds.
+		Weight::from_parts(1_788_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: Ignored)
+	fn storage_single_value_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `136`
+		//  Estimated: `0`
+		// Minimum execution time: 1_661_000 picoseconds.
+		Weight::from_parts(1_718_000, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Pov Value2 (r:1 w:0)
+	/// Proof: Pov Value2 (max_values: Some(1), max_size: Some(4), added: 499, mode: Ignored)
+	fn storage_single_value_ignored_some_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `160`
+		//  Estimated: `1489`
+		// Minimum execution time: 2_226_000 picoseconds.
+		Weight::from_parts(2_365_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_read_twice() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `136`
+		//  Estimated: `1489`
+		// Minimum execution time: 1_785_000 picoseconds.
+		Weight::from_parts(1_980_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Value (r:0 w:1)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_write() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 254_000 picoseconds.
+		Weight::from_parts(326_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Pov Value (r:0 w:1)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_kill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 239_000 picoseconds.
+		Weight::from_parts(277_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Measured)
+	fn storage_1m_map_read_one_value_two_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1275`
+		//  Estimated: `4740`
+		// Minimum execution time: 4_760_000 picoseconds.
+		Weight::from_parts(5_051_000, 4740)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Measured)
+	fn storage_1m_map_read_one_value_three_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1544`
+		//  Estimated: `5009`
+		// Minimum execution time: 5_490_000 picoseconds.
+		Weight::from_parts(5_703_000, 5009)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Measured)
+	fn storage_1m_map_read_one_value_four_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2044`
+		//  Estimated: `5509`
+		// Minimum execution time: 6_397_000 picoseconds.
+		Weight::from_parts(7_084_000, 5509)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:100 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// Storage: Pov Map16M (r:100 w:0)
+	/// Proof: Pov Map16M (max_values: Some(16000000), max_size: Some(36), added: 3006, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `990 + m * (2511 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 181_481_000 picoseconds.
+		Weight::from_parts(129_275_141, 990)
+			// Standard Error: 13_049
+			.saturating_add(Weight::from_parts(787_667, 0).saturating_mul(n.into()))
+			// Standard Error: 13_049
+			.saturating_add(Weight::from_parts(830_378, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: Pov Map1M (r:100 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Ignored)
+	/// Storage: Pov Map16M (r:100 w:0)
+	/// Proof: Pov Map16M (max_values: Some(16000000), max_size: Some(36), added: 3006, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component_one_ignored(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `1685 + m * (189 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 181_925_000 picoseconds.
+		Weight::from_parts(134_416_814, 1685)
+			// Standard Error: 15_678
+			.saturating_add(Weight::from_parts(827_168, 0).saturating_mul(n.into()))
+			// Standard Error: 15_678
+			.saturating_add(Weight::from_parts(813_655, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 189).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_one_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `170`
+		//  Estimated: `3501`
+		// Minimum execution time: 20_000 picoseconds.
+		Weight::from_parts(2_006_399, 3501)
+			// Standard Error: 808
+			.saturating_add(Weight::from_parts(263_609, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:100 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_multiple_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147 + n * (40 ±0)`
+		//  Estimated: `990 + n * (2511 ±0)`
+		// Minimum execution time: 21_000 picoseconds.
+		Weight::from_parts(3_940_044, 990)
+			// Standard Error: 4_906
+			.saturating_add(Weight::from_parts(3_454_882, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(n.into()))
+	}
+	/// Storage: Pov DoubleMap1M (r:1024 w:0)
+	/// Proof: Pov DoubleMap1M (max_values: Some(1000000), max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1024]`.
+	fn storage_1m_double_map_read_per_component(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `21938 + n * (57 ±0)`
+		//  Estimated: `990 + n * (2543 ±0)`
+		// Minimum execution time: 28_000 picoseconds.
+		Weight::from_parts(20_674_869, 990)
+			// Standard Error: 3_035
+			.saturating_add(Weight::from_parts(1_995_730, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2543).saturating_mul(n.into()))
+	}
+	/// Storage: Pov BoundedValue (r:1 w:0)
+	/// Proof: Pov BoundedValue (max_values: Some(1), max_size: Some(33), added: 528, mode: MaxEncodedLen)
+	fn storage_value_bounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `1518`
+		// Minimum execution time: 1_091_000 picoseconds.
+		Weight::from_parts(1_181_000, 1518)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov UnboundedValue (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedValue (max_values: Some(1), max_size: None, mode: Measured)
+	fn storage_value_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `1594`
+		// Minimum execution time: 1_079_000 picoseconds.
+		Weight::from_parts(1_176_000, 1594)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov UnboundedValue (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedValue (max_values: Some(1), max_size: None, mode: Ignored)
+	fn storage_value_unbounded_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `0`
+		// Minimum execution time: 1_101_000 picoseconds.
+		Weight::from_parts(1_160_000, 0)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov UnboundedValue (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedValue (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Pov BoundedValue (r:1 w:0)
+	/// Proof: Pov BoundedValue (max_values: Some(1), max_size: Some(33), added: 528, mode: MaxEncodedLen)
+	fn storage_value_bounded_and_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147`
+		//  Estimated: `1632`
+		// Minimum execution time: 2_143_000 picoseconds.
+		Weight::from_parts(2_280_000, 1632)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142 + l * (1 ±0)`
+		//  Estimated: `1626 + l * (1 ±0)`
+		// Minimum execution time: 1_665_000 picoseconds.
+		Weight::from_parts(1_725_000, 1626)
+			// Standard Error: 3
+			.saturating_add(Weight::from_parts(376, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(l.into()))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142 + l * (1 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 1_640_000 picoseconds.
+		Weight::from_parts(1_724_000, 4195793)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(395, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `1655 + l * (2 ±0)`
+		// Minimum execution time: 2_263_000 picoseconds.
+		Weight::from_parts(2_358_000, 1655)
+			// Standard Error: 8
+			.saturating_add(Weight::from_parts(737, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 2_161_000 picoseconds.
+		Weight::from_parts(2_233_000, 4195793)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(639, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 2_149_000 picoseconds.
+		Weight::from_parts(2_256_000, 4195793)
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(677, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 2_254_000 picoseconds.
+		Weight::from_parts(2_319_000, 4195793)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(664, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: Pov UnboundedMap (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Pov UnboundedMap2 (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap2 (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_unbounded_both_measured_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `229 + i * (8 ±0)`
+		//  Estimated: `3693 + i * (8 ±0)`
+		// Minimum execution time: 3_071_000 picoseconds.
+		Weight::from_parts(3_487_712, 3693)
+			// Standard Error: 26
+			.saturating_add(Weight::from_parts(748, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 8).saturating_mul(i.into()))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// Storage: Pov UnboundedMap (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `228 + i * (4 ±0)`
+		//  Estimated: `3692 + i * (4 ±0)`
+		// Minimum execution time: 3_150_000 picoseconds.
+		Weight::from_parts(3_582_963, 3692)
+			// Standard Error: 18
+			.saturating_add(Weight::from_parts(380, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// Storage: Pov UnboundedMap (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap (max_values: None, max_size: None, mode: Ignored)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_ignored_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `228 + i * (4 ±0)`
+		//  Estimated: `3501 + i * (4 ±0)`
+		// Minimum execution time: 3_092_000 picoseconds.
+		Weight::from_parts(3_595_328, 3501)
+			// Standard Error: 20
+			.saturating_add(Weight::from_parts(243, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	fn emit_event() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_705_000 picoseconds.
+		Weight::from_parts(1_818_000, 0)
+	}
+	fn noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 533_000 picoseconds.
+		Weight::from_parts(587_000, 0)
+	}
+	/// Storage: Pov UnboundedMapTwox (r:65001 w:0)
+	/// Proof Skipped: Pov UnboundedMapTwox (max_values: None, max_size: None, mode: Measured)
+	fn storage_iteration() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `17985289`
+		//  Estimated: `178863754`
+		// Minimum execution time: 118_753_057_000 picoseconds.
+		Weight::from_parts(121_396_503_000, 178863754)
+			.saturating_add(T::DbWeight::get().reads(65001_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `136`
+		//  Estimated: `1489`
+		// Minimum execution time: 1_706_000 picoseconds.
+		Weight::from_parts(1_788_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: Ignored)
+	fn storage_single_value_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `136`
+		//  Estimated: `0`
+		// Minimum execution time: 1_661_000 picoseconds.
+		Weight::from_parts(1_718_000, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Pov Value2 (r:1 w:0)
+	/// Proof: Pov Value2 (max_values: Some(1), max_size: Some(4), added: 499, mode: Ignored)
+	fn storage_single_value_ignored_some_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `160`
+		//  Estimated: `1489`
+		// Minimum execution time: 2_226_000 picoseconds.
+		Weight::from_parts(2_365_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: Pov Value (r:1 w:0)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_read_twice() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `136`
+		//  Estimated: `1489`
+		// Minimum execution time: 1_785_000 picoseconds.
+		Weight::from_parts(1_980_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Value (r:0 w:1)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_write() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 254_000 picoseconds.
+		Weight::from_parts(326_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Pov Value (r:0 w:1)
+	/// Proof: Pov Value (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn storage_single_value_kill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 239_000 picoseconds.
+		Weight::from_parts(277_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Measured)
+	fn storage_1m_map_read_one_value_two_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1275`
+		//  Estimated: `4740`
+		// Minimum execution time: 4_760_000 picoseconds.
+		Weight::from_parts(5_051_000, 4740)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Measured)
+	fn storage_1m_map_read_one_value_three_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1544`
+		//  Estimated: `5009`
+		// Minimum execution time: 5_490_000 picoseconds.
+		Weight::from_parts(5_703_000, 5009)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Measured)
+	fn storage_1m_map_read_one_value_four_additional_layers() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2044`
+		//  Estimated: `5509`
+		// Minimum execution time: 6_397_000 picoseconds.
+		Weight::from_parts(7_084_000, 5509)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:100 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// Storage: Pov Map16M (r:100 w:0)
+	/// Proof: Pov Map16M (max_values: Some(16000000), max_size: Some(36), added: 3006, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `990 + m * (2511 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 181_481_000 picoseconds.
+		Weight::from_parts(129_275_141, 990)
+			// Standard Error: 13_049
+			.saturating_add(Weight::from_parts(787_667, 0).saturating_mul(n.into()))
+			// Standard Error: 13_049
+			.saturating_add(Weight::from_parts(830_378, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: Pov Map1M (r:100 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: Ignored)
+	/// Storage: Pov Map16M (r:100 w:0)
+	/// Proof: Pov Map16M (max_values: Some(16000000), max_size: Some(36), added: 3006, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `m` is `[0, 100]`.
+	fn storage_map_read_per_component_one_ignored(n: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `515 + m * (188 ±0) + n * (188 ±0)`
+		//  Estimated: `1685 + m * (189 ±0) + n * (3006 ±0)`
+		// Minimum execution time: 181_925_000 picoseconds.
+		Weight::from_parts(134_416_814, 1685)
+			// Standard Error: 15_678
+			.saturating_add(Weight::from_parts(827_168, 0).saturating_mul(n.into()))
+			// Standard Error: 15_678
+			.saturating_add(Weight::from_parts(813_655, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(Weight::from_parts(0, 189).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 3006).saturating_mul(n.into()))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_one_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `170`
+		//  Estimated: `3501`
+		// Minimum execution time: 20_000 picoseconds.
+		Weight::from_parts(2_006_399, 3501)
+			// Standard Error: 808
+			.saturating_add(Weight::from_parts(263_609, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov Map1M (r:100 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	fn storage_1m_map_multiple_entry_repeated_read(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147 + n * (40 ±0)`
+		//  Estimated: `990 + n * (2511 ±0)`
+		// Minimum execution time: 21_000 picoseconds.
+		Weight::from_parts(3_940_044, 990)
+			// Standard Error: 4_906
+			.saturating_add(Weight::from_parts(3_454_882, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2511).saturating_mul(n.into()))
+	}
+	/// Storage: Pov DoubleMap1M (r:1024 w:0)
+	/// Proof: Pov DoubleMap1M (max_values: Some(1000000), max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1024]`.
+	fn storage_1m_double_map_read_per_component(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `21938 + n * (57 ±0)`
+		//  Estimated: `990 + n * (2543 ±0)`
+		// Minimum execution time: 28_000 picoseconds.
+		Weight::from_parts(20_674_869, 990)
+			// Standard Error: 3_035
+			.saturating_add(Weight::from_parts(1_995_730, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2543).saturating_mul(n.into()))
+	}
+	/// Storage: Pov BoundedValue (r:1 w:0)
+	/// Proof: Pov BoundedValue (max_values: Some(1), max_size: Some(33), added: 528, mode: MaxEncodedLen)
+	fn storage_value_bounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `1518`
+		// Minimum execution time: 1_091_000 picoseconds.
+		Weight::from_parts(1_181_000, 1518)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov UnboundedValue (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedValue (max_values: Some(1), max_size: None, mode: Measured)
+	fn storage_value_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `1594`
+		// Minimum execution time: 1_079_000 picoseconds.
+		Weight::from_parts(1_176_000, 1594)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov UnboundedValue (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedValue (max_values: Some(1), max_size: None, mode: Ignored)
+	fn storage_value_unbounded_ignored_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `0`
+		// Minimum execution time: 1_101_000 picoseconds.
+		Weight::from_parts(1_160_000, 0)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov UnboundedValue (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedValue (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Pov BoundedValue (r:1 w:0)
+	/// Proof: Pov BoundedValue (max_values: Some(1), max_size: Some(33), added: 528, mode: MaxEncodedLen)
+	fn storage_value_bounded_and_unbounded_read() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147`
+		//  Estimated: `1632`
+		// Minimum execution time: 2_143_000 picoseconds.
+		Weight::from_parts(2_280_000, 1632)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142 + l * (1 ±0)`
+		//  Estimated: `1626 + l * (1 ±0)`
+		// Minimum execution time: 1_665_000 picoseconds.
+		Weight::from_parts(1_725_000, 1626)
+			// Standard Error: 3
+			.saturating_add(Weight::from_parts(376, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(l.into()))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142 + l * (1 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 1_640_000 picoseconds.
+		Weight::from_parts(1_724_000, 4195793)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(395, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `1655 + l * (2 ±0)`
+		// Minimum execution time: 2_263_000 picoseconds.
+		Weight::from_parts(2_358_000, 1655)
+			// Standard Error: 8
+			.saturating_add(Weight::from_parts(737, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `4195793`
+		// Minimum execution time: 2_161_000 picoseconds.
+		Weight::from_parts(2_233_000, 4195793)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(639, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn mel_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 2_149_000 picoseconds.
+		Weight::from_parts(2_256_000, 4195793)
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(677, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: Pov LargeValue (r:1 w:0)
+	/// Proof: Pov LargeValue (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: Measured)
+	/// Storage: Pov LargeValue2 (r:1 w:0)
+	/// Proof: Pov LargeValue2 (max_values: Some(1), max_size: Some(4194308), added: 4194803, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 4194304]`.
+	fn measured_mixed_storage_double_value_read_linear_size(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + l * (2 ±0)`
+		//  Estimated: `4195793 + l * (2 ±0)`
+		// Minimum execution time: 2_254_000 picoseconds.
+		Weight::from_parts(2_319_000, 4195793)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(664, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 2).saturating_mul(l.into()))
+	}
+	/// Storage: Pov UnboundedMap (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Pov UnboundedMap2 (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap2 (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_unbounded_both_measured_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `229 + i * (8 ±0)`
+		//  Estimated: `3693 + i * (8 ±0)`
+		// Minimum execution time: 3_071_000 picoseconds.
+		Weight::from_parts(3_487_712, 3693)
+			// Standard Error: 26
+			.saturating_add(Weight::from_parts(748, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 8).saturating_mul(i.into()))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// Storage: Pov UnboundedMap (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `228 + i * (4 ±0)`
+		//  Estimated: `3692 + i * (4 ±0)`
+		// Minimum execution time: 3_150_000 picoseconds.
+		Weight::from_parts(3_582_963, 3692)
+			// Standard Error: 18
+			.saturating_add(Weight::from_parts(380, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	/// Storage: Pov Map1M (r:1 w:0)
+	/// Proof: Pov Map1M (max_values: Some(1000000), max_size: Some(36), added: 2511, mode: MaxEncodedLen)
+	/// Storage: Pov UnboundedMap (r:1 w:0)
+	/// Proof Skipped: Pov UnboundedMap (max_values: None, max_size: None, mode: Ignored)
+	/// The range of component `i` is `[0, 1000]`.
+	fn storage_map_partial_unbounded_ignored_read(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `228 + i * (4 ±0)`
+		//  Estimated: `3501 + i * (4 ±0)`
+		// Minimum execution time: 3_092_000 picoseconds.
+		Weight::from_parts(3_595_328, 3501)
+			// Standard Error: 20
+			.saturating_add(Weight::from_parts(243, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(i.into()))
+	}
+	fn emit_event() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_705_000 picoseconds.
+		Weight::from_parts(1_818_000, 0)
+	}
+	fn noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 533_000 picoseconds.
+		Weight::from_parts(587_000, 0)
+	}
+	/// Storage: Pov UnboundedMapTwox (r:65001 w:0)
+	/// Proof Skipped: Pov UnboundedMapTwox (max_values: None, max_size: None, mode: Measured)
+	fn storage_iteration() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `17985289`
+		//  Estimated: `178863754`
+		// Minimum execution time: 118_753_057_000 picoseconds.
+		Weight::from_parts(121_396_503_000, 178863754)
+			.saturating_add(RocksDbWeight::get().reads(65001_u64))
+	}
+}
diff --git a/substrate/frame/benchmarking/src/analysis.rs b/substrate/frame/benchmarking/src/analysis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5fc3abb5a27f0f2c2bcaadc2c6e71fbd603c0470
--- /dev/null
+++ b/substrate/frame/benchmarking/src/analysis.rs
@@ -0,0 +1,769 @@
+// 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.
+
+//! Tools for analyzing the benchmark results.
+
+use crate::BenchmarkResult;
+use std::collections::BTreeMap;
+
+pub struct Analysis {
+	pub base: u128,
+	pub slopes: Vec<u128>,
+	pub names: Vec<String>,
+	pub value_dists: Option<Vec<(Vec<u32>, u128, u128)>>,
+	pub errors: Option<Vec<u128>>,
+	pub minimum: u128,
+	selector: BenchmarkSelector,
+}
+
+#[derive(Clone, Copy)]
+pub enum BenchmarkSelector {
+	ExtrinsicTime,
+	StorageRootTime,
+	Reads,
+	Writes,
+	ProofSize,
+}
+
+/// Multiplies the value by 1000 and converts it into an u128.
+fn mul_1000_into_u128(value: f64) -> u128 {
+	// This is slighly more precise than the alternative of `(value * 1000.0) as u128`.
+	(value as u128)
+		.saturating_mul(1000)
+		.saturating_add((value.fract() * 1000.0) as u128)
+}
+
+impl BenchmarkSelector {
+	fn scale_and_cast_weight(self, value: f64, round_up: bool) -> u128 {
+		if let BenchmarkSelector::ExtrinsicTime = self {
+			// We add a very slight bias here to counteract the numerical imprecision of the linear
+			// regression where due to rounding issues it can emit a number like `2999999.999999998`
+			// which we most certainly always want to round up instead of truncating.
+			mul_1000_into_u128(value + 0.000_000_005)
+		} else {
+			if round_up {
+				(value + 0.5) as u128
+			} else {
+				value as u128
+			}
+		}
+	}
+
+	fn scale_weight(self, value: u128) -> u128 {
+		if let BenchmarkSelector::ExtrinsicTime = self {
+			value.saturating_mul(1000)
+		} else {
+			value
+		}
+	}
+
+	fn nanos_from_weight(self, value: u128) -> u128 {
+		if let BenchmarkSelector::ExtrinsicTime = self {
+			value / 1000
+		} else {
+			value
+		}
+	}
+
+	fn get_value(self, result: &BenchmarkResult) -> u128 {
+		match self {
+			BenchmarkSelector::ExtrinsicTime => result.extrinsic_time,
+			BenchmarkSelector::StorageRootTime => result.storage_root_time,
+			BenchmarkSelector::Reads => result.reads.into(),
+			BenchmarkSelector::Writes => result.writes.into(),
+			BenchmarkSelector::ProofSize => result.proof_size.into(),
+		}
+	}
+
+	fn get_minimum(self, results: &[BenchmarkResult]) -> u128 {
+		results
+			.iter()
+			.map(|result| self.get_value(result))
+			.min()
+			.expect("results cannot be empty")
+	}
+}
+
+#[derive(Debug)]
+pub enum AnalysisChoice {
+	/// Use minimum squares regression for analyzing the benchmarking results.
+	MinSquares,
+	/// Use median slopes for analyzing the benchmarking results.
+	MedianSlopes,
+	/// Use the maximum values among all other analysis functions for the benchmarking results.
+	Max,
+}
+
+impl Default for AnalysisChoice {
+	fn default() -> Self {
+		AnalysisChoice::MinSquares
+	}
+}
+
+impl TryFrom<Option<String>> for AnalysisChoice {
+	type Error = &'static str;
+
+	fn try_from(s: Option<String>) -> Result<Self, Self::Error> {
+		match s {
+			None => Ok(AnalysisChoice::default()),
+			Some(i) => match &i[..] {
+				"min-squares" | "min_squares" => Ok(AnalysisChoice::MinSquares),
+				"median-slopes" | "median_slopes" => Ok(AnalysisChoice::MedianSlopes),
+				"max" => Ok(AnalysisChoice::Max),
+				_ => Err("invalid analysis string"),
+			},
+		}
+	}
+}
+
+fn raw_linear_regression(
+	xs: &[f64],
+	ys: &[f64],
+	x_vars: usize,
+	with_intercept: bool,
+) -> Option<(f64, Vec<f64>, Vec<f64>)> {
+	let mut data: Vec<f64> = Vec::new();
+
+	// Here we build a raw matrix of linear equations for the `linregress` crate to solve for us
+	// and build a linear regression model around it.
+	//
+	// Each row of the matrix contains as the first column the actual value which we want
+	// the model to predict for us (the `y`), and the rest of the columns contain the input
+	// parameters on which the model will base its predictions on (the `xs`).
+	//
+	// In machine learning terms this is essentially the training data for the model.
+	//
+	// As a special case the very first input parameter represents the constant factor
+	// of the linear equation: the so called "intercept value". Since it's supposed to
+	// be constant we can just put a dummy input parameter of either a `1` (in case we want it)
+	// or a `0` (in case we do not).
+	for (&y, xs) in ys.iter().zip(xs.chunks_exact(x_vars)) {
+		data.push(y);
+		if with_intercept {
+			data.push(1.0);
+		} else {
+			data.push(0.0);
+		}
+		data.extend(xs);
+	}
+	let model = linregress::fit_low_level_regression_model(&data, ys.len(), x_vars + 2).ok()?;
+	Some((model.parameters()[0], model.parameters()[1..].to_vec(), model.se().to_vec()))
+}
+
+fn linear_regression(
+	xs: Vec<f64>,
+	mut ys: Vec<f64>,
+	x_vars: usize,
+) -> Option<(f64, Vec<f64>, Vec<f64>)> {
+	let (intercept, params, errors) = raw_linear_regression(&xs, &ys, x_vars, true)?;
+	if intercept >= -0.0001 {
+		// The intercept is positive, or is effectively zero.
+		return Some((intercept, params, errors[1..].to_vec()))
+	}
+
+	// The intercept is negative.
+	// The weights must be always positive, so we can't have that.
+
+	let mut min = ys[0];
+	for &value in &ys {
+		if value < min {
+			min = value;
+		}
+	}
+
+	for value in &mut ys {
+		*value -= min;
+	}
+
+	let (intercept, params, errors) = raw_linear_regression(&xs, &ys, x_vars, false)?;
+	assert!(intercept.abs() <= 0.0001);
+	Some((min, params, errors[1..].to_vec()))
+}
+
+impl Analysis {
+	// Useful for when there are no components, and we just need an median value of the benchmark
+	// results. Note: We choose the median value because it is more robust to outliers.
+	fn median_value(r: &Vec<BenchmarkResult>, selector: BenchmarkSelector) -> Option<Self> {
+		if r.is_empty() {
+			return None
+		}
+
+		let mut values: Vec<u128> = r
+			.iter()
+			.map(|result| match selector {
+				BenchmarkSelector::ExtrinsicTime => result.extrinsic_time,
+				BenchmarkSelector::StorageRootTime => result.storage_root_time,
+				BenchmarkSelector::Reads => result.reads.into(),
+				BenchmarkSelector::Writes => result.writes.into(),
+				BenchmarkSelector::ProofSize => result.proof_size.into(),
+			})
+			.collect();
+
+		values.sort();
+		let mid = values.len() / 2;
+
+		Some(Self {
+			base: selector.scale_weight(values[mid]),
+			slopes: Vec::new(),
+			names: Vec::new(),
+			value_dists: None,
+			errors: None,
+			minimum: selector.get_minimum(&r),
+			selector,
+		})
+	}
+
+	pub fn median_slopes(r: &Vec<BenchmarkResult>, selector: BenchmarkSelector) -> Option<Self> {
+		if r[0].components.is_empty() {
+			return Self::median_value(r, selector)
+		}
+
+		let results = r[0]
+			.components
+			.iter()
+			.enumerate()
+			.map(|(i, &(param, _))| {
+				let mut counted = BTreeMap::<Vec<u32>, usize>::new();
+				for result in r.iter() {
+					let mut p = result.components.iter().map(|x| x.1).collect::<Vec<_>>();
+					p[i] = 0;
+					*counted.entry(p).or_default() += 1;
+				}
+				let others: Vec<u32> =
+					counted.iter().max_by_key(|i| i.1).expect("r is not empty; qed").0.clone();
+				let values = r
+					.iter()
+					.filter(|v| {
+						v.components
+							.iter()
+							.map(|x| x.1)
+							.zip(others.iter())
+							.enumerate()
+							.all(|(j, (v1, v2))| j == i || v1 == *v2)
+					})
+					.map(|result| {
+						// Extract the data we are interested in analyzing
+						let data = match selector {
+							BenchmarkSelector::ExtrinsicTime => result.extrinsic_time,
+							BenchmarkSelector::StorageRootTime => result.storage_root_time,
+							BenchmarkSelector::Reads => result.reads.into(),
+							BenchmarkSelector::Writes => result.writes.into(),
+							BenchmarkSelector::ProofSize => result.proof_size.into(),
+						};
+						(result.components[i].1, data)
+					})
+					.collect::<Vec<_>>();
+				(format!("{:?}", param), i, others, values)
+			})
+			.collect::<Vec<_>>();
+
+		let models = results
+			.iter()
+			.map(|(_, _, _, ref values)| {
+				let mut slopes = vec![];
+				for (i, &(x1, y1)) in values.iter().enumerate() {
+					for &(x2, y2) in values.iter().skip(i + 1) {
+						if x1 != x2 {
+							slopes.push((y1 as f64 - y2 as f64) / (x1 as f64 - x2 as f64));
+						}
+					}
+				}
+				slopes.sort_by(|a, b| a.partial_cmp(b).expect("values well defined; qed"));
+				let slope = slopes[slopes.len() / 2];
+
+				let mut offsets = vec![];
+				for &(x, y) in values.iter() {
+					offsets.push(y as f64 - slope * x as f64);
+				}
+				offsets.sort_by(|a, b| a.partial_cmp(b).expect("values well defined; qed"));
+				let offset = offsets[offsets.len() / 2];
+
+				(offset, slope)
+			})
+			.collect::<Vec<_>>();
+
+		let models = models
+			.iter()
+			.zip(results.iter())
+			.map(|((offset, slope), (_, i, others, _))| {
+				let over = others
+					.iter()
+					.enumerate()
+					.filter(|(j, _)| j != i)
+					.map(|(j, v)| models[j].1 * *v as f64)
+					.fold(0f64, |acc, i| acc + i);
+				(*offset - over, *slope)
+			})
+			.collect::<Vec<_>>();
+
+		let base = selector.scale_and_cast_weight(models[0].0.max(0f64), false);
+		let slopes = models
+			.iter()
+			.map(|x| selector.scale_and_cast_weight(x.1.max(0f64), false))
+			.collect::<Vec<_>>();
+
+		Some(Self {
+			base,
+			slopes,
+			names: results.into_iter().map(|x| x.0).collect::<Vec<_>>(),
+			value_dists: None,
+			errors: None,
+			minimum: selector.get_minimum(&r),
+			selector,
+		})
+	}
+
+	pub fn min_squares_iqr(r: &Vec<BenchmarkResult>, selector: BenchmarkSelector) -> Option<Self> {
+		if r[0].components.is_empty() || r.len() <= 2 {
+			return Self::median_value(r, selector)
+		}
+
+		let mut results = BTreeMap::<Vec<u32>, Vec<u128>>::new();
+		for result in r.iter() {
+			let p = result.components.iter().map(|x| x.1).collect::<Vec<_>>();
+			results.entry(p).or_default().push(match selector {
+				BenchmarkSelector::ExtrinsicTime => result.extrinsic_time,
+				BenchmarkSelector::StorageRootTime => result.storage_root_time,
+				BenchmarkSelector::Reads => result.reads.into(),
+				BenchmarkSelector::Writes => result.writes.into(),
+				BenchmarkSelector::ProofSize => result.proof_size.into(),
+			})
+		}
+
+		for (_, rs) in results.iter_mut() {
+			rs.sort();
+			let ql = rs.len() / 4;
+			*rs = rs[ql..rs.len() - ql].to_vec();
+		}
+
+		let names = r[0].components.iter().map(|x| format!("{:?}", x.0)).collect::<Vec<_>>();
+		let value_dists = results
+			.iter()
+			.map(|(p, vs)| {
+				// Avoid divide by zero
+				if vs.is_empty() {
+					return (p.clone(), 0, 0)
+				}
+				let total = vs.iter().fold(0u128, |acc, v| acc + *v);
+				let mean = total / vs.len() as u128;
+				let sum_sq_diff = vs.iter().fold(0u128, |acc, v| {
+					let d = mean.max(*v) - mean.min(*v);
+					acc + d * d
+				});
+				let stddev = (sum_sq_diff as f64 / vs.len() as f64).sqrt() as u128;
+				(p.clone(), mean, stddev)
+			})
+			.collect::<Vec<_>>();
+
+		let mut ys: Vec<f64> = Vec::new();
+		let mut xs: Vec<f64> = Vec::new();
+		for result in results {
+			let x: Vec<f64> = result.0.iter().map(|value| *value as f64).collect();
+			for y in result.1 {
+				xs.extend(x.iter().copied());
+				ys.push(y as f64);
+			}
+		}
+
+		let (intercept, slopes, errors) = linear_regression(xs, ys, r[0].components.len())?;
+
+		Some(Self {
+			base: selector.scale_and_cast_weight(intercept, true),
+			slopes: slopes
+				.into_iter()
+				.map(|value| selector.scale_and_cast_weight(value, true))
+				.collect(),
+			names,
+			value_dists: Some(value_dists),
+			errors: Some(
+				errors
+					.into_iter()
+					.map(|value| selector.scale_and_cast_weight(value, false))
+					.collect(),
+			),
+			minimum: selector.get_minimum(&r),
+			selector,
+		})
+	}
+
+	pub fn max(r: &Vec<BenchmarkResult>, selector: BenchmarkSelector) -> Option<Self> {
+		let median_slopes = Self::median_slopes(r, selector);
+		let min_squares = Self::min_squares_iqr(r, selector);
+
+		if median_slopes.is_none() || min_squares.is_none() {
+			return None
+		}
+
+		let median_slopes = median_slopes.unwrap();
+		let min_squares = min_squares.unwrap();
+
+		let base = median_slopes.base.max(min_squares.base);
+		let slopes = median_slopes
+			.slopes
+			.into_iter()
+			.zip(min_squares.slopes.into_iter())
+			.map(|(a, b): (u128, u128)| a.max(b))
+			.collect::<Vec<u128>>();
+		// components should always be in the same order
+		median_slopes
+			.names
+			.iter()
+			.zip(min_squares.names.iter())
+			.for_each(|(a, b)| assert!(a == b, "benchmark results not in the same order"));
+		let names = median_slopes.names;
+		let value_dists = min_squares.value_dists;
+		let errors = min_squares.errors;
+		let minimum = selector.get_minimum(&r);
+
+		Some(Self { base, slopes, names, value_dists, errors, selector, minimum })
+	}
+}
+
+fn ms(mut nanos: u128) -> String {
+	let mut x = 100_000u128;
+	while x > 1 {
+		if nanos > x * 1_000 {
+			nanos = nanos / x * x;
+			break
+		}
+		x /= 10;
+	}
+	format!("{}", nanos as f64 / 1_000f64)
+}
+
+impl std::fmt::Display for Analysis {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		if let Some(ref value_dists) = self.value_dists {
+			writeln!(f, "\nData points distribution:")?;
+			writeln!(
+				f,
+				"{}   mean µs  sigma µs       %",
+				self.names.iter().map(|p| format!("{:>5}", p)).collect::<Vec<_>>().join(" ")
+			)?;
+			for (param_values, mean, sigma) in value_dists.iter() {
+				if *mean == 0 {
+					writeln!(
+						f,
+						"{}  {:>8}  {:>8}  {:>3}.{}%",
+						param_values
+							.iter()
+							.map(|v| format!("{:>5}", v))
+							.collect::<Vec<_>>()
+							.join(" "),
+						ms(*mean),
+						ms(*sigma),
+						"?",
+						"?"
+					)?;
+				} else {
+					writeln!(
+						f,
+						"{}  {:>8}  {:>8}  {:>3}.{}%",
+						param_values
+							.iter()
+							.map(|v| format!("{:>5}", v))
+							.collect::<Vec<_>>()
+							.join(" "),
+						ms(*mean),
+						ms(*sigma),
+						(sigma * 100 / mean),
+						(sigma * 1000 / mean % 10)
+					)?;
+				}
+			}
+		}
+
+		if let Some(ref errors) = self.errors {
+			writeln!(f, "\nQuality and confidence:")?;
+			writeln!(f, "param     error")?;
+			for (p, se) in self.names.iter().zip(errors.iter()) {
+				writeln!(f, "{}      {:>8}", p, ms(self.selector.nanos_from_weight(*se)))?;
+			}
+		}
+
+		writeln!(f, "\nModel:")?;
+		writeln!(f, "Time ~= {:>8}", ms(self.selector.nanos_from_weight(self.base)))?;
+		for (&t, n) in self.slopes.iter().zip(self.names.iter()) {
+			writeln!(f, "    + {} {:>8}", n, ms(self.selector.nanos_from_weight(t)))?;
+		}
+		writeln!(f, "              µs")
+	}
+}
+
+impl std::fmt::Debug for Analysis {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}", self.base)?;
+		for (&m, n) in self.slopes.iter().zip(self.names.iter()) {
+			write!(f, " + ({} * {})", m, n)?;
+		}
+		write!(f, "")
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::BenchmarkParameter;
+
+	fn benchmark_result(
+		components: Vec<(BenchmarkParameter, u32)>,
+		extrinsic_time: u128,
+		storage_root_time: u128,
+		reads: u32,
+		writes: u32,
+	) -> BenchmarkResult {
+		BenchmarkResult {
+			components,
+			extrinsic_time,
+			storage_root_time,
+			reads,
+			repeat_reads: 0,
+			writes,
+			repeat_writes: 0,
+			proof_size: 0,
+			keys: vec![],
+		}
+	}
+
+	#[test]
+	fn test_linear_regression() {
+		let ys = vec![
+			3797981.0,
+			37857779.0,
+			70569402.0,
+			104004114.0,
+			137233924.0,
+			169826237.0,
+			203521133.0,
+			237552333.0,
+			271082065.0,
+			305554637.0,
+			335218347.0,
+			371759065.0,
+			405086197.0,
+			438353555.0,
+			472891417.0,
+			505339532.0,
+			527784778.0,
+			562590596.0,
+			635291991.0,
+			673027090.0,
+			708119408.0,
+		];
+		let xs = vec![
+			0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0,
+			16.0, 17.0, 18.0, 19.0, 20.0,
+		];
+
+		let (intercept, params, errors) = raw_linear_regression(&xs, &ys, 1, true).unwrap();
+		assert_eq!(intercept as i64, -2712997);
+		assert_eq!(params.len(), 1);
+		assert_eq!(params[0] as i64, 34444926);
+		assert_eq!(errors.len(), 2);
+		assert_eq!(errors[0] as i64, 4805766);
+		assert_eq!(errors[1] as i64, 411084);
+
+		let (intercept, params, errors) = linear_regression(xs, ys, 1).unwrap();
+		assert_eq!(intercept as i64, 3797981);
+		assert_eq!(params.len(), 1);
+		assert_eq!(params[0] as i64, 33968513);
+		assert_eq!(errors.len(), 1);
+		assert_eq!(errors[0] as i64, 217331);
+	}
+
+	#[test]
+	fn analysis_median_slopes_should_work() {
+		let data = vec![
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 1), (BenchmarkParameter::m, 5)],
+				11_500_000,
+				0,
+				3,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 2), (BenchmarkParameter::m, 5)],
+				12_500_000,
+				0,
+				4,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 5)],
+				13_500_000,
+				0,
+				5,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 4), (BenchmarkParameter::m, 5)],
+				14_500_000,
+				0,
+				6,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 1)],
+				13_100_000,
+				0,
+				5,
+				2,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 3)],
+				13_300_000,
+				0,
+				5,
+				6,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 7)],
+				13_700_000,
+				0,
+				5,
+				14,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 10)],
+				14_000_000,
+				0,
+				5,
+				20,
+			),
+		];
+
+		let extrinsic_time =
+			Analysis::median_slopes(&data, BenchmarkSelector::ExtrinsicTime).unwrap();
+		assert_eq!(extrinsic_time.base, 10_000_000_000);
+		assert_eq!(extrinsic_time.slopes, vec![1_000_000_000, 100_000_000]);
+
+		let reads = Analysis::median_slopes(&data, BenchmarkSelector::Reads).unwrap();
+		assert_eq!(reads.base, 2);
+		assert_eq!(reads.slopes, vec![1, 0]);
+
+		let writes = Analysis::median_slopes(&data, BenchmarkSelector::Writes).unwrap();
+		assert_eq!(writes.base, 0);
+		assert_eq!(writes.slopes, vec![0, 2]);
+	}
+
+	#[test]
+	fn analysis_median_min_squares_should_work() {
+		let data = vec![
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 1), (BenchmarkParameter::m, 5)],
+				11_500_000,
+				0,
+				3,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 2), (BenchmarkParameter::m, 5)],
+				12_500_000,
+				0,
+				4,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 5)],
+				13_500_000,
+				0,
+				5,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 4), (BenchmarkParameter::m, 5)],
+				14_500_000,
+				0,
+				6,
+				10,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 1)],
+				13_100_000,
+				0,
+				5,
+				2,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 3)],
+				13_300_000,
+				0,
+				5,
+				6,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 7)],
+				13_700_000,
+				0,
+				5,
+				14,
+			),
+			benchmark_result(
+				vec![(BenchmarkParameter::n, 3), (BenchmarkParameter::m, 10)],
+				14_000_000,
+				0,
+				5,
+				20,
+			),
+		];
+
+		let extrinsic_time =
+			Analysis::min_squares_iqr(&data, BenchmarkSelector::ExtrinsicTime).unwrap();
+		assert_eq!(extrinsic_time.base, 10_000_000_000);
+		assert_eq!(extrinsic_time.slopes, vec![1000000000, 100000000]);
+
+		let reads = Analysis::min_squares_iqr(&data, BenchmarkSelector::Reads).unwrap();
+		assert_eq!(reads.base, 2);
+		assert_eq!(reads.slopes, vec![1, 0]);
+
+		let writes = Analysis::min_squares_iqr(&data, BenchmarkSelector::Writes).unwrap();
+		assert_eq!(writes.base, 0);
+		assert_eq!(writes.slopes, vec![0, 2]);
+	}
+
+	#[test]
+	fn analysis_min_squares_iqr_uses_multiple_samples_for_same_parameters() {
+		let data = vec![
+			benchmark_result(vec![(BenchmarkParameter::n, 0)], 2_000_000, 0, 0, 0),
+			benchmark_result(vec![(BenchmarkParameter::n, 0)], 4_000_000, 0, 0, 0),
+			benchmark_result(vec![(BenchmarkParameter::n, 1)], 4_000_000, 0, 0, 0),
+			benchmark_result(vec![(BenchmarkParameter::n, 1)], 8_000_000, 0, 0, 0),
+		];
+
+		let extrinsic_time =
+			Analysis::min_squares_iqr(&data, BenchmarkSelector::ExtrinsicTime).unwrap();
+		assert_eq!(extrinsic_time.base, 3_000_000_000);
+		assert_eq!(extrinsic_time.slopes, vec![3_000_000_000]);
+	}
+
+	#[test]
+	fn intercept_of_a_little_under_zero_is_rounded_up_to_zero() {
+		// Analytically this should result in an intercept of 0, but
+		// due to numerical imprecision this will generate an intercept
+		// equal to roughly -0.0000000000000004440892098500626
+		let data = vec![
+			benchmark_result(vec![(BenchmarkParameter::n, 1)], 2, 0, 0, 0),
+			benchmark_result(vec![(BenchmarkParameter::n, 2)], 4, 0, 0, 0),
+			benchmark_result(vec![(BenchmarkParameter::n, 3)], 6, 0, 0, 0),
+		];
+
+		let extrinsic_time =
+			Analysis::min_squares_iqr(&data, BenchmarkSelector::ExtrinsicTime).unwrap();
+		assert_eq!(extrinsic_time.base, 0);
+		assert_eq!(extrinsic_time.slopes, vec![2000]);
+	}
+}
diff --git a/substrate/frame/benchmarking/src/baseline.rs b/substrate/frame/benchmarking/src/baseline.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6cd23ebe028a348fc7733c57e8490c5e448797e6
--- /dev/null
+++ b/substrate/frame/benchmarking/src/baseline.rs
@@ -0,0 +1,164 @@
+// 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 set of benchmarks which can establish a global baseline for all other
+//! benchmarking. These benchmarks do not require a pallet to be deployed.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::benchmarks;
+use frame_system::Pallet as System;
+use sp_runtime::{
+	traits::{AppVerify, Hash},
+	RuntimeAppPublic,
+};
+use sp_std::{vec, vec::Vec};
+
+mod crypto {
+	use sp_application_crypto::{app_crypto, sr25519, KeyTypeId};
+
+	pub const TEST_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"test");
+	app_crypto!(sr25519, TEST_KEY_TYPE_ID);
+}
+pub type SignerId = crypto::Public;
+
+pub struct Pallet<T: Config>(System<T>);
+pub trait Config: frame_system::Config {}
+
+benchmarks! {
+	addition {
+		let i in 0 .. 1_000_000;
+		let mut start = 0;
+	}: {
+		(0..i).for_each(|_| start += 1);
+	} verify {
+		assert_eq!(start, i);
+	}
+
+	subtraction {
+		let i in 0 .. 1_000_000;
+		let mut start = u32::MAX;
+	}: {
+		(0..i).for_each(|_| start -= 1);
+	} verify {
+		assert_eq!(start, u32::MAX - i);
+	}
+
+	multiplication {
+		let i in 0 .. 1_000_000;
+		let mut out = 0;
+	}:  {
+		(1..=i).for_each(|j| out = 2 * j);
+	} verify {
+		assert_eq!(out, 2 * i);
+	}
+
+	division {
+		let i in 0 .. 1_000_000;
+		let mut out = 0;
+	}: {
+		(0..=i).for_each(|j| out = j / 2);
+	} verify {
+		assert_eq!(out, i / 2);
+	}
+
+	hashing {
+		let mut hash = T::Hash::default();
+	}: {
+		(0..=100_000u32).for_each(|j| hash = T::Hashing::hash(&j.to_be_bytes()));
+	} verify {
+		assert!(hash != T::Hash::default());
+	}
+
+	sr25519_verification {
+		let i in 0 .. 100;
+
+		let public = SignerId::generate_pair(None);
+
+		let sigs_count: u8 = i.try_into().unwrap();
+		let msg_and_sigs: Vec<_> = (0..sigs_count).map(|j| {
+			let msg = vec![j, j];
+			(msg.clone(), public.sign(&msg).unwrap())
+		})
+		.collect();
+	}: {
+		msg_and_sigs.iter().for_each(|(msg, sig)| {
+			assert!(sig.verify(&msg[..], &public));
+		});
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		mock::new_test_ext(),
+		mock::Test,
+	);
+}
+
+#[cfg(test)]
+pub mod mock {
+	use sp_runtime::{testing::H256, BuildStorage};
+
+	type AccountId = u64;
+	type Nonce = u32;
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		}
+	);
+
+	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 = 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 Version = ();
+		type PalletInfo = PalletInfo;
+		type AccountData = ();
+		type OnNewAccount = ();
+		type OnKilledAccount = ();
+		type SystemWeightInfo = ();
+		type SS58Prefix = ();
+		type OnSetCode = ();
+		type MaxConsumers = frame_support::traits::ConstU32<16>;
+	}
+
+	impl super::Config for Test {}
+
+	pub fn new_test_ext() -> sp_io::TestExternalities {
+		use sp_keystore::{testing::MemoryKeystore, KeystoreExt};
+
+		let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		let mut ext = sp_io::TestExternalities::new(t);
+		ext.register_extension(KeystoreExt::new(MemoryKeystore::new()));
+
+		ext
+	}
+}
diff --git a/substrate/frame/benchmarking/src/lib.rs b/substrate/frame/benchmarking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f79582d03e51caaaf395048fa224484b026d32f9
--- /dev/null
+++ b/substrate/frame/benchmarking/src/lib.rs
@@ -0,0 +1,353 @@
+// 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.
+
+//! Macro for benchmarking a FRAME runtime.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "std")]
+mod analysis;
+#[cfg(test)]
+mod tests;
+#[cfg(test)]
+mod tests_instance;
+mod utils;
+
+pub mod baseline;
+pub mod v1;
+
+/// Private exports that are being used by macros.
+///
+/// The exports are not stable and should not be relied on.
+#[doc(hidden)]
+pub mod __private {
+	pub use codec;
+	pub use frame_support::{storage, traits};
+	pub use log;
+	pub use paste;
+	pub use sp_core::defer;
+	pub use sp_io::storage::root as storage_root;
+	pub use sp_runtime::{traits::Zero, StateVersion};
+	pub use sp_std::{self, boxed::Box, str, vec, vec::Vec};
+	pub use sp_storage::{well_known_keys, TrackedStorageKey};
+}
+
+#[cfg(feature = "std")]
+pub use analysis::{Analysis, AnalysisChoice, BenchmarkSelector};
+pub use utils::*;
+pub use v1::*;
+
+/// Contains macros, structs, and traits associated with v2 of the pallet benchmarking syntax.
+///
+/// The [`v2::benchmarks`] and [`v2::instance_benchmarks`] macros can be used to designate a
+/// module as a benchmarking module that can contain benchmarks and benchmark tests. The
+/// `#[benchmarks]` variant will set up a regular, non-instance benchmarking module, and the
+/// `#[instance_benchmarks]` variant will set up the module in instance benchmarking mode.
+///
+/// Benchmarking modules should be gated behind a `#[cfg(feature = "runtime-benchmarks")]`
+/// feature gate to ensure benchmarking code that is only compiled when the
+/// `runtime-benchmarks` feature is enabled is not referenced.
+///
+/// The following is the general syntax for a benchmarks (or instance benchmarks) module:
+///
+/// ## General Syntax
+///
+/// ```ignore
+/// #![cfg(feature = "runtime-benchmarks")]
+///
+/// use super::{mock_helpers::*, Pallet as MyPallet};
+/// use frame_benchmarking::v2::*;
+///
+/// #[benchmarks]
+/// mod benchmarks {
+/// 	use super::*;
+///
+/// 	#[benchmark]
+/// 	fn bench_name_1(x: Linear<7, 1_000>, y: Linear<1_000, 100_0000>) {
+/// 		// setup code
+/// 		let z = x + y;
+/// 		let caller = whitelisted_caller();
+///
+/// 		#[extrinsic_call]
+/// 		extrinsic_name(SystemOrigin::Signed(caller), other, arguments);
+///
+/// 		// verification code
+/// 		assert_eq!(MyPallet::<T>::my_var(), z);
+/// 	}
+///
+/// 	#[benchmark]
+/// 	fn bench_name_2() {
+/// 		// setup code
+/// 		let caller = whitelisted_caller();
+///
+/// 		#[block]
+/// 		{
+/// 			something(some, thing);
+/// 			my_extrinsic(RawOrigin::Signed(caller), some, argument);
+/// 			something_else(foo, bar);
+/// 		}
+///
+/// 		// verification code
+/// 		assert_eq!(MyPallet::<T>::something(), 37);
+/// 	}
+/// }
+/// ```
+///
+/// ## Benchmark Definitions
+///
+/// Within a `#[benchmarks]` or `#[instance_benchmarks]` module, you can define individual
+/// benchmarks using the `#[benchmark]` attribute, as shown in the example above.
+///
+/// The `#[benchmark]` attribute expects a function definition with a blank return type (or a
+/// return type compatible with `Result<(), BenchmarkError>`, as discussed below) and zero or
+/// more arguments whose names are valid [BenchmarkParameter](`crate::BenchmarkParameter`)
+/// parameters, such as `x`, `y`, `a`, `b`, etc., and whose param types must implement
+/// [ParamRange](`v2::ParamRange`). At the moment the only valid type that implements
+/// [ParamRange](`v2::ParamRange`) is [Linear](`v2::Linear`).
+///
+/// The valid syntax for defining a [Linear](`v2::Linear`) is `Linear<A, B>` where `A`, and `B`
+/// are valid integer literals (that fit in a `u32`), such that `B` >= `A`.
+///
+/// Anywhere within a benchmark function you may use the generic `T: Config` parameter as well
+/// as `I` in the case of an `#[instance_benchmarks]` module. You should not add these to the
+/// function signature as this will be handled automatically for you based on whether this is a
+/// `#[benchmarks]` or `#[instance_benchmarks]` module and whatever [where clause](#where-clause)
+/// you have defined for the module. You should not manually add any generics to the
+/// signature of your benchmark function.
+///
+/// Also note that the `// setup code` and `// verification code` comments shown above are not
+/// required and are included simply for demonstration purposes.
+///
+/// ### `#[extrinsic_call]` and `#[block]`
+///
+/// Within the benchmark function body, either an `#[extrinsic_call]` or a `#[block]`
+/// annotation is required. These attributes should be attached to a block (shown in
+/// `bench_name_2` above) or a one-line function call (shown in `bench_name_1` above, in `syn`
+/// parlance this should be an `ExprCall`), respectively.
+///
+/// The `#[block]` syntax is broad and will benchmark any code contained within the block the
+/// attribute is attached to. If `#[block]` is attached to something other than a block, a
+/// compiler error will be emitted.
+///
+/// The one-line `#[extrinsic_call]` syntax must consist of a function call to an extrinsic,
+/// where the first argument is the origin. If `#[extrinsic_call]` is attached to an item that
+/// doesn't meet these requirements, a compiler error will be emitted.
+///
+/// As a short-hand, you may substitute the name of the extrinsic call with `_`, such as the
+/// following:
+///
+/// ```ignore
+/// #[extrinsic_call]
+/// _(RawOrigin::Signed(whitelisted_caller()), 0u32.into(), 0);
+/// ```
+///
+/// The underscore will be substituted with the name of the benchmark  (i.e. the name of the
+/// function in the benchmark function definition).
+///
+/// In case of a `force_origin` where you want to elevate the privileges of the provided origin,
+/// this is the general syntax:
+/// ```ignore
+/// #[extrinsic_call]
+/// _(force_origin as T::RuntimeOrigin, 0u32.into(), 0);
+/// ```
+///
+/// Regardless of whether `#[extrinsic_call]` or `#[block]` is used, this attribute also serves
+/// the purpose of designating the boundary between the setup code portion of the benchmark
+/// (everything before the `#[extrinsic_call]` or `#[block]` attribute) and the verification
+/// stage (everything after the item that the `#[extrinsic_call]` or `#[block]` attribute is
+/// attached to). The setup code section should contain any code that needs to execute before
+/// the measured portion of the benchmark executes. The verification section is where you can
+/// perform assertions to verify that the extrinsic call (or whatever is happening in your
+/// block, if you used the `#[block]` syntax) executed successfully.
+///
+/// Note that neither `#[extrinsic_call]` nor `#[block]` are real attribute macros and are
+/// instead consumed by the outer macro pattern as part of the enclosing benchmark function
+/// definition. This is why we are able to use `#[extrinsic_call]` and `#[block]` within a
+/// function definition even though this behavior has not been stabilized
+/// yet—`#[extrinsic_call]` and `#[block]` are parsed and consumed as part of the benchmark
+/// definition parsing code, so they never expand as their own attribute macros.
+///
+/// ### Optional Attributes
+///
+/// The keywords `extra` and `skip_meta` can be provided as optional arguments to the
+/// `#[benchmark]` attribute, i.e. `#[benchmark(extra, skip_meta)]`. Including either of these
+/// will enable the `extra` or `skip_meta` option, respectively. These options enable the same
+/// behavior they did in the old benchmarking syntax in `frame_benchmarking`, namely:
+///
+/// #### `extra`
+///
+/// Specifies that this benchmark should not normally run. To run benchmarks marked with
+/// `extra`, you will need to invoke the `frame-benchmarking-cli` with `--extra`.
+///
+/// #### `skip_meta`
+///
+/// Specifies that the benchmarking framework should not analyze the storage keys that the
+/// benchmarked code read or wrote. This useful to suppress the prints in the form of unknown
+/// 0x… in case a storage key that does not have metadata. Note that this skips the analysis of
+/// all accesses, not just ones without metadata.
+///
+/// ## Where Clause
+///
+/// Some pallets require a where clause specifying constraints on their generics to make
+/// writing benchmarks feasible. To accomodate this situation, you can provide such a where
+/// clause as the (only) argument to the `#[benchmarks]` or `#[instance_benchmarks]` attribute
+/// macros. Below is an example of this taken from the `message-queue` pallet.
+///
+/// ```ignore
+/// #[benchmarks(
+/// 	where
+/// 		<<T as Config>::MessageProcessor as ProcessMessage>::Origin: From<u32> + PartialEq,
+/// 		<T as Config>::Size: From<u32>,
+/// )]
+/// mod benchmarks {
+/// 	use super::*;
+/// 	// ...
+/// }
+/// ```
+///
+/// ## Benchmark Tests
+///
+/// Benchmark tests can be generated using the old syntax in `frame_benchmarking`,
+/// including the `frame_benchmarking::impl_benchmark_test_suite` macro.
+///
+/// An example is shown below (taken from the `message-queue` pallet's `benchmarking` module):
+/// ```ignore
+/// #[benchmarks]
+/// mod benchmarks {
+/// 	use super::*;
+/// 	// ...
+/// 	impl_benchmark_test_suite!(
+/// 		MessageQueue,
+/// 		crate::mock::new_test_ext::<crate::integration_test::Test>(),
+/// 		crate::integration_test::Test
+/// 	);
+/// }
+/// ```
+///
+/// ## Benchmark Function Generation
+///
+/// The benchmark function definition that you provide is used to automatically create a number
+/// of impls and structs required by the benchmarking engine. Additionally, a benchmark
+/// function is also generated that resembles the function definition you provide, with a few
+/// modifications:
+/// 1. The function name is transformed from i.e. `original_name` to `_original_name` so as not to
+///    collide with the struct `original_name` that is created for some of the benchmarking engine
+///    impls.
+/// 2. Appropriate `T: Config` and `I` (if this is an instance benchmark) generics are added to the
+///    function automatically during expansion, so you should not add these manually on your
+///    function definition (but you may make use of `T` and `I` anywhere within your benchmark
+///    function, in any of the three sections (setup, call, verification).
+/// 3. Arguments such as `u: Linear<10, 100>` are converted to `u: u32` to make the function
+///    directly callable.
+/// 4. A `verify: bool` param is added as the last argument. Specifying `true` will result in the
+///    verification section of your function executing, while a value of `false` will skip
+///    verification.
+/// 5. If you specify a return type on the function definition, it must conform to the [rules
+///    below](#support-for-result-benchmarkerror-and-the--operator), and the last statement of the
+///    function definition must resolve to something compatible with `Result<(), BenchmarkError>`.
+///
+/// The reason we generate an actual function as part of the expansion is to allow the compiler
+/// to enforce several constraints that would otherwise be difficult to enforce and to reduce
+/// developer confusion (especially regarding the use of the `?` operator, as covered below).
+///
+/// Note that any attributes, comments, and doc comments attached to your benchmark function
+/// definition are also carried over onto the resulting benchmark function and the struct for
+/// that benchmark. As a result you should be careful about what attributes you attach here as
+/// they will be replicated in multiple places.
+///
+/// ### Support for `Result<(), BenchmarkError>` and the `?` operator
+///
+/// You may optionally specify `Result<(), BenchmarkError>` as the return type of your
+/// benchmark function definition. If you do so, you must return a compatible `Result<(),
+/// BenchmarkError>` as the *last statement* of your benchmark function definition. You may
+/// also use the `?` operator throughout your benchmark function definition if you choose to
+/// follow this route. See the example below:
+///
+/// ```ignore
+/// #![cfg(feature = "runtime-benchmarks")]
+///
+/// use super::{mock_helpers::*, Pallet as MyPallet};
+/// use frame_benchmarking::v2::*;
+///
+/// #[benchmarks]
+/// mod benchmarks {
+/// 	use super::*;
+///
+/// 	#[benchmark]
+/// 	fn bench_name(x: Linear<5, 25>) -> Result<(), BenchmarkError> {
+/// 		// setup code
+/// 		let z = x + 4;
+/// 		let caller = whitelisted_caller();
+///
+/// 		// note we can make use of the ? operator here because of the return type
+/// 		something(z)?;
+///
+/// 		#[extrinsic_call]
+/// 		extrinsic_name(SystemOrigin::Signed(caller), other, arguments);
+///
+/// 		// verification code
+/// 		assert_eq!(MyPallet::<T>::my_var(), z);
+///
+/// 		// we must return a valid `Result<(), BenchmarkError>` as the last line of our benchmark
+/// 		// function definition. This line is not included as part of the verification code that
+/// 		// appears above it.
+/// 		Ok(())
+/// 	}
+/// }
+/// ```
+pub mod v2 {
+	pub use super::*;
+	pub use frame_support_procedural::{
+		benchmark, benchmarks, block, extrinsic_call, instance_benchmarks,
+	};
+
+	// Used in #[benchmark] implementation to ensure that benchmark function arguments
+	// implement [`ParamRange`].
+	#[doc(hidden)]
+	pub use static_assertions::{assert_impl_all, assert_type_eq_all};
+
+	/// Used by the new benchmarking code to specify that a benchmarking variable is linear
+	/// over some specified range, i.e. `Linear<0, 1_000>` means that the corresponding variable
+	/// is allowed to range from `0` to `1000`, inclusive.
+	///
+	/// See [`v2`] for more info.
+	pub struct Linear<const A: u32, const B: u32>;
+
+	/// Trait that must be implemented by all structs that can be used as parameter range types
+	/// in the new benchmarking code (i.e. `Linear<0, 1_000>`). Right now there is just
+	/// [`Linear`] but this could later be extended to support additional non-linear parameter
+	/// ranges.
+	///
+	/// See [`v2`] for more info.
+	pub trait ParamRange {
+		/// Represents the (inclusive) starting number of this `ParamRange`.
+		fn start(&self) -> u32;
+
+		/// Represents the (inclusive) ending number of this `ParamRange`.
+		fn end(&self) -> u32;
+	}
+
+	impl<const A: u32, const B: u32> ParamRange for Linear<A, B> {
+		fn start(&self) -> u32 {
+			A
+		}
+
+		fn end(&self) -> u32 {
+			B
+		}
+	}
+}
diff --git a/substrate/frame/benchmarking/src/tests.rs b/substrate/frame/benchmarking/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e5bacbdb2361ae223cb0545639026394be1c8d88
--- /dev/null
+++ b/substrate/frame/benchmarking/src/tests.rs
@@ -0,0 +1,443 @@
+// 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 the module.
+
+#![cfg(test)]
+
+use frame_support::{parameter_types, traits::ConstU32};
+use sp_runtime::{
+	testing::H256,
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+use sp_std::prelude::*;
+use std::cell::RefCell;
+
+#[frame_support::pallet(dev_mode)]
+mod pallet_test {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type LowerBound: Get<u32>;
+		type UpperBound: Get<u32>;
+		type MaybeItem: Get<Option<u32>>;
+	}
+
+	#[pallet::storage]
+	pub(crate) type Value<T: Config> = StorageValue<_, u32, OptionQuery>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn set_value(origin: OriginFor<T>, n: u32) -> DispatchResult {
+			let _sender = ensure_signed(origin)?;
+			Value::<T>::put(n);
+			Ok(())
+		}
+
+		pub fn dummy(origin: OriginFor<T>, _n: u32) -> DispatchResult {
+			let _sender = ensure_none(origin)?;
+			Ok(())
+		}
+
+		pub fn always_error(_origin: OriginFor<T>) -> DispatchResult {
+			return Err("I always fail".into())
+		}
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		TestPallet: pallet_test::{Pallet, Call, Storage},
+	}
+);
+
+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 = u64;
+	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>;
+}
+
+parameter_types! {
+	pub const MaybeItem: Option<u32> = None;
+}
+
+impl pallet_test::Config for Test {
+	type LowerBound = ConstU32<1>;
+	type UpperBound = ConstU32<100>;
+	type MaybeItem = MaybeItem;
+}
+
+fn new_test_ext() -> sp_io::TestExternalities {
+	RuntimeGenesisConfig::default().build_storage().unwrap().into()
+}
+
+thread_local! {
+	/// Tracks the used components per value. Needs to be a thread local since the
+	/// benchmarking clears the storage after each run.
+	static VALUES_PER_COMPONENT: RefCell<Vec<u32>> = RefCell::new(vec![]);
+}
+
+// NOTE: This attribute is only needed for the `modify_in_` functions.
+#[allow(unreachable_code)]
+mod benchmarks {
+	use super::{new_test_ext, pallet_test::Value, Test, VALUES_PER_COMPONENT};
+	use crate::{account, BenchmarkError, BenchmarkParameter, BenchmarkResult, BenchmarkingSetup};
+	use frame_support::{assert_err, assert_ok, ensure, traits::Get};
+	use frame_system::RawOrigin;
+	use rusty_fork::rusty_fork_test;
+	use sp_std::prelude::*;
+
+	// Additional used internally by the benchmark macro.
+	use super::pallet_test::{Call, Config, Pallet};
+
+	crate::benchmarks! {
+		where_clause {
+			where
+				crate::tests::RuntimeOrigin: From<RawOrigin<<T as frame_system::Config>::AccountId>>,
+		}
+
+		set_value {
+			let b in 1 .. 1000;
+			let caller = account::<T::AccountId>("caller", 0, 0);
+		}: _ (RawOrigin::Signed(caller), b.into())
+		verify {
+			assert_eq!(Value::<T>::get(), Some(b));
+		}
+
+		other_name {
+			let b in 1 .. 1000;
+		}: dummy (RawOrigin::None, b.into())
+
+		sort_vector {
+			let x in 1 .. 10000;
+			let mut m = Vec::<u32>::new();
+			for i in (0..x).rev() {
+				m.push(i);
+			}
+		}: {
+			m.sort();
+		} verify {
+			ensure!(m[0] == 0, "You forgot to sort!")
+		}
+
+		bad_origin {
+			let b in 1 .. 1000;
+			let caller = account::<T::AccountId>("caller", 0, 0);
+		}: dummy (RawOrigin::Signed(caller), b.into())
+
+		bad_verify {
+			let x in 1 .. 10000;
+			let mut m = Vec::<u32>::new();
+			for i in (0..x).rev() {
+				m.push(i);
+			}
+		}: { }
+		verify {
+			ensure!(m[0] == 0, "You forgot to sort!")
+		}
+
+		no_components {
+			let caller = account::<T::AccountId>("caller", 0, 0);
+		}: set_value(RawOrigin::Signed(caller), 0)
+
+		variable_components {
+			let b in ( T::LowerBound::get() ) .. T::UpperBound::get();
+		}: dummy (RawOrigin::None, b.into())
+
+		#[extra]
+		extra_benchmark {
+			let b in 1 .. 1000;
+			let caller = account::<T::AccountId>("caller", 0, 0);
+		}: set_value(RawOrigin::Signed(caller), b.into())
+		verify {
+			assert_eq!(Value::<T>::get(), Some(b));
+		}
+
+		#[skip_meta]
+		skip_meta_benchmark {
+			let b in 1 .. 1000;
+			let caller = account::<T::AccountId>("caller", 0, 0);
+		}: set_value(RawOrigin::Signed(caller), b.into())
+		verify {
+			assert_eq!(Value::<T>::get(), Some(b));
+		}
+
+		override_benchmark {
+			let b in 1 .. 1000;
+			let caller = account::<T::AccountId>("caller", 0, 0);
+		}: {
+			Err(BenchmarkError::Override(
+				BenchmarkResult {
+					extrinsic_time: 1_234_567_890,
+					reads: 1337,
+					writes: 420,
+					..Default::default()
+				}
+			))?;
+		}
+
+		skip_benchmark {
+			let value = T::MaybeItem::get().ok_or(BenchmarkError::Skip)?;
+		}: {
+			// This should never be reached.
+			assert!(value > 100);
+		}
+
+		modify_in_setup_then_error {
+			Value::<T>::set(Some(123));
+			return Err(BenchmarkError::Stop("Should error"));
+		}: { }
+
+		modify_in_call_then_error {
+		}: {
+			Value::<T>::set(Some(123));
+			return Err(BenchmarkError::Stop("Should error"));
+		}
+
+		modify_in_verify_then_error {
+		}: {
+		} verify {
+			Value::<T>::set(Some(123));
+			return Err(BenchmarkError::Stop("Should error"));
+		}
+
+		// Stores all component values in the thread-local storage.
+		values_per_component {
+			let n in 0 .. 10;
+		}: {
+			VALUES_PER_COMPONENT.with(|v| v.borrow_mut().push(n));
+		}
+	}
+
+	#[test]
+	fn benchmarks_macro_works() {
+		// Check benchmark creation for `set_value`.
+		let selected = SelectedBenchmark::set_value;
+
+		let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
+		assert_eq!(components, vec![(BenchmarkParameter::b, 1, 1000)]);
+
+		let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
+			&selected,
+			&[(BenchmarkParameter::b, 1)],
+			true,
+		)
+		.expect("failed to create closure");
+
+		new_test_ext().execute_with(|| {
+			assert_ok!(closure());
+		});
+	}
+
+	#[test]
+	fn benchmarks_macro_rename_works() {
+		// Check benchmark creation for `other_dummy`.
+		let selected = SelectedBenchmark::other_name;
+		let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
+		assert_eq!(components, vec![(BenchmarkParameter::b, 1, 1000)]);
+
+		let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
+			&selected,
+			&[(BenchmarkParameter::b, 1)],
+			true,
+		)
+		.expect("failed to create closure");
+
+		new_test_ext().execute_with(|| {
+			assert_ok!(closure());
+		});
+	}
+
+	#[test]
+	fn benchmarks_macro_works_for_non_dispatchable() {
+		let selected = SelectedBenchmark::sort_vector;
+
+		let components = <SelectedBenchmark as BenchmarkingSetup<Test>>::components(&selected);
+		assert_eq!(components, vec![(BenchmarkParameter::x, 1, 10000)]);
+
+		let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
+			&selected,
+			&[(BenchmarkParameter::x, 1)],
+			true,
+		)
+		.expect("failed to create closure");
+
+		assert_ok!(closure());
+	}
+
+	#[test]
+	fn benchmarks_macro_verify_works() {
+		// Check postcondition for benchmark `set_value` is valid.
+		let selected = SelectedBenchmark::set_value;
+
+		let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
+			&selected,
+			&[(BenchmarkParameter::b, 1)],
+			true,
+		)
+		.expect("failed to create closure");
+
+		new_test_ext().execute_with(|| {
+			assert_ok!(closure());
+		});
+
+		// Check postcondition for benchmark `bad_verify` is invalid.
+		let selected = SelectedBenchmark::bad_verify;
+
+		let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
+			&selected,
+			&[(BenchmarkParameter::x, 10000)],
+			true,
+		)
+		.expect("failed to create closure");
+
+		new_test_ext().execute_with(|| {
+			assert_err!(closure(), "You forgot to sort!");
+		});
+	}
+
+	#[test]
+	fn benchmark_override_works() {
+		let selected = SelectedBenchmark::override_benchmark;
+
+		let closure = <SelectedBenchmark as BenchmarkingSetup<Test>>::instance(
+			&selected,
+			&[(BenchmarkParameter::b, 1)],
+			true,
+		)
+		.expect("failed to create closure");
+
+		new_test_ext().execute_with(|| {
+			let result = closure();
+			assert!(matches!(result, Err(BenchmarkError::Override(_))));
+		});
+	}
+
+	#[test]
+	fn benchmarks_generate_unit_tests() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Pallet::<Test>::test_benchmark_set_value());
+			assert_ok!(Pallet::<Test>::test_benchmark_other_name());
+			assert_ok!(Pallet::<Test>::test_benchmark_sort_vector());
+			assert_err!(Pallet::<Test>::test_benchmark_bad_origin(), "Bad origin");
+			assert_err!(Pallet::<Test>::test_benchmark_bad_verify(), "You forgot to sort!");
+			assert_ok!(Pallet::<Test>::test_benchmark_no_components());
+			assert_ok!(Pallet::<Test>::test_benchmark_variable_components());
+			assert!(matches!(
+				Pallet::<Test>::test_benchmark_override_benchmark(),
+				Err(BenchmarkError::Override(_)),
+			));
+			assert_eq!(Pallet::<Test>::test_benchmark_skip_benchmark(), Err(BenchmarkError::Skip),);
+		});
+	}
+
+	/// An error return of a benchmark test function still causes the db to be wiped.
+	#[test]
+	fn benchmark_error_wipes_storage() {
+		new_test_ext().execute_with(|| {
+			// It resets when the error happens in the setup:
+			assert_err!(
+				Pallet::<Test>::test_benchmark_modify_in_setup_then_error(),
+				"Should error"
+			);
+			assert_eq!(Value::<Test>::get(), None);
+
+			// It resets when the error happens in the call:
+			assert_err!(Pallet::<Test>::test_benchmark_modify_in_call_then_error(), "Should error");
+			assert_eq!(Value::<Test>::get(), None);
+
+			// It resets when the error happens in the verify:
+			assert_err!(
+				Pallet::<Test>::test_benchmark_modify_in_verify_then_error(),
+				"Should error"
+			);
+			assert_eq!(Value::<Test>::get(), None);
+		});
+	}
+
+	rusty_fork_test! {
+		/// Test that the benchmarking uses the correct values for each component and
+		/// that the number of components can be controlled with `VALUES_PER_COMPONENT`.
+		///
+		/// NOTE: This test needs to run in its own process, since it
+		/// otherwise messes up the env variable for the other tests.
+		#[test]
+		fn test_values_per_component() {
+			let tests = vec![
+				(Some("1"), Err("`VALUES_PER_COMPONENT` must be at least 2".into())),
+				(Some("asdf"), Err("Could not parse env var `VALUES_PER_COMPONENT` as u32.".into())),
+				(None, Ok(vec![0, 2, 4, 6, 8, 10])),
+				(Some("2"), Ok(vec![0, 10])),
+				(Some("4"), Ok(vec![0, 3, 6, 10])),
+				(Some("6"), Ok(vec![0, 2, 4, 6, 8, 10])),
+				(Some("10"), Ok(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 10])),
+				(Some("11"), Ok(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])),
+				(Some("99"), Ok(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])),
+			];
+
+			for (num, expected) in tests {
+				run_test_values_per_component(num, expected);
+			}
+		}
+	}
+
+	/// Helper for [`test_values_per_component`].
+	fn run_test_values_per_component(num: Option<&str>, output: Result<Vec<u32>, BenchmarkError>) {
+		VALUES_PER_COMPONENT.with(|v| v.borrow_mut().clear());
+		match num {
+			Some(n) => std::env::set_var("VALUES_PER_COMPONENT", n),
+			None => std::env::remove_var("VALUES_PER_COMPONENT"),
+		}
+
+		new_test_ext().execute_with(|| {
+			let got = Pallet::<Test>::test_benchmark_values_per_component()
+				.map(|_| VALUES_PER_COMPONENT.with(|v| v.borrow().clone()));
+
+			assert_eq!(got, output);
+		});
+	}
+}
diff --git a/substrate/frame/benchmarking/src/tests_instance.rs b/substrate/frame/benchmarking/src/tests_instance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f2c721c8114c469d8fd8df0e9afac527f62e6984
--- /dev/null
+++ b/substrate/frame/benchmarking/src/tests_instance.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.
+
+//! Tests for the benchmark macro for instantiable modules
+
+#![cfg(test)]
+
+use frame_support::traits::ConstU32;
+use sp_runtime::{
+	testing::H256,
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+use sp_std::prelude::*;
+
+#[frame_support::pallet]
+mod pallet_test {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	pub trait OtherConfig {
+		type OtherEvent;
+	}
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config + OtherConfig {
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		type LowerBound: Get<u32>;
+		type UpperBound: Get<u32>;
+	}
+
+	#[pallet::storage]
+	pub(crate) type Value<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, OptionQuery>;
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I>
+	where
+		<T as OtherConfig>::OtherEvent: Into<<T as Config<I>>::RuntimeEvent>,
+	{
+		#[pallet::call_index(0)]
+		#[pallet::weight({0})]
+		pub fn set_value(origin: OriginFor<T>, n: u32) -> DispatchResult {
+			let _sender = ensure_signed(origin)?;
+			Value::<T, I>::put(n);
+			Ok(())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight({0})]
+		pub fn dummy(origin: OriginFor<T>, _n: u32) -> DispatchResult {
+			let _sender = ensure_none(origin)?;
+			Ok(())
+		}
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		TestPallet: pallet_test::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	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 Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl pallet_test::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type LowerBound = ConstU32<1>;
+	type UpperBound = ConstU32<100>;
+}
+
+impl pallet_test::OtherConfig for Test {
+	type OtherEvent = RuntimeEvent;
+}
+
+fn new_test_ext() -> sp_io::TestExternalities {
+	RuntimeGenesisConfig::default().build_storage().unwrap().into()
+}
+
+mod benchmarks {
+	use super::pallet_test::{self, Value};
+	use crate::account;
+	use frame_support::ensure;
+	use frame_system::RawOrigin;
+	use sp_std::prelude::*;
+
+	// Additional used internally by the benchmark macro.
+	use super::pallet_test::{Call, Config, Pallet};
+
+	crate::benchmarks_instance_pallet! {
+		where_clause {
+			where
+				<T as pallet_test::OtherConfig>::OtherEvent: Clone
+					+ Into<<T as pallet_test::Config<I>>::RuntimeEvent>,
+				<T as pallet_test::Config<I>>::RuntimeEvent: Clone,
+		}
+
+		set_value {
+			let b in 1 .. 1000;
+			let caller = account::<T::AccountId>("caller", 0, 0);
+		}: _ (RawOrigin::Signed(caller), b.into())
+		verify {
+			assert_eq!(Value::<T, I>::get(), Some(b));
+		}
+
+		other_name {
+			let b in 1 .. 1000;
+		}: dummy (RawOrigin::None, b.into())
+
+		sort_vector {
+			let x in 1 .. 10000;
+			let mut m = Vec::<u32>::new();
+			for i in (0..x).rev() {
+				m.push(i);
+			}
+		}: {
+			m.sort();
+		} verify {
+			ensure!(m[0] == 0, "You forgot to sort!")
+		}
+
+		impl_benchmark_test_suite!(
+			Pallet,
+			crate::tests_instance::new_test_ext(),
+			crate::tests_instance::Test
+		)
+	}
+}
diff --git a/substrate/frame/benchmarking/src/utils.rs b/substrate/frame/benchmarking/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..59e5192b427b0efcbdeec7ff73628ac5c1632621
--- /dev/null
+++ b/substrate/frame/benchmarking/src/utils.rs
@@ -0,0 +1,384 @@
+// 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.
+
+//! Interfaces, types and utils for benchmarking a FRAME runtime.
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{DispatchError, DispatchErrorWithPostInfo},
+	pallet_prelude::*,
+	traits::StorageInfo,
+};
+use scale_info::TypeInfo;
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+use sp_io::hashing::blake2_256;
+use sp_runtime::traits::TrailingZeroInput;
+use sp_std::{prelude::Box, vec::Vec};
+use sp_storage::TrackedStorageKey;
+
+/// An alphabet of possible parameters to use for benchmarking.
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, Clone, Copy, PartialEq, Debug, TypeInfo)]
+#[allow(missing_docs)]
+#[allow(non_camel_case_types)]
+pub enum BenchmarkParameter {
+	a,
+	b,
+	c,
+	d,
+	e,
+	f,
+	g,
+	h,
+	i,
+	j,
+	k,
+	l,
+	m,
+	n,
+	o,
+	p,
+	q,
+	r,
+	s,
+	t,
+	u,
+	v,
+	w,
+	x,
+	y,
+	z,
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for BenchmarkParameter {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{:?}", self)
+	}
+}
+
+/// The results of a single of benchmark.
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, Clone, PartialEq, Debug, TypeInfo)]
+pub struct BenchmarkBatch {
+	/// The pallet containing this benchmark.
+	#[cfg_attr(feature = "std", serde(with = "serde_as_str"))]
+	pub pallet: Vec<u8>,
+	/// The instance of this pallet being benchmarked.
+	#[cfg_attr(feature = "std", serde(with = "serde_as_str"))]
+	pub instance: Vec<u8>,
+	/// The extrinsic (or benchmark name) of this benchmark.
+	#[cfg_attr(feature = "std", serde(with = "serde_as_str"))]
+	pub benchmark: Vec<u8>,
+	/// The results from this benchmark.
+	pub results: Vec<BenchmarkResult>,
+}
+
+// TODO: could probably make API cleaner here.
+/// The results of a single of benchmark, where time and db results are separated.
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, Clone, PartialEq, Debug)]
+pub struct BenchmarkBatchSplitResults {
+	/// The pallet containing this benchmark.
+	#[cfg_attr(feature = "std", serde(with = "serde_as_str"))]
+	pub pallet: Vec<u8>,
+	/// The instance of this pallet being benchmarked.
+	#[cfg_attr(feature = "std", serde(with = "serde_as_str"))]
+	pub instance: Vec<u8>,
+	/// The extrinsic (or benchmark name) of this benchmark.
+	#[cfg_attr(feature = "std", serde(with = "serde_as_str"))]
+	pub benchmark: Vec<u8>,
+	/// The extrinsic timing results from this benchmark.
+	pub time_results: Vec<BenchmarkResult>,
+	/// The db tracking results from this benchmark.
+	pub db_results: Vec<BenchmarkResult>,
+}
+
+/// Result from running benchmarks on a FRAME pallet.
+/// Contains duration of the function call in nanoseconds along with the benchmark parameters
+/// used for that benchmark result.
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Encode, Decode, Default, Clone, PartialEq, Debug, TypeInfo)]
+pub struct BenchmarkResult {
+	pub components: Vec<(BenchmarkParameter, u32)>,
+	pub extrinsic_time: u128,
+	pub storage_root_time: u128,
+	pub reads: u32,
+	pub repeat_reads: u32,
+	pub writes: u32,
+	pub repeat_writes: u32,
+	pub proof_size: u32,
+	#[cfg_attr(feature = "std", serde(skip))]
+	pub keys: Vec<(Vec<u8>, u32, u32, bool)>,
+}
+
+impl BenchmarkResult {
+	pub fn from_weight(w: Weight) -> Self {
+		Self { extrinsic_time: (w.ref_time() / 1_000) as u128, ..Default::default() }
+	}
+}
+
+/// Helper module to make serde serialize `Vec<u8>` as strings.
+#[cfg(feature = "std")]
+mod serde_as_str {
+	pub fn serialize<S>(value: &Vec<u8>, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: serde::Serializer,
+	{
+		let s = std::str::from_utf8(value).map_err(serde::ser::Error::custom)?;
+		serializer.collect_str(s)
+	}
+
+	pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+	where
+		D: serde::de::Deserializer<'de>,
+	{
+		let s: &str = serde::de::Deserialize::deserialize(deserializer)?;
+		Ok(s.into())
+	}
+}
+
+/// Possible errors returned from the benchmarking pipeline.
+#[derive(Clone, PartialEq, Debug)]
+pub enum BenchmarkError {
+	/// The benchmarking pipeline should stop and return the inner string.
+	Stop(&'static str),
+	/// The benchmarking pipeline is allowed to fail here, and we should use the
+	/// included weight instead.
+	Override(BenchmarkResult),
+	/// The benchmarking pipeline is allowed to fail here, and we should simply
+	/// skip processing these results.
+	Skip,
+	/// No weight can be determined; set the weight of this call to zero.
+	///
+	/// You can also use `Override` instead, but this is easier to use since `Override` expects the
+	/// correct components to be present.
+	Weightless,
+}
+
+impl From<BenchmarkError> for &'static str {
+	fn from(e: BenchmarkError) -> Self {
+		match e {
+			BenchmarkError::Stop(s) => s,
+			BenchmarkError::Override(_) => "benchmark override",
+			BenchmarkError::Skip => "benchmark skip",
+			BenchmarkError::Weightless => "benchmark weightless",
+		}
+	}
+}
+
+impl From<&'static str> for BenchmarkError {
+	fn from(s: &'static str) -> Self {
+		Self::Stop(s)
+	}
+}
+
+impl From<DispatchErrorWithPostInfo> for BenchmarkError {
+	fn from(e: DispatchErrorWithPostInfo) -> Self {
+		Self::Stop(e.into())
+	}
+}
+
+impl From<DispatchError> for BenchmarkError {
+	fn from(e: DispatchError) -> Self {
+		Self::Stop(e.into())
+	}
+}
+
+/// Configuration used to setup and run runtime benchmarks.
+#[derive(Encode, Decode, Default, Clone, PartialEq, Debug, TypeInfo)]
+pub struct BenchmarkConfig {
+	/// The encoded name of the pallet to benchmark.
+	pub pallet: Vec<u8>,
+	/// The encoded name of the benchmark/extrinsic to run.
+	pub benchmark: Vec<u8>,
+	/// The selected component values to use when running the benchmark.
+	pub selected_components: Vec<(BenchmarkParameter, u32)>,
+	/// Enable an extra benchmark iteration which runs the verification logic for a benchmark.
+	pub verify: bool,
+	/// Number of times to repeat benchmark within the Wasm environment. (versus in the client)
+	pub internal_repeats: u32,
+}
+
+/// A list of benchmarks available for a particular pallet and instance.
+///
+/// All `Vec<u8>` must be valid utf8 strings.
+#[derive(Encode, Decode, Default, Clone, PartialEq, Debug, TypeInfo)]
+pub struct BenchmarkList {
+	pub pallet: Vec<u8>,
+	pub instance: Vec<u8>,
+	pub benchmarks: Vec<BenchmarkMetadata>,
+}
+
+#[derive(Encode, Decode, Default, Clone, PartialEq, Debug, TypeInfo)]
+pub struct BenchmarkMetadata {
+	pub name: Vec<u8>,
+	pub components: Vec<(BenchmarkParameter, u32, u32)>,
+	pub pov_modes: Vec<(Vec<u8>, Vec<u8>)>,
+}
+
+sp_api::decl_runtime_apis! {
+	/// Runtime api for benchmarking a FRAME runtime.
+	pub trait Benchmark {
+		/// Get the benchmark metadata available for this runtime.
+		///
+		/// Parameters
+		/// - `extra`: Also list benchmarks marked "extra" which would otherwise not be
+		///            needed for weight calculation.
+		fn benchmark_metadata(extra: bool) -> (Vec<BenchmarkList>, Vec<StorageInfo>);
+
+		/// Dispatch the given benchmark.
+		fn dispatch_benchmark(config: BenchmarkConfig) -> Result<Vec<BenchmarkBatch>, sp_runtime::RuntimeString>;
+	}
+}
+
+/// Interface that provides functions for benchmarking the runtime.
+#[sp_runtime_interface::runtime_interface]
+pub trait Benchmarking {
+	/// Get the number of nanoseconds passed since the UNIX epoch
+	///
+	/// WARNING! This is a non-deterministic call. Do not use this within
+	/// consensus critical logic.
+	fn current_time() -> u128 {
+		std::time::SystemTime::now()
+			.duration_since(std::time::SystemTime::UNIX_EPOCH)
+			.expect("Unix time doesn't go backwards; qed")
+			.as_nanos()
+	}
+
+	/// Reset the trie database to the genesis state.
+	fn wipe_db(&mut self) {
+		self.wipe()
+	}
+
+	/// Commit pending storage changes to the trie database and clear the database cache.
+	fn commit_db(&mut self) {
+		self.commit()
+	}
+
+	/// Get the read/write count.
+	fn read_write_count(&self) -> (u32, u32, u32, u32) {
+		self.read_write_count()
+	}
+
+	/// Reset the read/write count.
+	fn reset_read_write_count(&mut self) {
+		self.reset_read_write_count()
+	}
+
+	/// Get the DB whitelist.
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey> {
+		self.get_whitelist()
+	}
+
+	/// Set the DB whitelist.
+	fn set_whitelist(&mut self, new: Vec<TrackedStorageKey>) {
+		self.set_whitelist(new)
+	}
+
+	// Add a new item to the DB whitelist.
+	fn add_to_whitelist(&mut self, add: TrackedStorageKey) {
+		let mut whitelist = self.get_whitelist();
+		match whitelist.iter_mut().find(|x| x.key == add.key) {
+			// If we already have this key in the whitelist, update to be the most constrained
+			// value.
+			Some(item) => {
+				item.reads += add.reads;
+				item.writes += add.writes;
+				item.whitelisted = item.whitelisted || add.whitelisted;
+			},
+			// If the key does not exist, add it.
+			None => {
+				whitelist.push(add);
+			},
+		}
+		self.set_whitelist(whitelist);
+	}
+
+	// Remove an item from the DB whitelist.
+	fn remove_from_whitelist(&mut self, remove: Vec<u8>) {
+		let mut whitelist = self.get_whitelist();
+		whitelist.retain(|x| x.key != remove);
+		self.set_whitelist(whitelist);
+	}
+
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> {
+		self.get_read_and_written_keys()
+	}
+
+	/// Get current estimated proof size.
+	fn proof_size(&self) -> Option<u32> {
+		self.proof_size()
+	}
+}
+
+/// The pallet benchmarking trait.
+pub trait Benchmarking {
+	/// Get the benchmarks available for this pallet. Generally there is one benchmark per
+	/// extrinsic, so these are sometimes just called "extrinsics".
+	///
+	/// Parameters
+	/// - `extra`: Also return benchmarks marked "extra" which would otherwise not be needed for
+	///   weight calculation.
+	fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata>;
+
+	/// Run the benchmarks for this pallet.
+	fn run_benchmark(
+		name: &[u8],
+		selected_components: &[(BenchmarkParameter, u32)],
+		whitelist: &[TrackedStorageKey],
+		verify: bool,
+		internal_repeats: u32,
+	) -> Result<Vec<BenchmarkResult>, BenchmarkError>;
+}
+
+/// The required setup for creating a benchmark.
+///
+/// Instance generic parameter is optional and can be used in order to capture unused generics for
+/// instantiable pallets.
+pub trait BenchmarkingSetup<T, I = ()> {
+	/// Return the components and their ranges which should be tested in this benchmark.
+	fn components(&self) -> Vec<(BenchmarkParameter, u32, u32)>;
+
+	/// Set up the storage, and prepare a closure to run the benchmark.
+	fn instance(
+		&self,
+		components: &[(BenchmarkParameter, u32)],
+		verify: bool,
+	) -> Result<Box<dyn FnOnce() -> Result<(), BenchmarkError>>, BenchmarkError>;
+}
+
+/// Grab an account, seeded by a name and index.
+pub fn account<AccountId: Decode>(name: &'static str, index: u32, seed: u32) -> AccountId {
+	let entropy = (name, index, seed).using_encoded(blake2_256);
+	Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+		.expect("infinite length input; no invalid inputs for type; qed")
+}
+
+/// This caller account is automatically whitelisted for DB reads/writes by the benchmarking macro.
+pub fn whitelisted_caller<AccountId: Decode>() -> AccountId {
+	account::<AccountId>("whitelisted_caller", 0, 0)
+}
+
+#[macro_export]
+macro_rules! whitelist_account {
+	($acc:ident) => {
+		frame_benchmarking::benchmarking::add_to_whitelist(
+			frame_system::Account::<T>::hashed_key_for(&$acc).into(),
+		);
+	};
+}
diff --git a/substrate/frame/benchmarking/src/v1.rs b/substrate/frame/benchmarking/src/v1.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4ad8cc0edd46ccf554493aac274ca79c679eb642
--- /dev/null
+++ b/substrate/frame/benchmarking/src/v1.rs
@@ -0,0 +1,1990 @@
+// 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.
+
+//! Macros for benchmarking a FRAME runtime.
+
+pub use super::*;
+
+/// Whitelist the given account.
+#[macro_export]
+macro_rules! whitelist {
+	($acc:ident) => {
+		frame_benchmarking::benchmarking::add_to_whitelist(
+			frame_system::Account::<T>::hashed_key_for(&$acc).into(),
+		);
+	};
+}
+
+/// Construct pallet benchmarks for weighing dispatchables.
+///
+/// Works around the idea of complexity parameters, named by a single letter (which is usually
+/// upper cased in complexity notation but is lower-cased for use in this macro).
+///
+/// Complexity parameters ("parameters") have a range which is a `u32` pair. Every time a benchmark
+/// is prepared and run, this parameter takes a concrete value within the range. There is an
+/// associated instancing block, which is a single expression that is evaluated during
+/// preparation. It may use `?` (`i.e. `return Err(...)`) to bail with a string error. Here's a
+/// few examples:
+///
+/// ```ignore
+/// // These two are equivalent:
+/// let x in 0 .. 10;
+/// let x in 0 .. 10 => ();
+/// // This one calls a setup function and might return an error (which would be terminal).
+/// let y in 0 .. 10 => setup(y)?;
+/// // This one uses a code block to do lots of stuff:
+/// let z in 0 .. 10 => {
+///   let a = z * z / 5;
+///   let b = do_something(a)?;
+///   combine_into(z, b);
+/// }
+/// ```
+///
+/// Note that due to parsing restrictions, if the `from` expression is not a single token (i.e. a
+/// literal or constant), then it must be parenthesized.
+///
+/// The macro allows for a number of "arms", each representing an individual benchmark. Using the
+/// simple syntax, the associated dispatchable function maps 1:1 with the benchmark and the name of
+/// the benchmark is the same as that of the associated function. However, extended syntax allows
+/// for arbitrary expressions to be evaluated in a benchmark (including for example,
+/// `on_initialize`).
+///
+/// Note that the ranges are *inclusive* on both sides. This is in contrast to ranges in Rust which
+/// are left-inclusive right-exclusive.
+///
+/// Each arm may also have a block of code which is run prior to any instancing and a block of code
+/// which is run afterwards. All code blocks may draw upon the specific value of each parameter
+/// at any time. Local variables are shared between the two pre- and post- code blocks, but do not
+/// leak from the interior of any instancing expressions.
+///
+/// Example:
+/// ```ignore
+/// benchmarks! {
+///   where_clause {  where T::A: From<u32> } // Optional line to give additional bound on `T`.
+///
+///   // first dispatchable: foo; this is a user dispatchable and operates on a `u8` vector of
+///   // size `l`
+///   foo {
+///     let caller = account::<T>(b"caller", 0, benchmarks_seed);
+///     let l in 1 .. MAX_LENGTH => initialize_l(l);
+///   }: _(RuntimeOrigin::Signed(caller), vec![0u8; l])
+///
+///   // second dispatchable: bar; this is a root dispatchable and accepts a `u8` vector of size
+///   // `l`.
+///   // In this case, we explicitly name the call using `bar` instead of `_`.
+///   bar {
+///     let l in 1 .. MAX_LENGTH => initialize_l(l);
+///   }: bar(RuntimeOrigin::Root, vec![0u8; l])
+///
+///   // third dispatchable: baz; this is a user dispatchable. It isn't dependent on length like the
+///   // other two but has its own complexity `c` that needs setting up. It uses `caller` (in the
+///   // pre-instancing block) within the code block. This is only allowed in the param instancers
+///   // of arms.
+///   baz1 {
+///     let caller = account::<T>(b"caller", 0, benchmarks_seed);
+///     let c = 0 .. 10 => setup_c(&caller, c);
+///   }: baz(RuntimeOrigin::Signed(caller))
+///
+///   // this is a second benchmark of the baz dispatchable with a different setup.
+///   baz2 {
+///     let caller = account::<T>(b"caller", 0, benchmarks_seed);
+///     let c = 0 .. 10 => setup_c_in_some_other_way(&caller, c);
+///   }: baz(RuntimeOrigin::Signed(caller))
+///
+///   // You may optionally specify the origin type if it can't be determined automatically like
+///   // this.
+///   baz3 {
+///     let caller = account::<T>(b"caller", 0, benchmarks_seed);
+///     let l in 1 .. MAX_LENGTH => initialize_l(l);
+///   }: baz<T::RuntimeOrigin>(RuntimeOrigin::Signed(caller), vec![0u8; l])
+///
+///   // this is benchmarking some code that is not a dispatchable.
+///   populate_a_set {
+///     let x in 0 .. 10_000;
+///     let mut m = Vec::<u32>::new();
+///     for i in 0..x {
+///       m.insert(i);
+///     }
+///   }: { m.into_iter().collect::<BTreeSet>() }
+/// }
+/// ```
+///
+/// Test functions are automatically generated for each benchmark and are accessible to you when you
+/// run `cargo test`. All tests are named `test_benchmark_<benchmark_name>`, implemented on the
+/// Pallet struct, and run them in a test externalities environment. The test function runs your
+/// benchmark just like a regular benchmark, but only testing at the lowest and highest values for
+/// each component. The function will return `Ok(())` if the benchmarks return no errors.
+///
+/// It is also possible to generate one #[test] function per benchmark by calling the
+/// `impl_benchmark_test_suite` macro inside the `benchmarks` block. The functions will be named
+/// `bench_<benchmark_name>` and can be run via `cargo test`.
+/// You will see one line of output per benchmark. This approach will give you more understandable
+/// error messages and allows for parallel benchmark execution.
+///
+/// You can optionally add a `verify` code block at the end of a benchmark to test any final state
+/// of your benchmark in a unit test. For example:
+///
+/// ```ignore
+/// sort_vector {
+/// 	let x in 1 .. 10000;
+/// 	let mut m = Vec::<u32>::new();
+/// 	for i in (0..x).rev() {
+/// 		m.push(i);
+/// 	}
+/// }: {
+/// 	m.sort();
+/// } verify {
+/// 	ensure!(m[0] == 0, "You forgot to sort!")
+/// }
+/// ```
+///
+/// These `verify` blocks will not affect your benchmark results!
+///
+/// You can construct benchmark by using the `impl_benchmark_test_suite` macro or
+/// by manually implementing them like so:
+///
+/// ```ignore
+/// #[test]
+/// fn test_benchmarks() {
+///   new_test_ext().execute_with(|| {
+///     assert_ok!(Pallet::<Test>::test_benchmark_dummy());
+///     assert_err!(Pallet::<Test>::test_benchmark_other_name(), "Bad origin");
+///     assert_ok!(Pallet::<Test>::test_benchmark_sort_vector());
+///     assert_err!(Pallet::<Test>::test_benchmark_broken_benchmark(), "You forgot to sort!");
+///   });
+/// }
+/// ```
+#[macro_export]
+macro_rules! benchmarks {
+	(
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter!(
+			{ }
+			{ }
+			{ }
+			( )
+			( )
+			( )
+			( )
+			$( $rest )*
+		);
+	}
+}
+
+/// Same as [`benchmarks`] but for instantiable module.
+///
+/// NOTE: For pallet declared with [`frame_support::pallet`], use [`benchmarks_instance_pallet`].
+#[macro_export]
+macro_rules! benchmarks_instance {
+	(
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter!(
+			{ }
+			{ I: Instance }
+			{ }
+			( )
+			( )
+			( )
+			( )
+			$( $rest )*
+		);
+	}
+}
+
+/// Same as [`benchmarks`] but for instantiable pallet declared [`frame_support::pallet`].
+///
+/// NOTE: For pallet declared with `decl_module!`, use [`benchmarks_instance`].
+#[macro_export]
+macro_rules! benchmarks_instance_pallet {
+	(
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter!(
+			{ }
+			{ I: 'static }
+			{ }
+			( )
+			( )
+			( )
+			( )
+			$( $rest )*
+		);
+	}
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! benchmarks_iter {
+	// detect and extract `impl_benchmark_test_suite` call:
+	// - with a semi-colon
+	(
+		{ }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		impl_benchmark_test_suite!(
+			$bench_module:ident,
+			$new_test_ext:expr,
+			$test:path
+			$(, $( $args:tt )* )?);
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $bench_module, $new_test_ext, $test $(, $( $args )* )? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$( $rest )*
+		}
+	};
+	// - without a semicolon
+	(
+		{ }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		impl_benchmark_test_suite!(
+			$bench_module:ident,
+			$new_test_ext:expr,
+			$test:path
+			$(, $( $args:tt )* )?)
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $bench_module, $new_test_ext, $test $(, $( $args )* )? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$( $rest )*
+		}
+	};
+	// detect and extract where clause:
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		where_clause { where $( $where_bound:tt )* }
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound)? }
+			{ $( $where_bound )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$( $rest )*
+		}
+	};
+	// detect and extract `#[skip_meta]` tag:
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		#[skip_meta]
+		$( #[ $($attributes:tt)+ ] )*
+		$name:ident
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* $name )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$( #[ $( $attributes )+ ] )*
+			$name
+			$( $rest )*
+		}
+	};
+	// detect and extract `#[extra]` tag:
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		#[extra]
+		$( #[ $($attributes:tt)+ ] )*
+		$name:ident
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* $name )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$( #[ $( $attributes )+ ] )*
+			$name
+			$( $rest )*
+		}
+	};
+	// detect and extract `#[pov_mode = Mode { Pallet::Storage: Mode ... }]` tag:
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $old_pov_name:ident: $( $old_storage:path = $old_pov_mode:ident )*; )* )
+		#[pov_mode = $mode:ident $( { $( $storage:path: $pov_mode:ident )* } )?]
+		$( #[ $($attributes:tt)+ ] )*
+		$name:ident
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $name: ALL = $mode $($( $storage = $pov_mode )*)?; $( $old_pov_name: $( $old_storage = $old_pov_mode )*; )* )
+			$( #[ $( $attributes )+ ] )*
+			$name
+			$( $rest )*
+		}
+	};
+	// mutation arm:
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* ) // This contains $( $( { $instance } )? $name:ident )*
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		$name:ident { $( $code:tt )* }: _ $(< $origin_type:ty>)? ( $origin:expr $( , $arg:expr )* )
+		verify $postcode:block
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$name { $( $code )* }: $name $(< $origin_type >)? ( $origin $( , $arg )* )
+			verify $postcode
+			$( $rest )*
+		}
+	};
+	// mutation arm:
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		$name:ident { $( $code:tt )* }: $dispatch:ident $(<$origin_type:ty>)? ( $origin:expr $( , $arg:expr )* )
+		verify $postcode:block
+		$( $rest:tt )*
+	) => {
+		$crate::__private::paste::paste! {
+			$crate::benchmarks_iter! {
+				{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+				{ $( $instance: $instance_bound )? }
+				{ $( $where_clause )* }
+				( $( $names )* )
+				( $( $names_extra )* )
+				( $( $names_skip_meta )* )
+				( $( $pov_name: $( $storage = $pov_mode )*; )* )
+				$name {
+					$( $code )*
+					let __call = Call::<
+						T
+						$( , $instance )?
+					>:: [< new_call_variant_ $dispatch >] (
+						$($arg),*
+					);
+					let __benchmarked_call_encoded = $crate::__private::codec::Encode::encode(
+						&__call
+					);
+				}: {
+					let __call_decoded = <
+						Call<T $(, $instance )?>
+						as $crate::__private::codec::Decode
+					>::decode(&mut &__benchmarked_call_encoded[..])
+						.expect("call is encoded above, encoding must be correct");
+					let __origin = $crate::to_origin!($origin $(, $origin_type)?);
+					<Call<T $(, $instance)? > as $crate::__private::traits::UnfilteredDispatchable
+						>::dispatch_bypass_filter(__call_decoded, __origin)?;
+				}
+				verify $postcode
+				$( $rest )*
+			}
+		}
+	};
+	// iteration arm:
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		$name:ident { $( $code:tt )* }: $eval:block
+		verify $postcode:block
+		$( $rest:tt )*
+	) => {
+		$crate::benchmark_backend! {
+			{ $( $instance: $instance_bound )? }
+			$name
+			{ $( $where_clause )* }
+			{ }
+			{ $eval }
+			{ $( $code )* }
+			$postcode
+		}
+
+		#[cfg(test)]
+		$crate::impl_benchmark_test!(
+			{ $( $where_clause )* }
+			{ $( $instance: $instance_bound )? }
+			$name
+		);
+
+		$crate::benchmarks_iter!(
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* { $( $instance )? } $name )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$( $rest )*
+		);
+	};
+	// iteration-exit arm which generates a #[test] function for each case.
+	(
+		{ $bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+	) => {
+		$crate::selected_benchmark!(
+			{ $( $where_clause)* }
+			{ $( $instance: $instance_bound )? }
+			$( $names )*
+		);
+		$crate::impl_benchmark!(
+			{ $( $where_clause )* }
+			{ $( $instance: $instance_bound )? }
+			( $( $names )* )
+			( $( $names_extra ),* )
+			( $( $names_skip_meta ),* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+		);
+		$crate::impl_test_function!(
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			$bench_module,
+			$new_test_ext,
+			$test
+			$(, $( $args )* )?
+		);
+	};
+	// iteration-exit arm which doesn't generate a #[test] function for all cases.
+	(
+		{ }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+	) => {
+		$crate::selected_benchmark!(
+			{ $( $where_clause)* }
+			{ $( $instance: $instance_bound )? }
+			$( $names )*
+		);
+		$crate::impl_benchmark!(
+			{ $( $where_clause )* }
+			{ $( $instance: $instance_bound )? }
+			( $( $names )* )
+			( $( $names_extra ),* )
+			( $( $names_skip_meta ),* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+		);
+	};
+	// add verify block to _() format
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		$name:ident { $( $code:tt )* }: _ $(<$origin_type:ty>)? ( $origin:expr $( , $arg:expr )* )
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$name { $( $code )* }: _ $(<$origin_type>)? ( $origin $( , $arg )* )
+			verify { }
+			$( $rest )*
+		}
+	};
+	// add verify block to name() format
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		$name:ident { $( $code:tt )* }: $dispatch:ident $(<$origin_type:ty>)? ( $origin:expr $( , $arg:expr )* )
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter! {
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$name { $( $code )* }: $dispatch $(<$origin_type>)? ( $origin $( , $arg )* )
+			verify { }
+			$( $rest )*
+		}
+	};
+	// add verify block to {} format
+	(
+		{ $($bench_module:ident, $new_test_ext:expr, $test:path $(, $( $args:tt )* )?)? }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		{ $( $where_clause:tt )* }
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+		$name:ident { $( $code:tt )* }: $(<$origin_type:ty>)? $eval:block
+		$( $rest:tt )*
+	) => {
+		$crate::benchmarks_iter!(
+			{ $($bench_module, $new_test_ext, $test $(, $( $args )* )?)? }
+			{ $( $instance: $instance_bound )? }
+			{ $( $where_clause )* }
+			( $( $names )* )
+			( $( $names_extra )* )
+			( $( $names_skip_meta )* )
+			( $( $pov_name: $( $storage = $pov_mode )*; )* )
+			$name { $( $code )* }: $(<$origin_type>)? $eval
+			verify { }
+			$( $rest )*
+		);
+	};
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! to_origin {
+	($origin:expr) => {
+		$origin.into()
+	};
+	($origin:expr, $origin_type:ty) => {
+		<<T as frame_system::Config>::RuntimeOrigin as From<$origin_type>>::from($origin)
+	};
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! benchmark_backend {
+	// parsing arms
+	(
+		{ $( $instance:ident: $instance_bound:tt )? }
+		$name:ident
+		{ $( $where_clause:tt )* }
+		{ $( PRE { $( $pre_parsed:tt )* } )* }
+		{ $eval:block }
+		{
+			let $pre_id:tt $( : $pre_ty:ty )? = $pre_ex:expr;
+			$( $rest:tt )*
+		}
+		$postcode:block
+	) => {
+		$crate::benchmark_backend! {
+			{ $( $instance: $instance_bound )? }
+			$name
+			{ $( $where_clause )* }
+			{
+				$( PRE { $( $pre_parsed )* } )*
+				PRE { $pre_id , $( $pre_ty , )? $pre_ex }
+			}
+			{ $eval }
+			{ $( $rest )* }
+			$postcode
+		}
+	};
+	(
+		{ $( $instance:ident: $instance_bound:tt )? }
+		$name:ident
+		{ $( $where_clause:tt )* }
+		{ $( $parsed:tt )* }
+		{ $eval:block }
+		{
+			let $param:ident in ( $param_from:expr ) .. $param_to:expr => $param_instancer:expr;
+			$( $rest:tt )*
+		}
+		$postcode:block
+	) => {
+		$crate::benchmark_backend! {
+			{ $( $instance: $instance_bound )? }
+			$name
+			{ $( $where_clause )* }
+			{
+				$( $parsed )*
+				PARAM { $param , $param_from , $param_to , $param_instancer }
+			}
+			{ $eval }
+			{ $( $rest )* }
+			$postcode
+		}
+	};
+	// mutation arm to look after a single tt for param_from.
+	(
+		{ $( $instance:ident: $instance_bound:tt )? }
+		$name:ident
+		{ $( $where_clause:tt )* }
+		{ $( $parsed:tt )* }
+		{ $eval:block }
+		{
+			let $param:ident in $param_from:tt .. $param_to:expr => $param_instancer:expr ;
+			$( $rest:tt )*
+		}
+		$postcode:block
+	) => {
+		$crate::benchmark_backend! {
+			{ $( $instance: $instance_bound )? }
+			$name
+			{ $( $where_clause )* }
+			{ $( $parsed )* }
+			{ $eval }
+			{
+				let $param in ( $param_from ) .. $param_to => $param_instancer;
+				$( $rest )*
+			}
+			$postcode
+		}
+	};
+	// mutation arm to look after the default tail of `=> ()`
+	(
+		{ $( $instance:ident: $instance_bound:tt )? }
+		$name:ident
+		{ $( $where_clause:tt )* }
+		{ $( $parsed:tt )* }
+		{ $eval:block }
+		{
+			let $param:ident in $param_from:tt .. $param_to:expr;
+			$( $rest:tt )*
+		}
+		$postcode:block
+	) => {
+		$crate::benchmark_backend! {
+			{ $( $instance: $instance_bound )? }
+			$name
+			{ $( $where_clause )* }
+			{ $( $parsed )* }
+			{ $eval }
+			{
+				let $param in $param_from .. $param_to => ();
+				$( $rest )*
+			}
+			$postcode
+		}
+	};
+	// actioning arm
+	(
+		{ $( $instance:ident: $instance_bound:tt )? }
+		$name:ident
+		{ $( $where_clause:tt )* }
+		{
+			$( PRE { $pre_id:tt , $( $pre_ty:ty , )? $pre_ex:expr } )*
+			$( PARAM { $param:ident , $param_from:expr , $param_to:expr , $param_instancer:expr } )*
+		}
+		{ $eval:block }
+		{ $( $post:tt )* }
+		$postcode:block
+	) => {
+		#[allow(non_camel_case_types)]
+		struct $name;
+		#[allow(unused_variables)]
+		impl<T: Config $( <$instance>, $instance: $instance_bound )? >
+			$crate::BenchmarkingSetup<T $(, $instance)? > for $name
+			where $( $where_clause )*
+		{
+			fn components(&self) -> $crate::__private::Vec<($crate::BenchmarkParameter, u32, u32)> {
+				$crate::__private::vec! [
+					$(
+						($crate::BenchmarkParameter::$param, $param_from, $param_to)
+					),*
+				]
+			}
+
+			fn instance(
+				&self,
+				components: &[($crate::BenchmarkParameter, u32)],
+				verify: bool
+			) -> Result<$crate::__private::Box<dyn FnOnce() -> Result<(), $crate::BenchmarkError>>, $crate::BenchmarkError> {
+				$(
+					// Prepare instance
+					let $param = components.iter()
+						.find(|&c| c.0 == $crate::BenchmarkParameter::$param)
+						.ok_or("Could not find component in benchmark preparation.")?
+						.1;
+				)*
+				$(
+					let $pre_id $( : $pre_ty )? = $pre_ex;
+				)*
+				$( $param_instancer ; )*
+				$( $post )*
+
+				Ok($crate::__private::Box::new(move || -> Result<(), $crate::BenchmarkError> {
+					$eval;
+					if verify {
+						$postcode;
+					}
+					Ok(())
+				}))
+			}
+		}
+	};
+}
+
+// Creates #[test] functions for the given bench cases.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! impl_bench_case_tests {
+	(
+		{ $module:ident, $new_test_exec:expr, $exec_name:ident, $test:path, $extra:expr }
+		{ $( $names_extra:tt )* }
+		$( { $( $bench_inst:ident )? } $bench:ident )*
+	)
+	=> {
+		$crate::impl_bench_name_tests!(
+			$module, $new_test_exec, $exec_name, $test, $extra,
+			{ $( $names_extra )* },
+			$( { $bench } )+
+		);
+	}
+}
+
+// Creates a #[test] function for the given bench name.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! impl_bench_name_tests {
+	// recursion anchor
+	(
+		$module:ident, $new_test_exec:expr, $exec_name:ident, $test:path, $extra:expr,
+		{ $( $names_extra:tt )* },
+		{ $name:ident }
+	) => {
+		$crate::__private::paste::paste! {
+			#[test]
+			fn [<bench_ $name>] () {
+				$new_test_exec.$exec_name(|| {
+					// Skip all #[extra] benchmarks if $extra is false.
+					if !($extra) {
+						let disabled = $crate::__private::vec![ $( stringify!($names_extra).as_ref() ),* ];
+						if disabled.contains(&stringify!($name)) {
+							$crate::__private::log::error!(
+								"INFO: extra benchmark skipped - {}",
+								stringify!($name),
+							);
+							return ();
+						}
+					}
+
+					// Same per-case logic as when all cases are run in the
+					// same function.
+					match std::panic::catch_unwind(|| {
+						$module::<$test>::[< test_benchmark_ $name >] ()
+					}) {
+						Err(err) => {
+							panic!("{}: {:?}", stringify!($name), err);
+						},
+						Ok(Err(err)) => {
+							match err {
+								$crate::BenchmarkError::Stop(err) => {
+									panic!("{}: {:?}", stringify!($name), err);
+								},
+								$crate::BenchmarkError::Override(_) => {
+									// This is still considered a success condition.
+									$crate::__private::log::error!(
+										"WARNING: benchmark error overrided - {}",
+										stringify!($name),
+									);
+								},
+								$crate::BenchmarkError::Skip => {
+									// This is considered a success condition.
+									$crate::__private::log::error!(
+										"WARNING: benchmark error skipped - {}",
+										stringify!($name),
+									);
+								},
+								$crate::BenchmarkError::Weightless => {
+									// This is considered a success condition.
+									$crate::__private::log::error!(
+										"WARNING: benchmark weightless skipped - {}",
+										stringify!($name),
+									);
+								}
+							}
+						},
+						Ok(Ok(())) => (),
+					}
+				});
+			}
+		}
+	};
+	// recursion tail
+    (
+		$module:ident, $new_test_exec:expr, $exec_name:ident, $test:path, $extra:expr,
+		{ $( $names_extra:tt )* },
+		{ $name:ident } $( { $rest:ident } )+
+	) => {
+		// car
+		$crate::impl_bench_name_tests!($module, $new_test_exec, $exec_name, $test, $extra,
+			{ $( $names_extra )* }, { $name });
+		// cdr
+		$crate::impl_bench_name_tests!($module, $new_test_exec, $exec_name, $test, $extra,
+			{ $( $names_extra )* }, $( { $rest } )+);
+	};
+}
+
+// Creates a `SelectedBenchmark` enum implementing `BenchmarkingSetup`.
+//
+// Every variant must implement [`BenchmarkingSetup`].
+//
+// ```nocompile
+// 
+// struct Transfer;
+// impl BenchmarkingSetup for Transfer { ... }
+//
+// struct SetBalance;
+// impl BenchmarkingSetup for SetBalance { ... }
+//
+// selected_benchmark!({} Transfer {} SetBalance);
+// ```
+#[macro_export]
+#[doc(hidden)]
+macro_rules! selected_benchmark {
+	(
+		{ $( $where_clause:tt )* }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		$( { $( $bench_inst:ident )? } $bench:ident )*
+	) => {
+		// The list of available benchmarks for this pallet.
+		#[allow(non_camel_case_types)]
+		enum SelectedBenchmark {
+			$( $bench, )*
+		}
+
+		// Allow us to select a benchmark from the list of available benchmarks.
+		impl<T: Config $( <$instance>, $instance: $instance_bound )? >
+			$crate::BenchmarkingSetup<T $(, $instance )? > for SelectedBenchmark
+			where $( $where_clause )*
+		{
+			fn components(&self) -> $crate::__private::Vec<($crate::BenchmarkParameter, u32, u32)> {
+				match self {
+					$(
+						Self::$bench => <
+							$bench as $crate::BenchmarkingSetup<T $(, $bench_inst)? >
+						>::components(&$bench),
+					)*
+				}
+			}
+
+			fn instance(
+				&self,
+				components: &[($crate::BenchmarkParameter, u32)],
+				verify: bool
+			) -> Result<$crate::__private::Box<dyn FnOnce() -> Result<(), $crate::BenchmarkError>>, $crate::BenchmarkError> {
+				match self {
+					$(
+						Self::$bench => <
+							$bench as $crate::BenchmarkingSetup<T $(, $bench_inst)? >
+						>::instance(&$bench, components, verify),
+					)*
+				}
+			}
+		}
+	};
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! impl_benchmark {
+	(
+		{ $( $where_clause:tt )* }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		( $( { $( $name_inst:ident )? } $name:ident )* )
+		( $( $name_extra:ident ),* )
+		( $( $name_skip_meta:ident ),* )
+		( $( $pov_name:ident: $( $storage:path = $pov_mode:ident )*; )* )
+	) => {
+		// We only need to implement benchmarks for the runtime-benchmarks feature or testing.
+		#[cfg(any(feature = "runtime-benchmarks", test))]
+		impl<T: Config $(<$instance>, $instance: $instance_bound )? >
+			$crate::Benchmarking for Pallet<T $(, $instance)? >
+			where T: frame_system::Config, $( $where_clause )*
+		{
+			fn benchmarks(extra: bool) -> $crate::__private::Vec<$crate::BenchmarkMetadata> {
+				$($crate::validate_pov_mode!(
+					$pov_name: $( $storage = $pov_mode )*;
+				);)*
+				let mut all_names = $crate::__private::vec![ $( stringify!($name).as_ref() ),* ];
+				if !extra {
+					let extra = [ $( stringify!($name_extra).as_ref() ),* ];
+					all_names.retain(|x| !extra.contains(x));
+				}
+				let pov_modes: $crate::__private::Vec<($crate::__private::Vec<u8>, $crate::__private::Vec<($crate::__private::Vec<u8>, $crate::__private::Vec<u8>)>)> = $crate::__private::vec![
+					$(
+						(stringify!($pov_name).as_bytes().to_vec(),
+						$crate::__private::vec![
+							$( ( stringify!($storage).as_bytes().to_vec(),
+								 stringify!($pov_mode).as_bytes().to_vec() ), )*
+						]),
+					)*
+				];
+				all_names.into_iter().map(|benchmark| {
+					let selected_benchmark = match benchmark {
+						$( stringify!($name) => SelectedBenchmark::$name, )*
+						_ => panic!("all benchmarks should be selectable"),
+					};
+					let name = benchmark.as_bytes().to_vec();
+					let components = <
+						SelectedBenchmark as $crate::BenchmarkingSetup<T $(, $instance)?>
+					>::components(&selected_benchmark);
+
+					$crate::BenchmarkMetadata {
+						name: name.clone(),
+						components,
+						pov_modes: pov_modes.iter().find(|p| p.0 == name).map(|p| p.1.clone()).unwrap_or_default(),
+					}
+				}).collect::<$crate::__private::Vec<_>>()
+			}
+
+			fn run_benchmark(
+				extrinsic: &[u8],
+				c: &[($crate::BenchmarkParameter, u32)],
+				whitelist: &[$crate::__private::TrackedStorageKey],
+				verify: bool,
+				internal_repeats: u32,
+			) -> Result<$crate::__private::Vec<$crate::BenchmarkResult>, $crate::BenchmarkError> {
+				// Map the input to the selected benchmark.
+				let extrinsic = $crate::__private::str::from_utf8(extrinsic)
+					.map_err(|_| "`extrinsic` is not a valid utf8 string!")?;
+				let selected_benchmark = match extrinsic {
+					$( stringify!($name) => SelectedBenchmark::$name, )*
+					_ => return Err("Could not find extrinsic.".into()),
+				};
+
+				// Add whitelist to DB including whitelisted caller
+				let mut whitelist = whitelist.to_vec();
+				let whitelisted_caller_key =
+					<frame_system::Account::<T> as $crate::__private::storage::StorageMap<_,_>>::hashed_key_for(
+						$crate::whitelisted_caller::<T::AccountId>()
+					);
+				whitelist.push(whitelisted_caller_key.into());
+				// Whitelist the transactional layer.
+				let transactional_layer_key = $crate::__private::TrackedStorageKey::new(
+					$crate::__private::storage::transactional::TRANSACTION_LEVEL_KEY.into()
+				);
+				whitelist.push(transactional_layer_key);
+				// Whitelist the `:extrinsic_index`.
+				let extrinsic_index = $crate::__private::TrackedStorageKey::new(
+					$crate::__private::well_known_keys::EXTRINSIC_INDEX.into()
+				);
+				whitelist.push(extrinsic_index);
+				// Whitelist the `:intrablock_entropy`.
+				let intrablock_entropy = $crate::__private::TrackedStorageKey::new(
+					$crate::__private::well_known_keys::INTRABLOCK_ENTROPY.into()
+				);
+				whitelist.push(intrablock_entropy);
+
+				$crate::benchmarking::set_whitelist(whitelist.clone());
+
+				let mut results: $crate::__private::Vec<$crate::BenchmarkResult> = $crate::__private::Vec::new();
+
+				// Always do at least one internal repeat...
+				for _ in 0 .. internal_repeats.max(1) {
+					// Always reset the state after the benchmark.
+					$crate::__private::defer!($crate::benchmarking::wipe_db());
+
+					// Set up the externalities environment for the setup we want to
+					// benchmark.
+					let closure_to_benchmark = <
+						SelectedBenchmark as $crate::BenchmarkingSetup<T $(, $instance)?>
+					>::instance(&selected_benchmark, c, verify)?;
+
+					// Set the block number to at least 1 so events are deposited.
+					if $crate::__private::Zero::is_zero(&frame_system::Pallet::<T>::block_number()) {
+						frame_system::Pallet::<T>::set_block_number(1u32.into());
+					}
+
+					// Commit the externalities to the database, flushing the DB cache.
+					// This will enable worst case scenario for reading from the database.
+					$crate::benchmarking::commit_db();
+
+					// Access all whitelisted keys to get them into the proof recorder since the
+					// recorder does now have a whitelist.
+					for key in &whitelist {
+						$crate::__private::storage::unhashed::get_raw(&key.key);
+					}
+
+					// Reset the read/write counter so we don't count operations in the setup process.
+					$crate::benchmarking::reset_read_write_count();
+
+					// Time the extrinsic logic.
+					$crate::__private::log::trace!(
+						target: "benchmark",
+						"Start Benchmark: {} ({:?}) verify {}",
+						extrinsic,
+						c,
+						verify
+					);
+
+					let start_pov = $crate::benchmarking::proof_size();
+					let start_extrinsic = $crate::benchmarking::current_time();
+
+					closure_to_benchmark()?;
+
+					let finish_extrinsic = $crate::benchmarking::current_time();
+					let end_pov = $crate::benchmarking::proof_size();
+
+					// Calculate the diff caused by the benchmark.
+					let elapsed_extrinsic = finish_extrinsic.saturating_sub(start_extrinsic);
+					let diff_pov = match (start_pov, end_pov) {
+						(Some(start), Some(end)) => end.saturating_sub(start),
+						_ => Default::default(),
+					};
+
+					// Commit the changes to get proper write count
+					$crate::benchmarking::commit_db();
+					$crate::__private::log::trace!(
+						target: "benchmark",
+						"End Benchmark: {} ns", elapsed_extrinsic
+					);
+					let read_write_count = $crate::benchmarking::read_write_count();
+					$crate::__private::log::trace!(
+						target: "benchmark",
+						"Read/Write Count {:?}", read_write_count
+					);
+					$crate::__private::log::trace!(
+						target: "benchmark",
+						"Proof sizes: before {:?} after {:?} diff {}", &start_pov, &end_pov, &diff_pov
+					);
+
+					// Time the storage root recalculation.
+					let start_storage_root = $crate::benchmarking::current_time();
+					$crate::__private::storage_root($crate::__private::StateVersion::V1);
+					let finish_storage_root = $crate::benchmarking::current_time();
+					let elapsed_storage_root = finish_storage_root - start_storage_root;
+
+					let skip_meta = [ $( stringify!($name_skip_meta).as_ref() ),* ];
+					let read_and_written_keys = if skip_meta.contains(&extrinsic) {
+						$crate::__private::vec![(b"Skipped Metadata".to_vec(), 0, 0, false)]
+					} else {
+						$crate::benchmarking::get_read_and_written_keys()
+					};
+
+					results.push($crate::BenchmarkResult {
+						components: c.to_vec(),
+						extrinsic_time: elapsed_extrinsic,
+						storage_root_time: elapsed_storage_root,
+						reads: read_write_count.0,
+						repeat_reads: read_write_count.1,
+						writes: read_write_count.2,
+						repeat_writes: read_write_count.3,
+						proof_size: diff_pov,
+						keys: read_and_written_keys,
+					});
+				}
+
+				return Ok(results);
+			}
+		}
+
+		#[cfg(test)]
+		impl<T: Config $(<$instance>, $instance: $instance_bound )? >
+			Pallet<T $(, $instance)? >
+		where T: frame_system::Config, $( $where_clause )*
+		{
+			/// Test a particular benchmark by name.
+			///
+			/// This isn't called `test_benchmark_by_name` just in case some end-user eventually
+			/// writes a benchmark, itself called `by_name`; the function would be shadowed in
+			/// that case.
+			///
+			/// This is generally intended to be used by child test modules such as those created
+			/// by the `impl_benchmark_test_suite` macro. However, it is not an error if a pallet
+			/// author chooses not to implement benchmarks.
+			#[allow(unused)]
+			fn test_bench_by_name(name: &[u8]) -> Result<(), $crate::BenchmarkError> {
+				let name = $crate::__private::str::from_utf8(name)
+					.map_err(|_| -> $crate::BenchmarkError { "`name` is not a valid utf8 string!".into() })?;
+				match name {
+					$( stringify!($name) => {
+						$crate::__private::paste::paste! { Self::[< test_benchmark_ $name >]() }
+					} )*
+					_ => Err("Could not find test for requested benchmark.".into()),
+				}
+			}
+		}
+	};
+}
+
+// This creates a unit test for one benchmark of the main benchmark macro.
+// It runs the benchmark using the `high` and `low` value for each component
+// and ensure that everything completes successfully.
+// Instances each component with six values which can be controlled with the
+// env variable `VALUES_PER_COMPONENT`.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! impl_benchmark_test {
+	(
+		{ $( $where_clause:tt )* }
+		{ $( $instance:ident: $instance_bound:tt )? }
+		$name:ident
+	) => {
+		$crate::__private::paste::item! {
+			#[cfg(test)]
+			impl<T: Config $(<$instance>, $instance: $instance_bound )? >
+				Pallet<T $(, $instance)? >
+			where T: frame_system::Config, $( $where_clause )*
+			{
+				#[allow(unused)]
+				fn [<test_benchmark_ $name>] () -> Result<(), $crate::BenchmarkError> {
+					let selected_benchmark = SelectedBenchmark::$name;
+					let components = <
+						SelectedBenchmark as $crate::BenchmarkingSetup<T, _>
+					>::components(&selected_benchmark);
+
+					let execute_benchmark = |
+						c: $crate::__private::Vec<($crate::BenchmarkParameter, u32)>
+					| -> Result<(), $crate::BenchmarkError> {
+						// Always reset the state after the benchmark.
+						$crate::__private::defer!($crate::benchmarking::wipe_db());
+
+						// Set up the benchmark, return execution + verification function.
+						let closure_to_verify = <
+							SelectedBenchmark as $crate::BenchmarkingSetup<T, _>
+						>::instance(&selected_benchmark, &c, true)?;
+
+						// Set the block number to at least 1 so events are deposited.
+						if $crate::__private::Zero::is_zero(&frame_system::Pallet::<T>::block_number()) {
+							frame_system::Pallet::<T>::set_block_number(1u32.into());
+						}
+
+						// Run execution + verification
+						closure_to_verify()
+					};
+
+					if components.is_empty() {
+						execute_benchmark(Default::default())?;
+					} else {
+						let num_values: u32 = if let Ok(ev) = std::env::var("VALUES_PER_COMPONENT") {
+							ev.parse().map_err(|_| {
+								$crate::BenchmarkError::Stop(
+									"Could not parse env var `VALUES_PER_COMPONENT` as u32."
+								)
+							})?
+						} else {
+							6
+						};
+
+						if num_values < 2 {
+							return Err("`VALUES_PER_COMPONENT` must be at least 2".into());
+						}
+
+						for (name, low, high) in components.clone().into_iter() {
+							// Test the lowest, highest (if its different from the lowest)
+							// and up to num_values-2 more equidistant values in between.
+							// For 0..10 and num_values=6 this would mean: [0, 2, 4, 6, 8, 10]
+
+							let mut values = $crate::__private::vec![low];
+							let diff = (high - low).min(num_values - 1);
+							let slope = (high - low) as f32 / diff as f32;
+
+							for i in 1..=diff {
+								let value = ((low as f32 + slope * i as f32) as u32)
+												.clamp(low, high);
+								values.push(value);
+							}
+
+							for component_value in values {
+								// Select the max value for all the other components.
+								let c: $crate::__private::Vec<($crate::BenchmarkParameter, u32)> = components
+									.iter()
+									.map(|(n, _, h)|
+										if *n == name {
+											(*n, component_value)
+										} else {
+											(*n, *h)
+										}
+									)
+									.collect();
+
+								execute_benchmark(c)?;
+							}
+						}
+					}
+					Ok(())
+				}
+			}
+		}
+	};
+}
+
+/// This creates a test suite which runs the module's benchmarks.
+///
+/// When called in `pallet_example_basic` as
+///
+/// ```rust,ignore
+/// impl_benchmark_test_suite!(Pallet, crate::tests::new_test_ext(), crate::tests::Test);
+/// ```
+///
+/// It expands to the equivalent of:
+///
+/// ```rust,ignore
+/// #[cfg(test)]
+/// mod tests {
+/// 	use super::*;
+/// 	use crate::tests::{new_test_ext, Test};
+/// 	use frame_support::assert_ok;
+///
+/// 	#[test]
+/// 	fn test_benchmarks() {
+/// 		new_test_ext().execute_with(|| {
+/// 			assert_ok!(test_benchmark_accumulate_dummy::<Test>());
+/// 			assert_ok!(test_benchmark_set_dummy::<Test>());
+/// 			assert_ok!(test_benchmark_sort_vector::<Test>());
+/// 		});
+/// 	}
+/// }
+/// ```
+///
+/// When called inside the `benchmarks` macro of the `pallet_example_basic` as
+///
+/// ```rust,ignore
+/// benchmarks! {
+/// 	// Benchmarks omitted for brevity
+///
+/// 	impl_benchmark_test_suite!(Pallet, crate::tests::new_test_ext(), crate::tests::Test);
+/// }
+/// ```
+///
+/// It expands to the equivalent of:
+///
+/// ```rust,ignore
+/// #[cfg(test)]
+/// mod benchmarking {
+/// 	use super::*;
+/// 	use crate::tests::{new_test_ext, Test};
+/// 	use frame_support::assert_ok;
+///
+/// 	#[test]
+/// 	fn bench_accumulate_dummy() {
+/// 		new_test_ext().execute_with(|| {
+/// 			assert_ok!(test_benchmark_accumulate_dummy::<Test>());
+/// 		})
+/// 	}
+///
+/// 	#[test]
+/// 	fn bench_set_dummy() {
+/// 		new_test_ext().execute_with(|| {
+/// 			assert_ok!(test_benchmark_set_dummy::<Test>());
+/// 		})
+/// 	}
+///
+/// 	#[test]
+/// 	fn bench_sort_vector() {
+/// 		new_test_ext().execute_with(|| {
+/// 			assert_ok!(test_benchmark_sort_vector::<Test>());
+/// 		})
+/// 	}
+/// }
+/// ```
+///
+/// ## Arguments
+///
+/// The first argument, `module`, must be the path to this crate's module.
+///
+/// The second argument, `new_test_ext`, must be a function call which returns either a
+/// `sp_io::TestExternalities`, or some other type with a similar interface.
+///
+/// Note that this function call is _not_ evaluated at compile time, but is instead copied textually
+/// into each appropriate invocation site.
+///
+/// The third argument, `test`, must be the path to the runtime. The item to which this must refer
+/// will generally take the form:
+///
+/// ```rust,ignore
+/// frame_support::construct_runtime!(
+/// 	pub enum Test where ...
+/// 	{ ... }
+/// );
+/// ```
+///
+/// There is an optional fourth argument, with keyword syntax: `benchmarks_path =
+/// path_to_benchmarks_invocation`. In the typical case in which this macro is in the same module as
+/// the `benchmarks!` invocation, you don't need to supply this. However, if the
+/// `impl_benchmark_test_suite!` invocation is in a different module than the `benchmarks!`
+/// invocation, then you should provide the path to the module containing the `benchmarks!`
+/// invocation:
+///
+/// ```rust,ignore
+/// mod benches {
+/// 	benchmarks!{
+/// 		...
+/// 	}
+/// }
+///
+/// mod tests {
+/// 	// because of macro syntax limitations, neither Pallet nor benches can be paths, but both have
+/// 	// to be idents in the scope of `impl_benchmark_test_suite`.
+/// 	use crate::{benches, Pallet};
+///
+/// 	impl_benchmark_test_suite!(Pallet, new_test_ext(), Test, benchmarks_path = benches);
+///
+/// 	// new_test_ext and the Test item are defined later in this module
+/// }
+/// ```
+///
+/// There is an optional fifth argument, with keyword syntax: `extra = true` or `extra = false`.
+/// By default, this generates a test suite which iterates over all benchmarks, including those
+/// marked with the `#[extra]` annotation. Setting `extra = false` excludes those.
+///
+/// There is an optional sixth argument, with keyword syntax: `exec_name = custom_exec_name`.
+/// By default, this macro uses `execute_with` for this parameter. This argument, if set, is subject
+/// to these restrictions:
+///
+/// - It must be the name of a method applied to the output of the `new_test_ext` argument.
+/// - That method must have a signature capable of receiving a single argument of the form `impl
+///   FnOnce()`.
+// ## Notes (not for rustdoc)
+//
+// The biggest challenge for this macro is communicating the actual test functions to be run. We
+// can't just build an array of function pointers to each test function and iterate over it, because
+// the test functions are parameterized by the `Test` type. That's incompatible with
+// monomorphization: if it were legal, then even if the compiler detected and monomorphized the
+// functions into only the types of the callers, which implementation would the function pointer
+// point to? There would need to be some kind of syntax for selecting the destination of the pointer
+// according to a generic argument, and in general it would be a huge mess and not worth it.
+//
+// Instead, we're going to steal a trick from `fn run_benchmark`: generate a function which is
+// itself parametrized by `Test`, which accepts a `&[u8]` parameter containing the name of the
+// benchmark, and dispatches based on that to the appropriate real test implementation. Then, we can
+// just iterate over the `Benchmarking::benchmarks` list to run the actual implementations.
+#[macro_export]
+macro_rules! impl_benchmark_test_suite {
+	(
+		$bench_module:ident,
+		$new_test_ext:expr,
+		$test:path
+		$(, $( $rest:tt )* )?
+	) => {
+		$crate::impl_test_function!(
+			()
+			()
+			()
+			$bench_module,
+			$new_test_ext,
+			$test
+			$(, $( $rest )* )?
+		);
+	}
+}
+
+/// Validates the passed `pov_mode`s.
+///
+/// Checks that:
+/// - a top-level `ignored` is exclusive
+/// - all modes are valid
+#[macro_export]
+macro_rules! validate_pov_mode {
+	() => {};
+	( $_bench:ident: ; ) => { };
+	( $_bench:ident: $_car:path = Ignored ; ) => { };
+	( $bench:ident: $_car:path = Ignored $( $storage:path = $_pov_mode:ident )+; ) => {
+		compile_error!(
+			concat!(concat!("`pov_mode = Ignored` is exclusive. Please remove the attribute from keys: ", $( stringify!($storage) )+), " on benchmark '", stringify!($bench), "'"));
+	};
+	( $bench:ident: $car:path = Measured $( $storage:path = $pov_mode:ident )*; ) => {
+		$crate::validate_pov_mode!(
+			$bench: $( $storage = $pov_mode )*;
+		);
+	};
+	( $bench:ident: $car:path = MaxEncodedLen $( $storage:path = $pov_mode:ident )*; ) => {
+		$crate::validate_pov_mode!(
+			$bench: $( $storage = $pov_mode )*;
+		);
+	};
+	( $bench:ident: $key:path = $unknown:ident $( $_storage:path = $_pov_mode:ident )*; ) => {
+		compile_error!(
+			concat!("Unknown pov_mode '", stringify!($unknown) ,"' for benchmark '", stringify!($bench), "' on key '", stringify!($key), "'. Must be one of: Ignored, Measured, MaxEncodedLen")
+		);
+	};
+}
+
+// Takes all arguments from `impl_benchmark_test_suite` and three additional arguments.
+//
+// Can be configured to generate one #[test] fn per bench case or
+// one #[test] fn for all bench cases.
+// This depends on whether or not the first argument contains a non-empty list of bench names.
+#[macro_export]
+#[doc(hidden)]
+macro_rules! impl_test_function {
+	// user might or might not have set some keyword arguments; set the defaults
+	//
+	// The weird syntax indicates that `rest` comes only after a comma, which is otherwise optional
+	(
+		( $( $names:tt )* )
+		( $( $names_extra:tt )* )
+		( $( $names_skip_meta:tt )* )
+
+		$bench_module:ident,
+		$new_test_ext:expr,
+		$test:path
+		$(, $( $rest:tt )* )?
+	) => {
+		$crate::impl_test_function!(
+			@cases:
+				( $( $names )* )
+				( $( $names_extra )* )
+				( $( $names_skip_meta )* )
+			@selected:
+				$bench_module,
+				$new_test_ext,
+				$test,
+				benchmarks_path = super,
+				extra = true,
+				exec_name = execute_with,
+			@user:
+				$( $( $rest )* )?
+		);
+	};
+	// pick off the benchmarks_path keyword argument
+	(
+		@cases:
+			( $( $names:tt )* )
+			( $( $names_extra:tt )* )
+			( $( $names_skip_meta:tt )* )
+		@selected:
+			$bench_module:ident,
+			$new_test_ext:expr,
+			$test:path,
+			benchmarks_path = $old:ident,
+			extra = $extra:expr,
+			exec_name = $exec_name:ident,
+		@user:
+			benchmarks_path = $benchmarks_path:ident
+			$(, $( $rest:tt )* )?
+	) => {
+		$crate::impl_test_function!(
+			@cases:
+				( $( $names )* )
+				( $( $names_extra )* )
+				( $( $names_skip_meta )* )
+			@selected:
+				$bench_module,
+				$new_test_ext,
+				$test,
+				benchmarks_path = $benchmarks_path,
+				extra = $extra,
+				exec_name = $exec_name,
+			@user:
+				$( $( $rest )* )?
+		);
+	};
+	// pick off the extra keyword argument
+	(
+		@cases:
+			( $( $names:tt )* )
+			( $( $names_extra:tt )* )
+			( $( $names_skip_meta:tt )* )
+		@selected:
+			$bench_module:ident,
+			$new_test_ext:expr,
+			$test:path,
+			benchmarks_path = $benchmarks_path:ident,
+			extra = $old:expr,
+			exec_name = $exec_name:ident,
+		@user:
+			extra = $extra:expr
+			$(, $( $rest:tt )* )?
+	) => {
+		$crate::impl_test_function!(
+			@cases:
+				( $( $names )* )
+				( $( $names_extra )* )
+				( $( $names_skip_meta )* )
+			@selected:
+				$bench_module,
+				$new_test_ext,
+				$test,
+				benchmarks_path = $benchmarks_path,
+				extra = $extra,
+				exec_name = $exec_name,
+			@user:
+				$( $( $rest )* )?
+		);
+	};
+	// pick off the exec_name keyword argument
+	(
+		@cases:
+			( $( $names:tt )* )
+			( $( $names_extra:tt )* )
+			( $( $names_skip_meta:tt )* )
+		@selected:
+			$bench_module:ident,
+			$new_test_ext:expr,
+			$test:path,
+			benchmarks_path = $benchmarks_path:ident,
+			extra = $extra:expr,
+			exec_name = $old:ident,
+		@user:
+			exec_name = $exec_name:ident
+			$(, $( $rest:tt )* )?
+	) => {
+		$crate::impl_test_function!(
+			@cases:
+				( $( $names )* )
+				( $( $names_extra )* )
+				( $( $names_skip_meta )* )
+			@selected:
+				$bench_module,
+				$new_test_ext,
+				$test,
+				benchmarks_path = $benchmarks_path,
+				extra = $extra,
+				exec_name = $exec_name,
+			@user:
+				$( $( $rest )* )?
+		);
+	};
+	// iteration-exit arm which generates a #[test] function for each case.
+	(
+		@cases:
+			( $( $names:tt )+ )
+			( $( $names_extra:tt )* )
+			( $( $names_skip_meta:tt )* )
+		@selected:
+			$bench_module:ident,
+			$new_test_ext:expr,
+			$test:path,
+			benchmarks_path = $path_to_benchmarks_invocation:ident,
+			extra = $extra:expr,
+			exec_name = $exec_name:ident,
+		@user:
+			$(,)?
+	) => {
+		$crate::impl_bench_case_tests!(
+			{ $bench_module, $new_test_ext, $exec_name, $test, $extra }
+			{ $( $names_extra:tt )* }
+			$($names)+
+		);
+	};
+	// iteration-exit arm which generates one #[test] function for all cases.
+	(
+		@cases:
+			()
+			()
+			()
+		@selected:
+			$bench_module:ident,
+			$new_test_ext:expr,
+			$test:path,
+			benchmarks_path = $path_to_benchmarks_invocation:ident,
+			extra = $extra:expr,
+			exec_name = $exec_name:ident,
+		@user:
+			$(,)?
+	) => {
+		#[cfg(test)]
+		mod benchmark_tests {
+			use super::$bench_module;
+
+			#[test]
+			fn test_benchmarks() {
+				$new_test_ext.$exec_name(|| {
+					use $crate::Benchmarking;
+
+					let mut anything_failed = false;
+					println!("failing benchmark tests:");
+					for benchmark_metadata in $bench_module::<$test>::benchmarks($extra) {
+						let benchmark_name = &benchmark_metadata.name;
+						match std::panic::catch_unwind(|| {
+							$bench_module::<$test>::test_bench_by_name(benchmark_name)
+						}) {
+							Err(err) => {
+								println!(
+									"{}: {:?}",
+									$crate::__private::str::from_utf8(benchmark_name)
+										.expect("benchmark name is always a valid string!"),
+									err,
+								);
+								anything_failed = true;
+							},
+							Ok(Err(err)) => {
+								match err {
+									$crate::BenchmarkError::Stop(err) => {
+										println!(
+											"{}: {:?}",
+											$crate::__private::str::from_utf8(benchmark_name)
+												.expect("benchmark name is always a valid string!"),
+											err,
+										);
+										anything_failed = true;
+									},
+									$crate::BenchmarkError::Override(_) => {
+										// This is still considered a success condition.
+										$crate::__private::log::error!(
+											"WARNING: benchmark error overrided - {}",
+												$crate::__private::str::from_utf8(benchmark_name)
+													.expect("benchmark name is always a valid string!"),
+											);
+									},
+									$crate::BenchmarkError::Skip => {
+										// This is considered a success condition.
+										$crate::__private::log::error!(
+											"WARNING: benchmark error skipped - {}",
+											$crate::__private::str::from_utf8(benchmark_name)
+												.expect("benchmark name is always a valid string!"),
+										);
+									}
+									$crate::BenchmarkError::Weightless => {
+										// This is considered a success condition.
+										$crate::__private::log::error!(
+											"WARNING: benchmark weightless skipped - {}",
+											$crate::__private::str::from_utf8(benchmark_name)
+												.expect("benchmark name is always a valid string!"),
+										);
+									}
+								}
+							},
+							Ok(Ok(())) => (),
+						}
+					}
+					assert!(!anything_failed);
+				});
+			}
+		}
+	};
+}
+
+/// show error message and debugging info for the case of an error happening
+/// during a benchmark
+pub fn show_benchmark_debug_info(
+	instance_string: &[u8],
+	benchmark: &[u8],
+	components: &[(BenchmarkParameter, u32)],
+	verify: &bool,
+	error_message: &str,
+) -> sp_runtime::RuntimeString {
+	sp_runtime::format_runtime_string!(
+		"\n* Pallet: {}\n\
+		* Benchmark: {}\n\
+		* Components: {:?}\n\
+		* Verify: {:?}\n\
+		* Error message: {}",
+		sp_std::str::from_utf8(instance_string)
+			.expect("it's all just strings ran through the wasm interface. qed"),
+		sp_std::str::from_utf8(benchmark)
+			.expect("it's all just strings ran through the wasm interface. qed"),
+		components,
+		verify,
+		error_message,
+	)
+}
+
+/// This macro adds pallet benchmarks to a `Vec<BenchmarkBatch>` object.
+///
+/// First create an object that holds in the input parameters for the benchmark:
+///
+/// ```ignore
+/// let params = (&config, &whitelist);
+/// ```
+///
+/// The `whitelist` is a parameter you pass to control the DB read/write tracking.
+/// We use a vector of [TrackedStorageKey](./struct.TrackedStorageKey.html), which is a simple
+/// struct used to set if a key has been read or written to.
+///
+/// For values that should be skipped entirely, we can just pass `key.into()`. For example:
+///
+/// ```
+/// use sp_storage::TrackedStorageKey;
+/// let whitelist: Vec<TrackedStorageKey> = vec![
+/// 	// Block Number
+/// 	array_bytes::hex_into_unchecked("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac"),
+/// 	// Total Issuance
+/// 	array_bytes::hex_into_unchecked("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80"),
+/// 	// Execution Phase
+/// 	array_bytes::hex_into_unchecked("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a"),
+/// 	// Event Count
+/// 	array_bytes::hex_into_unchecked("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850"),
+/// ];
+/// ```
+///
+/// Then define a mutable local variable to hold your `BenchmarkBatch` object:
+///
+/// ```ignore
+/// let mut batches = Vec::<BenchmarkBatch>::new();
+/// ````
+///
+/// Then add the pallets you want to benchmark to this object, using their crate name and generated
+/// module struct:
+///
+/// ```ignore
+/// add_benchmark!(params, batches, pallet_balances, Balances);
+/// add_benchmark!(params, batches, pallet_session, SessionBench::<Runtime>);
+/// add_benchmark!(params, batches, frame_system, SystemBench::<Runtime>);
+/// ...
+/// ```
+///
+/// At the end of `dispatch_benchmark`, you should return this batches object.
+///
+/// In the case where you have multiple instances of a pallet that you need to separately benchmark,
+/// the name of your module struct will be used as a suffix to your outputted weight file. For
+/// example:
+///
+/// ```ignore
+/// add_benchmark!(params, batches, pallet_balances, Balances); // pallet_balances.rs
+/// add_benchmark!(params, batches, pallet_collective, Council); // pallet_collective_council.rs
+/// add_benchmark!(params, batches, pallet_collective, TechnicalCommittee); // pallet_collective_technical_committee.rs
+/// ```
+///
+/// You can manipulate this suffixed string by using a type alias if needed. For example:
+///
+/// ```ignore
+/// type Council2 = TechnicalCommittee;
+/// add_benchmark!(params, batches, pallet_collective, Council2); // pallet_collective_council_2.rs
+/// ```
+#[macro_export]
+macro_rules! add_benchmark {
+	( $params:ident, $batches:ident, $name:path, $location:ty ) => {
+		let name_string = stringify!($name).as_bytes();
+		let instance_string = stringify!($location).as_bytes();
+		let (config, whitelist) = $params;
+		let $crate::BenchmarkConfig {
+			pallet,
+			benchmark,
+			selected_components,
+			verify,
+			internal_repeats,
+		} = config;
+		if &pallet[..] == &name_string[..] {
+			let benchmark_result = <$location>::run_benchmark(
+				&benchmark[..],
+				&selected_components[..],
+				whitelist,
+				*verify,
+				*internal_repeats,
+			);
+
+			let final_results = match benchmark_result {
+				Ok(results) => Some(results),
+				Err($crate::BenchmarkError::Override(mut result)) => {
+					// Insert override warning as the first storage key.
+					$crate::__private::log::error!(
+						"WARNING: benchmark error overrided - {}",
+						$crate::__private::str::from_utf8(benchmark)
+							.expect("benchmark name is always a valid string!")
+					);
+					result.keys.insert(0, (b"Benchmark Override".to_vec(), 0, 0, false));
+					Some($crate::__private::vec![result])
+				},
+				Err($crate::BenchmarkError::Stop(e)) => {
+					$crate::show_benchmark_debug_info(
+						instance_string,
+						benchmark,
+						selected_components,
+						verify,
+						e,
+					);
+					return Err(e.into())
+				},
+				Err($crate::BenchmarkError::Skip) => {
+					$crate::__private::log::error!(
+						"WARNING: benchmark error skipped - {}",
+						$crate::__private::str::from_utf8(benchmark)
+							.expect("benchmark name is always a valid string!")
+					);
+					None
+				},
+				Err($crate::BenchmarkError::Weightless) => {
+					$crate::__private::log::error!(
+						"WARNING: benchmark weightless skipped - {}",
+						$crate::__private::str::from_utf8(benchmark)
+							.expect("benchmark name is always a valid string!")
+					);
+					Some($crate::__private::vec![$crate::BenchmarkResult {
+						components: selected_components.clone(),
+						..Default::default()
+					}])
+				},
+			};
+
+			if let Some(final_results) = final_results {
+				$batches.push($crate::BenchmarkBatch {
+					pallet: name_string.to_vec(),
+					instance: instance_string.to_vec(),
+					benchmark: benchmark.clone(),
+					results: final_results,
+				});
+			}
+		}
+	};
+}
+
+/// This macro allows users to easily generate a list of benchmarks for the pallets configured
+/// in the runtime.
+///
+/// To use this macro, first create a an object to store the list:
+///
+/// ```ignore
+/// let mut list = Vec::<BenchmarkList>::new();
+/// ```
+///
+/// Then pass this `list` to the macro, along with the `extra` boolean, the pallet crate, and
+/// pallet struct:
+///
+/// ```ignore
+/// list_benchmark!(list, extra, pallet_balances, Balances);
+/// list_benchmark!(list, extra, pallet_session, SessionBench::<Runtime>);
+/// list_benchmark!(list, extra, frame_system, SystemBench::<Runtime>);
+/// ```
+///
+/// This should match what exists with the `add_benchmark!` macro.
+#[macro_export]
+macro_rules! list_benchmark {
+	( $list:ident, $extra:ident, $name:path, $location:ty ) => {
+		let pallet_string = stringify!($name).as_bytes();
+		let instance_string = stringify!($location).as_bytes();
+		let benchmarks = <$location>::benchmarks($extra);
+		let pallet_benchmarks = BenchmarkList {
+			pallet: pallet_string.to_vec(),
+			instance: instance_string.to_vec(),
+			benchmarks: benchmarks.to_vec(),
+		};
+		$list.push(pallet_benchmarks)
+	};
+}
+
+/// Defines pallet configs that `add_benchmarks` and `list_benchmarks` use.
+/// Should be preferred instead of having a repetitive list of configs
+/// in `add_benchmark` and `list_benchmark`.
+#[macro_export]
+macro_rules! define_benchmarks {
+	( $([ $names:path, $locations:ty ])* ) => {
+		/// Calls `list_benchmark` with all configs from `define_benchmarks`
+		/// and passes the first two parameters on.
+		///
+		/// Use as:
+		/// ```ignore
+		/// list_benchmarks!(list, extra);
+		/// ```
+		#[macro_export]
+		macro_rules! list_benchmarks {
+			( $list:ident, $extra:ident ) => {
+				$( $crate::list_benchmark!( $list, $extra, $names, $locations); )*
+			}
+		}
+
+		/// Calls `add_benchmark` with all configs from `define_benchmarks`
+		/// and passes the first two parameters on.
+		///
+		/// Use as:
+		/// ```ignore
+		/// add_benchmarks!(params, batches);
+		/// ```
+		#[macro_export]
+		macro_rules! add_benchmarks {
+			( $params:ident, $batches:ident ) => {
+				$( $crate::add_benchmark!( $params, $batches, $names, $locations ); )*
+			}
+		}
+	}
+}
+
+pub use add_benchmark;
+pub use benchmark_backend;
+pub use benchmarks;
+pub use benchmarks_instance;
+pub use benchmarks_instance_pallet;
+pub use benchmarks_iter;
+pub use define_benchmarks;
+pub use impl_bench_case_tests;
+pub use impl_bench_name_tests;
+pub use impl_benchmark;
+pub use impl_benchmark_test;
+pub use impl_benchmark_test_suite;
+pub use impl_test_function;
+pub use list_benchmark;
+pub use selected_benchmark;
+pub use to_origin;
+pub use whitelist;
diff --git a/substrate/frame/benchmarking/src/weights.rs b/substrate/frame/benchmarking/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..13d73e420cce256080d117e3bab56842d302b3a0
--- /dev/null
+++ b/substrate/frame/benchmarking/src/weights.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.
+
+//! Autogenerated weights for frame_benchmarking
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=frame_benchmarking
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/benchmarking/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for frame_benchmarking.
+pub trait WeightInfo {
+	fn addition(i: u32, ) -> Weight;
+	fn subtraction(i: u32, ) -> Weight;
+	fn multiplication(i: u32, ) -> Weight;
+	fn division(i: u32, ) -> Weight;
+	fn hashing() -> Weight;
+	fn sr25519_verification(i: u32, ) -> Weight;
+}
+
+/// Weights for frame_benchmarking using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// The range of component `i` is `[0, 1000000]`.
+	fn addition(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 147_000 picoseconds.
+		Weight::from_parts(185_656, 0)
+	}
+	/// The range of component `i` is `[0, 1000000]`.
+	fn subtraction(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 146_000 picoseconds.
+		Weight::from_parts(189_816, 0)
+	}
+	/// The range of component `i` is `[0, 1000000]`.
+	fn multiplication(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 148_000 picoseconds.
+		Weight::from_parts(202_367, 0)
+	}
+	/// The range of component `i` is `[0, 1000000]`.
+	fn division(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 143_000 picoseconds.
+		Weight::from_parts(189_693, 0)
+	}
+	fn hashing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 24_167_071_000 picoseconds.
+		Weight::from_parts(24_391_749_000, 0)
+	}
+	/// The range of component `i` is `[0, 100]`.
+	fn sr25519_verification(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 231_000 picoseconds.
+		Weight::from_parts(2_998_013, 0)
+			// Standard Error: 6_256
+			.saturating_add(Weight::from_parts(55_456_705, 0).saturating_mul(i.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// The range of component `i` is `[0, 1000000]`.
+	fn addition(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 147_000 picoseconds.
+		Weight::from_parts(185_656, 0)
+	}
+	/// The range of component `i` is `[0, 1000000]`.
+	fn subtraction(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 146_000 picoseconds.
+		Weight::from_parts(189_816, 0)
+	}
+	/// The range of component `i` is `[0, 1000000]`.
+	fn multiplication(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 148_000 picoseconds.
+		Weight::from_parts(202_367, 0)
+	}
+	/// The range of component `i` is `[0, 1000000]`.
+	fn division(_i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 143_000 picoseconds.
+		Weight::from_parts(189_693, 0)
+	}
+	fn hashing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 24_167_071_000 picoseconds.
+		Weight::from_parts(24_391_749_000, 0)
+	}
+	/// The range of component `i` is `[0, 100]`.
+	fn sr25519_verification(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 231_000 picoseconds.
+		Weight::from_parts(2_998_013, 0)
+			// Standard Error: 6_256
+			.saturating_add(Weight::from_parts(55_456_705, 0).saturating_mul(i.into()))
+	}
+}
diff --git a/substrate/frame/bounties/Cargo.toml b/substrate/frame/bounties/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..38a7216e8ddf759157c96c16b982e7e767b4e11f
--- /dev/null
+++ b/substrate/frame/bounties/Cargo.toml
@@ -0,0 +1,63 @@
+[package]
+name = "pallet-bounties"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to manage bounties"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-treasury = { version = "4.0.0-dev", default-features = false, path = "../treasury" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-treasury/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-treasury/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-treasury/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/bounties/README.md b/substrate/frame/bounties/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..232334cb1edd64ea8aab141055457c494a352073
--- /dev/null
+++ b/substrate/frame/bounties/README.md
@@ -0,0 +1,64 @@
+# Bounties Module ( pallet-bounties )
+
+## Bounty
+
+> NOTE: This pallet is tightly coupled with pallet-treasury.
+
+A Bounty Spending is a reward for a specified body of work - or specified set of objectives -
+that needs to be executed for a predefined Treasury amount to be paid out. A curator is assigned
+after the bounty is approved and funded by Council, to be delegated with the responsibility of
+assigning a payout address once the specified set of objectives is completed.
+
+After the Council has activated a bounty, it delegates the work that requires expertise to a
+curator in exchange of a deposit. Once the curator accepts the bounty, they get to close the
+active bounty. Closing the active bounty enacts a delayed payout to the payout address, the
+curator fee and the return of the curator deposit. The delay allows for intervention through
+regular democracy. The Council gets to unassign the curator, resulting in a new curator
+election. The Council also gets to cancel the bounty if deemed necessary before assigning a
+curator or once the bounty is active or payout is pending, resulting in the slash of the
+curator's deposit.
+
+This pallet may opt into using a [`ChildBountyManager`] that enables bounties to be split into
+sub-bounties, as children of anh established bounty (called the parent in the context of it's
+children).
+
+> NOTE: The parent bounty cannot be closed if it has a non-zero number of it has active child
+> bounties associated with it.
+
+### Terminology
+
+Bounty:
+
+- **Bounty spending proposal:** A proposal to reward a predefined body of work upon completion
+  by the Treasury.
+- **Proposer:** An account proposing a bounty spending.
+- **Curator:** An account managing the bounty and assigning a payout address receiving the
+  reward for the completion of work.
+- **Deposit:** The amount held on deposit for placing a bounty proposal plus the amount held on
+  deposit per byte within the bounty description.
+- **Curator deposit:** The payment from a candidate willing to curate an approved bounty. The
+  deposit is returned when/if the bounty is completed.
+- **Bounty value:** The total amount that should be paid to the Payout Address if the bounty is
+  rewarded.
+- **Payout address:** The account to which the total or part of the bounty is assigned to.
+- **Payout Delay:** The delay period for which a bounty beneficiary needs to wait before
+  claiming.
+- **Curator fee:** The reserved upfront payment for a curator for work related to the bounty.
+
+## Interface
+
+### Dispatchable Functions
+
+Bounty protocol:
+
+- `propose_bounty` - Propose a specific treasury amount to be earmarked for a predefined set of
+  tasks and stake the required deposit.
+- `approve_bounty` - Accept a specific treasury amount to be earmarked for a predefined body of
+  work.
+- `propose_curator` - Assign an account to a bounty as candidate curator.
+- `accept_curator` - Accept a bounty assignment from the Council, setting a curator deposit.
+- `extend_bounty_expiry` - Extend the expiry block number of the bounty and stay active.
+- `award_bounty` - Close and pay out the specified amount for the completed work.
+- `claim_bounty` - Claim a specific bounty amount from the Payout Address.
+- `unassign_curator` - Unassign an accepted curator from a specific earmark.
+- `close_bounty` - Cancel the earmark for a specific treasury amount and close the bounty.
diff --git a/substrate/frame/bounties/src/benchmarking.rs b/substrate/frame/bounties/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6fff337cba45040b01d586c09e4c96d63ab93500
--- /dev/null
+++ b/substrate/frame/bounties/src/benchmarking.rs
@@ -0,0 +1,235 @@
+// 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.
+
+//! bounties pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelisted_caller, BenchmarkError,
+};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use sp_runtime::traits::Bounded;
+
+use crate::Pallet as Bounties;
+use pallet_treasury::Pallet as Treasury;
+
+const SEED: u32 = 0;
+
+// Create bounties that are approved for use in `on_initialize`.
+fn create_approved_bounties<T: Config<I>, I: 'static>(n: u32) -> Result<(), BenchmarkError> {
+	for i in 0..n {
+		let (caller, _curator, _fee, value, reason) =
+			setup_bounty::<T, I>(i, T::MaximumReasonLength::get());
+		Bounties::<T, I>::propose_bounty(RawOrigin::Signed(caller).into(), value, reason)?;
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let approve_origin =
+			T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		Bounties::<T, I>::approve_bounty(approve_origin, bounty_id)?;
+	}
+	ensure!(BountyApprovals::<T, I>::get().len() == n as usize, "Not all bounty approved");
+	Ok(())
+}
+
+// Create the pre-requisite information needed to create a treasury `propose_bounty`.
+fn setup_bounty<T: Config<I>, I: 'static>(
+	u: u32,
+	d: u32,
+) -> (T::AccountId, T::AccountId, BalanceOf<T, I>, BalanceOf<T, I>, Vec<u8>) {
+	let caller = account("caller", u, SEED);
+	let value: BalanceOf<T, I> = T::BountyValueMinimum::get().saturating_mul(100u32.into());
+	let fee = value / 2u32.into();
+	let deposit = T::BountyDepositBase::get() +
+		T::DataDepositPerByte::get() * T::MaximumReasonLength::get().into();
+	let _ = T::Currency::make_free_balance_be(&caller, deposit + T::Currency::minimum_balance());
+	let curator = account("curator", u, SEED);
+	let _ = T::Currency::make_free_balance_be(
+		&curator,
+		fee / 2u32.into() + T::Currency::minimum_balance(),
+	);
+	let reason = vec![0; d as usize];
+	(caller, curator, fee, value, reason)
+}
+
+fn create_bounty<T: Config<I>, I: 'static>(
+) -> Result<(AccountIdLookupOf<T>, BountyIndex), BenchmarkError> {
+	let (caller, curator, fee, value, reason) =
+		setup_bounty::<T, I>(0, T::MaximumReasonLength::get());
+	let curator_lookup = T::Lookup::unlookup(curator.clone());
+	Bounties::<T, I>::propose_bounty(RawOrigin::Signed(caller).into(), value, reason)?;
+	let bounty_id = BountyCount::<T, I>::get() - 1;
+	let approve_origin =
+		T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	Bounties::<T, I>::approve_bounty(approve_origin.clone(), bounty_id)?;
+	Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+	Bounties::<T, I>::propose_curator(approve_origin, bounty_id, curator_lookup.clone(), fee)?;
+	Bounties::<T, I>::accept_curator(RawOrigin::Signed(curator).into(), bounty_id)?;
+	Ok((curator_lookup, bounty_id))
+}
+
+fn setup_pot_account<T: Config<I>, I: 'static>() {
+	let pot_account = Bounties::<T, I>::account_id();
+	let value = T::Currency::minimum_balance().saturating_mul(1_000_000_000u32.into());
+	let _ = T::Currency::make_free_balance_be(&pot_account, value);
+}
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+benchmarks_instance_pallet! {
+	propose_bounty {
+		let d in 0 .. T::MaximumReasonLength::get();
+
+		let (caller, curator, fee, value, description) = setup_bounty::<T, I>(0, d);
+	}: _(RawOrigin::Signed(caller), value, description)
+
+	approve_bounty {
+		let (caller, curator, fee, value, reason) = setup_bounty::<T, I>(0, T::MaximumReasonLength::get());
+		Bounties::<T, I>::propose_bounty(RawOrigin::Signed(caller).into(), value, reason)?;
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let approve_origin = T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: _<T::RuntimeOrigin>(approve_origin, bounty_id)
+
+	propose_curator {
+		setup_pot_account::<T, I>();
+		let (caller, curator, fee, value, reason) = setup_bounty::<T, I>(0, T::MaximumReasonLength::get());
+		let curator_lookup = T::Lookup::unlookup(curator);
+		Bounties::<T, I>::propose_bounty(RawOrigin::Signed(caller).into(), value, reason)?;
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let approve_origin = T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		Bounties::<T, I>::approve_bounty(approve_origin.clone(), bounty_id)?;
+		Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+	}: _<T::RuntimeOrigin>(approve_origin, bounty_id, curator_lookup, fee)
+
+	// Worst case when curator is inactive and any sender unassigns the curator.
+	unassign_curator {
+		setup_pot_account::<T, I>();
+		let (curator_lookup, bounty_id) = create_bounty::<T, I>()?;
+		Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		frame_system::Pallet::<T>::set_block_number(T::BountyUpdatePeriod::get() + 2u32.into());
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), bounty_id)
+
+	accept_curator {
+		setup_pot_account::<T, I>();
+		let (caller, curator, fee, value, reason) = setup_bounty::<T, I>(0, T::MaximumReasonLength::get());
+		let curator_lookup = T::Lookup::unlookup(curator.clone());
+		Bounties::<T, I>::propose_bounty(RawOrigin::Signed(caller).into(), value, reason)?;
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let approve_origin = T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		Bounties::<T, I>::approve_bounty(approve_origin.clone(), bounty_id)?;
+		Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+		Bounties::<T, I>::propose_curator(approve_origin, bounty_id, curator_lookup, fee)?;
+	}: _(RawOrigin::Signed(curator), bounty_id)
+
+	award_bounty {
+		setup_pot_account::<T, I>();
+		let (curator_lookup, bounty_id) = create_bounty::<T, I>()?;
+		Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let curator = T::Lookup::lookup(curator_lookup).map_err(<&str>::from)?;
+
+		let beneficiary = T::Lookup::unlookup(account("beneficiary", 0, SEED));
+	}: _(RawOrigin::Signed(curator), bounty_id, beneficiary)
+
+	claim_bounty {
+		setup_pot_account::<T, I>();
+		let (curator_lookup, bounty_id) = create_bounty::<T, I>()?;
+		Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let curator = T::Lookup::lookup(curator_lookup).map_err(<&str>::from)?;
+
+		let beneficiary_account: T::AccountId = account("beneficiary", 0, SEED);
+		let beneficiary = T::Lookup::unlookup(beneficiary_account.clone());
+		Bounties::<T, I>::award_bounty(RawOrigin::Signed(curator.clone()).into(), bounty_id, beneficiary)?;
+
+		frame_system::Pallet::<T>::set_block_number(T::BountyDepositPayoutDelay::get() + 1u32.into());
+		ensure!(T::Currency::free_balance(&beneficiary_account).is_zero(), "Beneficiary already has balance");
+
+	}: _(RawOrigin::Signed(curator), bounty_id)
+	verify {
+		ensure!(!T::Currency::free_balance(&beneficiary_account).is_zero(), "Beneficiary didn't get paid");
+	}
+
+	close_bounty_proposed {
+		setup_pot_account::<T, I>();
+		let (caller, curator, fee, value, reason) = setup_bounty::<T, I>(0, 0);
+		Bounties::<T, I>::propose_bounty(RawOrigin::Signed(caller).into(), value, reason)?;
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let approve_origin =
+			T::ApproveOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: close_bounty<T::RuntimeOrigin>(approve_origin, bounty_id)
+
+	close_bounty_active {
+		setup_pot_account::<T, I>();
+		let (curator_lookup, bounty_id) = create_bounty::<T, I>()?;
+		Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let approve_origin =
+			T::ApproveOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: close_bounty<T::RuntimeOrigin>(approve_origin, bounty_id)
+	verify {
+		assert_last_event::<T, I>(Event::BountyCanceled { index: bounty_id }.into())
+	}
+
+	extend_bounty_expiry {
+		setup_pot_account::<T, I>();
+		let (curator_lookup, bounty_id) = create_bounty::<T, I>()?;
+		Treasury::<T, I>::on_initialize(BlockNumberFor::<T>::zero());
+
+		let bounty_id = BountyCount::<T, I>::get() - 1;
+		let curator = T::Lookup::lookup(curator_lookup).map_err(<&str>::from)?;
+	}: _(RawOrigin::Signed(curator), bounty_id, Vec::new())
+	verify {
+		assert_last_event::<T, I>(Event::BountyExtended { index: bounty_id }.into())
+	}
+
+	spend_funds {
+		let b in 0 .. 100;
+		setup_pot_account::<T, I>();
+		create_approved_bounties::<T, I>(b)?;
+
+		let mut budget_remaining = BalanceOf::<T, I>::max_value();
+		let mut imbalance = PositiveImbalanceOf::<T, I>::zero();
+		let mut total_weight = Weight::zero();
+		let mut missed_any = false;
+	}: {
+		<Bounties<T, I> as pallet_treasury::SpendFunds<T, I>>::spend_funds(
+			&mut budget_remaining,
+			&mut imbalance,
+			&mut total_weight,
+			&mut missed_any,
+		);
+	}
+	verify {
+		ensure!(missed_any == false, "Missed some");
+		if b > 0 {
+			ensure!(budget_remaining < BalanceOf::<T, I>::max_value(), "Budget not used");
+			assert_last_event::<T, I>(Event::BountyBecameActive { index: b - 1 }.into())
+		} else {
+			ensure!(budget_remaining == BalanceOf::<T, I>::max_value(), "Budget used");
+		}
+	}
+
+	impl_benchmark_test_suite!(Bounties, crate::tests::new_test_ext(), crate::tests::Test)
+}
diff --git a/substrate/frame/bounties/src/lib.rs b/substrate/frame/bounties/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c64a35672c7f728b6c528ebb1a99646a6c631c75
--- /dev/null
+++ b/substrate/frame/bounties/src/lib.rs
@@ -0,0 +1,917 @@
+// 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.
+
+//! # Bounties Module ( pallet-bounties )
+//!
+//! ## Bounty
+//!
+//! > NOTE: This pallet is tightly coupled with pallet-treasury.
+//!
+//! A Bounty Spending is a reward for a specified body of work - or specified set of objectives -
+//! that needs to be executed for a predefined Treasury amount to be paid out. A curator is assigned
+//! after the bounty is approved and funded by Council, to be delegated with the responsibility of
+//! assigning a payout address once the specified set of objectives is completed.
+//!
+//! After the Council has activated a bounty, it delegates the work that requires expertise to a
+//! curator in exchange of a deposit. Once the curator accepts the bounty, they get to close the
+//! active bounty. Closing the active bounty enacts a delayed payout to the payout address, the
+//! curator fee and the return of the curator deposit. The delay allows for intervention through
+//! regular democracy. The Council gets to unassign the curator, resulting in a new curator
+//! election. The Council also gets to cancel the bounty if deemed necessary before assigning a
+//! curator or once the bounty is active or payout is pending, resulting in the slash of the
+//! curator's deposit.
+//!
+//! This pallet may opt into using a [`ChildBountyManager`] that enables bounties to be split into
+//! sub-bounties, as children of anh established bounty (called the parent in the context of it's
+//! children).
+//!
+//! > NOTE: The parent bounty cannot be closed if it has a non-zero number of it has active child
+//! > bounties associated with it.
+//!
+//! ### Terminology
+//!
+//! Bounty:
+//!
+//! - **Bounty spending proposal:** A proposal to reward a predefined body of work upon completion
+//!   by the Treasury.
+//! - **Proposer:** An account proposing a bounty spending.
+//! - **Curator:** An account managing the bounty and assigning a payout address receiving the
+//!   reward for the completion of work.
+//! - **Deposit:** The amount held on deposit for placing a bounty proposal plus the amount held on
+//!   deposit per byte within the bounty description.
+//! - **Curator deposit:** The payment from a candidate willing to curate an approved bounty. The
+//!   deposit is returned when/if the bounty is completed.
+//! - **Bounty value:** The total amount that should be paid to the Payout Address if the bounty is
+//!   rewarded.
+//! - **Payout address:** The account to which the total or part of the bounty is assigned to.
+//! - **Payout Delay:** The delay period for which a bounty beneficiary needs to wait before
+//!   claiming.
+//! - **Curator fee:** The reserved upfront payment for a curator for work related to the bounty.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! Bounty protocol:
+//!
+//! - `propose_bounty` - Propose a specific treasury amount to be earmarked for a predefined set of
+//!   tasks and stake the required deposit.
+//! - `approve_bounty` - Accept a specific treasury amount to be earmarked for a predefined body of
+//!   work.
+//! - `propose_curator` - Assign an account to a bounty as candidate curator.
+//! - `accept_curator` - Accept a bounty assignment from the Council, setting a curator deposit.
+//! - `extend_bounty_expiry` - Extend the expiry block number of the bounty and stay active.
+//! - `award_bounty` - Close and pay out the specified amount for the completed work.
+//! - `claim_bounty` - Claim a specific bounty amount from the Payout Address.
+//! - `unassign_curator` - Unassign an accepted curator from a specific earmark.
+//! - `close_bounty` - Cancel the earmark for a specific treasury amount and close the bounty.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+pub mod migrations;
+mod tests;
+pub mod weights;
+
+use sp_std::prelude::*;
+
+use frame_support::traits::{
+	Currency, ExistenceRequirement::AllowDeath, Get, Imbalance, OnUnbalanced, ReservableCurrency,
+};
+
+use sp_runtime::{
+	traits::{AccountIdConversion, BadOrigin, Saturating, StaticLookup, Zero},
+	DispatchResult, Permill, RuntimeDebug,
+};
+
+use frame_support::{dispatch::DispatchResultWithPostInfo, traits::EnsureOrigin};
+
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+use scale_info::TypeInfo;
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+type BalanceOf<T, I = ()> = pallet_treasury::BalanceOf<T, I>;
+
+type PositiveImbalanceOf<T, I = ()> = pallet_treasury::PositiveImbalanceOf<T, I>;
+
+/// An index of a bounty. Just a `u32`.
+pub type BountyIndex = u32;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// A bounty proposal.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct Bounty<AccountId, Balance, BlockNumber> {
+	/// The account proposing it.
+	proposer: AccountId,
+	/// The (total) amount that should be paid if the bounty is rewarded.
+	value: Balance,
+	/// The curator fee. Included in value.
+	fee: Balance,
+	/// The deposit of curator.
+	curator_deposit: Balance,
+	/// The amount held on deposit (reserved) for making this proposal.
+	bond: Balance,
+	/// The status of this bounty.
+	status: BountyStatus<AccountId, BlockNumber>,
+}
+
+impl<AccountId: PartialEq + Clone + Ord, Balance, BlockNumber: Clone>
+	Bounty<AccountId, Balance, BlockNumber>
+{
+	/// Getter for bounty status, to be used for child bounties.
+	pub fn get_status(&self) -> BountyStatus<AccountId, BlockNumber> {
+		self.status.clone()
+	}
+}
+
+/// The status of a bounty proposal.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum BountyStatus<AccountId, BlockNumber> {
+	/// The bounty is proposed and waiting for approval.
+	Proposed,
+	/// The bounty is approved and waiting to become active at next spend period.
+	Approved,
+	/// The bounty is funded and waiting for curator assignment.
+	Funded,
+	/// A curator has been proposed. Waiting for acceptance from the curator.
+	CuratorProposed {
+		/// The assigned curator of this bounty.
+		curator: AccountId,
+	},
+	/// The bounty is active and waiting to be awarded.
+	Active {
+		/// The curator of this bounty.
+		curator: AccountId,
+		/// An update from the curator is due by this block, else they are considered inactive.
+		update_due: BlockNumber,
+	},
+	/// The bounty is awarded and waiting to released after a delay.
+	PendingPayout {
+		/// The curator of this bounty.
+		curator: AccountId,
+		/// The beneficiary of the bounty.
+		beneficiary: AccountId,
+		/// When the bounty can be claimed.
+		unlock_at: BlockNumber,
+	},
+}
+
+/// The child bounty manager.
+pub trait ChildBountyManager<Balance> {
+	/// Get the active child bounties for a parent bounty.
+	fn child_bounties_count(bounty_id: BountyIndex) -> BountyIndex;
+
+	/// Get total curator fees of children-bounty curators.
+	fn children_curator_fees(bounty_id: BountyIndex) -> Balance;
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config + pallet_treasury::Config<I> {
+		/// The amount held on deposit for placing a bounty proposal.
+		#[pallet::constant]
+		type BountyDepositBase: Get<BalanceOf<Self, I>>;
+
+		/// The delay period for which a bounty beneficiary need to wait before claim the payout.
+		#[pallet::constant]
+		type BountyDepositPayoutDelay: Get<BlockNumberFor<Self>>;
+
+		/// Bounty duration in blocks.
+		#[pallet::constant]
+		type BountyUpdatePeriod: Get<BlockNumberFor<Self>>;
+
+		/// The curator deposit is calculated as a percentage of the curator fee.
+		///
+		/// This deposit has optional upper and lower bounds with `CuratorDepositMax` and
+		/// `CuratorDepositMin`.
+		#[pallet::constant]
+		type CuratorDepositMultiplier: Get<Permill>;
+
+		/// Maximum amount of funds that should be placed in a deposit for making a proposal.
+		#[pallet::constant]
+		type CuratorDepositMax: Get<Option<BalanceOf<Self, I>>>;
+
+		/// Minimum amount of funds that should be placed in a deposit for making a proposal.
+		#[pallet::constant]
+		type CuratorDepositMin: Get<Option<BalanceOf<Self, I>>>;
+
+		/// Minimum value for a bounty.
+		#[pallet::constant]
+		type BountyValueMinimum: Get<BalanceOf<Self, I>>;
+
+		/// The amount held on deposit per byte within the tip report reason or bounty description.
+		#[pallet::constant]
+		type DataDepositPerByte: Get<BalanceOf<Self, I>>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Maximum acceptable reason length.
+		///
+		/// Benchmarks depend on this value, be sure to update weights file when changing this value
+		#[pallet::constant]
+		type MaximumReasonLength: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The child bounty manager.
+		type ChildBountyManager: ChildBountyManager<BalanceOf<Self, I>>;
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Proposer's balance is too low.
+		InsufficientProposersBalance,
+		/// No proposal or bounty at that index.
+		InvalidIndex,
+		/// The reason given is just too big.
+		ReasonTooBig,
+		/// The bounty status is unexpected.
+		UnexpectedStatus,
+		/// Require bounty curator.
+		RequireCurator,
+		/// Invalid bounty value.
+		InvalidValue,
+		/// Invalid bounty fee.
+		InvalidFee,
+		/// A bounty payout is pending.
+		/// To cancel the bounty, you must unassign and slash the curator.
+		PendingPayout,
+		/// The bounties cannot be claimed/closed because it's still in the countdown period.
+		Premature,
+		/// The bounty cannot be closed because it has active child bounties.
+		HasActiveChildBounty,
+		/// Too many approvals are already queued.
+		TooManyQueued,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// New bounty proposal.
+		BountyProposed { index: BountyIndex },
+		/// A bounty proposal was rejected; funds were slashed.
+		BountyRejected { index: BountyIndex, bond: BalanceOf<T, I> },
+		/// A bounty proposal is funded and became active.
+		BountyBecameActive { index: BountyIndex },
+		/// A bounty is awarded to a beneficiary.
+		BountyAwarded { index: BountyIndex, beneficiary: T::AccountId },
+		/// A bounty is claimed by beneficiary.
+		BountyClaimed { index: BountyIndex, payout: BalanceOf<T, I>, beneficiary: T::AccountId },
+		/// A bounty is cancelled.
+		BountyCanceled { index: BountyIndex },
+		/// A bounty expiry is extended.
+		BountyExtended { index: BountyIndex },
+	}
+
+	/// Number of bounty proposals that have been made.
+	#[pallet::storage]
+	#[pallet::getter(fn bounty_count)]
+	pub type BountyCount<T: Config<I>, I: 'static = ()> = StorageValue<_, BountyIndex, ValueQuery>;
+
+	/// Bounties that have been made.
+	#[pallet::storage]
+	#[pallet::getter(fn bounties)]
+	pub type Bounties<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Twox64Concat,
+		BountyIndex,
+		Bounty<T::AccountId, BalanceOf<T, I>, BlockNumberFor<T>>,
+	>;
+
+	/// The description of each bounty.
+	#[pallet::storage]
+	#[pallet::getter(fn bounty_descriptions)]
+	pub type BountyDescriptions<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, BountyIndex, BoundedVec<u8, T::MaximumReasonLength>>;
+
+	/// Bounty indices that have been approved but not yet funded.
+	#[pallet::storage]
+	#[pallet::getter(fn bounty_approvals)]
+	pub type BountyApprovals<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<BountyIndex, T::MaxApprovals>, ValueQuery>;
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Propose a new bounty.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Payment: `TipReportDepositBase` will be reserved from the origin account, as well as
+		/// `DataDepositPerByte` for each byte in `reason`. It will be unreserved upon approval,
+		/// or slashed when rejected.
+		///
+		/// - `curator`: The curator account whom will manage this bounty.
+		/// - `fee`: The curator fee.
+		/// - `value`: The total payment amount of this bounty, curator fee included.
+		/// - `description`: The description of this bounty.
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::propose_bounty(description.len() as u32))]
+		pub fn propose_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T, I>,
+			description: Vec<u8>,
+		) -> DispatchResult {
+			let proposer = ensure_signed(origin)?;
+			Self::create_bounty(proposer, description, value)?;
+			Ok(())
+		}
+
+		/// Approve a bounty proposal. At a later time, the bounty will be funded and become active
+		/// and the original deposit will be returned.
+		///
+		/// May only be called from `T::SpendOrigin`.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::approve_bounty())]
+		pub fn approve_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let max_amount = T::SpendOrigin::ensure_origin(origin)?;
+			Bounties::<T, I>::try_mutate_exists(bounty_id, |maybe_bounty| -> DispatchResult {
+				let bounty = maybe_bounty.as_mut().ok_or(Error::<T, I>::InvalidIndex)?;
+				ensure!(
+					bounty.value <= max_amount,
+					pallet_treasury::Error::<T, I>::InsufficientPermission
+				);
+				ensure!(bounty.status == BountyStatus::Proposed, Error::<T, I>::UnexpectedStatus);
+
+				bounty.status = BountyStatus::Approved;
+
+				BountyApprovals::<T, I>::try_append(bounty_id)
+					.map_err(|()| Error::<T, I>::TooManyQueued)?;
+
+				Ok(())
+			})?;
+			Ok(())
+		}
+
+		/// Assign a curator to a funded bounty.
+		///
+		/// May only be called from `T::SpendOrigin`.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(2)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::propose_curator())]
+		pub fn propose_curator(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+			curator: AccountIdLookupOf<T>,
+			#[pallet::compact] fee: BalanceOf<T, I>,
+		) -> DispatchResult {
+			let max_amount = T::SpendOrigin::ensure_origin(origin)?;
+
+			let curator = T::Lookup::lookup(curator)?;
+			Bounties::<T, I>::try_mutate_exists(bounty_id, |maybe_bounty| -> DispatchResult {
+				let bounty = maybe_bounty.as_mut().ok_or(Error::<T, I>::InvalidIndex)?;
+				ensure!(
+					bounty.value <= max_amount,
+					pallet_treasury::Error::<T, I>::InsufficientPermission
+				);
+				match bounty.status {
+					BountyStatus::Funded => {},
+					_ => return Err(Error::<T, I>::UnexpectedStatus.into()),
+				};
+
+				ensure!(fee < bounty.value, Error::<T, I>::InvalidFee);
+
+				bounty.status = BountyStatus::CuratorProposed { curator };
+				bounty.fee = fee;
+
+				Ok(())
+			})?;
+			Ok(())
+		}
+
+		/// Unassign curator from a bounty.
+		///
+		/// This function can only be called by the `RejectOrigin` a signed origin.
+		///
+		/// If this function is called by the `RejectOrigin`, we assume that the curator is
+		/// malicious or inactive. As a result, we will slash the curator when possible.
+		///
+		/// If the origin is the curator, we take this as a sign they are unable to do their job and
+		/// they willingly give up. We could slash them, but for now we allow them to recover their
+		/// deposit and exit without issue. (We may want to change this if it is abused.)
+		///
+		/// Finally, the origin can be anyone if and only if the curator is "inactive". This allows
+		/// anyone in the community to call out that a curator is not doing their due diligence, and
+		/// we should pick a new curator. In this case the curator should also be slashed.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(3)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::unassign_curator())]
+		pub fn unassign_curator(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let maybe_sender = ensure_signed(origin.clone())
+				.map(Some)
+				.or_else(|_| T::RejectOrigin::ensure_origin(origin).map(|_| None))?;
+
+			Bounties::<T, I>::try_mutate_exists(bounty_id, |maybe_bounty| -> DispatchResult {
+				let bounty = maybe_bounty.as_mut().ok_or(Error::<T, I>::InvalidIndex)?;
+
+				let slash_curator = |curator: &T::AccountId,
+				                     curator_deposit: &mut BalanceOf<T, I>| {
+					let imbalance = T::Currency::slash_reserved(curator, *curator_deposit).0;
+					T::OnSlash::on_unbalanced(imbalance);
+					*curator_deposit = Zero::zero();
+				};
+
+				match bounty.status {
+					BountyStatus::Proposed | BountyStatus::Approved | BountyStatus::Funded => {
+						// No curator to unassign at this point.
+						return Err(Error::<T, I>::UnexpectedStatus.into())
+					},
+					BountyStatus::CuratorProposed { ref curator } => {
+						// A curator has been proposed, but not accepted yet.
+						// Either `RejectOrigin` or the proposed curator can unassign the curator.
+						ensure!(maybe_sender.map_or(true, |sender| sender == *curator), BadOrigin);
+					},
+					BountyStatus::Active { ref curator, ref update_due } => {
+						// The bounty is active.
+						match maybe_sender {
+							// If the `RejectOrigin` is calling this function, slash the curator.
+							None => {
+								slash_curator(curator, &mut bounty.curator_deposit);
+								// Continue to change bounty status below...
+							},
+							Some(sender) => {
+								// If the sender is not the curator, and the curator is inactive,
+								// slash the curator.
+								if sender != *curator {
+									let block_number = frame_system::Pallet::<T>::block_number();
+									if *update_due < block_number {
+										slash_curator(curator, &mut bounty.curator_deposit);
+									// Continue to change bounty status below...
+									} else {
+										// Curator has more time to give an update.
+										return Err(Error::<T, I>::Premature.into())
+									}
+								} else {
+									// Else this is the curator, willingly giving up their role.
+									// Give back their deposit.
+									let err_amount =
+										T::Currency::unreserve(curator, bounty.curator_deposit);
+									debug_assert!(err_amount.is_zero());
+									bounty.curator_deposit = Zero::zero();
+									// Continue to change bounty status below...
+								}
+							},
+						}
+					},
+					BountyStatus::PendingPayout { ref curator, .. } => {
+						// The bounty is pending payout, so only council can unassign a curator.
+						// By doing so, they are claiming the curator is acting maliciously, so
+						// we slash the curator.
+						ensure!(maybe_sender.is_none(), BadOrigin);
+						slash_curator(curator, &mut bounty.curator_deposit);
+						// Continue to change bounty status below...
+					},
+				};
+
+				bounty.status = BountyStatus::Funded;
+				Ok(())
+			})?;
+			Ok(())
+		}
+
+		/// Accept the curator role for a bounty.
+		/// A deposit will be reserved from curator and refund upon successful payout.
+		///
+		/// May only be called from the curator.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(4)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::accept_curator())]
+		pub fn accept_curator(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+
+			Bounties::<T, I>::try_mutate_exists(bounty_id, |maybe_bounty| -> DispatchResult {
+				let bounty = maybe_bounty.as_mut().ok_or(Error::<T, I>::InvalidIndex)?;
+
+				match bounty.status {
+					BountyStatus::CuratorProposed { ref curator } => {
+						ensure!(signer == *curator, Error::<T, I>::RequireCurator);
+
+						let deposit = Self::calculate_curator_deposit(&bounty.fee);
+						T::Currency::reserve(curator, deposit)?;
+						bounty.curator_deposit = deposit;
+
+						let update_due = frame_system::Pallet::<T>::block_number() +
+							T::BountyUpdatePeriod::get();
+						bounty.status =
+							BountyStatus::Active { curator: curator.clone(), update_due };
+
+						Ok(())
+					},
+					_ => Err(Error::<T, I>::UnexpectedStatus.into()),
+				}
+			})?;
+			Ok(())
+		}
+
+		/// Award bounty to a beneficiary account. The beneficiary will be able to claim the funds
+		/// after a delay.
+		///
+		/// The dispatch origin for this call must be the curator of this bounty.
+		///
+		/// - `bounty_id`: Bounty ID to award.
+		/// - `beneficiary`: The beneficiary account whom will receive the payout.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(5)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::award_bounty())]
+		pub fn award_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+			beneficiary: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+
+			Bounties::<T, I>::try_mutate_exists(bounty_id, |maybe_bounty| -> DispatchResult {
+				let bounty = maybe_bounty.as_mut().ok_or(Error::<T, I>::InvalidIndex)?;
+
+				// Ensure no active child bounties before processing the call.
+				ensure!(
+					T::ChildBountyManager::child_bounties_count(bounty_id) == 0,
+					Error::<T, I>::HasActiveChildBounty
+				);
+
+				match &bounty.status {
+					BountyStatus::Active { curator, .. } => {
+						ensure!(signer == *curator, Error::<T, I>::RequireCurator);
+					},
+					_ => return Err(Error::<T, I>::UnexpectedStatus.into()),
+				}
+				bounty.status = BountyStatus::PendingPayout {
+					curator: signer,
+					beneficiary: beneficiary.clone(),
+					unlock_at: frame_system::Pallet::<T>::block_number() +
+						T::BountyDepositPayoutDelay::get(),
+				};
+
+				Ok(())
+			})?;
+
+			Self::deposit_event(Event::<T, I>::BountyAwarded { index: bounty_id, beneficiary });
+			Ok(())
+		}
+
+		/// Claim the payout from an awarded bounty after payout delay.
+		///
+		/// The dispatch origin for this call must be the beneficiary of this bounty.
+		///
+		/// - `bounty_id`: Bounty ID to claim.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(6)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::claim_bounty())]
+		pub fn claim_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let _ = ensure_signed(origin)?; // anyone can trigger claim
+
+			Bounties::<T, I>::try_mutate_exists(bounty_id, |maybe_bounty| -> DispatchResult {
+				let bounty = maybe_bounty.take().ok_or(Error::<T, I>::InvalidIndex)?;
+				if let BountyStatus::PendingPayout { curator, beneficiary, unlock_at } =
+					bounty.status
+				{
+					ensure!(
+						frame_system::Pallet::<T>::block_number() >= unlock_at,
+						Error::<T, I>::Premature
+					);
+					let bounty_account = Self::bounty_account_id(bounty_id);
+					let balance = T::Currency::free_balance(&bounty_account);
+					let fee = bounty.fee.min(balance); // just to be safe
+					let payout = balance.saturating_sub(fee);
+					let err_amount = T::Currency::unreserve(&curator, bounty.curator_deposit);
+					debug_assert!(err_amount.is_zero());
+
+					// Get total child bounties curator fees, and subtract it from the parent
+					// curator fee (the fee in present referenced bounty, `self`).
+					let children_fee = T::ChildBountyManager::children_curator_fees(bounty_id);
+					debug_assert!(children_fee <= fee);
+
+					let final_fee = fee.saturating_sub(children_fee);
+					let res =
+						T::Currency::transfer(&bounty_account, &curator, final_fee, AllowDeath); // should not fail
+					debug_assert!(res.is_ok());
+					let res =
+						T::Currency::transfer(&bounty_account, &beneficiary, payout, AllowDeath); // should not fail
+					debug_assert!(res.is_ok());
+
+					*maybe_bounty = None;
+
+					BountyDescriptions::<T, I>::remove(bounty_id);
+
+					Self::deposit_event(Event::<T, I>::BountyClaimed {
+						index: bounty_id,
+						payout,
+						beneficiary,
+					});
+					Ok(())
+				} else {
+					Err(Error::<T, I>::UnexpectedStatus.into())
+				}
+			})?;
+			Ok(())
+		}
+
+		/// Cancel a proposed or active bounty. All the funds will be sent to treasury and
+		/// the curator deposit will be unreserved if possible.
+		///
+		/// Only `T::RejectOrigin` is able to cancel a bounty.
+		///
+		/// - `bounty_id`: Bounty ID to cancel.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(7)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::close_bounty_proposed()
+			.max(<T as Config<I>>::WeightInfo::close_bounty_active()))]
+		pub fn close_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+		) -> DispatchResultWithPostInfo {
+			T::RejectOrigin::ensure_origin(origin)?;
+
+			Bounties::<T, I>::try_mutate_exists(
+				bounty_id,
+				|maybe_bounty| -> DispatchResultWithPostInfo {
+					let bounty = maybe_bounty.as_ref().ok_or(Error::<T, I>::InvalidIndex)?;
+
+					// Ensure no active child bounties before processing the call.
+					ensure!(
+						T::ChildBountyManager::child_bounties_count(bounty_id) == 0,
+						Error::<T, I>::HasActiveChildBounty
+					);
+
+					match &bounty.status {
+						BountyStatus::Proposed => {
+							// The reject origin would like to cancel a proposed bounty.
+							BountyDescriptions::<T, I>::remove(bounty_id);
+							let value = bounty.bond;
+							let imbalance = T::Currency::slash_reserved(&bounty.proposer, value).0;
+							T::OnSlash::on_unbalanced(imbalance);
+							*maybe_bounty = None;
+
+							Self::deposit_event(Event::<T, I>::BountyRejected {
+								index: bounty_id,
+								bond: value,
+							});
+							// Return early, nothing else to do.
+							return Ok(
+								Some(<T as Config<I>>::WeightInfo::close_bounty_proposed()).into()
+							)
+						},
+						BountyStatus::Approved => {
+							// For weight reasons, we don't allow a council to cancel in this phase.
+							// We ask for them to wait until it is funded before they can cancel.
+							return Err(Error::<T, I>::UnexpectedStatus.into())
+						},
+						BountyStatus::Funded | BountyStatus::CuratorProposed { .. } => {
+							// Nothing extra to do besides the removal of the bounty below.
+						},
+						BountyStatus::Active { curator, .. } => {
+							// Cancelled by council, refund deposit of the working curator.
+							let err_amount =
+								T::Currency::unreserve(curator, bounty.curator_deposit);
+							debug_assert!(err_amount.is_zero());
+							// Then execute removal of the bounty below.
+						},
+						BountyStatus::PendingPayout { .. } => {
+							// Bounty is already pending payout. If council wants to cancel
+							// this bounty, it should mean the curator was acting maliciously.
+							// So the council should first unassign the curator, slashing their
+							// deposit.
+							return Err(Error::<T, I>::PendingPayout.into())
+						},
+					}
+
+					let bounty_account = Self::bounty_account_id(bounty_id);
+
+					BountyDescriptions::<T, I>::remove(bounty_id);
+
+					let balance = T::Currency::free_balance(&bounty_account);
+					let res = T::Currency::transfer(
+						&bounty_account,
+						&Self::account_id(),
+						balance,
+						AllowDeath,
+					); // should not fail
+					debug_assert!(res.is_ok());
+					*maybe_bounty = None;
+
+					Self::deposit_event(Event::<T, I>::BountyCanceled { index: bounty_id });
+					Ok(Some(<T as Config<I>>::WeightInfo::close_bounty_active()).into())
+				},
+			)
+		}
+
+		/// Extend the expiry time of an active bounty.
+		///
+		/// The dispatch origin for this call must be the curator of this bounty.
+		///
+		/// - `bounty_id`: Bounty ID to extend.
+		/// - `remark`: additional information.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(8)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::extend_bounty_expiry())]
+		pub fn extend_bounty_expiry(
+			origin: OriginFor<T>,
+			#[pallet::compact] bounty_id: BountyIndex,
+			_remark: Vec<u8>,
+		) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+
+			Bounties::<T, I>::try_mutate_exists(bounty_id, |maybe_bounty| -> DispatchResult {
+				let bounty = maybe_bounty.as_mut().ok_or(Error::<T, I>::InvalidIndex)?;
+
+				match bounty.status {
+					BountyStatus::Active { ref curator, ref mut update_due } => {
+						ensure!(*curator == signer, Error::<T, I>::RequireCurator);
+						*update_due = (frame_system::Pallet::<T>::block_number() +
+							T::BountyUpdatePeriod::get())
+						.max(*update_due);
+					},
+					_ => return Err(Error::<T, I>::UnexpectedStatus.into()),
+				}
+
+				Ok(())
+			})?;
+
+			Self::deposit_event(Event::<T, I>::BountyExtended { index: bounty_id });
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	pub fn calculate_curator_deposit(fee: &BalanceOf<T, I>) -> BalanceOf<T, I> {
+		let mut deposit = T::CuratorDepositMultiplier::get() * *fee;
+
+		if let Some(max_deposit) = T::CuratorDepositMax::get() {
+			deposit = deposit.min(max_deposit)
+		}
+
+		if let Some(min_deposit) = T::CuratorDepositMin::get() {
+			deposit = deposit.max(min_deposit)
+		}
+
+		deposit
+	}
+
+	/// The account ID of the treasury pot.
+	///
+	/// This actually does computation. If you need to keep using it, then make sure you cache the
+	/// value and only call this once.
+	pub fn account_id() -> T::AccountId {
+		T::PalletId::get().into_account_truncating()
+	}
+
+	/// The account ID of a bounty account
+	pub fn bounty_account_id(id: BountyIndex) -> T::AccountId {
+		// only use two byte prefix to support 16 byte account id (used by test)
+		// "modl" ++ "py/trsry" ++ "bt" is 14 bytes, and two bytes remaining for bounty index
+		T::PalletId::get().into_sub_account_truncating(("bt", id))
+	}
+
+	fn create_bounty(
+		proposer: T::AccountId,
+		description: Vec<u8>,
+		value: BalanceOf<T, I>,
+	) -> DispatchResult {
+		let bounded_description: BoundedVec<_, _> =
+			description.try_into().map_err(|_| Error::<T, I>::ReasonTooBig)?;
+		ensure!(value >= T::BountyValueMinimum::get(), Error::<T, I>::InvalidValue);
+
+		let index = Self::bounty_count();
+
+		// reserve deposit for new bounty
+		let bond = T::BountyDepositBase::get() +
+			T::DataDepositPerByte::get() * (bounded_description.len() as u32).into();
+		T::Currency::reserve(&proposer, bond)
+			.map_err(|_| Error::<T, I>::InsufficientProposersBalance)?;
+
+		BountyCount::<T, I>::put(index + 1);
+
+		let bounty = Bounty {
+			proposer,
+			value,
+			fee: 0u32.into(),
+			curator_deposit: 0u32.into(),
+			bond,
+			status: BountyStatus::Proposed,
+		};
+
+		Bounties::<T, I>::insert(index, &bounty);
+		BountyDescriptions::<T, I>::insert(index, bounded_description);
+
+		Self::deposit_event(Event::<T, I>::BountyProposed { index });
+
+		Ok(())
+	}
+}
+
+impl<T: Config<I>, I: 'static> pallet_treasury::SpendFunds<T, I> for Pallet<T, I> {
+	fn spend_funds(
+		budget_remaining: &mut BalanceOf<T, I>,
+		imbalance: &mut PositiveImbalanceOf<T, I>,
+		total_weight: &mut Weight,
+		missed_any: &mut bool,
+	) {
+		let bounties_len = BountyApprovals::<T, I>::mutate(|v| {
+			let bounties_approval_len = v.len() as u32;
+			v.retain(|&index| {
+				Bounties::<T, I>::mutate(index, |bounty| {
+					// Should always be true, but shouldn't panic if false or we're screwed.
+					if let Some(bounty) = bounty {
+						if bounty.value <= *budget_remaining {
+							*budget_remaining -= bounty.value;
+
+							bounty.status = BountyStatus::Funded;
+
+							// return their deposit.
+							let err_amount = T::Currency::unreserve(&bounty.proposer, bounty.bond);
+							debug_assert!(err_amount.is_zero());
+
+							// fund the bounty account
+							imbalance.subsume(T::Currency::deposit_creating(
+								&Self::bounty_account_id(index),
+								bounty.value,
+							));
+
+							Self::deposit_event(Event::<T, I>::BountyBecameActive { index });
+							false
+						} else {
+							*missed_any = true;
+							true
+						}
+					} else {
+						false
+					}
+				})
+			});
+			bounties_approval_len
+		});
+
+		*total_weight += <T as pallet::Config<I>>::WeightInfo::spend_funds(bounties_len);
+	}
+}
+
+// Default impl for when ChildBounties is not being used in the runtime.
+impl<Balance: Zero> ChildBountyManager<Balance> for () {
+	fn child_bounties_count(_bounty_id: BountyIndex) -> BountyIndex {
+		Default::default()
+	}
+
+	fn children_curator_fees(_bounty_id: BountyIndex) -> Balance {
+		Zero::zero()
+	}
+}
diff --git a/substrate/frame/bounties/src/migrations/mod.rs b/substrate/frame/bounties/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2487ed1d5da5220522fc3d3143fe4166411a1dec
--- /dev/null
+++ b/substrate/frame/bounties/src/migrations/mod.rs
@@ -0,0 +1,19 @@
+// 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.
+
+/// Version 4.
+pub mod v4;
diff --git a/substrate/frame/bounties/src/migrations/v4.rs b/substrate/frame/bounties/src/migrations/v4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..936bac117008968cba3aef3e70e303056c8646df
--- /dev/null
+++ b/substrate/frame/bounties/src/migrations/v4.rs
@@ -0,0 +1,230 @@
+// 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_support::{
+	storage::{generator::StorageValue, StoragePrefixedMap},
+	traits::{
+		Get, GetStorageVersion, PalletInfoAccess, StorageVersion,
+		STORAGE_VERSION_STORAGE_KEY_POSTFIX,
+	},
+	weights::Weight,
+};
+use sp_core::hexdisplay::HexDisplay;
+use sp_io::{hashing::twox_128, storage};
+use sp_std::str;
+
+use crate as pallet_bounties;
+
+/// Migrate the storage of the bounties pallet to a new prefix, leaving all other storage untouched
+///
+/// This new prefix must be the same as the one set in construct_runtime. For safety, use
+/// `PalletInfo` to get it, as:
+/// `<Runtime as frame_system::Config>::PalletInfo::name::<BountiesPallet>`.
+///
+/// The migration will look into the storage version in order not to trigger a migration on an up
+/// to date storage. Thus the on chain storage version must be less than 4 in order to trigger the
+/// migration.
+pub fn migrate<
+	T: pallet_bounties::Config,
+	P: GetStorageVersion + PalletInfoAccess,
+	N: AsRef<str>,
+>(
+	old_pallet_name: N,
+	new_pallet_name: N,
+) -> Weight {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+
+	if new_pallet_name == old_pallet_name {
+		log::info!(
+			target: "runtime::bounties",
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return Weight::zero()
+	}
+
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: "runtime::bounties",
+		"Running migration to v4 for bounties with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 4 {
+		let storage_prefix = pallet_bounties::BountyCount::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, old_pallet_name, new_pallet_name);
+
+		let storage_prefix = pallet_bounties::Bounties::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, old_pallet_name, new_pallet_name);
+
+		let storage_prefix = pallet_bounties::BountyDescriptions::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, old_pallet_name, new_pallet_name);
+
+		let storage_prefix = pallet_bounties::BountyApprovals::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, old_pallet_name, new_pallet_name);
+
+		StorageVersion::new(4).put::<P>();
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: "runtime::bounties",
+			"Attempted to apply migration to v4 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::pre_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migration<T: pallet_bounties::Config, P: GetStorageVersion + 'static, N: AsRef<str>>(
+	old_pallet_name: N,
+	new_pallet_name: N,
+) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+	let storage_prefix_bounties_count = pallet_bounties::BountyCount::<T>::storage_prefix();
+	let storage_prefix_bounties = pallet_bounties::Bounties::<T>::storage_prefix();
+	let storage_prefix_bounties_description =
+		pallet_bounties::BountyDescriptions::<T>::storage_prefix();
+	let storage_prefix_bounties_approvals = pallet_bounties::BountyApprovals::<T>::storage_prefix();
+	log_migration("pre-migration", storage_prefix_bounties_count, old_pallet_name, new_pallet_name);
+	log_migration("pre-migration", storage_prefix_bounties, old_pallet_name, new_pallet_name);
+	log_migration(
+		"pre-migration",
+		storage_prefix_bounties_description,
+		old_pallet_name,
+		new_pallet_name,
+	);
+	log_migration(
+		"pre-migration",
+		storage_prefix_bounties_approvals,
+		old_pallet_name,
+		new_pallet_name,
+	);
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let storage_version_key =
+		[&new_pallet_prefix, &twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX)[..]].concat();
+
+	// ensure nothing is stored in the new prefix.
+	assert!(
+		storage::next_key(&new_pallet_prefix).map_or(
+			// either nothing is there
+			true,
+			// or we ensure that the next key has no common prefix with twox_128(new),
+			// or is the pallet version that is already stored using the pallet name
+			|next_key| {
+				storage::next_key(&next_key).map_or(true, |next_key| {
+					!next_key.starts_with(&new_pallet_prefix) || next_key == storage_version_key
+				})
+			},
+		),
+		"unexpected next_key({}) = {:?}",
+		new_pallet_name,
+		HexDisplay::from(&sp_io::storage::next_key(&new_pallet_prefix).unwrap()),
+	);
+	assert!(<P as GetStorageVersion>::on_chain_storage_version() < 4);
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migration<T: pallet_bounties::Config, P: GetStorageVersion, N: AsRef<str>>(
+	old_pallet_name: N,
+	new_pallet_name: N,
+) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+	let storage_prefix_bounties_count = pallet_bounties::BountyCount::<T>::storage_prefix();
+	let storage_prefix_bounties = pallet_bounties::Bounties::<T>::storage_prefix();
+	let storage_prefix_bounties_description =
+		pallet_bounties::BountyDescriptions::<T>::storage_prefix();
+	let storage_prefix_bounties_approvals = pallet_bounties::BountyApprovals::<T>::storage_prefix();
+	log_migration(
+		"post-migration",
+		storage_prefix_bounties_count,
+		old_pallet_name,
+		new_pallet_name,
+	);
+	log_migration("post-migration", storage_prefix_bounties, old_pallet_name, new_pallet_name);
+	log_migration(
+		"post-migration",
+		storage_prefix_bounties_description,
+		old_pallet_name,
+		new_pallet_name,
+	);
+	log_migration(
+		"post-migration",
+		storage_prefix_bounties_approvals,
+		old_pallet_name,
+		new_pallet_name,
+	);
+
+	let old_pallet_prefix = twox_128(old_pallet_name.as_bytes());
+	let old_bounties_count_key =
+		[&old_pallet_prefix, &twox_128(storage_prefix_bounties_count)[..]].concat();
+	let old_bounties_key = [&old_pallet_prefix, &twox_128(storage_prefix_bounties)[..]].concat();
+	let old_bounties_description_key =
+		[&old_pallet_prefix, &twox_128(storage_prefix_bounties_description)[..]].concat();
+	let old_bounties_approvals_key =
+		[&old_pallet_prefix, &twox_128(storage_prefix_bounties_approvals)[..]].concat();
+	assert!(storage::next_key(&old_bounties_count_key)
+		.map_or(true, |next_key| !next_key.starts_with(&old_bounties_count_key)));
+	assert!(storage::next_key(&old_bounties_key)
+		.map_or(true, |next_key| !next_key.starts_with(&old_bounties_key)));
+	assert!(storage::next_key(&old_bounties_description_key)
+		.map_or(true, |next_key| !next_key.starts_with(&old_bounties_description_key)));
+	assert!(storage::next_key(&old_bounties_approvals_key)
+		.map_or(true, |next_key| !next_key.starts_with(&old_bounties_approvals_key)));
+
+	assert_eq!(<P as GetStorageVersion>::on_chain_storage_version(), 4);
+}
+
+fn log_migration(stage: &str, storage_prefix: &[u8], old_pallet_name: &str, new_pallet_name: &str) {
+	log::info!(
+		target: "runtime::bounties",
+		"{} prefix of storage '{}': '{}' ==> '{}'",
+		stage,
+		str::from_utf8(storage_prefix).unwrap_or("<Invalid UTF8>"),
+		old_pallet_name,
+		new_pallet_name,
+	);
+}
diff --git a/substrate/frame/bounties/src/tests.rs b/substrate/frame/bounties/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a6fb89bb8601228cdd6427b6f20bc89887775781
--- /dev/null
+++ b/substrate/frame/bounties/src/tests.rs
@@ -0,0 +1,1392 @@
+// 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.
+
+//! bounties pallet tests.
+
+#![cfg(test)]
+
+use super::*;
+use crate as pallet_bounties;
+
+use frame_support::{
+	assert_noop, assert_ok, parameter_types,
+	traits::{ConstU32, ConstU64, OnInitialize},
+	PalletId,
+};
+
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BadOrigin, BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill, Storage,
+};
+
+use super::Event as BountiesEvent;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Bounties: pallet_bounties::{Pallet, Call, Storage, Event<T>},
+		Bounties1: pallet_bounties::<Instance1>::{Pallet, Call, Storage, Event<T>},
+		Treasury: pallet_treasury::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Treasury1: pallet_treasury::<Instance1>::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub const AvailableBlockRatio: Perbill = Perbill::one();
+}
+
+type Balance = u64;
+
+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 RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = u128; // u64 is not enough to hold bytes used to generate bounty account
+	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 RuntimeEvent = RuntimeEvent;
+	type DustRemoval = ();
+	type ExistentialDeposit = ConstU64<1>;
+	type AccountStore = System;
+	type WeightInfo = ();
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+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");
+	pub static SpendLimit: Balance = u64::MAX;
+	pub static SpendLimit1: Balance = u64::MAX;
+}
+
+impl pallet_treasury::Config for Test {
+	type PalletId = TreasuryPalletId;
+	type Currency = pallet_balances::Pallet<Test>;
+	type ApproveOrigin = frame_system::EnsureRoot<u128>;
+	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.
+	type WeightInfo = ();
+	type SpendFunds = Bounties;
+	type MaxApprovals = ConstU32<100>;
+	type SpendOrigin = frame_system::EnsureRootWithSuccess<Self::AccountId, SpendLimit>;
+}
+
+impl pallet_treasury::Config<Instance1> for Test {
+	type PalletId = TreasuryPalletId2;
+	type Currency = pallet_balances::Pallet<Test>;
+	type ApproveOrigin = frame_system::EnsureRoot<u128>;
+	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.
+	type WeightInfo = ();
+	type SpendFunds = Bounties1;
+	type MaxApprovals = ConstU32<100>;
+	type SpendOrigin = frame_system::EnsureRootWithSuccess<Self::AccountId, SpendLimit1>;
+}
+
+parameter_types! {
+	// This will be 50% of the bounty fee.
+	pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);
+	pub const CuratorDepositMax: Balance = 1_000;
+	pub const CuratorDepositMin: Balance = 3;
+
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type BountyDepositBase = ConstU64<80>;
+	type BountyDepositPayoutDelay = ConstU64<3>;
+	type BountyUpdatePeriod = ConstU64<20>;
+	type CuratorDepositMultiplier = CuratorDepositMultiplier;
+	type CuratorDepositMax = CuratorDepositMax;
+	type CuratorDepositMin = CuratorDepositMin;
+	type BountyValueMinimum = ConstU64<1>;
+	type DataDepositPerByte = ConstU64<1>;
+	type MaximumReasonLength = ConstU32<16384>;
+	type WeightInfo = ();
+	type ChildBountyManager = ();
+}
+
+impl Config<Instance1> for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type BountyDepositBase = ConstU64<80>;
+	type BountyDepositPayoutDelay = ConstU64<3>;
+	type BountyUpdatePeriod = ConstU64<20>;
+	type CuratorDepositMultiplier = CuratorDepositMultiplier;
+	type CuratorDepositMax = CuratorDepositMax;
+	type CuratorDepositMin = CuratorDepositMin;
+	type BountyValueMinimum = ConstU64<1>;
+	type DataDepositPerByte = ConstU64<1>;
+	type MaximumReasonLength = ConstU32<16384>;
+	type WeightInfo = ();
+	type ChildBountyManager = ();
+}
+
+type TreasuryError = pallet_treasury::Error<Test>;
+type TreasuryError1 = pallet_treasury::Error<Test, Instance1>;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut ext: sp_io::TestExternalities = RuntimeGenesisConfig {
+		system: frame_system::GenesisConfig::default(),
+		balances: pallet_balances::GenesisConfig { balances: vec![(0, 100), (1, 98), (2, 1)] },
+		treasury: Default::default(),
+		treasury_1: Default::default(),
+	}
+	.build_storage()
+	.unwrap()
+	.into();
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+fn last_event() -> BountiesEvent<Test> {
+	System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::Bounties(inner) = e { Some(inner) } else { None })
+		.last()
+		.unwrap()
+}
+
+#[test]
+fn genesis_config_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Treasury::pot(), 0);
+		assert_eq!(Treasury::proposal_count(), 0);
+	});
+}
+
+#[test]
+fn minting_works() {
+	new_test_ext().execute_with(|| {
+		// Check that accumulate works when we have Some value in Dummy already.
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+	});
+}
+
+#[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)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(1);
+		assert_eq!(Balances::free_balance(3), 0);
+		assert_eq!(Treasury::pot(), 100);
+	});
+}
+
+#[test]
+fn unused_pot_should_diminish() {
+	new_test_ext().execute_with(|| {
+		let init_total_issuance = Balances::total_issuance();
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::total_issuance(), init_total_issuance + 100);
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		assert_eq!(Treasury::pot(), 50);
+		assert_eq!(Balances::total_issuance(), init_total_issuance + 50);
+	});
+}
+
+#[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)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		assert_eq!(Balances::free_balance(3), 100);
+		assert_eq!(Treasury::pot(), 0);
+	});
+}
+
+#[test]
+fn pot_underflow_should_not_diminish() {
+	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), 150, 3)
+		});
+		assert_ok!({
+			#[allow(deprecated)]
+			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		assert_eq!(Treasury::pot(), 100); // Pot hasn't changed
+
+		assert_ok!(Balances::deposit_into_existing(&Treasury::account_id(), 100));
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+		assert_eq!(Balances::free_balance(3), 150); // Fund has been spent
+		assert_eq!(Treasury::pot(), 25); // Pot has finally changed
+	});
+}
+
+// Treasury account doesn't get deleted if amount approved to spend is all its free balance.
+// i.e. pot should not include existential deposit needed for account survival.
+#[test]
+fn treasury_account_doesnt_get_deleted() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		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)
+		});
+
+		<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)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+		assert_eq!(Treasury::pot(), 0); // Pot is emptied
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 1); // but the account is still there
+	});
+}
+
+// In case treasury account is not existing then it works fine.
+// This is useful for chain that will just update runtime.
+#[test]
+fn inexistent_account_works() {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> { balances: vec![(0, 100), (1, 99), (2, 1)] }
+		.assimilate_storage(&mut t)
+		.unwrap();
+	// Treasury genesis config is not build thus treasury account does not exist
+	let mut t: sp_io::TestExternalities = t.into();
+
+	t.execute_with(|| {
+		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)
+		});
+		<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
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 100);
+		assert_eq!(Treasury::pot(), 99); // Pot now contains funds
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 100); // Account does exist
+
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+
+		assert_eq!(Treasury::pot(), 0); // Pot has changed
+		assert_eq!(Balances::free_balance(3), 99); // Balance of `3` has changed
+	});
+}
+
+#[test]
+fn propose_bounty_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 10, b"1234567890".to_vec()));
+
+		assert_eq!(last_event(), BountiesEvent::BountyProposed { index: 0 });
+
+		let deposit: u64 = 85 + 5;
+		assert_eq!(Balances::reserved_balance(0), deposit);
+		assert_eq!(Balances::free_balance(0), 100 - deposit);
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 0,
+				curator_deposit: 0,
+				value: 10,
+				bond: deposit,
+				status: BountyStatus::Proposed,
+			}
+		);
+
+		assert_eq!(Bounties::bounty_descriptions(0).unwrap(), b"1234567890".to_vec());
+
+		assert_eq!(Bounties::bounty_count(), 1);
+	});
+}
+
+#[test]
+fn propose_bounty_validation_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+
+		assert_noop!(
+			Bounties::propose_bounty(RuntimeOrigin::signed(1), 0, [0; 17_000].to_vec()),
+			Error::<Test>::ReasonTooBig
+		);
+
+		assert_noop!(
+			Bounties::propose_bounty(
+				RuntimeOrigin::signed(1),
+				10,
+				b"12345678901234567890".to_vec()
+			),
+			Error::<Test>::InsufficientProposersBalance
+		);
+
+		assert_noop!(
+			Bounties::propose_bounty(RuntimeOrigin::signed(1), 0, b"12345678901234567890".to_vec()),
+			Error::<Test>::InvalidValue
+		);
+	});
+}
+
+#[test]
+fn close_bounty_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_noop!(Bounties::close_bounty(RuntimeOrigin::root(), 0), Error::<Test>::InvalidIndex);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 10, b"12345".to_vec()));
+
+		assert_ok!(Bounties::close_bounty(RuntimeOrigin::root(), 0));
+
+		let deposit: u64 = 80 + 5;
+
+		assert_eq!(last_event(), BountiesEvent::BountyRejected { index: 0, bond: deposit });
+
+		assert_eq!(Balances::reserved_balance(0), 0);
+		assert_eq!(Balances::free_balance(0), 100 - deposit);
+
+		assert_eq!(Bounties::bounties(0), None);
+		assert!(!pallet_treasury::Proposals::<Test>::contains_key(0));
+
+		assert_eq!(Bounties::bounty_descriptions(0), None);
+	});
+}
+
+#[test]
+fn approve_bounty_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_noop!(
+			Bounties::approve_bounty(RuntimeOrigin::root(), 0),
+			Error::<Test>::InvalidIndex
+		);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		let deposit: u64 = 80 + 5;
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 0,
+				value: 50,
+				curator_deposit: 0,
+				bond: deposit,
+				status: BountyStatus::Approved,
+			}
+		);
+		assert_eq!(Bounties::bounty_approvals(), vec![0]);
+
+		assert_noop!(
+			Bounties::close_bounty(RuntimeOrigin::root(), 0),
+			Error::<Test>::UnexpectedStatus
+		);
+
+		// deposit not returned yet
+		assert_eq!(Balances::reserved_balance(0), deposit);
+		assert_eq!(Balances::free_balance(0), 100 - deposit);
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		// return deposit
+		assert_eq!(Balances::reserved_balance(0), 0);
+		assert_eq!(Balances::free_balance(0), 100);
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 0,
+				curator_deposit: 0,
+				value: 50,
+				bond: deposit,
+				status: BountyStatus::Funded,
+			}
+		);
+
+		assert_eq!(Treasury::pot(), 100 - 50 - 25); // burn 25
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 50);
+	});
+}
+
+#[test]
+fn assign_curator_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+
+		assert_noop!(
+			Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 4),
+			Error::<Test>::InvalidIndex
+		);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_noop!(
+			Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 50),
+			Error::<Test>::InvalidFee
+		);
+
+		let fee = 4;
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, fee));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee,
+				curator_deposit: 0,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::CuratorProposed { curator: 4 },
+			}
+		);
+
+		assert_noop!(
+			Bounties::accept_curator(RuntimeOrigin::signed(1), 0),
+			Error::<Test>::RequireCurator
+		);
+		assert_noop!(
+			Bounties::accept_curator(RuntimeOrigin::signed(4), 0),
+			pallet_balances::Error::<Test, _>::InsufficientBalance
+		);
+
+		Balances::make_free_balance_be(&4, 10);
+
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		let expected_deposit = Bounties::calculate_curator_deposit(&fee);
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee,
+				curator_deposit: expected_deposit,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Active { curator: 4, update_due: 22 },
+			}
+		);
+
+		assert_eq!(Balances::free_balance(&4), 10 - expected_deposit);
+		assert_eq!(Balances::reserved_balance(&4), expected_deposit);
+	});
+}
+
+#[test]
+fn unassign_curator_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		let fee = 4;
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, fee));
+		assert_noop!(Bounties::unassign_curator(RuntimeOrigin::signed(1), 0), BadOrigin);
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::signed(4), 0));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee,
+				curator_deposit: 0,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Funded,
+			}
+		);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, fee));
+		Balances::make_free_balance_be(&4, 10);
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+		let expected_deposit = Bounties::calculate_curator_deposit(&fee);
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::root(), 0));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee,
+				curator_deposit: 0,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Funded,
+			}
+		);
+
+		assert_eq!(Balances::free_balance(&4), 10 - expected_deposit);
+		assert_eq!(Balances::reserved_balance(&4), 0); // slashed curator deposit
+	});
+}
+
+#[test]
+fn award_and_claim_bounty_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&4, 10);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		let fee = 4;
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, fee));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		let expected_deposit = Bounties::calculate_curator_deposit(&fee);
+		assert_eq!(Balances::free_balance(4), 10 - expected_deposit);
+
+		assert_noop!(
+			Bounties::award_bounty(RuntimeOrigin::signed(1), 0, 3),
+			Error::<Test>::RequireCurator
+		);
+
+		assert_ok!(Bounties::award_bounty(RuntimeOrigin::signed(4), 0, 3));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee,
+				curator_deposit: expected_deposit,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::PendingPayout { curator: 4, beneficiary: 3, unlock_at: 5 },
+			}
+		);
+
+		assert_noop!(Bounties::claim_bounty(RuntimeOrigin::signed(1), 0), Error::<Test>::Premature);
+
+		System::set_block_number(5);
+		<Treasury as OnInitialize<u64>>::on_initialize(5);
+
+		assert_ok!(Balances::transfer_allow_death(
+			RuntimeOrigin::signed(0),
+			Bounties::bounty_account_id(0),
+			10
+		));
+
+		assert_ok!(Bounties::claim_bounty(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(
+			last_event(),
+			BountiesEvent::BountyClaimed { index: 0, payout: 56, beneficiary: 3 }
+		);
+
+		assert_eq!(Balances::free_balance(4), 14); // initial 10 + fee 4
+
+		assert_eq!(Balances::free_balance(3), 56);
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 0);
+
+		assert_eq!(Bounties::bounties(0), None);
+		assert_eq!(Bounties::bounty_descriptions(0), None);
+	});
+}
+
+#[test]
+fn claim_handles_high_fee() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&4, 30);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 49));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		assert_ok!(Bounties::award_bounty(RuntimeOrigin::signed(4), 0, 3));
+
+		System::set_block_number(5);
+		<Treasury as OnInitialize<u64>>::on_initialize(5);
+
+		// make fee > balance
+		let res = Balances::slash(&Bounties::bounty_account_id(0), 10);
+		assert_eq!(res.0.peek(), 10);
+
+		assert_ok!(Bounties::claim_bounty(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(
+			last_event(),
+			BountiesEvent::BountyClaimed { index: 0, payout: 0, beneficiary: 3 }
+		);
+
+		assert_eq!(Balances::free_balance(4), 70); // 30 + 50 - 10
+		assert_eq!(Balances::free_balance(3), 0);
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 0);
+
+		assert_eq!(Bounties::bounties(0), None);
+		assert_eq!(Bounties::bounty_descriptions(0), None);
+	});
+}
+
+#[test]
+fn cancel_and_refund() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Balances::transfer_allow_death(
+			RuntimeOrigin::signed(0),
+			Bounties::bounty_account_id(0),
+			10
+		));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 0,
+				curator_deposit: 0,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Funded,
+			}
+		);
+
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 60);
+
+		assert_noop!(Bounties::close_bounty(RuntimeOrigin::signed(0), 0), BadOrigin);
+
+		assert_ok!(Bounties::close_bounty(RuntimeOrigin::root(), 0));
+
+		// `- 25 + 10`
+		assert_eq!(Treasury::pot(), 85);
+	});
+}
+
+#[test]
+fn award_and_cancel() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 0, 10));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(0), 0));
+
+		assert_eq!(Balances::free_balance(0), 95);
+		assert_eq!(Balances::reserved_balance(0), 5);
+
+		assert_ok!(Bounties::award_bounty(RuntimeOrigin::signed(0), 0, 3));
+
+		// Cannot close bounty directly when payout is happening...
+		assert_noop!(
+			Bounties::close_bounty(RuntimeOrigin::root(), 0),
+			Error::<Test>::PendingPayout
+		);
+
+		// Instead unassign the curator to slash them and then close.
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::root(), 0));
+		assert_ok!(Bounties::close_bounty(RuntimeOrigin::root(), 0));
+
+		assert_eq!(last_event(), BountiesEvent::BountyCanceled { index: 0 });
+
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 0);
+
+		// Slashed.
+		assert_eq!(Balances::free_balance(0), 95);
+		assert_eq!(Balances::reserved_balance(0), 0);
+
+		assert_eq!(Bounties::bounties(0), None);
+		assert_eq!(Bounties::bounty_descriptions(0), None);
+	});
+}
+
+#[test]
+fn expire_and_unassign() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 1, 10));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(Balances::free_balance(1), 93);
+		assert_eq!(Balances::reserved_balance(1), 5);
+
+		System::set_block_number(22);
+		<Treasury as OnInitialize<u64>>::on_initialize(22);
+
+		assert_noop!(
+			Bounties::unassign_curator(RuntimeOrigin::signed(0), 0),
+			Error::<Test>::Premature
+		);
+
+		System::set_block_number(23);
+		<Treasury as OnInitialize<u64>>::on_initialize(23);
+
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::signed(0), 0));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 10,
+				curator_deposit: 0,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Funded,
+			}
+		);
+
+		assert_eq!(Balances::free_balance(1), 93);
+		assert_eq!(Balances::reserved_balance(1), 0); // slashed
+	});
+}
+
+#[test]
+fn extend_expiry() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&4, 10);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		assert_noop!(
+			Bounties::extend_bounty_expiry(RuntimeOrigin::signed(1), 0, Vec::new()),
+			Error::<Test>::UnexpectedStatus
+		);
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 10));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		assert_eq!(Balances::free_balance(4), 5);
+		assert_eq!(Balances::reserved_balance(4), 5);
+
+		System::set_block_number(10);
+		<Treasury as OnInitialize<u64>>::on_initialize(10);
+
+		assert_noop!(
+			Bounties::extend_bounty_expiry(RuntimeOrigin::signed(0), 0, Vec::new()),
+			Error::<Test>::RequireCurator
+		);
+		assert_ok!(Bounties::extend_bounty_expiry(RuntimeOrigin::signed(4), 0, Vec::new()));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 10,
+				curator_deposit: 5,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Active { curator: 4, update_due: 30 },
+			}
+		);
+
+		assert_ok!(Bounties::extend_bounty_expiry(RuntimeOrigin::signed(4), 0, Vec::new()));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 10,
+				curator_deposit: 5,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Active { curator: 4, update_due: 30 }, // still the same
+			}
+		);
+
+		System::set_block_number(25);
+		<Treasury as OnInitialize<u64>>::on_initialize(25);
+
+		assert_noop!(
+			Bounties::unassign_curator(RuntimeOrigin::signed(0), 0),
+			Error::<Test>::Premature
+		);
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::signed(4), 0));
+
+		assert_eq!(Balances::free_balance(4), 10); // not slashed
+		assert_eq!(Balances::reserved_balance(4), 0);
+	});
+}
+
+#[test]
+fn test_migration_v4() {
+	let mut s = Storage::default();
+
+	let index: u32 = 10;
+
+	let bounty = Bounty::<u128, u64, u64> {
+		proposer: 0,
+		value: 20,
+		fee: 20,
+		curator_deposit: 20,
+		bond: 50,
+		status: BountyStatus::<u128, u64>::Proposed,
+	};
+
+	let data = vec![
+		(pallet_bounties::BountyCount::<Test>::hashed_key().to_vec(), 10.encode().to_vec()),
+		(pallet_bounties::Bounties::<Test>::hashed_key_for(index), bounty.encode().to_vec()),
+		(pallet_bounties::BountyDescriptions::<Test>::hashed_key_for(index), vec![0, 0]),
+		(
+			pallet_bounties::BountyApprovals::<Test>::hashed_key().to_vec(),
+			vec![10 as u32].encode().to_vec(),
+		),
+	];
+
+	s.top = data.into_iter().collect();
+
+	sp_io::TestExternalities::new(s).execute_with(|| {
+		use frame_support::traits::PalletInfo;
+		let old_pallet_name = <Test as frame_system::Config>::PalletInfo::name::<Bounties>()
+			.expect("Bounties is part of runtime, so it has a name; qed");
+		let new_pallet_name = "NewBounties";
+
+		crate::migrations::v4::pre_migration::<Test, Bounties, _>(old_pallet_name, new_pallet_name);
+		crate::migrations::v4::migrate::<Test, Bounties, _>(old_pallet_name, new_pallet_name);
+		crate::migrations::v4::post_migration::<Test, Bounties, _>(
+			old_pallet_name,
+			new_pallet_name,
+		);
+	});
+}
+
+#[test]
+fn genesis_funding_works() {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let initial_funding = 100;
+	pallet_balances::GenesisConfig::<Test> {
+		// Total issuance will be 200 with treasury account initialized with 100.
+		balances: vec![(0, 100), (Treasury::account_id(), initial_funding)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	pallet_treasury::GenesisConfig::<Test>::default()
+		.assimilate_storage(&mut t)
+		.unwrap();
+	let mut t: sp_io::TestExternalities = t.into();
+
+	t.execute_with(|| {
+		assert_eq!(Balances::free_balance(Treasury::account_id()), initial_funding);
+		assert_eq!(Treasury::pot(), initial_funding - Balances::minimum_balance());
+	});
+}
+
+#[test]
+fn unassign_curator_self() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 1, 10));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(Balances::free_balance(1), 93);
+		assert_eq!(Balances::reserved_balance(1), 5);
+
+		System::set_block_number(8);
+		<Treasury as OnInitialize<u64>>::on_initialize(8);
+
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::signed(1), 0));
+
+		assert_eq!(
+			Bounties::bounties(0).unwrap(),
+			Bounty {
+				proposer: 0,
+				fee: 10,
+				curator_deposit: 0,
+				value: 50,
+				bond: 85,
+				status: BountyStatus::Funded,
+			}
+		);
+
+		assert_eq!(Balances::free_balance(1), 98);
+		assert_eq!(Balances::reserved_balance(1), 0); // not slashed
+	});
+}
+
+#[test]
+fn accept_curator_handles_different_deposit_calculations() {
+	// This test will verify that a bounty with and without a fee results
+	// in a different curator deposit: one using the value, and one using the fee.
+	new_test_ext().execute_with(|| {
+		// Case 1: With a fee
+		let user = 1;
+		let bounty_index = 0;
+		let value = 88;
+		let fee = 42;
+
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&user, 100);
+		// Allow for a larger spend limit:
+		SpendLimit::set(value);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), value, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), bounty_index));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), bounty_index, user, fee));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(user), bounty_index));
+
+		let expected_deposit = CuratorDepositMultiplier::get() * fee;
+		assert_eq!(Balances::free_balance(&user), 100 - expected_deposit);
+		assert_eq!(Balances::reserved_balance(&user), expected_deposit);
+
+		// Case 2: Lower bound
+		let user = 2;
+		let bounty_index = 1;
+		let value = 35;
+		let fee = 0;
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&user, 100);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), value, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), bounty_index));
+
+		System::set_block_number(4);
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), bounty_index, user, fee));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(user), bounty_index));
+
+		let expected_deposit = CuratorDepositMin::get();
+		assert_eq!(Balances::free_balance(&user), 100 - expected_deposit);
+		assert_eq!(Balances::reserved_balance(&user), expected_deposit);
+
+		// Case 3: Upper bound
+		let user = 3;
+		let bounty_index = 2;
+		let value = 1_000_000;
+		let fee = 50_000;
+		let starting_balance = fee * 2;
+
+		Balances::make_free_balance_be(&Treasury::account_id(), value * 2);
+		Balances::make_free_balance_be(&user, starting_balance);
+		Balances::make_free_balance_be(&0, starting_balance);
+
+		// Allow for a larger spend limit:
+		SpendLimit::set(value);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), value, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), bounty_index));
+
+		System::set_block_number(6);
+		<Treasury as OnInitialize<u64>>::on_initialize(6);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), bounty_index, user, fee));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(user), bounty_index));
+
+		let expected_deposit = CuratorDepositMax::get();
+		assert_eq!(Balances::free_balance(&user), starting_balance - expected_deposit);
+		assert_eq!(Balances::reserved_balance(&user), expected_deposit);
+	});
+}
+
+#[test]
+fn approve_bounty_works_second_instance() {
+	new_test_ext().execute_with(|| {
+		// Set burn to 0 to make tracking funds easier.
+		Burn::set(Permill::from_percent(0));
+
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&Treasury1::account_id(), 201);
+		assert_eq!(Balances::free_balance(&Treasury::account_id()), 101);
+		assert_eq!(Balances::free_balance(&Treasury1::account_id()), 201);
+
+		assert_ok!(Bounties1::propose_bounty(RuntimeOrigin::signed(0), 10, b"12345".to_vec()));
+		assert_ok!(Bounties1::approve_bounty(RuntimeOrigin::root(), 0));
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		<Treasury1 as OnInitialize<u64>>::on_initialize(2);
+
+		// Bounties 1 is funded... but from where?
+		assert_eq!(Balances::free_balance(Bounties1::bounty_account_id(0)), 10);
+		// Treasury 1 unchanged
+		assert_eq!(Balances::free_balance(&Treasury::account_id()), 101);
+		// Treasury 2 has funds removed
+		assert_eq!(Balances::free_balance(&Treasury1::account_id()), 201 - 10);
+	});
+}
+
+#[test]
+fn approve_bounty_insufficient_spend_limit_errors() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 51, b"123".to_vec()));
+		// 51 will not work since the limit is 50.
+		SpendLimit::set(50);
+		assert_noop!(
+			Bounties::approve_bounty(RuntimeOrigin::root(), 0),
+			TreasuryError::InsufficientPermission
+		);
+	});
+}
+
+#[test]
+fn approve_bounty_instance1_insufficient_spend_limit_errors() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+
+		Balances::make_free_balance_be(&Treasury1::account_id(), 101);
+		assert_eq!(Treasury1::pot(), 100);
+
+		assert_ok!(Bounties1::propose_bounty(RuntimeOrigin::signed(0), 51, b"123".to_vec()));
+		// 51 will not work since the limit is 50.
+		SpendLimit1::set(50);
+		assert_noop!(
+			Bounties1::approve_bounty(RuntimeOrigin::root(), 0),
+			TreasuryError1::InsufficientPermission
+		);
+	});
+}
+
+#[test]
+fn propose_curator_insufficient_spend_limit_errors() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+
+		// Temporarily set a larger spend limit;
+		SpendLimit::set(51);
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 51, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		SpendLimit::set(50);
+		// 51 will not work since the limit is 50.
+		assert_noop!(
+			Bounties::propose_curator(RuntimeOrigin::root(), 0, 0, 0),
+			TreasuryError::InsufficientPermission
+		);
+	});
+}
+
+#[test]
+fn propose_curator_instance1_insufficient_spend_limit_errors() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+
+		// Temporarily set a larger spend limit;
+		SpendLimit1::set(11);
+		assert_ok!(Bounties1::propose_bounty(RuntimeOrigin::signed(0), 11, b"12345".to_vec()));
+		assert_ok!(Bounties1::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury1 as OnInitialize<u64>>::on_initialize(2);
+
+		SpendLimit1::set(10);
+		// 11 will not work since the limit is 10.
+		assert_noop!(
+			Bounties1::propose_curator(RuntimeOrigin::root(), 0, 0, 0),
+			TreasuryError1::InsufficientPermission
+		);
+	});
+}
diff --git a/substrate/frame/bounties/src/weights.rs b/substrate/frame/bounties/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a172d15b56cc9a2a4686e3d6af61d9560635d5be
--- /dev/null
+++ b/substrate/frame/bounties/src/weights.rs
@@ -0,0 +1,407 @@
+// 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.
+
+//! Autogenerated weights for pallet_bounties
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_bounties
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/bounties/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_bounties.
+pub trait WeightInfo {
+	fn propose_bounty(d: u32, ) -> Weight;
+	fn approve_bounty() -> Weight;
+	fn propose_curator() -> Weight;
+	fn unassign_curator() -> Weight;
+	fn accept_curator() -> Weight;
+	fn award_bounty() -> Weight;
+	fn claim_bounty() -> Weight;
+	fn close_bounty_proposed() -> Weight;
+	fn close_bounty_active() -> Weight;
+	fn extend_bounty_expiry() -> Weight;
+	fn spend_funds(b: u32, ) -> Weight;
+}
+
+/// Weights for pallet_bounties using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Bounties BountyCount (r:1 w:1)
+	/// Proof: Bounties BountyCount (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)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:0 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// The range of component `d` is `[0, 300]`.
+	fn propose_bounty(d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `276`
+		//  Estimated: `3593`
+		// Minimum execution time: 29_384_000 picoseconds.
+		Weight::from_parts(30_820_018, 3593)
+			// Standard Error: 298
+			.saturating_add(Weight::from_parts(2_920, 0).saturating_mul(d.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyApprovals (r:1 w:1)
+	/// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	fn approve_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `368`
+		//  Estimated: `3642`
+		// Minimum execution time: 10_873_000 picoseconds.
+		Weight::from_parts(11_421_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	fn propose_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3642`
+		// Minimum execution time: 9_181_000 picoseconds.
+		Weight::from_parts(9_726_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn unassign_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `564`
+		//  Estimated: `3642`
+		// Minimum execution time: 30_257_000 picoseconds.
+		Weight::from_parts(30_751_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn accept_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `560`
+		//  Estimated: `3642`
+		// Minimum execution time: 27_850_000 picoseconds.
+		Weight::from_parts(28_821_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:0)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	fn award_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `572`
+		//  Estimated: `3642`
+		// Minimum execution time: 19_164_000 picoseconds.
+		Weight::from_parts(20_136_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:3 w:3)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn claim_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `936`
+		//  Estimated: `8799`
+		// Minimum execution time: 120_235_000 picoseconds.
+		Weight::from_parts(121_673_000, 8799)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:0)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_bounty_proposed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `616`
+		//  Estimated: `3642`
+		// Minimum execution time: 35_713_000 picoseconds.
+		Weight::from_parts(37_174_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:0)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_bounty_active() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `852`
+		//  Estimated: `6196`
+		// Minimum execution time: 81_037_000 picoseconds.
+		Weight::from_parts(83_294_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	fn extend_bounty_expiry() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `424`
+		//  Estimated: `3642`
+		// Minimum execution time: 15_348_000 picoseconds.
+		Weight::from_parts(15_776_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Bounties BountyApprovals (r:1 w:1)
+	/// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:100 w:100)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:200 w:200)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `b` is `[0, 100]`.
+	fn spend_funds(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4 + b * (297 ±0)`
+		//  Estimated: `1887 + b * (5206 ±0)`
+		// Minimum execution time: 5_082_000 picoseconds.
+		Weight::from_parts(5_126_000, 1887)
+			// Standard Error: 21_949
+			.saturating_add(Weight::from_parts(42_635_308, 0).saturating_mul(b.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(b.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(b.into())))
+			.saturating_add(Weight::from_parts(0, 5206).saturating_mul(b.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Bounties BountyCount (r:1 w:1)
+	/// Proof: Bounties BountyCount (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)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:0 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// The range of component `d` is `[0, 300]`.
+	fn propose_bounty(d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `276`
+		//  Estimated: `3593`
+		// Minimum execution time: 29_384_000 picoseconds.
+		Weight::from_parts(30_820_018, 3593)
+			// Standard Error: 298
+			.saturating_add(Weight::from_parts(2_920, 0).saturating_mul(d.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyApprovals (r:1 w:1)
+	/// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	fn approve_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `368`
+		//  Estimated: `3642`
+		// Minimum execution time: 10_873_000 picoseconds.
+		Weight::from_parts(11_421_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	fn propose_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3642`
+		// Minimum execution time: 9_181_000 picoseconds.
+		Weight::from_parts(9_726_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn unassign_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `564`
+		//  Estimated: `3642`
+		// Minimum execution time: 30_257_000 picoseconds.
+		Weight::from_parts(30_751_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn accept_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `560`
+		//  Estimated: `3642`
+		// Minimum execution time: 27_850_000 picoseconds.
+		Weight::from_parts(28_821_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:0)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	fn award_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `572`
+		//  Estimated: `3642`
+		// Minimum execution time: 19_164_000 picoseconds.
+		Weight::from_parts(20_136_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:3 w:3)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn claim_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `936`
+		//  Estimated: `8799`
+		// Minimum execution time: 120_235_000 picoseconds.
+		Weight::from_parts(121_673_000, 8799)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:0)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_bounty_proposed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `616`
+		//  Estimated: `3642`
+		// Minimum execution time: 35_713_000 picoseconds.
+		Weight::from_parts(37_174_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:0)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyDescriptions (r:0 w:1)
+	/// Proof: Bounties BountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_bounty_active() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `852`
+		//  Estimated: `6196`
+		// Minimum execution time: 81_037_000 picoseconds.
+		Weight::from_parts(83_294_000, 6196)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:1)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	fn extend_bounty_expiry() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `424`
+		//  Estimated: `3642`
+		// Minimum execution time: 15_348_000 picoseconds.
+		Weight::from_parts(15_776_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Bounties BountyApprovals (r:1 w:1)
+	/// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:100 w:100)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:200 w:200)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `b` is `[0, 100]`.
+	fn spend_funds(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4 + b * (297 ±0)`
+		//  Estimated: `1887 + b * (5206 ±0)`
+		// Minimum execution time: 5_082_000 picoseconds.
+		Weight::from_parts(5_126_000, 1887)
+			// Standard Error: 21_949
+			.saturating_add(Weight::from_parts(42_635_308, 0).saturating_mul(b.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(b.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(b.into())))
+			.saturating_add(Weight::from_parts(0, 5206).saturating_mul(b.into()))
+	}
+}
diff --git a/substrate/frame/broker/Cargo.toml b/substrate/frame/broker/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..daa2426b2c34ad20a3a8c2dc0f2263e6eaeb1307
--- /dev/null
+++ b/substrate/frame/broker/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "pallet-broker"
+version = "0.1.0"
+description = "Brokerage tool for managing Polkadot Core scheduling"
+authors = ["Parity Technologies <admin@parity.io>"]
+homepage = "https://substrate.io"
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/paritytech/substrate"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = [ "derive"] }
+scale-info = { version = "2.0.0", default-features = false, features = ["derive"] }
+bitvec = "1"
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+
+[dev-dependencies]
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/broker/README.md b/substrate/frame/broker/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..65b6179863e3d9bd69f6286538ea5ff696413f5c
--- /dev/null
+++ b/substrate/frame/broker/README.md
@@ -0,0 +1,26 @@
+# Pallet Broker
+
+Brokerage tool for managing Polkadot Core scheduling.
+
+Properly described in RFC-0001 Agile Coretime.
+
+## Implemnentation Specifics
+
+### Core Mask Bits
+
+This is 1/80th of a Polkadot Core per timeslice. Assuming timeslices are 80 blocks, then this
+indicates usage of a single core one time over a timeslice.
+
+### The Sale
+
+```nocompile
+					1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2
+0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7
+--------------------------------------------------------
+< interlude  >
+			  <                   sale                 >
+							... of which ...
+			  <  descending-price   ><   fixed-price   >
+														| <-------\
+price fixed, unsold assigned to instapool, system cores reserved -/
+```
diff --git a/substrate/frame/broker/src/adapt_price.rs b/substrate/frame/broker/src/adapt_price.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8266625687a23073a335bcab58db6ef7c33c8d80
--- /dev/null
+++ b/substrate/frame/broker/src/adapt_price.rs
@@ -0,0 +1,84 @@
+// 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.
+
+#![deny(missing_docs)]
+
+use crate::CoreIndex;
+use sp_arithmetic::{traits::One, FixedU64};
+
+/// Type for determining how to set price.
+pub trait AdaptPrice {
+	/// 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.
+	///
+	/// - `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;
+}
+
+impl AdaptPrice for () {
+	fn leadin_factor_at(_: FixedU64) -> FixedU64 {
+		FixedU64::one()
+	}
+	fn adapt_price(_: CoreIndex, _: CoreIndex, _: CoreIndex) -> FixedU64 {
+		FixedU64::one()
+	}
+}
+
+/// Simple implementation of `AdaptPrice` giving a monotonic leadin and a linear price change based
+/// on cores sold.
+pub struct Linear;
+impl AdaptPrice for Linear {
+	fn leadin_factor_at(when: FixedU64) -> FixedU64 {
+		FixedU64::from(2) - when
+	}
+	fn adapt_price(sold: CoreIndex, target: CoreIndex, limit: CoreIndex) -> FixedU64 {
+		if sold <= target {
+			FixedU64::from_rational(sold.into(), target.into())
+		} else {
+			FixedU64::one() +
+				FixedU64::from_rational((sold - target).into(), (limit - target).into())
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[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());
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/substrate/frame/broker/src/benchmarking.rs b/substrate/frame/broker/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..663bf2f466cf3c0090cd7b832bb38ed26da90613
--- /dev/null
+++ b/substrate/frame/broker/src/benchmarking.rs
@@ -0,0 +1,858 @@
+// 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(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use crate::{CoreAssignment::Task, Pallet as Broker};
+use frame_benchmarking::v2::*;
+use frame_support::{
+	storage::bounded_vec::BoundedVec,
+	traits::{
+		fungible::{Inspect, Mutate},
+		EnsureOrigin, Hooks,
+	},
+};
+use frame_system::{Pallet as System, RawOrigin};
+use sp_arithmetic::{traits::Zero, Perbill};
+use sp_core::Get;
+use sp_runtime::Saturating;
+use sp_std::{vec, vec::Vec};
+
+const SEED: u32 = 0;
+const MAX_CORE_COUNT: u16 = 1_000;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn new_config_record<T: Config>() -> ConfigRecordOf<T> {
+	ConfigRecord {
+		advance_notice: 2u32.into(),
+		interlude_length: 1u32.into(),
+		leadin_length: 1u32.into(),
+		ideal_bulk_proportion: Default::default(),
+		limit_cores_offered: None,
+		region_length: 3,
+		renewal_bump: Perbill::from_percent(10),
+		contribution_timeout: 5,
+	}
+}
+
+fn new_schedule() -> Schedule {
+	// Max items for worst case
+	let mut items = Vec::new();
+	for i in 0..CORE_MASK_BITS {
+		items.push(ScheduleItem {
+			assignment: Task(i.try_into().unwrap()),
+			mask: CoreMask::complete(),
+		});
+	}
+	Schedule::truncate_from(items)
+}
+
+fn setup_reservations<T: Config>(n: u32) {
+	let schedule = new_schedule();
+
+	Reservations::<T>::put(BoundedVec::try_from(vec![schedule.clone(); n as usize]).unwrap());
+}
+
+fn setup_leases<T: Config>(n: u32, task: u32, until: u32) {
+	Leases::<T>::put(
+		BoundedVec::try_from(vec![LeaseRecordItem { task, until: until.into() }; n as usize])
+			.unwrap(),
+	);
+}
+
+fn advance_to<T: Config>(b: u32) {
+	while System::<T>::block_number() < b.into() {
+		System::<T>::set_block_number(System::<T>::block_number().saturating_add(1u32.into()));
+		Broker::<T>::on_initialize(System::<T>::block_number());
+	}
+}
+
+fn setup_and_start_sale<T: Config>() -> Result<u16, BenchmarkError> {
+	Configuration::<T>::put(new_config_record::<T>());
+
+	// Assume Reservations to be filled for worst case
+	setup_reservations::<T>(T::MaxReservedCores::get());
+
+	// Assume Leases to be filled for worst case
+	setup_leases::<T>(T::MaxLeasedCores::get(), 1, 10);
+
+	Broker::<T>::do_start_sales(10u32.into(), MAX_CORE_COUNT.into())
+		.map_err(|_| BenchmarkError::Weightless)?;
+
+	Ok(T::MaxReservedCores::get()
+		.saturating_add(T::MaxLeasedCores::get())
+		.try_into()
+		.unwrap())
+}
+
+#[benchmarks]
+mod benches {
+	use super::*;
+	use crate::Finality::*;
+
+	#[benchmark]
+	fn configure() -> Result<(), BenchmarkError> {
+		let config = new_config_record::<T>();
+
+		let origin =
+			T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, config.clone());
+
+		assert_eq!(Configuration::<T>::get(), Some(config));
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn reserve() -> Result<(), BenchmarkError> {
+		let schedule = new_schedule();
+
+		// Assume Reservations to be almost filled for worst case
+		setup_reservations::<T>(T::MaxReservedCores::get().saturating_sub(1));
+
+		let origin =
+			T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, schedule);
+
+		assert_eq!(Reservations::<T>::get().len(), T::MaxReservedCores::get() as usize);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn unreserve() -> Result<(), BenchmarkError> {
+		// Assume Reservations to be filled for worst case
+		setup_reservations::<T>(T::MaxReservedCores::get());
+
+		let origin =
+			T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, 0);
+
+		assert_eq!(
+			Reservations::<T>::get().len(),
+			T::MaxReservedCores::get().saturating_sub(1) as usize
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_lease() -> Result<(), BenchmarkError> {
+		let task = 1u32;
+		let until = 10u32.into();
+
+		// Assume Leases to be almost filled for worst case
+		setup_leases::<T>(T::MaxLeasedCores::get().saturating_sub(1), task, until);
+
+		let origin =
+			T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, task, until);
+
+		assert_eq!(Leases::<T>::get().len(), T::MaxLeasedCores::get() as usize);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn start_sales(n: Linear<0, { MAX_CORE_COUNT.into() }>) -> Result<(), BenchmarkError> {
+		Configuration::<T>::put(new_config_record::<T>());
+
+		// Assume Reservations to be filled for worst case
+		setup_reservations::<T>(T::MaxReservedCores::get());
+
+		// Assume Leases to be filled for worst case
+		setup_leases::<T>(T::MaxLeasedCores::get(), 1, 10);
+
+		let initial_price = 10u32.into();
+
+		let origin =
+			T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, initial_price, n.try_into().unwrap());
+
+		assert!(SaleInfo::<T>::get().is_some());
+		assert_last_event::<T>(
+			Event::SaleInitialized {
+				sale_start: 2u32.into(),
+				leadin_length: 1u32.into(),
+				start_price: 20u32.into(),
+				regular_price: 10u32.into(),
+				region_begin: 4,
+				region_end: 7,
+				ideal_cores_sold: 0,
+				cores_offered: n
+					.saturating_sub(T::MaxReservedCores::get())
+					.saturating_sub(T::MaxLeasedCores::get())
+					.try_into()
+					.unwrap(),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn purchase() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), 10u32.into());
+
+		assert_eq!(SaleInfo::<T>::get().unwrap().sellout_price, Some(10u32.into()));
+		assert_last_event::<T>(
+			Event::Purchased {
+				who: caller,
+				region_id: RegionId { begin: 4, core, mask: CoreMask::complete() },
+				price: 10u32.into(),
+				duration: 3u32.into(),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn renew() -> Result<(), BenchmarkError> {
+		setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(20u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		Broker::<T>::do_assign(region, None, 1001, Final)
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		advance_to::<T>(6);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region.core);
+
+		let id = AllowedRenewalId { core: region.core, when: 10 };
+		assert!(AllowedRenewals::<T>::get(id).is_some());
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn transfer() -> Result<(), BenchmarkError> {
+		setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), region, recipient.clone());
+
+		assert_last_event::<T>(
+			Event::Transferred {
+				region_id: region,
+				old_owner: caller,
+				owner: recipient,
+				duration: 3u32.into(),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn partition() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region, 2);
+
+		assert_last_event::<T>(
+			Event::Partitioned {
+				old_region_id: RegionId { begin: 4, core, mask: CoreMask::complete() },
+				new_region_ids: (
+					RegionId { begin: 4, core, mask: CoreMask::complete() },
+					RegionId { begin: 6, core, mask: CoreMask::complete() },
+				),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn interlace() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region, 0x00000_fffff_fffff_00000.into());
+
+		assert_last_event::<T>(
+			Event::Interlaced {
+				old_region_id: RegionId { begin: 4, core, mask: CoreMask::complete() },
+				new_region_ids: (
+					RegionId { begin: 4, core, mask: 0x00000_fffff_fffff_00000.into() },
+					RegionId {
+						begin: 4,
+						core,
+						mask: CoreMask::complete() ^ 0x00000_fffff_fffff_00000.into(),
+					},
+				),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn assign() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region, 1000, Provisional);
+
+		let workplan_key = (region.begin, region.core);
+		assert!(Workplan::<T>::get(workplan_key).is_some());
+
+		assert!(Regions::<T>::get(region).is_some());
+
+		assert_last_event::<T>(
+			Event::Assigned {
+				region_id: RegionId { begin: 4, core, mask: CoreMask::complete() },
+				task: 1000,
+				duration: 3u32.into(),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn pool() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region, recipient, Final);
+
+		let workplan_key = (region.begin, region.core);
+		assert!(Workplan::<T>::get(workplan_key).is_some());
+
+		assert_last_event::<T>(
+			Event::Pooled {
+				region_id: RegionId { begin: 4, core, mask: CoreMask::complete() },
+				duration: 3u32.into(),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn claim_revenue(
+		m: Linear<1, { new_config_record::<T>().region_length }>,
+	) -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+		T::Currency::set_balance(
+			&Broker::<T>::account_id(),
+			T::Currency::minimum_balance().saturating_add(200u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		T::Currency::set_balance(&recipient.clone(), T::Currency::minimum_balance());
+
+		Broker::<T>::do_pool(region, None, recipient.clone(), Final)
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let revenue = 10u32.into();
+		InstaPoolHistory::<T>::insert(
+			region.begin,
+			InstaPoolHistoryRecord {
+				private_contributions: 4u32.into(),
+				system_contributions: 3u32.into(),
+				maybe_payout: Some(revenue),
+			},
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region, m);
+
+		assert!(InstaPoolHistory::<T>::get(region.begin).is_none());
+		assert_last_event::<T>(
+			Event::RevenueClaimPaid {
+				who: recipient,
+				amount: 200u32.into(),
+				next: if m < new_config_record::<T>().region_length {
+					Some(RegionId { begin: 4.saturating_add(m), core, mask: CoreMask::complete() })
+				} else {
+					None
+				},
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn purchase_credit() -> Result<(), BenchmarkError> {
+		setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(30u32.into()),
+		);
+		T::Currency::set_balance(&Broker::<T>::account_id(), T::Currency::minimum_balance());
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+
+		Broker::<T>::do_pool(region, None, recipient, Final)
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let beneficiary: RelayAccountIdOf<T> = account("beneficiary", 0, SEED);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), 20u32.into(), beneficiary.clone());
+
+		assert_last_event::<T>(
+			Event::CreditPurchased { who: caller, beneficiary, amount: 20u32.into() }.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn drop_region() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		advance_to::<T>(12);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region);
+
+		assert_last_event::<T>(
+			Event::RegionDropped {
+				region_id: RegionId { begin: 4, core, mask: CoreMask::complete() },
+				duration: 3u32.into(),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn drop_contribution() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(10u32.into()),
+		);
+
+		let region = Broker::<T>::do_purchase(caller.clone(), 10u32.into())
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+
+		Broker::<T>::do_pool(region, None, recipient, Final)
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		advance_to::<T>(26);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), region);
+
+		assert_last_event::<T>(
+			Event::ContributionDropped {
+				region_id: RegionId { begin: 4, core, mask: CoreMask::complete() },
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn drop_history() -> Result<(), BenchmarkError> {
+		setup_and_start_sale::<T>()?;
+		let when = 5u32.into();
+		let revenue = 10u32.into();
+
+		advance_to::<T>(25);
+
+		let caller: T::AccountId = whitelisted_caller();
+		InstaPoolHistory::<T>::insert(
+			when,
+			InstaPoolHistoryRecord {
+				private_contributions: 4u32.into(),
+				system_contributions: 3u32.into(),
+				maybe_payout: Some(revenue),
+			},
+		);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), when);
+
+		assert!(InstaPoolHistory::<T>::get(when).is_none());
+		assert_last_event::<T>(Event::HistoryDropped { when, revenue }.into());
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn drop_renewal() -> Result<(), BenchmarkError> {
+		let core = setup_and_start_sale::<T>()?;
+		let when = 5u32.into();
+
+		advance_to::<T>(10);
+
+		let id = AllowedRenewalId { core, when };
+		let record = AllowedRenewalRecord {
+			price: 1u32.into(),
+			completion: CompletionStatus::Complete(new_schedule()),
+		};
+		AllowedRenewals::<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());
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn request_core_count(n: Linear<0, { MAX_CORE_COUNT.into() }>) -> Result<(), BenchmarkError> {
+		let admin_origin =
+			T::AdminOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(admin_origin as T::RuntimeOrigin, n.try_into().unwrap());
+
+		assert_last_event::<T>(
+			Event::CoreCountRequested { core_count: n.try_into().unwrap() }.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn process_core_count(n: Linear<0, { MAX_CORE_COUNT.into() }>) -> Result<(), BenchmarkError> {
+		setup_and_start_sale::<T>()?;
+
+		let core_count = n.try_into().unwrap();
+
+		<T::Coretime as CoretimeInterface>::ensure_notify_core_count(core_count);
+
+		let mut status = Status::<T>::get().ok_or(BenchmarkError::Weightless)?;
+
+		#[block]
+		{
+			Broker::<T>::process_core_count(&mut status);
+		}
+
+		assert_last_event::<T>(Event::CoreCountChanged { core_count }.into());
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn process_revenue() -> Result<(), BenchmarkError> {
+		setup_and_start_sale::<T>()?;
+
+		advance_to::<T>(2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(
+			&caller.clone(),
+			T::Currency::minimum_balance().saturating_add(30u32.into()),
+		);
+		T::Currency::set_balance(&Broker::<T>::account_id(), T::Currency::minimum_balance());
+
+		<T::Coretime as CoretimeInterface>::ensure_notify_revenue_info(10u32.into(), 10u32.into());
+
+		InstaPoolHistory::<T>::insert(
+			4u32,
+			InstaPoolHistoryRecord {
+				private_contributions: 1u32.into(),
+				system_contributions: 9u32.into(),
+				maybe_payout: None,
+			},
+		);
+
+		#[block]
+		{
+			Broker::<T>::process_revenue();
+		}
+
+		assert_last_event::<T>(
+			Event::ClaimsReady {
+				when: 4u32.into(),
+				system_payout: 9u32.into(),
+				private_payout: 1u32.into(),
+			}
+			.into(),
+		);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn rotate_sale(n: Linear<0, { MAX_CORE_COUNT.into() }>) {
+		let core_count = n.try_into().unwrap();
+		let config = new_config_record::<T>();
+
+		let now = frame_system::Pallet::<T>::block_number();
+		let 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,
+			sellout_price: None,
+			region_begin: commit_timeslice,
+			region_end: commit_timeslice.saturating_add(config.region_length),
+			first_core: 0,
+			ideal_cores_sold: 0,
+			cores_offered: 0,
+			cores_sold: 0,
+		};
+
+		let status = StatusRecord {
+			core_count,
+			private_pool_size: 0,
+			system_pool_size: 0,
+			last_committed_timeslice: commit_timeslice.saturating_sub(1),
+			last_timeslice: Broker::<T>::current_timeslice(),
+		};
+
+		// Assume Reservations to be filled for worst case
+		setup_reservations::<T>(T::MaxReservedCores::get());
+
+		// Assume Leases to be filled for worst case
+		setup_leases::<T>(T::MaxLeasedCores::get(), 1, 10);
+
+		#[block]
+		{
+			Broker::<T>::rotate_sale(sale, &config, &status);
+		}
+
+		assert!(SaleInfo::<T>::get().is_some());
+		assert_last_event::<T>(
+			Event::SaleInitialized {
+				sale_start: 2u32.into(),
+				leadin_length: 1u32.into(),
+				start_price: 20u32.into(),
+				regular_price: 10u32.into(),
+				region_begin: 4,
+				region_end: 7,
+				ideal_cores_sold: 0,
+				cores_offered: n
+					.saturating_sub(T::MaxReservedCores::get())
+					.saturating_sub(T::MaxLeasedCores::get())
+					.try_into()
+					.unwrap(),
+			}
+			.into(),
+		);
+	}
+
+	#[benchmark]
+	fn process_pool() {
+		let when = 10u32.into();
+		let private_pool_size = 5u32.into();
+		let system_pool_size = 4u32.into();
+
+		let config = new_config_record::<T>();
+		let commit_timeslice = Broker::<T>::latest_timeslice_ready_to_commit(&config);
+		let mut status = StatusRecord {
+			core_count: 5u16.into(),
+			private_pool_size,
+			system_pool_size,
+			last_committed_timeslice: commit_timeslice.saturating_sub(1),
+			last_timeslice: Broker::<T>::current_timeslice(),
+		};
+
+		#[block]
+		{
+			Broker::<T>::process_pool(when, &mut status);
+		}
+
+		assert!(InstaPoolHistory::<T>::get(when).is_some());
+		assert_last_event::<T>(
+			Event::HistoryInitialized { when, private_pool_size, system_pool_size }.into(),
+		);
+	}
+
+	#[benchmark]
+	fn process_core_schedule() {
+		let timeslice = 10u32.into();
+		let core = 5u16.into();
+		let rc_begin = 1u32.into();
+
+		Workplan::<T>::insert((timeslice, core), new_schedule());
+
+		#[block]
+		{
+			Broker::<T>::process_core_schedule(timeslice, rc_begin, core);
+		}
+
+		assert_eq!(Workload::<T>::get(core).len(), CORE_MASK_BITS);
+
+		let mut assignment: Vec<(CoreAssignment, PartsOf57600)> = vec![];
+		for i in 0..CORE_MASK_BITS {
+			assignment.push((CoreAssignment::Task(i.try_into().unwrap()), 57600));
+		}
+		assert_last_event::<T>(Event::CoreAssigned { core, when: rc_begin, assignment }.into());
+	}
+
+	#[benchmark]
+	fn request_revenue_info_at() {
+		let current_timeslice = Broker::<T>::current_timeslice();
+		let rc_block = T::TimeslicePeriod::get() * current_timeslice.into();
+
+		#[block]
+		{
+			T::Coretime::request_revenue_info_at(rc_block);
+		}
+	}
+
+	// Implements a test for each benchmark. Execute with:
+	// `cargo test -p pallet-broker --features runtime-benchmarks`.
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/broker/src/core_mask.rs b/substrate/frame/broker/src/core_mask.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b8d045077d8285c1b7998e109733d25f4f946d5d
--- /dev/null
+++ b/substrate/frame/broker/src/core_mask.rs
@@ -0,0 +1,227 @@
+// 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 codec::{Decode, Encode, MaxEncodedLen};
+use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not};
+use scale_info::TypeInfo;
+use sp_core::RuntimeDebug;
+
+/// The number of bits in the `CoreMask`.
+pub const CORE_MASK_BITS: usize = 80;
+
+// TODO: Use BitArr instead; for this, we'll need to ensure Codec is impl'ed for `BitArr`.
+#[derive(
+	Encode, Decode, Default, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen,
+)]
+pub struct CoreMask([u8; 10]);
+impl CoreMask {
+	pub fn void() -> Self {
+		Self([0u8; 10])
+	}
+	pub fn complete() -> Self {
+		Self([255u8; 10])
+	}
+	pub fn is_void(&self) -> bool {
+		&self.0 == &[0u8; 10]
+	}
+	pub fn is_complete(&self) -> bool {
+		&self.0 == &[255u8; 10]
+	}
+	pub fn set(&mut self, i: u32) -> Self {
+		if i < 80 {
+			self.0[(i / 8) as usize] |= 128 >> (i % 8);
+		}
+		*self
+	}
+	pub fn clear(&mut self, i: u32) -> Self {
+		if i < 80 {
+			self.0[(i / 8) as usize] &= !(128 >> (i % 8));
+		}
+		*self
+	}
+	pub fn count_zeros(&self) -> u32 {
+		self.0.iter().map(|i| i.count_zeros()).sum()
+	}
+	pub fn count_ones(&self) -> u32 {
+		self.0.iter().map(|i| i.count_ones()).sum()
+	}
+	pub fn from_chunk(from: u32, to: u32) -> Self {
+		let mut v = [0u8; 10];
+		for i in (from.min(80) as usize)..(to.min(80) as usize) {
+			v[i / 8] |= 128 >> (i % 8);
+		}
+		Self(v)
+	}
+}
+impl From<u128> for CoreMask {
+	fn from(x: u128) -> Self {
+		let mut v = [0u8; 10];
+		v.iter_mut().rev().fold(x, |a, i| {
+			*i = a as u8;
+			a >> 8
+		});
+		Self(v)
+	}
+}
+impl From<CoreMask> for u128 {
+	fn from(x: CoreMask) -> Self {
+		x.0.into_iter().fold(0u128, |a, i| a << 8 | i as u128)
+	}
+}
+impl BitAnd<Self> for CoreMask {
+	type Output = Self;
+	fn bitand(mut self, rhs: Self) -> Self {
+		self.bitand_assign(rhs);
+		self
+	}
+}
+impl BitAndAssign<Self> for CoreMask {
+	fn bitand_assign(&mut self, rhs: Self) {
+		for i in 0..10 {
+			self.0[i].bitand_assign(rhs.0[i]);
+		}
+	}
+}
+impl BitOr<Self> for CoreMask {
+	type Output = Self;
+	fn bitor(mut self, rhs: Self) -> Self {
+		self.bitor_assign(rhs);
+		self
+	}
+}
+impl BitOrAssign<Self> for CoreMask {
+	fn bitor_assign(&mut self, rhs: Self) {
+		for i in 0..10 {
+			self.0[i].bitor_assign(rhs.0[i]);
+		}
+	}
+}
+impl BitXor<Self> for CoreMask {
+	type Output = Self;
+	fn bitxor(mut self, rhs: Self) -> Self {
+		self.bitxor_assign(rhs);
+		self
+	}
+}
+impl BitXorAssign<Self> for CoreMask {
+	fn bitxor_assign(&mut self, rhs: Self) {
+		for i in 0..10 {
+			self.0[i].bitxor_assign(rhs.0[i]);
+		}
+	}
+}
+impl Not for CoreMask {
+	type Output = Self;
+	fn not(self) -> Self {
+		let mut result = [0u8; 10];
+		for i in 0..10 {
+			result[i] = self.0[i].not();
+		}
+		Self(result)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn complete_works() {
+		assert_eq!(CoreMask::complete(), CoreMask([0xff; 10]));
+		assert!(CoreMask([0xff; 10]).is_complete());
+		for i in 0..80 {
+			assert!(!CoreMask([0xff; 10]).clear(i).is_complete());
+		}
+	}
+
+	#[test]
+	fn void_works() {
+		assert_eq!(CoreMask::void(), CoreMask([0; 10]));
+		assert!(CoreMask([0; 10]).is_void());
+		for i in 0..80 {
+			assert!(!(CoreMask([0; 10]).set(i).is_void()));
+		}
+	}
+
+	#[test]
+	fn from_works() {
+		assert!(CoreMask::from(0xfffff_fffff_fffff_fffff).is_complete());
+		assert_eq!(
+			CoreMask::from(0x12345_67890_abcde_f0123),
+			CoreMask([0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x01, 0x23]),
+		);
+	}
+
+	#[test]
+	fn into_works() {
+		assert_eq!(u128::from(CoreMask::complete()), 0xfffff_fffff_fffff_fffff);
+		assert_eq!(
+			0x12345_67890_abcde_f0123u128,
+			CoreMask([0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x01, 0x23]).into(),
+		);
+	}
+
+	#[test]
+	fn chunk_works() {
+		assert_eq!(CoreMask::from_chunk(40, 60), CoreMask::from(0x00000_00000_fffff_00000),);
+	}
+
+	#[test]
+	fn bit_or_works() {
+		assert_eq!(
+			CoreMask::from(0x02040_a0c0e_d0a0b_0ffff) | CoreMask::from(0x10305_0b0d0_0e0d0_e0000),
+			CoreMask::from(0x12345_abcde_deadb_effff),
+		);
+	}
+
+	#[test]
+	fn bit_or_assign_works() {
+		let mut a = CoreMask::from(0x02040_a0c0e_d0a0b_0ffff);
+		a |= CoreMask::from(0x10305_0b0d0_0e0d0_e0000);
+		assert_eq!(a, CoreMask::from(0x12345_abcde_deadb_effff));
+	}
+
+	#[test]
+	fn bit_and_works() {
+		assert_eq!(
+			CoreMask::from(0x00000_abcde_deadb_efff0) & CoreMask::from(0x02040_00000_d0a0b_0ff0f),
+			CoreMask::from(0x00000_00000_d0a0b_0ff00),
+		);
+	}
+
+	#[test]
+	fn bit_and_assign_works() {
+		let mut a = CoreMask::from(0x00000_abcde_deadb_efff0);
+		a &= CoreMask::from(0x02040_00000_d0a0b_0ff0f);
+		assert_eq!(a, CoreMask::from(0x00000_00000_d0a0b_0ff00));
+	}
+
+	#[test]
+	fn bit_xor_works() {
+		assert_eq!(
+			CoreMask::from(0x10010_10010_10010_10010) ^ CoreMask::from(0x01110_01110_01110_01110),
+			CoreMask::from(0x11100_11100_11100_11100),
+		);
+	}
+
+	#[test]
+	fn bit_xor_assign_works() {
+		let mut a = CoreMask::from(0x10010_10010_10010_10010);
+		a ^= CoreMask::from(0x01110_01110_01110_01110);
+		assert_eq!(a, CoreMask::from(0x11100_11100_11100_11100));
+	}
+}
diff --git a/substrate/frame/broker/src/coretime_interface.rs b/substrate/frame/broker/src/coretime_interface.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fec40b9fdd7b3d0e18216a2f634040b7bffc9279
--- /dev/null
+++ b/substrate/frame/broker/src/coretime_interface.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.
+
+#![deny(missing_docs)]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::Parameter;
+use scale_info::TypeInfo;
+use sp_arithmetic::traits::AtLeast32BitUnsigned;
+use sp_core::RuntimeDebug;
+use sp_std::{fmt::Debug, vec::Vec};
+
+/// Index of a Polkadot Core.
+pub type CoreIndex = u16;
+
+/// A Task Id. In general this is called a ParachainId.
+pub type TaskId = u32;
+
+/// Fraction expressed as a nominator with an assumed denominator of 57,600.
+pub type PartsOf57600 = u16;
+
+/// An element to which a core can be assigned.
+#[derive(
+	Encode, Decode, Clone, Eq, PartialEq, Ord, PartialOrd, RuntimeDebug, TypeInfo, MaxEncodedLen,
+)]
+pub enum CoreAssignment {
+	/// Core need not be used for anything.
+	Idle,
+	/// Core should be used for the Instantaneous Coretime Pool.
+	Pool,
+	/// Core should be used to process the given task.
+	Task(TaskId),
+}
+
+/// Type able to accept Coretime scheduling instructions and provide certain usage information.
+/// Generally implemented by the Relay-chain or some means of communicating with it.
+///
+/// The trait representation of RFC#5 `<https://github.com/polkadot-fellows/RFCs/pull/5>`.
+pub trait CoretimeInterface {
+	/// A (Relay-chain-side) account ID.
+	type AccountId: Parameter;
+
+	/// A (Relay-chain-side) balance.
+	type Balance: AtLeast32BitUnsigned;
+
+	/// A (Relay-chain-side) block number.
+	type BlockNumber: AtLeast32BitUnsigned
+		+ Copy
+		+ TypeInfo
+		+ Encode
+		+ Decode
+		+ MaxEncodedLen
+		+ Debug;
+
+	/// Return the latest block number on the Relay-chain.
+	fn latest() -> Self::BlockNumber;
+
+	/// Requests the Relay-chain to alter the number of schedulable cores to `count`. Under normal
+	/// operation, the Relay-chain SHOULD send a `notify_core_count(count)` message back.
+	fn request_core_count(count: CoreIndex);
+
+	/// Requests that the Relay-chain send a `notify_revenue` message back at or soon after
+	/// Relay-chain block number `when` whose `until` parameter is equal to `when`.
+	///
+	/// `when` may never be greater than the result of `Self::latest()`.
+	/// The period in to the past which `when` is allowed to be may be limited; if so the limit
+	/// should be understood on a channel outside of this proposal. In the case that the request
+	/// cannot be serviced because `when` is too old a block then a `notify_revenue` message must
+	/// still be returned, but its `revenue` field may be `None`.
+	fn request_revenue_info_at(when: Self::BlockNumber);
+
+	/// Instructs the Relay-chain to add the `amount` of DOT to the Instantaneous Coretime Market
+	/// Credit account of `who`.
+	///
+	/// It is expected that Instantaneous Coretime Market Credit on the Relay-chain is NOT
+	/// transferrable and only redeemable when used to assign cores in the Instantaneous Coretime
+	/// Pool.
+	fn credit_account(who: Self::AccountId, amount: Self::Balance);
+
+	/// Instructs the Relay-chain to ensure that the core indexed as `core` is utilised for a number
+	/// of assignments in specific ratios given by `assignment` starting as soon after `begin` as
+	/// possible. Core assignments take the form of a `CoreAssignment` value which can either task
+	/// the core to a `ParaId` value or indicate that the core should be used in the Instantaneous
+	/// Pool. Each assignment comes with a ratio value, represented as the numerator of the fraction
+	/// with a denominator of 57,600.
+	///
+	/// If `end_hint` is `Some` and the inner is greater than the current block number, then the
+	/// Relay-chain should optimize in the expectation of receiving a new `assign_core(core, ...)`
+	/// message at or prior to the block number of the inner value. Specific functionality should
+	/// remain unchanged regardless of the `end_hint` value.
+	fn assign_core(
+		core: CoreIndex,
+		begin: Self::BlockNumber,
+		assignment: Vec<(CoreAssignment, PartsOf57600)>,
+		end_hint: Option<Self::BlockNumber>,
+	);
+
+	/// Indicate that from this block onwards, the range of acceptable values of the `core`
+	/// parameter of `assign_core` message is `[0, count)`. `assign_core` will be a no-op if
+	/// provided with a value for `core` outside of this range.
+	fn check_notify_core_count() -> Option<u16>;
+
+	/// Provide the amount of revenue accumulated from Instantaneous Coretime Sales from Relay-chain
+	/// block number `last_until` to `until`, not including `until` itself. `last_until` is defined
+	/// as being the `until` argument of the last `notify_revenue` message sent, or zero for the
+	/// first call. If `revenue` is `None`, this indicates that the information is no longer
+	/// available.
+	///
+	/// This explicitly disregards the possibility of multiple parachains requesting and being
+	/// notified of revenue information. The Relay-chain must be configured to ensure that only a
+	/// single revenue information destination exists.
+	fn check_notify_revenue_info() -> Option<(Self::BlockNumber, Self::Balance)>;
+
+	/// Ensure that core count is updated to the provided value.
+	///
+	/// This is only used for benchmarking.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_core_count(count: u16);
+
+	/// Ensure that revenue information is updated to the provided value.
+	///
+	/// This is only used for benchmarking.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_revenue_info(when: Self::BlockNumber, revenue: Self::Balance);
+}
+
+impl CoretimeInterface for () {
+	type AccountId = ();
+	type Balance = u64;
+	type BlockNumber = u32;
+	fn latest() -> Self::BlockNumber {
+		0
+	}
+	fn request_core_count(_count: CoreIndex) {}
+	fn request_revenue_info_at(_when: Self::BlockNumber) {}
+	fn credit_account(_who: Self::AccountId, _amount: Self::Balance) {}
+	fn assign_core(
+		_core: CoreIndex,
+		_begin: Self::BlockNumber,
+		_assignment: Vec<(CoreAssignment, PartsOf57600)>,
+		_end_hint: Option<Self::BlockNumber>,
+	) {
+	}
+	fn check_notify_core_count() -> Option<u16> {
+		None
+	}
+	fn check_notify_revenue_info() -> Option<(Self::BlockNumber, Self::Balance)> {
+		None
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_core_count(_count: u16) {}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_revenue_info(_when: Self::BlockNumber, _revenue: Self::Balance) {}
+}
diff --git a/substrate/frame/broker/src/dispatchable_impls.rs b/substrate/frame/broker/src/dispatchable_impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c1d5a786b7cfb1f5474b2a1764a36b9f6478d57
--- /dev/null
+++ b/substrate/frame/broker/src/dispatchable_impls.rs
@@ -0,0 +1,436 @@
+// 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::{
+	pallet_prelude::{DispatchResult, *},
+	traits::{fungible::Mutate, tokens::Preservation::Expendable, DefensiveResult},
+};
+use sp_arithmetic::traits::{CheckedDiv, Saturating, Zero};
+use sp_runtime::traits::Convert;
+use CompletionStatus::{Complete, Partial};
+
+impl<T: Config> Pallet<T> {
+	pub(crate) fn do_configure(config: ConfigRecordOf<T>) -> DispatchResult {
+		config.validate().map_err(|()| Error::<T>::InvalidConfig)?;
+		Configuration::<T>::put(config);
+		Ok(())
+	}
+
+	pub(crate) fn do_request_core_count(core_count: CoreIndex) -> DispatchResult {
+		T::Coretime::request_core_count(core_count);
+		Self::deposit_event(Event::<T>::CoreCountRequested { core_count });
+		Ok(())
+	}
+
+	pub(crate) fn do_reserve(workload: Schedule) -> DispatchResult {
+		let mut r = Reservations::<T>::get();
+		let index = r.len() as u32;
+		r.try_push(workload.clone()).map_err(|_| Error::<T>::TooManyReservations)?;
+		Reservations::<T>::put(r);
+		Self::deposit_event(Event::<T>::ReservationMade { index, workload });
+		Ok(())
+	}
+
+	pub(crate) fn do_unreserve(index: u32) -> DispatchResult {
+		let mut r = Reservations::<T>::get();
+		ensure!(index < r.len() as u32, Error::<T>::UnknownReservation);
+		let workload = r.remove(index as usize);
+		Reservations::<T>::put(r);
+		Self::deposit_event(Event::<T>::ReservationCancelled { index, workload });
+		Ok(())
+	}
+
+	pub(crate) fn do_set_lease(task: TaskId, until: Timeslice) -> DispatchResult {
+		let mut r = Leases::<T>::get();
+		ensure!(until > Self::current_timeslice(), Error::<T>::AlreadyExpired);
+		r.try_push(LeaseRecordItem { until, task })
+			.map_err(|_| Error::<T>::TooManyLeases)?;
+		Leases::<T>::put(r);
+		Self::deposit_event(Event::<T>::Leased { until, task });
+		Ok(())
+	}
+
+	pub(crate) fn do_start_sales(price: BalanceOf<T>, core_count: CoreIndex) -> DispatchResult {
+		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let commit_timeslice = Self::latest_timeslice_ready_to_commit(&config);
+		let status = StatusRecord {
+			core_count,
+			private_pool_size: 0,
+			system_pool_size: 0,
+			last_committed_timeslice: commit_timeslice.saturating_sub(1),
+			last_timeslice: Self::current_timeslice(),
+		};
+		let now = frame_system::Pallet::<T>::block_number();
+		let dummy_sale = SaleInfoRecord {
+			sale_start: now,
+			leadin_length: Zero::zero(),
+			price,
+			sellout_price: None,
+			region_begin: commit_timeslice,
+			region_end: commit_timeslice.saturating_add(config.region_length),
+			first_core: 0,
+			ideal_cores_sold: 0,
+			cores_offered: 0,
+			cores_sold: 0,
+		};
+		Self::deposit_event(Event::<T>::SalesStarted { price, core_count });
+		Self::rotate_sale(dummy_sale, &config, &status);
+		Status::<T>::put(&status);
+		Ok(())
+	}
+
+	pub(crate) fn do_purchase(
+		who: T::AccountId,
+		price_limit: BalanceOf<T>,
+	) -> Result<RegionId, DispatchError> {
+		let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let mut sale = SaleInfo::<T>::get().ok_or(Error::<T>::NoSales)?;
+		ensure!(sale.first_core < status.core_count, Error::<T>::Unavailable);
+		ensure!(sale.cores_sold < sale.cores_offered, Error::<T>::SoldOut);
+		let now = frame_system::Pallet::<T>::block_number();
+		ensure!(now > sale.sale_start, Error::<T>::TooEarly);
+		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);
+		}
+		SaleInfo::<T>::put(&sale);
+		let id = Self::issue(core, sale.region_begin, sale.region_end, who.clone(), Some(price));
+		let duration = sale.region_end.saturating_sub(sale.region_begin);
+		Self::deposit_event(Event::Purchased { who, region_id: id, price, duration });
+		Ok(id)
+	}
+
+	/// Must be called on a core in `AllowedRenewals` 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)?;
+		let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let mut sale = SaleInfo::<T>::get().ok_or(Error::<T>::NoSales)?;
+		ensure!(sale.first_core < status.core_count, Error::<T>::Unavailable);
+		ensure!(sale.cores_sold < sale.cores_offered, Error::<T>::SoldOut);
+
+		let renewal_id = AllowedRenewalId { core, when: sale.region_begin };
+		let record = AllowedRenewals::<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)?;
+		Self::deposit_event(Event::Renewed {
+			who,
+			old_core,
+			core,
+			price: record.price,
+			begin: sale.region_begin,
+			duration: sale.region_end.saturating_sub(sale.region_begin),
+			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);
+		SaleInfo::<T>::put(&sale);
+		if let Some(workload) = new_record.completion.drain_complete() {
+			Self::deposit_event(Event::Renewable { core, price, begin, workload });
+		}
+		Ok(core)
+	}
+
+	pub(crate) fn do_transfer(
+		region_id: RegionId,
+		maybe_check_owner: Option<T::AccountId>,
+		new_owner: T::AccountId,
+	) -> Result<(), Error<T>> {
+		let mut region = Regions::<T>::get(&region_id).ok_or(Error::<T>::UnknownRegion)?;
+
+		if let Some(check_owner) = maybe_check_owner {
+			ensure!(check_owner == region.owner, Error::<T>::NotOwner);
+		}
+
+		let old_owner = region.owner;
+		region.owner = new_owner;
+		Regions::<T>::insert(&region_id, &region);
+		let duration = region.end.saturating_sub(region_id.begin);
+		Self::deposit_event(Event::Transferred {
+			region_id,
+			old_owner,
+			owner: region.owner,
+			duration,
+		});
+
+		Ok(())
+	}
+
+	pub(crate) fn do_partition(
+		region_id: RegionId,
+		maybe_check_owner: Option<T::AccountId>,
+		pivot_offset: Timeslice,
+	) -> Result<(RegionId, RegionId), Error<T>> {
+		let mut region = Regions::<T>::get(&region_id).ok_or(Error::<T>::UnknownRegion)?;
+
+		if let Some(check_owner) = maybe_check_owner {
+			ensure!(check_owner == region.owner, Error::<T>::NotOwner);
+		}
+		let pivot = region_id.begin.saturating_add(pivot_offset);
+		ensure!(pivot < region.end, Error::<T>::PivotTooLate);
+		ensure!(pivot > region_id.begin, Error::<T>::PivotTooEarly);
+
+		region.paid = None;
+		let new_region_ids = (region_id, RegionId { begin: pivot, ..region_id });
+
+		Regions::<T>::insert(&new_region_ids.0, &RegionRecord { end: pivot, ..region.clone() });
+		Regions::<T>::insert(&new_region_ids.1, &region);
+		Self::deposit_event(Event::Partitioned { old_region_id: region_id, new_region_ids });
+
+		Ok(new_region_ids)
+	}
+
+	pub(crate) fn do_interlace(
+		region_id: RegionId,
+		maybe_check_owner: Option<T::AccountId>,
+		pivot: CoreMask,
+	) -> Result<(RegionId, RegionId), Error<T>> {
+		let region = Regions::<T>::get(&region_id).ok_or(Error::<T>::UnknownRegion)?;
+
+		if let Some(check_owner) = maybe_check_owner {
+			ensure!(check_owner == region.owner, Error::<T>::NotOwner);
+		}
+
+		ensure!((pivot & !region_id.mask).is_void(), Error::<T>::ExteriorPivot);
+		ensure!(!pivot.is_void(), Error::<T>::VoidPivot);
+		ensure!(pivot != region_id.mask, Error::<T>::CompletePivot);
+
+		let one = RegionId { mask: pivot, ..region_id };
+		Regions::<T>::insert(&one, &region);
+		let other = RegionId { mask: region_id.mask ^ pivot, ..region_id };
+		Regions::<T>::insert(&other, &region);
+
+		let new_region_ids = (one, other);
+		Self::deposit_event(Event::Interlaced { old_region_id: region_id, new_region_ids });
+		Ok(new_region_ids)
+	}
+
+	pub(crate) fn do_assign(
+		region_id: RegionId,
+		maybe_check_owner: Option<T::AccountId>,
+		target: TaskId,
+		finality: Finality,
+	) -> Result<(), Error<T>> {
+		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		if let Some((region_id, region)) = Self::utilize(region_id, maybe_check_owner, finality)? {
+			let workplan_key = (region_id.begin, region_id.core);
+			let mut workplan = Workplan::<T>::get(&workplan_key).unwrap_or_default();
+			// Ensure no previous allocations exist.
+			workplan.retain(|i| (i.mask & region_id.mask).is_void());
+			if workplan
+				.try_push(ScheduleItem {
+					mask: region_id.mask,
+					assignment: CoreAssignment::Task(target),
+				})
+				.is_ok()
+			{
+				Workplan::<T>::insert(&workplan_key, &workplan);
+			}
+
+			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 })
+							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);
+					if let Some(workload) = record.completion.drain_complete() {
+						Self::deposit_event(Event::Renewable {
+							core: region_id.core,
+							price,
+							begin: region.end,
+							workload,
+						});
+					}
+				}
+			}
+			Self::deposit_event(Event::Assigned { region_id, task: target, duration });
+		}
+		Ok(())
+	}
+
+	pub(crate) fn do_pool(
+		region_id: RegionId,
+		maybe_check_owner: Option<T::AccountId>,
+		payee: T::AccountId,
+		finality: Finality,
+	) -> Result<(), Error<T>> {
+		if let Some((region_id, region)) = Self::utilize(region_id, maybe_check_owner, finality)? {
+			let workplan_key = (region_id.begin, region_id.core);
+			let mut workplan = Workplan::<T>::get(&workplan_key).unwrap_or_default();
+			let duration = region.end.saturating_sub(region_id.begin);
+			if workplan
+				.try_push(ScheduleItem { mask: region_id.mask, assignment: CoreAssignment::Pool })
+				.is_ok()
+			{
+				Workplan::<T>::insert(&workplan_key, &workplan);
+				let size = region_id.mask.count_ones() as i32;
+				InstaPoolIo::<T>::mutate(region_id.begin, |a| a.private.saturating_accrue(size));
+				InstaPoolIo::<T>::mutate(region.end, |a| a.private.saturating_reduce(size));
+				let record = ContributionRecord { length: duration, payee };
+				InstaPoolContribution::<T>::insert(&region_id, record);
+			}
+
+			Self::deposit_event(Event::Pooled { region_id, duration });
+		}
+		Ok(())
+	}
+
+	pub(crate) fn do_claim_revenue(
+		mut region: RegionId,
+		max_timeslices: Timeslice,
+	) -> DispatchResult {
+		let mut contribution =
+			InstaPoolContribution::<T>::take(region).ok_or(Error::<T>::UnknownContribution)?;
+		let contributed_parts = region.mask.count_ones();
+
+		Self::deposit_event(Event::RevenueClaimBegun { region, max_timeslices });
+
+		let mut payout = BalanceOf::<T>::zero();
+		let last = region.begin + contribution.length.min(max_timeslices);
+		for r in region.begin..last {
+			region.begin = r + 1;
+			contribution.length.saturating_dec();
+
+			let Some(mut pool_record) = InstaPoolHistory::<T>::get(r) else {
+				continue;
+			};
+			let Some(total_payout) = pool_record.maybe_payout else {
+				break;
+			};
+			let p = total_payout
+				.saturating_mul(contributed_parts.into())
+				.checked_div(&pool_record.private_contributions.into())
+				.unwrap_or_default();
+
+			payout.saturating_accrue(p);
+			pool_record.private_contributions.saturating_reduce(contributed_parts);
+
+			let remaining_payout = total_payout.saturating_sub(p);
+			if !remaining_payout.is_zero() && pool_record.private_contributions > 0 {
+				pool_record.maybe_payout = Some(remaining_payout);
+				InstaPoolHistory::<T>::insert(r, &pool_record);
+			} else {
+				InstaPoolHistory::<T>::remove(r);
+			}
+			if !p.is_zero() {
+				Self::deposit_event(Event::RevenueClaimItem { when: r, amount: p });
+			}
+		}
+
+		if contribution.length > 0 {
+			InstaPoolContribution::<T>::insert(region, &contribution);
+		}
+		T::Currency::transfer(&Self::account_id(), &contribution.payee, payout, Expendable)
+			.defensive_ok();
+		let next = if last < region.begin + contribution.length { Some(region) } else { None };
+		Self::deposit_event(Event::RevenueClaimPaid {
+			who: contribution.payee,
+			amount: payout,
+			next,
+		});
+		Ok(())
+	}
+
+	pub(crate) fn do_purchase_credit(
+		who: T::AccountId,
+		amount: BalanceOf<T>,
+		beneficiary: RelayAccountIdOf<T>,
+	) -> DispatchResult {
+		T::Currency::transfer(&who, &Self::account_id(), amount, Expendable)?;
+		let rc_amount = T::ConvertBalance::convert(amount);
+		T::Coretime::credit_account(beneficiary.clone(), rc_amount);
+		Self::deposit_event(Event::<T>::CreditPurchased { who, beneficiary, amount });
+		Ok(())
+	}
+
+	pub(crate) fn do_drop_region(region_id: RegionId) -> DispatchResult {
+		let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let region = Regions::<T>::get(&region_id).ok_or(Error::<T>::UnknownRegion)?;
+		ensure!(status.last_committed_timeslice >= region.end, Error::<T>::StillValid);
+
+		Regions::<T>::remove(&region_id);
+		let duration = region.end.saturating_sub(region_id.begin);
+		Self::deposit_event(Event::RegionDropped { region_id, duration });
+		Ok(())
+	}
+
+	pub(crate) fn do_drop_contribution(region_id: RegionId) -> DispatchResult {
+		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let contrib =
+			InstaPoolContribution::<T>::get(&region_id).ok_or(Error::<T>::UnknownContribution)?;
+		let end = region_id.begin.saturating_add(contrib.length);
+		ensure!(
+			status.last_timeslice >= end.saturating_add(config.contribution_timeout),
+			Error::<T>::StillValid
+		);
+		InstaPoolContribution::<T>::remove(region_id);
+		Self::deposit_event(Event::ContributionDropped { region_id });
+		Ok(())
+	}
+
+	pub(crate) fn do_drop_history(when: Timeslice) -> DispatchResult {
+		let config = Configuration::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		ensure!(status.last_timeslice > when + config.contribution_timeout, Error::<T>::StillValid);
+		let record = InstaPoolHistory::<T>::take(when).ok_or(Error::<T>::NoHistory)?;
+		if let Some(payout) = record.maybe_payout {
+			let _ = Self::charge(&Self::account_id(), payout);
+		}
+		let revenue = record.maybe_payout.unwrap_or_default();
+		Self::deposit_event(Event::HistoryDropped { when, revenue });
+		Ok(())
+	}
+
+	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 });
+		Ok(())
+	}
+}
diff --git a/substrate/frame/broker/src/lib.rs b/substrate/frame/broker/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4abd041f5f397c977ca06b8dbd6c294155b09b4f
--- /dev/null
+++ b/substrate/frame/broker/src/lib.rs
@@ -0,0 +1,784 @@
+// 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)]
+#![doc = include_str!("../README.md")]
+
+pub use pallet::*;
+
+mod adapt_price;
+mod benchmarking;
+mod core_mask;
+mod coretime_interface;
+mod dispatchable_impls;
+#[cfg(test)]
+mod mock;
+mod nonfungible_impl;
+#[cfg(test)]
+mod test_fungibles;
+#[cfg(test)]
+mod tests;
+mod tick_impls;
+mod types;
+mod utility_impls;
+
+pub mod weights;
+pub use weights::WeightInfo;
+
+pub use adapt_price::*;
+pub use core_mask::*;
+pub use coretime_interface::*;
+pub use nonfungible_impl::*;
+pub use types::*;
+pub use utility_impls::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{
+		pallet_prelude::{DispatchResult, DispatchResultWithPostInfo, *},
+		traits::{
+			fungible::{Balanced, Credit, Mutate},
+			EnsureOrigin, OnUnbalanced,
+		},
+		PalletId,
+	};
+	use frame_system::pallet_prelude::*;
+	use sp_runtime::traits::{Convert, ConvertBack};
+	use sp_std::vec::Vec;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for all calls of this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Currency used to pay for Coretime.
+		type Currency: Mutate<Self::AccountId> + Balanced<Self::AccountId>;
+
+		/// The origin test needed for administrating this pallet.
+		type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// What to do with any revenues collected from the sale of Coretime.
+		type OnRevenue: OnUnbalanced<Credit<Self::AccountId, Self::Currency>>;
+
+		/// Relay chain's Coretime API used to interact with and instruct the low-level scheduling
+		/// system.
+		type Coretime: CoretimeInterface;
+
+		/// The algorithm to determine the next price on the basis of market performance.
+		type PriceAdapter: AdaptPrice;
+
+		/// 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.
+		type ConvertBalance: Convert<BalanceOf<Self>, RelayBalanceOf<Self>>
+			+ ConvertBack<BalanceOf<Self>, RelayBalanceOf<Self>>;
+
+		/// Identifier from which the internal Pot is generated.
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// Number of Relay-chain blocks per timeslice.
+		#[pallet::constant]
+		type TimeslicePeriod: Get<RelayBlockNumberOf<Self>>;
+
+		/// Maximum number of legacy leases.
+		#[pallet::constant]
+		type MaxLeasedCores: Get<u32>;
+
+		/// Maximum number of system cores.
+		#[pallet::constant]
+		type MaxReservedCores: Get<u32>;
+	}
+
+	/// The current configuration of this pallet.
+	#[pallet::storage]
+	pub type Configuration<T> = StorageValue<_, ConfigRecordOf<T>, OptionQuery>;
+
+	/// The Polkadot Core reservations (generally tasked with the maintenance of System Chains).
+	#[pallet::storage]
+	pub type Reservations<T> = StorageValue<_, ReservationsRecordOf<T>, ValueQuery>;
+
+	/// The Polkadot Core legacy leases.
+	#[pallet::storage]
+	pub type Leases<T> = StorageValue<_, LeasesRecordOf<T>, ValueQuery>;
+
+	/// The current status of miscellaneous subsystems of this pallet.
+	#[pallet::storage]
+	pub type Status<T> = StorageValue<_, StatusRecord, OptionQuery>;
+
+	/// The details of the current sale, including its properties and status.
+	#[pallet::storage]
+	pub type SaleInfo<T> = StorageValue<_, SaleInfoRecordOf<T>, OptionQuery>;
+
+	/// Records of allowed renewals.
+	#[pallet::storage]
+	pub type AllowedRenewals<T> =
+		StorageMap<_, Twox64Concat, AllowedRenewalId, AllowedRenewalRecordOf<T>, OptionQuery>;
+
+	/// The current (unassigned) Regions.
+	#[pallet::storage]
+	pub type Regions<T> = StorageMap<_, Blake2_128Concat, RegionId, RegionRecordOf<T>, OptionQuery>;
+
+	/// The work we plan on having each core do at a particular time in the future.
+	#[pallet::storage]
+	pub type Workplan<T> =
+		StorageMap<_, Twox64Concat, (Timeslice, CoreIndex), Schedule, OptionQuery>;
+
+	/// The current workload of each core. This gets updated with workplan as timeslices pass.
+	#[pallet::storage]
+	pub type Workload<T> = StorageMap<_, Twox64Concat, CoreIndex, Schedule, ValueQuery>;
+
+	/// Record of a single contribution to the Instantaneous Coretime Pool.
+	#[pallet::storage]
+	pub type InstaPoolContribution<T> =
+		StorageMap<_, Blake2_128Concat, RegionId, ContributionRecordOf<T>, OptionQuery>;
+
+	/// Record of Coretime entering or leaving the Instantaneous Coretime Pool.
+	#[pallet::storage]
+	pub type InstaPoolIo<T> = StorageMap<_, Blake2_128Concat, Timeslice, PoolIoRecord, ValueQuery>;
+
+	/// Total InstaPool rewards for each Timeslice and the number of core parts which contributed.
+	#[pallet::storage]
+	pub type InstaPoolHistory<T> =
+		StorageMap<_, Blake2_128Concat, Timeslice, InstaPoolHistoryRecordOf<T>>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A Region of Bulk Coretime has been purchased.
+		Purchased {
+			/// The identity of the purchaser.
+			who: T::AccountId,
+			/// The identity of the Region.
+			region_id: RegionId,
+			/// The price paid for this Region.
+			price: BalanceOf<T>,
+			/// The duration of the Region.
+			duration: Timeslice,
+		},
+		/// The workload of a core has become renewable.
+		Renewable {
+			/// The core whose workload can be renewed.
+			core: CoreIndex,
+			/// The price at which the workload can be renewed.
+			price: BalanceOf<T>,
+			/// The time at which the workload would recommence of this renewal. The call to renew
+			/// cannot happen before the beginning of the interlude prior to the sale for regions
+			/// which begin at this time.
+			begin: Timeslice,
+			/// The actual workload which can be renewed.
+			workload: Schedule,
+		},
+		/// A workload has been renewed.
+		Renewed {
+			/// The identity of the renewer.
+			who: T::AccountId,
+			/// The price paid for this renewal.
+			price: BalanceOf<T>,
+			/// The index of the core on which the `workload` was previously scheduled.
+			old_core: CoreIndex,
+			/// The index of the core on which the renewed `workload` has been scheduled.
+			core: CoreIndex,
+			/// The time at which the `workload` will begin on the `core`.
+			begin: Timeslice,
+			/// The number of timeslices for which this `workload` is newly scheduled.
+			duration: Timeslice,
+			/// The workload which was renewed.
+			workload: Schedule,
+		},
+		/// Ownership of a Region has been transferred.
+		Transferred {
+			/// The Region which has been transferred.
+			region_id: RegionId,
+			/// The duration of the Region.
+			duration: Timeslice,
+			/// The old owner of the Region.
+			old_owner: T::AccountId,
+			/// The new owner of the Region.
+			owner: T::AccountId,
+		},
+		/// A Region has been split into two non-overlapping Regions.
+		Partitioned {
+			/// The Region which was split.
+			old_region_id: RegionId,
+			/// The new Regions into which it became.
+			new_region_ids: (RegionId, RegionId),
+		},
+		/// A Region has been converted into two overlapping Regions each of lesser regularity.
+		Interlaced {
+			/// The Region which was interlaced.
+			old_region_id: RegionId,
+			/// The new Regions into which it became.
+			new_region_ids: (RegionId, RegionId),
+		},
+		/// A Region has been assigned to a particular task.
+		Assigned {
+			/// The Region which was assigned.
+			region_id: RegionId,
+			/// The duration of the assignment.
+			duration: Timeslice,
+			/// The task to which the Region was assigned.
+			task: TaskId,
+		},
+		/// A Region has been added to the Instantaneous Coretime Pool.
+		Pooled {
+			/// The Region which was added to the Instantaneous Coretime Pool.
+			region_id: RegionId,
+			/// The duration of the Region.
+			duration: Timeslice,
+		},
+		/// A new number of cores has been requested.
+		CoreCountRequested {
+			/// The number of cores requested.
+			core_count: CoreIndex,
+		},
+		/// The number of cores available for scheduling has changed.
+		CoreCountChanged {
+			/// The new number of cores available for scheduling.
+			core_count: CoreIndex,
+		},
+		/// There is a new reservation for a workload.
+		ReservationMade {
+			/// The index of the reservation.
+			index: u32,
+			/// The workload of the reservation.
+			workload: Schedule,
+		},
+		/// A reservation for a workload has been cancelled.
+		ReservationCancelled {
+			/// The index of the reservation which was cancelled.
+			index: u32,
+			/// The workload of the now cancelled reservation.
+			workload: Schedule,
+		},
+		/// A new sale has been initialized.
+		SaleInitialized {
+			/// The local block number at which the sale will/did start.
+			sale_start: BlockNumberFor<T>,
+			/// The length in blocks of the Leadin Period (where the price is decreasing).
+			leadin_length: BlockNumberFor<T>,
+			/// 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>,
+			/// 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.
+			ideal_cores_sold: CoreIndex,
+			/// Number of cores which are/have been offered for sale.
+			cores_offered: CoreIndex,
+		},
+		/// A new lease has been created.
+		Leased {
+			/// The task to which a core will be assigned.
+			task: TaskId,
+			/// The timeslice contained in the sale period after which this lease will
+			/// self-terminate (and therefore the earliest timeslice at which the lease may no
+			/// longer apply).
+			until: Timeslice,
+		},
+		/// A lease is about to end.
+		LeaseEnding {
+			/// The task to which a core was assigned.
+			task: TaskId,
+			/// The timeslice at which the task will no longer be scheduled.
+			when: Timeslice,
+		},
+		/// The sale rotation has been started and a new sale is imminent.
+		SalesStarted {
+			/// The nominal price of an Region of Bulk Coretime.
+			price: BalanceOf<T>,
+			/// The maximum number of cores which this pallet will attempt to assign.
+			core_count: CoreIndex,
+		},
+		/// The act of claiming revenue has begun.
+		RevenueClaimBegun {
+			/// The region to be claimed for.
+			region: RegionId,
+			/// The maximum number of timeslices which should be searched for claimed.
+			max_timeslices: Timeslice,
+		},
+		/// A particular timeslice has a non-zero claim.
+		RevenueClaimItem {
+			/// The timeslice whose claim is being processed.
+			when: Timeslice,
+			/// The amount which was claimed at this timeslice.
+			amount: BalanceOf<T>,
+		},
+		/// A revenue claim has (possibly only in part) been paid.
+		RevenueClaimPaid {
+			/// The account to whom revenue has been paid.
+			who: T::AccountId,
+			/// The total amount of revenue claimed and paid.
+			amount: BalanceOf<T>,
+			/// The next region which should be claimed for the continuation of this contribution.
+			next: Option<RegionId>,
+		},
+		/// Some Instantaneous Coretime Pool credit has been purchased.
+		CreditPurchased {
+			/// The account which purchased the credit.
+			who: T::AccountId,
+			/// The Relay-chain account to which the credit will be made.
+			beneficiary: RelayAccountIdOf<T>,
+			/// The amount of credit purchased.
+			amount: BalanceOf<T>,
+		},
+		/// A Region has been dropped due to being out of date.
+		RegionDropped {
+			/// The Region which no longer exists.
+			region_id: RegionId,
+			/// The duration of the Region.
+			duration: Timeslice,
+		},
+		/// Some historical Instantaneous Core Pool contribution record has been dropped.
+		ContributionDropped {
+			/// The Region whose contribution is no longer exists.
+			region_id: RegionId,
+		},
+		/// Some historical Instantaneous Core Pool payment record has been initialized.
+		HistoryInitialized {
+			/// The timeslice whose history has been initialized.
+			when: Timeslice,
+			/// The amount of privately contributed Coretime to the Instantaneous Coretime Pool.
+			private_pool_size: CoreMaskBitCount,
+			/// The amount of Coretime contributed to the Instantaneous Coretime Pool by the
+			/// Polkadot System.
+			system_pool_size: CoreMaskBitCount,
+		},
+		/// Some historical Instantaneous Core Pool payment record has been dropped.
+		HistoryDropped {
+			/// The timeslice whose history is no longer available.
+			when: Timeslice,
+			/// The amount of revenue the system has taken.
+			revenue: BalanceOf<T>,
+		},
+		/// Some historical Instantaneous Core Pool payment record has been ignored because the
+		/// timeslice was already known. Governance may need to intervene.
+		HistoryIgnored {
+			/// The timeslice whose history is was ignored.
+			when: Timeslice,
+			/// The amount of revenue which was ignored.
+			revenue: BalanceOf<T>,
+		},
+		/// Some historical Instantaneous Core Pool Revenue is ready for payout claims.
+		ClaimsReady {
+			/// The timeslice whose history is available.
+			when: Timeslice,
+			/// The amount of revenue the Polkadot System has already taken.
+			system_payout: BalanceOf<T>,
+			/// The total amount of revenue remaining to be claimed.
+			private_payout: BalanceOf<T>,
+		},
+		/// A Core has been assigned to one or more tasks and/or the Pool on the Relay-chain.
+		CoreAssigned {
+			/// The index of the Core which has been assigned.
+			core: CoreIndex,
+			/// The Relay-chain block at which this assignment should take effect.
+			when: RelayBlockNumberOf<T>,
+			/// The workload to be done on the Core.
+			assignment: Vec<(CoreAssignment, PartsOf57600)>,
+		},
+		/// Some historical Instantaneous Core Pool payment record has been dropped.
+		AllowedRenewalDropped {
+			/// The timeslice whose renewal is no longer available.
+			when: Timeslice,
+			/// The core whose workload is no longer available to be renewed for `when`.
+			core: CoreIndex,
+		},
+	}
+
+	#[pallet::error]
+	#[derive(PartialEq)]
+	pub enum Error<T> {
+		/// The given region identity is not known.
+		UnknownRegion,
+		/// The owner of the region is not the origin.
+		NotOwner,
+		/// The pivot point of the partition at or after the end of the region.
+		PivotTooLate,
+		/// The pivot point of the partition at the beginning of the region.
+		PivotTooEarly,
+		/// The pivot mask for the interlacing is not contained within the region's interlace mask.
+		ExteriorPivot,
+		/// The pivot mask for the interlacing is void (and therefore unschedulable).
+		VoidPivot,
+		/// The pivot mask for the interlacing is complete (and therefore not a strict subset).
+		CompletePivot,
+		/// The workplan of the pallet's state is invalid. This indicates a state corruption.
+		CorruptWorkplan,
+		/// There is no sale happening currently.
+		NoSales,
+		/// The price limit is exceeded.
+		Overpriced,
+		/// There are no cores available.
+		Unavailable,
+		/// The sale limit has been reached.
+		SoldOut,
+		/// The renewal operation is not valid at the current time (it may become valid in the next
+		/// sale).
+		WrongTime,
+		/// Invalid attempt to renew.
+		NotAllowed,
+		/// This pallet has not yet been initialized.
+		Uninitialized,
+		/// The purchase cannot happen yet as the sale period is yet to begin.
+		TooEarly,
+		/// There is no work to be done.
+		NothingToDo,
+		/// The maximum amount of reservations has already been reached.
+		TooManyReservations,
+		/// The maximum amount of leases has already been reached.
+		TooManyLeases,
+		/// The revenue for the Instantaneous Core Sales of this period is not (yet) known and thus
+		/// this operation cannot proceed.
+		UnknownRevenue,
+		/// The identified contribution to the Instantaneous Core Pool is unknown.
+		UnknownContribution,
+		/// The workload assigned for renewal is incomplete. This is unexpected and indicates a
+		/// logic error.
+		IncompleteAssignment,
+		/// An item cannot be dropped because it is still valid.
+		StillValid,
+		/// The history item does not exist.
+		NoHistory,
+		/// No reservation of the given index exists.
+		UnknownReservation,
+		/// The renewal record cannot be found.
+		UnknownRenewal,
+		/// The lease expiry time has already passed.
+		AlreadyExpired,
+		/// The configuration could not be applied because it is invalid.
+		InvalidConfig,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_now: BlockNumberFor<T>) -> Weight {
+			Self::do_tick()
+		}
+	}
+
+	#[pallet::call(weight(<T as Config>::WeightInfo))]
+	impl<T: Config> Pallet<T> {
+		/// Configure the pallet.
+		///
+		/// - `origin`: Must be Root or pass `AdminOrigin`.
+		/// - `config`: The configuration for this pallet.
+		#[pallet::call_index(0)]
+		pub fn configure(
+			origin: OriginFor<T>,
+			config: ConfigRecordOf<T>,
+		) -> DispatchResultWithPostInfo {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+			Self::do_configure(config)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Reserve a core for a workload.
+		///
+		/// - `origin`: Must be Root or pass `AdminOrigin`.
+		/// - `workload`: The workload which should be permanently placed on a core.
+		#[pallet::call_index(1)]
+		pub fn reserve(origin: OriginFor<T>, workload: Schedule) -> DispatchResultWithPostInfo {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+			Self::do_reserve(workload)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Cancel a reservation for a workload.
+		///
+		/// - `origin`: Must be Root or pass `AdminOrigin`.
+		/// - `item_index`: The index of the reservation. Usually this will also be the index of the
+		///   core on which the reservation has been scheduled. However, it is possible that if
+		///   other cores are reserved or unreserved in the same sale rotation that they won't
+		///   correspond, so it's better to look up the core properly in the `Reservations` storage.
+		#[pallet::call_index(2)]
+		pub fn unreserve(origin: OriginFor<T>, item_index: u32) -> DispatchResultWithPostInfo {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+			Self::do_unreserve(item_index)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Reserve a core for a single task workload for a limited period.
+		///
+		/// In the interlude and sale period where Bulk Coretime is sold for the period immediately
+		/// after `until`, then the same workload may be renewed.
+		///
+		/// - `origin`: Must be Root or pass `AdminOrigin`.
+		/// - `task`: The workload which should be placed on a core.
+		/// - `until`: The timeslice now earlier than which `task` should be placed as a workload on
+		///   a core.
+		#[pallet::call_index(3)]
+		pub fn set_lease(
+			origin: OriginFor<T>,
+			task: TaskId,
+			until: Timeslice,
+		) -> DispatchResultWithPostInfo {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+			Self::do_set_lease(task, until)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Begin the Bulk Coretime sales rotation.
+		///
+		/// - `origin`: Must be Root or pass `AdminOrigin`.
+		/// - `initial_price`: The price of Bulk Coretime in the first sale.
+		/// - `core_count`: The number of cores which can be allocated.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::start_sales((*core_count).into()))]
+		pub fn start_sales(
+			origin: OriginFor<T>,
+			initial_price: BalanceOf<T>,
+			core_count: CoreIndex,
+		) -> DispatchResultWithPostInfo {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+			Self::do_start_sales(initial_price, core_count)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Purchase Bulk Coretime in the ongoing Sale.
+		///
+		/// - `origin`: Must be a Signed origin with at least enough funds to pay the current price
+		///   of Bulk Coretime.
+		/// - `price_limit`: An amount no more than which should be paid.
+		#[pallet::call_index(5)]
+		pub fn purchase(
+			origin: OriginFor<T>,
+			price_limit: BalanceOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::do_purchase(who, price_limit)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Renew Bulk Coretime in the ongoing Sale or its prior Interlude Period.
+		///
+		/// - `origin`: Must be a Signed origin with at least enough funds to pay the renewal price
+		///   of the core.
+		/// - `core`: The core which should be renewed.
+		#[pallet::call_index(6)]
+		pub fn renew(origin: OriginFor<T>, core: CoreIndex) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::do_renew(who, core)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Transfer a Bulk Coretime Region to a new owner.
+		///
+		/// - `origin`: Must be a Signed origin of the account which owns the Region `region_id`.
+		/// - `region_id`: The Region whose ownership should change.
+		/// - `new_owner`: The new owner for the Region.
+		#[pallet::call_index(7)]
+		pub fn transfer(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+			new_owner: T::AccountId,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_transfer(region_id, Some(who), new_owner)?;
+			Ok(())
+		}
+
+		/// Split a Bulk Coretime Region into two non-overlapping Regions at a particular time into
+		/// the region.
+		///
+		/// - `origin`: Must be a Signed origin of the account which owns the Region `region_id`.
+		/// - `region_id`: The Region which should be partitioned into two non-overlapping Regions.
+		/// - `pivot`: The offset in time into the Region at which to make the split.
+		#[pallet::call_index(8)]
+		pub fn partition(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+			pivot: Timeslice,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_partition(region_id, Some(who), pivot)?;
+			Ok(())
+		}
+
+		/// Split a Bulk Coretime Region into two wholly-overlapping Regions with complementary
+		/// interlace masks which together make up the original Region's interlace mask.
+		///
+		/// - `origin`: Must be a Signed origin of the account which owns the Region `region_id`.
+		/// - `region_id`: The Region which should become two interlaced Regions of incomplete
+		///   regularity.
+		/// - `pivot`: The interlace mask of on of the two new regions (the other it its partial
+		///   complement).
+		#[pallet::call_index(9)]
+		pub fn interlace(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+			pivot: CoreMask,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_interlace(region_id, Some(who), pivot)?;
+			Ok(())
+		}
+
+		/// Assign a Bulk Coretime Region to a task.
+		///
+		/// - `origin`: Must be a Signed origin of the account which owns the Region `region_id`.
+		/// - `region_id`: The Region which should be assigned to the task.
+		/// - `task`: The task to assign.
+		/// - `finality`: Indication of whether this assignment is final (in which case it may be
+		///   eligible for renewal) or provisional (in which case it may be manipulated and/or
+		/// reassigned at a later stage).
+		#[pallet::call_index(10)]
+		pub fn assign(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+			task: TaskId,
+			finality: Finality,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::do_assign(region_id, Some(who), task, finality)?;
+			Ok(if finality == Finality::Final { Pays::No } else { Pays::Yes }.into())
+		}
+
+		/// Place a Bulk Coretime Region into the Instantaneous Coretime Pool.
+		///
+		/// - `origin`: Must be a Signed origin of the account which owns the Region `region_id`.
+		/// - `region_id`: The Region which should be assigned to the Pool.
+		/// - `payee`: The account which is able to collect any revenue due for the usage of this
+		///   Coretime.
+		#[pallet::call_index(11)]
+		pub fn pool(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+			payee: T::AccountId,
+			finality: Finality,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::do_pool(region_id, Some(who), payee, finality)?;
+			Ok(if finality == Finality::Final { Pays::No } else { Pays::Yes }.into())
+		}
+
+		/// Claim the revenue owed from inclusion in the Instantaneous Coretime Pool.
+		///
+		/// - `origin`: Must be a Signed origin of the account which owns the Region `region_id`.
+		/// - `region_id`: The Region which was assigned to the Pool.
+		/// - `max_timeslices`: The maximum number of timeslices which should be processed. This may
+		///   effect the weight of the call but should be ideally made equivalant to the length of
+		///   the Region `region_id`. If it is less than this, then further dispatches will be
+		///   required with the `region_id` which makes up any remainders of the region to be
+		///   collected.
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::claim_revenue(*max_timeslices))]
+		pub fn claim_revenue(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+			max_timeslices: Timeslice,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			Self::do_claim_revenue(region_id, max_timeslices)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Purchase credit for use in the Instantaneous Coretime Pool.
+		///
+		/// - `origin`: Must be a Signed origin able to pay at least `amount`.
+		/// - `amount`: The amount of credit to purchase.
+		/// - `beneficiary`: The account on the Relay-chain which controls the credit (generally
+		///   this will be the collator's hot wallet).
+		#[pallet::call_index(13)]
+		pub fn purchase_credit(
+			origin: OriginFor<T>,
+			amount: BalanceOf<T>,
+			beneficiary: RelayAccountIdOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_purchase_credit(who, amount, beneficiary)?;
+			Ok(())
+		}
+
+		/// Drop an expired Region from the chain.
+		///
+		/// - `origin`: Must be a Signed origin.
+		/// - `region_id`: The Region which has expired.
+		#[pallet::call_index(14)]
+		pub fn drop_region(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			Self::do_drop_region(region_id)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Drop an expired Instantaneous Pool Contribution record from the chain.
+		///
+		/// - `origin`: Must be a Signed origin.
+		/// - `region_id`: The Region identifying the Pool Contribution which has expired.
+		#[pallet::call_index(15)]
+		pub fn drop_contribution(
+			origin: OriginFor<T>,
+			region_id: RegionId,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			Self::do_drop_contribution(region_id)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Drop an expired Instantaneous Pool History record from the chain.
+		///
+		/// - `origin`: Must be a Signed origin.
+		/// - `region_id`: The time of the Pool History record which has expired.
+		#[pallet::call_index(16)]
+		pub fn drop_history(origin: OriginFor<T>, when: Timeslice) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			Self::do_drop_history(when)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Drop an expired Allowed Renewal record from the chain.
+		///
+		/// - `origin`: Must be a Signed origin of the account which owns the Region `region_id`.
+		/// - `core`: The core to which the expired renewal refers.
+		/// - `when`: The timeslice to which the expired renewal refers. This must have passed.
+		#[pallet::call_index(17)]
+		pub fn drop_renewal(
+			origin: OriginFor<T>,
+			core: CoreIndex,
+			when: Timeslice,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			Self::do_drop_renewal(core, when)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Request a change to the number of cores available for scheduling work.
+		///
+		/// - `origin`: Must be Root or pass `AdminOrigin`.
+		/// - `core_count`: The desired number of cores to be made available.
+		#[pallet::call_index(18)]
+		#[pallet::weight(T::WeightInfo::request_core_count((*core_count).into()))]
+		pub fn request_core_count(origin: OriginFor<T>, core_count: CoreIndex) -> DispatchResult {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+			Self::do_request_core_count(core_count)?;
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/broker/src/mock.rs b/substrate/frame/broker/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cab6b7389c06494a0bcddb4d8d02f8f734f67b8c
--- /dev/null
+++ b/substrate/frame/broker/src/mock.rs
@@ -0,0 +1,322 @@
+// 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)]
+
+use crate::{test_fungibles::TestFungibles, *};
+use frame_support::{
+	assert_ok, ensure, ord_parameter_types, parameter_types,
+	traits::{
+		fungible::{Balanced, Credit, Inspect, ItemOf, Mutate},
+		nonfungible::Inspect as NftInspect,
+		EitherOfDiverse, Hooks, OnUnbalanced,
+	},
+	PalletId,
+};
+use frame_system::{EnsureRoot, EnsureSignedBy};
+use sp_arithmetic::Perbill;
+use sp_core::{ConstU16, ConstU32, ConstU64, H256};
+use sp_runtime::{
+	traits::{BlakeTwo256, Identity, IdentityLookup},
+	BuildStorage, Saturating,
+};
+use sp_std::collections::btree_map::BTreeMap;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// Configure a mock runtime to test the pallet.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Broker: crate,
+	}
+);
+
+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>;
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub enum CoretimeTraceItem {
+	AssignCore {
+		core: CoreIndex,
+		begin: u32,
+		assignment: Vec<(CoreAssignment, PartsOf57600)>,
+		end_hint: Option<u32>,
+	},
+}
+use CoretimeTraceItem::*;
+
+parameter_types! {
+	pub static CoretimeTrace: Vec<(u32, CoretimeTraceItem)> = Default::default();
+	pub static CoretimeCredit: BTreeMap<u64, u64> = Default::default();
+	pub static CoretimeSpending: Vec<(u32, u64)> = Default::default();
+	pub static CoretimeWorkplan: BTreeMap<(u32, CoreIndex), Vec<(CoreAssignment, PartsOf57600)>> = Default::default();
+	pub static CoretimeUsage: BTreeMap<CoreIndex, Vec<(CoreAssignment, PartsOf57600)>> = Default::default();
+	pub static CoretimeInPool: CoreMaskBitCount = 0;
+	pub static NotifyCoreCount: Vec<u16> = Default::default();
+	pub static NotifyRevenueInfo: Vec<(u32, u64)> = Default::default();
+}
+
+pub struct TestCoretimeProvider;
+impl CoretimeInterface for TestCoretimeProvider {
+	type AccountId = u64;
+	type Balance = u64;
+	type BlockNumber = u32;
+	fn latest() -> Self::BlockNumber {
+		System::block_number() as u32
+	}
+	fn request_core_count(count: CoreIndex) {
+		NotifyCoreCount::mutate(|s| s.insert(0, count));
+	}
+	fn request_revenue_info_at(when: Self::BlockNumber) {
+		if when > Self::latest() {
+			panic!("Asking for revenue info in the future {:?} {:?}", when, Self::latest());
+		}
+
+		let mut total = 0;
+		CoretimeSpending::mutate(|s| {
+			s.retain(|(n, a)| {
+				if *n < when {
+					total += a;
+					false
+				} else {
+					true
+				}
+			})
+		});
+		NotifyRevenueInfo::mutate(|s| s.insert(0, (when, total)));
+	}
+	fn credit_account(who: Self::AccountId, amount: Self::Balance) {
+		CoretimeCredit::mutate(|c| c.entry(who).or_default().saturating_accrue(amount));
+	}
+	fn assign_core(
+		core: CoreIndex,
+		begin: Self::BlockNumber,
+		assignment: Vec<(CoreAssignment, PartsOf57600)>,
+		end_hint: Option<Self::BlockNumber>,
+	) {
+		CoretimeWorkplan::mutate(|p| p.insert((begin, core), assignment.clone()));
+		let item = (Self::latest(), AssignCore { core, begin, assignment, end_hint });
+		CoretimeTrace::mutate(|v| v.push(item));
+	}
+	fn check_notify_core_count() -> Option<u16> {
+		NotifyCoreCount::mutate(|s| s.pop())
+	}
+	fn check_notify_revenue_info() -> Option<(Self::BlockNumber, Self::Balance)> {
+		NotifyRevenueInfo::mutate(|s| s.pop())
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_core_count(count: u16) {
+		NotifyCoreCount::mutate(|s| s.insert(0, count));
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_notify_revenue_info(when: Self::BlockNumber, revenue: Self::Balance) {
+		NotifyRevenueInfo::mutate(|s| s.push((when, revenue)));
+	}
+}
+impl TestCoretimeProvider {
+	pub fn spend_instantaneous(who: u64, price: u64) -> Result<(), ()> {
+		let mut c = CoretimeCredit::get();
+		ensure!(CoretimeInPool::get() > 0, ());
+		c.insert(who, c.get(&who).ok_or(())?.checked_sub(price).ok_or(())?);
+		CoretimeCredit::set(c);
+		CoretimeSpending::mutate(|v| v.push((Self::latest(), price)));
+		Ok(())
+	}
+	pub fn bump() {
+		let mut pool_size = CoretimeInPool::get();
+		let mut workplan = CoretimeWorkplan::get();
+		let mut usage = CoretimeUsage::get();
+		let now = Self::latest();
+		workplan.retain(|(when, core), assignment| {
+			if *when <= now {
+				if let Some(old_assignment) = usage.get(core) {
+					if let Some(a) = old_assignment.iter().find(|i| i.0 == CoreAssignment::Pool) {
+						pool_size -= (a.1 / 720) as CoreMaskBitCount;
+					}
+				}
+				if let Some(a) = assignment.iter().find(|i| i.0 == CoreAssignment::Pool) {
+					pool_size += (a.1 / 720) as CoreMaskBitCount;
+				}
+				usage.insert(*core, assignment.clone());
+				false
+			} else {
+				true
+			}
+		});
+		CoretimeInPool::set(pool_size);
+		CoretimeWorkplan::set(workplan);
+		CoretimeUsage::set(usage);
+	}
+}
+
+parameter_types! {
+	pub const TestBrokerId: PalletId = PalletId(*b"TsBroker");
+}
+
+pub struct IntoZero;
+impl OnUnbalanced<Credit<u64, <Test as Config>::Currency>> for IntoZero {
+	fn on_nonzero_unbalanced(credit: Credit<u64, <Test as Config>::Currency>) {
+		let _ = <<Test as Config>::Currency as Balanced<_>>::resolve(&0, credit);
+	}
+}
+
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+type EnsureOneOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<One, u64>>;
+
+impl crate::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = ItemOf<TestFungibles<(), u64, (), ConstU64<0>, ()>, (), u64>;
+	type OnRevenue = IntoZero;
+	type TimeslicePeriod = ConstU32<2>;
+	type MaxLeasedCores = ConstU32<5>;
+	type MaxReservedCores = ConstU32<5>;
+	type Coretime = TestCoretimeProvider;
+	type ConvertBalance = Identity;
+	type WeightInfo = ();
+	type PalletId = TestBrokerId;
+	type AdminOrigin = EnsureOneOrRoot;
+	type PriceAdapter = Linear;
+}
+
+pub fn advance_to(b: u64) {
+	while System::block_number() < b {
+		System::set_block_number(System::block_number() + 1);
+		TestCoretimeProvider::bump();
+		Broker::on_initialize(System::block_number());
+	}
+}
+
+pub fn pot() -> u64 {
+	balance(Broker::account_id())
+}
+
+pub fn revenue() -> u64 {
+	balance(0)
+}
+
+pub fn balance(who: u64) -> u64 {
+	<<Test as Config>::Currency as Inspect<_>>::total_balance(&who)
+}
+
+pub fn attribute<T: codec::Decode>(nft: RegionId, attribute: impl codec::Encode) -> T {
+	<Broker as NftInspect<_>>::typed_attribute::<_, T>(&nft.into(), &attribute).unwrap()
+}
+
+pub fn new_config() -> ConfigRecordOf<Test> {
+	ConfigRecord {
+		advance_notice: 2,
+		interlude_length: 1,
+		leadin_length: 1,
+		ideal_bulk_proportion: Default::default(),
+		limit_cores_offered: None,
+		region_length: 3,
+		renewal_bump: Perbill::from_percent(10),
+		contribution_timeout: 5,
+	}
+}
+
+pub struct TestExt(ConfigRecordOf<Test>);
+#[allow(dead_code)]
+impl TestExt {
+	pub fn new() -> Self {
+		Self(new_config())
+	}
+
+	pub fn advance_notice(mut self, advance_notice: Timeslice) -> Self {
+		self.0.advance_notice = advance_notice;
+		self
+	}
+
+	pub fn interlude_length(mut self, interlude_length: u64) -> Self {
+		self.0.interlude_length = interlude_length;
+		self
+	}
+
+	pub fn leadin_length(mut self, leadin_length: u64) -> Self {
+		self.0.leadin_length = leadin_length;
+		self
+	}
+
+	pub fn region_length(mut self, region_length: Timeslice) -> Self {
+		self.0.region_length = region_length;
+		self
+	}
+
+	pub fn ideal_bulk_proportion(mut self, ideal_bulk_proportion: Perbill) -> Self {
+		self.0.ideal_bulk_proportion = ideal_bulk_proportion;
+		self
+	}
+
+	pub fn limit_cores_offered(mut self, limit_cores_offered: Option<CoreIndex>) -> Self {
+		self.0.limit_cores_offered = limit_cores_offered;
+		self
+	}
+
+	pub fn renewal_bump(mut self, renewal_bump: Perbill) -> Self {
+		self.0.renewal_bump = renewal_bump;
+		self
+	}
+
+	pub fn contribution_timeout(mut self, contribution_timeout: Timeslice) -> Self {
+		self.0.contribution_timeout = contribution_timeout;
+		self
+	}
+
+	pub fn endow(self, who: u64, amount: u64) -> Self {
+		assert_ok!(<<Test as Config>::Currency as Mutate<_>>::mint_into(&who, amount));
+		self
+	}
+
+	pub fn execute_with<R>(self, f: impl Fn() -> R) -> R {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Broker::do_configure(self.0));
+			f()
+		})
+	}
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let c = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	sp_io::TestExternalities::from(c)
+}
diff --git a/substrate/frame/broker/src/nonfungible_impl.rs b/substrate/frame/broker/src/nonfungible_impl.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe95438cb1afa0eaae8a409352ebc2855739435c
--- /dev/null
+++ b/substrate/frame/broker/src/nonfungible_impl.rs
@@ -0,0 +1,52 @@
+// 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::{
+	pallet_prelude::{DispatchResult, *},
+	traits::nonfungible::{Inspect, Transfer},
+};
+use sp_std::vec::Vec;
+
+impl<T: Config> Inspect<T::AccountId> for Pallet<T> {
+	type ItemId = u128;
+
+	fn owner(index: &Self::ItemId) -> Option<T::AccountId> {
+		Regions::<T>::get(RegionId::from(*index)).map(|r| r.owner)
+	}
+
+	fn attribute(index: &Self::ItemId, key: &[u8]) -> Option<Vec<u8>> {
+		let id = RegionId::from(*index);
+		let item = Regions::<T>::get(id)?;
+		match key {
+			b"begin" => Some(id.begin.encode()),
+			b"end" => Some(item.end.encode()),
+			b"length" => Some(item.end.saturating_sub(id.begin).encode()),
+			b"core" => Some(id.core.encode()),
+			b"part" => Some(id.mask.encode()),
+			b"owner" => Some(item.owner.encode()),
+			b"paid" => Some(item.paid.encode()),
+			_ => None,
+		}
+	}
+}
+
+impl<T: Config> Transfer<T::AccountId> for Pallet<T> {
+	fn transfer(index: &Self::ItemId, dest: &T::AccountId) -> DispatchResult {
+		Self::do_transfer((*index).into(), None, dest.clone()).map_err(Into::into)
+	}
+}
diff --git a/substrate/frame/broker/src/test_fungibles.rs b/substrate/frame/broker/src/test_fungibles.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f6ac5a49dedd28060dae9c4802fcb2842054051e
--- /dev/null
+++ b/substrate/frame/broker/src/test_fungibles.rs
@@ -0,0 +1,283 @@
+// 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 codec::{Decode, Encode};
+use frame_support::{
+	parameter_types,
+	traits::{
+		fungibles::{self, Dust},
+		tokens::{
+			self, DepositConsequence, Fortitude, Preservation, Provenance, WithdrawConsequence,
+		},
+	},
+};
+use scale_info::TypeInfo;
+use sp_arithmetic::traits::Zero;
+use sp_core::{Get, TypedGet};
+use sp_runtime::{DispatchError, DispatchResult};
+use sp_std::collections::btree_map::BTreeMap;
+
+parameter_types! {
+	static TestAssetOf: BTreeMap<(u32, Vec<u8>), Vec<u8>> = Default::default();
+	static TestBalanceOf: BTreeMap<(u32, Vec<u8>, Vec<u8>), Vec<u8>> = Default::default();
+	static TestHoldOf: BTreeMap<(u32, Vec<u8>, Vec<u8>, Vec<u8>), Vec<u8>> = Default::default();
+}
+
+pub struct TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>(
+	core::marker::PhantomData<(Instance, AccountId, AssetId, MinimumBalance, HoldReason)>,
+);
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason,
+	> fungibles::Inspect<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+	type AssetId = AssetId;
+	type Balance = MinimumBalance::Type;
+
+	fn total_issuance(asset: Self::AssetId) -> Self::Balance {
+		TestAssetOf::get()
+			.get(&(Instance::get(), asset.encode()))
+			.and_then(|data| Decode::decode(&mut &data[..]).ok())
+			.unwrap_or_default()
+	}
+
+	fn active_issuance(asset: Self::AssetId) -> Self::Balance {
+		Self::total_issuance(asset)
+	}
+
+	/// The minimum balance any single account may have.
+	fn minimum_balance(_asset: Self::AssetId) -> Self::Balance {
+		MinimumBalance::get()
+	}
+
+	fn total_balance(asset: Self::AssetId, who: &AccountId) -> Self::Balance {
+		TestBalanceOf::get()
+			.get(&(Instance::get(), asset.encode(), who.encode()))
+			.and_then(|data| Decode::decode(&mut &data[..]).ok())
+			.unwrap_or_default()
+	}
+
+	fn balance(asset: Self::AssetId, who: &AccountId) -> Self::Balance {
+		Self::total_balance(asset, who)
+	}
+
+	fn reducible_balance(
+		asset: Self::AssetId,
+		who: &AccountId,
+		_preservation: Preservation,
+		_force: Fortitude,
+	) -> Self::Balance {
+		Self::total_balance(asset, who)
+	}
+
+	fn can_deposit(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+		_provenance: Provenance,
+	) -> DepositConsequence {
+		if !Self::asset_exists(asset) {
+			return DepositConsequence::UnknownAsset
+		}
+		if amount + Self::balance(asset, who) < Self::minimum_balance(asset) {
+			return DepositConsequence::BelowMinimum
+		}
+		DepositConsequence::Success
+	}
+
+	fn can_withdraw(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance> {
+		if Self::reducible_balance(asset, who, Preservation::Expendable, Fortitude::Polite) < amount
+		{
+			return WithdrawConsequence::BalanceLow
+		}
+		if Self::total_balance(asset, who) < Self::minimum_balance(asset) + amount {
+			return WithdrawConsequence::WouldDie
+		}
+		WithdrawConsequence::Success
+	}
+
+	fn asset_exists(asset: Self::AssetId) -> bool {
+		TestAssetOf::get().contains_key(&(Instance::get(), asset.encode()))
+	}
+}
+
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason,
+	> fungibles::Unbalanced<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+	fn handle_dust(_dust: Dust<AccountId, Self>) {}
+
+	fn write_balance(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> Result<Option<Self::Balance>, DispatchError> {
+		let mut tb = TestBalanceOf::get();
+		let maybe_dust = if amount < MinimumBalance::get() {
+			tb.remove(&(Instance::get(), asset.encode(), who.encode()));
+			if amount.is_zero() {
+				None
+			} else {
+				Some(amount)
+			}
+		} else {
+			tb.insert((Instance::get(), asset.encode(), who.encode()), amount.encode());
+			None
+		};
+		TestBalanceOf::set(tb);
+		Ok(maybe_dust)
+	}
+
+	fn set_total_issuance(asset: Self::AssetId, amount: Self::Balance) {
+		let mut ta = TestAssetOf::get();
+		ta.insert((Instance::get(), asset.encode()), amount.encode());
+		TestAssetOf::set(ta);
+	}
+}
+
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason,
+	> fungibles::Mutate<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+}
+
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason,
+	> fungibles::Balanced<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+	type OnDropCredit = fungibles::DecreaseIssuance<AccountId, Self>;
+	type OnDropDebt = fungibles::IncreaseIssuance<AccountId, Self>;
+}
+
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason: Encode + Decode + TypeInfo + 'static,
+	> fungibles::InspectHold<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+	type Reason = HoldReason;
+
+	fn total_balance_on_hold(asset: Self::AssetId, who: &AccountId) -> Self::Balance {
+		let asset = asset.encode();
+		let who = who.encode();
+		TestHoldOf::get()
+			.iter()
+			.filter(|(k, _)| k.0 == Instance::get() && k.1 == asset && k.2 == who)
+			.filter_map(|(_, b)| Self::Balance::decode(&mut &b[..]).ok())
+			.fold(Zero::zero(), |a, i| a + i)
+	}
+
+	fn balance_on_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+	) -> Self::Balance {
+		TestHoldOf::get()
+			.get(&(Instance::get(), asset.encode(), who.encode(), reason.encode()))
+			.and_then(|data| Decode::decode(&mut &data[..]).ok())
+			.unwrap_or_default()
+	}
+}
+
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason: Encode + Decode + TypeInfo + 'static,
+	> fungibles::UnbalancedHold<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+	fn set_balance_on_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult {
+		let mut th = TestHoldOf::get();
+		th.insert(
+			(Instance::get(), asset.encode(), who.encode(), reason.encode()),
+			amount.encode(),
+		);
+		TestHoldOf::set(th);
+		Ok(())
+	}
+}
+
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason: Encode + Decode + TypeInfo + 'static,
+	> fungibles::MutateHold<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+}
+
+impl<
+		Instance: Get<u32>,
+		AccountId: Encode,
+		AssetId: tokens::AssetId + Copy,
+		MinimumBalance: TypedGet,
+		HoldReason: Encode + Decode + TypeInfo + 'static,
+	> fungibles::BalancedHold<AccountId>
+	for TestFungibles<Instance, AccountId, AssetId, MinimumBalance, HoldReason>
+where
+	MinimumBalance::Type: tokens::Balance,
+{
+}
diff --git a/substrate/frame/broker/src/tests.rs b/substrate/frame/broker/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3c326010dddfc7a01396064af1e5f706ed085ce1
--- /dev/null
+++ b/substrate/frame/broker/src/tests.rs
@@ -0,0 +1,896 @@
+// 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)]
+
+use crate::{core_mask::*, mock::*, *};
+use frame_support::{
+	assert_noop, assert_ok,
+	traits::nonfungible::{Inspect as NftInspect, Transfer},
+	BoundedVec,
+};
+use frame_system::RawOrigin::Root;
+use sp_runtime::traits::Get;
+use CoreAssignment::*;
+use CoretimeTraceItem::*;
+use Finality::*;
+
+#[test]
+fn basic_initialize_works() {
+	TestExt::new().execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		assert_eq!(CoretimeTrace::get(), vec![]);
+		assert_eq!(Broker::current_timeslice(), 0);
+	});
+}
+
+#[test]
+fn drop_region_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_ok!(Broker::do_assign(region, Some(1), 1001, Provisional));
+		advance_to(11);
+		assert_noop!(Broker::do_drop_region(region), Error::<Test>::StillValid);
+		advance_to(12);
+		// assignment worked.
+		let just_1001 = vec![(Task(1001), 57600)];
+		let just_pool = vec![(Pool, 57600)];
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(6, AssignCore { core: 0, begin: 8, assignment: just_1001, end_hint: None }),
+				(12, AssignCore { core: 0, begin: 14, assignment: just_pool, end_hint: None }),
+			]
+		);
+		// `region` still exists as it was never finalized.
+		assert_eq!(Regions::<Test>::iter().count(), 1);
+		assert_ok!(Broker::do_drop_region(region));
+		assert_eq!(Regions::<Test>::iter().count(), 0);
+		assert_noop!(Broker::do_drop_region(region), Error::<Test>::UnknownRegion);
+	});
+}
+
+#[test]
+fn drop_renewal_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_ok!(Broker::do_assign(region, Some(1), 1001, Final));
+		advance_to(11);
+		let e = Error::<Test>::StillValid;
+		assert_noop!(Broker::do_drop_renewal(region.core, region.begin + 3), e);
+		advance_to(12);
+		assert_ok!(Broker::do_drop_renewal(region.core, region.begin + 3));
+		let e = Error::<Test>::UnknownRenewal;
+		assert_noop!(Broker::do_drop_renewal(region.core, region.begin + 3), e);
+	});
+}
+
+#[test]
+fn drop_contribution_works() {
+	TestExt::new().contribution_timeout(3).endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		// Place region in pool. Active in pool timeslices 4, 5, 6 = rcblocks 8, 10, 12; we
+		// expect the contribution record to timeout 3 timeslices following 7 = 10
+		assert_ok!(Broker::do_pool(region, Some(1), 1, Final));
+		assert_eq!(InstaPoolContribution::<Test>::iter().count(), 1);
+		advance_to(19);
+		assert_noop!(Broker::do_drop_contribution(region), Error::<Test>::StillValid);
+		advance_to(20);
+		assert_ok!(Broker::do_drop_contribution(region));
+		assert_eq!(InstaPoolContribution::<Test>::iter().count(), 0);
+		assert_noop!(Broker::do_drop_contribution(region), Error::<Test>::UnknownContribution);
+	});
+}
+
+#[test]
+fn drop_history_works() {
+	TestExt::new()
+		.contribution_timeout(4)
+		.endow(1, 1000)
+		.endow(2, 30)
+		.execute_with(|| {
+			assert_ok!(Broker::do_start_sales(100, 1));
+			advance_to(2);
+			let mut region = Broker::do_purchase(1, u64::max_value()).unwrap();
+			// Place region in pool. Active in pool timeslices 4, 5, 6 = rcblocks 8, 10, 12; we
+			// expect to make/receive revenue reports on blocks 10, 12, 14.
+			assert_ok!(Broker::do_pool(region, Some(1), 1, Final));
+			assert_ok!(Broker::do_purchase_credit(2, 30, 2));
+			advance_to(6);
+			// In the stable state with no pending payouts, we expect to see 3 items in
+			// InstaPoolHistory here since there is a latency of 1 timeslice (for generating the
+			// revenue report), the forward notice period (equivalent to another timeslice) and a
+			// block between the revenue report being requested and the response being processed.
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 3);
+			advance_to(7);
+			// One block later, the most recent report will have been processed, so the effective
+			// queue drops to 2 items.
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 2);
+			advance_to(8);
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 3);
+			assert_ok!(TestCoretimeProvider::spend_instantaneous(2, 10));
+			advance_to(10);
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 3);
+			assert_ok!(TestCoretimeProvider::spend_instantaneous(2, 10));
+			advance_to(12);
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 4);
+			assert_ok!(TestCoretimeProvider::spend_instantaneous(2, 10));
+			advance_to(14);
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 5);
+			advance_to(16);
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 6);
+			advance_to(17);
+			assert_noop!(Broker::do_drop_history(region.begin), Error::<Test>::StillValid);
+			advance_to(18);
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 6);
+			// Block 18 is 8 blocks ()= 4 timeslices = contribution timeout) after first region.
+			// Its revenue should now be droppable.
+			assert_ok!(Broker::do_drop_history(region.begin));
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 5);
+			assert_noop!(Broker::do_drop_history(region.begin), Error::<Test>::NoHistory);
+			advance_to(19);
+			region.begin += 1;
+			assert_noop!(Broker::do_drop_history(region.begin), Error::<Test>::StillValid);
+			advance_to(20);
+			assert_ok!(Broker::do_drop_history(region.begin));
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 4);
+			assert_noop!(Broker::do_drop_history(region.begin), Error::<Test>::NoHistory);
+			advance_to(21);
+			region.begin += 1;
+			assert_noop!(Broker::do_drop_history(region.begin), Error::<Test>::StillValid);
+			advance_to(22);
+			assert_ok!(Broker::do_drop_history(region.begin));
+			assert_eq!(InstaPoolHistory::<Test>::iter().count(), 3);
+			assert_noop!(Broker::do_drop_history(region.begin), Error::<Test>::NoHistory);
+		});
+}
+
+#[test]
+fn request_core_count_works() {
+	TestExt::new().execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 0));
+		assert_ok!(Broker::request_core_count(RuntimeOrigin::root(), 1));
+		advance_to(12);
+		let assignment = vec![(Pool, 57600)];
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![(12, AssignCore { core: 0, begin: 14, assignment, end_hint: None })],
+		);
+	});
+}
+
+#[test]
+fn transfer_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_ok!(<Broker as Transfer<_>>::transfer(&region.into(), &2));
+		assert_eq!(<Broker as NftInspect<_>>::owner(&region.into()), Some(2));
+		assert_noop!(Broker::do_assign(region, Some(1), 1001, Final), Error::<Test>::NotOwner);
+		assert_ok!(Broker::do_assign(region, Some(2), 1002, Final));
+	});
+}
+
+#[test]
+fn permanent_is_not_reassignable() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_ok!(Broker::do_assign(region, Some(1), 1001, Final));
+		assert_noop!(Broker::do_assign(region, Some(1), 1002, Final), Error::<Test>::UnknownRegion);
+		assert_noop!(Broker::do_pool(region, Some(1), 1002, Final), Error::<Test>::UnknownRegion);
+		assert_noop!(Broker::do_partition(region, Some(1), 1), Error::<Test>::UnknownRegion);
+		assert_noop!(
+			Broker::do_interlace(region, Some(1), CoreMask::from_chunk(0, 40)),
+			Error::<Test>::UnknownRegion
+		);
+	});
+}
+
+#[test]
+fn provisional_is_reassignable() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_ok!(Broker::do_assign(region, Some(1), 1001, Provisional));
+		let (region1, region) = Broker::do_partition(region, Some(1), 1).unwrap();
+		let (region2, region3) =
+			Broker::do_interlace(region, Some(1), CoreMask::from_chunk(0, 40)).unwrap();
+		assert_ok!(Broker::do_pool(region1, Some(1), 1, Provisional));
+		assert_ok!(Broker::do_assign(region2, Some(1), 1002, Provisional));
+		assert_ok!(Broker::do_assign(region3, Some(1), 1003, Provisional));
+		advance_to(8);
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(
+					6,
+					AssignCore {
+						core: 0,
+						begin: 8,
+						assignment: vec![(Pool, 57600),],
+						end_hint: None
+					}
+				),
+				(
+					8,
+					AssignCore {
+						core: 0,
+						begin: 10,
+						assignment: vec![(Task(1002), 28800), (Task(1003), 28800),],
+						end_hint: None
+					}
+				),
+			]
+		);
+	});
+}
+
+#[test]
+fn nft_metadata_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_eq!(attribute::<Timeslice>(region, b"begin"), 4);
+		assert_eq!(attribute::<Timeslice>(region, b"length"), 3);
+		assert_eq!(attribute::<Timeslice>(region, b"end"), 7);
+		assert_eq!(attribute::<u64>(region, b"owner"), 1);
+		assert_eq!(attribute::<CoreMask>(region, b"part"), 0xfffff_fffff_fffff_fffff.into());
+		assert_eq!(attribute::<CoreIndex>(region, b"core"), 0);
+		assert_eq!(attribute::<Option<u64>>(region, b"paid"), Some(100));
+
+		assert_ok!(Broker::do_transfer(region, None, 42));
+		let (_, region) = Broker::do_partition(region, None, 2).unwrap();
+		let (region, _) =
+			Broker::do_interlace(region, None, 0x00000_fffff_fffff_00000.into()).unwrap();
+		assert_eq!(attribute::<Timeslice>(region, b"begin"), 6);
+		assert_eq!(attribute::<Timeslice>(region, b"length"), 1);
+		assert_eq!(attribute::<Timeslice>(region, b"end"), 7);
+		assert_eq!(attribute::<u64>(region, b"owner"), 42);
+		assert_eq!(attribute::<CoreMask>(region, b"part"), 0x00000_fffff_fffff_00000.into());
+		assert_eq!(attribute::<CoreIndex>(region, b"core"), 0);
+		assert_eq!(attribute::<Option<u64>>(region, b"paid"), None);
+	});
+}
+
+#[test]
+fn migration_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_set_lease(1000, 8));
+		assert_ok!(Broker::do_start_sales(100, 2));
+
+		// Sale is for regions from TS4..7
+		// Not ending in this sale period.
+		assert_noop!(Broker::do_renew(1, 0), Error::<Test>::NotAllowed);
+
+		advance_to(12);
+		// Sale is now for regions from TS10..13
+		// Ending in this sale period.
+		// Should now be renewable.
+		assert_ok!(Broker::do_renew(1, 0));
+		assert_eq!(balance(1), 900);
+		advance_to(18);
+
+		let just_pool = || vec![(Pool, 57600)];
+		let just_1000 = || vec![(Task(1000), 57600)];
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(6, AssignCore { core: 0, begin: 8, assignment: just_1000(), end_hint: None }),
+				(6, AssignCore { core: 1, begin: 8, assignment: just_pool(), end_hint: None }),
+				(12, AssignCore { core: 0, begin: 14, assignment: just_1000(), end_hint: None }),
+				(12, AssignCore { core: 1, begin: 14, assignment: just_pool(), end_hint: None }),
+				(18, AssignCore { core: 0, begin: 20, assignment: just_1000(), end_hint: None }),
+				(18, AssignCore { core: 1, begin: 20, assignment: just_pool(), end_hint: None }),
+			]
+		);
+	});
+}
+
+#[test]
+fn renewal_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		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_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);
+		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);
+	});
+}
+
+#[test]
+fn instapool_payouts_work() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		let item = ScheduleItem { assignment: Pool, mask: CoreMask::complete() };
+		assert_ok!(Broker::do_reserve(Schedule::truncate_from(vec![item])));
+		assert_ok!(Broker::do_start_sales(100, 3));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_ok!(Broker::do_pool(region, None, 2, Final));
+		assert_ok!(Broker::do_purchase_credit(1, 20, 1));
+		advance_to(8);
+		assert_ok!(TestCoretimeProvider::spend_instantaneous(1, 10));
+		advance_to(11);
+		assert_eq!(pot(), 14);
+		assert_eq!(revenue(), 106);
+		assert_ok!(Broker::do_claim_revenue(region, 100));
+		assert_eq!(pot(), 10);
+		assert_eq!(balance(2), 4);
+	});
+}
+
+#[test]
+fn instapool_partial_core_payouts_work() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		let item = ScheduleItem { assignment: Pool, mask: CoreMask::complete() };
+		assert_ok!(Broker::do_reserve(Schedule::truncate_from(vec![item])));
+		assert_ok!(Broker::do_start_sales(100, 2));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		let (region1, region2) =
+			Broker::do_interlace(region, None, CoreMask::from_chunk(0, 20)).unwrap();
+		assert_ok!(Broker::do_pool(region1, None, 2, Final));
+		assert_ok!(Broker::do_pool(region2, None, 3, Final));
+		assert_ok!(Broker::do_purchase_credit(1, 40, 1));
+		advance_to(8);
+		assert_ok!(TestCoretimeProvider::spend_instantaneous(1, 40));
+		advance_to(11);
+		assert_ok!(Broker::do_claim_revenue(region1, 100));
+		assert_ok!(Broker::do_claim_revenue(region2, 100));
+		assert_eq!(revenue(), 120);
+		assert_eq!(balance(2), 5);
+		assert_eq!(balance(3), 15);
+		assert_eq!(pot(), 0);
+	});
+}
+
+#[test]
+fn initialize_with_system_paras_works() {
+	TestExt::new().execute_with(|| {
+		let item = ScheduleItem { assignment: Task(1u32), mask: CoreMask::complete() };
+		assert_ok!(Broker::do_reserve(Schedule::truncate_from(vec![item])));
+		let items = vec![
+			ScheduleItem { assignment: Task(2u32), mask: 0xfffff_fffff_00000_00000.into() },
+			ScheduleItem { assignment: Task(3u32), mask: 0x00000_00000_fffff_00000.into() },
+			ScheduleItem { assignment: Task(4u32), mask: 0x00000_00000_00000_fffff.into() },
+		];
+		assert_ok!(Broker::do_reserve(Schedule::truncate_from(items)));
+		assert_ok!(Broker::do_start_sales(100, 2));
+		advance_to(10);
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(
+					6,
+					AssignCore {
+						core: 0,
+						begin: 8,
+						assignment: vec![(Task(1), 57600),],
+						end_hint: None
+					}
+				),
+				(
+					6,
+					AssignCore {
+						core: 1,
+						begin: 8,
+						assignment: vec![(Task(2), 28800), (Task(3), 14400), (Task(4), 14400),],
+						end_hint: None
+					}
+				),
+			]
+		);
+	});
+}
+
+#[test]
+fn initialize_with_leased_slots_works() {
+	TestExt::new().execute_with(|| {
+		assert_ok!(Broker::do_set_lease(1000, 6));
+		assert_ok!(Broker::do_set_lease(1001, 7));
+		assert_ok!(Broker::do_start_sales(100, 2));
+		advance_to(18);
+		let end_hint = None;
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(
+					6,
+					AssignCore {
+						core: 0,
+						begin: 8,
+						assignment: vec![(Task(1000), 57600),],
+						end_hint
+					}
+				),
+				(
+					6,
+					AssignCore {
+						core: 1,
+						begin: 8,
+						assignment: vec![(Task(1001), 57600),],
+						end_hint
+					}
+				),
+				(
+					12,
+					AssignCore {
+						core: 0,
+						begin: 14,
+						assignment: vec![(Task(1001), 57600),],
+						end_hint
+					}
+				),
+				(12, AssignCore { core: 1, begin: 14, assignment: vec![(Pool, 57600),], end_hint }),
+				(18, AssignCore { core: 0, begin: 20, assignment: vec![(Pool, 57600),], end_hint }),
+				(18, AssignCore { core: 1, begin: 20, assignment: vec![(Pool, 57600),], end_hint }),
+			]
+		);
+	});
+}
+
+#[test]
+fn purchase_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_ok!(Broker::do_assign(region, None, 1000, Final));
+		advance_to(6);
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![(
+				6,
+				AssignCore {
+					core: 0,
+					begin: 8,
+					assignment: vec![(Task(1000), 57600),],
+					end_hint: None
+				}
+			),]
+		);
+	});
+}
+
+#[test]
+fn partition_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		let (region1, region) = Broker::do_partition(region, None, 1).unwrap();
+		let (region2, region3) = Broker::do_partition(region, None, 1).unwrap();
+		assert_ok!(Broker::do_assign(region1, None, 1001, Final));
+		assert_ok!(Broker::do_assign(region2, None, 1002, Final));
+		assert_ok!(Broker::do_assign(region3, None, 1003, Final));
+		advance_to(10);
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(
+					6,
+					AssignCore {
+						core: 0,
+						begin: 8,
+						assignment: vec![(Task(1001), 57600),],
+						end_hint: None
+					}
+				),
+				(
+					8,
+					AssignCore {
+						core: 0,
+						begin: 10,
+						assignment: vec![(Task(1002), 57600),],
+						end_hint: None
+					}
+				),
+				(
+					10,
+					AssignCore {
+						core: 0,
+						begin: 12,
+						assignment: vec![(Task(1003), 57600),],
+						end_hint: None
+					}
+				),
+			]
+		);
+	});
+}
+
+#[test]
+fn interlace_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		let (region1, region) =
+			Broker::do_interlace(region, None, CoreMask::from_chunk(0, 30)).unwrap();
+		let (region2, region3) =
+			Broker::do_interlace(region, None, CoreMask::from_chunk(30, 60)).unwrap();
+		assert_ok!(Broker::do_assign(region1, None, 1001, Final));
+		assert_ok!(Broker::do_assign(region2, None, 1002, Final));
+		assert_ok!(Broker::do_assign(region3, None, 1003, Final));
+		advance_to(10);
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![(
+				6,
+				AssignCore {
+					core: 0,
+					begin: 8,
+					assignment: vec![(Task(1001), 21600), (Task(1002), 21600), (Task(1003), 14400),],
+					end_hint: None
+				}
+			),]
+		);
+	});
+}
+
+#[test]
+fn interlace_then_partition_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		let (region1, region2) =
+			Broker::do_interlace(region, None, CoreMask::from_chunk(0, 20)).unwrap();
+		let (region1, region3) = Broker::do_partition(region1, None, 1).unwrap();
+		let (region2, region4) = Broker::do_partition(region2, None, 2).unwrap();
+		assert_ok!(Broker::do_assign(region1, None, 1001, Final));
+		assert_ok!(Broker::do_assign(region2, None, 1002, Final));
+		assert_ok!(Broker::do_assign(region3, None, 1003, Final));
+		assert_ok!(Broker::do_assign(region4, None, 1004, Final));
+		advance_to(10);
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(
+					6,
+					AssignCore {
+						core: 0,
+						begin: 8,
+						assignment: vec![(Task(1001), 14400), (Task(1002), 43200),],
+						end_hint: None
+					}
+				),
+				(
+					8,
+					AssignCore {
+						core: 0,
+						begin: 10,
+						assignment: vec![(Task(1002), 43200), (Task(1003), 14400),],
+						end_hint: None
+					}
+				),
+				(
+					10,
+					AssignCore {
+						core: 0,
+						begin: 12,
+						assignment: vec![(Task(1003), 14400), (Task(1004), 43200),],
+						end_hint: None
+					}
+				),
+			]
+		);
+	});
+}
+
+#[test]
+fn partition_then_interlace_works() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		let (region1, region2) = Broker::do_partition(region, None, 1).unwrap();
+		let (region1, region3) =
+			Broker::do_interlace(region1, None, CoreMask::from_chunk(0, 20)).unwrap();
+		let (region2, region4) =
+			Broker::do_interlace(region2, None, CoreMask::from_chunk(0, 30)).unwrap();
+		assert_ok!(Broker::do_assign(region1, None, 1001, Final));
+		assert_ok!(Broker::do_assign(region2, None, 1002, Final));
+		assert_ok!(Broker::do_assign(region3, None, 1003, Final));
+		assert_ok!(Broker::do_assign(region4, None, 1004, Final));
+		advance_to(10);
+		assert_eq!(
+			CoretimeTrace::get(),
+			vec![
+				(
+					6,
+					AssignCore {
+						core: 0,
+						begin: 8,
+						assignment: vec![(Task(1001), 14400), (Task(1003), 43200),],
+						end_hint: None
+					}
+				),
+				(
+					8,
+					AssignCore {
+						core: 0,
+						begin: 10,
+						assignment: vec![(Task(1002), 21600), (Task(1004), 36000),],
+						end_hint: None
+					}
+				),
+			]
+		);
+	});
+}
+
+#[test]
+fn reservations_are_limited() {
+	TestExt::new().execute_with(|| {
+		let schedule = Schedule::truncate_from(vec![ScheduleItem {
+			assignment: Pool,
+			mask: CoreMask::complete(),
+		}]);
+		let max_cores: u32 = <Test as Config>::MaxReservedCores::get();
+		Reservations::<Test>::put(
+			BoundedVec::try_from(vec![schedule.clone(); max_cores as usize]).unwrap(),
+		);
+		assert_noop!(Broker::do_reserve(schedule), Error::<Test>::TooManyReservations);
+	});
+}
+
+#[test]
+fn cannot_unreserve_unknown() {
+	TestExt::new().execute_with(|| {
+		let schedule = Schedule::truncate_from(vec![ScheduleItem {
+			assignment: Pool,
+			mask: CoreMask::complete(),
+		}]);
+		Reservations::<Test>::put(BoundedVec::try_from(vec![schedule.clone(); 1usize]).unwrap());
+		assert_noop!(Broker::do_unreserve(2), Error::<Test>::UnknownReservation);
+	});
+}
+
+#[test]
+fn cannot_set_expired_lease() {
+	TestExt::new().execute_with(|| {
+		advance_to(2);
+		let current_timeslice = Broker::current_timeslice();
+		assert_noop!(
+			Broker::do_set_lease(1000, current_timeslice.saturating_sub(1)),
+			Error::<Test>::AlreadyExpired
+		);
+	});
+}
+
+#[test]
+fn leases_are_limited() {
+	TestExt::new().execute_with(|| {
+		let max_leases: u32 = <Test as Config>::MaxLeasedCores::get();
+		Leases::<Test>::put(
+			BoundedVec::try_from(vec![
+				LeaseRecordItem { task: 1u32, until: 10u32 };
+				max_leases as usize
+			])
+			.unwrap(),
+		);
+		assert_noop!(Broker::do_set_lease(1000, 10), Error::<Test>::TooManyLeases);
+	});
+}
+
+#[test]
+fn purchase_requires_valid_status_and_sale_info() {
+	TestExt::new().execute_with(|| {
+		assert_noop!(Broker::do_purchase(1, 100), Error::<Test>::Uninitialized);
+
+		let status = StatusRecord {
+			core_count: 2,
+			private_pool_size: 0,
+			system_pool_size: 0,
+			last_committed_timeslice: 0,
+			last_timeslice: 1,
+		};
+		Status::<Test>::put(&status);
+		assert_noop!(Broker::do_purchase(1, 100), Error::<Test>::NoSales);
+
+		let mut dummy_sale = SaleInfoRecord {
+			sale_start: 0,
+			leadin_length: 0,
+			price: 200,
+			sellout_price: None,
+			region_begin: 0,
+			region_end: 3,
+			first_core: 3,
+			ideal_cores_sold: 0,
+			cores_offered: 1,
+			cores_sold: 2,
+		};
+		SaleInfo::<Test>::put(&dummy_sale);
+		assert_noop!(Broker::do_purchase(1, 100), Error::<Test>::Unavailable);
+
+		dummy_sale.first_core = 1;
+		SaleInfo::<Test>::put(&dummy_sale);
+		assert_noop!(Broker::do_purchase(1, 100), Error::<Test>::SoldOut);
+
+		assert_ok!(Broker::do_start_sales(200, 1));
+		assert_noop!(Broker::do_purchase(1, 100), Error::<Test>::TooEarly);
+
+		advance_to(2);
+		assert_noop!(Broker::do_purchase(1, 100), Error::<Test>::Overpriced);
+	});
+}
+
+#[test]
+fn renewal_requires_valid_status_and_sale_info() {
+	TestExt::new().execute_with(|| {
+		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::Uninitialized);
+
+		let status = StatusRecord {
+			core_count: 2,
+			private_pool_size: 0,
+			system_pool_size: 0,
+			last_committed_timeslice: 0,
+			last_timeslice: 1,
+		};
+		Status::<Test>::put(&status);
+		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::NoSales);
+
+		let mut dummy_sale = SaleInfoRecord {
+			sale_start: 0,
+			leadin_length: 0,
+			price: 200,
+			sellout_price: None,
+			region_begin: 0,
+			region_end: 3,
+			first_core: 3,
+			ideal_cores_sold: 0,
+			cores_offered: 1,
+			cores_sold: 2,
+		};
+		SaleInfo::<Test>::put(&dummy_sale);
+		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::Unavailable);
+
+		dummy_sale.first_core = 1;
+		SaleInfo::<Test>::put(&dummy_sale);
+		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::SoldOut);
+
+		assert_ok!(Broker::do_start_sales(200, 1));
+		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::NotAllowed);
+
+		let record = AllowedRenewalRecord {
+			price: 100,
+			completion: CompletionStatus::Partial(CoreMask::from_chunk(0, 20)),
+		};
+		AllowedRenewals::<Test>::insert(AllowedRenewalId { core: 1, when: 4 }, &record);
+		assert_noop!(Broker::do_renew(1, 1), Error::<Test>::IncompleteAssignment);
+	});
+}
+
+#[test]
+fn cannot_transfer_or_partition_or_interlace_unknown() {
+	TestExt::new().execute_with(|| {
+		let region_id = RegionId { begin: 0, core: 0, mask: CoreMask::complete() };
+		assert_noop!(Broker::do_transfer(region_id, None, 2), Error::<Test>::UnknownRegion);
+		assert_noop!(Broker::do_partition(region_id, None, 2), Error::<Test>::UnknownRegion);
+		assert_noop!(
+			Broker::do_interlace(region_id, None, CoreMask::from_chunk(0, 20)),
+			Error::<Test>::UnknownRegion
+		);
+	});
+}
+
+#[test]
+fn check_ownership_for_transfer_or_partition_or_interlace() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_noop!(Broker::do_transfer(region, Some(2), 2), Error::<Test>::NotOwner);
+		assert_noop!(Broker::do_partition(region, Some(2), 2), Error::<Test>::NotOwner);
+		assert_noop!(
+			Broker::do_interlace(region, Some(2), CoreMask::from_chunk(0, 20)),
+			Error::<Test>::NotOwner
+		);
+	});
+}
+
+#[test]
+fn cannot_partition_invalid_offset() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		assert_noop!(Broker::do_partition(region, None, 0), Error::<Test>::PivotTooEarly);
+		assert_noop!(Broker::do_partition(region, None, 5), Error::<Test>::PivotTooLate);
+	});
+}
+
+#[test]
+fn cannot_interlace_invalid_pivot() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		let (region1, _) = Broker::do_interlace(region, None, CoreMask::from_chunk(0, 20)).unwrap();
+		assert_noop!(
+			Broker::do_interlace(region1, None, CoreMask::from_chunk(20, 40)),
+			Error::<Test>::ExteriorPivot
+		);
+		assert_noop!(
+			Broker::do_interlace(region1, None, CoreMask::void()),
+			Error::<Test>::VoidPivot
+		);
+		assert_noop!(
+			Broker::do_interlace(region1, None, CoreMask::from_chunk(0, 20)),
+			Error::<Test>::CompletePivot
+		);
+	});
+}
+
+#[test]
+fn assign_should_drop_invalid_region() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let mut region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		advance_to(10);
+		assert_ok!(Broker::do_assign(region, Some(1), 1001, Provisional));
+		region.begin = 7;
+		System::assert_last_event(Event::RegionDropped { region_id: region, duration: 0 }.into());
+	});
+}
+
+#[test]
+fn pool_should_drop_invalid_region() {
+	TestExt::new().endow(1, 1000).execute_with(|| {
+		assert_ok!(Broker::do_start_sales(100, 1));
+		advance_to(2);
+		let mut region = Broker::do_purchase(1, u64::max_value()).unwrap();
+		advance_to(10);
+		assert_ok!(Broker::do_pool(region, Some(1), 1001, Provisional));
+		region.begin = 7;
+		System::assert_last_event(Event::RegionDropped { region_id: region, duration: 0 }.into());
+	});
+}
+
+#[test]
+fn config_works() {
+	TestExt::new().execute_with(|| {
+		let mut cfg = new_config();
+		// Good config works:
+		assert_ok!(Broker::configure(Root.into(), cfg.clone()));
+		// Bad config is a noop:
+		cfg.leadin_length = 0;
+		assert_noop!(Broker::configure(Root.into(), cfg), Error::<Test>::InvalidConfig);
+	});
+}
diff --git a/substrate/frame/broker/src/tick_impls.rs b/substrate/frame/broker/src/tick_impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0677d2793e21acd17e3591738ec97c9df6687f7e
--- /dev/null
+++ b/substrate/frame/broker/src/tick_impls.rs
@@ -0,0 +1,326 @@
+// 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::{pallet_prelude::*, weights::WeightMeter};
+use sp_arithmetic::{
+	traits::{One, SaturatedConversion, Saturating, Zero},
+	FixedPointNumber,
+};
+use sp_runtime::traits::ConvertBack;
+use sp_std::{vec, vec::Vec};
+use CompletionStatus::Complete;
+
+impl<T: Config> Pallet<T> {
+	/// Attempt to tick things along.
+	///
+	/// This may do several things:
+	/// - Processes notifications of the core count changing
+	/// - Processes reports of Instantaneous Core Market Revenue
+	/// - Commit a timeslice
+	/// - Rotate the sale period
+	/// - Request revenue information for a previous timeslice
+	/// - Initialize an instantaneous core pool historical revenue record
+	pub(crate) fn do_tick() -> Weight {
+		let (mut status, config) = match (Status::<T>::get(), Configuration::<T>::get()) {
+			(Some(s), Some(c)) => (s, c),
+			_ => return Weight::zero(),
+		};
+
+		let mut meter = WeightMeter::max_limit();
+
+		if Self::process_core_count(&mut status) {
+			meter.consume(T::WeightInfo::process_core_count(status.core_count.into()));
+		}
+
+		if Self::process_revenue() {
+			meter.consume(T::WeightInfo::process_revenue());
+		}
+
+		if let Some(commit_timeslice) = Self::next_timeslice_to_commit(&config, &status) {
+			status.last_committed_timeslice = commit_timeslice;
+			if let Some(sale) = SaleInfo::<T>::get() {
+				if commit_timeslice >= sale.region_begin {
+					// Sale can be rotated.
+					Self::rotate_sale(sale, &config, &status);
+					meter.consume(T::WeightInfo::rotate_sale(status.core_count.into()));
+				}
+			}
+
+			Self::process_pool(commit_timeslice, &mut status);
+			meter.consume(T::WeightInfo::process_pool());
+
+			let timeslice_period = T::TimeslicePeriod::get();
+			let rc_begin = RelayBlockNumberOf::<T>::from(commit_timeslice) * timeslice_period;
+			for core in 0..status.core_count {
+				Self::process_core_schedule(commit_timeslice, rc_begin, core);
+				meter.consume(T::WeightInfo::process_core_schedule());
+			}
+		}
+
+		let current_timeslice = Self::current_timeslice();
+		if status.last_timeslice < current_timeslice {
+			status.last_timeslice.saturating_inc();
+			let rc_block = T::TimeslicePeriod::get() * status.last_timeslice.into();
+			T::Coretime::request_revenue_info_at(rc_block);
+			meter.consume(T::WeightInfo::request_revenue_info_at());
+		}
+
+		Status::<T>::put(&status);
+
+		meter.consumed()
+	}
+
+	pub(crate) fn process_core_count(status: &mut StatusRecord) -> bool {
+		if let Some(core_count) = T::Coretime::check_notify_core_count() {
+			status.core_count = core_count;
+			Self::deposit_event(Event::<T>::CoreCountChanged { core_count });
+			return true
+		}
+		false
+	}
+
+	pub(crate) fn process_revenue() -> bool {
+		let Some((until, amount)) = T::Coretime::check_notify_revenue_info() else {
+			return false;
+		};
+		let when: Timeslice =
+			(until / T::TimeslicePeriod::get()).saturating_sub(One::one()).saturated_into();
+		let mut revenue = T::ConvertBalance::convert_back(amount);
+		if revenue.is_zero() {
+			Self::deposit_event(Event::<T>::HistoryDropped { when, revenue });
+			InstaPoolHistory::<T>::remove(when);
+			return true
+		}
+		let mut r = InstaPoolHistory::<T>::get(when).unwrap_or_default();
+		if r.maybe_payout.is_some() {
+			Self::deposit_event(Event::<T>::HistoryIgnored { when, revenue });
+			return true
+		}
+		// Payout system InstaPool Cores.
+		let total_contrib = r.system_contributions.saturating_add(r.private_contributions);
+		let system_payout =
+			revenue.saturating_mul(r.system_contributions.into()) / total_contrib.into();
+		let _ = Self::charge(&Self::account_id(), system_payout);
+		revenue.saturating_reduce(system_payout);
+
+		if !revenue.is_zero() && r.private_contributions > 0 {
+			r.maybe_payout = Some(revenue);
+			InstaPoolHistory::<T>::insert(when, &r);
+			Self::deposit_event(Event::<T>::ClaimsReady {
+				when,
+				system_payout,
+				private_payout: revenue,
+			});
+		} else {
+			InstaPoolHistory::<T>::remove(when);
+			Self::deposit_event(Event::<T>::HistoryDropped { when, revenue });
+		}
+		true
+	}
+
+	/// Begin selling for the next sale period.
+	///
+	/// Triggered by Relay-chain block number/timeslice.
+	pub(crate) fn rotate_sale(
+		old_sale: SaleInfoRecordOf<T>,
+		config: &ConfigRecordOf<T>,
+		status: &StatusRecord,
+	) -> Option<()> {
+		let now = frame_system::Pallet::<T>::block_number();
+
+		let pool_item =
+			ScheduleItem { assignment: CoreAssignment::Pool, mask: CoreMask::complete() };
+		let just_pool = Schedule::truncate_from(vec![pool_item]);
+
+		// Clean up the old sale - we need to use up any unused cores by putting them into the
+		// InstaPool.
+		let mut old_pooled: SignedCoreMaskBitCount = 0;
+		for i in old_sale.cores_sold..old_sale.cores_offered {
+			old_pooled.saturating_accrue(80);
+			Workplan::<T>::insert((old_sale.region_begin, old_sale.first_core + i), &just_pool);
+		}
+		InstaPoolIo::<T>::mutate(old_sale.region_begin, |r| r.system.saturating_accrue(old_pooled));
+		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
+			}
+		};
+
+		// Set workload for the reserved (system, probably) workloads.
+		let region_begin = old_sale.region_end;
+		let region_end = region_begin + config.region_length;
+
+		let mut first_core = 0;
+		let mut total_pooled: SignedCoreMaskBitCount = 0;
+		for schedule in Reservations::<T>::get().into_iter() {
+			let parts: u32 = schedule
+				.iter()
+				.filter(|i| matches!(i.assignment, CoreAssignment::Pool))
+				.map(|i| i.mask.count_ones())
+				.sum();
+			total_pooled.saturating_accrue(parts as i32);
+
+			Workplan::<T>::insert((region_begin, first_core), &schedule);
+			first_core.saturating_inc();
+		}
+		InstaPoolIo::<T>::mutate(region_begin, |r| r.system.saturating_accrue(total_pooled));
+		InstaPoolIo::<T>::mutate(region_end, |r| r.system.saturating_reduce(total_pooled));
+
+		let mut leases = Leases::<T>::get();
+		// Can morph to a renewable as long as it's >=begin and <end.
+		leases.retain(|&LeaseRecordItem { until, task }| {
+			let mask = CoreMask::complete();
+			let assignment = CoreAssignment::Task(task);
+			let schedule = BoundedVec::truncate_from(vec![ScheduleItem { mask, assignment }]);
+			Workplan::<T>::insert((region_begin, first_core), &schedule);
+			let expiring = until >= region_begin && until < region_end;
+			if expiring {
+				// last time for this one - make it renewable.
+				let renewal_id = AllowedRenewalId { core: first_core, when: region_end };
+				let record = AllowedRenewalRecord { price, completion: Complete(schedule) };
+				AllowedRenewals::<T>::insert(renewal_id, &record);
+				Self::deposit_event(Event::Renewable {
+					core: first_core,
+					price,
+					begin: region_end,
+					workload: record.completion.drain_complete().unwrap_or_default(),
+				});
+				Self::deposit_event(Event::LeaseEnding { when: region_end, task });
+			}
+			first_core.saturating_inc();
+			!expiring
+		});
+		Leases::<T>::put(&leases);
+
+		let max_possible_sales = status.core_count.saturating_sub(first_core);
+		let limit_cores_offered = config.limit_cores_offered.unwrap_or(CoreIndex::max_value());
+		let cores_offered = limit_cores_offered.min(max_possible_sales);
+		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;
+		// Update SaleInfo
+		let new_sale = SaleInfoRecord {
+			sale_start,
+			leadin_length,
+			price,
+			sellout_price: None,
+			region_begin,
+			region_end,
+			first_core,
+			ideal_cores_sold,
+			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,
+			region_begin,
+			region_end,
+			ideal_cores_sold,
+			cores_offered,
+		});
+
+		Some(())
+	}
+
+	pub(crate) fn process_pool(when: Timeslice, status: &mut StatusRecord) {
+		let pool_io = InstaPoolIo::<T>::take(when);
+		status.private_pool_size = (status.private_pool_size as SignedCoreMaskBitCount)
+			.saturating_add(pool_io.private) as CoreMaskBitCount;
+		status.system_pool_size = (status.system_pool_size as SignedCoreMaskBitCount)
+			.saturating_add(pool_io.system) as CoreMaskBitCount;
+		let record = InstaPoolHistoryRecord {
+			private_contributions: status.private_pool_size,
+			system_contributions: status.system_pool_size,
+			maybe_payout: None,
+		};
+		InstaPoolHistory::<T>::insert(when, record);
+		Self::deposit_event(Event::<T>::HistoryInitialized {
+			when,
+			private_pool_size: status.private_pool_size,
+			system_pool_size: status.system_pool_size,
+		});
+	}
+
+	/// Schedule cores for the given `timeslice`.
+	pub(crate) fn process_core_schedule(
+		timeslice: Timeslice,
+		rc_begin: RelayBlockNumberOf<T>,
+		core: CoreIndex,
+	) {
+		let Some(workplan) = Workplan::<T>::take((timeslice, core)) else {
+			return;
+		};
+		let workload = Workload::<T>::get(core);
+		let parts_used = workplan.iter().map(|i| i.mask).fold(CoreMask::void(), |a, i| a | i);
+		let mut workplan = workplan.into_inner();
+		workplan.extend(workload.into_iter().filter(|i| (i.mask & parts_used).is_void()));
+		let workplan = Schedule::truncate_from(workplan);
+		Workload::<T>::insert(core, &workplan);
+
+		let mut total_used = 0;
+		let mut intermediate = workplan
+			.into_iter()
+			.map(|i| (i.assignment, i.mask.count_ones() as u16 * (57_600 / 80)))
+			.inspect(|i| total_used.saturating_accrue(i.1))
+			.collect::<Vec<_>>();
+		if total_used < 57_600 {
+			intermediate.push((CoreAssignment::Idle, 57_600 - total_used));
+		}
+		intermediate.sort();
+		let mut assignment: Vec<(CoreAssignment, PartsOf57600)> =
+			Vec::with_capacity(intermediate.len());
+		for i in intermediate.into_iter() {
+			if let Some(ref mut last) = assignment.last_mut() {
+				if last.0 == i.0 {
+					last.1 += i.1;
+					continue
+				}
+			}
+			assignment.push(i);
+		}
+		T::Coretime::assign_core(core, rc_begin, assignment.clone(), None);
+		Self::deposit_event(Event::<T>::CoreAssigned { core, when: rc_begin, assignment });
+	}
+}
diff --git a/substrate/frame/broker/src/types.rs b/substrate/frame/broker/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..89222ca8e95271098fe2d335142015024439a71a
--- /dev/null
+++ b/substrate/frame/broker/src/types.rs
@@ -0,0 +1,290 @@
+// 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::{
+	Config, CoreAssignment, CoreIndex, CoreMask, CoretimeInterface, TaskId, CORE_MASK_BITS,
+};
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::traits::fungible::Inspect;
+use frame_system::{pallet_prelude::BlockNumberFor, Config as SConfig};
+use scale_info::TypeInfo;
+use sp_arithmetic::Perbill;
+use sp_core::{ConstU32, RuntimeDebug};
+use sp_runtime::BoundedVec;
+
+pub type BalanceOf<T> = <<T as Config>::Currency as Inspect<<T as SConfig>::AccountId>>::Balance;
+pub type RelayBalanceOf<T> = <<T as Config>::Coretime as CoretimeInterface>::Balance;
+pub type RelayBlockNumberOf<T> = <<T as Config>::Coretime as CoretimeInterface>::BlockNumber;
+pub type RelayAccountIdOf<T> = <<T as Config>::Coretime as CoretimeInterface>::AccountId;
+
+/// Relay-chain block number with a fixed divisor of Config::TimeslicePeriod.
+pub type Timeslice = u32;
+/// Counter for the total number of set bits over every core's `CoreMask`. `u32` so we don't
+/// ever get an overflow. This is 1/80th of a Polkadot Core per timeslice. Assuming timeslices are
+/// 80 blocks, then this indicates usage of a single core one time over a timeslice.
+pub type CoreMaskBitCount = u32;
+/// The same as `CoreMaskBitCount` but signed.
+pub type SignedCoreMaskBitCount = i32;
+
+/// Whether a core assignment is revokable or not.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum Finality {
+	/// The region remains with the same owner allowing the assignment to be altered.
+	Provisional,
+	/// The region is removed; the assignment may be eligible for renewal.
+	Final,
+}
+
+/// Self-describing identity for a Region of Bulk Coretime.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct RegionId {
+	/// The timeslice at which this Region begins.
+	pub begin: Timeslice,
+	/// The index of the Polakdot Core on which this Region will be scheduled.
+	pub core: CoreIndex,
+	/// The regularity parts in which this Region will be scheduled.
+	pub mask: CoreMask,
+}
+impl From<u128> for RegionId {
+	fn from(x: u128) -> Self {
+		Self { begin: (x >> 96) as u32, core: (x >> 80) as u16, mask: x.into() }
+	}
+}
+impl From<RegionId> for u128 {
+	fn from(x: RegionId) -> Self {
+		(x.begin as u128) << 96 | (x.core as u128) << 80 | u128::from(x.mask)
+	}
+}
+#[test]
+fn region_id_converts_u128() {
+	let r = RegionId { begin: 0x12345678u32, core: 0xabcdu16, mask: 0xdeadbeefcafef00d0123.into() };
+	let u = 0x12345678_abcd_deadbeefcafef00d0123u128;
+	assert_eq!(RegionId::from(u), r);
+	assert_eq!(u128::from(r), u);
+}
+
+/// The rest of the information describing a Region.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct RegionRecord<AccountId, Balance> {
+	/// The end of the Region.
+	pub end: Timeslice,
+	/// The owner of the Region.
+	pub owner: AccountId,
+	/// The amount paid to Polkadot for this Region, or `None` if renewal is not allowed.
+	pub paid: Option<Balance>,
+}
+pub type RegionRecordOf<T> = RegionRecord<<T as SConfig>::AccountId, BalanceOf<T>>;
+
+/// An distinct item which can be scheduled on a Polkadot Core.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ScheduleItem {
+	/// The regularity parts in which this Item will be scheduled on the Core.
+	pub mask: CoreMask,
+	/// The job that the Core should be doing.
+	pub assignment: CoreAssignment,
+}
+pub type Schedule = BoundedVec<ScheduleItem, ConstU32<{ CORE_MASK_BITS as u32 }>>;
+
+/// The record body of a Region which was contributed to the Instantaneous Coretime Pool. This helps
+/// with making pro rata payments to contributors.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ContributionRecord<AccountId> {
+	/// The end of the Region contributed.
+	pub length: Timeslice,
+	/// The identity of the contributor.
+	pub payee: AccountId,
+}
+pub type ContributionRecordOf<T> = ContributionRecord<<T as SConfig>::AccountId>;
+
+/// A per-timeslice bookkeeping record for tracking Instantaneous Coretime Pool activity and
+/// making proper payments to contributors.
+#[derive(Encode, Decode, Clone, Default, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct InstaPoolHistoryRecord<Balance> {
+	/// The total amount of Coretime (measured in Core Mask Bits minus any contributions which have
+	/// already been paid out.
+	pub private_contributions: CoreMaskBitCount,
+	/// The total amount of Coretime (measured in Core Mask Bits contributed by the Polkadot System
+	/// in this timeslice.
+	pub system_contributions: CoreMaskBitCount,
+	/// The payout remaining for the `private_contributions`, or `None` if the revenue is not yet
+	/// known.
+	pub maybe_payout: Option<Balance>,
+}
+pub type InstaPoolHistoryRecordOf<T> = InstaPoolHistoryRecord<BalanceOf<T>>;
+
+/// How much of a core has been assigned or, if completely assigned, the workload itself.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum CompletionStatus {
+	/// The core is not fully assigned; the inner is the parts which have.
+	Partial(CoreMask),
+	/// The core is fully assigned; the inner is the workload which has been assigned.
+	Complete(Schedule),
+}
+impl CompletionStatus {
+	/// Return reference to the complete workload, or `None` if incomplete.
+	pub fn complete(&self) -> Option<&Schedule> {
+		match self {
+			Self::Complete(s) => Some(s),
+			Self::Partial(_) => None,
+		}
+	}
+	/// Return the complete workload, or `None` if incomplete.
+	pub fn drain_complete(self) -> Option<Schedule> {
+		match self {
+			Self::Complete(s) => Some(s),
+			Self::Partial(_) => None,
+		}
+	}
+}
+
+/// The identity of a possible Core workload renewal.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct AllowedRenewalId {
+	/// 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.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct AllowedRenewalRecord<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>>;
+
+/// General status of the system.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct StatusRecord {
+	/// The total number of cores which can be assigned (one plus the maximum index which can
+	/// be used in `Coretime::assign`).
+	pub core_count: CoreIndex,
+	/// The current size of the Instantaneous Coretime Pool, measured in
+	/// Core Mask Bits.
+	pub private_pool_size: CoreMaskBitCount,
+	/// The current amount of the Instantaneous Coretime Pool which is provided by the Polkadot
+	/// System, rather than provided as a result of privately operated Coretime.
+	pub system_pool_size: CoreMaskBitCount,
+	/// The last (Relay-chain) timeslice which we committed to the Relay-chain.
+	pub last_committed_timeslice: Timeslice,
+	/// The timeslice of the last time we ticked.
+	pub last_timeslice: Timeslice,
+}
+
+/// A record of flux in the InstaPool.
+#[derive(
+	Encode, Decode, Clone, Copy, Default, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen,
+)]
+pub struct PoolIoRecord {
+	/// The total change of the portion of the pool supplied by purchased Bulk Coretime, measured
+	/// in Core Mask Bits.
+	pub private: SignedCoreMaskBitCount,
+	/// The total change of the portion of the pool supplied by the Polkaot System, measured in
+	/// Core Mask Bits.
+	pub system: SignedCoreMaskBitCount,
+}
+
+/// The status of a Bulk Coretime Sale.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct SaleInfoRecord<Balance, BlockNumber> {
+	/// The local block number at which the sale will/did start.
+	pub sale_start: 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,
+	/// 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
+	/// after the last timeslice which the Regions control.)
+	pub 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.
+	pub ideal_cores_sold: CoreIndex,
+	/// Number of cores which are/have been offered for sale.
+	pub cores_offered: CoreIndex,
+	/// 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.
+	pub sellout_price: Option<Balance>,
+	/// Number of cores which have been sold; never more than cores_offered.
+	pub cores_sold: CoreIndex,
+}
+pub type SaleInfoRecordOf<T> = SaleInfoRecord<BalanceOf<T>, BlockNumberFor<T>>;
+
+/// Record for Polkadot Core reservations (generally tasked with the maintenance of System
+/// Chains).
+pub type ReservationsRecord<Max> = BoundedVec<Schedule, Max>;
+pub type ReservationsRecordOf<T> = ReservationsRecord<<T as Config>::MaxReservedCores>;
+
+/// Information on a single legacy lease.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct LeaseRecordItem {
+	/// The timeslice until the lease is valid.
+	pub until: Timeslice,
+	/// The task which the lease is for.
+	pub task: TaskId,
+}
+
+/// Record for Polkadot Core legacy leases.
+pub type LeasesRecord<Max> = BoundedVec<LeaseRecordItem, Max>;
+pub type LeasesRecordOf<T> = LeasesRecord<<T as Config>::MaxLeasedCores>;
+
+/// Configuration of this pallet.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ConfigRecord<BlockNumber, RelayBlockNumber> {
+	/// The number of Relay-chain blocks in advance which scheduling should be fixed and the
+	/// `Coretime::assign` API used to inform the Relay-chain.
+	pub advance_notice: RelayBlockNumber,
+	/// The length in blocks of the Interlude Period for forthcoming sales.
+	pub interlude_length: BlockNumber,
+	/// The length in blocks of the Leadin Period for forthcoming sales.
+	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.
+	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.
+	pub limit_cores_offered: Option<CoreIndex>,
+	/// The amount by which the renewal price increases each sale period.
+	pub renewal_bump: Perbill,
+	/// The duration by which rewards for contributions to the InstaPool must be collected.
+	pub contribution_timeout: Timeslice,
+}
+pub type ConfigRecordOf<T> = ConfigRecord<BlockNumberFor<T>, RelayBlockNumberOf<T>>;
+
+impl<BlockNumber, RelayBlockNumber> ConfigRecord<BlockNumber, RelayBlockNumber>
+where
+	BlockNumber: sp_arithmetic::traits::Zero,
+{
+	/// Check the config for basic validity constraints.
+	pub(crate) fn validate(&self) -> Result<(), ()> {
+		if self.leadin_length.is_zero() {
+			return Err(())
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/broker/src/utility_impls.rs b/substrate/frame/broker/src/utility_impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..99c4de32f77678f4df9568e7c5a2c442b255c4c8
--- /dev/null
+++ b/substrate/frame/broker/src/utility_impls.rs
@@ -0,0 +1,121 @@
+// 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::{
+	pallet_prelude::{DispatchResult, *},
+	traits::{
+		fungible::Balanced,
+		tokens::{Fortitude::Polite, Precision::Exact, Preservation::Expendable},
+		OnUnbalanced,
+	},
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_arithmetic::{
+	traits::{SaturatedConversion, Saturating},
+	FixedPointNumber, FixedU64,
+};
+use sp_runtime::traits::AccountIdConversion;
+
+impl<T: Config> Pallet<T> {
+	pub fn current_timeslice() -> Timeslice {
+		let latest = T::Coretime::latest();
+		let timeslice_period = T::TimeslicePeriod::get();
+		(latest / timeslice_period).saturated_into()
+	}
+
+	pub fn latest_timeslice_ready_to_commit(config: &ConfigRecordOf<T>) -> Timeslice {
+		let latest = T::Coretime::latest();
+		let advanced = latest.saturating_add(config.advance_notice);
+		let timeslice_period = T::TimeslicePeriod::get();
+		(advanced / timeslice_period).saturated_into()
+	}
+
+	pub fn next_timeslice_to_commit(
+		config: &ConfigRecordOf<T>,
+		status: &StatusRecord,
+	) -> Option<Timeslice> {
+		if status.last_committed_timeslice < Self::latest_timeslice_ready_to_commit(config) {
+			Some(status.last_committed_timeslice + 1)
+		} else {
+			None
+		}
+	}
+
+	pub fn account_id() -> T::AccountId {
+		T::PalletId::get().into_account_truncating()
+	}
+
+	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)
+	}
+
+	pub(crate) fn charge(who: &T::AccountId, amount: BalanceOf<T>) -> DispatchResult {
+		let credit = T::Currency::withdraw(&who, amount, Exact, Expendable, Polite)?;
+		T::OnRevenue::on_unbalanced(credit);
+		Ok(())
+	}
+
+	pub(crate) fn issue(
+		core: CoreIndex,
+		begin: Timeslice,
+		end: Timeslice,
+		owner: T::AccountId,
+		paid: Option<BalanceOf<T>>,
+	) -> RegionId {
+		let id = RegionId { begin, core, mask: CoreMask::complete() };
+		let record = RegionRecord { end, owner, paid };
+		Regions::<T>::insert(&id, &record);
+		id
+	}
+
+	pub(crate) fn utilize(
+		mut region_id: RegionId,
+		maybe_check_owner: Option<T::AccountId>,
+		finality: Finality,
+	) -> Result<Option<(RegionId, RegionRecordOf<T>)>, Error<T>> {
+		let status = Status::<T>::get().ok_or(Error::<T>::Uninitialized)?;
+		let region = Regions::<T>::get(&region_id).ok_or(Error::<T>::UnknownRegion)?;
+
+		if let Some(check_owner) = maybe_check_owner {
+			ensure!(check_owner == region.owner, Error::<T>::NotOwner);
+		}
+
+		Regions::<T>::remove(&region_id);
+
+		let last_committed_timeslice = status.last_committed_timeslice;
+		if region_id.begin <= last_committed_timeslice {
+			region_id.begin = last_committed_timeslice + 1;
+			if region_id.begin >= region.end {
+				let duration = region.end.saturating_sub(region_id.begin);
+				Self::deposit_event(Event::RegionDropped { region_id, duration });
+				return Ok(None)
+			}
+		} else {
+			Workplan::<T>::mutate_extant((region_id.begin, region_id.core), |p| {
+				p.retain(|i| (i.mask & region_id.mask).is_void())
+			});
+		}
+		if finality == Finality::Provisional {
+			Regions::<T>::insert(&region_id, &region);
+		}
+
+		Ok(Some((region_id, region)))
+	}
+}
diff --git a/substrate/frame/broker/src/weights.rs b/substrate/frame/broker/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..93b568bf2a035af7542056026ab3c8238bfc6cfd
--- /dev/null
+++ b/substrate/frame/broker/src/weights.rs
@@ -0,0 +1,794 @@
+// 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.
+
+//! Autogenerated weights for `pallet_broker`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-07-29, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-ynta1nyy-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: ``, WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
+
+// Executed Command:
+// target/production/substrate-node
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_broker
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/broker/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pallet_broker`.
+pub trait WeightInfo {
+	fn configure() -> Weight;
+	fn reserve() -> Weight;
+	fn unreserve() -> Weight;
+	fn set_lease() -> Weight;
+	fn start_sales(n: u32, ) -> Weight;
+	fn purchase() -> Weight;
+	fn renew() -> Weight;
+	fn transfer() -> Weight;
+	fn partition() -> Weight;
+	fn interlace() -> Weight;
+	fn assign() -> Weight;
+	fn pool() -> Weight;
+	fn claim_revenue(m: u32, ) -> Weight;
+	fn purchase_credit() -> Weight;
+	fn drop_region() -> Weight;
+	fn drop_contribution() -> Weight;
+	fn drop_history() -> Weight;
+	fn drop_renewal() -> Weight;
+	fn request_core_count(n: u32, ) -> Weight;
+	fn process_core_count(n: u32, ) -> Weight;
+	fn process_revenue() -> Weight;
+	fn rotate_sale(n: u32, ) -> Weight;
+	fn process_pool() -> Weight;
+	fn process_core_schedule() -> Weight;
+	fn request_revenue_info_at() -> Weight;
+}
+
+/// Weights for `pallet_broker` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `Broker::Configuration` (r:0 w:1)
+	/// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`)
+	fn configure() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_448_000 picoseconds.
+		Weight::from_parts(3_729_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Reservations` (r:1 w:1)
+	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
+	fn reserve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `5016`
+		//  Estimated: `7496`
+		// Minimum execution time: 22_537_000 picoseconds.
+		Weight::from_parts(23_335_000, 7496)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Reservations` (r:1 w:1)
+	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
+	fn unreserve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6218`
+		//  Estimated: `7496`
+		// Minimum execution time: 21_668_000 picoseconds.
+		Weight::from_parts(22_442_000, 7496)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Leases` (r:1 w:1)
+	/// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(41), added: 536, mode: `MaxEncodedLen`)
+	fn set_lease() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `239`
+		//  Estimated: `1526`
+		// Minimum execution time: 13_606_000 picoseconds.
+		Weight::from_parts(14_104_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::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)
+	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
+	/// 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 start_sales(_n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6330`
+		//  Estimated: `8499`
+		// Minimum execution time: 64_012_000 picoseconds.
+		Weight::from_parts(67_819_922, 8499)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(16_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::SaleInfo` (r:1 w:1)
+	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, 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)
+	/// 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`)
+	fn purchase() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `568`
+		//  Estimated: `2053`
+		// Minimum execution time: 48_110_000 picoseconds.
+		Weight::from_parts(49_234_000, 2053)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_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::Status` (r:1 w:0)
+	/// 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: `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)
+	/// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `Broker::Workplan` (r:0 w:1)
+	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
+	fn renew() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `686`
+		//  Estimated: `4698`
+		// Minimum execution time: 69_580_000 picoseconds.
+		Weight::from_parts(70_914_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`)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3550`
+		// Minimum execution time: 17_687_000 picoseconds.
+		Weight::from_parts(18_573_000, 3550)
+			.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`)
+	fn partition() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3550`
+		// Minimum execution time: 19_675_000 picoseconds.
+		Weight::from_parts(20_234_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Broker::Regions` (r:1 w:2)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	fn interlace() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3550`
+		// Minimum execution time: 19_426_000 picoseconds.
+		Weight::from_parts(20_414_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_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::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`)
+	/// 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`
+		//  Estimated: `4681`
+		// Minimum execution time: 31_751_000 picoseconds.
+		Weight::from_parts(32_966_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`)
+	/// 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)
+	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolContribution` (r:0 w:1)
+	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `775`
+		//  Estimated: `5996`
+		// Minimum execution time: 36_709_000 picoseconds.
+		Weight::from_parts(38_930_000, 5996)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: `Broker::InstaPoolContribution` (r:1 w:1)
+	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolHistory` (r:3 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `m` is `[1, 3]`.
+	fn claim_revenue(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `720`
+		//  Estimated: `6196 + m * (2520 ±0)`
+		// Minimum execution time: 55_510_000 picoseconds.
+		Weight::from_parts(56_665_061, 6196)
+			// Standard Error: 61_729
+			.saturating_add(Weight::from_parts(1_724_824, 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(3_u64))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(m.into()))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn purchase_credit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `3593`
+		// Minimum execution time: 44_992_000 picoseconds.
+		Weight::from_parts(46_225_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`)
+	fn drop_region() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `603`
+		//  Estimated: `3550`
+		// Minimum execution time: 28_207_000 picoseconds.
+		Weight::from_parts(28_707_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(2_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::Status` (r:1 w:0)
+	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolContribution` (r:1 w:1)
+	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn drop_contribution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `601`
+		//  Estimated: `3533`
+		// Minimum execution time: 31_813_000 picoseconds.
+		Weight::from_parts(32_612_000, 3533)
+			.saturating_add(T::DbWeight::get().reads(3_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::Status` (r:1 w:0)
+	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolHistory` (r:1 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn drop_history() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829`
+		//  Estimated: `3593`
+		// Minimum execution time: 38_571_000 picoseconds.
+		Weight::from_parts(39_493_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`)
+	fn drop_renewal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `525`
+		//  Estimated: `4698`
+		// Minimum execution time: 24_714_000 picoseconds.
+		Weight::from_parts(25_288_000, 4698)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:0 w:1)
+	/// Proof: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:0 w:1)
+	/// The range of component `n` is `[0, 1000]`.
+	fn request_core_count(_n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_258_000 picoseconds.
+		Weight::from_parts(7_925_570, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:1 w:0)
+	/// The range of component `n` is `[0, 1000]`.
+	fn process_core_count(_n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `97`
+		//  Estimated: `3562`
+		// Minimum execution time: 7_136_000 picoseconds.
+		Weight::from_parts(7_788_194, 3562)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Broker::InstaPoolHistory` (r:0 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	fn process_revenue() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_049_000 picoseconds.
+		Weight::from_parts(6_311_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// 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::SaleInfo` (r:0 w:1)
+	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
+	/// 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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `6281`
+		//  Estimated: `8499`
+		// Minimum execution time: 47_504_000 picoseconds.
+		Weight::from_parts(49_778_098, 8499)
+			// Standard Error: 109
+			.saturating_add(Weight::from_parts(427, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(15_u64))
+	}
+	/// Storage: `Broker::InstaPoolIo` (r:1 w:0)
+	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolHistory` (r:0 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	fn process_pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `180`
+		//  Estimated: `3493`
+		// Minimum execution time: 9_573_000 picoseconds.
+		Weight::from_parts(10_034_000, 3493)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Workplan` (r:1 w:1)
+	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::Workload` (r:1 w:1)
+	/// Proof: `Broker::Workload` (`max_values`: None, `max_size`: Some(1212), added: 3687, mode: `MaxEncodedLen`)
+	fn process_core_schedule() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1423`
+		//  Estimated: `4681`
+		// Minimum execution time: 21_331_000 picoseconds.
+		Weight::from_parts(22_235_000, 4681)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	fn request_revenue_info_at() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 191_000 picoseconds.
+		Weight::from_parts(234_000, 0)
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `Broker::Configuration` (r:0 w:1)
+	/// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`)
+	fn configure() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_448_000 picoseconds.
+		Weight::from_parts(3_729_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Reservations` (r:1 w:1)
+	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
+	fn reserve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `5016`
+		//  Estimated: `7496`
+		// Minimum execution time: 22_537_000 picoseconds.
+		Weight::from_parts(23_335_000, 7496)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Reservations` (r:1 w:1)
+	/// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(6011), added: 6506, mode: `MaxEncodedLen`)
+	fn unreserve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6218`
+		//  Estimated: `7496`
+		// Minimum execution time: 21_668_000 picoseconds.
+		Weight::from_parts(22_442_000, 7496)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Leases` (r:1 w:1)
+	/// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(41), added: 536, mode: `MaxEncodedLen`)
+	fn set_lease() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `239`
+		//  Estimated: `1526`
+		// Minimum execution time: 13_606_000 picoseconds.
+		Weight::from_parts(14_104_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::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)
+	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
+	/// 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 start_sales(_n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6330`
+		//  Estimated: `8499`
+		// Minimum execution time: 64_012_000 picoseconds.
+		Weight::from_parts(67_819_922, 8499)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(16_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::SaleInfo` (r:1 w:1)
+	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, 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)
+	/// 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`)
+	fn purchase() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `568`
+		//  Estimated: `2053`
+		// Minimum execution time: 48_110_000 picoseconds.
+		Weight::from_parts(49_234_000, 2053)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_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::Status` (r:1 w:0)
+	/// 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: `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)
+	/// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	/// Storage: `Broker::Workplan` (r:0 w:1)
+	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
+	fn renew() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `686`
+		//  Estimated: `4698`
+		// Minimum execution time: 69_580_000 picoseconds.
+		Weight::from_parts(70_914_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`)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3550`
+		// Minimum execution time: 17_687_000 picoseconds.
+		Weight::from_parts(18_573_000, 3550)
+			.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`)
+	fn partition() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3550`
+		// Minimum execution time: 19_675_000 picoseconds.
+		Weight::from_parts(20_234_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Broker::Regions` (r:1 w:2)
+	/// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	fn interlace() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3550`
+		// Minimum execution time: 19_426_000 picoseconds.
+		Weight::from_parts(20_414_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_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::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`)
+	/// 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`
+		//  Estimated: `4681`
+		// Minimum execution time: 31_751_000 picoseconds.
+		Weight::from_parts(32_966_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`)
+	/// 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)
+	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolContribution` (r:0 w:1)
+	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `775`
+		//  Estimated: `5996`
+		// Minimum execution time: 36_709_000 picoseconds.
+		Weight::from_parts(38_930_000, 5996)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: `Broker::InstaPoolContribution` (r:1 w:1)
+	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolHistory` (r:3 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:2 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// The range of component `m` is `[1, 3]`.
+	fn claim_revenue(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `720`
+		//  Estimated: `6196 + m * (2520 ±0)`
+		// Minimum execution time: 55_510_000 picoseconds.
+		Weight::from_parts(56_665_061, 6196)
+			// Standard Error: 61_729
+			.saturating_add(Weight::from_parts(1_724_824, 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(3_u64))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(m.into()))
+	}
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn purchase_credit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `103`
+		//  Estimated: `3593`
+		// Minimum execution time: 44_992_000 picoseconds.
+		Weight::from_parts(46_225_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`)
+	fn drop_region() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `603`
+		//  Estimated: `3550`
+		// Minimum execution time: 28_207_000 picoseconds.
+		Weight::from_parts(28_707_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(2_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::Status` (r:1 w:0)
+	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolContribution` (r:1 w:1)
+	/// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn drop_contribution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `601`
+		//  Estimated: `3533`
+		// Minimum execution time: 31_813_000 picoseconds.
+		Weight::from_parts(32_612_000, 3533)
+			.saturating_add(RocksDbWeight::get().reads(3_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::Status` (r:1 w:0)
+	/// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolHistory` (r:1 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	fn drop_history() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829`
+		//  Estimated: `3593`
+		// Minimum execution time: 38_571_000 picoseconds.
+		Weight::from_parts(39_493_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`)
+	fn drop_renewal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `525`
+		//  Estimated: `4698`
+		// Minimum execution time: 24_714_000 picoseconds.
+		Weight::from_parts(25_288_000, 4698)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:0 w:1)
+	/// Proof: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:0 w:1)
+	/// The range of component `n` is `[0, 1000]`.
+	fn request_core_count(_n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_258_000 picoseconds.
+		Weight::from_parts(7_925_570, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x18194fcb5c1fcace44d2d0a004272614` (r:1 w:0)
+	/// The range of component `n` is `[0, 1000]`.
+	fn process_core_count(_n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `97`
+		//  Estimated: `3562`
+		// Minimum execution time: 7_136_000 picoseconds.
+		Weight::from_parts(7_788_194, 3562)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Broker::InstaPoolHistory` (r:0 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	fn process_revenue() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_049_000 picoseconds.
+		Weight::from_parts(6_311_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// 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::SaleInfo` (r:0 w:1)
+	/// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`)
+	/// 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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `6281`
+		//  Estimated: `8499`
+		// Minimum execution time: 47_504_000 picoseconds.
+		Weight::from_parts(49_778_098, 8499)
+			// Standard Error: 109
+			.saturating_add(Weight::from_parts(427, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(15_u64))
+	}
+	/// Storage: `Broker::InstaPoolIo` (r:1 w:0)
+	/// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::InstaPoolHistory` (r:0 w:1)
+	/// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`)
+	fn process_pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `180`
+		//  Estimated: `3493`
+		// Minimum execution time: 9_573_000 picoseconds.
+		Weight::from_parts(10_034_000, 3493)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Broker::Workplan` (r:1 w:1)
+	/// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`)
+	/// Storage: `Broker::Workload` (r:1 w:1)
+	/// Proof: `Broker::Workload` (`max_values`: None, `max_size`: Some(1212), added: 3687, mode: `MaxEncodedLen`)
+	fn process_core_schedule() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1423`
+		//  Estimated: `4681`
+		// Minimum execution time: 21_331_000 picoseconds.
+		Weight::from_parts(22_235_000, 4681)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	fn request_revenue_info_at() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 191_000 picoseconds.
+		Weight::from_parts(234_000, 0)
+	}
+}
diff --git a/substrate/frame/child-bounties/Cargo.toml b/substrate/frame/child-bounties/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2db68263a02d4de1662c698a723417ede145924a
--- /dev/null
+++ b/substrate/frame/child-bounties/Cargo.toml
@@ -0,0 +1,68 @@
+[package]
+name = "pallet-child-bounties"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to manage child bounties"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-bounties = { version = "4.0.0-dev", default-features = false, path = "../bounties" }
+pallet-treasury = { version = "4.0.0-dev", default-features = false, path = "../treasury" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-bounties/std",
+	"pallet-treasury/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-bounties/runtime-benchmarks",
+	"pallet-treasury/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-bounties/try-runtime",
+	"pallet-treasury/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/child-bounties/README.md b/substrate/frame/child-bounties/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..695b6616b1751f087277ee8872ae6536afd560c2
--- /dev/null
+++ b/substrate/frame/child-bounties/README.md
@@ -0,0 +1,29 @@
+# Child Bounties Pallet ( `pallet-child-bounties` )
+
+## Child Bounty
+
+> NOTE: This pallet is tightly coupled with `pallet-treasury` and `pallet-bounties`.
+
+With child bounties, a large bounty proposal can be divided into smaller chunks,
+for parallel execution, and for efficient governance and tracking of spent funds.
+A child bounty is a smaller piece of work, extracted from a parent bounty.
+A curator is assigned after the child bounty is created by the parent bounty curator,
+to be delegated with the responsibility of assigning a payout address once 
+the specified set of tasks is completed.
+
+## Interface
+
+### Dispatchable Functions
+
+Child Bounty protocol:
+
+- `add_child_bounty` - Add a child bounty for a parent bounty to for dividing the work in
+  smaller tasks.
+- `propose_curator` - Assign an account to a child bounty as candidate curator.
+- `accept_curator` - Accept a child bounty assignment from the parent bounty curator,
+  setting a curator deposit.
+- `award_child_bounty` - Close and pay out the specified amount for the completed work.
+- `claim_child_bounty` - Claim a specific child bounty amount from the payout address.
+- `unassign_curator` - Unassign an accepted curator from a specific child bounty.
+- `close_child_bounty` - Cancel the child bounty for a specific treasury amount
+  and close the bounty.
diff --git a/substrate/frame/child-bounties/src/benchmarking.rs b/substrate/frame/child-bounties/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1973564d0dc1dacca9d30421cda2b4b03771cef9
--- /dev/null
+++ b/substrate/frame/child-bounties/src/benchmarking.rs
@@ -0,0 +1,316 @@
+// 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.
+
+//! Child-bounties pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller, BenchmarkError};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+
+use crate::Pallet as ChildBounties;
+use pallet_bounties::Pallet as Bounties;
+use pallet_treasury::Pallet as Treasury;
+
+const SEED: u32 = 0;
+
+#[derive(Clone)]
+struct BenchmarkChildBounty<T: Config> {
+	/// Bounty ID.
+	bounty_id: BountyIndex,
+	/// ChildBounty ID.
+	child_bounty_id: BountyIndex,
+	/// The account proposing it.
+	caller: T::AccountId,
+	/// The master curator account.
+	curator: T::AccountId,
+	/// The child-bounty curator account.
+	child_curator: T::AccountId,
+	/// The (total) amount that should be paid if the bounty is rewarded.
+	value: BalanceOf<T>,
+	/// The curator fee. included in value.
+	fee: BalanceOf<T>,
+	/// The (total) amount that should be paid if the child-bounty is rewarded.
+	child_bounty_value: BalanceOf<T>,
+	/// The child-bounty curator fee. included in value.
+	child_bounty_fee: BalanceOf<T>,
+	/// Bounty description.
+	reason: Vec<u8>,
+}
+
+fn setup_bounty<T: Config>(
+	user: u32,
+	description: u32,
+) -> (T::AccountId, T::AccountId, BalanceOf<T>, BalanceOf<T>, Vec<u8>) {
+	let caller = account("caller", user, SEED);
+	let value: BalanceOf<T> = T::BountyValueMinimum::get().saturating_mul(100u32.into());
+	let fee = value / 2u32.into();
+	let deposit = T::BountyDepositBase::get() +
+		T::DataDepositPerByte::get() * T::MaximumReasonLength::get().into();
+	let _ = T::Currency::make_free_balance_be(&caller, deposit + T::Currency::minimum_balance());
+	let curator = account("curator", user, SEED);
+	let _ = T::Currency::make_free_balance_be(
+		&curator,
+		fee / 2u32.into() + T::Currency::minimum_balance(),
+	);
+	let reason = vec![0; description as usize];
+	(caller, curator, fee, value, reason)
+}
+
+fn setup_child_bounty<T: Config>(user: u32, description: u32) -> BenchmarkChildBounty<T> {
+	let (caller, curator, fee, value, reason) = setup_bounty::<T>(user, description);
+	let child_curator = account("child-curator", user, SEED);
+	let _ = T::Currency::make_free_balance_be(
+		&child_curator,
+		fee / 2u32.into() + T::Currency::minimum_balance(),
+	);
+	let child_bounty_value = (value - fee) / 4u32.into();
+	let child_bounty_fee = child_bounty_value / 2u32.into();
+
+	BenchmarkChildBounty::<T> {
+		bounty_id: 0,
+		child_bounty_id: 0,
+		caller,
+		curator,
+		child_curator,
+		value,
+		fee,
+		child_bounty_value,
+		child_bounty_fee,
+		reason,
+	}
+}
+
+fn activate_bounty<T: Config>(
+	user: u32,
+	description: u32,
+) -> Result<BenchmarkChildBounty<T>, BenchmarkError> {
+	let mut child_bounty_setup = setup_child_bounty::<T>(user, description);
+	let curator_lookup = T::Lookup::unlookup(child_bounty_setup.curator.clone());
+	Bounties::<T>::propose_bounty(
+		RawOrigin::Signed(child_bounty_setup.caller.clone()).into(),
+		child_bounty_setup.value,
+		child_bounty_setup.reason.clone(),
+	)?;
+
+	child_bounty_setup.bounty_id = Bounties::<T>::bounty_count() - 1;
+
+	let approve_origin =
+		T::SpendOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	Bounties::<T>::approve_bounty(approve_origin, child_bounty_setup.bounty_id)?;
+	Treasury::<T>::on_initialize(BlockNumberFor::<T>::zero());
+	Bounties::<T>::propose_curator(
+		RawOrigin::Root.into(),
+		child_bounty_setup.bounty_id,
+		curator_lookup,
+		child_bounty_setup.fee,
+	)?;
+	Bounties::<T>::accept_curator(
+		RawOrigin::Signed(child_bounty_setup.curator.clone()).into(),
+		child_bounty_setup.bounty_id,
+	)?;
+
+	Ok(child_bounty_setup)
+}
+
+fn activate_child_bounty<T: Config>(
+	user: u32,
+	description: u32,
+) -> Result<BenchmarkChildBounty<T>, BenchmarkError> {
+	let mut bounty_setup = activate_bounty::<T>(user, description)?;
+	let child_curator_lookup = T::Lookup::unlookup(bounty_setup.child_curator.clone());
+
+	ChildBounties::<T>::add_child_bounty(
+		RawOrigin::Signed(bounty_setup.curator.clone()).into(),
+		bounty_setup.bounty_id,
+		bounty_setup.child_bounty_value,
+		bounty_setup.reason.clone(),
+	)?;
+
+	bounty_setup.child_bounty_id = ChildBountyCount::<T>::get() - 1;
+
+	ChildBounties::<T>::propose_curator(
+		RawOrigin::Signed(bounty_setup.curator.clone()).into(),
+		bounty_setup.bounty_id,
+		bounty_setup.child_bounty_id,
+		child_curator_lookup,
+		bounty_setup.child_bounty_fee,
+	)?;
+
+	ChildBounties::<T>::accept_curator(
+		RawOrigin::Signed(bounty_setup.child_curator.clone()).into(),
+		bounty_setup.bounty_id,
+		bounty_setup.child_bounty_id,
+	)?;
+
+	Ok(bounty_setup)
+}
+
+fn setup_pot_account<T: Config>() {
+	let pot_account = Bounties::<T>::account_id();
+	let value = T::Currency::minimum_balance().saturating_mul(1_000_000_000u32.into());
+	let _ = T::Currency::make_free_balance_be(&pot_account, value);
+}
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+benchmarks! {
+	add_child_bounty {
+		let d in 0 .. T::MaximumReasonLength::get();
+		setup_pot_account::<T>();
+		let bounty_setup = activate_bounty::<T>(0, d)?;
+	}: _(RawOrigin::Signed(bounty_setup.curator), bounty_setup.bounty_id,
+			bounty_setup.child_bounty_value, bounty_setup.reason.clone())
+	verify {
+		assert_last_event::<T>(Event::Added {
+			index: bounty_setup.bounty_id,
+			child_index: bounty_setup.child_bounty_id,
+		}.into())
+	}
+
+	propose_curator {
+		setup_pot_account::<T>();
+		let bounty_setup = activate_bounty::<T>(0, T::MaximumReasonLength::get())?;
+		let child_curator_lookup = T::Lookup::unlookup(bounty_setup.child_curator.clone());
+
+		ChildBounties::<T>::add_child_bounty(
+			RawOrigin::Signed(bounty_setup.curator.clone()).into(),
+			bounty_setup.bounty_id,
+			bounty_setup.child_bounty_value,
+			bounty_setup.reason.clone(),
+		)?;
+		let child_bounty_id = ChildBountyCount::<T>::get() - 1;
+
+	}: _(RawOrigin::Signed(bounty_setup.curator), bounty_setup.bounty_id,
+			child_bounty_id, child_curator_lookup, bounty_setup.child_bounty_fee)
+
+	accept_curator {
+		setup_pot_account::<T>();
+		let mut bounty_setup = activate_bounty::<T>(0, T::MaximumReasonLength::get())?;
+		let child_curator_lookup = T::Lookup::unlookup(bounty_setup.child_curator.clone());
+
+		ChildBounties::<T>::add_child_bounty(
+			RawOrigin::Signed(bounty_setup.curator.clone()).into(),
+			bounty_setup.bounty_id,
+			bounty_setup.child_bounty_value,
+			bounty_setup.reason.clone(),
+		)?;
+		bounty_setup.child_bounty_id = ChildBountyCount::<T>::get() - 1;
+
+		ChildBounties::<T>::propose_curator(
+			RawOrigin::Signed(bounty_setup.curator.clone()).into(),
+			bounty_setup.bounty_id,
+			bounty_setup.child_bounty_id,
+			child_curator_lookup,
+			bounty_setup.child_bounty_fee,
+		)?;
+	}: _(RawOrigin::Signed(bounty_setup.child_curator), bounty_setup.bounty_id,
+			bounty_setup.child_bounty_id)
+
+	// Worst case when curator is inactive and any sender un-assigns the curator.
+	unassign_curator {
+		setup_pot_account::<T>();
+		let bounty_setup = activate_child_bounty::<T>(0, T::MaximumReasonLength::get())?;
+		Treasury::<T>::on_initialize(BlockNumberFor::<T>::zero());
+		frame_system::Pallet::<T>::set_block_number(T::BountyUpdatePeriod::get() + 1u32.into());
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), bounty_setup.bounty_id,
+			bounty_setup.child_bounty_id)
+
+	award_child_bounty {
+		setup_pot_account::<T>();
+		let bounty_setup = activate_child_bounty::<T>(0, T::MaximumReasonLength::get())?;
+		let beneficiary_account: T::AccountId = account("beneficiary", 0, SEED);
+		let beneficiary = T::Lookup::unlookup(beneficiary_account.clone());
+	}: _(RawOrigin::Signed(bounty_setup.child_curator), bounty_setup.bounty_id,
+			bounty_setup.child_bounty_id, beneficiary)
+	verify {
+		assert_last_event::<T>(Event::Awarded {
+			index: bounty_setup.bounty_id,
+			child_index: bounty_setup.child_bounty_id,
+			beneficiary: beneficiary_account
+		}.into())
+	}
+
+	claim_child_bounty {
+		setup_pot_account::<T>();
+		let bounty_setup = activate_child_bounty::<T>(0, T::MaximumReasonLength::get())?;
+		let beneficiary_account: T::AccountId = account("beneficiary", 0, SEED);
+		let beneficiary = T::Lookup::unlookup(beneficiary_account);
+
+		ChildBounties::<T>::award_child_bounty(
+			RawOrigin::Signed(bounty_setup.child_curator.clone()).into(),
+			bounty_setup.bounty_id,
+			bounty_setup.child_bounty_id,
+			beneficiary
+		)?;
+
+		let beneficiary_account: T::AccountId = account("beneficiary", 0, SEED);
+		let beneficiary = T::Lookup::unlookup(beneficiary_account.clone());
+
+		frame_system::Pallet::<T>::set_block_number(T::BountyDepositPayoutDelay::get());
+		ensure!(T::Currency::free_balance(&beneficiary_account).is_zero(),
+			"Beneficiary already has balance.");
+
+	}: _(RawOrigin::Signed(bounty_setup.curator), bounty_setup.bounty_id,
+			bounty_setup.child_bounty_id)
+	verify {
+		ensure!(!T::Currency::free_balance(&beneficiary_account).is_zero(),
+			"Beneficiary didn't get paid.");
+	}
+
+	// Best case scenario.
+	close_child_bounty_added {
+		setup_pot_account::<T>();
+		let mut bounty_setup = activate_bounty::<T>(0, T::MaximumReasonLength::get())?;
+
+		ChildBounties::<T>::add_child_bounty(
+			RawOrigin::Signed(bounty_setup.curator.clone()).into(),
+			bounty_setup.bounty_id,
+			bounty_setup.child_bounty_value,
+			bounty_setup.reason.clone(),
+		)?;
+		bounty_setup.child_bounty_id = ChildBountyCount::<T>::get() - 1;
+
+	}: close_child_bounty(RawOrigin::Root, bounty_setup.bounty_id,
+		bounty_setup.child_bounty_id)
+	verify {
+		assert_last_event::<T>(Event::Canceled {
+			index: bounty_setup.bounty_id,
+			child_index: bounty_setup.child_bounty_id
+		}.into())
+	}
+
+	// Worst case scenario.
+	close_child_bounty_active {
+		setup_pot_account::<T>();
+		let bounty_setup = activate_child_bounty::<T>(0, T::MaximumReasonLength::get())?;
+		Treasury::<T>::on_initialize(BlockNumberFor::<T>::zero());
+	}: close_child_bounty(RawOrigin::Root, bounty_setup.bounty_id, bounty_setup.child_bounty_id)
+	verify {
+		assert_last_event::<T>(Event::Canceled {
+			index: bounty_setup.bounty_id,
+			child_index: bounty_setup.child_bounty_id,
+		}.into())
+	}
+
+	impl_benchmark_test_suite!(ChildBounties, crate::tests::new_test_ext(), crate::tests::Test)
+}
diff --git a/substrate/frame/child-bounties/src/lib.rs b/substrate/frame/child-bounties/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1eedeaa5a1ae3c5aa6b3804117921eab63768d1e
--- /dev/null
+++ b/substrate/frame/child-bounties/src/lib.rs
@@ -0,0 +1,914 @@
+// 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.
+
+//! # Child Bounties Pallet ( `pallet-child-bounties` )
+//!
+//! ## Child Bounty
+//!
+//! > NOTE: This pallet is tightly coupled with `pallet-treasury` and `pallet-bounties`.
+//!
+//! With child bounties, a large bounty proposal can be divided into smaller chunks,
+//! for parallel execution, and for efficient governance and tracking of spent funds.
+//! A child bounty is a smaller piece of work, extracted from a parent bounty.
+//! A curator is assigned after the child bounty is created by the parent bounty curator,
+//! to be delegated with the responsibility of assigning a payout address once the specified
+//! set of tasks is completed.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! Child Bounty protocol:
+//! - `add_child_bounty` - Add a child bounty for a parent bounty to for dividing the work in
+//!   smaller tasks.
+//! - `propose_curator` - Assign an account to a child bounty as candidate curator.
+//! - `accept_curator` - Accept a child bounty assignment from the parent bounty curator, setting a
+//!   curator deposit.
+//! - `award_child_bounty` - Close and pay out the specified amount for the completed work.
+//! - `claim_child_bounty` - Claim a specific child bounty amount from the payout address.
+//! - `unassign_curator` - Unassign an accepted curator from a specific child bounty.
+//! - `close_child_bounty` - Cancel the child bounty for a specific treasury amount and close the
+//!   bounty.
+
+// Most of the business logic in this pallet has been
+// originally contributed by "https://github.com/shamb0",
+// as part of the PR - https://github.com/paritytech/substrate/pull/7965.
+// The code has been moved here and then refactored in order to
+// extract child bounties as a separate pallet.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod tests;
+pub mod weights;
+
+use sp_std::prelude::*;
+
+use frame_support::traits::{
+	Currency,
+	ExistenceRequirement::{AllowDeath, KeepAlive},
+	Get, OnUnbalanced, ReservableCurrency, WithdrawReasons,
+};
+
+use sp_runtime::{
+	traits::{AccountIdConversion, BadOrigin, CheckedSub, Saturating, StaticLookup, Zero},
+	DispatchResult, RuntimeDebug,
+};
+
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+use pallet_bounties::BountyStatus;
+use scale_info::TypeInfo;
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+type BalanceOf<T> = pallet_treasury::BalanceOf<T>;
+type BountiesError<T> = pallet_bounties::Error<T>;
+type BountyIndex = pallet_bounties::BountyIndex;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// A child bounty proposal.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ChildBounty<AccountId, Balance, BlockNumber> {
+	/// The parent of this child-bounty.
+	parent_bounty: BountyIndex,
+	/// The (total) amount that should be paid if this child-bounty is rewarded.
+	value: Balance,
+	/// The child bounty curator fee.
+	fee: Balance,
+	/// The deposit of child-bounty curator.
+	curator_deposit: Balance,
+	/// The status of this child-bounty.
+	status: ChildBountyStatus<AccountId, BlockNumber>,
+}
+
+/// The status of a child-bounty.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum ChildBountyStatus<AccountId, BlockNumber> {
+	/// The child-bounty is added and waiting for curator assignment.
+	Added,
+	/// A curator has been proposed by the parent bounty curator. Waiting for
+	/// acceptance from the child-bounty curator.
+	CuratorProposed {
+		/// The assigned child-bounty curator of this bounty.
+		curator: AccountId,
+	},
+	/// The child-bounty is active and waiting to be awarded.
+	Active {
+		/// The curator of this child-bounty.
+		curator: AccountId,
+	},
+	/// The child-bounty is awarded and waiting to released after a delay.
+	PendingPayout {
+		/// The curator of this child-bounty.
+		curator: AccountId,
+		/// The beneficiary of the child-bounty.
+		beneficiary: AccountId,
+		/// When the child-bounty can be claimed.
+		unlock_at: BlockNumber,
+	},
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+
+	use super::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config:
+		frame_system::Config + pallet_treasury::Config + pallet_bounties::Config
+	{
+		/// Maximum number of child bounties that can be added to a parent bounty.
+		#[pallet::constant]
+		type MaxActiveChildBountyCount: Get<u32>;
+
+		/// Minimum value for a child-bounty.
+		#[pallet::constant]
+		type ChildBountyValueMinimum: Get<BalanceOf<Self>>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The parent bounty is not in active state.
+		ParentBountyNotActive,
+		/// The bounty balance is not enough to add new child-bounty.
+		InsufficientBountyBalance,
+		/// Number of child bounties exceeds limit `MaxActiveChildBountyCount`.
+		TooManyChildBounties,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A child-bounty is added.
+		Added { index: BountyIndex, child_index: BountyIndex },
+		/// A child-bounty is awarded to a beneficiary.
+		Awarded { index: BountyIndex, child_index: BountyIndex, beneficiary: T::AccountId },
+		/// A child-bounty is claimed by beneficiary.
+		Claimed {
+			index: BountyIndex,
+			child_index: BountyIndex,
+			payout: BalanceOf<T>,
+			beneficiary: T::AccountId,
+		},
+		/// A child-bounty is cancelled.
+		Canceled { index: BountyIndex, child_index: BountyIndex },
+	}
+
+	/// Number of total child bounties.
+	#[pallet::storage]
+	#[pallet::getter(fn child_bounty_count)]
+	pub type ChildBountyCount<T: Config> = StorageValue<_, BountyIndex, ValueQuery>;
+
+	/// Number of child bounties per parent bounty.
+	/// Map of parent bounty index to number of child bounties.
+	#[pallet::storage]
+	#[pallet::getter(fn parent_child_bounties)]
+	pub type ParentChildBounties<T: Config> =
+		StorageMap<_, Twox64Concat, BountyIndex, u32, ValueQuery>;
+
+	/// Child bounties that have been added.
+	#[pallet::storage]
+	#[pallet::getter(fn child_bounties)]
+	pub type ChildBounties<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		BountyIndex,
+		Twox64Concat,
+		BountyIndex,
+		ChildBounty<T::AccountId, BalanceOf<T>, BlockNumberFor<T>>,
+	>;
+
+	/// The description of each child-bounty.
+	#[pallet::storage]
+	#[pallet::getter(fn child_bounty_descriptions)]
+	pub type ChildBountyDescriptions<T: Config> =
+		StorageMap<_, Twox64Concat, BountyIndex, BoundedVec<u8, T::MaximumReasonLength>>;
+
+	/// The cumulative child-bounty curator fee for each parent bounty.
+	#[pallet::storage]
+	#[pallet::getter(fn children_curator_fees)]
+	pub type ChildrenCuratorFees<T: Config> =
+		StorageMap<_, Twox64Concat, BountyIndex, BalanceOf<T>, ValueQuery>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Add a new child-bounty.
+		///
+		/// The dispatch origin for this call must be the curator of parent
+		/// bounty and the parent bounty must be in "active" state.
+		///
+		/// Child-bounty gets added successfully & fund gets transferred from
+		/// parent bounty to child-bounty account, if parent bounty has enough
+		/// funds, else the call fails.
+		///
+		/// Upper bound to maximum number of active  child bounties that can be
+		/// added are managed via runtime trait config
+		/// [`Config::MaxActiveChildBountyCount`].
+		///
+		/// If the call is success, the status of child-bounty is updated to
+		/// "Added".
+		///
+		/// - `parent_bounty_id`: Index of parent bounty for which child-bounty is being added.
+		/// - `value`: Value for executing the proposal.
+		/// - `description`: Text description for the child-bounty.
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config>::WeightInfo::add_child_bounty(description.len() as u32))]
+		pub fn add_child_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] parent_bounty_id: BountyIndex,
+			#[pallet::compact] value: BalanceOf<T>,
+			description: Vec<u8>,
+		) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+
+			// Verify the arguments.
+			let bounded_description =
+				description.try_into().map_err(|_| BountiesError::<T>::ReasonTooBig)?;
+			ensure!(value >= T::ChildBountyValueMinimum::get(), BountiesError::<T>::InvalidValue);
+			ensure!(
+				Self::parent_child_bounties(parent_bounty_id) <=
+					T::MaxActiveChildBountyCount::get() as u32,
+				Error::<T>::TooManyChildBounties,
+			);
+
+			let (curator, _) = Self::ensure_bounty_active(parent_bounty_id)?;
+			ensure!(signer == curator, BountiesError::<T>::RequireCurator);
+
+			// Read parent bounty account info.
+			let parent_bounty_account =
+				pallet_bounties::Pallet::<T>::bounty_account_id(parent_bounty_id);
+
+			// Ensure parent bounty has enough balance after adding child-bounty.
+			let bounty_balance = T::Currency::free_balance(&parent_bounty_account);
+			let new_bounty_balance = bounty_balance
+				.checked_sub(&value)
+				.ok_or(Error::<T>::InsufficientBountyBalance)?;
+			T::Currency::ensure_can_withdraw(
+				&parent_bounty_account,
+				value,
+				WithdrawReasons::TRANSFER,
+				new_bounty_balance,
+			)?;
+
+			// Get child-bounty ID.
+			let child_bounty_id = Self::child_bounty_count();
+			let child_bounty_account = Self::child_bounty_account_id(child_bounty_id);
+
+			// Transfer funds from parent bounty to child-bounty.
+			T::Currency::transfer(&parent_bounty_account, &child_bounty_account, value, KeepAlive)?;
+
+			// Increment the active child-bounty count.
+			<ParentChildBounties<T>>::mutate(parent_bounty_id, |count| count.saturating_inc());
+			<ChildBountyCount<T>>::put(child_bounty_id.saturating_add(1));
+
+			// Create child-bounty instance.
+			Self::create_child_bounty(
+				parent_bounty_id,
+				child_bounty_id,
+				value,
+				bounded_description,
+			);
+			Ok(())
+		}
+
+		/// Propose curator for funded child-bounty.
+		///
+		/// The dispatch origin for this call must be curator of parent bounty.
+		///
+		/// Parent bounty must be in active state, for this child-bounty call to
+		/// work.
+		///
+		/// Child-bounty must be in "Added" state, for processing the call. And
+		/// state of child-bounty is moved to "CuratorProposed" on successful
+		/// call completion.
+		///
+		/// - `parent_bounty_id`: Index of parent bounty.
+		/// - `child_bounty_id`: Index of child bounty.
+		/// - `curator`: Address of child-bounty curator.
+		/// - `fee`: payment fee to child-bounty curator for execution.
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as Config>::WeightInfo::propose_curator())]
+		pub fn propose_curator(
+			origin: OriginFor<T>,
+			#[pallet::compact] parent_bounty_id: BountyIndex,
+			#[pallet::compact] child_bounty_id: BountyIndex,
+			curator: AccountIdLookupOf<T>,
+			#[pallet::compact] fee: BalanceOf<T>,
+		) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+			let child_bounty_curator = T::Lookup::lookup(curator)?;
+
+			let (curator, _) = Self::ensure_bounty_active(parent_bounty_id)?;
+			ensure!(signer == curator, BountiesError::<T>::RequireCurator);
+
+			// Mutate the child-bounty instance.
+			ChildBounties::<T>::try_mutate_exists(
+				parent_bounty_id,
+				child_bounty_id,
+				|maybe_child_bounty| -> DispatchResult {
+					let child_bounty =
+						maybe_child_bounty.as_mut().ok_or(BountiesError::<T>::InvalidIndex)?;
+
+					// Ensure child-bounty is in expected state.
+					ensure!(
+						child_bounty.status == ChildBountyStatus::Added,
+						BountiesError::<T>::UnexpectedStatus,
+					);
+
+					// Ensure child-bounty curator fee is less than child-bounty value.
+					ensure!(fee < child_bounty.value, BountiesError::<T>::InvalidFee);
+
+					// Add child-bounty curator fee to the cumulative sum. To be
+					// subtracted from the parent bounty curator when claiming
+					// bounty.
+					ChildrenCuratorFees::<T>::mutate(parent_bounty_id, |value| {
+						*value = value.saturating_add(fee)
+					});
+
+					// Update the child-bounty curator fee.
+					child_bounty.fee = fee;
+
+					// Update the child-bounty state.
+					child_bounty.status =
+						ChildBountyStatus::CuratorProposed { curator: child_bounty_curator };
+
+					Ok(())
+				},
+			)
+		}
+
+		/// Accept the curator role for the child-bounty.
+		///
+		/// The dispatch origin for this call must be the curator of this
+		/// child-bounty.
+		///
+		/// A deposit will be reserved from the curator and refund upon
+		/// successful payout or cancellation.
+		///
+		/// Fee for curator is deducted from curator fee of parent bounty.
+		///
+		/// Parent bounty must be in active state, for this child-bounty call to
+		/// work.
+		///
+		/// Child-bounty must be in "CuratorProposed" state, for processing the
+		/// call. And state of child-bounty is moved to "Active" on successful
+		/// call completion.
+		///
+		/// - `parent_bounty_id`: Index of parent bounty.
+		/// - `child_bounty_id`: Index of child bounty.
+		#[pallet::call_index(2)]
+		#[pallet::weight(<T as Config>::WeightInfo::accept_curator())]
+		pub fn accept_curator(
+			origin: OriginFor<T>,
+			#[pallet::compact] parent_bounty_id: BountyIndex,
+			#[pallet::compact] child_bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+
+			let (parent_curator, _) = Self::ensure_bounty_active(parent_bounty_id)?;
+			// Mutate child-bounty.
+			ChildBounties::<T>::try_mutate_exists(
+				parent_bounty_id,
+				child_bounty_id,
+				|maybe_child_bounty| -> DispatchResult {
+					let child_bounty =
+						maybe_child_bounty.as_mut().ok_or(BountiesError::<T>::InvalidIndex)?;
+
+					// Ensure child-bounty is in expected state.
+					if let ChildBountyStatus::CuratorProposed { ref curator } = child_bounty.status
+					{
+						ensure!(signer == *curator, BountiesError::<T>::RequireCurator);
+
+						// Reserve child-bounty curator deposit.
+						let deposit = Self::calculate_curator_deposit(
+							&parent_curator,
+							curator,
+							&child_bounty.fee,
+						);
+
+						T::Currency::reserve(curator, deposit)?;
+						child_bounty.curator_deposit = deposit;
+
+						child_bounty.status =
+							ChildBountyStatus::Active { curator: curator.clone() };
+						Ok(())
+					} else {
+						Err(BountiesError::<T>::UnexpectedStatus.into())
+					}
+				},
+			)
+		}
+
+		/// Unassign curator from a child-bounty.
+		///
+		/// The dispatch origin for this call can be either `RejectOrigin`, or
+		/// the curator of the parent bounty, or any signed origin.
+		///
+		/// For the origin other than T::RejectOrigin and the child-bounty
+		/// curator, parent bounty must be in active state, for this call to
+		/// work. We allow child-bounty curator and T::RejectOrigin to execute
+		/// this call irrespective of the parent bounty state.
+		///
+		/// If this function is called by the `RejectOrigin` or the
+		/// parent bounty curator, we assume that the child-bounty curator is
+		/// malicious or inactive. As a result, child-bounty curator deposit is
+		/// slashed.
+		///
+		/// If the origin is the child-bounty curator, we take this as a sign
+		/// that they are unable to do their job, and are willingly giving up.
+		/// We could slash the deposit, but for now we allow them to unreserve
+		/// their deposit and exit without issue. (We may want to change this if
+		/// it is abused.)
+		///
+		/// Finally, the origin can be anyone iff the child-bounty curator is
+		/// "inactive". Expiry update due of parent bounty is used to estimate
+		/// inactive state of child-bounty curator.
+		///
+		/// This allows anyone in the community to call out that a child-bounty
+		/// curator is not doing their due diligence, and we should pick a new
+		/// one. In this case the child-bounty curator deposit is slashed.
+		///
+		/// State of child-bounty is moved to Added state on successful call
+		/// completion.
+		///
+		/// - `parent_bounty_id`: Index of parent bounty.
+		/// - `child_bounty_id`: Index of child bounty.
+		#[pallet::call_index(3)]
+		#[pallet::weight(<T as Config>::WeightInfo::unassign_curator())]
+		pub fn unassign_curator(
+			origin: OriginFor<T>,
+			#[pallet::compact] parent_bounty_id: BountyIndex,
+			#[pallet::compact] child_bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let maybe_sender = ensure_signed(origin.clone())
+				.map(Some)
+				.or_else(|_| T::RejectOrigin::ensure_origin(origin).map(|_| None))?;
+
+			ChildBounties::<T>::try_mutate_exists(
+				parent_bounty_id,
+				child_bounty_id,
+				|maybe_child_bounty| -> DispatchResult {
+					let child_bounty =
+						maybe_child_bounty.as_mut().ok_or(BountiesError::<T>::InvalidIndex)?;
+
+					let slash_curator = |curator: &T::AccountId,
+					                     curator_deposit: &mut BalanceOf<T>| {
+						let imbalance = T::Currency::slash_reserved(curator, *curator_deposit).0;
+						T::OnSlash::on_unbalanced(imbalance);
+						*curator_deposit = Zero::zero();
+					};
+
+					match child_bounty.status {
+						ChildBountyStatus::Added => {
+							// No curator to unassign at this point.
+							return Err(BountiesError::<T>::UnexpectedStatus.into())
+						},
+						ChildBountyStatus::CuratorProposed { ref curator } => {
+							// A child-bounty curator has been proposed, but not accepted yet.
+							// Either `RejectOrigin`, parent bounty curator or the proposed
+							// child-bounty curator can unassign the child-bounty curator.
+							ensure!(
+								maybe_sender.map_or(true, |sender| {
+									sender == *curator ||
+										Self::ensure_bounty_active(parent_bounty_id)
+											.map_or(false, |(parent_curator, _)| {
+												sender == parent_curator
+											})
+								}),
+								BadOrigin
+							);
+							// Continue to change bounty status below.
+						},
+						ChildBountyStatus::Active { ref curator } => {
+							// The child-bounty is active.
+							match maybe_sender {
+								// If the `RejectOrigin` is calling this function, slash the curator
+								// deposit.
+								None => {
+									slash_curator(curator, &mut child_bounty.curator_deposit);
+									// Continue to change child-bounty status below.
+								},
+								Some(sender) if sender == *curator => {
+									// This is the child-bounty curator, willingly giving up their
+									// role. Give back their deposit.
+									T::Currency::unreserve(curator, child_bounty.curator_deposit);
+									// Reset curator deposit.
+									child_bounty.curator_deposit = Zero::zero();
+									// Continue to change bounty status below.
+								},
+								Some(sender) => {
+									let (parent_curator, update_due) =
+										Self::ensure_bounty_active(parent_bounty_id)?;
+									if sender == parent_curator ||
+										update_due < frame_system::Pallet::<T>::block_number()
+									{
+										// Slash the child-bounty curator if
+										// + the call is made by the parent bounty curator.
+										// + or the curator is inactive.
+										slash_curator(curator, &mut child_bounty.curator_deposit);
+									// Continue to change bounty status below.
+									} else {
+										// Curator has more time to give an update.
+										return Err(BountiesError::<T>::Premature.into())
+									}
+								},
+							}
+						},
+						ChildBountyStatus::PendingPayout { ref curator, .. } => {
+							let (parent_curator, _) = Self::ensure_bounty_active(parent_bounty_id)?;
+							ensure!(
+								maybe_sender.map_or(true, |sender| parent_curator == sender),
+								BadOrigin,
+							);
+							slash_curator(curator, &mut child_bounty.curator_deposit);
+							// Continue to change child-bounty status below.
+						},
+					};
+					// Move the child-bounty state to Added.
+					child_bounty.status = ChildBountyStatus::Added;
+					Ok(())
+				},
+			)
+		}
+
+		/// Award child-bounty to a beneficiary.
+		///
+		/// The beneficiary will be able to claim the funds after a delay.
+		///
+		/// The dispatch origin for this call must be the parent curator or
+		/// curator of this child-bounty.
+		///
+		/// Parent bounty must be in active state, for this child-bounty call to
+		/// work.
+		///
+		/// Child-bounty must be in active state, for processing the call. And
+		/// state of child-bounty is moved to "PendingPayout" on successful call
+		/// completion.
+		///
+		/// - `parent_bounty_id`: Index of parent bounty.
+		/// - `child_bounty_id`: Index of child bounty.
+		/// - `beneficiary`: Beneficiary account.
+		#[pallet::call_index(4)]
+		#[pallet::weight(<T as Config>::WeightInfo::award_child_bounty())]
+		pub fn award_child_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] parent_bounty_id: BountyIndex,
+			#[pallet::compact] child_bounty_id: BountyIndex,
+			beneficiary: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+
+			// Ensure parent bounty exists, and is active.
+			let (parent_curator, _) = Self::ensure_bounty_active(parent_bounty_id)?;
+
+			ChildBounties::<T>::try_mutate_exists(
+				parent_bounty_id,
+				child_bounty_id,
+				|maybe_child_bounty| -> DispatchResult {
+					let child_bounty =
+						maybe_child_bounty.as_mut().ok_or(BountiesError::<T>::InvalidIndex)?;
+
+					// Ensure child-bounty is in active state.
+					if let ChildBountyStatus::Active { ref curator } = child_bounty.status {
+						ensure!(
+							signer == *curator || signer == parent_curator,
+							BountiesError::<T>::RequireCurator,
+						);
+						// Move the child-bounty state to pending payout.
+						child_bounty.status = ChildBountyStatus::PendingPayout {
+							curator: signer,
+							beneficiary: beneficiary.clone(),
+							unlock_at: frame_system::Pallet::<T>::block_number() +
+								T::BountyDepositPayoutDelay::get(),
+						};
+						Ok(())
+					} else {
+						Err(BountiesError::<T>::UnexpectedStatus.into())
+					}
+				},
+			)?;
+
+			// Trigger the event Awarded.
+			Self::deposit_event(Event::<T>::Awarded {
+				index: parent_bounty_id,
+				child_index: child_bounty_id,
+				beneficiary,
+			});
+
+			Ok(())
+		}
+
+		/// Claim the payout from an awarded child-bounty after payout delay.
+		///
+		/// The dispatch origin for this call may be any signed origin.
+		///
+		/// Call works independent of parent bounty state, No need for parent
+		/// bounty to be in active state.
+		///
+		/// The Beneficiary is paid out with agreed bounty value. Curator fee is
+		/// paid & curator deposit is unreserved.
+		///
+		/// Child-bounty must be in "PendingPayout" state, for processing the
+		/// call. And instance of child-bounty is removed from the state on
+		/// successful call completion.
+		///
+		/// - `parent_bounty_id`: Index of parent bounty.
+		/// - `child_bounty_id`: Index of child bounty.
+		#[pallet::call_index(5)]
+		#[pallet::weight(<T as Config>::WeightInfo::claim_child_bounty())]
+		pub fn claim_child_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] parent_bounty_id: BountyIndex,
+			#[pallet::compact] child_bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let _ = ensure_signed(origin)?;
+
+			// Ensure child-bounty is in expected state.
+			ChildBounties::<T>::try_mutate_exists(
+				parent_bounty_id,
+				child_bounty_id,
+				|maybe_child_bounty| -> DispatchResult {
+					let child_bounty =
+						maybe_child_bounty.as_mut().ok_or(BountiesError::<T>::InvalidIndex)?;
+
+					if let ChildBountyStatus::PendingPayout {
+						ref curator,
+						ref beneficiary,
+						ref unlock_at,
+					} = child_bounty.status
+					{
+						// Ensure block number is elapsed for processing the
+						// claim.
+						ensure!(
+							frame_system::Pallet::<T>::block_number() >= *unlock_at,
+							BountiesError::<T>::Premature,
+						);
+
+						// Make curator fee payment.
+						let child_bounty_account = Self::child_bounty_account_id(child_bounty_id);
+						let balance = T::Currency::free_balance(&child_bounty_account);
+						let curator_fee = child_bounty.fee.min(balance);
+						let payout = balance.saturating_sub(curator_fee);
+
+						// Unreserve the curator deposit. Should not fail
+						// because the deposit is always reserved when curator is
+						// assigned.
+						let _ = T::Currency::unreserve(curator, child_bounty.curator_deposit);
+
+						// Make payout to child-bounty curator.
+						// Should not fail because curator fee is always less than bounty value.
+						let fee_transfer_result = T::Currency::transfer(
+							&child_bounty_account,
+							curator,
+							curator_fee,
+							AllowDeath,
+						);
+						debug_assert!(fee_transfer_result.is_ok());
+
+						// Make payout to beneficiary.
+						// Should not fail.
+						let payout_transfer_result = T::Currency::transfer(
+							&child_bounty_account,
+							beneficiary,
+							payout,
+							AllowDeath,
+						);
+						debug_assert!(payout_transfer_result.is_ok());
+
+						// Trigger the Claimed event.
+						Self::deposit_event(Event::<T>::Claimed {
+							index: parent_bounty_id,
+							child_index: child_bounty_id,
+							payout,
+							beneficiary: beneficiary.clone(),
+						});
+
+						// Update the active child-bounty tracking count.
+						<ParentChildBounties<T>>::mutate(parent_bounty_id, |count| {
+							count.saturating_dec()
+						});
+
+						// Remove the child-bounty description.
+						<ChildBountyDescriptions<T>>::remove(child_bounty_id);
+
+						// Remove the child-bounty instance from the state.
+						*maybe_child_bounty = None;
+
+						Ok(())
+					} else {
+						Err(BountiesError::<T>::UnexpectedStatus.into())
+					}
+				},
+			)
+		}
+
+		/// Cancel a proposed or active child-bounty. Child-bounty account funds
+		/// are transferred to parent bounty account. The child-bounty curator
+		/// deposit may be unreserved if possible.
+		///
+		/// The dispatch origin for this call must be either parent curator or
+		/// `T::RejectOrigin`.
+		///
+		/// If the state of child-bounty is `Active`, curator deposit is
+		/// unreserved.
+		///
+		/// If the state of child-bounty is `PendingPayout`, call fails &
+		/// returns `PendingPayout` error.
+		///
+		/// For the origin other than T::RejectOrigin, parent bounty must be in
+		/// active state, for this child-bounty call to work. For origin
+		/// T::RejectOrigin execution is forced.
+		///
+		/// Instance of child-bounty is removed from the state on successful
+		/// call completion.
+		///
+		/// - `parent_bounty_id`: Index of parent bounty.
+		/// - `child_bounty_id`: Index of child bounty.
+		#[pallet::call_index(6)]
+		#[pallet::weight(<T as Config>::WeightInfo::close_child_bounty_added()
+			.max(<T as Config>::WeightInfo::close_child_bounty_active()))]
+		pub fn close_child_bounty(
+			origin: OriginFor<T>,
+			#[pallet::compact] parent_bounty_id: BountyIndex,
+			#[pallet::compact] child_bounty_id: BountyIndex,
+		) -> DispatchResult {
+			let maybe_sender = ensure_signed(origin.clone())
+				.map(Some)
+				.or_else(|_| T::RejectOrigin::ensure_origin(origin).map(|_| None))?;
+
+			// Ensure parent bounty exist, get parent curator.
+			let (parent_curator, _) = Self::ensure_bounty_active(parent_bounty_id)?;
+
+			ensure!(maybe_sender.map_or(true, |sender| parent_curator == sender), BadOrigin);
+
+			Self::impl_close_child_bounty(parent_bounty_id, child_bounty_id)?;
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	// This function will calculate the deposit of a curator.
+	fn calculate_curator_deposit(
+		parent_curator: &T::AccountId,
+		child_curator: &T::AccountId,
+		bounty_fee: &BalanceOf<T>,
+	) -> BalanceOf<T> {
+		if parent_curator == child_curator {
+			return Zero::zero()
+		}
+
+		// We just use the same logic from the parent bounties pallet.
+		pallet_bounties::Pallet::<T>::calculate_curator_deposit(bounty_fee)
+	}
+
+	/// The account ID of a child-bounty account.
+	pub fn child_bounty_account_id(id: BountyIndex) -> T::AccountId {
+		// This function is taken from the parent (bounties) pallet, but the
+		// prefix is changed to have different AccountId when the index of
+		// parent and child is same.
+		T::PalletId::get().into_sub_account_truncating(("cb", id))
+	}
+
+	fn create_child_bounty(
+		parent_bounty_id: BountyIndex,
+		child_bounty_id: BountyIndex,
+		child_bounty_value: BalanceOf<T>,
+		description: BoundedVec<u8, T::MaximumReasonLength>,
+	) {
+		let child_bounty = ChildBounty {
+			parent_bounty: parent_bounty_id,
+			value: child_bounty_value,
+			fee: 0u32.into(),
+			curator_deposit: 0u32.into(),
+			status: ChildBountyStatus::Added,
+		};
+		ChildBounties::<T>::insert(parent_bounty_id, child_bounty_id, &child_bounty);
+		ChildBountyDescriptions::<T>::insert(child_bounty_id, description);
+		Self::deposit_event(Event::Added { index: parent_bounty_id, child_index: child_bounty_id });
+	}
+
+	fn ensure_bounty_active(
+		bounty_id: BountyIndex,
+	) -> Result<(T::AccountId, BlockNumberFor<T>), DispatchError> {
+		let parent_bounty = pallet_bounties::Pallet::<T>::bounties(bounty_id)
+			.ok_or(BountiesError::<T>::InvalidIndex)?;
+		if let BountyStatus::Active { curator, update_due } = parent_bounty.get_status() {
+			Ok((curator, update_due))
+		} else {
+			Err(Error::<T>::ParentBountyNotActive.into())
+		}
+	}
+
+	fn impl_close_child_bounty(
+		parent_bounty_id: BountyIndex,
+		child_bounty_id: BountyIndex,
+	) -> DispatchResult {
+		ChildBounties::<T>::try_mutate_exists(
+			parent_bounty_id,
+			child_bounty_id,
+			|maybe_child_bounty| -> DispatchResult {
+				let child_bounty =
+					maybe_child_bounty.as_mut().ok_or(BountiesError::<T>::InvalidIndex)?;
+
+				match &child_bounty.status {
+					ChildBountyStatus::Added | ChildBountyStatus::CuratorProposed { .. } => {
+						// Nothing extra to do besides the removal of the child-bounty below.
+					},
+					ChildBountyStatus::Active { curator } => {
+						// Cancelled by parent curator or RejectOrigin,
+						// refund deposit of the working child-bounty curator.
+						let _ = T::Currency::unreserve(curator, child_bounty.curator_deposit);
+						// Then execute removal of the child-bounty below.
+					},
+					ChildBountyStatus::PendingPayout { .. } => {
+						// Child-bounty is already in pending payout. If parent
+						// curator or RejectOrigin wants to close this
+						// child-bounty, it should mean the child-bounty curator
+						// was acting maliciously. So first unassign the
+						// child-bounty curator, slashing their deposit.
+						return Err(BountiesError::<T>::PendingPayout.into())
+					},
+				}
+
+				// Revert the curator fee back to parent bounty curator &
+				// reduce the active child-bounty count.
+				ChildrenCuratorFees::<T>::mutate(parent_bounty_id, |value| {
+					*value = value.saturating_sub(child_bounty.fee)
+				});
+				<ParentChildBounties<T>>::mutate(parent_bounty_id, |count| {
+					*count = count.saturating_sub(1)
+				});
+
+				// Transfer fund from child-bounty to parent bounty.
+				let parent_bounty_account =
+					pallet_bounties::Pallet::<T>::bounty_account_id(parent_bounty_id);
+				let child_bounty_account = Self::child_bounty_account_id(child_bounty_id);
+				let balance = T::Currency::free_balance(&child_bounty_account);
+				let transfer_result = T::Currency::transfer(
+					&child_bounty_account,
+					&parent_bounty_account,
+					balance,
+					AllowDeath,
+				); // Should not fail; child bounty account gets this balance during creation.
+				debug_assert!(transfer_result.is_ok());
+
+				// Remove the child-bounty description.
+				<ChildBountyDescriptions<T>>::remove(child_bounty_id);
+
+				*maybe_child_bounty = None;
+
+				Self::deposit_event(Event::<T>::Canceled {
+					index: parent_bounty_id,
+					child_index: child_bounty_id,
+				});
+				Ok(())
+			},
+		)
+	}
+}
+
+// Implement ChildBountyManager to connect with the bounties pallet. This is
+// where we pass the active child bounties and child curator fees to the parent
+// bounty.
+impl<T: Config> pallet_bounties::ChildBountyManager<BalanceOf<T>> for Pallet<T> {
+	fn child_bounties_count(
+		bounty_id: pallet_bounties::BountyIndex,
+	) -> pallet_bounties::BountyIndex {
+		Self::parent_child_bounties(bounty_id)
+	}
+
+	fn children_curator_fees(bounty_id: pallet_bounties::BountyIndex) -> BalanceOf<T> {
+		// This is asked for when the parent bounty is being claimed. No use of
+		// keeping it in state after that. Hence removing.
+		let children_fee_total = Self::children_curator_fees(bounty_id);
+		<ChildrenCuratorFees<T>>::remove(bounty_id);
+		children_fee_total
+	}
+}
diff --git a/substrate/frame/child-bounties/src/tests.rs b/substrate/frame/child-bounties/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..24a6410f29f78daf8e33edd8fe32fcbbd307d942
--- /dev/null
+++ b/substrate/frame/child-bounties/src/tests.rs
@@ -0,0 +1,1465 @@
+// 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.
+
+//! Child-bounties pallet tests.
+
+#![cfg(test)]
+
+use super::*;
+use crate as pallet_child_bounties;
+
+use frame_support::{
+	assert_noop, assert_ok, parameter_types,
+	traits::{ConstU32, ConstU64, OnInitialize},
+	weights::Weight,
+	PalletId,
+};
+
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BadOrigin, BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill, Permill, TokenError,
+};
+
+use super::Event as ChildBountiesEvent;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+type BountiesError = pallet_bounties::Error<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Bounties: pallet_bounties::{Pallet, Call, Storage, Event<T>},
+		Treasury: pallet_treasury::{Pallet, Call, Storage, Config<T>, Event<T>},
+		ChildBounties: pallet_child_bounties::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub const MaximumBlockWeight: Weight = Weight::from_parts(1024, 0);
+	pub const MaximumBlockLength: u32 = 2 * 1024;
+	pub const AvailableBlockRatio: Perbill = Perbill::one();
+}
+
+type Balance = u64;
+
+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 RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = u128;
+	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>;
+}
+
+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 MaxHolds = ();
+}
+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 SpendLimit: Balance = u64::MAX;
+}
+
+impl pallet_treasury::Config for Test {
+	type PalletId = TreasuryPalletId;
+	type Currency = pallet_balances::Pallet<Test>;
+	type ApproveOrigin = frame_system::EnsureRoot<u128>;
+	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 = ();
+	type WeightInfo = ();
+	type SpendFunds = Bounties;
+	type MaxApprovals = ConstU32<100>;
+	type SpendOrigin = frame_system::EnsureRootWithSuccess<Self::AccountId, SpendLimit>;
+}
+parameter_types! {
+	// This will be 50% of the bounty fee.
+	pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50);
+	pub const CuratorDepositMax: Balance = 1_000;
+	pub const CuratorDepositMin: Balance = 3;
+
+}
+impl pallet_bounties::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type BountyDepositBase = ConstU64<80>;
+	type BountyDepositPayoutDelay = ConstU64<3>;
+	type BountyUpdatePeriod = ConstU64<10>;
+	type CuratorDepositMultiplier = CuratorDepositMultiplier;
+	type CuratorDepositMax = CuratorDepositMax;
+	type CuratorDepositMin = CuratorDepositMin;
+	type BountyValueMinimum = ConstU64<5>;
+	type DataDepositPerByte = ConstU64<1>;
+	type MaximumReasonLength = ConstU32<300>;
+	type WeightInfo = ();
+	type ChildBountyManager = ChildBounties;
+}
+impl pallet_child_bounties::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type MaxActiveChildBountyCount = ConstU32<2>;
+	type ChildBountyValueMinimum = ConstU64<1>;
+	type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		// Total issuance will be 200 with treasury account initialized at ED.
+		balances: vec![(0, 100), (1, 98), (2, 1)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	pallet_treasury::GenesisConfig::<Test>::default()
+		.assimilate_storage(&mut t)
+		.unwrap();
+	t.into()
+}
+
+fn last_event() -> ChildBountiesEvent<Test> {
+	System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::ChildBounties(inner) = e { Some(inner) } else { None })
+		.last()
+		.unwrap()
+}
+
+#[test]
+fn genesis_config_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Treasury::pot(), 0);
+		assert_eq!(Treasury::proposal_count(), 0);
+	});
+}
+
+#[test]
+fn minting_works() {
+	new_test_ext().execute_with(|| {
+		// Check that accumulate works when we have Some value in Dummy already.
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+	});
+}
+
+#[test]
+fn add_child_bounty() {
+	new_test_ext().execute_with(|| {
+		// TestProcedure.
+		// 1, Create bounty & move to active state with enough bounty fund & parent curator.
+		// 2, Parent curator adds child-bounty child-bounty-1, test for error like RequireCurator
+		//    ,InsufficientProposersBalance, InsufficientBountyBalance with invalid arguments.
+		// 3, Parent curator adds child-bounty child-bounty-1, moves to "Approved" state &
+		//    test for the event Added.
+		// 4, Test for DB state of `Bounties` & `ChildBounties`.
+		// 5, Observe fund transaction moment between Bounty, Child-bounty,
+		//    Curator, child-bounty curator & beneficiary.
+
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		let fee = 8;
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, fee));
+
+		Balances::make_free_balance_be(&4, 10);
+
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// This verifies that the accept curator logic took a deposit.
+		let expected_deposit = CuratorDepositMultiplier::get() * fee;
+		assert_eq!(Balances::reserved_balance(&4), expected_deposit);
+		assert_eq!(Balances::free_balance(&4), 10 - expected_deposit);
+
+		// Add child-bounty.
+		// Acc-4 is the parent curator.
+		// Call from invalid origin & check for error "RequireCurator".
+		assert_noop!(
+			ChildBounties::add_child_bounty(RuntimeOrigin::signed(0), 0, 10, b"12345-p1".to_vec()),
+			BountiesError::RequireCurator,
+		);
+
+		// Update the parent curator balance.
+		Balances::make_free_balance_be(&4, 101);
+
+		// parent curator fee is reserved on parent bounty account.
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 50);
+		assert_eq!(Balances::reserved_balance(Bounties::bounty_account_id(0)), 0);
+
+		assert_noop!(
+			ChildBounties::add_child_bounty(RuntimeOrigin::signed(4), 0, 50, b"12345-p1".to_vec()),
+			TokenError::NotExpendable,
+		);
+
+		assert_noop!(
+			ChildBounties::add_child_bounty(RuntimeOrigin::signed(4), 0, 100, b"12345-p1".to_vec()),
+			Error::<Test>::InsufficientBountyBalance,
+		);
+
+		// Add child-bounty with valid value, which can be funded by parent bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		// Check for the event child-bounty added.
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		assert_eq!(Balances::free_balance(4), 101);
+		assert_eq!(Balances::reserved_balance(4), expected_deposit);
+
+		// DB check.
+		// Check the child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee: 0,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+
+		// Check the child-bounty count.
+		assert_eq!(ChildBounties::parent_child_bounties(0), 1);
+
+		// Check the child-bounty description status.
+		assert_eq!(ChildBounties::child_bounty_descriptions(0).unwrap(), b"12345-p1".to_vec(),);
+	});
+}
+
+#[test]
+fn child_bounty_assign_curator() {
+	new_test_ext().execute_with(|| {
+		// TestProcedure
+		// 1, Create bounty & move to active state with enough bounty fund & parent curator.
+		// 2, Parent curator adds child-bounty child-bounty-1, moves to "Active" state.
+		// 3, Test for DB state of `ChildBounties`.
+
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&4, 101);
+		Balances::make_free_balance_be(&8, 101);
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		let fee = 4;
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, fee));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Bounty account status before adding child-bounty.
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 50);
+		assert_eq!(Balances::reserved_balance(Bounties::bounty_account_id(0)), 0);
+
+		// Check the balance of parent curator.
+		// Curator deposit is reserved for parent curator on parent bounty.
+		let expected_deposit = Bounties::calculate_curator_deposit(&fee);
+		assert_eq!(Balances::free_balance(4), 101 - expected_deposit);
+		assert_eq!(Balances::reserved_balance(4), expected_deposit);
+
+		// Add child-bounty.
+		// Acc-4 is the parent curator & make sure enough deposit.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		// Bounty account status after adding child-bounty.
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 40);
+		assert_eq!(Balances::reserved_balance(Bounties::bounty_account_id(0)), 0);
+
+		// Child-bounty account status.
+		assert_eq!(Balances::free_balance(ChildBounties::child_bounty_account_id(0)), 10);
+		assert_eq!(Balances::reserved_balance(ChildBounties::child_bounty_account_id(0)), 0);
+
+		let fee = 6u64;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, fee));
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: 0,
+				status: ChildBountyStatus::CuratorProposed { curator: 8 },
+			}
+		);
+
+		// Check the balance of parent curator.
+		assert_eq!(Balances::free_balance(4), 101 - expected_deposit);
+		assert_eq!(Balances::reserved_balance(4), expected_deposit);
+
+		assert_noop!(
+			ChildBounties::accept_curator(RuntimeOrigin::signed(3), 0, 0),
+			BountiesError::RequireCurator,
+		);
+
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(8), 0, 0));
+
+		let expected_child_deposit = CuratorDepositMultiplier::get() * fee;
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_child_deposit,
+				status: ChildBountyStatus::Active { curator: 8 },
+			}
+		);
+
+		// Deposit for child-bounty curator deposit is reserved.
+		assert_eq!(Balances::free_balance(8), 101 - expected_child_deposit);
+		assert_eq!(Balances::reserved_balance(8), expected_child_deposit);
+
+		// Bounty account status at exit.
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 40);
+		assert_eq!(Balances::reserved_balance(Bounties::bounty_account_id(0)), 0);
+
+		// Child-bounty account status at exit.
+		assert_eq!(Balances::free_balance(ChildBounties::child_bounty_account_id(0)), 10);
+		assert_eq!(Balances::reserved_balance(ChildBounties::child_bounty_account_id(0)), 0);
+
+		// Treasury account status at exit.
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 26);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+	});
+}
+
+#[test]
+fn award_claim_child_bounty() {
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		// Propose and accept curator for child-bounty.
+		let fee = 8;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, fee));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(8), 0, 0));
+
+		// Award child-bounty.
+		// Test for non child-bounty curator.
+		assert_noop!(
+			ChildBounties::award_child_bounty(RuntimeOrigin::signed(3), 0, 0, 7),
+			BountiesError::RequireCurator,
+		);
+
+		assert_ok!(ChildBounties::award_child_bounty(RuntimeOrigin::signed(8), 0, 0, 7));
+
+		let expected_deposit = CuratorDepositMultiplier::get() * fee;
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_deposit,
+				status: ChildBountyStatus::PendingPayout {
+					curator: 8,
+					beneficiary: 7,
+					unlock_at: 5
+				},
+			}
+		);
+
+		// Claim child-bounty.
+		// Test for Premature condition.
+		assert_noop!(
+			ChildBounties::claim_child_bounty(RuntimeOrigin::signed(7), 0, 0),
+			BountiesError::Premature
+		);
+
+		System::set_block_number(9);
+
+		assert_ok!(ChildBounties::claim_child_bounty(RuntimeOrigin::signed(7), 0, 0));
+
+		// Ensure child-bounty curator is paid with curator fee & deposit refund.
+		assert_eq!(Balances::free_balance(8), 101 + fee);
+		assert_eq!(Balances::reserved_balance(8), 0);
+
+		// Ensure executor is paid with beneficiary amount.
+		assert_eq!(Balances::free_balance(7), 10 - fee);
+		assert_eq!(Balances::reserved_balance(7), 0);
+
+		// Child-bounty account status.
+		assert_eq!(Balances::free_balance(ChildBounties::child_bounty_account_id(0)), 0);
+		assert_eq!(Balances::reserved_balance(ChildBounties::child_bounty_account_id(0)), 0);
+
+		// Check the child-bounty count.
+		assert_eq!(ChildBounties::parent_child_bounties(0), 0);
+	});
+}
+
+#[test]
+fn close_child_bounty_added() {
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		System::set_block_number(4);
+
+		// Close child-bounty.
+		// Wrong origin.
+		assert_noop!(ChildBounties::close_child_bounty(RuntimeOrigin::signed(7), 0, 0), BadOrigin);
+		assert_noop!(ChildBounties::close_child_bounty(RuntimeOrigin::signed(8), 0, 0), BadOrigin);
+
+		// Correct origin - parent curator.
+		assert_ok!(ChildBounties::close_child_bounty(RuntimeOrigin::signed(4), 0, 0));
+
+		// Check the child-bounty count.
+		assert_eq!(ChildBounties::parent_child_bounties(0), 0);
+
+		// Parent-bounty account status.
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 50);
+		assert_eq!(Balances::reserved_balance(Bounties::bounty_account_id(0)), 0);
+
+		// Child-bounty account status.
+		assert_eq!(Balances::free_balance(ChildBounties::child_bounty_account_id(0)), 0);
+		assert_eq!(Balances::reserved_balance(ChildBounties::child_bounty_account_id(0)), 0);
+	});
+}
+
+#[test]
+fn close_child_bounty_active() {
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		// Propose and accept curator for child-bounty.
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, 2));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(8), 0, 0));
+
+		// Close child-bounty in active state.
+		assert_ok!(ChildBounties::close_child_bounty(RuntimeOrigin::signed(4), 0, 0));
+
+		// Check the child-bounty count.
+		assert_eq!(ChildBounties::parent_child_bounties(0), 0);
+
+		// Ensure child-bounty curator balance is unreserved.
+		assert_eq!(Balances::free_balance(8), 101);
+		assert_eq!(Balances::reserved_balance(8), 0);
+
+		// Parent-bounty account status.
+		assert_eq!(Balances::free_balance(Bounties::bounty_account_id(0)), 50);
+		assert_eq!(Balances::reserved_balance(Bounties::bounty_account_id(0)), 0);
+
+		// Child-bounty account status.
+		assert_eq!(Balances::free_balance(ChildBounties::child_bounty_account_id(0)), 0);
+		assert_eq!(Balances::reserved_balance(ChildBounties::child_bounty_account_id(0)), 0);
+	});
+}
+
+#[test]
+fn close_child_bounty_pending() {
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		let parent_fee = 6;
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, parent_fee));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		// Propose and accept curator for child-bounty.
+		let child_fee = 4;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, child_fee));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(8), 0, 0));
+		let expected_child_deposit = CuratorDepositMin::get();
+
+		assert_ok!(ChildBounties::award_child_bounty(RuntimeOrigin::signed(8), 0, 0, 7));
+
+		// Close child-bounty in pending_payout state.
+		assert_noop!(
+			ChildBounties::close_child_bounty(RuntimeOrigin::signed(4), 0, 0),
+			BountiesError::PendingPayout
+		);
+
+		// Check the child-bounty count.
+		assert_eq!(ChildBounties::parent_child_bounties(0), 1);
+
+		// Ensure no changes in child-bounty curator balance.
+		assert_eq!(Balances::reserved_balance(8), expected_child_deposit);
+		assert_eq!(Balances::free_balance(8), 101 - expected_child_deposit);
+
+		// Child-bounty account status.
+		assert_eq!(Balances::free_balance(ChildBounties::child_bounty_account_id(0)), 10);
+		assert_eq!(Balances::reserved_balance(ChildBounties::child_bounty_account_id(0)), 0);
+	});
+}
+
+#[test]
+fn child_bounty_added_unassign_curator() {
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		// Unassign curator in added state.
+		assert_noop!(
+			ChildBounties::unassign_curator(RuntimeOrigin::signed(4), 0, 0),
+			BountiesError::UnexpectedStatus
+		);
+	});
+}
+
+#[test]
+fn child_bounty_curator_proposed_unassign_curator() {
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		// Propose curator for child-bounty.
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, 2));
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee: 2,
+				curator_deposit: 0,
+				status: ChildBountyStatus::CuratorProposed { curator: 8 },
+			}
+		);
+
+		// Random account cannot unassign the curator when in proposed state.
+		assert_noop!(ChildBounties::unassign_curator(RuntimeOrigin::signed(99), 0, 0), BadOrigin);
+
+		// Unassign curator.
+		assert_ok!(ChildBounties::unassign_curator(RuntimeOrigin::signed(4), 0, 0));
+
+		// Verify updated child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee: 2,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+	});
+}
+
+#[test]
+fn child_bounty_active_unassign_curator() {
+	// Covers all scenarios with all origin types.
+	// Step 1: Setup bounty, child bounty.
+	// Step 2: Assign, accept curator for child bounty. Unassign from reject origin. Should slash.
+	// Step 3: Assign, accept another curator for child bounty. Unassign from parent-bounty curator.
+	// Should slash. Step 4: Assign, accept another curator for child bounty. Unassign from
+	// child-bounty curator. Should NOT slash. Step 5: Assign, accept another curator for child
+	// bounty. Unassign from random account. Should slash.
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&6, 101); // Child-bounty curator 1.
+		Balances::make_free_balance_be(&7, 101); // Child-bounty curator 2.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator 3.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Create Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		System::set_block_number(3);
+		<Treasury as OnInitialize<u64>>::on_initialize(3);
+
+		// Propose and accept curator for child-bounty.
+		let fee = 6;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, fee));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(8), 0, 0));
+		let expected_child_deposit = CuratorDepositMultiplier::get() * fee;
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_child_deposit,
+				status: ChildBountyStatus::Active { curator: 8 },
+			}
+		);
+
+		System::set_block_number(4);
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+
+		// Unassign curator - from reject origin.
+		assert_ok!(ChildBounties::unassign_curator(RuntimeOrigin::root(), 0, 0));
+
+		// Verify updated child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+
+		// Ensure child-bounty curator was slashed.
+		assert_eq!(Balances::free_balance(8), 101 - expected_child_deposit);
+		assert_eq!(Balances::reserved_balance(8), 0); // slashed
+
+		// Propose and accept curator for child-bounty again.
+		let fee = 2;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 7, fee));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(7), 0, 0));
+		let expected_child_deposit = CuratorDepositMin::get();
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_child_deposit,
+				status: ChildBountyStatus::Active { curator: 7 },
+			}
+		);
+
+		System::set_block_number(5);
+		<Treasury as OnInitialize<u64>>::on_initialize(5);
+
+		// Unassign curator again - from parent curator.
+		assert_ok!(ChildBounties::unassign_curator(RuntimeOrigin::signed(4), 0, 0));
+
+		// Verify updated child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee: 2,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+
+		// Ensure child-bounty curator was slashed.
+		assert_eq!(Balances::free_balance(7), 101 - expected_child_deposit);
+		assert_eq!(Balances::reserved_balance(7), 0); // slashed
+
+		// Propose and accept curator for child-bounty again.
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 6, 2));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(6), 0, 0));
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_child_deposit,
+				status: ChildBountyStatus::Active { curator: 6 },
+			}
+		);
+
+		System::set_block_number(6);
+		<Treasury as OnInitialize<u64>>::on_initialize(6);
+
+		// Unassign curator again - from child-bounty curator.
+		assert_ok!(ChildBounties::unassign_curator(RuntimeOrigin::signed(6), 0, 0));
+
+		// Verify updated child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee: 2,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+
+		// Ensure child-bounty curator was **not** slashed.
+		assert_eq!(Balances::free_balance(6), 101); // not slashed
+		assert_eq!(Balances::reserved_balance(6), 0);
+
+		// Propose and accept curator for child-bounty one last time.
+		let fee = 2;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 6, fee));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(6), 0, 0));
+		let expected_child_deposit = CuratorDepositMin::get();
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_child_deposit,
+				status: ChildBountyStatus::Active { curator: 6 },
+			}
+		);
+
+		System::set_block_number(7);
+		<Treasury as OnInitialize<u64>>::on_initialize(7);
+
+		// Unassign curator again - from non curator; non reject origin; some random guy.
+		// Bounty update period is not yet complete.
+		assert_noop!(
+			ChildBounties::unassign_curator(RuntimeOrigin::signed(3), 0, 0),
+			BountiesError::Premature
+		);
+
+		System::set_block_number(20);
+		<Treasury as OnInitialize<u64>>::on_initialize(20);
+
+		// Unassign child curator from random account after inactivity.
+		assert_ok!(ChildBounties::unassign_curator(RuntimeOrigin::signed(3), 0, 0));
+
+		// Verify updated child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee: 2,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+
+		// Ensure child-bounty curator was slashed.
+		assert_eq!(Balances::free_balance(6), 101 - expected_child_deposit); // slashed
+		assert_eq!(Balances::reserved_balance(6), 0);
+	});
+}
+
+#[test]
+fn parent_bounty_inactive_unassign_curator_child_bounty() {
+	// Unassign curator when parent bounty in not in active state.
+	// This can happen when the curator of parent bounty has been unassigned.
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator 1.
+		Balances::make_free_balance_be(&5, 101); // Parent-bounty curator 2.
+		Balances::make_free_balance_be(&6, 101); // Child-bounty curator 1.
+		Balances::make_free_balance_be(&7, 101); // Child-bounty curator 2.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator 3.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Create Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		System::set_block_number(3);
+		<Treasury as OnInitialize<u64>>::on_initialize(3);
+
+		// Propose and accept curator for child-bounty.
+		let fee = 8;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, fee));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(8), 0, 0));
+		let expected_child_deposit = CuratorDepositMultiplier::get() * fee;
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_child_deposit,
+				status: ChildBountyStatus::Active { curator: 8 },
+			}
+		);
+
+		System::set_block_number(4);
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+
+		// Unassign parent bounty curator.
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(5);
+		<Treasury as OnInitialize<u64>>::on_initialize(5);
+
+		// Try unassign child-bounty curator - from non curator; non reject
+		// origin; some random guy. Bounty update period is not yet complete.
+		assert_noop!(
+			ChildBounties::unassign_curator(RuntimeOrigin::signed(3), 0, 0),
+			Error::<Test>::ParentBountyNotActive
+		);
+
+		// Unassign curator - from reject origin.
+		assert_ok!(ChildBounties::unassign_curator(RuntimeOrigin::root(), 0, 0));
+
+		// Verify updated child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+
+		// Ensure child-bounty curator was slashed.
+		assert_eq!(Balances::free_balance(8), 101 - expected_child_deposit);
+		assert_eq!(Balances::reserved_balance(8), 0); // slashed
+
+		System::set_block_number(6);
+		<Treasury as OnInitialize<u64>>::on_initialize(6);
+
+		// Propose and accept curator for parent-bounty again.
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 5, 6));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(5), 0));
+
+		System::set_block_number(7);
+		<Treasury as OnInitialize<u64>>::on_initialize(7);
+
+		// Propose and accept curator for child-bounty again.
+		let fee = 2;
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(5), 0, 0, 7, fee));
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(7), 0, 0));
+		let expected_deposit = CuratorDepositMin::get();
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_deposit,
+				status: ChildBountyStatus::Active { curator: 7 },
+			}
+		);
+
+		System::set_block_number(8);
+		<Treasury as OnInitialize<u64>>::on_initialize(8);
+
+		assert_noop!(
+			ChildBounties::unassign_curator(RuntimeOrigin::signed(3), 0, 0),
+			BountiesError::Premature
+		);
+
+		// Unassign parent bounty curator again.
+		assert_ok!(Bounties::unassign_curator(RuntimeOrigin::signed(5), 0));
+
+		System::set_block_number(9);
+		<Treasury as OnInitialize<u64>>::on_initialize(9);
+
+		// Unassign curator again - from parent curator.
+		assert_ok!(ChildBounties::unassign_curator(RuntimeOrigin::signed(7), 0, 0));
+
+		// Verify updated child-bounty status.
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee: 2,
+				curator_deposit: 0,
+				status: ChildBountyStatus::Added,
+			}
+		);
+
+		// Ensure child-bounty curator was not slashed.
+		assert_eq!(Balances::free_balance(7), 101);
+		assert_eq!(Balances::reserved_balance(7), 0); // slashed
+	});
+}
+
+#[test]
+fn close_parent_with_child_bounty() {
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		// Try add child-bounty.
+		// Should fail, parent bounty not active yet.
+		assert_noop!(
+			ChildBounties::add_child_bounty(RuntimeOrigin::signed(4), 0, 10, b"12345-p1".to_vec()),
+			Error::<Test>::ParentBountyNotActive
+		);
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		System::set_block_number(4);
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+
+		// Try close parent-bounty.
+		// Child bounty active, can't close parent.
+		assert_noop!(
+			Bounties::close_bounty(RuntimeOrigin::root(), 0),
+			BountiesError::HasActiveChildBounty
+		);
+
+		System::set_block_number(2);
+
+		// Close child-bounty.
+		assert_ok!(ChildBounties::close_child_bounty(RuntimeOrigin::root(), 0, 0));
+
+		// Check the child-bounty count.
+		assert_eq!(ChildBounties::parent_child_bounties(0), 0);
+
+		// Try close parent-bounty again.
+		// Should pass this time.
+		assert_ok!(Bounties::close_bounty(RuntimeOrigin::root(), 0));
+	});
+}
+
+#[test]
+fn children_curator_fee_calculation_test() {
+	// Tests the calculation of subtracting child-bounty curator fee
+	// from parent bounty fee when claiming bounties.
+	new_test_ext().execute_with(|| {
+		// Make the parent bounty.
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 101);
+		assert_eq!(Balances::reserved_balance(Treasury::account_id()), 0);
+
+		// Bounty curator initial balance.
+		Balances::make_free_balance_be(&4, 101); // Parent-bounty curator.
+		Balances::make_free_balance_be(&8, 101); // Child-bounty curator.
+
+		assert_ok!(Bounties::propose_bounty(RuntimeOrigin::signed(0), 50, b"12345".to_vec()));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), 0));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(RuntimeOrigin::root(), 0, 4, 6));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(4), 0));
+
+		// Child-bounty.
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(4),
+			0,
+			10,
+			b"12345-p1".to_vec()
+		));
+		assert_eq!(last_event(), ChildBountiesEvent::Added { index: 0, child_index: 0 });
+
+		System::set_block_number(4);
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+
+		let fee = 6;
+
+		// Propose curator for child-bounty.
+		assert_ok!(ChildBounties::propose_curator(RuntimeOrigin::signed(4), 0, 0, 8, fee));
+		// Check curator fee added to the sum.
+		assert_eq!(ChildBounties::children_curator_fees(0), fee);
+		// Accept curator for child-bounty.
+		assert_ok!(ChildBounties::accept_curator(RuntimeOrigin::signed(8), 0, 0));
+		// Award child-bounty.
+		assert_ok!(ChildBounties::award_child_bounty(RuntimeOrigin::signed(8), 0, 0, 7));
+
+		let expected_child_deposit = CuratorDepositMultiplier::get() * fee;
+
+		assert_eq!(
+			ChildBounties::child_bounties(0, 0).unwrap(),
+			ChildBounty {
+				parent_bounty: 0,
+				value: 10,
+				fee,
+				curator_deposit: expected_child_deposit,
+				status: ChildBountyStatus::PendingPayout {
+					curator: 8,
+					beneficiary: 7,
+					unlock_at: 7
+				},
+			}
+		);
+
+		System::set_block_number(9);
+
+		// Claim child-bounty.
+		assert_ok!(ChildBounties::claim_child_bounty(RuntimeOrigin::signed(7), 0, 0));
+
+		// Check the child-bounty count.
+		assert_eq!(ChildBounties::parent_child_bounties(0), 0);
+
+		// Award the parent bounty.
+		assert_ok!(Bounties::award_bounty(RuntimeOrigin::signed(4), 0, 9));
+
+		System::set_block_number(15);
+
+		// Claim the parent bounty.
+		assert_ok!(Bounties::claim_bounty(RuntimeOrigin::signed(9), 0));
+
+		// Ensure parent-bounty curator received correctly reduced fee.
+		assert_eq!(Balances::free_balance(4), 101 + 6 - fee); // 101 + 6 - 2
+		assert_eq!(Balances::reserved_balance(4), 0);
+
+		// Verify parent-bounty beneficiary balance.
+		assert_eq!(Balances::free_balance(9), 34);
+		assert_eq!(Balances::reserved_balance(9), 0);
+	});
+}
+
+#[test]
+fn accept_curator_handles_different_deposit_calculations() {
+	// This test will verify that a bounty with and without a fee results
+	// in a different curator deposit, and if the child curator matches the parent curator.
+	new_test_ext().execute_with(|| {
+		// Setup a parent bounty.
+		let parent_curator = 0;
+		let parent_index = 0;
+		let parent_value = 1_000_000;
+		let parent_fee = 10_000;
+
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), parent_value * 3);
+		Balances::make_free_balance_be(&parent_curator, parent_fee * 100);
+		assert_ok!(Bounties::propose_bounty(
+			RuntimeOrigin::signed(parent_curator),
+			parent_value,
+			b"12345".to_vec()
+		));
+		assert_ok!(Bounties::approve_bounty(RuntimeOrigin::root(), parent_index));
+
+		System::set_block_number(2);
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+
+		assert_ok!(Bounties::propose_curator(
+			RuntimeOrigin::root(),
+			parent_index,
+			parent_curator,
+			parent_fee
+		));
+		assert_ok!(Bounties::accept_curator(RuntimeOrigin::signed(parent_curator), parent_index));
+
+		// Now we can start creating some child bounties.
+		// Case 1: Parent and child curator are not the same.
+
+		let child_index = 0;
+		let child_curator = 1;
+		let child_value = 1_000;
+		let child_fee = 100;
+		let starting_balance = 100 * child_fee + child_value;
+
+		Balances::make_free_balance_be(&child_curator, starting_balance);
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_value,
+			b"12345-p1".to_vec()
+		));
+		System::set_block_number(3);
+		<Treasury as OnInitialize<u64>>::on_initialize(3);
+		assert_ok!(ChildBounties::propose_curator(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_index,
+			child_curator,
+			child_fee
+		));
+		assert_ok!(ChildBounties::accept_curator(
+			RuntimeOrigin::signed(child_curator),
+			parent_index,
+			child_index
+		));
+
+		let expected_deposit = CuratorDepositMultiplier::get() * child_fee;
+		assert_eq!(Balances::free_balance(child_curator), starting_balance - expected_deposit);
+		assert_eq!(Balances::reserved_balance(child_curator), expected_deposit);
+
+		// Case 2: Parent and child curator are the same.
+
+		let child_index = 1;
+		let child_curator = parent_curator; // The same as parent bounty curator
+		let child_value = 1_000;
+		let child_fee = 10;
+
+		let free_before = Balances::free_balance(&parent_curator);
+		let reserved_before = Balances::reserved_balance(&parent_curator);
+
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_value,
+			b"12345-p1".to_vec()
+		));
+		System::set_block_number(4);
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+		assert_ok!(ChildBounties::propose_curator(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_index,
+			child_curator,
+			child_fee
+		));
+		assert_ok!(ChildBounties::accept_curator(
+			RuntimeOrigin::signed(child_curator),
+			parent_index,
+			child_index
+		));
+
+		// No expected deposit
+		assert_eq!(Balances::free_balance(child_curator), free_before);
+		assert_eq!(Balances::reserved_balance(child_curator), reserved_before);
+
+		// Case 3: Upper Limit
+
+		let child_index = 2;
+		let child_curator = 2;
+		let child_value = 10_000;
+		let child_fee = 5_000;
+
+		Balances::make_free_balance_be(&child_curator, starting_balance);
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_value,
+			b"12345-p1".to_vec()
+		));
+		System::set_block_number(5);
+		<Treasury as OnInitialize<u64>>::on_initialize(5);
+		assert_ok!(ChildBounties::propose_curator(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_index,
+			child_curator,
+			child_fee
+		));
+		assert_ok!(ChildBounties::accept_curator(
+			RuntimeOrigin::signed(child_curator),
+			parent_index,
+			child_index
+		));
+
+		let expected_deposit = CuratorDepositMax::get();
+		assert_eq!(Balances::free_balance(child_curator), starting_balance - expected_deposit);
+		assert_eq!(Balances::reserved_balance(child_curator), expected_deposit);
+
+		// There is a max number of child bounties at a time.
+		assert_ok!(ChildBounties::impl_close_child_bounty(parent_index, child_index));
+
+		// Case 4: Lower Limit
+
+		let child_index = 3;
+		let child_curator = 3;
+		let child_value = 10_000;
+		let child_fee = 0;
+
+		Balances::make_free_balance_be(&child_curator, starting_balance);
+		assert_ok!(ChildBounties::add_child_bounty(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_value,
+			b"12345-p1".to_vec()
+		));
+		System::set_block_number(5);
+		<Treasury as OnInitialize<u64>>::on_initialize(5);
+		assert_ok!(ChildBounties::propose_curator(
+			RuntimeOrigin::signed(parent_curator),
+			parent_index,
+			child_index,
+			child_curator,
+			child_fee
+		));
+		assert_ok!(ChildBounties::accept_curator(
+			RuntimeOrigin::signed(child_curator),
+			parent_index,
+			child_index
+		));
+
+		let expected_deposit = CuratorDepositMin::get();
+		assert_eq!(Balances::free_balance(child_curator), starting_balance - expected_deposit);
+		assert_eq!(Balances::reserved_balance(child_curator), expected_deposit);
+	});
+}
diff --git a/substrate/frame/child-bounties/src/weights.rs b/substrate/frame/child-bounties/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e4c1f238e88b7f94e177ab6005fca0beb3e91d1f
--- /dev/null
+++ b/substrate/frame/child-bounties/src/weights.rs
@@ -0,0 +1,350 @@
+// 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.
+
+//! Autogenerated weights for pallet_child_bounties
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_child_bounties
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/child-bounties/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_child_bounties.
+pub trait WeightInfo {
+	fn add_child_bounty(d: u32, ) -> Weight;
+	fn propose_curator() -> Weight;
+	fn accept_curator() -> Weight;
+	fn unassign_curator() -> Weight;
+	fn award_child_bounty() -> Weight;
+	fn claim_child_bounty() -> Weight;
+	fn close_child_bounty_added() -> Weight;
+	fn close_child_bounty_active() -> Weight;
+}
+
+/// Weights for pallet_child_bounties using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyCount (r:1 w:1)
+	/// Proof: ChildBounties ChildBountyCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:0 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// The range of component `d` is `[0, 300]`.
+	fn add_child_bounty(_d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `712`
+		//  Estimated: `6196`
+		// Minimum execution time: 69_805_000 picoseconds.
+		Weight::from_parts(73_216_717, 6196)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	fn propose_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `766`
+		//  Estimated: `3642`
+		// Minimum execution time: 18_190_000 picoseconds.
+		Weight::from_parts(18_932_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn accept_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `912`
+		//  Estimated: `3642`
+		// Minimum execution time: 35_035_000 picoseconds.
+		Weight::from_parts(35_975_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn unassign_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `912`
+		//  Estimated: `3642`
+		// Minimum execution time: 37_636_000 picoseconds.
+		Weight::from_parts(38_610_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	fn award_child_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `809`
+		//  Estimated: `3642`
+		// Minimum execution time: 22_457_000 picoseconds.
+		Weight::from_parts(23_691_000, 3642)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: System Account (r:3 w:3)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn claim_child_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `682`
+		//  Estimated: `8799`
+		// Minimum execution time: 118_272_000 picoseconds.
+		Weight::from_parts(121_646_000, 8799)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_child_bounty_added() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1012`
+		//  Estimated: `6196`
+		// Minimum execution time: 75_717_000 picoseconds.
+		Weight::from_parts(77_837_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: System Account (r:3 w:3)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_child_bounty_active() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1199`
+		//  Estimated: `8799`
+		// Minimum execution time: 94_215_000 picoseconds.
+		Weight::from_parts(97_017_000, 8799)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyCount (r:1 w:1)
+	/// Proof: ChildBounties ChildBountyCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:0 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// The range of component `d` is `[0, 300]`.
+	fn add_child_bounty(_d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `712`
+		//  Estimated: `6196`
+		// Minimum execution time: 69_805_000 picoseconds.
+		Weight::from_parts(73_216_717, 6196)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	fn propose_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `766`
+		//  Estimated: `3642`
+		// Minimum execution time: 18_190_000 picoseconds.
+		Weight::from_parts(18_932_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn accept_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `912`
+		//  Estimated: `3642`
+		// Minimum execution time: 35_035_000 picoseconds.
+		Weight::from_parts(35_975_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn unassign_curator() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `912`
+		//  Estimated: `3642`
+		// Minimum execution time: 37_636_000 picoseconds.
+		Weight::from_parts(38_610_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	fn award_child_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `809`
+		//  Estimated: `3642`
+		// Minimum execution time: 22_457_000 picoseconds.
+		Weight::from_parts(23_691_000, 3642)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: System Account (r:3 w:3)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn claim_child_bounty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `682`
+		//  Estimated: `8799`
+		// Minimum execution time: 118_272_000 picoseconds.
+		Weight::from_parts(121_646_000, 8799)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_child_bounty_added() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1012`
+		//  Estimated: `6196`
+		// Minimum execution time: 75_717_000 picoseconds.
+		Weight::from_parts(77_837_000, 6196)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Bounties Bounties (r:1 w:0)
+	/// Proof: Bounties Bounties (max_values: None, max_size: Some(177), added: 2652, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ChildBounties (max_values: None, max_size: Some(145), added: 2620, mode: MaxEncodedLen)
+	/// Storage: System Account (r:3 w:3)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildrenCuratorFees (r:1 w:1)
+	/// Proof: ChildBounties ChildrenCuratorFees (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ParentChildBounties (r:1 w:1)
+	/// Proof: ChildBounties ParentChildBounties (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: ChildBounties ChildBountyDescriptions (r:0 w:1)
+	/// Proof: ChildBounties ChildBountyDescriptions (max_values: None, max_size: Some(314), added: 2789, mode: MaxEncodedLen)
+	fn close_child_bounty_active() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1199`
+		//  Estimated: `8799`
+		// Minimum execution time: 94_215_000 picoseconds.
+		Weight::from_parts(97_017_000, 8799)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+}
diff --git a/substrate/frame/collective/Cargo.toml b/substrate/frame/collective/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b80de34ecc2bad4c9cd3ccc4c580c7c890fe038b
--- /dev/null
+++ b/substrate/frame/collective/Cargo.toml
@@ -0,0 +1,51 @@
+[package]
+name = "pallet-collective"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Collective system: Members of a set of account IDs can make their collective feelings known through dispatched calls from one of two specialized origins."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/collective/README.md b/substrate/frame/collective/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..444927e51da22898c893b668328521606ba8a9a4
--- /dev/null
+++ b/substrate/frame/collective/README.md
@@ -0,0 +1,25 @@
+Collective system: Members of a set of account IDs can make their collective feelings known
+through dispatched calls from one of two specialized origins.
+
+The membership can be provided in one of two ways: either directly, using the Root-dispatchable
+function `set_members`, or indirectly, through implementing the `ChangeMembers`.
+The pallet assumes that the amount of members stays at or below `MaxMembers` for its weight
+calculations, but enforces this neither in `set_members` nor in `change_members_sorted`.
+
+A "prime" member may be set to help determine the default vote behavior based on chain
+config. If `PrimeDefaultVote` is used, the prime vote acts as the default vote in case of any
+abstentions after the voting period. If `MoreThanMajorityThenPrimeDefaultVote` is used, then
+abstentations will first follow the majority of the collective voting, and then the prime
+member.
+
+Voting happens through motions comprising a proposal (i.e. a dispatchable) plus a
+number of approvals required for it to pass and be called. Motions are open for members to
+vote on for a minimum period given by `MotionDuration`. As soon as the required number of
+approvals is given, the motion is closed and executed. If the number of approvals is not reached
+during the voting period, then `close` may be called by any account in order to force the end
+the motion explicitly. If a prime member is defined, then their vote is used instead of any
+abstentions and the proposal is executed if there are enough approvals counting the new votes.
+
+If there are not, or if no prime member is set, then the motion is dropped without being executed.
+
+License: Apache-2.0
diff --git a/substrate/frame/collective/src/benchmarking.rs b/substrate/frame/collective/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..503d72510530903ba1676fe6630c326ef1a4f770
--- /dev/null
+++ b/substrate/frame/collective/src/benchmarking.rs
@@ -0,0 +1,652 @@
+// 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.
+
+//! Staking pallet benchmarking.
+
+use super::*;
+use crate::Pallet as Collective;
+
+use sp_runtime::traits::Bounded;
+use sp_std::mem::size_of;
+
+use frame_benchmarking::v1::{account, benchmarks_instance_pallet, whitelisted_caller};
+use frame_system::{
+	pallet_prelude::BlockNumberFor, Call as SystemCall, Pallet as System, RawOrigin as SystemOrigin,
+};
+
+const SEED: u32 = 0;
+
+const MAX_BYTES: u32 = 1_024;
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn id_to_remark_data(id: u32, length: usize) -> Vec<u8> {
+	id.to_le_bytes().into_iter().cycle().take(length).collect()
+}
+
+benchmarks_instance_pallet! {
+	set_members {
+		let m in 0 .. T::MaxMembers::get();
+		let n in 0 .. T::MaxMembers::get();
+		let p in 0 .. T::MaxProposals::get();
+
+		// Set old members.
+		// We compute the difference of old and new members, so it should influence timing.
+		let mut old_members = vec![];
+		for i in 0 .. m {
+			let old_member = account::<T::AccountId>("old member", i, SEED);
+			old_members.push(old_member);
+		}
+		let old_members_count = old_members.len() as u32;
+
+		Collective::<T, I>::set_members(
+			SystemOrigin::Root.into(),
+			old_members.clone(),
+			old_members.last().cloned(),
+			T::MaxMembers::get(),
+		)?;
+
+		// If there were any old members generate a bunch of proposals.
+		if m > 0 {
+			// Set a high threshold for proposals passing so that they stay around.
+			let threshold = m.max(2);
+			// Length of the proposals should be irrelevant to `set_members`.
+			let length = 100;
+			for i in 0 .. p {
+				// Proposals should be different so that different proposal hashes are generated
+				let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, length) }.into();
+				Collective::<T, I>::propose(
+					SystemOrigin::Signed(old_members.last().unwrap().clone()).into(),
+					threshold,
+					Box::new(proposal.clone()),
+					MAX_BYTES,
+				)?;
+				let hash = T::Hashing::hash_of(&proposal);
+				// Vote on the proposal to increase state relevant for `set_members`.
+				// Not voting for last old member because they proposed and not voting for the first member
+				// to keep the proposal from passing.
+				for j in 2 .. m - 1 {
+					let voter = &old_members[j as usize];
+					let approve = true;
+					Collective::<T, I>::vote(
+						SystemOrigin::Signed(voter.clone()).into(),
+						hash,
+						i,
+						approve,
+					)?;
+				}
+			}
+		}
+
+		// Construct `new_members`.
+		// It should influence timing since it will sort this vector.
+		let mut new_members = vec![];
+		for i in 0 .. n {
+			let member = account::<T::AccountId>("member", i, SEED);
+			new_members.push(member);
+		}
+
+	}: _(SystemOrigin::Root, new_members.clone(), new_members.last().cloned(), T::MaxMembers::get())
+	verify {
+		new_members.sort();
+		assert_eq!(Collective::<T, I>::members(), new_members);
+	}
+
+	execute {
+		let b in 2 .. MAX_BYTES;
+		let m in 1 .. T::MaxMembers::get();
+
+		let bytes_in_storage = b + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		for i in 0 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+
+		let caller: T::AccountId = whitelisted_caller();
+		members.push(caller.clone());
+
+		Collective::<T, I>::set_members(SystemOrigin::Root.into(), members, None, T::MaxMembers::get())?;
+
+		let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(1, b as usize) }.into();
+
+	}: _(SystemOrigin::Signed(caller), Box::new(proposal.clone()), bytes_in_storage)
+	verify {
+		let proposal_hash = T::Hashing::hash_of(&proposal);
+		// Note that execution fails due to mis-matched origin
+		assert_last_event::<T, I>(
+			Event::MemberExecuted { proposal_hash, result: Ok(()) }.into()
+		);
+	}
+
+	// This tests when execution would happen immediately after proposal
+	propose_execute {
+		let b in 2 .. MAX_BYTES;
+		let m in 1 .. T::MaxMembers::get();
+
+		let bytes_in_storage = b + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		for i in 0 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+
+		let caller: T::AccountId = whitelisted_caller();
+		members.push(caller.clone());
+
+		Collective::<T, I>::set_members(SystemOrigin::Root.into(), members, None, T::MaxMembers::get())?;
+
+		let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(1, b as usize) }.into();
+		let threshold = 1;
+
+	}: propose(SystemOrigin::Signed(caller), threshold, Box::new(proposal.clone()), bytes_in_storage)
+	verify {
+		let proposal_hash = T::Hashing::hash_of(&proposal);
+		// Note that execution fails due to mis-matched origin
+		assert_last_event::<T, I>(
+			Event::Executed { proposal_hash, result: Ok(()) }.into()
+		);
+	}
+
+	// This tests when proposal is created and queued as "proposed"
+	propose_proposed {
+		let b in 2 .. MAX_BYTES;
+		let m in 2 .. T::MaxMembers::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes_in_storage = b + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		for i in 0 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+		let caller: T::AccountId = whitelisted_caller();
+		members.push(caller.clone());
+		Collective::<T, I>::set_members(SystemOrigin::Root.into(), members, None, T::MaxMembers::get())?;
+
+		let threshold = m;
+		// Add previous proposals.
+		for i in 0 .. p - 1 {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, b as usize) }.into();
+			Collective::<T, I>::propose(
+				SystemOrigin::Signed(caller.clone()).into(),
+				threshold,
+				Box::new(proposal),
+				bytes_in_storage,
+			)?;
+		}
+
+		assert_eq!(Collective::<T, I>::proposals().len(), (p - 1) as usize);
+
+		let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(p, b as usize) }.into();
+
+	}: propose(SystemOrigin::Signed(caller.clone()), threshold, Box::new(proposal.clone()), bytes_in_storage)
+	verify {
+		// New proposal is recorded
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+		let proposal_hash = T::Hashing::hash_of(&proposal);
+		assert_last_event::<T, I>(Event::Proposed { account: caller, proposal_index: p - 1, proposal_hash, threshold }.into());
+	}
+
+	vote {
+		// We choose 5 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 5 .. T::MaxMembers::get();
+
+		let p = T::MaxProposals::get();
+		let b = MAX_BYTES;
+		let bytes_in_storage = b + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		let proposer: T::AccountId = account::<T::AccountId>("proposer", 0, SEED);
+		members.push(proposer.clone());
+		for i in 1 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+		let voter: T::AccountId = account::<T::AccountId>("voter", 0, SEED);
+		members.push(voter.clone());
+		Collective::<T, I>::set_members(SystemOrigin::Root.into(), members.clone(), None, T::MaxMembers::get())?;
+
+		// Threshold is 1 less than the number of members so that one person can vote nay
+		let threshold = m - 1;
+
+		// Add previous proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, b as usize) }.into();
+			Collective::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+		}
+
+		let index = p - 1;
+		// Have almost everyone vote aye on last proposal, while keeping it from passing.
+		for j in 0 .. m - 3 {
+			let voter = &members[j as usize];
+			let approve = true;
+			Collective::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash,
+				index,
+				approve,
+			)?;
+		}
+		// Voter votes aye without resolving the vote.
+		let approve = true;
+		Collective::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash,
+			index,
+			approve,
+		)?;
+
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+
+		// Voter switches vote to nay, but does not kill the vote, just updates + inserts
+		let approve = false;
+
+		// Whitelist voter account from further DB operations.
+		let voter_key = frame_system::Account::<T>::hashed_key_for(&voter);
+		frame_benchmarking::benchmarking::add_to_whitelist(voter_key.into());
+	}: _(SystemOrigin::Signed(voter), last_hash, index, approve)
+	verify {
+		// All proposals exist and the last proposal has just been updated.
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+		let voting = Collective::<T, I>::voting(&last_hash).ok_or("Proposal Missing")?;
+		assert_eq!(voting.ayes.len(), (m - 3) as usize);
+		assert_eq!(voting.nays.len(), 1);
+	}
+
+	close_early_disapproved {
+		// We choose 4 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 4 .. T::MaxMembers::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes = 100;
+		let bytes_in_storage = bytes + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		let proposer = account::<T::AccountId>("proposer", 0, SEED);
+		members.push(proposer.clone());
+		for i in 1 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+		let voter = account::<T::AccountId>("voter", 0, SEED);
+		members.push(voter.clone());
+		Collective::<T, I>::set_members(SystemOrigin::Root.into(), members.clone(), None, T::MaxMembers::get())?;
+
+		// Threshold is total members so that one nay will disapprove the vote
+		let threshold = m;
+
+		// Add previous proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, bytes as usize) }.into();
+			Collective::<T, I>::propose(
+				SystemOrigin::Signed(proposer.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+		}
+
+		let index = p - 1;
+		// Have most everyone vote aye on last proposal, while keeping it from passing.
+		for j in 0 .. m - 2 {
+			let voter = &members[j as usize];
+			let approve = true;
+			Collective::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash,
+				index,
+				approve,
+			)?;
+		}
+		// Voter votes aye without resolving the vote.
+		let approve = true;
+		Collective::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash,
+			index,
+			approve,
+		)?;
+
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+
+		// Voter switches vote to nay, which kills the vote
+		let approve = false;
+		Collective::<T, I>::vote(
+			SystemOrigin::Signed(voter.clone()).into(),
+			last_hash,
+			index,
+			approve,
+		)?;
+
+		// Whitelist voter account from further DB operations.
+		let voter_key = frame_system::Account::<T>::hashed_key_for(&voter);
+		frame_benchmarking::benchmarking::add_to_whitelist(voter_key.into());
+	}: close(SystemOrigin::Signed(voter), last_hash, index, Weight::MAX, bytes_in_storage)
+	verify {
+		// The last proposal is removed.
+		assert_eq!(Collective::<T, I>::proposals().len(), (p - 1) as usize);
+		assert_last_event::<T, I>(Event::Disapproved { proposal_hash: last_hash }.into());
+	}
+
+	close_early_approved {
+		let b in 2 .. MAX_BYTES;
+		// We choose 4 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 4 .. T::MaxMembers::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes_in_storage = b + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		for i in 0 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+		let caller: T::AccountId = whitelisted_caller();
+		members.push(caller.clone());
+		Collective::<T, I>::set_members(SystemOrigin::Root.into(), members.clone(), None, T::MaxMembers::get())?;
+
+		// Threshold is 2 so any two ayes will approve the vote
+		let threshold = 2;
+
+		// Add previous proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, b as usize) }.into();
+			Collective::<T, I>::propose(
+				SystemOrigin::Signed(caller.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+		}
+
+		// Caller switches vote to nay on their own proposal, allowing them to be the deciding approval vote
+		Collective::<T, I>::vote(
+			SystemOrigin::Signed(caller.clone()).into(),
+			last_hash,
+			p - 1,
+			false,
+		)?;
+
+		// Have almost everyone vote nay on last proposal, while keeping it from failing.
+		for j in 2 .. m - 1 {
+			let voter = &members[j as usize];
+			let approve = false;
+			Collective::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash,
+				p - 1,
+				approve,
+			)?;
+		}
+
+		// Member zero is the first aye
+		Collective::<T, I>::vote(
+			SystemOrigin::Signed(members[0].clone()).into(),
+			last_hash,
+			p - 1,
+			true,
+		)?;
+
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+
+		// Caller switches vote to aye, which passes the vote
+		let index = p - 1;
+		let approve = true;
+		Collective::<T, I>::vote(
+			SystemOrigin::Signed(caller.clone()).into(),
+			last_hash,
+			index, approve,
+		)?;
+
+	}: close(SystemOrigin::Signed(caller), last_hash, index, Weight::MAX, bytes_in_storage)
+	verify {
+		// The last proposal is removed.
+		assert_eq!(Collective::<T, I>::proposals().len(), (p - 1) as usize);
+		assert_last_event::<T, I>(Event::Executed { proposal_hash: last_hash, result: Ok(()) }.into());
+	}
+
+	close_disapproved {
+		// We choose 4 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 4 .. T::MaxMembers::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes = 100;
+		let bytes_in_storage = bytes + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		for i in 0 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+		let caller: T::AccountId = whitelisted_caller();
+		members.push(caller.clone());
+		Collective::<T, I>::set_members(
+			SystemOrigin::Root.into(),
+			members.clone(),
+			Some(caller.clone()),
+			T::MaxMembers::get(),
+		)?;
+
+		// Threshold is one less than total members so that two nays will disapprove the vote
+		let threshold = m - 1;
+
+		// Add proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, bytes as usize) }.into();
+			Collective::<T, I>::propose(
+				SystemOrigin::Signed(caller.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+		}
+
+		let index = p - 1;
+		// Have almost everyone vote aye on last proposal, while keeping it from passing.
+		// A few abstainers will be the nay votes needed to fail the vote.
+		let mut yes_votes: MemberCount = 0;
+		for j in 2 .. m - 1 {
+			let voter = &members[j as usize];
+			let approve = true;
+			yes_votes += 1;
+			// vote aye till a prime nay vote keeps the proposal disapproved.
+			if <<T as Config<I>>::DefaultVote as DefaultVote>::default_vote(
+				Some(false),
+				yes_votes,
+				0,
+				m,) {
+				break;
+			}
+			Collective::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash,
+				index,
+				approve,
+			)?;
+		}
+
+		// caller is prime, prime votes nay
+		Collective::<T, I>::vote(
+			SystemOrigin::Signed(caller.clone()).into(),
+			last_hash,
+			index,
+			false,
+		)?;
+
+		System::<T>::set_block_number(BlockNumberFor::<T>::max_value());
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+
+		// Prime nay will close it as disapproved
+	}: close(SystemOrigin::Signed(caller), last_hash, index, Weight::MAX, bytes_in_storage)
+	verify {
+		assert_eq!(Collective::<T, I>::proposals().len(), (p - 1) as usize);
+		assert_last_event::<T, I>(Event::Disapproved { proposal_hash: last_hash }.into());
+	}
+
+	close_approved {
+		let b in 2 .. MAX_BYTES;
+		// We choose 4 as a minimum so we always trigger a vote in the voting loop (`for j in ...`)
+		let m in 4 .. T::MaxMembers::get();
+		let p in 1 .. T::MaxProposals::get();
+
+		let bytes_in_storage = b + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		for i in 0 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+		let caller: T::AccountId = whitelisted_caller();
+		members.push(caller.clone());
+		Collective::<T, I>::set_members(
+			SystemOrigin::Root.into(),
+			members.clone(),
+			Some(caller.clone()),
+			T::MaxMembers::get(),
+		)?;
+
+		// Threshold is two, so any two ayes will pass the vote
+		let threshold = 2;
+
+		// Add proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, b as usize) }.into();
+			Collective::<T, I>::propose(
+				SystemOrigin::Signed(caller.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+		}
+
+		// The prime member votes aye, so abstentions default to aye.
+		Collective::<T, _>::vote(
+			SystemOrigin::Signed(caller.clone()).into(),
+			last_hash,
+			p - 1,
+			true // Vote aye.
+		)?;
+
+		// Have almost everyone vote nay on last proposal, while keeping it from failing.
+		// A few abstainers will be the aye votes needed to pass the vote.
+		for j in 2 .. m - 1 {
+			let voter = &members[j as usize];
+			let approve = false;
+			Collective::<T, I>::vote(
+				SystemOrigin::Signed(voter.clone()).into(),
+				last_hash,
+				p - 1,
+				approve
+			)?;
+		}
+
+		// caller is prime, prime already votes aye by creating the proposal
+		System::<T>::set_block_number(BlockNumberFor::<T>::max_value());
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+
+		// Prime aye will close it as approved
+	}: close(SystemOrigin::Signed(caller), last_hash, p - 1, Weight::MAX, bytes_in_storage)
+	verify {
+		assert_eq!(Collective::<T, I>::proposals().len(), (p - 1) as usize);
+		assert_last_event::<T, I>(Event::Executed { proposal_hash: last_hash, result: Ok(()) }.into());
+	}
+
+	disapprove_proposal {
+		let p in 1 .. T::MaxProposals::get();
+
+		let m = 3;
+		let b = MAX_BYTES;
+		let bytes_in_storage = b + size_of::<u32>() as u32;
+
+		// Construct `members`.
+		let mut members = vec![];
+		for i in 0 .. m - 1 {
+			let member = account::<T::AccountId>("member", i, SEED);
+			members.push(member);
+		}
+		let caller = account::<T::AccountId>("caller", 0, SEED);
+		members.push(caller.clone());
+		Collective::<T, I>::set_members(
+			SystemOrigin::Root.into(),
+			members.clone(),
+			Some(caller.clone()),
+			T::MaxMembers::get(),
+		)?;
+
+		// Threshold is one less than total members so that two nays will disapprove the vote
+		let threshold = m - 1;
+
+		// Add proposals
+		let mut last_hash = T::Hash::default();
+		for i in 0 .. p {
+			// Proposals should be different so that different proposal hashes are generated
+			let proposal: T::Proposal = SystemCall::<T>::remark { remark: id_to_remark_data(i, b as usize) }.into();
+			Collective::<T, I>::propose(
+				SystemOrigin::Signed(caller.clone()).into(),
+				threshold,
+				Box::new(proposal.clone()),
+				bytes_in_storage,
+			)?;
+			last_hash = T::Hashing::hash_of(&proposal);
+		}
+
+		System::<T>::set_block_number(BlockNumberFor::<T>::max_value());
+		assert_eq!(Collective::<T, I>::proposals().len(), p as usize);
+
+	}: _(SystemOrigin::Root, last_hash)
+	verify {
+		assert_eq!(Collective::<T, I>::proposals().len(), (p - 1) as usize);
+		assert_last_event::<T, I>(Event::Disapproved { proposal_hash: last_hash }.into());
+	}
+
+	impl_benchmark_test_suite!(Collective, crate::tests::ExtBuilder::default().build(), crate::tests::Test);
+}
diff --git a/substrate/frame/collective/src/lib.rs b/substrate/frame/collective/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ac6ad39eac5a44c0ae52cebef18e8352204c3d08
--- /dev/null
+++ b/substrate/frame/collective/src/lib.rs
@@ -0,0 +1,1258 @@
+// 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.
+
+//! Collective system: Members of a set of account IDs can make their collective feelings known
+//! through dispatched calls from one of two specialized origins.
+//!
+//! The membership can be provided in one of two ways: either directly, using the Root-dispatchable
+//! function `set_members`, or indirectly, through implementing the `ChangeMembers`.
+//! The pallet assumes that the amount of members stays at or below `MaxMembers` for its weight
+//! calculations, but enforces this neither in `set_members` nor in `change_members_sorted`.
+//!
+//! A "prime" member may be set to help determine the default vote behavior based on chain
+//! config. If `PrimeDefaultVote` is used, the prime vote acts as the default vote in case of any
+//! abstentions after the voting period. If `MoreThanMajorityThenPrimeDefaultVote` is used, then
+//! abstentions will first follow the majority of the collective voting, and then the prime
+//! member.
+//!
+//! Voting happens through motions comprising a proposal (i.e. a curried dispatchable) plus a
+//! number of approvals required for it to pass and be called. Motions are open for members to
+//! vote on for a minimum period given by `MotionDuration`. As soon as the needed number of
+//! approvals is given, the motion is closed and executed. If the number of approvals is not reached
+//! during the voting period, then `close` may be called by any account in order to force the end
+//! the motion explicitly. If a prime member is defined then their vote is used in place of any
+//! abstentions and the proposal is executed if there are enough approvals counting the new votes.
+//!
+//! If there are not, or if no prime is set, then the motion is dropped without being executed.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![recursion_limit = "128"]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_io::storage;
+use sp_runtime::{traits::Hash, RuntimeDebug};
+use sp_std::{marker::PhantomData, prelude::*, result};
+
+use frame_support::{
+	dispatch::{
+		DispatchError, DispatchResult, DispatchResultWithPostInfo, Dispatchable, GetDispatchInfo,
+		Pays, PostDispatchInfo,
+	},
+	ensure, impl_ensure_origin_with_arg_ignoring_arg,
+	traits::{
+		Backing, ChangeMembers, EnsureOrigin, EnsureOriginWithArg, Get, GetBacking,
+		InitializeMembers, StorageVersion,
+	},
+	weights::Weight,
+};
+
+#[cfg(any(feature = "try-runtime", test))]
+use sp_runtime::TryRuntimeError;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod migrations;
+pub mod weights;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+const LOG_TARGET: &str = "runtime::collective";
+
+/// Simple index type for proposal counting.
+pub type ProposalIndex = u32;
+
+/// A number of members.
+///
+/// This also serves as a number of voting members, and since for motions, each member may
+/// vote exactly once, therefore also the number of votes for any given motion.
+pub type MemberCount = u32;
+
+/// Default voting strategy when a member is inactive.
+pub trait DefaultVote {
+	/// Get the default voting strategy, given:
+	///
+	/// - Whether the prime member voted Aye.
+	/// - Raw number of yes votes.
+	/// - Raw number of no votes.
+	/// - Total number of member count.
+	fn default_vote(
+		prime_vote: Option<bool>,
+		yes_votes: MemberCount,
+		no_votes: MemberCount,
+		len: MemberCount,
+	) -> bool;
+}
+
+/// Set the prime member's vote as the default vote.
+pub struct PrimeDefaultVote;
+
+impl DefaultVote for PrimeDefaultVote {
+	fn default_vote(
+		prime_vote: Option<bool>,
+		_yes_votes: MemberCount,
+		_no_votes: MemberCount,
+		_len: MemberCount,
+	) -> bool {
+		prime_vote.unwrap_or(false)
+	}
+}
+
+/// First see if yes vote are over majority of the whole collective. If so, set the default vote
+/// as yes. Otherwise, use the prime member's vote as the default vote.
+pub struct MoreThanMajorityThenPrimeDefaultVote;
+
+impl DefaultVote for MoreThanMajorityThenPrimeDefaultVote {
+	fn default_vote(
+		prime_vote: Option<bool>,
+		yes_votes: MemberCount,
+		_no_votes: MemberCount,
+		len: MemberCount,
+	) -> bool {
+		let more_than_majority = yes_votes * 2 > len;
+		more_than_majority || prime_vote.unwrap_or(false)
+	}
+}
+
+/// Origin for the collective module.
+#[derive(PartialEq, Eq, Clone, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(I))]
+#[codec(mel_bound(AccountId: MaxEncodedLen))]
+pub enum RawOrigin<AccountId, I> {
+	/// It has been condoned by a given number of members of the collective from a given total.
+	Members(MemberCount, MemberCount),
+	/// It has been condoned by a single member of the collective.
+	Member(AccountId),
+	/// Dummy to manage the fact we have instancing.
+	_Phantom(PhantomData<I>),
+}
+
+impl<AccountId, I> GetBacking for RawOrigin<AccountId, I> {
+	fn get_backing(&self) -> Option<Backing> {
+		match self {
+			RawOrigin::Members(n, d) => Some(Backing { approvals: *n, eligible: *d }),
+			_ => None,
+		}
+	}
+}
+
+/// Info for keeping track of a motion being voted on.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct Votes<AccountId, BlockNumber> {
+	/// The proposal's unique index.
+	index: ProposalIndex,
+	/// The number of approval votes that are needed to pass the motion.
+	threshold: MemberCount,
+	/// The current set of voters that approved it.
+	ayes: Vec<AccountId>,
+	/// The current set of voters that rejected it.
+	nays: Vec<AccountId>,
+	/// The hard end time of this vote.
+	end: BlockNumber,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The runtime origin type.
+		type RuntimeOrigin: From<RawOrigin<Self::AccountId, I>>;
+
+		/// The runtime call dispatch type.
+		type Proposal: Parameter
+			+ Dispatchable<
+				RuntimeOrigin = <Self as Config<I>>::RuntimeOrigin,
+				PostInfo = PostDispatchInfo,
+			> + From<frame_system::Call<Self>>
+			+ GetDispatchInfo;
+
+		/// The runtime event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The time-out for council motions.
+		type MotionDuration: Get<BlockNumberFor<Self>>;
+
+		/// Maximum number of proposals allowed to be active in parallel.
+		type MaxProposals: Get<ProposalIndex>;
+
+		/// The maximum number of members supported by the pallet. Used for weight estimation.
+		///
+		/// NOTE:
+		/// + Benchmarks will need to be re-run and weights adjusted if this changes.
+		/// + This pallet assumes that dependents keep to the limit without enforcing it.
+		type MaxMembers: Get<MemberCount>;
+
+		/// Default vote strategy of this collective.
+		type DefaultVote: DefaultVote;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Origin allowed to set collective members
+		type SetMembersOrigin: EnsureOrigin<<Self as frame_system::Config>::RuntimeOrigin>;
+
+		/// The maximum weight of a dispatch call that can be proposed and executed.
+		#[pallet::constant]
+		type MaxProposalWeight: Get<Weight>;
+	}
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		#[serde(skip)]
+		pub phantom: PhantomData<I>,
+		pub members: Vec<T::AccountId>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			use sp_std::collections::btree_set::BTreeSet;
+			let members_set: BTreeSet<_> = self.members.iter().collect();
+			assert_eq!(
+				members_set.len(),
+				self.members.len(),
+				"Members cannot contain duplicate accounts."
+			);
+			assert!(
+				self.members.len() <= T::MaxMembers::get() as usize,
+				"Members length cannot exceed MaxMembers.",
+			);
+
+			Pallet::<T, I>::initialize_members(&self.members)
+		}
+	}
+
+	/// Origin for the collective pallet.
+	#[pallet::origin]
+	pub type Origin<T, I = ()> = RawOrigin<<T as frame_system::Config>::AccountId, I>;
+
+	/// The hashes of the active proposals.
+	#[pallet::storage]
+	#[pallet::getter(fn proposals)]
+	pub type Proposals<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<T::Hash, T::MaxProposals>, ValueQuery>;
+
+	/// Actual proposal for a given hash, if it's current.
+	#[pallet::storage]
+	#[pallet::getter(fn proposal_of)]
+	pub type ProposalOf<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Identity, T::Hash, <T as Config<I>>::Proposal, OptionQuery>;
+
+	/// Votes on a given proposal, if it is ongoing.
+	#[pallet::storage]
+	#[pallet::getter(fn voting)]
+	pub type Voting<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Identity, T::Hash, Votes<T::AccountId, BlockNumberFor<T>>, OptionQuery>;
+
+	/// Proposals so far.
+	#[pallet::storage]
+	#[pallet::getter(fn proposal_count)]
+	pub type ProposalCount<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
+
+	/// The current members of the collective. This is stored sorted (just by value).
+	#[pallet::storage]
+	#[pallet::getter(fn members)]
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+
+	/// The prime member that helps determine the default vote behavior in case of absentations.
+	#[pallet::storage]
+	#[pallet::getter(fn prime)]
+	pub type Prime<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A motion (given hash) has been proposed (by given account) with a threshold (given
+		/// `MemberCount`).
+		Proposed {
+			account: T::AccountId,
+			proposal_index: ProposalIndex,
+			proposal_hash: T::Hash,
+			threshold: MemberCount,
+		},
+		/// A motion (given hash) has been voted on by given account, leaving
+		/// a tally (yes votes and no votes given respectively as `MemberCount`).
+		Voted {
+			account: T::AccountId,
+			proposal_hash: T::Hash,
+			voted: bool,
+			yes: MemberCount,
+			no: MemberCount,
+		},
+		/// A motion was approved by the required threshold.
+		Approved { proposal_hash: T::Hash },
+		/// A motion was not approved by the required threshold.
+		Disapproved { proposal_hash: T::Hash },
+		/// A motion was executed; result will be `Ok` if it returned without error.
+		Executed { proposal_hash: T::Hash, result: DispatchResult },
+		/// A single member did some action; result will be `Ok` if it returned without error.
+		MemberExecuted { proposal_hash: T::Hash, result: DispatchResult },
+		/// A proposal was closed because its threshold was reached or after its duration was up.
+		Closed { proposal_hash: T::Hash, yes: MemberCount, no: MemberCount },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Account is not a member
+		NotMember,
+		/// Duplicate proposals not allowed
+		DuplicateProposal,
+		/// Proposal must exist
+		ProposalMissing,
+		/// Mismatched index
+		WrongIndex,
+		/// Duplicate vote ignored
+		DuplicateVote,
+		/// Members are already initialized!
+		AlreadyInitialized,
+		/// The close call was made too early, before the end of the voting.
+		TooEarly,
+		/// There can only be a maximum of `MaxProposals` active proposals.
+		TooManyProposals,
+		/// The given weight bound for the proposal was too low.
+		WrongProposalWeight,
+		/// The given length bound for the proposal was too low.
+		WrongProposalLength,
+		/// Prime account is not a member
+		PrimeAccountNotMember,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_n: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+			Self::do_try_state()
+		}
+	}
+
+	// Note that councillor operations are assigned to the operational class.
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Set the collective's membership.
+		///
+		/// - `new_members`: The new member list. Be nice to the chain and provide it sorted.
+		/// - `prime`: The prime member whose vote sets the default.
+		/// - `old_count`: The upper bound for the previous number of members in storage. Used for
+		///   weight estimation.
+		///
+		/// The dispatch of this call must be `SetMembersOrigin`.
+		///
+		/// NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
+		///       the weight estimations rely on it to estimate dispatchable weight.
+		///
+		/// # WARNING:
+		///
+		/// The `pallet-collective` can also be managed by logic outside of the pallet through the
+		/// implementation of the trait [`ChangeMembers`].
+		/// Any call to `set_members` must be careful that the member set doesn't get out of sync
+		/// with other logic managing the member set.
+		///
+		/// ## Complexity:
+		/// - `O(MP + N)` where:
+		///   - `M` old-members-count (code- and governance-bounded)
+		///   - `N` new-members-count (code- and governance-bounded)
+		///   - `P` proposals-count (code-bounded)
+		#[pallet::call_index(0)]
+		#[pallet::weight((
+			T::WeightInfo::set_members(
+				*old_count, // M
+				new_members.len() as u32, // N
+				T::MaxProposals::get() // P
+			),
+			DispatchClass::Operational
+		))]
+		pub fn set_members(
+			origin: OriginFor<T>,
+			new_members: Vec<T::AccountId>,
+			prime: Option<T::AccountId>,
+			old_count: MemberCount,
+		) -> DispatchResultWithPostInfo {
+			T::SetMembersOrigin::ensure_origin(origin)?;
+			if new_members.len() > T::MaxMembers::get() as usize {
+				log::error!(
+					target: LOG_TARGET,
+					"New members count ({}) exceeds maximum amount of members expected ({}).",
+					new_members.len(),
+					T::MaxMembers::get(),
+				);
+			}
+
+			let old = Members::<T, I>::get();
+			if old.len() > old_count as usize {
+				log::warn!(
+					target: LOG_TARGET,
+					"Wrong count used to estimate set_members weight. expected ({}) vs actual ({})",
+					old_count,
+					old.len(),
+				);
+			}
+			if let Some(p) = &prime {
+				ensure!(new_members.contains(p), Error::<T, I>::PrimeAccountNotMember);
+			}
+			let mut new_members = new_members;
+			new_members.sort();
+			<Self as ChangeMembers<T::AccountId>>::set_members_sorted(&new_members, &old);
+			Prime::<T, I>::set(prime);
+
+			Ok(Some(T::WeightInfo::set_members(
+				old.len() as u32,         // M
+				new_members.len() as u32, // N
+				T::MaxProposals::get(),   // P
+			))
+			.into())
+		}
+
+		/// Dispatch a proposal from a member using the `Member` origin.
+		///
+		/// Origin must be a member of the collective.
+		///
+		/// ## Complexity:
+		/// - `O(B + M + P)` where:
+		/// - `B` is `proposal` size in bytes (length-fee-bounded)
+		/// - `M` members-count (code-bounded)
+		/// - `P` complexity of dispatching `proposal`
+		#[pallet::call_index(1)]
+		#[pallet::weight((
+			T::WeightInfo::execute(
+				*length_bound, // B
+				T::MaxMembers::get(), // M
+			).saturating_add(proposal.get_dispatch_info().weight), // P
+			DispatchClass::Operational
+		))]
+		pub fn execute(
+			origin: OriginFor<T>,
+			proposal: Box<<T as Config<I>>::Proposal>,
+			#[pallet::compact] length_bound: u32,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let members = Self::members();
+			ensure!(members.contains(&who), Error::<T, I>::NotMember);
+			let proposal_len = proposal.encoded_size();
+			ensure!(proposal_len <= length_bound as usize, Error::<T, I>::WrongProposalLength);
+
+			let proposal_hash = T::Hashing::hash_of(&proposal);
+			let result = proposal.dispatch(RawOrigin::Member(who).into());
+			Self::deposit_event(Event::MemberExecuted {
+				proposal_hash,
+				result: result.map(|_| ()).map_err(|e| e.error),
+			});
+
+			Ok(get_result_weight(result)
+				.map(|w| {
+					T::WeightInfo::execute(
+						proposal_len as u32,  // B
+						members.len() as u32, // M
+					)
+					.saturating_add(w) // P
+				})
+				.into())
+		}
+
+		/// Add a new proposal to either be voted on or executed directly.
+		///
+		/// Requires the sender to be member.
+		///
+		/// `threshold` determines whether `proposal` is executed directly (`threshold < 2`)
+		/// or put up for voting.
+		///
+		/// ## Complexity
+		/// - `O(B + M + P1)` or `O(B + M + P2)` where:
+		///   - `B` is `proposal` size in bytes (length-fee-bounded)
+		///   - `M` is members-count (code- and governance-bounded)
+		///   - branching is influenced by `threshold` where:
+		///     - `P1` is proposal execution complexity (`threshold < 2`)
+		///     - `P2` is proposals-count (code-bounded) (`threshold >= 2`)
+		#[pallet::call_index(2)]
+		#[pallet::weight((
+			if *threshold < 2 {
+				T::WeightInfo::propose_execute(
+					*length_bound, // B
+					T::MaxMembers::get(), // M
+				).saturating_add(proposal.get_dispatch_info().weight) // P1
+			} else {
+				T::WeightInfo::propose_proposed(
+					*length_bound, // B
+					T::MaxMembers::get(), // M
+					T::MaxProposals::get(), // P2
+				)
+			},
+			DispatchClass::Operational
+		))]
+		pub fn propose(
+			origin: OriginFor<T>,
+			#[pallet::compact] threshold: MemberCount,
+			proposal: Box<<T as Config<I>>::Proposal>,
+			#[pallet::compact] length_bound: u32,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let members = Self::members();
+			ensure!(members.contains(&who), Error::<T, I>::NotMember);
+
+			if threshold < 2 {
+				let (proposal_len, result) = Self::do_propose_execute(proposal, length_bound)?;
+
+				Ok(get_result_weight(result)
+					.map(|w| {
+						T::WeightInfo::propose_execute(
+							proposal_len as u32,  // B
+							members.len() as u32, // M
+						)
+						.saturating_add(w) // P1
+					})
+					.into())
+			} else {
+				let (proposal_len, active_proposals) =
+					Self::do_propose_proposed(who, threshold, proposal, length_bound)?;
+
+				Ok(Some(T::WeightInfo::propose_proposed(
+					proposal_len as u32,  // B
+					members.len() as u32, // M
+					active_proposals,     // P2
+				))
+				.into())
+			}
+		}
+
+		/// Add an aye or nay vote for the sender to the given proposal.
+		///
+		/// Requires the sender to be a member.
+		///
+		/// Transaction fees will be waived if the member is voting on any particular proposal
+		/// for the first time and the call is successful. Subsequent vote changes will charge a
+		/// fee.
+		/// ## Complexity
+		/// - `O(M)` where `M` is members-count (code- and governance-bounded)
+		#[pallet::call_index(3)]
+		#[pallet::weight((T::WeightInfo::vote(T::MaxMembers::get()), DispatchClass::Operational))]
+		pub fn vote(
+			origin: OriginFor<T>,
+			proposal: T::Hash,
+			#[pallet::compact] index: ProposalIndex,
+			approve: bool,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let members = Self::members();
+			ensure!(members.contains(&who), Error::<T, I>::NotMember);
+
+			// Detects first vote of the member in the motion
+			let is_account_voting_first_time = Self::do_vote(who, proposal, index, approve)?;
+
+			if is_account_voting_first_time {
+				Ok((Some(T::WeightInfo::vote(members.len() as u32)), Pays::No).into())
+			} else {
+				Ok((Some(T::WeightInfo::vote(members.len() as u32)), Pays::Yes).into())
+			}
+		}
+
+		// Index 4 was `close_old_weight`; it was removed due to weights v1 deprecation.
+
+		/// Disapprove a proposal, close, and remove it from the system, regardless of its current
+		/// state.
+		///
+		/// Must be called by the Root origin.
+		///
+		/// Parameters:
+		/// * `proposal_hash`: The hash of the proposal that should be disapproved.
+		///
+		/// ## Complexity
+		/// O(P) where P is the number of max proposals
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::disapprove_proposal(T::MaxProposals::get()))]
+		pub fn disapprove_proposal(
+			origin: OriginFor<T>,
+			proposal_hash: T::Hash,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			let proposal_count = Self::do_disapprove_proposal(proposal_hash);
+			Ok(Some(T::WeightInfo::disapprove_proposal(proposal_count)).into())
+		}
+
+		/// Close a vote that is either approved, disapproved or whose voting period has ended.
+		///
+		/// May be called by any signed account in order to finish voting and close the proposal.
+		///
+		/// If called before the end of the voting period it will only close the vote if it is
+		/// has enough votes to be approved or disapproved.
+		///
+		/// If called after the end of the voting period abstentions are counted as rejections
+		/// unless there is a prime member set and the prime member cast an approval.
+		///
+		/// If the close operation completes successfully with disapproval, the transaction fee will
+		/// be waived. Otherwise execution of the approved operation will be charged to the caller.
+		///
+		/// + `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed
+		/// proposal.
+		/// + `length_bound`: The upper bound for the length of the proposal in storage. Checked via
+		/// `storage::read` so it is `size_of::<u32>() == 4` larger than the pure length.
+		///
+		/// ## Complexity
+		/// - `O(B + M + P1 + P2)` where:
+		///   - `B` is `proposal` size in bytes (length-fee-bounded)
+		///   - `M` is members-count (code- and governance-bounded)
+		///   - `P1` is the complexity of `proposal` preimage.
+		///   - `P2` is proposal-count (code-bounded)
+		#[pallet::call_index(6)]
+		#[pallet::weight((
+			{
+				let b = *length_bound;
+				let m = T::MaxMembers::get();
+				let p1 = *proposal_weight_bound;
+				let p2 = T::MaxProposals::get();
+				T::WeightInfo::close_early_approved(b, m, p2)
+					.max(T::WeightInfo::close_early_disapproved(m, p2))
+					.max(T::WeightInfo::close_approved(b, m, p2))
+					.max(T::WeightInfo::close_disapproved(m, p2))
+					.saturating_add(p1)
+			},
+			DispatchClass::Operational
+		))]
+		pub fn close(
+			origin: OriginFor<T>,
+			proposal_hash: T::Hash,
+			#[pallet::compact] index: ProposalIndex,
+			proposal_weight_bound: Weight,
+			#[pallet::compact] length_bound: u32,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+
+			Self::do_close(proposal_hash, index, proposal_weight_bound, length_bound)
+		}
+	}
+}
+
+/// Return the weight of a dispatch call result as an `Option`.
+///
+/// Will return the weight regardless of what the state of the result is.
+fn get_result_weight(result: DispatchResultWithPostInfo) -> Option<Weight> {
+	match result {
+		Ok(post_info) => post_info.actual_weight,
+		Err(err) => err.post_info.actual_weight,
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Check whether `who` is a member of the collective.
+	pub fn is_member(who: &T::AccountId) -> bool {
+		// Note: The dispatchables *do not* use this to check membership so make sure
+		// to update those if this is changed.
+		Self::members().contains(who)
+	}
+
+	/// Execute immediately when adding a new proposal.
+	pub fn do_propose_execute(
+		proposal: Box<<T as Config<I>>::Proposal>,
+		length_bound: MemberCount,
+	) -> Result<(u32, DispatchResultWithPostInfo), DispatchError> {
+		let proposal_len = proposal.encoded_size();
+		ensure!(proposal_len <= length_bound as usize, Error::<T, I>::WrongProposalLength);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		ensure!(
+			proposal_weight.all_lte(T::MaxProposalWeight::get()),
+			Error::<T, I>::WrongProposalWeight
+		);
+
+		let proposal_hash = T::Hashing::hash_of(&proposal);
+		ensure!(!<ProposalOf<T, I>>::contains_key(proposal_hash), Error::<T, I>::DuplicateProposal);
+
+		let seats = Self::members().len() as MemberCount;
+		let result = proposal.dispatch(RawOrigin::Members(1, seats).into());
+		Self::deposit_event(Event::Executed {
+			proposal_hash,
+			result: result.map(|_| ()).map_err(|e| e.error),
+		});
+		Ok((proposal_len as u32, result))
+	}
+
+	/// Add a new proposal to be voted.
+	pub fn do_propose_proposed(
+		who: T::AccountId,
+		threshold: MemberCount,
+		proposal: Box<<T as Config<I>>::Proposal>,
+		length_bound: MemberCount,
+	) -> Result<(u32, u32), DispatchError> {
+		let proposal_len = proposal.encoded_size();
+		ensure!(proposal_len <= length_bound as usize, Error::<T, I>::WrongProposalLength);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		ensure!(
+			proposal_weight.all_lte(T::MaxProposalWeight::get()),
+			Error::<T, I>::WrongProposalWeight
+		);
+
+		let proposal_hash = T::Hashing::hash_of(&proposal);
+		ensure!(!<ProposalOf<T, I>>::contains_key(proposal_hash), Error::<T, I>::DuplicateProposal);
+
+		let active_proposals =
+			<Proposals<T, I>>::try_mutate(|proposals| -> Result<usize, DispatchError> {
+				proposals.try_push(proposal_hash).map_err(|_| Error::<T, I>::TooManyProposals)?;
+				Ok(proposals.len())
+			})?;
+
+		let index = Self::proposal_count();
+		<ProposalCount<T, I>>::mutate(|i| *i += 1);
+		<ProposalOf<T, I>>::insert(proposal_hash, proposal);
+		let votes = {
+			let end = frame_system::Pallet::<T>::block_number() + T::MotionDuration::get();
+			Votes { index, threshold, ayes: vec![], nays: vec![], end }
+		};
+		<Voting<T, I>>::insert(proposal_hash, votes);
+
+		Self::deposit_event(Event::Proposed {
+			account: who,
+			proposal_index: index,
+			proposal_hash,
+			threshold,
+		});
+		Ok((proposal_len as u32, active_proposals as u32))
+	}
+
+	/// Add an aye or nay vote for the member to the given proposal, returns true if it's the first
+	/// vote of the member in the motion
+	pub fn do_vote(
+		who: T::AccountId,
+		proposal: T::Hash,
+		index: ProposalIndex,
+		approve: bool,
+	) -> Result<bool, DispatchError> {
+		let mut voting = Self::voting(&proposal).ok_or(Error::<T, I>::ProposalMissing)?;
+		ensure!(voting.index == index, Error::<T, I>::WrongIndex);
+
+		let position_yes = voting.ayes.iter().position(|a| a == &who);
+		let position_no = voting.nays.iter().position(|a| a == &who);
+
+		// Detects first vote of the member in the motion
+		let is_account_voting_first_time = position_yes.is_none() && position_no.is_none();
+
+		if approve {
+			if position_yes.is_none() {
+				voting.ayes.push(who.clone());
+			} else {
+				return Err(Error::<T, I>::DuplicateVote.into())
+			}
+			if let Some(pos) = position_no {
+				voting.nays.swap_remove(pos);
+			}
+		} else {
+			if position_no.is_none() {
+				voting.nays.push(who.clone());
+			} else {
+				return Err(Error::<T, I>::DuplicateVote.into())
+			}
+			if let Some(pos) = position_yes {
+				voting.ayes.swap_remove(pos);
+			}
+		}
+
+		let yes_votes = voting.ayes.len() as MemberCount;
+		let no_votes = voting.nays.len() as MemberCount;
+		Self::deposit_event(Event::Voted {
+			account: who,
+			proposal_hash: proposal,
+			voted: approve,
+			yes: yes_votes,
+			no: no_votes,
+		});
+
+		Voting::<T, I>::insert(&proposal, voting);
+
+		Ok(is_account_voting_first_time)
+	}
+
+	/// Close a vote that is either approved, disapproved or whose voting period has ended.
+	pub fn do_close(
+		proposal_hash: T::Hash,
+		index: ProposalIndex,
+		proposal_weight_bound: Weight,
+		length_bound: u32,
+	) -> DispatchResultWithPostInfo {
+		let voting = Self::voting(&proposal_hash).ok_or(Error::<T, I>::ProposalMissing)?;
+		ensure!(voting.index == index, Error::<T, I>::WrongIndex);
+
+		let mut no_votes = voting.nays.len() as MemberCount;
+		let mut yes_votes = voting.ayes.len() as MemberCount;
+		let seats = Self::members().len() as MemberCount;
+		let approved = yes_votes >= voting.threshold;
+		let disapproved = seats.saturating_sub(no_votes) < voting.threshold;
+		// Allow (dis-)approving the proposal as soon as there are enough votes.
+		if approved {
+			let (proposal, len) = Self::validate_and_get_proposal(
+				&proposal_hash,
+				length_bound,
+				proposal_weight_bound,
+			)?;
+			Self::deposit_event(Event::Closed { proposal_hash, yes: yes_votes, no: no_votes });
+			let (proposal_weight, proposal_count) =
+				Self::do_approve_proposal(seats, yes_votes, proposal_hash, proposal);
+			return Ok((
+				Some(
+					T::WeightInfo::close_early_approved(len as u32, seats, proposal_count)
+						.saturating_add(proposal_weight),
+				),
+				Pays::Yes,
+			)
+				.into())
+		} else if disapproved {
+			Self::deposit_event(Event::Closed { proposal_hash, yes: yes_votes, no: no_votes });
+			let proposal_count = Self::do_disapprove_proposal(proposal_hash);
+			return Ok((
+				Some(T::WeightInfo::close_early_disapproved(seats, proposal_count)),
+				Pays::No,
+			)
+				.into())
+		}
+
+		// Only allow actual closing of the proposal after the voting period has ended.
+		ensure!(frame_system::Pallet::<T>::block_number() >= voting.end, Error::<T, I>::TooEarly);
+
+		let prime_vote = Self::prime().map(|who| voting.ayes.iter().any(|a| a == &who));
+
+		// default voting strategy.
+		let default = T::DefaultVote::default_vote(prime_vote, yes_votes, no_votes, seats);
+
+		let abstentions = seats - (yes_votes + no_votes);
+		match default {
+			true => yes_votes += abstentions,
+			false => no_votes += abstentions,
+		}
+		let approved = yes_votes >= voting.threshold;
+
+		if approved {
+			let (proposal, len) = Self::validate_and_get_proposal(
+				&proposal_hash,
+				length_bound,
+				proposal_weight_bound,
+			)?;
+			Self::deposit_event(Event::Closed { proposal_hash, yes: yes_votes, no: no_votes });
+			let (proposal_weight, proposal_count) =
+				Self::do_approve_proposal(seats, yes_votes, proposal_hash, proposal);
+			Ok((
+				Some(
+					T::WeightInfo::close_approved(len as u32, seats, proposal_count)
+						.saturating_add(proposal_weight),
+				),
+				Pays::Yes,
+			)
+				.into())
+		} else {
+			Self::deposit_event(Event::Closed { proposal_hash, yes: yes_votes, no: no_votes });
+			let proposal_count = Self::do_disapprove_proposal(proposal_hash);
+			Ok((Some(T::WeightInfo::close_disapproved(seats, proposal_count)), Pays::No).into())
+		}
+	}
+
+	/// Ensure that the right proposal bounds were passed and get the proposal from storage.
+	///
+	/// Checks the length in storage via `storage::read` which adds an extra `size_of::<u32>() == 4`
+	/// to the length.
+	fn validate_and_get_proposal(
+		hash: &T::Hash,
+		length_bound: u32,
+		weight_bound: Weight,
+	) -> Result<(<T as Config<I>>::Proposal, usize), DispatchError> {
+		let key = ProposalOf::<T, I>::hashed_key_for(hash);
+		// read the length of the proposal storage entry directly
+		let proposal_len =
+			storage::read(&key, &mut [0; 0], 0).ok_or(Error::<T, I>::ProposalMissing)?;
+		ensure!(proposal_len <= length_bound, Error::<T, I>::WrongProposalLength);
+		let proposal = ProposalOf::<T, I>::get(hash).ok_or(Error::<T, I>::ProposalMissing)?;
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		ensure!(proposal_weight.all_lte(weight_bound), Error::<T, I>::WrongProposalWeight);
+		Ok((proposal, proposal_len as usize))
+	}
+
+	/// Weight:
+	/// If `approved`:
+	/// - the weight of `proposal` preimage.
+	/// - two events deposited.
+	/// - two removals, one mutation.
+	/// - computation and i/o `O(P + L)` where:
+	///   - `P` is number of active proposals,
+	///   - `L` is the encoded length of `proposal` preimage.
+	///
+	/// If not `approved`:
+	/// - one event deposited.
+	/// Two removals, one mutation.
+	/// Computation and i/o `O(P)` where:
+	/// - `P` is number of active proposals
+	fn do_approve_proposal(
+		seats: MemberCount,
+		yes_votes: MemberCount,
+		proposal_hash: T::Hash,
+		proposal: <T as Config<I>>::Proposal,
+	) -> (Weight, u32) {
+		Self::deposit_event(Event::Approved { proposal_hash });
+
+		let dispatch_weight = proposal.get_dispatch_info().weight;
+		let origin = RawOrigin::Members(yes_votes, seats).into();
+		let result = proposal.dispatch(origin);
+		Self::deposit_event(Event::Executed {
+			proposal_hash,
+			result: result.map(|_| ()).map_err(|e| e.error),
+		});
+		// default to the dispatch info weight for safety
+		let proposal_weight = get_result_weight(result).unwrap_or(dispatch_weight); // P1
+
+		let proposal_count = Self::remove_proposal(proposal_hash);
+		(proposal_weight, proposal_count)
+	}
+
+	/// Removes a proposal from the pallet, and deposit the `Disapproved` event.
+	pub fn do_disapprove_proposal(proposal_hash: T::Hash) -> u32 {
+		// disapproved
+		Self::deposit_event(Event::Disapproved { proposal_hash });
+		Self::remove_proposal(proposal_hash)
+	}
+
+	// Removes a proposal from the pallet, cleaning up votes and the vector of proposals.
+	fn remove_proposal(proposal_hash: T::Hash) -> u32 {
+		// remove proposal and vote
+		ProposalOf::<T, I>::remove(&proposal_hash);
+		Voting::<T, I>::remove(&proposal_hash);
+		let num_proposals = Proposals::<T, I>::mutate(|proposals| {
+			proposals.retain(|h| h != &proposal_hash);
+			proposals.len() + 1 // calculate weight based on original length
+		});
+		num_proposals as u32
+	}
+
+	/// Ensure the correctness of the state of this pallet.
+	///
+	/// The following expectation must always apply.
+	///
+	/// ## Expectations:
+	///
+	/// Looking at proposals:
+	///
+	/// * Each hash of a proposal that is stored inside `Proposals` must have a
+	/// call mapped to it inside the `ProposalOf` storage map.
+	/// * `ProposalCount` must always be more or equal to the number of
+	/// proposals inside the `Proposals` storage value. The reason why
+	/// `ProposalCount` can be more is because when a proposal is removed the
+	/// count is not deducted.
+	/// * Count of `ProposalOf` should match the count of `Proposals`
+	///
+	/// Looking at votes:
+	/// * The sum of aye and nay votes for a proposal can never exceed
+	///  `MaxMembers`.
+	/// * The proposal index inside the `Voting` storage map must be unique.
+	/// * All proposal hashes inside `Voting` must exist in `Proposals`.
+	///
+	/// Looking at members:
+	/// * The members count must never exceed `MaxMembers`.
+	/// * All the members must be sorted by value.
+	///
+	/// Looking at prime account:
+	/// * The prime account must be a member of the collective.
+	#[cfg(any(feature = "try-runtime", test))]
+	fn do_try_state() -> Result<(), TryRuntimeError> {
+		Self::proposals()
+			.into_iter()
+			.try_for_each(|proposal| -> Result<(), TryRuntimeError> {
+				ensure!(
+					Self::proposal_of(proposal).is_some(),
+					"Proposal hash from `Proposals` is not found inside the `ProposalOf` mapping."
+				);
+				Ok(())
+			})?;
+
+		ensure!(
+			Self::proposals().into_iter().count() <= Self::proposal_count() as usize,
+			"The actual number of proposals is greater than `ProposalCount`"
+		);
+		ensure!(
+			Self::proposals().into_iter().count() == <ProposalOf<T, I>>::iter_keys().count(),
+			"Proposal count inside `Proposals` is not equal to the proposal count in `ProposalOf`"
+		);
+
+		Self::proposals()
+			.into_iter()
+			.try_for_each(|proposal| -> Result<(), TryRuntimeError> {
+				if let Some(votes) = Self::voting(proposal) {
+					let ayes = votes.ayes.len();
+					let nays = votes.nays.len();
+
+					ensure!(
+						ayes.saturating_add(nays) <= T::MaxMembers::get() as usize,
+						"The sum of ayes and nays is greater than `MaxMembers`"
+					);
+				}
+				Ok(())
+			})?;
+
+		let mut proposal_indices = vec![];
+		Self::proposals()
+			.into_iter()
+			.try_for_each(|proposal| -> Result<(), TryRuntimeError> {
+				if let Some(votes) = Self::voting(proposal) {
+					let proposal_index = votes.index;
+					ensure!(
+						!proposal_indices.contains(&proposal_index),
+						"The proposal index is not unique."
+					);
+					proposal_indices.push(proposal_index);
+				}
+				Ok(())
+			})?;
+
+		<Voting<T, I>>::iter_keys().try_for_each(
+			|proposal_hash| -> Result<(), TryRuntimeError> {
+				ensure!(
+					Self::proposals().contains(&proposal_hash),
+					"`Proposals` doesn't contain the proposal hash from the `Voting` storage map."
+				);
+				Ok(())
+			},
+		)?;
+
+		ensure!(
+			Self::members().len() <= T::MaxMembers::get() as usize,
+			"The member count is greater than `MaxMembers`."
+		);
+
+		ensure!(
+			Self::members().windows(2).all(|members| members[0] <= members[1]),
+			"The members are not sorted by value."
+		);
+
+		if let Some(prime) = Self::prime() {
+			ensure!(Self::members().contains(&prime), "Prime account is not a member.");
+		}
+
+		Ok(())
+	}
+}
+
+impl<T: Config<I>, I: 'static> ChangeMembers<T::AccountId> for Pallet<T, I> {
+	/// Update the members of the collective. Votes are updated and the prime is reset.
+	///
+	/// NOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but
+	///       the weight estimations rely on it to estimate dispatchable weight.
+	///
+	/// ## Complexity
+	/// - `O(MP + N)`
+	///   - where `M` old-members-count (governance-bounded)
+	///   - where `N` new-members-count (governance-bounded)
+	///   - where `P` proposals-count
+	fn change_members_sorted(
+		_incoming: &[T::AccountId],
+		outgoing: &[T::AccountId],
+		new: &[T::AccountId],
+	) {
+		if new.len() > T::MaxMembers::get() as usize {
+			log::error!(
+				target: LOG_TARGET,
+				"New members count ({}) exceeds maximum amount of members expected ({}).",
+				new.len(),
+				T::MaxMembers::get(),
+			);
+		}
+		// remove accounts from all current voting in motions.
+		let mut outgoing = outgoing.to_vec();
+		outgoing.sort();
+		for h in Self::proposals().into_iter() {
+			<Voting<T, I>>::mutate(h, |v| {
+				if let Some(mut votes) = v.take() {
+					votes.ayes = votes
+						.ayes
+						.into_iter()
+						.filter(|i| outgoing.binary_search(i).is_err())
+						.collect();
+					votes.nays = votes
+						.nays
+						.into_iter()
+						.filter(|i| outgoing.binary_search(i).is_err())
+						.collect();
+					*v = Some(votes);
+				}
+			});
+		}
+		Members::<T, I>::put(new);
+		Prime::<T, I>::kill();
+	}
+
+	fn set_prime(prime: Option<T::AccountId>) {
+		Prime::<T, I>::set(prime);
+	}
+
+	fn get_prime() -> Option<T::AccountId> {
+		Prime::<T, I>::get()
+	}
+}
+
+impl<T: Config<I>, I: 'static> InitializeMembers<T::AccountId> for Pallet<T, I> {
+	fn initialize_members(members: &[T::AccountId]) {
+		if !members.is_empty() {
+			assert!(<Members<T, I>>::get().is_empty(), "Members are already initialized!");
+			let mut members = members.to_vec();
+			members.sort();
+			<Members<T, I>>::put(members);
+		}
+	}
+}
+
+/// Ensure that the origin `o` represents at least `n` members. Returns `Ok` or an `Err`
+/// otherwise.
+pub fn ensure_members<OuterOrigin, AccountId, I>(
+	o: OuterOrigin,
+	n: MemberCount,
+) -> result::Result<MemberCount, &'static str>
+where
+	OuterOrigin: Into<result::Result<RawOrigin<AccountId, I>, OuterOrigin>>,
+{
+	match o.into() {
+		Ok(RawOrigin::Members(x, _)) if x >= n => Ok(n),
+		_ => Err("bad origin: expected to be a threshold number of members"),
+	}
+}
+
+pub struct EnsureMember<AccountId, I: 'static>(PhantomData<(AccountId, I)>);
+impl<
+		O: Into<Result<RawOrigin<AccountId, I>, O>> + From<RawOrigin<AccountId, I>>,
+		I,
+		AccountId: Decode,
+	> EnsureOrigin<O> for EnsureMember<AccountId, I>
+{
+	type Success = AccountId;
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Member(id) => Ok(id),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		let zero_account_id =
+			AccountId::decode(&mut sp_runtime::traits::TrailingZeroInput::zeroes())
+				.expect("infinite length input; no invalid inputs for type; qed");
+		Ok(O::from(RawOrigin::Member(zero_account_id)))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., I: 'static, AccountId: Decode, T } >
+		EnsureOriginWithArg<O, T> for EnsureMember<AccountId, I>
+	{}
+}
+
+pub struct EnsureMembers<AccountId, I: 'static, const N: u32>(PhantomData<(AccountId, I)>);
+impl<
+		O: Into<Result<RawOrigin<AccountId, I>, O>> + From<RawOrigin<AccountId, I>>,
+		AccountId,
+		I,
+		const N: u32,
+	> EnsureOrigin<O> for EnsureMembers<AccountId, I, N>
+{
+	type Success = (MemberCount, MemberCount);
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Members(n, m) if n >= N => Ok((n, m)),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Ok(O::from(RawOrigin::Members(N, N)))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., I: 'static, const N: u32, AccountId, T } >
+		EnsureOriginWithArg<O, T> for EnsureMembers<AccountId, I, N>
+	{}
+}
+
+pub struct EnsureProportionMoreThan<AccountId, I: 'static, const N: u32, const D: u32>(
+	PhantomData<(AccountId, I)>,
+);
+impl<
+		O: Into<Result<RawOrigin<AccountId, I>, O>> + From<RawOrigin<AccountId, I>>,
+		AccountId,
+		I,
+		const N: u32,
+		const D: u32,
+	> EnsureOrigin<O> for EnsureProportionMoreThan<AccountId, I, N, D>
+{
+	type Success = ();
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Members(n, m) if n * D > N * m => Ok(()),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Ok(O::from(RawOrigin::Members(1u32, 0u32)))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., I: 'static, const N: u32, const D: u32, AccountId, T } >
+		EnsureOriginWithArg<O, T> for EnsureProportionMoreThan<AccountId, I, N, D>
+	{}
+}
+
+pub struct EnsureProportionAtLeast<AccountId, I: 'static, const N: u32, const D: u32>(
+	PhantomData<(AccountId, I)>,
+);
+impl<
+		O: Into<Result<RawOrigin<AccountId, I>, O>> + From<RawOrigin<AccountId, I>>,
+		AccountId,
+		I,
+		const N: u32,
+		const D: u32,
+	> EnsureOrigin<O> for EnsureProportionAtLeast<AccountId, I, N, D>
+{
+	type Success = ();
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Members(n, m) if n * D >= N * m => Ok(()),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Ok(O::from(RawOrigin::Members(0u32, 0u32)))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., I: 'static, const N: u32, const D: u32, AccountId, T } >
+		EnsureOriginWithArg<O, T> for EnsureProportionAtLeast<AccountId, I, N, D>
+	{}
+}
diff --git a/substrate/frame/collective/src/migrations/mod.rs b/substrate/frame/collective/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2487ed1d5da5220522fc3d3143fe4166411a1dec
--- /dev/null
+++ b/substrate/frame/collective/src/migrations/mod.rs
@@ -0,0 +1,19 @@
+// 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.
+
+/// Version 4.
+pub mod v4;
diff --git a/substrate/frame/collective/src/migrations/v4.rs b/substrate/frame/collective/src/migrations/v4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b3326b4251c9bd3d2f42dba0c61ec67e22fd91c6
--- /dev/null
+++ b/substrate/frame/collective/src/migrations/v4.rs
@@ -0,0 +1,148 @@
+// 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 sp_io::hashing::twox_128;
+
+use super::super::LOG_TARGET;
+use frame_support::{
+	traits::{
+		Get, GetStorageVersion, PalletInfoAccess, StorageVersion,
+		STORAGE_VERSION_STORAGE_KEY_POSTFIX,
+	},
+	weights::Weight,
+};
+
+/// Migrate the entire storage of this pallet to a new prefix.
+///
+/// This new prefix must be the same as the one set in construct_runtime. For safety, use
+/// `PalletInfo` to get it, as:
+/// `<Runtime as frame_system::Config>::PalletInfo::name::<CollectivePallet>`.
+///
+/// The migration will look into the storage version in order not to trigger a migration on an up
+/// to date storage. Thus the on chain storage version must be less than 4 in order to trigger the
+/// migration.
+pub fn migrate<T: frame_system::Config, P: GetStorageVersion + PalletInfoAccess, N: AsRef<str>>(
+	old_pallet_name: N,
+) -> Weight {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+
+	if new_pallet_name == old_pallet_name {
+		log::info!(
+			target: LOG_TARGET,
+			"New pallet name is equal to the old pallet name. No migration needs to be done.",
+		);
+		return Weight::zero()
+	}
+
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration to v4 for collective with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 4 {
+		frame_support::storage::migration::move_pallet(
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", old_pallet_name, new_pallet_name);
+
+		StorageVersion::new(4).put::<P>();
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to v4 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::pre_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migrate<P: GetStorageVersion + PalletInfoAccess, N: AsRef<str>>(old_pallet_name: N) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+	log_migration("pre-migration", old_pallet_name, new_pallet_name);
+
+	if new_pallet_name == old_pallet_name {
+		return
+	}
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let storage_version_key = twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX);
+
+	let mut new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|key| Ok(key.to_vec()),
+	);
+
+	// Ensure nothing except the storage_version_key is stored in the new prefix.
+	assert!(new_pallet_prefix_iter.all(|key| key == storage_version_key));
+
+	assert!(<P as GetStorageVersion>::on_chain_storage_version() < 4);
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migrate<P: GetStorageVersion + PalletInfoAccess, N: AsRef<str>>(old_pallet_name: N) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+	log_migration("post-migration", old_pallet_name, new_pallet_name);
+
+	if new_pallet_name == old_pallet_name {
+		return
+	}
+
+	// Assert that nothing remains at the old prefix.
+	let old_pallet_prefix = twox_128(old_pallet_name.as_bytes());
+	let old_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		old_pallet_prefix.to_vec(),
+		old_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert_eq!(old_pallet_prefix_iter.count(), 0);
+
+	// NOTE: storage_version_key is already in the new prefix.
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert!(new_pallet_prefix_iter.count() >= 1);
+
+	assert_eq!(<P as GetStorageVersion>::on_chain_storage_version(), 4);
+}
+
+fn log_migration(stage: &str, old_pallet_name: &str, new_pallet_name: &str) {
+	log::info!(
+		target: LOG_TARGET,
+		"{}, prefix: '{}' ==> '{}'",
+		stage,
+		old_pallet_name,
+		new_pallet_name,
+	);
+}
diff --git a/substrate/frame/collective/src/tests.rs b/substrate/frame/collective/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..86b85e07a8bd9336472b0ab3de918e6839862b8f
--- /dev/null
+++ b/substrate/frame/collective/src/tests.rs
@@ -0,0 +1,1524 @@
+// 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::{Event as CollectiveEvent, *};
+use crate as pallet_collective;
+use frame_support::{
+	assert_noop, assert_ok,
+	dispatch::Pays,
+	parameter_types,
+	traits::{ConstU32, ConstU64, StorageVersion},
+	Hashable,
+};
+use frame_system::{EnsureRoot, EventRecord, Phase};
+use sp_core::H256;
+use sp_runtime::{
+	testing::Header,
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, u64, RuntimeCall, ()>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Event<T>},
+		Collective: pallet_collective::<Instance1>::{Pallet, Call, Event<T>, Origin<T>, Config<T>},
+		CollectiveMajority: pallet_collective::<Instance2>::{Pallet, Call, Event<T>, Origin<T>, Config<T>},
+		DefaultCollective: pallet_collective::{Pallet, Call, Event<T>, Origin<T>, Config<T>},
+		Democracy: mock_democracy::{Pallet, Call, Event<T>},
+	}
+);
+
+mod mock_democracy {
+	pub use pallet::*;
+	#[frame_support::pallet(dev_mode)]
+	pub mod pallet {
+		use frame_support::pallet_prelude::*;
+		use frame_system::pallet_prelude::*;
+
+		#[pallet::pallet]
+		pub struct Pallet<T>(_);
+
+		#[pallet::config]
+		pub trait Config: frame_system::Config + Sized {
+			type RuntimeEvent: From<Event<Self>>
+				+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+			type ExternalMajorityOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		}
+
+		#[pallet::call]
+		impl<T: Config> Pallet<T> {
+			pub fn external_propose_majority(origin: OriginFor<T>) -> DispatchResult {
+				T::ExternalMajorityOrigin::ensure_origin(origin)?;
+				Self::deposit_event(Event::<T>::ExternalProposed);
+				Ok(())
+			}
+		}
+
+		#[pallet::event]
+		#[pallet::generate_deposit(pub(super) fn deposit_event)]
+		pub enum Event<T: Config> {
+			ExternalProposed,
+		}
+	}
+}
+
+pub type MaxMembers = ConstU32<100>;
+type AccountId = u64;
+
+parameter_types! {
+	pub const MotionDuration: u64 = 3;
+	pub const MaxProposals: u32 = 257;
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::MAX);
+	pub static MaxProposalWeight: Weight = default_max_proposal_weight();
+}
+impl frame_system::Config for Test {
+	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 = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+impl Config<Instance1> for Test {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = ConstU64<3>;
+	type MaxProposals = MaxProposals;
+	type MaxMembers = MaxMembers;
+	type DefaultVote = PrimeDefaultVote;
+	type WeightInfo = ();
+	type SetMembersOrigin = EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxProposalWeight;
+}
+impl Config<Instance2> for Test {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = ConstU64<3>;
+	type MaxProposals = MaxProposals;
+	type MaxMembers = MaxMembers;
+	type DefaultVote = MoreThanMajorityThenPrimeDefaultVote;
+	type WeightInfo = ();
+	type SetMembersOrigin = EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxProposalWeight;
+}
+impl mock_democracy::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type ExternalMajorityOrigin = EnsureProportionAtLeast<u64, Instance1, 3, 4>;
+}
+impl Config for Test {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = ConstU64<3>;
+	type MaxProposals = MaxProposals;
+	type MaxMembers = MaxMembers;
+	type DefaultVote = PrimeDefaultVote;
+	type WeightInfo = ();
+	type SetMembersOrigin = EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxProposalWeight;
+}
+
+pub struct ExtBuilder {
+	collective_members: Vec<AccountId>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self { collective_members: vec![1, 2, 3] }
+	}
+}
+
+impl ExtBuilder {
+	fn set_collective_members(mut self, collective_members: Vec<AccountId>) -> Self {
+		self.collective_members = collective_members;
+		self
+	}
+
+	pub fn build(self) -> sp_io::TestExternalities {
+		let mut ext: sp_io::TestExternalities = RuntimeGenesisConfig {
+			collective: pallet_collective::GenesisConfig {
+				members: self.collective_members,
+				phantom: Default::default(),
+			},
+			collective_majority: pallet_collective::GenesisConfig {
+				members: vec![1, 2, 3, 4, 5],
+				phantom: Default::default(),
+			},
+			default_collective: Default::default(),
+		}
+		.build_storage()
+		.unwrap()
+		.into();
+		ext.execute_with(|| System::set_block_number(1));
+		ext
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		self.build().execute_with(|| {
+			test();
+			Collective::do_try_state().unwrap();
+		})
+	}
+}
+
+fn make_proposal(value: u64) -> RuntimeCall {
+	RuntimeCall::System(frame_system::Call::remark_with_event {
+		remark: value.to_be_bytes().to_vec(),
+	})
+}
+
+fn record(event: RuntimeEvent) -> EventRecord<RuntimeEvent, H256> {
+	EventRecord { phase: Phase::Initialization, event, topics: vec![] }
+}
+
+fn default_max_proposal_weight() -> Weight {
+	sp_runtime::Perbill::from_percent(80) * BlockWeights::get().max_block
+}
+
+#[test]
+fn motions_basic_environment_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(Collective::members(), vec![1, 2, 3]);
+		assert_eq!(*Collective::proposals(), Vec::<H256>::new());
+	});
+}
+
+#[test]
+fn initialize_members_sorts_members() {
+	let unsorted_members = vec![3, 2, 4, 1];
+	let expected_members = vec![1, 2, 3, 4];
+	ExtBuilder::default()
+		.set_collective_members(unsorted_members)
+		.build_and_execute(|| {
+			assert_eq!(Collective::members(), expected_members);
+		});
+}
+
+#[test]
+fn set_members_with_prime_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let members = vec![1, 2, 3];
+		assert_ok!(Collective::set_members(
+			RuntimeOrigin::root(),
+			members.clone(),
+			Some(3),
+			MaxMembers::get()
+		));
+		assert_eq!(Collective::members(), members.clone());
+		assert_eq!(Collective::prime(), Some(3));
+		assert_noop!(
+			Collective::set_members(RuntimeOrigin::root(), members, Some(4), MaxMembers::get()),
+			Error::<Test, Instance1>::PrimeAccountNotMember
+		);
+	});
+}
+
+#[test]
+fn proposal_weight_limit_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+
+		// set a small limit for max proposal weight.
+		MaxProposalWeight::set(Weight::from_parts(1, 1));
+		assert_noop!(
+			Collective::propose(
+				RuntimeOrigin::signed(1),
+				2,
+				Box::new(proposal.clone()),
+				proposal_len
+			),
+			Error::<Test, Instance1>::WrongProposalWeight
+		);
+
+		// reset the max weight to default.
+		MaxProposalWeight::set(default_max_proposal_weight());
+	});
+}
+
+#[test]
+fn close_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+
+		System::set_block_number(3);
+		assert_noop!(
+			Collective::close(RuntimeOrigin::signed(4), hash, 0, proposal_weight, proposal_len),
+			Error::<Test, Instance1>::TooEarly
+		);
+
+		System::set_block_number(4);
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 3
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 2,
+					no: 1
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Disapproved {
+					proposal_hash: hash
+				}))
+			]
+		);
+	});
+}
+
+#[test]
+fn proposal_weight_limit_works_on_approve() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = RuntimeCall::Collective(crate::Call::set_members {
+			new_members: vec![1, 2, 3],
+			prime: None,
+			old_count: MaxMembers::get(),
+		});
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+		// Set 1 as prime voter
+		Prime::<Test, Instance1>::set(Some(1));
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		// With 1's prime vote, this should pass
+		System::set_block_number(4);
+		assert_noop!(
+			Collective::close(
+				RuntimeOrigin::signed(4),
+				hash,
+				0,
+				proposal_weight - Weight::from_parts(100, 0),
+				proposal_len
+			),
+			Error::<Test, Instance1>::WrongProposalWeight
+		);
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+	})
+}
+
+#[test]
+fn proposal_weight_limit_ignored_on_disapprove() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = RuntimeCall::Collective(crate::Call::set_members {
+			new_members: vec![1, 2, 3],
+			prime: None,
+			old_count: MaxMembers::get(),
+		});
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		// No votes, this proposal wont pass
+		System::set_block_number(4);
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight - Weight::from_parts(100, 0),
+			proposal_len
+		));
+	})
+}
+
+#[test]
+fn close_with_prime_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+		assert_ok!(Collective::set_members(
+			RuntimeOrigin::root(),
+			vec![1, 2, 3],
+			Some(3),
+			MaxMembers::get()
+		));
+
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+
+		System::set_block_number(4);
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 3
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 2,
+					no: 1
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Disapproved {
+					proposal_hash: hash
+				}))
+			]
+		);
+	});
+}
+
+#[test]
+fn close_with_voting_prime_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+		assert_ok!(Collective::set_members(
+			RuntimeOrigin::root(),
+			vec![1, 2, 3],
+			Some(1),
+			MaxMembers::get()
+		));
+
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+
+		System::set_block_number(4);
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 3
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 3,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Approved { proposal_hash: hash })),
+				record(RuntimeEvent::Collective(CollectiveEvent::Executed {
+					proposal_hash: hash,
+					result: Err(DispatchError::BadOrigin)
+				}))
+			]
+		);
+	});
+}
+
+#[test]
+fn close_with_no_prime_but_majority_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+		assert_ok!(CollectiveMajority::set_members(
+			RuntimeOrigin::root(),
+			vec![1, 2, 3, 4, 5],
+			Some(5),
+			MaxMembers::get()
+		));
+
+		assert_ok!(CollectiveMajority::propose(
+			RuntimeOrigin::signed(1),
+			5,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(CollectiveMajority::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(CollectiveMajority::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_ok!(CollectiveMajority::vote(RuntimeOrigin::signed(3), hash, 0, true));
+
+		System::set_block_number(4);
+		assert_ok!(CollectiveMajority::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::CollectiveMajority(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 5
+				})),
+				record(RuntimeEvent::CollectiveMajority(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::CollectiveMajority(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::CollectiveMajority(CollectiveEvent::Voted {
+					account: 3,
+					proposal_hash: hash,
+					voted: true,
+					yes: 3,
+					no: 0
+				})),
+				record(RuntimeEvent::CollectiveMajority(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 5,
+					no: 0
+				})),
+				record(RuntimeEvent::CollectiveMajority(CollectiveEvent::Approved {
+					proposal_hash: hash
+				})),
+				record(RuntimeEvent::CollectiveMajority(CollectiveEvent::Executed {
+					proposal_hash: hash,
+					result: Err(DispatchError::BadOrigin)
+				}))
+			]
+		);
+	});
+}
+
+#[test]
+fn removal_of_old_voters_votes_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash = BlakeTwo256::hash_of(&proposal);
+		let end = 4;
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 3, ayes: vec![1, 2], nays: vec![], end })
+		);
+		Collective::change_members_sorted(&[4], &[1], &[2, 3, 4]);
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 3, ayes: vec![2], nays: vec![], end })
+		);
+
+		let proposal = make_proposal(69);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash = BlakeTwo256::hash_of(&proposal);
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(2),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 1, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(3), hash, 1, false));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 1, threshold: 2, ayes: vec![2], nays: vec![3], end })
+		);
+		Collective::change_members_sorted(&[], &[3], &[2, 4]);
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 1, threshold: 2, ayes: vec![2], nays: vec![], end })
+		);
+	});
+}
+
+#[test]
+fn removal_of_old_voters_votes_works_with_set_members() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash = BlakeTwo256::hash_of(&proposal);
+		let end = 4;
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 3, ayes: vec![1, 2], nays: vec![], end })
+		);
+		assert_ok!(Collective::set_members(
+			RuntimeOrigin::root(),
+			vec![2, 3, 4],
+			None,
+			MaxMembers::get()
+		));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 3, ayes: vec![2], nays: vec![], end })
+		);
+
+		let proposal = make_proposal(69);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash = BlakeTwo256::hash_of(&proposal);
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(2),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 1, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(3), hash, 1, false));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 1, threshold: 2, ayes: vec![2], nays: vec![3], end })
+		);
+		assert_ok!(Collective::set_members(
+			RuntimeOrigin::root(),
+			vec![2, 4],
+			None,
+			MaxMembers::get()
+		));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 1, threshold: 2, ayes: vec![2], nays: vec![], end })
+		);
+	});
+}
+
+#[test]
+fn propose_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash = proposal.blake2_256().into();
+		let end = 4;
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_eq!(*Collective::proposals(), vec![hash]);
+		assert_eq!(Collective::proposal_of(&hash), Some(proposal));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 3, ayes: vec![], nays: vec![], end })
+		);
+
+		assert_eq!(
+			System::events(),
+			vec![record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+				account: 1,
+				proposal_index: 0,
+				proposal_hash: hash,
+				threshold: 3
+			}))]
+		);
+	});
+}
+
+#[test]
+fn limit_active_proposals() {
+	ExtBuilder::default().build_and_execute(|| {
+		for i in 0..MaxProposals::get() {
+			let proposal = make_proposal(i as u64);
+			let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+			assert_ok!(Collective::propose(
+				RuntimeOrigin::signed(1),
+				3,
+				Box::new(proposal.clone()),
+				proposal_len
+			));
+		}
+		let proposal = make_proposal(MaxProposals::get() as u64 + 1);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		assert_noop!(
+			Collective::propose(
+				RuntimeOrigin::signed(1),
+				3,
+				Box::new(proposal.clone()),
+				proposal_len
+			),
+			Error::<Test, Instance1>::TooManyProposals
+		);
+	})
+}
+
+#[test]
+fn correct_validate_and_get_proposal() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = RuntimeCall::Collective(crate::Call::set_members {
+			new_members: vec![1, 2, 3],
+			prime: None,
+			old_count: MaxMembers::get(),
+		});
+		let length = proposal.encode().len() as u32;
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			length
+		));
+
+		let hash = BlakeTwo256::hash_of(&proposal);
+		let weight = proposal.get_dispatch_info().weight;
+		assert_noop!(
+			Collective::validate_and_get_proposal(
+				&BlakeTwo256::hash_of(&vec![3; 4]),
+				length,
+				weight
+			),
+			Error::<Test, Instance1>::ProposalMissing
+		);
+		assert_noop!(
+			Collective::validate_and_get_proposal(&hash, length - 2, weight),
+			Error::<Test, Instance1>::WrongProposalLength
+		);
+		assert_noop!(
+			Collective::validate_and_get_proposal(
+				&hash,
+				length,
+				weight - Weight::from_parts(10, 0)
+			),
+			Error::<Test, Instance1>::WrongProposalWeight
+		);
+		let res = Collective::validate_and_get_proposal(&hash, length, weight);
+		assert_ok!(res.clone());
+		let (retrieved_proposal, len) = res.unwrap();
+		assert_eq!(length as usize, len);
+		assert_eq!(proposal, retrieved_proposal);
+	})
+}
+
+#[test]
+fn motions_ignoring_non_collective_proposals_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		assert_noop!(
+			Collective::propose(
+				RuntimeOrigin::signed(42),
+				3,
+				Box::new(proposal.clone()),
+				proposal_len
+			),
+			Error::<Test, Instance1>::NotMember
+		);
+	});
+}
+
+#[test]
+fn motions_ignoring_non_collective_votes_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_noop!(
+			Collective::vote(RuntimeOrigin::signed(42), hash, 0, true),
+			Error::<Test, Instance1>::NotMember,
+		);
+	});
+}
+
+#[test]
+fn motions_ignoring_bad_index_collective_vote_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		System::set_block_number(3);
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_noop!(
+			Collective::vote(RuntimeOrigin::signed(2), hash, 1, true),
+			Error::<Test, Instance1>::WrongIndex,
+		);
+	});
+}
+
+#[test]
+fn motions_vote_after_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash: H256 = proposal.blake2_256().into();
+		let end = 4;
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		// Initially there a no votes when the motion is proposed.
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 2, ayes: vec![], nays: vec![], end })
+		);
+		// Cast first aye vote.
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 2, ayes: vec![1], nays: vec![], end })
+		);
+		// Try to cast a duplicate aye vote.
+		assert_noop!(
+			Collective::vote(RuntimeOrigin::signed(1), hash, 0, true),
+			Error::<Test, Instance1>::DuplicateVote,
+		);
+		// Cast a nay vote.
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, false));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 2, ayes: vec![], nays: vec![1], end })
+		);
+		// Try to cast a duplicate nay vote.
+		assert_noop!(
+			Collective::vote(RuntimeOrigin::signed(1), hash, 0, false),
+			Error::<Test, Instance1>::DuplicateVote,
+		);
+
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 2
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: false,
+					yes: 0,
+					no: 1
+				})),
+			]
+		);
+	});
+}
+
+#[test]
+fn motions_all_first_vote_free_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash: H256 = proposal.blake2_256().into();
+		let end = 4;
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len,
+		));
+		assert_eq!(
+			Collective::voting(&hash),
+			Some(Votes { index: 0, threshold: 2, ayes: vec![], nays: vec![], end })
+		);
+
+		// For the motion, acc 2's first vote, expecting Ok with Pays::No.
+		let vote_rval: DispatchResultWithPostInfo =
+			Collective::vote(RuntimeOrigin::signed(2), hash, 0, true);
+		assert_eq!(vote_rval.unwrap().pays_fee, Pays::No);
+
+		// Duplicate vote, expecting error with Pays::Yes.
+		let vote_rval: DispatchResultWithPostInfo =
+			Collective::vote(RuntimeOrigin::signed(2), hash, 0, true);
+		assert_eq!(vote_rval.unwrap_err().post_info.pays_fee, Pays::Yes);
+
+		// Modifying vote, expecting ok with Pays::Yes.
+		let vote_rval: DispatchResultWithPostInfo =
+			Collective::vote(RuntimeOrigin::signed(2), hash, 0, false);
+		assert_eq!(vote_rval.unwrap().pays_fee, Pays::Yes);
+
+		// For the motion, acc 3's first vote, expecting Ok with Pays::No.
+		let vote_rval: DispatchResultWithPostInfo =
+			Collective::vote(RuntimeOrigin::signed(3), hash, 0, true);
+		assert_eq!(vote_rval.unwrap().pays_fee, Pays::No);
+
+		// acc 3 modify the vote, expecting Ok with Pays::Yes.
+		let vote_rval: DispatchResultWithPostInfo =
+			Collective::vote(RuntimeOrigin::signed(3), hash, 0, false);
+		assert_eq!(vote_rval.unwrap().pays_fee, Pays::Yes);
+
+		// Test close() Extrincis | Check DispatchResultWithPostInfo with Pay Info
+
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let close_rval: DispatchResultWithPostInfo =
+			Collective::close(RuntimeOrigin::signed(2), hash, 0, proposal_weight, proposal_len);
+		assert_eq!(close_rval.unwrap().pays_fee, Pays::No);
+
+		// trying to close the proposal, which is already closed.
+		// Expecting error "ProposalMissing" with Pays::Yes
+		let close_rval: DispatchResultWithPostInfo =
+			Collective::close(RuntimeOrigin::signed(2), hash, 0, proposal_weight, proposal_len);
+		assert_eq!(close_rval.unwrap_err().post_info.pays_fee, Pays::Yes);
+	});
+}
+
+#[test]
+fn motions_reproposing_disapproved_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, false));
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(2),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+		assert_eq!(*Collective::proposals(), vec![]);
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_eq!(*Collective::proposals(), vec![hash]);
+	});
+}
+
+#[test]
+fn motions_approval_with_enough_votes_and_lower_voting_threshold_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = RuntimeCall::Democracy(mock_democracy::Call::external_propose_majority {});
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash: H256 = proposal.blake2_256().into();
+		// The voting threshold is 2, but the required votes for `ExternalMajorityOrigin` is 3.
+		// The proposal will be executed regardless of the voting threshold
+		// as long as we have enough yes votes.
+		//
+		// Failed to execute with only 2 yes votes.
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(2),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 2
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Approved { proposal_hash: hash })),
+				record(RuntimeEvent::Collective(CollectiveEvent::Executed {
+					proposal_hash: hash,
+					result: Err(DispatchError::BadOrigin)
+				})),
+			]
+		);
+
+		System::reset_events();
+
+		// Executed with 3 yes votes.
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 1, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 1, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(3), hash, 1, true));
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(2),
+			hash,
+			1,
+			proposal_weight,
+			proposal_len
+		));
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 1,
+					proposal_hash: hash,
+					threshold: 2
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 3,
+					proposal_hash: hash,
+					voted: true,
+					yes: 3,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 3,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Approved { proposal_hash: hash })),
+				record(RuntimeEvent::Democracy(
+					mock_democracy::pallet::Event::<Test>::ExternalProposed
+				)),
+				record(RuntimeEvent::Collective(CollectiveEvent::Executed {
+					proposal_hash: hash,
+					result: Ok(())
+				})),
+			]
+		);
+	});
+}
+
+#[test]
+fn motions_disapproval_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, false));
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(2),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 3
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: false,
+					yes: 1,
+					no: 1
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 1,
+					no: 1
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Disapproved {
+					proposal_hash: hash
+				})),
+			]
+		);
+	});
+}
+
+#[test]
+fn motions_approval_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(2),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 2
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+					proposal_hash: hash,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Approved { proposal_hash: hash })),
+				record(RuntimeEvent::Collective(CollectiveEvent::Executed {
+					proposal_hash: hash,
+					result: Err(DispatchError::BadOrigin)
+				})),
+			]
+		);
+	});
+}
+
+#[test]
+fn motion_with_no_votes_closes_with_disapproval() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		assert_eq!(
+			System::events()[0],
+			record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+				account: 1,
+				proposal_index: 0,
+				proposal_hash: hash,
+				threshold: 3
+			}))
+		);
+
+		// Closing the motion too early is not possible because it has neither
+		// an approving or disapproving simple majority due to the lack of votes.
+		assert_noop!(
+			Collective::close(RuntimeOrigin::signed(2), hash, 0, proposal_weight, proposal_len),
+			Error::<Test, Instance1>::TooEarly
+		);
+
+		// Once the motion duration passes,
+		let closing_block = System::block_number() + MotionDuration::get();
+		System::set_block_number(closing_block);
+		// we can successfully close the motion.
+		assert_ok!(Collective::close(
+			RuntimeOrigin::signed(2),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		// Events show that the close ended in a disapproval.
+		assert_eq!(
+			System::events()[1],
+			record(RuntimeEvent::Collective(CollectiveEvent::Closed {
+				proposal_hash: hash,
+				yes: 0,
+				no: 3
+			}))
+		);
+		assert_eq!(
+			System::events()[2],
+			record(RuntimeEvent::Collective(CollectiveEvent::Disapproved { proposal_hash: hash }))
+		);
+	})
+}
+
+#[test]
+fn close_disapprove_does_not_care_about_weight_or_len() {
+	// This test confirms that if you close a proposal that would be disapproved,
+	// we do not care about the proposal length or proposal weight since it will
+	// not be read from storage or executed.
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		// First we make the proposal succeed
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		// It will not close with bad weight/len information
+		assert_noop!(
+			Collective::close(RuntimeOrigin::signed(2), hash, 0, Weight::zero(), 0),
+			Error::<Test, Instance1>::WrongProposalLength,
+		);
+		assert_noop!(
+			Collective::close(RuntimeOrigin::signed(2), hash, 0, Weight::zero(), proposal_len),
+			Error::<Test, Instance1>::WrongProposalWeight,
+		);
+		// Now we make the proposal fail
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, false));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, false));
+		// It can close even if the weight/len information is bad
+		assert_ok!(Collective::close(RuntimeOrigin::signed(2), hash, 0, Weight::zero(), 0));
+	})
+}
+
+#[test]
+fn disapprove_proposal_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let proposal = make_proposal(42);
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let hash: H256 = proposal.blake2_256().into();
+		assert_ok!(Collective::propose(
+			RuntimeOrigin::signed(1),
+			2,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+		// Proposal would normally succeed
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Collective::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		// But Root can disapprove and remove it anyway
+		assert_ok!(Collective::disapprove_proposal(RuntimeOrigin::root(), hash));
+		assert_eq!(
+			System::events(),
+			vec![
+				record(RuntimeEvent::Collective(CollectiveEvent::Proposed {
+					account: 1,
+					proposal_index: 0,
+					proposal_hash: hash,
+					threshold: 2
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 1,
+					proposal_hash: hash,
+					voted: true,
+					yes: 1,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Voted {
+					account: 2,
+					proposal_hash: hash,
+					voted: true,
+					yes: 2,
+					no: 0
+				})),
+				record(RuntimeEvent::Collective(CollectiveEvent::Disapproved {
+					proposal_hash: hash
+				})),
+			]
+		);
+	})
+}
+
+#[should_panic(expected = "Members length cannot exceed MaxMembers.")]
+#[test]
+fn genesis_build_panics_with_too_many_members() {
+	let max_members: u32 = MaxMembers::get();
+	let too_many_members = (1..=max_members as u64 + 1).collect::<Vec<AccountId>>();
+	pallet_collective::GenesisConfig::<Test> {
+		members: too_many_members,
+		phantom: Default::default(),
+	}
+	.build_storage()
+	.unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Members cannot contain duplicate accounts.")]
+fn genesis_build_panics_with_duplicate_members() {
+	pallet_collective::GenesisConfig::<Test> {
+		members: vec![1, 2, 3, 1],
+		phantom: Default::default(),
+	}
+	.build_storage()
+	.unwrap();
+}
+
+#[test]
+fn migration_v4() {
+	ExtBuilder::default().build_and_execute(|| {
+		use frame_support::traits::PalletInfoAccess;
+
+		let old_pallet = "OldCollective";
+		let new_pallet = <Collective as PalletInfoAccess>::name();
+		frame_support::storage::migration::move_pallet(
+			new_pallet.as_bytes(),
+			old_pallet.as_bytes(),
+		);
+		StorageVersion::new(0).put::<Collective>();
+
+		crate::migrations::v4::pre_migrate::<Collective, _>(old_pallet);
+		crate::migrations::v4::migrate::<Test, Collective, _>(old_pallet);
+		crate::migrations::v4::post_migrate::<Collective, _>(old_pallet);
+
+		let old_pallet = "OldCollectiveMajority";
+		let new_pallet = <CollectiveMajority as PalletInfoAccess>::name();
+		frame_support::storage::migration::move_pallet(
+			new_pallet.as_bytes(),
+			old_pallet.as_bytes(),
+		);
+		StorageVersion::new(0).put::<CollectiveMajority>();
+
+		crate::migrations::v4::pre_migrate::<CollectiveMajority, _>(old_pallet);
+		crate::migrations::v4::migrate::<Test, CollectiveMajority, _>(old_pallet);
+		crate::migrations::v4::post_migrate::<CollectiveMajority, _>(old_pallet);
+
+		let old_pallet = "OldDefaultCollective";
+		let new_pallet = <DefaultCollective as PalletInfoAccess>::name();
+		frame_support::storage::migration::move_pallet(
+			new_pallet.as_bytes(),
+			old_pallet.as_bytes(),
+		);
+		StorageVersion::new(0).put::<DefaultCollective>();
+
+		crate::migrations::v4::pre_migrate::<DefaultCollective, _>(old_pallet);
+		crate::migrations::v4::migrate::<Test, DefaultCollective, _>(old_pallet);
+		crate::migrations::v4::post_migrate::<DefaultCollective, _>(old_pallet);
+	});
+}
diff --git a/substrate/frame/collective/src/weights.rs b/substrate/frame/collective/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eece6a006b8f2bda108645e3d8b165a37ad04335
--- /dev/null
+++ b/substrate/frame/collective/src/weights.rs
@@ -0,0 +1,558 @@
+// 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.
+
+//! Autogenerated weights for pallet_collective
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_collective
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/collective/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_collective.
+pub trait WeightInfo {
+	fn set_members(m: u32, n: u32, p: u32, ) -> Weight;
+	fn execute(b: u32, m: u32, ) -> Weight;
+	fn propose_execute(b: u32, m: u32, ) -> Weight;
+	fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight;
+	fn vote(m: u32, ) -> Weight;
+	fn close_early_disapproved(m: u32, p: u32, ) -> Weight;
+	fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight;
+	fn close_disapproved(m: u32, p: u32, ) -> Weight;
+	fn close_approved(b: u32, m: u32, p: u32, ) -> Weight;
+	fn disapprove_proposal(p: u32, ) -> Weight;
+}
+
+/// Weights for pallet_collective using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Council Members (r:1 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:100 w:100)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:0 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[0, 100]`.
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `p` is `[0, 100]`.
+	fn set_members(m: u32, _n: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + m * (3232 ±0) + p * (3190 ±0)`
+		//  Estimated: `15861 + m * (1967 ±24) + p * (4332 ±24)`
+		// Minimum execution time: 17_506_000 picoseconds.
+		Weight::from_parts(17_767_000, 15861)
+			// Standard Error: 60_220
+			.saturating_add(Weight::from_parts(4_374_805, 0).saturating_mul(m.into()))
+			// Standard Error: 60_220
+			.saturating_add(Weight::from_parts(8_398_316, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into())))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into())))
+			.saturating_add(Weight::from_parts(0, 1967).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 4332).saturating_mul(p.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[1, 100]`.
+	fn execute(b: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `202 + m * (32 ±0)`
+		//  Estimated: `1688 + m * (32 ±0)`
+		// Minimum execution time: 16_203_000 picoseconds.
+		Weight::from_parts(15_348_267, 1688)
+			// Standard Error: 37
+			.saturating_add(Weight::from_parts(1_766, 0).saturating_mul(b.into()))
+			// Standard Error: 382
+			.saturating_add(Weight::from_parts(15_765, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:0)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[1, 100]`.
+	fn propose_execute(b: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `202 + m * (32 ±0)`
+		//  Estimated: `3668 + m * (32 ±0)`
+		// Minimum execution time: 18_642_000 picoseconds.
+		Weight::from_parts(17_708_609, 3668)
+			// Standard Error: 58
+			.saturating_add(Weight::from_parts(2_285, 0).saturating_mul(b.into()))
+			// Standard Error: 598
+			.saturating_add(Weight::from_parts(30_454, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalCount (r:1 w:1)
+	/// Proof Skipped: Council ProposalCount (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:0 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[2, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `492 + m * (32 ±0) + p * (36 ±0)`
+		//  Estimated: `3884 + m * (33 ±0) + p * (36 ±0)`
+		// Minimum execution time: 27_067_000 picoseconds.
+		Weight::from_parts(25_456_964, 3884)
+			// Standard Error: 112
+			.saturating_add(Weight::from_parts(3_773, 0).saturating_mul(b.into()))
+			// Standard Error: 1_177
+			.saturating_add(Weight::from_parts(32_783, 0).saturating_mul(m.into()))
+			// Standard Error: 1_162
+			.saturating_add(Weight::from_parts(194_388, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 33).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[5, 100]`.
+	fn vote(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `941 + m * (64 ±0)`
+		//  Estimated: `4405 + m * (64 ±0)`
+		// Minimum execution time: 26_055_000 picoseconds.
+		Weight::from_parts(27_251_907, 4405)
+			// Standard Error: 1_008
+			.saturating_add(Weight::from_parts(65_947, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:0 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `530 + m * (64 ±0) + p * (36 ±0)`
+		//  Estimated: `3975 + m * (65 ±0) + p * (36 ±0)`
+		// Minimum execution time: 28_363_000 picoseconds.
+		Weight::from_parts(28_733_464, 3975)
+			// Standard Error: 1_275
+			.saturating_add(Weight::from_parts(43_236, 0).saturating_mul(m.into()))
+			// Standard Error: 1_244
+			.saturating_add(Weight::from_parts(180_187, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `832 + b * (1 ±0) + m * (64 ±0) + p * (40 ±0)`
+		//  Estimated: `4149 + b * (1 ±0) + m * (66 ±0) + p * (40 ±0)`
+		// Minimum execution time: 40_391_000 picoseconds.
+		Weight::from_parts(42_695_215, 4149)
+			// Standard Error: 167
+			.saturating_add(Weight::from_parts(3_622, 0).saturating_mul(b.into()))
+			// Standard Error: 1_772
+			.saturating_add(Weight::from_parts(33_830, 0).saturating_mul(m.into()))
+			// Standard Error: 1_727
+			.saturating_add(Weight::from_parts(205_374, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into()))
+			.saturating_add(Weight::from_parts(0, 66).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:0)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:0 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `550 + m * (64 ±0) + p * (36 ±0)`
+		//  Estimated: `3995 + m * (65 ±0) + p * (36 ±0)`
+		// Minimum execution time: 31_368_000 picoseconds.
+		Weight::from_parts(32_141_835, 3995)
+			// Standard Error: 1_451
+			.saturating_add(Weight::from_parts(36_372, 0).saturating_mul(m.into()))
+			// Standard Error: 1_415
+			.saturating_add(Weight::from_parts(210_635, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:0)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `852 + b * (1 ±0) + m * (64 ±0) + p * (40 ±0)`
+		//  Estimated: `4169 + b * (1 ±0) + m * (66 ±0) + p * (40 ±0)`
+		// Minimum execution time: 43_271_000 picoseconds.
+		Weight::from_parts(45_495_648, 4169)
+			// Standard Error: 174
+			.saturating_add(Weight::from_parts(3_034, 0).saturating_mul(b.into()))
+			// Standard Error: 1_840
+			.saturating_add(Weight::from_parts(42_209, 0).saturating_mul(m.into()))
+			// Standard Error: 1_793
+			.saturating_add(Weight::from_parts(207_525, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into()))
+			.saturating_add(Weight::from_parts(0, 66).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into()))
+	}
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:0 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:0 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `p` is `[1, 100]`.
+	fn disapprove_proposal(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `359 + p * (32 ±0)`
+		//  Estimated: `1844 + p * (32 ±0)`
+		// Minimum execution time: 15_170_000 picoseconds.
+		Weight::from_parts(17_567_243, 1844)
+			// Standard Error: 1_430
+			.saturating_add(Weight::from_parts(169_040, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(p.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Council Members (r:1 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:100 w:100)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:0 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[0, 100]`.
+	/// The range of component `n` is `[0, 100]`.
+	/// The range of component `p` is `[0, 100]`.
+	fn set_members(m: u32, _n: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + m * (3232 ±0) + p * (3190 ±0)`
+		//  Estimated: `15861 + m * (1967 ±24) + p * (4332 ±24)`
+		// Minimum execution time: 17_506_000 picoseconds.
+		Weight::from_parts(17_767_000, 15861)
+			// Standard Error: 60_220
+			.saturating_add(Weight::from_parts(4_374_805, 0).saturating_mul(m.into()))
+			// Standard Error: 60_220
+			.saturating_add(Weight::from_parts(8_398_316, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(p.into())))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(p.into())))
+			.saturating_add(Weight::from_parts(0, 1967).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 4332).saturating_mul(p.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[1, 100]`.
+	fn execute(b: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `202 + m * (32 ±0)`
+		//  Estimated: `1688 + m * (32 ±0)`
+		// Minimum execution time: 16_203_000 picoseconds.
+		Weight::from_parts(15_348_267, 1688)
+			// Standard Error: 37
+			.saturating_add(Weight::from_parts(1_766, 0).saturating_mul(b.into()))
+			// Standard Error: 382
+			.saturating_add(Weight::from_parts(15_765, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:0)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[1, 100]`.
+	fn propose_execute(b: u32, m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `202 + m * (32 ±0)`
+		//  Estimated: `3668 + m * (32 ±0)`
+		// Minimum execution time: 18_642_000 picoseconds.
+		Weight::from_parts(17_708_609, 3668)
+			// Standard Error: 58
+			.saturating_add(Weight::from_parts(2_285, 0).saturating_mul(b.into()))
+			// Standard Error: 598
+			.saturating_add(Weight::from_parts(30_454, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalCount (r:1 w:1)
+	/// Proof Skipped: Council ProposalCount (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:0 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[2, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `492 + m * (32 ±0) + p * (36 ±0)`
+		//  Estimated: `3884 + m * (33 ±0) + p * (36 ±0)`
+		// Minimum execution time: 27_067_000 picoseconds.
+		Weight::from_parts(25_456_964, 3884)
+			// Standard Error: 112
+			.saturating_add(Weight::from_parts(3_773, 0).saturating_mul(b.into()))
+			// Standard Error: 1_177
+			.saturating_add(Weight::from_parts(32_783, 0).saturating_mul(m.into()))
+			// Standard Error: 1_162
+			.saturating_add(Weight::from_parts(194_388, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 33).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[5, 100]`.
+	fn vote(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `941 + m * (64 ±0)`
+		//  Estimated: `4405 + m * (64 ±0)`
+		// Minimum execution time: 26_055_000 picoseconds.
+		Weight::from_parts(27_251_907, 4405)
+			// Standard Error: 1_008
+			.saturating_add(Weight::from_parts(65_947, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:0 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `530 + m * (64 ±0) + p * (36 ±0)`
+		//  Estimated: `3975 + m * (65 ±0) + p * (36 ±0)`
+		// Minimum execution time: 28_363_000 picoseconds.
+		Weight::from_parts(28_733_464, 3975)
+			// Standard Error: 1_275
+			.saturating_add(Weight::from_parts(43_236, 0).saturating_mul(m.into()))
+			// Standard Error: 1_244
+			.saturating_add(Weight::from_parts(180_187, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `832 + b * (1 ±0) + m * (64 ±0) + p * (40 ±0)`
+		//  Estimated: `4149 + b * (1 ±0) + m * (66 ±0) + p * (40 ±0)`
+		// Minimum execution time: 40_391_000 picoseconds.
+		Weight::from_parts(42_695_215, 4149)
+			// Standard Error: 167
+			.saturating_add(Weight::from_parts(3_622, 0).saturating_mul(b.into()))
+			// Standard Error: 1_772
+			.saturating_add(Weight::from_parts(33_830, 0).saturating_mul(m.into()))
+			// Standard Error: 1_727
+			.saturating_add(Weight::from_parts(205_374, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into()))
+			.saturating_add(Weight::from_parts(0, 66).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:0)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:0 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_disapproved(m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `550 + m * (64 ±0) + p * (36 ±0)`
+		//  Estimated: `3995 + m * (65 ±0) + p * (36 ±0)`
+		// Minimum execution time: 31_368_000 picoseconds.
+		Weight::from_parts(32_141_835, 3995)
+			// Standard Error: 1_451
+			.saturating_add(Weight::from_parts(36_372, 0).saturating_mul(m.into()))
+			// Standard Error: 1_415
+			.saturating_add(Weight::from_parts(210_635, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into()))
+	}
+	/// Storage: Council Voting (r:1 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Members (r:1 w:0)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:0)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:1 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `b` is `[2, 1024]`.
+	/// The range of component `m` is `[4, 100]`.
+	/// The range of component `p` is `[1, 100]`.
+	fn close_approved(b: u32, m: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `852 + b * (1 ±0) + m * (64 ±0) + p * (40 ±0)`
+		//  Estimated: `4169 + b * (1 ±0) + m * (66 ±0) + p * (40 ±0)`
+		// Minimum execution time: 43_271_000 picoseconds.
+		Weight::from_parts(45_495_648, 4169)
+			// Standard Error: 174
+			.saturating_add(Weight::from_parts(3_034, 0).saturating_mul(b.into()))
+			// Standard Error: 1_840
+			.saturating_add(Weight::from_parts(42_209, 0).saturating_mul(m.into()))
+			// Standard Error: 1_793
+			.saturating_add(Weight::from_parts(207_525, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into()))
+			.saturating_add(Weight::from_parts(0, 66).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into()))
+	}
+	/// Storage: Council Proposals (r:1 w:1)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Voting (r:0 w:1)
+	/// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council ProposalOf (r:0 w:1)
+	/// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `p` is `[1, 100]`.
+	fn disapprove_proposal(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `359 + p * (32 ±0)`
+		//  Estimated: `1844 + p * (32 ±0)`
+		// Minimum execution time: 15_170_000 picoseconds.
+		Weight::from_parts(17_567_243, 1844)
+			// Standard Error: 1_430
+			.saturating_add(Weight::from_parts(169_040, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(p.into()))
+	}
+}
diff --git a/substrate/frame/contracts/CHANGELOG.md b/substrate/frame/contracts/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..dcb9d6d4d2b206b97cd271195f6e6a8cb86c56a0
--- /dev/null
+++ b/substrate/frame/contracts/CHANGELOG.md
@@ -0,0 +1,116 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+The semantic versioning guarantees cover the interface to the substrate runtime which
+includes this pallet as a dependency. This module will also add storage migrations whenever
+changes require it. Stability with regard to offchain tooling is explicitly excluded from
+this guarantee: For example adding a new field to an in-storage data structure will require
+changes to frontends to properly display it. However, those changes will still be regarded
+as a minor version bump.
+
+The interface provided to smart contracts will adhere to semver with one exception: Even
+major version bumps will be backwards compatible with regard to already deployed contracts.
+In other words: Upgrading this pallet will not break pre-existing contracts.
+
+## [Unreleased]
+
+### Added
+
+- Forbid calling back to contracts after switching to runtime
+[#13443](https://github.com/paritytech/substrate/pull/13443)
+
+- Allow contracts to dispatch calls into the runtime (**unstable**)
+[#9276](https://github.com/paritytech/substrate/pull/9276)
+
+- New version of `seal_call` that offers more features.
+[#8909](https://github.com/paritytech/substrate/pull/8909)
+
+- New `instantiate` RPC that allows clients to dry-run contract instantiation.
+[#8451](https://github.com/paritytech/substrate/pull/8451)
+
+- New version of `seal_random` which exposes additional information.
+[#8329](https://github.com/paritytech/substrate/pull/8329)
+
+### Changed
+
+- Replaced storage rent with automatic storage deposits
+[#9669](https://github.com/paritytech/substrate/pull/9669)
+[#10082](https://github.com/paritytech/substrate/pull/10082)
+
+- Replaced `seal_println` with the `seal_debug_message` API which allows outputting debug
+messages to the console and RPC clients.
+[#8773](https://github.com/paritytech/substrate/pull/8773)
+[#9550](https://github.com/paritytech/substrate/pull/9550)
+
+- Make storage and fields of `Schedule` private to the crate.
+[#8359](https://github.com/paritytech/substrate/pull/8359)
+
+### Fixed
+
+- Remove pre-charging which caused wrongly estimated weights
+[#8976](https://github.com/paritytech/substrate/pull/8976)
+
+## [v3.0.0] 2021-02-25
+
+This version constitutes the first release that brings any stability guarantees (see above).
+
+### Added
+
+- Emit an event when a contract terminates (self-destructs).
+[#8014](https://github.com/paritytech/substrate/pull/8014)
+
+- Charge rent for code stored on the chain in addition to the already existing
+rent that is paid for data storage.
+[#7935](https://github.com/paritytech/substrate/pull/7935)
+
+- Allow the runtime to configure per storage item costs in addition
+to the already existing per byte costs.
+[#7819](https://github.com/paritytech/substrate/pull/7819)
+
+- Contracts are now deleted lazily so that the user who removes a contract
+does not need to pay for the deletion of the contract storage.
+[#7740](https://github.com/paritytech/substrate/pull/7740)
+
+- Allow runtime authors to define chain extensions in order to provide custom
+functionality to contracts.
+[#7548](https://github.com/paritytech/substrate/pull/7548)
+[#8003](https://github.com/paritytech/substrate/pull/8003)
+
+- Proper weights which are fully automated by benchmarking.
+[#6715](https://github.com/paritytech/substrate/pull/6715)
+[#7017](https://github.com/paritytech/substrate/pull/7017)
+[#7361](https://github.com/paritytech/substrate/pull/7361)
+
+### Changed
+
+- Collect the rent for one block during instantiation.
+[#7847](https://github.com/paritytech/substrate/pull/7847)
+
+- Instantiation takes a `salt` argument to allow for easier instantion of the
+same code by the same sender.
+[#7482](https://github.com/paritytech/substrate/pull/7482)
+
+- Improve the information returned by the `contracts_call` RPC.
+[#7468](https://github.com/paritytech/substrate/pull/7468)
+
+- Simplify the node configuration necessary to add this module.
+[#7409](https://github.com/paritytech/substrate/pull/7409)
+
+### Fixed
+
+- Consider the code size of a contract in the weight that is charged for
+loading a contract from storage.
+[#8086](https://github.com/paritytech/substrate/pull/8086)
+
+- Fix possible overflow in storage size calculation
+[#7885](https://github.com/paritytech/substrate/pull/7885)
+
+- Cap the surcharge reward that can be claimed.
+[#7870](https://github.com/paritytech/substrate/pull/7870)
+
+- Fix a possible DoS vector where contracts could allocate too large buffers.
+[#7818](https://github.com/paritytech/substrate/pull/7818)
diff --git a/substrate/frame/contracts/Cargo.toml b/substrate/frame/contracts/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..75a6093dffac8054635202b99b6e14b40efeac77
--- /dev/null
+++ b/substrate/frame/contracts/Cargo.toml
@@ -0,0 +1,116 @@
+[package]
+name = "pallet-contracts"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+build = "build.rs"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for WASM contracts"
+readme = "README.md"
+include = ["src/**/*", "README.md", "CHANGELOG.md"]
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+bitflags = "1.3"
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+	"max-encoded-len",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+log = { version = "0.4", default-features = false }
+serde = { version = "1", optional = true, features = ["derive"] }
+smallvec = { version = "1", default-features = false, features = [
+	"const_generics",
+] }
+wasmi = { version = "0.30", default-features = false }
+impl-trait-for-tuples = "0.2"
+
+# Only used in benchmarking to generate contract code
+wasm-instrument = { version = "0.4", optional = true, default-features = false }
+rand = { version = "0.8", optional = true, default-features = false }
+rand_pcg = { version = "0.3", optional = true }
+
+# Substrate Dependencies
+environmental = { version = "1.1.4", default-features = false }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances", optional = true, default-features = false }
+pallet-contracts-primitives = { version = "24.0.0", default-features = false, path = "primitives" }
+pallet-contracts-proc-macro = { version = "4.0.0-dev", path = "proc-macro" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+array-bytes = "6.1"
+assert_matches = "1"
+env_logger = "0.9"
+pretty_assertions = "1"
+wat = "1"
+
+# Substrate Dependencies
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../timestamp" }
+pallet-insecure-randomness-collective-flip = { version = "4.0.0-dev", path = "../insecure-randomness-collective-flip" }
+pallet-utility = { version = "4.0.0-dev", path = "../utility" }
+pallet-proxy = { version = "4.0.0-dev", path = "../proxy" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"environmental/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances?/std",
+	"pallet-contracts-primitives/std",
+	"pallet-contracts-proc-macro/full",
+	"pallet-insecure-randomness-collective-flip/std",
+	"pallet-proxy/std",
+	"pallet-timestamp/std",
+	"pallet-utility/std",
+	"rand/std",
+	"scale-info/std",
+	"serde",
+	"sp-api/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-keystore/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"wasm-instrument/std",
+	"wasmi/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-proxy/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"pallet-utility/runtime-benchmarks",
+	"rand",
+	"rand_pcg",
+	"sp-runtime/runtime-benchmarks",
+	"wasm-instrument",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-insecure-randomness-collective-flip/try-runtime",
+	"pallet-proxy/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"pallet-utility/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/contracts/README.md b/substrate/frame/contracts/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..aeb30cef32fc8cd9cdd3d65f24fcd98be151b7dd
--- /dev/null
+++ b/substrate/frame/contracts/README.md
@@ -0,0 +1,160 @@
+# Contracts Module
+
+The Contracts module provides functionality for the runtime to deploy and execute WebAssembly smart-contracts.
+
+- [`Call`](https://paritytech.github.io/substrate/master/pallet_contracts/pallet/enum.Call.html)
+- [`Config`](https://paritytech.github.io/substrate/master/pallet_contracts/pallet/trait.Config.html)
+- [`Error`](https://paritytech.github.io/substrate/master/pallet_contracts/pallet/enum.Error.html)
+- [`Event`](https://paritytech.github.io/substrate/master/pallet_contracts/pallet/enum.Event.html)
+
+## Overview
+
+This module extends accounts based on the [`frame_support::traits::fungible`] traits to have smart-contract functionality. It can
+be used with other modules that implement accounts based on [`frame_support::traits::fungible`]. These "smart-contract accounts"
+have the ability to instantiate smart-contracts and make calls to other contract and non-contract accounts.
+
+The smart-contract code is stored once, and later retrievable via its `code_hash`.
+This means that multiple smart-contracts can be instantiated from the same `code`, without replicating
+the code each time.
+
+When a smart-contract is called, its associated code is retrieved via the code hash and gets executed.
+This call can alter the storage entries of the smart-contract account, instantiate new smart-contracts,
+or call other smart-contracts.
+
+Finally, when an account is reaped, its associated code and storage of the smart-contract account
+will also be deleted.
+
+### Weight
+
+Senders must specify a [`Weight`](https://paritytech.github.io/substrate/master/sp_weights/struct.Weight.html) limit with every call, as all instructions invoked by the smart-contract require weight.
+Unused weight is refunded after the call, regardless of the execution outcome.
+
+If the weight limit is reached, then all calls and state changes (including balance transfers) are only
+reverted at the current call's contract level. For example, if contract A calls B and B runs out of weight mid-call,
+then all of B's calls are reverted. Assuming correct error handling by contract A, A's other calls and state
+changes still persist.
+
+One `ref_time` `Weight` is defined as one picosecond of execution time on the runtime's reference machine.
+
+### Revert Behaviour
+
+Contract call failures are not cascading. When failures occur in a sub-call, they do not "bubble up",
+and the call will only revert at the specific contract level. For example, if contract A calls contract B, and B
+fails, A can decide how to handle that failure, either proceeding or reverting A's changes.
+
+### Off-chain Execution
+
+In general, a contract execution needs to be deterministic so that all nodes come to the same
+conclusion when executing it. To that end we disallow any instructions that could cause
+indeterminism. Most notable are any floating point arithmetic. That said, sometimes contracts
+are executed off-chain and hence are not subject to consensus. If code is only executed by a
+single node and implicitly trusted by other actors is such a case. Trusted execution environments
+come to mind. To that end we allow the execution of indeterminstic code for off-chain usages
+with the following constraints:
+
+1. No contract can ever be instantiated from an indeterministic code. The only way to execute
+the code is to use a delegate call from a deterministic contract.
+2. The code that wants to use this feature needs to depend on `pallet-contracts` and use [`bare_call()`](https://paritytech.github.io/substrate/master/pallet_contracts/pallet/struct.Pallet.html#method.bare_call)
+directly. This makes sure that by default `pallet-contracts` does not expose any indeterminism.
+
+#### How to use
+
+An indeterministic code can be deployed on-chain by passing `Determinism::Relaxed`
+to [`upload_code()`](https://paritytech.github.io/substrate/master/pallet_contracts/pallet/struct.Pallet.html#method.upload_code). A deterministic contract can then delegate call into it if and only if it
+is ran by using [`bare_call()`](https://paritytech.github.io/substrate/master/pallet_contracts/pallet/struct.Pallet.html#method.bare_call) and passing [`Determinism::Relaxed`](https://paritytech.github.io/substrate/master/pallet_contracts/enum.Determinism.html#variant.Relaxed) to it. **Never use
+this argument when the contract is called from an on-chain transaction.**
+
+## Interface
+
+### Dispatchable functions
+
+Those are documented in the [reference documentation](https://paritytech.github.io/substrate/master/pallet_contracts/index.html#dispatchable-functions).
+
+### Interface exposed to contracts
+
+Each contract is one WebAssembly module that looks like this:
+
+```wat
+(module
+    ;; Invoked by pallet-contracts when a contract is instantiated.
+    ;; No arguments and empty return type.
+    (func (export "deploy"))
+
+    ;; Invoked by pallet-contracts when a contract is called.
+    ;; No arguments and empty return type.
+    (func (export "call"))
+
+    ;; If a contract uses memory it must be imported. Memory is optional.
+    ;; The maximum allowed memory size depends on the pallet-contracts configuration.
+    (import "env" "memory" (memory 1 1))
+
+    ;; This is one of many functions that can be imported and is implemented by pallet-contracts.
+    ;; This function is used to copy the result buffer and flags back to the caller.
+    (import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+)
+```
+
+The documentation of all importable functions can be found
+[here](https://paritytech.github.io/substrate/master/pallet_contracts/api_doc/trait.Current.html).
+
+## Usage
+
+This module executes WebAssembly smart contracts. These can potentially be written in any language
+that compiles to Wasm. However, using a language that specifically targets this module
+will make things a lot easier. One such language is [`ink!`](https://use.ink). It enables
+writing WebAssembly-based smart-contracts in the Rust programming language.
+
+## Debugging
+
+Contracts can emit messages to the client when called as RPC through the [`debug_message`](https://paritytech.github.io/substrate/master/pallet_contracts/api_doc/trait.Current.html#tymethod.debug_message)
+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 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 `runtime::contracts` target needs to be raised to at least
+the `debug` level. However, those messages are easy to overlook because of the noise generated
+by block production. A good starting point for observing them on the console is using this
+command line in the root directory of the substrate repository:
+
+```bash
+cargo run --release -- --dev -lerror,runtime::contracts=debug
+```
+
+This raises the log level of `runtime::contracts` to `debug` and all other targets
+to `error` in order to prevent them from spamming the console.
+
+`--dev`: Use a dev chain spec
+`--tmp`: Use temporary storage for chain data (the chain state is deleted on exit)
+
+## Host function tracing
+
+For contract authors, it can be a helpful debugging tool to see which host functions are called, with which arguments, and what the result was. 
+
+In order to see these messages on the node console, the log level for the `runtime::contracts::strace` target needs to be raised to the `trace` level. 
+
+Example: 
+
+```bash
+cargo run --release -- --dev -lerror,runtime::contracts::strace=trace,runtime::contracts=debug
+```
+
+## Unstable Interfaces
+
+Driven by the desire to have an iterative approach in developing new contract interfaces
+this pallet contains the concept of an unstable interface. Akin to the rust nightly compiler
+it allows us to add new interfaces but mark them as unstable so that contract languages can
+experiment with them and give feedback before we stabilize those.
+
+In order to access interfaces marked as `#[unstable]` in [`runtime.rs`](src/wasm/runtime.rs) one need to set
+`pallet_contracts::Config::UnsafeUnstableInterface` to `ConstU32<true>`. **It should be obvious
+that any production runtime should never be compiled with this feature: In addition to be
+subject to change or removal those interfaces might not have proper weights associated with
+them and are therefore considered unsafe**.
+
+New interfaces are generally added as unstable and might go through several iterations
+before they are promoted to a stable interface.
+
+License: Apache-2.0
diff --git a/substrate/frame/contracts/benchmarks/README.md b/substrate/frame/contracts/benchmarks/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a621dd65d593143d48b6ca16d5820ce09eb99e3d
--- /dev/null
+++ b/substrate/frame/contracts/benchmarks/README.md
@@ -0,0 +1,9 @@
+# Benchmarks
+
+This directory contains real world ([ink!](https://use.ink), [solang](https://github.com/hyperledger/solang)) contracts which are used in macro benchmarks.
+Those benchmarks are not used to determine weights but rather to compare different contract
+languages and execution engines with larger wasm modules.
+
+Files in this directory are used by `#[extra]` benchmarks in `src/benchmarking`. The json
+files are for informational purposes only and are not consumed by the benchmarks.
+
diff --git a/substrate/frame/contracts/benchmarks/ink_erc20.json b/substrate/frame/contracts/benchmarks/ink_erc20.json
new file mode 100644
index 0000000000000000000000000000000000000000..390dd9b06cd4cd3ee57f83f64c9089508c68464d
--- /dev/null
+++ b/substrate/frame/contracts/benchmarks/ink_erc20.json
@@ -0,0 +1,819 @@
+{
+  "metadataVersion": "0.1.0",
+  "source": {
+    "hash": "0x6be8492017fe96b7a92bb39b4ede04b96effb8fcaf9237bfdccef7d9e732c760",
+    "language": "ink! 3.0.0-rc4",
+    "compiler": "rustc 1.56.0-nightly"
+  },
+  "contract": {
+    "name": "erc20",
+    "version": "3.0.0-rc4",
+    "authors": [
+      "Parity Technologies <admin@parity.io>"
+    ]
+  },
+  "spec": {
+    "constructors": [
+      {
+        "args": [
+          {
+            "name": "initial_supply",
+            "type": {
+              "displayName": [
+                "Balance"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          "Creates a new ERC-20 contract with the specified initial supply."
+        ],
+        "name": [
+          "new"
+        ],
+        "selector": "0x9bae9d5e"
+      }
+    ],
+    "docs": [],
+    "events": [
+      {
+        "args": [
+          {
+            "docs": [],
+            "indexed": true,
+            "name": "from",
+            "type": {
+              "displayName": [
+                "Option"
+              ],
+              "type": 15
+            }
+          },
+          {
+            "docs": [],
+            "indexed": true,
+            "name": "to",
+            "type": {
+              "displayName": [
+                "Option"
+              ],
+              "type": 15
+            }
+          },
+          {
+            "docs": [],
+            "indexed": false,
+            "name": "value",
+            "type": {
+              "displayName": [
+                "Balance"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          " Event emitted when a token transfer occurs."
+        ],
+        "name": "Transfer"
+      },
+      {
+        "args": [
+          {
+            "docs": [],
+            "indexed": true,
+            "name": "owner",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "docs": [],
+            "indexed": true,
+            "name": "spender",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "docs": [],
+            "indexed": false,
+            "name": "value",
+            "type": {
+              "displayName": [
+                "Balance"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          " Event emitted when an approval occurs that `spender` is allowed to withdraw",
+          " up to the amount of `value` tokens from `owner`."
+        ],
+        "name": "Approval"
+      }
+    ],
+    "messages": [
+      {
+        "args": [],
+        "docs": [
+          " Returns the total token supply."
+        ],
+        "mutates": false,
+        "name": [
+          "total_supply"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "Balance"
+          ],
+          "type": 1
+        },
+        "selector": "0xdb6375a8"
+      },
+      {
+        "args": [
+          {
+            "name": "owner",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          " Returns the account balance for the specified `owner`.",
+          "",
+          " Returns `0` if the account is non-existent."
+        ],
+        "mutates": false,
+        "name": [
+          "balance_of"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "Balance"
+          ],
+          "type": 1
+        },
+        "selector": "0x0f755a56"
+      },
+      {
+        "args": [
+          {
+            "name": "owner",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "spender",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          " Returns the amount which `spender` is still allowed to withdraw from `owner`.",
+          "",
+          " Returns `0` if no allowance has been set `0`."
+        ],
+        "mutates": false,
+        "name": [
+          "allowance"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "Balance"
+          ],
+          "type": 1
+        },
+        "selector": "0x6a00165e"
+      },
+      {
+        "args": [
+          {
+            "name": "to",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "value",
+            "type": {
+              "displayName": [
+                "Balance"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          " Transfers `value` amount of tokens from the caller's account to account `to`.",
+          "",
+          " On success a `Transfer` event is emitted.",
+          "",
+          " # Errors",
+          "",
+          " Returns `InsufficientBalance` error if there are not enough tokens on",
+          " the caller's account balance."
+        ],
+        "mutates": true,
+        "name": [
+          "transfer"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "Result"
+          ],
+          "type": 12
+        },
+        "selector": "0x84a15da1"
+      },
+      {
+        "args": [
+          {
+            "name": "spender",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "value",
+            "type": {
+              "displayName": [
+                "Balance"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          " Allows `spender` to withdraw from the caller's account multiple times, up to",
+          " the `value` amount.",
+          "",
+          " If this function is called again it overwrites the current allowance with `value`.",
+          "",
+          " An `Approval` event is emitted."
+        ],
+        "mutates": true,
+        "name": [
+          "approve"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "Result"
+          ],
+          "type": 12
+        },
+        "selector": "0x681266a0"
+      },
+      {
+        "args": [
+          {
+            "name": "from",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "to",
+            "type": {
+              "displayName": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "value",
+            "type": {
+              "displayName": [
+                "Balance"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          " Transfers `value` tokens on the behalf of `from` to the account `to`.",
+          "",
+          " This can be used to allow a contract to transfer tokens on ones behalf and/or",
+          " to charge fees in sub-currencies, for example.",
+          "",
+          " On success a `Transfer` event is emitted.",
+          "",
+          " # Errors",
+          "",
+          " Returns `InsufficientAllowance` error if there are not enough tokens allowed",
+          " for the caller to withdraw from `from`.",
+          "",
+          " Returns `InsufficientBalance` error if there are not enough tokens on",
+          " the account balance of `from`."
+        ],
+        "mutates": true,
+        "name": [
+          "transfer_from"
+        ],
+        "payable": false,
+        "returnType": {
+          "displayName": [
+            "Result"
+          ],
+          "type": 12
+        },
+        "selector": "0x0b396f18"
+      }
+    ]
+  },
+  "storage": {
+    "struct": {
+      "fields": [
+        {
+          "layout": {
+            "cell": {
+              "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+              "ty": 1
+            }
+          },
+          "name": "total_supply"
+        },
+        {
+          "layout": {
+            "struct": {
+              "fields": [
+                {
+                  "layout": {
+                    "struct": {
+                      "fields": [
+                        {
+                          "layout": {
+                            "cell": {
+                              "key": "0x0100000000000000000000000000000000000000000000000000000000000000",
+                              "ty": 2
+                            }
+                          },
+                          "name": "header"
+                        },
+                        {
+                          "layout": {
+                            "struct": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0200000000000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "len"
+                                },
+                                {
+                                  "layout": {
+                                    "array": {
+                                      "cellsPerElem": 1,
+                                      "layout": {
+                                        "cell": {
+                                          "key": "0x0200000001000000000000000000000000000000000000000000000000000000",
+                                          "ty": 4
+                                        }
+                                      },
+                                      "len": 4294967295,
+                                      "offset": "0x0300000000000000000000000000000000000000000000000000000000000000"
+                                    }
+                                  },
+                                  "name": "elems"
+                                }
+                              ]
+                            }
+                          },
+                          "name": "entries"
+                        }
+                      ]
+                    }
+                  },
+                  "name": "keys"
+                },
+                {
+                  "layout": {
+                    "hash": {
+                      "layout": {
+                        "cell": {
+                          "key": "0x0300000001000000000000000000000000000000000000000000000000000000",
+                          "ty": 9
+                        }
+                      },
+                      "offset": "0x0200000001000000000000000000000000000000000000000000000000000000",
+                      "strategy": {
+                        "hasher": "Blake2x256",
+                        "postfix": "",
+                        "prefix": "0x696e6b20686173686d6170"
+                      }
+                    }
+                  },
+                  "name": "values"
+                }
+              ]
+            }
+          },
+          "name": "balances"
+        },
+        {
+          "layout": {
+            "struct": {
+              "fields": [
+                {
+                  "layout": {
+                    "struct": {
+                      "fields": [
+                        {
+                          "layout": {
+                            "cell": {
+                              "key": "0x0300000001000000000000000000000000000000000000000000000000000000",
+                              "ty": 2
+                            }
+                          },
+                          "name": "header"
+                        },
+                        {
+                          "layout": {
+                            "struct": {
+                              "fields": [
+                                {
+                                  "layout": {
+                                    "cell": {
+                                      "key": "0x0400000001000000000000000000000000000000000000000000000000000000",
+                                      "ty": 3
+                                    }
+                                  },
+                                  "name": "len"
+                                },
+                                {
+                                  "layout": {
+                                    "array": {
+                                      "cellsPerElem": 1,
+                                      "layout": {
+                                        "cell": {
+                                          "key": "0x0400000002000000000000000000000000000000000000000000000000000000",
+                                          "ty": 10
+                                        }
+                                      },
+                                      "len": 4294967295,
+                                      "offset": "0x0500000001000000000000000000000000000000000000000000000000000000"
+                                    }
+                                  },
+                                  "name": "elems"
+                                }
+                              ]
+                            }
+                          },
+                          "name": "entries"
+                        }
+                      ]
+                    }
+                  },
+                  "name": "keys"
+                },
+                {
+                  "layout": {
+                    "hash": {
+                      "layout": {
+                        "cell": {
+                          "key": "0x0500000002000000000000000000000000000000000000000000000000000000",
+                          "ty": 9
+                        }
+                      },
+                      "offset": "0x0400000002000000000000000000000000000000000000000000000000000000",
+                      "strategy": {
+                        "hasher": "Blake2x256",
+                        "postfix": "",
+                        "prefix": "0x696e6b20686173686d6170"
+                      }
+                    }
+                  },
+                  "name": "values"
+                }
+              ]
+            }
+          },
+          "name": "allowances"
+        }
+      ]
+    }
+  },
+  "types": [
+    {
+      "def": {
+        "primitive": "u128"
+      }
+    },
+    {
+      "def": {
+        "composite": {
+          "fields": [
+            {
+              "name": "last_vacant",
+              "type": 3,
+              "typeName": "Index"
+            },
+            {
+              "name": "len",
+              "type": 3,
+              "typeName": "u32"
+            },
+            {
+              "name": "len_entries",
+              "type": 3,
+              "typeName": "u32"
+            }
+          ]
+        }
+      },
+      "path": [
+        "ink_storage",
+        "collections",
+        "stash",
+        "Header"
+      ]
+    },
+    {
+      "def": {
+        "primitive": "u32"
+      }
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "fields": [
+                {
+                  "type": 8,
+                  "typeName": "VacantEntry"
+                }
+              ],
+              "name": "Vacant"
+            },
+            {
+              "fields": [
+                {
+                  "type": 5,
+                  "typeName": "T"
+                }
+              ],
+              "name": "Occupied"
+            }
+          ]
+        }
+      },
+      "params": [
+        5
+      ],
+      "path": [
+        "ink_storage",
+        "collections",
+        "stash",
+        "Entry"
+      ]
+    },
+    {
+      "def": {
+        "composite": {
+          "fields": [
+            {
+              "type": 6,
+              "typeName": "[u8; 32]"
+            }
+          ]
+        }
+      },
+      "path": [
+        "ink_env",
+        "types",
+        "AccountId"
+      ]
+    },
+    {
+      "def": {
+        "array": {
+          "len": 32,
+          "type": 7
+        }
+      }
+    },
+    {
+      "def": {
+        "primitive": "u8"
+      }
+    },
+    {
+      "def": {
+        "composite": {
+          "fields": [
+            {
+              "name": "next",
+              "type": 3,
+              "typeName": "Index"
+            },
+            {
+              "name": "prev",
+              "type": 3,
+              "typeName": "Index"
+            }
+          ]
+        }
+      },
+      "path": [
+        "ink_storage",
+        "collections",
+        "stash",
+        "VacantEntry"
+      ]
+    },
+    {
+      "def": {
+        "composite": {
+          "fields": [
+            {
+              "name": "value",
+              "type": 1,
+              "typeName": "V"
+            },
+            {
+              "name": "key_index",
+              "type": 3,
+              "typeName": "KeyIndex"
+            }
+          ]
+        }
+      },
+      "params": [
+        1
+      ],
+      "path": [
+        "ink_storage",
+        "collections",
+        "hashmap",
+        "ValueEntry"
+      ]
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "fields": [
+                {
+                  "type": 8,
+                  "typeName": "VacantEntry"
+                }
+              ],
+              "name": "Vacant"
+            },
+            {
+              "fields": [
+                {
+                  "type": 11,
+                  "typeName": "T"
+                }
+              ],
+              "name": "Occupied"
+            }
+          ]
+        }
+      },
+      "params": [
+        11
+      ],
+      "path": [
+        "ink_storage",
+        "collections",
+        "stash",
+        "Entry"
+      ]
+    },
+    {
+      "def": {
+        "tuple": [
+          5,
+          5
+        ]
+      }
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "fields": [
+                {
+                  "type": 13,
+                  "typeName": "T"
+                }
+              ],
+              "name": "Ok"
+            },
+            {
+              "fields": [
+                {
+                  "type": 14,
+                  "typeName": "E"
+                }
+              ],
+              "name": "Err"
+            }
+          ]
+        }
+      },
+      "params": [
+        13,
+        14
+      ],
+      "path": [
+        "Result"
+      ]
+    },
+    {
+      "def": {
+        "tuple": []
+      }
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "discriminant": 0,
+              "name": "InsufficientBalance"
+            },
+            {
+              "discriminant": 1,
+              "name": "InsufficientAllowance"
+            }
+          ]
+        }
+      },
+      "path": [
+        "erc20",
+        "erc20",
+        "Error"
+      ]
+    },
+    {
+      "def": {
+        "variant": {
+          "variants": [
+            {
+              "name": "None"
+            },
+            {
+              "fields": [
+                {
+                  "type": 5,
+                  "typeName": "T"
+                }
+              ],
+              "name": "Some"
+            }
+          ]
+        }
+      },
+      "params": [
+        5
+      ],
+      "path": [
+        "Option"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/substrate/frame/contracts/benchmarks/ink_erc20.wasm b/substrate/frame/contracts/benchmarks/ink_erc20.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..ffd522760a02dd8416f8ee04db02c32e2172b8ff
Binary files /dev/null and b/substrate/frame/contracts/benchmarks/ink_erc20.wasm differ
diff --git a/substrate/frame/contracts/benchmarks/ink_erc20_test.wasm b/substrate/frame/contracts/benchmarks/ink_erc20_test.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..f5d84552960a348db3935e457adc4b6fba249d17
Binary files /dev/null and b/substrate/frame/contracts/benchmarks/ink_erc20_test.wasm differ
diff --git a/substrate/frame/contracts/benchmarks/solang_erc20.json b/substrate/frame/contracts/benchmarks/solang_erc20.json
new file mode 100644
index 0000000000000000000000000000000000000000..9d8fd5ce70e70edb0fdb96439be847369e6ae7e0
--- /dev/null
+++ b/substrate/frame/contracts/benchmarks/solang_erc20.json
@@ -0,0 +1,581 @@
+{
+  "contract": {
+    "authors": [
+      "unknown"
+    ],
+    "name": "ERC20PresetFixedSupply",
+    "version": "0.0.1"
+  },
+  "metadataVersion": "0.1.0",
+  "source": {
+    "compiler": "solang 0.1.7",
+    "hash": "0x9c55e342566e89c741eb641eec3af796836da750fc930c55bccc0604a47ef700",
+    "language": "Solidity 0.1.7"
+  },
+  "spec": {
+    "constructors": [
+      {
+        "args": [
+          {
+            "name": "name",
+            "type": {
+              "display_name": [
+                "String"
+              ],
+              "type": 2
+            }
+          },
+          {
+            "name": "symbol",
+            "type": {
+              "display_name": [
+                "String"
+              ],
+              "type": 2
+            }
+          },
+          {
+            "name": "initialSupply",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          },
+          {
+            "name": "owner",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "name": "new",
+        "selector": "0xa6f1f5e1"
+      }
+    ],
+    "events": [
+      {
+        "args": [
+          {
+            "indexed": true,
+            "name": "owner",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "indexed": true,
+            "name": "spender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "indexed": false,
+            "name": "value",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "name": "Approval"
+      },
+      {
+        "args": [
+          {
+            "indexed": true,
+            "name": "from",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "indexed": true,
+            "name": "to",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "indexed": false,
+            "name": "value",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "name": "Transfer"
+      }
+    ],
+    "messages": [
+      {
+        "args": [
+          {
+            "name": "account",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "amount",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "burnFrom",
+        "payable": false,
+        "return_type": null,
+        "selector": "0x0f1354f3"
+      },
+      {
+        "args": [
+          {
+            "name": "account",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "balanceOf",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "u256"
+          ],
+          "type": 1
+        },
+        "selector": "0x6c7f1542"
+      },
+      {
+        "args": [],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "totalSupply",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "u256"
+          ],
+          "type": 1
+        },
+        "selector": "0x18160ddd"
+      },
+      {
+        "args": [],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "decimals",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "u8"
+          ],
+          "type": 3
+        },
+        "selector": "0x313ce567"
+      },
+      {
+        "args": [
+          {
+            "name": "owner",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "spender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "allowance",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "u256"
+          ],
+          "type": 1
+        },
+        "selector": "0xf2a9a8c7"
+      },
+      {
+        "args": [],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "name",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "String"
+          ],
+          "type": 2
+        },
+        "selector": "0x06fdde03"
+      },
+      {
+        "args": [
+          {
+            "name": "spender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "subtractedValue",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "decreaseAllowance",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "bool"
+          ],
+          "type": 6
+        },
+        "selector": "0x4b76697b"
+      },
+      {
+        "args": [
+          {
+            "name": "sender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "recipient",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "amount",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "transferFrom",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "bool"
+          ],
+          "type": 6
+        },
+        "selector": "0x2fb840f5"
+      },
+      {
+        "args": [],
+        "docs": [
+          ""
+        ],
+        "mutates": false,
+        "name": "symbol",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "String"
+          ],
+          "type": 2
+        },
+        "selector": "0x95d89b41"
+      },
+      {
+        "args": [
+          {
+            "name": "spender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "addedValue",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "increaseAllowance",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "bool"
+          ],
+          "type": 6
+        },
+        "selector": "0xb936c899"
+      },
+      {
+        "args": [
+          {
+            "name": "recipient",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "amount",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "transfer",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "bool"
+          ],
+          "type": 6
+        },
+        "selector": "0x6a467394"
+      },
+      {
+        "args": [
+          {
+            "name": "spender",
+            "type": {
+              "display_name": [
+                "AccountId"
+              ],
+              "type": 5
+            }
+          },
+          {
+            "name": "amount",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "approve",
+        "payable": false,
+        "return_type": {
+          "display_name": [
+            "bool"
+          ],
+          "type": 6
+        },
+        "selector": "0x47144421"
+      },
+      {
+        "args": [
+          {
+            "name": "amount",
+            "type": {
+              "display_name": [
+                "u256"
+              ],
+              "type": 1
+            }
+          }
+        ],
+        "docs": [
+          ""
+        ],
+        "mutates": true,
+        "name": "burn",
+        "payable": false,
+        "return_type": null,
+        "selector": "0x42966c68"
+      }
+    ]
+  },
+  "storage": {
+    "struct": {
+      "fields": [
+        {
+          "layout": {
+            "cell": {
+              "key": "0x0000000000000000000000000000000000000000000000000000000000000002",
+              "ty": 1
+            }
+          },
+          "name": "_totalSupply"
+        },
+        {
+          "layout": {
+            "cell": {
+              "key": "0x0000000000000000000000000000000000000000000000000000000000000003",
+              "ty": 2
+            }
+          },
+          "name": "_name"
+        },
+        {
+          "layout": {
+            "cell": {
+              "key": "0x0000000000000000000000000000000000000000000000000000000000000004",
+              "ty": 2
+            }
+          },
+          "name": "_symbol"
+        }
+      ]
+    }
+  },
+  "types": [
+    {
+      "def": {
+        "primitive": "u256"
+      }
+    },
+    {
+      "def": {
+        "primitive": "str"
+      }
+    },
+    {
+      "def": {
+        "primitive": "u8"
+      }
+    },
+    {
+      "def": {
+        "array": {
+          "len": 32,
+          "type": 3
+        }
+      }
+    },
+    {
+      "def": {
+        "composite": {
+          "fields": [
+            {
+              "type": 4
+            }
+          ]
+        }
+      },
+      "path": [
+        "AccountId"
+      ]
+    },
+    {
+      "def": {
+        "primitive": "bool"
+      }
+    }
+  ]
+}
diff --git a/substrate/frame/contracts/benchmarks/solang_erc20.wasm b/substrate/frame/contracts/benchmarks/solang_erc20.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..0796085d33249b78871f4a336623444a0ef94e85
Binary files /dev/null and b/substrate/frame/contracts/benchmarks/solang_erc20.wasm differ
diff --git a/substrate/frame/contracts/build.rs b/substrate/frame/contracts/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7817ace9c98e2e877080d05552914f39d89eec85
--- /dev/null
+++ b/substrate/frame/contracts/build.rs
@@ -0,0 +1,73 @@
+// 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 std::io::Write;
+
+/// Get the latest migration version.
+///
+/// Find the highest version number from the available migration files.
+/// Each migration file should follow the naming convention `vXX.rs`, where `XX` is the version
+/// number.
+fn get_latest_version() -> u16 {
+	std::fs::read_dir("src/migration")
+		.expect("Folder `src/migration` not found.")
+		.filter_map(|entry| {
+			let file_name = entry.as_ref().ok()?.file_name();
+			let file_name = file_name.to_str()?;
+			if file_name.starts_with('v') && file_name.ends_with(".rs") {
+				let version = &file_name[1..&file_name.len() - 3];
+				let version = version.parse::<u16>().ok()?;
+
+				// Ensure that the version matches the one defined in the file.
+				let path = entry.unwrap().path();
+				let file_content = std::fs::read_to_string(&path).ok()?;
+				assert!(
+					file_content.contains(&format!("const VERSION: u16 = {}", version)),
+					"Invalid MigrationStep::VERSION in {:?}",
+					path
+				);
+
+				return Some(version)
+			}
+			None
+		})
+		.max()
+		.expect("Failed to find any files matching the 'src/migration/vxx.rs' pattern.")
+}
+
+/// Generates a module that exposes the latest migration version, and the benchmark migrations type.
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+	let out_dir = std::env::var("OUT_DIR")?;
+	let path = std::path::Path::new(&out_dir).join("migration_codegen.rs");
+	let mut f = std::fs::File::create(&path)?;
+	let version = get_latest_version();
+	write!(
+		f,
+		"
+         pub mod codegen {{
+		  use crate::NoopMigration;
+		  /// The latest migration version, pulled from the latest migration file.
+		  pub const LATEST_MIGRATION_VERSION: u16 = {version};
+		  /// The Migration Steps used for benchmarking the migration framework.
+		  pub type BenchMigrations = (NoopMigration<{}>, NoopMigration<{version}>);
+		}}",
+		version - 1,
+	)?;
+
+	println!("cargo:rerun-if-changed=src/migration");
+	Ok(())
+}
diff --git a/substrate/frame/contracts/fixtures/account_reentrance_count_call.wat b/substrate/frame/contracts/fixtures/account_reentrance_count_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..ab6789066487084faca88cad8d6ca045cffe6750
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/account_reentrance_count_call.wat
@@ -0,0 +1,37 @@
+;; This fixture tests if account_reentrance_count works as expected
+;; testing it with 2 different addresses
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_caller" (func $seal_caller (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal0" "account_reentrance_count" (func $account_reentrance_count (param i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) buffer where input is copied
+	;; [32, 36) size of the input buffer
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; Reading "callee" input address
+		(call $seal_input (i32.const 0) (i32.const 32))
+
+		(i32.store
+		    (i32.const 36)
+            (call $account_reentrance_count (i32.const 0))
+		)
+
+		(call $seal_return (i32.const 0) (i32.const 36) (i32.const 4))
+	)
+
+	(func (export "deploy"))
+
+)
\ No newline at end of file
diff --git a/substrate/frame/contracts/fixtures/add_remove_delegate_dependency.wat b/substrate/frame/contracts/fixtures/add_remove_delegate_dependency.wat
new file mode 100644
index 0000000000000000000000000000000000000000..ef456b6d620a3a52110b73417977fe3139527a56
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/add_remove_delegate_dependency.wat
@@ -0,0 +1,111 @@
+;; This contract tests the behavior of adding / removing delegate_dependencies when delegate calling into a contract.
+(module
+	(import "seal0" "add_delegate_dependency" (func $add_delegate_dependency (param i32)))
+	(import "seal0" "remove_delegate_dependency" (func $remove_delegate_dependency (param i32)))
+	(import "seal0" "input" (func $input (param i32 i32)))
+	(import "seal1" "terminate" (func $terminate (param i32)))
+	(import "seal0" "delegate_call" (func $delegate_call (param i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [100, 132) Address of Alice
+	(data (i32.const 100)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	;; This function loads input data and performs the action specified.
+	;; The first 4 bytes of the input specify the action to perform.
+	;; The next 32 bytes specify the code hash to use when calling add_delegate_dependency or remove_delegate_dependency.
+	;; Actions are:
+	;; 1: call add_delegate_dependency
+	;; 2: call remove_delegate_dependency.
+	;; 3: call terminate.
+	;; Any other value is a no-op.
+	(func $load_input
+		(local $action i32)
+		(local $code_hash_ptr i32)
+
+	    ;; Store available input size at offset 0.
+        (i32.store (i32.const 0) (i32.const 512))
+
+		;; Read input data.
+		(call $input (i32.const 4) (i32.const 0))
+
+		;; Input data layout.
+		;; [0..4) - size of the call
+		;; [4..8) - action to perform
+		;; [8..42) - code hash of the callee
+		(set_local $action (i32.load (i32.const 4)))
+		(set_local $code_hash_ptr (i32.const 8))
+
+		;; Assert input size == 36 (4 for action + 32 for code_hash).
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 0))
+				(i32.const 36)
+			)
+		)
+
+		;; Call add_delegate_dependency when action == 1.
+		(if (i32.eq (get_local $action) (i32.const 1))
+		    (then
+				(call $add_delegate_dependency (get_local $code_hash_ptr))
+			)
+			(else)
+		)
+
+		;; Call remove_delegate_dependency when action == 2.
+		(if (i32.eq (get_local $action) (i32.const 2))
+		    (then
+				(call $remove_delegate_dependency
+					(get_local $code_hash_ptr)
+				)
+			)
+			(else)
+		)
+
+		;; Call terminate when action == 3.
+		(if (i32.eq (get_local $action) (i32.const 3))
+		    (then
+				(call $terminate
+					(i32.const 100)	;; Pointer to beneficiary address
+				)
+				(unreachable) ;; terminate never returns
+			)
+			(else)
+		)
+	)
+
+	(func (export "deploy")
+		(call $load_input)
+	)
+
+	(func (export "call")
+		(call $load_input)
+
+		;; Delegate call into passed code hash.
+		(call $assert
+			(i32.eq
+				(call $delegate_call
+					(i32.const 0)	;; Set no call flags.
+					(i32.const 8)	;; Pointer to "callee" code_hash.
+					(i32.const 0)	;; Input is ignored.
+					(i32.const 0)	;; Length of the input.
+					(i32.const 4294967295)	;; u32 max sentinel value: do not copy output.
+					(i32.const 0)	;; Length is ignored in this case.
+				)
+				(i32.const 0)
+			)
+		)
+	)
+
+)
diff --git a/substrate/frame/contracts/fixtures/call.wat b/substrate/frame/contracts/fixtures/call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..4558b2c6409b999801ce68a1afd68a60c91d53b8
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/call.wat
@@ -0,0 +1,39 @@
+;; This calls another contract as passed as its account id.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+    (func (export "deploy"))
+
+    (func (export "call")
+    	;; Store length of input buffer.
+        (i32.store (i32.const 0) (i32.const 512))
+
+        ;; Copy input at address 4.
+        (call $seal_input (i32.const 4) (i32.const 0))
+
+		;; Call passed contract.
+		(call $assert (i32.eqz
+			(call $seal_call
+				(i32.const 0) ;; No flags
+				(i32.const 8)  ;; Pointer to "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 512) ;; Pointer to the buffer with value to transfer
+				(i32.const 4) ;; Pointer to input data buffer address
+				(i32.const 4)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/call_return_code.wat b/substrate/frame/contracts/fixtures/call_return_code.wat
new file mode 100644
index 0000000000000000000000000000000000000000..4e9ab4dd77ce153704b60e40c065dfd1fe13a0b1
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/call_return_code.wat
@@ -0,0 +1,42 @@
+;; This calls the supplied dest and transfers 100 balance during this call and copies
+;; the return code of this call to the output buffer.
+;; It also forwards its input to the callee.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) 100 balance
+	(data (i32.const 0) "\64\00\00\00\00\00\00\00")
+
+	;; [8, 12) here we store the return code of the transfer
+
+	;; [12, 16) size of the input data
+	(data (i32.const 12) "\24")
+
+	;; [16, inf) here we store the input data
+	;; 32 byte dest + 4 byte forward
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(call $seal_input (i32.const 16) (i32.const 12))
+		(i32.store
+			(i32.const 8)
+			(call $seal_call
+				(i32.const 16) ;; Pointer to "callee" address.
+				(i32.const 32) ;; Length of "callee" address.
+				(i64.const 0) ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 0) ;; Pointer to the buffer with value to transfer
+				(i32.const 8) ;; Length of the buffer with value to transfer.
+				(i32.const 48) ;; Pointer to input data buffer address
+				(i32.const 4) ;; Length of input data buffer
+				(i32.const 0xffffffff) ;; u32 max sentinel value: do not copy output
+				(i32.const 0) ;; Ptr to output buffer len
+			)
+		)
+		;; exit with success and take transfer return code to the output buffer
+		(call $seal_return (i32.const 0) (i32.const 8) (i32.const 4))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/call_runtime.wat b/substrate/frame/contracts/fixtures/call_runtime.wat
new file mode 100644
index 0000000000000000000000000000000000000000..d3d08ee24541a29c462871232f7663764a752638
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/call_runtime.wat
@@ -0,0 +1,33 @@
+;; This passes its input to `seal_call_runtime` and returns the return value to its caller.
+(module
+	(import "seal0" "call_runtime" (func $call_runtime (param i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; 0x1000 = 4k in little endian
+	;; size of input buffer
+	(data (i32.const 0) "\00\10")
+
+	(func (export "call")
+		;; Receive the encoded call
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the length buffer
+		)
+		;; Just use the call passed as input and store result to memory
+		(i32.store (i32.const 0)
+			(call $call_runtime
+				(i32.const 4)				;; Pointer where the call is stored
+				(i32.load (i32.const 0))	;; Size of the call
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 0)	;; returned value
+			(i32.const 4)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/call_runtime_and_call.wat b/substrate/frame/contracts/fixtures/call_runtime_and_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..3320922d9e2cb558706cbed4363577d6a5b7e1d0
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/call_runtime_and_call.wat
@@ -0,0 +1,56 @@
+(module
+	(import "seal0" "call_runtime" (func $call_runtime (param i32 i32) (result i32)))
+	(import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok (get_local 0))
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+	    ;; Store available input size at offset 0.
+        (i32.store (i32.const 0) (i32.const 512))
+
+		;; read input data
+        (call $seal_input (i32.const 4) (i32.const 0))
+
+		;; Input data layout.
+		;; [0..4) - size of the call
+		;; [4..8) - how many bytes to add to storage
+		;; [8..40) - address of the callee
+		;; [40..n) - encoded runtime call
+
+		;; Invoke call_runtime with the encoded call passed to this contract.
+		(call $assert (i32.eqz
+			(call $call_runtime
+				(i32.const 40)                ;; Pointer where the call is stored
+				(i32.sub
+					(i32.load (i32.const 0))  ;; Size of the call
+					(i32.const 36)            ;; Subtract size of the subcall-related part: 4 bytes for storage length to add + 32 bytes of the callee address 
+				)
+			)
+		))
+
+		;; call passed contract
+		(call $assert (i32.eqz
+			(call $seal_call
+				(i32.const 0) ;; No flags
+				(i32.const 8)  ;; Pointer to "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 512) ;; Pointer to the buffer with value to transfer
+				(i32.const 4) ;; Pointer to input data buffer address
+				(i32.const 4)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		))
+	)
+
+	(func (export "deploy"))
+)
+
diff --git a/substrate/frame/contracts/fixtures/call_with_limit.wat b/substrate/frame/contracts/fixtures/call_with_limit.wat
new file mode 100644
index 0000000000000000000000000000000000000000..04da59551a8ced5eeb14309d1843c981f30adb32
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/call_with_limit.wat
@@ -0,0 +1,38 @@
+;; This expects [account_id, ref_time, proof_size] as input and calls the account_id with the supplied 2D Weight limit.
+;; It returns the result of the call as output data.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal2" "call" (func $seal_call (param i32 i32 i64 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; 0x1000 = 4k in little endian
+	;; size of input buffer
+	(data (i32.const 0) "\00\10")
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		;; Receive the encoded account_id, ref_time, proof_size
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Pointer to the length of the input buffer
+		)
+		(i32.store
+			(i32.const 0)
+			(call $seal_call
+				(i32.const 0) ;; Set no flag.
+				(i32.const 4) ;; Pointer to "callee" address.
+				(i64.load (i32.const 36)) ;; How much ref_time to devote for the execution.
+				(i64.load (i32.const 44)) ;; How much proof_size to devote for the execution.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0) ;; Pointer to the buffer with value to transfer
+				(i32.const 0) ;; Pointer to input data buffer address
+				(i32.const 0)  ;; Length of input data buffer
+				(i32.const 0xffffffff) ;; u32 max sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+				)
+		)
+		(call $seal_return (i32.const 0) (i32.const 0) (i32.const 4))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/caller_contract.wat b/substrate/frame/contracts/fixtures/caller_contract.wat
new file mode 100644
index 0000000000000000000000000000000000000000..929171b9a26f6bcbd2b9523ab13dfedf1ea2a1b8
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/caller_contract.wat
@@ -0,0 +1,286 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_balance" (func $seal_balance (param i32 i32)))
+	(import "seal2" "call" (func $seal_call (param i32 i32 i64 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal2" "instantiate" (func $seal_instantiate
+		(param i32 i64 i64 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
+	))
+	(import "env" "memory" (memory 1 1))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(local $sp i32)
+		(local $exit_code i32)
+
+		;; Length of the buffer
+		(i32.store (i32.const 20) (i32.const 32))
+
+		;; Copy input to this contracts memory
+		(call $seal_input (i32.const 24) (i32.const 20))
+
+		;; Input data is the code hash of the contract to be deployed.
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 20))
+				(i32.const 32)
+			)
+		)
+
+		;; Read current balance into local variable.
+		(set_local $sp (i32.const 1024))
+
+		;; Fail to deploy the contract since it returns a non-zero exit status.
+		(set_local $exit_code
+			(call $seal_instantiate
+				(i32.const 24)	;; Pointer to the code hash.
+				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
+				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 9)	;; Pointer to input data buffer address
+				(i32.const 7)	;; Length of input data buffer
+				(i32.const 4294967295)	;; u32 max sentinel value: do not copy address
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 4294967295) ;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 0)	;; salt_ptr
+				(i32.const 0)	;; salt_le
+			)
+		)
+
+		;; Check non-zero exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 2)) ;; ReturnCode::CalleeReverted
+		)
+
+		;; Fail to deploy the contract due to insufficient ref_time weight.
+		(set_local $exit_code
+			(call $seal_instantiate
+				(i32.const 24)	;; Pointer to the code hash.
+				(i64.const 1)	;; Supply too little ref_time weight
+				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 8)	;; Pointer to input data buffer address
+				(i32.const 8)	;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max sentinel value: do not copy address
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 4294967295) ;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 0)	;; salt_ptr
+				(i32.const 0)	;; salt_le
+
+			)
+		)
+
+		;; Check for special trap exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped
+		)
+
+		;; Fail to deploy the contract due to insufficient ref_time weight.
+		(set_local $exit_code
+			(call $seal_instantiate
+				(i32.const 24)	;; Pointer to the code hash.
+				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
+				(i64.const 1)	;; Supply too little proof_size weight
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 8)	;; Pointer to input data buffer address
+				(i32.const 8)	;; Length of input data buffer
+				(i32.const 4294967295)	;; u32 max sentinel value: do not copy address
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 4294967295)	;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 0)	;; salt_ptr
+				(i32.const 0)	;; salt_le
+
+			)
+		)
+
+		;; Check for special trap exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped
+		)
+
+		;; Length of the output buffer
+		(i32.store
+			(i32.sub (get_local $sp) (i32.const 4))
+			(i32.const 256)
+		)
+
+		;; Deploy the contract successfully.
+		(set_local $exit_code
+			(call $seal_instantiate
+				(i32.const 24)	;; Pointer to the code hash.
+				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
+				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 8)	;; Pointer to input data buffer address
+				(i32.const 8)	;; Length of input data buffer
+				(i32.const 16)	;; Pointer to the address output buffer
+				(i32.sub (get_local $sp) (i32.const 4))	;; Pointer to the address buffer length
+				(i32.const 4294967295)	;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 0)	;; salt_ptr
+				(i32.const 0)	;; salt_le
+
+			)
+		)
+
+		;; Check for success exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 0)) ;; ReturnCode::Success
+		)
+
+		;; Check that address has the expected length
+		(call $assert
+			(i32.eq (i32.load (i32.sub (get_local $sp) (i32.const 4))) (i32.const 32))
+		)
+
+		;; Zero out destination buffer of output
+		(i32.store
+			(i32.sub (get_local $sp) (i32.const 4))
+			(i32.const 0)
+		)
+
+		;; Length of the output buffer
+		(i32.store
+			(i32.sub (get_local $sp) (i32.const 8))
+			(i32.const 4)
+		)
+
+		;; Call the new contract and expect it to return failing exit code.
+		(set_local $exit_code
+			(call $seal_call
+				(i32.const 0)	;; Set no flag
+				(i32.const 16)	;; Pointer to "callee" address.
+				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
+				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 9)	;; Pointer to input data buffer address
+				(i32.const 7)	;; Length of input data buffer
+				(i32.sub (get_local $sp) (i32.const 4))	;; Ptr to output buffer
+				(i32.sub (get_local $sp) (i32.const 8))	;; Ptr to output buffer len
+			)
+		)
+
+		;; Check non-zero exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 2)) ;; ReturnCode::CalleeReverted
+		)
+
+		;; Check that output buffer contains the expected return data.
+		(call $assert
+			(i32.eq (i32.load (i32.sub (get_local $sp) (i32.const 8))) (i32.const 3))
+		)
+		(call $assert
+			(i32.eq
+				(i32.load (i32.sub (get_local $sp) (i32.const 4)))
+				(i32.const 0x00776655)
+			)
+		)
+
+		;; Fail to call the contract due to insufficient ref_time weight.
+		(set_local $exit_code
+			(call $seal_call
+				(i32.const 0)	;; Set no flag
+				(i32.const 16)	;; Pointer to "callee" address.
+				(i64.const 1)	;; Supply too little ref_time weight
+				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 8)	;; Pointer to input data buffer address
+				(i32.const 8)	;; Length of input data buffer
+				(i32.const 4294967295)	;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this cas
+			)
+		)
+
+		;; Check for special trap exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped
+		)
+
+		;; Fail to call the contract due to insufficient proof_size weight.
+		(set_local $exit_code
+			(call $seal_call
+				(i32.const 0)	;; Set no flag
+				(i32.const 16)	;; Pointer to "callee" address.
+				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
+				(i64.const 1)	;; Supply too little proof_size weight
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 8)	;; Pointer to input data buffer address
+				(i32.const 8)	;; Length of input data buffer
+				(i32.const 4294967295)	;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this cas
+			)
+		)
+
+		;; Check for special trap exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 1)) ;; ReturnCode::CalleeTrapped
+		)
+
+		;; Zero out destination buffer of output
+		(i32.store
+			(i32.sub (get_local $sp) (i32.const 4))
+			(i32.const 0)
+		)
+
+		;; Length of the output buffer
+		(i32.store
+			(i32.sub (get_local $sp) (i32.const 8))
+			(i32.const 4)
+		)
+
+		;; Call the contract successfully.
+		(set_local $exit_code
+			(call $seal_call
+				(i32.const 0)	;; Set no flag
+				(i32.const 16)	;; Pointer to "callee" address.
+				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
+				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 0xffffffff)	;; u32 max sentinel value: pass no deposit limit.
+				(i32.const 0)	;; Pointer to the buffer with value to transfer
+				(i32.const 8)	;; Pointer to input data buffer address
+				(i32.const 8)	;; Length of input data buffer
+				(i32.sub (get_local $sp) (i32.const 4))	;; Ptr to output buffer
+				(i32.sub (get_local $sp) (i32.const 8))	;; Ptr to output buffer len
+			)
+		)
+
+		;; Check for success exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 0)) ;; ReturnCode::Success
+		)
+
+		;; Check that the output buffer contains the expected return data.
+		(call $assert
+			(i32.eq (i32.load (i32.sub (get_local $sp) (i32.const 8))) (i32.const 4))
+		)
+		(call $assert
+			(i32.eq
+				(i32.load (i32.sub (get_local $sp) (i32.const 4)))
+				(i32.const 0x77665544)
+			)
+		)
+	)
+
+	(data (i32.const 0) "\00\80")		;; The value to transfer on instantiation and calls.
+										;; Chosen to be greater than existential deposit.
+	(data (i32.const 8) "\00\01\22\33\44\55\66\77")		;; The input data to instantiations and calls.
+)
diff --git a/substrate/frame/contracts/fixtures/chain_extension.wat b/substrate/frame/contracts/fixtures/chain_extension.wat
new file mode 100644
index 0000000000000000000000000000000000000000..670f8e70172e75063b307e4ec679bf68c05be394
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/chain_extension.wat
@@ -0,0 +1,46 @@
+;; Call chain extension by passing through input and output of this contract
+(module
+	(import "seal0" "call_chain_extension"
+		(func $call_chain_extension (param i32 i32 i32 i32 i32) (result i32))
+	)
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 16 16))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok (get_local 0))
+			(unreachable)
+		)
+	)
+
+	;; [0, 4) len of input output
+	(data (i32.const 0) "\08")
+
+	;; [4, 12) buffer for input
+
+	;; [12, 48) len of output buffer
+	(data (i32.const 12) "\20")
+
+	;; [16, inf) buffer for output
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(call $seal_input (i32.const 4) (i32.const 0))
+
+		;; the chain extension passes through the input and returns it as output
+		(call $call_chain_extension
+			(i32.load (i32.const 4))	;; id
+			(i32.const 4)				;; input_ptr
+			(i32.load (i32.const 0))	;; input_len
+			(i32.const 16)				;; output_ptr
+			(i32.const 12)				;; output_len_ptr
+		)
+
+		;; the chain extension passes through the id
+		(call $assert (i32.eq (i32.load (i32.const 4))))
+
+		(call $seal_return (i32.const 0) (i32.const 16) (i32.load (i32.const 12)))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/chain_extension_temp_storage.wat b/substrate/frame/contracts/fixtures/chain_extension_temp_storage.wat
new file mode 100644
index 0000000000000000000000000000000000000000..b481abb5bc7c9617d716ced0a054a94c7b591b86
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/chain_extension_temp_storage.wat
@@ -0,0 +1,85 @@
+;; Call chain extension two times with the specified func_ids
+;; It then calls itself once
+(module
+	(import "seal0" "seal_call_chain_extension"
+		(func $seal_call_chain_extension (param i32 i32 i32 i32 i32) (result i32))
+	)
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_address" (func $seal_address (param i32 i32)))
+	(import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 16 16))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok (get_local 0))
+			(unreachable)
+		)
+	)
+
+	;; [0, 4) len of input buffer: 8 byte (func_ids) + 1byte (stop_recurse)
+	(data (i32.const 0) "\09")
+
+	;; [4, 16) buffer for input
+
+	;; [16, 48] buffer for self address
+
+	;; [48, 52] len of self address buffer
+	(data (i32.const 48) "\20")
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		;; input: (func_id1: i32, func_id2: i32, stop_recurse: i8)
+		(call $seal_input (i32.const 4) (i32.const 0))
+
+		(call $seal_call_chain_extension
+			(i32.load (i32.const 4))	;; id
+			(i32.const 0)				;; input_ptr
+			(i32.const 0)				;; input_len
+			(i32.const 0xffffffff) 		;; u32 max sentinel value: do not copy output
+			(i32.const 0)				;; output_len_ptr
+		)
+		drop
+
+		(call $seal_call_chain_extension
+			(i32.load (i32.const 8))	;; _id
+			(i32.const 0)				;; input_ptr
+			(i32.const 0)				;; input_len
+			(i32.const 0xffffffff) 		;; u32 max sentinel value: do not copy output
+			(i32.const 0)				;; output_len_ptr
+		)
+		drop
+
+		(if (i32.eqz (i32.load8_u (i32.const 12)))
+			(then
+				;; stop recursion
+				(i32.store8 (i32.const 12) (i32.const 1))
+
+				;; load own address into buffer
+				(call $seal_address (i32.const 16) (i32.const 48))
+
+				;; call function 2 + 3 of chainext 3 next time
+				;; (3 << 16) | 2
+				;; (3 << 16) | 3
+				(i32.store (i32.const 4) (i32.const 196610))
+				(i32.store (i32.const 8) (i32.const 196611))
+
+				;; call self
+				(call $seal_call
+					(i32.const 8) ;; Set ALLOW_REENTRY
+					(i32.const 16)  ;; Pointer to "callee" address.
+					(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+					(i32.const 512) ;; Pointer to the buffer with value to transfer
+					(i32.const 4) ;; Pointer to input data buffer address
+					(i32.load (i32.const 0))  ;; Length of input data buffer
+					(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+					(i32.const 0) ;; Length is ignored in this case
+				)
+
+				;; check that call succeeded of call
+				(call $assert (i32.eqz))
+			)
+			(else)
+		)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/create_storage_and_call.wat b/substrate/frame/contracts/fixtures/create_storage_and_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..5592e7e96a9804589046a6ecc6e1c3d3d058c0b9
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/create_storage_and_call.wat
@@ -0,0 +1,60 @@
+;; This calls another contract as passed as its account id. It also creates some storage.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal2" "call" (func $seal_call (param i32 i32 i64 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+    (func (export "deploy"))
+
+    (func (export "call")
+    	;; store length of input buffer
+        (i32.store (i32.const 0) (i32.const 512))
+
+        ;; copy input at address 4:
+		;; first 4 bytes for the size of the storage to be created in callee
+		;; next 32 bytes are for the callee address
+		;; next bytes for the encoded deposit limit
+        (call $seal_input (i32.const 4) (i32.const 0))
+
+       	;; create 4 byte of storage before calling
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.const 4)		;; Size of value
+		)
+
+		;; call passed contract
+		(call $assert (i32.eqz
+			(call $seal_call
+				(i32.const 0) ;; No flags
+				(i32.const 8)  ;; Pointer to "callee" address
+				(i64.const 0)  ;; How much ref_time to devote for the execution. 0 = all
+				(i64.const 0)  ;; How much proof_limit to devote for the execution. 0 = all
+				(i32.const 40) ;; Pointer to the storage deposit limit
+				(i32.const 512) ;; Pointer to the buffer with value to transfer
+				(i32.const 4) ;; Pointer to input data buffer address
+				(i32.const 4)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		))
+
+		;; create 8 byte of storage after calling
+		;; item of 12 bytes because we override 4 bytes
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.const 12)		;; Size of value
+		)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/create_storage_and_instantiate.wat b/substrate/frame/contracts/fixtures/create_storage_and_instantiate.wat
new file mode 100644
index 0000000000000000000000000000000000000000..cd7202478437b8e8052c620c26f973b93f70006c
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/create_storage_and_instantiate.wat
@@ -0,0 +1,66 @@
+;; This instantiates another contract and passes some input to its constructor.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal2" "instantiate" (func $seal_instantiate
+		(param i32 i64 i64 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
+	))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) send 10_000 balance
+	(data (i32.const 48) "\10\27\00\00\00\00\00\00")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+    (func (export "deploy"))
+
+    (func (export "call")
+    	;; store length of input buffer
+        (i32.store (i32.const 0) (i32.const 512))
+    	;; store length of contract address
+        (i32.store (i32.const 84) (i32.const 32))
+
+        ;; copy input at address 4
+        (call $seal_input (i32.const 4) (i32.const 0))
+
+		;; memory layout is:
+		;; 	[0,4): size of input buffer
+		;; 	[4,8): size of the storage to be created in callee
+		;; 	[8,40): the code hash of the contract to instantiate
+		;; 	[40,48): for the encoded deposit limit
+		;; 	[48,52): value to transfer
+		;; 	[52,84): address of the deployed contract
+		;; 	[84,88): len of the address
+
+		;; instantiate a contract
+		(call $assert (i32.eqz
+;;		(i32.store
+;;		 (i32.const 64)
+		 (call $seal_instantiate
+				(i32.const 8)	;; Pointer to the code hash.
+				(i64.const 0)	;; How much ref_time weight to devote for the execution. 0 = all.
+				(i64.const 0)	;; How much proof_size weight to devote for the execution. 0 = all.
+				(i32.const 40)	;; Pointer to the storage deposit limit
+				(i32.const 48)	;; Pointer to the buffer with value to transfer
+				(i32.const 4)	;; Pointer to input data buffer address
+				(i32.const 4)	;; Length of input data buffer
+				(i32.const 52) 	;; Pointer to where to copy address
+				(i32.const 84)	;; Pointer to address len ptr
+				(i32.const 0xffffffff) ;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this case
+				(i32.const 0)	;; salt_ptr
+				(i32.const 0)	;; salt_len
+			)
+		))
+		;; return the deployed contract address
+		(call $seal_return (i32.const 0) (i32.const 52) (i32.const 32))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/crypto_hashes.wat b/substrate/frame/contracts/fixtures/crypto_hashes.wat
new file mode 100644
index 0000000000000000000000000000000000000000..c2b4d6b81edbf95cd6a08d1fd7a92f0f2d9173f5
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/crypto_hashes.wat
@@ -0,0 +1,81 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+
+	(import "seal0" "seal_hash_sha2_256" (func $seal_hash_sha2_256 (param i32 i32 i32)))
+	(import "seal0" "seal_hash_keccak_256" (func $seal_hash_keccak_256 (param i32 i32 i32)))
+	(import "seal0" "seal_hash_blake2_256" (func $seal_hash_blake2_256 (param i32 i32 i32)))
+	(import "seal0" "seal_hash_blake2_128" (func $seal_hash_blake2_128 (param i32 i32 i32)))
+
+	(import "env" "memory" (memory 1 1))
+
+	(type $hash_fn_sig (func (param i32 i32 i32)))
+	(table 8 funcref)
+	(elem (i32.const 1)
+		$seal_hash_sha2_256
+		$seal_hash_keccak_256
+		$seal_hash_blake2_256
+		$seal_hash_blake2_128
+	)
+	(data (i32.const 1) "20202010201008") ;; Output sizes of the hashes in order in hex.
+
+	;; Not in use by the tests besides instantiating the contract.
+	(func (export "deploy"))
+
+	;; Called by the tests.
+	;;
+	;; The `call` function expects data in a certain format in the input buffer.
+	;;
+	;; 1. The first byte encodes an identifier for the crypto hash function
+	;;    under test. (*)
+	;; 2. The rest encodes the input data that is directly fed into the
+	;;    crypto hash function chosen in 1.
+	;;
+	;; The `deploy` function then computes the chosen crypto hash function
+	;; given the input and puts the result into the output buffer.
+	;; After contract execution the test driver then asserts that the returned
+	;; values are equal to the expected bytes for the input and chosen hash
+	;; function.
+	;;
+	;; (*) The possible value for the crypto hash identifiers can be found below:
+	;;
+	;; | value | Algorithm | Bit Width |
+	;; |-------|-----------|-----------|
+	;; |     0 |      SHA2 |       256 |
+	;; |     1 |    KECCAK |       256 |
+	;; |     2 |    BLAKE2 |       256 |
+	;; |     3 |    BLAKE2 |       128 |
+	;; ---------------------------------
+	(func (export "call")
+		(local $chosen_hash_fn i32)
+		(local $input_len_ptr i32)
+		(local $input_ptr i32)
+		(local $input_len i32)
+		(local $output_ptr i32)
+		(local $output_len i32)
+		(local.set $input_len_ptr (i32.const 256))
+		(local.set $input_ptr (i32.const 10))
+		(i32.store (local.get $input_len_ptr) (i32.const 246))
+		(call $seal_input (local.get $input_ptr) (local.get $input_len_ptr))
+		(local.set $chosen_hash_fn (i32.load8_u (local.get $input_ptr)))
+		(if (i32.gt_u (local.get $chosen_hash_fn) (i32.const 7))
+			;; We check that the chosen hash fn  identifier is within bounds: [0,7]
+			(unreachable)
+		)
+		(local.set $input_ptr (i32.add (local.get $input_ptr) (i32.const 1)))
+		(local.set $input_len (i32.sub (i32.load (local.get $input_len_ptr)) (i32.const 1)))
+		(local.set $output_len (i32.load8_u (local.get $chosen_hash_fn)))
+		(call_indirect (type $hash_fn_sig)
+			(local.get $input_ptr)
+			(local.get $input_len)
+			(local.get $input_ptr)
+			(local.get $chosen_hash_fn) ;; Which crypto hash function to execute.
+		)
+		(call $seal_return
+			(i32.const 0)
+			(local.get $input_ptr) ;; Linear memory location of the output buffer.
+			(local.get $output_len) ;; Number of output buffer bytes.
+		)
+		(unreachable)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/debug_message_invalid_utf8.wat b/substrate/frame/contracts/fixtures/debug_message_invalid_utf8.wat
new file mode 100644
index 0000000000000000000000000000000000000000..e8c447b42fca522c32bd471ea02c29911967d166
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/debug_message_invalid_utf8.wat
@@ -0,0 +1,28 @@
+;; Emit a debug message with an invalid utf-8 code
+(module
+	(import "seal0" "seal_debug_message" (func $seal_debug_message (param i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(data (i32.const 0) "\fc")
+
+	(func $assert_eq (param i32 i32)
+		(block $ok
+			(br_if $ok
+				(i32.eq (get_local 0) (get_local 1))
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $assert_eq
+			 (call $seal_debug_message
+				 (i32.const 0)	;; Pointer to the text buffer
+				 (i32.const 12)	;; The size of the buffer
+			 )
+			 (i32.const 0)	;; Success return code
+		)
+	 )
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/debug_message_logging_disabled.wat b/substrate/frame/contracts/fixtures/debug_message_logging_disabled.wat
new file mode 100644
index 0000000000000000000000000000000000000000..fc6ee72df8b08c3a25c649ff16d8216f84dba8de
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/debug_message_logging_disabled.wat
@@ -0,0 +1,28 @@
+;; Emit a "Hello World!" debug message but assume that logging is disabled.
+(module
+	(import "seal0" "seal_debug_message" (func $seal_debug_message (param i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(data (i32.const 0) "Hello World!")
+
+	(func $assert_eq (param i32 i32)
+		(block $ok
+			(br_if $ok
+				(i32.eq (get_local 0) (get_local 1))
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $assert_eq
+			(call $seal_debug_message
+				(i32.const 0)	;; Pointer to the text buffer
+				(i32.const 12)	;; The size of the buffer
+			)
+			(i32.const 0)	;; Success return code
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/debug_message_works.wat b/substrate/frame/contracts/fixtures/debug_message_works.wat
new file mode 100644
index 0000000000000000000000000000000000000000..61933c23296116114f668f2aab747bb46edf5c9b
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/debug_message_works.wat
@@ -0,0 +1,28 @@
+;; Emit a "Hello World!" debug message
+(module
+	(import "seal0" "seal_debug_message" (func $seal_debug_message (param i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(data (i32.const 0) "Hello World!")
+
+	(func $assert_eq (param i32 i32)
+		(block $ok
+			(br_if $ok
+				(i32.eq (get_local 0) (get_local 1))
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $assert_eq
+			(call $seal_debug_message
+				(i32.const 0)	;; Pointer to the text buffer
+				(i32.const 12)	;; The size of the buffer
+			)
+			(i32.const 0)	;; success return code
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/delegate_call.wat b/substrate/frame/contracts/fixtures/delegate_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..7fe422af4551131d29164a2bacb69c05ee009fdf
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/delegate_call.wat
@@ -0,0 +1,111 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_get_storage" (func $seal_get_storage (param i32 i32 i32) (result i32)))
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_delegate_call" (func $seal_delegate_call (param i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 3 3))
+
+	;; [0, 32) storage key
+	(data (i32.const 0) "\01")
+
+	;; [32, 64) storage key
+	(data (i32.const 32) "\02")
+
+	;; [64, 96) buffer where input is copied
+
+	;; [96, 100) size of the input buffer
+	(data (i32.const 96) "\20")
+
+	;; [100, 104) size of buffer for seal_get_storage
+	(data (i32.const 100) "\20")
+
+	;; [104, 136) seal_get_storage buffer
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(local $exit_code i32)
+
+		;; Reading "callee" code_hash
+		(call $seal_input (i32.const 64) (i32.const 96))
+
+		;; assert input size == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 96))
+				(i32.const 32)
+			)
+		)
+
+		;; place a value in storage, the size of which is specified by the call input.
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 32)		;; Pointer to initial value
+		    (i32.load (i32.const 100))		;; Size of value
+		)
+
+		(call $assert
+			(i32.eq
+		        (call $seal_get_storage
+		        	(i32.const 0)		;; Pointer to storage key
+		        	(i32.const 104)		;; buffer where to copy result
+		        	(i32.const 100)		;; pointer to size of buffer
+		        )
+				(i32.const 0) ;; ReturnCode::Success
+			)
+		)
+
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 104))		;; value received from storage
+				(i32.load (i32.const 32))		;; initial value
+			)
+		)
+
+		;; Call deployed library contract code.
+		(set_local $exit_code
+			(call $seal_delegate_call
+				(i32.const 0)	;; Set no call flags
+				(i32.const 64)	;; Pointer to "callee" code_hash.
+				(i32.const 0)	;; Input is ignored
+				(i32.const 0)	;; Length of the input
+				(i32.const 4294967295)	;; u32 max sentinel value: do not copy output
+				(i32.const 0)	;; Length is ignored in this case
+			)
+		)
+
+		;; Check for success exit status.
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 0)) ;; ReturnCode::Success
+		)
+
+		(call $assert
+			(i32.eq
+				(call $seal_get_storage
+					(i32.const 0)		;; Pointer to storage key
+					(i32.const 104)		;; buffer where to copy result
+					(i32.const 100)		;; pointer to size of buffer
+				)
+				(i32.const 0) ;; ReturnCode::Success
+			)
+		)
+
+		;; Make sure that 'callee' code changed the value
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 104))
+				(i32.const 1)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+
+)
diff --git a/substrate/frame/contracts/fixtures/delegate_call_lib.wat b/substrate/frame/contracts/fixtures/delegate_call_lib.wat
new file mode 100644
index 0000000000000000000000000000000000000000..340b9699f87551d9fcbfd968b3fb25f9337ab544
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/delegate_call_lib.wat
@@ -0,0 +1,79 @@
+(module
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_caller" (func $seal_caller (param i32 i32)))
+	(import "seal0" "seal_value_transferred" (func $seal_value_transferred (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) storage key
+	(data (i32.const 0) "\01")
+
+	;; [32, 64) buffer for transferred value
+
+	;; [64, 96) size of the buffer for transferred value
+	(data (i32.const 64) "\20")
+
+	;; [96, 128) buffer for the caller
+
+	;; [128, 160) size of the buffer for caller
+	(data (i32.const 128) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; place a value in storage
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.const 32)		;; Size of value
+		)
+
+		;; This stores the value transferred in the buffer
+		(call $seal_value_transferred (i32.const 32) (i32.const 64))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 64))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the value
+		;; passed to the `caller` contract: 1337
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 32))
+				(i64.const 1337)
+			)
+		)
+
+		;; fill the buffer with the caller.
+		(call $seal_caller (i32.const 96) (i32.const 128))
+
+		;; assert len == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 128))
+				(i32.const 32)
+			)
+		)
+
+		;; assert that the first 64 byte are the beginning of "ALICE",
+		;; who is the caller of the `caller` contract
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 96))
+				(i64.const 0x0101010101010101)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/delegate_call_simple.wat b/substrate/frame/contracts/fixtures/delegate_call_simple.wat
new file mode 100644
index 0000000000000000000000000000000000000000..24ae5a13e33e5c49fb2e638e189e799137cb24f9
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/delegate_call_simple.wat
@@ -0,0 +1,50 @@
+;; Just delegate call into the passed code hash and assert success.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_delegate_call" (func $seal_delegate_call (param i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 3 3))
+
+	;; [0, 32) buffer where input is copied
+
+	;; [32, 36) size of the input buffer
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; Reading "callee" code_hash
+		(call $seal_input (i32.const 0) (i32.const 32))
+
+		;; assert input size == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 32)
+			)
+		)
+
+		;; Delegate call into passed code hash
+		(call $assert
+			(i32.eq
+				(call $seal_delegate_call
+					(i32.const 0)	;; Set no call flags
+					(i32.const 0)	;; Pointer to "callee" code_hash.
+					(i32.const 0)	;; Input is ignored
+					(i32.const 0)	;; Length of the input
+					(i32.const 4294967295)	;; u32 max sentinel value: do not copy output
+					(i32.const 0)	;; Length is ignored in this case
+				)
+				(i32.const 0)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/destroy_and_transfer.wat b/substrate/frame/contracts/fixtures/destroy_and_transfer.wat
new file mode 100644
index 0000000000000000000000000000000000000000..255547955527262162c955d1430026ea9d1ed341
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/destroy_and_transfer.wat
@@ -0,0 +1,161 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_get_storage" (func $seal_get_storage (param i32 i32 i32) (result i32)))
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_transfer" (func $seal_transfer (param i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_instantiate"  (func $seal_instantiate
+		(param i32 i32 i64 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
+	))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) value to send when creating contract.
+	(data (i32.const 0) "\00\00\01")
+
+	;; [8, 16) Value to send when calling contract.
+
+	;; [16, 48) The key to store the contract address under.
+
+	;; [48, 80) Buffer where to store the input to the contract
+
+	;; [88, 96) Size of the buffer
+	(data (i32.const 88) "\FF")
+
+	;; [96, 100) Size of the input buffer
+	(data (i32.const 96) "\20")
+
+	;; [100, 132) Buffer where to store the address of the instantiated contract
+
+	;; [132, 134) Salt
+	(data (i32.const 132) "\47\11")
+
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "deploy")
+		;; Input data is the code hash of the contract to be deployed.
+		(call $seal_input (i32.const 48) (i32.const 96))
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 96))
+				(i32.const 32)
+			)
+		)
+
+		;; Deploy the contract with the provided code hash.
+		(call $assert
+			(i32.eq
+				(call $seal_instantiate
+					(i32.const 48)	;; Pointer to the code hash.
+					(i32.const 32)	;; Length of the code hash.
+					(i64.const 0)	;; How much gas to devote for the execution. 0 = all.
+					(i32.const 0)	;; Pointer to the buffer with value to transfer
+					(i32.const 8)	;; Length of the buffer with value to transfer.
+					(i32.const 0)	;; Pointer to input data buffer address
+					(i32.const 0)	;; Length of input data buffer
+					(i32.const 100)	;; Buffer where to store address of new contract
+					(i32.const 88)	;; Pointer to the length of the buffer
+					(i32.const 4294967295) ;; u32 max sentinel value: do not copy output
+					(i32.const 0) ;; Length is ignored in this case
+					(i32.const 132) ;; salt_ptr
+					(i32.const 2) ;; salt_len
+				)
+				(i32.const 0)
+			)
+		)
+
+		;; Check that address has expected length
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 88))
+				(i32.const 32)
+			)
+		)
+
+		;; Store the return address.
+		(call $seal_set_storage
+			(i32.const 16)	;; Pointer to the key
+			(i32.const 100)	;; Pointer to the value
+			(i32.const 32)	;; Length of the value
+		)
+	)
+
+	(func (export "call")
+		;; Read address of destination contract from storage.
+		(call $assert
+			(i32.eq
+				(call $seal_get_storage
+					(i32.const 16)	;; Pointer to the key
+					(i32.const 100)	;; Pointer to the value
+					(i32.const 88)	;; Pointer to the len of the value
+				)
+				(i32.const 0)
+			)
+		)
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 88))
+				(i32.const 32)
+			)
+		)
+
+		;; Calling the destination contract with non-empty input data should fail.
+		(call $assert
+			(i32.eq
+				(call $seal_call
+					(i32.const 100)	;; Pointer to destination address
+					(i32.const 32)	;; Length of destination address
+					(i64.const 0)	;; How much gas to devote for the execution. 0 = all.
+					(i32.const 0)	;; Pointer to the buffer with value to transfer
+					(i32.const 8)	;; Length of the buffer with value to transfer
+					(i32.const 0)	;; Pointer to input data buffer address
+					(i32.const 1)	;; Length of input data buffer
+					(i32.const 4294967295) ;; u32 max sentinel value: do not copy output
+					(i32.const 0) ;; Length is ignored in this case
+
+				)
+				(i32.const 0x1)
+			)
+		)
+
+		;; Call the destination contract regularly, forcing it to self-destruct.
+		(call $assert
+			(i32.eq
+				(call $seal_call
+					(i32.const 100)	;; Pointer to destination address
+					(i32.const 32)	;; Length of destination address
+					(i64.const 0)	;; How much gas to devote for the execution. 0 = all.
+					(i32.const 8)	;; Pointer to the buffer with value to transfer
+					(i32.const 8)	;; Length of the buffer with value to transfer
+					(i32.const 0)	;; Pointer to input data buffer address
+					(i32.const 0)	;; Length of input data buffer
+					(i32.const 4294967295) ;; u32 max sentinel value: do not copy output
+					(i32.const 0) ;; Length is ignored in this case
+				)
+				(i32.const 0)
+			)
+		)
+
+		;; Calling the destination address with non-empty input data should now work since the
+		;; contract has been removed. Also transfer a balance to the address so we can ensure this
+		;; does not hinder the contract from being removed.
+		(call $assert
+			(i32.eq
+				(call $seal_transfer
+					(i32.const 100)	;; Pointer to destination address
+					(i32.const 32)	;; Length of destination address
+					(i32.const 0)	;; Pointer to the buffer with value to transfer
+					(i32.const 8)	;; Length of the buffer with value to transfer
+				)
+				(i32.const 0)
+			)
+		)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/drain.wat b/substrate/frame/contracts/fixtures/drain.wat
new file mode 100644
index 0000000000000000000000000000000000000000..9f126898fac81e48d62581d61fbbfc2c8a009bc1
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/drain.wat
@@ -0,0 +1,50 @@
+(module
+	(import "seal0" "seal_balance" (func $seal_balance (param i32 i32)))
+	(import "seal0" "seal_transfer" (func $seal_transfer (param i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) reserved for $seal_balance output
+
+	;; [8, 16) length of the buffer
+	(data (i32.const 8) "\08")
+
+	;; [16, inf) zero initialized
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		;; Send entire remaining balance to the 0 address.
+		(call $seal_balance (i32.const 0) (i32.const 8))
+
+		;; Balance should be encoded as a u64.
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 8))
+				(i32.const 8)
+			)
+		)
+
+		;; Try to self-destruct by sending full balance to the 0 address.
+		;; The call will fail because a contract transfer has a keep alive requirement
+		(call $assert
+			(i32.eq
+				(call $seal_transfer
+					(i32.const 16)	;; Pointer to destination address
+					(i32.const 32)	;; Length of destination address
+					(i32.const 0)	;; Pointer to the buffer with value to transfer
+					(i32.const 8)	;; Length of the buffer with value to transfer
+				)
+				(i32.const 5) ;; ReturnCode::TransferFailed
+			)
+		)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/dummy.wat b/substrate/frame/contracts/fixtures/dummy.wat
new file mode 100644
index 0000000000000000000000000000000000000000..a6435e49df222fcad04e38b16e63cca7c9282796
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/dummy.wat
@@ -0,0 +1,6 @@
+;; A valid contract which does nothing at all
+(module
+	(import "env" "memory" (memory 1 1))
+	(func (export "deploy"))
+	(func (export "call"))
+)
diff --git a/substrate/frame/contracts/fixtures/ecdsa_recover.wat b/substrate/frame/contracts/fixtures/ecdsa_recover.wat
new file mode 100644
index 0000000000000000000000000000000000000000..d694b3215e86b3025c99daa3f6704b62f90647fe
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/ecdsa_recover.wat
@@ -0,0 +1,55 @@
+;; This contract:
+;; 1) Reads signature and message hash from the input
+;; 2) Calls ecdsa_recover
+;; 3) Validates that result is Success
+;; 4) Returns recovered compressed public key
+(module
+	(import "seal0" "seal_ecdsa_recover" (func $seal_ecdsa_recover (param i32 i32 i32) (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "deploy"))
+
+	;; [4, 8) len of signature + message hash - 65 bytes + 32 byte = 97 bytes
+	(data (i32.const 4) "\61")
+
+	;; Memory layout during `call`
+	;; [10, 75) signature
+	;; [75, 107) message hash
+	(func (export "call")
+		(local $signature_ptr i32)
+		(local $message_hash_ptr i32)
+		(local $result i32)
+		(local.set $signature_ptr (i32.const 10))
+		(local.set $message_hash_ptr (i32.const 75))
+		;; Read signature and message hash - 97 bytes
+		(call $seal_input (local.get $signature_ptr) (i32.const 4))
+		(local.set
+			$result
+			(call $seal_ecdsa_recover
+				(local.get $signature_ptr)
+				(local.get $message_hash_ptr)
+				(local.get $signature_ptr) ;; Store output into message signature ptr, because we don't need it anymore
+			)
+		)
+		(call $assert
+			(i32.eq
+				(local.get $result) ;; The result of recovery execution
+				(i32.const 0x0) ;; 0x0 - Success result
+			)
+		)
+
+		;; exit with success and return recovered public key
+		(call $seal_return (i32.const 0) (local.get $signature_ptr) (i32.const 33))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/event_and_return_on_deploy.wat b/substrate/frame/contracts/fixtures/event_and_return_on_deploy.wat
new file mode 100644
index 0000000000000000000000000000000000000000..809cfe13545a62bbfb72558312c1b585f2a9dbd2
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/event_and_return_on_deploy.wat
@@ -0,0 +1,26 @@
+(module
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal0" "seal_deposit_event" (func $seal_deposit_event (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "deploy")
+		(call $seal_deposit_event
+			(i32.const 0) ;; The topics buffer
+			(i32.const 0) ;; The topics buffer's length
+			(i32.const 8) ;; The data buffer
+			(i32.const 4) ;; The data buffer's length
+		)
+		(call $seal_return
+			(i32.const 0)
+			(i32.const 8)
+			(i32.const 4)
+		)
+		(unreachable)
+	)
+
+	(func (export "call")
+		(unreachable)
+	)
+
+	(data (i32.const 8) "\01\02\03\04")
+)
diff --git a/substrate/frame/contracts/fixtures/event_size.wat b/substrate/frame/contracts/fixtures/event_size.wat
new file mode 100644
index 0000000000000000000000000000000000000000..4bd6158d72fb95471f202b01a92855a0312a76f7
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/event_size.wat
@@ -0,0 +1,39 @@
+(module
+	(import "seal0" "seal_deposit_event" (func $seal_deposit_event (param i32 i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 16 16))
+
+	;; [0, 4) size of the input buffer
+	(data (i32.const 0) "\04")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $seal_input (i32.const 4) (i32.const 0))
+
+		;; assert input size == 4
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 0))
+				(i32.const 4)
+			)
+		)
+
+		;; place a garbage value in storage, the size of which is specified by the call input.
+		(call $seal_deposit_event
+			(i32.const 0) ;; topics_ptr
+			(i32.const 0) ;; topics_len
+			(i32.const 0) ;; data_ptr
+			(i32.load (i32.const 4)) ;; data_len
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/float_instruction.wat b/substrate/frame/contracts/fixtures/float_instruction.wat
new file mode 100644
index 0000000000000000000000000000000000000000..efa6b9de52de6c63f68d620c843dec07a565153b
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/float_instruction.wat
@@ -0,0 +1,12 @@
+;; Module that contains a float instruction which is illegal in deterministic mode
+(module
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		f32.const 1
+		drop
+	)
+	(func (export "deploy")
+		f32.const 2
+        drop
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/instantiate_return_code.wat b/substrate/frame/contracts/fixtures/instantiate_return_code.wat
new file mode 100644
index 0000000000000000000000000000000000000000..6a8654520f106476e477408e8afa4995f44dc2cf
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/instantiate_return_code.wat
@@ -0,0 +1,47 @@
+;; This instantiats a contract and transfers 100 balance during this call and copies the return code
+;; of this call to the output buffer.
+;; The first 32 byte of input is the code hash to instantiate
+;; The rest of the input is forwarded to the constructor of the callee
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal1" "seal_instantiate" (func $seal_instantiate
+		(param i32 i64 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
+	))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) 10_000 balance
+	(data (i32.const 0) "\10\27\00\00\00\00\00\00")
+
+	;; [8, 12) here we store the return code of the transfer
+
+	;; [12, 16) size of the input buffer
+	(data (i32.const 12) "\24")
+
+	;; [16, inf) input buffer
+	;; 32 bye code hash + 4 byte forward
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(call $seal_input (i32.const 16) (i32.const 12))
+		(i32.store
+			(i32.const 8)
+			(call $seal_instantiate
+				(i32.const 16) ;; Pointer to the code hash.
+				(i64.const 0) ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 0) ;; Pointer to the buffer with value to transfer
+				(i32.const 48) ;; Pointer to input data buffer address
+				(i32.const 4) ;; Length of input data buffer
+				(i32.const 0xffffffff) ;; u32 max sentinel value: do not copy address
+				(i32.const 0) ;; Length is ignored in this case
+				(i32.const 0xffffffff) ;; u32 max sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+				(i32.const 0) ;; salt_ptr
+				(i32.const 0) ;; salt_len
+			)
+		)
+		;; exit with success and take transfer return code to the output buffer
+		(call $seal_return (i32.const 0) (i32.const 8) (i32.const 4))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/invalid_contract_no_call.wat b/substrate/frame/contracts/fixtures/invalid_contract_no_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..34f7c99ba85e4813d329a01ca9201046b6055b86
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/invalid_contract_no_call.wat
@@ -0,0 +1,5 @@
+;; Valid module but missing the call function
+(module
+	(import "env" "memory" (memory 1 1))
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/invalid_contract_no_memory.wat b/substrate/frame/contracts/fixtures/invalid_contract_no_memory.wat
new file mode 100644
index 0000000000000000000000000000000000000000..0aeefbcb7ebfe27f55fb84de0f14a3c7ec12b05c
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/invalid_contract_no_memory.wat
@@ -0,0 +1,5 @@
+;; A valid contract which does nothing at all
+(module
+	(func (export "deploy"))
+	(func (export "call"))
+)
diff --git a/substrate/frame/contracts/fixtures/invalid_module.wat b/substrate/frame/contracts/fixtures/invalid_module.wat
new file mode 100644
index 0000000000000000000000000000000000000000..e4a72f74273f9350420f737e0974516b3e5c4132
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/invalid_module.wat
@@ -0,0 +1,8 @@
+;; An invalid module
+(module
+	(func (export "deploy"))
+	(func (export "call")
+		;; imbalanced stack
+		(i32.const 7)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/multi_store.wat b/substrate/frame/contracts/fixtures/multi_store.wat
new file mode 100644
index 0000000000000000000000000000000000000000..2592baf618355ea75d277ee72ff8ce4874af7642
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/multi_store.wat
@@ -0,0 +1,54 @@
+;; Does two stores to two seperate storage items
+;; Expects (len0, len1) as input.
+(module
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 16 16))
+
+	;; [0, 32) storage key 0
+	(data (i32.const 0) "\01")
+
+	;; [32, 64) storage key 1
+	(data (i32.const 32) "\02")
+
+	;; [64, 72) buffer where input is copied (expected sizes of storage items)
+
+	;; [72, 76) size of the input buffer
+	(data (i32.const 72) "\08")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $seal_input (i32.const 64) (i32.const 72))
+
+		;; assert input size == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 72))
+				(i32.const 8)
+			)
+		)
+
+		;; place a values in storage sizes are specified in the input buffer
+		;; we don't care about the contents of the storage item
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.load (i32.const 64))	;; Size of value
+		)
+		(call $seal_set_storage
+			(i32.const 32)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.load (i32.const 68))	;; Size of value
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/new_set_code_hash_contract.wat b/substrate/frame/contracts/fixtures/new_set_code_hash_contract.wat
new file mode 100644
index 0000000000000000000000000000000000000000..86ab2737be4844053b1ad46a3add0b7d5c1dafcb
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/new_set_code_hash_contract.wat
@@ -0,0 +1,13 @@
+(module
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) return value
+	(data (i32.const 0) "\02")
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(call $seal_return (i32.const 0) (i32.const 0) (i32.const 4))
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/ok_trap_revert.wat b/substrate/frame/contracts/fixtures/ok_trap_revert.wat
new file mode 100644
index 0000000000000000000000000000000000000000..b7eaa9b700af57ff34ba46a816d1758d6de5fbc4
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/ok_trap_revert.wat
@@ -0,0 +1,35 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+    (func (export "deploy")
+        (call $ok_trap_revert)
+    )
+
+    (func (export "call")
+        (call $ok_trap_revert)
+    )
+
+    (func $ok_trap_revert
+        (i32.store (i32.const 4) (i32.const 4))
+        (call $seal_input (i32.const 0) (i32.const 4))
+        (block $IF_2
+            (block $IF_1
+                (block $IF_0
+                    (br_table $IF_0 $IF_1 $IF_2
+                        (i32.load8_u (i32.const 0))
+                    )
+                    (unreachable)
+                )
+                ;; 0 = return with success
+                return
+            )
+            ;; 1 = revert
+            (call $seal_return (i32.const 1) (i32.const 0) (i32.const 0))
+            (unreachable)
+        )
+        ;; 2 = trap
+        (unreachable)
+    )
+)
diff --git a/substrate/frame/contracts/fixtures/reentrance_count_call.wat b/substrate/frame/contracts/fixtures/reentrance_count_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..c6b529e2aff8b147ad34dc12a4466e8a0e652eed
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/reentrance_count_call.wat
@@ -0,0 +1,76 @@
+;; This fixture recursively tests if reentrance_count returns correct reentrant count value when
+;; using seal_call to make caller contract call to itself
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_address" (func $seal_address (param i32 i32)))
+	(import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "reentrance_count" (func $reentrance_count (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) reserved for $seal_address output
+
+	;; [32, 36) buffer for the call stack height
+
+	;; [36, 40) size of the input buffer
+	(data (i32.const 36) "\04")
+
+	;; [40, 44) length of the buffer for $seal_address
+	(data (i32.const 40) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+	(func (export "call")
+		(local $expected_reentrance_count i32)
+		(local $seal_call_exit_code i32)
+
+		;; reading current contract address
+		(call $seal_address (i32.const 0) (i32.const 40))
+
+		;; reading passed input
+		(call $seal_input (i32.const 32) (i32.const 36))
+
+		;; reading manually passed reentrant count
+		(set_local $expected_reentrance_count (i32.load (i32.const 32)))
+
+		;; reentrance count is calculated correctly
+		(call $assert
+			(i32.eq (call $reentrance_count) (get_local $expected_reentrance_count))
+		)
+
+		;; re-enter 5 times in a row and assert that the reentrant counter works as expected
+		(i32.eq (call $reentrance_count) (i32.const 5))
+		(if
+			(then) ;; recursion exit case
+			(else
+				;; incrementing $expected_reentrance_count passed to the contract
+				(i32.store (i32.const 32) (i32.add (i32.load (i32.const 32)) (i32.const 1)))
+
+				;; Call to itself
+				(set_local $seal_call_exit_code
+					(call $seal_call
+						(i32.const 8)	;; Allow reentrancy flag set
+						(i32.const 0)	;; Pointer to "callee" address
+						(i64.const 0)	;; How much gas to devote for the execution. 0 = all.
+						(i32.const 0)	;; Pointer to the buffer with value to transfer
+						(i32.const 32)	;; Pointer to input data buffer address
+						(i32.const 4)	;; Length of input data buffer
+						(i32.const 0xffffffff) ;; u32 max sentinel value: do not copy output
+						(i32.const 0) ;; Ptr to output buffer len
+					)
+				)
+
+				(call $assert
+					(i32.eq (get_local $seal_call_exit_code) (i32.const 0))
+				)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
\ No newline at end of file
diff --git a/substrate/frame/contracts/fixtures/reentrance_count_delegated_call.wat b/substrate/frame/contracts/fixtures/reentrance_count_delegated_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..b8219a8462ee2ef23001f336e5160d1dda35fbc7
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/reentrance_count_delegated_call.wat
@@ -0,0 +1,71 @@
+;; This fixture recursively tests if reentrance_count returns correct reentrant count value when
+;; using seal_delegate_call to make caller contract delegate call to itself
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_delegate_call" (func $seal_delegate_call (param i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "reentrance_count" (func $reentrance_count (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) buffer where code hash is copied
+
+	;; [32, 36) buffer for the call stack height
+
+	;; [36, 40) size of the input buffer
+	(data (i32.const 36) "\24")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+	(func (export "call")
+		(local $callstack_height i32)
+		(local $delegate_call_exit_code i32)
+
+		;; Reading input
+		(call $seal_input (i32.const 0) (i32.const 36))
+
+		;; reading passed callstack height
+		(set_local $callstack_height (i32.load (i32.const 32)))
+
+		;; incrementing callstack height
+		(i32.store (i32.const 32) (i32.add (i32.load (i32.const 32)) (i32.const 1)))
+
+		;; reentrance count stays 0
+		(call $assert
+			(i32.eq (call $reentrance_count) (i32.const 0))
+		)
+
+		(i32.eq (get_local $callstack_height) (i32.const 5))
+		(if
+			(then) ;; exit recursion case
+			(else
+				;; Call to itself
+				(set_local $delegate_call_exit_code
+					(call $seal_delegate_call
+						(i32.const 0)	;; Set no call flags
+						(i32.const 0)	;; Pointer to "callee" code_hash.
+						(i32.const 0)	;; Pointer to the input data
+						(i32.const 36)	;; Length of the input
+						(i32.const 4294967295)	;; u32 max sentinel value: do not copy output
+						(i32.const 0)	;; Length is ignored in this case
+					)
+				)
+
+				(call $assert
+					(i32.eq (get_local $delegate_call_exit_code) (i32.const 0))
+				)
+			)
+		)
+
+		(call $assert
+			(i32.le_s (get_local $callstack_height) (i32.const 5))
+		)
+	)
+
+	(func (export "deploy"))
+)
\ No newline at end of file
diff --git a/substrate/frame/contracts/fixtures/return_with_data.wat b/substrate/frame/contracts/fixtures/return_with_data.wat
new file mode 100644
index 0000000000000000000000000000000000000000..93b9daa07a303f632e56c360b173969e4c1dfdca
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/return_with_data.wat
@@ -0,0 +1,33 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 128) buffer where input is copied
+
+	;; [128, 132) length of the input buffer
+	(data (i32.const 128) "\80")
+
+	;; Deploy routine is the same as call.
+	(func (export "deploy")
+		(call $call)
+	)
+
+	;; Call reads the first 4 bytes (LE) as the exit status and returns the rest as output data.
+	(func $call (export "call")
+		;; Copy input into this contracts memory.
+		(call $seal_input (i32.const 0) (i32.const 128))
+
+		;; Copy all but the first 4 bytes of the input data as the output data.
+		;; Use the first byte as exit status
+		(call $seal_return
+			(i32.load8_u (i32.const 0))	;; Exit status
+			(i32.const 4)	;; Pointer to the data to return.
+			(i32.sub		;; Count of bytes to copy.
+				(i32.load (i32.const 128))
+				(i32.const 4)
+			)
+		)
+		(unreachable)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/run_out_of_gas.wat b/substrate/frame/contracts/fixtures/run_out_of_gas.wat
new file mode 100644
index 0000000000000000000000000000000000000000..fe53e92c4fa842a386117e2b4cea52e191398ea1
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/run_out_of_gas.wat
@@ -0,0 +1,8 @@
+(module
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(loop $inf (br $inf)) ;; just run out of gas
+		(unreachable)
+	)
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/seal_input_noop.wat b/substrate/frame/contracts/fixtures/seal_input_noop.wat
new file mode 100644
index 0000000000000000000000000000000000000000..7b5a1e32af4d61ba8dfecdc978e5f4d3a09e1480
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/seal_input_noop.wat
@@ -0,0 +1,14 @@
+;; Everything prepared for the host function call, but no call is performed.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) buffer to write input
+
+	;; [8, 12) size of the input buffer
+	(data (i32.const 8) "\04")
+
+	(func (export "call"))
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/seal_input_once.wat b/substrate/frame/contracts/fixtures/seal_input_once.wat
new file mode 100644
index 0000000000000000000000000000000000000000..919a03a9b6903df3ff4917347b9c40a2d260b8f1
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/seal_input_once.wat
@@ -0,0 +1,22 @@
+;; Stores a value of the passed size. The host function is called once.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) buffer to write input
+
+	;; [8, 12) size of the input buffer
+	(data (i32.const 8) "\04")
+
+	(func (export "call")
+		;; instructions to consume engine fuel
+		(drop
+			(i32.const 42)
+		 )
+
+ 	    (call $seal_input (i32.const 0) (i32.const 8))
+
+	 )
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/seal_input_twice.wat b/substrate/frame/contracts/fixtures/seal_input_twice.wat
new file mode 100644
index 0000000000000000000000000000000000000000..3a8be814efb045078494294961686931c4cd7ab4
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/seal_input_twice.wat
@@ -0,0 +1,28 @@
+;; Stores a value of the passed size. The host function is called twice.
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 8) buffer to write input
+
+	;; [8, 12) size of the input buffer
+	(data (i32.const 8) "\04")
+
+	(func (export "call")
+		;; instructions to consume engine fuel
+		(drop
+			(i32.const 42)
+		 )
+
+ 	    (call $seal_input (i32.const 0) (i32.const 8))
+
+		;; instructions to consume engine fuel
+		(drop
+			(i32.const 42)
+		 )
+
+ 	    (call $seal_input (i32.const 0) (i32.const 8))
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/self_destruct.wat b/substrate/frame/contracts/fixtures/self_destruct.wat
new file mode 100644
index 0000000000000000000000000000000000000000..b8a37306e20110bf43087a511cdf241683da6f43
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/self_destruct.wat
@@ -0,0 +1,83 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_address" (func $seal_address (param i32 i32)))
+	(import "seal0" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_terminate" (func $seal_terminate (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) reserved for $seal_address output
+
+	;; [32, 36) length of the buffer
+	(data (i32.const 32) "\20")
+
+	;; [36, 68) Address of django
+	(data (i32.const 36)
+		"\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04"
+		"\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04"
+	)
+
+	;; [68, 72) reserved for output of $seal_input
+
+	;; [72, 76) length of the buffer
+	(data (i32.const 72) "\04")
+
+	;; [76, inf) zero initialized
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		;; If the input data is not empty, then recursively call self with empty input data.
+		;; This should trap instead of self-destructing since a contract cannot be removed live in
+		;; the execution stack cannot be removed. If the recursive call traps, then trap here as
+		;; well.
+		(call $seal_input (i32.const 68) (i32.const 72))
+		(if (i32.load (i32.const 72))
+			(then
+				(call $seal_address (i32.const 0) (i32.const 32))
+
+				;; Expect address to be 8 bytes.
+				(call $assert
+					(i32.eq
+						(i32.load (i32.const 32))
+						(i32.const 32)
+					)
+				)
+
+				;; Recursively call self with empty input data.
+				(call $assert
+					(i32.eq
+						(call $seal_call
+							(i32.const 0)	;; Pointer to own address
+							(i32.const 32)	;; Length of own address
+							(i64.const 0)	;; How much gas to devote for the execution. 0 = all.
+							(i32.const 76)	;; Pointer to the buffer with value to transfer
+							(i32.const 8)	;; Length of the buffer with value to transfer
+							(i32.const 0)	;; Pointer to input data buffer address
+							(i32.const 0)	;; Length of input data buffer
+							(i32.const 4294967295) ;; u32 max sentinel value: do not copy output
+							(i32.const 0) ;; Length is ignored in this case
+						)
+						(i32.const 0)
+					)
+				)
+			)
+			(else
+				;; Try to terminate and give balance to django.
+				(call $seal_terminate
+					(i32.const 36)	;; Pointer to beneficiary address
+					(i32.const 32)	;; Length of beneficiary address
+				)
+				(unreachable) ;; seal_terminate never returns
+			)
+		)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/self_destructing_constructor.wat b/substrate/frame/contracts/fixtures/self_destructing_constructor.wat
new file mode 100644
index 0000000000000000000000000000000000000000..85fce511e21b96fcb3b7c15fce5ad765c6e405d7
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/self_destructing_constructor.wat
@@ -0,0 +1,23 @@
+(module
+	(import "seal0" "seal_terminate" (func $seal_terminate (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "deploy")
+		;; Self-destruct by sending full balance to the 0 address.
+		(call $seal_terminate
+			(i32.const 0)	;; Pointer to destination address
+			(i32.const 32)	;; Length of destination address
+		)
+	)
+
+	(func (export "call"))
+)
diff --git a/substrate/frame/contracts/fixtures/set_code_hash.wat b/substrate/frame/contracts/fixtures/set_code_hash.wat
new file mode 100644
index 0000000000000000000000000000000000000000..b4df1b133186b67100fc6cee9d8804590cc8e66b
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/set_code_hash.wat
@@ -0,0 +1,43 @@
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal0" "seal_set_code_hash" (func $seal_set_code_hash (param i32) (result i32)))
+
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) here we store input
+
+	;; [32, 36) input size
+	(data (i32.const 32) "\20")
+
+	;; [36, 40) return value
+	(data (i32.const 36) "\01")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(local $exit_code i32)
+
+		(call $seal_input (i32.const 0) (i32.const 32))
+
+		(set_local $exit_code
+			(call $seal_set_code_hash (i32.const 0)) ;; Pointer to the input data.
+		)
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 0)) ;; ReturnCode::Success
+		)
+
+		;; we return 1 after setting new code_hash
+		;; next `call` will NOT return this value, because contract code has been changed
+		(call $seal_return (i32.const 0) (i32.const 36) (i32.const 4))
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/set_empty_storage.wat b/substrate/frame/contracts/fixtures/set_empty_storage.wat
new file mode 100644
index 0000000000000000000000000000000000000000..dbcd3a1326aa27298704d738f75b8d5110357763
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/set_empty_storage.wat
@@ -0,0 +1,15 @@
+;; This module stores a KV pair into the storage
+(module
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "env" "memory" (memory 16 16))
+
+	(func (export "call")
+	)
+	(func (export "deploy")
+		(call $seal_set_storage
+			(i32.const 0)				;; Pointer to storage key
+			(i32.const 0)				;; Pointer to value
+			(i32.load (i32.const 0))	;; Size of value
+		)
+	)
+)
diff --git a/substrate/frame/contracts/fixtures/sr25519_verify.wat b/substrate/frame/contracts/fixtures/sr25519_verify.wat
new file mode 100644
index 0000000000000000000000000000000000000000..2da1ceb87eab060b9c714f642bc864200e126c68
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/sr25519_verify.wat
@@ -0,0 +1,55 @@
+;; This contract:
+;; 1) Reads signature, message and public key from the input
+;; 2) Calls and return the result of sr25519_verify
+
+(module
+    ;; import the host functions from the seal0 module
+	(import "seal0" "sr25519_verify" (func $sr25519_verify (param i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+
+	;; give the program 1 page of memory
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 4) length of signature + message + public key - 64 + 11 + 32 = 107 bytes
+	;; write the length of the input (6b = 107) bytes at offset 0
+	(data (i32.const 0) "\6b")
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		;; define local variables
+		(local $signature_ptr i32)
+		(local $pub_key_ptr i32)
+		(local $message_len i32)
+		(local $message_ptr i32)
+
+		;; set the pointers to the memory locations
+		;; Memory layout during `call`
+		;; [10, 74) signature
+		;; [74, 106) public key
+		;; [106, 117) message (11 bytes)
+		(local.set $signature_ptr (i32.const 10))
+		(local.set $pub_key_ptr (i32.const 74))
+		(local.set $message_ptr (i32.const 106))
+
+		;; store the input into the memory, starting at the signature and 
+		;; up to 107 bytes stored at offset 0
+		(call $seal_input (local.get $signature_ptr) (i32.const 0))
+
+		;; call sr25519_verify and store the return code
+		(i32.store
+			(i32.const 0)
+			(call $sr25519_verify
+				(local.get $signature_ptr)
+				(local.get $pub_key_ptr)
+				(i32.const 11)
+				(local.get $message_ptr)
+			)
+		)
+
+		;; exit with success and take transfer return code to the output buffer
+		(call $seal_return (i32.const 0) (i32.const 0) (i32.const 4))
+	)
+)
+
diff --git a/substrate/frame/contracts/fixtures/storage_size.wat b/substrate/frame/contracts/fixtures/storage_size.wat
new file mode 100644
index 0000000000000000000000000000000000000000..293a656d4f6ea4e029e7fc7cbd98241da263f220
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/storage_size.wat
@@ -0,0 +1,68 @@
+(module
+	(import "seal0" "seal_get_storage" (func $seal_get_storage (param i32 i32 i32) (result i32)))
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 16 16))
+
+	;; [0, 32) storage key
+	(data (i32.const 0) "\01")
+
+	;; [32, 36) buffer where input is copied (expected size of storage item)
+
+	;; [36, 40) size of the input buffer
+	(data (i32.const 36) "\04")
+
+	;; [40, 44) size of buffer for seal_get_storage set to max
+	(data (i32.const 40) "\FF\FF\FF\FF")
+
+	;; [44, inf) seal_get_storage buffer
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $seal_input (i32.const 32) (i32.const 36))
+
+		;; assert input size == 4
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 36))
+				(i32.const 4)
+			)
+		)
+
+		;; place a garbage value in storage, the size of which is specified by the call input.
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.load (i32.const 32))	;; Size of value
+		)
+
+		(call $assert
+			(i32.eq
+				(call $seal_get_storage
+					(i32.const 0)		;; Pointer to storage key
+					(i32.const 44)		;; buffer where to copy result
+					(i32.const 40)		;; pointer to size of buffer
+				)
+				(i32.const 0)
+			)
+		)
+
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 40))
+				(i32.load (i32.const 32))
+			)
+		)
+	)
+
+	(func (export "deploy"))
+
+)
diff --git a/substrate/frame/contracts/fixtures/store_call.wat b/substrate/frame/contracts/fixtures/store_call.wat
new file mode 100644
index 0000000000000000000000000000000000000000..9e090d31801f8d00572b3330c606c875054217c8
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/store_call.wat
@@ -0,0 +1,45 @@
+;; Stores a value of the passed size.
+(module
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 16 16))
+
+	;; [0, 32) storage key
+	(data (i32.const 0) "\01")
+
+	;; [32, 36) buffer where input is copied (expected size of storage item)
+
+	;; [36, 40) size of the input buffer
+	(data (i32.const 36) "\04")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $seal_input (i32.const 32) (i32.const 36))
+
+		;; assert input size == 4
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 36))
+				(i32.const 4)
+			)
+		)
+
+		;; place a value in storage, the size of which is specified by the call input.
+		;; we don't care about the contents of the storage item
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.load (i32.const 32))	;; Size of value
+		)
+	)
+
+	(func (export "deploy"))
+)
diff --git a/substrate/frame/contracts/fixtures/store_deploy.wat b/substrate/frame/contracts/fixtures/store_deploy.wat
new file mode 100644
index 0000000000000000000000000000000000000000..cc428e9623bfb49c3b3b52ed349b0a6f856096bb
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/store_deploy.wat
@@ -0,0 +1,45 @@
+;; Stores a value of the passed size in constructor.
+(module
+	(import "seal0" "seal_set_storage" (func $seal_set_storage (param i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 16 16))
+
+	;; [0, 32) storage key
+	(data (i32.const 0) "\01")
+
+	;; [32, 36) buffer where input is copied (expected size of storage item)
+
+	;; [36, 40) size of the input buffer
+	(data (i32.const 36) "\04")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "deploy")
+		(call $seal_input (i32.const 32) (i32.const 36))
+
+		;; assert input size == 4
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 36))
+				(i32.const 4)
+			)
+		)
+
+		;; place a value in storage, the size of which is specified by the call input.
+		;; we don't care about the contents of the storage item
+		(call $seal_set_storage
+			(i32.const 0)		;; Pointer to storage key
+			(i32.const 0)		;; Pointer to value
+			(i32.load (i32.const 32))	;; Size of value
+		)
+	)
+
+	(func (export "call"))
+)
diff --git a/substrate/frame/contracts/fixtures/transfer_return_code.wat b/substrate/frame/contracts/fixtures/transfer_return_code.wat
new file mode 100644
index 0000000000000000000000000000000000000000..50098851dcf81ab3250b4736c559a6b391eda455
--- /dev/null
+++ b/substrate/frame/contracts/fixtures/transfer_return_code.wat
@@ -0,0 +1,34 @@
+;; This transfers 100 balance to the zero account and copies the return code
+;; of this transfer to the output buffer.
+(module
+	(import "seal0" "seal_transfer" (func $seal_transfer (param i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) zero-adress
+	(data (i32.const 0)
+		"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+		"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	)
+
+	;; [32, 40) 100 balance
+	(data (i32.const 32) "\64\00\00\00\00\00\00\00")
+
+	;; [40, 44) here we store the return code of the transfer
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(i32.store
+			(i32.const 40)
+			(call $seal_transfer
+				(i32.const 0) ;; ptr to destination address
+				(i32.const 32) ;; length of destination address
+				(i32.const 32) ;; ptr to value to transfer
+				(i32.const 8) ;; length of value to transfer
+			)
+		)
+		;; exit with success and take transfer return code to the output buffer
+		(call $seal_return (i32.const 0) (i32.const 40) (i32.const 4))
+	)
+)
diff --git a/substrate/frame/contracts/primitives/Cargo.toml b/substrate/frame/contracts/primitives/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c868035c2404dd08bf14657ae2a0b129f748ceee
--- /dev/null
+++ b/substrate/frame/contracts/primitives/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "pallet-contracts-primitives"
+version = "24.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "A crate that hosts a common definitions that are relevant for the pallet-contracts."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+bitflags = "1.0"
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+
+# Substrate Dependencies (This crate should not rely on frame)
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-weights = { version = "20.0.0", default-features = false, path = "../../../primitives/weights" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-weights/std",
+]
diff --git a/substrate/frame/contracts/primitives/README.md b/substrate/frame/contracts/primitives/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..12718cd86425b4820dc63ce1369c7e4d93d3bc93
--- /dev/null
+++ b/substrate/frame/contracts/primitives/README.md
@@ -0,0 +1,3 @@
+A crate that hosts a common definitions that are relevant for the pallet-contracts.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/contracts/primitives/src/lib.rs b/substrate/frame/contracts/primitives/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c33149285004b38ad4beee7aac330c9d7421324b
--- /dev/null
+++ b/substrate/frame/contracts/primitives/src/lib.rs
@@ -0,0 +1,263 @@
+// 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 crate that hosts a common definitions that are relevant for the pallet-contracts.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use bitflags::bitflags;
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	DispatchError, RuntimeDebug,
+};
+use sp_std::prelude::*;
+use sp_weights::Weight;
+
+/// Result type of a `bare_call` or `bare_instantiate` call as well as `ContractsApi::call` and
+/// `ContractsApi::instantiate`.
+///
+/// It contains the execution result together with some auxiliary information.
+///
+/// #Note
+///
+/// It has been extended to include `events` at the end of the struct while not bumping the
+/// `ContractsApi` version. Therefore when SCALE decoding a `ContractResult` its trailing data
+/// should be ignored to avoid any potential compatibility issues.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct ContractResult<R, Balance, EventRecord> {
+	/// How much weight was consumed during execution.
+	pub gas_consumed: Weight,
+	/// How much weight is required as gas limit in order to execute this call.
+	///
+	/// This value should be used to determine the weight limit for on-chain execution.
+	///
+	/// # Note
+	///
+	/// This can only different from [`Self::gas_consumed`] when weight pre charging
+	/// is used. Currently, only `seal_call_runtime` makes use of pre charging.
+	/// Additionally, any `seal_call` or `seal_instantiate` makes use of pre-charging
+	/// when a non-zero `gas_limit` argument is supplied.
+	pub gas_required: Weight,
+	/// How much balance was paid by the origin into the contract's deposit account in order to
+	/// pay for storage.
+	///
+	/// The storage deposit is never actually charged from the origin in case of [`Self::result`]
+	/// is `Err`. This is because on error all storage changes are rolled back including the
+	/// payment of the deposit.
+	pub storage_deposit: StorageDeposit<Balance>,
+	/// An optional debug message. This message is only filled when explicitly requested
+	/// by the code that calls into the contract. Otherwise it is empty.
+	///
+	/// The contained bytes are valid UTF-8. This is not declared as `String` because
+	/// this type is not allowed within the runtime.
+	///
+	/// Clients should not make any assumptions about the format of the buffer.
+	/// They should just display it as-is. It is **not** only a collection of log lines
+	/// provided by a contract but a formatted buffer with different sections.
+	///
+	/// # Note
+	///
+	/// The debug message is never generated during on-chain execution. It is reserved for
+	/// RPC calls.
+	pub debug_message: Vec<u8>,
+	/// The execution result of the wasm code.
+	pub result: R,
+	/// The events that were emitted during execution. It is an option as event collection is
+	/// optional.
+	pub events: Option<Vec<EventRecord>>,
+}
+
+/// Result type of a `bare_call` call as well as `ContractsApi::call`.
+pub type ContractExecResult<Balance, EventRecord> =
+	ContractResult<Result<ExecReturnValue, DispatchError>, Balance, EventRecord>;
+
+/// Result type of a `bare_instantiate` call as well as `ContractsApi::instantiate`.
+pub type ContractInstantiateResult<AccountId, Balance, EventRecord> =
+	ContractResult<Result<InstantiateReturnValue<AccountId>, DispatchError>, Balance, EventRecord>;
+
+/// Result type of a `bare_code_upload` call.
+pub type CodeUploadResult<CodeHash, Balance> =
+	Result<CodeUploadReturnValue<CodeHash, Balance>, DispatchError>;
+
+/// Result type of a `get_storage` call.
+pub type GetStorageResult = Result<Option<Vec<u8>>, ContractAccessError>;
+
+/// The possible errors that can happen querying the storage of a contract.
+#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, MaxEncodedLen, RuntimeDebug, TypeInfo)]
+pub enum ContractAccessError {
+	/// The given address doesn't point to a contract.
+	DoesntExist,
+	/// Storage key cannot be decoded from the provided input data.
+	KeyDecodingFailed,
+	/// Storage is migrating. Try again later.
+	MigrationInProgress,
+}
+
+bitflags! {
+	/// Flags used by a contract to customize exit behaviour.
+	#[derive(Encode, Decode, TypeInfo)]
+	pub struct ReturnFlags: u32 {
+		/// If this bit is set all changes made by the contract execution are rolled back.
+		const REVERT = 0x0000_0001;
+	}
+}
+
+/// Output of a contract call or instantiation which ran to completion.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct ExecReturnValue {
+	/// Flags passed along by `seal_return`. Empty when `seal_return` was never called.
+	pub flags: ReturnFlags,
+	/// Buffer passed along by `seal_return`. Empty when `seal_return` was never called.
+	pub data: Vec<u8>,
+}
+
+impl ExecReturnValue {
+	/// The contract did revert all storage changes.
+	pub fn did_revert(&self) -> bool {
+		self.flags.contains(ReturnFlags::REVERT)
+	}
+}
+
+/// The result of a successful contract instantiation.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct InstantiateReturnValue<AccountId> {
+	/// The output of the called constructor.
+	pub result: ExecReturnValue,
+	/// The account id of the new contract.
+	pub account_id: AccountId,
+}
+
+/// The result of successfully uploading a contract.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, MaxEncodedLen, RuntimeDebug, TypeInfo)]
+pub struct CodeUploadReturnValue<CodeHash, Balance> {
+	/// The key under which the new code is stored.
+	pub code_hash: CodeHash,
+	/// The deposit that was reserved at the caller. Is zero when the code already existed.
+	pub deposit: Balance,
+}
+
+/// Reference to an existing code hash or a new wasm module.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub enum Code<Hash> {
+	/// A wasm module as raw bytes.
+	Upload(Vec<u8>),
+	/// The code hash of an on-chain wasm blob.
+	Existing(Hash),
+}
+
+/// The amount of balance that was either charged or refunded in order to pay for storage.
+#[derive(
+	Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, RuntimeDebug, TypeInfo,
+)]
+pub enum StorageDeposit<Balance> {
+	/// The transaction reduced storage consumption.
+	///
+	/// This means that the specified amount of balance was transferred from the involved
+	/// deposit accounts to the origin.
+	Refund(Balance),
+	/// The transaction increased storage consumption.
+	///
+	/// This means that the specified amount of balance was transferred from the origin
+	/// to the involved deposit accounts.
+	Charge(Balance),
+}
+
+impl<Balance: Zero> Default for StorageDeposit<Balance> {
+	fn default() -> Self {
+		Self::Charge(Zero::zero())
+	}
+}
+
+impl<Balance: Zero + Copy> StorageDeposit<Balance> {
+	/// Returns how much balance is charged or `0` in case of a refund.
+	pub fn charge_or_zero(&self) -> Balance {
+		match self {
+			Self::Charge(amount) => *amount,
+			Self::Refund(_) => Zero::zero(),
+		}
+	}
+
+	pub fn is_zero(&self) -> bool {
+		match self {
+			Self::Charge(amount) => amount.is_zero(),
+			Self::Refund(amount) => amount.is_zero(),
+		}
+	}
+}
+
+impl<Balance> StorageDeposit<Balance>
+where
+	Balance: Saturating + Ord + Copy,
+{
+	/// This is essentially a saturating signed add.
+	pub fn saturating_add(&self, rhs: &Self) -> Self {
+		use StorageDeposit::*;
+		match (self, rhs) {
+			(Charge(lhs), Charge(rhs)) => Charge(lhs.saturating_add(*rhs)),
+			(Refund(lhs), Refund(rhs)) => Refund(lhs.saturating_add(*rhs)),
+			(Charge(lhs), Refund(rhs)) =>
+				if lhs >= rhs {
+					Charge(lhs.saturating_sub(*rhs))
+				} else {
+					Refund(rhs.saturating_sub(*lhs))
+				},
+			(Refund(lhs), Charge(rhs)) =>
+				if lhs > rhs {
+					Refund(lhs.saturating_sub(*rhs))
+				} else {
+					Charge(rhs.saturating_sub(*lhs))
+				},
+		}
+	}
+
+	/// This is essentially a saturating signed sub.
+	pub fn saturating_sub(&self, rhs: &Self) -> Self {
+		use StorageDeposit::*;
+		match (self, rhs) {
+			(Charge(lhs), Refund(rhs)) => Charge(lhs.saturating_add(*rhs)),
+			(Refund(lhs), Charge(rhs)) => Refund(lhs.saturating_add(*rhs)),
+			(Charge(lhs), Charge(rhs)) =>
+				if lhs >= rhs {
+					Charge(lhs.saturating_sub(*rhs))
+				} else {
+					Refund(rhs.saturating_sub(*lhs))
+				},
+			(Refund(lhs), Refund(rhs)) =>
+				if lhs > rhs {
+					Refund(lhs.saturating_sub(*rhs))
+				} else {
+					Charge(rhs.saturating_sub(*lhs))
+				},
+		}
+	}
+
+	/// If the amount of deposit (this type) is constrained by a `limit` this calculates how
+	/// much balance (if any) is still available from this limit.
+	///
+	/// # Note
+	///
+	/// In case of a refund the return value can be larger than `limit`.
+	pub fn available(&self, limit: &Balance) -> Balance {
+		use StorageDeposit::*;
+		match self {
+			Charge(amount) => limit.saturating_sub(*amount),
+			Refund(amount) => limit.saturating_add(*amount),
+		}
+	}
+}
diff --git a/substrate/frame/contracts/proc-macro/Cargo.toml b/substrate/frame/contracts/proc-macro/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8a63875f2a980ad24aa97fbbe1c5602b0a28142c
--- /dev/null
+++ b/substrate/frame/contracts/proc-macro/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "pallet-contracts-proc-macro"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Procedural macros used in pallet_contracts"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full"] }
+
+[dev-dependencies]
+
+[features]
+# If set the full output is generated. Do NOT set when generating for wasm runtime.
+full = []
diff --git a/substrate/frame/contracts/proc-macro/src/lib.rs b/substrate/frame/contracts/proc-macro/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b31403c29adfd10b570c068923f47974f636489e
--- /dev/null
+++ b/substrate/frame/contracts/proc-macro/src/lib.rs
@@ -0,0 +1,862 @@
+// 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.
+
+//! Procedural macros used in the contracts module.
+//!
+//! Most likely you should use the [`#[define_env]`][`macro@define_env`] attribute macro which hides
+//! boilerplate of defining external environment for a wasm module.
+
+#![no_std]
+
+extern crate alloc;
+
+use alloc::{
+	collections::BTreeMap,
+	format,
+	string::{String, ToString},
+	vec::Vec,
+};
+use core::cmp::Reverse;
+use proc_macro::TokenStream;
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use quote::{quote, quote_spanned, ToTokens};
+use syn::{
+	parse_macro_input, punctuated::Punctuated, spanned::Spanned, token::Comma, Data, DeriveInput,
+	FnArg, Ident,
+};
+
+/// This derives `Debug` for a struct where each field must be of some numeric type.
+/// It interprets each field as its represents some weight and formats it as times so that
+/// it is readable by humans.
+#[proc_macro_derive(WeightDebug)]
+pub fn derive_weight_debug(input: TokenStream) -> TokenStream {
+	derive_debug(input, format_weight)
+}
+
+/// This is basically identical to the std libs Debug derive but without adding any
+/// bounds to existing generics.
+#[proc_macro_derive(ScheduleDebug)]
+pub fn derive_schedule_debug(input: TokenStream) -> TokenStream {
+	derive_debug(input, format_default)
+}
+
+fn derive_debug(input: TokenStream, fmt: impl Fn(&Ident) -> TokenStream2) -> TokenStream {
+	let input = parse_macro_input!(input as DeriveInput);
+	let name = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+	let data = if let Data::Struct(data) = &input.data {
+		data
+	} else {
+		return quote_spanned! {
+			name.span() =>
+			compile_error!("WeightDebug is only supported for structs.");
+		}
+		.into()
+	};
+
+	#[cfg(feature = "full")]
+	let fields = iterate_fields(data, fmt);
+
+	#[cfg(not(feature = "full"))]
+	let fields = {
+		drop(fmt);
+		drop(data);
+		TokenStream2::new()
+	};
+
+	let tokens = quote! {
+		impl #impl_generics core::fmt::Debug for #name #ty_generics #where_clause {
+			fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+				use ::sp_runtime::{FixedPointNumber, FixedU128 as Fixed};
+				let mut formatter = formatter.debug_struct(stringify!(#name));
+				#fields
+				formatter.finish()
+			}
+		}
+	};
+
+	tokens.into()
+}
+
+/// This is only used then the `full` feature is activated.
+#[cfg(feature = "full")]
+fn iterate_fields(data: &syn::DataStruct, fmt: impl Fn(&Ident) -> TokenStream2) -> TokenStream2 {
+	use syn::Fields;
+
+	match &data.fields {
+		Fields::Named(fields) => {
+			let recurse = fields.named.iter().filter_map(|f| {
+				let name = f.ident.as_ref()?;
+				if name.to_string().starts_with('_') {
+					return None
+				}
+				let value = fmt(name);
+				let ret = quote_spanned! { f.span() =>
+					formatter.field(stringify!(#name), #value);
+				};
+				Some(ret)
+			});
+			quote! {
+				#( #recurse )*
+			}
+		},
+		Fields::Unnamed(fields) => quote_spanned! {
+			fields.span() =>
+			compile_error!("Unnamed fields are not supported")
+		},
+		Fields::Unit => quote!(),
+	}
+}
+
+fn format_weight(field: &Ident) -> TokenStream2 {
+	quote_spanned! { field.span() =>
+		&if self.#field.ref_time() > 1_000_000_000 {
+			format!(
+				"{:.1?} ms, {} bytes",
+				Fixed::saturating_from_rational(self.#field.ref_time(), 1_000_000_000).to_float(),
+				self.#field.proof_size()
+			)
+		} else if self.#field.ref_time() > 1_000_000 {
+			format!(
+				"{:.1?} µs, {} bytes",
+				Fixed::saturating_from_rational(self.#field.ref_time(), 1_000_000).to_float(),
+				self.#field.proof_size()
+			)
+		} else if self.#field.ref_time() > 1_000 {
+			format!(
+				"{:.1?} ns, {} bytes",
+				Fixed::saturating_from_rational(self.#field.ref_time(), 1_000).to_float(),
+				self.#field.proof_size()
+			)
+		} else {
+			format!("{} ps, {} bytes", self.#field.ref_time(), self.#field.proof_size())
+		}
+	}
+}
+
+fn format_default(field: &Ident) -> TokenStream2 {
+	quote_spanned! { field.span() =>
+		&self.#field
+	}
+}
+
+/// Parsed environment definition.
+struct EnvDef {
+	host_funcs: Vec<HostFn>,
+}
+
+/// Parsed host function definition.
+struct HostFn {
+	item: syn::ItemFn,
+	version: u8,
+	name: String,
+	returns: HostFnReturn,
+	is_stable: bool,
+	alias_to: Option<String>,
+	/// Formulating the predicate inverted makes the expression using it simpler.
+	not_deprecated: bool,
+}
+
+enum HostFnReturn {
+	Unit,
+	U32,
+	U64,
+	ReturnCode,
+}
+
+impl HostFnReturn {
+	fn to_wasm_sig(&self) -> TokenStream2 {
+		let ok = match self {
+			Self::Unit => quote! { () },
+			Self::U32 | Self::ReturnCode => quote! { ::core::primitive::u32 },
+			Self::U64 => quote! { ::core::primitive::u64 },
+		};
+		quote! {
+			::core::result::Result<#ok, ::wasmi::core::Trap>
+		}
+	}
+}
+
+impl ToTokens for HostFn {
+	fn to_tokens(&self, tokens: &mut TokenStream2) {
+		self.item.to_tokens(tokens);
+	}
+}
+
+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);
+			syn::Error::new(span, msg)
+		};
+
+		// process attributes
+		let msg =
+			"only #[version(<u8>)], #[unstable], #[prefixed_alias] and #[deprecated] attributes are allowed.";
+		let span = item.span();
+		let mut attrs = item.attrs.clone();
+		attrs.retain(|a| !a.path().is_ident("doc"));
+		let mut maybe_version = None;
+		let mut is_stable = true;
+		let mut alias_to = None;
+		let mut not_deprecated = true;
+		while let Some(attr) = attrs.pop() {
+			let ident = attr.path().get_ident().ok_or(err(span, msg))?.to_string();
+			match ident.as_str() {
+				"version" => {
+					if maybe_version.is_some() {
+						return Err(err(span, "#[version] can only be specified once"))
+					}
+					maybe_version =
+						Some(attr.parse_args::<syn::LitInt>().and_then(|lit| lit.base10_parse())?);
+				},
+				"unstable" => {
+					if !is_stable {
+						return Err(err(span, "#[unstable] can only be specified once"))
+					}
+					is_stable = false;
+				},
+				"prefixed_alias" => {
+					alias_to = Some(item.sig.ident.to_string());
+					item.sig.ident = syn::Ident::new(
+						&format!("seal_{}", &item.sig.ident.to_string()),
+						item.sig.ident.span(),
+					);
+				},
+				"deprecated" => {
+					if !not_deprecated {
+						return Err(err(span, "#[deprecated] can only be specified once"))
+					}
+					not_deprecated = false;
+				},
+				_ => return Err(err(span, msg)),
+			}
+		}
+		let name = item.sig.ident.to_string();
+
+		if !(is_stable || not_deprecated) {
+			return Err(err(span, "#[deprecated] is mutually exclusive with #[unstable]"))
+		}
+
+		// process arguments: The first and second args are treated differently (ctx, memory)
+		// they must exist and be `ctx: _` and `memory: _`.
+		let msg = "Every function must start with two inferred parameters: ctx: _ and memory: _";
+		let special_args = item
+			.sig
+			.inputs
+			.iter()
+			.take(2)
+			.enumerate()
+			.map(|(i, arg)| is_valid_special_arg(i, arg))
+			.fold(0u32, |acc, valid| if valid { acc + 1 } else { acc });
+
+		if special_args != 2 {
+			return Err(err(span, msg))
+		}
+
+		// process return type
+		let msg = r#"Should return one of the following:
+				- Result<(), TrapReason>,
+				- Result<ReturnCode, TrapReason>,
+				- Result<u64, TrapReason>,
+				- Result<u32, TrapReason>"#;
+		let ret_ty = match item.clone().sig.output {
+			syn::ReturnType::Type(_, ty) => Ok(ty.clone()),
+			_ => Err(err(span, &msg)),
+		}?;
+		match *ret_ty {
+			syn::Type::Path(tp) => {
+				let result = &tp.path.segments.last().ok_or(err(span, &msg))?;
+				let (id, span) = (result.ident.to_string(), result.ident.span());
+				id.eq(&"Result".to_string()).then_some(()).ok_or(err(span, &msg))?;
+
+				match &result.arguments {
+					syn::PathArguments::AngleBracketed(group) => {
+						if group.args.len() != 2 {
+							return Err(err(span, &msg))
+						};
+
+						let arg2 = group.args.last().ok_or(err(span, &msg))?;
+
+						let err_ty = match arg2 {
+							syn::GenericArgument::Type(ty) => Ok(ty.clone()),
+							_ => Err(err(arg2.span(), &msg)),
+						}?;
+
+						match err_ty {
+							syn::Type::Path(tp) => Ok(tp
+								.path
+								.segments
+								.first()
+								.ok_or(err(arg2.span(), &msg))?
+								.ident
+								.to_string()),
+							_ => Err(err(tp.span(), &msg)),
+						}?
+						.eq("TrapReason")
+						.then_some(())
+						.ok_or(err(span, &msg))?;
+
+						let arg1 = group.args.first().ok_or(err(span, &msg))?;
+						let ok_ty = match arg1 {
+							syn::GenericArgument::Type(ty) => Ok(ty.clone()),
+							_ => Err(err(arg1.span(), &msg)),
+						}?;
+						let ok_ty_str = match ok_ty {
+							syn::Type::Path(tp) => Ok(tp
+								.path
+								.segments
+								.first()
+								.ok_or(err(arg1.span(), &msg))?
+								.ident
+								.to_string()),
+							syn::Type::Tuple(tt) => {
+								if !tt.elems.is_empty() {
+									return Err(err(arg1.span(), &msg))
+								};
+								Ok("()".to_string())
+							},
+							_ => Err(err(ok_ty.span(), &msg)),
+						}?;
+						let returns = match ok_ty_str.as_str() {
+							"()" => Ok(HostFnReturn::Unit),
+							"u32" => Ok(HostFnReturn::U32),
+							"u64" => Ok(HostFnReturn::U64),
+							"ReturnCode" => Ok(HostFnReturn::ReturnCode),
+							_ => Err(err(arg1.span(), &msg)),
+						}?;
+
+						Ok(Self {
+							item,
+							version: maybe_version.unwrap_or_default(),
+							name,
+							returns,
+							is_stable,
+							alias_to,
+							not_deprecated,
+						})
+					},
+					_ => Err(err(span, &msg)),
+				}
+			},
+			_ => Err(err(span, &msg)),
+		}
+	}
+
+	fn module(&self) -> String {
+		format!("seal{}", self.version)
+	}
+}
+
+impl EnvDef {
+	pub fn try_from(item: syn::ItemMod) -> syn::Result<Self> {
+		let span = item.span();
+		let err = |msg| syn::Error::new(span, msg);
+		let items = &item
+			.content
+			.as_ref()
+			.ok_or(err("Invalid environment definition, expected `mod` to be inlined."))?
+			.1;
+
+		let extract_fn = |i: &syn::Item| match i {
+			syn::Item::Fn(i_fn) => Some(i_fn.clone()),
+			_ => None,
+		};
+
+		let selector = |a: &syn::Attribute| a.path().is_ident("prefixed_alias");
+
+		let aliases = items
+			.iter()
+			.filter_map(extract_fn)
+			.filter(|i| i.attrs.iter().any(selector))
+			.map(|i| HostFn::try_from(i));
+
+		let host_funcs = items
+			.iter()
+			.filter_map(extract_fn)
+			.map(|mut i| {
+				i.attrs.retain(|i| !selector(i));
+				i
+			})
+			.map(|i| HostFn::try_from(i))
+			.chain(aliases)
+			.collect::<Result<Vec<_>, _>>()?;
+
+		Ok(Self { host_funcs })
+	}
+}
+
+fn is_valid_special_arg(idx: usize, arg: &FnArg) -> bool {
+	let FnArg::Typed(pat) = arg else { return false };
+	let ident = if let syn::Pat::Ident(ref ident) = *pat.pat { &ident.ident } else { return false };
+	let name_ok = match idx {
+		0 => ident == "ctx" || ident == "_ctx",
+		1 => ident == "memory" || ident == "_memory",
+		_ => false,
+	};
+	if !name_ok {
+		return false
+	}
+	matches!(*pat.ty, syn::Type::Infer(_))
+}
+
+fn expand_func_doc(func: &HostFn) -> TokenStream2 {
+	// Remove auxiliary args: `ctx: _` and `memory: _`
+	let func_decl = {
+		let mut sig = func.item.sig.clone();
+		sig.inputs = sig
+			.inputs
+			.iter()
+			.skip(2)
+			.map(|p| p.clone())
+			.collect::<Punctuated<FnArg, Comma>>();
+		sig.to_token_stream()
+	};
+	let func_doc = {
+		let func_docs = if let Some(origin_fn) = &func.alias_to {
+			let alias_doc = format!(
+				"This is just an alias function to [`{0}()`][`Self::{0}`] with backwards-compatible prefixed identifier.",
+				origin_fn,
+			);
+			quote! { #[doc = #alias_doc] }
+		} else {
+			let docs = func.item.attrs.iter().filter(|a| a.path().is_ident("doc")).map(|d| {
+				let docs = d.to_token_stream();
+				quote! { #docs }
+			});
+			quote! { #( #docs )* }
+		};
+		let deprecation_notice = if !func.not_deprecated {
+			let warning = "\n # Deprecated\n\n \
+								This function is deprecated and will be removed in future versions.\n \
+								No new code or contracts with this API can be deployed.";
+			quote! { #[doc = #warning] }
+		} else {
+			quote! {}
+		};
+		let import_notice = {
+			let info = format!(
+				"\n# Wasm Import Statement\n```wat\n(import \"seal{}\" \"{}\" (func ...))\n```",
+				func.version, func.name,
+			);
+			quote! { #[doc = #info] }
+		};
+		let unstable_notice = if !func.is_stable {
+			let warning = "\n # Unstable\n\n \
+								This function is unstable and it is a subject to change (or removal) in the future.\n \
+								Do not deploy a contract using it to a production chain.";
+			quote! { #[doc = #warning] }
+		} else {
+			quote! {}
+		};
+		quote! {
+			#deprecation_notice
+			#func_docs
+			#import_notice
+			#unstable_notice
+		}
+	};
+	quote! {
+		#func_doc
+		#func_decl;
+	}
+}
+
+/// Expands documentation for host functions.
+fn expand_docs(def: &EnvDef) -> TokenStream2 {
+	// Create the `Current` trait with only the newest versions
+	// we sort so that only the newest versions make it into `docs`
+	let mut current_docs = BTreeMap::new();
+	let mut funcs: Vec<_> = def.host_funcs.iter().filter(|f| f.alias_to.is_none()).collect();
+	funcs.sort_unstable_by_key(|func| Reverse(func.version));
+	for func in funcs {
+		if current_docs.contains_key(&func.name) {
+			continue
+		}
+		current_docs.insert(func.name.clone(), expand_func_doc(&func));
+	}
+	let current_docs = current_docs.values();
+
+	// Create the `legacy` module with all functions
+	// Maps from version to list of functions that have this version
+	let mut legacy_doc = BTreeMap::<u8, Vec<TokenStream2>>::new();
+	for func in def.host_funcs.iter() {
+		legacy_doc.entry(func.version).or_default().push(expand_func_doc(&func));
+	}
+	let legacy_doc = legacy_doc.into_iter().map(|(version, funcs)| {
+		let doc = format!("All functions available in the **seal{}** module", version);
+		let version = Ident::new(&format!("Version{version}"), Span::call_site());
+		quote! {
+			#[doc = #doc]
+			pub trait #version {
+				#( #funcs )*
+			}
+		}
+	});
+
+	quote! {
+		/// Contains only the latest version of each function.
+		///
+		/// In reality there are more functions available but they are all obsolete: When a function
+		/// is updated a new **version** is added and the old versions stays available as-is.
+		/// We only list the newest version here. Some functions are available under additional
+		/// names (aliases) for historic reasons which are omitted here.
+		///
+		/// If you want an overview of all the functions available to a contact all you need
+		/// to look at is this trait. It contains only the latest version of each
+		/// function and no aliases. If you are writing a contract(language) from scratch
+		/// this is where you should look at.
+		pub trait Current {
+			#( #current_docs )*
+		}
+		#( #legacy_doc )*
+	}
+}
+
+/// Expands environment definition.
+/// Should generate source code for:
+///  - implementations of the host functions to be added to the wasm runtime environment (see
+///    `expand_impls()`).
+fn expand_env(def: &EnvDef, docs: bool) -> TokenStream2 {
+	let impls = expand_impls(def);
+	let docs = docs.then_some(expand_docs(def)).unwrap_or(TokenStream2::new());
+
+	quote! {
+		pub struct Env;
+		#impls
+		/// Documentation of the API (host functions) available to contracts.
+		///
+		/// The `Current` trait might be the most useful doc to look at. The versioned
+		/// traits only exist for reference: If trying to find out if a specific version of
+		/// `pallet-contracts` contains a certain function.
+		///
+		/// # Note
+		///
+		/// This module is not meant to be used by any code. Rather, it is meant to be
+		/// consumed by humans through rustdoc.
+		#[cfg(doc)]
+		pub mod api_doc {
+			use super::{TrapReason, ReturnCode};
+			#docs
+		}
+	}
+}
+
+/// Generates for every host function:
+///   - 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! { () });
+
+	quote! {
+		impl<'a, E: Ext> crate::wasm::Environment<crate::wasm::runtime::Runtime<'a, E>> for Env
+		{
+			fn define(
+				store: &mut ::wasmi::Store<crate::wasm::Runtime<E>>,
+				linker: &mut ::wasmi::Linker<crate::wasm::Runtime<E>>,
+				allow_unstable: AllowUnstableInterface,
+				allow_deprecated: AllowDeprecatedInterface,
+			) -> Result<(),::wasmi::errors::LinkerError> {
+				#impls
+				Ok(())
+			}
+		}
+
+		impl crate::wasm::Environment<()> for Env
+		{
+			fn define(
+				store: &mut ::wasmi::Store<()>,
+				linker: &mut ::wasmi::Linker<()>,
+				allow_unstable: AllowUnstableInterface,
+				allow_deprecated: AllowDeprecatedInterface,
+			) -> Result<(), ::wasmi::errors::LinkerError> {
+				#dummy_impls
+				Ok(())
+			}
+		}
+	}
+}
+
+fn expand_functions(def: &EnvDef, expand_blocks: bool, host_state: TokenStream2) -> 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 is_stable = f.is_stable;
+		let not_deprecated = f.not_deprecated;
+
+		// wrapped host function body call with host function traces
+		// see https://github.com/paritytech/substrate/tree/master/frame/contracts#host-function-tracing
+		let wrapped_body_with_trace = {
+			let trace_fmt_args = params.clone().filter_map(|arg| match arg {
+				syn::FnArg::Receiver(_) => None,
+				syn::FnArg::Typed(p) => {
+					match *p.pat.clone() {
+						syn::Pat::Ident(ref pat_ident) => Some(pat_ident.ident.clone()),
+						_ => None,
+					}
+				},
+			});
+
+			let params_fmt_str = trace_fmt_args.clone().map(|s| format!("{s}: {{:?}}")).collect::<Vec<_>>().join(", ");
+			let trace_fmt_str = format!("{}::{}({}) = {{:?}}\n", module, name, params_fmt_str);
+
+			quote! {
+				let result = #body;
+				if ::log::log_enabled!(target: "runtime::contracts::strace", ::log::Level::Trace) {
+						use sp_std::fmt::Write;
+						let mut w = sp_std::Writer::default();
+						let _ = core::write!(&mut w, #trace_fmt_str, #( #trace_fmt_args, )* result);
+						let msg = core::str::from_utf8(&w.inner()).unwrap_or_default();
+						ctx.ext().append_debug_buffer(msg);
+				}
+				result
+			}
+		};
+
+		// If we don't expand blocks (implementing for `()`) we change a few things:
+		// - 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 into_host = if expand_blocks {
+			quote! {
+				|reason| {
+					::wasmi::core::Trap::from(reason)
+				}
+			}
+		} else {
+			quote! {
+				|reason| { reason }
+			}
+		};
+		let allow_unused =  if expand_blocks {
+			quote! { }
+		} else {
+			quote! { #[allow(unused_variables)] }
+		};
+		let sync_gas_before = if expand_blocks {
+			quote! {
+				// Gas left in the gas meter right before switching to engine execution.
+				let __gas_before__ = {
+					let engine_consumed_total =
+						__caller__.fuel_consumed().expect("Fuel metering is enabled; qed");
+					let gas_meter = __caller__.data_mut().ext().gas_meter_mut();
+					gas_meter
+						.charge_fuel(engine_consumed_total)
+						.map_err(TrapReason::from)
+						.map_err(#into_host)?
+						.ref_time()
+				};
+			}
+		} else {
+			quote! { }
+		};
+		// Gas left in the gas meter right after returning from engine execution.
+		let sync_gas_after = if expand_blocks {
+			quote! {
+				let mut gas_after = __caller__.data_mut().ext().gas_meter().gas_left().ref_time();
+				let mut host_consumed = __gas_before__.saturating_sub(gas_after);
+				// Possible undercharge of at max 1 fuel here, if host consumed less than `instruction_weights.base`
+				// Not a problem though, as soon as host accounts its spent gas properly.
+				let fuel_consumed = host_consumed
+					.checked_div(__caller__.data_mut().ext().schedule().instruction_weights.base as u64)
+					.ok_or(Error::<E::T>::InvalidSchedule)
+					.map_err(TrapReason::from)
+					.map_err(#into_host)?;
+				 __caller__
+					 .consume_fuel(fuel_consumed)
+					 .map_err(|_| TrapReason::from(Error::<E::T>::OutOfGas))
+					 .map_err(#into_host)?;
+			}
+		} 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
+				}))?;
+			}
+		}
+	});
+	quote! {
+		let __allow_unstable__ = matches!(allow_unstable, AllowUnstableInterface::Yes);
+		let __allow_deprecated__ = matches!(allow_deprecated, AllowDeprecatedInterface::Yes);
+		#( #impls )*
+	}
+}
+
+/// Defines a host functions set that can be imported by contract wasm code.
+///
+/// **NB**: Be advised that all functions defined by this macro
+/// will panic if called with unexpected arguments.
+///
+/// It's up to you as the user of this macro to check signatures of wasm code to be executed
+/// and reject the code if any imported function has a mismatched signature.
+///
+/// ## Example
+///
+/// ```nocompile
+/// #[define_env]
+/// pub mod some_env {
+/// 	fn foo(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<(), TrapReason> {
+/// 		ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
+/// 	}
+/// }
+/// ```
+/// This example will expand to the `foo()` defined in the wasm module named `seal0`. This is
+/// because the module `seal0` is the default when no module is specified.
+///
+/// To define a host function in `seal2` and `seal3` modules, it should be annotated with the
+/// appropriate attribute as follows:
+///
+/// ## Example
+///
+/// ```nocompile
+/// #[define_env]
+/// pub mod some_env {
+/// 	#[version(2)]
+/// 	fn foo(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<ReturnCode, TrapReason> {
+/// 		ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
+/// 	}
+///
+/// 	#[version(3)]
+/// 	#[unstable]
+/// 	fn bar(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<u32, TrapReason> {
+/// 		ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
+/// 	}
+/// }
+/// ```
+/// The function `bar` is additionally annotated with `unstable` which removes it from the stable
+/// interface. Check out the README to learn about unstable functions.
+///
+/// In legacy versions of pallet_contracts, it was a naming convention that all host functions had
+/// to be named with the `seal_` prefix. For the sake of backwards compatibility, each host function
+/// now can get a such prefix-named alias function generated by marking it by the
+/// `#[prefixed_alias]` attribute:
+///
+/// ## Example
+///
+/// ```nocompile
+/// #[define_env]
+/// pub mod some_env {
+/// 	#[version(1)]
+/// 	#[prefixed_alias]
+/// 	fn foo(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<ReturnCode, TrapReason> {
+/// 		ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
+/// 	}
+///
+/// 	#[version(42)]
+/// 	fn bar(ctx: _, memory: _, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<u32, TrapReason> {
+/// 		ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
+/// 	}
+/// }
+/// ```
+///
+/// In this example, the following host functions will be generated by the macro:
+/// - `foo()` in module `seal1`,
+/// - `seal_foo()` in module `seal1`,
+/// - `bar()` in module `seal42`.
+///
+/// Only following return types are allowed for the host functions defined with the macro:
+/// - `Result<(), TrapReason>`,
+/// - `Result<ReturnCode, TrapReason>`,
+/// - `Result<u32, TrapReason>`.
+///
+/// The macro expands to `pub struct Env` declaration, with the following traits implementations:
+/// - `pallet_contracts::wasm::Environment<Runtime<E>> where E: Ext`
+/// - `pallet_contracts::wasm::Environment<()>`
+///
+/// The implementation on `()` can be used in places where no `Ext` exists, yet. This is useful
+/// when only checking whether a code can be instantiated without actually executing any code.
+///
+/// # Generating Documentation
+///
+/// Passing `doc` attribute to the macro (like `#[define_env(doc)]`) will make it also expand
+/// additional `pallet_contracts::api_doc::seal0`, `pallet_contracts::api_doc::seal1`,
+/// `...` modules each having its `Api` trait containing functions holding documentation for every
+/// host function defined by the macro.
+///
+/// # Deprecated Interfaces
+///
+/// An interface can be annotated with `#[deprecated]`. It is mutually exclusive with `#[unstable]`.
+/// Deprecated interfaces have the following properties:
+/// 	- New contract codes utilizing those interfaces cannot be uploaded.
+/// 	- New contracts from existing codes utilizing those interfaces cannot be instantiated.
+/// - Existing contracts containing those interfaces still work.
+///
+/// Those interfaces will eventually be removed.
+///
+/// To build up these docs, run:
+///
+/// ```nocompile
+/// cargo doc
+/// ```
+#[proc_macro_attribute]
+pub fn define_env(attr: TokenStream, item: TokenStream) -> TokenStream {
+	if !attr.is_empty() && !(attr.to_string() == "doc".to_string()) {
+		let msg = r#"Invalid `define_env` attribute macro: expected either no attributes or a single `doc` attribute:
+					 - `#[define_env]`
+					 - `#[define_env(doc)]`"#;
+		let span = TokenStream2::from(attr).span();
+		return syn::Error::new(span, msg).to_compile_error().into()
+	}
+
+	let item = syn::parse_macro_input!(item as syn::ItemMod);
+
+	match EnvDef::try_from(item) {
+		Ok(mut def) => expand_env(&mut def, !attr.is_empty()).into(),
+		Err(e) => e.to_compile_error().into(),
+	}
+}
diff --git a/substrate/frame/contracts/src/address.rs b/substrate/frame/contracts/src/address.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5758daf7b1ff8117d1de5e48e8c1e40490ed7a69
--- /dev/null
+++ b/substrate/frame/contracts/src/address.rs
@@ -0,0 +1,68 @@
+// 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.
+
+//! Functions that deal with address derivation.
+
+use crate::{CodeHash, Config};
+use codec::{Decode, Encode};
+use sp_runtime::traits::{Hash, TrailingZeroInput};
+
+/// Provides the contract address generation method.
+///
+/// See [`DefaultAddressGenerator`] for the default implementation.
+///
+/// # Note for implementors
+///
+/// 1. Make sure that there are no collisions, different inputs never lead to the same output.
+/// 2. Make sure that the same inputs lead to the same output.
+pub trait AddressGenerator<T: Config> {
+	/// The address of a contract based on the given instantiate parameters.
+	///
+	/// Changing the formular for an already deployed chain is fine as long as no collisions
+	/// with the old formular. Changes only affect existing contracts.
+	fn contract_address(
+		deploying_address: &T::AccountId,
+		code_hash: &CodeHash<T>,
+		input_data: &[u8],
+		salt: &[u8],
+	) -> T::AccountId;
+}
+
+/// Default address generator.
+///
+/// This is the default address generator used by contract instantiation. Its result
+/// is only dependent on its inputs. It can therefore be used to reliably predict the
+/// address of a contract. This is akin to the formula of eth's CREATE2 opcode. There
+/// is no CREATE equivalent because CREATE2 is strictly more powerful.
+/// Formula:
+/// `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)`
+pub struct DefaultAddressGenerator;
+
+impl<T: Config> AddressGenerator<T> for DefaultAddressGenerator {
+	/// Formula: `hash("contract_addr_v1" ++ deploying_address ++ code_hash ++ input_data ++ salt)`
+	fn contract_address(
+		deploying_address: &T::AccountId,
+		code_hash: &CodeHash<T>,
+		input_data: &[u8],
+		salt: &[u8],
+	) -> T::AccountId {
+		let entropy = (b"contract_addr_v1", deploying_address, code_hash, input_data, salt)
+			.using_encoded(T::Hashing::hash);
+		Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+			.expect("infinite length input; no invalid inputs for type; qed")
+	}
+}
diff --git a/substrate/frame/contracts/src/benchmarking/code.rs b/substrate/frame/contracts/src/benchmarking/code.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f50611b41c21a95ebc29f4c9a2cc497a1bb084f
--- /dev/null
+++ b/substrate/frame/contracts/src/benchmarking/code.rs
@@ -0,0 +1,426 @@
+// 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.
+
+//! Functions to procedurally construct contract code used for benchmarking.
+//!
+//! In order to be able to benchmark events that are triggered by contract execution
+//! (API calls into seal, individual instructions), we need to generate contracts that
+//! perform those events. Because those contracts can get very big we cannot simply define
+//! them as text (.wat) as this will be too slow and consume too much memory. Therefore
+//! we define this simple definition of a contract that can be passed to `create_code` that
+//! compiles it down into a `WasmModule` that can be used as a contract's code.
+
+use crate::Config;
+use frame_support::traits::Get;
+use sp_runtime::traits::Hash;
+use sp_std::{borrow::ToOwned, prelude::*};
+use wasm_instrument::parity_wasm::{
+	builder,
+	elements::{
+		self, BlockType, CustomSection, External, FuncBody, Instruction, Instructions, Module,
+		Section, ValueType,
+	},
+};
+
+/// The location where to put the generated code.
+pub enum Location {
+	/// Generate all code into the `call` exported function.
+	Call,
+	/// Generate all code into the `deploy` exported function.
+	Deploy,
+}
+
+/// Pass to `create_code` in order to create a compiled `WasmModule`.
+///
+/// This exists to have a more declarative way to describe a wasm module than to use
+/// parity-wasm directly. It is tailored to fit the structure of contracts that are
+/// needed for benchmarking.
+#[derive(Default)]
+pub struct ModuleDefinition {
+	/// Imported memory attached to the module. No memory is imported if `None`.
+	pub memory: Option<ImportedMemory>,
+	/// Initializers for the imported memory.
+	pub data_segments: Vec<DataSegment>,
+	/// Creates the supplied amount of i64 mutable globals initialized with random values.
+	pub num_globals: u32,
+	/// List of functions that the module should import. They start with index 0.
+	pub imported_functions: Vec<ImportedFunction>,
+	/// Function body of the exported `deploy` function. Body is empty if `None`.
+	/// Its index is `imported_functions.len()`.
+	pub deploy_body: Option<FuncBody>,
+	/// Function body of the exported `call` function. Body is empty if `None`.
+	/// Its index is `imported_functions.len() + 1`.
+	pub call_body: Option<FuncBody>,
+	/// Function body of a non-exported function with index `imported_functions.len() + 2`.
+	pub aux_body: Option<FuncBody>,
+	/// The amount of I64 arguments the aux function should have.
+	pub aux_arg_num: u32,
+	/// Create a table containing function pointers.
+	pub table: Option<TableSegment>,
+	/// Create a section named "dummy" of the specified size. This is useful in order to
+	/// benchmark the overhead of loading and storing codes of specified sizes. The dummy
+	/// section only contributes to the size of the contract but does not affect execution.
+	pub dummy_section: u32,
+}
+
+pub struct TableSegment {
+	/// How many elements should be created inside the table.
+	pub num_elements: u32,
+	/// The function index with which all table elements should be initialized.
+	pub function_index: u32,
+}
+
+pub struct DataSegment {
+	pub offset: u32,
+	pub value: Vec<u8>,
+}
+
+#[derive(Clone)]
+pub struct ImportedMemory {
+	pub min_pages: u32,
+	pub max_pages: u32,
+}
+
+impl ImportedMemory {
+	pub fn max<T: Config>() -> Self {
+		let pages = max_pages::<T>();
+		Self { min_pages: pages, max_pages: pages }
+	}
+}
+
+pub struct ImportedFunction {
+	pub module: &'static str,
+	pub name: &'static str,
+	pub params: Vec<ValueType>,
+	pub return_type: Option<ValueType>,
+}
+
+/// A wasm module ready to be put on chain.
+#[derive(Clone)]
+pub struct WasmModule<T: Config> {
+	pub code: Vec<u8>,
+	pub hash: <T::Hashing as Hash>::Output,
+	pub memory: Option<ImportedMemory>,
+}
+
+impl<T: Config> From<ModuleDefinition> for WasmModule<T> {
+	fn from(def: ModuleDefinition) -> Self {
+		// internal functions start at that offset.
+		let func_offset = u32::try_from(def.imported_functions.len()).unwrap();
+
+		// Every contract must export "deploy" and "call" functions.
+		let mut contract = builder::module()
+			// deploy function (first internal function)
+			.function()
+			.signature()
+			.build()
+			.with_body(
+				def.deploy_body
+					.unwrap_or_else(|| FuncBody::new(Vec::new(), Instructions::empty())),
+			)
+			.build()
+			// call function (second internal function)
+			.function()
+			.signature()
+			.build()
+			.with_body(
+				def.call_body
+					.unwrap_or_else(|| FuncBody::new(Vec::new(), Instructions::empty())),
+			)
+			.build()
+			.export()
+			.field("deploy")
+			.internal()
+			.func(func_offset)
+			.build()
+			.export()
+			.field("call")
+			.internal()
+			.func(func_offset + 1)
+			.build();
+
+		// If specified we add an additional internal function
+		if let Some(body) = def.aux_body {
+			let mut signature = contract.function().signature();
+			for _ in 0..def.aux_arg_num {
+				signature = signature.with_param(ValueType::I64);
+			}
+			contract = signature.build().with_body(body).build();
+		}
+
+		// Grant access to linear memory.
+		// Every contract module is required to have an imported memory.
+		// If no memory is specified in the passed ModuleDefenition, then
+		// default to (1, 1).
+		let (init, max) = if let Some(memory) = &def.memory {
+			(memory.min_pages, Some(memory.max_pages))
+		} else {
+			(1, Some(1))
+		};
+
+		contract = contract.import().path("env", "memory").external().memory(init, max).build();
+
+		// Import supervisor functions. They start with idx 0.
+		for func in def.imported_functions {
+			let sig = builder::signature()
+				.with_params(func.params)
+				.with_results(func.return_type)
+				.build_sig();
+			let sig = contract.push_signature(sig);
+			contract = contract
+				.import()
+				.module(func.module)
+				.field(func.name)
+				.with_external(elements::External::Function(sig))
+				.build();
+		}
+
+		// Initialize memory
+		for data in def.data_segments {
+			contract = contract
+				.data()
+				.offset(Instruction::I32Const(data.offset as i32))
+				.value(data.value)
+				.build()
+		}
+
+		// Add global variables
+		if def.num_globals > 0 {
+			use rand::{distributions::Standard, prelude::*};
+			let rng = rand_pcg::Pcg32::seed_from_u64(3112244599778833558);
+			for val in rng.sample_iter(Standard).take(def.num_globals as usize) {
+				contract = contract
+					.global()
+					.value_type()
+					.i64()
+					.mutable()
+					.init_expr(Instruction::I64Const(val))
+					.build()
+			}
+		}
+
+		// Add function pointer table
+		if let Some(table) = def.table {
+			contract = contract
+				.table()
+				.with_min(table.num_elements)
+				.with_max(Some(table.num_elements))
+				.with_element(0, vec![table.function_index; table.num_elements as usize])
+				.build();
+		}
+
+		// Add the dummy section
+		if def.dummy_section > 0 {
+			contract = contract.with_section(Section::Custom(CustomSection::new(
+				"dummy".to_owned(),
+				vec![42; def.dummy_section as usize],
+			)));
+		}
+
+		let code = contract.build().into_bytes().unwrap();
+		let hash = T::Hashing::hash(&code);
+		Self { code: code.into(), hash, memory: def.memory }
+	}
+}
+
+impl<T: Config> WasmModule<T> {
+	/// Uses the supplied wasm module.
+	pub fn from_code(code: &[u8]) -> Self {
+		let module = Module::from_bytes(code).unwrap();
+		let limits = *module
+			.import_section()
+			.unwrap()
+			.entries()
+			.iter()
+			.find_map(|e| if let External::Memory(mem) = e.external() { Some(mem) } else { None })
+			.unwrap()
+			.limits();
+		let code = module.into_bytes().unwrap();
+		let hash = T::Hashing::hash(&code);
+		let memory =
+			ImportedMemory { min_pages: limits.initial(), max_pages: limits.maximum().unwrap() };
+		Self { code: code.into(), hash, memory: Some(memory) }
+	}
+
+	/// Creates a wasm module with an empty `call` and `deploy` function and nothing else.
+	pub fn dummy() -> Self {
+		ModuleDefinition::default().into()
+	}
+
+	/// Same as `dummy` but with maximum sized linear memory and a dummy section of specified size.
+	pub fn dummy_with_bytes(dummy_bytes: u32) -> Self {
+		// We want the module to have the size `dummy_bytes`.
+		// This is not completely correct as the overhead grows when the contract grows
+		// because of variable length integer encoding. However, it is good enough to be that
+		// close for benchmarking purposes.
+		let module_overhead = 65;
+		ModuleDefinition {
+			memory: Some(ImportedMemory::max::<T>()),
+			dummy_section: dummy_bytes.saturating_sub(module_overhead),
+			..Default::default()
+		}
+		.into()
+	}
+
+	/// Creates a wasm module of `target_bytes` size. Used to benchmark the performance of
+	/// `instantiate_with_code` for different sizes of wasm modules. The generated module maximizes
+	/// instrumentation runtime by nesting blocks as deeply as possible given the byte budget.
+	/// `code_location`: Whether to place the code into `deploy` or `call`.
+	pub fn sized(target_bytes: u32, code_location: Location) -> Self {
+		use self::elements::Instruction::{End, I32Const, If, Return};
+		// Base size of a contract is 63 bytes and each expansion adds 6 bytes.
+		// We do one expansion less to account for the code section and function body
+		// size fields inside the binary wasm module representation which are leb128 encoded
+		// and therefore grow in size when the contract grows. We are not allowed to overshoot
+		// because of the maximum code size that is enforced by `instantiate_with_code`.
+		let expansions = (target_bytes.saturating_sub(63) / 6).saturating_sub(1);
+		const EXPANSION: [Instruction; 4] = [I32Const(0), If(BlockType::NoResult), Return, End];
+		let mut module =
+			ModuleDefinition { memory: Some(ImportedMemory::max::<T>()), ..Default::default() };
+		let body = Some(body::repeated(expansions, &EXPANSION));
+		match code_location {
+			Location::Call => module.call_body = body,
+			Location::Deploy => module.deploy_body = body,
+		}
+		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 {
+		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],
+				return_type: None,
+			}],
+			// Write the output buffer size. The output size will be overwritten by the
+			// supervisor with the real size when calling the getter. Since this size does not
+			// change between calls it suffices to start with an initial value and then just
+			// leave as whatever value was written there.
+			data_segments: vec![DataSegment {
+				offset: 0,
+				value: (pages * 64 * 1024 - 4).to_le_bytes().to_vec(),
+			}],
+			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),
+				],
+			)),
+			..Default::default()
+		}
+		.into()
+	}
+}
+
+/// Mechanisms to generate a function body that can be used inside a `ModuleDefinition`.
+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),
+		/// Insert the specified amount of I64Const with a random value.
+		RandomI64Repeated(usize),
+	}
+
+	pub fn plain(instructions: Vec<Instruction>) -> FuncBody {
+		FuncBody::new(Vec::new(), Instructions::new(instructions))
+	}
+
+	pub fn repeated(repetitions: u32, instructions: &[Instruction]) -> FuncBody {
+		let instructions = Instructions::new(
+			instructions
+				.iter()
+				.cycle()
+				.take(instructions.len() * usize::try_from(repetitions).unwrap())
+				.cloned()
+				.chain(sp_std::iter::once(Instruction::End))
+				.collect(),
+		);
+		FuncBody::new(Vec::new(), instructions)
+	}
+
+	pub fn repeated_dyn(repetitions: u32, mut instructions: Vec<DynInstr>) -> FuncBody {
+		use rand::{distributions::Standard, prelude::*};
+
+		// We do not need to be secure here.
+		let mut rng = rand_pcg::Pcg32::seed_from_u64(8446744073709551615);
+
+		// 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)]
+				},
+				DynInstr::RandomI64Repeated(num) =>
+					(&mut rng).sample_iter(Standard).take(*num).map(Instruction::I64Const).collect(),
+			})
+			.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`.
+pub fn max_pages<T: Config>() -> u32 {
+	T::Schedule::get().limits.memory_pages
+}
diff --git a/substrate/frame/contracts/src/benchmarking/mod.rs b/substrate/frame/contracts/src/benchmarking/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ac5787e23404192be6699fea9c19117da764c749
--- /dev/null
+++ b/substrate/frame/contracts/src/benchmarking/mod.rs
@@ -0,0 +1,2712 @@
+// 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.
+
+//! Benchmarks for the contracts pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+mod code;
+mod sandbox;
+use self::{
+	code::{
+		body::{self, DynInstr::*},
+		DataSegment, ImportedFunction, ImportedMemory, Location, ModuleDefinition, WasmModule,
+	},
+	sandbox::Sandbox,
+};
+use crate::{
+	exec::{AccountIdOf, Key},
+	migration::{
+		codegen::LATEST_MIGRATION_VERSION, v09, v10, v11, v12, v13, v14, v15, MigrationStep,
+	},
+	wasm::CallFlags,
+	Pallet as Contracts, *,
+};
+use codec::{Encode, MaxEncodedLen};
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller};
+use frame_support::{
+	self,
+	pallet_prelude::StorageVersion,
+	traits::{fungible::InspectHold, Currency},
+	weights::Weight,
+};
+use frame_system::RawOrigin;
+use pallet_balances;
+use sp_runtime::traits::{Bounded, Hash};
+use sp_std::prelude::*;
+use wasm_instrument::parity_wasm::elements::{BlockType, Instruction, ValueType};
+
+/// How many runs we do per API benchmark.
+///
+/// This is picked more or less arbitrary. We experimented with different numbers until
+/// the results appeared to be stable. Reducing the number would speed up the benchmarks
+/// but might make the results less precise.
+const API_BENCHMARK_RUNS: u32 = 1600;
+
+/// How many runs we do per instruction benchmark.
+///
+/// Same rationale as for [`API_BENCHMARK_RUNS`]. The number is bigger because instruction
+/// benchmarks are faster.
+const INSTR_BENCHMARK_RUNS: u32 = 5000;
+
+/// An instantiated and deployed contract.
+struct Contract<T: Config> {
+	caller: T::AccountId,
+	account_id: T::AccountId,
+	addr: AccountIdLookupOf<T>,
+	value: BalanceOf<T>,
+}
+
+impl<T> Contract<T>
+where
+	T: Config + pallet_balances::Config,
+	<BalanceOf<T> as HasCompact>::Type: Clone + Eq + PartialEq + Debug + TypeInfo + Encode,
+{
+	/// Create new contract and use a default account id as instantiator.
+	fn new(module: WasmModule<T>, data: Vec<u8>) -> Result<Contract<T>, &'static str> {
+		Self::with_index(0, module, data)
+	}
+
+	/// Create new contract and use an account id derived from the supplied index as instantiator.
+	fn with_index(
+		index: u32,
+		module: WasmModule<T>,
+		data: Vec<u8>,
+	) -> Result<Contract<T>, &'static str> {
+		Self::with_caller(account("instantiator", index, 0), module, data)
+	}
+
+	/// Create new contract and use the supplied `caller` as instantiator.
+	fn with_caller(
+		caller: T::AccountId,
+		module: WasmModule<T>,
+		data: Vec<u8>,
+	) -> Result<Contract<T>, &'static str> {
+		let value = Pallet::<T>::min_balance();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let salt = vec![0xff];
+		let addr = Contracts::<T>::contract_address(&caller, &module.hash, &data, &salt);
+
+		Contracts::<T>::store_code_raw(module.code, caller.clone())?;
+		Contracts::<T>::instantiate(
+			RawOrigin::Signed(caller.clone()).into(),
+			value,
+			Weight::MAX,
+			None,
+			module.hash,
+			data,
+			salt,
+		)?;
+
+		let result =
+			Contract { caller, account_id: addr.clone(), addr: T::Lookup::unlookup(addr), value };
+
+		ContractInfoOf::<T>::insert(&result.account_id, result.info()?);
+
+		Ok(result)
+	}
+
+	/// Create a new contract with the supplied storage item count and size each.
+	fn with_storage(
+		code: WasmModule<T>,
+		stor_num: u32,
+		stor_size: u32,
+	) -> Result<Self, &'static str> {
+		let contract = Contract::<T>::new(code, vec![])?;
+		let storage_items = (0..stor_num)
+			.map(|i| {
+				let hash = T::Hashing::hash_of(&i)
+					.as_ref()
+					.try_into()
+					.map_err(|_| "Hash too big for storage key")?;
+				Ok((hash, vec![42u8; stor_size as usize]))
+			})
+			.collect::<Result<Vec<_>, &'static str>>()?;
+		contract.store(&storage_items)?;
+		Ok(contract)
+	}
+
+	/// Store the supplied storage items into this contracts storage.
+	fn store(&self, items: &Vec<([u8; 32], Vec<u8>)>) -> Result<(), &'static str> {
+		let info = self.info()?;
+		for item in items {
+			info.write(&Key::Fix(item.0), Some(item.1.clone()), None, false)
+				.map_err(|_| "Failed to write storage to restoration dest")?;
+		}
+		<ContractInfoOf<T>>::insert(&self.account_id, info);
+		Ok(())
+	}
+
+	/// Get the `ContractInfo` of the `addr` or an error if it no longer exists.
+	fn address_info(addr: &T::AccountId) -> Result<ContractInfo<T>, &'static str> {
+		ContractInfoOf::<T>::get(addr).ok_or("Expected contract to exist at this point.")
+	}
+
+	/// Get the `ContractInfo` of this contract or an error if it no longer exists.
+	fn info(&self) -> Result<ContractInfo<T>, &'static str> {
+		Self::address_info(&self.account_id)
+	}
+
+	/// Set the balance of the contract to the supplied amount.
+	fn set_balance(&self, balance: BalanceOf<T>) {
+		T::Currency::set_balance(&self.account_id, balance);
+	}
+
+	/// Returns `true` iff all storage entries related to code storage exist.
+	fn code_exists(hash: &CodeHash<T>) -> bool {
+		<PristineCode<T>>::contains_key(hash) && <CodeInfoOf<T>>::contains_key(&hash)
+	}
+
+	/// Returns `true` iff no storage entry related to code storage exist.
+	fn code_removed(hash: &CodeHash<T>) -> bool {
+		!<PristineCode<T>>::contains_key(hash) && !<CodeInfoOf<T>>::contains_key(&hash)
+	}
+}
+
+/// The funding that each account that either calls or instantiates contracts is funded with.
+fn caller_funding<T: Config>() -> BalanceOf<T> {
+	// Minting can overflow, so we can't abuse of the funding. This value happens to be big enough,
+	// but not too big to make the total supply overflow.
+	BalanceOf::<T>::max_value() / 10_000u32.into()
+}
+
+/// Load the specified contract file from disk by including it into the runtime.
+///
+/// We need to load a different version of ink! contracts when the benchmark is run as
+/// a test. This is because ink! contracts depend on the sizes of types that are defined
+/// differently in the test environment. Solang is more lax in that regard.
+macro_rules! load_benchmark {
+	($name:expr) => {{
+		#[cfg(not(test))]
+		{
+			include_bytes!(concat!("../../benchmarks/", $name, ".wasm"))
+		}
+		#[cfg(test)]
+		{
+			include_bytes!(concat!("../../benchmarks/", $name, "_test.wasm"))
+		}
+	}};
+}
+
+benchmarks! {
+	where_clause { where
+		<BalanceOf<T> as codec::HasCompact>::Type: Clone + Eq + PartialEq + sp_std::fmt::Debug + scale_info::TypeInfo + codec::Encode,
+		T: Config + pallet_balances::Config,
+		BalanceOf<T>: From<<pallet_balances::Pallet<T> as Currency<T::AccountId>>::Balance>,
+		<pallet_balances::Pallet<T> as Currency<T::AccountId>>::Balance: From<BalanceOf<T>>,
+	}
+
+	// The base weight consumed on processing contracts deletion queue.
+	#[pov_mode = Measured]
+	on_process_deletion_queue_batch {}: {
+		ContractInfo::<T>::process_deletion_queue_batch(Weight::MAX)
+	}
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	on_initialize_per_trie_key {
+		let k in 0..1024;
+		let instance = Contract::<T>::with_storage(WasmModule::dummy(), k, T::Schedule::get().limits.payload_len)?;
+		instance.info()?.queue_trie_for_deletion();
+	}: {
+		ContractInfo::<T>::process_deletion_queue_batch(Weight::MAX)
+	}
+
+	// This benchmarks the v9 migration step (update codeStorage).
+	#[pov_mode = Measured]
+	v9_migration_step {
+		let c in 0 .. T::MaxCodeLen::get();
+		v09::store_old_dummy_code::<T>(c as usize);
+		let mut m = v09::Migration::<T>::default();
+	}: {
+		m.step();
+	}
+
+	// This benchmarks the v10 migration step (use dedicated deposit_account).
+	#[pov_mode = Measured]
+	v10_migration_step {
+		let contract = <Contract<T>>::with_caller(
+			whitelisted_caller(), WasmModule::dummy(), vec![],
+		)?;
+
+		v10::store_old_contract_info::<T, pallet_balances::Pallet<T>>(contract.account_id.clone(), contract.info()?);
+		let mut m = v10::Migration::<T, pallet_balances::Pallet<T>>::default();
+	}: {
+		m.step();
+	}
+
+	// This benchmarks the v11 migration step (Don't rely on reserved balances keeping an account alive).
+	#[pov_mode = Measured]
+	v11_migration_step {
+		let k in 0 .. 1024;
+		v11::fill_old_queue::<T>(k as usize);
+		let mut m = v11::Migration::<T>::default();
+	}: {
+		m.step();
+	}
+
+	// This benchmarks the v12 migration step (Move `OwnerInfo` to `CodeInfo`,
+	// add `determinism` field to the latter, clear `CodeStorage`
+	// and repay deposits).
+	#[pov_mode = Measured]
+	v12_migration_step {
+		let c in 0 .. T::MaxCodeLen::get();
+		v12::store_old_dummy_code::<
+			T,
+			pallet_balances::Pallet<T>
+		>(c as usize, account::<T::AccountId>("account", 0, 0));
+		let mut m = v12::Migration::<T, pallet_balances::Pallet<T>>::default();
+	}: {
+		m.step();
+	}
+
+	// This benchmarks the v13 migration step (Add delegate_dependencies field).
+	#[pov_mode = Measured]
+	v13_migration_step {
+		let contract = <Contract<T>>::with_caller(
+			whitelisted_caller(), WasmModule::dummy(), vec![],
+		)?;
+
+		v13::store_old_contract_info::<T>(contract.account_id.clone(), contract.info()?);
+		let mut m = v13::Migration::<T>::default();
+	}: {
+		m.step();
+	}
+
+	// This benchmarks the v14 migration step (Move code owners' reserved balance to be held instead).
+	#[pov_mode = Measured]
+	v14_migration_step {
+		let account = account::<T::AccountId>("account", 0, 0);
+		T::Currency::set_balance(&account, caller_funding::<T>());
+		v14::store_dummy_code::<T, pallet_balances::Pallet<T>>(account);
+		let mut m = v14::Migration::<T, pallet_balances::Pallet<T>>::default();
+	}: {
+		m.step();
+	}
+
+	// This benchmarks the v15 migration step (remove deposit account).
+	#[pov_mode = Measured]
+	v15_migration_step {
+		let contract = <Contract<T>>::with_caller(
+			whitelisted_caller(), WasmModule::dummy(), vec![],
+		)?;
+
+		v15::store_old_contract_info::<T>(contract.account_id.clone(), contract.info()?);
+		let mut m = v15::Migration::<T>::default();
+	}: {
+		m.step();
+	}
+
+	// This benchmarks the weight of executing Migration::migrate to execute a noop migration.
+	#[pov_mode = Measured]
+	migration_noop {
+		let version = LATEST_MIGRATION_VERSION;
+		assert_eq!(StorageVersion::get::<Pallet<T>>(), version);
+	}:  {
+		Migration::<T>::migrate(Weight::MAX)
+	} verify {
+		assert_eq!(StorageVersion::get::<Pallet<T>>(), version);
+	}
+
+	// This benchmarks the weight of dispatching migrate to execute 1 `NoopMigraton`
+	#[pov_mode = Measured]
+	migrate {
+		let latest_version = LATEST_MIGRATION_VERSION;
+		StorageVersion::new(latest_version - 2).put::<Pallet<T>>();
+		<Migration::<T, false> as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade();
+		let caller: T::AccountId = whitelisted_caller();
+		let origin = RawOrigin::Signed(caller.clone());
+	}: _(origin, Weight::MAX)
+	verify {
+		assert_eq!(StorageVersion::get::<Pallet<T>>(), latest_version - 1);
+	}
+
+	// This benchmarks the weight of running on_runtime_upgrade when there are no migration in progress.
+	#[pov_mode = Measured]
+	on_runtime_upgrade_noop {
+		let latest_version = LATEST_MIGRATION_VERSION;
+		assert_eq!(StorageVersion::get::<Pallet<T>>(), latest_version);
+	}:  {
+		<Migration::<T, false> as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade()
+	} verify {
+		assert!(MigrationInProgress::<T>::get().is_none());
+	}
+
+	// This benchmarks the weight of running on_runtime_upgrade when there is a migration in progress.
+	#[pov_mode = Measured]
+	on_runtime_upgrade_in_progress {
+		let latest_version = LATEST_MIGRATION_VERSION;
+		StorageVersion::new(latest_version - 2).put::<Pallet<T>>();
+		let v = vec![42u8].try_into().ok();
+		MigrationInProgress::<T>::set(v.clone());
+	}:  {
+		<Migration::<T, false> as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade()
+	} verify {
+		assert!(MigrationInProgress::<T>::get().is_some());
+		assert_eq!(MigrationInProgress::<T>::get(), v);
+	}
+
+	// This benchmarks the weight of running on_runtime_upgrade when there is a migration to process.
+	#[pov_mode = Measured]
+	on_runtime_upgrade {
+		let latest_version = LATEST_MIGRATION_VERSION;
+		StorageVersion::new(latest_version - 2).put::<Pallet<T>>();
+	}:  {
+		<Migration::<T, false> as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade()
+	} verify {
+		assert!(MigrationInProgress::<T>::get().is_some());
+	}
+
+	// This benchmarks the overhead of loading a code of size `c` byte from storage and into
+	// the sandbox. This does **not** include the actual execution for which the gas meter
+	// is responsible. This is achieved by generating all code to the `deploy` function
+	// which is in the wasm module but not executed on `call`.
+	// The results are supposed to be used as `call_with_code_per_byte(c) - call_with_code_per_byte(0)`.
+	#[pov_mode = Measured]
+	call_with_code_per_byte {
+		let c in 0 .. T::MaxCodeLen::get();
+		let instance = Contract::<T>::with_caller(
+			whitelisted_caller(), WasmModule::sized(c, Location::Deploy), vec![],
+		)?;
+		let value = Pallet::<T>::min_balance();
+		let origin = RawOrigin::Signed(instance.caller.clone());
+		let callee = instance.addr;
+	}: call(origin, callee, value, Weight::MAX, None, vec![])
+
+	// 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.
+	#[pov_mode = Measured]
+	instantiate_with_code {
+		let c in 0 .. T::MaxCodeLen::get();
+		let i in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let s in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let input = vec![42u8; i as usize];
+		let salt = vec![42u8; s as usize];
+		let value = Pallet::<T>::min_balance();
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let WasmModule { code, hash, .. } = WasmModule::<T>::sized(c, Location::Call);
+		let origin = RawOrigin::Signed(caller.clone());
+		let addr = Contracts::<T>::contract_address(&caller, &hash, &input, &salt);
+	}: _(origin, value, Weight::MAX, None, code, input, salt)
+	verify {
+		let deposit = T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr);
+		// uploading the code reserves some balance in the callers account
+		let code_deposit = T::Currency::balance_on_hold(&HoldReason::CodeUploadDepositReserve.into(), &caller);
+		assert_eq!(
+			T::Currency::balance(&caller),
+			caller_funding::<T>() - value - deposit - code_deposit - Pallet::<T>::min_balance(),
+		);
+		// contract has the full value
+		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.
+	#[pov_mode = Measured]
+	instantiate {
+		let i in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let s in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let input = vec![42u8; i as usize];
+		let salt = vec![42u8; s as usize];
+		let value = Pallet::<T>::min_balance();
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let WasmModule { code, hash, .. } = WasmModule::<T>::dummy();
+		let origin = RawOrigin::Signed(caller.clone());
+		let addr = Contracts::<T>::contract_address(&caller, &hash, &input, &salt);
+		Contracts::<T>::store_code_raw(code, caller.clone())?;
+	}: _(origin, value, Weight::MAX, None, hash, input, salt)
+	verify {
+		let deposit = T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr);
+		// value was removed from the caller
+		assert_eq!(
+			T::Currency::balance(&caller),
+			caller_funding::<T>() - value - deposit - Pallet::<T>::min_balance(),
+		);
+		// contract has the full value
+		assert_eq!(T::Currency::balance(&addr), value + Pallet::<T>::min_balance());
+	}
+
+	// We just call a dummy contract to measure the overhead of the call extrinsic.
+	// The size of the data has no influence on the costs of this extrinsic as long as the contract
+	// won't call `seal_input` in its constructor to copy the data to contract memory.
+	// The dummy contract used here does not do this. The costs for the data copy is billed as
+	// part of `seal_input`. The costs for invoking a contract of a specific size are not part
+	// of this benchmark because we cannot know the size of the contract when issuing a call
+	// transaction. See `call_with_code_per_byte` for this.
+	#[pov_mode = Measured]
+	call {
+		let data = vec![42u8; 1024];
+		let instance = Contract::<T>::with_caller(
+			whitelisted_caller(), WasmModule::dummy(), vec![],
+		)?;
+		let value = Pallet::<T>::min_balance();
+		let origin = RawOrigin::Signed(instance.caller.clone());
+		let callee = instance.addr.clone();
+		let before = T::Currency::balance(&instance.account_id);
+	}: _(origin, callee, value, Weight::MAX, None, data)
+	verify {
+		let deposit = T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &instance.account_id);
+		// value and value transferred via call should be removed from the caller
+		assert_eq!(
+			T::Currency::balance(&instance.caller),
+			caller_funding::<T>() - instance.value - value - deposit - Pallet::<T>::min_balance(),
+		);
+		// contract should have received the value
+		assert_eq!(T::Currency::balance(&instance.account_id), before + value);
+		// contract should still exist
+		instance.info()?;
+	}
+
+	// This constructs a contract that is maximal expensive to instrument.
+	// It creates a maximum number of metering blocks per byte.
+	// `c`: Size of the code in bytes.
+	#[pov_mode = Measured]
+	upload_code {
+		let c in 0 .. T::MaxCodeLen::get();
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let WasmModule { code, hash, .. } = WasmModule::<T>::sized(c, Location::Call);
+		let origin = RawOrigin::Signed(caller.clone());
+	}: _(origin, code, None, Determinism::Enforced)
+	verify {
+		// uploading the code reserves some balance in the callers account
+		assert!(T::Currency::total_balance_on_hold(&caller) > 0u32.into());
+		assert!(<Contract<T>>::code_exists(&hash));
+	}
+
+	// Removing code does not depend on the size of the contract because all the information
+	// needed to verify the removal claim (refcount, owner) is stored in a separate storage
+	// item (`CodeInfoOf`).
+	#[pov_mode = Measured]
+	remove_code {
+		let caller = whitelisted_caller();
+		T::Currency::set_balance(&caller, caller_funding::<T>());
+		let WasmModule { code, hash, .. } = WasmModule::<T>::dummy();
+		let origin = RawOrigin::Signed(caller.clone());
+		let uploaded = <Contracts<T>>::bare_upload_code(caller.clone(), code, None, Determinism::Enforced)?;
+		assert_eq!(uploaded.code_hash, hash);
+		assert_eq!(uploaded.deposit, T::Currency::total_balance_on_hold(&caller));
+		assert!(<Contract<T>>::code_exists(&hash));
+	}: _(origin, hash)
+	verify {
+		// removing the code should have unreserved the deposit
+		assert_eq!(T::Currency::total_balance_on_hold(&caller), 0u32.into());
+		assert!(<Contract<T>>::code_removed(&hash));
+	}
+
+	#[pov_mode = Measured]
+	set_code {
+		let instance = <Contract<T>>::with_caller(
+			whitelisted_caller(), WasmModule::dummy(), vec![],
+		)?;
+		// we just add some bytes so that the code hash is different
+		let WasmModule { code, hash, .. } = <WasmModule<T>>::dummy_with_bytes(128);
+		<Contracts<T>>::store_code_raw(code, instance.caller.clone())?;
+		let callee = instance.addr.clone();
+		assert_ne!(instance.info()?.code_hash, hash);
+	}: _(RawOrigin::Root, callee, hash)
+	verify {
+		assert_eq!(instance.info()?.code_hash, hash);
+	}
+
+	#[pov_mode = Measured]
+	seal_caller {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_caller", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_is_contract {
+		let r in 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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		// every account would be a contract (worst case)
+		for acc in accounts.iter() {
+			<ContractInfoOf<T>>::insert(acc, info.clone());
+		}
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_code_hash {
+		let r in 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 accounts_len = accounts_bytes.len();
+		let pages = code::max_pages::<T>();
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		// every account would be a contract (worst case)
+		for acc in accounts.iter() {
+			<ContractInfoOf<T>>::insert(acc, info.clone());
+		}
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_own_code_hash {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_own_code_hash", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_caller_is_origin {
+		let r in 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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_caller_is_root {
+		let r in 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 instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Root;
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_address {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_address", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_gas_left {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal1", "gas_left", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_balance {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_balance", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_value_transferred {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_value_transferred", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_minimum_balance {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_minimum_balance", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_block_number {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_block_number", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_now {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::getter(
+			"seal0", "seal_now", r
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_weight_to_fee {
+		let r in 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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_input {
+		let r in 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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_input_per_byte {
+		let n in 0 .. code::max_pages::<T>() * 64 * 1024;
+		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());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, data)
+
+	// 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.
+	#[pov_mode = Measured]
+	seal_return {
+		let r in 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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_return_per_byte {
+		let n in 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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// The same argument as for `seal_return` is true here.
+	#[pov_mode = Measured]
+	seal_terminate {
+		let r in 0 .. 1;
+		let beneficiary = account::<T::AccountId>("beneficiary", 0, 0);
+		let beneficiary_bytes = beneficiary.encode();
+		let beneficiary_len = beneficiary_bytes.len();
+		let caller = whitelisted_caller();
+
+		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: "add_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(r, 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()
+		});
+		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());
+	}: call(origin, instance.addr.clone(), 0u32.into(), Weight::MAX, None, vec![])
+	verify {
+		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());
+		}
+	}
+
+	// We benchmark only for the maximum subject length. We assume that this is some lowish
+	// number (< 1 KB). Therefore we are not overcharging too much in case a smaller subject is
+	// used.
+	#[pov_mode = Measured]
+	seal_random {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let pages = code::max_pages::<T>();
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Overhead of calling the function without any topic.
+	// We benchmark for the worst case (largest event).
+	#[pov_mode = Measured]
+	seal_deposit_event {
+		let r in 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 instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Benchmark the overhead that topics generate.
+	// `t`: Number of topics
+	// `n`: Size of event payload in bytes
+	#[pov_mode = Measured]
+	seal_deposit_event_per_topic_and_byte {
+		let t in 0 .. T::Schedule::get().limits.event_topics;
+		let n in 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 instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Benchmark debug_message call with zero input data.
+	// Whereas this function is used in RPC mode only, it still should be secured
+	// against an excessive use.
+	#[pov_mode = Measured]
+	seal_debug_message {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		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 instance = Contract::<T>::new(code, vec![])?;
+	}: {
+		<Contracts<T>>::bare_call(
+			instance.caller,
+			instance.account_id,
+			0u32.into(),
+			Weight::MAX,
+			None,
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result?;
+	}
+
+	seal_debug_message_per_byte {
+		// Vary size of input in bytes up to maximum allowed contract memory
+		// or maximum allowed debug buffer size, whichever is less.
+		let i in 0 .. (T::Schedule::get().limits.memory_pages * 64 * 1024).min(T::MaxDebugBufferLen::get());
+		// 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 instance = Contract::<T>::new(code, vec![])?;
+	}: {
+		<Contracts<T>>::bare_call(
+			instance.caller,
+			instance.account_id,
+			0u32.into(),
+			Weight::MAX,
+			None,
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result?;
+	}
+
+	// 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.
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_set_storage {
+		let r in 0 .. API_BENCHMARK_RUNS/2;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		for key in keys {
+			info.write(
+				&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+				Some(vec![]),
+				None,
+				false,
+			)
+			.map_err(|_| "Failed to write to storage during setup.")?;
+		}
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_set_storage_per_new_byte {
+		let n in 0 .. T::Schedule::get().limits.payload_len;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		info.write(
+			&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+			Some(vec![]),
+			None,
+			false,
+		)
+		.map_err(|_| "Failed to write to storage during setup.")?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_set_storage_per_old_byte {
+		let n in 0 .. T::Schedule::get().limits.payload_len;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		info.write(
+			&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+			Some(vec![42u8; n as usize]),
+			None,
+			false,
+		)
+		.map_err(|_| "Failed to write to storage during setup.")?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// 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.
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_clear_storage {
+		let r in 0 .. API_BENCHMARK_RUNS/2;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		for key in keys {
+			info.write(
+				&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+				Some(vec![]),
+				None,
+				false,
+			)
+			.map_err(|_| "Failed to write to storage during setup.")?;
+		}
+		<ContractInfoOf<T>>::insert(&instance.account_id, info);
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_clear_storage_per_byte {
+		let n in 0 .. T::Schedule::get().limits.payload_len;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		info.write(
+			&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+			Some(vec![42u8; n as usize]),
+			None,
+			false,
+		)
+		.map_err(|_| "Failed to write to storage during setup.")?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// We make sure that all storage accesses are to unique keys.
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_get_storage {
+		let r in 0 .. API_BENCHMARK_RUNS/2;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		for key in keys {
+			info.write(
+				&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+				Some(vec![]),
+				None,
+				false,
+			)
+			.map_err(|_| "Failed to write to storage during setup.")?;
+		}
+		<ContractInfoOf<T>>::insert(&instance.account_id, info);
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_get_storage_per_byte {
+		let n in 0 .. T::Schedule::get().limits.payload_len;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		info.write(
+			&Key::<T>::try_from_var(key).map_err(|e| "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 origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// We make sure that all storage accesses are to unique keys.
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_contains_storage {
+		let r in 0 .. API_BENCHMARK_RUNS/2;
+		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: "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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		for key in keys {
+			info.write(
+				&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+				Some(vec![]),
+				None,
+				false,
+			)
+			.map_err(|_| "Failed to write to storage during setup.")?;
+		}
+		<ContractInfoOf<T>>::insert(&instance.account_id, info);
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_contains_storage_per_byte {
+		let n in 0 .. T::Schedule::get().limits.payload_len;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		info.write(
+			&Key::<T>::try_from_var(key).map_err(|e| "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 origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_take_storage {
+		let r in 0 .. API_BENCHMARK_RUNS/2;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		for key in keys {
+			info.write(
+				&Key::<T>::try_from_var(key).map_err(|e| "Key has wrong length")?,
+				Some(vec![]),
+				None,
+				false,
+			)
+			.map_err(|_| "Failed to write to storage during setup.")?;
+		}
+		<ContractInfoOf<T>>::insert(&instance.account_id, info);
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[skip_meta]
+	#[pov_mode = Measured]
+	seal_take_storage_per_byte {
+		let n in 0 .. T::Schedule::get().limits.payload_len;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let info = instance.info()?;
+		info.write(
+			&Key::<T>::try_from_var(key).map_err(|e| "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 origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// We transfer to unique accounts.
+	#[pov_mode = Measured]
+	seal_transfer {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		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();
+		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 instance = Contract::<T>::new(code, vec![])?;
+		instance.set_balance(value * (r + 1).into());
+		let origin = RawOrigin::Signed(instance.caller.clone());
+		for account in &accounts {
+			assert_eq!(T::Currency::total_balance(account), 0u32.into());
+		}
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+	verify {
+		for account in &accounts {
+			assert_eq!(T::Currency::total_balance(account), value);
+		}
+	}
+
+	// We call unique accounts.
+	//
+	// This is a slow call: We redeuce the number of runs.
+	#[pov_mode = Measured]
+	seal_call {
+		let r in 0 .. API_BENCHMARK_RUNS / 2;
+		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 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.clone();
+		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 instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, Some(BalanceOf::<T>::from(u32::MAX.into()).into()), vec![])
+
+	// This is a slow call: We redeuce the number of runs.
+	#[pov_mode = Measured]
+	seal_delegate_call {
+		let r in 0 .. API_BENCHMARK_RUNS / 2;
+		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_len = hashes_bytes.len();
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let callee = instance.addr.clone();
+		let origin = RawOrigin::Signed(instance.caller);
+	}: call(origin, callee, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_call_per_transfer_clone_byte {
+		let t in 0 .. 1;
+		let c in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let callee = Contract::with_index(5, <WasmModule<T>>::dummy(), vec![])?;
+		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 instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+		let bytes = vec![42; c as usize];
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, bytes)
+
+	// We assume that every instantiate sends at least the minimum balance.
+	// This is a slow call: we reduce the number of runs.
+	#[pov_mode = Measured]
+	seal_instantiate {
+		let r in 1 .. API_BENCHMARK_RUNS / 2;
+		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 instance = Contract::<T>::new(code, vec![])?;
+		instance.set_balance((value + Pallet::<T>::min_balance()) * (r + 1).into());
+		let origin = RawOrigin::Signed(instance.caller.clone());
+		let callee = instance.addr.clone();
+		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());
+			}
+		}
+	}: call(origin, callee, 0u32.into(), Weight::MAX, None, vec![])
+	verify {
+		for addr in &addresses {
+			ContractInfoOf::<T>::get(&addr)
+				.ok_or("Contract should have been instantiated")?;
+		}
+	}
+
+	#[pov_mode = Measured]
+	seal_instantiate_per_transfer_input_salt_byte {
+		let t in 0 .. 1;
+		let i in 0 .. (code::max_pages::<T>() - 1) * 64 * 1024;
+		let s in 0 .. (code::max_pages::<T>() - 1) * 64 * 1024;
+		let callee_code = WasmModule::<T>::dummy();
+		let hash = callee_code.hash;
+		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 value_bytes = value.encode();
+
+		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 instance = Contract::<T>::new(code, vec![])?;
+		instance.set_balance(value + (Pallet::<T>::min_balance() * 2u32.into()));
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Only the overhead of calling the function itself with minimal arguments.
+	#[pov_mode = Measured]
+	seal_hash_sha2_256 {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_sha2_256", r, 0,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// `n`: Input to hash in bytes
+	#[pov_mode = Measured]
+	seal_hash_sha2_256_per_byte {
+		let n in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_sha2_256", 1, n,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Only the overhead of calling the function itself with minimal arguments.
+	#[pov_mode = Measured]
+	seal_hash_keccak_256 {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_keccak_256", r, 0,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// `n`: Input to hash in bytes
+	#[pov_mode = Measured]
+	seal_hash_keccak_256_per_byte {
+		let n in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_keccak_256", 1, n,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Only the overhead of calling the function itself with minimal arguments.
+	#[pov_mode = Measured]
+	seal_hash_blake2_256 {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_blake2_256", r, 0,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// `n`: Input to hash in bytes
+	#[pov_mode = Measured]
+	seal_hash_blake2_256_per_byte {
+		let n in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_blake2_256", 1, n,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Only the overhead of calling the function itself with minimal arguments.
+	#[pov_mode = Measured]
+	seal_hash_blake2_128 {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_blake2_128", r, 0,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// `n`: Input to hash in bytes
+	#[pov_mode = Measured]
+	seal_hash_blake2_128_per_byte {
+		let n in 0 .. code::max_pages::<T>() * 64 * 1024;
+		let instance = Contract::<T>::new(WasmModule::hasher(
+			"seal_hash_blake2_128", 1, n,
+		), vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// `n`: Message input length to verify in bytes.
+	#[pov_mode = Measured]
+	seal_sr25519_verify_per_byte {
+		let n in 0 .. T::MaxCodeLen::get() - 255; // need some buffer so the code size does not
+												  // exceed the max code size.
+
+		let message = (0..n).zip((32u8..127u8).cycle()).map(|(_, c)| c).collect::<Vec<_>>();
+		let message_len = message.len() as i32;
+
+		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 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()
+		});
+
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// 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.
+	#[pov_mode = Measured]
+	seal_sr25519_verify {
+		let r in 0 .. API_BENCHMARK_RUNS / 10;
+
+		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)
+			.map(|i| {
+				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
+			})
+			.flatten()
+			.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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// 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.
+	#[pov_mode = Measured]
+	seal_ecdsa_recover {
+		let r in 0 .. API_BENCHMARK_RUNS / 10;
+
+		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(|i| {
+				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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// Only calling the function itself for the list of
+	// generated different ECDSA keys.
+	// This is a slow call: We redeuce the number of runs.
+	#[pov_mode = Measured]
+	seal_ecdsa_to_eth_address {
+		let r in 0 .. API_BENCHMARK_RUNS / 10;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_set_code_hash {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		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_hashes_len = code_hashes_bytes.len();
+
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	add_delegate_dependency {
+		let r in 0 .. T::MaxDelegateDependencies::get();
+		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: "add_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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	remove_delegate_dependency {
+		let r in 0 .. T::MaxDelegateDependencies::get();
+		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: "remove_delegate_dependency",
+				params: vec![ValueType::I32],
+				return_type: None,
+			}, ImportedFunction {
+				module: "seal0",
+				name: "add_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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_reentrance_count {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		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());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_account_reentrance_count {
+		let r in 0 .. API_BENCHMARK_RUNS;
+		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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	#[pov_mode = Measured]
+	seal_instantiation_nonce {
+		let r in 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()
+		});
+		let instance = Contract::<T>::new(code, vec![])?;
+		let origin = RawOrigin::Signed(instance.caller.clone());
+	}: call(origin, instance.addr, 0u32.into(), Weight::MAX, None, vec![])
+
+	// We make the assumption that pushing a constant and dropping a value takes roughly
+	// the same amount of time. We call this weight `w_base`.
+	// The weight that would result from the respective benchmark we call: `w_bench`.
+	//
+	// w_base = w_i{32,64}const = w_drop = w_bench / 2
+	#[pov_mode = Ignored]
+	instr_i64const {
+		let r in 0 .. INSTR_BENCHMARK_RUNS;
+		let mut sbox = Sandbox::from(&WasmModule::<T>::from(ModuleDefinition {
+			call_body: Some(body::repeated_dyn(r, vec![
+				RandomI64Repeated(1),
+				Regular(Instruction::Drop),
+			])),
+			.. Default::default()
+		}));
+	}: {
+		sbox.invoke();
+	}
+
+	// This is no benchmark. It merely exist to have an easy way to pretty print the currently
+	// configured `Schedule` during benchmark development.
+	// It can be outputted using the following command:
+	// cargo run --manifest-path=bin/node/cli/Cargo.toml \
+	//     --features runtime-benchmarks -- benchmark pallet --extra --dev --execution=native \
+	//     -p pallet_contracts -e print_schedule --no-median-slopes --no-min-squares
+	#[extra]
+	#[pov_mode = Ignored]
+	print_schedule {
+		#[cfg(feature = "std")]
+		{
+			let max_weight = <T as frame_system::Config>::BlockWeights::get().max_block;
+			let (weight_per_key, key_budget) = ContractInfo::<T>::deletion_budget(max_weight);
+			println!("{:#?}", Schedule::<T>::default());
+			println!("###############################################");
+			println!("Lazy deletion weight per key: {weight_per_key}");
+			println!("Lazy deletion throughput per block: {key_budget}");
+		}
+		#[cfg(not(feature = "std"))]
+		Err("Run this bench with a native runtime in order to see the schedule.")?;
+	}: {}
+
+	// Execute one erc20 transfer using the ink! erc20 example contract.
+	#[extra]
+	#[pov_mode = Measured]
+	ink_erc20_transfer {
+		let code = load_benchmark!("ink_erc20");
+		let data = {
+			let new: ([u8; 4], BalanceOf<T>) = ([0x9b, 0xae, 0x9d, 0x5e], 1000u32.into());
+			new.encode()
+		};
+		let instance = Contract::<T>::new(
+			WasmModule::from_code(code), data,
+		)?;
+		let data = {
+			let transfer: ([u8; 4], AccountIdOf<T>, BalanceOf<T>) = (
+				[0x84, 0xa1, 0x5d, 0xa1],
+				account::<T::AccountId>("receiver", 0, 0),
+				1u32.into(),
+			);
+			transfer.encode()
+		};
+	}: {
+		<Contracts<T>>::bare_call(
+			instance.caller,
+			instance.account_id,
+			0u32.into(),
+			Weight::MAX,
+			None,
+			data,
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result?;
+	}
+
+	// Execute one erc20 transfer using the open zeppelin erc20 contract compiled with solang.
+	#[extra]
+	#[pov_mode = Measured]
+	solang_erc20_transfer {
+		let code = include_bytes!("../../benchmarks/solang_erc20.wasm");
+		let caller = account::<T::AccountId>("instantiator", 0, 0);
+		let mut balance = [0u8; 32];
+		balance[0] = 100;
+		let data = {
+			let new: ([u8; 4], &str, &str, [u8; 32], AccountIdOf<T>) = (
+				[0xa6, 0xf1, 0xf5, 0xe1],
+				"KSM",
+				"K",
+				balance,
+				caller.clone(),
+			);
+			new.encode()
+		};
+		let instance = Contract::<T>::with_caller(
+			caller, WasmModule::from_code(code), data,
+		)?;
+		balance[0] = 1;
+		let data = {
+			let transfer: ([u8; 4], AccountIdOf<T>, [u8; 32]) = (
+				[0x6a, 0x46, 0x73, 0x94],
+				account::<T::AccountId>("receiver", 0, 0),
+				balance,
+			);
+			transfer.encode()
+		};
+	}: {
+		<Contracts<T>>::bare_call(
+			instance.caller,
+			instance.account_id,
+			0u32.into(),
+			Weight::MAX,
+			None,
+			data,
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result?;
+	}
+
+	impl_benchmark_test_suite!(
+		Contracts,
+		crate::tests::ExtBuilder::default().build(),
+		crate::tests::Test,
+	)
+}
diff --git a/substrate/frame/contracts/src/benchmarking/sandbox.rs b/substrate/frame/contracts/src/benchmarking/sandbox.rs
new file mode 100644
index 0000000000000000000000000000000000000000..34974b02ea0c45305acfa67123663ddf10ce74c0
--- /dev/null
+++ b/substrate/frame/contracts/src/benchmarking/sandbox.rs
@@ -0,0 +1,77 @@
+// 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.
+
+/// ! For instruction benchmarking we do not instantiate a full contract but merely the
+/// ! sandbox to execute the Wasm code. This is because we do not need the full
+/// ! environment that provides the seal interface as imported functions.
+use super::{code::WasmModule, Config};
+use crate::wasm::{
+	AllowDeprecatedInterface, AllowUnstableInterface, Determinism, Environment, WasmBlob,
+};
+use sp_core::Get;
+use wasmi::{errors::LinkerError, Func, Linker, StackLimits, Store};
+
+/// Minimal execution environment without any imported functions.
+pub struct Sandbox {
+	entry_point: Func,
+	store: Store<()>,
+}
+
+impl Sandbox {
+	/// Invoke the `call` function of a contract code and panic on any execution error.
+	pub fn invoke(&mut self) {
+		self.entry_point.call(&mut self.store, &[], &mut []).unwrap();
+	}
+}
+
+impl<T: Config> From<&WasmModule<T>> for Sandbox {
+	/// Creates an instance from the supplied module.
+	/// Sets the execution engine fuel level to `u64::MAX`.
+	fn from(module: &WasmModule<T>) -> Self {
+		let (mut store, _memory, instance) = WasmBlob::<T>::instantiate::<EmptyEnv, _>(
+			&module.code,
+			(),
+			&<T>::Schedule::get(),
+			Determinism::Relaxed,
+			StackLimits::default(),
+			// We are testing with an empty environment anyways
+			AllowDeprecatedInterface::No,
+		)
+		.expect("Failed to create benchmarking Sandbox instance");
+
+		// Set fuel for wasmi execution.
+		store
+			.add_fuel(u64::MAX)
+			.expect("We've set up engine to fuel consuming mode; qed");
+
+		let entry_point = instance.get_export(&store, "call").unwrap().into_func().unwrap();
+		Self { entry_point, store }
+	}
+}
+
+struct EmptyEnv;
+
+impl Environment<()> for EmptyEnv {
+	fn define(
+		_: &mut Store<()>,
+		_: &mut Linker<()>,
+		_: AllowUnstableInterface,
+		_: AllowDeprecatedInterface,
+	) -> Result<(), LinkerError> {
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/chain_extension.rs b/substrate/frame/contracts/src/chain_extension.rs
new file mode 100644
index 0000000000000000000000000000000000000000..664504d207f3af75641abcb3684410b496521db8
--- /dev/null
+++ b/substrate/frame/contracts/src/chain_extension.rs
@@ -0,0 +1,488 @@
+// 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 mechanism for runtime authors to augment the functionality of contracts.
+//!
+//! The runtime is able to call into any contract and retrieve the result using
+//! [`bare_call`](crate::Pallet::bare_call). This already allows customization of runtime
+//! behaviour by user generated code (contracts). However, often it is more straightforward
+//! to allow the reverse behaviour: The contract calls into the runtime. We call the latter
+//! one a "chain extension" because it allows the chain to extend the set of functions that are
+//! callable by a contract.
+//!
+//! In order to create a chain extension the runtime author implements the [`ChainExtension`]
+//! trait and declares it in this pallet's [configuration Trait](crate::Config). All types
+//! required for this endeavour are defined or re-exported in this module. There is an
+//! implementation on `()` which can be used to signal that no chain extension is available.
+//!
+//! # Using multiple chain extensions
+//!
+//! Often there is a need for having multiple chain extensions. This is often the case when
+//! some generally useful off-the-shelf extensions should be included. To have multiple chain
+//! extensions they can be put into a tuple which is then passed to [`Config::ChainExtension`] like
+//! this `type Extensions = (ExtensionA, ExtensionB)`.
+//!
+//! However, only extensions implementing [`RegisteredChainExtension`] can be put into a tuple.
+//! This is because the [`RegisteredChainExtension::ID`] is used to decide which of those extensions
+//! should be used when the contract calls a chain extensions. Extensions which are generally
+//! useful should claim their `ID` with [the registry](https://github.com/paritytech/chainextension-registry)
+//! so that no collisions with other vendors will occur.
+//!
+//! **Chain specific extensions must use the reserved `ID = 0` so that they can't be registered with
+//! the registry.**
+//!
+//! # Security
+//!
+//! The chain author alone is responsible for the security of the chain extension.
+//! This includes avoiding the exposure of exploitable functions and charging the
+//! appropriate amount of weight. In order to do so benchmarks must be written and the
+//! [`charge_weight`](Environment::charge_weight) function must be called **before**
+//! carrying out any action that causes the consumption of the chargeable weight.
+//! It cannot be overstated how delicate of a process the creation of a chain extension
+//! is. Check whether using [`bare_call`](crate::Pallet::bare_call) suffices for the
+//! use case at hand.
+//!
+//! # Benchmarking
+//!
+//! The builtin contract callable functions that pallet-contracts provides all have
+//! benchmarks that determine the correct weight that an invocation of these functions
+//! induces. In order to be able to charge the correct weight for the functions defined
+//! by a chain extension benchmarks must be written, too. In the near future this crate
+//! will provide the means for easier creation of those specialized benchmarks.
+//!
+//! # Example
+//!
+//! The ink-examples repository maintains an
+//! [end-to-end example](https://github.com/paritytech/ink-examples/tree/main/rand-extension)
+//! on how to use a chain extension in order to provide new features to ink! contracts.
+
+use crate::{
+	wasm::{Runtime, RuntimeCosts},
+	Error,
+};
+use codec::{Decode, MaxEncodedLen};
+use frame_support::weights::Weight;
+use sp_runtime::DispatchError;
+use sp_std::{marker::PhantomData, vec::Vec};
+
+pub use crate::{exec::Ext, gas::ChargedAmount, storage::meter::Diff, Config};
+pub use frame_system::Config as SysConfig;
+pub use pallet_contracts_primitives::ReturnFlags;
+
+/// Result that returns a [`DispatchError`] on error.
+pub type Result<T> = sp_std::result::Result<T, DispatchError>;
+
+/// A trait used to extend the set of contract callable functions.
+///
+/// In order to create a custom chain extension this trait must be implemented and supplied
+/// to the pallet contracts configuration trait as the associated type of the same name.
+/// Consult the [module documentation](self) for a general explanation of chain extensions.
+///
+/// # Lifetime
+///
+/// The extension will be [`Default`] initialized at the beginning of each call
+/// (**not** per call stack) and dropped afterwards. Hence any value held inside the extension
+/// can be used as a per-call scratch buffer.
+pub trait ChainExtension<C: Config> {
+	/// Call the chain extension logic.
+	///
+	/// This is the only function that needs to be implemented in order to write a
+	/// chain extensions. It is called whenever a contract calls the `seal_call_chain_extension`
+	/// imported wasm function.
+	///
+	/// # Parameters
+	/// - `env`: Access to the remaining arguments and the execution environment.
+	///
+	/// # Return
+	///
+	/// 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.
+	fn call<E: Ext<T = C>>(&mut self, env: Environment<E, InitState>) -> Result<RetVal>;
+
+	/// Determines whether chain extensions are enabled for this chain.
+	///
+	/// The default implementation returns `true`. Therefore it is not necessary to overwrite
+	/// this function when implementing a chain extension. In case of `false` the deployment of
+	/// a contract that references `seal_call_chain_extension` will be denied and calling this
+	/// function will return [`NoChainExtension`](Error::NoChainExtension) without first calling
+	/// into [`call`](Self::call).
+	fn enabled() -> bool {
+		true
+	}
+}
+
+/// A [`ChainExtension`] that can be composed with other extensions using a tuple.
+///
+/// An extension that implements this trait can be put in a tuple in order to have multiple
+/// extensions available. The tuple implementation routes requests based on the first two
+/// most significant bytes of the `id` passed to `call`.
+///
+/// If this extensions is to be used by multiple runtimes consider
+/// [registering it](https://github.com/paritytech/chainextension-registry) to ensure that there
+/// are no collisions with other vendors.
+///
+/// # Note
+///
+/// Currently, we support tuples of up to ten registered chain extensions. If more chain extensions
+/// are needed consider opening an issue.
+pub trait RegisteredChainExtension<C: Config>: ChainExtension<C> {
+	/// The extensions globally unique identifier.
+	const ID: u16;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(10)]
+#[tuple_types_custom_trait_bound(RegisteredChainExtension<C>)]
+impl<C: Config> ChainExtension<C> for Tuple {
+	fn call<E: Ext<T = C>>(&mut self, mut env: Environment<E, InitState>) -> Result<RetVal> {
+		for_tuples!(
+			#(
+				if (Tuple::ID == env.ext_id()) && Tuple::enabled() {
+					return Tuple.call(env);
+				}
+			)*
+		);
+		Err(Error::<E::T>::NoChainExtension.into())
+	}
+
+	fn enabled() -> bool {
+		for_tuples!(
+			#(
+				if Tuple::enabled() {
+					return true;
+				}
+			)*
+		);
+		false
+	}
+}
+
+/// Determines the exit behaviour and return value of a chain extension.
+pub enum RetVal {
+	/// The chain extensions returns the supplied value to its calling contract.
+	Converging(u32),
+	/// The control does **not** return to the calling contract.
+	///
+	/// Use this to stop the execution of the contract when the chain extension returns.
+	/// The semantic is the same as for calling `seal_return`: The control returns to
+	/// the caller of the currently executing contract yielding the supplied buffer and
+	/// flags.
+	Diverging { flags: ReturnFlags, data: Vec<u8> },
+}
+
+/// Grants the chain extension access to its parameters and execution environment.
+///
+/// It uses [typestate programming](https://docs.rust-embedded.org/book/static-guarantees/typestate-programming.html)
+/// to enforce the correct usage of the parameters passed to the chain extension.
+pub struct Environment<'a, 'b, E: Ext, S: State> {
+	/// The actual data of this type.
+	inner: Inner<'a, 'b, E>,
+	/// `S` is only used in the type system but never as value.
+	phantom: PhantomData<S>,
+}
+
+/// Functions that are available in every state of this type.
+impl<'a, 'b, E: Ext, S: State> Environment<'a, 'b, E, S> {
+	/// The function id within the `id` passed by a contract.
+	///
+	/// It returns the two least significant bytes of the `id` passed by a contract as the other
+	/// two bytes represent the chain extension itself (the code which is calling this function).
+	pub fn func_id(&self) -> u16 {
+		(self.inner.id & 0x0000FFFF) as u16
+	}
+
+	/// The chain extension id within the `id` passed by a contract.
+	///
+	/// It returns the two most significant bytes of the `id` passed by a contract which represent
+	/// the chain extension itself (the code which is calling this function).
+	pub fn ext_id(&self) -> u16 {
+		(self.inner.id >> 16) as u16
+	}
+
+	/// Charge the passed `amount` of weight from the overall limit.
+	///
+	/// It returns `Ok` when there the remaining weight budget is larger than the passed
+	/// `weight`. It returns `Err` otherwise. In this case the chain extension should
+	/// abort the execution and pass through the error.
+	///
+	/// The returned value can be used to with [`Self::adjust_weight`]. Other than that
+	/// it has no purpose.
+	///
+	/// # Note
+	///
+	/// Weight is synonymous with gas in substrate.
+	pub fn charge_weight(&mut self, amount: Weight) -> Result<ChargedAmount> {
+		self.inner.runtime.charge_gas(RuntimeCosts::ChainExtension(amount))
+	}
+
+	/// Adjust a previously charged amount down to its actual amount.
+	///
+	/// This is when a maximum a priori amount was charged and then should be partially
+	/// refunded to match the actual amount.
+	pub fn adjust_weight(&mut self, charged: ChargedAmount, actual_weight: Weight) {
+		self.inner
+			.runtime
+			.adjust_gas(charged, RuntimeCosts::ChainExtension(actual_weight))
+	}
+
+	/// Grants access to the execution environment of the current contract call.
+	///
+	/// Consult the functions on the returned type before re-implementing those functions.
+	pub fn ext(&mut self) -> &mut E {
+		self.inner.runtime.ext()
+	}
+}
+
+/// Functions that are only available in the initial state of this type.
+///
+/// Those are the functions that determine how the arguments to the chain extensions
+/// should be consumed.
+impl<'a, 'b, E: Ext> Environment<'a, 'b, E, InitState> {
+	/// Creates a new environment for consumption by a chain extension.
+	///
+	/// It is only available to this crate because only the wasm runtime module needs to
+	/// ever create this type. Chain extensions merely consume it.
+	pub(crate) fn new(
+		runtime: &'a mut Runtime<'b, E>,
+		memory: &'a mut [u8],
+		id: u32,
+		input_ptr: u32,
+		input_len: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+	) -> Self {
+		Environment {
+			inner: Inner { runtime, memory, id, input_ptr, input_len, output_ptr, output_len_ptr },
+			phantom: PhantomData,
+		}
+	}
+
+	/// Use all arguments as integer values.
+	pub fn only_in(self) -> Environment<'a, 'b, E, OnlyInState> {
+		Environment { inner: self.inner, phantom: PhantomData }
+	}
+
+	/// Use input arguments as integer and output arguments as pointer to a buffer.
+	pub fn prim_in_buf_out(self) -> Environment<'a, 'b, E, PrimInBufOutState> {
+		Environment { inner: self.inner, phantom: PhantomData }
+	}
+
+	/// Use input and output arguments as pointers to a buffer.
+	pub fn buf_in_buf_out(self) -> Environment<'a, 'b, E, BufInBufOutState> {
+		Environment { inner: self.inner, phantom: PhantomData }
+	}
+}
+
+/// Functions to use the input arguments as integers.
+impl<'a, 'b, E: Ext, S: PrimIn> Environment<'a, 'b, E, S> {
+	/// The `input_ptr` argument.
+	pub fn val0(&self) -> u32 {
+		self.inner.input_ptr
+	}
+
+	/// The `input_len` argument.
+	pub fn val1(&self) -> u32 {
+		self.inner.input_len
+	}
+}
+
+/// Functions to use the output arguments as integers.
+impl<'a, 'b, E: Ext, S: PrimOut> Environment<'a, 'b, E, S> {
+	/// The `output_ptr` argument.
+	pub fn val2(&self) -> u32 {
+		self.inner.output_ptr
+	}
+
+	/// The `output_len_ptr` argument.
+	pub fn val3(&self) -> u32 {
+		self.inner.output_len_ptr
+	}
+}
+
+/// Functions to use the input arguments as pointer to a buffer.
+impl<'a, 'b, E: Ext, S: BufIn> Environment<'a, 'b, E, S> {
+	/// Reads `min(max_len, in_len)` from contract memory.
+	///
+	/// This does **not** charge any weight. The caller must make sure that the an
+	/// appropriate amount of weight is charged **before** reading from contract memory.
+	/// The reason for that is that usually the costs for reading data and processing
+	/// said data cannot be separated in a benchmark. Therefore a chain extension would
+	/// charge the overall costs either using `max_len` (worst case approximation) or using
+	/// [`in_len()`](Self::in_len).
+	pub fn read(&self, max_len: u32) -> Result<Vec<u8>> {
+		self.inner.runtime.read_sandbox_memory(
+			self.inner.memory,
+			self.inner.input_ptr,
+			self.inner.input_len.min(max_len),
+		)
+	}
+
+	/// Reads `min(buffer.len(), in_len) from contract memory.
+	///
+	/// This takes a mutable pointer to a buffer fills it with data and shrinks it to
+	/// the size of the actual data. Apart from supporting pre-allocated buffers it is
+	/// equivalent to to [`read()`](Self::read).
+	pub fn read_into(&self, buffer: &mut &mut [u8]) -> Result<()> {
+		let len = buffer.len();
+		let sliced = {
+			let buffer = core::mem::take(buffer);
+			&mut buffer[..len.min(self.inner.input_len as usize)]
+		};
+		self.inner.runtime.read_sandbox_memory_into_buf(
+			self.inner.memory,
+			self.inner.input_ptr,
+			sliced,
+		)?;
+		*buffer = sliced;
+		Ok(())
+	}
+
+	/// Reads and decodes a type with a size fixed at compile time from contract memory.
+	///
+	/// This function is secure and recommended for all input types of fixed size
+	/// as long as the cost of reading the memory is included in the overall already charged
+	/// weight of the chain extension. This should usually be the case when fixed input types
+	/// are used.
+	pub fn read_as<T: Decode + MaxEncodedLen>(&mut self) -> Result<T> {
+		self.inner
+			.runtime
+			.read_sandbox_memory_as(self.inner.memory, self.inner.input_ptr)
+	}
+
+	/// Reads and decodes a type with a dynamic size from contract memory.
+	///
+	/// Make sure to include `len` in your weight calculations.
+	pub fn read_as_unbounded<T: Decode>(&mut self, len: u32) -> Result<T> {
+		self.inner.runtime.read_sandbox_memory_as_unbounded(
+			self.inner.memory,
+			self.inner.input_ptr,
+			len,
+		)
+	}
+
+	/// The length of the input as passed in as `input_len`.
+	///
+	/// A chain extension would use this value to calculate the dynamic part of its
+	/// weight. For example a chain extension that calculates the hash of some passed in
+	/// bytes would use `in_len` to charge the costs of hashing that amount of bytes.
+	/// This also subsumes the act of copying those bytes as a benchmarks measures both.
+	pub fn in_len(&self) -> u32 {
+		self.inner.input_len
+	}
+}
+
+/// Functions to use the output arguments as pointer to a buffer.
+impl<'a, 'b, E: Ext, S: BufOut> Environment<'a, 'b, E, S> {
+	/// Write the supplied buffer to contract memory.
+	///
+	/// If the contract supplied buffer is smaller than the passed `buffer` an `Err` is returned.
+	/// If `allow_skip` is set to true the contract is allowed to skip the copying of the buffer
+	/// by supplying the guard value of `pallet-contracts::SENTINEL` as `out_ptr`. The
+	/// `weight_per_byte` is only charged when the write actually happens and is not skipped or
+	/// failed due to a too small output buffer.
+	pub fn write(
+		&mut self,
+		buffer: &[u8],
+		allow_skip: bool,
+		weight_per_byte: Option<Weight>,
+	) -> Result<()> {
+		self.inner.runtime.write_sandbox_output(
+			self.inner.memory,
+			self.inner.output_ptr,
+			self.inner.output_len_ptr,
+			buffer,
+			allow_skip,
+			|len| {
+				weight_per_byte.map(|w| RuntimeCosts::ChainExtension(w.saturating_mul(len.into())))
+			},
+		)
+	}
+}
+
+/// The actual data of an `Environment`.
+///
+/// All data is put into this struct to easily pass it around as part of the typestate
+/// pattern. Also it creates the opportunity to box this struct in the future in case it
+/// gets too large.
+struct Inner<'a, 'b, E: Ext> {
+	/// The runtime contains all necessary functions to interact with the running contract.
+	runtime: &'a mut Runtime<'b, E>,
+	/// Reference to the contracts memory.
+	memory: &'a mut [u8],
+	/// Verbatim argument passed to `seal_call_chain_extension`.
+	id: u32,
+	/// Verbatim argument passed to `seal_call_chain_extension`.
+	input_ptr: u32,
+	/// Verbatim argument passed to `seal_call_chain_extension`.
+	input_len: u32,
+	/// Verbatim argument passed to `seal_call_chain_extension`.
+	output_ptr: u32,
+	/// Verbatim argument passed to `seal_call_chain_extension`.
+	output_len_ptr: u32,
+}
+
+/// Any state of an [`Environment`] implements this trait.
+/// See [typestate programming](https://docs.rust-embedded.org/book/static-guarantees/typestate-programming.html).
+pub trait State: sealed::Sealed {}
+
+/// A state that uses primitive inputs.
+pub trait PrimIn: State {}
+
+/// A state that uses primitive outputs.
+pub trait PrimOut: State {}
+
+/// A state that uses a buffer as input.
+pub trait BufIn: State {}
+
+/// A state that uses a buffer as output.
+pub trait BufOut: State {}
+
+/// The initial state of an [`Environment`].
+pub enum InitState {}
+
+/// A state that uses all arguments as primitive inputs.
+pub enum OnlyInState {}
+
+/// A state that uses two arguments as primitive inputs and the other two as buffer output.
+pub enum PrimInBufOutState {}
+
+/// Uses a buffer for input and a buffer for output.
+pub enum BufInBufOutState {}
+
+mod sealed {
+	use super::*;
+
+	/// Trait to prevent users from implementing `State` for anything else.
+	pub trait Sealed {}
+
+	impl Sealed for InitState {}
+	impl Sealed for OnlyInState {}
+	impl Sealed for PrimInBufOutState {}
+	impl Sealed for BufInBufOutState {}
+
+	impl State for InitState {}
+	impl State for OnlyInState {}
+	impl State for PrimInBufOutState {}
+	impl State for BufInBufOutState {}
+
+	impl PrimIn for OnlyInState {}
+	impl PrimOut for OnlyInState {}
+	impl PrimIn for PrimInBufOutState {}
+	impl BufOut for PrimInBufOutState {}
+	impl BufIn for BufInBufOutState {}
+	impl BufOut for BufInBufOutState {}
+}
diff --git a/substrate/frame/contracts/src/debug.rs b/substrate/frame/contracts/src/debug.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a92f428c8f8a43d8d37f79220c2564eb618b4827
--- /dev/null
+++ b/substrate/frame/contracts/src/debug.rs
@@ -0,0 +1,55 @@
+pub use crate::exec::ExportedFunction;
+use crate::{CodeHash, Config, LOG_TARGET};
+use pallet_contracts_primitives::ExecReturnValue;
+
+/// Umbrella trait for all interfaces that serves for debugging.
+pub trait Debugger<T: Config>: Tracing<T> {}
+
+impl<T: Config, V> Debugger<T> for V where V: Tracing<T> {}
+
+/// Defines methods to capture contract calls, enabling external observers to
+/// measure, trace, and react to contract interactions.
+pub trait Tracing<T: Config> {
+	/// The type of [`CallSpan`] that is created by this trait.
+	type CallSpan: CallSpan;
+
+	/// Creates a new call span to encompass the upcoming contract execution.
+	///
+	/// This method should be invoked just before the execution of a contract and
+	/// marks the beginning of a traceable span of execution.
+	///
+	/// # Arguments
+	///
+	/// * `code_hash` - The code hash of the contract being called.
+	/// * `entry_point` - Describes whether the call is the constructor or a regular call.
+	/// * `input_data` - The raw input data of the call.
+	fn new_call_span(
+		code_hash: &CodeHash<T>,
+		entry_point: ExportedFunction,
+		input_data: &[u8],
+	) -> Self::CallSpan;
+}
+
+/// Defines a span of execution for a contract call.
+pub trait CallSpan {
+	/// Called just after the execution of a contract.
+	///
+	/// # Arguments
+	///
+	/// * `output` - The raw output of the call.
+	fn after_call(self, output: &ExecReturnValue);
+}
+
+impl<T: Config> Tracing<T> for () {
+	type CallSpan = ();
+
+	fn new_call_span(code_hash: &CodeHash<T>, entry_point: ExportedFunction, input_data: &[u8]) {
+		log::trace!(target: LOG_TARGET, "call {entry_point:?} hash: {code_hash:?}, input_data: {input_data:?}")
+	}
+}
+
+impl CallSpan for () {
+	fn after_call(self, output: &ExecReturnValue) {
+		log::trace!(target: LOG_TARGET, "call result {output:?}")
+	}
+}
diff --git a/substrate/frame/contracts/src/exec.rs b/substrate/frame/contracts/src/exec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ba44220ff8dcb1448b2047eeb92f77f9af58bb2
--- /dev/null
+++ b/substrate/frame/contracts/src/exec.rs
@@ -0,0 +1,3884 @@
+// 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::{
+	debug::{CallSpan, Tracing},
+	gas::GasMeter,
+	storage::{self, meter::Diff, WriteOutcome},
+	BalanceOf, CodeHash, CodeInfo, CodeInfoOf, Config, ContractInfo, ContractInfoOf,
+	DebugBufferVec, Determinism, Error, Event, Nonce, Origin, Pallet as Contracts, Schedule,
+	WasmBlob, LOG_TARGET,
+};
+use frame_support::{
+	crypto::ecdsa::ECDSAExt,
+	dispatch::{
+		fmt::Debug, DispatchError, DispatchResult, DispatchResultWithPostInfo, Dispatchable,
+	},
+	ensure,
+	storage::{with_transaction, TransactionOutcome},
+	traits::{
+		fungible::{Inspect, Mutate},
+		tokens::Preservation,
+		Contains, OriginTrait, Randomness, Time,
+	},
+	weights::Weight,
+	Blake2_128Concat, BoundedVec, StorageHasher,
+};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use pallet_contracts_primitives::{ExecReturnValue, StorageDeposit};
+use smallvec::{Array, SmallVec};
+use sp_core::{
+	ecdsa::Public as ECDSAPublic,
+	sr25519::{Public as SR25519Public, Signature as SR25519Signature},
+	Get,
+};
+use sp_io::{crypto::secp256k1_ecdsa_recover_compressed, hashing::blake2_256};
+use sp_runtime::traits::{Convert, Hash, Zero};
+use sp_std::{marker::PhantomData, mem, prelude::*, vec::Vec};
+
+pub type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
+pub type MomentOf<T> = <<T as Config>::Time as Time>::Moment;
+pub type SeedOf<T> = <T as frame_system::Config>::Hash;
+pub type ExecResult = Result<ExecReturnValue, ExecError>;
+
+/// A type that represents a topic of an event. At the moment a hash is used.
+pub type TopicOf<T> = <T as frame_system::Config>::Hash;
+
+/// Type for variable sized storage key. Used for transparent hashing.
+type VarSizedKey<T> = BoundedVec<u8, <T as Config>::MaxStorageKeyLen>;
+
+/// Combined key type for both fixed and variable sized storage keys.
+pub enum Key<T: Config> {
+	/// Variant for fixed sized keys.
+	Fix([u8; 32]),
+	/// Variant for variable sized keys.
+	Var(VarSizedKey<T>),
+}
+
+impl<T: Config> Key<T> {
+	/// Copies self into a new vec.
+	pub fn to_vec(&self) -> Vec<u8> {
+		match self {
+			Key::Fix(v) => v.to_vec(),
+			Key::Var(v) => v.to_vec(),
+		}
+	}
+
+	pub fn hash(&self) -> Vec<u8> {
+		match self {
+			Key::Fix(v) => blake2_256(v.as_slice()).to_vec(),
+			Key::Var(v) => Blake2_128Concat::hash(v.as_slice()),
+		}
+	}
+
+	pub fn try_from_fix(v: Vec<u8>) -> Result<Self, Vec<u8>> {
+		<[u8; 32]>::try_from(v).map(Self::Fix)
+	}
+
+	pub fn try_from_var(v: Vec<u8>) -> Result<Self, Vec<u8>> {
+		VarSizedKey::<T>::try_from(v).map(Self::Var)
+	}
+}
+
+/// Origin of the error.
+///
+/// Call or instantiate both called into other contracts and pass through errors happening
+/// in those to the caller. This enum is for the caller to distinguish whether the error
+/// happened during the execution of the callee or in the current execution context.
+#[cfg_attr(test, derive(Debug, PartialEq))]
+pub enum ErrorOrigin {
+	/// Caller error origin.
+	///
+	/// The error happened in the current execution context rather than in the one
+	/// of the contract that is called into.
+	Caller,
+	/// The error happened during execution of the called contract.
+	Callee,
+}
+
+/// Error returned by contract execution.
+#[cfg_attr(test, derive(Debug, PartialEq))]
+pub struct ExecError {
+	/// The reason why the execution failed.
+	pub error: DispatchError,
+	/// Origin of the error.
+	pub origin: ErrorOrigin,
+}
+
+impl<T: Into<DispatchError>> From<T> for ExecError {
+	fn from(error: T) -> Self {
+		Self { error: error.into(), origin: ErrorOrigin::Caller }
+	}
+}
+
+/// An interface that provides access to the external environment in which the
+/// smart-contract is executed.
+///
+/// This interface is specialized to an account of the executing code, so all
+/// operations are implicitly performed on that account.
+///
+/// # Note
+///
+/// This trait is sealed and cannot be implemented by downstream crates.
+pub trait Ext: sealing::Sealed {
+	type T: Config;
+
+	/// Call (possibly transferring some amount of funds) into the specified account.
+	///
+	/// Returns the code size of the called contract.
+	fn call(
+		&mut self,
+		gas_limit: Weight,
+		deposit_limit: BalanceOf<Self::T>,
+		to: AccountIdOf<Self::T>,
+		value: BalanceOf<Self::T>,
+		input_data: Vec<u8>,
+		allows_reentry: bool,
+	) -> Result<ExecReturnValue, ExecError>;
+
+	/// Execute code in the current frame.
+	///
+	/// Returns the code size of the called contract.
+	fn delegate_call(
+		&mut self,
+		code: CodeHash<Self::T>,
+		input_data: Vec<u8>,
+	) -> Result<ExecReturnValue, ExecError>;
+
+	/// Instantiate a contract from the given code.
+	///
+	/// Returns the original code size of the called contract.
+	/// The newly created account will be associated with `code`. `value` specifies the amount of
+	/// value transferred from the caller to the newly created account.
+	fn instantiate(
+		&mut self,
+		gas_limit: Weight,
+		deposit_limit: BalanceOf<Self::T>,
+		code: CodeHash<Self::T>,
+		value: BalanceOf<Self::T>,
+		input_data: Vec<u8>,
+		salt: &[u8],
+	) -> Result<(AccountIdOf<Self::T>, ExecReturnValue), ExecError>;
+
+	/// Transfer all funds to `beneficiary` and delete the contract.
+	///
+	/// Since this function removes the self contract eagerly, if succeeded, no further actions
+	/// should be performed on this `Ext` instance.
+	///
+	/// 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>;
+
+	/// Transfer some amount of funds into the specified account.
+	fn transfer(&mut self, to: &AccountIdOf<Self::T>, value: BalanceOf<Self::T>) -> DispatchResult;
+
+	/// Returns the storage entry of the executing account by the given `key`.
+	///
+	/// Returns `None` if the `key` wasn't previously set by `set_storage` or
+	/// was deleted.
+	fn get_storage(&mut self, key: &Key<Self::T>) -> Option<Vec<u8>>;
+
+	/// Returns `Some(len)` (in bytes) if a storage item exists at `key`.
+	///
+	/// Returns `None` if the `key` wasn't previously set by `set_storage` or
+	/// was deleted.
+	fn get_storage_size(&mut self, key: &Key<Self::T>) -> Option<u32>;
+
+	/// Sets the storage entry by the given key to the specified value. If `value` is `None` then
+	/// the storage entry is deleted.
+	fn set_storage(
+		&mut self,
+		key: &Key<Self::T>,
+		value: Option<Vec<u8>>,
+		take_old: bool,
+	) -> Result<WriteOutcome, DispatchError>;
+
+	/// Returns the caller.
+	fn caller(&self) -> Origin<Self::T>;
+
+	/// Check if a contract lives at the specified `address`.
+	fn is_contract(&self, address: &AccountIdOf<Self::T>) -> bool;
+
+	/// Returns the code hash of the contract for the given `address`.
+	///
+	/// Returns `None` if the `address` does not belong to a contract.
+	fn code_hash(&self, address: &AccountIdOf<Self::T>) -> Option<CodeHash<Self::T>>;
+
+	/// Returns the code hash of the contract being executed.
+	fn own_code_hash(&mut self) -> &CodeHash<Self::T>;
+
+	/// Check if the caller of the current contract is the origin of the whole call stack.
+	///
+	/// This can be checked with `is_contract(self.caller())` as well.
+	/// However, this function does not require any storage lookup and therefore uses less weight.
+	fn caller_is_origin(&self) -> bool;
+
+	/// Check if the caller is origin, and this origin is root.
+	fn caller_is_root(&self) -> bool;
+
+	/// Returns a reference to the account id of the current contract.
+	fn address(&self) -> &AccountIdOf<Self::T>;
+
+	/// Returns the balance of the current contract.
+	///
+	/// The `value_transferred` is already added.
+	fn balance(&self) -> BalanceOf<Self::T>;
+
+	/// Returns the value transferred along with this call.
+	fn value_transferred(&self) -> BalanceOf<Self::T>;
+
+	/// Returns a reference to the timestamp of the current block
+	fn now(&self) -> &MomentOf<Self::T>;
+
+	/// Returns the minimum balance that is required for creating an account.
+	fn minimum_balance(&self) -> BalanceOf<Self::T>;
+
+	/// Returns a random number for the current block with the given subject.
+	fn random(&self, subject: &[u8]) -> (SeedOf<Self::T>, BlockNumberFor<Self::T>);
+
+	/// Deposit an event with the given topics.
+	///
+	/// There should not be any duplicates in `topics`.
+	fn deposit_event(&mut self, topics: Vec<TopicOf<Self::T>>, data: Vec<u8>);
+
+	/// Returns the current block number.
+	fn block_number(&self) -> BlockNumberFor<Self::T>;
+
+	/// Returns the maximum allowed size of a storage item.
+	fn max_value_size(&self) -> u32;
+
+	/// Returns the price for the specified amount of weight.
+	fn get_weight_price(&self, weight: Weight) -> BalanceOf<Self::T>;
+
+	/// Get a reference to the schedule used by the current call.
+	fn schedule(&self) -> &Schedule<Self::T>;
+
+	/// Get an immutable reference to the nested gas meter.
+	fn gas_meter(&self) -> &GasMeter<Self::T>;
+
+	/// Get a mutable reference to the nested gas meter.
+	fn gas_meter_mut(&mut self) -> &mut GasMeter<Self::T>;
+
+	/// Charges `diff` from the meter.
+	fn charge_storage(&mut self, diff: &Diff);
+
+	/// Append a string to the debug buffer.
+	///
+	/// It is added as-is without any additional new line.
+	///
+	/// This is a no-op if debug message recording is disabled which is always the case
+	/// when the code is executing on-chain.
+	///
+	/// Returns `true` if debug message recording is enabled. Otherwise `false` is returned.
+	fn append_debug_buffer(&mut self, msg: &str) -> bool;
+
+	/// Call some dispatchable and return the result.
+	fn call_runtime(&self, call: <Self::T as Config>::RuntimeCall) -> DispatchResultWithPostInfo;
+
+	/// Recovers ECDSA compressed public key based on signature and message hash.
+	fn ecdsa_recover(&self, signature: &[u8; 65], message_hash: &[u8; 32]) -> Result<[u8; 33], ()>;
+
+	/// Verify a sr25519 signature.
+	fn sr25519_verify(&self, signature: &[u8; 64], message: &[u8], pub_key: &[u8; 32]) -> bool;
+
+	/// Returns Ethereum address from the ECDSA compressed public key.
+	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)]
+	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>;
+
+	/// 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.
+	fn reentrance_count(&self) -> u32;
+
+	/// Returns the number of times the specified contract exists on the call stack. Delegated calls
+	/// are not calculated as separate entrance.
+	/// A value of 0 means it does not exist on the call stack.
+	fn account_reentrance_count(&self, account_id: &AccountIdOf<Self::T>) -> u32;
+
+	/// Returns a nonce that is incremented for every instantiated contract.
+	fn nonce(&mut self) -> u64;
+
+	/// Adds a delegate dependency to [`ContractInfo`]'s `delegate_dependencies` field.
+	///
+	/// This ensures that the delegated contract is not removed while it is still in use. It
+	/// increases the reference count of the code hash and charges a fraction (see
+	/// [`Config::CodeHashLockupDepositPercent`]) of the code deposit.
+	///
+	/// # Errors
+	///
+	/// - [`Error::<T>::MaxDelegateDependenciesReached`]
+	/// - [`Error::<T>::CannotAddSelfAsDelegateDependency`]
+	/// - [`Error::<T>::DelegateDependencyAlreadyExists`]
+	fn add_delegate_dependency(
+		&mut self,
+		code_hash: CodeHash<Self::T>,
+	) -> Result<(), DispatchError>;
+
+	/// Removes a delegate dependency from [`ContractInfo`]'s `delegate_dependencies` field.
+	///
+	/// This is the counterpart of [`Self::add_delegate_dependency`]. It decreases the reference
+	/// count and refunds the deposit that was charged by [`Self::add_delegate_dependency`].
+	///
+	/// # Errors
+	///
+	/// - [`Error::<T>::DelegateDependencyNotFound`]
+	fn remove_delegate_dependency(
+		&mut self,
+		code_hash: &CodeHash<Self::T>,
+	) -> Result<(), DispatchError>;
+}
+
+/// Describes the different functions that can be exported by an [`Executable`].
+#[derive(
+	Copy,
+	Clone,
+	PartialEq,
+	Eq,
+	sp_core::RuntimeDebug,
+	codec::Decode,
+	codec::Encode,
+	codec::MaxEncodedLen,
+	scale_info::TypeInfo,
+)]
+pub enum ExportedFunction {
+	/// The constructor function which is executed on deployment of a contract.
+	Constructor,
+	/// The function which is executed when a contract is called.
+	Call,
+}
+
+/// A trait that represents something that can be executed.
+///
+/// In the on-chain environment this would be represented by a wasm module. This trait exists in
+/// order to be able to mock the wasm logic for testing.
+pub trait Executable<T: Config>: Sized {
+	/// Load the executable from storage.
+	///
+	/// # Note
+	/// Charges size base load weight from the gas meter.
+	fn from_storage(
+		code_hash: CodeHash<T>,
+		gas_meter: &mut GasMeter<T>,
+	) -> Result<Self, DispatchError>;
+
+	/// Increment the reference count of a of a stored code by one.
+	///
+	/// # Errors
+	///
+	/// [`Error::CodeNotFound`] is returned if no stored code found having the specified
+	/// `code_hash`.
+	fn increment_refcount(code_hash: CodeHash<T>) -> Result<(), DispatchError>;
+
+	/// Decrement the reference count of a stored code by one.
+	///
+	/// # Note
+	///
+	/// A contract whose reference count dropped to zero isn't automatically removed. A
+	/// `remove_code` transaction must be submitted by the original uploader to do so.
+	fn decrement_refcount(code_hash: CodeHash<T>);
+
+	/// Execute the specified exported function and return the result.
+	///
+	/// When the specified function is `Constructor` the executable is stored and its
+	/// refcount incremented.
+	///
+	/// # Note
+	///
+	/// This functions expects to be executed in a storage transaction that rolls back
+	/// all of its emitted storage changes.
+	fn execute<E: Ext<T = T>>(
+		self,
+		ext: &mut E,
+		function: &ExportedFunction,
+		input_data: Vec<u8>,
+	) -> ExecResult;
+
+	/// The code info of the executable.
+	fn code_info(&self) -> &CodeInfo<T>;
+
+	/// The code hash of the executable.
+	fn code_hash(&self) -> &CodeHash<T>;
+
+	/// Size of the contract code in bytes.
+	fn code_len(&self) -> u32;
+
+	/// The code does not contain any instructions which could lead to indeterminism.
+	fn is_deterministic(&self) -> bool;
+}
+
+/// The complete call stack of a contract execution.
+///
+/// The call stack is initiated by either a signed origin or one of the contract RPC calls.
+/// This type implements `Ext` and by that exposes the business logic of contract execution to
+/// the runtime module which interfaces with the contract (the wasm blob) itself.
+pub struct Stack<'a, T: Config, E> {
+	/// The origin that initiated the call stack. It could either be a Signed plain account that
+	/// holds an account id or Root.
+	///
+	/// # Note
+	///
+	/// Please note that it is possible that the id of a Signed origin belongs to a contract rather
+	/// than a plain account when being called through one of the contract RPCs where the
+	/// client can freely choose the origin. This usually makes no sense but is still possible.
+	origin: Origin<T>,
+	/// The cost schedule used when charging from the gas meter.
+	schedule: &'a Schedule<T>,
+	/// The gas meter where costs are charged to.
+	gas_meter: &'a mut GasMeter<T>,
+	/// The storage meter makes sure that the storage deposit limit is obeyed.
+	storage_meter: &'a mut storage::meter::Meter<T>,
+	/// The timestamp at the point of call stack instantiation.
+	timestamp: MomentOf<T>,
+	/// The block number at the time of call stack instantiation.
+	block_number: BlockNumberFor<T>,
+	/// The nonce is cached here when accessed. It is written back when the call stack
+	/// finishes executing. Please refer to [`Nonce`] to a description of
+	/// the nonce itself.
+	nonce: Option<u64>,
+	/// The actual call stack. One entry per nested contract called/instantiated.
+	/// This does **not** include the [`Self::first_frame`].
+	frames: SmallVec<T::CallStack>,
+	/// Statically guarantee that each call stack has at least one frame.
+	first_frame: Frame<T>,
+	/// A text buffer used to output human readable information.
+	///
+	/// All the bytes added to this field should be valid UTF-8. The buffer has no defined
+	/// structure and is intended to be shown to users as-is for debugging purposes.
+	debug_message: Option<&'a mut DebugBufferVec<T>>,
+	/// The determinism requirement of this call stack.
+	determinism: Determinism,
+	/// No executable is held by the struct but influences its behaviour.
+	_phantom: PhantomData<E>,
+}
+
+/// Represents one entry in the call stack.
+///
+/// For each nested contract call or instantiate one frame is created. It holds specific
+/// information for the said call and caches the in-storage `ContractInfo` data structure.
+///
+/// # Note
+///
+/// This is an internal data structure. It is exposed to the public for the sole reason
+/// of specifying [`Config::CallStack`].
+pub struct Frame<T: Config> {
+	/// The account id of the executing contract.
+	account_id: T::AccountId,
+	/// The cached in-storage data of the contract.
+	contract_info: CachedContract<T>,
+	/// The amount of balance transferred by the caller as part of the call.
+	value_transferred: BalanceOf<T>,
+	/// Determines whether this is a call or instantiate frame.
+	entry_point: ExportedFunction,
+	/// The gas meter capped to the supplied gas limit.
+	nested_gas: GasMeter<T>,
+	/// The storage meter for the individual call.
+	nested_storage: storage::meter::NestedMeter<T>,
+	/// If `false` the contract enabled its defense against reentrance attacks.
+	allows_reentry: bool,
+	/// The caller of the currently executing frame which was spawned by `delegate_call`.
+	delegate_caller: Option<Origin<T>>,
+}
+
+/// Used in a delegate call frame arguments in order to override the executable and caller.
+struct DelegatedCall<T: Config, E> {
+	/// The executable which is run instead of the contracts own `executable`.
+	executable: E,
+	/// The caller of the contract.
+	caller: Origin<T>,
+}
+
+/// Parameter passed in when creating a new `Frame`.
+///
+/// It determines whether the new frame is for a call or an instantiate.
+enum FrameArgs<'a, T: Config, E> {
+	Call {
+		/// The account id of the contract that is to be called.
+		dest: T::AccountId,
+		/// If `None` the contract info needs to be reloaded from storage.
+		cached_info: Option<ContractInfo<T>>,
+		/// This frame was created by `seal_delegate_call` and hence uses different code than
+		/// what is stored at [`Self::Call::dest`]. Its caller ([`DelegatedCall::caller`]) is the
+		/// account which called the caller contract
+		delegated_call: Option<DelegatedCall<T, E>>,
+	},
+	Instantiate {
+		/// The contract or signed origin which instantiates the new contract.
+		sender: T::AccountId,
+		/// The nonce that should be used to derive a new trie id for the contract.
+		nonce: u64,
+		/// The executable whose `deploy` function is run.
+		executable: E,
+		/// A salt used in the contract address deriviation of the new contract.
+		salt: &'a [u8],
+		/// The input data is used in the contract address deriviation of the new contract.
+		input_data: &'a [u8],
+	},
+}
+
+/// Describes the different states of a contract as contained in a `Frame`.
+enum CachedContract<T: Config> {
+	/// The cached contract is up to date with the in-storage value.
+	Cached(ContractInfo<T>),
+	/// A recursive call into the same contract did write to the contract info.
+	///
+	/// In this case the cached contract is stale and needs to be reloaded from storage.
+	Invalidated,
+	/// The current contract executed `terminate` and removed the contract.
+	///
+	/// In this case a reload is neither allowed nor possible. Please note that recursive
+	/// calls cannot remove a contract as this is checked and denied.
+	Terminated,
+}
+
+impl<T: Config> CachedContract<T> {
+	/// Return `Some(ContractInfo)` if the contract is in cached state. `None` otherwise.
+	fn into_contract(self) -> Option<ContractInfo<T>> {
+		if let CachedContract::Cached(contract) = self {
+			Some(contract)
+		} else {
+			None
+		}
+	}
+
+	/// Return `Some(&mut ContractInfo)` if the contract is in cached state. `None` otherwise.
+	fn as_contract(&mut self) -> Option<&mut ContractInfo<T>> {
+		if let CachedContract::Cached(contract) = self {
+			Some(contract)
+		} else {
+			None
+		}
+	}
+}
+
+impl<T: Config> Frame<T> {
+	/// Return the `contract_info` of the current contract.
+	fn contract_info(&mut self) -> &mut ContractInfo<T> {
+		self.contract_info.get(&self.account_id)
+	}
+
+	/// Terminate and return the `contract_info` of the current contract.
+	///
+	/// # Note
+	///
+	/// Under no circumstances the contract is allowed to access the `contract_info` after
+	/// a call to this function. This would constitute a programming error in the exec module.
+	fn terminate(&mut self) -> ContractInfo<T> {
+		self.contract_info.terminate(&self.account_id)
+	}
+}
+
+/// Extract the contract info after loading it from storage.
+///
+/// This assumes that `load` was executed before calling this macro.
+macro_rules! get_cached_or_panic_after_load {
+	($c:expr) => {{
+		if let CachedContract::Cached(contract) = $c {
+			contract
+		} else {
+			panic!(
+				"It is impossible to remove a contract that is on the call stack;\
+				See implementations of terminate;\
+				Therefore fetching a contract will never fail while using an account id
+				that is currently active on the call stack;\
+				qed"
+			);
+		}
+	}};
+}
+
+/// Same as [`Stack::top_frame`].
+///
+/// We need this access as a macro because sometimes hiding the lifetimes behind
+/// a function won't work out.
+macro_rules! top_frame {
+	($stack:expr) => {
+		$stack.frames.last().unwrap_or(&$stack.first_frame)
+	};
+}
+
+/// Same as [`Stack::top_frame_mut`].
+///
+/// We need this access as a macro because sometimes hiding the lifetimes behind
+/// a function won't work out.
+macro_rules! top_frame_mut {
+	($stack:expr) => {
+		$stack.frames.last_mut().unwrap_or(&mut $stack.first_frame)
+	};
+}
+
+impl<T: Config> CachedContract<T> {
+	/// Load the `contract_info` from storage if necessary.
+	fn load(&mut self, account_id: &T::AccountId) {
+		if let CachedContract::Invalidated = self {
+			let contract = <ContractInfoOf<T>>::get(&account_id);
+			if let Some(contract) = contract {
+				*self = CachedContract::Cached(contract);
+			}
+		}
+	}
+
+	/// Return the cached contract_info.
+	fn get(&mut self, account_id: &T::AccountId) -> &mut ContractInfo<T> {
+		self.load(account_id);
+		get_cached_or_panic_after_load!(self)
+	}
+
+	/// Terminate and return the contract info.
+	fn terminate(&mut self, account_id: &T::AccountId) -> ContractInfo<T> {
+		self.load(account_id);
+		get_cached_or_panic_after_load!(mem::replace(self, Self::Terminated))
+	}
+}
+
+impl<'a, T, E> Stack<'a, T, E>
+where
+	T: Config,
+	E: Executable<T>,
+{
+	/// Create and run a new call stack by calling into `dest`.
+	///
+	/// # Note
+	///
+	/// `debug_message` should only ever be set to `Some` when executing as an RPC because
+	/// it adds allocations and could be abused to drive the runtime into an OOM panic.
+	///
+	/// # Return Value
+	///
+	/// Result<(ExecReturnValue, CodeSize), (ExecError, CodeSize)>
+	pub fn run_call(
+		origin: Origin<T>,
+		dest: T::AccountId,
+		gas_meter: &'a mut GasMeter<T>,
+		storage_meter: &'a mut storage::meter::Meter<T>,
+		schedule: &'a Schedule<T>,
+		value: BalanceOf<T>,
+		input_data: Vec<u8>,
+		debug_message: Option<&'a mut DebugBufferVec<T>>,
+		determinism: Determinism,
+	) -> Result<ExecReturnValue, ExecError> {
+		let (mut stack, executable) = Self::new(
+			FrameArgs::Call { dest, cached_info: None, delegated_call: None },
+			origin,
+			gas_meter,
+			storage_meter,
+			schedule,
+			value,
+			debug_message,
+			determinism,
+		)?;
+		stack.run(executable, input_data)
+	}
+
+	/// Create and run a new call stack by instantiating a new contract.
+	///
+	/// # Note
+	///
+	/// `debug_message` should only ever be set to `Some` when executing as an RPC because
+	/// it adds allocations and could be abused to drive the runtime into an OOM panic.
+	///
+	/// # Return Value
+	///
+	/// Result<(NewContractAccountId, ExecReturnValue), ExecError)>
+	pub fn run_instantiate(
+		origin: T::AccountId,
+		executable: E,
+		gas_meter: &'a mut GasMeter<T>,
+		storage_meter: &'a mut storage::meter::Meter<T>,
+		schedule: &'a Schedule<T>,
+		value: BalanceOf<T>,
+		input_data: Vec<u8>,
+		salt: &[u8],
+		debug_message: Option<&'a mut DebugBufferVec<T>>,
+	) -> Result<(T::AccountId, ExecReturnValue), ExecError> {
+		let (mut stack, executable) = Self::new(
+			FrameArgs::Instantiate {
+				sender: origin.clone(),
+				nonce: <Nonce<T>>::get().wrapping_add(1),
+				executable,
+				salt,
+				input_data: input_data.as_ref(),
+			},
+			Origin::from_account_id(origin),
+			gas_meter,
+			storage_meter,
+			schedule,
+			value,
+			debug_message,
+			Determinism::Enforced,
+		)?;
+		let account_id = stack.top_frame().account_id.clone();
+		stack.run(executable, input_data).map(|ret| (account_id, ret))
+	}
+
+	/// Create a new call stack.
+	fn new(
+		args: FrameArgs<T, E>,
+		origin: Origin<T>,
+		gas_meter: &'a mut GasMeter<T>,
+		storage_meter: &'a mut storage::meter::Meter<T>,
+		schedule: &'a Schedule<T>,
+		value: BalanceOf<T>,
+		debug_message: Option<&'a mut DebugBufferVec<T>>,
+		determinism: Determinism,
+	) -> Result<(Self, E), ExecError> {
+		let (first_frame, executable, nonce) = Self::new_frame(
+			args,
+			value,
+			gas_meter,
+			Weight::zero(),
+			storage_meter,
+			BalanceOf::<T>::zero(),
+			determinism,
+		)?;
+
+		let stack = Self {
+			origin,
+			schedule,
+			gas_meter,
+			storage_meter,
+			timestamp: T::Time::now(),
+			block_number: <frame_system::Pallet<T>>::block_number(),
+			nonce,
+			first_frame,
+			frames: Default::default(),
+			debug_message,
+			determinism,
+			_phantom: Default::default(),
+		};
+
+		Ok((stack, executable))
+	}
+
+	/// Construct a new frame.
+	///
+	/// This does not take `self` because when constructing the first frame `self` is
+	/// not initialized, yet.
+	fn new_frame<S: storage::meter::State + Default + Debug>(
+		frame_args: FrameArgs<T, E>,
+		value_transferred: BalanceOf<T>,
+		gas_meter: &mut GasMeter<T>,
+		gas_limit: Weight,
+		storage_meter: &mut storage::meter::GenericMeter<T, S>,
+		deposit_limit: BalanceOf<T>,
+		determinism: Determinism,
+	) -> Result<(Frame<T>, E, Option<u64>), ExecError> {
+		let (account_id, contract_info, executable, delegate_caller, entry_point, nonce) =
+			match frame_args {
+				FrameArgs::Call { dest, cached_info, delegated_call } => {
+					let contract = if let Some(contract) = cached_info {
+						contract
+					} else {
+						<ContractInfoOf<T>>::get(&dest).ok_or(<Error<T>>::ContractNotFound)?
+					};
+
+					let (executable, delegate_caller) =
+						if let Some(DelegatedCall { executable, caller }) = delegated_call {
+							(executable, Some(caller))
+						} else {
+							(E::from_storage(contract.code_hash, gas_meter)?, None)
+						};
+
+					(dest, contract, executable, delegate_caller, ExportedFunction::Call, None)
+				},
+				FrameArgs::Instantiate { sender, nonce, executable, salt, input_data } => {
+					let account_id = Contracts::<T>::contract_address(
+						&sender,
+						&executable.code_hash(),
+						input_data,
+						salt,
+					);
+					let contract = ContractInfo::new(&account_id, nonce, *executable.code_hash())?;
+					(
+						account_id,
+						contract,
+						executable,
+						None,
+						ExportedFunction::Constructor,
+						Some(nonce),
+					)
+				},
+			};
+
+		// `Relaxed` will only be ever set in case of off-chain execution.
+		// Instantiations are never allowed even when executing off-chain.
+		if !(executable.is_deterministic() ||
+			(matches!(determinism, Determinism::Relaxed) &&
+				matches!(entry_point, ExportedFunction::Call)))
+		{
+			return Err(Error::<T>::Indeterministic.into())
+		}
+
+		let frame = Frame {
+			delegate_caller,
+			value_transferred,
+			contract_info: CachedContract::Cached(contract_info),
+			account_id,
+			entry_point,
+			nested_gas: gas_meter.nested(gas_limit)?,
+			nested_storage: storage_meter.nested(deposit_limit),
+			allows_reentry: true,
+		};
+
+		Ok((frame, executable, nonce))
+	}
+
+	/// Create a subsequent nested frame.
+	fn push_frame(
+		&mut self,
+		frame_args: FrameArgs<T, E>,
+		value_transferred: BalanceOf<T>,
+		gas_limit: Weight,
+		deposit_limit: BalanceOf<T>,
+	) -> Result<E, ExecError> {
+		if self.frames.len() == T::CallStack::size() {
+			return Err(Error::<T>::MaxCallDepthReached.into())
+		}
+
+		// We need to make sure that changes made to the contract info are not discarded.
+		// See the `in_memory_changes_not_discarded` test for more information.
+		// We do not store on instantiate because we do not allow to call into a contract
+		// from its own constructor.
+		let frame = self.top_frame();
+		if let (CachedContract::Cached(contract), ExportedFunction::Call) =
+			(&frame.contract_info, frame.entry_point)
+		{
+			<ContractInfoOf<T>>::insert(frame.account_id.clone(), contract.clone());
+		}
+
+		let frame = top_frame_mut!(self);
+		let nested_gas = &mut frame.nested_gas;
+		let nested_storage = &mut frame.nested_storage;
+		let (frame, executable, _) = Self::new_frame(
+			frame_args,
+			value_transferred,
+			nested_gas,
+			gas_limit,
+			nested_storage,
+			deposit_limit,
+			self.determinism,
+		)?;
+		self.frames.push(frame);
+		Ok(executable)
+	}
+
+	/// Run the current (top) frame.
+	///
+	/// This can be either a call or an instantiate.
+	fn run(&mut self, executable: E, input_data: Vec<u8>) -> Result<ExecReturnValue, ExecError> {
+		let frame = self.top_frame();
+		let entry_point = frame.entry_point;
+		let delegated_code_hash =
+			if frame.delegate_caller.is_some() { Some(*executable.code_hash()) } else { None };
+		let do_transaction = || {
+			// We need to charge the storage deposit before the initial transfer so that
+			// it can create the account in case the initial transfer is < ed.
+			if entry_point == ExportedFunction::Constructor {
+				// Root origin can't be used to instantiate a contract, so it is safe to assume that
+				// if we reached this point the origin has an associated account.
+				let origin = &self.origin.account_id()?;
+				let frame = top_frame_mut!(self);
+				frame.nested_storage.charge_instantiate(
+					origin,
+					&frame.account_id,
+					frame.contract_info.get(&frame.account_id),
+					executable.code_info(),
+				)?;
+			}
+
+			// Every non delegate call or instantiate also optionally transfers the balance.
+			self.initial_transfer()?;
+
+			let call_span =
+				T::Debug::new_call_span(executable.code_hash(), entry_point, &input_data);
+
+			// Call into the Wasm blob.
+			let output = executable
+				.execute(self, &entry_point, input_data)
+				.map_err(|e| ExecError { error: e.error, origin: ErrorOrigin::Callee })?;
+
+			call_span.after_call(&output);
+
+			// Avoid useless work that would be reverted anyways.
+			if output.did_revert() {
+				return Ok(output)
+			}
+
+			// Storage limit is normally enforced as late as possible (when the last frame returns)
+			// so that the ordering of storage accesses does not matter.
+			// (However, if a special limit was set for a sub-call, it should be enforced right
+			// after the sub-call returned. See below for this case of enforcement).
+			if self.frames.is_empty() {
+				let frame = &mut self.first_frame;
+				frame.contract_info.load(&frame.account_id);
+				let contract = frame.contract_info.as_contract();
+				frame.nested_storage.enforce_limit(contract)?;
+			}
+
+			let frame = self.top_frame();
+			let account_id = &frame.account_id.clone();
+			match (entry_point, delegated_code_hash) {
+				(ExportedFunction::Constructor, _) => {
+					// It is not allowed to terminate a contract inside its constructor.
+					if matches!(frame.contract_info, CachedContract::Terminated) {
+						return Err(Error::<T>::TerminatedInConstructor.into())
+					}
+
+					// If a special limit was set for the sub-call, we enforce it here.
+					// This is needed because contract constructor might write to storage.
+					// The sub-call will be rolled back in case the limit is exhausted.
+					let frame = self.top_frame_mut();
+					let contract = frame.contract_info.as_contract();
+					frame.nested_storage.enforce_subcall_limit(contract)?;
+
+					let caller = self.caller().account_id()?.clone();
+
+					// Deposit an instantiation event.
+					Contracts::<T>::deposit_event(
+						vec![T::Hashing::hash_of(&caller), T::Hashing::hash_of(account_id)],
+						Event::Instantiated { deployer: caller, contract: account_id.clone() },
+					);
+				},
+				(ExportedFunction::Call, Some(code_hash)) => {
+					Contracts::<T>::deposit_event(
+						vec![T::Hashing::hash_of(account_id), T::Hashing::hash_of(&code_hash)],
+						Event::DelegateCalled { contract: account_id.clone(), code_hash },
+					);
+				},
+				(ExportedFunction::Call, None) => {
+					// If a special limit was set for the sub-call, we enforce it here.
+					// The sub-call will be rolled back in case the limit is exhausted.
+					let frame = self.top_frame_mut();
+					let contract = frame.contract_info.as_contract();
+					frame.nested_storage.enforce_subcall_limit(contract)?;
+
+					let caller = self.caller();
+					Contracts::<T>::deposit_event(
+						vec![T::Hashing::hash_of(&caller), T::Hashing::hash_of(&account_id)],
+						Event::Called { caller: caller.clone(), contract: account_id.clone() },
+					);
+				},
+			}
+
+			Ok(output)
+		};
+
+		// All changes performed by the contract are executed under a storage transaction.
+		// This allows for roll back on error. Changes to the cached contract_info are
+		// committed or rolled back when popping the frame.
+		//
+		// `with_transactional` may return an error caused by a limit in the
+		// transactional storage depth.
+		let transaction_outcome =
+			with_transaction(|| -> TransactionOutcome<Result<_, DispatchError>> {
+				let output = do_transaction();
+				match &output {
+					Ok(result) if !result.did_revert() =>
+						TransactionOutcome::Commit(Ok((true, output))),
+					_ => TransactionOutcome::Rollback(Ok((false, output))),
+				}
+			});
+
+		let (success, output) = match transaction_outcome {
+			// `with_transactional` executed successfully, and we have the expected output.
+			Ok((success, output)) => (success, output),
+			// `with_transactional` returned an error, and we propagate that error and note no state
+			// has changed.
+			Err(error) => (false, Err(error.into())),
+		};
+
+		self.pop_frame(success);
+		output
+	}
+
+	/// Remove the current (top) frame from the stack.
+	///
+	/// This is called after running the current frame. It commits cached values to storage
+	/// and invalidates all stale references to it that might exist further down the call stack.
+	fn pop_frame(&mut self, persist: bool) {
+		// Revert changes to the nonce in case of a failed instantiation.
+		if !persist && self.top_frame().entry_point == ExportedFunction::Constructor {
+			self.nonce.as_mut().map(|c| *c = c.wrapping_sub(1));
+		}
+
+		// Pop the current frame from the stack and return it in case it needs to interact
+		// with duplicates that might exist on the stack.
+		// A `None` means that we are returning from the `first_frame`.
+		let frame = self.frames.pop();
+
+		// Both branches do essentially the same with the exception. The difference is that
+		// the else branch does consume the hardcoded `first_frame`.
+		if let Some(mut frame) = frame {
+			let account_id = &frame.account_id;
+			let prev = top_frame_mut!(self);
+
+			prev.nested_gas.absorb_nested(frame.nested_gas);
+
+			// Only gas counter changes are persisted in case of a failure.
+			if !persist {
+				return
+			}
+
+			// Record the storage meter changes of the nested call into the parent meter.
+			// If the dropped frame's contract wasn't terminated we update the deposit counter
+			// in its contract info. The load is necessary to pull it from storage in case
+			// it was invalidated.
+			frame.contract_info.load(account_id);
+			let mut contract = frame.contract_info.into_contract();
+			prev.nested_storage.absorb(frame.nested_storage, account_id, contract.as_mut());
+
+			// In case the contract wasn't terminated we need to persist changes made to it.
+			if let Some(contract) = contract {
+				// optimization: Predecessor is the same contract.
+				// We can just copy the contract into the predecessor without a storage write.
+				// This is possible when there is no other contract in-between that could
+				// trigger a rollback.
+				if prev.account_id == *account_id {
+					prev.contract_info = CachedContract::Cached(contract);
+					return
+				}
+
+				// Predecessor is a different contract: We persist the info and invalidate the first
+				// stale cache we find. This triggers a reload from storage on next use. We skip(1)
+				// because that case is already handled by the optimization above. Only the first
+				// cache needs to be invalidated because that one will invalidate the next cache
+				// when it is popped from the stack.
+				<ContractInfoOf<T>>::insert(account_id, contract);
+				if let Some(c) = self.frames_mut().skip(1).find(|f| f.account_id == *account_id) {
+					c.contract_info = CachedContract::Invalidated;
+				}
+			}
+		} else {
+			if let Some((msg, false)) = self.debug_message.as_ref().map(|m| (m, m.is_empty())) {
+				log::debug!(
+					target: LOG_TARGET,
+					"Execution finished with debug buffer: {}",
+					core::str::from_utf8(msg).unwrap_or("<Invalid UTF8>"),
+				);
+			}
+			self.gas_meter.absorb_nested(mem::take(&mut self.first_frame.nested_gas));
+			if !persist {
+				return
+			}
+			let mut contract = self.first_frame.contract_info.as_contract();
+			self.storage_meter.absorb(
+				mem::take(&mut self.first_frame.nested_storage),
+				&self.first_frame.account_id,
+				contract.as_deref_mut(),
+			);
+			if let Some(contract) = contract {
+				<ContractInfoOf<T>>::insert(&self.first_frame.account_id, contract);
+			}
+			if let Some(nonce) = self.nonce {
+				<Nonce<T>>::set(nonce);
+			}
+		}
+	}
+
+	/// Transfer some funds from `from` to `to`.
+	fn transfer(
+		preservation: Preservation,
+		from: &T::AccountId,
+		to: &T::AccountId,
+		value: BalanceOf<T>,
+	) -> DispatchResult {
+		if !value.is_zero() && from != to {
+			T::Currency::transfer(from, to, value, preservation)
+				.map_err(|_| Error::<T>::TransferFailed)?;
+		}
+		Ok(())
+	}
+
+	// The transfer as performed by a call or instantiate.
+	fn initial_transfer(&self) -> DispatchResult {
+		let frame = self.top_frame();
+
+		// If it is a delegate call, then we've already transferred tokens in the
+		// last non-delegate frame.
+		if frame.delegate_caller.is_some() {
+			return Ok(())
+		}
+
+		let value = frame.value_transferred;
+
+		// Get the account id from the caller.
+		// If the caller is root there is no account to transfer from, and therefore we can't take
+		// any `value` other than 0.
+		let caller = match self.caller() {
+			Origin::Signed(caller) => caller,
+			Origin::Root if value.is_zero() => return Ok(()),
+			Origin::Root => return DispatchError::RootNotAllowed.into(),
+		};
+		Self::transfer(Preservation::Preserve, &caller, &frame.account_id, value)
+	}
+
+	/// Reference to the current (top) frame.
+	fn top_frame(&self) -> &Frame<T> {
+		top_frame!(self)
+	}
+
+	/// Mutable reference to the current (top) frame.
+	fn top_frame_mut(&mut self) -> &mut Frame<T> {
+		top_frame_mut!(self)
+	}
+
+	/// Iterator over all frames.
+	///
+	/// The iterator starts with the top frame and ends with the root frame.
+	fn frames(&self) -> impl Iterator<Item = &Frame<T>> {
+		sp_std::iter::once(&self.first_frame).chain(&self.frames).rev()
+	}
+
+	/// Same as `frames` but with a mutable reference as iterator item.
+	fn frames_mut(&mut self) -> impl Iterator<Item = &mut Frame<T>> {
+		sp_std::iter::once(&mut self.first_frame).chain(&mut self.frames).rev()
+	}
+
+	/// Returns whether the current contract is on the stack multiple times.
+	fn is_recursive(&self) -> bool {
+		let account_id = &self.top_frame().account_id;
+		self.frames().skip(1).any(|f| &f.account_id == account_id)
+	}
+
+	/// Returns whether the specified contract allows to be reentered right now.
+	fn allows_reentry(&self, id: &AccountIdOf<T>) -> bool {
+		!self.frames().any(|f| &f.account_id == id && !f.allows_reentry)
+	}
+
+	/// Increments and returns the next nonce. Pulls it from storage if it isn't in cache.
+	fn next_nonce(&mut self) -> u64 {
+		let next = self.nonce().wrapping_add(1);
+		self.nonce = Some(next);
+		next
+	}
+}
+
+impl<'a, T, E> Ext for Stack<'a, T, E>
+where
+	T: Config,
+	E: Executable<T>,
+{
+	type T = T;
+
+	fn call(
+		&mut self,
+		gas_limit: Weight,
+		deposit_limit: BalanceOf<T>,
+		to: T::AccountId,
+		value: BalanceOf<T>,
+		input_data: Vec<u8>,
+		allows_reentry: 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
+		// is caught by it.
+		self.top_frame_mut().allows_reentry = allows_reentry;
+
+		let try_call = || {
+			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.
+			let cached_info = self
+				.frames()
+				.find(|f| f.entry_point == ExportedFunction::Call && f.account_id == to)
+				.and_then(|f| match &f.contract_info {
+					CachedContract::Cached(contract) => Some(contract.clone()),
+					_ => None,
+				});
+			let executable = self.push_frame(
+				FrameArgs::Call { dest: to, cached_info, delegated_call: None },
+				value,
+				gas_limit,
+				deposit_limit,
+			)?;
+			self.run(executable, input_data)
+		};
+
+		// We need to make sure to reset `allows_reentry` even on failure.
+		let result = try_call();
+
+		// Protection is on a per call basis.
+		self.top_frame_mut().allows_reentry = true;
+
+		result
+	}
+
+	fn delegate_call(
+		&mut self,
+		code_hash: CodeHash<Self::T>,
+		input_data: Vec<u8>,
+	) -> Result<ExecReturnValue, ExecError> {
+		let executable = E::from_storage(code_hash, self.gas_meter_mut())?;
+		let top_frame = self.top_frame_mut();
+		let contract_info = top_frame.contract_info().clone();
+		let account_id = top_frame.account_id.clone();
+		let value = top_frame.value_transferred;
+		let executable = self.push_frame(
+			FrameArgs::Call {
+				dest: account_id,
+				cached_info: Some(contract_info),
+				delegated_call: Some(DelegatedCall { executable, caller: self.caller().clone() }),
+			},
+			value,
+			Weight::zero(),
+			BalanceOf::<T>::zero(),
+		)?;
+		self.run(executable, input_data)
+	}
+
+	fn instantiate(
+		&mut self,
+		gas_limit: Weight,
+		deposit_limit: BalanceOf<Self::T>,
+		code_hash: CodeHash<T>,
+		value: BalanceOf<T>,
+		input_data: Vec<u8>,
+		salt: &[u8],
+	) -> Result<(AccountIdOf<T>, ExecReturnValue), ExecError> {
+		let executable = E::from_storage(code_hash, self.gas_meter_mut())?;
+		let nonce = self.next_nonce();
+		let executable = self.push_frame(
+			FrameArgs::Instantiate {
+				sender: self.top_frame().account_id.clone(),
+				nonce,
+				executable,
+				salt,
+				input_data: input_data.as_ref(),
+			},
+			value,
+			gas_limit,
+			deposit_limit,
+		)?;
+		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> {
+		if self.is_recursive() {
+			return Err(Error::<T>::TerminatedWhileReentrant.into())
+		}
+		let frame = self.top_frame_mut();
+		let info = frame.terminate();
+		frame.nested_storage.terminate(&info, beneficiary.clone());
+
+		info.queue_trie_for_deletion();
+		ContractInfoOf::<T>::remove(&frame.account_id);
+		E::decrement_refcount(info.code_hash);
+
+		for (code_hash, deposit) in info.delegate_dependencies() {
+			E::decrement_refcount(*code_hash);
+			frame
+				.nested_storage
+				.charge_deposit(frame.account_id.clone(), StorageDeposit::Refund(*deposit));
+		}
+
+		Contracts::<T>::deposit_event(
+			vec![T::Hashing::hash_of(&frame.account_id), T::Hashing::hash_of(&beneficiary)],
+			Event::Terminated {
+				contract: frame.account_id.clone(),
+				beneficiary: beneficiary.clone(),
+			},
+		);
+		Ok(())
+	}
+
+	fn transfer(&mut self, to: &T::AccountId, value: BalanceOf<T>) -> DispatchResult {
+		Self::transfer(Preservation::Preserve, &self.top_frame().account_id, to, value)
+	}
+
+	fn get_storage(&mut self, key: &Key<T>) -> Option<Vec<u8>> {
+		self.top_frame_mut().contract_info().read(key)
+	}
+
+	fn get_storage_size(&mut self, key: &Key<T>) -> Option<u32> {
+		self.top_frame_mut().contract_info().size(key.into())
+	}
+
+	fn set_storage(
+		&mut self,
+		key: &Key<T>,
+		value: Option<Vec<u8>>,
+		take_old: bool,
+	) -> Result<WriteOutcome, DispatchError> {
+		let frame = self.top_frame_mut();
+		frame.contract_info.get(&frame.account_id).write(
+			key.into(),
+			value,
+			Some(&mut frame.nested_storage),
+			take_old,
+		)
+	}
+
+	fn address(&self) -> &T::AccountId {
+		&self.top_frame().account_id
+	}
+
+	fn caller(&self) -> Origin<T> {
+		if let Some(caller) = &self.top_frame().delegate_caller {
+			caller.clone()
+		} else {
+			self.frames()
+				.nth(1)
+				.map(|f| Origin::from_account_id(f.account_id.clone()))
+				.unwrap_or(self.origin.clone())
+		}
+	}
+
+	fn is_contract(&self, address: &T::AccountId) -> bool {
+		ContractInfoOf::<T>::contains_key(&address)
+	}
+
+	fn code_hash(&self, address: &T::AccountId) -> Option<CodeHash<Self::T>> {
+		<ContractInfoOf<T>>::get(&address).map(|contract| contract.code_hash)
+	}
+
+	fn own_code_hash(&mut self) -> &CodeHash<Self::T> {
+		&self.top_frame_mut().contract_info().code_hash
+	}
+
+	fn caller_is_origin(&self) -> bool {
+		self.origin == self.caller()
+	}
+
+	fn caller_is_root(&self) -> bool {
+		// if the caller isn't origin, then it can't be root.
+		self.caller_is_origin() && self.origin == Origin::Root
+	}
+
+	fn balance(&self) -> BalanceOf<T> {
+		T::Currency::balance(&self.top_frame().account_id)
+	}
+
+	fn value_transferred(&self) -> BalanceOf<T> {
+		self.top_frame().value_transferred
+	}
+
+	fn random(&self, subject: &[u8]) -> (SeedOf<T>, BlockNumberFor<T>) {
+		T::Randomness::random(subject)
+	}
+
+	fn now(&self) -> &MomentOf<T> {
+		&self.timestamp
+	}
+
+	fn minimum_balance(&self) -> BalanceOf<T> {
+		T::Currency::minimum_balance()
+	}
+
+	fn deposit_event(&mut self, topics: Vec<T::Hash>, data: Vec<u8>) {
+		Contracts::<Self::T>::deposit_event(
+			topics,
+			Event::ContractEmitted { contract: self.top_frame().account_id.clone(), data },
+		);
+	}
+
+	fn block_number(&self) -> BlockNumberFor<T> {
+		self.block_number
+	}
+
+	fn max_value_size(&self) -> u32 {
+		self.schedule.limits.payload_len
+	}
+
+	fn get_weight_price(&self, weight: Weight) -> BalanceOf<Self::T> {
+		T::WeightPrice::convert(weight)
+	}
+
+	fn schedule(&self) -> &Schedule<Self::T> {
+		self.schedule
+	}
+
+	fn gas_meter(&self) -> &GasMeter<Self::T> {
+		&self.top_frame().nested_gas
+	}
+
+	fn gas_meter_mut(&mut self) -> &mut GasMeter<Self::T> {
+		&mut self.top_frame_mut().nested_gas
+	}
+
+	fn charge_storage(&mut self, diff: &Diff) {
+		self.top_frame_mut().nested_storage.charge(diff)
+	}
+
+	fn append_debug_buffer(&mut self, msg: &str) -> bool {
+		if let Some(buffer) = &mut self.debug_message {
+			buffer
+				.try_extend(&mut msg.bytes())
+				.map_err(|_| {
+					log::debug!(
+						target: LOG_TARGET,
+						"Debug buffer (of {} bytes) exhausted!",
+						DebugBufferVec::<T>::bound(),
+					)
+				})
+				.ok();
+			true
+		} else {
+			false
+		}
+	}
+
+	fn call_runtime(&self, call: <Self::T as Config>::RuntimeCall) -> DispatchResultWithPostInfo {
+		let mut origin: T::RuntimeOrigin = RawOrigin::Signed(self.address().clone()).into();
+		origin.add_filter(T::CallFilter::contains);
+		call.dispatch(origin)
+	}
+
+	fn ecdsa_recover(&self, signature: &[u8; 65], message_hash: &[u8; 32]) -> Result<[u8; 33], ()> {
+		secp256k1_ecdsa_recover_compressed(signature, message_hash).map_err(|_| ())
+	}
+
+	fn sr25519_verify(&self, signature: &[u8; 64], message: &[u8], pub_key: &[u8; 32]) -> bool {
+		sp_io::crypto::sr25519_verify(
+			&SR25519Signature(*signature),
+			message,
+			&SR25519Public(*pub_key),
+		)
+	}
+
+	fn ecdsa_to_eth_address(&self, pk: &[u8; 33]) -> Result<[u8; 20], ()> {
+		ECDSAPublic(*pk).to_eth_address()
+	}
+
+	#[cfg(test)]
+	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> {
+		let frame = top_frame_mut!(self);
+		if !E::from_storage(hash, &mut frame.nested_gas)?.is_deterministic() {
+			return Err(<Error<T>>::Indeterministic.into())
+		}
+
+		let info = frame.contract_info();
+
+		let prev_hash = info.code_hash;
+		info.code_hash = hash;
+
+		let code_info = CodeInfoOf::<T>::get(hash).ok_or(Error::<T>::CodeNotFound)?;
+
+		let old_base_deposit = info.storage_base_deposit();
+		let new_base_deposit = info.update_base_deposit(&code_info);
+		let deposit = StorageDeposit::Charge(new_base_deposit)
+			.saturating_sub(&StorageDeposit::Charge(old_base_deposit));
+
+		frame.nested_storage.charge_deposit(frame.account_id.clone(), deposit);
+
+		E::increment_refcount(hash)?;
+		E::decrement_refcount(prev_hash);
+		Contracts::<Self::T>::deposit_event(
+			vec![T::Hashing::hash_of(&frame.account_id), hash, prev_hash],
+			Event::ContractCodeUpdated {
+				contract: frame.account_id.clone(),
+				new_code_hash: hash,
+				old_code_hash: prev_hash,
+			},
+		);
+		Ok(())
+	}
+
+	fn reentrance_count(&self) -> u32 {
+		let id: &AccountIdOf<Self::T> = &self.top_frame().account_id;
+		self.account_reentrance_count(id).saturating_sub(1)
+	}
+
+	fn account_reentrance_count(&self, account_id: &AccountIdOf<Self::T>) -> u32 {
+		self.frames()
+			.filter(|f| f.delegate_caller.is_none() && &f.account_id == account_id)
+			.count() as u32
+	}
+
+	fn nonce(&mut self) -> u64 {
+		if let Some(current) = self.nonce {
+			current
+		} else {
+			let current = <Nonce<T>>::get();
+			self.nonce = Some(current);
+			current
+		}
+	}
+
+	fn add_delegate_dependency(
+		&mut self,
+		code_hash: CodeHash<Self::T>,
+	) -> Result<(), DispatchError> {
+		let frame = self.top_frame_mut();
+		let info = frame.contract_info.get(&frame.account_id);
+		ensure!(code_hash != info.code_hash, Error::<T>::CannotAddSelfAsDelegateDependency);
+
+		let code_info = CodeInfoOf::<T>::get(code_hash).ok_or(Error::<T>::CodeNotFound)?;
+		let deposit = T::CodeHashLockupDepositPercent::get().mul_ceil(code_info.deposit());
+
+		info.add_delegate_dependency(code_hash, deposit)?;
+		<WasmBlob<T>>::increment_refcount(code_hash)?;
+		frame
+			.nested_storage
+			.charge_deposit(frame.account_id.clone(), StorageDeposit::Charge(deposit));
+		Ok(())
+	}
+
+	fn remove_delegate_dependency(
+		&mut self,
+		code_hash: &CodeHash<Self::T>,
+	) -> Result<(), DispatchError> {
+		let frame = self.top_frame_mut();
+		let info = frame.contract_info.get(&frame.account_id);
+
+		let deposit = info.remove_delegate_dependency(code_hash)?;
+		<WasmBlob<T>>::decrement_refcount(*code_hash);
+
+		frame
+			.nested_storage
+			.charge_deposit(frame.account_id.clone(), StorageDeposit::Refund(deposit));
+		Ok(())
+	}
+}
+
+mod sealing {
+	use super::*;
+
+	pub trait Sealed {}
+
+	impl<'a, T: Config, E> Sealed for Stack<'a, T, E> {}
+
+	#[cfg(test)]
+	impl Sealed for crate::wasm::MockExt {}
+
+	#[cfg(test)]
+	impl Sealed for &mut crate::wasm::MockExt {}
+}
+
+/// These tests exercise the executive layer.
+///
+/// In these tests the VM/loader are mocked. Instead of dealing with wasm bytecode they use simple
+/// closures. This allows you to tackle executive logic more thoroughly without writing a
+/// wasm VM code.
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		exec::ExportedFunction::*,
+		gas::GasMeter,
+		tests::{
+			test_utils::{get_balance, hash, place_contract, set_balance},
+			ExtBuilder, RuntimeCall, RuntimeEvent as MetaEvent, Test, TestFilter, ALICE, BOB,
+			CHARLIE, GAS_LIMIT,
+		},
+		Error,
+	};
+	use assert_matches::assert_matches;
+	use codec::{Decode, Encode};
+	use frame_support::{assert_err, assert_ok, parameter_types};
+	use frame_system::{EventRecord, Phase};
+	use pallet_contracts_primitives::ReturnFlags;
+	use pretty_assertions::assert_eq;
+	use sp_runtime::{traits::Hash, DispatchError};
+	use std::{
+		cell::RefCell,
+		collections::hash_map::{Entry, HashMap},
+		rc::Rc,
+	};
+
+	type System = frame_system::Pallet<Test>;
+
+	type MockStack<'a> = Stack<'a, Test, MockExecutable>;
+
+	parameter_types! {
+		static Loader: MockLoader = MockLoader::default();
+	}
+
+	fn events() -> Vec<Event<Test>> {
+		System::events()
+			.into_iter()
+			.filter_map(|meta| match meta.event {
+				MetaEvent::Contracts(contract_event) => Some(contract_event),
+				_ => None,
+			})
+			.collect()
+	}
+
+	struct MockCtx<'a> {
+		ext: &'a mut dyn Ext<T = Test>,
+		input_data: Vec<u8>,
+	}
+
+	#[derive(Clone)]
+	struct MockExecutable {
+		func: Rc<dyn Fn(MockCtx, &Self) -> ExecResult + 'static>,
+		func_type: ExportedFunction,
+		code_hash: CodeHash<Test>,
+		code_info: CodeInfo<Test>,
+		refcount: u64,
+	}
+
+	#[derive(Default, Clone)]
+	pub struct MockLoader {
+		map: HashMap<CodeHash<Test>, MockExecutable>,
+		counter: u64,
+	}
+
+	impl MockLoader {
+		fn code_hashes() -> Vec<CodeHash<Test>> {
+			Loader::get().map.keys().copied().collect()
+		}
+
+		fn insert(
+			func_type: ExportedFunction,
+			f: impl Fn(MockCtx, &MockExecutable) -> ExecResult + 'static,
+		) -> CodeHash<Test> {
+			Loader::mutate(|loader| {
+				// Generate code hashes as monotonically increasing values.
+				let hash = <Test as frame_system::Config>::Hash::from_low_u64_be(loader.counter);
+				loader.counter += 1;
+				loader.map.insert(
+					hash,
+					MockExecutable {
+						func: Rc::new(f),
+						func_type,
+						code_hash: hash,
+						code_info: CodeInfo::<Test>::new(ALICE),
+						refcount: 1,
+					},
+				);
+				hash
+			})
+		}
+
+		fn increment_refcount(code_hash: CodeHash<Test>) -> Result<(), DispatchError> {
+			Loader::mutate(|loader| {
+				match loader.map.entry(code_hash) {
+					Entry::Vacant(_) => Err(<Error<Test>>::CodeNotFound)?,
+					Entry::Occupied(mut entry) => entry.get_mut().refcount += 1,
+				}
+				Ok(())
+			})
+		}
+
+		fn decrement_refcount(code_hash: CodeHash<Test>) {
+			use std::collections::hash_map::Entry::Occupied;
+			Loader::mutate(|loader| {
+				let mut entry = match loader.map.entry(code_hash) {
+					Occupied(e) => e,
+					_ => panic!("code_hash does not exist"),
+				};
+				let refcount = &mut entry.get_mut().refcount;
+				*refcount -= 1;
+				if *refcount == 0 {
+					entry.remove();
+				}
+			});
+		}
+	}
+
+	impl Executable<Test> for MockExecutable {
+		fn from_storage(
+			code_hash: CodeHash<Test>,
+			_gas_meter: &mut GasMeter<Test>,
+		) -> Result<Self, DispatchError> {
+			Loader::mutate(|loader| {
+				loader.map.get(&code_hash).cloned().ok_or(Error::<Test>::CodeNotFound.into())
+			})
+		}
+
+		fn increment_refcount(code_hash: CodeHash<Test>) -> Result<(), DispatchError> {
+			MockLoader::increment_refcount(code_hash)
+		}
+
+		fn decrement_refcount(code_hash: CodeHash<Test>) {
+			MockLoader::decrement_refcount(code_hash);
+		}
+
+		fn execute<E: Ext<T = Test>>(
+			self,
+			ext: &mut E,
+			function: &ExportedFunction,
+			input_data: Vec<u8>,
+		) -> ExecResult {
+			if let &Constructor = function {
+				Self::increment_refcount(self.code_hash).unwrap();
+			}
+			if function == &self.func_type {
+				(self.func)(MockCtx { ext, input_data }, &self)
+			} else {
+				exec_success()
+			}
+		}
+
+		fn code_hash(&self) -> &CodeHash<Test> {
+			&self.code_hash
+		}
+
+		fn code_info(&self) -> &CodeInfo<Test> {
+			&self.code_info
+		}
+
+		fn code_len(&self) -> u32 {
+			0
+		}
+
+		fn is_deterministic(&self) -> bool {
+			true
+		}
+	}
+
+	fn exec_success() -> ExecResult {
+		Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() })
+	}
+
+	fn exec_trapped() -> ExecResult {
+		Err(ExecError { error: <Error<Test>>::ContractTrapped.into(), origin: ErrorOrigin::Callee })
+	}
+
+	#[test]
+	fn it_works() {
+		parameter_types! {
+			static TestData: Vec<usize> = vec![0];
+		}
+
+		let value = Default::default();
+		let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+		let exec_ch = MockLoader::insert(Call, |_ctx, _executable| {
+			TestData::mutate(|data| data.push(1));
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, exec_ch);
+			let mut storage_meter =
+				storage::meter::Meter::new(&Origin::from_account_id(ALICE), Some(0), value)
+					.unwrap();
+
+			assert_matches!(
+				MockStack::run_call(
+					Origin::from_account_id(ALICE),
+					BOB,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					value,
+					vec![],
+					None,
+					Determinism::Enforced,
+				),
+				Ok(_)
+			);
+		});
+
+		assert_eq!(TestData::get(), vec![0, 1]);
+	}
+
+	#[test]
+	fn transfer_works() {
+		// This test verifies that a contract is able to transfer
+		// some funds to another account.
+		let origin = ALICE;
+		let dest = BOB;
+
+		ExtBuilder::default().build().execute_with(|| {
+			set_balance(&origin, 100);
+			set_balance(&dest, 0);
+
+			MockStack::transfer(Preservation::Preserve, &origin, &dest, 55).unwrap();
+
+			assert_eq!(get_balance(&origin), 45);
+			assert_eq!(get_balance(&dest), 55);
+		});
+	}
+
+	#[test]
+	fn correct_transfer_on_call() {
+		let origin = ALICE;
+		let dest = BOB;
+		let value = 55;
+
+		let success_ch = MockLoader::insert(Call, move |ctx, _| {
+			assert_eq!(ctx.ext.value_transferred(), value);
+			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() })
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&dest, success_ch);
+			set_balance(&origin, 100);
+			let balance = get_balance(&dest);
+			let contract_origin = Origin::from_account_id(origin.clone());
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), value).unwrap();
+
+			let _ = MockStack::run_call(
+				contract_origin.clone(),
+				dest.clone(),
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				value,
+				vec![],
+				None,
+				Determinism::Enforced,
+			)
+			.unwrap();
+
+			assert_eq!(get_balance(&origin), 100 - value);
+			assert_eq!(get_balance(&dest), balance + value);
+		});
+	}
+
+	#[test]
+	fn correct_transfer_on_delegate_call() {
+		let origin = ALICE;
+		let dest = BOB;
+		let value = 35;
+
+		let success_ch = MockLoader::insert(Call, move |ctx, _| {
+			assert_eq!(ctx.ext.value_transferred(), value);
+			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() })
+		});
+
+		let delegate_ch = MockLoader::insert(Call, move |ctx, _| {
+			assert_eq!(ctx.ext.value_transferred(), value);
+			let _ = ctx.ext.delegate_call(success_ch, Vec::new())?;
+			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() })
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&dest, delegate_ch);
+			set_balance(&origin, 100);
+			let balance = get_balance(&dest);
+			let contract_origin = Origin::from_account_id(origin.clone());
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 55).unwrap();
+
+			let _ = MockStack::run_call(
+				contract_origin.clone(),
+				dest.clone(),
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				value,
+				vec![],
+				None,
+				Determinism::Enforced,
+			)
+			.unwrap();
+
+			assert_eq!(get_balance(&origin), 100 - value);
+			assert_eq!(get_balance(&dest), balance + value);
+		});
+	}
+
+	#[test]
+	fn changes_are_reverted_on_failing_call() {
+		// This test verifies that changes are reverted on a call which fails (or equally, returns
+		// a non-zero status code).
+		let origin = ALICE;
+		let dest = BOB;
+
+		let return_ch = MockLoader::insert(Call, |_, _| {
+			Ok(ExecReturnValue { flags: ReturnFlags::REVERT, data: Vec::new() })
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&dest, return_ch);
+			set_balance(&origin, 100);
+			let balance = get_balance(&dest);
+			let contract_origin = Origin::from_account_id(origin.clone());
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 55).unwrap();
+
+			let output = MockStack::run_call(
+				contract_origin.clone(),
+				dest.clone(),
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				55,
+				vec![],
+				None,
+				Determinism::Enforced,
+			)
+			.unwrap();
+
+			assert!(output.did_revert());
+			assert_eq!(get_balance(&origin), 100);
+			assert_eq!(get_balance(&dest), balance);
+		});
+	}
+
+	#[test]
+	fn balance_too_low() {
+		// This test verifies that a contract can't send value if it's
+		// balance is too low.
+		let origin = ALICE;
+		let dest = BOB;
+
+		ExtBuilder::default().build().execute_with(|| {
+			set_balance(&origin, 0);
+
+			let result = MockStack::transfer(Preservation::Preserve, &origin, &dest, 100);
+
+			assert_eq!(result, Err(Error::<Test>::TransferFailed.into()));
+			assert_eq!(get_balance(&origin), 0);
+			assert_eq!(get_balance(&dest), 0);
+		});
+	}
+
+	#[test]
+	fn output_is_returned_on_success() {
+		// Verifies that if a contract returns data with a successful exit status, this data
+		// is returned from the execution context.
+		let origin = ALICE;
+		let dest = BOB;
+		let return_ch = MockLoader::insert(Call, |_, _| {
+			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: vec![1, 2, 3, 4] })
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			let contract_origin = Origin::from_account_id(origin);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			place_contract(&BOB, return_ch);
+
+			let result = MockStack::run_call(
+				contract_origin,
+				dest,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+
+			let output = result.unwrap();
+			assert!(!output.did_revert());
+			assert_eq!(output.data, vec![1, 2, 3, 4]);
+		});
+	}
+
+	#[test]
+	fn output_is_returned_on_failure() {
+		// Verifies that if a contract returns data with a failing exit status, this data
+		// is returned from the execution context.
+		let origin = ALICE;
+		let dest = BOB;
+		let return_ch = MockLoader::insert(Call, |_, _| {
+			Ok(ExecReturnValue { flags: ReturnFlags::REVERT, data: vec![1, 2, 3, 4] })
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, return_ch);
+			let contract_origin = Origin::from_account_id(origin);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			let result = MockStack::run_call(
+				contract_origin,
+				dest,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+
+			let output = result.unwrap();
+			assert!(output.did_revert());
+			assert_eq!(output.data, vec![1, 2, 3, 4]);
+		});
+	}
+
+	#[test]
+	fn input_data_to_call() {
+		let input_data_ch = MockLoader::insert(Call, |ctx, _| {
+			assert_eq!(ctx.input_data, &[1, 2, 3, 4]);
+			exec_success()
+		});
+
+		// This one tests passing the input data into a contract via call.
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, input_data_ch);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![1, 2, 3, 4],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn input_data_to_instantiate() {
+		let input_data_ch = MockLoader::insert(Constructor, |ctx, _| {
+			assert_eq!(ctx.input_data, &[1, 2, 3, 4]);
+			exec_success()
+		});
+
+		// This one tests passing the input data into a contract via instantiate.
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				let min_balance = <Test as Config>::Currency::minimum_balance();
+				let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+				let executable =
+					MockExecutable::from_storage(input_data_ch, &mut gas_meter).unwrap();
+				set_balance(&ALICE, min_balance * 10_000);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter =
+					storage::meter::Meter::new(&contract_origin, None, min_balance).unwrap();
+
+				let result = MockStack::run_instantiate(
+					ALICE,
+					executable,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					min_balance,
+					vec![1, 2, 3, 4],
+					&[],
+					None,
+				);
+				assert_matches!(result, Ok(_));
+			});
+	}
+
+	#[test]
+	fn max_depth() {
+		// This test verifies that when we reach the maximal depth creation of an
+		// yet another context fails.
+		parameter_types! {
+			static ReachedBottom: bool = false;
+		}
+		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);
+
+			ReachedBottom::mutate(|reached_bottom| {
+				if !*reached_bottom {
+					// We are first time here, it means we just reached bottom.
+					// Verify that we've got proper error and set `reached_bottom`.
+					assert_eq!(r, Err(Error::<Test>::MaxCallDepthReached.into()));
+					*reached_bottom = true;
+				} else {
+					// We just unwinding stack here.
+					assert_matches!(r, Ok(_));
+				}
+			});
+
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			set_balance(&BOB, 1);
+			place_contract(&BOB, recurse_ch);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), value).unwrap();
+
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				value,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn caller_returns_proper_values() {
+		let origin = ALICE;
+		let dest = BOB;
+
+		parameter_types! {
+			static WitnessedCallerBob: Option<AccountIdOf<Test>> = None;
+			static WitnessedCallerCharlie: Option<AccountIdOf<Test>> = None;
+		}
+
+		let bob_ch = MockLoader::insert(Call, |ctx, _| {
+			// Record the caller for bob.
+			WitnessedCallerBob::mutate(|caller| {
+				*caller = Some(ctx.ext.caller().account_id().unwrap().clone())
+			});
+
+			// Call into CHARLIE contract.
+			assert_matches!(
+				ctx.ext
+					.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true),
+				Ok(_)
+			);
+			exec_success()
+		});
+		let charlie_ch = MockLoader::insert(Call, |ctx, _| {
+			// Record the caller for charlie.
+			WitnessedCallerCharlie::mutate(|caller| {
+				*caller = Some(ctx.ext.caller().account_id().unwrap().clone())
+			});
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&dest, bob_ch);
+			place_contract(&CHARLIE, charlie_ch);
+			let contract_origin = Origin::from_account_id(origin.clone());
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			let result = MockStack::run_call(
+				contract_origin.clone(),
+				dest.clone(),
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+
+			assert_matches!(result, Ok(_));
+		});
+
+		assert_eq!(WitnessedCallerBob::get(), Some(origin));
+		assert_eq!(WitnessedCallerCharlie::get(), Some(dest));
+	}
+
+	#[test]
+	fn is_contract_returns_proper_values() {
+		let bob_ch = MockLoader::insert(Call, |ctx, _| {
+			// Verify that BOB is a contract
+			assert!(ctx.ext.is_contract(&BOB));
+			// Verify that ALICE is not a contract
+			assert!(!ctx.ext.is_contract(&ALICE));
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, bob_ch);
+
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn code_hash_returns_proper_values() {
+		let code_bob = MockLoader::insert(Call, |ctx, _| {
+			// ALICE is not a contract and hence they do not have a code_hash
+			assert!(ctx.ext.code_hash(&ALICE).is_none());
+			// BOB is a contract and hence it has a code_hash
+			assert!(ctx.ext.code_hash(&BOB).is_some());
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			// ALICE (not contract) -> BOB (contract)
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![0],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn own_code_hash_returns_proper_values() {
+		let bob_ch = MockLoader::insert(Call, |ctx, _| {
+			let code_hash = ctx.ext.code_hash(&BOB).unwrap();
+			assert_eq!(*ctx.ext.own_code_hash(), code_hash);
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, bob_ch);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			// ALICE (not contract) -> BOB (contract)
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![0],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn caller_is_origin_returns_proper_values() {
+		let code_charlie = MockLoader::insert(Call, |ctx, _| {
+			// BOB is not the origin of the stack call
+			assert!(!ctx.ext.caller_is_origin());
+			exec_success()
+		});
+
+		let code_bob = MockLoader::insert(Call, |ctx, _| {
+			// ALICE is the origin of the call stack
+			assert!(ctx.ext.caller_is_origin());
+			// BOB calls CHARLIE
+			ctx.ext
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true)
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			place_contract(&CHARLIE, code_charlie);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			// ALICE -> BOB (caller is origin) -> CHARLIE (caller is not origin)
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![0],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn root_caller_succeeds() {
+		let code_bob = MockLoader::insert(Call, |ctx, _| {
+			// root is the origin of the call stack.
+			assert!(ctx.ext.caller_is_root());
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			let contract_origin = Origin::Root;
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			// root -> BOB (caller is root)
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![0],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn root_caller_does_not_succeed_when_value_not_zero() {
+		let code_bob = MockLoader::insert(Call, |ctx, _| {
+			// root is the origin of the call stack.
+			assert!(ctx.ext.caller_is_root());
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			let contract_origin = Origin::Root;
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			// root -> BOB (caller is root)
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				1,
+				vec![0],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Err(_));
+		});
+	}
+
+	#[test]
+	fn root_caller_succeeds_with_consecutive_calls() {
+		let code_charlie = MockLoader::insert(Call, |ctx, _| {
+			// BOB is not root, even though the origin is root.
+			assert!(!ctx.ext.caller_is_root());
+			exec_success()
+		});
+
+		let code_bob = MockLoader::insert(Call, |ctx, _| {
+			// root is the origin of the call stack.
+			assert!(ctx.ext.caller_is_root());
+			// BOB calls CHARLIE.
+			ctx.ext
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true)
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			place_contract(&CHARLIE, code_charlie);
+			let contract_origin = Origin::Root;
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			// root -> BOB (caller is root) -> CHARLIE (caller is not root)
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![0],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn address_returns_proper_values() {
+		let bob_ch = MockLoader::insert(Call, |ctx, _| {
+			// Verify that address matches BOB.
+			assert_eq!(*ctx.ext.address(), BOB);
+
+			// Call into charlie contract.
+			assert_matches!(
+				ctx.ext
+					.call(Weight::zero(), BalanceOf::<Test>::zero(), CHARLIE, 0, vec![], true),
+				Ok(_)
+			);
+			exec_success()
+		});
+		let charlie_ch = MockLoader::insert(Call, |ctx, _| {
+			assert_eq!(*ctx.ext.address(), CHARLIE);
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, bob_ch);
+			place_contract(&CHARLIE, charlie_ch);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn refuse_instantiate_with_value_below_existential_deposit() {
+		let dummy_ch = MockLoader::insert(Constructor, |_, _| exec_success());
+
+		ExtBuilder::default().existential_deposit(15).build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			let executable = MockExecutable::from_storage(dummy_ch, &mut gas_meter).unwrap();
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			assert_matches!(
+				MockStack::run_instantiate(
+					ALICE,
+					executable,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					0, // <- zero value
+					vec![],
+					&[],
+					None,
+				),
+				Err(_)
+			);
+		});
+	}
+
+	#[test]
+	fn instantiation_work_with_success_output() {
+		let dummy_ch = MockLoader::insert(Constructor, |_, _| {
+			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: vec![80, 65, 83, 83] })
+		});
+
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.existential_deposit(15)
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				let min_balance = <Test as Config>::Currency::minimum_balance();
+				let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+				let executable = MockExecutable::from_storage(dummy_ch, &mut gas_meter).unwrap();
+				set_balance(&ALICE, min_balance * 1000);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter = storage::meter::Meter::new(
+					&contract_origin,
+					Some(min_balance * 100),
+					min_balance,
+				)
+				.unwrap();
+
+				let instantiated_contract_address = assert_matches!(
+					MockStack::run_instantiate(
+						ALICE,
+						executable,
+						&mut gas_meter,
+						&mut storage_meter,
+						&schedule,
+						min_balance,
+						vec![],
+						&[],
+						None,
+					),
+					Ok((address, ref output)) if output.data == vec![80, 65, 83, 83] => address
+				);
+
+				// Check that the newly created account has the expected code hash and
+				// there are instantiation event.
+				assert_eq!(
+					ContractInfo::<Test>::load_code_hash(&instantiated_contract_address).unwrap(),
+					dummy_ch
+				);
+				assert_eq!(
+					&events(),
+					&[Event::Instantiated {
+						deployer: ALICE,
+						contract: instantiated_contract_address
+					}]
+				);
+			});
+	}
+
+	#[test]
+	fn instantiation_fails_with_failing_output() {
+		let dummy_ch = MockLoader::insert(Constructor, |_, _| {
+			Ok(ExecReturnValue { flags: ReturnFlags::REVERT, data: vec![70, 65, 73, 76] })
+		});
+
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.existential_deposit(15)
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				let min_balance = <Test as Config>::Currency::minimum_balance();
+				let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+				let executable = MockExecutable::from_storage(dummy_ch, &mut gas_meter).unwrap();
+				set_balance(&ALICE, min_balance * 1000);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter = storage::meter::Meter::new(
+					&contract_origin,
+					Some(min_balance * 100),
+					min_balance,
+				)
+				.unwrap();
+
+				let instantiated_contract_address = assert_matches!(
+					MockStack::run_instantiate(
+						ALICE,
+						executable,
+						&mut gas_meter,
+						&mut storage_meter,
+						&schedule,
+						min_balance,
+						vec![],
+						&[],
+						None,
+					),
+					Ok((address, ref output)) if output.data == vec![70, 65, 73, 76] => address
+				);
+
+				// Check that the account has not been created.
+				assert!(
+					ContractInfo::<Test>::load_code_hash(&instantiated_contract_address).is_none()
+				);
+				assert!(events().is_empty());
+			});
+	}
+
+	#[test]
+	fn instantiation_from_contract() {
+		let dummy_ch = MockLoader::insert(Call, |_, _| exec_success());
+		let instantiated_contract_address = Rc::new(RefCell::new(None::<AccountIdOf<Test>>));
+		let instantiator_ch = MockLoader::insert(Call, {
+			let instantiated_contract_address = Rc::clone(&instantiated_contract_address);
+			move |ctx, _| {
+				// Instantiate a contract and save it's address in `instantiated_contract_address`.
+				let (address, output) = ctx
+					.ext
+					.instantiate(
+						Weight::zero(),
+						BalanceOf::<Test>::zero(),
+						dummy_ch,
+						<Test as Config>::Currency::minimum_balance(),
+						vec![],
+						&[48, 49, 50],
+					)
+					.unwrap();
+
+				*instantiated_contract_address.borrow_mut() = address.into();
+				Ok(output)
+			}
+		});
+
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.existential_deposit(15)
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				let min_balance = <Test as Config>::Currency::minimum_balance();
+				set_balance(&ALICE, min_balance * 100);
+				place_contract(&BOB, instantiator_ch);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter = storage::meter::Meter::new(
+					&contract_origin,
+					Some(min_balance * 10),
+					min_balance * 10,
+				)
+				.unwrap();
+
+				assert_matches!(
+					MockStack::run_call(
+						contract_origin,
+						BOB,
+						&mut GasMeter::<Test>::new(GAS_LIMIT),
+						&mut storage_meter,
+						&schedule,
+						min_balance * 10,
+						vec![],
+						None,
+						Determinism::Enforced,
+					),
+					Ok(_)
+				);
+
+				let instantiated_contract_address =
+					instantiated_contract_address.borrow().as_ref().unwrap().clone();
+
+				// Check that the newly created account has the expected code hash and
+				// there are instantiation event.
+				assert_eq!(
+					ContractInfo::<Test>::load_code_hash(&instantiated_contract_address).unwrap(),
+					dummy_ch
+				);
+				assert_eq!(
+					&events(),
+					&[
+						Event::Instantiated {
+							deployer: BOB,
+							contract: instantiated_contract_address
+						},
+						Event::Called { caller: Origin::from_account_id(ALICE), contract: BOB },
+					]
+				);
+			});
+	}
+
+	#[test]
+	fn instantiation_traps() {
+		let dummy_ch = MockLoader::insert(Constructor, |_, _| Err("It's a trap!".into()));
+		let instantiator_ch = MockLoader::insert(Call, {
+			move |ctx, _| {
+				// Instantiate a contract and save it's address in `instantiated_contract_address`.
+				assert_matches!(
+					ctx.ext.instantiate(
+						Weight::zero(),
+						BalanceOf::<Test>::zero(),
+						dummy_ch,
+						<Test as Config>::Currency::minimum_balance(),
+						vec![],
+						&[],
+					),
+					Err(ExecError {
+						error: DispatchError::Other("It's a trap!"),
+						origin: ErrorOrigin::Callee,
+					})
+				);
+
+				exec_success()
+			}
+		});
+
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.existential_deposit(15)
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				set_balance(&ALICE, 1000);
+				set_balance(&BOB, 100);
+				place_contract(&BOB, instantiator_ch);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter =
+					storage::meter::Meter::new(&contract_origin, Some(200), 0).unwrap();
+
+				assert_matches!(
+					MockStack::run_call(
+						contract_origin,
+						BOB,
+						&mut GasMeter::<Test>::new(GAS_LIMIT),
+						&mut storage_meter,
+						&schedule,
+						0,
+						vec![],
+						None,
+						Determinism::Enforced,
+					),
+					Ok(_)
+				);
+
+				// The contract wasn't instantiated so we don't expect to see an instantiation
+				// event here.
+				assert_eq!(
+					&events(),
+					&[Event::Called { caller: Origin::from_account_id(ALICE), contract: BOB },]
+				);
+			});
+	}
+
+	#[test]
+	fn termination_from_instantiate_fails() {
+		let terminate_ch = MockLoader::insert(Constructor, |ctx, _| {
+			ctx.ext.terminate(&ALICE).unwrap();
+			exec_success()
+		});
+
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.existential_deposit(15)
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+				let executable =
+					MockExecutable::from_storage(terminate_ch, &mut gas_meter).unwrap();
+				set_balance(&ALICE, 10_000);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter =
+					storage::meter::Meter::new(&contract_origin, None, 100).unwrap();
+
+				assert_eq!(
+					MockStack::run_instantiate(
+						ALICE,
+						executable,
+						&mut gas_meter,
+						&mut storage_meter,
+						&schedule,
+						100,
+						vec![],
+						&[],
+						None,
+					),
+					Err(Error::<Test>::TerminatedInConstructor.into())
+				);
+
+				assert_eq!(&events(), &[]);
+			});
+	}
+
+	#[test]
+	fn in_memory_changes_not_discarded() {
+		// Call stack: BOB -> CHARLIE (trap) -> BOB' (success)
+		// This tests verifies some edge case of the contract info cache:
+		// We change some value in our contract info before calling into a contract
+		// that calls into ourself. This triggers a case where BOBs contract info
+		// is written to storage and invalidated by the successful execution of BOB'.
+		// The trap of CHARLIE reverts the storage changes to BOB. When the root BOB regains
+		// control it reloads its contract info from storage. We check that changes that
+		// are made before calling into CHARLIE are not discarded.
+		let code_bob = MockLoader::insert(Call, |ctx, _| {
+			if ctx.input_data[0] == 0 {
+				let info = ctx.ext.contract_info();
+				assert_eq!(info.storage_byte_deposit, 0);
+				info.storage_byte_deposit = 42;
+				assert_eq!(
+					ctx.ext.call(
+						Weight::zero(),
+						BalanceOf::<Test>::zero(),
+						CHARLIE,
+						0,
+						vec![],
+						true
+					),
+					exec_trapped()
+				);
+				assert_eq!(ctx.ext.contract_info().storage_byte_deposit, 42);
+			}
+			exec_success()
+		});
+		let code_charlie = MockLoader::insert(Call, |ctx, _| {
+			assert!(ctx
+				.ext
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), BOB, 0, vec![99], true)
+				.is_ok());
+			exec_trapped()
+		});
+
+		// This one tests passing the input data into a contract via call.
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			place_contract(&CHARLIE, code_charlie);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![0],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	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),
+				Err(ExecError{error, ..}) if error == <Error<Test>>::ContractNotFound.into()
+			);
+			exec_success()
+		});
+
+		// This one tests passing the input data into a contract via instantiate.
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				let min_balance = <Test as Config>::Currency::minimum_balance();
+				let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+				let executable = MockExecutable::from_storage(code, &mut gas_meter).unwrap();
+				set_balance(&ALICE, min_balance * 10_000);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter =
+					storage::meter::Meter::new(&contract_origin, None, min_balance).unwrap();
+
+				let result = MockStack::run_instantiate(
+					ALICE,
+					executable,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					min_balance,
+					vec![],
+					&[],
+					None,
+				);
+				assert_matches!(result, Ok(_));
+			});
+	}
+
+	#[test]
+	fn printing_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			ctx.ext.append_debug_buffer("This is a test");
+			ctx.ext.append_debug_buffer("More text");
+			exec_success()
+		});
+
+		let mut debug_buffer = DebugBufferVec::<Test>::try_from(Vec::new()).unwrap();
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 10);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				Some(&mut debug_buffer),
+				Determinism::Enforced,
+			)
+			.unwrap();
+		});
+
+		assert_eq!(&String::from_utf8(debug_buffer.to_vec()).unwrap(), "This is a testMore text");
+	}
+
+	#[test]
+	fn printing_works_on_fail() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			ctx.ext.append_debug_buffer("This is a test");
+			ctx.ext.append_debug_buffer("More text");
+			exec_trapped()
+		});
+
+		let mut debug_buffer = DebugBufferVec::<Test>::try_from(Vec::new()).unwrap();
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 10);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				Some(&mut debug_buffer),
+				Determinism::Enforced,
+			);
+			assert!(result.is_err());
+		});
+
+		assert_eq!(&String::from_utf8(debug_buffer.to_vec()).unwrap(), "This is a testMore text");
+	}
+
+	#[test]
+	fn debug_buffer_is_limited() {
+		let code_hash = MockLoader::insert(Call, move |ctx, _| {
+			ctx.ext.append_debug_buffer("overflowing bytes");
+			exec_success()
+		});
+
+		// Pre-fill the buffer almost up to its limit, leaving not enough space to the message
+		let debug_buf_before =
+			DebugBufferVec::<Test>::try_from(vec![0u8; DebugBufferVec::<Test>::bound() - 5])
+				.unwrap();
+		let mut debug_buf_after = debug_buf_before.clone();
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule: Schedule<Test> = <Test as Config>::Schedule::get();
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 10);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				Some(&mut debug_buf_after),
+				Determinism::Enforced,
+			)
+			.unwrap();
+			assert_eq!(debug_buf_before, debug_buf_after);
+		});
+	}
+
+	#[test]
+	fn call_reentry_direct_recursion() {
+		// 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)
+		});
+
+		let code_charlie = MockLoader::insert(Call, |_, _| exec_success());
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			place_contract(&CHARLIE, code_charlie);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			// Calling another contract should succeed
+			assert_ok!(MockStack::run_call(
+				contract_origin.clone(),
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				CHARLIE.encode(),
+				None,
+				Determinism::Enforced
+			));
+
+			// Calling into oneself fails
+			assert_err!(
+				MockStack::run_call(
+					contract_origin,
+					BOB,
+					&mut GasMeter::<Test>::new(GAS_LIMIT),
+					&mut storage_meter,
+					&schedule,
+					0,
+					BOB.encode(),
+					None,
+					Determinism::Enforced
+				)
+				.map_err(|e| e.error),
+				<Error<Test>>::ReentranceDenied,
+			);
+		});
+	}
+
+	#[test]
+	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)
+			} else {
+				exec_success()
+			}
+		});
+
+		// 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)
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_bob);
+			place_contract(&CHARLIE, code_charlie);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+
+			// BOB -> CHARLIE -> BOB fails as BOB denies reentry.
+			assert_err!(
+				MockStack::run_call(
+					contract_origin,
+					BOB,
+					&mut GasMeter::<Test>::new(GAS_LIMIT),
+					&mut storage_meter,
+					&schedule,
+					0,
+					vec![0],
+					None,
+					Determinism::Enforced
+				)
+				.map_err(|e| e.error),
+				<Error<Test>>::ReentranceDenied,
+			);
+		});
+	}
+
+	#[test]
+	fn call_runtime_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			let call = RuntimeCall::System(frame_system::Call::remark_with_event {
+				remark: b"Hello World".to_vec(),
+			});
+			ctx.ext.call_runtime(call).unwrap();
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 10);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			System::reset_events();
+			MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			)
+			.unwrap();
+
+			let remark_hash = <Test as frame_system::Config>::Hashing::hash(b"Hello World");
+			assert_eq!(
+				System::events(),
+				vec![
+					EventRecord {
+						phase: Phase::Initialization,
+						event: MetaEvent::System(frame_system::Event::Remarked {
+							sender: BOB,
+							hash: remark_hash
+						}),
+						topics: vec![],
+					},
+					EventRecord {
+						phase: Phase::Initialization,
+						event: MetaEvent::Contracts(crate::Event::Called {
+							caller: Origin::from_account_id(ALICE),
+							contract: BOB,
+						}),
+						topics: vec![hash(&Origin::<Test>::from_account_id(ALICE)), hash(&BOB)],
+					},
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn call_runtime_filter() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			use frame_system::Call as SysCall;
+			use pallet_balances::Call as BalanceCall;
+			use pallet_utility::Call as UtilCall;
+
+			// remark should still be allowed
+			let allowed_call =
+				RuntimeCall::System(SysCall::remark_with_event { remark: b"Hello".to_vec() });
+
+			// transfers are disallowed by the `TestFiler` (see below)
+			let forbidden_call = RuntimeCall::Balances(BalanceCall::transfer_allow_death {
+				dest: CHARLIE,
+				value: 22,
+			});
+
+			// simple cases: direct call
+			assert_err!(
+				ctx.ext.call_runtime(forbidden_call.clone()),
+				frame_system::Error::<Test>::CallFiltered
+			);
+
+			// as part of a patch: return is OK (but it interrupted the batch)
+			assert_ok!(ctx.ext.call_runtime(RuntimeCall::Utility(UtilCall::batch {
+				calls: vec![allowed_call.clone(), forbidden_call, allowed_call]
+			})),);
+
+			// the transfer wasn't performed
+			assert_eq!(get_balance(&CHARLIE), 0);
+
+			exec_success()
+		});
+
+		TestFilter::set_filter(|call| match call {
+			RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death { .. }) => false,
+			_ => true,
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 10);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			System::reset_events();
+			MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			)
+			.unwrap();
+
+			let remark_hash = <Test as frame_system::Config>::Hashing::hash(b"Hello");
+			assert_eq!(
+				System::events(),
+				vec![
+					EventRecord {
+						phase: Phase::Initialization,
+						event: MetaEvent::System(frame_system::Event::Remarked {
+							sender: BOB,
+							hash: remark_hash
+						}),
+						topics: vec![],
+					},
+					EventRecord {
+						phase: Phase::Initialization,
+						event: MetaEvent::Utility(pallet_utility::Event::ItemCompleted),
+						topics: vec![],
+					},
+					EventRecord {
+						phase: Phase::Initialization,
+						event: MetaEvent::Utility(pallet_utility::Event::BatchInterrupted {
+							index: 1,
+							error: frame_system::Error::<Test>::CallFiltered.into()
+						},),
+						topics: vec![],
+					},
+					EventRecord {
+						phase: Phase::Initialization,
+						event: MetaEvent::Contracts(crate::Event::Called {
+							caller: Origin::from_account_id(ALICE),
+							contract: BOB,
+						}),
+						topics: vec![hash(&Origin::<Test>::from_account_id(ALICE)), hash(&BOB)],
+					},
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn nonce() {
+		let fail_code = MockLoader::insert(Constructor, |_, _| exec_trapped());
+		let success_code = MockLoader::insert(Constructor, |_, _| exec_success());
+		let succ_fail_code = MockLoader::insert(Constructor, move |ctx, _| {
+			ctx.ext
+				.instantiate(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					fail_code,
+					ctx.ext.minimum_balance() * 100,
+					vec![],
+					&[],
+				)
+				.ok();
+			exec_success()
+		});
+		let succ_succ_code = MockLoader::insert(Constructor, move |ctx, _| {
+			let (account_id, _) = ctx
+				.ext
+				.instantiate(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					success_code,
+					ctx.ext.minimum_balance() * 100,
+					vec![],
+					&[],
+				)
+				.unwrap();
+
+			// a plain call should not influence the account counter
+			ctx.ext
+				.call(Weight::zero(), BalanceOf::<Test>::zero(), account_id, 0, vec![], false)
+				.unwrap();
+
+			exec_success()
+		});
+
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.build()
+			.execute_with(|| {
+				let schedule = <Test as Config>::Schedule::get();
+				let min_balance = <Test as Config>::Currency::minimum_balance();
+				let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+				let fail_executable =
+					MockExecutable::from_storage(fail_code, &mut gas_meter).unwrap();
+				let success_executable =
+					MockExecutable::from_storage(success_code, &mut gas_meter).unwrap();
+				let succ_fail_executable =
+					MockExecutable::from_storage(succ_fail_code, &mut gas_meter).unwrap();
+				let succ_succ_executable =
+					MockExecutable::from_storage(succ_succ_code, &mut gas_meter).unwrap();
+				set_balance(&ALICE, min_balance * 10_000);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter =
+					storage::meter::Meter::new(&contract_origin, None, min_balance * 100).unwrap();
+
+				MockStack::run_instantiate(
+					ALICE,
+					fail_executable,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					min_balance * 100,
+					vec![],
+					&[],
+					None,
+				)
+				.ok();
+				assert_eq!(<Nonce<Test>>::get(), 0);
+
+				assert_ok!(MockStack::run_instantiate(
+					ALICE,
+					success_executable,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					min_balance * 100,
+					vec![],
+					&[],
+					None,
+				));
+				assert_eq!(<Nonce<Test>>::get(), 1);
+
+				assert_ok!(MockStack::run_instantiate(
+					ALICE,
+					succ_fail_executable,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					min_balance * 200,
+					vec![],
+					&[],
+					None,
+				));
+				assert_eq!(<Nonce<Test>>::get(), 2);
+
+				assert_ok!(MockStack::run_instantiate(
+					ALICE,
+					succ_succ_executable,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					min_balance * 200,
+					vec![],
+					&[],
+					None,
+				));
+				assert_eq!(<Nonce<Test>>::get(), 4);
+			});
+	}
+
+	#[test]
+	fn set_storage_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			// Write
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([1; 32]), Some(vec![1, 2, 3]), false),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([2; 32]), Some(vec![4, 5, 6]), true),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(ctx.ext.set_storage(&Key::Fix([3; 32]), None, false), Ok(WriteOutcome::New));
+			assert_eq!(ctx.ext.set_storage(&Key::Fix([4; 32]), None, true), Ok(WriteOutcome::New));
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([5; 32]), Some(vec![]), false),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([6; 32]), Some(vec![]), true),
+				Ok(WriteOutcome::New)
+			);
+
+			// Overwrite
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([1; 32]), Some(vec![42]), false),
+				Ok(WriteOutcome::Overwritten(3))
+			);
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([2; 32]), Some(vec![48]), true),
+				Ok(WriteOutcome::Taken(vec![4, 5, 6]))
+			);
+			assert_eq!(ctx.ext.set_storage(&Key::Fix([3; 32]), None, false), Ok(WriteOutcome::New));
+			assert_eq!(ctx.ext.set_storage(&Key::Fix([4; 32]), None, true), Ok(WriteOutcome::New));
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([5; 32]), Some(vec![]), false),
+				Ok(WriteOutcome::Overwritten(0))
+			);
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([6; 32]), Some(vec![]), true),
+				Ok(WriteOutcome::Taken(vec![]))
+			);
+
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 1000);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter = storage::meter::Meter::new(&contract_origin, None, 0).unwrap();
+			assert_ok!(MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced
+			));
+		});
+	}
+
+	#[test]
+	fn set_storage_varsized_key_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			// Write
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([1; 64].to_vec()).unwrap(),
+					Some(vec![1, 2, 3]),
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([2; 19].to_vec()).unwrap(),
+					Some(vec![4, 5, 6]),
+					true
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([3; 19].to_vec()).unwrap(),
+					None,
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([4; 64].to_vec()).unwrap(),
+					None,
+					true
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([5; 30].to_vec()).unwrap(),
+					Some(vec![]),
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([6; 128].to_vec()).unwrap(),
+					Some(vec![]),
+					true
+				),
+				Ok(WriteOutcome::New)
+			);
+
+			// Overwrite
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([1; 64].to_vec()).unwrap(),
+					Some(vec![42, 43, 44]),
+					false
+				),
+				Ok(WriteOutcome::Overwritten(3))
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([2; 19].to_vec()).unwrap(),
+					Some(vec![48]),
+					true
+				),
+				Ok(WriteOutcome::Taken(vec![4, 5, 6]))
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([3; 19].to_vec()).unwrap(),
+					None,
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([4; 64].to_vec()).unwrap(),
+					None,
+					true
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([5; 30].to_vec()).unwrap(),
+					Some(vec![]),
+					false
+				),
+				Ok(WriteOutcome::Overwritten(0))
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([6; 128].to_vec()).unwrap(),
+					Some(vec![]),
+					true
+				),
+				Ok(WriteOutcome::Taken(vec![]))
+			);
+
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 1000);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter = storage::meter::Meter::new(&contract_origin, None, 0).unwrap();
+			assert_ok!(MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced
+			));
+		});
+	}
+
+	#[test]
+	fn get_storage_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([1; 32]), Some(vec![1, 2, 3]), false),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([2; 32]), Some(vec![]), false),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(ctx.ext.get_storage(&Key::Fix([1; 32])), Some(vec![1, 2, 3]));
+			assert_eq!(ctx.ext.get_storage(&Key::Fix([2; 32])), Some(vec![]));
+			assert_eq!(ctx.ext.get_storage(&Key::Fix([3; 32])), None);
+
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 1000);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter = storage::meter::Meter::new(&contract_origin, None, 0).unwrap();
+			assert_ok!(MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced
+			));
+		});
+	}
+
+	#[test]
+	fn get_storage_size_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([1; 32]), Some(vec![1, 2, 3]), false),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(&Key::Fix([2; 32]), Some(vec![]), false),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(ctx.ext.get_storage_size(&Key::Fix([1; 32])), Some(3));
+			assert_eq!(ctx.ext.get_storage_size(&Key::Fix([2; 32])), Some(0));
+			assert_eq!(ctx.ext.get_storage_size(&Key::Fix([3; 32])), None);
+
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 1000);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter = storage::meter::Meter::new(&contract_origin, None, 0).unwrap();
+			assert_ok!(MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced
+			));
+		});
+	}
+
+	#[test]
+	fn get_storage_varsized_key_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([1; 19].to_vec()).unwrap(),
+					Some(vec![1, 2, 3]),
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([2; 16].to_vec()).unwrap(),
+					Some(vec![]),
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.get_storage(&Key::<Test>::try_from_var([1; 19].to_vec()).unwrap()),
+				Some(vec![1, 2, 3])
+			);
+			assert_eq!(
+				ctx.ext.get_storage(&Key::<Test>::try_from_var([2; 16].to_vec()).unwrap()),
+				Some(vec![])
+			);
+			assert_eq!(
+				ctx.ext.get_storage(&Key::<Test>::try_from_var([3; 8].to_vec()).unwrap()),
+				None
+			);
+
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 1000);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter = storage::meter::Meter::new(&contract_origin, None, 0).unwrap();
+			assert_ok!(MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced
+			));
+		});
+	}
+
+	#[test]
+	fn get_storage_size_varsized_key_works() {
+		let code_hash = MockLoader::insert(Call, |ctx, _| {
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([1; 19].to_vec()).unwrap(),
+					Some(vec![1, 2, 3]),
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.set_storage(
+					&Key::<Test>::try_from_var([2; 16].to_vec()).unwrap(),
+					Some(vec![]),
+					false
+				),
+				Ok(WriteOutcome::New)
+			);
+			assert_eq!(
+				ctx.ext.get_storage_size(&Key::<Test>::try_from_var([1; 19].to_vec()).unwrap()),
+				Some(3)
+			);
+			assert_eq!(
+				ctx.ext.get_storage_size(&Key::<Test>::try_from_var([2; 16].to_vec()).unwrap()),
+				Some(0)
+			);
+			assert_eq!(
+				ctx.ext.get_storage_size(&Key::<Test>::try_from_var([3; 8].to_vec()).unwrap()),
+				None
+			);
+
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let min_balance = <Test as Config>::Currency::minimum_balance();
+			let schedule = <Test as Config>::Schedule::get();
+			let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+			set_balance(&ALICE, min_balance * 1000);
+			place_contract(&BOB, code_hash);
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter = storage::meter::Meter::new(&contract_origin, None, 0).unwrap();
+			assert_ok!(MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced
+			));
+		});
+	}
+
+	#[test]
+	fn ecdsa_to_eth_address_returns_proper_value() {
+		let bob_ch = MockLoader::insert(Call, |ctx, _| {
+			let pubkey_compressed = array_bytes::hex2array_unchecked(
+				"028db55b05db86c0b1786ca49f095d76344c9e6056b2f02701a7e7f3c20aabfd91",
+			);
+			assert_eq!(
+				ctx.ext.ecdsa_to_eth_address(&pubkey_compressed).unwrap(),
+				array_bytes::hex2array_unchecked::<_, 20>(
+					"09231da7b19A016f9e576d23B16277062F4d46A8"
+				)
+			);
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, bob_ch);
+
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+
+	#[test]
+	fn nonce_api_works() {
+		let fail_code = MockLoader::insert(Constructor, |_, _| exec_trapped());
+		let success_code = MockLoader::insert(Constructor, |_, _| exec_success());
+		let code_hash = MockLoader::insert(Call, move |ctx, _| {
+			// It is set to one when this contract was instantiated by `place_contract`
+			assert_eq!(ctx.ext.nonce(), 1);
+			// Should not change without any instantiation in-between
+			assert_eq!(ctx.ext.nonce(), 1);
+			// Should not change with a failed instantiation
+			assert_err!(
+				ctx.ext.instantiate(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					fail_code,
+					0,
+					vec![],
+					&[],
+				),
+				ExecError {
+					error: <Error<Test>>::ContractTrapped.into(),
+					origin: ErrorOrigin::Callee
+				}
+			);
+			assert_eq!(ctx.ext.nonce(), 1);
+			// Successful instantiation increments
+			ctx.ext
+				.instantiate(
+					Weight::zero(),
+					BalanceOf::<Test>::zero(),
+					success_code,
+					0,
+					vec![],
+					&[],
+				)
+				.unwrap();
+			assert_eq!(ctx.ext.nonce(), 2);
+			exec_success()
+		});
+
+		ExtBuilder::default()
+			.with_code_hashes(MockLoader::code_hashes())
+			.build()
+			.execute_with(|| {
+				let min_balance = <Test as Config>::Currency::minimum_balance();
+				let schedule = <Test as Config>::Schedule::get();
+				let mut gas_meter = GasMeter::<Test>::new(GAS_LIMIT);
+				set_balance(&ALICE, min_balance * 1000);
+				place_contract(&BOB, code_hash);
+				let contract_origin = Origin::from_account_id(ALICE);
+				let mut storage_meter =
+					storage::meter::Meter::new(&contract_origin, None, 0).unwrap();
+				assert_ok!(MockStack::run_call(
+					contract_origin,
+					BOB,
+					&mut gas_meter,
+					&mut storage_meter,
+					&schedule,
+					0,
+					vec![],
+					None,
+					Determinism::Enforced
+				));
+			});
+	}
+
+	/// This works even though random interface is deprecated, as the check to ban deprecated
+	/// functions happens in the wasm stack which is mocked for exec tests.
+	#[test]
+	fn randomness_works() {
+		let subject = b"nice subject".as_ref();
+		let code_hash = MockLoader::insert(Call, move |ctx, _| {
+			let rand = <Test as Config>::Randomness::random(subject);
+			assert_eq!(rand, ctx.ext.random(subject));
+			exec_success()
+		});
+
+		ExtBuilder::default().build().execute_with(|| {
+			let schedule = <Test as Config>::Schedule::get();
+			place_contract(&BOB, code_hash);
+
+			let contract_origin = Origin::from_account_id(ALICE);
+			let mut storage_meter =
+				storage::meter::Meter::new(&contract_origin, Some(0), 0).unwrap();
+			let result = MockStack::run_call(
+				contract_origin,
+				BOB,
+				&mut GasMeter::<Test>::new(GAS_LIMIT),
+				&mut storage_meter,
+				&schedule,
+				0,
+				vec![],
+				None,
+				Determinism::Enforced,
+			);
+			assert_matches!(result, Ok(_));
+		});
+	}
+}
diff --git a/substrate/frame/contracts/src/gas.rs b/substrate/frame/contracts/src/gas.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7d17642d92e54f4ecad74c71faf1eae8741c3fbc
--- /dev/null
+++ b/substrate/frame/contracts/src/gas.rs
@@ -0,0 +1,355 @@
+// 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::{exec::ExecError, Config, Error};
+use frame_support::{
+	dispatch::{
+		DispatchError, DispatchErrorWithPostInfo, DispatchResultWithPostInfo, PostDispatchInfo,
+	},
+	weights::Weight,
+	DefaultNoBound,
+};
+use sp_core::Get;
+use sp_runtime::traits::Zero;
+use sp_std::marker::PhantomData;
+
+#[cfg(test)]
+use std::{any::Any, fmt::Debug};
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct ChargedAmount(Weight);
+
+impl ChargedAmount {
+	pub fn amount(&self) -> Weight {
+		self.0
+	}
+}
+
+#[cfg(not(test))]
+pub trait TestAuxiliaries {}
+#[cfg(not(test))]
+impl<T> TestAuxiliaries for T {}
+
+#[cfg(test)]
+pub trait TestAuxiliaries: Any + Debug + PartialEq + Eq {}
+#[cfg(test)]
+impl<T: Any + Debug + PartialEq + Eq> TestAuxiliaries for T {}
+
+/// This trait represents a token that can be used for charging `GasMeter`.
+/// There is no other way of charging it.
+///
+/// Implementing type is expected to be super lightweight hence `Copy` (`Clone` is added
+/// for consistency). If inlined there should be no observable difference compared
+/// to a hand-written code.
+pub trait Token<T: Config>: Copy + Clone + TestAuxiliaries {
+	/// Return the amount of gas that should be taken by this token.
+	///
+	/// This function should be really lightweight and must not fail. It is not
+	/// expected that implementors will query the storage or do any kinds of heavy operations.
+	///
+	/// That said, implementors of this function still can run into overflows
+	/// while calculating the amount. In this case it is ok to use saturating operations
+	/// since on overflow they will return `max_value` which should consume all gas.
+	fn weight(&self) -> Weight;
+}
+
+/// A wrapper around a type-erased trait object of what used to be a `Token`.
+#[cfg(test)]
+pub struct ErasedToken {
+	pub description: String,
+	pub token: Box<dyn Any>,
+}
+
+#[derive(DefaultNoBound)]
+pub struct GasMeter<T: Config> {
+	gas_limit: Weight,
+	/// Amount of gas left from initial gas limit. Can reach zero.
+	gas_left: Weight,
+	/// Due to `adjust_gas` and `nested` the `gas_left` can temporarily dip below its final value.
+	gas_left_lowest: Weight,
+	/// Amount of fuel consumed by the engine from the last host function call.
+	engine_consumed: u64,
+	_phantom: PhantomData<T>,
+	#[cfg(test)]
+	tokens: Vec<ErasedToken>,
+}
+
+impl<T: Config> GasMeter<T> {
+	pub fn new(gas_limit: Weight) -> Self {
+		GasMeter {
+			gas_limit,
+			gas_left: gas_limit,
+			gas_left_lowest: gas_limit,
+			engine_consumed: Default::default(),
+			_phantom: PhantomData,
+			#[cfg(test)]
+			tokens: Vec::new(),
+		}
+	}
+
+	/// Create a new gas meter by removing gas from the current meter.
+	///
+	/// # Note
+	///
+	/// Passing `0` as amount is interpreted as "all remaining gas".
+	pub fn nested(&mut self, amount: Weight) -> Result<Self, DispatchError> {
+		// NOTE that it is ok to allocate all available gas since it still ensured
+		// by `charge` that it doesn't reach zero.
+		let amount = Weight::from_parts(
+			if amount.ref_time().is_zero() {
+				self.gas_left().ref_time()
+			} else {
+				amount.ref_time()
+			},
+			if amount.proof_size().is_zero() {
+				self.gas_left().proof_size()
+			} else {
+				amount.proof_size()
+			},
+		);
+		self.gas_left = self.gas_left.checked_sub(&amount).ok_or_else(|| <Error<T>>::OutOfGas)?;
+		Ok(GasMeter::new(amount))
+	}
+
+	/// Absorb the remaining gas of a nested meter after we are done using it.
+	pub fn absorb_nested(&mut self, nested: Self) {
+		if self.gas_left.ref_time().is_zero() {
+			// All of the remaining gas was inherited by the nested gas meter. When absorbing
+			// we can therefore safely inherit the lowest gas that the nested gas meter experienced
+			// as long as it is lower than the lowest gas that was experienced by the parent.
+			// We cannot call `self.gas_left_lowest()` here because in the state that this
+			// code is run the parent gas meter has `0` gas left.
+			*self.gas_left_lowest.ref_time_mut() =
+				nested.gas_left_lowest().ref_time().min(self.gas_left_lowest.ref_time());
+		} else {
+			// The nested gas meter was created with a fixed amount that did not consume all of the
+			// parents (self) gas. The lowest gas that self will experience is when the nested
+			// gas was pre charged with the fixed amount.
+			*self.gas_left_lowest.ref_time_mut() = self.gas_left_lowest().ref_time();
+		}
+		if self.gas_left.proof_size().is_zero() {
+			*self.gas_left_lowest.proof_size_mut() =
+				nested.gas_left_lowest().proof_size().min(self.gas_left_lowest.proof_size());
+		} else {
+			*self.gas_left_lowest.proof_size_mut() = self.gas_left_lowest().proof_size();
+		}
+		self.gas_left += nested.gas_left;
+	}
+
+	/// Account for used gas.
+	///
+	/// Amount is calculated by the given `token`.
+	///
+	/// Returns `OutOfGas` if there is not enough gas or addition of the specified
+	/// amount of gas has lead to overflow.
+	///
+	/// NOTE that amount isn't consumed if there is not enough gas. This is considered
+	/// safe because we always charge gas before performing any resource-spending action.
+	#[inline]
+	pub fn charge<Tok: Token<T>>(&mut self, token: Tok) -> Result<ChargedAmount, DispatchError> {
+		#[cfg(test)]
+		{
+			// Unconditionally add the token to the storage.
+			let erased_tok =
+				ErasedToken { description: format!("{:?}", token), token: Box::new(token) };
+			self.tokens.push(erased_tok);
+		}
+		let amount = token.weight();
+		// It is OK to not charge anything on failure because we always charge _before_ we perform
+		// any action
+		self.gas_left = self.gas_left.checked_sub(&amount).ok_or_else(|| Error::<T>::OutOfGas)?;
+		Ok(ChargedAmount(amount))
+	}
+
+	/// Adjust a previously charged amount down to its actual amount.
+	///
+	/// This is when a maximum a priori amount was charged and then should be partially
+	/// refunded to match the actual amount.
+	pub fn adjust_gas<Tok: Token<T>>(&mut self, charged_amount: ChargedAmount, token: Tok) {
+		self.gas_left_lowest = self.gas_left_lowest();
+		let adjustment = charged_amount.0.saturating_sub(token.weight());
+		self.gas_left = self.gas_left.saturating_add(adjustment).min(self.gas_limit);
+	}
+
+	/// This method is used for gas syncs with the engine.
+	///
+	/// Updates internal `engine_comsumed` tracker of engine fuel consumption.
+	///
+	/// Charges self with the `ref_time` Weight corresponding to wasmi fuel consumed on the engine
+	/// side since last sync. Passed value is scaled by multiplying it by the weight of a basic
+	/// operation, as such an operation in wasmi engine costs 1.
+	///
+	/// Returns the updated `gas_left` `Weight` value from the meter.
+	/// Normally this would never fail, as engine should fail first when out of gas.
+	pub fn charge_fuel(&mut self, wasmi_fuel_total: u64) -> Result<Weight, DispatchError> {
+		// Take the part consumed since the last update.
+		let wasmi_fuel = wasmi_fuel_total.saturating_sub(self.engine_consumed);
+		if !wasmi_fuel.is_zero() {
+			self.engine_consumed = wasmi_fuel_total;
+			let reftime_consumed =
+				wasmi_fuel.saturating_mul(T::Schedule::get().instruction_weights.base as u64);
+			let ref_time_left = self
+				.gas_left
+				.ref_time()
+				.checked_sub(reftime_consumed)
+				.ok_or_else(|| Error::<T>::OutOfGas)?;
+
+			*(self.gas_left.ref_time_mut()) = ref_time_left;
+		}
+		Ok(self.gas_left)
+	}
+
+	/// Returns the amount of gas that is required to run the same call.
+	///
+	/// This can be different from `gas_spent` because due to `adjust_gas` the amount of
+	/// spent gas can temporarily drop and be refunded later.
+	pub fn gas_required(&self) -> Weight {
+		self.gas_limit.saturating_sub(self.gas_left_lowest())
+	}
+
+	/// Returns how much gas was spent
+	pub fn gas_consumed(&self) -> Weight {
+		self.gas_limit.saturating_sub(self.gas_left)
+	}
+
+	/// Returns how much gas left from the initial budget.
+	pub fn gas_left(&self) -> Weight {
+		self.gas_left
+	}
+
+	/// Turn this GasMeter into a DispatchResult that contains the actually used gas.
+	pub fn into_dispatch_result<R, E>(
+		self,
+		result: Result<R, E>,
+		base_weight: Weight,
+	) -> DispatchResultWithPostInfo
+	where
+		E: Into<ExecError>,
+	{
+		let post_info = PostDispatchInfo {
+			actual_weight: Some(self.gas_consumed().saturating_add(base_weight)),
+			pays_fee: Default::default(),
+		};
+
+		result
+			.map(|_| post_info)
+			.map_err(|e| DispatchErrorWithPostInfo { post_info, error: e.into().error })
+	}
+
+	fn gas_left_lowest(&self) -> Weight {
+		self.gas_left_lowest.min(self.gas_left)
+	}
+
+	#[cfg(test)]
+	pub fn tokens(&self) -> &[ErasedToken] {
+		&self.tokens
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{GasMeter, Token, Weight};
+	use crate::tests::Test;
+
+	/// A simple utility macro that helps to match against a
+	/// list of tokens.
+	macro_rules! match_tokens {
+		($tokens_iter:ident,) => {
+		};
+		($tokens_iter:ident, $x:expr, $($rest:tt)*) => {
+			{
+				let next = ($tokens_iter).next().unwrap();
+				let pattern = $x;
+
+				// Note that we don't specify the type name directly in this macro,
+				// we only have some expression $x of some type. At the same time, we
+				// have an iterator of Box<dyn Any> and to downcast we need to specify
+				// the type which we want downcast to.
+				//
+				// So what we do is we assign `_pattern_typed_next_ref` to a variable which has
+				// the required type.
+				//
+				// Then we make `_pattern_typed_next_ref = token.downcast_ref()`. This makes
+				// rustc infer the type `T` (in `downcast_ref<T: Any>`) to be the same as in $x.
+
+				let mut _pattern_typed_next_ref = &pattern;
+				_pattern_typed_next_ref = match next.token.downcast_ref() {
+					Some(p) => {
+						assert_eq!(p, &pattern);
+						p
+					}
+					None => {
+						panic!("expected type {} got {}", stringify!($x), next.description);
+					}
+				};
+			}
+
+			match_tokens!($tokens_iter, $($rest)*);
+		};
+	}
+
+	/// A trivial token that charges the specified number of gas units.
+	#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+	struct SimpleToken(u64);
+	impl Token<Test> for SimpleToken {
+		fn weight(&self) -> Weight {
+			Weight::from_parts(self.0, 0)
+		}
+	}
+
+	#[test]
+	fn it_works() {
+		let gas_meter = GasMeter::<Test>::new(Weight::from_parts(50000, 0));
+		assert_eq!(gas_meter.gas_left(), Weight::from_parts(50000, 0));
+	}
+
+	#[test]
+	fn tracing() {
+		let mut gas_meter = GasMeter::<Test>::new(Weight::from_parts(50000, 0));
+		assert!(!gas_meter.charge(SimpleToken(1)).is_err());
+
+		let mut tokens = gas_meter.tokens().iter();
+		match_tokens!(tokens, SimpleToken(1),);
+	}
+
+	// This test makes sure that nothing can be executed if there is no gas.
+	#[test]
+	fn refuse_to_execute_anything_if_zero() {
+		let mut gas_meter = GasMeter::<Test>::new(Weight::zero());
+		assert!(gas_meter.charge(SimpleToken(1)).is_err());
+	}
+
+	// Make sure that the gas meter does not charge in case of overcharger
+	#[test]
+	fn overcharge_does_not_charge() {
+		let mut gas_meter = GasMeter::<Test>::new(Weight::from_parts(200, 0));
+
+		// The first charge is should lead to OOG.
+		assert!(gas_meter.charge(SimpleToken(300)).is_err());
+
+		// The gas meter should still contain the full 200.
+		assert!(gas_meter.charge(SimpleToken(200)).is_ok());
+	}
+
+	// Charging the exact amount that the user paid for should be
+	// possible.
+	#[test]
+	fn charge_exact_amount() {
+		let mut gas_meter = GasMeter::<Test>::new(Weight::from_parts(25, 0));
+		assert!(!gas_meter.charge(SimpleToken(25)).is_err());
+	}
+}
diff --git a/substrate/frame/contracts/src/lib.rs b/substrate/frame/contracts/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2b9dd07b3f6fee0fa60b7140ba54e00723466b6d
--- /dev/null
+++ b/substrate/frame/contracts/src/lib.rs
@@ -0,0 +1,1721 @@
+// 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.
+
+//! # Contracts Pallet
+//!
+//! The Contracts module provides functionality for the runtime to deploy and execute WebAssembly
+//! smart-contracts.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! This module extends accounts based on the [`frame_support::traits::fungible`] traits to have
+//! smart-contract functionality. It can be used with other modules that implement accounts based on
+//! the [`frame_support::traits::fungible`] traits. These "smart-contract accounts" have the ability
+//! to instantiate smart-contracts and make calls to other contract and non-contract accounts.
+//!
+//! The smart-contract code is stored once, and later retrievable via its hash.
+//! This means that multiple smart-contracts can be instantiated from the same hash, without
+//! replicating the code each time.
+//!
+//! When a smart-contract is called, its associated code is retrieved via the code hash and gets
+//! executed. This call can alter the storage entries of the smart-contract account, instantiate new
+//! smart-contracts, or call other smart-contracts.
+//!
+//! Finally, when an account is reaped, its associated code and storage of the smart-contract
+//! account will also be deleted.
+//!
+//! ### Weight
+//!
+//! Senders must specify a [`Weight`] limit with every call, as all instructions invoked by the
+//! smart-contract require weight. Unused weight is refunded after the call, regardless of the
+//! execution outcome.
+//!
+//! If the weight limit is reached, then all calls and state changes (including balance transfers)
+//! are only reverted at the current call's contract level. For example, if contract A calls B and B
+//! runs out of gas mid-call, then all of B's calls are reverted. Assuming correct error handling by
+//! contract A, A's other calls and state changes still persist.
+//!
+//! ### Notable Scenarios
+//!
+//! Contract call failures are not always cascading. When failures occur in a sub-call, they do not
+//! "bubble up", and the call will only revert at the specific contract level. For example, if
+//! contract A calls contract B, and B fails, A can decide how to handle that failure, either
+//! proceeding or reverting A's changes.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable functions
+//!
+//! * [`Pallet::instantiate_with_code`] - Deploys a new contract from the supplied Wasm binary,
+//! optionally transferring
+//! some balance. This instantiates a new smart contract account with the supplied code and
+//! calls its constructor to initialize the contract.
+//! * [`Pallet::instantiate`] - The same as `instantiate_with_code` but instead of uploading new
+//! code an existing `code_hash` is supplied.
+//! * [`Pallet::call`] - Makes a call to an account, optionally transferring some balance.
+//! * [`Pallet::upload_code`] - Uploads new code without instantiating a contract from it.
+//! * [`Pallet::remove_code`] - Removes the stored code and refunds the deposit to its owner. Only
+//!   allowed to code owner.
+//! * [`Pallet::set_code`] - Changes the code of an existing contract. Only allowed to `Root`
+//!   origin.
+//! * [`Pallet::migrate`] - Runs migration steps of current multi-block migration in priority,
+//!   before [`Hooks::on_idle`][frame_support::traits::Hooks::on_idle] activates.
+//!
+//! ## Usage
+//!
+//! * [`ink!`](https://use.ink) is language that enables writing Wasm-based smart contracts in plain
+//!   Rust.
+
+#![allow(rustdoc::private_intra_doc_links)]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(feature = "runtime-benchmarks", recursion_limit = "1024")]
+
+mod address;
+mod benchmarking;
+mod exec;
+mod gas;
+mod schedule;
+mod storage;
+mod wasm;
+
+pub mod chain_extension;
+pub mod debug;
+pub mod migration;
+pub mod weights;
+
+#[cfg(test)]
+mod tests;
+use crate::{
+	exec::{AccountIdOf, ErrorOrigin, ExecError, Executable, Key, MomentOf, Stack as ExecStack},
+	gas::GasMeter,
+	storage::{meter::Meter as StorageMeter, ContractInfo, DeletionQueueManager},
+	wasm::{CodeInfo, WasmBlob},
+};
+use codec::{Codec, Decode, Encode, HasCompact, MaxEncodedLen};
+use environmental::*;
+use frame_support::{
+	dispatch::{
+		DispatchError, Dispatchable, GetDispatchInfo, Pays, PostDispatchInfo, RawOrigin,
+		WithPostDispatchInfo,
+	},
+	ensure,
+	error::BadOrigin,
+	traits::{
+		fungible::{Inspect, Mutate, MutateHold},
+		ConstU32, Contains, Get, Randomness, Time,
+	},
+	weights::Weight,
+	BoundedVec, DefaultNoBound, RuntimeDebugNoBound,
+};
+use frame_system::{
+	ensure_signed,
+	pallet_prelude::{BlockNumberFor, OriginFor},
+	EventRecord, Pallet as System,
+};
+use pallet_contracts_primitives::{
+	Code, CodeUploadResult, CodeUploadReturnValue, ContractAccessError, ContractExecResult,
+	ContractInstantiateResult, ContractResult, ExecReturnValue, GetStorageResult,
+	InstantiateReturnValue, StorageDeposit,
+};
+use scale_info::TypeInfo;
+use smallvec::Array;
+use sp_runtime::{
+	traits::{Convert, Hash, Saturating, StaticLookup, Zero},
+	RuntimeDebug,
+};
+use sp_std::{fmt::Debug, prelude::*};
+
+pub use crate::{
+	address::{AddressGenerator, DefaultAddressGenerator},
+	debug::Tracing,
+	exec::Frame,
+	migration::{MigrateSequence, Migration, NoopMigration},
+	pallet::*,
+	schedule::{HostFnWeights, InstructionWeights, Limits, Schedule},
+	wasm::Determinism,
+};
+pub use weights::WeightInfo;
+
+#[cfg(doc)]
+pub use crate::wasm::api_doc;
+
+type CodeHash<T> = <T as frame_system::Config>::Hash;
+type TrieId = BoundedVec<u8, ConstU32<128>>;
+type BalanceOf<T> =
+	<<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
+type CodeVec<T> = BoundedVec<u8, <T as Config>::MaxCodeLen>;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+type DebugBufferVec<T> = BoundedVec<u8, <T as Config>::MaxDebugBufferLen>;
+type EventRecordOf<T> =
+	EventRecord<<T as frame_system::Config>::RuntimeEvent, <T as frame_system::Config>::Hash>;
+
+/// The old weight type.
+///
+/// This is a copy of the [`frame_support::weights::OldWeight`] type since the contracts pallet
+/// needs to support it indefinitely.
+type OldWeight = u64;
+
+/// Used as a sentinel value when reading and writing contract memory.
+///
+/// It is usually used to signal `None` to a contract when only a primitive is allowed
+/// and we don't want to go through encoding a full Rust type. Using `u32::Max` is a safe
+/// sentinel because contracts are never allowed to use such a large amount of resources
+/// that this value makes sense for a memory location or length.
+const SENTINEL: u32 = u32::MAX;
+
+/// The target that is used for the log output emitted by this crate.
+///
+/// Hence you can use this target to selectively increase the log level for this crate.
+///
+/// Example: `RUST_LOG=runtime::contracts=debug my_code --dev`
+const LOG_TARGET: &str = "runtime::contracts";
+
+/// Wrapper around `PhantomData` to prevent it being filtered by `scale-info`.
+///
+/// `scale-info` filters out `PhantomData` fields because usually we are only interested
+/// in sized types. However, when trying to communicate **types** as opposed to **values**
+/// we want to have those zero sized types be included.
+#[derive(Encode, Decode, DefaultNoBound, TypeInfo)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+pub struct EnvironmentType<T>(PhantomData<T>);
+
+/// List of all runtime configurable types that are used in the communication between
+/// `pallet-contracts` and any given contract.
+///
+/// Since those types are configurable they can vary between
+/// chains all using `pallet-contracts`. Hence we need a mechanism to communicate those types
+/// in a way that can be consumed by offchain tooling.
+///
+/// This type only exists in order to appear in the metadata where it can be read by
+/// offchain tooling.
+#[derive(Encode, Decode, DefaultNoBound, TypeInfo)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+#[scale_info(skip_type_params(T))]
+pub struct Environment<T: Config> {
+	account_id: EnvironmentType<AccountIdOf<T>>,
+	balance: EnvironmentType<BalanceOf<T>>,
+	hash: EnvironmentType<<T as frame_system::Config>::Hash>,
+	hasher: EnvironmentType<<T as frame_system::Config>::Hashing>,
+	timestamp: EnvironmentType<MomentOf<T>>,
+	block_number: EnvironmentType<BlockNumberFor<T>>,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use crate::debug::Debugger;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+	use sp_runtime::Perbill;
+
+	/// The current storage version.
+	pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(15);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The time implementation used to supply timestamps to contracts through `seal_now`.
+		type Time: Time;
+
+		/// The generator used to supply randomness to contracts through `seal_random`.
+		///
+		/// # Deprecated
+		///
+		/// Codes using the randomness functionality cannot be uploaded. Neither can contracts
+		/// be instantiated from existing codes that use this deprecated functionality. It will
+		/// be removed eventually. Hence for new `pallet-contracts` deployments it is okay
+		/// to supply a dummy implementation for this type (because it is never used).
+		type Randomness: Randomness<Self::Hash, BlockNumberFor<Self>>;
+
+		/// The fungible in which fees are paid and contract balances are held.
+		type Currency: Inspect<Self::AccountId>
+			+ Mutate<Self::AccountId>
+			+ MutateHold<Self::AccountId, Reason = Self::RuntimeHoldReason>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The overarching call type.
+		type RuntimeCall: Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ GetDispatchInfo
+			+ codec::Decode
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+
+		/// Filter that is applied to calls dispatched by contracts.
+		///
+		/// Use this filter to control which dispatchables are callable by contracts.
+		/// This is applied in **addition** to [`frame_system::Config::BaseCallFilter`].
+		/// It is recommended to treat this as a whitelist.
+		///
+		/// # Stability
+		///
+		/// The runtime **must** make sure that all dispatchables that are callable by
+		/// contracts remain stable. In addition [`Self::RuntimeCall`] itself must remain stable.
+		/// This means that no existing variants are allowed to switch their positions.
+		///
+		/// # Note
+		///
+		/// Note that dispatchables that are called via contracts do not spawn their
+		/// own wasm instance for each call (as opposed to when called via a transaction).
+		/// Therefore please make sure to be restrictive about which dispatchables are allowed
+		/// in order to not introduce a new DoS vector like memory allocation patterns that can
+		/// be exploited to drive the runtime into a panic.
+		type CallFilter: Contains<<Self as frame_system::Config>::RuntimeCall>;
+
+		/// Used to answer contracts' queries regarding the current weight price. This is **not**
+		/// used to calculate the actual fee and is only for informational purposes.
+		type WeightPrice: Convert<Weight, BalanceOf<Self>>;
+
+		/// Describes the weights of the dispatchables of this module and is also used to
+		/// construct a default cost schedule.
+		type WeightInfo: WeightInfo;
+
+		/// Type that allows the runtime authors to add new host functions for a contract to call.
+		type ChainExtension: chain_extension::ChainExtension<Self> + Default;
+
+		/// Cost schedule and limits.
+		#[pallet::constant]
+		type Schedule: Get<Schedule<Self>>;
+
+		/// The type of the call stack determines the maximum nesting depth of contract calls.
+		///
+		/// The allowed depth is `CallStack::size() + 1`.
+		/// Therefore a size of `0` means that a contract cannot use call or instantiate.
+		/// In other words only the origin called "root contract" is allowed to execute then.
+		///
+		/// This setting along with [`MaxCodeLen`](#associatedtype.MaxCodeLen) directly affects
+		/// memory usage of your runtime.
+		type CallStack: Array<Item = Frame<Self>>;
+
+		/// The amount of balance a caller has to pay for each byte of storage.
+		///
+		/// # Note
+		///
+		/// Changing this value for an existing chain might need a storage migration.
+		#[pallet::constant]
+		type DepositPerByte: Get<BalanceOf<Self>>;
+
+		/// Fallback value to limit the storage deposit if it's not being set by the caller.
+		#[pallet::constant]
+		type DefaultDepositLimit: Get<BalanceOf<Self>>;
+
+		/// The amount of balance a caller has to pay for each storage item.
+		///
+		/// # Note
+		///
+		/// Changing this value for an existing chain might need a storage migration.
+		#[pallet::constant]
+		type DepositPerItem: Get<BalanceOf<Self>>;
+
+		/// The percentage of the storage deposit that should be held for using a code hash.
+		/// Instantiating a contract, or calling [`chain_extension::Ext::add_delegate_dependency`]
+		/// protects the code from being removed. In order to prevent abuse these actions are
+		/// protected with a percentage of the code deposit.
+		#[pallet::constant]
+		type CodeHashLockupDepositPercent: Get<Perbill>;
+
+		/// The address generator used to generate the addresses of contracts.
+		type AddressGenerator: AddressGenerator<Self>;
+
+		/// The maximum length of a contract code in bytes.
+		///
+		/// The value should be chosen carefully taking into the account the overall memory limit
+		/// your runtime has, as well as the [maximum allowed callstack
+		/// depth](#associatedtype.CallStack). Look into the `integrity_test()` for some insights.
+		#[pallet::constant]
+		type MaxCodeLen: Get<u32>;
+
+		/// The maximum allowable length in bytes for storage keys.
+		#[pallet::constant]
+		type MaxStorageKeyLen: Get<u32>;
+
+		/// The maximum number of delegate_dependencies that a contract can lock with
+		/// [`chain_extension::Ext::add_delegate_dependency`].
+		#[pallet::constant]
+		type MaxDelegateDependencies: Get<u32>;
+
+		/// Make contract callable functions marked as `#[unstable]` available.
+		///
+		/// Contracts that use `#[unstable]` functions won't be able to be uploaded unless
+		/// this is set to `true`. This is only meant for testnets and dev nodes in order to
+		/// experiment with new features.
+		///
+		/// # Warning
+		///
+		/// Do **not** set to `true` on productions chains.
+		#[pallet::constant]
+		type UnsafeUnstableInterface: Get<bool>;
+
+		/// The maximum length of the debug buffer in bytes.
+		#[pallet::constant]
+		type MaxDebugBufferLen: Get<u32>;
+
+		/// Overarching hold reason.
+		type RuntimeHoldReason: From<HoldReason>;
+
+		/// The sequence of migration steps that will be applied during a migration.
+		///
+		/// # Examples
+		/// ```
+		/// use pallet_contracts::migration::{v10, v11};
+		/// # struct Runtime {};
+		/// # struct Currency {};
+		/// type Migrations = (v10::Migration<Runtime, Currency>, v11::Migration<Runtime>);
+		/// ```
+		///
+		/// If you have a single migration step, you can use a tuple with a single element:
+		/// ```
+		/// use pallet_contracts::migration::v10;
+		/// # struct Runtime {};
+		/// # struct Currency {};
+		/// type Migrations = (v10::Migration<Runtime, Currency>,);
+		/// ```
+		type Migrations: MigrateSequence;
+
+		/// # Note
+		/// For most production chains, it's recommended to use the `()` implementation of this
+		/// trait. This implementation offers additional logging when the log target
+		/// "runtime::contracts" is set to trace.
+		type Debug: Debugger<Self>;
+
+		/// Type that bundles together all the runtime configurable interface types.
+		///
+		/// This is not a real config. We just mention the type here as constant so that
+		/// its type appears in the metadata. Only valid value is `()`.
+		#[pallet::constant]
+		type Environment: Get<Environment<Self>>;
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_idle(_block: BlockNumberFor<T>, mut remaining_weight: Weight) -> Weight {
+			use migration::MigrateResult::*;
+
+			loop {
+				let (result, weight) = Migration::<T>::migrate(remaining_weight);
+				remaining_weight.saturating_reduce(weight);
+
+				match result {
+					// There is not enough weight to perform a migration, or make any progress, we
+					// just return the remaining weight.
+					NoMigrationPerformed | InProgress { steps_done: 0 } => return remaining_weight,
+					// Migration is still in progress, we can start the next step.
+					InProgress { .. } => continue,
+					// Either no migration is in progress, or we are done with all migrations, we
+					// can do some more other work with the remaining weight.
+					Completed | NoMigrationInProgress => break,
+				}
+			}
+
+			ContractInfo::<T>::process_deletion_queue_batch(remaining_weight)
+				.saturating_add(T::WeightInfo::on_process_deletion_queue_batch())
+		}
+
+		fn integrity_test() {
+			Migration::<T>::integrity_test();
+
+			// Total runtime memory limit
+			let max_runtime_mem: u32 = T::Schedule::get().limits.runtime_memory;
+			// Memory limits for a single contract:
+			// Value stack size: 1Mb per contract, default defined in wasmi
+			const MAX_STACK_SIZE: u32 = 1024 * 1024;
+			// Heap limit is normally 16 mempages of 64kb each = 1Mb per contract
+			let max_heap_size = T::Schedule::get().limits.max_memory_size();
+			// Max call depth is CallStack::size() + 1
+			let max_call_depth = u32::try_from(T::CallStack::size().saturating_add(1))
+				.expect("CallStack size is too big");
+
+			// Check that given configured `MaxCodeLen`, runtime heap memory limit can't be broken.
+			//
+			// In worst case, the decoded Wasm contract code would be `x16` times larger than the
+			// encoded one. This is because even a single-byte wasm instruction has 16-byte size in
+			// wasmi. This gives us `MaxCodeLen*16` safety margin.
+			//
+			// Next, the pallet keeps the Wasm blob for each
+			// contract, hence we add up `MaxCodeLen` to the safety margin.
+			//
+			// Finally, the inefficiencies of the freeing-bump allocator
+			// being used in the client for the runtime memory allocations, could lead to possible
+			// memory allocations for contract code grow up to `x4` times in some extreme cases,
+			// which gives us total multiplier of `17*4` for `MaxCodeLen`.
+			//
+			// That being said, for every contract executed in runtime, at least `MaxCodeLen*17*4`
+			// memory should be available. Note that maximum allowed heap memory and stack size per
+			// each contract (stack frame) should also be counted.
+			//
+			// Finally, we allow 50% of the runtime memory to be utilized by the contracts call
+			// stack, keeping the rest for other facilities, such as PoV, etc.
+			//
+			// This gives us the following formula:
+			//
+			// `(MaxCodeLen * 17 * 4 + MAX_STACK_SIZE + max_heap_size) * max_call_depth <
+			// max_runtime_mem/2`
+			//
+			// Hence the upper limit for the `MaxCodeLen` can be defined as follows:
+			let code_len_limit = max_runtime_mem
+				.saturating_div(2)
+				.saturating_div(max_call_depth)
+				.saturating_sub(max_heap_size)
+				.saturating_sub(MAX_STACK_SIZE)
+				.saturating_div(17 * 4);
+
+			assert!(
+				T::MaxCodeLen::get() < code_len_limit,
+				"Given `CallStack` height {:?}, `MaxCodeLen` should be set less than {:?} \
+				 (current value is {:?}), to avoid possible runtime oom issues.",
+				max_call_depth,
+				code_len_limit,
+				T::MaxCodeLen::get(),
+			);
+
+			// Debug buffer should at least be large enough to accommodate a simple error message
+			const MIN_DEBUG_BUF_SIZE: u32 = 256;
+			assert!(
+				T::MaxDebugBufferLen::get() > MIN_DEBUG_BUF_SIZE,
+				"Debug buffer should have minimum size of {} (current setting is {})",
+				MIN_DEBUG_BUF_SIZE,
+				T::MaxDebugBufferLen::get(),
+			)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T>
+	where
+		<BalanceOf<T> as HasCompact>::Type: Clone + Eq + PartialEq + Debug + TypeInfo + Encode,
+	{
+		/// Deprecated version if [`Self::call`] for use in an in-storage `Call`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::call().saturating_add(<Pallet<T>>::compat_weight_limit(*gas_limit)))]
+		#[allow(deprecated)]
+		#[deprecated(note = "1D weight is used in this extrinsic, please migrate to `call`")]
+		pub fn call_old_weight(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+			#[pallet::compact] gas_limit: OldWeight,
+			storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+			data: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			Self::call(
+				origin,
+				dest,
+				value,
+				<Pallet<T>>::compat_weight_limit(gas_limit),
+				storage_deposit_limit,
+				data,
+			)
+		}
+
+		/// Deprecated version if [`Self::instantiate_with_code`] for use in an in-storage `Call`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(
+			T::WeightInfo::instantiate_with_code(code.len() as u32, data.len() as u32, salt.len() as u32)
+			.saturating_add(<Pallet<T>>::compat_weight_limit(*gas_limit))
+		)]
+		#[allow(deprecated)]
+		#[deprecated(
+			note = "1D weight is used in this extrinsic, please migrate to `instantiate_with_code`"
+		)]
+		pub fn instantiate_with_code_old_weight(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+			#[pallet::compact] gas_limit: OldWeight,
+			storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+			code: Vec<u8>,
+			data: Vec<u8>,
+			salt: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			Self::instantiate_with_code(
+				origin,
+				value,
+				<Pallet<T>>::compat_weight_limit(gas_limit),
+				storage_deposit_limit,
+				code,
+				data,
+				salt,
+			)
+		}
+
+		/// Deprecated version if [`Self::instantiate`] for use in an in-storage `Call`.
+		#[pallet::call_index(2)]
+		#[pallet::weight(
+			T::WeightInfo::instantiate(data.len() as u32, salt.len() as u32).saturating_add(<Pallet<T>>::compat_weight_limit(*gas_limit))
+		)]
+		#[allow(deprecated)]
+		#[deprecated(note = "1D weight is used in this extrinsic, please migrate to `instantiate`")]
+		pub fn instantiate_old_weight(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+			#[pallet::compact] gas_limit: OldWeight,
+			storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+			code_hash: CodeHash<T>,
+			data: Vec<u8>,
+			salt: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			Self::instantiate(
+				origin,
+				value,
+				<Pallet<T>>::compat_weight_limit(gas_limit),
+				storage_deposit_limit,
+				code_hash,
+				data,
+				salt,
+			)
+		}
+
+		/// Upload new `code` without instantiating a contract from it.
+		///
+		/// If the code does not already exist a deposit is reserved from the caller
+		/// and unreserved only when [`Self::remove_code`] is called. The size of the reserve
+		/// depends on the size of the supplied `code`.
+		///
+		/// If the code already exists in storage it will still return `Ok` and upgrades
+		/// the in storage version to the current
+		/// [`InstructionWeights::version`](InstructionWeights).
+		///
+		/// - `determinism`: If this is set to any other value but [`Determinism::Enforced`] then
+		///   the only way to use this code is to delegate call into it from an offchain execution.
+		///   Set to [`Determinism::Enforced`] if in doubt.
+		///
+		/// # Note
+		///
+		/// Anyone can instantiate a contract from any uploaded code and thus prevent its removal.
+		/// To avoid this situation a constructor could employ access control so that it can
+		/// only be instantiated by permissioned entities. The same is true when uploading
+		/// through [`Self::instantiate_with_code`].
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::upload_code(code.len() as u32))]
+		pub fn upload_code(
+			origin: OriginFor<T>,
+			code: Vec<u8>,
+			storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+			determinism: Determinism,
+		) -> DispatchResult {
+			Migration::<T>::ensure_migrated()?;
+			let origin = ensure_signed(origin)?;
+			Self::bare_upload_code(origin, code, storage_deposit_limit.map(Into::into), determinism)
+				.map(|_| ())
+		}
+
+		/// Remove the code stored under `code_hash` and refund the deposit to its owner.
+		///
+		/// A code can only be removed by its original uploader (its owner) and only if it is
+		/// not used by any contract.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::remove_code())]
+		pub fn remove_code(
+			origin: OriginFor<T>,
+			code_hash: CodeHash<T>,
+		) -> DispatchResultWithPostInfo {
+			Migration::<T>::ensure_migrated()?;
+			let origin = ensure_signed(origin)?;
+			<WasmBlob<T>>::remove(&origin, code_hash)?;
+			// we waive the fee because removing unused code is beneficial
+			Ok(Pays::No.into())
+		}
+
+		/// Privileged function that changes the code of an existing contract.
+		///
+		/// This takes care of updating refcounts and all other necessary operations. Returns
+		/// an error if either the `code_hash` or `dest` do not exist.
+		///
+		/// # Note
+		///
+		/// This does **not** change the address of the contract in question. This means
+		/// that the contract address is no longer derived from its code hash after calling
+		/// this dispatchable.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::set_code())]
+		pub fn set_code(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			code_hash: CodeHash<T>,
+		) -> DispatchResult {
+			Migration::<T>::ensure_migrated()?;
+			ensure_root(origin)?;
+			let dest = T::Lookup::lookup(dest)?;
+			<ContractInfoOf<T>>::try_mutate(&dest, |contract| {
+				let contract = if let Some(contract) = contract {
+					contract
+				} else {
+					return Err(<Error<T>>::ContractNotFound.into())
+				};
+				<WasmBlob<T>>::increment_refcount(code_hash)?;
+				<WasmBlob<T>>::decrement_refcount(contract.code_hash);
+				Self::deposit_event(
+					vec![T::Hashing::hash_of(&dest), code_hash, contract.code_hash],
+					Event::ContractCodeUpdated {
+						contract: dest.clone(),
+						new_code_hash: code_hash,
+						old_code_hash: contract.code_hash,
+					},
+				);
+				contract.code_hash = code_hash;
+				Ok(())
+			})
+		}
+
+		/// Makes a call to an account, optionally transferring some balance.
+		///
+		/// # Parameters
+		///
+		/// * `dest`: Address of the contract to call.
+		/// * `value`: The balance to transfer from the `origin` to `dest`.
+		/// * `gas_limit`: The gas limit enforced when executing the constructor.
+		/// * `storage_deposit_limit`: The maximum amount of balance that can be charged from the
+		///   caller to pay for the storage consumed.
+		/// * `data`: The input data to pass to the contract.
+		///
+		/// * If the account is a smart-contract account, the associated code will be
+		/// executed and any value will be transferred.
+		/// * If the account is a regular account, any value will be transferred.
+		/// * If no account exists and the call value is not less than `existential_deposit`,
+		/// a regular account will be created and any value will be transferred.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::call().saturating_add(*gas_limit))]
+		pub fn call(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+			gas_limit: Weight,
+			storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+			data: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			Migration::<T>::ensure_migrated()?;
+			let common = CommonInput {
+				origin: Origin::from_runtime_origin(origin)?,
+				value,
+				data,
+				gas_limit: gas_limit.into(),
+				storage_deposit_limit: storage_deposit_limit.map(Into::into),
+				debug_message: None,
+			};
+			let dest = T::Lookup::lookup(dest)?;
+			let mut output =
+				CallInput::<T> { dest, determinism: Determinism::Enforced }.run_guarded(common);
+			if let Ok(retval) = &output.result {
+				if retval.did_revert() {
+					output.result = Err(<Error<T>>::ContractReverted.into());
+				}
+			}
+			output.gas_meter.into_dispatch_result(output.result, T::WeightInfo::call())
+		}
+
+		/// Instantiates a new contract from the supplied `code` optionally transferring
+		/// some balance.
+		///
+		/// This dispatchable has the same effect as calling [`Self::upload_code`] +
+		/// [`Self::instantiate`]. Bundling them together provides efficiency gains. Please
+		/// also check the documentation of [`Self::upload_code`].
+		///
+		/// # Parameters
+		///
+		/// * `value`: The balance to transfer from the `origin` to the newly created contract.
+		/// * `gas_limit`: The gas limit enforced when executing the constructor.
+		/// * `storage_deposit_limit`: The maximum amount of balance that can be charged/reserved
+		///   from the caller to pay for the storage consumed.
+		/// * `code`: The contract code to deploy in raw bytes.
+		/// * `data`: The input data to pass to the contract constructor.
+		/// * `salt`: Used for the address derivation. See [`Pallet::contract_address`].
+		///
+		/// Instantiation is executed as follows:
+		///
+		/// - The supplied `code` is deployed, and a `code_hash` is created for that code.
+		/// - If the `code_hash` already exists on the chain the underlying `code` will be shared.
+		/// - The destination address is computed based on the sender, code_hash and the salt.
+		/// - The smart-contract account is created at the computed address.
+		/// - The `value` is transferred to the new account.
+		/// - The `deploy` function is executed in the context of the newly-created account.
+		#[pallet::call_index(7)]
+		#[pallet::weight(
+			T::WeightInfo::instantiate_with_code(code.len() as u32, data.len() as u32, salt.len() as u32)
+			.saturating_add(*gas_limit)
+		)]
+		pub fn instantiate_with_code(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+			gas_limit: Weight,
+			storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+			code: Vec<u8>,
+			data: Vec<u8>,
+			salt: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			Migration::<T>::ensure_migrated()?;
+			let origin = ensure_signed(origin)?;
+			let code_len = code.len() as u32;
+
+			let (module, upload_deposit) = Self::try_upload_code(
+				origin.clone(),
+				code,
+				storage_deposit_limit.clone().map(Into::into),
+				Determinism::Enforced,
+				None,
+			)?;
+
+			// Reduces the storage deposit limit by the amount that was reserved for the upload.
+			let storage_deposit_limit =
+				storage_deposit_limit.map(|limit| limit.into().saturating_sub(upload_deposit));
+
+			let data_len = data.len() as u32;
+			let salt_len = salt.len() as u32;
+			let common = CommonInput {
+				origin: Origin::from_account_id(origin),
+				value,
+				data,
+				gas_limit,
+				storage_deposit_limit,
+				debug_message: None,
+			};
+
+			let mut output =
+				InstantiateInput::<T> { code: WasmCode::Wasm(module), salt }.run_guarded(common);
+			if let Ok(retval) = &output.result {
+				if retval.1.did_revert() {
+					output.result = Err(<Error<T>>::ContractReverted.into());
+				}
+			}
+
+			output.gas_meter.into_dispatch_result(
+				output.result.map(|(_address, output)| output),
+				T::WeightInfo::instantiate_with_code(code_len, data_len, salt_len),
+			)
+		}
+
+		/// Instantiates a contract from a previously deployed wasm binary.
+		///
+		/// This function is identical to [`Self::instantiate_with_code`] but without the
+		/// code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary
+		/// must be supplied.
+		#[pallet::call_index(8)]
+		#[pallet::weight(
+			T::WeightInfo::instantiate(data.len() as u32, salt.len() as u32).saturating_add(*gas_limit)
+		)]
+		pub fn instantiate(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+			gas_limit: Weight,
+			storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+			code_hash: CodeHash<T>,
+			data: Vec<u8>,
+			salt: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			Migration::<T>::ensure_migrated()?;
+			let data_len = data.len() as u32;
+			let salt_len = salt.len() as u32;
+			let common = CommonInput {
+				origin: Origin::from_runtime_origin(origin)?,
+				value,
+				data,
+				gas_limit,
+				storage_deposit_limit: storage_deposit_limit.map(Into::into),
+				debug_message: None,
+			};
+			let mut output = InstantiateInput::<T> { code: WasmCode::CodeHash(code_hash), salt }
+				.run_guarded(common);
+			if let Ok(retval) = &output.result {
+				if retval.1.did_revert() {
+					output.result = Err(<Error<T>>::ContractReverted.into());
+				}
+			}
+			output.gas_meter.into_dispatch_result(
+				output.result.map(|(_address, output)| output),
+				T::WeightInfo::instantiate(data_len, salt_len),
+			)
+		}
+
+		/// When a migration is in progress, this dispatchable can be used to run migration steps.
+		/// Calls that contribute to advancing the migration have their fees waived, as it's helpful
+		/// for the chain. Note that while the migration is in progress, the pallet will also
+		/// leverage the `on_idle` hooks to run migration steps.
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::migrate().saturating_add(*weight_limit))]
+		pub fn migrate(origin: OriginFor<T>, weight_limit: Weight) -> DispatchResultWithPostInfo {
+			use migration::MigrateResult::*;
+			ensure_signed(origin)?;
+
+			let weight_limit = weight_limit.saturating_add(T::WeightInfo::migrate());
+			let (result, weight) = Migration::<T>::migrate(weight_limit);
+
+			match result {
+				Completed =>
+					Ok(PostDispatchInfo { actual_weight: Some(weight), pays_fee: Pays::No }),
+				InProgress { steps_done, .. } if steps_done > 0 =>
+					Ok(PostDispatchInfo { actual_weight: Some(weight), pays_fee: Pays::No }),
+				InProgress { .. } =>
+					Ok(PostDispatchInfo { actual_weight: Some(weight), pays_fee: Pays::Yes }),
+				NoMigrationInProgress | NoMigrationPerformed => {
+					let err: DispatchError = <Error<T>>::NoMigrationPerformed.into();
+					Err(err.with_weight(T::WeightInfo::migrate()))
+				},
+			}
+		}
+	}
+
+	#[pallet::event]
+	pub enum Event<T: Config> {
+		/// Contract deployed by address at the specified address.
+		Instantiated { deployer: T::AccountId, contract: T::AccountId },
+
+		/// Contract has been removed.
+		///
+		/// # Note
+		///
+		/// The only way for a contract to be removed and emitting this event is by calling
+		/// `seal_terminate`.
+		Terminated {
+			/// The contract that was terminated.
+			contract: T::AccountId,
+			/// The account that received the contracts remaining balance
+			beneficiary: T::AccountId,
+		},
+
+		/// Code with the specified hash has been stored.
+		CodeStored { code_hash: T::Hash, deposit_held: BalanceOf<T>, uploader: T::AccountId },
+
+		/// A custom event emitted by the contract.
+		ContractEmitted {
+			/// The contract that emitted the event.
+			contract: T::AccountId,
+			/// Data supplied by the contract. Metadata generated during contract compilation
+			/// is needed to decode it.
+			data: Vec<u8>,
+		},
+
+		/// A code with the specified hash was removed.
+		CodeRemoved { code_hash: T::Hash, deposit_released: BalanceOf<T>, remover: T::AccountId },
+
+		/// A contract's code was updated.
+		ContractCodeUpdated {
+			/// The contract that has been updated.
+			contract: T::AccountId,
+			/// New code hash that was set for the contract.
+			new_code_hash: T::Hash,
+			/// Previous code hash of the contract.
+			old_code_hash: T::Hash,
+		},
+
+		/// A contract was called either by a plain account or another contract.
+		///
+		/// # Note
+		///
+		/// Please keep in mind that like all events this is only emitted for successful
+		/// calls. This is because on failure all storage changes including events are
+		/// rolled back.
+		Called {
+			/// The caller of the `contract`.
+			caller: Origin<T>,
+			/// The contract that was called.
+			contract: T::AccountId,
+		},
+
+		/// A contract delegate called a code hash.
+		///
+		/// # Note
+		///
+		/// Please keep in mind that like all events this is only emitted for successful
+		/// calls. This is because on failure all storage changes including events are
+		/// rolled back.
+		DelegateCalled {
+			/// The contract that performed the delegate call and hence in whose context
+			/// the `code_hash` is executed.
+			contract: T::AccountId,
+			/// The code hash that was delegate called.
+			code_hash: CodeHash<T>,
+		},
+
+		/// Some funds have been transferred and held as storage deposit.
+		StorageDepositTransferredAndHeld {
+			from: T::AccountId,
+			to: T::AccountId,
+			amount: BalanceOf<T>,
+		},
+
+		/// Some storage deposit funds have been transferred and released.
+		StorageDepositTransferredAndReleased {
+			from: T::AccountId,
+			to: T::AccountId,
+			amount: BalanceOf<T>,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Invalid schedule supplied, e.g. with zero weight of a basic operation.
+		InvalidSchedule,
+		/// Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
+		InvalidCallFlags,
+		/// The executed contract exhausted its gas limit.
+		OutOfGas,
+		/// The output buffer supplied to a contract API call was too small.
+		OutputBufferTooSmall,
+		/// Performing the requested transfer failed. Probably because there isn't enough
+		/// free balance in the sender's account.
+		TransferFailed,
+		/// Performing a call was denied because the calling depth reached the limit
+		/// of what is specified in the schedule.
+		MaxCallDepthReached,
+		/// No contract was found at the specified address.
+		ContractNotFound,
+		/// The code supplied to `instantiate_with_code` exceeds the limit specified in the
+		/// current schedule.
+		CodeTooLarge,
+		/// No code could be found at the supplied code hash.
+		CodeNotFound,
+		/// No code info could be found at the supplied code hash.
+		CodeInfoNotFound,
+		/// A buffer outside of sandbox memory was passed to a contract API function.
+		OutOfBounds,
+		/// Input passed to a contract API function failed to decode as expected type.
+		DecodingFailed,
+		/// Contract trapped during execution.
+		ContractTrapped,
+		/// The size defined in `T::MaxValueSize` was exceeded.
+		ValueTooLarge,
+		/// Termination of a contract is not allowed while the contract is already
+		/// on the call stack. Can be triggered by `seal_terminate`.
+		TerminatedWhileReentrant,
+		/// `seal_call` forwarded this contracts input. It therefore is no longer available.
+		InputForwarded,
+		/// The subject passed to `seal_random` exceeds the limit.
+		RandomSubjectTooLong,
+		/// The amount of topics passed to `seal_deposit_events` exceeds the limit.
+		TooManyTopics,
+		/// The chain does not provide a chain extension. Calling the chain extension results
+		/// in this error. Note that this usually  shouldn't happen as deploying such contracts
+		/// is rejected.
+		NoChainExtension,
+		/// A contract with the same AccountId already exists.
+		DuplicateContract,
+		/// A contract self destructed in its constructor.
+		///
+		/// This can be triggered by a call to `seal_terminate`.
+		TerminatedInConstructor,
+		/// A call tried to invoke a contract that is flagged as non-reentrant.
+		/// The only other cause is that a call from a contract into the runtime tried to call back
+		/// into `pallet-contracts`. This would make the whole pallet reentrant with regard to
+		/// contract code execution which is not supported.
+		ReentranceDenied,
+		/// Origin doesn't have enough balance to pay the required storage deposits.
+		StorageDepositNotEnoughFunds,
+		/// More storage was created than allowed by the storage deposit limit.
+		StorageDepositLimitExhausted,
+		/// Code removal was denied because the code is still in use by at least one contract.
+		CodeInUse,
+		/// The contract ran to completion but decided to revert its storage changes.
+		/// Please note that this error is only returned from extrinsics. When called directly
+		/// or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags
+		/// to determine whether a reversion has taken place.
+		ContractReverted,
+		/// The contract's code was found to be invalid during validation.
+		///
+		/// The most likely cause of this is that an API was used which is not supported by the
+		/// node. This happens if an older node is used with a new version of ink!. Try updating
+		/// your node to the newest available version.
+		///
+		/// A more detailed error can be found on the node console if debug messages are enabled
+		/// by supplying `-lruntime::contracts=debug`.
+		CodeRejected,
+		/// An indetermistic code was used in a context where this is not permitted.
+		Indeterministic,
+		/// A pending migration needs to complete before the extrinsic can be called.
+		MigrationInProgress,
+		/// Migrate dispatch call was attempted but no migration was performed.
+		NoMigrationPerformed,
+		/// The contract has reached its maximum number of delegate dependencies.
+		MaxDelegateDependenciesReached,
+		/// The dependency was not found in the contract's delegate dependencies.
+		DelegateDependencyNotFound,
+		/// The contract already depends on the given delegate dependency.
+		DelegateDependencyAlreadyExists,
+		/// Can not add a delegate dependency to the code hash of the contract itself.
+		CannotAddSelfAsDelegateDependency,
+	}
+
+	/// A reason for the pallet contracts placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// The Pallet has reserved it for storing code on-chain.
+		CodeUploadDepositReserve,
+		/// The Pallet has reserved it for storage deposit.
+		StorageDepositReserve,
+	}
+
+	/// A mapping from a contract's code hash to its code.
+	#[pallet::storage]
+	pub(crate) type PristineCode<T: Config> = StorageMap<_, Identity, CodeHash<T>, CodeVec<T>>;
+
+	/// A mapping from a contract's code hash to its code info.
+	#[pallet::storage]
+	pub(crate) type CodeInfoOf<T: Config> = StorageMap<_, Identity, CodeHash<T>, CodeInfo<T>>;
+
+	/// This is a **monotonic** counter incremented on contract instantiation.
+	///
+	/// This is used in order to generate unique trie ids for contracts.
+	/// The trie id of a new contract is calculated from hash(account_id, nonce).
+	/// The nonce is required because otherwise the following sequence would lead to
+	/// a possible collision of storage:
+	///
+	/// 1. Create a new contract.
+	/// 2. Terminate the contract.
+	/// 3. Immediately recreate the contract with the same account_id.
+	///
+	/// This is bad because the contents of a trie are deleted lazily and there might be
+	/// storage of the old instantiation still in it when the new contract is created. Please
+	/// note that we can't replace the counter by the block number because the sequence above
+	/// can happen in the same block. We also can't keep the account counter in memory only
+	/// because storage is the only way to communicate across different extrinsics in the
+	/// same block.
+	///
+	/// # Note
+	///
+	/// Do not use it to determine the number of contracts. It won't be decremented if
+	/// a contract is destroyed.
+	#[pallet::storage]
+	pub(crate) type Nonce<T: Config> = StorageValue<_, u64, ValueQuery>;
+
+	/// The code associated with a given account.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+	#[pallet::storage]
+	pub(crate) type ContractInfoOf<T: Config> =
+		StorageMap<_, Twox64Concat, T::AccountId, ContractInfo<T>>;
+
+	/// Evicted contracts that await child trie deletion.
+	///
+	/// Child trie deletion is a heavy operation depending on the amount of storage items
+	/// stored in said trie. Therefore this operation is performed lazily in `on_idle`.
+	#[pallet::storage]
+	pub(crate) type DeletionQueue<T: Config> = StorageMap<_, Twox64Concat, u32, TrieId>;
+
+	/// A pair of monotonic counters used to track the latest contract marked for deletion
+	/// and the latest deleted contract in queue.
+	#[pallet::storage]
+	pub(crate) type DeletionQueueCounter<T: Config> =
+		StorageValue<_, DeletionQueueManager<T>, ValueQuery>;
+
+	/// A migration can span across multiple blocks. This storage defines a cursor to track the
+	/// progress of the migration, enabling us to resume from the last completed position.
+	#[pallet::storage]
+	pub(crate) type MigrationInProgress<T: Config> =
+		StorageValue<_, migration::Cursor, OptionQuery>;
+}
+
+/// The type of origins supported by the contracts pallet.
+#[derive(Clone, Encode, Decode, PartialEq, TypeInfo, RuntimeDebugNoBound)]
+pub enum Origin<T: Config> {
+	Root,
+	Signed(T::AccountId),
+}
+
+impl<T: Config> Origin<T> {
+	/// Creates a new Signed Caller from an AccountId.
+	pub fn from_account_id(account_id: T::AccountId) -> Self {
+		Origin::Signed(account_id)
+	}
+	/// Creates a new Origin from a `RuntimeOrigin`.
+	pub fn from_runtime_origin(o: OriginFor<T>) -> Result<Self, DispatchError> {
+		match o.into() {
+			Ok(RawOrigin::Root) => Ok(Self::Root),
+			Ok(RawOrigin::Signed(t)) => Ok(Self::Signed(t)),
+			_ => Err(BadOrigin.into()),
+		}
+	}
+	/// Returns the AccountId of a Signed Origin or an error if the origin is Root.
+	pub fn account_id(&self) -> Result<&T::AccountId, DispatchError> {
+		match self {
+			Origin::Signed(id) => Ok(id),
+			Origin::Root => Err(DispatchError::RootNotAllowed),
+		}
+	}
+}
+
+/// Context of a contract invocation.
+struct CommonInput<'a, T: Config> {
+	origin: Origin<T>,
+	value: BalanceOf<T>,
+	data: Vec<u8>,
+	gas_limit: Weight,
+	storage_deposit_limit: Option<BalanceOf<T>>,
+	debug_message: Option<&'a mut DebugBufferVec<T>>,
+}
+
+/// Input specific to a call into contract.
+struct CallInput<T: Config> {
+	dest: T::AccountId,
+	determinism: Determinism,
+}
+
+/// Reference to an existing code hash or a new wasm module.
+enum WasmCode<T: Config> {
+	Wasm(WasmBlob<T>),
+	CodeHash(CodeHash<T>),
+}
+
+/// Input specific to a contract instantiation invocation.
+struct InstantiateInput<T: Config> {
+	code: WasmCode<T>,
+	salt: Vec<u8>,
+}
+
+/// Determines whether events should be collected during execution.
+#[derive(
+	Copy, Clone, PartialEq, Eq, RuntimeDebug, Decode, Encode, MaxEncodedLen, scale_info::TypeInfo,
+)]
+pub enum CollectEvents {
+	/// Collect events.
+	///
+	/// # Note
+	///
+	/// Events should only be collected when called off-chain, as this would otherwise
+	/// collect all the Events emitted in the block so far and put them into the PoV.
+	///
+	/// **Never** use this mode for on-chain execution.
+	UnsafeCollect,
+	/// Skip event collection.
+	Skip,
+}
+
+/// Determines whether debug messages will be collected.
+#[derive(
+	Copy, Clone, PartialEq, Eq, RuntimeDebug, Decode, Encode, MaxEncodedLen, scale_info::TypeInfo,
+)]
+pub enum DebugInfo {
+	/// Collect debug messages.
+	/// # Note
+	///
+	/// This should only ever be set to `UnsafeDebug` when executing as an RPC because
+	/// it adds allocations and could be abused to drive the runtime into an OOM panic.
+	UnsafeDebug,
+	/// Skip collection of debug messages.
+	Skip,
+}
+
+/// Return type of private helper functions.
+struct InternalOutput<T: Config, O> {
+	/// The gas meter that was used to execute the call.
+	gas_meter: GasMeter<T>,
+	/// The storage deposit used by the call.
+	storage_deposit: StorageDeposit<BalanceOf<T>>,
+	/// The result of the call.
+	result: Result<O, ExecError>,
+}
+
+/// Helper trait to wrap contract execution entry points into a single function
+/// [`Invokable::run_guarded`].
+trait Invokable<T: Config>: Sized {
+	/// What is returned as a result of a successful invocation.
+	type Output;
+
+	/// Single entry point to contract execution.
+	/// Downstream execution flow is branched by implementations of [`Invokable`] trait:
+	///
+	/// - [`InstantiateInput::run`] runs contract instantiation,
+	/// - [`CallInput::run`] runs contract call.
+	///
+	/// We enforce a re-entrancy guard here by initializing and checking a boolean flag through a
+	/// global reference.
+	fn run_guarded(self, common: CommonInput<T>) -> InternalOutput<T, Self::Output> {
+		// Set up a global reference to the boolean flag used for the re-entrancy guard.
+		environmental!(executing_contract: bool);
+
+		let gas_limit = common.gas_limit;
+
+		// Check whether the origin is allowed here. The logic of the access rules
+		// is in the `ensure_origin`, this could vary for different implementations of this
+		// trait. For example, some actions might not allow Root origin as they could require an
+		// AccountId associated with the origin.
+		if let Err(e) = self.ensure_origin(common.origin.clone()) {
+			return InternalOutput {
+				gas_meter: GasMeter::new(gas_limit),
+				storage_deposit: Default::default(),
+				result: Err(ExecError { error: e.into(), origin: ErrorOrigin::Caller }),
+			}
+		}
+
+		executing_contract::using_once(&mut false, || {
+			executing_contract::with(|f| {
+				// Fail if already entered contract execution
+				if *f {
+					return Err(())
+				}
+				// We are entering contract execution
+				*f = true;
+				Ok(())
+			})
+			.expect("Returns `Ok` if called within `using_once`. It is syntactically obvious that this is the case; qed")
+			.map_or_else(
+				|_| InternalOutput {
+					gas_meter: GasMeter::new(gas_limit),
+					storage_deposit: Default::default(),
+					result: Err(ExecError {
+						error: <Error<T>>::ReentranceDenied.into(),
+						origin: ErrorOrigin::Caller,
+					}),
+				},
+				// Enter contract call.
+				|_| self.run(common, GasMeter::new(gas_limit)),
+			)
+		})
+	}
+
+	/// Method that does the actual call to a contract. It can be either a call to a deployed
+	/// contract or a instantiation of a new one.
+	///
+	/// Called by dispatchables and public functions through the [`Invokable::run_guarded`].
+	fn run(self, common: CommonInput<T>, gas_meter: GasMeter<T>)
+		-> InternalOutput<T, Self::Output>;
+
+	/// This method ensures that the given `origin` is allowed to invoke the current `Invokable`.
+	///
+	/// Called by dispatchables and public functions through the [`Invokable::run_guarded`].
+	fn ensure_origin(&self, origin: Origin<T>) -> Result<(), DispatchError>;
+}
+
+impl<T: Config> Invokable<T> for CallInput<T> {
+	type Output = ExecReturnValue;
+
+	fn run(
+		self,
+		common: CommonInput<T>,
+		mut gas_meter: GasMeter<T>,
+	) -> InternalOutput<T, Self::Output> {
+		let CallInput { dest, determinism } = self;
+		let CommonInput { origin, value, data, debug_message, .. } = common;
+		let mut storage_meter =
+			match StorageMeter::new(&origin, common.storage_deposit_limit, common.value) {
+				Ok(meter) => meter,
+				Err(err) =>
+					return InternalOutput {
+						result: Err(err.into()),
+						gas_meter,
+						storage_deposit: Default::default(),
+					},
+			};
+		let schedule = T::Schedule::get();
+		let result = ExecStack::<T, WasmBlob<T>>::run_call(
+			origin.clone(),
+			dest.clone(),
+			&mut gas_meter,
+			&mut storage_meter,
+			&schedule,
+			value,
+			data.clone(),
+			debug_message,
+			determinism,
+		);
+
+		match storage_meter.try_into_deposit(&origin) {
+			Ok(storage_deposit) => InternalOutput { gas_meter, storage_deposit, result },
+			Err(err) => InternalOutput {
+				gas_meter,
+				storage_deposit: Default::default(),
+				result: Err(err.into()),
+			},
+		}
+	}
+
+	fn ensure_origin(&self, _origin: Origin<T>) -> Result<(), DispatchError> {
+		Ok(())
+	}
+}
+
+impl<T: Config> Invokable<T> for InstantiateInput<T> {
+	type Output = (AccountIdOf<T>, ExecReturnValue);
+
+	fn run(
+		self,
+		common: CommonInput<T>,
+		mut gas_meter: GasMeter<T>,
+	) -> InternalOutput<T, Self::Output> {
+		let mut storage_deposit = Default::default();
+		let try_exec = || {
+			let schedule = T::Schedule::get();
+			let InstantiateInput { salt, .. } = self;
+			let CommonInput { origin: contract_origin, .. } = common;
+			let origin = contract_origin.account_id()?;
+
+			let executable = match self.code {
+				WasmCode::Wasm(module) => module,
+				WasmCode::CodeHash(code_hash) => WasmBlob::from_storage(code_hash, &mut gas_meter)?,
+			};
+
+			let contract_origin = Origin::from_account_id(origin.clone());
+			let mut storage_meter =
+				StorageMeter::new(&contract_origin, common.storage_deposit_limit, common.value)?;
+			let CommonInput { value, data, debug_message, .. } = common;
+			let result = ExecStack::<T, WasmBlob<T>>::run_instantiate(
+				origin.clone(),
+				executable,
+				&mut gas_meter,
+				&mut storage_meter,
+				&schedule,
+				value,
+				data.clone(),
+				&salt,
+				debug_message,
+			);
+
+			storage_deposit = storage_meter.try_into_deposit(&contract_origin)?;
+			result
+		};
+		InternalOutput { result: try_exec(), gas_meter, storage_deposit }
+	}
+
+	fn ensure_origin(&self, origin: Origin<T>) -> Result<(), DispatchError> {
+		match origin {
+			Origin::Signed(_) => Ok(()),
+			Origin::Root => Err(DispatchError::RootNotAllowed),
+		}
+	}
+}
+
+macro_rules! ensure_no_migration_in_progress {
+	() => {
+		if Migration::<T>::in_progress() {
+			return ContractResult {
+				gas_consumed: Zero::zero(),
+				gas_required: Zero::zero(),
+				storage_deposit: Default::default(),
+				debug_message: Vec::new(),
+				result: Err(Error::<T>::MigrationInProgress.into()),
+				events: None,
+			}
+		}
+	};
+}
+
+impl<T: Config> Pallet<T> {
+	/// Perform a call to a specified contract.
+	///
+	/// This function is similar to [`Self::call`], but doesn't perform any address lookups
+	/// and better suitable for calling directly from Rust.
+	///
+	/// # Note
+	///
+	/// If `debug` is set to `DebugInfo::UnsafeDebug` it returns additional human readable debugging
+	/// information.
+	///
+	/// If `collect_events` is set to `CollectEvents::UnsafeCollect` it collects all the Events
+	/// emitted in the block so far and the ones emitted during the execution of this contract.
+	pub fn bare_call(
+		origin: T::AccountId,
+		dest: T::AccountId,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<BalanceOf<T>>,
+		data: Vec<u8>,
+		debug: DebugInfo,
+		collect_events: CollectEvents,
+		determinism: Determinism,
+	) -> ContractExecResult<BalanceOf<T>, EventRecordOf<T>> {
+		ensure_no_migration_in_progress!();
+
+		let mut debug_message = if matches!(debug, DebugInfo::UnsafeDebug) {
+			Some(DebugBufferVec::<T>::default())
+		} else {
+			None
+		};
+		let origin = Origin::from_account_id(origin);
+		let common = CommonInput {
+			origin,
+			value,
+			data,
+			gas_limit,
+			storage_deposit_limit,
+			debug_message: debug_message.as_mut(),
+		};
+		let output = CallInput::<T> { dest, determinism }.run_guarded(common);
+		let events = if matches!(collect_events, CollectEvents::UnsafeCollect) {
+			Some(System::<T>::read_events_no_consensus().map(|e| *e).collect())
+		} else {
+			None
+		};
+
+		ContractExecResult {
+			result: output.result.map_err(|r| r.error),
+			gas_consumed: output.gas_meter.gas_consumed(),
+			gas_required: output.gas_meter.gas_required(),
+			storage_deposit: output.storage_deposit,
+			debug_message: debug_message.unwrap_or_default().to_vec(),
+			events,
+		}
+	}
+
+	/// Instantiate a new contract.
+	///
+	/// This function is similar to [`Self::instantiate`], but doesn't perform any address lookups
+	/// and better suitable for calling directly from Rust.
+	///
+	/// It returns the execution result, account id and the amount of used weight.
+	///
+	/// # Note
+	///
+	/// If `debug` is set to `DebugInfo::UnsafeDebug` it returns additional human readable debugging
+	/// information.
+	///
+	/// If `collect_events` is set to `CollectEvents::UnsafeCollect` it collects all the Events
+	/// emitted in the block so far.
+	pub fn bare_instantiate(
+		origin: T::AccountId,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		mut storage_deposit_limit: Option<BalanceOf<T>>,
+		code: Code<CodeHash<T>>,
+		data: Vec<u8>,
+		salt: Vec<u8>,
+		debug: DebugInfo,
+		collect_events: CollectEvents,
+	) -> ContractInstantiateResult<T::AccountId, BalanceOf<T>, EventRecordOf<T>> {
+		ensure_no_migration_in_progress!();
+
+		let mut debug_message = if debug == DebugInfo::UnsafeDebug {
+			Some(DebugBufferVec::<T>::default())
+		} else {
+			None
+		};
+		// collect events if CollectEvents is UnsafeCollect
+		let events = || {
+			if collect_events == CollectEvents::UnsafeCollect {
+				Some(System::<T>::read_events_no_consensus().map(|e| *e).collect())
+			} else {
+				None
+			}
+		};
+
+		let (code, upload_deposit): (WasmCode<T>, BalanceOf<T>) = match code {
+			Code::Upload(code) => {
+				let result = Self::try_upload_code(
+					origin.clone(),
+					code,
+					storage_deposit_limit.map(Into::into),
+					Determinism::Enforced,
+					debug_message.as_mut(),
+				);
+
+				let (module, deposit) = match result {
+					Ok(result) => result,
+					Err(error) =>
+						return ContractResult {
+							gas_consumed: Zero::zero(),
+							gas_required: Zero::zero(),
+							storage_deposit: Default::default(),
+							debug_message: debug_message.unwrap_or(Default::default()).into(),
+							result: Err(error),
+							events: events(),
+						},
+				};
+
+				storage_deposit_limit =
+					storage_deposit_limit.map(|l| l.saturating_sub(deposit.into()));
+				(WasmCode::Wasm(module), deposit)
+			},
+			Code::Existing(hash) => (WasmCode::CodeHash(hash), Default::default()),
+		};
+
+		let common = CommonInput {
+			origin: Origin::from_account_id(origin),
+			value,
+			data,
+			gas_limit,
+			storage_deposit_limit,
+			debug_message: debug_message.as_mut(),
+		};
+
+		let output = InstantiateInput::<T> { code, salt }.run_guarded(common);
+		ContractInstantiateResult {
+			result: output
+				.result
+				.map(|(account_id, result)| InstantiateReturnValue { result, account_id })
+				.map_err(|e| e.error),
+			gas_consumed: output.gas_meter.gas_consumed(),
+			gas_required: output.gas_meter.gas_required(),
+			storage_deposit: output
+				.storage_deposit
+				.saturating_add(&StorageDeposit::Charge(upload_deposit)),
+			debug_message: debug_message.unwrap_or_default().to_vec(),
+			events: events(),
+		}
+	}
+
+	/// Upload new code without instantiating a contract from it.
+	///
+	/// This function is similar to [`Self::upload_code`], but doesn't perform any address lookups
+	/// and better suitable for calling directly from Rust.
+	pub fn bare_upload_code(
+		origin: T::AccountId,
+		code: Vec<u8>,
+		storage_deposit_limit: Option<BalanceOf<T>>,
+		determinism: Determinism,
+	) -> CodeUploadResult<CodeHash<T>, BalanceOf<T>> {
+		Migration::<T>::ensure_migrated()?;
+		let (module, deposit) =
+			Self::try_upload_code(origin, code, storage_deposit_limit, determinism, None)?;
+		Ok(CodeUploadReturnValue { code_hash: *module.code_hash(), deposit })
+	}
+
+	/// Uploads new code and returns the Wasm blob and deposit amount collected.
+	fn try_upload_code(
+		origin: T::AccountId,
+		code: Vec<u8>,
+		storage_deposit_limit: Option<BalanceOf<T>>,
+		determinism: Determinism,
+		mut debug_message: Option<&mut DebugBufferVec<T>>,
+	) -> Result<(WasmBlob<T>, BalanceOf<T>), DispatchError> {
+		let schedule = T::Schedule::get();
+		let mut module =
+			WasmBlob::from_code(code, &schedule, origin, determinism).map_err(|(err, msg)| {
+				debug_message.as_mut().map(|d| d.try_extend(msg.bytes()));
+				err
+			})?;
+		let deposit = module.store_code()?;
+		if let Some(storage_deposit_limit) = storage_deposit_limit {
+			ensure!(storage_deposit_limit >= deposit, <Error<T>>::StorageDepositLimitExhausted);
+		}
+
+		Ok((module, deposit))
+	}
+
+	/// Query storage of a specified contract under a specified key.
+	pub fn get_storage(address: T::AccountId, key: Vec<u8>) -> GetStorageResult {
+		if Migration::<T>::in_progress() {
+			return Err(ContractAccessError::MigrationInProgress)
+		}
+		let contract_info =
+			ContractInfoOf::<T>::get(&address).ok_or(ContractAccessError::DoesntExist)?;
+
+		let maybe_value = contract_info.read(
+			&Key::<T>::try_from_var(key)
+				.map_err(|_| ContractAccessError::KeyDecodingFailed)?
+				.into(),
+		);
+		Ok(maybe_value)
+	}
+
+	/// Determine the address of a contract.
+	///
+	/// This is the address generation function used by contract instantiation. See
+	/// [`DefaultAddressGenerator`] for the default implementation.
+	pub fn contract_address(
+		deploying_address: &T::AccountId,
+		code_hash: &CodeHash<T>,
+		input_data: &[u8],
+		salt: &[u8],
+	) -> T::AccountId {
+		T::AddressGenerator::contract_address(deploying_address, code_hash, input_data, salt)
+	}
+
+	/// Returns the code hash of the contract specified by `account` ID.
+	pub fn code_hash(account: &AccountIdOf<T>) -> Option<CodeHash<T>> {
+		ContractInfo::<T>::load_code_hash(account)
+	}
+
+	/// Store code for benchmarks which does not validate the code.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn store_code_raw(
+		code: Vec<u8>,
+		owner: T::AccountId,
+	) -> frame_support::dispatch::DispatchResult {
+		let schedule = T::Schedule::get();
+		WasmBlob::<T>::from_code_unchecked(code, &schedule, owner)?.store_code()?;
+		Ok(())
+	}
+
+	/// Deposit a pallet contracts event. Handles the conversion to the overarching event type.
+	fn deposit_event(topics: Vec<T::Hash>, event: Event<T>) {
+		<frame_system::Pallet<T>>::deposit_event_indexed(
+			&topics,
+			<T as Config>::RuntimeEvent::from(event).into(),
+		)
+	}
+
+	/// Return the existential deposit of [`Config::Currency`].
+	fn min_balance() -> BalanceOf<T> {
+		<T::Currency as Inspect<AccountIdOf<T>>>::minimum_balance()
+	}
+
+	/// Convert gas_limit from 1D Weight to a 2D Weight.
+	///
+	/// Used by backwards compatible extrinsics. We cannot just set the proof_size weight limit to
+	/// zero or an old `Call` will just fail with OutOfGas.
+	fn compat_weight_limit(gas_limit: OldWeight) -> Weight {
+		Weight::from_parts(gas_limit, u64::from(T::MaxCodeLen::get()) * 2)
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// The API used to dry-run contract interactions.
+	#[api_version(2)]
+	pub trait ContractsApi<AccountId, Balance, BlockNumber, Hash, EventRecord> where
+		AccountId: Codec,
+		Balance: Codec,
+		BlockNumber: Codec,
+		Hash: Codec,
+		EventRecord: Codec,
+	{
+		/// Perform a call from a specified account to a given contract.
+		///
+		/// See [`crate::Pallet::bare_call`].
+		fn call(
+			origin: AccountId,
+			dest: AccountId,
+			value: Balance,
+			gas_limit: Option<Weight>,
+			storage_deposit_limit: Option<Balance>,
+			input_data: Vec<u8>,
+		) -> ContractExecResult<Balance, EventRecord>;
+
+		/// Instantiate a new contract.
+		///
+		/// See `[crate::Pallet::bare_instantiate]`.
+		fn instantiate(
+			origin: AccountId,
+			value: Balance,
+			gas_limit: Option<Weight>,
+			storage_deposit_limit: Option<Balance>,
+			code: Code<Hash>,
+			data: Vec<u8>,
+			salt: Vec<u8>,
+		) -> ContractInstantiateResult<AccountId, Balance, EventRecord>;
+
+		/// Upload new code without instantiating a contract from it.
+		///
+		/// See [`crate::Pallet::bare_upload_code`].
+		fn upload_code(
+			origin: AccountId,
+			code: Vec<u8>,
+			storage_deposit_limit: Option<Balance>,
+			determinism: Determinism,
+		) -> CodeUploadResult<Hash, Balance>;
+
+		/// Query a given storage key in a given contract.
+		///
+		/// Returns `Ok(Some(Vec<u8>))` if the storage value exists under the given key in the
+		/// specified account and `Ok(None)` if it doesn't. If the account specified by the address
+		/// doesn't exist, or doesn't have a contract then `Err` is returned.
+		fn get_storage(
+			address: AccountId,
+			key: Vec<u8>,
+		) -> GetStorageResult;
+	}
+}
diff --git a/substrate/frame/contracts/src/migration.rs b/substrate/frame/contracts/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3e3d6f37884c7a757285a79a22e79065b69fc5f7
--- /dev/null
+++ b/substrate/frame/contracts/src/migration.rs
@@ -0,0 +1,631 @@
+// 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.
+
+//! Multi-block Migration framework for pallet-contracts.
+//!
+//! This module allows us to define a migration as a sequence of [`MigrationStep`]s that can be
+//! executed across multiple blocks.
+//!
+//! # Usage
+//!
+//! A migration step is defined under `src/migration/vX.rs`, where `X` is the version number.
+//! For example, `vX.rs` defines a migration from version `X - 1` to version `X`.
+//!
+//! ## Example:
+//!
+//! To configure a migration to `v11` for a runtime using `v10` of pallet-contracts on the chain,
+//! you would set the `Migrations` type as follows:
+//!
+//! ```
+//! use pallet_contracts::migration::{v10, v11};
+//! # pub enum Runtime {};
+//! # struct Currency;
+//! type Migrations = (v10::Migration<Runtime, Currency>, v11::Migration<Runtime>);
+//! ```
+//!
+//! ## Notes:
+//!
+//! - Migrations should always be tested with `try-runtime` before being deployed.
+//! - By testing with `try-runtime` against a live network, you ensure that all migration steps work
+//!   and that you have included the required steps.
+//!
+//! ## Low Level / Implementation Details
+//!
+//! When a migration starts and [`OnRuntimeUpgrade::on_runtime_upgrade`] is called, instead of
+//! performing the actual migration, we set a custom storage item [`MigrationInProgress`].
+//! This storage item defines a [`Cursor`] for the current migration.
+//!
+//! If the [`MigrationInProgress`] storage item exists, it means a migration is in progress, and its
+//! value holds a cursor for the current migration step. These migration steps are executed during
+//! [`Hooks<BlockNumber>::on_idle`] or when the [`Pallet::migrate`] dispatchable is
+//! called.
+//!
+//! While the migration is in progress, all dispatchables except `migrate`, are blocked, and returns
+//! a `MigrationInProgress` error.
+
+pub mod v09;
+pub mod v10;
+pub mod v11;
+pub mod v12;
+pub mod v13;
+pub mod v14;
+pub mod v15;
+include!(concat!(env!("OUT_DIR"), "/migration_codegen.rs"));
+
+use crate::{weights::WeightInfo, Config, Error, MigrationInProgress, Pallet, Weight, LOG_TARGET};
+use codec::{Codec, Decode};
+use frame_support::{
+	pallet_prelude::*,
+	traits::{ConstU32, OnRuntimeUpgrade},
+};
+use sp_runtime::Saturating;
+use sp_std::marker::PhantomData;
+
+#[cfg(feature = "try-runtime")]
+use sp_std::prelude::*;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+const PROOF_ENCODE: &str = "Tuple::max_encoded_len() < Cursor::max_encoded_len()` is verified in `Self::integrity_test()`; qed";
+const PROOF_DECODE: &str =
+	"We encode to the same type in this trait only. No other code touches this item; qed";
+
+fn invalid_version(version: StorageVersion) -> ! {
+	panic!("Required migration {version:?} not supported by this runtime. This is a bug.");
+}
+
+/// The cursor used to encode the position (usually the last iterated key) of the current migration
+/// step.
+pub type Cursor = BoundedVec<u8, ConstU32<1024>>;
+
+/// IsFinished describes whether a migration is finished or not.
+pub enum IsFinished {
+	Yes,
+	No,
+}
+
+/// A trait that allows to migrate storage from one version to another.
+///
+/// The migration is done in steps. The migration is finished when
+/// `step()` returns `IsFinished::Yes`.
+pub trait MigrationStep: Codec + MaxEncodedLen + Default {
+	/// Returns the version of the migration.
+	const VERSION: u16;
+
+	/// Returns the maximum weight that can be consumed in a single step.
+	fn max_step_weight() -> Weight;
+
+	/// Process one step of the migration.
+	///
+	/// Returns whether the migration is finished and the weight consumed.
+	fn step(&mut self) -> (IsFinished, Weight);
+
+	/// Verify that the migration step fits into `Cursor`, and that `max_step_weight` is not greater
+	/// than `max_block_weight`.
+	fn integrity_test(max_block_weight: Weight) {
+		if Self::max_step_weight().any_gt(max_block_weight) {
+			panic!(
+				"Invalid max_step_weight for Migration {}. Value should be lower than {}",
+				Self::VERSION,
+				max_block_weight
+			);
+		}
+
+		let len = <Self as MaxEncodedLen>::max_encoded_len();
+		let max = Cursor::bound();
+		if len > max {
+			panic!(
+				"Migration {} has size {} which is bigger than the maximum of {}",
+				Self::VERSION,
+				len,
+				max,
+			);
+		}
+	}
+
+	/// Execute some pre-checks prior to running the first step of this migration.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		Ok(Vec::new())
+	}
+
+	/// Execute some post-checks after running the last step of this migration.
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		Ok(())
+	}
+}
+
+/// A noop migration that can be used when there is no migration to be done for a given version.
+#[doc(hidden)]
+#[derive(frame_support::DefaultNoBound, Encode, Decode, MaxEncodedLen)]
+pub struct NoopMigration<const N: u16>;
+
+impl<const N: u16> MigrationStep for NoopMigration<N> {
+	const VERSION: u16 = N;
+	fn max_step_weight() -> Weight {
+		Weight::zero()
+	}
+	fn step(&mut self) -> (IsFinished, Weight) {
+		log::debug!(target: LOG_TARGET, "Noop migration for version {}", N);
+		(IsFinished::Yes, Weight::zero())
+	}
+}
+
+mod private {
+	use crate::migration::MigrationStep;
+	pub trait Sealed {}
+	#[impl_trait_for_tuples::impl_for_tuples(10)]
+	#[tuple_types_custom_trait_bound(MigrationStep)]
+	impl Sealed for Tuple {}
+}
+
+/// Defines a sequence of migrations.
+///
+/// The sequence must be defined by a tuple of migrations, each of which must implement the
+/// `MigrationStep` trait. Migrations must be ordered by their versions with no gaps.
+pub trait MigrateSequence: private::Sealed {
+	/// Returns the range of versions that this migrations sequence can handle.
+	/// Migrations must be ordered by their versions with no gaps.
+	///
+	/// The following code will fail to compile:
+	///
+	/// ```compile_fail
+	///     # use pallet_contracts::{NoopMigration, MigrateSequence};
+	/// 	let _ = <(NoopMigration<1>, NoopMigration<3>)>::VERSION_RANGE;
+	/// ```
+	/// The following code will compile:
+	/// ```
+	///     # use pallet_contracts::{NoopMigration, MigrateSequence};
+	/// 	let _ = <(NoopMigration<1>, NoopMigration<2>)>::VERSION_RANGE;
+	/// ```
+	const VERSION_RANGE: (u16, u16);
+
+	/// Returns the default cursor for the given version.
+	fn new(version: StorageVersion) -> Cursor;
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step(_version: StorageVersion) -> Result<Vec<u8>, TryRuntimeError> {
+		Ok(Vec::new())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(_version: StorageVersion, _state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		Ok(())
+	}
+
+	/// Execute the migration step until the weight limit is reached.
+	fn steps(version: StorageVersion, cursor: &[u8], weight_left: &mut Weight) -> StepResult;
+
+	/// Verify that the migration step fits into `Cursor`, and that `max_step_weight` is not greater
+	/// than `max_block_weight`.
+	fn integrity_test(max_block_weight: Weight);
+
+	/// Returns whether migrating from `in_storage` to `target` is supported.
+	///
+	/// A migration is supported if `VERSION_RANGE` is (in_storage + 1, target).
+	fn is_upgrade_supported(in_storage: StorageVersion, target: StorageVersion) -> bool {
+		let (low, high) = Self::VERSION_RANGE;
+		target == high && in_storage + 1 == low
+	}
+}
+
+/// Performs all necessary migrations based on `StorageVersion`.
+///
+/// If `TEST_ALL_STEPS == true` and `try-runtime` is enabled, this will run all the migrations
+/// inside `on_runtime_upgrade`. This should be set to false in tests that want to ensure the step
+/// by step migration works.
+pub struct Migration<T: Config, const TEST_ALL_STEPS: bool = true>(PhantomData<T>);
+
+#[cfg(feature = "try-runtime")]
+impl<T: Config, const TEST_ALL_STEPS: bool> Migration<T, TEST_ALL_STEPS> {
+	fn run_all_steps() -> Result<(), TryRuntimeError> {
+		let mut weight = Weight::zero();
+		let name = <Pallet<T>>::name();
+		loop {
+			let in_progress_version = <Pallet<T>>::on_chain_storage_version() + 1;
+			let state = T::Migrations::pre_upgrade_step(in_progress_version)?;
+			let (status, w) = Self::migrate(Weight::MAX);
+			weight.saturating_accrue(w);
+			log::info!(
+				target: LOG_TARGET,
+				"{name}: Migration step {:?} weight = {}",
+				in_progress_version,
+				weight
+			);
+			T::Migrations::post_upgrade_step(in_progress_version, state)?;
+			if matches!(status, MigrateResult::Completed) {
+				break
+			}
+		}
+
+		let name = <Pallet<T>>::name();
+		log::info!(target: LOG_TARGET, "{name}: Migration steps weight = {}", weight);
+		Ok(())
+	}
+}
+
+impl<T: Config, const TEST_ALL_STEPS: bool> OnRuntimeUpgrade for Migration<T, TEST_ALL_STEPS> {
+	fn on_runtime_upgrade() -> Weight {
+		let name = <Pallet<T>>::name();
+		let latest_version = <Pallet<T>>::current_storage_version();
+		let storage_version = <Pallet<T>>::on_chain_storage_version();
+
+		if storage_version == latest_version {
+			log::warn!(
+				target: LOG_TARGET,
+				"{name}: No Migration performed storage_version = latest_version = {:?}",
+				&storage_version
+			);
+			return T::WeightInfo::on_runtime_upgrade_noop()
+		}
+
+		// In case a migration is already in progress we create the next migration
+		// (if any) right when the current one finishes.
+		if Self::in_progress() {
+			log::warn!(
+				target: LOG_TARGET,
+				"{name}: Migration already in progress {:?}",
+				&storage_version
+			);
+
+			return T::WeightInfo::on_runtime_upgrade_in_progress()
+		}
+
+		log::info!(
+			target: LOG_TARGET,
+			"{name}: Upgrading storage from {storage_version:?} to {latest_version:?}.",
+		);
+
+		let cursor = T::Migrations::new(storage_version + 1);
+		MigrationInProgress::<T>::set(Some(cursor));
+
+		#[cfg(feature = "try-runtime")]
+		if TEST_ALL_STEPS {
+			Self::run_all_steps().unwrap();
+		}
+
+		T::WeightInfo::on_runtime_upgrade()
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		// We can't really do much here as our migrations do not happen during the runtime upgrade.
+		// Instead, we call the migrations `pre_upgrade` and `post_upgrade` hooks when we iterate
+		// over our migrations.
+		let storage_version = <Pallet<T>>::on_chain_storage_version();
+		let target_version = <Pallet<T>>::current_storage_version();
+
+		ensure!(
+			storage_version != target_version,
+			"No upgrade: Please remove this migration from your runtime upgrade configuration."
+		);
+
+		log::debug!(
+			target: LOG_TARGET,
+			"Requested migration of {} from {:?}(on-chain storage version) to {:?}(current storage version)",
+			<Pallet<T>>::name(), storage_version, target_version
+		);
+
+		ensure!(
+			T::Migrations::is_upgrade_supported(storage_version, target_version),
+			"Unsupported upgrade: VERSION_RANGE should be (on-chain storage version + 1, current storage version)"
+		);
+		Ok(Default::default())
+	}
+}
+
+/// The result of running the migration.
+#[derive(Debug, PartialEq)]
+pub enum MigrateResult {
+	/// No migration was performed
+	NoMigrationPerformed,
+	/// No migration currently in progress
+	NoMigrationInProgress,
+	/// A migration is in progress
+	InProgress { steps_done: u32 },
+	/// All migrations are completed
+	Completed,
+}
+
+/// The result of running a migration step.
+#[derive(Debug, PartialEq)]
+pub enum StepResult {
+	InProgress { cursor: Cursor, steps_done: u32 },
+	Completed { steps_done: u32 },
+}
+
+impl<T: Config, const TEST_ALL_STEPS: bool> Migration<T, TEST_ALL_STEPS> {
+	/// Verify that each migration's step of the [`Config::Migrations`] sequence fits into
+	/// `Cursor`.
+	pub(crate) fn integrity_test() {
+		let max_weight = <T as frame_system::Config>::BlockWeights::get().max_block;
+		T::Migrations::integrity_test(max_weight)
+	}
+
+	/// Migrate
+	/// Return the weight used and whether or not a migration is in progress
+	pub(crate) fn migrate(weight_limit: Weight) -> (MigrateResult, Weight) {
+		let name = <Pallet<T>>::name();
+		let mut weight_left = weight_limit;
+
+		if weight_left.checked_reduce(T::WeightInfo::migrate()).is_none() {
+			return (MigrateResult::NoMigrationPerformed, Weight::zero())
+		}
+
+		MigrationInProgress::<T>::mutate_exists(|progress| {
+			let Some(cursor_before) = progress.as_mut() else {
+				return (MigrateResult::NoMigrationInProgress, T::WeightInfo::migration_noop())
+			};
+
+			// if a migration is running it is always upgrading to the next version
+			let storage_version = <Pallet<T>>::on_chain_storage_version();
+			let in_progress_version = storage_version + 1;
+
+			log::info!(
+				target: LOG_TARGET,
+				"{name}: Migrating from {:?} to {:?},",
+				storage_version,
+				in_progress_version,
+			);
+
+			let result = match T::Migrations::steps(
+				in_progress_version,
+				cursor_before.as_ref(),
+				&mut weight_left,
+			) {
+				StepResult::InProgress { cursor, steps_done } => {
+					*progress = Some(cursor);
+					MigrateResult::InProgress { steps_done }
+				},
+				StepResult::Completed { steps_done } => {
+					in_progress_version.put::<Pallet<T>>();
+					if <Pallet<T>>::current_storage_version() != in_progress_version {
+						log::info!(
+							target: LOG_TARGET,
+							"{name}: Next migration is {:?},",
+							in_progress_version + 1
+						);
+						*progress = Some(T::Migrations::new(in_progress_version + 1));
+						MigrateResult::InProgress { steps_done }
+					} else {
+						log::info!(
+							target: LOG_TARGET,
+							"{name}: All migrations done. At version {:?},",
+							in_progress_version
+						);
+						*progress = None;
+						MigrateResult::Completed
+					}
+				},
+			};
+
+			(result, weight_limit.saturating_sub(weight_left))
+		})
+	}
+
+	pub(crate) fn ensure_migrated() -> DispatchResult {
+		if Self::in_progress() {
+			Err(Error::<T>::MigrationInProgress.into())
+		} else {
+			Ok(())
+		}
+	}
+
+	pub(crate) fn in_progress() -> bool {
+		MigrationInProgress::<T>::exists()
+	}
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(10)]
+#[tuple_types_custom_trait_bound(MigrationStep)]
+impl MigrateSequence for Tuple {
+	const VERSION_RANGE: (u16, u16) = {
+		let mut versions: (u16, u16) = (0, 0);
+		for_tuples!(
+			#(
+				match versions {
+					(0, 0) => {
+						versions = (Tuple::VERSION, Tuple::VERSION);
+					},
+					(min_version, last_version) if Tuple::VERSION == last_version + 1 => {
+						versions = (min_version, Tuple::VERSION);
+					},
+					_ => panic!("Migrations must be ordered by their versions with no gaps.")
+				}
+			)*
+		);
+		versions
+	};
+
+	fn new(version: StorageVersion) -> Cursor {
+		for_tuples!(
+			#(
+				if version == Tuple::VERSION {
+					return Tuple::default().encode().try_into().expect(PROOF_ENCODE)
+				}
+			)*
+		);
+		invalid_version(version)
+	}
+
+	#[cfg(feature = "try-runtime")]
+	/// Execute the pre-checks of the step associated with this version.
+	fn pre_upgrade_step(version: StorageVersion) -> Result<Vec<u8>, TryRuntimeError> {
+		for_tuples!(
+			#(
+				if version == Tuple::VERSION {
+					return Tuple::pre_upgrade_step()
+				}
+			)*
+		);
+		invalid_version(version)
+	}
+
+	#[cfg(feature = "try-runtime")]
+	/// Execute the post-checks of the step associated with this version.
+	fn post_upgrade_step(version: StorageVersion, state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		for_tuples!(
+			#(
+				if version == Tuple::VERSION {
+					return Tuple::post_upgrade_step(state)
+				}
+			)*
+		);
+		invalid_version(version)
+	}
+
+	fn steps(version: StorageVersion, mut cursor: &[u8], weight_left: &mut Weight) -> StepResult {
+		for_tuples!(
+			#(
+				if version == Tuple::VERSION {
+					let mut migration = <Tuple as Decode>::decode(&mut cursor)
+						.expect(PROOF_DECODE);
+					let max_weight = Tuple::max_step_weight();
+					let mut steps_done = 0;
+					while weight_left.all_gt(max_weight) {
+						let (finished, weight) = migration.step();
+						steps_done.saturating_accrue(1);
+						weight_left.saturating_reduce(weight);
+						if matches!(finished, IsFinished::Yes) {
+							return StepResult::Completed{ steps_done }
+						}
+					}
+					return StepResult::InProgress{cursor: migration.encode().try_into().expect(PROOF_ENCODE), steps_done }
+				}
+			)*
+		);
+		invalid_version(version)
+	}
+
+	fn integrity_test(max_block_weight: Weight) {
+		for_tuples!(
+			#(
+				Tuple::integrity_test(max_block_weight);
+			)*
+		);
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{
+		migration::codegen::LATEST_MIGRATION_VERSION,
+		tests::{ExtBuilder, Test},
+	};
+
+	#[derive(Default, Encode, Decode, MaxEncodedLen)]
+	struct MockMigration<const N: u16> {
+		// MockMigration<N> needs `N` steps to finish
+		count: u16,
+	}
+
+	impl<const N: u16> MigrationStep for MockMigration<N> {
+		const VERSION: u16 = N;
+		fn max_step_weight() -> Weight {
+			Weight::from_all(1)
+		}
+		fn step(&mut self) -> (IsFinished, Weight) {
+			assert!(self.count != N);
+			self.count += 1;
+			if self.count == N {
+				(IsFinished::Yes, Weight::from_all(1))
+			} else {
+				(IsFinished::No, Weight::from_all(1))
+			}
+		}
+	}
+
+	#[test]
+	fn test_storage_version_matches_last_migration_file() {
+		assert_eq!(StorageVersion::new(LATEST_MIGRATION_VERSION), crate::pallet::STORAGE_VERSION);
+	}
+
+	#[test]
+	fn version_range_works() {
+		let range = <(MockMigration<1>, MockMigration<2>)>::VERSION_RANGE;
+		assert_eq!(range, (1, 2));
+	}
+
+	#[test]
+	fn is_upgrade_supported_works() {
+		type Migrations = (MockMigration<9>, MockMigration<10>, MockMigration<11>);
+		assert!(Migrations::is_upgrade_supported(StorageVersion::new(8), StorageVersion::new(11)));
+		assert!(!Migrations::is_upgrade_supported(StorageVersion::new(9), StorageVersion::new(11)));
+		assert!(!Migrations::is_upgrade_supported(StorageVersion::new(8), StorageVersion::new(12)));
+	}
+
+	#[test]
+	fn steps_works() {
+		type Migrations = (MockMigration<2>, MockMigration<3>);
+		let version = StorageVersion::new(2);
+		let mut cursor = Migrations::new(version);
+
+		let mut weight = Weight::from_all(2);
+		let result = Migrations::steps(version, &cursor, &mut weight);
+		cursor = vec![1u8, 0].try_into().unwrap();
+		assert_eq!(result, StepResult::InProgress { cursor: cursor.clone(), steps_done: 1 });
+		assert_eq!(weight, Weight::from_all(1));
+
+		let mut weight = Weight::from_all(2);
+		assert_eq!(
+			Migrations::steps(version, &cursor, &mut weight),
+			StepResult::Completed { steps_done: 1 }
+		);
+	}
+
+	#[test]
+	fn no_migration_in_progress_works() {
+		type TestMigration = Migration<Test>;
+
+		ExtBuilder::default().build().execute_with(|| {
+			assert_eq!(StorageVersion::get::<Pallet<Test>>(), LATEST_MIGRATION_VERSION);
+			assert_eq!(TestMigration::migrate(Weight::MAX).0, MigrateResult::NoMigrationInProgress)
+		});
+	}
+
+	#[test]
+	fn migration_works() {
+		type TestMigration = Migration<Test, false>;
+
+		ExtBuilder::default()
+			.set_storage_version(LATEST_MIGRATION_VERSION - 2)
+			.build()
+			.execute_with(|| {
+				assert_eq!(StorageVersion::get::<Pallet<Test>>(), LATEST_MIGRATION_VERSION - 2);
+				TestMigration::on_runtime_upgrade();
+				for (version, status) in [
+					(LATEST_MIGRATION_VERSION - 1, MigrateResult::InProgress { steps_done: 1 }),
+					(LATEST_MIGRATION_VERSION, MigrateResult::Completed),
+				] {
+					assert_eq!(TestMigration::migrate(Weight::MAX).0, status);
+					assert_eq!(
+						<Pallet<Test>>::on_chain_storage_version(),
+						StorageVersion::new(version)
+					);
+				}
+
+				assert_eq!(
+					TestMigration::migrate(Weight::MAX).0,
+					MigrateResult::NoMigrationInProgress
+				);
+				assert_eq!(StorageVersion::get::<Pallet<Test>>(), LATEST_MIGRATION_VERSION);
+			});
+	}
+}
diff --git a/substrate/frame/contracts/src/migration/v09.rs b/substrate/frame/contracts/src/migration/v09.rs
new file mode 100644
index 0000000000000000000000000000000000000000..98fcccc2c0becedccd4bd15eed98b36fd52662ee
--- /dev/null
+++ b/substrate/frame/contracts/src/migration/v09.rs
@@ -0,0 +1,144 @@
+// 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.
+
+//! Update `CodeStorage` with the new `determinism` field.
+
+use crate::{
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	CodeHash, Config, Determinism, Pallet, Weight, LOG_TARGET,
+};
+use codec::{Decode, Encode};
+use frame_support::{pallet_prelude::*, storage_alias, DefaultNoBound, Identity};
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+use sp_std::prelude::*;
+
+mod old {
+	use super::*;
+
+	#[derive(Encode, Decode)]
+	pub struct PrefabWasmModule {
+		#[codec(compact)]
+		pub instruction_weights_version: u32,
+		#[codec(compact)]
+		pub initial: u32,
+		#[codec(compact)]
+		pub maximum: u32,
+		pub code: Vec<u8>,
+	}
+
+	#[storage_alias]
+	pub type CodeStorage<T: Config> =
+		StorageMap<Pallet<T>, Identity, CodeHash<T>, PrefabWasmModule>;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn store_old_dummy_code<T: Config>(len: usize) {
+	use sp_runtime::traits::Hash;
+	let module = old::PrefabWasmModule {
+		instruction_weights_version: 0,
+		initial: 0,
+		maximum: 0,
+		code: vec![42u8; len],
+	};
+	let hash = T::Hashing::hash(&module.code);
+	old::CodeStorage::<T>::insert(hash, module);
+}
+
+#[derive(Encode, Decode)]
+struct PrefabWasmModule {
+	#[codec(compact)]
+	pub instruction_weights_version: u32,
+	#[codec(compact)]
+	pub initial: u32,
+	#[codec(compact)]
+	pub maximum: u32,
+	pub code: Vec<u8>,
+	pub determinism: Determinism,
+}
+
+#[storage_alias]
+type CodeStorage<T: Config> = StorageMap<Pallet<T>, Identity, CodeHash<T>, PrefabWasmModule>;
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T: Config> {
+	last_code_hash: Option<CodeHash<T>>,
+}
+
+impl<T: Config> MigrationStep for Migration<T> {
+	const VERSION: u16 = 9;
+
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v9_migration_step(T::MaxCodeLen::get())
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let mut iter = if let Some(last_key) = self.last_code_hash.take() {
+			old::CodeStorage::<T>::iter_from(old::CodeStorage::<T>::hashed_key_for(last_key))
+		} else {
+			old::CodeStorage::<T>::iter()
+		};
+
+		if let Some((key, old)) = iter.next() {
+			log::debug!(target: LOG_TARGET, "Migrating contract code {:?}", key);
+			let len = old.code.len() as u32;
+			let module = PrefabWasmModule {
+				instruction_weights_version: old.instruction_weights_version,
+				initial: old.initial,
+				maximum: old.maximum,
+				code: old.code,
+				determinism: Determinism::Enforced,
+			};
+			CodeStorage::<T>::insert(key, module);
+			self.last_code_hash = Some(key);
+			(IsFinished::No, T::WeightInfo::v9_migration_step(len))
+		} else {
+			log::debug!(target: LOG_TARGET, "No more contracts code to migrate");
+			(IsFinished::Yes, T::WeightInfo::v9_migration_step(0))
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		let sample: Vec<_> = old::CodeStorage::<T>::iter().take(100).collect();
+
+		log::debug!(target: LOG_TARGET, "Taking sample of {} contract codes", sample.len());
+		Ok(sample.encode())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let sample = <Vec<(CodeHash<T>, old::PrefabWasmModule)> as Decode>::decode(&mut &state[..])
+			.expect("pre_upgrade_step provides a valid state; qed");
+
+		log::debug!(target: LOG_TARGET, "Validating sample of {} contract codes", sample.len());
+		for (code_hash, old) in sample {
+			let module = CodeStorage::<T>::get(&code_hash).unwrap();
+			ensure!(
+				module.instruction_weights_version == old.instruction_weights_version,
+				"invalid isntruction weights version"
+			);
+			ensure!(module.determinism == Determinism::Enforced, "invalid determinism");
+			ensure!(module.initial == old.initial, "invalid initial");
+			ensure!(module.maximum == old.maximum, "invalid maximum");
+			ensure!(module.code == old.code, "invalid code");
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/migration/v10.rs b/substrate/frame/contracts/src/migration/v10.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f02e28f6fde325b26a041c683e03671a8f876897
--- /dev/null
+++ b/substrate/frame/contracts/src/migration/v10.rs
@@ -0,0 +1,314 @@
+// 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.
+
+//! Don't rely on reserved balances keeping an account alive
+//! See <https://github.com/paritytech/substrate/pull/13369>.
+
+use crate::{
+	exec::AccountIdOf,
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	CodeHash, Config, Pallet, TrieId, Weight, LOG_TARGET,
+};
+use codec::{Decode, Encode};
+use core::cmp::{max, min};
+use frame_support::{
+	pallet_prelude::*,
+	storage_alias,
+	traits::{
+		tokens::{fungible::Inspect, Fortitude::Polite, Preservation::Preserve},
+		ExistenceRequirement, ReservableCurrency,
+	},
+	DefaultNoBound,
+};
+use sp_core::hexdisplay::HexDisplay;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+use sp_runtime::{
+	traits::{Hash, TrailingZeroInput, Zero},
+	Perbill, Saturating,
+};
+use sp_std::{ops::Deref, prelude::*};
+
+mod old {
+	use super::*;
+
+	pub type BalanceOf<T, OldCurrency> = <OldCurrency as frame_support::traits::Currency<
+		<T as frame_system::Config>::AccountId,
+	>>::Balance;
+
+	#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+	#[scale_info(skip_type_params(T, OldCurrency))]
+	pub struct ContractInfo<T: Config, OldCurrency>
+	where
+		OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	{
+		pub trie_id: TrieId,
+		pub code_hash: CodeHash<T>,
+		pub storage_bytes: u32,
+		pub storage_items: u32,
+		pub storage_byte_deposit: BalanceOf<T, OldCurrency>,
+		pub storage_item_deposit: BalanceOf<T, OldCurrency>,
+		pub storage_base_deposit: BalanceOf<T, OldCurrency>,
+	}
+
+	#[storage_alias]
+	pub type ContractInfoOf<T: Config, OldCurrency> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		ContractInfo<T, OldCurrency>,
+	>;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn store_old_contract_info<T: Config, OldCurrency>(
+	account: T::AccountId,
+	info: crate::ContractInfo<T>,
+) where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+{
+	let info = old::ContractInfo {
+		trie_id: info.trie_id,
+		code_hash: info.code_hash,
+		storage_bytes: Default::default(),
+		storage_items: Default::default(),
+		storage_byte_deposit: Default::default(),
+		storage_item_deposit: Default::default(),
+		storage_base_deposit: Default::default(),
+	};
+	old::ContractInfoOf::<T, OldCurrency>::insert(account, info);
+}
+
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(T))]
+pub struct DepositAccount<T: Config>(AccountIdOf<T>);
+
+impl<T: Config> Deref for DepositAccount<T> {
+	type Target = AccountIdOf<T>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(T, OldCurrency))]
+pub struct ContractInfo<T: Config, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
+	pub trie_id: TrieId,
+	deposit_account: DepositAccount<T>,
+	pub code_hash: CodeHash<T>,
+	storage_bytes: u32,
+	storage_items: u32,
+	pub storage_byte_deposit: old::BalanceOf<T, OldCurrency>,
+	storage_item_deposit: old::BalanceOf<T, OldCurrency>,
+	storage_base_deposit: old::BalanceOf<T, OldCurrency>,
+}
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T: Config, OldCurrency = ()> {
+	last_account: Option<T::AccountId>,
+	_phantom: PhantomData<(T, OldCurrency)>,
+}
+
+#[storage_alias]
+type ContractInfoOf<T: Config, OldCurrency> = StorageMap<
+	Pallet<T>,
+	Twox64Concat,
+	<T as frame_system::Config>::AccountId,
+	ContractInfo<T, OldCurrency>,
+>;
+
+/// Formula: `hash("contract_depo_v1" ++ contract_addr)`
+fn deposit_address<T: Config>(
+	contract_addr: &<T as frame_system::Config>::AccountId,
+) -> <T as frame_system::Config>::AccountId {
+	let entropy = (b"contract_depo_v1", contract_addr)
+		.using_encoded(<T as frame_system::Config>::Hashing::hash);
+	Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+		.expect("infinite length input; no invalid inputs for type; qed")
+}
+
+impl<T: Config, OldCurrency: 'static> MigrationStep for Migration<T, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>
+		+ Inspect<<T as frame_system::Config>::AccountId, Balance = old::BalanceOf<T, OldCurrency>>,
+{
+	const VERSION: u16 = 10;
+
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v10_migration_step()
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let mut iter = if let Some(last_account) = self.last_account.take() {
+			old::ContractInfoOf::<T, OldCurrency>::iter_from(
+				old::ContractInfoOf::<T, OldCurrency>::hashed_key_for(last_account),
+			)
+		} else {
+			old::ContractInfoOf::<T, OldCurrency>::iter()
+		};
+
+		if let Some((account, contract)) = iter.next() {
+			let min_balance = <OldCurrency as frame_support::traits::Currency<
+				<T as frame_system::Config>::AccountId,
+			>>::minimum_balance();
+			log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode()));
+
+			// Get the new deposit account address
+			let deposit_account: DepositAccount<T> = DepositAccount(deposit_address::<T>(&account));
+
+			// Calculate the existing deposit, that should be reserved on the contract account
+			let old_deposit = contract
+				.storage_base_deposit
+				.saturating_add(contract.storage_item_deposit)
+				.saturating_add(contract.storage_byte_deposit);
+
+			// Unreserve the existing deposit
+			// Note we can't use repatriate_reserve, because it only works with existing accounts
+			let remaining = OldCurrency::unreserve(&account, old_deposit);
+			if !remaining.is_zero() {
+				log::warn!(
+					target: LOG_TARGET,
+					"Partially unreserved. Remaining {:?} out of {:?} asked",
+					remaining,
+					old_deposit
+				);
+			}
+
+			// Attempt to transfer the old deposit to the deposit account.
+			let amount = old_deposit
+				.saturating_sub(min_balance)
+				.min(OldCurrency::reducible_balance(&account, Preserve, Polite));
+
+			let new_deposit = OldCurrency::transfer(
+				&account,
+				&deposit_account,
+				amount,
+				ExistenceRequirement::KeepAlive,
+			)
+			.map(|_| {
+				log::debug!(
+					target: LOG_TARGET,
+					"Transferred deposit ({:?}) to deposit account",
+					amount
+				);
+				amount
+			})
+			// If it fails we fallback to minting the ED.
+			.unwrap_or_else(|err| {
+				log::error!(
+					target: LOG_TARGET,
+					"Failed to transfer the base deposit, reason: {:?}",
+					err
+				);
+				OldCurrency::deposit_creating(&deposit_account, min_balance);
+				min_balance
+			});
+
+			// Calculate the new base_deposit to store in the contract:
+			// Ideally, it should be the same as the old one
+			// Ideally, it should be at least 2xED (for the contract and deposit accounts).
+			// It can't be more than the `new_deposit`.
+			let new_base_deposit = min(
+				max(contract.storage_base_deposit, min_balance.saturating_add(min_balance)),
+				new_deposit,
+			);
+
+			// Calculate the ratio to adjust storage_byte and storage_item deposits.
+			let new_deposit_without_base = new_deposit.saturating_sub(new_base_deposit);
+			let old_deposit_without_base =
+				old_deposit.saturating_sub(contract.storage_base_deposit);
+			let ratio = Perbill::from_rational(new_deposit_without_base, old_deposit_without_base);
+
+			// Calculate the new storage deposits based on the ratio
+			let storage_byte_deposit = ratio.mul_ceil(contract.storage_byte_deposit);
+			let storage_item_deposit = ratio.mul_ceil(contract.storage_item_deposit);
+
+			// Recalculate the new base deposit, instead of using new_base_deposit to avoid rounding
+			// errors
+			let storage_base_deposit = new_deposit
+				.saturating_sub(storage_byte_deposit)
+				.saturating_sub(storage_item_deposit);
+
+			let new_contract_info = ContractInfo {
+				trie_id: contract.trie_id,
+				deposit_account,
+				code_hash: contract.code_hash,
+				storage_bytes: contract.storage_bytes,
+				storage_items: contract.storage_items,
+				storage_byte_deposit,
+				storage_item_deposit,
+				storage_base_deposit,
+			};
+
+			ContractInfoOf::<T, OldCurrency>::insert(&account, new_contract_info);
+
+			// Store last key for next migration step
+			self.last_account = Some(account);
+
+			(IsFinished::No, T::WeightInfo::v10_migration_step())
+		} else {
+			log::debug!(target: LOG_TARGET, "Done Migrating contract info");
+			(IsFinished::Yes, T::WeightInfo::v10_migration_step())
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		let sample: Vec<_> = old::ContractInfoOf::<T, OldCurrency>::iter().take(10).collect();
+
+		log::debug!(target: LOG_TARGET, "Taking sample of {} contracts", sample.len());
+		Ok(sample.encode())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let sample = <Vec<(T::AccountId, old::ContractInfo<T, OldCurrency>)> as Decode>::decode(
+			&mut &state[..],
+		)
+		.expect("pre_upgrade_step provides a valid state; qed");
+
+		log::debug!(target: LOG_TARGET, "Validating sample of {} contracts", sample.len());
+		for (account, old_contract) in sample {
+			log::debug!(target: LOG_TARGET, "===");
+			log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode()));
+			let contract = ContractInfoOf::<T, OldCurrency>::get(&account).unwrap();
+			ensure!(old_contract.trie_id == contract.trie_id, "invalid trie_id");
+			ensure!(old_contract.code_hash == contract.code_hash, "invalid code_hash");
+			ensure!(old_contract.storage_bytes == contract.storage_bytes, "invalid storage_bytes");
+			ensure!(old_contract.storage_items == contract.storage_items, "invalid storage_items");
+
+			let deposit = <OldCurrency as frame_support::traits::Currency<_>>::total_balance(
+				&contract.deposit_account,
+			);
+			ensure!(
+				deposit ==
+					contract
+						.storage_base_deposit
+						.saturating_add(contract.storage_item_deposit)
+						.saturating_add(contract.storage_byte_deposit),
+				"deposit mismatch"
+			);
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/migration/v11.rs b/substrate/frame/contracts/src/migration/v11.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a5b11f6e08977fbbeb737bc2650ad318ddac97c8
--- /dev/null
+++ b/substrate/frame/contracts/src/migration/v11.rs
@@ -0,0 +1,133 @@
+// 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.
+
+//! Overflowing bounded DeletionQueue.
+//! See <https://github.com/paritytech/substrate/pull/13702>.
+
+use crate::{
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	Config, Pallet, TrieId, Weight, LOG_TARGET,
+};
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+use codec::{Decode, Encode};
+use frame_support::{pallet_prelude::*, storage_alias, DefaultNoBound};
+use sp_std::{marker::PhantomData, prelude::*};
+mod old {
+	use super::*;
+
+	#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]
+	pub struct DeletedContract {
+		pub(crate) trie_id: TrieId,
+	}
+
+	#[storage_alias]
+	pub type DeletionQueue<T: Config> = StorageValue<Pallet<T>, Vec<DeletedContract>>;
+}
+
+#[derive(Encode, Decode, TypeInfo, MaxEncodedLen, DefaultNoBound, Clone)]
+#[scale_info(skip_type_params(T))]
+pub struct DeletionQueueManager<T: Config> {
+	insert_counter: u32,
+	delete_counter: u32,
+	_phantom: PhantomData<T>,
+}
+
+#[cfg(any(feature = "runtime-benchmarks", feature = "try-runtime"))]
+pub fn fill_old_queue<T: Config>(len: usize) {
+	let queue: Vec<old::DeletedContract> =
+		core::iter::repeat_with(|| old::DeletedContract { trie_id: Default::default() })
+			.take(len)
+			.collect();
+	old::DeletionQueue::<T>::set(Some(queue));
+}
+
+#[storage_alias]
+type DeletionQueue<T: Config> = StorageMap<Pallet<T>, Twox64Concat, u32, TrieId>;
+
+#[storage_alias]
+type DeletionQueueCounter<T: Config> = StorageValue<Pallet<T>, DeletionQueueManager<T>, ValueQuery>;
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T: Config> {
+	_phantom: PhantomData<T>,
+}
+
+impl<T: Config> MigrationStep for Migration<T> {
+	const VERSION: u16 = 11;
+
+	// It would be more correct to make our use the now removed [DeletionQueueDepth](https://github.com/paritytech/substrate/pull/13702/files#diff-70e9723e9db62816e35f6f885b6770a8449c75a6c2733e9fa7a245fe52c4656c)
+	// but in practice the queue is always empty, so 128 is a good enough approximation for not
+	// underestimating the weight of our migration.
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v11_migration_step(128)
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let Some(old_queue) = old::DeletionQueue::<T>::take() else {
+			return (IsFinished::Yes, Weight::zero())
+		};
+		let len = old_queue.len();
+
+		log::debug!(
+			target: LOG_TARGET,
+			"Migrating deletion queue with {} deleted contracts",
+			old_queue.len()
+		);
+
+		if !old_queue.is_empty() {
+			let mut queue = DeletionQueueManager::<T>::default();
+			for contract in old_queue {
+				<DeletionQueue<T>>::insert(queue.insert_counter, contract.trie_id);
+				queue.insert_counter += 1;
+			}
+
+			<DeletionQueueCounter<T>>::set(queue);
+		}
+
+		(IsFinished::Yes, T::WeightInfo::v11_migration_step(len as u32))
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		let old_queue = old::DeletionQueue::<T>::take().unwrap_or_default();
+
+		if old_queue.is_empty() {
+			let len = 10u32;
+			log::debug!(
+				target: LOG_TARGET,
+				"Injecting {len} entries to deletion queue to test migration"
+			);
+			fill_old_queue::<T>(len as usize);
+			return Ok(len.encode())
+		}
+
+		Ok((old_queue.len() as u32).encode())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let len = <u32 as Decode>::decode(&mut &state[..])
+			.expect("pre_upgrade_step provides a valid state; qed");
+		let counter = <DeletionQueueCounter<T>>::get();
+		ensure!(counter.insert_counter == len, "invalid insert counter");
+		ensure!(counter.delete_counter == 0, "invalid delete counter");
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/migration/v12.rs b/substrate/frame/contracts/src/migration/v12.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb045aa42e9d70d1245384768ae2db62627757e1
--- /dev/null
+++ b/substrate/frame/contracts/src/migration/v12.rs
@@ -0,0 +1,348 @@
+// 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.
+
+//! Move `OwnerInfo` to `CodeInfo`, add `determinism` field to the latter, clear `CodeStorage` and
+//! repay deposits.
+
+use crate::{
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	AccountIdOf, BalanceOf, CodeHash, Config, Determinism, Pallet, Weight, LOG_TARGET,
+};
+use codec::{Decode, Encode};
+use frame_support::{
+	pallet_prelude::*, storage_alias, traits::ReservableCurrency, DefaultNoBound, Identity,
+};
+use scale_info::prelude::format;
+use sp_core::hexdisplay::HexDisplay;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+use sp_runtime::{traits::Zero, FixedPointNumber, FixedU128, Saturating};
+use sp_std::prelude::*;
+
+mod old {
+	use super::*;
+
+	pub type BalanceOf<T, OldCurrency> = <OldCurrency as frame_support::traits::Currency<
+		<T as frame_system::Config>::AccountId,
+	>>::Balance;
+
+	#[derive(Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)]
+	#[codec(mel_bound())]
+	#[scale_info(skip_type_params(T, OldCurrency))]
+	pub struct OwnerInfo<T: Config, OldCurrency>
+	where
+		OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	{
+		pub owner: AccountIdOf<T>,
+		#[codec(compact)]
+		pub deposit: BalanceOf<T, OldCurrency>,
+		#[codec(compact)]
+		pub refcount: u64,
+	}
+
+	#[derive(Encode, Decode, scale_info::TypeInfo)]
+	#[codec(mel_bound())]
+	#[scale_info(skip_type_params(T))]
+	pub struct PrefabWasmModule {
+		#[codec(compact)]
+		pub instruction_weights_version: u32,
+		#[codec(compact)]
+		pub initial: u32,
+		#[codec(compact)]
+		pub maximum: u32,
+		pub code: Vec<u8>,
+		pub determinism: Determinism,
+	}
+
+	#[storage_alias]
+	pub type OwnerInfoOf<T: Config, OldCurrency> =
+		StorageMap<Pallet<T>, Identity, CodeHash<T>, OwnerInfo<T, OldCurrency>>;
+
+	#[storage_alias]
+	pub type CodeStorage<T: Config> =
+		StorageMap<Pallet<T>, Identity, CodeHash<T>, PrefabWasmModule>;
+}
+
+#[derive(Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)]
+#[codec(mel_bound())]
+#[scale_info(skip_type_params(T, OldCurrency))]
+pub struct CodeInfo<T: Config, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
+	owner: AccountIdOf<T>,
+	#[codec(compact)]
+	deposit: old::BalanceOf<T, OldCurrency>,
+	#[codec(compact)]
+	refcount: u64,
+	determinism: Determinism,
+	code_len: u32,
+}
+
+#[storage_alias]
+pub type CodeInfoOf<T: Config, OldCurrency> =
+	StorageMap<Pallet<T>, Twox64Concat, CodeHash<T>, CodeInfo<T, OldCurrency>>;
+
+#[storage_alias]
+pub type PristineCode<T: Config> = StorageMap<Pallet<T>, Identity, CodeHash<T>, Vec<u8>>;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn store_old_dummy_code<T: Config, OldCurrency>(len: usize, account: T::AccountId)
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+{
+	use sp_runtime::traits::Hash;
+
+	let code = vec![42u8; len];
+	let hash = T::Hashing::hash(&code);
+	PristineCode::<T>::insert(hash, code.clone());
+
+	let module = old::PrefabWasmModule {
+		instruction_weights_version: Default::default(),
+		initial: Default::default(),
+		maximum: Default::default(),
+		code,
+		determinism: Determinism::Enforced,
+	};
+	old::CodeStorage::<T>::insert(hash, module);
+
+	let info = old::OwnerInfo { owner: account, deposit: u32::MAX.into(), refcount: u64::MAX };
+	old::OwnerInfoOf::<T, OldCurrency>::insert(hash, info);
+}
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T: Config, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	OldCurrency::Balance: From<BalanceOf<T>>,
+{
+	last_code_hash: Option<CodeHash<T>>,
+	_phantom: PhantomData<OldCurrency>,
+}
+
+impl<T: Config, OldCurrency> MigrationStep for Migration<T, OldCurrency>
+where
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+	OldCurrency::Balance: From<BalanceOf<T>>,
+{
+	const VERSION: u16 = 12;
+
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v12_migration_step(T::MaxCodeLen::get())
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let mut iter = if let Some(last_key) = self.last_code_hash.take() {
+			old::OwnerInfoOf::<T, OldCurrency>::iter_from(
+				old::OwnerInfoOf::<T, OldCurrency>::hashed_key_for(last_key),
+			)
+		} else {
+			old::OwnerInfoOf::<T, OldCurrency>::iter()
+		};
+		if let Some((hash, old_info)) = iter.next() {
+			log::debug!(target: LOG_TARGET, "Migrating OwnerInfo for code_hash {:?}", hash);
+
+			let module = old::CodeStorage::<T>::take(hash)
+				.expect(format!("No PrefabWasmModule found for code_hash: {:?}", hash).as_str());
+
+			let code_len = module.code.len();
+			// We print this to measure the impact of the migration.
+			// Storage removed: deleted PrefabWasmModule's encoded len.
+			// Storage added: determinism field encoded len (as all other CodeInfo fields are the
+			// same as in the deleted OwnerInfo).
+			log::debug!(target: LOG_TARGET, "Storage removed: 1 item, {} bytes", &code_len,);
+
+			// Storage usage prices could change over time, and accounts who uploaded their
+			// contracts code before the storage deposits where introduced, had not been ever
+			// charged with any deposit for that (see migration v6).
+			//
+			// This is why deposit to be refunded here is calculated as follows:
+			//
+			// 1. Calculate the deposit amount for storage before the migration, given current
+			// prices.
+			// 2. Given current reserved deposit amount, calculate the correction factor.
+			// 3. Calculate the deposit amount for storage after the migration, given current
+			// prices.
+			// 4. Calculate real deposit amount to be reserved after the migration.
+			let price_per_byte = T::DepositPerByte::get();
+			let price_per_item = T::DepositPerItem::get();
+			let bytes_before = module
+				.encoded_size()
+				.saturating_add(code_len)
+				.saturating_add(old::OwnerInfo::<T, OldCurrency>::max_encoded_len())
+				as u32;
+			let items_before = 3u32;
+			let deposit_expected_before = price_per_byte
+				.saturating_mul(bytes_before.into())
+				.saturating_add(price_per_item.saturating_mul(items_before.into()));
+			let ratio = FixedU128::checked_from_rational(old_info.deposit, deposit_expected_before)
+				.unwrap_or_default()
+				.min(FixedU128::from_u32(1));
+			let bytes_after =
+				code_len.saturating_add(CodeInfo::<T, OldCurrency>::max_encoded_len()) as u32;
+			let items_after = 2u32;
+			let deposit_expected_after = price_per_byte
+				.saturating_mul(bytes_after.into())
+				.saturating_add(price_per_item.saturating_mul(items_after.into()));
+			let deposit = ratio.saturating_mul_int(deposit_expected_after);
+
+			let info = CodeInfo::<T, OldCurrency> {
+				determinism: module.determinism,
+				owner: old_info.owner,
+				deposit: deposit.into(),
+				refcount: old_info.refcount,
+				code_len: code_len as u32,
+			};
+
+			let amount = old_info.deposit.saturating_sub(info.deposit);
+			if !amount.is_zero() {
+				OldCurrency::unreserve(&info.owner, amount);
+				log::debug!(
+					target: LOG_TARGET,
+					"Deposit refunded: {:?} Balance, to: {:?}",
+					&amount,
+					HexDisplay::from(&info.owner.encode())
+				);
+			} else {
+				log::warn!(
+					target: LOG_TARGET,
+					"new deposit: {:?} >= old deposit: {:?}",
+					&info.deposit,
+					&old_info.deposit
+				);
+			}
+			CodeInfoOf::<T, OldCurrency>::insert(hash, info);
+
+			self.last_code_hash = Some(hash);
+
+			(IsFinished::No, T::WeightInfo::v12_migration_step(code_len as u32))
+		} else {
+			log::debug!(target: LOG_TARGET, "No more OwnerInfo to migrate");
+			(IsFinished::Yes, T::WeightInfo::v12_migration_step(0))
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		let len = 100;
+		log::debug!(target: LOG_TARGET, "Taking sample of {} OwnerInfo(s)", len);
+		let sample: Vec<_> = old::OwnerInfoOf::<T, OldCurrency>::iter()
+			.take(len)
+			.map(|(k, v)| {
+				let module = old::CodeStorage::<T>::get(k)
+					.expect("No PrefabWasmModule found for code_hash: {:?}");
+				let info: CodeInfo<T, OldCurrency> = CodeInfo {
+					determinism: module.determinism,
+					deposit: v.deposit,
+					refcount: v.refcount,
+					owner: v.owner,
+					code_len: module.code.len() as u32,
+				};
+				(k, info)
+			})
+			.collect();
+
+		let storage: u32 =
+			old::CodeStorage::<T>::iter().map(|(_k, v)| v.encoded_size() as u32).sum();
+		let mut deposit: old::BalanceOf<T, OldCurrency> = Default::default();
+		old::OwnerInfoOf::<T, OldCurrency>::iter().for_each(|(_k, v)| deposit += v.deposit);
+
+		Ok((sample, deposit, storage).encode())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let state = <(
+			Vec<(CodeHash<T>, CodeInfo<T, OldCurrency>)>,
+			old::BalanceOf<T, OldCurrency>,
+			u32,
+		) as Decode>::decode(&mut &state[..])
+		.unwrap();
+
+		log::debug!(target: LOG_TARGET, "Validating state of {} Codeinfo(s)", state.0.len());
+		for (hash, old) in state.0 {
+			let info = CodeInfoOf::<T, OldCurrency>::get(&hash)
+				.expect(format!("CodeInfo for code_hash {:?} not found!", hash).as_str());
+			ensure!(info.determinism == old.determinism, "invalid determinism");
+			ensure!(info.owner == old.owner, "invalid owner");
+			ensure!(info.refcount == old.refcount, "invalid refcount");
+		}
+
+		if let Some((k, _)) = old::CodeStorage::<T>::iter().next() {
+			log::warn!(
+				target: LOG_TARGET,
+				"CodeStorage is still NOT empty, found code_hash: {:?}",
+				k
+			);
+		} else {
+			log::debug!(target: LOG_TARGET, "CodeStorage is empty.");
+		}
+		if let Some((k, _)) = old::OwnerInfoOf::<T, OldCurrency>::iter().next() {
+			log::warn!(
+				target: LOG_TARGET,
+				"OwnerInfoOf is still NOT empty, found code_hash: {:?}",
+				k
+			);
+		} else {
+			log::debug!(target: LOG_TARGET, "OwnerInfoOf is empty.");
+		}
+
+		let mut deposit: old::BalanceOf<T, OldCurrency> = Default::default();
+		let mut items = 0u32;
+		let mut storage_info = 0u32;
+		CodeInfoOf::<T, OldCurrency>::iter().for_each(|(_k, v)| {
+			deposit += v.deposit;
+			items += 1;
+			storage_info += v.encoded_size() as u32;
+		});
+		let mut storage_code = 0u32;
+		PristineCode::<T>::iter().for_each(|(_k, v)| {
+			storage_code += v.len() as u32;
+		});
+		let (_, old_deposit, storage_module) = state;
+		// CodeInfoOf::max_encoded_len == OwnerInfoOf::max_encoded_len + 1
+		// I.e. code info adds up 1 byte per record.
+		let info_bytes_added = items.clone();
+		// We removed 1 PrefabWasmModule, and added 1 byte of determinism flag, per contract code.
+		let storage_removed = storage_module.saturating_sub(info_bytes_added);
+		// module+code+info - bytes
+		let storage_was = storage_module
+			.saturating_add(storage_code)
+			.saturating_add(storage_info)
+			.saturating_sub(info_bytes_added);
+		// We removed 1 storage item (PrefabWasmMod) for every stored contract code (was stored 3
+		// items per code).
+		let items_removed = items;
+		log::info!(
+			target: LOG_TARGET,
+			"Storage freed, bytes: {} (of {}), items: {} (of {})",
+			storage_removed,
+			storage_was,
+			items_removed,
+			items_removed * 3,
+		);
+		log::info!(
+			target: LOG_TARGET,
+			"Deposits returned, total: {:?} Balance (of {:?} Balance)",
+			old_deposit.saturating_sub(deposit),
+			old_deposit,
+		);
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/migration/v13.rs b/substrate/frame/contracts/src/migration/v13.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dd2eb12eb62a5daf92cec8b5910c03f6d81ae0c0
--- /dev/null
+++ b/substrate/frame/contracts/src/migration/v13.rs
@@ -0,0 +1,135 @@
+// 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.
+
+//! Add `delegate_dependencies` to `ContractInfo`.
+//! See <https://github.com/paritytech/substrate/pull/14079>.
+
+use crate::{
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	AccountIdOf, BalanceOf, CodeHash, Config, Pallet, TrieId, Weight, LOG_TARGET,
+};
+use codec::{Decode, Encode};
+use frame_support::{pallet_prelude::*, storage_alias, DefaultNoBound};
+use sp_runtime::BoundedBTreeMap;
+use sp_std::prelude::*;
+
+mod old {
+	use super::*;
+
+	#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+	#[scale_info(skip_type_params(T))]
+	pub struct ContractInfo<T: Config> {
+		pub trie_id: TrieId,
+		pub deposit_account: AccountIdOf<T>,
+		pub code_hash: CodeHash<T>,
+		pub storage_bytes: u32,
+		pub storage_items: u32,
+		pub storage_byte_deposit: BalanceOf<T>,
+		pub storage_item_deposit: BalanceOf<T>,
+		pub storage_base_deposit: BalanceOf<T>,
+	}
+
+	#[storage_alias]
+	pub type ContractInfoOf<T: Config> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		ContractInfo<T>,
+	>;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn store_old_contract_info<T: Config>(account: T::AccountId, info: crate::ContractInfo<T>) {
+	use sp_runtime::traits::{Hash, TrailingZeroInput};
+	let entropy = (b"contract_depo_v1", account.clone()).using_encoded(T::Hashing::hash);
+	let deposit_account = Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+		.expect("infinite length input; no invalid inputs for type; qed");
+	let info = old::ContractInfo {
+		trie_id: info.trie_id.clone(),
+		deposit_account,
+		code_hash: info.code_hash,
+		storage_bytes: Default::default(),
+		storage_items: Default::default(),
+		storage_byte_deposit: Default::default(),
+		storage_item_deposit: Default::default(),
+		storage_base_deposit: Default::default(),
+	};
+	old::ContractInfoOf::<T>::insert(account, info);
+}
+
+#[storage_alias]
+pub type ContractInfoOf<T: Config> =
+	StorageMap<Pallet<T>, Twox64Concat, <T as frame_system::Config>::AccountId, ContractInfo<T>>;
+
+#[derive(Encode, Decode, CloneNoBound, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(T))]
+pub struct ContractInfo<T: Config> {
+	trie_id: TrieId,
+	deposit_account: AccountIdOf<T>,
+	code_hash: CodeHash<T>,
+	storage_bytes: u32,
+	storage_items: u32,
+	storage_byte_deposit: BalanceOf<T>,
+	storage_item_deposit: BalanceOf<T>,
+	storage_base_deposit: BalanceOf<T>,
+	delegate_dependencies: BoundedBTreeMap<CodeHash<T>, BalanceOf<T>, T::MaxDelegateDependencies>,
+}
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T: Config> {
+	last_account: Option<T::AccountId>,
+}
+
+impl<T: Config> MigrationStep for Migration<T> {
+	const VERSION: u16 = 13;
+
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v13_migration_step()
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let mut iter = if let Some(last_account) = self.last_account.take() {
+			old::ContractInfoOf::<T>::iter_from(old::ContractInfoOf::<T>::hashed_key_for(
+				last_account,
+			))
+		} else {
+			old::ContractInfoOf::<T>::iter()
+		};
+
+		if let Some((key, old)) = iter.next() {
+			log::debug!(target: LOG_TARGET, "Migrating contract {:?}", key);
+			let info = ContractInfo {
+				trie_id: old.trie_id,
+				deposit_account: old.deposit_account,
+				code_hash: old.code_hash,
+				storage_bytes: old.storage_bytes,
+				storage_items: old.storage_items,
+				storage_byte_deposit: old.storage_byte_deposit,
+				storage_item_deposit: old.storage_item_deposit,
+				storage_base_deposit: old.storage_base_deposit,
+				delegate_dependencies: Default::default(),
+			};
+			ContractInfoOf::<T>::insert(key.clone(), info);
+			self.last_account = Some(key);
+			(IsFinished::No, T::WeightInfo::v13_migration_step())
+		} else {
+			log::debug!(target: LOG_TARGET, "No more contracts to migrate");
+			(IsFinished::Yes, T::WeightInfo::v13_migration_step())
+		}
+	}
+}
diff --git a/substrate/frame/contracts/src/migration/v14.rs b/substrate/frame/contracts/src/migration/v14.rs
new file mode 100644
index 0000000000000000000000000000000000000000..efb49dff4f10ac2b8a27ebae1f58541b6e7f793b
--- /dev/null
+++ b/substrate/frame/contracts/src/migration/v14.rs
@@ -0,0 +1,271 @@
+// 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.
+
+//! Update the code owner balance, make the code upload deposit balance to be held instead of
+//! reserved. Since [`Currency`](frame_support::traits::Currency) has been
+//! [deprecated](https://github.com/paritytech/substrate/pull/12951), we need the deposits to be
+//! handled by the [`frame_support::traits::fungible`] traits.
+
+use crate::{
+	exec::AccountIdOf,
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	BalanceOf, CodeHash, Config, Determinism, HoldReason, Pallet, Weight, LOG_TARGET,
+};
+use codec::{Decode, Encode};
+#[cfg(feature = "try-runtime")]
+use environmental::Vec;
+#[cfg(feature = "try-runtime")]
+use frame_support::traits::fungible::{Inspect, InspectHold};
+use frame_support::{
+	pallet_prelude::*,
+	storage_alias,
+	traits::{fungible::MutateHold, ReservableCurrency},
+	DefaultNoBound,
+};
+use sp_core::hexdisplay::HexDisplay;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+use sp_runtime::{traits::Zero, Saturating};
+#[cfg(feature = "try-runtime")]
+use sp_std::collections::btree_map::BTreeMap;
+
+mod old {
+	use super::*;
+
+	pub type BalanceOf<T, OldCurrency> = <OldCurrency as frame_support::traits::Currency<
+		<T as frame_system::Config>::AccountId,
+	>>::Balance;
+
+	#[derive(Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)]
+	#[codec(mel_bound())]
+	#[scale_info(skip_type_params(T, OldCurrency))]
+	pub struct CodeInfo<T, OldCurrency>
+	where
+		T: Config,
+		OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	{
+		pub owner: AccountIdOf<T>,
+		#[codec(compact)]
+		pub deposit: old::BalanceOf<T, OldCurrency>,
+		#[codec(compact)]
+		pub refcount: u64,
+		pub determinism: Determinism,
+		pub code_len: u32,
+	}
+
+	#[storage_alias]
+	pub type CodeInfoOf<T: Config, OldCurrency> =
+		StorageMap<Pallet<T>, Twox64Concat, CodeHash<T>, CodeInfo<T, OldCurrency>>;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn store_dummy_code<T: Config, OldCurrency>(account: T::AccountId)
+where
+	T: Config,
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId> + 'static,
+{
+	use sp_runtime::traits::Hash;
+	use sp_std::vec;
+
+	let len = T::MaxCodeLen::get();
+	let code = vec![42u8; len as usize];
+	let hash = T::Hashing::hash(&code);
+
+	let info = old::CodeInfo {
+		owner: account,
+		deposit: 10_000u32.into(),
+		refcount: u64::MAX,
+		determinism: Determinism::Enforced,
+		code_len: len,
+	};
+	old::CodeInfoOf::<T, OldCurrency>::insert(hash, info);
+}
+
+#[cfg(feature = "try-runtime")]
+#[derive(Encode, Decode)]
+/// Accounts for the balance allocation of a code owner.
+struct BalanceAllocation<T, OldCurrency>
+where
+	T: Config,
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
+	/// Total reserved balance as code upload deposit for the owner.
+	reserved: old::BalanceOf<T, OldCurrency>,
+	/// Total balance of the owner.
+	total: old::BalanceOf<T, OldCurrency>,
+}
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T, OldCurrency>
+where
+	T: Config,
+	OldCurrency: ReservableCurrency<<T as frame_system::Config>::AccountId>,
+{
+	last_code_hash: Option<CodeHash<T>>,
+	_phantom: PhantomData<(T, OldCurrency)>,
+}
+
+impl<T, OldCurrency> MigrationStep for Migration<T, OldCurrency>
+where
+	T: Config,
+	OldCurrency: 'static + ReservableCurrency<<T as frame_system::Config>::AccountId>,
+	BalanceOf<T>: From<OldCurrency::Balance>,
+{
+	const VERSION: u16 = 14;
+
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v14_migration_step()
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let mut iter = if let Some(last_hash) = self.last_code_hash.take() {
+			old::CodeInfoOf::<T, OldCurrency>::iter_from(
+				old::CodeInfoOf::<T, OldCurrency>::hashed_key_for(last_hash),
+			)
+		} else {
+			old::CodeInfoOf::<T, OldCurrency>::iter()
+		};
+
+		if let Some((hash, code_info)) = iter.next() {
+			log::debug!(target: LOG_TARGET, "Migrating code upload deposit for 0x{:?}", HexDisplay::from(&code_info.owner.encode()));
+
+			let remaining = OldCurrency::unreserve(&code_info.owner, code_info.deposit);
+
+			if remaining > Zero::zero() {
+				log::warn!(
+					target: LOG_TARGET,
+					"Code owner's account 0x{:?} for code {:?} has some non-unreservable deposit {:?} from a total of {:?} that will remain in reserved.",
+					HexDisplay::from(&code_info.owner.encode()),
+					hash,
+					remaining,
+					code_info.deposit
+				);
+			}
+
+			let unreserved = code_info.deposit.saturating_sub(remaining);
+			let amount = BalanceOf::<T>::from(unreserved);
+
+			log::debug!(
+				target: LOG_TARGET,
+				"Holding {:?} on the code owner's account 0x{:?} for code {:?}.",
+				amount,
+				HexDisplay::from(&code_info.owner.encode()),
+				hash,
+			);
+
+			T::Currency::hold(
+				&HoldReason::CodeUploadDepositReserve.into(),
+				&code_info.owner,
+				amount,
+			)
+			.unwrap_or_else(|err| {
+				log::error!(
+					target: LOG_TARGET,
+					"Failed to hold {:?} from the code owner's account 0x{:?} for code {:?}, reason: {:?}.",
+					amount,
+					HexDisplay::from(&code_info.owner.encode()),
+					hash,
+					err
+				);
+			});
+
+			self.last_code_hash = Some(hash);
+			(IsFinished::No, T::WeightInfo::v14_migration_step())
+		} else {
+			log::debug!(target: LOG_TARGET, "No more code upload deposit to migrate");
+			(IsFinished::Yes, T::WeightInfo::v14_migration_step())
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		let info: Vec<_> = old::CodeInfoOf::<T, OldCurrency>::iter().collect();
+
+		let mut owner_balance_allocation =
+			BTreeMap::<AccountIdOf<T>, BalanceAllocation<T, OldCurrency>>::new();
+
+		// Calculates the balance allocation by accumulating the code upload deposits of all codes
+		// owned by an owner.
+		for (_, code_info) in info {
+			owner_balance_allocation
+				.entry(code_info.owner.clone())
+				.and_modify(|alloc| {
+					alloc.reserved = alloc.reserved.saturating_add(code_info.deposit);
+				})
+				.or_insert(BalanceAllocation {
+					reserved: code_info.deposit,
+					total: OldCurrency::total_balance(&code_info.owner),
+				});
+		}
+
+		Ok(owner_balance_allocation.encode())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let owner_balance_allocation =
+			<BTreeMap<AccountIdOf<T>, BalanceAllocation<T, OldCurrency>> as Decode>::decode(
+				&mut &state[..],
+			)
+			.expect("pre_upgrade_step provides a valid state; qed");
+
+		let mut total_held: BalanceOf<T> = Zero::zero();
+		let count = owner_balance_allocation.len();
+		for (owner, old_balance_allocation) in owner_balance_allocation {
+			let held =
+				T::Currency::balance_on_hold(&HoldReason::CodeUploadDepositReserve.into(), &owner);
+			log::debug!(
+				target: LOG_TARGET,
+				"Validating code upload deposit for owner 0x{:?}, reserved: {:?}, held: {:?}",
+				HexDisplay::from(&owner.encode()),
+				old_balance_allocation.reserved,
+				held
+			);
+			ensure!(held == old_balance_allocation.reserved.into(), "Held amount mismatch");
+
+			log::debug!(
+				target: LOG_TARGET,
+				"Validating total balance for owner 0x{:?}, new: {:?}, old: {:?}",
+				HexDisplay::from(&owner.encode()),
+				T::Currency::total_balance(&owner),
+				old_balance_allocation.total
+			);
+			ensure!(
+				T::Currency::total_balance(&owner) ==
+					BalanceOf::<T>::decode(&mut &old_balance_allocation.total.encode()[..])
+						.unwrap(),
+				"Balance mismatch "
+			);
+			total_held += held;
+		}
+
+		log::info!(
+			target: LOG_TARGET,
+			"Code owners processed: {:?}.",
+			count
+		);
+
+		log::info!(
+			target: LOG_TARGET,
+			"Total held amount for code upload deposit: {:?}",
+			total_held
+		);
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/migration/v15.rs b/substrate/frame/contracts/src/migration/v15.rs
new file mode 100644
index 0000000000000000000000000000000000000000..efece62905ff8474a7288cb03d21bd8ae05eae11
--- /dev/null
+++ b/substrate/frame/contracts/src/migration/v15.rs
@@ -0,0 +1,327 @@
+// 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.
+
+//! Move contracts' _reserved_ balance from the `deposit_account` to be _held_ in the contract's
+//! account instead. Since [`Currency`](frame_support::traits::Currency) has been
+//! [deprecated](https://github.com/paritytech/substrate/pull/12951), we need the deposits to be
+//! handled by the [`frame_support::traits::fungible`] traits instead. For this transfer the
+//! balance from the deposit account to the contract's account and hold it in there.
+//! Then the deposit account is not needed anymore and we can get rid of it.
+
+use crate::{
+	migration::{IsFinished, MigrationStep},
+	weights::WeightInfo,
+	AccountIdOf, BalanceOf, CodeHash, Config, HoldReason, Pallet, TrieId, Weight, LOG_TARGET,
+};
+#[cfg(feature = "try-runtime")]
+use frame_support::{dispatch::Vec, traits::fungible::InspectHold};
+use frame_support::{
+	pallet_prelude::*,
+	storage_alias,
+	traits::{
+		fungible::{Mutate, MutateHold},
+		tokens::{fungible::Inspect, Fortitude, Preservation},
+	},
+	BoundedBTreeMap, DefaultNoBound,
+};
+use frame_system::Pallet as System;
+use sp_core::hexdisplay::HexDisplay;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+use sp_runtime::{traits::Zero, Saturating};
+
+mod old {
+	use super::*;
+
+	#[derive(
+		Encode, Decode, CloneNoBound, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen,
+	)]
+	#[scale_info(skip_type_params(T))]
+	pub struct ContractInfo<T: Config> {
+		pub trie_id: TrieId,
+		pub deposit_account: AccountIdOf<T>,
+		pub code_hash: CodeHash<T>,
+		pub storage_bytes: u32,
+		pub storage_items: u32,
+		pub storage_byte_deposit: BalanceOf<T>,
+		pub storage_item_deposit: BalanceOf<T>,
+		pub storage_base_deposit: BalanceOf<T>,
+		pub delegate_dependencies:
+			BoundedBTreeMap<CodeHash<T>, BalanceOf<T>, T::MaxDelegateDependencies>,
+	}
+
+	#[storage_alias]
+	pub type ContractInfoOf<T: Config> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		ContractInfo<T>,
+	>;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn store_old_contract_info<T: Config>(account: T::AccountId, info: crate::ContractInfo<T>) {
+	use sp_runtime::traits::{Hash, TrailingZeroInput};
+	let entropy = (b"contract_depo_v1", account.clone()).using_encoded(T::Hashing::hash);
+	let deposit_account = Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+		.expect("infinite length input; no invalid inputs for type; qed");
+	let info = old::ContractInfo {
+		trie_id: info.trie_id.clone(),
+		deposit_account,
+		code_hash: info.code_hash,
+		storage_bytes: Default::default(),
+		storage_items: Default::default(),
+		storage_byte_deposit: info.storage_byte_deposit,
+		storage_item_deposit: Default::default(),
+		storage_base_deposit: info.storage_base_deposit(),
+		delegate_dependencies: info.delegate_dependencies().clone(),
+	};
+	old::ContractInfoOf::<T>::insert(account, info);
+}
+
+#[derive(Encode, Decode, CloneNoBound, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(T))]
+struct ContractInfo<T: Config> {
+	pub trie_id: TrieId,
+	pub code_hash: CodeHash<T>,
+	pub storage_bytes: u32,
+	pub storage_items: u32,
+	pub storage_byte_deposit: BalanceOf<T>,
+	pub storage_item_deposit: BalanceOf<T>,
+	pub storage_base_deposit: BalanceOf<T>,
+	pub delegate_dependencies:
+		BoundedBTreeMap<CodeHash<T>, BalanceOf<T>, T::MaxDelegateDependencies>,
+}
+
+#[storage_alias]
+type ContractInfoOf<T: Config> =
+	StorageMap<Pallet<T>, Twox64Concat, <T as frame_system::Config>::AccountId, ContractInfo<T>>;
+
+#[derive(Encode, Decode, MaxEncodedLen, DefaultNoBound)]
+pub struct Migration<T: Config> {
+	last_account: Option<T::AccountId>,
+}
+
+impl<T: Config> MigrationStep for Migration<T> {
+	const VERSION: u16 = 15;
+
+	fn max_step_weight() -> Weight {
+		T::WeightInfo::v15_migration_step()
+	}
+
+	fn step(&mut self) -> (IsFinished, Weight) {
+		let mut iter = if let Some(last_account) = self.last_account.take() {
+			old::ContractInfoOf::<T>::iter_from(old::ContractInfoOf::<T>::hashed_key_for(
+				last_account,
+			))
+		} else {
+			old::ContractInfoOf::<T>::iter()
+		};
+
+		if let Some((account, old_contract)) = iter.next() {
+			let deposit_account = &old_contract.deposit_account;
+			System::<T>::dec_consumers(deposit_account);
+
+			// Get the deposit balance to transfer.
+			let total_deposit_balance = T::Currency::total_balance(deposit_account);
+			let reducible_deposit_balance = T::Currency::reducible_balance(
+				deposit_account,
+				Preservation::Expendable,
+				Fortitude::Force,
+			);
+
+			if total_deposit_balance > reducible_deposit_balance {
+				// This should never happen, as by design all balance in the deposit account is
+				// storage deposit and therefore reducible after decrementing the consumer
+				// reference.
+				log::warn!(
+					target: LOG_TARGET,
+					"Deposit account 0x{:?} for contract 0x{:?} has some non-reducible balance {:?} from a total of {:?} that will remain in there.",
+					HexDisplay::from(&deposit_account.encode()),
+					HexDisplay::from(&account.encode()),
+					total_deposit_balance.saturating_sub(reducible_deposit_balance),
+					total_deposit_balance
+				);
+			}
+
+			// Move balance reserved from the deposit account back to the contract account.
+			// Let the deposit account die.
+			log::debug!(
+				target: LOG_TARGET,
+				"Transferring {:?} from the deposit account 0x{:?} to the contract 0x{:?}.",
+				reducible_deposit_balance,
+				HexDisplay::from(&deposit_account.encode()),
+				HexDisplay::from(&account.encode())
+			);
+			let transferred_deposit_balance = T::Currency::transfer(
+				deposit_account,
+				&account,
+				reducible_deposit_balance,
+				Preservation::Expendable,
+			)
+			.unwrap_or_else(|err| {
+				log::error!(
+					target: LOG_TARGET,
+					"Failed to transfer {:?} from the deposit account 0x{:?} to the contract 0x{:?}, reason: {:?}.",
+					reducible_deposit_balance,
+					HexDisplay::from(&deposit_account.encode()),
+					HexDisplay::from(&account.encode()),
+					err
+				);
+				Zero::zero()
+			});
+
+			// Hold the reserved balance.
+			if transferred_deposit_balance == Zero::zero() {
+				log::warn!(
+					target: LOG_TARGET,
+					"No balance to hold as storage deposit on the contract 0x{:?}.",
+					HexDisplay::from(&account.encode())
+				);
+			} else {
+				log::debug!(
+					target: LOG_TARGET,
+					"Holding {:?} as storage deposit on the contract 0x{:?}.",
+					transferred_deposit_balance,
+					HexDisplay::from(&account.encode())
+				);
+
+				T::Currency::hold(
+					&HoldReason::StorageDepositReserve.into(),
+					&account,
+					transferred_deposit_balance,
+				)
+				.unwrap_or_else(|err| {
+					log::error!(
+						target: LOG_TARGET,
+						"Failed to hold {:?} as storage deposit on the contract 0x{:?}, reason: {:?}.",
+						transferred_deposit_balance,
+						HexDisplay::from(&account.encode()),
+						err
+					);
+				});
+			}
+
+			log::debug!(target: LOG_TARGET, "===");
+			let info = ContractInfo {
+				trie_id: old_contract.trie_id,
+				code_hash: old_contract.code_hash,
+				storage_bytes: old_contract.storage_bytes,
+				storage_items: old_contract.storage_items,
+				storage_byte_deposit: old_contract.storage_byte_deposit,
+				storage_item_deposit: old_contract.storage_item_deposit,
+				storage_base_deposit: old_contract.storage_base_deposit,
+				delegate_dependencies: old_contract.delegate_dependencies,
+			};
+			ContractInfoOf::<T>::insert(account.clone(), info);
+
+			// Store last key for next migration step
+			self.last_account = Some(account);
+
+			(IsFinished::No, T::WeightInfo::v15_migration_step())
+		} else {
+			log::info!(target: LOG_TARGET, "Done Migrating Storage Deposits.");
+			(IsFinished::Yes, T::WeightInfo::v15_migration_step())
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade_step() -> Result<Vec<u8>, TryRuntimeError> {
+		let sample: Vec<_> = old::ContractInfoOf::<T>::iter().take(100).collect();
+
+		log::debug!(target: LOG_TARGET, "Taking sample of {} contracts", sample.len());
+
+		let state: Vec<(T::AccountId, old::ContractInfo<T>, BalanceOf<T>, BalanceOf<T>)> = sample
+			.iter()
+			.map(|(account, contract)| {
+				(
+					account.clone(),
+					contract.clone(),
+					T::Currency::total_balance(&account),
+					T::Currency::total_balance(&contract.deposit_account),
+				)
+			})
+			.collect();
+
+		Ok(state.encode())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade_step(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let sample =
+			<Vec<(T::AccountId, old::ContractInfo<T>, BalanceOf<T>, BalanceOf<T>)> as Decode>::decode(
+				&mut &state[..],
+			)
+			.expect("pre_upgrade_step provides a valid state; qed");
+
+		log::debug!(target: LOG_TARGET, "Validating sample of {} contracts", sample.len());
+		for (account, old_contract, old_account_balance, old_deposit_balance) in sample {
+			log::debug!(target: LOG_TARGET, "===");
+			log::debug!(target: LOG_TARGET, "Account: 0x{} ", HexDisplay::from(&account.encode()));
+
+			let on_hold =
+				T::Currency::balance_on_hold(&HoldReason::StorageDepositReserve.into(), &account);
+			let account_balance = T::Currency::total_balance(&account);
+
+			log::debug!(
+				target: LOG_TARGET,
+				"Validating balances match. Old deposit account's balance: {:?}. Contract's on hold: {:?}. Old contract's total balance: {:?}, Contract's total balance: {:?}.",
+				old_deposit_balance,
+				on_hold,
+				old_account_balance,
+				account_balance
+			);
+			ensure!(
+				old_account_balance.saturating_add(old_deposit_balance) == account_balance,
+				"total balance mismatch"
+			);
+			ensure!(old_deposit_balance == on_hold, "deposit mismatch");
+			ensure!(
+				!System::<T>::account_exists(&old_contract.deposit_account),
+				"deposit account still exists"
+			);
+
+			let migration_contract_info = ContractInfoOf::<T>::try_get(&account).unwrap();
+			let crate_contract_info = crate::ContractInfoOf::<T>::try_get(&account).unwrap();
+			ensure!(
+				migration_contract_info.trie_id == crate_contract_info.trie_id,
+				"trie_id mismatch"
+			);
+			ensure!(
+				migration_contract_info.code_hash == crate_contract_info.code_hash,
+				"code_hash mismatch"
+			);
+			ensure!(
+				migration_contract_info.storage_byte_deposit ==
+					crate_contract_info.storage_byte_deposit,
+				"storage_byte_deposit mismatch"
+			);
+			ensure!(
+				migration_contract_info.storage_base_deposit ==
+					crate_contract_info.storage_base_deposit(),
+				"storage_base_deposit mismatch"
+			);
+			ensure!(
+				&migration_contract_info.delegate_dependencies ==
+					crate_contract_info.delegate_dependencies(),
+				"delegate_dependencies mismatch"
+			);
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/schedule.rs b/substrate/frame/contracts/src/schedule.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5ca18af026a4c7f3ec40e00aaf612ce5a09758ad
--- /dev/null
+++ b/substrate/frame/contracts/src/schedule.rs
@@ -0,0 +1,502 @@
+// 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 module contains the cost schedule and supporting code that constructs a
+//! sane default schedule from a `WeightInfo` implementation.
+
+use crate::{weights::WeightInfo, Config};
+
+use codec::{Decode, Encode};
+use frame_support::{weights::Weight, DefaultNoBound};
+use pallet_contracts_proc_macro::{ScheduleDebug, WeightDebug};
+use scale_info::TypeInfo;
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+use sp_runtime::RuntimeDebug;
+use sp_std::marker::PhantomData;
+
+/// Definition of the cost schedule and other parameterizations for the wasm vm.
+///
+/// Its [`Default`] implementation is the designated way to initialize this type. It uses
+/// the benchmarked information supplied by [`Config::WeightInfo`]. All of its fields are
+/// public and can therefore be modified. For example in order to change some of the limits
+/// and set a custom instruction weight version the following code could be used:
+/// ```rust
+/// use pallet_contracts::{Schedule, Limits, InstructionWeights, Config};
+///
+/// fn create_schedule<T: Config>() -> Schedule<T> {
+///     Schedule {
+///         limits: Limits {
+/// 		        globals: 3,
+/// 		        parameters: 3,
+/// 		        memory_pages: 16,
+/// 		        table_size: 3,
+/// 		        br_table_size: 3,
+/// 		        .. Default::default()
+/// 	        },
+///         instruction_weights: InstructionWeights {
+///             .. Default::default()
+///         },
+/// 	        .. Default::default()
+///     }
+/// }
+/// ```
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(bound(serialize = "", deserialize = "")))]
+#[derive(Clone, Encode, Decode, PartialEq, Eq, ScheduleDebug, DefaultNoBound, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct Schedule<T: Config> {
+	/// Describes the upper limits on various metrics.
+	pub limits: Limits,
+
+	/// 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>,
+}
+
+/// Describes the upper limits on various metrics.
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Clone, Encode, Decode, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Limits {
+	/// The maximum number of topics supported by an event.
+	pub event_topics: u32,
+
+	/// Maximum number of globals a module is allowed to declare.
+	///
+	/// Globals are not limited through the linear memory limit `memory_pages`.
+	pub globals: u32,
+
+	/// Maximum number of locals a function can have.
+	///
+	/// As wasm engine initializes each of the local, we need to limit their number to confine
+	/// execution costs.
+	pub locals: u32,
+
+	/// Maximum numbers of parameters a function can have.
+	///
+	/// Those need to be limited to prevent a potentially exploitable interaction with
+	/// the stack height instrumentation: The costs of executing the stack height
+	/// instrumentation for an indirectly called function scales linearly with the amount
+	/// of parameters of this function. Because the stack height instrumentation itself is
+	/// is not weight metered its costs must be static (via this limit) and included in
+	/// the costs of the instructions that cause them (call, call_indirect).
+	pub parameters: u32,
+
+	/// Maximum number of memory pages allowed for a contract.
+	pub memory_pages: u32,
+
+	/// Maximum number of elements allowed in a table.
+	///
+	/// Currently, the only type of element that is allowed in a table is funcref.
+	pub table_size: u32,
+
+	/// Maximum number of elements that can appear as immediate value to the br_table instruction.
+	pub br_table_size: u32,
+
+	/// The maximum length of a subject in bytes used for PRNG generation.
+	pub subject_len: u32,
+
+	/// The maximum size of a storage value and event payload in bytes.
+	pub payload_len: u32,
+
+	/// The maximum node runtime memory. This is for integrity checks only and does not affect the
+	/// real setting.
+	pub runtime_memory: u32,
+}
+
+impl Limits {
+	/// The maximum memory size in bytes that a contract can occupy.
+	pub fn max_memory_size(&self) -> u32 {
+		self.memory_pages * 64 * 1024
+	}
+}
+
+/// Gas metering of Wasm executed instructions is being done on the engine side.
+/// This struct holds a reference value used to gas units scaling between host and engine.
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[derive(Clone, Encode, Decode, PartialEq, Eq, ScheduleDebug, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct InstructionWeights<T: Config> {
+	/// Base instruction `ref_time` Weight.
+	/// Should match to wasmi's `1` fuel (see <https://github.com/paritytech/wasmi/issues/701>).
+	pub base: u32,
+	/// The type parameter is used in the default implementation.
+	#[codec(skip)]
+	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))]
+#[derive(Clone, Encode, Decode, PartialEq, Eq, WeightDebug, 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 byten 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 `add_delegate_dependency`.
+	pub add_delegate_dependency: Weight,
+
+	/// Weight of calling `remove_delegate_dependency`.
+	pub remove_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_instr_no_params {
+	($name:ident) => {
+		cost_args!($name, 1).ref_time() as u32
+	};
+}
+
+macro_rules! cost {
+	($name:ident) => {
+		cost_args!($name, 1)
+	};
+}
+
+macro_rules! cost_instr {
+	($name:ident, $num_params:expr) => {
+		cost_instr_no_params!($name)
+			.saturating_sub((cost_instr_no_params!(instr_i64const) / 2).saturating_mul($num_params))
+	};
+}
+
+impl Default for Limits {
+	fn default() -> Self {
+		Self {
+			event_topics: 4,
+			globals: 256,
+			locals: 1024,
+			parameters: 128,
+			memory_pages: 16,
+			// 4k function pointers (This is in count not bytes).
+			table_size: 4096,
+			br_table_size: 256,
+			subject_len: 32,
+			payload_len: 16 * 1024,
+			runtime_memory: 1024 * 1024 * 128,
+		}
+	}
+}
+
+impl<T: Config> Default for InstructionWeights<T> {
+	/// We price both `i64.const` and `drop` as `instr_i64const / 2`. The reason
+	/// for that is that we cannot benchmark either of them on its own.
+	fn default() -> Self {
+		Self { base: cost_instr!(instr_i64const, 1), _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),
+			add_delegate_dependency: cost!(add_delegate_dependency),
+			remove_delegate_dependency: cost!(remove_delegate_dependency),
+			_phantom: PhantomData,
+		}
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::tests::Test;
+
+	#[test]
+	fn print_test_schedule() {
+		let schedule = Schedule::<Test>::default();
+		println!("{:#?}", schedule);
+	}
+}
diff --git a/substrate/frame/contracts/src/storage.rs b/substrate/frame/contracts/src/storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d58fd0fe9dbdf42d01dac9f048fba96ea4973664
--- /dev/null
+++ b/substrate/frame/contracts/src/storage.rs
@@ -0,0 +1,461 @@
+// 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 module contains routines for accessing and altering a contract related state.
+
+pub mod meter;
+
+use crate::{
+	exec::{AccountIdOf, Key},
+	weights::WeightInfo,
+	BalanceOf, CodeHash, CodeInfo, Config, ContractInfoOf, DeletionQueue, DeletionQueueCounter,
+	Error, Pallet, TrieId, SENTINEL,
+};
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::DispatchError,
+	storage::child::{self, ChildInfo},
+	weights::Weight,
+	CloneNoBound, DefaultNoBound,
+};
+use scale_info::TypeInfo;
+use sp_core::Get;
+use sp_io::KillStorageResult;
+use sp_runtime::{
+	traits::{Hash, Saturating, Zero},
+	BoundedBTreeMap, DispatchResult, RuntimeDebug,
+};
+use sp_std::{marker::PhantomData, prelude::*};
+
+use self::meter::Diff;
+
+/// Information for managing an account and its sub trie abstraction.
+/// This is the required info to cache for an account.
+#[derive(Encode, Decode, CloneNoBound, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(T))]
+pub struct ContractInfo<T: Config> {
+	/// Unique ID for the subtree encoded as a bytes vector.
+	pub trie_id: TrieId,
+	/// The code associated with a given account.
+	pub code_hash: CodeHash<T>,
+	/// How many bytes of storage are accumulated in this contract's child trie.
+	storage_bytes: u32,
+	/// How many items of storage are accumulated in this contract's child trie.
+	storage_items: u32,
+	/// This records to how much deposit the accumulated `storage_bytes` amount to.
+	pub storage_byte_deposit: BalanceOf<T>,
+	/// This records to how much deposit the accumulated `storage_items` amount to.
+	storage_item_deposit: BalanceOf<T>,
+	/// This records how much deposit is put down in order to pay for the contract itself.
+	///
+	/// We need to store this information separately so it is not used when calculating any refunds
+	/// since the base deposit can only ever be refunded on contract termination.
+	storage_base_deposit: BalanceOf<T>,
+	/// Map of code hashes and deposit balances.
+	///
+	/// Tracks the code hash and deposit held for adding delegate dependencies. Dependencies added
+	/// to the map can not be removed from the chain state and can be safely used for delegate
+	/// calls.
+	delegate_dependencies: BoundedBTreeMap<CodeHash<T>, BalanceOf<T>, T::MaxDelegateDependencies>,
+}
+
+impl<T: Config> ContractInfo<T> {
+	/// Constructs a new contract info **without** writing it to storage.
+	///
+	/// This returns an `Err` if an contract with the supplied `account` already exists
+	/// in storage.
+	pub fn new(
+		account: &AccountIdOf<T>,
+		nonce: u64,
+		code_hash: CodeHash<T>,
+	) -> Result<Self, DispatchError> {
+		if <ContractInfoOf<T>>::contains_key(account) {
+			return Err(Error::<T>::DuplicateContract.into())
+		}
+
+		let trie_id = {
+			let buf = (account, nonce).using_encoded(T::Hashing::hash);
+			buf.as_ref()
+				.to_vec()
+				.try_into()
+				.expect("Runtime uses a reasonable hash size. Hence sizeof(T::Hash) <= 128; qed")
+		};
+
+		let contract = Self {
+			trie_id,
+			code_hash,
+			storage_bytes: 0,
+			storage_items: 0,
+			storage_byte_deposit: Zero::zero(),
+			storage_item_deposit: Zero::zero(),
+			storage_base_deposit: Zero::zero(),
+			delegate_dependencies: Default::default(),
+		};
+
+		Ok(contract)
+	}
+
+	/// Associated child trie unique id is built from the hash part of the trie id.
+	pub fn child_trie_info(&self) -> ChildInfo {
+		ChildInfo::new_default(self.trie_id.as_ref())
+	}
+
+	/// The deposit paying for the accumulated storage generated within the contract's child trie.
+	pub fn extra_deposit(&self) -> BalanceOf<T> {
+		self.storage_byte_deposit.saturating_add(self.storage_item_deposit)
+	}
+
+	/// Same as [`Self::extra_deposit`] but including the base deposit.
+	pub fn total_deposit(&self) -> BalanceOf<T> {
+		self.extra_deposit()
+			.saturating_add(self.storage_base_deposit)
+			.saturating_sub(Pallet::<T>::min_balance())
+	}
+
+	/// Returns the storage base deposit of the contract.
+	pub fn storage_base_deposit(&self) -> BalanceOf<T> {
+		self.storage_base_deposit
+	}
+
+	/// Reads a storage kv pair of a contract.
+	///
+	/// The read is performed from the `trie_id` only. The `address` is not necessary. If the
+	/// contract doesn't store under the given `key` `None` is returned.
+	pub fn read(&self, key: &Key<T>) -> Option<Vec<u8>> {
+		child::get_raw(&self.child_trie_info(), key.hash().as_slice())
+	}
+
+	/// Returns `Some(len)` (in bytes) if a storage item exists at `key`.
+	///
+	/// Returns `None` if the `key` wasn't previously set by `set_storage` or
+	/// was deleted.
+	pub fn size(&self, key: &Key<T>) -> Option<u32> {
+		child::len(&self.child_trie_info(), key.hash().as_slice())
+	}
+
+	/// Update a storage entry into a contract's kv storage.
+	///
+	/// If the `new_value` is `None` then the kv pair is removed. If `take` is true
+	/// a [`WriteOutcome::Taken`] is returned instead of a [`WriteOutcome::Overwritten`].
+	///
+	/// This function also records how much storage was created or removed if a `storage_meter`
+	/// is supplied. It should only be absent for testing or benchmarking code.
+	pub fn write(
+		&self,
+		key: &Key<T>,
+		new_value: Option<Vec<u8>>,
+		storage_meter: Option<&mut meter::NestedMeter<T>>,
+		take: bool,
+	) -> Result<WriteOutcome, DispatchError> {
+		let child_trie_info = &self.child_trie_info();
+		let hashed_key = key.hash();
+		let (old_len, old_value) = if take {
+			let val = child::get_raw(child_trie_info, &hashed_key);
+			(val.as_ref().map(|v| v.len() as u32), val)
+		} else {
+			(child::len(child_trie_info, &hashed_key), None)
+		};
+
+		if let Some(storage_meter) = storage_meter {
+			let mut diff = meter::Diff::default();
+			match (old_len, new_value.as_ref().map(|v| v.len() as u32)) {
+				(Some(old_len), Some(new_len)) =>
+					if new_len > old_len {
+						diff.bytes_added = new_len - old_len;
+					} else {
+						diff.bytes_removed = old_len - new_len;
+					},
+				(None, Some(new_len)) => {
+					diff.bytes_added = new_len;
+					diff.items_added = 1;
+				},
+				(Some(old_len), None) => {
+					diff.bytes_removed = old_len;
+					diff.items_removed = 1;
+				},
+				(None, None) => (),
+			}
+			storage_meter.charge(&diff);
+		}
+
+		match &new_value {
+			Some(new_value) => child::put_raw(child_trie_info, &hashed_key, new_value),
+			None => child::kill(child_trie_info, &hashed_key),
+		}
+
+		Ok(match (old_len, old_value) {
+			(None, _) => WriteOutcome::New,
+			(Some(old_len), None) => WriteOutcome::Overwritten(old_len),
+			(Some(_), Some(old_value)) => WriteOutcome::Taken(old_value),
+		})
+	}
+
+	/// Sets and returns the contract base deposit.
+	///
+	/// The base deposit is updated when the `code_hash` of the contract changes, as it depends on
+	/// the deposit paid to upload the contract's code.
+	pub fn update_base_deposit(&mut self, code_info: &CodeInfo<T>) -> BalanceOf<T> {
+		let ed = Pallet::<T>::min_balance();
+		let info_deposit =
+			Diff { bytes_added: self.encoded_size() as u32, items_added: 1, ..Default::default() }
+				.update_contract::<T>(None)
+				.charge_or_zero();
+
+		// Instantiating the contract prevents its code to be deleted, therefore the base deposit
+		// includes a fraction (`T::CodeHashLockupDepositPercent`) of the original storage deposit
+		// to prevent abuse.
+		let upload_deposit = T::CodeHashLockupDepositPercent::get().mul_ceil(code_info.deposit());
+
+		// Instantiate needs to transfer at least the minimum balance in order to pull the
+		// contract's own account into existence, as the deposit itself does not contribute to the
+		// `ed`.
+		let deposit = info_deposit.saturating_add(upload_deposit).saturating_add(ed);
+
+		self.storage_base_deposit = deposit;
+		deposit
+	}
+
+	/// Adds a new delegate dependency to the contract.
+	/// The `amount` is the amount of funds that will be reserved for the dependency.
+	///
+	/// Returns an error if the maximum number of delegate_dependencies is reached or if
+	/// the delegate dependency already exists.
+	pub fn add_delegate_dependency(
+		&mut self,
+		code_hash: CodeHash<T>,
+		amount: BalanceOf<T>,
+	) -> DispatchResult {
+		self.delegate_dependencies
+			.try_insert(code_hash, amount)
+			.map_err(|_| Error::<T>::MaxDelegateDependenciesReached)?
+			.map_or(Ok(()), |_| Err(Error::<T>::DelegateDependencyAlreadyExists))
+			.map_err(Into::into)
+	}
+
+	/// Removes the delegate dependency from the contract and returns the deposit held for this
+	/// dependency.
+	///
+	/// Returns an error if the entry doesn't exist.
+	pub fn remove_delegate_dependency(
+		&mut self,
+		code_hash: &CodeHash<T>,
+	) -> Result<BalanceOf<T>, DispatchError> {
+		self.delegate_dependencies
+			.remove(code_hash)
+			.ok_or(Error::<T>::DelegateDependencyNotFound.into())
+	}
+
+	/// Returns the delegate_dependencies of the contract.
+	pub fn delegate_dependencies(
+		&self,
+	) -> &BoundedBTreeMap<CodeHash<T>, BalanceOf<T>, T::MaxDelegateDependencies> {
+		&self.delegate_dependencies
+	}
+
+	/// Push a contract's trie to the deletion queue for lazy removal.
+	///
+	/// You must make sure that the contract is also removed when queuing the trie for deletion.
+	pub fn queue_trie_for_deletion(&self) {
+		DeletionQueueManager::<T>::load().insert(self.trie_id.clone());
+	}
+
+	/// Calculates the weight that is necessary to remove one key from the trie and how many
+	/// of those keys can be deleted from the deletion queue given the supplied weight limit.
+	pub fn deletion_budget(weight_limit: Weight) -> (Weight, u32) {
+		let base_weight = T::WeightInfo::on_process_deletion_queue_batch();
+		let weight_per_key = T::WeightInfo::on_initialize_per_trie_key(1) -
+			T::WeightInfo::on_initialize_per_trie_key(0);
+
+		// `weight_per_key` being zero makes no sense and would constitute a failure to
+		// benchmark properly. We opt for not removing any keys at all in this case.
+		let key_budget = weight_limit
+			.saturating_sub(base_weight)
+			.checked_div_per_component(&weight_per_key)
+			.unwrap_or(0) as u32;
+
+		(weight_per_key, key_budget)
+	}
+
+	/// Delete as many items from the deletion queue possible within the supplied weight limit.
+	///
+	/// It returns the amount of weight used for that task.
+	pub fn process_deletion_queue_batch(weight_limit: Weight) -> Weight {
+		let mut queue = <DeletionQueueManager<T>>::load();
+
+		if queue.is_empty() {
+			return Weight::zero()
+		}
+
+		let (weight_per_key, mut remaining_key_budget) = Self::deletion_budget(weight_limit);
+
+		// We want to check whether we have enough weight to decode the queue before
+		// proceeding. Too little weight for decoding might happen during runtime upgrades
+		// which consume the whole block before the other `on_initialize` blocks are called.
+		if remaining_key_budget == 0 {
+			return weight_limit
+		}
+
+		while remaining_key_budget > 0 {
+			let Some(entry) = queue.next() else { break };
+
+			#[allow(deprecated)]
+			let outcome = child::kill_storage(
+				&ChildInfo::new_default(&entry.trie_id),
+				Some(remaining_key_budget),
+			);
+
+			match outcome {
+				// This happens when our budget wasn't large enough to remove all keys.
+				KillStorageResult::SomeRemaining(_) => return weight_limit,
+				KillStorageResult::AllRemoved(keys_removed) => {
+					entry.remove();
+					remaining_key_budget = remaining_key_budget.saturating_sub(keys_removed);
+				},
+			};
+		}
+
+		weight_limit.saturating_sub(weight_per_key.saturating_mul(u64::from(remaining_key_budget)))
+	}
+
+	/// Returns the code hash of the contract specified by `account` ID.
+	pub fn load_code_hash(account: &AccountIdOf<T>) -> Option<CodeHash<T>> {
+		<ContractInfoOf<T>>::get(account).map(|i| i.code_hash)
+	}
+}
+
+/// Information about what happened to the pre-existing value when calling [`ContractInfo::write`].
+#[cfg_attr(test, derive(Debug, PartialEq))]
+pub enum WriteOutcome {
+	/// No value existed at the specified key.
+	New,
+	/// A value of the returned length was overwritten.
+	Overwritten(u32),
+	/// The returned value was taken out of storage before being overwritten.
+	///
+	/// This is only returned when specifically requested because it causes additional work
+	/// depending on the size of the pre-existing value. When not requested [`Self::Overwritten`]
+	/// is returned instead.
+	Taken(Vec<u8>),
+}
+
+impl WriteOutcome {
+	/// Extracts the size of the overwritten value or `0` if there
+	/// was no value in storage.
+	pub fn old_len(&self) -> u32 {
+		match self {
+			Self::New => 0,
+			Self::Overwritten(len) => *len,
+			Self::Taken(value) => value.len() as u32,
+		}
+	}
+
+	/// Extracts the size of the overwritten value or `SENTINEL` if there
+	/// was no value in storage.
+	///
+	/// # Note
+	///
+	/// We cannot use `0` as sentinel value because there could be a zero sized
+	/// storage entry which is different from a non existing one.
+	pub fn old_len_with_sentinel(&self) -> u32 {
+		match self {
+			Self::New => SENTINEL,
+			Self::Overwritten(len) => *len,
+			Self::Taken(value) => value.len() as u32,
+		}
+	}
+}
+
+/// Manage the removal of contracts storage that are marked for deletion.
+///
+/// When a contract is deleted by calling `seal_terminate` it becomes inaccessible
+/// immediately, but the deletion of the storage items it has accumulated is performed
+/// later by pulling the contract from the queue in the `on_idle` hook.
+#[derive(Encode, Decode, TypeInfo, MaxEncodedLen, DefaultNoBound, Clone)]
+#[scale_info(skip_type_params(T))]
+pub struct DeletionQueueManager<T: Config> {
+	/// Counter used as a key for inserting a new deleted contract in the queue.
+	/// The counter is incremented after each insertion.
+	insert_counter: u32,
+	/// The index used to read the next element to be deleted in the queue.
+	/// The counter is incremented after each deletion.
+	delete_counter: u32,
+
+	_phantom: PhantomData<T>,
+}
+
+/// View on a contract that is marked for deletion.
+struct DeletionQueueEntry<'a, T: Config> {
+	/// the trie id of the contract to delete.
+	trie_id: TrieId,
+
+	/// A mutable reference on the queue so that the contract can be removed, and none can be added
+	/// or read in the meantime.
+	queue: &'a mut DeletionQueueManager<T>,
+}
+
+impl<'a, T: Config> DeletionQueueEntry<'a, T> {
+	/// Remove the contract from the deletion queue.
+	fn remove(self) {
+		<DeletionQueue<T>>::remove(self.queue.delete_counter);
+		self.queue.delete_counter = self.queue.delete_counter.wrapping_add(1);
+		<DeletionQueueCounter<T>>::set(self.queue.clone());
+	}
+}
+
+impl<T: Config> DeletionQueueManager<T> {
+	/// Load the `DeletionQueueCounter`, so we can perform read or write operations on the
+	/// DeletionQueue storage.
+	fn load() -> Self {
+		<DeletionQueueCounter<T>>::get()
+	}
+
+	/// Returns `true` if the queue contains no elements.
+	fn is_empty(&self) -> bool {
+		self.insert_counter.wrapping_sub(self.delete_counter) == 0
+	}
+
+	/// Insert a contract in the deletion queue.
+	fn insert(&mut self, trie_id: TrieId) {
+		<DeletionQueue<T>>::insert(self.insert_counter, trie_id);
+		self.insert_counter = self.insert_counter.wrapping_add(1);
+		<DeletionQueueCounter<T>>::set(self.clone());
+	}
+
+	/// Fetch the next contract to be deleted.
+	///
+	/// Note:
+	/// we use the delete counter to get the next value to read from the queue and thus don't pay
+	/// the cost of an extra call to `sp_io::storage::next_key` to lookup the next entry in the map
+	fn next(&mut self) -> Option<DeletionQueueEntry<T>> {
+		if self.is_empty() {
+			return None
+		}
+
+		let entry = <DeletionQueue<T>>::get(self.delete_counter);
+		entry.map(|trie_id| DeletionQueueEntry { trie_id, queue: self })
+	}
+}
+
+#[cfg(test)]
+impl<T: Config> DeletionQueueManager<T> {
+	pub fn from_test_values(insert_counter: u32, delete_counter: u32) -> Self {
+		Self { insert_counter, delete_counter, _phantom: Default::default() }
+	}
+	pub fn as_test_tuple(&self) -> (u32, u32) {
+		(self.insert_counter, self.delete_counter)
+	}
+}
diff --git a/substrate/frame/contracts/src/storage/meter.rs b/substrate/frame/contracts/src/storage/meter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a9a083412b00f56a74d1bf2526b00a32b78848b
--- /dev/null
+++ b/substrate/frame/contracts/src/storage/meter.rs
@@ -0,0 +1,924 @@
+// 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 module contains functions to meter the storage deposit.
+
+use crate::{
+	storage::ContractInfo, AccountIdOf, BalanceOf, CodeInfo, Config, Error, Event, HoldReason,
+	Inspect, Origin, Pallet, StorageDeposit as Deposit, System, LOG_TARGET,
+};
+
+use frame_support::{
+	dispatch::{fmt::Debug, DispatchError},
+	ensure,
+	traits::{
+		fungible::{Mutate, MutateHold},
+		tokens::{
+			Fortitude, Fortitude::Polite, Precision, Preservation, Restriction, WithdrawConsequence,
+		},
+		Get,
+	},
+	DefaultNoBound, RuntimeDebugNoBound,
+};
+use sp_api::HashT;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	FixedPointNumber, FixedU128,
+};
+use sp_std::{marker::PhantomData, vec, vec::Vec};
+
+/// Deposit that uses the native fungible's balance type.
+pub type DepositOf<T> = Deposit<BalanceOf<T>>;
+
+/// A production root storage meter that actually charges from its origin.
+pub type Meter<T> = RawMeter<T, ReservingExt, Root>;
+
+/// A production nested storage meter that actually charges from its origin.
+pub type NestedMeter<T> = RawMeter<T, ReservingExt, Nested>;
+
+/// A production storage meter that actually charges from its origin.
+///
+/// This can be used where we want to be generic over the state (Root vs. Nested).
+pub type GenericMeter<T, S> = RawMeter<T, ReservingExt, S>;
+
+/// A trait that allows to decouple the metering from the charging of balance.
+///
+/// This mostly exists for testing so that the charging can be mocked.
+pub trait Ext<T: Config> {
+	/// This checks whether `origin` is able to afford the storage deposit limit.
+	///
+	/// It is necessary to do this check beforehand so that the charge won't fail later on.
+	///
+	/// `origin`: The origin of the call stack from which is responsible for putting down a deposit.
+	/// `limit`: The limit with which the meter was constructed.
+	/// `min_leftover`: How much `free_balance` in addition to the existential deposit (ed) should
+	/// be left inside the `origin` account.
+	///
+	/// Returns the limit that should be used by the meter. If origin can't afford the `limit`
+	/// it returns `Err`.
+	fn check_limit(
+		origin: &T::AccountId,
+		limit: Option<BalanceOf<T>>,
+		min_leftover: BalanceOf<T>,
+	) -> Result<BalanceOf<T>, DispatchError>;
+	/// This is called to inform the implementer that some balance should be charged due to
+	/// some interaction of the `origin` with a `contract`.
+	///
+	/// The balance transfer can either flow from `origin` to `contract` or the other way
+	/// around depending on whether `amount` constitutes a `Charge` or a `Refund`.
+	/// It should be used in combination with `check_limit` to check that no more balance than this
+	/// limit is ever charged.
+	fn charge(
+		origin: &T::AccountId,
+		contract: &T::AccountId,
+		amount: &DepositOf<T>,
+		state: &ContractState<T>,
+	) -> Result<(), DispatchError>;
+}
+
+/// This [`Ext`] is used for actual on-chain execution when balance needs to be charged.
+///
+/// It uses [`frame_support::traits::fungible::Mutate`] in order to do accomplish the reserves.
+pub enum ReservingExt {}
+
+/// Used to implement a type state pattern for the meter.
+///
+/// It is sealed and cannot be implemented outside of this module.
+pub trait State: private::Sealed {}
+
+/// State parameter that constitutes a meter that is in its root state.
+#[derive(Default, Debug)]
+pub struct Root;
+
+/// State parameter that constitutes a meter that is in its nested state.
+/// Its value indicates whether the nested meter has its own limit.
+#[derive(DefaultNoBound, RuntimeDebugNoBound)]
+pub enum Nested {
+	#[default]
+	DerivedLimit,
+	OwnLimit,
+}
+
+impl State for Root {}
+impl State for Nested {}
+
+/// A type that allows the metering of consumed or freed storage of a single contract call stack.
+#[derive(DefaultNoBound, RuntimeDebugNoBound)]
+pub struct RawMeter<T: Config, E, S: State + Default + Debug> {
+	/// The limit of how much balance this meter is allowed to consume.
+	limit: BalanceOf<T>,
+	/// The amount of balance that was used in this meter and all of its already absorbed children.
+	total_deposit: DepositOf<T>,
+	/// The amount of storage changes that were recorded in this meter alone.
+	own_contribution: Contribution<T>,
+	/// List of charges that should be applied at the end of a contract stack execution.
+	///
+	/// We only have one charge per contract hence the size of this vector is
+	/// limited by the maximum call depth.
+	charges: Vec<Charge<T>>,
+	/// We store the nested state to determine if it has a special limit for sub-call.
+	nested: S,
+	/// Type parameter only used in impls.
+	_phantom: PhantomData<E>,
+}
+
+/// This type is used to describe a storage change when charging from the meter.
+#[derive(Default, RuntimeDebugNoBound)]
+pub struct Diff {
+	/// How many bytes were added to storage.
+	pub bytes_added: u32,
+	/// How many bytes were removed from storage.
+	pub bytes_removed: u32,
+	/// How many storage items were added to storage.
+	pub items_added: u32,
+	/// How many storage items were removed from storage.
+	pub items_removed: u32,
+}
+
+impl Diff {
+	/// Calculate how much of a charge or refund results from applying the diff and store it
+	/// in the passed `info` if any.
+	///
+	/// # Note
+	///
+	/// In case `None` is passed for `info` only charges are calculated. This is because refunds
+	/// are calculated pro rata of the existing storage within a contract and hence need extract
+	/// this information from the passed `info`.
+	pub fn update_contract<T: Config>(&self, info: Option<&mut ContractInfo<T>>) -> DepositOf<T> {
+		let per_byte = T::DepositPerByte::get();
+		let per_item = T::DepositPerItem::get();
+		let bytes_added = self.bytes_added.saturating_sub(self.bytes_removed);
+		let items_added = self.items_added.saturating_sub(self.items_removed);
+		let mut bytes_deposit = Deposit::Charge(per_byte.saturating_mul((bytes_added).into()));
+		let mut items_deposit = Deposit::Charge(per_item.saturating_mul((items_added).into()));
+
+		// Without any contract info we can only calculate diffs which add storage
+		let info = if let Some(info) = info {
+			info
+		} else {
+			debug_assert_eq!(self.bytes_removed, 0);
+			debug_assert_eq!(self.items_removed, 0);
+			return bytes_deposit.saturating_add(&items_deposit)
+		};
+
+		// Refunds are calculated pro rata based on the accumulated storage within the contract
+		let bytes_removed = self.bytes_removed.saturating_sub(self.bytes_added);
+		let items_removed = self.items_removed.saturating_sub(self.items_added);
+		let ratio = FixedU128::checked_from_rational(bytes_removed, info.storage_bytes)
+			.unwrap_or_default()
+			.min(FixedU128::from_u32(1));
+		bytes_deposit = bytes_deposit
+			.saturating_add(&Deposit::Refund(ratio.saturating_mul_int(info.storage_byte_deposit)));
+		let ratio = FixedU128::checked_from_rational(items_removed, info.storage_items)
+			.unwrap_or_default()
+			.min(FixedU128::from_u32(1));
+		items_deposit = items_deposit
+			.saturating_add(&Deposit::Refund(ratio.saturating_mul_int(info.storage_item_deposit)));
+
+		// We need to update the contract info structure with the new deposits
+		info.storage_bytes =
+			info.storage_bytes.saturating_add(bytes_added).saturating_sub(bytes_removed);
+		info.storage_items =
+			info.storage_items.saturating_add(items_added).saturating_sub(items_removed);
+		match &bytes_deposit {
+			Deposit::Charge(amount) =>
+				info.storage_byte_deposit = info.storage_byte_deposit.saturating_add(*amount),
+			Deposit::Refund(amount) =>
+				info.storage_byte_deposit = info.storage_byte_deposit.saturating_sub(*amount),
+		}
+		match &items_deposit {
+			Deposit::Charge(amount) =>
+				info.storage_item_deposit = info.storage_item_deposit.saturating_add(*amount),
+			Deposit::Refund(amount) =>
+				info.storage_item_deposit = info.storage_item_deposit.saturating_sub(*amount),
+		}
+
+		bytes_deposit.saturating_add(&items_deposit)
+	}
+}
+
+impl Diff {
+	fn saturating_add(&self, rhs: &Self) -> Self {
+		Self {
+			bytes_added: self.bytes_added.saturating_add(rhs.bytes_added),
+			bytes_removed: self.bytes_removed.saturating_add(rhs.bytes_removed),
+			items_added: self.items_added.saturating_add(rhs.items_added),
+			items_removed: self.items_removed.saturating_add(rhs.items_removed),
+		}
+	}
+}
+
+/// The state of a contract.
+///
+/// In case of termination the beneficiary is indicated.
+#[derive(RuntimeDebugNoBound, Clone, PartialEq, Eq)]
+pub enum ContractState<T: Config> {
+	Alive,
+	Terminated { beneficiary: AccountIdOf<T> },
+}
+
+/// Records information to charge or refund a plain account.
+///
+/// All the charges are deferred to the end of a whole call stack. Reason is that by doing
+/// this we can do all the refunds before doing any charge. This way a plain account can use
+/// more deposit than it has balance as along as it is covered by a refund. This
+/// essentially makes the order of storage changes irrelevant with regard to the deposit system.
+/// The only exception is when a special (tougher) deposit limit is specified for a cross-contract
+/// call. In that case the limit is enforced once the call is returned, rolling it back if
+/// exhausted.
+#[derive(RuntimeDebugNoBound, Clone)]
+struct Charge<T: Config> {
+	contract: T::AccountId,
+	amount: DepositOf<T>,
+	state: ContractState<T>,
+}
+
+/// Records the storage changes of a storage meter.
+#[derive(RuntimeDebugNoBound)]
+enum Contribution<T: Config> {
+	/// The contract the meter belongs to is alive and accumulates changes using a [`Diff`].
+	Alive(Diff),
+	/// The meter was checked against its limit using [`RawMeter::enforce_limit`] at the end of
+	/// its execution. In this process the [`Diff`] was converted into a [`Deposit`].
+	Checked(DepositOf<T>),
+	/// The contract was terminated. In this process the [`Diff`] was converted into a [`Deposit`]
+	/// in order to calculate the refund. Upon termination the `reducible_balance` in the
+	/// contract's account is transferred to the [`beneficiary`].
+	Terminated { deposit: DepositOf<T>, beneficiary: AccountIdOf<T> },
+}
+
+impl<T: Config> Contribution<T> {
+	/// See [`Diff::update_contract`].
+	fn update_contract(&self, info: Option<&mut ContractInfo<T>>) -> DepositOf<T> {
+		match self {
+			Self::Alive(diff) => diff.update_contract::<T>(info),
+			Self::Terminated { deposit, beneficiary: _ } | Self::Checked(deposit) =>
+				deposit.clone(),
+		}
+	}
+}
+
+impl<T: Config> Default for Contribution<T> {
+	fn default() -> Self {
+		Self::Alive(Default::default())
+	}
+}
+
+/// Functions that apply to all states.
+impl<T, E, S> RawMeter<T, E, S>
+where
+	T: Config,
+	E: Ext<T>,
+	S: State + Default + Debug,
+{
+	/// Create a new child that has its `limit`.
+	/// Passing `0` as the limit is interpreted as to take whatever is remaining from its parent.
+	///
+	/// This is called whenever a new subcall is initiated in order to track the storage
+	/// usage for this sub call separately. This is necessary because we want to exchange balance
+	/// with the current contract we are interacting with.
+	pub fn nested(&self, limit: BalanceOf<T>) -> RawMeter<T, E, Nested> {
+		debug_assert!(matches!(self.contract_state(), ContractState::Alive));
+		// If a special limit is specified higher than it is available,
+		// we want to enforce the lesser limit to the nested meter, to fail in the sub-call.
+		let limit = self.available().min(limit);
+		if limit.is_zero() {
+			RawMeter { limit: self.available(), ..Default::default() }
+		} else {
+			RawMeter { limit, nested: Nested::OwnLimit, ..Default::default() }
+		}
+	}
+
+	/// Absorb a child that was spawned to handle a sub call.
+	///
+	/// This should be called whenever a sub call comes to its end and it is **not** reverted.
+	/// This does the actual balance transfer from/to `origin` and `contract` based on the
+	/// overall storage consumption of the call. It also updates the supplied contract info.
+	///
+	/// In case a contract reverted the child meter should just be dropped in order to revert
+	/// any changes it recorded.
+	///
+	/// # Parameters
+	///
+	/// - `absorbed`: The child storage meter that should be absorbed.
+	/// - `origin`: The origin that spawned the original root meter.
+	/// - `contract`: The contract's account that this sub call belongs to.
+	/// - `info`: The info of the contract in question. `None` if the contract was terminated.
+	pub fn absorb(
+		&mut self,
+		absorbed: RawMeter<T, E, Nested>,
+		contract: &T::AccountId,
+		info: Option<&mut ContractInfo<T>>,
+	) {
+		let own_deposit = absorbed.own_contribution.update_contract(info);
+		self.total_deposit = self
+			.total_deposit
+			.saturating_add(&absorbed.total_deposit)
+			.saturating_add(&own_deposit);
+		self.charges.extend_from_slice(&absorbed.charges);
+		if !own_deposit.is_zero() {
+			self.charges.push(Charge {
+				contract: contract.clone(),
+				amount: own_deposit,
+				state: absorbed.contract_state(),
+			});
+		}
+	}
+
+	/// The amount of balance that is still available from the original `limit`.
+	fn available(&self) -> BalanceOf<T> {
+		self.total_deposit.available(&self.limit)
+	}
+
+	/// Returns the state of the currently executed contract.
+	fn contract_state(&self) -> ContractState<T> {
+		match &self.own_contribution {
+			Contribution::Terminated { deposit: _, beneficiary } =>
+				ContractState::Terminated { beneficiary: beneficiary.clone() },
+			_ => ContractState::Alive,
+		}
+	}
+}
+
+/// Functions that only apply to the root state.
+impl<T, E> RawMeter<T, E, Root>
+where
+	T: Config,
+	E: Ext<T>,
+{
+	/// Create new storage meter for the specified `origin` and `limit`.
+	///
+	/// This tries to [`Ext::check_limit`] on `origin` and fails if this is not possible.
+	pub fn new(
+		origin: &Origin<T>,
+		limit: Option<BalanceOf<T>>,
+		min_leftover: BalanceOf<T>,
+	) -> Result<Self, DispatchError> {
+		// Check the limit only if the origin is not root.
+		return match origin {
+			Origin::Root => Ok(Self {
+				limit: limit.unwrap_or(T::DefaultDepositLimit::get()),
+				..Default::default()
+			}),
+			Origin::Signed(o) => {
+				let limit = E::check_limit(o, limit, min_leftover)?;
+				Ok(Self { limit, ..Default::default() })
+			},
+		}
+	}
+
+	/// The total amount of deposit that should change hands as result of the execution
+	/// that this meter was passed into. This will also perform all the charges accumulated
+	/// in the whole contract stack.
+	///
+	/// This drops the root meter in order to make sure it is only called when the whole
+	/// execution did finish.
+	pub fn try_into_deposit(self, origin: &Origin<T>) -> Result<DepositOf<T>, DispatchError> {
+		// Only refund or charge deposit if the origin is not root.
+		let origin = match origin {
+			Origin::Root => return Ok(Deposit::Charge(Zero::zero())),
+			Origin::Signed(o) => o,
+		};
+		for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Refund(_))) {
+			E::charge(origin, &charge.contract, &charge.amount, &charge.state)?;
+		}
+		for charge in self.charges.iter().filter(|c| matches!(c.amount, Deposit::Charge(_))) {
+			E::charge(origin, &charge.contract, &charge.amount, &charge.state)?;
+		}
+		Ok(self.total_deposit)
+	}
+}
+
+/// Functions that only apply to the nested state.
+impl<T, E> RawMeter<T, E, Nested>
+where
+	T: Config,
+	E: Ext<T>,
+{
+	/// Charges `diff` from the meter.
+	pub fn charge(&mut self, diff: &Diff) {
+		match &mut self.own_contribution {
+			Contribution::Alive(own) => *own = own.saturating_add(diff),
+			_ => panic!("Charge is never called after termination; qed"),
+		};
+	}
+
+	/// Adds a deposit charge.
+	///
+	/// Use this method instead of [`Self::charge`] when the charge is not the result of a storage
+	/// change. This is the case when a `delegate_dependency` is added or removed, or when the
+	/// `code_hash` is updated. [`Self::charge`] cannot be used here because we keep track of the
+	/// deposit charge separately from the storage charge.
+	pub fn charge_deposit(&mut self, contract: T::AccountId, amount: DepositOf<T>) {
+		self.total_deposit = self.total_deposit.saturating_add(&amount);
+		self.charges.push(Charge { contract, amount, state: ContractState::Alive });
+	}
+
+	/// Charges from `origin` a storage deposit for contract instantiation.
+	///
+	/// This immediately transfers the balance in order to create the account.
+	pub fn charge_instantiate(
+		&mut self,
+		origin: &T::AccountId,
+		contract: &T::AccountId,
+		contract_info: &mut ContractInfo<T>,
+		code_info: &CodeInfo<T>,
+	) -> Result<DepositOf<T>, DispatchError> {
+		debug_assert!(matches!(self.contract_state(), ContractState::Alive));
+		let ed = Pallet::<T>::min_balance();
+
+		let deposit = contract_info.update_base_deposit(&code_info);
+		if deposit > self.limit {
+			return Err(<Error<T>>::StorageDepositLimitExhausted.into())
+		}
+
+		let deposit = Deposit::Charge(deposit);
+
+		// We do not increase `own_contribution` because this will be charged later when the
+		// contract execution does conclude and hence would lead to a double charge.
+		self.total_deposit = Deposit::Charge(ed);
+
+		// We need to make sure that the contract's account exists.
+		T::Currency::transfer(origin, contract, ed, Preservation::Preserve)?;
+
+		// A consumer is added at account creation and removed it on termination, otherwise the
+		// runtime could remove the account. As long as a contract exists its account must exist.
+		// With the consumer, a correct runtime cannot remove the account.
+		System::<T>::inc_consumers(contract)?;
+
+		self.charge_deposit(contract.clone(), deposit.saturating_sub(&Deposit::Charge(ed)));
+
+		Ok(deposit)
+	}
+
+	/// Call to tell the meter that the currently executing contract was terminated.
+	///
+	/// This will manipulate the meter so that all storage deposit accumulated in
+	/// `contract_info` will be refunded to the `origin` of the meter. And the free
+	/// (`reducible_balance`) will be sent to the `beneficiary`.
+	pub fn terminate(&mut self, info: &ContractInfo<T>, beneficiary: T::AccountId) {
+		debug_assert!(matches!(self.contract_state(), ContractState::Alive));
+		self.own_contribution = Contribution::Terminated {
+			deposit: Deposit::Refund(info.total_deposit()),
+			beneficiary,
+		};
+	}
+
+	/// [`Self::charge`] does not enforce the storage limit since we want to do this check as late
+	/// as possible to allow later refunds to offset earlier charges.
+	///
+	/// # Note
+	///
+	/// We normally need to call this **once** for every call stack and not for every cross contract
+	/// call. However, if a dedicated limit is specified for a sub-call, this needs to be called
+	/// once the sub-call has returned. For this, the [`Self::enforce_subcall_limit`] wrapper is
+	/// used.
+	pub fn enforce_limit(
+		&mut self,
+		info: Option<&mut ContractInfo<T>>,
+	) -> Result<(), DispatchError> {
+		let deposit = self.own_contribution.update_contract(info);
+		let total_deposit = self.total_deposit.saturating_add(&deposit);
+		// We don't want to override a `Terminated` with a `Checked`.
+		if matches!(self.contract_state(), ContractState::Alive) {
+			self.own_contribution = Contribution::Checked(deposit);
+		}
+		if let Deposit::Charge(amount) = total_deposit {
+			if amount > self.limit {
+				return Err(<Error<T>>::StorageDepositLimitExhausted.into())
+			}
+		}
+		Ok(())
+	}
+
+	/// This is a wrapper around [`Self::enforce_limit`] to use on the exit from a sub-call to
+	/// enforce its special limit if needed.
+	pub fn enforce_subcall_limit(
+		&mut self,
+		info: Option<&mut ContractInfo<T>>,
+	) -> Result<(), DispatchError> {
+		match self.nested {
+			Nested::OwnLimit => self.enforce_limit(info),
+			Nested::DerivedLimit => Ok(()),
+		}
+	}
+}
+
+impl<T: Config> Ext<T> for ReservingExt {
+	fn check_limit(
+		origin: &T::AccountId,
+		limit: Option<BalanceOf<T>>,
+		min_leftover: BalanceOf<T>,
+	) -> Result<BalanceOf<T>, DispatchError> {
+		// We are sending the `min_leftover` and the `min_balance` from the origin
+		// account as part of a contract call. Hence origin needs to have those left over
+		// as free balance after accounting for all deposits.
+		let max = T::Currency::reducible_balance(origin, Preservation::Preserve, Polite)
+			.saturating_sub(min_leftover)
+			.saturating_sub(Pallet::<T>::min_balance());
+		let default = max.min(T::DefaultDepositLimit::get());
+		let limit = limit.unwrap_or(default);
+		ensure!(
+			limit <= max &&
+				matches!(T::Currency::can_withdraw(origin, limit), WithdrawConsequence::Success),
+			<Error<T>>::StorageDepositNotEnoughFunds,
+		);
+		Ok(limit)
+	}
+
+	fn charge(
+		origin: &T::AccountId,
+		contract: &T::AccountId,
+		amount: &DepositOf<T>,
+		state: &ContractState<T>,
+	) -> Result<(), DispatchError> {
+		match amount {
+			Deposit::Charge(amount) | Deposit::Refund(amount) if amount.is_zero() => return Ok(()),
+			Deposit::Charge(amount) => {
+				// This could fail if the `origin` does not have enough liquidity. Ideally, though,
+				// this should have been checked before with `check_limit`.
+				T::Currency::transfer_and_hold(
+					&HoldReason::StorageDepositReserve.into(),
+					origin,
+					contract,
+					*amount,
+					Precision::Exact,
+					Preservation::Preserve,
+					Fortitude::Polite,
+				)?;
+
+				Pallet::<T>::deposit_event(
+					vec![T::Hashing::hash_of(&origin), T::Hashing::hash_of(&contract)],
+					Event::StorageDepositTransferredAndHeld {
+						from: origin.clone(),
+						to: contract.clone(),
+						amount: *amount,
+					},
+				);
+			},
+			Deposit::Refund(amount) => {
+				let transferred = T::Currency::transfer_on_hold(
+					&HoldReason::StorageDepositReserve.into(),
+					contract,
+					origin,
+					*amount,
+					Precision::BestEffort,
+					Restriction::Free,
+					Fortitude::Polite,
+				)?;
+
+				Pallet::<T>::deposit_event(
+					vec![T::Hashing::hash_of(&contract), T::Hashing::hash_of(&origin)],
+					Event::StorageDepositTransferredAndReleased {
+						from: contract.clone(),
+						to: origin.clone(),
+						amount: transferred,
+					},
+				);
+
+				if transferred < *amount {
+					// This should never happen, if it does it means that there is a bug in the
+					// runtime logic. In the rare case this happens we try to refund as much as we
+					// can, thus the `Precision::BestEffort`.
+					log::error!(
+						target: LOG_TARGET,
+						"Failed to repatriate full storage deposit {:?} from contract {:?} to origin {:?}. Transferred {:?}.",
+						amount, contract, origin, transferred,
+					);
+				}
+			},
+		}
+		if let ContractState::<T>::Terminated { beneficiary } = state {
+			System::<T>::dec_consumers(&contract);
+			// Whatever is left in the contract is sent to the termination beneficiary.
+			T::Currency::transfer(
+				&contract,
+				&beneficiary,
+				T::Currency::reducible_balance(&contract, Preservation::Expendable, Polite),
+				Preservation::Expendable,
+			)?;
+		}
+		Ok(())
+	}
+}
+
+mod private {
+	pub trait Sealed {}
+	impl Sealed for super::Root {}
+	impl Sealed for super::Nested {}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		exec::AccountIdOf,
+		tests::{Test, ALICE, BOB, CHARLIE},
+	};
+	use frame_support::parameter_types;
+	use pretty_assertions::assert_eq;
+
+	type TestMeter = RawMeter<Test, TestExt, Root>;
+
+	parameter_types! {
+		static TestExtTestValue: TestExt = Default::default();
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone)]
+	struct LimitCheck {
+		origin: AccountIdOf<Test>,
+		limit: BalanceOf<Test>,
+		min_leftover: BalanceOf<Test>,
+	}
+
+	#[derive(Debug, PartialEq, Eq, Clone)]
+	struct Charge {
+		origin: AccountIdOf<Test>,
+		contract: AccountIdOf<Test>,
+		amount: DepositOf<Test>,
+		state: ContractState<Test>,
+	}
+
+	#[derive(Default, Debug, PartialEq, Eq, Clone)]
+	pub struct TestExt {
+		limit_checks: Vec<LimitCheck>,
+		charges: Vec<Charge>,
+	}
+
+	impl TestExt {
+		fn clear(&mut self) {
+			self.limit_checks.clear();
+			self.charges.clear();
+		}
+	}
+
+	impl Ext<Test> for TestExt {
+		fn check_limit(
+			origin: &AccountIdOf<Test>,
+			limit: Option<BalanceOf<Test>>,
+			min_leftover: BalanceOf<Test>,
+		) -> Result<BalanceOf<Test>, DispatchError> {
+			let limit = limit.unwrap_or(42);
+			TestExtTestValue::mutate(|ext| {
+				ext.limit_checks
+					.push(LimitCheck { origin: origin.clone(), limit, min_leftover })
+			});
+			Ok(limit)
+		}
+
+		fn charge(
+			origin: &AccountIdOf<Test>,
+			contract: &AccountIdOf<Test>,
+			amount: &DepositOf<Test>,
+			state: &ContractState<Test>,
+		) -> Result<(), DispatchError> {
+			TestExtTestValue::mutate(|ext| {
+				ext.charges.push(Charge {
+					origin: origin.clone(),
+					contract: contract.clone(),
+					amount: amount.clone(),
+					state: state.clone(),
+				})
+			});
+			Ok(())
+		}
+	}
+
+	fn clear_ext() {
+		TestExtTestValue::mutate(|ext| ext.clear())
+	}
+
+	struct ChargingTestCase {
+		origin: Origin<Test>,
+		deposit: DepositOf<Test>,
+		expected: TestExt,
+	}
+
+	#[derive(Default)]
+	struct StorageInfo {
+		bytes: u32,
+		items: u32,
+		bytes_deposit: BalanceOf<Test>,
+		items_deposit: BalanceOf<Test>,
+	}
+
+	fn new_info(info: StorageInfo) -> ContractInfo<Test> {
+		ContractInfo::<Test> {
+			trie_id: Default::default(),
+			code_hash: Default::default(),
+			storage_bytes: info.bytes,
+			storage_items: info.items,
+			storage_byte_deposit: info.bytes_deposit,
+			storage_item_deposit: info.items_deposit,
+			storage_base_deposit: Default::default(),
+			delegate_dependencies: Default::default(),
+		}
+	}
+
+	#[test]
+	fn new_reserves_balance_works() {
+		clear_ext();
+
+		TestMeter::new(&Origin::from_account_id(ALICE), Some(1_000), 0).unwrap();
+
+		assert_eq!(
+			TestExtTestValue::get(),
+			TestExt {
+				limit_checks: vec![LimitCheck { origin: ALICE, limit: 1_000, min_leftover: 0 }],
+				..Default::default()
+			}
+		)
+	}
+
+	#[test]
+	fn empty_charge_works() {
+		clear_ext();
+
+		let mut meter = TestMeter::new(&Origin::from_account_id(ALICE), Some(1_000), 0).unwrap();
+		assert_eq!(meter.available(), 1_000);
+
+		// an empty charge does not create a `Charge` entry
+		let mut nested0 = meter.nested(BalanceOf::<Test>::zero());
+		nested0.charge(&Default::default());
+		meter.absorb(nested0, &BOB, None);
+
+		assert_eq!(
+			TestExtTestValue::get(),
+			TestExt {
+				limit_checks: vec![LimitCheck { origin: ALICE, limit: 1_000, min_leftover: 0 }],
+				..Default::default()
+			}
+		)
+	}
+
+	#[test]
+	fn charging_works() {
+		let test_cases = vec![
+			ChargingTestCase {
+				origin: Origin::<Test>::from_account_id(ALICE),
+				deposit: Deposit::Refund(28),
+				expected: TestExt {
+					limit_checks: vec![LimitCheck { origin: ALICE, limit: 100, min_leftover: 0 }],
+					charges: vec![
+						Charge {
+							origin: ALICE,
+							contract: CHARLIE,
+							amount: Deposit::Refund(10),
+							state: ContractState::Alive,
+						},
+						Charge {
+							origin: ALICE,
+							contract: CHARLIE,
+							amount: Deposit::Refund(20),
+							state: ContractState::Alive,
+						},
+						Charge {
+							origin: ALICE,
+							contract: BOB,
+							amount: Deposit::Charge(2),
+							state: ContractState::Alive,
+						},
+					],
+				},
+			},
+			ChargingTestCase {
+				origin: Origin::<Test>::Root,
+				deposit: Deposit::Charge(0),
+				expected: TestExt { limit_checks: vec![], charges: vec![] },
+			},
+		];
+
+		for test_case in test_cases {
+			clear_ext();
+
+			let mut meter = TestMeter::new(&test_case.origin, Some(100), 0).unwrap();
+			assert_eq!(meter.available(), 100);
+
+			let mut nested0_info = new_info(StorageInfo {
+				bytes: 100,
+				items: 5,
+				bytes_deposit: 100,
+				items_deposit: 10,
+			});
+			let mut nested0 = meter.nested(BalanceOf::<Test>::zero());
+			nested0.charge(&Diff {
+				bytes_added: 108,
+				bytes_removed: 5,
+				items_added: 1,
+				items_removed: 2,
+			});
+			nested0.charge(&Diff { bytes_removed: 99, ..Default::default() });
+
+			let mut nested1_info = new_info(StorageInfo {
+				bytes: 100,
+				items: 10,
+				bytes_deposit: 100,
+				items_deposit: 20,
+			});
+			let mut nested1 = nested0.nested(BalanceOf::<Test>::zero());
+			nested1.charge(&Diff { items_removed: 5, ..Default::default() });
+			nested0.absorb(nested1, &CHARLIE, Some(&mut nested1_info));
+
+			let mut nested2_info = new_info(StorageInfo {
+				bytes: 100,
+				items: 7,
+				bytes_deposit: 100,
+				items_deposit: 20,
+			});
+			let mut nested2 = nested0.nested(BalanceOf::<Test>::zero());
+			nested2.charge(&Diff { items_removed: 7, ..Default::default() });
+			nested0.absorb(nested2, &CHARLIE, Some(&mut nested2_info));
+
+			nested0.enforce_limit(Some(&mut nested0_info)).unwrap();
+			meter.absorb(nested0, &BOB, Some(&mut nested0_info));
+
+			assert_eq!(meter.try_into_deposit(&test_case.origin).unwrap(), test_case.deposit);
+
+			assert_eq!(nested0_info.extra_deposit(), 112);
+			assert_eq!(nested1_info.extra_deposit(), 110);
+			assert_eq!(nested2_info.extra_deposit(), 100);
+
+			assert_eq!(TestExtTestValue::get(), test_case.expected)
+		}
+	}
+
+	#[test]
+	fn termination_works() {
+		let test_cases = vec![
+			ChargingTestCase {
+				origin: Origin::<Test>::from_account_id(ALICE),
+				deposit: Deposit::Refund(107),
+				expected: TestExt {
+					limit_checks: vec![LimitCheck { origin: ALICE, limit: 1_000, min_leftover: 0 }],
+					charges: vec![
+						Charge {
+							origin: ALICE,
+							contract: CHARLIE,
+							amount: Deposit::Refund(119),
+							state: ContractState::Terminated { beneficiary: CHARLIE },
+						},
+						Charge {
+							origin: ALICE,
+							contract: BOB,
+							amount: Deposit::Charge(12),
+							state: ContractState::Alive,
+						},
+					],
+				},
+			},
+			ChargingTestCase {
+				origin: Origin::<Test>::Root,
+				deposit: Deposit::Charge(0),
+				expected: TestExt { limit_checks: vec![], charges: vec![] },
+			},
+		];
+
+		for test_case in test_cases {
+			clear_ext();
+
+			let mut meter = TestMeter::new(&test_case.origin, Some(1_000), 0).unwrap();
+			assert_eq!(meter.available(), 1_000);
+
+			let mut nested0 = meter.nested(BalanceOf::<Test>::zero());
+			nested0.charge(&Diff {
+				bytes_added: 5,
+				bytes_removed: 1,
+				items_added: 3,
+				items_removed: 1,
+			});
+			nested0.charge(&Diff { items_added: 2, ..Default::default() });
+
+			let mut nested1_info = new_info(StorageInfo {
+				bytes: 100,
+				items: 10,
+				bytes_deposit: 100,
+				items_deposit: 20,
+			});
+			let mut nested1 = nested0.nested(BalanceOf::<Test>::zero());
+			nested1.charge(&Diff { items_removed: 5, ..Default::default() });
+			nested1.charge(&Diff { bytes_added: 20, ..Default::default() });
+			nested1.terminate(&nested1_info, CHARLIE);
+			nested0.enforce_limit(Some(&mut nested1_info)).unwrap();
+			nested0.absorb(nested1, &CHARLIE, None);
+
+			meter.absorb(nested0, &BOB, None);
+			assert_eq!(meter.try_into_deposit(&test_case.origin).unwrap(), test_case.deposit);
+
+			assert_eq!(TestExtTestValue::get(), test_case.expected)
+		}
+	}
+}
diff --git a/substrate/frame/contracts/src/tests.rs b/substrate/frame/contracts/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8cc6d00b3d45d726b445210c1a20d643464dc2a3
--- /dev/null
+++ b/substrate/frame/contracts/src/tests.rs
@@ -0,0 +1,5893 @@
+// 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.
+
+mod pallet_dummy;
+mod test_debug;
+
+use self::{
+	test_debug::TestDebug,
+	test_utils::{ensure_stored, expected_deposit, hash},
+};
+use crate::{
+	self as pallet_contracts,
+	chain_extension::{
+		ChainExtension, Environment, Ext, InitState, RegisteredChainExtension,
+		Result as ExtensionResult, RetVal, ReturnFlags, SysConfig,
+	},
+	exec::{Frame, Key},
+	migration::codegen::LATEST_MIGRATION_VERSION,
+	storage::DeletionQueueManager,
+	tests::test_utils::{get_contract, get_contract_checked},
+	wasm::{Determinism, ReturnCode as RuntimeReturnCode},
+	weights::WeightInfo,
+	BalanceOf, Code, CodeHash, CodeInfoOf, CollectEvents, Config, ContractInfo, ContractInfoOf,
+	DebugInfo, DefaultAddressGenerator, DeletionQueueCounter, Error, HoldReason,
+	MigrationInProgress, Origin, Pallet, PristineCode, Schedule,
+};
+use assert_matches::assert_matches;
+use codec::Encode;
+use frame_support::{
+	assert_err, assert_err_ignore_postinfo, assert_err_with_weight, assert_noop, assert_ok,
+	dispatch::{DispatchError, DispatchErrorWithPostInfo, PostDispatchInfo},
+	parameter_types,
+	storage::child,
+	traits::{
+		fungible::{BalancedHold, Inspect, Mutate, MutateHold},
+		tokens::Preservation,
+		ConstU32, ConstU64, Contains, OnIdle, OnInitialize, StorageVersion,
+	},
+	weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight},
+};
+use frame_system::{EventRecord, Phase};
+use pallet_contracts_primitives::CodeUploadReturnValue;
+use pretty_assertions::{assert_eq, assert_ne};
+use sp_core::ByteArray;
+use sp_io::hashing::blake2_256;
+use sp_keystore::{testing::MemoryKeystore, KeystoreExt};
+use sp_runtime::{
+	testing::H256,
+	traits::{BlakeTwo256, Convert, Hash, IdentityLookup},
+	AccountId32, BuildStorage, Perbill, TokenError,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+		Randomness: pallet_insecure_randomness_collective_flip::{Pallet, Storage},
+		Utility: pallet_utility::{Pallet, Call, Storage, Event},
+		Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>, HoldReason},
+		Proxy: pallet_proxy::{Pallet, Call, Storage, Event<T>},
+		Dummy: pallet_dummy
+	}
+);
+
+macro_rules! assert_return_code {
+	( $x:expr , $y:expr $(,)? ) => {{
+		assert_eq!(u32::from_le_bytes($x.data[..].try_into().unwrap()), $y as u32);
+	}};
+}
+
+macro_rules! assert_refcount {
+	( $code_hash:expr , $should:expr $(,)? ) => {{
+		let is = crate::CodeInfoOf::<Test>::get($code_hash).map(|m| m.refcount()).unwrap();
+		assert_eq!(is, $should);
+	}};
+}
+
+pub mod test_utils {
+
+	use super::{Contracts, DepositPerByte, DepositPerItem, Hash, SysConfig, Test};
+	use crate::{
+		exec::AccountIdOf, BalanceOf, CodeHash, CodeInfo, CodeInfoOf, Config, ContractInfo,
+		ContractInfoOf, Nonce, PristineCode,
+	};
+	use codec::{Encode, MaxEncodedLen};
+	use frame_support::traits::fungible::{InspectHold, Mutate};
+
+	pub fn place_contract(address: &AccountIdOf<Test>, code_hash: CodeHash<Test>) {
+		let nonce = <Nonce<Test>>::mutate(|counter| {
+			*counter += 1;
+			*counter
+		});
+		set_balance(address, Contracts::min_balance() * 10);
+		<CodeInfoOf<Test>>::insert(code_hash, CodeInfo::new(address.clone()));
+		let contract = <ContractInfo<Test>>::new(&address, nonce, code_hash).unwrap();
+		<ContractInfoOf<Test>>::insert(address, contract);
+	}
+	pub fn set_balance(who: &AccountIdOf<Test>, amount: u64) {
+		let _ = <Test as Config>::Currency::set_balance(who, amount);
+	}
+	pub fn get_balance(who: &AccountIdOf<Test>) -> u64 {
+		<Test as Config>::Currency::free_balance(who)
+	}
+	pub fn get_balance_on_hold(
+		reason: &<Test as Config>::RuntimeHoldReason,
+		who: &AccountIdOf<Test>,
+	) -> u64 {
+		<Test as Config>::Currency::balance_on_hold(reason.into(), who)
+	}
+	pub fn get_contract(addr: &AccountIdOf<Test>) -> ContractInfo<Test> {
+		get_contract_checked(addr).unwrap()
+	}
+	pub fn get_contract_checked(addr: &AccountIdOf<Test>) -> Option<ContractInfo<Test>> {
+		ContractInfoOf::<Test>::get(addr)
+	}
+	pub fn get_code_deposit(code_hash: &CodeHash<Test>) -> BalanceOf<Test> {
+		crate::CodeInfoOf::<Test>::get(code_hash).unwrap().deposit()
+	}
+	pub fn contract_info_storage_deposit(
+		addr: &<Test as frame_system::Config>::AccountId,
+	) -> BalanceOf<Test> {
+		let contract_info = self::get_contract(&addr);
+		let info_size = contract_info.encoded_size() as u64;
+		DepositPerByte::get()
+			.saturating_mul(info_size)
+			.saturating_add(DepositPerItem::get())
+	}
+	pub fn hash<S: Encode>(s: &S) -> <<Test as SysConfig>::Hashing as Hash>::Output {
+		<<Test as SysConfig>::Hashing as Hash>::hash_of(s)
+	}
+	pub fn expected_deposit(code_len: usize) -> u64 {
+		// For code_info, the deposit for max_encoded_len is taken.
+		let code_info_len = CodeInfo::<Test>::max_encoded_len() as u64;
+		// Calculate deposit to be reserved.
+		// We add 2 storage items: one for code, other for code_info
+		DepositPerByte::get().saturating_mul(code_len as u64 + code_info_len) +
+			DepositPerItem::get().saturating_mul(2)
+	}
+	pub fn ensure_stored(code_hash: CodeHash<Test>) -> usize {
+		// Assert that code_info is stored
+		assert!(CodeInfoOf::<Test>::contains_key(&code_hash));
+		// Assert that contract code is stored, and get its size.
+		PristineCode::<Test>::try_get(&code_hash).unwrap().len()
+	}
+}
+
+impl Test {
+	pub fn set_unstable_interface(unstable_interface: bool) {
+		UNSTABLE_INTERFACE.with(|v| *v.borrow_mut() = unstable_interface);
+	}
+}
+
+parameter_types! {
+	static TestExtensionTestValue: TestExtension = Default::default();
+}
+
+#[derive(Clone)]
+pub struct TestExtension {
+	enabled: bool,
+	last_seen_buffer: Vec<u8>,
+	last_seen_inputs: (u32, u32, u32, u32),
+}
+
+#[derive(Default)]
+pub struct RevertingExtension;
+
+#[derive(Default)]
+pub struct DisabledExtension;
+
+#[derive(Default)]
+pub struct TempStorageExtension {
+	storage: u32,
+}
+
+impl TestExtension {
+	fn disable() {
+		TestExtensionTestValue::mutate(|e| e.enabled = false)
+	}
+
+	fn last_seen_buffer() -> Vec<u8> {
+		TestExtensionTestValue::get().last_seen_buffer.clone()
+	}
+
+	fn last_seen_inputs() -> (u32, u32, u32, u32) {
+		TestExtensionTestValue::get().last_seen_inputs
+	}
+}
+
+impl Default for TestExtension {
+	fn default() -> Self {
+		Self { enabled: true, last_seen_buffer: vec![], last_seen_inputs: (0, 0, 0, 0) }
+	}
+}
+
+impl ChainExtension<Test> for TestExtension {
+	fn call<E>(&mut self, env: Environment<E, InitState>) -> ExtensionResult<RetVal>
+	where
+		E: Ext<T = Test>,
+	{
+		use codec::Decode;
+
+		let func_id = env.func_id();
+		let id = env.ext_id() as u32 | func_id as u32;
+		match func_id {
+			0 => {
+				let mut env = env.buf_in_buf_out();
+				let input = env.read(8)?;
+				env.write(&input, false, None)?;
+				TestExtensionTestValue::mutate(|e| e.last_seen_buffer = input);
+				Ok(RetVal::Converging(id))
+			},
+			1 => {
+				let env = env.only_in();
+				TestExtensionTestValue::mutate(|e| {
+					e.last_seen_inputs = (env.val0(), env.val1(), env.val2(), env.val3())
+				});
+				Ok(RetVal::Converging(id))
+			},
+			2 => {
+				let mut env = env.buf_in_buf_out();
+				let mut enc = &env.read(9)?[4..8];
+				let weight = Weight::from_parts(
+					u32::decode(&mut enc).map_err(|_| Error::<Test>::ContractTrapped)?.into(),
+					0,
+				);
+				env.charge_weight(weight)?;
+				Ok(RetVal::Converging(id))
+			},
+			3 => Ok(RetVal::Diverging { flags: ReturnFlags::REVERT, data: vec![42, 99] }),
+			_ => {
+				panic!("Passed unknown id to test chain extension: {}", func_id);
+			},
+		}
+	}
+
+	fn enabled() -> bool {
+		TestExtensionTestValue::get().enabled
+	}
+}
+
+impl RegisteredChainExtension<Test> for TestExtension {
+	const ID: u16 = 0;
+}
+
+impl ChainExtension<Test> for RevertingExtension {
+	fn call<E>(&mut self, _env: Environment<E, InitState>) -> ExtensionResult<RetVal>
+	where
+		E: Ext<T = Test>,
+	{
+		Ok(RetVal::Diverging { flags: ReturnFlags::REVERT, data: vec![0x4B, 0x1D] })
+	}
+
+	fn enabled() -> bool {
+		TestExtensionTestValue::get().enabled
+	}
+}
+
+impl RegisteredChainExtension<Test> for RevertingExtension {
+	const ID: u16 = 1;
+}
+
+impl ChainExtension<Test> for DisabledExtension {
+	fn call<E>(&mut self, _env: Environment<E, InitState>) -> ExtensionResult<RetVal>
+	where
+		E: Ext<T = Test>,
+	{
+		panic!("Disabled chain extensions are never called")
+	}
+
+	fn enabled() -> bool {
+		false
+	}
+}
+
+impl RegisteredChainExtension<Test> for DisabledExtension {
+	const ID: u16 = 2;
+}
+
+impl ChainExtension<Test> for TempStorageExtension {
+	fn call<E>(&mut self, env: Environment<E, InitState>) -> ExtensionResult<RetVal>
+	where
+		E: Ext<T = Test>,
+	{
+		let func_id = env.func_id();
+		match func_id {
+			0 => self.storage = 42,
+			1 => assert_eq!(self.storage, 42, "Storage is preserved inside the same call."),
+			2 => {
+				assert_eq!(self.storage, 0, "Storage is different for different calls.");
+				self.storage = 99;
+			},
+			3 => assert_eq!(self.storage, 99, "Storage is preserved inside the same call."),
+			_ => {
+				panic!("Passed unknown id to test chain extension: {}", func_id);
+			},
+		}
+		Ok(RetVal::Converging(0))
+	}
+
+	fn enabled() -> bool {
+		TestExtensionTestValue::get().enabled
+	}
+}
+
+impl RegisteredChainExtension<Test> for TempStorageExtension {
+	const ID: u16 = 3;
+}
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(
+			Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
+		);
+	pub static ExistentialDeposit: u64 = 1;
+}
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = BlockWeights;
+	type BlockLength = ();
+	type DbWeight = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId32;
+	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_insecure_randomness_collective_flip::Config for Test {}
+impl pallet_balances::Config for Test {
+	type MaxLocks = ();
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
+	type Balance = u64;
+	type RuntimeEvent = RuntimeEvent;
+	type DustRemoval = ();
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+	type WeightInfo = ();
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type MaxHolds = ConstU32<1>;
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<1>;
+	type WeightInfo = ();
+}
+impl pallet_utility::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+}
+
+impl pallet_proxy::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type ProxyType = ();
+	type ProxyDepositBase = ConstU64<1>;
+	type ProxyDepositFactor = ConstU64<1>;
+	type MaxProxies = ConstU32<32>;
+	type WeightInfo = ();
+	type MaxPending = ConstU32<32>;
+	type CallHasher = BlakeTwo256;
+	type AnnouncementDepositBase = ConstU64<1>;
+	type AnnouncementDepositFactor = ConstU64<1>;
+}
+
+impl pallet_dummy::Config for Test {}
+
+parameter_types! {
+	pub MySchedule: Schedule<Test> = {
+		let schedule = <Schedule<Test>>::default();
+		schedule
+	};
+	pub static DepositPerByte: BalanceOf<Test> = 1;
+	pub const DepositPerItem: BalanceOf<Test> = 2;
+	pub static MaxDelegateDependencies: u32 = 32;
+
+	pub static CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(0);
+	// We need this one set high enough for running benchmarks.
+	pub static DefaultDepositLimit: BalanceOf<Test> = 10_000_000;
+}
+
+impl Convert<Weight, BalanceOf<Self>> for Test {
+	fn convert(w: Weight) -> BalanceOf<Self> {
+		w.ref_time()
+	}
+}
+
+/// A filter whose filter function can be swapped at runtime.
+pub struct TestFilter;
+
+#[derive(Clone)]
+pub struct Filters {
+	filter: fn(&RuntimeCall) -> bool,
+}
+
+impl Default for Filters {
+	fn default() -> Self {
+		Filters { filter: (|_| true) }
+	}
+}
+
+parameter_types! {
+	static CallFilter: Filters = Default::default();
+}
+
+impl TestFilter {
+	pub fn set_filter(filter: fn(&RuntimeCall) -> bool) {
+		CallFilter::mutate(|fltr| fltr.filter = filter);
+	}
+}
+
+impl Contains<RuntimeCall> for TestFilter {
+	fn contains(call: &RuntimeCall) -> bool {
+		(CallFilter::get().filter)(call)
+	}
+}
+
+parameter_types! {
+	pub static UnstableInterface: bool = true;
+}
+
+impl Config for Test {
+	type Time = Timestamp;
+	type Randomness = Randomness;
+	type Currency = Balances;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type CallFilter = TestFilter;
+	type CallStack = [Frame<Self>; 5];
+	type WeightPrice = Self;
+	type WeightInfo = ();
+	type ChainExtension =
+		(TestExtension, DisabledExtension, RevertingExtension, TempStorageExtension);
+	type Schedule = MySchedule;
+	type DepositPerByte = DepositPerByte;
+	type DepositPerItem = DepositPerItem;
+	type DefaultDepositLimit = DefaultDepositLimit;
+	type AddressGenerator = DefaultAddressGenerator;
+	type MaxCodeLen = ConstU32<{ 123 * 1024 }>;
+	type MaxStorageKeyLen = ConstU32<128>;
+	type UnsafeUnstableInterface = UnstableInterface;
+	type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type Migrations = crate::migration::codegen::BenchMigrations;
+	type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent;
+	type MaxDelegateDependencies = MaxDelegateDependencies;
+	type Debug = TestDebug;
+	type Environment = ();
+}
+
+pub const ALICE: AccountId32 = AccountId32::new([1u8; 32]);
+pub const BOB: AccountId32 = AccountId32::new([2u8; 32]);
+pub const CHARLIE: AccountId32 = AccountId32::new([3u8; 32]);
+pub const DJANGO: AccountId32 = AccountId32::new([4u8; 32]);
+
+pub const GAS_LIMIT: Weight = Weight::from_parts(100_000_000_000, 3 * 1024 * 1024);
+
+pub struct ExtBuilder {
+	existential_deposit: u64,
+	storage_version: Option<StorageVersion>,
+	code_hashes: Vec<CodeHash<Test>>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			existential_deposit: ExistentialDeposit::get(),
+			storage_version: None,
+			code_hashes: vec![],
+		}
+	}
+}
+
+impl ExtBuilder {
+	pub fn existential_deposit(mut self, existential_deposit: u64) -> Self {
+		self.existential_deposit = existential_deposit;
+		self
+	}
+	pub fn with_code_hashes(mut self, code_hashes: Vec<CodeHash<Test>>) -> Self {
+		self.code_hashes = code_hashes;
+		self
+	}
+	pub fn set_associated_consts(&self) {
+		EXISTENTIAL_DEPOSIT.with(|v| *v.borrow_mut() = self.existential_deposit);
+	}
+	pub fn set_storage_version(mut self, version: u16) -> Self {
+		self.storage_version = Some(StorageVersion::new(version));
+		self
+	}
+	pub fn build(self) -> sp_io::TestExternalities {
+		use env_logger::{Builder, Env};
+		let env = Env::new().default_filter_or("runtime=debug");
+		let _ = Builder::from_env(env).is_test(true).try_init();
+		self.set_associated_consts();
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Test> { balances: vec![] }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		let mut ext = sp_io::TestExternalities::new(t);
+		ext.register_extension(KeystoreExt::new(MemoryKeystore::new()));
+		ext.execute_with(|| {
+			use frame_support::traits::OnGenesis;
+
+			Pallet::<Test>::on_genesis();
+			if let Some(storage_version) = self.storage_version {
+				storage_version.put::<Pallet<Test>>();
+			}
+			System::set_block_number(1)
+		});
+		ext.execute_with(|| {
+			for code_hash in self.code_hashes {
+				CodeInfoOf::<Test>::insert(code_hash, crate::CodeInfo::new(ALICE));
+			}
+		});
+		ext
+	}
+}
+
+/// Load a given wasm module represented by a .wat file and returns a wasm binary contents along
+/// with it's hash.
+///
+/// The fixture files are located under the `fixtures/` directory.
+fn compile_module<T>(fixture_name: &str) -> wat::Result<(Vec<u8>, <T::Hashing as Hash>::Output)>
+where
+	T: frame_system::Config,
+{
+	let fixture_path = [
+		// When `CARGO_MANIFEST_DIR` is not set, Rust resolves relative paths from the root folder
+		std::env::var("CARGO_MANIFEST_DIR").as_deref().unwrap_or("frame/contracts"),
+		"/fixtures/",
+		fixture_name,
+		".wat",
+	]
+	.concat();
+	let wasm_binary = wat::parse_file(fixture_path)?;
+	let code_hash = T::Hashing::hash(&wasm_binary);
+	Ok((wasm_binary, code_hash))
+}
+
+fn initialize_block(number: u64) {
+	System::reset_events();
+	System::initialize(&number, &[0u8; 32].into(), &Default::default());
+}
+
+struct ExtensionInput<'a> {
+	extension_id: u16,
+	func_id: u16,
+	extra: &'a [u8],
+}
+
+impl<'a> ExtensionInput<'a> {
+	fn to_vec(&self) -> Vec<u8> {
+		((self.extension_id as u32) << 16 | (self.func_id as u32))
+			.to_le_bytes()
+			.iter()
+			.chain(self.extra)
+			.cloned()
+			.collect()
+	}
+}
+
+impl<'a> From<ExtensionInput<'a>> for Vec<u8> {
+	fn from(input: ExtensionInput) -> Vec<u8> {
+		input.to_vec()
+	}
+}
+
+impl Default for Origin<Test> {
+	fn default() -> Self {
+		Self::Signed(ALICE)
+	}
+}
+// Perform a call to a plain account.
+// The actual transfer fails because we can only call contracts.
+// Then we check that at least the base costs where charged (no runtime gas costs.)
+#[test]
+fn calling_plain_account_fails() {
+	ExtBuilder::default().build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 100_000_000);
+		let base_cost = <<Test as Config>::WeightInfo as WeightInfo>::call();
+
+		assert_eq!(
+			Contracts::call(RuntimeOrigin::signed(ALICE), BOB, 0, GAS_LIMIT, None, Vec::new()),
+			Err(DispatchErrorWithPostInfo {
+				error: Error::<Test>::ContractNotFound.into(),
+				post_info: PostDispatchInfo {
+					actual_weight: Some(base_cost),
+					pays_fee: Default::default(),
+				},
+			})
+		);
+	});
+}
+
+#[test]
+fn migration_on_idle_hooks_works() {
+	// Defines expectations of how many migration steps can be done given the weight limit.
+	let tests = [
+		(Weight::zero(), LATEST_MIGRATION_VERSION - 2),
+		(<Test as Config>::WeightInfo::migrate() + 1.into(), LATEST_MIGRATION_VERSION - 1),
+		(Weight::MAX, LATEST_MIGRATION_VERSION),
+	];
+
+	for (weight, expected_version) in tests {
+		ExtBuilder::default()
+			.set_storage_version(LATEST_MIGRATION_VERSION - 2)
+			.build()
+			.execute_with(|| {
+				MigrationInProgress::<Test>::set(Some(Default::default()));
+				Contracts::on_idle(System::block_number(), weight);
+				assert_eq!(StorageVersion::get::<Pallet<Test>>(), expected_version);
+			});
+	}
+}
+
+#[test]
+fn migration_in_progress_works() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().existential_deposit(1).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		MigrationInProgress::<Test>::set(Some(Default::default()));
+
+		assert_err!(
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				vec![],
+				None,
+				Determinism::Enforced
+			),
+			Error::<Test>::MigrationInProgress,
+		);
+		assert_err!(
+			Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash),
+			Error::<Test>::MigrationInProgress,
+		);
+		assert_err!(
+			Contracts::set_code(RuntimeOrigin::signed(ALICE), BOB.clone(), code_hash),
+			Error::<Test>::MigrationInProgress,
+		);
+		assert_err_ignore_postinfo!(
+			Contracts::call(RuntimeOrigin::signed(ALICE), BOB, 0, GAS_LIMIT, None, vec![],),
+			Error::<Test>::MigrationInProgress,
+		);
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate_with_code(
+				RuntimeOrigin::signed(ALICE),
+				100_000,
+				GAS_LIMIT,
+				None,
+				wasm,
+				vec![],
+				vec![],
+			),
+			Error::<Test>::MigrationInProgress,
+		);
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate(
+				RuntimeOrigin::signed(ALICE),
+				100_000,
+				GAS_LIMIT,
+				None,
+				code_hash,
+				vec![],
+				vec![],
+			),
+			Error::<Test>::MigrationInProgress,
+		);
+	});
+}
+
+#[test]
+fn instantiate_and_call_and_deposit_event() {
+	let (wasm, code_hash) = compile_module::<Test>("event_and_return_on_deploy").unwrap();
+
+	ExtBuilder::default().existential_deposit(1).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let min_balance = Contracts::min_balance();
+		let value = 100;
+
+		// We determine the storage deposit limit after uploading because it depends on ALICEs free
+		// balance which is changed by uploading a module.
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm,
+			None,
+			Determinism::Enforced
+		));
+
+		// Drop previous events
+		initialize_block(2);
+
+		// Check at the end to get hash on error easily
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			value,
+			GAS_LIMIT,
+			None,
+			Code::Existing(code_hash),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		assert!(ContractInfoOf::<Test>::contains_key(&addr));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::System(frame_system::Event::NewAccount {
+						account: addr.clone()
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+						account: addr.clone(),
+						free_balance: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: addr.clone(),
+						amount: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: addr.clone(),
+						amount: value,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::ContractEmitted {
+						contract: addr.clone(),
+						data: vec![1, 2, 3, 4]
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Instantiated {
+						deployer: ALICE,
+						contract: addr.clone()
+					}),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndHeld {
+							from: ALICE,
+							to: addr.clone(),
+							amount: test_utils::contract_info_storage_deposit(&addr),
+						}
+					),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn deposit_event_max_value_limit() {
+	let (wasm, _code_hash) = compile_module::<Test>("event_size").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		// Create
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			30_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Call contract with allowed storage value.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT.set_ref_time(GAS_LIMIT.ref_time() * 2), // we are copying a huge buffer,
+			None,
+			<Test as Config>::Schedule::get().limits.payload_len.encode(),
+		));
+
+		// Call contract with too large a storage value.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr,
+				0,
+				GAS_LIMIT,
+				None,
+				(<Test as Config>::Schedule::get().limits.payload_len + 1).encode(),
+			),
+			Error::<Test>::ValueTooLarge,
+		);
+	});
+}
+
+// Fail out of fuel (ref_time weight) in the engine.
+#[test]
+fn run_out_of_fuel_engine() {
+	let (wasm, _code_hash) = compile_module::<Test>("run_out_of_gas").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			100 * min_balance,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Call the contract with a fixed gas limit. It must run out of gas because it just
+		// loops forever.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr, // newly created account
+				0,
+				Weight::from_parts(1_000_000_000_000, u64::MAX),
+				None,
+				vec![],
+			),
+			Error::<Test>::OutOfGas,
+		);
+	});
+}
+
+// Fail out of fuel (ref_time weight) in the host.
+#[test]
+fn run_out_of_fuel_host() {
+	let (code, _hash) = compile_module::<Test>("chain_extension").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let gas_limit = Weight::from_parts(u32::MAX as u64, GAS_LIMIT.proof_size());
+
+		// Use chain extension to charge more ref_time than it is available.
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			gas_limit,
+			None,
+			ExtensionInput { extension_id: 0, func_id: 2, extra: &u32::MAX.encode() }.into(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result;
+		assert_err!(result, <Error<Test>>::OutOfGas);
+	});
+}
+
+#[test]
+fn gas_syncs_work() {
+	let (wasm0, _code_hash) = compile_module::<Test>("seal_input_noop").unwrap();
+	let (wasm1, _code_hash) = compile_module::<Test>("seal_input_once").unwrap();
+	let (wasm2, _code_hash) = compile_module::<Test>("seal_input_twice").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		// Instantiate noop contract.
+		let addr0 = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm0),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Instantiate 1st contract.
+		let addr1 = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm1),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Instantiate 2nd contract.
+		let addr2 = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm2),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let result = Contracts::bare_call(
+			ALICE,
+			addr0,
+			0,
+			GAS_LIMIT,
+			None,
+			1u8.to_le_bytes().to_vec(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_ok!(result.result);
+		let engine_consumed_noop = result.gas_consumed.ref_time();
+
+		let result = Contracts::bare_call(
+			ALICE,
+			addr1,
+			0,
+			GAS_LIMIT,
+			None,
+			1u8.to_le_bytes().to_vec(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		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.input.ref_time();
+		let engine_consumed_once = gas_consumed_once - host_consumed_once - engine_consumed_noop;
+
+		let result = Contracts::bare_call(
+			ALICE,
+			addr2,
+			0,
+			GAS_LIMIT,
+			None,
+			1u8.to_le_bytes().to_vec(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_ok!(result.result);
+		let gas_consumed_twice = result.gas_consumed.ref_time();
+		let host_consumed_twice = host_consumed_once * 2;
+		let engine_consumed_twice = gas_consumed_twice - host_consumed_twice - engine_consumed_noop;
+
+		// Second contract just repeats first contract's instructions twice.
+		// If runtime syncs gas with the engine properly, this should pass.
+		assert_eq!(engine_consumed_twice, engine_consumed_once * 2);
+	});
+}
+
+/// Check that contracts with the same account id have different trie ids.
+/// Check the `Nonce` storage item for more information.
+#[test]
+fn instantiate_unique_trie_id() {
+	let (wasm, code_hash) = compile_module::<Test>("self_destruct").unwrap();
+
+	ExtBuilder::default().existential_deposit(500).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		Contracts::upload_code(RuntimeOrigin::signed(ALICE), wasm, None, Determinism::Enforced)
+			.unwrap();
+
+		// Instantiate the contract and store its trie id for later comparison.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Existing(code_hash),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		let trie_id = get_contract(&addr).trie_id;
+
+		// Try to instantiate it again without termination should yield an error.
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate(
+				RuntimeOrigin::signed(ALICE),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash,
+				vec![],
+				vec![],
+			),
+			<Error<Test>>::DuplicateContract,
+		);
+
+		// Terminate the contract.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+
+		// Re-Instantiate after termination.
+		assert_ok!(Contracts::instantiate(
+			RuntimeOrigin::signed(ALICE),
+			0,
+			GAS_LIMIT,
+			None,
+			code_hash,
+			vec![],
+			vec![],
+		));
+
+		// Trie ids shouldn't match or we might have a collision
+		assert_ne!(trie_id, get_contract(&addr).trie_id);
+	});
+}
+
+#[test]
+fn storage_max_value_limit() {
+	let (wasm, _code_hash) = compile_module::<Test>("storage_size").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		// Create
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			30_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		get_contract(&addr);
+
+		// Call contract with allowed storage value.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT.set_ref_time(GAS_LIMIT.ref_time() * 2), // we are copying a huge buffer
+			None,
+			<Test as Config>::Schedule::get().limits.payload_len.encode(),
+		));
+
+		// Call contract with too large a storage value.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr,
+				0,
+				GAS_LIMIT,
+				None,
+				(<Test as Config>::Schedule::get().limits.payload_len + 1).encode(),
+			),
+			Error::<Test>::ValueTooLarge,
+		);
+	});
+}
+
+#[test]
+fn deploy_and_call_other_contract() {
+	let (caller_wasm, _caller_code_hash) = compile_module::<Test>("caller_contract").unwrap();
+	let (callee_wasm, callee_code_hash) = compile_module::<Test>("return_with_data").unwrap();
+
+	ExtBuilder::default().existential_deposit(1).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+
+		// Create
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let caller_addr = Contracts::bare_instantiate(
+			ALICE,
+			100_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		Contracts::bare_upload_code(ALICE, callee_wasm, None, Determinism::Enforced).unwrap();
+
+		let callee_addr = Contracts::contract_address(
+			&caller_addr,
+			&callee_code_hash,
+			&[0, 1, 34, 51, 68, 85, 102, 119], // hard coded in wasm
+			&[],
+		);
+
+		// Drop previous events
+		initialize_block(2);
+
+		// Call BOB contract, which attempts to instantiate and call the callee contract and
+		// makes various assertions on the results from those calls.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			caller_addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			callee_code_hash.as_ref().to_vec(),
+		));
+
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::System(frame_system::Event::NewAccount {
+						account: callee_addr.clone()
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+						account: callee_addr.clone(),
+						free_balance: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: callee_addr.clone(),
+						amount: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: caller_addr.clone(),
+						to: callee_addr.clone(),
+						amount: 32768 // hardcoded in wasm
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Instantiated {
+						deployer: caller_addr.clone(),
+						contract: callee_addr.clone(),
+					}),
+					topics: vec![hash(&caller_addr), hash(&callee_addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: caller_addr.clone(),
+						to: callee_addr.clone(),
+						amount: 32768,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(caller_addr.clone()),
+						contract: callee_addr.clone(),
+					}),
+					topics: vec![
+						hash(&Origin::<Test>::from_account_id(caller_addr.clone())),
+						hash(&callee_addr)
+					],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(ALICE),
+						contract: caller_addr.clone(),
+					}),
+					topics: vec![hash(&Origin::<Test>::from_account_id(ALICE)), hash(&caller_addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndHeld {
+							from: ALICE,
+							to: callee_addr.clone(),
+							amount: test_utils::contract_info_storage_deposit(&callee_addr),
+						}
+					),
+					topics: vec![hash(&ALICE), hash(&callee_addr)],
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn delegate_call() {
+	let (caller_wasm, _caller_code_hash) = compile_module::<Test>("delegate_call").unwrap();
+	let (callee_wasm, callee_code_hash) = compile_module::<Test>("delegate_call_lib").unwrap();
+
+	ExtBuilder::default().existential_deposit(500).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate the 'caller'
+		let caller_addr = Contracts::bare_instantiate(
+			ALICE,
+			300_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		// Only upload 'callee' code
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			callee_wasm,
+			Some(codec::Compact(100_000)),
+			Determinism::Enforced,
+		));
+
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			caller_addr.clone(),
+			1337,
+			GAS_LIMIT,
+			None,
+			callee_code_hash.as_ref().to_vec(),
+		));
+	});
+}
+
+#[test]
+fn transfer_expendable_cannot_kill_account() {
+	let (wasm, _code_hash) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			1_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Check that the BOB contract has been instantiated.
+		get_contract(&addr);
+
+		let total_balance = <Test as Config>::Currency::total_balance(&addr);
+
+		assert_eq!(
+			test_utils::get_balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr),
+			test_utils::contract_info_storage_deposit(&addr)
+		);
+
+		// Some ot the total balance is held, so it can't be transferred.
+		assert_err!(
+			<<Test as Config>::Currency as Mutate<AccountId32>>::transfer(
+				&addr,
+				&ALICE,
+				total_balance,
+				Preservation::Expendable,
+			),
+			TokenError::FundsUnavailable,
+		);
+
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), total_balance);
+	});
+}
+
+#[test]
+fn cannot_self_destruct_through_draning() {
+	let (wasm, _code_hash) = compile_module::<Test>("drain").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let value = 1_000;
+		let min_balance = Contracts::min_balance();
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			value,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Check that the BOB contract has been instantiated.
+		get_contract(&addr);
+
+		// Call BOB which makes it send all funds to the zero address
+		// The contract code asserts that the transfer fails with the correct error code
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+
+		// Make sure the account wasn't remove by sending all free balance away.
+		assert_eq!(
+			<Test as Config>::Currency::total_balance(&addr),
+			value + test_utils::contract_info_storage_deposit(&addr) + min_balance,
+		);
+	});
+}
+
+#[test]
+fn cannot_self_destruct_through_storage_refund_after_price_change() {
+	let (wasm, _code_hash) = 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);
+		let min_balance = Contracts::min_balance();
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info_deposit = test_utils::contract_info_storage_deposit(&addr);
+
+		// Check that the contract has been instantiated and has the minimum balance
+		assert_eq!(get_contract(&addr).total_deposit(), info_deposit);
+		assert_eq!(get_contract(&addr).extra_deposit(), 0);
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), info_deposit + min_balance);
+
+		// Create 100 bytes of storage with a price of per byte and a single storage item of price 2
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			100u32.to_le_bytes().to_vec()
+		));
+		assert_eq!(get_contract(&addr).total_deposit(), info_deposit + 102);
+
+		// Increase the byte price and trigger a refund. This should not have any influence because
+		// the removal is pro rata and exactly those 100 bytes should have been removed.
+		DEPOSIT_PER_BYTE.with(|c| *c.borrow_mut() = 500);
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			0u32.to_le_bytes().to_vec()
+		));
+
+		// Make sure the account wasn't removed by the refund
+		assert_eq!(
+			<Test as Config>::Currency::total_balance(&addr),
+			get_contract(&addr).total_deposit() + min_balance,
+		);
+		assert_eq!(get_contract(&addr).extra_deposit(), 2);
+	});
+}
+
+#[test]
+fn cannot_self_destruct_while_live() {
+	let (wasm, _code_hash) = compile_module::<Test>("self_destruct").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			100_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Check that the BOB contract has been instantiated.
+		get_contract(&addr);
+
+		// Call BOB with input data, forcing it make a recursive call to itself to
+		// self-destruct, resulting in a trap.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				vec![0],
+			),
+			Error::<Test>::ContractTrapped,
+		);
+
+		// Check that BOB is still there.
+		get_contract(&addr);
+	});
+}
+
+#[test]
+fn self_destruct_works() {
+	let (wasm, code_hash) = compile_module::<Test>("self_destruct").unwrap();
+	ExtBuilder::default().existential_deposit(1_000).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let _ = <Test as Config>::Currency::set_balance(&DJANGO, 1_000_000);
+		let min_balance = Contracts::min_balance();
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			100_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Check that the BOB contract has been instantiated.
+		let _ = get_contract(&addr);
+
+		let info_deposit = test_utils::contract_info_storage_deposit(&addr);
+
+		// Drop all previous events
+		initialize_block(2);
+
+		// Call BOB without input data which triggers termination.
+		assert_matches!(
+			Contracts::call(RuntimeOrigin::signed(ALICE), addr.clone(), 0, GAS_LIMIT, None, vec![],),
+			Ok(_)
+		);
+
+		// Check that code is still there but refcount dropped to zero.
+		assert_refcount!(&code_hash, 0);
+
+		// Check that account is gone
+		assert!(get_contract_checked(&addr).is_none());
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), 0);
+
+		// Check that the beneficiary (django) got remaining balance.
+		assert_eq!(
+			<Test as Config>::Currency::free_balance(DJANGO),
+			1_000_000 + 100_000 + min_balance
+		);
+
+		// Check that the Alice is missing Django's benefit. Within ALICE's total balance there's
+		// also the code upload deposit held.
+		assert_eq!(
+			<Test as Config>::Currency::total_balance(&ALICE),
+			1_000_000 - (100_000 + min_balance)
+		);
+
+		pretty_assertions::assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Terminated {
+						contract: addr.clone(),
+						beneficiary: DJANGO
+					}),
+					topics: vec![hash(&addr), hash(&DJANGO)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(ALICE),
+						contract: addr.clone(),
+					}),
+					topics: vec![hash(&Origin::<Test>::from_account_id(ALICE)), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndReleased {
+							from: addr.clone(),
+							to: ALICE,
+							amount: info_deposit,
+						}
+					),
+					topics: vec![hash(&addr), hash(&ALICE)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::System(frame_system::Event::KilledAccount {
+						account: addr.clone()
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: addr.clone(),
+						to: DJANGO,
+						amount: 100_000 + min_balance,
+					}),
+					topics: vec![],
+				},
+			],
+		);
+	});
+}
+
+// This tests that one contract cannot prevent another from self-destructing by sending it
+// additional funds after it has been drained.
+#[test]
+fn destroy_contract_and_transfer_funds() {
+	let (callee_wasm, callee_code_hash) = compile_module::<Test>("self_destruct").unwrap();
+	let (caller_wasm, _caller_code_hash) = compile_module::<Test>("destroy_and_transfer").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		// Create code hash for bob to instantiate
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		Contracts::bare_upload_code(ALICE, callee_wasm, None, Determinism::Enforced).unwrap();
+
+		// This deploys the BOB contract, which in turn deploys the CHARLIE contract during
+		// construction.
+		let addr_bob = Contracts::bare_instantiate(
+			ALICE,
+			200_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_wasm),
+			callee_code_hash.as_ref().to_vec(),
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Check that the CHARLIE contract has been instantiated.
+		let addr_charlie =
+			Contracts::contract_address(&addr_bob, &callee_code_hash, &[], &[0x47, 0x11]);
+		get_contract(&addr_charlie);
+
+		// Call BOB, which calls CHARLIE, forcing CHARLIE to self-destruct.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr_bob,
+			0,
+			GAS_LIMIT,
+			None,
+			addr_charlie.encode(),
+		));
+
+		// Check that CHARLIE has moved on to the great beyond (ie. died).
+		assert!(get_contract_checked(&addr_charlie).is_none());
+	});
+}
+
+#[test]
+fn cannot_self_destruct_in_constructor() {
+	let (wasm, _) = compile_module::<Test>("self_destructing_constructor").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Fail to instantiate the BOB because the contructor calls seal_terminate.
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate_with_code(
+				RuntimeOrigin::signed(ALICE),
+				100_000,
+				GAS_LIMIT,
+				None,
+				wasm,
+				vec![],
+				vec![],
+			),
+			Error::<Test>::TerminatedInConstructor,
+		);
+	});
+}
+
+#[test]
+fn crypto_hashes() {
+	let (wasm, _code_hash) = compile_module::<Test>("crypto_hashes").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate the CRYPTO_HASHES contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			100_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		// Perform the call.
+		let input = b"_DEAD_BEEF";
+		use sp_io::hashing::*;
+		// Wraps a hash function into a more dynamic form usable for testing.
+		macro_rules! dyn_hash_fn {
+			($name:ident) => {
+				Box::new(|input| $name(input).as_ref().to_vec().into_boxed_slice())
+			};
+		}
+		// All hash functions and their associated output byte lengths.
+		let test_cases: &[(Box<dyn Fn(&[u8]) -> Box<[u8]>>, usize)] = &[
+			(dyn_hash_fn!(sha2_256), 32),
+			(dyn_hash_fn!(keccak_256), 32),
+			(dyn_hash_fn!(blake2_256), 32),
+			(dyn_hash_fn!(blake2_128), 16),
+		];
+		// Test the given hash functions for the input: "_DEAD_BEEF"
+		for (n, (hash_fn, expected_size)) in test_cases.iter().enumerate() {
+			// We offset data in the contract tables by 1.
+			let mut params = vec![(n + 1) as u8];
+			params.extend_from_slice(input);
+			let result = <Pallet<Test>>::bare_call(
+				ALICE,
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				params,
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result
+			.unwrap();
+			assert!(!result.did_revert());
+			let expected = hash_fn(input.as_ref());
+			assert_eq!(&result.data[..*expected_size], &*expected);
+		}
+	})
+}
+
+#[test]
+fn transfer_return_code() {
+	let (wasm, _code_hash) = compile_module::<Test>("transfer_return_code").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Contract has only the minimal balance so any transfer will fail.
+		<Test as Config>::Currency::set_balance(&addr, min_balance);
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::TransferFailed);
+	});
+}
+
+#[test]
+fn call_return_code() {
+	let (caller_code, _caller_hash) = compile_module::<Test>("call_return_code").unwrap();
+	let (callee_code, _callee_hash) = compile_module::<Test>("ok_trap_revert").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let _ = <Test as Config>::Currency::set_balance(&CHARLIE, 1000 * min_balance);
+
+		let addr_bob = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_code),
+			vec![0],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		<Test as Config>::Currency::set_balance(&addr_bob, min_balance);
+
+		// Contract calls into Django which is no valid contract
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_bob.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			AsRef::<[u8]>::as_ref(&DJANGO).to_vec(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::NotCallable);
+
+		let addr_django = Contracts::bare_instantiate(
+			CHARLIE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(callee_code),
+			vec![0],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		<Test as Config>::Currency::set_balance(&addr_django, min_balance);
+
+		// Contract has only the minimal balance so any transfer will fail.
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_bob.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			AsRef::<[u8]>::as_ref(&addr_django)
+				.iter()
+				.chain(&0u32.to_le_bytes())
+				.cloned()
+				.collect(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::TransferFailed);
+
+		// Contract has enough balance but callee reverts because "1" is passed.
+		<Test as Config>::Currency::set_balance(&addr_bob, min_balance + 1000);
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_bob.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			AsRef::<[u8]>::as_ref(&addr_django)
+				.iter()
+				.chain(&1u32.to_le_bytes())
+				.cloned()
+				.collect(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::CalleeReverted);
+
+		// Contract has enough balance but callee traps because "2" is passed.
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_bob,
+			0,
+			GAS_LIMIT,
+			None,
+			AsRef::<[u8]>::as_ref(&addr_django)
+				.iter()
+				.chain(&2u32.to_le_bytes())
+				.cloned()
+				.collect(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::CalleeTrapped);
+	});
+}
+
+#[test]
+fn instantiate_return_code() {
+	let (caller_code, _caller_hash) = compile_module::<Test>("instantiate_return_code").unwrap();
+	let (callee_code, callee_hash) = compile_module::<Test>("ok_trap_revert").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let _ = <Test as Config>::Currency::set_balance(&CHARLIE, 1000 * min_balance);
+		let callee_hash = callee_hash.as_ref().to_vec();
+
+		assert_ok!(Contracts::instantiate_with_code(
+			RuntimeOrigin::signed(ALICE),
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			callee_code,
+			vec![],
+			vec![],
+		));
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Contract has only the minimal balance so any transfer will fail.
+		<Test as Config>::Currency::set_balance(&addr, min_balance);
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			callee_hash.clone(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::TransferFailed);
+
+		// Contract has enough balance but the passed code hash is invalid
+		<Test as Config>::Currency::set_balance(&addr, min_balance + 10_000);
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![0; 33],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::CodeNotFound);
+
+		// Contract has enough balance but callee reverts because "1" is passed.
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			callee_hash.iter().chain(&1u32.to_le_bytes()).cloned().collect(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::CalleeReverted);
+
+		// Contract has enough balance but callee traps because "2" is passed.
+		let result = Contracts::bare_call(
+			ALICE,
+			addr,
+			0,
+			GAS_LIMIT,
+			None,
+			callee_hash.iter().chain(&2u32.to_le_bytes()).cloned().collect(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, RuntimeReturnCode::CalleeTrapped);
+	});
+}
+
+#[test]
+fn disabled_chain_extension_wont_deploy() {
+	let (code, _hash) = compile_module::<Test>("chain_extension").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		TestExtension::disable();
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate_with_code(
+				RuntimeOrigin::signed(ALICE),
+				3 * min_balance,
+				GAS_LIMIT,
+				None,
+				code,
+				vec![],
+				vec![],
+			),
+			<Error<Test>>::CodeRejected,
+		);
+	});
+}
+
+#[test]
+fn disabled_chain_extension_errors_on_call() {
+	let (code, _hash) = compile_module::<Test>("chain_extension").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		TestExtension::disable();
+		assert_err_ignore_postinfo!(
+			Contracts::call(RuntimeOrigin::signed(ALICE), addr.clone(), 0, GAS_LIMIT, None, vec![],),
+			Error::<Test>::CodeRejected,
+		);
+	});
+}
+
+#[test]
+fn chain_extension_works() {
+	let (code, _hash) = compile_module::<Test>("chain_extension").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// 0 = read input buffer and pass it through as output
+		let input: Vec<u8> = ExtensionInput { extension_id: 0, func_id: 0, extra: &[99] }.into();
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			input.clone(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_eq!(TestExtension::last_seen_buffer(), input);
+		assert_eq!(result.result.unwrap().data, input);
+
+		// 1 = treat inputs as integer primitives and store the supplied integers
+		Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			ExtensionInput { extension_id: 0, func_id: 1, extra: &[] }.into(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		// those values passed in the fixture
+		assert_eq!(TestExtension::last_seen_inputs(), (4, 4, 16, 12));
+
+		// 2 = charge some extra weight (amount supplied in the fifth byte)
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			ExtensionInput { extension_id: 0, func_id: 2, extra: &0u32.encode() }.into(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_ok!(result.result);
+		let gas_consumed = result.gas_consumed;
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			ExtensionInput { extension_id: 0, func_id: 2, extra: &42u32.encode() }.into(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_ok!(result.result);
+		assert_eq!(result.gas_consumed.ref_time(), gas_consumed.ref_time() + 42);
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			ExtensionInput { extension_id: 0, func_id: 2, extra: &95u32.encode() }.into(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_ok!(result.result);
+		assert_eq!(result.gas_consumed.ref_time(), gas_consumed.ref_time() + 95);
+
+		// 3 = diverging chain extension call that sets flags to 0x1 and returns a fixed buffer
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			ExtensionInput { extension_id: 0, func_id: 3, extra: &[] }.into(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_eq!(result.flags, ReturnFlags::REVERT);
+		assert_eq!(result.data, vec![42, 99]);
+
+		// diverging to second chain extension that sets flags to 0x1 and returns a fixed buffer
+		// We set the MSB part to 1 (instead of 0) which routes the request into the second
+		// extension
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			ExtensionInput { extension_id: 1, func_id: 0, extra: &[] }.into(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_eq!(result.flags, ReturnFlags::REVERT);
+		assert_eq!(result.data, vec![0x4B, 0x1D]);
+
+		// Diverging to third chain extension that is disabled
+		// We set the MSB part to 2 (instead of 0) which routes the request into the third extension
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				ExtensionInput { extension_id: 2, func_id: 0, extra: &[] }.into(),
+			),
+			Error::<Test>::NoChainExtension,
+		);
+	});
+}
+
+#[test]
+fn chain_extension_temp_storage_works() {
+	let (code, _hash) = compile_module::<Test>("chain_extension_temp_storage").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Call func 0 and func 1 back to back.
+		let stop_recursion = 0u8;
+		let mut input: Vec<u8> = ExtensionInput { extension_id: 3, func_id: 0, extra: &[] }.into();
+		input.extend_from_slice(
+			ExtensionInput { extension_id: 3, func_id: 1, extra: &[stop_recursion] }
+				.to_vec()
+				.as_ref(),
+		);
+
+		assert_ok!(
+			Contracts::bare_call(
+				ALICE,
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				input.clone(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result
+		);
+	})
+}
+
+#[test]
+fn lazy_removal_works() {
+	let (code, _hash) = compile_module::<Test>("self_destruct").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info = get_contract(&addr);
+		let trie = &info.child_trie_info();
+
+		// Put value into the contracts child trie
+		child::put(trie, &[99], &42);
+
+		// Terminate the contract
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+
+		// Contract info should be gone
+		assert!(!<ContractInfoOf::<Test>>::contains_key(&addr));
+
+		// But value should be still there as the lazy removal did not run, yet.
+		assert_matches!(child::get(trie, &[99]), Some(42));
+
+		// Run the lazy removal
+		Contracts::on_idle(System::block_number(), Weight::MAX);
+
+		// Value should be gone now
+		assert_matches!(child::get::<i32>(trie, &[99]), None);
+	});
+}
+
+#[test]
+fn lazy_batch_removal_works() {
+	let (code, _hash) = compile_module::<Test>("self_destruct").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let mut tries: Vec<child::ChildInfo> = vec![];
+
+		for i in 0..3u8 {
+			let addr = Contracts::bare_instantiate(
+				ALICE,
+				min_balance * 100,
+				GAS_LIMIT,
+				None,
+				Code::Upload(code.clone()),
+				vec![],
+				vec![i],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			)
+			.result
+			.unwrap()
+			.account_id;
+
+			let info = get_contract(&addr);
+			let trie = &info.child_trie_info();
+
+			// Put value into the contracts child trie
+			child::put(trie, &[99], &42);
+
+			// Terminate the contract. Contract info should be gone, but value should be still there
+			// as the lazy removal did not run, yet.
+			assert_ok!(Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				vec![]
+			));
+
+			assert!(!<ContractInfoOf::<Test>>::contains_key(&addr));
+			assert_matches!(child::get(trie, &[99]), Some(42));
+
+			tries.push(trie.clone())
+		}
+
+		// Run single lazy removal
+		Contracts::on_idle(System::block_number(), Weight::MAX);
+
+		// The single lazy removal should have removed all queued tries
+		for trie in tries.iter() {
+			assert_matches!(child::get::<i32>(trie, &[99]), None);
+		}
+	});
+}
+
+#[test]
+fn lazy_removal_partial_remove_works() {
+	let (code, _hash) = compile_module::<Test>("self_destruct").unwrap();
+
+	// We create a contract with some extra keys above the weight limit
+	let extra_keys = 7u32;
+	let weight_limit = Weight::from_parts(5_000_000_000, 0);
+	let (_, max_keys) = ContractInfo::<Test>::deletion_budget(weight_limit);
+	let vals: Vec<_> = (0..max_keys + extra_keys)
+		.map(|i| (blake2_256(&i.encode()), (i as u32), (i as u32).encode()))
+		.collect();
+
+	let mut ext = ExtBuilder::default().existential_deposit(50).build();
+
+	let trie = ext.execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info = get_contract(&addr);
+
+		// Put value into the contracts child trie
+		for val in &vals {
+			info.write(&Key::Fix(val.0), Some(val.2.clone()), None, false).unwrap();
+		}
+		<ContractInfoOf<Test>>::insert(&addr, info.clone());
+
+		// Terminate the contract
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+
+		// Contract info should be gone
+		assert!(!<ContractInfoOf::<Test>>::contains_key(&addr));
+
+		let trie = info.child_trie_info();
+
+		// But value should be still there as the lazy removal did not run, yet.
+		for val in &vals {
+			assert_eq!(child::get::<u32>(&trie, &blake2_256(&val.0)), Some(val.1));
+		}
+
+		trie.clone()
+	});
+
+	// The lazy removal limit only applies to the backend but not to the overlay.
+	// This commits all keys from the overlay to the backend.
+	ext.commit_all().unwrap();
+
+	ext.execute_with(|| {
+		// Run the lazy removal
+		let weight_used = ContractInfo::<Test>::process_deletion_queue_batch(weight_limit);
+
+		// Weight should be exhausted because we could not even delete all keys
+		assert_eq!(weight_used, weight_limit);
+
+		let mut num_deleted = 0u32;
+		let mut num_remaining = 0u32;
+
+		for val in &vals {
+			match child::get::<u32>(&trie, &blake2_256(&val.0)) {
+				None => num_deleted += 1,
+				Some(x) if x == val.1 => num_remaining += 1,
+				Some(_) => panic!("Unexpected value in contract storage"),
+			}
+		}
+
+		// All but one key is removed
+		assert_eq!(num_deleted + num_remaining, vals.len() as u32);
+		assert_eq!(num_deleted, max_keys);
+		assert_eq!(num_remaining, extra_keys);
+	});
+}
+
+#[test]
+fn lazy_removal_does_no_run_on_low_remaining_weight() {
+	let (code, _hash) = compile_module::<Test>("self_destruct").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info = get_contract(&addr);
+		let trie = &info.child_trie_info();
+
+		// Put value into the contracts child trie
+		child::put(trie, &[99], &42);
+
+		// Terminate the contract
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+
+		// Contract info should be gone
+		assert!(!<ContractInfoOf::<Test>>::contains_key(&addr));
+
+		// But value should be still there as the lazy removal did not run, yet.
+		assert_matches!(child::get(trie, &[99]), Some(42));
+
+		// Assign a remaining weight which is too low for a successful deletion of the contract
+		let low_remaining_weight =
+			<<Test as Config>::WeightInfo as WeightInfo>::on_process_deletion_queue_batch();
+
+		// Run the lazy removal
+		Contracts::on_idle(System::block_number(), low_remaining_weight);
+
+		// Value should still be there, since remaining weight was too low for removal
+		assert_matches!(child::get::<i32>(trie, &[99]), Some(42));
+
+		// Run the lazy removal while deletion_queue is not full
+		Contracts::on_initialize(System::block_number());
+
+		// Value should still be there, since deletion_queue was not full
+		assert_matches!(child::get::<i32>(trie, &[99]), Some(42));
+
+		// Run on_idle with max remaining weight, this should remove the value
+		Contracts::on_idle(System::block_number(), Weight::MAX);
+
+		// Value should be gone
+		assert_matches!(child::get::<i32>(trie, &[99]), None);
+	});
+}
+
+#[test]
+fn lazy_removal_does_not_use_all_weight() {
+	let (code, _hash) = compile_module::<Test>("self_destruct").unwrap();
+
+	let weight_limit = Weight::from_parts(5_000_000_000, 100 * 1024);
+	let mut ext = ExtBuilder::default().existential_deposit(50).build();
+
+	let (trie, vals, weight_per_key) = ext.execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(code),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info = get_contract(&addr);
+		let (weight_per_key, max_keys) = ContractInfo::<Test>::deletion_budget(weight_limit);
+
+		// We create a contract with one less storage item than we can remove within the limit
+		let vals: Vec<_> = (0..max_keys - 1)
+			.map(|i| (blake2_256(&i.encode()), (i as u32), (i as u32).encode()))
+			.collect();
+
+		// Put value into the contracts child trie
+		for val in &vals {
+			info.write(&Key::Fix(val.0), Some(val.2.clone()), None, false).unwrap();
+		}
+		<ContractInfoOf<Test>>::insert(&addr, info.clone());
+
+		// Terminate the contract
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+
+		// Contract info should be gone
+		assert!(!<ContractInfoOf::<Test>>::contains_key(&addr));
+
+		let trie = info.child_trie_info();
+
+		// But value should be still there as the lazy removal did not run, yet.
+		for val in &vals {
+			assert_eq!(child::get::<u32>(&trie, &blake2_256(&val.0)), Some(val.1));
+		}
+
+		(trie, vals, weight_per_key)
+	});
+
+	// The lazy removal limit only applies to the backend but not to the overlay.
+	// This commits all keys from the overlay to the backend.
+	ext.commit_all().unwrap();
+
+	ext.execute_with(|| {
+		// Run the lazy removal
+		let weight_used = ContractInfo::<Test>::process_deletion_queue_batch(weight_limit);
+
+		// We have one less key in our trie than our weight limit suffices for
+		assert_eq!(weight_used, weight_limit - weight_per_key);
+
+		// All the keys are removed
+		for val in vals {
+			assert_eq!(child::get::<u32>(&trie, &blake2_256(&val.0)), None);
+		}
+	});
+}
+
+#[test]
+fn deletion_queue_ring_buffer_overflow() {
+	let (code, _hash) = compile_module::<Test>("self_destruct").unwrap();
+	let mut ext = ExtBuilder::default().existential_deposit(50).build();
+
+	// setup the deletion queue with custom counters
+	ext.execute_with(|| {
+		let queue = DeletionQueueManager::from_test_values(u32::MAX - 1, u32::MAX - 1);
+		<DeletionQueueCounter<Test>>::set(queue);
+	});
+
+	// commit the changes to the storage
+	ext.commit_all().unwrap();
+
+	ext.execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let mut tries: Vec<child::ChildInfo> = vec![];
+
+		// add 3 contracts to the deletion queue
+		for i in 0..3u8 {
+			let addr = Contracts::bare_instantiate(
+				ALICE,
+				min_balance * 100,
+				GAS_LIMIT,
+				None,
+				Code::Upload(code.clone()),
+				vec![],
+				vec![i],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			)
+			.result
+			.unwrap()
+			.account_id;
+
+			let info = get_contract(&addr);
+			let trie = &info.child_trie_info();
+
+			// Put value into the contracts child trie
+			child::put(trie, &[99], &42);
+
+			// Terminate the contract. Contract info should be gone, but value should be still
+			// there as the lazy removal did not run, yet.
+			assert_ok!(Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				vec![]
+			));
+
+			assert!(!<ContractInfoOf::<Test>>::contains_key(&addr));
+			assert_matches!(child::get(trie, &[99]), Some(42));
+
+			tries.push(trie.clone())
+		}
+
+		// Run single lazy removal
+		Contracts::on_idle(System::block_number(), Weight::MAX);
+
+		// The single lazy removal should have removed all queued tries
+		for trie in tries.iter() {
+			assert_matches!(child::get::<i32>(trie, &[99]), None);
+		}
+
+		// insert and delete counter values should go from u32::MAX - 1 to 1
+		assert_eq!(<DeletionQueueCounter<Test>>::get().as_test_tuple(), (1, 1));
+	})
+}
+#[test]
+fn refcounter() {
+	let (wasm, code_hash) = compile_module::<Test>("self_destruct").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let min_balance = Contracts::min_balance();
+
+		// Create two contracts with the same code and check that they do in fact share it.
+		let addr0 = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm.clone()),
+			vec![],
+			vec![0],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		let addr1 = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm.clone()),
+			vec![],
+			vec![1],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		assert_refcount!(code_hash, 2);
+
+		// Sharing should also work with the usual instantiate call
+		let addr2 = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Existing(code_hash),
+			vec![],
+			vec![2],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		assert_refcount!(code_hash, 3);
+
+		// Terminating one contract should decrement the refcount
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr0,
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+		assert_refcount!(code_hash, 2);
+
+		// remove another one
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr1,
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+		assert_refcount!(code_hash, 1);
+
+		// Pristine code should still be there
+		PristineCode::<Test>::get(code_hash).unwrap();
+
+		// remove the last contract
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr2,
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+		assert_refcount!(code_hash, 0);
+
+		// refcount is `0` but code should still exists because it needs to be removed manually
+		assert!(crate::PristineCode::<Test>::contains_key(&code_hash));
+	});
+}
+
+#[test]
+fn debug_message_works() {
+	let (wasm, _code_hash) = compile_module::<Test>("debug_message_works").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			30_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		let result = Contracts::bare_call(
+			ALICE,
+			addr,
+			0,
+			GAS_LIMIT,
+			None,
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+
+		assert_matches!(result.result, Ok(_));
+		assert_eq!(std::str::from_utf8(&result.debug_message).unwrap(), "Hello World!");
+	});
+}
+
+#[test]
+fn debug_message_logging_disabled() {
+	let (wasm, _code_hash) = compile_module::<Test>("debug_message_logging_disabled").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			30_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		// disable logging by passing `false`
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_matches!(result.result, Ok(_));
+		// the dispatchables always run without debugging
+		assert_ok!(Contracts::call(RuntimeOrigin::signed(ALICE), addr, 0, GAS_LIMIT, None, vec![]));
+		assert!(result.debug_message.is_empty());
+	});
+}
+
+#[test]
+fn debug_message_invalid_utf8() {
+	let (wasm, _code_hash) = compile_module::<Test>("debug_message_invalid_utf8").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			30_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		let result = Contracts::bare_call(
+			ALICE,
+			addr,
+			0,
+			GAS_LIMIT,
+			None,
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_ok!(result.result);
+		assert!(result.debug_message.is_empty());
+	});
+}
+
+#[test]
+fn gas_estimation_nested_call_fixed_limit() {
+	let (caller_code, _caller_hash) = compile_module::<Test>("call_with_limit").unwrap();
+	let (callee_code, _callee_hash) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr_caller = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_code),
+			vec![],
+			vec![0],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let addr_callee = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(callee_code),
+			vec![],
+			vec![1],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let input: Vec<u8> = AsRef::<[u8]>::as_ref(&addr_callee)
+			.iter()
+			.cloned()
+			.chain((GAS_LIMIT / 5).ref_time().to_le_bytes())
+			.chain((GAS_LIMIT / 5).proof_size().to_le_bytes())
+			.collect();
+
+		// Call in order to determine the gas that is required for this call
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_caller.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			input.clone(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		assert_ok!(&result.result);
+
+		// We have a subcall with a fixed gas limit. This constitutes precharging.
+		assert!(result.gas_required.all_gt(result.gas_consumed));
+
+		// Make the same call using the estimated gas. Should succeed.
+		assert_ok!(
+			Contracts::bare_call(
+				ALICE,
+				addr_caller.clone(),
+				0,
+				result.gas_required,
+				Some(result.storage_deposit.charge_or_zero()),
+				input.clone(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result
+		);
+
+		// Make the same call using proof_size but less than estimated. Should fail with OutOfGas.
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_caller,
+			0,
+			result.gas_required.sub_proof_size(1),
+			Some(result.storage_deposit.charge_or_zero()),
+			input,
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result;
+		assert_err!(result, <Error<Test>>::OutOfGas);
+	});
+}
+
+#[test]
+fn gas_estimation_call_runtime() {
+	use codec::Decode;
+	let (caller_code, _caller_hash) = compile_module::<Test>("call_runtime").unwrap();
+	let (callee_code, _callee_hash) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let _ = <Test as Config>::Currency::set_balance(&CHARLIE, 1000 * min_balance);
+
+		let addr_caller = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_code),
+			vec![],
+			vec![0],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(callee_code),
+			vec![],
+			vec![1],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap();
+
+		// Call something trivial with a huge gas limit so that we can observe the effects
+		// of pre-charging. This should create a difference between consumed and required.
+		let call = RuntimeCall::Dummy(pallet_dummy::Call::overestimate_pre_charge {
+			pre_charge: Weight::from_parts(10_000_000, 0),
+			actual_weight: Weight::from_parts(100, 0),
+		});
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_caller.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			call.encode(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+		// contract encodes the result of the dispatch runtime
+		let outcome = u32::decode(&mut result.result.unwrap().data.as_ref()).unwrap();
+		assert_eq!(outcome, 0);
+		assert!(result.gas_required.ref_time() > result.gas_consumed.ref_time());
+
+		// Make the same call using the required gas. Should succeed.
+		assert_ok!(
+			Contracts::bare_call(
+				ALICE,
+				addr_caller,
+				0,
+				result.gas_required,
+				None,
+				call.encode(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result
+		);
+	});
+}
+
+#[test]
+fn call_runtime_reentrancy_guarded() {
+	let (caller_code, _caller_hash) = compile_module::<Test>("call_runtime").unwrap();
+	let (callee_code, _callee_hash) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+		let _ = <Test as Config>::Currency::set_balance(&CHARLIE, 1000 * min_balance);
+
+		let addr_caller = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_code),
+			vec![],
+			vec![0],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let addr_callee = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(callee_code),
+			vec![],
+			vec![1],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Call pallet_contracts call() dispatchable
+		let call = RuntimeCall::Contracts(crate::Call::call {
+			dest: addr_callee,
+			value: 0,
+			gas_limit: GAS_LIMIT / 3,
+			storage_deposit_limit: None,
+			data: vec![],
+		});
+
+		// Call runtime to re-enter back to contracts engine by
+		// calling dummy contract
+		let result = Contracts::bare_call(
+			ALICE,
+			addr_caller.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			call.encode(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		// Call to runtime should fail because of the re-entrancy guard
+		assert_return_code!(result, RuntimeReturnCode::CallRuntimeFailed);
+	});
+}
+
+#[test]
+fn ecdsa_recover() {
+	let (wasm, _code_hash) = compile_module::<Test>("ecdsa_recover").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate the ecdsa_recover contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			100_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		#[rustfmt::skip]
+		let signature: [u8; 65] = [
+			161, 234, 203,  74, 147, 96,  51, 212,   5, 174, 231,   9, 142,  48, 137, 201,
+			162, 118, 192,  67, 239, 16,  71, 216, 125,  86, 167, 139,  70,   7,  86, 241,
+			 33,  87, 154, 251,  81, 29, 160,   4, 176, 239,  88, 211, 244, 232, 232,  52,
+			211, 234, 100, 115, 230, 47,  80,  44, 152, 166,  62,  50,   8,  13,  86, 175,
+			 28,
+		];
+		#[rustfmt::skip]
+		let message_hash: [u8; 32] = [
+			162, 28, 244, 179, 96, 76, 244, 178, 188,  83, 230, 248, 143, 106,  77, 117,
+			239, 95, 244, 171, 65, 95,  62, 153, 174, 166, 182,  28, 130,  73, 196, 208
+		];
+		#[rustfmt::skip]
+		const EXPECTED_COMPRESSED_PUBLIC_KEY: [u8; 33] = [
+			  2, 121, 190, 102, 126, 249, 220, 187, 172, 85, 160,  98, 149, 206, 135, 11,
+			  7,   2, 155, 252, 219,  45, 206,  40, 217, 89, 242, 129,  91,  22, 248, 23,
+			152,
+		];
+		let mut params = vec![];
+		params.extend_from_slice(&signature);
+		params.extend_from_slice(&message_hash);
+		assert!(params.len() == 65 + 32);
+		let result = <Pallet<Test>>::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			params,
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert!(!result.did_revert());
+		assert_eq!(result.data, EXPECTED_COMPRESSED_PUBLIC_KEY);
+	})
+}
+
+#[test]
+fn bare_instantiate_returns_events() {
+	let (wasm, _code_hash) = compile_module::<Test>("transfer_return_code").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let result = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::UnsafeCollect,
+		);
+
+		let events = result.events.unwrap();
+		assert!(!events.is_empty());
+		assert_eq!(events, System::events());
+	});
+}
+
+#[test]
+fn bare_instantiate_does_not_return_events() {
+	let (wasm, _code_hash) = compile_module::<Test>("transfer_return_code").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let result = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		);
+
+		let events = result.events;
+		assert!(!System::events().is_empty());
+		assert!(events.is_none());
+	});
+}
+
+#[test]
+fn bare_call_returns_events() {
+	let (wasm, _code_hash) = compile_module::<Test>("transfer_return_code").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::UnsafeCollect,
+			Determinism::Enforced,
+		);
+
+		let events = result.events.unwrap();
+		assert_return_code!(&result.result.unwrap(), RuntimeReturnCode::Success);
+		assert!(!events.is_empty());
+		assert_eq!(events, System::events());
+	});
+}
+
+#[test]
+fn bare_call_does_not_return_events() {
+	let (wasm, _code_hash) = compile_module::<Test>("transfer_return_code").unwrap();
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let min_balance = Contracts::min_balance();
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1000 * min_balance);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			min_balance * 100,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+
+		let events = result.events;
+		assert_return_code!(&result.result.unwrap(), RuntimeReturnCode::Success);
+		assert!(!System::events().is_empty());
+		assert!(events.is_none());
+	});
+}
+
+#[test]
+fn sr25519_verify() {
+	let (wasm, _code_hash) = compile_module::<Test>("sr25519_verify").unwrap();
+
+	ExtBuilder::default().existential_deposit(50).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate the sr25519_verify contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			100_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let call_with = |message: &[u8; 11]| {
+			// Alice's signature for "hello world"
+			#[rustfmt::skip]
+			let signature: [u8; 64] = [
+				184, 49, 74, 238, 78, 165, 102, 252, 22, 92, 156, 176, 124, 118, 168, 116, 247,
+				99, 0, 94, 2, 45, 9, 170, 73, 222, 182, 74, 60, 32, 75, 64, 98, 174, 69, 55, 83,
+				85, 180, 98, 208, 75, 231, 57, 205, 62, 4, 105, 26, 136, 172, 17, 123, 99, 90, 255,
+				228, 54, 115, 63, 30, 207, 205, 131,
+			];
+
+			// Alice's public key
+			#[rustfmt::skip]
+			let public_key: [u8; 32] = [
+				212, 53, 147, 199, 21, 253, 211, 28, 97, 20, 26, 189, 4, 169, 159, 214, 130, 44,
+				133, 88, 133, 76, 205, 227, 154, 86, 132, 231, 165, 109, 162, 125,
+			];
+
+			let mut params = vec![];
+			params.extend_from_slice(&signature);
+			params.extend_from_slice(&public_key);
+			params.extend_from_slice(message);
+
+			<Pallet<Test>>::bare_call(
+				ALICE,
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				params,
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result
+			.unwrap()
+		};
+
+		// verification should succeed for "hello world"
+		assert_return_code!(call_with(&b"hello world"), RuntimeReturnCode::Success);
+
+		// verification should fail for other messages
+		assert_return_code!(call_with(&b"hello worlD"), RuntimeReturnCode::Sr25519VerifyFailed);
+	});
+}
+
+#[test]
+fn failed_deposit_charge_should_roll_back_call() {
+	let (wasm_caller, _) = compile_module::<Test>("call_runtime_and_call").unwrap();
+	let (wasm_callee, _) = compile_module::<Test>("store_call").unwrap();
+	const ED: u64 = 200;
+
+	let execute = || {
+		ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+			let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+			// Instantiate both contracts.
+			let addr_caller = Contracts::bare_instantiate(
+				ALICE,
+				0,
+				GAS_LIMIT,
+				None,
+				Code::Upload(wasm_caller.clone()),
+				vec![],
+				vec![],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			)
+			.result
+			.unwrap()
+			.account_id;
+			let addr_callee = Contracts::bare_instantiate(
+				ALICE,
+				0,
+				GAS_LIMIT,
+				None,
+				Code::Upload(wasm_callee.clone()),
+				vec![],
+				vec![],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			)
+			.result
+			.unwrap()
+			.account_id;
+
+			// Give caller proxy access to Alice.
+			assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(ALICE), addr_caller.clone(), (), 0));
+
+			// Create a Proxy call that will attempt to transfer away Alice's balance.
+			let transfer_call =
+				Box::new(RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
+					dest: CHARLIE,
+					value: pallet_balances::Pallet::<Test>::free_balance(&ALICE) - 2 * ED,
+				}));
+
+			// Wrap the transfer call in a proxy call.
+			let transfer_proxy_call = RuntimeCall::Proxy(pallet_proxy::Call::proxy {
+				real: ALICE,
+				force_proxy_type: Some(()),
+				call: transfer_call,
+			});
+
+			let data = (
+				(ED - DepositPerItem::get()) as u32, // storage length
+				addr_callee,
+				transfer_proxy_call,
+			);
+
+			<Pallet<Test>>::call(
+				RuntimeOrigin::signed(ALICE),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				data.encode(),
+			)
+		})
+	};
+
+	// With a low enough deposit per byte, the call should succeed.
+	let result = execute().unwrap();
+
+	// Bump the deposit per byte to a high value to trigger a FundsUnavailable error.
+	DEPOSIT_PER_BYTE.with(|c| *c.borrow_mut() = ED);
+	assert_err_with_weight!(execute(), TokenError::FundsUnavailable, result.actual_weight);
+}
+
+#[test]
+fn upload_code_works() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert!(!PristineCode::<Test>::contains_key(&code_hash));
+
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm,
+			Some(codec::Compact(1_000)),
+			Determinism::Enforced,
+		));
+		// Ensure the contract was stored and get expected deposit amount to be reserved.
+		let deposit_expected = expected_deposit(ensure_stored(code_hash));
+
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Initialization,
+				event: RuntimeEvent::Contracts(crate::Event::CodeStored {
+					code_hash,
+					deposit_held: deposit_expected,
+					uploader: ALICE
+				}),
+				topics: vec![code_hash],
+			},]
+		);
+	});
+}
+
+#[test]
+fn upload_code_limit_too_low() {
+	let (wasm, _code_hash) = compile_module::<Test>("dummy").unwrap();
+	let deposit_expected = expected_deposit(wasm.len());
+	let deposit_insufficient = deposit_expected.saturating_sub(1);
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert_noop!(
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				wasm,
+				Some(codec::Compact(deposit_insufficient)),
+				Determinism::Enforced
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+
+		assert_eq!(System::events(), vec![]);
+	});
+}
+
+#[test]
+fn upload_code_not_enough_balance() {
+	let (wasm, _code_hash) = compile_module::<Test>("dummy").unwrap();
+	let deposit_expected = expected_deposit(wasm.len());
+	let deposit_insufficient = deposit_expected.saturating_sub(1);
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, deposit_insufficient);
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert_noop!(
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				wasm,
+				Some(codec::Compact(1_000)),
+				Determinism::Enforced
+			),
+			<Error<Test>>::StorageDepositNotEnoughFunds,
+		);
+
+		assert_eq!(System::events(), vec![]);
+	});
+}
+
+#[test]
+fn remove_code_works() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm,
+			Some(codec::Compact(1_000)),
+			Determinism::Enforced,
+		));
+		// Ensure the contract was stored and get expected deposit amount to be reserved.
+		let deposit_expected = expected_deposit(ensure_stored(code_hash));
+
+		assert_ok!(Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash));
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::CodeStored {
+						code_hash,
+						deposit_held: deposit_expected,
+						uploader: ALICE
+					}),
+					topics: vec![code_hash],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::CodeRemoved {
+						code_hash,
+						deposit_released: deposit_expected,
+						remover: ALICE
+					}),
+					topics: vec![code_hash],
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn remove_code_wrong_origin() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm,
+			Some(codec::Compact(1_000)),
+			Determinism::Enforced,
+		));
+		// Ensure the contract was stored and get expected deposit amount to be reserved.
+		let deposit_expected = expected_deposit(ensure_stored(code_hash));
+
+		assert_noop!(
+			Contracts::remove_code(RuntimeOrigin::signed(BOB), code_hash),
+			sp_runtime::traits::BadOrigin,
+		);
+
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Initialization,
+				event: RuntimeEvent::Contracts(crate::Event::CodeStored {
+					code_hash,
+					deposit_held: deposit_expected,
+					uploader: ALICE
+				}),
+				topics: vec![code_hash],
+			},]
+		);
+	});
+}
+
+#[test]
+fn remove_code_in_use() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		assert_ok!(Contracts::instantiate_with_code(
+			RuntimeOrigin::signed(ALICE),
+			0,
+			GAS_LIMIT,
+			None,
+			wasm,
+			vec![],
+			vec![],
+		));
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert_noop!(
+			Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash),
+			<Error<Test>>::CodeInUse,
+		);
+
+		assert_eq!(System::events(), vec![]);
+	});
+}
+
+#[test]
+fn remove_code_not_found() {
+	let (_wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert_noop!(
+			Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash),
+			<Error<Test>>::CodeNotFound,
+		);
+
+		assert_eq!(System::events(), vec![]);
+	});
+}
+
+#[test]
+fn instantiate_with_zero_balance_works() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let min_balance = Contracts::min_balance();
+
+		// Drop previous events
+		initialize_block(2);
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Ensure the contract was stored and get expected deposit amount to be reserved.
+		let deposit_expected = expected_deposit(ensure_stored(code_hash));
+
+		// Make sure the account exists even though no free balance was send
+		assert_eq!(<Test as Config>::Currency::free_balance(&addr), min_balance);
+		assert_eq!(
+			<Test as Config>::Currency::total_balance(&addr),
+			min_balance + test_utils::contract_info_storage_deposit(&addr)
+		);
+
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::CodeStored {
+						code_hash,
+						deposit_held: deposit_expected,
+						uploader: ALICE
+					}),
+					topics: vec![code_hash],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::System(frame_system::Event::NewAccount {
+						account: addr.clone(),
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+						account: addr.clone(),
+						free_balance: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: addr.clone(),
+						amount: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Instantiated {
+						deployer: ALICE,
+						contract: addr.clone(),
+					}),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndHeld {
+							from: ALICE,
+							to: addr.clone(),
+							amount: test_utils::contract_info_storage_deposit(&addr),
+						}
+					),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn instantiate_with_below_existential_deposit_works() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let min_balance = Contracts::min_balance();
+		let value = 50;
+
+		// Drop previous events
+		initialize_block(2);
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			value,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Ensure the contract was stored and get expected deposit amount to be reserved.
+		let deposit_expected = expected_deposit(ensure_stored(code_hash));
+		// Make sure the account exists even though not enough free balance was send
+		assert_eq!(<Test as Config>::Currency::free_balance(&addr), min_balance + value);
+		assert_eq!(
+			<Test as Config>::Currency::total_balance(&addr),
+			min_balance + value + test_utils::contract_info_storage_deposit(&addr)
+		);
+
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::CodeStored {
+						code_hash,
+						deposit_held: deposit_expected,
+						uploader: ALICE
+					}),
+					topics: vec![code_hash],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::System(frame_system::Event::NewAccount {
+						account: addr.clone()
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Endowed {
+						account: addr.clone(),
+						free_balance: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: addr.clone(),
+						amount: min_balance,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: addr.clone(),
+						amount: 50,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Instantiated {
+						deployer: ALICE,
+						contract: addr.clone(),
+					}),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndHeld {
+							from: ALICE,
+							to: addr.clone(),
+							amount: test_utils::contract_info_storage_deposit(&addr),
+						}
+					),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn storage_deposit_works() {
+	let (wasm, _code_hash) = compile_module::<Test>("multi_store").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let mut deposit = test_utils::contract_info_storage_deposit(&addr);
+
+		// Drop previous events
+		initialize_block(2);
+
+		// Create storage
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			42,
+			GAS_LIMIT,
+			None,
+			(1_000u32, 5_000u32).encode(),
+		));
+		// 4 is for creating 2 storage items
+		let charged0 = 4 + 1_000 + 5_000;
+		deposit += charged0;
+		assert_eq!(get_contract(&addr).total_deposit(), deposit);
+
+		// Add more storage (but also remove some)
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			(2_000u32, 4_900u32).encode(),
+		));
+		let charged1 = 1_000 - 100;
+		deposit += charged1;
+		assert_eq!(get_contract(&addr).total_deposit(), deposit);
+
+		// Remove more storage (but also add some)
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			(2_100u32, 900u32).encode(),
+		));
+		// -1 for numeric instability
+		let refunded0 = 4_000 - 100 - 1;
+		deposit -= refunded0;
+		assert_eq!(get_contract(&addr).total_deposit(), deposit);
+
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+						from: ALICE,
+						to: addr.clone(),
+						amount: 42,
+					}),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(ALICE),
+						contract: addr.clone(),
+					}),
+					topics: vec![hash(&Origin::<Test>::from_account_id(ALICE)), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndHeld {
+							from: ALICE,
+							to: addr.clone(),
+							amount: charged0,
+						}
+					),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(ALICE),
+						contract: addr.clone(),
+					}),
+					topics: vec![hash(&Origin::<Test>::from_account_id(ALICE)), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndHeld {
+							from: ALICE,
+							to: addr.clone(),
+							amount: charged1,
+						}
+					),
+					topics: vec![hash(&ALICE), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(ALICE),
+						contract: addr.clone(),
+					}),
+					topics: vec![hash(&Origin::<Test>::from_account_id(ALICE)), hash(&addr)],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(
+						pallet_contracts::Event::StorageDepositTransferredAndReleased {
+							from: addr.clone(),
+							to: ALICE,
+							amount: refunded0,
+						}
+					),
+					topics: vec![hash(&addr.clone()), hash(&ALICE)],
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn storage_deposit_callee_works() {
+	let (wasm_caller, _code_hash_caller) = compile_module::<Test>("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);
+		let min_balance = Contracts::min_balance();
+
+		// Create both contracts: Constructors do nothing.
+		let addr_caller = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_caller),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		let addr_callee = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_callee),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr_caller,
+			0,
+			GAS_LIMIT,
+			None,
+			(100u32, &addr_callee).encode()
+		));
+
+		let callee = get_contract(&addr_callee);
+		let deposit = DepositPerByte::get() * 100 + DepositPerItem::get() * 1;
+
+		assert_eq!(test_utils::get_balance(&addr_callee), min_balance);
+		assert_eq!(
+			callee.total_deposit(),
+			deposit + test_utils::contract_info_storage_deposit(&addr_callee)
+		);
+	});
+}
+
+#[test]
+fn set_code_extrinsic() {
+	let (wasm, code_hash) = compile_module::<Test>("dummy").unwrap();
+	let (new_wasm, new_code_hash) = compile_module::<Test>("crypto_hashes").unwrap();
+
+	assert_ne!(code_hash, new_code_hash);
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			new_wasm,
+			None,
+			Determinism::Enforced
+		));
+
+		// Drop previous events
+		initialize_block(2);
+
+		assert_eq!(get_contract(&addr).code_hash, code_hash);
+		assert_refcount!(&code_hash, 1);
+		assert_refcount!(&new_code_hash, 0);
+
+		// only root can execute this extrinsic
+		assert_noop!(
+			Contracts::set_code(RuntimeOrigin::signed(ALICE), addr.clone(), new_code_hash),
+			sp_runtime::traits::BadOrigin,
+		);
+		assert_eq!(get_contract(&addr).code_hash, code_hash);
+		assert_refcount!(&code_hash, 1);
+		assert_refcount!(&new_code_hash, 0);
+		assert_eq!(System::events(), vec![],);
+
+		// contract must exist
+		assert_noop!(
+			Contracts::set_code(RuntimeOrigin::root(), BOB, new_code_hash),
+			<Error<Test>>::ContractNotFound,
+		);
+		assert_eq!(get_contract(&addr).code_hash, code_hash);
+		assert_refcount!(&code_hash, 1);
+		assert_refcount!(&new_code_hash, 0);
+		assert_eq!(System::events(), vec![],);
+
+		// new code hash must exist
+		assert_noop!(
+			Contracts::set_code(RuntimeOrigin::root(), addr.clone(), Default::default()),
+			<Error<Test>>::CodeNotFound,
+		);
+		assert_eq!(get_contract(&addr).code_hash, code_hash);
+		assert_refcount!(&code_hash, 1);
+		assert_refcount!(&new_code_hash, 0);
+		assert_eq!(System::events(), vec![],);
+
+		// successful call
+		assert_ok!(Contracts::set_code(RuntimeOrigin::root(), addr.clone(), new_code_hash));
+		assert_eq!(get_contract(&addr).code_hash, new_code_hash);
+		assert_refcount!(&code_hash, 0);
+		assert_refcount!(&new_code_hash, 1);
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Initialization,
+				event: RuntimeEvent::Contracts(pallet_contracts::Event::ContractCodeUpdated {
+					contract: addr.clone(),
+					new_code_hash,
+					old_code_hash: code_hash,
+				}),
+				topics: vec![hash(&addr), new_code_hash, code_hash],
+			},]
+		);
+	});
+}
+
+#[test]
+fn slash_cannot_kill_account() {
+	let (wasm, _code_hash) = compile_module::<Test>("dummy").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let value = 700;
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let min_balance = Contracts::min_balance();
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			value,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Drop previous events
+		initialize_block(2);
+
+		let info_deposit = test_utils::contract_info_storage_deposit(&addr);
+
+		assert_eq!(
+			test_utils::get_balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr),
+			info_deposit
+		);
+
+		assert_eq!(
+			<Test as Config>::Currency::total_balance(&addr),
+			info_deposit + value + min_balance
+		);
+
+		// Try to destroy the account of the contract by slashing the total balance.
+		// The account does not get destroyed because slashing only affects the balance held under
+		// certain `reason`. Slashing can for example happen if the contract takes part in staking.
+		let _ = <Test as Config>::Currency::slash(
+			&HoldReason::StorageDepositReserve.into(),
+			&addr,
+			<Test as Config>::Currency::total_balance(&addr),
+		);
+
+		// Slashing only removed the balance held.
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), value + min_balance);
+	});
+}
+
+#[test]
+fn contract_reverted() {
+	let (wasm, code_hash) = compile_module::<Test>("return_with_data").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let flags = ReturnFlags::REVERT;
+		let buffer = [4u8, 8, 15, 16, 23, 42];
+		let input = (flags.bits(), buffer).encode();
+
+		// We just upload the code for later use
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm.clone(),
+			None,
+			Determinism::Enforced
+		));
+
+		// Calling extrinsic: revert leads to an error
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate(
+				RuntimeOrigin::signed(ALICE),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash,
+				input.clone(),
+				vec![],
+			),
+			<Error<Test>>::ContractReverted,
+		);
+
+		// Calling extrinsic: revert leads to an error
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate_with_code(
+				RuntimeOrigin::signed(ALICE),
+				0,
+				GAS_LIMIT,
+				None,
+				wasm,
+				input.clone(),
+				vec![],
+			),
+			<Error<Test>>::ContractReverted,
+		);
+
+		// Calling directly: revert leads to success but the flags indicate the error
+		// This is just a different way of transporting the error that allows the read out
+		// the `data` which is only there on success. Obviously, the contract isn't
+		// instantiated.
+		let result = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Existing(code_hash),
+			input.clone(),
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap();
+		assert_eq!(result.result.flags, flags);
+		assert_eq!(result.result.data, buffer);
+		assert!(!<ContractInfoOf<Test>>::contains_key(result.account_id));
+
+		// Pass empty flags and therefore successfully instantiate the contract for later use.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Existing(code_hash),
+			ReturnFlags::empty().bits().encode(),
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Calling extrinsic: revert leads to an error
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				input.clone()
+			),
+			<Error<Test>>::ContractReverted,
+		);
+
+		// Calling directly: revert leads to success but the flags indicate the error
+		let result = Contracts::bare_call(
+			ALICE,
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			input,
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_eq!(result.flags, flags);
+		assert_eq!(result.data, buffer);
+	});
+}
+
+#[test]
+fn code_rejected_error_works() {
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let (wasm, _) = compile_module::<Test>("invalid_module").unwrap();
+		assert_noop!(
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				wasm.clone(),
+				None,
+				Determinism::Enforced
+			),
+			<Error<Test>>::CodeRejected,
+		);
+		let result = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+		);
+		assert_err!(result.result, <Error<Test>>::CodeRejected);
+		assert_eq!(
+			std::str::from_utf8(&result.debug_message).unwrap(),
+			"Can't load the module into wasmi!"
+		);
+
+		let (wasm, _) = compile_module::<Test>("invalid_contract_no_call").unwrap();
+		assert_noop!(
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				wasm.clone(),
+				None,
+				Determinism::Enforced
+			),
+			<Error<Test>>::CodeRejected,
+		);
+
+		let result = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+		);
+		assert_err!(result.result, <Error<Test>>::CodeRejected);
+		assert_eq!(
+			std::str::from_utf8(&result.debug_message).unwrap(),
+			"call function isn't exported"
+		);
+
+		let (wasm, _) = compile_module::<Test>("invalid_contract_no_memory").unwrap();
+		assert_noop!(
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				wasm.clone(),
+				None,
+				Determinism::Enforced
+			),
+			<Error<Test>>::CodeRejected,
+		);
+
+		let result = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+		);
+		assert_err!(result.result, <Error<Test>>::CodeRejected);
+		assert_eq!(
+			std::str::from_utf8(&result.debug_message).unwrap(),
+			"No memory import found in the module"
+		);
+	});
+}
+
+#[test]
+fn set_code_hash() {
+	let (wasm, code_hash) = compile_module::<Test>("set_code_hash").unwrap();
+	let (new_wasm, new_code_hash) = compile_module::<Test>("new_set_code_hash_contract").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate the 'caller'
+		let contract_addr = Contracts::bare_instantiate(
+			ALICE,
+			300_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		// upload new code
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			new_wasm.clone(),
+			None,
+			Determinism::Enforced
+		));
+
+		System::reset_events();
+
+		// First call sets new code_hash and returns 1
+		let result = Contracts::bare_call(
+			ALICE,
+			contract_addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			new_code_hash.as_ref().to_vec(),
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, 1);
+
+		// Second calls new contract code that returns 2
+		let result = Contracts::bare_call(
+			ALICE,
+			contract_addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![],
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+		assert_return_code!(result, 2);
+
+		// Checking for the last event only
+		assert_eq!(
+			&System::events(),
+			&[
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::ContractCodeUpdated {
+						contract: contract_addr.clone(),
+						new_code_hash,
+						old_code_hash: code_hash,
+					}),
+					topics: vec![hash(&contract_addr), new_code_hash, code_hash],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(ALICE),
+						contract: contract_addr.clone(),
+					}),
+					topics: vec![
+						hash(&Origin::<Test>::from_account_id(ALICE)),
+						hash(&contract_addr)
+					],
+				},
+				EventRecord {
+					phase: Phase::Initialization,
+					event: RuntimeEvent::Contracts(crate::Event::Called {
+						caller: Origin::from_account_id(ALICE),
+						contract: contract_addr.clone(),
+					}),
+					topics: vec![
+						hash(&Origin::<Test>::from_account_id(ALICE)),
+						hash(&contract_addr)
+					],
+				},
+			],
+		);
+	});
+}
+
+#[test]
+fn storage_deposit_limit_is_enforced() {
+	let (wasm, _code_hash) = 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);
+		let min_balance = Contracts::min_balance();
+
+		// Setting insufficient storage_deposit should fail.
+		assert_err!(
+			Contracts::bare_instantiate(
+				ALICE,
+				0,
+				GAS_LIMIT,
+				Some((2 * min_balance + 3 - 1).into()), /* expected deposit is 2 * ed + 3 for
+				                                         * the call */
+				Code::Upload(wasm.clone()),
+				vec![],
+				vec![],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			)
+			.result,
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info_deposit = test_utils::contract_info_storage_deposit(&addr);
+		// Check that the BOB contract has been instantiated and has the minimum balance
+		assert_eq!(get_contract(&addr).total_deposit(), info_deposit);
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), info_deposit + min_balance);
+
+		// Create 1 byte of storage with a price of per byte,
+		// setting insufficient deposit limit, as it requires 3 Balance:
+		// 2 for the item added + 1 for the new storage item.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(2)),
+				1u32.to_le_bytes().to_vec()
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+
+		// To check that deposit limit fallbacks to DefaultDepositLimit,
+		// we customize it here.
+		DEFAULT_DEPOSIT_LIMIT.with(|c| *c.borrow_mut() = 3);
+
+		// Create 1 byte of storage, should cost 3 Balance:
+		// 2 for the item added + 1 for the new storage item.
+		// Should pass as it fallbacks to DefaultDepositLimit.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			1u32.to_le_bytes().to_vec()
+		));
+
+		// Use 4 more bytes of the storage for the same item, which requires 4 Balance.
+		// Should fail as DefaultDepositLimit is 3 and hence isn't enough.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				5u32.to_le_bytes().to_vec()
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+	});
+}
+
+#[test]
+fn deposit_limit_in_nested_calls() {
+	let (wasm_caller, _code_hash_caller) =
+		compile_module::<Test>("create_storage_and_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 = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_caller),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		let addr_callee = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_callee),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Create 100 bytes of storage with a price of per byte
+		// This is 100 Balance + 2 Balance for the item
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr_callee.clone(),
+			0,
+			GAS_LIMIT,
+			Some(codec::Compact(102)),
+			100u32.to_le_bytes().to_vec()
+		));
+
+		// We do not remove any storage but add a storage item of 12 bytes in the caller
+		// contract. This would cost 12 + 2 = 14 Balance.
+		// The nested call doesn't get a special limit, which is set by passing 0 to it.
+		// This should fail as the specified parent's limit is less than the cost: 13 <
+		// 14.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(13)),
+				(100u32, &addr_callee, 0u64).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+		// Now we specify the parent's limit high enough to cover the caller's storage additions.
+		// However, we use a single byte more in the callee, hence the storage deposit should be 15
+		// Balance.
+		// The nested call doesn't get a special limit, which is set by passing 0 to it.
+		// This should fail as the specified parent's limit is less than the cost: 14
+		// < 15.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(14)),
+				(101u32, &addr_callee, 0u64).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+
+		// Now we specify the parent's limit high enough to cover both the caller's and callee's
+		// storage additions. However, we set a special deposit limit of 1 Balance for the nested
+		// call. This should fail as callee adds up 2 bytes to the storage, meaning that the nested
+		// call should have a deposit limit of at least 2 Balance. The sub-call should be rolled
+		// back, which is covered by the next test case.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(16)),
+				(102u32, &addr_callee, 1u64).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+
+		// Refund in the callee contract but not enough to cover the 14 Balance required by the
+		// caller. Note that if previous sub-call wouldn't roll back, this call would pass making
+		// the test case fail. We don't set a special limit for the nested call here.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(0)),
+				(87u32, &addr_callee, 0u64).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000);
+
+		// Require more than the sender's balance.
+		// We don't set a special limit for the nested call.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(ALICE),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				(1200u32, &addr_callee, 1u64).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+
+		// Same as above but allow for the additional deposit of 1 Balance in parent.
+		// We set the special deposit limit of 1 Balance for the nested call, which isn't
+		// enforced as callee frees up storage. This should pass.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr_caller.clone(),
+			0,
+			GAS_LIMIT,
+			Some(codec::Compact(1)),
+			(87u32, &addr_callee, 1u64).encode(),
+		));
+	});
+}
+
+#[test]
+fn deposit_limit_in_nested_instantiate() {
+	let (wasm_caller, _code_hash_caller) =
+		compile_module::<Test>("create_storage_and_instantiate").unwrap();
+	let (wasm_callee, code_hash_callee) = compile_module::<Test>("store_deploy").unwrap();
+	const ED: u64 = 5;
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let _ = <Test as Config>::Currency::set_balance(&BOB, 1_000_000);
+		// Create caller contract
+		let addr_caller = Contracts::bare_instantiate(
+			ALICE,
+			10_000u64, // this balance is later passed to the deployed contract
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_caller),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+		// Deploy a contract to get its occupied storage size
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_callee),
+			vec![0, 0, 0, 0],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let callee_info_len = ContractInfoOf::<Test>::get(&addr).unwrap().encoded_size() as u64;
+
+		// We don't set a special deposit limit for the nested instantiation.
+		//
+		// The deposit limit set for the parent is insufficient for the instantiation, which
+		// requires:
+		// - callee_info_len + 2 for storing the new contract info,
+		// - ED for deployed contract account,
+		// - 2 for the storage item of 0 bytes being created in the callee constructor
+		// or (callee_info_len + 2 + ED + 2) Balance in total.
+		//
+		// Provided the limit is set to be 1 Balance less,
+		// this call should fail on the return from the caller contract.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(BOB),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(callee_info_len + 2 + ED + 1)),
+				(0u32, &code_hash_callee, 0u64).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+		// The charges made on instantiation should be rolled back.
+		assert_eq!(<Test as Config>::Currency::free_balance(&BOB), 1_000_000);
+
+		// Now we give enough limit for the instantiation itself, but require for 1 more storage
+		// byte in the constructor. Hence +1 Balance to the limit is needed. This should fail on the
+		// return from constructor.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(BOB),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(callee_info_len + 2 + ED + 2)),
+				(1u32, &code_hash_callee, 0u64).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+		// The charges made on the instantiation should be rolled back.
+		assert_eq!(<Test as Config>::Currency::free_balance(&BOB), 1_000_000);
+
+		// Now we set enough limit in parent call, but an insufficient limit for child instantiate.
+		// This should fail during the charging for the instantiation in
+		// `RawMeter::charge_instantiate()`
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(BOB),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(callee_info_len + 2 + ED + 2)),
+				(0u32, &code_hash_callee, callee_info_len + 2 + ED + 1).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+		// The charges made on the instantiation should be rolled back.
+		assert_eq!(<Test as Config>::Currency::free_balance(&BOB), 1_000_000);
+
+		// Same as above but requires for single added storage
+		// item of 1 byte to be covered by the limit, which implies 3 more Balance.
+		// Now we set enough limit for the parent call, but insufficient limit for child
+		// instantiate. This should fail right after the constructor execution.
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(BOB),
+				addr_caller.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(callee_info_len + 2 + ED + 3)), // enough parent limit
+				(1u32, &code_hash_callee, callee_info_len + 2 + ED + 2).encode(),
+			),
+			<Error<Test>>::StorageDepositLimitExhausted,
+		);
+		// The charges made on the instantiation should be rolled back.
+		assert_eq!(<Test as Config>::Currency::free_balance(&BOB), 1_000_000);
+
+		// Set enough deposit limit for the child instantiate. This should succeed.
+		let result = Contracts::bare_call(
+			BOB,
+			addr_caller.clone(),
+			0,
+			GAS_LIMIT,
+			Some(codec::Compact(callee_info_len + 2 + ED + 4).into()),
+			(1u32, &code_hash_callee, callee_info_len + 2 + ED + 3).encode(),
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		);
+
+		let returned = result.result.unwrap();
+		// All balance of the caller except ED has been transferred to the callee.
+		// No deposit has been taken from it.
+		assert_eq!(<Test as Config>::Currency::free_balance(&addr_caller), ED);
+		// Get address of the deployed contract.
+		let addr_callee = AccountId32::from_slice(&returned.data[0..32]).unwrap();
+		// 10_000 should be sent to callee from the caller contract, plus ED to be sent from the
+		// origin.
+		assert_eq!(<Test as Config>::Currency::free_balance(&addr_callee), 10_000 + ED);
+		// The origin should be charged with:
+		//  - callee instantiation deposit = (callee_info_len + 2)
+		//  - callee account ED
+		//  - for writing an item of 1 byte to storage = 3 Balance
+		assert_eq!(
+			<Test as Config>::Currency::free_balance(&BOB),
+			1_000_000 - (callee_info_len + 2 + ED + 3)
+		);
+		// Check that deposit due to be charged still includes these 3 Balance
+		assert_eq!(result.storage_deposit.charge_or_zero(), (callee_info_len + 2 + ED + 3),)
+	});
+}
+
+#[test]
+fn deposit_limit_honors_liquidity_restrictions() {
+	let (wasm, _code_hash) = compile_module::<Test>("store_call").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let bobs_balance = 1_000;
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+		let _ = <Test as Config>::Currency::set_balance(&BOB, bobs_balance);
+		let min_balance = Contracts::min_balance();
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info_deposit = test_utils::contract_info_storage_deposit(&addr);
+		// Check that the contract has been instantiated and has the minimum balance
+		assert_eq!(get_contract(&addr).total_deposit(), info_deposit);
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), info_deposit + min_balance);
+
+		// check that the hold is honored
+		<Test as Config>::Currency::hold(
+			&HoldReason::CodeUploadDepositReserve.into(),
+			&BOB,
+			bobs_balance - min_balance,
+		)
+		.unwrap();
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(BOB),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(200)),
+				100u32.to_le_bytes().to_vec()
+			),
+			<Error<Test>>::StorageDepositNotEnoughFunds,
+		);
+		assert_eq!(<Test as Config>::Currency::free_balance(&BOB), min_balance);
+	});
+}
+
+#[test]
+fn deposit_limit_honors_existential_deposit() {
+	let (wasm, _code_hash) = 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);
+		let _ = <Test as Config>::Currency::set_balance(&BOB, 1_000);
+		let min_balance = Contracts::min_balance();
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info_deposit = test_utils::contract_info_storage_deposit(&addr);
+
+		// Check that the contract has been instantiated and has the minimum balance
+		assert_eq!(get_contract(&addr).total_deposit(), info_deposit);
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), min_balance + info_deposit);
+
+		// check that the deposit can't bring the account below the existential deposit
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(BOB),
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				Some(codec::Compact(900)),
+				100u32.to_le_bytes().to_vec()
+			),
+			<Error<Test>>::StorageDepositNotEnoughFunds,
+		);
+		assert_eq!(<Test as Config>::Currency::free_balance(&BOB), 1_000);
+	});
+}
+
+#[test]
+fn deposit_limit_honors_min_leftover() {
+	let (wasm, _code_hash) = 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);
+		let _ = <Test as Config>::Currency::set_balance(&BOB, 1_000);
+		let min_balance = Contracts::min_balance();
+
+		// Instantiate the BOB contract.
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let info_deposit = test_utils::contract_info_storage_deposit(&addr);
+
+		// Check that the contract has been instantiated and has the minimum balance and the storage
+		// deposit
+		assert_eq!(get_contract(&addr).total_deposit(), info_deposit);
+		assert_eq!(<Test as Config>::Currency::total_balance(&addr), info_deposit + min_balance);
+
+		// check that the minimum leftover (value send) is considered
+		assert_err_ignore_postinfo!(
+			Contracts::call(
+				RuntimeOrigin::signed(BOB),
+				addr.clone(),
+				400,
+				GAS_LIMIT,
+				Some(codec::Compact(500)),
+				100u32.to_le_bytes().to_vec()
+			),
+			<Error<Test>>::StorageDepositNotEnoughFunds,
+		);
+		assert_eq!(<Test as Config>::Currency::free_balance(&BOB), 1_000);
+	});
+}
+
+#[test]
+fn cannot_instantiate_indeterministic_code() {
+	let (wasm, code_hash) = compile_module::<Test>("float_instruction").unwrap();
+	let (caller_wasm, _) = compile_module::<Test>("instantiate_return_code").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Try to instantiate directly from code
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate_with_code(
+				RuntimeOrigin::signed(ALICE),
+				0,
+				GAS_LIMIT,
+				None,
+				wasm.clone(),
+				vec![],
+				vec![],
+			),
+			<Error<Test>>::CodeRejected,
+		);
+		assert_err!(
+			Contracts::bare_instantiate(
+				ALICE,
+				0,
+				GAS_LIMIT,
+				None,
+				Code::Upload(wasm.clone()),
+				vec![],
+				vec![],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			)
+			.result,
+			<Error<Test>>::CodeRejected,
+		);
+
+		// Try to upload a non deterministic code as deterministic
+		assert_err!(
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				wasm.clone(),
+				None,
+				Determinism::Enforced
+			),
+			<Error<Test>>::CodeRejected,
+		);
+
+		// Try to instantiate from already stored indeterministic code hash
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm,
+			None,
+			Determinism::Relaxed,
+		));
+
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate(
+				RuntimeOrigin::signed(ALICE),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash,
+				vec![],
+				vec![],
+			),
+			<Error<Test>>::Indeterministic,
+		);
+		assert_err!(
+			Contracts::bare_instantiate(
+				ALICE,
+				0,
+				GAS_LIMIT,
+				None,
+				Code::Existing(code_hash),
+				vec![],
+				vec![],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			)
+			.result,
+			<Error<Test>>::Indeterministic,
+		);
+
+		// Deploy contract which instantiates another contract
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Try to instantiate `code_hash` from another contract in deterministic mode
+		assert_err!(
+			<Pallet<Test>>::bare_call(
+				ALICE,
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash.encode(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result,
+			<Error<Test>>::Indeterministic,
+		);
+
+		// Instantiations are not allowed even in non determinism mode
+		assert_err!(
+			<Pallet<Test>>::bare_call(
+				ALICE,
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash.encode(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Relaxed,
+			)
+			.result,
+			<Error<Test>>::Indeterministic,
+		);
+	});
+}
+
+#[test]
+fn cannot_set_code_indeterministic_code() {
+	let (wasm, code_hash) = compile_module::<Test>("float_instruction").unwrap();
+	let (caller_wasm, _) = compile_module::<Test>("set_code_hash").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Put the non deterministic contract on-chain
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm,
+			None,
+			Determinism::Relaxed,
+		));
+
+		// Create the contract that will call `seal_set_code_hash`
+		let caller_addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// We do not allow to set the code hash to a non determinstic wasm
+		assert_err!(
+			<Pallet<Test>>::bare_call(
+				ALICE,
+				caller_addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash.encode(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Relaxed,
+			)
+			.result,
+			<Error<Test>>::Indeterministic,
+		);
+	});
+}
+
+#[test]
+fn delegate_call_indeterministic_code() {
+	let (wasm, code_hash) = compile_module::<Test>("float_instruction").unwrap();
+	let (caller_wasm, _) = compile_module::<Test>("delegate_call_simple").unwrap();
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		// Put the non deterministic contract on-chain
+		assert_ok!(Contracts::upload_code(
+			RuntimeOrigin::signed(ALICE),
+			wasm,
+			None,
+			Determinism::Relaxed,
+		));
+
+		// Create the contract that will call `seal_delegate_call`
+		let caller_addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(caller_wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// The delegate call will fail in deterministic mode
+		assert_err!(
+			<Pallet<Test>>::bare_call(
+				ALICE,
+				caller_addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash.encode(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result,
+			<Error<Test>>::Indeterministic,
+		);
+
+		// The delegate call will work on non deterministic mode
+		assert_ok!(
+			<Pallet<Test>>::bare_call(
+				ALICE,
+				caller_addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash.encode(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Relaxed,
+			)
+			.result
+		);
+	});
+}
+
+#[test]
+fn add_remove_delegate_dependency_works() {
+	// set hash lock up deposit to 30%, to test deposit calculation.
+	CODE_HASH_LOCKUP_DEPOSIT_PERCENT.with(|c| *c.borrow_mut() = Perbill::from_percent(30));
+	MAX_DELEGATE_DEPENDENCIES.with(|c| *c.borrow_mut() = 1);
+
+	let (wasm_caller, self_code_hash) =
+		compile_module::<Test>("add_remove_delegate_dependency").unwrap();
+	let (wasm_callee, code_hash) = compile_module::<Test>("dummy").unwrap();
+	let (wasm_other, other_code_hash) = compile_module::<Test>("call").unwrap();
+
+	// Define inputs with various actions to test adding / removing delegate_dependencies.
+	// See the contract for more details.
+	let noop_input = (0u32, code_hash);
+	let add_delegate_dependency_input = (1u32, code_hash);
+	let remove_delegate_dependency_input = (2u32, code_hash);
+	let terminate_input = (3u32, code_hash);
+
+	// Instantiate the caller contract with the given input.
+	let instantiate = |input: &(u32, H256)| {
+		Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_caller.clone()),
+			input.encode(),
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+	};
+
+	// Call contract with the given input.
+	let call = |addr_caller: &AccountId32, input: &(u32, H256)| {
+		<Pallet<Test>>::bare_call(
+			ALICE,
+			addr_caller.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			input.encode(),
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+	};
+
+	const ED: u64 = 2000;
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let _ = Balances::set_balance(&ALICE, 1_000_000);
+
+		// Instantiate with add_delegate_dependency should fail since the code is not yet on chain.
+		assert_err!(
+			instantiate(&add_delegate_dependency_input).result,
+			Error::<Test>::CodeNotFound
+		);
+
+		// Upload the delegated code.
+		let CodeUploadReturnValue { deposit, .. } =
+			Contracts::bare_upload_code(ALICE, wasm_callee.clone(), None, Determinism::Enforced)
+				.unwrap();
+
+		// Instantiate should now work.
+		let addr_caller = instantiate(&add_delegate_dependency_input).result.unwrap().account_id;
+
+		// There should be a dependency and a deposit.
+		let contract = test_utils::get_contract(&addr_caller);
+
+		let dependency_deposit = &CodeHashLockupDepositPercent::get().mul_ceil(deposit);
+		assert_eq!(contract.delegate_dependencies().get(&code_hash), Some(dependency_deposit));
+		assert_eq!(
+			test_utils::get_balance_on_hold(
+				&HoldReason::StorageDepositReserve.into(),
+				&addr_caller
+			),
+			dependency_deposit + contract.storage_base_deposit() - ED
+		);
+
+		// Removing the code should fail, since we have added a dependency.
+		assert_err!(
+			Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash),
+			<Error<Test>>::CodeInUse
+		);
+
+		// Adding an already existing dependency should fail.
+		assert_err!(
+			call(&addr_caller, &add_delegate_dependency_input).result,
+			Error::<Test>::DelegateDependencyAlreadyExists
+		);
+
+		// Adding a dependency to self should fail.
+		assert_err!(
+			call(&addr_caller, &(1u32, self_code_hash)).result,
+			Error::<Test>::CannotAddSelfAsDelegateDependency
+		);
+
+		// Adding more than the maximum allowed delegate_dependencies should fail.
+		Contracts::bare_upload_code(ALICE, wasm_other, None, Determinism::Enforced).unwrap();
+		assert_err!(
+			call(&addr_caller, &(1u32, other_code_hash)).result,
+			Error::<Test>::MaxDelegateDependenciesReached
+		);
+
+		// Removing dependency should work.
+		assert_ok!(call(&addr_caller, &remove_delegate_dependency_input).result);
+
+		// Dependency should be removed, and deposit should be returned.
+		let contract = test_utils::get_contract(&addr_caller);
+		assert!(contract.delegate_dependencies().is_empty());
+		assert_eq!(
+			test_utils::get_balance_on_hold(
+				&HoldReason::StorageDepositReserve.into(),
+				&addr_caller
+			),
+			contract.storage_base_deposit() - ED
+		);
+
+		// Removing an unexisting dependency should fail.
+		assert_err!(
+			call(&addr_caller, &remove_delegate_dependency_input).result,
+			Error::<Test>::DelegateDependencyNotFound
+		);
+
+		// Adding a dependency with a storage limit too low should fail.
+		DEFAULT_DEPOSIT_LIMIT.with(|c| *c.borrow_mut() = dependency_deposit - 1);
+		assert_err!(
+			call(&addr_caller, &add_delegate_dependency_input).result,
+			Error::<Test>::StorageDepositLimitExhausted
+		);
+
+		// Since we removed the dependency we should now be able to remove the code.
+		assert_ok!(Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash));
+
+		// Calling should fail since the delegated contract is not on chain anymore.
+		assert_err!(call(&addr_caller, &noop_input).result, Error::<Test>::ContractTrapped);
+
+		// Restore initial deposit limit and add the dependency back.
+		DEFAULT_DEPOSIT_LIMIT.with(|c| *c.borrow_mut() = 10_000_000);
+		Contracts::bare_upload_code(ALICE, wasm_callee, None, Determinism::Enforced).unwrap();
+		call(&addr_caller, &add_delegate_dependency_input).result.unwrap();
+
+		// Call terminate should work, and return the deposit.
+		let balance_before = test_utils::get_balance(&ALICE);
+		assert_ok!(call(&addr_caller, &terminate_input).result);
+		assert_eq!(
+			test_utils::get_balance(&ALICE),
+			balance_before + contract.storage_base_deposit() + dependency_deposit
+		);
+
+		// Terminate should also remove the dependency, so we can remove the code.
+		assert_ok!(Contracts::remove_code(RuntimeOrigin::signed(ALICE), code_hash));
+	});
+}
+
+#[test]
+fn native_dependency_deposit_works() {
+	let (wasm, code_hash) = compile_module::<Test>("set_code_hash").unwrap();
+	let (dummy_wasm, dummy_code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	// Set hash lock up deposit to 30%, to test deposit calculation.
+	CODE_HASH_LOCKUP_DEPOSIT_PERCENT.with(|c| *c.borrow_mut() = Perbill::from_percent(30));
+
+	// Set a low existential deposit so that the base storage deposit is based on the contract
+	// storage deposit rather than the existential deposit.
+	const ED: u64 = 10;
+
+	// Test with both existing and uploaded code
+	for code in [Code::Upload(wasm.clone()), Code::Existing(code_hash)] {
+		ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+			let _ = Balances::set_balance(&ALICE, 1_000_000);
+			let lockup_deposit_percent = CodeHashLockupDepositPercent::get();
+
+			// Upload the dummy contract,
+			Contracts::upload_code(
+				RuntimeOrigin::signed(ALICE),
+				dummy_wasm.clone(),
+				None,
+				Determinism::Enforced,
+			)
+			.unwrap();
+
+			// Upload `set_code_hash` contracts if using Code::Existing.
+			let add_upload_deposit = match code {
+				Code::Existing(_) => {
+					Contracts::upload_code(
+						RuntimeOrigin::signed(ALICE),
+						wasm.clone(),
+						None,
+						Determinism::Enforced,
+					)
+					.unwrap();
+					false
+				},
+				Code::Upload(_) => true,
+			};
+
+			// Instantiate the set_code_hash contract.
+			let res = Contracts::bare_instantiate(
+				ALICE,
+				0,
+				GAS_LIMIT,
+				None,
+				code,
+				vec![],
+				vec![],
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+			);
+
+			let addr = res.result.unwrap().account_id;
+			let base_deposit = ED + test_utils::contract_info_storage_deposit(&addr);
+			let upload_deposit = test_utils::get_code_deposit(&code_hash);
+			let extra_deposit = add_upload_deposit.then(|| upload_deposit).unwrap_or_default();
+
+			// Check initial storage_deposit
+			// The base deposit should be: ED + contract_info_storage_deposit + 30% * deposit
+			let deposit =
+				extra_deposit + base_deposit + lockup_deposit_percent.mul_ceil(upload_deposit);
+
+			assert_eq!(res.storage_deposit.charge_or_zero(), deposit);
+
+			// call set_code_hash
+			<Pallet<Test>>::bare_call(
+				ALICE,
+				addr.clone(),
+				0,
+				GAS_LIMIT,
+				None,
+				dummy_code_hash.encode(),
+				DebugInfo::Skip,
+				CollectEvents::Skip,
+				Determinism::Enforced,
+			)
+			.result
+			.unwrap();
+
+			// Check updated storage_deposit
+			let code_deposit = test_utils::get_code_deposit(&dummy_code_hash);
+			let deposit = base_deposit + lockup_deposit_percent.mul_ceil(code_deposit);
+			assert_eq!(test_utils::get_contract(&addr).storage_base_deposit(), deposit);
+			assert_eq!(
+				test_utils::get_balance_on_hold(&HoldReason::StorageDepositReserve.into(), &addr),
+				deposit - ED
+			);
+		});
+	}
+}
+
+#[test]
+fn reentrance_count_works_with_call() {
+	let (wasm, _code_hash) = compile_module::<Test>("reentrance_count_call").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let contract_addr = Contracts::bare_instantiate(
+			ALICE,
+			300_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// passing reentrant count to the input
+		let input = 0.encode();
+
+		Contracts::bare_call(
+			ALICE,
+			contract_addr,
+			0,
+			GAS_LIMIT,
+			None,
+			input,
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+	});
+}
+
+#[test]
+fn reentrance_count_works_with_delegated_call() {
+	let (wasm, code_hash) = compile_module::<Test>("reentrance_count_delegated_call").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let contract_addr = Contracts::bare_instantiate(
+			ALICE,
+			300_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// adding a callstack height to the input
+		let input = (code_hash, 1).encode();
+
+		Contracts::bare_call(
+			ALICE,
+			contract_addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			input,
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+	});
+}
+
+#[test]
+fn account_reentrance_count_works() {
+	let (wasm, _code_hash) = compile_module::<Test>("account_reentrance_count_call").unwrap();
+	let (wasm_reentrance_count, _code_hash_reentrance_count) =
+		compile_module::<Test>("reentrance_count_call").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let contract_addr = Contracts::bare_instantiate(
+			ALICE,
+			300_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let another_contract_addr = Contracts::bare_instantiate(
+			ALICE,
+			300_000,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm_reentrance_count),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		let result1 = Contracts::bare_call(
+			ALICE,
+			contract_addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			contract_addr.encode(),
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+
+		let result2 = Contracts::bare_call(
+			ALICE,
+			contract_addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			another_contract_addr.encode(),
+			DebugInfo::UnsafeDebug,
+			CollectEvents::Skip,
+			Determinism::Enforced,
+		)
+		.result
+		.unwrap();
+
+		assert_eq!(result1.data, 1.encode());
+		assert_eq!(result2.data, 0.encode());
+	});
+}
+
+#[test]
+fn root_cannot_upload_code() {
+	let (wasm, _) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().build().execute_with(|| {
+		assert_noop!(
+			Contracts::upload_code(RuntimeOrigin::root(), wasm, None, Determinism::Enforced),
+			DispatchError::BadOrigin,
+		);
+	});
+}
+
+#[test]
+fn root_cannot_remove_code() {
+	let (_, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().build().execute_with(|| {
+		assert_noop!(
+			Contracts::remove_code(RuntimeOrigin::root(), code_hash),
+			DispatchError::BadOrigin,
+		);
+	});
+}
+
+#[test]
+fn signed_cannot_set_code() {
+	let (_, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().build().execute_with(|| {
+		assert_noop!(
+			Contracts::set_code(RuntimeOrigin::signed(ALICE), BOB, code_hash),
+			DispatchError::BadOrigin,
+		);
+	});
+}
+
+#[test]
+fn none_cannot_call_code() {
+	ExtBuilder::default().build().execute_with(|| {
+		assert_noop!(
+			Contracts::call(RuntimeOrigin::none(), BOB, 0, GAS_LIMIT, None, Vec::new()),
+			DispatchError::BadOrigin,
+		);
+	});
+}
+
+#[test]
+fn root_can_call() {
+	let (wasm, _) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().existential_deposit(100).build().execute_with(|| {
+		let _ = <Test as Config>::Currency::set_balance(&ALICE, 1_000_000);
+
+		let addr = Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id;
+
+		// Call the contract.
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::root(),
+			addr.clone(),
+			0,
+			GAS_LIMIT,
+			None,
+			vec![]
+		));
+	});
+}
+
+#[test]
+fn root_cannot_instantiate_with_code() {
+	let (wasm, _) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().build().execute_with(|| {
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate_with_code(
+				RuntimeOrigin::root(),
+				0,
+				GAS_LIMIT,
+				None,
+				wasm,
+				vec![],
+				vec![],
+			),
+			DispatchError::BadOrigin
+		);
+	});
+}
+
+#[test]
+fn root_cannot_instantiate() {
+	let (_, code_hash) = compile_module::<Test>("dummy").unwrap();
+
+	ExtBuilder::default().build().execute_with(|| {
+		assert_err_ignore_postinfo!(
+			Contracts::instantiate(
+				RuntimeOrigin::root(),
+				0,
+				GAS_LIMIT,
+				None,
+				code_hash,
+				vec![],
+				vec![],
+			),
+			DispatchError::RootNotAllowed
+		);
+	});
+}
diff --git a/substrate/frame/contracts/src/tests/pallet_dummy.rs b/substrate/frame/contracts/src/tests/pallet_dummy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7f8db53bf463fba8d83ebb7c643a421148b9dfa3
--- /dev/null
+++ b/substrate/frame/contracts/src/tests/pallet_dummy.rs
@@ -0,0 +1,36 @@
+pub use pallet::*;
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use frame_support::{
+		dispatch::{Pays, PostDispatchInfo},
+		ensure,
+		pallet_prelude::DispatchResultWithPostInfo,
+		weights::Weight,
+	};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Dummy function that overcharges the predispatch weight, allowing us to test the correct
+		/// values of [`ContractResult::gas_consumed`] and [`ContractResult::gas_required`] in
+		/// tests.
+		#[pallet::call_index(1)]
+		#[pallet::weight(*pre_charge)]
+		pub fn overestimate_pre_charge(
+			origin: OriginFor<T>,
+			pre_charge: Weight,
+			actual_weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			ensure!(pre_charge.any_gt(actual_weight), "pre_charge must be > actual_weight");
+			Ok(PostDispatchInfo { actual_weight: Some(actual_weight), pays_fee: Pays::Yes })
+		}
+	}
+}
diff --git a/substrate/frame/contracts/src/tests/test_debug.rs b/substrate/frame/contracts/src/tests/test_debug.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ba936a4588d18954119664b1647241b736eed7e3
--- /dev/null
+++ b/substrate/frame/contracts/src/tests/test_debug.rs
@@ -0,0 +1,145 @@
+use super::*;
+use crate::debug::{CallSpan, ExportedFunction, Tracing};
+use frame_support::traits::Currency;
+use pallet_contracts_primitives::ExecReturnValue;
+use pretty_assertions::assert_eq;
+use std::cell::RefCell;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+struct DebugFrame {
+	code_hash: CodeHash<Test>,
+	call: ExportedFunction,
+	input: Vec<u8>,
+	result: Option<Vec<u8>>,
+}
+
+thread_local! {
+	static DEBUG_EXECUTION_TRACE: RefCell<Vec<DebugFrame>> = RefCell::new(Vec::new());
+}
+
+pub struct TestDebug;
+pub struct TestCallSpan {
+	code_hash: CodeHash<Test>,
+	call: ExportedFunction,
+	input: Vec<u8>,
+}
+
+impl Tracing<Test> for TestDebug {
+	type CallSpan = TestCallSpan;
+
+	fn new_call_span(
+		code_hash: &CodeHash<Test>,
+		entry_point: ExportedFunction,
+		input_data: &[u8],
+	) -> TestCallSpan {
+		DEBUG_EXECUTION_TRACE.with(|d| {
+			d.borrow_mut().push(DebugFrame {
+				code_hash: *code_hash,
+				call: entry_point,
+				input: input_data.to_vec(),
+				result: None,
+			})
+		});
+		TestCallSpan { code_hash: *code_hash, call: entry_point, input: input_data.to_vec() }
+	}
+}
+
+impl CallSpan for TestCallSpan {
+	fn after_call(self, output: &ExecReturnValue) {
+		DEBUG_EXECUTION_TRACE.with(|d| {
+			d.borrow_mut().push(DebugFrame {
+				code_hash: self.code_hash,
+				call: self.call,
+				input: self.input,
+				result: Some(output.data.clone()),
+			})
+		});
+	}
+}
+
+#[test]
+fn unsafe_debugging_works() {
+	let (wasm_caller, code_hash_caller) = compile_module::<Test>("call").unwrap();
+	let (wasm_callee, code_hash_callee) = compile_module::<Test>("store_call").unwrap();
+
+	fn current_stack() -> Vec<DebugFrame> {
+		DEBUG_EXECUTION_TRACE.with(|stack| stack.borrow().clone())
+	}
+
+	fn deploy(wasm: Vec<u8>) -> AccountId32 {
+		Contracts::bare_instantiate(
+			ALICE,
+			0,
+			GAS_LIMIT,
+			None,
+			Code::Upload(wasm),
+			vec![],
+			vec![],
+			DebugInfo::Skip,
+			CollectEvents::Skip,
+		)
+		.result
+		.unwrap()
+		.account_id
+	}
+
+	fn constructor_frame(hash: CodeHash<Test>, after: bool) -> DebugFrame {
+		DebugFrame {
+			code_hash: hash,
+			call: ExportedFunction::Constructor,
+			input: vec![],
+			result: if after { Some(vec![]) } else { None },
+		}
+	}
+
+	fn call_frame(hash: CodeHash<Test>, args: Vec<u8>, after: bool) -> DebugFrame {
+		DebugFrame {
+			code_hash: hash,
+			call: ExportedFunction::Call,
+			input: args,
+			result: if after { Some(vec![]) } else { None },
+		}
+	}
+
+	ExtBuilder::default().existential_deposit(200).build().execute_with(|| {
+		let _ = Balances::deposit_creating(&ALICE, 1_000_000);
+
+		assert_eq!(current_stack(), vec![]);
+
+		let addr_caller = deploy(wasm_caller);
+		let addr_callee = deploy(wasm_callee);
+
+		assert_eq!(
+			current_stack(),
+			vec![
+				constructor_frame(code_hash_caller, false),
+				constructor_frame(code_hash_caller, true),
+				constructor_frame(code_hash_callee, false),
+				constructor_frame(code_hash_callee, true),
+			]
+		);
+
+		let main_args = (100u32, &addr_callee).encode();
+		let inner_args = (100u32).encode();
+
+		assert_ok!(Contracts::call(
+			RuntimeOrigin::signed(ALICE),
+			addr_caller,
+			0,
+			GAS_LIMIT,
+			None,
+			main_args.clone()
+		));
+
+		let stack_top = current_stack()[4..].to_vec();
+		assert_eq!(
+			stack_top,
+			vec![
+				call_frame(code_hash_caller, main_args.clone(), false),
+				call_frame(code_hash_callee, inner_args.clone(), false),
+				call_frame(code_hash_callee, inner_args, true),
+				call_frame(code_hash_caller, main_args, true),
+			]
+		);
+	});
+}
diff --git a/substrate/frame/contracts/src/wasm/mod.rs b/substrate/frame/contracts/src/wasm/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..291f39f7fa797462dcfc4825234f837ac94787b6
--- /dev/null
+++ b/substrate/frame/contracts/src/wasm/mod.rs
@@ -0,0 +1,3420 @@
+// 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 module provides a means for executing contracts
+//! represented in wasm.
+
+mod prepare;
+mod runtime;
+
+#[cfg(doc)]
+pub use crate::wasm::runtime::api_doc;
+
+#[cfg(test)]
+pub use tests::MockExt;
+
+pub use crate::wasm::runtime::{
+	AllowDeprecatedInterface, AllowUnstableInterface, CallFlags, Environment, ReturnCode, Runtime,
+	RuntimeCosts,
+};
+
+use crate::{
+	exec::{ExecResult, Executable, ExportedFunction, Ext},
+	gas::{GasMeter, Token},
+	wasm::prepare::LoadedModule,
+	weights::WeightInfo,
+	AccountIdOf, BadOrigin, BalanceOf, CodeHash, CodeInfoOf, CodeVec, Config, Error, Event,
+	HoldReason, Pallet, PristineCode, Schedule, Weight, LOG_TARGET,
+};
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{DispatchError, DispatchResult},
+	ensure,
+	traits::{fungible::MutateHold, tokens::Precision::BestEffort},
+};
+use sp_core::Get;
+use sp_runtime::RuntimeDebug;
+use sp_std::prelude::*;
+use wasmi::{Instance, Linker, Memory, MemoryType, StackLimits, Store};
+
+const BYTES_PER_PAGE: usize = 64 * 1024;
+
+/// Validated Wasm module ready for execution.
+/// This data structure is immutable once created and stored.
+#[derive(Encode, Decode, scale_info::TypeInfo)]
+#[codec(mel_bound())]
+#[scale_info(skip_type_params(T))]
+pub struct WasmBlob<T: Config> {
+	code: CodeVec<T>,
+	// This isn't needed for contract execution and is not stored alongside it.
+	#[codec(skip)]
+	code_info: CodeInfo<T>,
+	// This is for not calculating the hash every time we need it.
+	#[codec(skip)]
+	code_hash: CodeHash<T>,
+}
+
+/// Contract code related data, such as:
+///
+/// - owner of the contract, i.e. account uploaded its code,
+/// - storage deposit amount,
+/// - reference count,
+/// - determinism marker.
+///
+/// It is stored in a separate storage entry to avoid loading the code when not necessary.
+#[derive(Clone, Encode, Decode, scale_info::TypeInfo, MaxEncodedLen)]
+#[codec(mel_bound())]
+#[scale_info(skip_type_params(T))]
+pub struct CodeInfo<T: Config> {
+	/// The account that has uploaded the contract code and hence is allowed to remove it.
+	owner: AccountIdOf<T>,
+	/// The amount of balance that was deposited by the owner in order to store it on-chain.
+	#[codec(compact)]
+	deposit: BalanceOf<T>,
+	/// The number of instantiated contracts that use this as their code.
+	#[codec(compact)]
+	refcount: u64,
+	/// Marks if the code might contain non-deterministic features and is therefore never allowed
+	/// to be run on-chain. Specifically, such a code can never be instantiated into a contract
+	/// and can just be used through a delegate call.
+	determinism: Determinism,
+	/// length of the code in bytes.
+	code_len: u32,
+}
+
+/// Defines the required determinism level of a wasm blob when either running or uploading code.
+#[derive(
+	Clone, Copy, Encode, Decode, scale_info::TypeInfo, MaxEncodedLen, RuntimeDebug, PartialEq, Eq,
+)]
+pub enum Determinism {
+	/// The execution should be deterministic and hence no indeterministic instructions are
+	/// allowed.
+	///
+	/// Dispatchables always use this mode in order to make on-chain execution deterministic.
+	Enforced,
+	/// Allow calling or uploading an indeterministic code.
+	///
+	/// This is only possible when calling into `pallet-contracts` directly via
+	/// [`crate::Pallet::bare_call`].
+	///
+	/// # Note
+	///
+	/// **Never** use this mode for on-chain execution.
+	Relaxed,
+}
+
+impl ExportedFunction {
+	/// The wasm export name for the function.
+	fn identifier(&self) -> &str {
+		match self {
+			Self::Constructor => "deploy",
+			Self::Call => "call",
+		}
+	}
+}
+
+/// Cost of code loading from storage.
+#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
+#[derive(Clone, Copy)]
+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))
+	}
+}
+
+impl<T: Config> WasmBlob<T> {
+	/// Create the module by checking the `code`.
+	pub fn from_code(
+		code: Vec<u8>,
+		schedule: &Schedule<T>,
+		owner: AccountIdOf<T>,
+		determinism: Determinism,
+	) -> Result<Self, (DispatchError, &'static str)> {
+		prepare::prepare::<runtime::Env, T>(
+			code.try_into().map_err(|_| (<Error<T>>::CodeTooLarge.into(), ""))?,
+			schedule,
+			owner,
+			determinism,
+		)
+	}
+
+	/// Remove the code from storage and refund the deposit to its owner.
+	///
+	/// Applies all necessary checks before removing the code.
+	pub fn remove(origin: &T::AccountId, code_hash: CodeHash<T>) -> DispatchResult {
+		Self::try_remove_code(origin, code_hash)
+	}
+
+	/// Creates and returns an instance of the supplied code.
+	///
+	/// This is either used for later executing a contract or for validation of a contract.
+	/// When validating we pass `()` as `host_state`. Please note that such a dummy instance must
+	/// **never** be called/executed, since it will panic the executor.
+	pub fn instantiate<E, H>(
+		code: &[u8],
+		host_state: H,
+		schedule: &Schedule<T>,
+		determinism: Determinism,
+		stack_limits: StackLimits,
+		allow_deprecated: AllowDeprecatedInterface,
+	) -> Result<(Store<H>, Memory, Instance), &'static str>
+	where
+		E: Environment<H>,
+	{
+		let contract = LoadedModule::new::<T>(&code, determinism, Some(stack_limits))?;
+		let mut store = Store::new(&contract.engine, host_state);
+		let mut linker = Linker::new(&contract.engine);
+		E::define(
+			&mut store,
+			&mut linker,
+			if T::UnsafeUnstableInterface::get() {
+				AllowUnstableInterface::Yes
+			} else {
+				AllowUnstableInterface::No
+			},
+			allow_deprecated,
+		)
+		.map_err(|_| "can't define host functions to Linker")?;
+
+		// Query wasmi for memory limits specified in the module's import entry.
+		let memory_limits = contract.scan_imports::<T>(schedule)?;
+		// Here we allocate this memory in the _store_. It allocates _inital_ value, but allows it
+		// to grow up to maximum number of memory pages, if necessary.
+		let qed = "We checked the limits versus our Schedule,
+					 which specifies the max amount of memory pages
+					 well below u16::MAX; qed";
+		let memory = Memory::new(
+			&mut store,
+			MemoryType::new(memory_limits.0, Some(memory_limits.1)).expect(qed),
+		)
+		.expect(qed);
+
+		linker
+			.define("env", "memory", memory)
+			.expect("We just created the Linker. It has no definitions with this name; qed");
+
+		let instance = linker
+			.instantiate(&mut store, &contract.module)
+			.map_err(|_| "can't instantiate module with provided definitions")?
+			.ensure_no_start(&mut store)
+			.map_err(|_| "start function is forbidden but found in the module")?;
+
+		Ok((store, memory, instance))
+	}
+
+	/// Puts the module blob into storage, and returns the deposit collected for the storage.
+	pub fn store_code(&mut self) -> Result<BalanceOf<T>, Error<T>> {
+		let code_hash = *self.code_hash();
+		<CodeInfoOf<T>>::mutate(code_hash, |stored_code_info| {
+			match stored_code_info {
+				// Contract code is already stored in storage. Nothing to be done here.
+				Some(_) => Ok(Default::default()),
+				// Upload a new contract code.
+				// We need to store the code and its code_info, and collect the deposit.
+				// This `None` case happens only with freshly uploaded modules. This means that
+				// the `owner` is always the origin of the current transaction.
+				None => {
+					let deposit = self.code_info.deposit;
+					T::Currency::hold(
+						&HoldReason::CodeUploadDepositReserve.into(),
+						&self.code_info.owner,
+						deposit,
+					)
+					.map_err(|_| <Error<T>>::StorageDepositNotEnoughFunds)?;
+
+					self.code_info.refcount = 0;
+					<PristineCode<T>>::insert(code_hash, &self.code);
+					*stored_code_info = Some(self.code_info.clone());
+					<Pallet<T>>::deposit_event(
+						vec![code_hash],
+						Event::CodeStored {
+							code_hash,
+							deposit_held: deposit,
+							uploader: self.code_info.owner.clone(),
+						},
+					);
+					Ok(deposit)
+				},
+			}
+		})
+	}
+
+	/// Try to remove code together with all associated information.
+	fn try_remove_code(origin: &T::AccountId, code_hash: CodeHash<T>) -> DispatchResult {
+		<CodeInfoOf<T>>::try_mutate_exists(&code_hash, |existing| {
+			if let Some(code_info) = existing {
+				ensure!(code_info.refcount == 0, <Error<T>>::CodeInUse);
+				ensure!(&code_info.owner == origin, BadOrigin);
+				let _ = T::Currency::release(
+					&HoldReason::CodeUploadDepositReserve.into(),
+					&code_info.owner,
+					code_info.deposit,
+					BestEffort,
+				);
+				let deposit_released = code_info.deposit;
+				let remover = code_info.owner.clone();
+
+				*existing = None;
+				<PristineCode<T>>::remove(&code_hash);
+				<Pallet<T>>::deposit_event(
+					vec![code_hash],
+					Event::CodeRemoved { code_hash, deposit_released, remover },
+				);
+				Ok(())
+			} else {
+				Err(<Error<T>>::CodeNotFound.into())
+			}
+		})
+	}
+
+	/// Load code with the given code hash.
+	fn load_code(
+		code_hash: CodeHash<T>,
+		gas_meter: &mut GasMeter<T>,
+	) -> Result<(CodeVec<T>, CodeInfo<T>), DispatchError> {
+		let code_info = <CodeInfoOf<T>>::get(code_hash).ok_or(Error::<T>::CodeNotFound)?;
+		gas_meter.charge(CodeLoadToken(code_info.code_len))?;
+		let code = <PristineCode<T>>::get(code_hash).ok_or(Error::<T>::CodeNotFound)?;
+		Ok((code, code_info))
+	}
+
+	/// Create the module without checking the passed code.
+	///
+	/// # Note
+	///
+	/// This is useful for benchmarking where we don't want validation of the module to skew
+	/// our results. This also does not collect any deposit from the `owner`. Also useful
+	/// during testing when we want to deploy codes that do not pass the instantiation checks.
+	#[cfg(any(test, feature = "runtime-benchmarks"))]
+	pub fn from_code_unchecked(
+		code: Vec<u8>,
+		schedule: &Schedule<T>,
+		owner: T::AccountId,
+	) -> Result<Self, DispatchError> {
+		prepare::benchmarking::prepare(code, schedule, owner)
+	}
+}
+
+impl<T: Config> CodeInfo<T> {
+	/// Return the refcount of the module.
+	#[cfg(test)]
+	pub fn refcount(&self) -> u64 {
+		self.refcount
+	}
+
+	#[cfg(test)]
+	pub fn new(owner: T::AccountId) -> Self {
+		CodeInfo {
+			owner,
+			deposit: Default::default(),
+			refcount: 0,
+			code_len: 0,
+			determinism: Determinism::Enforced,
+		}
+	}
+
+	/// Returns the deposit of the module.
+	pub fn deposit(&self) -> BalanceOf<T> {
+		self.deposit
+	}
+}
+
+impl<T: Config> Executable<T> for WasmBlob<T> {
+	fn from_storage(
+		code_hash: CodeHash<T>,
+		gas_meter: &mut GasMeter<T>,
+	) -> Result<Self, DispatchError> {
+		let (code, code_info) = Self::load_code(code_hash, gas_meter)?;
+		Ok(Self { code, code_info, code_hash })
+	}
+
+	fn increment_refcount(code_hash: CodeHash<T>) -> Result<(), DispatchError> {
+		<CodeInfoOf<T>>::mutate(code_hash, |existing| -> Result<(), DispatchError> {
+			if let Some(info) = existing {
+				info.refcount = info.refcount.saturating_add(1);
+				Ok(())
+			} else {
+				Err(Error::<T>::CodeNotFound.into())
+			}
+		})
+	}
+
+	fn decrement_refcount(code_hash: CodeHash<T>) {
+		<CodeInfoOf<T>>::mutate(code_hash, |existing| {
+			if let Some(info) = existing {
+				info.refcount = info.refcount.saturating_sub(1);
+			}
+		});
+	}
+
+	fn execute<E: Ext<T = T>>(
+		self,
+		ext: &mut E,
+		function: &ExportedFunction,
+		input_data: Vec<u8>,
+	) -> ExecResult {
+		let code = self.code.as_slice();
+		// Instantiate the Wasm module to the engine.
+		let runtime = Runtime::new(ext, input_data);
+		let schedule = <T>::Schedule::get();
+		let (mut store, memory, instance) = Self::instantiate::<crate::wasm::runtime::Env, _>(
+			code,
+			runtime,
+			&schedule,
+			self.code_info.determinism,
+			StackLimits::default(),
+			match function {
+				ExportedFunction::Call => AllowDeprecatedInterface::Yes,
+				ExportedFunction::Constructor => AllowDeprecatedInterface::No,
+			},
+		)
+		.map_err(|msg| {
+			log::debug!(target: LOG_TARGET, "failed to instantiate code to wasmi: {}", msg);
+			Error::<T>::CodeRejected
+		})?;
+		store.data_mut().set_memory(memory);
+
+		// Set fuel limit for the wasmi execution.
+		// We normalize it by the base instruction weight, as its cost in wasmi engine is `1`.
+		let fuel_limit = store
+			.data_mut()
+			.ext()
+			.gas_meter_mut()
+			.gas_left()
+			.ref_time()
+			.checked_div(T::Schedule::get().instruction_weights.base as u64)
+			.ok_or(Error::<T>::InvalidSchedule)?;
+		store
+			.add_fuel(fuel_limit)
+			.expect("We've set up engine to fuel consuming mode; qed");
+
+		let exported_func = instance
+			.get_export(&store, function.identifier())
+			.and_then(|export| export.into_func())
+			.ok_or_else(|| {
+				log::error!(target: LOG_TARGET, "failed to find entry point");
+				Error::<T>::CodeRejected
+			})?;
+
+		if let &ExportedFunction::Constructor = function {
+			WasmBlob::<T>::increment_refcount(self.code_hash)?;
+		}
+
+		let result = exported_func.call(&mut store, &[], &mut []);
+		let engine_consumed_total = store.fuel_consumed().expect("Fuel metering is enabled; qed");
+		// Sync this frame's gas meter with the engine's one.
+		let gas_meter = store.data_mut().ext().gas_meter_mut();
+		gas_meter.charge_fuel(engine_consumed_total)?;
+
+		store.into_data().to_execution_result(result)
+	}
+
+	fn code_hash(&self) -> &CodeHash<T> {
+		&self.code_hash
+	}
+
+	fn code_info(&self) -> &CodeInfo<T> {
+		&self.code_info
+	}
+
+	fn code_len(&self) -> u32 {
+		self.code.len() as u32
+	}
+
+	fn is_deterministic(&self) -> bool {
+		matches!(self.code_info.determinism, Determinism::Enforced)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		exec::{AccountIdOf, ErrorOrigin, ExecError, Executable, Ext, Key, SeedOf},
+		gas::GasMeter,
+		storage::WriteOutcome,
+		tests::{RuntimeCall, Test, ALICE, BOB},
+		BalanceOf, CodeHash, Error, Origin, Pallet as Contracts,
+	};
+	use assert_matches::assert_matches;
+	use frame_support::{
+		assert_err, assert_ok, dispatch::DispatchResultWithPostInfo, weights::Weight,
+	};
+	use frame_system::pallet_prelude::BlockNumberFor;
+	use pallet_contracts_primitives::{ExecReturnValue, ReturnFlags};
+	use pretty_assertions::assert_eq;
+	use sp_core::H256;
+	use sp_runtime::DispatchError;
+	use std::{
+		borrow::BorrowMut,
+		cell::RefCell,
+		collections::{
+			hash_map::{Entry, HashMap},
+			HashSet,
+		},
+	};
+
+	#[derive(Debug, PartialEq, Eq)]
+	struct InstantiateEntry {
+		code_hash: H256,
+		value: u64,
+		data: Vec<u8>,
+		gas_left: u64,
+		salt: Vec<u8>,
+	}
+
+	#[derive(Debug, PartialEq, Eq)]
+	struct TerminationEntry {
+		beneficiary: AccountIdOf<Test>,
+	}
+
+	#[derive(Debug, PartialEq, Eq)]
+	struct TransferEntry {
+		to: AccountIdOf<Test>,
+		value: u64,
+	}
+
+	#[derive(Debug, PartialEq, Eq)]
+	struct CallEntry {
+		to: AccountIdOf<Test>,
+		value: u64,
+		data: Vec<u8>,
+		allows_reentry: bool,
+	}
+
+	#[derive(Debug, PartialEq, Eq)]
+	struct CallCodeEntry {
+		code_hash: H256,
+		data: Vec<u8>,
+	}
+
+	pub struct MockExt {
+		storage: HashMap<Vec<u8>, Vec<u8>>,
+		instantiates: Vec<InstantiateEntry>,
+		terminations: Vec<TerminationEntry>,
+		calls: Vec<CallEntry>,
+		code_calls: Vec<CallCodeEntry>,
+		transfers: Vec<TransferEntry>,
+		// (topics, data)
+		events: Vec<(Vec<H256>, Vec<u8>)>,
+		runtime_calls: RefCell<Vec<RuntimeCall>>,
+		schedule: Schedule<Test>,
+		gas_meter: GasMeter<Test>,
+		debug_buffer: Vec<u8>,
+		ecdsa_recover: RefCell<Vec<([u8; 65], [u8; 32])>>,
+		sr25519_verify: RefCell<Vec<([u8; 64], Vec<u8>, [u8; 32])>>,
+		code_hashes: Vec<CodeHash<Test>>,
+		caller: Origin<Test>,
+		delegate_dependencies: RefCell<HashSet<CodeHash<Test>>>,
+	}
+
+	/// The call is mocked and just returns this hardcoded value.
+	fn call_return_data() -> Vec<u8> {
+		vec![0xDE, 0xAD, 0xBE, 0xEF]
+	}
+
+	impl Default for MockExt {
+		fn default() -> Self {
+			Self {
+				code_hashes: Default::default(),
+				storage: Default::default(),
+				instantiates: Default::default(),
+				terminations: Default::default(),
+				calls: Default::default(),
+				code_calls: Default::default(),
+				transfers: Default::default(),
+				events: Default::default(),
+				runtime_calls: Default::default(),
+				schedule: Default::default(),
+				gas_meter: GasMeter::new(Weight::from_parts(10_000_000_000, 10 * 1024 * 1024)),
+				debug_buffer: Default::default(),
+				ecdsa_recover: Default::default(),
+				caller: Default::default(),
+				sr25519_verify: Default::default(),
+				delegate_dependencies: Default::default(),
+			}
+		}
+	}
+
+	impl Ext for MockExt {
+		type T = Test;
+
+		fn call(
+			&mut self,
+			_gas_limit: Weight,
+			_deposit_limit: BalanceOf<Self::T>,
+			to: AccountIdOf<Self::T>,
+			value: u64,
+			data: Vec<u8>,
+			allows_reentry: bool,
+		) -> Result<ExecReturnValue, ExecError> {
+			self.calls.push(CallEntry { to, value, data, allows_reentry });
+			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: call_return_data() })
+		}
+		fn delegate_call(
+			&mut self,
+			code_hash: CodeHash<Self::T>,
+			data: Vec<u8>,
+		) -> Result<ExecReturnValue, ExecError> {
+			self.code_calls.push(CallCodeEntry { code_hash, data });
+			Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: call_return_data() })
+		}
+		fn instantiate(
+			&mut self,
+			gas_limit: Weight,
+			_deposit_limit: BalanceOf<Self::T>,
+			code_hash: CodeHash<Test>,
+			value: u64,
+			data: Vec<u8>,
+			salt: &[u8],
+		) -> Result<(AccountIdOf<Self::T>, ExecReturnValue), ExecError> {
+			self.instantiates.push(InstantiateEntry {
+				code_hash,
+				value,
+				data: data.to_vec(),
+				gas_left: gas_limit.ref_time(),
+				salt: salt.to_vec(),
+			});
+			Ok((
+				Contracts::<Test>::contract_address(&ALICE, &code_hash, &data, salt),
+				ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() },
+			))
+		}
+		fn set_code_hash(&mut self, hash: CodeHash<Self::T>) -> Result<(), DispatchError> {
+			self.code_hashes.push(hash);
+			Ok(())
+		}
+		fn transfer(&mut self, to: &AccountIdOf<Self::T>, value: u64) -> Result<(), DispatchError> {
+			self.transfers.push(TransferEntry { to: to.clone(), value });
+			Ok(())
+		}
+		fn terminate(&mut self, beneficiary: &AccountIdOf<Self::T>) -> Result<(), DispatchError> {
+			self.terminations.push(TerminationEntry { beneficiary: beneficiary.clone() });
+			Ok(())
+		}
+		fn get_storage(&mut self, key: &Key<Self::T>) -> Option<Vec<u8>> {
+			self.storage.get(&key.to_vec()).cloned()
+		}
+		fn get_storage_size(&mut self, key: &Key<Self::T>) -> Option<u32> {
+			self.storage.get(&key.to_vec()).map(|val| val.len() as u32)
+		}
+		fn set_storage(
+			&mut self,
+			key: &Key<Self::T>,
+			value: Option<Vec<u8>>,
+			take_old: bool,
+		) -> Result<WriteOutcome, DispatchError> {
+			let key = key.to_vec();
+			let entry = self.storage.entry(key.clone());
+			let result = match (entry, take_old) {
+				(Entry::Vacant(_), _) => WriteOutcome::New,
+				(Entry::Occupied(entry), false) =>
+					WriteOutcome::Overwritten(entry.remove().len() as u32),
+				(Entry::Occupied(entry), true) => WriteOutcome::Taken(entry.remove()),
+			};
+			if let Some(value) = value {
+				self.storage.insert(key, value);
+			}
+			Ok(result)
+		}
+		fn caller(&self) -> Origin<Self::T> {
+			self.caller.clone()
+		}
+		fn is_contract(&self, _address: &AccountIdOf<Self::T>) -> bool {
+			true
+		}
+		fn code_hash(&self, _address: &AccountIdOf<Self::T>) -> Option<CodeHash<Self::T>> {
+			Some(H256::from_slice(&[0x11; 32]))
+		}
+		fn own_code_hash(&mut self) -> &CodeHash<Self::T> {
+			const HASH: H256 = H256::repeat_byte(0x10);
+			&HASH
+		}
+		fn caller_is_origin(&self) -> bool {
+			false
+		}
+		fn caller_is_root(&self) -> bool {
+			&self.caller == &Origin::Root
+		}
+		fn address(&self) -> &AccountIdOf<Self::T> {
+			&BOB
+		}
+		fn balance(&self) -> u64 {
+			228
+		}
+		fn value_transferred(&self) -> u64 {
+			1337
+		}
+		fn now(&self) -> &u64 {
+			&1111
+		}
+		fn minimum_balance(&self) -> u64 {
+			666
+		}
+		fn random(&self, subject: &[u8]) -> (SeedOf<Self::T>, BlockNumberFor<Self::T>) {
+			(H256::from_slice(subject), 42)
+		}
+		fn deposit_event(&mut self, topics: Vec<H256>, data: Vec<u8>) {
+			self.events.push((topics, data))
+		}
+		fn block_number(&self) -> u64 {
+			121
+		}
+		fn max_value_size(&self) -> u32 {
+			16_384
+		}
+		fn get_weight_price(&self, weight: Weight) -> BalanceOf<Self::T> {
+			BalanceOf::<Self::T>::from(1312_u32)
+				.saturating_mul(weight.ref_time().into())
+				.saturating_add(
+					BalanceOf::<Self::T>::from(103_u32).saturating_mul(weight.proof_size()),
+				)
+		}
+		fn schedule(&self) -> &Schedule<Self::T> {
+			&self.schedule
+		}
+		fn gas_meter(&self) -> &GasMeter<Self::T> {
+			&self.gas_meter
+		}
+		fn gas_meter_mut(&mut self) -> &mut GasMeter<Self::T> {
+			&mut self.gas_meter
+		}
+		fn charge_storage(&mut self, _diff: &crate::storage::meter::Diff) {}
+		fn append_debug_buffer(&mut self, msg: &str) -> bool {
+			self.debug_buffer.extend(msg.as_bytes());
+			true
+		}
+		fn call_runtime(
+			&self,
+			call: <Self::T as Config>::RuntimeCall,
+		) -> DispatchResultWithPostInfo {
+			self.runtime_calls.borrow_mut().push(call);
+			Ok(Default::default())
+		}
+		fn ecdsa_recover(
+			&self,
+			signature: &[u8; 65],
+			message_hash: &[u8; 32],
+		) -> Result<[u8; 33], ()> {
+			self.ecdsa_recover.borrow_mut().push((*signature, *message_hash));
+			Ok([3; 33])
+		}
+		fn sr25519_verify(&self, signature: &[u8; 64], message: &[u8], pub_key: &[u8; 32]) -> bool {
+			self.sr25519_verify.borrow_mut().push((*signature, message.to_vec(), *pub_key));
+			true
+		}
+		fn contract_info(&mut self) -> &mut crate::ContractInfo<Self::T> {
+			unimplemented!()
+		}
+		fn ecdsa_to_eth_address(&self, _pk: &[u8; 33]) -> Result<[u8; 20], ()> {
+			Ok([2u8; 20])
+		}
+		fn reentrance_count(&self) -> u32 {
+			12
+		}
+		fn account_reentrance_count(&self, _account_id: &AccountIdOf<Self::T>) -> u32 {
+			12
+		}
+		fn nonce(&mut self) -> u64 {
+			995
+		}
+
+		fn add_delegate_dependency(
+			&mut self,
+			code: CodeHash<Self::T>,
+		) -> Result<(), DispatchError> {
+			self.delegate_dependencies.borrow_mut().insert(code);
+			Ok(())
+		}
+
+		fn remove_delegate_dependency(
+			&mut self,
+			code: &CodeHash<Self::T>,
+		) -> Result<(), DispatchError> {
+			self.delegate_dependencies.borrow_mut().remove(code);
+			Ok(())
+		}
+	}
+
+	/// Execute the supplied code.
+	///
+	/// Not used directly but through the wrapper functions defined below.
+	fn execute_internal<E: BorrowMut<MockExt>>(
+		wat: &str,
+		input_data: Vec<u8>,
+		mut ext: E,
+		entry_point: &ExportedFunction,
+		unstable_interface: bool,
+		skip_checks: bool,
+	) -> ExecResult {
+		type RuntimeConfig = <MockExt as Ext>::T;
+		RuntimeConfig::set_unstable_interface(unstable_interface);
+		let wasm = wat::parse_str(wat).unwrap();
+		let executable = if skip_checks {
+			WasmBlob::<RuntimeConfig>::from_code_unchecked(
+				wasm,
+				ext.borrow_mut().schedule(),
+				ALICE,
+			)?
+		} else {
+			WasmBlob::<RuntimeConfig>::from_code(
+				wasm,
+				ext.borrow_mut().schedule(),
+				ALICE,
+				Determinism::Enforced,
+			)
+			.map_err(|err| err.0)?
+		};
+		executable.execute(ext.borrow_mut(), entry_point, input_data)
+	}
+
+	/// Execute the supplied code.
+	fn execute<E: BorrowMut<MockExt>>(wat: &str, input_data: Vec<u8>, ext: E) -> ExecResult {
+		execute_internal(wat, input_data, ext, &ExportedFunction::Call, true, false)
+	}
+
+	/// Execute the supplied code with disabled unstable functions.
+	///
+	/// In our test config unstable functions are disabled so that we can test them.
+	/// In order to test that code using them is properly rejected we temporarily disable
+	/// them when this test is run.
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	fn execute_no_unstable<E: BorrowMut<MockExt>>(
+		wat: &str,
+		input_data: Vec<u8>,
+		ext: E,
+	) -> ExecResult {
+		execute_internal(wat, input_data, ext, &ExportedFunction::Call, false, false)
+	}
+
+	/// Execute code without validating it first.
+	///
+	/// This is mainly useful in order to test code which uses deprecated functions. Those
+	/// would fail when validating the code.
+	fn execute_unvalidated<E: BorrowMut<MockExt>>(
+		wat: &str,
+		input_data: Vec<u8>,
+		ext: E,
+	) -> ExecResult {
+		execute_internal(wat, input_data, ext, &ExportedFunction::Call, false, true)
+	}
+
+	/// Execute instantiation entry point of code without validating it first.
+	///
+	/// Same as `execute_unvalidated` except that the `deploy` entry point is ran.
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	fn execute_instantiate_unvalidated<E: BorrowMut<MockExt>>(
+		wat: &str,
+		input_data: Vec<u8>,
+		ext: E,
+	) -> ExecResult {
+		execute_internal(wat, input_data, ext, &ExportedFunction::Constructor, false, true)
+	}
+
+	const CODE_TRANSFER: &str = r#"
+(module
+	;; seal_transfer(
+	;;    account_ptr: u32,
+	;;    account_len: u32,
+	;;    value_ptr: u32,
+	;;    value_len: u32,
+	;;) -> u32
+	(import "seal0" "seal_transfer" (func $seal_transfer (param i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_transfer
+				(i32.const 4)  ;; Pointer to "account" address.
+				(i32.const 32)  ;; Length of "account" address.
+				(i32.const 36) ;; Pointer to the buffer with value to transfer
+				(i32.const 8)  ;; Length of the buffer with value to transfer.
+			)
+		)
+	)
+	(func (export "deploy"))
+
+	;; Destination AccountId (ALICE)
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;; Amount of value to transfer.
+	;; Represented by u64 (8 bytes long) in little endian.
+	(data (i32.const 36) "\99\00\00\00\00\00\00\00")
+)
+"#;
+
+	#[test]
+	fn contract_transfer() {
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(CODE_TRANSFER, vec![], &mut mock_ext));
+
+		assert_eq!(&mock_ext.transfers, &[TransferEntry { to: ALICE, value: 153 }]);
+	}
+
+	const CODE_CALL: &str = r#"
+(module
+	;; seal_call(
+	;;    callee_ptr: u32,
+	;;    callee_len: u32,
+	;;    gas: u64,
+	;;    value_ptr: u32,
+	;;    value_len: u32,
+	;;    input_data_ptr: u32,
+	;;    input_data_len: u32,
+	;;    output_ptr: u32,
+	;;    output_len_ptr: u32
+	;;) -> u32
+	(import "seal0" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_call
+				(i32.const 4)  ;; Pointer to "callee" address.
+				(i32.const 32)  ;; Length of "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 36) ;; Pointer to the buffer with value to transfer
+				(i32.const 8)  ;; Length of the buffer with value to transfer.
+				(i32.const 44) ;; Pointer to input data buffer address
+				(i32.const 4)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		)
+	)
+	(func (export "deploy"))
+
+	;; Destination AccountId (ALICE)
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;; Amount of value to transfer.
+	;; Represented by u64 (8 bytes long) in little endian.
+	(data (i32.const 36) "\06\00\00\00\00\00\00\00")
+
+	(data (i32.const 44) "\01\02\03\04")
+)
+"#;
+
+	#[test]
+	fn contract_call() {
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(CODE_CALL, vec![], &mut mock_ext));
+
+		assert_eq!(
+			&mock_ext.calls,
+			&[CallEntry { to: ALICE, value: 6, data: vec![1, 2, 3, 4], allows_reentry: true }]
+		);
+	}
+
+	#[test]
+	fn contract_delegate_call() {
+		const CODE: &str = r#"
+(module
+	;; seal_delegate_call(
+	;;    flags: u32,
+	;;    code_hash_ptr: u32,
+	;;    input_data_ptr: u32,
+	;;    input_data_len: u32,
+	;;    output_ptr: u32,
+	;;    output_len_ptr: u32
+	;;) -> u32
+	(import "seal0" "seal_delegate_call" (func $seal_delegate_call (param i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_delegate_call
+				(i32.const 0) ;; No flags are set
+				(i32.const 4)  ;; Pointer to "callee" code_hash.
+				(i32.const 36) ;; Pointer to input data buffer address
+				(i32.const 4)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		)
+	)
+	(func (export "deploy"))
+
+	;; Callee code_hash
+	(data (i32.const 4)
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+	)
+
+	(data (i32.const 36) "\01\02\03\04")
+)
+"#;
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(CODE, vec![], &mut mock_ext));
+
+		assert_eq!(
+			&mock_ext.code_calls,
+			&[CallCodeEntry { code_hash: [0x11; 32].into(), data: vec![1, 2, 3, 4] }]
+		);
+	}
+
+	#[test]
+	fn contract_call_forward_input() {
+		const CODE: &str = r#"
+(module
+	(import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_call
+				(i32.const 1) ;; Set FORWARD_INPUT bit
+				(i32.const 4)  ;; Pointer to "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 36) ;; Pointer to the buffer with value to transfer
+				(i32.const 44) ;; Pointer to input data buffer address
+				(i32.const 4)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		)
+
+		;; triggers a trap because we already forwarded the input
+		(call $seal_input (i32.const 1) (i32.const 44))
+	)
+
+	(func (export "deploy"))
+
+	;; Destination AccountId (ALICE)
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;; Amount of value to transfer.
+	;; Represented by u64 (8 bytes long) in little endian.
+	(data (i32.const 36) "\2A\00\00\00\00\00\00\00")
+
+	;; The input is ignored because we forward our own input
+	(data (i32.const 44) "\01\02\03\04")
+)
+"#;
+		let mut mock_ext = MockExt::default();
+		let input = vec![0xff, 0x2a, 0x99, 0x88];
+		assert_err!(execute(CODE, input.clone(), &mut mock_ext), <Error<Test>>::InputForwarded,);
+
+		assert_eq!(
+			&mock_ext.calls,
+			&[CallEntry { to: ALICE, value: 0x2a, data: input, allows_reentry: false }]
+		);
+	}
+
+	#[test]
+	fn contract_call_clone_input() {
+		const CODE: &str = r#"
+(module
+	(import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_call
+				(i32.const 11) ;; Set FORWARD_INPUT | CLONE_INPUT | ALLOW_REENTRY bits
+				(i32.const 4)  ;; Pointer to "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 36) ;; Pointer to the buffer with value to transfer
+				(i32.const 44) ;; Pointer to input data buffer address
+				(i32.const 4)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		)
+
+		;; works because the input was cloned
+		(call $seal_input (i32.const 0) (i32.const 44))
+
+		;; return the input to caller for inspection
+		(call $seal_return (i32.const 0) (i32.const 0) (i32.load (i32.const 44)))
+	)
+
+	(func (export "deploy"))
+
+	;; Destination AccountId (ALICE)
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;; Amount of value to transfer.
+	;; Represented by u64 (8 bytes long) in little endian.
+	(data (i32.const 36) "\2A\00\00\00\00\00\00\00")
+
+	;; The input is ignored because we forward our own input
+	(data (i32.const 44) "\01\02\03\04")
+)
+"#;
+		let mut mock_ext = MockExt::default();
+		let input = vec![0xff, 0x2a, 0x99, 0x88];
+		let result = execute(CODE, input.clone(), &mut mock_ext).unwrap();
+		assert_eq!(result.data, input);
+		assert_eq!(
+			&mock_ext.calls,
+			&[CallEntry { to: ALICE, value: 0x2a, data: input, allows_reentry: true }]
+		);
+	}
+
+	#[test]
+	fn contract_call_tail_call() {
+		const CODE: &str = r#"
+(module
+	(import "seal1" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_call
+				(i32.const 5) ;; Set FORWARD_INPUT | TAIL_CALL bit
+				(i32.const 4)  ;; Pointer to "callee" address.
+				(i64.const 0)  ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 36) ;; Pointer to the buffer with value to transfer
+				(i32.const 0) ;; Pointer to input data buffer address
+				(i32.const 0)  ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+			)
+		)
+
+		;; a tail call never returns
+		(unreachable)
+	)
+
+	(func (export "deploy"))
+
+	;; Destination AccountId (ALICE)
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;; Amount of value to transfer.
+	;; Represented by u64 (8 bytes long) in little endian.
+	(data (i32.const 36) "\2A\00\00\00\00\00\00\00")
+)
+"#;
+		let mut mock_ext = MockExt::default();
+		let input = vec![0xff, 0x2a, 0x99, 0x88];
+		let result = execute(CODE, input.clone(), &mut mock_ext).unwrap();
+		assert_eq!(result.data, call_return_data());
+		assert_eq!(
+			&mock_ext.calls,
+			&[CallEntry { to: ALICE, value: 0x2a, data: input, allows_reentry: false }]
+		);
+	}
+
+	#[test]
+	fn contains_storage_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal1" "contains_storage" (func $contains_storage (param i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+
+	;; size of input buffer
+	;; [0, 4) size of input buffer (128+32 = 160 bytes = 0xA0)
+	(data (i32.const 0) "\A0")
+
+	;; [4, 164) input buffer
+
+	(func (export "call")
+		;; Receive key
+		(call $seal_input
+			(i32.const 4)	;; Where we take input and store it
+			(i32.const 0)	;; Where we take and store the length of the data
+		)
+		;; Call seal_clear_storage and save what it returns at 0
+		(i32.store (i32.const 0)
+			(call $contains_storage
+				(i32.const 8)			;; key_ptr
+				(i32.load (i32.const 4))	;; key_len
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 0)	;; returned value
+			(i32.const 4)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+		let mut ext = MockExt::default();
+		ext.set_storage(
+			&Key::<Test>::try_from_var([1u8; 64].to_vec()).unwrap(),
+			Some(vec![42u8]),
+			false,
+		)
+		.unwrap();
+		ext.set_storage(
+			&Key::<Test>::try_from_var([2u8; 19].to_vec()).unwrap(),
+			Some(vec![]),
+			false,
+		)
+		.unwrap();
+
+		//value does not exist (wrong key length)
+		let input = (63, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		// sentinel returned
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), crate::SENTINEL);
+
+		// value exists
+		let input = (64, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		// true as u32 returned
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), 1);
+		// getter does not remove the value from storage
+		assert_eq!(ext.storage.get(&[1u8; 64].to_vec()).unwrap(), &[42u8]);
+
+		// value exists (test for 0 sized)
+		let input = (19, [2u8; 19]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		// true as u32 returned
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), 0);
+		// getter does not remove the value from storage
+		assert_eq!(ext.storage.get(&[2u8; 19].to_vec()).unwrap(), &([] as [u8; 0]));
+	}
+
+	const CODE_INSTANTIATE: &str = r#"
+(module
+	;; seal_instantiate(
+	;;     code_ptr: u32,
+	;;     code_len: u32,
+	;;     gas: u64,
+	;;     value_ptr: u32,
+	;;     value_len: u32,
+	;;     input_data_ptr: u32,
+	;;     input_data_len: u32,
+	;;     input_data_len: u32,
+	;;     address_ptr: u32,
+	;;     address_len_ptr: u32,
+	;;     output_ptr: u32,
+	;;     output_len_ptr: u32
+	;; ) -> u32
+	(import "seal0" "seal_instantiate" (func $seal_instantiate
+		(param i32 i32 i64 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
+	))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_instantiate
+				(i32.const 16)   ;; Pointer to `code_hash`
+				(i32.const 32)   ;; Length of `code_hash`
+				(i64.const 0)    ;; How much gas to devote for the execution. 0 = all.
+				(i32.const 4)    ;; Pointer to the buffer with value to transfer
+				(i32.const 8)    ;; Length of the buffer with value to transfer
+				(i32.const 12)   ;; Pointer to input data buffer address
+				(i32.const 4)    ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy address
+				(i32.const 0) ;; Length is ignored in this case
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this case
+				(i32.const 0) ;; salt_ptr
+				(i32.const 4) ;; salt_len
+			)
+		)
+	)
+	(func (export "deploy"))
+
+	;; Salt
+	(data (i32.const 0) "\42\43\44\45")
+	;; Amount of value to transfer.
+	;; Represented by u64 (8 bytes long) in little endian.
+	(data (i32.const 4) "\03\00\00\00\00\00\00\00")
+	;; Input data to pass to the contract being instantiated.
+	(data (i32.const 12) "\01\02\03\04")
+	;; Hash of code.
+	(data (i32.const 16)
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+	)
+)
+"#;
+
+	#[test]
+	fn contract_instantiate() {
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(CODE_INSTANTIATE, vec![], &mut mock_ext));
+
+		assert_matches!(
+			&mock_ext.instantiates[..],
+			[InstantiateEntry {
+				code_hash,
+				value: 3,
+				data,
+				gas_left: _,
+				salt,
+			}] if
+				code_hash == &[0x11; 32].into() &&
+				data == &vec![1, 2, 3, 4] &&
+				salt == &vec![0x42, 0x43, 0x44, 0x45]
+		);
+	}
+
+	const CODE_TERMINATE: &str = r#"
+(module
+	;; seal_terminate(
+	;;     beneficiary_ptr: u32,
+	;;     beneficiary_len: u32,
+	;; )
+	(import "seal0" "seal_terminate" (func $seal_terminate (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(call $seal_terminate
+			(i32.const 4)  ;; Pointer to "beneficiary" address.
+			(i32.const 32)  ;; Length of "beneficiary" address.
+		)
+	)
+	(func (export "deploy"))
+
+	;; Beneficiary AccountId to transfer the funds.
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+)
+"#;
+
+	#[test]
+	fn contract_terminate() {
+		let mut mock_ext = MockExt::default();
+		execute(CODE_TERMINATE, vec![], &mut mock_ext).unwrap();
+
+		assert_eq!(&mock_ext.terminations, &[TerminationEntry { beneficiary: ALICE }]);
+	}
+
+	const CODE_TRANSFER_LIMITED_GAS: &str = r#"
+(module
+	;; seal_call(
+	;;    callee_ptr: u32,
+	;;    callee_len: u32,
+	;;    gas: u64,
+	;;    value_ptr: u32,
+	;;    value_len: u32,
+	;;    input_data_ptr: u32,
+	;;    input_data_len: u32,
+	;;    output_ptr: u32,
+	;;    output_len_ptr: u32
+	;;) -> u32
+	(import "seal0" "seal_call" (func $seal_call (param i32 i32 i64 i32 i32 i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_call
+				(i32.const 4)  ;; Pointer to "callee" address.
+				(i32.const 32)  ;; Length of "callee" address.
+				(i64.const 228)  ;; How much gas to devote for the execution.
+				(i32.const 36)  ;; Pointer to the buffer with value to transfer
+				(i32.const 8)   ;; Length of the buffer with value to transfer.
+				(i32.const 44)   ;; Pointer to input data buffer address
+				(i32.const 4)   ;; Length of input data buffer
+				(i32.const 4294967295) ;; u32 max value is the sentinel value: do not copy output
+				(i32.const 0) ;; Length is ignored in this cas
+			)
+		)
+	)
+	(func (export "deploy"))
+
+	;; Destination AccountId to transfer the funds.
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+	;; Amount of value to transfer.
+	;; Represented by u64 (8 bytes long) in little endian.
+	(data (i32.const 36) "\06\00\00\00\00\00\00\00")
+
+	(data (i32.const 44) "\01\02\03\04")
+)
+"#;
+
+	#[test]
+	fn contract_call_limited_gas() {
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(&CODE_TRANSFER_LIMITED_GAS, vec![], &mut mock_ext));
+
+		assert_eq!(
+			&mock_ext.calls,
+			&[CallEntry { to: ALICE, value: 6, data: vec![1, 2, 3, 4], allows_reentry: true }]
+		);
+	}
+
+	const CODE_ECDSA_RECOVER: &str = r#"
+(module
+	;; seal_ecdsa_recover(
+	;;    signature_ptr: u32,
+	;;    message_hash_ptr: u32,
+	;;    output_ptr: u32
+	;; ) -> u32
+	(import "seal0" "seal_ecdsa_recover" (func $seal_ecdsa_recover (param i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $seal_ecdsa_recover
+				(i32.const 36) ;; Pointer to signature.
+				(i32.const 4)  ;; Pointer to message hash.
+				(i32.const 36) ;; Pointer for output - public key.
+			)
+		)
+	)
+	(func (export "deploy"))
+
+	;; Hash of message.
+	(data (i32.const 4)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+	;; Signature
+	(data (i32.const 36)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01"
+	)
+)
+"#;
+
+	#[test]
+	fn contract_ecdsa_recover() {
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(&CODE_ECDSA_RECOVER, vec![], &mut mock_ext));
+		assert_eq!(mock_ext.ecdsa_recover.into_inner(), [([1; 65], [1; 32])]);
+	}
+
+	#[test]
+	fn contract_ecdsa_to_eth_address() {
+		/// calls `seal_ecdsa_to_eth_address` for the contstant and ensures the result equals the
+		/// expected one.
+		const CODE_ECDSA_TO_ETH_ADDRESS: &str = r#"
+(module
+	(import "seal0" "seal_ecdsa_to_eth_address" (func $seal_ecdsa_to_eth_address (param i32 i32) (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call")
+		;; fill the buffer with the eth address.
+		(call $seal_ecdsa_to_eth_address (i32.const 0) (i32.const 0))
+
+		;; Return the contents of the buffer
+		(call $seal_return
+			(i32.const 0)
+			(i32.const 0)
+			(i32.const 20)
+		)
+
+		;; seal_return doesn't return, so this is effectively unreachable.
+		(unreachable)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+		let output = execute(CODE_ECDSA_TO_ETH_ADDRESS, vec![], MockExt::default()).unwrap();
+		assert_eq!(
+			output,
+			ExecReturnValue { flags: ReturnFlags::empty(), data: [0x02; 20].to_vec() }
+		);
+	}
+
+	#[test]
+	fn contract_sr25519() {
+		const CODE_SR25519: &str = r#"
+(module
+	(import "seal0" "sr25519_verify" (func $sr25519_verify (param i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(drop
+			(call $sr25519_verify
+				(i32.const 0) ;; Pointer to signature.
+				(i32.const 64) ;; Pointer to public key.
+				(i32.const 16) ;; message length.
+				(i32.const 96) ;; Pointer to message.
+			)
+		)
+	)
+	(func (export "deploy"))
+
+	;; Signature (64 bytes)
+	(data (i32.const 0)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;;  public key (32 bytes)
+	(data (i32.const 64)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;;  message. (16 bytes)
+	(data (i32.const 96)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+)
+"#;
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(&CODE_SR25519, vec![], &mut mock_ext));
+		assert_eq!(mock_ext.sr25519_verify.into_inner(), [([1; 64], [1; 16].to_vec(), [1; 32])]);
+	}
+
+	const CODE_GET_STORAGE: &str = r#"
+(module
+	(import "seal0" "seal_get_storage" (func $seal_get_storage (param i32 i32 i32) (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) key for get storage
+	(data (i32.const 0)
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+	)
+
+	;; [32, 36) buffer size = 4k in little endian
+	(data (i32.const 32) "\00\10")
+
+	;; [36; inf) buffer where the result is copied
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(local $buf_size i32)
+
+		;; Load a storage value into contract memory.
+		(call $assert
+			(i32.eq
+				(call $seal_get_storage
+					(i32.const 0)		;; The pointer to the storage key to fetch
+					(i32.const 36)		;; Pointer to the output buffer
+					(i32.const 32)		;; Pointer to the size of the buffer
+				)
+
+				;; Return value 0 means that the value is found and there were
+				;; no errors.
+				(i32.const 0)
+			)
+		)
+
+		;; Find out the size of the buffer
+		(set_local $buf_size
+			(i32.load (i32.const 32))
+		)
+
+		;; Return the contents of the buffer
+		(call $seal_return
+			(i32.const 0)
+			(i32.const 36)
+			(get_local $buf_size)
+		)
+
+		;; env:seal_return doesn't return, so this is effectively unreachable.
+		(unreachable)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn get_storage_puts_data_into_buf() {
+		let mut mock_ext = MockExt::default();
+		mock_ext.storage.insert([0x11; 32].to_vec(), [0x22; 32].to_vec());
+
+		let output = execute(CODE_GET_STORAGE, vec![], mock_ext).unwrap();
+
+		assert_eq!(
+			output,
+			ExecReturnValue { flags: ReturnFlags::empty(), data: [0x22; 32].to_vec() }
+		);
+	}
+
+	/// calls `seal_caller` and compares the result with the constant (ALICE's address part).
+	const CODE_CALLER: &str = r#"
+(module
+	(import "seal0" "seal_caller" (func $seal_caller (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; fill the buffer with the caller.
+		(call $seal_caller (i32.const 0) (i32.const 32))
+
+		;; assert len == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 32)
+			)
+		)
+
+		;; assert that the first 8 bytes are the beginning of "ALICE"
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 0x0101010101010101)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn caller() {
+		assert_ok!(execute(CODE_CALLER, vec![], MockExt::default()));
+	}
+
+	#[test]
+	fn caller_traps_when_no_account_id() {
+		let mut ext = MockExt::default();
+		ext.caller = Origin::Root;
+		assert_eq!(
+			execute(CODE_CALLER, vec![], ext),
+			Err(ExecError { error: DispatchError::RootNotAllowed, origin: ErrorOrigin::Caller })
+		);
+	}
+
+	/// calls `seal_address` and compares the result with the constant (BOB's address part).
+	const CODE_ADDRESS: &str = r#"
+(module
+	(import "seal0" "seal_address" (func $seal_address (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; fill the buffer with the self address.
+		(call $seal_address (i32.const 0) (i32.const 32))
+
+		;; assert size == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 32)
+			)
+		)
+
+		;; assert that the first 8 bytes are the beginning of "BOB"
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 0x0202020202020202)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn address() {
+		assert_ok!(execute(CODE_ADDRESS, vec![], MockExt::default()));
+	}
+
+	const CODE_BALANCE: &str = r#"
+(module
+	(import "seal0" "seal_balance" (func $seal_balance (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the balance in the buffer
+		(call $seal_balance (i32.const 0) (i32.const 32))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the i64 value of 228.
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 228)
+			)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn balance() {
+		assert_ok!(execute(CODE_BALANCE, vec![], MockExt::default()));
+	}
+
+	const CODE_GAS_PRICE: &str = r#"
+(module
+	(import "seal1" "weight_to_fee" (func $seal_weight_to_fee (param i64 i64 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the gas price in the buffer
+		(call $seal_weight_to_fee (i64.const 2) (i64.const 1) (i32.const 0) (i32.const 32))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the i64 value of 2 * 1312 + 103 = 2727.
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 2727)
+			)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn gas_price() {
+		assert_ok!(execute(CODE_GAS_PRICE, vec![], MockExt::default()));
+	}
+
+	const CODE_GAS_LEFT: &str = r#"
+(module
+	(import "seal1" "gas_left" (func $seal_gas_left (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; Make output buffer size 20 bytes
+	(data (i32.const 20) "\14")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the weight left to the buffer
+		(call $seal_gas_left (i32.const 0) (i32.const 20))
+
+		;; Assert len <= 16 (max encoded Weight len)
+		(call $assert
+			(i32.le_u
+				(i32.load (i32.const 20))
+				(i32.const 16)
+			)
+		)
+
+		;; Return weight left and its encoded value len
+		(call $seal_return (i32.const 0) (i32.const 0) (i32.load (i32.const 20)))
+
+		(unreachable)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn gas_left() {
+		let mut ext = MockExt::default();
+		let gas_limit = ext.gas_meter.gas_left();
+
+		let output = execute(CODE_GAS_LEFT, vec![], &mut ext).unwrap();
+
+		let weight_left = Weight::decode(&mut &*output.data).unwrap();
+		let actual_left = ext.gas_meter.gas_left();
+
+		assert!(weight_left.all_lt(gas_limit), "gas_left must be less than initial");
+		assert!(weight_left.all_gt(actual_left), "gas_left must be greater than final");
+	}
+
+	/// Test that [`frame_support::weights::OldWeight`] en/decodes the same as our
+	/// [`crate::OldWeight`].
+	#[test]
+	fn old_weight_decode() {
+		#![allow(deprecated)]
+		let sp = frame_support::weights::OldWeight(42).encode();
+		let our = crate::OldWeight::decode(&mut &*sp).unwrap();
+
+		assert_eq!(our, 42);
+	}
+
+	const CODE_VALUE_TRANSFERRED: &str = r#"
+(module
+	(import "seal0" "seal_value_transferred" (func $seal_value_transferred (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the value transferred in the buffer
+		(call $seal_value_transferred (i32.const 0) (i32.const 32))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the i64 value of 1337.
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 1337)
+			)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn value_transferred() {
+		assert_ok!(execute(CODE_VALUE_TRANSFERRED, vec![], MockExt::default()));
+	}
+
+	const START_FN_ILLEGAL: &str = r#"
+(module
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(start $start)
+	(func $start
+		(unreachable)
+	)
+
+	(func (export "call")
+		(unreachable)
+	)
+
+	(func (export "deploy")
+		(unreachable)
+	)
+
+	(data (i32.const 8) "\01\02\03\04")
+)
+"#;
+
+	#[test]
+	fn start_fn_illegal() {
+		let output = execute(START_FN_ILLEGAL, vec![], MockExt::default());
+		assert_err!(output, <Error<Test>>::CodeRejected,);
+	}
+
+	const CODE_TIMESTAMP_NOW: &str = r#"
+(module
+	(import "seal0" "seal_now" (func $seal_now (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the block timestamp in the buffer
+		(call $seal_now (i32.const 0) (i32.const 32))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the i64 value of 1111.
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 1111)
+			)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	const CODE_TIMESTAMP_NOW_UNPREFIXED: &str = r#"
+(module
+	(import "seal0" "now" (func $now (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the block timestamp in the buffer
+		(call $now (i32.const 0) (i32.const 32))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the i64 value of 1111.
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 1111)
+			)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn now() {
+		assert_ok!(execute(CODE_TIMESTAMP_NOW, vec![], MockExt::default()));
+		assert_ok!(execute(CODE_TIMESTAMP_NOW_UNPREFIXED, vec![], MockExt::default()));
+	}
+
+	const CODE_MINIMUM_BALANCE: &str = r#"
+(module
+	(import "seal0" "seal_minimum_balance" (func $seal_minimum_balance (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		(call $seal_minimum_balance (i32.const 0) (i32.const 32))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the i64 value of 666.
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 666)
+			)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn minimum_balance() {
+		assert_ok!(execute(CODE_MINIMUM_BALANCE, vec![], MockExt::default()));
+	}
+
+	const CODE_RANDOM: &str = r#"
+(module
+	(import "seal0" "seal_random" (func $seal_random (param i32 i32 i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0,128) is reserved for the result of PRNG.
+
+	;; the subject used for the PRNG. [128,160)
+	(data (i32.const 128)
+		"\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F"
+		"\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F"
+	)
+
+	;; size of our buffer is 128 bytes
+	(data (i32.const 160) "\80")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the block random seed in the buffer
+		(call $seal_random
+			(i32.const 128) ;; Pointer in memory to the start of the subject buffer
+			(i32.const 32) ;; The subject buffer's length
+			(i32.const 0) ;; Pointer to the output buffer
+			(i32.const 160) ;; Pointer to the output buffer length
+		)
+
+		;; assert len == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 160))
+				(i32.const 32)
+			)
+		)
+
+		;; return the random data
+		(call $seal_return
+			(i32.const 0)
+			(i32.const 0)
+			(i32.const 32)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn random() {
+		let output = execute_unvalidated(CODE_RANDOM, vec![], MockExt::default()).unwrap();
+
+		// The mock ext just returns the same data that was passed as the subject.
+		assert_eq!(
+			output,
+			ExecReturnValue {
+				flags: ReturnFlags::empty(),
+				data: array_bytes::hex_into_unchecked(
+					"000102030405060708090A0B0C0D0E0F000102030405060708090A0B0C0D0E0F"
+				)
+			},
+		);
+	}
+
+	const CODE_RANDOM_V1: &str = r#"
+(module
+	(import "seal1" "seal_random" (func $seal_random (param i32 i32 i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0,128) is reserved for the result of PRNG.
+
+	;; the subject used for the PRNG. [128,160)
+	(data (i32.const 128)
+		"\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F"
+		"\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F"
+	)
+
+	;; size of our buffer is 128 bytes
+	(data (i32.const 160) "\80")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the block random seed in the buffer
+		(call $seal_random
+			(i32.const 128) ;; Pointer in memory to the start of the subject buffer
+			(i32.const 32) ;; The subject buffer's length
+			(i32.const 0) ;; Pointer to the output buffer
+			(i32.const 160) ;; Pointer to the output buffer length
+		)
+
+		;; assert len == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 160))
+				(i32.const 40)
+			)
+		)
+
+		;; return the random data
+		(call $seal_return
+			(i32.const 0)
+			(i32.const 0)
+			(i32.const 40)
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn random_v1() {
+		let output = execute_unvalidated(CODE_RANDOM_V1, vec![], MockExt::default()).unwrap();
+
+		// The mock ext just returns the same data that was passed as the subject.
+		assert_eq!(
+			output,
+			ExecReturnValue {
+				flags: ReturnFlags::empty(),
+				data: (
+					array_bytes::hex2array_unchecked::<_, 32>(
+						"000102030405060708090A0B0C0D0E0F000102030405060708090A0B0C0D0E0F"
+					),
+					42u64,
+				)
+					.encode()
+			},
+		);
+	}
+
+	const CODE_DEPOSIT_EVENT: &str = r#"
+(module
+	(import "seal0" "seal_deposit_event" (func $seal_deposit_event (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call")
+		(call $seal_deposit_event
+			(i32.const 32) ;; Pointer to the start of topics buffer
+			(i32.const 33) ;; The length of the topics buffer.
+			(i32.const 8) ;; Pointer to the start of the data buffer
+			(i32.const 13) ;; Length of the buffer
+		)
+	)
+	(func (export "deploy"))
+
+	(data (i32.const 8) "\00\01\2A\00\00\00\00\00\00\00\E5\14\00")
+
+	;; Encoded Vec<TopicOf<T>>, the buffer has length of 33 bytes.
+	(data (i32.const 32) "\04\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33\33"
+	"\33\33\33\33\33\33\33\33\33")
+)
+"#;
+
+	#[test]
+	fn deposit_event() {
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(CODE_DEPOSIT_EVENT, vec![], &mut mock_ext));
+
+		assert_eq!(
+			mock_ext.events,
+			vec![(
+				vec![H256::repeat_byte(0x33)],
+				vec![0x00, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe5, 0x14, 0x00]
+			)]
+		);
+
+		assert!(mock_ext.gas_meter.gas_left().ref_time() > 0);
+	}
+
+	const CODE_DEPOSIT_EVENT_DUPLICATES: &str = r#"
+(module
+	(import "seal0" "seal_deposit_event" (func $seal_deposit_event (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call")
+		(call $seal_deposit_event
+			(i32.const 32) ;; Pointer to the start of topics buffer
+			(i32.const 129) ;; The length of the topics buffer.
+			(i32.const 8) ;; Pointer to the start of the data buffer
+			(i32.const 13) ;; Length of the buffer
+		)
+	)
+	(func (export "deploy"))
+
+	(data (i32.const 8) "\00\01\2A\00\00\00\00\00\00\00\E5\14\00")
+
+	;; Encoded Vec<TopicOf<T>>, the buffer has length of 129 bytes.
+	(data (i32.const 32) "\10"
+"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+"\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02"
+"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+"\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04")
+)
+"#;
+
+	/// Checks that the runtime allows duplicate topics.
+	#[test]
+	fn deposit_event_duplicates_allowed() {
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(CODE_DEPOSIT_EVENT_DUPLICATES, vec![], &mut mock_ext,));
+
+		assert_eq!(
+			mock_ext.events,
+			vec![(
+				vec![
+					H256::repeat_byte(0x01),
+					H256::repeat_byte(0x02),
+					H256::repeat_byte(0x01),
+					H256::repeat_byte(0x04)
+				],
+				vec![0x00, 0x01, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe5, 0x14, 0x00]
+			)]
+		);
+	}
+
+	const CODE_DEPOSIT_EVENT_MAX_TOPICS: &str = r#"
+(module
+	(import "seal0" "seal_deposit_event" (func $seal_deposit_event (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call")
+		(call $seal_deposit_event
+			(i32.const 32) ;; Pointer to the start of topics buffer
+			(i32.const 161) ;; The length of the topics buffer.
+			(i32.const 8) ;; Pointer to the start of the data buffer
+			(i32.const 13) ;; Length of the buffer
+		)
+	)
+	(func (export "deploy"))
+
+	(data (i32.const 8) "\00\01\2A\00\00\00\00\00\00\00\E5\14\00")
+
+	;; Encoded Vec<TopicOf<T>>, the buffer has length of 161 bytes.
+	(data (i32.const 32) "\14"
+"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+"\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02"
+"\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03"
+"\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04\04"
+"\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05\05")
+)
+"#;
+
+	/// Checks that the runtime traps if there are more than `max_topic_events` topics.
+	#[test]
+	fn deposit_event_max_topics() {
+		assert_eq!(
+			execute(CODE_DEPOSIT_EVENT_MAX_TOPICS, vec![], MockExt::default(),),
+			Err(ExecError {
+				error: Error::<Test>::TooManyTopics.into(),
+				origin: ErrorOrigin::Caller,
+			})
+		);
+	}
+
+	/// calls `seal_block_number` compares the result with the constant 121.
+	const CODE_BLOCK_NUMBER: &str = r#"
+(module
+	(import "seal0" "seal_block_number" (func $seal_block_number (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; This stores the block height in the buffer
+		(call $seal_block_number (i32.const 0) (i32.const 32))
+
+		;; assert len == 8
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 8)
+			)
+		)
+
+		;; assert that contents of the buffer is equal to the i64 value of 121.
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 121)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn block_number() {
+		let _ = execute(CODE_BLOCK_NUMBER, vec![], MockExt::default()).unwrap();
+	}
+
+	const CODE_RETURN_WITH_DATA: &str = r#"
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(data (i32.const 32) "\20")
+
+	;; Deploy routine is the same as call.
+	(func (export "deploy")
+		(call $call)
+	)
+
+	;; Call reads the first 4 bytes (LE) as the exit status and returns the rest as output data.
+	(func $call (export "call")
+		;; Copy input data this contract memory.
+		(call $seal_input
+			(i32.const 0)	;; Pointer where to store input
+			(i32.const 32)	;; Pointer to the length of the buffer
+		)
+
+		;; Copy all but the first 4 bytes of the input data as the output data.
+		(call $seal_return
+			(i32.load (i32.const 0))
+			(i32.const 4)
+			(i32.sub (i32.load (i32.const 32)) (i32.const 4))
+		)
+		(unreachable)
+	)
+)
+"#;
+
+	#[test]
+	fn seal_return_with_success_status() {
+		let output = execute(
+			CODE_RETURN_WITH_DATA,
+			array_bytes::hex2bytes_unchecked("00000000445566778899"),
+			MockExt::default(),
+		)
+		.unwrap();
+
+		assert_eq!(
+			output,
+			ExecReturnValue {
+				flags: ReturnFlags::empty(),
+				data: array_bytes::hex2bytes_unchecked("445566778899"),
+			}
+		);
+		assert!(!output.did_revert());
+	}
+
+	#[test]
+	fn return_with_revert_status() {
+		let output = execute(
+			CODE_RETURN_WITH_DATA,
+			array_bytes::hex2bytes_unchecked("010000005566778899"),
+			MockExt::default(),
+		)
+		.unwrap();
+
+		assert_eq!(
+			output,
+			ExecReturnValue {
+				flags: ReturnFlags::REVERT,
+				data: array_bytes::hex2bytes_unchecked("5566778899"),
+			}
+		);
+		assert!(output.did_revert());
+	}
+
+	const CODE_OUT_OF_BOUNDS_ACCESS: &str = r#"
+(module
+	(import "seal0" "seal_terminate" (func $seal_terminate (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(call $seal_terminate
+			(i32.const 65536)  ;; Pointer to "account" address (out of bound).
+			(i32.const 8)  ;; Length of "account" address.
+		)
+	)
+)
+"#;
+
+	#[test]
+	fn contract_out_of_bounds_access() {
+		let mut mock_ext = MockExt::default();
+		let result = execute(CODE_OUT_OF_BOUNDS_ACCESS, vec![], &mut mock_ext);
+
+		assert_eq!(
+			result,
+			Err(ExecError {
+				error: Error::<Test>::OutOfBounds.into(),
+				origin: ErrorOrigin::Caller,
+			})
+		);
+	}
+
+	const CODE_DECODE_FAILURE: &str = r#"
+(module
+	(import "seal0" "seal_terminate" (func $seal_terminate (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(call $seal_terminate
+			(i32.const 0)  ;; Pointer to "account" address.
+			(i32.const 4)  ;; Length of "account" address (too small -> decode fail).
+		)
+	)
+)
+"#;
+
+	#[test]
+	fn contract_decode_length_ignored() {
+		let mut mock_ext = MockExt::default();
+		let result = execute(CODE_DECODE_FAILURE, vec![], &mut mock_ext);
+		// AccountID implements `MaxEncodeLen` and therefore the supplied length is
+		// no longer needed nor used to determine how much is read from contract memory.
+		assert_ok!(result);
+	}
+
+	#[test]
+	fn debug_message_works() {
+		const CODE_DEBUG_MESSAGE: &str = r#"
+(module
+	(import "seal0" "seal_debug_message" (func $seal_debug_message (param i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(data (i32.const 0) "Hello World!")
+
+	(func (export "call")
+		(call $seal_debug_message
+			(i32.const 0)	;; Pointer to the text buffer
+			(i32.const 12)	;; The size of the buffer
+		)
+		drop
+	)
+
+	(func (export "deploy"))
+)
+"#;
+		let mut ext = MockExt::default();
+		execute(CODE_DEBUG_MESSAGE, vec![], &mut ext).unwrap();
+
+		assert_eq!(std::str::from_utf8(&ext.debug_buffer).unwrap(), "Hello World!");
+	}
+
+	#[test]
+	fn debug_message_invalid_utf8_fails() {
+		const CODE_DEBUG_MESSAGE_FAIL: &str = r#"
+(module
+	(import "seal0" "seal_debug_message" (func $seal_debug_message (param i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(data (i32.const 0) "\fc")
+
+	(func (export "call")
+		(call $seal_debug_message
+			(i32.const 0)	;; Pointer to the text buffer
+			(i32.const 1)	;; The size of the buffer
+		)
+		drop
+	)
+
+	(func (export "deploy"))
+)
+"#;
+		let mut ext = MockExt::default();
+		let result = execute(CODE_DEBUG_MESSAGE_FAIL, vec![], &mut ext);
+		assert_ok!(result);
+		assert!(ext.debug_buffer.is_empty());
+	}
+
+	const CODE_CALL_RUNTIME: &str = r#"
+(module
+	(import "seal0" "call_runtime" (func $call_runtime (param i32 i32) (result i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; 0x1000 = 4k in little endian
+	;; size of input buffer
+	(data (i32.const 0) "\00\10")
+
+	(func (export "call")
+		;; Receive the encoded call
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the length buffer
+		)
+		;; Just use the call passed as input and store result to memory
+		(i32.store (i32.const 0)
+			(call $call_runtime
+				(i32.const 4)				;; Pointer where the call is stored
+				(i32.load (i32.const 0))	;; Size of the call
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 0)	;; returned value
+			(i32.const 4)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+	#[test]
+	fn call_runtime_works() {
+		let call =
+			RuntimeCall::System(frame_system::Call::remark { remark: b"Hello World".to_vec() });
+		let mut ext = MockExt::default();
+		let result = execute(CODE_CALL_RUNTIME, call.encode(), &mut ext).unwrap();
+		assert_eq!(*ext.runtime_calls.borrow(), vec![call]);
+		// 0 = ReturnCode::Success
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), 0);
+	}
+
+	#[test]
+	fn call_runtime_panics_on_invalid_call() {
+		let mut ext = MockExt::default();
+		let result = execute(CODE_CALL_RUNTIME, vec![0x42], &mut ext);
+		assert_eq!(
+			result,
+			Err(ExecError {
+				error: Error::<Test>::DecodingFailed.into(),
+				origin: ErrorOrigin::Caller,
+			})
+		);
+		assert_eq!(*ext.runtime_calls.borrow(), vec![]);
+	}
+
+	#[test]
+	fn set_storage_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal2" "set_storage" (func $set_storage (param i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 4) size of input buffer
+	;; 4k in little endian
+	(data (i32.const 0) "\00\10")
+
+	;; [4, 4100) input buffer
+
+	(func (export "call")
+		;; Receive (key ++ value_to_write)
+		(call $seal_input
+			(i32.const 4)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the input buffer
+		)
+		;; Store the passed value to the passed key and store result to memory
+		(i32.store (i32.const 168)
+			(call $set_storage
+				(i32.const 8)				;; key_ptr
+				(i32.load (i32.const 4))		;; key_len
+				(i32.add				;; value_ptr = 8 + key_len
+					(i32.const 8)
+					(i32.load (i32.const 4)))
+				(i32.sub				;; value_len (input_size - (key_len + key_len_len))
+					(i32.load (i32.const 0))
+					(i32.add
+						(i32.load (i32.const 4))
+						(i32.const 4)
+					)
+				)
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 168)	;; ptr to returned value
+			(i32.const 4)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+		let mut ext = MockExt::default();
+
+		// value did not exist before -> sentinel returned
+		let input = (32, [1u8; 32], [42u8, 48]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), crate::SENTINEL);
+		assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[42u8, 48]);
+
+		// value do exist -> length of old value returned
+		let input = (32, [1u8; 32], [0u8; 0]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), 2);
+		assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[0u8; 0]);
+
+		// value do exist -> length of old value returned (test for zero sized val)
+		let input = (32, [1u8; 32], [99u8]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), 0);
+		assert_eq!(ext.storage.get(&[1u8; 32].to_vec()).unwrap(), &[99u8]);
+	}
+
+	#[test]
+	fn get_storage_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal1" "get_storage" (func $get_storage (param i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 4) size of input buffer (160 bytes as we copy the key+len here)
+	(data (i32.const 0) "\A0")
+
+	;; [4, 8) size of output buffer
+	;; 4k in little endian
+	(data (i32.const 4) "\00\10")
+
+	;; [8, 168) input buffer
+	;; [168, 4264) output buffer
+
+	(func (export "call")
+		;; Receive (key ++ value_to_write)
+		(call $seal_input
+			(i32.const 8)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the input buffer
+		)
+		;; Load a storage value and result of this call into the output buffer
+		(i32.store (i32.const 168)
+			(call $get_storage
+				(i32.const 12)			;; key_ptr
+				(i32.load (i32.const 8))	;; key_len
+				(i32.const 172)			;; Pointer to the output buffer
+				(i32.const 4)			;; Pointer to the size of the buffer
+			)
+		)
+		(call $seal_return
+			(i32.const 0)				;; flags
+			(i32.const 168)				;; output buffer ptr
+			(i32.add				;; length: output size + 4 (retval)
+				(i32.load (i32.const 4))
+				(i32.const 4)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+		let mut ext = MockExt::default();
+
+		ext.set_storage(
+			&Key::<Test>::try_from_var([1u8; 64].to_vec()).unwrap(),
+			Some(vec![42u8]),
+			false,
+		)
+		.unwrap();
+
+		ext.set_storage(
+			&Key::<Test>::try_from_var([2u8; 19].to_vec()).unwrap(),
+			Some(vec![]),
+			false,
+		)
+		.unwrap();
+
+		// value does not exist
+		let input = (63, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(
+			u32::from_le_bytes(result.data[0..4].try_into().unwrap()),
+			ReturnCode::KeyNotFound as u32
+		);
+
+		// value exists
+		let input = (64, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(
+			u32::from_le_bytes(result.data[0..4].try_into().unwrap()),
+			ReturnCode::Success as u32
+		);
+		assert_eq!(ext.storage.get(&[1u8; 64].to_vec()).unwrap(), &[42u8]);
+		assert_eq!(&result.data[4..], &[42u8]);
+
+		// value exists (test for 0 sized)
+		let input = (19, [2u8; 19]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(
+			u32::from_le_bytes(result.data[0..4].try_into().unwrap()),
+			ReturnCode::Success as u32
+		);
+		assert_eq!(ext.storage.get(&[2u8; 19].to_vec()), Some(&vec![]));
+		assert_eq!(&result.data[4..], &([] as [u8; 0]));
+	}
+
+	#[test]
+	fn clear_storage_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal1" "clear_storage" (func $clear_storage (param i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of input buffer
+	;; [0, 4) size of input buffer (128+32 = 160 bytes = 0xA0)
+	(data (i32.const 0) "\A0")
+
+	;; [4, 164) input buffer
+
+	(func (export "call")
+		;; Receive key
+		(call $seal_input
+			(i32.const 4)	;; Where we take input and store it
+			(i32.const 0)	;; Where we take and store the length of thedata
+		)
+		;; Call seal_clear_storage and save what it returns at 0
+		(i32.store (i32.const 0)
+			(call $clear_storage
+				(i32.const 8)			;; key_ptr
+				(i32.load (i32.const 4))	;; key_len
+			)
+		)
+		(call $seal_return
+			(i32.const 0)	;; flags
+			(i32.const 0)	;; returned value
+			(i32.const 4)	;; length of returned value
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+		let mut ext = MockExt::default();
+
+		ext.set_storage(
+			&Key::<Test>::try_from_var([1u8; 64].to_vec()).unwrap(),
+			Some(vec![42u8]),
+			false,
+		)
+		.unwrap();
+		ext.set_storage(
+			&Key::<Test>::try_from_var([2u8; 19].to_vec()).unwrap(),
+			Some(vec![]),
+			false,
+		)
+		.unwrap();
+
+		// value did not exist
+		let input = (32, [3u8; 32]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		// sentinel returned
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), crate::SENTINEL);
+		assert_eq!(ext.storage.get(&[3u8; 32].to_vec()), None);
+
+		// value did exist
+		let input = (64, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		// length returned
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), 1);
+		// value cleared
+		assert_eq!(ext.storage.get(&[1u8; 64].to_vec()), None);
+
+		//value did not exist (wrong key length)
+		let input = (63, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		// sentinel returned
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), crate::SENTINEL);
+		assert_eq!(ext.storage.get(&[1u8; 64].to_vec()), None);
+
+		// value exists
+		let input = (19, [2u8; 19]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		// length returned (test for 0 sized)
+		assert_eq!(u32::from_le_bytes(result.data.try_into().unwrap()), 0);
+		// value cleared
+		assert_eq!(ext.storage.get(&[2u8; 19].to_vec()), None);
+	}
+
+	#[test]
+	fn take_storage_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "seal0" "seal_input" (func $seal_input (param i32 i32)))
+	(import "seal0" "take_storage" (func $take_storage (param i32 i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 4) size of input buffer (160 bytes as we copy the key+len here)
+	(data (i32.const 0) "\A0")
+
+	;; [4, 8) size of output buffer
+	;; 4k in little endian
+	(data (i32.const 4) "\00\10")
+
+	;; [8, 168) input buffer
+	;; [168, 4264) output buffer
+
+	(func (export "call")
+		;; Receive key
+		(call $seal_input
+			(i32.const 8)	;; Pointer to the input buffer
+			(i32.const 0)	;; Size of the length buffer
+		)
+
+		;; Load a storage value and result of this call into the output buffer
+		(i32.store (i32.const 168)
+			(call $take_storage
+				(i32.const 12)			;; key_ptr
+				(i32.load (i32.const 8))	;; key_len
+				(i32.const 172)			;; Pointer to the output buffer
+				(i32.const 4)			;; Pointer to the size of the buffer
+			)
+		)
+
+		;; Return the contents of the buffer
+		(call $seal_return
+			(i32.const 0)				;; flags
+			(i32.const 168)				;; output buffer ptr
+			(i32.add				;; length: storage size + 4 (retval)
+				(i32.load (i32.const 4))
+				(i32.const 4)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+		let mut ext = MockExt::default();
+
+		ext.set_storage(
+			&Key::<Test>::try_from_var([1u8; 64].to_vec()).unwrap(),
+			Some(vec![42u8]),
+			false,
+		)
+		.unwrap();
+
+		ext.set_storage(
+			&Key::<Test>::try_from_var([2u8; 19].to_vec()).unwrap(),
+			Some(vec![]),
+			false,
+		)
+		.unwrap();
+
+		// value does not exist -> error returned
+		let input = (63, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(
+			u32::from_le_bytes(result.data[0..4].try_into().unwrap()),
+			ReturnCode::KeyNotFound as u32
+		);
+
+		// value did exist -> value returned
+		let input = (64, [1u8; 64]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(
+			u32::from_le_bytes(result.data[0..4].try_into().unwrap()),
+			ReturnCode::Success as u32
+		);
+		assert_eq!(ext.storage.get(&[1u8; 64].to_vec()), None);
+		assert_eq!(&result.data[4..], &[42u8]);
+
+		// value did exist -> length returned (test for 0 sized)
+		let input = (19, [2u8; 19]).encode();
+		let result = execute(CODE, input, &mut ext).unwrap();
+		assert_eq!(
+			u32::from_le_bytes(result.data[0..4].try_into().unwrap()),
+			ReturnCode::Success as u32
+		);
+		assert_eq!(ext.storage.get(&[2u8; 19].to_vec()), None);
+		assert_eq!(&result.data[4..], &[0u8; 0]);
+	}
+
+	#[test]
+	fn is_contract_works() {
+		const CODE_IS_CONTRACT: &str = r#"
+;; This runs `is_contract` check on zero account address
+(module
+	(import "seal0" "seal_is_contract" (func $seal_is_contract (param i32) (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 32) zero-adress
+	(data (i32.const 0)
+		"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+		"\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+	)
+
+	;; [32, 36) here we store the return code of the `seal_is_contract`
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(i32.store
+			(i32.const 32)
+			(call $seal_is_contract
+				(i32.const 0) ;; ptr to destination address
+			)
+		)
+		;; exit with success and take `seal_is_contract` return code to the output buffer
+		(call $seal_return (i32.const 0) (i32.const 32) (i32.const 4))
+	)
+)
+"#;
+		let output = execute(CODE_IS_CONTRACT, vec![], MockExt::default()).unwrap();
+
+		// The mock ext just always returns 1u32 (`true`).
+		assert_eq!(output, ExecReturnValue { flags: ReturnFlags::empty(), data: 1u32.encode() },);
+	}
+
+	#[test]
+	fn code_hash_works() {
+		/// calls `seal_code_hash` and compares the result with the constant.
+		const CODE_CODE_HASH: &str = r#"
+(module
+	(import "seal0" "seal_code_hash" (func $seal_code_hash (param i32 i32 i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; fill the buffer with the code hash.
+		(call $seal_code_hash
+			(i32.const 0) ;; input: address_ptr (before call)
+			(i32.const 0) ;; output: code_hash_ptr (after call)
+			(i32.const 32) ;; same 32 bytes length for input and output
+		)
+
+		;; assert size == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 32)
+			)
+		)
+
+		;; assert that the first 8 bytes are "1111111111111111"
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 0x1111111111111111)
+			)
+		)
+		drop
+	)
+
+	(func (export "deploy"))
+)
+"#;
+		assert_ok!(execute(CODE_CODE_HASH, vec![], MockExt::default()));
+	}
+
+	#[test]
+	fn own_code_hash_works() {
+		/// calls `seal_own_code_hash` and compares the result with the constant.
+		const CODE_OWN_CODE_HASH: &str = r#"
+(module
+	(import "seal0" "seal_own_code_hash" (func $seal_own_code_hash (param i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; size of our buffer is 32 bytes
+	(data (i32.const 32) "\20")
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+
+	(func (export "call")
+		;; fill the buffer with the code hash
+		(call $seal_own_code_hash
+			(i32.const 0)  ;; output: code_hash_ptr
+			(i32.const 32) ;; 32 bytes length of code_hash output
+		)
+
+		;; assert size == 32
+		(call $assert
+			(i32.eq
+				(i32.load (i32.const 32))
+				(i32.const 32)
+			)
+		)
+
+		;; assert that the first 8 bytes are "1010101010101010"
+		(call $assert
+			(i64.eq
+				(i64.load (i32.const 0))
+				(i64.const 0x1010101010101010)
+			)
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+		assert_ok!(execute(CODE_OWN_CODE_HASH, vec![], MockExt::default()));
+	}
+
+	#[test]
+	fn caller_is_origin_works() {
+		const CODE_CALLER_IS_ORIGIN: &str = r#"
+;; This runs `caller_is_origin` check on zero account address
+(module
+	(import "seal0" "seal_caller_is_origin" (func $seal_caller_is_origin (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 4) here the return code of the `seal_caller_is_origin` will be stored
+	;; we initialize it with non-zero value to be sure that it's being overwritten below
+	(data (i32.const 0) "\10\10\10\10")
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(i32.store
+			(i32.const 0)
+			(call $seal_caller_is_origin)
+		)
+		;; exit with success and take `seal_caller_is_origin` return code to the output buffer
+		(call $seal_return (i32.const 0) (i32.const 0) (i32.const 4))
+	)
+)
+"#;
+		let output = execute(CODE_CALLER_IS_ORIGIN, vec![], MockExt::default()).unwrap();
+
+		// The mock ext just always returns 0u32 (`false`)
+		assert_eq!(output, ExecReturnValue { flags: ReturnFlags::empty(), data: 0u32.encode() },);
+	}
+
+	#[test]
+	fn caller_is_root_works() {
+		const CODE_CALLER_IS_ROOT: &str = r#"
+;; This runs `caller_is_root` check on zero account address
+(module
+	(import "seal0" "caller_is_root" (func $caller_is_root (result i32)))
+	(import "seal0" "seal_return" (func $seal_return (param i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	;; [0, 4) here the return code of the `caller_is_root` will be stored
+	;; we initialize it with non-zero value to be sure that it's being overwritten below
+	(data (i32.const 0) "\10\10\10\10")
+
+	(func (export "deploy"))
+
+	(func (export "call")
+		(i32.store
+			(i32.const 0)
+			(call $caller_is_root)
+		)
+		;; exit with success and take `caller_is_root` return code to the output buffer
+		(call $seal_return (i32.const 0) (i32.const 0) (i32.const 4))
+	)
+)
+"#;
+		// The default `caller` is ALICE. Therefore not root.
+		let output = execute(CODE_CALLER_IS_ROOT, vec![], MockExt::default()).unwrap();
+		assert_eq!(output, ExecReturnValue { flags: ReturnFlags::empty(), data: 0u32.encode() },);
+
+		// The caller is forced to be root instead of using the default ALICE.
+		let output = execute(
+			CODE_CALLER_IS_ROOT,
+			vec![],
+			MockExt { caller: Origin::Root, ..MockExt::default() },
+		)
+		.unwrap();
+		assert_eq!(output, ExecReturnValue { flags: ReturnFlags::empty(), data: 1u32.encode() },);
+	}
+
+	#[test]
+	fn set_code_hash() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "seal_set_code_hash" (func $seal_set_code_hash (param i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+	(func (export "call")
+		(local $exit_code i32)
+		(set_local $exit_code
+			(call $seal_set_code_hash (i32.const 0))
+		)
+		(call $assert
+			(i32.eq (get_local $exit_code) (i32.const 0)) ;; ReturnCode::Success
+		)
+	)
+
+	(func (export "deploy"))
+
+	;; Hash of code.
+	(data (i32.const 0)
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+		"\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11\11"
+	)
+)
+"#;
+
+		let mut mock_ext = MockExt::default();
+		execute(CODE, [0u8; 32].encode(), &mut mock_ext).unwrap();
+
+		assert_eq!(mock_ext.code_hashes.pop().unwrap(), H256::from_slice(&[17u8; 32]));
+	}
+
+	#[test]
+	fn reentrance_count_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "reentrance_count" (func $reentrance_count (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+	(func (export "call")
+		(local $return_val i32)
+		(set_local $return_val
+			(call $reentrance_count)
+		)
+		(call $assert
+			(i32.eq (get_local $return_val) (i32.const 12))
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+		let mut mock_ext = MockExt::default();
+		execute(CODE, vec![], &mut mock_ext).unwrap();
+	}
+
+	#[test]
+	fn account_reentrance_count_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "account_reentrance_count" (func $account_reentrance_count (param i32) (result i32)))
+	(import "env" "memory" (memory 1 1))
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+	(func (export "call")
+		(local $return_val i32)
+		(set_local $return_val
+			(call $account_reentrance_count (i32.const 0))
+		)
+		(call $assert
+			(i32.eq (get_local $return_val) (i32.const 12))
+		)
+	)
+
+	(func (export "deploy"))
+)
+"#;
+
+		let mut mock_ext = MockExt::default();
+		execute(CODE, vec![], &mut mock_ext).unwrap();
+	}
+
+	#[test]
+	fn instantiation_nonce_works() {
+		const CODE: &str = r#"
+(module
+	(import "seal0" "instantiation_nonce" (func $nonce (result i64)))
+	(import "env" "memory" (memory 1 1))
+
+	(func $assert (param i32)
+		(block $ok
+			(br_if $ok
+				(get_local 0)
+			)
+			(unreachable)
+		)
+	)
+	(func (export "call")
+		(call $assert
+			(i64.eq (call $nonce) (i64.const 995))
+		)
+	)
+	(func (export "deploy"))
+)
+"#;
+
+		let mut mock_ext = MockExt::default();
+		execute(CODE, vec![], &mut mock_ext).unwrap();
+	}
+
+	/// This test check that an unstable interface cannot be deployed. In case of runtime
+	/// benchmarks we always allow unstable interfaces. This is why this test does not
+	/// work when this feature is enabled.
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	#[test]
+	fn cannot_deploy_unstable() {
+		const CANNOT_DEPLOY_UNSTABLE: &str = r#"
+(module
+	(import "seal0" "reentrance_count" (func $reentrance_count (result i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call"))
+	(func (export "deploy"))
+)
+"#;
+		assert_err!(
+			execute_no_unstable(CANNOT_DEPLOY_UNSTABLE, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+		assert_ok!(execute(CANNOT_DEPLOY_UNSTABLE, vec![], MockExt::default()));
+	}
+
+	/// The random interface is deprecated and hence new contracts using it should not be deployed.
+	/// In case of runtime benchmarks we always allow deprecated interfaces. This is why this
+	/// test doesn't work if this feature is enabled.
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	#[test]
+	fn cannot_deploy_deprecated() {
+		const CODE_RANDOM_0: &str = r#"
+(module
+	(import "seal0" "seal_random" (func $seal_random (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call"))
+	(func (export "deploy"))
+)
+	"#;
+		const CODE_RANDOM_1: &str = r#"
+(module
+	(import "seal1" "seal_random" (func $seal_random (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call"))
+	(func (export "deploy"))
+)
+	"#;
+		const CODE_RANDOM_2: &str = r#"
+(module
+	(import "seal0" "random" (func $seal_random (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call"))
+	(func (export "deploy"))
+)
+	"#;
+		const CODE_RANDOM_3: &str = r#"
+(module
+	(import "seal1" "random" (func $seal_random (param i32 i32 i32 i32)))
+	(import "env" "memory" (memory 1 1))
+
+	(func (export "call"))
+	(func (export "deploy"))
+)
+	"#;
+
+		assert_ok!(execute_unvalidated(CODE_RANDOM_0, vec![], MockExt::default()));
+		assert_err!(
+			execute_instantiate_unvalidated(CODE_RANDOM_0, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+		assert_err!(
+			execute(CODE_RANDOM_0, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+
+		assert_ok!(execute_unvalidated(CODE_RANDOM_1, vec![], MockExt::default()));
+		assert_err!(
+			execute_instantiate_unvalidated(CODE_RANDOM_1, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+		assert_err!(
+			execute(CODE_RANDOM_1, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+
+		assert_ok!(execute_unvalidated(CODE_RANDOM_2, vec![], MockExt::default()));
+		assert_err!(
+			execute_instantiate_unvalidated(CODE_RANDOM_2, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+		assert_err!(
+			execute(CODE_RANDOM_2, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+
+		assert_ok!(execute_unvalidated(CODE_RANDOM_3, vec![], MockExt::default()));
+		assert_err!(
+			execute_instantiate_unvalidated(CODE_RANDOM_3, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+		assert_err!(
+			execute(CODE_RANDOM_3, vec![], MockExt::default()),
+			<Error<Test>>::CodeRejected,
+		);
+	}
+
+	#[test]
+	fn add_remove_delegate_dependency() {
+		const CODE_ADD_REMOVE_DELEGATE_DEPENDENCY: &str = r#"
+(module
+	(import "seal0" "add_delegate_dependency" (func $add_delegate_dependency (param i32)))
+	(import "seal0" "remove_delegate_dependency" (func $remove_delegate_dependency (param i32)))
+	(import "env" "memory" (memory 1 1))
+	(func (export "call")
+		(call $add_delegate_dependency (i32.const 0))
+		(call $add_delegate_dependency (i32.const 32))
+		(call $remove_delegate_dependency (i32.const 32))
+	)
+	(func (export "deploy"))
+
+	;;  hash1 (32 bytes)
+	(data (i32.const 0)
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+		"\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01"
+	)
+
+	;;  hash2 (32 bytes)
+	(data (i32.const 32)
+		"\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02"
+		"\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02"
+	)
+)
+"#;
+		let mut mock_ext = MockExt::default();
+		assert_ok!(execute(&CODE_ADD_REMOVE_DELEGATE_DEPENDENCY, vec![], &mut mock_ext));
+		let delegate_dependencies: Vec<_> =
+			mock_ext.delegate_dependencies.into_inner().into_iter().collect();
+		assert_eq!(delegate_dependencies.len(), 1);
+		assert_eq!(delegate_dependencies[0].as_bytes(), [1; 32]);
+	}
+}
diff --git a/substrate/frame/contracts/src/wasm/prepare.rs b/substrate/frame/contracts/src/wasm/prepare.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b129c17e13eca5cbef72c40387a9f86d81fa3515
--- /dev/null
+++ b/substrate/frame/contracts/src/wasm/prepare.rs
@@ -0,0 +1,824 @@
+// 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 module takes care of loading, checking and preprocessing of a
+//! wasm module before execution. It also extracts some essential information
+//! from a module.
+
+use crate::{
+	chain_extension::ChainExtension,
+	storage::meter::Diff,
+	wasm::{
+		runtime::AllowDeprecatedInterface, CodeInfo, Determinism, Environment, WasmBlob,
+		BYTES_PER_PAGE,
+	},
+	AccountIdOf, CodeVec, Config, Error, Schedule, LOG_TARGET,
+};
+use codec::MaxEncodedLen;
+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,
+};
+
+/// Imported memory must be located inside this module. The reason for hardcoding is that current
+/// compiler toolchains might not support specifying other modules than "env" for memory imports.
+pub const IMPORT_MODULE_MEMORY: &str = "env";
+
+/// The inner deserialized module is valid and contains only allowed WebAssembly features.
+/// This is checked by loading it into wasmi interpreter `engine`.
+pub struct LoadedModule {
+	pub module: Module,
+	pub engine: Engine,
+}
+
+impl LoadedModule {
+	/// Creates a new instance of `LoadedModule`.
+	///
+	/// The inner Wasm module is checked not to have restricted WebAssembly proposals.
+	/// Returns `Err` if the `code` cannot be deserialized or if it contains an invalid module.
+	pub fn new<T>(
+		code: &[u8],
+		determinism: Determinism,
+		stack_limits: Option<StackLimits>,
+	) -> 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.
+		let mut config = WasmiConfig::default();
+		config
+			.wasm_multi_value(false)
+			.wasm_mutable_global(false)
+			.wasm_sign_extension(true)
+			.wasm_bulk_memory(false)
+			.wasm_reference_types(false)
+			.wasm_tail_call(false)
+			.wasm_extended_const(false)
+			.wasm_saturating_float_to_int(false)
+			.floats(matches!(determinism, Determinism::Relaxed))
+			.consume_fuel(true)
+			.fuel_consumption_mode(FuelConsumptionMode::Eager);
+
+		if let Some(stack_limits) = stack_limits {
+			config.set_stack_limits(stack_limits);
+		}
+
+		let engine = Engine::new(&config);
+		let module =
+			Module::new(&engine, code.clone()).map_err(|_| "Can't load the module into wasmi!")?;
+
+		// Return a `LoadedModule` instance with
+		// __valid__ module.
+		Ok(LoadedModule { module, engine })
+	}
+
+	/// Check that the module has required exported functions. For now
+	/// these are just entrypoints:
+	///
+	/// - 'call'
+	/// - 'deploy'
+	///
+	/// Any other exports are not allowed.
+	fn scan_exports(&self) -> Result<(), &'static str> {
+		let mut deploy_found = false;
+		let mut call_found = false;
+		let module = &self.module;
+		let exports = module.exports();
+
+		for export in exports {
+			match export.ty() {
+				ExternType::Func(ft) => {
+					match export.name() {
+						"call" => call_found = true,
+						"deploy" => deploy_found = true,
+						_ =>
+							return Err(
+								"unknown function export: expecting only deploy and call functions",
+							),
+					}
+					// Check the signature.
+					// Both "call" and "deploy" have the () -> () function type.
+					// We still support () -> (i32) for backwards compatibility.
+					if !(ft.params().is_empty() &&
+						(ft.results().is_empty() || ft.results() == [WasmiValueType::I32]))
+					{
+						return Err("entry point has wrong signature")
+					}
+				},
+				ExternType::Memory(_) => return Err("memory export is forbidden"),
+				ExternType::Global(_) => return Err("global export is forbidden"),
+				ExternType::Table(_) => return Err("table export is forbidden"),
+			}
+		}
+
+		if !deploy_found {
+			return Err("deploy function isn't exported")
+		}
+		if !call_found {
+			return Err("call function isn't exported")
+		}
+
+		Ok(())
+	}
+
+	/// Scan an import section if any.
+	///
+	/// This makes sure that:
+	/// - The import section looks as we expect it from a contract.
+	/// - The limits of the memory type declared by the contract comply with the Schedule.
+	///
+	/// Returns the checked memory limits back to caller.
+	///
+	/// This method fails if:
+	///
+	/// - Memory import not found in the module.
+	/// - Tables or globals found among imports.
+	/// - `call_chain_extension` host function is imported, while chain extensions are disabled.
+	///
+	/// NOTE that only single memory instance is allowed for contract modules, which is enforced by
+	/// this check combined with multi_memory proposal gets disabled in the engine.
+	pub fn scan_imports<T: Config>(
+		&self,
+		schedule: &Schedule<T>,
+	) -> Result<(u32, u32), &'static str> {
+		let module = &self.module;
+		let imports = module.imports();
+		let mut memory_limits = None;
+
+		for import in imports {
+			match *import.ty() {
+				ExternType::Table(_) => return Err("Cannot import tables"),
+				ExternType::Global(_) => return Err("Cannot import globals"),
+				ExternType::Func(_) => {
+					let _ = import.ty().func().ok_or("expected a function")?;
+
+					if !<T as Config>::ChainExtension::enabled() &&
+						(import.name().as_bytes() == b"seal_call_chain_extension" ||
+							import.name().as_bytes() == b"call_chain_extension")
+					{
+						return Err("Module uses chain extensions but chain extensions are disabled")
+					}
+				},
+				ExternType::Memory(mt) => {
+					if import.module().as_bytes() != IMPORT_MODULE_MEMORY.as_bytes() {
+						return Err("Invalid module for imported memory")
+					}
+					if import.name().as_bytes() != b"memory" {
+						return Err("Memory import must have the field name 'memory'")
+					}
+					if memory_limits.is_some() {
+						return Err("Multiple memory imports defined")
+					}
+					// Parse memory limits defaulting it to (0,0).
+					// Any access to it will then lead to out of bounds trap.
+					let (initial, maximum) = (
+						mt.initial_pages().to_bytes().unwrap_or(0).saturating_div(BYTES_PER_PAGE)
+							as u32,
+						mt.maximum_pages().map_or(schedule.limits.memory_pages, |p| {
+							p.to_bytes().unwrap_or(0).saturating_div(BYTES_PER_PAGE) as u32
+						}),
+					);
+					if initial > maximum {
+						return Err(
+						"Requested initial number of memory pages should not exceed the requested maximum",
+					)
+					}
+					if maximum > schedule.limits.memory_pages {
+						return Err("Maximum number of memory pages should not exceed the maximum configured in the Schedule")
+					}
+
+					memory_limits = Some((initial, maximum));
+					continue
+				},
+			}
+		}
+
+		memory_limits.ok_or("No memory import found in the module")
+	}
+}
+
+/// Check that given `code` satisfies constraints required for the contract Wasm module.
+/// This includes two groups of checks:
+///
+/// 1. General engine-side validation makes sure the module is consistent and does not contain
+///    forbidden WebAssembly features.
+/// 2. Additional checks which are specific to smart contracts eligible for this pallet.
+fn validate<E, T>(
+	code: &[u8],
+	schedule: &Schedule<T>,
+	determinism: Determinism,
+) -> Result<(), (DispatchError, &'static str)>
+where
+	E: Environment<()>,
+	T: Config,
+{
+	(|| {
+		// We check that the module is generally valid,
+		// and does not have restricted WebAssembly features, here.
+		let contract_module = LoadedModule::new::<T>(code, determinism, None)?;
+		// The we check that module satisfies constraints the pallet puts on contracts.
+		contract_module.scan_exports()?;
+		contract_module.scan_imports::<T>(schedule)?;
+		Ok(())
+	})()
+	.map_err(|msg: &str| {
+		log::debug!(target: LOG_TARGET, "New code rejected on validation: {}", msg);
+		(Error::<T>::CodeRejected.into(), msg)
+	})?;
+
+	// This will make sure that the module can be actually run within wasmi:
+	//
+	// - It doesn't use any unknown imports.
+	// - It doesn't explode the wasmi bytecode generation.
+	//
+	// We don't actually ever execute this instance so we can get away with a minimal stack which
+	// reduces the amount of memory that needs to be zeroed.
+	let stack_limits = StackLimits::new(1, 1, 0).expect("initial <= max; qed");
+	WasmBlob::<T>::instantiate::<E, _>(
+		&code,
+		(),
+		schedule,
+		determinism,
+		stack_limits,
+		AllowDeprecatedInterface::No,
+	)
+	.map_err(|err| {
+		log::debug!(target: LOG_TARGET, "{}", err);
+		(Error::<T>::CodeRejected.into(), "New code rejected on wasmi instantiation!")
+	})?;
+
+	Ok(())
+}
+
+/// Validates the given binary `code` is a valid Wasm module satisfying following constraints:
+///
+/// - The module doesn't export any memory.
+/// - The module does imports memory, which limits lay within the limits permitted by the
+///   `schedule`.
+/// - All imported functions from the external environment match defined by `env` module.
+///
+/// Also constructs contract `code_info` by calculating the storage deposit.
+pub fn prepare<E, T>(
+	code: CodeVec<T>,
+	schedule: &Schedule<T>,
+	owner: AccountIdOf<T>,
+	determinism: Determinism,
+) -> Result<WasmBlob<T>, (DispatchError, &'static str)>
+where
+	E: Environment<()>,
+	T: Config,
+{
+	validate::<E, T>(code.as_ref(), schedule, determinism)?;
+
+	// Calculate deposit for storing contract code and `code_info` in two different storage items.
+	let code_len = code.len() as u32;
+	let bytes_added = code_len.saturating_add(<CodeInfo<T>>::max_encoded_len() as u32);
+	let deposit = Diff { bytes_added, items_added: 2, ..Default::default() }
+		.update_contract::<T>(None)
+		.charge_or_zero();
+	let code_info = CodeInfo { owner, deposit, determinism, refcount: 0, code_len };
+	let code_hash = T::Hashing::hash(&code);
+
+	Ok(WasmBlob { code, code_info, code_hash })
+}
+
+/// Alternate (possibly unsafe) preparation functions used only for benchmarking and testing.
+///
+/// For benchmarking we need to construct special contracts that might not pass our
+/// sanity checks. We hide functions allowing this behind a feature that is only set during
+/// benchmarking or testing to prevent usage in production code.
+#[cfg(any(test, feature = "runtime-benchmarks"))]
+pub mod benchmarking {
+	use super::*;
+
+	/// Prepare function that does not perform export section checks on the passed in code.
+	pub fn prepare<T: Config>(
+		code: Vec<u8>,
+		schedule: &Schedule<T>,
+		owner: AccountIdOf<T>,
+	) -> Result<WasmBlob<T>, DispatchError> {
+		let determinism = Determinism::Enforced;
+		let contract_module = LoadedModule::new::<T>(&code, determinism, None)?;
+		let _ = contract_module.scan_imports::<T>(schedule)?;
+		let code: CodeVec<T> = code.try_into().map_err(|_| <Error<T>>::CodeTooLarge)?;
+		let code_info = CodeInfo {
+			owner,
+			// this is a helper function for benchmarking which skips deposit collection
+			deposit: Default::default(),
+			refcount: 0,
+			code_len: code.len() as u32,
+			determinism,
+		};
+		let code_hash = T::Hashing::hash(&code);
+
+		Ok(WasmBlob { code, code_info, code_hash })
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		exec::Ext,
+		schedule::Limits,
+		tests::{Test, ALICE},
+	};
+	use pallet_contracts_proc_macro::define_env;
+	use std::fmt;
+
+	impl fmt::Debug for WasmBlob<Test> {
+		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+			write!(f, "ContractCode {{ .. }}")
+		}
+	}
+
+	/// Using unreachable statements triggers unreachable warnings in the generated code
+	#[allow(unreachable_code)]
+	mod env {
+		use super::*;
+		use crate::wasm::runtime::{AllowDeprecatedInterface, AllowUnstableInterface, TrapReason};
+
+		// Define test environment for tests. We need ImportSatisfyCheck
+		// implementation from it. So actual implementations doesn't matter.
+		#[define_env]
+		pub mod test_env {
+			fn panic(_ctx: _, _memory: _) -> Result<(), TrapReason> {
+				Ok(())
+			}
+
+			// gas is an implementation defined function and a contract can't import it.
+			fn gas(_ctx: _, _memory: _, _amount: u64) -> Result<(), TrapReason> {
+				Ok(())
+			}
+
+			fn nop(_ctx: _, _memory: _, _unused: u64) -> Result<(), TrapReason> {
+				Ok(())
+			}
+
+			// new version of nop with other data type for argument
+			#[version(1)]
+			fn nop(_ctx: _, _memory: _, _unused: i32) -> Result<(), TrapReason> {
+				Ok(())
+			}
+		}
+	}
+
+	macro_rules! prepare_test {
+		($name:ident, $wat:expr, $($expected:tt)*) => {
+			#[test]
+			fn $name() {
+				let wasm = wat::parse_str($wat).unwrap().try_into().unwrap();
+				let schedule = Schedule {
+					limits: Limits {
+					    globals: 3,
+					    locals: 3,
+						parameters: 3,
+						memory_pages: 16,
+						table_size: 3,
+						br_table_size: 3,
+						.. Default::default()
+					},
+					.. Default::default()
+				};
+				let r = prepare::<env::Env, Test>(
+					wasm,
+					&schedule,
+					ALICE,
+					Determinism::Enforced,
+				);
+				assert_matches::assert_matches!(r.map_err(|(_, msg)| msg), $($expected)*);
+			}
+		};
+	}
+
+	prepare_test!(
+		no_floats,
+		r#"
+		(module
+			(func (export "call")
+				(drop
+					(f32.add
+						(f32.const 0)
+						(f32.const 1)
+					)
+				)
+			)
+			(func (export "deploy"))
+		)"#,
+		Err("Can't load the module into wasmi!")
+	);
+
+	mod memories {
+		use super::*;
+
+		prepare_test!(
+			memory_with_one_page,
+			r#"
+			(module
+				(import "env" "memory" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Ok(_)
+		);
+
+		prepare_test!(
+			internal_memory_declaration,
+			r#"
+			(module
+				(memory 1 1)
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("No memory import found in the module")
+		);
+
+		prepare_test!(
+			no_memory_import,
+			r#"
+			(module
+				;; no memory imported
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)"#,
+			Err("No memory import found in the module")
+		);
+
+		prepare_test!(
+			initial_exceeds_maximum,
+			r#"
+			(module
+				(import "env" "memory" (memory 16 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Can't load the module into wasmi!")
+		);
+
+		prepare_test!(
+			requested_maximum_valid,
+			r#"
+			(module
+				(import "env" "memory" (memory 1 16))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Ok(_)
+		);
+
+		prepare_test!(
+			requested_maximum_exceeds_configured_maximum,
+			r#"
+			(module
+				(import "env" "memory" (memory 1 17))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Maximum number of memory pages should not exceed the maximum configured in the Schedule")
+		);
+
+		prepare_test!(
+			field_name_not_memory,
+			r#"
+			(module
+				(import "env" "forgetit" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Memory import must have the field name 'memory'")
+		);
+
+		prepare_test!(
+			multiple_memory_imports,
+			r#"
+			(module
+				(import "env" "memory" (memory 1 1))
+				(import "env" "memory" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Can't load the module into wasmi!")
+		);
+
+		prepare_test!(
+			table_import,
+			r#"
+			(module
+				(import "seal0" "table" (table 1 anyfunc))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Cannot import tables")
+		);
+
+		prepare_test!(
+			global_import,
+			r#"
+			(module
+				(global $g (import "seal0" "global") i32)
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Cannot import globals")
+		);
+	}
+
+	mod imports {
+		use super::*;
+
+		prepare_test!(
+			can_import_legit_function,
+			r#"
+			(module
+				(import "seal0" "nop" (func (param i64)))
+				(import "env" "memory" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Ok(_)
+		);
+
+		// memory is in "env" and not in "seal0"
+		prepare_test!(
+			memory_not_in_seal0,
+			r#"
+			(module
+				(import "seal0" "memory" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Invalid module for imported memory")
+		);
+
+		// Memory is in "env" and not in some arbitrary module
+		prepare_test!(
+			memory_not_in_arbitrary_module,
+			r#"
+			(module
+				(import "any_module" "memory" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Invalid module for imported memory")
+		);
+
+		prepare_test!(
+			function_in_other_module_works,
+			r#"
+			(module
+				(import "seal1" "nop" (func (param i32)))
+				(import "env" "memory" (memory 1 1))
+
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Ok(_)
+		);
+
+		prepare_test!(
+			wrong_signature,
+			r#"
+			(module
+				(import "seal0" "input" (func (param i64)))
+				(import "env" "memory" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("New code rejected on wasmi instantiation!")
+		);
+
+		prepare_test!(
+			unknown_func_name,
+			r#"
+			(module
+				(import "seal0" "unknown_func" (func))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("No memory import found in the module")
+		);
+
+		// Try to import function from not a "seal*" module.
+		prepare_test!(
+			try_import_from_wrong_module,
+			r#"
+			(module
+				(import "env" "panic" (func))
+				(import "env" "memory" (memory 1 1))
+
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("New code rejected on wasmi instantiation!")
+		);
+	}
+
+	mod entrypoints {
+		use super::*;
+
+		prepare_test!(
+			it_works,
+			r#"
+			(module
+				(import "env" "memory" (memory 1 1))
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Ok(_)
+		);
+
+		prepare_test!(
+			signed_extension_works,
+			r#"
+			(module
+				(import "env" "memory" (memory 1 1))
+				(func (export "deploy"))
+				(func (export "call"))
+				(func (param i32) (result i32)
+					local.get 0
+					i32.extend8_s
+				)
+			)
+			"#,
+			Ok(_)
+		);
+
+		prepare_test!(
+			omit_memory,
+			r#"
+			(module
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("No memory import found in the module")
+		);
+
+		prepare_test!(
+			omit_deploy,
+			r#"
+			(module
+				(func (export "call"))
+			)
+			"#,
+			Err("deploy function isn't exported")
+		);
+
+		prepare_test!(
+			omit_call,
+			r#"
+			(module
+				(func (export "deploy"))
+			)
+			"#,
+			Err("call function isn't exported")
+		);
+
+		// Try to use imported function as an entry point.
+		// This is allowed.
+		prepare_test!(
+			try_sneak_export_as_entrypoint,
+			r#"
+			(module
+				(import "seal0" "panic" (func))
+				(import "env" "memory" (memory 1 1))
+
+				(func (export "deploy"))
+
+				(export "call" (func 0))
+			)
+			"#,
+			Ok(_)
+		);
+
+		// Try to use global as an entry point.
+		prepare_test!(
+			try_sneak_export_as_global,
+			r#"
+			(module
+				(func (export "deploy"))
+				(global (export "call") i32 (i32.const 0))
+			)
+			"#,
+			Err("global export is forbidden")
+		);
+
+		prepare_test!(
+			wrong_signature,
+			r#"
+			(module
+				(func (export "deploy"))
+				(func (export "call") (param i32))
+			)
+			"#,
+			Err("entry point has wrong signature")
+		);
+
+		prepare_test!(
+			unknown_exports,
+			r#"
+			(module
+				(func (export "call"))
+				(func (export "deploy"))
+				(func (export "whatevs"))
+			)
+			"#,
+			Err("unknown function export: expecting only deploy and call functions")
+		);
+
+		prepare_test!(
+			global_float,
+			r#"
+			(module
+				(global $x f32 (f32.const 0))
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Can't load the module into wasmi!")
+		);
+
+		prepare_test!(
+			local_float,
+			r#"
+			(module
+				(func $foo (local f32))
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Can't load the module into wasmi!")
+		);
+
+		prepare_test!(
+			param_float,
+			r#"
+			(module
+				(func $foo (param f32))
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Can't load the module into wasmi!")
+		);
+
+		prepare_test!(
+			result_float,
+			r#"
+			(module
+				(func $foo (result f32) (f32.const 0))
+				(func (export "call"))
+				(func (export "deploy"))
+			)
+			"#,
+			Err("Can't load the module into wasmi!")
+		);
+	}
+}
diff --git a/substrate/frame/contracts/src/wasm/runtime.rs b/substrate/frame/contracts/src/wasm/runtime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ca23ab9fe5dd0205bc437773b1628e60545ea99b
--- /dev/null
+++ b/substrate/frame/contracts/src/wasm/runtime.rs
@@ -0,0 +1,2856 @@
+// 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.
+
+//! Environment definition of the wasm smart-contract runtime.
+
+use crate::{
+	exec::{ExecError, ExecResult, Ext, Key, TopicOf},
+	gas::{ChargedAmount, Token},
+	schedule::HostFnWeights,
+	BalanceOf, CodeHash, Config, DebugBufferVec, Error, SENTINEL,
+};
+
+use bitflags::bitflags;
+use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen};
+use frame_support::{dispatch::DispatchError, ensure, traits::Get, weights::Weight};
+use pallet_contracts_primitives::{ExecReturnValue, ReturnFlags};
+use pallet_contracts_proc_macro::define_env;
+use sp_io::hashing::{blake2_128, blake2_256, keccak_256, sha2_256};
+use sp_runtime::{
+	traits::{Bounded, Zero},
+	RuntimeDebug,
+};
+use sp_std::{fmt, prelude::*};
+use wasmi::{core::HostError, errors::LinkerError, Linker, Memory, Store};
+
+/// The maximum nesting depth a contract can use when encoding types.
+const MAX_DECODE_NESTING: u32 = 256;
+
+/// Passed to [`Environment`] to determine whether it should expose deprecated interfaces.
+pub enum AllowDeprecatedInterface {
+	/// No deprecated interfaces are exposed.
+	No,
+	/// Deprecated interfaces are exposed.
+	Yes,
+}
+
+/// Passed to [`Environment`] to determine whether it should expose unstable interfaces.
+pub enum AllowUnstableInterface {
+	/// No unstable interfaces are exposed.
+	No,
+	/// Unstable interfaces are exposed.
+	Yes,
+}
+
+/// Trait implemented by the [`define_env`](pallet_contracts_proc_macro::define_env) macro for the
+/// emitted `Env` struct.
+pub trait Environment<HostState> {
+	/// Adds all declared functions to the supplied [`Linker`](wasmi::Linker) and
+	/// [`Store`](wasmi::Store).
+	fn define(
+		store: &mut Store<HostState>,
+		linker: &mut Linker<HostState>,
+		allow_unstable: AllowUnstableInterface,
+		allow_deprecated: AllowDeprecatedInterface,
+	) -> Result<(), LinkerError>;
+}
+
+/// Type of a storage key.
+enum KeyType {
+	/// Legacy fix sized key `[u8;32]`.
+	Fix,
+	/// Variable sized key used in transparent hashing,
+	/// cannot be larger than MaxStorageKeyLen.
+	Var(u32),
+}
+
+/// Every error that can be returned to a contract when it calls any of the host functions.
+///
+/// # Note
+///
+/// This enum can be extended in the future: New codes can be added but existing codes
+/// will not be changed or removed. This means that any contract **must not** exhaustively
+/// match return codes. Instead, contracts should prepare for unknown variants and deal with
+/// those errors gracefully in order to be forward compatible.
+#[derive(Debug)]
+#[repr(u32)]
+pub enum ReturnCode {
+	/// API call successful.
+	Success = 0,
+	/// The called function trapped and has its state changes reverted.
+	/// In this case no output buffer is returned.
+	CalleeTrapped = 1,
+	/// The called function ran to completion but decided to revert its state.
+	/// An output buffer is returned when one was supplied.
+	CalleeReverted = 2,
+	/// The passed key does not exist in storage.
+	KeyNotFound = 3,
+	/// See [`Error::TransferFailed`].
+	TransferFailed = 5,
+	/// No code could be found at the supplied code hash.
+	CodeNotFound = 7,
+	/// The contract that was called is no contract (a plain account).
+	NotCallable = 8,
+	/// The call dispatched by `seal_call_runtime` was executed but returned an error.
+	CallRuntimeFailed = 10,
+	/// ECDSA pubkey recovery failed (most probably wrong recovery id or signature), or
+	/// ECDSA compressed pubkey conversion into Ethereum address failed (most probably
+	/// wrong pubkey provided).
+	EcdsaRecoverFailed = 11,
+	/// sr25519 signature verification failed.
+	Sr25519VerifyFailed = 12,
+}
+
+impl From<ExecReturnValue> for ReturnCode {
+	fn from(from: ExecReturnValue) -> Self {
+		if from.flags.contains(ReturnFlags::REVERT) {
+			Self::CalleeReverted
+		} else {
+			Self::Success
+		}
+	}
+}
+
+impl From<ReturnCode> for u32 {
+	fn from(code: ReturnCode) -> u32 {
+		code as u32
+	}
+}
+
+/// The data passed through when a contract uses `seal_return`.
+#[derive(RuntimeDebug)]
+pub struct ReturnData {
+	/// The flags as passed through by the contract. They are still unchecked and
+	/// will later be parsed into a `ReturnFlags` bitflags struct.
+	flags: u32,
+	/// The output buffer passed by the contract as return data.
+	data: Vec<u8>,
+}
+
+/// Enumerates all possible reasons why a trap was generated.
+///
+/// This is either used to supply the caller with more information about why an error
+/// occurred (the SupervisorError variant).
+/// The other case is where the trap does not constitute an error but rather was invoked
+/// as a quick way to terminate the application (all other variants).
+#[derive(RuntimeDebug)]
+pub enum TrapReason {
+	/// The supervisor trapped the contract because of an error condition occurred during
+	/// execution in privileged code.
+	SupervisorError(DispatchError),
+	/// Signals that trap was generated in response to call `seal_return` host function.
+	Return(ReturnData),
+	/// Signals that a trap was generated in response to a successful call to the
+	/// `seal_terminate` host function.
+	Termination,
+}
+
+impl<T: Into<DispatchError>> From<T> for TrapReason {
+	fn from(from: T) -> Self {
+		Self::SupervisorError(from.into())
+	}
+}
+
+impl fmt::Display for TrapReason {
+	fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+		Ok(())
+	}
+}
+
+impl HostError for TrapReason {}
+
+#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
+#[derive(Copy, Clone)]
+pub enum RuntimeCosts {
+	/// Weight charged for copying data from the sandbox.
+	CopyFromContract(u32),
+	/// Weight charged for copying data to the sandbox.
+	CopyToContract(u32),
+	/// Weight of calling `seal_caller`.
+	Caller,
+	/// Weight of calling `seal_is_contract`.
+	IsContract,
+	/// Weight of calling `seal_code_hash`.
+	CodeHash,
+	/// Weight of calling `seal_own_code_hash`.
+	OwnCodeHash,
+	/// Weight of calling `seal_caller_is_origin`.
+	CallerIsOrigin,
+	/// Weight of calling `caller_is_root`.
+	CallerIsRoot,
+	/// Weight of calling `seal_address`.
+	Address,
+	/// Weight of calling `seal_gas_left`.
+	GasLeft,
+	/// Weight of calling `seal_balance`.
+	Balance,
+	/// Weight of calling `seal_value_transferred`.
+	ValueTransferred,
+	/// Weight of calling `seal_minimum_balance`.
+	MinimumBalance,
+	/// Weight of calling `seal_block_number`.
+	BlockNumber,
+	/// Weight of calling `seal_now`.
+	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_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.
+	DepositEvent { num_topic: u32, len: u32 },
+	/// Weight of calling `seal_debug_message` per byte of passed message.
+	DebugMessage(u32),
+	/// Weight of calling `seal_set_storage` for the given storage item sizes.
+	SetStorage { old_bytes: u32, new_bytes: u32 },
+	/// Weight of calling `seal_clear_storage` per cleared byte.
+	ClearStorage(u32),
+	/// Weight of calling `seal_contains_storage` per byte of the checked item.
+	ContainsStorage(u32),
+	/// Weight of calling `seal_get_storage` with the specified size in storage.
+	GetStorage(u32),
+	/// Weight of calling `seal_take_storage` for the given size.
+	TakeStorage(u32),
+	/// Weight of calling `seal_transfer`.
+	Transfer,
+	/// Base weight of calling `seal_call`.
+	CallBase,
+	/// Weight of calling `seal_delegate_call` for the given input size.
+	DelegateCallBase,
+	/// Weight of the transfer performed during a call.
+	CallSurchargeTransfer,
+	/// 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,
+	/// 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.
+	HashKeccak256(u32),
+	/// Weight of calling `seal_hash_blake2_256` for the given input size.
+	HashBlake256(u32),
+	/// Weight of calling `seal_hash_blake2_128` for the given input size.
+	HashBlake128(u32),
+	/// Weight of calling `seal_ecdsa_recover`.
+	EcdsaRecovery,
+	/// Weight of calling `seal_sr25519_verify` for the given input size.
+	Sr25519Verify(u32),
+	/// Weight charged by a chain extension through `seal_call_chain_extension`.
+	ChainExtension(Weight),
+	/// Weight charged for calling into the runtime.
+	CallRuntime(Weight),
+	/// Weight of calling `seal_set_code_hash`
+	SetCodeHash,
+	/// Weight of calling `ecdsa_to_eth_address`
+	EcdsaToEthAddress,
+	/// Weight of calling `reentrance_count`
+	ReentrantCount,
+	/// Weight of calling `account_reentrance_count`
+	AccountEntranceCount,
+	/// Weight of calling `instantiation_nonce`
+	InstantationNonce,
+	/// Weight of calling `add_delegate_dependency`
+	AddDelegateDependency,
+	/// Weight of calling `remove_delegate_dependency`
+	RemoveDelegateDependency,
+}
+
+impl RuntimeCosts {
+	fn token<T: Config>(&self, s: &HostFnWeights<T>) -> RuntimeToken {
+		use self::RuntimeCosts::*;
+		let weight = 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())),
+			ChainExtension(weight) => weight,
+			CallRuntime(weight) => weight,
+			SetCodeHash => s.set_code_hash,
+			EcdsaToEthAddress => s.ecdsa_to_eth_address,
+			ReentrantCount => s.reentrance_count,
+			AccountEntranceCount => s.account_reentrance_count,
+			InstantationNonce => s.instantiation_nonce,
+			AddDelegateDependency => s.add_delegate_dependency,
+			RemoveDelegateDependency => s.remove_delegate_dependency,
+		};
+		RuntimeToken {
+			#[cfg(test)]
+			_created_from: *self,
+			weight,
+		}
+	}
+}
+
+/// Same as [`Runtime::charge_gas`].
+///
+/// We need this access as a macro because sometimes hiding the lifetimes behind
+/// a function won't work out.
+macro_rules! charge_gas {
+	($runtime:expr, $costs:expr) => {{
+		let token = $costs.token(&$runtime.ext.schedule().host_fn_weights);
+		$runtime.ext.gas_meter_mut().charge(token)
+	}};
+}
+
+#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
+#[derive(Copy, Clone)]
+struct RuntimeToken {
+	#[cfg(test)]
+	_created_from: RuntimeCosts,
+	weight: Weight,
+}
+
+impl<T: Config> Token<T> for RuntimeToken {
+	fn weight(&self) -> Weight {
+		self.weight
+	}
+}
+
+bitflags! {
+	/// Flags used to change the behaviour of `seal_call` and `seal_delegate_call`.
+	pub struct CallFlags: u32 {
+		/// Forward the input of current function to the callee.
+		///
+		/// Supplied input pointers are ignored when set.
+		///
+		/// # Note
+		///
+		/// A forwarding call will consume the current contracts input. Any attempt to
+		/// access the input after this call returns will lead to [`Error::InputForwarded`].
+		/// It does not matter if this is due to calling `seal_input` or trying another
+		/// forwarding call. Consider using [`Self::CLONE_INPUT`] in order to preserve
+		/// the input.
+		const FORWARD_INPUT = 0b0000_0001;
+		/// Identical to [`Self::FORWARD_INPUT`] but without consuming the input.
+		///
+		/// This adds some additional weight costs to the call.
+		///
+		/// # Note
+		///
+		/// This implies [`Self::FORWARD_INPUT`] and takes precedence when both are set.
+		const CLONE_INPUT = 0b0000_0010;
+		/// Do not return from the call but rather return the result of the callee to the
+		/// callers caller.
+		///
+		/// # Note
+		///
+		/// This makes the current contract completely transparent to its caller by replacing
+		/// this contracts potential output by the callee ones. Any code after `seal_call`
+		/// can be safely considered unreachable.
+		const TAIL_CALL = 0b0000_0100;
+		/// Allow the callee to reenter into the current contract.
+		///
+		/// Without this flag any reentrancy into the current contract that originates from
+		/// the callee (or any of its callees) is denied. This includes the first callee:
+		/// You cannot call into yourself with this flag set.
+		///
+		/// # Note
+		///
+		/// For `seal_delegate_call` should be always unset, otherwise
+		/// [`Error::InvalidCallFlags`] is returned.
+		const ALLOW_REENTRY = 0b0000_1000;
+	}
+}
+
+/// The kind of call that should be performed.
+enum CallType {
+	/// Execute another instantiated contract
+	Call { callee_ptr: u32, value_ptr: u32, deposit_ptr: u32, weight: Weight },
+	/// Execute deployed code in the context (storage, account ID, value) of the caller contract
+	DelegateCall { code_hash_ptr: u32 },
+}
+
+impl CallType {
+	fn cost(&self) -> RuntimeCosts {
+		match self {
+			CallType::Call { .. } => RuntimeCosts::CallBase,
+			CallType::DelegateCall { .. } => RuntimeCosts::DelegateCallBase,
+		}
+	}
+}
+
+/// This is only appropriate when writing out data of constant size that does not depend on user
+/// input. In this case the costs for this copy was already charged as part of the token at
+/// the beginning of the API entry point.
+fn already_charged(_: u32) -> Option<RuntimeCosts> {
+	None
+}
+
+/// Can only be used for one call.
+pub struct Runtime<'a, E: Ext + 'a> {
+	ext: &'a mut E,
+	input_data: Option<Vec<u8>>,
+	memory: Option<Memory>,
+	chain_extension: Option<Box<<E::T as Config>::ChainExtension>>,
+}
+
+impl<'a, E: Ext + 'a> Runtime<'a, E> {
+	pub fn new(ext: &'a mut E, input_data: Vec<u8>) -> Self {
+		Runtime {
+			ext,
+			input_data: Some(input_data),
+			memory: None,
+			chain_extension: Some(Box::new(Default::default())),
+		}
+	}
+
+	pub fn memory(&self) -> Option<Memory> {
+		self.memory
+	}
+
+	pub fn set_memory(&mut self, memory: Memory) {
+		self.memory = Some(memory);
+	}
+
+	/// 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 TrapReason::*;
+
+		match sandbox_result {
+			// Contract returned from main function -> no data was returned.
+			Ok(_) => Ok(ExecReturnValue { flags: ReturnFlags::empty(), data: Vec::new() }),
+			// `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()),
+					}
+				}
+				// Otherwise the trap came from the contract itself.
+				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()),
+		}
+	}
+
+	/// Get a mutable reference to the inner `Ext`.
+	///
+	/// This is mainly for the chain extension to have access to the environment the
+	/// contract is executing in.
+	pub fn ext(&mut self) -> &mut E {
+		self.ext
+	}
+
+	/// Charge the gas meter with the specified token.
+	///
+	/// Returns `Err(HostError)` if there is not enough gas.
+	pub fn charge_gas(&mut self, costs: RuntimeCosts) -> Result<ChargedAmount, DispatchError> {
+		charge_gas!(self, costs)
+	}
+
+	/// Adjust a previously charged amount down to its actual amount.
+	///
+	/// This is when a maximum a priori amount was charged and then should be partially
+	/// refunded to match the actual amount.
+	pub fn adjust_gas(&mut self, charged: ChargedAmount, actual_costs: RuntimeCosts) {
+		let token = actual_costs.token(&self.ext.schedule().host_fn_weights);
+		self.ext.gas_meter_mut().adjust_gas(charged, token);
+	}
+
+	/// Read designated chunk from the sandbox memory.
+	///
+	/// Returns `Err` if one of the following conditions occurs:
+	///
+	/// - requested buffer is not within the bounds of the sandbox memory.
+	pub fn read_sandbox_memory(
+		&self,
+		memory: &[u8],
+		ptr: u32,
+		len: u32,
+	) -> Result<Vec<u8>, DispatchError> {
+		ensure!(len <= self.ext.schedule().limits.max_memory_size(), Error::<E::T>::OutOfBounds);
+		let mut buf = vec![0u8; len as usize];
+		self.read_sandbox_memory_into_buf(memory, ptr, buf.as_mut_slice())?;
+		Ok(buf)
+	}
+
+	/// Read designated chunk from the sandbox memory into the supplied buffer.
+	///
+	/// Returns `Err` if one of the following conditions occurs:
+	///
+	/// - requested buffer is not within the bounds of the sandbox memory.
+	pub fn read_sandbox_memory_into_buf(
+		&self,
+		memory: &[u8],
+		ptr: u32,
+		buf: &mut [u8],
+	) -> Result<(), DispatchError> {
+		let ptr = ptr as usize;
+		let bound_checked =
+			memory.get(ptr..ptr + buf.len()).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
+		buf.copy_from_slice(bound_checked);
+		Ok(())
+	}
+
+	/// Reads and decodes a type with a size fixed at compile time from contract memory.
+	///
+	/// # Note
+	///
+	/// The weight of reading a fixed value is included in the overall weight of any
+	/// contract callable function.
+	pub fn read_sandbox_memory_as<D: Decode + MaxEncodedLen>(
+		&self,
+		memory: &[u8],
+		ptr: u32,
+	) -> Result<D, DispatchError> {
+		let ptr = ptr as usize;
+		let mut bound_checked = memory
+			.get(ptr..ptr + D::max_encoded_len() as usize)
+			.ok_or_else(|| Error::<E::T>::OutOfBounds)?;
+		let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked)
+			.map_err(|_| DispatchError::from(Error::<E::T>::DecodingFailed))?;
+		Ok(decoded)
+	}
+
+	/// Read designated chunk from the sandbox memory and attempt to decode into the specified type.
+	///
+	/// Returns `Err` if one of the following conditions occurs:
+	///
+	/// - requested buffer is not within the bounds of the sandbox memory.
+	/// - the buffer contents cannot be decoded as the required type.
+	///
+	/// # Note
+	///
+	/// There must be an extra benchmark for determining the influence of `len` with
+	/// regard to the overall weight.
+	pub fn read_sandbox_memory_as_unbounded<D: Decode>(
+		&self,
+		memory: &[u8],
+		ptr: u32,
+		len: u32,
+	) -> Result<D, DispatchError> {
+		let ptr = ptr as usize;
+		let mut bound_checked =
+			memory.get(ptr..ptr + len as usize).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
+		let decoded = D::decode_all_with_depth_limit(MAX_DECODE_NESTING, &mut bound_checked)
+			.map_err(|_| DispatchError::from(Error::<E::T>::DecodingFailed))?;
+		Ok(decoded)
+	}
+
+	/// Write the given buffer and its length to the designated locations in sandbox memory and
+	/// charge gas according to the token returned by `create_token`.
+	//
+	/// `out_ptr` is the location in sandbox memory where `buf` should be written to.
+	/// `out_len_ptr` is an in-out location in sandbox memory. It is read to determine the
+	/// length of the buffer located at `out_ptr`. If that buffer is large enough the actual
+	/// `buf.len()` is written to this location.
+	///
+	/// If `out_ptr` is set to the sentinel value of `SENTINEL` and `allow_skip` is true the
+	/// operation is skipped and `Ok` is returned. This is supposed to help callers to make copying
+	/// output optional. For example to skip copying back the output buffer of an `seal_call`
+	/// when the caller is not interested in the result.
+	///
+	/// `create_token` can optionally instruct this function to charge the gas meter with the token
+	/// it returns. `create_token` receives the variable amount of bytes that are about to be copied
+	/// by this function.
+	///
+	/// In addition to the error conditions of `write_sandbox_memory` this functions returns
+	/// `Err` if the size of the buffer located at `out_ptr` is too small to fit `buf`.
+	pub fn write_sandbox_output(
+		&mut self,
+		memory: &mut [u8],
+		out_ptr: u32,
+		out_len_ptr: u32,
+		buf: &[u8],
+		allow_skip: bool,
+		create_token: impl FnOnce(u32) -> Option<RuntimeCosts>,
+	) -> Result<(), DispatchError> {
+		if allow_skip && out_ptr == SENTINEL {
+			return Ok(())
+		}
+
+		let buf_len = buf.len() as u32;
+		let len: u32 = self.read_sandbox_memory_as(memory, out_len_ptr)?;
+
+		if len < buf_len {
+			return Err(Error::<E::T>::OutputBufferTooSmall.into())
+		}
+
+		if let Some(costs) = create_token(buf_len) {
+			self.charge_gas(costs)?;
+		}
+
+		self.write_sandbox_memory(memory, out_ptr, buf)?;
+		self.write_sandbox_memory(memory, out_len_ptr, &buf_len.encode())
+	}
+
+	/// Write the given buffer to the designated location in the sandbox memory.
+	///
+	/// Returns `Err` if one of the following conditions occurs:
+	///
+	/// - designated area is not within the bounds of the sandbox memory.
+	fn write_sandbox_memory(
+		&self,
+		memory: &mut [u8],
+		ptr: u32,
+		buf: &[u8],
+	) -> Result<(), DispatchError> {
+		let ptr = ptr as usize;
+		let bound_checked =
+			memory.get_mut(ptr..ptr + buf.len()).ok_or_else(|| Error::<E::T>::OutOfBounds)?;
+		bound_checked.copy_from_slice(buf);
+		Ok(())
+	}
+
+	/// Computes the given hash function on the supplied input.
+	///
+	/// Reads from the sandboxed input buffer into an intermediate buffer.
+	/// Returns the result directly to the output buffer of the sandboxed memory.
+	///
+	/// It is the callers responsibility to provide an output buffer that
+	/// is large enough to hold the expected amount of bytes returned by the
+	/// chosen hash function.
+	///
+	/// # Note
+	///
+	/// The `input` and `output` buffers may overlap.
+	fn compute_hash_on_intermediate_buffer<F, R>(
+		&self,
+		memory: &mut [u8],
+		hash_fn: F,
+		input_ptr: u32,
+		input_len: u32,
+		output_ptr: u32,
+	) -> Result<(), DispatchError>
+	where
+		F: FnOnce(&[u8]) -> R,
+		R: AsRef<[u8]>,
+	{
+		// Copy input into supervisor memory.
+		let input = self.read_sandbox_memory(memory, input_ptr, input_len)?;
+		// Compute the hash on the input buffer using the given hash function.
+		let hash = hash_fn(&input);
+		// Write the resulting hash back into the sandboxed output buffer.
+		self.write_sandbox_memory(memory, output_ptr, hash.as_ref())?;
+		Ok(())
+	}
+
+	/// Fallible conversion of `DispatchError` to `ReturnCode`.
+	fn err_into_return_code(from: DispatchError) -> Result<ReturnCode, DispatchError> {
+		use ReturnCode::*;
+
+		let transfer_failed = Error::<E::T>::TransferFailed.into();
+		let no_code = Error::<E::T>::CodeNotFound.into();
+		let not_found = Error::<E::T>::ContractNotFound.into();
+
+		match from {
+			x if x == transfer_failed => Ok(TransferFailed),
+			x if x == no_code => Ok(CodeNotFound),
+			x if x == not_found => Ok(NotCallable),
+			err => Err(err),
+		}
+	}
+
+	/// Fallible conversion of a `ExecResult` to `ReturnCode`.
+	fn exec_into_return_code(from: ExecResult) -> Result<ReturnCode, DispatchError> {
+		use crate::exec::ErrorOrigin::Callee;
+
+		let ExecError { error, origin } = match from {
+			Ok(retval) => return Ok(retval.into()),
+			Err(err) => err,
+		};
+
+		match (error, origin) {
+			(_, Callee) => Ok(ReturnCode::CalleeTrapped),
+			(err, _) => Self::err_into_return_code(err),
+		}
+	}
+	fn decode_key(
+		&self,
+		memory: &[u8],
+		key_type: KeyType,
+		key_ptr: u32,
+	) -> Result<crate::exec::Key<E::T>, TrapReason> {
+		let res = match key_type {
+			KeyType::Fix => {
+				let key = self.read_sandbox_memory(memory, key_ptr, 32u32)?;
+				Key::try_from_fix(key)
+			},
+			KeyType::Var(len) => {
+				ensure!(
+					len <= <<E as Ext>::T as Config>::MaxStorageKeyLen::get(),
+					Error::<E::T>::DecodingFailed
+				);
+				let key = self.read_sandbox_memory(memory, key_ptr, len)?;
+				Key::try_from_var(key)
+			},
+		};
+
+		res.map_err(|_| Error::<E::T>::DecodingFailed.into())
+	}
+
+	fn set_storage(
+		&mut self,
+		memory: &[u8],
+		key_type: KeyType,
+		key_ptr: u32,
+		value_ptr: u32,
+		value_len: u32,
+	) -> Result<u32, TrapReason> {
+		let max_size = self.ext.max_value_size();
+		let charged = self
+			.charge_gas(RuntimeCosts::SetStorage { new_bytes: value_len, old_bytes: max_size })?;
+		if value_len > max_size {
+			return Err(Error::<E::T>::ValueTooLarge.into())
+		}
+		let key = self.decode_key(memory, key_type, key_ptr)?;
+		let value = Some(self.read_sandbox_memory(memory, value_ptr, value_len)?);
+		let write_outcome = self.ext.set_storage(&key, value, false)?;
+
+		self.adjust_gas(
+			charged,
+			RuntimeCosts::SetStorage { new_bytes: value_len, old_bytes: write_outcome.old_len() },
+		);
+		Ok(write_outcome.old_len_with_sentinel())
+	}
+
+	fn clear_storage(
+		&mut self,
+		memory: &[u8],
+		key_type: KeyType,
+		key_ptr: u32,
+	) -> Result<u32, TrapReason> {
+		let charged = self.charge_gas(RuntimeCosts::ClearStorage(self.ext.max_value_size()))?;
+		let key = self.decode_key(memory, key_type, key_ptr)?;
+		let outcome = self.ext.set_storage(&key, None, false)?;
+
+		self.adjust_gas(charged, RuntimeCosts::ClearStorage(outcome.old_len()));
+		Ok(outcome.old_len_with_sentinel())
+	}
+
+	fn get_storage(
+		&mut self,
+		memory: &mut [u8],
+		key_type: KeyType,
+		key_ptr: u32,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		let charged = self.charge_gas(RuntimeCosts::GetStorage(self.ext.max_value_size()))?;
+		let key = self.decode_key(memory, key_type, key_ptr)?;
+		let outcome = self.ext.get_storage(&key);
+
+		if let Some(value) = outcome {
+			self.adjust_gas(charged, RuntimeCosts::GetStorage(value.len() as u32));
+			self.write_sandbox_output(
+				memory,
+				out_ptr,
+				out_len_ptr,
+				&value,
+				false,
+				already_charged,
+			)?;
+			Ok(ReturnCode::Success)
+		} else {
+			self.adjust_gas(charged, RuntimeCosts::GetStorage(0));
+			Ok(ReturnCode::KeyNotFound)
+		}
+	}
+
+	fn contains_storage(
+		&mut self,
+		memory: &[u8],
+		key_type: KeyType,
+		key_ptr: u32,
+	) -> Result<u32, TrapReason> {
+		let charged = self.charge_gas(RuntimeCosts::ContainsStorage(self.ext.max_value_size()))?;
+		let key = self.decode_key(memory, key_type, key_ptr)?;
+		let outcome = self.ext.get_storage_size(&key);
+
+		self.adjust_gas(charged, RuntimeCosts::ClearStorage(outcome.unwrap_or(0)));
+		Ok(outcome.unwrap_or(SENTINEL))
+	}
+
+	fn call(
+		&mut self,
+		memory: &mut [u8],
+		flags: CallFlags,
+		call_type: CallType,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+	) -> Result<ReturnCode, 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))?;
+			input.clone()
+		} else if flags.contains(CallFlags::FORWARD_INPUT) {
+			self.input_data.take().ok_or(Error::<E::T>::InputForwarded)?
+		} else {
+			self.charge_gas(RuntimeCosts::CopyFromContract(input_data_len))?;
+			self.read_sandbox_memory(memory, input_data_ptr, input_data_len)?
+		};
+
+		let call_outcome = match call_type {
+			CallType::Call { callee_ptr, value_ptr, deposit_ptr, weight } => {
+				let callee: <<E as Ext>::T as frame_system::Config>::AccountId =
+					self.read_sandbox_memory_as(memory, callee_ptr)?;
+				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::CallSurchargeTransfer)?;
+				}
+				self.ext.call(
+					weight,
+					deposit_limit,
+					callee,
+					value,
+					input_data,
+					flags.contains(CallFlags::ALLOW_REENTRY),
+				)
+			},
+			CallType::DelegateCall { code_hash_ptr } => {
+				if flags.contains(CallFlags::ALLOW_REENTRY) {
+					return Err(Error::<E::T>::InvalidCallFlags.into())
+				}
+				let code_hash = self.read_sandbox_memory_as(memory, code_hash_ptr)?;
+				self.ext.delegate_call(code_hash, input_data)
+			},
+		};
+
+		// `TAIL_CALL` only matters on an `OK` result. Otherwise the call stack comes to
+		// a halt anyways without anymore code being executed.
+		if flags.contains(CallFlags::TAIL_CALL) {
+			if let Ok(return_value) = call_outcome {
+				return Err(TrapReason::Return(ReturnData {
+					flags: return_value.flags.bits(),
+					data: return_value.data,
+				}))
+			}
+		}
+
+		if let Ok(output) = &call_outcome {
+			self.write_sandbox_output(
+				memory,
+				output_ptr,
+				output_len_ptr,
+				&output.data,
+				true,
+				|len| Some(RuntimeCosts::CopyToContract(len)),
+			)?;
+		}
+		Ok(Runtime::<E>::exec_into_return_code(call_outcome)?)
+	}
+
+	fn instantiate(
+		&mut self,
+		memory: &mut [u8],
+		code_hash_ptr: u32,
+		weight: Weight,
+		deposit_ptr: u32,
+		value_ptr: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		address_ptr: u32,
+		address_len_ptr: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+		salt_ptr: u32,
+		salt_len: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		self.charge_gas(RuntimeCosts::InstantiateBase { 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)?;
+		let salt = self.read_sandbox_memory(memory, salt_ptr, salt_len)?;
+		let instantiate_outcome =
+			self.ext.instantiate(weight, deposit_limit, code_hash, value, input_data, &salt);
+		if let Ok((address, output)) = &instantiate_outcome {
+			if !output.flags.contains(ReturnFlags::REVERT) {
+				self.write_sandbox_output(
+					memory,
+					address_ptr,
+					address_len_ptr,
+					&address.encode(),
+					true,
+					already_charged,
+				)?;
+			}
+			self.write_sandbox_output(
+				memory,
+				output_ptr,
+				output_len_ptr,
+				&output.data,
+				true,
+				|len| Some(RuntimeCosts::CopyToContract(len)),
+			)?;
+		}
+		Ok(Runtime::<E>::exec_into_return_code(instantiate_outcome.map(|(_, retval)| retval))?)
+	}
+
+	fn terminate(&mut self, memory: &[u8], beneficiary_ptr: u32) -> Result<(), TrapReason> {
+		self.charge_gas(RuntimeCosts::Terminate)?;
+		let beneficiary: <<E as Ext>::T as frame_system::Config>::AccountId =
+			self.read_sandbox_memory_as(memory, beneficiary_ptr)?;
+		self.ext.terminate(&beneficiary)?;
+		Err(TrapReason::Termination)
+	}
+}
+
+// This is the API exposed to contracts.
+//
+// # Note
+//
+// Any input that leads to a out of bound error (reading or writing) or failing to decode
+// data passed to the supervisor will lead to a trap. This is not documented explicitly
+// for every function.
+#[define_env(doc)]
+pub mod env {
+	/// Set the value at the given key in the contract storage.
+	///
+	/// Equivalent to the newer [`seal1`][`super::api_doc::Version1::set_storage`] version with the
+	/// exception of the return type. Still a valid thing to call when not interested in the return
+	/// value.
+	#[prefixed_alias]
+	fn set_storage(
+		ctx: _,
+		memory: _,
+		key_ptr: u32,
+		value_ptr: u32,
+		value_len: u32,
+	) -> Result<(), TrapReason> {
+		ctx.set_storage(memory, KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
+	}
+
+	/// Set the value at the given key in the contract storage.
+	///
+	/// This version is to be used with a fixed sized storage key. For runtimes supporting
+	/// transparent hashing, please use the newer version of this function.
+	///
+	/// The value length must not exceed the maximum defined by the contracts module parameters.
+	/// Specifying a `value_len` of zero will store an empty value.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the location to store the value is placed.
+	/// - `value_ptr`: pointer into the linear memory where the value to set is placed.
+	/// - `value_len`: the length of the value in bytes.
+	///
+	/// # Return Value
+	///
+	/// Returns the size of the pre-existing value at the specified key if any. Otherwise
+	/// `SENTINEL` is returned as a sentinel value.
+	#[version(1)]
+	#[prefixed_alias]
+	fn set_storage(
+		ctx: _,
+		memory: _,
+		key_ptr: u32,
+		value_ptr: u32,
+		value_len: u32,
+	) -> Result<u32, TrapReason> {
+		ctx.set_storage(memory, KeyType::Fix, key_ptr, value_ptr, value_len)
+	}
+
+	/// Set the value at the given key in the contract storage.
+	///
+	/// The key and value lengths must not exceed the maximums defined by the contracts module
+	/// parameters. Specifying a `value_len` of zero will store an empty value.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the location to store the value is placed.
+	/// - `key_len`: the length of the key in bytes.
+	/// - `value_ptr`: pointer into the linear memory where the value to set is placed.
+	/// - `value_len`: the length of the value in bytes.
+	///
+	/// # Return Value
+	///
+	/// Returns the size of the pre-existing value at the specified key if any. Otherwise
+	/// `SENTINEL` is returned as a sentinel value.
+	#[version(2)]
+	#[prefixed_alias]
+	fn set_storage(
+		ctx: _,
+		memory: _,
+		key_ptr: u32,
+		key_len: u32,
+		value_ptr: u32,
+		value_len: u32,
+	) -> Result<u32, TrapReason> {
+		ctx.set_storage(memory, KeyType::Var(key_len), key_ptr, value_ptr, value_len)
+	}
+
+	/// Clear the value at the given key in the contract storage.
+	///
+	/// Equivalent to the newer [`seal1`][`super::api_doc::Version1::clear_storage`] version with
+	/// the exception of the return type. Still a valid thing to call when not interested in the
+	/// return value.
+	#[prefixed_alias]
+	fn clear_storage(ctx: _, memory: _, key_ptr: u32) -> Result<(), TrapReason> {
+		ctx.clear_storage(memory, KeyType::Fix, key_ptr).map(|_| ())
+	}
+
+	/// Clear the value at the given key in the contract storage.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the key is placed.
+	/// - `key_len`: the length of the key in bytes.
+	///
+	/// # Return Value
+	///
+	/// Returns the size of the pre-existing value at the specified key if any. Otherwise
+	/// `SENTINEL` is returned as a sentinel value.
+	#[version(1)]
+	#[prefixed_alias]
+	fn clear_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
+		ctx.clear_storage(memory, KeyType::Var(key_len), key_ptr)
+	}
+
+	/// Retrieve the value under the given key from storage.
+	///
+	/// This version is to be used with a fixed sized storage key. For runtimes supporting
+	/// transparent hashing, please use the newer version of this function.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
+	/// - `out_ptr`: pointer to the linear memory where the value is written to.
+	/// - `out_len_ptr`: in-out pointer into linear memory where the buffer length is read from and
+	///   the value length is written to.
+	///
+	/// # Errors
+	///
+	/// `ReturnCode::KeyNotFound`
+	#[prefixed_alias]
+	fn get_storage(
+		ctx: _,
+		memory: _,
+		key_ptr: u32,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.get_storage(memory, KeyType::Fix, key_ptr, out_ptr, out_len_ptr)
+	}
+
+	/// Retrieve the value under the given key from storage.
+	///
+	/// This version is to be used with a fixed sized storage key. For runtimes supporting
+	/// transparent hashing, please use the newer version of this function.
+	///
+	/// The key length must not exceed the maximum defined by the contracts module parameter.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
+	/// - `key_len`: the length of the key in bytes.
+	/// - `out_ptr`: pointer to the linear memory where the value is written to.
+	/// - `out_len_ptr`: in-out pointer into linear memory where the buffer length is read from and
+	///   the value length is written to.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::KeyNotFound`
+	#[version(1)]
+	#[prefixed_alias]
+	fn get_storage(
+		ctx: _,
+		memory: _,
+		key_ptr: u32,
+		key_len: u32,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.get_storage(memory, KeyType::Var(key_len), key_ptr, out_ptr, out_len_ptr)
+	}
+
+	/// Checks whether there is a value stored under the given key.
+	///
+	/// This version is to be used with a fixed sized storage key. For runtimes supporting
+	/// transparent hashing, please use the newer version of this function.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
+	///
+	/// # Return Value
+	///
+	/// Returns the size of the pre-existing value at the specified key if any. Otherwise
+	/// `SENTINEL` is returned as a sentinel value.
+	#[prefixed_alias]
+	fn contains_storage(ctx: _, memory: _, key_ptr: u32) -> Result<u32, TrapReason> {
+		ctx.contains_storage(memory, KeyType::Fix, key_ptr)
+	}
+
+	/// Checks whether there is a value stored under the given key.
+	///
+	/// The key length must not exceed the maximum defined by the contracts module parameter.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
+	/// - `key_len`: the length of the key in bytes.
+	///
+	/// # Return Value
+	///
+	/// Returns the size of the pre-existing value at the specified key if any. Otherwise
+	/// `SENTINEL` is returned as a sentinel value.
+	#[version(1)]
+	#[prefixed_alias]
+	fn contains_storage(ctx: _, memory: _, key_ptr: u32, key_len: u32) -> Result<u32, TrapReason> {
+		ctx.contains_storage(memory, KeyType::Var(key_len), key_ptr)
+	}
+
+	/// Retrieve and remove the value under the given key from storage.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: pointer into the linear memory where the key of the requested value is placed.
+	/// - `key_len`: the length of the key in bytes.
+	/// - `out_ptr`: pointer to the linear memory where the value is written to.
+	/// - `out_len_ptr`: in-out pointer into linear memory where the buffer length is read from and
+	///   the value length is written to.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::KeyNotFound`
+	#[prefixed_alias]
+	fn take_storage(
+		ctx: _,
+		memory: _,
+		key_ptr: u32,
+		key_len: u32,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		let charged = ctx.charge_gas(RuntimeCosts::TakeStorage(ctx.ext.max_value_size()))?;
+		ensure!(
+			key_len <= <<E as Ext>::T as Config>::MaxStorageKeyLen::get(),
+			Error::<E::T>::DecodingFailed
+		);
+		let key = ctx.read_sandbox_memory(memory, key_ptr, key_len)?;
+		if let crate::storage::WriteOutcome::Taken(value) = ctx.ext.set_storage(
+			&Key::<E::T>::try_from_var(key).map_err(|_| Error::<E::T>::DecodingFailed)?,
+			None,
+			true,
+		)? {
+			ctx.adjust_gas(charged, RuntimeCosts::TakeStorage(value.len() as u32));
+			ctx.write_sandbox_output(memory, out_ptr, out_len_ptr, &value, false, already_charged)?;
+			Ok(ReturnCode::Success)
+		} else {
+			ctx.adjust_gas(charged, RuntimeCosts::TakeStorage(0));
+			Ok(ReturnCode::KeyNotFound)
+		}
+	}
+
+	/// Transfer some value to another account.
+	///
+	/// # Parameters
+	///
+	/// - `account_ptr`: a pointer to the address of the beneficiary account Should be decodable as
+	///   an `T::AccountId`. Traps otherwise.
+	/// - `account_len`: length of the address buffer.
+	/// - `value_ptr`: a pointer to the buffer with value, how much value to send. Should be
+	///   decodable as a `T::Balance`. Traps otherwise.
+	/// - `value_len`: length of the value buffer.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::TransferFailed`
+	#[prefixed_alias]
+	fn transfer(
+		ctx: _,
+		memory: _,
+		account_ptr: u32,
+		_account_len: u32,
+		value_ptr: u32,
+		_value_len: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Transfer)?;
+		let callee: <<E as Ext>::T as frame_system::Config>::AccountId =
+			ctx.read_sandbox_memory_as(memory, account_ptr)?;
+		let value: BalanceOf<<E as Ext>::T> = ctx.read_sandbox_memory_as(memory, value_ptr)?;
+		let result = ctx.ext.transfer(&callee, value);
+		match result {
+			Ok(()) => Ok(ReturnCode::Success),
+			Err(err) => {
+				let code = Runtime::<E>::err_into_return_code(err)?;
+				Ok(code)
+			},
+		}
+	}
+
+	/// Make a call to another contract.
+	///
+	/// # New version available
+	///
+	/// This is equivalent to calling the newer version of this function with
+	/// `flags` set to `ALLOW_REENTRY`. See the newer version for documentation.
+	///
+	/// # Note
+	///
+	/// The values `_callee_len` and `_value_len` are ignored because the encoded sizes
+	/// 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]
+	fn call(
+		ctx: _,
+		memory: _,
+		callee_ptr: u32,
+		_callee_len: u32,
+		gas: u64,
+		value_ptr: u32,
+		_value_len: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.call(
+			memory,
+			CallFlags::ALLOW_REENTRY,
+			CallType::Call {
+				callee_ptr,
+				value_ptr,
+				deposit_ptr: SENTINEL,
+				weight: Weight::from_parts(gas, 0),
+			},
+			input_data_ptr,
+			input_data_len,
+			output_ptr,
+			output_len_ptr,
+		)
+	}
+
+	/// Make a call to another contract.
+	///
+	/// Equivalent to the newer [`seal2`][`super::api_doc::Version2::call`] version but works with
+	/// *ref_time* Weight only. It is recommended to switch to the latest version, once it's
+	/// stabilized.
+	#[version(1)]
+	#[prefixed_alias]
+	fn call(
+		ctx: _,
+		memory: _,
+		flags: u32,
+		callee_ptr: u32,
+		gas: u64,
+		value_ptr: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.call(
+			memory,
+			CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
+			CallType::Call {
+				callee_ptr,
+				value_ptr,
+				deposit_ptr: SENTINEL,
+				weight: Weight::from_parts(gas, 0),
+			},
+			input_data_ptr,
+			input_data_len,
+			output_ptr,
+			output_len_ptr,
+		)
+	}
+
+	/// Make a call to another contract.
+	///
+	/// The callees output buffer is copied to `output_ptr` and its length to `output_len_ptr`.
+	/// The copy of the output buffer can be skipped by supplying the sentinel value
+	/// of `SENTINEL` to `output_ptr`.
+	///
+	/// # Parameters
+	///
+	/// - `flags`: See `crate::wasm::runtime::CallFlags` for a documentation of the supported flags.
+	/// - `callee_ptr`: a pointer to the address of the callee contract. Should be decodable as an
+	///   `T::AccountId`. Traps otherwise.
+	/// - `ref_time_limit`: how much *ref_time* Weight to devote to the execution.
+	/// - `proof_size_limit`: how much *proof_size* Weight to devote to the execution.
+	/// - `deposit_ptr`: a pointer to the buffer with value of the storage deposit limit for the
+	///   call. Should be decodable as a `T::Balance`. Traps otherwise. Passing `SENTINEL` means
+	///   setting no specific limit for the call, which implies storage usage up to the limit of the
+	///   parent call.
+	/// - `value_ptr`: a pointer to the buffer with value, how much value to send. Should be
+	///   decodable as a `T::Balance`. Traps otherwise.
+	/// - `input_data_ptr`: a pointer to a buffer to be used as input data to the callee.
+	/// - `input_data_len`: length of the input data buffer.
+	/// - `output_ptr`: a pointer where the output buffer is copied to.
+	/// - `output_len_ptr`: in-out pointer to where the length of the buffer is read from and the
+	///   actual length is written to.
+	///
+	/// # Errors
+	///
+	/// An error means that the call wasn't successful output buffer is returned unless
+	/// stated otherwise.
+	///
+	/// - `ReturnCode::CalleeReverted`: Output buffer is returned.
+	/// - `ReturnCode::CalleeTrapped`
+	/// - `ReturnCode::TransferFailed`
+	/// - `ReturnCode::NotCallable`
+	#[version(2)]
+	#[unstable]
+	fn call(
+		ctx: _,
+		memory: _,
+		flags: u32,
+		callee_ptr: u32,
+		ref_time_limit: u64,
+		proof_size_limit: u64,
+		deposit_ptr: u32,
+		value_ptr: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.call(
+			memory,
+			CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
+			CallType::Call {
+				callee_ptr,
+				value_ptr,
+				deposit_ptr,
+				weight: Weight::from_parts(ref_time_limit, proof_size_limit),
+			},
+			input_data_ptr,
+			input_data_len,
+			output_ptr,
+			output_len_ptr,
+		)
+	}
+
+	/// Execute code in the context (storage, caller, value) of the current contract.
+	///
+	/// Reentrancy protection is always disabled since the callee is allowed
+	/// to modify the callers storage. This makes going through a reentrancy attack
+	/// unnecessary for the callee when it wants to exploit the caller.
+	///
+	/// # Parameters
+	///
+	/// - `flags`: see `crate::wasm::runtime::CallFlags` for a documentation of the supported flags.
+	/// - `code_hash`: a pointer to the hash of the code to be called.
+	/// - `input_data_ptr`: a pointer to a buffer to be used as input data to the callee.
+	/// - `input_data_len`: length of the input data buffer.
+	/// - `output_ptr`: a pointer where the output buffer is copied to.
+	/// - `output_len_ptr`: in-out pointer to where the length of the buffer is read from and the
+	///   actual length is written to.
+	///
+	/// # Errors
+	///
+	/// An error means that the call wasn't successful and no output buffer is returned unless
+	/// stated otherwise.
+	///
+	/// - `ReturnCode::CalleeReverted`: Output buffer is returned.
+	/// - `ReturnCode::CalleeTrapped`
+	/// - `ReturnCode::CodeNotFound`
+	#[prefixed_alias]
+	fn delegate_call(
+		ctx: _,
+		memory: _,
+		flags: u32,
+		code_hash_ptr: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.call(
+			memory,
+			CallFlags::from_bits(flags).ok_or(Error::<E::T>::InvalidCallFlags)?,
+			CallType::DelegateCall { code_hash_ptr },
+			input_data_ptr,
+			input_data_len,
+			output_ptr,
+			output_len_ptr,
+		)
+	}
+
+	/// Instantiate a contract with the specified code hash.
+	///
+	/// # New version available
+	///
+	/// This is equivalent to calling the newer version of this function. The newer version
+	/// drops the now unnecessary length fields.
+	///
+	/// # Note
+	///
+	/// The values `_code_hash_len` and `_value_len` are ignored because the encoded sizes
+	/// 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]
+	fn instantiate(
+		ctx: _,
+		memory: _,
+		code_hash_ptr: u32,
+		_code_hash_len: u32,
+		gas: u64,
+		value_ptr: u32,
+		_value_len: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		address_ptr: u32,
+		address_len_ptr: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+		salt_ptr: u32,
+		salt_len: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.instantiate(
+			memory,
+			code_hash_ptr,
+			Weight::from_parts(gas, 0),
+			SENTINEL,
+			value_ptr,
+			input_data_ptr,
+			input_data_len,
+			address_ptr,
+			address_len_ptr,
+			output_ptr,
+			output_len_ptr,
+			salt_ptr,
+			salt_len,
+		)
+	}
+
+	/// Instantiate a contract with the specified code hash.
+	///
+	/// Equivalent to the newer [`seal2`][`super::api_doc::Version2::instantiate`] version but works
+	/// with *ref_time* Weight only. It is recommended to switch to the latest version, once it's
+	/// stabilized.
+	#[version(1)]
+	#[prefixed_alias]
+	fn instantiate(
+		ctx: _,
+		memory: _,
+		code_hash_ptr: u32,
+		gas: u64,
+		value_ptr: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		address_ptr: u32,
+		address_len_ptr: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+		salt_ptr: u32,
+		salt_len: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.instantiate(
+			memory,
+			code_hash_ptr,
+			Weight::from_parts(gas, 0),
+			SENTINEL,
+			value_ptr,
+			input_data_ptr,
+			input_data_len,
+			address_ptr,
+			address_len_ptr,
+			output_ptr,
+			output_len_ptr,
+			salt_ptr,
+			salt_len,
+		)
+	}
+
+	/// Instantiate a contract with the specified code hash.
+	///
+	/// This function creates an account and executes the constructor defined in the code specified
+	/// by the code hash. The address of this new account is copied to `address_ptr` and its length
+	/// to `address_len_ptr`. The constructors output buffer is copied to `output_ptr` and its
+	/// length to `output_len_ptr`. The copy of the output buffer and address can be skipped by
+	/// supplying the sentinel value of `SENTINEL` to `output_ptr` or `address_ptr`.
+	///
+	/// # Parameters
+	///
+	/// - `code_hash_ptr`: a pointer to the buffer that contains the initializer code.
+	/// - `ref_time_limit`: how much *ref_time* Weight to devote to the execution.
+	/// - `proof_size_limit`: how much *proof_size* Weight to devote to the execution.
+	/// - `deposit_ptr`: a pointer to the buffer with value of the storage deposit limit for
+	///   instantiation. Should be decodable as a `T::Balance`. Traps otherwise. Passing `SENTINEL`
+	///   means setting no specific limit for the call, which implies storage usage up to the limit
+	///   of the parent call.
+	/// - `value_ptr`: a pointer to the buffer with value, how much value to send. Should be
+	///   decodable as a `T::Balance`. Traps otherwise.
+	/// - `input_data_ptr`: a pointer to a buffer to be used as input data to the initializer code.
+	/// - `input_data_len`: length of the input data buffer.
+	/// - `address_ptr`: a pointer where the new account's address is copied to. `SENTINEL` means
+	///   not to copy.
+	/// - `address_len_ptr`: pointer to where put the length of the address.
+	/// - `output_ptr`: a pointer where the output buffer is copied to. `SENTINEL` means not to
+	///   copy.
+	/// - `output_len_ptr`: in-out pointer to where the length of the buffer is read from and the
+	///   actual length is written to.
+	/// - `salt_ptr`: Pointer to raw bytes used for address derivation. See `fn contract_address`.
+	/// - `salt_len`: length in bytes of the supplied salt.
+	///
+	/// # Errors
+	///
+	/// Please consult the `ReturnCode` enum declaration for more information on those
+	/// errors. Here we only note things specific to this function.
+	///
+	/// An error means that the account wasn't created and no address or output buffer
+	/// is returned unless stated otherwise.
+	///
+	/// - `ReturnCode::CalleeReverted`: Output buffer is returned.
+	/// - `ReturnCode::CalleeTrapped`
+	/// - `ReturnCode::TransferFailed`
+	/// - `ReturnCode::CodeNotFound`
+	#[version(2)]
+	#[unstable]
+	fn instantiate(
+		ctx: _,
+		memory: _,
+		code_hash_ptr: u32,
+		ref_time_limit: u64,
+		proof_size_limit: u64,
+		deposit_ptr: u32,
+		value_ptr: u32,
+		input_data_ptr: u32,
+		input_data_len: u32,
+		address_ptr: u32,
+		address_len_ptr: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+		salt_ptr: u32,
+		salt_len: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.instantiate(
+			memory,
+			code_hash_ptr,
+			Weight::from_parts(ref_time_limit, proof_size_limit),
+			deposit_ptr,
+			value_ptr,
+			input_data_ptr,
+			input_data_len,
+			address_ptr,
+			address_len_ptr,
+			output_ptr,
+			output_len_ptr,
+			salt_ptr,
+			salt_len,
+		)
+	}
+
+	/// Remove the calling account and transfer remaining balance.
+	///
+	/// # New version available
+	///
+	/// This is equivalent to calling the newer version of this function. The newer version
+	/// drops the now unnecessary length fields.
+	///
+	/// # Note
+	///
+	/// The value `_beneficiary_len` is ignored because the encoded sizes
+	/// this type is fixed through `[`MaxEncodedLen`]. The field exist for backwards
+	/// compatibility. Consider switching to the newest version of this function.
+	#[prefixed_alias]
+	fn terminate(
+		ctx: _,
+		memory: _,
+		beneficiary_ptr: u32,
+		_beneficiary_len: u32,
+	) -> Result<(), TrapReason> {
+		ctx.terminate(memory, beneficiary_ptr)
+	}
+
+	/// Remove the calling account and transfer remaining **free** balance.
+	///
+	/// This function never returns. Either the termination was successful and the
+	/// execution of the destroyed contract is halted. Or it failed during the termination
+	/// which is considered fatal and results in a trap + rollback.
+	///
+	/// - `beneficiary_ptr`: a pointer to the address of the beneficiary account where all where all
+	///   remaining funds of the caller are transferred. Should be decodable as an `T::AccountId`.
+	///   Traps otherwise.
+	///
+	/// # Traps
+	///
+	/// - The contract is live i.e is already on the call stack.
+	/// - Failed to send the balance to the beneficiary.
+	/// - The deletion queue is full.
+	#[version(1)]
+	#[prefixed_alias]
+	fn terminate(ctx: _, memory: _, beneficiary_ptr: u32) -> Result<(), TrapReason> {
+		ctx.terminate(memory, beneficiary_ptr)
+	}
+
+	/// Stores the input passed by the caller into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// # Note
+	///
+	/// This function traps if the input was previously forwarded by a [`call()`][`Self::call()`].
+	#[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))
+			})?;
+			ctx.input_data = Some(input);
+			Ok(())
+		} else {
+			Err(Error::<E::T>::InputForwarded.into())
+		}
+	}
+
+	/// Cease contract execution and save a data buffer as a result of the execution.
+	///
+	/// This function never returns as it stops execution of the caller.
+	/// This is the only way to return a data buffer to the caller. Returning from
+	/// execution without calling this function is equivalent to calling:
+	/// ```nocompile
+	/// seal_return(0, 0, 0);
+	/// ```
+	///
+	/// The flags argument is a bitfield that can be used to signal special return
+	/// conditions to the supervisor:
+	/// --- lsb ---
+	/// bit 0      : REVERT - Revert all storage changes made by the caller.
+	/// bit [1, 31]: Reserved for future use.
+	/// --- msb ---
+	///
+	/// Using a reserved bit triggers a trap.
+	fn seal_return(
+		ctx: _,
+		memory: _,
+		flags: u32,
+		data_ptr: u32,
+		data_len: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Return(data_len))?;
+		Err(TrapReason::Return(ReturnData {
+			flags,
+			data: ctx.read_sandbox_memory(memory, data_ptr, data_len)?,
+		}))
+	}
+
+	/// Stores the address of the caller into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// If this is a top-level call (i.e. initiated by an extrinsic) the origin address of the
+	/// extrinsic will be returned. Otherwise, if this call is initiated by another contract then
+	/// the address of the contract will be returned. The value is encoded as T::AccountId.
+	///
+	/// If there is no address associated with the caller (e.g. because the caller is root) then
+	/// it traps with `BadOrigin`.
+	#[prefixed_alias]
+	fn caller(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Caller)?;
+		let caller = ctx.ext.caller().account_id()?.clone();
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&caller.encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Checks whether a specified address belongs to a contract.
+	///
+	/// # Parameters
+	///
+	/// - `account_ptr`: a pointer to the address of the beneficiary account Should be decodable as
+	///   an `T::AccountId`. Traps otherwise.
+	///
+	/// Returned value is a `u32`-encoded boolean: (0 = false, 1 = true).
+	#[prefixed_alias]
+	fn is_contract(ctx: _, memory: _, account_ptr: u32) -> Result<u32, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::IsContract)?;
+		let address: <<E as Ext>::T as frame_system::Config>::AccountId =
+			ctx.read_sandbox_memory_as(memory, account_ptr)?;
+
+		Ok(ctx.ext.is_contract(&address) as u32)
+	}
+
+	/// Retrieve the code hash for a specified contract address.
+	///
+	/// # Parameters
+	///
+	/// - `account_ptr`: a pointer to the address in question. Should be decodable as an
+	///   `T::AccountId`. Traps otherwise.
+	/// - `out_ptr`: pointer to the linear memory where the returning value is written to.
+	/// - `out_len_ptr`: in-out pointer into linear memory where the buffer length is read from and
+	///   the value length is written to.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::KeyNotFound`
+	#[prefixed_alias]
+	fn code_hash(
+		ctx: _,
+		memory: _,
+		account_ptr: u32,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::CodeHash)?;
+		let address: <<E as Ext>::T as frame_system::Config>::AccountId =
+			ctx.read_sandbox_memory_as(memory, account_ptr)?;
+		if let Some(value) = ctx.ext.code_hash(&address) {
+			ctx.write_sandbox_output(
+				memory,
+				out_ptr,
+				out_len_ptr,
+				&value.encode(),
+				false,
+				already_charged,
+			)?;
+			Ok(ReturnCode::Success)
+		} else {
+			Ok(ReturnCode::KeyNotFound)
+		}
+	}
+
+	/// Retrieve the code hash of the currently executing contract.
+	///
+	/// # Parameters
+	///
+	/// - `out_ptr`: pointer to the linear memory where the returning value is written to.
+	/// - `out_len_ptr`: in-out pointer into linear memory where the buffer length is read from and
+	///   the value length is written to.
+	#[prefixed_alias]
+	fn own_code_hash(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::OwnCodeHash)?;
+		let code_hash_encoded = &ctx.ext.own_code_hash().encode();
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			code_hash_encoded,
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Checks whether the caller of the current contract is the origin of the whole call stack.
+	///
+	/// Prefer this over [`is_contract()`][`Self::is_contract`] when checking whether your contract
+	/// is being called by a contract or a plain account. The reason is that it performs better
+	/// since it does not need to do any storage lookups.
+	///
+	/// A return value of `true` indicates that this contract is being called by a plain account
+	/// and `false` indicates that the caller is another contract.
+	///
+	/// Returned value is a `u32`-encoded boolean: (`0 = false`, `1 = true`).
+	#[prefixed_alias]
+	fn caller_is_origin(ctx: _, _memory: _) -> Result<u32, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::CallerIsOrigin)?;
+		Ok(ctx.ext.caller_is_origin() as u32)
+	}
+
+	/// Checks whether the caller of the current contract is root.
+	///
+	/// Note that only the origin of the call stack can be root. Hence this function returning
+	/// `true` implies that the contract is being called by the origin.
+	///
+	/// A return value of `true` indicates that this contract is being called by a root origin,
+	/// and `false` indicates that the caller is a signed origin.
+	///
+	/// Returned value is a `u32`-encoded boolean: (`0 = false`, `1 = true`).
+	#[unstable]
+	fn caller_is_root(ctx: _, _memory: _) -> Result<u32, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::CallerIsRoot)?;
+		Ok(ctx.ext.caller_is_root() as u32)
+	}
+
+	/// Stores the address of the current contract into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	#[prefixed_alias]
+	fn address(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Address)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.address().encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the price for the specified amount of gas into the supplied buffer.
+	///
+	/// Equivalent to the newer [`seal1`][`super::api_doc::Version2::weight_to_fee`] version but
+	/// works with *ref_time* Weight only. It is recommended to switch to the latest version, once
+	/// it's stabilized.
+	#[prefixed_alias]
+	fn weight_to_fee(
+		ctx: _,
+		memory: _,
+		gas: u64,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<(), TrapReason> {
+		let gas = Weight::from_parts(gas, 0);
+		ctx.charge_gas(RuntimeCosts::WeightToFee)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.get_weight_price(gas).encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the price for the specified amount of weight into the supplied buffer.
+	///
+	/// # Parameters
+	///
+	/// - `out_ptr`: pointer to the linear memory where the returning value is written to. If the
+	///   available space at `out_ptr` is less than the size of the value a trap is triggered.
+	/// - `out_len_ptr`: in-out pointer into linear memory where the buffer length is read from and
+	///   the value length is written to.
+	///
+	/// The data is encoded as `T::Balance`.
+	///
+	/// # Note
+	///
+	/// It is recommended to avoid specifying very small values for `ref_time_limit` and
+	/// `proof_size_limit` as the prices for a single gas can be smaller than the basic balance
+	/// unit.
+	#[version(1)]
+	#[unstable]
+	fn weight_to_fee(
+		ctx: _,
+		memory: _,
+		ref_time_limit: u64,
+		proof_size_limit: u64,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<(), TrapReason> {
+		let weight = Weight::from_parts(ref_time_limit, proof_size_limit);
+		ctx.charge_gas(RuntimeCosts::WeightToFee)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.get_weight_price(weight).encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the weight left into the supplied buffer.
+	///
+	/// Equivalent to the newer [`seal1`][`super::api_doc::Version2::gas_left`] version but
+	/// works with *ref_time* Weight only. It is recommended to switch to the latest version, once
+	/// it's stabilized.
+	#[prefixed_alias]
+	fn gas_left(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::GasLeft)?;
+		let gas_left = &ctx.ext.gas_meter().gas_left().ref_time().encode();
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			gas_left,
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the amount of weight left into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// The data is encoded as Weight.
+	#[version(1)]
+	#[unstable]
+	fn gas_left(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::GasLeft)?;
+		let gas_left = &ctx.ext.gas_meter().gas_left().encode();
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			gas_left,
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the *free* balance of the current account into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// The data is encoded as `T::Balance`.
+	#[prefixed_alias]
+	fn balance(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Balance)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.balance().encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the value transferred along with this call/instantiate into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a `u32` value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// The data is encoded as `T::Balance`.
+	#[prefixed_alias]
+	fn value_transferred(
+		ctx: _,
+		memory: _,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::ValueTransferred)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.value_transferred().encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores a random number for the current block and the given subject into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// The data is encoded as `T::Hash`.
+	#[prefixed_alias]
+	#[deprecated]
+	fn random(
+		ctx: _,
+		memory: _,
+		subject_ptr: u32,
+		subject_len: u32,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Random)?;
+		if subject_len > ctx.ext.schedule().limits.subject_len {
+			return Err(Error::<E::T>::RandomSubjectTooLong.into())
+		}
+		let subject_buf = ctx.read_sandbox_memory(memory, subject_ptr, subject_len)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.random(&subject_buf).0.encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores a random number for the current block and the given subject into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// The data is encoded as (T::Hash, frame_system::pallet_prelude::BlockNumberFor::<T>).
+	///
+	/// # Changes from v0
+	///
+	/// In addition to the seed it returns the block number since which it was determinable
+	/// by chain observers.
+	///
+	/// # Note
+	///
+	/// The returned seed should only be used to distinguish commitments made before
+	/// the returned block number. If the block number is too early (i.e. commitments were
+	/// made afterwards), then ensure no further commitments may be made and repeatedly
+	/// call this on later blocks until the block number returned is later than the latest
+	/// commitment.
+	#[version(1)]
+	#[prefixed_alias]
+	#[deprecated]
+	fn random(
+		ctx: _,
+		memory: _,
+		subject_ptr: u32,
+		subject_len: u32,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Random)?;
+		if subject_len > ctx.ext.schedule().limits.subject_len {
+			return Err(Error::<E::T>::RandomSubjectTooLong.into())
+		}
+		let subject_buf = ctx.read_sandbox_memory(memory, subject_ptr, subject_len)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.random(&subject_buf).encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Load the latest block timestamp into the supplied buffer
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	#[prefixed_alias]
+	fn now(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Now)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.now().encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the minimum balance (a.k.a. existential deposit) into the supplied buffer.
+	///
+	/// The data is encoded as `T::Balance`.
+	#[prefixed_alias]
+	fn minimum_balance(
+		ctx: _,
+		memory: _,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::MinimumBalance)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.minimum_balance().encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Stores the tombstone deposit into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// # Note
+	///
+	/// There is no longer a tombstone deposit. This function always returns `0`.
+	#[prefixed_alias]
+	#[deprecated]
+	fn tombstone_deposit(
+		ctx: _,
+		memory: _,
+		out_ptr: u32,
+		out_len_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Balance)?;
+		let deposit = <BalanceOf<E::T>>::zero().encode();
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&deposit,
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Was used to restore the given destination contract sacrificing the caller.
+	///
+	/// # Note
+	///
+	/// The state rent functionality was removed. This is stub only exists for
+	/// backwards compatibility
+	#[prefixed_alias]
+	#[deprecated]
+	fn restore_to(
+		ctx: _,
+		memory: _,
+		_dest_ptr: u32,
+		_dest_len: u32,
+		_code_hash_ptr: u32,
+		_code_hash_len: u32,
+		_rent_allowance_ptr: u32,
+		_rent_allowance_len: u32,
+		_delta_ptr: u32,
+		_delta_count: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
+		Ok(())
+	}
+
+	/// Was used to restore the given destination contract sacrificing the caller.
+	///
+	/// # Note
+	///
+	/// The state rent functionality was removed. This is stub only exists for
+	/// backwards compatibility
+	#[version(1)]
+	#[prefixed_alias]
+	#[deprecated]
+	fn restore_to(
+		ctx: _,
+		memory: _,
+		_dest_ptr: u32,
+		_code_hash_ptr: u32,
+		_rent_allowance_ptr: u32,
+		_delta_ptr: u32,
+		_delta_count: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
+		Ok(())
+	}
+
+	/// Was used to set rent allowance of the contract.
+	///
+	/// # Note
+	///
+	/// The state rent functionality was removed. This is stub only exists for
+	/// backwards compatibility.
+	#[prefixed_alias]
+	#[deprecated]
+	fn set_rent_allowance(
+		ctx: _,
+		memory: _,
+		_value_ptr: u32,
+		_value_len: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
+		Ok(())
+	}
+
+	/// Was used to set rent allowance of the contract.
+	///
+	/// # Note
+	///
+	/// The state rent functionality was removed. This is stub only exists for
+	/// backwards compatibility.
+	#[version(1)]
+	#[prefixed_alias]
+	#[deprecated]
+	fn set_rent_allowance(ctx: _, _memory: _, _value_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::DebugMessage(0))?;
+		Ok(())
+	}
+
+	/// Was used to store the rent allowance into the supplied buffer.
+	///
+	/// # Note
+	///
+	/// The state rent functionality was removed. This is stub only exists for
+	/// backwards compatibility.
+	#[prefixed_alias]
+	#[deprecated]
+	fn rent_allowance(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Balance)?;
+		let rent_allowance = <BalanceOf<E::T>>::max_value().encode();
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&rent_allowance,
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Deposit a contract event with the data buffer and optional list of topics. There is a limit
+	/// on the maximum number of topics specified by `event_topics`.
+	///
+	/// - `topics_ptr`: a pointer to the buffer of topics encoded as `Vec<T::Hash>`. The value of
+	///   this is ignored if `topics_len` is set to `0`. The topics list can't contain duplicates.
+	/// - `topics_len`:  the length of the topics buffer. Pass 0 if you want to pass an empty
+	///   vector.
+	/// - `data_ptr`: a pointer to a raw data buffer which will saved along the event.
+	/// - `data_len`:  the length of the data buffer.
+	#[prefixed_alias]
+	fn deposit_event(
+		ctx: _,
+		memory: _,
+		topics_ptr: u32,
+		topics_len: u32,
+		data_ptr: u32,
+		data_len: u32,
+	) -> Result<(), TrapReason> {
+		let num_topic = topics_len
+			.checked_div(sp_std::mem::size_of::<TopicOf<E::T>>() as u32)
+			.ok_or("Zero sized topics are not allowed")?;
+		ctx.charge_gas(RuntimeCosts::DepositEvent { num_topic, len: data_len })?;
+		if data_len > ctx.ext.max_value_size() {
+			return Err(Error::<E::T>::ValueTooLarge.into())
+		}
+
+		let topics: Vec<TopicOf<<E as Ext>::T>> = match topics_len {
+			0 => Vec::new(),
+			_ => ctx.read_sandbox_memory_as_unbounded(memory, topics_ptr, topics_len)?,
+		};
+
+		// If there are more than `event_topics`, then trap.
+		if topics.len() > ctx.ext.schedule().limits.event_topics as usize {
+			return Err(Error::<E::T>::TooManyTopics.into())
+		}
+
+		let event_data = ctx.read_sandbox_memory(memory, data_ptr, data_len)?;
+
+		ctx.ext.deposit_event(topics, event_data);
+
+		Ok(())
+	}
+
+	/// Stores the current block number of the current contract into the supplied buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// `out_len_ptr` must point to a u32 value that describes the available space at
+	/// `out_ptr`. This call overwrites it with the size of the value. If the available
+	/// space at `out_ptr` is less than the size of the value a trap is triggered.
+	#[prefixed_alias]
+	fn block_number(ctx: _, memory: _, out_ptr: u32, out_len_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::BlockNumber)?;
+		Ok(ctx.write_sandbox_output(
+			memory,
+			out_ptr,
+			out_len_ptr,
+			&ctx.ext.block_number().encode(),
+			false,
+			already_charged,
+		)?)
+	}
+
+	/// Computes the SHA2 256-bit hash on the given input buffer.
+	///
+	/// Returns the result directly into the given output buffer.
+	///
+	/// # Note
+	///
+	/// - The `input` and `output` buffer may overlap.
+	/// - The output buffer is expected to hold at least 32 bytes (256 bits).
+	/// - It is the callers responsibility to provide an output buffer that is large enough to hold
+	///   the expected amount of bytes returned by the chosen hash function.
+	///
+	/// # Parameters
+	///
+	/// - `input_ptr`: the pointer into the linear memory where the input data is placed.
+	/// - `input_len`: the length of the input data in bytes.
+	/// - `output_ptr`: the pointer into the linear memory where the output data is placed. The
+	///   function will write the result directly into this buffer.
+	#[prefixed_alias]
+	fn hash_sha2_256(
+		ctx: _,
+		memory: _,
+		input_ptr: u32,
+		input_len: u32,
+		output_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::HashSha256(input_len))?;
+		Ok(ctx.compute_hash_on_intermediate_buffer(
+			memory, sha2_256, input_ptr, input_len, output_ptr,
+		)?)
+	}
+
+	/// Computes the KECCAK 256-bit hash on the given input buffer.
+	///
+	/// Returns the result directly into the given output buffer.
+	///
+	/// # Note
+	///
+	/// - The `input` and `output` buffer may overlap.
+	/// - The output buffer is expected to hold at least 32 bytes (256 bits).
+	/// - It is the callers responsibility to provide an output buffer that is large enough to hold
+	///   the expected amount of bytes returned by the chosen hash function.
+	///
+	/// # Parameters
+	///
+	/// - `input_ptr`: the pointer into the linear memory where the input data is placed.
+	/// - `input_len`: the length of the input data in bytes.
+	/// - `output_ptr`: the pointer into the linear memory where the output data is placed. The
+	///   function will write the result directly into this buffer.
+	#[prefixed_alias]
+	fn hash_keccak_256(
+		ctx: _,
+		memory: _,
+		input_ptr: u32,
+		input_len: u32,
+		output_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::HashKeccak256(input_len))?;
+		Ok(ctx.compute_hash_on_intermediate_buffer(
+			memory, keccak_256, input_ptr, input_len, output_ptr,
+		)?)
+	}
+
+	/// Computes the BLAKE2 256-bit hash on the given input buffer.
+	///
+	/// Returns the result directly into the given output buffer.
+	///
+	/// # Note
+	///
+	/// - The `input` and `output` buffer may overlap.
+	/// - The output buffer is expected to hold at least 32 bytes (256 bits).
+	/// - It is the callers responsibility to provide an output buffer that is large enough to hold
+	///   the expected amount of bytes returned by the chosen hash function.
+	///
+	/// # Parameters
+	///
+	/// - `input_ptr`: the pointer into the linear memory where the input data is placed.
+	/// - `input_len`: the length of the input data in bytes.
+	/// - `output_ptr`: the pointer into the linear memory where the output data is placed. The
+	///   function will write the result directly into this buffer.
+	#[prefixed_alias]
+	fn hash_blake2_256(
+		ctx: _,
+		memory: _,
+		input_ptr: u32,
+		input_len: u32,
+		output_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::HashBlake256(input_len))?;
+		Ok(ctx.compute_hash_on_intermediate_buffer(
+			memory, blake2_256, input_ptr, input_len, output_ptr,
+		)?)
+	}
+
+	/// Computes the BLAKE2 128-bit hash on the given input buffer.
+	///
+	/// Returns the result directly into the given output buffer.
+	///
+	/// # Note
+	///
+	/// - The `input` and `output` buffer may overlap.
+	/// - The output buffer is expected to hold at least 16 bytes (128 bits).
+	/// - It is the callers responsibility to provide an output buffer that is large enough to hold
+	///   the expected amount of bytes returned by the chosen hash function.
+	///
+	/// # Parameters
+	///
+	/// - `input_ptr`: the pointer into the linear memory where the input data is placed.
+	/// - `input_len`: the length of the input data in bytes.
+	/// - `output_ptr`: the pointer into the linear memory where the output data is placed. The
+	///   function will write the result directly into this buffer.
+	#[prefixed_alias]
+	fn hash_blake2_128(
+		ctx: _,
+		memory: _,
+		input_ptr: u32,
+		input_len: u32,
+		output_ptr: u32,
+	) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::HashBlake128(input_len))?;
+		Ok(ctx.compute_hash_on_intermediate_buffer(
+			memory, blake2_128, input_ptr, input_len, output_ptr,
+		)?)
+	}
+
+	/// Call into the chain extension provided by the chain if any.
+	///
+	/// Handling of the input values is up to the specific chain extension and so is the
+	/// return value. The extension can decide to use the inputs as primitive inputs or as
+	/// in/out arguments by interpreting them as pointers. Any caller of this function
+	/// must therefore coordinate with the chain that it targets.
+	///
+	/// # Note
+	///
+	/// If no chain extension exists the contract will trap with the `NoChainExtension`
+	/// module error.
+	#[prefixed_alias]
+	fn call_chain_extension(
+		ctx: _,
+		memory: _,
+		id: u32,
+		input_ptr: u32,
+		input_len: u32,
+		output_ptr: u32,
+		output_len_ptr: u32,
+	) -> Result<u32, TrapReason> {
+		use crate::chain_extension::{ChainExtension, Environment, RetVal};
+		if !<E::T as Config>::ChainExtension::enabled() {
+			return Err(Error::<E::T>::NoChainExtension.into())
+		}
+		let mut chain_extension = ctx.chain_extension.take().expect(
+			"Constructor initializes with `Some`. This is the only place where it is set to `None`.\
+			It is always reset to `Some` afterwards. qed"
+		);
+		let env =
+			Environment::new(ctx, memory, id, input_ptr, input_len, output_ptr, output_len_ptr);
+		let ret = match chain_extension.call(env)? {
+			RetVal::Converging(val) => Ok(val),
+			RetVal::Diverging { flags, data } =>
+				Err(TrapReason::Return(ReturnData { flags: flags.bits(), data })),
+		};
+		ctx.chain_extension = Some(chain_extension);
+		ret
+	}
+
+	/// Emit a custom debug message.
+	///
+	/// No newlines are added to the supplied message.
+	/// Specifying invalid UTF-8 just drops the message with no trap.
+	///
+	/// This is a no-op if debug message recording is disabled which is always the case
+	/// when the code is executing on-chain. The message is interpreted as UTF-8 and
+	/// appended to the debug buffer which is then supplied to the calling RPC client.
+	///
+	/// # Note
+	///
+	/// Even though no action is taken when debug message recording is disabled there is still
+	/// a non trivial overhead (and weight cost) associated with calling this function. Contract
+	/// languages should remove calls to this function (either at runtime or compile time) when
+	/// not being executed as an RPC. For example, they could allow users to disable logging
+	/// through compile time flags (cargo features) for on-chain deployment. Additionally, the
+	/// return value of this function can be cached in order to prevent further calls at runtime.
+	#[prefixed_alias]
+	fn debug_message(
+		ctx: _,
+		memory: _,
+		str_ptr: u32,
+		str_len: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		let str_len = str_len.min(DebugBufferVec::<E::T>::bound() as u32);
+		ctx.charge_gas(RuntimeCosts::DebugMessage(str_len))?;
+		if ctx.ext.append_debug_buffer("") {
+			let data = ctx.read_sandbox_memory(memory, str_ptr, str_len)?;
+			if let Some(msg) = core::str::from_utf8(&data).ok() {
+				ctx.ext.append_debug_buffer(msg);
+			}
+		}
+		Ok(ReturnCode::Success)
+	}
+
+	/// Call some dispatchable of the runtime.
+	///
+	/// This function decodes the passed in data as the overarching `Call` type of the
+	/// runtime and dispatches it. The weight as specified in the runtime is charged
+	/// from the gas meter. Any weight refunds made by the dispatchable are considered.
+	///
+	/// The filter specified by `Config::CallFilter` is attached to the origin of
+	/// the dispatched call.
+	///
+	/// # Parameters
+	///
+	/// - `call_ptr`: the pointer into the linear memory where the input data is placed.
+	/// - `call_len`: the length of the input data in bytes.
+	///
+	/// # Return Value
+	///
+	/// Returns `ReturnCode::Success` when the dispatchable was successfully executed and
+	/// returned `Ok`. When the dispatchable was exeuted but returned an error
+	/// `ReturnCode::CallRuntimeFailed` is returned. The full error is not
+	/// provided because it is not guaranteed to be stable.
+	///
+	/// # Comparison with `ChainExtension`
+	///
+	/// Just as a chain extension this API allows the runtime to extend the functionality
+	/// of contracts. While making use of this function is generally easier it cannot be
+	/// used in all cases. Consider writing a chain extension if you need to do perform
+	/// one of the following tasks:
+	///
+	/// - Return data.
+	/// - Provide functionality **exclusively** to contracts.
+	/// - Provide custom weights.
+	/// - Avoid the need to keep the `Call` data structure stable.
+	fn call_runtime(
+		ctx: _,
+		memory: _,
+		call_ptr: u32,
+		call_len: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		use frame_support::dispatch::{extract_actual_weight, GetDispatchInfo};
+		ctx.charge_gas(RuntimeCosts::CopyFromContract(call_len))?;
+		let call: <E::T as Config>::RuntimeCall =
+			ctx.read_sandbox_memory_as_unbounded(memory, call_ptr, call_len)?;
+		let dispatch_info = call.get_dispatch_info();
+		let charged = ctx.charge_gas(RuntimeCosts::CallRuntime(dispatch_info.weight))?;
+		let result = ctx.ext.call_runtime(call);
+		let actual_weight = extract_actual_weight(&result, &dispatch_info);
+		ctx.adjust_gas(charged, RuntimeCosts::CallRuntime(actual_weight));
+		match result {
+			Ok(_) => Ok(ReturnCode::Success),
+			Err(e) => {
+				if ctx.ext.append_debug_buffer("") {
+					ctx.ext.append_debug_buffer("seal0::call_runtime failed with: ");
+					ctx.ext.append_debug_buffer(e.into());
+				};
+				Ok(ReturnCode::CallRuntimeFailed)
+			},
+		}
+	}
+
+	/// Recovers the ECDSA public key from the given message hash and signature.
+	///
+	/// Writes the public key into the given output buffer.
+	/// Assumes the secp256k1 curve.
+	///
+	/// # Parameters
+	///
+	/// - `signature_ptr`: the pointer into the linear memory where the signature is placed. Should
+	///   be decodable as a 65 bytes. Traps otherwise.
+	/// - `message_hash_ptr`: the pointer into the linear memory where the message hash is placed.
+	///   Should be decodable as a 32 bytes. Traps otherwise.
+	/// - `output_ptr`: the pointer into the linear memory where the output data is placed. The
+	///   buffer should be 33 bytes. The function will write the result directly into this buffer.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::EcdsaRecoverFailed`
+	#[prefixed_alias]
+	fn ecdsa_recover(
+		ctx: _,
+		memory: _,
+		signature_ptr: u32,
+		message_hash_ptr: u32,
+		output_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::EcdsaRecovery)?;
+
+		let mut signature: [u8; 65] = [0; 65];
+		ctx.read_sandbox_memory_into_buf(memory, signature_ptr, &mut signature)?;
+		let mut message_hash: [u8; 32] = [0; 32];
+		ctx.read_sandbox_memory_into_buf(memory, message_hash_ptr, &mut message_hash)?;
+
+		let result = ctx.ext.ecdsa_recover(&signature, &message_hash);
+
+		match result {
+			Ok(pub_key) => {
+				// Write the recovered compressed ecdsa public key back into the sandboxed output
+				// buffer.
+				ctx.write_sandbox_memory(memory, output_ptr, pub_key.as_ref())?;
+
+				Ok(ReturnCode::Success)
+			},
+			Err(_) => Ok(ReturnCode::EcdsaRecoverFailed),
+		}
+	}
+
+	/// Verify a sr25519 signature
+	///
+	/// # Parameters
+	///
+	/// - `signature_ptr`: the pointer into the linear memory where the signature is placed. Should
+	///   be a value of 64 bytes.
+	/// - `pub_key_ptr`: the pointer into the linear memory where the public key is placed. Should
+	///   be a value of 32 bytes.
+	/// - `message_len`: the length of the message payload.
+	/// - `message_ptr`: the pointer into the linear memory where the message is placed.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::Sr25519VerifyFailed
+	#[unstable]
+	fn sr25519_verify(
+		ctx: _,
+		memory: _,
+		signature_ptr: u32,
+		pub_key_ptr: u32,
+		message_len: u32,
+		message_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::Sr25519Verify(message_len))?;
+
+		let mut signature: [u8; 64] = [0; 64];
+		ctx.read_sandbox_memory_into_buf(memory, signature_ptr, &mut signature)?;
+
+		let mut pub_key: [u8; 32] = [0; 32];
+		ctx.read_sandbox_memory_into_buf(memory, pub_key_ptr, &mut pub_key)?;
+
+		let message: Vec<u8> = ctx.read_sandbox_memory(memory, message_ptr, message_len)?;
+
+		if ctx.ext.sr25519_verify(&signature, &message, &pub_key) {
+			Ok(ReturnCode::Success)
+		} else {
+			Ok(ReturnCode::Sr25519VerifyFailed)
+		}
+	}
+
+	/// Replace the contract code at the specified address with new code.
+	///
+	/// # Note
+	///
+	/// There are a couple of important considerations which must be taken into account when
+	/// using this API:
+	///
+	/// 1. The storage at the code address will remain untouched. This means that contract
+	/// developers must ensure that the storage layout of the new code is compatible with that of
+	/// the old code.
+	///
+	/// 2. Contracts using this API can't be assumed as having deterministic addresses. Said another
+	/// way, when using this API you lose the guarantee that an address always identifies a specific
+	/// code hash.
+	///
+	/// 3. If a contract calls into itself after changing its code the new call would use
+	/// the new code. However, if the original caller panics after returning from the sub call it
+	/// would revert the changes made by [`set_code_hash()`][`Self::set_code_hash`] and the next
+	/// caller would use the old code.
+	///
+	/// # Parameters
+	///
+	/// - `code_hash_ptr`: A pointer to the buffer that contains the new code hash.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::CodeNotFound`
+	#[prefixed_alias]
+	fn set_code_hash(ctx: _, memory: _, code_hash_ptr: u32) -> Result<ReturnCode, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::SetCodeHash)?;
+		let code_hash: CodeHash<<E as Ext>::T> =
+			ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
+		match ctx.ext.set_code_hash(code_hash) {
+			Err(err) => {
+				let code = Runtime::<E>::err_into_return_code(err)?;
+				Ok(code)
+			},
+			Ok(()) => Ok(ReturnCode::Success),
+		}
+	}
+
+	/// Calculates Ethereum address from the ECDSA compressed public key and stores
+	/// it into the supplied buffer.
+	///
+	/// # Parameters
+	///
+	/// - `key_ptr`: a pointer to the ECDSA compressed public key. Should be decodable as a 33 bytes
+	///   value. Traps otherwise.
+	/// - `out_ptr`: the pointer into the linear memory where the output data is placed. The
+	///   function will write the result directly into this buffer.
+	///
+	/// The value is stored to linear memory at the address pointed to by `out_ptr`.
+	/// If the available space at `out_ptr` is less than the size of the value a trap is triggered.
+	///
+	/// # Errors
+	///
+	/// - `ReturnCode::EcdsaRecoverFailed`
+	#[prefixed_alias]
+	fn ecdsa_to_eth_address(
+		ctx: _,
+		memory: _,
+		key_ptr: u32,
+		out_ptr: u32,
+	) -> Result<ReturnCode, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::EcdsaToEthAddress)?;
+		let mut compressed_key: [u8; 33] = [0; 33];
+		ctx.read_sandbox_memory_into_buf(memory, key_ptr, &mut compressed_key)?;
+		let result = ctx.ext.ecdsa_to_eth_address(&compressed_key);
+		match result {
+			Ok(eth_address) => {
+				ctx.write_sandbox_memory(memory, out_ptr, eth_address.as_ref())?;
+				Ok(ReturnCode::Success)
+			},
+			Err(_) => Ok(ReturnCode::EcdsaRecoverFailed),
+		}
+	}
+
+	/// Returns the number of times the currently executing contract exists on the call stack in
+	/// addition to the calling instance.
+	///
+	/// # Return Value
+	///
+	/// Returns `0` when there is no reentrancy.
+	#[unstable]
+	fn reentrance_count(ctx: _, memory: _) -> Result<u32, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::ReentrantCount)?;
+		Ok(ctx.ext.reentrance_count())
+	}
+
+	/// Returns the number of times specified contract exists on the call stack. Delegated calls are
+	/// not counted as separate calls.
+	///
+	/// # Parameters
+	///
+	/// - `account_ptr`: a pointer to the contract address.
+	///
+	/// # Return Value
+	///
+	/// Returns `0` when the contract does not exist on the call stack.
+	#[unstable]
+	fn account_reentrance_count(ctx: _, memory: _, account_ptr: u32) -> Result<u32, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::AccountEntranceCount)?;
+		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))
+	}
+
+	/// Returns a nonce that is unique per contract instantiation.
+	///
+	/// The nonce is incremented for each successful contract instantiation. This is a
+	/// sensible default salt for contract instantiations.
+	fn instantiation_nonce(ctx: _, _memory: _) -> Result<u64, TrapReason> {
+		ctx.charge_gas(RuntimeCosts::InstantationNonce)?;
+		Ok(ctx.ext.nonce())
+	}
+
+	/// Adds a new delegate dependency to the contract.
+	///
+	/// # Parameters
+	///
+	/// - `code_hash_ptr`: A pointer to the code hash of the dependency.
+	#[unstable]
+	fn add_delegate_dependency(ctx: _, memory: _, code_hash_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::AddDelegateDependency)?;
+		let code_hash = ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
+		ctx.ext.add_delegate_dependency(code_hash)?;
+		Ok(())
+	}
+
+	/// Removes the delegate dependency from the contract.
+	///
+	/// # Parameters
+	///
+	/// - `code_hash_ptr`: A pointer to the code hash of the dependency.
+	#[unstable]
+	fn remove_delegate_dependency(ctx: _, memory: _, code_hash_ptr: u32) -> Result<(), TrapReason> {
+		ctx.charge_gas(RuntimeCosts::RemoveDelegateDependency)?;
+		let code_hash = ctx.read_sandbox_memory_as(memory, code_hash_ptr)?;
+		ctx.ext.remove_delegate_dependency(&code_hash)?;
+		Ok(())
+	}
+}
diff --git a/substrate/frame/contracts/src/weights.rs b/substrate/frame/contracts/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..34bea8ff0a30ff0546c88c8b84895e87c4ce53ea
--- /dev/null
+++ b/substrate/frame/contracts/src/weights.rs
@@ -0,0 +1,3926 @@
+// 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.
+
+//! Autogenerated weights for `pallet_contracts`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-ynta1nyy-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: ``, WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
+
+// Executed Command:
+// target/production/substrate-node
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_contracts
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/contracts/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pallet_contracts`.
+pub trait WeightInfo {
+	fn on_process_deletion_queue_batch() -> Weight;
+	fn on_initialize_per_trie_key(k: u32, ) -> Weight;
+	fn v9_migration_step(c: u32, ) -> Weight;
+	fn v10_migration_step() -> Weight;
+	fn v11_migration_step(k: u32, ) -> Weight;
+	fn v12_migration_step(c: u32, ) -> Weight;
+	fn v13_migration_step() -> Weight;
+	fn v14_migration_step() -> Weight;
+	fn v15_migration_step() -> Weight;
+	fn migration_noop() -> Weight;
+	fn migrate() -> Weight;
+	fn on_runtime_upgrade_noop() -> Weight;
+	fn on_runtime_upgrade_in_progress() -> Weight;
+	fn on_runtime_upgrade() -> Weight;
+	fn call_with_code_per_byte(c: u32, ) -> Weight;
+	fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight;
+	fn instantiate(i: u32, s: u32, ) -> Weight;
+	fn call() -> Weight;
+	fn upload_code(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 add_delegate_dependency(r: u32, ) -> Weight;
+	fn remove_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 instr_i64const(r: u32, ) -> Weight;
+}
+
+/// Weights for `pallet_contracts` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `Contracts::DeletionQueueCounter` (r:1 w:0)
+	/// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	fn on_process_deletion_queue_batch() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1627`
+		// Minimum execution time: 2_410_000 picoseconds.
+		Weight::from_parts(2_581_000, 1627)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Skipped::Metadata` (r:0 w:0)
+	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `k` is `[0, 1024]`.
+	fn on_initialize_per_trie_key(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `451 + k * (69 ±0)`
+		//  Estimated: `441 + k * (70 ±0)`
+		// Minimum execution time: 13_278_000 picoseconds.
+		Weight::from_parts(13_944_000, 441)
+			// Standard Error: 1_643
+			.saturating_add(Weight::from_parts(1_194_404, 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))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into())))
+			.saturating_add(Weight::from_parts(0, 70).saturating_mul(k.into()))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:2 w:1)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:2 w:1)
+	/// The range of component `c` is `[0, 125952]`.
+	fn v9_migration_step(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `211 + c * (1 ±0)`
+		//  Estimated: `6149 + c * (1 ±0)`
+		// Minimum execution time: 8_533_000 picoseconds.
+		Weight::from_parts(9_141_899, 6149)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_327, 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()))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	fn v10_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `510`
+		//  Estimated: `6450`
+		// Minimum execution time: 16_998_000 picoseconds.
+		Weight::from_parts(17_776_000, 6450)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::DeletionQueue` (r:1 w:1025)
+	/// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`)
+	/// Storage: `Contracts::DeletionQueueCounter` (r:0 w:1)
+	/// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	/// The range of component `k` is `[0, 1024]`.
+	fn v11_migration_step(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + k * (1 ±0)`
+		//  Estimated: `3635 + k * (1 ±0)`
+		// Minimum execution time: 3_919_000 picoseconds.
+		Weight::from_parts(4_057_153, 3635)
+			// Standard Error: 1_252
+			.saturating_add(Weight::from_parts(1_151_419, 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())))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into()))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553053f13fd319a03c211337c76e0fe776df` (r:2 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553053f13fd319a03c211337c76e0fe776df` (r:2 w:0)
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:0 w:1)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// The range of component `c` is `[0, 125952]`.
+	fn v12_migration_step(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `325 + c * (1 ±0)`
+		//  Estimated: `6263 + c * (1 ±0)`
+		// Minimum execution time: 17_730_000 picoseconds.
+		Weight::from_parts(17_540_884, 6263)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(417, 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()))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	fn v13_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `440`
+		//  Estimated: `6380`
+		// Minimum execution time: 13_089_000 picoseconds.
+		Weight::from_parts(13_727_000, 6380)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:0)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	fn v14_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `360`
+		//  Estimated: `6300`
+		// Minimum execution time: 49_083_000 picoseconds.
+		Weight::from_parts(50_462_000, 6300)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `System::Account` (r:2 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	fn v15_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `594`
+		//  Estimated: `6534`
+		// Minimum execution time: 49_299_000 picoseconds.
+		Weight::from_parts(50_805_000, 6534)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	fn migration_noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1627`
+		// Minimum execution time: 3_305_000 picoseconds.
+		Weight::from_parts(3_489_000, 1627)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1)
+	fn migrate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `166`
+		//  Estimated: `3631`
+		// Minimum execution time: 12_657_000 picoseconds.
+		Weight::from_parts(13_100_000, 3631)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	fn on_runtime_upgrade_noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3607`
+		// Minimum execution time: 4_784_000 picoseconds.
+		Weight::from_parts(4_994_000, 3607)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	fn on_runtime_upgrade_in_progress() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `167`
+		//  Estimated: `3632`
+		// Minimum execution time: 6_762_000 picoseconds.
+		Weight::from_parts(6_945_000, 3632)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	fn on_runtime_upgrade() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3607`
+		// Minimum execution time: 6_999_000 picoseconds.
+		Weight::from_parts(7_372_000, 3607)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::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: `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::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:  `759`
+		//  Estimated: `6710 + c * (1 ±0)`
+		// Minimum execution time: 304_121_000 picoseconds.
+		Weight::from_parts(288_627_840, 6710)
+			// Standard Error: 83
+			.saturating_add(Weight::from_parts(37_343, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// 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(85), added: 2560, 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)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, 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::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, 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]`.
+	/// The range of component `i` is `[0, 1048576]`.
+	/// The range of component `s` is `[0, 1048576]`.
+	fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `290`
+		//  Estimated: `8714`
+		// Minimum execution time: 4_101_589_000 picoseconds.
+		Weight::from_parts(694_193_047, 8714)
+			// Standard Error: 334
+			.saturating_add(Weight::from_parts(108_847, 0).saturating_mul(c.into()))
+			// Standard Error: 40
+			.saturating_add(Weight::from_parts(1_677, 0).saturating_mul(i.into()))
+			// Standard Error: 40
+			.saturating_add(Weight::from_parts(1_783, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(11_u64))
+			.saturating_add(T::DbWeight::get().writes(10_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// 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`)
+	/// 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)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, 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::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	/// Storage: `System::EventTopics` (r:2 w:2)
+	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1048576]`.
+	/// The range of component `s` is `[0, 1048576]`.
+	fn instantiate(i: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `527`
+		//  Estimated: `6471`
+		// Minimum execution time: 2_011_580_000 picoseconds.
+		Weight::from_parts(397_415_227, 6471)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(1_689, 0).saturating_mul(i.into()))
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(1_679, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(10_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`)
+	/// 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::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:  `793`
+		//  Estimated: `6733`
+		// Minimum execution time: 204_975_000 picoseconds.
+		Weight::from_parts(214_770_000, 6733)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// 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(85), added: 2560, 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]`.
+	fn upload_code(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3607`
+		// Minimum execution time: 269_545_000 picoseconds.
+		Weight::from_parts(256_054_650, 3607)
+			// Standard Error: 91
+			.saturating_add(Weight::from_parts(72_743, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// 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(85), added: 2560, 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: 47_880_000 picoseconds.
+		Weight::from_parts(49_427_000, 3780)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, 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: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: 37_898_000 picoseconds.
+		Weight::from_parts(39_826_000, 8967)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(6_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_caller(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `833 + r * (6 ±0)`
+		//  Estimated: `6773 + r * (6 ±0)`
+		// Minimum execution time: 260_916_000 picoseconds.
+		Weight::from_parts(295_521_846, 6773)
+			// Standard Error: 1_126
+			.saturating_add(Weight::from_parts(348_317, 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, 6).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:1601 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_is_contract(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `889 + r * (209 ±0)`
+		//  Estimated: `6793 + r * (2684 ±0)`
+		// Minimum execution time: 274_335_000 picoseconds.
+		Weight::from_parts(132_998_512, 6793)
+			// Standard Error: 7_396
+			.saturating_add(Weight::from_parts(3_602_287, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 2684).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:1601 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_code_hash(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `888 + r * (213 ±0)`
+		//  Estimated: `6797 + r * (2688 ±0)`
+		// Minimum execution time: 272_514_000 picoseconds.
+		Weight::from_parts(104_825_618, 6797)
+			// Standard Error: 10_038
+			.saturating_add(Weight::from_parts(4_520_258, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 2688).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_own_code_hash(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `840 + r * (6 ±0)`
+		//  Estimated: `6782 + r * (6 ±0)`
+		// Minimum execution time: 264_593_000 picoseconds.
+		Weight::from_parts(294_139_363, 6782)
+			// Standard Error: 907
+			.saturating_add(Weight::from_parts(432_964, 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, 6).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_caller_is_origin(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (3 ±0)`
+		//  Estimated: `6771 + r * (3 ±0)`
+		// Minimum execution time: 260_412_000 picoseconds.
+		Weight::from_parts(284_371_703, 6771)
+			// Standard Error: 433
+			.saturating_add(Weight::from_parts(182_952, 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()))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, 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_caller_is_root(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `720 + r * (3 ±0)`
+		//  Estimated: `6660 + r * (3 ±0)`
+		// Minimum execution time: 255_112_000 picoseconds.
+		Weight::from_parts(273_052_488, 6660)
+			// Standard Error: 376
+			.saturating_add(Weight::from_parts(166_644, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 3).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_address(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `834 + r * (6 ±0)`
+		//  Estimated: `6774 + r * (6 ±0)`
+		// Minimum execution time: 270_426_000 picoseconds.
+		Weight::from_parts(289_240_775, 6774)
+			// Standard Error: 748
+			.saturating_add(Weight::from_parts(344_791, 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, 6).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_gas_left(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (6 ±0)`
+		//  Estimated: `6773 + r * (6 ±0)`
+		// Minimum execution time: 260_217_000 picoseconds.
+		Weight::from_parts(288_660_978, 6773)
+			// Standard Error: 1_199
+			.saturating_add(Weight::from_parts(550_304, 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, 6).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:2 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_balance(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `974 + r * (6 ±0)`
+		//  Estimated: `6898 + r * (6 ±0)`
+		// Minimum execution time: 273_473_000 picoseconds.
+		Weight::from_parts(298_889_279, 6898)
+			// Standard Error: 4_604
+			.saturating_add(Weight::from_parts(1_630_175, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 6).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_value_transferred(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `844 + r * (6 ±0)`
+		//  Estimated: `6790 + r * (6 ±0)`
+		// Minimum execution time: 262_033_000 picoseconds.
+		Weight::from_parts(284_293_851, 6790)
+			// Standard Error: 591
+			.saturating_add(Weight::from_parts(369_240, 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, 6).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_minimum_balance(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `842 + r * (6 ±0)`
+		//  Estimated: `6783 + r * (6 ±0)`
+		// Minimum execution time: 274_568_000 picoseconds.
+		Weight::from_parts(294_688_466, 6783)
+			// Standard Error: 768
+			.saturating_add(Weight::from_parts(349_584, 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, 6).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_block_number(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839 + r * (6 ±0)`
+		//  Estimated: `6786 + r * (6 ±0)`
+		// Minimum execution time: 264_061_000 picoseconds.
+		Weight::from_parts(287_964_188, 6786)
+			// Standard Error: 490
+			.saturating_add(Weight::from_parts(356_273, 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, 6).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_now(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (6 ±0)`
+		//  Estimated: `6771 + r * (6 ±0)`
+		// Minimum execution time: 275_707_000 picoseconds.
+		Weight::from_parts(290_797_828, 6771)
+			// Standard Error: 967
+			.saturating_add(Weight::from_parts(352_839, 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, 6).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: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
+	/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, 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_weight_to_fee(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `904 + r * (14 ±0)`
+		//  Estimated: `6839 + r * (14 ±0)`
+		// Minimum execution time: 272_492_000 picoseconds.
+		Weight::from_parts(295_010_878, 6839)
+			// Standard Error: 2_549
+			.saturating_add(Weight::from_parts(1_426_715, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 14).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_input(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `832 + r * (6 ±0)`
+		//  Estimated: `6774 + r * (6 ±0)`
+		// Minimum execution time: 257_981_000 picoseconds.
+		Weight::from_parts(285_824_773, 6774)
+			// Standard Error: 704
+			.saturating_add(Weight::from_parts(301_327, 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, 6).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:  `836`
+		//  Estimated: `6776`
+		// Minimum execution time: 259_470_000 picoseconds.
+		Weight::from_parts(232_759_442, 6776)
+			// Standard Error: 24
+			.saturating_add(Weight::from_parts(981, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_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`)
+	/// 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, 1]`.
+	fn seal_return(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `820 + r * (45 ±0)`
+		//  Estimated: `6760 + r * (45 ±0)`
+		// Minimum execution time: 252_740_000 picoseconds.
+		Weight::from_parts(278_155_436, 6760)
+			// Standard Error: 882_420
+			.saturating_add(Weight::from_parts(755_063, 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, 45).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_return_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830`
+		//  Estimated: `6777`
+		// Minimum execution time: 257_318_000 picoseconds.
+		Weight::from_parts(285_765_697, 6777)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(322, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_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`)
+	/// 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:2 w:2)
+	/// 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(85), added: 2560, 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:  `2939 + r * (316 ±0)`
+		//  Estimated: `8879 + r * (5266 ±0)`
+		// Minimum execution time: 280_392_000 picoseconds.
+		Weight::from_parts(310_023_381, 8879)
+			// Standard Error: 1_008_026
+			.saturating_add(Weight::from_parts(130_208_818, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((10_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 5266).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: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0)
+	/// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, 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_random(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `911 + r * (10 ±0)`
+		//  Estimated: `6852 + r * (10 ±0)`
+		// Minimum execution time: 270_547_000 picoseconds.
+		Weight::from_parts(295_931_189, 6852)
+			// Standard Error: 3_280
+			.saturating_add(Weight::from_parts(1_941_248, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 10).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_deposit_event(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (10 ±0)`
+		//  Estimated: `6772 + r * (10 ±0)`
+		// Minimum execution time: 255_730_000 picoseconds.
+		Weight::from_parts(301_859_471, 6772)
+			// Standard Error: 5_401
+			.saturating_add(Weight::from_parts(3_887_632, 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, 10).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:6 w:6)
+	/// 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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `847 + t * (32 ±0)`
+		//  Estimated: `6792 + t * (2508 ±0)`
+		// Minimum execution time: 276_643_000 picoseconds.
+		Weight::from_parts(294_275_838, 6792)
+			// Standard Error: 106_745
+			.saturating_add(Weight::from_parts(2_831_489, 0).saturating_mul(t.into()))
+			// Standard Error: 29
+			.saturating_add(Weight::from_parts(624, 0).saturating_mul(n.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(3_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 2508).saturating_mul(t.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_debug_message(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829 + r * (7 ±0)`
+		//  Estimated: `6774 + r * (7 ±0)`
+		// Minimum execution time: 169_012_000 picoseconds.
+		Weight::from_parts(179_567_029, 6774)
+			// Standard Error: 534
+			.saturating_add(Weight::from_parts(249_500, 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, 7).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: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::PristineCode` (r:1 w:0)
+	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `MaxEncodedLen`)
+	/// Storage: `Timestamp::Now` (r:1 w:0)
+	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	/// Storage: `System::EventTopics` (r:2 w:2)
+	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1048576]`.
+	fn seal_debug_message_per_byte(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `125780`
+		//  Estimated: `131722`
+		// Minimum execution time: 408_647_000 picoseconds.
+		Weight::from_parts(387_678_006, 131722)
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(1_045, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// 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:  `891 + r * (292 ±0)`
+		//  Estimated: `892 + r * (293 ±0)`
+		// Minimum execution time: 279_315_000 picoseconds.
+		Weight::from_parts(171_270_899, 892)
+			// Standard Error: 15_492
+			.saturating_add(Weight::from_parts(6_776_878, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 293).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_set_storage_per_new_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1413`
+		//  Estimated: `1396`
+		// Minimum execution time: 289_666_000 picoseconds.
+		Weight::from_parts(348_062_625, 1396)
+			// Standard Error: 79
+			.saturating_add(Weight::from_parts(532, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(12_u64))
+			.saturating_add(T::DbWeight::get().writes(8_u64))
+	}
+	/// 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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1219 + n * (1 ±0)`
+		//  Estimated: `1219 + n * (1 ±0)`
+		// Minimum execution time: 273_840_000 picoseconds.
+		Weight::from_parts(297_024_621, 1219)
+			// Standard Error: 55
+			.saturating_add(Weight::from_parts(945, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(4_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:  `887 + r * (288 ±0)`
+		//  Estimated: `893 + r * (289 ±0)`
+		// Minimum execution time: 279_110_000 picoseconds.
+		Weight::from_parts(177_898_012, 893)
+			// Standard Error: 16_287
+			.saturating_add(Weight::from_parts(6_640_103, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 289).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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1215 + n * (1 ±0)`
+		//  Estimated: `1215 + n * (1 ±0)`
+		// Minimum execution time: 276_566_000 picoseconds.
+		Weight::from_parts(304_992_376, 1215)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(4_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:  `887 + r * (296 ±0)`
+		//  Estimated: `889 + r * (297 ±0)`
+		// Minimum execution time: 266_285_000 picoseconds.
+		Weight::from_parts(200_488_939, 889)
+			// Standard Error: 11_193
+			.saturating_add(Weight::from_parts(5_467_725, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 297).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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1231 + n * (1 ±0)`
+		//  Estimated: `1231 + n * (1 ±0)`
+		// Minimum execution time: 278_625_000 picoseconds.
+		Weight::from_parts(304_319_493, 1231)
+			// Standard Error: 39
+			.saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(3_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:  `898 + r * (288 ±0)`
+		//  Estimated: `895 + r * (289 ±0)`
+		// Minimum execution time: 271_851_000 picoseconds.
+		Weight::from_parts(202_164_395, 895)
+			// Standard Error: 11_115
+			.saturating_add(Weight::from_parts(5_273_320, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 289).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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1218 + n * (1 ±0)`
+		//  Estimated: `1218 + n * (1 ±0)`
+		// Minimum execution time: 274_200_000 picoseconds.
+		Weight::from_parts(299_524_586, 1218)
+			// Standard Error: 33
+			.saturating_add(Weight::from_parts(272, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(3_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:  `880 + r * (296 ±0)`
+		//  Estimated: `885 + r * (297 ±0)`
+		// Minimum execution time: 258_535_000 picoseconds.
+		Weight::from_parts(190_468_808, 885)
+			// Standard Error: 11_940
+			.saturating_add(Weight::from_parts(6_737_079, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 297).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:  `1232 + n * (1 ±0)`
+		//  Estimated: `1232 + n * (1 ±0)`
+		// Minimum execution time: 280_536_000 picoseconds.
+		Weight::from_parts(304_479_477, 1232)
+			// Standard Error: 37
+			.saturating_add(Weight::from_parts(534, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 1).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:1602 w:1601)
+	/// 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_transfer(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1382 + r * (45 ±0)`
+		//  Estimated: `7274 + r * (2520 ±0)`
+		// Minimum execution time: 260_373_000 picoseconds.
+		Weight::from_parts(278_290_000, 7274)
+			// Standard Error: 25_683
+			.saturating_add(Weight::from_parts(39_264_864, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2520).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:801 w:801)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:2 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:803 w:803)
+	/// 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:  `1227 + r * (245 ±0)`
+		//  Estimated: `9407 + r * (2721 ±0)`
+		// Minimum execution time: 277_621_000 picoseconds.
+		Weight::from_parts(281_775_000, 9407)
+			// Standard Error: 110_802
+			.saturating_add(Weight::from_parts(245_363_533, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(11_u64))
+			.saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2721).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:736 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:736 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:737 w:737)
+	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, 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 * (576 ±0)`
+		//  Estimated: `6779 + r * (2637 ±3)`
+		// Minimum execution time: 267_314_000 picoseconds.
+		Weight::from_parts(279_888_000, 6779)
+			// Standard Error: 144_378
+			.saturating_add(Weight::from_parts(244_606_414, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2637).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:3 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:2)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:2 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:4 w:4)
+	/// 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:  `1274 + t * (277 ±0)`
+		//  Estimated: `12164 + t * (5227 ±0)`
+		// Minimum execution time: 477_589_000 picoseconds.
+		Weight::from_parts(70_712_793, 12164)
+			// Standard Error: 11_713_135
+			.saturating_add(Weight::from_parts(375_371_698, 0).saturating_mul(t.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(991, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(13_u64))
+			.saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(t.into())))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 5227).saturating_mul(t.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:802 w:802)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::ContractInfoOf` (r:801 w:801)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:801 w:800)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:801 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::Nonce` (r:1 w:1)
+	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:800 w:800)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	/// Storage: `System::EventTopics` (r:803 w:803)
+	/// 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:  `1245 + r * (255 ±0)`
+		//  Estimated: `9587 + r * (2731 ±0)`
+		// Minimum execution time: 662_502_000 picoseconds.
+		Weight::from_parts(671_726_000, 9587)
+			// Standard Error: 351_643
+			.saturating_add(Weight::from_parts(390_457_971, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(11_u64))
+			.saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+			.saturating_add(T::DbWeight::get().writes((5_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2731).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:3 w:3)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:2)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:2 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::Nonce` (r:1 w:1)
+	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	/// 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, 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:  `1270 + t * (104 ±0)`
+		//  Estimated: `12178 + t * (2549 ±1)`
+		// Minimum execution time: 2_675_525_000 picoseconds.
+		Weight::from_parts(851_421_242, 12178)
+			// Standard Error: 7_094_722
+			.saturating_add(Weight::from_parts(112_457_697, 0).saturating_mul(t.into()))
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(1_867, 0).saturating_mul(i.into()))
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(1_931, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(16_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(t.into())))
+			.saturating_add(T::DbWeight::get().writes(11_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 2549).saturating_mul(t.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_hash_sha2_256(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829 + r * (8 ±0)`
+		//  Estimated: `6768 + r * (8 ±0)`
+		// Minimum execution time: 270_818_000 picoseconds.
+		Weight::from_parts(286_520_166, 6768)
+			// Standard Error: 575
+			.saturating_add(Weight::from_parts(402_286, 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, 8).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_hash_sha2_256_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `837`
+		//  Estimated: `6775`
+		// Minimum execution time: 257_134_000 picoseconds.
+		Weight::from_parts(268_214_648, 6775)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_098, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_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`)
+	/// 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_hash_keccak_256(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `831 + r * (8 ±0)`
+		//  Estimated: `6773 + r * (8 ±0)`
+		// Minimum execution time: 259_222_000 picoseconds.
+		Weight::from_parts(283_273_283, 6773)
+			// Standard Error: 967
+			.saturating_add(Weight::from_parts(817_596, 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, 8).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_hash_keccak_256_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839`
+		//  Estimated: `6781`
+		// Minimum execution time: 260_040_000 picoseconds.
+		Weight::from_parts(283_869_860, 6781)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(3_349, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_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`)
+	/// 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_hash_blake2_256(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `831 + r * (8 ±0)`
+		//  Estimated: `6775 + r * (8 ±0)`
+		// Minimum execution time: 260_698_000 picoseconds.
+		Weight::from_parts(282_900_345, 6775)
+			// Standard Error: 805
+			.saturating_add(Weight::from_parts(469_457, 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, 8).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_hash_blake2_256_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839`
+		//  Estimated: `6780`
+		// Minimum execution time: 256_967_000 picoseconds.
+		Weight::from_parts(273_024_512, 6780)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_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`)
+	/// 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_hash_blake2_128(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `831 + r * (8 ±0)`
+		//  Estimated: `6772 + r * (8 ±0)`
+		// Minimum execution time: 272_039_000 picoseconds.
+		Weight::from_parts(289_853_116, 6772)
+			// Standard Error: 559
+			.saturating_add(Weight::from_parts(459_383, 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, 8).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_hash_blake2_128_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839`
+		//  Estimated: `6778`
+		// Minimum execution time: 253_913_000 picoseconds.
+		Weight::from_parts(274_682_010, 6778)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_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`)
+	/// 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, 125697]`.
+	fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `964 + n * (1 ±0)`
+		//  Estimated: `6901 + n * (1 ±0)`
+		// Minimum execution time: 343_955_000 picoseconds.
+		Weight::from_parts(350_777_388, 6901)
+			// Standard Error: 14
+			.saturating_add(Weight::from_parts(5_915, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).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: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, 160]`.
+	fn seal_sr25519_verify(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `774 + r * (112 ±0)`
+		//  Estimated: `6715 + r * (112 ±0)`
+		// Minimum execution time: 268_698_000 picoseconds.
+		Weight::from_parts(336_398_814, 6715)
+			// Standard Error: 16_627
+			.saturating_add(Weight::from_parts(56_155_384, 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, 112).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, 160]`.
+	fn seal_ecdsa_recover(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `874 + r * (76 ±0)`
+		//  Estimated: `6768 + r * (77 ±0)`
+		// Minimum execution time: 258_906_000 picoseconds.
+		Weight::from_parts(340_672_829, 6768)
+			// Standard Error: 18_295
+			.saturating_add(Weight::from_parts(46_106_884, 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, 77).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, 160]`.
+	fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `844 + r * (42 ±0)`
+		//  Estimated: `6783 + r * (42 ±0)`
+		// Minimum execution time: 275_105_000 picoseconds.
+		Weight::from_parts(313_700_348, 6783)
+			// Standard Error: 11_960
+			.saturating_add(Weight::from_parts(12_050_300, 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, 42).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:1536 w:1536)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:1536 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:1538 w:1538)
+	/// 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 * (965 ±0)`
+		//  Estimated: `6774 + r * (3090 ±7)`
+		// Minimum execution time: 259_178_000 picoseconds.
+		Weight::from_parts(275_643_000, 6774)
+			// Standard Error: 54_044
+			.saturating_add(Weight::from_parts(26_026_930, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 3090).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:33 w:32)
+	/// 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, 32]`.
+	fn add_delegate_dependency(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `895 + r * (131 ±0)`
+		//  Estimated: `6845 + r * (2606 ±0)`
+		// Minimum execution time: 263_386_000 picoseconds.
+		Weight::from_parts(295_443_439, 6845)
+			// Standard Error: 24_422
+			.saturating_add(Weight::from_parts(6_429_537, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2606).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: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::CodeInfoOf` (r:33 w:32)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::PristineCode` (r:1 w:0)
+	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `MaxEncodedLen`)
+	/// Storage: `Timestamp::Now` (r:1 w:0)
+	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	/// 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, 32]`.
+	fn remove_delegate_dependency(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `936 + r * (183 ±0)`
+		//  Estimated: `129453 + r * (2568 ±0)`
+		// Minimum execution time: 261_371_000 picoseconds.
+		Weight::from_parts(297_493_194, 129453)
+			// Standard Error: 23_734
+			.saturating_add(Weight::from_parts(5_673_169, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.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:  `825 + r * (3 ±0)`
+		//  Estimated: `6771 + r * (3 ±0)`
+		// Minimum execution time: 275_558_000 picoseconds.
+		Weight::from_parts(287_220_765, 6771)
+			// Standard Error: 437
+			.saturating_add(Weight::from_parts(184_125, 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()))
+	}
+	/// 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_account_reentrance_count(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2076 + r * (39 ±0)`
+		//  Estimated: `7866 + r * (40 ±0)`
+		// Minimum execution time: 265_752_000 picoseconds.
+		Weight::from_parts(331_187_665, 7866)
+			// Standard Error: 1_950
+			.saturating_add(Weight::from_parts(312_262, 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, 40).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: `Contracts::Nonce` (r:1 w:1)
+	/// Proof: `Contracts::Nonce` (`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_instantiation_nonce(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `828 + r * (3 ±0)`
+		//  Estimated: `6768 + r * (3 ±0)`
+		// Minimum execution time: 257_114_000 picoseconds.
+		Weight::from_parts(286_686_654, 6768)
+			// Standard Error: 426
+			.saturating_add(Weight::from_parts(162_295, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into()))
+	}
+	/// The range of component `r` is `[0, 5000]`.
+	fn instr_i64const(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_388_000 picoseconds.
+		Weight::from_parts(1_680_408, 0)
+			// Standard Error: 21
+			.saturating_add(Weight::from_parts(10_564, 0).saturating_mul(r.into()))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `Contracts::DeletionQueueCounter` (r:1 w:0)
+	/// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	fn on_process_deletion_queue_batch() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1627`
+		// Minimum execution time: 2_410_000 picoseconds.
+		Weight::from_parts(2_581_000, 1627)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `Skipped::Metadata` (r:0 w:0)
+	/// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `k` is `[0, 1024]`.
+	fn on_initialize_per_trie_key(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `451 + k * (69 ±0)`
+		//  Estimated: `441 + k * (70 ±0)`
+		// Minimum execution time: 13_278_000 picoseconds.
+		Weight::from_parts(13_944_000, 441)
+			// Standard Error: 1_643
+			.saturating_add(Weight::from_parts(1_194_404, 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))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into())))
+			.saturating_add(Weight::from_parts(0, 70).saturating_mul(k.into()))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:2 w:1)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:2 w:1)
+	/// The range of component `c` is `[0, 125952]`.
+	fn v9_migration_step(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `211 + c * (1 ±0)`
+		//  Estimated: `6149 + c * (1 ±0)`
+		// Minimum execution time: 8_533_000 picoseconds.
+		Weight::from_parts(9_141_899, 6149)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_327, 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()))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	fn v10_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `510`
+		//  Estimated: `6450`
+		// Minimum execution time: 16_998_000 picoseconds.
+		Weight::from_parts(17_776_000, 6450)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::DeletionQueue` (r:1 w:1025)
+	/// Proof: `Contracts::DeletionQueue` (`max_values`: None, `max_size`: Some(142), added: 2617, mode: `Measured`)
+	/// Storage: `Contracts::DeletionQueueCounter` (r:0 w:1)
+	/// Proof: `Contracts::DeletionQueueCounter` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	/// The range of component `k` is `[0, 1024]`.
+	fn v11_migration_step(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `171 + k * (1 ±0)`
+		//  Estimated: `3635 + k * (1 ±0)`
+		// Minimum execution time: 3_919_000 picoseconds.
+		Weight::from_parts(4_057_153, 3635)
+			// Standard Error: 1_252
+			.saturating_add(Weight::from_parts(1_151_419, 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())))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(k.into()))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553053f13fd319a03c211337c76e0fe776df` (r:2 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553053f13fd319a03c211337c76e0fe776df` (r:2 w:0)
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc553022fca90611ba8b7942f8bdb3b97f6580` (r:1 w:1)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:0 w:1)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// The range of component `c` is `[0, 125952]`.
+	fn v12_migration_step(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `325 + c * (1 ±0)`
+		//  Estimated: `6263 + c * (1 ±0)`
+		// Minimum execution time: 17_730_000 picoseconds.
+		Weight::from_parts(17_540_884, 6263)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(417, 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()))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	fn v13_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `440`
+		//  Estimated: `6380`
+		// Minimum execution time: 13_089_000 picoseconds.
+		Weight::from_parts(13_727_000, 6380)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `System::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:0)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	fn v14_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `360`
+		//  Estimated: `6300`
+		// Minimum execution time: 49_083_000 picoseconds.
+		Weight::from_parts(50_462_000, 6300)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `System::Account` (r:2 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	fn v15_migration_step() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `594`
+		//  Estimated: `6534`
+		// Minimum execution time: 49_299_000 picoseconds.
+		Weight::from_parts(50_805_000, 6534)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	fn migration_noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1627`
+		// Minimum execution time: 3_305_000 picoseconds.
+		Weight::from_parts(3_489_000, 1627)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:1)
+	fn migrate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `166`
+		//  Estimated: `3631`
+		// Minimum execution time: 12_657_000 picoseconds.
+		Weight::from_parts(13_100_000, 3631)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	fn on_runtime_upgrade_noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3607`
+		// Minimum execution time: 4_784_000 picoseconds.
+		Weight::from_parts(4_994_000, 3607)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	fn on_runtime_upgrade_in_progress() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `167`
+		//  Estimated: `3632`
+		// Minimum execution time: 6_762_000 picoseconds.
+		Weight::from_parts(6_945_000, 3632)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Proof: UNKNOWN KEY `0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429` (r:1 w:0)
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:1)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	fn on_runtime_upgrade() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3607`
+		// Minimum execution time: 6_999_000 picoseconds.
+		Weight::from_parts(7_372_000, 3607)
+			.saturating_add(RocksDbWeight::get().reads(2_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: `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::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:  `759`
+		//  Estimated: `6710 + c * (1 ±0)`
+		// Minimum execution time: 304_121_000 picoseconds.
+		Weight::from_parts(288_627_840, 6710)
+			// Standard Error: 83
+			.saturating_add(Weight::from_parts(37_343, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(c.into()))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// 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(85), added: 2560, 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)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, 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::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, 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]`.
+	/// The range of component `i` is `[0, 1048576]`.
+	/// The range of component `s` is `[0, 1048576]`.
+	fn instantiate_with_code(c: u32, i: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `290`
+		//  Estimated: `8714`
+		// Minimum execution time: 4_101_589_000 picoseconds.
+		Weight::from_parts(694_193_047, 8714)
+			// Standard Error: 334
+			.saturating_add(Weight::from_parts(108_847, 0).saturating_mul(c.into()))
+			// Standard Error: 40
+			.saturating_add(Weight::from_parts(1_677, 0).saturating_mul(i.into()))
+			// Standard Error: 40
+			.saturating_add(Weight::from_parts(1_783, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(11_u64))
+			.saturating_add(RocksDbWeight::get().writes(10_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// 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`)
+	/// 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)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, 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::Account` (r:1 w:1)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	/// Storage: `System::EventTopics` (r:2 w:2)
+	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1048576]`.
+	/// The range of component `s` is `[0, 1048576]`.
+	fn instantiate(i: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `527`
+		//  Estimated: `6471`
+		// Minimum execution time: 2_011_580_000 picoseconds.
+		Weight::from_parts(397_415_227, 6471)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(1_689, 0).saturating_mul(i.into()))
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(1_679, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(10_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`)
+	/// 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::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:  `793`
+		//  Estimated: `6733`
+		// Minimum execution time: 204_975_000 picoseconds.
+		Weight::from_parts(214_770_000, 6733)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// 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(85), added: 2560, 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]`.
+	fn upload_code(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3607`
+		// Minimum execution time: 269_545_000 picoseconds.
+		Weight::from_parts(256_054_650, 3607)
+			// Standard Error: 91
+			.saturating_add(Weight::from_parts(72_743, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:1)
+	/// 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(85), added: 2560, 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: 47_880_000 picoseconds.
+		Weight::from_parts(49_427_000, 3780)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, 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: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: 37_898_000 picoseconds.
+		Weight::from_parts(39_826_000, 8967)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_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_caller(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `833 + r * (6 ±0)`
+		//  Estimated: `6773 + r * (6 ±0)`
+		// Minimum execution time: 260_916_000 picoseconds.
+		Weight::from_parts(295_521_846, 6773)
+			// Standard Error: 1_126
+			.saturating_add(Weight::from_parts(348_317, 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, 6).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:1601 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_is_contract(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `889 + r * (209 ±0)`
+		//  Estimated: `6793 + r * (2684 ±0)`
+		// Minimum execution time: 274_335_000 picoseconds.
+		Weight::from_parts(132_998_512, 6793)
+			// Standard Error: 7_396
+			.saturating_add(Weight::from_parts(3_602_287, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 2684).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:1601 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_code_hash(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `888 + r * (213 ±0)`
+		//  Estimated: `6797 + r * (2688 ±0)`
+		// Minimum execution time: 272_514_000 picoseconds.
+		Weight::from_parts(104_825_618, 6797)
+			// Standard Error: 10_038
+			.saturating_add(Weight::from_parts(4_520_258, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 2688).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_own_code_hash(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `840 + r * (6 ±0)`
+		//  Estimated: `6782 + r * (6 ±0)`
+		// Minimum execution time: 264_593_000 picoseconds.
+		Weight::from_parts(294_139_363, 6782)
+			// Standard Error: 907
+			.saturating_add(Weight::from_parts(432_964, 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, 6).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_caller_is_origin(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (3 ±0)`
+		//  Estimated: `6771 + r * (3 ±0)`
+		// Minimum execution time: 260_412_000 picoseconds.
+		Weight::from_parts(284_371_703, 6771)
+			// Standard Error: 433
+			.saturating_add(Weight::from_parts(182_952, 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()))
+	}
+	/// Storage: `Contracts::MigrationInProgress` (r:1 w:0)
+	/// Proof: `Contracts::MigrationInProgress` (`max_values`: Some(1), `max_size`: Some(1026), added: 1521, 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_caller_is_root(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `720 + r * (3 ±0)`
+		//  Estimated: `6660 + r * (3 ±0)`
+		// Minimum execution time: 255_112_000 picoseconds.
+		Weight::from_parts(273_052_488, 6660)
+			// Standard Error: 376
+			.saturating_add(Weight::from_parts(166_644, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 3).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_address(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `834 + r * (6 ±0)`
+		//  Estimated: `6774 + r * (6 ±0)`
+		// Minimum execution time: 270_426_000 picoseconds.
+		Weight::from_parts(289_240_775, 6774)
+			// Standard Error: 748
+			.saturating_add(Weight::from_parts(344_791, 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, 6).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_gas_left(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (6 ±0)`
+		//  Estimated: `6773 + r * (6 ±0)`
+		// Minimum execution time: 260_217_000 picoseconds.
+		Weight::from_parts(288_660_978, 6773)
+			// Standard Error: 1_199
+			.saturating_add(Weight::from_parts(550_304, 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, 6).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:2 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_balance(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `974 + r * (6 ±0)`
+		//  Estimated: `6898 + r * (6 ±0)`
+		// Minimum execution time: 273_473_000 picoseconds.
+		Weight::from_parts(298_889_279, 6898)
+			// Standard Error: 4_604
+			.saturating_add(Weight::from_parts(1_630_175, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 6).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_value_transferred(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `844 + r * (6 ±0)`
+		//  Estimated: `6790 + r * (6 ±0)`
+		// Minimum execution time: 262_033_000 picoseconds.
+		Weight::from_parts(284_293_851, 6790)
+			// Standard Error: 591
+			.saturating_add(Weight::from_parts(369_240, 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, 6).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_minimum_balance(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `842 + r * (6 ±0)`
+		//  Estimated: `6783 + r * (6 ±0)`
+		// Minimum execution time: 274_568_000 picoseconds.
+		Weight::from_parts(294_688_466, 6783)
+			// Standard Error: 768
+			.saturating_add(Weight::from_parts(349_584, 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, 6).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_block_number(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839 + r * (6 ±0)`
+		//  Estimated: `6786 + r * (6 ±0)`
+		// Minimum execution time: 264_061_000 picoseconds.
+		Weight::from_parts(287_964_188, 6786)
+			// Standard Error: 490
+			.saturating_add(Weight::from_parts(356_273, 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, 6).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_now(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (6 ±0)`
+		//  Estimated: `6771 + r * (6 ±0)`
+		// Minimum execution time: 275_707_000 picoseconds.
+		Weight::from_parts(290_797_828, 6771)
+			// Standard Error: 967
+			.saturating_add(Weight::from_parts(352_839, 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, 6).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: `TransactionPayment::NextFeeMultiplier` (r:1 w:0)
+	/// Proof: `TransactionPayment::NextFeeMultiplier` (`max_values`: Some(1), `max_size`: Some(16), added: 511, 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_weight_to_fee(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `904 + r * (14 ±0)`
+		//  Estimated: `6839 + r * (14 ±0)`
+		// Minimum execution time: 272_492_000 picoseconds.
+		Weight::from_parts(295_010_878, 6839)
+			// Standard Error: 2_549
+			.saturating_add(Weight::from_parts(1_426_715, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 14).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_input(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `832 + r * (6 ±0)`
+		//  Estimated: `6774 + r * (6 ±0)`
+		// Minimum execution time: 257_981_000 picoseconds.
+		Weight::from_parts(285_824_773, 6774)
+			// Standard Error: 704
+			.saturating_add(Weight::from_parts(301_327, 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, 6).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:  `836`
+		//  Estimated: `6776`
+		// Minimum execution time: 259_470_000 picoseconds.
+		Weight::from_parts(232_759_442, 6776)
+			// Standard Error: 24
+			.saturating_add(Weight::from_parts(981, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_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`)
+	/// 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, 1]`.
+	fn seal_return(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `820 + r * (45 ±0)`
+		//  Estimated: `6760 + r * (45 ±0)`
+		// Minimum execution time: 252_740_000 picoseconds.
+		Weight::from_parts(278_155_436, 6760)
+			// Standard Error: 882_420
+			.saturating_add(Weight::from_parts(755_063, 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, 45).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_return_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830`
+		//  Estimated: `6777`
+		// Minimum execution time: 257_318_000 picoseconds.
+		Weight::from_parts(285_765_697, 6777)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(322, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_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`)
+	/// 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:2 w:2)
+	/// 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(85), added: 2560, 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:  `2939 + r * (316 ±0)`
+		//  Estimated: `8879 + r * (5266 ±0)`
+		// Minimum execution time: 280_392_000 picoseconds.
+		Weight::from_parts(310_023_381, 8879)
+			// Standard Error: 1_008_026
+			.saturating_add(Weight::from_parts(130_208_818, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((10_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 5266).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: `RandomnessCollectiveFlip::RandomMaterial` (r:1 w:0)
+	/// Proof: `RandomnessCollectiveFlip::RandomMaterial` (`max_values`: Some(1), `max_size`: Some(2594), added: 3089, 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_random(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `911 + r * (10 ±0)`
+		//  Estimated: `6852 + r * (10 ±0)`
+		// Minimum execution time: 270_547_000 picoseconds.
+		Weight::from_parts(295_931_189, 6852)
+			// Standard Error: 3_280
+			.saturating_add(Weight::from_parts(1_941_248, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 10).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_deposit_event(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (10 ±0)`
+		//  Estimated: `6772 + r * (10 ±0)`
+		// Minimum execution time: 255_730_000 picoseconds.
+		Weight::from_parts(301_859_471, 6772)
+			// Standard Error: 5_401
+			.saturating_add(Weight::from_parts(3_887_632, 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, 10).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:6 w:6)
+	/// 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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `847 + t * (32 ±0)`
+		//  Estimated: `6792 + t * (2508 ±0)`
+		// Minimum execution time: 276_643_000 picoseconds.
+		Weight::from_parts(294_275_838, 6792)
+			// Standard Error: 106_745
+			.saturating_add(Weight::from_parts(2_831_489, 0).saturating_mul(t.into()))
+			// Standard Error: 29
+			.saturating_add(Weight::from_parts(624, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 2508).saturating_mul(t.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_debug_message(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829 + r * (7 ±0)`
+		//  Estimated: `6774 + r * (7 ±0)`
+		// Minimum execution time: 169_012_000 picoseconds.
+		Weight::from_parts(179_567_029, 6774)
+			// Standard Error: 534
+			.saturating_add(Weight::from_parts(249_500, 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, 7).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: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::CodeInfoOf` (r:1 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::PristineCode` (r:1 w:0)
+	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `MaxEncodedLen`)
+	/// Storage: `Timestamp::Now` (r:1 w:0)
+	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	/// Storage: `System::EventTopics` (r:2 w:2)
+	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// The range of component `i` is `[0, 1048576]`.
+	fn seal_debug_message_per_byte(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `125780`
+		//  Estimated: `131722`
+		// Minimum execution time: 408_647_000 picoseconds.
+		Weight::from_parts(387_678_006, 131722)
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(1_045, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// 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:  `891 + r * (292 ±0)`
+		//  Estimated: `892 + r * (293 ±0)`
+		// Minimum execution time: 279_315_000 picoseconds.
+		Weight::from_parts(171_270_899, 892)
+			// Standard Error: 15_492
+			.saturating_add(Weight::from_parts(6_776_878, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 293).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_set_storage_per_new_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1413`
+		//  Estimated: `1396`
+		// Minimum execution time: 289_666_000 picoseconds.
+		Weight::from_parts(348_062_625, 1396)
+			// Standard Error: 79
+			.saturating_add(Weight::from_parts(532, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(12_u64))
+			.saturating_add(RocksDbWeight::get().writes(8_u64))
+	}
+	/// 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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1219 + n * (1 ±0)`
+		//  Estimated: `1219 + n * (1 ±0)`
+		// Minimum execution time: 273_840_000 picoseconds.
+		Weight::from_parts(297_024_621, 1219)
+			// Standard Error: 55
+			.saturating_add(Weight::from_parts(945, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_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:  `887 + r * (288 ±0)`
+		//  Estimated: `893 + r * (289 ±0)`
+		// Minimum execution time: 279_110_000 picoseconds.
+		Weight::from_parts(177_898_012, 893)
+			// Standard Error: 16_287
+			.saturating_add(Weight::from_parts(6_640_103, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 289).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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1215 + n * (1 ±0)`
+		//  Estimated: `1215 + n * (1 ±0)`
+		// Minimum execution time: 276_566_000 picoseconds.
+		Weight::from_parts(304_992_376, 1215)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_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:  `887 + r * (296 ±0)`
+		//  Estimated: `889 + r * (297 ±0)`
+		// Minimum execution time: 266_285_000 picoseconds.
+		Weight::from_parts(200_488_939, 889)
+			// Standard Error: 11_193
+			.saturating_add(Weight::from_parts(5_467_725, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 297).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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1231 + n * (1 ±0)`
+		//  Estimated: `1231 + n * (1 ±0)`
+		// Minimum execution time: 278_625_000 picoseconds.
+		Weight::from_parts(304_319_493, 1231)
+			// Standard Error: 39
+			.saturating_add(Weight::from_parts(415, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_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:  `898 + r * (288 ±0)`
+		//  Estimated: `895 + r * (289 ±0)`
+		// Minimum execution time: 271_851_000 picoseconds.
+		Weight::from_parts(202_164_395, 895)
+			// Standard Error: 11_115
+			.saturating_add(Weight::from_parts(5_273_320, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 289).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 {
+		// Proof Size summary in bytes:
+		//  Measured:  `1218 + n * (1 ±0)`
+		//  Estimated: `1218 + n * (1 ±0)`
+		// Minimum execution time: 274_200_000 picoseconds.
+		Weight::from_parts(299_524_586, 1218)
+			// Standard Error: 33
+			.saturating_add(Weight::from_parts(272, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_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:  `880 + r * (296 ±0)`
+		//  Estimated: `885 + r * (297 ±0)`
+		// Minimum execution time: 258_535_000 picoseconds.
+		Weight::from_parts(190_468_808, 885)
+			// Standard Error: 11_940
+			.saturating_add(Weight::from_parts(6_737_079, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 297).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:  `1232 + n * (1 ±0)`
+		//  Estimated: `1232 + n * (1 ±0)`
+		// Minimum execution time: 280_536_000 picoseconds.
+		Weight::from_parts(304_479_477, 1232)
+			// Standard Error: 37
+			.saturating_add(Weight::from_parts(534, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 1).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:1602 w:1601)
+	/// 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_transfer(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1382 + r * (45 ±0)`
+		//  Estimated: `7274 + r * (2520 ±0)`
+		// Minimum execution time: 260_373_000 picoseconds.
+		Weight::from_parts(278_290_000, 7274)
+			// Standard Error: 25_683
+			.saturating_add(Weight::from_parts(39_264_864, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2520).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:801 w:801)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:2 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:803 w:803)
+	/// 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:  `1227 + r * (245 ±0)`
+		//  Estimated: `9407 + r * (2721 ±0)`
+		// Minimum execution time: 277_621_000 picoseconds.
+		Weight::from_parts(281_775_000, 9407)
+			// Standard Error: 110_802
+			.saturating_add(Weight::from_parts(245_363_533, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(11_u64))
+			.saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2721).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:736 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:736 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:737 w:737)
+	/// Proof: `System::EventTopics` (`max_values`: None, `max_size`: None, 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 * (576 ±0)`
+		//  Estimated: `6779 + r * (2637 ±3)`
+		// Minimum execution time: 267_314_000 picoseconds.
+		Weight::from_parts(279_888_000, 6779)
+			// Standard Error: 144_378
+			.saturating_add(Weight::from_parts(244_606_414, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2637).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:3 w:2)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:2)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:0)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:2 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:4 w:4)
+	/// 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:  `1274 + t * (277 ±0)`
+		//  Estimated: `12164 + t * (5227 ±0)`
+		// Minimum execution time: 477_589_000 picoseconds.
+		Weight::from_parts(70_712_793, 12164)
+			// Standard Error: 11_713_135
+			.saturating_add(Weight::from_parts(375_371_698, 0).saturating_mul(t.into()))
+			// Standard Error: 17
+			.saturating_add(Weight::from_parts(991, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(13_u64))
+			.saturating_add(RocksDbWeight::get().reads((2_u64).saturating_mul(t.into())))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 5227).saturating_mul(t.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:802 w:802)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::ContractInfoOf` (r:801 w:801)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:801 w:800)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:801 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::Nonce` (r:1 w:1)
+	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:800 w:800)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	/// Storage: `System::EventTopics` (r:803 w:803)
+	/// 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:  `1245 + r * (255 ±0)`
+		//  Estimated: `9587 + r * (2731 ±0)`
+		// Minimum execution time: 662_502_000 picoseconds.
+		Weight::from_parts(671_726_000, 9587)
+			// Standard Error: 351_643
+			.saturating_add(Weight::from_parts(390_457_971, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(11_u64))
+			.saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+			.saturating_add(RocksDbWeight::get().writes((5_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2731).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:3 w:3)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `Measured`)
+	/// Storage: `Contracts::ContractInfoOf` (r:2 w:2)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `Measured`)
+	/// Storage: `Contracts::CodeInfoOf` (r:2 w:1)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:2 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::Nonce` (r:1 w:1)
+	/// Proof: `Contracts::Nonce` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `Measured`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `Measured`)
+	/// 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, 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:  `1270 + t * (104 ±0)`
+		//  Estimated: `12178 + t * (2549 ±1)`
+		// Minimum execution time: 2_675_525_000 picoseconds.
+		Weight::from_parts(851_421_242, 12178)
+			// Standard Error: 7_094_722
+			.saturating_add(Weight::from_parts(112_457_697, 0).saturating_mul(t.into()))
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(1_867, 0).saturating_mul(i.into()))
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(1_931, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(16_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(t.into())))
+			.saturating_add(RocksDbWeight::get().writes(11_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(t.into())))
+			.saturating_add(Weight::from_parts(0, 2549).saturating_mul(t.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_hash_sha2_256(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829 + r * (8 ±0)`
+		//  Estimated: `6768 + r * (8 ±0)`
+		// Minimum execution time: 270_818_000 picoseconds.
+		Weight::from_parts(286_520_166, 6768)
+			// Standard Error: 575
+			.saturating_add(Weight::from_parts(402_286, 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, 8).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_hash_sha2_256_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `837`
+		//  Estimated: `6775`
+		// Minimum execution time: 257_134_000 picoseconds.
+		Weight::from_parts(268_214_648, 6775)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_098, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_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`)
+	/// 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_hash_keccak_256(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `831 + r * (8 ±0)`
+		//  Estimated: `6773 + r * (8 ±0)`
+		// Minimum execution time: 259_222_000 picoseconds.
+		Weight::from_parts(283_273_283, 6773)
+			// Standard Error: 967
+			.saturating_add(Weight::from_parts(817_596, 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, 8).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_hash_keccak_256_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839`
+		//  Estimated: `6781`
+		// Minimum execution time: 260_040_000 picoseconds.
+		Weight::from_parts(283_869_860, 6781)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(3_349, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_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`)
+	/// 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_hash_blake2_256(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `831 + r * (8 ±0)`
+		//  Estimated: `6775 + r * (8 ±0)`
+		// Minimum execution time: 260_698_000 picoseconds.
+		Weight::from_parts(282_900_345, 6775)
+			// Standard Error: 805
+			.saturating_add(Weight::from_parts(469_457, 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, 8).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_hash_blake2_256_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839`
+		//  Estimated: `6780`
+		// Minimum execution time: 256_967_000 picoseconds.
+		Weight::from_parts(273_024_512, 6780)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_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`)
+	/// 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_hash_blake2_128(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `831 + r * (8 ±0)`
+		//  Estimated: `6772 + r * (8 ±0)`
+		// Minimum execution time: 272_039_000 picoseconds.
+		Weight::from_parts(289_853_116, 6772)
+			// Standard Error: 559
+			.saturating_add(Weight::from_parts(459_383, 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, 8).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_hash_blake2_128_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `839`
+		//  Estimated: `6778`
+		// Minimum execution time: 253_913_000 picoseconds.
+		Weight::from_parts(274_682_010, 6778)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_204, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_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`)
+	/// 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, 125697]`.
+	fn seal_sr25519_verify_per_byte(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `964 + n * (1 ±0)`
+		//  Estimated: `6901 + n * (1 ±0)`
+		// Minimum execution time: 343_955_000 picoseconds.
+		Weight::from_parts(350_777_388, 6901)
+			// Standard Error: 14
+			.saturating_add(Weight::from_parts(5_915, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).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: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, 160]`.
+	fn seal_sr25519_verify(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `774 + r * (112 ±0)`
+		//  Estimated: `6715 + r * (112 ±0)`
+		// Minimum execution time: 268_698_000 picoseconds.
+		Weight::from_parts(336_398_814, 6715)
+			// Standard Error: 16_627
+			.saturating_add(Weight::from_parts(56_155_384, 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, 112).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, 160]`.
+	fn seal_ecdsa_recover(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `874 + r * (76 ±0)`
+		//  Estimated: `6768 + r * (77 ±0)`
+		// Minimum execution time: 258_906_000 picoseconds.
+		Weight::from_parts(340_672_829, 6768)
+			// Standard Error: 18_295
+			.saturating_add(Weight::from_parts(46_106_884, 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, 77).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, 160]`.
+	fn seal_ecdsa_to_eth_address(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `844 + r * (42 ±0)`
+		//  Estimated: `6783 + r * (42 ±0)`
+		// Minimum execution time: 275_105_000 picoseconds.
+		Weight::from_parts(313_700_348, 6783)
+			// Standard Error: 11_960
+			.saturating_add(Weight::from_parts(12_050_300, 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, 42).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:1536 w:1536)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `Measured`)
+	/// Storage: `Contracts::PristineCode` (r:1536 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:1538 w:1538)
+	/// 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 * (965 ±0)`
+		//  Estimated: `6774 + r * (3090 ±7)`
+		// Minimum execution time: 259_178_000 picoseconds.
+		Weight::from_parts(275_643_000, 6774)
+			// Standard Error: 54_044
+			.saturating_add(Weight::from_parts(26_026_930, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 3090).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:33 w:32)
+	/// 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, 32]`.
+	fn add_delegate_dependency(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `895 + r * (131 ±0)`
+		//  Estimated: `6845 + r * (2606 ±0)`
+		// Minimum execution time: 263_386_000 picoseconds.
+		Weight::from_parts(295_443_439, 6845)
+			// Standard Error: 24_422
+			.saturating_add(Weight::from_parts(6_429_537, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2606).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: `MaxEncodedLen`)
+	/// Storage: `System::Account` (r:1 w:0)
+	/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::ContractInfoOf` (r:1 w:1)
+	/// Proof: `Contracts::ContractInfoOf` (`max_values`: None, `max_size`: Some(1795), added: 4270, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::CodeInfoOf` (r:33 w:32)
+	/// Proof: `Contracts::CodeInfoOf` (`max_values`: None, `max_size`: Some(93), added: 2568, mode: `MaxEncodedLen`)
+	/// Storage: `Contracts::PristineCode` (r:1 w:0)
+	/// Proof: `Contracts::PristineCode` (`max_values`: None, `max_size`: Some(125988), added: 128463, mode: `MaxEncodedLen`)
+	/// Storage: `Timestamp::Now` (r:1 w:0)
+	/// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`)
+	/// 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, 32]`.
+	fn remove_delegate_dependency(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `936 + r * (183 ±0)`
+		//  Estimated: `129453 + r * (2568 ±0)`
+		// Minimum execution time: 261_371_000 picoseconds.
+		Weight::from_parts(297_493_194, 129453)
+			// Standard Error: 23_734
+			.saturating_add(Weight::from_parts(5_673_169, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::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:  `825 + r * (3 ±0)`
+		//  Estimated: `6771 + r * (3 ±0)`
+		// Minimum execution time: 275_558_000 picoseconds.
+		Weight::from_parts(287_220_765, 6771)
+			// Standard Error: 437
+			.saturating_add(Weight::from_parts(184_125, 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()))
+	}
+	/// 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_account_reentrance_count(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2076 + r * (39 ±0)`
+		//  Estimated: `7866 + r * (40 ±0)`
+		// Minimum execution time: 265_752_000 picoseconds.
+		Weight::from_parts(331_187_665, 7866)
+			// Standard Error: 1_950
+			.saturating_add(Weight::from_parts(312_262, 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, 40).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: `Contracts::Nonce` (r:1 w:1)
+	/// Proof: `Contracts::Nonce` (`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_instantiation_nonce(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `828 + r * (3 ±0)`
+		//  Estimated: `6768 + r * (3 ±0)`
+		// Minimum execution time: 257_114_000 picoseconds.
+		Weight::from_parts(286_686_654, 6768)
+			// Standard Error: 426
+			.saturating_add(Weight::from_parts(162_295, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 3).saturating_mul(r.into()))
+	}
+	/// The range of component `r` is `[0, 5000]`.
+	fn instr_i64const(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_388_000 picoseconds.
+		Weight::from_parts(1_680_408, 0)
+			// Standard Error: 21
+			.saturating_add(Weight::from_parts(10_564, 0).saturating_mul(r.into()))
+	}
+}
diff --git a/substrate/frame/conviction-voting/Cargo.toml b/substrate/frame/conviction-voting/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c5e1e5b9905169815ed9e583be6065095fe04fd3
--- /dev/null
+++ b/substrate/frame/conviction-voting/Cargo.toml
@@ -0,0 +1,66 @@
+[package]
+name = "pallet-conviction-voting"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for conviction voting in referenda"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+assert_matches = "1.3.0"
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+	"max-encoded-len",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive"], optional = true }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-scheduler = { version = "4.0.0-dev", path = "../scheduler" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-scheduler/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-scheduler/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-scheduler/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/conviction-voting/README.md b/substrate/frame/conviction-voting/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5dc5d526d5c231630874dadfe0ea47d9a429d5e8
--- /dev/null
+++ b/substrate/frame/conviction-voting/README.md
@@ -0,0 +1,8 @@
+# Voting Pallet
+
+- [`assembly::Config`](https://docs.rs/pallet-assembly/latest/pallet_assembly/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-assembly/latest/pallet_assembly/enum.Call.html)
+
+## Overview
+
+Pallet for voting in referenda.
diff --git a/substrate/frame/conviction-voting/src/benchmarking.rs b/substrate/frame/conviction-voting/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8701ed7ebb074273b161a980ef0f6650d1ced11b
--- /dev/null
+++ b/substrate/frame/conviction-voting/src/benchmarking.rs
@@ -0,0 +1,287 @@
+// 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.
+
+//! ConvictionVoting pallet benchmarking.
+
+use super::*;
+
+use assert_matches::assert_matches;
+use frame_benchmarking::v1::{account, benchmarks_instance_pallet, whitelist_account};
+use frame_support::{
+	dispatch::RawOrigin,
+	traits::{
+		fungible,
+		tokens::{Fortitude::Polite, Preservation::Expendable},
+		Currency, Get,
+	},
+};
+use sp_runtime::traits::Bounded;
+use sp_std::collections::btree_map::BTreeMap;
+
+use crate::Pallet as ConvictionVoting;
+
+const SEED: u32 = 0;
+
+/// Fill all classes as much as possible up to `MaxVotes` and return the Class with the most votes
+/// ongoing.
+fn fill_voting<T: Config<I>, I: 'static>(
+) -> (ClassOf<T, I>, BTreeMap<ClassOf<T, I>, Vec<IndexOf<T, I>>>) {
+	let mut r = BTreeMap::<ClassOf<T, I>, Vec<IndexOf<T, I>>>::new();
+	for class in T::Polls::classes().into_iter() {
+		for _ in 0..T::MaxVotes::get() {
+			match T::Polls::create_ongoing(class.clone()) {
+				Ok(i) => r.entry(class.clone()).or_default().push(i),
+				Err(()) => break,
+			}
+		}
+	}
+	let c = r.iter().max_by_key(|(_, v)| v.len()).unwrap().0.clone();
+	(c, r)
+}
+
+fn funded_account<T: Config<I>, I: 'static>(name: &'static str, index: u32) -> T::AccountId {
+	let caller: T::AccountId = account(name, index, SEED);
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+	caller
+}
+
+fn account_vote<T: Config<I>, I: 'static>(b: BalanceOf<T, I>) -> AccountVote<BalanceOf<T, I>> {
+	let v = Vote { aye: true, conviction: Conviction::Locked1x };
+
+	AccountVote::Standard { vote: v, balance: b }
+}
+
+benchmarks_instance_pallet! {
+	where_clause {  where T::MaxVotes: core::fmt::Debug }
+
+	vote_new {
+		let caller = funded_account::<T, I>("caller", 0);
+		whitelist_account!(caller);
+		let account_vote = account_vote::<T, I>(100u32.into());
+
+		let (class, all_polls) = fill_voting::<T, I>();
+		let polls = &all_polls[&class];
+		let r = polls.len() - 1;
+		// We need to create existing votes
+		for i in polls.iter().skip(1) {
+			ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, account_vote)?;
+		}
+		let votes = match VotingFor::<T, I>::get(&caller, &class) {
+			Voting::Casting(Casting { votes, .. }) => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r as usize, "Votes were not recorded.");
+
+		let index = polls[0];
+	}: vote(RawOrigin::Signed(caller.clone()), index, account_vote)
+	verify {
+		assert_matches!(
+			VotingFor::<T, I>::get(&caller, &class),
+			Voting::Casting(Casting { votes, .. }) if votes.len() == (r + 1) as usize
+		);
+	}
+
+	vote_existing {
+		let caller = funded_account::<T, I>("caller", 0);
+		whitelist_account!(caller);
+		let old_account_vote = account_vote::<T, I>(100u32.into());
+
+		let (class, all_polls) = fill_voting::<T, I>();
+		let polls = &all_polls[&class];
+		let r = polls.len();
+		// We need to create existing votes
+		for i in polls.iter() {
+			ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, old_account_vote)?;
+		}
+		let votes = match VotingFor::<T, I>::get(&caller, &class) {
+			Voting::Casting(Casting { votes, .. }) => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r, "Votes were not recorded.");
+
+		let new_account_vote = account_vote::<T, I>(200u32.into());
+		let index = polls[0];
+	}: vote(RawOrigin::Signed(caller.clone()), index, new_account_vote)
+	verify {
+		assert_matches!(
+			VotingFor::<T, I>::get(&caller, &class),
+			Voting::Casting(Casting { votes, .. }) if votes.len() == r as usize
+		);
+	}
+
+	remove_vote {
+		let caller = funded_account::<T, I>("caller", 0);
+		whitelist_account!(caller);
+		let old_account_vote = account_vote::<T, I>(100u32.into());
+
+		let (class, all_polls) = fill_voting::<T, I>();
+		let polls = &all_polls[&class];
+		let r = polls.len();
+		// We need to create existing votes
+		for i in polls.iter() {
+			ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, old_account_vote)?;
+		}
+		let votes = match VotingFor::<T, I>::get(&caller, &class) {
+			Voting::Casting(Casting { votes, .. }) => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r, "Votes were not recorded.");
+
+		let index = polls[0];
+	}: _(RawOrigin::Signed(caller.clone()), Some(class.clone()), index)
+	verify {
+		assert_matches!(
+			VotingFor::<T, I>::get(&caller, &class),
+			Voting::Casting(Casting { votes, .. }) if votes.len() == (r - 1) as usize
+		);
+	}
+
+	remove_other_vote {
+		let caller = funded_account::<T, I>("caller", 0);
+		let voter = funded_account::<T, I>("caller", 0);
+		let voter_lookup = T::Lookup::unlookup(voter.clone());
+		whitelist_account!(caller);
+		let old_account_vote = account_vote::<T, I>(100u32.into());
+
+		let (class, all_polls) = fill_voting::<T, I>();
+		let polls = &all_polls[&class];
+		let r = polls.len();
+		// We need to create existing votes
+		for i in polls.iter() {
+			ConvictionVoting::<T, I>::vote(RawOrigin::Signed(voter.clone()).into(), *i, old_account_vote)?;
+		}
+		let votes = match VotingFor::<T, I>::get(&caller, &class) {
+			Voting::Casting(Casting { votes, .. }) => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r, "Votes were not recorded.");
+
+		let index = polls[0];
+		assert!(T::Polls::end_ongoing(index, false).is_ok());
+	}: _(RawOrigin::Signed(caller.clone()), voter_lookup, class.clone(), index)
+	verify {
+		assert_matches!(
+			VotingFor::<T, I>::get(&voter, &class),
+			Voting::Casting(Casting { votes, .. }) if votes.len() == (r - 1) as usize
+		);
+	}
+
+	delegate {
+		let r in 0 .. T::MaxVotes::get().min(T::Polls::max_ongoing().1);
+
+		let all_polls = fill_voting::<T, I>().1;
+		let class = T::Polls::max_ongoing().0;
+		let polls = &all_polls[&class];
+		let voter = funded_account::<T, I>("voter", 0);
+		let voter_lookup = T::Lookup::unlookup(voter.clone());
+		let caller = funded_account::<T, I>("caller", 0);
+		whitelist_account!(caller);
+
+		let delegated_balance: BalanceOf<T, I> = 1000u32.into();
+		let delegate_vote = account_vote::<T, I>(delegated_balance);
+
+		// We need to create existing delegations
+		for i in polls.iter().take(r as usize) {
+			ConvictionVoting::<T, I>::vote(RawOrigin::Signed(voter.clone()).into(), *i, delegate_vote)?;
+		}
+		assert_matches!(
+			VotingFor::<T, I>::get(&voter, &class),
+			Voting::Casting(Casting { votes, .. }) if votes.len() == r as usize
+		);
+
+	}: _(RawOrigin::Signed(caller.clone()), class.clone(), voter_lookup, Conviction::Locked1x, delegated_balance)
+	verify {
+		assert_matches!(VotingFor::<T, I>::get(&caller, &class), Voting::Delegating(_));
+	}
+
+	undelegate {
+		let r in 0 .. T::MaxVotes::get().min(T::Polls::max_ongoing().1);
+
+		let all_polls = fill_voting::<T, I>().1;
+		let class = T::Polls::max_ongoing().0;
+		let polls = &all_polls[&class];
+		let voter = funded_account::<T, I>("voter", 0);
+		let voter_lookup = T::Lookup::unlookup(voter.clone());
+		let caller = funded_account::<T, I>("caller", 0);
+		whitelist_account!(caller);
+
+		let delegated_balance: BalanceOf<T, I> = 1000u32.into();
+		let delegate_vote = account_vote::<T, I>(delegated_balance);
+
+		ConvictionVoting::<T, I>::delegate(
+			RawOrigin::Signed(caller.clone()).into(),
+			class.clone(),
+			voter_lookup,
+			Conviction::Locked1x,
+			delegated_balance,
+		)?;
+
+		// We need to create delegations
+		for i in polls.iter().take(r as usize) {
+			ConvictionVoting::<T, I>::vote(RawOrigin::Signed(voter.clone()).into(), *i, delegate_vote)?;
+		}
+		assert_matches!(
+			VotingFor::<T, I>::get(&voter, &class),
+			Voting::Casting(Casting { votes, .. }) if votes.len() == r as usize
+		);
+		assert_matches!(VotingFor::<T, I>::get(&caller, &class), Voting::Delegating(_));
+	}: _(RawOrigin::Signed(caller.clone()), class.clone())
+	verify {
+		assert_matches!(VotingFor::<T, I>::get(&caller, &class), Voting::Casting(_));
+	}
+
+	unlock {
+		let caller = funded_account::<T, I>("caller", 0);
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		whitelist_account!(caller);
+		let normal_account_vote = account_vote::<T, I>(T::Currency::free_balance(&caller) - 100u32.into());
+		let big_account_vote = account_vote::<T, I>(T::Currency::free_balance(&caller));
+
+		// Fill everything up to the max by filling all classes with votes and voting on them all.
+		let (class, all_polls) = fill_voting::<T, I>();
+		assert!(all_polls.len() > 0);
+		for (class, polls) in all_polls.iter() {
+			assert!(polls.len() > 0);
+			for i in polls.iter() {
+				ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), *i, normal_account_vote)?;
+			}
+		}
+
+		let orig_usable = <T::Currency as fungible::Inspect<T::AccountId>>::reducible_balance(&caller, Expendable, Polite);
+		let polls = &all_polls[&class];
+
+		// Vote big on the class with the most ongoing votes of them to bump the lock and make it
+		// hard to recompute when removed.
+		ConvictionVoting::<T, I>::vote(RawOrigin::Signed(caller.clone()).into(), polls[0], big_account_vote)?;
+		let now_usable = <T::Currency as fungible::Inspect<T::AccountId>>::reducible_balance(&caller, Expendable, Polite);
+		assert_eq!(orig_usable - now_usable, 100u32.into());
+
+		// Remove the vote
+		ConvictionVoting::<T, I>::remove_vote(RawOrigin::Signed(caller.clone()).into(), Some(class.clone()), polls[0])?;
+
+		// We can now unlock on `class` from 200 to 100...
+	}: _(RawOrigin::Signed(caller.clone()), class, caller_lookup)
+	verify {
+		assert_eq!(orig_usable, <T::Currency as fungible::Inspect<T::AccountId>>::reducible_balance(&caller, Expendable, Polite));
+	}
+
+	impl_benchmark_test_suite!(
+		ConvictionVoting,
+		crate::tests::new_test_ext(),
+		crate::tests::Test
+	);
+}
diff --git a/substrate/frame/conviction-voting/src/conviction.rs b/substrate/frame/conviction-voting/src/conviction.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b5c9a3a705f6b306a6f1d596d1e58f427ad4e23e
--- /dev/null
+++ b/substrate/frame/conviction-voting/src/conviction.rs
@@ -0,0 +1,131 @@
+// 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.
+
+//! The conviction datatype.
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Bounded, CheckedDiv, CheckedMul, Zero},
+	RuntimeDebug,
+};
+
+use crate::types::Delegations;
+
+/// A value denoting the strength of conviction of a vote.
+#[derive(
+	Encode,
+	Decode,
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	RuntimeDebug,
+	TypeInfo,
+	MaxEncodedLen,
+)]
+pub enum Conviction {
+	/// 0.1x votes, unlocked.
+	None,
+	/// 1x votes, locked for an enactment period following a successful vote.
+	Locked1x,
+	/// 2x votes, locked for 2x enactment periods following a successful vote.
+	Locked2x,
+	/// 3x votes, locked for 4x...
+	Locked3x,
+	/// 4x votes, locked for 8x...
+	Locked4x,
+	/// 5x votes, locked for 16x...
+	Locked5x,
+	/// 6x votes, locked for 32x...
+	Locked6x,
+}
+
+impl Default for Conviction {
+	fn default() -> Self {
+		Conviction::None
+	}
+}
+
+impl From<Conviction> for u8 {
+	fn from(c: Conviction) -> u8 {
+		match c {
+			Conviction::None => 0,
+			Conviction::Locked1x => 1,
+			Conviction::Locked2x => 2,
+			Conviction::Locked3x => 3,
+			Conviction::Locked4x => 4,
+			Conviction::Locked5x => 5,
+			Conviction::Locked6x => 6,
+		}
+	}
+}
+
+impl TryFrom<u8> for Conviction {
+	type Error = ();
+	fn try_from(i: u8) -> Result<Conviction, ()> {
+		Ok(match i {
+			0 => Conviction::None,
+			1 => Conviction::Locked1x,
+			2 => Conviction::Locked2x,
+			3 => Conviction::Locked3x,
+			4 => Conviction::Locked4x,
+			5 => Conviction::Locked5x,
+			6 => Conviction::Locked6x,
+			_ => return Err(()),
+		})
+	}
+}
+
+impl Conviction {
+	/// The amount of time (in number of periods) that our conviction implies a successful voter's
+	/// balance should be locked for.
+	pub fn lock_periods(self) -> u32 {
+		match self {
+			Conviction::None => 0,
+			Conviction::Locked1x => 1,
+			Conviction::Locked2x => 2,
+			Conviction::Locked3x => 4,
+			Conviction::Locked4x => 8,
+			Conviction::Locked5x => 16,
+			Conviction::Locked6x => 32,
+		}
+	}
+
+	/// The votes of a voter of the given `balance` with our conviction.
+	pub fn votes<B: From<u8> + Zero + Copy + CheckedMul + CheckedDiv + Bounded>(
+		self,
+		capital: B,
+	) -> Delegations<B> {
+		let votes = match self {
+			Conviction::None => capital.checked_div(&10u8.into()).unwrap_or_else(Zero::zero),
+			x => capital.checked_mul(&u8::from(x).into()).unwrap_or_else(B::max_value),
+		};
+		Delegations { votes, capital }
+	}
+}
+
+impl Bounded for Conviction {
+	fn min_value() -> Self {
+		Conviction::None
+	}
+	fn max_value() -> Self {
+		Conviction::Locked6x
+	}
+}
diff --git a/substrate/frame/conviction-voting/src/lib.rs b/substrate/frame/conviction-voting/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9c2993fc5cae19215eeb973b97fe9d057983b92b
--- /dev/null
+++ b/substrate/frame/conviction-voting/src/lib.rs
@@ -0,0 +1,679 @@
+// 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.
+
+//! # Voting Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! Pallet for managing actual voting in polls.
+
+#![recursion_limit = "256"]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{
+	dispatch::{DispatchError, DispatchResult},
+	ensure,
+	traits::{
+		fungible, Currency, Get, LockIdentifier, LockableCurrency, PollStatus, Polling,
+		ReservableCurrency, WithdrawReasons,
+	},
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_runtime::{
+	traits::{AtLeast32BitUnsigned, Saturating, StaticLookup, Zero},
+	ArithmeticError, Perbill,
+};
+use sp_std::prelude::*;
+
+mod conviction;
+mod types;
+mod vote;
+pub mod weights;
+
+pub use self::{
+	conviction::Conviction,
+	pallet::*,
+	types::{Delegations, Tally, UnvoteScope},
+	vote::{AccountVote, Casting, Delegating, Vote, Voting},
+	weights::WeightInfo,
+};
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+
+const CONVICTION_VOTING_ID: LockIdentifier = *b"pyconvot";
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+type BalanceOf<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type VotingOf<T, I = ()> = Voting<
+	BalanceOf<T, I>,
+	<T as frame_system::Config>::AccountId,
+	BlockNumberFor<T>,
+	PollIndexOf<T, I>,
+	<T as Config<I>>::MaxVotes,
+>;
+#[allow(dead_code)]
+type DelegatingOf<T, I = ()> =
+	Delegating<BalanceOf<T, I>, <T as frame_system::Config>::AccountId, BlockNumberFor<T>>;
+pub type TallyOf<T, I = ()> = Tally<BalanceOf<T, I>, <T as Config<I>>::MaxTurnout>;
+pub type VotesOf<T, I = ()> = BalanceOf<T, I>;
+type PollIndexOf<T, I = ()> = <<T as Config<I>>::Polls as Polling<TallyOf<T, I>>>::Index;
+#[cfg(feature = "runtime-benchmarks")]
+type IndexOf<T, I = ()> = <<T as Config<I>>::Polls as Polling<TallyOf<T, I>>>::Index;
+type ClassOf<T, I = ()> = <<T as Config<I>>::Polls as Polling<TallyOf<T, I>>>::Class;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{pallet_prelude::*, traits::ClassCountOf};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config + Sized {
+		// System level stuff.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+		/// Currency type with which voting happens.
+		type Currency: ReservableCurrency<Self::AccountId>
+			+ LockableCurrency<Self::AccountId, Moment = BlockNumberFor<Self>>
+			+ fungible::Inspect<Self::AccountId>;
+
+		/// The implementation of the logic which conducts polls.
+		type Polls: Polling<
+			TallyOf<Self, I>,
+			Votes = BalanceOf<Self, I>,
+			Moment = BlockNumberFor<Self>,
+		>;
+
+		/// The maximum amount of tokens which may be used for voting. May just be
+		/// `Currency::total_issuance`, but you might want to reduce this in order to account for
+		/// funds in the system which are unable to vote (e.g. parachain auction deposits).
+		type MaxTurnout: Get<BalanceOf<Self, I>>;
+
+		/// The maximum number of concurrent votes an account may have.
+		///
+		/// Also used to compute weight, an overly large value can lead to extrinsics with large
+		/// weight estimation: see `delegate` for instance.
+		#[pallet::constant]
+		type MaxVotes: Get<u32>;
+
+		/// The minimum period of vote locking.
+		///
+		/// It should be no shorter than enactment period to ensure that in the case of an approval,
+		/// those successful voters are locked into the consequences that their votes entail.
+		#[pallet::constant]
+		type VoteLockingPeriod: Get<BlockNumberFor<Self>>;
+	}
+
+	/// All voting for a particular voter in a particular voting class. We store the balance for the
+	/// number of votes that we have recorded.
+	#[pallet::storage]
+	pub type VotingFor<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Twox64Concat,
+		ClassOf<T, I>,
+		VotingOf<T, I>,
+		ValueQuery,
+	>;
+
+	/// The voting classes which have a non-zero lock requirement and the lock amounts which they
+	/// require. The actual amount locked on behalf of this pallet should always be the maximum of
+	/// this list.
+	#[pallet::storage]
+	pub type ClassLocksFor<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		BoundedVec<(ClassOf<T, I>, BalanceOf<T, I>), ClassCountOf<T::Polls, TallyOf<T, I>>>,
+		ValueQuery,
+	>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// An account has delegated their vote to another account. \[who, target\]
+		Delegated(T::AccountId, T::AccountId),
+		/// An \[account\] has cancelled a previous delegation operation.
+		Undelegated(T::AccountId),
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Poll is not ongoing.
+		NotOngoing,
+		/// The given account did not vote on the poll.
+		NotVoter,
+		/// The actor has no permission to conduct the action.
+		NoPermission,
+		/// The actor has no permission to conduct the action right now but will do in the future.
+		NoPermissionYet,
+		/// The account is already delegating.
+		AlreadyDelegating,
+		/// The account currently has votes attached to it and the operation cannot succeed until
+		/// these are removed, either through `unvote` or `reap_vote`.
+		AlreadyVoting,
+		/// Too high a balance was provided that the account cannot afford.
+		InsufficientFunds,
+		/// The account is not currently delegating.
+		NotDelegating,
+		/// Delegation to oneself makes no sense.
+		Nonsense,
+		/// Maximum number of votes reached.
+		MaxVotesReached,
+		/// The class must be supplied since it is not easily determinable from the state.
+		ClassNeeded,
+		/// The class ID supplied is invalid.
+		BadClass,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Vote in a poll. If `vote.is_aye()`, the vote is to enact the proposal;
+		/// otherwise it is a vote to keep the status quo.
+		///
+		/// The dispatch origin of this call must be _Signed_.
+		///
+		/// - `poll_index`: The index of the poll to vote for.
+		/// - `vote`: The vote configuration.
+		///
+		/// Weight: `O(R)` where R is the number of polls the voter has voted on.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::vote_new().max(T::WeightInfo::vote_existing()))]
+		pub fn vote(
+			origin: OriginFor<T>,
+			#[pallet::compact] poll_index: PollIndexOf<T, I>,
+			vote: AccountVote<BalanceOf<T, I>>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::try_vote(&who, poll_index, vote)
+		}
+
+		/// Delegate the voting power (with some given conviction) of the sending account for a
+		/// particular class of polls.
+		///
+		/// The balance delegated is locked for as long as it's delegated, and thereafter for the
+		/// time appropriate for the conviction's lock period.
+		///
+		/// The dispatch origin of this call must be _Signed_, and the signing account must either:
+		///   - be delegating already; or
+		///   - have no voting activity (if there is, then it will need to be removed/consolidated
+		///     through `reap_vote` or `unvote`).
+		///
+		/// - `to`: The account whose voting the `target` account's voting power will follow.
+		/// - `class`: The class of polls to delegate. To delegate multiple classes, multiple calls
+		///   to this function are required.
+		/// - `conviction`: The conviction that will be attached to the delegated votes. When the
+		///   account is undelegated, the funds will be locked for the corresponding period.
+		/// - `balance`: The amount of the account's balance to be used in delegating. This must not
+		///   be more than the account's current balance.
+		///
+		/// Emits `Delegated`.
+		///
+		/// Weight: `O(R)` where R is the number of polls the voter delegating to has
+		///   voted on. Weight is initially charged as if maximum votes, but is refunded later.
+		// NOTE: weight must cover an incorrect voting of origin with max votes, this is ensure
+		// because a valid delegation cover decoding a direct voting with max votes.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::delegate(T::MaxVotes::get()))]
+		pub fn delegate(
+			origin: OriginFor<T>,
+			class: ClassOf<T, I>,
+			to: AccountIdLookupOf<T>,
+			conviction: Conviction,
+			balance: BalanceOf<T, I>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let to = T::Lookup::lookup(to)?;
+			let votes = Self::try_delegate(who, class, to, conviction, balance)?;
+
+			Ok(Some(T::WeightInfo::delegate(votes)).into())
+		}
+
+		/// Undelegate the voting power of the sending account for a particular class of polls.
+		///
+		/// Tokens may be unlocked following once an amount of time consistent with the lock period
+		/// of the conviction with which the delegation was issued has passed.
+		///
+		/// The dispatch origin of this call must be _Signed_ and the signing account must be
+		/// currently delegating.
+		///
+		/// - `class`: The class of polls to remove the delegation from.
+		///
+		/// Emits `Undelegated`.
+		///
+		/// Weight: `O(R)` where R is the number of polls the voter delegating to has
+		///   voted on. Weight is initially charged as if maximum votes, but is refunded later.
+		// NOTE: weight must cover an incorrect voting of origin with max votes, this is ensure
+		// because a valid delegation cover decoding a direct voting with max votes.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::undelegate(T::MaxVotes::get().into()))]
+		pub fn undelegate(
+			origin: OriginFor<T>,
+			class: ClassOf<T, I>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let votes = Self::try_undelegate(who, class)?;
+			Ok(Some(T::WeightInfo::undelegate(votes)).into())
+		}
+
+		/// Remove the lock caused by prior voting/delegating which has expired within a particular
+		/// class.
+		///
+		/// The dispatch origin of this call must be _Signed_.
+		///
+		/// - `class`: The class of polls to unlock.
+		/// - `target`: The account to remove the lock on.
+		///
+		/// Weight: `O(R)` with R number of vote of target.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::unlock())]
+		pub fn unlock(
+			origin: OriginFor<T>,
+			class: ClassOf<T, I>,
+			target: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			ensure_signed(origin)?;
+			let target = T::Lookup::lookup(target)?;
+			Self::update_lock(&class, &target);
+			Ok(())
+		}
+
+		/// Remove a vote for a poll.
+		///
+		/// If:
+		/// - the poll was cancelled, or
+		/// - the poll is ongoing, or
+		/// - the poll has ended such that
+		///   - the vote of the account was in opposition to the result; or
+		///   - there was no conviction to the account's vote; or
+		///   - the account made a split vote
+		/// ...then the vote is removed cleanly and a following call to `unlock` may result in more
+		/// funds being available.
+		///
+		/// If, however, the poll has ended and:
+		/// - it finished corresponding to the vote of the account, and
+		/// - the account made a standard vote with conviction, and
+		/// - the lock period of the conviction is not over
+		/// ...then the lock will be aggregated into the overall account's lock, which may involve
+		/// *overlocking* (where the two locks are combined into a single lock that is the maximum
+		/// of both the amount locked and the time is it locked for).
+		///
+		/// The dispatch origin of this call must be _Signed_, and the signer must have a vote
+		/// registered for poll `index`.
+		///
+		/// - `index`: The index of poll of the vote to be removed.
+		/// - `class`: Optional parameter, if given it indicates the class of the poll. For polls
+		///   which have finished or are cancelled, this must be `Some`.
+		///
+		/// Weight: `O(R + log R)` where R is the number of polls that `target` has voted on.
+		///   Weight is calculated for the maximum number of vote.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::remove_vote())]
+		pub fn remove_vote(
+			origin: OriginFor<T>,
+			class: Option<ClassOf<T, I>>,
+			index: PollIndexOf<T, I>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::try_remove_vote(&who, index, class, UnvoteScope::Any)
+		}
+
+		/// Remove a vote for a poll.
+		///
+		/// If the `target` is equal to the signer, then this function is exactly equivalent to
+		/// `remove_vote`. If not equal to the signer, then the vote must have expired,
+		/// either because the poll was cancelled, because the voter lost the poll or
+		/// because the conviction period is over.
+		///
+		/// The dispatch origin of this call must be _Signed_.
+		///
+		/// - `target`: The account of the vote to be removed; this account must have voted for poll
+		///   `index`.
+		/// - `index`: The index of poll of the vote to be removed.
+		/// - `class`: The class of the poll.
+		///
+		/// Weight: `O(R + log R)` where R is the number of polls that `target` has voted on.
+		///   Weight is calculated for the maximum number of vote.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::remove_other_vote())]
+		pub fn remove_other_vote(
+			origin: OriginFor<T>,
+			target: AccountIdLookupOf<T>,
+			class: ClassOf<T, I>,
+			index: PollIndexOf<T, I>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let target = T::Lookup::lookup(target)?;
+			let scope = if target == who { UnvoteScope::Any } else { UnvoteScope::OnlyExpired };
+			Self::try_remove_vote(&target, index, Some(class), scope)?;
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Actually enact a vote, if legit.
+	fn try_vote(
+		who: &T::AccountId,
+		poll_index: PollIndexOf<T, I>,
+		vote: AccountVote<BalanceOf<T, I>>,
+	) -> DispatchResult {
+		ensure!(
+			vote.balance() <= T::Currency::total_balance(who),
+			Error::<T, I>::InsufficientFunds
+		);
+		T::Polls::try_access_poll(poll_index, |poll_status| {
+			let (tally, class) = poll_status.ensure_ongoing().ok_or(Error::<T, I>::NotOngoing)?;
+			VotingFor::<T, I>::try_mutate(who, &class, |voting| {
+				if let Voting::Casting(Casting { ref mut votes, delegations, .. }) = voting {
+					match votes.binary_search_by_key(&poll_index, |i| i.0) {
+						Ok(i) => {
+							// Shouldn't be possible to fail, but we handle it gracefully.
+							tally.remove(votes[i].1).ok_or(ArithmeticError::Underflow)?;
+							if let Some(approve) = votes[i].1.as_standard() {
+								tally.reduce(approve, *delegations);
+							}
+							votes[i].1 = vote;
+						},
+						Err(i) => {
+							votes
+								.try_insert(i, (poll_index, vote))
+								.map_err(|_| Error::<T, I>::MaxVotesReached)?;
+						},
+					}
+					// Shouldn't be possible to fail, but we handle it gracefully.
+					tally.add(vote).ok_or(ArithmeticError::Overflow)?;
+					if let Some(approve) = vote.as_standard() {
+						tally.increase(approve, *delegations);
+					}
+				} else {
+					return Err(Error::<T, I>::AlreadyDelegating.into())
+				}
+				// Extend the lock to `balance` (rather than setting it) since we don't know what
+				// other votes are in place.
+				Self::extend_lock(who, &class, vote.balance());
+				Ok(())
+			})
+		})
+	}
+
+	/// Remove the account's vote for the given poll if possible. This is possible when:
+	/// - The poll has not finished.
+	/// - The poll has finished and the voter lost their direction.
+	/// - The poll has finished and the voter's lock period is up.
+	///
+	/// This will generally be combined with a call to `unlock`.
+	fn try_remove_vote(
+		who: &T::AccountId,
+		poll_index: PollIndexOf<T, I>,
+		class_hint: Option<ClassOf<T, I>>,
+		scope: UnvoteScope,
+	) -> DispatchResult {
+		let class = class_hint
+			.or_else(|| Some(T::Polls::as_ongoing(poll_index)?.1))
+			.ok_or(Error::<T, I>::ClassNeeded)?;
+		VotingFor::<T, I>::try_mutate(who, class, |voting| {
+			if let Voting::Casting(Casting { ref mut votes, delegations, ref mut prior }) = voting {
+				let i = votes
+					.binary_search_by_key(&poll_index, |i| i.0)
+					.map_err(|_| Error::<T, I>::NotVoter)?;
+				let v = votes.remove(i);
+
+				T::Polls::try_access_poll(poll_index, |poll_status| match poll_status {
+					PollStatus::Ongoing(tally, _) => {
+						ensure!(matches!(scope, UnvoteScope::Any), Error::<T, I>::NoPermission);
+						// Shouldn't be possible to fail, but we handle it gracefully.
+						tally.remove(v.1).ok_or(ArithmeticError::Underflow)?;
+						if let Some(approve) = v.1.as_standard() {
+							tally.reduce(approve, *delegations);
+						}
+						Ok(())
+					},
+					PollStatus::Completed(end, approved) => {
+						if let Some((lock_periods, balance)) = v.1.locked_if(approved) {
+							let unlock_at = end.saturating_add(
+								T::VoteLockingPeriod::get().saturating_mul(lock_periods.into()),
+							);
+							let now = frame_system::Pallet::<T>::block_number();
+							if now < unlock_at {
+								ensure!(
+									matches!(scope, UnvoteScope::Any),
+									Error::<T, I>::NoPermissionYet
+								);
+								prior.accumulate(unlock_at, balance)
+							}
+						}
+						Ok(())
+					},
+					PollStatus::None => Ok(()), // Poll was cancelled.
+				})
+			} else {
+				Ok(())
+			}
+		})
+	}
+
+	/// Return the number of votes for `who`.
+	fn increase_upstream_delegation(
+		who: &T::AccountId,
+		class: &ClassOf<T, I>,
+		amount: Delegations<BalanceOf<T, I>>,
+	) -> u32 {
+		VotingFor::<T, I>::mutate(who, class, |voting| match voting {
+			Voting::Delegating(Delegating { delegations, .. }) => {
+				// We don't support second level delegating, so we don't need to do anything more.
+				*delegations = delegations.saturating_add(amount);
+				1
+			},
+			Voting::Casting(Casting { votes, delegations, .. }) => {
+				*delegations = delegations.saturating_add(amount);
+				for &(poll_index, account_vote) in votes.iter() {
+					if let AccountVote::Standard { vote, .. } = account_vote {
+						T::Polls::access_poll(poll_index, |poll_status| {
+							if let PollStatus::Ongoing(tally, _) = poll_status {
+								tally.increase(vote.aye, amount);
+							}
+						});
+					}
+				}
+				votes.len() as u32
+			},
+		})
+	}
+
+	/// Return the number of votes for `who`.
+	fn reduce_upstream_delegation(
+		who: &T::AccountId,
+		class: &ClassOf<T, I>,
+		amount: Delegations<BalanceOf<T, I>>,
+	) -> u32 {
+		VotingFor::<T, I>::mutate(who, class, |voting| match voting {
+			Voting::Delegating(Delegating { delegations, .. }) => {
+				// We don't support second level delegating, so we don't need to do anything more.
+				*delegations = delegations.saturating_sub(amount);
+				1
+			},
+			Voting::Casting(Casting { votes, delegations, .. }) => {
+				*delegations = delegations.saturating_sub(amount);
+				for &(poll_index, account_vote) in votes.iter() {
+					if let AccountVote::Standard { vote, .. } = account_vote {
+						T::Polls::access_poll(poll_index, |poll_status| {
+							if let PollStatus::Ongoing(tally, _) = poll_status {
+								tally.reduce(vote.aye, amount);
+							}
+						});
+					}
+				}
+				votes.len() as u32
+			},
+		})
+	}
+
+	/// Attempt to delegate `balance` times `conviction` of voting power from `who` to `target`.
+	///
+	/// Return the upstream number of votes.
+	fn try_delegate(
+		who: T::AccountId,
+		class: ClassOf<T, I>,
+		target: T::AccountId,
+		conviction: Conviction,
+		balance: BalanceOf<T, I>,
+	) -> Result<u32, DispatchError> {
+		ensure!(who != target, Error::<T, I>::Nonsense);
+		T::Polls::classes().binary_search(&class).map_err(|_| Error::<T, I>::BadClass)?;
+		ensure!(balance <= T::Currency::total_balance(&who), Error::<T, I>::InsufficientFunds);
+		let votes =
+			VotingFor::<T, I>::try_mutate(&who, &class, |voting| -> Result<u32, DispatchError> {
+				let old = sp_std::mem::replace(
+					voting,
+					Voting::Delegating(Delegating {
+						balance,
+						target: target.clone(),
+						conviction,
+						delegations: Default::default(),
+						prior: Default::default(),
+					}),
+				);
+				match old {
+					Voting::Delegating(Delegating { .. }) =>
+						return Err(Error::<T, I>::AlreadyDelegating.into()),
+					Voting::Casting(Casting { votes, delegations, prior }) => {
+						// here we just ensure that we're currently idling with no votes recorded.
+						ensure!(votes.is_empty(), Error::<T, I>::AlreadyVoting);
+						voting.set_common(delegations, prior);
+					},
+				}
+
+				let votes =
+					Self::increase_upstream_delegation(&target, &class, conviction.votes(balance));
+				// Extend the lock to `balance` (rather than setting it) since we don't know what
+				// other votes are in place.
+				Self::extend_lock(&who, &class, balance);
+				Ok(votes)
+			})?;
+		Self::deposit_event(Event::<T, I>::Delegated(who, target));
+		Ok(votes)
+	}
+
+	/// Attempt to end the current delegation.
+	///
+	/// Return the number of votes of upstream.
+	fn try_undelegate(who: T::AccountId, class: ClassOf<T, I>) -> Result<u32, DispatchError> {
+		let votes =
+			VotingFor::<T, I>::try_mutate(&who, &class, |voting| -> Result<u32, DispatchError> {
+				match sp_std::mem::replace(voting, Voting::default()) {
+					Voting::Delegating(Delegating {
+						balance,
+						target,
+						conviction,
+						delegations,
+						mut prior,
+					}) => {
+						// remove any delegation votes to our current target.
+						let votes = Self::reduce_upstream_delegation(
+							&target,
+							&class,
+							conviction.votes(balance),
+						);
+						let now = frame_system::Pallet::<T>::block_number();
+						let lock_periods = conviction.lock_periods().into();
+						prior.accumulate(
+							now.saturating_add(
+								T::VoteLockingPeriod::get().saturating_mul(lock_periods),
+							),
+							balance,
+						);
+						voting.set_common(delegations, prior);
+
+						Ok(votes)
+					},
+					Voting::Casting(_) => Err(Error::<T, I>::NotDelegating.into()),
+				}
+			})?;
+		Self::deposit_event(Event::<T, I>::Undelegated(who));
+		Ok(votes)
+	}
+
+	fn extend_lock(who: &T::AccountId, class: &ClassOf<T, I>, amount: BalanceOf<T, I>) {
+		ClassLocksFor::<T, I>::mutate(who, |locks| {
+			match locks.iter().position(|x| &x.0 == class) {
+				Some(i) => locks[i].1 = locks[i].1.max(amount),
+				None => {
+					let ok = locks.try_push((class.clone(), amount)).is_ok();
+					debug_assert!(
+						ok,
+						"Vec bounded by number of classes; \
+						all items in Vec associated with a unique class; \
+						qed"
+					);
+				},
+			}
+		});
+		T::Currency::extend_lock(
+			CONVICTION_VOTING_ID,
+			who,
+			amount,
+			WithdrawReasons::except(WithdrawReasons::RESERVE),
+		);
+	}
+
+	/// Rejig the lock on an account. It will never get more stringent (since that would indicate
+	/// a security hole) but may be reduced from what they are currently.
+	fn update_lock(class: &ClassOf<T, I>, who: &T::AccountId) {
+		let class_lock_needed = VotingFor::<T, I>::mutate(who, class, |voting| {
+			voting.rejig(frame_system::Pallet::<T>::block_number());
+			voting.locked_balance()
+		});
+		let lock_needed = ClassLocksFor::<T, I>::mutate(who, |locks| {
+			locks.retain(|x| &x.0 != class);
+			if !class_lock_needed.is_zero() {
+				let ok = locks.try_push((class.clone(), class_lock_needed)).is_ok();
+				debug_assert!(
+					ok,
+					"Vec bounded by number of classes; \
+					all items in Vec associated with a unique class; \
+					qed"
+				);
+			}
+			locks.iter().map(|x| x.1).max().unwrap_or(Zero::zero())
+		});
+		if lock_needed.is_zero() {
+			T::Currency::remove_lock(CONVICTION_VOTING_ID, who);
+		} else {
+			T::Currency::set_lock(
+				CONVICTION_VOTING_ID,
+				who,
+				lock_needed,
+				WithdrawReasons::except(WithdrawReasons::RESERVE),
+			);
+		}
+	}
+}
diff --git a/substrate/frame/conviction-voting/src/tests.rs b/substrate/frame/conviction-voting/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..656112deebfbb7c0519807d5e7100d974d5acb3a
--- /dev/null
+++ b/substrate/frame/conviction-voting/src/tests.rs
@@ -0,0 +1,882 @@
+// 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.
+
+//! The crate's tests.
+
+use std::collections::BTreeMap;
+
+use frame_support::{
+	assert_noop, assert_ok, parameter_types,
+	traits::{ConstU32, ConstU64, Contains, Polling, VoteTally},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+use super::*;
+use crate as pallet_conviction_voting;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Voting: pallet_conviction_voting::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+// Test that a fitlered call can be dispatched.
+pub struct BaseFilter;
+impl Contains<RuntimeCall> for BaseFilter {
+	fn contains(call: &RuntimeCall) -> bool {
+		!matches!(call, &RuntimeCall::Balances(pallet_balances::Call::force_set_balance { .. }))
+	}
+}
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = BaseFilter;
+	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 = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum TestPollState {
+	Ongoing(TallyOf<Test>, u8),
+	Completed(u64, bool),
+}
+use TestPollState::*;
+
+parameter_types! {
+	pub static Polls: BTreeMap<u8, TestPollState> = vec![
+		(1, Completed(1, true)),
+		(2, Completed(2, false)),
+		(3, Ongoing(Tally::from_parts(0, 0, 0), 0)),
+	].into_iter().collect();
+}
+
+pub struct TestPolls;
+impl Polling<TallyOf<Test>> for TestPolls {
+	type Index = u8;
+	type Votes = u64;
+	type Moment = u64;
+	type Class = u8;
+	fn classes() -> Vec<u8> {
+		vec![0, 1, 2]
+	}
+	fn as_ongoing(index: u8) -> Option<(TallyOf<Test>, Self::Class)> {
+		Polls::get().remove(&index).and_then(|x| {
+			if let TestPollState::Ongoing(t, c) = x {
+				Some((t, c))
+			} else {
+				None
+			}
+		})
+	}
+	fn access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(PollStatus<&mut TallyOf<Test>, u64, u8>) -> R,
+	) -> R {
+		let mut polls = Polls::get();
+		let entry = polls.get_mut(&index);
+		let r = match entry {
+			Some(Ongoing(ref mut tally_mut_ref, class)) =>
+				f(PollStatus::Ongoing(tally_mut_ref, *class)),
+			Some(Completed(when, succeeded)) => f(PollStatus::Completed(*when, *succeeded)),
+			None => f(PollStatus::None),
+		};
+		Polls::set(polls);
+		r
+	}
+	fn try_access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(PollStatus<&mut TallyOf<Test>, u64, u8>) -> Result<R, DispatchError>,
+	) -> Result<R, DispatchError> {
+		let mut polls = Polls::get();
+		let entry = polls.get_mut(&index);
+		let r = match entry {
+			Some(Ongoing(ref mut tally_mut_ref, class)) =>
+				f(PollStatus::Ongoing(tally_mut_ref, *class)),
+			Some(Completed(when, succeeded)) => f(PollStatus::Completed(*when, *succeeded)),
+			None => f(PollStatus::None),
+		}?;
+		Polls::set(polls);
+		Ok(r)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn create_ongoing(class: Self::Class) -> Result<Self::Index, ()> {
+		let mut polls = Polls::get();
+		let i = polls.keys().rev().next().map_or(0, |x| x + 1);
+		polls.insert(i, Ongoing(Tally::new(0), class));
+		Polls::set(polls);
+		Ok(i)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn end_ongoing(index: Self::Index, approved: bool) -> Result<(), ()> {
+		let mut polls = Polls::get();
+		match polls.get(&index) {
+			Some(Ongoing(..)) => {},
+			_ => return Err(()),
+		}
+		let now = frame_system::Pallet::<Test>::block_number();
+		polls.insert(index, Completed(now, approved));
+		Polls::set(polls);
+		Ok(())
+	}
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = pallet_balances::Pallet<Self>;
+	type VoteLockingPeriod = ConstU64<3>;
+	type MaxVotes = ConstU32<3>;
+	type WeightInfo = ();
+	type MaxTurnout = frame_support::traits::TotalIssuanceOf<Balances, Self::AccountId>;
+	type Polls = TestPolls;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+#[test]
+fn params_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(42), 0);
+		assert_eq!(Balances::total_issuance(), 210);
+	});
+}
+
+fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+}
+
+#[allow(dead_code)]
+fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+fn aye(amount: u64, conviction: u8) -> AccountVote<u64> {
+	let vote = Vote { aye: true, conviction: conviction.try_into().unwrap() };
+	AccountVote::Standard { vote, balance: amount }
+}
+
+fn nay(amount: u64, conviction: u8) -> AccountVote<u64> {
+	let vote = Vote { aye: false, conviction: conviction.try_into().unwrap() };
+	AccountVote::Standard { vote, balance: amount }
+}
+
+fn split(aye: u64, nay: u64) -> AccountVote<u64> {
+	AccountVote::Split { aye, nay }
+}
+
+fn split_abstain(aye: u64, nay: u64, abstain: u64) -> AccountVote<u64> {
+	AccountVote::SplitAbstain { aye, nay, abstain }
+}
+
+fn tally(index: u8) -> TallyOf<Test> {
+	<TestPolls as Polling<TallyOf<Test>>>::as_ongoing(index).expect("No poll").0
+}
+
+fn class(index: u8) -> u8 {
+	<TestPolls as Polling<TallyOf<Test>>>::as_ongoing(index).expect("No poll").1
+}
+
+#[test]
+#[ignore]
+#[should_panic(expected = "No poll")]
+fn unknown_poll_should_panic() {
+	let _ = tally(0);
+}
+
+#[test]
+#[ignore]
+#[should_panic(expected = "No poll")]
+fn completed_poll_should_panic() {
+	let _ = tally(1);
+}
+
+#[test]
+fn basic_stuff() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
+	});
+}
+
+#[test]
+fn basic_voting_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(2, 5)));
+		assert_eq!(tally(3), Tally::from_parts(10, 0, 2));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, nay(2, 5)));
+		assert_eq!(tally(3), Tally::from_parts(0, 10, 0));
+		assert_eq!(Balances::usable_balance(1), 8);
+
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(5, 1)));
+		assert_eq!(tally(3), Tally::from_parts(5, 0, 5));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, nay(5, 1)));
+		assert_eq!(tally(3), Tally::from_parts(0, 5, 0));
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(10, 0)));
+		assert_eq!(tally(3), Tally::from_parts(1, 0, 10));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, nay(10, 0)));
+		assert_eq!(tally(3), Tally::from_parts(0, 1, 0));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), None, 3));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), class(3), 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn split_voting_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, split(10, 0)));
+		assert_eq!(tally(3), Tally::from_parts(1, 0, 10));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, split(5, 5)));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 5));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), None, 3));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), class(3), 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn abstain_voting_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, split_abstain(0, 0, 10)));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 10));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 3, split_abstain(0, 0, 20)));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 30));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 3, split_abstain(10, 0, 10)));
+		assert_eq!(tally(3), Tally::from_parts(1, 0, 30));
+		assert_eq!(Balances::usable_balance(1), 0);
+		assert_eq!(Balances::usable_balance(2), 0);
+
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), None, 3));
+		assert_eq!(tally(3), Tally::from_parts(1, 0, 20));
+
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(2), None, 3));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), class(3), 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(2), class(3), 2));
+		assert_eq!(Balances::usable_balance(2), 20);
+	});
+}
+
+#[test]
+fn voting_balance_gets_locked() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(2, 5)));
+		assert_eq!(tally(3), Tally::from_parts(10, 0, 2));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, nay(2, 5)));
+		assert_eq!(tally(3), Tally::from_parts(0, 10, 0));
+		assert_eq!(Balances::usable_balance(1), 8);
+
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(5, 1)));
+		assert_eq!(tally(3), Tally::from_parts(5, 0, 5));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, nay(5, 1)));
+		assert_eq!(tally(3), Tally::from_parts(0, 5, 0));
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(10, 0)));
+		assert_eq!(tally(3), Tally::from_parts(1, 0, 10));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, nay(10, 0)));
+		assert_eq!(tally(3), Tally::from_parts(0, 1, 0));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), None, 3));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), class(3), 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn successful_but_zero_conviction_vote_balance_can_be_unlocked() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(1, 1)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 3, nay(20, 0)));
+		let c = class(3);
+		Polls::set(vec![(3, Completed(3, false))].into_iter().collect());
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(2), Some(c), 3));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(2), c, 2));
+		assert_eq!(Balances::usable_balance(2), 20);
+	});
+}
+
+#[test]
+fn unsuccessful_conviction_vote_balance_can_be_unlocked() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(1, 1)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 3, nay(20, 0)));
+		let c = class(3);
+		Polls::set(vec![(3, Completed(3, false))].into_iter().collect());
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(c), 3));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), c, 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn successful_conviction_vote_balance_stays_locked_for_correct_time() {
+	new_test_ext().execute_with(|| {
+		for i in 1..=5 {
+			assert_ok!(Voting::vote(RuntimeOrigin::signed(i), 3, aye(10, i as u8)));
+		}
+		let c = class(3);
+		Polls::set(vec![(3, Completed(3, true))].into_iter().collect());
+		for i in 1..=5 {
+			assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(i), Some(c), 3));
+		}
+		for block in 1..=(3 + 5 * 3) {
+			run_to(block);
+			for i in 1..=5 {
+				assert_ok!(Voting::unlock(RuntimeOrigin::signed(i), c, i));
+				let expired = block >= (3 << (i - 1)) + 3;
+				assert_eq!(Balances::usable_balance(i), i * 10 - if expired { 0 } else { 10 });
+			}
+		}
+	});
+}
+
+#[test]
+fn classwise_delegation_works() {
+	new_test_ext().execute_with(|| {
+		Polls::set(
+			vec![
+				(0, Ongoing(Tally::new(0), 0)),
+				(1, Ongoing(Tally::new(0), 1)),
+				(2, Ongoing(Tally::new(0), 2)),
+				(3, Ongoing(Tally::new(0), 2)),
+			]
+			.into_iter()
+			.collect(),
+		);
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 5));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 1, 3, Conviction::Locked1x, 5));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 2, 4, Conviction::Locked1x, 5));
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 0, aye(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 1, nay(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 2, nay(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(3), 0, nay(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(3), 1, aye(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(3), 2, nay(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(4), 0, nay(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(4), 1, nay(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(4), 2, aye(10, 0)));
+		// 4 hasn't voted yet
+
+		assert_eq!(
+			Polls::get(),
+			vec![
+				(0, Ongoing(Tally::from_parts(6, 2, 15), 0)),
+				(1, Ongoing(Tally::from_parts(6, 2, 15), 1)),
+				(2, Ongoing(Tally::from_parts(6, 2, 15), 2)),
+				(3, Ongoing(Tally::from_parts(0, 0, 0), 2)),
+			]
+			.into_iter()
+			.collect()
+		);
+
+		// 4 votes nay to 3.
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(4), 3, nay(10, 0)));
+		assert_eq!(
+			Polls::get(),
+			vec![
+				(0, Ongoing(Tally::from_parts(6, 2, 15), 0)),
+				(1, Ongoing(Tally::from_parts(6, 2, 15), 1)),
+				(2, Ongoing(Tally::from_parts(6, 2, 15), 2)),
+				(3, Ongoing(Tally::from_parts(0, 6, 0), 2)),
+			]
+			.into_iter()
+			.collect()
+		);
+
+		// Redelegate for class 2 to account 3.
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 2));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 2, 3, Conviction::Locked1x, 5));
+		assert_eq!(
+			Polls::get(),
+			vec![
+				(0, Ongoing(Tally::from_parts(6, 2, 15), 0)),
+				(1, Ongoing(Tally::from_parts(6, 2, 15), 1)),
+				(2, Ongoing(Tally::from_parts(1, 7, 10), 2)),
+				(3, Ongoing(Tally::from_parts(0, 1, 0), 2)),
+			]
+			.into_iter()
+			.collect()
+		);
+
+		// Redelegating with a lower lock does not forget previous lock and updates correctly.
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 1));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 2));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 3));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 1, 3, Conviction::Locked1x, 3));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 2, 4, Conviction::Locked1x, 3));
+		assert_eq!(
+			Polls::get(),
+			vec![
+				(0, Ongoing(Tally::from_parts(4, 2, 13), 0)),
+				(1, Ongoing(Tally::from_parts(4, 2, 13), 1)),
+				(2, Ongoing(Tally::from_parts(4, 2, 13), 2)),
+				(3, Ongoing(Tally::from_parts(0, 4, 0), 2)),
+			]
+			.into_iter()
+			.collect()
+		);
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		// unlock does nothing since the delegation already took place.
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		// Redelegating with higher amount extends previous lock.
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 6));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 4);
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 1));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 1, 3, Conviction::Locked1x, 7));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_eq!(Balances::usable_balance(1), 3);
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 2));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 2, 4, Conviction::Locked1x, 8));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		assert_eq!(Balances::usable_balance(1), 2);
+		assert_eq!(
+			Polls::get(),
+			vec![
+				(0, Ongoing(Tally::from_parts(7, 2, 16), 0)),
+				(1, Ongoing(Tally::from_parts(8, 2, 17), 1)),
+				(2, Ongoing(Tally::from_parts(9, 2, 18), 2)),
+				(3, Ongoing(Tally::from_parts(0, 9, 0), 2)),
+			]
+			.into_iter()
+			.collect()
+		);
+	});
+}
+
+#[test]
+fn redelegation_after_vote_ending_should_keep_lock() {
+	new_test_ext().execute_with(|| {
+		Polls::set(vec![(0, Ongoing(Tally::new(0), 0))].into_iter().collect());
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 5));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(2), 0, aye(10, 1)));
+		Polls::set(vec![(0, Completed(1, true))].into_iter().collect());
+		assert_eq!(Balances::usable_balance(1), 5);
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 3, Conviction::Locked1x, 3));
+		assert_eq!(Balances::usable_balance(1), 5);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 5);
+	});
+}
+
+#[test]
+fn lock_amalgamation_valid_with_multiple_removed_votes() {
+	new_test_ext().execute_with(|| {
+		Polls::set(
+			vec![
+				(0, Ongoing(Tally::new(0), 0)),
+				(1, Ongoing(Tally::new(0), 0)),
+				(2, Ongoing(Tally::new(0), 0)),
+			]
+			.into_iter()
+			.collect(),
+		);
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 0, aye(5, 1)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 1, aye(10, 1)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 2, aye(5, 2)));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		Polls::set(
+			vec![(0, Completed(1, true)), (1, Completed(1, true)), (2, Completed(1, true))]
+				.into_iter()
+				.collect(),
+		);
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 0));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 2));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		run_to(3);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		run_to(6);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert!(Balances::usable_balance(1) <= 5);
+
+		run_to(7);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn lock_amalgamation_valid_with_multiple_delegations() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 5));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 10));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked2x, 5));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+
+		run_to(3);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		run_to(6);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert!(Balances::usable_balance(1) <= 5);
+
+		run_to(7);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn lock_amalgamation_valid_with_move_roundtrip_to_delegation() {
+	new_test_ext().execute_with(|| {
+		Polls::set(vec![(0, Ongoing(Tally::new(0), 0))].into_iter().collect());
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 0, aye(5, 1)));
+		Polls::set(vec![(0, Completed(1, true))].into_iter().collect());
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 0));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 10));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		Polls::set(vec![(1, Ongoing(Tally::new(0), 0))].into_iter().collect());
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 1, aye(5, 2)));
+		Polls::set(vec![(1, Completed(1, true))].into_iter().collect());
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 1));
+
+		run_to(3);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		run_to(6);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert!(Balances::usable_balance(1) <= 5);
+
+		run_to(7);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn lock_amalgamation_valid_with_move_roundtrip_to_casting() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 5));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		Polls::set(vec![(0, Ongoing(Tally::new(0), 0))].into_iter().collect());
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 0, aye(10, 1)));
+		Polls::set(vec![(0, Completed(1, true))].into_iter().collect());
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 0));
+
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked2x, 10));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+
+		run_to(3);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		run_to(6);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert!(Balances::usable_balance(1) <= 5);
+
+		run_to(7);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn lock_aggregation_over_different_classes_with_delegation_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::Locked1x, 5));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 1, 2, Conviction::Locked2x, 5));
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 2, 2, Conviction::Locked1x, 10));
+
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 1));
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 2));
+
+		run_to(3);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		run_to(6);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		run_to(7);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn lock_aggregation_over_different_classes_with_casting_works() {
+	new_test_ext().execute_with(|| {
+		Polls::set(
+			vec![
+				(0, Ongoing(Tally::new(0), 0)),
+				(1, Ongoing(Tally::new(0), 1)),
+				(2, Ongoing(Tally::new(0), 2)),
+			]
+			.into_iter()
+			.collect(),
+		);
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 0, aye(5, 1)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 1, aye(10, 1)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 2, aye(5, 2)));
+		Polls::set(
+			vec![(0, Completed(1, true)), (1, Completed(1, true)), (2, Completed(1, true))]
+				.into_iter()
+				.collect(),
+		);
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 0));
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(1), 1));
+		assert_ok!(Voting::remove_vote(RuntimeOrigin::signed(1), Some(2), 2));
+
+		run_to(3);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		assert_eq!(Balances::usable_balance(1), 0);
+
+		run_to(6);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		assert_eq!(Balances::usable_balance(1), 5);
+
+		run_to(7);
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 0, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 1, 1));
+		assert_ok!(Voting::unlock(RuntimeOrigin::signed(1), 2, 1));
+		assert_eq!(Balances::usable_balance(1), 10);
+	});
+}
+
+#[test]
+fn errors_with_vote_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Voting::vote(RuntimeOrigin::signed(1), 0, aye(10, 0)),
+			Error::<Test>::NotOngoing
+		);
+		assert_noop!(
+			Voting::vote(RuntimeOrigin::signed(1), 1, aye(10, 0)),
+			Error::<Test>::NotOngoing
+		);
+		assert_noop!(
+			Voting::vote(RuntimeOrigin::signed(1), 2, aye(10, 0)),
+			Error::<Test>::NotOngoing
+		);
+		assert_noop!(
+			Voting::vote(RuntimeOrigin::signed(1), 3, aye(11, 0)),
+			Error::<Test>::InsufficientFunds
+		);
+
+		assert_ok!(Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::None, 10));
+		assert_noop!(
+			Voting::vote(RuntimeOrigin::signed(1), 3, aye(10, 0)),
+			Error::<Test>::AlreadyDelegating
+		);
+
+		assert_ok!(Voting::undelegate(RuntimeOrigin::signed(1), 0));
+		Polls::set(
+			vec![
+				(0, Ongoing(Tally::new(0), 0)),
+				(1, Ongoing(Tally::new(0), 0)),
+				(2, Ongoing(Tally::new(0), 0)),
+				(3, Ongoing(Tally::new(0), 0)),
+			]
+			.into_iter()
+			.collect(),
+		);
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 0, aye(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 1, aye(10, 0)));
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 2, aye(10, 0)));
+		assert_noop!(
+			Voting::vote(RuntimeOrigin::signed(1), 3, aye(10, 0)),
+			Error::<Test>::MaxVotesReached
+		);
+	});
+}
+
+#[test]
+fn errors_with_delegating_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::None, 11),
+			Error::<Test>::InsufficientFunds
+		);
+		assert_noop!(
+			Voting::delegate(RuntimeOrigin::signed(1), 3, 2, Conviction::None, 10),
+			Error::<Test>::BadClass
+		);
+
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(10, 0)));
+		assert_noop!(
+			Voting::delegate(RuntimeOrigin::signed(1), 0, 2, Conviction::None, 10),
+			Error::<Test>::AlreadyVoting
+		);
+
+		assert_noop!(Voting::undelegate(RuntimeOrigin::signed(1), 0), Error::<Test>::NotDelegating);
+	});
+}
+
+#[test]
+fn remove_other_vote_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Voting::remove_other_vote(RuntimeOrigin::signed(2), 1, 0, 3),
+			Error::<Test>::NotVoter
+		);
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(10, 2)));
+		assert_noop!(
+			Voting::remove_other_vote(RuntimeOrigin::signed(2), 1, 0, 3),
+			Error::<Test>::NoPermission
+		);
+		Polls::set(vec![(3, Completed(1, true))].into_iter().collect());
+		run_to(6);
+		assert_noop!(
+			Voting::remove_other_vote(RuntimeOrigin::signed(2), 1, 0, 3),
+			Error::<Test>::NoPermissionYet
+		);
+		run_to(7);
+		assert_ok!(Voting::remove_other_vote(RuntimeOrigin::signed(2), 1, 0, 3));
+	});
+}
+
+#[test]
+fn errors_with_remove_vote_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Voting::remove_vote(RuntimeOrigin::signed(1), Some(0), 3),
+			Error::<Test>::NotVoter
+		);
+		assert_ok!(Voting::vote(RuntimeOrigin::signed(1), 3, aye(10, 2)));
+		Polls::set(vec![(3, Completed(1, true))].into_iter().collect());
+		assert_noop!(
+			Voting::remove_vote(RuntimeOrigin::signed(1), None, 3),
+			Error::<Test>::ClassNeeded
+		);
+	});
+}
diff --git a/substrate/frame/conviction-voting/src/types.rs b/substrate/frame/conviction-voting/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2c45b54485bd95c5d0e6e97b114ea199b376444f
--- /dev/null
+++ b/substrate/frame/conviction-voting/src/types.rs
@@ -0,0 +1,264 @@
+// 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.
+
+//! Miscellaneous additional datatypes.
+
+use codec::{Codec, Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	traits::VoteTally, CloneNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	RuntimeDebug,
+};
+use sp_std::{fmt::Debug, marker::PhantomData};
+
+use super::*;
+use crate::{AccountVote, Conviction, Vote};
+
+/// Info regarding an ongoing referendum.
+#[derive(
+	CloneNoBound,
+	PartialEqNoBound,
+	EqNoBound,
+	RuntimeDebugNoBound,
+	TypeInfo,
+	Encode,
+	Decode,
+	MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(Total))]
+#[codec(mel_bound(Votes: MaxEncodedLen))]
+pub struct Tally<Votes: Clone + PartialEq + Eq + Debug + TypeInfo + Codec, Total> {
+	/// The number of aye votes, expressed in terms of post-conviction lock-vote.
+	pub ayes: Votes,
+	/// The number of nay votes, expressed in terms of post-conviction lock-vote.
+	pub nays: Votes,
+	/// The basic number of aye votes, expressed pre-conviction.
+	pub support: Votes,
+	/// Dummy.
+	dummy: PhantomData<Total>,
+}
+
+impl<
+		Votes: Clone + Default + PartialEq + Eq + Debug + Copy + AtLeast32BitUnsigned + TypeInfo + Codec,
+		Total: Get<Votes>,
+		Class,
+	> VoteTally<Votes, Class> for Tally<Votes, Total>
+{
+	fn new(_: Class) -> Self {
+		Self { ayes: Zero::zero(), nays: Zero::zero(), support: Zero::zero(), dummy: PhantomData }
+	}
+
+	fn ayes(&self, _: Class) -> Votes {
+		self.ayes
+	}
+
+	fn support(&self, _: Class) -> Perbill {
+		Perbill::from_rational(self.support, Total::get())
+	}
+
+	fn approval(&self, _: Class) -> Perbill {
+		Perbill::from_rational(self.ayes, self.ayes.saturating_add(self.nays))
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn unanimity(_: Class) -> Self {
+		Self { ayes: Total::get(), nays: Zero::zero(), support: Total::get(), dummy: PhantomData }
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn rejection(_: Class) -> Self {
+		Self { ayes: Zero::zero(), nays: Total::get(), support: Total::get(), dummy: PhantomData }
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn from_requirements(support: Perbill, approval: Perbill, _: Class) -> Self {
+		let support = support.mul_ceil(Total::get());
+		let ayes = approval.mul_ceil(support);
+		Self { ayes, nays: support - ayes, support, dummy: PhantomData }
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn setup(_: Class, _: Perbill) {}
+}
+
+impl<
+		Votes: Clone + Default + PartialEq + Eq + Debug + Copy + AtLeast32BitUnsigned + TypeInfo + Codec,
+		Total: Get<Votes>,
+	> Tally<Votes, Total>
+{
+	/// Create a new tally.
+	pub fn from_vote(vote: Vote, balance: Votes) -> Self {
+		let Delegations { votes, capital } = vote.conviction.votes(balance);
+		Self {
+			ayes: if vote.aye { votes } else { Zero::zero() },
+			nays: if vote.aye { Zero::zero() } else { votes },
+			support: capital,
+			dummy: PhantomData,
+		}
+	}
+
+	pub fn from_parts(
+		ayes_with_conviction: Votes,
+		nays_with_conviction: Votes,
+		ayes: Votes,
+	) -> Self {
+		Self {
+			ayes: ayes_with_conviction,
+			nays: nays_with_conviction,
+			support: ayes,
+			dummy: PhantomData,
+		}
+	}
+
+	/// Add an account's vote into the tally.
+	pub fn add(&mut self, vote: AccountVote<Votes>) -> Option<()> {
+		match vote {
+			AccountVote::Standard { vote, balance } => {
+				let Delegations { votes, capital } = vote.conviction.votes(balance);
+				match vote.aye {
+					true => {
+						self.support = self.support.checked_add(&capital)?;
+						self.ayes = self.ayes.checked_add(&votes)?
+					},
+					false => self.nays = self.nays.checked_add(&votes)?,
+				}
+			},
+			AccountVote::Split { aye, nay } => {
+				let aye = Conviction::None.votes(aye);
+				let nay = Conviction::None.votes(nay);
+				self.support = self.support.checked_add(&aye.capital)?;
+				self.ayes = self.ayes.checked_add(&aye.votes)?;
+				self.nays = self.nays.checked_add(&nay.votes)?;
+			},
+			AccountVote::SplitAbstain { aye, nay, abstain } => {
+				let aye = Conviction::None.votes(aye);
+				let nay = Conviction::None.votes(nay);
+				let abstain = Conviction::None.votes(abstain);
+				self.support =
+					self.support.checked_add(&aye.capital)?.checked_add(&abstain.capital)?;
+				self.ayes = self.ayes.checked_add(&aye.votes)?;
+				self.nays = self.nays.checked_add(&nay.votes)?;
+			},
+		}
+		Some(())
+	}
+
+	/// Remove an account's vote from the tally.
+	pub fn remove(&mut self, vote: AccountVote<Votes>) -> Option<()> {
+		match vote {
+			AccountVote::Standard { vote, balance } => {
+				let Delegations { votes, capital } = vote.conviction.votes(balance);
+				match vote.aye {
+					true => {
+						self.support = self.support.checked_sub(&capital)?;
+						self.ayes = self.ayes.checked_sub(&votes)?
+					},
+					false => self.nays = self.nays.checked_sub(&votes)?,
+				}
+			},
+			AccountVote::Split { aye, nay } => {
+				let aye = Conviction::None.votes(aye);
+				let nay = Conviction::None.votes(nay);
+				self.support = self.support.checked_sub(&aye.capital)?;
+				self.ayes = self.ayes.checked_sub(&aye.votes)?;
+				self.nays = self.nays.checked_sub(&nay.votes)?;
+			},
+			AccountVote::SplitAbstain { aye, nay, abstain } => {
+				let aye = Conviction::None.votes(aye);
+				let nay = Conviction::None.votes(nay);
+				let abstain = Conviction::None.votes(abstain);
+				self.support =
+					self.support.checked_sub(&aye.capital)?.checked_sub(&abstain.capital)?;
+				self.ayes = self.ayes.checked_sub(&aye.votes)?;
+				self.nays = self.nays.checked_sub(&nay.votes)?;
+			},
+		}
+		Some(())
+	}
+
+	/// Increment some amount of votes.
+	pub fn increase(&mut self, approve: bool, delegations: Delegations<Votes>) {
+		match approve {
+			true => {
+				self.support = self.support.saturating_add(delegations.capital);
+				self.ayes = self.ayes.saturating_add(delegations.votes);
+			},
+			false => self.nays = self.nays.saturating_add(delegations.votes),
+		}
+	}
+
+	/// Decrement some amount of votes.
+	pub fn reduce(&mut self, approve: bool, delegations: Delegations<Votes>) {
+		match approve {
+			true => {
+				self.support = self.support.saturating_sub(delegations.capital);
+				self.ayes = self.ayes.saturating_sub(delegations.votes);
+			},
+			false => self.nays = self.nays.saturating_sub(delegations.votes),
+		}
+	}
+}
+
+/// Amount of votes and capital placed in delegation for an account.
+#[derive(
+	Encode, Decode, Default, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen,
+)]
+pub struct Delegations<Balance> {
+	/// The number of votes (this is post-conviction).
+	pub votes: Balance,
+	/// The amount of raw capital, used for the support.
+	pub capital: Balance,
+}
+
+impl<Balance: Saturating> Saturating for Delegations<Balance> {
+	fn saturating_add(self, o: Self) -> Self {
+		Self {
+			votes: self.votes.saturating_add(o.votes),
+			capital: self.capital.saturating_add(o.capital),
+		}
+	}
+
+	fn saturating_sub(self, o: Self) -> Self {
+		Self {
+			votes: self.votes.saturating_sub(o.votes),
+			capital: self.capital.saturating_sub(o.capital),
+		}
+	}
+
+	fn saturating_mul(self, o: Self) -> Self {
+		Self {
+			votes: self.votes.saturating_mul(o.votes),
+			capital: self.capital.saturating_mul(o.capital),
+		}
+	}
+
+	fn saturating_pow(self, exp: usize) -> Self {
+		Self { votes: self.votes.saturating_pow(exp), capital: self.capital.saturating_pow(exp) }
+	}
+}
+
+/// Whether an `unvote` operation is able to make actions that are not strictly always in the
+/// interest of an account.
+pub enum UnvoteScope {
+	/// Permitted to do everything.
+	Any,
+	/// Permitted to do only the changes that do not need the owner's permission.
+	OnlyExpired,
+}
diff --git a/substrate/frame/conviction-voting/src/vote.rs b/substrate/frame/conviction-voting/src/vote.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5ae08f0de65f269ad71cf1e7679e5421be4fa3db
--- /dev/null
+++ b/substrate/frame/conviction-voting/src/vote.rs
@@ -0,0 +1,265 @@
+// 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.
+
+//! The vote datatype.
+
+use crate::{Conviction, Delegations};
+use codec::{Decode, Encode, EncodeLike, Input, MaxEncodedLen, Output};
+use frame_support::{pallet_prelude::Get, BoundedVec};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	RuntimeDebug,
+};
+use sp_std::prelude::*;
+
+/// A number of lock periods, plus a vote, one way or the other.
+#[derive(Copy, Clone, Eq, PartialEq, Default, RuntimeDebug, MaxEncodedLen)]
+pub struct Vote {
+	pub aye: bool,
+	pub conviction: Conviction,
+}
+
+impl Encode for Vote {
+	fn encode_to<T: Output + ?Sized>(&self, output: &mut T) {
+		output.push_byte(u8::from(self.conviction) | if self.aye { 0b1000_0000 } else { 0 });
+	}
+}
+
+impl EncodeLike for Vote {}
+
+impl Decode for Vote {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		let b = input.read_byte()?;
+		Ok(Vote {
+			aye: (b & 0b1000_0000) == 0b1000_0000,
+			conviction: Conviction::try_from(b & 0b0111_1111)
+				.map_err(|_| codec::Error::from("Invalid conviction"))?,
+		})
+	}
+}
+
+impl TypeInfo for Vote {
+	type Identity = Self;
+
+	fn type_info() -> scale_info::Type {
+		scale_info::Type::builder()
+			.path(scale_info::Path::new("Vote", module_path!()))
+			.composite(
+				scale_info::build::Fields::unnamed()
+					.field(|f| f.ty::<u8>().docs(&["Raw vote byte, encodes aye + conviction"])),
+			)
+	}
+}
+
+/// A vote for a referendum of a particular account.
+#[derive(Encode, Decode, Copy, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum AccountVote<Balance> {
+	/// A standard vote, one-way (approve or reject) with a given amount of conviction.
+	Standard { vote: Vote, balance: Balance },
+	/// A split vote with balances given for both ways, and with no conviction, useful for
+	/// parachains when voting.
+	Split { aye: Balance, nay: Balance },
+	/// A split vote with balances given for both ways as well as abstentions, and with no
+	/// conviction, useful for parachains when voting, other off-chain aggregate accounts and
+	/// individuals who wish to abstain.
+	SplitAbstain { aye: Balance, nay: Balance, abstain: Balance },
+}
+
+impl<Balance: Saturating> AccountVote<Balance> {
+	/// Returns `Some` of the lock periods that the account is locked for, assuming that the
+	/// referendum passed iff `approved` is `true`.
+	pub fn locked_if(self, approved: bool) -> Option<(u32, Balance)> {
+		// winning side: can only be removed after the lock period ends.
+		match self {
+			AccountVote::Standard { vote: Vote { conviction: Conviction::None, .. }, .. } => None,
+			AccountVote::Standard { vote, balance } if vote.aye == approved =>
+				Some((vote.conviction.lock_periods(), balance)),
+			_ => None,
+		}
+	}
+
+	/// The total balance involved in this vote.
+	pub fn balance(self) -> Balance {
+		match self {
+			AccountVote::Standard { balance, .. } => balance,
+			AccountVote::Split { aye, nay } => aye.saturating_add(nay),
+			AccountVote::SplitAbstain { aye, nay, abstain } =>
+				aye.saturating_add(nay).saturating_add(abstain),
+		}
+	}
+
+	/// Returns `Some` with whether the vote is an aye vote if it is standard, otherwise `None` if
+	/// it is split.
+	pub fn as_standard(self) -> Option<bool> {
+		match self {
+			AccountVote::Standard { vote, .. } => Some(vote.aye),
+			_ => None,
+		}
+	}
+}
+
+/// A "prior" lock, i.e. a lock for some now-forgotten reason.
+#[derive(
+	Encode,
+	Decode,
+	Default,
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	RuntimeDebug,
+	TypeInfo,
+	MaxEncodedLen,
+)]
+pub struct PriorLock<BlockNumber, Balance>(BlockNumber, Balance);
+
+impl<BlockNumber: Ord + Copy + Zero, Balance: Ord + Copy + Zero> PriorLock<BlockNumber, Balance> {
+	/// Accumulates an additional lock.
+	pub fn accumulate(&mut self, until: BlockNumber, amount: Balance) {
+		self.0 = self.0.max(until);
+		self.1 = self.1.max(amount);
+	}
+
+	pub fn locked(&self) -> Balance {
+		self.1
+	}
+
+	pub fn rejig(&mut self, now: BlockNumber) {
+		if now >= self.0 {
+			self.0 = Zero::zero();
+			self.1 = Zero::zero();
+		}
+	}
+}
+
+/// Information concerning the delegation of some voting power.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct Delegating<Balance, AccountId, BlockNumber> {
+	/// The amount of balance delegated.
+	pub balance: Balance,
+	/// The account to which the voting power is delegated.
+	pub target: AccountId,
+	/// The conviction with which the voting power is delegated. When this gets undelegated, the
+	/// relevant lock begins.
+	pub conviction: Conviction,
+	/// The total amount of delegations that this account has received, post-conviction-weighting.
+	pub delegations: Delegations<Balance>,
+	/// Any pre-existing locks from past voting/delegating activity.
+	pub prior: PriorLock<BlockNumber, Balance>,
+}
+
+/// Information concerning the direct vote-casting of some voting power.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(MaxVotes))]
+#[codec(mel_bound(Balance: MaxEncodedLen, BlockNumber: MaxEncodedLen, PollIndex: MaxEncodedLen))]
+pub struct Casting<Balance, BlockNumber, PollIndex, MaxVotes>
+where
+	MaxVotes: Get<u32>,
+{
+	/// The current votes of the account.
+	pub votes: BoundedVec<(PollIndex, AccountVote<Balance>), MaxVotes>,
+	/// The total amount of delegations that this account has received, post-conviction-weighting.
+	pub delegations: Delegations<Balance>,
+	/// Any pre-existing locks from past voting/delegating activity.
+	pub prior: PriorLock<BlockNumber, Balance>,
+}
+
+/// An indicator for what an account is doing; it can either be delegating or voting.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(MaxVotes))]
+#[codec(mel_bound(
+	Balance: MaxEncodedLen, AccountId: MaxEncodedLen, BlockNumber: MaxEncodedLen,
+	PollIndex: MaxEncodedLen,
+))]
+pub enum Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>
+where
+	MaxVotes: Get<u32>,
+{
+	/// The account is voting directly.
+	Casting(Casting<Balance, BlockNumber, PollIndex, MaxVotes>),
+	/// The account is delegating `balance` of its balance to a `target` account with `conviction`.
+	Delegating(Delegating<Balance, AccountId, BlockNumber>),
+}
+
+impl<Balance: Default, AccountId, BlockNumber: Zero, PollIndex, MaxVotes> Default
+	for Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>
+where
+	MaxVotes: Get<u32>,
+{
+	fn default() -> Self {
+		Voting::Casting(Casting {
+			votes: Default::default(),
+			delegations: Default::default(),
+			prior: PriorLock(Zero::zero(), Default::default()),
+		})
+	}
+}
+
+impl<Balance, AccountId, BlockNumber, PollIndex, MaxVotes> AsMut<PriorLock<BlockNumber, Balance>>
+	for Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>
+where
+	MaxVotes: Get<u32>,
+{
+	fn as_mut(&mut self) -> &mut PriorLock<BlockNumber, Balance> {
+		match self {
+			Voting::Casting(Casting { prior, .. }) => prior,
+			Voting::Delegating(Delegating { prior, .. }) => prior,
+		}
+	}
+}
+
+impl<
+		Balance: Saturating + Ord + Zero + Copy,
+		BlockNumber: Ord + Copy + Zero,
+		AccountId,
+		PollIndex,
+		MaxVotes,
+	> Voting<Balance, AccountId, BlockNumber, PollIndex, MaxVotes>
+where
+	MaxVotes: Get<u32>,
+{
+	pub fn rejig(&mut self, now: BlockNumber) {
+		AsMut::<PriorLock<BlockNumber, Balance>>::as_mut(self).rejig(now);
+	}
+
+	/// The amount of this account's balance that must currently be locked due to voting.
+	pub fn locked_balance(&self) -> Balance {
+		match self {
+			Voting::Casting(Casting { votes, prior, .. }) =>
+				votes.iter().map(|i| i.1.balance()).fold(prior.locked(), |a, i| a.max(i)),
+			Voting::Delegating(Delegating { balance, prior, .. }) => *balance.max(&prior.locked()),
+		}
+	}
+
+	pub fn set_common(
+		&mut self,
+		delegations: Delegations<Balance>,
+		prior: PriorLock<BlockNumber, Balance>,
+	) {
+		let (d, p) = match self {
+			Voting::Casting(Casting { ref mut delegations, ref mut prior, .. }) =>
+				(delegations, prior),
+			Voting::Delegating(Delegating { ref mut delegations, ref mut prior, .. }) =>
+				(delegations, prior),
+		};
+		*d = delegations;
+		*p = prior;
+	}
+}
diff --git a/substrate/frame/conviction-voting/src/weights.rs b/substrate/frame/conviction-voting/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..225f5c2cadd6fc3d4cb1dc735cf164d92150327f
--- /dev/null
+++ b/substrate/frame/conviction-voting/src/weights.rs
@@ -0,0 +1,341 @@
+// 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.
+
+//! Autogenerated weights for pallet_conviction_voting
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_conviction_voting
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/conviction-voting/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_conviction_voting.
+pub trait WeightInfo {
+	fn vote_new() -> Weight;
+	fn vote_existing() -> Weight;
+	fn remove_vote() -> Weight;
+	fn remove_other_vote() -> Weight;
+	fn delegate(r: u32, ) -> Weight;
+	fn undelegate(r: u32, ) -> Weight;
+	fn unlock() -> Weight;
+}
+
+/// Weights for pallet_conviction_voting using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn vote_new() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `13074`
+		//  Estimated: `219984`
+		// Minimum execution time: 112_936_000 picoseconds.
+		Weight::from_parts(116_972_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn vote_existing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `20216`
+		//  Estimated: `219984`
+		// Minimum execution time: 291_971_000 picoseconds.
+		Weight::from_parts(301_738_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn remove_vote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `19968`
+		//  Estimated: `219984`
+		// Minimum execution time: 262_582_000 picoseconds.
+		Weight::from_parts(270_955_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn remove_other_vote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `12675`
+		//  Estimated: `30706`
+		// Minimum execution time: 52_909_000 picoseconds.
+		Weight::from_parts(56_365_000, 30706)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:2 w:2)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 1]`.
+	fn delegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `240 + r * (1627 ±0)`
+		//  Estimated: `109992 + r * (109992 ±0)`
+		// Minimum execution time: 54_640_000 picoseconds.
+		Weight::from_parts(57_185_281, 109992)
+			// Standard Error: 193_362
+			.saturating_add(Weight::from_parts(44_897_418, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 109992).saturating_mul(r.into()))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:2 w:2)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 1]`.
+	fn undelegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `406 + r * (1376 ±0)`
+		//  Estimated: `109992 + r * (109992 ±0)`
+		// Minimum execution time: 26_514_000 picoseconds.
+		Weight::from_parts(28_083_732, 109992)
+			// Standard Error: 104_905
+			.saturating_add(Weight::from_parts(40_722_467, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 109992).saturating_mul(r.into()))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	fn unlock() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `11734`
+		//  Estimated: `30706`
+		// Minimum execution time: 71_140_000 picoseconds.
+		Weight::from_parts(77_388_000, 30706)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn vote_new() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `13074`
+		//  Estimated: `219984`
+		// Minimum execution time: 112_936_000 picoseconds.
+		Weight::from_parts(116_972_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn vote_existing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `20216`
+		//  Estimated: `219984`
+		// Minimum execution time: 291_971_000 picoseconds.
+		Weight::from_parts(301_738_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn remove_vote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `19968`
+		//  Estimated: `219984`
+		// Minimum execution time: 262_582_000 picoseconds.
+		Weight::from_parts(270_955_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn remove_other_vote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `12675`
+		//  Estimated: `30706`
+		// Minimum execution time: 52_909_000 picoseconds.
+		Weight::from_parts(56_365_000, 30706)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:2 w:2)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 1]`.
+	fn delegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `240 + r * (1627 ±0)`
+		//  Estimated: `109992 + r * (109992 ±0)`
+		// Minimum execution time: 54_640_000 picoseconds.
+		Weight::from_parts(57_185_281, 109992)
+			// Standard Error: 193_362
+			.saturating_add(Weight::from_parts(44_897_418, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 109992).saturating_mul(r.into()))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:2 w:2)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 1]`.
+	fn undelegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `406 + r * (1376 ±0)`
+		//  Estimated: `109992 + r * (109992 ±0)`
+		// Minimum execution time: 26_514_000 picoseconds.
+		Weight::from_parts(28_083_732, 109992)
+			// Standard Error: 104_905
+			.saturating_add(Weight::from_parts(40_722_467, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 109992).saturating_mul(r.into()))
+	}
+	/// Storage: ConvictionVoting VotingFor (r:1 w:1)
+	/// Proof: ConvictionVoting VotingFor (max_values: None, max_size: Some(27241), added: 29716, mode: MaxEncodedLen)
+	/// Storage: ConvictionVoting ClassLocksFor (r:1 w:1)
+	/// Proof: ConvictionVoting ClassLocksFor (max_values: None, max_size: Some(59), added: 2534, 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(49), added: 2524, mode: MaxEncodedLen)
+	fn unlock() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `11734`
+		//  Estimated: `30706`
+		// Minimum execution time: 71_140_000 picoseconds.
+		Weight::from_parts(77_388_000, 30706)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+}
diff --git a/substrate/frame/core-fellowship/Cargo.toml b/substrate/frame/core-fellowship/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..981e71c651383aed2e1728783de3f4e78cb4624d
--- /dev/null
+++ b/substrate/frame/core-fellowship/Cargo.toml
@@ -0,0 +1,53 @@
+[package]
+name = "pallet-core-fellowship"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Logic as per the description of The Fellowship for core Polkadot technology"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.16", default-features = false }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/core-fellowship/README.md b/substrate/frame/core-fellowship/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3c9b1f63e08961e7f1a0634e04018ed6b0fc85b2
--- /dev/null
+++ b/substrate/frame/core-fellowship/README.md
@@ -0,0 +1,3 @@
+# Core Fellowship
+
+Logic specific to the core Polkadot Fellowship.
\ No newline at end of file
diff --git a/substrate/frame/core-fellowship/src/benchmarking.rs b/substrate/frame/core-fellowship/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ea0b5c6d4495f1968c2493b73641ca808278f89b
--- /dev/null
+++ b/substrate/frame/core-fellowship/src/benchmarking.rs
@@ -0,0 +1,216 @@
+// 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.
+
+//! Salary pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use crate::Pallet as CoreFellowship;
+
+use frame_benchmarking::v2::*;
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use sp_arithmetic::traits::Bounded;
+
+const SEED: u32 = 0;
+
+type BenchResult = Result<(), BenchmarkError>;
+
+#[instance_benchmarks]
+mod benchmarks {
+	use super::*;
+
+	fn ensure_evidence<T: Config<I>, I: 'static>(who: &T::AccountId) -> BenchResult {
+		let evidence = BoundedVec::try_from(vec![0; Evidence::<T, I>::bound()]).unwrap();
+		let wish = Wish::Retention;
+		let origin = RawOrigin::Signed(who.clone()).into();
+		CoreFellowship::<T, I>::submit_evidence(origin, wish, evidence)?;
+		assert!(MemberEvidence::<T, I>::contains_key(who));
+		Ok(())
+	}
+
+	fn make_member<T: Config<I>, I: 'static>(rank: u16) -> Result<T::AccountId, BenchmarkError> {
+		let member = account("member", 0, SEED);
+		T::Members::induct(&member)?;
+		for _ in 0..rank {
+			T::Members::promote(&member)?;
+		}
+		CoreFellowship::<T, I>::import(RawOrigin::Signed(member.clone()).into())?;
+		Ok(member)
+	}
+
+	#[benchmark]
+	fn set_params() -> Result<(), BenchmarkError> {
+		let params = ParamsType {
+			active_salary: [100u32.into(); 9],
+			passive_salary: [10u32.into(); 9],
+			demotion_period: [100u32.into(); 9],
+			min_promotion_period: [100u32.into(); 9],
+			offboard_timeout: 1u32.into(),
+		};
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, Box::new(params.clone()));
+
+		assert_eq!(Params::<T, I>::get(), params);
+		Ok(())
+	}
+
+	#[benchmark]
+	fn bump_offboard() -> Result<(), BenchmarkError> {
+		let member = make_member::<T, I>(0)?;
+
+		// Set it to the max value to ensure that any possible auto-demotion period has passed.
+		frame_system::Pallet::<T>::set_block_number(BlockNumberFor::<T>::max_value());
+		ensure_evidence::<T, I>(&member)?;
+		assert!(Member::<T, I>::contains_key(&member));
+
+		#[extrinsic_call]
+		CoreFellowship::<T, I>::bump(RawOrigin::Signed(member.clone()), member.clone());
+
+		assert!(!Member::<T, I>::contains_key(&member));
+		assert!(!MemberEvidence::<T, I>::contains_key(&member));
+		Ok(())
+	}
+
+	#[benchmark]
+	fn bump_demote() -> Result<(), BenchmarkError> {
+		let member = make_member::<T, I>(2)?;
+
+		// Set it to the max value to ensure that any possible auto-demotion period has passed.
+		frame_system::Pallet::<T>::set_block_number(BlockNumberFor::<T>::max_value());
+		ensure_evidence::<T, I>(&member)?;
+		assert!(Member::<T, I>::contains_key(&member));
+		assert_eq!(T::Members::rank_of(&member), Some(2));
+
+		#[extrinsic_call]
+		CoreFellowship::<T, I>::bump(RawOrigin::Signed(member.clone()), member.clone());
+
+		assert!(Member::<T, I>::contains_key(&member));
+		assert_eq!(T::Members::rank_of(&member), Some(1));
+		assert!(!MemberEvidence::<T, I>::contains_key(&member));
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_active() -> Result<(), BenchmarkError> {
+		let member = make_member::<T, I>(1)?;
+		assert!(Member::<T, I>::get(&member).unwrap().is_active);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(member.clone()), false);
+
+		assert!(!Member::<T, I>::get(&member).unwrap().is_active);
+		Ok(())
+	}
+
+	#[benchmark]
+	fn induct() -> Result<(), BenchmarkError> {
+		let candidate: T::AccountId = account("candidate", 0, SEED);
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, candidate.clone());
+
+		assert_eq!(T::Members::rank_of(&candidate), Some(0));
+		assert!(Member::<T, I>::contains_key(&candidate));
+		Ok(())
+	}
+
+	#[benchmark]
+	fn promote() -> Result<(), BenchmarkError> {
+		let member = make_member::<T, I>(1)?;
+		ensure_evidence::<T, I>(&member)?;
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, member.clone(), 2u8.into());
+
+		assert_eq!(T::Members::rank_of(&member), Some(2));
+		assert!(!MemberEvidence::<T, I>::contains_key(&member));
+		Ok(())
+	}
+
+	#[benchmark]
+	fn offboard() -> Result<(), BenchmarkError> {
+		let member = make_member::<T, I>(0)?;
+		T::Members::demote(&member)?;
+		ensure_evidence::<T, I>(&member)?;
+
+		assert!(T::Members::rank_of(&member).is_none());
+		assert!(Member::<T, I>::contains_key(&member));
+		assert!(MemberEvidence::<T, I>::contains_key(&member));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(member.clone()), member.clone());
+
+		assert!(!Member::<T, I>::contains_key(&member));
+		assert!(!MemberEvidence::<T, I>::contains_key(&member));
+		Ok(())
+	}
+
+	#[benchmark]
+	fn import() -> Result<(), BenchmarkError> {
+		let member = account("member", 0, SEED);
+		T::Members::induct(&member)?;
+		T::Members::promote(&member)?;
+
+		assert!(!Member::<T, I>::contains_key(&member));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(member.clone()));
+
+		assert!(Member::<T, I>::contains_key(&member));
+		Ok(())
+	}
+
+	#[benchmark]
+	fn approve() -> Result<(), BenchmarkError> {
+		let member = make_member::<T, I>(1)?;
+		let then = frame_system::Pallet::<T>::block_number();
+		let now = then.saturating_plus_one();
+		frame_system::Pallet::<T>::set_block_number(now);
+		ensure_evidence::<T, I>(&member)?;
+
+		assert_eq!(Member::<T, I>::get(&member).unwrap().last_proof, then);
+
+		#[extrinsic_call]
+		_(RawOrigin::Root, member.clone(), 1u8.into());
+
+		assert_eq!(Member::<T, I>::get(&member).unwrap().last_proof, now);
+		assert!(!MemberEvidence::<T, I>::contains_key(&member));
+		Ok(())
+	}
+
+	#[benchmark]
+	fn submit_evidence() -> Result<(), BenchmarkError> {
+		let member = make_member::<T, I>(1)?;
+		let evidence = vec![0; Evidence::<T, I>::bound()].try_into().unwrap();
+
+		assert!(!MemberEvidence::<T, I>::contains_key(&member));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(member.clone()), Wish::Retention, evidence);
+
+		assert!(MemberEvidence::<T, I>::contains_key(&member));
+		Ok(())
+	}
+
+	impl_benchmark_test_suite! {
+		CoreFellowship,
+		crate::tests::new_test_ext(),
+		crate::tests::Test,
+	}
+}
diff --git a/substrate/frame/core-fellowship/src/lib.rs b/substrate/frame/core-fellowship/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ace614d2bddb9d1fec24bb24252ebe18e8f51dec
--- /dev/null
+++ b/substrate/frame/core-fellowship/src/lib.rs
@@ -0,0 +1,601 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Additional logic for the Core Fellowship. This determines salary, registers activity/passivity
+//! and handles promotion and demotion periods.
+//!
+//! This only handles members of non-zero rank.
+//!
+//! # Process Flow
+//! - Begin with a call to `induct`, where some privileged origin (perhaps a pre-existing member of
+//!   `rank > 1`) is able to make a candidate from an account and introduce it to be tracked in this
+//!   pallet in order to allow evidence to be submitted and promotion voted on.
+//! - The candidate then calls `submit_evidence` to apply for their promotion to rank 1.
+//! - A `PromoteOrigin` of at least rank 1 calls `promote` on the candidate to elevate it to rank 1.
+//! - Some time later but before rank 1's `demotion_period` elapses, candidate calls
+//!   `submit_evidence` with evidence of their efforts to apply for approval to stay at rank 1.
+//! - An `ApproveOrigin` of at least rank 1 calls `approve` on the candidate to avoid imminent
+//!   demotion and keep it at rank 1.
+//! - These last two steps continue until the candidate is ready to apply for a promotion, at which
+//!   point the previous two steps are repeated with a higher rank.
+//! - If the member fails to get an approval within the `demotion_period` then anyone may call
+//!   `bump` to demote the candidate by one rank.
+//! - If a candidate fails to be promoted to a member within the `offboard_timeout` period, then
+//!   anyone may call `bump` to remove the account's candidacy.
+//! - Pre-existing members may call `import` to have their rank recognised and be inducted into this
+//!   pallet (to gain a salary and allow for eventual promotion).
+//! - If, externally to this pallet, a member or candidate has their rank removed completely, then
+//!   `offboard` may be called to remove them entirely from this pallet.
+//!
+//! Note there is a difference between having a rank of 0 (whereby the account is a *candidate*) and
+//! having no rank at all (whereby we consider it *unranked*). An account can be demoted from rank
+//! 0 to become unranked. This process is called being offboarded and there is an extrinsic to do
+//! this explicitly when external factors to this pallet have caused the tracked account to become
+//! unranked. At rank 0, there is not a "demotion" period after which the account may be bumped to
+//! become offboarded but rather an "offboard timeout".
+//!
+//! Candidates may be introduced (i.e. an account to go from unranked to rank of 0) by an origin
+//! of a different privilege to that for promotion. This allows the possibility for even a single
+//! existing member to introduce a new candidate without payment.
+//!
+//! Only tracked/ranked accounts may submit evidence for their proof and promotion. Candidates
+//! cannot be approved - they must proceed only to promotion prior to the offboard timeout elapsing.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![recursion_limit = "128"]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_arithmetic::traits::{Saturating, Zero};
+use sp_runtime::RuntimeDebug;
+use sp_std::{marker::PhantomData, prelude::*};
+
+use frame_support::{
+	dispatch::DispatchResultWithPostInfo,
+	ensure, impl_ensure_origin_with_arg_ignoring_arg,
+	traits::{
+		tokens::Balance as BalanceTrait, EnsureOrigin, EnsureOriginWithArg, Get, RankedMembers,
+	},
+	BoundedVec,
+};
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod weights;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// The desired outcome for which evidence is presented.
+#[derive(Encode, Decode, Eq, PartialEq, Copy, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub enum Wish {
+	/// Member wishes only to retain their current rank.
+	Retention,
+	/// Member wishes to be promoted.
+	Promotion,
+}
+
+/// A piece of evidence to underpin a [Wish].
+///
+/// From the pallet's perspective, this is just a blob of data without meaning. The fellows can
+/// decide how to concretely utilise it. This could be an IPFS hash, a URL or structured data.
+pub type Evidence<T, I> = BoundedVec<u8, <T as Config<I>>::EvidenceSize>;
+
+/// The status of the pallet instance.
+#[derive(Encode, Decode, Eq, PartialEq, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub struct ParamsType<Balance, BlockNumber, const RANKS: usize> {
+	/// The amounts to be paid when a member of a given rank (-1) is active.
+	active_salary: [Balance; RANKS],
+	/// The amounts to be paid when a member of a given rank (-1) is passive.
+	passive_salary: [Balance; RANKS],
+	/// The period between which unproven members become demoted.
+	demotion_period: [BlockNumber; RANKS],
+	/// The period between which members must wait before they may proceed to this rank.
+	min_promotion_period: [BlockNumber; RANKS],
+	/// Amount by which an account can remain at rank 0 (candidate before being offboard entirely).
+	offboard_timeout: BlockNumber,
+}
+
+impl<Balance: Default + Copy, BlockNumber: Default + Copy, const RANKS: usize> Default
+	for ParamsType<Balance, BlockNumber, RANKS>
+{
+	fn default() -> Self {
+		Self {
+			active_salary: [Balance::default(); RANKS],
+			passive_salary: [Balance::default(); RANKS],
+			demotion_period: [BlockNumber::default(); RANKS],
+			min_promotion_period: [BlockNumber::default(); RANKS],
+			offboard_timeout: BlockNumber::default(),
+		}
+	}
+}
+
+/// The status of a single member.
+#[derive(Encode, Decode, Eq, PartialEq, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub struct MemberStatus<BlockNumber> {
+	/// Are they currently active?
+	is_active: bool,
+	/// The block number at which we last promoted them.
+	last_promotion: BlockNumber,
+	/// The last time a member was demoted, promoted or proved their rank.
+	last_proof: BlockNumber,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{
+		dispatch::Pays,
+		pallet_prelude::*,
+		traits::{tokens::GetSalary, EnsureOrigin},
+	};
+	use frame_system::{ensure_root, pallet_prelude::*};
+
+	const RANK_COUNT: usize = 9;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The runtime event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The current membership of the fellowship.
+		type Members: RankedMembers<
+			AccountId = <Self as frame_system::Config>::AccountId,
+			Rank = u16,
+		>;
+
+		/// The type in which salaries/budgets are measured.
+		type Balance: BalanceTrait;
+
+		/// The origin which has permission update the parameters.
+		type ParamsOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin which has permission to move a candidate into being tracked in this pallet.
+		/// Generally a very low-permission, such as a pre-existing member of rank 1 or above.
+		///
+		/// This allows the candidate to deposit evidence for their request to be promoted to a
+		/// member.
+		type InductOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin which has permission to issue a proof that a member may retain their rank.
+		/// The `Success` value is the maximum rank of members it is able to prove.
+		type ApproveOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = RankOf<Self, I>>;
+
+		/// The origin which has permission to promote a member. The `Success` value is the maximum
+		/// rank to which it can promote.
+		type PromoteOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = RankOf<Self, I>>;
+
+		/// The maximum size in bytes submitted evidence is allowed to be.
+		#[pallet::constant]
+		type EvidenceSize: Get<u32>;
+	}
+
+	pub type ParamsOf<T, I> = ParamsType<<T as Config<I>>::Balance, BlockNumberFor<T>, RANK_COUNT>;
+	pub type MemberStatusOf<T> = MemberStatus<BlockNumberFor<T>>;
+	pub type RankOf<T, I> = <<T as Config<I>>::Members as RankedMembers>::Rank;
+
+	/// The overall status of the system.
+	#[pallet::storage]
+	pub(super) type Params<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, ParamsOf<T, I>, ValueQuery>;
+
+	/// The status of a claimant.
+	#[pallet::storage]
+	pub(super) type Member<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, MemberStatusOf<T>, OptionQuery>;
+
+	/// Some evidence together with the desired outcome for which it was presented.
+	#[pallet::storage]
+	pub(super) type MemberEvidence<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, (Wish, Evidence<T, I>), OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// Parameters for the pallet have changed.
+		ParamsChanged { params: ParamsOf<T, I> },
+		/// Member activity flag has been set.
+		ActiveChanged { who: T::AccountId, is_active: bool },
+		/// Member has begun being tracked in this pallet.
+		Inducted { who: T::AccountId },
+		/// Member has been removed from being tracked in this pallet (i.e. because rank is now
+		/// zero).
+		Offboarded { who: T::AccountId },
+		/// Member has been promoted to the given rank.
+		Promoted { who: T::AccountId, to_rank: RankOf<T, I> },
+		/// Member has been demoted to the given (non-zero) rank.
+		Demoted { who: T::AccountId, to_rank: RankOf<T, I> },
+		/// Member has been proven at their current rank, postponing auto-demotion.
+		Proven { who: T::AccountId, at_rank: RankOf<T, I> },
+		/// Member has stated evidence of their efforts their request for rank.
+		Requested { who: T::AccountId, wish: Wish },
+		/// Some submitted evidence was judged and removed. There may or may not have been a change
+		/// to the rank, but in any case, `last_proof` is reset.
+		EvidenceJudged {
+			/// The member/candidate.
+			who: T::AccountId,
+			/// The desired outcome for which the evidence was presented.
+			wish: Wish,
+			/// The evidence of efforts.
+			evidence: Evidence<T, I>,
+			/// The old rank, prior to this change.
+			old_rank: u16,
+			/// New rank. If `None` then candidate record was removed entirely.
+			new_rank: Option<u16>,
+		},
+		/// Pre-ranked account has been inducted at their current rank.
+		Imported { who: T::AccountId, rank: RankOf<T, I> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Member's rank is too low.
+		Unranked,
+		/// Member's rank is not zero.
+		Ranked,
+		/// Member's rank is not as expected - generally means that the rank provided to the call
+		/// does not agree with the state of the system.
+		UnexpectedRank,
+		/// The given rank is invalid - this generally means it's not between 1 and `RANK_COUNT`.
+		InvalidRank,
+		/// The origin does not have enough permission to do this operation.
+		NoPermission,
+		/// No work needs to be done at present for this member.
+		NothingDoing,
+		/// The candidate has already been inducted. This should never happen since it would
+		/// require a candidate (rank 0) to already be tracked in the pallet.
+		AlreadyInducted,
+		/// The candidate has not been inducted, so cannot be offboarded from this pallet.
+		NotTracked,
+		/// Operation cannot be done yet since not enough time has passed.
+		TooSoon,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Bump the state of a member.
+		///
+		/// This will demote a member whose `last_proof` is now beyond their rank's
+		/// `demotion_period`.
+		///
+		/// - `origin`: A `Signed` origin of an account.
+		/// - `who`: A member account whose state is to be updated.
+		#[pallet::weight(T::WeightInfo::bump_offboard().max(T::WeightInfo::bump_demote()))]
+		#[pallet::call_index(0)]
+		pub fn bump(origin: OriginFor<T>, who: T::AccountId) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			let mut member = Member::<T, I>::get(&who).ok_or(Error::<T, I>::NotTracked)?;
+			let rank = T::Members::rank_of(&who).ok_or(Error::<T, I>::Unranked)?;
+
+			let params = Params::<T, I>::get();
+			let demotion_period = if rank == 0 {
+				params.offboard_timeout
+			} else {
+				let rank_index = Self::rank_to_index(rank).ok_or(Error::<T, I>::InvalidRank)?;
+				params.demotion_period[rank_index]
+			};
+			let demotion_block = member.last_proof.saturating_add(demotion_period);
+
+			// Ensure enough time has passed.
+			let now = frame_system::Pallet::<T>::block_number();
+			if now >= demotion_block {
+				T::Members::demote(&who)?;
+				let maybe_to_rank = T::Members::rank_of(&who);
+				Self::dispose_evidence(who.clone(), rank, maybe_to_rank);
+				let event = if let Some(to_rank) = maybe_to_rank {
+					member.last_proof = now;
+					Member::<T, I>::insert(&who, &member);
+					Event::<T, I>::Demoted { who, to_rank }
+				} else {
+					Member::<T, I>::remove(&who);
+					Event::<T, I>::Offboarded { who }
+				};
+				Self::deposit_event(event);
+				return Ok(Pays::No.into())
+			}
+
+			Err(Error::<T, I>::NothingDoing.into())
+		}
+
+		/// Set the parameters.
+		///
+		/// - `origin`: An origin complying with `ParamsOrigin` or root.
+		/// - `params`: The new parameters for the pallet.
+		#[pallet::weight(T::WeightInfo::set_params())]
+		#[pallet::call_index(1)]
+		pub fn set_params(origin: OriginFor<T>, params: Box<ParamsOf<T, I>>) -> DispatchResult {
+			T::ParamsOrigin::ensure_origin_or_root(origin)?;
+			Params::<T, I>::put(params.as_ref());
+			Self::deposit_event(Event::<T, I>::ParamsChanged { params: *params });
+			Ok(())
+		}
+
+		/// Set whether a member is active or not.
+		///
+		/// - `origin`: A `Signed` origin of a member's account.
+		/// - `is_active`: `true` iff the member is active.
+		#[pallet::weight(T::WeightInfo::set_active())]
+		#[pallet::call_index(2)]
+		pub fn set_active(origin: OriginFor<T>, is_active: bool) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			ensure!(
+				T::Members::rank_of(&who).map_or(false, |r| !r.is_zero()),
+				Error::<T, I>::Unranked
+			);
+			let mut member = Member::<T, I>::get(&who).ok_or(Error::<T, I>::NotTracked)?;
+			member.is_active = is_active;
+			Member::<T, I>::insert(&who, &member);
+			Self::deposit_event(Event::<T, I>::ActiveChanged { who, is_active });
+			Ok(())
+		}
+
+		/// Approve a member to continue at their rank.
+		///
+		/// This resets `last_proof` to the current block, thereby delaying any automatic demotion.
+		///
+		/// If `who` is not already tracked by this pallet, then it will become tracked.
+		/// `last_promotion` will be set to zero.
+		///
+		/// - `origin`: An origin which satisfies `ApproveOrigin` or root.
+		/// - `who`: A member (i.e. of non-zero rank).
+		/// - `at_rank`: The rank of member.
+		#[pallet::weight(T::WeightInfo::approve())]
+		#[pallet::call_index(3)]
+		pub fn approve(
+			origin: OriginFor<T>,
+			who: T::AccountId,
+			at_rank: RankOf<T, I>,
+		) -> DispatchResult {
+			match T::ApproveOrigin::try_origin(origin) {
+				Ok(allow_rank) => ensure!(allow_rank >= at_rank, Error::<T, I>::NoPermission),
+				Err(origin) => ensure_root(origin)?,
+			}
+			ensure!(at_rank > 0, Error::<T, I>::InvalidRank);
+			let rank = T::Members::rank_of(&who).ok_or(Error::<T, I>::Unranked)?;
+			ensure!(rank == at_rank, Error::<T, I>::UnexpectedRank);
+			let mut member = Member::<T, I>::get(&who).ok_or(Error::<T, I>::NotTracked)?;
+
+			member.last_proof = frame_system::Pallet::<T>::block_number();
+			Member::<T, I>::insert(&who, &member);
+
+			Self::dispose_evidence(who.clone(), at_rank, Some(at_rank));
+			Self::deposit_event(Event::<T, I>::Proven { who, at_rank });
+
+			Ok(())
+		}
+
+		/// Introduce a new and unranked candidate (rank zero).
+		///
+		/// - `origin`: An origin which satisfies `InductOrigin` or root.
+		/// - `who`: The account ID of the candidate to be inducted and become a member.
+		#[pallet::weight(T::WeightInfo::induct())]
+		#[pallet::call_index(4)]
+		pub fn induct(origin: OriginFor<T>, who: T::AccountId) -> DispatchResult {
+			match T::InductOrigin::try_origin(origin) {
+				Ok(_) => {},
+				Err(origin) => ensure_root(origin)?,
+			}
+			ensure!(!Member::<T, I>::contains_key(&who), Error::<T, I>::AlreadyInducted);
+			ensure!(T::Members::rank_of(&who).is_none(), Error::<T, I>::Ranked);
+
+			T::Members::induct(&who)?;
+			let now = frame_system::Pallet::<T>::block_number();
+			Member::<T, I>::insert(
+				&who,
+				MemberStatus { is_active: true, last_promotion: now, last_proof: now },
+			);
+			Self::deposit_event(Event::<T, I>::Inducted { who });
+			Ok(())
+		}
+
+		/// Increment the rank of a ranked and tracked account.
+		///
+		/// - `origin`: An origin which satisfies `PromoteOrigin` with a `Success` result of
+		///   `to_rank` or more or root.
+		/// - `who`: The account ID of the member to be promoted to `to_rank`.
+		/// - `to_rank`: One more than the current rank of `who`.
+		#[pallet::weight(T::WeightInfo::promote())]
+		#[pallet::call_index(5)]
+		pub fn promote(
+			origin: OriginFor<T>,
+			who: T::AccountId,
+			to_rank: RankOf<T, I>,
+		) -> DispatchResult {
+			match T::PromoteOrigin::try_origin(origin) {
+				Ok(allow_rank) => ensure!(allow_rank >= to_rank, Error::<T, I>::NoPermission),
+				Err(origin) => ensure_root(origin)?,
+			}
+			let rank = T::Members::rank_of(&who).ok_or(Error::<T, I>::Unranked)?;
+			ensure!(
+				rank.checked_add(1).map_or(false, |i| i == to_rank),
+				Error::<T, I>::UnexpectedRank
+			);
+
+			let mut member = Member::<T, I>::get(&who).ok_or(Error::<T, I>::NotTracked)?;
+			let now = frame_system::Pallet::<T>::block_number();
+
+			let params = Params::<T, I>::get();
+			let rank_index = Self::rank_to_index(to_rank).ok_or(Error::<T, I>::InvalidRank)?;
+			let min_period = params.min_promotion_period[rank_index];
+			// Ensure enough time has passed.
+			ensure!(
+				member.last_promotion.saturating_add(min_period) <= now,
+				Error::<T, I>::TooSoon,
+			);
+
+			T::Members::promote(&who)?;
+			member.last_promotion = now;
+			member.last_proof = now;
+			Member::<T, I>::insert(&who, &member);
+			Self::dispose_evidence(who.clone(), rank, Some(to_rank));
+
+			Self::deposit_event(Event::<T, I>::Promoted { who, to_rank });
+
+			Ok(())
+		}
+
+		/// Stop tracking a prior member who is now not a ranked member of the collective.
+		///
+		/// - `origin`: A `Signed` origin of an account.
+		/// - `who`: The ID of an account which was tracked in this pallet but which is now not a
+		///   ranked member of the collective.
+		#[pallet::weight(T::WeightInfo::offboard())]
+		#[pallet::call_index(6)]
+		pub fn offboard(origin: OriginFor<T>, who: T::AccountId) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			ensure!(T::Members::rank_of(&who).is_none(), Error::<T, I>::Ranked);
+			ensure!(Member::<T, I>::contains_key(&who), Error::<T, I>::NotTracked);
+			Member::<T, I>::remove(&who);
+			MemberEvidence::<T, I>::remove(&who);
+			Self::deposit_event(Event::<T, I>::Offboarded { who });
+			Ok(Pays::No.into())
+		}
+
+		/// Provide evidence that a rank is deserved.
+		///
+		/// This is free as long as no evidence for the forthcoming judgement is already submitted.
+		/// Evidence is cleared after an outcome (either demotion, promotion of approval).
+		///
+		/// - `origin`: A `Signed` origin of an inducted and ranked account.
+		/// - `wish`: The stated desire of the member.
+		/// - `evidence`: A dump of evidence to be considered. This should generally be either a
+		///   Markdown-encoded document or a series of 32-byte hashes which can be found on a
+		///   decentralised content-based-indexing system such as IPFS.
+		#[pallet::weight(T::WeightInfo::submit_evidence())]
+		#[pallet::call_index(7)]
+		pub fn submit_evidence(
+			origin: OriginFor<T>,
+			wish: Wish,
+			evidence: Evidence<T, I>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			ensure!(Member::<T, I>::contains_key(&who), Error::<T, I>::NotTracked);
+			let replaced = MemberEvidence::<T, I>::contains_key(&who);
+			MemberEvidence::<T, I>::insert(&who, (wish, evidence));
+			Self::deposit_event(Event::<T, I>::Requested { who, wish });
+			Ok(if replaced { Pays::Yes } else { Pays::No }.into())
+		}
+
+		/// Introduce an already-ranked individual of the collective into this pallet. The rank may
+		/// still be zero.
+		///
+		/// This resets `last_proof` to the current block and `last_promotion` will be set to zero,
+		/// thereby delaying any automatic demotion but allowing immediate promotion.
+		///
+		/// - `origin`: A signed origin of a ranked, but not tracked, account.
+		#[pallet::weight(T::WeightInfo::import())]
+		#[pallet::call_index(8)]
+		pub fn import(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			ensure!(!Member::<T, I>::contains_key(&who), Error::<T, I>::AlreadyInducted);
+			let rank = T::Members::rank_of(&who).ok_or(Error::<T, I>::Unranked)?;
+
+			let now = frame_system::Pallet::<T>::block_number();
+			Member::<T, I>::insert(
+				&who,
+				MemberStatus { is_active: true, last_promotion: 0u32.into(), last_proof: now },
+			);
+			Self::deposit_event(Event::<T, I>::Imported { who, rank });
+
+			Ok(Pays::No.into())
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// 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
+		/// in the range `1..=RANK_COUNT` is `None`.
+		pub(crate) fn rank_to_index(rank: RankOf<T, I>) -> Option<usize> {
+			match TryInto::<usize>::try_into(rank) {
+				Ok(r) if r <= RANK_COUNT && r > 0 => Some(r - 1),
+				_ => return None,
+			}
+		}
+
+		fn dispose_evidence(who: T::AccountId, old_rank: u16, new_rank: Option<u16>) {
+			if let Some((wish, evidence)) = MemberEvidence::<T, I>::take(&who) {
+				let e = Event::<T, I>::EvidenceJudged { who, wish, evidence, old_rank, new_rank };
+				Self::deposit_event(e);
+			}
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> GetSalary<RankOf<T, I>, T::AccountId, T::Balance> for Pallet<T, I> {
+		fn get_salary(rank: RankOf<T, I>, who: &T::AccountId) -> T::Balance {
+			let index = match Self::rank_to_index(rank) {
+				Some(i) => i,
+				None => return Zero::zero(),
+			};
+			let member = match Member::<T, I>::get(who) {
+				Some(m) => m,
+				None => return Zero::zero(),
+			};
+			let params = Params::<T, I>::get();
+			let salary =
+				if member.is_active { params.active_salary } else { params.passive_salary };
+			salary[index]
+		}
+	}
+}
+
+/// Guard to ensure that the given origin is inducted into this pallet with a given minimum rank.
+/// The account ID of the member is the `Success` value.
+pub struct EnsureInducted<T, I, const MIN_RANK: u16>(PhantomData<(T, I)>);
+impl<T: Config<I>, I: 'static, const MIN_RANK: u16> EnsureOrigin<T::RuntimeOrigin>
+	for EnsureInducted<T, I, MIN_RANK>
+{
+	type Success = T::AccountId;
+
+	fn try_origin(o: T::RuntimeOrigin) -> Result<Self::Success, T::RuntimeOrigin> {
+		let who = <frame_system::EnsureSigned<_> as EnsureOrigin<_>>::try_origin(o)?;
+		match T::Members::rank_of(&who) {
+			Some(rank) if rank >= MIN_RANK && Member::<T, I>::contains_key(&who) => Ok(who),
+			_ => Err(frame_system::RawOrigin::Signed(who).into()),
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<T::RuntimeOrigin, ()> {
+		let who = frame_benchmarking::account::<T::AccountId>("successful_origin", 0, 0);
+		if T::Members::rank_of(&who).is_none() {
+			T::Members::induct(&who).map_err(|_| ())?;
+		}
+		for _ in 0..MIN_RANK {
+			if T::Members::rank_of(&who).ok_or(())? < MIN_RANK {
+				T::Members::promote(&who).map_err(|_| ())?;
+			}
+		}
+		Ok(frame_system::RawOrigin::Signed(who).into())
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { T: Config<I>, I: 'static, const MIN_RANK: u16, A } >
+		EnsureOriginWithArg<T::RuntimeOrigin, A> for EnsureInducted<T, I, MIN_RANK>
+	{}
+}
diff --git a/substrate/frame/core-fellowship/src/tests.rs b/substrate/frame/core-fellowship/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c95699e66e41be802e3163d54f5bbe6ae376c4ec
--- /dev/null
+++ b/substrate/frame/core-fellowship/src/tests.rs
@@ -0,0 +1,356 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! The crate's tests.
+
+use std::collections::BTreeMap;
+
+use frame_support::{
+	assert_noop, assert_ok, ord_parameter_types,
+	pallet_prelude::Weight,
+	parameter_types,
+	traits::{tokens::GetSalary, ConstU32, ConstU64, Everything, IsInVec, TryMapSuccess},
+};
+use frame_system::EnsureSignedBy;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup, TryMorphInto},
+	BuildStorage, DispatchError, DispatchResult,
+};
+use sp_std::cell::RefCell;
+
+use super::*;
+use crate as pallet_core_fellowship;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		CoreFellowship: pallet_core_fellowship::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1_000_000, u64::max_value()));
+}
+impl frame_system::Config for Test {
+	type BaseCallFilter = 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>;
+}
+
+thread_local! {
+	pub static CLUB: RefCell<BTreeMap<u64, u16>> = RefCell::new(BTreeMap::new());
+}
+
+pub struct TestClub;
+impl RankedMembers for TestClub {
+	type AccountId = u64;
+	type Rank = u16;
+	fn min_rank() -> Self::Rank {
+		0
+	}
+	fn rank_of(who: &Self::AccountId) -> Option<Self::Rank> {
+		CLUB.with(|club| club.borrow().get(who).cloned())
+	}
+	fn induct(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| club.borrow_mut().insert(*who, 0));
+		Ok(())
+	}
+	fn promote(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| {
+			club.borrow_mut().entry(*who).and_modify(|r| *r += 1);
+		});
+		Ok(())
+	}
+	fn demote(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| match Self::rank_of(who) {
+			None => Err(sp_runtime::DispatchError::Unavailable),
+			Some(0) => {
+				club.borrow_mut().remove(&who);
+				Ok(())
+			},
+			Some(_) => {
+				club.borrow_mut().entry(*who).and_modify(|x| *x -= 1);
+				Ok(())
+			},
+		})
+	}
+}
+
+fn set_rank(who: u64, rank: u16) {
+	CLUB.with(|club| club.borrow_mut().insert(who, rank));
+}
+
+fn unrank(who: u64) {
+	CLUB.with(|club| club.borrow_mut().remove(&who));
+}
+
+parameter_types! {
+	pub ZeroToNine: Vec<u64> = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Members = TestClub;
+	type Balance = u64;
+	type ParamsOrigin = EnsureSignedBy<One, u64>;
+	type InductOrigin = EnsureInducted<Test, (), 1>;
+	type ApproveOrigin = TryMapSuccess<EnsureSignedBy<IsInVec<ZeroToNine>, u64>, TryMorphInto<u16>>;
+	type PromoteOrigin = TryMapSuccess<EnsureSignedBy<IsInVec<ZeroToNine>, u64>, TryMorphInto<u16>>;
+	type EvidenceSize = ConstU32<1024>;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| {
+		let params = ParamsType {
+			active_salary: [10, 20, 30, 40, 50, 60, 70, 80, 90],
+			passive_salary: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			demotion_period: [2, 4, 6, 8, 10, 12, 14, 16, 18],
+			min_promotion_period: [3, 6, 9, 12, 15, 18, 21, 24, 27],
+			offboard_timeout: 1,
+		};
+		assert_ok!(CoreFellowship::set_params(signed(1), Box::new(params)));
+		System::set_block_number(1);
+	});
+	ext
+}
+
+fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+}
+
+fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+fn signed(who: u64) -> RuntimeOrigin {
+	RuntimeOrigin::signed(who)
+}
+
+fn next_demotion(who: u64) -> u64 {
+	let member = Member::<Test>::get(who).unwrap();
+	let demotion_period = Params::<Test>::get().demotion_period;
+	member.last_proof + demotion_period[TestClub::rank_of(&who).unwrap() as usize - 1]
+}
+
+#[test]
+fn basic_stuff() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(CoreFellowship::rank_to_index(0), None);
+		assert_eq!(CoreFellowship::rank_to_index(1), Some(0));
+		assert_eq!(CoreFellowship::rank_to_index(9), Some(8));
+		assert_eq!(CoreFellowship::rank_to_index(10), None);
+		assert_eq!(CoreFellowship::get_salary(0, &1), 0);
+	});
+}
+
+#[test]
+fn set_params_works() {
+	new_test_ext().execute_with(|| {
+		let params = ParamsType {
+			active_salary: [10, 20, 30, 40, 50, 60, 70, 80, 90],
+			passive_salary: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			demotion_period: [1, 2, 3, 4, 5, 6, 7, 8, 9],
+			min_promotion_period: [1, 2, 3, 4, 5, 10, 15, 20, 30],
+			offboard_timeout: 1,
+		};
+		assert_noop!(
+			CoreFellowship::set_params(signed(2), Box::new(params.clone())),
+			DispatchError::BadOrigin
+		);
+		assert_ok!(CoreFellowship::set_params(signed(1), Box::new(params)));
+	});
+}
+
+#[test]
+fn induct_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(0, 0);
+		assert_ok!(CoreFellowship::import(signed(0)));
+		set_rank(1, 1);
+		assert_ok!(CoreFellowship::import(signed(1)));
+
+		assert_noop!(CoreFellowship::induct(signed(10), 10), DispatchError::BadOrigin);
+		assert_noop!(CoreFellowship::induct(signed(0), 10), DispatchError::BadOrigin);
+		assert_ok!(CoreFellowship::induct(signed(1), 10));
+		assert_noop!(CoreFellowship::induct(signed(1), 10), Error::<Test>::AlreadyInducted);
+	});
+}
+
+#[test]
+fn promote_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(CoreFellowship::import(signed(1)));
+		assert_noop!(CoreFellowship::promote(signed(1), 10, 1), Error::<Test>::Unranked);
+
+		assert_ok!(CoreFellowship::induct(signed(1), 10));
+		assert_noop!(CoreFellowship::promote(signed(10), 10, 1), DispatchError::BadOrigin);
+		assert_noop!(CoreFellowship::promote(signed(0), 10, 1), Error::<Test>::NoPermission);
+		assert_noop!(CoreFellowship::promote(signed(3), 10, 2), Error::<Test>::UnexpectedRank);
+		run_to(3);
+		assert_noop!(CoreFellowship::promote(signed(1), 10, 1), Error::<Test>::TooSoon);
+		run_to(4);
+		assert_ok!(CoreFellowship::promote(signed(1), 10, 1));
+		set_rank(11, 0);
+		assert_noop!(CoreFellowship::promote(signed(1), 11, 1), Error::<Test>::NotTracked);
+	});
+}
+
+#[test]
+fn sync_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_noop!(CoreFellowship::approve(signed(4), 10, 5), Error::<Test>::NoPermission);
+		assert_noop!(CoreFellowship::approve(signed(6), 10, 6), Error::<Test>::UnexpectedRank);
+		assert_ok!(CoreFellowship::import(signed(10)));
+		assert!(Member::<Test>::contains_key(10));
+		assert_eq!(next_demotion(10), 11);
+	});
+}
+
+#[test]
+fn auto_demote_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(10);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+		run_to(11);
+		assert_ok!(CoreFellowship::bump(signed(0), 10));
+		assert_eq!(TestClub::rank_of(&10), Some(4));
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+		assert_eq!(next_demotion(10), 19);
+	});
+}
+
+#[test]
+fn auto_demote_offboard_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 1);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(3);
+		assert_ok!(CoreFellowship::bump(signed(0), 10));
+		assert_eq!(TestClub::rank_of(&10), Some(0));
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+		run_to(4);
+		assert_ok!(CoreFellowship::bump(signed(0), 10));
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NotTracked);
+	});
+}
+
+#[test]
+fn offboard_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::NotTracked);
+		set_rank(10, 0);
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::Ranked);
+
+		assert_ok!(CoreFellowship::import(signed(10)));
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::Ranked);
+
+		unrank(10);
+		assert_ok!(CoreFellowship::offboard(signed(0), 10));
+		assert_noop!(CoreFellowship::offboard(signed(0), 10), Error::<Test>::NotTracked);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NotTracked);
+	});
+}
+
+#[test]
+fn proof_postpones_auto_demote() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(11);
+		assert_ok!(CoreFellowship::approve(signed(5), 10, 5));
+		assert_eq!(next_demotion(10), 21);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+	});
+}
+
+#[test]
+fn promote_postpones_auto_demote() {
+	new_test_ext().execute_with(|| {
+		set_rank(10, 5);
+		assert_ok!(CoreFellowship::import(signed(10)));
+
+		run_to(19);
+		assert_ok!(CoreFellowship::promote(signed(6), 10, 6));
+		assert_eq!(next_demotion(10), 31);
+		assert_noop!(CoreFellowship::bump(signed(0), 10), Error::<Test>::NothingDoing);
+	});
+}
+
+#[test]
+fn get_salary_works() {
+	new_test_ext().execute_with(|| {
+		for i in 1..=9u64 {
+			set_rank(10 + i, i as u16);
+			assert_ok!(CoreFellowship::import(signed(10 + i)));
+			assert_eq!(CoreFellowship::get_salary(i as u16, &(10 + i)), i * 10);
+		}
+	});
+}
+
+#[test]
+fn active_changing_get_salary_works() {
+	new_test_ext().execute_with(|| {
+		for i in 1..=9u64 {
+			set_rank(10 + i, i as u16);
+			assert_ok!(CoreFellowship::import(signed(10 + i)));
+			assert_ok!(CoreFellowship::set_active(signed(10 + i), false));
+			assert_eq!(CoreFellowship::get_salary(i as u16, &(10 + i)), i);
+			assert_ok!(CoreFellowship::set_active(signed(10 + i), true));
+			assert_eq!(CoreFellowship::get_salary(i as u16, &(10 + i)), i * 10);
+		}
+	});
+}
diff --git a/substrate/frame/core-fellowship/src/weights.rs b/substrate/frame/core-fellowship/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8bbfd1a4dd81da2146994f668d722f1e8afa27b6
--- /dev/null
+++ b/substrate/frame/core-fellowship/src/weights.rs
@@ -0,0 +1,400 @@
+// 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.
+
+//! Autogenerated weights for pallet_core_fellowship
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_core_fellowship
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/core-fellowship/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_core_fellowship.
+pub trait WeightInfo {
+	fn set_params() -> Weight;
+	fn bump_offboard() -> Weight;
+	fn bump_demote() -> Weight;
+	fn set_active() -> Weight;
+	fn induct() -> Weight;
+	fn promote() -> Weight;
+	fn offboard() -> Weight;
+	fn import() -> Weight;
+	fn approve() -> Weight;
+	fn submit_evidence() -> Weight;
+}
+
+/// Weights for pallet_core_fellowship using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: CoreFellowship Params (r:0 w:1)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	fn set_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)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Params (r:1 w:0)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:1 w:0)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn bump_offboard() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16887`
+		//  Estimated: `19894`
+		// Minimum execution time: 58_489_000 picoseconds.
+		Weight::from_parts(60_202_000, 19894)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(4_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)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Params (r:1 w:0)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:1 w:0)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn bump_demote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16997`
+		//  Estimated: `19894`
+		// Minimum execution time: 60_605_000 picoseconds.
+		Weight::from_parts(63_957_000, 19894)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn set_active() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3514`
+		// Minimum execution time: 17_816_000 picoseconds.
+		Weight::from_parts(18_524_000, 3514)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.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)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	fn induct() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `146`
+		//  Estimated: `3514`
+		// Minimum execution time: 27_249_000 picoseconds.
+		Weight::from_parts(28_049_000, 3514)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Params (r:1 w:0)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	fn promote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16865`
+		//  Estimated: `19894`
+		// Minimum execution time: 56_642_000 picoseconds.
+		Weight::from_parts(59_353_000, 19894)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:0 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn offboard() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `359`
+		//  Estimated: `3514`
+		// Minimum execution time: 17_459_000 picoseconds.
+		Weight::from_parts(18_033_000, 3514)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_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:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	fn import() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `313`
+		//  Estimated: `3514`
+		// Minimum execution time: 16_728_000 picoseconds.
+		Weight::from_parts(17_263_000, 3514)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn approve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16843`
+		//  Estimated: `19894`
+		// Minimum execution time: 41_487_000 picoseconds.
+		Weight::from_parts(43_459_000, 19894)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: CoreFellowship Member (r:1 w:0)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn submit_evidence() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `79`
+		//  Estimated: `19894`
+		// Minimum execution time: 26_033_000 picoseconds.
+		Weight::from_parts(26_612_000, 19894)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: CoreFellowship Params (r:0 w:1)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	fn set_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)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Params (r:1 w:0)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:1 w:0)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn bump_offboard() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16887`
+		//  Estimated: `19894`
+		// Minimum execution time: 58_489_000 picoseconds.
+		Weight::from_parts(60_202_000, 19894)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_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)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Params (r:1 w:0)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:1 w:0)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn bump_demote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16997`
+		//  Estimated: `19894`
+		// Minimum execution time: 60_605_000 picoseconds.
+		Weight::from_parts(63_957_000, 19894)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn set_active() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3514`
+		// Minimum execution time: 17_816_000 picoseconds.
+		Weight::from_parts(18_524_000, 3514)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.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)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	fn induct() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `146`
+		//  Estimated: `3514`
+		// Minimum execution time: 27_249_000 picoseconds.
+		Weight::from_parts(28_049_000, 3514)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Params (r:1 w:0)
+	/// Proof: CoreFellowship Params (max_values: Some(1), max_size: Some(364), added: 859, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	fn promote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16865`
+		//  Estimated: `19894`
+		// Minimum execution time: 56_642_000 picoseconds.
+		Weight::from_parts(59_353_000, 19894)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:0 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn offboard() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `359`
+		//  Estimated: `3514`
+		// Minimum execution time: 17_459_000 picoseconds.
+		Weight::from_parts(18_033_000, 3514)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_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:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	fn import() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `313`
+		//  Estimated: `3514`
+		// Minimum execution time: 16_728_000 picoseconds.
+		Weight::from_parts(17_263_000, 3514)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship Member (r:1 w:1)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn approve() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `16843`
+		//  Estimated: `19894`
+		// Minimum execution time: 41_487_000 picoseconds.
+		Weight::from_parts(43_459_000, 19894)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: CoreFellowship Member (r:1 w:0)
+	/// Proof: CoreFellowship Member (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: CoreFellowship MemberEvidence (r:1 w:1)
+	/// Proof: CoreFellowship MemberEvidence (max_values: None, max_size: Some(16429), added: 18904, mode: MaxEncodedLen)
+	fn submit_evidence() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `79`
+		//  Estimated: `19894`
+		// Minimum execution time: 26_033_000 picoseconds.
+		Weight::from_parts(26_612_000, 19894)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/democracy/Cargo.toml b/substrate/frame/democracy/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..71e52ed73be00820b1b9bf06d7f69d17e0a71455
--- /dev/null
+++ b/substrate/frame/democracy/Cargo.toml
@@ -0,0 +1,68 @@
+[package]
+name = "pallet-democracy"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for democracy"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive"], optional = true }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-scheduler = { version = "4.0.0-dev", path = "../scheduler" }
+pallet-preimage = { version = "4.0.0-dev", path = "../preimage" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-preimage/std",
+	"pallet-scheduler/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-preimage/runtime-benchmarks",
+	"pallet-scheduler/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-preimage/try-runtime",
+	"pallet-scheduler/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/democracy/README.md b/substrate/frame/democracy/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..bbc5f1c65586ae7054e24df183ad12c6ac6357f5
--- /dev/null
+++ b/substrate/frame/democracy/README.md
@@ -0,0 +1,135 @@
+# Democracy Pallet
+
+- [`democracy::Config`](https://docs.rs/pallet-democracy/latest/pallet_democracy/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-democracy/latest/pallet_democracy/enum.Call.html)
+
+## Overview
+
+The Democracy pallet handles the administration of general stakeholder voting.
+
+There are two different queues that a proposal can be added to before it
+becomes a referendum, 1) the proposal queue consisting of all public proposals
+and 2) the external queue consisting of a single proposal that originates
+from one of the _external_ origins (such as a collective group).
+
+Every launch period - a length defined in the runtime - the Democracy pallet
+launches a referendum from a proposal that it takes from either the proposal
+queue or the external queue in turn. Any token holder in the system can vote
+on referenda. The voting system
+uses time-lock voting by allowing the token holder to set their _conviction_
+behind a vote. The conviction will dictate the length of time the tokens
+will be locked, as well as the multiplier that scales the vote power.
+
+### Terminology
+
+- **Enactment Period:** The minimum period of locking and the period between a proposal being
+approved and enacted.
+- **Lock Period:** A period of time after proposal enactment that the tokens of _winning_ voters
+will be locked.
+- **Conviction:** An indication of a voter's strength of belief in their vote. An increase
+of one in conviction indicates that a token holder is willing to lock their tokens for twice
+as many lock periods after enactment.
+- **Vote:** A value that can either be in approval ("Aye") or rejection ("Nay")
+  of a particular referendum.
+- **Proposal:** A submission to the chain that represents an action that a proposer (either an
+account or an external origin) suggests that the system adopt.
+- **Referendum:** A proposal that is in the process of being voted on for
+  either acceptance or rejection as a change to the system.
+- **Delegation:** The act of granting your voting power to the decisions of another account for
+  up to a certain conviction.
+
+### Adaptive Quorum Biasing
+
+A _referendum_ can be either simple majority-carries in which 50%+1 of the
+votes decide the outcome or _adaptive quorum biased_. Adaptive quorum biasing
+makes the threshold for passing or rejecting a referendum higher or lower
+depending on how the referendum was originally proposed. There are two types of
+adaptive quorum biasing: 1) _positive turnout bias_ makes a referendum
+require a super-majority to pass that decreases as turnout increases and
+2) _negative turnout bias_ makes a referendum require a super-majority to
+reject that decreases as turnout increases. Another way to think about the
+quorum biasing is that _positive bias_ referendums will be rejected by
+default and _negative bias_ referendums get passed by default.
+
+## Interface
+
+### Dispatchable Functions
+
+#### Public
+
+These calls can be made from any externally held account capable of creating
+a signed extrinsic.
+
+Basic actions:
+- `propose` - Submits a sensitive action, represented as a hash. Requires a deposit.
+- `second` - Signals agreement with a proposal, moves it higher on the proposal queue, and
+  requires a matching deposit to the original.
+- `vote` - Votes in a referendum, either the vote is "Aye" to enact the proposal or "Nay" to
+  keep the status quo.
+- `unvote` - Cancel a previous vote, this must be done by the voter before the vote ends.
+- `delegate` - Delegates the voting power (tokens * conviction) to another account.
+- `undelegate` - Stops the delegation of voting power to another account.
+
+Administration actions that can be done to any account:
+- `reap_vote` - Remove some account's expired votes.
+- `unlock` - Redetermine the account's balance lock, potentially making tokens available.
+
+Preimage actions:
+- `note_preimage` - Registers the preimage for an upcoming proposal, requires
+  a deposit that is returned once the proposal is enacted.
+- `note_preimage_operational` - same but provided by `T::OperationalPreimageOrigin`.
+- `note_imminent_preimage` - Registers the preimage for an upcoming proposal.
+  Does not require a deposit, but the proposal must be in the dispatch queue.
+- `note_imminent_preimage_operational` - same but provided by `T::OperationalPreimageOrigin`.
+- `reap_preimage` - Removes the preimage for an expired proposal. Will only
+  work under the condition that it's the same account that noted it and
+  after the voting period, OR it's a different account after the enactment period.
+
+#### Cancellation Origin
+
+This call can only be made by the `CancellationOrigin`.
+
+- `emergency_cancel` - Schedules an emergency cancellation of a referendum.
+  Can only happen once to a specific referendum.
+
+#### ExternalOrigin
+
+This call can only be made by the `ExternalOrigin`.
+
+- `external_propose` - Schedules a proposal to become a referendum once it is is legal
+  for an externally proposed referendum.
+
+#### External Majority Origin
+
+This call can only be made by the `ExternalMajorityOrigin`.
+
+- `external_propose_majority` - Schedules a proposal to become a majority-carries
+	 referendum once it is legal for an externally proposed referendum.
+
+#### External Default Origin
+
+This call can only be made by the `ExternalDefaultOrigin`.
+
+- `external_propose_default` - Schedules a proposal to become a negative-turnout-bias
+  referendum once it is legal for an externally proposed referendum.
+
+#### Fast Track Origin
+
+This call can only be made by the `FastTrackOrigin`.
+
+- `fast_track` - Schedules the current externally proposed proposal that
+  is "majority-carries" to become a referendum immediately.
+
+#### Veto Origin
+
+This call can only be made by the `VetoOrigin`.
+
+- `veto_external` - Vetoes and blacklists the external proposal hash.
+
+#### Root
+
+- `cancel_referendum` - Removes a referendum.
+- `cancel_queued` - Cancels a proposal that is queued for enactment.
+- `clear_public_proposal` - Removes all public proposals.
+
+License: Apache-2.0
diff --git a/substrate/frame/democracy/src/benchmarking.rs b/substrate/frame/democracy/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e4a21a4e1d9b8a1a82c7b45f96bba22264383ed5
--- /dev/null
+++ b/substrate/frame/democracy/src/benchmarking.rs
@@ -0,0 +1,855 @@
+// 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.
+
+//! Democracy pallet benchmarking.
+
+use super::*;
+
+use frame_benchmarking::v1::{account, benchmarks, whitelist_account, BenchmarkError};
+use frame_support::{
+	assert_noop, assert_ok,
+	traits::{Currency, EnsureOrigin, Get, OnInitialize, UnfilteredDispatchable},
+};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use sp_core::H256;
+use sp_runtime::{traits::Bounded, BoundedVec};
+
+use crate::Pallet as Democracy;
+
+const REFERENDUM_COUNT_HINT: u32 = 10;
+const SEED: u32 = 0;
+
+fn funded_account<T: Config>(name: &'static str, index: u32) -> T::AccountId {
+	let caller: T::AccountId = account(name, index, SEED);
+	// Give the account half of the maximum value of the `Balance` type.
+	// Otherwise some transfers will fail with an overflow error.
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
+	caller
+}
+
+fn make_proposal<T: Config>(n: u32) -> BoundedCallOf<T> {
+	let call: CallOf<T> = frame_system::Call::remark { remark: n.encode() }.into();
+	<T as Config>::Preimages::bound(call).unwrap()
+}
+
+fn add_proposal<T: Config>(n: u32) -> Result<H256, &'static str> {
+	let other = funded_account::<T>("proposer", n);
+	let value = T::MinimumDeposit::get();
+	let proposal = make_proposal::<T>(n);
+	Democracy::<T>::propose(RawOrigin::Signed(other).into(), proposal.clone(), value)?;
+	Ok(proposal.hash())
+}
+
+// add a referendum with a metadata.
+fn add_referendum<T: Config>(n: u32) -> (ReferendumIndex, H256, PreimageHash) {
+	let vote_threshold = VoteThreshold::SimpleMajority;
+	let proposal = make_proposal::<T>(n);
+	let hash = proposal.hash();
+	let index = Democracy::<T>::inject_referendum(
+		T::LaunchPeriod::get(),
+		proposal,
+		vote_threshold,
+		0u32.into(),
+	);
+	let preimage_hash = note_preimage::<T>();
+	MetadataOf::<T>::insert(crate::MetadataOwner::Referendum(index), preimage_hash.clone());
+	(index, hash, preimage_hash)
+}
+
+fn account_vote<T: Config>(b: BalanceOf<T>) -> AccountVote<BalanceOf<T>> {
+	let v = Vote { aye: true, conviction: Conviction::Locked1x };
+
+	AccountVote::Standard { vote: v, balance: b }
+}
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn assert_has_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_has_event(generic_event.into());
+}
+
+// note a new preimage.
+fn note_preimage<T: Config>() -> PreimageHash {
+	use core::sync::atomic::{AtomicU8, Ordering};
+	use sp_std::borrow::Cow;
+	// note a new preimage on every function invoke.
+	static COUNTER: AtomicU8 = AtomicU8::new(0);
+	let data = Cow::from(vec![COUNTER.fetch_add(1, Ordering::Relaxed)]);
+	let hash = <T as Config>::Preimages::note(data).unwrap();
+	hash
+}
+
+benchmarks! {
+	propose {
+		let p = T::MaxProposals::get();
+
+		for i in 0 .. (p - 1) {
+			add_proposal::<T>(i)?;
+		}
+
+		let caller = funded_account::<T>("caller", 0);
+		let proposal = make_proposal::<T>(0);
+		let value = T::MinimumDeposit::get();
+		whitelist_account!(caller);
+	}: _(RawOrigin::Signed(caller), proposal, value)
+	verify {
+		assert_eq!(Democracy::<T>::public_props().len(), p as usize, "Proposals not created.");
+	}
+
+	second {
+		let caller = funded_account::<T>("caller", 0);
+		add_proposal::<T>(0)?;
+
+		// Create s existing "seconds"
+		// we must reserve one deposit for the `proposal` and one for our benchmarked `second` call.
+		for i in 0 .. T::MaxDeposits::get() - 2 {
+			let seconder = funded_account::<T>("seconder", i);
+			Democracy::<T>::second(RawOrigin::Signed(seconder).into(), 0)?;
+		}
+
+		let deposits = Democracy::<T>::deposit_of(0).ok_or("Proposal not created")?;
+		assert_eq!(deposits.0.len(), (T::MaxDeposits::get() - 1) as usize, "Seconds not recorded");
+		whitelist_account!(caller);
+	}: _(RawOrigin::Signed(caller), 0)
+	verify {
+		let deposits = Democracy::<T>::deposit_of(0).ok_or("Proposal not created")?;
+		assert_eq!(deposits.0.len(), (T::MaxDeposits::get()) as usize, "`second` benchmark did not work");
+	}
+
+	vote_new {
+		let caller = funded_account::<T>("caller", 0);
+		let account_vote = account_vote::<T>(100u32.into());
+
+		// We need to create existing direct votes
+		for i in 0 .. T::MaxVotes::get() - 1 {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(RawOrigin::Signed(caller.clone()).into(), ref_index, account_vote)?;
+		}
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), (T::MaxVotes::get() - 1) as usize, "Votes were not recorded.");
+
+		let ref_index = add_referendum::<T>(T::MaxVotes::get() - 1).0;
+		whitelist_account!(caller);
+	}: vote(RawOrigin::Signed(caller.clone()), ref_index, account_vote)
+	verify {
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), T::MaxVotes::get() as usize, "Vote was not recorded.");
+	}
+
+	vote_existing {
+		let caller = funded_account::<T>("caller", 0);
+		let account_vote = account_vote::<T>(100u32.into());
+
+		// We need to create existing direct votes
+		for i in 0..T::MaxVotes::get() {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(RawOrigin::Signed(caller.clone()).into(), ref_index, account_vote)?;
+		}
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), T::MaxVotes::get() as usize, "Votes were not recorded.");
+
+		// Change vote from aye to nay
+		let nay = Vote { aye: false, conviction: Conviction::Locked1x };
+		let new_vote = AccountVote::Standard { vote: nay, balance: 1000u32.into() };
+		let ref_index = Democracy::<T>::referendum_count() - 1;
+
+		// This tests when a user changes a vote
+		whitelist_account!(caller);
+	}: vote(RawOrigin::Signed(caller.clone()), ref_index, new_vote)
+	verify {
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), T::MaxVotes::get() as usize, "Vote was incorrectly added");
+		let referendum_info = Democracy::<T>::referendum_info(ref_index)
+			.ok_or("referendum doesn't exist")?;
+		let tally =  match referendum_info {
+			ReferendumInfo::Ongoing(r) => r.tally,
+			_ => return Err("referendum not ongoing".into()),
+		};
+		assert_eq!(tally.nays, 1000u32.into(), "changed vote was not recorded");
+	}
+
+	emergency_cancel {
+		let origin =
+			T::CancellationOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let (ref_index, _, preimage_hash) = add_referendum::<T>(0);
+		assert_ok!(Democracy::<T>::referendum_status(ref_index));
+	}: _<T::RuntimeOrigin>(origin, ref_index)
+	verify {
+		// Referendum has been canceled
+		assert_noop!(
+			Democracy::<T>::referendum_status(ref_index),
+			Error::<T>::ReferendumInvalid,
+		);
+		assert_last_event::<T>(crate::Event::MetadataCleared {
+			owner: MetadataOwner::Referendum(ref_index),
+			hash: preimage_hash,
+		}.into());
+	}
+
+	blacklist {
+		// Place our proposal at the end to make sure it's worst case.
+		for i in 0 .. T::MaxProposals::get() - 1 {
+			add_proposal::<T>(i)?;
+		}
+		// We should really add a lot of seconds here, but we're not doing it elsewhere.
+
+		// Add a referendum of our proposal.
+		let (ref_index, hash, preimage_hash) = add_referendum::<T>(0);
+		assert_ok!(Democracy::<T>::referendum_status(ref_index));
+		// Place our proposal in the external queue, too.
+		assert_ok!(Democracy::<T>::external_propose(
+			T::ExternalOrigin::try_successful_origin()
+				.expect("ExternalOrigin has no successful origin required for the benchmark"),
+			make_proposal::<T>(0)
+		));
+		let origin =
+			T::BlacklistOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: _<T::RuntimeOrigin>(origin, hash, Some(ref_index))
+	verify {
+		// Referendum has been canceled
+		assert_noop!(
+			Democracy::<T>::referendum_status(ref_index),
+			Error::<T>::ReferendumInvalid
+		);
+		assert_has_event::<T>(crate::Event::MetadataCleared {
+			owner: MetadataOwner::Referendum(ref_index),
+			hash: preimage_hash,
+		}.into());
+	}
+
+	// Worst case scenario, we external propose a previously blacklisted proposal
+	external_propose {
+		let origin =
+			T::ExternalOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let proposal = make_proposal::<T>(0);
+		// Add proposal to blacklist with block number 0
+
+		let addresses: BoundedVec<_, _> = (0..(T::MaxBlacklisted::get() - 1))
+			.into_iter()
+			.map(|i| account::<T::AccountId>("blacklist", i, SEED))
+			.collect::<Vec<_>>()
+			.try_into()
+			.unwrap();
+		Blacklist::<T>::insert(proposal.hash(), (BlockNumberFor::<T>::zero(), addresses));
+	}: _<T::RuntimeOrigin>(origin, proposal)
+	verify {
+		// External proposal created
+		ensure!(<NextExternal<T>>::exists(), "External proposal didn't work");
+	}
+
+	external_propose_majority {
+		let origin = T::ExternalMajorityOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let proposal = make_proposal::<T>(0);
+	}: _<T::RuntimeOrigin>(origin, proposal)
+	verify {
+		// External proposal created
+		ensure!(<NextExternal<T>>::exists(), "External proposal didn't work");
+	}
+
+	external_propose_default {
+		let origin = T::ExternalDefaultOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let proposal = make_proposal::<T>(0);
+	}: _<T::RuntimeOrigin>(origin, proposal)
+	verify {
+		// External proposal created
+		ensure!(<NextExternal<T>>::exists(), "External proposal didn't work");
+	}
+
+	fast_track {
+		let origin_propose = T::ExternalDefaultOrigin::try_successful_origin()
+			.expect("ExternalDefaultOrigin has no successful origin required for the benchmark");
+		let proposal = make_proposal::<T>(0);
+		let proposal_hash = proposal.hash();
+		Democracy::<T>::external_propose_default(origin_propose.clone(), proposal)?;
+		// Set metadata to the external proposal.
+		let preimage_hash = note_preimage::<T>();
+		assert_ok!(Democracy::<T>::set_metadata(
+			origin_propose,
+			MetadataOwner::External,
+			Some(preimage_hash)));
+		// NOTE: Instant origin may invoke a little bit more logic, but may not always succeed.
+		let origin_fast_track =
+			T::FastTrackOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let voting_period = T::FastTrackVotingPeriod::get();
+		let delay = 0u32;
+	}: _<T::RuntimeOrigin>(origin_fast_track, proposal_hash, voting_period, delay.into())
+	verify {
+		assert_eq!(Democracy::<T>::referendum_count(), 1, "referendum not created");
+		assert_last_event::<T>(crate::Event::MetadataTransferred {
+			prev_owner: MetadataOwner::External,
+			owner: MetadataOwner::Referendum(0),
+			hash: preimage_hash,
+		}.into());
+	}
+
+	veto_external {
+		let proposal = make_proposal::<T>(0);
+		let proposal_hash = proposal.hash();
+
+		let origin_propose = T::ExternalDefaultOrigin::try_successful_origin()
+			.expect("ExternalDefaultOrigin has no successful origin required for the benchmark");
+		Democracy::<T>::external_propose_default(origin_propose.clone(), proposal)?;
+
+		let preimage_hash = note_preimage::<T>();
+		assert_ok!(Democracy::<T>::set_metadata(
+			origin_propose,
+			MetadataOwner::External,
+			Some(preimage_hash))
+		);
+
+		let mut vetoers: BoundedVec<T::AccountId, _> = Default::default();
+		for i in 0 .. (T::MaxBlacklisted::get() - 1) {
+			vetoers.try_push(account::<T::AccountId>("vetoer", i, SEED)).unwrap();
+		}
+		vetoers.sort();
+		Blacklist::<T>::insert(proposal_hash, (BlockNumberFor::<T>::zero(), vetoers));
+
+		let origin = T::VetoOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		ensure!(NextExternal::<T>::get().is_some(), "no external proposal");
+	}: _<T::RuntimeOrigin>(origin, proposal_hash)
+	verify {
+		assert!(NextExternal::<T>::get().is_none());
+		let (_, new_vetoers) = <Blacklist<T>>::get(&proposal_hash).ok_or("no blacklist")?;
+		assert_eq!(new_vetoers.len(), T::MaxBlacklisted::get() as usize, "vetoers not added");
+	}
+
+	cancel_proposal {
+		// Place our proposal at the end to make sure it's worst case.
+		for i in 0 .. T::MaxProposals::get() {
+			add_proposal::<T>(i)?;
+		}
+		// Add metadata to the first proposal.
+		let proposer = funded_account::<T>("proposer", 0);
+		let preimage_hash = note_preimage::<T>();
+		assert_ok!(Democracy::<T>::set_metadata(
+			RawOrigin::Signed(proposer).into(),
+			MetadataOwner::Proposal(0),
+			Some(preimage_hash)));
+		let cancel_origin = T::CancelProposalOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+	}: _<T::RuntimeOrigin>(cancel_origin, 0)
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataCleared {
+			owner: MetadataOwner::Proposal(0),
+			hash: preimage_hash,
+		}.into());
+	}
+
+	cancel_referendum {
+		let (ref_index, _, preimage_hash) = add_referendum::<T>(0);
+	}: _(RawOrigin::Root, ref_index)
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataCleared {
+			owner: MetadataOwner::Referendum(0),
+			hash: preimage_hash,
+		}.into());
+	}
+
+	#[extra]
+	on_initialize_external {
+		let r in 0 .. REFERENDUM_COUNT_HINT;
+
+		for i in 0..r {
+			add_referendum::<T>(i);
+		}
+
+		assert_eq!(Democracy::<T>::referendum_count(), r, "referenda not created");
+
+		// Launch external
+		LastTabledWasExternal::<T>::put(false);
+
+		let origin = T::ExternalMajorityOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let proposal = make_proposal::<T>(r);
+		let call = Call::<T>::external_propose_majority { proposal };
+		call.dispatch_bypass_filter(origin)?;
+		// External proposal created
+		ensure!(<NextExternal<T>>::exists(), "External proposal didn't work");
+
+		let block_number = T::LaunchPeriod::get();
+
+	}: { Democracy::<T>::on_initialize(block_number) }
+	verify {
+		// One extra because of next external
+		assert_eq!(Democracy::<T>::referendum_count(), r + 1, "referenda not created");
+		ensure!(!<NextExternal<T>>::exists(), "External wasn't taken");
+
+		// All but the new next external should be finished
+		for i in 0 .. r {
+			if let Some(value) = ReferendumInfoOf::<T>::get(i) {
+				match value {
+					ReferendumInfo::Finished { .. } => (),
+					ReferendumInfo::Ongoing(_) => return Err("Referendum was not finished".into()),
+				}
+			}
+		}
+	}
+
+	#[extra]
+	on_initialize_public {
+		let r in 0 .. (T::MaxVotes::get() - 1);
+
+		for i in 0..r {
+			add_referendum::<T>(i);
+		}
+
+		assert_eq!(Democracy::<T>::referendum_count(), r, "referenda not created");
+
+		// Launch public
+		assert!(add_proposal::<T>(r).is_ok(), "proposal not created");
+		LastTabledWasExternal::<T>::put(true);
+
+		let block_number = T::LaunchPeriod::get();
+
+	}: { Democracy::<T>::on_initialize(block_number) }
+	verify {
+		// One extra because of next public
+		assert_eq!(Democracy::<T>::referendum_count(), r + 1, "proposal not accepted");
+
+		// All should be finished
+		for i in 0 .. r {
+			if let Some(value) = ReferendumInfoOf::<T>::get(i) {
+				match value {
+					ReferendumInfo::Finished { .. } => (),
+					ReferendumInfo::Ongoing(_) => return Err("Referendum was not finished".into()),
+				}
+			}
+		}
+	}
+
+	// No launch no maturing referenda.
+	on_initialize_base {
+		let r in 0 .. (T::MaxVotes::get() - 1);
+
+		for i in 0..r {
+			add_referendum::<T>(i);
+		}
+
+		for (key, mut info) in ReferendumInfoOf::<T>::iter() {
+			if let ReferendumInfo::Ongoing(ref mut status) = info {
+				status.end += 100u32.into();
+			}
+			ReferendumInfoOf::<T>::insert(key, info);
+		}
+
+		assert_eq!(Democracy::<T>::referendum_count(), r, "referenda not created");
+		assert_eq!(Democracy::<T>::lowest_unbaked(), 0, "invalid referenda init");
+
+	}: { Democracy::<T>::on_initialize(1u32.into()) }
+	verify {
+		// All should be on going
+		for i in 0 .. r {
+			if let Some(value) = ReferendumInfoOf::<T>::get(i) {
+				match value {
+					ReferendumInfo::Finished { .. } => return Err("Referendum has been finished".into()),
+					ReferendumInfo::Ongoing(_) => (),
+				}
+			}
+		}
+	}
+
+	on_initialize_base_with_launch_period {
+		let r in 0 .. (T::MaxVotes::get() - 1);
+
+		for i in 0..r {
+			add_referendum::<T>(i);
+		}
+
+		for (key, mut info) in ReferendumInfoOf::<T>::iter() {
+			if let ReferendumInfo::Ongoing(ref mut status) = info {
+				status.end += 100u32.into();
+			}
+			ReferendumInfoOf::<T>::insert(key, info);
+		}
+
+		assert_eq!(Democracy::<T>::referendum_count(), r, "referenda not created");
+		assert_eq!(Democracy::<T>::lowest_unbaked(), 0, "invalid referenda init");
+
+		let block_number = T::LaunchPeriod::get();
+
+	}: { Democracy::<T>::on_initialize(block_number) }
+	verify {
+		// All should be on going
+		for i in 0 .. r {
+			if let Some(value) = ReferendumInfoOf::<T>::get(i) {
+				match value {
+					ReferendumInfo::Finished { .. } => return Err("Referendum has been finished".into()),
+					ReferendumInfo::Ongoing(_) => (),
+				}
+			}
+		}
+	}
+
+	delegate {
+		let r in 0 .. (T::MaxVotes::get() - 1);
+
+		let initial_balance: BalanceOf<T> = 100u32.into();
+		let delegated_balance: BalanceOf<T> = 1000u32.into();
+
+		let caller = funded_account::<T>("caller", 0);
+		// Caller will initially delegate to `old_delegate`
+		let old_delegate: T::AccountId = funded_account::<T>("old_delegate", r);
+		let old_delegate_lookup = T::Lookup::unlookup(old_delegate.clone());
+		Democracy::<T>::delegate(
+			RawOrigin::Signed(caller.clone()).into(),
+			old_delegate_lookup,
+			Conviction::Locked1x,
+			delegated_balance,
+		)?;
+		let (target, balance) = match VotingOf::<T>::get(&caller) {
+			Voting::Delegating { target, balance, .. } => (target, balance),
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(target, old_delegate, "delegation target didn't work");
+		assert_eq!(balance, delegated_balance, "delegation balance didn't work");
+		// Caller will now switch to `new_delegate`
+		let new_delegate: T::AccountId = funded_account::<T>("new_delegate", r);
+		let new_delegate_lookup = T::Lookup::unlookup(new_delegate.clone());
+		let account_vote = account_vote::<T>(initial_balance);
+		// We need to create existing direct votes for the `new_delegate`
+		for i in 0..r {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(RawOrigin::Signed(new_delegate.clone()).into(), ref_index, account_vote)?;
+		}
+		let votes = match VotingOf::<T>::get(&new_delegate) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r as usize, "Votes were not recorded.");
+		whitelist_account!(caller);
+	}: _(RawOrigin::Signed(caller.clone()), new_delegate_lookup, Conviction::Locked1x, delegated_balance)
+	verify {
+		let (target, balance) = match VotingOf::<T>::get(&caller) {
+			Voting::Delegating { target, balance, .. } => (target, balance),
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(target, new_delegate, "delegation target didn't work");
+		assert_eq!(balance, delegated_balance, "delegation balance didn't work");
+		let delegations = match VotingOf::<T>::get(&new_delegate) {
+			Voting::Direct { delegations, .. } => delegations,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(delegations.capital, delegated_balance, "delegation was not recorded.");
+	}
+
+	undelegate {
+		let r in 0 .. (T::MaxVotes::get() - 1);
+
+		let initial_balance: BalanceOf<T> = 100u32.into();
+		let delegated_balance: BalanceOf<T> = 1000u32.into();
+
+		let caller = funded_account::<T>("caller", 0);
+		// Caller will delegate
+		let the_delegate: T::AccountId = funded_account::<T>("delegate", r);
+		let the_delegate_lookup = T::Lookup::unlookup(the_delegate.clone());
+		Democracy::<T>::delegate(
+			RawOrigin::Signed(caller.clone()).into(),
+			the_delegate_lookup,
+			Conviction::Locked1x,
+			delegated_balance,
+		)?;
+		let (target, balance) = match VotingOf::<T>::get(&caller) {
+			Voting::Delegating { target, balance, .. } => (target, balance),
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(target, the_delegate, "delegation target didn't work");
+		assert_eq!(balance, delegated_balance, "delegation balance didn't work");
+		// We need to create votes direct votes for the `delegate`
+		let account_vote = account_vote::<T>(initial_balance);
+		for i in 0..r {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(
+				RawOrigin::Signed(the_delegate.clone()).into(),
+				ref_index,
+				account_vote
+			)?;
+		}
+		let votes = match VotingOf::<T>::get(&the_delegate) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r as usize, "Votes were not recorded.");
+		whitelist_account!(caller);
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		// Voting should now be direct
+		match VotingOf::<T>::get(&caller) {
+			Voting::Direct { .. } => (),
+			_ => return Err("undelegation failed".into()),
+		}
+	}
+
+	clear_public_proposals {
+		add_proposal::<T>(0)?;
+
+	}: _(RawOrigin::Root)
+
+	// Test when unlock will remove locks
+	unlock_remove {
+		let r in 0 .. (T::MaxVotes::get() - 1);
+
+		let locker = funded_account::<T>("locker", 0);
+		let locker_lookup = T::Lookup::unlookup(locker.clone());
+		// Populate votes so things are locked
+		let base_balance: BalanceOf<T> = 100u32.into();
+		let small_vote = account_vote::<T>(base_balance);
+		// Vote and immediately unvote
+		for i in 0 .. r {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(RawOrigin::Signed(locker.clone()).into(), ref_index, small_vote)?;
+			Democracy::<T>::remove_vote(RawOrigin::Signed(locker.clone()).into(), ref_index)?;
+		}
+
+		let caller = funded_account::<T>("caller", 0);
+		whitelist_account!(caller);
+	}: unlock(RawOrigin::Signed(caller), locker_lookup)
+	verify {
+		// Note that we may want to add a `get_lock` api to actually verify
+		let voting = VotingOf::<T>::get(&locker);
+		assert_eq!(voting.locked_balance(), BalanceOf::<T>::zero());
+	}
+
+	// Test when unlock will set a new value
+	unlock_set {
+		let r in 0 .. (T::MaxVotes::get() - 1);
+
+		let locker = funded_account::<T>("locker", 0);
+		let locker_lookup = T::Lookup::unlookup(locker.clone());
+		// Populate votes so things are locked
+		let base_balance: BalanceOf<T> = 100u32.into();
+		let small_vote = account_vote::<T>(base_balance);
+		for i in 0 .. r {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(RawOrigin::Signed(locker.clone()).into(), ref_index, small_vote)?;
+		}
+
+		// Create a big vote so lock increases
+		let big_vote = account_vote::<T>(base_balance * 10u32.into());
+		let ref_index = add_referendum::<T>(r).0;
+		Democracy::<T>::vote(RawOrigin::Signed(locker.clone()).into(), ref_index, big_vote)?;
+
+		let votes = match VotingOf::<T>::get(&locker) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), (r + 1) as usize, "Votes were not recorded.");
+
+		let voting = VotingOf::<T>::get(&locker);
+		assert_eq!(voting.locked_balance(), base_balance * 10u32.into());
+
+		Democracy::<T>::remove_vote(RawOrigin::Signed(locker.clone()).into(), ref_index)?;
+
+		let caller = funded_account::<T>("caller", 0);
+		whitelist_account!(caller);
+	}: unlock(RawOrigin::Signed(caller), locker_lookup)
+	verify {
+		let votes = match VotingOf::<T>::get(&locker) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r as usize, "Vote was not removed");
+
+		let voting = VotingOf::<T>::get(&locker);
+		// Note that we may want to add a `get_lock` api to actually verify
+		assert_eq!(voting.locked_balance(), if r > 0 { base_balance } else { 0u32.into() });
+	}
+
+	remove_vote {
+		let r in 1 .. T::MaxVotes::get();
+
+		let caller = funded_account::<T>("caller", 0);
+		let account_vote = account_vote::<T>(100u32.into());
+
+		for i in 0 .. r {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(RawOrigin::Signed(caller.clone()).into(), ref_index, account_vote)?;
+		}
+
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r as usize, "Votes not created");
+
+		let ref_index = r - 1;
+		whitelist_account!(caller);
+	}: _(RawOrigin::Signed(caller.clone()), ref_index)
+	verify {
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), (r - 1) as usize, "Vote was not removed");
+	}
+
+	// Worst case is when target == caller and referendum is ongoing
+	remove_other_vote {
+		let r in 1 .. T::MaxVotes::get();
+
+		let caller = funded_account::<T>("caller", r);
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		let account_vote = account_vote::<T>(100u32.into());
+
+		for i in 0 .. r {
+			let ref_index = add_referendum::<T>(i).0;
+			Democracy::<T>::vote(RawOrigin::Signed(caller.clone()).into(), ref_index, account_vote)?;
+		}
+
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), r as usize, "Votes not created");
+
+		let ref_index = r - 1;
+		whitelist_account!(caller);
+	}: _(RawOrigin::Signed(caller.clone()), caller_lookup, ref_index)
+	verify {
+		let votes = match VotingOf::<T>::get(&caller) {
+			Voting::Direct { votes, .. } => votes,
+			_ => return Err("Votes are not direct".into()),
+		};
+		assert_eq!(votes.len(), (r - 1) as usize, "Vote was not removed");
+	}
+
+	set_external_metadata {
+		let origin = T::ExternalOrigin::try_successful_origin()
+			.expect("ExternalOrigin has no successful origin required for the benchmark");
+		assert_ok!(
+			Democracy::<T>::external_propose(origin.clone(), make_proposal::<T>(0))
+		);
+		let owner = MetadataOwner::External;
+		let hash = note_preimage::<T>();
+	}: set_metadata<T::RuntimeOrigin>(origin, owner.clone(), Some(hash))
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataSet {
+			owner,
+			hash,
+		}.into());
+	}
+
+	clear_external_metadata {
+		let origin = T::ExternalOrigin::try_successful_origin()
+			.expect("ExternalOrigin has no successful origin required for the benchmark");
+		assert_ok!(
+			Democracy::<T>::external_propose(origin.clone(), make_proposal::<T>(0))
+		);
+		let owner = MetadataOwner::External;
+		let proposer = funded_account::<T>("proposer", 0);
+		let hash = note_preimage::<T>();
+		assert_ok!(Democracy::<T>::set_metadata(origin.clone(), owner.clone(), Some(hash)));
+	}: set_metadata<T::RuntimeOrigin>(origin, owner.clone(), None)
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataCleared {
+			owner,
+			hash,
+		}.into());
+	}
+
+	set_proposal_metadata {
+		// Place our proposal at the end to make sure it's worst case.
+		for i in 0 .. T::MaxProposals::get() {
+			add_proposal::<T>(i)?;
+		}
+		let owner = MetadataOwner::Proposal(0);
+		let proposer = funded_account::<T>("proposer", 0);
+		let hash = note_preimage::<T>();
+	}: set_metadata<T::RuntimeOrigin>(RawOrigin::Signed(proposer).into(), owner.clone(), Some(hash))
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataSet {
+			owner,
+			hash,
+		}.into());
+	}
+
+	clear_proposal_metadata {
+		// Place our proposal at the end to make sure it's worst case.
+		for i in 0 .. T::MaxProposals::get() {
+			add_proposal::<T>(i)?;
+		}
+		let proposer = funded_account::<T>("proposer", 0);
+		let owner = MetadataOwner::Proposal(0);
+		let hash = note_preimage::<T>();
+		assert_ok!(Democracy::<T>::set_metadata(
+			RawOrigin::Signed(proposer.clone()).into(),
+			owner.clone(),
+			Some(hash)));
+	}: set_metadata<T::RuntimeOrigin>(RawOrigin::Signed(proposer).into(), owner.clone(), None)
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataCleared {
+			owner,
+			hash,
+		}.into());
+	}
+
+	set_referendum_metadata {
+		// create not ongoing referendum.
+		ReferendumInfoOf::<T>::insert(
+			0,
+			ReferendumInfo::Finished { end: BlockNumberFor::<T>::zero(), approved: true },
+		);
+		let owner = MetadataOwner::Referendum(0);
+		let caller = funded_account::<T>("caller", 0);
+		let hash = note_preimage::<T>();
+	}: set_metadata<T::RuntimeOrigin>(RawOrigin::Root.into(), owner.clone(), Some(hash))
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataSet {
+			owner,
+			hash,
+		}.into());
+	}
+
+	clear_referendum_metadata {
+		// create not ongoing referendum.
+		ReferendumInfoOf::<T>::insert(
+			0,
+			ReferendumInfo::Finished { end: BlockNumberFor::<T>::zero(), approved: true },
+		);
+		let owner = MetadataOwner::Referendum(0);
+		let hash = note_preimage::<T>();
+		MetadataOf::<T>::insert(owner.clone(), hash);
+		let caller = funded_account::<T>("caller", 0);
+	}: set_metadata<T::RuntimeOrigin>(RawOrigin::Signed(caller).into(), owner.clone(), None)
+	verify {
+		assert_last_event::<T>(crate::Event::MetadataCleared {
+			owner,
+			hash,
+		}.into());
+	}
+
+	impl_benchmark_test_suite!(
+		Democracy,
+		crate::tests::new_test_ext(),
+		crate::tests::Test
+	);
+}
diff --git a/substrate/frame/democracy/src/conviction.rs b/substrate/frame/democracy/src/conviction.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d2f685f7d99efb79e12628ac38370fb69445a44d
--- /dev/null
+++ b/substrate/frame/democracy/src/conviction.rs
@@ -0,0 +1,131 @@
+// 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.
+
+//! The conviction datatype.
+
+use crate::types::Delegations;
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Bounded, CheckedDiv, CheckedMul, Zero},
+	RuntimeDebug,
+};
+use sp_std::{prelude::*, result::Result};
+
+/// A value denoting the strength of conviction of a vote.
+#[derive(
+	Encode,
+	MaxEncodedLen,
+	Decode,
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	RuntimeDebug,
+	TypeInfo,
+)]
+pub enum Conviction {
+	/// 0.1x votes, unlocked.
+	None,
+	/// 1x votes, locked for an enactment period following a successful vote.
+	Locked1x,
+	/// 2x votes, locked for 2x enactment periods following a successful vote.
+	Locked2x,
+	/// 3x votes, locked for 4x...
+	Locked3x,
+	/// 4x votes, locked for 8x...
+	Locked4x,
+	/// 5x votes, locked for 16x...
+	Locked5x,
+	/// 6x votes, locked for 32x...
+	Locked6x,
+}
+
+impl Default for Conviction {
+	fn default() -> Self {
+		Conviction::None
+	}
+}
+
+impl From<Conviction> for u8 {
+	fn from(c: Conviction) -> u8 {
+		match c {
+			Conviction::None => 0,
+			Conviction::Locked1x => 1,
+			Conviction::Locked2x => 2,
+			Conviction::Locked3x => 3,
+			Conviction::Locked4x => 4,
+			Conviction::Locked5x => 5,
+			Conviction::Locked6x => 6,
+		}
+	}
+}
+
+impl TryFrom<u8> for Conviction {
+	type Error = ();
+	fn try_from(i: u8) -> Result<Conviction, ()> {
+		Ok(match i {
+			0 => Conviction::None,
+			1 => Conviction::Locked1x,
+			2 => Conviction::Locked2x,
+			3 => Conviction::Locked3x,
+			4 => Conviction::Locked4x,
+			5 => Conviction::Locked5x,
+			6 => Conviction::Locked6x,
+			_ => return Err(()),
+		})
+	}
+}
+
+impl Conviction {
+	/// The amount of time (in number of periods) that our conviction implies a successful voter's
+	/// balance should be locked for.
+	pub fn lock_periods(self) -> u32 {
+		match self {
+			Conviction::None => 0,
+			Conviction::Locked1x => 1,
+			Conviction::Locked2x => 2,
+			Conviction::Locked3x => 4,
+			Conviction::Locked4x => 8,
+			Conviction::Locked5x => 16,
+			Conviction::Locked6x => 32,
+		}
+	}
+
+	/// The votes of a voter of the given `balance` with our conviction.
+	pub fn votes<B: From<u8> + Zero + Copy + CheckedMul + CheckedDiv + Bounded>(
+		self,
+		capital: B,
+	) -> Delegations<B> {
+		let votes = match self {
+			Conviction::None => capital.checked_div(&10u8.into()).unwrap_or_else(Zero::zero),
+			x => capital.checked_mul(&u8::from(x).into()).unwrap_or_else(B::max_value),
+		};
+		Delegations { votes, capital }
+	}
+}
+
+impl Bounded for Conviction {
+	fn min_value() -> Self {
+		Conviction::None
+	}
+	fn max_value() -> Self {
+		Conviction::Locked6x
+	}
+}
diff --git a/substrate/frame/democracy/src/lib.rs b/substrate/frame/democracy/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e538d31c6ad0312e9a81d155786fac16ab403c54
--- /dev/null
+++ b/substrate/frame/democracy/src/lib.rs
@@ -0,0 +1,1756 @@
+// 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.
+
+//! # Democracy Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! The Democracy pallet handles the administration of general stakeholder voting.
+//!
+//! There are two different queues that a proposal can be added to before it
+//! becomes a referendum, 1) the proposal queue consisting of all public proposals
+//! and 2) the external queue consisting of a single proposal that originates
+//! from one of the _external_ origins (such as a collective group).
+//!
+//! Every launch period - a length defined in the runtime - the Democracy pallet
+//! launches a referendum from a proposal that it takes from either the proposal
+//! queue or the external queue in turn. Any token holder in the system can vote
+//! on referenda. The voting system
+//! uses time-lock voting by allowing the token holder to set their _conviction_
+//! behind a vote. The conviction will dictate the length of time the tokens
+//! will be locked, as well as the multiplier that scales the vote power.
+//!
+//! ### Terminology
+//!
+//! - **Enactment Period:** The minimum period of locking and the period between a proposal being
+//! approved and enacted.
+//! - **Lock Period:** A period of time after proposal enactment that the tokens of _winning_ voters
+//! will be locked.
+//! - **Conviction:** An indication of a voter's strength of belief in their vote. An increase
+//! of one in conviction indicates that a token holder is willing to lock their tokens for twice
+//! as many lock periods after enactment.
+//! - **Vote:** A value that can either be in approval ("Aye") or rejection ("Nay") of a particular
+//!   referendum.
+//! - **Proposal:** A submission to the chain that represents an action that a proposer (either an
+//! account or an external origin) suggests that the system adopt.
+//! - **Referendum:** A proposal that is in the process of being voted on for either acceptance or
+//!   rejection as a change to the system.
+//! - **Delegation:** The act of granting your voting power to the decisions of another account for
+//!   up to a certain conviction.
+//!
+//! ### Adaptive Quorum Biasing
+//!
+//! A _referendum_ can be either simple majority-carries in which 50%+1 of the
+//! votes decide the outcome or _adaptive quorum biased_. Adaptive quorum biasing
+//! makes the threshold for passing or rejecting a referendum higher or lower
+//! depending on how the referendum was originally proposed. There are two types of
+//! adaptive quorum biasing: 1) _positive turnout bias_ makes a referendum
+//! require a super-majority to pass that decreases as turnout increases and
+//! 2) _negative turnout bias_ makes a referendum require a super-majority to
+//! reject that decreases as turnout increases. Another way to think about the
+//! quorum biasing is that _positive bias_ referendums will be rejected by
+//! default and _negative bias_ referendums get passed by default.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! #### Public
+//!
+//! These calls can be made from any externally held account capable of creating
+//! a signed extrinsic.
+//!
+//! Basic actions:
+//! - `propose` - Submits a sensitive action, represented as a hash. Requires a deposit.
+//! - `second` - Signals agreement with a proposal, moves it higher on the proposal queue, and
+//!   requires a matching deposit to the original.
+//! - `vote` - Votes in a referendum, either the vote is "Aye" to enact the proposal or "Nay" to
+//!   keep the status quo.
+//! - `unvote` - Cancel a previous vote, this must be done by the voter before the vote ends.
+//! - `delegate` - Delegates the voting power (tokens * conviction) to another account.
+//! - `undelegate` - Stops the delegation of voting power to another account.
+//!
+//! Administration actions that can be done to any account:
+//! - `reap_vote` - Remove some account's expired votes.
+//! - `unlock` - Redetermine the account's balance lock, potentially making tokens available.
+//!
+//! Preimage actions:
+//! - `note_preimage` - Registers the preimage for an upcoming proposal, requires a deposit that is
+//!   returned once the proposal is enacted.
+//! - `note_preimage_operational` - same but provided by `T::OperationalPreimageOrigin`.
+//! - `note_imminent_preimage` - Registers the preimage for an upcoming proposal. Does not require a
+//!   deposit, but the proposal must be in the dispatch queue.
+//! - `note_imminent_preimage_operational` - same but provided by `T::OperationalPreimageOrigin`.
+//! - `reap_preimage` - Removes the preimage for an expired proposal. Will only work under the
+//!   condition that it's the same account that noted it and after the voting period, OR it's a
+//!   different account after the enactment period.
+//!
+//! #### Cancellation Origin
+//!
+//! This call can only be made by the `CancellationOrigin`.
+//!
+//! - `emergency_cancel` - Schedules an emergency cancellation of a referendum. Can only happen once
+//!   to a specific referendum.
+//!
+//! #### ExternalOrigin
+//!
+//! This call can only be made by the `ExternalOrigin`.
+//!
+//! - `external_propose` - Schedules a proposal to become a referendum once it is is legal for an
+//!   externally proposed referendum.
+//!
+//! #### External Majority Origin
+//!
+//! This call can only be made by the `ExternalMajorityOrigin`.
+//!
+//! - `external_propose_majority` - Schedules a proposal to become a majority-carries referendum
+//!   once it is legal for an externally proposed referendum.
+//!
+//! #### External Default Origin
+//!
+//! This call can only be made by the `ExternalDefaultOrigin`.
+//!
+//! - `external_propose_default` - Schedules a proposal to become a negative-turnout-bias referendum
+//!   once it is legal for an externally proposed referendum.
+//!
+//! #### Fast Track Origin
+//!
+//! This call can only be made by the `FastTrackOrigin`.
+//!
+//! - `fast_track` - Schedules the current externally proposed proposal that is "majority-carries"
+//!   to become a referendum immediately.
+//!
+//! #### Veto Origin
+//!
+//! This call can only be made by the `VetoOrigin`.
+//!
+//! - `veto_external` - Vetoes and blacklists the external proposal hash.
+//!
+//! #### Root
+//!
+//! - `cancel_referendum` - Removes a referendum.
+//! - `cancel_queued` - Cancels a proposal that is queued for enactment.
+//! - `clear_public_proposal` - Removes all public proposals.
+
+#![recursion_limit = "256"]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+use frame_support::{
+	ensure,
+	error::BadOrigin,
+	traits::{
+		defensive_prelude::*,
+		schedule::{v3::Named as ScheduleNamed, DispatchTime},
+		Bounded, Currency, EnsureOrigin, Get, Hash as PreimageHash, LockIdentifier,
+		LockableCurrency, OnUnbalanced, QueryPreimage, ReservableCurrency, StorePreimage,
+		WithdrawReasons,
+	},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+use sp_runtime::{
+	traits::{Bounded as ArithBounded, One, Saturating, StaticLookup, Zero},
+	ArithmeticError, DispatchError, DispatchResult,
+};
+use sp_std::prelude::*;
+
+mod conviction;
+mod types;
+mod vote;
+mod vote_threshold;
+pub mod weights;
+pub use conviction::Conviction;
+pub use pallet::*;
+pub use types::{
+	Delegations, MetadataOwner, PropIndex, ReferendumIndex, ReferendumInfo, ReferendumStatus,
+	Tally, UnvoteScope,
+};
+pub use vote::{AccountVote, Vote, Voting};
+pub use vote_threshold::{Approved, VoteThreshold};
+pub use weights::WeightInfo;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+
+pub mod migrations;
+
+pub(crate) const DEMOCRACY_ID: LockIdentifier = *b"democrac";
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+pub type CallOf<T> = <T as frame_system::Config>::RuntimeCall;
+pub type BoundedCallOf<T> = Bounded<CallOf<T>>;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::{DispatchResult, *};
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+	use sp_core::H256;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config + Sized {
+		type WeightInfo: WeightInfo;
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The Scheduler.
+		type Scheduler: ScheduleNamed<BlockNumberFor<Self>, CallOf<Self>, Self::PalletsOrigin>;
+
+		/// The Preimage provider.
+		type Preimages: QueryPreimage + StorePreimage;
+
+		/// Currency type for this pallet.
+		type Currency: ReservableCurrency<Self::AccountId>
+			+ LockableCurrency<Self::AccountId, Moment = BlockNumberFor<Self>>;
+
+		/// The period between a proposal being approved and enacted.
+		///
+		/// It should generally be a little more than the unstake period to ensure that
+		/// voting stakers have an opportunity to remove themselves from the system in the case
+		/// where they are on the losing side of a vote.
+		#[pallet::constant]
+		type EnactmentPeriod: Get<BlockNumberFor<Self>>;
+
+		/// How often (in blocks) new public referenda are launched.
+		#[pallet::constant]
+		type LaunchPeriod: Get<BlockNumberFor<Self>>;
+
+		/// How often (in blocks) to check for new votes.
+		#[pallet::constant]
+		type VotingPeriod: Get<BlockNumberFor<Self>>;
+
+		/// The minimum period of vote locking.
+		///
+		/// It should be no shorter than enactment period to ensure that in the case of an approval,
+		/// those successful voters are locked into the consequences that their votes entail.
+		#[pallet::constant]
+		type VoteLockingPeriod: Get<BlockNumberFor<Self>>;
+
+		/// The minimum amount to be used as a deposit for a public referendum proposal.
+		#[pallet::constant]
+		type MinimumDeposit: Get<BalanceOf<Self>>;
+
+		/// Indicator for whether an emergency origin is even allowed to happen. Some chains may
+		/// want to set this permanently to `false`, others may want to condition it on things such
+		/// as an upgrade having happened recently.
+		#[pallet::constant]
+		type InstantAllowed: Get<bool>;
+
+		/// Minimum voting period allowed for a fast-track referendum.
+		#[pallet::constant]
+		type FastTrackVotingPeriod: Get<BlockNumberFor<Self>>;
+
+		/// Period in blocks where an external proposal may not be re-submitted after being vetoed.
+		#[pallet::constant]
+		type CooloffPeriod: Get<BlockNumberFor<Self>>;
+
+		/// The maximum number of votes for an account.
+		///
+		/// Also used to compute weight, an overly big value can
+		/// lead to extrinsic with very big weight: see `delegate` for instance.
+		#[pallet::constant]
+		type MaxVotes: Get<u32>;
+
+		/// The maximum number of public proposals that can exist at any time.
+		#[pallet::constant]
+		type MaxProposals: Get<u32>;
+
+		/// The maximum number of deposits a public proposal may have at any time.
+		#[pallet::constant]
+		type MaxDeposits: Get<u32>;
+
+		/// The maximum number of items which can be blacklisted.
+		#[pallet::constant]
+		type MaxBlacklisted: Get<u32>;
+
+		/// Origin from which the next tabled referendum may be forced. This is a normal
+		/// "super-majority-required" referendum.
+		type ExternalOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which the next tabled referendum may be forced; this allows for the tabling
+		/// of a majority-carries referendum.
+		type ExternalMajorityOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which the next tabled referendum may be forced; this allows for the tabling
+		/// of a negative-turnout-bias (default-carries) referendum.
+		type ExternalDefaultOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which the new proposal can be made.
+		///
+		/// The success variant is the account id of the depositor.
+		type SubmitOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Self::AccountId>;
+
+		/// Origin from which the next majority-carries (or more permissive) referendum may be
+		/// tabled to vote according to the `FastTrackVotingPeriod` asynchronously in a similar
+		/// manner to the emergency origin. It retains its threshold method.
+		type FastTrackOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which the next majority-carries (or more permissive) referendum may be
+		/// tabled to vote immediately and asynchronously in a similar manner to the emergency
+		/// origin. It retains its threshold method.
+		type InstantOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which any referendum may be cancelled in an emergency.
+		type CancellationOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which proposals may be blacklisted.
+		type BlacklistOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which a proposal may be cancelled and its backers slashed.
+		type CancelProposalOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin for anyone able to veto proposals.
+		type VetoOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Self::AccountId>;
+
+		/// Overarching type of all pallets origins.
+		type PalletsOrigin: From<frame_system::RawOrigin<Self::AccountId>>;
+
+		/// Handler for the unbalanced reduction when slashing a preimage deposit.
+		type Slash: OnUnbalanced<NegativeImbalanceOf<Self>>;
+	}
+
+	/// The number of (public) proposals that have been made so far.
+	#[pallet::storage]
+	#[pallet::getter(fn public_prop_count)]
+	pub type PublicPropCount<T> = StorageValue<_, PropIndex, ValueQuery>;
+
+	/// The public proposals. Unsorted. The second item is the proposal.
+	#[pallet::storage]
+	#[pallet::getter(fn public_props)]
+	pub type PublicProps<T: Config> = StorageValue<
+		_,
+		BoundedVec<(PropIndex, BoundedCallOf<T>, T::AccountId), T::MaxProposals>,
+		ValueQuery,
+	>;
+
+	/// Those who have locked a deposit.
+	///
+	/// TWOX-NOTE: Safe, as increasing integer keys are safe.
+	#[pallet::storage]
+	#[pallet::getter(fn deposit_of)]
+	pub type DepositOf<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		PropIndex,
+		(BoundedVec<T::AccountId, T::MaxDeposits>, BalanceOf<T>),
+	>;
+
+	/// The next free referendum index, aka the number of referenda started so far.
+	#[pallet::storage]
+	#[pallet::getter(fn referendum_count)]
+	pub type ReferendumCount<T> = StorageValue<_, ReferendumIndex, ValueQuery>;
+
+	/// The lowest referendum index representing an unbaked referendum. Equal to
+	/// `ReferendumCount` if there isn't a unbaked referendum.
+	#[pallet::storage]
+	#[pallet::getter(fn lowest_unbaked)]
+	pub type LowestUnbaked<T> = StorageValue<_, ReferendumIndex, ValueQuery>;
+
+	/// Information concerning any given referendum.
+	///
+	/// TWOX-NOTE: SAFE as indexes are not under an attacker’s control.
+	#[pallet::storage]
+	#[pallet::getter(fn referendum_info)]
+	pub type ReferendumInfoOf<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		ReferendumIndex,
+		ReferendumInfo<BlockNumberFor<T>, BoundedCallOf<T>, BalanceOf<T>>,
+	>;
+
+	/// All votes for a particular voter. We store the balance for the number of votes that we
+	/// have recorded. The second item is the total amount of delegations, that will be added.
+	///
+	/// TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.
+	#[pallet::storage]
+	pub type VotingOf<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Voting<BalanceOf<T>, T::AccountId, BlockNumberFor<T>, T::MaxVotes>,
+		ValueQuery,
+	>;
+
+	/// True if the last referendum tabled was submitted externally. False if it was a public
+	/// proposal.
+	#[pallet::storage]
+	pub type LastTabledWasExternal<T> = StorageValue<_, bool, ValueQuery>;
+
+	/// The referendum to be tabled whenever it would be valid to table an external proposal.
+	/// This happens when a referendum needs to be tabled and one of two conditions are met:
+	/// - `LastTabledWasExternal` is `false`; or
+	/// - `PublicProps` is empty.
+	#[pallet::storage]
+	pub type NextExternal<T: Config> = StorageValue<_, (BoundedCallOf<T>, VoteThreshold)>;
+
+	/// A record of who vetoed what. Maps proposal hash to a possible existent block number
+	/// (until when it may not be resubmitted) and who vetoed it.
+	#[pallet::storage]
+	pub type Blacklist<T: Config> = StorageMap<
+		_,
+		Identity,
+		H256,
+		(BlockNumberFor<T>, BoundedVec<T::AccountId, T::MaxBlacklisted>),
+	>;
+
+	/// Record of all proposals that have been subject to emergency cancellation.
+	#[pallet::storage]
+	pub type Cancellations<T: Config> = StorageMap<_, Identity, H256, bool, ValueQuery>;
+
+	/// General information concerning any proposal or referendum.
+	/// The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON
+	/// dump or IPFS hash of a JSON file.
+	///
+	/// Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
+	/// large preimages.
+	#[pallet::storage]
+	pub type MetadataOf<T: Config> = StorageMap<_, Blake2_128Concat, MetadataOwner, PreimageHash>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		#[serde(skip)]
+		_config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			PublicPropCount::<T>::put(0 as PropIndex);
+			ReferendumCount::<T>::put(0 as ReferendumIndex);
+			LowestUnbaked::<T>::put(0 as ReferendumIndex);
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A motion has been proposed by a public account.
+		Proposed { proposal_index: PropIndex, deposit: BalanceOf<T> },
+		/// A public proposal has been tabled for referendum vote.
+		Tabled { proposal_index: PropIndex, deposit: BalanceOf<T> },
+		/// An external proposal has been tabled.
+		ExternalTabled,
+		/// A referendum has begun.
+		Started { ref_index: ReferendumIndex, threshold: VoteThreshold },
+		/// A proposal has been approved by referendum.
+		Passed { ref_index: ReferendumIndex },
+		/// A proposal has been rejected by referendum.
+		NotPassed { ref_index: ReferendumIndex },
+		/// A referendum has been cancelled.
+		Cancelled { ref_index: ReferendumIndex },
+		/// An account has delegated their vote to another account.
+		Delegated { who: T::AccountId, target: T::AccountId },
+		/// An account has cancelled a previous delegation operation.
+		Undelegated { account: T::AccountId },
+		/// An external proposal has been vetoed.
+		Vetoed { who: T::AccountId, proposal_hash: H256, until: BlockNumberFor<T> },
+		/// A proposal_hash has been blacklisted permanently.
+		Blacklisted { proposal_hash: H256 },
+		/// An account has voted in a referendum
+		Voted { voter: T::AccountId, ref_index: ReferendumIndex, vote: AccountVote<BalanceOf<T>> },
+		/// An account has secconded a proposal
+		Seconded { seconder: T::AccountId, prop_index: PropIndex },
+		/// A proposal got canceled.
+		ProposalCanceled { prop_index: PropIndex },
+		/// Metadata for a proposal or a referendum has been set.
+		MetadataSet {
+			/// Metadata owner.
+			owner: MetadataOwner,
+			/// Preimage hash.
+			hash: PreimageHash,
+		},
+		/// Metadata for a proposal or a referendum has been cleared.
+		MetadataCleared {
+			/// Metadata owner.
+			owner: MetadataOwner,
+			/// Preimage hash.
+			hash: PreimageHash,
+		},
+		/// Metadata has been transferred to new owner.
+		MetadataTransferred {
+			/// Previous metadata owner.
+			prev_owner: MetadataOwner,
+			/// New metadata owner.
+			owner: MetadataOwner,
+			/// Preimage hash.
+			hash: PreimageHash,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Value too low
+		ValueLow,
+		/// Proposal does not exist
+		ProposalMissing,
+		/// Cannot cancel the same proposal twice
+		AlreadyCanceled,
+		/// Proposal already made
+		DuplicateProposal,
+		/// Proposal still blacklisted
+		ProposalBlacklisted,
+		/// Next external proposal not simple majority
+		NotSimpleMajority,
+		/// Invalid hash
+		InvalidHash,
+		/// No external proposal
+		NoProposal,
+		/// Identity may not veto a proposal twice
+		AlreadyVetoed,
+		/// Vote given for invalid referendum
+		ReferendumInvalid,
+		/// No proposals waiting
+		NoneWaiting,
+		/// The given account did not vote on the referendum.
+		NotVoter,
+		/// The actor has no permission to conduct the action.
+		NoPermission,
+		/// The account is already delegating.
+		AlreadyDelegating,
+		/// Too high a balance was provided that the account cannot afford.
+		InsufficientFunds,
+		/// The account is not currently delegating.
+		NotDelegating,
+		/// The account currently has votes attached to it and the operation cannot succeed until
+		/// these are removed, either through `unvote` or `reap_vote`.
+		VotesExist,
+		/// The instant referendum origin is currently disallowed.
+		InstantNotAllowed,
+		/// Delegation to oneself makes no sense.
+		Nonsense,
+		/// Invalid upper bound.
+		WrongUpperBound,
+		/// Maximum number of votes reached.
+		MaxVotesReached,
+		/// Maximum number of items reached.
+		TooMany,
+		/// Voting period too low
+		VotingPeriodLow,
+		/// The preimage does not exist.
+		PreimageNotExist,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// Weight: see `begin_block`
+		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+			Self::begin_block(n)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Propose a sensitive action to be taken.
+		///
+		/// The dispatch origin of this call must be _Signed_ and the sender must
+		/// have funds to cover the deposit.
+		///
+		/// - `proposal_hash`: The hash of the proposal preimage.
+		/// - `value`: The amount of deposit (must be at least `MinimumDeposit`).
+		///
+		/// Emits `Proposed`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::propose())]
+		pub fn propose(
+			origin: OriginFor<T>,
+			proposal: BoundedCallOf<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+		) -> DispatchResult {
+			let who = T::SubmitOrigin::ensure_origin(origin)?;
+			ensure!(value >= T::MinimumDeposit::get(), Error::<T>::ValueLow);
+
+			let index = Self::public_prop_count();
+			let real_prop_count = PublicProps::<T>::decode_len().unwrap_or(0) as u32;
+			let max_proposals = T::MaxProposals::get();
+			ensure!(real_prop_count < max_proposals, Error::<T>::TooMany);
+			let proposal_hash = proposal.hash();
+
+			if let Some((until, _)) = <Blacklist<T>>::get(proposal_hash) {
+				ensure!(
+					<frame_system::Pallet<T>>::block_number() >= until,
+					Error::<T>::ProposalBlacklisted,
+				);
+			}
+
+			T::Currency::reserve(&who, value)?;
+
+			let depositors = BoundedVec::<_, T::MaxDeposits>::truncate_from(vec![who.clone()]);
+			DepositOf::<T>::insert(index, (depositors, value));
+
+			PublicPropCount::<T>::put(index + 1);
+
+			PublicProps::<T>::try_append((index, proposal, who))
+				.map_err(|_| Error::<T>::TooMany)?;
+
+			Self::deposit_event(Event::<T>::Proposed { proposal_index: index, deposit: value });
+			Ok(())
+		}
+
+		/// Signals agreement with a particular proposal.
+		///
+		/// The dispatch origin of this call must be _Signed_ and the sender
+		/// must have funds to cover the deposit, equal to the original deposit.
+		///
+		/// - `proposal`: The index of the proposal to second.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::second())]
+		pub fn second(
+			origin: OriginFor<T>,
+			#[pallet::compact] proposal: PropIndex,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let seconds = Self::len_of_deposit_of(proposal).ok_or(Error::<T>::ProposalMissing)?;
+			ensure!(seconds < T::MaxDeposits::get(), Error::<T>::TooMany);
+			let mut deposit = Self::deposit_of(proposal).ok_or(Error::<T>::ProposalMissing)?;
+			T::Currency::reserve(&who, deposit.1)?;
+			let ok = deposit.0.try_push(who.clone()).is_ok();
+			debug_assert!(ok, "`seconds` is below static limit; `try_insert` should succeed; qed");
+			<DepositOf<T>>::insert(proposal, deposit);
+			Self::deposit_event(Event::<T>::Seconded { seconder: who, prop_index: proposal });
+			Ok(())
+		}
+
+		/// Vote in a referendum. If `vote.is_aye()`, the vote is to enact the proposal;
+		/// otherwise it is a vote to keep the status quo.
+		///
+		/// The dispatch origin of this call must be _Signed_.
+		///
+		/// - `ref_index`: The index of the referendum to vote for.
+		/// - `vote`: The vote configuration.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::vote_new().max(T::WeightInfo::vote_existing()))]
+		pub fn vote(
+			origin: OriginFor<T>,
+			#[pallet::compact] ref_index: ReferendumIndex,
+			vote: AccountVote<BalanceOf<T>>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::try_vote(&who, ref_index, vote)
+		}
+
+		/// Schedule an emergency cancellation of a referendum. Cannot happen twice to the same
+		/// referendum.
+		///
+		/// The dispatch origin of this call must be `CancellationOrigin`.
+		///
+		/// -`ref_index`: The index of the referendum to cancel.
+		///
+		/// Weight: `O(1)`.
+		#[pallet::call_index(3)]
+		#[pallet::weight((T::WeightInfo::emergency_cancel(), DispatchClass::Operational))]
+		pub fn emergency_cancel(
+			origin: OriginFor<T>,
+			ref_index: ReferendumIndex,
+		) -> DispatchResult {
+			T::CancellationOrigin::ensure_origin(origin)?;
+
+			let status = Self::referendum_status(ref_index)?;
+			let h = status.proposal.hash();
+			ensure!(!<Cancellations<T>>::contains_key(h), Error::<T>::AlreadyCanceled);
+
+			<Cancellations<T>>::insert(h, true);
+			Self::internal_cancel_referendum(ref_index);
+			Ok(())
+		}
+
+		/// Schedule a referendum to be tabled once it is legal to schedule an external
+		/// referendum.
+		///
+		/// The dispatch origin of this call must be `ExternalOrigin`.
+		///
+		/// - `proposal_hash`: The preimage hash of the proposal.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::external_propose())]
+		pub fn external_propose(
+			origin: OriginFor<T>,
+			proposal: BoundedCallOf<T>,
+		) -> DispatchResult {
+			T::ExternalOrigin::ensure_origin(origin)?;
+			ensure!(!<NextExternal<T>>::exists(), Error::<T>::DuplicateProposal);
+			if let Some((until, _)) = <Blacklist<T>>::get(proposal.hash()) {
+				ensure!(
+					<frame_system::Pallet<T>>::block_number() >= until,
+					Error::<T>::ProposalBlacklisted,
+				);
+			}
+			<NextExternal<T>>::put((proposal, VoteThreshold::SuperMajorityApprove));
+			Ok(())
+		}
+
+		/// Schedule a majority-carries referendum to be tabled next once it is legal to schedule
+		/// an external referendum.
+		///
+		/// The dispatch of this call must be `ExternalMajorityOrigin`.
+		///
+		/// - `proposal_hash`: The preimage hash of the proposal.
+		///
+		/// Unlike `external_propose`, blacklisting has no effect on this and it may replace a
+		/// pre-scheduled `external_propose` call.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::external_propose_majority())]
+		pub fn external_propose_majority(
+			origin: OriginFor<T>,
+			proposal: BoundedCallOf<T>,
+		) -> DispatchResult {
+			T::ExternalMajorityOrigin::ensure_origin(origin)?;
+			<NextExternal<T>>::put((proposal, VoteThreshold::SimpleMajority));
+			Ok(())
+		}
+
+		/// Schedule a negative-turnout-bias referendum to be tabled next once it is legal to
+		/// schedule an external referendum.
+		///
+		/// The dispatch of this call must be `ExternalDefaultOrigin`.
+		///
+		/// - `proposal_hash`: The preimage hash of the proposal.
+		///
+		/// Unlike `external_propose`, blacklisting has no effect on this and it may replace a
+		/// pre-scheduled `external_propose` call.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::external_propose_default())]
+		pub fn external_propose_default(
+			origin: OriginFor<T>,
+			proposal: BoundedCallOf<T>,
+		) -> DispatchResult {
+			T::ExternalDefaultOrigin::ensure_origin(origin)?;
+			<NextExternal<T>>::put((proposal, VoteThreshold::SuperMajorityAgainst));
+			Ok(())
+		}
+
+		/// Schedule the currently externally-proposed majority-carries referendum to be tabled
+		/// immediately. If there is no externally-proposed referendum currently, or if there is one
+		/// but it is not a majority-carries referendum then it fails.
+		///
+		/// The dispatch of this call must be `FastTrackOrigin`.
+		///
+		/// - `proposal_hash`: The hash of the current external proposal.
+		/// - `voting_period`: The period that is allowed for voting on this proposal. Increased to
+		/// 	Must be always greater than zero.
+		/// 	For `FastTrackOrigin` must be equal or greater than `FastTrackVotingPeriod`.
+		/// - `delay`: The number of block after voting has ended in approval and this should be
+		///   enacted. This doesn't have a minimum amount.
+		///
+		/// Emits `Started`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::fast_track())]
+		pub fn fast_track(
+			origin: OriginFor<T>,
+			proposal_hash: H256,
+			voting_period: BlockNumberFor<T>,
+			delay: BlockNumberFor<T>,
+		) -> DispatchResult {
+			// Rather complicated bit of code to ensure that either:
+			// - `voting_period` is at least `FastTrackVotingPeriod` and `origin` is
+			//   `FastTrackOrigin`; or
+			// - `InstantAllowed` is `true` and `origin` is `InstantOrigin`.
+			let maybe_ensure_instant = if voting_period < T::FastTrackVotingPeriod::get() {
+				Some(origin)
+			} else if let Err(origin) = T::FastTrackOrigin::try_origin(origin) {
+				Some(origin)
+			} else {
+				None
+			};
+			if let Some(ensure_instant) = maybe_ensure_instant {
+				T::InstantOrigin::ensure_origin(ensure_instant)?;
+				ensure!(T::InstantAllowed::get(), Error::<T>::InstantNotAllowed);
+			}
+
+			ensure!(voting_period > Zero::zero(), Error::<T>::VotingPeriodLow);
+			let (ext_proposal, threshold) =
+				<NextExternal<T>>::get().ok_or(Error::<T>::ProposalMissing)?;
+			ensure!(
+				threshold != VoteThreshold::SuperMajorityApprove,
+				Error::<T>::NotSimpleMajority,
+			);
+			ensure!(proposal_hash == ext_proposal.hash(), Error::<T>::InvalidHash);
+
+			<NextExternal<T>>::kill();
+			let now = <frame_system::Pallet<T>>::block_number();
+			let ref_index = Self::inject_referendum(
+				now.saturating_add(voting_period),
+				ext_proposal,
+				threshold,
+				delay,
+			);
+			Self::transfer_metadata(MetadataOwner::External, MetadataOwner::Referendum(ref_index));
+			Ok(())
+		}
+
+		/// Veto and blacklist the external proposal hash.
+		///
+		/// The dispatch origin of this call must be `VetoOrigin`.
+		///
+		/// - `proposal_hash`: The preimage hash of the proposal to veto and blacklist.
+		///
+		/// Emits `Vetoed`.
+		///
+		/// Weight: `O(V + log(V))` where V is number of `existing vetoers`
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::veto_external())]
+		pub fn veto_external(origin: OriginFor<T>, proposal_hash: H256) -> DispatchResult {
+			let who = T::VetoOrigin::ensure_origin(origin)?;
+
+			if let Some((ext_proposal, _)) = NextExternal::<T>::get() {
+				ensure!(proposal_hash == ext_proposal.hash(), Error::<T>::ProposalMissing);
+			} else {
+				return Err(Error::<T>::NoProposal.into())
+			}
+
+			let mut existing_vetoers =
+				<Blacklist<T>>::get(&proposal_hash).map(|pair| pair.1).unwrap_or_default();
+			let insert_position =
+				existing_vetoers.binary_search(&who).err().ok_or(Error::<T>::AlreadyVetoed)?;
+			existing_vetoers
+				.try_insert(insert_position, who.clone())
+				.map_err(|_| Error::<T>::TooMany)?;
+
+			let until =
+				<frame_system::Pallet<T>>::block_number().saturating_add(T::CooloffPeriod::get());
+			<Blacklist<T>>::insert(&proposal_hash, (until, existing_vetoers));
+
+			Self::deposit_event(Event::<T>::Vetoed { who, proposal_hash, until });
+			<NextExternal<T>>::kill();
+			Self::clear_metadata(MetadataOwner::External);
+			Ok(())
+		}
+
+		/// Remove a referendum.
+		///
+		/// The dispatch origin of this call must be _Root_.
+		///
+		/// - `ref_index`: The index of the referendum to cancel.
+		///
+		/// # Weight: `O(1)`.
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::cancel_referendum())]
+		pub fn cancel_referendum(
+			origin: OriginFor<T>,
+			#[pallet::compact] ref_index: ReferendumIndex,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::internal_cancel_referendum(ref_index);
+			Ok(())
+		}
+
+		/// Delegate the voting power (with some given conviction) of the sending account.
+		///
+		/// The balance delegated is locked for as long as it's delegated, and thereafter for the
+		/// time appropriate for the conviction's lock period.
+		///
+		/// The dispatch origin of this call must be _Signed_, and the signing account must either:
+		///   - be delegating already; or
+		///   - have no voting activity (if there is, then it will need to be removed/consolidated
+		///     through `reap_vote` or `unvote`).
+		///
+		/// - `to`: The account whose voting the `target` account's voting power will follow.
+		/// - `conviction`: The conviction that will be attached to the delegated votes. When the
+		///   account is undelegated, the funds will be locked for the corresponding period.
+		/// - `balance`: The amount of the account's balance to be used in delegating. This must not
+		///   be more than the account's current balance.
+		///
+		/// Emits `Delegated`.
+		///
+		/// Weight: `O(R)` where R is the number of referendums the voter delegating to has
+		///   voted on. Weight is charged as if maximum votes.
+		// NOTE: weight must cover an incorrect voting of origin with max votes, this is ensure
+		// because a valid delegation cover decoding a direct voting with max votes.
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::delegate(T::MaxVotes::get()))]
+		pub fn delegate(
+			origin: OriginFor<T>,
+			to: AccountIdLookupOf<T>,
+			conviction: Conviction,
+			balance: BalanceOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let to = T::Lookup::lookup(to)?;
+			let votes = Self::try_delegate(who, to, conviction, balance)?;
+
+			Ok(Some(T::WeightInfo::delegate(votes)).into())
+		}
+
+		/// Undelegate the voting power of the sending account.
+		///
+		/// Tokens may be unlocked following once an amount of time consistent with the lock period
+		/// of the conviction with which the delegation was issued.
+		///
+		/// The dispatch origin of this call must be _Signed_ and the signing account must be
+		/// currently delegating.
+		///
+		/// Emits `Undelegated`.
+		///
+		/// Weight: `O(R)` where R is the number of referendums the voter delegating to has
+		///   voted on. Weight is charged as if maximum votes.
+		// NOTE: weight must cover an incorrect voting of origin with max votes, this is ensure
+		// because a valid delegation cover decoding a direct voting with max votes.
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::undelegate(T::MaxVotes::get()))]
+		pub fn undelegate(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let votes = Self::try_undelegate(who)?;
+			Ok(Some(T::WeightInfo::undelegate(votes)).into())
+		}
+
+		/// Clears all public proposals.
+		///
+		/// The dispatch origin of this call must be _Root_.
+		///
+		/// Weight: `O(1)`.
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::clear_public_proposals())]
+		pub fn clear_public_proposals(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+			<PublicProps<T>>::kill();
+			Ok(())
+		}
+
+		/// Unlock tokens that have an expired lock.
+		///
+		/// The dispatch origin of this call must be _Signed_.
+		///
+		/// - `target`: The account to remove the lock on.
+		///
+		/// Weight: `O(R)` with R number of vote of target.
+		#[pallet::call_index(13)]
+		#[pallet::weight(T::WeightInfo::unlock_set(T::MaxVotes::get()).max(T::WeightInfo::unlock_remove(T::MaxVotes::get())))]
+		pub fn unlock(origin: OriginFor<T>, target: AccountIdLookupOf<T>) -> DispatchResult {
+			ensure_signed(origin)?;
+			let target = T::Lookup::lookup(target)?;
+			Self::update_lock(&target);
+			Ok(())
+		}
+
+		/// Remove a vote for a referendum.
+		///
+		/// If:
+		/// - the referendum was cancelled, or
+		/// - the referendum is ongoing, or
+		/// - the referendum has ended such that
+		///   - the vote of the account was in opposition to the result; or
+		///   - there was no conviction to the account's vote; or
+		///   - the account made a split vote
+		/// ...then the vote is removed cleanly and a following call to `unlock` may result in more
+		/// funds being available.
+		///
+		/// If, however, the referendum has ended and:
+		/// - it finished corresponding to the vote of the account, and
+		/// - the account made a standard vote with conviction, and
+		/// - the lock period of the conviction is not over
+		/// ...then the lock will be aggregated into the overall account's lock, which may involve
+		/// *overlocking* (where the two locks are combined into a single lock that is the maximum
+		/// of both the amount locked and the time is it locked for).
+		///
+		/// The dispatch origin of this call must be _Signed_, and the signer must have a vote
+		/// registered for referendum `index`.
+		///
+		/// - `index`: The index of referendum of the vote to be removed.
+		///
+		/// Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on.
+		///   Weight is calculated for the maximum number of vote.
+		#[pallet::call_index(14)]
+		#[pallet::weight(T::WeightInfo::remove_vote(T::MaxVotes::get()))]
+		pub fn remove_vote(origin: OriginFor<T>, index: ReferendumIndex) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::try_remove_vote(&who, index, UnvoteScope::Any)
+		}
+
+		/// Remove a vote for a referendum.
+		///
+		/// If the `target` is equal to the signer, then this function is exactly equivalent to
+		/// `remove_vote`. If not equal to the signer, then the vote must have expired,
+		/// either because the referendum was cancelled, because the voter lost the referendum or
+		/// because the conviction period is over.
+		///
+		/// The dispatch origin of this call must be _Signed_.
+		///
+		/// - `target`: The account of the vote to be removed; this account must have voted for
+		///   referendum `index`.
+		/// - `index`: The index of referendum of the vote to be removed.
+		///
+		/// Weight: `O(R + log R)` where R is the number of referenda that `target` has voted on.
+		///   Weight is calculated for the maximum number of vote.
+		#[pallet::call_index(15)]
+		#[pallet::weight(T::WeightInfo::remove_other_vote(T::MaxVotes::get()))]
+		pub fn remove_other_vote(
+			origin: OriginFor<T>,
+			target: AccountIdLookupOf<T>,
+			index: ReferendumIndex,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let target = T::Lookup::lookup(target)?;
+			let scope = if target == who { UnvoteScope::Any } else { UnvoteScope::OnlyExpired };
+			Self::try_remove_vote(&target, index, scope)?;
+			Ok(())
+		}
+
+		/// Permanently place a proposal into the blacklist. This prevents it from ever being
+		/// proposed again.
+		///
+		/// If called on a queued public or external proposal, then this will result in it being
+		/// removed. If the `ref_index` supplied is an active referendum with the proposal hash,
+		/// then it will be cancelled.
+		///
+		/// The dispatch origin of this call must be `BlacklistOrigin`.
+		///
+		/// - `proposal_hash`: The proposal hash to blacklist permanently.
+		/// - `ref_index`: An ongoing referendum whose hash is `proposal_hash`, which will be
+		/// cancelled.
+		///
+		/// Weight: `O(p)` (though as this is an high-privilege dispatch, we assume it has a
+		///   reasonable value).
+		#[pallet::call_index(16)]
+		#[pallet::weight((T::WeightInfo::blacklist(), DispatchClass::Operational))]
+		pub fn blacklist(
+			origin: OriginFor<T>,
+			proposal_hash: H256,
+			maybe_ref_index: Option<ReferendumIndex>,
+		) -> DispatchResult {
+			T::BlacklistOrigin::ensure_origin(origin)?;
+
+			// Insert the proposal into the blacklist.
+			let permanent =
+				(BlockNumberFor::<T>::max_value(), BoundedVec::<T::AccountId, _>::default());
+			Blacklist::<T>::insert(&proposal_hash, permanent);
+
+			// Remove the queued proposal, if it's there.
+			PublicProps::<T>::mutate(|props| {
+				if let Some(index) = props.iter().position(|p| p.1.hash() == proposal_hash) {
+					let (prop_index, ..) = props.remove(index);
+					if let Some((whos, amount)) = DepositOf::<T>::take(prop_index) {
+						for who in whos.into_iter() {
+							T::Slash::on_unbalanced(T::Currency::slash_reserved(&who, amount).0);
+						}
+					}
+					Self::clear_metadata(MetadataOwner::Proposal(prop_index));
+				}
+			});
+
+			// Remove the external queued referendum, if it's there.
+			if matches!(NextExternal::<T>::get(), Some((p, ..)) if p.hash() == proposal_hash) {
+				NextExternal::<T>::kill();
+				Self::clear_metadata(MetadataOwner::External);
+			}
+
+			// Remove the referendum, if it's there.
+			if let Some(ref_index) = maybe_ref_index {
+				if let Ok(status) = Self::referendum_status(ref_index) {
+					if status.proposal.hash() == proposal_hash {
+						Self::internal_cancel_referendum(ref_index);
+					}
+				}
+			}
+
+			Self::deposit_event(Event::<T>::Blacklisted { proposal_hash });
+			Ok(())
+		}
+
+		/// Remove a proposal.
+		///
+		/// The dispatch origin of this call must be `CancelProposalOrigin`.
+		///
+		/// - `prop_index`: The index of the proposal to cancel.
+		///
+		/// Weight: `O(p)` where `p = PublicProps::<T>::decode_len()`
+		#[pallet::call_index(17)]
+		#[pallet::weight(T::WeightInfo::cancel_proposal())]
+		pub fn cancel_proposal(
+			origin: OriginFor<T>,
+			#[pallet::compact] prop_index: PropIndex,
+		) -> DispatchResult {
+			T::CancelProposalOrigin::ensure_origin(origin)?;
+
+			PublicProps::<T>::mutate(|props| props.retain(|p| p.0 != prop_index));
+			if let Some((whos, amount)) = DepositOf::<T>::take(prop_index) {
+				for who in whos.into_iter() {
+					T::Slash::on_unbalanced(T::Currency::slash_reserved(&who, amount).0);
+				}
+			}
+			Self::deposit_event(Event::<T>::ProposalCanceled { prop_index });
+			Self::clear_metadata(MetadataOwner::Proposal(prop_index));
+			Ok(())
+		}
+
+		/// Set or clear a metadata of a proposal or a referendum.
+		///
+		/// Parameters:
+		/// - `origin`: Must correspond to the `MetadataOwner`.
+		///     - `ExternalOrigin` for an external proposal with the `SuperMajorityApprove`
+		///       threshold.
+		///     - `ExternalDefaultOrigin` for an external proposal with the `SuperMajorityAgainst`
+		///       threshold.
+		///     - `ExternalMajorityOrigin` for an external proposal with the `SimpleMajority`
+		///       threshold.
+		///     - `Signed` by a creator for a public proposal.
+		///     - `Signed` to clear a metadata for a finished referendum.
+		///     - `Root` to set a metadata for an ongoing referendum.
+		/// - `owner`: an identifier of a metadata owner.
+		/// - `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.
+		#[pallet::call_index(18)]
+		#[pallet::weight(
+			match (owner, maybe_hash) {
+				(MetadataOwner::External, Some(_)) => T::WeightInfo::set_external_metadata(),
+				(MetadataOwner::External, None) => T::WeightInfo::clear_external_metadata(),
+				(MetadataOwner::Proposal(_), Some(_)) => T::WeightInfo::set_proposal_metadata(),
+				(MetadataOwner::Proposal(_), None) => T::WeightInfo::clear_proposal_metadata(),
+				(MetadataOwner::Referendum(_), Some(_)) => T::WeightInfo::set_referendum_metadata(),
+				(MetadataOwner::Referendum(_), None) => T::WeightInfo::clear_referendum_metadata(),
+			}
+		)]
+		pub fn set_metadata(
+			origin: OriginFor<T>,
+			owner: MetadataOwner,
+			maybe_hash: Option<PreimageHash>,
+		) -> DispatchResult {
+			match owner {
+				MetadataOwner::External => {
+					let (_, threshold) = <NextExternal<T>>::get().ok_or(Error::<T>::NoProposal)?;
+					Self::ensure_external_origin(threshold, origin)?;
+				},
+				MetadataOwner::Proposal(index) => {
+					let who = ensure_signed(origin)?;
+					let (_, _, proposer) = Self::proposal(index)?;
+					ensure!(proposer == who, Error::<T>::NoPermission);
+				},
+				MetadataOwner::Referendum(index) => {
+					let is_root = ensure_signed_or_root(origin)?.is_none();
+					ensure!(is_root || maybe_hash.is_none(), Error::<T>::NoPermission);
+					ensure!(
+						is_root || Self::referendum_status(index).is_err(),
+						Error::<T>::NoPermission
+					);
+				},
+			}
+			if let Some(hash) = maybe_hash {
+				ensure!(T::Preimages::len(&hash).is_some(), Error::<T>::PreimageNotExist);
+				MetadataOf::<T>::insert(owner.clone(), hash);
+				Self::deposit_event(Event::<T>::MetadataSet { owner, hash });
+			} else {
+				Self::clear_metadata(owner);
+			}
+			Ok(())
+		}
+	}
+}
+
+pub trait EncodeInto: Encode {
+	fn encode_into<T: AsMut<[u8]> + Default>(&self) -> T {
+		let mut t = T::default();
+		self.using_encoded(|data| {
+			if data.len() <= t.as_mut().len() {
+				t.as_mut()[0..data.len()].copy_from_slice(data);
+			} else {
+				// encoded self is too big to fit into a T. hash it and use the first bytes of that
+				// instead.
+				let hash = sp_io::hashing::blake2_256(data);
+				let l = t.as_mut().len().min(hash.len());
+				t.as_mut()[0..l].copy_from_slice(&hash[0..l]);
+			}
+		});
+		t
+	}
+}
+impl<T: Encode> EncodeInto for T {}
+
+impl<T: Config> Pallet<T> {
+	// exposed immutables.
+
+	/// Get the amount locked in support of `proposal`; `None` if proposal isn't a valid proposal
+	/// index.
+	pub fn backing_for(proposal: PropIndex) -> Option<BalanceOf<T>> {
+		Self::deposit_of(proposal).map(|(l, d)| d.saturating_mul((l.len() as u32).into()))
+	}
+
+	/// Get all referenda ready for tally at block `n`.
+	pub fn maturing_referenda_at(
+		n: BlockNumberFor<T>,
+	) -> Vec<(ReferendumIndex, ReferendumStatus<BlockNumberFor<T>, BoundedCallOf<T>, BalanceOf<T>>)>
+	{
+		let next = Self::lowest_unbaked();
+		let last = Self::referendum_count();
+		Self::maturing_referenda_at_inner(n, next..last)
+	}
+
+	fn maturing_referenda_at_inner(
+		n: BlockNumberFor<T>,
+		range: core::ops::Range<PropIndex>,
+	) -> Vec<(ReferendumIndex, ReferendumStatus<BlockNumberFor<T>, BoundedCallOf<T>, BalanceOf<T>>)>
+	{
+		range
+			.into_iter()
+			.map(|i| (i, Self::referendum_info(i)))
+			.filter_map(|(i, maybe_info)| match maybe_info {
+				Some(ReferendumInfo::Ongoing(status)) => Some((i, status)),
+				_ => None,
+			})
+			.filter(|(_, status)| status.end == n)
+			.collect()
+	}
+
+	// Exposed mutables.
+
+	/// Start a referendum.
+	pub fn internal_start_referendum(
+		proposal: BoundedCallOf<T>,
+		threshold: VoteThreshold,
+		delay: BlockNumberFor<T>,
+	) -> ReferendumIndex {
+		<Pallet<T>>::inject_referendum(
+			<frame_system::Pallet<T>>::block_number().saturating_add(T::VotingPeriod::get()),
+			proposal,
+			threshold,
+			delay,
+		)
+	}
+
+	/// Remove a referendum.
+	pub fn internal_cancel_referendum(ref_index: ReferendumIndex) {
+		Self::deposit_event(Event::<T>::Cancelled { ref_index });
+		ReferendumInfoOf::<T>::remove(ref_index);
+		Self::clear_metadata(MetadataOwner::Referendum(ref_index));
+	}
+
+	// private.
+
+	/// Ok if the given referendum is active, Err otherwise
+	fn ensure_ongoing(
+		r: ReferendumInfo<BlockNumberFor<T>, BoundedCallOf<T>, BalanceOf<T>>,
+	) -> Result<ReferendumStatus<BlockNumberFor<T>, BoundedCallOf<T>, BalanceOf<T>>, DispatchError>
+	{
+		match r {
+			ReferendumInfo::Ongoing(s) => Ok(s),
+			_ => Err(Error::<T>::ReferendumInvalid.into()),
+		}
+	}
+
+	fn referendum_status(
+		ref_index: ReferendumIndex,
+	) -> Result<ReferendumStatus<BlockNumberFor<T>, BoundedCallOf<T>, BalanceOf<T>>, DispatchError>
+	{
+		let info = ReferendumInfoOf::<T>::get(ref_index).ok_or(Error::<T>::ReferendumInvalid)?;
+		Self::ensure_ongoing(info)
+	}
+
+	/// Actually enact a vote, if legit.
+	fn try_vote(
+		who: &T::AccountId,
+		ref_index: ReferendumIndex,
+		vote: AccountVote<BalanceOf<T>>,
+	) -> DispatchResult {
+		let mut status = Self::referendum_status(ref_index)?;
+		ensure!(vote.balance() <= T::Currency::free_balance(who), Error::<T>::InsufficientFunds);
+		VotingOf::<T>::try_mutate(who, |voting| -> DispatchResult {
+			if let Voting::Direct { ref mut votes, delegations, .. } = voting {
+				match votes.binary_search_by_key(&ref_index, |i| i.0) {
+					Ok(i) => {
+						// Shouldn't be possible to fail, but we handle it gracefully.
+						status.tally.remove(votes[i].1).ok_or(ArithmeticError::Underflow)?;
+						if let Some(approve) = votes[i].1.as_standard() {
+							status.tally.reduce(approve, *delegations);
+						}
+						votes[i].1 = vote;
+					},
+					Err(i) => {
+						votes
+							.try_insert(i, (ref_index, vote))
+							.map_err(|_| Error::<T>::MaxVotesReached)?;
+					},
+				}
+				Self::deposit_event(Event::<T>::Voted { voter: who.clone(), ref_index, vote });
+				// Shouldn't be possible to fail, but we handle it gracefully.
+				status.tally.add(vote).ok_or(ArithmeticError::Overflow)?;
+				if let Some(approve) = vote.as_standard() {
+					status.tally.increase(approve, *delegations);
+				}
+				Ok(())
+			} else {
+				Err(Error::<T>::AlreadyDelegating.into())
+			}
+		})?;
+		// Extend the lock to `balance` (rather than setting it) since we don't know what other
+		// votes are in place.
+		T::Currency::extend_lock(
+			DEMOCRACY_ID,
+			who,
+			vote.balance(),
+			WithdrawReasons::except(WithdrawReasons::RESERVE),
+		);
+		ReferendumInfoOf::<T>::insert(ref_index, ReferendumInfo::Ongoing(status));
+		Ok(())
+	}
+
+	/// Remove the account's vote for the given referendum if possible. This is possible when:
+	/// - The referendum has not finished.
+	/// - The referendum has finished and the voter lost their direction.
+	/// - The referendum has finished and the voter's lock period is up.
+	///
+	/// This will generally be combined with a call to `unlock`.
+	fn try_remove_vote(
+		who: &T::AccountId,
+		ref_index: ReferendumIndex,
+		scope: UnvoteScope,
+	) -> DispatchResult {
+		let info = ReferendumInfoOf::<T>::get(ref_index);
+		VotingOf::<T>::try_mutate(who, |voting| -> DispatchResult {
+			if let Voting::Direct { ref mut votes, delegations, ref mut prior } = voting {
+				let i = votes
+					.binary_search_by_key(&ref_index, |i| i.0)
+					.map_err(|_| Error::<T>::NotVoter)?;
+				match info {
+					Some(ReferendumInfo::Ongoing(mut status)) => {
+						ensure!(matches!(scope, UnvoteScope::Any), Error::<T>::NoPermission);
+						// Shouldn't be possible to fail, but we handle it gracefully.
+						status.tally.remove(votes[i].1).ok_or(ArithmeticError::Underflow)?;
+						if let Some(approve) = votes[i].1.as_standard() {
+							status.tally.reduce(approve, *delegations);
+						}
+						ReferendumInfoOf::<T>::insert(ref_index, ReferendumInfo::Ongoing(status));
+					},
+					Some(ReferendumInfo::Finished { end, approved }) => {
+						if let Some((lock_periods, balance)) = votes[i].1.locked_if(approved) {
+							let unlock_at = end.saturating_add(
+								T::VoteLockingPeriod::get().saturating_mul(lock_periods.into()),
+							);
+							let now = frame_system::Pallet::<T>::block_number();
+							if now < unlock_at {
+								ensure!(
+									matches!(scope, UnvoteScope::Any),
+									Error::<T>::NoPermission
+								);
+								prior.accumulate(unlock_at, balance)
+							}
+						}
+					},
+					None => {}, // Referendum was cancelled.
+				}
+				votes.remove(i);
+			}
+			Ok(())
+		})?;
+		Ok(())
+	}
+
+	/// Return the number of votes for `who`
+	fn increase_upstream_delegation(who: &T::AccountId, amount: Delegations<BalanceOf<T>>) -> u32 {
+		VotingOf::<T>::mutate(who, |voting| match voting {
+			Voting::Delegating { delegations, .. } => {
+				// We don't support second level delegating, so we don't need to do anything more.
+				*delegations = delegations.saturating_add(amount);
+				1
+			},
+			Voting::Direct { votes, delegations, .. } => {
+				*delegations = delegations.saturating_add(amount);
+				for &(ref_index, account_vote) in votes.iter() {
+					if let AccountVote::Standard { vote, .. } = account_vote {
+						ReferendumInfoOf::<T>::mutate(ref_index, |maybe_info| {
+							if let Some(ReferendumInfo::Ongoing(ref mut status)) = maybe_info {
+								status.tally.increase(vote.aye, amount);
+							}
+						});
+					}
+				}
+				votes.len() as u32
+			},
+		})
+	}
+
+	/// Return the number of votes for `who`
+	fn reduce_upstream_delegation(who: &T::AccountId, amount: Delegations<BalanceOf<T>>) -> u32 {
+		VotingOf::<T>::mutate(who, |voting| match voting {
+			Voting::Delegating { delegations, .. } => {
+				// We don't support second level delegating, so we don't need to do anything more.
+				*delegations = delegations.saturating_sub(amount);
+				1
+			},
+			Voting::Direct { votes, delegations, .. } => {
+				*delegations = delegations.saturating_sub(amount);
+				for &(ref_index, account_vote) in votes.iter() {
+					if let AccountVote::Standard { vote, .. } = account_vote {
+						ReferendumInfoOf::<T>::mutate(ref_index, |maybe_info| {
+							if let Some(ReferendumInfo::Ongoing(ref mut status)) = maybe_info {
+								status.tally.reduce(vote.aye, amount);
+							}
+						});
+					}
+				}
+				votes.len() as u32
+			},
+		})
+	}
+
+	/// Attempt to delegate `balance` times `conviction` of voting power from `who` to `target`.
+	///
+	/// Return the upstream number of votes.
+	fn try_delegate(
+		who: T::AccountId,
+		target: T::AccountId,
+		conviction: Conviction,
+		balance: BalanceOf<T>,
+	) -> Result<u32, DispatchError> {
+		ensure!(who != target, Error::<T>::Nonsense);
+		ensure!(balance <= T::Currency::free_balance(&who), Error::<T>::InsufficientFunds);
+		let votes = VotingOf::<T>::try_mutate(&who, |voting| -> Result<u32, DispatchError> {
+			let mut old = Voting::Delegating {
+				balance,
+				target: target.clone(),
+				conviction,
+				delegations: Default::default(),
+				prior: Default::default(),
+			};
+			sp_std::mem::swap(&mut old, voting);
+			match old {
+				Voting::Delegating {
+					balance, target, conviction, delegations, mut prior, ..
+				} => {
+					// remove any delegation votes to our current target.
+					Self::reduce_upstream_delegation(&target, conviction.votes(balance));
+					let now = frame_system::Pallet::<T>::block_number();
+					let lock_periods = conviction.lock_periods().into();
+					let unlock_block = now
+						.saturating_add(T::VoteLockingPeriod::get().saturating_mul(lock_periods));
+					prior.accumulate(unlock_block, balance);
+					voting.set_common(delegations, prior);
+				},
+				Voting::Direct { votes, delegations, prior } => {
+					// here we just ensure that we're currently idling with no votes recorded.
+					ensure!(votes.is_empty(), Error::<T>::VotesExist);
+					voting.set_common(delegations, prior);
+				},
+			}
+			let votes = Self::increase_upstream_delegation(&target, conviction.votes(balance));
+			// Extend the lock to `balance` (rather than setting it) since we don't know what other
+			// votes are in place.
+			T::Currency::extend_lock(
+				DEMOCRACY_ID,
+				&who,
+				balance,
+				WithdrawReasons::except(WithdrawReasons::RESERVE),
+			);
+			Ok(votes)
+		})?;
+		Self::deposit_event(Event::<T>::Delegated { who, target });
+		Ok(votes)
+	}
+
+	/// Attempt to end the current delegation.
+	///
+	/// Return the number of votes of upstream.
+	fn try_undelegate(who: T::AccountId) -> Result<u32, DispatchError> {
+		let votes = VotingOf::<T>::try_mutate(&who, |voting| -> Result<u32, DispatchError> {
+			let mut old = Voting::default();
+			sp_std::mem::swap(&mut old, voting);
+			match old {
+				Voting::Delegating { balance, target, conviction, delegations, mut prior } => {
+					// remove any delegation votes to our current target.
+					let votes =
+						Self::reduce_upstream_delegation(&target, conviction.votes(balance));
+					let now = frame_system::Pallet::<T>::block_number();
+					let lock_periods = conviction.lock_periods().into();
+					let unlock_block = now
+						.saturating_add(T::VoteLockingPeriod::get().saturating_mul(lock_periods));
+					prior.accumulate(unlock_block, balance);
+					voting.set_common(delegations, prior);
+
+					Ok(votes)
+				},
+				Voting::Direct { .. } => Err(Error::<T>::NotDelegating.into()),
+			}
+		})?;
+		Self::deposit_event(Event::<T>::Undelegated { account: who });
+		Ok(votes)
+	}
+
+	/// Rejig the lock on an account. It will never get more stringent (since that would indicate
+	/// a security hole) but may be reduced from what they are currently.
+	fn update_lock(who: &T::AccountId) {
+		let lock_needed = VotingOf::<T>::mutate(who, |voting| {
+			voting.rejig(frame_system::Pallet::<T>::block_number());
+			voting.locked_balance()
+		});
+		if lock_needed.is_zero() {
+			T::Currency::remove_lock(DEMOCRACY_ID, who);
+		} else {
+			T::Currency::set_lock(
+				DEMOCRACY_ID,
+				who,
+				lock_needed,
+				WithdrawReasons::except(WithdrawReasons::RESERVE),
+			);
+		}
+	}
+
+	/// Start a referendum
+	fn inject_referendum(
+		end: BlockNumberFor<T>,
+		proposal: BoundedCallOf<T>,
+		threshold: VoteThreshold,
+		delay: BlockNumberFor<T>,
+	) -> ReferendumIndex {
+		let ref_index = Self::referendum_count();
+		ReferendumCount::<T>::put(ref_index + 1);
+		let status =
+			ReferendumStatus { end, proposal, threshold, delay, tally: Default::default() };
+		let item = ReferendumInfo::Ongoing(status);
+		<ReferendumInfoOf<T>>::insert(ref_index, item);
+		Self::deposit_event(Event::<T>::Started { ref_index, threshold });
+		ref_index
+	}
+
+	/// Table the next waiting proposal for a vote.
+	fn launch_next(now: BlockNumberFor<T>) -> DispatchResult {
+		if LastTabledWasExternal::<T>::take() {
+			Self::launch_public(now).or_else(|_| Self::launch_external(now))
+		} else {
+			Self::launch_external(now).or_else(|_| Self::launch_public(now))
+		}
+		.map_err(|_| Error::<T>::NoneWaiting.into())
+	}
+
+	/// Table the waiting external proposal for a vote, if there is one.
+	fn launch_external(now: BlockNumberFor<T>) -> DispatchResult {
+		if let Some((proposal, threshold)) = <NextExternal<T>>::take() {
+			LastTabledWasExternal::<T>::put(true);
+			Self::deposit_event(Event::<T>::ExternalTabled);
+			let ref_index = Self::inject_referendum(
+				now.saturating_add(T::VotingPeriod::get()),
+				proposal,
+				threshold,
+				T::EnactmentPeriod::get(),
+			);
+			Self::transfer_metadata(MetadataOwner::External, MetadataOwner::Referendum(ref_index));
+			Ok(())
+		} else {
+			return Err(Error::<T>::NoneWaiting.into())
+		}
+	}
+
+	/// Table the waiting public proposal with the highest backing for a vote.
+	fn launch_public(now: BlockNumberFor<T>) -> DispatchResult {
+		let mut public_props = Self::public_props();
+		if let Some((winner_index, _)) = public_props.iter().enumerate().max_by_key(
+			// defensive only: All current public proposals have an amount locked
+			|x| Self::backing_for((x.1).0).defensive_unwrap_or_else(Zero::zero),
+		) {
+			let (prop_index, proposal, _) = public_props.swap_remove(winner_index);
+			<PublicProps<T>>::put(public_props);
+
+			if let Some((depositors, deposit)) = <DepositOf<T>>::take(prop_index) {
+				// refund depositors
+				for d in depositors.iter() {
+					T::Currency::unreserve(d, deposit);
+				}
+				Self::deposit_event(Event::<T>::Tabled { proposal_index: prop_index, deposit });
+				let ref_index = Self::inject_referendum(
+					now.saturating_add(T::VotingPeriod::get()),
+					proposal,
+					VoteThreshold::SuperMajorityApprove,
+					T::EnactmentPeriod::get(),
+				);
+				Self::transfer_metadata(
+					MetadataOwner::Proposal(prop_index),
+					MetadataOwner::Referendum(ref_index),
+				)
+			}
+			Ok(())
+		} else {
+			return Err(Error::<T>::NoneWaiting.into())
+		}
+	}
+
+	fn bake_referendum(
+		now: BlockNumberFor<T>,
+		index: ReferendumIndex,
+		status: ReferendumStatus<BlockNumberFor<T>, BoundedCallOf<T>, BalanceOf<T>>,
+	) -> bool {
+		let total_issuance = T::Currency::total_issuance();
+		let approved = status.threshold.approved(status.tally, total_issuance);
+
+		if approved {
+			Self::deposit_event(Event::<T>::Passed { ref_index: index });
+
+			// Earliest it can be scheduled for is next block.
+			let when = now.saturating_add(status.delay.max(One::one()));
+			if T::Scheduler::schedule_named(
+				(DEMOCRACY_ID, index).encode_into(),
+				DispatchTime::At(when),
+				None,
+				63,
+				frame_system::RawOrigin::Root.into(),
+				status.proposal,
+			)
+			.is_err()
+			{
+				frame_support::print("LOGIC ERROR: bake_referendum/schedule_named failed");
+			}
+		} else {
+			Self::deposit_event(Event::<T>::NotPassed { ref_index: index });
+		}
+
+		approved
+	}
+
+	/// Current era is ending; we should finish up any proposals.
+	///
+	///
+	/// ## Complexity:
+	/// If a referendum is launched or maturing, this will take full block weight if queue is not
+	/// empty. Otherwise, `O(R)` where `R` is the number of unbaked referenda.
+	fn begin_block(now: BlockNumberFor<T>) -> Weight {
+		let max_block_weight = T::BlockWeights::get().max_block;
+		let mut weight = Weight::zero();
+
+		let next = Self::lowest_unbaked();
+		let last = Self::referendum_count();
+		let r = last.saturating_sub(next);
+
+		// pick out another public referendum if it's time.
+		if (now % T::LaunchPeriod::get()).is_zero() {
+			// Errors come from the queue being empty. If the queue is not empty, it will take
+			// full block weight.
+			if Self::launch_next(now).is_ok() {
+				weight = max_block_weight;
+			} else {
+				weight.saturating_accrue(T::WeightInfo::on_initialize_base_with_launch_period(r));
+			}
+		} else {
+			weight.saturating_accrue(T::WeightInfo::on_initialize_base(r));
+		}
+
+		// tally up votes for any expiring referenda.
+		for (index, info) in Self::maturing_referenda_at_inner(now, next..last).into_iter() {
+			let approved = Self::bake_referendum(now, index, info);
+			ReferendumInfoOf::<T>::insert(index, ReferendumInfo::Finished { end: now, approved });
+			weight = max_block_weight;
+		}
+
+		// Notes:
+		// * We don't consider the lowest unbaked to be the last maturing in case some referenda
+		//   have a longer voting period than others.
+		// * The iteration here shouldn't trigger any storage read that are not in cache, due to
+		//   `maturing_referenda_at_inner` having already read them.
+		// * We shouldn't iterate more than `LaunchPeriod/VotingPeriod + 1` times because the number
+		//   of unbaked referendum is bounded by this number. In case those number have changed in a
+		//   runtime upgrade the formula should be adjusted but the bound should still be sensible.
+		<LowestUnbaked<T>>::mutate(|ref_index| {
+			while *ref_index < last &&
+				Self::referendum_info(*ref_index)
+					.map_or(true, |info| matches!(info, ReferendumInfo::Finished { .. }))
+			{
+				*ref_index += 1
+			}
+		});
+
+		weight
+	}
+
+	/// Reads the length of account in DepositOf without getting the complete value in the runtime.
+	///
+	/// Return 0 if no deposit for this proposal.
+	fn len_of_deposit_of(proposal: PropIndex) -> Option<u32> {
+		// DepositOf first tuple element is a vec, decoding its len is equivalent to decode a
+		// `Compact<u32>`.
+		decode_compact_u32_at(&<DepositOf<T>>::hashed_key_for(proposal))
+	}
+
+	/// Return a proposal of an index.
+	fn proposal(index: PropIndex) -> Result<(PropIndex, BoundedCallOf<T>, T::AccountId), Error<T>> {
+		PublicProps::<T>::get()
+			.into_iter()
+			.find(|(prop_index, _, _)| prop_index == &index)
+			.ok_or(Error::<T>::ProposalMissing)
+	}
+
+	/// Clear metadata if exist for a given owner.
+	fn clear_metadata(owner: MetadataOwner) {
+		if let Some(hash) = MetadataOf::<T>::take(&owner) {
+			Self::deposit_event(Event::<T>::MetadataCleared { owner, hash });
+		}
+	}
+
+	/// Transfer the metadata of an `owner` to a `new_owner`.
+	fn transfer_metadata(owner: MetadataOwner, new_owner: MetadataOwner) {
+		if let Some(hash) = MetadataOf::<T>::take(&owner) {
+			MetadataOf::<T>::insert(&new_owner, hash);
+			Self::deposit_event(Event::<T>::MetadataTransferred {
+				prev_owner: owner,
+				owner: new_owner,
+				hash,
+			});
+		}
+	}
+
+	/// Ensure external origin for corresponding vote threshold.
+	fn ensure_external_origin(
+		threshold: VoteThreshold,
+		origin: OriginFor<T>,
+	) -> Result<(), BadOrigin> {
+		match threshold {
+			VoteThreshold::SuperMajorityApprove => {
+				let _ = T::ExternalOrigin::ensure_origin(origin)?;
+			},
+			VoteThreshold::SuperMajorityAgainst => {
+				let _ = T::ExternalDefaultOrigin::ensure_origin(origin)?;
+			},
+			VoteThreshold::SimpleMajority => {
+				let _ = T::ExternalMajorityOrigin::ensure_origin(origin)?;
+			},
+		};
+		Ok(())
+	}
+}
+
+/// Decode `Compact<u32>` from the trie at given key.
+fn decode_compact_u32_at(key: &[u8]) -> Option<u32> {
+	// `Compact<u32>` takes at most 5 bytes.
+	let mut buf = [0u8; 5];
+	let bytes = sp_io::storage::read(key, &mut buf, 0)?;
+	// The value may be smaller than 5 bytes.
+	let mut input = &buf[0..buf.len().min(bytes as usize)];
+	match codec::Compact::<u32>::decode(&mut input) {
+		Ok(c) => Some(c.0),
+		Err(_) => {
+			sp_runtime::print("Failed to decode compact u32 at:");
+			sp_runtime::print(key);
+			None
+		},
+	}
+}
diff --git a/substrate/frame/democracy/src/migrations/mod.rs b/substrate/frame/democracy/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3f77e03884edd4bf659aee5728a23926ce50ceda
--- /dev/null
+++ b/substrate/frame/democracy/src/migrations/mod.rs
@@ -0,0 +1,22 @@
+// 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.
+
+//! All migrations of this pallet.
+
+/// Migration to unlock and unreserve all pallet funds.
+pub mod unlock_and_unreserve_all_funds;
+
+/// V1 storage migrations for the preimage pallet.
+pub mod v1;
diff --git a/substrate/frame/democracy/src/migrations/unlock_and_unreserve_all_funds.rs b/substrate/frame/democracy/src/migrations/unlock_and_unreserve_all_funds.rs
new file mode 100644
index 0000000000000000000000000000000000000000..188c475f64d0ef3e55e6daf3f86f9423e93a4efa
--- /dev/null
+++ b/substrate/frame/democracy/src/migrations/unlock_and_unreserve_all_funds.rs
@@ -0,0 +1,430 @@
+// 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 migration that unreserves all deposit and unlocks all stake held in the context of this
+//! pallet.
+
+use crate::{PropIndex, Voting, DEMOCRACY_ID};
+use core::iter::Sum;
+use frame_support::{
+	pallet_prelude::ValueQuery,
+	storage_alias,
+	traits::{Currency, LockableCurrency, OnRuntimeUpgrade, ReservableCurrency},
+	weights::RuntimeDbWeight,
+	Parameter, Twox64Concat,
+};
+use sp_core::Get;
+use sp_runtime::{traits::Zero, BoundedVec, Saturating};
+use sp_std::{collections::btree_map::BTreeMap, vec::Vec};
+
+const LOG_TARGET: &str = "runtime::democracy::migrations::unlock_and_unreserve_all_funds";
+
+type BalanceOf<T> =
+	<<T as UnlockConfig>::Currency as Currency<<T as UnlockConfig>::AccountId>>::Balance;
+
+/// The configuration for [`UnlockAndUnreserveAllFunds`].
+pub trait UnlockConfig: 'static {
+	/// The account ID used in the runtime.
+	type AccountId: Parameter + Ord;
+	/// The currency type used in the runtime.
+	///
+	/// Should match the currency type previously used for the pallet, if applicable.
+	type Currency: LockableCurrency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
+	/// The name of the pallet as previously configured in
+	/// [`construct_runtime!`](frame_support::construct_runtime).
+	type PalletName: Get<&'static str>;
+	/// The maximum number of votes as configured previously in the runtime.
+	type MaxVotes: Get<u32>;
+	/// The maximum deposit as configured previously in the runtime.
+	type MaxDeposits: Get<u32>;
+	/// The DB weight as configured in the runtime to calculate the correct weight.
+	type DbWeight: Get<RuntimeDbWeight>;
+	/// The block number as configured in the runtime.
+	type BlockNumber: Parameter + Zero + Copy + Ord;
+}
+
+#[storage_alias(dynamic)]
+type DepositOf<T: UnlockConfig> = StorageMap<
+	<T as UnlockConfig>::PalletName,
+	Twox64Concat,
+	PropIndex,
+	(BoundedVec<<T as UnlockConfig>::AccountId, <T as UnlockConfig>::MaxDeposits>, BalanceOf<T>),
+>;
+
+#[storage_alias(dynamic)]
+type VotingOf<T: UnlockConfig> = StorageMap<
+	<T as UnlockConfig>::PalletName,
+	Twox64Concat,
+	<T as UnlockConfig>::AccountId,
+	Voting<
+		BalanceOf<T>,
+		<T as UnlockConfig>::AccountId,
+		<T as UnlockConfig>::BlockNumber,
+		<T as UnlockConfig>::MaxVotes,
+	>,
+	ValueQuery,
+>;
+
+/// A migration that unreserves all deposit and unlocks all stake held in the context of this
+/// pallet.
+///
+/// Useful to prevent funds from being locked up when the pallet is being deprecated.
+///
+/// The pallet should be made inoperable before this migration is run.
+///
+/// (See also [`RemovePallet`][frame_support::migrations::RemovePallet])
+pub struct UnlockAndUnreserveAllFunds<T: UnlockConfig>(sp_std::marker::PhantomData<T>);
+
+impl<T: UnlockConfig> UnlockAndUnreserveAllFunds<T> {
+	/// Calculates and returns the total amounts reserved by each account by this pallet, and all
+	/// accounts with locks in the context of this pallet.
+	///
+	/// There is no need to return the amount locked, because the entire lock is removed (always
+	/// should be zero post-migration). We need to return the amounts reserved to check that the
+	/// reserved amount is deducted correctly.
+	///
+	/// # Returns
+	///
+	/// This function returns a tuple of two `BTreeMap` collections and the weight of the reads:
+	///
+	/// * `BTreeMap<T::AccountId, BalanceOf<T>>`: Map of account IDs to their respective total
+	///   reserved balance by this pallet
+	/// * `BTreeMap<T::AccountId, BalanceOf<T>>`: Map of account IDs to their respective total
+	///   locked balance by this pallet
+	/// * `frame_support::weights::Weight`: the weight consumed by this call.
+	fn get_account_deposits_and_locks() -> (
+		BTreeMap<T::AccountId, BalanceOf<T>>,
+		BTreeMap<T::AccountId, BalanceOf<T>>,
+		frame_support::weights::Weight,
+	) {
+		let mut deposit_of_len = 0;
+
+		// Get all deposits (reserved).
+		let mut total_voting_vec_entries: u64 = 0;
+		let account_deposits: BTreeMap<T::AccountId, BalanceOf<T>> = DepositOf::<T>::iter()
+			.flat_map(|(_prop_index, (accounts, balance))| {
+				// Count the number of deposits
+				deposit_of_len.saturating_inc();
+
+				// Track the total number of vec entries to calculate the weight of the reads.
+				total_voting_vec_entries.saturating_accrue(accounts.len() as u64);
+
+				// Create a vec of tuples where each account is associated with the given balance
+				accounts.into_iter().map(|account| (account, balance)).collect::<Vec<_>>()
+			})
+			.fold(BTreeMap::new(), |mut acc, (account, balance)| {
+				// Add the balance to the account's existing balance in the accumulator
+				acc.entry(account.clone()).or_insert(Zero::zero()).saturating_accrue(balance);
+				acc
+			});
+
+		// Voter accounts have amounts locked.
+		let account_stakes: BTreeMap<T::AccountId, BalanceOf<T>> = VotingOf::<T>::iter()
+			.map(|(account_id, voting)| (account_id, voting.locked_balance()))
+			.collect();
+		let voting_of_len = account_stakes.len() as u64;
+
+		(
+			account_deposits,
+			account_stakes,
+			T::DbWeight::get().reads(
+				deposit_of_len.saturating_add(voting_of_len).saturating_add(
+					// Max items in a Voting enum is MaxVotes + 5
+					total_voting_vec_entries
+						.saturating_mul(T::MaxVotes::get().saturating_add(5) as u64),
+				),
+			),
+		)
+	}
+}
+
+impl<T: UnlockConfig> OnRuntimeUpgrade for UnlockAndUnreserveAllFunds<T>
+where
+	BalanceOf<T>: Sum,
+{
+	/// Collects pre-migration data useful for validating the migration was successful, and also
+	/// checks the integrity of deposited and reserved balances.
+	///
+	/// Steps:
+	/// 1. Gets the deposited balances for each account stored in this pallet.
+	/// 2. Collects actual pre-migration reserved balances for each account.
+	/// 3. Checks the integrity of the deposited balances.
+	/// 4. Prints summary statistics about the state to be migrated.
+	/// 5. Encodes and returns pre-migration data to be used in post_upgrade.
+	///
+	/// Fails with a `TryRuntimeError` if somehow the amount reserved by this pallet is greater than
+	/// the actual total reserved amount for any accounts.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		use codec::Encode;
+		use sp_std::collections::btree_set::BTreeSet;
+
+		// Get staked and deposited balances as reported by this pallet.
+		let (account_deposits, account_locks, _) = Self::get_account_deposits_and_locks();
+
+		let all_accounts = account_deposits
+			.keys()
+			.chain(account_locks.keys())
+			.cloned()
+			.collect::<BTreeSet<_>>();
+		let account_reserved_before: BTreeMap<T::AccountId, BalanceOf<T>> = account_deposits
+			.keys()
+			.map(|account| (account.clone(), T::Currency::reserved_balance(&account)))
+			.collect();
+
+		// Total deposited for each account *should* be less than or equal to the total reserved,
+		// however this does not hold for all cases due to bugs in the reserve logic of this pallet.
+		let bugged_deposits = all_accounts
+			.iter()
+			.filter(|account| {
+				account_deposits.get(&account).unwrap_or(&Zero::zero()) >
+					account_reserved_before.get(&account).unwrap_or(&Zero::zero())
+			})
+			.count();
+
+		let total_deposits_to_unreserve =
+			account_deposits.clone().into_values().sum::<BalanceOf<T>>();
+		let total_stake_to_unlock = account_locks.clone().into_values().sum::<BalanceOf<T>>();
+
+		log::info!(target: LOG_TARGET, "Total accounts: {:?}", all_accounts.len());
+		log::info!(target: LOG_TARGET, "Total stake to unlock: {:?}", total_stake_to_unlock);
+		log::info!(
+			target: LOG_TARGET,
+			"Total deposit to unreserve: {:?}",
+			total_deposits_to_unreserve
+		);
+		log::info!(
+			target: LOG_TARGET,
+			"Bugged deposits: {}/{}",
+			bugged_deposits,
+			account_deposits.len()
+		);
+
+		Ok(account_reserved_before.encode())
+	}
+
+	/// Executes the migration.
+	///
+	/// Steps:
+	/// 1. Retrieves the deposit and accounts with locks for the pallet.
+	/// 2. Unreserves the deposited funds for each account.
+	/// 3. Unlocks the staked funds for each account.
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		// Get staked and deposited balances as reported by this pallet.
+		let (account_deposits, account_stakes, initial_reads) =
+			Self::get_account_deposits_and_locks();
+
+		// Deposited funds need to be unreserved.
+		for (account, unreserve_amount) in account_deposits.iter() {
+			if unreserve_amount.is_zero() {
+				log::warn!(target: LOG_TARGET, "Unexpected zero amount to unreserve!");
+				continue
+			}
+			T::Currency::unreserve(&account, *unreserve_amount);
+		}
+
+		// Staked funds need to be unlocked.
+		for account in account_stakes.keys() {
+			T::Currency::remove_lock(DEMOCRACY_ID, account);
+		}
+
+		T::DbWeight::get()
+			.reads_writes(
+				account_stakes.len().saturating_add(account_deposits.len()) as u64,
+				account_stakes.len().saturating_add(account_deposits.len()) as u64,
+			)
+			.saturating_add(initial_reads)
+	}
+
+	/// Performs post-upgrade sanity checks:
+	///
+	/// 1. No locks remain for this pallet in Balances.
+	/// 2. The reserved balance for each account has been reduced by the expected amount.
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(
+		account_reserved_before_bytes: Vec<u8>,
+	) -> Result<(), sp_runtime::TryRuntimeError> {
+		use codec::Decode;
+
+		let account_reserved_before =
+			BTreeMap::<T::AccountId, BalanceOf<T>>::decode(&mut &account_reserved_before_bytes[..])
+				.map_err(|_| "Failed to decode account_reserved_before_bytes")?;
+
+		// Get staked and deposited balances as reported by this pallet.
+		let (account_deposits, _, _) = Self::get_account_deposits_and_locks();
+
+		// Check that the reserved balance is reduced by the expected deposited amount.
+		for (account, actual_reserved_before) in account_reserved_before {
+			let actual_reserved_after = T::Currency::reserved_balance(&account);
+			let expected_amount_deducted = *account_deposits
+				.get(&account)
+				.expect("account deposit must exist to be in pre_migration_data, qed");
+			let expected_reserved_after =
+				actual_reserved_before.saturating_sub(expected_amount_deducted);
+			assert!(
+				actual_reserved_after == expected_reserved_after,
+				"Reserved balance for {:?} is incorrect. actual before: {:?}, actual after, {:?}, expected deducted: {:?}",
+				account,
+				actual_reserved_before,
+				actual_reserved_after,
+				expected_amount_deducted,
+			);
+		}
+
+		Ok(())
+	}
+}
+
+#[cfg(all(feature = "try-runtime", test))]
+mod test {
+	use super::*;
+	use crate::{
+		tests::{new_test_ext, Balances, Test},
+		DepositOf, Voting, VotingOf,
+	};
+	use frame_support::{
+		assert_ok, parameter_types,
+		traits::{Currency, OnRuntimeUpgrade, ReservableCurrency, WithdrawReasons},
+		BoundedVec,
+	};
+	use frame_system::pallet_prelude::BlockNumberFor;
+	use sp_core::ConstU32;
+
+	parameter_types! {
+		const PalletName: &'static str = "Democracy";
+	}
+
+	struct UnlockConfigImpl;
+
+	impl super::UnlockConfig for UnlockConfigImpl {
+		type Currency = Balances;
+		type MaxVotes = ConstU32<100>;
+		type MaxDeposits = ConstU32<1000>;
+		type AccountId = u64;
+		type BlockNumber = BlockNumberFor<Test>;
+		type DbWeight = ();
+		type PalletName = PalletName;
+	}
+
+	#[test]
+	fn unreserve_works_for_depositer() {
+		let depositer_0 = 10;
+		let depositer_1 = 11;
+		let deposit = 25;
+		let depositer_0_initial_reserved = 0;
+		let depositer_1_initial_reserved = 15;
+		let initial_balance = 100_000;
+		new_test_ext().execute_with(|| {
+			// Set up initial state.
+			<Test as crate::Config>::Currency::make_free_balance_be(&depositer_0, initial_balance);
+			<Test as crate::Config>::Currency::make_free_balance_be(&depositer_1, initial_balance);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(
+				&depositer_0,
+				depositer_0_initial_reserved + deposit
+			));
+			assert_ok!(<Test as crate::Config>::Currency::reserve(
+				&depositer_1,
+				depositer_1_initial_reserved + deposit
+			));
+			let depositors =
+				BoundedVec::<_, <Test as crate::Config>::MaxDeposits>::truncate_from(vec![
+					depositer_0,
+					depositer_1,
+				]);
+			DepositOf::<Test>::insert(0, (depositors, deposit));
+
+			// Sanity check: ensure initial reserved balance was set correctly.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&depositer_0),
+				depositer_0_initial_reserved + deposit
+			);
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&depositer_1),
+				depositer_1_initial_reserved + deposit
+			);
+
+			// Run the migration.
+			let bytes = UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::pre_upgrade()
+				.unwrap_or_else(|e| panic!("pre_upgrade failed: {:?}", e));
+			UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::on_runtime_upgrade();
+			assert_ok!(UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::post_upgrade(bytes));
+
+			// Assert the reserved balance was reduced by the expected amount.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&depositer_0),
+				depositer_0_initial_reserved
+			);
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&depositer_1),
+				depositer_1_initial_reserved
+			);
+		});
+	}
+
+	#[test]
+	fn unlock_works_for_voter() {
+		let voter = 10;
+		let stake = 25;
+		let initial_locks = vec![(b"somethin", 10)];
+		let initial_balance = 100_000;
+		new_test_ext().execute_with(|| {
+			// Set up initial state.
+			<Test as crate::Config>::Currency::make_free_balance_be(&voter, initial_balance);
+			for lock in initial_locks.clone() {
+				<Test as crate::Config>::Currency::set_lock(
+					*lock.0,
+					&voter,
+					lock.1,
+					WithdrawReasons::all(),
+				);
+			}
+			VotingOf::<Test>::insert(voter, Voting::default());
+			<Test as crate::Config>::Currency::set_lock(
+				DEMOCRACY_ID,
+				&voter,
+				stake,
+				WithdrawReasons::all(),
+			);
+
+			// Sanity check: ensure initial Balance state was set up correctly.
+			let mut voter_all_locks = initial_locks.clone();
+			voter_all_locks.push((&DEMOCRACY_ID, stake));
+			assert_eq!(
+				<Test as crate::Config>::Currency::locks(&voter)
+					.iter()
+					.map(|lock| (&lock.id, lock.amount))
+					.collect::<Vec<_>>(),
+				voter_all_locks
+			);
+
+			// Run the migration.
+			let bytes = UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::pre_upgrade()
+				.unwrap_or_else(|e| panic!("pre_upgrade failed: {:?}", e));
+			UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::on_runtime_upgrade();
+			assert_ok!(UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::post_upgrade(bytes));
+
+			// Assert the voter lock was removed
+			assert_eq!(
+				<Test as crate::Config>::Currency::locks(&voter)
+					.iter()
+					.map(|lock| (&lock.id, lock.amount))
+					.collect::<Vec<_>>(),
+				initial_locks
+			);
+		});
+	}
+}
diff --git a/substrate/frame/democracy/src/migrations/v1.rs b/substrate/frame/democracy/src/migrations/v1.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c27f437901b7ee1a7ce537d09eb3b3f313320292
--- /dev/null
+++ b/substrate/frame/democracy/src/migrations/v1.rs
@@ -0,0 +1,233 @@
+// 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.
+
+//! Storage migrations for the preimage pallet.
+
+use crate::*;
+use frame_support::{pallet_prelude::*, storage_alias, traits::OnRuntimeUpgrade, BoundedVec};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_core::H256;
+
+/// The log target.
+const TARGET: &'static str = "runtime::democracy::migration::v1";
+
+/// The original data layout of the democracy pallet without a specific version number.
+mod v0 {
+	use super::*;
+
+	#[storage_alias]
+	pub type PublicProps<T: Config> = StorageValue<
+		Pallet<T>,
+		Vec<(PropIndex, <T as frame_system::Config>::Hash, <T as frame_system::Config>::AccountId)>,
+		ValueQuery,
+	>;
+
+	#[storage_alias]
+	pub type NextExternal<T: Config> =
+		StorageValue<Pallet<T>, (<T as frame_system::Config>::Hash, VoteThreshold)>;
+
+	#[cfg(feature = "try-runtime")]
+	#[storage_alias]
+	pub type ReferendumInfoOf<T: Config> = StorageMap<
+		Pallet<T>,
+		frame_support::Twox64Concat,
+		ReferendumIndex,
+		ReferendumInfo<BlockNumberFor<T>, <T as frame_system::Config>::Hash, BalanceOf<T>>,
+	>;
+}
+
+pub mod v1 {
+	use super::*;
+
+	/// Migration for translating bare `Hash`es into `Bounded<Call>`s.
+	pub struct Migration<T>(sp_std::marker::PhantomData<T>);
+
+	impl<T: Config + frame_system::Config<Hash = H256>> OnRuntimeUpgrade for Migration<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+			ensure!(StorageVersion::get::<Pallet<T>>() == 0, "can only upgrade from version 0");
+
+			let props_count = v0::PublicProps::<T>::get().len();
+			log::info!(target: TARGET, "{} public proposals will be migrated.", props_count,);
+			ensure!(props_count <= T::MaxProposals::get() as usize, Error::<T>::TooMany);
+
+			let referenda_count = v0::ReferendumInfoOf::<T>::iter().count();
+			log::info!(target: TARGET, "{} referenda will be migrated.", referenda_count);
+
+			Ok((props_count as u32, referenda_count as u32).encode())
+		}
+
+		#[allow(deprecated)]
+		fn on_runtime_upgrade() -> Weight {
+			let mut weight = T::DbWeight::get().reads(1);
+			if StorageVersion::get::<Pallet<T>>() != 0 {
+				log::warn!(
+					target: TARGET,
+					"skipping on_runtime_upgrade: executed on wrong storage version.\
+				Expected version 0"
+				);
+				return weight
+			}
+
+			ReferendumInfoOf::<T>::translate(
+				|index, old: ReferendumInfo<BlockNumberFor<T>, T::Hash, BalanceOf<T>>| {
+					weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+					log::info!(target: TARGET, "migrating referendum #{:?}", &index);
+					Some(match old {
+						ReferendumInfo::Ongoing(status) =>
+							ReferendumInfo::Ongoing(ReferendumStatus {
+								end: status.end,
+								proposal: Bounded::from_legacy_hash(status.proposal),
+								threshold: status.threshold,
+								delay: status.delay,
+								tally: status.tally,
+							}),
+						ReferendumInfo::Finished { approved, end } =>
+							ReferendumInfo::Finished { approved, end },
+					})
+				},
+			);
+
+			let props = v0::PublicProps::<T>::take()
+				.into_iter()
+				.map(|(i, hash, a)| (i, Bounded::from_legacy_hash(hash), a))
+				.collect::<Vec<_>>();
+			let bounded = BoundedVec::<_, T::MaxProposals>::truncate_from(props.clone());
+			PublicProps::<T>::put(bounded);
+			weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+			if props.len() as u32 > T::MaxProposals::get() {
+				log::error!(
+					target: TARGET,
+					"truncated {} public proposals to {}; continuing",
+					props.len(),
+					T::MaxProposals::get()
+				);
+			}
+
+			if let Some((hash, threshold)) = v0::NextExternal::<T>::take() {
+				log::info!(target: TARGET, "migrating next external proposal");
+				NextExternal::<T>::put((Bounded::from_legacy_hash(hash), threshold));
+			}
+
+			StorageVersion::new(1).put::<Pallet<T>>();
+
+			weight.saturating_add(T::DbWeight::get().reads_writes(1, 2))
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+			ensure!(StorageVersion::get::<Pallet<T>>() == 1, "must upgrade");
+
+			let (old_props_count, old_ref_count): (u32, u32) =
+				Decode::decode(&mut &state[..]).expect("pre_upgrade provides a valid state; qed");
+			let new_props_count = crate::PublicProps::<T>::get().len() as u32;
+			ensure!(new_props_count == old_props_count, "must migrate all public proposals");
+			let new_ref_count = crate::ReferendumInfoOf::<T>::iter().count() as u32;
+			ensure!(new_ref_count == old_ref_count, "must migrate all referenda");
+
+			log::info!(
+				target: TARGET,
+				"{} public proposals migrated, {} referenda migrated",
+				new_props_count,
+				new_ref_count,
+			);
+			Ok(())
+		}
+	}
+}
+
+#[cfg(test)]
+#[cfg(feature = "try-runtime")]
+mod test {
+	use super::*;
+	use crate::{
+		tests::{Test as T, *},
+		types::*,
+	};
+	use sp_runtime::bounded_vec;
+
+	#[allow(deprecated)]
+	#[test]
+	fn migration_works() {
+		new_test_ext().execute_with(|| {
+			assert_eq!(StorageVersion::get::<Pallet<T>>(), 0);
+			// Insert some values into the v0 storage:
+
+			// Case 1: Ongoing referendum
+			let hash = H256::repeat_byte(1);
+			let status = ReferendumStatus {
+				end: 1u32.into(),
+				proposal: hash.clone(),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 1u32.into(),
+				tally: Tally { ayes: 1u32.into(), nays: 1u32.into(), turnout: 1u32.into() },
+			};
+			v0::ReferendumInfoOf::<T>::insert(1u32, ReferendumInfo::Ongoing(status));
+
+			// Case 2: Finished referendum
+			v0::ReferendumInfoOf::<T>::insert(
+				2u32,
+				ReferendumInfo::Finished { approved: true, end: 123u32.into() },
+			);
+
+			// Case 3: Public proposals
+			let hash2 = H256::repeat_byte(2);
+			v0::PublicProps::<T>::put(vec![
+				(3u32, hash.clone(), 123u64),
+				(4u32, hash2.clone(), 123u64),
+			]);
+
+			// Case 4: Next external
+			v0::NextExternal::<T>::put((hash.clone(), VoteThreshold::SuperMajorityApprove));
+
+			// Migrate.
+			let state = v1::Migration::<T>::pre_upgrade().unwrap();
+			let _weight = v1::Migration::<T>::on_runtime_upgrade();
+			v1::Migration::<T>::post_upgrade(state).unwrap();
+			// Check that all values got migrated.
+
+			// Case 1: Ongoing referendum
+			assert_eq!(
+				ReferendumInfoOf::<T>::get(1u32),
+				Some(ReferendumInfo::Ongoing(ReferendumStatus {
+					end: 1u32.into(),
+					proposal: Bounded::from_legacy_hash(hash),
+					threshold: VoteThreshold::SuperMajorityApprove,
+					delay: 1u32.into(),
+					tally: Tally { ayes: 1u32.into(), nays: 1u32.into(), turnout: 1u32.into() },
+				}))
+			);
+			// Case 2: Finished referendum
+			assert_eq!(
+				ReferendumInfoOf::<T>::get(2u32),
+				Some(ReferendumInfo::Finished { approved: true, end: 123u32.into() })
+			);
+			// Case 3: Public proposals
+			let props: BoundedVec<_, <Test as Config>::MaxProposals> = bounded_vec![
+				(3u32, Bounded::from_legacy_hash(hash), 123u64),
+				(4u32, Bounded::from_legacy_hash(hash2), 123u64)
+			];
+			assert_eq!(PublicProps::<T>::get(), props);
+			// Case 4: Next external
+			assert_eq!(
+				NextExternal::<T>::get(),
+				Some((Bounded::from_legacy_hash(hash), VoteThreshold::SuperMajorityApprove))
+			);
+		});
+	}
+}
diff --git a/substrate/frame/democracy/src/tests.rs b/substrate/frame/democracy/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e5cfcc5b4002963387ef78126630ea7433ed63ab
--- /dev/null
+++ b/substrate/frame/democracy/src/tests.rs
@@ -0,0 +1,290 @@
+// 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.
+
+//! The crate's tests.
+
+use super::*;
+use crate as pallet_democracy;
+use frame_support::{
+	assert_noop, assert_ok, ord_parameter_types, parameter_types,
+	traits::{
+		ConstU32, ConstU64, Contains, EqualPrivilegeOnly, OnInitialize, SortedMembers,
+		StorePreimage,
+	},
+	weights::Weight,
+};
+use frame_system::{EnsureRoot, EnsureSigned, EnsureSignedBy};
+use pallet_balances::{BalanceLock, Error as BalancesError};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BadOrigin, BlakeTwo256, Hash, IdentityLookup},
+	BuildStorage, Perbill,
+};
+mod cancellation;
+mod decoders;
+mod delegation;
+mod external_proposing;
+mod fast_tracking;
+mod lock_voting;
+mod metadata;
+mod public_proposals;
+mod scheduling;
+mod voting;
+
+const AYE: Vote = Vote { aye: true, conviction: Conviction::None };
+const NAY: Vote = Vote { aye: false, conviction: Conviction::None };
+const BIG_AYE: Vote = Vote { aye: true, conviction: Conviction::Locked1x };
+const BIG_NAY: Vote = Vote { aye: false, conviction: Conviction::Locked1x };
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Preimage: pallet_preimage,
+		Scheduler: pallet_scheduler::{Pallet, Call, Storage, Event<T>},
+		Democracy: pallet_democracy::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+);
+
+// Test that a fitlered call can be dispatched.
+pub struct BaseFilter;
+impl Contains<RuntimeCall> for BaseFilter {
+	fn contains(call: &RuntimeCall) -> bool {
+		!matches!(call, &RuntimeCall::Balances(pallet_balances::Call::force_set_balance { .. }))
+	}
+}
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(
+			Weight::from_parts(frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
+		);
+}
+impl frame_system::Config for Test {
+	type BaseCallFilter = BaseFilter;
+	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 = frame_support::traits::ConstU32<16>;
+}
+parameter_types! {
+	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * BlockWeights::get().max_block;
+}
+
+impl pallet_preimage::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type ManagerOrigin = EnsureRoot<u64>;
+	type BaseDeposit = ConstU64<0>;
+	type ByteDeposit = ConstU64<0>;
+}
+
+impl pallet_scheduler::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type PalletsOrigin = OriginCaller;
+	type RuntimeCall = RuntimeCall;
+	type MaximumWeight = MaximumSchedulerWeight;
+	type ScheduleOrigin = EnsureRoot<u64>;
+	type MaxScheduledPerBlock = ConstU32<100>;
+	type WeightInfo = ();
+	type OriginPrivilegeCmp = EqualPrivilegeOnly;
+	type Preimages = ();
+}
+
+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 MaxHolds = ();
+}
+parameter_types! {
+	pub static PreimageByteDeposit: u64 = 0;
+	pub static InstantAllowed: bool = false;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+	pub const Two: u64 = 2;
+	pub const Three: u64 = 3;
+	pub const Four: u64 = 4;
+	pub const Five: u64 = 5;
+	pub const Six: u64 = 6;
+}
+pub struct OneToFive;
+impl SortedMembers<u64> for OneToFive {
+	fn sorted_members() -> Vec<u64> {
+		vec![1, 2, 3, 4, 5]
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add(_m: &u64) {}
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = pallet_balances::Pallet<Self>;
+	type EnactmentPeriod = ConstU64<2>;
+	type LaunchPeriod = ConstU64<2>;
+	type VotingPeriod = ConstU64<2>;
+	type VoteLockingPeriod = ConstU64<3>;
+	type FastTrackVotingPeriod = ConstU64<2>;
+	type MinimumDeposit = ConstU64<1>;
+	type MaxDeposits = ConstU32<1000>;
+	type MaxBlacklisted = ConstU32<5>;
+	type SubmitOrigin = EnsureSigned<Self::AccountId>;
+	type ExternalOrigin = EnsureSignedBy<Two, u64>;
+	type ExternalMajorityOrigin = EnsureSignedBy<Three, u64>;
+	type ExternalDefaultOrigin = EnsureSignedBy<One, u64>;
+	type FastTrackOrigin = EnsureSignedBy<Five, u64>;
+	type CancellationOrigin = EnsureSignedBy<Four, u64>;
+	type BlacklistOrigin = EnsureRoot<u64>;
+	type CancelProposalOrigin = EnsureRoot<u64>;
+	type VetoOrigin = EnsureSignedBy<OneToFive, u64>;
+	type CooloffPeriod = ConstU64<2>;
+	type Slash = ();
+	type InstantOrigin = EnsureSignedBy<Six, u64>;
+	type InstantAllowed = InstantAllowed;
+	type Scheduler = Scheduler;
+	type MaxVotes = ConstU32<100>;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+	type MaxProposals = ConstU32<100>;
+	type Preimages = Preimage;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	pallet_democracy::GenesisConfig::<Test>::default()
+		.assimilate_storage(&mut t)
+		.unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+#[test]
+fn params_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Democracy::referendum_count(), 0);
+		assert_eq!(Balances::free_balance(42), 0);
+		assert_eq!(Balances::total_issuance(), 210);
+	});
+}
+
+fn set_balance_proposal(value: u64) -> BoundedCallOf<Test> {
+	let inner = pallet_balances::Call::force_set_balance { who: 42, new_free: value };
+	let outer = RuntimeCall::Balances(inner);
+	Preimage::bound(outer).unwrap()
+}
+
+#[test]
+fn set_balance_proposal_is_correctly_filtered_out() {
+	for i in 0..10 {
+		let call = Preimage::realize(&set_balance_proposal(i)).unwrap().0;
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+	}
+}
+
+fn propose_set_balance(who: u64, value: u64, delay: u64) -> DispatchResult {
+	Democracy::propose(RuntimeOrigin::signed(who), set_balance_proposal(value), delay)
+}
+
+fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+	Scheduler::on_initialize(System::block_number());
+	Democracy::begin_block(System::block_number());
+}
+
+fn fast_forward_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+fn begin_referendum() -> ReferendumIndex {
+	System::set_block_number(0);
+	assert_ok!(propose_set_balance(1, 2, 1));
+	fast_forward_to(2);
+	0
+}
+
+fn aye(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: AYE, balance: Balances::free_balance(&who) }
+}
+
+fn nay(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: NAY, balance: Balances::free_balance(&who) }
+}
+
+fn big_aye(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: BIG_AYE, balance: Balances::free_balance(&who) }
+}
+
+fn big_nay(who: u64) -> AccountVote<u64> {
+	AccountVote::Standard { vote: BIG_NAY, balance: Balances::free_balance(&who) }
+}
+
+fn tally(r: ReferendumIndex) -> Tally<u64> {
+	Democracy::referendum_status(r).unwrap().tally
+}
+
+/// note a new preimage without registering.
+fn note_preimage(who: u64) -> PreimageHash {
+	use std::sync::atomic::{AtomicU8, Ordering};
+	// note a new preimage on every function invoke.
+	static COUNTER: AtomicU8 = AtomicU8::new(0);
+	let data = vec![COUNTER.fetch_add(1, Ordering::Relaxed)];
+	assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(who), data.clone()));
+	let hash = BlakeTwo256::hash(&data);
+	assert!(!Preimage::is_requested(&hash));
+	hash
+}
diff --git a/substrate/frame/democracy/src/tests/cancellation.rs b/substrate/frame/democracy/src/tests/cancellation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4384fe6a1641aa2f51723c70caeac7093dcb1951
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/cancellation.rs
@@ -0,0 +1,75 @@
+// 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.
+
+//! The tests for cancelation functionality.
+
+use super::*;
+
+#[test]
+fn cancel_referendum_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		assert_ok!(Democracy::cancel_referendum(RuntimeOrigin::root(), r.into()));
+		assert_eq!(Democracy::lowest_unbaked(), 0);
+
+		next_block();
+
+		next_block();
+
+		assert_eq!(Democracy::lowest_unbaked(), 1);
+		assert_eq!(Democracy::lowest_unbaked(), Democracy::referendum_count());
+		assert_eq!(Balances::free_balance(42), 0);
+	});
+}
+
+#[test]
+fn emergency_cancel_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			2,
+		);
+		assert!(Democracy::referendum_status(r).is_ok());
+
+		assert_noop!(Democracy::emergency_cancel(RuntimeOrigin::signed(3), r), BadOrigin);
+		assert_ok!(Democracy::emergency_cancel(RuntimeOrigin::signed(4), r));
+		assert!(Democracy::referendum_info(r).is_none());
+
+		// some time later...
+
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			2,
+		);
+		assert!(Democracy::referendum_status(r).is_ok());
+		assert_noop!(
+			Democracy::emergency_cancel(RuntimeOrigin::signed(4), r),
+			Error::<Test>::AlreadyCanceled,
+		);
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/decoders.rs b/substrate/frame/democracy/src/tests/decoders.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9cd725d97f64b7afc3d903f4104d3f8112eba6f3
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/decoders.rs
@@ -0,0 +1,57 @@
+// 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.
+
+//! The for various partial storage decoders
+
+use super::*;
+use frame_support::{
+	storage::{migration, unhashed},
+	BoundedVec,
+};
+
+#[test]
+fn test_decode_compact_u32_at() {
+	new_test_ext().execute_with(|| {
+		let v = codec::Compact(u64::MAX);
+		migration::put_storage_value(b"test", b"", &[], v);
+		assert_eq!(decode_compact_u32_at(b"test"), None);
+
+		for v in vec![0, 10, u32::MAX] {
+			let compact_v = codec::Compact(v);
+			unhashed::put(b"test", &compact_v);
+			assert_eq!(decode_compact_u32_at(b"test"), Some(v));
+		}
+
+		unhashed::kill(b"test");
+		assert_eq!(decode_compact_u32_at(b"test"), None);
+	})
+}
+
+#[test]
+fn len_of_deposit_of() {
+	new_test_ext().execute_with(|| {
+		for l in vec![0, 1, 200, 1000] {
+			let value: (BoundedVec<u64, _>, u64) =
+				((0..l).map(|_| Default::default()).collect::<Vec<_>>().try_into().unwrap(), 3u64);
+			DepositOf::<Test>::insert(2, value);
+			assert_eq!(Democracy::len_of_deposit_of(2), Some(l));
+		}
+
+		DepositOf::<Test>::remove(2);
+		assert_eq!(Democracy::len_of_deposit_of(2), None);
+	})
+}
diff --git a/substrate/frame/democracy/src/tests/delegation.rs b/substrate/frame/democracy/src/tests/delegation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..710faf9192386d2e41c897977600b13fb1edb5e9
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/delegation.rs
@@ -0,0 +1,222 @@
+// 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.
+
+//! The tests for functionality concerning delegation.
+
+use super::*;
+
+#[test]
+fn single_proposal_should_work_with_delegation() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+
+		assert_ok!(propose_set_balance(1, 2, 1));
+
+		fast_forward_to(2);
+
+		// Delegate first vote.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::None, 20));
+		let r = 0;
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		assert_eq!(tally(r), Tally { ayes: 3, nays: 0, turnout: 30 });
+
+		// Delegate a second vote.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(3), 1, Conviction::None, 30));
+		assert_eq!(tally(r), Tally { ayes: 6, nays: 0, turnout: 60 });
+
+		// Reduce first vote.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::None, 10));
+		assert_eq!(tally(r), Tally { ayes: 5, nays: 0, turnout: 50 });
+
+		// Second vote delegates to first; we don't do tiered delegation, so it doesn't get used.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(3), 2, Conviction::None, 30));
+		assert_eq!(tally(r), Tally { ayes: 2, nays: 0, turnout: 20 });
+
+		// Main voter cancels their vote
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(1), r));
+		assert_eq!(tally(r), Tally { ayes: 0, nays: 0, turnout: 0 });
+
+		// First delegator delegates half funds with conviction; nothing changes yet.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::Locked1x, 10));
+		assert_eq!(tally(r), Tally { ayes: 0, nays: 0, turnout: 0 });
+
+		// Main voter reinstates their vote
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		assert_eq!(tally(r), Tally { ayes: 11, nays: 0, turnout: 20 });
+	});
+}
+
+#[test]
+fn self_delegation_not_allowed() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Democracy::delegate(RuntimeOrigin::signed(1), 1, Conviction::None, 10),
+			Error::<Test>::Nonsense,
+		);
+	});
+}
+
+#[test]
+fn cyclic_delegation_should_unwind() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+
+		assert_ok!(propose_set_balance(1, 2, 1));
+
+		fast_forward_to(2);
+
+		// Check behavior with cycle.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::None, 20));
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(3), 2, Conviction::None, 30));
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(1), 3, Conviction::None, 10));
+		let r = 0;
+		assert_ok!(Democracy::undelegate(RuntimeOrigin::signed(3)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(3), r, aye(3)));
+		assert_ok!(Democracy::undelegate(RuntimeOrigin::signed(1)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, nay(1)));
+
+		// Delegated vote is counted.
+		assert_eq!(tally(r), Tally { ayes: 3, nays: 3, turnout: 60 });
+	});
+}
+
+#[test]
+fn single_proposal_should_work_with_vote_and_delegation() {
+	// If transactor already voted, delegated vote is overwritten.
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+
+		assert_ok!(propose_set_balance(1, 2, 1));
+
+		fast_forward_to(2);
+
+		let r = 0;
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(2), r, nay(2)));
+		assert_eq!(tally(r), Tally { ayes: 1, nays: 2, turnout: 30 });
+
+		// Delegate vote.
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(2), r));
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::None, 20));
+		// Delegated vote replaces the explicit vote.
+		assert_eq!(tally(r), Tally { ayes: 3, nays: 0, turnout: 30 });
+	});
+}
+
+#[test]
+fn single_proposal_should_work_with_undelegation() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+
+		assert_ok!(propose_set_balance(1, 2, 1));
+
+		// Delegate and undelegate vote.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::None, 20));
+		assert_ok!(Democracy::undelegate(RuntimeOrigin::signed(2)));
+
+		fast_forward_to(2);
+		let r = 0;
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+
+		// Delegated vote is not counted.
+		assert_eq!(tally(r), Tally { ayes: 1, nays: 0, turnout: 10 });
+	});
+}
+
+#[test]
+fn single_proposal_should_work_with_delegation_and_vote() {
+	// If transactor voted, delegated vote is overwritten.
+	new_test_ext().execute_with(|| {
+		let r = begin_referendum();
+		// Delegate, undelegate and vote.
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::None, 20));
+		assert_eq!(tally(r), Tally { ayes: 3, nays: 0, turnout: 30 });
+		assert_ok!(Democracy::undelegate(RuntimeOrigin::signed(2)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(2), r, aye(2)));
+		// Delegated vote is not counted.
+		assert_eq!(tally(r), Tally { ayes: 3, nays: 0, turnout: 30 });
+	});
+}
+
+#[test]
+fn conviction_should_be_honored_in_delegation() {
+	// If transactor voted, delegated vote is overwritten.
+	new_test_ext().execute_with(|| {
+		let r = begin_referendum();
+		// Delegate and vote.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::Locked6x, 20));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		// Delegated vote is huge.
+		assert_eq!(tally(r), Tally { ayes: 121, nays: 0, turnout: 30 });
+	});
+}
+
+#[test]
+fn split_vote_delegation_should_be_ignored() {
+	// If transactor voted, delegated vote is overwritten.
+	new_test_ext().execute_with(|| {
+		let r = begin_referendum();
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::Locked6x, 20));
+		assert_ok!(Democracy::vote(
+			RuntimeOrigin::signed(1),
+			r,
+			AccountVote::Split { aye: 10, nay: 0 }
+		));
+		// Delegated vote is huge.
+		assert_eq!(tally(r), Tally { ayes: 1, nays: 0, turnout: 10 });
+	});
+}
+
+#[test]
+fn redelegation_keeps_lock() {
+	// If transactor voted, delegated vote is overwritten.
+	new_test_ext().execute_with(|| {
+		let r = begin_referendum();
+		// Delegate and vote.
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 1, Conviction::Locked6x, 20));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		// Delegated vote is huge.
+		assert_eq!(tally(r), Tally { ayes: 121, nays: 0, turnout: 30 });
+
+		let mut prior_lock = vote::PriorLock::default();
+
+		// Locked balance of delegator exists
+		assert_eq!(VotingOf::<Test>::get(2).locked_balance(), 20);
+		assert_eq!(VotingOf::<Test>::get(2).prior(), &prior_lock);
+
+		// Delegate someone else at a lower conviction and amount
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(2), 3, Conviction::None, 10));
+
+		// 6x prior should appear w/ locked balance.
+		prior_lock.accumulate(98, 20);
+		assert_eq!(VotingOf::<Test>::get(2).prior(), &prior_lock);
+		assert_eq!(VotingOf::<Test>::get(2).locked_balance(), 20);
+		// Unlock shouldn't work
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(2), 2));
+		assert_eq!(VotingOf::<Test>::get(2).prior(), &prior_lock);
+		assert_eq!(VotingOf::<Test>::get(2).locked_balance(), 20);
+
+		fast_forward_to(100);
+
+		// Now unlock can remove the prior lock and reduce the locked amount.
+		assert_eq!(VotingOf::<Test>::get(2).prior(), &prior_lock);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(2), 2));
+		assert_eq!(VotingOf::<Test>::get(2).prior(), &vote::PriorLock::default());
+		assert_eq!(VotingOf::<Test>::get(2).locked_balance(), 10);
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/external_proposing.rs b/substrate/frame/democracy/src/tests/external_proposing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..08b497ab4b90e6ce458b7462c521b0d9d6d78640
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/external_proposing.rs
@@ -0,0 +1,276 @@
+// 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.
+
+//! The tests for functionality concerning the "external" origin.
+
+use super::*;
+
+#[test]
+fn veto_external_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2),));
+		assert!(<NextExternal<Test>>::exists());
+
+		let h = set_balance_proposal(2).hash();
+		assert_ok!(Democracy::veto_external(RuntimeOrigin::signed(3), h));
+		// cancelled.
+		assert!(!<NextExternal<Test>>::exists());
+		// fails - same proposal can't be resubmitted.
+		assert_noop!(
+			Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2),),
+			Error::<Test>::ProposalBlacklisted
+		);
+
+		fast_forward_to(1);
+		// fails as we're still in cooloff period.
+		assert_noop!(
+			Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2),),
+			Error::<Test>::ProposalBlacklisted
+		);
+
+		fast_forward_to(2);
+		// works; as we're out of the cooloff period.
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2),));
+		assert!(<NextExternal<Test>>::exists());
+
+		// 3 can't veto the same thing twice.
+		assert_noop!(
+			Democracy::veto_external(RuntimeOrigin::signed(3), h),
+			Error::<Test>::AlreadyVetoed
+		);
+
+		// 4 vetoes.
+		assert_ok!(Democracy::veto_external(RuntimeOrigin::signed(4), h));
+		// cancelled again.
+		assert!(!<NextExternal<Test>>::exists());
+
+		fast_forward_to(3);
+		// same proposal fails as we're still in cooloff
+		assert_noop!(
+			Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2)),
+			Error::<Test>::ProposalBlacklisted
+		);
+		// different proposal works fine.
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(3),));
+	});
+}
+
+#[test]
+fn external_blacklisting_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2),));
+
+		let hash = set_balance_proposal(2).hash();
+		assert_ok!(Democracy::blacklist(RuntimeOrigin::root(), hash, None));
+
+		fast_forward_to(2);
+		assert_noop!(Democracy::referendum_status(0), Error::<Test>::ReferendumInvalid);
+
+		assert_noop!(
+			Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2)),
+			Error::<Test>::ProposalBlacklisted,
+		);
+	});
+}
+
+#[test]
+fn external_referendum_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_noop!(
+			Democracy::external_propose(RuntimeOrigin::signed(1), set_balance_proposal(2),),
+			BadOrigin,
+		);
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2),));
+		assert_noop!(
+			Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(1),),
+			Error::<Test>::DuplicateProposal
+		);
+		fast_forward_to(2);
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: 4,
+				proposal: set_balance_proposal(2),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+	});
+}
+
+#[test]
+fn external_majority_referendum_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_noop!(
+			Democracy::external_propose_majority(RuntimeOrigin::signed(1), set_balance_proposal(2)),
+			BadOrigin,
+		);
+		assert_ok!(Democracy::external_propose_majority(
+			RuntimeOrigin::signed(3),
+			set_balance_proposal(2)
+		));
+		fast_forward_to(2);
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: 4,
+				proposal: set_balance_proposal(2),
+				threshold: VoteThreshold::SimpleMajority,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+	});
+}
+
+#[test]
+fn external_default_referendum_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_noop!(
+			Democracy::external_propose_default(RuntimeOrigin::signed(3), set_balance_proposal(2)),
+			BadOrigin,
+		);
+		assert_ok!(Democracy::external_propose_default(
+			RuntimeOrigin::signed(1),
+			set_balance_proposal(2)
+		));
+		fast_forward_to(2);
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: 4,
+				proposal: set_balance_proposal(2),
+				threshold: VoteThreshold::SuperMajorityAgainst,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+	});
+}
+
+#[test]
+fn external_and_public_interleaving_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(1),));
+		assert_ok!(propose_set_balance(6, 2, 2));
+
+		fast_forward_to(2);
+
+		// both waiting: external goes first.
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: 4,
+				proposal: set_balance_proposal(1),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+		// replenish external
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(3),));
+
+		fast_forward_to(4);
+
+		// both waiting: public goes next.
+		assert_eq!(
+			Democracy::referendum_status(1),
+			Ok(ReferendumStatus {
+				end: 6,
+				proposal: set_balance_proposal(2),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+		// don't replenish public
+
+		fast_forward_to(6);
+
+		// it's external "turn" again, though since public is empty that doesn't really matter
+		assert_eq!(
+			Democracy::referendum_status(2),
+			Ok(ReferendumStatus {
+				end: 8,
+				proposal: set_balance_proposal(3),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+		// replenish external
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(5),));
+
+		fast_forward_to(8);
+
+		// external goes again because there's no public waiting.
+		assert_eq!(
+			Democracy::referendum_status(3),
+			Ok(ReferendumStatus {
+				end: 10,
+				proposal: set_balance_proposal(5),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+		// replenish both
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(7),));
+		assert_ok!(propose_set_balance(6, 4, 2));
+
+		fast_forward_to(10);
+
+		// public goes now since external went last time.
+		assert_eq!(
+			Democracy::referendum_status(4),
+			Ok(ReferendumStatus {
+				end: 12,
+				proposal: set_balance_proposal(4),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+		// replenish public again
+		assert_ok!(propose_set_balance(6, 6, 2));
+		// cancel external
+		let h = set_balance_proposal(7).hash();
+		assert_ok!(Democracy::veto_external(RuntimeOrigin::signed(3), h));
+
+		fast_forward_to(12);
+
+		// public goes again now since there's no external waiting.
+		assert_eq!(
+			Democracy::referendum_status(5),
+			Ok(ReferendumStatus {
+				end: 14,
+				proposal: set_balance_proposal(6),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/fast_tracking.rs b/substrate/frame/democracy/src/tests/fast_tracking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..85e7792a4c2edf3728f2b0215fe94fc0dc3efdbb
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/fast_tracking.rs
@@ -0,0 +1,164 @@
+// 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.
+
+//! The tests for fast-tracking functionality.
+
+use super::*;
+
+#[test]
+fn fast_track_referendum_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let h = set_balance_proposal(2).hash();
+		assert_noop!(
+			Democracy::fast_track(RuntimeOrigin::signed(5), h, 3, 2),
+			Error::<Test>::ProposalMissing
+		);
+		assert_ok!(Democracy::external_propose_majority(
+			RuntimeOrigin::signed(3),
+			set_balance_proposal(2)
+		));
+		let hash = note_preimage(1);
+		assert!(<MetadataOf<Test>>::get(MetadataOwner::External).is_none());
+		assert_ok!(Democracy::set_metadata(
+			RuntimeOrigin::signed(3),
+			MetadataOwner::External,
+			Some(hash),
+		),);
+		assert!(<MetadataOf<Test>>::get(MetadataOwner::External).is_some());
+		assert_noop!(Democracy::fast_track(RuntimeOrigin::signed(1), h, 3, 2), BadOrigin);
+		assert_ok!(Democracy::fast_track(RuntimeOrigin::signed(5), h, 2, 0));
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: 2,
+				proposal: set_balance_proposal(2),
+				threshold: VoteThreshold::SimpleMajority,
+				delay: 0,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+		// metadata reset from the external proposal to the referendum.
+		assert!(<MetadataOf<Test>>::get(MetadataOwner::External).is_none());
+		assert!(<MetadataOf<Test>>::get(MetadataOwner::Referendum(0)).is_some());
+	});
+}
+
+#[test]
+fn instant_referendum_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let h = set_balance_proposal(2).hash();
+		assert_noop!(
+			Democracy::fast_track(RuntimeOrigin::signed(5), h, 3, 2),
+			Error::<Test>::ProposalMissing
+		);
+		assert_ok!(Democracy::external_propose_majority(
+			RuntimeOrigin::signed(3),
+			set_balance_proposal(2)
+		));
+		assert_noop!(Democracy::fast_track(RuntimeOrigin::signed(1), h, 3, 2), BadOrigin);
+		assert_noop!(Democracy::fast_track(RuntimeOrigin::signed(5), h, 1, 0), BadOrigin);
+		assert_noop!(
+			Democracy::fast_track(RuntimeOrigin::signed(6), h, 1, 0),
+			Error::<Test>::InstantNotAllowed
+		);
+		INSTANT_ALLOWED.with(|v| *v.borrow_mut() = true);
+		assert_noop!(
+			Democracy::fast_track(RuntimeOrigin::signed(6), h, 0, 0),
+			Error::<Test>::VotingPeriodLow
+		);
+		assert_ok!(Democracy::fast_track(RuntimeOrigin::signed(6), h, 1, 0));
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: 1,
+				proposal: set_balance_proposal(2),
+				threshold: VoteThreshold::SimpleMajority,
+				delay: 0,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+	});
+}
+
+#[test]
+fn instant_next_block_referendum_backed() {
+	new_test_ext().execute_with(|| {
+		// arrange
+		let start_block_number = 10;
+		let majority_origin_id = 3;
+		let instant_origin_id = 6;
+		let voting_period = 1;
+		let proposal = set_balance_proposal(2);
+		let delay = 2; // has no effect on test
+
+		// init
+		System::set_block_number(start_block_number);
+		InstantAllowed::set(true);
+
+		// propose with majority origin
+		assert_ok!(Democracy::external_propose_majority(
+			RuntimeOrigin::signed(majority_origin_id),
+			proposal.clone()
+		));
+
+		// fast track with instant origin and voting period pointing to the next block
+		assert_ok!(Democracy::fast_track(
+			RuntimeOrigin::signed(instant_origin_id),
+			proposal.hash(),
+			voting_period,
+			delay
+		));
+
+		// fetch the status of the only referendum at index 0
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: start_block_number + voting_period,
+				proposal,
+				threshold: VoteThreshold::SimpleMajority,
+				delay,
+				tally: Tally { ayes: 0, nays: 0, turnout: 0 },
+			})
+		);
+
+		// referendum expected to be baked with the start of the next block
+		next_block();
+
+		// assert no active referendums
+		assert_noop!(Democracy::referendum_status(0), Error::<Test>::ReferendumInvalid);
+		// the only referendum in the storage is finished and not approved
+		assert_eq!(
+			ReferendumInfoOf::<Test>::get(0).unwrap(),
+			ReferendumInfo::Finished { approved: false, end: start_block_number + voting_period }
+		);
+	});
+}
+
+#[test]
+fn fast_track_referendum_fails_when_no_simple_majority() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let h = set_balance_proposal(2).hash();
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2)));
+		assert_noop!(
+			Democracy::fast_track(RuntimeOrigin::signed(5), h, 3, 2),
+			Error::<Test>::NotSimpleMajority
+		);
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/lock_voting.rs b/substrate/frame/democracy/src/tests/lock_voting.rs
new file mode 100644
index 0000000000000000000000000000000000000000..31f2e3f3dcc26fb58ccf1498e56734261fd34324
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/lock_voting.rs
@@ -0,0 +1,364 @@
+// 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.
+
+//! The tests for functionality concerning locking and lock-voting.
+
+use super::*;
+
+fn aye(x: u8, balance: u64) -> AccountVote<u64> {
+	AccountVote::Standard {
+		vote: Vote { aye: true, conviction: Conviction::try_from(x).unwrap() },
+		balance,
+	}
+}
+
+fn nay(x: u8, balance: u64) -> AccountVote<u64> {
+	AccountVote::Standard {
+		vote: Vote { aye: false, conviction: Conviction::try_from(x).unwrap() },
+		balance,
+	}
+}
+
+fn the_lock(amount: u64) -> BalanceLock<u64> {
+	BalanceLock { id: DEMOCRACY_ID, amount, reasons: pallet_balances::Reasons::All }
+}
+
+#[test]
+fn lock_voting_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, nay(5, 10)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(2), r, aye(4, 20)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(3), r, aye(3, 30)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(4), r, aye(2, 40)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, nay(1, 50)));
+		assert_eq!(tally(r), Tally { ayes: 250, nays: 100, turnout: 150 });
+
+		// All balances are currently locked.
+		for i in 1..=5 {
+			assert_eq!(Balances::locks(i), vec![the_lock(i * 10)]);
+		}
+
+		fast_forward_to(3);
+
+		// Referendum passed; 1 and 5 didn't get their way and can now reap and unlock.
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(1), r));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(1), 1));
+		// Anyone can reap and unlock anyone else's in this context.
+		assert_ok!(Democracy::remove_other_vote(RuntimeOrigin::signed(2), 5, r));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(2), 5));
+
+		// 2, 3, 4 got their way with the vote, so they cannot be reaped by others.
+		assert_noop!(
+			Democracy::remove_other_vote(RuntimeOrigin::signed(1), 2, r),
+			Error::<Test>::NoPermission
+		);
+		// However, they can be unvoted by the owner, though it will make no difference to the lock.
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(2), r));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(2), 2));
+
+		assert_eq!(Balances::locks(1), vec![]);
+		assert_eq!(Balances::locks(2), vec![the_lock(20)]);
+		assert_eq!(Balances::locks(3), vec![the_lock(30)]);
+		assert_eq!(Balances::locks(4), vec![the_lock(40)]);
+		assert_eq!(Balances::locks(5), vec![]);
+		assert_eq!(Balances::free_balance(42), 2);
+
+		fast_forward_to(7);
+		// No change yet...
+		assert_noop!(
+			Democracy::remove_other_vote(RuntimeOrigin::signed(1), 4, r),
+			Error::<Test>::NoPermission
+		);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(1), 4));
+		assert_eq!(Balances::locks(4), vec![the_lock(40)]);
+		fast_forward_to(8);
+		// 4 should now be able to reap and unlock
+		assert_ok!(Democracy::remove_other_vote(RuntimeOrigin::signed(1), 4, r));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(1), 4));
+		assert_eq!(Balances::locks(4), vec![]);
+
+		fast_forward_to(13);
+		assert_noop!(
+			Democracy::remove_other_vote(RuntimeOrigin::signed(1), 3, r),
+			Error::<Test>::NoPermission
+		);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(1), 3));
+		assert_eq!(Balances::locks(3), vec![the_lock(30)]);
+		fast_forward_to(14);
+		assert_ok!(Democracy::remove_other_vote(RuntimeOrigin::signed(1), 3, r));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(1), 3));
+		assert_eq!(Balances::locks(3), vec![]);
+
+		// 2 doesn't need to reap_vote here because it was already done before.
+		fast_forward_to(25);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(1), 2));
+		assert_eq!(Balances::locks(2), vec![the_lock(20)]);
+		fast_forward_to(26);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(1), 2));
+		assert_eq!(Balances::locks(2), vec![]);
+	});
+}
+
+#[test]
+fn no_locks_without_conviction_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(0, 10)));
+
+		fast_forward_to(3);
+
+		assert_eq!(Balances::free_balance(42), 2);
+		assert_ok!(Democracy::remove_other_vote(RuntimeOrigin::signed(2), 1, r));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(2), 1));
+		assert_eq!(Balances::locks(1), vec![]);
+	});
+}
+
+#[test]
+fn lock_voting_should_work_with_delegation() {
+	new_test_ext().execute_with(|| {
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, nay(5, 10)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(2), r, aye(4, 20)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(3), r, aye(3, 30)));
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(4), 2, Conviction::Locked2x, 40));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, nay(1, 50)));
+
+		assert_eq!(tally(r), Tally { ayes: 250, nays: 100, turnout: 150 });
+
+		next_block();
+		next_block();
+
+		assert_eq!(Balances::free_balance(42), 2);
+	});
+}
+
+fn setup_three_referenda() -> (u32, u32, u32) {
+	System::set_block_number(0);
+	let r1 =
+		Democracy::inject_referendum(2, set_balance_proposal(2), VoteThreshold::SimpleMajority, 0);
+	assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r1, aye(4, 10)));
+
+	let r2 =
+		Democracy::inject_referendum(2, set_balance_proposal(2), VoteThreshold::SimpleMajority, 0);
+	assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r2, aye(3, 20)));
+
+	let r3 =
+		Democracy::inject_referendum(2, set_balance_proposal(2), VoteThreshold::SimpleMajority, 0);
+	assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r3, aye(2, 50)));
+
+	fast_forward_to(2);
+
+	(r1, r2, r3)
+}
+
+#[test]
+fn prior_lockvotes_should_be_enforced() {
+	new_test_ext().execute_with(|| {
+		let r = setup_three_referenda();
+		// r.0 locked 10 until 2 + 8 * 3 = #26
+		// r.1 locked 20 until 2 + 4 * 3 = #14
+		// r.2 locked 50 until 2 + 2 * 3 = #8
+
+		fast_forward_to(7);
+		assert_noop!(
+			Democracy::remove_other_vote(RuntimeOrigin::signed(1), 5, r.2),
+			Error::<Test>::NoPermission
+		);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(50)]);
+		fast_forward_to(8);
+		assert_ok!(Democracy::remove_other_vote(RuntimeOrigin::signed(1), 5, r.2));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(20)]);
+		fast_forward_to(13);
+		assert_noop!(
+			Democracy::remove_other_vote(RuntimeOrigin::signed(1), 5, r.1),
+			Error::<Test>::NoPermission
+		);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(20)]);
+		fast_forward_to(14);
+		assert_ok!(Democracy::remove_other_vote(RuntimeOrigin::signed(1), 5, r.1));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(10)]);
+		fast_forward_to(25);
+		assert_noop!(
+			Democracy::remove_other_vote(RuntimeOrigin::signed(1), 5, r.0),
+			Error::<Test>::NoPermission
+		);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(10)]);
+		fast_forward_to(26);
+		assert_ok!(Democracy::remove_other_vote(RuntimeOrigin::signed(1), 5, r.0));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![]);
+	});
+}
+
+#[test]
+fn single_consolidation_of_lockvotes_should_work_as_before() {
+	new_test_ext().execute_with(|| {
+		let r = setup_three_referenda();
+		// r.0 locked 10 until 2 + 8 * 3 = #26
+		// r.1 locked 20 until 2 + 4 * 3 = #14
+		// r.2 locked 50 until 2 + 2 * 3 = #8
+
+		fast_forward_to(7);
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.2));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(50)]);
+		fast_forward_to(8);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(20)]);
+
+		fast_forward_to(13);
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.1));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(20)]);
+		fast_forward_to(14);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(10)]);
+
+		fast_forward_to(25);
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.0));
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![the_lock(10)]);
+		fast_forward_to(26);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![]);
+	});
+}
+
+#[test]
+fn multi_consolidation_of_lockvotes_should_be_conservative() {
+	new_test_ext().execute_with(|| {
+		let r = setup_three_referenda();
+		// r.0 locked 10 until 2 + 8 * 3 = #26
+		// r.1 locked 20 until 2 + 4 * 3 = #14
+		// r.2 locked 50 until 2 + 2 * 3 = #8
+
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.2));
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.1));
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.0));
+
+		fast_forward_to(8);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount >= 20);
+
+		fast_forward_to(14);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount >= 10);
+
+		fast_forward_to(26);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![]);
+	});
+}
+
+#[test]
+fn locks_should_persist_from_voting_to_delegation() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SimpleMajority,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, aye(4, 10)));
+		fast_forward_to(2);
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r));
+		// locked 10 until #26.
+
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(5), 1, Conviction::Locked3x, 20));
+		// locked 20.
+		assert!(Balances::locks(5)[0].amount == 20);
+
+		assert_ok!(Democracy::undelegate(RuntimeOrigin::signed(5)));
+		// locked 20 until #14
+
+		fast_forward_to(13);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount == 20);
+
+		fast_forward_to(14);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount >= 10);
+
+		fast_forward_to(25);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount >= 10);
+
+		fast_forward_to(26);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![]);
+	});
+}
+
+#[test]
+fn locks_should_persist_from_delegation_to_voting() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_ok!(Democracy::delegate(RuntimeOrigin::signed(5), 1, Conviction::Locked5x, 5));
+		assert_ok!(Democracy::undelegate(RuntimeOrigin::signed(5)));
+		// locked 5 until 16 * 3 = #48
+
+		let r = setup_three_referenda();
+		// r.0 locked 10 until 2 + 8 * 3 = #26
+		// r.1 locked 20 until 2 + 4 * 3 = #14
+		// r.2 locked 50 until 2 + 2 * 3 = #8
+
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.2));
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.1));
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r.0));
+
+		fast_forward_to(8);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount >= 20);
+
+		fast_forward_to(14);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount >= 10);
+
+		fast_forward_to(26);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert!(Balances::locks(5)[0].amount >= 5);
+
+		fast_forward_to(48);
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![]);
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/metadata.rs b/substrate/frame/democracy/src/tests/metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5a36d80b72637dbae4d931016df11484f2228256
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/metadata.rs
@@ -0,0 +1,209 @@
+// 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.
+
+//! The tests for functionality concerning the metadata.
+
+use super::*;
+
+#[test]
+fn set_external_metadata_works() {
+	new_test_ext().execute_with(|| {
+		use frame_support::traits::Hash as PreimageHash;
+		// invalid preimage hash.
+		let invalid_hash: PreimageHash = [1u8; 32].into();
+		// metadata owner is an external proposal.
+		let owner = MetadataOwner::External;
+		// fails to set metadata if an external proposal does not exist.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(2), owner.clone(), Some(invalid_hash)),
+			Error::<Test>::NoProposal,
+		);
+		// create an external proposal.
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2)));
+		assert!(<NextExternal<Test>>::exists());
+		// fails to set metadata with non external origin.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), Some(invalid_hash)),
+			BadOrigin,
+		);
+		// fails to set non-existing preimage.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(2), owner.clone(), Some(invalid_hash)),
+			Error::<Test>::PreimageNotExist,
+		);
+		// set metadata successful.
+		let hash = note_preimage(1);
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::signed(2), owner.clone(), Some(hash)));
+		System::assert_last_event(RuntimeEvent::Democracy(crate::Event::MetadataSet {
+			owner,
+			hash,
+		}));
+	});
+}
+
+#[test]
+fn clear_metadata_works() {
+	new_test_ext().execute_with(|| {
+		// metadata owner is an external proposal.
+		let owner = MetadataOwner::External;
+		// create an external proposal.
+		assert_ok!(Democracy::external_propose(RuntimeOrigin::signed(2), set_balance_proposal(2)));
+		assert!(<NextExternal<Test>>::exists());
+		// set metadata.
+		let hash = note_preimage(1);
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::signed(2), owner.clone(), Some(hash)));
+		// fails to clear metadata with a wrong origin.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), None),
+			BadOrigin,
+		);
+		// clear metadata successful.
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::signed(2), owner.clone(), None));
+		System::assert_last_event(RuntimeEvent::Democracy(crate::Event::MetadataCleared {
+			owner,
+			hash,
+		}));
+	});
+}
+
+#[test]
+fn set_proposal_metadata_works() {
+	new_test_ext().execute_with(|| {
+		use frame_support::traits::Hash as PreimageHash;
+		// invalid preimage hash.
+		let invalid_hash: PreimageHash = [1u8; 32].into();
+		// create an external proposal.
+		assert_ok!(propose_set_balance(1, 2, 5));
+		// metadata owner is a public proposal.
+		let owner = MetadataOwner::Proposal(Democracy::public_prop_count() - 1);
+		// fails to set non-existing preimage.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), Some(invalid_hash)),
+			Error::<Test>::PreimageNotExist,
+		);
+		// note preimage.
+		let hash = note_preimage(1);
+		// fails to set a preimage if an origin is not a proposer.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(3), owner.clone(), Some(hash)),
+			Error::<Test>::NoPermission,
+		);
+		// set metadata successful.
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), Some(hash)));
+		System::assert_last_event(RuntimeEvent::Democracy(crate::Event::MetadataSet {
+			owner,
+			hash,
+		}));
+	});
+}
+
+#[test]
+fn clear_proposal_metadata_works() {
+	new_test_ext().execute_with(|| {
+		// create an external proposal.
+		assert_ok!(propose_set_balance(1, 2, 5));
+		// metadata owner is a public proposal.
+		let owner = MetadataOwner::Proposal(Democracy::public_prop_count() - 1);
+		// set metadata.
+		let hash = note_preimage(1);
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), Some(hash)));
+		// fails to clear metadata with a wrong origin.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(3), owner.clone(), None),
+			Error::<Test>::NoPermission,
+		);
+		// clear metadata successful.
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), None));
+		System::assert_last_event(RuntimeEvent::Democracy(crate::Event::MetadataCleared {
+			owner,
+			hash,
+		}));
+	});
+}
+
+#[test]
+fn set_referendum_metadata_by_root() {
+	new_test_ext().execute_with(|| {
+		let index = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		// metadata owner is a referendum.
+		let owner = MetadataOwner::Referendum(index);
+		// note preimage.
+		let hash = note_preimage(1);
+		// fails to set if not a root.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(3), owner.clone(), Some(hash)),
+			Error::<Test>::NoPermission,
+		);
+		// fails to clear if not a root.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(3), owner.clone(), None),
+			Error::<Test>::NoPermission,
+		);
+		// succeed to set metadata by a root for an ongoing referendum.
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::root(), owner.clone(), Some(hash)));
+		System::assert_last_event(RuntimeEvent::Democracy(crate::Event::MetadataSet {
+			owner: owner.clone(),
+			hash,
+		}));
+		// succeed to clear metadata by a root for an ongoing referendum.
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::root(), owner.clone(), None));
+		System::assert_last_event(RuntimeEvent::Democracy(crate::Event::MetadataCleared {
+			owner,
+			hash,
+		}));
+	});
+}
+
+#[test]
+fn clear_referendum_metadata_works() {
+	new_test_ext().execute_with(|| {
+		// create a referendum.
+		let index = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		// metadata owner is a referendum.
+		let owner = MetadataOwner::Referendum(index);
+		// set metadata.
+		let hash = note_preimage(1);
+		// referendum finished.
+		MetadataOf::<Test>::insert(owner.clone(), hash);
+		// no permission to clear metadata of an ongoing referendum.
+		assert_noop!(
+			Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), None),
+			Error::<Test>::NoPermission,
+		);
+		// referendum finished.
+		ReferendumInfoOf::<Test>::insert(
+			index,
+			ReferendumInfo::Finished { end: 1, approved: true },
+		);
+		// clear metadata successful.
+		assert_ok!(Democracy::set_metadata(RuntimeOrigin::signed(1), owner.clone(), None));
+		System::assert_last_event(RuntimeEvent::Democracy(crate::Event::MetadataCleared {
+			owner,
+			hash,
+		}));
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/public_proposals.rs b/substrate/frame/democracy/src/tests/public_proposals.rs
new file mode 100644
index 0000000000000000000000000000000000000000..69a2d3e25686f6a17337ff78c81d3c69a13ac345
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/public_proposals.rs
@@ -0,0 +1,153 @@
+// 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.
+
+//! The tests for the public proposal queue.
+
+use super::*;
+
+#[test]
+fn backing_for_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(propose_set_balance(1, 2, 2));
+		assert_ok!(propose_set_balance(1, 4, 4));
+		assert_ok!(propose_set_balance(1, 3, 3));
+		assert_eq!(Democracy::backing_for(0), Some(2));
+		assert_eq!(Democracy::backing_for(1), Some(4));
+		assert_eq!(Democracy::backing_for(2), Some(3));
+	});
+}
+
+#[test]
+fn deposit_for_proposals_should_be_taken() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(propose_set_balance(1, 2, 5));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(2), 0));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(5), 0));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(5), 0));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(5), 0));
+		assert_eq!(Balances::free_balance(1), 5);
+		assert_eq!(Balances::free_balance(2), 15);
+		assert_eq!(Balances::free_balance(5), 35);
+	});
+}
+
+#[test]
+fn deposit_for_proposals_should_be_returned() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(propose_set_balance(1, 2, 5));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(2), 0));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(5), 0));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(5), 0));
+		assert_ok!(Democracy::second(RuntimeOrigin::signed(5), 0));
+		fast_forward_to(3);
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 20);
+		assert_eq!(Balances::free_balance(5), 50);
+	});
+}
+
+#[test]
+fn proposal_with_deposit_below_minimum_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(propose_set_balance(1, 2, 0), Error::<Test>::ValueLow);
+	});
+}
+
+#[test]
+fn poor_proposer_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(propose_set_balance(1, 2, 11), BalancesError::<Test, _>::InsufficientBalance);
+	});
+}
+
+#[test]
+fn poor_seconder_should_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(propose_set_balance(2, 2, 11));
+		assert_noop!(
+			Democracy::second(RuntimeOrigin::signed(1), 0),
+			BalancesError::<Test, _>::InsufficientBalance
+		);
+	});
+}
+
+#[test]
+fn cancel_proposal_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(propose_set_balance(1, 2, 2));
+		assert_ok!(propose_set_balance(1, 4, 4));
+		assert_noop!(Democracy::cancel_proposal(RuntimeOrigin::signed(1), 0), BadOrigin);
+		let hash = note_preimage(1);
+		assert_ok!(Democracy::set_metadata(
+			RuntimeOrigin::signed(1),
+			MetadataOwner::Proposal(0),
+			Some(hash)
+		));
+		assert!(<MetadataOf<Test>>::get(MetadataOwner::Proposal(0)).is_some());
+		assert_ok!(Democracy::cancel_proposal(RuntimeOrigin::root(), 0));
+		// metadata cleared, preimage unrequested.
+		assert!(<MetadataOf<Test>>::get(MetadataOwner::Proposal(0)).is_none());
+		System::assert_has_event(crate::Event::ProposalCanceled { prop_index: 0 }.into());
+		System::assert_last_event(
+			crate::Event::MetadataCleared { owner: MetadataOwner::Proposal(0), hash }.into(),
+		);
+		assert_eq!(Democracy::backing_for(0), None);
+		assert_eq!(Democracy::backing_for(1), Some(4));
+	});
+}
+
+#[test]
+fn blacklisting_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		let hash = set_balance_proposal(2).hash();
+
+		assert_ok!(propose_set_balance(1, 2, 2));
+		assert_ok!(propose_set_balance(1, 4, 4));
+
+		assert_noop!(Democracy::blacklist(RuntimeOrigin::signed(1), hash, None), BadOrigin);
+		assert_ok!(Democracy::blacklist(RuntimeOrigin::root(), hash, None));
+
+		assert_eq!(Democracy::backing_for(0), None);
+		assert_eq!(Democracy::backing_for(1), Some(4));
+
+		assert_noop!(propose_set_balance(1, 2, 2), Error::<Test>::ProposalBlacklisted);
+
+		fast_forward_to(2);
+
+		let hash = set_balance_proposal(4).hash();
+		assert_ok!(Democracy::referendum_status(0));
+		assert_ok!(Democracy::blacklist(RuntimeOrigin::root(), hash, Some(0)));
+		assert_noop!(Democracy::referendum_status(0), Error::<Test>::ReferendumInvalid);
+	});
+}
+
+#[test]
+fn runners_up_should_come_after() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_ok!(propose_set_balance(1, 2, 2));
+		assert_ok!(propose_set_balance(1, 4, 4));
+		assert_ok!(propose_set_balance(1, 3, 3));
+		fast_forward_to(2);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), 0, aye(1)));
+		fast_forward_to(4);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), 1, aye(1)));
+		fast_forward_to(6);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), 2, aye(1)));
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/scheduling.rs b/substrate/frame/democracy/src/tests/scheduling.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fdbc8fdb34947ae1454355ebd4afd6493e7de992
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/scheduling.rs
@@ -0,0 +1,161 @@
+// 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.
+
+//! The tests for functionality concerning normal starting, ending and enacting of referenda.
+
+use super::*;
+
+#[test]
+fn simple_passing_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		assert_eq!(tally(r), Tally { ayes: 1, nays: 0, turnout: 10 });
+		assert_eq!(Democracy::lowest_unbaked(), 0);
+		next_block();
+		next_block();
+		assert_eq!(Democracy::lowest_unbaked(), 1);
+		assert_eq!(Balances::free_balance(42), 2);
+	});
+}
+
+#[test]
+fn simple_failing_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, nay(1)));
+		assert_eq!(tally(r), Tally { ayes: 0, nays: 1, turnout: 10 });
+
+		next_block();
+		next_block();
+
+		assert_eq!(Balances::free_balance(42), 0);
+	});
+}
+
+#[test]
+fn ooo_inject_referendums_should_work() {
+	new_test_ext().execute_with(|| {
+		let r1 = Democracy::inject_referendum(
+			3,
+			set_balance_proposal(3),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		let r2 = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r2, aye(1)));
+		assert_eq!(tally(r2), Tally { ayes: 1, nays: 0, turnout: 10 });
+
+		next_block();
+
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r1, aye(1)));
+		assert_eq!(tally(r1), Tally { ayes: 1, nays: 0, turnout: 10 });
+
+		next_block();
+		assert_eq!(Balances::free_balance(42), 2);
+
+		next_block();
+		assert_eq!(Balances::free_balance(42), 3);
+	});
+}
+
+#[test]
+fn delayed_enactment_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			1,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(2), r, aye(2)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(3), r, aye(3)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(4), r, aye(4)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, aye(5)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(6), r, aye(6)));
+
+		assert_eq!(tally(r), Tally { ayes: 21, nays: 0, turnout: 210 });
+
+		next_block();
+		assert_eq!(Balances::free_balance(42), 0);
+
+		next_block();
+		assert_eq!(Balances::free_balance(42), 2);
+	});
+}
+
+#[test]
+fn lowest_unbaked_should_be_sensible() {
+	new_test_ext().execute_with(|| {
+		let r1 = Democracy::inject_referendum(
+			3,
+			set_balance_proposal(1),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		let r2 = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		let r3 = Democracy::inject_referendum(
+			10,
+			set_balance_proposal(3),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r1, aye(1)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r2, aye(1)));
+		// r3 is canceled
+		assert_ok!(Democracy::cancel_referendum(RuntimeOrigin::root(), r3.into()));
+		assert_eq!(Democracy::lowest_unbaked(), 0);
+
+		next_block();
+		// r2 ends with approval
+		assert_eq!(Democracy::lowest_unbaked(), 0);
+
+		next_block();
+		// r1 ends with approval
+		assert_eq!(Democracy::lowest_unbaked(), 3);
+		assert_eq!(Democracy::lowest_unbaked(), Democracy::referendum_count());
+
+		// r2 is executed
+		assert_eq!(Balances::free_balance(42), 2);
+
+		next_block();
+		// r1 is executed
+		assert_eq!(Balances::free_balance(42), 1);
+	});
+}
diff --git a/substrate/frame/democracy/src/tests/voting.rs b/substrate/frame/democracy/src/tests/voting.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f096b633ee6d4a2b226dc5be0421523edb453de5
--- /dev/null
+++ b/substrate/frame/democracy/src/tests/voting.rs
@@ -0,0 +1,172 @@
+// 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.
+
+//! The tests for normal voting functionality.
+
+use super::*;
+
+#[test]
+fn overvoting_should_fail() {
+	new_test_ext().execute_with(|| {
+		let r = begin_referendum();
+		assert_noop!(
+			Democracy::vote(RuntimeOrigin::signed(1), r, aye(2)),
+			Error::<Test>::InsufficientFunds
+		);
+	});
+}
+
+#[test]
+fn split_voting_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = begin_referendum();
+		let v = AccountVote::Split { aye: 40, nay: 20 };
+		assert_noop!(
+			Democracy::vote(RuntimeOrigin::signed(5), r, v),
+			Error::<Test>::InsufficientFunds
+		);
+		let v = AccountVote::Split { aye: 30, nay: 20 };
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, v));
+
+		assert_eq!(tally(r), Tally { ayes: 3, nays: 2, turnout: 50 });
+	});
+}
+
+#[test]
+fn split_vote_cancellation_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = begin_referendum();
+		let v = AccountVote::Split { aye: 30, nay: 20 };
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, v));
+		assert_ok!(Democracy::remove_vote(RuntimeOrigin::signed(5), r));
+		assert_eq!(tally(r), Tally { ayes: 0, nays: 0, turnout: 0 });
+		assert_ok!(Democracy::unlock(RuntimeOrigin::signed(5), 5));
+		assert_eq!(Balances::locks(5), vec![]);
+	});
+}
+
+#[test]
+fn single_proposal_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert_ok!(propose_set_balance(1, 2, 1));
+		let r = 0;
+		assert!(Democracy::referendum_info(r).is_none());
+
+		// start of 2 => next referendum scheduled.
+		fast_forward_to(2);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, aye(1)));
+
+		assert_eq!(Democracy::referendum_count(), 1);
+		assert_eq!(
+			Democracy::referendum_status(0),
+			Ok(ReferendumStatus {
+				end: 4,
+				proposal: set_balance_proposal(2),
+				threshold: VoteThreshold::SuperMajorityApprove,
+				delay: 2,
+				tally: Tally { ayes: 1, nays: 0, turnout: 10 },
+			})
+		);
+
+		fast_forward_to(3);
+
+		// referendum still running
+		assert_ok!(Democracy::referendum_status(0));
+
+		// referendum runs during 2 and 3, ends @ start of 4.
+		fast_forward_to(4);
+
+		assert_noop!(Democracy::referendum_status(0), Error::<Test>::ReferendumInvalid);
+		assert!(pallet_scheduler::Agenda::<Test>::get(6)[0].is_some());
+
+		// referendum passes and wait another two blocks for enactment.
+		fast_forward_to(6);
+
+		assert_eq!(Balances::free_balance(42), 2);
+	});
+}
+
+#[test]
+fn controversial_voting_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(1), r, big_aye(1)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(2), r, big_nay(2)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(3), r, big_nay(3)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(4), r, big_aye(4)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, big_nay(5)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(6), r, big_aye(6)));
+
+		assert_eq!(tally(r), Tally { ayes: 110, nays: 100, turnout: 210 });
+
+		next_block();
+		next_block();
+
+		assert_eq!(Balances::free_balance(42), 2);
+	});
+}
+
+#[test]
+fn controversial_low_turnout_voting_should_work() {
+	new_test_ext().execute_with(|| {
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, big_nay(5)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(6), r, big_aye(6)));
+
+		assert_eq!(tally(r), Tally { ayes: 60, nays: 50, turnout: 110 });
+
+		next_block();
+		next_block();
+
+		assert_eq!(Balances::free_balance(42), 0);
+	});
+}
+
+#[test]
+fn passing_low_turnout_voting_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(42), 0);
+		assert_eq!(Balances::total_issuance(), 210);
+
+		let r = Democracy::inject_referendum(
+			2,
+			set_balance_proposal(2),
+			VoteThreshold::SuperMajorityApprove,
+			0,
+		);
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(4), r, big_aye(4)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(5), r, big_nay(5)));
+		assert_ok!(Democracy::vote(RuntimeOrigin::signed(6), r, big_aye(6)));
+		assert_eq!(tally(r), Tally { ayes: 100, nays: 50, turnout: 150 });
+
+		next_block();
+		next_block();
+		assert_eq!(Balances::free_balance(42), 2);
+	});
+}
diff --git a/substrate/frame/democracy/src/types.rs b/substrate/frame/democracy/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee6e2e0aa253793751053a4393a2409b42bbee0f
--- /dev/null
+++ b/substrate/frame/democracy/src/types.rs
@@ -0,0 +1,225 @@
+// 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.
+
+//! Miscellaneous additional datatypes.
+
+use crate::{AccountVote, Conviction, Vote, VoteThreshold};
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Bounded, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, Saturating, Zero},
+	RuntimeDebug,
+};
+
+/// A proposal index.
+pub type PropIndex = u32;
+
+/// A referendum index.
+pub type ReferendumIndex = u32;
+
+/// Info regarding an ongoing referendum.
+#[derive(Encode, MaxEncodedLen, Decode, Default, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Tally<Balance> {
+	/// The number of aye votes, expressed in terms of post-conviction lock-vote.
+	pub ayes: Balance,
+	/// The number of nay votes, expressed in terms of post-conviction lock-vote.
+	pub nays: Balance,
+	/// The amount of funds currently expressing its opinion. Pre-conviction.
+	pub turnout: Balance,
+}
+
+/// Amount of votes and capital placed in delegation for an account.
+#[derive(
+	Encode, MaxEncodedLen, Decode, Default, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo,
+)]
+pub struct Delegations<Balance> {
+	/// The number of votes (this is post-conviction).
+	pub votes: Balance,
+	/// The amount of raw capital, used for the turnout.
+	pub capital: Balance,
+}
+
+impl<Balance: Saturating> Saturating for Delegations<Balance> {
+	fn saturating_add(self, o: Self) -> Self {
+		Self {
+			votes: self.votes.saturating_add(o.votes),
+			capital: self.capital.saturating_add(o.capital),
+		}
+	}
+
+	fn saturating_sub(self, o: Self) -> Self {
+		Self {
+			votes: self.votes.saturating_sub(o.votes),
+			capital: self.capital.saturating_sub(o.capital),
+		}
+	}
+
+	fn saturating_mul(self, o: Self) -> Self {
+		Self {
+			votes: self.votes.saturating_mul(o.votes),
+			capital: self.capital.saturating_mul(o.capital),
+		}
+	}
+
+	fn saturating_pow(self, exp: usize) -> Self {
+		Self { votes: self.votes.saturating_pow(exp), capital: self.capital.saturating_pow(exp) }
+	}
+}
+
+impl<
+		Balance: From<u8>
+			+ Zero
+			+ Copy
+			+ CheckedAdd
+			+ CheckedSub
+			+ CheckedMul
+			+ CheckedDiv
+			+ Bounded
+			+ Saturating,
+	> Tally<Balance>
+{
+	/// Create a new tally.
+	pub fn new(vote: Vote, balance: Balance) -> Self {
+		let Delegations { votes, capital } = vote.conviction.votes(balance);
+		Self {
+			ayes: if vote.aye { votes } else { Zero::zero() },
+			nays: if vote.aye { Zero::zero() } else { votes },
+			turnout: capital,
+		}
+	}
+
+	/// Add an account's vote into the tally.
+	pub fn add(&mut self, vote: AccountVote<Balance>) -> Option<()> {
+		match vote {
+			AccountVote::Standard { vote, balance } => {
+				let Delegations { votes, capital } = vote.conviction.votes(balance);
+				self.turnout = self.turnout.checked_add(&capital)?;
+				match vote.aye {
+					true => self.ayes = self.ayes.checked_add(&votes)?,
+					false => self.nays = self.nays.checked_add(&votes)?,
+				}
+			},
+			AccountVote::Split { aye, nay } => {
+				let aye = Conviction::None.votes(aye);
+				let nay = Conviction::None.votes(nay);
+				self.turnout = self.turnout.checked_add(&aye.capital)?.checked_add(&nay.capital)?;
+				self.ayes = self.ayes.checked_add(&aye.votes)?;
+				self.nays = self.nays.checked_add(&nay.votes)?;
+			},
+		}
+		Some(())
+	}
+
+	/// Remove an account's vote from the tally.
+	pub fn remove(&mut self, vote: AccountVote<Balance>) -> Option<()> {
+		match vote {
+			AccountVote::Standard { vote, balance } => {
+				let Delegations { votes, capital } = vote.conviction.votes(balance);
+				self.turnout = self.turnout.checked_sub(&capital)?;
+				match vote.aye {
+					true => self.ayes = self.ayes.checked_sub(&votes)?,
+					false => self.nays = self.nays.checked_sub(&votes)?,
+				}
+			},
+			AccountVote::Split { aye, nay } => {
+				let aye = Conviction::None.votes(aye);
+				let nay = Conviction::None.votes(nay);
+				self.turnout = self.turnout.checked_sub(&aye.capital)?.checked_sub(&nay.capital)?;
+				self.ayes = self.ayes.checked_sub(&aye.votes)?;
+				self.nays = self.nays.checked_sub(&nay.votes)?;
+			},
+		}
+		Some(())
+	}
+
+	/// Increment some amount of votes.
+	pub fn increase(&mut self, approve: bool, delegations: Delegations<Balance>) -> Option<()> {
+		self.turnout = self.turnout.saturating_add(delegations.capital);
+		match approve {
+			true => self.ayes = self.ayes.saturating_add(delegations.votes),
+			false => self.nays = self.nays.saturating_add(delegations.votes),
+		}
+		Some(())
+	}
+
+	/// Decrement some amount of votes.
+	pub fn reduce(&mut self, approve: bool, delegations: Delegations<Balance>) -> Option<()> {
+		self.turnout = self.turnout.saturating_sub(delegations.capital);
+		match approve {
+			true => self.ayes = self.ayes.saturating_sub(delegations.votes),
+			false => self.nays = self.nays.saturating_sub(delegations.votes),
+		}
+		Some(())
+	}
+}
+
+/// Info regarding an ongoing referendum.
+#[derive(Encode, MaxEncodedLen, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct ReferendumStatus<BlockNumber, Proposal, Balance> {
+	/// When voting on this referendum will end.
+	pub end: BlockNumber,
+	/// The proposal being voted on.
+	pub proposal: Proposal,
+	/// The thresholding mechanism to determine whether it passed.
+	pub threshold: VoteThreshold,
+	/// The delay (in blocks) to wait after a successful referendum before deploying.
+	pub delay: BlockNumber,
+	/// The current tally of votes in this referendum.
+	pub tally: Tally<Balance>,
+}
+
+/// Info regarding a referendum, present or past.
+#[derive(Encode, MaxEncodedLen, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub enum ReferendumInfo<BlockNumber, Proposal, Balance> {
+	/// Referendum is happening, the arg is the block number at which it will end.
+	Ongoing(ReferendumStatus<BlockNumber, Proposal, Balance>),
+	/// Referendum finished at `end`, and has been `approved` or rejected.
+	Finished { approved: bool, end: BlockNumber },
+}
+
+impl<BlockNumber, Proposal, Balance: Default> ReferendumInfo<BlockNumber, Proposal, Balance> {
+	/// Create a new instance.
+	pub fn new(
+		end: BlockNumber,
+		proposal: Proposal,
+		threshold: VoteThreshold,
+		delay: BlockNumber,
+	) -> Self {
+		let s = ReferendumStatus { end, proposal, threshold, delay, tally: Tally::default() };
+		ReferendumInfo::Ongoing(s)
+	}
+}
+
+/// Whether an `unvote` operation is able to make actions that are not strictly always in the
+/// interest of an account.
+pub enum UnvoteScope {
+	/// Permitted to do everything.
+	Any,
+	/// Permitted to do only the changes that do not need the owner's permission.
+	OnlyExpired,
+}
+
+/// Identifies an owner of a metadata.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum MetadataOwner {
+	/// External proposal.
+	External,
+	/// Public proposal of the index.
+	Proposal(PropIndex),
+	/// Referendum of the index.
+	Referendum(ReferendumIndex),
+}
diff --git a/substrate/frame/democracy/src/vote.rs b/substrate/frame/democracy/src/vote.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b3fe9aa28e1ac4948761de52c0bec456f28e4618
--- /dev/null
+++ b/substrate/frame/democracy/src/vote.rs
@@ -0,0 +1,233 @@
+// 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.
+
+//! The vote datatype.
+
+use crate::{Conviction, Delegations, ReferendumIndex};
+use codec::{Decode, Encode, EncodeLike, Input, MaxEncodedLen, Output};
+use frame_support::traits::Get;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	BoundedVec, RuntimeDebug,
+};
+use sp_std::prelude::*;
+
+/// A number of lock periods, plus a vote, one way or the other.
+#[derive(Copy, Clone, Eq, PartialEq, Default, RuntimeDebug)]
+pub struct Vote {
+	pub aye: bool,
+	pub conviction: Conviction,
+}
+
+impl Encode for Vote {
+	fn encode_to<T: Output + ?Sized>(&self, output: &mut T) {
+		output.push_byte(u8::from(self.conviction) | if self.aye { 0b1000_0000 } else { 0 });
+	}
+}
+
+impl MaxEncodedLen for Vote {
+	fn max_encoded_len() -> usize {
+		1
+	}
+}
+
+impl EncodeLike for Vote {}
+
+impl Decode for Vote {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		let b = input.read_byte()?;
+		Ok(Vote {
+			aye: (b & 0b1000_0000) == 0b1000_0000,
+			conviction: Conviction::try_from(b & 0b0111_1111)
+				.map_err(|_| codec::Error::from("Invalid conviction"))?,
+		})
+	}
+}
+
+impl TypeInfo for Vote {
+	type Identity = Self;
+
+	fn type_info() -> scale_info::Type {
+		scale_info::Type::builder()
+			.path(scale_info::Path::new("Vote", module_path!()))
+			.composite(
+				scale_info::build::Fields::unnamed()
+					.field(|f| f.ty::<u8>().docs(&["Raw vote byte, encodes aye + conviction"])),
+			)
+	}
+}
+
+/// A vote for a referendum of a particular account.
+#[derive(Encode, MaxEncodedLen, Decode, Copy, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)]
+pub enum AccountVote<Balance> {
+	/// A standard vote, one-way (approve or reject) with a given amount of conviction.
+	Standard { vote: Vote, balance: Balance },
+	/// A split vote with balances given for both ways, and with no conviction, useful for
+	/// parachains when voting.
+	Split { aye: Balance, nay: Balance },
+}
+
+impl<Balance: Saturating> AccountVote<Balance> {
+	/// Returns `Some` of the lock periods that the account is locked for, assuming that the
+	/// referendum passed iff `approved` is `true`.
+	pub fn locked_if(self, approved: bool) -> Option<(u32, Balance)> {
+		// winning side: can only be removed after the lock period ends.
+		match self {
+			AccountVote::Standard { vote, balance } if vote.aye == approved =>
+				Some((vote.conviction.lock_periods(), balance)),
+			_ => None,
+		}
+	}
+
+	/// The total balance involved in this vote.
+	pub fn balance(self) -> Balance {
+		match self {
+			AccountVote::Standard { balance, .. } => balance,
+			AccountVote::Split { aye, nay } => aye.saturating_add(nay),
+		}
+	}
+
+	/// Returns `Some` with whether the vote is an aye vote if it is standard, otherwise `None` if
+	/// it is split.
+	pub fn as_standard(self) -> Option<bool> {
+		match self {
+			AccountVote::Standard { vote, .. } => Some(vote.aye),
+			_ => None,
+		}
+	}
+}
+
+/// A "prior" lock, i.e. a lock for some now-forgotten reason.
+#[derive(
+	Encode,
+	MaxEncodedLen,
+	Decode,
+	Default,
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	RuntimeDebug,
+	TypeInfo,
+)]
+pub struct PriorLock<BlockNumber, Balance>(BlockNumber, Balance);
+
+impl<BlockNumber: Ord + Copy + Zero, Balance: Ord + Copy + Zero> PriorLock<BlockNumber, Balance> {
+	/// Accumulates an additional lock.
+	pub fn accumulate(&mut self, until: BlockNumber, amount: Balance) {
+		self.0 = self.0.max(until);
+		self.1 = self.1.max(amount);
+	}
+
+	pub fn locked(&self) -> Balance {
+		self.1
+	}
+
+	pub fn rejig(&mut self, now: BlockNumber) {
+		if now >= self.0 {
+			self.0 = Zero::zero();
+			self.1 = Zero::zero();
+		}
+	}
+}
+
+/// An indicator for what an account is doing; it can either be delegating or voting.
+#[derive(Clone, Encode, Decode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)]
+#[codec(mel_bound(skip_type_params(MaxVotes)))]
+#[scale_info(skip_type_params(MaxVotes))]
+pub enum Voting<Balance, AccountId, BlockNumber, MaxVotes: Get<u32>> {
+	/// The account is voting directly. `delegations` is the total amount of post-conviction voting
+	/// weight that it controls from those that have delegated to it.
+	Direct {
+		/// The current votes of the account.
+		votes: BoundedVec<(ReferendumIndex, AccountVote<Balance>), MaxVotes>,
+		/// The total amount of delegations that this account has received.
+		delegations: Delegations<Balance>,
+		/// Any pre-existing locks from past voting/delegating activity.
+		prior: PriorLock<BlockNumber, Balance>,
+	},
+	/// The account is delegating `balance` of its balance to a `target` account with `conviction`.
+	Delegating {
+		balance: Balance,
+		target: AccountId,
+		conviction: Conviction,
+		/// The total amount of delegations that this account has received.
+		delegations: Delegations<Balance>,
+		/// Any pre-existing locks from past voting/delegating activity.
+		prior: PriorLock<BlockNumber, Balance>,
+	},
+}
+
+impl<Balance: Default, AccountId, BlockNumber: Zero, MaxVotes: Get<u32>> Default
+	for Voting<Balance, AccountId, BlockNumber, MaxVotes>
+{
+	fn default() -> Self {
+		Voting::Direct {
+			votes: Default::default(),
+			delegations: Default::default(),
+			prior: PriorLock(Zero::zero(), Default::default()),
+		}
+	}
+}
+
+impl<
+		Balance: Saturating + Ord + Zero + Copy,
+		BlockNumber: Ord + Copy + Zero,
+		AccountId,
+		MaxVotes: Get<u32>,
+	> Voting<Balance, AccountId, BlockNumber, MaxVotes>
+{
+	pub fn rejig(&mut self, now: BlockNumber) {
+		match self {
+			Voting::Direct { prior, .. } => prior,
+			Voting::Delegating { prior, .. } => prior,
+		}
+		.rejig(now);
+	}
+
+	/// The amount of this account's balance that must currently be locked due to voting.
+	pub fn locked_balance(&self) -> Balance {
+		match self {
+			Voting::Direct { votes, prior, .. } =>
+				votes.iter().map(|i| i.1.balance()).fold(prior.locked(), |a, i| a.max(i)),
+			Voting::Delegating { balance, prior, .. } => *balance.max(&prior.locked()),
+		}
+	}
+
+	pub fn set_common(
+		&mut self,
+		delegations: Delegations<Balance>,
+		prior: PriorLock<BlockNumber, Balance>,
+	) {
+		let (d, p) = match self {
+			Voting::Direct { ref mut delegations, ref mut prior, .. } => (delegations, prior),
+			Voting::Delegating { ref mut delegations, ref mut prior, .. } => (delegations, prior),
+		};
+		*d = delegations;
+		*p = prior;
+	}
+
+	pub fn prior(&self) -> &PriorLock<BlockNumber, Balance> {
+		match self {
+			Voting::Direct { prior, .. } => prior,
+			Voting::Delegating { prior, .. } => prior,
+		}
+	}
+}
diff --git a/substrate/frame/democracy/src/vote_threshold.rs b/substrate/frame/democracy/src/vote_threshold.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e8efa179ed8bf1ad68ac34aa2f19d90985143125
--- /dev/null
+++ b/substrate/frame/democracy/src/vote_threshold.rs
@@ -0,0 +1,121 @@
+// 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.
+
+//! Voting thresholds.
+
+use crate::Tally;
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+use sp_runtime::traits::{IntegerSquareRoot, Zero};
+use sp_std::ops::{Add, Div, Mul, Rem};
+
+/// A means of determining if a vote is past pass threshold.
+#[derive(
+	Clone, Copy, PartialEq, Eq, Encode, MaxEncodedLen, Decode, sp_runtime::RuntimeDebug, TypeInfo,
+)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum VoteThreshold {
+	/// A supermajority of approvals is needed to pass this vote.
+	SuperMajorityApprove,
+	/// A supermajority of rejects is needed to fail this vote.
+	SuperMajorityAgainst,
+	/// A simple majority of approvals is needed to pass this vote.
+	SimpleMajority,
+}
+
+pub trait Approved<Balance> {
+	/// Given a `tally` of votes and a total size of `electorate`, this returns `true` if the
+	/// overall outcome is in favor of approval according to `self`'s threshold method.
+	fn approved(&self, tally: Tally<Balance>, electorate: Balance) -> bool;
+}
+
+/// Return `true` iff `n1 / d1 < n2 / d2`. `d1` and `d2` may not be zero.
+fn compare_rationals<
+	T: Zero + Mul<T, Output = T> + Div<T, Output = T> + Rem<T, Output = T> + Ord + Copy,
+>(
+	mut n1: T,
+	mut d1: T,
+	mut n2: T,
+	mut d2: T,
+) -> bool {
+	// Uses a continued fractional representation for a non-overflowing compare.
+	// Detailed at https://janmr.com/blog/2014/05/comparing-rational-numbers-without-overflow/.
+	loop {
+		let q1 = n1 / d1;
+		let q2 = n2 / d2;
+		if q1 < q2 {
+			return true
+		}
+		if q2 < q1 {
+			return false
+		}
+		let r1 = n1 % d1;
+		let r2 = n2 % d2;
+		if r2.is_zero() {
+			return false
+		}
+		if r1.is_zero() {
+			return true
+		}
+		n1 = d2;
+		n2 = d1;
+		d1 = r2;
+		d2 = r1;
+	}
+}
+
+impl<
+		Balance: IntegerSquareRoot
+			+ Zero
+			+ Ord
+			+ Add<Balance, Output = Balance>
+			+ Mul<Balance, Output = Balance>
+			+ Div<Balance, Output = Balance>
+			+ Rem<Balance, Output = Balance>
+			+ Copy,
+	> Approved<Balance> for VoteThreshold
+{
+	fn approved(&self, tally: Tally<Balance>, electorate: Balance) -> bool {
+		let sqrt_voters = tally.turnout.integer_sqrt();
+		let sqrt_electorate = electorate.integer_sqrt();
+		if sqrt_voters.is_zero() {
+			return false
+		}
+		match *self {
+			VoteThreshold::SuperMajorityApprove =>
+				compare_rationals(tally.nays, sqrt_voters, tally.ayes, sqrt_electorate),
+			VoteThreshold::SuperMajorityAgainst =>
+				compare_rationals(tally.nays, sqrt_electorate, tally.ayes, sqrt_voters),
+			VoteThreshold::SimpleMajority => tally.ayes > tally.nays,
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_work() {
+		assert!(!VoteThreshold::SuperMajorityApprove
+			.approved(Tally { ayes: 60, nays: 50, turnout: 110 }, 210));
+		assert!(VoteThreshold::SuperMajorityApprove
+			.approved(Tally { ayes: 100, nays: 50, turnout: 150 }, 210));
+	}
+}
diff --git a/substrate/frame/democracy/src/weights.rs b/substrate/frame/democracy/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..241f6c3cb38de2c270411cd2d39913f857bbe807
--- /dev/null
+++ b/substrate/frame/democracy/src/weights.rs
@@ -0,0 +1,986 @@
+// 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.
+
+//! Autogenerated weights for pallet_democracy
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_democracy
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/democracy/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_democracy.
+pub trait WeightInfo {
+	fn propose() -> Weight;
+	fn second() -> Weight;
+	fn vote_new() -> Weight;
+	fn vote_existing() -> Weight;
+	fn emergency_cancel() -> Weight;
+	fn blacklist() -> Weight;
+	fn external_propose() -> Weight;
+	fn external_propose_majority() -> Weight;
+	fn external_propose_default() -> Weight;
+	fn fast_track() -> Weight;
+	fn veto_external() -> Weight;
+	fn cancel_proposal() -> Weight;
+	fn cancel_referendum() -> Weight;
+	fn on_initialize_base(r: u32, ) -> Weight;
+	fn on_initialize_base_with_launch_period(r: u32, ) -> Weight;
+	fn delegate(r: u32, ) -> Weight;
+	fn undelegate(r: u32, ) -> Weight;
+	fn clear_public_proposals() -> Weight;
+	fn unlock_remove(r: u32, ) -> Weight;
+	fn unlock_set(r: u32, ) -> Weight;
+	fn remove_vote(r: u32, ) -> Weight;
+	fn remove_other_vote(r: u32, ) -> Weight;
+	fn set_external_metadata() -> Weight;
+	fn clear_external_metadata() -> Weight;
+	fn set_proposal_metadata() -> Weight;
+	fn clear_proposal_metadata() -> Weight;
+	fn set_referendum_metadata() -> Weight;
+	fn clear_referendum_metadata() -> Weight;
+}
+
+/// Weights for pallet_democracy using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Democracy PublicPropCount (r:1 w:1)
+	/// Proof: Democracy PublicPropCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy PublicProps (r:1 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:1 w:0)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	/// Storage: Democracy DepositOf (r:0 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	fn propose() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4801`
+		//  Estimated: `18187`
+		// Minimum execution time: 49_339_000 picoseconds.
+		Weight::from_parts(50_942_000, 18187)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy DepositOf (r:1 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	fn second() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3556`
+		//  Estimated: `6695`
+		// Minimum execution time: 43_291_000 picoseconds.
+		Weight::from_parts(44_856_000, 6695)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	fn vote_new() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3470`
+		//  Estimated: `7260`
+		// Minimum execution time: 61_890_000 picoseconds.
+		Weight::from_parts(63_626_000, 7260)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	fn vote_existing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3492`
+		//  Estimated: `7260`
+		// Minimum execution time: 67_802_000 picoseconds.
+		Weight::from_parts(69_132_000, 7260)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy Cancellations (r:1 w:1)
+	/// Proof: Democracy Cancellations (max_values: None, max_size: Some(33), added: 2508, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn emergency_cancel() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `366`
+		//  Estimated: `3666`
+		// Minimum execution time: 25_757_000 picoseconds.
+		Weight::from_parts(27_226_000, 3666)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy DepositOf (r:1 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:3 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:0 w:1)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	fn blacklist() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `5910`
+		//  Estimated: `18187`
+		// Minimum execution time: 113_060_000 picoseconds.
+		Weight::from_parts(114_813_000, 18187)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:1 w:0)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	fn external_propose() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3416`
+		//  Estimated: `6703`
+		// Minimum execution time: 13_413_000 picoseconds.
+		Weight::from_parts(13_794_000, 6703)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:0 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	fn external_propose_majority() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_213_000 picoseconds.
+		Weight::from_parts(3_429_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:0 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	fn external_propose_default() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_280_000 picoseconds.
+		Weight::from_parts(3_389_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumCount (r:1 w:1)
+	/// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:2)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:0 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	fn fast_track() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `286`
+		//  Estimated: `3518`
+		// Minimum execution time: 28_142_000 picoseconds.
+		Weight::from_parts(28_862_000, 3518)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:1 w:1)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn veto_external() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3519`
+		//  Estimated: `6703`
+		// Minimum execution time: 32_395_000 picoseconds.
+		Weight::from_parts(33_617_000, 6703)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy DepositOf (r:1 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn cancel_proposal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `5821`
+		//  Estimated: `18187`
+		// Minimum execution time: 92_255_000 picoseconds.
+		Weight::from_parts(93_704_000, 18187)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:0 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	fn cancel_referendum() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `271`
+		//  Estimated: `3518`
+		// Minimum execution time: 19_623_000 picoseconds.
+		Weight::from_parts(20_545_000, 3518)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Democracy LowestUnbaked (r:1 w:1)
+	/// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumCount (r:1 w:0)
+	/// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:0)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn on_initialize_base(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244 + r * (86 ±0)`
+		//  Estimated: `1489 + r * (2676 ±0)`
+		// Minimum execution time: 7_032_000 picoseconds.
+		Weight::from_parts(7_931_421, 1489)
+			// Standard Error: 7_395
+			.saturating_add(Weight::from_parts(3_236_964, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy LowestUnbaked (r:1 w:1)
+	/// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumCount (r:1 w:0)
+	/// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy LastTabledWasExternal (r:1 w:0)
+	/// Proof: Democracy LastTabledWasExternal (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Democracy NextExternal (r:1 w:0)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy PublicProps (r:1 w:0)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:0)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn on_initialize_base_with_launch_period(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244 + r * (86 ±0)`
+		//  Estimated: `18187 + r * (2676 ±0)`
+		// Minimum execution time: 10_524_000 picoseconds.
+		Weight::from_parts(10_369_064, 18187)
+			// Standard Error: 8_385
+			.saturating_add(Weight::from_parts(3_242_334, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy VotingOf (r:3 w:3)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:99)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn delegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (108 ±0)`
+		//  Estimated: `19800 + r * (2676 ±0)`
+		// Minimum execution time: 46_106_000 picoseconds.
+		Weight::from_parts(48_936_654, 19800)
+			// Standard Error: 8_879
+			.saturating_add(Weight::from_parts(4_708_141, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy VotingOf (r:2 w:2)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:99)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn undelegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `493 + r * (108 ±0)`
+		//  Estimated: `13530 + r * (2676 ±0)`
+		// Minimum execution time: 21_078_000 picoseconds.
+		Weight::from_parts(22_732_737, 13530)
+			// Standard Error: 7_969
+			.saturating_add(Weight::from_parts(4_626_458, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy PublicProps (r:0 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	fn clear_public_proposals() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_229_000 picoseconds.
+		Weight::from_parts(3_415_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn unlock_remove(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `563`
+		//  Estimated: `7260`
+		// Minimum execution time: 25_735_000 picoseconds.
+		Weight::from_parts(41_341_468, 7260)
+			// Standard Error: 3_727
+			.saturating_add(Weight::from_parts(94_755, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn unlock_set(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `564 + r * (22 ±0)`
+		//  Estimated: `7260`
+		// Minimum execution time: 36_233_000 picoseconds.
+		Weight::from_parts(39_836_017, 7260)
+			// Standard Error: 1_791
+			.saturating_add(Weight::from_parts(132_158, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 100]`.
+	fn remove_vote(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `728 + r * (26 ±0)`
+		//  Estimated: `7260`
+		// Minimum execution time: 16_081_000 picoseconds.
+		Weight::from_parts(19_624_101, 7260)
+			// Standard Error: 1_639
+			.saturating_add(Weight::from_parts(133_630, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 100]`.
+	fn remove_other_vote(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `728 + r * (26 ±0)`
+		//  Estimated: `7260`
+		// Minimum execution time: 15_634_000 picoseconds.
+		Weight::from_parts(19_573_407, 7260)
+			// Standard Error: 1_790
+			.saturating_add(Weight::from_parts(139_707, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:0)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:0 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn set_external_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `356`
+		//  Estimated: `3556`
+		// Minimum execution time: 18_344_000 picoseconds.
+		Weight::from_parts(18_727_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:0)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn clear_external_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `286`
+		//  Estimated: `3518`
+		// Minimum execution time: 16_497_000 picoseconds.
+		Weight::from_parts(16_892_000, 3518)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:0)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:0 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn set_proposal_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4888`
+		//  Estimated: `18187`
+		// Minimum execution time: 39_517_000 picoseconds.
+		Weight::from_parts(40_632_000, 18187)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:0)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn clear_proposal_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4822`
+		//  Estimated: `18187`
+		// Minimum execution time: 37_108_000 picoseconds.
+		Weight::from_parts(37_599_000, 18187)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:0 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn set_referendum_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 13_997_000 picoseconds.
+		Weight::from_parts(14_298_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:0)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn clear_referendum_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `302`
+		//  Estimated: `3666`
+		// Minimum execution time: 18_122_000 picoseconds.
+		Weight::from_parts(18_655_000, 3666)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Democracy PublicPropCount (r:1 w:1)
+	/// Proof: Democracy PublicPropCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy PublicProps (r:1 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:1 w:0)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	/// Storage: Democracy DepositOf (r:0 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	fn propose() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4801`
+		//  Estimated: `18187`
+		// Minimum execution time: 49_339_000 picoseconds.
+		Weight::from_parts(50_942_000, 18187)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy DepositOf (r:1 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	fn second() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3556`
+		//  Estimated: `6695`
+		// Minimum execution time: 43_291_000 picoseconds.
+		Weight::from_parts(44_856_000, 6695)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	fn vote_new() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3470`
+		//  Estimated: `7260`
+		// Minimum execution time: 61_890_000 picoseconds.
+		Weight::from_parts(63_626_000, 7260)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	fn vote_existing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3492`
+		//  Estimated: `7260`
+		// Minimum execution time: 67_802_000 picoseconds.
+		Weight::from_parts(69_132_000, 7260)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy Cancellations (r:1 w:1)
+	/// Proof: Democracy Cancellations (max_values: None, max_size: Some(33), added: 2508, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn emergency_cancel() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `366`
+		//  Estimated: `3666`
+		// Minimum execution time: 25_757_000 picoseconds.
+		Weight::from_parts(27_226_000, 3666)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy DepositOf (r:1 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:3 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:0 w:1)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	fn blacklist() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `5910`
+		//  Estimated: `18187`
+		// Minimum execution time: 113_060_000 picoseconds.
+		Weight::from_parts(114_813_000, 18187)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:1 w:0)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	fn external_propose() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3416`
+		//  Estimated: `6703`
+		// Minimum execution time: 13_413_000 picoseconds.
+		Weight::from_parts(13_794_000, 6703)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:0 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	fn external_propose_majority() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_213_000 picoseconds.
+		Weight::from_parts(3_429_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:0 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	fn external_propose_default() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_280_000 picoseconds.
+		Weight::from_parts(3_389_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumCount (r:1 w:1)
+	/// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:2)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:0 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	fn fast_track() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `286`
+		//  Estimated: `3518`
+		// Minimum execution time: 28_142_000 picoseconds.
+		Weight::from_parts(28_862_000, 3518)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:1)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy Blacklist (r:1 w:1)
+	/// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn veto_external() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3519`
+		//  Estimated: `6703`
+		// Minimum execution time: 32_395_000 picoseconds.
+		Weight::from_parts(33_617_000, 6703)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy DepositOf (r:1 w:1)
+	/// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn cancel_proposal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `5821`
+		//  Estimated: `18187`
+		// Minimum execution time: 92_255_000 picoseconds.
+		Weight::from_parts(93_704_000, 18187)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:0 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	fn cancel_referendum() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `271`
+		//  Estimated: `3518`
+		// Minimum execution time: 19_623_000 picoseconds.
+		Weight::from_parts(20_545_000, 3518)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Democracy LowestUnbaked (r:1 w:1)
+	/// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumCount (r:1 w:0)
+	/// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:0)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn on_initialize_base(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244 + r * (86 ±0)`
+		//  Estimated: `1489 + r * (2676 ±0)`
+		// Minimum execution time: 7_032_000 picoseconds.
+		Weight::from_parts(7_931_421, 1489)
+			// Standard Error: 7_395
+			.saturating_add(Weight::from_parts(3_236_964, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy LowestUnbaked (r:1 w:1)
+	/// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumCount (r:1 w:0)
+	/// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Democracy LastTabledWasExternal (r:1 w:0)
+	/// Proof: Democracy LastTabledWasExternal (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Democracy NextExternal (r:1 w:0)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy PublicProps (r:1 w:0)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:0)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn on_initialize_base_with_launch_period(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `244 + r * (86 ±0)`
+		//  Estimated: `18187 + r * (2676 ±0)`
+		// Minimum execution time: 10_524_000 picoseconds.
+		Weight::from_parts(10_369_064, 18187)
+			// Standard Error: 8_385
+			.saturating_add(Weight::from_parts(3_242_334, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy VotingOf (r:3 w:3)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:99)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn delegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `830 + r * (108 ±0)`
+		//  Estimated: `19800 + r * (2676 ±0)`
+		// Minimum execution time: 46_106_000 picoseconds.
+		Weight::from_parts(48_936_654, 19800)
+			// Standard Error: 8_879
+			.saturating_add(Weight::from_parts(4_708_141, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy VotingOf (r:2 w:2)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// Storage: Democracy ReferendumInfoOf (r:99 w:99)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn undelegate(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `493 + r * (108 ±0)`
+		//  Estimated: `13530 + r * (2676 ±0)`
+		// Minimum execution time: 21_078_000 picoseconds.
+		Weight::from_parts(22_732_737, 13530)
+			// Standard Error: 7_969
+			.saturating_add(Weight::from_parts(4_626_458, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into()))
+	}
+	/// Storage: Democracy PublicProps (r:0 w:1)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	fn clear_public_proposals() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_229_000 picoseconds.
+		Weight::from_parts(3_415_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn unlock_remove(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `563`
+		//  Estimated: `7260`
+		// Minimum execution time: 25_735_000 picoseconds.
+		Weight::from_parts(41_341_468, 7260)
+			// Standard Error: 3_727
+			.saturating_add(Weight::from_parts(94_755, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 99]`.
+	fn unlock_set(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `564 + r * (22 ±0)`
+		//  Estimated: `7260`
+		// Minimum execution time: 36_233_000 picoseconds.
+		Weight::from_parts(39_836_017, 7260)
+			// Standard Error: 1_791
+			.saturating_add(Weight::from_parts(132_158, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 100]`.
+	fn remove_vote(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `728 + r * (26 ±0)`
+		//  Estimated: `7260`
+		// Minimum execution time: 16_081_000 picoseconds.
+		Weight::from_parts(19_624_101, 7260)
+			// Standard Error: 1_639
+			.saturating_add(Weight::from_parts(133_630, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:1)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy VotingOf (r:1 w:1)
+	/// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 100]`.
+	fn remove_other_vote(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `728 + r * (26 ±0)`
+		//  Estimated: `7260`
+		// Minimum execution time: 15_634_000 picoseconds.
+		Weight::from_parts(19_573_407, 7260)
+			// Standard Error: 1_790
+			.saturating_add(Weight::from_parts(139_707, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:0)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:0 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn set_external_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `356`
+		//  Estimated: `3556`
+		// Minimum execution time: 18_344_000 picoseconds.
+		Weight::from_parts(18_727_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy NextExternal (r:1 w:0)
+	/// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn clear_external_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `286`
+		//  Estimated: `3518`
+		// Minimum execution time: 16_497_000 picoseconds.
+		Weight::from_parts(16_892_000, 3518)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:0)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:0 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn set_proposal_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4888`
+		//  Estimated: `18187`
+		// Minimum execution time: 39_517_000 picoseconds.
+		Weight::from_parts(40_632_000, 18187)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy PublicProps (r:1 w:0)
+	/// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn clear_proposal_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4822`
+		//  Estimated: `18187`
+		// Minimum execution time: 37_108_000 picoseconds.
+		Weight::from_parts(37_599_000, 18187)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:0 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn set_referendum_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 13_997_000 picoseconds.
+		Weight::from_parts(14_298_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Democracy ReferendumInfoOf (r:1 w:0)
+	/// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen)
+	/// Storage: Democracy MetadataOf (r:1 w:1)
+	/// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen)
+	fn clear_referendum_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `302`
+		//  Estimated: `3666`
+		// Minimum execution time: 18_122_000 picoseconds.
+		Weight::from_parts(18_655_000, 3666)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/election-provider-multi-phase/Cargo.toml b/substrate/frame/election-provider-multi-phase/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0ccde14bc4c6c06e85453a99c8eabf21daf46560
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/Cargo.toml
@@ -0,0 +1,90 @@
+[package]
+name = "pallet-election-provider-multi-phase"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "PALLET two phase election providers"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = [
+	"derive",
+] }
+log = { version = "0.4.17", default-features = false }
+
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../primitives/npos-elections" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+frame-election-provider-support = { version = "4.0.0-dev", default-features = false, path = "../election-provider-support" }
+
+# Optional imports for benchmarking
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
+pallet-election-provider-support-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../election-provider-support/benchmarking", optional = true }
+rand = { version = "0.8.5", default-features = false, features = ["alloc", "small_rng"], optional = true }
+strum = { version = "0.24.1",  default-features = false, features = ["derive"], optional = true }
+
+[dev-dependencies]
+parking_lot = "0.12.1"
+rand = "0.8.5"
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../primitives/npos-elections" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+frame-benchmarking = { version = "4.0.0-dev", path = "../benchmarking" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-election-provider-support-benchmarking?/std",
+	"rand/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-npos-elections/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-tracing/std",
+	"strum/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-election-provider-support-benchmarking?/runtime-benchmarks",
+	"rand",
+	"sp-runtime/runtime-benchmarks",
+	"strum",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/election-provider-multi-phase/src/benchmarking.rs b/substrate/frame/election-provider-multi-phase/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4a2855f1361f2c7f098a023e74344e1062be7506
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/benchmarking.rs
@@ -0,0 +1,538 @@
+// 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.
+
+//! Two phase election pallet benchmarking.
+
+use super::*;
+use crate::{unsigned::IndexAssignmentOf, Pallet as MultiPhase};
+use frame_benchmarking::account;
+use frame_election_provider_support::bounds::DataProviderBounds;
+use frame_support::{
+	assert_ok,
+	traits::{Hooks, TryCollect},
+	BoundedVec,
+};
+use frame_system::RawOrigin;
+use rand::{prelude::SliceRandom, rngs::SmallRng, SeedableRng};
+use sp_arithmetic::{per_things::Percent, traits::One};
+use sp_runtime::InnerOf;
+
+const SEED: u32 = 999;
+
+/// Creates a **valid** solution with exactly the given size.
+///
+/// The snapshot is also created internally.
+fn solution_with_size<T: Config>(
+	size: SolutionOrSnapshotSize,
+	active_voters_count: u32,
+	desired_targets: u32,
+) -> Result<RawSolution<SolutionOf<T::MinerConfig>>, &'static str> {
+	ensure!(size.targets >= desired_targets, "must have enough targets");
+	ensure!(
+		size.targets >= (<SolutionOf<T::MinerConfig>>::LIMIT * 2) as u32,
+		"must have enough targets for unique votes."
+	);
+	ensure!(size.voters >= active_voters_count, "must have enough voters");
+	ensure!(
+		(<SolutionOf<T::MinerConfig>>::LIMIT as u32) < desired_targets,
+		"must have enough winners to give them votes."
+	);
+
+	let ed: VoteWeight = T::Currency::minimum_balance().saturated_into::<u64>();
+	let stake: VoteWeight = ed.max(One::one()).saturating_mul(100);
+
+	// first generates random targets.
+	let targets: Vec<T::AccountId> = (0..size.targets)
+		.map(|i| frame_benchmarking::account("Targets", i, SEED))
+		.collect();
+
+	let mut rng = SmallRng::seed_from_u64(SEED.into());
+
+	// decide who are the winners.
+	let winners = targets
+		.as_slice()
+		.choose_multiple(&mut rng, desired_targets as usize)
+		.cloned()
+		.collect::<Vec<_>>();
+
+	// first generate active voters who must vote for a subset of winners.
+	let active_voters = (0..active_voters_count)
+		.map(|i| {
+			// chose a random subset of winners.
+			let winner_votes: BoundedVec<_, _> = winners
+				.as_slice()
+				.choose_multiple(&mut rng, <SolutionOf<T::MinerConfig>>::LIMIT)
+				.cloned()
+				.try_collect()
+				.expect("<SolutionOf<T::MinerConfig>>::LIMIT is the correct bound; qed.");
+			let voter = frame_benchmarking::account::<T::AccountId>("Voter", i, SEED);
+			(voter, stake, winner_votes)
+		})
+		.collect::<Vec<_>>();
+
+	// rest of the voters. They can only vote for non-winners.
+	let non_winners = targets
+		.iter()
+		.filter(|t| !winners.contains(t))
+		.cloned()
+		.collect::<Vec<T::AccountId>>();
+	let rest_voters = (active_voters_count..size.voters)
+		.map(|i| {
+			let votes: BoundedVec<_, _> = (&non_winners)
+				.choose_multiple(&mut rng, <SolutionOf<T::MinerConfig>>::LIMIT)
+				.cloned()
+				.try_collect()
+				.expect("<SolutionOf<T::MinerConfig>>::LIMIT is the correct bound; qed.");
+			let voter = frame_benchmarking::account::<T::AccountId>("Voter", i, SEED);
+			(voter, stake, votes)
+		})
+		.collect::<Vec<_>>();
+
+	let mut all_voters = active_voters.clone();
+	all_voters.extend(rest_voters);
+	all_voters.shuffle(&mut rng);
+
+	assert_eq!(active_voters.len() as u32, active_voters_count);
+	assert_eq!(all_voters.len() as u32, size.voters);
+	assert_eq!(winners.len() as u32, desired_targets);
+
+	<SnapshotMetadata<T>>::put(SolutionOrSnapshotSize {
+		voters: all_voters.len() as u32,
+		targets: targets.len() as u32,
+	});
+	<DesiredTargets<T>>::put(desired_targets);
+	<Snapshot<T>>::put(RoundSnapshot { voters: all_voters.clone(), targets: targets.clone() });
+
+	// write the snapshot to staking or whoever is the data provider, in case it is needed further
+	// down the road.
+	T::DataProvider::put_snapshot(all_voters.clone(), targets.clone(), Some(stake));
+
+	let cache = helpers::generate_voter_cache::<T::MinerConfig>(&all_voters);
+	let stake_of = helpers::stake_of_fn::<T::MinerConfig>(&all_voters, &cache);
+	let voter_index = helpers::voter_index_fn::<T::MinerConfig>(&cache);
+	let target_index = helpers::target_index_fn::<T::MinerConfig>(&targets);
+	let voter_at = helpers::voter_at_fn::<T::MinerConfig>(&all_voters);
+	let target_at = helpers::target_at_fn::<T::MinerConfig>(&targets);
+
+	let assignments = active_voters
+		.iter()
+		.map(|(voter, _stake, votes)| {
+			let percent_per_edge: InnerOf<SolutionAccuracyOf<T>> =
+				(100 / votes.len()).try_into().unwrap_or_else(|_| panic!("failed to convert"));
+			crate::unsigned::Assignment::<T> {
+				who: voter.clone(),
+				distribution: votes
+					.iter()
+					.map(|t| (t.clone(), <SolutionAccuracyOf<T>>::from_percent(percent_per_edge)))
+					.collect::<Vec<_>>(),
+			}
+		})
+		.collect::<Vec<_>>();
+
+	let solution =
+		<SolutionOf<T::MinerConfig>>::from_assignment(&assignments, &voter_index, &target_index)
+			.unwrap();
+	let score = solution.clone().score(stake_of, voter_at, target_at).unwrap();
+	let round = <MultiPhase<T>>::round();
+
+	assert!(
+		score.minimal_stake > 0,
+		"score is zero, this probably means that the stakes are not set."
+	);
+	Ok(RawSolution { solution, score, round })
+}
+
+fn set_up_data_provider<T: Config>(v: u32, t: u32) {
+	T::DataProvider::clear();
+	log!(
+		info,
+		"setting up with voters = {} [degree = {}], targets = {}",
+		v,
+		<T::DataProvider as ElectionDataProvider>::MaxVotesPerVoter::get(),
+		t
+	);
+
+	// fill targets.
+	let mut targets = (0..t)
+		.map(|i| {
+			let target = frame_benchmarking::account::<T::AccountId>("Target", i, SEED);
+
+			T::DataProvider::add_target(target.clone());
+			target
+		})
+		.collect::<Vec<_>>();
+
+	// we should always have enough voters to fill.
+	assert!(
+		targets.len() > <T::DataProvider as ElectionDataProvider>::MaxVotesPerVoter::get() as usize
+	);
+	targets.truncate(<T::DataProvider as ElectionDataProvider>::MaxVotesPerVoter::get() as usize);
+
+	// fill voters.
+	(0..v).for_each(|i| {
+		let voter = frame_benchmarking::account::<T::AccountId>("Voter", i, SEED);
+		let weight = T::Currency::minimum_balance().saturated_into::<u64>() * 1000;
+		T::DataProvider::add_voter(voter, weight, targets.clone().try_into().unwrap());
+	});
+}
+
+frame_benchmarking::benchmarks! {
+	on_initialize_nothing {
+		assert!(<MultiPhase<T>>::current_phase().is_off());
+	}: {
+		<MultiPhase<T>>::on_initialize(1u32.into());
+	} verify {
+		assert!(<MultiPhase<T>>::current_phase().is_off());
+	}
+
+	on_initialize_open_signed {
+		assert!(<MultiPhase<T>>::snapshot().is_none());
+		assert!(<MultiPhase<T>>::current_phase().is_off());
+	}: {
+		<MultiPhase<T>>::phase_transition(Phase::Signed);
+	} verify {
+		assert!(<MultiPhase<T>>::snapshot().is_none());
+		assert!(<MultiPhase<T>>::current_phase().is_signed());
+	}
+
+	on_initialize_open_unsigned {
+		assert!(<MultiPhase<T>>::snapshot().is_none());
+		assert!(<MultiPhase<T>>::current_phase().is_off());
+	}: {
+		let now = frame_system::Pallet::<T>::block_number();
+		<MultiPhase<T>>::phase_transition(Phase::Unsigned((true, now)));
+	} verify {
+		assert!(<MultiPhase<T>>::snapshot().is_none());
+		assert!(<MultiPhase<T>>::current_phase().is_unsigned());
+	}
+
+	finalize_signed_phase_accept_solution {
+		let receiver = account("receiver", 0, SEED);
+		let initial_balance = T::Currency::minimum_balance() + 10u32.into();
+		T::Currency::make_free_balance_be(&receiver, initial_balance);
+		let ready = Default::default();
+		let deposit: BalanceOf<T> = 10u32.into();
+
+		let reward: BalanceOf<T> = T::SignedRewardBase::get();
+		let call_fee: BalanceOf<T> = 30u32.into();
+
+		assert_ok!(T::Currency::reserve(&receiver, deposit));
+		assert_eq!(T::Currency::free_balance(&receiver), T::Currency::minimum_balance());
+	}: {
+		<MultiPhase<T>>::finalize_signed_phase_accept_solution(
+			ready,
+			&receiver,
+			deposit,
+			call_fee
+		)
+	} verify {
+		assert_eq!(
+			T::Currency::free_balance(&receiver),
+			initial_balance + reward + call_fee
+		);
+		assert_eq!(T::Currency::reserved_balance(&receiver), 0u32.into());
+	}
+
+	finalize_signed_phase_reject_solution {
+		let receiver = account("receiver", 0, SEED);
+		let initial_balance = T::Currency::minimum_balance() + 10u32.into();
+		let deposit: BalanceOf<T> = 10u32.into();
+		T::Currency::make_free_balance_be(&receiver, initial_balance);
+		assert_ok!(T::Currency::reserve(&receiver, deposit));
+
+		assert_eq!(T::Currency::free_balance(&receiver), T::Currency::minimum_balance());
+		assert_eq!(T::Currency::reserved_balance(&receiver), 10u32.into());
+	}: {
+		<MultiPhase<T>>::finalize_signed_phase_reject_solution(&receiver, deposit)
+	} verify {
+		assert_eq!(T::Currency::free_balance(&receiver), T::Currency::minimum_balance());
+		assert_eq!(T::Currency::reserved_balance(&receiver), 0u32.into());
+	}
+
+	create_snapshot_internal {
+		// number of votes in snapshot.
+		let v in (T::BenchmarkingConfig::VOTERS[0]) .. T::BenchmarkingConfig::VOTERS[1];
+		// number of targets in snapshot.
+		let t in (T::BenchmarkingConfig::TARGETS[0]) .. T::BenchmarkingConfig::TARGETS[1];
+
+		// we don't directly need the data-provider to be populated, but it is just easy to use it.
+		set_up_data_provider::<T>(v, t);
+		// default bounds are unbounded.
+		let targets = T::DataProvider::electable_targets(DataProviderBounds::default())?;
+		let voters = T::DataProvider::electing_voters(DataProviderBounds::default())?;
+		let desired_targets = T::DataProvider::desired_targets()?;
+		assert!(<MultiPhase<T>>::snapshot().is_none());
+	}: {
+		<MultiPhase::<T>>::create_snapshot_internal(targets, voters, desired_targets)
+	} verify {
+		assert!(<MultiPhase<T>>::snapshot().is_some());
+		assert_eq!(<MultiPhase<T>>::snapshot_metadata().ok_or("metadata missing")?.voters, v);
+		assert_eq!(<MultiPhase<T>>::snapshot_metadata().ok_or("metadata missing")?.targets, t);
+	}
+
+	// a call to `<Pallet as ElectionProvider>::elect` where we only return the queued solution.
+	elect_queued {
+		// number of assignments, i.e. solution.len(). This means the active nominators, thus must be
+		// a subset of `v`.
+		let a in (T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
+		// number of desired targets. Must be a subset of `t`.
+		let d in (T::BenchmarkingConfig::DESIRED_TARGETS[0]) .. T::BenchmarkingConfig::DESIRED_TARGETS[1];
+
+		// number of votes in snapshot. Not dominant.
+		let v  = T::BenchmarkingConfig::VOTERS[1];
+		// number of targets in snapshot. Not dominant.
+		let t = T::BenchmarkingConfig::TARGETS[1];
+
+		let witness = SolutionOrSnapshotSize { voters: v, targets: t };
+		let raw_solution = solution_with_size::<T>(witness, a, d)?;
+		let ready_solution =
+			<MultiPhase<T>>::feasibility_check(raw_solution, ElectionCompute::Signed)
+				.map_err(<&str>::from)?;
+		<CurrentPhase<T>>::put(Phase::Signed);
+		// assume a queued solution is stored, regardless of where it comes from.
+		<QueuedSolution<T>>::put(ready_solution);
+
+		// these are set by the `solution_with_size` function.
+		assert!(<DesiredTargets<T>>::get().is_some());
+		assert!(<Snapshot<T>>::get().is_some());
+		assert!(<SnapshotMetadata<T>>::get().is_some());
+	}: {
+		assert_ok!(<MultiPhase<T> as ElectionProvider>::elect());
+	} verify {
+		assert!(<MultiPhase<T>>::queued_solution().is_none());
+		assert!(<DesiredTargets<T>>::get().is_none());
+		assert!(<Snapshot<T>>::get().is_none());
+		assert!(<SnapshotMetadata<T>>::get().is_none());
+		assert_eq!(<CurrentPhase<T>>::get(), <Phase<frame_system::pallet_prelude::BlockNumberFor::<T>>>::Off);
+	}
+
+	submit {
+		// the queue is full and the solution is only better than the worse.
+		<MultiPhase<T>>::create_snapshot().map_err(<&str>::from)?;
+		<MultiPhase<T>>::phase_transition(Phase::Signed);
+		<Round<T>>::put(1);
+
+		let mut signed_submissions = SignedSubmissions::<T>::get();
+
+		// Insert `max` submissions
+		for i in 0..(T::SignedMaxSubmissions::get() - 1) {
+			let raw_solution = RawSolution {
+				score: ElectionScore { minimal_stake: 10_000_000u128 + (i as u128), ..Default::default() },
+				..Default::default()
+			};
+			let signed_submission = SignedSubmission {
+				raw_solution,
+				who: account("submitters", i, SEED),
+				deposit: Default::default(),
+				call_fee: Default::default(),
+			};
+			signed_submissions.insert(signed_submission);
+		}
+		signed_submissions.put();
+
+		// this score will eject the weakest one.
+		let solution = RawSolution {
+			score: ElectionScore { minimal_stake: 10_000_000u128 + 1, ..Default::default() },
+			..Default::default()
+		};
+
+		let caller = frame_benchmarking::whitelisted_caller();
+		let deposit = MultiPhase::<T>::deposit_for(
+			&solution,
+			MultiPhase::<T>::snapshot_metadata().unwrap_or_default(),
+		);
+		T::Currency::make_free_balance_be(&caller,  T::Currency::minimum_balance() * 1000u32.into() + deposit);
+
+	}: _(RawOrigin::Signed(caller), Box::new(solution))
+	verify {
+		assert!(<MultiPhase<T>>::signed_submissions().len() as u32 == T::SignedMaxSubmissions::get());
+	}
+
+	submit_unsigned {
+		// number of votes in snapshot.
+		let v in (T::BenchmarkingConfig::VOTERS[0]) .. T::BenchmarkingConfig::VOTERS[1];
+		// number of targets in snapshot.
+		let t in (T::BenchmarkingConfig::TARGETS[0]) .. T::BenchmarkingConfig::TARGETS[1];
+		// number of assignments, i.e. solution.len(). This means the active nominators, thus must be
+		// a subset of `v` component.
+		let a in
+			(T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
+		// number of desired targets. Must be a subset of `t` component.
+		let d in
+			(T::BenchmarkingConfig::DESIRED_TARGETS[0]) ..
+			T::BenchmarkingConfig::DESIRED_TARGETS[1];
+
+		let witness = SolutionOrSnapshotSize { voters: v, targets: t };
+		let raw_solution = solution_with_size::<T>(witness, a, d)?;
+
+		assert!(<MultiPhase<T>>::queued_solution().is_none());
+		<CurrentPhase<T>>::put(Phase::Unsigned((true, 1u32.into())));
+	}: _(RawOrigin::None, Box::new(raw_solution), witness)
+	verify {
+		assert!(<MultiPhase<T>>::queued_solution().is_some());
+	}
+
+	// This is checking a valid solution. The worse case is indeed a valid solution.
+	feasibility_check {
+		// number of votes in snapshot.
+		let v in (T::BenchmarkingConfig::VOTERS[0]) .. T::BenchmarkingConfig::VOTERS[1];
+		// number of targets in snapshot.
+		let t in (T::BenchmarkingConfig::TARGETS[0]) .. T::BenchmarkingConfig::TARGETS[1];
+		// number of assignments, i.e. solution.len(). This means the active nominators, thus must be
+		// a subset of `v` component.
+		let a in (T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
+		// number of desired targets. Must be a subset of `t` component.
+		let d in (T::BenchmarkingConfig::DESIRED_TARGETS[0]) .. T::BenchmarkingConfig::DESIRED_TARGETS[1];
+
+		let size = SolutionOrSnapshotSize { voters: v, targets: t };
+		let raw_solution = solution_with_size::<T>(size, a, d)?;
+
+		assert_eq!(raw_solution.solution.voter_count() as u32, a);
+		assert_eq!(raw_solution.solution.unique_targets().len() as u32, d);
+	}: {
+		assert!(<MultiPhase<T>>::feasibility_check(raw_solution, ElectionCompute::Unsigned).is_ok());
+	}
+
+	// NOTE: this weight is not used anywhere, but the fact that it should succeed when execution in
+	// isolation is vital to ensure memory-safety. For the same reason, we don't care about the
+	// components iterating, we merely check that this operation will work with the "maximum"
+	// numbers.
+	//
+	// ONLY run this benchmark in isolation, and pass the `--extra` flag to enable it.
+	//
+	// NOTE: If this benchmark does not run out of memory with a given heap pages, it means that the
+	// OCW process can SURELY succeed with the given configuration, but the opposite is not true.
+	// This benchmark is doing more work than a raw call to `OffchainWorker_offchain_worker` runtime
+	// api call, since it is also setting up some mock data, which will itself exhaust the heap to
+	// some extent.
+	#[extra]
+	mine_solution_offchain_memory {
+		// number of votes in snapshot. Fixed to maximum.
+		let v = T::BenchmarkingConfig::MINER_MAXIMUM_VOTERS;
+		// number of targets in snapshot. Fixed to maximum.
+		let t = T::BenchmarkingConfig::MAXIMUM_TARGETS;
+
+		set_up_data_provider::<T>(v, t);
+		let now = frame_system::Pallet::<T>::block_number();
+		<CurrentPhase<T>>::put(Phase::Unsigned((true, now)));
+		<MultiPhase::<T>>::create_snapshot().unwrap();
+	}: {
+		// we can't really verify this as it won't write anything to state, check logs.
+		<MultiPhase::<T>>::offchain_worker(now)
+	}
+
+	// NOTE: this weight is not used anywhere, but the fact that it should succeed when execution in
+	// isolation is vital to ensure memory-safety. For the same reason, we don't care about the
+	// components iterating, we merely check that this operation will work with the "maximum"
+	// numbers.
+	//
+	// ONLY run this benchmark in isolation, and pass the `--extra` flag to enable it.
+	#[extra]
+	create_snapshot_memory {
+		// number of votes in snapshot. Fixed to maximum.
+		let v = T::BenchmarkingConfig::SNAPSHOT_MAXIMUM_VOTERS;
+		// number of targets in snapshot. Fixed to maximum.
+		let t = T::BenchmarkingConfig::MAXIMUM_TARGETS;
+
+		set_up_data_provider::<T>(v, t);
+		assert!(<MultiPhase<T>>::snapshot().is_none());
+	}: {
+		<MultiPhase::<T>>::create_snapshot().map_err(|_| "could not create snapshot")?;
+	} verify {
+		assert!(<MultiPhase<T>>::snapshot().is_some());
+		assert_eq!(<MultiPhase<T>>::snapshot_metadata().ok_or("snapshot missing")?.voters, v);
+		assert_eq!(<MultiPhase<T>>::snapshot_metadata().ok_or("snapshot missing")?.targets, t);
+	}
+
+	#[extra]
+	trim_assignments_length {
+		// number of votes in snapshot.
+		let v in (T::BenchmarkingConfig::VOTERS[0]) .. T::BenchmarkingConfig::VOTERS[1];
+		// number of targets in snapshot.
+		let t in (T::BenchmarkingConfig::TARGETS[0]) .. T::BenchmarkingConfig::TARGETS[1];
+		// number of assignments, i.e. solution.len(). This means the active nominators, thus must be
+		// a subset of `v` component.
+		let a in
+			(T::BenchmarkingConfig::ACTIVE_VOTERS[0]) .. T::BenchmarkingConfig::ACTIVE_VOTERS[1];
+		// number of desired targets. Must be a subset of `t` component.
+		let d in
+			(T::BenchmarkingConfig::DESIRED_TARGETS[0]) ..
+			T::BenchmarkingConfig::DESIRED_TARGETS[1];
+		// Subtract this percentage from the actual encoded size
+		let f in 0 .. 95;
+		use frame_election_provider_support::IndexAssignment;
+
+		// Compute a random solution, then work backwards to get the lists of voters, targets, and
+		// assignments
+		let witness = SolutionOrSnapshotSize { voters: v, targets: t };
+		let RawSolution { solution, .. } = solution_with_size::<T>(witness, a, d)?;
+		let RoundSnapshot { voters, targets } = MultiPhase::<T>::snapshot().ok_or("snapshot missing")?;
+		let voter_at = helpers::voter_at_fn::<T::MinerConfig>(&voters);
+		let target_at = helpers::target_at_fn::<T::MinerConfig>(&targets);
+		let mut assignments = solution.into_assignment(voter_at, target_at).expect("solution generated by `solution_with_size` must be valid.");
+
+		// make a voter cache and some helper functions for access
+		let cache = helpers::generate_voter_cache::<T::MinerConfig>(&voters);
+		let voter_index = helpers::voter_index_fn::<T::MinerConfig>(&cache);
+		let target_index = helpers::target_index_fn::<T::MinerConfig>(&targets);
+
+		// sort assignments by decreasing voter stake
+		assignments.sort_by_key(|crate::unsigned::Assignment::<T> { who, .. }| {
+			let stake = cache.get(who).map(|idx| {
+				let (_, stake, _) = voters[*idx];
+				stake
+			}).unwrap_or_default();
+			sp_std::cmp::Reverse(stake)
+		});
+
+		let mut index_assignments = assignments
+			.into_iter()
+			.map(|assignment| IndexAssignment::new(&assignment, &voter_index, &target_index))
+			.collect::<Result<Vec<_>, _>>()
+			.unwrap();
+
+		let encoded_size_of = |assignments: &[IndexAssignmentOf<T::MinerConfig>]| {
+			SolutionOf::<T::MinerConfig>::try_from(assignments).map(|solution| solution.encoded_size())
+		};
+
+		let desired_size = Percent::from_percent(100 - f.saturated_into::<u8>())
+			.mul_ceil(encoded_size_of(index_assignments.as_slice()).unwrap());
+		log!(trace, "desired_size = {}", desired_size);
+	}: {
+		crate::Miner::<T::MinerConfig>::trim_assignments_length(
+			desired_size.saturated_into(),
+			&mut index_assignments,
+			&encoded_size_of,
+		).unwrap();
+	} verify {
+		let solution = SolutionOf::<T::MinerConfig>::try_from(index_assignments.as_slice()).unwrap();
+		let encoding = solution.encode();
+		log!(
+			trace,
+			"encoded size prediction = {}",
+			encoded_size_of(index_assignments.as_slice()).unwrap(),
+		);
+		log!(trace, "actual encoded size = {}", encoding.len());
+		assert!(encoding.len() <= desired_size);
+	}
+
+	impl_benchmark_test_suite!(
+		MultiPhase,
+		crate::mock::ExtBuilder::default().build_offchainify(10).0,
+		crate::mock::Runtime,
+	);
+}
diff --git a/substrate/frame/election-provider-multi-phase/src/helpers.rs b/substrate/frame/election-provider-multi-phase/src/helpers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..57d580e93016cf9be6e1dede6ebbeb95c1609826
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/helpers.rs
@@ -0,0 +1,219 @@
+// 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.
+
+//! Some helper functions/macros for this crate.
+
+use crate::{
+	unsigned::{MinerConfig, MinerVoterOf},
+	SolutionTargetIndexOf, SolutionVoterIndexOf, VoteWeight,
+};
+use sp_std::{collections::btree_map::BTreeMap, prelude::*};
+
+#[macro_export]
+macro_rules! log {
+	($level:tt, $pattern:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: $crate::LOG_TARGET,
+			concat!("[#{:?}] 🗳  ", $pattern), <frame_system::Pallet<T>>::block_number() $(, $values)*
+		)
+	};
+}
+
+// This is only useful for a context where a `<T: Config>` is not in scope.
+#[macro_export]
+macro_rules! log_no_system {
+	($level:tt, $pattern:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: $crate::LOG_TARGET,
+			concat!("🗳 ", $pattern) $(, $values)*
+		)
+	};
+}
+
+/// Generate a btree-map cache of the voters and their indices.
+///
+/// This can be used to efficiently build index getter closures.
+pub fn generate_voter_cache<T: MinerConfig>(
+	snapshot: &Vec<MinerVoterOf<T>>,
+) -> BTreeMap<T::AccountId, usize> {
+	let mut cache: BTreeMap<T::AccountId, usize> = BTreeMap::new();
+	snapshot.iter().enumerate().for_each(|(i, (x, _, _))| {
+		let _existed = cache.insert(x.clone(), i);
+		// if a duplicate exists, we only consider the last one. Defensive only, should never
+		// happen.
+		debug_assert!(_existed.is_none());
+	});
+
+	cache
+}
+
+/// Create a function that returns the index of a voter in the snapshot.
+///
+/// The returning index type is the same as the one defined in `T::Solution::Voter`.
+///
+/// ## Warning
+///
+/// Note that this will represent the snapshot data from which the `cache` is generated.
+pub fn voter_index_fn<T: MinerConfig>(
+	cache: &BTreeMap<T::AccountId, usize>,
+) -> impl Fn(&T::AccountId) -> Option<SolutionVoterIndexOf<T>> + '_ {
+	move |who| {
+		cache
+			.get(who)
+			.and_then(|i| <usize as TryInto<SolutionVoterIndexOf<T>>>::try_into(*i).ok())
+	}
+}
+
+/// Create a function that returns the index of a voter in the snapshot.
+///
+/// Same as [`voter_index_fn`] but the returned function owns all its necessary data; nothing is
+/// borrowed.
+pub fn voter_index_fn_owned<T: MinerConfig>(
+	cache: BTreeMap<T::AccountId, usize>,
+) -> impl Fn(&T::AccountId) -> Option<SolutionVoterIndexOf<T>> {
+	move |who| {
+		cache
+			.get(who)
+			.and_then(|i| <usize as TryInto<SolutionVoterIndexOf<T>>>::try_into(*i).ok())
+	}
+}
+
+/// Same as [`voter_index_fn`], but the returning index is converted into usize, if possible.
+///
+/// ## Warning
+///
+/// Note that this will represent the snapshot data from which the `cache` is generated.
+pub fn voter_index_fn_usize<T: MinerConfig>(
+	cache: &BTreeMap<T::AccountId, usize>,
+) -> impl Fn(&T::AccountId) -> Option<usize> + '_ {
+	move |who| cache.get(who).cloned()
+}
+
+/// A non-optimized, linear version of [`voter_index_fn`] that does not need a cache and does a
+/// linear search.
+///
+/// ## Warning
+///
+/// Not meant to be used in production.
+#[cfg(test)]
+pub fn voter_index_fn_linear<T: MinerConfig>(
+	snapshot: &Vec<MinerVoterOf<T>>,
+) -> impl Fn(&T::AccountId) -> Option<SolutionVoterIndexOf<T>> + '_ {
+	move |who| {
+		snapshot
+			.iter()
+			.position(|(x, _, _)| x == who)
+			.and_then(|i| <usize as TryInto<SolutionVoterIndexOf<T>>>::try_into(i).ok())
+	}
+}
+
+/// Create a function that returns the index of a target in the snapshot.
+///
+/// The returned index type is the same as the one defined in `T::Solution::Target`.
+///
+/// Note: to the extent possible, the returned function should be cached and reused. Producing that
+/// function requires a `O(n log n)` data transform. Each invocation of that function completes
+/// in `O(log n)`.
+pub fn target_index_fn<T: MinerConfig>(
+	snapshot: &Vec<T::AccountId>,
+) -> impl Fn(&T::AccountId) -> Option<SolutionTargetIndexOf<T>> + '_ {
+	let cache: BTreeMap<_, _> =
+		snapshot.iter().enumerate().map(|(idx, account_id)| (account_id, idx)).collect();
+	move |who| {
+		cache
+			.get(who)
+			.and_then(|i| <usize as TryInto<SolutionTargetIndexOf<T>>>::try_into(*i).ok())
+	}
+}
+
+/// Create a function the returns the index to a target in the snapshot.
+///
+/// The returned index type is the same as the one defined in `T::Solution::Target`.
+///
+/// ## Warning
+///
+/// Not meant to be used in production.
+#[cfg(test)]
+pub fn target_index_fn_linear<T: MinerConfig>(
+	snapshot: &Vec<T::AccountId>,
+) -> impl Fn(&T::AccountId) -> Option<SolutionTargetIndexOf<T>> + '_ {
+	move |who| {
+		snapshot
+			.iter()
+			.position(|x| x == who)
+			.and_then(|i| <usize as TryInto<SolutionTargetIndexOf<T>>>::try_into(i).ok())
+	}
+}
+
+/// Create a function that can map a voter index ([`SolutionVoterIndexOf`]) to the actual voter
+/// account using a linearly indexible snapshot.
+pub fn voter_at_fn<T: MinerConfig>(
+	snapshot: &Vec<MinerVoterOf<T>>,
+) -> impl Fn(SolutionVoterIndexOf<T>) -> Option<T::AccountId> + '_ {
+	move |i| {
+		<SolutionVoterIndexOf<T> as TryInto<usize>>::try_into(i)
+			.ok()
+			.and_then(|i| snapshot.get(i).map(|(x, _, _)| x).cloned())
+	}
+}
+
+/// Create a function that can map a target index ([`SolutionTargetIndexOf`]) to the actual target
+/// account using a linearly indexible snapshot.
+pub fn target_at_fn<T: MinerConfig>(
+	snapshot: &Vec<T::AccountId>,
+) -> impl Fn(SolutionTargetIndexOf<T>) -> Option<T::AccountId> + '_ {
+	move |i| {
+		<SolutionTargetIndexOf<T> as TryInto<usize>>::try_into(i)
+			.ok()
+			.and_then(|i| snapshot.get(i).cloned())
+	}
+}
+
+/// Create a function to get the stake of a voter.
+///
+/// This is not optimized and uses a linear search.
+#[cfg(test)]
+pub fn stake_of_fn_linear<T: MinerConfig>(
+	snapshot: &Vec<MinerVoterOf<T>>,
+) -> impl Fn(&T::AccountId) -> VoteWeight + '_ {
+	move |who| {
+		snapshot
+			.iter()
+			.find(|(x, _, _)| x == who)
+			.map(|(_, x, _)| *x)
+			.unwrap_or_default()
+	}
+}
+
+/// Create a function to get the stake of a voter.
+///
+/// ## Warning
+///
+/// The cache need must be derived from the same snapshot. Zero is returned if a voter is
+/// non-existent.
+pub fn stake_of_fn<'a, T: MinerConfig>(
+	snapshot: &'a Vec<MinerVoterOf<T>>,
+	cache: &'a BTreeMap<T::AccountId, usize>,
+) -> impl Fn(&T::AccountId) -> VoteWeight + 'a {
+	move |who| {
+		if let Some(index) = cache.get(who) {
+			snapshot.get(*index).map(|(_, x, _)| x).cloned().unwrap_or_default()
+		} else {
+			0
+		}
+	}
+}
diff --git a/substrate/frame/election-provider-multi-phase/src/lib.rs b/substrate/frame/election-provider-multi-phase/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f26a6f40d42677584d548fd2e396c5b2cac230d6
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/lib.rs
@@ -0,0 +1,2696 @@
+// 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.
+
+//! # Multi phase, offchain election provider pallet.
+//!
+//! Currently, this election-provider has two distinct phases (see [`Phase`]), **signed** and
+//! **unsigned**.
+//!
+//! ## Phases
+//!
+//! The timeline of pallet is as follows. At each block,
+//! [`frame_election_provider_support::ElectionDataProvider::next_election_prediction`] is used to
+//! estimate the time remaining to the next call to
+//! [`frame_election_provider_support::ElectionProvider::elect`]. Based on this, a phase is chosen.
+//! The timeline is as follows.
+//!
+//! ```ignore
+//!                                                                    elect()
+//!                 +   <--T::SignedPhase-->  +  <--T::UnsignedPhase-->   +
+//!   +-------------------------------------------------------------------+
+//!    Phase::Off   +       Phase::Signed     +      Phase::Unsigned      +
+//! ```
+//!
+//! Note that the unsigned phase starts [`pallet::Config::UnsignedPhase`] blocks before the
+//! `next_election_prediction`, but only ends when a call to [`ElectionProvider::elect`] happens. If
+//! no `elect` happens, the signed phase is extended.
+//!
+//! > Given this, it is rather important for the user of this pallet to ensure it always terminates
+//! election via `elect` before requesting a new one.
+//!
+//! Each of the phases can be disabled by essentially setting their length to zero. If both phases
+//! have length zero, then the pallet essentially runs only the fallback strategy, denoted by
+//! [`Config::Fallback`].
+//!
+//! ### Signed Phase
+//!
+//! In the signed phase, solutions (of type [`RawSolution`]) are submitted and queued on chain. A
+//! deposit is reserved, based on the size of the solution, for the cost of keeping this solution
+//! on-chain for a number of blocks, and the potential weight of the solution upon being checked. A
+//! maximum of `pallet::Config::SignedMaxSubmissions` solutions are stored. The queue is always
+//! sorted based on score (worse to best).
+//!
+//! Upon arrival of a new solution:
+//!
+//! 1. If the queue is not full, it is stored in the appropriate sorted index.
+//! 2. If the queue is full but the submitted solution is better than one of the queued ones, the
+//!    worse solution is discarded, the bond of the outgoing solution is returned, and the new
+//!    solution is stored in the correct index.
+//! 3. If the queue is full and the solution is not an improvement compared to any of the queued
+//!    ones, it is instantly rejected and no additional bond is reserved.
+//!
+//! A signed solution cannot be reversed, taken back, updated, or retracted. In other words, the
+//! origin can not bail out in any way, if their solution is queued.
+//!
+//! Upon the end of the signed phase, the solutions are examined from best to worse (i.e. `pop()`ed
+//! until drained). Each solution undergoes an expensive `Pallet::feasibility_check`, which ensures
+//! the score claimed by this score was correct, and it is valid based on the election data (i.e.
+//! votes and targets). At each step, if the current best solution passes the feasibility check,
+//! it is considered to be the best one. The sender of the origin is rewarded, and the rest of the
+//! queued solutions get their deposit back and are discarded, without being checked.
+//!
+//! The following example covers all of the cases at the end of the signed phase:
+//!
+//! ```ignore
+//! Queue
+//! +-------------------------------+
+//! |Solution(score=20, valid=false)| +-->  Slashed
+//! +-------------------------------+
+//! |Solution(score=15, valid=true )| +-->  Rewarded, Saved
+//! +-------------------------------+
+//! |Solution(score=10, valid=true )| +-->  Discarded
+//! +-------------------------------+
+//! |Solution(score=05, valid=false)| +-->  Discarded
+//! +-------------------------------+
+//! |             None              |
+//! +-------------------------------+
+//! ```
+//!
+//! Note that both of the bottom solutions end up being discarded and get their deposit back,
+//! despite one of them being *invalid*.
+//!
+//! ## Unsigned Phase
+//!
+//! The unsigned phase will always follow the signed phase, with the specified duration. In this
+//! phase, only validator nodes can submit solutions. A validator node who has offchain workers
+//! enabled will start to mine a solution in this phase and submits it back to the chain as an
+//! unsigned transaction, thus the name _unsigned_ phase. This unsigned transaction can never be
+//! valid if propagated, and it acts similar to an inherent.
+//!
+//! Validators will only submit solutions if the one that they have computed is sufficiently better
+//! than the best queued one (see [`pallet::Config::BetterUnsignedThreshold`]) and will limit the
+//! weight of the solution to [`MinerConfig::MaxWeight`].
+//!
+//! The unsigned phase can be made passive depending on how the previous signed phase went, by
+//! setting the first inner value of [`Phase`] to `false`. For now, the signed phase is always
+//! active.
+//!
+//! ### Fallback
+//!
+//! If we reach the end of both phases (i.e. call to [`ElectionProvider::elect`] happens) and no
+//! good solution is queued, then the fallback strategy [`pallet::Config::Fallback`] is used to
+//! determine what needs to be done. The on-chain election is slow, and contains no balancing or
+//! reduction post-processing. If [`pallet::Config::Fallback`] fails, the next phase
+//! [`Phase::Emergency`] is enabled, which is a more *fail-safe* approach.
+//!
+//! ### Emergency Phase
+//!
+//! If, for any of the below reasons:
+//!
+//! 1. No **signed** or **unsigned** solution submitted, and no successful [`Config::Fallback`] is
+//!    provided
+//! 2. Any other unforeseen internal error
+//!
+//! A call to `T::ElectionProvider::elect` is made, and `Ok(_)` cannot be returned, then the pallet
+//! proceeds to the [`Phase::Emergency`]. During this phase, any solution can be submitted from
+//! [`Config::ForceOrigin`], without any checking, via [`Pallet::set_emergency_election_result`]
+//! transaction. Hence, `[`Config::ForceOrigin`]` should only be set to a trusted origin, such as
+//! the council or root. Once submitted, the forced solution is kept in [`QueuedSolution`] until the
+//! next call to `T::ElectionProvider::elect`, where it is returned and [`Phase`] goes back to
+//! `Off`.
+//!
+//! This implies that the user of this pallet (i.e. a staking pallet) should re-try calling
+//! `T::ElectionProvider::elect` in case of error, until `OK(_)` is returned.
+//!
+//! To generate an emergency solution, one must only provide one argument: [`Supports`]. This is
+//! essentially a collection of elected winners for the election, and voters who support them. The
+//! supports can be generated by any means. In the simplest case, it could be manual. For example,
+//! in the case of massive network failure or misbehavior, [`Config::ForceOrigin`] might decide to
+//! select only a small number of emergency winners (which would greatly restrict the next validator
+//! set, if this pallet is used with `pallet-staking`). If the failure is for other technical
+//! reasons, then a simple and safe way to generate supports is using the staking-miner binary
+//! provided in the Polkadot repository. This binary has a subcommand named `emergency-solution`
+//! which is capable of connecting to a live network, and generating appropriate `supports` using a
+//! standard algorithm, and outputting the `supports` in hex format, ready for submission. Note that
+//! while this binary lives in the Polkadot repository, this particular subcommand of it can work
+//! against any substrate-based chain.
+//!
+//! See the `staking-miner` documentation in the Polkadot repository for more information.
+//!
+//! ## Feasible Solution (correct solution)
+//!
+//! All submissions must undergo a feasibility check. Signed solutions are checked one by one at the
+//! end of the signed phase, and the unsigned solutions are checked on the spot. A feasible solution
+//! is as follows:
+//!
+//! 0. **all** of the used indices must be correct.
+//! 1. present *exactly* correct number of winners.
+//! 2. any assignment is checked to match with [`RoundSnapshot::voters`].
+//! 3. the claimed score is valid, based on the fixed point arithmetic accuracy.
+//!
+//! ## Accuracy
+//!
+//! The accuracy of the election is configured via [`SolutionAccuracyOf`] which is the accuracy that
+//! the submitted solutions must adhere to.
+//!
+//! Note that the accuracy is of great importance. The offchain solution should be as small as
+//! possible, reducing solutions size/weight.
+//!
+//! ## Error types
+//!
+//! This pallet provides a verbose error system to ease future debugging and debugging. The overall
+//! hierarchy of errors is as follows:
+//!
+//! 1. [`pallet::Error`]: These are the errors that can be returned in the dispatchables of the
+//!    pallet, either signed or unsigned. Since decomposition with nested enums is not possible
+//!    here, they are prefixed with the logical sub-system to which they belong.
+//! 2. [`ElectionError`]: These are the errors that can be generated while the pallet is doing
+//!    something in automatic scenarios, such as `offchain_worker` or `on_initialize`. These errors
+//!    are helpful for logging and are thus nested as:
+//!    - [`ElectionError::Miner`]: wraps a [`unsigned::MinerError`].
+//!    - [`ElectionError::Feasibility`]: wraps a [`FeasibilityError`].
+//!    - [`ElectionError::Fallback`]: wraps a fallback error.
+//!    - [`ElectionError::DataProvider`]: wraps a static str.
+//!
+//! Note that there could be an overlap between these sub-errors. For example, A
+//! `SnapshotUnavailable` can happen in both miner and feasibility check phase.
+//!
+//! ## Future Plans
+//!
+//! **Emergency-phase recovery script**: This script should be taken out of staking-miner in
+//! polkadot and ideally live in `substrate/utils/frame/elections`.
+//!
+//! **Challenge Phase**. We plan on adding a third phase to the pallet, called the challenge phase.
+//! This is a phase in which no further solutions are processed, and the current best solution might
+//! be challenged by anyone (signed or unsigned). The main plan here is to enforce the solution to
+//! be PJR. Checking PJR on-chain is quite expensive, yet proving that a solution is **not** PJR is
+//! rather cheap. If a queued solution is successfully proven bad:
+//!
+//! 1. We must surely slash whoever submitted that solution (might be a challenge for unsigned
+//!    solutions).
+//! 2. We will fallback to the emergency strategy (likely extending the current era).
+//!
+//! **Bailing out**. The functionality of bailing out of a queued solution is nice. A miner can
+//! submit a solution as soon as they _think_ it is high probability feasible, and do the checks
+//! afterwards, and remove their solution (for a small cost of probably just transaction fees, or a
+//! portion of the bond).
+//!
+//! **Conditionally open unsigned phase**: Currently, the unsigned phase is always opened. This is
+//! useful because an honest validator will run substrate OCW code, which should be good enough to
+//! trump a mediocre or malicious signed submission (assuming in the absence of honest signed bots).
+//! If there are signed submissions, they can be checked against an absolute measure (e.g. PJR),
+//! then we can only open the unsigned phase in extreme conditions (i.e. "no good signed solution
+//! received") to spare some work for the active validators.
+//!
+//! **Allow smaller solutions and build up**: For now we only allow solutions that are exactly
+//! [`DesiredTargets`], no more, no less. Over time, we can change this to a [min, max] where any
+//! solution within this range is acceptable, where bigger solutions are prioritized.
+//!
+//! **Score based on (byte) size**: We should always prioritize small solutions over bigger ones, if
+//! there is a tie. Even more harsh should be to enforce the bound of the `reduce` algorithm.
+//!
+//! **Take into account the encode/decode weight in benchmarks.** Currently, we only take into
+//! account the weight of encode/decode in the `submit_unsigned` given its priority. Nonetheless,
+//! all operations on the solution and the snapshot are worthy of taking this into account.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+use frame_election_provider_support::{
+	bounds::{CountBound, ElectionBounds, ElectionBoundsBuilder, SizeBound},
+	BoundedSupportsOf, DataProviderBounds, ElectionDataProvider, ElectionProvider,
+	ElectionProviderBase, InstantElectionProvider, NposSolution,
+};
+use frame_support::{
+	dispatch::DispatchClass,
+	ensure,
+	traits::{Currency, DefensiveResult, Get, OnUnbalanced, ReservableCurrency},
+	weights::Weight,
+	DefaultNoBound, EqNoBound, PartialEqNoBound,
+};
+use frame_system::{ensure_none, offchain::SendTransactionTypes, pallet_prelude::BlockNumberFor};
+use scale_info::TypeInfo;
+use sp_arithmetic::{
+	traits::{CheckedAdd, Zero},
+	UpperOf,
+};
+use sp_npos_elections::{BoundedSupports, ElectionScore, IdentifierT, Supports, VoteWeight};
+use sp_runtime::{
+	transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
+		TransactionValidityError, ValidTransaction,
+	},
+	DispatchError, ModuleError, PerThing, Perbill, RuntimeDebug, SaturatedConversion,
+};
+use sp_std::prelude::*;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[macro_use]
+pub mod helpers;
+
+const LOG_TARGET: &str = "runtime::election-provider";
+
+pub mod migrations;
+pub mod signed;
+pub mod unsigned;
+pub mod weights;
+use unsigned::VoterOf;
+pub use weights::WeightInfo;
+
+pub use signed::{
+	BalanceOf, NegativeImbalanceOf, PositiveImbalanceOf, SignedSubmission, SignedSubmissionOf,
+	SignedSubmissions, SubmissionIndicesOf,
+};
+pub use unsigned::{Miner, MinerConfig};
+
+/// The solution type used by this crate.
+pub type SolutionOf<T> = <T as MinerConfig>::Solution;
+
+/// The voter index. Derived from [`SolutionOf`].
+pub type SolutionVoterIndexOf<T> = <SolutionOf<T> as NposSolution>::VoterIndex;
+/// The target index. Derived from [`SolutionOf`].
+pub type SolutionTargetIndexOf<T> = <SolutionOf<T> as NposSolution>::TargetIndex;
+/// The accuracy of the election, when submitted from offchain. Derived from [`SolutionOf`].
+pub type SolutionAccuracyOf<T> =
+	<SolutionOf<<T as crate::Config>::MinerConfig> as NposSolution>::Accuracy;
+/// The fallback election type.
+pub type FallbackErrorOf<T> = <<T as crate::Config>::Fallback as ElectionProviderBase>::Error;
+
+/// Configuration for the benchmarks of the pallet.
+pub trait BenchmarkingConfig {
+	/// Range of voters.
+	const VOTERS: [u32; 2];
+	/// Range of targets.
+	const TARGETS: [u32; 2];
+	/// Range of active voters.
+	const ACTIVE_VOTERS: [u32; 2];
+	/// Range of desired targets.
+	const DESIRED_TARGETS: [u32; 2];
+	/// Maximum number of voters expected. This is used only for memory-benchmarking of snapshot.
+	const SNAPSHOT_MAXIMUM_VOTERS: u32;
+	/// Maximum number of voters expected. This is used only for memory-benchmarking of miner.
+	const MINER_MAXIMUM_VOTERS: u32;
+	/// Maximum number of targets expected. This is used only for memory-benchmarking.
+	const MAXIMUM_TARGETS: u32;
+}
+
+/// Current phase of the pallet.
+#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo)]
+pub enum Phase<Bn> {
+	/// Nothing, the election is not happening.
+	Off,
+	/// Signed phase is open.
+	Signed,
+	/// Unsigned phase. First element is whether it is active or not, second the starting block
+	/// number.
+	///
+	/// We do not yet check whether the unsigned phase is active or passive. The intent is for the
+	/// blockchain to be able to declare: "I believe that there exists an adequate signed
+	/// solution," advising validators not to bother running the unsigned offchain worker.
+	///
+	/// As validator nodes are free to edit their OCW code, they could simply ignore this advisory
+	/// and always compute their own solution. However, by default, when the unsigned phase is
+	/// passive, the offchain workers will not bother running.
+	Unsigned((bool, Bn)),
+	/// The emergency phase. This is enabled upon a failing call to `T::ElectionProvider::elect`.
+	/// After that, the only way to leave this phase is through a successful
+	/// `T::ElectionProvider::elect`.
+	Emergency,
+}
+
+impl<Bn> Default for Phase<Bn> {
+	fn default() -> Self {
+		Phase::Off
+	}
+}
+
+impl<Bn: PartialEq + Eq> Phase<Bn> {
+	/// Whether the phase is emergency or not.
+	pub fn is_emergency(&self) -> bool {
+		matches!(self, Phase::Emergency)
+	}
+
+	/// Whether the phase is signed or not.
+	pub fn is_signed(&self) -> bool {
+		matches!(self, Phase::Signed)
+	}
+
+	/// Whether the phase is unsigned or not.
+	pub fn is_unsigned(&self) -> bool {
+		matches!(self, Phase::Unsigned(_))
+	}
+
+	/// Whether the phase is unsigned and open or not, with specific start.
+	pub fn is_unsigned_open_at(&self, at: Bn) -> bool {
+		matches!(self, Phase::Unsigned((true, real)) if *real == at)
+	}
+
+	/// Whether the phase is unsigned and open or not.
+	pub fn is_unsigned_open(&self) -> bool {
+		matches!(self, Phase::Unsigned((true, _)))
+	}
+
+	/// Whether the phase is off or not.
+	pub fn is_off(&self) -> bool {
+		matches!(self, Phase::Off)
+	}
+}
+
+/// The type of `Computation` that provided this election data.
+#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo)]
+pub enum ElectionCompute {
+	/// Election was computed on-chain.
+	OnChain,
+	/// Election was computed with a signed submission.
+	Signed,
+	/// Election was computed with an unsigned submission.
+	Unsigned,
+	/// Election was computed using the fallback
+	Fallback,
+	/// Election was computed with emergency status.
+	Emergency,
+}
+
+impl Default for ElectionCompute {
+	fn default() -> Self {
+		ElectionCompute::OnChain
+	}
+}
+
+/// A raw, unchecked solution.
+///
+/// This is what will get submitted to the chain.
+///
+/// Such a solution should never become effective in anyway before being checked by the
+/// `Pallet::feasibility_check`.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, PartialOrd, Ord, TypeInfo)]
+pub struct RawSolution<S> {
+	/// the solution itself.
+	pub solution: S,
+	/// The _claimed_ score of the solution.
+	pub score: ElectionScore,
+	/// The round at which this solution should be submitted.
+	pub round: u32,
+}
+
+impl<C: Default> Default for RawSolution<C> {
+	fn default() -> Self {
+		// Round 0 is always invalid, only set this to 1.
+		Self { round: 1, solution: Default::default(), score: Default::default() }
+	}
+}
+
+/// A checked solution, ready to be enacted.
+#[derive(
+	PartialEqNoBound,
+	EqNoBound,
+	Clone,
+	Encode,
+	Decode,
+	RuntimeDebug,
+	DefaultNoBound,
+	scale_info::TypeInfo,
+)]
+#[scale_info(skip_type_params(AccountId, MaxWinners))]
+pub struct ReadySolution<AccountId, MaxWinners>
+where
+	AccountId: IdentifierT,
+	MaxWinners: Get<u32>,
+{
+	/// The final supports of the solution.
+	///
+	/// This is target-major vector, storing each winners, total backing, and each individual
+	/// backer.
+	pub supports: BoundedSupports<AccountId, MaxWinners>,
+	/// The score of the solution.
+	///
+	/// This is needed to potentially challenge the solution.
+	pub score: ElectionScore,
+	/// How this election was computed.
+	pub compute: ElectionCompute,
+}
+
+/// A snapshot of all the data that is needed for en entire round. They are provided by
+/// [`ElectionDataProvider`] and are kept around until the round is finished.
+///
+/// These are stored together because they are often accessed together.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, Default, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct RoundSnapshot<AccountId, DataProvider> {
+	/// All of the voters.
+	pub voters: Vec<DataProvider>,
+	/// All of the targets.
+	pub targets: Vec<AccountId>,
+}
+
+/// Encodes the length of a solution or a snapshot.
+///
+/// This is stored automatically on-chain, and it contains the **size of the entire snapshot**.
+/// This is also used in dispatchables as weight witness data and should **only contain the size of
+/// the presented solution**, not the entire snapshot.
+#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, Debug, Default, TypeInfo)]
+pub struct SolutionOrSnapshotSize {
+	/// The length of voters.
+	#[codec(compact)]
+	pub voters: u32,
+	/// The length of targets.
+	#[codec(compact)]
+	pub targets: u32,
+}
+
+/// Internal errors of the pallet.
+///
+/// Note that this is different from [`pallet::Error`].
+#[derive(frame_support::DebugNoBound)]
+#[cfg_attr(feature = "runtime-benchmarks", derive(strum::IntoStaticStr))]
+pub enum ElectionError<T: Config> {
+	/// An error happened in the feasibility check sub-system.
+	Feasibility(FeasibilityError),
+	/// An error in the miner (offchain) sub-system.
+	Miner(unsigned::MinerError),
+	/// An error happened in the data provider.
+	DataProvider(&'static str),
+	/// An error nested in the fallback.
+	Fallback(FallbackErrorOf<T>),
+	/// No solution has been queued.
+	NothingQueued,
+}
+
+// NOTE: we have to do this manually because of the additional where clause needed on
+// `FallbackErrorOf<T>`.
+#[cfg(test)]
+impl<T: Config> PartialEq for ElectionError<T>
+where
+	FallbackErrorOf<T>: PartialEq,
+{
+	fn eq(&self, other: &Self) -> bool {
+		use ElectionError::*;
+		match (self, other) {
+			(Feasibility(x), Feasibility(y)) if x == y => true,
+			(Miner(x), Miner(y)) if x == y => true,
+			(DataProvider(x), DataProvider(y)) if x == y => true,
+			(Fallback(x), Fallback(y)) if x == y => true,
+			_ => false,
+		}
+	}
+}
+
+impl<T: Config> From<FeasibilityError> for ElectionError<T> {
+	fn from(e: FeasibilityError) -> Self {
+		ElectionError::Feasibility(e)
+	}
+}
+
+impl<T: Config> From<unsigned::MinerError> for ElectionError<T> {
+	fn from(e: unsigned::MinerError) -> Self {
+		ElectionError::Miner(e)
+	}
+}
+
+/// Errors that can happen in the feasibility check.
+#[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "runtime-benchmarks", derive(strum::IntoStaticStr))]
+pub enum FeasibilityError {
+	/// Wrong number of winners presented.
+	WrongWinnerCount,
+	/// The snapshot is not available.
+	///
+	/// Kinda defensive: The pallet should technically never attempt to do a feasibility check when
+	/// no snapshot is present.
+	SnapshotUnavailable,
+	/// Internal error from the election crate.
+	NposElection(sp_npos_elections::Error),
+	/// A vote is invalid.
+	InvalidVote,
+	/// A voter is invalid.
+	InvalidVoter,
+	/// The given score was invalid.
+	InvalidScore,
+	/// The provided round is incorrect.
+	InvalidRound,
+	/// Comparison against `MinimumUntrustedScore` failed.
+	UntrustedScoreTooLow,
+	/// Data Provider returned too many desired targets
+	TooManyDesiredTargets,
+	/// Conversion into bounded types failed.
+	///
+	/// Should never happen under correct configurations.
+	BoundedConversionFailed,
+}
+
+impl From<sp_npos_elections::Error> for FeasibilityError {
+	fn from(e: sp_npos_elections::Error) -> Self {
+		FeasibilityError::NposElection(e)
+	}
+}
+
+pub use pallet::*;
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_election_provider_support::{InstantElectionProvider, NposSolver};
+	use frame_support::{pallet_prelude::*, traits::EstimateCallFee};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config + SendTransactionTypes<Call<Self>> {
+		type RuntimeEvent: From<Event<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>
+			+ TryInto<Event<Self>>;
+
+		/// Currency type.
+		type Currency: ReservableCurrency<Self::AccountId> + Currency<Self::AccountId>;
+
+		/// Something that can predict the fee of a call. Used to sensibly distribute rewards.
+		type EstimateCallFee: EstimateCallFee<Call<Self>, BalanceOf<Self>>;
+
+		/// Duration of the unsigned phase.
+		#[pallet::constant]
+		type UnsignedPhase: Get<BlockNumberFor<Self>>;
+		/// Duration of the signed phase.
+		#[pallet::constant]
+		type SignedPhase: Get<BlockNumberFor<Self>>;
+
+		/// The minimum amount of improvement to the solution score that defines a solution as
+		/// "better" in the Signed phase.
+		#[pallet::constant]
+		type BetterSignedThreshold: Get<Perbill>;
+
+		/// The minimum amount of improvement to the solution score that defines a solution as
+		/// "better" in the Unsigned phase.
+		#[pallet::constant]
+		type BetterUnsignedThreshold: Get<Perbill>;
+
+		/// The repeat threshold of the offchain worker.
+		///
+		/// For example, if it is 5, that means that at least 5 blocks will elapse between attempts
+		/// to submit the worker's solution.
+		#[pallet::constant]
+		type OffchainRepeat: Get<BlockNumberFor<Self>>;
+
+		/// The priority of the unsigned transaction submitted in the unsigned-phase
+		#[pallet::constant]
+		type MinerTxPriority: Get<TransactionPriority>;
+
+		/// Configurations of the embedded miner.
+		///
+		/// Any external software implementing this can use the [`unsigned::Miner`] type provided,
+		/// which can mine new solutions and trim them accordingly.
+		type MinerConfig: crate::unsigned::MinerConfig<
+			AccountId = Self::AccountId,
+			MaxVotesPerVoter = <Self::DataProvider as ElectionDataProvider>::MaxVotesPerVoter,
+			MaxWinners = Self::MaxWinners,
+		>;
+
+		/// Maximum number of signed submissions that can be queued.
+		///
+		/// It is best to avoid adjusting this during an election, as it impacts downstream data
+		/// structures. In particular, `SignedSubmissionIndices<T>` is bounded on this value. If you
+		/// update this value during an election, you _must_ ensure that
+		/// `SignedSubmissionIndices.len()` is less than or equal to the new value. Otherwise,
+		/// attempts to submit new solutions may cause a runtime panic.
+		#[pallet::constant]
+		type SignedMaxSubmissions: Get<u32>;
+
+		/// Maximum weight of a signed solution.
+		///
+		/// If [`Config::MinerConfig`] is being implemented to submit signed solutions (outside of
+		/// this pallet), then [`MinerConfig::solution_weight`] is used to compare against
+		/// this value.
+		#[pallet::constant]
+		type SignedMaxWeight: Get<Weight>;
+
+		/// The maximum amount of unchecked solutions to refund the call fee for.
+		#[pallet::constant]
+		type SignedMaxRefunds: Get<u32>;
+
+		/// Base reward for a signed solution
+		#[pallet::constant]
+		type SignedRewardBase: Get<BalanceOf<Self>>;
+
+		/// Base deposit for a signed solution.
+		#[pallet::constant]
+		type SignedDepositBase: Get<BalanceOf<Self>>;
+
+		/// Per-byte deposit for a signed solution.
+		#[pallet::constant]
+		type SignedDepositByte: Get<BalanceOf<Self>>;
+
+		/// Per-weight deposit for a signed solution.
+		#[pallet::constant]
+		type SignedDepositWeight: Get<BalanceOf<Self>>;
+
+		/// The maximum number of winners that can be elected by this `ElectionProvider`
+		/// implementation.
+		///
+		/// Note: This must always be greater or equal to `T::DataProvider::desired_targets()`.
+		#[pallet::constant]
+		type MaxWinners: Get<u32>;
+
+		/// The maximum number of electing voters and electable targets to put in the snapshot.
+		/// At the moment, snapshots are only over a single block, but once multi-block elections
+		/// are introduced they will take place over multiple blocks.
+		type ElectionBounds: Get<ElectionBounds>;
+
+		/// Handler for the slashed deposits.
+		type SlashHandler: OnUnbalanced<NegativeImbalanceOf<Self>>;
+
+		/// Handler for the rewards.
+		type RewardHandler: OnUnbalanced<PositiveImbalanceOf<Self>>;
+
+		/// Something that will provide the election data.
+		type DataProvider: ElectionDataProvider<
+			AccountId = Self::AccountId,
+			BlockNumber = BlockNumberFor<Self>,
+		>;
+
+		/// Configuration for the fallback.
+		type Fallback: InstantElectionProvider<
+			AccountId = Self::AccountId,
+			BlockNumber = BlockNumberFor<Self>,
+			DataProvider = Self::DataProvider,
+			MaxWinners = Self::MaxWinners,
+		>;
+
+		/// Configuration of the governance-only fallback.
+		///
+		/// As a side-note, it is recommend for test-nets to use `type ElectionProvider =
+		/// BoundedExecution<_>` if the test-net is not expected to have thousands of nominators.
+		type GovernanceFallback: InstantElectionProvider<
+			AccountId = Self::AccountId,
+			BlockNumber = BlockNumberFor<Self>,
+			DataProvider = Self::DataProvider,
+			MaxWinners = Self::MaxWinners,
+		>;
+
+		/// OCW election solution miner algorithm implementation.
+		type Solver: NposSolver<AccountId = Self::AccountId>;
+
+		/// Origin that can control this pallet. Note that any action taken by this origin (such)
+		/// as providing an emergency solution is not checked. Thus, it must be a trusted origin.
+		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The configuration of benchmarking.
+		type BenchmarkingConfig: BenchmarkingConfig;
+
+		/// The weight of the pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	// Expose miner configs over the metadata such that they can be re-implemented.
+	#[pallet::extra_constants]
+	impl<T: Config> Pallet<T> {
+		#[pallet::constant_name(MinerMaxLength)]
+		fn max_length() -> u32 {
+			<T::MinerConfig as MinerConfig>::MaxLength::get()
+		}
+
+		#[pallet::constant_name(MinerMaxWeight)]
+		fn max_weight() -> Weight {
+			<T::MinerConfig as MinerConfig>::MaxWeight::get()
+		}
+
+		#[pallet::constant_name(MinerMaxVotesPerVoter)]
+		fn max_votes_per_voter() -> u32 {
+			<T::MinerConfig as MinerConfig>::MaxVotesPerVoter::get()
+		}
+
+		#[pallet::constant_name(MinerMaxWinners)]
+		fn max_winners() -> u32 {
+			<T::MinerConfig as MinerConfig>::MaxWinners::get()
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(now: BlockNumberFor<T>) -> Weight {
+			let next_election = T::DataProvider::next_election_prediction(now).max(now);
+
+			let signed_deadline = T::SignedPhase::get() + T::UnsignedPhase::get();
+			let unsigned_deadline = T::UnsignedPhase::get();
+
+			let remaining = next_election - now;
+			let current_phase = Self::current_phase();
+
+			log!(
+				trace,
+				"current phase {:?}, next election {:?}, metadata: {:?}",
+				current_phase,
+				next_election,
+				Self::snapshot_metadata()
+			);
+			match current_phase {
+				Phase::Off if remaining <= signed_deadline && remaining > unsigned_deadline => {
+					// NOTE: if signed-phase length is zero, second part of the if-condition fails.
+					match Self::create_snapshot() {
+						Ok(_) => {
+							Self::phase_transition(Phase::Signed);
+							T::WeightInfo::on_initialize_open_signed()
+						},
+						Err(why) => {
+							// Not much we can do about this at this point.
+							log!(warn, "failed to open signed phase due to {:?}", why);
+							T::WeightInfo::on_initialize_nothing()
+						},
+					}
+				},
+				Phase::Signed | Phase::Off
+					if remaining <= unsigned_deadline && remaining > Zero::zero() =>
+				{
+					// our needs vary according to whether or not the unsigned phase follows a
+					// signed phase
+					let (need_snapshot, enabled) = if current_phase == Phase::Signed {
+						// there was previously a signed phase: close the signed phase, no need for
+						// snapshot.
+						//
+						// Notes:
+						//
+						//   - `Self::finalize_signed_phase()` also appears in `fn do_elect`. This
+						//     is a guard against the case that `elect` is called prematurely. This
+						//     adds a small amount of overhead, but that is unfortunately
+						//     unavoidable.
+						let _ = Self::finalize_signed_phase();
+						// In the future we can consider disabling the unsigned phase if the signed
+						// phase completes successfully, but for now we're enabling it
+						// unconditionally as a defensive measure.
+						(false, true)
+					} else {
+						// No signed phase: create a new snapshot, definitely `enable` the unsigned
+						// phase.
+						(true, true)
+					};
+
+					if need_snapshot {
+						match Self::create_snapshot() {
+							Ok(_) => {
+								Self::phase_transition(Phase::Unsigned((enabled, now)));
+								T::WeightInfo::on_initialize_open_unsigned()
+							},
+							Err(why) => {
+								log!(warn, "failed to open unsigned phase due to {:?}", why);
+								T::WeightInfo::on_initialize_nothing()
+							},
+						}
+					} else {
+						Self::phase_transition(Phase::Unsigned((enabled, now)));
+						T::WeightInfo::on_initialize_open_unsigned()
+					}
+				},
+				_ => T::WeightInfo::on_initialize_nothing(),
+			}
+		}
+
+		fn offchain_worker(now: BlockNumberFor<T>) {
+			use sp_runtime::offchain::storage_lock::{BlockAndTime, StorageLock};
+
+			// Create a lock with the maximum deadline of number of blocks in the unsigned phase.
+			// This should only come useful in an **abrupt** termination of execution, otherwise the
+			// guard will be dropped upon successful execution.
+			let mut lock =
+				StorageLock::<BlockAndTime<frame_system::Pallet<T>>>::with_block_deadline(
+					unsigned::OFFCHAIN_LOCK,
+					T::UnsignedPhase::get().saturated_into(),
+				);
+
+			match lock.try_lock() {
+				Ok(_guard) => {
+					Self::do_synchronized_offchain_worker(now);
+				},
+				Err(deadline) => {
+					log!(debug, "offchain worker lock not released, deadline is {:?}", deadline);
+				},
+			};
+		}
+
+		fn integrity_test() {
+			use sp_std::mem::size_of;
+			// The index type of both voters and targets need to be smaller than that of usize (very
+			// unlikely to be the case, but anyhow)..
+			assert!(size_of::<SolutionVoterIndexOf<T::MinerConfig>>() <= size_of::<usize>());
+			assert!(size_of::<SolutionTargetIndexOf<T::MinerConfig>>() <= size_of::<usize>());
+
+			// ----------------------------
+			// Based on the requirements of [`sp_npos_elections::Assignment::try_normalize`].
+			let max_vote: usize = <SolutionOf<T::MinerConfig> as NposSolution>::LIMIT;
+
+			// 2. Maximum sum of [SolutionAccuracy; 16] must fit into `UpperOf<OffchainAccuracy>`.
+			let maximum_chain_accuracy: Vec<UpperOf<SolutionAccuracyOf<T>>> = (0..max_vote)
+				.map(|_| {
+					<UpperOf<SolutionAccuracyOf<T>>>::from(
+						<SolutionAccuracyOf<T>>::one().deconstruct(),
+					)
+				})
+				.collect();
+			let _: UpperOf<SolutionAccuracyOf<T>> = maximum_chain_accuracy
+				.iter()
+				.fold(Zero::zero(), |acc, x| acc.checked_add(x).unwrap());
+
+			// We only accept data provider who's maximum votes per voter matches our
+			// `T::Solution`'s `LIMIT`.
+			//
+			// NOTE that this pallet does not really need to enforce this in runtime. The
+			// solution cannot represent any voters more than `LIMIT` anyhow.
+			assert_eq!(
+				<T::DataProvider as ElectionDataProvider>::MaxVotesPerVoter::get(),
+				<SolutionOf<T::MinerConfig> as NposSolution>::LIMIT as u32,
+			);
+
+			// While it won't cause any failures, setting `SignedMaxRefunds` gt
+			// `SignedMaxSubmissions` is a red flag that the developer does not understand how to
+			// configure this pallet.
+			assert!(T::SignedMaxSubmissions::get() >= T::SignedMaxRefunds::get());
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_n: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+			Self::do_try_state()
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Submit a solution for the unsigned phase.
+		///
+		/// The dispatch origin fo this call must be __none__.
+		///
+		/// This submission is checked on the fly. Moreover, this unsigned solution is only
+		/// validated when submitted to the pool from the **local** node. Effectively, this means
+		/// that only active validators can submit this transaction when authoring a block (similar
+		/// to an inherent).
+		///
+		/// To prevent any incorrect solution (and thus wasted time/weight), this transaction will
+		/// panic if the solution submitted by the validator is invalid in any way, effectively
+		/// putting their authoring reward at risk.
+		///
+		/// No deposit or reward is associated with this submission.
+		#[pallet::call_index(0)]
+		#[pallet::weight((
+			T::WeightInfo::submit_unsigned(
+				witness.voters,
+				witness.targets,
+				raw_solution.solution.voter_count() as u32,
+				raw_solution.solution.unique_targets().len() as u32
+			),
+			DispatchClass::Operational,
+		))]
+		pub fn submit_unsigned(
+			origin: OriginFor<T>,
+			raw_solution: Box<RawSolution<SolutionOf<T::MinerConfig>>>,
+			witness: SolutionOrSnapshotSize,
+		) -> DispatchResult {
+			ensure_none(origin)?;
+			let error_message = "Invalid unsigned submission must produce invalid block and \
+				 deprive validator from their authoring reward.";
+
+			// Check score being an improvement, phase, and desired targets.
+			Self::unsigned_pre_dispatch_checks(&raw_solution).expect(error_message);
+
+			// Ensure witness was correct.
+			let SolutionOrSnapshotSize { voters, targets } =
+				Self::snapshot_metadata().expect(error_message);
+
+			// NOTE: we are asserting, not `ensure`ing -- we want to panic here.
+			assert!(voters as u32 == witness.voters, "{}", error_message);
+			assert!(targets as u32 == witness.targets, "{}", error_message);
+
+			let ready = Self::feasibility_check(*raw_solution, ElectionCompute::Unsigned)
+				.expect(error_message);
+
+			// Store the newly received solution.
+			log!(info, "queued unsigned solution with score {:?}", ready.score);
+			let ejected_a_solution = <QueuedSolution<T>>::exists();
+			<QueuedSolution<T>>::put(ready);
+			Self::deposit_event(Event::SolutionStored {
+				compute: ElectionCompute::Unsigned,
+				origin: None,
+				prev_ejected: ejected_a_solution,
+			});
+
+			Ok(())
+		}
+
+		/// Set a new value for `MinimumUntrustedScore`.
+		///
+		/// Dispatch origin must be aligned with `T::ForceOrigin`.
+		///
+		/// This check can be turned off by setting the value to `None`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::DbWeight::get().writes(1))]
+		pub fn set_minimum_untrusted_score(
+			origin: OriginFor<T>,
+			maybe_next_score: Option<ElectionScore>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			<MinimumUntrustedScore<T>>::set(maybe_next_score);
+			Ok(())
+		}
+
+		/// Set a solution in the queue, to be handed out to the client of this pallet in the next
+		/// call to `ElectionProvider::elect`.
+		///
+		/// This can only be set by `T::ForceOrigin`, and only when the phase is `Emergency`.
+		///
+		/// The solution is not checked for any feasibility and is assumed to be trustworthy, as any
+		/// feasibility check itself can in principle cause the election process to fail (due to
+		/// memory/weight constrains).
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1))]
+		pub fn set_emergency_election_result(
+			origin: OriginFor<T>,
+			supports: Supports<T::AccountId>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			ensure!(Self::current_phase().is_emergency(), <Error<T>>::CallNotAllowed);
+
+			// bound supports with T::MaxWinners
+			let supports = supports.try_into().map_err(|_| Error::<T>::TooManyWinners)?;
+
+			// Note: we don't `rotate_round` at this point; the next call to
+			// `ElectionProvider::elect` will succeed and take care of that.
+			let solution = ReadySolution {
+				supports,
+				score: Default::default(),
+				compute: ElectionCompute::Emergency,
+			};
+
+			Self::deposit_event(Event::SolutionStored {
+				compute: ElectionCompute::Emergency,
+				origin: None,
+				prev_ejected: QueuedSolution::<T>::exists(),
+			});
+
+			<QueuedSolution<T>>::put(solution);
+			Ok(())
+		}
+
+		/// Submit a solution for the signed phase.
+		///
+		/// The dispatch origin fo this call must be __signed__.
+		///
+		/// The solution is potentially queued, based on the claimed score and processed at the end
+		/// of the signed phase.
+		///
+		/// A deposit is reserved and recorded for the solution. Based on the outcome, the solution
+		/// might be rewarded, slashed, or get all or a part of the deposit back.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::submit())]
+		pub fn submit(
+			origin: OriginFor<T>,
+			raw_solution: Box<RawSolution<SolutionOf<T::MinerConfig>>>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			// ensure solution is timely.
+			ensure!(Self::current_phase().is_signed(), Error::<T>::PreDispatchEarlySubmission);
+
+			// NOTE: this is the only case where having separate snapshot would have been better
+			// because could do just decode_len. But we can create abstractions to do this.
+
+			// build size. Note: this is not needed for weight calc, thus not input.
+			// unlikely to ever return an error: if phase is signed, snapshot will exist.
+			let size = Self::snapshot_metadata().ok_or(Error::<T>::MissingSnapshotMetadata)?;
+
+			ensure!(
+				Self::solution_weight_of(&raw_solution, size).all_lt(T::SignedMaxWeight::get()),
+				Error::<T>::SignedTooMuchWeight,
+			);
+
+			// create the submission
+			let deposit = Self::deposit_for(&raw_solution, size);
+			let call_fee = {
+				let call = Call::submit { raw_solution: raw_solution.clone() };
+				T::EstimateCallFee::estimate_call_fee(&call, None::<Weight>.into())
+			};
+
+			let submission = SignedSubmission {
+				who: who.clone(),
+				deposit,
+				raw_solution: *raw_solution,
+				call_fee,
+			};
+
+			// insert the submission if the queue has space or it's better than the weakest
+			// eject the weakest if the queue was full
+			let mut signed_submissions = Self::signed_submissions();
+			let maybe_removed = match signed_submissions.insert(submission) {
+				// it's an error if we failed to insert a submission: this indicates the queue was
+				// full but our solution had insufficient score to eject any solution
+				signed::InsertResult::NotInserted => return Err(Error::<T>::SignedQueueFull.into()),
+				signed::InsertResult::Inserted => None,
+				signed::InsertResult::InsertedEjecting(weakest) => Some(weakest),
+			};
+
+			// collect deposit. Thereafter, the function cannot fail.
+			T::Currency::reserve(&who, deposit).map_err(|_| Error::<T>::SignedCannotPayDeposit)?;
+
+			let ejected_a_solution = maybe_removed.is_some();
+			// if we had to remove the weakest solution, unreserve its deposit
+			if let Some(removed) = maybe_removed {
+				let _remainder = T::Currency::unreserve(&removed.who, removed.deposit);
+				debug_assert!(_remainder.is_zero());
+			}
+
+			signed_submissions.put();
+			Self::deposit_event(Event::SolutionStored {
+				compute: ElectionCompute::Signed,
+				origin: Some(who),
+				prev_ejected: ejected_a_solution,
+			});
+			Ok(())
+		}
+
+		/// Trigger the governance fallback.
+		///
+		/// This can only be called when [`Phase::Emergency`] is enabled, as an alternative to
+		/// calling [`Call::set_emergency_election_result`].
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1))]
+		pub fn governance_fallback(
+			origin: OriginFor<T>,
+			maybe_max_voters: Option<u32>,
+			maybe_max_targets: Option<u32>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			ensure!(Self::current_phase().is_emergency(), <Error<T>>::CallNotAllowed);
+
+			let election_bounds = ElectionBoundsBuilder::default()
+				.voters_count(maybe_max_voters.unwrap_or(u32::MAX).into())
+				.targets_count(maybe_max_targets.unwrap_or(u32::MAX).into())
+				.build();
+
+			let supports = T::GovernanceFallback::instant_elect(
+				election_bounds.voters,
+				election_bounds.targets,
+			)
+			.map_err(|e| {
+				log!(error, "GovernanceFallback failed: {:?}", e);
+				Error::<T>::FallbackFailed
+			})?;
+
+			// transform BoundedVec<_, T::GovernanceFallback::MaxWinners> into
+			// `BoundedVec<_, T::MaxWinners>`
+			let supports: BoundedVec<_, T::MaxWinners> = supports
+				.into_inner()
+				.try_into()
+				.defensive_map_err(|_| Error::<T>::BoundNotMet)?;
+
+			let solution = ReadySolution {
+				supports,
+				score: Default::default(),
+				compute: ElectionCompute::Fallback,
+			};
+
+			Self::deposit_event(Event::SolutionStored {
+				compute: ElectionCompute::Fallback,
+				origin: None,
+				prev_ejected: QueuedSolution::<T>::exists(),
+			});
+
+			<QueuedSolution<T>>::put(solution);
+			Ok(())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A solution was stored with the given compute.
+		///
+		/// The `origin` indicates the origin of the solution. If `origin` is `Some(AccountId)`,
+		/// the stored solution was submited in the signed phase by a miner with the `AccountId`.
+		/// Otherwise, the solution was stored either during the unsigned phase or by
+		/// `T::ForceOrigin`. The `bool` is `true` when a previous solution was ejected to make
+		/// room for this one.
+		SolutionStored {
+			compute: ElectionCompute,
+			origin: Option<T::AccountId>,
+			prev_ejected: bool,
+		},
+		/// The election has been finalized, with the given computation and score.
+		ElectionFinalized { compute: ElectionCompute, score: ElectionScore },
+		/// An election failed.
+		///
+		/// Not much can be said about which computes failed in the process.
+		ElectionFailed,
+		/// An account has been rewarded for their signed submission being finalized.
+		Rewarded { account: <T as frame_system::Config>::AccountId, value: BalanceOf<T> },
+		/// An account has been slashed for submitting an invalid signed submission.
+		Slashed { account: <T as frame_system::Config>::AccountId, value: BalanceOf<T> },
+		/// There was a phase transition in a given round.
+		PhaseTransitioned {
+			from: Phase<BlockNumberFor<T>>,
+			to: Phase<BlockNumberFor<T>>,
+			round: u32,
+		},
+	}
+
+	/// Error of the pallet that can be returned in response to dispatches.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Submission was too early.
+		PreDispatchEarlySubmission,
+		/// Wrong number of winners presented.
+		PreDispatchWrongWinnerCount,
+		/// Submission was too weak, score-wise.
+		PreDispatchWeakSubmission,
+		/// The queue was full, and the solution was not better than any of the existing ones.
+		SignedQueueFull,
+		/// The origin failed to pay the deposit.
+		SignedCannotPayDeposit,
+		/// Witness data to dispatchable is invalid.
+		SignedInvalidWitness,
+		/// The signed submission consumes too much weight
+		SignedTooMuchWeight,
+		/// OCW submitted solution for wrong round
+		OcwCallWrongEra,
+		/// Snapshot metadata should exist but didn't.
+		MissingSnapshotMetadata,
+		/// `Self::insert_submission` returned an invalid index.
+		InvalidSubmissionIndex,
+		/// The call is not allowed at this point.
+		CallNotAllowed,
+		/// The fallback failed
+		FallbackFailed,
+		/// Some bound not met
+		BoundNotMet,
+		/// Submitted solution has too many winners
+		TooManyWinners,
+	}
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+		fn validate_unsigned(source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			if let Call::submit_unsigned { raw_solution, .. } = call {
+				// Discard solution not coming from the local OCW.
+				match source {
+					TransactionSource::Local | TransactionSource::InBlock => { /* allowed */ },
+					_ => return InvalidTransaction::Call.into(),
+				}
+
+				let _ = Self::unsigned_pre_dispatch_checks(raw_solution)
+					.map_err(|err| {
+						log!(debug, "unsigned transaction validation failed due to {:?}", err);
+						err
+					})
+					.map_err(dispatch_error_to_invalid)?;
+
+				ValidTransaction::with_tag_prefix("OffchainElection")
+					// The higher the score.minimal_stake, the better a solution is.
+					.priority(
+						T::MinerTxPriority::get()
+							.saturating_add(raw_solution.score.minimal_stake.saturated_into()),
+					)
+					// Used to deduplicate unsigned solutions: each validator should produce one
+					// solution per round at most, and solutions are not propagate.
+					.and_provides(raw_solution.round)
+					// Transaction should stay in the pool for the duration of the unsigned phase.
+					.longevity(T::UnsignedPhase::get().saturated_into::<u64>())
+					// We don't propagate this. This can never be validated at a remote node.
+					.propagate(false)
+					.build()
+			} else {
+				InvalidTransaction::Call.into()
+			}
+		}
+
+		fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError> {
+			if let Call::submit_unsigned { raw_solution, .. } = call {
+				Self::unsigned_pre_dispatch_checks(raw_solution)
+					.map_err(dispatch_error_to_invalid)
+					.map_err(Into::into)
+			} else {
+				Err(InvalidTransaction::Call.into())
+			}
+		}
+	}
+
+	#[pallet::type_value]
+	pub fn DefaultForRound() -> u32 {
+		1
+	}
+
+	/// Internal counter for the number of rounds.
+	///
+	/// This is useful for de-duplication of transactions submitted to the pool, and general
+	/// diagnostics of the pallet.
+	///
+	/// This is merely incremented once per every time that an upstream `elect` is called.
+	#[pallet::storage]
+	#[pallet::getter(fn round)]
+	pub type Round<T: Config> = StorageValue<_, u32, ValueQuery, DefaultForRound>;
+
+	/// Current phase.
+	#[pallet::storage]
+	#[pallet::getter(fn current_phase)]
+	pub type CurrentPhase<T: Config> = StorageValue<_, Phase<BlockNumberFor<T>>, ValueQuery>;
+
+	/// Current best solution, signed or unsigned, queued to be returned upon `elect`.
+	///
+	/// Always sorted by score.
+	#[pallet::storage]
+	#[pallet::getter(fn queued_solution)]
+	pub type QueuedSolution<T: Config> =
+		StorageValue<_, ReadySolution<T::AccountId, T::MaxWinners>>;
+
+	/// Snapshot data of the round.
+	///
+	/// This is created at the beginning of the signed phase and cleared upon calling `elect`.
+	#[pallet::storage]
+	#[pallet::getter(fn snapshot)]
+	pub type Snapshot<T: Config> = StorageValue<_, RoundSnapshot<T::AccountId, VoterOf<T>>>;
+
+	/// Desired number of targets to elect for this round.
+	///
+	/// Only exists when [`Snapshot`] is present.
+	#[pallet::storage]
+	#[pallet::getter(fn desired_targets)]
+	pub type DesiredTargets<T> = StorageValue<_, u32>;
+
+	/// The metadata of the [`RoundSnapshot`]
+	///
+	/// Only exists when [`Snapshot`] is present.
+	#[pallet::storage]
+	#[pallet::getter(fn snapshot_metadata)]
+	pub type SnapshotMetadata<T: Config> = StorageValue<_, SolutionOrSnapshotSize>;
+
+	// The following storage items collectively comprise `SignedSubmissions<T>`, and should never be
+	// accessed independently. Instead, get `Self::signed_submissions()`, modify it as desired, and
+	// then do `signed_submissions.put()` when you're done with it.
+
+	/// The next index to be assigned to an incoming signed submission.
+	///
+	/// Every accepted submission is assigned a unique index; that index is bound to that particular
+	/// submission for the duration of the election. On election finalization, the next index is
+	/// reset to 0.
+	///
+	/// We can't just use `SignedSubmissionIndices.len()`, because that's a bounded set; past its
+	/// capacity, it will simply saturate. We can't just iterate over `SignedSubmissionsMap`,
+	/// because iteration is slow. Instead, we store the value here.
+	#[pallet::storage]
+	pub type SignedSubmissionNextIndex<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	/// A sorted, bounded vector of `(score, block_number, index)`, where each `index` points to a
+	/// value in `SignedSubmissions`.
+	///
+	/// We never need to process more than a single signed submission at a time. Signed submissions
+	/// can be quite large, so we're willing to pay the cost of multiple database accesses to access
+	/// them one at a time instead of reading and decoding all of them at once.
+	#[pallet::storage]
+	pub type SignedSubmissionIndices<T: Config> =
+		StorageValue<_, SubmissionIndicesOf<T>, ValueQuery>;
+
+	/// Unchecked, signed solutions.
+	///
+	/// Together with `SubmissionIndices`, this stores a bounded set of `SignedSubmissions` while
+	/// allowing us to keep only a single one in memory at a time.
+	///
+	/// Twox note: the key of the map is an auto-incrementing index which users cannot inspect or
+	/// affect; we shouldn't need a cryptographically secure hasher.
+	#[pallet::storage]
+	pub type SignedSubmissionsMap<T: Config> =
+		StorageMap<_, Twox64Concat, u32, SignedSubmissionOf<T>, OptionQuery>;
+
+	// `SignedSubmissions` items end here.
+
+	/// The minimum score that each 'untrusted' solution must attain in order to be considered
+	/// feasible.
+	///
+	/// Can be set via `set_minimum_untrusted_score`.
+	#[pallet::storage]
+	#[pallet::getter(fn minimum_untrusted_score)]
+	pub type MinimumUntrustedScore<T: Config> = StorageValue<_, ElectionScore>;
+
+	/// The current storage version.
+	///
+	/// v1: https://github.com/paritytech/substrate/pull/12237/
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::without_storage_info]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+}
+
+impl<T: Config> Pallet<T> {
+	/// Internal logic of the offchain worker, to be executed only when the offchain lock is
+	/// acquired with success.
+	fn do_synchronized_offchain_worker(now: BlockNumberFor<T>) {
+		let current_phase = Self::current_phase();
+		log!(trace, "lock for offchain worker acquired. Phase = {:?}", current_phase);
+		match current_phase {
+			Phase::Unsigned((true, opened)) if opened == now => {
+				// Mine a new solution, cache it, and attempt to submit it
+				let initial_output = Self::ensure_offchain_repeat_frequency(now).and_then(|_| {
+					// This is executed at the beginning of each round. Any cache is now invalid.
+					// Clear it.
+					unsigned::kill_ocw_solution::<T>();
+					Self::mine_check_save_submit()
+				});
+				log!(debug, "initial offchain thread output: {:?}", initial_output);
+			},
+			Phase::Unsigned((true, opened)) if opened < now => {
+				// Try and resubmit the cached solution, and recompute ONLY if it is not
+				// feasible.
+				let resubmit_output = Self::ensure_offchain_repeat_frequency(now)
+					.and_then(|_| Self::restore_or_compute_then_maybe_submit());
+				log!(debug, "resubmit offchain thread output: {:?}", resubmit_output);
+			},
+			_ => {},
+		}
+	}
+
+	/// Phase transition helper.
+	pub(crate) fn phase_transition(to: Phase<BlockNumberFor<T>>) {
+		log!(info, "Starting phase {:?}, round {}.", to, Self::round());
+		Self::deposit_event(Event::PhaseTransitioned {
+			from: <CurrentPhase<T>>::get(),
+			to,
+			round: Self::round(),
+		});
+		<CurrentPhase<T>>::put(to);
+	}
+
+	/// Parts of [`create_snapshot`] that happen inside of this pallet.
+	///
+	/// Extracted for easier weight calculation.
+	fn create_snapshot_internal(
+		targets: Vec<T::AccountId>,
+		voters: Vec<VoterOf<T>>,
+		desired_targets: u32,
+	) {
+		let metadata =
+			SolutionOrSnapshotSize { voters: voters.len() as u32, targets: targets.len() as u32 };
+		log!(info, "creating a snapshot with metadata {:?}", metadata);
+
+		<SnapshotMetadata<T>>::put(metadata);
+		<DesiredTargets<T>>::put(desired_targets);
+
+		// instead of using storage APIs, we do a manual encoding into a fixed-size buffer.
+		// `encoded_size` encodes it without storing it anywhere, this should not cause any
+		// allocation.
+		let snapshot = RoundSnapshot::<T::AccountId, VoterOf<T>> { voters, targets };
+		let size = snapshot.encoded_size();
+		log!(debug, "snapshot pre-calculated size {:?}", size);
+		let mut buffer = Vec::with_capacity(size);
+		snapshot.encode_to(&mut buffer);
+
+		// do some checks.
+		debug_assert_eq!(buffer, snapshot.encode());
+		// buffer should have not re-allocated since.
+		debug_assert!(buffer.len() == size && size == buffer.capacity());
+
+		sp_io::storage::set(&<Snapshot<T>>::hashed_key(), &buffer);
+	}
+
+	/// Parts of [`create_snapshot`] that happen outside of this pallet.
+	///
+	/// Extracted for easier weight calculation.
+	fn create_snapshot_external(
+	) -> Result<(Vec<T::AccountId>, Vec<VoterOf<T>>, u32), ElectionError<T>> {
+		let election_bounds = T::ElectionBounds::get();
+
+		let targets = T::DataProvider::electable_targets(election_bounds.targets)
+			.and_then(|t| {
+				election_bounds.ensure_targets_limits(
+					CountBound(t.len() as u32),
+					SizeBound(t.encoded_size() as u32),
+				)?;
+				Ok(t)
+			})
+			.map_err(ElectionError::DataProvider)?;
+
+		let voters = T::DataProvider::electing_voters(election_bounds.voters)
+			.and_then(|v| {
+				election_bounds.ensure_voters_limits(
+					CountBound(v.len() as u32),
+					SizeBound(v.encoded_size() as u32),
+				)?;
+				Ok(v)
+			})
+			.map_err(ElectionError::DataProvider)?;
+
+		let mut desired_targets = <Pallet<T> as ElectionProviderBase>::desired_targets_checked()
+			.map_err(|e| ElectionError::DataProvider(e))?;
+
+		// If `desired_targets` > `targets.len()`, cap `desired_targets` to that level and emit a
+		// warning
+		let max_desired_targets: u32 = targets.len() as u32;
+		if desired_targets > max_desired_targets {
+			log!(
+				warn,
+				"desired_targets: {} > targets.len(): {}, capping desired_targets",
+				desired_targets,
+				max_desired_targets
+			);
+			desired_targets = max_desired_targets;
+		}
+
+		Ok((targets, voters, desired_targets))
+	}
+
+	/// Creates the snapshot. Writes new data to:
+	///
+	/// 1. [`SnapshotMetadata`]
+	/// 2. [`RoundSnapshot`]
+	/// 3. [`DesiredTargets`]
+	///
+	/// Returns `Ok(())` if operation is okay.
+	///
+	/// This is a *self-weighing* function, it will register its own extra weight as
+	/// [`DispatchClass::Mandatory`] with the system pallet.
+	pub fn create_snapshot() -> Result<(), ElectionError<T>> {
+		// this is self-weighing itself..
+		let (targets, voters, desired_targets) = Self::create_snapshot_external()?;
+
+		// ..therefore we only measure the weight of this and add it.
+		let internal_weight =
+			T::WeightInfo::create_snapshot_internal(voters.len() as u32, targets.len() as u32);
+		Self::create_snapshot_internal(targets, voters, desired_targets);
+		Self::register_weight(internal_weight);
+		Ok(())
+	}
+
+	/// Register some amount of weight directly with the system pallet.
+	///
+	/// This is always mandatory weight.
+	fn register_weight(weight: Weight) {
+		<frame_system::Pallet<T>>::register_extra_weight_unchecked(
+			weight,
+			DispatchClass::Mandatory,
+		);
+	}
+
+	/// Kill everything created by [`Pallet::create_snapshot`].
+	pub fn kill_snapshot() {
+		<Snapshot<T>>::kill();
+		<SnapshotMetadata<T>>::kill();
+		<DesiredTargets<T>>::kill();
+	}
+
+	/// Checks the feasibility of a solution.
+	pub fn feasibility_check(
+		raw_solution: RawSolution<SolutionOf<T::MinerConfig>>,
+		compute: ElectionCompute,
+	) -> Result<ReadySolution<T::AccountId, T::MaxWinners>, FeasibilityError> {
+		let desired_targets =
+			Self::desired_targets().ok_or(FeasibilityError::SnapshotUnavailable)?;
+
+		let snapshot = Self::snapshot().ok_or(FeasibilityError::SnapshotUnavailable)?;
+		let round = Self::round();
+		let minimum_untrusted_score = Self::minimum_untrusted_score();
+
+		Miner::<T::MinerConfig>::feasibility_check(
+			raw_solution,
+			compute,
+			desired_targets,
+			snapshot,
+			round,
+			minimum_untrusted_score,
+		)
+	}
+
+	/// Perform the tasks to be done after a new `elect` has been triggered:
+	///
+	/// 1. Increment round.
+	/// 2. Change phase to [`Phase::Off`]
+	/// 3. Clear all snapshot data.
+	fn rotate_round() {
+		// Inc round.
+		<Round<T>>::mutate(|r| *r += 1);
+
+		// Phase is off now.
+		Self::phase_transition(Phase::Off);
+
+		// Kill snapshots.
+		Self::kill_snapshot();
+	}
+
+	fn do_elect() -> Result<BoundedSupportsOf<Self>, ElectionError<T>> {
+		// We have to unconditionally try finalizing the signed phase here. There are only two
+		// possibilities:
+		//
+		// - signed phase was open, in which case this is essential for correct functioning of the
+		//   system
+		// - signed phase was complete or not started, in which case finalization is idempotent and
+		//   inexpensive (1 read of an empty vector).
+		let _ = Self::finalize_signed_phase();
+
+		<QueuedSolution<T>>::take()
+			.ok_or(ElectionError::<T>::NothingQueued)
+			.or_else(|_| {
+				// default data provider bounds are unbounded. calling `instant_elect` with
+				// unbounded data provider bounds means that the on-chain `T:Bounds` configs will
+				// *not* be overwritten.
+				T::Fallback::instant_elect(
+					DataProviderBounds::default(),
+					DataProviderBounds::default(),
+				)
+				.map_err(|fe| ElectionError::Fallback(fe))
+				.and_then(|supports| {
+					Ok(ReadySolution {
+						supports,
+						score: Default::default(),
+						compute: ElectionCompute::Fallback,
+					})
+				})
+			})
+			.map(|ReadySolution { compute, score, supports }| {
+				Self::deposit_event(Event::ElectionFinalized { compute, score });
+				if Self::round() != 1 {
+					log!(info, "Finalized election round with compute {:?}.", compute);
+				}
+				supports
+			})
+			.map_err(|err| {
+				Self::deposit_event(Event::ElectionFailed);
+				if Self::round() != 1 {
+					log!(warn, "Failed to finalize election round. reason {:?}", err);
+				}
+				err
+			})
+	}
+
+	/// record the weight of the given `supports`.
+	fn weigh_supports(supports: &Supports<T::AccountId>) {
+		let active_voters = supports
+			.iter()
+			.map(|(_, x)| x)
+			.fold(Zero::zero(), |acc, next| acc + next.voters.len() as u32);
+		let desired_targets = supports.len() as u32;
+		Self::register_weight(T::WeightInfo::elect_queued(active_voters, desired_targets));
+	}
+}
+
+#[cfg(feature = "try-runtime")]
+impl<T: Config> Pallet<T> {
+	fn do_try_state() -> Result<(), TryRuntimeError> {
+		Self::try_state_snapshot()?;
+		Self::try_state_signed_submissions_map()?;
+		Self::try_state_phase_off()
+	}
+
+	// [`Snapshot`] state check. Invariants:
+	// - [`DesiredTargets`] exists if and only if [`Snapshot`] is present.
+	// - [`SnapshotMetadata`] exist if and only if [`Snapshot`] is present.
+	fn try_state_snapshot() -> Result<(), TryRuntimeError> {
+		if <Snapshot<T>>::exists() &&
+			<SnapshotMetadata<T>>::exists() &&
+			<DesiredTargets<T>>::exists()
+		{
+			Ok(())
+		} else if !<Snapshot<T>>::exists() &&
+			!<SnapshotMetadata<T>>::exists() &&
+			!<DesiredTargets<T>>::exists()
+		{
+			Ok(())
+		} else {
+			Err("If snapshot exists, metadata and desired targets should be set too. Otherwise, none should be set.".into())
+		}
+	}
+
+	// [`SignedSubmissionsMap`] state check. Invariants:
+	// - All [`SignedSubmissionIndices`] are present in [`SignedSubmissionsMap`], and no more;
+	// - [`SignedSubmissionNextIndex`] is not present in [`SignedSubmissionsMap`];
+	// - [`SignedSubmissionIndices`] is sorted by election score.
+	fn try_state_signed_submissions_map() -> Result<(), TryRuntimeError> {
+		let mut last_score: ElectionScore = Default::default();
+		let indices = <SignedSubmissionIndices<T>>::get();
+
+		for (i, indice) in indices.iter().enumerate() {
+			let submission = <SignedSubmissionsMap<T>>::get(indice.2);
+			if submission.is_none() {
+				return Err(
+					"All signed submissions indices must be part of the submissions map".into()
+				)
+			}
+
+			if i == 0 {
+				last_score = indice.0
+			} else {
+				if last_score.strict_threshold_better(indice.0, Perbill::zero()) {
+					return Err(
+						"Signed submission indices vector must be ordered by election score".into()
+					)
+				}
+				last_score = indice.0;
+			}
+		}
+
+		if <SignedSubmissionsMap<T>>::iter().nth(indices.len()).is_some() {
+			return Err(
+				"Signed submissions map length should be the same as the indices vec length".into()
+			)
+		}
+
+		match <SignedSubmissionNextIndex<T>>::get() {
+			0 => Ok(()),
+			next =>
+				if <SignedSubmissionsMap<T>>::get(next).is_some() {
+					return Err(
+						"The next submissions index should not be in the submissions maps already"
+							.into(),
+					)
+				} else {
+					Ok(())
+				},
+		}
+	}
+
+	// [`Phase::Off`] state check. Invariants:
+	// - If phase is `Phase::Off`, [`Snapshot`] must be none.
+	fn try_state_phase_off() -> Result<(), TryRuntimeError> {
+		match Self::current_phase().is_off() {
+			false => Ok(()),
+			true =>
+				if <Snapshot<T>>::get().is_some() {
+					Err("Snapshot must be none when in Phase::Off".into())
+				} else {
+					Ok(())
+				},
+		}
+	}
+}
+
+impl<T: Config> ElectionProviderBase for Pallet<T> {
+	type AccountId = T::AccountId;
+	type BlockNumber = BlockNumberFor<T>;
+	type Error = ElectionError<T>;
+	type MaxWinners = T::MaxWinners;
+	type DataProvider = T::DataProvider;
+}
+
+impl<T: Config> ElectionProvider for Pallet<T> {
+	fn ongoing() -> bool {
+		match Self::current_phase() {
+			Phase::Off => false,
+			_ => true,
+		}
+	}
+
+	fn elect() -> Result<BoundedSupportsOf<Self>, Self::Error> {
+		match Self::do_elect() {
+			Ok(supports) => {
+				// All went okay, record the weight, put sign to be Off, clean snapshot, etc.
+				Self::weigh_supports(&supports);
+				Self::rotate_round();
+				Ok(supports)
+			},
+			Err(why) => {
+				log!(error, "Entering emergency mode: {:?}", why);
+				Self::phase_transition(Phase::Emergency);
+				Err(why)
+			},
+		}
+	}
+}
+
+/// convert a DispatchError to a custom InvalidTransaction with the inner code being the error
+/// number.
+pub fn dispatch_error_to_invalid(error: DispatchError) -> InvalidTransaction {
+	let error_number = match error {
+		DispatchError::Module(ModuleError { error, .. }) => error[0],
+		_ => 0,
+	};
+	InvalidTransaction::Custom(error_number)
+}
+
+#[cfg(test)]
+mod feasibility_check {
+	//! All of the tests here should be dedicated to only testing the feasibility check and nothing
+	//! more. The best way to audit and review these tests is to try and come up with a solution
+	//! that is invalid, but gets through the system as valid.
+
+	use super::*;
+	use crate::mock::{
+		raw_solution, roll_to, EpochLength, ExtBuilder, MultiPhase, Runtime, SignedPhase,
+		TargetIndex, UnsignedPhase, VoterIndex,
+	};
+	use frame_support::{assert_noop, assert_ok};
+
+	const COMPUTE: ElectionCompute = ElectionCompute::OnChain;
+
+	#[test]
+	fn snapshot_is_there() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+			let solution = raw_solution();
+
+			// For whatever reason it might be:
+			<Snapshot<Runtime>>::kill();
+
+			assert_noop!(
+				MultiPhase::feasibility_check(solution, COMPUTE),
+				FeasibilityError::SnapshotUnavailable
+			);
+
+			// kill also `SnapshotMetadata` and `DesiredTargets` for the storage state to be
+			// consistent for the try_state checks to pass.
+			<SnapshotMetadata<Runtime>>::kill();
+			<DesiredTargets<Runtime>>::kill();
+		})
+	}
+
+	#[test]
+	fn round() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut solution = raw_solution();
+			solution.round += 1;
+			assert_noop!(
+				MultiPhase::feasibility_check(solution, COMPUTE),
+				FeasibilityError::InvalidRound
+			);
+		})
+	}
+
+	#[test]
+	fn desired_targets_gets_capped() {
+		ExtBuilder::default().desired_targets(8).build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let raw = raw_solution();
+
+			assert_eq!(raw.solution.unique_targets().len(), 4);
+			// desired_targets is capped to the number of targets which is 4
+			assert_eq!(MultiPhase::desired_targets().unwrap(), 4);
+
+			// It should succeed
+			assert_ok!(MultiPhase::feasibility_check(raw, COMPUTE));
+		})
+	}
+
+	#[test]
+	fn less_than_desired_targets_fails() {
+		ExtBuilder::default().desired_targets(8).build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut raw = raw_solution();
+
+			assert_eq!(raw.solution.unique_targets().len(), 4);
+			// desired_targets is capped to the number of targets which is 4
+			assert_eq!(MultiPhase::desired_targets().unwrap(), 4);
+
+			// Force the number of winners to be bigger to fail
+			raw.solution.votes1[0].1 = 4;
+
+			// It should succeed
+			assert_noop!(
+				MultiPhase::feasibility_check(raw, COMPUTE),
+				FeasibilityError::WrongWinnerCount,
+			);
+		})
+	}
+
+	#[test]
+	fn winner_indices() {
+		ExtBuilder::default().desired_targets(2).build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut raw = raw_solution();
+			assert_eq!(MultiPhase::snapshot().unwrap().targets.len(), 4);
+			// ----------------------------------------------------^^ valid range is [0..3].
+
+			// Swap all votes from 3 to 4. This will ensure that the number of unique winners will
+			// still be 4, but one of the indices will be gibberish. Requirement is to make sure 3 a
+			// winner, which we don't do here.
+			raw.solution
+				.votes1
+				.iter_mut()
+				.filter(|(_, t)| *t == TargetIndex::from(3u16))
+				.for_each(|(_, t)| *t += 1);
+			raw.solution.votes2.iter_mut().for_each(|(_, [(t0, _)], t1)| {
+				if *t0 == TargetIndex::from(3u16) {
+					*t0 += 1
+				};
+				if *t1 == TargetIndex::from(3u16) {
+					*t1 += 1
+				};
+			});
+			assert_noop!(
+				MultiPhase::feasibility_check(raw, COMPUTE),
+				FeasibilityError::NposElection(sp_npos_elections::Error::SolutionInvalidIndex)
+			);
+		})
+	}
+
+	#[test]
+	fn voter_indices() {
+		// Should be caught in `solution.into_assignment`.
+		ExtBuilder::default().desired_targets(2).build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut solution = raw_solution();
+			assert_eq!(MultiPhase::snapshot().unwrap().voters.len(), 8);
+			// ----------------------------------------------------^^ valid range is [0..7].
+
+			// Check that there is an index 7 in votes1, and flip to 8.
+			assert!(
+				solution
+					.solution
+					.votes1
+					.iter_mut()
+					.filter(|(v, _)| *v == VoterIndex::from(7u32))
+					.map(|(v, _)| *v = 8)
+					.count() > 0
+			);
+			assert_noop!(
+				MultiPhase::feasibility_check(solution, COMPUTE),
+				FeasibilityError::NposElection(sp_npos_elections::Error::SolutionInvalidIndex),
+			);
+		})
+	}
+
+	#[test]
+	fn voter_votes() {
+		ExtBuilder::default().desired_targets(2).build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut solution = raw_solution();
+			assert_eq!(MultiPhase::snapshot().unwrap().voters.len(), 8);
+			// ----------------------------------------------------^^ valid range is [0..7].
+
+			// First, check that voter at index 7 (40) actually voted for 3 (40) -- this is self
+			// vote. Then, change the vote to 2 (30).
+			assert_eq!(
+				solution
+					.solution
+					.votes1
+					.iter_mut()
+					.filter(|(v, t)| *v == 7 && *t == 3)
+					.map(|(_, t)| *t = 2)
+					.count(),
+				1,
+			);
+			assert_noop!(
+				MultiPhase::feasibility_check(solution, COMPUTE),
+				FeasibilityError::InvalidVote,
+			);
+		})
+	}
+
+	#[test]
+	fn score() {
+		ExtBuilder::default().desired_targets(2).build_and_execute(|| {
+			roll_to(<EpochLength>::get() - <SignedPhase>::get() - <UnsignedPhase>::get());
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut solution = raw_solution();
+			assert_eq!(MultiPhase::snapshot().unwrap().voters.len(), 8);
+
+			// Simply faff with the score.
+			solution.score.minimal_stake += 1;
+
+			assert_noop!(
+				MultiPhase::feasibility_check(solution, COMPUTE),
+				FeasibilityError::InvalidScore,
+			);
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		mock::{
+			multi_phase_events, raw_solution, roll_to, roll_to_signed, roll_to_unsigned, AccountId,
+			ElectionsBounds, ExtBuilder, MockWeightInfo, MockedWeightInfo, MultiPhase, Runtime,
+			RuntimeOrigin, SignedMaxSubmissions, System, TargetIndex, Targets, Voters,
+		},
+		Phase,
+	};
+	use frame_support::{assert_noop, assert_ok};
+	use sp_npos_elections::{BalancingConfig, Support};
+
+	#[test]
+	fn phase_rotation_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// 0 ------- 15 ------- 25 ------- 30 ------- ------- 45 ------- 55 ------- 60
+			//           |           |          |                 |           |          |
+			//         Signed      Unsigned   Elect             Signed     Unsigned    Elect
+
+			assert_eq!(System::block_number(), 0);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+			assert_eq!(MultiPhase::round(), 1);
+
+			roll_to(4);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+			assert!(MultiPhase::snapshot().is_none());
+			assert_eq!(MultiPhase::round(), 1);
+
+			roll_to_signed();
+			assert_eq!(MultiPhase::current_phase(), Phase::Signed);
+			assert_eq!(
+				multi_phase_events(),
+				vec![Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 }]
+			);
+			assert!(MultiPhase::snapshot().is_some());
+			assert_eq!(MultiPhase::round(), 1);
+
+			roll_to(24);
+			assert_eq!(MultiPhase::current_phase(), Phase::Signed);
+			assert!(MultiPhase::snapshot().is_some());
+			assert_eq!(MultiPhase::round(), 1);
+
+			roll_to_unsigned();
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+				],
+			);
+			assert!(MultiPhase::snapshot().is_some());
+
+			roll_to(29);
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+			assert!(MultiPhase::snapshot().is_some());
+
+			roll_to(30);
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+			assert!(MultiPhase::snapshot().is_some());
+
+			// We close when upstream tells us to elect.
+			roll_to(32);
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+			assert!(MultiPhase::snapshot().is_some());
+
+			assert_ok!(MultiPhase::elect());
+
+			assert!(MultiPhase::current_phase().is_off());
+			assert!(MultiPhase::snapshot().is_none());
+			assert_eq!(MultiPhase::round(), 2);
+
+			roll_to(44);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			roll_to(55);
+			assert!(MultiPhase::current_phase().is_unsigned_open_at(55));
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 25)),
+						to: Phase::Off,
+						round: 2
+					},
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 2 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 55)),
+						round: 2
+					},
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn signed_phase_void() {
+		ExtBuilder::default().phases(0, 10).build_and_execute(|| {
+			roll_to(15);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to(19);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to(20);
+			assert!(MultiPhase::current_phase().is_unsigned_open_at(20));
+			assert!(MultiPhase::snapshot().is_some());
+
+			roll_to(30);
+			assert!(MultiPhase::current_phase().is_unsigned_open_at(20));
+
+			assert_ok!(MultiPhase::elect());
+
+			assert!(MultiPhase::current_phase().is_off());
+			assert!(MultiPhase::snapshot().is_none());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned {
+						from: Phase::Off,
+						to: Phase::Unsigned((true, 20)),
+						round: 1
+					},
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 20)),
+						to: Phase::Off,
+						round: 2
+					},
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn unsigned_phase_void() {
+		ExtBuilder::default().phases(10, 0).build_and_execute(|| {
+			roll_to(15);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to(19);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+			assert!(MultiPhase::snapshot().is_some());
+
+			roll_to(30);
+			assert!(MultiPhase::current_phase().is_signed());
+
+			assert_ok!(MultiPhase::elect());
+
+			assert!(MultiPhase::current_phase().is_off());
+			assert!(MultiPhase::snapshot().is_none());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned { from: Phase::Signed, to: Phase::Off, round: 2 },
+				]
+			)
+		});
+	}
+
+	#[test]
+	fn both_phases_void() {
+		ExtBuilder::default().phases(0, 0).build_and_execute(|| {
+			roll_to(15);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to(19);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to(20);
+			assert!(MultiPhase::current_phase().is_off());
+
+			roll_to(30);
+			assert!(MultiPhase::current_phase().is_off());
+
+			// This module is now only capable of doing on-chain backup.
+			assert_ok!(MultiPhase::elect());
+
+			assert!(MultiPhase::current_phase().is_off());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Off, round: 2 },
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn early_termination() {
+		// An early termination in the signed phase, with no queued solution.
+		ExtBuilder::default().build_and_execute(|| {
+			// Signed phase started at block 15 and will end at 25.
+
+			roll_to_signed();
+			assert_eq!(
+				multi_phase_events(),
+				vec![Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 }]
+			);
+			assert_eq!(MultiPhase::current_phase(), Phase::Signed);
+			assert_eq!(MultiPhase::round(), 1);
+
+			// An unexpected call to elect.
+			assert_ok!(MultiPhase::elect());
+
+			// We surely can't have any feasible solutions. This will cause an on-chain election.
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: Default::default()
+					},
+					Event::PhaseTransitioned { from: Phase::Signed, to: Phase::Off, round: 2 },
+				],
+			);
+			// All storage items must be cleared.
+			assert_eq!(MultiPhase::round(), 2);
+			assert!(MultiPhase::snapshot().is_none());
+			assert!(MultiPhase::snapshot_metadata().is_none());
+			assert!(MultiPhase::desired_targets().is_none());
+			assert!(MultiPhase::queued_solution().is_none());
+			assert!(MultiPhase::signed_submissions().is_empty());
+		})
+	}
+
+	#[test]
+	fn early_termination_with_submissions() {
+		// an early termination in the signed phase, with no queued solution.
+		ExtBuilder::default().build_and_execute(|| {
+			// signed phase started at block 15 and will end at 25.
+
+			roll_to_signed();
+			assert_eq!(
+				multi_phase_events(),
+				vec![Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 }]
+			);
+			assert_eq!(MultiPhase::current_phase(), Phase::Signed);
+			assert_eq!(MultiPhase::round(), 1);
+
+			// fill the queue with signed submissions
+			for s in 0..SignedMaxSubmissions::get() {
+				let solution = RawSolution {
+					score: ElectionScore { minimal_stake: (5 + s).into(), ..Default::default() },
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(
+					crate::mock::RuntimeOrigin::signed(99),
+					Box::new(solution)
+				));
+			}
+
+			// an unexpected call to elect.
+			assert_ok!(MultiPhase::elect());
+
+			// all storage items must be cleared.
+			assert_eq!(MultiPhase::round(), 2);
+			assert!(MultiPhase::snapshot().is_none());
+			assert!(MultiPhase::snapshot_metadata().is_none());
+			assert!(MultiPhase::desired_targets().is_none());
+			assert!(MultiPhase::queued_solution().is_none());
+			assert!(MultiPhase::signed_submissions().is_empty());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::Slashed { account: 99, value: 5 },
+					Event::Slashed { account: 99, value: 5 },
+					Event::Slashed { account: 99, value: 5 },
+					Event::Slashed { account: 99, value: 5 },
+					Event::Slashed { account: 99, value: 5 },
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned { from: Phase::Signed, to: Phase::Off, round: 2 },
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn check_events_with_compute_signed() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let solution = raw_solution();
+			assert_ok!(MultiPhase::submit(
+				crate::mock::RuntimeOrigin::signed(99),
+				Box::new(solution)
+			));
+
+			roll_to(30);
+			assert_ok!(MultiPhase::elect());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::Rewarded { account: 99, value: 7 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Signed,
+						score: ElectionScore {
+							minimal_stake: 40,
+							sum_stake: 100,
+							sum_stake_squared: 5200
+						}
+					},
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 25)),
+						to: Phase::Off,
+						round: 2
+					},
+				],
+			);
+		})
+	}
+
+	#[test]
+	fn check_events_with_compute_unsigned() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// ensure we have snapshots in place.
+			assert!(MultiPhase::snapshot().is_some());
+			assert_eq!(MultiPhase::desired_targets().unwrap(), 2);
+
+			// mine seq_phragmen solution with 2 iters.
+			let (solution, witness) = MultiPhase::mine_solution().unwrap();
+
+			// ensure this solution is valid.
+			assert!(MultiPhase::queued_solution().is_none());
+			assert_ok!(MultiPhase::submit_unsigned(
+				crate::mock::RuntimeOrigin::none(),
+				Box::new(solution),
+				witness
+			));
+			assert!(MultiPhase::queued_solution().is_some());
+
+			assert_ok!(MultiPhase::elect());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Unsigned,
+						origin: None,
+						prev_ejected: false
+					},
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Unsigned,
+						score: ElectionScore {
+							minimal_stake: 40,
+							sum_stake: 100,
+							sum_stake_squared: 5200
+						}
+					},
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 25)),
+						to: Phase::Off,
+						round: 2
+					},
+				],
+			);
+		})
+	}
+
+	#[test]
+	fn fallback_strategy_works() {
+		ExtBuilder::default().onchain_fallback(true).build_and_execute(|| {
+			roll_to_unsigned();
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+
+			// Zilch solutions thus far, but we get a result.
+			assert!(MultiPhase::queued_solution().is_none());
+			let supports = MultiPhase::elect().unwrap();
+
+			assert_eq!(
+				supports,
+				vec![
+					(30, Support { total: 40, voters: vec![(2, 5), (4, 5), (30, 30)] }),
+					(40, Support { total: 60, voters: vec![(2, 5), (3, 10), (4, 5), (40, 40)] })
+				]
+			);
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 25)),
+						to: Phase::Off,
+						round: 2
+					},
+				]
+			);
+		});
+
+		ExtBuilder::default().onchain_fallback(false).build_and_execute(|| {
+			roll_to_unsigned();
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+
+			// Zilch solutions thus far.
+			assert!(MultiPhase::queued_solution().is_none());
+			assert_eq!(MultiPhase::elect().unwrap_err(), ElectionError::Fallback("NoFallback."));
+			// phase is now emergency.
+			assert_eq!(MultiPhase::current_phase(), Phase::Emergency);
+			// snapshot is still there until election finalizes.
+			assert!(MultiPhase::snapshot().is_some());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::ElectionFailed,
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 25)),
+						to: Phase::Emergency,
+						round: 1
+					},
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn governance_fallback_works() {
+		ExtBuilder::default().onchain_fallback(false).build_and_execute(|| {
+			roll_to_unsigned();
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+
+			// Zilch solutions thus far.
+			assert!(MultiPhase::queued_solution().is_none());
+			assert_eq!(MultiPhase::elect().unwrap_err(), ElectionError::Fallback("NoFallback."));
+
+			// phase is now emergency.
+			assert_eq!(MultiPhase::current_phase(), Phase::Emergency);
+			assert!(MultiPhase::queued_solution().is_none());
+			assert!(MultiPhase::snapshot().is_some());
+
+			// no single account can trigger this
+			assert_noop!(
+				MultiPhase::governance_fallback(RuntimeOrigin::signed(99), None, None),
+				DispatchError::BadOrigin
+			);
+
+			// only root can
+			assert_ok!(MultiPhase::governance_fallback(RuntimeOrigin::root(), None, None));
+			// something is queued now
+			assert!(MultiPhase::queued_solution().is_some());
+			// next election call with fix everything.;
+			assert!(MultiPhase::elect().is_ok());
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::ElectionFailed,
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 25)),
+						to: Phase::Emergency,
+						round: 1
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Fallback,
+						origin: None,
+						prev_ejected: false
+					},
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: Default::default()
+					},
+					Event::PhaseTransitioned { from: Phase::Emergency, to: Phase::Off, round: 2 },
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn snapshot_too_big_failure_onchain_fallback() {
+		// the `MockStaking` is designed such that if it has too many targets, it simply fails.
+		ExtBuilder::default().build_and_execute(|| {
+			// sets bounds on number of targets.
+			let new_bounds = ElectionBoundsBuilder::default().targets_count(1_000.into()).build();
+			ElectionsBounds::set(new_bounds);
+
+			Targets::set((0..(1_000 as AccountId) + 1).collect::<Vec<_>>());
+
+			// Signed phase failed to open.
+			roll_to(15);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+
+			// Unsigned phase failed to open.
+			roll_to(25);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+
+			// On-chain backup works though.
+			let supports = MultiPhase::elect().unwrap();
+			assert!(supports.len() > 0);
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Off, round: 2 },
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn snapshot_too_big_failure_no_fallback() {
+		// and if the backup mode is nothing, we go into the emergency mode..
+		ExtBuilder::default().onchain_fallback(false).build_and_execute(|| {
+			// sets bounds on number of targets.
+			let new_bounds = ElectionBoundsBuilder::default().targets_count(1_000.into()).build();
+			ElectionsBounds::set(new_bounds);
+
+			Targets::set((0..(TargetIndex::max_value() as AccountId) + 1).collect::<Vec<_>>());
+
+			// Signed phase failed to open.
+			roll_to(15);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+
+			// Unsigned phase failed to open.
+			roll_to(25);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+
+			roll_to(29);
+			let err = MultiPhase::elect().unwrap_err();
+			assert_eq!(err, ElectionError::Fallback("NoFallback."));
+			assert_eq!(MultiPhase::current_phase(), Phase::Emergency);
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::ElectionFailed,
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Emergency, round: 1 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn snapshot_too_big_truncate() {
+		// but if there are too many voters, we simply truncate them.
+		ExtBuilder::default().build_and_execute(|| {
+			// we have 8 voters in total.
+			assert_eq!(Voters::get().len(), 8);
+			// but we want to take 2.
+			let new_bounds = ElectionBoundsBuilder::default().voters_count(2.into()).build();
+			ElectionsBounds::set(new_bounds);
+
+			// Signed phase opens just fine.
+			roll_to_signed();
+			assert_eq!(MultiPhase::current_phase(), Phase::Signed);
+
+			assert_eq!(
+				MultiPhase::snapshot_metadata().unwrap(),
+				SolutionOrSnapshotSize { voters: 2, targets: 4 }
+			);
+		})
+	}
+
+	#[test]
+	fn untrusted_score_verification_is_respected() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert_eq!(MultiPhase::current_phase(), Phase::Signed);
+
+			// set the solution balancing to get the desired score.
+			crate::mock::Balancing::set(Some(BalancingConfig { iterations: 2, tolerance: 0 }));
+
+			let (solution, _) = MultiPhase::mine_solution().unwrap();
+			// Default solution's score.
+			assert!(matches!(solution.score, ElectionScore { minimal_stake: 50, .. }));
+
+			<MinimumUntrustedScore<Runtime>>::put(ElectionScore {
+				minimal_stake: 49,
+				..Default::default()
+			});
+			assert_ok!(MultiPhase::feasibility_check(solution.clone(), ElectionCompute::Signed));
+
+			<MinimumUntrustedScore<Runtime>>::put(ElectionScore {
+				minimal_stake: 51,
+				..Default::default()
+			});
+			assert_noop!(
+				MultiPhase::feasibility_check(solution, ElectionCompute::Signed),
+				FeasibilityError::UntrustedScoreTooLow,
+			);
+		})
+	}
+
+	#[test]
+	fn number_of_voters_allowed_2sec_block() {
+		// Just a rough estimate with the substrate weights.
+		assert_eq!(MockWeightInfo::get(), MockedWeightInfo::Real);
+
+		let all_voters: u32 = 10_000;
+		let all_targets: u32 = 5_000;
+		let desired: u32 = 1_000;
+		let weight_with = |active| {
+			<Runtime as Config>::WeightInfo::submit_unsigned(
+				all_voters,
+				all_targets,
+				active,
+				desired,
+			)
+		};
+
+		let mut active = 1;
+		while weight_with(active)
+			.all_lte(<Runtime as frame_system::Config>::BlockWeights::get().max_block) ||
+			active == all_voters
+		{
+			active += 1;
+		}
+
+		println!("can support {} voters to yield a weight of {}", active, weight_with(active));
+	}
+}
diff --git a/substrate/frame/election-provider-multi-phase/src/migrations.rs b/substrate/frame/election-provider-multi-phase/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..50b821e6db6ae8c7a2cc68192f9dd8cb39e9f460
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/migrations.rs
@@ -0,0 +1,78 @@
+// 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.
+
+pub mod v1 {
+	use frame_support::{
+		storage::unhashed,
+		traits::{Defensive, GetStorageVersion, OnRuntimeUpgrade},
+		BoundedVec,
+	};
+	use sp_std::collections::btree_map::BTreeMap;
+
+	use crate::*;
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			log!(
+				info,
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current,
+				onchain
+			);
+
+			if current == 1 && onchain == 0 {
+				if SignedSubmissionIndices::<T>::exists() {
+					// This needs to be tested at a both a block height where this value exists, and
+					// when it doesn't.
+					let now = frame_system::Pallet::<T>::block_number();
+					let map = unhashed::get::<BTreeMap<ElectionScore, u32>>(
+						&SignedSubmissionIndices::<T>::hashed_key(),
+					)
+					.defensive_unwrap_or_default();
+					let vector = map
+						.into_iter()
+						.map(|(score, index)| (score, now, index))
+						.collect::<Vec<_>>();
+
+					log!(
+						debug,
+						"{:?} SignedSubmissionIndices read from storage (max: {:?})",
+						vector.len(),
+						T::SignedMaxSubmissions::get()
+					);
+
+					// defensive-only, assuming a constant `SignedMaxSubmissions`.
+					let bounded = BoundedVec::<_, _>::truncate_from(vector);
+					SignedSubmissionIndices::<T>::put(bounded);
+
+					log!(info, "SignedSubmissionIndices existed and got migrated");
+				} else {
+					log!(info, "SignedSubmissionIndices did NOT exist.");
+				}
+
+				current.put::<Pallet<T>>();
+				T::DbWeight::get().reads_writes(2, 1)
+			} else {
+				log!(info, "Migration did not execute. This probably should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+	}
+}
diff --git a/substrate/frame/election-provider-multi-phase/src/mock.rs b/substrate/frame/election-provider-multi-phase/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..05d151e51ecc5beb5cc3e5f883ac91ada10318c4
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/mock.rs
@@ -0,0 +1,626 @@
+// 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 crate::{self as multi_phase, unsigned::MinerConfig};
+use frame_election_provider_support::{
+	bounds::{DataProviderBounds, ElectionBounds},
+	data_provider, onchain, ElectionDataProvider, NposSolution, SequentialPhragmen,
+};
+pub use frame_support::{assert_noop, assert_ok, pallet_prelude::GetDefault};
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, Hooks},
+	weights::{constants, Weight},
+	BoundedVec,
+};
+use multi_phase::unsigned::{IndexAssignmentOf, VoterOf};
+use parking_lot::RwLock;
+use sp_core::{
+	offchain::{
+		testing::{PoolState, TestOffchainExt, TestTransactionPoolExt},
+		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
+	},
+	H256,
+};
+use sp_npos_elections::{
+	assignment_ratio_to_staked_normalized, seq_phragmen, to_supports, BalancingConfig,
+	ElectionResult, EvaluateSupport,
+};
+use sp_runtime::{
+	bounded_vec,
+	testing::Header,
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage, PerU16,
+};
+use std::sync::Arc;
+
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic =
+	sp_runtime::generic::UncheckedExtrinsic<AccountId, RuntimeCall, (), ()>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Event<T>, Config<T>},
+		Balances: pallet_balances::{Pallet, Call, Event<T>, Config<T>},
+		MultiPhase: multi_phase::{Pallet, Call, Event<T>},
+	}
+);
+
+pub(crate) type Balance = u64;
+pub(crate) type AccountId = u64;
+pub(crate) type BlockNumber = u64;
+pub(crate) type VoterIndex = u32;
+pub(crate) type TargetIndex = u16;
+
+frame_election_provider_support::generate_solution_type!(
+	#[compact]
+	pub struct TestNposSolution::<
+		VoterIndex = VoterIndex,
+		TargetIndex = TargetIndex,
+		Accuracy = PerU16,
+		MaxVoters = ConstU32::<2_000>
+	>(16)
+);
+
+/// All events of this pallet.
+pub(crate) fn multi_phase_events() -> Vec<super::Event<Runtime>> {
+	System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::MultiPhase(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>()
+}
+
+/// To from `now` to block `n`.
+pub fn roll_to(n: BlockNumber) {
+	let now = System::block_number();
+	for i in now + 1..=n {
+		System::set_block_number(i);
+		MultiPhase::on_initialize(i);
+	}
+}
+
+pub fn roll_to_unsigned() {
+	while !matches!(MultiPhase::current_phase(), Phase::Unsigned(_)) {
+		roll_to(System::block_number() + 1);
+	}
+}
+pub fn roll_to_signed() {
+	while !matches!(MultiPhase::current_phase(), Phase::Signed) {
+		roll_to(System::block_number() + 1);
+	}
+}
+
+pub fn roll_to_with_ocw(n: BlockNumber) {
+	let now = System::block_number();
+	for i in now + 1..=n {
+		System::set_block_number(i);
+		MultiPhase::on_initialize(i);
+		MultiPhase::offchain_worker(i);
+	}
+}
+
+pub struct TrimHelpers {
+	pub voters: Vec<VoterOf<Runtime>>,
+	pub assignments: Vec<IndexAssignmentOf<Runtime>>,
+	pub encoded_size_of:
+		Box<dyn Fn(&[IndexAssignmentOf<Runtime>]) -> Result<usize, sp_npos_elections::Error>>,
+	pub voter_index: Box<
+		dyn Fn(
+			&<Runtime as frame_system::Config>::AccountId,
+		) -> Option<SolutionVoterIndexOf<Runtime>>,
+	>,
+}
+
+/// Helpers for setting up trimming tests.
+///
+/// Assignments are pre-sorted in reverse order of stake.
+pub fn trim_helpers() -> TrimHelpers {
+	let RoundSnapshot { voters, targets } = MultiPhase::snapshot().unwrap();
+	let stakes: std::collections::HashMap<_, _> =
+		voters.iter().map(|(id, stake, _)| (*id, *stake)).collect();
+
+	// Compute the size of a solution comprised of the selected arguments.
+	//
+	// This function completes in `O(edges)`; it's expensive, but linear.
+	let encoded_size_of = Box::new(|assignments: &[IndexAssignmentOf<Runtime>]| {
+		SolutionOf::<Runtime>::try_from(assignments).map(|s| s.encoded_size())
+	});
+	let cache = helpers::generate_voter_cache::<Runtime>(&voters);
+	let voter_index = helpers::voter_index_fn_owned::<Runtime>(cache);
+	let target_index = helpers::target_index_fn::<Runtime>(&targets);
+
+	let desired_targets = MultiPhase::desired_targets().unwrap();
+
+	let ElectionResult::<_, SolutionAccuracyOf<Runtime>> { mut assignments, .. } =
+		seq_phragmen(desired_targets as usize, targets.clone(), voters.clone(), None).unwrap();
+
+	// sort by decreasing order of stake
+	assignments.sort_by_key(|assignment| {
+		std::cmp::Reverse(stakes.get(&assignment.who).cloned().unwrap_or_default())
+	});
+
+	// convert to IndexAssignment
+	let assignments = assignments
+		.iter()
+		.map(|assignment| {
+			IndexAssignmentOf::<Runtime>::new(assignment, &voter_index, &target_index)
+		})
+		.collect::<Result<Vec<_>, _>>()
+		.expect("test assignments don't contain any voters with too many votes");
+
+	TrimHelpers { voters, assignments, encoded_size_of, voter_index: Box::new(voter_index) }
+}
+
+/// Spit out a verifiable raw solution.
+///
+/// This is a good example of what an offchain miner would do.
+pub fn raw_solution() -> RawSolution<SolutionOf<Runtime>> {
+	let RoundSnapshot { voters, targets } = MultiPhase::snapshot().unwrap();
+	let desired_targets = MultiPhase::desired_targets().unwrap();
+
+	let ElectionResult::<_, SolutionAccuracyOf<Runtime>> { winners: _, assignments } =
+		seq_phragmen(desired_targets as usize, targets.clone(), voters.clone(), None).unwrap();
+
+	// closures
+	let cache = helpers::generate_voter_cache::<Runtime>(&voters);
+	let voter_index = helpers::voter_index_fn_linear::<Runtime>(&voters);
+	let target_index = helpers::target_index_fn_linear::<Runtime>(&targets);
+	let stake_of = helpers::stake_of_fn::<Runtime>(&voters, &cache);
+
+	let score = {
+		let staked = assignment_ratio_to_staked_normalized(assignments.clone(), &stake_of).unwrap();
+		to_supports(&staked).evaluate()
+	};
+	let solution =
+		<SolutionOf<Runtime>>::from_assignment(&assignments, &voter_index, &target_index).unwrap();
+
+	let round = MultiPhase::round();
+	RawSolution { solution, score, round }
+}
+
+pub fn witness() -> SolutionOrSnapshotSize {
+	MultiPhase::snapshot()
+		.map(|snap| SolutionOrSnapshotSize {
+			voters: snap.voters.len() as u32,
+			targets: snap.targets.len() as u32,
+		})
+		.unwrap_or_default()
+}
+
+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 = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ();
+	type DbWeight = ();
+	type BlockLength = ();
+	type BlockWeights = BlockWeights;
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+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),
+			NORMAL_DISPATCH_RATIO,
+		);
+}
+
+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 MaxHolds = ();
+}
+
+#[derive(Default, Eq, PartialEq, Debug, Clone, Copy)]
+pub enum MockedWeightInfo {
+	#[default]
+	Basic,
+	Complex,
+	Real,
+}
+
+parameter_types! {
+	pub static Targets: Vec<AccountId> = vec![10, 20, 30, 40];
+	pub static Voters: Vec<VoterOf<Runtime>> = vec![
+		(1, 10, bounded_vec![10, 20]),
+		(2, 10, bounded_vec![30, 40]),
+		(3, 10, bounded_vec![40]),
+		(4, 10, bounded_vec![10, 20, 30, 40]),
+		// self votes.
+		(10, 10, bounded_vec![10]),
+		(20, 20, bounded_vec![20]),
+		(30, 30, bounded_vec![30]),
+		(40, 40, bounded_vec![40]),
+	];
+
+	pub static DesiredTargets: u32 = 2;
+	pub static SignedPhase: BlockNumber = 10;
+	pub static UnsignedPhase: BlockNumber = 5;
+	pub static SignedMaxSubmissions: u32 = 5;
+	pub static SignedMaxRefunds: u32 = 1;
+	pub static SignedDepositBase: Balance = 5;
+	pub static SignedDepositByte: Balance = 0;
+	pub static SignedDepositWeight: Balance = 0;
+	pub static SignedRewardBase: Balance = 7;
+	pub static SignedMaxWeight: Weight = BlockWeights::get().max_block;
+	pub static MinerTxPriority: u64 = 100;
+	pub static BetterSignedThreshold: Perbill = Perbill::zero();
+	pub static BetterUnsignedThreshold: Perbill = Perbill::zero();
+	pub static OffchainRepeat: BlockNumber = 5;
+	pub static MinerMaxWeight: Weight = BlockWeights::get().max_block;
+	pub static MinerMaxLength: u32 = 256;
+	pub static MockWeightInfo: MockedWeightInfo = MockedWeightInfo::Real;
+	pub static MaxElectingVoters: VoterIndex = u32::max_value();
+	pub static MaxElectableTargets: TargetIndex = TargetIndex::max_value();
+
+	#[derive(Debug)]
+	pub static MaxWinners: u32 = 200;
+	// `ElectionBounds` and `OnChainElectionsBounds` are defined separately to set them independently in the tests.
+	pub static ElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
+	pub static OnChainElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
+	pub static EpochLength: u64 = 30;
+	pub static OnChainFallback: bool = true;
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Runtime;
+	type Solver = SequentialPhragmen<AccountId, SolutionAccuracyOf<Runtime>, Balancing>;
+	type DataProvider = StakingMock;
+	type WeightInfo = ();
+	type MaxWinners = MaxWinners;
+	type Bounds = OnChainElectionsBounds;
+}
+
+pub struct MockFallback;
+impl ElectionProviderBase for MockFallback {
+	type BlockNumber = BlockNumber;
+	type AccountId = AccountId;
+	type Error = &'static str;
+	type DataProvider = StakingMock;
+	type MaxWinners = MaxWinners;
+}
+
+impl InstantElectionProvider for MockFallback {
+	fn instant_elect(
+		voters_bounds: DataProviderBounds,
+		targets_bounds: DataProviderBounds,
+	) -> Result<BoundedSupportsOf<Self>, Self::Error> {
+		if OnChainFallback::get() {
+			onchain::OnChainExecution::<OnChainSeqPhragmen>::instant_elect(
+				voters_bounds,
+				targets_bounds,
+			)
+			.map_err(|_| "onchain::OnChainExecution failed.")
+		} else {
+			Err("NoFallback.")
+		}
+	}
+}
+
+parameter_types! {
+	pub static Balancing: Option<BalancingConfig> = Some( BalancingConfig { iterations: 0, tolerance: 0 } );
+}
+
+pub struct TestBenchmarkingConfig;
+impl BenchmarkingConfig for TestBenchmarkingConfig {
+	const VOTERS: [u32; 2] = [400, 600];
+	const ACTIVE_VOTERS: [u32; 2] = [100, 300];
+	const TARGETS: [u32; 2] = [200, 400];
+	const DESIRED_TARGETS: [u32; 2] = [100, 180];
+
+	const SNAPSHOT_MAXIMUM_VOTERS: u32 = 1000;
+	const MINER_MAXIMUM_VOTERS: u32 = 1000;
+
+	const MAXIMUM_TARGETS: u32 = 200;
+}
+
+impl MinerConfig for Runtime {
+	type AccountId = AccountId;
+	type MaxLength = MinerMaxLength;
+	type MaxWeight = MinerMaxWeight;
+	type MaxVotesPerVoter = <StakingMock as ElectionDataProvider>::MaxVotesPerVoter;
+	type MaxWinners = MaxWinners;
+	type Solution = TestNposSolution;
+
+	fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight {
+		match MockWeightInfo::get() {
+			MockedWeightInfo::Basic => Weight::from_parts(
+				(10 as u64).saturating_add((5 as u64).saturating_mul(a as u64)),
+				0,
+			),
+			MockedWeightInfo::Complex =>
+				Weight::from_parts((0 * v + 0 * t + 1000 * a + 0 * d) as u64, 0),
+			MockedWeightInfo::Real =>
+				<() as multi_phase::weights::WeightInfo>::feasibility_check(v, t, a, d),
+		}
+	}
+}
+
+impl crate::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type EstimateCallFee = frame_support::traits::ConstU32<8>;
+	type SignedPhase = SignedPhase;
+	type UnsignedPhase = UnsignedPhase;
+	type BetterUnsignedThreshold = BetterUnsignedThreshold;
+	type BetterSignedThreshold = BetterSignedThreshold;
+	type OffchainRepeat = OffchainRepeat;
+	type MinerTxPriority = MinerTxPriority;
+	type SignedRewardBase = SignedRewardBase;
+	type SignedDepositBase = SignedDepositBase;
+	type SignedDepositByte = ();
+	type SignedDepositWeight = ();
+	type SignedMaxWeight = SignedMaxWeight;
+	type SignedMaxSubmissions = SignedMaxSubmissions;
+	type SignedMaxRefunds = SignedMaxRefunds;
+	type SlashHandler = ();
+	type RewardHandler = ();
+	type DataProvider = StakingMock;
+	type WeightInfo = ();
+	type BenchmarkingConfig = TestBenchmarkingConfig;
+	type Fallback = MockFallback;
+	type GovernanceFallback =
+		frame_election_provider_support::onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type ForceOrigin = frame_system::EnsureRoot<AccountId>;
+	type MaxWinners = MaxWinners;
+	type MinerConfig = Self;
+	type Solver = SequentialPhragmen<AccountId, SolutionAccuracyOf<Runtime>, Balancing>;
+	type ElectionBounds = ElectionsBounds;
+}
+
+impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Runtime
+where
+	RuntimeCall: From<LocalCall>,
+{
+	type OverarchingCall = RuntimeCall;
+	type Extrinsic = Extrinsic;
+}
+
+pub type Extrinsic = sp_runtime::testing::TestXt<RuntimeCall, ()>;
+
+parameter_types! {
+	pub MaxNominations: u32 = <TestNposSolution as NposSolution>::LIMIT as u32;
+	// only used in testing to manipulate mock behaviour
+	pub static DataProviderAllowBadData: bool = false;
+}
+
+#[derive(Default)]
+pub struct ExtBuilder {}
+
+pub struct StakingMock;
+impl ElectionDataProvider for StakingMock {
+	type BlockNumber = BlockNumber;
+	type AccountId = AccountId;
+	type MaxVotesPerVoter = MaxNominations;
+
+	fn electable_targets(bounds: DataProviderBounds) -> data_provider::Result<Vec<AccountId>> {
+		let targets = Targets::get();
+
+		if !DataProviderAllowBadData::get() &&
+			bounds.count.map_or(false, |max_len| targets.len() > max_len.0 as usize)
+		{
+			return Err("Targets too big")
+		}
+
+		Ok(targets)
+	}
+
+	fn electing_voters(bounds: DataProviderBounds) -> data_provider::Result<Vec<VoterOf<Runtime>>> {
+		let mut voters = Voters::get();
+
+		if !DataProviderAllowBadData::get() {
+			if let Some(max_len) = bounds.count {
+				voters.truncate(max_len.0 as usize)
+			}
+		}
+
+		Ok(voters)
+	}
+
+	fn desired_targets() -> data_provider::Result<u32> {
+		Ok(DesiredTargets::get())
+	}
+
+	fn next_election_prediction(now: u64) -> u64 {
+		now + EpochLength::get() - now % EpochLength::get()
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn put_snapshot(
+		voters: Vec<VoterOf<Runtime>>,
+		targets: Vec<AccountId>,
+		_target_stake: Option<VoteWeight>,
+	) {
+		Targets::set(targets);
+		Voters::set(voters);
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn clear() {
+		Targets::set(vec![]);
+		Voters::set(vec![]);
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add_voter(
+		voter: AccountId,
+		weight: VoteWeight,
+		targets: frame_support::BoundedVec<AccountId, Self::MaxVotesPerVoter>,
+	) {
+		let mut current = Voters::get();
+		current.push((voter, weight, targets));
+		Voters::set(current);
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add_target(target: AccountId) {
+		let mut current = Targets::get();
+		current.push(target);
+		Targets::set(current);
+	}
+}
+
+impl ExtBuilder {
+	pub fn miner_tx_priority(self, p: u64) -> Self {
+		<MinerTxPriority>::set(p);
+		self
+	}
+	pub fn better_signed_threshold(self, p: Perbill) -> Self {
+		<BetterSignedThreshold>::set(p);
+		self
+	}
+	pub fn better_unsigned_threshold(self, p: Perbill) -> Self {
+		<BetterUnsignedThreshold>::set(p);
+		self
+	}
+	pub fn phases(self, signed: BlockNumber, unsigned: BlockNumber) -> Self {
+		<SignedPhase>::set(signed);
+		<UnsignedPhase>::set(unsigned);
+		self
+	}
+	pub fn onchain_fallback(self, onchain: bool) -> Self {
+		<OnChainFallback>::set(onchain);
+		self
+	}
+	pub fn miner_weight(self, weight: Weight) -> Self {
+		<MinerMaxWeight>::set(weight);
+		self
+	}
+	pub fn mock_weight_info(self, mock: MockedWeightInfo) -> Self {
+		<MockWeightInfo>::set(mock);
+		self
+	}
+	pub fn desired_targets(self, t: u32) -> Self {
+		<DesiredTargets>::set(t);
+		self
+	}
+	pub fn add_voter(
+		self,
+		who: AccountId,
+		stake: Balance,
+		targets: BoundedVec<AccountId, MaxNominations>,
+	) -> Self {
+		VOTERS.with(|v| v.borrow_mut().push((who, stake, targets)));
+		self
+	}
+	pub fn signed_max_submission(self, count: u32) -> Self {
+		<SignedMaxSubmissions>::set(count);
+		self
+	}
+	pub fn signed_deposit(self, base: u64, byte: u64, weight: u64) -> Self {
+		<SignedDepositBase>::set(base);
+		<SignedDepositByte>::set(byte);
+		<SignedDepositWeight>::set(weight);
+		self
+	}
+	pub fn signed_weight(self, weight: Weight) -> Self {
+		<SignedMaxWeight>::set(weight);
+		self
+	}
+	pub fn build(self) -> sp_io::TestExternalities {
+		sp_tracing::try_init_simple();
+		let mut storage =
+			frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+		let _ = pallet_balances::GenesisConfig::<Runtime> {
+			balances: vec![
+				// bunch of account for submitting stuff only.
+				(99, 100),
+				(100, 100),
+				(101, 100),
+				(102, 100),
+				(103, 100),
+				(104, 100),
+				(105, 100),
+				(999, 100),
+				(9999, 100),
+			],
+		}
+		.assimilate_storage(&mut storage);
+
+		sp_io::TestExternalities::from(storage)
+	}
+
+	pub fn build_offchainify(
+		self,
+		iters: u32,
+	) -> (sp_io::TestExternalities, Arc<RwLock<PoolState>>) {
+		let mut ext = self.build();
+		let (offchain, offchain_state) = TestOffchainExt::new();
+		let (pool, pool_state) = TestTransactionPoolExt::new();
+
+		let mut seed = [0_u8; 32];
+		seed[0..4].copy_from_slice(&iters.to_le_bytes());
+		offchain_state.write().seed = seed;
+
+		ext.register_extension(OffchainDbExt::new(offchain.clone()));
+		ext.register_extension(OffchainWorkerExt::new(offchain));
+		ext.register_extension(TransactionPoolExt::new(pool));
+
+		(ext, pool_state)
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		sp_tracing::try_init_simple();
+
+		let mut ext = self.build();
+		ext.execute_with(test);
+
+		#[cfg(feature = "try-runtime")]
+		ext.execute_with(|| {
+			assert_ok!(<MultiPhase as frame_support::traits::Hooks<u64>>::try_state(
+				System::block_number()
+			));
+		});
+	}
+}
+
+pub(crate) fn balances(who: &AccountId) -> (Balance, Balance) {
+	(Balances::free_balance(who), Balances::reserved_balance(who))
+}
diff --git a/substrate/frame/election-provider-multi-phase/src/signed.rs b/substrate/frame/election-provider-multi-phase/src/signed.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76068ba99d36c97a9b1060cea4e3147e894da4dd
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/signed.rs
@@ -0,0 +1,1397 @@
+// 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.
+
+//! The signed phase implementation.
+
+use crate::{
+	unsigned::MinerConfig, Config, ElectionCompute, Pallet, QueuedSolution, RawSolution,
+	ReadySolution, SignedSubmissionIndices, SignedSubmissionNextIndex, SignedSubmissionsMap,
+	SolutionOf, SolutionOrSnapshotSize, Weight, WeightInfo,
+};
+use codec::{Decode, Encode, HasCompact};
+use frame_election_provider_support::NposSolution;
+use frame_support::traits::{
+	defensive_prelude::*, Currency, Get, OnUnbalanced, ReservableCurrency,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_arithmetic::traits::SaturatedConversion;
+use sp_core::bounded::BoundedVec;
+use sp_npos_elections::ElectionScore;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	RuntimeDebug,
+};
+use sp_std::{
+	cmp::Ordering,
+	collections::{btree_map::BTreeMap, btree_set::BTreeSet},
+	vec::Vec,
+};
+
+/// A raw, unchecked signed submission.
+///
+/// This is just a wrapper around [`RawSolution`] and some additional info.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, scale_info::TypeInfo)]
+pub struct SignedSubmission<AccountId, Balance: HasCompact, Solution> {
+	/// Who submitted this solution.
+	pub who: AccountId,
+	/// The deposit reserved for storing this solution.
+	pub deposit: Balance,
+	/// The raw solution itself.
+	pub raw_solution: RawSolution<Solution>,
+	// The estimated fee `who` paid to submit the solution.
+	pub call_fee: Balance,
+}
+
+impl<AccountId, Balance, Solution> Ord for SignedSubmission<AccountId, Balance, Solution>
+where
+	AccountId: Ord,
+	Balance: Ord + HasCompact,
+	Solution: Ord,
+	RawSolution<Solution>: Ord,
+{
+	fn cmp(&self, other: &Self) -> Ordering {
+		self.raw_solution
+			.score
+			.cmp(&other.raw_solution.score)
+			.then_with(|| self.raw_solution.cmp(&other.raw_solution))
+			.then_with(|| self.deposit.cmp(&other.deposit))
+			.then_with(|| self.who.cmp(&other.who))
+	}
+}
+
+impl<AccountId, Balance, Solution> PartialOrd for SignedSubmission<AccountId, Balance, Solution>
+where
+	AccountId: Ord,
+	Balance: Ord + HasCompact,
+	Solution: Ord,
+	RawSolution<Solution>: Ord,
+{
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+pub type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+pub type PositiveImbalanceOf<T> = <<T as Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::PositiveImbalance;
+pub type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+pub type SignedSubmissionOf<T> = SignedSubmission<
+	<T as frame_system::Config>::AccountId,
+	BalanceOf<T>,
+	<<T as crate::Config>::MinerConfig as MinerConfig>::Solution,
+>;
+
+/// Always sorted vector of a score, submitted at the given block number, which can be found at the
+/// given index (`u32`) of the `SignedSubmissionsMap`.
+pub type SubmissionIndicesOf<T> =
+	BoundedVec<(ElectionScore, BlockNumberFor<T>, u32), <T as Config>::SignedMaxSubmissions>;
+
+/// Outcome of [`SignedSubmissions::insert`].
+pub enum InsertResult<T: Config> {
+	/// The submission was not inserted because the queue was full and the submission had
+	/// insufficient score to eject a prior solution from the queue.
+	NotInserted,
+	/// The submission was inserted successfully without ejecting a solution.
+	Inserted,
+	/// The submission was inserted successfully. As the queue was full, this operation ejected a
+	/// prior solution, contained in this variant.
+	InsertedEjecting(SignedSubmissionOf<T>),
+}
+
+/// Mask type which pretends to be a set of `SignedSubmissionOf<T>`, while in fact delegating to the
+/// actual implementations in `SignedSubmissionIndices<T>`, `SignedSubmissionsMap<T>`, and
+/// `SignedSubmissionNextIndex<T>`.
+#[cfg_attr(feature = "std", derive(frame_support::DebugNoBound))]
+pub struct SignedSubmissions<T: Config> {
+	indices: SubmissionIndicesOf<T>,
+	next_idx: u32,
+	insertion_overlay: BTreeMap<u32, SignedSubmissionOf<T>>,
+	deletion_overlay: BTreeSet<u32>,
+}
+
+impl<T: Config> SignedSubmissions<T> {
+	/// `true` if the structure is empty.
+	pub fn is_empty(&self) -> bool {
+		self.indices.is_empty()
+	}
+
+	/// Get the length of submitted solutions.
+	pub fn len(&self) -> usize {
+		self.indices.len()
+	}
+
+	/// Get the signed submissions from storage.
+	pub fn get() -> Self {
+		let submissions = SignedSubmissions {
+			indices: SignedSubmissionIndices::<T>::get(),
+			next_idx: SignedSubmissionNextIndex::<T>::get(),
+			insertion_overlay: BTreeMap::new(),
+			deletion_overlay: BTreeSet::new(),
+		};
+
+		// validate that the stored state is sane
+		debug_assert!(submissions
+			.indices
+			.iter()
+			.map(|(_, _, index)| index)
+			.copied()
+			.max()
+			.map_or(true, |max_idx| submissions.next_idx > max_idx,));
+		submissions
+	}
+
+	/// Put the signed submissions back into storage.
+	pub fn put(mut self) {
+		// validate that we're going to write only sane things to storage
+		debug_assert!(self
+			.insertion_overlay
+			.keys()
+			.copied()
+			.max()
+			.map_or(true, |max_idx| self.next_idx > max_idx,));
+		debug_assert!(self
+			.indices
+			.iter()
+			.map(|(_, _, index)| index)
+			.copied()
+			.max()
+			.map_or(true, |max_idx| self.next_idx > max_idx,));
+
+		SignedSubmissionIndices::<T>::put(self.indices);
+		SignedSubmissionNextIndex::<T>::put(self.next_idx);
+		for key in self.deletion_overlay {
+			self.insertion_overlay.remove(&key);
+			SignedSubmissionsMap::<T>::remove(key);
+		}
+		for (key, value) in self.insertion_overlay {
+			SignedSubmissionsMap::<T>::insert(key, value);
+		}
+	}
+
+	/// Get the submission at a particular index.
+	fn get_submission(&self, index: u32) -> Option<SignedSubmissionOf<T>> {
+		if self.deletion_overlay.contains(&index) {
+			// Note: can't actually remove the item from the insertion overlay (if present) because
+			// we don't want to use `&mut self` here. There may be some kind of `RefCell`
+			// optimization possible here in the future.
+			None
+		} else {
+			self.insertion_overlay
+				.get(&index)
+				.cloned()
+				.or_else(|| SignedSubmissionsMap::<T>::get(index))
+		}
+	}
+
+	/// Perform three operations:
+	///
+	/// - Remove the solution at the given position of `self.indices`.
+	/// - Insert a new submission (identified by score and insertion index), if provided.
+	/// - Return the submission which was removed, if any.
+	///
+	/// The call site must ensure that `remove_pos` is a valid index. If otherwise, `None` is
+	/// silently returned.
+	///
+	/// Note: this doesn't insert into `insertion_overlay`, the optional new insertion must be
+	/// inserted into `insertion_overlay` to keep the variable `self` in a valid state.
+	fn swap_out_submission(
+		&mut self,
+		remove_pos: usize,
+		insert: Option<(ElectionScore, BlockNumberFor<T>, u32)>,
+	) -> Option<SignedSubmissionOf<T>> {
+		if remove_pos >= self.indices.len() {
+			return None
+		}
+
+		// safe: index was just checked in the line above.
+		let (_, _, remove_index) = self.indices.remove(remove_pos);
+
+		if let Some((insert_score, block_number, insert_idx)) = insert {
+			self.indices
+				.try_push((insert_score, block_number, insert_idx))
+				.expect("just removed an item, we must be under capacity; qed");
+		}
+
+		self.insertion_overlay.remove(&remove_index).or_else(|| {
+			(!self.deletion_overlay.contains(&remove_index))
+				.then(|| {
+					self.deletion_overlay.insert(remove_index);
+					SignedSubmissionsMap::<T>::get(remove_index)
+				})
+				.flatten()
+		})
+	}
+
+	/// Remove the signed submission with the highest score from the set.
+	pub fn pop_last(&mut self) -> Option<SignedSubmissionOf<T>> {
+		let best_index = self.indices.len().checked_sub(1)?;
+		self.swap_out_submission(best_index, None)
+	}
+
+	/// Iterate through the set of signed submissions in order of increasing score.
+	pub fn iter(&self) -> impl '_ + Iterator<Item = SignedSubmissionOf<T>> {
+		self.indices
+			.iter()
+			.filter_map(move |(_score, _bn, idx)| self.get_submission(*idx).defensive())
+	}
+
+	/// Empty the set of signed submissions, returning an iterator of signed submissions in
+	/// order of submission.
+	///
+	/// Note that if the iterator is dropped without consuming all elements, not all may be removed
+	/// from the underlying `SignedSubmissionsMap`, putting the storages into an invalid state.
+	///
+	/// Note that, like `put`, this function consumes `Self` and modifies storage.
+	fn drain_submitted_order(mut self) -> impl Iterator<Item = SignedSubmissionOf<T>> {
+		let mut keys = SignedSubmissionsMap::<T>::iter_keys()
+			.filter(|k| {
+				if self.deletion_overlay.contains(k) {
+					// Remove submissions that should be deleted.
+					SignedSubmissionsMap::<T>::remove(k);
+					false
+				} else {
+					true
+				}
+			})
+			.chain(self.insertion_overlay.keys().copied())
+			.collect::<Vec<_>>();
+		keys.sort();
+
+		SignedSubmissionIndices::<T>::kill();
+		SignedSubmissionNextIndex::<T>::kill();
+
+		keys.into_iter().filter_map(move |index| {
+			SignedSubmissionsMap::<T>::take(index).or_else(|| self.insertion_overlay.remove(&index))
+		})
+	}
+
+	/// Decode the length of the signed submissions without actually reading the entire struct into
+	/// memory.
+	///
+	/// Note that if you hold an instance of `SignedSubmissions`, this function does _not_
+	/// track its current length. This only decodes what is currently stored in memory.
+	pub fn decode_len() -> Option<usize> {
+		SignedSubmissionIndices::<T>::decode_len()
+	}
+
+	/// Insert a new signed submission into the set.
+	///
+	/// In the event that the new submission is not better than the current weakest according
+	/// to `is_score_better`, we do not change anything.
+	pub fn insert(&mut self, submission: SignedSubmissionOf<T>) -> InsertResult<T> {
+		// verify the expectation that we never reuse an index
+		debug_assert!(!self.indices.iter().map(|(_, _, x)| x).any(|&idx| idx == self.next_idx));
+		let block_number = frame_system::Pallet::<T>::block_number();
+
+		let maybe_weakest = match self.indices.try_push((
+			submission.raw_solution.score,
+			block_number,
+			self.next_idx,
+		)) {
+			Ok(_) => None,
+			Err(_) => {
+				// the queue is full -- if this is better, insert it.
+				let weakest_score = match self.indices.iter().next().defensive() {
+					None => return InsertResult::NotInserted,
+					Some((score, _, _)) => *score,
+				};
+				let threshold = T::BetterSignedThreshold::get();
+
+				// if we haven't improved on the weakest score, don't change anything.
+				if !submission.raw_solution.score.strict_threshold_better(weakest_score, threshold)
+				{
+					return InsertResult::NotInserted
+				}
+
+				self.swap_out_submission(
+					0, // swap out the worse one, which is always index 0.
+					Some((submission.raw_solution.score, block_number, self.next_idx)),
+				)
+			},
+		};
+
+		// this is the ONLY place that we insert, and we sort post insertion. If scores are the
+		// same, we sort based on reverse of submission block number.
+		self.indices
+			.sort_by(|(score1, bn1, _), (score2, bn2, _)| match score1.cmp(score2) {
+				Ordering::Equal => bn1.cmp(&bn2).reverse(),
+				x => x,
+			});
+
+		// we've taken out the weakest, so update the storage map and the next index
+		debug_assert!(!self.insertion_overlay.contains_key(&self.next_idx));
+		self.insertion_overlay.insert(self.next_idx, submission);
+		debug_assert!(!self.deletion_overlay.contains(&self.next_idx));
+		self.next_idx += 1;
+		match maybe_weakest {
+			Some(weakest) => InsertResult::InsertedEjecting(weakest),
+			None => InsertResult::Inserted,
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// `Self` accessor for `SignedSubmission<T>`.
+	pub fn signed_submissions() -> SignedSubmissions<T> {
+		SignedSubmissions::<T>::get()
+	}
+
+	/// Finish the signed phase. Process the signed submissions from best to worse until a valid one
+	/// is found, rewarding the best one and slashing the invalid ones along the way.
+	///
+	/// Returns true if we have a good solution in the signed phase.
+	///
+	/// This drains the [`SignedSubmissions`], potentially storing the best valid one in
+	/// [`QueuedSolution`].
+	///
+	/// This is a *self-weighing* function, it automatically registers its weight internally when
+	/// being called.
+	pub fn finalize_signed_phase() -> bool {
+		let (weight, found_solution) = Self::finalize_signed_phase_internal();
+		Self::register_weight(weight);
+		found_solution
+	}
+
+	/// The guts of [`finalized_signed_phase`], that does everything except registering its weight.
+	pub(crate) fn finalize_signed_phase_internal() -> (Weight, bool) {
+		let mut all_submissions = Self::signed_submissions();
+		let mut found_solution = false;
+		let mut weight = T::DbWeight::get().reads(1);
+
+		let SolutionOrSnapshotSize { voters, targets } =
+			Self::snapshot_metadata().unwrap_or_default();
+
+		while let Some(best) = all_submissions.pop_last() {
+			log!(
+				debug,
+				"finalized_signed: trying to verify from {:?} score {:?}",
+				best.who,
+				best.raw_solution.score
+			);
+			let SignedSubmission { raw_solution, who, deposit, call_fee } = best;
+			let active_voters = raw_solution.solution.voter_count() as u32;
+			let feasibility_weight = {
+				// defensive only: at the end of signed phase, snapshot will exits.
+				let desired_targets = Self::desired_targets().defensive_unwrap_or_default();
+				T::WeightInfo::feasibility_check(voters, targets, active_voters, desired_targets)
+			};
+
+			// the feasibility check itself has some weight
+			weight = weight.saturating_add(feasibility_weight);
+			match Self::feasibility_check(raw_solution, ElectionCompute::Signed) {
+				Ok(ready_solution) => {
+					Self::finalize_signed_phase_accept_solution(
+						ready_solution,
+						&who,
+						deposit,
+						call_fee,
+					);
+					found_solution = true;
+					log!(debug, "finalized_signed: found a valid solution");
+
+					weight = weight
+						.saturating_add(T::WeightInfo::finalize_signed_phase_accept_solution());
+					break
+				},
+				Err(_) => {
+					log!(warn, "finalized_signed: invalid signed submission found, slashing.");
+					Self::finalize_signed_phase_reject_solution(&who, deposit);
+					weight = weight
+						.saturating_add(T::WeightInfo::finalize_signed_phase_reject_solution());
+				},
+			}
+		}
+
+		// Any unprocessed solution is pointless to even consider. Feasible or malicious,
+		// they didn't end up being used. Unreserve the bonds.
+		let discarded = all_submissions.len();
+		let mut refund_count = 0;
+		let max_refunds = T::SignedMaxRefunds::get();
+
+		for SignedSubmission { who, deposit, call_fee, .. } in
+			all_submissions.drain_submitted_order()
+		{
+			if refund_count < max_refunds {
+				// Refund fee
+				let positive_imbalance = T::Currency::deposit_creating(&who, call_fee);
+				T::RewardHandler::on_unbalanced(positive_imbalance);
+				refund_count += 1;
+			}
+
+			// Unreserve deposit
+			let _remaining = T::Currency::unreserve(&who, deposit);
+			debug_assert!(_remaining.is_zero());
+			weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 2));
+		}
+
+		debug_assert!(!SignedSubmissionIndices::<T>::exists());
+		debug_assert!(!SignedSubmissionNextIndex::<T>::exists());
+		debug_assert!(SignedSubmissionsMap::<T>::iter().next().is_none());
+
+		log!(
+			debug,
+			"closed signed phase, found solution? {}, discarded {}",
+			found_solution,
+			discarded
+		);
+
+		(weight, found_solution)
+	}
+	/// Helper function for the case where a solution is accepted in the signed phase.
+	///
+	/// Extracted to facilitate with weight calculation.
+	///
+	/// Infallible
+	pub fn finalize_signed_phase_accept_solution(
+		ready_solution: ReadySolution<T::AccountId, T::MaxWinners>,
+		who: &T::AccountId,
+		deposit: BalanceOf<T>,
+		call_fee: BalanceOf<T>,
+	) {
+		// write this ready solution.
+		<QueuedSolution<T>>::put(ready_solution);
+
+		let reward = T::SignedRewardBase::get();
+		// emit reward event
+		Self::deposit_event(crate::Event::Rewarded { account: who.clone(), value: reward });
+
+		// Unreserve deposit.
+		let _remaining = T::Currency::unreserve(who, deposit);
+		debug_assert!(_remaining.is_zero());
+
+		// Reward and refund the call fee.
+		let positive_imbalance =
+			T::Currency::deposit_creating(who, reward.saturating_add(call_fee));
+		T::RewardHandler::on_unbalanced(positive_imbalance);
+	}
+
+	/// Helper function for the case where a solution is accepted in the rejected phase.
+	///
+	/// Extracted to facilitate with weight calculation.
+	///
+	/// Infallible
+	pub fn finalize_signed_phase_reject_solution(who: &T::AccountId, deposit: BalanceOf<T>) {
+		Self::deposit_event(crate::Event::Slashed { account: who.clone(), value: deposit });
+		let (negative_imbalance, _remaining) = T::Currency::slash_reserved(who, deposit);
+		debug_assert!(_remaining.is_zero());
+		T::SlashHandler::on_unbalanced(negative_imbalance);
+	}
+
+	/// The weight of the given raw solution.
+	pub fn solution_weight_of(
+		raw_solution: &RawSolution<SolutionOf<T::MinerConfig>>,
+		size: SolutionOrSnapshotSize,
+	) -> Weight {
+		T::MinerConfig::solution_weight(
+			size.voters,
+			size.targets,
+			raw_solution.solution.voter_count() as u32,
+			raw_solution.solution.unique_targets().len() as u32,
+		)
+	}
+
+	/// Collect a sufficient deposit to store this solution.
+	///
+	/// The deposit is composed of 3 main elements:
+	///
+	/// 1. base deposit, fixed for all submissions.
+	/// 2. a per-byte deposit, for renting the state usage.
+	/// 3. a per-weight deposit, for the potential weight usage in an upcoming on_initialize
+	pub fn deposit_for(
+		raw_solution: &RawSolution<SolutionOf<T::MinerConfig>>,
+		size: SolutionOrSnapshotSize,
+	) -> BalanceOf<T> {
+		let encoded_len: u32 = raw_solution.encoded_size().saturated_into();
+		let encoded_len: BalanceOf<T> = encoded_len.into();
+		let feasibility_weight = Self::solution_weight_of(raw_solution, size);
+
+		let len_deposit = T::SignedDepositByte::get().saturating_mul(encoded_len);
+		let weight_deposit = T::SignedDepositWeight::get()
+			.saturating_mul(feasibility_weight.ref_time().saturated_into());
+
+		T::SignedDepositBase::get()
+			.saturating_add(len_deposit)
+			.saturating_add(weight_deposit)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		mock::*, ElectionBoundsBuilder, ElectionCompute, ElectionError, Error, Event, Perbill,
+		Phase,
+	};
+	use frame_support::{assert_noop, assert_ok, assert_storage_noop};
+
+	#[test]
+	fn cannot_submit_too_early() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to(2);
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+
+			// create a temp snapshot only for this test.
+			MultiPhase::create_snapshot().unwrap();
+			let solution = raw_solution();
+
+			assert_noop!(
+				MultiPhase::submit(RuntimeOrigin::signed(10), Box::new(solution)),
+				Error::<Runtime>::PreDispatchEarlySubmission,
+			);
+
+			// make sure invariants hold true and post-test try state checks to pass.
+			<crate::Snapshot<Runtime>>::kill();
+			<crate::SnapshotMetadata<Runtime>>::kill();
+			<crate::DesiredTargets<Runtime>>::kill();
+		})
+	}
+
+	#[test]
+	fn data_provider_should_respect_target_limits() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given a reduced expectation of maximum electable targets
+			let new_bounds = ElectionBoundsBuilder::default().targets_count(2.into()).build();
+			ElectionsBounds::set(new_bounds);
+			// and a data provider that does not respect limits
+			DataProviderAllowBadData::set(true);
+
+			assert_noop!(
+				MultiPhase::create_snapshot(),
+				ElectionError::DataProvider("Ensure targets bounds: bounds exceeded."),
+			);
+		})
+	}
+
+	#[test]
+	fn data_provider_should_respect_voter_limits() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given a reduced expectation of maximum electing voters
+			let new_bounds = ElectionBoundsBuilder::default().voters_count(2.into()).build();
+			ElectionsBounds::set(new_bounds);
+			// and a data provider that does not respect limits
+			DataProviderAllowBadData::set(true);
+
+			assert_noop!(
+				MultiPhase::create_snapshot(),
+				ElectionError::DataProvider("Ensure voters bounds: bounds exceeded."),
+			);
+		})
+	}
+
+	#[test]
+	fn desired_targets_greater_than_max_winners() {
+		ExtBuilder::default().build_and_execute(|| {
+			// given desired_targets bigger than MaxWinners
+			DesiredTargets::set(4);
+			MaxWinners::set(3);
+
+			// snapshot not created because data provider returned an unexpected number of
+			// desired_targets
+			assert_noop!(
+				MultiPhase::create_snapshot_external(),
+				ElectionError::DataProvider("desired_targets must not be greater than MaxWinners."),
+			);
+		})
+	}
+
+	#[test]
+	fn should_pay_deposit() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let solution = raw_solution();
+			assert_eq!(balances(&99), (100, 0));
+
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+
+			assert_eq!(balances(&99), (95, 5));
+			assert_eq!(MultiPhase::signed_submissions().iter().next().unwrap().deposit, 5);
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					}
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn good_solution_is_rewarded() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let solution = raw_solution();
+			assert_eq!(balances(&99), (100, 0));
+
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+			assert_eq!(balances(&99), (95, 5));
+
+			assert!(MultiPhase::finalize_signed_phase());
+			assert_eq!(balances(&99), (100 + 7 + 8, 0));
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::Rewarded { account: 99, value: 7 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn bad_solution_is_slashed() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut solution = raw_solution();
+			assert_eq!(balances(&99), (100, 0));
+
+			// make the solution invalid.
+			solution.score.minimal_stake += 1;
+
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+			assert_eq!(balances(&99), (95, 5));
+
+			// no good solution was stored.
+			assert!(!MultiPhase::finalize_signed_phase());
+			// and the bond is gone.
+			assert_eq!(balances(&99), (95, 0));
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::Slashed { account: 99, value: 5 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn suppressed_solution_gets_bond_back() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let mut solution = raw_solution();
+			assert_eq!(balances(&99), (100, 0));
+			assert_eq!(balances(&999), (100, 0));
+
+			// submit as correct.
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution.clone())));
+
+			// make the solution invalid and weaker.
+			solution.score.minimal_stake -= 1;
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(999), Box::new(solution)));
+			assert_eq!(balances(&99), (95, 5));
+			assert_eq!(balances(&999), (95, 5));
+
+			// _some_ good solution was stored.
+			assert!(MultiPhase::finalize_signed_phase());
+
+			// 99 is rewarded.
+			assert_eq!(balances(&99), (100 + 7 + 8, 0));
+			// 999 gets everything back, including the call fee.
+			assert_eq!(balances(&999), (100 + 8, 0));
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(999),
+						prev_ejected: false
+					},
+					Event::Rewarded { account: 99, value: 7 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn cannot_submit_worse_with_full_queue() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			for s in 0..SignedMaxSubmissions::get() {
+				// score is always getting better
+				let solution = RawSolution {
+					score: ElectionScore { minimal_stake: (5 + s).into(), ..Default::default() },
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+			}
+
+			// weaker.
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 4, ..Default::default() },
+				..Default::default()
+			};
+
+			assert_noop!(
+				MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)),
+				Error::<Runtime>::SignedQueueFull,
+			);
+		})
+	}
+
+	#[test]
+	fn call_fee_refund_is_limited_by_signed_max_refunds() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+			assert_eq!(SignedMaxRefunds::get(), 1);
+			assert!(SignedMaxSubmissions::get() > 2);
+
+			for s in 0..SignedMaxSubmissions::get() {
+				let account = 99 + s as u64;
+				Balances::make_free_balance_be(&account, 100);
+				// score is always decreasing
+				let mut solution = raw_solution();
+				solution.score.minimal_stake -= s as u128;
+
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(account), Box::new(solution)));
+				assert_eq!(balances(&account), (95, 5));
+			}
+
+			assert_ok!(MultiPhase::do_elect());
+
+			for s in 0..SignedMaxSubmissions::get() {
+				let account = 99 + s as u64;
+				// lower accounts have higher scores
+				if s == 0 {
+					// winning solution always gets call fee + reward
+					assert_eq!(balances(&account), (100 + 8 + 7, 0))
+				} else if s == 1 {
+					// 1 runner up gets their call fee refunded
+					assert_eq!(balances(&account), (100 + 8, 0))
+				} else {
+					// all other solutions don't get a call fee refund
+					assert_eq!(balances(&account), (100, 0));
+				}
+			}
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(100),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(101),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(102),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(103),
+						prev_ejected: false
+					},
+					Event::Rewarded { account: 99, value: 7 },
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Signed,
+						score: ElectionScore {
+							minimal_stake: 40,
+							sum_stake: 100,
+							sum_stake_squared: 5200
+						}
+					}
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn cannot_submit_worse_with_full_queue_depends_on_threshold() {
+		ExtBuilder::default()
+			.signed_max_submission(1)
+			.better_signed_threshold(Perbill::from_percent(20))
+			.build_and_execute(|| {
+				roll_to_signed();
+				assert!(MultiPhase::current_phase().is_signed());
+
+				let mut solution = RawSolution {
+					score: ElectionScore {
+						minimal_stake: 5u128,
+						sum_stake: 0u128,
+						sum_stake_squared: 10u128,
+					},
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+
+				// This is 10% better, so does not meet the 20% threshold and is therefore rejected.
+				solution = RawSolution {
+					score: ElectionScore {
+						minimal_stake: 5u128,
+						sum_stake: 0u128,
+						sum_stake_squared: 9u128,
+					},
+					..Default::default()
+				};
+
+				assert_noop!(
+					MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)),
+					Error::<Runtime>::SignedQueueFull,
+				);
+
+				// This is however 30% better and should therefore be accepted.
+				solution = RawSolution {
+					score: ElectionScore {
+						minimal_stake: 5u128,
+						sum_stake: 0u128,
+						sum_stake_squared: 7u128,
+					},
+					..Default::default()
+				};
+
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+				assert_eq!(
+					multi_phase_events(),
+					vec![
+						Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+						Event::SolutionStored {
+							compute: ElectionCompute::Signed,
+							origin: Some(99),
+							prev_ejected: false
+						},
+						Event::SolutionStored {
+							compute: ElectionCompute::Signed,
+							origin: Some(99),
+							prev_ejected: true
+						}
+					]
+				);
+			})
+	}
+
+	#[test]
+	fn weakest_is_removed_if_better_provided() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			for s in 0..SignedMaxSubmissions::get() {
+				let account = 99 + s as u64;
+				Balances::make_free_balance_be(&account, 100);
+				// score is always getting better
+				let solution = RawSolution {
+					score: ElectionScore { minimal_stake: (5 + s).into(), ..Default::default() },
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(account), Box::new(solution)));
+				assert_eq!(balances(&account), (95, 5));
+			}
+
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| s.raw_solution.score.minimal_stake)
+					.collect::<Vec<_>>(),
+				vec![5, 6, 7, 8, 9]
+			);
+
+			// better.
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 20, ..Default::default() },
+				..Default::default()
+			};
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(999), Box::new(solution)));
+
+			// the one with score 5 was rejected, the new one inserted.
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| s.raw_solution.score.minimal_stake)
+					.collect::<Vec<_>>(),
+				vec![6, 7, 8, 9, 20]
+			);
+
+			// the submitter of the ejected solution does *not* get a call fee refund
+			assert_eq!(balances(&(99 + 0)), (100, 0));
+		})
+	}
+
+	#[test]
+	fn replace_weakest_by_score_works() {
+		ExtBuilder::default().signed_max_submission(3).build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			for s in 1..SignedMaxSubmissions::get() {
+				// score is always getting better
+				let solution = RawSolution {
+					score: ElectionScore { minimal_stake: (5 + s).into(), ..Default::default() },
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+			}
+
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 4, ..Default::default() },
+				..Default::default()
+			};
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| s.raw_solution.score.minimal_stake)
+					.collect::<Vec<_>>(),
+				vec![4, 6, 7],
+			);
+
+			// better.
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+
+			// the one with score 5 was rejected, the new one inserted.
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| s.raw_solution.score.minimal_stake)
+					.collect::<Vec<_>>(),
+				vec![5, 6, 7],
+			);
+		})
+	}
+
+	#[test]
+	fn early_ejected_solution_gets_bond_back() {
+		ExtBuilder::default().signed_deposit(2, 0, 0).build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			for s in 0..SignedMaxSubmissions::get() {
+				// score is always getting better
+				let solution = RawSolution {
+					score: ElectionScore { minimal_stake: (5 + s).into(), ..Default::default() },
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+			}
+
+			assert_eq!(balances(&99).1, 2 * 5);
+			assert_eq!(balances(&999).1, 0);
+
+			// better.
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 20, ..Default::default() },
+				..Default::default()
+			};
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(999), Box::new(solution)));
+
+			// got one bond back.
+			assert_eq!(balances(&99).1, 2 * 4);
+			assert_eq!(balances(&999).1, 2);
+		})
+	}
+
+	#[test]
+	fn equally_good_solution_is_not_accepted_when_queue_full() {
+		// because in ordering of solutions, an older solution has higher priority and should stay.
+		ExtBuilder::default().signed_max_submission(3).build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			for i in 0..SignedMaxSubmissions::get() {
+				let solution = RawSolution {
+					score: ElectionScore { minimal_stake: (5 + i).into(), ..Default::default() },
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+			}
+
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| s.raw_solution.score.minimal_stake)
+					.collect::<Vec<_>>(),
+				vec![5, 6, 7]
+			);
+
+			// 5 is not accepted. This will only cause processing with no benefit.
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			assert_noop!(
+				MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)),
+				Error::<Runtime>::SignedQueueFull,
+			);
+		})
+	}
+
+	#[test]
+	fn equally_good_solution_is_accepted_when_queue_not_full() {
+		// because in ordering of solutions, an older solution has higher priority and should stay.
+		ExtBuilder::default().signed_max_submission(3).build_and_execute(|| {
+			roll_to(15);
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| (s.who, s.raw_solution.score.minimal_stake,))
+					.collect::<Vec<_>>(),
+				vec![(99, 5)]
+			);
+
+			roll_to(16);
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(999), Box::new(solution)));
+
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| (s.who, s.raw_solution.score.minimal_stake,))
+					.collect::<Vec<_>>(),
+				vec![(999, 5), (99, 5)]
+			);
+
+			let solution = RawSolution {
+				score: ElectionScore { minimal_stake: 6, ..Default::default() },
+				..Default::default()
+			};
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(9999), Box::new(solution)));
+
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| (s.who, s.raw_solution.score.minimal_stake,))
+					.collect::<Vec<_>>(),
+				vec![(999, 5), (99, 5), (9999, 6)]
+			);
+		})
+	}
+
+	#[test]
+	fn all_equal_score() {
+		// because in ordering of solutions, an older solution has higher priority and should stay.
+		ExtBuilder::default().signed_max_submission(3).build_and_execute(|| {
+			roll_to(15);
+			assert!(MultiPhase::current_phase().is_signed());
+
+			for i in 0..SignedMaxSubmissions::get() {
+				roll_to((15 + i).into());
+				let solution = raw_solution();
+				assert_ok!(MultiPhase::submit(
+					RuntimeOrigin::signed(100 + i as AccountId),
+					Box::new(solution)
+				));
+			}
+
+			assert_eq!(
+				MultiPhase::signed_submissions()
+					.iter()
+					.map(|s| (s.who, s.raw_solution.score.minimal_stake))
+					.collect::<Vec<_>>(),
+				vec![(102, 40), (101, 40), (100, 40)]
+			);
+
+			roll_to(25);
+
+			// The first one that will actually get verified is the last one.
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(100),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(101),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(102),
+						prev_ejected: false
+					},
+					Event::Rewarded { account: 100, value: 7 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn all_in_one_signed_submission_scenario() {
+		// a combination of:
+		// - good_solution_is_rewarded
+		// - bad_solution_is_slashed
+		// - suppressed_solution_gets_bond_back
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			assert_eq!(balances(&99), (100, 0));
+			assert_eq!(balances(&999), (100, 0));
+			assert_eq!(balances(&9999), (100, 0));
+
+			let solution = raw_solution();
+
+			// submit a correct one.
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution.clone())));
+
+			// make the solution invalidly better and submit. This ought to be slashed.
+			let mut solution_999 = solution.clone();
+			solution_999.score.minimal_stake += 1;
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(999), Box::new(solution_999)));
+
+			// make the solution invalidly worse and submit. This ought to be suppressed and
+			// returned.
+			let mut solution_9999 = solution.clone();
+			solution_9999.score.minimal_stake -= 1;
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(9999), Box::new(solution_9999)));
+
+			assert_eq!(
+				MultiPhase::signed_submissions().iter().map(|x| x.who).collect::<Vec<_>>(),
+				vec![9999, 99, 999]
+			);
+
+			// _some_ good solution was stored.
+			assert!(MultiPhase::finalize_signed_phase());
+
+			// 99 is rewarded.
+			assert_eq!(balances(&99), (100 + 7 + 8, 0));
+			// 999 is slashed.
+			assert_eq!(balances(&999), (95, 0));
+			// 9999 gets everything back, including the call fee.
+			assert_eq!(balances(&9999), (100 + 8, 0));
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(999),
+						prev_ejected: false
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(9999),
+						prev_ejected: false
+					},
+					Event::Slashed { account: 999, value: 5 },
+					Event::Rewarded { account: 99, value: 7 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn cannot_consume_too_much_future_weight() {
+		ExtBuilder::default()
+			.signed_weight(Weight::from_parts(40, u64::MAX))
+			.mock_weight_info(MockedWeightInfo::Basic)
+			.build_and_execute(|| {
+				roll_to_signed();
+				assert!(MultiPhase::current_phase().is_signed());
+
+				let (raw, witness) = MultiPhase::mine_solution().unwrap();
+				let solution_weight = <Runtime as MinerConfig>::solution_weight(
+					witness.voters,
+					witness.targets,
+					raw.solution.voter_count() as u32,
+					raw.solution.unique_targets().len() as u32,
+				);
+				// default solution will have 5 edges (5 * 5 + 10)
+				assert_eq!(solution_weight, Weight::from_parts(35, 0));
+				assert_eq!(raw.solution.voter_count(), 5);
+				assert_eq!(
+					<Runtime as Config>::SignedMaxWeight::get(),
+					Weight::from_parts(40, u64::MAX)
+				);
+
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(raw.clone())));
+
+				<SignedMaxWeight>::set(Weight::from_parts(30, u64::MAX));
+
+				// note: resubmitting the same solution is technically okay as long as the queue has
+				// space.
+				assert_noop!(
+					MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(raw)),
+					Error::<Runtime>::SignedTooMuchWeight,
+				);
+			})
+	}
+
+	#[test]
+	fn insufficient_deposit_does_not_store_submission() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let solution = raw_solution();
+
+			assert_eq!(balances(&123), (0, 0));
+			assert_noop!(
+				MultiPhase::submit(RuntimeOrigin::signed(123), Box::new(solution)),
+				Error::<Runtime>::SignedCannotPayDeposit,
+			);
+
+			assert_eq!(balances(&123), (0, 0));
+		})
+	}
+
+	// given a full queue, and a solution which _should_ be allowed in, but the proposer of this
+	// new solution has insufficient deposit, we should not modify storage at all
+	#[test]
+	fn insufficient_deposit_with_full_queue_works_properly() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			for s in 0..SignedMaxSubmissions::get() {
+				// score is always getting better
+				let solution = RawSolution {
+					score: ElectionScore { minimal_stake: (5 + s).into(), ..Default::default() },
+					..Default::default()
+				};
+				assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+			}
+
+			// this solution has a higher score than any in the queue
+			let solution = RawSolution {
+				score: ElectionScore {
+					minimal_stake: (5 + SignedMaxSubmissions::get()).into(),
+					..Default::default()
+				},
+				..Default::default()
+			};
+
+			assert_eq!(balances(&123), (0, 0));
+			assert_noop!(
+				MultiPhase::submit(RuntimeOrigin::signed(123), Box::new(solution)),
+				Error::<Runtime>::SignedCannotPayDeposit,
+			);
+
+			assert_eq!(balances(&123), (0, 0));
+		})
+	}
+
+	#[test]
+	fn finalize_signed_phase_is_idempotent_given_no_submissions() {
+		ExtBuilder::default().build_and_execute(|| {
+			for block_number in 0..25 {
+				roll_to(block_number);
+
+				assert_eq!(SignedSubmissions::<Runtime>::decode_len().unwrap_or_default(), 0);
+				assert_storage_noop!(MultiPhase::finalize_signed_phase_internal());
+			}
+		})
+	}
+
+	#[test]
+	fn finalize_signed_phase_is_idempotent_given_submissions() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_signed();
+			assert!(MultiPhase::current_phase().is_signed());
+
+			let solution = raw_solution();
+
+			// submit a correct one.
+			assert_ok!(MultiPhase::submit(RuntimeOrigin::signed(99), Box::new(solution)));
+
+			// _some_ good solution was stored.
+			assert!(MultiPhase::finalize_signed_phase());
+
+			// calling it again doesn't change anything
+			assert_storage_noop!(MultiPhase::finalize_signed_phase());
+
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::SolutionStored {
+						compute: ElectionCompute::Signed,
+						origin: Some(99),
+						prev_ejected: false
+					},
+					Event::Rewarded { account: 99, value: 7 }
+				]
+			);
+		})
+	}
+}
diff --git a/substrate/frame/election-provider-multi-phase/src/unsigned.rs b/substrate/frame/election-provider-multi-phase/src/unsigned.rs
new file mode 100644
index 0000000000000000000000000000000000000000..af8f632f8a9e3322edb2a17180f29005a5b68d98
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/unsigned.rs
@@ -0,0 +1,1915 @@
+// 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.
+
+//! The unsigned phase, and its miner.
+
+use crate::{
+	helpers, Call, Config, ElectionCompute, Error, FeasibilityError, Pallet, RawSolution,
+	ReadySolution, RoundSnapshot, SolutionAccuracyOf, SolutionOf, SolutionOrSnapshotSize, Weight,
+};
+use codec::Encode;
+use frame_election_provider_support::{NposSolution, NposSolver, PerThing128, VoteWeight};
+use frame_support::{
+	dispatch::DispatchResult,
+	ensure,
+	traits::{DefensiveResult, Get},
+	BoundedVec,
+};
+use frame_system::{offchain::SubmitTransaction, pallet_prelude::BlockNumberFor};
+use scale_info::TypeInfo;
+use sp_npos_elections::{
+	assignment_ratio_to_staked_normalized, assignment_staked_to_ratio_normalized, ElectionResult,
+	ElectionScore, EvaluateSupport,
+};
+use sp_runtime::{
+	offchain::storage::{MutateStorageError, StorageValueRef},
+	DispatchError, SaturatedConversion,
+};
+use sp_std::prelude::*;
+
+/// Storage key used to store the last block number at which offchain worker ran.
+pub(crate) const OFFCHAIN_LAST_BLOCK: &[u8] = b"parity/multi-phase-unsigned-election";
+/// Storage key used to store the offchain worker running status.
+pub(crate) const OFFCHAIN_LOCK: &[u8] = b"parity/multi-phase-unsigned-election/lock";
+
+/// Storage key used to cache the solution `call`.
+pub(crate) const OFFCHAIN_CACHED_CALL: &[u8] = b"parity/multi-phase-unsigned-election/call";
+
+/// A voter's fundamental data: their ID, their stake, and the list of candidates for whom they
+/// voted.
+pub type VoterOf<T> = frame_election_provider_support::VoterOf<<T as Config>::DataProvider>;
+
+/// Same as [`VoterOf`], but parameterized by the `MinerConfig`.
+pub type MinerVoterOf<T> = frame_election_provider_support::Voter<
+	<T as MinerConfig>::AccountId,
+	<T as MinerConfig>::MaxVotesPerVoter,
+>;
+
+/// The relative distribution of a voter's stake among the winning targets.
+pub type Assignment<T> =
+	sp_npos_elections::Assignment<<T as frame_system::Config>::AccountId, SolutionAccuracyOf<T>>;
+
+/// The [`IndexAssignment`][frame_election_provider_support::IndexAssignment] type specialized for a
+/// particular runtime `T`.
+pub type IndexAssignmentOf<T> = frame_election_provider_support::IndexAssignmentOf<SolutionOf<T>>;
+
+/// Error type of the pallet's [`crate::Config::Solver`].
+pub type SolverErrorOf<T> = <<T as Config>::Solver as NposSolver>::Error;
+/// Error type for operations related to the OCW npos solution miner.
+#[derive(frame_support::DebugNoBound, frame_support::PartialEqNoBound)]
+pub enum MinerError {
+	/// An internal error in the NPoS elections crate.
+	NposElections(sp_npos_elections::Error),
+	/// Snapshot data was unavailable unexpectedly.
+	SnapshotUnAvailable,
+	/// Submitting a transaction to the pool failed.
+	PoolSubmissionFailed,
+	/// The pre-dispatch checks failed for the mined solution.
+	PreDispatchChecksFailed(DispatchError),
+	/// The solution generated from the miner is not feasible.
+	Feasibility(FeasibilityError),
+	/// Something went wrong fetching the lock.
+	Lock(&'static str),
+	/// Cannot restore a solution that was not stored.
+	NoStoredSolution,
+	/// Cached solution is not a `submit_unsigned` call.
+	SolutionCallInvalid,
+	/// Failed to store a solution.
+	FailedToStoreSolution,
+	/// There are no more voters to remove to trim the solution.
+	NoMoreVoters,
+	/// An error from the solver.
+	Solver,
+}
+
+impl From<sp_npos_elections::Error> for MinerError {
+	fn from(e: sp_npos_elections::Error) -> Self {
+		MinerError::NposElections(e)
+	}
+}
+
+impl From<FeasibilityError> for MinerError {
+	fn from(e: FeasibilityError) -> Self {
+		MinerError::Feasibility(e)
+	}
+}
+
+/// Save a given call into OCW storage.
+fn save_solution<T: Config>(call: &Call<T>) -> Result<(), MinerError> {
+	log!(debug, "saving a call to the offchain storage.");
+	let storage = StorageValueRef::persistent(OFFCHAIN_CACHED_CALL);
+	match storage.mutate::<_, (), _>(|_| Ok(call.clone())) {
+		Ok(_) => Ok(()),
+		Err(MutateStorageError::ConcurrentModification(_)) =>
+			Err(MinerError::FailedToStoreSolution),
+		Err(MutateStorageError::ValueFunctionFailed(_)) => {
+			// this branch should be unreachable according to the definition of
+			// `StorageValueRef::mutate`: that function should only ever `Err` if the closure we
+			// pass it returns an error. however, for safety in case the definition changes, we do
+			// not optimize the branch away or panic.
+			Err(MinerError::FailedToStoreSolution)
+		},
+	}
+}
+
+/// Get a saved solution from OCW storage if it exists.
+fn restore_solution<T: Config>() -> Result<Call<T>, MinerError> {
+	StorageValueRef::persistent(OFFCHAIN_CACHED_CALL)
+		.get()
+		.ok()
+		.flatten()
+		.ok_or(MinerError::NoStoredSolution)
+}
+
+/// Clear a saved solution from OCW storage.
+pub(super) fn kill_ocw_solution<T: Config>() {
+	log!(debug, "clearing offchain call cache storage.");
+	let mut storage = StorageValueRef::persistent(OFFCHAIN_CACHED_CALL);
+	storage.clear();
+}
+
+/// Clear the offchain repeat storage.
+///
+/// After calling this, the next offchain worker is guaranteed to work, with respect to the
+/// frequency repeat.
+fn clear_offchain_repeat_frequency() {
+	let mut last_block = StorageValueRef::persistent(OFFCHAIN_LAST_BLOCK);
+	last_block.clear();
+}
+
+/// `true` when OCW storage contains a solution
+#[cfg(test)]
+fn ocw_solution_exists<T: Config>() -> bool {
+	matches!(StorageValueRef::persistent(OFFCHAIN_CACHED_CALL).get::<Call<T>>(), Ok(Some(_)))
+}
+
+impl<T: Config> Pallet<T> {
+	/// Mine a new npos solution.
+	///
+	/// The Npos Solver type, `S`, must have the same AccountId and Error type as the
+	/// [`crate::Config::Solver`] in order to create a unified return type.
+	pub fn mine_solution(
+	) -> Result<(RawSolution<SolutionOf<T::MinerConfig>>, SolutionOrSnapshotSize), MinerError> {
+		let RoundSnapshot { voters, targets } =
+			Self::snapshot().ok_or(MinerError::SnapshotUnAvailable)?;
+		let desired_targets = Self::desired_targets().ok_or(MinerError::SnapshotUnAvailable)?;
+		let (solution, score, size) = Miner::<T::MinerConfig>::mine_solution_with_snapshot::<
+			T::Solver,
+		>(voters, targets, desired_targets)?;
+		let round = Self::round();
+		Ok((RawSolution { solution, score, round }, size))
+	}
+
+	/// Attempt to restore a solution from cache. Otherwise, compute it fresh. Either way, submit
+	/// if our call's score is greater than that of the cached solution.
+	pub fn restore_or_compute_then_maybe_submit() -> Result<(), MinerError> {
+		log!(debug, "miner attempting to restore or compute an unsigned solution.");
+
+		let call = restore_solution::<T>()
+			.and_then(|call| {
+				// ensure the cached call is still current before submitting
+				if let Call::submit_unsigned { raw_solution, .. } = &call {
+					// prevent errors arising from state changes in a forkful chain
+					Self::basic_checks(raw_solution, "restored")?;
+					Ok(call)
+				} else {
+					Err(MinerError::SolutionCallInvalid)
+				}
+			})
+			.or_else::<MinerError, _>(|error| {
+				log!(debug, "restoring solution failed due to {:?}", error);
+				match error {
+					MinerError::NoStoredSolution => {
+						log!(trace, "mining a new solution.");
+						// if not present or cache invalidated due to feasibility, regenerate.
+						// note that failing `Feasibility` can only mean that the solution was
+						// computed over a snapshot that has changed due to a fork.
+						let call = Self::mine_checked_call()?;
+						save_solution(&call)?;
+						Ok(call)
+					},
+					MinerError::Feasibility(_) => {
+						log!(trace, "wiping infeasible solution.");
+						// kill the infeasible solution, hopefully in the next runs (whenever they
+						// may be) we mine a new one.
+						kill_ocw_solution::<T>();
+						clear_offchain_repeat_frequency();
+						Err(error)
+					},
+					_ => {
+						// nothing to do. Return the error as-is.
+						Err(error)
+					},
+				}
+			})?;
+
+		Self::submit_call(call)
+	}
+
+	/// Mine a new solution, cache it, and submit it back to the chain as an unsigned transaction.
+	pub fn mine_check_save_submit() -> Result<(), MinerError> {
+		log!(debug, "miner attempting to compute an unsigned solution.");
+
+		let call = Self::mine_checked_call()?;
+		save_solution(&call)?;
+		Self::submit_call(call)
+	}
+
+	/// Mine a new solution as a call. Performs all checks.
+	pub fn mine_checked_call() -> Result<Call<T>, MinerError> {
+		// get the solution, with a load of checks to ensure if submitted, IT IS ABSOLUTELY VALID.
+		let (raw_solution, witness) = Self::mine_and_check()?;
+
+		let score = raw_solution.score;
+		let call: Call<T> = Call::submit_unsigned { raw_solution: Box::new(raw_solution), witness };
+
+		log!(
+			debug,
+			"mined a solution with score {:?} and size {}",
+			score,
+			call.using_encoded(|b| b.len())
+		);
+
+		Ok(call)
+	}
+
+	fn submit_call(call: Call<T>) -> Result<(), MinerError> {
+		log!(debug, "miner submitting a solution as an unsigned transaction");
+
+		SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into())
+			.map_err(|_| MinerError::PoolSubmissionFailed)
+	}
+
+	// perform basic checks of a solution's validity
+	//
+	// Performance: note that it internally clones the provided solution.
+	pub fn basic_checks(
+		raw_solution: &RawSolution<SolutionOf<T::MinerConfig>>,
+		solution_type: &str,
+	) -> Result<(), MinerError> {
+		Self::unsigned_pre_dispatch_checks(raw_solution).map_err(|err| {
+			log!(debug, "pre-dispatch checks failed for {} solution: {:?}", solution_type, err);
+			MinerError::PreDispatchChecksFailed(err)
+		})?;
+
+		Self::feasibility_check(raw_solution.clone(), ElectionCompute::Unsigned).map_err(
+			|err| {
+				log!(debug, "feasibility check failed for {} solution: {:?}", solution_type, err);
+				err
+			},
+		)?;
+
+		Ok(())
+	}
+
+	/// Mine a new npos solution, with all the relevant checks to make sure that it will be accepted
+	/// to the chain.
+	///
+	/// If you want an unchecked solution, use [`Pallet::mine_solution`].
+	/// If you want a checked solution and submit it at the same time, use
+	/// [`Pallet::mine_check_save_submit`].
+	pub fn mine_and_check(
+	) -> Result<(RawSolution<SolutionOf<T::MinerConfig>>, SolutionOrSnapshotSize), MinerError> {
+		let (raw_solution, witness) = Self::mine_solution()?;
+		Self::basic_checks(&raw_solution, "mined")?;
+		Ok((raw_solution, witness))
+	}
+
+	/// Checks if an execution of the offchain worker is permitted at the given block number, or
+	/// not.
+	///
+	/// This makes sure that
+	/// 1. we don't run on previous blocks in case of a re-org
+	/// 2. we don't run twice within a window of length `T::OffchainRepeat`.
+	///
+	/// Returns `Ok(())` if offchain worker limit is respected, `Err(reason)` otherwise. If `Ok()`
+	/// is returned, `now` is written in storage and will be used in further calls as the baseline.
+	pub fn ensure_offchain_repeat_frequency(now: BlockNumberFor<T>) -> Result<(), MinerError> {
+		let threshold = T::OffchainRepeat::get();
+		let last_block = StorageValueRef::persistent(OFFCHAIN_LAST_BLOCK);
+
+		let mutate_stat = last_block.mutate::<_, &'static str, _>(
+			|maybe_head: Result<Option<BlockNumberFor<T>>, _>| {
+				match maybe_head {
+					Ok(Some(head)) if now < head => Err("fork."),
+					Ok(Some(head)) if now >= head && now <= head + threshold =>
+						Err("recently executed."),
+					Ok(Some(head)) if now > head + threshold => {
+						// we can run again now. Write the new head.
+						Ok(now)
+					},
+					_ => {
+						// value doesn't exists. Probably this node just booted up. Write, and run
+						Ok(now)
+					},
+				}
+			},
+		);
+
+		match mutate_stat {
+			// all good
+			Ok(_) => Ok(()),
+			// failed to write.
+			Err(MutateStorageError::ConcurrentModification(_)) =>
+				Err(MinerError::Lock("failed to write to offchain db (concurrent modification).")),
+			// fork etc.
+			Err(MutateStorageError::ValueFunctionFailed(why)) => Err(MinerError::Lock(why)),
+		}
+	}
+
+	/// Do the basics checks that MUST happen during the validation and pre-dispatch of an unsigned
+	/// transaction.
+	///
+	/// Can optionally also be called during dispatch, if needed.
+	///
+	/// NOTE: Ideally, these tests should move more and more outside of this and more to the miner's
+	/// code, so that we do less and less storage reads here.
+	pub fn unsigned_pre_dispatch_checks(
+		raw_solution: &RawSolution<SolutionOf<T::MinerConfig>>,
+	) -> DispatchResult {
+		// ensure solution is timely. Don't panic yet. This is a cheap check.
+		ensure!(Self::current_phase().is_unsigned_open(), Error::<T>::PreDispatchEarlySubmission);
+
+		// ensure round is current
+		ensure!(Self::round() == raw_solution.round, Error::<T>::OcwCallWrongEra);
+
+		// ensure correct number of winners.
+		ensure!(
+			Self::desired_targets().unwrap_or_default() ==
+				raw_solution.solution.unique_targets().len() as u32,
+			Error::<T>::PreDispatchWrongWinnerCount,
+		);
+
+		// ensure score is being improved. Panic henceforth.
+		ensure!(
+			Self::queued_solution().map_or(true, |q: ReadySolution<_, _>| raw_solution
+				.score
+				.strict_threshold_better(q.score, T::BetterUnsignedThreshold::get())),
+			Error::<T>::PreDispatchWeakSubmission,
+		);
+
+		Ok(())
+	}
+}
+
+/// Configurations for a miner that comes with this pallet.
+pub trait MinerConfig {
+	/// The account id type.
+	type AccountId: Ord + Clone + codec::Codec + sp_std::fmt::Debug;
+	/// The solution that the miner is mining.
+	type Solution: codec::Codec
+		+ Default
+		+ PartialEq
+		+ Eq
+		+ Clone
+		+ sp_std::fmt::Debug
+		+ Ord
+		+ NposSolution
+		+ TypeInfo;
+	/// Maximum number of votes per voter in the snapshots.
+	type MaxVotesPerVoter;
+	/// Maximum length of the solution that the miner is allowed to generate.
+	///
+	/// Solutions are trimmed to respect this.
+	type MaxLength: Get<u32>;
+	/// Maximum weight of the solution that the miner is allowed to generate.
+	///
+	/// Solutions are trimmed to respect this.
+	///
+	/// The weight is computed using `solution_weight`.
+	type MaxWeight: Get<Weight>;
+	/// The maximum number of winners that can be elected.
+	type MaxWinners: Get<u32>;
+	/// Something that can compute the weight of a solution.
+	///
+	/// This weight estimate is then used to trim the solution, based on [`MinerConfig::MaxWeight`].
+	fn solution_weight(voters: u32, targets: u32, active_voters: u32, degree: u32) -> Weight;
+}
+
+/// A base miner, suitable to be used for both signed and unsigned submissions.
+pub struct Miner<T: MinerConfig>(sp_std::marker::PhantomData<T>);
+impl<T: MinerConfig> Miner<T> {
+	/// Same as [`Pallet::mine_solution`], but the input snapshot data must be given.
+	pub fn mine_solution_with_snapshot<S>(
+		voters: Vec<(T::AccountId, VoteWeight, BoundedVec<T::AccountId, T::MaxVotesPerVoter>)>,
+		targets: Vec<T::AccountId>,
+		desired_targets: u32,
+	) -> Result<(SolutionOf<T>, ElectionScore, SolutionOrSnapshotSize), MinerError>
+	where
+		S: NposSolver<AccountId = T::AccountId>,
+	{
+		S::solve(desired_targets as usize, targets.clone(), voters.clone())
+			.map_err(|e| {
+				log_no_system!(error, "solver error: {:?}", e);
+				MinerError::Solver
+			})
+			.and_then(|e| {
+				Self::prepare_election_result_with_snapshot::<S::Accuracy>(
+					e,
+					voters,
+					targets,
+					desired_targets,
+				)
+			})
+	}
+
+	/// Convert a raw solution from [`sp_npos_elections::ElectionResult`] to [`RawSolution`], which
+	/// is ready to be submitted to the chain.
+	///
+	/// Will always reduce the solution as well.
+	pub fn prepare_election_result_with_snapshot<Accuracy: PerThing128>(
+		election_result: ElectionResult<T::AccountId, Accuracy>,
+		voters: Vec<(T::AccountId, VoteWeight, BoundedVec<T::AccountId, T::MaxVotesPerVoter>)>,
+		targets: Vec<T::AccountId>,
+		desired_targets: u32,
+	) -> Result<(SolutionOf<T>, ElectionScore, SolutionOrSnapshotSize), MinerError> {
+		// now make some helper closures.
+		let cache = helpers::generate_voter_cache::<T>(&voters);
+		let voter_index = helpers::voter_index_fn::<T>(&cache);
+		let target_index = helpers::target_index_fn::<T>(&targets);
+		let voter_at = helpers::voter_at_fn::<T>(&voters);
+		let target_at = helpers::target_at_fn::<T>(&targets);
+		let stake_of = helpers::stake_of_fn::<T>(&voters, &cache);
+
+		// Compute the size of a solution comprised of the selected arguments.
+		//
+		// This function completes in `O(edges)`; it's expensive, but linear.
+		let encoded_size_of = |assignments: &[IndexAssignmentOf<T>]| {
+			SolutionOf::<T>::try_from(assignments).map(|s| s.encoded_size())
+		};
+
+		let ElectionResult { assignments, winners: _ } = election_result;
+
+		// Reduce (requires round-trip to staked form)
+		let sorted_assignments = {
+			// convert to staked and reduce.
+			let mut staked = assignment_ratio_to_staked_normalized(assignments, &stake_of)?;
+
+			// we reduce before sorting in order to ensure that the reduction process doesn't
+			// accidentally change the sort order
+			sp_npos_elections::reduce(&mut staked);
+
+			// Sort the assignments by reversed voter stake. This ensures that we can efficiently
+			// truncate the list.
+			staked.sort_by_key(
+				|sp_npos_elections::StakedAssignment::<T::AccountId> { who, .. }| {
+					// though staked assignments are expressed in terms of absolute stake, we'd
+					// still need to iterate over all votes in order to actually compute the total
+					// stake. it should be faster to look it up from the cache.
+					let stake = cache
+						.get(who)
+						.map(|idx| {
+							let (_, stake, _) = voters[*idx];
+							stake
+						})
+						.unwrap_or_default();
+					sp_std::cmp::Reverse(stake)
+				},
+			);
+
+			// convert back.
+			assignment_staked_to_ratio_normalized(staked)?
+		};
+
+		// convert to `IndexAssignment`. This improves the runtime complexity of repeatedly
+		// converting to `Solution`.
+		let mut index_assignments = sorted_assignments
+			.into_iter()
+			.map(|assignment| IndexAssignmentOf::<T>::new(&assignment, &voter_index, &target_index))
+			.collect::<Result<Vec<_>, _>>()?;
+
+		// trim assignments list for weight and length.
+		let size =
+			SolutionOrSnapshotSize { voters: voters.len() as u32, targets: targets.len() as u32 };
+		Self::trim_assignments_weight(
+			desired_targets,
+			size,
+			T::MaxWeight::get(),
+			&mut index_assignments,
+		);
+		Self::trim_assignments_length(
+			T::MaxLength::get(),
+			&mut index_assignments,
+			&encoded_size_of,
+		)?;
+
+		// now make solution.
+		let solution = SolutionOf::<T>::try_from(&index_assignments)?;
+
+		// re-calc score.
+		let score = solution.clone().score(stake_of, voter_at, target_at)?;
+
+		Ok((solution, score, size))
+	}
+
+	/// Greedily reduce the size of the solution to fit into the block w.r.t length.
+	///
+	/// The length of the solution is largely a function of the number of voters. The number of
+	/// winners cannot be changed. Thus, to reduce the solution size, we need to strip voters.
+	///
+	/// Note that this solution is already computed, and winners are elected based on the merit of
+	/// the total stake in the system. Nevertheless, some of the voters may be removed here.
+	///
+	/// Sometimes, removing a voter can cause a validator to also be implicitly removed, if
+	/// that voter was the only backer of that winner. In such cases, this solution is invalid,
+	/// which will be caught prior to submission.
+	///
+	/// The score must be computed **after** this step. If this step reduces the score too much,
+	/// then the solution must be discarded.
+	pub fn trim_assignments_length(
+		max_allowed_length: u32,
+		assignments: &mut Vec<IndexAssignmentOf<T>>,
+		encoded_size_of: impl Fn(&[IndexAssignmentOf<T>]) -> Result<usize, sp_npos_elections::Error>,
+	) -> Result<(), MinerError> {
+		// Perform a binary search for the max subset of which can fit into the allowed
+		// length. Having discovered that, we can truncate efficiently.
+		let max_allowed_length: usize = max_allowed_length.saturated_into();
+		let mut high = assignments.len();
+		let mut low = 0;
+
+		// not much we can do if assignments are already empty.
+		if high == low {
+			return Ok(())
+		}
+
+		while high - low > 1 {
+			let test = (high + low) / 2;
+			if encoded_size_of(&assignments[..test])? <= max_allowed_length {
+				low = test;
+			} else {
+				high = test;
+			}
+		}
+		let maximum_allowed_voters = if low < assignments.len() &&
+			encoded_size_of(&assignments[..low + 1])? <= max_allowed_length
+		{
+			low + 1
+		} else {
+			low
+		};
+
+		// ensure our post-conditions are correct
+		debug_assert!(
+			encoded_size_of(&assignments[..maximum_allowed_voters]).unwrap() <= max_allowed_length
+		);
+		debug_assert!(if maximum_allowed_voters < assignments.len() {
+			encoded_size_of(&assignments[..maximum_allowed_voters + 1]).unwrap() >
+				max_allowed_length
+		} else {
+			true
+		});
+
+		// NOTE: before this point, every access was immutable.
+		// after this point, we never error.
+		// check before edit.
+
+		log_no_system!(
+			debug,
+			"from {} assignments, truncating to {} for length, removing {}",
+			assignments.len(),
+			maximum_allowed_voters,
+			assignments.len().saturating_sub(maximum_allowed_voters),
+		);
+		assignments.truncate(maximum_allowed_voters);
+
+		Ok(())
+	}
+
+	/// Greedily reduce the size of the solution to fit into the block w.r.t. weight.
+	///
+	/// The weight of the solution is foremost a function of the number of voters (i.e.
+	/// `assignments.len()`). Aside from this, the other components of the weight are invariant. The
+	/// number of winners shall not be changed (otherwise the solution is invalid) and the
+	/// `ElectionSize` is merely a representation of the total number of stakers.
+	///
+	/// Thus, we reside to stripping away some voters from the `assignments`.
+	///
+	/// Note that the solution is already computed, and the winners are elected based on the merit
+	/// of the entire stake in the system. Nonetheless, some of the voters will be removed further
+	/// down the line.
+	///
+	/// Indeed, the score must be computed **after** this step. If this step reduces the score too
+	/// much or remove a winner, then the solution must be discarded **after** this step.
+	pub fn trim_assignments_weight(
+		desired_targets: u32,
+		size: SolutionOrSnapshotSize,
+		max_weight: Weight,
+		assignments: &mut Vec<IndexAssignmentOf<T>>,
+	) {
+		let maximum_allowed_voters =
+			Self::maximum_voter_for_weight(desired_targets, size, max_weight);
+		let removing: usize =
+			assignments.len().saturating_sub(maximum_allowed_voters.saturated_into());
+		log_no_system!(
+			debug,
+			"from {} assignments, truncating to {} for weight, removing {}",
+			assignments.len(),
+			maximum_allowed_voters,
+			removing,
+		);
+		assignments.truncate(maximum_allowed_voters as usize);
+	}
+
+	/// Find the maximum `len` that a solution can have in order to fit into the block weight.
+	///
+	/// This only returns a value between zero and `size.nominators`.
+	pub fn maximum_voter_for_weight(
+		desired_winners: u32,
+		size: SolutionOrSnapshotSize,
+		max_weight: Weight,
+	) -> u32 {
+		if size.voters < 1 {
+			return size.voters
+		}
+
+		let max_voters = size.voters.max(1);
+		let mut voters = max_voters;
+
+		// helper closures.
+		let weight_with = |active_voters: u32| -> Weight {
+			T::solution_weight(size.voters, size.targets, active_voters, desired_winners)
+		};
+
+		let next_voters = |current_weight: Weight, voters: u32, step: u32| -> Result<u32, ()> {
+			if current_weight.all_lt(max_weight) {
+				let next_voters = voters.checked_add(step);
+				match next_voters {
+					Some(voters) if voters < max_voters => Ok(voters),
+					_ => Err(()),
+				}
+			} else if current_weight.any_gt(max_weight) {
+				voters.checked_sub(step).ok_or(())
+			} else {
+				// If any of the constituent weights is equal to the max weight, we're at max
+				Ok(voters)
+			}
+		};
+
+		// First binary-search the right amount of voters
+		let mut step = voters / 2;
+		let mut current_weight = weight_with(voters);
+
+		while step > 0 {
+			match next_voters(current_weight, voters, step) {
+				// proceed with the binary search
+				Ok(next) if next != voters => {
+					voters = next;
+				},
+				// we are out of bounds, break out of the loop.
+				Err(()) => break,
+				// we found the right value - early exit the function.
+				Ok(next) => return next,
+			}
+			step /= 2;
+			current_weight = weight_with(voters);
+		}
+
+		// Time to finish. We might have reduced less than expected due to rounding error. Increase
+		// one last time if we have any room left, the reduce until we are sure we are below limit.
+		while voters < max_voters && weight_with(voters + 1).all_lt(max_weight) {
+			voters += 1;
+		}
+		while voters.checked_sub(1).is_some() && weight_with(voters).any_gt(max_weight) {
+			voters -= 1;
+		}
+
+		let final_decision = voters.min(size.voters);
+		debug_assert!(
+			weight_with(final_decision).all_lte(max_weight),
+			"weight_with({}) <= {}",
+			final_decision,
+			max_weight,
+		);
+		final_decision
+	}
+
+	/// Checks the feasibility of a solution.
+	pub fn feasibility_check(
+		raw_solution: RawSolution<SolutionOf<T>>,
+		compute: ElectionCompute,
+		desired_targets: u32,
+		snapshot: RoundSnapshot<T::AccountId, MinerVoterOf<T>>,
+		current_round: u32,
+		minimum_untrusted_score: Option<ElectionScore>,
+	) -> Result<ReadySolution<T::AccountId, T::MaxWinners>, FeasibilityError> {
+		let RawSolution { solution, score, round } = raw_solution;
+		let RoundSnapshot { voters: snapshot_voters, targets: snapshot_targets } = snapshot;
+
+		// First, check round.
+		ensure!(current_round == round, FeasibilityError::InvalidRound);
+
+		// Winners are not directly encoded in the solution.
+		let winners = solution.unique_targets();
+
+		ensure!(winners.len() as u32 == desired_targets, FeasibilityError::WrongWinnerCount);
+		// Fail early if targets requested by data provider exceed maximum winners supported.
+		ensure!(desired_targets <= T::MaxWinners::get(), FeasibilityError::TooManyDesiredTargets);
+
+		// Ensure that the solution's score can pass absolute min-score.
+		let submitted_score = raw_solution.score;
+		ensure!(
+			minimum_untrusted_score.map_or(true, |min_score| {
+				submitted_score.strict_threshold_better(min_score, sp_runtime::Perbill::zero())
+			}),
+			FeasibilityError::UntrustedScoreTooLow
+		);
+
+		// ----- Start building. First, we need some closures.
+		let cache = helpers::generate_voter_cache::<T>(&snapshot_voters);
+		let voter_at = helpers::voter_at_fn::<T>(&snapshot_voters);
+		let target_at = helpers::target_at_fn::<T>(&snapshot_targets);
+		let voter_index = helpers::voter_index_fn_usize::<T>(&cache);
+
+		// Then convert solution -> assignment. This will fail if any of the indices are gibberish,
+		// namely any of the voters or targets.
+		let assignments = solution
+			.into_assignment(voter_at, target_at)
+			.map_err::<FeasibilityError, _>(Into::into)?;
+
+		// Ensure that assignments is correct.
+		let _ = assignments.iter().try_for_each(|assignment| {
+			// Check that assignment.who is actually a voter (defensive-only).
+			// NOTE: while using the index map from `voter_index` is better than a blind linear
+			// search, this *still* has room for optimization. Note that we had the index when
+			// we did `solution -> assignment` and we lost it. Ideal is to keep the index
+			// around.
+
+			// Defensive-only: must exist in the snapshot.
+			let snapshot_index =
+				voter_index(&assignment.who).ok_or(FeasibilityError::InvalidVoter)?;
+			// Defensive-only: index comes from the snapshot, must exist.
+			let (_voter, _stake, targets) =
+				snapshot_voters.get(snapshot_index).ok_or(FeasibilityError::InvalidVoter)?;
+
+			// Check that all of the targets are valid based on the snapshot.
+			if assignment.distribution.iter().any(|(d, _)| !targets.contains(d)) {
+				return Err(FeasibilityError::InvalidVote)
+			}
+			Ok(())
+		})?;
+
+		// ----- Start building support. First, we need one more closure.
+		let stake_of = helpers::stake_of_fn::<T>(&snapshot_voters, &cache);
+
+		// This might fail if the normalization fails. Very unlikely. See `integrity_test`.
+		let staked_assignments = assignment_ratio_to_staked_normalized(assignments, stake_of)
+			.map_err::<FeasibilityError, _>(Into::into)?;
+		let supports = sp_npos_elections::to_supports(&staked_assignments);
+
+		// Finally, check that the claimed score was indeed correct.
+		let known_score = supports.evaluate();
+		ensure!(known_score == score, FeasibilityError::InvalidScore);
+
+		// Size of winners in miner solution is equal to `desired_targets` <= `MaxWinners`.
+		let supports = supports
+			.try_into()
+			.defensive_map_err(|_| FeasibilityError::BoundedConversionFailed)?;
+
+		Ok(ReadySolution { supports, compute, score })
+	}
+}
+
+#[cfg(test)]
+mod max_weight {
+	#![allow(unused_variables)]
+	use super::*;
+	use crate::mock::{MockWeightInfo, Runtime};
+	#[test]
+	fn find_max_voter_binary_search_works() {
+		let w = SolutionOrSnapshotSize { voters: 10, targets: 0 };
+		MockWeightInfo::set(crate::mock::MockedWeightInfo::Complex);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(0, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(999, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1000, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1001, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1990, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1999, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2000, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2001, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2010, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2990, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2999, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(3000, u64::MAX)),
+			3
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(3333, u64::MAX)),
+			3
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(5500, u64::MAX)),
+			5
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(7777, u64::MAX)),
+			7
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(9999, u64::MAX)),
+			9
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(10_000, u64::MAX)),
+			10
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(10_999, u64::MAX)),
+			10
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(11_000, u64::MAX)),
+			10
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(22_000, u64::MAX)),
+			10
+		);
+
+		let w = SolutionOrSnapshotSize { voters: 1, targets: 0 };
+
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(0, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(999, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1000, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1001, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1990, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1999, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2000, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2001, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2010, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(3333, u64::MAX)),
+			1
+		);
+
+		let w = SolutionOrSnapshotSize { voters: 2, targets: 0 };
+
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(0, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(999, u64::MAX)),
+			0
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1000, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1001, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(1999, u64::MAX)),
+			1
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2000, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2001, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(2010, u64::MAX)),
+			2
+		);
+		assert_eq!(
+			Miner::<Runtime>::maximum_voter_for_weight(0, w, Weight::from_parts(3333, u64::MAX)),
+			2
+		);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		mock::{
+			multi_phase_events, roll_to, roll_to_signed, roll_to_unsigned, roll_to_with_ocw,
+			trim_helpers, witness, BlockNumber, ExtBuilder, Extrinsic, MinerMaxWeight, MultiPhase,
+			Runtime, RuntimeCall, RuntimeOrigin, System, TestNposSolution, TrimHelpers,
+			UnsignedPhase,
+		},
+		Event, InvalidTransaction, Phase, QueuedSolution, TransactionSource,
+		TransactionValidityError,
+	};
+	use codec::Decode;
+	use frame_election_provider_support::IndexAssignment;
+	use frame_support::{assert_noop, assert_ok, dispatch::Dispatchable, traits::OffchainWorker};
+	use sp_npos_elections::ElectionScore;
+	use sp_runtime::{
+		bounded_vec,
+		offchain::storage_lock::{BlockAndTime, StorageLock},
+		traits::{ValidateUnsigned, Zero},
+		ModuleError, PerU16, Perbill,
+	};
+
+	type Assignment = crate::unsigned::Assignment<Runtime>;
+
+	#[test]
+	fn validate_unsigned_retracts_wrong_phase() {
+		ExtBuilder::default().desired_targets(0).build_and_execute(|| {
+			let solution = RawSolution::<TestNposSolution> {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			let call = Call::submit_unsigned {
+				raw_solution: Box::new(solution.clone()),
+				witness: witness(),
+			};
+
+			// initial
+			assert_eq!(MultiPhase::current_phase(), Phase::Off);
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::validate_unsigned(
+					TransactionSource::Local,
+					&call
+				)
+				.unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(0))
+			));
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::pre_dispatch(&call).unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(0))
+			));
+
+			// signed
+			roll_to_signed();
+			assert_eq!(MultiPhase::current_phase(), Phase::Signed);
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::validate_unsigned(
+					TransactionSource::Local,
+					&call
+				)
+				.unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(0))
+			));
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::pre_dispatch(&call).unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(0))
+			));
+
+			// unsigned
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			assert!(<MultiPhase as ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&call
+			)
+			.is_ok());
+			assert!(<MultiPhase as ValidateUnsigned>::pre_dispatch(&call).is_ok());
+
+			// unsigned -- but not enabled.
+			MultiPhase::phase_transition(Phase::Unsigned((false, 25)));
+			assert!(MultiPhase::current_phase().is_unsigned());
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::validate_unsigned(
+					TransactionSource::Local,
+					&call
+				)
+				.unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(0))
+			));
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::pre_dispatch(&call).unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(0))
+			));
+		})
+	}
+
+	#[test]
+	fn validate_unsigned_retracts_low_score() {
+		ExtBuilder::default().desired_targets(0).build_and_execute(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			let solution = RawSolution::<TestNposSolution> {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			let call = Call::submit_unsigned {
+				raw_solution: Box::new(solution.clone()),
+				witness: witness(),
+			};
+
+			// initial
+			assert!(<MultiPhase as ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&call
+			)
+			.is_ok());
+			assert!(<MultiPhase as ValidateUnsigned>::pre_dispatch(&call).is_ok());
+
+			// set a better score
+			let ready = ReadySolution {
+				score: ElectionScore { minimal_stake: 10, ..Default::default() },
+				..Default::default()
+			};
+			<QueuedSolution<Runtime>>::put(ready);
+
+			// won't work anymore.
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::validate_unsigned(
+					TransactionSource::Local,
+					&call
+				)
+				.unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(2))
+			));
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::pre_dispatch(&call).unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(2))
+			));
+		})
+	}
+
+	#[test]
+	fn validate_unsigned_retracts_incorrect_winner_count() {
+		ExtBuilder::default().desired_targets(1).build_and_execute(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			let raw = RawSolution::<TestNposSolution> {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			let call =
+				Call::submit_unsigned { raw_solution: Box::new(raw.clone()), witness: witness() };
+			assert_eq!(raw.solution.unique_targets().len(), 0);
+
+			// won't work anymore.
+			assert!(matches!(
+				<MultiPhase as ValidateUnsigned>::validate_unsigned(
+					TransactionSource::Local,
+					&call
+				)
+				.unwrap_err(),
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(1))
+			));
+		})
+	}
+
+	#[test]
+	fn priority_is_set() {
+		ExtBuilder::default()
+			.miner_tx_priority(20)
+			.desired_targets(0)
+			.build_and_execute(|| {
+				roll_to_unsigned();
+				assert!(MultiPhase::current_phase().is_unsigned());
+
+				let solution = RawSolution::<TestNposSolution> {
+					score: ElectionScore { minimal_stake: 5, ..Default::default() },
+					..Default::default()
+				};
+				let call = Call::submit_unsigned {
+					raw_solution: Box::new(solution.clone()),
+					witness: witness(),
+				};
+
+				assert_eq!(
+					<MultiPhase as ValidateUnsigned>::validate_unsigned(
+						TransactionSource::Local,
+						&call
+					)
+					.unwrap()
+					.priority,
+					25
+				);
+			})
+	}
+
+	#[test]
+	#[should_panic(expected = "Invalid unsigned submission must produce invalid block and \
+	                           deprive validator from their authoring reward.: \
+	                           Module(ModuleError { index: 2, error: [1, 0, 0, 0], message: \
+	                           Some(\"PreDispatchWrongWinnerCount\") })")]
+	fn unfeasible_solution_panics() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// This is in itself an invalid BS solution.
+			let solution = RawSolution::<TestNposSolution> {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+			let call = Call::submit_unsigned {
+				raw_solution: Box::new(solution.clone()),
+				witness: witness(),
+			};
+			let runtime_call: RuntimeCall = call.into();
+			let _ = runtime_call.dispatch(RuntimeOrigin::none());
+		})
+	}
+
+	#[test]
+	#[should_panic(expected = "Invalid unsigned submission must produce invalid block and \
+	                           deprive validator from their authoring reward.")]
+	fn wrong_witness_panics() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// This solution is unfeasible as well, but we won't even get there.
+			let solution = RawSolution::<TestNposSolution> {
+				score: ElectionScore { minimal_stake: 5, ..Default::default() },
+				..Default::default()
+			};
+
+			let mut correct_witness = witness();
+			correct_witness.voters += 1;
+			correct_witness.targets -= 1;
+			let call = Call::submit_unsigned {
+				raw_solution: Box::new(solution.clone()),
+				witness: correct_witness,
+			};
+			let runtime_call: RuntimeCall = call.into();
+			let _ = runtime_call.dispatch(RuntimeOrigin::none());
+		})
+	}
+
+	#[test]
+	fn miner_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// ensure we have snapshots in place.
+			assert!(MultiPhase::snapshot().is_some());
+			assert_eq!(MultiPhase::desired_targets().unwrap(), 2);
+
+			// mine seq_phragmen solution with 2 iters.
+			let (solution, witness) = MultiPhase::mine_solution().unwrap();
+
+			// ensure this solution is valid.
+			assert!(MultiPhase::queued_solution().is_none());
+			assert_ok!(MultiPhase::submit_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(solution),
+				witness
+			));
+			assert!(MultiPhase::queued_solution().is_some());
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::SolutionStored {
+						compute: ElectionCompute::Unsigned,
+						origin: None,
+						prev_ejected: false
+					}
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn miner_trims_weight() {
+		ExtBuilder::default()
+			.miner_weight(Weight::from_parts(100, u64::MAX))
+			.mock_weight_info(crate::mock::MockedWeightInfo::Basic)
+			.build_and_execute(|| {
+				roll_to_unsigned();
+				assert!(MultiPhase::current_phase().is_unsigned());
+
+				let (raw, witness) = MultiPhase::mine_solution().unwrap();
+				let solution_weight = <Runtime as MinerConfig>::solution_weight(
+					witness.voters,
+					witness.targets,
+					raw.solution.voter_count() as u32,
+					raw.solution.unique_targets().len() as u32,
+				);
+				// default solution will have 5 edges (5 * 5 + 10)
+				assert_eq!(solution_weight, Weight::from_parts(35, 0));
+				assert_eq!(raw.solution.voter_count(), 5);
+
+				// now reduce the max weight
+				<MinerMaxWeight>::set(Weight::from_parts(25, u64::MAX));
+
+				let (raw, witness) = MultiPhase::mine_solution().unwrap();
+				let solution_weight = <Runtime as MinerConfig>::solution_weight(
+					witness.voters,
+					witness.targets,
+					raw.solution.voter_count() as u32,
+					raw.solution.unique_targets().len() as u32,
+				);
+				// default solution will have 5 edges (5 * 5 + 10)
+				assert_eq!(solution_weight, Weight::from_parts(25, 0));
+				assert_eq!(raw.solution.voter_count(), 3);
+			})
+	}
+
+	#[test]
+	fn miner_will_not_submit_if_not_enough_winners() {
+		let (mut ext, _) = ExtBuilder::default().desired_targets(8).build_offchainify(0);
+		ext.execute_with(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// Force the number of winners to be bigger to fail
+			let (mut solution, _) = MultiPhase::mine_solution().unwrap();
+			solution.solution.votes1[0].1 = 4;
+
+			assert_eq!(
+				MultiPhase::basic_checks(&solution, "mined").unwrap_err(),
+				MinerError::PreDispatchChecksFailed(DispatchError::Module(ModuleError {
+					index: 2,
+					error: [1, 0, 0, 0],
+					message: Some("PreDispatchWrongWinnerCount"),
+				})),
+			);
+		})
+	}
+
+	#[test]
+	fn unsigned_per_dispatch_checks_can_only_submit_threshold_better() {
+		ExtBuilder::default()
+			.desired_targets(1)
+			.add_voter(7, 2, bounded_vec![10])
+			.add_voter(8, 5, bounded_vec![10])
+			.better_unsigned_threshold(Perbill::from_percent(50))
+			.build_and_execute(|| {
+				roll_to_unsigned();
+				assert!(MultiPhase::current_phase().is_unsigned());
+				assert_eq!(MultiPhase::desired_targets().unwrap(), 1);
+
+				// an initial solution
+				let result = ElectionResult {
+					// note: This second element of backing stake is not important here.
+					winners: vec![(10, 10)],
+					assignments: vec![Assignment {
+						who: 10,
+						distribution: vec![(10, PerU16::one())],
+					}],
+				};
+
+				let RoundSnapshot { voters, targets } = MultiPhase::snapshot().unwrap();
+				let desired_targets = MultiPhase::desired_targets().unwrap();
+
+				let (raw, score, witness) =
+					Miner::<Runtime>::prepare_election_result_with_snapshot(
+						result,
+						voters.clone(),
+						targets.clone(),
+						desired_targets,
+					)
+					.unwrap();
+				let solution = RawSolution { solution: raw, score, round: MultiPhase::round() };
+				assert_ok!(MultiPhase::unsigned_pre_dispatch_checks(&solution));
+				assert_ok!(MultiPhase::submit_unsigned(
+					RuntimeOrigin::none(),
+					Box::new(solution),
+					witness
+				));
+				assert_eq!(MultiPhase::queued_solution().unwrap().score.minimal_stake, 10);
+
+				// trial 1: a solution who's score is only 2, i.e. 20% better in the first element.
+				let result = ElectionResult {
+					winners: vec![(10, 12)],
+					assignments: vec![
+						Assignment { who: 10, distribution: vec![(10, PerU16::one())] },
+						Assignment {
+							who: 7,
+							// note: this percent doesn't even matter, in solution it is 100%.
+							distribution: vec![(10, PerU16::one())],
+						},
+					],
+				};
+				let (raw, score, _) = Miner::<Runtime>::prepare_election_result_with_snapshot(
+					result,
+					voters.clone(),
+					targets.clone(),
+					desired_targets,
+				)
+				.unwrap();
+				let solution = RawSolution { solution: raw, score, round: MultiPhase::round() };
+				// 12 is not 50% more than 10
+				assert_eq!(solution.score.minimal_stake, 12);
+				assert_noop!(
+					MultiPhase::unsigned_pre_dispatch_checks(&solution),
+					Error::<Runtime>::PreDispatchWeakSubmission,
+				);
+				// submitting this will actually panic.
+
+				// trial 2: a solution who's score is only 7, i.e. 70% better in the first element.
+				let result = ElectionResult {
+					winners: vec![(10, 12)],
+					assignments: vec![
+						Assignment { who: 10, distribution: vec![(10, PerU16::one())] },
+						Assignment { who: 7, distribution: vec![(10, PerU16::one())] },
+						Assignment {
+							who: 8,
+							// note: this percent doesn't even matter, in solution it is 100%.
+							distribution: vec![(10, PerU16::one())],
+						},
+					],
+				};
+				let (raw, score, witness) =
+					Miner::<Runtime>::prepare_election_result_with_snapshot(
+						result,
+						voters.clone(),
+						targets.clone(),
+						desired_targets,
+					)
+					.unwrap();
+				let solution = RawSolution { solution: raw, score, round: MultiPhase::round() };
+				assert_eq!(solution.score.minimal_stake, 17);
+
+				// and it is fine
+				assert_ok!(MultiPhase::unsigned_pre_dispatch_checks(&solution));
+				assert_ok!(MultiPhase::submit_unsigned(
+					RuntimeOrigin::none(),
+					Box::new(solution),
+					witness
+				));
+			})
+	}
+
+	#[test]
+	fn ocw_lock_prevents_frequent_execution() {
+		let (mut ext, _) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			let offchain_repeat = <Runtime as Config>::OffchainRepeat::get();
+
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// first execution -- okay.
+			assert!(MultiPhase::ensure_offchain_repeat_frequency(25).is_ok());
+
+			// next block: rejected.
+			assert_noop!(
+				MultiPhase::ensure_offchain_repeat_frequency(26),
+				MinerError::Lock("recently executed.")
+			);
+
+			// allowed after `OFFCHAIN_REPEAT`
+			assert!(
+				MultiPhase::ensure_offchain_repeat_frequency((26 + offchain_repeat).into()).is_ok()
+			);
+
+			// a fork like situation: re-execute last 3.
+			assert!(MultiPhase::ensure_offchain_repeat_frequency(
+				(26 + offchain_repeat - 3).into()
+			)
+			.is_err());
+			assert!(MultiPhase::ensure_offchain_repeat_frequency(
+				(26 + offchain_repeat - 2).into()
+			)
+			.is_err());
+			assert!(MultiPhase::ensure_offchain_repeat_frequency(
+				(26 + offchain_repeat - 1).into()
+			)
+			.is_err());
+		})
+	}
+
+	#[test]
+	fn ocw_lock_released_after_successful_execution() {
+		// first, ensure that a successful execution releases the lock
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			let guard = StorageValueRef::persistent(&OFFCHAIN_LOCK);
+			let last_block = StorageValueRef::persistent(OFFCHAIN_LAST_BLOCK);
+
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// initially, the lock is not set.
+			assert!(guard.get::<bool>().unwrap().is_none());
+
+			// a successful a-z execution.
+			MultiPhase::offchain_worker(25);
+			assert_eq!(pool.read().transactions.len(), 1);
+
+			// afterwards, the lock is not set either..
+			assert!(guard.get::<bool>().unwrap().is_none());
+			assert_eq!(last_block.get::<BlockNumber>().unwrap(), Some(25));
+		});
+	}
+
+	#[test]
+	fn ocw_lock_prevents_overlapping_execution() {
+		// ensure that if the guard is in hold, a new execution is not allowed.
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			roll_to_unsigned();
+			assert!(MultiPhase::current_phase().is_unsigned());
+
+			// artificially set the value, as if another thread is mid-way.
+			let mut lock = StorageLock::<BlockAndTime<System>>::with_block_deadline(
+				OFFCHAIN_LOCK,
+				UnsignedPhase::get().saturated_into(),
+			);
+			let guard = lock.lock();
+
+			// nothing submitted.
+			MultiPhase::offchain_worker(25);
+			assert_eq!(pool.read().transactions.len(), 0);
+			MultiPhase::offchain_worker(26);
+			assert_eq!(pool.read().transactions.len(), 0);
+
+			drop(guard);
+
+			// 🎉 !
+			MultiPhase::offchain_worker(25);
+			assert_eq!(pool.read().transactions.len(), 1);
+		});
+	}
+
+	#[test]
+	fn ocw_only_runs_when_unsigned_open_now() {
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			roll_to_unsigned();
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+
+			// we must clear the offchain storage to ensure the offchain execution check doesn't get
+			// in the way.
+			let mut storage = StorageValueRef::persistent(&OFFCHAIN_LAST_BLOCK);
+
+			MultiPhase::offchain_worker(24);
+			assert!(pool.read().transactions.len().is_zero());
+			storage.clear();
+
+			// creates, caches, submits without expecting previous cache value
+			MultiPhase::offchain_worker(25);
+			assert_eq!(pool.read().transactions.len(), 1);
+			// assume that the tx has been processed
+			pool.try_write().unwrap().transactions.clear();
+
+			// locked, but also, has previously cached.
+			MultiPhase::offchain_worker(26);
+			assert!(pool.read().transactions.len().is_zero());
+		})
+	}
+
+	#[test]
+	fn ocw_clears_cache_on_unsigned_phase_open() {
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			const BLOCK: u64 = 25;
+			let block_plus = |delta: u64| BLOCK + delta;
+			let offchain_repeat = <Runtime as Config>::OffchainRepeat::get();
+
+			roll_to(BLOCK);
+			// we are on the first block of the unsigned phase
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, BLOCK)));
+
+			assert!(
+				!ocw_solution_exists::<Runtime>(),
+				"no solution should be present before we mine one",
+			);
+
+			// create and cache a solution on the first block of the unsigned phase
+			MultiPhase::offchain_worker(BLOCK);
+			assert!(
+				ocw_solution_exists::<Runtime>(),
+				"a solution must be cached after running the worker",
+			);
+
+			// record the submitted tx,
+			let tx_cache_1 = pool.read().transactions[0].clone();
+			// and assume it has been processed.
+			pool.try_write().unwrap().transactions.clear();
+
+			// after an election, the solution is not cleared
+			// we don't actually care about the result of the election
+			let _ = MultiPhase::do_elect();
+			MultiPhase::offchain_worker(block_plus(1));
+			assert!(ocw_solution_exists::<Runtime>(), "elections does not clear the ocw cache");
+
+			// submit a solution with the offchain worker after the repeat interval
+			MultiPhase::offchain_worker(block_plus(offchain_repeat + 1));
+
+			// record the submitted tx,
+			let tx_cache_2 = pool.read().transactions[0].clone();
+			// and assume it has been processed.
+			pool.try_write().unwrap().transactions.clear();
+
+			// the OCW submitted the same solution twice since the cache was not cleared.
+			assert_eq!(tx_cache_1, tx_cache_2);
+
+			let current_block = block_plus(offchain_repeat * 2 + 2);
+			// force the unsigned phase to start on the current block.
+			MultiPhase::phase_transition(Phase::Unsigned((true, current_block)));
+
+			// clear the cache and create a solution since we are on the first block of the unsigned
+			// phase.
+			MultiPhase::offchain_worker(current_block);
+			let tx_cache_3 = pool.read().transactions[0].clone();
+
+			// the submitted solution changes because the cache was cleared.
+			assert_eq!(tx_cache_1, tx_cache_3);
+			assert_eq!(
+				multi_phase_events(),
+				vec![
+					Event::PhaseTransitioned { from: Phase::Off, to: Phase::Signed, round: 1 },
+					Event::PhaseTransitioned {
+						from: Phase::Signed,
+						to: Phase::Unsigned((true, 25)),
+						round: 1
+					},
+					Event::ElectionFinalized {
+						compute: ElectionCompute::Fallback,
+						score: ElectionScore {
+							minimal_stake: 0,
+							sum_stake: 0,
+							sum_stake_squared: 0
+						}
+					},
+					Event::PhaseTransitioned {
+						from: Phase::Unsigned((true, 25)),
+						to: Phase::Unsigned((true, 37)),
+						round: 1
+					},
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn ocw_resubmits_after_offchain_repeat() {
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			const BLOCK: u64 = 25;
+			let block_plus = |delta: i32| ((BLOCK as i32) + delta) as u64;
+			let offchain_repeat = <Runtime as Config>::OffchainRepeat::get();
+
+			roll_to(BLOCK);
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, BLOCK)));
+
+			// we must clear the offchain storage to ensure the offchain execution check doesn't get
+			// in the way.
+			let mut storage = StorageValueRef::persistent(&OFFCHAIN_LAST_BLOCK);
+
+			MultiPhase::offchain_worker(block_plus(-1));
+			assert!(pool.read().transactions.len().is_zero());
+			storage.clear();
+
+			// creates, caches, submits without expecting previous cache value
+			MultiPhase::offchain_worker(BLOCK);
+			assert_eq!(pool.read().transactions.len(), 1);
+			let tx_cache = pool.read().transactions[0].clone();
+			// assume that the tx has been processed
+			pool.try_write().unwrap().transactions.clear();
+
+			// attempts to resubmit the tx after the threshold has expired
+			// note that we have to add 1: the semantics forbid resubmission at
+			// BLOCK + offchain_repeat
+			MultiPhase::offchain_worker(block_plus(1 + offchain_repeat as i32));
+			assert_eq!(pool.read().transactions.len(), 1);
+
+			// resubmitted tx is identical to first submission
+			let tx = &pool.read().transactions[0];
+			assert_eq!(&tx_cache, tx);
+		})
+	}
+
+	#[test]
+	fn ocw_regenerates_and_resubmits_after_offchain_repeat() {
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			const BLOCK: u64 = 25;
+			let block_plus = |delta: i32| ((BLOCK as i32) + delta) as u64;
+			let offchain_repeat = <Runtime as Config>::OffchainRepeat::get();
+
+			roll_to(BLOCK);
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, BLOCK)));
+
+			// we must clear the offchain storage to ensure the offchain execution check doesn't get
+			// in the way.
+			let mut storage = StorageValueRef::persistent(&OFFCHAIN_LAST_BLOCK);
+
+			MultiPhase::offchain_worker(block_plus(-1));
+			assert!(pool.read().transactions.len().is_zero());
+			storage.clear();
+
+			// creates, caches, submits without expecting previous cache value
+			MultiPhase::offchain_worker(BLOCK);
+			assert_eq!(pool.read().transactions.len(), 1);
+			let tx_cache = pool.read().transactions[0].clone();
+			// assume that the tx has been processed
+			pool.try_write().unwrap().transactions.clear();
+
+			// remove the cached submitted tx
+			// this ensures that when the resubmit window rolls around, we're ready to regenerate
+			// from scratch if necessary
+			let mut call_cache = StorageValueRef::persistent(&OFFCHAIN_CACHED_CALL);
+			assert!(matches!(call_cache.get::<Call<Runtime>>(), Ok(Some(_call))));
+			call_cache.clear();
+
+			// attempts to resubmit the tx after the threshold has expired
+			// note that we have to add 1: the semantics forbid resubmission at
+			// BLOCK + offchain_repeat
+			MultiPhase::offchain_worker(block_plus(1 + offchain_repeat as i32));
+			assert_eq!(pool.read().transactions.len(), 1);
+
+			// resubmitted tx is identical to first submission
+			let tx = &pool.read().transactions[0];
+			assert_eq!(&tx_cache, tx);
+		})
+	}
+
+	#[test]
+	fn ocw_can_submit_to_pool() {
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			roll_to_with_ocw(25);
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+			// OCW must have submitted now
+
+			let encoded = pool.read().transactions[0].clone();
+			let extrinsic: Extrinsic = codec::Decode::decode(&mut &*encoded).unwrap();
+			let call = extrinsic.call;
+			assert!(matches!(call, RuntimeCall::MultiPhase(Call::submit_unsigned { .. })));
+		})
+	}
+
+	#[test]
+	fn ocw_solution_must_have_correct_round() {
+		let (mut ext, pool) = ExtBuilder::default().build_offchainify(0);
+		ext.execute_with(|| {
+			roll_to_with_ocw(25);
+			assert_eq!(MultiPhase::current_phase(), Phase::Unsigned((true, 25)));
+			// OCW must have submitted now
+			// now, before we check the call, update the round
+			<crate::Round<Runtime>>::mutate(|round| *round += 1);
+
+			let encoded = pool.read().transactions[0].clone();
+			let extrinsic = Extrinsic::decode(&mut &*encoded).unwrap();
+			let call = match extrinsic.call {
+				RuntimeCall::MultiPhase(call @ Call::submit_unsigned { .. }) => call,
+				_ => panic!("bad call: unexpected submission"),
+			};
+
+			// Custom(7) maps to PreDispatchChecksFailed
+			let pre_dispatch_check_error =
+				TransactionValidityError::Invalid(InvalidTransaction::Custom(7));
+			assert_eq!(
+				<MultiPhase as ValidateUnsigned>::validate_unsigned(
+					TransactionSource::Local,
+					&call,
+				)
+				.unwrap_err(),
+				pre_dispatch_check_error,
+			);
+			assert_eq!(
+				<MultiPhase as ValidateUnsigned>::pre_dispatch(&call).unwrap_err(),
+				pre_dispatch_check_error,
+			);
+		})
+	}
+
+	#[test]
+	fn trim_assignments_length_does_not_modify_when_short_enough() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_unsigned();
+
+			// given
+			let TrimHelpers { mut assignments, encoded_size_of, .. } = trim_helpers();
+			let solution = SolutionOf::<Runtime>::try_from(assignments.as_slice()).unwrap();
+			let encoded_len = solution.encoded_size() as u32;
+			let solution_clone = solution.clone();
+
+			// when
+			Miner::<Runtime>::trim_assignments_length(
+				encoded_len,
+				&mut assignments,
+				encoded_size_of,
+			)
+			.unwrap();
+
+			// then
+			let solution = SolutionOf::<Runtime>::try_from(assignments.as_slice()).unwrap();
+			assert_eq!(solution, solution_clone);
+		});
+	}
+
+	#[test]
+	fn trim_assignments_length_modifies_when_too_long() {
+		ExtBuilder::default().build().execute_with(|| {
+			roll_to_unsigned();
+
+			// given
+			let TrimHelpers { mut assignments, encoded_size_of, .. } = trim_helpers();
+			let solution = SolutionOf::<Runtime>::try_from(assignments.as_slice()).unwrap();
+			let encoded_len = solution.encoded_size();
+			let solution_clone = solution.clone();
+
+			// when
+			Miner::<Runtime>::trim_assignments_length(
+				encoded_len as u32 - 1,
+				&mut assignments,
+				encoded_size_of,
+			)
+			.unwrap();
+
+			// then
+			let solution = SolutionOf::<Runtime>::try_from(assignments.as_slice()).unwrap();
+			assert_ne!(solution, solution_clone);
+			assert!(solution.encoded_size() < encoded_len);
+		});
+	}
+
+	#[test]
+	fn trim_assignments_length_trims_lowest_stake() {
+		ExtBuilder::default().build().execute_with(|| {
+			roll_to_unsigned();
+
+			// given
+			let TrimHelpers { voters, mut assignments, encoded_size_of, voter_index } =
+				trim_helpers();
+			let solution = SolutionOf::<Runtime>::try_from(assignments.as_slice()).unwrap();
+			let encoded_len = solution.encoded_size() as u32;
+			let count = assignments.len();
+			let min_stake_voter = voters
+				.iter()
+				.map(|(id, weight, _)| (weight, id))
+				.min()
+				.and_then(|(_, id)| voter_index(id))
+				.unwrap();
+
+			// when
+			Miner::<Runtime>::trim_assignments_length(
+				encoded_len - 1,
+				&mut assignments,
+				encoded_size_of,
+			)
+			.unwrap();
+
+			// then
+			assert_eq!(assignments.len(), count - 1, "we must have removed exactly one assignment");
+			assert!(
+				assignments.iter().all(|IndexAssignment { who, .. }| *who != min_stake_voter),
+				"min_stake_voter must no longer be in the set of voters",
+			);
+		});
+	}
+
+	#[test]
+	fn trim_assignments_length_wont_panic() {
+		// we shan't panic if assignments are initially empty.
+		ExtBuilder::default().build_and_execute(|| {
+			let encoded_size_of = Box::new(|assignments: &[IndexAssignmentOf<Runtime>]| {
+				SolutionOf::<Runtime>::try_from(assignments).map(|solution| solution.encoded_size())
+			});
+
+			let mut assignments = vec![];
+
+			// since we have 16 fields, we need to store the length fields of 16 vecs, thus 16 bytes
+			// minimum.
+			let min_solution_size = encoded_size_of(&assignments).unwrap();
+			assert_eq!(min_solution_size, SolutionOf::<Runtime>::LIMIT);
+
+			// all of this should not panic.
+			Miner::<Runtime>::trim_assignments_length(0, &mut assignments, encoded_size_of.clone())
+				.unwrap();
+			Miner::<Runtime>::trim_assignments_length(1, &mut assignments, encoded_size_of.clone())
+				.unwrap();
+			Miner::<Runtime>::trim_assignments_length(
+				min_solution_size as u32,
+				&mut assignments,
+				encoded_size_of,
+			)
+			.unwrap();
+		});
+
+		// or when we trim it to zero.
+		ExtBuilder::default().build_and_execute(|| {
+			// we need snapshot for `trim_helpers` to work.
+			roll_to_unsigned();
+			let TrimHelpers { mut assignments, encoded_size_of, .. } = trim_helpers();
+			assert!(assignments.len() > 0);
+
+			// trim to min solution size.
+			let min_solution_size = SolutionOf::<Runtime>::LIMIT as u32;
+			Miner::<Runtime>::trim_assignments_length(
+				min_solution_size,
+				&mut assignments,
+				encoded_size_of,
+			)
+			.unwrap();
+			assert_eq!(assignments.len(), 0);
+		});
+	}
+
+	// all the other solution-generation functions end up delegating to `mine_solution`, so if we
+	// demonstrate that `mine_solution` solutions are all trimmed to an acceptable length, then
+	// we know that higher-level functions will all also have short-enough solutions.
+	#[test]
+	fn mine_solution_solutions_always_within_acceptable_length() {
+		ExtBuilder::default().build_and_execute(|| {
+			roll_to_unsigned();
+
+			// how long would the default solution be?
+			let solution = MultiPhase::mine_solution().unwrap();
+			let max_length = <Runtime as MinerConfig>::MaxLength::get();
+			let solution_size = solution.0.solution.encoded_size();
+			assert!(solution_size <= max_length as usize);
+
+			// now set the max size to less than the actual size and regenerate
+			<Runtime as MinerConfig>::MaxLength::set(solution_size as u32 - 1);
+			let solution = MultiPhase::mine_solution().unwrap();
+			let max_length = <Runtime as MinerConfig>::MaxLength::get();
+			let solution_size = solution.0.solution.encoded_size();
+			assert!(solution_size <= max_length as usize);
+		});
+	}
+}
diff --git a/substrate/frame/election-provider-multi-phase/src/weights.rs b/substrate/frame/election-provider-multi-phase/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..be578fac8c435769de3b030a4c7fb20832786b83
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/src/weights.rs
@@ -0,0 +1,484 @@
+// 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.
+
+//! Autogenerated weights for pallet_election_provider_multi_phase
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_election_provider_multi_phase
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/election-provider-multi-phase/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_election_provider_multi_phase.
+pub trait WeightInfo {
+	fn on_initialize_nothing() -> Weight;
+	fn on_initialize_open_signed() -> Weight;
+	fn on_initialize_open_unsigned() -> Weight;
+	fn finalize_signed_phase_accept_solution() -> Weight;
+	fn finalize_signed_phase_reject_solution() -> Weight;
+	fn create_snapshot_internal(v: u32, t: u32, ) -> Weight;
+	fn elect_queued(a: u32, d: u32, ) -> Weight;
+	fn submit() -> Weight;
+	fn submit_unsigned(v: u32, t: u32, a: u32, d: u32, ) -> Weight;
+	fn feasibility_check(v: u32, t: u32, a: u32, d: u32, ) -> Weight;
+}
+
+/// Weights for pallet_election_provider_multi_phase using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CurrentPlannedSession (r:1 w:0)
+	/// Proof: Staking CurrentPlannedSession (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStartSessionIndex (r:1 w:0)
+	/// Proof: Staking ErasStartSessionIndex (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: Babe EpochIndex (r:1 w:0)
+	/// Proof: Babe EpochIndex (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Babe GenesisSlot (r:1 w:0)
+	/// Proof: Babe GenesisSlot (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Babe CurrentSlot (r:1 w:0)
+	/// Proof: Babe CurrentSlot (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Staking ForceEra (r:1 w:0)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	fn on_initialize_nothing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1028`
+		//  Estimated: `3481`
+		// Minimum execution time: 22_089_000 picoseconds.
+		Weight::from_parts(22_677_000, 3481)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	fn on_initialize_open_signed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `148`
+		//  Estimated: `1633`
+		// Minimum execution time: 11_986_000 picoseconds.
+		Weight::from_parts(12_445_000, 1633)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	fn on_initialize_open_unsigned() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `148`
+		//  Estimated: `1633`
+		// Minimum execution time: 12_988_000 picoseconds.
+		Weight::from_parts(13_281_000, 1633)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase QueuedSolution (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase QueuedSolution (max_values: Some(1), max_size: None, mode: Measured)
+	fn finalize_signed_phase_accept_solution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 32_659_000 picoseconds.
+		Weight::from_parts(33_281_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn finalize_signed_phase_reject_solution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 22_471_000 picoseconds.
+		Weight::from_parts(23_046_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[1000, 2000]`.
+	/// The range of component `t` is `[500, 1000]`.
+	fn create_snapshot_internal(v: u32, _t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 262_360_000 picoseconds.
+		Weight::from_parts(279_313_000, 0)
+			// Standard Error: 2_384
+			.saturating_add(Weight::from_parts(176_415, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionIndices (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionIndices (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionNextIndex (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionNextIndex (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionsMap (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionsMap (max_values: None, max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase QueuedSolution (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase QueuedSolution (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `a` is `[500, 800]`.
+	/// The range of component `d` is `[200, 400]`.
+	fn elect_queued(a: u32, d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `371 + a * (768 ±0) + d * (48 ±0)`
+		//  Estimated: `3923 + a * (768 ±0) + d * (49 ±0)`
+		// Minimum execution time: 301_283_000 picoseconds.
+		Weight::from_parts(324_586_000, 3923)
+			// Standard Error: 4_763
+			.saturating_add(Weight::from_parts(279_812, 0).saturating_mul(a.into()))
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(8_u64))
+			.saturating_add(Weight::from_parts(0, 768).saturating_mul(a.into()))
+			.saturating_add(Weight::from_parts(0, 49).saturating_mul(d.into()))
+	}
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TransactionPayment NextFeeMultiplier (r:1 w:0)
+	/// Proof: TransactionPayment NextFeeMultiplier (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionIndices (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionIndices (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionNextIndex (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionNextIndex (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionsMap (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionsMap (max_values: None, max_size: None, mode: Measured)
+	fn submit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `927`
+		//  Estimated: `2412`
+		// Minimum execution time: 52_276_000 picoseconds.
+		Weight::from_parts(53_846_000, 2412)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase QueuedSolution (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase QueuedSolution (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase MinimumUntrustedScore (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase MinimumUntrustedScore (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[1000, 2000]`.
+	/// The range of component `t` is `[500, 1000]`.
+	/// The range of component `a` is `[500, 800]`.
+	/// The range of component `d` is `[200, 400]`.
+	fn submit_unsigned(v: u32, t: u32, a: u32, _d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `253 + t * (32 ±0) + v * (553 ±0)`
+		//  Estimated: `1738 + t * (32 ±0) + v * (553 ±0)`
+		// Minimum execution time: 5_448_459_000 picoseconds.
+		Weight::from_parts(5_525_622_000, 1738)
+			// Standard Error: 21_478
+			.saturating_add(Weight::from_parts(256_345, 0).saturating_mul(v.into()))
+			// Standard Error: 63_648
+			.saturating_add(Weight::from_parts(5_103_224, 0).saturating_mul(a.into()))
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(t.into()))
+			.saturating_add(Weight::from_parts(0, 553).saturating_mul(v.into()))
+	}
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase MinimumUntrustedScore (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase MinimumUntrustedScore (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[1000, 2000]`.
+	/// The range of component `t` is `[500, 1000]`.
+	/// The range of component `a` is `[500, 800]`.
+	/// The range of component `d` is `[200, 400]`.
+	fn feasibility_check(v: u32, t: u32, a: u32, _d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `228 + t * (32 ±0) + v * (553 ±0)`
+		//  Estimated: `1713 + t * (32 ±0) + v * (553 ±0)`
+		// Minimum execution time: 4_724_399_000 picoseconds.
+		Weight::from_parts(4_886_472_000, 1713)
+			// Standard Error: 15_220
+			.saturating_add(Weight::from_parts(365_569, 0).saturating_mul(v.into()))
+			// Standard Error: 45_104
+			.saturating_add(Weight::from_parts(3_176_675, 0).saturating_mul(a.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(t.into()))
+			.saturating_add(Weight::from_parts(0, 553).saturating_mul(v.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CurrentPlannedSession (r:1 w:0)
+	/// Proof: Staking CurrentPlannedSession (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStartSessionIndex (r:1 w:0)
+	/// Proof: Staking ErasStartSessionIndex (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: Babe EpochIndex (r:1 w:0)
+	/// Proof: Babe EpochIndex (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Babe GenesisSlot (r:1 w:0)
+	/// Proof: Babe GenesisSlot (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Babe CurrentSlot (r:1 w:0)
+	/// Proof: Babe CurrentSlot (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Staking ForceEra (r:1 w:0)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	fn on_initialize_nothing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1028`
+		//  Estimated: `3481`
+		// Minimum execution time: 22_089_000 picoseconds.
+		Weight::from_parts(22_677_000, 3481)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	fn on_initialize_open_signed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `148`
+		//  Estimated: `1633`
+		// Minimum execution time: 11_986_000 picoseconds.
+		Weight::from_parts(12_445_000, 1633)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	fn on_initialize_open_unsigned() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `148`
+		//  Estimated: `1633`
+		// Minimum execution time: 12_988_000 picoseconds.
+		Weight::from_parts(13_281_000, 1633)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase QueuedSolution (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase QueuedSolution (max_values: Some(1), max_size: None, mode: Measured)
+	fn finalize_signed_phase_accept_solution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 32_659_000 picoseconds.
+		Weight::from_parts(33_281_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn finalize_signed_phase_reject_solution() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3593`
+		// Minimum execution time: 22_471_000 picoseconds.
+		Weight::from_parts(23_046_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[1000, 2000]`.
+	/// The range of component `t` is `[500, 1000]`.
+	fn create_snapshot_internal(v: u32, _t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 262_360_000 picoseconds.
+		Weight::from_parts(279_313_000, 0)
+			// Standard Error: 2_384
+			.saturating_add(Weight::from_parts(176_415, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionIndices (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionIndices (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionNextIndex (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionNextIndex (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionsMap (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionsMap (max_values: None, max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase QueuedSolution (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase QueuedSolution (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `a` is `[500, 800]`.
+	/// The range of component `d` is `[200, 400]`.
+	fn elect_queued(a: u32, d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `371 + a * (768 ±0) + d * (48 ±0)`
+		//  Estimated: `3923 + a * (768 ±0) + d * (49 ±0)`
+		// Minimum execution time: 301_283_000 picoseconds.
+		Weight::from_parts(324_586_000, 3923)
+			// Standard Error: 4_763
+			.saturating_add(Weight::from_parts(279_812, 0).saturating_mul(a.into()))
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(8_u64))
+			.saturating_add(Weight::from_parts(0, 768).saturating_mul(a.into()))
+			.saturating_add(Weight::from_parts(0, 49).saturating_mul(d.into()))
+	}
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TransactionPayment NextFeeMultiplier (r:1 w:0)
+	/// Proof: TransactionPayment NextFeeMultiplier (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionIndices (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionIndices (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionNextIndex (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionNextIndex (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SignedSubmissionsMap (r:0 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase SignedSubmissionsMap (max_values: None, max_size: None, mode: Measured)
+	fn submit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `927`
+		//  Estimated: `2412`
+		// Minimum execution time: 52_276_000 picoseconds.
+		Weight::from_parts(53_846_000, 2412)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase QueuedSolution (r:1 w:1)
+	/// Proof Skipped: ElectionProviderMultiPhase QueuedSolution (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase SnapshotMetadata (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase SnapshotMetadata (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase MinimumUntrustedScore (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase MinimumUntrustedScore (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[1000, 2000]`.
+	/// The range of component `t` is `[500, 1000]`.
+	/// The range of component `a` is `[500, 800]`.
+	/// The range of component `d` is `[200, 400]`.
+	fn submit_unsigned(v: u32, t: u32, a: u32, _d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `253 + t * (32 ±0) + v * (553 ±0)`
+		//  Estimated: `1738 + t * (32 ±0) + v * (553 ±0)`
+		// Minimum execution time: 5_448_459_000 picoseconds.
+		Weight::from_parts(5_525_622_000, 1738)
+			// Standard Error: 21_478
+			.saturating_add(Weight::from_parts(256_345, 0).saturating_mul(v.into()))
+			// Standard Error: 63_648
+			.saturating_add(Weight::from_parts(5_103_224, 0).saturating_mul(a.into()))
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(t.into()))
+			.saturating_add(Weight::from_parts(0, 553).saturating_mul(v.into()))
+	}
+	/// Storage: ElectionProviderMultiPhase DesiredTargets (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase DesiredTargets (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Snapshot (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Snapshot (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase Round (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase Round (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ElectionProviderMultiPhase MinimumUntrustedScore (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase MinimumUntrustedScore (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[1000, 2000]`.
+	/// The range of component `t` is `[500, 1000]`.
+	/// The range of component `a` is `[500, 800]`.
+	/// The range of component `d` is `[200, 400]`.
+	fn feasibility_check(v: u32, t: u32, a: u32, _d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `228 + t * (32 ±0) + v * (553 ±0)`
+		//  Estimated: `1713 + t * (32 ±0) + v * (553 ±0)`
+		// Minimum execution time: 4_724_399_000 picoseconds.
+		Weight::from_parts(4_886_472_000, 1713)
+			// Standard Error: 15_220
+			.saturating_add(Weight::from_parts(365_569, 0).saturating_mul(v.into()))
+			// Standard Error: 45_104
+			.saturating_add(Weight::from_parts(3_176_675, 0).saturating_mul(a.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(t.into()))
+			.saturating_add(Weight::from_parts(0, 553).saturating_mul(v.into()))
+	}
+}
diff --git a/substrate/frame/election-provider-multi-phase/test-staking-e2e/Cargo.toml b/substrate/frame/election-provider-multi-phase/test-staking-e2e/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..01644887759c05a448b323cf3f9daf4b8b28ea7a
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-election-provider-e2e-test"
+version = "1.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME election provider multi phase pallet tests with staking pallet, bags-list and session pallets"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dev-dependencies]
+parking_lot = "0.12.1"
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+scale-info = { version = "2.0.1", features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+sp-std = { version = "8.0.0", path = "../../../primitives/std" }
+sp-staking = { version = "4.0.0-dev", path = "../../../primitives/staking" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/npos-elections" }
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+
+frame-system = { version = "4.0.0-dev", path = "../../system" }
+frame-support = { version = "4.0.0-dev", path = "../../support" }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../../election-provider-support" }
+
+pallet-election-provider-multi-phase = { version = "4.0.0-dev", path = "../../election-provider-multi-phase" }
+pallet-staking = { version = "4.0.0-dev", path = "../../staking" }
+pallet-bags-list = { version = "4.0.0-dev", path = "../../bags-list" }
+pallet-balances = { version = "4.0.0-dev", path = "../../balances" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../../timestamp" }
+pallet-session = { version = "4.0.0-dev", path = "../../session" }
+
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
new file mode 100644
index 0000000000000000000000000000000000000000..e40bac3e9fc44adb37b0d8e527d4ac6eae460ed2
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/lib.rs
@@ -0,0 +1,389 @@
+// 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;
+
+pub(crate) const LOG_TARGET: &str = "tests::e2e-epm";
+
+use frame_support::{assert_err, assert_noop, assert_ok};
+use mock::*;
+use sp_core::Get;
+use sp_npos_elections::{to_supports, StakedAssignment};
+use sp_runtime::Perbill;
+
+use crate::mock::RuntimeOrigin;
+
+// syntactic sugar for logging.
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: crate::LOG_TARGET,
+			concat!("🛠�  ", $patter)  $(, $values)*
+		)
+	};
+}
+
+fn log_current_time() {
+	log!(
+		trace,
+		"block: {:?}, session: {:?}, era: {:?}, EPM phase: {:?} ts: {:?}",
+		System::block_number(),
+		Session::current_index(),
+		Staking::current_era(),
+		ElectionProviderMultiPhase::current_phase(),
+		Timestamp::now()
+	);
+}
+
+#[test]
+fn block_progression_works() {
+	let (mut ext, pool_state, _) = ExtBuilder::default().build_offchainify();
+
+	ext.execute_with(|| {
+		assert_eq!(active_era(), 0);
+		assert_eq!(Session::current_index(), 0);
+		assert!(ElectionProviderMultiPhase::current_phase().is_off());
+
+		assert!(start_next_active_era(pool_state.clone()).is_ok());
+		assert_eq!(active_era(), 1);
+		assert_eq!(Session::current_index(), <SessionsPerEra as Get<u32>>::get());
+
+		assert!(ElectionProviderMultiPhase::current_phase().is_off());
+
+		roll_to_epm_signed();
+		assert!(ElectionProviderMultiPhase::current_phase().is_signed());
+	});
+
+	let (mut ext, pool_state, _) = ExtBuilder::default().build_offchainify();
+
+	ext.execute_with(|| {
+		assert_eq!(active_era(), 0);
+		assert_eq!(Session::current_index(), 0);
+		assert!(ElectionProviderMultiPhase::current_phase().is_off());
+
+		assert!(start_next_active_era_delayed_solution(pool_state).is_ok());
+		// if the solution is delayed, EPM will end up in emergency mode..
+		assert!(ElectionProviderMultiPhase::current_phase().is_emergency());
+		// .. era won't progress..
+		assert_eq!(active_era(), 0);
+		// .. but session does.
+		assert_eq!(Session::current_index(), 2);
+	})
+}
+
+#[test]
+fn offchainify_works() {
+	use pallet_election_provider_multi_phase::QueuedSolution;
+
+	let staking_builder = StakingExtBuilder::default();
+	let epm_builder = EpmExtBuilder::default();
+	let (mut ext, pool_state, _) = ExtBuilder::default()
+		.epm(epm_builder)
+		.staking(staking_builder)
+		.build_offchainify();
+
+	ext.execute_with(|| {
+		// test ocw progression and solution queue if submission when unsigned phase submission is
+		// not delayed.
+		for _ in 0..100 {
+			roll_one(pool_state.clone(), false);
+			let current_phase = ElectionProviderMultiPhase::current_phase();
+
+			assert!(
+				match QueuedSolution::<Runtime>::get() {
+					Some(_) => current_phase.is_unsigned(),
+					None => !current_phase.is_unsigned(),
+				},
+				"solution must be queued *only* in unsigned phase"
+			);
+		}
+
+		// test ocw solution queue if submission in unsigned phase is delayed.
+		for _ in 0..100 {
+			roll_one(pool_state.clone(), true);
+			assert_eq!(
+				QueuedSolution::<Runtime>::get(),
+				None,
+				"solution must never be submitted and stored since it is delayed"
+			);
+		}
+	})
+}
+
+#[test]
+/// Replicates the Kusama incident of 8th Dec 2022 and its resolution through the governance
+/// fallback.
+///
+/// After enough slashes exceeded the `Staking::OffendingValidatorsThreshold`, the staking pallet
+/// set `Forcing::ForceNew`. When a new session starts, staking will start to force a new era and
+/// calls <EPM as election_provider>::elect(). If at this point EPM and the staking miners did not
+/// have enough time to queue a new solution (snapshot + solution submission), the election request
+/// fails. If there is no election fallback mechanism in place, EPM enters in emergency mode.
+/// Recovery: Once EPM is in emergency mode, subsequent calls to `elect()` will fail until a new
+/// solution is added to EPM's `QueuedSolution` queue. This can be achieved through
+/// `Call::set_emergency_election_result` or `Call::governance_fallback` dispatchables. Once a new
+/// solution is added to the queue, EPM phase transitions to `Phase::Off` and the election flow
+/// restarts. Note that in this test case, the emergency throttling is disabled.
+fn enters_emergency_phase_after_forcing_before_elect() {
+	let epm_builder = EpmExtBuilder::default().disable_emergency_throttling();
+	let (mut ext, pool_state, _) = ExtBuilder::default().epm(epm_builder).build_offchainify();
+
+	ext.execute_with(|| {
+		log!(
+			trace,
+			"current validators (staking): {:?}",
+			<Runtime as pallet_staking::SessionInterface<AccountId>>::validators()
+		);
+		let session_validators_before = Session::validators();
+
+		roll_to_epm_off();
+		assert!(ElectionProviderMultiPhase::current_phase().is_off());
+
+		assert_eq!(pallet_staking::ForceEra::<Runtime>::get(), pallet_staking::Forcing::NotForcing);
+		// slashes so that staking goes into `Forcing::ForceNew`.
+		slash_through_offending_threshold();
+
+		assert_eq!(pallet_staking::ForceEra::<Runtime>::get(), pallet_staking::Forcing::ForceNew);
+
+		advance_session_delayed_solution(pool_state.clone());
+		assert!(ElectionProviderMultiPhase::current_phase().is_emergency());
+		log_current_time();
+
+		let era_before_delayed_next = Staking::current_era();
+		// try to advance 2 eras.
+		assert!(start_next_active_era_delayed_solution(pool_state.clone()).is_ok());
+		assert_eq!(Staking::current_era(), era_before_delayed_next);
+		assert!(start_next_active_era(pool_state).is_err());
+		assert_eq!(Staking::current_era(), era_before_delayed_next);
+
+		// EPM is still in emergency phase.
+		assert!(ElectionProviderMultiPhase::current_phase().is_emergency());
+
+		// session validator set remains the same.
+		assert_eq!(Session::validators(), session_validators_before);
+
+		// performs recovery through the set emergency result.
+		let supports = to_supports(&vec![
+			StakedAssignment { who: 21, distribution: vec![(21, 10)] },
+			StakedAssignment { who: 31, distribution: vec![(21, 10), (31, 10)] },
+			StakedAssignment { who: 41, distribution: vec![(41, 10)] },
+		]);
+		assert!(ElectionProviderMultiPhase::set_emergency_election_result(
+			RuntimeOrigin::root(),
+			supports
+		)
+		.is_ok());
+
+		// EPM can now roll to signed phase to proceed with elections. The validator set is the
+		// expected (ie. set through `set_emergency_election_result`).
+		roll_to_epm_signed();
+		//assert!(ElectionProviderMultiPhase::current_phase().is_signed());
+		assert_eq!(Session::validators(), vec![21, 31, 41]);
+		assert_eq!(Staking::current_era(), era_before_delayed_next.map(|e| e + 1));
+	});
+}
+
+#[test]
+/// Continuously slash 10% of the active validators per era.
+///
+/// Since the `OffendingValidatorsThreshold` is only checked per era staking does not force a new
+/// era even as the number of active validators is decreasing across eras. When processing a new
+/// slash, staking calculates the offending threshold based on the length of the current list of
+/// active validators. Thus, slashing a percentage of the current validators that is lower than
+/// `OffendingValidatorsThreshold` will never force a new era. However, as the slashes progress, if
+/// the subsequent elections do not meet the minimum election untrusted score, the election will
+/// fail and enter in emenergency mode.
+fn continous_slashes_below_offending_threshold() {
+	let staking_builder = StakingExtBuilder::default().validator_count(10);
+	let epm_builder = EpmExtBuilder::default().disable_emergency_throttling();
+
+	let (mut ext, pool_state, _) = ExtBuilder::default()
+		.epm(epm_builder)
+		.staking(staking_builder)
+		.build_offchainify();
+
+	ext.execute_with(|| {
+		assert_eq!(Session::validators().len(), 10);
+		let mut active_validator_set = Session::validators();
+
+		roll_to_epm_signed();
+
+		// set a minimum election score.
+		assert!(set_minimum_election_score(500, 1000, 500).is_ok());
+
+		// slash 10% of the active validators and progress era until the minimum trusted score
+		// is reached.
+		while active_validator_set.len() > 0 {
+			let slashed = slash_percentage(Perbill::from_percent(10));
+			assert_eq!(slashed.len(), 1);
+
+			// break loop when era does not progress; EPM is in emergency phase as election
+			// failed due to election minimum score.
+			if start_next_active_era(pool_state.clone()).is_err() {
+				assert!(ElectionProviderMultiPhase::current_phase().is_emergency());
+				break
+			}
+
+			active_validator_set = Session::validators();
+
+			log!(
+				trace,
+				"slashed 10% of active validators ({:?}). After slash: {:?}",
+				slashed,
+				active_validator_set
+			);
+		}
+	});
+}
+
+#[test]
+/// Slashed validator sets intentions in the same era of slashing.
+///
+/// When validators are slashed, they are chilled and removed from the current `VoterList`. Thus,
+/// the slashed validator should not be considered in the next validator set. However, if the
+/// slashed validator sets its intention to validate again in the same era when it was slashed and
+/// chilled, the validator may not be removed from the active validator set across eras, provided
+/// it would selected in the subsequent era if there was no slash. Nominators of the slashed
+/// validator will also be slashed and chilled, as expected, but the nomination intentions will
+/// remain after the validator re-set the intention to be validating again.
+///
+/// This behaviour is due to removing implicit chill upon slash
+/// <https://github.com/paritytech/substrate/pull/12420>.
+///
+/// Related to <https://github.com/paritytech/substrate/issues/13714>.
+fn set_validation_intention_after_chilled() {
+	use frame_election_provider_support::SortedListProvider;
+	use pallet_staking::{Event, Forcing, Nominators};
+
+	let (mut ext, pool_state, _) = ExtBuilder::default()
+		.epm(EpmExtBuilder::default())
+		.staking(StakingExtBuilder::default())
+		.build_offchainify();
+
+	ext.execute_with(|| {
+		assert_eq!(active_era(), 0);
+		// validator is part of the validator set.
+		assert!(Session::validators().contains(&41));
+		assert!(<Runtime as pallet_staking::Config>::VoterList::contains(&41));
+
+		// nominate validator 81.
+		assert_ok!(Staking::nominate(RuntimeOrigin::signed(21), vec![41]));
+		assert_eq!(Nominators::<Runtime>::get(21).unwrap().targets, vec![41]);
+
+		// validator is slashed. it is removed from the `VoterList` through chilling but in the
+		// current era, the validator is still part of the active validator set.
+		add_slash(&41);
+		assert!(Session::validators().contains(&41));
+		assert!(!<Runtime as pallet_staking::Config>::VoterList::contains(&41));
+		assert_eq!(
+			staking_events(),
+			[
+				Event::Chilled { stash: 41 },
+				Event::ForceEra { mode: Forcing::ForceNew },
+				Event::SlashReported {
+					validator: 41,
+					slash_era: 0,
+					fraction: Perbill::from_percent(10)
+				}
+			],
+		);
+
+		// after the nominator is slashed and chilled, the nominations remain.
+		assert_eq!(Nominators::<Runtime>::get(21).unwrap().targets, vec![41]);
+
+		// validator sets intention to stake again in the same era it was chilled.
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(41), Default::default()));
+
+		// progress era and check that the slashed validator is still part of the validator
+		// set.
+		assert!(start_next_active_era(pool_state).is_ok());
+		assert_eq!(active_era(), 1);
+		assert!(Session::validators().contains(&41));
+		assert!(<Runtime as pallet_staking::Config>::VoterList::contains(&41));
+
+		// nominations are still active as before the slash.
+		assert_eq!(Nominators::<Runtime>::get(21).unwrap().targets, vec![41]);
+	})
+}
+
+#[test]
+/// Active ledger balance may fall below ED if account chills before unbounding.
+///
+/// Unbonding call fails if the remaining ledger's stash balance falls below the existential
+/// deposit. However, if the stash is chilled before unbonding, the ledger's active balance may
+/// be below ED. In that case, only the stash (or root) can kill the ledger entry by calling
+/// `withdraw_unbonded` after the bonding period has passed.
+///
+/// Related to <https://github.com/paritytech/substrate/issues/14246>.
+fn ledger_consistency_active_balance_below_ed() {
+	use pallet_staking::{Error, Event};
+
+	let (mut ext, pool_state, _) =
+		ExtBuilder::default().staking(StakingExtBuilder::default()).build_offchainify();
+
+	ext.execute_with(|| {
+		assert_eq!(Staking::ledger(&11).unwrap().active, 1000);
+
+		// unbonding total of active stake fails because the active ledger balance would fall
+		// below the `MinNominatorBond`.
+		assert_noop!(
+			Staking::unbond(RuntimeOrigin::signed(11), 1000),
+			Error::<Runtime>::InsufficientBond
+		);
+
+		// however, chilling works as expected.
+		assert_ok!(Staking::chill(RuntimeOrigin::signed(11)));
+
+		// now unbonding the full active balance works, since remainer of the active balance is
+		// not enforced to be below `MinNominatorBond` if the stash has been chilled.
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 1000));
+
+		// the active balance of the ledger entry is 0, while total balance is 1000 until
+		// `withdraw_unbonded` is called.
+		assert_eq!(Staking::ledger(&11).unwrap().active, 0);
+		assert_eq!(Staking::ledger(&11).unwrap().total, 1000);
+
+		// trying to withdraw the unbonded balance won't work yet because not enough bonding
+		// eras have passed.
+		assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(11), 0));
+		assert_eq!(Staking::ledger(&11).unwrap().total, 1000);
+
+		// tries to reap stash after chilling, which fails since the stash total balance is
+		// above ED.
+		assert_err!(
+			Staking::reap_stash(RuntimeOrigin::signed(11), 21, 0),
+			Error::<Runtime>::FundedTarget,
+		);
+
+		// check the events so far: 1x Chilled and 1x Unbounded
+		assert_eq!(
+			staking_events(),
+			[Event::Chilled { stash: 11 }, Event::Unbonded { stash: 11, amount: 1000 }]
+		);
+
+		// after advancing `BondingDuration` eras, the `withdraw_unbonded` will unlock the
+		// chunks and the ledger entry will be cleared, since the ledger active balance is 0.
+		advance_eras(
+			<Runtime as pallet_staking::Config>::BondingDuration::get() as usize,
+			pool_state,
+		);
+		assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(11), 0));
+		assert_eq!(Staking::ledger(&11), None);
+	});
+}
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
new file mode 100644
index 0000000000000000000000000000000000000000..9c3511ae35751527eb7c702eb0e51cdd7a4577e5
--- /dev/null
+++ b/substrate/frame/election-provider-multi-phase/test-staking-e2e/src/mock.rs
@@ -0,0 +1,886 @@
+// 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.
+
+#![allow(dead_code)]
+
+use frame_support::{
+	assert_ok, dispatch::UnfilteredDispatchable, parameter_types, traits, traits::Hooks,
+	weights::constants,
+};
+use frame_system::EnsureRoot;
+use sp_core::{ConstU32, Get};
+use sp_npos_elections::{ElectionScore, VoteWeight};
+use sp_runtime::{
+	offchain::{
+		testing::{OffchainState, PoolState, TestOffchainExt, TestTransactionPoolExt},
+		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
+	},
+	testing,
+	traits::Zero,
+	transaction_validity, BuildStorage, PerU16, Perbill,
+};
+use sp_staking::{
+	offence::{DisableStrategy, OffenceDetails, OnOffenceHandler},
+	EraIndex, SessionIndex,
+};
+use sp_std::prelude::*;
+use std::collections::BTreeMap;
+
+use codec::Decode;
+use frame_election_provider_support::{
+	bounds::ElectionBoundsBuilder, onchain, ElectionDataProvider, ExtendedBalance,
+	SequentialPhragmen, Weight,
+};
+use pallet_election_provider_multi_phase::{
+	unsigned::MinerConfig, Call, ElectionCompute, QueuedSolution, SolutionAccuracyOf,
+};
+use pallet_staking::StakerStatus;
+use parking_lot::RwLock;
+use std::sync::Arc;
+
+use frame_support::derive_impl;
+
+use crate::{log, log_current_time};
+
+pub const INIT_TIMESTAMP: BlockNumber = 30_000;
+pub const BLOCK_TIME: BlockNumber = 1000;
+
+type Block = frame_system::mocking::MockBlockU32<Runtime>;
+type Extrinsic = testing::TestXt<RuntimeCall, ()>;
+
+frame_support::construct_runtime!(
+	pub enum Runtime
+	{
+		System: frame_system,
+		ElectionProviderMultiPhase: pallet_election_provider_multi_phase,
+		Staking: pallet_staking,
+		Balances: pallet_balances,
+		BagsList: pallet_bags_list,
+		Session: pallet_session,
+		Historical: pallet_session::historical,
+		Timestamp: pallet_timestamp,
+	}
+);
+
+pub(crate) type AccountId = u64;
+pub(crate) type AccountIndex = u32;
+pub(crate) type BlockNumber = u32;
+pub(crate) type Balance = u64;
+pub(crate) type VoterIndex = u16;
+pub(crate) type TargetIndex = u16;
+pub(crate) type Moment = u32;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Runtime {
+	type Block = Block;
+	type BlockHashCount = ConstU32<10>;
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+
+	type AccountData = pallet_balances::AccountData<Balance>;
+}
+
+const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
+parameter_types! {
+	pub static ExistentialDeposit: Balance = 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),
+			NORMAL_DISPATCH_RATIO,
+		);
+}
+
+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 MaxHolds = ConstU32<1>;
+	type MaxFreezes = traits::ConstU32<1>;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type FreezeIdentifier = ();
+	type WeightInfo = ();
+}
+
+impl pallet_timestamp::Config for Runtime {
+	type Moment = Moment;
+	type OnTimestampSet = ();
+	type MinimumPeriod = traits::ConstU32<5>;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub static Period: u32 = 30;
+	pub static Offset: u32 = 0;
+}
+
+sp_runtime::impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub other: OtherSessionHandler,
+	}
+}
+
+impl pallet_session::Config for Runtime {
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Runtime, Staking>;
+	type Keys = SessionKeys;
+	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+	type SessionHandler = (OtherSessionHandler,);
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = AccountId;
+	type ValidatorIdOf = pallet_staking::StashOf<Runtime>;
+	type WeightInfo = ();
+}
+impl pallet_session::historical::Config for Runtime {
+	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Runtime>;
+}
+
+frame_election_provider_support::generate_solution_type!(
+	#[compact]
+	pub struct MockNposSolution::<
+		VoterIndex = VoterIndex,
+		TargetIndex = TargetIndex,
+		Accuracy = PerU16,
+		MaxVoters = ConstU32::<2_000>
+	>(16)
+);
+
+parameter_types! {
+	pub static SignedPhase: BlockNumber = 10;
+	pub static UnsignedPhase: BlockNumber = 10;
+	// we expect a minimum of 3 blocks in signed phase and unsigned phases before trying
+	// enetering in emergency phase after the election failed.
+	pub static MinBlocksBeforeEmergency: BlockNumber = 3;
+	pub static MaxActiveValidators: u32 = 1000;
+	pub static OffchainRepeat: u32 = 5;
+	pub static MinerMaxLength: u32 = 256;
+	pub static MinerMaxWeight: Weight = BlockWeights::get().max_block;
+	pub static TransactionPriority: transaction_validity::TransactionPriority = 1;
+	#[derive(Debug)]
+	pub static MaxWinners: u32 = 100;
+	pub static ElectionBounds: frame_election_provider_support::bounds::ElectionBounds = ElectionBoundsBuilder::default()
+		.voters_count(1_000.into()).targets_count(1_000.into()).build();
+}
+
+impl pallet_election_provider_multi_phase::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type EstimateCallFee = frame_support::traits::ConstU32<8>;
+	type SignedPhase = SignedPhase;
+	type UnsignedPhase = UnsignedPhase;
+	type BetterSignedThreshold = ();
+	type BetterUnsignedThreshold = ();
+	type OffchainRepeat = OffchainRepeat;
+	type MinerTxPriority = TransactionPriority;
+	type MinerConfig = Self;
+	type SignedMaxSubmissions = ConstU32<10>;
+	type SignedRewardBase = ();
+	type SignedDepositBase = ();
+	type SignedDepositByte = ();
+	type SignedMaxRefunds = ConstU32<3>;
+	type SignedDepositWeight = ();
+	type SignedMaxWeight = ();
+	type SlashHandler = ();
+	type RewardHandler = ();
+	type DataProvider = Staking;
+	type Fallback =
+		frame_election_provider_support::NoElection<(AccountId, BlockNumber, Staking, MaxWinners)>;
+	type GovernanceFallback = onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type Solver = SequentialPhragmen<AccountId, SolutionAccuracyOf<Runtime>, ()>;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type MaxWinners = MaxWinners;
+	type ElectionBounds = ElectionBounds;
+	type BenchmarkingConfig = NoopElectionProviderBenchmarkConfig;
+	type WeightInfo = ();
+}
+
+impl MinerConfig for Runtime {
+	type AccountId = AccountId;
+	type Solution = MockNposSolution;
+	type MaxVotesPerVoter =
+	<<Self as pallet_election_provider_multi_phase::Config>::DataProvider as ElectionDataProvider>::MaxVotesPerVoter;
+	type MaxLength = MinerMaxLength;
+	type MaxWeight = MinerMaxWeight;
+	type MaxWinners = MaxWinners;
+
+	fn solution_weight(_v: u32, _t: u32, _a: u32, _d: u32) -> Weight {
+		Weight::zero()
+	}
+}
+
+const THRESHOLDS: [VoteWeight; 9] = [10, 20, 30, 40, 50, 60, 1_000, 2_000, 10_000];
+
+parameter_types! {
+	pub static BagThresholds: &'static [sp_npos_elections::VoteWeight] = &THRESHOLDS;
+	pub const SessionsPerEra: sp_staking::SessionIndex = 2;
+	pub const BondingDuration: sp_staking::EraIndex = 28;
+	pub const SlashDeferDuration: sp_staking::EraIndex = 7; // 1/4 the bonding duration.
+	pub const MaxNominatorRewardedPerValidator: u32 = 256;
+	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(40);
+	pub HistoryDepth: u32 = 84;
+}
+
+impl pallet_bags_list::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type ScoreProvider = Staking;
+	type BagThresholds = BagThresholds;
+	type Score = VoteWeight;
+}
+
+/// Upper limit on the number of NPOS nominations.
+const MAX_QUOTA_NOMINATIONS: u32 = 16;
+
+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;
+	type AdminOrigin = EnsureRoot<AccountId>; // root can cancel slashes
+	type SessionInterface = Self;
+	type EraPayout = ();
+	type NextNewSession = Session;
+	type MaxNominatorRewardedPerValidator = MaxNominatorRewardedPerValidator;
+	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+	type ElectionProvider = ElectionProviderMultiPhase;
+	type GenesisElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type VoterList = BagsList;
+	type NominationsQuota = pallet_staking::FixedNominationsQuota<MAX_QUOTA_NOMINATIONS>;
+	type TargetList = pallet_staking::UseValidatorsMap<Self>;
+	type MaxUnlockingChunks = ConstU32<32>;
+	type HistoryDepth = HistoryDepth;
+	type EventListeners = ();
+	type WeightInfo = pallet_staking::weights::SubstrateWeight<Runtime>;
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+}
+
+impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Runtime
+where
+	RuntimeCall: From<LocalCall>,
+{
+	type OverarchingCall = RuntimeCall;
+	type Extrinsic = Extrinsic;
+}
+
+pub struct OnChainSeqPhragmen;
+
+parameter_types! {
+	pub static VotersBound: u32 = 600;
+	pub static TargetsBound: u32 = 400;
+}
+
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Runtime;
+	type Solver = SequentialPhragmen<
+		AccountId,
+		pallet_election_provider_multi_phase::SolutionAccuracyOf<Runtime>,
+	>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = MaxWinners;
+	type Bounds = ElectionBounds;
+}
+
+pub struct NoopElectionProviderBenchmarkConfig;
+
+impl pallet_election_provider_multi_phase::BenchmarkingConfig
+	for NoopElectionProviderBenchmarkConfig
+{
+	const VOTERS: [u32; 2] = [0, 0];
+	const TARGETS: [u32; 2] = [0, 0];
+	const ACTIVE_VOTERS: [u32; 2] = [0, 0];
+	const DESIRED_TARGETS: [u32; 2] = [0, 0];
+	const SNAPSHOT_MAXIMUM_VOTERS: u32 = 0;
+	const MINER_MAXIMUM_VOTERS: u32 = 0;
+	const MAXIMUM_TARGETS: u32 = 0;
+}
+
+pub struct OtherSessionHandler;
+impl traits::OneSessionHandler<AccountId> for OtherSessionHandler {
+	type Key = testing::UintAuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(_: I)
+	where
+		I: Iterator<Item = (&'a AccountId, Self::Key)>,
+		AccountId: 'a,
+	{
+	}
+
+	fn on_new_session<'a, I: 'a>(_: bool, _: I, _: I)
+	where
+		I: Iterator<Item = (&'a AccountId, Self::Key)>,
+		AccountId: 'a,
+	{
+	}
+
+	fn on_disabled(_validator_index: u32) {}
+}
+
+impl sp_runtime::BoundToRuntimeAppPublic for OtherSessionHandler {
+	type Public = testing::UintAuthorityId;
+}
+
+pub struct StakingExtBuilder {
+	validator_count: u32,
+	minimum_validator_count: u32,
+	min_nominator_bond: Balance,
+	min_validator_bond: Balance,
+	status: BTreeMap<AccountId, StakerStatus<AccountId>>,
+	stakes: BTreeMap<AccountId, Balance>,
+	stakers: Vec<(AccountId, AccountId, Balance, StakerStatus<AccountId>)>,
+}
+
+impl Default for StakingExtBuilder {
+	fn default() -> Self {
+		let stakers = vec![
+			// (stash, ctrl, stake, status)
+			// these two will be elected in the default test where we elect 2.
+			(11, 11, 1000, StakerStatus::<AccountId>::Validator),
+			(21, 21, 1000, StakerStatus::<AccountId>::Validator),
+			// loser validators if validator_count() is default.
+			(31, 31, 500, StakerStatus::<AccountId>::Validator),
+			(41, 41, 1500, StakerStatus::<AccountId>::Validator),
+			(51, 51, 1500, StakerStatus::<AccountId>::Validator),
+			(61, 61, 1500, StakerStatus::<AccountId>::Validator),
+			(71, 71, 1500, StakerStatus::<AccountId>::Validator),
+			(81, 81, 1500, StakerStatus::<AccountId>::Validator),
+			(91, 91, 1500, StakerStatus::<AccountId>::Validator),
+			(101, 101, 500, StakerStatus::<AccountId>::Validator),
+			// an idle validator
+			(201, 201, 1000, StakerStatus::<AccountId>::Idle),
+		];
+
+		Self {
+			validator_count: 2,
+			minimum_validator_count: 0,
+			min_nominator_bond: ExistentialDeposit::get(),
+			min_validator_bond: ExistentialDeposit::get(),
+			status: Default::default(),
+			stakes: Default::default(),
+			stakers,
+		}
+	}
+}
+
+impl StakingExtBuilder {
+	pub fn validator_count(mut self, n: u32) -> Self {
+		self.validator_count = n;
+		self
+	}
+}
+
+pub struct EpmExtBuilder {}
+
+impl Default for EpmExtBuilder {
+	fn default() -> Self {
+		EpmExtBuilder {}
+	}
+}
+
+impl EpmExtBuilder {
+	pub fn disable_emergency_throttling(self) -> Self {
+		<MinBlocksBeforeEmergency>::set(0);
+		self
+	}
+
+	pub fn phases(self, signed: BlockNumber, unsigned: BlockNumber) -> Self {
+		<SignedPhase>::set(signed);
+		<UnsignedPhase>::set(unsigned);
+		self
+	}
+}
+
+pub struct BalancesExtBuilder {
+	balances: Vec<(AccountId, Balance)>,
+}
+
+impl Default for BalancesExtBuilder {
+	fn default() -> Self {
+		let balances = vec![
+			// (account_id, balance)
+			(1, 10),
+			(2, 20),
+			(3, 300),
+			(4, 400),
+			// controllers (still used in some tests. Soon to be deprecated).
+			(10, 100),
+			(20, 100),
+			(30, 100),
+			(40, 100),
+			(50, 100),
+			(60, 100),
+			(70, 100),
+			(80, 100),
+			(90, 100),
+			(100, 100),
+			(200, 100),
+			// stashes
+			(11, 1000),
+			(21, 2000),
+			(31, 3000),
+			(41, 4000),
+			(51, 5000),
+			(61, 6000),
+			(71, 7000),
+			(81, 8000),
+			(91, 9000),
+			(101, 10000),
+			(201, 20000),
+			// This allows us to have a total_payout different from 0.
+			(999, 1_000_000_000_000),
+		];
+		Self { balances }
+	}
+}
+
+pub struct ExtBuilder {
+	staking_builder: StakingExtBuilder,
+	epm_builder: EpmExtBuilder,
+	balances_builder: BalancesExtBuilder,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			staking_builder: StakingExtBuilder::default(),
+			epm_builder: EpmExtBuilder::default(),
+			balances_builder: BalancesExtBuilder::default(),
+		}
+	}
+}
+
+impl ExtBuilder {
+	pub fn build(&self) -> sp_io::TestExternalities {
+		sp_tracing::try_init_simple();
+		let mut storage =
+			frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+		let _ = pallet_balances::GenesisConfig::<Runtime> {
+			balances: self.balances_builder.balances.clone(),
+		}
+		.assimilate_storage(&mut storage);
+
+		let mut stakers = self.staking_builder.stakers.clone();
+		self.staking_builder.status.clone().into_iter().for_each(|(stash, status)| {
+			let (_, _, _, ref mut prev_status) = stakers
+				.iter_mut()
+				.find(|s| s.0 == stash)
+				.expect("set_status staker should exist; qed");
+			*prev_status = status;
+		});
+		// replaced any of the stakes if needed.
+		self.staking_builder.stakes.clone().into_iter().for_each(|(stash, stake)| {
+			let (_, _, ref mut prev_stake, _) = stakers
+				.iter_mut()
+				.find(|s| s.0 == stash)
+				.expect("set_stake staker should exits; qed.");
+			*prev_stake = stake;
+		});
+
+		let _ = pallet_staking::GenesisConfig::<Runtime> {
+			stakers: stakers.clone(),
+			validator_count: self.staking_builder.validator_count,
+			minimum_validator_count: self.staking_builder.minimum_validator_count,
+			slash_reward_fraction: Perbill::from_percent(10),
+			min_nominator_bond: self.staking_builder.min_nominator_bond,
+			min_validator_bond: self.staking_builder.min_validator_bond,
+			..Default::default()
+		}
+		.assimilate_storage(&mut storage);
+
+		let _ = pallet_session::GenesisConfig::<Runtime> {
+			// set the keys for the first session.
+			keys: stakers
+				.into_iter()
+				.map(|(id, ..)| (id, id, SessionKeys { other: (id as u64).into() }))
+				.collect(),
+		}
+		.assimilate_storage(&mut storage);
+
+		let mut ext = sp_io::TestExternalities::from(storage);
+
+		// We consider all test to start after timestamp is initialized This must be ensured by
+		// having `timestamp::on_initialize` called before `staking::on_initialize`.
+		ext.execute_with(|| {
+			System::set_block_number(1);
+			Session::on_initialize(1);
+			<Staking as Hooks<u32>>::on_initialize(1);
+			Timestamp::set_timestamp(INIT_TIMESTAMP);
+		});
+
+		ext
+	}
+
+	pub fn staking(mut self, builder: StakingExtBuilder) -> Self {
+		self.staking_builder = builder;
+		self
+	}
+
+	pub fn epm(mut self, builder: EpmExtBuilder) -> Self {
+		self.epm_builder = builder;
+		self
+	}
+
+	pub fn balances(mut self, builder: BalancesExtBuilder) -> Self {
+		self.balances_builder = builder;
+		self
+	}
+
+	pub fn build_offchainify(
+		self,
+	) -> (sp_io::TestExternalities, Arc<RwLock<PoolState>>, Arc<RwLock<OffchainState>>) {
+		// add offchain and pool externality extensions.
+		let mut ext = self.build();
+		let (offchain, offchain_state) = TestOffchainExt::new();
+		let (pool, pool_state) = TestTransactionPoolExt::new();
+
+		ext.register_extension(OffchainDbExt::new(offchain.clone()));
+		ext.register_extension(OffchainWorkerExt::new(offchain));
+		ext.register_extension(TransactionPoolExt::new(pool));
+
+		(ext, pool_state, offchain_state)
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		let mut ext = self.build();
+		ext.execute_with(test);
+
+		#[cfg(feature = "try-runtime")]
+		ext.execute_with(|| {
+			let bn = System::block_number();
+
+			assert_ok!(<MultiPhase as Hooks<u64>>::try_state(bn));
+			assert_ok!(<Staking as Hooks<u64>>::try_state(bn));
+			assert_ok!(<Session as Hooks<u64>>::try_state(bn));
+		});
+	}
+}
+
+// Progress to given block, triggering session and era changes as we progress and ensuring that
+// there is a solution queued when expected.
+pub fn roll_to(n: BlockNumber, delay_solution: bool) {
+	for b in (System::block_number()) + 1..=n {
+		System::set_block_number(b);
+		Session::on_initialize(b);
+		Timestamp::set_timestamp(System::block_number() * BLOCK_TIME + INIT_TIMESTAMP);
+
+		// TODO(gpestana): implement a realistic OCW worker insted of simulating it
+		// https://github.com/paritytech/substrate/issues/13589
+		// if there's no solution queued and the solution should not be delayed, try mining and
+		// queue a solution.
+		if ElectionProviderMultiPhase::current_phase().is_signed() && !delay_solution {
+			let _ = try_queue_solution(ElectionCompute::Signed).map_err(|e| {
+				log!(info, "failed to mine/queue solution: {:?}", e);
+			});
+		}
+		ElectionProviderMultiPhase::on_initialize(b);
+
+		Staking::on_initialize(b);
+		if b != n {
+			Staking::on_finalize(System::block_number());
+		}
+
+		log_current_time();
+	}
+}
+
+// Progress to given block, triggering session and era changes as we progress and ensuring that
+// there is a solution queued when expected.
+pub fn roll_to_with_ocw(n: BlockNumber, pool: Arc<RwLock<PoolState>>, delay_solution: bool) {
+	for b in (System::block_number()) + 1..=n {
+		System::set_block_number(b);
+		Session::on_initialize(b);
+		Timestamp::set_timestamp(System::block_number() * BLOCK_TIME + INIT_TIMESTAMP);
+
+		ElectionProviderMultiPhase::on_initialize(b);
+		ElectionProviderMultiPhase::offchain_worker(b);
+
+		if !delay_solution && pool.read().transactions.len() > 0 {
+			// decode submit_unsigned callable that may be queued in the pool by ocw. skip all
+			// other extrinsics in the pool.
+			for encoded in &pool.read().transactions {
+				let extrinsic = Extrinsic::decode(&mut &encoded[..]).unwrap();
+
+				let _ = match extrinsic.call {
+					RuntimeCall::ElectionProviderMultiPhase(
+						call @ Call::submit_unsigned { .. },
+					) => {
+						// call submit_unsigned callable in OCW pool.
+						crate::assert_ok!(call.dispatch_bypass_filter(RuntimeOrigin::none()));
+					},
+					_ => (),
+				};
+			}
+
+			pool.try_write().unwrap().transactions.clear();
+		}
+
+		Staking::on_initialize(b);
+		if b != n {
+			Staking::on_finalize(System::block_number());
+		}
+
+		log_current_time();
+	}
+}
+// helper to progress one block ahead.
+pub fn roll_one(pool: Arc<RwLock<PoolState>>, delay_solution: bool) {
+	let bn = System::block_number().saturating_add(1);
+	roll_to_with_ocw(bn, pool, delay_solution);
+}
+
+/// Progresses from the current block number (whatever that may be) to the block where the session
+/// `session_index` starts.
+pub(crate) fn start_session(
+	session_index: SessionIndex,
+	pool: Arc<RwLock<PoolState>>,
+	delay_solution: bool,
+) {
+	let end = if Offset::get().is_zero() {
+		Period::get() * session_index
+	} else {
+		Offset::get() * session_index + Period::get() * session_index
+	};
+
+	assert!(end >= System::block_number());
+
+	roll_to_with_ocw(end, pool, delay_solution);
+
+	// session must have progressed properly.
+	assert_eq!(
+		Session::current_index(),
+		session_index,
+		"current session index = {}, expected = {}",
+		Session::current_index(),
+		session_index,
+	);
+}
+
+/// Go one session forward.
+pub(crate) fn advance_session(pool: Arc<RwLock<PoolState>>) {
+	let current_index = Session::current_index();
+	start_session(current_index + 1, pool, false);
+}
+
+pub(crate) fn advance_session_delayed_solution(pool: Arc<RwLock<PoolState>>) {
+	let current_index = Session::current_index();
+	start_session(current_index + 1, pool, true);
+}
+
+pub(crate) fn start_next_active_era(pool: Arc<RwLock<PoolState>>) -> Result<(), ()> {
+	start_active_era(active_era() + 1, pool, false)
+}
+
+pub(crate) fn start_next_active_era_delayed_solution(
+	pool: Arc<RwLock<PoolState>>,
+) -> Result<(), ()> {
+	start_active_era(active_era() + 1, pool, true)
+}
+
+pub(crate) fn advance_eras(n: usize, pool: Arc<RwLock<PoolState>>) {
+	for _ in 0..n {
+		assert_ok!(start_next_active_era(pool.clone()));
+	}
+}
+
+/// Progress until the given era.
+pub(crate) fn start_active_era(
+	era_index: EraIndex,
+	pool: Arc<RwLock<PoolState>>,
+	delay_solution: bool,
+) -> Result<(), ()> {
+	let era_before = current_era();
+
+	start_session((era_index * <SessionsPerEra as Get<u32>>::get()).into(), pool, delay_solution);
+
+	log!(
+		info,
+		"start_active_era - era_before: {}, current era: {} -> progress to: {} -> after era: {}",
+		era_before,
+		active_era(),
+		era_index,
+		current_era(),
+	);
+
+	// if the solution was not delayed, era should have progressed.
+	if !delay_solution && (active_era() != era_index || current_era() != active_era()) {
+		Err(())
+	} else {
+		Ok(())
+	}
+}
+
+pub(crate) fn active_era() -> EraIndex {
+	Staking::active_era().unwrap().index
+}
+
+pub(crate) fn current_era() -> EraIndex {
+	Staking::current_era().unwrap()
+}
+
+// Fast forward until EPM signed phase.
+pub fn roll_to_epm_signed() {
+	while !matches!(
+		ElectionProviderMultiPhase::current_phase(),
+		pallet_election_provider_multi_phase::Phase::Signed
+	) {
+		roll_to(System::block_number() + 1, false);
+	}
+}
+
+// Fast forward until EPM unsigned phase.
+pub fn roll_to_epm_unsigned() {
+	while !matches!(
+		ElectionProviderMultiPhase::current_phase(),
+		pallet_election_provider_multi_phase::Phase::Unsigned(_)
+	) {
+		roll_to(System::block_number() + 1, false);
+	}
+}
+
+// Fast forward until EPM off.
+pub fn roll_to_epm_off() {
+	while !matches!(
+		ElectionProviderMultiPhase::current_phase(),
+		pallet_election_provider_multi_phase::Phase::Off
+	) {
+		roll_to(System::block_number() + 1, false);
+	}
+}
+
+// Queue a solution based on the current snapshot.
+pub(crate) fn try_queue_solution(when: ElectionCompute) -> Result<(), String> {
+	let raw_solution = ElectionProviderMultiPhase::mine_solution()
+		.map_err(|e| format!("error mining solution: {:?}", e))?;
+
+	ElectionProviderMultiPhase::feasibility_check(raw_solution.0, when)
+		.map(|ready| {
+			QueuedSolution::<Runtime>::put(ready);
+		})
+		.map_err(|e| format!("error in solution feasibility: {:?}", e))
+}
+
+pub(crate) fn on_offence_now(
+	offenders: &[OffenceDetails<
+		AccountId,
+		pallet_session::historical::IdentificationTuple<Runtime>,
+	>],
+	slash_fraction: &[Perbill],
+) {
+	let now = Staking::active_era().unwrap().index;
+	let _ = Staking::on_offence(
+		offenders,
+		slash_fraction,
+		Staking::eras_start_session_index(now).unwrap(),
+		DisableStrategy::WhenSlashed,
+	);
+}
+
+// Add offence to validator, slash it.
+pub(crate) fn add_slash(who: &AccountId) {
+	on_offence_now(
+		&[OffenceDetails {
+			offender: (*who, Staking::eras_stakers(active_era(), *who)),
+			reporters: vec![],
+		}],
+		&[Perbill::from_percent(10)],
+	);
+}
+
+// Slashes enough validators to cross the `Staking::OffendingValidatorsThreshold`.
+pub(crate) fn slash_through_offending_threshold() {
+	let validators = Session::validators();
+	let mut remaining_slashes =
+		<Runtime as pallet_staking::Config>::OffendingValidatorsThreshold::get() *
+			validators.len() as u32;
+
+	for v in validators.into_iter() {
+		if remaining_slashes != 0 {
+			add_slash(&v);
+			remaining_slashes -= 1;
+		}
+	}
+}
+
+// Slashes a percentage of the active nominators that haven't been slashed yet, with
+// a minimum of 1 validator slash.
+pub(crate) fn slash_percentage(percentage: Perbill) -> Vec<AccountId> {
+	let validators = Session::validators();
+	let mut remaining_slashes = (percentage * validators.len() as u32).max(1);
+	let mut slashed = vec![];
+
+	for v in validators.into_iter() {
+		if remaining_slashes != 0 {
+			add_slash(&v);
+			slashed.push(v);
+			remaining_slashes -= 1;
+		}
+	}
+	slashed
+}
+
+pub(crate) fn set_minimum_election_score(
+	minimal_stake: ExtendedBalance,
+	sum_stake: ExtendedBalance,
+	sum_stake_squared: ExtendedBalance,
+) -> Result<(), ()> {
+	let election_score = ElectionScore { minimal_stake, sum_stake, sum_stake_squared };
+	ElectionProviderMultiPhase::set_minimum_untrusted_score(
+		RuntimeOrigin::root(),
+		Some(election_score),
+	)
+	.map(|_| ())
+	.map_err(|_| ())
+}
+
+pub(crate) fn staking_events() -> Vec<pallet_staking::Event<Runtime>> {
+	System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::Staking(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>()
+}
+
+pub(crate) fn epm_events() -> Vec<pallet_election_provider_multi_phase::Event<Runtime>> {
+	System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| {
+			if let RuntimeEvent::ElectionProviderMultiPhase(inner) = e {
+				Some(inner)
+			} else {
+				None
+			}
+		})
+		.collect::<Vec<_>>()
+}
diff --git a/substrate/frame/election-provider-support/Cargo.toml b/substrate/frame/election-provider-support/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..975be4ee04044fc38fd7196a90343cf16cb87f4f
--- /dev/null
+++ b/substrate/frame/election-provider-support/Cargo.toml
@@ -0,0 +1,55 @@
+[package]
+name = "frame-election-provider-support"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "election provider supporting traits"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-election-provider-solution-type = { version = "4.0.0-dev", path = "solution-type" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../primitives/npos-elections" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+
+[dev-dependencies]
+rand = { version = "0.8.5", features = ["small_rng"] }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-npos-elections = { version = "4.0.0-dev", path = "../../primitives/npos-elections" }
+
+[features]
+default = [ "std" ]
+fuzz = [ "default" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-npos-elections/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/election-provider-support/benchmarking/Cargo.toml b/substrate/frame/election-provider-support/benchmarking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..477869b45a5c8472c12092f6d40754cf6f43c2b4
--- /dev/null
+++ b/substrate/frame/election-provider-support/benchmarking/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "pallet-election-provider-support-benchmarking"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Benchmarking for election provider support onchain config trait"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../../benchmarking" }
+frame-election-provider-support = { version = "4.0.0-dev", default-features = false, path = ".." }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/npos-elections" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-election-provider-support/std",
+	"frame-system/std",
+	"sp-npos-elections/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
diff --git a/substrate/frame/election-provider-support/benchmarking/src/lib.rs b/substrate/frame/election-provider-support/benchmarking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c75aed0a911d3c66802951f0387ba675f8cfdba
--- /dev/null
+++ b/substrate/frame/election-provider-support/benchmarking/src/lib.rs
@@ -0,0 +1,92 @@
+// 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.
+
+//! Election provider support pallet benchmarking.
+//! This is separated into its own crate to avoid bloating the size of the runtime.
+
+#![cfg(feature = "runtime-benchmarks")]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::Decode;
+use frame_benchmarking::v1::benchmarks;
+use frame_election_provider_support::{NposSolver, PhragMMS, SequentialPhragmen};
+use sp_std::vec::Vec;
+
+pub struct Pallet<T: Config>(frame_system::Pallet<T>);
+pub trait Config: frame_system::Config {}
+
+const VOTERS: [u32; 2] = [1_000, 2_000];
+const TARGETS: [u32; 2] = [500, 1_000];
+const VOTES_PER_VOTER: [u32; 2] = [5, 16];
+
+const SEED: u32 = 999;
+fn set_up_voters_targets<AccountId: Decode + Clone>(
+	voters_len: u32,
+	targets_len: u32,
+	degree: usize,
+) -> (Vec<(AccountId, u64, impl IntoIterator<Item = AccountId>)>, Vec<AccountId>) {
+	// fill targets.
+	let mut targets = (0..targets_len)
+		.map(|i| frame_benchmarking::account::<AccountId>("Target", i, SEED))
+		.collect::<Vec<_>>();
+	assert!(targets.len() > degree, "we should always have enough voters to fill");
+	targets.truncate(degree);
+
+	// fill voters.
+	let voters = (0..voters_len)
+		.map(|i| {
+			let voter = frame_benchmarking::account::<AccountId>("Voter", i, SEED);
+			(voter, 1_000, targets.clone())
+		})
+		.collect::<Vec<_>>();
+
+	(voters, targets)
+}
+
+benchmarks! {
+	phragmen {
+		// number of votes in snapshot.
+		let v in (VOTERS[0]) .. VOTERS[1];
+		// number of targets in snapshot.
+		let t in (TARGETS[0]) .. TARGETS[1];
+		// number of votes per voter (ie the degree).
+		let d in (VOTES_PER_VOTER[0]) .. VOTES_PER_VOTER[1];
+
+		let (voters, targets) = set_up_voters_targets::<T::AccountId>(v, t, d as usize);
+	}: {
+		assert!(
+			SequentialPhragmen::<T::AccountId, sp_runtime::Perbill>
+				::solve(d as usize, targets, voters).is_ok()
+		);
+	}
+
+	phragmms {
+		// number of votes in snapshot.
+		let v in (VOTERS[0]) .. VOTERS[1];
+		// number of targets in snapshot.
+		let t in (TARGETS[0]) .. TARGETS[1];
+		// number of votes per voter (ie the degree).
+		let d in (VOTES_PER_VOTER[0]) .. VOTES_PER_VOTER[1];
+
+		let (voters, targets) = set_up_voters_targets::<T::AccountId>(v, t, d as usize);
+	}: {
+		assert!(
+			PhragMMS::<T::AccountId, sp_runtime::Perbill>
+				::solve(d as usize, targets, voters).is_ok()
+		);
+	}
+}
diff --git a/substrate/frame/election-provider-support/solution-type/Cargo.toml b/substrate/frame/election-provider-support/solution-type/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ef98cb8c1f38f9186f38b5080075acc452c9c6bd
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "frame-election-provider-solution-type"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "NPoS Solution Type"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "2.0.16", features = ["full", "visit"] }
+quote = "1.0.28"
+proc-macro2 = "1.0.56"
+proc-macro-crate = "1.1.3"
+
+[dev-dependencies]
+parity-scale-codec = "3.6.1"
+scale-info = "2.1.1"
+sp-arithmetic = { version = "16.0.0", path = "../../../primitives/arithmetic" }
+# used by generate_solution_type:
+frame-election-provider-support = { version = "4.0.0-dev", path = ".." }
+frame-support = { version = "4.0.0-dev", path = "../../support" }
+trybuild = "1.0.74"
diff --git a/substrate/frame/election-provider-support/solution-type/fuzzer/Cargo.toml b/substrate/frame/election-provider-support/solution-type/fuzzer/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..91b544d162198dc5d4f2cc81dc33092030ee9a49
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/fuzzer/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "frame-election-solution-type-fuzzer"
+version = "2.0.0-alpha.5"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Fuzzer for phragmén solution type implementation."
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive"] }
+honggfuzz = "0.5"
+rand = { version = "0.8", features = ["std", "small_rng"] }
+
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-election-provider-solution-type = { version = "4.0.0-dev", path = ".." }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../.." }
+sp-arithmetic = { version = "16.0.0", path = "../../../../primitives/arithmetic" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+# used by generate_solution_type:
+sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../../../primitives/npos-elections" }
+frame-support = { version = "4.0.0-dev", path = "../../../support" }
+
+[[bin]]
+name = "compact"
+path = "src/compact.rs"
diff --git a/substrate/frame/election-provider-support/solution-type/fuzzer/src/compact.rs b/substrate/frame/election-provider-support/solution-type/fuzzer/src/compact.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e7ef440ff21956ba0ecf8c3346c19612b57c3727
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/fuzzer/src/compact.rs
@@ -0,0 +1,40 @@
+use frame_election_provider_solution_type::generate_solution_type;
+use honggfuzz::fuzz;
+use sp_arithmetic::Percent;
+use sp_runtime::codec::{Encode, Error};
+
+fn main() {
+	generate_solution_type!(#[compact] pub struct InnerTestSolutionCompact::<
+		VoterIndex = u32,
+		TargetIndex = u32,
+		Accuracy = Percent,
+		MaxVoters = frame_support::traits::ConstU32::<100_000>,
+	>(16));
+	loop {
+		fuzz!(|fuzzer_data: &[u8]| {
+			let result_decoded: Result<InnerTestSolutionCompact, Error> =
+				<InnerTestSolutionCompact as codec::Decode>::decode(&mut &*fuzzer_data);
+			// Ignore errors as not every random sequence of bytes can be decoded as
+			// InnerTestSolutionCompact
+			if let Ok(decoded) = result_decoded {
+				// Decoding works, let's re-encode it and compare results.
+				let reencoded: std::vec::Vec<u8> = decoded.encode();
+				// The reencoded value may or may not be equal to the original fuzzer output.
+				// However, the original decoder should be optimal (in the sense that there is no
+				// shorter encoding of the same object). So let's see if the fuzzer can find
+				// something shorter:
+				if fuzzer_data.len() < reencoded.len() {
+					panic!("fuzzer_data.len() < reencoded.len()");
+				}
+				// The reencoded value should definitely be decodable (if unwrap() fails that is a
+				// valid panic/finding for the fuzzer):
+				let decoded2: InnerTestSolutionCompact =
+					<InnerTestSolutionCompact as codec::Decode>::decode(&mut reencoded.as_slice())
+						.unwrap();
+				// And it should be equal to the original decoded object (resulting from directly
+				// decoding fuzzer_data):
+				assert_eq!(decoded, decoded2);
+			}
+		});
+	}
+}
diff --git a/substrate/frame/election-provider-support/solution-type/src/codec.rs b/substrate/frame/election-provider-support/solution-type/src/codec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..17a256c228e287a2ad810cf37fd948d0d9f0abc0
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/src/codec.rs
@@ -0,0 +1,242 @@
+// 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.
+
+//! Code generation for the ratio assignment type' encode/decode/info impl.
+
+use crate::vote_field;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+
+pub(crate) fn codec_and_info_impl(
+	ident: syn::Ident,
+	voter_type: syn::Type,
+	target_type: syn::Type,
+	weight_type: syn::Type,
+	count: usize,
+) -> TokenStream2 {
+	let encode = encode_impl(&ident, count);
+	let decode = decode_impl(&ident, &voter_type, &target_type, &weight_type, count);
+	let scale_info = scale_info_impl(&ident, &voter_type, &target_type, &weight_type, count);
+
+	quote! {
+		#encode
+		#decode
+		#scale_info
+	}
+}
+
+fn decode_impl(
+	ident: &syn::Ident,
+	voter_type: &syn::Type,
+	target_type: &syn::Type,
+	weight_type: &syn::Type,
+	count: usize,
+) -> TokenStream2 {
+	let decode_impl_single = {
+		let name = vote_field(1);
+		quote! {
+			let #name =
+			<
+				_fepsp::sp_std::prelude::Vec<(_fepsp::codec::Compact<#voter_type>, _fepsp::codec::Compact<#target_type>)>
+				as
+				_fepsp::codec::Decode
+			>::decode(value)?;
+			let #name = #name
+				.into_iter()
+				.map(|(v, t)| (v.0, t.0))
+				.collect::<_fepsp::sp_std::prelude::Vec<_>>();
+		}
+	};
+
+	let decode_impl_rest = (2..=count)
+		.map(|c| {
+			let name = vote_field(c);
+
+			let inner_impl = (0..c - 1)
+				.map(|i| quote! { ( (inner[#i].0).0, (inner[#i].1).0 ), })
+				.collect::<TokenStream2>();
+
+			quote! {
+				let #name =
+				<
+					_fepsp::sp_std::prelude::Vec<(
+						_fepsp::codec::Compact<#voter_type>,
+						[(_fepsp::codec::Compact<#target_type>, _fepsp::codec::Compact<#weight_type>); #c-1],
+						_fepsp::codec::Compact<#target_type>,
+					)>
+					as _fepsp::codec::Decode
+				>::decode(value)?;
+				let #name = #name
+					.into_iter()
+					.map(|(v, inner, t_last)| (
+						v.0,
+						[ #inner_impl ],
+						t_last.0,
+					))
+					.collect::<_fepsp::sp_std::prelude::Vec<_>>();
+			}
+		})
+		.collect::<TokenStream2>();
+
+	let all_field_names = (1..=count)
+		.map(|c| {
+			let name = vote_field(c);
+			quote! { #name, }
+		})
+		.collect::<TokenStream2>();
+
+	quote!(
+		impl _fepsp::codec::Decode for #ident {
+			fn decode<I: _fepsp::codec::Input>(value: &mut I) -> Result<Self, _fepsp::codec::Error> {
+				#decode_impl_single
+				#decode_impl_rest
+
+				// The above code generates variables with the decoded value with the same name as
+				// filed names of the struct, i.e. `let votes4 = decode_value_of_votes4`. All we
+				// have to do is collect them into the main struct now.
+				Ok(#ident { #all_field_names })
+			}
+		}
+	)
+}
+
+// General attitude is that we will convert inner values to `Compact` and then use the normal
+// `Encode` implementation.
+fn encode_impl(ident: &syn::Ident, count: usize) -> TokenStream2 {
+	let encode_impl_single = {
+		let name = vote_field(1);
+		quote! {
+			let #name = self.#name
+				.iter()
+				.map(|(v, t)| (
+					_fepsp::codec::Compact(v.clone()),
+					_fepsp::codec::Compact(t.clone()),
+				))
+				.collect::<_fepsp::sp_std::prelude::Vec<_>>();
+			#name.encode_to(&mut r);
+		}
+	};
+
+	let encode_impl_rest = (2..=count)
+		.map(|c| {
+			let name = vote_field(c);
+
+			// we use the knowledge of the length to avoid copy_from_slice.
+			let inners_solution_array = (0..c - 1)
+				.map(|i| {
+					quote! {(
+						_fepsp::codec::Compact(inner[#i].0.clone()),
+						_fepsp::codec::Compact(inner[#i].1.clone()),
+					),}
+				})
+				.collect::<TokenStream2>();
+
+			quote! {
+				let #name = self.#name
+					.iter()
+					.map(|(v, inner, t_last)| (
+						_fepsp::codec::Compact(v.clone()),
+						[ #inners_solution_array ],
+						_fepsp::codec::Compact(t_last.clone()),
+					))
+					.collect::<_fepsp::sp_std::prelude::Vec<_>>();
+				#name.encode_to(&mut r);
+			}
+		})
+		.collect::<TokenStream2>();
+
+	quote!(
+		impl _fepsp::codec::Encode for #ident {
+			fn encode(&self) -> _fepsp::sp_std::prelude::Vec<u8> {
+				let mut r = vec![];
+				#encode_impl_single
+				#encode_impl_rest
+				r
+			}
+		}
+	)
+}
+
+fn scale_info_impl(
+	ident: &syn::Ident,
+	voter_type: &syn::Type,
+	target_type: &syn::Type,
+	weight_type: &syn::Type,
+	count: usize,
+) -> TokenStream2 {
+	let scale_info_impl_single = {
+		let name = format!("{}", vote_field(1));
+		quote! {
+			.field(|f|
+				f.ty::<_fepsp::sp_std::prelude::Vec<
+				   (_fepsp::codec::Compact<#voter_type>, _fepsp::codec::Compact<#target_type>)
+				>>()
+				.name(#name)
+			)
+		}
+	};
+
+	let scale_info_impl_double = {
+		let name = format!("{}", vote_field(2));
+		quote! {
+			.field(|f|
+				f.ty::<_fepsp::sp_std::prelude::Vec<(
+					_fepsp::codec::Compact<#voter_type>,
+					(_fepsp::codec::Compact<#target_type>, _fepsp::codec::Compact<#weight_type>),
+					_fepsp::codec::Compact<#target_type>
+				)>>()
+				.name(#name)
+			)
+		}
+	};
+
+	let scale_info_impl_rest = (3..=count)
+		.map(|c| {
+			let name = format!("{}", vote_field(c));
+			quote! {
+				.field(|f|
+					f.ty::<_fepsp::sp_std::prelude::Vec<(
+						_fepsp::codec::Compact<#voter_type>,
+						[
+							(_fepsp::codec::Compact<#target_type>, _fepsp::codec::Compact<#weight_type>);
+							#c - 1
+						],
+						_fepsp::codec::Compact<#target_type>
+					)>>()
+					.name(#name)
+				)
+			}
+		})
+		.collect::<TokenStream2>();
+
+	quote!(
+		 impl _fepsp::scale_info::TypeInfo for #ident {
+			 type Identity = Self;
+
+			 fn type_info() -> _fepsp::scale_info::Type<_fepsp::scale_info::form::MetaForm> {
+				 _fepsp::scale_info::Type::builder()
+					 .path(_fepsp::scale_info::Path::new(stringify!(#ident), module_path!()))
+					 .composite(
+						 _fepsp::scale_info::build::Fields::named()
+						 #scale_info_impl_single
+						 #scale_info_impl_double
+						 #scale_info_impl_rest
+					 )
+			 }
+		 }
+	)
+}
diff --git a/substrate/frame/election-provider-support/solution-type/src/from_assignment_helpers.rs b/substrate/frame/election-provider-support/solution-type/src/from_assignment_helpers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e8429b7f91cb50ba5839ea0bb612cc51e6a2caae
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/src/from_assignment_helpers.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! Helpers to generate the push code for `from_assignment` implementations. This can be shared
+//! between both single_page and double_page, thus extracted here.
+//!
+//! All of the code in this helper module assumes some variable names, namely `who` and
+//! `distribution`.
+
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+
+pub(crate) fn from_impl_single_push_code() -> TokenStream2 {
+	quote!(push((
+		voter_index(&who).or_invalid_index()?,
+		target_index(&distribution[0].0).or_invalid_index()?,
+	)))
+}
+
+pub(crate) fn from_impl_rest_push_code(count: usize) -> TokenStream2 {
+	let inner = (0..count - 1).map(|i| {
+		quote!(
+			(
+				target_index(&distribution[#i].0).or_invalid_index()?,
+				distribution[#i].1
+			)
+		)
+	});
+
+	let last_index = count - 1;
+	let last = quote!(target_index(&distribution[#last_index].0).or_invalid_index()?);
+
+	quote!(
+		push(
+			(
+				voter_index(&who).or_invalid_index()?,
+				[ #( #inner ),* ],
+				#last,
+			)
+		)
+	)
+}
diff --git a/substrate/frame/election-provider-support/solution-type/src/index_assignment.rs b/substrate/frame/election-provider-support/solution-type/src/index_assignment.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2518393038580668fd1a06ead9e7a46f110c9904
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/src/index_assignment.rs
@@ -0,0 +1,61 @@
+// 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.
+
+//! Code generation for getting the solution representation from the `IndexAssignment` type.
+
+use crate::vote_field;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+
+pub(crate) fn from_impl(struct_name: &syn::Ident, count: usize) -> TokenStream2 {
+	let from_impl_single = {
+		let name = vote_field(1);
+		quote!(1 => #struct_name.#name.push(
+			(
+				*who,
+				distribution[0].0,
+			)
+		),)
+	};
+
+	let from_impl_rest = (2..=count)
+		.map(|c| {
+			let inner = (0..c - 1)
+				.map(|i| quote!((distribution[#i].0, distribution[#i].1),))
+				.collect::<TokenStream2>();
+
+			let field_name = vote_field(c);
+			let last_index = c - 1;
+			let last = quote!(distribution[#last_index].0);
+
+			quote!(
+				#c => #struct_name.#field_name.push(
+					(
+						*who,
+						[#inner],
+						#last,
+					)
+				),
+			)
+		})
+		.collect::<TokenStream2>();
+
+	quote!(
+		#from_impl_single
+		#from_impl_rest
+	)
+}
diff --git a/substrate/frame/election-provider-support/solution-type/src/lib.rs b/substrate/frame/election-provider-support/solution-type/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..80773f6fb476859746677711401d70bd955b8ad7
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/src/lib.rs
@@ -0,0 +1,282 @@
+// 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.
+
+//! Proc macro for a npos solution type.
+
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
+use proc_macro_crate::{crate_name, FoundCrate};
+use quote::quote;
+use syn::parse::{Parse, ParseStream, Result};
+
+mod codec;
+mod from_assignment_helpers;
+mod index_assignment;
+mod single_page;
+
+/// Get the name of a filed based on voter count.
+pub(crate) fn vote_field(n: usize) -> Ident {
+	quote::format_ident!("votes{}", n)
+}
+
+/// Generate a `syn::Error`.
+pub(crate) fn syn_err(message: &'static str) -> syn::Error {
+	syn::Error::new(Span::call_site(), message)
+}
+
+/// Generates a struct to store the election result in a small/compact way. This can encode a
+/// structure which is the equivalent of a `sp_npos_elections::Assignment<_>`.
+///
+/// The following data types can be configured by the macro.
+///
+/// - The identifier of the voter. This can be any type that supports `parity-scale-codec`'s compact
+///   encoding.
+/// - The identifier of the target. This can be any type that supports `parity-scale-codec`'s
+///   compact encoding.
+/// - The accuracy of the ratios. This must be one of the `PerThing` types defined in
+///   `sp-arithmetic`.
+/// - The maximum number of voters. This must be of type `Get<u32>`. Check <https://github.com/paritytech/substrate/issues/10866>
+///   for more details. This is used to bound the struct, by leveraging the fact that `votes1.len()
+///   < votes2.len() < ... < votesn.len()` (the details of the struct is explained further below).
+///   We know that `sum_i votes_i.len() <= MaxVoters`, and we know that the maximum size of the
+///   struct would be achieved if all voters fall in the last bucket. One can also check the tests
+///   and more specifically `max_encoded_len_exact` for a concrete example.
+///
+/// Moreover, the maximum number of edges per voter (distribution per assignment) also need to be
+/// specified. Attempting to convert from/to an assignment with more distributions will fail.
+///
+/// For example, the following generates a public struct with name `TestSolution` with `u16` voter
+/// type, `u8` target type and `Perbill` accuracy with maximum of 4 edges per voter.
+///
+/// ```
+/// # use frame_election_provider_solution_type::generate_solution_type;
+/// # use sp_arithmetic::per_things::Perbill;
+/// # use frame_support::traits::ConstU32;
+/// generate_solution_type!(pub struct TestSolution::<
+///     VoterIndex = u16,
+///     TargetIndex = u8,
+///     Accuracy = Perbill,
+///     MaxVoters = ConstU32::<10>,
+/// >(4));
+/// ```
+///
+/// The output of this macro will roughly look like:
+///
+/// ```ignore
+/// struct TestSolution {
+/// 	voters1: vec![(u16 /* voter */, u8 /* target */)]
+/// 	voters2: vec![
+/// 		(u16 /* voter */, [u8 /* first target*/, Perbill /* proportion for first target */], u8 /* last target */)
+/// 	]
+/// 	voters3: vec![
+/// 		(u16 /* voter */,  [
+/// 			(u8 /* first target*/, Perbill /* proportion for first target */ ),
+/// 			(u8 /* second target */, Perbill /* proportion for second target*/)
+/// 		], u8 /* last target */)
+/// 		],
+/// 	voters4: ...,
+/// }
+///
+/// impl NposSolution for TestSolution {};
+/// impl Solution for TestSolution {};
+/// ```
+///
+/// The given struct provides function to convert from/to `Assignment` as part of
+/// `frame_election_provider_support::NposSolution` trait:
+///
+/// - `fn from_assignment<..>(..)`
+/// - `fn into_assignment<..>(..)`
+///
+/// ## Compact Encoding
+///
+/// The generated struct is by default deriving both `Encode` and `Decode`. This is okay but could
+/// lead to many `0`s in the solution. If prefixed with `#[compact]`, then a custom compact encoding
+/// for numbers will be used, similar to how `parity-scale-codec`'s `Compact` works.
+///
+/// ```
+/// # use frame_election_provider_solution_type::generate_solution_type;
+/// # use frame_election_provider_support::NposSolution;
+/// # use sp_arithmetic::per_things::Perbill;
+/// # use frame_support::traits::ConstU32;
+/// generate_solution_type!(
+///     #[compact]
+///     pub struct TestSolutionCompact::<
+///          VoterIndex = u16,
+///          TargetIndex = u8,
+///          Accuracy = Perbill,
+///          MaxVoters = ConstU32::<10>,
+///     >(8)
+/// );
+/// ```
+#[proc_macro]
+pub fn generate_solution_type(item: TokenStream) -> TokenStream {
+	let solution_def = syn::parse_macro_input!(item as SolutionDef);
+
+	let imports = imports().unwrap_or_else(|e| e.to_compile_error());
+
+	let def = single_page::generate(solution_def).unwrap_or_else(|e| e.to_compile_error());
+
+	quote!(
+		#imports
+		#def
+	)
+	.into()
+}
+
+struct SolutionDef {
+	vis: syn::Visibility,
+	ident: syn::Ident,
+	voter_type: syn::Type,
+	target_type: syn::Type,
+	weight_type: syn::Type,
+	max_voters: syn::Type,
+	count: usize,
+	compact_encoding: bool,
+}
+
+fn check_attributes(input: ParseStream) -> syn::Result<bool> {
+	let mut attrs = input.call(syn::Attribute::parse_outer).unwrap_or_default();
+	if attrs.len() > 1 {
+		let extra_attr = attrs.pop().expect("attributes vec with len > 1 can be popped");
+		return Err(syn::Error::new_spanned(
+			extra_attr,
+			"compact solution can accept only #[compact]",
+		))
+	}
+	if attrs.is_empty() {
+		return Ok(false)
+	}
+	let attr = attrs.pop().expect("attributes vec with len 1 can be popped.");
+	if attr.path().is_ident("compact") {
+		Ok(true)
+	} else {
+		Err(syn::Error::new_spanned(attr, "compact solution can accept only #[compact]"))
+	}
+}
+
+impl Parse for SolutionDef {
+	fn parse(input: ParseStream) -> syn::Result<Self> {
+		// optional #[compact]
+		let compact_encoding = check_attributes(input)?;
+
+		// <vis> struct <name>
+		let vis: syn::Visibility = input.parse()?;
+		let _ = <syn::Token![struct]>::parse(input)?;
+		let ident: syn::Ident = input.parse()?;
+
+		// ::<V, T, W>
+		let _ = <syn::Token![::]>::parse(input)?;
+		let generics: syn::AngleBracketedGenericArguments = input.parse()?;
+
+		if generics.args.len() != 4 {
+			return Err(syn_err("Must provide 4 generic args."))
+		}
+
+		let expected_types = ["VoterIndex", "TargetIndex", "Accuracy", "MaxVoters"];
+
+		let mut types: Vec<syn::Type> = generics
+			.args
+			.iter()
+			.zip(expected_types.iter())
+			.map(|(t, expected)| match t {
+				syn::GenericArgument::Type(ty) => {
+					// this is now an error
+					Err(syn::Error::new_spanned(
+						ty,
+						format!("Expected binding: `{} = ...`", expected),
+					))
+				},
+				syn::GenericArgument::AssocType(syn::AssocType { ident, ty, .. }) => {
+					// check that we have the right keyword for this position in the argument list
+					if ident == expected {
+						Ok(ty.clone())
+					} else {
+						Err(syn::Error::new_spanned(ident, format!("Expected `{}`", expected)))
+					}
+				},
+				_ => Err(syn_err("Wrong type of generic provided. Must be a `type`.")),
+			})
+			.collect::<Result<_>>()?;
+
+		let max_voters = types.pop().expect("Vector of length 4 can be popped; qed");
+		let weight_type = types.pop().expect("Vector of length 3 can be popped; qed");
+		let target_type = types.pop().expect("Vector of length 2 can be popped; qed");
+		let voter_type = types.pop().expect("Vector of length 1 can be popped; qed");
+
+		// (<count>)
+		let count_expr: syn::ExprParen = input.parse()?;
+		let count = parse_parenthesized_number::<usize>(count_expr)?;
+
+		Ok(Self {
+			vis,
+			ident,
+			voter_type,
+			target_type,
+			weight_type,
+			max_voters,
+			count,
+			compact_encoding,
+		})
+	}
+}
+
+fn parse_parenthesized_number<N: std::str::FromStr>(input_expr: syn::ExprParen) -> syn::Result<N>
+where
+	<N as std::str::FromStr>::Err: std::fmt::Display,
+{
+	let expr = input_expr.expr;
+	let expr_lit = match *expr {
+		syn::Expr::Lit(count_lit) => count_lit.lit,
+		_ => return Err(syn_err("Count must be literal.")),
+	};
+	let int_lit = match expr_lit {
+		syn::Lit::Int(int_lit) => int_lit,
+		_ => return Err(syn_err("Count must be int literal.")),
+	};
+	int_lit.base10_parse::<N>()
+}
+
+fn imports() -> Result<TokenStream2> {
+	match crate_name("frame-election-provider-support") {
+		Ok(FoundCrate::Itself) => Ok(quote! {
+			use crate as _feps;
+			use _feps::private as _fepsp;
+		}),
+		Ok(FoundCrate::Name(frame_election_provider_support)) => {
+			let ident = syn::Ident::new(&frame_election_provider_support, Span::call_site());
+			Ok(quote!(
+					use #ident as _feps;
+					use _feps::private as _fepsp;
+			))
+		},
+		Err(e) => Err(syn::Error::new(Span::call_site(), e)),
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn ui_fail() {
+		// Only run the ui tests when `RUN_UI_TESTS` is set.
+		if std::env::var("RUN_UI_TESTS").is_err() {
+			return
+		}
+
+		let cases = trybuild::TestCases::new();
+		cases.compile_fail("tests/ui/fail/*.rs");
+	}
+}
diff --git a/substrate/frame/election-provider-support/solution-type/src/single_page.rs b/substrate/frame/election-provider-support/solution-type/src/single_page.rs
new file mode 100644
index 0000000000000000000000000000000000000000..161631ee83fa6562c47b6f09ad5962ee111fde28
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/src/single_page.rs
@@ -0,0 +1,391 @@
+// 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::{from_assignment_helpers::*, syn_err, vote_field};
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::parse::Result;
+
+pub(crate) fn generate(def: crate::SolutionDef) -> Result<TokenStream2> {
+	let crate::SolutionDef {
+		vis,
+		ident,
+		count,
+		voter_type,
+		target_type,
+		weight_type,
+		max_voters,
+		compact_encoding,
+	} = def;
+
+	if count <= 2 {
+		return Err(syn_err("cannot build solution struct with capacity less than 3."))
+	}
+
+	let single = {
+		let name = vote_field(1);
+		// NOTE: we use the visibility of the struct for the fields as well.. could be made better.
+		quote!(
+			#vis #name: _fepsp::sp_std::prelude::Vec<(#voter_type, #target_type)>,
+		)
+	};
+
+	let rest = (2..=count)
+		.map(|c| {
+			let field_name = vote_field(c);
+			let array_len = c - 1;
+			quote!(
+				#vis #field_name: _fepsp::sp_std::prelude::Vec<(
+					#voter_type,
+					[(#target_type, #weight_type); #array_len],
+					#target_type
+				)>,
+			)
+		})
+		.collect::<TokenStream2>();
+
+	let len_impl = len_impl(count);
+	let edge_count_impl = edge_count_impl(count);
+	let unique_targets_impl = unique_targets_impl(count);
+	let remove_voter_impl = remove_voter_impl(count);
+
+	let derives_and_maybe_compact_encoding = if compact_encoding {
+		// custom compact encoding.
+		let compact_impl = crate::codec::codec_and_info_impl(
+			ident.clone(),
+			voter_type.clone(),
+			target_type.clone(),
+			weight_type.clone(),
+			count,
+		);
+		quote! {
+			#compact_impl
+			#[derive(Default, PartialEq, Eq, Clone, Debug, PartialOrd, Ord)]
+		}
+	} else {
+		// automatically derived.
+		quote!(#[derive(
+			Default,
+			PartialEq,
+			Eq,
+			Clone,
+			Debug,
+			_fepsp::codec::Encode,
+			_fepsp::codec::Decode,
+			_fepsp::scale_info::TypeInfo,
+		)])
+	};
+
+	let struct_name = syn::Ident::new("solution", proc_macro2::Span::call_site());
+	let assignment_name = syn::Ident::new("all_assignments", proc_macro2::Span::call_site());
+
+	let from_impl = from_impl(&struct_name, count);
+	let into_impl = into_impl(&assignment_name, count, weight_type.clone());
+	let from_index_impl = crate::index_assignment::from_impl(&struct_name, count);
+
+	Ok(quote! (
+		/// A struct to encode a election assignment in a compact way.
+		#derives_and_maybe_compact_encoding
+		#vis struct #ident { #single #rest }
+
+		use _fepsp::__OrInvalidIndex;
+		impl _feps::NposSolution for #ident {
+			const LIMIT: usize = #count;
+			type VoterIndex = #voter_type;
+			type TargetIndex = #target_type;
+			type Accuracy = #weight_type;
+
+			fn remove_voter(&mut self, to_remove: Self::VoterIndex) -> bool {
+				#remove_voter_impl
+				return false
+			}
+
+			fn from_assignment<FV, FT, A>(
+				assignments: &[_feps::Assignment<A, #weight_type>],
+				voter_index: FV,
+				target_index: FT,
+			) -> Result<Self, _feps::Error>
+				where
+					A: _feps::IdentifierT,
+					for<'r> FV: Fn(&'r A) -> Option<Self::VoterIndex>,
+					for<'r> FT: Fn(&'r A) -> Option<Self::TargetIndex>,
+			{
+				// Make sure that the voter bound is binding.
+				// `assignments.len()` actually represents the number of voters
+				if assignments.len() as u32 > <#max_voters as _feps::Get<u32>>::get() {
+					return Err(_feps::Error::TooManyVoters);
+				}
+				let mut #struct_name: #ident = Default::default();
+				for _feps::Assignment { who, distribution } in assignments {
+					match distribution.len() {
+						0 => continue,
+						#from_impl
+						_ => {
+							return Err(_feps::Error::SolutionTargetOverflow);
+						}
+					}
+				};
+
+				Ok(#struct_name)
+			}
+
+			fn into_assignment<A: _feps::IdentifierT>(
+				self,
+				voter_at: impl Fn(Self::VoterIndex) -> Option<A>,
+				target_at: impl Fn(Self::TargetIndex) -> Option<A>,
+			) -> Result<_fepsp::sp_std::prelude::Vec<_feps::Assignment<A, #weight_type>>, _feps::Error> {
+				let mut #assignment_name: _fepsp::sp_std::prelude::Vec<_feps::Assignment<A, #weight_type>> = Default::default();
+				#into_impl
+				Ok(#assignment_name)
+			}
+
+			fn voter_count(&self) -> usize {
+				let mut all_len = 0usize;
+				#len_impl
+				all_len
+			}
+
+			fn edge_count(&self) -> usize {
+				let mut all_edges = 0usize;
+				#edge_count_impl
+				all_edges
+			}
+
+			fn unique_targets(&self) -> _fepsp::sp_std::prelude::Vec<Self::TargetIndex> {
+				// NOTE: this implementation returns the targets sorted, but we don't use it yet per
+				// se, nor is the API enforcing it.
+				use _fepsp::sp_std::collections::btree_set::BTreeSet;
+				let mut all_targets: BTreeSet<Self::TargetIndex> = BTreeSet::new();
+				let mut maybe_insert_target = |t: Self::TargetIndex| {
+					all_targets.insert(t);
+				};
+
+				#unique_targets_impl
+
+				all_targets.into_iter().collect()
+			}
+		}
+
+		type __IndexAssignment = _feps::IndexAssignment<
+			<#ident as _feps::NposSolution>::VoterIndex,
+			<#ident as _feps::NposSolution>::TargetIndex,
+			<#ident as _feps::NposSolution>::Accuracy,
+		>;
+		impl _fepsp::codec::MaxEncodedLen for #ident {
+			fn max_encoded_len() -> usize {
+				use frame_support::traits::Get;
+				use _fepsp::codec::Encode;
+				let s: u32 = #max_voters::get();
+				let max_element_size =
+					// the first voter..
+					#voter_type::max_encoded_len()
+					// #count - 1 tuples..
+					.saturating_add(
+						(#count - 1).saturating_mul(
+							#target_type::max_encoded_len().saturating_add(#weight_type::max_encoded_len())))
+					// and the last target.
+					.saturating_add(#target_type::max_encoded_len());
+				// The assumption is that it contains #count-1 empty elements
+				// and then last element with full size
+				#count
+					.saturating_mul(_fepsp::codec::Compact(0u32).encoded_size())
+					.saturating_add((s as usize).saturating_mul(max_element_size))
+			}
+		}
+		impl<'a> _fepsp::sp_std::convert::TryFrom<&'a [__IndexAssignment]> for #ident {
+			type Error = _feps::Error;
+			fn try_from(index_assignments: &'a [__IndexAssignment]) -> Result<Self, Self::Error> {
+				let mut #struct_name =  #ident::default();
+
+				for _feps::IndexAssignment { who, distribution } in index_assignments {
+					match distribution.len() {
+						0 => {}
+						#from_index_impl
+						_ => {
+							return Err(_feps::Error::SolutionTargetOverflow);
+						}
+					}
+				};
+
+				Ok(#struct_name)
+			}
+		}
+	))
+}
+
+fn remove_voter_impl(count: usize) -> TokenStream2 {
+	let field_name = vote_field(1);
+	let single = quote! {
+		if let Some(idx) = self.#field_name.iter().position(|(x, _)| *x == to_remove) {
+			self.#field_name.remove(idx);
+			return true
+		}
+	};
+
+	let rest = (2..=count)
+		.map(|c| {
+			let field_name = vote_field(c);
+			quote! {
+				if let Some(idx) = self.#field_name.iter().position(|(x, _, _)| *x == to_remove) {
+					self.#field_name.remove(idx);
+					return true
+				}
+			}
+		})
+		.collect::<TokenStream2>();
+
+	quote! {
+		#single
+		#rest
+	}
+}
+
+fn len_impl(count: usize) -> TokenStream2 {
+	(1..=count)
+		.map(|c| {
+			let field_name = vote_field(c);
+			quote!(
+				all_len = all_len.saturating_add(self.#field_name.len());
+			)
+		})
+		.collect::<TokenStream2>()
+}
+
+fn edge_count_impl(count: usize) -> TokenStream2 {
+	(1..=count)
+		.map(|c| {
+			let field_name = vote_field(c);
+			quote!(
+				all_edges = all_edges.saturating_add(
+					self.#field_name.len().saturating_mul(#c as usize)
+				);
+			)
+		})
+		.collect::<TokenStream2>()
+}
+
+fn unique_targets_impl(count: usize) -> TokenStream2 {
+	let unique_targets_impl_single = {
+		let field_name = vote_field(1);
+		quote! {
+			self.#field_name.iter().for_each(|(_, t)| {
+				maybe_insert_target(*t);
+			});
+		}
+	};
+
+	let unique_targets_impl_rest = (2..=count)
+		.map(|c| {
+			let field_name = vote_field(c);
+			quote! {
+				self.#field_name.iter().for_each(|(_, inners, t_last)| {
+					inners.iter().for_each(|(t, _)| {
+						maybe_insert_target(*t);
+					});
+					maybe_insert_target(*t_last);
+				});
+			}
+		})
+		.collect::<TokenStream2>();
+
+	quote! {
+		#unique_targets_impl_single
+		#unique_targets_impl_rest
+	}
+}
+
+pub(crate) fn from_impl(struct_name: &syn::Ident, count: usize) -> TokenStream2 {
+	let from_impl_single = {
+		let field = vote_field(1);
+		let push_code = from_impl_single_push_code();
+		quote!(1 => #struct_name.#field.#push_code,)
+	};
+
+	let from_impl_rest = (2..=count)
+		.map(|c| {
+			let field = vote_field(c);
+			let push_code = from_impl_rest_push_code(c);
+			quote!(#c => #struct_name.#field.#push_code,)
+		})
+		.collect::<TokenStream2>();
+
+	quote!(
+		#from_impl_single
+		#from_impl_rest
+	)
+}
+
+pub(crate) fn into_impl(
+	assignments: &syn::Ident,
+	count: usize,
+	per_thing: syn::Type,
+) -> TokenStream2 {
+	let into_impl_single = {
+		let name = vote_field(1);
+		quote!(
+			for (voter_index, target_index) in self.#name {
+				#assignments.push(_feps::Assignment {
+					who: voter_at(voter_index).or_invalid_index()?,
+					distribution: vec![
+						(target_at(target_index).or_invalid_index()?, #per_thing::one())
+					],
+				})
+			}
+		)
+	};
+
+	let into_impl_rest = (2..=count)
+		.map(|c| {
+			let name = vote_field(c);
+			quote!(
+				for (voter_index, inners, t_last_idx) in self.#name {
+					let mut sum = #per_thing::zero();
+					let mut inners_parsed = inners
+						.iter()
+						.map(|(ref t_idx, p)| {
+							sum = _fepsp::sp_arithmetic::traits::Saturating::saturating_add(sum, *p);
+							let target = target_at(*t_idx).or_invalid_index()?;
+							Ok((target, *p))
+						})
+						.collect::<Result<_fepsp::sp_std::prelude::Vec<(A, #per_thing)>, _feps::Error>>()?;
+
+					if sum >= #per_thing::one() {
+						return Err(_feps::Error::SolutionWeightOverflow);
+					}
+
+					// defensive only. Since Percent doesn't have `Sub`.
+					let p_last = _fepsp::sp_arithmetic::traits::Saturating::saturating_sub(
+						#per_thing::one(),
+						sum,
+					);
+
+					inners_parsed.push((target_at(t_last_idx).or_invalid_index()?, p_last));
+
+					#assignments.push(_feps::Assignment {
+						who: voter_at(voter_index).or_invalid_index()?,
+						distribution: inners_parsed,
+					});
+				}
+			)
+		})
+		.collect::<TokenStream2>();
+
+	quote!(
+		#into_impl_single
+		#into_impl_rest
+	)
+}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_accuracy.rs b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_accuracy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..52ae9623fd38462da2fc60f195e944d79da1e7c6
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_accuracy.rs
@@ -0,0 +1,10 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(pub struct TestSolution::<
+	VoterIndex = u16,
+	TargetIndex = u8,
+	Perbill,
+	MaxVoters = ConstU32::<10>,
+>(8));
+
+fn main() {}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_accuracy.stderr b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_accuracy.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b6bb8f39ede610819e35684e50ecb8d287c29171
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_accuracy.stderr
@@ -0,0 +1,5 @@
+error: Expected binding: `Accuracy = ...`
+ --> $DIR/missing_accuracy.rs:6:2
+  |
+6 |     Perbill,
+  |     ^^^^^^^
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.rs b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe8ac04cc8d6148bab6f1ef23139c95fe9af172e
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.rs
@@ -0,0 +1,10 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(pub struct TestSolution::<
+	VoterIndex = u16,
+	TargetIndex = u8,
+	Accuracy = Perbill,
+	ConstU32::<10>,
+>(8));
+
+fn main() {}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.stderr b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c685ab816d399d47bb8d4551fe9b8b6e2cae8bd8
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_size_bound.stderr
@@ -0,0 +1,5 @@
+error: Expected binding: `MaxVoters = ...`
+ --> tests/ui/fail/missing_size_bound.rs:7:2
+  |
+7 |     ConstU32::<10>,
+  |     ^^^^^^^^^^^^^^
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_target.rs b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_target.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b457c4abada6c3dc0ea8e1ab630f5a48c999565e
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_target.rs
@@ -0,0 +1,10 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(pub struct TestSolution::<
+	VoterIndex = u16,
+	u8,
+	Accuracy = Perbill,
+	MaxVoters = ConstU32::<10>,
+>(8));
+
+fn main() {}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_target.stderr b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_target.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d0c92c5bbd8e9f84154cd676dd7d80f7023e4469
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_target.stderr
@@ -0,0 +1,5 @@
+error: Expected binding: `TargetIndex = ...`
+ --> $DIR/missing_target.rs:5:2
+  |
+5 |     u8,
+  |     ^^
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_voter.rs b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_voter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3d12e3e6b5ec4822fc044a4e2ab2c8f8b30a8b06
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_voter.rs
@@ -0,0 +1,10 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(pub struct TestSolution::<
+	u16,
+	TargetIndex = u8,
+	Accuracy = Perbill,
+	MaxVoters = ConstU32::<10>,
+>(8));
+
+fn main() {}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_voter.stderr b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_voter.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..a825d460c2fa8c9411c5132a1c755c7e87a090ff
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/missing_voter.stderr
@@ -0,0 +1,5 @@
+error: Expected binding: `VoterIndex = ...`
+ --> $DIR/missing_voter.rs:4:2
+  |
+4 |     u16,
+  |     ^^^
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/no_annotations.rs b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/no_annotations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9aab15e7ec9a1798464cca328fb89cc88dacba62
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/no_annotations.rs
@@ -0,0 +1,10 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(pub struct TestSolution::<
+	u16,
+	u8,
+	Perbill,
+	MaxVoters = ConstU32::<10>,
+>(8));
+
+fn main() {}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/no_annotations.stderr b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/no_annotations.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..28f1c2091546fc24f2bfea8dc976fbcc979fbba4
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/no_annotations.stderr
@@ -0,0 +1,5 @@
+error: Expected binding: `VoterIndex = ...`
+ --> $DIR/no_annotations.rs:4:2
+  |
+4 |     u16,
+  |     ^^^
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/swap_voter_target.rs b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/swap_voter_target.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4275aae045a604f9b5e8e746b87fd830b4c0bd27
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/swap_voter_target.rs
@@ -0,0 +1,10 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(pub struct TestSolution::<
+	TargetIndex = u16,
+	VoterIndex = u8,
+	Accuracy = Perbill,
+	MaxVoters = ConstU32::<10>,
+>(8));
+
+fn main() {}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/swap_voter_target.stderr b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/swap_voter_target.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5759fee7472fab271a1a79f0a02c48684d7a5951
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/swap_voter_target.stderr
@@ -0,0 +1,5 @@
+error: Expected `VoterIndex`
+ --> $DIR/swap_voter_target.rs:4:2
+  |
+4 |     TargetIndex = u16,
+  |     ^^^^^^^^^^^
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/wrong_attribute.rs b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/wrong_attribute.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a51cc724ad1580489fc8d71335717462df67fa54
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/wrong_attribute.rs
@@ -0,0 +1,12 @@
+use frame_election_provider_solution_type::generate_solution_type;
+
+generate_solution_type!(
+	#[pages(1)] pub struct TestSolution::<
+		VoterIndex = u8,
+		TargetIndex = u16,
+		Accuracy = Perbill,
+		MaxVoters = ConstU32::<10>,
+	>(8)
+);
+
+fn main() {}
diff --git a/substrate/frame/election-provider-support/solution-type/tests/ui/fail/wrong_attribute.stderr b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/wrong_attribute.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..ab700a3f2afcbf4516d695aebbfe034ce08ffc22
--- /dev/null
+++ b/substrate/frame/election-provider-support/solution-type/tests/ui/fail/wrong_attribute.stderr
@@ -0,0 +1,5 @@
+error: compact solution can accept only #[compact]
+ --> $DIR/wrong_attribute.rs:4:2
+  |
+4 |     #[pages(1)] pub struct TestSolution::<
+  |     ^^^^^^^^^^^
diff --git a/substrate/frame/election-provider-support/src/bounds.rs b/substrate/frame/election-provider-support/src/bounds.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b9ae21e49ca70b3700ad43603fbac38f217f75de
--- /dev/null
+++ b/substrate/frame/election-provider-support/src/bounds.rs
@@ -0,0 +1,460 @@
+// 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.
+
+//! Types and helpers to define and handle election bounds.
+//!
+//! ### Overview
+//!
+//! This module defines and implements types that help creating and handling election bounds.
+//! [`DataProviderBounds`] encapsulates the upper limits for the results provided by `DataProvider`
+//! implementors. Those limits can be defined over two axis: number of elements returned (`count`)
+//! and/or the size of the returned SCALE encoded structure (`size`).
+//!
+//! [`ElectionBoundsBuilder`] is a helper to construct data election bounds and it aims at
+//! preventing the caller from mistake the order of size and count limits.
+//!
+//! ### Examples
+//!
+//! [`ElectionBoundsBuilder`] helps defining the size and count bounds for both voters and targets.
+//!
+//! ```
+//! use frame_election_provider_support::bounds::*;
+//!
+//! // unbounded limits are never exhausted.
+//! let unbounded = ElectionBoundsBuilder::default().build();
+//! assert!(!unbounded.targets.exhausted(SizeBound(1_000_000_000).into(), None));
+//!
+//! let bounds = ElectionBoundsBuilder::default()
+//!     .voters_count(100.into())
+//!     .voters_size(1_000.into())
+//!     .targets_count(200.into())
+//!     .targets_size(2_000.into())
+//!     .build();
+//!
+//! assert!(!bounds.targets.exhausted(SizeBound(1).into(), CountBound(1).into()));
+//! assert!(bounds.targets.exhausted(SizeBound(1).into(), CountBound(100_000).into()));
+//! ```
+//!
+//! ### Implementation details
+//!
+//! A default or `None` bound means that no bounds are enforced (i.e. unlimited result size). In
+//! general, be careful when using unbounded election bounds in production.
+
+use core::ops::Add;
+use sp_runtime::traits::Zero;
+
+/// Count type for data provider bounds.
+///
+/// Encapsulates the counting of things that can be bounded in an election, such as voters,
+/// targets or anything else.
+///
+/// This struct is defined mostly to prevent callers from mistankingly using `CountBound` instead of
+/// `SizeBound` and vice-versa.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct CountBound(pub u32);
+
+impl From<u32> for CountBound {
+	fn from(value: u32) -> Self {
+		CountBound(value)
+	}
+}
+
+impl Add for CountBound {
+	type Output = Self;
+	fn add(self, rhs: Self) -> Self::Output {
+		CountBound(self.0.saturating_add(rhs.0))
+	}
+}
+
+impl Zero for CountBound {
+	fn is_zero(&self) -> bool {
+		self.0 == 0u32
+	}
+	fn zero() -> Self {
+		CountBound(0)
+	}
+}
+
+/// Size type for data provider bounds.
+///
+/// Encapsulates the size limit of things that can be bounded in an election, such as voters,
+/// targets or anything else. The size unit can represent anything depending on the election
+/// logic and implementation, but it most likely will represent bytes in SCALE encoding in this
+/// context.
+///
+/// This struct is defined mostly to prevent callers from mistankingly using `CountBound` instead of
+/// `SizeBound` and vice-versa.
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct SizeBound(pub u32);
+
+impl From<u32> for SizeBound {
+	fn from(value: u32) -> Self {
+		SizeBound(value)
+	}
+}
+
+impl Zero for SizeBound {
+	fn is_zero(&self) -> bool {
+		self.0 == 0u32
+	}
+	fn zero() -> Self {
+		SizeBound(0)
+	}
+}
+
+impl Add for SizeBound {
+	type Output = Self;
+	fn add(self, rhs: Self) -> Self::Output {
+		SizeBound(self.0.saturating_add(rhs.0))
+	}
+}
+
+/// Data bounds for election data.
+///
+/// Limits the data returned by `DataProvider` implementors, defined over two axis: `count`,
+/// defining the maximum number of elements returned, and `size`, defining the limit in size
+/// (bytes) of the SCALE encoded result.
+///
+/// `None` represents unlimited bounds in both `count` and `size` axis.
+#[derive(Clone, Copy, Default, Debug, Eq, PartialEq)]
+pub struct DataProviderBounds {
+	pub count: Option<CountBound>,
+	pub size: Option<SizeBound>,
+}
+
+impl DataProviderBounds {
+	///  Returns true if `given_count` exhausts `self.count`.
+	pub fn count_exhausted(self, given_count: CountBound) -> bool {
+		self.count.map_or(false, |count| given_count > count)
+	}
+
+	///  Returns true if `given_size` exhausts `self.size`.
+	pub fn size_exhausted(self, given_size: SizeBound) -> bool {
+		self.size.map_or(false, |size| given_size > size)
+	}
+
+	/// Returns true if `given_size` or `given_count` exhausts `self.size` or `self_count`,
+	/// respectively.
+	pub fn exhausted(self, given_size: Option<SizeBound>, given_count: Option<CountBound>) -> bool {
+		self.count_exhausted(given_count.unwrap_or(CountBound::zero())) ||
+			self.size_exhausted(given_size.unwrap_or(SizeBound::zero()))
+	}
+
+	/// Returns an instance of `Self` that is constructed by capping both the `count` and `size`
+	/// fields. If `self` is None, overwrite it with the provided bounds.
+	pub fn max(self, bounds: DataProviderBounds) -> Self {
+		DataProviderBounds {
+			count: self
+				.count
+				.map(|c| {
+					c.clamp(CountBound::zero(), bounds.count.unwrap_or(CountBound(u32::MAX))).into()
+				})
+				.or(bounds.count),
+			size: self
+				.size
+				.map(|c| {
+					c.clamp(SizeBound::zero(), bounds.size.unwrap_or(SizeBound(u32::MAX))).into()
+				})
+				.or(bounds.size),
+		}
+	}
+}
+
+/// The voter and target bounds of an election.
+///
+/// The bounds are defined over two axis: `count` of element of the election (voters or targets) and
+/// the `size` of the SCALE encoded result snapshot.
+#[derive(Clone, Debug, Copy)]
+pub struct ElectionBounds {
+	pub voters: DataProviderBounds,
+	pub targets: DataProviderBounds,
+}
+
+impl ElectionBounds {
+	/// Returns an error if the provided `count` and `size` do not fit in the voter's election
+	/// bounds.
+	pub fn ensure_voters_limits(
+		self,
+		count: CountBound,
+		size: SizeBound,
+	) -> Result<(), &'static str> {
+		match self.voters.exhausted(Some(size), Some(count)) {
+			true => Err("Ensure voters bounds: bounds exceeded."),
+			false => Ok(()),
+		}
+	}
+
+	/// Returns an error if the provided `count` and `size` do not fit in the target's election
+	/// bounds.
+	pub fn ensure_targets_limits(
+		self,
+		count: CountBound,
+		size: SizeBound,
+	) -> Result<(), &'static str> {
+		match self.targets.exhausted(Some(size), Some(count).into()) {
+			true => Err("Ensure targets bounds: bounds exceeded."),
+			false => Ok(()),
+		}
+	}
+}
+
+/// Utility builder for [`ElectionBounds`].
+#[derive(Copy, Clone, Default)]
+pub struct ElectionBoundsBuilder {
+	voters: Option<DataProviderBounds>,
+	targets: Option<DataProviderBounds>,
+}
+
+impl From<ElectionBounds> for ElectionBoundsBuilder {
+	fn from(bounds: ElectionBounds) -> Self {
+		ElectionBoundsBuilder { voters: Some(bounds.voters), targets: Some(bounds.targets) }
+	}
+}
+
+impl ElectionBoundsBuilder {
+	/// Sets the voters count bounds.
+	pub fn voters_count(mut self, count: CountBound) -> Self {
+		self.voters = self.voters.map_or(
+			Some(DataProviderBounds { count: Some(count), size: None }),
+			|mut bounds| {
+				bounds.count = Some(count);
+				Some(bounds)
+			},
+		);
+		self
+	}
+
+	/// Sets the voters size bounds.
+	pub fn voters_size(mut self, size: SizeBound) -> Self {
+		self.voters = self.voters.map_or(
+			Some(DataProviderBounds { count: None, size: Some(size) }),
+			|mut bounds| {
+				bounds.size = Some(size);
+				Some(bounds)
+			},
+		);
+		self
+	}
+
+	/// Sets the targets count bounds.
+	pub fn targets_count(mut self, count: CountBound) -> Self {
+		self.targets = self.targets.map_or(
+			Some(DataProviderBounds { count: Some(count), size: None }),
+			|mut bounds| {
+				bounds.count = Some(count);
+				Some(bounds)
+			},
+		);
+		self
+	}
+
+	/// Sets the targets size bounds.
+	pub fn targets_size(mut self, size: SizeBound) -> Self {
+		self.targets = self.targets.map_or(
+			Some(DataProviderBounds { count: None, size: Some(size) }),
+			|mut bounds| {
+				bounds.size = Some(size);
+				Some(bounds)
+			},
+		);
+		self
+	}
+
+	/// Set the voters bounds.
+	pub fn voters(mut self, bounds: Option<DataProviderBounds>) -> Self {
+		self.voters = bounds;
+		self
+	}
+
+	/// Set the targets bounds.
+	pub fn targets(mut self, bounds: Option<DataProviderBounds>) -> Self {
+		self.targets = bounds;
+		self
+	}
+
+	/// Caps the number of the voters bounds in self to `voters` bounds. If `voters` bounds are
+	/// higher than the self bounds, keeps it. Note that `None` bounds are equivalent to maximum
+	/// and should be treated as such.
+	pub fn voters_or_lower(mut self, voters: DataProviderBounds) -> Self {
+		self.voters = match self.voters {
+			None => Some(voters),
+			Some(v) => Some(v.max(voters)),
+		};
+		self
+	}
+
+	/// Caps the number of the target bounds in self to `voters` bounds. If `voters` bounds are
+	/// higher than the self bounds, keeps it. Note that `None` bounds are equivalent to maximum
+	/// and should be treated as such.
+	pub fn targets_or_lower(mut self, targets: DataProviderBounds) -> Self {
+		self.targets = match self.targets {
+			None => Some(targets),
+			Some(t) => Some(t.max(targets)),
+		};
+		self
+	}
+
+	/// Returns an instance of `ElectionBounds` from the current state.
+	pub fn build(self) -> ElectionBounds {
+		ElectionBounds {
+			voters: self.voters.unwrap_or_default(),
+			targets: self.targets.unwrap_or_default(),
+		}
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	use frame_support::{assert_err, assert_ok};
+
+	#[test]
+	fn data_provider_bounds_unbounded_works() {
+		let bounds = DataProviderBounds::default();
+		assert!(!bounds.exhausted(None, None));
+		assert!(!bounds.exhausted(SizeBound(u32::MAX).into(), CountBound(u32::MAX).into()));
+	}
+
+	#[test]
+	fn election_bounds_builder_and_exhausted_bounds_work() {
+		// voter bounds exhausts if count > 100 or size > 1_000; target bounds exhausts if count >
+		// 200 or size > 2_000.
+		let bounds = ElectionBoundsBuilder::default()
+			.voters_count(100.into())
+			.voters_size(1_000.into())
+			.targets_count(200.into())
+			.targets_size(2_000.into())
+			.build();
+
+		assert!(!bounds.voters.exhausted(None, None));
+		assert!(!bounds.voters.exhausted(SizeBound(10).into(), CountBound(10).into()));
+		assert!(!bounds.voters.exhausted(None, CountBound(100).into()));
+		assert!(!bounds.voters.exhausted(SizeBound(1_000).into(), None));
+		// exhausts bounds.
+		assert!(bounds.voters.exhausted(None, CountBound(101).into()));
+		assert!(bounds.voters.exhausted(SizeBound(1_001).into(), None));
+
+		assert!(!bounds.targets.exhausted(None, None));
+		assert!(!bounds.targets.exhausted(SizeBound(20).into(), CountBound(20).into()));
+		assert!(!bounds.targets.exhausted(None, CountBound(200).into()));
+		assert!(!bounds.targets.exhausted(SizeBound(2_000).into(), None));
+		// exhausts bounds.
+		assert!(bounds.targets.exhausted(None, CountBound(201).into()));
+		assert!(bounds.targets.exhausted(SizeBound(2_001).into(), None));
+	}
+
+	#[test]
+	fn election_bounds_ensure_limits_works() {
+		let bounds = ElectionBounds {
+			voters: DataProviderBounds { count: Some(CountBound(10)), size: Some(SizeBound(10)) },
+			targets: DataProviderBounds { count: Some(CountBound(10)), size: Some(SizeBound(10)) },
+		};
+
+		assert_ok!(bounds.ensure_voters_limits(CountBound(1), SizeBound(1)));
+		assert_ok!(bounds.ensure_voters_limits(CountBound(1), SizeBound(1)));
+		assert_ok!(bounds.ensure_voters_limits(CountBound(10), SizeBound(10)));
+		assert_err!(
+			bounds.ensure_voters_limits(CountBound(1), SizeBound(11)),
+			"Ensure voters bounds: bounds exceeded."
+		);
+		assert_err!(
+			bounds.ensure_voters_limits(CountBound(11), SizeBound(10)),
+			"Ensure voters bounds: bounds exceeded."
+		);
+
+		assert_ok!(bounds.ensure_targets_limits(CountBound(1), SizeBound(1)));
+		assert_ok!(bounds.ensure_targets_limits(CountBound(1), SizeBound(1)));
+		assert_ok!(bounds.ensure_targets_limits(CountBound(10), SizeBound(10)));
+		assert_err!(
+			bounds.ensure_targets_limits(CountBound(1), SizeBound(11)),
+			"Ensure targets bounds: bounds exceeded."
+		);
+		assert_err!(
+			bounds.ensure_targets_limits(CountBound(11), SizeBound(10)),
+			"Ensure targets bounds: bounds exceeded."
+		);
+	}
+
+	#[test]
+	fn data_provider_max_unbounded_works() {
+		let unbounded = DataProviderBounds::default();
+
+		// max of some bounds with unbounded data provider bounds will always return the defined
+		// bounds.
+		let bounds = DataProviderBounds { count: CountBound(5).into(), size: SizeBound(10).into() };
+		assert_eq!(unbounded.max(bounds), bounds);
+
+		let bounds = DataProviderBounds { count: None, size: SizeBound(10).into() };
+		assert_eq!(unbounded.max(bounds), bounds);
+
+		let bounds = DataProviderBounds { count: CountBound(5).into(), size: None };
+		assert_eq!(unbounded.max(bounds), bounds);
+	}
+
+	#[test]
+	fn data_provider_max_bounded_works() {
+		let bounds_one =
+			DataProviderBounds { count: CountBound(10).into(), size: SizeBound(100).into() };
+		let bounds_two =
+			DataProviderBounds { count: CountBound(100).into(), size: SizeBound(10).into() };
+		let max_bounds_expected =
+			DataProviderBounds { count: CountBound(10).into(), size: SizeBound(10).into() };
+
+		assert_eq!(bounds_one.max(bounds_two), max_bounds_expected);
+		assert_eq!(bounds_two.max(bounds_one), max_bounds_expected);
+	}
+
+	#[test]
+	fn election_bounds_clamp_works() {
+		let bounds = ElectionBoundsBuilder::default()
+			.voters_count(10.into())
+			.voters_size(10.into())
+			.voters_or_lower(DataProviderBounds {
+				count: CountBound(5).into(),
+				size: SizeBound(20).into(),
+			})
+			.targets_count(20.into())
+			.targets_or_lower(DataProviderBounds {
+				count: CountBound(30).into(),
+				size: SizeBound(30).into(),
+			})
+			.build();
+
+		assert_eq!(bounds.voters.count.unwrap(), CountBound(5));
+		assert_eq!(bounds.voters.size.unwrap(), SizeBound(10));
+		assert_eq!(bounds.targets.count.unwrap(), CountBound(20));
+		assert_eq!(bounds.targets.size.unwrap(), SizeBound(30));
+
+		// note that unbounded bounds (None) are equivalent to maximum value.
+		let bounds = ElectionBoundsBuilder::default()
+			.voters_or_lower(DataProviderBounds {
+				count: CountBound(5).into(),
+				size: SizeBound(20).into(),
+			})
+			.targets_or_lower(DataProviderBounds {
+				count: CountBound(10).into(),
+				size: SizeBound(10).into(),
+			})
+			.build();
+
+		assert_eq!(bounds.voters.count.unwrap(), CountBound(5));
+		assert_eq!(bounds.voters.size.unwrap(), SizeBound(20));
+		assert_eq!(bounds.targets.count.unwrap(), CountBound(10));
+		assert_eq!(bounds.targets.size.unwrap(), SizeBound(10));
+	}
+}
diff --git a/substrate/frame/election-provider-support/src/lib.rs b/substrate/frame/election-provider-support/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2e9ee3b8a48b581b5a5880bd24e9abd3ebd636ea
--- /dev/null
+++ b/substrate/frame/election-provider-support/src/lib.rs
@@ -0,0 +1,690 @@
+// 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.
+
+//! Primitive traits for providing election functionality.
+//!
+//! This crate provides two traits that could interact to enable extensible election functionality
+//! within FRAME pallets.
+//!
+//! Something that will provide the functionality of election will implement
+//! [`ElectionProvider`] and its parent-trait [`ElectionProviderBase`], whilst needing an
+//! associated [`ElectionProviderBase::DataProvider`], which needs to be
+//! fulfilled by an entity implementing [`ElectionDataProvider`]. Most often, *the data provider is*
+//! the receiver of the election, resulting in a diagram as below:
+//!
+//! ```ignore
+//!                                         ElectionDataProvider
+//!                          <------------------------------------------+
+//!                          |                                          |
+//!                          v                                          |
+//!                    +-----+----+                              +------+---+
+//!                    |          |                              |          |
+//! pallet-do-election |          |                              |          | pallet-needs-election
+//!                    |          |                              |          |
+//!                    |          |                              |          |
+//!                    +-----+----+                              +------+---+
+//!                          |                                          ^
+//!                          |                                          |
+//!                          +------------------------------------------+
+//!                                         ElectionProvider
+//! ```
+//!
+//! > It could also be possible that a third party pallet (C), provides the data of election to an
+//! > election provider (B), which then passes the election result to another pallet (A).
+//!
+//! ## Election Types
+//!
+//! Typically, two types of elections exist:
+//!
+//! 1. **Stateless**: Election data is provided, and the election result is immediately ready.
+//! 2. **Stateful**: Election data is is queried ahead of time, and the election result might be
+//!    ready some number of blocks in the future.
+//!
+//! To accommodate both type of elections in one trait, the traits lean toward **stateful
+//! election**, as it is more general than the stateless. This is why [`ElectionProvider::elect`]
+//! has no parameters. All value and type parameter must be provided by the [`ElectionDataProvider`]
+//! trait, even if the election happens immediately.
+//!
+//! ## Election Data
+//!
+//! The data associated with an election, essentially what the [`ElectionDataProvider`] must convey
+//! is as follows:
+//!
+//! 1. A list of voters, with their stake.
+//! 2. A list of targets (i.e. _candidates_).
+//! 3. A number of desired targets to be elected (i.e. _winners_)
+//!
+//! In addition to that, the [`ElectionDataProvider`] must also hint [`ElectionProvider`] at when
+//! the next election might happen ([`ElectionDataProvider::next_election_prediction`]). A stateless
+//! election provider would probably ignore this. A stateful election provider can use this to
+//! prepare the election result in advance.
+//!
+//! Nonetheless, an [`ElectionProvider`] shan't rely on this and should preferably provide some
+//! means of fallback election as well, in case the `elect` was called immaturely early.
+//!
+//! ## Example
+//!
+//! ```rust
+//! # use frame_election_provider_support::{*, data_provider};
+//! # use sp_npos_elections::{Support, Assignment};
+//! # use frame_support::traits::ConstU32;
+//! # use sp_runtime::bounded_vec;
+//!
+//! type AccountId = u64;
+//! type Balance = u64;
+//! type BlockNumber = u32;
+//!
+//! mod data_provider_mod {
+//!     use super::*;
+//!
+//!     pub trait Config: Sized {
+//!         type ElectionProvider: ElectionProvider<
+//!             AccountId = AccountId,
+//!             BlockNumber = BlockNumber,
+//!             DataProvider = Pallet<Self>,
+//!         >;
+//!     }
+//!
+//!     pub struct Pallet<T: Config>(std::marker::PhantomData<T>);
+//!
+//!     impl<T: Config> ElectionDataProvider for Pallet<T> {
+//!         type AccountId = AccountId;
+//!         type BlockNumber = BlockNumber;
+//!         type MaxVotesPerVoter = ConstU32<1>;
+//!
+//!         fn desired_targets() -> data_provider::Result<u32> {
+//!             Ok(1)
+//!         }
+//!         fn electing_voters(bounds: DataProviderBounds)
+//!           -> data_provider::Result<Vec<VoterOf<Self>>>
+//!         {
+//!             Ok(Default::default())
+//!         }
+//!         fn electable_targets(bounds: DataProviderBounds) -> data_provider::Result<Vec<AccountId>> {
+//!             Ok(vec![10, 20, 30])
+//!         }
+//!         fn next_election_prediction(now: BlockNumber) -> BlockNumber {
+//!             0
+//!         }
+//!     }
+//! }
+//!
+//!
+//! mod generic_election_provider {
+//!     use super::*;
+//!
+//!     pub struct GenericElectionProvider<T: Config>(std::marker::PhantomData<T>);
+//!
+//!     pub trait Config {
+//!         type DataProvider: ElectionDataProvider<AccountId=AccountId, BlockNumber = BlockNumber>;
+//!     }
+//!
+//!     impl<T: Config> ElectionProviderBase for GenericElectionProvider<T> {
+//!         type AccountId = AccountId;
+//!         type BlockNumber = BlockNumber;
+//!         type Error = &'static str;
+//!         type DataProvider = T::DataProvider;
+//!         type MaxWinners = ConstU32<{ u32::MAX }>;
+//!
+//!     }
+//!
+//!     impl<T: Config> ElectionProvider for GenericElectionProvider<T> {
+//!         fn ongoing() -> bool { false }
+//!         fn elect() -> Result<BoundedSupportsOf<Self>, Self::Error> {
+//!             Self::DataProvider::electable_targets(DataProviderBounds::default())
+//!                 .map_err(|_| "failed to elect")
+//!                 .map(|t| bounded_vec![(t[0], Support::default())])
+//!         }
+//!     }
+//! }
+//!
+//! mod runtime {
+//!     use super::generic_election_provider;
+//!     use super::data_provider_mod;
+//!     use super::AccountId;
+//!
+//!     struct Runtime;
+//!     impl generic_election_provider::Config for Runtime {
+//!         type DataProvider = data_provider_mod::Pallet<Runtime>;
+//!     }
+//!
+//!     impl data_provider_mod::Config for Runtime {
+//!         type ElectionProvider = generic_election_provider::GenericElectionProvider<Runtime>;
+//!     }
+//!
+//! }
+//!
+//! # fn main() {}
+//! ```
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod bounds;
+pub mod onchain;
+pub mod traits;
+
+use sp_runtime::{
+	traits::{Bounded, Saturating, Zero},
+	RuntimeDebug,
+};
+use sp_std::{fmt::Debug, prelude::*};
+
+pub use bounds::DataProviderBounds;
+pub use codec::{Decode, Encode};
+/// Re-export the solution generation macro.
+pub use frame_election_provider_solution_type::generate_solution_type;
+pub use frame_support::{traits::Get, weights::Weight, BoundedVec};
+/// Re-export some type as they are used in the interface.
+pub use sp_arithmetic::PerThing;
+pub use sp_npos_elections::{
+	Assignment, BalancingConfig, BoundedSupports, ElectionResult, Error, ExtendedBalance,
+	IdentifierT, PerThing128, Support, Supports, VoteWeight,
+};
+pub use traits::NposSolution;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+// re-export for the solution macro, with the dependencies of the macro.
+#[doc(hidden)]
+pub mod private {
+	pub use codec;
+	pub use scale_info;
+	pub use sp_arithmetic;
+	pub use sp_std;
+
+	// Simple Extension trait to easily convert `None` from index closures to `Err`.
+	//
+	// This is only generated and re-exported for the solution code to use.
+	pub trait __OrInvalidIndex<T> {
+		fn or_invalid_index(self) -> Result<T, crate::Error>;
+	}
+
+	impl<T> __OrInvalidIndex<T> for Option<T> {
+		fn or_invalid_index(self) -> Result<T, crate::Error> {
+			self.ok_or(crate::Error::SolutionInvalidIndex)
+		}
+	}
+}
+
+use private::__OrInvalidIndex;
+
+pub mod weights;
+pub use weights::WeightInfo;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+/// The [`IndexAssignment`] type is an intermediate between the assignments list
+/// ([`&[Assignment<T>]`][Assignment]) and `SolutionOf<T>`.
+///
+/// The voter and target identifiers have already been replaced with appropriate indices,
+/// making it fast to repeatedly encode into a `SolutionOf<T>`. This property turns out
+/// to be important when trimming for solution length.
+#[derive(RuntimeDebug, Clone, Default)]
+#[cfg_attr(feature = "std", derive(PartialEq, Eq, Encode, Decode))]
+pub struct IndexAssignment<VoterIndex, TargetIndex, P: PerThing> {
+	/// Index of the voter among the voters list.
+	pub who: VoterIndex,
+	/// The distribution of the voter's stake among winning targets.
+	///
+	/// Targets are identified by their index in the canonical list.
+	pub distribution: Vec<(TargetIndex, P)>,
+}
+
+impl<VoterIndex, TargetIndex, P: PerThing> IndexAssignment<VoterIndex, TargetIndex, P> {
+	pub fn new<AccountId: IdentifierT>(
+		assignment: &Assignment<AccountId, P>,
+		voter_index: impl Fn(&AccountId) -> Option<VoterIndex>,
+		target_index: impl Fn(&AccountId) -> Option<TargetIndex>,
+	) -> Result<Self, Error> {
+		Ok(Self {
+			who: voter_index(&assignment.who).or_invalid_index()?,
+			distribution: assignment
+				.distribution
+				.iter()
+				.map(|(target, proportion)| Some((target_index(target)?, *proportion)))
+				.collect::<Option<Vec<_>>>()
+				.or_invalid_index()?,
+		})
+	}
+}
+
+/// A type alias for [`IndexAssignment`] made from [`NposSolution`].
+pub type IndexAssignmentOf<C> = IndexAssignment<
+	<C as NposSolution>::VoterIndex,
+	<C as NposSolution>::TargetIndex,
+	<C as NposSolution>::Accuracy,
+>;
+
+/// Types that are used by the data provider trait.
+pub mod data_provider {
+	/// Alias for the result type of the election data provider.
+	pub type Result<T> = sp_std::result::Result<T, &'static str>;
+}
+
+/// Something that can provide the data to an [`ElectionProvider`].
+pub trait ElectionDataProvider {
+	/// The account identifier type.
+	type AccountId: Encode;
+
+	/// The block number type.
+	type BlockNumber;
+
+	/// Maximum number of votes per voter that this data provider is providing.
+	type MaxVotesPerVoter: Get<u32>;
+
+	/// All possible targets for the election, i.e. the targets that could become elected, thus
+	/// "electable".
+	///
+	/// This should be implemented as a self-weighing function. The implementor should register its
+	/// appropriate weight at the end of execution with the system pallet directly.
+	fn electable_targets(bounds: DataProviderBounds)
+		-> data_provider::Result<Vec<Self::AccountId>>;
+
+	/// All the voters that participate in the election, thus "electing".
+	///
+	/// Note that if a notion of self-vote exists, it should be represented here.
+	///
+	/// This should be implemented as a self-weighing function. The implementor should register its
+	/// appropriate weight at the end of execution with the system pallet directly.
+	fn electing_voters(bounds: DataProviderBounds) -> data_provider::Result<Vec<VoterOf<Self>>>;
+
+	/// The number of targets to elect.
+	///
+	/// This should be implemented as a self-weighing function. The implementor should register its
+	/// appropriate weight at the end of execution with the system pallet directly.
+	///
+	/// A sensible implementation should use the minimum between this value and
+	/// [`Self::targets().len()`], since desiring a winner set larger than candidates is not
+	/// feasible.
+	///
+	/// This is documented further in issue: <https://github.com/paritytech/substrate/issues/9478>
+	fn desired_targets() -> data_provider::Result<u32>;
+
+	/// Provide a best effort prediction about when the next election is about to happen.
+	///
+	/// In essence, the implementor should predict with this function when it will trigger the
+	/// [`ElectionProvider::elect`].
+	///
+	/// This is only useful for stateful election providers.
+	fn next_election_prediction(now: Self::BlockNumber) -> Self::BlockNumber;
+
+	/// Utility function only to be used in benchmarking scenarios, to be implemented optionally,
+	/// else a noop.
+	#[cfg(any(feature = "runtime-benchmarks", test))]
+	fn put_snapshot(
+		_voters: Vec<VoterOf<Self>>,
+		_targets: Vec<Self::AccountId>,
+		_target_stake: Option<VoteWeight>,
+	) {
+	}
+
+	/// Utility function only to be used in benchmarking scenarios, to be implemented optionally,
+	/// else a noop.
+	///
+	/// Same as `put_snapshot`, but can add a single voter one by one.
+	#[cfg(any(feature = "runtime-benchmarks", test))]
+	fn add_voter(
+		_voter: Self::AccountId,
+		_weight: VoteWeight,
+		_targets: BoundedVec<Self::AccountId, Self::MaxVotesPerVoter>,
+	) {
+	}
+
+	/// Utility function only to be used in benchmarking scenarios, to be implemented optionally,
+	/// else a noop.
+	///
+	/// Same as `put_snapshot`, but can add a single voter one by one.
+	#[cfg(any(feature = "runtime-benchmarks", test))]
+	fn add_target(_target: Self::AccountId) {}
+
+	/// Clear all voters and targets.
+	#[cfg(any(feature = "runtime-benchmarks", test))]
+	fn clear() {}
+}
+
+/// Base trait for types that can provide election
+pub trait ElectionProviderBase {
+	/// The account identifier type.
+	type AccountId;
+
+	/// The block number type.
+	type BlockNumber;
+
+	/// The error type that is returned by the provider.
+	type Error: Debug;
+
+	/// The upper bound on election winners that can be returned.
+	///
+	/// # WARNING
+	///
+	/// when communicating with the data provider, one must ensure that
+	/// `DataProvider::desired_targets` returns a value less than this bound. An
+	/// implementation can chose to either return an error and/or sort and
+	/// truncate the output to meet this bound.
+	type MaxWinners: Get<u32>;
+
+	/// The data provider of the election.
+	type DataProvider: ElectionDataProvider<
+		AccountId = Self::AccountId,
+		BlockNumber = Self::BlockNumber,
+	>;
+
+	/// checked call to `Self::DataProvider::desired_targets()` ensuring the value never exceeds
+	/// [`Self::MaxWinners`].
+	fn desired_targets_checked() -> data_provider::Result<u32> {
+		Self::DataProvider::desired_targets().and_then(|desired_targets| {
+			if desired_targets <= Self::MaxWinners::get() {
+				Ok(desired_targets)
+			} else {
+				Err("desired_targets must not be greater than MaxWinners.")
+			}
+		})
+	}
+}
+
+/// Elect a new set of winners, bounded by `MaxWinners`.
+///
+/// It must always use [`ElectionProviderBase::DataProvider`] to fetch the data it needs.
+///
+/// This election provider that could function asynchronously. This implies that this election might
+/// needs data ahead of time (ergo, receives no arguments to `elect`), and might be `ongoing` at
+/// times.
+pub trait ElectionProvider: ElectionProviderBase {
+	/// Indicate if this election provider is currently ongoing an asynchronous election or not.
+	fn ongoing() -> bool;
+
+	/// Performs the election. This should be implemented as a self-weighing function. The
+	/// implementor should register its appropriate weight at the end of execution with the
+	/// system pallet directly.
+	fn elect() -> Result<BoundedSupportsOf<Self>, Self::Error>;
+}
+
+/// A (almost) marker trait that signifies an election provider as working synchronously. i.e. being
+/// *instant*.
+///
+/// This must still use the same data provider as with [`ElectionProviderBase::DataProvider`].
+/// However, it can optionally overwrite the amount of voters and targets that are fetched from the
+/// data provider at runtime via `forced_input_voters_bound` and `forced_input_target_bound`.
+pub trait InstantElectionProvider: ElectionProviderBase {
+	fn instant_elect(
+		forced_input_voters_bound: DataProviderBounds,
+		forced_input_target_bound: DataProviderBounds,
+	) -> Result<BoundedSupportsOf<Self>, Self::Error>;
+}
+
+/// An election provider that does nothing whatsoever.
+pub struct NoElection<X>(sp_std::marker::PhantomData<X>);
+
+impl<AccountId, BlockNumber, DataProvider, MaxWinners> ElectionProviderBase
+	for NoElection<(AccountId, BlockNumber, DataProvider, MaxWinners)>
+where
+	DataProvider: ElectionDataProvider<AccountId = AccountId, BlockNumber = BlockNumber>,
+	MaxWinners: Get<u32>,
+{
+	type AccountId = AccountId;
+	type BlockNumber = BlockNumber;
+	type Error = &'static str;
+	type MaxWinners = MaxWinners;
+	type DataProvider = DataProvider;
+}
+
+impl<AccountId, BlockNumber, DataProvider, MaxWinners> ElectionProvider
+	for NoElection<(AccountId, BlockNumber, DataProvider, MaxWinners)>
+where
+	DataProvider: ElectionDataProvider<AccountId = AccountId, BlockNumber = BlockNumber>,
+	MaxWinners: Get<u32>,
+{
+	fn ongoing() -> bool {
+		false
+	}
+
+	fn elect() -> Result<BoundedSupportsOf<Self>, Self::Error> {
+		Err("`NoElection` cannot do anything.")
+	}
+}
+
+impl<AccountId, BlockNumber, DataProvider, MaxWinners> InstantElectionProvider
+	for NoElection<(AccountId, BlockNumber, DataProvider, MaxWinners)>
+where
+	DataProvider: ElectionDataProvider<AccountId = AccountId, BlockNumber = BlockNumber>,
+	MaxWinners: Get<u32>,
+{
+	fn instant_elect(
+		_: DataProviderBounds,
+		_: DataProviderBounds,
+	) -> Result<BoundedSupportsOf<Self>, Self::Error> {
+		Err("`NoElection` cannot do anything.")
+	}
+}
+
+/// A utility trait for something to implement `ElectionDataProvider` in a sensible way.
+///
+/// This is generic over `AccountId` and it can represent a validator, a nominator, or any other
+/// entity.
+///
+/// The scores (see [`Self::Score`]) are ascending, the higher, the better.
+///
+/// Something that implements this trait will do a best-effort sort over ids, and thus can be
+/// used on the implementing side of [`ElectionDataProvider`].
+pub trait SortedListProvider<AccountId> {
+	/// The list's error type.
+	type Error: sp_std::fmt::Debug;
+
+	/// The type used by the list to compare nodes for ordering.
+	type Score: Bounded + Saturating + Zero;
+
+	/// An iterator over the list, which can have `take` called on it.
+	fn iter() -> Box<dyn Iterator<Item = AccountId>>;
+
+	/// Returns an iterator over the list, starting right after from the given voter.
+	///
+	/// May return an error if `start` is invalid.
+	fn iter_from(start: &AccountId) -> Result<Box<dyn Iterator<Item = AccountId>>, Self::Error>;
+
+	/// The current count of ids in the list.
+	fn count() -> u32;
+
+	/// Return true if the list already contains `id`.
+	fn contains(id: &AccountId) -> bool;
+
+	/// Hook for inserting a new id.
+	///
+	/// Implementation should return an error if duplicate item is being inserted.
+	fn on_insert(id: AccountId, score: Self::Score) -> Result<(), Self::Error>;
+
+	/// Hook for updating a single id.
+	///
+	/// The `new` score is given.
+	///
+	/// Returns `Ok(())` iff it successfully updates an item, an `Err(_)` otherwise.
+	fn on_update(id: &AccountId, score: Self::Score) -> Result<(), Self::Error>;
+
+	/// Get the score of `id`.
+	fn get_score(id: &AccountId) -> Result<Self::Score, Self::Error>;
+
+	/// Same as `on_update`, but incorporate some increased score.
+	fn on_increase(id: &AccountId, additional: Self::Score) -> Result<(), Self::Error> {
+		let old_score = Self::get_score(id)?;
+		let new_score = old_score.saturating_add(additional);
+		Self::on_update(id, new_score)
+	}
+
+	/// Same as `on_update`, but incorporate some decreased score.
+	///
+	/// If the new score of the item is `Zero`, it is removed.
+	fn on_decrease(id: &AccountId, decreased: Self::Score) -> Result<(), Self::Error> {
+		let old_score = Self::get_score(id)?;
+		let new_score = old_score.saturating_sub(decreased);
+		if new_score.is_zero() {
+			Self::on_remove(id)
+		} else {
+			Self::on_update(id, new_score)
+		}
+	}
+
+	/// Hook for removing am id from the list.
+	///
+	/// Returns `Ok(())` iff it successfully removes an item, an `Err(_)` otherwise.
+	fn on_remove(id: &AccountId) -> Result<(), Self::Error>;
+
+	/// Regenerate this list from scratch. Returns the count of items inserted.
+	///
+	/// This should typically only be used at a runtime upgrade.
+	///
+	/// ## WARNING
+	///
+	/// This function should be called with care, regenerate will remove the current list write the
+	/// new list, which can lead to too many storage accesses, exhausting the block weight.
+	fn unsafe_regenerate(
+		all: impl IntoIterator<Item = AccountId>,
+		score_of: Box<dyn Fn(&AccountId) -> Self::Score>,
+	) -> u32;
+
+	/// Remove all items from the list.
+	///
+	/// ## WARNING
+	///
+	/// This function should never be called in production settings because it can lead to an
+	/// unbounded amount of storage accesses.
+	fn unsafe_clear();
+
+	/// Check internal state of the list. Only meant for debugging.
+	#[cfg(feature = "try-runtime")]
+	fn try_state() -> Result<(), TryRuntimeError>;
+
+	/// If `who` changes by the returned amount they are guaranteed to have a worst case change
+	/// in their list position.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn score_update_worst_case(_who: &AccountId, _is_increase: bool) -> Self::Score;
+}
+
+/// Something that can provide the `Score` of an account. Similar to [`ElectionProvider`] and
+/// [`ElectionDataProvider`], this should typically be implementing by whoever is supposed to *use*
+/// `SortedListProvider`.
+pub trait ScoreProvider<AccountId> {
+	type Score;
+
+	/// Get the current `Score` of `who`.
+	fn score(who: &AccountId) -> Self::Score;
+
+	/// For tests, benchmarks and fuzzing, set the `score`.
+	#[cfg(any(feature = "runtime-benchmarks", feature = "fuzz", feature = "std"))]
+	fn set_score_of(_: &AccountId, _: Self::Score) {}
+}
+
+/// Something that can compute the result to an NPoS solution.
+pub trait NposSolver {
+	/// The account identifier type of this solver.
+	type AccountId: sp_npos_elections::IdentifierT;
+	/// The accuracy of this solver. This will affect the accuracy of the output.
+	type Accuracy: PerThing128;
+	/// The error type of this implementation.
+	type Error: sp_std::fmt::Debug + sp_std::cmp::PartialEq;
+
+	/// Solve an NPoS solution with the given `voters`, `targets`, and select `to_elect` count
+	/// of `targets`.
+	fn solve(
+		to_elect: usize,
+		targets: Vec<Self::AccountId>,
+		voters: Vec<(Self::AccountId, VoteWeight, impl IntoIterator<Item = Self::AccountId>)>,
+	) -> Result<ElectionResult<Self::AccountId, Self::Accuracy>, Self::Error>;
+
+	/// Measure the weight used in the calculation of the solver.
+	/// - `voters` is the number of voters.
+	/// - `targets` is the number of targets.
+	/// - `vote_degree` is the degree ie the maximum numbers of votes per voter.
+	fn weight<T: WeightInfo>(voters: u32, targets: u32, vote_degree: u32) -> Weight;
+}
+
+/// A wrapper for [`sp_npos_elections::seq_phragmen`] that implements [`NposSolver`]. See the
+/// documentation of [`sp_npos_elections::seq_phragmen`] for more info.
+pub struct SequentialPhragmen<AccountId, Accuracy, Balancing = ()>(
+	sp_std::marker::PhantomData<(AccountId, Accuracy, Balancing)>,
+);
+
+impl<AccountId: IdentifierT, Accuracy: PerThing128, Balancing: Get<Option<BalancingConfig>>>
+	NposSolver for SequentialPhragmen<AccountId, Accuracy, Balancing>
+{
+	type AccountId = AccountId;
+	type Accuracy = Accuracy;
+	type Error = sp_npos_elections::Error;
+	fn solve(
+		winners: usize,
+		targets: Vec<Self::AccountId>,
+		voters: Vec<(Self::AccountId, VoteWeight, impl IntoIterator<Item = Self::AccountId>)>,
+	) -> Result<ElectionResult<Self::AccountId, Self::Accuracy>, Self::Error> {
+		sp_npos_elections::seq_phragmen(winners, targets, voters, Balancing::get())
+	}
+
+	fn weight<T: WeightInfo>(voters: u32, targets: u32, vote_degree: u32) -> Weight {
+		T::phragmen(voters, targets, vote_degree)
+	}
+}
+
+/// A wrapper for [`sp_npos_elections::phragmms()`] that implements [`NposSolver`]. See the
+/// documentation of [`sp_npos_elections::phragmms()`] for more info.
+pub struct PhragMMS<AccountId, Accuracy, Balancing = ()>(
+	sp_std::marker::PhantomData<(AccountId, Accuracy, Balancing)>,
+);
+
+impl<AccountId: IdentifierT, Accuracy: PerThing128, Balancing: Get<Option<BalancingConfig>>>
+	NposSolver for PhragMMS<AccountId, Accuracy, Balancing>
+{
+	type AccountId = AccountId;
+	type Accuracy = Accuracy;
+	type Error = sp_npos_elections::Error;
+	fn solve(
+		winners: usize,
+		targets: Vec<Self::AccountId>,
+		voters: Vec<(Self::AccountId, VoteWeight, impl IntoIterator<Item = Self::AccountId>)>,
+	) -> Result<ElectionResult<Self::AccountId, Self::Accuracy>, Self::Error> {
+		sp_npos_elections::phragmms(winners, targets, voters, Balancing::get())
+	}
+
+	fn weight<T: WeightInfo>(voters: u32, targets: u32, vote_degree: u32) -> Weight {
+		T::phragmms(voters, targets, vote_degree)
+	}
+}
+
+/// A voter, at the level of abstraction of this crate.
+pub type Voter<AccountId, Bound> = (AccountId, VoteWeight, BoundedVec<AccountId, Bound>);
+
+/// Same as [`Voter`], but parameterized by an [`ElectionDataProvider`].
+pub type VoterOf<D> =
+	Voter<<D as ElectionDataProvider>::AccountId, <D as ElectionDataProvider>::MaxVotesPerVoter>;
+
+/// Same as `BoundedSupports` but parameterized by a `ElectionProviderBase`.
+pub type BoundedSupportsOf<E> = BoundedSupports<
+	<E as ElectionProviderBase>::AccountId,
+	<E as ElectionProviderBase>::MaxWinners,
+>;
+
+sp_core::generate_feature_enabled_macro!(
+	runtime_benchmarks_enabled,
+	feature = "runtime-benchmarks",
+	$
+);
+
+sp_core::generate_feature_enabled_macro!(
+	runtime_benchmarks_fuzz_or_std_enabled,
+	any(feature = "runtime-benchmarks", feature = "fuzzing", feature = "std"),
+	$
+);
diff --git a/substrate/frame/election-provider-support/src/mock.rs b/substrate/frame/election-provider-support/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5cbe305eb522dfabc8a1b2e2d0568b72183cf91d
--- /dev/null
+++ b/substrate/frame/election-provider-support/src/mock.rs
@@ -0,0 +1,184 @@
+// 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.
+
+//! Mock file for solution-type.
+
+#![cfg(test)]
+
+use std::{
+	collections::{HashMap, HashSet},
+	hash::Hash,
+};
+
+use rand::{seq::SliceRandom, Rng};
+
+pub type AccountId = u64;
+
+/// The candidate mask allows easy disambiguation between voters and candidates: accounts
+/// for which this bit is set are candidates, and without it, are voters.
+pub const CANDIDATE_MASK: AccountId = 1 << ((std::mem::size_of::<AccountId>() * 8) - 1);
+
+pub type TestAccuracy = sp_runtime::Perbill;
+
+pub fn p(p: u8) -> TestAccuracy {
+	TestAccuracy::from_percent(p.into())
+}
+
+pub type MockAssignment = crate::Assignment<AccountId, TestAccuracy>;
+pub type Voter = (AccountId, crate::VoteWeight, Vec<AccountId>);
+
+crate::generate_solution_type! {
+	pub struct TestSolution::<
+		VoterIndex = u32,
+		TargetIndex = u16,
+		Accuracy = TestAccuracy,
+		MaxVoters = frame_support::traits::ConstU32::<2_500>,
+	>(16)
+}
+
+/// Generate voter and assignment lists. Makes no attempt to be realistic about winner or assignment
+/// fairness.
+///
+/// Maintains these invariants:
+///
+/// - candidate ids have `CANDIDATE_MASK` bit set
+/// - voter ids do not have `CANDIDATE_MASK` bit set
+/// - assignments have the same ordering as voters
+/// - `assignments.distribution.iter().map(|(_, frac)| frac).sum() == One::one()`
+/// - a coherent set of winners is chosen.
+/// - the winner set is a subset of the candidate set.
+/// - `assignments.distribution.iter().all(|(who, _)| winners.contains(who))`
+pub fn generate_random_votes(
+	candidate_count: usize,
+	voter_count: usize,
+	mut rng: impl Rng,
+) -> (Vec<Voter>, Vec<MockAssignment>, Vec<AccountId>) {
+	// cache for fast generation of unique candidate and voter ids
+	let mut used_ids = HashSet::with_capacity(candidate_count + voter_count);
+
+	// candidates are easy: just a completely random set of IDs
+	let mut candidates: Vec<AccountId> = Vec::with_capacity(candidate_count);
+	while candidates.len() < candidate_count {
+		let mut new = || rng.gen::<AccountId>() | CANDIDATE_MASK;
+		let mut id = new();
+		// insert returns `false` when the value was already present
+		while !used_ids.insert(id) {
+			id = new();
+		}
+		candidates.push(id);
+	}
+
+	// voters are random ids, random weights, random selection from the candidates
+	let mut voters = Vec::with_capacity(voter_count);
+	while voters.len() < voter_count {
+		let mut new = || rng.gen::<AccountId>() & !CANDIDATE_MASK;
+		let mut id = new();
+		// insert returns `false` when the value was already present
+		while !used_ids.insert(id) {
+			id = new();
+		}
+
+		let vote_weight = rng.gen();
+
+		// it's not interesting if a voter chooses 0 or all candidates, so rule those cases out.
+		// also, let's not generate any cases which result in a compact overflow.
+		let n_candidates_chosen =
+			rng.gen_range(1..candidates.len().min(<TestSolution as crate::NposSolution>::LIMIT));
+
+		let mut chosen_candidates = Vec::with_capacity(n_candidates_chosen);
+		chosen_candidates.extend(candidates.choose_multiple(&mut rng, n_candidates_chosen));
+		voters.push((id, vote_weight, chosen_candidates));
+	}
+
+	// always generate a sensible number of winners: elections are uninteresting if nobody wins,
+	// or everybody wins
+	let num_winners = rng.gen_range(1..candidate_count);
+	let mut winners: HashSet<AccountId> = HashSet::with_capacity(num_winners);
+	winners.extend(candidates.choose_multiple(&mut rng, num_winners));
+	assert_eq!(winners.len(), num_winners);
+
+	let mut assignments = Vec::with_capacity(voters.len());
+	for (voter_id, _, votes) in voters.iter() {
+		let chosen_winners = votes.iter().filter(|vote| winners.contains(vote)).cloned();
+		let num_chosen_winners = chosen_winners.clone().count();
+
+		// distribute the available stake randomly
+		let stake_distribution = if num_chosen_winners == 0 {
+			continue
+		} else {
+			let mut available_stake = 1000;
+			let mut stake_distribution = Vec::with_capacity(num_chosen_winners);
+			for _ in 0..num_chosen_winners - 1 {
+				let stake = rng.gen_range(0..available_stake).min(1);
+				stake_distribution.push(TestAccuracy::from_perthousand(stake));
+				available_stake -= stake;
+			}
+			stake_distribution.push(TestAccuracy::from_perthousand(available_stake));
+			stake_distribution.shuffle(&mut rng);
+			stake_distribution
+		};
+
+		assignments.push(MockAssignment {
+			who: *voter_id,
+			distribution: chosen_winners.zip(stake_distribution).collect(),
+		});
+	}
+
+	(voters, assignments, candidates)
+}
+
+fn generate_cache<Voters, Item>(voters: Voters) -> HashMap<Item, usize>
+where
+	Voters: Iterator<Item = Item>,
+	Item: Hash + Eq + Copy,
+{
+	let mut cache = HashMap::new();
+	for (idx, voter_id) in voters.enumerate() {
+		cache.insert(voter_id, idx);
+	}
+	cache
+}
+
+/// Create a function that returns the index of a voter in the voters list.
+pub fn make_voter_fn<VoterIndex>(voters: &[Voter]) -> impl Fn(&AccountId) -> Option<VoterIndex>
+where
+	usize: TryInto<VoterIndex>,
+{
+	let cache = generate_cache(voters.iter().map(|(id, _, _)| *id));
+	move |who| {
+		if cache.get(who).is_none() {
+			println!("WARNING: voter {} will raise InvalidIndex", who);
+		}
+		cache.get(who).cloned().and_then(|i| i.try_into().ok())
+	}
+}
+
+/// Create a function that returns the index of a candidate in the candidates list.
+pub fn make_target_fn<TargetIndex>(
+	candidates: &[AccountId],
+) -> impl Fn(&AccountId) -> Option<TargetIndex>
+where
+	usize: TryInto<TargetIndex>,
+{
+	let cache = generate_cache(candidates.iter().cloned());
+	move |who| {
+		if cache.get(who).is_none() {
+			println!("WARNING: target {} will raise InvalidIndex", who);
+		}
+		cache.get(who).cloned().and_then(|i| i.try_into().ok())
+	}
+}
diff --git a/substrate/frame/election-provider-support/src/onchain.rs b/substrate/frame/election-provider-support/src/onchain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8ac245a360bb5358f630360e5d384936d69c5d8e
--- /dev/null
+++ b/substrate/frame/election-provider-support/src/onchain.rs
@@ -0,0 +1,329 @@
+// 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.
+
+//! An implementation of [`ElectionProvider`] that uses an `NposSolver` to do the election. As the
+//! name suggests, this is meant to be used onchain. Given how heavy the calculations are, please be
+//! careful when using it onchain.
+
+use crate::{
+	bounds::{DataProviderBounds, ElectionBounds, ElectionBoundsBuilder},
+	BoundedSupportsOf, Debug, ElectionDataProvider, ElectionProvider, ElectionProviderBase,
+	InstantElectionProvider, NposSolver, WeightInfo,
+};
+use frame_support::{dispatch::DispatchClass, traits::Get};
+use sp_npos_elections::{
+	assignment_ratio_to_staked_normalized, to_supports, BoundedSupports, ElectionResult, VoteWeight,
+};
+use sp_std::{collections::btree_map::BTreeMap, marker::PhantomData, prelude::*};
+
+/// Errors of the on-chain election.
+#[derive(Eq, PartialEq, Debug)]
+pub enum Error {
+	/// An internal error in the NPoS elections crate.
+	NposElections(sp_npos_elections::Error),
+	/// Errors from the data provider.
+	DataProvider(&'static str),
+	/// Configurational error caused by `desired_targets` requested by data provider exceeding
+	/// `MaxWinners`.
+	TooManyWinners,
+}
+
+impl From<sp_npos_elections::Error> for Error {
+	fn from(e: sp_npos_elections::Error) -> Self {
+		Error::NposElections(e)
+	}
+}
+
+/// A simple on-chain implementation of the election provider trait.
+///
+/// This implements both `ElectionProvider` and `InstantElectionProvider`.
+///
+/// This type has some utilities to make it safe. Nonetheless, it should be used with utmost care. A
+/// thoughtful value must be set as [`Config::Bounds`] to ensure the size of the input is sensible.
+pub struct OnChainExecution<T: Config>(PhantomData<T>);
+
+#[deprecated(note = "use OnChainExecution, which is bounded by default")]
+pub type BoundedExecution<T> = OnChainExecution<T>;
+
+/// Configuration trait for an onchain election execution.
+pub trait Config {
+	/// Needed for weight registration.
+	type System: frame_system::Config;
+
+	/// `NposSolver` that should be used, an example would be `PhragMMS`.
+	type Solver: NposSolver<
+		AccountId = <Self::System as frame_system::Config>::AccountId,
+		Error = sp_npos_elections::Error,
+	>;
+
+	/// Something that provides the data for election.
+	type DataProvider: ElectionDataProvider<
+		AccountId = <Self::System as frame_system::Config>::AccountId,
+		BlockNumber = frame_system::pallet_prelude::BlockNumberFor<Self::System>,
+	>;
+
+	/// Weight information for extrinsics in this pallet.
+	type WeightInfo: WeightInfo;
+
+	/// Upper bound on maximum winners from electable targets.
+	///
+	/// As noted in the documentation of [`ElectionProviderBase::MaxWinners`], this value should
+	/// always be more than `DataProvider::desired_target`.
+	type MaxWinners: Get<u32>;
+
+	/// Elections bounds, to use when calling into [`Config::DataProvider`]. It might be overwritten
+	/// in the `InstantElectionProvider` impl.
+	type Bounds: Get<ElectionBounds>;
+}
+
+/// Same as `BoundedSupportsOf` but for `onchain::Config`.
+pub type OnChainBoundedSupportsOf<E> = BoundedSupports<
+	<<E as Config>::System as frame_system::Config>::AccountId,
+	<E as Config>::MaxWinners,
+>;
+
+fn elect_with_input_bounds<T: Config>(
+	bounds: ElectionBounds,
+) -> Result<OnChainBoundedSupportsOf<T>, Error> {
+	let (voters, targets) = T::DataProvider::electing_voters(bounds.voters)
+		.and_then(|voters| Ok((voters, T::DataProvider::electable_targets(bounds.targets)?)))
+		.map_err(Error::DataProvider)?;
+
+	let desired_targets = T::DataProvider::desired_targets().map_err(Error::DataProvider)?;
+
+	if desired_targets > T::MaxWinners::get() {
+		// early exit
+		return Err(Error::TooManyWinners)
+	}
+
+	let voters_len = voters.len() as u32;
+	let targets_len = targets.len() as u32;
+
+	let stake_map: BTreeMap<_, _> = voters
+		.iter()
+		.map(|(validator, vote_weight, _)| (validator.clone(), *vote_weight))
+		.collect();
+
+	let stake_of = |w: &<T::System as frame_system::Config>::AccountId| -> VoteWeight {
+		stake_map.get(w).cloned().unwrap_or_default()
+	};
+
+	let ElectionResult { winners: _, assignments } =
+		T::Solver::solve(desired_targets as usize, targets, voters).map_err(Error::from)?;
+
+	let staked = assignment_ratio_to_staked_normalized(assignments, &stake_of)?;
+
+	let weight = T::Solver::weight::<T::WeightInfo>(
+		voters_len,
+		targets_len,
+		<T::DataProvider as ElectionDataProvider>::MaxVotesPerVoter::get(),
+	);
+	frame_system::Pallet::<T::System>::register_extra_weight_unchecked(
+		weight,
+		DispatchClass::Mandatory,
+	);
+
+	// defensive: Since npos solver returns a result always bounded by `desired_targets`, this is
+	// never expected to happen as long as npos solver does what is expected for it to do.
+	let supports: OnChainBoundedSupportsOf<T> =
+		to_supports(&staked).try_into().map_err(|_| Error::TooManyWinners)?;
+
+	Ok(supports)
+}
+
+impl<T: Config> ElectionProviderBase for OnChainExecution<T> {
+	type AccountId = <T::System as frame_system::Config>::AccountId;
+	type BlockNumber = frame_system::pallet_prelude::BlockNumberFor<T::System>;
+	type Error = Error;
+	type MaxWinners = T::MaxWinners;
+	type DataProvider = T::DataProvider;
+}
+
+impl<T: Config> InstantElectionProvider for OnChainExecution<T> {
+	fn instant_elect(
+		forced_input_voters_bounds: DataProviderBounds,
+		forced_input_targets_bounds: DataProviderBounds,
+	) -> Result<BoundedSupportsOf<Self>, Self::Error> {
+		let elections_bounds = ElectionBoundsBuilder::from(T::Bounds::get())
+			.voters_or_lower(forced_input_voters_bounds)
+			.targets_or_lower(forced_input_targets_bounds)
+			.build();
+
+		elect_with_input_bounds::<T>(elections_bounds)
+	}
+}
+
+impl<T: Config> ElectionProvider for OnChainExecution<T> {
+	fn ongoing() -> bool {
+		false
+	}
+
+	fn elect() -> Result<BoundedSupportsOf<Self>, Self::Error> {
+		let election_bounds = ElectionBoundsBuilder::from(T::Bounds::get()).build();
+		elect_with_input_bounds::<T>(election_bounds)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{ElectionProvider, PhragMMS, SequentialPhragmen};
+	use frame_support::{assert_noop, parameter_types};
+	use sp_npos_elections::Support;
+	use sp_runtime::Perbill;
+	type AccountId = u64;
+	type Nonce = u64;
+	type BlockNumber = u64;
+
+	pub type Header = sp_runtime::generic::Header<BlockNumber, sp_runtime::traits::BlakeTwo256>;
+	pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<AccountId, (), (), ()>;
+	pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+
+	frame_support::construct_runtime!(
+		pub struct Runtime
+		{
+			System: frame_system::{Pallet, Call, Event<T>},
+		}
+	);
+
+	impl frame_system::Config for Runtime {
+		type SS58Prefix = ();
+		type BaseCallFilter = frame_support::traits::Everything;
+		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 = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+		type Block = Block;
+		type RuntimeEvent = ();
+		type BlockHashCount = ();
+		type DbWeight = ();
+		type BlockLength = ();
+		type BlockWeights = ();
+		type Version = ();
+		type PalletInfo = PalletInfo;
+		type AccountData = ();
+		type OnNewAccount = ();
+		type OnKilledAccount = ();
+		type SystemWeightInfo = ();
+		type OnSetCode = ();
+		type MaxConsumers = frame_support::traits::ConstU32<16>;
+	}
+
+	struct PhragmenParams;
+	struct PhragMMSParams;
+
+	parameter_types! {
+		pub static MaxWinners: u32 = 10;
+		pub static DesiredTargets: u32 = 2;
+		pub static Bounds: ElectionBounds = ElectionBoundsBuilder::default().voters_count(600.into()).targets_count(400.into()).build();
+	}
+
+	impl Config for PhragmenParams {
+		type System = Runtime;
+		type Solver = SequentialPhragmen<AccountId, Perbill>;
+		type DataProvider = mock_data_provider::DataProvider;
+		type WeightInfo = ();
+		type MaxWinners = MaxWinners;
+		type Bounds = Bounds;
+	}
+
+	impl Config for PhragMMSParams {
+		type System = Runtime;
+		type Solver = PhragMMS<AccountId, Perbill>;
+		type DataProvider = mock_data_provider::DataProvider;
+		type WeightInfo = ();
+		type MaxWinners = MaxWinners;
+		type Bounds = Bounds;
+	}
+
+	mod mock_data_provider {
+		use frame_support::traits::ConstU32;
+		use sp_runtime::bounded_vec;
+
+		use super::*;
+		use crate::{data_provider, VoterOf};
+
+		pub struct DataProvider;
+		impl ElectionDataProvider for DataProvider {
+			type AccountId = AccountId;
+			type BlockNumber = BlockNumber;
+			type MaxVotesPerVoter = ConstU32<2>;
+			fn electing_voters(_: DataProviderBounds) -> data_provider::Result<Vec<VoterOf<Self>>> {
+				Ok(vec![
+					(1, 10, bounded_vec![10, 20]),
+					(2, 20, bounded_vec![30, 20]),
+					(3, 30, bounded_vec![10, 30]),
+				])
+			}
+
+			fn electable_targets(_: DataProviderBounds) -> data_provider::Result<Vec<AccountId>> {
+				Ok(vec![10, 20, 30])
+			}
+
+			fn desired_targets() -> data_provider::Result<u32> {
+				Ok(DesiredTargets::get())
+			}
+
+			fn next_election_prediction(_: BlockNumber) -> BlockNumber {
+				0
+			}
+		}
+	}
+
+	#[test]
+	fn onchain_seq_phragmen_works() {
+		sp_io::TestExternalities::new_empty().execute_with(|| {
+			assert_eq!(
+				<OnChainExecution::<PhragmenParams> as ElectionProvider>::elect().unwrap(),
+				vec![
+					(10, Support { total: 25, voters: vec![(1, 10), (3, 15)] }),
+					(30, Support { total: 35, voters: vec![(2, 20), (3, 15)] })
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn too_many_winners_when_desired_targets_exceed_max_winners() {
+		sp_io::TestExternalities::new_empty().execute_with(|| {
+			// given desired targets larger than max winners
+			DesiredTargets::set(10);
+			MaxWinners::set(9);
+
+			assert_noop!(
+				<OnChainExecution::<PhragmenParams> as ElectionProvider>::elect(),
+				Error::TooManyWinners,
+			);
+		})
+	}
+
+	#[test]
+	fn onchain_phragmms_works() {
+		sp_io::TestExternalities::new_empty().execute_with(|| {
+			assert_eq!(
+				<OnChainExecution::<PhragMMSParams> as ElectionProvider>::elect().unwrap(),
+				vec![
+					(10, Support { total: 25, voters: vec![(1, 10), (3, 15)] }),
+					(30, Support { total: 35, voters: vec![(2, 20), (3, 15)] })
+				]
+			);
+		})
+	}
+}
diff --git a/substrate/frame/election-provider-support/src/tests.rs b/substrate/frame/election-provider-support/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..73ce1427cf2f00883865a4b8c6cc5fad864d9c13
--- /dev/null
+++ b/substrate/frame/election-provider-support/src/tests.rs
@@ -0,0 +1,454 @@
+// 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 solution-type.
+
+#![cfg(test)]
+
+use crate::{mock::*, IndexAssignment, NposSolution};
+use frame_support::traits::ConstU32;
+use rand::SeedableRng;
+
+mod solution_type {
+	use super::*;
+	use codec::{Decode, Encode, MaxEncodedLen};
+	// these need to come from the same dev-dependency `frame-election-provider-support`, not from
+	// the crate.
+	use crate::{generate_solution_type, Assignment, Error as NposError, NposSolution};
+	use sp_std::fmt::Debug;
+
+	#[allow(dead_code)]
+	mod __private {
+		// This is just to make sure that the solution can be generated in a scope without any
+		// imports.
+		use crate::generate_solution_type;
+		generate_solution_type!(
+			#[compact]
+			struct InnerTestSolutionIsolated::<
+				VoterIndex = u32,
+				TargetIndex = u8,
+				Accuracy = sp_runtime::Percent,
+				MaxVoters = crate::tests::ConstU32::<20>,
+			>(12)
+		);
+	}
+
+	#[test]
+	fn solution_struct_works_with_and_without_compact() {
+		// we use u32 size to make sure compact is smaller.
+		let without_compact = {
+			generate_solution_type!(
+				pub struct InnerTestSolution::<
+					VoterIndex = u32,
+					TargetIndex = u32,
+					Accuracy = TestAccuracy,
+					MaxVoters = ConstU32::<20>,
+				>(16)
+			);
+			let solution = InnerTestSolution {
+				votes1: vec![(2, 20), (4, 40)],
+				votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+				..Default::default()
+			};
+
+			solution.encode().len()
+		};
+
+		let with_compact = {
+			generate_solution_type!(
+				#[compact]
+				pub struct InnerTestSolutionCompact::<
+					VoterIndex = u32,
+					TargetIndex = u32,
+					Accuracy = TestAccuracy,
+					MaxVoters = ConstU32::<20>,
+				>(16)
+			);
+			let compact = InnerTestSolutionCompact {
+				votes1: vec![(2, 20), (4, 40)],
+				votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+				..Default::default()
+			};
+
+			compact.encode().len()
+		};
+
+		assert!(with_compact < without_compact);
+	}
+
+	#[test]
+	fn from_assignment_fail_too_many_voters() {
+		let rng = rand::rngs::SmallRng::seed_from_u64(1);
+
+		// This will produce 24 voters..
+		let (voters, assignments, candidates) = generate_random_votes(10, 25, rng);
+		let voter_index = make_voter_fn(&voters);
+		let target_index = make_target_fn(&candidates);
+
+		// Limit the voters to 20..
+		generate_solution_type!(
+			pub struct InnerTestSolution::<
+				VoterIndex = u32,
+				TargetIndex = u16,
+				Accuracy = TestAccuracy,
+				MaxVoters = frame_support::traits::ConstU32::<20>,
+			>(16)
+		);
+
+		// 24 > 20, so this should fail.
+		assert_eq!(
+			InnerTestSolution::from_assignment(&assignments, &voter_index, &target_index)
+				.unwrap_err(),
+			NposError::TooManyVoters,
+		);
+	}
+
+	#[test]
+	fn max_encoded_len_too_small() {
+		generate_solution_type!(
+			pub struct InnerTestSolution::<
+				VoterIndex = u32,
+				TargetIndex = u32,
+				Accuracy = TestAccuracy,
+				MaxVoters = ConstU32::<1>,
+			>(3)
+		);
+		let solution = InnerTestSolution {
+			votes1: vec![(2, 20), (4, 40)],
+			votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+			..Default::default()
+		};
+
+		// We actually have 4 voters, but the bound is 1 voter, so the implemented bound is too
+		// small.
+		assert!(solution.encode().len() > InnerTestSolution::max_encoded_len());
+	}
+
+	#[test]
+	fn max_encoded_len_upper_bound() {
+		generate_solution_type!(
+			pub struct InnerTestSolution::<
+				VoterIndex = u32,
+				TargetIndex = u32,
+				Accuracy = TestAccuracy,
+				MaxVoters = ConstU32::<4>,
+			>(3)
+		);
+		let solution = InnerTestSolution {
+			votes1: vec![(2, 20), (4, 40)],
+			votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+			..Default::default()
+		};
+
+		// We actually have 4 voters, and the bound is 4 voters, so the implemented bound should be
+		// larger than the encoded len.
+		assert!(solution.encode().len() < InnerTestSolution::max_encoded_len());
+	}
+
+	#[test]
+	fn max_encoded_len_exact() {
+		generate_solution_type!(
+			pub struct InnerTestSolution::<
+				VoterIndex = u32,
+				TargetIndex = u32,
+				Accuracy = TestAccuracy,
+				MaxVoters = ConstU32::<4>,
+			>(3)
+		);
+		let solution = InnerTestSolution {
+			votes1: vec![],
+			votes2: vec![],
+			votes3: vec![
+				(1, [(10, p(50)), (11, p(20))], 12),
+				(2, [(20, p(50)), (21, p(20))], 22),
+				(3, [(30, p(50)), (31, p(20))], 32),
+				(4, [(40, p(50)), (41, p(20))], 42),
+			],
+		};
+
+		// We have 4 voters, the bound is 4 voters, and all the voters voted for 3 targets, which is
+		// the max number of targets. This should represent the upper bound that `max_encoded_len`
+		// represents.
+		assert_eq!(solution.encode().len(), InnerTestSolution::max_encoded_len());
+	}
+
+	#[test]
+	fn solution_struct_is_codec() {
+		let solution = TestSolution {
+			votes1: vec![(2, 20), (4, 40)],
+			votes2: vec![(1, [(10, p(80))], 11), (5, [(50, p(85))], 51)],
+			..Default::default()
+		};
+
+		let encoded = solution.encode();
+
+		assert_eq!(solution, Decode::decode(&mut &encoded[..]).unwrap());
+		assert_eq!(solution.voter_count(), 4);
+		assert_eq!(solution.edge_count(), 2 + 4);
+		assert_eq!(solution.unique_targets(), vec![10, 11, 20, 40, 50, 51]);
+	}
+
+	#[test]
+	fn remove_voter_works() {
+		let mut solution = TestSolution {
+			votes1: vec![(0, 2), (1, 6)],
+			votes2: vec![(2, [(0, p(80))], 1), (3, [(7, p(85))], 8)],
+			votes3: vec![(4, [(3, p(50)), (4, p(25))], 5)],
+			..Default::default()
+		};
+
+		assert!(!solution.remove_voter(11));
+		assert!(solution.remove_voter(2));
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2), (1, 6)],
+				votes2: vec![(3, [(7, p(85))], 8)],
+				votes3: vec![(4, [(3, p(50)), (4, p(25))], 5,)],
+				..Default::default()
+			},
+		);
+
+		assert!(solution.remove_voter(4));
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2), (1, 6)],
+				votes2: vec![(3, [(7, p(85))], 8)],
+				..Default::default()
+			},
+		);
+
+		assert!(solution.remove_voter(1));
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2)],
+				votes2: vec![(3, [(7, p(85))], 8),],
+				..Default::default()
+			},
+		);
+	}
+
+	#[test]
+	fn from_and_into_assignment_works() {
+		let voters = vec![2 as AccountId, 4, 1, 5, 3];
+		let targets = vec![
+			10 as AccountId,
+			11,
+			20, // 2
+			30,
+			31, // 4
+			32,
+			40, // 6
+			50,
+			51, // 8
+		];
+
+		let assignments = vec![
+			Assignment { who: 2 as AccountId, distribution: vec![(20u64, p(100))] },
+			Assignment { who: 4, distribution: vec![(40, p(100))] },
+			Assignment { who: 1, distribution: vec![(10, p(80)), (11, p(20))] },
+			Assignment { who: 5, distribution: vec![(50, p(85)), (51, p(15))] },
+			Assignment { who: 3, distribution: vec![(30, p(50)), (31, p(25)), (32, p(25))] },
+		];
+
+		let voter_index = |a: &AccountId| -> Option<u32> {
+			voters.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+		let target_index = |a: &AccountId| -> Option<u16> {
+			targets.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+
+		let solution =
+			TestSolution::from_assignment(&assignments, voter_index, target_index).unwrap();
+
+		// basically number of assignments that it is encoding.
+		assert_eq!(solution.voter_count(), assignments.len());
+		assert_eq!(
+			solution.edge_count(),
+			assignments.iter().fold(0, |a, b| a + b.distribution.len()),
+		);
+
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: vec![(0, 2), (1, 6)],
+				votes2: vec![(2, [(0, p(80))], 1), (3, [(7, p(85))], 8)],
+				votes3: vec![(4, [(3, p(50)), (4, p(25))], 5)],
+				..Default::default()
+			}
+		);
+
+		assert_eq!(solution.unique_targets(), vec![0, 1, 2, 3, 4, 5, 6, 7, 8]);
+
+		let voter_at = |a: u32| -> Option<AccountId> {
+			voters.get(<u32 as TryInto<usize>>::try_into(a).unwrap()).cloned()
+		};
+		let target_at = |a: u16| -> Option<AccountId> {
+			targets.get(<u16 as TryInto<usize>>::try_into(a).unwrap()).cloned()
+		};
+
+		assert_eq!(solution.into_assignment(voter_at, target_at).unwrap(), assignments);
+	}
+
+	#[test]
+	fn unique_targets_len_edge_count_works() {
+		// we don't really care about voters here so all duplicates. This is not invalid per se.
+		let solution = TestSolution {
+			votes1: vec![(99, 1), (99, 2)],
+			votes2: vec![(99, [(3, p(10))], 7), (99, [(4, p(10))], 8)],
+			votes3: vec![(99, [(11, p(10)), (12, p(10))], 13)],
+			// ensure the last one is also counted.
+			votes16: vec![(
+				99,
+				[
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+					(66, p(10)),
+				],
+				67,
+			)],
+			..Default::default()
+		};
+
+		assert_eq!(solution.unique_targets(), vec![1, 2, 3, 4, 7, 8, 11, 12, 13, 66, 67]);
+		assert_eq!(solution.edge_count(), 2 + (2 * 2) + 3 + 16);
+		assert_eq!(solution.voter_count(), 6);
+
+		// this one has some duplicates.
+		let solution = TestSolution {
+			votes1: vec![(99, 1), (99, 1)],
+			votes2: vec![(99, [(3, p(10))], 7), (99, [(4, p(10))], 8)],
+			votes3: vec![(99, [(11, p(10)), (11, p(10))], 13)],
+			..Default::default()
+		};
+
+		assert_eq!(solution.unique_targets(), vec![1, 3, 4, 7, 8, 11, 13]);
+		assert_eq!(solution.edge_count(), 2 + (2 * 2) + 3);
+		assert_eq!(solution.voter_count(), 5);
+	}
+
+	#[test]
+	fn solution_into_assignment_must_report_overflow() {
+		// in votes2
+		let solution = TestSolution {
+			votes1: Default::default(),
+			votes2: vec![(0, [(1, p(100))], 2)],
+			..Default::default()
+		};
+
+		let voter_at = |a: u32| -> Option<AccountId> { Some(a as AccountId) };
+		let target_at = |a: u16| -> Option<AccountId> { Some(a as AccountId) };
+
+		assert_eq!(
+			solution.into_assignment(&voter_at, &target_at).unwrap_err(),
+			NposError::SolutionWeightOverflow,
+		);
+
+		// in votes3 onwards
+		let solution = TestSolution {
+			votes1: Default::default(),
+			votes2: Default::default(),
+			votes3: vec![(0, [(1, p(70)), (2, p(80))], 3)],
+			..Default::default()
+		};
+
+		assert_eq!(
+			solution.into_assignment(&voter_at, &target_at).unwrap_err(),
+			NposError::SolutionWeightOverflow,
+		);
+	}
+
+	#[test]
+	fn target_count_overflow_is_detected() {
+		let voter_index = |a: &AccountId| -> Option<u32> { Some(*a as u32) };
+		let target_index = |a: &AccountId| -> Option<u16> { Some(*a as u16) };
+
+		let assignments = vec![Assignment {
+			who: 1 as AccountId,
+			distribution: (10..27).map(|i| (i as AccountId, p(i as u8))).collect::<Vec<_>>(),
+		}];
+
+		let solution = TestSolution::from_assignment(&assignments, voter_index, target_index);
+		assert_eq!(solution.unwrap_err(), NposError::SolutionTargetOverflow);
+	}
+
+	#[test]
+	fn zero_target_count_is_ignored() {
+		let voters = vec![1 as AccountId, 2];
+		let targets = vec![10 as AccountId, 11];
+
+		let assignments = vec![
+			Assignment { who: 1 as AccountId, distribution: vec![(10, p(50)), (11, p(50))] },
+			Assignment { who: 2, distribution: vec![] },
+		];
+
+		let voter_index = |a: &AccountId| -> Option<u32> {
+			voters.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+		let target_index = |a: &AccountId| -> Option<u16> {
+			targets.iter().position(|x| x == a).map(TryInto::try_into).unwrap().ok()
+		};
+
+		let solution =
+			TestSolution::from_assignment(&assignments, voter_index, target_index).unwrap();
+
+		assert_eq!(
+			solution,
+			TestSolution {
+				votes1: Default::default(),
+				votes2: vec![(0, [(0, p(50))], 1)],
+				..Default::default()
+			}
+		);
+	}
+}
+
+#[test]
+fn index_assignments_generate_same_solution_as_plain_assignments() {
+	let rng = rand::rngs::SmallRng::seed_from_u64(0);
+
+	let (voters, assignments, candidates) = generate_random_votes(1000, 2500, rng);
+	let voter_index = make_voter_fn(&voters);
+	let target_index = make_target_fn(&candidates);
+
+	let solution =
+		TestSolution::from_assignment(&assignments, &voter_index, &target_index).unwrap();
+
+	let index_assignments = assignments
+		.into_iter()
+		.map(|assignment| IndexAssignment::new(&assignment, &voter_index, &target_index))
+		.collect::<Result<Vec<_>, _>>()
+		.unwrap();
+
+	let index_compact = index_assignments.as_slice().try_into().unwrap();
+
+	assert_eq!(solution, index_compact);
+}
diff --git a/substrate/frame/election-provider-support/src/traits.rs b/substrate/frame/election-provider-support/src/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43d183b338e297f675453c5ba361a3e0d409ab3d
--- /dev/null
+++ b/substrate/frame/election-provider-support/src/traits.rs
@@ -0,0 +1,125 @@
+// 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
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Traits for the election operations.
+
+use crate::{Assignment, IdentifierT, IndexAssignmentOf, PerThing128, VoteWeight};
+use codec::Encode;
+use scale_info::TypeInfo;
+use sp_arithmetic::traits::{Bounded, UniqueSaturatedInto};
+use sp_npos_elections::{ElectionScore, Error, EvaluateSupport};
+use sp_std::{fmt::Debug, prelude::*};
+
+/// An opaque index-based, NPoS solution type.
+pub trait NposSolution
+where
+	Self: Sized + for<'a> TryFrom<&'a [IndexAssignmentOf<Self>], Error = Error>,
+{
+	/// The maximum number of votes that are allowed.
+	const LIMIT: usize;
+
+	/// The voter type. Needs to be an index (convert to usize).
+	type VoterIndex: UniqueSaturatedInto<usize>
+		+ TryInto<usize>
+		+ TryFrom<usize>
+		+ Debug
+		+ Copy
+		+ Clone
+		+ Bounded
+		+ Encode
+		+ TypeInfo;
+
+	/// The target type. Needs to be an index (convert to usize).
+	type TargetIndex: UniqueSaturatedInto<usize>
+		+ TryInto<usize>
+		+ TryFrom<usize>
+		+ Debug
+		+ Copy
+		+ Clone
+		+ Bounded
+		+ Encode
+		+ TypeInfo;
+
+	/// The weight/accuracy type of each vote.
+	type Accuracy: PerThing128;
+
+	/// Get the length of all the voters that this type is encoding.
+	///
+	/// This is basically the same as the number of assignments, or number of active voters.
+	fn voter_count(&self) -> usize;
+
+	/// Get the total count of edges.
+	///
+	/// This is effectively in the range of {[`Self::voter_count`], [`Self::voter_count`] *
+	/// [`Self::LIMIT`]}.
+	fn edge_count(&self) -> usize;
+
+	/// Get the number of unique targets in the whole struct.
+	///
+	/// Once presented with a list of winners, this set and the set of winners must be
+	/// equal.
+	fn unique_targets(&self) -> Vec<Self::TargetIndex>;
+
+	/// Get the average edge count.
+	fn average_edge_count(&self) -> usize {
+		self.edge_count().checked_div(self.voter_count()).unwrap_or(0)
+	}
+
+	/// Compute the score of this solution type.
+	fn score<A, FS>(
+		self,
+		stake_of: FS,
+		voter_at: impl Fn(Self::VoterIndex) -> Option<A>,
+		target_at: impl Fn(Self::TargetIndex) -> Option<A>,
+	) -> Result<ElectionScore, Error>
+	where
+		for<'r> FS: Fn(&'r A) -> VoteWeight,
+		A: IdentifierT,
+	{
+		let ratio = self.into_assignment(voter_at, target_at)?;
+		let staked =
+			sp_npos_elections::helpers::assignment_ratio_to_staked_normalized(ratio, stake_of)?;
+		let supports = sp_npos_elections::to_supports(&staked);
+		Ok(supports.evaluate())
+	}
+
+	/// Remove a certain voter.
+	///
+	/// This will only search until the first instance of `to_remove`, and return true. If
+	/// no instance is found (no-op), then it returns false.
+	///
+	/// In other words, if this return true, exactly **one** element must have been removed self.
+	fn remove_voter(&mut self, to_remove: Self::VoterIndex) -> bool;
+
+	/// Build self from a list of assignments.
+	fn from_assignment<FV, FT, A>(
+		assignments: &[Assignment<A, Self::Accuracy>],
+		voter_index: FV,
+		target_index: FT,
+	) -> Result<Self, Error>
+	where
+		A: IdentifierT,
+		for<'r> FV: Fn(&'r A) -> Option<Self::VoterIndex>,
+		for<'r> FT: Fn(&'r A) -> Option<Self::TargetIndex>;
+
+	/// Convert self into a `Vec<Assignment<A, Self::Accuracy>>`
+	fn into_assignment<A: IdentifierT>(
+		self,
+		voter_at: impl Fn(Self::VoterIndex) -> Option<A>,
+		target_at: impl Fn(Self::TargetIndex) -> Option<A>,
+	) -> Result<Vec<Assignment<A, Self::Accuracy>>, Error>;
+}
diff --git a/substrate/frame/election-provider-support/src/weights.rs b/substrate/frame/election-provider-support/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..addb6ad8d03069aecd6fda3b2725cdbc37e5ba5d
--- /dev/null
+++ b/substrate/frame/election-provider-support/src/weights.rs
@@ -0,0 +1,95 @@
+// 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.
+
+//! Autogenerated weights for pallet_election_provider_support_benchmarking
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-04-23, STEPS: `1`, REPEAT: 1, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// target/release/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=1
+// --repeat=1
+// --pallet=pallet_election_provider_support_benchmarking
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=frame/election-provider-support/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_election_provider_support_benchmarking.
+pub trait WeightInfo {
+	fn phragmen(v: u32, t: u32, d: u32, ) -> Weight;
+	fn phragmms(v: u32, t: u32, d: u32, ) -> Weight;
+}
+
+/// Weights for pallet_election_provider_support_benchmarking using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	fn phragmen(v: u32, t: u32, d: u32, ) -> Weight {
+		Weight::from_parts(0 as u64, 0)
+			// Standard Error: 667_000
+			.saturating_add(Weight::from_parts(32_973_000 as u64, 0).saturating_mul(v as u64))
+			// Standard Error: 1_334_000
+			.saturating_add(Weight::from_parts(1_334_000 as u64, 0).saturating_mul(t as u64))
+			// Standard Error: 60_644_000
+			.saturating_add(Weight::from_parts(2_636_364_000 as u64, 0).saturating_mul(d as u64))
+	}
+	fn phragmms(v: u32, t: u32, d: u32, ) -> Weight {
+		Weight::from_parts(0 as u64, 0)
+			// Standard Error: 73_000
+			.saturating_add(Weight::from_parts(21_073_000 as u64, 0).saturating_mul(v as u64))
+			// Standard Error: 146_000
+			.saturating_add(Weight::from_parts(65_000 as u64, 0).saturating_mul(t as u64))
+			// Standard Error: 6_649_000
+			.saturating_add(Weight::from_parts(1_711_424_000 as u64, 0).saturating_mul(d as u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	fn phragmen(v: u32, t: u32, d: u32, ) -> Weight {
+		Weight::from_parts(0 as u64, 0)
+			// Standard Error: 667_000
+			.saturating_add(Weight::from_parts(32_973_000 as u64, 0).saturating_mul(v as u64))
+			// Standard Error: 1_334_000
+			.saturating_add(Weight::from_parts(1_334_000 as u64, 0).saturating_mul(t as u64))
+			// Standard Error: 60_644_000
+			.saturating_add(Weight::from_parts(2_636_364_000 as u64, 0).saturating_mul(d as u64))
+	}
+	fn phragmms(v: u32, t: u32, d: u32, ) -> Weight {
+		Weight::from_parts(0 as u64, 0)
+			// Standard Error: 73_000
+			.saturating_add(Weight::from_parts(21_073_000 as u64, 0).saturating_mul(v as u64))
+			// Standard Error: 146_000
+			.saturating_add(Weight::from_parts(65_000 as u64, 0).saturating_mul(t as u64))
+			// Standard Error: 6_649_000
+			.saturating_add(Weight::from_parts(1_711_424_000 as u64, 0).saturating_mul(d as u64))
+	}
+}
diff --git a/substrate/frame/elections-phragmen/CHANGELOG.md b/substrate/frame/elections-phragmen/CHANGELOG.md
new file mode 100644
index 0000000000000000000000000000000000000000..231de1d2e475e061794d45f2953f539fde26dacb
--- /dev/null
+++ b/substrate/frame/elections-phragmen/CHANGELOG.md
@@ -0,0 +1,35 @@
+# Changelog
+All notable changes to this crate will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this crate adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [4.0.0] - UNRELEASED
+
+### Added
+
+### Changed
+\[**Needs Migration**\] [migrate pallet-elections-phragmen to attribute macros](https://github.com/paritytech/substrate/pull/8044)
+
+### Fixed
+
+### Security
+
+## [3.0.0]
+
+### Added
+[Add slashing events to elections-phragmen](https://github.com/paritytech/substrate/pull/7543)
+
+### Changed
+
+### Fixed
+[Don't slash all outgoing members](https://github.com/paritytech/substrate/pull/7394)
+[Fix wrong outgoing calculation in election](https://github.com/paritytech/substrate/pull/7384)
+
+### Security
+\[**Needs Migration**\] [Fix elections-phragmen and proxy issue + Record deposits on-chain](https://github.com/paritytech/substrate/pull/7040)
+
+## [2.0.0] - 2020-09-2020
+
+Initial version from which version tracking has begun.
+
diff --git a/substrate/frame/elections-phragmen/Cargo.toml b/substrate/frame/elections-phragmen/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b8c2efdc068c004659829190c4ffa49ddc36ece0
--- /dev/null
+++ b/substrate/frame/elections-phragmen/Cargo.toml
@@ -0,0 +1,68 @@
+[package]
+name = "pallet-elections-phragmen"
+version = "5.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet based on seq-Phragmén election method."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+log = { version = "0.4.14", default-features = false }
+scale-info = { version = "2.0.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-npos-elections = { version = "4.0.0-dev", default-features = false, path = "../../primitives/npos-elections" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-staking = { default-features = false, path = "../../primitives/staking" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-tracing = { path = "../../primitives/tracing" }
+substrate-test-utils = { version = "4.0.0-dev", path = "../../test-utils" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-npos-elections/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+	"sp-tracing/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/elections-phragmen/README.md b/substrate/frame/elections-phragmen/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..26b3f260da5635de07949d7449800e3d34c1a480
--- /dev/null
+++ b/substrate/frame/elections-phragmen/README.md
@@ -0,0 +1,67 @@
+# Phragmén Election Module.
+
+An election module based on sequential phragmen.
+
+### Term and Round
+
+The election happens in _rounds_: every `N` blocks, all previous members are retired and a new
+set is elected (which may or may not have an intersection with the previous set). Each round
+lasts for some number of blocks defined by `TermDuration` storage item. The words _term_ and
+_round_ can be used interchangeably in this context.
+
+`TermDuration` might change during a round. This can shorten or extend the length of the round.
+The next election round's block number is never stored but rather always checked on the fly.
+Based on the current block number and `TermDuration`, the condition `BlockNumber % TermDuration
+== 0` being satisfied will always trigger a new election round.
+
+### Voting
+
+Voters can vote for any set of the candidates by providing a list of account ids. Invalid votes
+(voting for non-candidates) are ignored during election. Yet, a voter _might_ vote for a future
+candidate. Voters reserve a bond as they vote. Each vote defines a `value`. This amount is
+locked from the account of the voter and indicates the weight of the vote. Voters can update
+their votes at any time by calling `vote()` again. This keeps the bond untouched but can
+optionally change the locked `value`. After a round, votes are kept and might still be valid for
+further rounds. A voter is responsible for calling `remove_voter` once they are done to have
+their bond back and remove the lock.
+
+Voters also report other voters as being defunct to earn their bond. A voter is defunct once all
+of the candidates that they have voted for are neither a valid candidate anymore nor a member.
+Upon reporting, if the target voter is actually defunct, the reporter will be rewarded by the
+voting bond of the target. The target will lose their bond and get removed. If the target is not
+defunct, the reporter is slashed and removed. To prevent being reported, voters should manually
+submit a `remove_voter()` as soon as they are in the defunct state.
+
+### Candidacy and Members
+
+Candidates also reserve a bond as they submit candidacy. A candidate cannot take their candidacy
+back. A candidate can end up in one of the below situations:
+  - **Winner**: A winner is kept as a _member_. They must still have a bond in reserve and they
+    are automatically counted as a candidate for the next election.
+  - **Runner-up**: Runners-up are the best candidates immediately after the winners. The number
+    of runners_up to keep is configurable. Runners-up are used, in order that they are elected,
+    as replacements when a candidate is kicked by `[remove_member]`, or when an active member
+    renounces their candidacy. Runners are automatically counted as a candidate for the next
+    election.
+  - **Loser**: Any of the candidate who are not a winner are left as losers. A loser might be an
+    _outgoing member or runner_, meaning that they are an active member who failed to keep their
+    spot. An outgoing will always lose their bond.
+
+##### Renouncing candidacy.
+
+All candidates, elected or not, can renounce their candidacy. A call to [`Module::renounce_candidacy`]
+will always cause the candidacy bond to be refunded.
+
+Note that with the members being the default candidates for the next round and votes persisting
+in storage, the election system is entirely stable given no further input. This means that if
+the system has a particular set of candidates `C` and voters `V` that lead to a set of members
+`M` being elected, as long as `V` and `C` don't remove their candidacy and votes, `M` will keep
+being re-elected at the end of each round.
+
+### Module Information
+
+- [`election_sp_phragmen::Config`](https://docs.rs/pallet-elections-phragmen/latest/pallet_elections_phragmen/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-elections-phragmen/latest/pallet_elections_phragmen/enum.Call.html)
+- [`Module`](https://docs.rs/pallet-elections-phragmen/latest/pallet_elections_phragmen/struct.Module.html)
+
+License: Apache-2.0
diff --git a/substrate/frame/elections-phragmen/src/benchmarking.rs b/substrate/frame/elections-phragmen/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..56ea19578c8f5425bc9f42029659d64ebf9cba84
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/benchmarking.rs
@@ -0,0 +1,430 @@
+// 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.
+
+//! Elections-Phragmen pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use frame_benchmarking::v1::{account, benchmarks, whitelist, BenchmarkError, BenchmarkResult};
+use frame_support::{dispatch::DispatchResultWithPostInfo, traits::OnInitialize};
+use frame_system::RawOrigin;
+
+use crate::Pallet as Elections;
+
+const BALANCE_FACTOR: u32 = 250;
+
+/// grab new account with infinite balance.
+fn endowed_account<T: Config>(name: &'static str, index: u32) -> T::AccountId {
+	let account: T::AccountId = account(name, index, 0);
+	// Fund each account with at-least their stake but still a sane amount as to not mess up
+	// the vote calculation.
+	let amount = default_stake::<T>(T::MaxVoters::get()) * BalanceOf::<T>::from(BALANCE_FACTOR);
+	let _ = T::Currency::make_free_balance_be(&account, amount);
+	// important to increase the total issuance since T::CurrencyToVote will need it to be sane for
+	// phragmen to work.
+	T::Currency::issue(amount);
+
+	account
+}
+
+/// Account to lookup type of system trait.
+fn as_lookup<T: Config>(account: T::AccountId) -> AccountIdLookupOf<T> {
+	T::Lookup::unlookup(account)
+}
+
+/// Get a reasonable amount of stake based on the execution trait's configuration
+fn default_stake<T: Config>(num_votes: u32) -> BalanceOf<T> {
+	let min = T::Currency::minimum_balance();
+	Elections::<T>::deposit_of(num_votes as usize).max(min)
+}
+
+/// Get the current number of candidates.
+fn candidate_count<T: Config>() -> u32 {
+	<Candidates<T>>::decode_len().unwrap_or(0usize) as u32
+}
+
+/// Add `c` new candidates.
+fn submit_candidates<T: Config>(
+	c: u32,
+	prefix: &'static str,
+) -> Result<Vec<T::AccountId>, &'static str> {
+	(0..c)
+		.map(|i| {
+			let account = endowed_account::<T>(prefix, i);
+			<Elections<T>>::submit_candidacy(
+				RawOrigin::Signed(account.clone()).into(),
+				candidate_count::<T>(),
+			)
+			.map_err(|_| "failed to submit candidacy")?;
+			Ok(account)
+		})
+		.collect::<Result<_, _>>()
+}
+
+/// Add `c` new candidates with self vote.
+fn submit_candidates_with_self_vote<T: Config>(
+	c: u32,
+	prefix: &'static str,
+) -> Result<Vec<T::AccountId>, &'static str> {
+	let candidates = submit_candidates::<T>(c, prefix)?;
+	let stake = default_stake::<T>(c);
+	let _ = candidates
+		.iter()
+		.try_for_each(|c| submit_voter::<T>(c.clone(), vec![c.clone()], stake).map(|_| ()))?;
+	Ok(candidates)
+}
+
+/// Submit one voter.
+fn submit_voter<T: Config>(
+	caller: T::AccountId,
+	votes: Vec<T::AccountId>,
+	stake: BalanceOf<T>,
+) -> DispatchResultWithPostInfo {
+	<Elections<T>>::vote(RawOrigin::Signed(caller).into(), votes, stake)
+}
+
+/// create `num_voter` voters who randomly vote for at most `votes` of `all_candidates` if
+/// available.
+fn distribute_voters<T: Config>(
+	mut all_candidates: Vec<T::AccountId>,
+	num_voters: u32,
+	votes: usize,
+) -> Result<(), &'static str> {
+	let stake = default_stake::<T>(num_voters);
+	for i in 0..num_voters {
+		// to ensure that votes are different
+		all_candidates.rotate_left(1);
+		let votes = all_candidates.iter().cloned().take(votes).collect::<Vec<_>>();
+		let voter = endowed_account::<T>("voter", i);
+		submit_voter::<T>(voter, votes, stake)?;
+	}
+	Ok(())
+}
+
+/// Fill the seats of members and runners-up up until `m`. Note that this might include either only
+/// members, or members and runners-up.
+fn fill_seats_up_to<T: Config>(m: u32) -> Result<Vec<T::AccountId>, &'static str> {
+	let _ = submit_candidates_with_self_vote::<T>(m, "fill_seats_up_to")?;
+	assert_eq!(<Elections<T>>::candidates().len() as u32, m, "wrong number of candidates.");
+	<Elections<T>>::do_phragmen();
+	assert_eq!(<Elections<T>>::candidates().len(), 0, "some candidates remaining.");
+	assert_eq!(
+		<Elections<T>>::members().len() + <Elections<T>>::runners_up().len(),
+		m as usize,
+		"wrong number of members and runners-up",
+	);
+	Ok(<Elections<T>>::members()
+		.into_iter()
+		.map(|m| m.who)
+		.chain(<Elections<T>>::runners_up().into_iter().map(|r| r.who))
+		.collect())
+}
+
+/// removes all the storage items to reverse any genesis state.
+fn clean<T: Config>() {
+	<Members<T>>::kill();
+	<Candidates<T>>::kill();
+	<RunnersUp<T>>::kill();
+	#[allow(deprecated)]
+	<Voting<T>>::remove_all(None);
+}
+
+benchmarks! {
+	// -- Signed ones
+	vote_equal {
+		let v in 1 .. T::MaxVotesPerVoter::get();
+		clean::<T>();
+
+		// create a bunch of candidates.
+		let all_candidates = submit_candidates::<T>(v, "candidates")?;
+
+		let caller = endowed_account::<T>("caller", 0);
+		let stake = default_stake::<T>(v);
+
+		// original votes.
+		let mut votes = all_candidates;
+		submit_voter::<T>(caller.clone(), votes.clone(), stake)?;
+
+		// new votes.
+		votes.rotate_left(1);
+
+		whitelist!(caller);
+	}: vote(RawOrigin::Signed(caller), votes, stake)
+
+	vote_more {
+		let v in 2 .. T::MaxVotesPerVoter::get();
+		clean::<T>();
+
+		// create a bunch of candidates.
+		let all_candidates = submit_candidates::<T>(v, "candidates")?;
+
+		let caller = endowed_account::<T>("caller", 0);
+		// Multiply the stake with 10 since we want to be able to divide it by 10 again.
+		let stake = default_stake::<T>(v) * BalanceOf::<T>::from(10u32);
+
+		// original votes.
+		let mut votes = all_candidates.iter().skip(1).cloned().collect::<Vec<_>>();
+		submit_voter::<T>(caller.clone(), votes.clone(), stake / <BalanceOf<T>>::from(10u32))?;
+
+		// new votes.
+		votes = all_candidates;
+		assert!(votes.len() > <Voting<T>>::get(caller.clone()).votes.len());
+
+		whitelist!(caller);
+	}: vote(RawOrigin::Signed(caller), votes, stake / <BalanceOf<T>>::from(10u32))
+
+	vote_less {
+		let v in 2 .. T::MaxVotesPerVoter::get();
+		clean::<T>();
+
+		// create a bunch of candidates.
+		let all_candidates = submit_candidates::<T>(v, "candidates")?;
+
+		let caller = endowed_account::<T>("caller", 0);
+		let stake = default_stake::<T>(v);
+
+		// original votes.
+		let mut votes = all_candidates;
+		submit_voter::<T>(caller.clone(), votes.clone(), stake)?;
+
+		// new votes.
+		votes = votes.into_iter().skip(1).collect::<Vec<_>>();
+		assert!(votes.len() < <Voting<T>>::get(caller.clone()).votes.len());
+
+		whitelist!(caller);
+	}: vote(RawOrigin::Signed(caller), votes, stake)
+
+	remove_voter {
+		// we fix the number of voted candidates to max
+		let v = T::MaxVotesPerVoter::get();
+		clean::<T>();
+
+		// create a bunch of candidates.
+		let all_candidates = submit_candidates::<T>(v, "candidates")?;
+
+		let caller = endowed_account::<T>("caller", 0);
+
+		let stake = default_stake::<T>(v);
+		submit_voter::<T>(caller.clone(), all_candidates, stake)?;
+
+		whitelist!(caller);
+	}: _(RawOrigin::Signed(caller))
+
+	submit_candidacy {
+		// number of already existing candidates.
+		let c in 1 .. T::MaxCandidates::get();
+		// we fix the number of members to the number of desired members and runners-up. We'll be in
+		// this state almost always.
+		let m = T::DesiredMembers::get() + T::DesiredRunnersUp::get();
+
+		clean::<T>();
+		let stake = default_stake::<T>(c);
+
+		// create m members and runners combined.
+		let _ = fill_seats_up_to::<T>(m)?;
+
+		// create previous candidates;
+		let _ = submit_candidates::<T>(c, "candidates")?;
+
+		// we assume worse case that: extrinsic is successful and candidate is not duplicate.
+		let candidate_account = endowed_account::<T>("caller", 0);
+		whitelist!(candidate_account);
+	}: _(RawOrigin::Signed(candidate_account.clone()), candidate_count::<T>())
+	verify {
+		#[cfg(test)]
+		{
+			// reset members in between benchmark tests.
+			use crate::tests::MEMBERS;
+			MEMBERS.with(|m| *m.borrow_mut() = vec![]);
+		}
+	}
+
+	renounce_candidacy_candidate {
+		// this will check members, runners-up and candidate for removal. Members and runners-up are
+		// limited by the runtime bound, nonetheless we fill them by `m`.
+		// number of already existing candidates.
+		let c in 1 .. T::MaxCandidates::get();
+		// we fix the number of members to the number of desired members and runners-up. We'll be in
+		// this state almost always.
+		let m = T::DesiredMembers::get() + T::DesiredRunnersUp::get();
+
+		clean::<T>();
+
+		// create m members and runners combined.
+		let _ = fill_seats_up_to::<T>(m)?;
+		let all_candidates = submit_candidates::<T>(c, "caller")?;
+
+		let bailing = all_candidates[0].clone(); // Should be ("caller", 0)
+		let count = candidate_count::<T>();
+		whitelist!(bailing);
+	}: renounce_candidacy(RawOrigin::Signed(bailing), Renouncing::Candidate(count))
+	verify {
+		#[cfg(test)]
+		{
+			// reset members in between benchmark tests.
+			use crate::tests::MEMBERS;
+			MEMBERS.with(|m| *m.borrow_mut() = vec![]);
+		}
+	}
+
+	renounce_candidacy_members {
+		// removing members and runners will be cheaper than a candidate.
+		// we fix the number of members to when members and runners-up to the desired. We'll be in
+		// this state almost always.
+		let m = T::DesiredMembers::get() + T::DesiredRunnersUp::get();
+		clean::<T>();
+
+		// create m members and runners combined.
+		let members_and_runners_up = fill_seats_up_to::<T>(m)?;
+
+		let bailing = members_and_runners_up[0].clone();
+		assert!(<Elections<T>>::is_member(&bailing));
+
+		whitelist!(bailing);
+	}: renounce_candidacy(RawOrigin::Signed(bailing.clone()), Renouncing::Member)
+	verify {
+		#[cfg(test)]
+		{
+			// reset members in between benchmark tests.
+			use crate::tests::MEMBERS;
+			MEMBERS.with(|m| *m.borrow_mut() = vec![]);
+		}
+	}
+
+	renounce_candidacy_runners_up {
+		// removing members and runners will be cheaper than a candidate.
+		// we fix the number of members to when members and runners-up to the desired. We'll be in
+		// this state almost always.
+		let m = T::DesiredMembers::get() + T::DesiredRunnersUp::get();
+		clean::<T>();
+
+		// create m members and runners combined.
+		let members_and_runners_up = fill_seats_up_to::<T>(m)?;
+
+		let bailing = members_and_runners_up[T::DesiredMembers::get() as usize + 1].clone();
+		assert!(<Elections<T>>::is_runner_up(&bailing));
+
+		whitelist!(bailing);
+	}: renounce_candidacy(RawOrigin::Signed(bailing.clone()), Renouncing::RunnerUp)
+	verify {
+		#[cfg(test)]
+		{
+			// reset members in between benchmark tests.
+			use crate::tests::MEMBERS;
+			MEMBERS.with(|m| *m.borrow_mut() = vec![]);
+		}
+	}
+
+	// We use the max block weight for this extrinsic for now. See below.
+	remove_member_without_replacement {}: {
+		Err(BenchmarkError::Override(
+			BenchmarkResult::from_weight(T::BlockWeights::get().max_block)
+		))?;
+	}
+
+	remove_member_with_replacement {
+		// easy case. We have a runner up. Nothing will have that much of an impact. m will be
+		// number of members and runners. There is always at least one runner.
+		let m = T::DesiredMembers::get() + T::DesiredRunnersUp::get();
+		clean::<T>();
+
+		let _ = fill_seats_up_to::<T>(m)?;
+		let removing = as_lookup::<T>(<Elections<T>>::members_ids()[0].clone());
+	}: remove_member(RawOrigin::Root, removing, true, false)
+	verify {
+		// must still have enough members.
+		assert_eq!(<Elections<T>>::members().len() as u32, T::DesiredMembers::get());
+		#[cfg(test)]
+		{
+			// reset members in between benchmark tests.
+			use crate::tests::MEMBERS;
+			MEMBERS.with(|m| *m.borrow_mut() = vec![]);
+		}
+	}
+
+	clean_defunct_voters {
+		// total number of voters.
+		let v in (T::MaxVoters::get() / 2) .. T::MaxVoters::get();
+		// those that are defunct and need removal.
+		let d in 0 .. (T::MaxVoters::get() / 2);
+
+		// remove any previous stuff.
+		clean::<T>();
+
+		let all_candidates = submit_candidates::<T>(T::MaxCandidates::get(), "candidates")?;
+		distribute_voters::<T>(all_candidates, v, T::MaxVotesPerVoter::get() as usize)?;
+
+		// all candidates leave.
+		<Candidates<T>>::kill();
+
+		// now everyone is defunct
+		assert!(<Voting<T>>::iter().all(|(_, v)| <Elections<T>>::is_defunct_voter(&v.votes)));
+		assert_eq!(<Voting<T>>::iter().count() as u32, v);
+		let root = RawOrigin::Root;
+	}: _(root, v, d)
+	verify {
+		assert_eq!(<Voting<T>>::iter().count() as u32, 0);
+	}
+
+	election_phragmen {
+		// This is just to focus on phragmen in the context of this module. We always select 20
+		// members, this is hard-coded in the runtime and cannot be trivially changed at this stage.
+		// Yet, change the number of voters, candidates and edge per voter to see the impact. Note
+		// that we give all candidates a self vote to make sure they are all considered.
+		let c in 1 .. T::MaxCandidates::get();
+		let v in 1 .. T::MaxVoters::get();
+		let e in (T::MaxVoters::get()) .. T::MaxVoters::get() * T::MaxVotesPerVoter::get();
+		clean::<T>();
+
+		// so we have a situation with v and e. we want e to basically always be in the range of `e
+		// -> e * T::MaxVotesPerVoter::get()`, but we cannot express that now with the benchmarks.
+		// So what we do is: when c is being iterated, v, and e are max and fine. when v is being
+		// iterated, e is being set to max and this is a problem. In these cases, we cap e to a
+		// lower value, namely v * T::MaxVotesPerVoter::get(). when e is being iterated, v is at
+		// max, and again fine. all in all, votes_per_voter can never be more than
+		// T::MaxVotesPerVoter::get(). Note that this might cause `v` to be an overestimate.
+		let votes_per_voter = (e / v).min(T::MaxVotesPerVoter::get());
+
+		let all_candidates = submit_candidates_with_self_vote::<T>(c, "candidates")?;
+		let _ = distribute_voters::<T>(all_candidates, v.saturating_sub(c), votes_per_voter as usize)?;
+	}: {
+		<Elections<T>>::on_initialize(T::TermDuration::get());
+	}
+	verify {
+		assert_eq!(<Elections<T>>::members().len() as u32, T::DesiredMembers::get().min(c));
+		assert_eq!(
+			<Elections<T>>::runners_up().len() as u32,
+			T::DesiredRunnersUp::get().min(c.saturating_sub(T::DesiredMembers::get())),
+		);
+
+		#[cfg(test)]
+		{
+			// reset members in between benchmark tests.
+			use crate::tests::MEMBERS;
+			MEMBERS.with(|m| *m.borrow_mut() = vec![]);
+		}
+	}
+
+	impl_benchmark_test_suite!(
+		Elections,
+		crate::tests::ExtBuilder::default().desired_members(13).desired_runners_up(7),
+		crate::tests::Test,
+		exec_name = build_and_execute,
+	);
+}
diff --git a/substrate/frame/elections-phragmen/src/lib.rs b/substrate/frame/elections-phragmen/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6912649bd122d8d66014b9f805f54732c01bc18b
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/lib.rs
@@ -0,0 +1,3327 @@
+// 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.
+
+//! # Phragmén Election Module.
+//!
+//! An election module based on sequential phragmen.
+//!
+//! ### Term and Round
+//!
+//! The election happens in _rounds_: every `N` blocks, all previous members are retired and a new
+//! set is elected (which may or may not have an intersection with the previous set). Each round
+//! lasts for some number of blocks defined by [`Config::TermDuration`]. The words _term_ and
+//! _round_ can be used interchangeably in this context.
+//!
+//! [`Config::TermDuration`] might change during a round. This can shorten or extend the length of
+//! the round. The next election round's block number is never stored but rather always checked on
+//! the fly. Based on the current block number and [`Config::TermDuration`], the condition
+//! `BlockNumber % TermDuration == 0` being satisfied will always trigger a new election round.
+//!
+//! ### Bonds and Deposits
+//!
+//! Both voting and being a candidate requires deposits to be taken, in exchange for the data that
+//! needs to be kept on-chain. The terms *bond* and *deposit* can be used interchangeably in this
+//! context.
+//!
+//! Bonds will be unreserved only upon adhering to the protocol laws. Failing to do so will cause in
+//! the bond to slashed.
+//!
+//! ### Voting
+//!
+//! Voters can vote for a limited number of the candidates by providing a list of account ids,
+//! bounded by [`Config::MaxVotesPerVoter`]. Invalid votes (voting for non-candidates) and duplicate
+//! votes are ignored during election. Yet, a voter _might_ vote for a future candidate. Voters
+//! reserve a bond as they vote. Each vote defines a `value`. This amount is locked from the account
+//! of the voter and indicates the weight of the vote. Voters can update their votes at any time by
+//! calling `vote()` again. This can update the vote targets (which might update the deposit) or
+//! update the vote's stake ([`Voter::stake`]). After a round, votes are kept and might still be
+//! valid for further rounds. A voter is responsible for calling `remove_voter` once they are done
+//! to have their bond back and remove the lock.
+//!
+//! See [`Call::vote`], [`Call::remove_voter`].
+//!
+//! ### Defunct Voter
+//!
+//! A voter is defunct once all of the candidates that they have voted for are not a valid candidate
+//! (as seen further below, members and runners-up are also always candidates). Defunct voters can
+//! be removed via a root call ([`Call::clean_defunct_voters`]). Upon being removed, their bond is
+//! returned. This is an administrative operation and can be called only by the root origin in the
+//! case of state bloat.
+//!
+//! ### Candidacy and Members
+//!
+//! Candidates also reserve a bond as they submit candidacy. A candidate can end up in one of the
+//! below situations:
+//!   - **Members**: A winner is kept as a _member_. They must still have a bond in reserve and they
+//!     are automatically counted as a candidate for the next election. The number of desired
+//!     members is set by [`Config::DesiredMembers`].
+//!   - **Runner-up**: Runners-up are the best candidates immediately after the winners. The number
+//!     of runners up to keep is set by [`Config::DesiredRunnersUp`]. Runners-up are used, in the
+//!     same order as they are elected, as replacements when a candidate is kicked by
+//!     [`Call::remove_member`], or when an active member renounces their candidacy. Runners are
+//!     automatically counted as a candidate for the next election.
+//!   - **Loser**: Any of the candidate who are not member/runner-up are left as losers. A loser
+//!     might be an _outgoing member or runner-up_, meaning that they are an active member who
+//!     failed to keep their spot. **An outgoing candidate/member/runner-up will always lose their
+//!     bond**.
+//!
+//! #### Renouncing candidacy.
+//!
+//! All candidates, elected or not, can renounce their candidacy. A call to
+//! [`Call::renounce_candidacy`] will always cause the candidacy bond to be refunded.
+//!
+//! Note that with the members being the default candidates for the next round and votes persisting
+//! in storage, the election system is entirely stable given no further input. This means that if
+//! the system has a particular set of candidates `C` and voters `V` that lead to a set of members
+//! `M` being elected, as long as `V` and `C` don't remove their candidacy and votes, `M` will keep
+//! being re-elected at the end of each round.
+//!
+//! ### Module Information
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Module`]
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+use frame_support::{
+	traits::{
+		defensive_prelude::*, ChangeMembers, Contains, ContainsLengthBound, Currency, Get,
+		InitializeMembers, LockIdentifier, LockableCurrency, OnUnbalanced, ReservableCurrency,
+		SortedMembers, WithdrawReasons,
+	},
+	weights::Weight,
+};
+use log;
+use scale_info::TypeInfo;
+use sp_npos_elections::{ElectionResult, ExtendedBalance};
+use sp_runtime::{
+	traits::{Saturating, StaticLookup, Zero},
+	DispatchError, Perbill, RuntimeDebug,
+};
+use sp_staking::currency_to_vote::CurrencyToVote;
+use sp_std::{cmp::Ordering, prelude::*};
+
+#[cfg(any(feature = "try-runtime", test))]
+use sp_runtime::TryRuntimeError;
+
+mod benchmarking;
+pub mod weights;
+pub use weights::WeightInfo;
+
+/// All migrations.
+pub mod migrations;
+
+const LOG_TARGET: &str = "runtime::elections-phragmen";
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+
+/// An indication that the renouncing account currently has which of the below roles.
+#[derive(Encode, Decode, Clone, PartialEq, RuntimeDebug, TypeInfo)]
+pub enum Renouncing {
+	/// A member is renouncing.
+	Member,
+	/// A runner-up is renouncing.
+	RunnerUp,
+	/// A candidate is renouncing, while the given total number of candidates exists.
+	Candidate(#[codec(compact)] u32),
+}
+
+/// An active voter.
+#[derive(Encode, Decode, Clone, RuntimeDebug, PartialEq, TypeInfo)]
+pub struct Voter<AccountId, Balance> {
+	/// The members being backed.
+	pub votes: Vec<AccountId>,
+	/// The amount of stake placed on this vote.
+	pub stake: Balance,
+	/// The amount of deposit reserved for this vote.
+	///
+	/// To be unreserved upon removal.
+	pub deposit: Balance,
+}
+
+impl<AccountId, Balance: Default> Default for Voter<AccountId, Balance> {
+	fn default() -> Self {
+		Self { votes: vec![], stake: Default::default(), deposit: Default::default() }
+	}
+}
+
+/// A holder of a seat as either a member or a runner-up.
+#[derive(Encode, Decode, Clone, Default, RuntimeDebug, PartialEq, TypeInfo)]
+pub struct SeatHolder<AccountId, Balance> {
+	/// The holder.
+	pub who: AccountId,
+	/// The total backing stake.
+	pub stake: Balance,
+	/// The amount of deposit held on-chain.
+	///
+	/// To be unreserved upon renouncing, or slashed upon being a loser.
+	pub deposit: Balance,
+}
+
+pub use pallet::*;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Identifier for the elections-phragmen pallet's lock
+		#[pallet::constant]
+		type PalletId: Get<LockIdentifier>;
+
+		/// The currency that people are electing with.
+		type Currency: LockableCurrency<Self::AccountId, Moment = BlockNumberFor<Self>>
+			+ ReservableCurrency<Self::AccountId>;
+
+		/// What to do when the members change.
+		type ChangeMembers: ChangeMembers<Self::AccountId>;
+
+		/// What to do with genesis members
+		type InitializeMembers: InitializeMembers<Self::AccountId>;
+
+		/// Convert a balance into a number used for election calculation.
+		/// This must fit into a `u64` but is allowed to be sensibly lossy.
+		type CurrencyToVote: CurrencyToVote<BalanceOf<Self>>;
+
+		/// How much should be locked up in order to submit one's candidacy.
+		#[pallet::constant]
+		type CandidacyBond: Get<BalanceOf<Self>>;
+
+		/// Base deposit associated with voting.
+		///
+		/// This should be sensibly high to economically ensure the pallet cannot be attacked by
+		/// creating a gigantic number of votes.
+		#[pallet::constant]
+		type VotingBondBase: Get<BalanceOf<Self>>;
+
+		/// The amount of bond that need to be locked for each vote (32 bytes).
+		#[pallet::constant]
+		type VotingBondFactor: Get<BalanceOf<Self>>;
+
+		/// Handler for the unbalanced reduction when a candidate has lost (and is not a runner-up)
+		type LoserCandidate: OnUnbalanced<NegativeImbalanceOf<Self>>;
+
+		/// Handler for the unbalanced reduction when a member has been kicked.
+		type KickedMember: OnUnbalanced<NegativeImbalanceOf<Self>>;
+
+		/// Number of members to elect.
+		#[pallet::constant]
+		type DesiredMembers: Get<u32>;
+
+		/// Number of runners_up to keep.
+		#[pallet::constant]
+		type DesiredRunnersUp: Get<u32>;
+
+		/// How long each seat is kept. This defines the next block number at which an election
+		/// round will happen. If set to zero, no elections are ever triggered and the module will
+		/// be in passive mode.
+		#[pallet::constant]
+		type TermDuration: Get<BlockNumberFor<Self>>;
+
+		/// The maximum number of candidates in a phragmen election.
+		///
+		/// Warning: This impacts the size of the election which is run onchain. Chose wisely, and
+		/// consider how it will impact `T::WeightInfo::election_phragmen`.
+		///
+		/// When this limit is reached no more candidates are accepted in the election.
+		#[pallet::constant]
+		type MaxCandidates: Get<u32>;
+
+		/// The maximum number of voters to allow in a phragmen election.
+		///
+		/// Warning: This impacts the size of the election which is run onchain. Chose wisely, and
+		/// consider how it will impact `T::WeightInfo::election_phragmen`.
+		///
+		/// When the limit is reached the new voters are ignored.
+		#[pallet::constant]
+		type MaxVoters: Get<u32>;
+
+		/// Maximum numbers of votes per voter.
+		///
+		/// Warning: This impacts the size of the election which is run onchain. Chose wisely, and
+		/// consider how it will impact `T::WeightInfo::election_phragmen`.
+		#[pallet::constant]
+		type MaxVotesPerVoter: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// What to do at the end of each block.
+		///
+		/// Checks if an election needs to happen or not.
+		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+			let term_duration = T::TermDuration::get();
+			if !term_duration.is_zero() && (n % term_duration).is_zero() {
+				Self::do_phragmen()
+			} else {
+				Weight::zero()
+			}
+		}
+
+		fn integrity_test() {
+			let block_weight = T::BlockWeights::get().max_block;
+			// mind the order.
+			let election_weight = T::WeightInfo::election_phragmen(
+				T::MaxCandidates::get(),
+				T::MaxVoters::get(),
+				T::MaxVotesPerVoter::get() * T::MaxVoters::get(),
+			);
+
+			let to_seconds = |w: &Weight| {
+				w.ref_time() as f32 /
+					frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND as f32
+			};
+
+			log::debug!(
+				target: LOG_TARGET,
+				"election weight {}s ({:?}) // chain's block weight {}s ({:?})",
+				to_seconds(&election_weight),
+				election_weight,
+				to_seconds(&block_weight),
+				block_weight,
+			);
+			assert!(
+				election_weight.all_lt(block_weight),
+				"election weight {}s ({:?}) will exceed a {}s chain's block weight ({:?}) (MaxCandidates {}, MaxVoters {}, MaxVotesPerVoter {} -- tweak these parameters)",
+				election_weight,
+				to_seconds(&election_weight),
+				to_seconds(&block_weight),
+				block_weight,
+				T::MaxCandidates::get(),
+				T::MaxVoters::get(),
+				T::MaxVotesPerVoter::get(),
+			);
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_n: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+			Self::do_try_state()
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Vote for a set of candidates for the upcoming round of election. This can be called to
+		/// set the initial votes, or update already existing votes.
+		///
+		/// Upon initial voting, `value` units of `who`'s balance is locked and a deposit amount is
+		/// reserved. The deposit is based on the number of votes and can be updated over time.
+		///
+		/// The `votes` should:
+		///   - not be empty.
+		///   - be less than the number of possible candidates. Note that all current members and
+		///     runners-up are also automatically candidates for the next round.
+		///
+		/// If `value` is more than `who`'s free balance, then the maximum of the two is used.
+		///
+		/// The dispatch origin of this call must be signed.
+		///
+		/// ### Warning
+		///
+		/// It is the responsibility of the caller to **NOT** place all of their balance into the
+		/// lock and keep some for further operations.
+		#[pallet::call_index(0)]
+		#[pallet::weight(
+			T::WeightInfo::vote_more(votes.len() as u32)
+			.max(T::WeightInfo::vote_less(votes.len() as u32))
+			.max(T::WeightInfo::vote_equal(votes.len() as u32))
+		)]
+		pub fn vote(
+			origin: OriginFor<T>,
+			votes: Vec<T::AccountId>,
+			#[pallet::compact] value: BalanceOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+
+			ensure!(
+				votes.len() <= T::MaxVotesPerVoter::get() as usize,
+				Error::<T>::MaximumVotesExceeded
+			);
+			ensure!(!votes.is_empty(), Error::<T>::NoVotes);
+
+			let candidates_count = <Candidates<T>>::decode_len().unwrap_or(0);
+			let members_count = <Members<T>>::decode_len().unwrap_or(0);
+			let runners_up_count = <RunnersUp<T>>::decode_len().unwrap_or(0);
+
+			// can never submit a vote of there are no members, and cannot submit more votes than
+			// all potential vote targets.
+			// addition is valid: candidates, members and runners-up will never overlap.
+			let allowed_votes =
+				candidates_count.saturating_add(members_count).saturating_add(runners_up_count);
+			ensure!(!allowed_votes.is_zero(), Error::<T>::UnableToVote);
+			ensure!(votes.len() <= allowed_votes, Error::<T>::TooManyVotes);
+
+			ensure!(value > T::Currency::minimum_balance(), Error::<T>::LowBalance);
+
+			// Reserve bond.
+			let new_deposit = Self::deposit_of(votes.len());
+			let Voter { deposit: old_deposit, .. } = <Voting<T>>::get(&who);
+			match new_deposit.cmp(&old_deposit) {
+				Ordering::Greater => {
+					// Must reserve a bit more.
+					let to_reserve = new_deposit - old_deposit;
+					T::Currency::reserve(&who, to_reserve)
+						.map_err(|_| Error::<T>::UnableToPayBond)?;
+				},
+				Ordering::Equal => {},
+				Ordering::Less => {
+					// Must unreserve a bit.
+					let to_unreserve = old_deposit - new_deposit;
+					let _remainder = T::Currency::unreserve(&who, to_unreserve);
+					debug_assert!(_remainder.is_zero());
+				},
+			};
+
+			// Amount to be locked up.
+			let locked_stake = value.min(T::Currency::free_balance(&who));
+			T::Currency::set_lock(T::PalletId::get(), &who, locked_stake, WithdrawReasons::all());
+
+			Voting::<T>::insert(&who, Voter { votes, deposit: new_deposit, stake: locked_stake });
+			Ok(None::<Weight>.into())
+		}
+
+		/// Remove `origin` as a voter.
+		///
+		/// This removes the lock and returns the deposit.
+		///
+		/// The dispatch origin of this call must be signed and be a voter.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::remove_voter())]
+		pub fn remove_voter(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			ensure!(Self::is_voter(&who), Error::<T>::MustBeVoter);
+			Self::do_remove_voter(&who);
+			Ok(())
+		}
+
+		/// Submit oneself for candidacy. A fixed amount of deposit is recorded.
+		///
+		/// All candidates are wiped at the end of the term. They either become a member/runner-up,
+		/// or leave the system while their deposit is slashed.
+		///
+		/// The dispatch origin of this call must be signed.
+		///
+		/// ### Warning
+		///
+		/// Even if a candidate ends up being a member, they must call [`Call::renounce_candidacy`]
+		/// to get their deposit back. Losing the spot in an election will always lead to a slash.
+		///
+		/// The number of current candidates must be provided as witness data.
+		/// ## Complexity
+		/// O(C + log(C)) where C is candidate_count.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::submit_candidacy(*candidate_count))]
+		pub fn submit_candidacy(
+			origin: OriginFor<T>,
+			#[pallet::compact] candidate_count: u32,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let actual_count = <Candidates<T>>::decode_len().unwrap_or(0) as u32;
+			ensure!(actual_count <= candidate_count, Error::<T>::InvalidWitnessData);
+			ensure!(
+				actual_count <= <T as Config>::MaxCandidates::get(),
+				Error::<T>::TooManyCandidates
+			);
+
+			let index = Self::is_candidate(&who).err().ok_or(Error::<T>::DuplicatedCandidate)?;
+
+			ensure!(!Self::is_member(&who), Error::<T>::MemberSubmit);
+			ensure!(!Self::is_runner_up(&who), Error::<T>::RunnerUpSubmit);
+
+			T::Currency::reserve(&who, T::CandidacyBond::get())
+				.map_err(|_| Error::<T>::InsufficientCandidateFunds)?;
+
+			<Candidates<T>>::mutate(|c| c.insert(index, (who, T::CandidacyBond::get())));
+			Ok(())
+		}
+
+		/// Renounce one's intention to be a candidate for the next election round. 3 potential
+		/// outcomes exist:
+		///
+		/// - `origin` is a candidate and not elected in any set. In this case, the deposit is
+		///   unreserved, returned and origin is removed as a candidate.
+		/// - `origin` is a current runner-up. In this case, the deposit is unreserved, returned and
+		///   origin is removed as a runner-up.
+		/// - `origin` is a current member. In this case, the deposit is unreserved and origin is
+		///   removed as a member, consequently not being a candidate for the next round anymore.
+		///   Similar to [`remove_member`](Self::remove_member), if replacement runners exists, they
+		///   are immediately used. If the prime is renouncing, then no prime will exist until the
+		///   next round.
+		///
+		/// The dispatch origin of this call must be signed, and have one of the above roles.
+		/// The type of renouncing must be provided as witness data.
+		///
+		/// ## Complexity
+		///   - Renouncing::Candidate(count): O(count + log(count))
+		///   - Renouncing::Member: O(1)
+		///   - Renouncing::RunnerUp: O(1)
+		#[pallet::call_index(3)]
+		#[pallet::weight(match *renouncing {
+			Renouncing::Candidate(count) => T::WeightInfo::renounce_candidacy_candidate(count),
+			Renouncing::Member => T::WeightInfo::renounce_candidacy_members(),
+			Renouncing::RunnerUp => T::WeightInfo::renounce_candidacy_runners_up(),
+		})]
+		pub fn renounce_candidacy(origin: OriginFor<T>, renouncing: Renouncing) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			match renouncing {
+				Renouncing::Member => {
+					let _ = Self::remove_and_replace_member(&who, false)
+						.map_err(|_| Error::<T>::InvalidRenouncing)?;
+					Self::deposit_event(Event::Renounced { candidate: who });
+				},
+				Renouncing::RunnerUp => {
+					<RunnersUp<T>>::try_mutate::<_, Error<T>, _>(|runners_up| {
+						let index = runners_up
+							.iter()
+							.position(|SeatHolder { who: r, .. }| r == &who)
+							.ok_or(Error::<T>::InvalidRenouncing)?;
+						// can't fail anymore.
+						let SeatHolder { deposit, .. } = runners_up.remove(index);
+						let _remainder = T::Currency::unreserve(&who, deposit);
+						debug_assert!(_remainder.is_zero());
+						Self::deposit_event(Event::Renounced { candidate: who });
+						Ok(())
+					})?;
+				},
+				Renouncing::Candidate(count) => {
+					<Candidates<T>>::try_mutate::<_, Error<T>, _>(|candidates| {
+						ensure!(count >= candidates.len() as u32, Error::<T>::InvalidWitnessData);
+						let index = candidates
+							.binary_search_by(|(c, _)| c.cmp(&who))
+							.map_err(|_| Error::<T>::InvalidRenouncing)?;
+						let (_removed, deposit) = candidates.remove(index);
+						let _remainder = T::Currency::unreserve(&who, deposit);
+						debug_assert!(_remainder.is_zero());
+						Self::deposit_event(Event::Renounced { candidate: who });
+						Ok(())
+					})?;
+				},
+			};
+			Ok(())
+		}
+
+		/// Remove a particular member from the set. This is effective immediately and the bond of
+		/// the outgoing member is slashed.
+		///
+		/// If a runner-up is available, then the best runner-up will be removed and replaces the
+		/// outgoing member. Otherwise, if `rerun_election` is `true`, a new phragmen election is
+		/// started, else, nothing happens.
+		///
+		/// If `slash_bond` is set to true, the bond of the member being removed is slashed. Else,
+		/// it is returned.
+		///
+		/// The dispatch origin of this call must be root.
+		///
+		/// Note that this does not affect the designated block number of the next election.
+		///
+		/// ## Complexity
+		/// - Check details of remove_and_replace_member() and do_phragmen().
+		#[pallet::call_index(4)]
+		#[pallet::weight(if *rerun_election {
+			T::WeightInfo::remove_member_without_replacement()
+		} else {
+			T::WeightInfo::remove_member_with_replacement()
+		})]
+		pub fn remove_member(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			slash_bond: bool,
+			rerun_election: bool,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let who = T::Lookup::lookup(who)?;
+
+			let _ = Self::remove_and_replace_member(&who, slash_bond)?;
+			Self::deposit_event(Event::MemberKicked { member: who });
+
+			if rerun_election {
+				Self::do_phragmen();
+			}
+
+			// no refund needed.
+			Ok(())
+		}
+
+		/// Clean all voters who are defunct (i.e. they do not serve any purpose at all). The
+		/// deposit of the removed voters are returned.
+		///
+		/// This is an root function to be used only for cleaning the state.
+		///
+		/// The dispatch origin of this call must be root.
+		///
+		/// ## Complexity
+		/// - Check is_defunct_voter() details.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::clean_defunct_voters(*_num_voters, *_num_defunct))]
+		pub fn clean_defunct_voters(
+			origin: OriginFor<T>,
+			_num_voters: u32,
+			_num_defunct: u32,
+		) -> DispatchResult {
+			let _ = ensure_root(origin)?;
+			<Voting<T>>::iter()
+				.filter(|(_, x)| Self::is_defunct_voter(&x.votes))
+				.for_each(|(dv, _)| Self::do_remove_voter(&dv));
+
+			Ok(())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A new term with new_members. This indicates that enough candidates existed to run
+		/// the election, not that enough have has been elected. The inner value must be examined
+		/// for this purpose. A `NewTerm(\[\])` indicates that some candidates got their bond
+		/// slashed and none were elected, whilst `EmptyTerm` means that no candidates existed to
+		/// begin with.
+		NewTerm { new_members: Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T>)> },
+		/// No (or not enough) candidates existed for this round. This is different from
+		/// `NewTerm(\[\])`. See the description of `NewTerm`.
+		EmptyTerm,
+		/// Internal error happened while trying to perform election.
+		ElectionError,
+		/// A member has been removed. This should always be followed by either `NewTerm` or
+		/// `EmptyTerm`.
+		MemberKicked { member: <T as frame_system::Config>::AccountId },
+		/// Someone has renounced their candidacy.
+		Renounced { candidate: <T as frame_system::Config>::AccountId },
+		/// A candidate was slashed by amount due to failing to obtain a seat as member or
+		/// runner-up.
+		///
+		/// Note that old members and runners-up are also candidates.
+		CandidateSlashed { candidate: <T as frame_system::Config>::AccountId, amount: BalanceOf<T> },
+		/// A seat holder was slashed by amount by being forcefully removed from the set.
+		SeatHolderSlashed {
+			seat_holder: <T as frame_system::Config>::AccountId,
+			amount: BalanceOf<T>,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Cannot vote when no candidates or members exist.
+		UnableToVote,
+		/// Must vote for at least one candidate.
+		NoVotes,
+		/// Cannot vote more than candidates.
+		TooManyVotes,
+		/// Cannot vote more than maximum allowed.
+		MaximumVotesExceeded,
+		/// Cannot vote with stake less than minimum balance.
+		LowBalance,
+		/// Voter can not pay voting bond.
+		UnableToPayBond,
+		/// Must be a voter.
+		MustBeVoter,
+		/// Duplicated candidate submission.
+		DuplicatedCandidate,
+		/// Too many candidates have been created.
+		TooManyCandidates,
+		/// Member cannot re-submit candidacy.
+		MemberSubmit,
+		/// Runner cannot re-submit candidacy.
+		RunnerUpSubmit,
+		/// Candidate does not have enough funds.
+		InsufficientCandidateFunds,
+		/// Not a member.
+		NotMember,
+		/// The provided count of number of candidates is incorrect.
+		InvalidWitnessData,
+		/// The provided count of number of votes is incorrect.
+		InvalidVoteCount,
+		/// The renouncing origin presented a wrong `Renouncing` parameter.
+		InvalidRenouncing,
+		/// Prediction regarding replacement after member removal is wrong.
+		InvalidReplacement,
+	}
+
+	/// The current elected members.
+	///
+	/// Invariant: Always sorted based on account id.
+	#[pallet::storage]
+	#[pallet::getter(fn members)]
+	pub type Members<T: Config> =
+		StorageValue<_, Vec<SeatHolder<T::AccountId, BalanceOf<T>>>, ValueQuery>;
+
+	/// The current reserved runners-up.
+	///
+	/// Invariant: Always sorted based on rank (worse to best). Upon removal of a member, the
+	/// last (i.e. _best_) runner-up will be replaced.
+	#[pallet::storage]
+	#[pallet::getter(fn runners_up)]
+	pub type RunnersUp<T: Config> =
+		StorageValue<_, Vec<SeatHolder<T::AccountId, BalanceOf<T>>>, ValueQuery>;
+
+	/// The present candidate list. A current member or runner-up can never enter this vector
+	/// and is always implicitly assumed to be a candidate.
+	///
+	/// Second element is the deposit.
+	///
+	/// Invariant: Always sorted based on account id.
+	#[pallet::storage]
+	#[pallet::getter(fn candidates)]
+	pub type Candidates<T: Config> = StorageValue<_, Vec<(T::AccountId, BalanceOf<T>)>, ValueQuery>;
+
+	/// The total number of vote rounds that have happened, excluding the upcoming one.
+	#[pallet::storage]
+	#[pallet::getter(fn election_rounds)]
+	pub type ElectionRounds<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	/// Votes and locked stake of a particular voter.
+	///
+	/// TWOX-NOTE: SAFE as `AccountId` is a crypto hash.
+	#[pallet::storage]
+	#[pallet::getter(fn voting)]
+	pub type Voting<T: Config> =
+		StorageMap<_, Twox64Concat, T::AccountId, Voter<T::AccountId, BalanceOf<T>>, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub members: Vec<(T::AccountId, BalanceOf<T>)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			assert!(
+				self.members.len() as u32 <= T::DesiredMembers::get(),
+				"Cannot accept more than DesiredMembers genesis member",
+			);
+			let members = self
+				.members
+				.iter()
+				.map(|(ref member, ref stake)| {
+					// make sure they have enough stake.
+					assert!(
+						T::Currency::free_balance(member) >= *stake,
+						"Genesis member does not have enough stake.",
+					);
+
+					// Note: all members will only vote for themselves, hence they must be given
+					// exactly their own stake as total backing. Any sane election should behave as
+					// such. Nonetheless, stakes will be updated for term 1 onwards according to the
+					// election.
+					Members::<T>::mutate(|members| {
+						match members.binary_search_by(|m| m.who.cmp(member)) {
+							Ok(_) => {
+								panic!(
+									"Duplicate member in elections-phragmen genesis: {:?}",
+									member
+								)
+							},
+							Err(pos) => members.insert(
+								pos,
+								SeatHolder {
+									who: member.clone(),
+									stake: *stake,
+									deposit: Zero::zero(),
+								},
+							),
+						}
+					});
+
+					// set self-votes to make persistent. Genesis voters don't have any bond, nor do
+					// they have any lock. NOTE: this means that we will still try to remove a lock
+					// once this genesis voter is removed, and for now it is okay because
+					// remove_lock is noop if lock is not there.
+					<Voting<T>>::insert(
+						&member,
+						Voter { votes: vec![member.clone()], stake: *stake, deposit: Zero::zero() },
+					);
+
+					member.clone()
+				})
+				.collect::<Vec<T::AccountId>>();
+
+			// report genesis members to upstream, if any.
+			T::InitializeMembers::initialize_members(&members);
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// The deposit value of `count` votes.
+	fn deposit_of(count: usize) -> BalanceOf<T> {
+		T::VotingBondBase::get()
+			.saturating_add(T::VotingBondFactor::get().saturating_mul((count as u32).into()))
+	}
+
+	/// Attempts to remove a member `who`. If a runner-up exists, it is used as the replacement.
+	///
+	/// Returns:
+	///
+	/// - `Ok(true)` if the member was removed and a replacement was found.
+	/// - `Ok(false)` if the member was removed and but no replacement was found.
+	/// - `Err(_)` if the member was no found.
+	///
+	/// Both `Members` and `RunnersUp` storage is updated accordingly. `T::ChangeMember` is called
+	/// if needed. If `slash` is true, the deposit of the potentially removed member is slashed,
+	/// else, it is unreserved.
+	///
+	/// ### Note: Prime preservation
+	///
+	/// This function attempts to preserve the prime. If the removed members is not the prime, it is
+	/// set again via [`Config::ChangeMembers`].
+	fn remove_and_replace_member(who: &T::AccountId, slash: bool) -> Result<bool, DispatchError> {
+		// closure will return:
+		// - `Ok(Option(replacement))` if member was removed and replacement was replaced.
+		// - `Ok(None)` if member was removed but no replacement was found
+		// - `Err(_)` if who is not a member.
+		let maybe_replacement = <Members<T>>::try_mutate::<_, Error<T>, _>(|members| {
+			let remove_index = members
+				.binary_search_by(|m| m.who.cmp(who))
+				.map_err(|_| Error::<T>::NotMember)?;
+			// we remove the member anyhow, regardless of having a runner-up or not.
+			let removed = members.remove(remove_index);
+
+			// slash or unreserve
+			if slash {
+				let (imbalance, _remainder) = T::Currency::slash_reserved(who, removed.deposit);
+				debug_assert!(_remainder.is_zero());
+				T::LoserCandidate::on_unbalanced(imbalance);
+				Self::deposit_event(Event::SeatHolderSlashed {
+					seat_holder: who.clone(),
+					amount: removed.deposit,
+				});
+			} else {
+				T::Currency::unreserve(who, removed.deposit);
+			}
+
+			let maybe_next_best = <RunnersUp<T>>::mutate(|r| r.pop()).map(|next_best| {
+				// defensive-only: Members and runners-up are disjoint. This will always be err and
+				// give us an index to insert.
+				if let Err(index) = members.binary_search_by(|m| m.who.cmp(&next_best.who)) {
+					members.insert(index, next_best.clone());
+				} else {
+					// overlap. This can never happen. If so, it seems like our intended replacement
+					// is already a member, so not much more to do.
+					log::error!(target: LOG_TARGET, "A member seems to also be a runner-up.");
+				}
+				next_best
+			});
+			Ok(maybe_next_best)
+		})?;
+
+		let remaining_member_ids_sorted =
+			Self::members().into_iter().map(|x| x.who).collect::<Vec<_>>();
+		let outgoing = &[who.clone()];
+		let maybe_current_prime = T::ChangeMembers::get_prime();
+		let return_value = match maybe_replacement {
+			// member ids are already sorted, other two elements have one item.
+			Some(incoming) => {
+				T::ChangeMembers::change_members_sorted(
+					&[incoming.who],
+					outgoing,
+					&remaining_member_ids_sorted[..],
+				);
+				true
+			},
+			None => {
+				T::ChangeMembers::change_members_sorted(
+					&[],
+					outgoing,
+					&remaining_member_ids_sorted[..],
+				);
+				false
+			},
+		};
+
+		// if there was a prime before and they are not the one being removed, then set them
+		// again.
+		if let Some(current_prime) = maybe_current_prime {
+			if &current_prime != who {
+				T::ChangeMembers::set_prime(Some(current_prime));
+			}
+		}
+
+		Ok(return_value)
+	}
+
+	/// Check if `who` is a candidate. It returns the insert index if the element does not exists as
+	/// an error.
+	fn is_candidate(who: &T::AccountId) -> Result<(), usize> {
+		Self::candidates().binary_search_by(|c| c.0.cmp(who)).map(|_| ())
+	}
+
+	/// Check if `who` is a voter. It may or may not be a _current_ one.
+	fn is_voter(who: &T::AccountId) -> bool {
+		Voting::<T>::contains_key(who)
+	}
+
+	/// Check if `who` is currently an active member.
+	fn is_member(who: &T::AccountId) -> bool {
+		Self::members().binary_search_by(|m| m.who.cmp(who)).is_ok()
+	}
+
+	/// Check if `who` is currently an active runner-up.
+	fn is_runner_up(who: &T::AccountId) -> bool {
+		Self::runners_up().iter().any(|r| &r.who == who)
+	}
+
+	/// Get the members' account ids.
+	pub(crate) fn members_ids() -> Vec<T::AccountId> {
+		Self::members().into_iter().map(|m| m.who).collect::<Vec<T::AccountId>>()
+	}
+
+	/// Get a concatenation of previous members and runners-up and their deposits.
+	///
+	/// These accounts are essentially treated as candidates.
+	fn implicit_candidates_with_deposit() -> Vec<(T::AccountId, BalanceOf<T>)> {
+		// invariant: these two are always without duplicates.
+		Self::members()
+			.into_iter()
+			.map(|m| (m.who, m.deposit))
+			.chain(Self::runners_up().into_iter().map(|r| (r.who, r.deposit)))
+			.collect::<Vec<_>>()
+	}
+
+	/// Check if `votes` will correspond to a defunct voter. As no origin is part of the inputs,
+	/// this function does not check the origin at all.
+	///
+	/// O(NLogM) with M candidates and `who` having voted for `N` of them.
+	/// Reads Members, RunnersUp, Candidates and Voting(who) from database.
+	fn is_defunct_voter(votes: &[T::AccountId]) -> bool {
+		votes.iter().all(|v| {
+			!Self::is_member(v) && !Self::is_runner_up(v) && Self::is_candidate(v).is_err()
+		})
+	}
+
+	/// Remove a certain someone as a voter.
+	fn do_remove_voter(who: &T::AccountId) {
+		let Voter { deposit, .. } = <Voting<T>>::take(who);
+
+		// remove storage, lock and unreserve.
+		T::Currency::remove_lock(T::PalletId::get(), who);
+
+		// NOTE: we could check the deposit amount before removing and skip if zero, but it will be
+		// a noop anyhow.
+		let _remainder = T::Currency::unreserve(who, deposit);
+		debug_assert!(_remainder.is_zero());
+	}
+
+	/// Run the phragmen election with all required side processes and state updates, if election
+	/// succeeds. Else, it will emit an `ElectionError` event.
+	///
+	/// Calls the appropriate [`ChangeMembers`] function variant internally.
+	fn do_phragmen() -> Weight {
+		let desired_seats = T::DesiredMembers::get() as usize;
+		let desired_runners_up = T::DesiredRunnersUp::get() as usize;
+		let num_to_elect = desired_runners_up + desired_seats;
+
+		let mut candidates_and_deposit = Self::candidates();
+		// add all the previous members and runners-up as candidates as well.
+		candidates_and_deposit.append(&mut Self::implicit_candidates_with_deposit());
+
+		if candidates_and_deposit.len().is_zero() {
+			Self::deposit_event(Event::EmptyTerm);
+			return T::DbWeight::get().reads(3)
+		}
+
+		// All of the new winners that come out of phragmen will thus have a deposit recorded.
+		let candidate_ids =
+			candidates_and_deposit.iter().map(|(x, _)| x).cloned().collect::<Vec<_>>();
+
+		// helper closures to deal with balance/stake.
+		let total_issuance = T::Currency::total_issuance();
+		let to_votes = |b: BalanceOf<T>| T::CurrencyToVote::to_vote(b, total_issuance);
+		let to_balance = |e: ExtendedBalance| T::CurrencyToVote::to_currency(e, total_issuance);
+
+		let mut num_edges: u32 = 0;
+
+		let max_voters = <T as Config>::MaxVoters::get() as usize;
+		// used for prime election.
+		let mut voters_and_stakes = Vec::new();
+		match Voting::<T>::iter().try_for_each(|(voter, Voter { stake, votes, .. })| {
+			if voters_and_stakes.len() < max_voters {
+				voters_and_stakes.push((voter, stake, votes));
+				Ok(())
+			} else {
+				Err(())
+			}
+		}) {
+			Ok(_) => (),
+			Err(_) => {
+				log::error!(
+					target: LOG_TARGET,
+					"Failed to run election. Number of voters exceeded",
+				);
+				Self::deposit_event(Event::ElectionError);
+				return T::DbWeight::get().reads(3 + max_voters as u64)
+			},
+		}
+
+		// used for phragmen.
+		let voters_and_votes = voters_and_stakes
+			.iter()
+			.cloned()
+			.map(|(voter, stake, votes)| {
+				num_edges = num_edges.saturating_add(votes.len() as u32);
+				(voter, to_votes(stake), votes)
+			})
+			.collect::<Vec<_>>();
+
+		let weight_candidates = candidates_and_deposit.len() as u32;
+		let weight_voters = voters_and_votes.len() as u32;
+		let weight_edges = num_edges;
+		let _ =
+			sp_npos_elections::seq_phragmen(num_to_elect, candidate_ids, voters_and_votes, None)
+				.map(|ElectionResult::<T::AccountId, Perbill> { winners, assignments: _ }| {
+					// this is already sorted by id.
+					let old_members_ids_sorted = <Members<T>>::take()
+						.into_iter()
+						.map(|m| m.who)
+						.collect::<Vec<T::AccountId>>();
+					// this one needs a sort by id.
+					let mut old_runners_up_ids_sorted = <RunnersUp<T>>::take()
+						.into_iter()
+						.map(|r| r.who)
+						.collect::<Vec<T::AccountId>>();
+					old_runners_up_ids_sorted.sort();
+
+					// filter out those who end up with no backing stake.
+					let mut new_set_with_stake = winners
+						.into_iter()
+						.filter_map(
+							|(m, b)| if b.is_zero() { None } else { Some((m, to_balance(b))) },
+						)
+						.collect::<Vec<(T::AccountId, BalanceOf<T>)>>();
+
+					// OPTIMIZATION NOTE: we could bail out here if `new_set.len() == 0`. There
+					// isn't much left to do. Yet, re-arranging the code would require duplicating
+					// the slashing of exposed candidates, cleaning any previous members, and so on.
+					// For now, in favor of readability and veracity, we keep it simple.
+
+					// split new set into winners and runners up.
+					let split_point = desired_seats.min(new_set_with_stake.len());
+					let mut new_members_sorted_by_id =
+						new_set_with_stake.drain(..split_point).collect::<Vec<_>>();
+					new_members_sorted_by_id.sort_by(|i, j| i.0.cmp(&j.0));
+
+					// all the rest will be runners-up
+					new_set_with_stake.reverse();
+					let new_runners_up_sorted_by_rank = new_set_with_stake;
+					let mut new_runners_up_ids_sorted = new_runners_up_sorted_by_rank
+						.iter()
+						.map(|(r, _)| r.clone())
+						.collect::<Vec<_>>();
+					new_runners_up_ids_sorted.sort();
+
+					// Now we select a prime member using a [Borda
+					// count](https://en.wikipedia.org/wiki/Borda_count). We weigh everyone's vote for
+					// that new member by a multiplier based on the order of the votes. i.e. the
+					// first person a voter votes for gets a 16x multiplier, the next person gets a
+					// 15x multiplier, an so on... (assuming `T::MaxVotesPerVoter` = 16)
+					let mut prime_votes = new_members_sorted_by_id
+						.iter()
+						.map(|c| (&c.0, BalanceOf::<T>::zero()))
+						.collect::<Vec<_>>();
+					for (_, stake, votes) in voters_and_stakes.into_iter() {
+						for (vote_multiplier, who) in
+							votes.iter().enumerate().map(|(vote_position, who)| {
+								((T::MaxVotesPerVoter::get() as usize - vote_position) as u32, who)
+							}) {
+							if let Ok(i) = prime_votes.binary_search_by_key(&who, |k| k.0) {
+								prime_votes[i].1 = prime_votes[i]
+									.1
+									.saturating_add(stake.saturating_mul(vote_multiplier.into()));
+							}
+						}
+					}
+					// We then select the new member with the highest weighted stake. In the case of
+					// a tie, the last person in the list with the tied score is selected. This is
+					// the person with the "highest" account id based on the sort above.
+					let prime = prime_votes.into_iter().max_by_key(|x| x.1).map(|x| x.0.clone());
+
+					// new_members_sorted_by_id is sorted by account id.
+					let new_members_ids_sorted = new_members_sorted_by_id
+						.iter()
+						.map(|(m, _)| m.clone())
+						.collect::<Vec<T::AccountId>>();
+
+					// report member changes. We compute diff because we need the outgoing list.
+					let (incoming, outgoing) = T::ChangeMembers::compute_members_diff_sorted(
+						&new_members_ids_sorted,
+						&old_members_ids_sorted,
+					);
+					T::ChangeMembers::change_members_sorted(
+						&incoming,
+						&outgoing,
+						&new_members_ids_sorted,
+					);
+					T::ChangeMembers::set_prime(prime);
+
+					// All candidates/members/runners-up who are no longer retaining a position as a
+					// seat holder will lose their bond.
+					candidates_and_deposit.iter().for_each(|(c, d)| {
+						if new_members_ids_sorted.binary_search(c).is_err() &&
+							new_runners_up_ids_sorted.binary_search(c).is_err()
+						{
+							let (imbalance, _) = T::Currency::slash_reserved(c, *d);
+							T::LoserCandidate::on_unbalanced(imbalance);
+							Self::deposit_event(Event::CandidateSlashed {
+								candidate: c.clone(),
+								amount: *d,
+							});
+						}
+					});
+
+					// write final values to storage.
+					let deposit_of_candidate = |x: &T::AccountId| -> BalanceOf<T> {
+						// defensive-only. This closure is used against the new members and new
+						// runners-up, both of which are phragmen winners and thus must have
+						// deposit.
+						candidates_and_deposit
+							.iter()
+							.find_map(|(c, d)| if c == x { Some(*d) } else { None })
+							.defensive_unwrap_or_default()
+					};
+					// fetch deposits from the one recorded one. This will make sure that a
+					// candidate who submitted candidacy before a change to candidacy deposit will
+					// have the correct amount recorded.
+					<Members<T>>::put(
+						new_members_sorted_by_id
+							.iter()
+							.map(|(who, stake)| SeatHolder {
+								deposit: deposit_of_candidate(who),
+								who: who.clone(),
+								stake: *stake,
+							})
+							.collect::<Vec<_>>(),
+					);
+					<RunnersUp<T>>::put(
+						new_runners_up_sorted_by_rank
+							.into_iter()
+							.map(|(who, stake)| SeatHolder {
+								deposit: deposit_of_candidate(&who),
+								who,
+								stake,
+							})
+							.collect::<Vec<_>>(),
+					);
+
+					// clean candidates.
+					<Candidates<T>>::kill();
+
+					Self::deposit_event(Event::NewTerm { new_members: new_members_sorted_by_id });
+					<ElectionRounds<T>>::mutate(|v| *v += 1);
+				})
+				.map_err(|e| {
+					log::error!(target: LOG_TARGET, "Failed to run election [{:?}].", e,);
+					Self::deposit_event(Event::ElectionError);
+				});
+
+		T::WeightInfo::election_phragmen(weight_candidates, weight_voters, weight_edges)
+	}
+}
+
+impl<T: Config> Contains<T::AccountId> for Pallet<T> {
+	fn contains(who: &T::AccountId) -> bool {
+		Self::is_member(who)
+	}
+}
+
+impl<T: Config> SortedMembers<T::AccountId> for Pallet<T> {
+	fn contains(who: &T::AccountId) -> bool {
+		Self::is_member(who)
+	}
+
+	fn sorted_members() -> Vec<T::AccountId> {
+		Self::members_ids()
+	}
+
+	// A special function to populate members in this pallet for passing Origin
+	// checks in runtime benchmarking.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add(who: &T::AccountId) {
+		Members::<T>::mutate(|members| match members.binary_search_by(|m| m.who.cmp(who)) {
+			Ok(_) => (),
+			Err(pos) => {
+				let s = SeatHolder {
+					who: who.clone(),
+					stake: Default::default(),
+					deposit: Default::default(),
+				};
+				members.insert(pos, s)
+			},
+		})
+	}
+}
+
+impl<T: Config> ContainsLengthBound for Pallet<T> {
+	fn min_len() -> usize {
+		0
+	}
+
+	/// Implementation uses a parameter type so calling is cost-free.
+	fn max_len() -> usize {
+		T::DesiredMembers::get() as usize
+	}
+}
+
+#[cfg(any(feature = "try-runtime", test))]
+impl<T: Config> Pallet<T> {
+	fn do_try_state() -> Result<(), TryRuntimeError> {
+		Self::try_state_members()?;
+		Self::try_state_runners_up()?;
+		Self::try_state_candidates()?;
+		Self::try_state_candidates_runners_up_disjoint()?;
+		Self::try_state_members_disjoint()?;
+		Self::try_state_members_approval_stake()
+	}
+
+	/// [`Members`] state checks. Invariants:
+	///  - Members are always sorted based on account ID.
+	fn try_state_members() -> Result<(), TryRuntimeError> {
+		let mut members = Members::<T>::get().clone();
+		members.sort_by_key(|m| m.who.clone());
+
+		if Members::<T>::get() == members {
+			Ok(())
+		} else {
+			Err("try_state checks: Members must be always sorted by account ID".into())
+		}
+	}
+
+	// [`RunnersUp`] state checks. Invariants:
+	//  - Elements are sorted based on weight (worst to best).
+	fn try_state_runners_up() -> Result<(), TryRuntimeError> {
+		let mut sorted = RunnersUp::<T>::get();
+		// worst stake first
+		sorted.sort_by(|a, b| a.stake.cmp(&b.stake));
+
+		if RunnersUp::<T>::get() == sorted {
+			Ok(())
+		} else {
+			Err("try_state checks: Runners Up must always be sorted by stake (worst to best)"
+				.into())
+		}
+	}
+
+	// [`Candidates`] state checks. Invariants:
+	//  - Always sorted based on account ID.
+	fn try_state_candidates() -> Result<(), TryRuntimeError> {
+		let mut candidates = Candidates::<T>::get().clone();
+		candidates.sort_by_key(|(c, _)| c.clone());
+
+		if Candidates::<T>::get() == candidates {
+			Ok(())
+		} else {
+			Err("try_state checks: Candidates must be always sorted by account ID".into())
+		}
+	}
+	// [`Candidates`] and [`RunnersUp`] state checks. Invariants:
+	//  - Candidates and runners-ups sets are disjoint.
+	fn try_state_candidates_runners_up_disjoint() -> Result<(), TryRuntimeError> {
+		match Self::intersects(&Self::candidates_ids(), &Self::runners_up_ids()) {
+			true => Err("Candidates and runners up sets should always be disjoint".into()),
+			false => Ok(()),
+		}
+	}
+
+	// [`Members`], [`Candidates`] and [`RunnersUp`] state checks. Invariants:
+	//  - Members and candidates sets are disjoint;
+	//  - Members and runners-ups sets are disjoint.
+	fn try_state_members_disjoint() -> Result<(), TryRuntimeError> {
+		match Self::intersects(&Pallet::<T>::members_ids(), &Self::candidates_ids()) &&
+			Self::intersects(&Pallet::<T>::members_ids(), &Self::runners_up_ids())
+		{
+			true =>
+				Err("Members set should be disjoint from candidates and runners-up sets".into()),
+			false => Ok(()),
+		}
+	}
+
+	// [`Members`], [`RunnersUp`] and approval stake state checks. Invariants:
+	// - Selected members should have approval stake;
+	// - Selected RunnersUp should have approval stake.
+	fn try_state_members_approval_stake() -> Result<(), TryRuntimeError> {
+		match Members::<T>::get()
+			.iter()
+			.chain(RunnersUp::<T>::get().iter())
+			.all(|s| s.stake != BalanceOf::<T>::zero())
+		{
+			true => Ok(()),
+			false => Err("Members and RunnersUp must have approval stake".into()),
+		}
+	}
+
+	fn intersects<P: PartialEq>(a: &[P], b: &[P]) -> bool {
+		a.iter().any(|e| b.contains(e))
+	}
+
+	fn candidates_ids() -> Vec<T::AccountId> {
+		Pallet::<T>::candidates().iter().map(|(x, _)| x).cloned().collect::<Vec<_>>()
+	}
+
+	fn runners_up_ids() -> Vec<T::AccountId> {
+		Pallet::<T>::runners_up().into_iter().map(|r| r.who).collect::<Vec<_>>()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate as elections_phragmen;
+	use frame_support::{
+		assert_noop, assert_ok,
+		dispatch::DispatchResultWithPostInfo,
+		parameter_types,
+		traits::{ConstU32, ConstU64, OnInitialize},
+	};
+	use frame_system::ensure_signed;
+	use sp_core::H256;
+	use sp_runtime::{
+		testing::Header,
+		traits::{BlakeTwo256, IdentityLookup},
+		BuildStorage,
+	};
+	use substrate_test_utils::assert_eq_uvec;
+
+	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 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>;
+	}
+
+	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 MaxHolds = ();
+	}
+
+	frame_support::parameter_types! {
+		pub static VotingBondBase: u64 = 2;
+		pub static VotingBondFactor: u64 = 0;
+		pub static CandidacyBond: u64 = 3;
+		pub static DesiredMembers: u32 = 2;
+		pub static DesiredRunnersUp: u32 = 0;
+		pub static TermDuration: u64 = 5;
+		pub static Members: Vec<u64> = vec![];
+		pub static Prime: Option<u64> = None;
+	}
+
+	pub struct TestChangeMembers;
+	impl ChangeMembers<u64> for TestChangeMembers {
+		fn change_members_sorted(incoming: &[u64], outgoing: &[u64], new: &[u64]) {
+			// new, incoming, outgoing must be sorted.
+			let mut new_sorted = new.to_vec();
+			new_sorted.sort();
+			assert_eq!(new, &new_sorted[..]);
+
+			let mut incoming_sorted = incoming.to_vec();
+			incoming_sorted.sort();
+			assert_eq!(incoming, &incoming_sorted[..]);
+
+			let mut outgoing_sorted = outgoing.to_vec();
+			outgoing_sorted.sort();
+			assert_eq!(outgoing, &outgoing_sorted[..]);
+
+			// incoming and outgoing must be disjoint
+			for x in incoming.iter() {
+				assert!(outgoing.binary_search(x).is_err());
+			}
+
+			let mut old_plus_incoming = MEMBERS.with(|m| m.borrow().to_vec());
+			old_plus_incoming.extend_from_slice(incoming);
+			old_plus_incoming.sort();
+
+			let mut new_plus_outgoing = new.to_vec();
+			new_plus_outgoing.extend_from_slice(outgoing);
+			new_plus_outgoing.sort();
+
+			assert_eq!(old_plus_incoming, new_plus_outgoing, "change members call is incorrect!");
+
+			MEMBERS.with(|m| *m.borrow_mut() = new.to_vec());
+			PRIME.with(|p| *p.borrow_mut() = None);
+		}
+
+		fn set_prime(who: Option<u64>) {
+			PRIME.with(|p| *p.borrow_mut() = who);
+		}
+
+		fn get_prime() -> Option<u64> {
+			PRIME.with(|p| *p.borrow())
+		}
+	}
+
+	parameter_types! {
+		pub const ElectionsPhragmenPalletId: LockIdentifier = *b"phrelect";
+		pub const PhragmenMaxVoters: u32 = 1000;
+		pub const PhragmenMaxCandidates: u32 = 100;
+	}
+
+	impl Config for Test {
+		type PalletId = ElectionsPhragmenPalletId;
+		type RuntimeEvent = RuntimeEvent;
+		type Currency = Balances;
+		type CurrencyToVote = ();
+		type ChangeMembers = TestChangeMembers;
+		type InitializeMembers = ();
+		type CandidacyBond = CandidacyBond;
+		type VotingBondBase = VotingBondBase;
+		type VotingBondFactor = VotingBondFactor;
+		type TermDuration = TermDuration;
+		type DesiredMembers = DesiredMembers;
+		type DesiredRunnersUp = DesiredRunnersUp;
+		type LoserCandidate = ();
+		type KickedMember = ();
+		type WeightInfo = ();
+		type MaxVoters = PhragmenMaxVoters;
+		type MaxVotesPerVoter = ConstU32<16>;
+		type MaxCandidates = PhragmenMaxCandidates;
+	}
+
+	pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+	pub type UncheckedExtrinsic =
+		sp_runtime::generic::UncheckedExtrinsic<u32, u64, RuntimeCall, ()>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Event<T>},
+			Balances: pallet_balances::{Pallet, Call, Event<T>, Config<T>},
+			Elections: elections_phragmen::{Pallet, Call, Event<T>, Config<T>},
+		}
+	);
+
+	pub struct ExtBuilder {
+		balance_factor: u64,
+		genesis_members: Vec<(u64, u64)>,
+	}
+
+	impl Default for ExtBuilder {
+		fn default() -> Self {
+			Self { balance_factor: 1, genesis_members: vec![] }
+		}
+	}
+
+	impl ExtBuilder {
+		pub fn voter_bond(self, bond: u64) -> Self {
+			VOTING_BOND_BASE.with(|v| *v.borrow_mut() = bond);
+			self
+		}
+		pub fn voter_bond_factor(self, bond: u64) -> Self {
+			VOTING_BOND_FACTOR.with(|v| *v.borrow_mut() = bond);
+			self
+		}
+		pub fn desired_runners_up(self, count: u32) -> Self {
+			DESIRED_RUNNERS_UP.with(|v| *v.borrow_mut() = count);
+			self
+		}
+		pub fn term_duration(self, duration: u64) -> Self {
+			TERM_DURATION.with(|v| *v.borrow_mut() = duration);
+			self
+		}
+		pub fn genesis_members(mut self, members: Vec<(u64, u64)>) -> Self {
+			MEMBERS.with(|m| *m.borrow_mut() = members.iter().map(|(m, _)| *m).collect::<Vec<_>>());
+			self.genesis_members = members;
+			self
+		}
+		pub fn desired_members(self, count: u32) -> Self {
+			DESIRED_MEMBERS.with(|m| *m.borrow_mut() = count);
+			self
+		}
+		pub fn balance_factor(mut self, factor: u64) -> Self {
+			self.balance_factor = factor;
+			self
+		}
+		pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+			sp_tracing::try_init_simple();
+			MEMBERS.with(|m| {
+				*m.borrow_mut() = self.genesis_members.iter().map(|(m, _)| *m).collect::<Vec<_>>()
+			});
+			let mut ext: sp_io::TestExternalities = RuntimeGenesisConfig {
+				balances: pallet_balances::GenesisConfig::<Test> {
+					balances: vec![
+						(1, 10 * self.balance_factor),
+						(2, 20 * self.balance_factor),
+						(3, 30 * self.balance_factor),
+						(4, 40 * self.balance_factor),
+						(5, 50 * self.balance_factor),
+						(6, 60 * self.balance_factor),
+					],
+				},
+				elections: elections_phragmen::GenesisConfig::<Test> {
+					members: self.genesis_members,
+				},
+			}
+			.build_storage()
+			.unwrap()
+			.into();
+			ext.execute_with(pre_conditions);
+			ext.execute_with(test);
+
+			#[cfg(feature = "try-runtime")]
+			ext.execute_with(|| {
+				assert_ok!(<Elections as frame_support::traits::Hooks<u64>>::try_state(
+					System::block_number()
+				));
+			});
+		}
+	}
+
+	fn candidate_ids() -> Vec<u64> {
+		Elections::candidates().into_iter().map(|(c, _)| c).collect::<Vec<_>>()
+	}
+
+	fn candidate_deposit(who: &u64) -> u64 {
+		Elections::candidates()
+			.into_iter()
+			.find_map(|(c, d)| if c == *who { Some(d) } else { None })
+			.unwrap_or_default()
+	}
+
+	fn voter_deposit(who: &u64) -> u64 {
+		Elections::voting(who).deposit
+	}
+
+	fn runners_up_ids() -> Vec<u64> {
+		Elections::runners_up().into_iter().map(|r| r.who).collect::<Vec<_>>()
+	}
+
+	fn members_ids() -> Vec<u64> {
+		Elections::members_ids()
+	}
+
+	fn members_and_stake() -> Vec<(u64, u64)> {
+		Elections::members().into_iter().map(|m| (m.who, m.stake)).collect::<Vec<_>>()
+	}
+
+	fn runners_up_and_stake() -> Vec<(u64, u64)> {
+		Elections::runners_up()
+			.into_iter()
+			.map(|r| (r.who, r.stake))
+			.collect::<Vec<_>>()
+	}
+
+	fn all_voters() -> Vec<u64> {
+		Voting::<Test>::iter().map(|(v, _)| v).collect::<Vec<u64>>()
+	}
+
+	fn balances(who: &u64) -> (u64, u64) {
+		(Balances::free_balance(who), Balances::reserved_balance(who))
+	}
+
+	fn has_lock(who: &u64) -> u64 {
+		Balances::locks(who)
+			.get(0)
+			.cloned()
+			.map(|lock| {
+				assert_eq!(lock.id, ElectionsPhragmenPalletId::get());
+				lock.amount
+			})
+			.unwrap_or_default()
+	}
+
+	fn locked_stake_of(who: &u64) -> u64 {
+		Voting::<Test>::get(who).stake
+	}
+
+	fn pre_conditions() {
+		System::set_block_number(1);
+		Elections::do_try_state().unwrap();
+	}
+
+	fn submit_candidacy(origin: RuntimeOrigin) -> sp_runtime::DispatchResult {
+		Elections::submit_candidacy(origin, Elections::candidates().len() as u32)
+	}
+
+	fn vote(origin: RuntimeOrigin, votes: Vec<u64>, stake: u64) -> DispatchResultWithPostInfo {
+		// historical note: helper function was created in a period of time in which the API of vote
+		// call was changing. Currently it is a wrapper for the original call and does not do much.
+		// Nonetheless, totally harmless.
+		ensure_signed(origin.clone()).expect("vote origin must be signed");
+		Elections::vote(origin, votes, stake)
+	}
+
+	fn votes_of(who: &u64) -> Vec<u64> {
+		Voting::<Test>::get(who).votes
+	}
+
+	#[test]
+	fn params_should_work() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(<Test as Config>::DesiredMembers::get(), 2);
+			assert_eq!(<Test as Config>::DesiredRunnersUp::get(), 0);
+			assert_eq!(<Test as Config>::VotingBondBase::get(), 2);
+			assert_eq!(<Test as Config>::VotingBondFactor::get(), 0);
+			assert_eq!(<Test as Config>::CandidacyBond::get(), 3);
+			assert_eq!(<Test as Config>::TermDuration::get(), 5);
+			assert_eq!(Elections::election_rounds(), 0);
+
+			assert!(Elections::members().is_empty());
+			assert!(Elections::runners_up().is_empty());
+
+			assert!(candidate_ids().is_empty());
+			assert_eq!(<Candidates<Test>>::decode_len(), None);
+			assert!(Elections::is_candidate(&1).is_err());
+
+			assert!(all_voters().is_empty());
+			assert!(votes_of(&1).is_empty());
+		});
+	}
+
+	#[test]
+	fn genesis_members_should_work() {
+		ExtBuilder::default()
+			.genesis_members(vec![(1, 10), (2, 20)])
+			.build_and_execute(|| {
+				System::set_block_number(1);
+				assert_eq!(
+					Elections::members(),
+					vec![
+						SeatHolder { who: 1, stake: 10, deposit: 0 },
+						SeatHolder { who: 2, stake: 20, deposit: 0 }
+					]
+				);
+
+				assert_eq!(
+					Elections::voting(1),
+					Voter { stake: 10u64, votes: vec![1], deposit: 0 }
+				);
+				assert_eq!(
+					Elections::voting(2),
+					Voter { stake: 20u64, votes: vec![2], deposit: 0 }
+				);
+
+				// they will persist since they have self vote.
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![1, 2]);
+			})
+	}
+
+	#[test]
+	fn genesis_voters_can_remove_lock() {
+		ExtBuilder::default()
+			.genesis_members(vec![(1, 10), (2, 20)])
+			.build_and_execute(|| {
+				System::set_block_number(1);
+
+				assert_eq!(
+					Elections::voting(1),
+					Voter { stake: 10u64, votes: vec![1], deposit: 0 }
+				);
+				assert_eq!(
+					Elections::voting(2),
+					Voter { stake: 20u64, votes: vec![2], deposit: 0 }
+				);
+
+				assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(1)));
+				assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(2)));
+
+				assert_eq!(Elections::voting(1), Default::default());
+				assert_eq!(Elections::voting(2), Default::default());
+			})
+	}
+
+	#[test]
+	fn genesis_members_unsorted_should_work() {
+		ExtBuilder::default()
+			.genesis_members(vec![(2, 20), (1, 10)])
+			.build_and_execute(|| {
+				System::set_block_number(1);
+				assert_eq!(
+					Elections::members(),
+					vec![
+						SeatHolder { who: 1, stake: 10, deposit: 0 },
+						SeatHolder { who: 2, stake: 20, deposit: 0 },
+					]
+				);
+
+				assert_eq!(
+					Elections::voting(1),
+					Voter { stake: 10u64, votes: vec![1], deposit: 0 }
+				);
+				assert_eq!(
+					Elections::voting(2),
+					Voter { stake: 20u64, votes: vec![2], deposit: 0 }
+				);
+
+				// they will persist since they have self vote.
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![1, 2]);
+			})
+	}
+
+	#[test]
+	#[should_panic = "Genesis member does not have enough stake"]
+	fn genesis_members_cannot_over_stake_0() {
+		// 10 cannot lock 20 as their stake and extra genesis will panic.
+		ExtBuilder::default()
+			.genesis_members(vec![(1, 20), (2, 20)])
+			.build_and_execute(|| {});
+	}
+
+	#[test]
+	#[should_panic = "Duplicate member in elections-phragmen genesis: 2"]
+	fn genesis_members_cannot_be_duplicate() {
+		ExtBuilder::default()
+			.desired_members(3)
+			.genesis_members(vec![(1, 10), (2, 10), (2, 10)])
+			.build_and_execute(|| {});
+	}
+
+	#[test]
+	#[should_panic = "Cannot accept more than DesiredMembers genesis member"]
+	fn genesis_members_cannot_too_many() {
+		ExtBuilder::default()
+			.genesis_members(vec![(1, 10), (2, 10), (3, 30)])
+			.desired_members(2)
+			.build_and_execute(|| {});
+	}
+
+	#[test]
+	fn term_duration_zero_is_passive() {
+		ExtBuilder::default().term_duration(0).build_and_execute(|| {
+			assert_eq!(<Test as Config>::TermDuration::get(), 0);
+			assert_eq!(<Test as Config>::DesiredMembers::get(), 2);
+			assert_eq!(Elections::election_rounds(), 0);
+
+			assert!(members_ids().is_empty());
+			assert!(Elections::runners_up().is_empty());
+			assert!(candidate_ids().is_empty());
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert!(members_ids().is_empty());
+			assert!(Elections::runners_up().is_empty());
+			assert!(candidate_ids().is_empty());
+		});
+	}
+
+	#[test]
+	fn simple_candidate_submission_should_work() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(candidate_ids(), Vec::<u64>::new());
+			assert!(Elections::is_candidate(&1).is_err());
+			assert!(Elections::is_candidate(&2).is_err());
+
+			assert_eq!(balances(&1), (10, 0));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(1)));
+			assert_eq!(balances(&1), (7, 3));
+
+			assert_eq!(candidate_ids(), vec![1]);
+
+			assert!(Elections::is_candidate(&1).is_ok());
+			assert!(Elections::is_candidate(&2).is_err());
+
+			assert_eq!(balances(&2), (20, 0));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+			assert_eq!(balances(&2), (17, 3));
+
+			assert_eq!(candidate_ids(), vec![1, 2]);
+
+			assert!(Elections::is_candidate(&1).is_ok());
+			assert!(Elections::is_candidate(&2).is_ok());
+
+			assert_eq!(candidate_deposit(&1), 3);
+			assert_eq!(candidate_deposit(&2), 3);
+			assert_eq!(candidate_deposit(&3), 0);
+		});
+	}
+
+	#[test]
+	fn updating_candidacy_bond_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_eq!(Elections::candidates(), vec![(5, 3)]);
+
+			// a runtime upgrade changes the bond.
+			CANDIDACY_BOND.with(|v| *v.borrow_mut() = 4);
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_eq!(Elections::candidates(), vec![(4, 4), (5, 3)]);
+
+			// once elected, they each hold their candidacy bond, no more.
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(balances(&4), (34, 6));
+			assert_eq!(balances(&5), (45, 5));
+			assert_eq!(
+				Elections::members(),
+				vec![
+					SeatHolder { who: 4, stake: 34, deposit: 4 },
+					SeatHolder { who: 5, stake: 45, deposit: 3 },
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn candidates_are_always_sorted() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(candidate_ids(), Vec::<u64>::new());
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_eq!(candidate_ids(), vec![3]);
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(1)));
+			assert_eq!(candidate_ids(), vec![1, 3]);
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+			assert_eq!(candidate_ids(), vec![1, 2, 3]);
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_eq!(candidate_ids(), vec![1, 2, 3, 4]);
+		});
+	}
+
+	#[test]
+	fn dupe_candidate_submission_should_not_work() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(candidate_ids(), Vec::<u64>::new());
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(1)));
+			assert_eq!(candidate_ids(), vec![1]);
+			assert_noop!(
+				submit_candidacy(RuntimeOrigin::signed(1)),
+				Error::<Test>::DuplicatedCandidate
+			);
+		});
+	}
+
+	#[test]
+	fn member_candidacy_submission_should_not_work() {
+		// critically important to make sure that outgoing candidates and losers are not mixed up.
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![5]);
+			assert!(Elections::runners_up().is_empty());
+			assert!(candidate_ids().is_empty());
+
+			assert_noop!(submit_candidacy(RuntimeOrigin::signed(5)), Error::<Test>::MemberSubmit);
+		});
+	}
+
+	#[test]
+	fn runner_candidate_submission_should_not_work() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5, 4], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(1), vec![3], 10));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![3]);
+
+			assert_noop!(submit_candidacy(RuntimeOrigin::signed(3)), Error::<Test>::RunnerUpSubmit);
+		});
+	}
+
+	#[test]
+	fn poor_candidate_submission_should_not_work() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(candidate_ids(), Vec::<u64>::new());
+			assert_noop!(
+				submit_candidacy(RuntimeOrigin::signed(7)),
+				Error::<Test>::InsufficientCandidateFunds,
+			);
+		});
+	}
+
+	#[test]
+	fn simple_voting_should_work() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(candidate_ids(), Vec::<u64>::new());
+			assert_eq!(balances(&2), (20, 0));
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+
+			assert_eq!(balances(&2), (18, 2));
+			assert_eq!(has_lock(&2), 18);
+		});
+	}
+
+	#[test]
+	fn can_vote_with_custom_stake() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(candidate_ids(), Vec::<u64>::new());
+			assert_eq!(balances(&2), (20, 0));
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 12));
+
+			assert_eq!(balances(&2), (18, 2));
+			assert_eq!(has_lock(&2), 12);
+		});
+	}
+
+	#[test]
+	fn can_update_votes_and_stake() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(balances(&2), (20, 0));
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+
+			// User only locks up to their free balance.
+			assert_eq!(balances(&2), (18, 2));
+			assert_eq!(has_lock(&2), 18);
+			assert_eq!(locked_stake_of(&2), 18);
+
+			// can update; different stake; different lock and reserve.
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5, 4], 15));
+			assert_eq!(balances(&2), (18, 2));
+			assert_eq!(has_lock(&2), 15);
+			assert_eq!(locked_stake_of(&2), 15);
+		});
+	}
+
+	#[test]
+	fn updated_voting_bond_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			assert_eq!(balances(&2), (20, 0));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 5));
+			assert_eq!(balances(&2), (18, 2));
+			assert_eq!(voter_deposit(&2), 2);
+
+			// a runtime upgrade lowers the voting bond to 1. This guy still un-reserves 2 when
+			// leaving.
+			VOTING_BOND_BASE.with(|v| *v.borrow_mut() = 1);
+
+			// proof that bond changed.
+			assert_eq!(balances(&1), (10, 0));
+			assert_ok!(vote(RuntimeOrigin::signed(1), vec![5], 5));
+			assert_eq!(balances(&1), (9, 1));
+			assert_eq!(voter_deposit(&1), 1);
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(2)));
+			assert_eq!(balances(&2), (20, 0));
+		})
+	}
+
+	#[test]
+	fn voting_reserves_bond_per_vote() {
+		ExtBuilder::default().voter_bond_factor(1).build_and_execute(|| {
+			assert_eq!(balances(&2), (20, 0));
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			// initial vote.
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 10));
+
+			// 2 + 1
+			assert_eq!(balances(&2), (17, 3));
+			assert_eq!(Elections::voting(&2).deposit, 3);
+			assert_eq!(has_lock(&2), 10);
+			assert_eq!(locked_stake_of(&2), 10);
+
+			// can update; different stake; different lock and reserve.
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5, 4], 15));
+			// 2 + 2
+			assert_eq!(balances(&2), (16, 4));
+			assert_eq!(Elections::voting(&2).deposit, 4);
+			assert_eq!(has_lock(&2), 15);
+			assert_eq!(locked_stake_of(&2), 15);
+
+			// stay at two votes with different stake.
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5, 3], 18));
+			// 2 + 2
+			assert_eq!(balances(&2), (16, 4));
+			assert_eq!(Elections::voting(&2).deposit, 4);
+			assert_eq!(has_lock(&2), 16);
+			assert_eq!(locked_stake_of(&2), 16);
+
+			// back to 1 vote.
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![4], 12));
+			// 2 + 1
+			assert_eq!(balances(&2), (17, 3));
+			assert_eq!(Elections::voting(&2).deposit, 3);
+			assert_eq!(has_lock(&2), 12);
+			assert_eq!(locked_stake_of(&2), 12);
+		});
+	}
+
+	#[test]
+	fn cannot_vote_for_no_candidate() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_noop!(vote(RuntimeOrigin::signed(2), vec![], 20), Error::<Test>::NoVotes);
+		});
+	}
+
+	#[test]
+	fn can_vote_for_old_members_even_when_no_new_candidates() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![4, 5], 20));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert!(candidate_ids().is_empty());
+
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![4, 5], 10));
+		});
+	}
+
+	#[test]
+	fn prime_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(1), vec![4, 3], 10));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![4], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert!(candidate_ids().is_empty());
+
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![4, 5], 10));
+			assert_eq!(PRIME.with(|p| *p.borrow()), Some(4));
+		});
+	}
+
+	#[test]
+	fn prime_votes_for_exiting_members_are_removed() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(1), vec![4, 3], 10));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![4], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(4),
+				Renouncing::Candidate(3)
+			));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![3, 5]);
+			assert!(candidate_ids().is_empty());
+
+			assert_eq!(PRIME.with(|p| *p.borrow()), Some(5));
+		});
+	}
+
+	#[test]
+	fn prime_is_kept_if_other_members_leave() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(PRIME.with(|p| *p.borrow()), Some(5));
+			assert_ok!(Elections::renounce_candidacy(RuntimeOrigin::signed(4), Renouncing::Member));
+
+			assert_eq!(members_ids(), vec![5]);
+			assert_eq!(PRIME.with(|p| *p.borrow()), Some(5));
+		})
+	}
+
+	#[test]
+	fn prime_is_gone_if_renouncing() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(PRIME.with(|p| *p.borrow()), Some(5));
+			assert_ok!(Elections::renounce_candidacy(RuntimeOrigin::signed(5), Renouncing::Member));
+
+			assert_eq!(members_ids(), vec![4]);
+			assert_eq!(PRIME.with(|p| *p.borrow()), None);
+		})
+	}
+
+	#[test]
+	fn cannot_vote_for_more_than_candidates_and_members_and_runners() {
+		ExtBuilder::default()
+			.desired_runners_up(1)
+			.balance_factor(10)
+			.build_and_execute(|| {
+				// when we have only candidates
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+				assert_noop!(
+					// content of the vote is irrelevant.
+					vote(RuntimeOrigin::signed(1), vec![9, 99, 999, 9999], 5),
+					Error::<Test>::TooManyVotes,
+				);
+
+				assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+				assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				// now we have 2 members, 1 runner-up, and 1 new candidate
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+				assert_ok!(vote(RuntimeOrigin::signed(1), vec![9, 99, 999, 9999], 5));
+				assert_noop!(
+					vote(RuntimeOrigin::signed(1), vec![9, 99, 999, 9_999, 99_999], 5),
+					Error::<Test>::TooManyVotes,
+				);
+			});
+	}
+
+	#[test]
+	fn cannot_vote_for_less_than_ed() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			assert_noop!(vote(RuntimeOrigin::signed(2), vec![4], 1), Error::<Test>::LowBalance);
+		})
+	}
+
+	#[test]
+	fn can_vote_for_more_than_free_balance_but_moot() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			// User has 100 free and 50 reserved.
+			assert_ok!(Balances::force_set_balance(RuntimeOrigin::root(), 2, 150));
+			assert_ok!(Balances::reserve(&2, 50));
+			// User tries to vote with 150 tokens.
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![4, 5], 150));
+			// We truncate to only their free balance, after reserving additional for voting.
+			assert_eq!(locked_stake_of(&2), 98);
+			assert_eq!(has_lock(&2), 98);
+		});
+	}
+
+	#[test]
+	fn remove_voter_should_work() {
+		ExtBuilder::default().voter_bond(8).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![5], 30));
+
+			assert_eq_uvec!(all_voters(), vec![2, 3]);
+			assert_eq!(balances(&2), (12, 8));
+			assert_eq!(locked_stake_of(&2), 12);
+			assert_eq!(balances(&3), (22, 8));
+			assert_eq!(locked_stake_of(&3), 22);
+			assert_eq!(votes_of(&2), vec![5]);
+			assert_eq!(votes_of(&3), vec![5]);
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(2)));
+
+			assert_eq_uvec!(all_voters(), vec![3]);
+			assert!(votes_of(&2).is_empty());
+			assert_eq!(locked_stake_of(&2), 0);
+
+			assert_eq!(balances(&2), (20, 0));
+			assert_eq!(Balances::locks(&2).len(), 0);
+		});
+	}
+
+	#[test]
+	fn non_voter_remove_should_not_work() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_noop!(
+				Elections::remove_voter(RuntimeOrigin::signed(3)),
+				Error::<Test>::MustBeVoter
+			);
+		});
+	}
+
+	#[test]
+	fn dupe_remove_should_fail() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(2)));
+			assert!(all_voters().is_empty());
+
+			assert_noop!(
+				Elections::remove_voter(RuntimeOrigin::signed(2)),
+				Error::<Test>::MustBeVoter
+			);
+		});
+	}
+
+	#[test]
+	fn removed_voter_should_not_be_counted() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(4)));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![3, 5]);
+		});
+	}
+
+	#[test]
+	fn simple_voting_rounds_should_work() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 15));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			assert_eq_uvec!(all_voters(), vec![2, 3, 4]);
+
+			assert_eq!(votes_of(&2), vec![5]);
+			assert_eq!(votes_of(&3), vec![3]);
+			assert_eq!(votes_of(&4), vec![4]);
+
+			assert_eq!(candidate_ids(), vec![3, 4, 5]);
+			assert_eq!(<Candidates<Test>>::decode_len().unwrap(), 3);
+
+			assert_eq!(Elections::election_rounds(), 0);
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(balances(&3), (25, 5));
+			// votes for 5
+			assert_eq!(balances(&2), (18, 2));
+			assert_eq!(members_and_stake(), vec![(3, 25), (5, 18)]);
+			assert!(Elections::runners_up().is_empty());
+
+			assert_eq_uvec!(all_voters(), vec![2, 3, 4]);
+			assert!(candidate_ids().is_empty());
+			assert_eq!(<Candidates<Test>>::decode_len(), None);
+
+			assert_eq!(Elections::election_rounds(), 1);
+		});
+	}
+
+	#[test]
+	fn empty_term() {
+		ExtBuilder::default().build_and_execute(|| {
+			// no candidates, no nothing.
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			System::assert_last_event(RuntimeEvent::Elections(super::Event::EmptyTerm));
+		})
+	}
+
+	#[test]
+	fn all_outgoing() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			System::assert_last_event(RuntimeEvent::Elections(super::Event::NewTerm {
+				new_members: vec![(4, 35), (5, 45)],
+			}));
+
+			assert_eq!(members_and_stake(), vec![(4, 35), (5, 45)]);
+			assert_eq!(runners_up_and_stake(), vec![]);
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(5)));
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(4)));
+
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+
+			System::assert_last_event(RuntimeEvent::Elections(super::Event::NewTerm {
+				new_members: vec![],
+			}));
+
+			// outgoing have lost their bond.
+			assert_eq!(balances(&4), (37, 0));
+			assert_eq!(balances(&5), (47, 0));
+		});
+	}
+
+	#[test]
+	fn defunct_voter_will_be_counted() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			// This guy's vote is pointless for this round.
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![4], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_and_stake(), vec![(5, 45)]);
+			assert_eq!(Elections::election_rounds(), 1);
+
+			// but now it has a valid target.
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+
+			// candidate 4 is affected by an old vote.
+			assert_eq!(members_and_stake(), vec![(4, 28), (5, 45)]);
+			assert_eq!(Elections::election_rounds(), 2);
+			assert_eq_uvec!(all_voters(), vec![3, 5]);
+		});
+	}
+
+	#[test]
+	fn only_desired_seats_are_chosen() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(Elections::election_rounds(), 1);
+			assert_eq!(members_ids(), vec![4, 5]);
+		});
+	}
+
+	#[test]
+	fn phragmen_should_not_self_vote() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert!(candidate_ids().is_empty());
+			assert_eq!(Elections::election_rounds(), 1);
+			assert!(members_ids().is_empty());
+
+			System::assert_last_event(RuntimeEvent::Elections(super::Event::NewTerm {
+				new_members: vec![],
+			}));
+		});
+	}
+
+	#[test]
+	fn runners_up_should_be_kept() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![3], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![2], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![5], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![4], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			// sorted based on account id.
+			assert_eq!(members_ids(), vec![4, 5]);
+			// sorted based on merit (least -> most)
+			assert_eq!(runners_up_ids(), vec![3, 2]);
+
+			// runner ups are still locked.
+			assert_eq!(balances(&4), (35, 5));
+			assert_eq!(balances(&5), (45, 5));
+			assert_eq!(balances(&3), (25, 5));
+		});
+	}
+
+	#[test]
+	fn runners_up_should_be_next_candidates() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			assert_eq!(members_and_stake(), vec![(4, 35), (5, 45)]);
+			assert_eq!(runners_up_and_stake(), vec![(2, 15), (3, 25)]);
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 10));
+
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_and_stake(), vec![(3, 25), (4, 35)]);
+			assert_eq!(runners_up_and_stake(), vec![(5, 10), (2, 15)]);
+		});
+	}
+
+	#[test]
+	fn runners_up_lose_bond_once_outgoing() {
+		ExtBuilder::default().desired_runners_up(1).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![2]);
+			assert_eq!(balances(&2), (15, 5));
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(runners_up_ids(), vec![3]);
+			assert_eq!(balances(&2), (15, 2));
+		});
+	}
+
+	#[test]
+	fn members_lose_bond_once_outgoing() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(balances(&5), (50, 0));
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_eq!(balances(&5), (47, 3));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_eq!(balances(&5), (45, 5));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			assert_eq!(members_ids(), vec![5]);
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(5)));
+			assert_eq!(balances(&5), (47, 3));
+
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+			assert!(members_ids().is_empty());
+
+			assert_eq!(balances(&5), (47, 0));
+		});
+	}
+
+	#[test]
+	fn candidates_lose_the_bond_when_outgoing() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![5], 40));
+
+			assert_eq!(balances(&5), (47, 3));
+			assert_eq!(balances(&3), (27, 3));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![5]);
+
+			// winner
+			assert_eq!(balances(&5), (47, 3));
+			// loser
+			assert_eq!(balances(&3), (27, 0));
+		});
+	}
+
+	#[test]
+	fn current_members_are_always_next_candidate() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(Elections::election_rounds(), 1);
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(4)));
+
+			// 5 will persist as candidates despite not being in the list.
+			assert_eq!(candidate_ids(), vec![2, 3]);
+
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+
+			// 4 removed; 5 and 3 are the new best.
+			assert_eq!(members_ids(), vec![3, 5]);
+		});
+	}
+
+	#[test]
+	fn election_state_is_uninterrupted() {
+		// what I mean by uninterrupted:
+		// given no input or stimulants the same members are re-elected.
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+			let check_at_block = |b: u32| {
+				System::set_block_number(b.into());
+				Elections::on_initialize(System::block_number());
+				// we keep re-electing the same folks.
+				assert_eq!(members_and_stake(), vec![(4, 35), (5, 45)]);
+				assert_eq!(runners_up_and_stake(), vec![(2, 15), (3, 25)]);
+				// no new candidates but old members and runners-up are always added.
+				assert!(candidate_ids().is_empty());
+				assert_eq!(Elections::election_rounds(), b / 5);
+				assert_eq_uvec!(all_voters(), vec![2, 3, 4, 5]);
+			};
+
+			// this state will always persist when no further input is given.
+			check_at_block(5);
+			check_at_block(10);
+			check_at_block(15);
+			check_at_block(20);
+		});
+	}
+
+	#[test]
+	fn remove_members_triggers_election() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(Elections::election_rounds(), 1);
+
+			// a new candidate
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			assert_ok!(Elections::remove_member(RuntimeOrigin::root(), 4, true, true));
+
+			assert_eq!(balances(&4), (35, 2)); // slashed
+			assert_eq!(Elections::election_rounds(), 2); // new election round
+			assert_eq!(members_ids(), vec![3, 5]); // new members
+		});
+	}
+
+	#[test]
+	fn seats_should_be_released_when_no_vote() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![3], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			assert_eq!(<Candidates<Test>>::decode_len().unwrap(), 3);
+
+			assert_eq!(Elections::election_rounds(), 0);
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			assert_eq!(members_ids(), vec![3, 5]);
+			assert_eq!(Elections::election_rounds(), 1);
+
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(2)));
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(3)));
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(4)));
+			assert_ok!(Elections::remove_voter(RuntimeOrigin::signed(5)));
+
+			// meanwhile, no one cares to become a candidate again.
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+			assert!(members_ids().is_empty());
+			assert_eq!(Elections::election_rounds(), 2);
+		});
+	}
+
+	#[test]
+	fn incoming_outgoing_are_reported() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			assert_eq!(members_ids(), vec![4, 5]);
+
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(1)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			// 5 will change their vote and becomes an `outgoing`
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![4], 8));
+			// 4 will stay in the set
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			// 3 will become a winner
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			// these two are losers.
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(1), vec![1], 10));
+
+			System::set_block_number(10);
+			Elections::on_initialize(System::block_number());
+
+			// 3, 4 are new members, must still be bonded, nothing slashed.
+			assert_eq!(members_and_stake(), vec![(3, 25), (4, 43)]);
+			assert_eq!(balances(&3), (25, 5));
+			assert_eq!(balances(&4), (35, 5));
+
+			// 1 is a loser, slashed by 3.
+			assert_eq!(balances(&1), (5, 2));
+
+			// 5 is an outgoing loser. will also get slashed.
+			assert_eq!(balances(&5), (45, 2));
+
+			System::assert_has_event(RuntimeEvent::Elections(super::Event::NewTerm {
+				new_members: vec![(4, 35), (5, 45)],
+			}));
+		})
+	}
+
+	#[test]
+	fn invalid_votes_are_moot() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![10], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq_uvec!(members_ids(), vec![3, 4]);
+			assert_eq!(Elections::election_rounds(), 1);
+		});
+	}
+
+	#[test]
+	fn members_are_sorted_based_on_id_runners_on_merit() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![3], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![2], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![5], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![4], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+			// id: low -> high.
+			assert_eq!(members_and_stake(), vec![(4, 45), (5, 35)]);
+			// merit: low -> high.
+			assert_eq!(runners_up_and_stake(), vec![(3, 15), (2, 25)]);
+		});
+	}
+
+	#[test]
+	fn runner_up_replacement_maintains_members_order() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![2], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![2, 4]);
+			assert_ok!(Elections::remove_member(RuntimeOrigin::root(), 2, true, false));
+			assert_eq!(members_ids(), vec![4, 5]);
+		});
+	}
+
+	#[test]
+	fn can_renounce_candidacy_member_with_runners_bond_is_refunded() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![2, 3]);
+
+			assert_ok!(Elections::renounce_candidacy(RuntimeOrigin::signed(4), Renouncing::Member));
+			assert_eq!(balances(&4), (38, 2)); // 2 is voting bond.
+
+			assert_eq!(members_ids(), vec![3, 5]);
+			assert_eq!(runners_up_ids(), vec![2]);
+		})
+	}
+
+	#[test]
+	fn can_renounce_candidacy_member_without_runners_bond_is_refunded() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert!(runners_up_ids().is_empty());
+
+			assert_ok!(Elections::renounce_candidacy(RuntimeOrigin::signed(4), Renouncing::Member));
+			assert_eq!(balances(&4), (38, 2)); // 2 is voting bond.
+
+			// no replacement
+			assert_eq!(members_ids(), vec![5]);
+			assert!(runners_up_ids().is_empty());
+		})
+	}
+
+	#[test]
+	fn can_renounce_candidacy_runner_up() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![4], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![5], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![2, 3]);
+
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(3),
+				Renouncing::RunnerUp
+			));
+			assert_eq!(balances(&3), (28, 2)); // 2 is voting bond.
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![2]);
+		})
+	}
+
+	#[test]
+	fn runner_up_replacement_works_when_out_of_order() {
+		ExtBuilder::default().desired_runners_up(2).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![5], 20));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![2], 50));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![2, 4]);
+			assert_eq!(runners_up_ids(), vec![5, 3]);
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(3),
+				Renouncing::RunnerUp
+			));
+			assert_eq!(members_ids(), vec![2, 4]);
+			assert_eq!(runners_up_ids(), vec![5]);
+		});
+	}
+
+	#[test]
+	fn can_renounce_candidacy_candidate() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_eq!(balances(&5), (47, 3));
+			assert_eq!(candidate_ids(), vec![5]);
+
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(5),
+				Renouncing::Candidate(1)
+			));
+			assert_eq!(balances(&5), (50, 0));
+			assert!(candidate_ids().is_empty());
+		})
+	}
+
+	#[test]
+	fn wrong_renounce_candidacy_should_fail() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_noop!(
+				Elections::renounce_candidacy(RuntimeOrigin::signed(5), Renouncing::Candidate(0)),
+				Error::<Test>::InvalidRenouncing,
+			);
+			assert_noop!(
+				Elections::renounce_candidacy(RuntimeOrigin::signed(5), Renouncing::Member),
+				Error::<Test>::InvalidRenouncing,
+			);
+			assert_noop!(
+				Elections::renounce_candidacy(RuntimeOrigin::signed(5), Renouncing::RunnerUp),
+				Error::<Test>::InvalidRenouncing,
+			);
+		})
+	}
+
+	#[test]
+	fn non_member_renounce_member_should_fail() {
+		ExtBuilder::default().desired_runners_up(1).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![3]);
+
+			assert_noop!(
+				Elections::renounce_candidacy(RuntimeOrigin::signed(3), Renouncing::Member),
+				Error::<Test>::InvalidRenouncing,
+			);
+		})
+	}
+
+	#[test]
+	fn non_runner_up_renounce_runner_up_should_fail() {
+		ExtBuilder::default().desired_runners_up(1).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![3]);
+
+			assert_noop!(
+				Elections::renounce_candidacy(RuntimeOrigin::signed(4), Renouncing::RunnerUp),
+				Error::<Test>::InvalidRenouncing,
+			);
+		})
+	}
+
+	#[test]
+	fn wrong_candidate_count_renounce_should_fail() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_noop!(
+				Elections::renounce_candidacy(RuntimeOrigin::signed(4), Renouncing::Candidate(2)),
+				Error::<Test>::InvalidWitnessData,
+			);
+
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(4),
+				Renouncing::Candidate(3)
+			));
+		})
+	}
+
+	#[test]
+	fn renounce_candidacy_count_can_overestimate() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			// while we have only 3 candidates.
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(4),
+				Renouncing::Candidate(4)
+			));
+		})
+	}
+
+	#[test]
+	fn unsorted_runners_up_are_detected() {
+		ExtBuilder::default()
+			.desired_runners_up(2)
+			.desired_members(1)
+			.build_and_execute(|| {
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+				assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 5));
+				assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 15));
+
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![5]);
+				assert_eq!(runners_up_ids(), vec![4, 3]);
+
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+				assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 10));
+
+				System::set_block_number(10);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![5]);
+				assert_eq!(runners_up_ids(), vec![2, 3]);
+
+				// 4 is outgoing runner-up. Slash candidacy bond.
+				assert_eq!(balances(&4), (35, 2));
+				// 3 stays.
+				assert_eq!(balances(&3), (25, 5));
+			})
+	}
+
+	#[test]
+	fn member_to_runner_up_wont_slash() {
+		ExtBuilder::default()
+			.desired_runners_up(2)
+			.desired_members(1)
+			.build_and_execute(|| {
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+				assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+				assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![4]);
+				assert_eq!(runners_up_ids(), vec![2, 3]);
+
+				assert_eq!(balances(&4), (35, 5));
+				assert_eq!(balances(&3), (25, 5));
+				assert_eq!(balances(&2), (15, 5));
+
+				// this guy will shift everyone down.
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+				assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+
+				System::set_block_number(10);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![5]);
+				assert_eq!(runners_up_ids(), vec![3, 4]);
+
+				// 4 went from member to runner-up -- don't slash.
+				assert_eq!(balances(&4), (35, 5));
+				// 3 stayed runner-up -- don't slash.
+				assert_eq!(balances(&3), (25, 5));
+				// 2 was removed -- slash.
+				assert_eq!(balances(&2), (15, 2));
+			});
+	}
+
+	#[test]
+	fn runner_up_to_member_wont_slash() {
+		ExtBuilder::default()
+			.desired_runners_up(2)
+			.desired_members(1)
+			.build_and_execute(|| {
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+				assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+				assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![4]);
+				assert_eq!(runners_up_ids(), vec![2, 3]);
+
+				assert_eq!(balances(&4), (35, 5));
+				assert_eq!(balances(&3), (25, 5));
+				assert_eq!(balances(&2), (15, 5));
+
+				// swap some votes.
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![2], 40));
+				assert_ok!(vote(RuntimeOrigin::signed(2), vec![4], 20));
+
+				System::set_block_number(10);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![2]);
+				assert_eq!(runners_up_ids(), vec![4, 3]);
+
+				// 2 went from runner to member, don't slash
+				assert_eq!(balances(&2), (15, 5));
+				// 4 went from member to runner, don't slash
+				assert_eq!(balances(&4), (35, 5));
+				// 3 stayed the same
+				assert_eq!(balances(&3), (25, 5));
+			});
+	}
+
+	#[test]
+	fn remove_and_replace_member_works() {
+		let setup = || {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5], 50));
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![4, 5]);
+			assert_eq!(runners_up_ids(), vec![3]);
+		};
+
+		// member removed, replacement found.
+		ExtBuilder::default().desired_runners_up(1).build_and_execute(|| {
+			setup();
+			assert_eq!(Elections::remove_and_replace_member(&4, false), Ok(true));
+
+			assert_eq!(members_ids(), vec![3, 5]);
+			assert_eq!(runners_up_ids().len(), 0);
+		});
+
+		// member removed, no replacement found.
+		ExtBuilder::default().desired_runners_up(1).build_and_execute(|| {
+			setup();
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(3),
+				Renouncing::RunnerUp
+			));
+			assert_eq!(Elections::remove_and_replace_member(&4, false), Ok(false));
+
+			assert_eq!(members_ids(), vec![5]);
+			assert_eq!(runners_up_ids().len(), 0);
+		});
+
+		// wrong member to remove.
+		ExtBuilder::default().desired_runners_up(1).build_and_execute(|| {
+			setup();
+			assert!(matches!(Elections::remove_and_replace_member(&2, false), Err(_)));
+		});
+	}
+
+	#[test]
+	fn no_desired_members() {
+		// not interested in anything
+		ExtBuilder::default()
+			.desired_members(0)
+			.desired_runners_up(0)
+			.build_and_execute(|| {
+				assert_eq!(Elections::candidates().len(), 0);
+
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+				assert_eq!(Elections::candidates().len(), 3);
+
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+				assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+				assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids().len(), 0);
+				assert_eq!(runners_up_ids().len(), 0);
+				assert_eq!(all_voters().len(), 3);
+				assert_eq!(Elections::candidates().len(), 0);
+			});
+
+		// not interested in members
+		ExtBuilder::default()
+			.desired_members(0)
+			.desired_runners_up(2)
+			.build_and_execute(|| {
+				assert_eq!(Elections::candidates().len(), 0);
+
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+				assert_eq!(Elections::candidates().len(), 3);
+
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+				assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+				assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids().len(), 0);
+				assert_eq!(runners_up_ids(), vec![3, 4]);
+				assert_eq!(all_voters().len(), 3);
+				assert_eq!(Elections::candidates().len(), 0);
+			});
+
+		// not interested in runners-up
+		ExtBuilder::default()
+			.desired_members(2)
+			.desired_runners_up(0)
+			.build_and_execute(|| {
+				assert_eq!(Elections::candidates().len(), 0);
+
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+				assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+
+				assert_eq!(Elections::candidates().len(), 3);
+
+				assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 40));
+				assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+				assert_ok!(vote(RuntimeOrigin::signed(2), vec![2], 20));
+
+				System::set_block_number(5);
+				Elections::on_initialize(System::block_number());
+
+				assert_eq!(members_ids(), vec![3, 4]);
+				assert_eq!(runners_up_ids().len(), 0);
+				assert_eq!(all_voters().len(), 3);
+				assert_eq!(Elections::candidates().len(), 0);
+			});
+	}
+
+	#[test]
+	fn dupe_vote_is_moot() {
+		ExtBuilder::default().desired_members(1).build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(2)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(1)));
+
+			// all these duplicate votes will not cause 2 to win.
+			assert_ok!(vote(RuntimeOrigin::signed(1), vec![2, 2, 2, 2], 5));
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![2, 2, 2, 2], 20));
+
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 30));
+
+			System::set_block_number(5);
+			Elections::on_initialize(System::block_number());
+
+			assert_eq!(members_ids(), vec![3]);
+		})
+	}
+
+	#[test]
+	fn remove_defunct_voter_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(5)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(4)));
+			assert_ok!(submit_candidacy(RuntimeOrigin::signed(3)));
+
+			// defunct
+			assert_ok!(vote(RuntimeOrigin::signed(5), vec![5, 4], 5));
+			// defunct
+			assert_ok!(vote(RuntimeOrigin::signed(4), vec![4], 5));
+			// ok
+			assert_ok!(vote(RuntimeOrigin::signed(3), vec![3], 5));
+			// ok
+			assert_ok!(vote(RuntimeOrigin::signed(2), vec![3, 4], 5));
+
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(5),
+				Renouncing::Candidate(3)
+			));
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(4),
+				Renouncing::Candidate(2)
+			));
+			assert_ok!(Elections::renounce_candidacy(
+				RuntimeOrigin::signed(3),
+				Renouncing::Candidate(1)
+			));
+
+			assert_ok!(Elections::clean_defunct_voters(RuntimeOrigin::root(), 4, 2));
+		})
+	}
+}
diff --git a/substrate/frame/elections-phragmen/src/migrations/mod.rs b/substrate/frame/elections-phragmen/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f5403284126a057957edeae6465d331365594431
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/migrations/mod.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.
+
+//! All migrations of this pallet.
+
+/// Migration to unreserve all pallet funds.
+pub mod unlock_and_unreserve_all_funds;
+/// Version 3.
+pub mod v3;
+/// Version 4.
+pub mod v4;
+/// Version 5.
+pub mod v5;
diff --git a/substrate/frame/elections-phragmen/src/migrations/unlock_and_unreserve_all_funds.rs b/substrate/frame/elections-phragmen/src/migrations/unlock_and_unreserve_all_funds.rs
new file mode 100644
index 0000000000000000000000000000000000000000..482766ee97f543081d520148ed6cdc37c7641945
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/migrations/unlock_and_unreserve_all_funds.rs
@@ -0,0 +1,513 @@
+// 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 migration that unreserves all deposit and unlocks all stake held in the context of this
+//! pallet.
+
+use core::iter::Sum;
+use frame_support::{
+	pallet_prelude::ValueQuery,
+	storage_alias,
+	traits::{Currency, LockIdentifier, LockableCurrency, OnRuntimeUpgrade, ReservableCurrency},
+	weights::RuntimeDbWeight,
+	Parameter, Twox64Concat,
+};
+use sp_core::Get;
+use sp_runtime::traits::Zero;
+use sp_std::{collections::btree_map::BTreeMap, vec::Vec};
+
+const LOG_TARGET: &str = "elections_phragmen::migrations::unlock_and_unreserve_all_funds";
+
+type BalanceOf<T> =
+	<<T as UnlockConfig>::Currency as Currency<<T as UnlockConfig>::AccountId>>::Balance;
+
+/// The configuration for [`UnlockAndUnreserveAllFunds`].
+pub trait UnlockConfig: 'static {
+	/// The account ID used in the runtime.
+	type AccountId: Parameter + Ord;
+	/// The currency type used in the runtime.
+	///
+	/// Should match the currency type previously used for the pallet, if applicable.
+	type Currency: LockableCurrency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
+	/// The name of the pallet as previously configured in
+	/// [`construct_runtime!`](frame_support::construct_runtime).
+	type PalletName: Get<&'static str>;
+	/// The maximum number of votes per voter as configured previously in the previous runtime.
+	type MaxVotesPerVoter: Get<u32>;
+	/// Identifier for the elections-phragmen pallet's lock, as previously configured in the
+	/// runtime.
+	type PalletId: Get<LockIdentifier>;
+	/// The DB weight as configured in the runtime to calculate the correct weight.
+	type DbWeight: Get<RuntimeDbWeight>;
+}
+
+#[storage_alias(dynamic)]
+type Members<T: UnlockConfig> = StorageValue<
+	<T as UnlockConfig>::PalletName,
+	Vec<crate::SeatHolder<<T as UnlockConfig>::AccountId, BalanceOf<T>>>,
+	ValueQuery,
+>;
+
+#[storage_alias(dynamic)]
+type RunnersUp<T: UnlockConfig> = StorageValue<
+	<T as UnlockConfig>::PalletName,
+	Vec<crate::SeatHolder<<T as UnlockConfig>::AccountId, BalanceOf<T>>>,
+	ValueQuery,
+>;
+
+#[storage_alias(dynamic)]
+type Candidates<T: UnlockConfig> = StorageValue<
+	<T as UnlockConfig>::PalletName,
+	Vec<(<T as UnlockConfig>::AccountId, BalanceOf<T>)>,
+	ValueQuery,
+>;
+
+#[storage_alias(dynamic)]
+type Voting<T: UnlockConfig> = StorageMap<
+	<T as UnlockConfig>::PalletName,
+	Twox64Concat,
+	<T as UnlockConfig>::AccountId,
+	crate::Voter<<T as UnlockConfig>::AccountId, BalanceOf<T>>,
+	ValueQuery,
+>;
+
+/// A migration that unreserves all deposit and unlocks all stake held in the context of this
+/// pallet.
+///
+/// Useful to prevent funds from being locked up when the pallet is being deprecated.
+///
+/// The pallet should be made inoperable before this migration is run.
+///
+/// (See also [`RemovePallet`][frame_support::migrations::RemovePallet])
+pub struct UnlockAndUnreserveAllFunds<T: UnlockConfig>(sp_std::marker::PhantomData<T>);
+
+impl<T: UnlockConfig> UnlockAndUnreserveAllFunds<T> {
+	/// Calculates and returns the total amounts deposited and staked by each account in the context
+	/// of this pallet.
+	///
+	/// The deposited and staked amounts are returned in two separate `BTreeMap` collections.
+	///
+	/// The first `BTreeMap`, `account_deposited_sums`, contains each account's total amount
+	/// deposited. This includes deposits made by Members, RunnerUps, Candidates, and Voters.
+	///
+	/// The second `BTreeMap`, `account_staked_sums`, contains each account's total amount staked.
+	/// This includes stakes made by Voters.
+	///
+	/// # Returns
+	///
+	/// This function returns a tuple of two `BTreeMap` collections and the weight of the reads:
+	///
+	/// * `BTreeMap<T::AccountId, BalanceOf<T>>`: Map of account IDs to their respective total
+	///   deposit sums.
+	/// * `BTreeMap<T::AccountId, BalanceOf<T>>`: Map of account IDs to their respective total
+	///   staked sums.
+	/// * `frame_support::weights::Weight`: The weight of reading the storage.
+	fn get_account_deposited_and_staked_sums() -> (
+		BTreeMap<T::AccountId, BalanceOf<T>>,
+		BTreeMap<T::AccountId, BalanceOf<T>>,
+		frame_support::weights::Weight,
+	) {
+		use sp_runtime::Saturating;
+
+		let members = Members::<T>::get();
+		let runner_ups = RunnersUp::<T>::get();
+		let candidates = Candidates::<T>::get();
+
+		// Get the total amount deposited (Members, RunnerUps, Candidates and Voters all can have
+		// deposits).
+		let account_deposited_sums: BTreeMap<T::AccountId, BalanceOf<T>> = members
+			// Massage all data structures into (account_id, deposit) tuples.
+			.iter()
+			.chain(runner_ups.iter())
+			.map(|member| (member.who.clone(), member.deposit))
+			.chain(candidates.iter().map(|(candidate, amount)| (candidate.clone(), *amount)))
+			.chain(
+				Voting::<T>::iter().map(|(account_id, voter)| (account_id.clone(), voter.deposit)),
+			)
+			// Finally, aggregate the tuples into a Map.
+			.fold(BTreeMap::new(), |mut acc, (id, deposit)| {
+				acc.entry(id.clone()).or_insert(Zero::zero()).saturating_accrue(deposit);
+				acc
+			});
+
+		// Get the total amount staked (only Voters stake) and count the number of voters.
+		let mut voters_len = 0;
+		let account_staked_sums: BTreeMap<T::AccountId, BalanceOf<T>> = Voting::<T>::iter()
+			.map(|(account_id, voter)| (account_id.clone(), voter.stake))
+			.fold(BTreeMap::new(), |mut acc, (id, stake)| {
+				voters_len.saturating_accrue(1);
+				acc.entry(id.clone()).or_insert(Zero::zero()).saturating_accrue(stake);
+				acc
+			});
+
+		(
+			account_deposited_sums,
+			account_staked_sums,
+			T::DbWeight::get().reads(
+				members
+					.len()
+					.saturating_add(runner_ups.len())
+					.saturating_add(candidates.len())
+					.saturating_add(voters_len.saturating_mul(T::MaxVotesPerVoter::get() as usize))
+					as u64,
+			),
+		)
+	}
+}
+
+impl<T: UnlockConfig> OnRuntimeUpgrade for UnlockAndUnreserveAllFunds<T>
+where
+	BalanceOf<T>: Sum,
+{
+	/// Collects pre-migration data useful for validating the migration was successful, and also
+	/// checks the integrity of deposited and reserved balances.
+	///
+	/// Steps:
+	/// 1. Gets the deposited and staked balances for each account stored in this pallet.
+	/// 2. Collects actual pre-migration locked and reserved balances for each account.
+	/// 3. Checks the integrity of the deposited and reserved balances.
+	/// 4. Prints summary statistics about the state to be migrated.
+	/// 5. Encodes and returns pre-migration data to be used in post_upgrade.
+	///
+	/// Fails with a `TryRuntimeError` if there's a discrepancy between the amount
+	/// reported as staked by the pallet and the amount actually locked in `Balances`.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		use codec::Encode;
+		use sp_std::collections::btree_set::BTreeSet;
+
+		// Get staked and deposited balances as reported by this pallet.
+		let (account_deposited_sums, account_staked_sums, _) =
+			Self::get_account_deposited_and_staked_sums();
+
+		let all_accounts: BTreeSet<T::AccountId> = account_staked_sums
+			.keys()
+			.chain(account_deposited_sums.keys())
+			.cloned()
+			.collect();
+
+		let account_reserved_before: BTreeMap<T::AccountId, BalanceOf<T>> = all_accounts
+			.iter()
+			.map(|account| (account.clone(), T::Currency::reserved_balance(&account)))
+			.collect();
+
+		// Total deposited for each account *should* be less than or equal to the total reserved,
+		// however this does not hold for all cases due to bugs in the reserve logic of this pallet.
+		let bugged_deposits = all_accounts
+			.iter()
+			.filter(|account| {
+				account_deposited_sums.get(&account).unwrap_or(&Zero::zero()) >
+					account_reserved_before.get(&account).unwrap_or(&Zero::zero())
+			})
+			.count();
+
+		// Print some summary stats.
+		let total_stake_to_unlock = account_staked_sums.clone().into_values().sum::<BalanceOf<T>>();
+		let total_deposits_to_unreserve =
+			account_deposited_sums.clone().into_values().sum::<BalanceOf<T>>();
+		log::info!(target: LOG_TARGET, "Total accounts: {:?}", all_accounts.len());
+		log::info!(target: LOG_TARGET, "Total stake to unlock: {:?}", total_stake_to_unlock);
+		log::info!(
+			target: LOG_TARGET,
+			"Total deposit to unreserve: {:?}",
+			total_deposits_to_unreserve
+		);
+		if bugged_deposits > 0 {
+			log::warn!(
+				target: LOG_TARGET,
+				"Bugged deposits: {}/{}",
+				bugged_deposits,
+				all_accounts.len()
+			);
+		}
+
+		Ok(account_reserved_before.encode())
+	}
+
+	/// Executes the migration.
+	///
+	/// Steps:
+	/// 1. Retrieves the deposit and stake amounts from the pallet.
+	/// 2. Unreserves the deposited funds for each account.
+	/// 3. Unlocks the staked funds for each account.
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		// Get staked and deposited balances as reported by this pallet.
+		let (account_deposited_sums, account_staked_sums, initial_reads) =
+			Self::get_account_deposited_and_staked_sums();
+
+		// Deposited funds need to be unreserved.
+		for (account, unreserve_amount) in account_deposited_sums.iter() {
+			if unreserve_amount.is_zero() {
+				log::warn!(target: LOG_TARGET, "Unexpected zero amount to unreserve");
+				continue
+			}
+			T::Currency::unreserve(&account, *unreserve_amount);
+		}
+
+		// Staked funds need to be unlocked.
+		for (account, amount) in account_staked_sums.iter() {
+			if amount.is_zero() {
+				log::warn!(target: LOG_TARGET, "Unexpected zero amount to unlock");
+				continue
+			}
+			T::Currency::remove_lock(T::PalletId::get(), account);
+		}
+
+		T::DbWeight::get()
+			.reads_writes(
+				(account_deposited_sums.len().saturating_add(account_staked_sums.len())) as u64,
+				(account_deposited_sums.len().saturating_add(account_staked_sums.len())) as u64,
+			)
+			.saturating_add(initial_reads)
+	}
+
+	/// Performs post-upgrade sanity checks:
+	///
+	/// 1. All expected locks were removed after the migration.
+	/// 2. The reserved balance for each account has been reduced by the expected amount.
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(
+		account_reserved_before_bytes: Vec<u8>,
+	) -> Result<(), sp_runtime::TryRuntimeError> {
+		use codec::Decode;
+		use sp_runtime::Saturating;
+
+		let account_reserved_before =
+			BTreeMap::<T::AccountId, BalanceOf<T>>::decode(&mut &account_reserved_before_bytes[..])
+				.map_err(|_| "Failed to decode account_reserved_before_bytes")?;
+
+		// Get deposited balances as reported by this pallet.
+		let (account_deposited_sums, _, _) = Self::get_account_deposited_and_staked_sums();
+
+		// Check that the reserved balance is reduced by the expected deposited amount.
+		for (account, actual_reserved_before) in account_reserved_before {
+			let actual_reserved_after = T::Currency::reserved_balance(&account);
+			let expected_amount_deducted = *account_deposited_sums
+				.get(&account)
+				.unwrap_or(&Zero::zero())
+				// .min here to handle bugged deposits where actual_reserved_before is less than the
+				// amount the pallet reports is reserved
+				.min(&actual_reserved_before);
+			let expected_reserved_after =
+				actual_reserved_before.saturating_sub(expected_amount_deducted);
+			assert!(
+				actual_reserved_after == expected_reserved_after,
+				"Reserved balance for {:?} is incorrect. actual before: {:?}, actual after, {:?}, expected deducted: {:?}",
+				account,
+				actual_reserved_before,
+				actual_reserved_after,
+				expected_amount_deducted,
+			);
+		}
+
+		Ok(())
+	}
+}
+
+#[cfg(all(feature = "try-runtime", test))]
+mod test {
+	use super::*;
+	use crate::{
+		tests::{Balances, ElectionsPhragmenPalletId, ExtBuilder, PhragmenMaxVoters, Test},
+		Candidates, Members, RunnersUp, SeatHolder, Voter, Voting,
+	};
+	use frame_support::{
+		assert_ok, parameter_types,
+		traits::{Currency, OnRuntimeUpgrade, ReservableCurrency, WithdrawReasons},
+	};
+
+	parameter_types! {
+		const PalletName: &'static str = "Elections";
+	}
+
+	struct UnlockConfigImpl;
+	impl super::UnlockConfig for UnlockConfigImpl {
+		type Currency = Balances;
+		type AccountId = u64;
+		type DbWeight = ();
+		type PalletName = PalletName;
+		type MaxVotesPerVoter = PhragmenMaxVoters;
+		type PalletId = ElectionsPhragmenPalletId;
+	}
+
+	#[test]
+	fn unreserve_works_for_candidate() {
+		let candidate = 10;
+		let deposit = 100;
+		let initial_reserved = 15;
+		let initial_balance = 100_000;
+		ExtBuilder::default().build_and_execute(|| {
+			// Set up initial state.
+			<Test as crate::Config>::Currency::make_free_balance_be(&candidate, initial_balance);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&candidate, initial_reserved));
+			Candidates::<Test>::set(vec![(candidate, deposit)]);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&candidate, deposit));
+
+			// Sanity check: ensure initial Balance state was set up correctly.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&candidate),
+				deposit + initial_reserved
+			);
+
+			// Run the migration.
+			let bytes = UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::pre_upgrade()
+				.unwrap_or_else(|e| panic!("pre_upgrade failed: {:?}", e));
+			UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::on_runtime_upgrade();
+			assert_ok!(UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::post_upgrade(bytes));
+
+			// Assert the candidate reserved balance was reduced by the expected amount.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&candidate),
+				initial_reserved
+			);
+		});
+	}
+
+	#[test]
+	fn unreserve_works_for_runner_up() {
+		let runner_up = 10;
+		let deposit = 100;
+		let initial_reserved = 15;
+		let initial_balance = 100_000;
+		ExtBuilder::default().build_and_execute(|| {
+			// Set up initial state.
+			<Test as crate::Config>::Currency::make_free_balance_be(&runner_up, initial_balance);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&runner_up, initial_reserved));
+			RunnersUp::<Test>::set(vec![SeatHolder { who: runner_up, deposit, stake: 10 }]);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&runner_up, deposit));
+
+			// Sanity check: ensure initial Balance state was set up correctly.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&runner_up),
+				deposit + initial_reserved
+			);
+
+			// Run the migration.
+			let bytes = UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::pre_upgrade()
+				.unwrap_or_else(|e| panic!("pre_upgrade failed: {:?}", e));
+			UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::on_runtime_upgrade();
+			assert_ok!(UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::post_upgrade(bytes));
+
+			// Assert the reserved balance was reduced by the expected amount.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&runner_up),
+				initial_reserved
+			);
+		});
+	}
+
+	#[test]
+	fn unreserve_works_for_member() {
+		let member = 10;
+		let deposit = 100;
+		let initial_reserved = 15;
+		let initial_balance = 100_000;
+		ExtBuilder::default().build_and_execute(|| {
+			// Set up initial state.
+			<Test as crate::Config>::Currency::make_free_balance_be(&member, initial_balance);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&member, initial_reserved));
+			Members::<Test>::set(vec![SeatHolder { who: member, deposit, stake: 10 }]);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&member, deposit));
+
+			// Sanity check: ensure initial Balance state was set up correctly.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&member),
+				deposit + initial_reserved
+			);
+
+			// Run the migration.
+			let bytes = UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::pre_upgrade()
+				.unwrap_or_else(|e| panic!("pre_upgrade failed: {:?}", e));
+			UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::on_runtime_upgrade();
+			assert_ok!(UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::post_upgrade(bytes));
+
+			// Assert the reserved balance was reduced by the expected amount.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&member),
+				initial_reserved
+			);
+		});
+	}
+
+	#[test]
+	fn unlock_and_unreserve_works_for_voter() {
+		let voter = 10;
+		let deposit = 100;
+		let initial_reserved = 15;
+		let initial_locks = vec![(b"somethin", 10)];
+		let stake = 25;
+		let initial_balance = 100_000;
+		ExtBuilder::default().build_and_execute(|| {
+			let pallet_id = <Test as crate::Config>::PalletId::get();
+
+			// Set up initial state.
+			<Test as crate::Config>::Currency::make_free_balance_be(&voter, initial_balance);
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&voter, initial_reserved));
+			for lock in initial_locks.clone() {
+				<Test as crate::Config>::Currency::set_lock(
+					*lock.0,
+					&voter,
+					lock.1,
+					WithdrawReasons::all(),
+				);
+			}
+			Voting::<Test>::insert(voter, Voter { votes: vec![], deposit, stake });
+			assert_ok!(<Test as crate::Config>::Currency::reserve(&voter, deposit));
+			<Test as crate::Config>::Currency::set_lock(
+				<Test as crate::Config>::PalletId::get(),
+				&voter,
+				stake,
+				WithdrawReasons::all(),
+			);
+
+			// Sanity check: ensure initial Balance state was set up correctly.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&voter),
+				deposit + initial_reserved
+			);
+			let mut voter_all_locks = initial_locks.clone();
+			voter_all_locks.push((&pallet_id, stake));
+			assert_eq!(
+				<Test as crate::Config>::Currency::locks(&voter)
+					.iter()
+					.map(|lock| (&lock.id, lock.amount))
+					.collect::<Vec<_>>(),
+				voter_all_locks
+			);
+
+			// Run the migration.
+			let bytes = UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::pre_upgrade()
+				.unwrap_or_else(|e| panic!("pre_upgrade failed: {:?}", e));
+			UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::on_runtime_upgrade();
+			assert_ok!(UnlockAndUnreserveAllFunds::<UnlockConfigImpl>::post_upgrade(bytes));
+
+			// Assert the voter lock was removed and the reserved balance was reduced by the
+			// expected amount.
+			assert_eq!(
+				<Test as crate::Config>::Currency::reserved_balance(&voter),
+				initial_reserved
+			);
+			assert_eq!(
+				<Test as crate::Config>::Currency::locks(&voter)
+					.iter()
+					.map(|lock| (&lock.id, lock.amount))
+					.collect::<Vec<_>>(),
+				initial_locks
+			);
+		});
+	}
+}
diff --git a/substrate/frame/elections-phragmen/src/migrations/v3.rs b/substrate/frame/elections-phragmen/src/migrations/v3.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cdca1138ebbd2f9de20ebcfaf9e39fb313850347
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/migrations/v3.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.
+
+//! Migrations to version [`3.0.0`], as denoted by the changelog.
+
+use super::super::LOG_TARGET;
+use crate::{Config, Pallet};
+use codec::{Decode, Encode, FullCodec};
+use frame_support::{
+	pallet_prelude::ValueQuery, traits::StorageVersion, weights::Weight, Twox64Concat,
+};
+use sp_runtime::RuntimeDebug;
+use sp_std::prelude::*;
+
+#[derive(Encode, Decode, Clone, Default, RuntimeDebug, PartialEq)]
+struct SeatHolder<AccountId, Balance> {
+	who: AccountId,
+	stake: Balance,
+	deposit: Balance,
+}
+
+#[derive(Encode, Decode, Clone, Default, RuntimeDebug, PartialEq)]
+struct Voter<AccountId, Balance> {
+	votes: Vec<AccountId>,
+	stake: Balance,
+	deposit: Balance,
+}
+
+/// Trait to implement to give information about types used for migration
+pub trait V2ToV3 {
+	/// System config account id
+	type AccountId: 'static + FullCodec;
+
+	/// Elections-phragmen currency balance.
+	type Balance: 'static + FullCodec + Copy;
+}
+
+#[frame_support::storage_alias]
+type Candidates<V, T: Config> =
+	StorageValue<Pallet<T>, Vec<(<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance)>, ValueQuery>;
+
+#[frame_support::storage_alias]
+type Members<V, T: Config> = StorageValue<
+	Pallet<T>,
+	Vec<SeatHolder<<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance>>,
+	ValueQuery,
+>;
+
+#[frame_support::storage_alias]
+type RunnersUp<V, T: Config> = StorageValue<
+	Pallet<T>,
+	Vec<SeatHolder<<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance>>,
+	ValueQuery,
+>;
+
+#[frame_support::storage_alias]
+type Voting<V, T: Config> = StorageMap<
+	Pallet<T>,
+	Twox64Concat,
+	<V as V2ToV3>::AccountId,
+	Voter<<V as V2ToV3>::AccountId, <V as V2ToV3>::Balance>,
+>;
+
+/// Apply all of the migrations from 2 to 3.
+///
+/// ### Warning
+///
+/// This code will **ONLY** check that the storage version is less than or equal to 2_0_0.
+/// Further check might be needed at the user runtime.
+///
+/// Be aware that this migration is intended to be used only for the mentioned versions. Use
+/// with care and run at your own risk.
+pub fn apply<V: V2ToV3, T: Config>(
+	old_voter_bond: V::Balance,
+	old_candidacy_bond: V::Balance,
+) -> Weight {
+	let storage_version = StorageVersion::get::<Pallet<T>>();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration for elections-phragmen with storage version {:?}",
+		storage_version,
+	);
+
+	if storage_version <= 2 {
+		migrate_voters_to_recorded_deposit::<V, T>(old_voter_bond);
+		migrate_candidates_to_recorded_deposit::<V, T>(old_candidacy_bond);
+		migrate_runners_up_to_recorded_deposit::<V, T>(old_candidacy_bond);
+		migrate_members_to_recorded_deposit::<V, T>(old_candidacy_bond);
+
+		StorageVersion::new(3).put::<Pallet<T>>();
+
+		Weight::MAX
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to V3 but failed because storage version is {:?}",
+			storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Migrate from the old legacy voting bond (fixed) to the new one (per-vote dynamic).
+pub fn migrate_voters_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	<Voting<V, T>>::translate::<(V::Balance, Vec<V::AccountId>), _>(|_who, (stake, votes)| {
+		Some(Voter { votes, stake, deposit: old_deposit })
+	});
+
+	log::info!(target: LOG_TARGET, "migrated {} voter accounts.", <Voting<V, T>>::iter().count());
+}
+
+/// Migrate all candidates to recorded deposit.
+pub fn migrate_candidates_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	let _ = <Candidates<V, T>>::translate::<Vec<V::AccountId>, _>(|maybe_old_candidates| {
+		maybe_old_candidates.map(|old_candidates| {
+			log::info!(target: LOG_TARGET, "migrated {} candidate accounts.", old_candidates.len());
+			old_candidates.into_iter().map(|c| (c, old_deposit)).collect::<Vec<_>>()
+		})
+	});
+}
+
+/// Migrate all members to recorded deposit.
+pub fn migrate_members_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	let _ = <Members<V, T>>::translate::<Vec<(V::AccountId, V::Balance)>, _>(|maybe_old_members| {
+		maybe_old_members.map(|old_members| {
+			log::info!(target: LOG_TARGET, "migrated {} member accounts.", old_members.len());
+			old_members
+				.into_iter()
+				.map(|(who, stake)| SeatHolder { who, stake, deposit: old_deposit })
+				.collect::<Vec<_>>()
+		})
+	});
+}
+
+/// Migrate all runners-up to recorded deposit.
+pub fn migrate_runners_up_to_recorded_deposit<V: V2ToV3, T: Config>(old_deposit: V::Balance) {
+	let _ = <RunnersUp<V, T>>::translate::<Vec<(V::AccountId, V::Balance)>, _>(
+		|maybe_old_runners_up| {
+			maybe_old_runners_up.map(|old_runners_up| {
+				log::info!(
+					target: LOG_TARGET,
+					"migrated {} runner-up accounts.",
+					old_runners_up.len(),
+				);
+				old_runners_up
+					.into_iter()
+					.map(|(who, stake)| SeatHolder { who, stake, deposit: old_deposit })
+					.collect::<Vec<_>>()
+			})
+		},
+	);
+}
diff --git a/substrate/frame/elections-phragmen/src/migrations/v4.rs b/substrate/frame/elections-phragmen/src/migrations/v4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7e946371f5ca6cfe8c6399aab61d886a48f7e880
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/migrations/v4.rs
@@ -0,0 +1,107 @@
+// 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.
+
+//! Migrations to version [`4.0.0`], as denoted by the changelog.
+
+use super::super::LOG_TARGET;
+use frame_support::{
+	traits::{Get, StorageVersion},
+	weights::Weight,
+};
+
+/// The old prefix.
+pub const OLD_PREFIX: &[u8] = b"PhragmenElection";
+
+/// Migrate the entire storage of this pallet to a new prefix.
+///
+/// This new prefix must be the same as the one set in construct_runtime. For safety, use
+/// `PalletInfo` to get it, as:
+/// `<Runtime as frame_system::Config>::PalletInfo::name::<ElectionsPhragmenPallet>`.
+///
+/// The old storage prefix, `PhragmenElection` is hardcoded in the migration code.
+pub fn migrate<T: crate::Config, N: AsRef<str>>(new_pallet_name: N) -> Weight {
+	if new_pallet_name.as_ref().as_bytes() == OLD_PREFIX {
+		log::info!(
+			target: LOG_TARGET,
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return Weight::zero()
+	}
+	let storage_version = StorageVersion::get::<crate::Pallet<T>>();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration to v4 for elections-phragmen with storage version {:?}",
+		storage_version,
+	);
+
+	if storage_version <= 3 {
+		log::info!("new prefix: {}", new_pallet_name.as_ref());
+		frame_support::storage::migration::move_pallet(
+			OLD_PREFIX,
+			new_pallet_name.as_ref().as_bytes(),
+		);
+
+		StorageVersion::new(4).put::<crate::Pallet<T>>();
+
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to v4 but failed because storage version is {:?}",
+			storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::pre_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migration<T: crate::Config, N: AsRef<str>>(new: N) {
+	let new = new.as_ref();
+	log::info!("pre-migration elections-phragmen test with new = {}", new);
+
+	// the next key must exist, and start with the hash of `OLD_PREFIX`.
+	let next_key = sp_io::storage::next_key(OLD_PREFIX).unwrap();
+	assert!(next_key.starts_with(&sp_io::hashing::twox_128(OLD_PREFIX)));
+
+	// ensure nothing is stored in the new prefix.
+	assert!(
+		sp_io::storage::next_key(new.as_bytes()).map_or(
+			// either nothing is there
+			true,
+			// or we ensure that it has no common prefix with twox_128(new).
+			|next_key| !next_key.starts_with(&sp_io::hashing::twox_128(new.as_bytes()))
+		),
+		"unexpected next_key({}) = {:?}",
+		new,
+		sp_core::hexdisplay::HexDisplay::from(&sp_io::storage::next_key(new.as_bytes()).unwrap())
+	);
+	// ensure storage version is 3.
+	assert_eq!(StorageVersion::get::<crate::Pallet<T>>(), 3);
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migration<T: crate::Config>() {
+	log::info!("post-migration elections-phragmen");
+	// ensure we've been updated to v4 by the automatic write of crate version -> storage version.
+	assert_eq!(StorageVersion::get::<crate::Pallet<T>>(), 4);
+}
diff --git a/substrate/frame/elections-phragmen/src/migrations/v5.rs b/substrate/frame/elections-phragmen/src/migrations/v5.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb35c1fae0f29645ceba82c9c38f83ad382e6561
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/migrations/v5.rs
@@ -0,0 +1,70 @@
+use super::super::*;
+
+/// Migrate the locks and vote stake on accounts (as specified with param `to_migrate`) that have
+/// more than their free balance locked.
+///
+/// This migration addresses a bug were a voter could lock up to their reserved balance + free
+/// balance. Since locks are only designed to operate on free balance, this put those affected in a
+/// situation where they could increase their free balance but still not be able to use their funds
+/// because they were less than the lock.
+pub fn migrate<T: Config>(to_migrate: Vec<T::AccountId>) -> Weight {
+	let mut weight = Weight::zero();
+
+	for who in to_migrate.iter() {
+		if let Ok(mut voter) = Voting::<T>::try_get(who) {
+			let free_balance = T::Currency::free_balance(who);
+
+			weight = weight.saturating_add(T::DbWeight::get().reads(2));
+
+			if voter.stake > free_balance {
+				voter.stake = free_balance;
+				Voting::<T>::insert(&who, voter);
+
+				let pallet_id = T::PalletId::get();
+				T::Currency::set_lock(pallet_id, who, free_balance, WithdrawReasons::all());
+
+				weight = weight.saturating_add(T::DbWeight::get().writes(2));
+			}
+		}
+	}
+
+	weight
+}
+
+/// Given the list of voters to migrate return a function that does some checks and information
+/// prior to migration. This can be linked to [`frame_support::traits::OnRuntimeUpgrade::
+/// pre_upgrade`] for further testing.
+pub fn pre_migrate_fn<T: Config>(to_migrate: Vec<T::AccountId>) -> Box<dyn Fn() -> ()> {
+	Box::new(move || {
+		for who in to_migrate.iter() {
+			if let Ok(voter) = Voting::<T>::try_get(who) {
+				let free_balance = T::Currency::free_balance(who);
+
+				if voter.stake > free_balance {
+					// all good
+				} else {
+					log::warn!("pre-migrate elections-phragmen: voter={:?} has less stake then free balance", who);
+				}
+			} else {
+				log::warn!("pre-migrate elections-phragmen: cannot find voter={:?}", who);
+			}
+		}
+		log::info!("pre-migrate elections-phragmen complete");
+	})
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migrate<T: crate::Config>() {
+	for (who, voter) in Voting::<T>::iter() {
+		let free_balance = T::Currency::free_balance(&who);
+
+		assert!(voter.stake <= free_balance, "migration should have made locked <= free_balance");
+		// Ideally we would also check that the locks and AccountData.misc_frozen where correctly
+		// updated, but since both of those are generic we can't do that without further bounding T.
+	}
+
+	log::info!("post-migrate elections-phragmen complete");
+}
diff --git a/substrate/frame/elections-phragmen/src/weights.rs b/substrate/frame/elections-phragmen/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b7ed13dae9f734e524072bcd6ac5e116fca632bc
--- /dev/null
+++ b/substrate/frame/elections-phragmen/src/weights.rs
@@ -0,0 +1,582 @@
+// 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.
+
+//! Autogenerated weights for pallet_elections_phragmen
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_elections_phragmen
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/elections-phragmen/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_elections_phragmen.
+pub trait WeightInfo {
+	fn vote_equal(v: u32, ) -> Weight;
+	fn vote_more(v: u32, ) -> Weight;
+	fn vote_less(v: u32, ) -> Weight;
+	fn remove_voter() -> Weight;
+	fn submit_candidacy(c: u32, ) -> Weight;
+	fn renounce_candidacy_candidate(c: u32, ) -> Weight;
+	fn renounce_candidacy_members() -> Weight;
+	fn renounce_candidacy_runners_up() -> Weight;
+	fn remove_member_without_replacement() -> Weight;
+	fn remove_member_with_replacement() -> Weight;
+	fn clean_defunct_voters(v: u32, d: u32, ) -> Weight;
+	fn election_phragmen(c: u32, v: u32, e: u32, ) -> Weight;
+}
+
+/// Weights for pallet_elections_phragmen using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `v` is `[1, 16]`.
+	fn vote_equal(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + v * (80 ±0)`
+		//  Estimated: `4764 + v * (80 ±0)`
+		// Minimum execution time: 33_028_000 picoseconds.
+		Weight::from_parts(34_073_914, 4764)
+			// Standard Error: 3_474
+			.saturating_add(Weight::from_parts(205_252, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 80).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `v` is `[2, 16]`.
+	fn vote_more(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `371 + v * (80 ±0)`
+		//  Estimated: `4764 + v * (80 ±0)`
+		// Minimum execution time: 45_725_000 picoseconds.
+		Weight::from_parts(47_169_586, 4764)
+			// Standard Error: 5_148
+			.saturating_add(Weight::from_parts(213_742, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 80).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `v` is `[2, 16]`.
+	fn vote_less(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + v * (80 ±0)`
+		//  Estimated: `4764 + v * (80 ±0)`
+		// Minimum execution time: 45_519_000 picoseconds.
+		Weight::from_parts(47_339_108, 4764)
+			// Standard Error: 5_501
+			.saturating_add(Weight::from_parts(195_247, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 80).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	fn remove_voter() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `925`
+		//  Estimated: `4764`
+		// Minimum execution time: 50_386_000 picoseconds.
+		Weight::from_parts(51_378_000, 4764)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Elections Candidates (r:1 w:1)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `c` is `[1, 64]`.
+	fn submit_candidacy(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1570 + c * (48 ±0)`
+		//  Estimated: `3055 + c * (48 ±0)`
+		// Minimum execution time: 38_987_000 picoseconds.
+		Weight::from_parts(41_302_276, 3055)
+			// Standard Error: 2_047
+			.saturating_add(Weight::from_parts(125_200, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 48).saturating_mul(c.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:1)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `c` is `[1, 64]`.
+	fn renounce_candidacy_candidate(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `285 + c * (48 ±0)`
+		//  Estimated: `1770 + c * (48 ±0)`
+		// Minimum execution time: 33_510_000 picoseconds.
+		Weight::from_parts(34_947_760, 1770)
+			// Standard Error: 1_781
+			.saturating_add(Weight::from_parts(78_851, 0).saturating_mul(c.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 48).saturating_mul(c.into()))
+	}
+	/// Storage: Elections Members (r:1 w:1)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Members (r:0 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	fn renounce_candidacy_members() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1900`
+		//  Estimated: `3385`
+		// Minimum execution time: 50_603_000 picoseconds.
+		Weight::from_parts(51_715_000, 3385)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	fn renounce_candidacy_runners_up() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `880`
+		//  Estimated: `2365`
+		// Minimum execution time: 33_441_000 picoseconds.
+		Weight::from_parts(34_812_000, 2365)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Benchmark Override (r:0 w:0)
+	/// Proof Skipped: Benchmark Override (max_values: None, max_size: None, mode: Measured)
+	fn remove_member_without_replacement() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_000_000_000_000 picoseconds.
+		Weight::from_parts(2_000_000_000_000, 0)
+	}
+	/// Storage: Elections Members (r:1 w:1)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Members (r:0 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	fn remove_member_with_replacement() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1900`
+		//  Estimated: `3593`
+		// Minimum execution time: 57_289_000 picoseconds.
+		Weight::from_parts(58_328_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Elections Voting (r:513 w:512)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Balances Locks (r:512 w:512)
+	/// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen)
+	/// Storage: Balances Freezes (r:512 w:0)
+	/// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:512 w:512)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `v` is `[256, 512]`.
+	/// The range of component `d` is `[0, 256]`.
+	fn clean_defunct_voters(v: u32, _d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1149 + v * (811 ±0)`
+		//  Estimated: `4621 + v * (3774 ±0)`
+		// Minimum execution time: 18_774_231_000 picoseconds.
+		Weight::from_parts(18_933_040_000, 4621)
+			// Standard Error: 301_534
+			.saturating_add(Weight::from_parts(44_306_903, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(v.into())))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(v.into())))
+			.saturating_add(Weight::from_parts(0, 3774).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:1)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:1)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:513 w:0)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: System Account (r:44 w:44)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Elections ElectionRounds (r:1 w:1)
+	/// Proof Skipped: Elections ElectionRounds (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Members (r:0 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:0 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `c` is `[1, 64]`.
+	/// The range of component `v` is `[1, 512]`.
+	/// The range of component `e` is `[512, 8192]`.
+	fn election_phragmen(c: u32, v: u32, e: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + e * (28 ±0) + v * (606 ±0)`
+		//  Estimated: `178887 + c * (2135 ±7) + e * (12 ±0) + v * (2653 ±6)`
+		// Minimum execution time: 1_281_877_000 picoseconds.
+		Weight::from_parts(1_288_147_000, 178887)
+			// Standard Error: 528_851
+			.saturating_add(Weight::from_parts(17_761_407, 0).saturating_mul(v.into()))
+			// Standard Error: 33_932
+			.saturating_add(Weight::from_parts(698_277, 0).saturating_mul(e.into()))
+			.saturating_add(T::DbWeight::get().reads(21_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(c.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(v.into())))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(c.into())))
+			.saturating_add(Weight::from_parts(0, 2135).saturating_mul(c.into()))
+			.saturating_add(Weight::from_parts(0, 12).saturating_mul(e.into()))
+			.saturating_add(Weight::from_parts(0, 2653).saturating_mul(v.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `v` is `[1, 16]`.
+	fn vote_equal(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + v * (80 ±0)`
+		//  Estimated: `4764 + v * (80 ±0)`
+		// Minimum execution time: 33_028_000 picoseconds.
+		Weight::from_parts(34_073_914, 4764)
+			// Standard Error: 3_474
+			.saturating_add(Weight::from_parts(205_252, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 80).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `v` is `[2, 16]`.
+	fn vote_more(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `371 + v * (80 ±0)`
+		//  Estimated: `4764 + v * (80 ±0)`
+		// Minimum execution time: 45_725_000 picoseconds.
+		Weight::from_parts(47_169_586, 4764)
+			// Standard Error: 5_148
+			.saturating_add(Weight::from_parts(213_742, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 80).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `v` is `[2, 16]`.
+	fn vote_less(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + v * (80 ±0)`
+		//  Estimated: `4764 + v * (80 ±0)`
+		// Minimum execution time: 45_519_000 picoseconds.
+		Weight::from_parts(47_339_108, 4764)
+			// Standard Error: 5_501
+			.saturating_add(Weight::from_parts(195_247, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 80).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Voting (r:1 w:1)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	fn remove_voter() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `925`
+		//  Estimated: `4764`
+		// Minimum execution time: 50_386_000 picoseconds.
+		Weight::from_parts(51_378_000, 4764)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Elections Candidates (r:1 w:1)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `c` is `[1, 64]`.
+	fn submit_candidacy(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1570 + c * (48 ±0)`
+		//  Estimated: `3055 + c * (48 ±0)`
+		// Minimum execution time: 38_987_000 picoseconds.
+		Weight::from_parts(41_302_276, 3055)
+			// Standard Error: 2_047
+			.saturating_add(Weight::from_parts(125_200, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 48).saturating_mul(c.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:1)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `c` is `[1, 64]`.
+	fn renounce_candidacy_candidate(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `285 + c * (48 ±0)`
+		//  Estimated: `1770 + c * (48 ±0)`
+		// Minimum execution time: 33_510_000 picoseconds.
+		Weight::from_parts(34_947_760, 1770)
+			// Standard Error: 1_781
+			.saturating_add(Weight::from_parts(78_851, 0).saturating_mul(c.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 48).saturating_mul(c.into()))
+	}
+	/// Storage: Elections Members (r:1 w:1)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Members (r:0 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	fn renounce_candidacy_members() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1900`
+		//  Estimated: `3385`
+		// Minimum execution time: 50_603_000 picoseconds.
+		Weight::from_parts(51_715_000, 3385)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	fn renounce_candidacy_runners_up() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `880`
+		//  Estimated: `2365`
+		// Minimum execution time: 33_441_000 picoseconds.
+		Weight::from_parts(34_812_000, 2365)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Benchmark Override (r:0 w:0)
+	/// Proof Skipped: Benchmark Override (max_values: None, max_size: None, mode: Measured)
+	fn remove_member_without_replacement() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_000_000_000_000 picoseconds.
+		Weight::from_parts(2_000_000_000_000, 0)
+	}
+	/// Storage: Elections Members (r:1 w:1)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:1 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Members (r:0 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	fn remove_member_with_replacement() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1900`
+		//  Estimated: `3593`
+		// Minimum execution time: 57_289_000 picoseconds.
+		Weight::from_parts(58_328_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Elections Voting (r:513 w:512)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:0)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Candidates (r:1 w:0)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Balances Locks (r:512 w:512)
+	/// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen)
+	/// Storage: Balances Freezes (r:512 w:0)
+	/// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:512 w:512)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `v` is `[256, 512]`.
+	/// The range of component `d` is `[0, 256]`.
+	fn clean_defunct_voters(v: u32, _d: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1149 + v * (811 ±0)`
+		//  Estimated: `4621 + v * (3774 ±0)`
+		// Minimum execution time: 18_774_231_000 picoseconds.
+		Weight::from_parts(18_933_040_000, 4621)
+			// Standard Error: 301_534
+			.saturating_add(Weight::from_parts(44_306_903, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(v.into())))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(v.into())))
+			.saturating_add(Weight::from_parts(0, 3774).saturating_mul(v.into()))
+	}
+	/// Storage: Elections Candidates (r:1 w:1)
+	/// Proof Skipped: Elections Candidates (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:1)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections RunnersUp (r:1 w:1)
+	/// Proof Skipped: Elections RunnersUp (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Elections Voting (r:513 w:0)
+	/// Proof Skipped: Elections Voting (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Council Proposals (r:1 w:0)
+	/// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: System Account (r:44 w:44)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Elections ElectionRounds (r:1 w:1)
+	/// Proof Skipped: Elections ElectionRounds (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Members (r:0 w:1)
+	/// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Council Prime (r:0 w:1)
+	/// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `c` is `[1, 64]`.
+	/// The range of component `v` is `[1, 512]`.
+	/// The range of component `e` is `[512, 8192]`.
+	fn election_phragmen(c: u32, v: u32, e: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + e * (28 ±0) + v * (606 ±0)`
+		//  Estimated: `178887 + c * (2135 ±7) + e * (12 ±0) + v * (2653 ±6)`
+		// Minimum execution time: 1_281_877_000 picoseconds.
+		Weight::from_parts(1_288_147_000, 178887)
+			// Standard Error: 528_851
+			.saturating_add(Weight::from_parts(17_761_407, 0).saturating_mul(v.into()))
+			// Standard Error: 33_932
+			.saturating_add(Weight::from_parts(698_277, 0).saturating_mul(e.into()))
+			.saturating_add(RocksDbWeight::get().reads(21_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(c.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(v.into())))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(c.into())))
+			.saturating_add(Weight::from_parts(0, 2135).saturating_mul(c.into()))
+			.saturating_add(Weight::from_parts(0, 12).saturating_mul(e.into()))
+			.saturating_add(Weight::from_parts(0, 2653).saturating_mul(v.into()))
+	}
+}
diff --git a/substrate/frame/examples/Cargo.toml b/substrate/frame/examples/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e636bc67ea89d089bf418624af4d311bc004959d
--- /dev/null
+++ b/substrate/frame/examples/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "pallet-examples"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "The single package with various examples for frame pallets"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+pallet-example-basic = { default-features = false, path = "./basic" }
+pallet-default-config-example = { default-features = false, path = "./default-config" }
+pallet-example-offchain-worker = { default-features = false, path = "./offchain-worker" }
+pallet-example-kitchensink = { default-features = false, path = "./kitchensink" }
+pallet-dev-mode = { default-features = false, path = "./dev-mode" }
+pallet-example-split = { default-features = false, path = "./split" }
+
+[features]
+default = [ "std" ]
+std = [
+	"pallet-default-config-example/std",
+	"pallet-dev-mode/std",
+	"pallet-example-basic/std",
+	"pallet-example-kitchensink/std",
+	"pallet-example-offchain-worker/std",
+	"pallet-example-split/std",
+]
+try-runtime = [
+	"pallet-default-config-example/try-runtime",
+	"pallet-dev-mode/try-runtime",
+	"pallet-example-basic/try-runtime",
+	"pallet-example-kitchensink/try-runtime",
+	"pallet-example-offchain-worker/try-runtime",
+	"pallet-example-split/try-runtime",
+]
diff --git a/substrate/frame/examples/basic/Cargo.toml b/substrate/frame/examples/basic/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..667afb23c83e1ffd9a555d22b853fdcb83b2ba37
--- /dev/null
+++ b/substrate/frame/examples/basic/Cargo.toml
@@ -0,0 +1,57 @@
+[package]
+name = "pallet-example-basic"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME example pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../balances" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/examples/basic/README.md b/substrate/frame/examples/basic/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2af50573f8075cffe03e8509cc5740ea3ebb6a0f
--- /dev/null
+++ b/substrate/frame/examples/basic/README.md
@@ -0,0 +1,240 @@
+<!-- markdown-link-check-disable -->
+# Basic Example Pallet
+
+<!-- Original author of paragraph: @gavofyork -->
+The Example: A simple example of a FRAME pallet demonstrating
+concepts, APIs and structures common to most FRAME runtimes.
+
+Run `cargo doc --package pallet-example-basic --open` to view this pallet's documentation.
+
+**This pallet serves as an example and is not meant to be used in production.**
+
+### Documentation Guidelines:
+
+<!-- Original author of paragraph: Various. Based on collation of review comments to PRs addressing issues with -->
+<!-- label 'S3-FRAME' in https://github.com/paritytech/substrate-developer-hub/issues -->
+<ul>
+    <li>Documentation comments (i.e. <code>/// comment</code>) - should
+        accompany pallet functions and be restricted to the pallet interface,
+        not the internals of the pallet implementation. Only state inputs,
+        outputs, and a brief description that mentions whether calling it
+        requires root, but without repeating the source code details.
+        Capitalize the first word of each documentation comment and end it with
+        a full stop. See
+        <a href="https://github.com/paritytech/substrate#72-contributing-to-documentation-for-substrate-packages"
+        target="_blank"> Generic example of annotating source code with documentation comments</a></li>
+    <li>Self-documenting code - Try to refactor code to be self-documenting.</li>
+    <li>Code comments - Supplement complex code with a brief explanation, not every line of code.</li>
+    <li>Identifiers - surround by backticks (i.e. <code>INHERENT_IDENTIFIER</code>, <code>InherentType</code>,
+        <code>u64</code>)</li>
+    <li>Usage scenarios - should be simple doctests. The compiler should ensure they stay valid.</li>
+    <li>Extended tutorials - should be moved to external files and refer to.</li>
+    <!-- Original author of paragraph: @AmarRSingh -->
+    <li>Mandatory - include all of the sections/subsections where <b>MUST</b> is specified.</li>
+    <li>Optional - optionally include sections/subsections where <b>CAN</b> is specified.</li>
+</ul>
+
+### Documentation Template:<br>
+
+Copy and paste this template from frame/examples/basic/src/lib.rs into file
+`frame/<INSERT_CUSTOM_PALLET_NAME>/src/lib.rs` of your own custom pallet and complete it.
+<details><p><pre>
+// Add heading with custom pallet name
+
+\# <INSERT_CUSTOM_PALLET_NAME> Pallet
+
+// Add simple description
+
+// Include the following links that shows what trait needs to be implemented to use the pallet
+// and the supported dispatchables that are documented in the Call enum.
+
+- \[`<INSERT_CUSTOM_PALLET_NAME>::Config`](https://docs.rs/pallet-example-basic/latest/pallet_example_basic/trait.Config.html)
+- \[`Call`](https://docs.rs/pallet-example-basic/latest/pallet_example_basic/enum.Call.html)
+- \[`Module`](https://docs.rs/pallet-example-basic/latest/pallet_example_basic/struct.Module.html)
+
+\## Overview
+
+<!-- Original author of paragraph: Various. See https://github.com/paritytech/substrate-developer-hub/issues/44 -->
+// Short description of pallet's purpose.
+// Links to Traits that should be implemented.
+// What this pallet is for.
+// What functionality the pallet provides.
+// When to use the pallet (use case examples).
+// How it is used.
+// Inputs it uses and the source of each input.
+// Outputs it produces.
+
+<!-- Original author of paragraph: @Kianenigma in PR https://github.com/paritytech/substrate/pull/1951 -->
+<!-- and comment https://github.com/paritytech/substrate-developer-hub/issues/44#issuecomment-471982710 -->
+
+\## Terminology
+
+// Add terminology used in the custom pallet. Include concepts, storage items, or actions that you think
+// deserve to be noted to give context to the rest of the documentation or pallet usage. The author needs to
+// use some judgment about what is included. We don't want a list of every storage item nor types - the user
+// can go to the code for that. For example, "transfer fee" is obvious and should not be included, but
+// "free balance" and "reserved balance" should be noted to give context to the pallet.
+// Please do not link to outside resources. The reference docs should be the ultimate source of truth.
+
+<!-- Original author of heading: @Kianenigma in PR https://github.com/paritytech/substrate/pull/1951 -->
+
+\## Goals
+
+// Add goals that the custom pallet is designed to achieve.
+
+<!-- Original author of heading: @Kianenigma in PR https://github.com/paritytech/substrate/pull/1951 -->
+
+\### Scenarios
+
+<!-- Original author of paragraph: @Kianenigma. Based on PR https://github.com/paritytech/substrate/pull/1951 -->
+
+\#### <INSERT_SCENARIO_NAME>
+
+// Describe requirements prior to interacting with the custom pallet.
+// Describe the process of interacting with the custom pallet for this scenario and public API functions used.
+
+\## Interface
+
+\### Supported Origins
+
+// What origins are used and supported in this pallet (root, signed, none)
+// i.e. root when <code>\`ensure_root\`</code> used
+// i.e. none when <code>\`ensure_none\`</code> used
+// i.e. signed when <code>\`ensure_signed\`</code> used
+
+<code>\`inherent\`</code> <INSERT_DESCRIPTION>
+
+<!-- Original author of paragraph: @Kianenigma in comment -->
+<!-- https://github.com/paritytech/substrate-developer-hub/issues/44#issuecomment-471982710 -->
+
+\### Types
+
+// Type aliases. Include any associated types and where the user would typically define them.
+
+<code>\`ExampleType\`</code> <INSERT_DESCRIPTION>
+
+<!-- Original author of paragraph: ??? -->
+
+// Reference documentation of aspects such as `storageItems` and `dispatchable` functions should only be
+// included in the https://docs.rs Rustdocs for Substrate and not repeated in the README file.
+
+\### Dispatchable Functions
+
+<!-- Original author of paragraph: @AmarRSingh & @joepetrowski -->
+
+// A brief description of dispatchable functions and a link to the rustdoc with their actual documentation.
+
+// <b>MUST</b> have link to Call enum
+// <b>MUST</b> have origin information included in function doc
+// <b>CAN</b> have more info up to the user
+
+\### Public Functions
+
+<!-- Original author of paragraph: @joepetrowski -->
+
+// A link to the rustdoc and any notes about usage in the pallet, not for specific functions.
+// For example, in the Balances Pallet: "Note that when using the publicly exposed functions,
+// you (the runtime developer) are responsible for implementing any necessary checks
+// (e.g. that the sender is the signer) before calling a function that will affect storage."
+
+<!-- Original author of paragraph: @AmarRSingh -->
+
+// It is up to the writer of the respective pallet (with respect to how much information to provide).
+
+\#### Public Inspection functions - Immutable (getters)
+
+// Insert a subheading for each getter function signature
+
+\##### <code>\`example_getter_name()\`</code>
+
+// What it returns
+// Why, when, and how often to call it
+// When it could panic or error
+// When safety issues to consider
+
+\#### Public Mutable functions (changing state)
+
+// Insert a subheading for each setter function signature
+
+\##### <code>\`example_setter_name(origin, parameter_name: T::ExampleType)\`</code>
+
+// What state it changes
+// Why, when, and how often to call it
+// When it could panic or error
+// When safety issues to consider
+// What parameter values are valid and why
+
+\### Storage Items
+
+// Explain any storage items included in this pallet
+
+\### Digest Items
+
+// Explain any digest items included in this pallet
+
+\### Inherent Data
+
+// Explain what inherent data (if any) is defined in the pallet and any other related types
+
+\### Events:
+
+// Insert events for this pallet if any
+
+\### Errors:
+
+// Explain what generates errors
+
+\## Usage
+
+// Insert 2-3 examples of usage and code snippets that show how to
+// use <INSERT_CUSTOM_PALLET_NAME> Pallet in a custom pallet.
+
+\### Prerequisites
+
+// Show how to include necessary imports for <INSERT_CUSTOM_PALLET_NAME> and derive
+// your pallet configuration trait with the `INSERT_CUSTOM_PALLET_NAME` trait.
+
+\```rust
+use <INSERT_CUSTOM_PALLET_NAME>;
+
+pub trait Config: <INSERT_CUSTOM_PALLET_NAME>::Config { }
+\```
+
+\### Simple Code Snippet
+
+// Show a simple example (e.g. how to query a public getter function of <INSERT_CUSTOM_PALLET_NAME>)
+
+\### Example from FRAME
+
+// Show a usage example in an actual runtime
+
+// See:
+// - Substrate TCR https://github.com/parity-samples/substrate-tcr
+// - Substrate Kitties https://shawntabrizi.github.io/substrate-collectables-workshop/#/
+
+\## Genesis Config
+
+<!-- Original author of paragraph: @joepetrowski -->
+
+\## Dependencies
+
+// Dependencies on other FRAME pallets and the genesis config should be mentioned,
+// but not the Rust Standard Library.
+// Genesis configuration modifications that may be made to incorporate this pallet
+// Interaction with other pallets
+
+<!-- Original author of heading: @AmarRSingh -->
+
+\## Related Pallets
+
+// Interaction with other pallets in the form of a bullet point list
+
+\## References
+
+<!-- Original author of paragraph: @joepetrowski -->
+
+// Links to reference material, if applicable. For example, Phragmen, W3F research, etc.
+// that the implementation is based on.
+</pre></p></details>
+
+License: MIT-0
diff --git a/substrate/frame/examples/basic/src/benchmarking.rs b/substrate/frame/examples/basic/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b2ebb41fbda1d6d8a0d12a65b32391510f1a488
--- /dev/null
+++ b/substrate/frame/examples/basic/src/benchmarking.rs
@@ -0,0 +1,118 @@
+// 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.
+
+//! Benchmarking for `pallet-example-basic`.
+
+// Only enable this module for benchmarking.
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::*;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+// To actually run this benchmark on pallet-example-basic, we need to put this pallet into the
+//   runtime and compile it with `runtime-benchmarks` feature. The detail procedures are
+//   documented at:
+//   https://docs.substrate.io/reference/how-to-guides/weights/add-benchmarks/
+//
+// The auto-generated weight estimate of this pallet is copied over to the `weights.rs` file.
+// The exact command of how the estimate generated is printed at the top of the file.
+
+// Details on using the benchmarks macro can be seen at:
+//   https://paritytech.github.io/substrate/master/frame_benchmarking/trait.Benchmarking.html#tymethod.benchmarks
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	// This will measure the execution time of `set_dummy`.
+	#[benchmark]
+	fn set_dummy_benchmark() {
+		// This is the benchmark setup phase.
+		// `set_dummy` is a constant time function, hence we hard-code some random value here.
+		let value = 1000u32.into();
+		#[extrinsic_call]
+		set_dummy(RawOrigin::Root, value); // The execution phase is just running `set_dummy` extrinsic call
+
+		// This is the optional benchmark verification phase, asserting certain states.
+		assert_eq!(Pallet::<T>::dummy(), Some(value))
+	}
+
+	// An example method that returns a Result that can be called within a benchmark
+	fn example_result_method() -> Result<(), BenchmarkError> {
+		Ok(())
+	}
+
+	// This will measure the execution time of `accumulate_dummy`.
+	// The benchmark execution phase is shorthanded. When the name of the benchmark case is the same
+	// as the extrinsic call. `_(...)` is used to represent the extrinsic name.
+	// The benchmark verification phase is omitted.
+	#[benchmark]
+	fn accumulate_dummy() -> Result<(), BenchmarkError> {
+		let value = 1000u32.into();
+		// The caller account is whitelisted for DB reads/write by the benchmarking macro.
+		let caller: T::AccountId = whitelisted_caller();
+
+		// an example of calling something result-based within a benchmark using the ? operator
+		// this necessitates specifying the `Result<(), BenchmarkError>` return type
+		example_result_method()?;
+
+		// You can use `_` if the name of the Call matches the benchmark name.
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), value);
+
+		// need this to be compatible with the return type
+		Ok(())
+	}
+
+	/// You can write helper functions in here since its a normal Rust module.
+	fn setup_vector(len: u32) -> Vec<u32> {
+		let mut vector = Vec::<u32>::new();
+		for i in (0..len).rev() {
+			vector.push(i);
+		}
+		vector
+	}
+
+	// This will measure the execution time of sorting a vector.
+	//
+	// Define `x` as a linear component with range `[0, =10_000]`. This means that the benchmarking
+	// will assume that the weight grows at a linear rate depending on `x`.
+	#[benchmark]
+	fn sort_vector(x: Linear<0, 10_000>) {
+		let mut vector = setup_vector(x);
+
+		// The benchmark execution phase could also be a closure with custom code:
+		#[block]
+		{
+			vector.sort();
+		}
+
+		// Check that it was sorted correctly. This will not be benchmarked and is just for
+		// verification.
+		vector.windows(2).for_each(|w| assert!(w[0] <= w[1]));
+	}
+
+	// This line generates test cases for benchmarking, and could be run by:
+	//   `cargo test -p pallet-example-basic --all-features`, you will see one line per case:
+	//   `test benchmarking::bench_sort_vector ... ok`
+	//   `test benchmarking::bench_accumulate_dummy ... ok`
+	//   `test benchmarking::bench_set_dummy_benchmark ... ok` in the result.
+	//
+	// The line generates three steps per benchmark, with repeat=1 and the three steps are
+	//   [low, mid, high] of the range.
+	impl_benchmark_test_suite!(Pallet, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/examples/basic/src/lib.rs b/substrate/frame/examples/basic/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..426e9b7ec648c25dda54b27b498cbdd1d92b51d6
--- /dev/null
+++ b/substrate/frame/examples/basic/src/lib.rs
@@ -0,0 +1,759 @@
+// 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.
+
+//! <!-- markdown-link-check-disable -->
+//! # Basic Example Pallet
+//!
+//! <!-- Original author of paragraph: @gavofyork -->
+//! The Example: A simple example of a FRAME pallet demonstrating
+//! concepts, APIs and structures common to most FRAME runtimes.
+//!
+//! Run `cargo doc --package pallet-example-basic --open` to view this pallet's documentation.
+//!
+//! **This pallet serves as an example and is not meant to be used in production.**
+//!
+//! ### Documentation Guidelines:
+//!
+//! <!-- Original author of paragraph: Various. Based on collation of review comments to PRs
+//! addressing issues with --> <!-- label 'S3-FRAME' in https://github.com/paritytech/substrate-developer-hub/issues -->
+//! <ul>
+//! <li>Documentation comments (i.e. <code>/// comment</code>) - should
+//! accompany pallet functions and be restricted to the pallet interface,
+//! not the internals of the pallet implementation. Only state inputs,
+//! outputs, and a brief description that mentions whether calling it
+//! requires root, but without repeating the source code details.
+//! Capitalize the first word of each documentation comment and end it with
+//! a full stop. See
+//! <a href="https://github.com/paritytech/substrate#72-contributing-to-documentation-for-substrate-packages"
+//! target="_blank"> Generic example of annotating source code with documentation comments</a></li>
+//!
+//! <li>Self-documenting code - Try to refactor code to be self-documenting.</li>
+//!
+//! <li>Code comments - Supplement complex code with a brief explanation, not every line of
+//! code.</li>
+//!
+//! <li>Identifiers - surround by backticks (i.e. <code>INHERENT_IDENTIFIER</code>,
+//! <code>InherentType</code>, <code>u64</code>)</li>
+//!
+//! <li>Usage scenarios - should be simple doctests. The compiler should ensure they stay
+//! valid.</li>
+//!
+//! <li>Extended tutorials - should be moved to external files and refer to.</li>
+//!
+//! <li>Mandatory - include all of the sections/subsections where <b>MUST</b> is specified.</li>
+//!
+//! <li>Optional - optionally include sections/subsections where <b>CAN</b> is specified.</li>
+//! </ul>
+//!
+//! ### Documentation Template:<br>
+//!
+//! Copy and paste this template from frame/examples/basic/src/lib.rs into file
+//! `frame/<INSERT_CUSTOM_PALLET_NAME>/src/lib.rs` of your own custom pallet and complete it.
+//! <details><p><pre>
+//! // Add heading with custom pallet name
+//!
+//! \# <INSERT_CUSTOM_PALLET_NAME> Pallet
+//!
+//! // Add simple description
+//!
+//! // Include the following links that shows what trait needs to be implemented to use the pallet
+//! // and the supported dispatchables that are documented in the Call enum.
+//!
+//! - \[`Config`]
+//! - \[`Call`]
+//! - \[`Pallet`]
+//!
+//! \## Overview
+//!
+//! <!-- Original author of paragraph: Various. See https://github.com/paritytech/substrate-developer-hub/issues/44 -->
+//! // Short description of pallet's purpose.
+//! // Links to Traits that should be implemented.
+//! // What this pallet is for.
+//! // What functionality the pallet provides.
+//! // When to use the pallet (use case examples).
+//! // How it is used.
+//! // Inputs it uses and the source of each input.
+//! // Outputs it produces.
+//!
+//! <!-- Original author of paragraph: @Kianenigma in PR https://github.com/paritytech/substrate/pull/1951 -->
+//! <!-- and comment https://github.com/paritytech/substrate-developer-hub/issues/44#issuecomment-471982710 -->
+//!
+//! \## Terminology
+//!
+//! // Add terminology used in the custom pallet. Include concepts, storage items, or actions that
+//! you think // deserve to be noted to give context to the rest of the documentation or pallet
+//! usage. The author needs to // use some judgment about what is included. We don't want a list of
+//! every storage item nor types - the user // can go to the code for that. For example, "transfer
+//! fee" is obvious and should not be included, but // "free balance" and "reserved balance" should
+//! be noted to give context to the pallet. // Please do not link to outside resources. The
+//! reference docs should be the ultimate source of truth.
+//!
+//! <!-- Original author of heading: @Kianenigma in PR https://github.com/paritytech/substrate/pull/1951 -->
+//!
+//! \## Goals
+//!
+//! // Add goals that the custom pallet is designed to achieve.
+//!
+//! <!-- Original author of heading: @Kianenigma in PR https://github.com/paritytech/substrate/pull/1951 -->
+//!
+//! \### Scenarios
+//!
+//! <!-- Original author of paragraph: @Kianenigma. Based on PR https://github.com/paritytech/substrate/pull/1951 -->
+//!
+//! \#### <INSERT_SCENARIO_NAME>
+//!
+//! // Describe requirements prior to interacting with the custom pallet.
+//! // Describe the process of interacting with the custom pallet for this scenario and public API
+//! functions used.
+//!
+//! \## Interface
+//!
+//! \### Supported Origins
+//!
+//! // What origins are used and supported in this pallet (root, signed, none)
+//! // i.e. root when <code>\`ensure_root\`</code> used
+//! // i.e. none when <code>\`ensure_none\`</code> used
+//! // i.e. signed when <code>\`ensure_signed\`</code> used
+//!
+//! <code>\`inherent\`</code> <INSERT_DESCRIPTION>
+//!
+//! <!-- Original author of paragraph: @Kianenigma in comment -->
+//! <!-- https://github.com/paritytech/substrate-developer-hub/issues/44#issuecomment-471982710 -->
+//!
+//! \### Types
+//!
+//! // Type aliases. Include any associated types and where the user would typically define them.
+//!
+//! <code>\`ExampleType\`</code> <INSERT_DESCRIPTION>
+//!
+//! <!-- Original author of paragraph: ??? -->
+//!
+//! // Reference documentation of aspects such as `storageItems` and `dispatchable` functions should
+//! // only be included in the <https://docs.rs> Rustdocs for Substrate and not repeated in the
+//! // README file.
+//!
+//! \### Dispatchable Functions
+//!
+//! <!-- Original author of paragraph: @AmarRSingh & @joepetrowski -->
+//!
+//! // A brief description of dispatchable functions and a link to the rustdoc with their actual
+//! documentation.
+//!
+//! // <b>MUST</b> have link to Call enum
+//! // <b>MUST</b> have origin information included in function doc
+//! // <b>CAN</b> have more info up to the user
+//!
+//! \### Public Functions
+//!
+//! <!-- Original author of paragraph: @joepetrowski -->
+//!
+//! // A link to the rustdoc and any notes about usage in the pallet, not for specific functions.
+//! // For example, in the Balances Pallet: "Note that when using the publicly exposed functions,
+//! // you (the runtime developer) are responsible for implementing any necessary checks
+//! // (e.g. that the sender is the signer) before calling a function that will affect storage."
+//!
+//! <!-- Original author of paragraph: @AmarRSingh -->
+//!
+//! // It is up to the writer of the respective pallet (with respect to how much information to
+//! provide).
+//!
+//! \#### Public Inspection functions - Immutable (getters)
+//!
+//! // Insert a subheading for each getter function signature
+//!
+//! \##### <code>\`example_getter_name()\`</code>
+//!
+//! // What it returns
+//! // Why, when, and how often to call it
+//! // When it could panic or error
+//! // When safety issues to consider
+//!
+//! \#### Public Mutable functions (changing state)
+//!
+//! // Insert a subheading for each setter function signature
+//!
+//! \##### <code>\`example_setter_name(origin, parameter_name: T::ExampleType)\`</code>
+//!
+//! // What state it changes
+//! // Why, when, and how often to call it
+//! // When it could panic or error
+//! // When safety issues to consider
+//! // What parameter values are valid and why
+//!
+//! \### Storage Items
+//!
+//! // Explain any storage items included in this pallet
+//!
+//! \### Digest Items
+//!
+//! // Explain any digest items included in this pallet
+//!
+//! \### Inherent Data
+//!
+//! // Explain what inherent data (if any) is defined in the pallet and any other related types
+//!
+//! \### Events:
+//!
+//! // Insert events for this pallet if any
+//!
+//! \### Errors:
+//!
+//! // Explain what generates errors
+//!
+//! \## Usage
+//!
+//! // Insert 2-3 examples of usage and code snippets that show how to
+//! // use <INSERT_CUSTOM_PALLET_NAME> Pallet in a custom pallet.
+//!
+//! \### Prerequisites
+//!
+//! // Show how to include necessary imports for <INSERT_CUSTOM_PALLET_NAME> and derive
+//! // your pallet configuration trait with the `INSERT_CUSTOM_PALLET_NAME` trait.
+//!
+//! \```rust
+//! use <INSERT_CUSTOM_PALLET_NAME>;
+//!
+//! pub trait Config: <INSERT_CUSTOM_PALLET_NAME>::Config { }
+//! \```
+//!
+//! \### Simple Code Snippet
+//!
+//! // Show a simple example (e.g. how to query a public getter function of
+//! <INSERT_CUSTOM_PALLET_NAME>)
+//!
+//! \### Example from FRAME
+//!
+//! // Show a usage example in an actual runtime
+//!
+//! // See:
+//! // - Substrate TCR <https://github.com/parity-samples/substrate-tcr>
+//! // - Substrate Kitties <https://shawntabrizi.github.io/substrate-collectables-workshop/#/>
+//!
+//! \## Genesis Config
+//!
+//! <!-- Original author of paragraph: @joepetrowski -->
+//!
+//! \## Dependencies
+//!
+//! // Dependencies on other FRAME pallets and the genesis config should be mentioned,
+//! // but not the Rust Standard Library.
+//! // Genesis configuration modifications that may be made to incorporate this pallet
+//! // Interaction with other pallets
+//!
+//! <!-- Original author of heading: @AmarRSingh -->
+//!
+//! \## Related Pallets
+//!
+//! // Interaction with other pallets in the form of a bullet point list
+//!
+//! \## References
+//!
+//! <!-- Original author of paragraph: @joepetrowski -->
+//!
+//! // Links to reference material, if applicable. For example, Phragmen, W3F research, etc.
+//! // that the implementation is based on.
+//! </pre></p></details>
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{ClassifyDispatch, DispatchClass, DispatchResult, Pays, PaysFee, WeighData},
+	traits::IsSubType,
+	weights::Weight,
+};
+use frame_system::ensure_signed;
+use log::info;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Bounded, DispatchInfoOf, SaturatedConversion, Saturating, SignedExtension},
+	transaction_validity::{
+		InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+	},
+};
+use sp_std::{marker::PhantomData, prelude::*};
+
+// Re-export pallet items so that they can be accessed from the crate namespace.
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+mod benchmarking;
+pub mod weights;
+pub use weights::*;
+
+/// A type alias for the balance type from this pallet's point of view.
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+const MILLICENTS: u32 = 1_000_000_000;
+
+// A custom weight calculator tailored for the dispatch call `set_dummy()`. This actually examines
+// the arguments and makes a decision based upon them.
+//
+// The `WeightData<T>` trait has access to the arguments of the dispatch that it wants to assign a
+// weight to. Nonetheless, the trait itself cannot make any assumptions about what the generic type
+// of the arguments (`T`) is. Based on our needs, we could replace `T` with a more concrete type
+// while implementing the trait. The `pallet::weight` expects whatever implements `WeighData<T>` to
+// replace `T` with a tuple of the dispatch arguments. This is exactly how we will craft the
+// implementation below.
+//
+// The rules of `WeightForSetDummy` are as follows:
+// - The final weight of each dispatch is calculated as the argument of the call multiplied by the
+//   parameter given to the `WeightForSetDummy`'s constructor.
+// - assigns a dispatch class `operational` if the argument of the call is more than 1000.
+//
+// More information can be read at:
+//   - https://docs.substrate.io/main-docs/build/tx-weights-fees/
+//
+// Manually configuring weight is an advanced operation and what you really need may well be
+//   fulfilled by running the benchmarking toolchain. Refer to `benchmarking.rs` file.
+struct WeightForSetDummy<T: pallet_balances::Config>(BalanceOf<T>);
+
+impl<T: pallet_balances::Config> WeighData<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+	fn weigh_data(&self, target: (&BalanceOf<T>,)) -> Weight {
+		let multiplier = self.0;
+		// *target.0 is the amount passed into the extrinsic
+		let cents = *target.0 / <BalanceOf<T>>::from(MILLICENTS);
+		Weight::from_parts((cents * multiplier).saturated_into::<u64>(), 0)
+	}
+}
+
+impl<T: pallet_balances::Config> ClassifyDispatch<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+	fn classify_dispatch(&self, target: (&BalanceOf<T>,)) -> DispatchClass {
+		if *target.0 > <BalanceOf<T>>::from(1000u32) {
+			DispatchClass::Operational
+		} else {
+			DispatchClass::Normal
+		}
+	}
+}
+
+impl<T: pallet_balances::Config> PaysFee<(&BalanceOf<T>,)> for WeightForSetDummy<T> {
+	fn pays_fee(&self, _target: (&BalanceOf<T>,)) -> Pays {
+		Pays::Yes
+	}
+}
+
+// Definition of the pallet logic, to be aggregated at runtime definition through
+// `construct_runtime`.
+#[frame_support::pallet]
+pub mod pallet {
+	// Import various types used to declare pallet in scope.
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// Our pallet's configuration trait. All our types and constants go in here. If the
+	/// pallet is dependent on specific other pallets, then their configuration traits
+	/// should be added to our implied traits list.
+	///
+	/// `frame_system::Config` should always be included.
+	#[pallet::config]
+	pub trait Config: pallet_balances::Config + frame_system::Config {
+		// Setting a constant config parameter from the runtime
+		#[pallet::constant]
+		type MagicNumber: Get<Self::Balance>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Type representing the weight of this pallet
+		type WeightInfo: WeightInfo;
+	}
+
+	// Simple declaration of the `Pallet` type. It is placeholder we use to implement traits and
+	// method.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	// Pallet implements [`Hooks`] trait to define some logic to execute in some context.
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		// `on_initialize` is executed at the beginning of the block before any extrinsic are
+		// dispatched.
+		//
+		// This function must return the weight consumed by `on_initialize` and `on_finalize`.
+		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+			// Anything that needs to be done at the start of the block.
+			// We don't do anything here.
+			Weight::zero()
+		}
+
+		// `on_finalize` is executed at the end of block after all extrinsic are dispatched.
+		fn on_finalize(_n: BlockNumberFor<T>) {
+			// Perform necessary data/state clean up here.
+		}
+
+		// A runtime code run after every block and have access to extended set of APIs.
+		//
+		// For instance you can generate extrinsics for the upcoming produced block.
+		fn offchain_worker(_n: BlockNumberFor<T>) {
+			// We don't do anything here.
+			// but we could dispatch extrinsic (transaction/unsigned/inherent) using
+			// sp_io::submit_extrinsic.
+			// To see example on offchain worker, please refer to example-offchain-worker pallet
+			// accompanied in this repository.
+		}
+	}
+
+	// The call declaration. This states the entry points that we handle. The
+	// macro takes care of the marshalling of arguments and dispatch.
+	//
+	// Anyone can have these functions execute by signing and submitting
+	// an extrinsic. Ensure that calls into each of these execute in a time, memory and
+	// using storage space proportional to any costs paid for by the caller or otherwise the
+	// difficulty of forcing the call to happen.
+	//
+	// Generally you'll want to split these into three groups:
+	// - Public calls that are signed by an external account.
+	// - Root calls that are allowed to be made only by the governance system.
+	// - Unsigned calls that can be of two kinds:
+	//   * "Inherent extrinsics" that are opinions generally held by the block authors that build
+	//     child blocks.
+	//   * Unsigned Transactions that are of intrinsic recognizable utility to the network, and are
+	//     validated by the runtime.
+	//
+	// Information about where this dispatch initiated from is provided as the first argument
+	// "origin". As such functions must always look like:
+	//
+	// `fn foo(origin: OriginFor<T>, bar: Bar, baz: Baz) -> DispatchResultWithPostInfo { ... }`
+	//
+	// The `DispatchResultWithPostInfo` is required as part of the syntax (and can be found at
+	// `pallet_prelude::DispatchResultWithPostInfo`).
+	//
+	// There are three entries in the `frame_system::Origin` enum that correspond
+	// to the above bullets: `::Signed(AccountId)`, `::Root` and `::None`. You should always match
+	// against them as the first thing you do in your function. There are three convenience calls
+	// in system that do the matching for you and return a convenient result: `ensure_signed`,
+	// `ensure_root` and `ensure_none`.
+	#[pallet::call(weight(<T as Config>::WeightInfo))]
+	impl<T: Config> Pallet<T> {
+		/// This is your public interface. Be extremely careful.
+		/// This is just a simple example of how to interact with the pallet from the external
+		/// world.
+		// This just increases the value of `Dummy` by `increase_by`.
+		//
+		// Since this is a dispatched function there are two extremely important things to
+		// remember:
+		//
+		// - MUST NOT PANIC: Under no circumstances (save, perhaps, storage getting into an
+		// irreparably damaged state) must this function panic.
+		// - NO SIDE-EFFECTS ON ERROR: This function must either complete totally (and return
+		// `Ok(())` or it must have no side-effects on storage and return `Err('Some reason')`.
+		//
+		// The first is relatively easy to audit for - just ensure all panickers are removed from
+		// logic that executes in production (which you do anyway, right?!). To ensure the second
+		// is followed, you should do all tests for validity at the top of your function. This
+		// is stuff like checking the sender (`origin`) or that state is such that the operation
+		// makes sense.
+		//
+		// Once you've determined that it's all good, then enact the operation and change storage.
+		// If you can't be certain that the operation will succeed without substantial computation
+		// then you have a classic blockchain attack scenario. The normal way of managing this is
+		// to attach a bond to the operation. As the first major alteration of storage, reserve
+		// some value from the sender's account (`Balances` Pallet has a `reserve` function for
+		// exactly this scenario). This amount should be enough to cover any costs of the
+		// substantial execution in case it turns out that you can't proceed with the operation.
+		//
+		// If it eventually transpires that the operation is fine and, therefore, that the
+		// expense of the checks should be borne by the network, then you can refund the reserved
+		// deposit. If, however, the operation turns out to be invalid and the computation is
+		// wasted, then you can burn it or repatriate elsewhere.
+		//
+		// Security bonds ensure that attackers can't game it by ensuring that anyone interacting
+		// with the system either progresses it or pays for the trouble of faffing around with
+		// no progress.
+		//
+		// If you don't respect these rules, it is likely that your chain will be attackable.
+		//
+		// Each transaction must define a `#[pallet::weight(..)]` attribute to convey a set of
+		// static information about its dispatch. FRAME System and FRAME Executive pallet then use
+		// this information to properly execute the transaction, whilst keeping the total load of
+		// the chain in a moderate rate.
+		//
+		// The parenthesized value of the `#[pallet::weight(..)]` attribute can be any type that
+		// implements a set of traits, namely [`WeighData`], [`ClassifyDispatch`], and
+		// [`PaysFee`]. The first conveys the weight (a numeric representation of pure
+		// execution time and difficulty) of the transaction and the second demonstrates the
+		// [`DispatchClass`] of the call, the third gives whereas extrinsic must pay fees or not.
+		// A higher weight means a larger transaction (less of which can be placed in a single
+		// block).
+		//
+		// The weight for this extrinsic we rely on the auto-generated `WeightInfo` from the
+		// benchmark toolchain.
+		#[pallet::call_index(0)]
+		pub fn accumulate_dummy(origin: OriginFor<T>, increase_by: T::Balance) -> DispatchResult {
+			// This is a public call, so we ensure that the origin is some signed account.
+			let _sender = ensure_signed(origin)?;
+
+			// Read the value of dummy from storage.
+			// let dummy = Self::dummy();
+			// Will also work using the `::get` on the storage item type itself:
+			// let dummy = <Dummy<T>>::get();
+
+			// Calculate the new value.
+			// let new_dummy = dummy.map_or(increase_by, |dummy| dummy + increase_by);
+
+			// Put the new value into storage.
+			// <Dummy<T>>::put(new_dummy);
+			// Will also work with a reference:
+			// <Dummy<T>>::put(&new_dummy);
+
+			// Here's the new one of read and then modify the value.
+			<Dummy<T>>::mutate(|dummy| {
+				// Using `saturating_add` instead of a regular `+` to avoid overflowing
+				let new_dummy = dummy.map_or(increase_by, |d| d.saturating_add(increase_by));
+				*dummy = Some(new_dummy);
+			});
+
+			// Let's deposit an event to let the outside world know this happened.
+			Self::deposit_event(Event::AccumulateDummy { balance: increase_by });
+
+			// All good, no refund.
+			Ok(())
+		}
+
+		/// A privileged call; in this case it resets our dummy value to something new.
+		// Implementation of a privileged call. The `origin` parameter is ROOT because
+		// it's not (directly) from an extrinsic, but rather the system as a whole has decided
+		// to execute it. Different runtimes have different reasons for allow privileged
+		// calls to be executed - we don't need to care why. Because it's privileged, we can
+		// assume it's a one-off operation and substantial processing/storage/memory can be used
+		// without worrying about gameability or attack scenarios.
+		//
+		// The weight for this extrinsic we use our own weight object `WeightForSetDummy` to
+		// determine its weight
+		#[pallet::call_index(1)]
+		#[pallet::weight(WeightForSetDummy::<T>(<BalanceOf<T>>::from(100u32)))]
+		pub fn set_dummy(
+			origin: OriginFor<T>,
+			#[pallet::compact] new_value: T::Balance,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			// Print out log or debug message in the console via log::{error, warn, info, debug,
+			// trace}, accepting format strings similar to `println!`.
+			// https://paritytech.github.io/substrate/master/sp_io/logging/fn.log.html
+			// https://paritytech.github.io/substrate/master/frame_support/constant.LOG_TARGET.html
+			info!("New value is now: {:?}", new_value);
+
+			// Put the new value into storage.
+			<Dummy<T>>::put(new_value);
+
+			Self::deposit_event(Event::SetDummy { balance: new_value });
+
+			// All good, no refund.
+			Ok(())
+		}
+	}
+
+	/// Events are a simple means of reporting specific conditions and
+	/// circumstances that have happened that users, Dapps and/or chain explorers would find
+	/// interesting and otherwise difficult to detect.
+	#[pallet::event]
+	/// This attribute generate the function `deposit_event` to deposit one of this pallet event,
+	/// it is optional, it is also possible to provide a custom implementation.
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		// Just a normal `enum`, here's a dummy event to ensure it compiles.
+		/// Dummy event, just here so there's a generic type that's used.
+		AccumulateDummy {
+			balance: BalanceOf<T>,
+		},
+		SetDummy {
+			balance: BalanceOf<T>,
+		},
+		SetBar {
+			account: T::AccountId,
+			balance: BalanceOf<T>,
+		},
+	}
+
+	// pallet::storage attributes allow for type-safe usage of the Substrate storage database,
+	// so you can keep things around between blocks.
+	//
+	// Any storage must be one of `StorageValue`, `StorageMap` or `StorageDoubleMap`.
+	// The first generic holds the prefix to use and is generated by the macro.
+	// The query kind is either `OptionQuery` (the default) or `ValueQuery`.
+	// - for `type Foo<T> = StorageValue<_, u32, OptionQuery>`:
+	//   - `Foo::put(1); Foo::get()` returns `Some(1)`;
+	//   - `Foo::kill(); Foo::get()` returns `None`.
+	// - for `type Foo<T> = StorageValue<_, u32, ValueQuery>`:
+	//   - `Foo::put(1); Foo::get()` returns `1`;
+	//   - `Foo::kill(); Foo::get()` returns `0` (u32::default()).
+	#[pallet::storage]
+	// The getter attribute generate a function on `Pallet` placeholder:
+	// `fn getter_name() -> Type` for basic value items or
+	// `fn getter_name(key: KeyType) -> ValueType` for map items.
+	#[pallet::getter(fn dummy)]
+	pub(super) type Dummy<T: Config> = StorageValue<_, T::Balance>;
+
+	// A map that has enumerable entries.
+	#[pallet::storage]
+	#[pallet::getter(fn bar)]
+	pub(super) type Bar<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, T::Balance>;
+
+	// this one uses the query kind: `ValueQuery`, we'll demonstrate the usage of 'mutate' API.
+	#[pallet::storage]
+	#[pallet::getter(fn foo)]
+	pub(super) type Foo<T: Config> = StorageValue<_, T::Balance, ValueQuery>;
+
+	#[pallet::storage]
+	pub type CountedMap<T> = CountedStorageMap<_, Blake2_128Concat, u8, u16>;
+
+	// The genesis config type.
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub dummy: T::Balance,
+		pub bar: Vec<(T::AccountId, T::Balance)>,
+		pub foo: T::Balance,
+	}
+
+	// The build of genesis for the pallet.
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			<Dummy<T>>::put(&self.dummy);
+			for (a, b) in &self.bar {
+				<Bar<T>>::insert(a, b);
+			}
+			<Foo<T>>::put(&self.foo);
+		}
+	}
+}
+
+// The main implementation block for the pallet. Functions here fall into three broad
+// categories:
+// - Public interface. These are functions that are `pub` and generally fall into inspector
+// functions that do not write to storage and operation functions that do.
+// - Private functions. These are your usual private utilities unavailable to other pallets.
+impl<T: Config> Pallet<T> {
+	// Add public immutables and private mutables.
+	#[allow(dead_code)]
+	fn accumulate_foo(origin: T::RuntimeOrigin, increase_by: T::Balance) -> DispatchResult {
+		let _sender = ensure_signed(origin)?;
+
+		let prev = <Foo<T>>::get();
+		// Because Foo has 'default', the type of 'foo' in closure is the raw type instead of an
+		// Option<> type.
+		let result = <Foo<T>>::mutate(|foo| {
+			*foo = foo.saturating_add(increase_by);
+			*foo
+		});
+		assert!(prev + increase_by == result);
+
+		Ok(())
+	}
+}
+
+// Similar to other FRAME pallets, your pallet can also define a signed extension and perform some
+// checks and [pre/post]processing [before/after] the transaction. A signed extension can be any
+// decodable type that implements `SignedExtension`. See the trait definition for the full list of
+// bounds. As a convention, you can follow this approach to create an extension for your pallet:
+//   - If the extension does not carry any data, then use a tuple struct with just a `marker`
+//     (needed for the compiler to accept `T: Config`) will suffice.
+//   - Otherwise, create a tuple struct which contains the external data. Of course, for the entire
+//     struct to be decodable, each individual item also needs to be decodable.
+//
+// Note that a signed extension can also indicate that a particular data must be present in the
+// _signing payload_ of a transaction by providing an implementation for the `additional_signed`
+// method. This example will not cover this type of extension. See `CheckSpecVersion` in
+// [FRAME System](https://github.com/paritytech/substrate/tree/master/frame/system#signed-extensions)
+// for an example.
+//
+// Using the extension, you can add some hooks to the life cycle of each transaction. Note that by
+// default, an extension is applied to all `Call` functions (i.e. all transactions). the `Call` enum
+// variant is given to each function of `SignedExtension`. Hence, you can filter based on pallet or
+// a particular call if needed.
+//
+// Some extra information, such as encoded length, some static dispatch info like weight and the
+// sender of the transaction (if signed) are also provided.
+//
+// The full list of hooks that can be added to a signed extension can be found
+// [here](https://crates.parity.io/sp_runtime/traits/trait.SignedExtension.html).
+//
+// The signed extensions are aggregated in the runtime file of a substrate chain. All extensions
+// should be aggregated in a tuple and passed to the `CheckedExtrinsic` and `UncheckedExtrinsic`
+// types defined in the runtime. Lookup `pub type SignedExtra = (...)` in `node/runtime` and
+// `node-template` for an example of this.
+
+/// A simple signed extension that checks for the `set_dummy` call. In that case, it increases the
+/// priority and prints some log.
+///
+/// Additionally, it drops any transaction with an encoded length higher than 200 bytes. No
+/// particular reason why, just to demonstrate the power of signed extensions.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct WatchDummy<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for WatchDummy<T> {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "WatchDummy")
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for WatchDummy<T>
+where
+	<T as frame_system::Config>::RuntimeCall: IsSubType<Call<T>>,
+{
+	const IDENTIFIER: &'static str = "WatchDummy";
+	type AccountId = T::AccountId;
+	type Call = <T as frame_system::Config>::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	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(|_| ())
+	}
+
+	fn validate(
+		&self,
+		_who: &Self::AccountId,
+		call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		// if the transaction is too big, just drop it.
+		if len > 200 {
+			return InvalidTransaction::ExhaustsResources.into()
+		}
+
+		// check for `set_dummy`
+		match call.is_sub_type() {
+			Some(Call::set_dummy { .. }) => {
+				sp_runtime::print("set_dummy was received.");
+
+				let valid_tx =
+					ValidTransaction { priority: Bounded::max_value(), ..Default::default() };
+				Ok(valid_tx)
+			},
+			_ => Ok(Default::default()),
+		}
+	}
+}
diff --git a/substrate/frame/examples/basic/src/tests.rs b/substrate/frame/examples/basic/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..addf219dc3c3938b41ab831cc42669a0f3af52bf
--- /dev/null
+++ b/substrate/frame/examples/basic/src/tests.rs
@@ -0,0 +1,197 @@
+// 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-example-basic.
+
+use crate::*;
+use frame_support::{
+	assert_ok,
+	dispatch::{DispatchInfo, GetDispatchInfo},
+	traits::{ConstU64, OnInitialize},
+};
+use sp_core::H256;
+// 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 sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+// Reexport crate as its pallet name for construct_runtime.
+use crate as pallet_example_basic;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// For testing the pallet, we construct a mock runtime.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Example: pallet_example_basic::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+);
+
+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 = 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 = frame_support::traits::ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+impl Config for Test {
+	type MagicNumber = ConstU64<1_000_000_000>;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+}
+
+// This function basically just builds a genesis storage key/value store according to
+// our desired mockup.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig {
+		// We use default for brevity, but you can configure as desired if needed.
+		system: Default::default(),
+		balances: Default::default(),
+		example: pallet_example_basic::GenesisConfig {
+			dummy: 42,
+			// we configure the map with (key, value) pairs.
+			bar: vec![(1, 2), (2, 3)],
+			foo: 24,
+		},
+	}
+	.build_storage()
+	.unwrap();
+	t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+	new_test_ext().execute_with(|| {
+		// Check that GenesisBuilder works properly.
+		let val1 = 42;
+		let val2 = 27;
+		assert_eq!(Example::dummy(), Some(val1));
+
+		// Check that accumulate works when we have Some value in Dummy already.
+		assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val2));
+		assert_eq!(Example::dummy(), Some(val1 + val2));
+
+		// Check that accumulate works when we Dummy has None in it.
+		<Example as OnInitialize<u64>>::on_initialize(2);
+		assert_ok!(Example::accumulate_dummy(RuntimeOrigin::signed(1), val1));
+		assert_eq!(Example::dummy(), Some(val1 + val2 + val1));
+	});
+}
+
+#[test]
+fn it_works_for_default_value() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Example::foo(), 24);
+		assert_ok!(Example::accumulate_foo(RuntimeOrigin::signed(1), 1));
+		assert_eq!(Example::foo(), 25);
+	});
+}
+
+#[test]
+fn set_dummy_works() {
+	new_test_ext().execute_with(|| {
+		let test_val = 133;
+		assert_ok!(Example::set_dummy(RuntimeOrigin::root(), test_val.into()));
+		assert_eq!(Example::dummy(), Some(test_val));
+	});
+}
+
+#[test]
+fn signed_ext_watch_dummy_works() {
+	new_test_ext().execute_with(|| {
+		let call = pallet_example_basic::Call::set_dummy { new_value: 10 }.into();
+		let info = DispatchInfo::default();
+
+		assert_eq!(
+			WatchDummy::<Test>(PhantomData)
+				.validate(&1, &call, &info, 150)
+				.unwrap()
+				.priority,
+			u64::MAX,
+		);
+		assert_eq!(
+			WatchDummy::<Test>(PhantomData).validate(&1, &call, &info, 250),
+			InvalidTransaction::ExhaustsResources.into(),
+		);
+	})
+}
+
+#[test]
+fn counted_map_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(CountedMap::<Test>::count(), 0);
+		CountedMap::<Test>::insert(3, 3);
+		assert_eq!(CountedMap::<Test>::count(), 1);
+	})
+}
+
+#[test]
+fn weights_work() {
+	// must have a defined weight.
+	let default_call = pallet_example_basic::Call::<Test>::accumulate_dummy { increase_by: 10 };
+	let info1 = default_call.get_dispatch_info();
+	// aka. `let info = <Call<Test> as GetDispatchInfo>::get_dispatch_info(&default_call);`
+	// TODO: account for proof size weight
+	assert!(info1.weight.ref_time() > 0);
+	assert_eq!(info1.weight, <Test as Config>::WeightInfo::accumulate_dummy());
+
+	// `set_dummy` is simpler than `accumulate_dummy`, and the weight
+	//   should be less.
+	let custom_call = pallet_example_basic::Call::<Test>::set_dummy { new_value: 20 };
+	let info2 = custom_call.get_dispatch_info();
+	// TODO: account for proof size weight
+	assert!(info1.weight.ref_time() > info2.weight.ref_time());
+}
diff --git a/substrate/frame/examples/basic/src/weights.rs b/substrate/frame/examples/basic/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..def944054cce8a8b5230781385fd2427e8949603
--- /dev/null
+++ b/substrate/frame/examples/basic/src/weights.rs
@@ -0,0 +1,95 @@
+// 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.
+
+//! Autogenerated weights for pallet_example_basic
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-10-09, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! HOSTNAME: `Shawns-MacBook-Pro.local`, CPU: `<UNKNOWN>`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/release/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --execution=wasm
+// --wasm-execution=compiled
+// --pallet=pallet_example_basic
+// --extrinsic=*
+// --steps=50
+// --repeat=20
+// --output=./
+// --template
+// ./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_example_basic.
+pub trait WeightInfo {
+	fn set_dummy_benchmark() -> Weight;
+	fn accumulate_dummy() -> Weight;
+	fn sort_vector(x: u32, ) -> Weight;
+}
+
+/// Weights for pallet_example_basic using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: BasicExample Dummy (r:0 w:1)
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000 as u64, 0)
+			.saturating_add(T::DbWeight::get().writes(1 as u64))
+	}
+	// Storage: BasicExample Dummy (r:1 w:1)
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000 as u64, 0)
+			.saturating_add(T::DbWeight::get().reads(1 as u64))
+			.saturating_add(T::DbWeight::get().writes(1 as u64))
+	}
+	/// The range of component `x` is `[0, 10000]`.
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0 as u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520 as u64, 0).saturating_mul(x as u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	// Storage: BasicExample Dummy (r:0 w:1)
+	fn set_dummy_benchmark() -> Weight {
+		Weight::from_parts(19_000_000 as u64, 0)
+			.saturating_add(RocksDbWeight::get().writes(1 as u64))
+	}
+	// Storage: BasicExample Dummy (r:1 w:1)
+	fn accumulate_dummy() -> Weight {
+		Weight::from_parts(18_000_000 as u64, 0)
+			.saturating_add(RocksDbWeight::get().reads(1 as u64))
+			.saturating_add(RocksDbWeight::get().writes(1 as u64))
+	}
+	/// The range of component `x` is `[0, 10000]`.
+	fn sort_vector(x: u32, ) -> Weight {
+		Weight::from_parts(0 as u64, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(520 as u64, 0).saturating_mul(x as u64))
+	}
+}
diff --git a/substrate/frame/examples/default-config/Cargo.toml b/substrate/frame/examples/default-config/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fbb14730fe7efc542be909c056fa95509ebd51fb
--- /dev/null
+++ b/substrate/frame/examples/default-config/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "pallet-default-config-example"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME example pallet demonstrating derive_impl / default_config in action"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { default-features = false, path = "../../support" }
+frame-system = { default-features = false, path = "../../system" }
+
+sp-io = { default-features = false, path = "../../../primitives/io" }
+sp-runtime = { default-features = false, path = "../../../primitives/runtime" }
+sp-std = { default-features = false, path = "../../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/examples/default-config/README.md b/substrate/frame/examples/default-config/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b1a67a5c16e550ae9988c68e22d1ad1a44657f74
--- /dev/null
+++ b/substrate/frame/examples/default-config/README.md
@@ -0,0 +1,8 @@
+# Default Config Example Pallet
+
+An example pallet demonstrating the ability to derive default testing configs via
+`#[derive_impl]` and `#[pallet::config(with_default)]`.
+
+Run `cargo doc --package pallet-default-config-example --open` to view this pallet's documentation.
+
+License: MIT-0
diff --git a/substrate/frame/examples/default-config/src/lib.rs b/substrate/frame/examples/default-config/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d2eade0ccff1eeab28ada5b4af9ed3b810d0bcb8
--- /dev/null
+++ b/substrate/frame/examples/default-config/src/lib.rs
@@ -0,0 +1,229 @@
+// 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.
+
+//! # Default Config Pallet Example
+//!
+//! A simple example of a FRAME pallet that utilizes [`frame_support::derive_impl`] to demonstrate
+//! the simpler way to implement `Config` trait of pallets. This example only showcases this in a
+//! `mock.rs` environment, but the same applies to a real runtime as well.
+//!
+//! See the source code of [`tests`] for a real examples.
+//!
+//! Study the following types:
+//!
+//! - [`pallet::DefaultConfig`], and how it differs from [`pallet::Config`].
+//! - [`pallet::config_preludes::TestDefaultConfig`] and how it implements
+//!   [`pallet::DefaultConfig`].
+//! - Notice how [`pallet::DefaultConfig`] is independent of [`frame_system::Config`].
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	/// This pallet is annotated to have a default config. This will auto-generate
+	/// [`DefaultConfig`].
+	///
+	/// It will be an identical, but won't have anything that is `#[pallet::no_default]`.
+	#[pallet::config(with_default)]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type. This is coming from the runtime, and cannot have a default.
+		/// In general, `Runtime*`-oriented types cannot have a sensible default.
+		#[pallet::no_default] // optional. `RuntimeEvent` is automatically excluded as well.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// An input parameter to this pallet. This value can have a default, because it is not
+		/// reliant on `frame_system::Config` or the overarching runtime in any way.
+		type WithDefaultValue: Get<u32>;
+
+		/// Same as [`Config::WithDefaultValue`], but we don't intend to define a default for this
+		/// in our tests below.
+		type OverwrittenDefaultValue: Get<u32>;
+
+		/// An input parameter that relies on `<Self as frame_system::Config>::AccountId`. This can
+		/// too have a default, as long as as it is present in `frame_system::DefaultConfig`.
+		type CanDeriveDefaultFromSystem: Get<Self::AccountId>;
+
+		/// We might chose to declare as one that doesn't have a default, for whatever semantical
+		/// reason.
+		#[pallet::no_default]
+		type HasNoDefault: Get<u32>;
+
+		/// Some types can technically have no default, such as those the rely on
+		/// `frame_system::Config` but are not present in `frame_system::DefaultConfig`. For
+		/// example, a `RuntimeCall` cannot reasonably have a default.
+		#[pallet::no_default] // if we skip this, there will be a compiler error.
+		type CannotHaveDefault: Get<Self::RuntimeCall>;
+
+		/// Something that is a normal type, with default.
+		type WithDefaultType;
+
+		/// Same as [`Config::WithDefaultType`], but we don't intend to define a default for this
+		/// in our tests below.
+		type OverwrittenDefaultType;
+	}
+
+	/// Container for different types that implement [`DefaultConfig`]` of this pallet.
+	pub mod config_preludes {
+		// This will help use not need to disambiguate anything when using `derive_impl`.
+		use super::*;
+		use frame_support::derive_impl;
+
+		/// A type providing default configurations for this pallet in testing environment.
+		pub struct TestDefaultConfig;
+
+		#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig, no_aggregated_types)]
+		impl frame_system::DefaultConfig for TestDefaultConfig {}
+
+		#[frame_support::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			type WithDefaultValue = frame_support::traits::ConstU32<42>;
+			type OverwrittenDefaultValue = frame_support::traits::ConstU32<42>;
+
+			// `frame_system::config_preludes::TestDefaultConfig` declares account-id as u64.
+			type CanDeriveDefaultFromSystem = frame_support::traits::ConstU64<42>;
+
+			type WithDefaultType = u32;
+			type OverwrittenDefaultType = u32;
+		}
+
+		/// A type providing default configurations for this pallet in another environment. Examples
+		/// could be a parachain, or a solo-chain.
+		///
+		/// Appropriate derive for `frame_system::DefaultConfig` needs to be provided. In this
+		/// example, we simple derive `frame_system::config_preludes::TestDefaultConfig` again.
+		pub struct OtherDefaultConfig;
+
+		#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig, no_aggregated_types)]
+		impl frame_system::DefaultConfig for OtherDefaultConfig {}
+
+		#[frame_support::register_default_impl(OtherDefaultConfig)]
+		impl DefaultConfig for OtherDefaultConfig {
+			type WithDefaultValue = frame_support::traits::ConstU32<66>;
+			type OverwrittenDefaultValue = frame_support::traits::ConstU32<66>;
+			type CanDeriveDefaultFromSystem = frame_support::traits::ConstU64<42>;
+			type WithDefaultType = u32;
+			type OverwrittenDefaultType = u32;
+		}
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	pub enum Event<T: Config> {}
+}
+
+#[cfg(any(test, doc))]
+pub mod tests {
+	use super::*;
+	use frame_support::{derive_impl, parameter_types};
+	use pallet::{self as pallet_default_config_example, config_preludes::*};
+
+	type Block = frame_system::mocking::MockBlock<Runtime>;
+
+	frame_support::construct_runtime!(
+		pub struct Runtime {
+			System: frame_system,
+			DefaultPallet: pallet_default_config_example,
+		}
+	);
+
+	#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+	impl frame_system::Config for Runtime {
+		// these items are defined by frame-system as `no_default`, so we must specify them here.
+		type Block = Block;
+
+		// all of this is coming from `frame_system::config_preludes::TestDefaultConfig`.
+
+		// type Nonce = u32;
+		// type BlockNumber = u32;
+		// type Hash = sp_core::hash::H256;
+		// type Hashing = sp_runtime::traits::BlakeTwo256;
+		// type AccountId = u64;
+		// type Lookup = sp_runtime::traits::IdentityLookup<u64>;
+		// type BlockHashCount = frame_support::traits::ConstU32<10>;
+		// type MaxConsumers = frame_support::traits::ConstU32<16>;
+		// type AccountData = ();
+		// type OnNewAccount = ();
+		// type OnKilledAccount = ();
+		// type SystemWeightInfo = ();
+		// type SS58Prefix = ();
+		// type Version = ();
+		// type BlockWeights = ();
+		// type BlockLength = ();
+		// type DbWeight = ();
+		// type BaseCallFilter = frame_support::traits::Everything;
+		// type BlockHashCount = frame_support::traits::ConstU64<10>;
+		// type OnSetCode = ();
+
+		// These are marked as `#[inject_runtime_type]`. Hence, they are being injected as
+		// types generated by `construct_runtime`.
+
+		// type RuntimeOrigin = RuntimeOrigin;
+		// type RuntimeCall = RuntimeCall;
+		// type RuntimeEvent = RuntimeEvent;
+		// type PalletInfo = PalletInfo;
+
+		// you could still overwrite any of them if desired.
+		type SS58Prefix = frame_support::traits::ConstU16<456>;
+	}
+
+	parameter_types! {
+		pub const SomeCall: RuntimeCall = RuntimeCall::System(frame_system::Call::<Runtime>::remark { remark: vec![] });
+	}
+
+	#[derive_impl(TestDefaultConfig as pallet::DefaultConfig)]
+	impl pallet_default_config_example::Config for Runtime {
+		// These two both cannot have defaults.
+		type RuntimeEvent = RuntimeEvent;
+
+		type HasNoDefault = frame_support::traits::ConstU32<1>;
+		type CannotHaveDefault = SomeCall;
+
+		type OverwrittenDefaultValue = frame_support::traits::ConstU32<678>;
+		type OverwrittenDefaultType = u128;
+	}
+
+	#[test]
+	fn it_works() {
+		use frame_support::traits::Get;
+		use pallet::{Config, DefaultConfig};
+
+		// assert one of the value types that is not overwritten.
+		assert_eq!(
+			<<Runtime as Config>::WithDefaultValue as Get<u32>>::get(),
+			<<TestDefaultConfig as DefaultConfig>::WithDefaultValue as Get<u32>>::get()
+		);
+
+		// assert one of the value types that is overwritten.
+		assert_eq!(<<Runtime as Config>::OverwrittenDefaultValue as Get<u32>>::get(), 678u32);
+
+		// assert one of the types that is not overwritten.
+		assert_eq!(
+			std::any::TypeId::of::<<Runtime as Config>::WithDefaultType>(),
+			std::any::TypeId::of::<<TestDefaultConfig as DefaultConfig>::WithDefaultType>()
+		);
+
+		// assert one of the types that is overwritten.
+		assert_eq!(
+			std::any::TypeId::of::<<Runtime as Config>::OverwrittenDefaultType>(),
+			std::any::TypeId::of::<u128>()
+		)
+	}
+}
diff --git a/substrate/frame/examples/dev-mode/Cargo.toml b/substrate/frame/examples/dev-mode/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1dda112bf0864bb8be47b022f2f219d15f47c100
--- /dev/null
+++ b/substrate/frame/examples/dev-mode/Cargo.toml
@@ -0,0 +1,48 @@
+[package]
+name = "pallet-dev-mode"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME example pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../balances" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/examples/dev-mode/README.md b/substrate/frame/examples/dev-mode/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4c9ee88629c232de8d6058eeafac8dbd70443988
--- /dev/null
+++ b/substrate/frame/examples/dev-mode/README.md
@@ -0,0 +1,11 @@
+<!-- markdown-link-check-disable -->
+# Dev Mode Example Pallet
+
+A simple example of a FRAME pallet demonstrating
+the ease of requirements for a pallet in dev mode.
+
+Run `cargo doc --package pallet-dev-mode --open` to view this pallet's documentation.
+
+**Dev mode is not meant to be used in production.**
+
+License: MIT-0
diff --git a/substrate/frame/examples/dev-mode/src/lib.rs b/substrate/frame/examples/dev-mode/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d57e7a5b76b82f92425596b69f2f495ab0865f1e
--- /dev/null
+++ b/substrate/frame/examples/dev-mode/src/lib.rs
@@ -0,0 +1,118 @@
+// 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.
+
+//! <!-- markdown-link-check-disable -->
+//! # Dev Mode Example Pallet
+//!
+//! A simple example of a FRAME pallet demonstrating
+//! the ease of requirements for a pallet in dev mode.
+//!
+//! Run `cargo doc --package pallet-dev-mode --open` to view this pallet's documentation.
+//!
+//! **Dev mode is not meant to be used in production.**
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::dispatch::DispatchResult;
+use frame_system::ensure_signed;
+
+// Re-export pallet items so that they can be accessed from the crate namespace.
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+/// A type alias for the balance type from this pallet's point of view.
+type BalanceOf<T> = <T as pallet_balances::Config>::Balance;
+
+/// Enable `dev_mode` for this pallet.
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: pallet_balances::Config + frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	// Simple declaration of the `Pallet` type. It is placeholder we use to implement traits and
+	// method.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		// No need to define a `call_index` attribute here because of `dev_mode`.
+		// No need to define a `weight` attribute here because of `dev_mode`.
+		pub fn add_dummy(origin: OriginFor<T>, id: T::AccountId) -> DispatchResult {
+			ensure_root(origin)?;
+
+			if let Some(mut dummies) = Dummy::<T>::get() {
+				dummies.push(id.clone());
+				Dummy::<T>::set(Some(dummies));
+			} else {
+				Dummy::<T>::set(Some(vec![id.clone()]));
+			}
+
+			// Let's deposit an event to let the outside world know this happened.
+			Self::deposit_event(Event::AddDummy { account: id });
+
+			Ok(())
+		}
+
+		// No need to define a `call_index` attribute here because of `dev_mode`.
+		// No need to define a `weight` attribute here because of `dev_mode`.
+		pub fn set_bar(
+			origin: OriginFor<T>,
+			#[pallet::compact] new_value: T::Balance,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			// Put the new value into storage.
+			<Bar<T>>::insert(&sender, new_value);
+
+			Self::deposit_event(Event::SetBar { account: sender, balance: new_value });
+
+			Ok(())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		AddDummy { account: T::AccountId },
+		SetBar { account: T::AccountId, balance: BalanceOf<T> },
+	}
+
+	/// The MEL requirement for bounded pallets is skipped by `dev_mode`.
+	/// This means that all storages are marked as unbounded.
+	/// This is equivalent to specifying `#[pallet::unbounded]` on this type definitions.
+	/// When the dev_mode is removed, we would need to implement implement `MaxEncodedLen`.
+	#[pallet::storage]
+	pub type Dummy<T: Config> = StorageValue<_, Vec<T::AccountId>>;
+
+	/// The Hasher requirement is skipped by `dev_mode`. So, second parameter can be `_`
+	/// and `Blake2_128Concat` is used as a default.
+	/// When the dev_mode is removed, we would need to specify the hasher like so:
+	/// `pub type Bar<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, T::Balance>;`.
+	#[pallet::storage]
+	pub type Bar<T: Config> = StorageMap<_, _, T::AccountId, T::Balance>;
+}
diff --git a/substrate/frame/examples/dev-mode/src/tests.rs b/substrate/frame/examples/dev-mode/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ba98f5174ce2049a31372c8d7ee03eba044556fc
--- /dev/null
+++ b/substrate/frame/examples/dev-mode/src/tests.rs
@@ -0,0 +1,124 @@
+// 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-dev-mode.
+
+use crate::*;
+use frame_support::{assert_ok, traits::ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+// Reexport crate as its pallet name for construct_runtime.
+use crate as pallet_dev_mode;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// For testing the pallet, we construct a mock runtime.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Example: pallet_dev_mode::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+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 = 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 = frame_support::traits::ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+// This function basically just builds a genesis storage key/value store according to
+// our desired mockup.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig {
+		// We use default for brevity, but you can configure as desired if needed.
+		system: Default::default(),
+		balances: Default::default(),
+	}
+	.build_storage()
+	.unwrap();
+	t.into()
+}
+
+#[test]
+fn it_works_for_optional_value() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Dummy::<Test>::get(), None);
+
+		let val1 = 42;
+		assert_ok!(Example::add_dummy(RuntimeOrigin::root(), val1));
+		assert_eq!(Dummy::<Test>::get(), Some(vec![val1]));
+
+		// Check that accumulate works when we have Some value in Dummy already.
+		let val2 = 27;
+		assert_ok!(Example::add_dummy(RuntimeOrigin::root(), val2));
+		assert_eq!(Dummy::<Test>::get(), Some(vec![val1, val2]));
+	});
+}
+
+#[test]
+fn set_dummy_works() {
+	new_test_ext().execute_with(|| {
+		let test_val = 133;
+		assert_ok!(Example::set_bar(RuntimeOrigin::signed(1), test_val.into()));
+		assert_eq!(Bar::<Test>::get(1), Some(test_val));
+	});
+}
diff --git a/substrate/frame/examples/kitchensink/Cargo.toml b/substrate/frame/examples/kitchensink/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..942260115719dab79d3677f25629f4ca4fb11fa1
--- /dev/null
+++ b/substrate/frame/examples/kitchensink/Cargo.toml
@@ -0,0 +1,60 @@
+[package]
+name = "pallet-example-kitchensink"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME example kitchensink pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../../benchmarking" }
+
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../balances" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/examples/kitchensink/src/benchmarking.rs b/substrate/frame/examples/kitchensink/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..24da581fc967b8e8c8586bf3b41a4452a89a4dcd
--- /dev/null
+++ b/substrate/frame/examples/kitchensink/src/benchmarking.rs
@@ -0,0 +1,66 @@
+// 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.
+
+//! Benchmarking for `pallet-example-kitchensink`.
+
+// Only enable this module for benchmarking.
+#![cfg(feature = "runtime-benchmarks")]
+use super::*;
+
+#[allow(unused)]
+use crate::Pallet as Kitchensink;
+
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+// To actually run this benchmark on pallet-example-kitchensink, we need to put this pallet into the
+//   runtime and compile it with `runtime-benchmarks` feature. The detail procedures are
+//   documented at:
+//   https://docs.substrate.io/reference/how-to-guides/weights/add-benchmarks/
+//
+// The auto-generated weight estimate of this pallet is copied over to the `weights.rs` file.
+// The exact command of how the estimate generated is printed at the top of the file.
+
+// Details on using the benchmarks macro can be seen at:
+//   https://paritytech.github.io/substrate/master/frame_benchmarking/trait.Benchmarking.html#tymethod.benchmarks
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	// This will measure the execution time of `set_foo`.
+	#[benchmark]
+	fn set_foo_benchmark() {
+		// This is the benchmark setup phase.
+		// `set_foo` is a constant time function, hence we hard-code some random value here.
+		let value = 1000u32.into();
+		#[extrinsic_call]
+		set_foo(RawOrigin::Root, value, 10u128); // The execution phase is just running `set_foo` extrinsic call
+
+		// This is the optional benchmark verification phase, asserting certain states.
+		assert_eq!(Pallet::<T>::foo(), Some(value))
+	}
+
+	// This line generates test cases for benchmarking, and could be run by:
+	//   `cargo test -p pallet-example-kitchensink --all-features`, you will see one line per case:
+	//   `test benchmarking::bench_sort_vector ... ok`
+	//   `test benchmarking::bench_accumulate_dummy ... ok`
+	//   `test benchmarking::bench_set_dummy_benchmark ... ok` in the result.
+	//
+	// The line generates three steps per benchmark, with repeat=1 and the three steps are
+	//   [low, mid, high] of the range.
+	impl_benchmark_test_suite!(Kitchensink, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/examples/kitchensink/src/lib.rs b/substrate/frame/examples/kitchensink/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0fbffc971da6225180b1548b3f87c88b8231ca48
--- /dev/null
+++ b/substrate/frame/examples/kitchensink/src/lib.rs
@@ -0,0 +1,330 @@
+// 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.
+
+//! # Kitchensink Example Pallet
+//!
+//! **This pallet serves as an example and is not meant to be used in production.**
+//!
+//! The kitchen-sink catalog of the the FRAME macros and their various syntax options.
+//!
+//! This example does not focus on pallet instancing, `dev_mode`, and does nto include any 'where'
+//! clauses on `T`. These will both incur additional complexity to the syntax, but are not discussed
+//! here.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+// Re-export pallet items so that they can be accessed from the crate namespace.
+pub use pallet::*;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+pub mod weights;
+pub use weights::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The config trait of the pallet. You can basically do anything with the config trait that you
+	/// can do with a normal rust trait: import items consisting of types, constants and functions.
+	///
+	/// A very common pattern is for a pallet to import implementations of traits such as
+	/// [`frame_support::traits::Currency`], [`frame_support::traits::fungibles::Inspect`] and
+	/// [`frame_support::traits::Get`]. These are all types that the pallet is delegating to the top
+	/// level runtime to provide to it.
+	///
+	/// The `FRAME`-specific syntax are:
+	///
+	/// * the use of `#[pallet::constant]`([`frame_support::procedural`]), which places a `Get`
+	///   implementation in the metadata.
+	/// * `type RuntimeEvent`, which is mandatory if your pallet has events. See TODO.
+	/// * Needless to say, because [`Config`] is bounded by [`frame_system::Config`], you can use
+	///   all the items from [`frame_system::Config`] as well, such as `AccountId`.
+	/// * `#[pallet::disable_frame_system_supertrait_check]` would remove the need for
+	///   `frame_system::Config` to exist, which you should almost never need.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching runtime event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Type representing the weight of this pallet
+		type WeightInfo: WeightInfo;
+
+		/// This is a normal Rust type, nothing specific to FRAME here.
+		type Currency: frame_support::traits::tokens::fungible::Inspect<Self::AccountId>;
+
+		/// Similarly, let the runtime decide this.
+		fn some_function() -> u32;
+
+		/// And this
+		const FOO: u32;
+
+		/// This is a FRAME-specific item. It will be placed in the metadata of the pallet, and
+		/// therefore can be queried by offchain applications.
+		#[pallet::constant]
+		type InMetadata: Get<u32>;
+	}
+
+	/// Allows you to define some extra constants to be added into constant metadata.
+	#[pallet::extra_constants]
+	impl<T: Config> Pallet<T> {
+		#[allow(non_snake_case)]
+		fn SomeValue() -> u32 {
+			unimplemented!()
+		}
+
+		#[pallet::constant_name(OtherValue)]
+		fn arbitrary_name() -> u32 {
+			unimplemented!()
+		}
+	}
+
+	const STORAGE_VERSION: frame_support::traits::StorageVersion = StorageVersion::new(1);
+
+	/// The pallet struct. There's nothing special to FRAME about this; it can implement functions
+	/// in an impl blocks, traits and so on.
+	#[pallet::pallet]
+	#[pallet::without_storage_info]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	/// Allows you to define some origin for the pallet.
+	#[pallet::origin]
+	pub type Origin<T> = frame_system::RawOrigin<<T as frame_system::Config>::AccountId>;
+
+	// first, we showcase all the possible storage types, with most of their details.
+
+	/// A storage value. We mark this as unbounded, alter its prefix, and define a custom storage
+	/// getter for it.
+	///
+	/// The value is stored a single trie node, and therefore can be retrieved with a single
+	/// database access.
+	#[pallet::storage]
+	#[pallet::unbounded] // optional
+	#[pallet::storage_prefix = "OtherFoo"] // optional
+	#[pallet::getter(fn foo)] // optional
+	pub type Foo<T> = StorageValue<Value = u32>;
+
+	#[pallet::type_value]
+	pub fn DefaultForFoo() -> u32 {
+		1
+	}
+
+	#[pallet::storage]
+	pub type FooWithDefault<T> =
+		StorageValue<Value = u32, QueryKind = ValueQuery, OnEmpty = DefaultForFoo>;
+
+	/// A storage map. This creates a mapping from keys of type `u32` to values of type `u32`.
+	///
+	/// Keys and values can be iterated, albeit each value is stored under a unique trie key,
+	/// meaning that an iteration consists of many database accesses.
+	#[pallet::storage]
+	pub type Bar<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
+
+	/// Conceptually same as `StorageMap<>` where the key is a tuple of `(u32, u32)`. On top, it
+	/// provides some functions to iterate or remove items based on only the first key.
+	#[pallet::storage]
+	pub type Qux<T> = StorageDoubleMap<
+		Hasher1 = Blake2_128Concat,
+		Key1 = u32,
+		Hasher2 = Blake2_128Concat,
+		Key2 = u32,
+		Value = u32,
+	>;
+
+	/// Same as `StorageDoubleMap`, but with arbitrary number of keys.
+	#[pallet::storage]
+	pub type Quux<T> = StorageNMap<
+		Key = (
+			NMapKey<Blake2_128Concat, u8>,
+			NMapKey<Blake2_128Concat, u16>,
+			NMapKey<Blake2_128Concat, u32>,
+		),
+		Value = u64,
+	>;
+
+	/// In all of these examples, we chose a syntax where the storage item is defined using the
+	/// explicit generic syntax (`X = Y`). Alternatively:
+	#[pallet::storage]
+	pub type AlternativeSyntax<T> = StorageMap<_, Blake2_128Concat, u32, u32>;
+
+	/// Lastly, all storage items, as you saw, had to be generic over `T`. If they want to use an
+	/// item from `Config`, `<T: Config>` should be used.
+	#[pallet::storage]
+	pub type AlternativeSyntax2<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, u32>;
+
+	/// The genesis config type. This allows the pallet to define how it should initialized upon
+	/// genesis.
+	///
+	/// It can be generic over `T` or not, depending on whether it is or not.
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub foo: u32,
+		pub bar: BlockNumberFor<T>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			Self { foo: 0, bar: Default::default() }
+		}
+	}
+
+	/// Allows you to define how `genesis_configuration is built.
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			Foo::<T>::put(self.foo);
+		}
+	}
+
+	/// The call declaration. This states the entry points that we handle. The
+	/// macro takes care of the marshalling of arguments and dispatch.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::set_foo_benchmark())]
+		pub fn set_foo(
+			_: OriginFor<T>,
+			new_foo: u32,
+			#[pallet::compact] _other_compact: u128,
+		) -> DispatchResult {
+			Foo::<T>::set(Some(new_foo));
+
+			Ok(())
+		}
+	}
+
+	/// The event type. This exactly like a normal Rust enum.
+	///
+	/// It can or cannot be generic over `<T: Config>`. Note that unlike a normal enum, if none of
+	/// the variants actually use `<T: Config>`, the macro will generate a hidden `PhantomData`
+	/// variant.
+	///
+	/// The `generate_deposit` macro generates a function on `Pallet` called `deposit_event` which
+	/// will properly convert the error type of your pallet into `RuntimeEvent` (recall `type
+	/// RuntimeEvent: From<Event<Self>>`, so it can be converted) and deposit it via
+	/// `frame_system::Pallet::deposit_event`.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A simple tuple style variant.
+		SomethingHappened(u32),
+		/// A simple struct-style variant. Note that we use `AccountId` from `T` because `T:
+		/// Config`, which by extension implies `T: frame_system::Config`.
+		SomethingDetailedHappened { at: u32, to: T::AccountId },
+		/// Another variant.
+		SomeoneJoined(T::AccountId),
+	}
+
+	/// The error enum. Must always be generic over `<T>`, which is expanded to `<T: Config>`.
+	#[pallet::error]
+	pub enum Error<T> {
+		SomethingWentWrong,
+		SomethingBroke,
+	}
+
+	/// All the possible hooks that a pallet can have. See [`frame_support::traits::Hooks`] for more
+	/// info.
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn integrity_test() {}
+
+		fn offchain_worker(_n: BlockNumberFor<T>) {
+			unimplemented!()
+		}
+
+		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+			unimplemented!()
+		}
+
+		fn on_finalize(_n: BlockNumberFor<T>) {
+			unimplemented!()
+		}
+
+		fn on_idle(_n: BlockNumberFor<T>, _remaining_weight: Weight) -> Weight {
+			unimplemented!()
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			unimplemented!()
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			unimplemented!()
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			unimplemented!()
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_n: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+			unimplemented!()
+		}
+	}
+
+	/// Allows you to define an enum on the pallet which will then instruct
+	/// `construct_runtime` to amalgamate all similarly-named enums from other
+	/// pallets into an aggregate enum.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		Staking,
+	}
+
+	/// Allows the pallet to validate some unsigned transaction. See
+	/// [`sp_runtime::traits::ValidateUnsigned`] for more info.
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+		fn validate_unsigned(_: TransactionSource, _: &Self::Call) -> TransactionValidity {
+			unimplemented!()
+		}
+
+		fn pre_dispatch(_: &Self::Call) -> Result<(), TransactionValidityError> {
+			unimplemented!()
+		}
+	}
+
+	/// Allows the pallet to provide some inherent. See [`frame_support::inherent::ProvideInherent`]
+	/// for more info.
+	#[pallet::inherent]
+	impl<T: Config> ProvideInherent for Pallet<T> {
+		type Call = Call<T>;
+		type Error = MakeFatalError<()>;
+
+		const INHERENT_IDENTIFIER: [u8; 8] = *b"test1234";
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			unimplemented!();
+		}
+
+		fn is_inherent(_call: &Self::Call) -> bool {
+			unimplemented!()
+		}
+	}
+}
diff --git a/substrate/frame/examples/kitchensink/src/tests.rs b/substrate/frame/examples/kitchensink/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b2af7c8983f563e5ab636ab63a9e8da102167d8f
--- /dev/null
+++ b/substrate/frame/examples/kitchensink/src/tests.rs
@@ -0,0 +1,111 @@
+// 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-example-kitchensink.
+
+use crate::*;
+use frame_support::{assert_ok, derive_impl, parameter_types, traits::ConstU64};
+use sp_runtime::BuildStorage;
+// Reexport crate as its pallet name for construct_runtime.
+use crate as pallet_example_kitchensink;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// For testing the pallet, we construct a mock runtime.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Kitchensink: pallet_example_kitchensink::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+);
+
+/// Using a default config for [`frame_system`] in tests. See `default-config` example for more
+/// details.
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+
+	type AccountData = pallet_balances::AccountData<u64>;
+}
+
+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 MaxHolds = ();
+}
+
+parameter_types! {
+	pub const InMetadata: u32 = 30;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+
+	type Currency = Balances;
+	type InMetadata = InMetadata;
+
+	const FOO: u32 = 100;
+
+	fn some_function() -> u32 {
+		5u32
+	}
+}
+
+// This function basically just builds a genesis storage key/value store according to
+// our desired mockup.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig {
+		// We use default for brevity, but you can configure as desired if needed.
+		system: Default::default(),
+		balances: Default::default(),
+		kitchensink: pallet_example_kitchensink::GenesisConfig { bar: 32, foo: 24 },
+	}
+	.build_storage()
+	.unwrap();
+	t.into()
+}
+
+#[test]
+fn set_foo_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Foo::<Test>::get(), Some(24)); // From genesis config.
+
+		let val1 = 42;
+		assert_ok!(Kitchensink::set_foo(RuntimeOrigin::root(), val1, 2));
+		assert_eq!(Foo::<Test>::get(), Some(val1));
+	});
+}
diff --git a/substrate/frame/examples/kitchensink/src/weights.rs b/substrate/frame/examples/kitchensink/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1d083a9b80eeaa69783f8a811f82b998f23f1938
--- /dev/null
+++ b/substrate/frame/examples/kitchensink/src/weights.rs
@@ -0,0 +1,68 @@
+
+//! Autogenerated weights for `pallet_example_kitchensink`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-02, STEPS: `20`, REPEAT: `10`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `MacBook.local`, CPU: `<UNKNOWN>`
+//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/release/node-template
+// benchmark
+// pallet
+// --chain
+// dev
+// --pallet
+// pallet_example_kitchensink
+// --extrinsic
+// *
+// --steps
+// 20
+// --repeat
+// 10
+// --output
+// frame/examples/kitchensink/src/weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_template.
+pub trait WeightInfo {
+	fn set_foo_benchmark() -> Weight;
+}
+
+/// Weight functions for `pallet_example_kitchensink`.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Kitchensink OtherFoo (r:0 w:1)
+	/// Proof Skipped: Kitchensink OtherFoo (max_values: Some(1), max_size: None, mode: Measured)
+	fn set_foo_benchmark() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_000_000 picoseconds.
+		Weight::from_parts(1_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+}
+
+impl WeightInfo for () {
+	/// Storage: Kitchensink OtherFoo (r:0 w:1)
+	/// Proof Skipped: Kitchensink OtherFoo (max_values: Some(1), max_size: None, mode: Measured)
+	fn set_foo_benchmark() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 1_000_000 picoseconds.
+		Weight::from_parts(1_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 0))
+			.saturating_add(RocksDbWeight::get().writes(1))
+	}
+}
diff --git a/substrate/frame/examples/offchain-worker/Cargo.toml b/substrate/frame/examples/offchain-worker/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f3359ee77e11b36457f644d833cab2cf545d5942
--- /dev/null
+++ b/substrate/frame/examples/offchain-worker/Cargo.toml
@@ -0,0 +1,47 @@
+[package]
+name = "pallet-example-offchain-worker"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME example pallet for offchain worker"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+lite-json = { version = "0.2.0", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-keystore = { version = "0.27.0", optional = true, path = "../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"lite-json/std",
+	"log/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-keystore/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/examples/offchain-worker/README.md b/substrate/frame/examples/offchain-worker/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b8905cda3074610be65f184e914ebc7ea4c5c91
--- /dev/null
+++ b/substrate/frame/examples/offchain-worker/README.md
@@ -0,0 +1,29 @@
+<!-- markdown-link-check-disable -->
+# Offchain Worker Example Pallet
+
+The Offchain Worker Example: A simple pallet demonstrating
+concepts, APIs and structures common to most offchain workers.
+
+Run `cargo doc --package pallet-example-offchain-worker --open` to view this module's
+documentation.
+
+- [`pallet_example_offchain_worker::Trait`](./trait.Trait.html)
+- [`Call`](./enum.Call.html)
+- [`Module`](./struct.Module.html)
+
+**This pallet serves as an example showcasing Substrate off-chain worker and is not meant to be
+used in production.**
+
+## Overview
+
+In this example we are going to build a very simplistic, naive and definitely NOT
+production-ready oracle for BTC/USD price.
+Offchain Worker (OCW) will be triggered after every block, fetch the current price
+and prepare either signed or unsigned transaction to feed the result back on chain.
+The on-chain logic will simply aggregate the results and store last `64` values to compute
+the average price.
+Additional logic in OCW is put in place to prevent spamming the network with both signed
+and unsigned transactions, and custom `UnsignedValidator` makes sure that there is only
+one unsigned transaction floating in the network.
+
+License: MIT-0
diff --git a/substrate/frame/examples/offchain-worker/src/lib.rs b/substrate/frame/examples/offchain-worker/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c1fa6ea8ec42dbee21875a0610b3724aadff802
--- /dev/null
+++ b/substrate/frame/examples/offchain-worker/src/lib.rs
@@ -0,0 +1,726 @@
+// 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.
+
+//! <!-- markdown-link-check-disable -->
+//! # Offchain Worker Example Pallet
+//!
+//! The Offchain Worker Example: A simple pallet demonstrating
+//! concepts, APIs and structures common to most offchain workers.
+//!
+//! Run `cargo doc --package pallet-example-offchain-worker --open` to view this module's
+//! documentation.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! **This pallet serves as an example showcasing Substrate off-chain worker and is not meant to
+//! be used in production.**
+//!
+//! ## Overview
+//!
+//! In this example we are going to build a very simplistic, naive and definitely NOT
+//! production-ready oracle for BTC/USD price.
+//! Offchain Worker (OCW) will be triggered after every block, fetch the current price
+//! and prepare either signed or unsigned transaction to feed the result back on chain.
+//! The on-chain logic will simply aggregate the results and store last `64` values to compute
+//! the average price.
+//! Additional logic in OCW is put in place to prevent spamming the network with both signed
+//! and unsigned transactions, and custom `UnsignedValidator` makes sure that there is only
+//! one unsigned transaction floating in the network.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+use frame_support::traits::Get;
+use frame_system::{
+	self as system,
+	offchain::{
+		AppCrypto, CreateSignedTransaction, SendSignedTransaction, SendUnsignedTransaction,
+		SignedPayload, Signer, SigningTypes, SubmitTransaction,
+	},
+	pallet_prelude::BlockNumberFor,
+};
+use lite_json::json::JsonValue;
+use sp_core::crypto::KeyTypeId;
+use sp_runtime::{
+	offchain::{
+		http,
+		storage::{MutateStorageError, StorageRetrievalError, StorageValueRef},
+		Duration,
+	},
+	traits::Zero,
+	transaction_validity::{InvalidTransaction, TransactionValidity, ValidTransaction},
+	RuntimeDebug,
+};
+use sp_std::vec::Vec;
+
+#[cfg(test)]
+mod tests;
+
+/// Defines application identifier for crypto keys of this module.
+///
+/// Every module that deals with signatures needs to declare its unique identifier for
+/// its crypto keys.
+/// When offchain worker is signing transactions it's going to request keys of type
+/// `KeyTypeId` from the keystore and use the ones it finds to sign the transaction.
+/// The keys can be inserted manually via RPC (see `author_insertKey`).
+pub const KEY_TYPE: KeyTypeId = KeyTypeId(*b"btc!");
+
+/// Based on the above `KeyTypeId` we need to generate a pallet-specific crypto type wrappers.
+/// We can use from supported crypto kinds (`sr25519`, `ed25519` and `ecdsa`) and augment
+/// the types with this pallet-specific identifier.
+pub mod crypto {
+	use super::KEY_TYPE;
+	use sp_core::sr25519::Signature as Sr25519Signature;
+	use sp_runtime::{
+		app_crypto::{app_crypto, sr25519},
+		traits::Verify,
+		MultiSignature, MultiSigner,
+	};
+	app_crypto!(sr25519, KEY_TYPE);
+
+	pub struct TestAuthId;
+
+	impl frame_system::offchain::AppCrypto<MultiSigner, MultiSignature> for TestAuthId {
+		type RuntimeAppPublic = Public;
+		type GenericSignature = sp_core::sr25519::Signature;
+		type GenericPublic = sp_core::sr25519::Public;
+	}
+
+	// implemented for mock runtime in test
+	impl frame_system::offchain::AppCrypto<<Sr25519Signature as Verify>::Signer, Sr25519Signature>
+		for TestAuthId
+	{
+		type RuntimeAppPublic = Public;
+		type GenericSignature = sp_core::sr25519::Signature;
+		type GenericPublic = sp_core::sr25519::Public;
+	}
+}
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// This pallet's configuration trait
+	#[pallet::config]
+	pub trait Config: CreateSignedTransaction<Call<Self>> + frame_system::Config {
+		/// The identifier type for an offchain worker.
+		type AuthorityId: AppCrypto<Self::Public, Self::Signature>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		// Configuration parameters
+
+		/// A grace period after we send transaction.
+		///
+		/// To avoid sending too many transactions, we only attempt to send one
+		/// every `GRACE_PERIOD` blocks. We use Local Storage to coordinate
+		/// sending between distinct runs of this offchain worker.
+		#[pallet::constant]
+		type GracePeriod: Get<BlockNumberFor<Self>>;
+
+		/// Number of blocks of cooldown after unsigned transaction is included.
+		///
+		/// This ensures that we only accept unsigned transactions once, every `UnsignedInterval`
+		/// blocks.
+		#[pallet::constant]
+		type UnsignedInterval: Get<BlockNumberFor<Self>>;
+
+		/// A configuration for base priority of unsigned transactions.
+		///
+		/// This is exposed so that it can be tuned for particular runtime, when
+		/// multiple pallets send unsigned transactions.
+		#[pallet::constant]
+		type UnsignedPriority: Get<TransactionPriority>;
+
+		/// Maximum number of prices.
+		#[pallet::constant]
+		type MaxPrices: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// Offchain Worker entry point.
+		///
+		/// By implementing `fn offchain_worker` you declare a new offchain worker.
+		/// This function will be called when the node is fully synced and a new best block is
+		/// successfully imported.
+		/// Note that it's not guaranteed for offchain workers to run on EVERY block, there might
+		/// be cases where some blocks are skipped, or for some the worker runs twice (re-orgs),
+		/// so the code should be able to handle that.
+		/// You can use `Local Storage` API to coordinate runs of the worker.
+		fn offchain_worker(block_number: BlockNumberFor<T>) {
+			// Note that having logs compiled to WASM may cause the size of the blob to increase
+			// significantly. You can use `RuntimeDebug` custom derive to hide details of the types
+			// in WASM. The `sp-api` crate also provides a feature `disable-logging` to disable
+			// all logging and thus, remove any logging from the WASM.
+			log::info!("Hello World from offchain workers!");
+
+			// Since off-chain workers are just part of the runtime code, they have direct access
+			// to the storage and other included pallets.
+			//
+			// We can easily import `frame_system` and retrieve a block hash of the parent block.
+			let parent_hash = <system::Pallet<T>>::block_hash(block_number - 1u32.into());
+			log::debug!("Current block: {:?} (parent hash: {:?})", block_number, parent_hash);
+
+			// It's a good practice to keep `fn offchain_worker()` function minimal, and move most
+			// of the code to separate `impl` block.
+			// Here we call a helper function to calculate current average price.
+			// This function reads storage entries of the current state.
+			let average: Option<u32> = Self::average_price();
+			log::debug!("Current price: {:?}", average);
+
+			// For this example we are going to send both signed and unsigned transactions
+			// depending on the block number.
+			// Usually it's enough to choose one or the other.
+			let should_send = Self::choose_transaction_type(block_number);
+			let res = match should_send {
+				TransactionType::Signed => Self::fetch_price_and_send_signed(),
+				TransactionType::UnsignedForAny =>
+					Self::fetch_price_and_send_unsigned_for_any_account(block_number),
+				TransactionType::UnsignedForAll =>
+					Self::fetch_price_and_send_unsigned_for_all_accounts(block_number),
+				TransactionType::Raw => Self::fetch_price_and_send_raw_unsigned(block_number),
+				TransactionType::None => Ok(()),
+			};
+			if let Err(e) = res {
+				log::error!("Error: {}", e);
+			}
+		}
+	}
+
+	/// A public part of the pallet.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Submit new price to the list.
+		///
+		/// This method is a public function of the module and can be called from within
+		/// a transaction. It appends given `price` to current list of prices.
+		/// In our example the `offchain worker` will create, sign & submit a transaction that
+		/// calls this function passing the price.
+		///
+		/// The transaction needs to be signed (see `ensure_signed`) check, so that the caller
+		/// pays a fee to execute it.
+		/// This makes sure that it's not easy (or rather cheap) to attack the chain by submitting
+		/// excessive transactions, but note that it doesn't ensure the price oracle is actually
+		/// working and receives (and provides) meaningful data.
+		/// This example is not focused on correctness of the oracle itself, but rather its
+		/// purpose is to showcase offchain worker capabilities.
+		#[pallet::call_index(0)]
+		#[pallet::weight({0})]
+		pub fn submit_price(origin: OriginFor<T>, price: u32) -> DispatchResultWithPostInfo {
+			// Retrieve sender of the transaction.
+			let who = ensure_signed(origin)?;
+			// Add the price to the on-chain list.
+			Self::add_price(Some(who), price);
+			Ok(().into())
+		}
+
+		/// Submit new price to the list via unsigned transaction.
+		///
+		/// Works exactly like the `submit_price` function, but since we allow sending the
+		/// transaction without a signature, and hence without paying any fees,
+		/// we need a way to make sure that only some transactions are accepted.
+		/// This function can be called only once every `T::UnsignedInterval` blocks.
+		/// Transactions that call that function are de-duplicated on the pool level
+		/// via `validate_unsigned` implementation and also are rendered invalid if
+		/// the function has already been called in current "session".
+		///
+		/// It's important to specify `weight` for unsigned calls as well, because even though
+		/// they don't charge fees, we still don't want a single block to contain unlimited
+		/// number of such transactions.
+		///
+		/// This example is not focused on correctness of the oracle itself, but rather its
+		/// purpose is to showcase offchain worker capabilities.
+		#[pallet::call_index(1)]
+		#[pallet::weight({0})]
+		pub fn submit_price_unsigned(
+			origin: OriginFor<T>,
+			_block_number: BlockNumberFor<T>,
+			price: u32,
+		) -> DispatchResultWithPostInfo {
+			// This ensures that the function can only be called via unsigned transaction.
+			ensure_none(origin)?;
+			// Add the price to the on-chain list, but mark it as coming from an empty address.
+			Self::add_price(None, price);
+			// now increment the block number at which we expect next unsigned transaction.
+			let current_block = <system::Pallet<T>>::block_number();
+			<NextUnsignedAt<T>>::put(current_block + T::UnsignedInterval::get());
+			Ok(().into())
+		}
+
+		#[pallet::call_index(2)]
+		#[pallet::weight({0})]
+		pub fn submit_price_unsigned_with_signed_payload(
+			origin: OriginFor<T>,
+			price_payload: PricePayload<T::Public, BlockNumberFor<T>>,
+			_signature: T::Signature,
+		) -> DispatchResultWithPostInfo {
+			// This ensures that the function can only be called via unsigned transaction.
+			ensure_none(origin)?;
+			// Add the price to the on-chain list, but mark it as coming from an empty address.
+			Self::add_price(None, price_payload.price);
+			// now increment the block number at which we expect next unsigned transaction.
+			let current_block = <system::Pallet<T>>::block_number();
+			<NextUnsignedAt<T>>::put(current_block + T::UnsignedInterval::get());
+			Ok(().into())
+		}
+	}
+
+	/// Events for the pallet.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Event generated when new price is accepted to contribute to the average.
+		NewPrice { price: u32, maybe_who: Option<T::AccountId> },
+	}
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+
+		/// Validate unsigned call to this module.
+		///
+		/// By default unsigned transactions are disallowed, but implementing the validator
+		/// here we make sure that some particular calls (the ones produced by offchain worker)
+		/// are being whitelisted and marked as valid.
+		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			// Firstly let's check that we call the right function.
+			if let Call::submit_price_unsigned_with_signed_payload {
+				price_payload: ref payload,
+				ref signature,
+			} = call
+			{
+				let signature_valid =
+					SignedPayload::<T>::verify::<T::AuthorityId>(payload, signature.clone());
+				if !signature_valid {
+					return InvalidTransaction::BadProof.into()
+				}
+				Self::validate_transaction_parameters(&payload.block_number, &payload.price)
+			} else if let Call::submit_price_unsigned { block_number, price: new_price } = call {
+				Self::validate_transaction_parameters(block_number, new_price)
+			} else {
+				InvalidTransaction::Call.into()
+			}
+		}
+	}
+
+	/// A vector of recently submitted prices.
+	///
+	/// This is used to calculate average price, should have bounded size.
+	#[pallet::storage]
+	#[pallet::getter(fn prices)]
+	pub(super) type Prices<T: Config> = StorageValue<_, BoundedVec<u32, T::MaxPrices>, ValueQuery>;
+
+	/// Defines the block when next unsigned transaction will be accepted.
+	///
+	/// To prevent spam of unsigned (and unpaid!) transactions on the network,
+	/// we only allow one transaction every `T::UnsignedInterval` blocks.
+	/// This storage entry defines when new transaction is going to be accepted.
+	#[pallet::storage]
+	#[pallet::getter(fn next_unsigned_at)]
+	pub(super) type NextUnsignedAt<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;
+}
+
+/// Payload used by this example crate to hold price
+/// data required to submit a transaction.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, scale_info::TypeInfo)]
+pub struct PricePayload<Public, BlockNumber> {
+	block_number: BlockNumber,
+	price: u32,
+	public: Public,
+}
+
+impl<T: SigningTypes> SignedPayload<T> for PricePayload<T::Public, BlockNumberFor<T>> {
+	fn public(&self) -> T::Public {
+		self.public.clone()
+	}
+}
+
+enum TransactionType {
+	Signed,
+	UnsignedForAny,
+	UnsignedForAll,
+	Raw,
+	None,
+}
+
+impl<T: Config> Pallet<T> {
+	/// Chooses which transaction type to send.
+	///
+	/// This function serves mostly to showcase `StorageValue` helper
+	/// and local storage usage.
+	///
+	/// Returns a type of transaction that should be produced in current run.
+	fn choose_transaction_type(block_number: BlockNumberFor<T>) -> TransactionType {
+		/// A friendlier name for the error that is going to be returned in case we are in the grace
+		/// period.
+		const RECENTLY_SENT: () = ();
+
+		// Start off by creating a reference to Local Storage value.
+		// Since the local storage is common for all offchain workers, it's a good practice
+		// to prepend your entry with the module name.
+		let val = StorageValueRef::persistent(b"example_ocw::last_send");
+		// The Local Storage is persisted and shared between runs of the offchain workers,
+		// and offchain workers may run concurrently. We can use the `mutate` function, to
+		// write a storage entry in an atomic fashion. Under the hood it uses `compare_and_set`
+		// low-level method of local storage API, which means that only one worker
+		// will be able to "acquire a lock" and send a transaction if multiple workers
+		// happen to be executed concurrently.
+		let res =
+			val.mutate(|last_send: Result<Option<BlockNumberFor<T>>, StorageRetrievalError>| {
+				match last_send {
+					// If we already have a value in storage and the block number is recent enough
+					// we avoid sending another transaction at this time.
+					Ok(Some(block)) if block_number < block + T::GracePeriod::get() =>
+						Err(RECENTLY_SENT),
+					// In every other case we attempt to acquire the lock and send a transaction.
+					_ => Ok(block_number),
+				}
+			});
+
+		// The result of `mutate` call will give us a nested `Result` type.
+		// The first one matches the return of the closure passed to `mutate`, i.e.
+		// if we return `Err` from the closure, we get an `Err` here.
+		// In case we return `Ok`, here we will have another (inner) `Result` that indicates
+		// if the value has been set to the storage correctly - i.e. if it wasn't
+		// written to in the meantime.
+		match res {
+			// The value has been set correctly, which means we can safely send a transaction now.
+			Ok(block_number) => {
+				// We will send different transactions based on a random number.
+				// Note that this logic doesn't really guarantee that the transactions will be sent
+				// in an alternating fashion (i.e. fairly distributed). Depending on the execution
+				// order and lock acquisition, we may end up for instance sending two `Signed`
+				// transactions in a row. If a strict order is desired, it's better to use
+				// the storage entry for that. (for instance store both block number and a flag
+				// indicating the type of next transaction to send).
+				let transaction_type = block_number % 4u32.into();
+				if transaction_type == Zero::zero() {
+					TransactionType::Signed
+				} else if transaction_type == BlockNumberFor::<T>::from(1u32) {
+					TransactionType::UnsignedForAny
+				} else if transaction_type == BlockNumberFor::<T>::from(2u32) {
+					TransactionType::UnsignedForAll
+				} else {
+					TransactionType::Raw
+				}
+			},
+			// We are in the grace period, we should not send a transaction this time.
+			Err(MutateStorageError::ValueFunctionFailed(RECENTLY_SENT)) => TransactionType::None,
+			// We wanted to send a transaction, but failed to write the block number (acquire a
+			// lock). This indicates that another offchain worker that was running concurrently
+			// most likely executed the same logic and succeeded at writing to storage.
+			// Thus we don't really want to send the transaction, knowing that the other run
+			// already did.
+			Err(MutateStorageError::ConcurrentModification(_)) => TransactionType::None,
+		}
+	}
+
+	/// A helper function to fetch the price and send signed transaction.
+	fn fetch_price_and_send_signed() -> Result<(), &'static str> {
+		let signer = Signer::<T, T::AuthorityId>::all_accounts();
+		if !signer.can_sign() {
+			return Err(
+				"No local accounts available. Consider adding one via `author_insertKey` RPC.",
+			)
+		}
+		// Make an external HTTP request to fetch the current price.
+		// Note this call will block until response is received.
+		let price = Self::fetch_price().map_err(|_| "Failed to fetch price")?;
+
+		// Using `send_signed_transaction` associated type we create and submit a transaction
+		// representing the call, we've just created.
+		// Submit signed will return a vector of results for all accounts that were found in the
+		// local keystore with expected `KEY_TYPE`.
+		let results = signer.send_signed_transaction(|_account| {
+			// Received price is wrapped into a call to `submit_price` public function of this
+			// pallet. This means that the transaction, when executed, will simply call that
+			// function passing `price` as an argument.
+			Call::submit_price { price }
+		});
+
+		for (acc, res) in &results {
+			match res {
+				Ok(()) => log::info!("[{:?}] Submitted price of {} cents", acc.id, price),
+				Err(e) => log::error!("[{:?}] Failed to submit transaction: {:?}", acc.id, e),
+			}
+		}
+
+		Ok(())
+	}
+
+	/// A helper function to fetch the price and send a raw unsigned transaction.
+	fn fetch_price_and_send_raw_unsigned(
+		block_number: BlockNumberFor<T>,
+	) -> Result<(), &'static str> {
+		// Make sure we don't fetch the price if unsigned transaction is going to be rejected
+		// anyway.
+		let next_unsigned_at = <NextUnsignedAt<T>>::get();
+		if next_unsigned_at > block_number {
+			return Err("Too early to send unsigned transaction")
+		}
+
+		// Make an external HTTP request to fetch the current price.
+		// Note this call will block until response is received.
+		let price = Self::fetch_price().map_err(|_| "Failed to fetch price")?;
+
+		// Received price is wrapped into a call to `submit_price_unsigned` public function of this
+		// pallet. This means that the transaction, when executed, will simply call that function
+		// passing `price` as an argument.
+		let call = Call::submit_price_unsigned { block_number, price };
+
+		// Now let's create a transaction out of this call and submit it to the pool.
+		// Here we showcase two ways to send an unsigned transaction / unsigned payload (raw)
+		//
+		// By default unsigned transactions are disallowed, so we need to whitelist this case
+		// by writing `UnsignedValidator`. Note that it's EXTREMELY important to carefuly
+		// implement unsigned validation logic, as any mistakes can lead to opening DoS or spam
+		// attack vectors. See validation logic docs for more details.
+		//
+		SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into())
+			.map_err(|()| "Unable to submit unsigned transaction.")?;
+
+		Ok(())
+	}
+
+	/// A helper function to fetch the price, sign payload and send an unsigned transaction
+	fn fetch_price_and_send_unsigned_for_any_account(
+		block_number: BlockNumberFor<T>,
+	) -> Result<(), &'static str> {
+		// Make sure we don't fetch the price if unsigned transaction is going to be rejected
+		// anyway.
+		let next_unsigned_at = <NextUnsignedAt<T>>::get();
+		if next_unsigned_at > block_number {
+			return Err("Too early to send unsigned transaction")
+		}
+
+		// Make an external HTTP request to fetch the current price.
+		// Note this call will block until response is received.
+		let price = Self::fetch_price().map_err(|_| "Failed to fetch price")?;
+
+		// -- Sign using any account
+		let (_, result) = Signer::<T, T::AuthorityId>::any_account()
+			.send_unsigned_transaction(
+				|account| PricePayload { price, block_number, public: account.public.clone() },
+				|payload, signature| Call::submit_price_unsigned_with_signed_payload {
+					price_payload: payload,
+					signature,
+				},
+			)
+			.ok_or("No local accounts accounts available.")?;
+		result.map_err(|()| "Unable to submit transaction")?;
+
+		Ok(())
+	}
+
+	/// A helper function to fetch the price, sign payload and send an unsigned transaction
+	fn fetch_price_and_send_unsigned_for_all_accounts(
+		block_number: BlockNumberFor<T>,
+	) -> Result<(), &'static str> {
+		// Make sure we don't fetch the price if unsigned transaction is going to be rejected
+		// anyway.
+		let next_unsigned_at = <NextUnsignedAt<T>>::get();
+		if next_unsigned_at > block_number {
+			return Err("Too early to send unsigned transaction")
+		}
+
+		// Make an external HTTP request to fetch the current price.
+		// Note this call will block until response is received.
+		let price = Self::fetch_price().map_err(|_| "Failed to fetch price")?;
+
+		// -- Sign using all accounts
+		let transaction_results = Signer::<T, T::AuthorityId>::all_accounts()
+			.send_unsigned_transaction(
+				|account| PricePayload { price, block_number, public: account.public.clone() },
+				|payload, signature| Call::submit_price_unsigned_with_signed_payload {
+					price_payload: payload,
+					signature,
+				},
+			);
+		for (_account_id, result) in transaction_results.into_iter() {
+			if result.is_err() {
+				return Err("Unable to submit transaction")
+			}
+		}
+
+		Ok(())
+	}
+
+	/// Fetch current price and return the result in cents.
+	fn fetch_price() -> Result<u32, http::Error> {
+		// We want to keep the offchain worker execution time reasonable, so we set a hard-coded
+		// deadline to 2s to complete the external call.
+		// You can also wait indefinitely for the response, however you may still get a timeout
+		// coming from the host machine.
+		let deadline = sp_io::offchain::timestamp().add(Duration::from_millis(2_000));
+		// Initiate an external HTTP GET request.
+		// This is using high-level wrappers from `sp_runtime`, for the low-level calls that
+		// you can find in `sp_io`. The API is trying to be similar to `request`, but
+		// since we are running in a custom WASM execution environment we can't simply
+		// import the library here.
+		let request =
+			http::Request::get("https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD");
+		// We set the deadline for sending of the request, note that awaiting response can
+		// have a separate deadline. Next we send the request, before that it's also possible
+		// to alter request headers or stream body content in case of non-GET requests.
+		let pending = request.deadline(deadline).send().map_err(|_| http::Error::IoError)?;
+
+		// The request is already being processed by the host, we are free to do anything
+		// else in the worker (we can send multiple concurrent requests too).
+		// At some point however we probably want to check the response though,
+		// so we can block current thread and wait for it to finish.
+		// Note that since the request is being driven by the host, we don't have to wait
+		// for the request to have it complete, we will just not read the response.
+		let response = pending.try_wait(deadline).map_err(|_| http::Error::DeadlineReached)??;
+		// Let's check the status code before we proceed to reading the response.
+		if response.code != 200 {
+			log::warn!("Unexpected status code: {}", response.code);
+			return Err(http::Error::Unknown)
+		}
+
+		// Next we want to fully read the response body and collect it to a vector of bytes.
+		// Note that the return object allows you to read the body in chunks as well
+		// with a way to control the deadline.
+		let body = response.body().collect::<Vec<u8>>();
+
+		// Create a str slice from the body.
+		let body_str = sp_std::str::from_utf8(&body).map_err(|_| {
+			log::warn!("No UTF8 body");
+			http::Error::Unknown
+		})?;
+
+		let price = match Self::parse_price(body_str) {
+			Some(price) => Ok(price),
+			None => {
+				log::warn!("Unable to extract price from the response: {:?}", body_str);
+				Err(http::Error::Unknown)
+			},
+		}?;
+
+		log::warn!("Got price: {} cents", price);
+
+		Ok(price)
+	}
+
+	/// Parse the price from the given JSON string using `lite-json`.
+	///
+	/// Returns `None` when parsing failed or `Some(price in cents)` when parsing is successful.
+	fn parse_price(price_str: &str) -> Option<u32> {
+		let val = lite_json::parse_json(price_str);
+		let price = match val.ok()? {
+			JsonValue::Object(obj) => {
+				let (_, v) = obj.into_iter().find(|(k, _)| k.iter().copied().eq("USD".chars()))?;
+				match v {
+					JsonValue::Number(number) => number,
+					_ => return None,
+				}
+			},
+			_ => return None,
+		};
+
+		let exp = price.fraction_length.saturating_sub(2);
+		Some(price.integer as u32 * 100 + (price.fraction / 10_u64.pow(exp)) as u32)
+	}
+
+	/// Add new price to the list.
+	fn add_price(maybe_who: Option<T::AccountId>, price: u32) {
+		log::info!("Adding to the average: {}", price);
+		<Prices<T>>::mutate(|prices| {
+			if prices.try_push(price).is_err() {
+				prices[(price % T::MaxPrices::get()) as usize] = price;
+			}
+		});
+
+		let average = Self::average_price()
+			.expect("The average is not empty, because it was just mutated; qed");
+		log::info!("Current average price is: {}", average);
+		// here we are raising the NewPrice event
+		Self::deposit_event(Event::NewPrice { price, maybe_who });
+	}
+
+	/// Calculate current average price.
+	fn average_price() -> Option<u32> {
+		let prices = <Prices<T>>::get();
+		if prices.is_empty() {
+			None
+		} else {
+			Some(prices.iter().fold(0_u32, |a, b| a.saturating_add(*b)) / prices.len() as u32)
+		}
+	}
+
+	fn validate_transaction_parameters(
+		block_number: &BlockNumberFor<T>,
+		new_price: &u32,
+	) -> TransactionValidity {
+		// Now let's check if the transaction has any chance to succeed.
+		let next_unsigned_at = <NextUnsignedAt<T>>::get();
+		if &next_unsigned_at > block_number {
+			return InvalidTransaction::Stale.into()
+		}
+		// Let's make sure to reject transactions from the future.
+		let current_block = <system::Pallet<T>>::block_number();
+		if &current_block < block_number {
+			return InvalidTransaction::Future.into()
+		}
+
+		// We prioritize transactions that are more far away from current average.
+		//
+		// Note this doesn't make much sense when building an actual oracle, but this example
+		// is here mostly to show off offchain workers capabilities, not about building an
+		// oracle.
+		let avg_price = Self::average_price()
+			.map(|price| if &price > new_price { price - new_price } else { new_price - price })
+			.unwrap_or(0);
+
+		ValidTransaction::with_tag_prefix("ExampleOffchainWorker")
+			// We set base priority to 2**20 and hope it's included before any other
+			// transactions in the pool. Next we tweak the priority depending on how much
+			// it differs from the current average. (the more it differs the more priority it
+			// has).
+			.priority(T::UnsignedPriority::get().saturating_add(avg_price as _))
+			// This transaction does not require anything else to go before into the pool.
+			// In theory we could require `previous_unsigned_at` transaction to go first,
+			// but it's not necessary in our case.
+			//.and_requires()
+			// We set the `provides` tag to be the same as `next_unsigned_at`. This makes
+			// sure only one transaction produced after `next_unsigned_at` will ever
+			// get to the transaction pool and will end up in the block.
+			// We can still have multiple transactions compete for the same "spot",
+			// and the one with higher priority will replace other one in the pool.
+			.and_provides(next_unsigned_at)
+			// The transaction is only valid for next 5 blocks. After that it's
+			// going to be revalidated by the pool.
+			.longevity(5)
+			// It's fine to propagate that transaction to other peers, which means it can be
+			// created even by nodes that don't produce blocks.
+			// Note that sometimes it's better to keep it for yourself (if you are the block
+			// producer), since for instance in some schemes others may copy your solution and
+			// claim a reward.
+			.propagate(true)
+			.build()
+	}
+}
diff --git a/substrate/frame/examples/offchain-worker/src/tests.rs b/substrate/frame/examples/offchain-worker/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..203a59a8af03c61e9bf33e5c21d9a8a574296314
--- /dev/null
+++ b/substrate/frame/examples/offchain-worker/src/tests.rs
@@ -0,0 +1,390 @@
+// 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 as example_offchain_worker;
+use crate::*;
+use codec::Decode;
+use frame_support::{
+	assert_ok, parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use sp_core::{
+	offchain::{testing, OffchainWorkerExt, TransactionPoolExt},
+	sr25519::Signature,
+	H256,
+};
+
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use sp_runtime::{
+	testing::TestXt,
+	traits::{BlakeTwo256, Extrinsic as ExtrinsicT, IdentifyAccount, IdentityLookup, Verify},
+	RuntimeAppPublic,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// For testing the module, we construct a mock runtime.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Example: example_offchain_worker::{Pallet, Call, Storage, Event<T>, ValidateUnsigned},
+	}
+);
+
+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 = sp_core::sr25519::Public;
+	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>;
+}
+
+type Extrinsic = TestXt<RuntimeCall, ()>;
+type AccountId = <<Signature as Verify>::Signer as IdentifyAccount>::AccountId;
+
+impl frame_system::offchain::SigningTypes for Test {
+	type Public = <Signature as Verify>::Signer;
+	type Signature = Signature;
+}
+
+impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Test
+where
+	RuntimeCall: From<LocalCall>,
+{
+	type OverarchingCall = RuntimeCall;
+	type Extrinsic = Extrinsic;
+}
+
+impl<LocalCall> frame_system::offchain::CreateSignedTransaction<LocalCall> for Test
+where
+	RuntimeCall: From<LocalCall>,
+{
+	fn create_transaction<C: frame_system::offchain::AppCrypto<Self::Public, Self::Signature>>(
+		call: RuntimeCall,
+		_public: <Signature as Verify>::Signer,
+		_account: AccountId,
+		nonce: u64,
+	) -> Option<(RuntimeCall, <Extrinsic as ExtrinsicT>::SignaturePayload)> {
+		Some((call, (nonce, ())))
+	}
+}
+
+parameter_types! {
+	pub const UnsignedPriority: u64 = 1 << 20;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type AuthorityId = crypto::TestAuthId;
+	type GracePeriod = ConstU64<5>;
+	type UnsignedInterval = ConstU64<128>;
+	type UnsignedPriority = UnsignedPriority;
+	type MaxPrices = ConstU32<64>;
+}
+
+fn test_pub() -> sp_core::sr25519::Public {
+	sp_core::sr25519::Public::from_raw([1u8; 32])
+}
+
+#[test]
+fn it_aggregates_the_price() {
+	sp_io::TestExternalities::default().execute_with(|| {
+		assert_eq!(Example::average_price(), None);
+
+		assert_ok!(Example::submit_price(RuntimeOrigin::signed(test_pub()), 27));
+		assert_eq!(Example::average_price(), Some(27));
+
+		assert_ok!(Example::submit_price(RuntimeOrigin::signed(test_pub()), 43));
+		assert_eq!(Example::average_price(), Some(35));
+	});
+}
+
+#[test]
+fn should_make_http_call_and_parse_result() {
+	let (offchain, state) = testing::TestOffchainExt::new();
+	let mut t = sp_io::TestExternalities::default();
+	t.register_extension(OffchainWorkerExt::new(offchain));
+
+	price_oracle_response(&mut state.write());
+
+	t.execute_with(|| {
+		// when
+		let price = Example::fetch_price().unwrap();
+		// then
+		assert_eq!(price, 15523);
+	});
+}
+
+#[test]
+fn knows_how_to_mock_several_http_calls() {
+	let (offchain, state) = testing::TestOffchainExt::new();
+	let mut t = sp_io::TestExternalities::default();
+	t.register_extension(OffchainWorkerExt::new(offchain));
+
+	{
+		let mut state = state.write();
+		state.expect_request(testing::PendingRequest {
+			method: "GET".into(),
+			uri: "https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD".into(),
+			response: Some(br#"{"USD": 1}"#.to_vec()),
+			sent: true,
+			..Default::default()
+		});
+
+		state.expect_request(testing::PendingRequest {
+			method: "GET".into(),
+			uri: "https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD".into(),
+			response: Some(br#"{"USD": 2}"#.to_vec()),
+			sent: true,
+			..Default::default()
+		});
+
+		state.expect_request(testing::PendingRequest {
+			method: "GET".into(),
+			uri: "https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD".into(),
+			response: Some(br#"{"USD": 3}"#.to_vec()),
+			sent: true,
+			..Default::default()
+		});
+	}
+
+	t.execute_with(|| {
+		let price1 = Example::fetch_price().unwrap();
+		let price2 = Example::fetch_price().unwrap();
+		let price3 = Example::fetch_price().unwrap();
+
+		assert_eq!(price1, 100);
+		assert_eq!(price2, 200);
+		assert_eq!(price3, 300);
+	})
+}
+
+#[test]
+fn should_submit_signed_transaction_on_chain() {
+	const PHRASE: &str =
+		"news slush supreme milk chapter athlete soap sausage put clutch what kitten";
+
+	let (offchain, offchain_state) = testing::TestOffchainExt::new();
+	let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+	let keystore = MemoryKeystore::new();
+	keystore
+		.sr25519_generate_new(crate::crypto::Public::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+
+	let mut t = sp_io::TestExternalities::default();
+	t.register_extension(OffchainWorkerExt::new(offchain));
+	t.register_extension(TransactionPoolExt::new(pool));
+	t.register_extension(KeystoreExt::new(keystore));
+
+	price_oracle_response(&mut offchain_state.write());
+
+	t.execute_with(|| {
+		// when
+		Example::fetch_price_and_send_signed().unwrap();
+		// then
+		let tx = pool_state.write().transactions.pop().unwrap();
+		assert!(pool_state.read().transactions.is_empty());
+		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		assert_eq!(tx.signature.unwrap().0, 0);
+		assert_eq!(tx.call, RuntimeCall::Example(crate::Call::submit_price { price: 15523 }));
+	});
+}
+
+#[test]
+fn should_submit_unsigned_transaction_on_chain_for_any_account() {
+	const PHRASE: &str =
+		"news slush supreme milk chapter athlete soap sausage put clutch what kitten";
+	let (offchain, offchain_state) = testing::TestOffchainExt::new();
+	let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+
+	let keystore = MemoryKeystore::new();
+
+	keystore
+		.sr25519_generate_new(crate::crypto::Public::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+
+	let public_key = *keystore.sr25519_public_keys(crate::crypto::Public::ID).get(0).unwrap();
+
+	let mut t = sp_io::TestExternalities::default();
+	t.register_extension(OffchainWorkerExt::new(offchain));
+	t.register_extension(TransactionPoolExt::new(pool));
+	t.register_extension(KeystoreExt::new(keystore));
+
+	price_oracle_response(&mut offchain_state.write());
+
+	let price_payload = PricePayload {
+		block_number: 1,
+		price: 15523,
+		public: <Test as SigningTypes>::Public::from(public_key),
+	};
+
+	// let signature = price_payload.sign::<crypto::TestAuthId>().unwrap();
+	t.execute_with(|| {
+		// when
+		Example::fetch_price_and_send_unsigned_for_any_account(1).unwrap();
+		// then
+		let tx = pool_state.write().transactions.pop().unwrap();
+		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		assert_eq!(tx.signature, None);
+		if let RuntimeCall::Example(crate::Call::submit_price_unsigned_with_signed_payload {
+			price_payload: body,
+			signature,
+		}) = tx.call
+		{
+			assert_eq!(body, price_payload);
+
+			let signature_valid =
+				<PricePayload<
+					<Test as SigningTypes>::Public,
+					frame_system::pallet_prelude::BlockNumberFor<Test>,
+				> as SignedPayload<Test>>::verify::<crypto::TestAuthId>(&price_payload, signature);
+
+			assert!(signature_valid);
+		}
+	});
+}
+
+#[test]
+fn should_submit_unsigned_transaction_on_chain_for_all_accounts() {
+	const PHRASE: &str =
+		"news slush supreme milk chapter athlete soap sausage put clutch what kitten";
+	let (offchain, offchain_state) = testing::TestOffchainExt::new();
+	let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+
+	let keystore = MemoryKeystore::new();
+
+	keystore
+		.sr25519_generate_new(crate::crypto::Public::ID, Some(&format!("{}/hunter1", PHRASE)))
+		.unwrap();
+
+	let public_key = *keystore.sr25519_public_keys(crate::crypto::Public::ID).get(0).unwrap();
+
+	let mut t = sp_io::TestExternalities::default();
+	t.register_extension(OffchainWorkerExt::new(offchain));
+	t.register_extension(TransactionPoolExt::new(pool));
+	t.register_extension(KeystoreExt::new(keystore));
+
+	price_oracle_response(&mut offchain_state.write());
+
+	let price_payload = PricePayload {
+		block_number: 1,
+		price: 15523,
+		public: <Test as SigningTypes>::Public::from(public_key),
+	};
+
+	// let signature = price_payload.sign::<crypto::TestAuthId>().unwrap();
+	t.execute_with(|| {
+		// when
+		Example::fetch_price_and_send_unsigned_for_all_accounts(1).unwrap();
+		// then
+		let tx = pool_state.write().transactions.pop().unwrap();
+		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		assert_eq!(tx.signature, None);
+		if let RuntimeCall::Example(crate::Call::submit_price_unsigned_with_signed_payload {
+			price_payload: body,
+			signature,
+		}) = tx.call
+		{
+			assert_eq!(body, price_payload);
+
+			let signature_valid =
+				<PricePayload<
+					<Test as SigningTypes>::Public,
+					frame_system::pallet_prelude::BlockNumberFor<Test>,
+				> as SignedPayload<Test>>::verify::<crypto::TestAuthId>(&price_payload, signature);
+
+			assert!(signature_valid);
+		}
+	});
+}
+
+#[test]
+fn should_submit_raw_unsigned_transaction_on_chain() {
+	let (offchain, offchain_state) = testing::TestOffchainExt::new();
+	let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+
+	let keystore = MemoryKeystore::new();
+
+	let mut t = sp_io::TestExternalities::default();
+	t.register_extension(OffchainWorkerExt::new(offchain));
+	t.register_extension(TransactionPoolExt::new(pool));
+	t.register_extension(KeystoreExt::new(keystore));
+
+	price_oracle_response(&mut offchain_state.write());
+
+	t.execute_with(|| {
+		// when
+		Example::fetch_price_and_send_raw_unsigned(1).unwrap();
+		// then
+		let tx = pool_state.write().transactions.pop().unwrap();
+		assert!(pool_state.read().transactions.is_empty());
+		let tx = Extrinsic::decode(&mut &*tx).unwrap();
+		assert_eq!(tx.signature, None);
+		assert_eq!(
+			tx.call,
+			RuntimeCall::Example(crate::Call::submit_price_unsigned {
+				block_number: 1,
+				price: 15523
+			})
+		);
+	});
+}
+
+fn price_oracle_response(state: &mut testing::OffchainState) {
+	state.expect_request(testing::PendingRequest {
+		method: "GET".into(),
+		uri: "https://min-api.cryptocompare.com/data/price?fsym=BTC&tsyms=USD".into(),
+		response: Some(br#"{"USD": 155.23}"#.to_vec()),
+		sent: true,
+		..Default::default()
+	});
+}
+
+#[test]
+fn parse_price_works() {
+	let test_data = vec![
+		("{\"USD\":6536.92}", Some(653692)),
+		("{\"USD\":65.92}", Some(6592)),
+		("{\"USD\":6536.924565}", Some(653692)),
+		("{\"USD\":6536}", Some(653600)),
+		("{\"USD2\":6536}", None),
+		("{\"USD\":\"6432\"}", None),
+	];
+
+	for (json, expected) in test_data {
+		assert_eq!(expected, Example::parse_price(json));
+	}
+}
diff --git a/substrate/frame/examples/split/Cargo.toml b/substrate/frame/examples/split/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f64d79855a1a5e4d9b48790492996cac129a87a0
--- /dev/null
+++ b/substrate/frame/examples/split/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "pallet-example-split"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "MIT-0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME example splitted pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../../benchmarking" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+]
+try-runtime = [ "frame-support/try-runtime", "frame-system/try-runtime" ]
diff --git a/substrate/frame/examples/split/README.md b/substrate/frame/examples/split/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..413ce9b913cb9850acb0a910297a1aa46202427c
--- /dev/null
+++ b/substrate/frame/examples/split/README.md
@@ -0,0 +1,10 @@
+<!-- markdown-link-check-disable -->
+# Basic Example For Splitting A Pallet
+A simple example of a FRAME pallet demonstrating the ability to split sections across multiple
+files.
+
+Note that this is purely experimental at this point. 
+
+Run `cargo doc --package pallet-example-split --open` to view this pallet's documentation.
+
+License: MIT-0
diff --git a/substrate/frame/examples/split/src/benchmarking.rs b/substrate/frame/examples/split/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5a503009372034d67b237fed977a4ad4eb7bb8b8
--- /dev/null
+++ b/substrate/frame/examples/split/src/benchmarking.rs
@@ -0,0 +1,54 @@
+// 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.
+
+//! Benchmarking setup for pallet-example-split
+
+// Only enable this module for benchmarking.
+#![cfg(feature = "runtime-benchmarks")]
+use super::*;
+
+#[allow(unused)]
+use crate::Pallet as Template;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn do_something() {
+		let value = 100u32.into();
+		let caller: T::AccountId = whitelisted_caller();
+		#[extrinsic_call]
+		do_something(RawOrigin::Signed(caller), value);
+
+		assert_eq!(Something::<T>::get(), Some(value));
+	}
+
+	#[benchmark]
+	fn cause_error() {
+		Something::<T>::put(100u32);
+		let caller: T::AccountId = whitelisted_caller();
+		#[extrinsic_call]
+		cause_error(RawOrigin::Signed(caller));
+
+		assert_eq!(Something::<T>::get(), Some(101u32));
+	}
+
+	impl_benchmark_test_suite!(Template, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/examples/split/src/events.rs b/substrate/frame/examples/split/src/events.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7560766bacb33fe32201fe4f2536aa7c3f2f5d01
--- /dev/null
+++ b/substrate/frame/examples/split/src/events.rs
@@ -0,0 +1,31 @@
+// 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_support::pallet_macros::*;
+
+/// A [`pallet_section`] that defines the events for a pallet.
+/// This can later be imported into the pallet using [`import_section`].
+#[pallet_section]
+mod events {
+	#[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 { something: u32, who: T::AccountId },
+	}
+}
diff --git a/substrate/frame/examples/split/src/lib.rs b/substrate/frame/examples/split/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74d2e0cc24b7bf5789da19f2657c5e7d2514bbfe
--- /dev/null
+++ b/substrate/frame/examples/split/src/lib.rs
@@ -0,0 +1,123 @@
+// 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.
+
+//! # Split Example Pallet
+//!
+//! **This pallet serves as an example and is not meant to be used in production.**
+//!
+//! A FRAME pallet demonstrating the ability to split sections across multiple files.
+//!
+//! Note that this is purely experimental at this point.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+// Re-export pallet items so that they can be accessed from the crate namespace.
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+mod events;
+
+pub mod weights;
+pub use weights::*;
+
+use frame_support::pallet_macros::*;
+
+/// Imports a [`pallet_section`] defined at [`events::events`].
+/// This brings the events defined in that section into the pallet's namespace.
+#[import_section(events::events)]
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Configure the pallet by specifying the parameters and types on which it depends.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Because this pallet emits events, it depends on the runtime's definition of an event.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// Type representing the weight of this pallet
+		type WeightInfo: WeightInfo;
+	}
+
+	// The pallet's runtime storage items.
+	#[pallet::storage]
+	pub type Something<T> = StorageValue<_, u32>;
+
+	// Errors inform users that something went wrong.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Error names should be descriptive.
+		NoneValue,
+		/// Errors should have helpful documentation associated with them.
+		StorageOverflow,
+	}
+
+	// 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.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// An example dispatchable that takes a singles value as a parameter, writes the value to
+		/// storage and emits an event. This function must be dispatched by a signed extrinsic.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::do_something())]
+		pub fn do_something(origin: OriginFor<T>, something: u32) -> DispatchResult {
+			// Check that the extrinsic was signed and get the signer.
+			// This function will return an error if the extrinsic is not signed.
+			let who = ensure_signed(origin)?;
+
+			// Update storage.
+			<Something<T>>::put(something);
+
+			// Emit an event.
+			Self::deposit_event(Event::SomethingStored { something, who });
+			// Return a successful DispatchResultWithPostInfo
+			Ok(())
+		}
+
+		/// An example dispatchable that may throw a custom error.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::cause_error())]
+		pub fn cause_error(origin: OriginFor<T>) -> DispatchResult {
+			let _who = ensure_signed(origin)?;
+
+			// Read a value from storage.
+			match <Something<T>>::get() {
+				// Return an error if the value has not been set.
+				None => return Err(Error::<T>::NoneValue.into()),
+				Some(old) => {
+					// Increment the value read from storage; will error in the event of overflow.
+					let new = old.checked_add(1).ok_or(Error::<T>::StorageOverflow)?;
+					// Update the value in storage with the incremented result.
+					<Something<T>>::put(new);
+					Ok(())
+				},
+			}
+		}
+	}
+}
diff --git a/substrate/frame/examples/split/src/mock.rs b/substrate/frame/examples/split/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bee3633ef68f2c02856b70429370c34301577e32
--- /dev/null
+++ b/substrate/frame/examples/split/src/mock.rs
@@ -0,0 +1,55 @@
+// 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 as pallet_template;
+use frame_support::{derive_impl, sp_runtime::BuildStorage};
+use sp_core::ConstU64;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// Configure a mock runtime to test the pallet.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		TemplatePallet: pallet_template,
+	}
+);
+
+/// Using a default config for [`frame_system`] in tests. See `default-config` example for more
+/// details.
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+	type BlockHashCount = ConstU64<10>;
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl pallet_template::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+}
+
+// Build genesis storage according to the mock runtime.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
diff --git a/substrate/frame/examples/split/src/tests.rs b/substrate/frame/examples/split/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1d4b6dfcff9d5c82ac7fa3efca50a92c1e298803
--- /dev/null
+++ b/substrate/frame/examples/split/src/tests.rs
@@ -0,0 +1,44 @@
+// 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::{mock::*, Error, Event, Something};
+use frame_support::{assert_noop, assert_ok};
+
+#[test]
+fn it_works_for_default_value() {
+	new_test_ext().execute_with(|| {
+		// Go past genesis block so events get deposited
+		System::set_block_number(1);
+		// Dispatch a signed extrinsic.
+		assert_ok!(TemplatePallet::do_something(RuntimeOrigin::signed(1), 42));
+		// Read pallet storage and assert an expected result.
+		assert_eq!(Something::<Test>::get(), Some(42));
+		// Assert that the correct event was deposited
+		System::assert_last_event(Event::SomethingStored { something: 42, who: 1 }.into());
+	});
+}
+
+#[test]
+fn correct_error_for_none_value() {
+	new_test_ext().execute_with(|| {
+		// Ensure the expected error is thrown when no value is present.
+		assert_noop!(
+			TemplatePallet::cause_error(RuntimeOrigin::signed(1)),
+			Error::<Test>::NoneValue
+		);
+	});
+}
diff --git a/substrate/frame/examples/split/src/weights.rs b/substrate/frame/examples/split/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4219ce1e2697c1a20d396ee24085e1efa87e3ec8
--- /dev/null
+++ b/substrate/frame/examples/split/src/weights.rs
@@ -0,0 +1,91 @@
+
+//! Autogenerated weights for pallet_template
+//!
+//! 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>`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ../../target/release/node-template
+// benchmark
+// pallet
+// --chain
+// dev
+// --pallet
+// pallet_template
+// --extrinsic
+// *
+// --steps=50
+// --repeat=20
+// --execution=wasm
+// --wasm-execution=compiled
+// --output
+// pallets/template/src/weights.rs
+// --template
+// ../../.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_template.
+pub trait WeightInfo {
+	fn do_something() -> Weight;
+	fn cause_error() -> Weight;
+}
+
+/// Weights for pallet_template using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: TemplatePallet Something (r:0 w:1)
+	/// Proof: TemplatePallet Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn do_something() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_000_000 picoseconds.
+		Weight::from_parts(9_000_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: TemplatePallet Something (r:1 w:1)
+	/// Proof: TemplatePallet Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn cause_error() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32`
+		//  Estimated: `1489`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(6_000_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: TemplatePallet Something (r:0 w:1)
+	/// Proof: TemplatePallet Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn do_something() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_000_000 picoseconds.
+		Weight::from_parts(9_000_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: TemplatePallet Something (r:1 w:1)
+	/// Proof: TemplatePallet Something (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn cause_error() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32`
+		//  Estimated: `1489`
+		// Minimum execution time: 6_000_000 picoseconds.
+		Weight::from_parts(6_000_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/examples/src/lib.rs b/substrate/frame/examples/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d1cd32bb50f263429567b4872ca5049f08586ac3
--- /dev/null
+++ b/substrate/frame/examples/src/lib.rs
@@ -0,0 +1,40 @@
+// 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 Pallet Examples
+//!
+//! This crate contains examples of FRAME pallets. It is not intended to be used in production.
+//!
+//! ## Pallets
+//!
+//! - [**`pallet_example_basic`**](./basic): A simple example of a FRAME pallet demonstrating
+//! concepts, APIs and structures common to most FRAME runtimes.
+//!
+//! - [**`pallet_example_offchain_worker`**](./offchain-worker): A simple example of a FRAME pallet
+//!   demonstrating concepts, APIs and structures common to most offchain workers.
+//!
+//! - [**`pallet-default-config-example`**](./default-config): A simple example of a FRAME pallet
+//!   demonstrating the simpler way to implement `Config` trait of pallets.
+//!
+//! - [**`pallet-dev-mode`**](./dev-mode): A simple example of a FRAME pallet demonstrating the ease
+//!   of requirements for a pallet in dev mode.
+//!
+//! - [**`pallet-example-kitchensink`**](./kitchensink): A simple example of a FRAME pallet
+//!   demonstrating a catalog of the the FRAME macros and their various syntax options.
+//!
+//! - [**`pallet-example-split`**](./split): A simple example of a FRAME pallet demonstrating the
+//!   ability to split sections across multiple files.
diff --git a/substrate/frame/executive/Cargo.toml b/substrate/frame/executive/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..48cbb47fe7d2805d38b5b884a054e82145993f39
--- /dev/null
+++ b/substrate/frame/executive/Cargo.toml
@@ -0,0 +1,66 @@
+[package]
+name = "frame-executive"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME executives engine"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+frame-try-runtime = { version = "0.10.0-dev", default-features = false, path = "../try-runtime", optional = true }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-tracing = { version = "10.0.0", default-features = false, path = "../../primitives/tracing" }
+
+[dev-dependencies]
+array-bytes = "6.1"
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-transaction-payment = { version = "4.0.0-dev", path = "../transaction-payment" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../primitives/inherents" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-version = { version = "22.0.0", path = "../../primitives/version" }
+
+[features]
+default = [ "std" ]
+with-tracing = [ "sp-tracing/with-tracing" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"frame-try-runtime/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-transaction-payment/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-tracing/std",
+	"sp-version/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"frame-try-runtime/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-transaction-payment/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/executive/README.md b/substrate/frame/executive/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c14c3912b082d940aad7e0ee848c718915242a5e
--- /dev/null
+++ b/substrate/frame/executive/README.md
@@ -0,0 +1,73 @@
+# Executive Module
+
+The Executive module acts as the orchestration layer for the runtime. It dispatches incoming
+extrinsic calls to the respective modules in the runtime.
+
+## Overview
+
+The executive module is not a typical pallet providing functionality around a specific feature.
+It is a cross-cutting framework component for the FRAME. It works in conjunction with the
+[FRAME System module](https://docs.rs/frame-system/latest/frame_system/) to perform these cross-cutting functions.
+
+The Executive module provides functions to:
+
+- Check transaction validity.
+- Initialize a block.
+- Apply extrinsics.
+- Execute a block.
+- Finalize a block.
+- Start an off-chain worker.
+
+### Implementations
+
+The Executive module provides the following implementations:
+
+- `Executive`: Type that can be used to make the FRAME available from the runtime.
+
+## Usage
+
+The default Substrate node template declares the [`Executive`](https://docs.rs/frame-executive/latest/frame_executive/struct.Executive.html) type in its library.
+
+### Example
+
+`Executive` type declaration from the node template.
+
+```rust
+#
+/// Executive: handles dispatch to the various modules.
+pub type Executive = executive::Executive<
+    Runtime,
+    Block,
+    Context,
+    Runtime,
+    AllPallets,
+>;
+```
+
+### Custom `OnRuntimeUpgrade` logic
+
+You can add custom logic that should be called in your runtime on a runtime upgrade. This is
+done by setting an optional generic parameter. The custom logic will be called before
+the on runtime upgrade logic of all modules is called.
+
+```rust
+#
+struct CustomOnRuntimeUpgrade;
+impl frame_support::traits::OnRuntimeUpgrade for CustomOnRuntimeUpgrade {
+    fn on_runtime_upgrade() -> frame_support::weights::Weight {
+        // Do whatever you want.
+        frame_support::weights::Weight::zero()
+    }
+}
+
+pub type Executive = executive::Executive<
+    Runtime,
+    Block,
+    Context,
+    Runtime,
+    AllPallets,
+    CustomOnRuntimeUpgrade,
+>;
+```
+
+License: Apache-2.0
diff --git a/substrate/frame/executive/src/lib.rs b/substrate/frame/executive/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1d9afdfa60aa4441a4701822066c21711c41eb0c
--- /dev/null
+++ b/substrate/frame/executive/src/lib.rs
@@ -0,0 +1,1645 @@
+// 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.
+
+//! # Executive Module
+//!
+//! The Executive module acts as the orchestration layer for the runtime. It dispatches incoming
+//! extrinsic calls to the respective modules in the runtime.
+//!
+//! ## Overview
+//!
+//! The executive module is not a typical pallet providing functionality around a specific feature.
+//! It is a cross-cutting framework component for the FRAME. It works in conjunction with the
+//! [FRAME System module](../frame_system/index.html) to perform these cross-cutting functions.
+//!
+//! The Executive module provides functions to:
+//!
+//! - Check transaction validity.
+//! - Initialize a block.
+//! - Apply extrinsics.
+//! - Execute a block.
+//! - Finalize a block.
+//! - Start an off-chain worker.
+//!
+//! ### Implementations
+//!
+//! The Executive module provides the following implementations:
+//!
+//! - `ExecuteBlock`: Trait that can be used to execute a block.
+//! - `Executive`: Type that can be used to make the FRAME available from the runtime.
+//!
+//! ## Usage
+//!
+//! The default Substrate node template declares the [`Executive`](./struct.Executive.html) type in
+//! its library.
+//!
+//! ### Example
+//!
+//! `Executive` type declaration from the node template.
+//!
+//! ```
+//! # use sp_runtime::generic;
+//! # use frame_executive as executive;
+//! # pub struct UncheckedExtrinsic {};
+//! # pub struct Header {};
+//! # type Context = frame_system::ChainContext<Runtime>;
+//! # pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+//! # pub type Balances = u64;
+//! # pub type AllPalletsWithSystem = u64;
+//! # pub enum Runtime {};
+//! # use sp_runtime::transaction_validity::{
+//! #    TransactionValidity, UnknownTransaction, TransactionSource,
+//! # };
+//! # use sp_runtime::traits::ValidateUnsigned;
+//! # impl ValidateUnsigned for Runtime {
+//! #     type Call = ();
+//! #
+//! #     fn validate_unsigned(_source: TransactionSource, _call: &Self::Call) -> TransactionValidity {
+//! #         UnknownTransaction::NoUnsignedValidator.into()
+//! #     }
+//! # }
+//! /// Executive: handles dispatch to the various modules.
+//! pub type Executive = executive::Executive<Runtime, Block, Context, Runtime, AllPalletsWithSystem>;
+//! ```
+//!
+//! ### Custom `OnRuntimeUpgrade` logic
+//!
+//! You can add custom logic that should be called in your runtime on a runtime upgrade. This is
+//! done by setting an optional generic parameter. The custom logic will be called before
+//! the on runtime upgrade logic of all modules is called.
+//!
+//! ```
+//! # use sp_runtime::generic;
+//! # use frame_executive as executive;
+//! # pub struct UncheckedExtrinsic {};
+//! # pub struct Header {};
+//! # type Context = frame_system::ChainContext<Runtime>;
+//! # pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+//! # pub type Balances = u64;
+//! # pub type AllPalletsWithSystem = u64;
+//! # pub enum Runtime {};
+//! # use sp_runtime::transaction_validity::{
+//! #    TransactionValidity, UnknownTransaction, TransactionSource,
+//! # };
+//! # use sp_runtime::traits::ValidateUnsigned;
+//! # impl ValidateUnsigned for Runtime {
+//! #     type Call = ();
+//! #
+//! #     fn validate_unsigned(_source: TransactionSource, _call: &Self::Call) -> TransactionValidity {
+//! #         UnknownTransaction::NoUnsignedValidator.into()
+//! #     }
+//! # }
+//! struct CustomOnRuntimeUpgrade;
+//! impl frame_support::traits::OnRuntimeUpgrade for CustomOnRuntimeUpgrade {
+//!     fn on_runtime_upgrade() -> frame_support::weights::Weight {
+//!         // Do whatever you want.
+//!         frame_support::weights::Weight::zero()
+//!     }
+//! }
+//!
+//! pub type Executive = executive::Executive<Runtime, Block, Context, Runtime, AllPalletsWithSystem, CustomOnRuntimeUpgrade>;
+//! ```
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Codec, Encode};
+use frame_support::{
+	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, PostDispatchInfo},
+	pallet_prelude::InvalidTransaction,
+	traits::{
+		EnsureInherentsAreFirst, ExecuteBlock, OffchainWorker, OnFinalize, OnIdle, OnInitialize,
+		OnRuntimeUpgrade,
+	},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_runtime::{
+	generic::Digest,
+	traits::{
+		self, Applyable, CheckEqual, Checkable, Dispatchable, Header, NumberFor, One,
+		ValidateUnsigned, Zero,
+	},
+	transaction_validity::{TransactionSource, TransactionValidity},
+	ApplyExtrinsicResult,
+};
+use sp_std::{marker::PhantomData, prelude::*};
+
+#[cfg(feature = "try-runtime")]
+use log;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+#[allow(dead_code)]
+const LOG_TARGET: &str = "runtime::executive";
+
+pub type CheckedOf<E, C> = <E as Checkable<C>>::Checked;
+pub type CallOf<E, C> = <CheckedOf<E, C> as Applyable>::Call;
+pub type OriginOf<E, C> = <CallOf<E, C> as Dispatchable>::RuntimeOrigin;
+
+/// Main entry point for certain runtime actions as e.g. `execute_block`.
+///
+/// Generic parameters:
+/// - `System`: Something that implements `frame_system::Config`
+/// - `Block`: The block type of the runtime
+/// - `Context`: The context that is used when checking an extrinsic.
+/// - `UnsignedValidator`: The unsigned transaction validator of the runtime.
+/// - `AllPalletsWithSystem`: Tuple that contains all pallets including frame system pallet. Will be
+///   used to call hooks e.g. `on_initialize`.
+/// - `OnRuntimeUpgrade`: Custom logic that should be called after a runtime upgrade. Modules are
+///   already called by `AllPalletsWithSystem`. It will be called before all modules will be called.
+pub struct Executive<
+	System,
+	Block,
+	Context,
+	UnsignedValidator,
+	AllPalletsWithSystem,
+	OnRuntimeUpgrade = (),
+>(
+	PhantomData<(
+		System,
+		Block,
+		Context,
+		UnsignedValidator,
+		AllPalletsWithSystem,
+		OnRuntimeUpgrade,
+	)>,
+);
+
+impl<
+		System: frame_system::Config + EnsureInherentsAreFirst<Block>,
+		Block: traits::Block<
+			Header = frame_system::pallet_prelude::HeaderFor<System>,
+			Hash = System::Hash,
+		>,
+		Context: Default,
+		UnsignedValidator,
+		AllPalletsWithSystem: OnRuntimeUpgrade
+			+ OnInitialize<BlockNumberFor<System>>
+			+ OnIdle<BlockNumberFor<System>>
+			+ OnFinalize<BlockNumberFor<System>>
+			+ OffchainWorker<BlockNumberFor<System>>,
+		COnRuntimeUpgrade: OnRuntimeUpgrade,
+	> ExecuteBlock<Block>
+	for Executive<System, Block, Context, UnsignedValidator, AllPalletsWithSystem, COnRuntimeUpgrade>
+where
+	Block::Extrinsic: Checkable<Context> + Codec,
+	CheckedOf<Block::Extrinsic, Context>: Applyable + GetDispatchInfo,
+	CallOf<Block::Extrinsic, Context>:
+		Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	OriginOf<Block::Extrinsic, Context>: From<Option<System::AccountId>>,
+	UnsignedValidator: ValidateUnsigned<Call = CallOf<Block::Extrinsic, Context>>,
+{
+	fn execute_block(block: Block) {
+		Executive::<
+			System,
+			Block,
+			Context,
+			UnsignedValidator,
+			AllPalletsWithSystem,
+			COnRuntimeUpgrade,
+		>::execute_block(block);
+	}
+}
+
+#[cfg(feature = "try-runtime")]
+impl<
+		System: frame_system::Config + EnsureInherentsAreFirst<Block>,
+		Block: traits::Block<
+			Header = frame_system::pallet_prelude::HeaderFor<System>,
+			Hash = System::Hash,
+		>,
+		Context: Default,
+		UnsignedValidator,
+		AllPalletsWithSystem: OnRuntimeUpgrade
+			+ OnInitialize<BlockNumberFor<System>>
+			+ OnIdle<BlockNumberFor<System>>
+			+ OnFinalize<BlockNumberFor<System>>
+			+ OffchainWorker<BlockNumberFor<System>>
+			+ frame_support::traits::TryState<BlockNumberFor<System>>,
+		COnRuntimeUpgrade: OnRuntimeUpgrade,
+	> Executive<System, Block, Context, UnsignedValidator, AllPalletsWithSystem, COnRuntimeUpgrade>
+where
+	Block::Extrinsic: Checkable<Context> + Codec,
+	CheckedOf<Block::Extrinsic, Context>: Applyable + GetDispatchInfo,
+	CallOf<Block::Extrinsic, Context>:
+		Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	OriginOf<Block::Extrinsic, Context>: From<Option<System::AccountId>>,
+	UnsignedValidator: ValidateUnsigned<Call = CallOf<Block::Extrinsic, Context>>,
+{
+	/// Execute given block, but don't as strict is the normal block execution.
+	///
+	/// Some checks can be disabled via:
+	///
+	/// - `state_root_check`
+	/// - `signature_check`
+	///
+	/// Should only be used for testing ONLY.
+	pub fn try_execute_block(
+		block: Block,
+		state_root_check: bool,
+		signature_check: bool,
+		select: frame_try_runtime::TryStateSelect,
+	) -> Result<Weight, &'static str> {
+		log::info!(
+			target: LOG_TARGET,
+			"try-runtime: executing block #{:?} / state root check: {:?} / signature check: {:?} / try-state-select: {:?}",
+			block.header().number(),
+			state_root_check,
+			signature_check,
+			select,
+		);
+
+		Self::initialize_block(block.header());
+		Self::initial_checks(&block);
+
+		let (header, extrinsics) = block.deconstruct();
+
+		let try_apply_extrinsic = |uxt: Block::Extrinsic| -> ApplyExtrinsicResult {
+			sp_io::init_tracing();
+			let encoded = uxt.encode();
+			let encoded_len = encoded.len();
+
+			// skip signature verification.
+			let xt = if signature_check {
+				uxt.check(&Default::default())
+			} else {
+				uxt.unchecked_into_checked_i_know_what_i_am_doing(&Default::default())
+			}?;
+			<frame_system::Pallet<System>>::note_extrinsic(encoded);
+
+			let dispatch_info = xt.get_dispatch_info();
+			let r = Applyable::apply::<UnsignedValidator>(xt, &dispatch_info, encoded_len)?;
+
+			<frame_system::Pallet<System>>::note_applied_extrinsic(&r, dispatch_info);
+
+			Ok(r.map(|_| ()).map_err(|e| e.error))
+		};
+
+		for e in extrinsics {
+			if let Err(err) = try_apply_extrinsic(e.clone()) {
+				log::error!(
+					target: LOG_TARGET, "executing transaction {:?} failed due to {:?}. Aborting the rest of the block execution.",
+					e,
+					err,
+				);
+				break
+			}
+		}
+
+		// post-extrinsics book-keeping
+		<frame_system::Pallet<System>>::note_finished_extrinsics();
+		Self::idle_and_finalize_hook(*header.number());
+
+		// run the try-state checks of all pallets, ensuring they don't alter any state.
+		let _guard = frame_support::StorageNoopGuard::default();
+		<AllPalletsWithSystem as frame_support::traits::TryState<
+			BlockNumberFor<System>,
+		>>::try_state(*header.number(), select)
+		.map_err(|e| {
+			log::error!(target: LOG_TARGET, "failure: {:?}", e);
+			e
+		})?;
+		drop(_guard);
+
+		// do some of the checks that would normally happen in `final_checks`, but perhaps skip
+		// the state root check.
+		{
+			let new_header = <frame_system::Pallet<System>>::finalize();
+			let items_zip = header.digest().logs().iter().zip(new_header.digest().logs().iter());
+			for (header_item, computed_item) in items_zip {
+				header_item.check_equal(computed_item);
+				assert!(header_item == computed_item, "Digest item must match that calculated.");
+			}
+
+			if state_root_check {
+				let storage_root = new_header.state_root();
+				header.state_root().check_equal(storage_root);
+				assert!(
+					header.state_root() == storage_root,
+					"Storage root must match that calculated."
+				);
+			}
+
+			assert!(
+				header.extrinsics_root() == new_header.extrinsics_root(),
+				"Transaction trie root must be valid.",
+			);
+		}
+
+		log::info!(
+			target: LOG_TARGET,
+			"try-runtime: Block #{:?} successfully executed",
+			header.number(),
+		);
+
+		Ok(frame_system::Pallet::<System>::block_weight().total())
+	}
+
+	/// Execute all `OnRuntimeUpgrade` of this runtime, including the pre and post migration checks.
+	///
+	/// Runs the try-state code both before and after the migration function if `checks` is set to
+	/// `true`. Also, if set to `true`, it runs the `pre_upgrade` and `post_upgrade` hooks.
+	pub fn try_runtime_upgrade(
+		checks: frame_try_runtime::UpgradeCheckSelect,
+	) -> Result<Weight, TryRuntimeError> {
+		if checks.try_state() {
+			let _guard = frame_support::StorageNoopGuard::default();
+			<AllPalletsWithSystem as frame_support::traits::TryState<
+				BlockNumberFor<System>,
+			>>::try_state(
+				frame_system::Pallet::<System>::block_number(),
+				frame_try_runtime::TryStateSelect::All,
+			)?;
+		}
+
+		let weight =
+			<(COnRuntimeUpgrade, AllPalletsWithSystem) as OnRuntimeUpgrade>::try_on_runtime_upgrade(
+				checks.pre_and_post(),
+			)?;
+
+		if checks.try_state() {
+			let _guard = frame_support::StorageNoopGuard::default();
+			<AllPalletsWithSystem as frame_support::traits::TryState<
+				BlockNumberFor<System>,
+			>>::try_state(
+				frame_system::Pallet::<System>::block_number(),
+				frame_try_runtime::TryStateSelect::All,
+			)?;
+		}
+
+		Ok(weight)
+	}
+}
+
+impl<
+		System: frame_system::Config + EnsureInherentsAreFirst<Block>,
+		Block: traits::Block<
+			Header = frame_system::pallet_prelude::HeaderFor<System>,
+			Hash = System::Hash,
+		>,
+		Context: Default,
+		UnsignedValidator,
+		AllPalletsWithSystem: OnRuntimeUpgrade
+			+ OnInitialize<BlockNumberFor<System>>
+			+ OnIdle<BlockNumberFor<System>>
+			+ OnFinalize<BlockNumberFor<System>>
+			+ OffchainWorker<BlockNumberFor<System>>,
+		COnRuntimeUpgrade: OnRuntimeUpgrade,
+	> Executive<System, Block, Context, UnsignedValidator, AllPalletsWithSystem, COnRuntimeUpgrade>
+where
+	Block::Extrinsic: Checkable<Context> + Codec,
+	CheckedOf<Block::Extrinsic, Context>: Applyable + GetDispatchInfo,
+	CallOf<Block::Extrinsic, Context>:
+		Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	OriginOf<Block::Extrinsic, Context>: From<Option<System::AccountId>>,
+	UnsignedValidator: ValidateUnsigned<Call = CallOf<Block::Extrinsic, Context>>,
+{
+	/// Execute all `OnRuntimeUpgrade` of this runtime, and return the aggregate weight.
+	pub fn execute_on_runtime_upgrade() -> Weight {
+		<(COnRuntimeUpgrade, AllPalletsWithSystem) as OnRuntimeUpgrade>::on_runtime_upgrade()
+	}
+
+	/// Start the execution of a particular block.
+	pub fn initialize_block(header: &frame_system::pallet_prelude::HeaderFor<System>) {
+		sp_io::init_tracing();
+		sp_tracing::enter_span!(sp_tracing::Level::TRACE, "init_block");
+		let digests = Self::extract_pre_digest(header);
+		Self::initialize_block_impl(header.number(), header.parent_hash(), &digests);
+	}
+
+	fn extract_pre_digest(header: &frame_system::pallet_prelude::HeaderFor<System>) -> Digest {
+		let mut digest = <Digest>::default();
+		header.digest().logs().iter().for_each(|d| {
+			if d.as_pre_runtime().is_some() {
+				digest.push(d.clone())
+			}
+		});
+		digest
+	}
+
+	fn initialize_block_impl(
+		block_number: &BlockNumberFor<System>,
+		parent_hash: &System::Hash,
+		digest: &Digest,
+	) {
+		// Reset events before apply runtime upgrade hook.
+		// This is required to preserve events from runtime upgrade hook.
+		// This means the format of all the event related storages must always be compatible.
+		<frame_system::Pallet<System>>::reset_events();
+
+		let mut weight = Weight::zero();
+		if Self::runtime_upgraded() {
+			weight = weight.saturating_add(Self::execute_on_runtime_upgrade());
+		}
+		<frame_system::Pallet<System>>::initialize(block_number, parent_hash, digest);
+		weight = weight.saturating_add(<AllPalletsWithSystem as OnInitialize<
+			BlockNumberFor<System>,
+		>>::on_initialize(*block_number));
+		weight = weight.saturating_add(
+			<System::BlockWeights as frame_support::traits::Get<_>>::get().base_block,
+		);
+		<frame_system::Pallet<System>>::register_extra_weight_unchecked(
+			weight,
+			DispatchClass::Mandatory,
+		);
+
+		frame_system::Pallet::<System>::note_finished_initialize();
+	}
+
+	/// Returns if the runtime was upgraded since the last time this function was called.
+	fn runtime_upgraded() -> bool {
+		let last = frame_system::LastRuntimeUpgrade::<System>::get();
+		let current = <System::Version as frame_support::traits::Get<_>>::get();
+
+		if last.map(|v| v.was_upgraded(&current)).unwrap_or(true) {
+			frame_system::LastRuntimeUpgrade::<System>::put(
+				frame_system::LastRuntimeUpgradeInfo::from(current),
+			);
+			true
+		} else {
+			false
+		}
+	}
+
+	fn initial_checks(block: &Block) {
+		sp_tracing::enter_span!(sp_tracing::Level::TRACE, "initial_checks");
+		let header = block.header();
+
+		// Check that `parent_hash` is correct.
+		let n = *header.number();
+		assert!(
+			n > BlockNumberFor::<System>::zero() &&
+				<frame_system::Pallet<System>>::block_hash(n - BlockNumberFor::<System>::one()) ==
+					*header.parent_hash(),
+			"Parent hash should be valid.",
+		);
+
+		if let Err(i) = System::ensure_inherents_are_first(block) {
+			panic!("Invalid inherent position for extrinsic at index {}", i);
+		}
+	}
+
+	/// Actually execute all transitions for `block`.
+	pub fn execute_block(block: Block) {
+		sp_io::init_tracing();
+		sp_tracing::within_span! {
+			sp_tracing::info_span!("execute_block", ?block);
+
+			Self::initialize_block(block.header());
+
+			// any initial checks
+			Self::initial_checks(&block);
+
+			// execute extrinsics
+			let (header, extrinsics) = block.deconstruct();
+			Self::execute_extrinsics_with_book_keeping(extrinsics, *header.number());
+
+			// any final checks
+			Self::final_checks(&header);
+		}
+	}
+
+	/// Execute given extrinsics and take care of post-extrinsics book-keeping.
+	fn execute_extrinsics_with_book_keeping(
+		extrinsics: Vec<Block::Extrinsic>,
+		block_number: NumberFor<Block>,
+	) {
+		extrinsics.into_iter().for_each(|e| {
+			if let Err(e) = Self::apply_extrinsic(e) {
+				let err: &'static str = e.into();
+				panic!("{}", err)
+			}
+		});
+
+		// post-extrinsics book-keeping
+		<frame_system::Pallet<System>>::note_finished_extrinsics();
+
+		Self::idle_and_finalize_hook(block_number);
+	}
+
+	/// Finalize the block - it is up the caller to ensure that all header fields are valid
+	/// except state-root.
+	pub fn finalize_block() -> frame_system::pallet_prelude::HeaderFor<System> {
+		sp_io::init_tracing();
+		sp_tracing::enter_span!(sp_tracing::Level::TRACE, "finalize_block");
+		<frame_system::Pallet<System>>::note_finished_extrinsics();
+		let block_number = <frame_system::Pallet<System>>::block_number();
+
+		Self::idle_and_finalize_hook(block_number);
+
+		<frame_system::Pallet<System>>::finalize()
+	}
+
+	fn idle_and_finalize_hook(block_number: NumberFor<Block>) {
+		let weight = <frame_system::Pallet<System>>::block_weight();
+		let max_weight = <System::BlockWeights as frame_support::traits::Get<_>>::get().max_block;
+		let remaining_weight = max_weight.saturating_sub(weight.total());
+
+		if remaining_weight.all_gt(Weight::zero()) {
+			let used_weight = <AllPalletsWithSystem as OnIdle<BlockNumberFor<System>>>::on_idle(
+				block_number,
+				remaining_weight,
+			);
+			<frame_system::Pallet<System>>::register_extra_weight_unchecked(
+				used_weight,
+				DispatchClass::Mandatory,
+			);
+		}
+
+		<AllPalletsWithSystem as OnFinalize<BlockNumberFor<System>>>::on_finalize(block_number);
+	}
+
+	/// Apply extrinsic outside of the block execution function.
+	///
+	/// This doesn't attempt to validate anything regarding the block, but it builds a list of uxt
+	/// hashes.
+	pub fn apply_extrinsic(uxt: Block::Extrinsic) -> ApplyExtrinsicResult {
+		sp_io::init_tracing();
+		let encoded = uxt.encode();
+		let encoded_len = encoded.len();
+		sp_tracing::enter_span!(sp_tracing::info_span!("apply_extrinsic",
+				ext=?sp_core::hexdisplay::HexDisplay::from(&encoded)));
+		// Verify that the signature is good.
+		let xt = uxt.check(&Default::default())?;
+
+		// We don't need to make sure to `note_extrinsic` only after we know it's going to be
+		// executed to prevent it from leaking in storage since at this point, it will either
+		// execute or panic (and revert storage changes).
+		<frame_system::Pallet<System>>::note_extrinsic(encoded);
+
+		// AUDIT: Under no circumstances may this function panic from here onwards.
+
+		// Decode parameters and dispatch
+		let dispatch_info = xt.get_dispatch_info();
+		let r = Applyable::apply::<UnsignedValidator>(xt, &dispatch_info, encoded_len)?;
+
+		// Mandatory(inherents) are not allowed to fail.
+		//
+		// The entire block should be discarded if an inherent fails to apply. Otherwise
+		// it may open an attack vector.
+		if r.is_err() && dispatch_info.class == DispatchClass::Mandatory {
+			return Err(InvalidTransaction::BadMandatory.into())
+		}
+
+		<frame_system::Pallet<System>>::note_applied_extrinsic(&r, dispatch_info);
+
+		Ok(r.map(|_| ()).map_err(|e| e.error))
+	}
+
+	fn final_checks(header: &frame_system::pallet_prelude::HeaderFor<System>) {
+		sp_tracing::enter_span!(sp_tracing::Level::TRACE, "final_checks");
+		// remove temporaries
+		let new_header = <frame_system::Pallet<System>>::finalize();
+
+		// check digest
+		assert_eq!(
+			header.digest().logs().len(),
+			new_header.digest().logs().len(),
+			"Number of digest items must match that calculated."
+		);
+		let items_zip = header.digest().logs().iter().zip(new_header.digest().logs().iter());
+		for (header_item, computed_item) in items_zip {
+			header_item.check_equal(computed_item);
+			assert!(header_item == computed_item, "Digest item must match that calculated.");
+		}
+
+		// check storage root.
+		let storage_root = new_header.state_root();
+		header.state_root().check_equal(storage_root);
+		assert!(header.state_root() == storage_root, "Storage root must match that calculated.");
+
+		assert!(
+			header.extrinsics_root() == new_header.extrinsics_root(),
+			"Transaction trie root must be valid.",
+		);
+	}
+
+	/// Check a given signed transaction for validity. This doesn't execute any
+	/// side-effects; it merely checks whether the transaction would panic if it were included or
+	/// not.
+	///
+	/// Changes made to storage should be discarded.
+	pub fn validate_transaction(
+		source: TransactionSource,
+		uxt: Block::Extrinsic,
+		block_hash: Block::Hash,
+	) -> TransactionValidity {
+		sp_io::init_tracing();
+		use sp_tracing::{enter_span, within_span};
+
+		<frame_system::Pallet<System>>::initialize(
+			&(frame_system::Pallet::<System>::block_number() + One::one()),
+			&block_hash,
+			&Default::default(),
+		);
+
+		enter_span! { sp_tracing::Level::TRACE, "validate_transaction" };
+
+		let encoded_len = within_span! { sp_tracing::Level::TRACE, "using_encoded";
+			uxt.using_encoded(|d| d.len())
+		};
+
+		let xt = within_span! { sp_tracing::Level::TRACE, "check";
+			uxt.check(&Default::default())
+		}?;
+
+		let dispatch_info = within_span! { sp_tracing::Level::TRACE, "dispatch_info";
+			xt.get_dispatch_info()
+		};
+
+		if dispatch_info.class == DispatchClass::Mandatory {
+			return Err(InvalidTransaction::MandatoryValidation.into())
+		}
+
+		within_span! {
+			sp_tracing::Level::TRACE, "validate";
+			xt.validate::<UnsignedValidator>(source, &dispatch_info, encoded_len)
+		}
+	}
+
+	/// Start an offchain worker and generate extrinsics.
+	pub fn offchain_worker(header: &frame_system::pallet_prelude::HeaderFor<System>) {
+		sp_io::init_tracing();
+		// We need to keep events available for offchain workers,
+		// hence we initialize the block manually.
+		// OffchainWorker RuntimeApi should skip initialization.
+		let digests = header.digest().clone();
+
+		<frame_system::Pallet<System>>::initialize(header.number(), header.parent_hash(), &digests);
+
+		// Frame system only inserts the parent hash into the block hashes as normally we don't know
+		// the hash for the header before. However, here we are aware of the hash and we can add it
+		// as well.
+		frame_system::BlockHash::<System>::insert(header.number(), header.hash());
+
+		<AllPalletsWithSystem as OffchainWorker<BlockNumberFor<System>>>::offchain_worker(
+			*header.number(),
+		)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use sp_core::H256;
+	use sp_runtime::{
+		generic::{DigestItem, Era},
+		testing::{Block, Digest, Header},
+		traits::{BlakeTwo256, Block as BlockT, Header as HeaderT, IdentityLookup},
+		transaction_validity::{
+			InvalidTransaction, TransactionValidityError, UnknownTransaction, ValidTransaction,
+		},
+		BuildStorage, DispatchError,
+	};
+
+	use frame_support::{
+		assert_err, parameter_types,
+		traits::{fungible, ConstU32, ConstU64, ConstU8, Currency},
+		weights::{ConstantMultiplier, IdentityFee, RuntimeDbWeight, Weight, WeightToFee},
+	};
+	use frame_system::{ChainContext, LastRuntimeUpgradeInfo};
+	use pallet_balances::Call as BalancesCall;
+	use pallet_transaction_payment::CurrencyAdapter;
+
+	const TEST_KEY: &[u8] = b":test:key:";
+
+	#[frame_support::pallet(dev_mode)]
+	mod custom {
+		use frame_support::pallet_prelude::*;
+		use frame_system::pallet_prelude::*;
+
+		#[pallet::pallet]
+		pub struct Pallet<T>(_);
+
+		#[pallet::config]
+		pub trait Config: frame_system::Config {}
+
+		#[pallet::hooks]
+		impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+			// module hooks.
+			// one with block number arg and one without
+			fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+				println!("on_initialize({})", n);
+				Weight::from_parts(175, 0)
+			}
+
+			fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight {
+				println!("on_idle{}, {})", n, remaining_weight);
+				Weight::from_parts(175, 0)
+			}
+
+			fn on_finalize(n: BlockNumberFor<T>) {
+				println!("on_finalize({})", n);
+			}
+
+			fn on_runtime_upgrade() -> Weight {
+				sp_io::storage::set(super::TEST_KEY, "module".as_bytes());
+				Weight::from_parts(200, 0)
+			}
+
+			fn offchain_worker(n: BlockNumberFor<T>) {
+				assert_eq!(BlockNumberFor::<T>::from(1u32), n);
+			}
+		}
+
+		#[pallet::call]
+		impl<T: Config> Pallet<T> {
+			pub fn some_function(origin: OriginFor<T>) -> DispatchResult {
+				// NOTE: does not make any different.
+				frame_system::ensure_signed(origin)?;
+				Ok(())
+			}
+
+			#[pallet::weight((200, DispatchClass::Operational))]
+			pub fn some_root_operation(origin: OriginFor<T>) -> DispatchResult {
+				frame_system::ensure_root(origin)?;
+				Ok(())
+			}
+
+			pub fn some_unsigned_message(origin: OriginFor<T>) -> DispatchResult {
+				frame_system::ensure_none(origin)?;
+				Ok(())
+			}
+
+			pub fn allowed_unsigned(origin: OriginFor<T>) -> DispatchResult {
+				frame_system::ensure_root(origin)?;
+				Ok(())
+			}
+
+			pub fn unallowed_unsigned(origin: OriginFor<T>) -> DispatchResult {
+				frame_system::ensure_root(origin)?;
+				Ok(())
+			}
+
+			#[pallet::weight((0, DispatchClass::Mandatory))]
+			pub fn inherent_call(origin: OriginFor<T>) -> DispatchResult {
+				frame_system::ensure_none(origin)?;
+				Ok(())
+			}
+
+			pub fn calculate_storage_root(_origin: OriginFor<T>) -> DispatchResult {
+				let root = sp_io::storage::root(sp_runtime::StateVersion::V1);
+				sp_io::storage::set("storage_root".as_bytes(), &root);
+				Ok(())
+			}
+		}
+
+		#[pallet::inherent]
+		impl<T: Config> ProvideInherent for Pallet<T> {
+			type Call = Call<T>;
+
+			type Error = sp_inherents::MakeFatalError<()>;
+
+			const INHERENT_IDENTIFIER: [u8; 8] = *b"test1234";
+
+			fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+				None
+			}
+
+			fn is_inherent(call: &Self::Call) -> bool {
+				*call == Call::<T>::inherent_call {}
+			}
+		}
+
+		#[pallet::validate_unsigned]
+		impl<T: Config> ValidateUnsigned for Pallet<T> {
+			type Call = Call<T>;
+
+			// Inherent call is accepted for being dispatched
+			fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError> {
+				match call {
+					Call::allowed_unsigned { .. } => Ok(()),
+					Call::inherent_call { .. } => Ok(()),
+					_ => Err(UnknownTransaction::NoUnsignedValidator.into()),
+				}
+			}
+
+			// Inherent call is not validated as unsigned
+			fn validate_unsigned(
+				_source: TransactionSource,
+				call: &Self::Call,
+			) -> TransactionValidity {
+				match call {
+					Call::allowed_unsigned { .. } => Ok(Default::default()),
+					_ => UnknownTransaction::NoUnsignedValidator.into(),
+				}
+			}
+		}
+	}
+
+	frame_support::construct_runtime!(
+		pub struct Runtime
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+			Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+			TransactionPayment: pallet_transaction_payment::{Pallet, Storage, Event<T>},
+			Custom: custom::{Pallet, Call, ValidateUnsigned, Inherent},
+		}
+	);
+
+	parameter_types! {
+		pub BlockWeights: frame_system::limits::BlockWeights =
+			frame_system::limits::BlockWeights::builder()
+				.base_block(Weight::from_parts(10, 0))
+				.for_class(DispatchClass::all(), |weights| weights.base_extrinsic = Weight::from_parts(5, 0))
+				.for_class(DispatchClass::non_mandatory(), |weights| weights.max_total = Weight::from_parts(1024, u64::MAX).into())
+				.build_or_panic();
+		pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 10,
+			write: 100,
+		};
+	}
+	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 = sp_core::H256;
+		type Hashing = BlakeTwo256;
+		type AccountId = u64;
+		type Lookup = IdentityLookup<u64>;
+		type Block = TestBlock;
+		type RuntimeEvent = RuntimeEvent;
+		type BlockHashCount = ConstU64<250>;
+		type Version = RuntimeVersion;
+		type PalletInfo = PalletInfo;
+		type AccountData = pallet_balances::AccountData<Balance>;
+		type OnNewAccount = ();
+		type OnKilledAccount = ();
+		type SystemWeightInfo = ();
+		type SS58Prefix = ();
+		type OnSetCode = ();
+		type MaxConsumers = ConstU32<16>;
+	}
+
+	type Balance = u64;
+	impl pallet_balances::Config for Runtime {
+		type Balance = Balance;
+		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 = ConstU32<1>;
+		type RuntimeHoldReason = ();
+		type MaxHolds = ConstU32<1>;
+	}
+
+	parameter_types! {
+		pub const TransactionByteFee: Balance = 0;
+	}
+	impl pallet_transaction_payment::Config for Runtime {
+		type RuntimeEvent = RuntimeEvent;
+		type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
+		type OperationalFeeMultiplier = ConstU8<5>;
+		type WeightToFee = IdentityFee<Balance>;
+		type LengthToFee = ConstantMultiplier<Balance, TransactionByteFee>;
+		type FeeMultiplierUpdate = ();
+	}
+	impl custom::Config for Runtime {}
+
+	pub struct RuntimeVersion;
+	impl frame_support::traits::Get<sp_version::RuntimeVersion> for RuntimeVersion {
+		fn get() -> sp_version::RuntimeVersion {
+			RuntimeVersionTestValues::get().clone()
+		}
+	}
+
+	parameter_types! {
+		pub static RuntimeVersionTestValues: sp_version::RuntimeVersion =
+			Default::default();
+	}
+
+	type SignedExtra = (
+		frame_system::CheckEra<Runtime>,
+		frame_system::CheckNonce<Runtime>,
+		frame_system::CheckWeight<Runtime>,
+		pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+	);
+	type TestXt = sp_runtime::testing::TestXt<RuntimeCall, SignedExtra>;
+	type TestBlock = Block<TestXt>;
+
+	// Will contain `true` when the custom runtime logic was called.
+	const CUSTOM_ON_RUNTIME_KEY: &[u8] = b":custom:on_runtime";
+
+	struct CustomOnRuntimeUpgrade;
+	impl OnRuntimeUpgrade for CustomOnRuntimeUpgrade {
+		fn on_runtime_upgrade() -> Weight {
+			sp_io::storage::set(TEST_KEY, "custom_upgrade".as_bytes());
+			sp_io::storage::set(CUSTOM_ON_RUNTIME_KEY, &true.encode());
+			System::deposit_event(frame_system::Event::CodeUpdated);
+			Weight::from_parts(100, 0)
+		}
+	}
+
+	type Executive = super::Executive<
+		Runtime,
+		Block<TestXt>,
+		ChainContext<Runtime>,
+		Runtime,
+		AllPalletsWithSystem,
+		CustomOnRuntimeUpgrade,
+	>;
+
+	fn extra(nonce: u64, fee: Balance) -> SignedExtra {
+		(
+			frame_system::CheckEra::from(Era::Immortal),
+			frame_system::CheckNonce::from(nonce),
+			frame_system::CheckWeight::new(),
+			pallet_transaction_payment::ChargeTransactionPayment::from(fee),
+		)
+	}
+
+	fn sign_extra(who: u64, nonce: u64, fee: Balance) -> Option<(u64, SignedExtra)> {
+		Some((who, extra(nonce, fee)))
+	}
+
+	fn call_transfer(dest: u64, value: u64) -> RuntimeCall {
+		RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest, value })
+	}
+
+	#[test]
+	fn balance_transfer_dispatch_works() {
+		let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Runtime> { balances: vec![(1, 211)] }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		let xt = TestXt::new(call_transfer(2, 69), sign_extra(1, 0, 0));
+		let weight = xt.get_dispatch_info().weight +
+			<Runtime as frame_system::Config>::BlockWeights::get()
+				.get(DispatchClass::Normal)
+				.base_extrinsic;
+		let fee: Balance =
+			<Runtime as pallet_transaction_payment::Config>::WeightToFee::weight_to_fee(&weight);
+		let mut t = sp_io::TestExternalities::new(t);
+		t.execute_with(|| {
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+			let r = Executive::apply_extrinsic(xt);
+			assert!(r.is_ok());
+			assert_eq!(<pallet_balances::Pallet<Runtime>>::total_balance(&1), 142 - fee);
+			assert_eq!(<pallet_balances::Pallet<Runtime>>::total_balance(&2), 69);
+		});
+	}
+
+	fn new_test_ext(balance_factor: Balance) -> sp_io::TestExternalities {
+		let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Runtime> { balances: vec![(1, 111 * balance_factor)] }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		t.into()
+	}
+
+	fn new_test_ext_v0(balance_factor: Balance) -> sp_io::TestExternalities {
+		let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Runtime> { balances: vec![(1, 111 * balance_factor)] }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		(t, sp_runtime::StateVersion::V0).into()
+	}
+
+	#[test]
+	fn block_import_works() {
+		block_import_works_inner(
+			new_test_ext_v0(1),
+			array_bytes::hex_n_into_unchecked(
+				"65e953676859e7a33245908af7ad3637d6861eb90416d433d485e95e2dd174a1",
+			),
+		);
+		block_import_works_inner(
+			new_test_ext(1),
+			array_bytes::hex_n_into_unchecked(
+				"5a19b3d6fdb7241836349fdcbe2d9df4d4f945b949d979e31ad50bff1cbcd1c2",
+			),
+		);
+	}
+	fn block_import_works_inner(mut ext: sp_io::TestExternalities, state_root: H256) {
+		ext.execute_with(|| {
+			Executive::execute_block(Block {
+				header: Header {
+					parent_hash: [69u8; 32].into(),
+					number: 1,
+					state_root,
+					extrinsics_root: array_bytes::hex_n_into_unchecked(
+						"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314",
+					),
+					digest: Digest { logs: vec![] },
+				},
+				extrinsics: vec![],
+			});
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn block_import_of_bad_state_root_fails() {
+		new_test_ext(1).execute_with(|| {
+			Executive::execute_block(Block {
+				header: Header {
+					parent_hash: [69u8; 32].into(),
+					number: 1,
+					state_root: [0u8; 32].into(),
+					extrinsics_root: array_bytes::hex_n_into_unchecked(
+						"03170a2e7597b7b7e3d84c05391d139a62b157e78786d8c082f29dcf4c111314",
+					),
+					digest: Digest { logs: vec![] },
+				},
+				extrinsics: vec![],
+			});
+		});
+	}
+
+	#[test]
+	#[should_panic]
+	fn block_import_of_bad_extrinsic_root_fails() {
+		new_test_ext(1).execute_with(|| {
+			Executive::execute_block(Block {
+				header: Header {
+					parent_hash: [69u8; 32].into(),
+					number: 1,
+					state_root: array_bytes::hex_n_into_unchecked(
+						"75e7d8f360d375bbe91bcf8019c01ab6362448b4a89e3b329717eb9d910340e5",
+					),
+					extrinsics_root: [0u8; 32].into(),
+					digest: Digest { logs: vec![] },
+				},
+				extrinsics: vec![],
+			});
+		});
+	}
+
+	#[test]
+	fn bad_extrinsic_not_inserted() {
+		let mut t = new_test_ext(1);
+		// bad nonce check!
+		let xt = TestXt::new(call_transfer(33, 69), sign_extra(1, 30, 0));
+		t.execute_with(|| {
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+			assert_err!(
+				Executive::apply_extrinsic(xt),
+				TransactionValidityError::Invalid(InvalidTransaction::Future)
+			);
+			assert_eq!(<frame_system::Pallet<Runtime>>::extrinsic_index(), Some(0));
+		});
+	}
+
+	#[test]
+	fn block_weight_limit_enforced() {
+		let mut t = new_test_ext(10000);
+		// given: TestXt uses the encoded len as fixed Len:
+		let xt = TestXt::new(
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 33, value: 0 }),
+			sign_extra(1, 0, 0),
+		);
+		let encoded = xt.encode();
+		let encoded_len = encoded.len() as u64;
+		// on_initialize weight + base block execution weight
+		let block_weights = <Runtime as frame_system::Config>::BlockWeights::get();
+		let base_block_weight = Weight::from_parts(175, 0) + block_weights.base_block;
+		let limit = block_weights.get(DispatchClass::Normal).max_total.unwrap() - base_block_weight;
+		let num_to_exhaust_block = limit.ref_time() / (encoded_len + 5);
+		t.execute_with(|| {
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+			// Base block execution weight + `on_initialize` weight from the custom module.
+			assert_eq!(<frame_system::Pallet<Runtime>>::block_weight().total(), base_block_weight);
+
+			for nonce in 0..=num_to_exhaust_block {
+				let xt = TestXt::new(
+					RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+						dest: 33,
+						value: 0,
+					}),
+					sign_extra(1, nonce.into(), 0),
+				);
+				let res = Executive::apply_extrinsic(xt);
+				if nonce != num_to_exhaust_block {
+					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,
+					);
+					assert_eq!(
+						<frame_system::Pallet<Runtime>>::extrinsic_index(),
+						Some(nonce as u32 + 1)
+					);
+				} else {
+					assert_eq!(res, Err(InvalidTransaction::ExhaustsResources.into()));
+				}
+			}
+		});
+	}
+
+	#[test]
+	fn block_weight_and_size_is_stored_per_tx() {
+		let xt = TestXt::new(
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 33, value: 0 }),
+			sign_extra(1, 0, 0),
+		);
+		let x1 = TestXt::new(
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 33, value: 0 }),
+			sign_extra(1, 1, 0),
+		);
+		let x2 = TestXt::new(
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 33, value: 0 }),
+			sign_extra(1, 2, 0),
+		);
+		let len = xt.clone().encode().len() as u32;
+		let mut t = new_test_ext(1);
+		t.execute_with(|| {
+			// Block execution weight + on_initialize weight from custom module
+			let base_block_weight = Weight::from_parts(175, 0) +
+				<Runtime as frame_system::Config>::BlockWeights::get().base_block;
+
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			assert_eq!(<frame_system::Pallet<Runtime>>::block_weight().total(), base_block_weight);
+			assert_eq!(<frame_system::Pallet<Runtime>>::all_extrinsics_len(), 0);
+
+			assert!(Executive::apply_extrinsic(xt.clone()).unwrap().is_ok());
+			assert!(Executive::apply_extrinsic(x1.clone()).unwrap().is_ok());
+			assert!(Executive::apply_extrinsic(x2.clone()).unwrap().is_ok());
+
+			// default weight for `TestXt` == encoded length.
+			let extrinsic_weight = Weight::from_parts(len as u64, 0) +
+				<Runtime as frame_system::Config>::BlockWeights::get()
+					.get(DispatchClass::Normal)
+					.base_extrinsic;
+			assert_eq!(
+				<frame_system::Pallet<Runtime>>::block_weight().total(),
+				base_block_weight + 3u64 * extrinsic_weight,
+			);
+			assert_eq!(<frame_system::Pallet<Runtime>>::all_extrinsics_len(), 3 * len);
+
+			let _ = <frame_system::Pallet<Runtime>>::finalize();
+			// All extrinsics length cleaned on `System::finalize`
+			assert_eq!(<frame_system::Pallet<Runtime>>::all_extrinsics_len(), 0);
+
+			// New Block
+			Executive::initialize_block(&Header::new(
+				2,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			// Block weight cleaned up on `System::initialize`
+			assert_eq!(<frame_system::Pallet<Runtime>>::block_weight().total(), base_block_weight);
+		});
+	}
+
+	#[test]
+	fn validate_unsigned() {
+		let valid = TestXt::new(RuntimeCall::Custom(custom::Call::allowed_unsigned {}), None);
+		let invalid = TestXt::new(RuntimeCall::Custom(custom::Call::unallowed_unsigned {}), None);
+		let mut t = new_test_ext(1);
+
+		t.execute_with(|| {
+			assert_eq!(
+				Executive::validate_transaction(
+					TransactionSource::InBlock,
+					valid.clone(),
+					Default::default(),
+				),
+				Ok(ValidTransaction::default()),
+			);
+			assert_eq!(
+				Executive::validate_transaction(
+					TransactionSource::InBlock,
+					invalid.clone(),
+					Default::default(),
+				),
+				Err(TransactionValidityError::Unknown(UnknownTransaction::NoUnsignedValidator)),
+			);
+			assert_eq!(Executive::apply_extrinsic(valid), Ok(Err(DispatchError::BadOrigin)));
+			assert_eq!(
+				Executive::apply_extrinsic(invalid),
+				Err(TransactionValidityError::Unknown(UnknownTransaction::NoUnsignedValidator))
+			);
+		});
+	}
+
+	#[test]
+	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();
+			let xt = TestXt::new(
+				RuntimeCall::System(frame_system::Call::remark { remark: vec![1u8] }),
+				sign_extra(1, 0, 0),
+			);
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			assert_eq!(Executive::apply_extrinsic(xt), Err(InvalidTransaction::Payment.into()),);
+			assert_eq!(<pallet_balances::Pallet<Runtime>>::total_balance(&1), 111);
+		});
+	}
+
+	#[test]
+	fn block_hooks_weight_is_stored() {
+		new_test_ext(1).execute_with(|| {
+			Executive::initialize_block(&Header::new_from_number(1));
+			Executive::finalize_block();
+			// NOTE: might need updates over time if new weights are introduced.
+			// For now it only accounts for the base block execution weight and
+			// the `on_initialize` weight defined in the custom test module.
+			assert_eq!(
+				<frame_system::Pallet<Runtime>>::block_weight().total(),
+				Weight::from_parts(175 + 175 + 10, 0)
+			);
+		})
+	}
+
+	#[test]
+	fn runtime_upgraded_should_work() {
+		new_test_ext(1).execute_with(|| {
+			RuntimeVersionTestValues::mutate(|v| *v = Default::default());
+			// It should be added at genesis
+			assert!(frame_system::LastRuntimeUpgrade::<Runtime>::exists());
+			assert!(!Executive::runtime_upgraded());
+
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }
+			});
+			assert!(Executive::runtime_upgraded());
+			assert_eq!(
+				Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "".into() }),
+				frame_system::LastRuntimeUpgrade::<Runtime>::get(),
+			);
+
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion {
+					spec_version: 1,
+					spec_name: "test".into(),
+					..Default::default()
+				}
+			});
+			assert!(Executive::runtime_upgraded());
+			assert_eq!(
+				Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "test".into() }),
+				frame_system::LastRuntimeUpgrade::<Runtime>::get(),
+			);
+
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion {
+					spec_version: 1,
+					spec_name: "test".into(),
+					impl_version: 2,
+					..Default::default()
+				}
+			});
+			assert!(!Executive::runtime_upgraded());
+
+			frame_system::LastRuntimeUpgrade::<Runtime>::take();
+			assert!(Executive::runtime_upgraded());
+			assert_eq!(
+				Some(LastRuntimeUpgradeInfo { spec_version: 1.into(), spec_name: "test".into() }),
+				frame_system::LastRuntimeUpgrade::<Runtime>::get(),
+			);
+		})
+	}
+
+	#[test]
+	fn last_runtime_upgrade_was_upgraded_works() {
+		let test_data = vec![
+			(0, "", 1, "", true),
+			(1, "", 1, "", false),
+			(1, "", 1, "test", true),
+			(1, "", 0, "", false),
+			(1, "", 0, "test", true),
+		];
+
+		for (spec_version, spec_name, c_spec_version, c_spec_name, result) in test_data {
+			let current = sp_version::RuntimeVersion {
+				spec_version: c_spec_version,
+				spec_name: c_spec_name.into(),
+				..Default::default()
+			};
+
+			let last = LastRuntimeUpgradeInfo {
+				spec_version: spec_version.into(),
+				spec_name: spec_name.into(),
+			};
+
+			assert_eq!(result, last.was_upgraded(&current));
+		}
+	}
+
+	#[test]
+	fn custom_runtime_upgrade_is_called_before_modules() {
+		new_test_ext(1).execute_with(|| {
+			// Make sure `on_runtime_upgrade` is called.
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }
+			});
+
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			assert_eq!(&sp_io::storage::get(TEST_KEY).unwrap()[..], *b"module");
+			assert_eq!(sp_io::storage::get(CUSTOM_ON_RUNTIME_KEY).unwrap(), true.encode());
+		});
+	}
+
+	#[test]
+	fn event_from_runtime_upgrade_is_included() {
+		new_test_ext(1).execute_with(|| {
+			// Make sure `on_runtime_upgrade` is called.
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }
+			});
+
+			// set block number to non zero so events are not excluded
+			System::set_block_number(1);
+
+			Executive::initialize_block(&Header::new(
+				2,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			System::assert_last_event(frame_system::Event::<Runtime>::CodeUpdated.into());
+		});
+	}
+
+	/// Regression test that ensures that the custom on runtime upgrade is called when executive is
+	/// used through the `ExecuteBlock` trait.
+	#[test]
+	fn custom_runtime_upgrade_is_called_when_using_execute_block_trait() {
+		let xt = TestXt::new(
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 33, value: 0 }),
+			sign_extra(1, 0, 0),
+		);
+
+		let header = new_test_ext(1).execute_with(|| {
+			// Make sure `on_runtime_upgrade` is called.
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }
+			});
+
+			// Let's build some fake block.
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			Executive::apply_extrinsic(xt.clone()).unwrap().unwrap();
+
+			Executive::finalize_block()
+		});
+
+		// Reset to get the correct new genesis below.
+		RuntimeVersionTestValues::mutate(|v| {
+			*v = sp_version::RuntimeVersion { spec_version: 0, ..Default::default() }
+		});
+
+		new_test_ext(1).execute_with(|| {
+			// Make sure `on_runtime_upgrade` is called.
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }
+			});
+
+			<Executive as ExecuteBlock<Block<TestXt>>>::execute_block(Block::new(header, vec![xt]));
+
+			assert_eq!(&sp_io::storage::get(TEST_KEY).unwrap()[..], *b"module");
+			assert_eq!(sp_io::storage::get(CUSTOM_ON_RUNTIME_KEY).unwrap(), true.encode());
+		});
+	}
+
+	#[test]
+	fn all_weights_are_recorded_correctly() {
+		new_test_ext(1).execute_with(|| {
+			// Make sure `on_runtime_upgrade` is called for maximum complexity
+			RuntimeVersionTestValues::mutate(|v| {
+				*v = sp_version::RuntimeVersion { spec_version: 1, ..Default::default() }
+			});
+
+			let block_number = 1;
+
+			Executive::initialize_block(&Header::new(
+				block_number,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			// All weights that show up in the `initialize_block_impl`
+			let custom_runtime_upgrade_weight = CustomOnRuntimeUpgrade::on_runtime_upgrade();
+			let runtime_upgrade_weight =
+				<AllPalletsWithSystem as OnRuntimeUpgrade>::on_runtime_upgrade();
+			let on_initialize_weight =
+				<AllPalletsWithSystem as OnInitialize<u64>>::on_initialize(block_number);
+			let base_block_weight =
+				<Runtime as frame_system::Config>::BlockWeights::get().base_block;
+
+			// Weights are recorded correctly
+			assert_eq!(
+				frame_system::Pallet::<Runtime>::block_weight().total(),
+				custom_runtime_upgrade_weight +
+					runtime_upgrade_weight +
+					on_initialize_weight + base_block_weight,
+			);
+		});
+	}
+
+	#[test]
+	fn offchain_worker_works_as_expected() {
+		new_test_ext(1).execute_with(|| {
+			let parent_hash = sp_core::H256::from([69u8; 32]);
+			let mut digest = Digest::default();
+			digest.push(DigestItem::Seal([1, 2, 3, 4], vec![5, 6, 7, 8]));
+
+			let header =
+				Header::new(1, H256::default(), H256::default(), parent_hash, digest.clone());
+
+			Executive::offchain_worker(&header);
+
+			assert_eq!(digest, System::digest());
+			assert_eq!(parent_hash, System::block_hash(0));
+			assert_eq!(header.hash(), System::block_hash(1));
+		});
+	}
+
+	#[test]
+	fn calculating_storage_root_twice_works() {
+		let call = RuntimeCall::Custom(custom::Call::calculate_storage_root {});
+		let xt = TestXt::new(call, sign_extra(1, 0, 0));
+
+		let header = new_test_ext(1).execute_with(|| {
+			// Let's build some fake block.
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			Executive::apply_extrinsic(xt.clone()).unwrap().unwrap();
+
+			Executive::finalize_block()
+		});
+
+		new_test_ext(1).execute_with(|| {
+			Executive::execute_block(Block::new(header, vec![xt]));
+		});
+	}
+
+	#[test]
+	#[should_panic(expected = "Invalid inherent position for extrinsic at index 1")]
+	fn invalid_inherent_position_fail() {
+		let xt1 = TestXt::new(
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 33, value: 0 }),
+			sign_extra(1, 0, 0),
+		);
+		let xt2 = TestXt::new(RuntimeCall::Custom(custom::Call::inherent_call {}), None);
+
+		let header = new_test_ext(1).execute_with(|| {
+			// Let's build some fake block.
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			Executive::apply_extrinsic(xt1.clone()).unwrap().unwrap();
+			Executive::apply_extrinsic(xt2.clone()).unwrap().unwrap();
+
+			Executive::finalize_block()
+		});
+
+		new_test_ext(1).execute_with(|| {
+			Executive::execute_block(Block::new(header, vec![xt1, xt2]));
+		});
+	}
+
+	#[test]
+	fn valid_inherents_position_works() {
+		let xt1 = TestXt::new(RuntimeCall::Custom(custom::Call::inherent_call {}), None);
+		let xt2 = TestXt::new(call_transfer(33, 0), sign_extra(1, 0, 0));
+
+		let header = new_test_ext(1).execute_with(|| {
+			// Let's build some fake block.
+			Executive::initialize_block(&Header::new(
+				1,
+				H256::default(),
+				H256::default(),
+				[69u8; 32].into(),
+				Digest::default(),
+			));
+
+			Executive::apply_extrinsic(xt1.clone()).unwrap().unwrap();
+			Executive::apply_extrinsic(xt2.clone()).unwrap().unwrap();
+
+			Executive::finalize_block()
+		});
+
+		new_test_ext(1).execute_with(|| {
+			Executive::execute_block(Block::new(header, vec![xt1, xt2]));
+		});
+	}
+
+	#[test]
+	#[should_panic(expected = "A call was labelled as mandatory, but resulted in an Error.")]
+	fn invalid_inherents_fail_block_execution() {
+		let xt1 =
+			TestXt::new(RuntimeCall::Custom(custom::Call::inherent_call {}), sign_extra(1, 0, 0));
+
+		new_test_ext(1).execute_with(|| {
+			Executive::execute_block(Block::new(
+				Header::new(
+					1,
+					H256::default(),
+					H256::default(),
+					[69u8; 32].into(),
+					Digest::default(),
+				),
+				vec![xt1],
+			));
+		});
+	}
+
+	// Inherents are created by the runtime and don't need to be validated.
+	#[test]
+	fn inherents_fail_validate_block() {
+		let xt1 = TestXt::new(RuntimeCall::Custom(custom::Call::inherent_call {}), None);
+
+		new_test_ext(1).execute_with(|| {
+			assert_eq!(
+				Executive::validate_transaction(TransactionSource::External, xt1, H256::random())
+					.unwrap_err(),
+				InvalidTransaction::MandatoryValidation.into()
+			);
+		})
+	}
+}
diff --git a/substrate/frame/fast-unstake/Cargo.toml b/substrate/frame/fast-unstake/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6e67253f762f7497464e3a8b60bd8180b9060c53
--- /dev/null
+++ b/substrate/frame/fast-unstake/Cargo.toml
@@ -0,0 +1,80 @@
+[package]
+name = "pallet-fast-unstake"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME fast unstake pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-staking = { default-features = false, path = "../../primitives/staking" }
+frame-election-provider-support = { default-features = false, path = "../election-provider-support" }
+
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+
+docify = "0.2.1"
+
+[dev-dependencies]
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../staking/reward-curve" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+substrate-test-utils = { version = "4.0.0-dev", path = "../../test-utils" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+pallet-staking = { path = "../staking" }
+pallet-balances = { path = "../balances" }
+pallet-timestamp = { path = "../timestamp" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+	"sp-tracing/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-staking/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/fast-unstake/src/benchmarking.rs b/substrate/frame/fast-unstake/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5ec997e8eaa2ae8acd452cdb158799e3dcca7635
--- /dev/null
+++ b/substrate/frame/fast-unstake/src/benchmarking.rs
@@ -0,0 +1,202 @@
+// 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.
+
+//! Benchmarking for pallet-fast-unstake.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::{types::*, Pallet as FastUnstake, *};
+use frame_benchmarking::v1::{benchmarks, whitelist_account, BenchmarkError};
+use frame_support::{
+	assert_ok,
+	traits::{Currency, EnsureOrigin, Get, Hooks},
+};
+use frame_system::RawOrigin;
+use sp_runtime::traits::Zero;
+use sp_staking::{EraIndex, StakingInterface};
+use sp_std::prelude::*;
+
+const USER_SEED: u32 = 0;
+
+type CurrencyOf<T> = <T as Config>::Currency;
+
+fn create_unexposed_batch<T: Config>(batch_size: u32) -> Vec<T::AccountId> {
+	(0..batch_size)
+		.map(|i| {
+			let account =
+				frame_benchmarking::account::<T::AccountId>("unexposed_nominator", i, USER_SEED);
+			fund_and_bond_account::<T>(&account);
+			account
+		})
+		.collect()
+}
+
+fn fund_and_bond_account<T: Config>(account: &T::AccountId) {
+	let stake = CurrencyOf::<T>::minimum_balance() * 100u32.into();
+	CurrencyOf::<T>::make_free_balance_be(&account, stake * 10u32.into());
+
+	// bond and nominate ourselves, this will guarantee that we are not backing anyone.
+	assert_ok!(T::Staking::bond(account, stake, account));
+	assert_ok!(T::Staking::nominate(account, vec![account.clone()]));
+}
+
+pub(crate) fn fast_unstake_events<T: Config>() -> Vec<crate::Event<T>> {
+	frame_system::Pallet::<T>::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| <T as Config>::RuntimeEvent::from(e).try_into().ok())
+		.collect::<Vec<_>>()
+}
+
+fn setup_staking<T: Config>(v: u32, until: EraIndex) {
+	let ed = CurrencyOf::<T>::minimum_balance();
+
+	log!(debug, "registering {} validators and {} eras.", v, until);
+
+	// our validators don't actually need to registered in staking -- just generate `v` random
+	// accounts.
+	let validators = (0..v)
+		.map(|x| frame_benchmarking::account::<T::AccountId>("validator", x, USER_SEED))
+		.collect::<Vec<_>>();
+
+	for era in 0..=until {
+		let others = (0..T::MaxBackersPerValidator::get())
+			.map(|s| {
+				let who = frame_benchmarking::account::<T::AccountId>("nominator", era, s);
+				let value = ed;
+				(who, value)
+			})
+			.collect::<Vec<_>>();
+		validators.iter().for_each(|v| {
+			T::Staking::add_era_stakers(&era, &v, others.clone());
+		});
+	}
+}
+
+fn on_idle_full_block<T: Config>() {
+	let remaining_weight = <T as frame_system::Config>::BlockWeights::get().max_block;
+	FastUnstake::<T>::on_idle(Zero::zero(), remaining_weight);
+}
+
+benchmarks! {
+	// on_idle, we don't check anyone, but fully unbond them.
+	on_idle_unstake {
+		let b in 1 .. T::BatchSize::get();
+
+		ErasToCheckPerBlock::<T>::put(1);
+		for who in create_unexposed_batch::<T>(b).into_iter() {
+			assert_ok!(FastUnstake::<T>::register_fast_unstake(
+				RawOrigin::Signed(who.clone()).into(),
+			));
+		}
+
+		// run on_idle once. This will check era 0.
+		assert_eq!(Head::<T>::get(), None);
+		on_idle_full_block::<T>();
+
+		assert!(matches!(
+			Head::<T>::get(),
+			Some(UnstakeRequest {
+				checked,
+				stashes,
+				..
+			}) if checked.len() == 1 && stashes.len() as u32 == b
+		));
+	}
+	: {
+		on_idle_full_block::<T>();
+	}
+	verify {
+		assert!(matches!(
+			fast_unstake_events::<T>().last(),
+			Some(Event::BatchFinished { size: b })
+		));
+	}
+
+	// on_idle, when we check some number of eras and the queue is already set.
+	on_idle_check {
+		let v in 1 .. 256;
+		let b in 1 .. T::BatchSize::get();
+		let u = T::MaxErasToCheckPerBlock::get().min(T::Staking::bonding_duration());
+
+		ErasToCheckPerBlock::<T>::put(u);
+		T::Staking::set_current_era(u);
+
+		// setup staking with v validators and u eras of data (0..=u+1)
+		setup_staking::<T>(v, u);
+
+		let stashes = create_unexposed_batch::<T>(b).into_iter().map(|s| {
+			assert_ok!(FastUnstake::<T>::register_fast_unstake(
+				RawOrigin::Signed(s.clone()).into(),
+			));
+			(s, T::Deposit::get())
+		}).collect::<Vec<_>>();
+
+		// no one is queued thus far.
+		assert_eq!(Head::<T>::get(), None);
+
+		Head::<T>::put(UnstakeRequest { stashes: stashes.clone().try_into().unwrap(), checked: Default::default() });
+	}
+	: {
+		on_idle_full_block::<T>();
+	}
+	verify {
+		let checked = (1..=u).rev().collect::<Vec<EraIndex>>();
+		let request = Head::<T>::get().unwrap();
+		assert_eq!(checked, request.checked.into_inner());
+		assert!(matches!(
+			fast_unstake_events::<T>().last(),
+			Some(Event::BatchChecked { .. })
+		));
+		assert!(stashes.iter().all(|(s, _)| request.stashes.iter().find(|(ss, _)| ss == s).is_some()));
+	}
+
+	register_fast_unstake {
+		ErasToCheckPerBlock::<T>::put(1);
+		let who = create_unexposed_batch::<T>(1).get(0).cloned().unwrap();
+		whitelist_account!(who);
+		assert_eq!(Queue::<T>::count(), 0);
+
+	}
+	:_(RawOrigin::Signed(who.clone()))
+	verify {
+		assert_eq!(Queue::<T>::count(), 1);
+	}
+
+	deregister {
+		ErasToCheckPerBlock::<T>::put(1);
+		let who = create_unexposed_batch::<T>(1).get(0).cloned().unwrap();
+		assert_ok!(FastUnstake::<T>::register_fast_unstake(
+			RawOrigin::Signed(who.clone()).into(),
+		));
+		assert_eq!(Queue::<T>::count(), 1);
+		whitelist_account!(who);
+	}
+	:_(RawOrigin::Signed(who.clone()))
+	verify {
+		assert_eq!(Queue::<T>::count(), 0);
+	}
+
+	control {
+		let origin = <T as Config>::ControlOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+	}
+	: _<T::RuntimeOrigin>(origin, T::MaxErasToCheckPerBlock::get())
+	verify {}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::ExtBuilder::default().build(), crate::mock::Runtime)
+}
diff --git a/substrate/frame/fast-unstake/src/lib.rs b/substrate/frame/fast-unstake/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..39783271e6569381de242a92b6a7213e7c2d6227
--- /dev/null
+++ b/substrate/frame/fast-unstake/src/lib.rs
@@ -0,0 +1,632 @@
+// 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.
+
+//! > Made with *Substrate*, for *Polkadot*.
+//!
+//! [![github]](https://github.com/paritytech/substrate/frame/fast-unstake) -
+//! [![polkadot]](https://polkadot.network)
+//!
+//! [polkadot]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//!
+//! # Fast Unstake Pallet
+//!
+//! A pallet to allow participants of the staking system (represented by [`Config::Staking`], being
+//! [`StakingInterface`]) to unstake quicker, if and only if they meet the condition of not being
+//! exposed to any slashes.
+//!
+//! ## Overview
+//!
+//! If a nominator is not exposed anywhere in the staking system, checked via
+//! [`StakingInterface::is_exposed_in_era`] (i.e. "has not actively backed any validators in the
+//! last [`StakingInterface::bonding_duration`] days"), then they can register themselves in this
+//! pallet and unstake faster than having to wait an entire bonding duration.
+//!
+//! *Being exposed with validator* from the point of view of the staking system means earning
+//! rewards with the validator, and also being at the risk of slashing with the validator. This is
+//! equivalent to the "Active Nominator" role explained in
+//! [here](https://polkadot.network/blog/staking-update-february-2022/).
+//!
+//! Stakers who are certain about NOT being exposed can register themselves with
+//! [`Pallet::register_fast_unstake`]. This will chill, fully unbond the staker and place them
+//! in the queue to be checked.
+//!
+//! A successful registration implies being fully unbonded and chilled in the staking system. These
+//! effects persist even if the fast-unstake registration is retracted (see [`Pallet::deregister`]
+//! and further).
+//!
+//! Once registered as a fast-unstaker, the staker will be queued and checked by the system. This
+//! can take a variable number of blocks based on demand, but will almost certainly be "faster" (as
+//! the name suggest) than waiting the standard bonding duration.
+//!
+//! A fast-unstaker is either in [`Queue`] or actively being checked, at which point it lives in
+//! [`Head`]. Once in [`Head`], the request cannot be retracted anymore. But, once in [`Queue`], it
+//! can, via [`Pallet::deregister`].
+//!
+//! A deposit equal to [`Config::Deposit`] is collected for this process, and is returned in case a
+//! successful unstake occurs (`Event::Unstaked` signals that).
+//!
+//! Once processed, if successful, no additional fee for the checking process is taken, and the
+//! staker is instantly unbonded.
+//!
+//! If unsuccessful, meaning that the staker was exposed, the aforementioned deposit will be slashed
+//! for the amount of wasted work they have inflicted on the chain.
+//!
+//! All in all, this pallet is meant to provide an easy off-ramp for some stakers.
+//!
+//! ### Example
+//!
+//! 1. Fast-unstake with multiple participants in the queue.
+#![doc = docify::embed!("src/tests.rs", successful_multi_queue)]
+//!
+//! 2. Fast unstake failing because a nominator is exposed.
+#![doc = docify::embed!("src/tests.rs", exposed_nominator_cannot_unstake)]
+//!
+//! ## 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.
+//!
+//! ## Low Level / Implementation Details
+//!
+//! This pallet works off the basis of `on_idle`, meaning that it provides no guarantee about when
+//! it will succeed, if at all. Moreover, the queue implementation is unordered. In case of
+//! congestion, no FIFO ordering is provided.
+//!
+//! A few important considerations can be concluded based on the `on_idle`-based implementation:
+//!
+//! * It is crucial for the weights of this pallet to be correct. The code inside
+//! [`Pallet::on_idle`] MUST be able to measure itself and report the remaining weight correctly
+//! after execution.
+//!
+//! * If the weight measurement is incorrect, it can lead to perpetual overweight (consequently
+//!   slow) blocks.
+//!
+//! * The amount of weight that `on_idle` consumes is a direct function of [`ErasToCheckPerBlock`].
+//!
+//! * Thus, a correct value of [`ErasToCheckPerBlock`] (which can be set via [`Pallet::control`])
+//!   should be chosen, such that a reasonable amount of weight is used `on_idle`. If
+//!   [`ErasToCheckPerBlock`] is too large, `on_idle` will always conclude that it has not enough
+//!   weight to proceed, and will early-return. Nonetheless, this should also be *safe* as long as
+//!   the benchmarking/weights are *accurate*.
+//!
+//! * See the inline code-comments on `do_on_idle` (private) for more details.
+//!
+//! * For further safety, in case of any unforeseen errors, the pallet will emit
+//!   [`Event::InternalError`] and set [`ErasToCheckPerBlock`] back to 0, which essentially means
+//!   the pallet will halt/disable itself.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+// NOTE: enable benchmarking in tests as well.
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod migrations;
+pub mod types;
+pub mod weights;
+
+// some extra imports for docs to link properly.
+#[cfg(doc)]
+pub use frame_support::traits::Hooks;
+#[cfg(doc)]
+pub use sp_staking::StakingInterface;
+
+/// The logging target of this pallet.
+pub const LOG_TARGET: &'static str = "runtime::fast-unstake";
+
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: crate::LOG_TARGET,
+			concat!("[{:?}] 💨 ", $patter), <frame_system::Pallet<T>>::block_number() $(, $values)*
+		)
+	};
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use crate::types::*;
+	use frame_support::{
+		pallet_prelude::*,
+		traits::{Defensive, ReservableCurrency, StorageVersion},
+	};
+	use frame_system::pallet_prelude::*;
+	use sp_runtime::{traits::Zero, DispatchResult};
+	use sp_staking::{EraIndex, StakingInterface};
+	use sp_std::{prelude::*, vec::Vec};
+	pub use weights::WeightInfo;
+
+	#[cfg(feature = "try-runtime")]
+	use sp_runtime::TryRuntimeError;
+
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>
+			+ TryInto<Event<Self>>;
+
+		/// The currency used for deposits.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// Deposit to take for unstaking, to make sure we're able to slash the it in order to cover
+		/// the costs of resources on unsuccessful unstake.
+		#[pallet::constant]
+		type Deposit: Get<BalanceOf<Self>>;
+
+		/// The origin that can control this pallet, in other words invoke [`Pallet::control`].
+		type ControlOrigin: frame_support::traits::EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Batch size.
+		///
+		/// This many stashes are processed in each unstake request.
+		type BatchSize: Get<u32>;
+
+		/// The access to staking functionality.
+		type Staking: StakingInterface<Balance = BalanceOf<Self>, AccountId = Self::AccountId>;
+
+		/// Maximum value for `ErasToCheckPerBlock`, checked in [`Pallet::control`].
+		///
+		/// This should be slightly bigger than the actual value in order to have accurate
+		/// benchmarks.
+		type MaxErasToCheckPerBlock: Get<u32>;
+
+		/// The weight information of this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Use only for benchmarking.
+		#[cfg(feature = "runtime-benchmarks")]
+		type MaxBackersPerValidator: Get<u32>;
+	}
+
+	/// The current "head of the queue" being unstaked.
+	///
+	/// The head in itself can be a batch of up to [`Config::BatchSize`] stakers.
+	#[pallet::storage]
+	pub type Head<T: Config> = StorageValue<_, UnstakeRequest<T>, OptionQuery>;
+
+	/// The map of all accounts wishing to be unstaked.
+	///
+	/// Keeps track of `AccountId` wishing to unstake and it's corresponding deposit.
+	// Hasher: Twox safe since `AccountId` is a secure hash.
+	#[pallet::storage]
+	pub type Queue<T: Config> = CountedStorageMap<_, Twox64Concat, T::AccountId, BalanceOf<T>>;
+
+	/// Number of eras to check per block.
+	///
+	/// If set to 0, this pallet does absolutely nothing. Cannot be set to more than
+	/// [`Config::MaxErasToCheckPerBlock`].
+	///
+	/// Based on the amount of weight available at [`Pallet::on_idle`], up to this many eras are
+	/// checked. The checking is represented by updating [`UnstakeRequest::checked`], which is
+	/// stored in [`Head`].
+	#[pallet::storage]
+	#[pallet::getter(fn eras_to_check_per_block)]
+	pub type ErasToCheckPerBlock<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A staker was unstaked.
+		Unstaked { stash: T::AccountId, result: DispatchResult },
+		/// A staker was slashed for requesting fast-unstake whilst being exposed.
+		Slashed { stash: T::AccountId, amount: BalanceOf<T> },
+		/// A batch was partially checked for the given eras, but the process did not finish.
+		BatchChecked { eras: Vec<EraIndex> },
+		/// A batch of a given size was terminated.
+		///
+		/// This is always follows by a number of `Unstaked` or `Slashed` events, marking the end
+		/// of the batch. A new batch will be created upon next block.
+		BatchFinished { size: u32 },
+		/// An internal error happened. Operations will be paused now.
+		InternalError,
+	}
+
+	#[pallet::error]
+	#[cfg_attr(test, derive(PartialEq))]
+	pub enum Error<T> {
+		/// The provided Controller account was not found.
+		///
+		/// This means that the given account is not bonded.
+		NotController,
+		/// The bonded account has already been queued.
+		AlreadyQueued,
+		/// The bonded account has active unlocking chunks.
+		NotFullyBonded,
+		/// The provided un-staker is not in the `Queue`.
+		NotQueued,
+		/// The provided un-staker is already in Head, and cannot deregister.
+		AlreadyHead,
+		/// The call is not allowed at this point because the pallet is not active.
+		CallNotAllowed,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_idle(_: BlockNumberFor<T>, remaining_weight: Weight) -> Weight {
+			if remaining_weight.any_lt(T::DbWeight::get().reads(2)) {
+				return Weight::from_parts(0, 0)
+			}
+
+			Self::do_on_idle(remaining_weight)
+		}
+
+		fn integrity_test() {
+			// Ensure that the value of `ErasToCheckPerBlock` is less or equal to
+			// `T::MaxErasToCheckPerBlock`.
+			assert!(
+				ErasToCheckPerBlock::<T>::get() <= T::MaxErasToCheckPerBlock::get(),
+				"the value of `ErasToCheckPerBlock` is greater than `T::MaxErasToCheckPerBlock`",
+			);
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_n: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+			// ensure that the value of `ErasToCheckPerBlock` is less than
+			// `T::MaxErasToCheckPerBlock`.
+			ensure!(
+				ErasToCheckPerBlock::<T>::get() <= T::MaxErasToCheckPerBlock::get(),
+				"the value of `ErasToCheckPerBlock` is greater than `T::MaxErasToCheckPerBlock`",
+			);
+
+			Ok(())
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Register oneself for fast-unstake.
+		///
+		/// ## Dispatch Origin
+		///
+		/// The dispatch origin of this call must be *signed* by whoever is permitted to call
+		/// unbond funds by the staking system. See [`Config::Staking`].
+		///
+		/// ## Details
+		///
+		/// The stash associated with the origin must have no ongoing unlocking chunks. If
+		/// successful, this will fully unbond and chill the stash. Then, it will enqueue the stash
+		/// to be checked in further blocks.
+		///
+		/// If by the time this is called, the stash is actually eligible for fast-unstake, then
+		/// they are guaranteed to remain eligible, because the call will chill them as well.
+		///
+		/// If the check works, the entire staking data is removed, i.e. the stash is fully
+		/// unstaked.
+		///
+		/// If the check fails, the stash remains chilled and waiting for being unbonded as in with
+		/// the normal staking system, but they lose part of their unbonding chunks due to consuming
+		/// the chain's resources.
+		///
+		/// ## Events
+		///
+		/// Some events from the staking and currency system might be emitted.
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config>::WeightInfo::register_fast_unstake())]
+		pub fn register_fast_unstake(origin: OriginFor<T>) -> DispatchResult {
+			let ctrl = ensure_signed(origin)?;
+
+			ensure!(ErasToCheckPerBlock::<T>::get() != 0, <Error<T>>::CallNotAllowed);
+			let stash_account =
+				T::Staking::stash_by_ctrl(&ctrl).map_err(|_| Error::<T>::NotController)?;
+			ensure!(!Queue::<T>::contains_key(&stash_account), Error::<T>::AlreadyQueued);
+			ensure!(!Self::is_head(&stash_account), Error::<T>::AlreadyHead);
+			ensure!(!T::Staking::is_unbonding(&stash_account)?, Error::<T>::NotFullyBonded);
+
+			// chill and fully unstake.
+			T::Staking::chill(&stash_account)?;
+			T::Staking::fully_unbond(&stash_account)?;
+
+			T::Currency::reserve(&stash_account, T::Deposit::get())?;
+
+			// enqueue them.
+			Queue::<T>::insert(stash_account, T::Deposit::get());
+			Ok(())
+		}
+
+		/// Deregister oneself from the fast-unstake.
+		///
+		/// ## Dispatch Origin
+		///
+		/// The dispatch origin of this call must be *signed* by whoever is permitted to call
+		/// unbond funds by the staking system. See [`Config::Staking`].
+		///
+		/// ## Details
+		///
+		/// This is useful if one is registered, they are still waiting, and they change their mind.
+		///
+		/// Note that the associated stash is still fully unbonded and chilled as a consequence of
+		/// calling [`Pallet::register_fast_unstake`]. Therefore, this should probably be followed
+		/// by a call to `rebond` in the staking system.
+		///
+		/// ## Events
+		///
+		/// Some events from the staking and currency system might be emitted.
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as Config>::WeightInfo::deregister())]
+		pub fn deregister(origin: OriginFor<T>) -> DispatchResult {
+			let ctrl = ensure_signed(origin)?;
+
+			ensure!(ErasToCheckPerBlock::<T>::get() != 0, <Error<T>>::CallNotAllowed);
+
+			let stash_account =
+				T::Staking::stash_by_ctrl(&ctrl).map_err(|_| Error::<T>::NotController)?;
+			ensure!(Queue::<T>::contains_key(&stash_account), Error::<T>::NotQueued);
+			ensure!(!Self::is_head(&stash_account), Error::<T>::AlreadyHead);
+			let deposit = Queue::<T>::take(stash_account.clone());
+
+			if let Some(deposit) = deposit.defensive() {
+				let remaining = T::Currency::unreserve(&stash_account, deposit);
+				if !remaining.is_zero() {
+					Self::halt("not enough balance to unreserve");
+				}
+			}
+
+			Ok(())
+		}
+
+		/// Control the operation of this pallet.
+		///
+		/// ## Dispatch Origin
+		///
+		/// The dispatch origin of this call must be [`Config::ControlOrigin`].
+		///
+		/// ## Details
+		///
+		/// Can set the number of eras to check per block, and potentially other admin work.
+		///
+		/// ## Events
+		///
+		/// No events are emitted from this dispatch.
+		#[pallet::call_index(2)]
+		#[pallet::weight(<T as Config>::WeightInfo::control())]
+		pub fn control(origin: OriginFor<T>, eras_to_check: EraIndex) -> DispatchResult {
+			let _ = T::ControlOrigin::ensure_origin(origin)?;
+			ensure!(eras_to_check <= T::MaxErasToCheckPerBlock::get(), Error::<T>::CallNotAllowed);
+			ErasToCheckPerBlock::<T>::put(eras_to_check);
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// Returns `true` if `staker` is anywhere to be found in the `head`.
+		pub(crate) fn is_head(staker: &T::AccountId) -> bool {
+			Head::<T>::get().map_or(false, |UnstakeRequest { stashes, .. }| {
+				stashes.iter().any(|(stash, _)| stash == staker)
+			})
+		}
+
+		/// Halt the operations of this pallet.
+		pub(crate) fn halt(reason: &'static str) {
+			frame_support::defensive!(reason);
+			ErasToCheckPerBlock::<T>::put(0);
+			Self::deposit_event(Event::<T>::InternalError)
+		}
+
+		/// process up to `remaining_weight`.
+		///
+		/// Returns the actual weight consumed.
+		///
+		/// Written for readability in mind, not efficiency. For example:
+		///
+		/// 1. We assume this is only ever called once per `on_idle`. This is because we know that
+		/// in all use cases, even a single nominator cannot be unbonded in a single call. Multiple
+		/// calls to this function are thus not needed.
+		///
+		/// 2. We will only mark a staker as unstaked if at the beginning of a check cycle, they are
+		/// found out to have no eras to check. At the end of a check cycle, even if they are fully
+		/// checked, we don't finish the process.
+		pub(crate) fn do_on_idle(remaining_weight: Weight) -> Weight {
+			// any weight that is unaccounted for
+			let mut unaccounted_weight = Weight::from_parts(0, 0);
+
+			let eras_to_check_per_block = ErasToCheckPerBlock::<T>::get();
+			if eras_to_check_per_block.is_zero() {
+				return T::DbWeight::get().reads(1).saturating_add(unaccounted_weight)
+			}
+
+			// NOTE: here we're assuming that the number of validators has only ever increased,
+			// meaning that the number of exposures to check is either this per era, or less.
+			let validator_count = T::Staking::desired_validator_count();
+			let (next_batch_size, reads_from_queue) = Head::<T>::get()
+				.map_or((Queue::<T>::count().min(T::BatchSize::get()), true), |head| {
+					(head.stashes.len() as u32, false)
+				});
+
+			// determine the number of eras to check. This is based on both `ErasToCheckPerBlock`
+			// and `remaining_weight` passed on to us from the runtime executive.
+			let max_weight = |v, b| {
+				// NOTE: this potentially under-counts by up to `BatchSize` reads from the queue.
+				<T as Config>::WeightInfo::on_idle_check(v, b)
+					.max(<T as Config>::WeightInfo::on_idle_unstake(b))
+					.saturating_add(if reads_from_queue {
+						T::DbWeight::get().reads(next_batch_size.into())
+					} else {
+						Zero::zero()
+					})
+			};
+
+			if max_weight(validator_count, next_batch_size).any_gt(remaining_weight) {
+				log!(debug, "early exit because eras_to_check_per_block is zero");
+				return T::DbWeight::get().reads(3).saturating_add(unaccounted_weight)
+			}
+
+			if T::Staking::election_ongoing() {
+				// NOTE: we assume `ongoing` does not consume any weight.
+				// there is an ongoing election -- we better not do anything. Imagine someone is not
+				// exposed anywhere in the last era, and the snapshot for the election is already
+				// taken. In this time period, we don't want to accidentally unstake them.
+				return T::DbWeight::get().reads(4).saturating_add(unaccounted_weight)
+			}
+
+			let UnstakeRequest { stashes, mut checked } = match Head::<T>::take().or_else(|| {
+				// NOTE: there is no order guarantees in `Queue`.
+				let stashes: BoundedVec<_, T::BatchSize> = Queue::<T>::drain()
+					.take(T::BatchSize::get() as usize)
+					.collect::<Vec<_>>()
+					.try_into()
+					.expect("take ensures bound is met; qed");
+				unaccounted_weight.saturating_accrue(
+					T::DbWeight::get().reads_writes(stashes.len() as u64, stashes.len() as u64),
+				);
+				if stashes.is_empty() {
+					None
+				} else {
+					Some(UnstakeRequest { stashes, checked: Default::default() })
+				}
+			}) {
+				None => {
+					// There's no `Head` and nothing in the `Queue`, nothing to do here.
+					return T::DbWeight::get().reads(4)
+				},
+				Some(head) => head,
+			};
+
+			log!(
+				debug,
+				"checking {:?} stashes, eras_to_check_per_block = {:?}, checked {:?}, remaining_weight = {:?}",
+				stashes.len(),
+				eras_to_check_per_block,
+				checked,
+				remaining_weight,
+			);
+
+			// the range that we're allowed to check in this round.
+			let current_era = T::Staking::current_era();
+			let bonding_duration = T::Staking::bonding_duration();
+
+			// prune all the old eras that we don't care about. This will help us keep the bound
+			// of `checked`.
+			checked.retain(|e| *e >= current_era.saturating_sub(bonding_duration));
+
+			let unchecked_eras_to_check = {
+				// get the last available `bonding_duration` eras up to current era in reverse
+				// order.
+				let total_check_range = (current_era.saturating_sub(bonding_duration)..=
+					current_era)
+					.rev()
+					.collect::<Vec<_>>();
+				debug_assert!(
+					total_check_range.len() <= (bonding_duration + 1) as usize,
+					"{:?}",
+					total_check_range
+				);
+
+				// remove eras that have already been checked, take a maximum of
+				// eras_to_check_per_block.
+				total_check_range
+					.into_iter()
+					.filter(|e| !checked.contains(e))
+					.take(eras_to_check_per_block as usize)
+					.collect::<Vec<_>>()
+			};
+
+			log!(
+				debug,
+				"{} eras to check: {:?}",
+				unchecked_eras_to_check.len(),
+				unchecked_eras_to_check
+			);
+
+			let unstake_stash = |stash: T::AccountId, deposit| {
+				let result = T::Staking::force_unstake(stash.clone());
+				let remaining = T::Currency::unreserve(&stash, deposit);
+				if !remaining.is_zero() {
+					Self::halt("not enough balance to unreserve");
+				} else {
+					log!(info, "unstaked {:?}, outcome: {:?}", stash, result);
+					Self::deposit_event(Event::<T>::Unstaked { stash, result });
+				}
+			};
+
+			let check_stash = |stash, deposit| {
+				let is_exposed = unchecked_eras_to_check
+					.iter()
+					.any(|e| T::Staking::is_exposed_in_era(&stash, e));
+
+				if is_exposed {
+					T::Currency::slash_reserved(&stash, deposit);
+					log!(info, "slashed {:?} by {:?}", stash, deposit);
+					Self::deposit_event(Event::<T>::Slashed { stash, amount: deposit });
+					false
+				} else {
+					true
+				}
+			};
+
+			if unchecked_eras_to_check.is_empty() {
+				// `stashes` are not exposed in any era now -- we can let go of them now.
+				let size = stashes.len() as u32;
+				stashes.into_iter().for_each(|(stash, deposit)| unstake_stash(stash, deposit));
+				Self::deposit_event(Event::<T>::BatchFinished { size });
+				<T as Config>::WeightInfo::on_idle_unstake(size).saturating_add(unaccounted_weight)
+			} else {
+				let pre_length = stashes.len();
+				let stashes: BoundedVec<(T::AccountId, BalanceOf<T>), T::BatchSize> = stashes
+					.into_iter()
+					.filter(|(stash, deposit)| check_stash(stash.clone(), *deposit))
+					.collect::<Vec<_>>()
+					.try_into()
+					.expect("filter can only lessen the length; still in bound; qed");
+				let post_length = stashes.len();
+
+				log!(
+					debug,
+					"checked {:?}, pre stashes: {:?}, post: {:?}",
+					unchecked_eras_to_check,
+					pre_length,
+					post_length,
+				);
+
+				match checked.try_extend(unchecked_eras_to_check.clone().into_iter()) {
+					Ok(_) =>
+						if stashes.is_empty() {
+							Self::deposit_event(Event::<T>::BatchFinished { size: 0 });
+						} else {
+							Head::<T>::put(UnstakeRequest { stashes, checked });
+							Self::deposit_event(Event::<T>::BatchChecked {
+								eras: unchecked_eras_to_check,
+							});
+						},
+					Err(_) => {
+						// don't put the head back in -- there is an internal error in the pallet.
+						Self::halt("checked is pruned via retain above")
+					},
+				}
+
+				<T as Config>::WeightInfo::on_idle_check(validator_count, pre_length as u32)
+					.saturating_add(unaccounted_weight)
+			}
+		}
+	}
+}
diff --git a/substrate/frame/fast-unstake/src/migrations.rs b/substrate/frame/fast-unstake/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..564388407045e0ae86b87c7823f3f07c5613e012
--- /dev/null
+++ b/substrate/frame/fast-unstake/src/migrations.rs
@@ -0,0 +1,90 @@
+// 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.
+
+pub mod v1 {
+	use crate::{types::BalanceOf, *};
+	use frame_support::{
+		storage::unhashed,
+		traits::{Defensive, Get, GetStorageVersion, OnRuntimeUpgrade},
+		weights::Weight,
+	};
+	use sp_staking::EraIndex;
+	use sp_std::prelude::*;
+
+	#[cfg(feature = "try-runtime")]
+	use frame_support::ensure;
+	#[cfg(feature = "try-runtime")]
+	use sp_runtime::TryRuntimeError;
+
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			log!(
+				info,
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current,
+				onchain
+			);
+
+			if current == 1 && onchain == 0 {
+				// update the version nonetheless.
+				current.put::<Pallet<T>>();
+
+				// if a head exists, then we put them back into the queue.
+				if Head::<T>::exists() {
+					if let Some((stash, _, deposit)) =
+						unhashed::take::<(T::AccountId, Vec<EraIndex>, BalanceOf<T>)>(
+							&Head::<T>::hashed_key(),
+						)
+						.defensive()
+					{
+						Queue::<T>::insert(stash, deposit);
+					} else {
+						// not much we can do here -- head is already deleted.
+					}
+					T::DbWeight::get().reads_writes(2, 3)
+				} else {
+					T::DbWeight::get().reads(2)
+				}
+			} else {
+				log!(info, "Migration did not execute. This probably should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			ensure!(
+				Pallet::<T>::on_chain_storage_version() == 0,
+				"The onchain storage version must be zero for the migration to execute."
+			);
+			Ok(Default::default())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+			ensure!(
+				Pallet::<T>::on_chain_storage_version() == 1,
+				"The onchain version must be updated after the migration."
+			);
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/fast-unstake/src/mock.rs b/substrate/frame/fast-unstake/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dc24a823c0db022ad0f625be9d6a51a3505f07b0
--- /dev/null
+++ b/substrate/frame/fast-unstake/src/mock.rs
@@ -0,0 +1,377 @@
+// 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::{self as fast_unstake};
+use frame_support::{
+	assert_ok,
+	pallet_prelude::*,
+	parameter_types,
+	traits::{ConstU64, Currency},
+	weights::constants::WEIGHT_REF_TIME_PER_SECOND,
+};
+use sp_runtime::{
+	traits::{Convert, IdentityLookup},
+	BuildStorage,
+};
+
+use pallet_staking::{Exposure, IndividualExposure, StakerStatus};
+use sp_std::prelude::*;
+
+pub type AccountId = u128;
+pub type Nonce = u32;
+pub type BlockNumber = u64;
+pub type Balance = u128;
+pub type T = Runtime;
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(
+			Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
+		);
+}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = 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 {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub static ExistentialDeposit: Balance = 1;
+}
+
+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 MaxHolds = ();
+}
+
+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;
+	pub static CurrentEra: u32 = 0;
+	pub static Ongoing: bool = false;
+	pub static MaxWinners: u32 = 100;
+}
+
+pub struct MockElection;
+impl frame_election_provider_support::ElectionProviderBase for MockElection {
+	type AccountId = AccountId;
+	type BlockNumber = BlockNumber;
+	type MaxWinners = MaxWinners;
+	type DataProvider = Staking;
+	type Error = ();
+}
+
+impl frame_election_provider_support::ElectionProvider for MockElection {
+	fn ongoing() -> bool {
+		Ongoing::get()
+	}
+	fn elect() -> Result<frame_election_provider_support::BoundedSupportsOf<Self>, Self::Error> {
+		Err(())
+	}
+}
+
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = ();
+	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 EventListeners = ();
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+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 static Deposit: u128 = 7;
+	pub static BatchSize: u32 = 1;
+}
+
+impl fast_unstake::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Deposit = Deposit;
+	type Currency = Balances;
+	type Staking = Staking;
+	type ControlOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type BatchSize = BatchSize;
+	type WeightInfo = ();
+	type MaxErasToCheckPerBlock = ConstU32<16>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type MaxBackersPerValidator = ConstU32<128>;
+}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime {
+		System: frame_system,
+		Timestamp: pallet_timestamp,
+		Balances: pallet_balances,
+		Staking: pallet_staking,
+		FastUnstake: fast_unstake,
+	}
+);
+
+parameter_types! {
+	static FastUnstakeEvents: u32 = 0;
+}
+
+pub(crate) fn fast_unstake_events_since_last_call() -> Vec<super::Event<Runtime>> {
+	let events = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::FastUnstake(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>();
+	let already_seen = FastUnstakeEvents::get();
+	FastUnstakeEvents::set(events.len() as u32);
+	events.into_iter().skip(already_seen as usize).collect()
+}
+
+pub struct ExtBuilder {
+	unexposed: Vec<(AccountId, AccountId, Balance)>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			unexposed: vec![
+				(1, 1, 7 + 100),
+				(3, 3, 7 + 100),
+				(5, 5, 7 + 100),
+				(7, 7, 7 + 100),
+				(9, 9, 7 + 100),
+			],
+		}
+	}
+}
+
+pub(crate) const VALIDATORS_PER_ERA: AccountId = 32;
+pub(crate) const VALIDATOR_PREFIX: AccountId = 100;
+pub(crate) const NOMINATORS_PER_VALIDATOR_PER_ERA: AccountId = 4;
+pub(crate) const NOMINATOR_PREFIX: AccountId = 1000;
+
+impl ExtBuilder {
+	pub(crate) fn register_stakers_for_era(era: u32) {
+		// validators are prefixed with 100 and nominators with 1000 to prevent conflict. Make sure
+		// all the other accounts used in tests are below 100. Also ensure here that we don't
+		// overlap.
+		assert!(VALIDATOR_PREFIX + VALIDATORS_PER_ERA < NOMINATOR_PREFIX);
+
+		(VALIDATOR_PREFIX..VALIDATOR_PREFIX + VALIDATORS_PER_ERA)
+			.map(|v| {
+				// for the sake of sanity, let's register this taker as an actual validator.
+				let others = (NOMINATOR_PREFIX..
+					(NOMINATOR_PREFIX + NOMINATORS_PER_VALIDATOR_PER_ERA))
+					.map(|n| IndividualExposure { who: n, value: 0 as Balance })
+					.collect::<Vec<_>>();
+				(v, Exposure { total: 0, own: 0, others })
+			})
+			.for_each(|(validator, exposure)| {
+				pallet_staking::ErasStakers::<T>::insert(era, validator, exposure);
+			});
+	}
+
+	pub(crate) fn batch(self, size: u32) -> Self {
+		BatchSize::set(size);
+		self
+	}
+
+	pub(crate) fn build(self) -> sp_io::TestExternalities {
+		sp_tracing::try_init_simple();
+		let mut storage =
+			frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+		let validators_range = VALIDATOR_PREFIX..VALIDATOR_PREFIX + VALIDATORS_PER_ERA;
+		let nominators_range =
+			NOMINATOR_PREFIX..NOMINATOR_PREFIX + NOMINATORS_PER_VALIDATOR_PER_ERA;
+
+		let _ = pallet_balances::GenesisConfig::<Runtime> {
+			balances: self
+				.unexposed
+				.clone()
+				.into_iter()
+				.map(|(stash, _, balance)| (stash, balance * 2))
+				.chain(validators_range.clone().map(|x| (x, 7 + 100)))
+				.chain(nominators_range.clone().map(|x| (x, 7 + 100)))
+				.collect::<Vec<_>>(),
+		}
+		.assimilate_storage(&mut storage);
+
+		let _ = pallet_staking::GenesisConfig::<Runtime> {
+			stakers: self
+				.unexposed
+				.into_iter()
+				.map(|(x, y, z)| (x, y, z, pallet_staking::StakerStatus::Nominator(vec![42])))
+				.chain(validators_range.map(|x| (x, x, 100, StakerStatus::Validator)))
+				.chain(nominators_range.map(|x| (x, x, 100, StakerStatus::Nominator(vec![x]))))
+				.collect::<Vec<_>>(),
+			..Default::default()
+		}
+		.assimilate_storage(&mut storage);
+
+		let mut ext = sp_io::TestExternalities::from(storage);
+
+		ext.execute_with(|| {
+			// for events to be deposited.
+			frame_system::Pallet::<Runtime>::set_block_number(1);
+
+			for era in 0..=(BondingDuration::get()) {
+				Self::register_stakers_for_era(era);
+			}
+
+			// because we read this value as a measure of how many validators we have.
+			pallet_staking::ValidatorCount::<Runtime>::put(VALIDATORS_PER_ERA as u32);
+		});
+
+		ext
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		self.build().execute_with(|| {
+			test();
+		})
+	}
+}
+
+pub(crate) fn run_to_block(n: u64, on_idle: bool) {
+	let current_block = System::block_number();
+	assert!(n > current_block);
+	while System::block_number() < n {
+		Balances::on_finalize(System::block_number());
+		Staking::on_finalize(System::block_number());
+		FastUnstake::on_finalize(System::block_number());
+
+		System::set_block_number(System::block_number() + 1);
+
+		Balances::on_initialize(System::block_number());
+		Staking::on_initialize(System::block_number());
+		FastUnstake::on_initialize(System::block_number());
+		if on_idle {
+			FastUnstake::on_idle(System::block_number(), BlockWeights::get().max_block);
+		}
+	}
+}
+
+pub(crate) fn next_block(on_idle: bool) {
+	let current = System::block_number();
+	run_to_block(current + 1, on_idle);
+}
+
+pub fn assert_unstaked(stash: &AccountId) {
+	assert!(!pallet_staking::Bonded::<T>::contains_key(stash));
+	assert!(!pallet_staking::Payee::<T>::contains_key(stash));
+	assert!(!pallet_staking::Validators::<T>::contains_key(stash));
+	assert!(!pallet_staking::Nominators::<T>::contains_key(stash));
+}
+
+pub fn create_exposed_nominator(exposed: AccountId, era: u32) {
+	// create an exposed nominator in era 1
+	pallet_staking::ErasStakers::<T>::mutate(era, VALIDATORS_PER_ERA, |expo| {
+		expo.others.push(IndividualExposure { who: exposed, value: 0 as Balance });
+	});
+	Balances::make_free_balance_be(&exposed, 100);
+	assert_ok!(Staking::bond(
+		RuntimeOrigin::signed(exposed),
+		10,
+		pallet_staking::RewardDestination::Staked
+	));
+	assert_ok!(Staking::nominate(RuntimeOrigin::signed(exposed), vec![exposed]));
+	// register the exposed one.
+	assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(exposed)));
+}
diff --git a/substrate/frame/fast-unstake/src/tests.rs b/substrate/frame/fast-unstake/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..94ad6a84b85a1768b60c93ef94727df523b0f480
--- /dev/null
+++ b/substrate/frame/fast-unstake/src/tests.rs
@@ -0,0 +1,1116 @@
+// 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-fast-unstake.
+
+use super::*;
+use crate::{mock::*, types::*, Event};
+use frame_support::{pallet_prelude::*, testing_prelude::*, traits::Currency};
+use pallet_staking::{CurrentEra, RewardDestination};
+
+use sp_runtime::traits::BadOrigin;
+use sp_staking::StakingInterface;
+
+#[test]
+fn test_setup_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(Staking::bonding_duration(), 3);
+	});
+}
+
+#[test]
+fn register_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Controller account registers for fast unstake.
+		assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+		// Ensure stash is in the queue.
+		assert_ne!(Queue::<T>::get(1), None);
+	});
+}
+
+#[test]
+fn register_insufficient_funds_fails() {
+	use pallet_balances::Error as BalancesError;
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		<T as Config>::Currency::make_free_balance_be(&1, 3);
+
+		// Controller account registers for fast unstake.
+		assert_noop!(
+			FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)),
+			BalancesError::<T, _>::InsufficientBalance,
+		);
+
+		// Ensure stash is in the queue.
+		assert_eq!(Queue::<T>::get(1), None);
+	});
+}
+
+#[test]
+fn register_disabled_fails() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_noop!(
+			FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)),
+			Error::<T>::CallNotAllowed
+		);
+	});
+}
+
+#[test]
+fn cannot_register_if_not_bonded() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Mint accounts 1 and 2 with 200 tokens.
+		for _ in 1..2 {
+			let _ = Balances::make_free_balance_be(&1, 200);
+		}
+		// Attempt to fast unstake.
+		assert_noop!(
+			FastUnstake::register_fast_unstake(RuntimeOrigin::signed(2)),
+			Error::<T>::NotController
+		);
+	});
+}
+
+#[test]
+fn cannot_register_if_in_queue() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Insert some Queue item
+		Queue::<T>::insert(1, 10);
+		// Cannot re-register, already in queue
+		assert_noop!(
+			FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)),
+			Error::<T>::AlreadyQueued
+		);
+	});
+}
+
+#[test]
+fn cannot_register_if_head() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Insert some Head item for stash
+		Head::<T>::put(UnstakeRequest {
+			stashes: bounded_vec![(1, Deposit::get())],
+			checked: bounded_vec![],
+		});
+		// Controller attempts to regsiter
+		assert_noop!(
+			FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)),
+			Error::<T>::AlreadyHead
+		);
+	});
+}
+
+#[test]
+fn cannot_register_if_has_unlocking_chunks() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Start unbonding half of staked tokens
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(1), 50_u128));
+		// Cannot register for fast unstake with unlock chunks active
+		assert_noop!(
+			FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)),
+			Error::<T>::NotFullyBonded
+		);
+	});
+}
+
+#[test]
+fn deregister_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+
+		assert_eq!(<T as Config>::Currency::reserved_balance(&1), 0);
+
+		// Controller account registers for fast unstake.
+		assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+		assert_eq!(<T as Config>::Currency::reserved_balance(&1), Deposit::get());
+
+		// Controller then changes mind and deregisters.
+		assert_ok!(FastUnstake::deregister(RuntimeOrigin::signed(1)));
+		assert_eq!(<T as Config>::Currency::reserved_balance(&1), 0);
+
+		// Ensure stash no longer exists in the queue.
+		assert_eq!(Queue::<T>::get(1), None);
+	});
+}
+
+#[test]
+fn deregister_disabled_fails() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+		ErasToCheckPerBlock::<T>::put(0);
+		assert_noop!(FastUnstake::deregister(RuntimeOrigin::signed(1)), Error::<T>::CallNotAllowed);
+	});
+}
+
+#[test]
+fn cannot_deregister_if_not_controller() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Controller (same as stash) account registers for fast unstake.
+		assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+		// Another account tries to deregister.
+		assert_noop!(FastUnstake::deregister(RuntimeOrigin::signed(2)), Error::<T>::NotController);
+	});
+}
+
+#[test]
+fn cannot_deregister_if_not_queued() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Controller tries to deregister without first registering
+		assert_noop!(FastUnstake::deregister(RuntimeOrigin::signed(1)), Error::<T>::NotQueued);
+	});
+}
+
+#[test]
+fn cannot_deregister_already_head() {
+	ExtBuilder::default().build_and_execute(|| {
+		ErasToCheckPerBlock::<T>::put(1);
+		// Controller attempts to register, should fail
+		assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+		// Insert some Head item for stash.
+		Head::<T>::put(UnstakeRequest {
+			stashes: bounded_vec![(1, Deposit::get())],
+			checked: bounded_vec![],
+		});
+		// Controller attempts to deregister
+		assert_noop!(FastUnstake::deregister(RuntimeOrigin::signed(1)), Error::<T>::AlreadyHead);
+	});
+}
+
+#[test]
+fn control_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// account with control (root) origin wants to only check 1 era per block.
+		assert_ok!(FastUnstake::control(RuntimeOrigin::root(), 1_u32));
+	});
+}
+
+#[test]
+fn control_must_be_control_origin() {
+	ExtBuilder::default().build_and_execute(|| {
+		// account without control (root) origin wants to only check 1 era per block.
+		assert_noop!(FastUnstake::control(RuntimeOrigin::signed(2), 1_u32), BadOrigin);
+	});
+}
+
+mod on_idle {
+	use super::*;
+
+	#[test]
+	fn early_exit() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// set up Queue item
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_eq!(Queue::<T>::get(1), Some(Deposit::get()));
+
+			// call on_idle with no remaining weight
+			FastUnstake::on_idle(System::block_number(), Weight::from_parts(0, 0));
+
+			// assert nothing changed in Queue and Head
+			assert_eq!(Head::<T>::get(), None);
+			assert_eq!(Queue::<T>::get(1), Some(Deposit::get()));
+		});
+	}
+
+	#[test]
+	fn if_head_not_set_one_random_fetched_from_queue() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// given
+			assert_eq!(<T as Config>::Currency::reserved_balance(&1), 0);
+
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(3)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(5)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(7)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(9)));
+
+			assert_eq!(<T as Config>::Currency::reserved_balance(&1), Deposit::get());
+
+			assert_eq!(Queue::<T>::count(), 5);
+			assert_eq!(Head::<T>::get(), None);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+			assert_eq!(Queue::<T>::count(), 4);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(Head::<T>::get(), None,);
+			assert_eq!(Queue::<T>::count(), 4);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(5, Deposit::get())],
+					checked: bounded_vec![3, 2, 1, 0]
+				}),
+			);
+			assert_eq!(Queue::<T>::count(), 3);
+
+			assert_eq!(<T as Config>::Currency::reserved_balance(&1), 0);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::BatchFinished { size: 1 },
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] }
+				]
+			);
+		});
+	}
+
+	#[docify::export]
+	#[test]
+	fn successful_multi_queue() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// register multi accounts for fast unstake
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_eq!(Queue::<T>::get(1), Some(Deposit::get()));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(3)));
+			assert_eq!(Queue::<T>::get(3), Some(Deposit::get()));
+
+			// assert 2 queue items are in Queue & None in Head to start with
+			assert_eq!(Queue::<T>::count(), 2);
+			assert_eq!(Head::<T>::get(), None);
+
+			// process on idle and check eras for next Queue item
+			next_block(true);
+
+			// process on idle & let go of current Head
+			next_block(true);
+
+			// confirm Head / Queue items remaining
+			assert_eq!(Queue::<T>::count(), 1);
+			assert_eq!(Head::<T>::get(), None);
+
+			// process on idle and check eras for next Queue item
+			next_block(true);
+
+			// process on idle & let go of current Head
+			next_block(true);
+
+			// Head & Queue should now be empty
+			assert_eq!(Head::<T>::get(), None);
+			assert_eq!(Queue::<T>::count(), 0);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::BatchFinished { size: 1 },
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] },
+					Event::Unstaked { stash: 3, result: Ok(()) },
+					Event::BatchFinished { size: 1 },
+				]
+			);
+
+			assert_unstaked(&1);
+			assert_unstaked(&3);
+		});
+	}
+
+	#[docify::export]
+	#[test]
+	fn successful_unstake() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// register for fast unstake
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_eq!(Queue::<T>::get(1), Some(Deposit::get()));
+
+			// process on idle
+			next_block(true);
+
+			// assert queue item has been moved to head
+			assert_eq!(Queue::<T>::get(1), None);
+
+			// assert head item present
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None,);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::BatchFinished { size: 1 }
+				]
+			);
+			assert_unstaked(&1);
+		});
+	}
+
+	#[test]
+	fn successful_unstake_all_eras_per_block() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			Balances::make_free_balance_be(&2, 100);
+
+			// register for fast unstake
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_eq!(Queue::<T>::get(1), Some(Deposit::get()));
+
+			// process on idle
+			next_block(true);
+
+			// assert queue item has been moved to head
+			assert_eq!(Queue::<T>::get(1), None);
+
+			// assert head item present
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None,);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::BatchFinished { size: 1 }
+				]
+			);
+			assert_unstaked(&1);
+		});
+	}
+
+	#[test]
+	fn successful_unstake_one_era_per_block() {
+		ExtBuilder::default().build_and_execute(|| {
+			// put 1 era per block
+			ErasToCheckPerBlock::<T>::put(1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// register for fast unstake
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_eq!(Queue::<T>::get(1), Some(Deposit::get()));
+
+			// process on idle
+			next_block(true);
+
+			// assert queue item has been moved to head
+			assert_eq!(Queue::<T>::get(1), None);
+
+			// assert head item present
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3]
+				})
+			);
+
+			next_block(true);
+
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2]
+				})
+			);
+
+			next_block(true);
+
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 1]
+				})
+			);
+
+			next_block(true);
+
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+
+			next_block(true);
+
+			assert_eq!(Head::<T>::get(), None,);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3] },
+					Event::BatchChecked { eras: vec![2] },
+					Event::BatchChecked { eras: vec![1] },
+					Event::BatchChecked { eras: vec![0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::BatchFinished { size: 1 }
+				]
+			);
+			assert_unstaked(&1);
+		});
+	}
+
+	#[test]
+	fn old_checked_era_pruned() {
+		// the only scenario where checked era pruning (checked.retain) comes handy is a follows:
+		// the whole vector is full and at capacity and in the next call we are ready to unstake,
+		// but then a new era happens.
+		ExtBuilder::default().build_and_execute(|| {
+			// given
+			ErasToCheckPerBlock::<T>::put(1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// register for fast unstake
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_eq!(Queue::<T>::get(1), Some(Deposit::get()));
+
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3]
+				})
+			);
+
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2]
+				})
+			);
+
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 1]
+				})
+			);
+
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+
+			// when: a new era happens right before one is free.
+			CurrentEra::<T>::put(CurrentEra::<T>::get().unwrap() + 1);
+			ExtBuilder::register_stakers_for_era(CurrentEra::<T>::get().unwrap());
+
+			// then
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					// note era 0 is pruned to keep the vector length sane.
+					checked: bounded_vec![3, 2, 1, 4],
+				})
+			);
+
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3] },
+					Event::BatchChecked { eras: vec![2] },
+					Event::BatchChecked { eras: vec![1] },
+					Event::BatchChecked { eras: vec![0] },
+					Event::BatchChecked { eras: vec![4] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::BatchFinished { size: 1 }
+				]
+			);
+			assert_unstaked(&1);
+		});
+	}
+
+	#[test]
+	fn unstake_paused_mid_election() {
+		ExtBuilder::default().build_and_execute(|| {
+			// give: put 1 era per block
+			ErasToCheckPerBlock::<T>::put(1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// register for fast unstake
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+
+			// process 2 blocks
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3]
+				})
+			);
+
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2]
+				})
+			);
+
+			// when
+			Ongoing::set(true);
+
+			// then nothing changes
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2]
+				})
+			);
+
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2]
+				})
+			);
+
+			// then we register a new era.
+			Ongoing::set(false);
+			CurrentEra::<T>::put(CurrentEra::<T>::get().unwrap() + 1);
+			ExtBuilder::register_stakers_for_era(CurrentEra::<T>::get().unwrap());
+
+			// then we can progress again, but notice that the new era that had to be checked.
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 4]
+				})
+			);
+
+			// progress to end
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get())],
+					checked: bounded_vec![3, 2, 4, 1]
+				})
+			);
+
+			// but notice that we don't care about era 0 instead anymore! we're done.
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3] },
+					Event::BatchChecked { eras: vec![2] },
+					Event::BatchChecked { eras: vec![4] },
+					Event::BatchChecked { eras: vec![1] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::BatchFinished { size: 1 }
+				]
+			);
+
+			assert_unstaked(&1);
+		});
+	}
+
+	#[docify::export]
+	#[test]
+	fn exposed_nominator_cannot_unstake() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// create an exposed nominator in era 1
+			let exposed = 666;
+			create_exposed_nominator(exposed, 1);
+
+			// a few blocks later, we realize they are slashed
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(exposed, Deposit::get())],
+					checked: bounded_vec![3]
+				})
+			);
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(exposed, Deposit::get())],
+					checked: bounded_vec![3, 2]
+				})
+			);
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3] },
+					Event::BatchChecked { eras: vec![2] },
+					Event::Slashed { stash: exposed, amount: Deposit::get() },
+					Event::BatchFinished { size: 0 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn exposed_nominator_cannot_unstake_multi_check() {
+		ExtBuilder::default().build_and_execute(|| {
+			// same as the previous check, but we check 2 eras per block, and we make the exposed be
+			// exposed in era 0, so that it is detected halfway in a check era.
+			ErasToCheckPerBlock::<T>::put(2);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// create an exposed nominator in era 0
+			let exposed = 666;
+			create_exposed_nominator(exposed, 0);
+
+			// a few blocks later, we realize they are slashed
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(exposed, Deposit::get())],
+					checked: bounded_vec![3, 2]
+				})
+			);
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				// we slash them
+				vec![
+					Event::BatchChecked { eras: vec![3, 2] },
+					Event::Slashed { stash: exposed, amount: Deposit::get() },
+					Event::BatchFinished { size: 0 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn validators_cannot_bail() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// a validator switches role and register...
+			assert_ok!(Staking::nominate(
+				RuntimeOrigin::signed(VALIDATOR_PREFIX),
+				vec![VALIDATOR_PREFIX]
+			));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(VALIDATOR_PREFIX)));
+
+			// but they indeed are exposed!
+			assert!(pallet_staking::ErasStakers::<T>::contains_key(
+				BondingDuration::get() - 1,
+				VALIDATOR_PREFIX
+			));
+
+			// process a block, this validator is exposed and has been slashed.
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::Slashed { stash: 100, amount: Deposit::get() },
+					Event::BatchFinished { size: 0 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn unexposed_validator_can_fast_unstake() {
+		ExtBuilder::default().build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// create a new validator that 100% not exposed.
+			Balances::make_free_balance_be(&42, 100 + Deposit::get());
+			assert_ok!(Staking::bond(RuntimeOrigin::signed(42), 10, RewardDestination::Staked));
+			assert_ok!(Staking::validate(RuntimeOrigin::signed(42), Default::default()));
+
+			// let them register:
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(42)));
+
+			// 2 block's enough to unstake them.
+			next_block(true);
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(42, Deposit::get())],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+			next_block(true);
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] },
+					Event::Unstaked { stash: 42, result: Ok(()) },
+					Event::BatchFinished { size: 1 }
+				]
+			);
+		});
+	}
+}
+
+mod batched {
+	use super::*;
+
+	#[test]
+	fn single_block_batched_successful() {
+		ExtBuilder::default().batch(3).build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(BondingDuration::get() + 1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(3)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(5)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(7)));
+
+			assert_eq!(Queue::<T>::count(), 4);
+			assert_eq!(Head::<T>::get(), None);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![
+						(1, Deposit::get()),
+						(5, Deposit::get()),
+						(7, Deposit::get())
+					],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+			assert_eq!(Queue::<T>::count(), 1);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(Head::<T>::get(), None);
+			assert_eq!(Queue::<T>::count(), 1);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3, 2, 1, 0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::Unstaked { stash: 5, result: Ok(()) },
+					Event::Unstaked { stash: 7, result: Ok(()) },
+					Event::BatchFinished { size: 3 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn multi_block_batched_successful() {
+		ExtBuilder::default().batch(3).build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(2);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(3)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(5)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(7)));
+
+			assert_eq!(Queue::<T>::count(), 4);
+			assert_eq!(Head::<T>::get(), None);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![
+						(1, Deposit::get()),
+						(5, Deposit::get()),
+						(7, Deposit::get())
+					],
+					checked: bounded_vec![3, 2]
+				})
+			);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![
+						(1, Deposit::get()),
+						(5, Deposit::get()),
+						(7, Deposit::get())
+					],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::BatchChecked { eras: vec![3, 2] },
+					Event::BatchChecked { eras: vec![1, 0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::Unstaked { stash: 5, result: Ok(()) },
+					Event::Unstaked { stash: 7, result: Ok(()) },
+					Event::BatchFinished { size: 3 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn multi_block_batched_some_fail() {
+		ExtBuilder::default().batch(4).build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(2);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// register two good ones.
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(3)));
+			create_exposed_nominator(666, 1);
+			create_exposed_nominator(667, 3);
+
+			// then
+			assert_eq!(Queue::<T>::count(), 4);
+			assert_eq!(Head::<T>::get(), None);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![
+						(1, Deposit::get()),
+						(3, Deposit::get()),
+						(666, Deposit::get())
+					],
+					checked: bounded_vec![3, 2]
+				})
+			);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get()), (3, Deposit::get()),],
+					checked: bounded_vec![3, 2, 1, 0]
+				})
+			);
+
+			// when
+			next_block(true);
+
+			// then
+			assert_eq!(Head::<T>::get(), None);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::Slashed { stash: 667, amount: 7 },
+					Event::BatchChecked { eras: vec![3, 2] },
+					Event::Slashed { stash: 666, amount: 7 },
+					Event::BatchChecked { eras: vec![1, 0] },
+					Event::Unstaked { stash: 1, result: Ok(()) },
+					Event::Unstaked { stash: 3, result: Ok(()) },
+					Event::BatchFinished { size: 2 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn multi_block_batched_all_fail_early_exit() {
+		ExtBuilder::default().batch(2).build_and_execute(|| {
+			ErasToCheckPerBlock::<T>::put(1);
+			CurrentEra::<T>::put(BondingDuration::get());
+
+			// register two bad ones.
+			create_exposed_nominator(666, 3);
+			create_exposed_nominator(667, 2);
+
+			// then
+			assert_eq!(Queue::<T>::count(), 2);
+			assert_eq!(Head::<T>::get(), None);
+
+			// when we progress a block..
+			next_block(true);
+
+			// ..and register two good ones.
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(1)));
+			assert_ok!(FastUnstake::register_fast_unstake(RuntimeOrigin::signed(3)));
+
+			// then one of the bad ones is reaped.
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(667, Deposit::get())],
+					checked: bounded_vec![3]
+				})
+			);
+
+			// when we go to next block
+			next_block(true);
+
+			// then the head is empty, we early terminate the batch.
+			assert_eq!(Head::<T>::get(), None);
+
+			// upon next block, we will assemble a new head.
+			next_block(true);
+
+			assert_eq!(
+				Head::<T>::get(),
+				Some(UnstakeRequest {
+					stashes: bounded_vec![(1, Deposit::get()), (3, Deposit::get()),],
+					checked: bounded_vec![3]
+				})
+			);
+
+			assert_eq!(
+				fast_unstake_events_since_last_call(),
+				vec![
+					Event::Slashed { stash: 666, amount: Deposit::get() },
+					Event::BatchChecked { eras: vec![3] },
+					Event::Slashed { stash: 667, amount: Deposit::get() },
+					Event::BatchFinished { size: 0 },
+					Event::BatchChecked { eras: vec![3] }
+				]
+			);
+		});
+	}
+}
+
+#[test]
+fn kusama_estimate() {
+	use crate::WeightInfo;
+	let block_time = frame_support::weights::Weight::from_parts(
+		frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND * 2,
+		0,
+	)
+	.ref_time() as f32;
+	let on_idle = crate::weights::SubstrateWeight::<T>::on_idle_check(1000, 64).ref_time() as f32;
+	dbg!(block_time, on_idle, on_idle / block_time);
+}
+
+#[test]
+fn polkadot_estimate() {
+	use crate::WeightInfo;
+	let block_time = frame_support::weights::Weight::from_parts(
+		frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND * 2,
+		0,
+	)
+	.ref_time() as f32;
+	let on_idle = crate::weights::SubstrateWeight::<T>::on_idle_check(300, 64).ref_time() as f32;
+	dbg!(block_time, on_idle, on_idle / block_time);
+}
diff --git a/substrate/frame/fast-unstake/src/types.rs b/substrate/frame/fast-unstake/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..15d0a327e917e3123b0df5d22eb2e9d7e655b39f
--- /dev/null
+++ b/substrate/frame/fast-unstake/src/types.rs
@@ -0,0 +1,57 @@
+// 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.
+
+//! Types used in the Fast Unstake pallet.
+
+use crate::Config;
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	traits::Currency, BoundedVec, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+use scale_info::TypeInfo;
+use sp_staking::{EraIndex, StakingInterface};
+use sp_std::prelude::*;
+
+/// Maximum number of eras that we might check for a single staker.
+///
+/// In effect, it is the bonding duration, coming from [`Config::Staking`], plus one.
+#[derive(scale_info::TypeInfo, codec::Encode, codec::Decode, codec::MaxEncodedLen)]
+#[codec(mel_bound(T: Config))]
+#[scale_info(skip_type_params(T))]
+pub struct MaxChecking<T: Config>(sp_std::marker::PhantomData<T>);
+impl<T: Config> frame_support::traits::Get<u32> for MaxChecking<T> {
+	fn get() -> u32 {
+		T::Staking::bonding_duration() + 1
+	}
+}
+
+pub(crate) type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+/// An unstake request.
+///
+/// This is stored in [`crate::Head`] storage item and points to the current unstake request that is
+/// being processed.
+#[derive(
+	Encode, Decode, EqNoBound, PartialEqNoBound, Clone, TypeInfo, RuntimeDebugNoBound, MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(T))]
+pub struct UnstakeRequest<T: Config> {
+	/// This list of stashes are being processed in this request, and their corresponding deposit.
+	pub stashes: BoundedVec<(T::AccountId, BalanceOf<T>), T::BatchSize>,
+	/// The list of eras for which they have been checked.
+	pub checked: BoundedVec<EraIndex, MaxChecking<T>>,
+}
diff --git a/substrate/frame/fast-unstake/src/weights.rs b/substrate/frame/fast-unstake/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9c25a409f74099fc4d13158f99fae9036b34eff8
--- /dev/null
+++ b/substrate/frame/fast-unstake/src/weights.rs
@@ -0,0 +1,359 @@
+// 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.
+
+//! Autogenerated weights for pallet_fast_unstake
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_fast_unstake
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/fast-unstake/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_fast_unstake.
+pub trait WeightInfo {
+	fn on_idle_unstake(b: u32, ) -> Weight;
+	fn on_idle_check(v: u32, b: u32, ) -> Weight;
+	fn register_fast_unstake() -> Weight;
+	fn deregister() -> Weight;
+	fn control() -> Weight;
+}
+
+/// Weights for pallet_fast_unstake using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ValidatorCount (r:1 w:0)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:1)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:0)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking SlashingSpans (r:64 w:0)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking Bonded (r:64 w:64)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:64 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:64 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: System Account (r:64 w:64)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Balances Locks (r:64 w:64)
+	/// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen)
+	/// Storage: Balances Freezes (r:64 w:0)
+	/// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:0 w:64)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:64)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// The range of component `b` is `[1, 64]`.
+	fn on_idle_unstake(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1378 + b * (343 ±0)`
+		//  Estimated: `7253 + b * (3774 ±0)`
+		// Minimum execution time: 92_847_000 picoseconds.
+		Weight::from_parts(42_300_813, 7253)
+			// Standard Error: 40_514
+			.saturating_add(Weight::from_parts(58_412_402, 0).saturating_mul(b.into()))
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().reads((7_u64).saturating_mul(b.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((5_u64).saturating_mul(b.into())))
+			.saturating_add(Weight::from_parts(0, 3774).saturating_mul(b.into()))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ValidatorCount (r:1 w:0)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:1)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:0)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakers (r:257 w:0)
+	/// Proof Skipped: Staking ErasStakers (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `v` is `[1, 256]`.
+	/// The range of component `b` is `[1, 64]`.
+	fn on_idle_check(v: u32, b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1546 + b * (48 ±0) + v * (10037 ±0)`
+		//  Estimated: `7253 + b * (49 ±0) + v * (12513 ±0)`
+		// Minimum execution time: 1_685_784_000 picoseconds.
+		Weight::from_parts(1_693_370_000, 7253)
+			// Standard Error: 13_295_842
+			.saturating_add(Weight::from_parts(425_349_148, 0).saturating_mul(v.into()))
+			// Standard Error: 53_198_180
+			.saturating_add(Weight::from_parts(1_673_328_444, 0).saturating_mul(b.into()))
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(v.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 49).saturating_mul(b.into()))
+			.saturating_add(Weight::from_parts(0, 12513).saturating_mul(v.into()))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Queue (r:1 w:1)
+	/// Proof: FastUnstake Queue (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:0)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, 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 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn register_fast_unstake() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1964`
+		//  Estimated: `7253`
+		// Minimum execution time: 125_512_000 picoseconds.
+		Weight::from_parts(129_562_000, 7253)
+			.saturating_add(T::DbWeight::get().reads(15_u64))
+			.saturating_add(T::DbWeight::get().writes(9_u64))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Queue (r:1 w:1)
+	/// Proof: FastUnstake Queue (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:0)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn deregister() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1223`
+		//  Estimated: `7253`
+		// Minimum execution time: 43_943_000 picoseconds.
+		Weight::from_parts(45_842_000, 7253)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:0 w:1)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn control() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_677_000 picoseconds.
+		Weight::from_parts(2_849_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ValidatorCount (r:1 w:0)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:1)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:0)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking SlashingSpans (r:64 w:0)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking Bonded (r:64 w:64)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:64 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:64 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: System Account (r:64 w:64)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Balances Locks (r:64 w:64)
+	/// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen)
+	/// Storage: Balances Freezes (r:64 w:0)
+	/// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:0 w:64)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:64)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// The range of component `b` is `[1, 64]`.
+	fn on_idle_unstake(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1378 + b * (343 ±0)`
+		//  Estimated: `7253 + b * (3774 ±0)`
+		// Minimum execution time: 92_847_000 picoseconds.
+		Weight::from_parts(42_300_813, 7253)
+			// Standard Error: 40_514
+			.saturating_add(Weight::from_parts(58_412_402, 0).saturating_mul(b.into()))
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().reads((7_u64).saturating_mul(b.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((5_u64).saturating_mul(b.into())))
+			.saturating_add(Weight::from_parts(0, 3774).saturating_mul(b.into()))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ValidatorCount (r:1 w:0)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:1)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:0)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: ElectionProviderMultiPhase CurrentPhase (r:1 w:0)
+	/// Proof Skipped: ElectionProviderMultiPhase CurrentPhase (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakers (r:257 w:0)
+	/// Proof Skipped: Staking ErasStakers (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `v` is `[1, 256]`.
+	/// The range of component `b` is `[1, 64]`.
+	fn on_idle_check(v: u32, b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1546 + b * (48 ±0) + v * (10037 ±0)`
+		//  Estimated: `7253 + b * (49 ±0) + v * (12513 ±0)`
+		// Minimum execution time: 1_685_784_000 picoseconds.
+		Weight::from_parts(1_693_370_000, 7253)
+			// Standard Error: 13_295_842
+			.saturating_add(Weight::from_parts(425_349_148, 0).saturating_mul(v.into()))
+			// Standard Error: 53_198_180
+			.saturating_add(Weight::from_parts(1_673_328_444, 0).saturating_mul(b.into()))
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(v.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 49).saturating_mul(b.into()))
+			.saturating_add(Weight::from_parts(0, 12513).saturating_mul(v.into()))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Queue (r:1 w:1)
+	/// Proof: FastUnstake Queue (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:0)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, 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 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn register_fast_unstake() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1964`
+		//  Estimated: `7253`
+		// Minimum execution time: 125_512_000 picoseconds.
+		Weight::from_parts(129_562_000, 7253)
+			.saturating_add(RocksDbWeight::get().reads(15_u64))
+			.saturating_add(RocksDbWeight::get().writes(9_u64))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:1 w:0)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Queue (r:1 w:1)
+	/// Proof: FastUnstake Queue (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen)
+	/// Storage: FastUnstake Head (r:1 w:0)
+	/// Proof: FastUnstake Head (max_values: Some(1), max_size: Some(5768), added: 6263, mode: MaxEncodedLen)
+	/// Storage: FastUnstake CounterForQueue (r:1 w:1)
+	/// Proof: FastUnstake CounterForQueue (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn deregister() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1223`
+		//  Estimated: `7253`
+		// Minimum execution time: 43_943_000 picoseconds.
+		Weight::from_parts(45_842_000, 7253)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: FastUnstake ErasToCheckPerBlock (r:0 w:1)
+	/// Proof: FastUnstake ErasToCheckPerBlock (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn control() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_677_000 picoseconds.
+		Weight::from_parts(2_849_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/glutton/Cargo.toml b/substrate/frame/glutton/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..65b01e8390b576fa961487d12051388395ad4c94
--- /dev/null
+++ b/substrate/frame/glutton/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-glutton"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for pushing a chain to its weight limits"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+blake2 = { version = "0.10.4", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+log = { version = "0.4.14", default-features = false }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"blake2/std",
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
diff --git a/substrate/frame/glutton/README.md b/substrate/frame/glutton/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8ad4f79171820a48fe0d9d94f6793a931840e6e6
--- /dev/null
+++ b/substrate/frame/glutton/README.md
@@ -0,0 +1,9 @@
+# WARNING
+
+**DO NOT USE ON VALUE-BEARING CHAINS. THIS PALLET IS ONLY INTENDED FOR TESTING USAGE.**
+
+# Glutton Pallet
+
+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`.
diff --git a/substrate/frame/glutton/src/benchmarking.rs b/substrate/frame/glutton/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..587207587456a025b52f6819ff658b40007c5af3
--- /dev/null
+++ b/substrate/frame/glutton/src/benchmarking.rs
@@ -0,0 +1,99 @@
+// 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.
+
+//! Glutton pallet benchmarking.
+//!
+//! Has to be compiled and run twice to calibrate on new hardware.
+
+#[cfg(feature = "runtime-benchmarks")]
+use super::*;
+
+use frame_benchmarking::benchmarks;
+use frame_support::{pallet_prelude::*, weights::constants::*};
+use frame_system::RawOrigin as SystemOrigin;
+use sp_runtime::{traits::One, Perbill};
+
+use crate::Pallet as Glutton;
+use frame_system::Pallet as System;
+
+benchmarks! {
+	initialize_pallet_grow {
+		let n in 0 .. 1_000;
+	}: {
+		Glutton::<T>::initialize_pallet(SystemOrigin::Root.into(), n, None).unwrap()
+	} verify {
+		assert_eq!(TrashDataCount::<T>::get(), n);
+	}
+
+	initialize_pallet_shrink {
+		let n in 0 .. 1_000;
+
+		Glutton::<T>::initialize_pallet(SystemOrigin::Root.into(), n, None).unwrap();
+	}: {
+		Glutton::<T>::initialize_pallet(SystemOrigin::Root.into(), 0, Some(n)).unwrap()
+	} verify {
+		assert_eq!(TrashDataCount::<T>::get(), 0);
+	}
+
+	waste_ref_time_iter {
+		let i in 0..100_000;
+	}: {
+		Glutton::<T>::waste_ref_time_iter(vec![0u8; 64], i);
+	}
+
+	waste_proof_size_some {
+		let i in 0..5_000;
+
+		(0..5000).for_each(|i| TrashData::<T>::insert(i, [i as u8; 1024]));
+	}: {
+		(0..i).for_each(|i| {
+			TrashData::<T>::get(i);
+		})
+	}
+
+	// For manual verification only.
+	on_idle_high_proof_waste {
+		(0..5000).for_each(|i| TrashData::<T>::insert(i, [i as u8; 1024]));
+		let _ = Glutton::<T>::set_compute(SystemOrigin::Root.into(), One::one());
+		let _ = Glutton::<T>::set_storage(SystemOrigin::Root.into(), One::one());
+	}: {
+		let weight = Glutton::<T>::on_idle(System::<T>::block_number(), Weight::from_parts(WEIGHT_REF_TIME_PER_MILLIS * 100, WEIGHT_PROOF_SIZE_PER_MB * 5));
+	}
+
+	// For manual verification only.
+	on_idle_low_proof_waste {
+		(0..5000).for_each(|i| TrashData::<T>::insert(i, [i as u8; 1024]));
+		let _ = Glutton::<T>::set_compute(SystemOrigin::Root.into(), One::one());
+		let _ = Glutton::<T>::set_storage(SystemOrigin::Root.into(), One::one());
+	}: {
+		let weight = Glutton::<T>::on_idle(System::<T>::block_number(), Weight::from_parts(WEIGHT_REF_TIME_PER_MILLIS * 100, WEIGHT_PROOF_SIZE_PER_KB * 20));
+	}
+
+	empty_on_idle {
+	}: {
+		// Enough weight do do nothing.
+		Glutton::<T>::on_idle(System::<T>::block_number(), T::WeightInfo::empty_on_idle());
+	}
+
+	set_compute {
+	}: _(SystemOrigin::Root, FixedU64::from_perbill(Perbill::from_percent(50)))
+
+	set_storage {
+	}: _(SystemOrigin::Root, FixedU64::from_perbill(Perbill::from_percent(50)))
+
+	impl_benchmark_test_suite!(Glutton, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/glutton/src/lib.rs b/substrate/frame/glutton/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c76cc30017cf00e639c0061ff73dc6f95062ab07
--- /dev/null
+++ b/substrate/frame/glutton/src/lib.rs
@@ -0,0 +1,378 @@
+// 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.
+
+//! # WARNING
+//!
+//! **DO NOT USE ON VALUE-BEARING CHAINS. THIS PALLET IS ONLY INTENDED FOR TESTING USAGE.**
+//!
+//! # Glutton Pallet
+//!
+//! Pallet that consumes `ref_time` and `proof_size` of a block. Based on the
+//! `Compute` and `Storage` parameters the pallet consumes the adequate amount
+//! of weight.
+
+#![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use blake2::{Blake2b512, Digest};
+use frame_support::{pallet_prelude::*, weights::WeightMeter, DefaultNoBound};
+use frame_system::pallet_prelude::*;
+use sp_io::hashing::twox_256;
+use sp_runtime::{traits::Zero, FixedPointNumber, FixedU64};
+use sp_std::{vec, vec::Vec};
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// The size of each value in the `TrashData` storage in bytes.
+pub const VALUE_SIZE: usize = 1024;
+/// Max number of entries for the `TrashData` map.
+pub const MAX_TRASH_DATA_ENTRIES: u32 = 65_000;
+/// Hard limit for any other resource limit (in units).
+pub const RESOURCE_HARD_LIMIT: FixedU64 = FixedU64::from_u32(10);
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The admin origin that can set computational limits and initialize the pallet.
+		type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Weight information for this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event {
+		/// The pallet has been (re)initialized.
+		PalletInitialized {
+			/// Whether the pallet has been re-initialized.
+			reinit: bool,
+		},
+		/// The computation limit has been updated.
+		ComputationLimitSet {
+			/// The computation limit.
+			compute: FixedU64,
+		},
+		/// The storage limit has been updated.
+		StorageLimitSet {
+			/// The storage limit.
+			storage: FixedU64,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The pallet was already initialized.
+		///
+		/// Set `witness_count` to `Some` to bypass this error.
+		AlreadyInitialized,
+
+		/// The limit was over [`crate::RESOURCE_HARD_LIMIT`].
+		InsaneLimit,
+	}
+
+	/// The proportion of the remaining `ref_time` to consume during `on_idle`.
+	///
+	/// `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 Compute<T: Config> = StorageValue<_, FixedU64, ValueQuery>;
+
+	/// The proportion of the remaining `proof_size` to consume during `on_idle`.
+	///
+	/// `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 Storage<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
+	/// set to 65k, which is just below the next jump at 16^4. This is important to reduce the proof
+	/// size benchmarking overestimate. The assumption here is that we won't have more than 65k *
+	/// 1KiB = 65MiB of proof size wasting in practice. However, this limit is not enforced, so the
+	/// pallet would also work out of the box with more entries, but its benchmarked proof weight
+	/// would possibly be underestimated in that case.
+	#[pallet::storage]
+	pub(super) type TrashData<T: Config> = StorageMap<
+		Hasher = Twox64Concat,
+		Key = u32,
+		Value = [u8; VALUE_SIZE],
+		QueryKind = OptionQuery,
+		MaxValues = ConstU32<MAX_TRASH_DATA_ENTRIES>,
+	>;
+
+	/// The current number of entries in `TrashData`.
+	#[pallet::storage]
+	pub(crate) type TrashDataCount<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		/// The compute limit.
+		pub compute: FixedU64,
+		/// The storage limit.
+		pub storage: FixedU64,
+		/// The amount of trash data for wasting proof size.
+		pub trash_data_count: u32,
+		#[serde(skip)]
+		/// The required configuration field.
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			assert!(
+				self.trash_data_count <= MAX_TRASH_DATA_ENTRIES,
+				"number of TrashData entries cannot be bigger than {:?}",
+				MAX_TRASH_DATA_ENTRIES
+			);
+
+			(0..self.trash_data_count)
+				.for_each(|i| TrashData::<T>::insert(i, Pallet::<T>::gen_value(i)));
+
+			TrashDataCount::<T>::set(self.trash_data_count);
+
+			assert!(self.compute <= RESOURCE_HARD_LIMIT, "Compute limit is insane");
+			<Compute<T>>::put(self.compute);
+
+			assert!(self.storage <= RESOURCE_HARD_LIMIT, "Storage limit is insane");
+			<Storage<T>>::put(self.storage);
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn integrity_test() {
+			assert!(
+				!T::WeightInfo::waste_ref_time_iter(1).ref_time().is_zero(),
+				"Weight zero; would get stuck in an infinite loop"
+			);
+			assert!(
+				!T::WeightInfo::waste_proof_size_some(1).proof_size().is_zero(),
+				"Weight zero; would get stuck in an infinite loop"
+			);
+		}
+
+		fn on_idle(_: BlockNumberFor<T>, remaining_weight: Weight) -> Weight {
+			let mut meter = WeightMeter::from_limit(remaining_weight);
+			if meter.try_consume(T::WeightInfo::empty_on_idle()).is_err() {
+				return T::WeightInfo::empty_on_idle()
+			}
+
+			let proof_size_limit =
+				Storage::<T>::get().saturating_mul_int(meter.remaining().proof_size());
+			let computation_weight_limit =
+				Compute::<T>::get().saturating_mul_int(meter.remaining().ref_time());
+			let mut meter = WeightMeter::from_limit(Weight::from_parts(
+				computation_weight_limit,
+				proof_size_limit,
+			));
+
+			Self::waste_at_most_proof_size(&mut meter);
+			Self::waste_at_most_ref_time(&mut meter);
+
+			meter.consumed()
+		}
+	}
+
+	#[pallet::call(weight = T::WeightInfo)]
+	impl<T: Config> Pallet<T> {
+		/// Initialize the pallet. Should be called once, if no genesis state was provided.
+		///
+		/// `current_count` is the current number of elements in `TrashData`. This can be set to
+		/// `None` when the pallet is first initialized.
+		///
+		/// Only callable by Root or `AdminOrigin`. A good default for `new_count` is `5_000`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(
+			T::WeightInfo::initialize_pallet_grow(witness_count.unwrap_or_default())
+				.max(T::WeightInfo::initialize_pallet_shrink(witness_count.unwrap_or_default()))
+		)]
+		pub fn initialize_pallet(
+			origin: OriginFor<T>,
+			new_count: u32,
+			witness_count: Option<u32>,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+
+			let current_count = TrashDataCount::<T>::get();
+			ensure!(
+				current_count == witness_count.unwrap_or_default(),
+				Error::<T>::AlreadyInitialized
+			);
+
+			if new_count > current_count {
+				(current_count..new_count)
+					.for_each(|i| TrashData::<T>::insert(i, Self::gen_value(i)));
+			} else {
+				(new_count..current_count).for_each(TrashData::<T>::remove);
+			}
+
+			Self::deposit_event(Event::PalletInitialized { reinit: witness_count.is_some() });
+			TrashDataCount::<T>::set(new_count);
+			Ok(())
+		}
+
+		/// Set how much of the remaining `ref_time` weight should be consumed by `on_idle`.
+		///
+		/// Only callable by Root or `AdminOrigin`.
+		#[pallet::call_index(1)]
+		pub fn set_compute(origin: OriginFor<T>, compute: FixedU64) -> DispatchResult {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+
+			ensure!(compute <= RESOURCE_HARD_LIMIT, Error::<T>::InsaneLimit);
+			Compute::<T>::set(compute);
+
+			Self::deposit_event(Event::ComputationLimitSet { compute });
+			Ok(())
+		}
+
+		/// Set how much of the remaining `proof_size` weight should be consumed by `on_idle`.
+		///
+		/// `1.0` means that all remaining `proof_size` will be consumed. The PoV benchmarking
+		/// results that are used here are likely an over-estimation. 100% intended consumption will
+		/// therefore translate to less than 100% actual consumption.
+		///
+		/// Only callable by Root or `AdminOrigin`.
+		#[pallet::call_index(2)]
+		pub fn set_storage(origin: OriginFor<T>, storage: FixedU64) -> DispatchResult {
+			T::AdminOrigin::ensure_origin_or_root(origin)?;
+
+			ensure!(storage <= RESOURCE_HARD_LIMIT, Error::<T>::InsaneLimit);
+			Storage::<T>::set(storage);
+
+			Self::deposit_event(Event::StorageLimitSet { storage });
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// Waste at most the remaining proof size of `meter`.
+		///
+		/// Tries to come as close to the limit as possible.
+		pub(crate) fn waste_at_most_proof_size(meter: &mut WeightMeter) {
+			let Ok(n) = Self::calculate_proof_size_iters(&meter) else { return };
+
+			meter.consume(T::WeightInfo::waste_proof_size_some(n));
+
+			(0..n).for_each(|i| {
+				TrashData::<T>::get(i);
+			});
+		}
+
+		/// Calculate how many times `waste_proof_size_some` should be called to fill up `meter`.
+		fn calculate_proof_size_iters(meter: &WeightMeter) -> Result<u32, ()> {
+			let base = T::WeightInfo::waste_proof_size_some(0);
+			let slope = T::WeightInfo::waste_proof_size_some(1).saturating_sub(base);
+
+			let remaining = meter.remaining().saturating_sub(base);
+			let iter_by_proof_size =
+				remaining.proof_size().checked_div(slope.proof_size()).ok_or(())?;
+			let iter_by_ref_time = remaining.ref_time().checked_div(slope.ref_time()).ok_or(())?;
+
+			if iter_by_proof_size > 0 && iter_by_proof_size <= iter_by_ref_time {
+				Ok(iter_by_proof_size as u32)
+			} else {
+				Err(())
+			}
+		}
+
+		/// Waste at most the remaining ref time weight of `meter`.
+		///
+		/// Tries to come as close to the limit as possible.
+		pub(crate) fn waste_at_most_ref_time(meter: &mut WeightMeter) {
+			let Ok(n) = Self::calculate_ref_time_iters(&meter) else { return };
+			meter.consume(T::WeightInfo::waste_ref_time_iter(n));
+
+			let clobber = Self::waste_ref_time_iter(vec![0u8; 64], n);
+
+			// By casting it into a vec we can hopefully prevent the compiler from optimizing it
+			// out. Note that `Blake2b512` produces 64 bytes, this is therefore impossible - but the
+			// compiler does not know that (hopefully).
+			debug_assert!(clobber.len() == 64);
+			if clobber.len() == 65 {
+				TrashData::<T>::insert(0, [clobber[0] as u8; VALUE_SIZE]);
+			}
+		}
+
+		/// Wastes some `ref_time`. Receives the previous result as an argument.
+		///
+		/// The ref_time of one iteration should be in the order of 1-10 ms.
+		pub(crate) fn waste_ref_time_iter(clobber: Vec<u8>, i: u32) -> Vec<u8> {
+			let mut hasher = Blake2b512::new();
+
+			// Blake2 has a very high speed of hashing so we make multiple hashes with it to
+			// waste more `ref_time` at once.
+			(0..i).for_each(|_| {
+				hasher.update(clobber.as_slice());
+			});
+
+			hasher.finalize().to_vec()
+		}
+
+		/// Calculate how many times `waste_ref_time_iter` should be called to fill up `meter`.
+		fn calculate_ref_time_iters(meter: &WeightMeter) -> Result<u32, ()> {
+			let base = T::WeightInfo::waste_ref_time_iter(0);
+			let slope = T::WeightInfo::waste_ref_time_iter(1).saturating_sub(base);
+			if !slope.proof_size().is_zero() || !base.proof_size().is_zero() {
+				return Err(())
+			}
+
+			match meter
+				.remaining()
+				.ref_time()
+				.saturating_sub(base.ref_time())
+				.checked_div(slope.ref_time())
+			{
+				Some(0) | None => Err(()),
+				Some(i) => Ok(i as u32),
+			}
+		}
+
+		/// Generate a pseudo-random deterministic value from a `seed`.
+		pub(crate) fn gen_value(seed: u32) -> [u8; VALUE_SIZE] {
+			let mut ret = [0u8; VALUE_SIZE];
+
+			for i in 0u32..(VALUE_SIZE as u32 / 32) {
+				let hash = (seed, i).using_encoded(twox_256);
+				ret[i as usize * 32..(i + 1) as usize * 32].copy_from_slice(&hash);
+			}
+
+			ret
+		}
+	}
+}
diff --git a/substrate/frame/glutton/src/mock.rs b/substrate/frame/glutton/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c79ddd53718eb5acabe6a63105a93ac725b87a35
--- /dev/null
+++ b/substrate/frame/glutton/src/mock.rs
@@ -0,0 +1,87 @@
+// 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.
+
+use super::*;
+use crate as pallet_glutton;
+
+use frame_support::{
+	assert_ok,
+	traits::{ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Glutton: pallet_glutton::{Pallet, Event},
+	}
+);
+
+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 = 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>;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type AdminOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+/// Set the `compute` and `storage` limits.
+///
+/// `1.0` corresponds to `100%`.
+pub fn set_limits(compute: f64, storage: f64) {
+	assert_ok!(Glutton::set_compute(RuntimeOrigin::root(), FixedU64::from_float(compute)));
+	assert_ok!(Glutton::set_storage(RuntimeOrigin::root(), FixedU64::from_float(storage)));
+}
diff --git a/substrate/frame/glutton/src/tests.rs b/substrate/frame/glutton/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1897ff63a70fb31a88c4effd192eb6db98404dca
--- /dev/null
+++ b/substrate/frame/glutton/src/tests.rs
@@ -0,0 +1,294 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2023 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 the glutton pallet.
+
+use super::{mock::*, *};
+
+use frame_support::{assert_err, assert_noop, assert_ok, weights::constants::*};
+use sp_runtime::{traits::One, Perbill};
+
+const CALIBRATION_ERROR: &'static str =
+	"Weight calibration failed. Please re-run the benchmarks on the same hardware.";
+
+#[test]
+fn initialize_pallet_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(TrashData::<Test>::get(0), None);
+
+		assert_noop!(
+			Glutton::initialize_pallet(RuntimeOrigin::signed(1), 3, None),
+			DispatchError::BadOrigin
+		);
+		assert_noop!(
+			Glutton::initialize_pallet(RuntimeOrigin::none(), 3, None),
+			DispatchError::BadOrigin
+		);
+
+		assert_ok!(Glutton::initialize_pallet(RuntimeOrigin::root(), 2, None));
+		System::assert_last_event(Event::PalletInitialized { reinit: false }.into());
+		assert_err!(
+			Glutton::initialize_pallet(RuntimeOrigin::root(), 2, None),
+			Error::<Test>::AlreadyInitialized
+		);
+
+		assert_eq!(TrashData::<Test>::get(0), Some(Pallet::<Test>::gen_value(0)));
+		assert_eq!(TrashData::<Test>::get(1), Some(Pallet::<Test>::gen_value(1)));
+		assert_eq!(TrashData::<Test>::get(2), None);
+
+		assert_eq!(TrashDataCount::<Test>::get(), 2);
+
+		assert_ok!(Glutton::initialize_pallet(RuntimeOrigin::root(), 20, Some(2)));
+
+		assert_eq!(TrashDataCount::<Test>::get(), 20);
+		assert_eq!(TrashData::<Test>::iter_keys().count(), 20);
+	});
+}
+
+#[test]
+fn expand_and_shrink_trash_data_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(TrashDataCount::<Test>::get(), 0);
+
+		assert_ok!(Glutton::initialize_pallet(RuntimeOrigin::root(), 5000, None));
+		assert_eq!(TrashDataCount::<Test>::get(), 5000);
+		assert_eq!(TrashData::<Test>::iter_keys().count(), 5000);
+
+		assert_ok!(Glutton::initialize_pallet(RuntimeOrigin::root(), 8000, Some(5000)));
+		assert_eq!(TrashDataCount::<Test>::get(), 8000);
+		assert_eq!(TrashData::<Test>::iter_keys().count(), 8000);
+
+		assert_ok!(Glutton::initialize_pallet(RuntimeOrigin::root(), 6000, Some(8000)));
+		assert_eq!(TrashDataCount::<Test>::get(), 6000);
+		assert_eq!(TrashData::<Test>::iter_keys().count(), 6000);
+
+		assert_noop!(
+			Glutton::initialize_pallet(RuntimeOrigin::root(), 0, None),
+			Error::<Test>::AlreadyInitialized
+		);
+		assert_ok!(Glutton::initialize_pallet(RuntimeOrigin::root(), 0, Some(6000)));
+		assert_eq!(TrashDataCount::<Test>::get(), 0);
+		assert_eq!(TrashData::<Test>::iter_keys().count(), 0);
+	});
+}
+
+#[test]
+fn setting_compute_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Compute::<Test>::get(), Zero::zero());
+
+		assert_ok!(Glutton::set_compute(RuntimeOrigin::root(), FixedU64::from_float(0.3)));
+		assert_eq!(Compute::<Test>::get(), FixedU64::from_float(0.3));
+		System::assert_last_event(
+			Event::ComputationLimitSet { compute: FixedU64::from_float(0.3) }.into(),
+		);
+
+		assert_noop!(
+			Glutton::set_compute(RuntimeOrigin::signed(1), FixedU64::from_float(0.5)),
+			DispatchError::BadOrigin
+		);
+		assert_noop!(
+			Glutton::set_compute(RuntimeOrigin::none(), FixedU64::from_float(0.5)),
+			DispatchError::BadOrigin
+		);
+	});
+}
+
+#[test]
+fn setting_compute_respects_limit() {
+	new_test_ext().execute_with(|| {
+		// < 1000% is fine
+		assert_ok!(Glutton::set_compute(RuntimeOrigin::root(), FixedU64::from_float(9.99)),);
+		// == 1000% is fine
+		assert_ok!(Glutton::set_compute(RuntimeOrigin::root(), FixedU64::from_u32(10)),);
+		// > 1000% is not
+		assert_noop!(
+			Glutton::set_compute(RuntimeOrigin::root(), FixedU64::from_float(10.01)),
+			Error::<Test>::InsaneLimit
+		);
+	});
+}
+
+#[test]
+fn setting_storage_works() {
+	new_test_ext().execute_with(|| {
+		assert!(Storage::<Test>::get().is_zero());
+
+		assert_ok!(Glutton::set_storage(RuntimeOrigin::root(), FixedU64::from_float(0.3)));
+		assert_eq!(Storage::<Test>::get(), FixedU64::from_float(0.3));
+		System::assert_last_event(
+			Event::StorageLimitSet { storage: FixedU64::from_float(0.3) }.into(),
+		);
+
+		assert_noop!(
+			Glutton::set_storage(RuntimeOrigin::signed(1), FixedU64::from_float(0.5)),
+			DispatchError::BadOrigin
+		);
+		assert_noop!(
+			Glutton::set_storage(RuntimeOrigin::none(), FixedU64::from_float(0.5)),
+			DispatchError::BadOrigin
+		);
+	});
+}
+
+#[test]
+fn setting_storage_respects_limit() {
+	new_test_ext().execute_with(|| {
+		// < 1000% is fine
+		assert_ok!(Glutton::set_storage(RuntimeOrigin::root(), FixedU64::from_float(9.99)),);
+		// == 1000% is fine
+		assert_ok!(Glutton::set_storage(RuntimeOrigin::root(), FixedU64::from_u32(10)),);
+		// > 1000% is not
+		assert_noop!(
+			Glutton::set_storage(RuntimeOrigin::root(), FixedU64::from_float(10.01)),
+			Error::<Test>::InsaneLimit
+		);
+	});
+}
+
+#[test]
+fn on_idle_works() {
+	new_test_ext().execute_with(|| {
+		set_limits(One::one(), One::one());
+
+		Glutton::on_idle(1, Weight::from_parts(20_000_000, 0));
+	});
+}
+
+/// Check that the expected is close enough to the consumed weight.
+#[test]
+fn on_idle_weight_high_proof_is_close_enough_works() {
+	new_test_ext().execute_with(|| {
+		set_limits(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);
+		assert!(got.all_lte(should), "Consumed too much weight");
+
+		let ratio = Perbill::from_rational(got.proof_size(), should.proof_size());
+		assert!(
+			ratio >= Perbill::from_percent(99),
+			"Too few proof size consumed, was only {ratio:?} of expected",
+		);
+
+		let ratio = Perbill::from_rational(got.ref_time(), should.ref_time());
+		assert!(
+			ratio >= Perbill::from_percent(99),
+			"Too few ref time consumed, was only {ratio:?} of expected",
+		);
+	});
+}
+
+#[test]
+fn on_idle_weight_low_proof_is_close_enough_works() {
+	new_test_ext().execute_with(|| {
+		set_limits(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);
+		assert!(got.all_lte(should), "Consumed too much weight");
+
+		let ratio = Perbill::from_rational(got.proof_size(), should.proof_size());
+		// Just a sanity check here for > 0
+		assert!(
+			ratio >= Perbill::from_percent(50),
+			"Too few proof size consumed, was only {ratio:?} of expected",
+		);
+
+		let ratio = Perbill::from_rational(got.ref_time(), should.ref_time());
+		assert!(
+			ratio >= Perbill::from_percent(99),
+			"Too few ref time consumed, was only {ratio:?} of expected",
+		);
+	});
+}
+
+#[test]
+fn on_idle_weight_over_unity_is_close_enough_works() {
+	new_test_ext().execute_with(|| {
+		// Para blocks get ~500ms compute and ~5MB proof size.
+		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);
+		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,
+		);
+
+		let consumed = Glutton::on_idle(1, max_block);
+		assert!(consumed.all_gt(max_block), "Must consume more than the block limit");
+		assert!(consumed.all_lte(want), "Consumed more than the requested weight");
+
+		let ratio = Perbill::from_rational(consumed.proof_size(), want.proof_size());
+		assert!(
+			ratio >= Perbill::from_percent(99),
+			"Too few proof size consumed, was only {ratio:?} of expected",
+		);
+
+		let ratio = Perbill::from_rational(consumed.ref_time(), want.ref_time());
+		assert!(
+			ratio >= Perbill::from_percent(99),
+			"Too few ref time consumed, was only {ratio:?} of expected",
+		);
+	});
+}
+
+#[test]
+fn waste_at_most_ref_time_weight_close_enough() {
+	new_test_ext().execute_with(|| {
+		let mut meter =
+			WeightMeter::from_limit(Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND, u64::MAX));
+		// Over-spending fails defensively.
+		Glutton::waste_at_most_ref_time(&mut meter);
+
+		// We require it to be under-spend by at most 1%.
+		assert!(
+			meter.consumed_ratio() >= Perbill::from_percent(99),
+			"{CALIBRATION_ERROR}\nConsumed too few: {:?}",
+			meter.consumed_ratio()
+		);
+	});
+}
+
+#[test]
+fn waste_at_most_proof_size_weight_close_enough() {
+	new_test_ext().execute_with(|| {
+		let mut meter =
+			WeightMeter::from_limit(Weight::from_parts(u64::MAX, WEIGHT_PROOF_SIZE_PER_MB * 5));
+		// Over-spending fails defensively.
+		Glutton::waste_at_most_proof_size(&mut meter);
+
+		// We require it to be under-spend by at most 1%.
+		assert!(
+			meter.consumed_ratio() >= Perbill::from_percent(99),
+			"{CALIBRATION_ERROR}\nConsumed too few: {:?}",
+			meter.consumed_ratio()
+		);
+	});
+}
+
+#[test]
+fn gen_value_works() {
+	let g0 = Pallet::<Test>::gen_value(0);
+	let g1 = Pallet::<Test>::gen_value(1);
+
+	assert_eq!(g0.len(), VALUE_SIZE);
+	assert_ne!(g0, g1, "Is distinct");
+	assert_ne!(g0, [0; VALUE_SIZE], "Is not zero");
+	assert_eq!(g0, Pallet::<Test>::gen_value(0), "Is deterministic");
+}
diff --git a/substrate/frame/glutton/src/weights.rs b/substrate/frame/glutton/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cbc0fb022f510889e66a403f1624c025faa5a7f8
--- /dev/null
+++ b/substrate/frame/glutton/src/weights.rs
@@ -0,0 +1,309 @@
+// 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.
+
+//! Autogenerated weights for pallet_glutton
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_glutton
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/glutton/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_glutton.
+pub trait WeightInfo {
+	fn initialize_pallet_grow(n: u32, ) -> Weight;
+	fn initialize_pallet_shrink(n: u32, ) -> Weight;
+	fn waste_ref_time_iter(i: u32, ) -> Weight;
+	fn waste_proof_size_some(i: u32, ) -> Weight;
+	fn on_idle_high_proof_waste() -> Weight;
+	fn on_idle_low_proof_waste() -> Weight;
+	fn empty_on_idle() -> Weight;
+	fn set_compute() -> Weight;
+	fn set_storage() -> Weight;
+}
+
+/// Weights for pallet_glutton using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Glutton TrashDataCount (r:1 w:1)
+	/// Proof: Glutton TrashDataCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:0 w:1000)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1000]`.
+	fn initialize_pallet_grow(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `86`
+		//  Estimated: `1489`
+		// Minimum execution time: 11_488_000 picoseconds.
+		Weight::from_parts(93_073_710, 1489)
+			// Standard Error: 22_390
+			.saturating_add(Weight::from_parts(9_572_012, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+	}
+	/// Storage: Glutton TrashDataCount (r:1 w:1)
+	/// Proof: Glutton TrashDataCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:0 w:1000)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1000]`.
+	fn initialize_pallet_shrink(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119`
+		//  Estimated: `1489`
+		// Minimum execution time: 11_378_000 picoseconds.
+		Weight::from_parts(5_591_508, 1489)
+			// Standard Error: 1_592
+			.saturating_add(Weight::from_parts(1_163_758, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+	}
+	/// The range of component `i` is `[0, 100000]`.
+	fn waste_ref_time_iter(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 669_000 picoseconds.
+		Weight::from_parts(990_745, 0)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(105_224, 0).saturating_mul(i.into()))
+	}
+	/// Storage: Glutton TrashData (r:5000 w:0)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	/// The range of component `i` is `[0, 5000]`.
+	fn waste_proof_size_some(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119114 + i * (1022 ±0)`
+		//  Estimated: `990 + i * (3016 ±0)`
+		// Minimum execution time: 435_000 picoseconds.
+		Weight::from_parts(66_547_542, 990)
+			// Standard Error: 4_557
+			.saturating_add(Weight::from_parts(5_851_324, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(i.into())))
+			.saturating_add(Weight::from_parts(0, 3016).saturating_mul(i.into()))
+	}
+	/// Storage: Glutton Storage (r:1 w:0)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton Compute (r:1 w:0)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:1737 w:0)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	fn on_idle_high_proof_waste() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1900497`
+		//  Estimated: `5239782`
+		// Minimum execution time: 67_699_845_000 picoseconds.
+		Weight::from_parts(67_893_204_000, 5239782)
+			.saturating_add(T::DbWeight::get().reads(1739_u64))
+	}
+	/// Storage: Glutton Storage (r:1 w:0)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton Compute (r:1 w:0)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:5 w:0)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	fn on_idle_low_proof_waste() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `9547`
+		//  Estimated: `16070`
+		// Minimum execution time: 122_297_527_000 picoseconds.
+		Weight::from_parts(122_394_818_000, 16070)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+	}
+	/// Storage: Glutton Storage (r:1 w:0)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton Compute (r:1 w:0)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn empty_on_idle() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `86`
+		//  Estimated: `1493`
+		// Minimum execution time: 5_882_000 picoseconds.
+		Weight::from_parts(6_138_000, 1493)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+	}
+	/// Storage: Glutton Compute (r:0 w:1)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn set_compute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_830_000 picoseconds.
+		Weight::from_parts(8_366_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Glutton Storage (r:0 w:1)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn set_storage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_933_000 picoseconds.
+		Weight::from_parts(8_213_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Glutton TrashDataCount (r:1 w:1)
+	/// Proof: Glutton TrashDataCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:0 w:1000)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1000]`.
+	fn initialize_pallet_grow(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `86`
+		//  Estimated: `1489`
+		// Minimum execution time: 11_488_000 picoseconds.
+		Weight::from_parts(93_073_710, 1489)
+			// Standard Error: 22_390
+			.saturating_add(Weight::from_parts(9_572_012, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
+	}
+	/// Storage: Glutton TrashDataCount (r:1 w:1)
+	/// Proof: Glutton TrashDataCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:0 w:1000)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1000]`.
+	fn initialize_pallet_shrink(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119`
+		//  Estimated: `1489`
+		// Minimum execution time: 11_378_000 picoseconds.
+		Weight::from_parts(5_591_508, 1489)
+			// Standard Error: 1_592
+			.saturating_add(Weight::from_parts(1_163_758, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
+	}
+	/// The range of component `i` is `[0, 100000]`.
+	fn waste_ref_time_iter(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 669_000 picoseconds.
+		Weight::from_parts(990_745, 0)
+			// Standard Error: 10
+			.saturating_add(Weight::from_parts(105_224, 0).saturating_mul(i.into()))
+	}
+	/// Storage: Glutton TrashData (r:5000 w:0)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	/// The range of component `i` is `[0, 5000]`.
+	fn waste_proof_size_some(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `119114 + i * (1022 ±0)`
+		//  Estimated: `990 + i * (3016 ±0)`
+		// Minimum execution time: 435_000 picoseconds.
+		Weight::from_parts(66_547_542, 990)
+			// Standard Error: 4_557
+			.saturating_add(Weight::from_parts(5_851_324, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(i.into())))
+			.saturating_add(Weight::from_parts(0, 3016).saturating_mul(i.into()))
+	}
+	/// Storage: Glutton Storage (r:1 w:0)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton Compute (r:1 w:0)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:1737 w:0)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	fn on_idle_high_proof_waste() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1900497`
+		//  Estimated: `5239782`
+		// Minimum execution time: 67_699_845_000 picoseconds.
+		Weight::from_parts(67_893_204_000, 5239782)
+			.saturating_add(RocksDbWeight::get().reads(1739_u64))
+	}
+	/// Storage: Glutton Storage (r:1 w:0)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton Compute (r:1 w:0)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton TrashData (r:5 w:0)
+	/// Proof: Glutton TrashData (max_values: Some(65000), max_size: Some(1036), added: 3016, mode: MaxEncodedLen)
+	fn on_idle_low_proof_waste() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `9547`
+		//  Estimated: `16070`
+		// Minimum execution time: 122_297_527_000 picoseconds.
+		Weight::from_parts(122_394_818_000, 16070)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+	}
+	/// Storage: Glutton Storage (r:1 w:0)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Glutton Compute (r:1 w:0)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn empty_on_idle() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `86`
+		//  Estimated: `1493`
+		// Minimum execution time: 5_882_000 picoseconds.
+		Weight::from_parts(6_138_000, 1493)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+	}
+	/// Storage: Glutton Compute (r:0 w:1)
+	/// Proof: Glutton Compute (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn set_compute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_830_000 picoseconds.
+		Weight::from_parts(8_366_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Glutton Storage (r:0 w:1)
+	/// Proof: Glutton Storage (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn set_storage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_933_000 picoseconds.
+		Weight::from_parts(8_213_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/grandpa/Cargo.toml b/substrate/frame/grandpa/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b9f8cc5c2cb896f7b4a3cade129d1780a377977d
--- /dev/null
+++ b/substrate/frame/grandpa/Cargo.toml
@@ -0,0 +1,92 @@
+[package]
+name = "pallet-grandpa"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for GRANDPA finality gadget"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-authorship = { version = "4.0.0-dev", default-features = false, path = "../authorship" }
+pallet-session = { version = "4.0.0-dev", default-features = false, path = "../session" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto", features = ["serde"] }
+sp-consensus-grandpa = { version = "4.0.0-dev", default-features = false, path = "../../primitives/consensus/grandpa", features = ["serde"] }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core", features = ["serde"] }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../primitives/session" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+grandpa = { package = "finality-grandpa", version = "0.16.2", features = ["derive-codec"] }
+frame-benchmarking = { version = "4.0.0-dev", path = "../benchmarking" }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-offences = { version = "4.0.0-dev", path = "../offences" }
+pallet-staking = { version = "4.0.0-dev", path = "../staking" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../staking/reward-curve" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../timestamp" }
+sp-keyring = { version = "24.0.0", path = "../../primitives/keyring" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-authorship/std",
+	"pallet-balances/std",
+	"pallet-offences/std",
+	"pallet-session/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-application-crypto/std",
+	"sp-consensus-grandpa/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-offences/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-authorship/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-offences/try-runtime",
+	"pallet-session/try-runtime",
+	"pallet-staking/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/grandpa/README.md b/substrate/frame/grandpa/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..84b181a8b31e1c102215f72d6a2d59724a9af596
--- /dev/null
+++ b/substrate/frame/grandpa/README.md
@@ -0,0 +1,12 @@
+GRANDPA Consensus module for runtime.
+
+This manages the GRANDPA authority set ready for the native code.
+These authorities are only for GRANDPA finality, not for consensus overall.
+
+In the future, it will also handle misbehavior reports, and on-chain
+finality notifications.
+
+For full integration with GRANDPA, the `GrandpaApi` should be implemented.
+The necessary items are re-exported via the `fg_primitives` crate.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/grandpa/src/benchmarking.rs b/substrate/frame/grandpa/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7a87f0c4b07881864aefd8eb5aad55ea41fc713d
--- /dev/null
+++ b/substrate/frame/grandpa/src/benchmarking.rs
@@ -0,0 +1,107 @@
+// 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.
+
+//! Benchmarks for the GRANDPA pallet.
+
+use super::{Pallet as Grandpa, *};
+use frame_benchmarking::v1::benchmarks;
+use frame_system::RawOrigin;
+use sp_core::H256;
+
+benchmarks! {
+	check_equivocation_proof {
+		let x in 0 .. 1;
+
+		// NOTE: generated with the test below `test_generate_equivocation_report_blob`.
+		// the output should be deterministic since the keys we use are static.
+		// with the current benchmark setup it is not possible to generate this
+		// programatically from the benchmark setup.
+		const EQUIVOCATION_PROOF_BLOB: [u8; 257] = [
+			1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 136, 220, 52, 23,
+			213, 5, 142, 196, 180, 80, 62, 12, 18, 234, 26, 10, 137, 190, 32,
+			15, 233, 137, 34, 66, 61, 67, 52, 1, 79, 166, 176, 238, 207, 48,
+			195, 55, 171, 225, 252, 130, 161, 56, 151, 29, 193, 32, 25, 157,
+			249, 39, 80, 193, 214, 96, 167, 147, 25, 130, 45, 42, 64, 208, 182,
+			164, 10, 0, 0, 0, 0, 0, 0, 0, 234, 236, 231, 45, 70, 171, 135, 246,
+			136, 153, 38, 167, 91, 134, 150, 242, 215, 83, 56, 238, 16, 119, 55,
+			170, 32, 69, 255, 248, 164, 20, 57, 50, 122, 115, 135, 96, 80, 203,
+			131, 232, 73, 23, 149, 86, 174, 59, 193, 92, 121, 76, 154, 211, 44,
+			96, 10, 84, 159, 133, 211, 56, 103, 0, 59, 2, 96, 20, 69, 2, 32,
+			179, 16, 184, 108, 76, 215, 64, 195, 78, 143, 73, 177, 139, 20, 144,
+			98, 231, 41, 117, 255, 220, 115, 41, 59, 27, 75, 56, 10, 0, 0, 0, 0,
+			0, 0, 0, 128, 179, 250, 48, 211, 76, 10, 70, 74, 230, 219, 139, 96,
+			78, 88, 112, 33, 170, 44, 184, 59, 200, 155, 143, 128, 40, 222, 179,
+			210, 190, 84, 16, 182, 21, 34, 94, 28, 193, 163, 226, 51, 251, 134,
+			233, 187, 121, 63, 157, 240, 165, 203, 92, 16, 146, 120, 190, 229,
+			251, 129, 29, 45, 32, 29, 6
+		];
+
+		let equivocation_proof1: sp_consensus_grandpa::EquivocationProof<H256, u64> =
+			Decode::decode(&mut &EQUIVOCATION_PROOF_BLOB[..]).unwrap();
+
+		let equivocation_proof2 = equivocation_proof1.clone();
+	}: {
+		sp_consensus_grandpa::check_equivocation_proof(equivocation_proof1);
+	} verify {
+		assert!(sp_consensus_grandpa::check_equivocation_proof(equivocation_proof2));
+	}
+
+	note_stalled {
+		let delay = 1000u32.into();
+		let best_finalized_block_number = 1u32.into();
+
+	}: _(RawOrigin::Root, delay, best_finalized_block_number)
+	verify {
+		assert!(Grandpa::<T>::stalled().is_some());
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		crate::mock::new_test_ext(vec![(1, 1), (2, 1), (3, 1)]),
+		crate::mock::Test,
+	);
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::*;
+
+	#[test]
+	fn test_generate_equivocation_report_blob() {
+		let authorities = crate::tests::test_authorities();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+
+		new_test_ext_raw_authorities(authorities).execute_with(|| {
+			start_era(1);
+
+			// generate an equivocation proof, with two votes in the same round for
+			// different block hashes signed by the same key
+			let equivocation_proof = generate_equivocation_proof(
+				1,
+				(1, H256::random(), 10, &equivocation_keyring),
+				(1, H256::random(), 10, &equivocation_keyring),
+			);
+
+			println!("equivocation_proof: {:?}", equivocation_proof);
+			println!("equivocation_proof.encode(): {:?}", equivocation_proof.encode());
+		});
+	}
+}
diff --git a/substrate/frame/grandpa/src/default_weights.rs b/substrate/frame/grandpa/src/default_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5ccf3794880eb4cc89608aa14a1957aec1509aa7
--- /dev/null
+++ b/substrate/frame/grandpa/src/default_weights.rs
@@ -0,0 +1,57 @@
+// 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.
+
+//! Default weights for the GRANDPA Pallet
+//! This file was not auto-generated.
+
+use frame_support::weights::{
+	constants::{RocksDbWeight as DbWeight, WEIGHT_REF_TIME_PER_MICROS, WEIGHT_REF_TIME_PER_NANOS},
+	Weight,
+};
+
+impl crate::WeightInfo for () {
+	fn report_equivocation(validator_count: u32, max_nominators_per_validator: u32) -> Weight {
+		// we take the validator set count from the membership proof to
+		// calculate the weight but we set a floor of 100 validators.
+		let validator_count = validator_count.max(100) as u64;
+
+		// checking membership proof
+		Weight::from_parts(35u64 * WEIGHT_REF_TIME_PER_MICROS, 0)
+			.saturating_add(
+				Weight::from_parts(175u64 * WEIGHT_REF_TIME_PER_NANOS, 0)
+					.saturating_mul(validator_count),
+			)
+			.saturating_add(DbWeight::get().reads(5))
+			// check equivocation proof
+			.saturating_add(Weight::from_parts(95u64 * WEIGHT_REF_TIME_PER_MICROS, 0))
+			// report offence
+			.saturating_add(Weight::from_parts(110u64 * WEIGHT_REF_TIME_PER_MICROS, 0))
+			.saturating_add(Weight::from_parts(
+				25u64 * WEIGHT_REF_TIME_PER_MICROS * max_nominators_per_validator as u64,
+				0,
+			))
+			.saturating_add(DbWeight::get().reads(14 + 3 * max_nominators_per_validator as u64))
+			.saturating_add(DbWeight::get().writes(10 + 3 * max_nominators_per_validator as u64))
+			// fetching set id -> session index mappings
+			.saturating_add(DbWeight::get().reads(2))
+	}
+
+	fn note_stalled() -> Weight {
+		Weight::from_parts(3u64 * WEIGHT_REF_TIME_PER_MICROS, 0)
+			.saturating_add(DbWeight::get().writes(1))
+	}
+}
diff --git a/substrate/frame/grandpa/src/equivocation.rs b/substrate/frame/grandpa/src/equivocation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..16727f79a58d589182f5dbfbd01e9cf8674efabb
--- /dev/null
+++ b/substrate/frame/grandpa/src/equivocation.rs
@@ -0,0 +1,290 @@
+// 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.
+
+//! An opt-in utility module for reporting equivocations.
+//!
+//! This module defines an offence type for GRANDPA equivocations
+//! and some utility traits to wire together:
+//! - a key ownership proof system (e.g. to prove that a given authority was
+//! part of a session);
+//! - a system for reporting offences;
+//! - a system for signing and submitting transactions;
+//! - a way to get the current block author;
+//!
+//! These can be used in an offchain context in order to submit equivocation
+//! reporting extrinsics (from the client that's running the GRANDPA protocol).
+//! And in a runtime context, so that the GRANDPA module can validate the
+//! equivocation proofs in the extrinsic and report the offences.
+//!
+//! IMPORTANT:
+//! When using this module for enabling equivocation reporting it is required
+//! that the `ValidateUnsigned` for the GRANDPA pallet is used in the runtime
+//! definition.
+
+use codec::{self as codec, Decode, Encode};
+use frame_support::traits::{Get, KeyOwnerProofSystem};
+use frame_system::pallet_prelude::BlockNumberFor;
+use log::{error, info};
+use sp_consensus_grandpa::{AuthorityId, EquivocationProof, RoundNumber, SetId, KEY_TYPE};
+use sp_runtime::{
+	transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
+		TransactionValidityError, ValidTransaction,
+	},
+	DispatchError, KeyTypeId, Perbill,
+};
+use sp_session::{GetSessionNumber, GetValidatorCount};
+use sp_staking::{
+	offence::{Kind, Offence, OffenceReportSystem, ReportOffence},
+	SessionIndex,
+};
+use sp_std::prelude::*;
+
+use super::{Call, Config, Error, Pallet, LOG_TARGET};
+
+/// A round number and set id which point on the time of an offence.
+#[derive(Copy, Clone, PartialOrd, Ord, Eq, PartialEq, Encode, Decode)]
+pub struct TimeSlot {
+	// The order of these matters for `derive(Ord)`.
+	/// Grandpa Set ID.
+	pub set_id: SetId,
+	/// Round number.
+	pub round: RoundNumber,
+}
+
+/// GRANDPA equivocation offence report.
+pub struct EquivocationOffence<Offender> {
+	/// Time slot at which this incident happened.
+	pub time_slot: TimeSlot,
+	/// The session index in which the incident happened.
+	pub session_index: SessionIndex,
+	/// The size of the validator set at the time of the offence.
+	pub validator_set_count: u32,
+	/// The authority which produced this equivocation.
+	pub offender: Offender,
+}
+
+impl<Offender: Clone> Offence<Offender> for EquivocationOffence<Offender> {
+	const ID: Kind = *b"grandpa:equivoca";
+	type TimeSlot = TimeSlot;
+
+	fn offenders(&self) -> Vec<Offender> {
+		vec![self.offender.clone()]
+	}
+
+	fn session_index(&self) -> SessionIndex {
+		self.session_index
+	}
+
+	fn validator_set_count(&self) -> u32 {
+		self.validator_set_count
+	}
+
+	fn time_slot(&self) -> Self::TimeSlot {
+		self.time_slot
+	}
+
+	// The formula is min((3k / n)^2, 1)
+	// where k = offenders_number and n = validators_number
+	fn slash_fraction(&self, offenders_count: u32) -> Perbill {
+		// Perbill type domain is [0, 1] by definition
+		Perbill::from_rational(3 * offenders_count, self.validator_set_count).square()
+	}
+}
+
+/// GRANDPA equivocation offence report system.
+///
+/// This type implements `OffenceReportSystem` such that:
+/// - Equivocation reports are published on-chain as unsigned extrinsic via
+///   `offchain::SendTransactionTypes`.
+/// - On-chain validity checks and processing are mostly delegated to the user provided generic
+///   types implementing `KeyOwnerProofSystem` and `ReportOffence` traits.
+/// - Offence reporter for unsigned transactions is fetched via the the authorship pallet.
+pub struct EquivocationReportSystem<T, R, P, L>(sp_std::marker::PhantomData<(T, R, P, L)>);
+
+impl<T, R, P, L>
+	OffenceReportSystem<
+		Option<T::AccountId>,
+		(EquivocationProof<T::Hash, BlockNumberFor<T>>, T::KeyOwnerProof),
+	> for EquivocationReportSystem<T, R, P, L>
+where
+	T: Config + pallet_authorship::Config + frame_system::offchain::SendTransactionTypes<Call<T>>,
+	R: ReportOffence<
+		T::AccountId,
+		P::IdentificationTuple,
+		EquivocationOffence<P::IdentificationTuple>,
+	>,
+	P: KeyOwnerProofSystem<(KeyTypeId, AuthorityId), Proof = T::KeyOwnerProof>,
+	P::IdentificationTuple: Clone,
+	L: Get<u64>,
+{
+	type Longevity = L;
+
+	fn publish_evidence(
+		evidence: (EquivocationProof<T::Hash, BlockNumberFor<T>>, T::KeyOwnerProof),
+	) -> Result<(), ()> {
+		use frame_system::offchain::SubmitTransaction;
+		let (equivocation_proof, key_owner_proof) = evidence;
+
+		let call = Call::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof),
+			key_owner_proof,
+		};
+		let res = SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into());
+		match res {
+			Ok(_) => info!(target: LOG_TARGET, "Submitted equivocation report"),
+			Err(e) => error!(target: LOG_TARGET, "Error submitting equivocation report: {:?}", e),
+		}
+		res
+	}
+
+	fn check_evidence(
+		evidence: (EquivocationProof<T::Hash, BlockNumberFor<T>>, T::KeyOwnerProof),
+	) -> Result<(), TransactionValidityError> {
+		let (equivocation_proof, key_owner_proof) = evidence;
+
+		// Check the membership proof to extract the offender's id
+		let key = (KEY_TYPE, equivocation_proof.offender().clone());
+		let offender = P::check_proof(key, key_owner_proof).ok_or(InvalidTransaction::BadProof)?;
+
+		// Check if the offence has already been reported, and if so then we can discard the report.
+		let time_slot =
+			TimeSlot { set_id: equivocation_proof.set_id(), round: equivocation_proof.round() };
+		if R::is_known_offence(&[offender], &time_slot) {
+			Err(InvalidTransaction::Stale.into())
+		} else {
+			Ok(())
+		}
+	}
+
+	fn process_evidence(
+		reporter: Option<T::AccountId>,
+		evidence: (EquivocationProof<T::Hash, BlockNumberFor<T>>, T::KeyOwnerProof),
+	) -> Result<(), DispatchError> {
+		let (equivocation_proof, key_owner_proof) = evidence;
+		let reporter = reporter.or_else(|| <pallet_authorship::Pallet<T>>::author());
+		let offender = equivocation_proof.offender().clone();
+
+		// We check the equivocation within the context of its set id (and
+		// associated session) and round. We also need to know the validator
+		// set count when the offence since it is required to calculate the
+		// slash amount.
+		let set_id = equivocation_proof.set_id();
+		let round = equivocation_proof.round();
+		let session_index = key_owner_proof.session();
+		let validator_set_count = key_owner_proof.validator_count();
+
+		// Validate equivocation proof (check votes are different and signatures are valid).
+		if !sp_consensus_grandpa::check_equivocation_proof(equivocation_proof) {
+			return Err(Error::<T>::InvalidEquivocationProof.into())
+		}
+
+		// Validate the key ownership proof extracting the id of the offender.
+		let offender = P::check_proof((KEY_TYPE, offender), key_owner_proof)
+			.ok_or(Error::<T>::InvalidKeyOwnershipProof)?;
+
+		// Fetch the current and previous sets last session index.
+		// For genesis set there's no previous set.
+		let previous_set_id_session_index = if set_id != 0 {
+			let idx = crate::SetIdSession::<T>::get(set_id - 1)
+				.ok_or(Error::<T>::InvalidEquivocationProof)?;
+			Some(idx)
+		} else {
+			None
+		};
+
+		let set_id_session_index =
+			crate::SetIdSession::<T>::get(set_id).ok_or(Error::<T>::InvalidEquivocationProof)?;
+
+		// Check that the session id for the membership proof is within the
+		// bounds of the set id reported in the equivocation.
+		if session_index > set_id_session_index ||
+			previous_set_id_session_index
+				.map(|previous_index| session_index <= previous_index)
+				.unwrap_or(false)
+		{
+			return Err(Error::<T>::InvalidEquivocationProof.into())
+		}
+
+		let offence = EquivocationOffence {
+			time_slot: TimeSlot { set_id, round },
+			session_index,
+			offender,
+			validator_set_count,
+		};
+
+		R::report_offence(reporter.into_iter().collect(), offence)
+			.map_err(|_| Error::<T>::DuplicateOffenceReport)?;
+
+		Ok(())
+	}
+}
+
+/// Methods for the `ValidateUnsigned` implementation:
+/// It restricts calls to `report_equivocation_unsigned` to local calls (i.e. extrinsics generated
+/// on this node) or that already in a block. This guarantees that only block authors can include
+/// unsigned equivocation reports.
+impl<T: Config> Pallet<T> {
+	pub fn validate_unsigned(source: TransactionSource, call: &Call<T>) -> TransactionValidity {
+		if let Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } = call {
+			// discard equivocation report not coming from the local node
+			match source {
+				TransactionSource::Local | TransactionSource::InBlock => { /* allowed */ },
+				_ => {
+					log::warn!(
+						target: LOG_TARGET,
+						"rejecting unsigned report equivocation transaction because it is not local/in-block."
+					);
+
+					return InvalidTransaction::Call.into()
+				},
+			}
+
+			// Check report validity
+			let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
+			T::EquivocationReportSystem::check_evidence(evidence)?;
+
+			let longevity =
+				<T::EquivocationReportSystem as OffenceReportSystem<_, _>>::Longevity::get();
+
+			ValidTransaction::with_tag_prefix("GrandpaEquivocation")
+				// We assign the maximum priority for any equivocation report.
+				.priority(TransactionPriority::max_value())
+				// Only one equivocation report for the same offender at the same slot.
+				.and_provides((
+					equivocation_proof.offender().clone(),
+					equivocation_proof.set_id(),
+					equivocation_proof.round(),
+				))
+				.longevity(longevity)
+				// We don't propagate this. This can never be included on a remote node.
+				.propagate(false)
+				.build()
+		} else {
+			InvalidTransaction::Call.into()
+		}
+	}
+
+	pub fn pre_dispatch(call: &Call<T>) -> Result<(), TransactionValidityError> {
+		if let Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } = call {
+			let evidence = (*equivocation_proof.clone(), key_owner_proof.clone());
+			T::EquivocationReportSystem::check_evidence(evidence)
+		} else {
+			Err(InvalidTransaction::Call.into())
+		}
+	}
+}
diff --git a/substrate/frame/grandpa/src/lib.rs b/substrate/frame/grandpa/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a0e707ac4148c81777a99014fb907a23ee0ca67
--- /dev/null
+++ b/substrate/frame/grandpa/src/lib.rs
@@ -0,0 +1,625 @@
+// 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.
+
+//! GRANDPA Consensus module for runtime.
+//!
+//! This manages the GRANDPA authority set ready for the native code.
+//! These authorities are only for GRANDPA finality, not for consensus overall.
+//!
+//! In the future, it will also handle misbehavior reports, and on-chain
+//! finality notifications.
+//!
+//! For full integration with GRANDPA, the `GrandpaApi` should be implemented.
+//! The necessary items are re-exported via the `fg_primitives` crate.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+// Re-export since this is necessary for `impl_apis` in runtime.
+pub use sp_consensus_grandpa::{
+	self as fg_primitives, AuthorityId, AuthorityList, AuthorityWeight, VersionedAuthorityList,
+};
+
+use codec::{self as codec, Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{DispatchResultWithPostInfo, Pays},
+	pallet_prelude::Get,
+	storage,
+	traits::OneSessionHandler,
+	weights::Weight,
+	WeakBoundedVec,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use scale_info::TypeInfo;
+use sp_consensus_grandpa::{
+	ConsensusLog, EquivocationProof, ScheduledChange, SetId, GRANDPA_AUTHORITIES_KEY,
+	GRANDPA_ENGINE_ID, RUNTIME_LOG_TARGET as LOG_TARGET,
+};
+use sp_runtime::{generic::DigestItem, traits::Zero, DispatchResult};
+use sp_session::{GetSessionNumber, GetValidatorCount};
+use sp_staking::{offence::OffenceReportSystem, SessionIndex};
+use sp_std::prelude::*;
+
+mod default_weights;
+mod equivocation;
+pub mod migrations;
+
+#[cfg(any(feature = "runtime-benchmarks", test))]
+mod benchmarking;
+#[cfg(all(feature = "std", test))]
+mod mock;
+#[cfg(all(feature = "std", test))]
+mod tests;
+
+pub use equivocation::{EquivocationOffence, EquivocationReportSystem, TimeSlot};
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{dispatch::DispatchResult, pallet_prelude::*};
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The event type of this module.
+		type RuntimeEvent: From<Event>
+			+ Into<<Self as frame_system::Config>::RuntimeEvent>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weights for this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Max Authorities in use
+		#[pallet::constant]
+		type MaxAuthorities: Get<u32>;
+
+		/// The maximum number of nominators for each validator.
+		#[pallet::constant]
+		type MaxNominators: Get<u32>;
+
+		/// The maximum number of entries to keep in the set id to session index mapping.
+		///
+		/// Since the `SetIdSession` map is only used for validating equivocations this
+		/// value should relate to the bonding duration of whatever staking system is
+		/// being used (if any). If equivocation handling is not enabled then this value
+		/// can be zero.
+		#[pallet::constant]
+		type MaxSetIdSessionEntries: Get<u64>;
+
+		/// The proof of key ownership, used for validating equivocation reports
+		/// The proof include the session index and validator count of the
+		/// session at which the equivocation occurred.
+		type KeyOwnerProof: Parameter + GetSessionNumber + GetValidatorCount;
+
+		/// The equivocation handling subsystem, defines methods to check/report an
+		/// offence and for submitting a transaction to report an equivocation
+		/// (from an offchain context).
+		type EquivocationReportSystem: OffenceReportSystem<
+			Option<Self::AccountId>,
+			(EquivocationProof<Self::Hash, BlockNumberFor<Self>>, Self::KeyOwnerProof),
+		>;
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_finalize(block_number: BlockNumberFor<T>) {
+			// check for scheduled pending authority set changes
+			if let Some(pending_change) = <PendingChange<T>>::get() {
+				// emit signal if we're at the block that scheduled the change
+				if block_number == pending_change.scheduled_at {
+					if let Some(median) = pending_change.forced {
+						Self::deposit_log(ConsensusLog::ForcedChange(
+							median,
+							ScheduledChange {
+								delay: pending_change.delay,
+								next_authorities: pending_change.next_authorities.to_vec(),
+							},
+						))
+					} else {
+						Self::deposit_log(ConsensusLog::ScheduledChange(ScheduledChange {
+							delay: pending_change.delay,
+							next_authorities: pending_change.next_authorities.to_vec(),
+						}));
+					}
+				}
+
+				// enact the change if we've reached the enacting block
+				if block_number == pending_change.scheduled_at + pending_change.delay {
+					Self::set_grandpa_authorities(&pending_change.next_authorities);
+					Self::deposit_event(Event::NewAuthorities {
+						authority_set: pending_change.next_authorities.to_vec(),
+					});
+					<PendingChange<T>>::kill();
+				}
+			}
+
+			// check for scheduled pending state changes
+			match <State<T>>::get() {
+				StoredState::PendingPause { scheduled_at, delay } => {
+					// signal change to pause
+					if block_number == scheduled_at {
+						Self::deposit_log(ConsensusLog::Pause(delay));
+					}
+
+					// enact change to paused state
+					if block_number == scheduled_at + delay {
+						<State<T>>::put(StoredState::Paused);
+						Self::deposit_event(Event::Paused);
+					}
+				},
+				StoredState::PendingResume { scheduled_at, delay } => {
+					// signal change to resume
+					if block_number == scheduled_at {
+						Self::deposit_log(ConsensusLog::Resume(delay));
+					}
+
+					// enact change to live state
+					if block_number == scheduled_at + delay {
+						<State<T>>::put(StoredState::Live);
+						Self::deposit_event(Event::Resumed);
+					}
+				},
+				_ => {},
+			}
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Report voter equivocation/misbehavior. This method will verify the
+		/// equivocation proof and validate the given key ownership proof
+		/// against the extracted offender. If both are valid, the offence
+		/// will be reported.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::report_equivocation(
+			key_owner_proof.validator_count(),
+			T::MaxNominators::get(),
+		))]
+		pub fn report_equivocation(
+			origin: OriginFor<T>,
+			equivocation_proof: Box<EquivocationProof<T::Hash, BlockNumberFor<T>>>,
+			key_owner_proof: T::KeyOwnerProof,
+		) -> DispatchResultWithPostInfo {
+			let reporter = ensure_signed(origin)?;
+
+			T::EquivocationReportSystem::process_evidence(
+				Some(reporter),
+				(*equivocation_proof, key_owner_proof),
+			)?;
+			// Waive the fee since the report is valid and beneficial
+			Ok(Pays::No.into())
+		}
+
+		/// Report voter equivocation/misbehavior. This method will verify the
+		/// equivocation proof and validate the given key ownership proof
+		/// against the extracted offender. If both are valid, the offence
+		/// will be reported.
+		///
+		/// This extrinsic must be called unsigned and it is expected that only
+		/// block authors will call it (validated in `ValidateUnsigned`), as such
+		/// if the block author is defined it will be defined as the equivocation
+		/// reporter.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::report_equivocation(
+			key_owner_proof.validator_count(),
+			T::MaxNominators::get(),
+		))]
+		pub fn report_equivocation_unsigned(
+			origin: OriginFor<T>,
+			equivocation_proof: Box<EquivocationProof<T::Hash, BlockNumberFor<T>>>,
+			key_owner_proof: T::KeyOwnerProof,
+		) -> DispatchResultWithPostInfo {
+			ensure_none(origin)?;
+
+			T::EquivocationReportSystem::process_evidence(
+				None,
+				(*equivocation_proof, key_owner_proof),
+			)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Note that the current authority set of the GRANDPA finality gadget has stalled.
+		///
+		/// This will trigger a forced authority set change at the beginning of the next session, to
+		/// be enacted `delay` blocks after that. The `delay` should be high enough to safely assume
+		/// that the block signalling the forced change will not be re-orged e.g. 1000 blocks.
+		/// The block production rate (which may be slowed down because of finality lagging) should
+		/// be taken into account when choosing the `delay`. The GRANDPA voters based on the new
+		/// authority will start voting on top of `best_finalized_block_number` for new finalized
+		/// blocks. `best_finalized_block_number` should be the highest of the latest finalized
+		/// block of all validators of the new authority set.
+		///
+		/// Only callable by root.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::note_stalled())]
+		pub fn note_stalled(
+			origin: OriginFor<T>,
+			delay: BlockNumberFor<T>,
+			best_finalized_block_number: BlockNumberFor<T>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			Self::on_stalled(delay, best_finalized_block_number);
+			Ok(())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(fn deposit_event)]
+	pub enum Event {
+		/// New authority set has been applied.
+		NewAuthorities { authority_set: AuthorityList },
+		/// Current authority set has been paused.
+		Paused,
+		/// Current authority set has been resumed.
+		Resumed,
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Attempt to signal GRANDPA pause when the authority set isn't live
+		/// (either paused or already pending pause).
+		PauseFailed,
+		/// Attempt to signal GRANDPA resume when the authority set isn't paused
+		/// (either live or already pending resume).
+		ResumeFailed,
+		/// Attempt to signal GRANDPA change with one already pending.
+		ChangePending,
+		/// Cannot signal forced change so soon after last.
+		TooSoon,
+		/// A key ownership proof provided as part of an equivocation report is invalid.
+		InvalidKeyOwnershipProof,
+		/// An equivocation proof provided as part of an equivocation report is invalid.
+		InvalidEquivocationProof,
+		/// A given equivocation report is valid but already previously reported.
+		DuplicateOffenceReport,
+	}
+
+	#[pallet::type_value]
+	pub(super) fn DefaultForState<T: Config>() -> StoredState<BlockNumberFor<T>> {
+		StoredState::Live
+	}
+
+	/// State of the current authority set.
+	#[pallet::storage]
+	#[pallet::getter(fn state)]
+	pub(super) type State<T: Config> =
+		StorageValue<_, StoredState<BlockNumberFor<T>>, ValueQuery, DefaultForState<T>>;
+
+	/// Pending change: (signaled at, scheduled change).
+	#[pallet::storage]
+	#[pallet::getter(fn pending_change)]
+	pub(super) type PendingChange<T: Config> =
+		StorageValue<_, StoredPendingChange<BlockNumberFor<T>, T::MaxAuthorities>>;
+
+	/// next block number where we can force a change.
+	#[pallet::storage]
+	#[pallet::getter(fn next_forced)]
+	pub(super) type NextForced<T: Config> = StorageValue<_, BlockNumberFor<T>>;
+
+	/// `true` if we are currently stalled.
+	#[pallet::storage]
+	#[pallet::getter(fn stalled)]
+	pub(super) type Stalled<T: Config> = StorageValue<_, (BlockNumberFor<T>, BlockNumberFor<T>)>;
+
+	/// The number of changes (both in terms of keys and underlying economic responsibilities)
+	/// in the "set" of Grandpa validators from genesis.
+	#[pallet::storage]
+	#[pallet::getter(fn current_set_id)]
+	pub(super) type CurrentSetId<T: Config> = StorageValue<_, SetId, ValueQuery>;
+
+	/// A mapping from grandpa set ID to the index of the *most recent* session for which its
+	/// members were responsible.
+	///
+	/// This is only used for validating equivocation proofs. An equivocation proof must
+	/// contains a key-ownership proof for a given session, therefore we need a way to tie
+	/// together sessions and GRANDPA set ids, i.e. we need to validate that a validator
+	/// was the owner of a given key on a given session, and what the active set ID was
+	/// during that session.
+	///
+	/// TWOX-NOTE: `SetId` is not under user control.
+	#[pallet::storage]
+	#[pallet::getter(fn session_for_set)]
+	pub(super) type SetIdSession<T: Config> = StorageMap<_, Twox64Concat, SetId, SessionIndex>;
+
+	#[derive(frame_support::DefaultNoBound)]
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub authorities: AuthorityList,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			CurrentSetId::<T>::put(SetId::default());
+			Pallet::<T>::initialize(&self.authorities)
+		}
+	}
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+
+		fn validate_unsigned(source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			Self::validate_unsigned(source, call)
+		}
+
+		fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError> {
+			Self::pre_dispatch(call)
+		}
+	}
+}
+
+pub trait WeightInfo {
+	fn report_equivocation(validator_count: u32, max_nominators_per_validator: u32) -> Weight;
+	fn note_stalled() -> Weight;
+}
+
+/// Bounded version of `AuthorityList`, `Limit` being the bound
+pub type BoundedAuthorityList<Limit> = WeakBoundedVec<(AuthorityId, AuthorityWeight), Limit>;
+
+/// A stored pending change.
+/// `Limit` is the bound for `next_authorities`
+#[derive(Encode, Decode, TypeInfo, MaxEncodedLen)]
+#[codec(mel_bound(N: MaxEncodedLen, Limit: Get<u32>))]
+#[scale_info(skip_type_params(Limit))]
+pub struct StoredPendingChange<N, Limit> {
+	/// The block number this was scheduled at.
+	pub scheduled_at: N,
+	/// The delay in blocks until it will be applied.
+	pub delay: N,
+	/// The next authority set, weakly bounded in size by `Limit`.
+	pub next_authorities: BoundedAuthorityList<Limit>,
+	/// If defined it means the change was forced and the given block number
+	/// indicates the median last finalized block when the change was signaled.
+	pub forced: Option<N>,
+}
+
+/// Current state of the GRANDPA authority set. State transitions must happen in
+/// the same order of states defined below, e.g. `Paused` implies a prior
+/// `PendingPause`.
+#[derive(Decode, Encode, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(test, derive(Debug, PartialEq))]
+pub enum StoredState<N> {
+	/// The current authority set is live, and GRANDPA is enabled.
+	Live,
+	/// There is a pending pause event which will be enacted at the given block
+	/// height.
+	PendingPause {
+		/// Block at which the intention to pause was scheduled.
+		scheduled_at: N,
+		/// Number of blocks after which the change will be enacted.
+		delay: N,
+	},
+	/// The current GRANDPA authority set is paused.
+	Paused,
+	/// There is a pending resume event which will be enacted at the given block
+	/// height.
+	PendingResume {
+		/// Block at which the intention to resume was scheduled.
+		scheduled_at: N,
+		/// Number of blocks after which the change will be enacted.
+		delay: N,
+	},
+}
+
+impl<T: Config> Pallet<T> {
+	/// Get the current set of authorities, along with their respective weights.
+	pub fn grandpa_authorities() -> AuthorityList {
+		storage::unhashed::get_or_default::<VersionedAuthorityList>(GRANDPA_AUTHORITIES_KEY).into()
+	}
+
+	/// Set the current set of authorities, along with their respective weights.
+	fn set_grandpa_authorities(authorities: &AuthorityList) {
+		storage::unhashed::put(GRANDPA_AUTHORITIES_KEY, &VersionedAuthorityList::from(authorities));
+	}
+
+	/// Schedule GRANDPA to pause starting in the given number of blocks.
+	/// Cannot be done when already paused.
+	pub fn schedule_pause(in_blocks: BlockNumberFor<T>) -> DispatchResult {
+		if let StoredState::Live = <State<T>>::get() {
+			let scheduled_at = <frame_system::Pallet<T>>::block_number();
+			<State<T>>::put(StoredState::PendingPause { delay: in_blocks, scheduled_at });
+
+			Ok(())
+		} else {
+			Err(Error::<T>::PauseFailed.into())
+		}
+	}
+
+	/// Schedule a resume of GRANDPA after pausing.
+	pub fn schedule_resume(in_blocks: BlockNumberFor<T>) -> DispatchResult {
+		if let StoredState::Paused = <State<T>>::get() {
+			let scheduled_at = <frame_system::Pallet<T>>::block_number();
+			<State<T>>::put(StoredState::PendingResume { delay: in_blocks, scheduled_at });
+
+			Ok(())
+		} else {
+			Err(Error::<T>::ResumeFailed.into())
+		}
+	}
+
+	/// Schedule a change in the authorities.
+	///
+	/// The change will be applied at the end of execution of the block
+	/// `in_blocks` after the current block. This value may be 0, in which
+	/// case the change is applied at the end of the current block.
+	///
+	/// If the `forced` parameter is defined, this indicates that the current
+	/// set has been synchronously determined to be offline and that after
+	/// `in_blocks` the given change should be applied. The given block number
+	/// indicates the median last finalized block number and it should be used
+	/// as the canon block when starting the new grandpa voter.
+	///
+	/// No change should be signaled while any change is pending. Returns
+	/// an error if a change is already pending.
+	pub fn schedule_change(
+		next_authorities: AuthorityList,
+		in_blocks: BlockNumberFor<T>,
+		forced: Option<BlockNumberFor<T>>,
+	) -> DispatchResult {
+		if !<PendingChange<T>>::exists() {
+			let scheduled_at = <frame_system::Pallet<T>>::block_number();
+
+			if forced.is_some() {
+				if Self::next_forced().map_or(false, |next| next > scheduled_at) {
+					return Err(Error::<T>::TooSoon.into())
+				}
+
+				// only allow the next forced change when twice the window has passed since
+				// this one.
+				<NextForced<T>>::put(scheduled_at + in_blocks * 2u32.into());
+			}
+
+			let next_authorities = WeakBoundedVec::<_, T::MaxAuthorities>::force_from(
+				next_authorities,
+				Some(
+					"Warning: The number of authorities given is too big. \
+					A runtime configuration adjustment may be needed.",
+				),
+			);
+
+			<PendingChange<T>>::put(StoredPendingChange {
+				delay: in_blocks,
+				scheduled_at,
+				next_authorities,
+				forced,
+			});
+
+			Ok(())
+		} else {
+			Err(Error::<T>::ChangePending.into())
+		}
+	}
+
+	/// Deposit one of this module's logs.
+	fn deposit_log(log: ConsensusLog<BlockNumberFor<T>>) {
+		let log = DigestItem::Consensus(GRANDPA_ENGINE_ID, log.encode());
+		<frame_system::Pallet<T>>::deposit_log(log);
+	}
+
+	// Perform module initialization, abstracted so that it can be called either through genesis
+	// config builder or through `on_genesis_session`.
+	fn initialize(authorities: &AuthorityList) {
+		if !authorities.is_empty() {
+			assert!(Self::grandpa_authorities().is_empty(), "Authorities are already initialized!");
+			Self::set_grandpa_authorities(authorities);
+		}
+
+		// NOTE: initialize first session of first set. this is necessary for
+		// the genesis set and session since we only update the set -> session
+		// mapping whenever a new session starts, i.e. through `on_new_session`.
+		SetIdSession::<T>::insert(0, 0);
+	}
+
+	/// Submits an extrinsic to report an equivocation. This method will create
+	/// an unsigned extrinsic with a call to `report_equivocation_unsigned` and
+	/// will push the transaction to the pool. Only useful in an offchain
+	/// context.
+	pub fn submit_unsigned_equivocation_report(
+		equivocation_proof: EquivocationProof<T::Hash, BlockNumberFor<T>>,
+		key_owner_proof: T::KeyOwnerProof,
+	) -> Option<()> {
+		T::EquivocationReportSystem::publish_evidence((equivocation_proof, key_owner_proof)).ok()
+	}
+
+	fn on_stalled(further_wait: BlockNumberFor<T>, median: BlockNumberFor<T>) {
+		// when we record old authority sets we could try to figure out _who_
+		// failed. until then, we can't meaningfully guard against
+		// `next == last` the way that normal session changes do.
+		<Stalled<T>>::put((further_wait, median));
+	}
+}
+
+impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
+	type Public = AuthorityId;
+}
+
+impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T>
+where
+	T: pallet_session::Config,
+{
+	type Key = AuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, AuthorityId)>,
+	{
+		let authorities = validators.map(|(_, k)| (k, 1)).collect::<Vec<_>>();
+		Self::initialize(&authorities);
+	}
+
+	fn on_new_session<'a, I: 'a>(changed: bool, validators: I, _queued_validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, AuthorityId)>,
+	{
+		// Always issue a change if `session` says that the validators have changed.
+		// Even if their session keys are the same as before, the underlying economic
+		// identities have changed.
+		let current_set_id = if changed || <Stalled<T>>::exists() {
+			let next_authorities = validators.map(|(_, k)| (k, 1)).collect::<Vec<_>>();
+
+			let res = if let Some((further_wait, median)) = <Stalled<T>>::take() {
+				Self::schedule_change(next_authorities, further_wait, Some(median))
+			} else {
+				Self::schedule_change(next_authorities, Zero::zero(), None)
+			};
+
+			if res.is_ok() {
+				let current_set_id = CurrentSetId::<T>::mutate(|s| {
+					*s += 1;
+					*s
+				});
+
+				let max_set_id_session_entries = T::MaxSetIdSessionEntries::get().max(1);
+				if current_set_id >= max_set_id_session_entries {
+					SetIdSession::<T>::remove(current_set_id - max_set_id_session_entries);
+				}
+
+				current_set_id
+			} else {
+				// either the session module signalled that the validators have changed
+				// or the set was stalled. but since we didn't successfully schedule
+				// an authority set change we do not increment the set id.
+				Self::current_set_id()
+			}
+		} else {
+			// nothing's changed, neither economic conditions nor session keys. update the pointer
+			// of the current set.
+			Self::current_set_id()
+		};
+
+		// update the mapping to note that the current set corresponds to the
+		// latest equivalent session (i.e. now).
+		let session_index = <pallet_session::Pallet<T>>::current_index();
+		SetIdSession::<T>::insert(current_set_id, &session_index);
+	}
+
+	fn on_disabled(i: u32) {
+		Self::deposit_log(ConsensusLog::OnDisabled(i as u64))
+	}
+}
diff --git a/substrate/frame/grandpa/src/migrations.rs b/substrate/frame/grandpa/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6307cbdd3b05685906b14a3c519325457bf9545e
--- /dev/null
+++ b/substrate/frame/grandpa/src/migrations.rs
@@ -0,0 +1,65 @@
+// 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_support::{
+	traits::{Get, OnRuntimeUpgrade},
+	weights::Weight,
+};
+
+use crate::{Config, CurrentSetId, SetIdSession, LOG_TARGET};
+
+/// Version 4.
+pub mod v4;
+
+/// This migration will clean up all stale set id -> session entries from the
+/// `SetIdSession` storage map, only the latest `max_set_id_session_entries`
+/// will be kept.
+///
+/// This migration should be added with a runtime upgrade that introduces the
+/// `MaxSetIdSessionEntries` constant to the pallet (although it could also be
+/// done later on).
+pub struct CleanupSetIdSessionMap<T>(sp_std::marker::PhantomData<T>);
+impl<T: Config> OnRuntimeUpgrade for CleanupSetIdSessionMap<T> {
+	fn on_runtime_upgrade() -> Weight {
+		// NOTE: since this migration will loop over all stale entries in the
+		// map we need to set some cutoff value, otherwise the migration might
+		// take too long to run. for scenarios where there are that many entries
+		// to cleanup a multiblock migration will be needed instead.
+		if CurrentSetId::<T>::get() > 25_000 {
+			log::warn!(
+				target: LOG_TARGET,
+				"CleanupSetIdSessionMap migration was aborted since there are too many entries to cleanup."
+			);
+
+			return T::DbWeight::get().reads(1)
+		}
+
+		cleanup_set_id_sesion_map::<T>()
+	}
+}
+
+fn cleanup_set_id_sesion_map<T: Config>() -> Weight {
+	let until_set_id = CurrentSetId::<T>::get().saturating_sub(T::MaxSetIdSessionEntries::get());
+
+	for set_id in 0..=until_set_id {
+		SetIdSession::<T>::remove(set_id);
+	}
+
+	T::DbWeight::get()
+		.reads(1)
+		.saturating_add(T::DbWeight::get().writes(until_set_id + 1))
+}
diff --git a/substrate/frame/grandpa/src/migrations/v4.rs b/substrate/frame/grandpa/src/migrations/v4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8604296b6e57b9829851213f7843fa0b0a3c31fa
--- /dev/null
+++ b/substrate/frame/grandpa/src/migrations/v4.rs
@@ -0,0 +1,111 @@
+// 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::LOG_TARGET;
+use frame_support::{
+	traits::{Get, StorageVersion},
+	weights::Weight,
+};
+use sp_io::hashing::twox_128;
+
+/// The old prefix.
+pub const OLD_PREFIX: &[u8] = b"GrandpaFinality";
+
+/// Migrate the entire storage of this pallet to a new prefix.
+///
+/// This new prefix must be the same as the one set in construct_runtime. For safety, use
+/// `PalletInfo` to get it, as:
+/// `<Runtime as frame_system::Config>::PalletInfo::name::<GrandpaPallet>`.
+///
+/// The old storage prefix, `GrandpaFinality` is hardcoded in the migration code.
+pub fn migrate<T: crate::Config, N: AsRef<str>>(new_pallet_name: N) -> Weight {
+	if new_pallet_name.as_ref().as_bytes() == OLD_PREFIX {
+		log::info!(
+			target: LOG_TARGET,
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return Weight::zero()
+	}
+	let storage_version = StorageVersion::get::<crate::Pallet<T>>();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration to v3.1 for grandpa with storage version {:?}",
+		storage_version,
+	);
+
+	if storage_version <= 3 {
+		log::info!("new prefix: {}", new_pallet_name.as_ref());
+		frame_support::storage::migration::move_pallet(
+			OLD_PREFIX,
+			new_pallet_name.as_ref().as_bytes(),
+		);
+
+		StorageVersion::new(4).put::<crate::Pallet<T>>();
+
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::pre_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migration<T: crate::Config, N: AsRef<str>>(new: N) {
+	let new = new.as_ref();
+	log::info!("pre-migration grandpa test with new = {}", new);
+
+	// the next key must exist, and start with the hash of `OLD_PREFIX`.
+	let next_key = sp_io::storage::next_key(&twox_128(OLD_PREFIX)).unwrap();
+	assert!(next_key.starts_with(&twox_128(OLD_PREFIX)));
+
+	// The pallet version is already stored using the pallet name
+	let storage_key = StorageVersion::storage_key::<crate::Pallet<T>>();
+
+	// ensure nothing is stored in the new prefix.
+	assert!(
+		sp_io::storage::next_key(&twox_128(new.as_bytes())).map_or(
+			// either nothing is there
+			true,
+			// or we ensure that it has no common prefix with twox_128(new),
+			// or isn't the pallet version that is already stored using the pallet name
+			|next_key| {
+				!next_key.starts_with(&twox_128(new.as_bytes())) || next_key == storage_key
+			},
+		),
+		"unexpected next_key({}) = {:?}",
+		new,
+		sp_core::hexdisplay::HexDisplay::from(
+			&sp_io::storage::next_key(&twox_128(new.as_bytes())).unwrap()
+		),
+	);
+	// ensure storage version is 3.
+	assert_eq!(StorageVersion::get::<crate::Pallet<T>>(), 3);
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migration() {
+	log::info!("post-migration grandpa");
+
+	// Assert that nothing remains at the old prefix
+	assert!(sp_io::storage::next_key(&twox_128(OLD_PREFIX))
+		.map_or(true, |next_key| !next_key.starts_with(&twox_128(OLD_PREFIX))));
+}
diff --git a/substrate/frame/grandpa/src/mock.rs b/substrate/frame/grandpa/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fd4d737dc493faebcb311d8a845029deb3b7e233
--- /dev/null
+++ b/substrate/frame/grandpa/src/mock.rs
@@ -0,0 +1,367 @@
+// 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.
+
+//! Test utilities
+
+#![cfg(test)]
+
+use crate::{self as pallet_grandpa, AuthorityId, AuthorityList, Config, ConsensusLog};
+use ::grandpa as finality_grandpa;
+use codec::Encode;
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, SequentialPhragmen,
+};
+use frame_support::{
+	parameter_types,
+	traits::{ConstU128, ConstU32, ConstU64, KeyOwnerProofSystem, OnFinalize, OnInitialize},
+};
+use pallet_session::historical as pallet_session_historical;
+use sp_consensus_grandpa::{RoundNumber, SetId, GRANDPA_ENGINE_ID};
+use sp_core::{crypto::KeyTypeId, H256};
+use sp_keyring::Ed25519Keyring;
+use sp_runtime::{
+	curve::PiecewiseLinear,
+	impl_opaque_keys,
+	testing::{TestXt, UintAuthorityId},
+	traits::{IdentityLookup, OpaqueKeys},
+	BuildStorage, DigestItem, Perbill,
+};
+use sp_staking::{EraIndex, SessionIndex};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Authorship: pallet_authorship,
+		Timestamp: pallet_timestamp,
+		Balances: pallet_balances,
+		Staking: pallet_staking,
+		Session: pallet_session,
+		Grandpa: pallet_grandpa,
+		Offences: pallet_offences,
+		Historical: pallet_session_historical,
+	}
+);
+
+impl_opaque_keys! {
+	pub struct TestSessionKeys {
+		pub grandpa_authority: super::Pallet<Test>,
+	}
+}
+
+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 RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Hashing = sp_runtime::traits::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<u128>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+impl<C> frame_system::offchain::SendTransactionTypes<C> for Test
+where
+	RuntimeCall: From<C>,
+{
+	type OverarchingCall = RuntimeCall;
+	type Extrinsic = TestXt<RuntimeCall, ()>;
+}
+
+parameter_types! {
+	pub const Period: u64 = 1;
+	pub const Offset: u64 = 0;
+}
+
+/// Custom `SessionHandler` since we use `TestSessionKeys` as `Keys`.
+impl pallet_session::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = u64;
+	type ValidatorIdOf = pallet_staking::StashOf<Self>;
+	type ShouldEndSession = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Self, Staking>;
+	type SessionHandler = <TestSessionKeys as OpaqueKeys>::KeyTypeIdProviders;
+	type Keys = TestSessionKeys;
+	type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Test {
+	type FullIdentification = pallet_staking::Exposure<u64, u128>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Self>;
+}
+
+impl pallet_authorship::Config for Test {
+	type FindAuthor = ();
+	type EventHandler = ();
+}
+
+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 MaxHolds = ();
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<3>;
+	type WeightInfo = ();
+}
+
+pallet_staking_reward_curve::build! {
+	const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
+		min_inflation: 0_025_000u64,
+		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 SessionsPerEra: SessionIndex = 3;
+	pub const BondingDuration: EraIndex = 3;
+	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(17);
+	pub static ElectionsBoundsOnChain: ElectionBounds = ElectionBoundsBuilder::default().build();
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Test;
+	type Solver = SequentialPhragmen<u64, Perbill>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = ConstU32<100>;
+	type Bounds = ElectionsBoundsOnChain;
+}
+
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+	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 HistoryDepth = ConstU32<84>;
+	type EventListeners = ();
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+impl pallet_offences::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
+	type OnOffenceHandler = Staking;
+}
+
+parameter_types! {
+	pub const ReportLongevity: u64 =
+		BondingDuration::get() as u64 * SessionsPerEra::get() as u64 * Period::get();
+	pub const MaxSetIdSessionEntries: u32 = BondingDuration::get() * SessionsPerEra::get();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type MaxAuthorities = ConstU32<100>;
+	type MaxNominators = ConstU32<1000>;
+	type MaxSetIdSessionEntries = MaxSetIdSessionEntries;
+	type KeyOwnerProof = <Historical as KeyOwnerProofSystem<(KeyTypeId, AuthorityId)>>::Proof;
+	type EquivocationReportSystem =
+		super::EquivocationReportSystem<Self, Offences, Historical, ReportLongevity>;
+}
+
+pub fn grandpa_log(log: ConsensusLog<u64>) -> DigestItem {
+	DigestItem::Consensus(GRANDPA_ENGINE_ID, log.encode())
+}
+
+pub fn to_authorities(vec: Vec<(u64, u64)>) -> AuthorityList {
+	vec.into_iter()
+		.map(|(id, weight)| (UintAuthorityId(id).to_public_key::<AuthorityId>(), weight))
+		.collect()
+}
+
+pub fn extract_keyring(id: &AuthorityId) -> Ed25519Keyring {
+	let mut raw_public = [0; 32];
+	raw_public.copy_from_slice(id.as_ref());
+	Ed25519Keyring::from_raw_public(raw_public).unwrap()
+}
+
+pub fn new_test_ext(vec: Vec<(u64, u64)>) -> sp_io::TestExternalities {
+	new_test_ext_raw_authorities(to_authorities(vec))
+}
+
+pub fn new_test_ext_raw_authorities(authorities: AuthorityList) -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let balances: Vec<_> = (0..authorities.len()).map(|i| (i as u64, 10_000_000)).collect();
+
+	pallet_balances::GenesisConfig::<Test> { balances }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	// stashes are the index.
+	let session_keys: Vec<_> = authorities
+		.iter()
+		.enumerate()
+		.map(|(i, (k, _))| {
+			(
+				i as u64,
+				i as u64,
+				TestSessionKeys { grandpa_authority: AuthorityId::from(k.clone()) },
+			)
+		})
+		.collect();
+
+	// NOTE: this will initialize the grandpa authorities
+	// through OneSessionHandler::on_genesis_session
+	pallet_session::GenesisConfig::<Test> { keys: session_keys }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	// controllers are the same as stash
+	let stakers: Vec<_> = (0..authorities.len())
+		.map(|i| (i as u64, i as u64, 10_000, pallet_staking::StakerStatus::<u64>::Validator))
+		.collect();
+
+	let staking_config = pallet_staking::GenesisConfig::<Test> {
+		stakers,
+		validator_count: 8,
+		force_era: pallet_staking::Forcing::ForceNew,
+		minimum_validator_count: 0,
+		invulnerables: vec![],
+		..Default::default()
+	};
+
+	staking_config.assimilate_storage(&mut t).unwrap();
+
+	t.into()
+}
+
+pub fn start_session(session_index: SessionIndex) {
+	for i in Session::current_index()..session_index {
+		System::on_finalize(System::block_number());
+		Session::on_finalize(System::block_number());
+		Staking::on_finalize(System::block_number());
+		Grandpa::on_finalize(System::block_number());
+
+		let parent_hash = if System::block_number() > 1 {
+			let hdr = System::finalize();
+			hdr.hash()
+		} else {
+			System::parent_hash()
+		};
+
+		System::reset_events();
+		System::initialize(&(i as u64 + 1), &parent_hash, &Default::default());
+		System::set_block_number((i + 1).into());
+		Timestamp::set_timestamp(System::block_number() * 6000);
+
+		System::on_initialize(System::block_number());
+		Session::on_initialize(System::block_number());
+		Staking::on_initialize(System::block_number());
+		Grandpa::on_initialize(System::block_number());
+	}
+
+	assert_eq!(Session::current_index(), session_index);
+}
+
+pub fn start_era(era_index: EraIndex) {
+	start_session((era_index * 3).into());
+	assert_eq!(Staking::current_era(), Some(era_index));
+}
+
+pub fn initialize_block(number: u64, parent_hash: H256) {
+	System::reset_events();
+	System::initialize(&number, &parent_hash, &Default::default());
+}
+
+pub fn generate_equivocation_proof(
+	set_id: SetId,
+	vote1: (RoundNumber, H256, u64, &Ed25519Keyring),
+	vote2: (RoundNumber, H256, u64, &Ed25519Keyring),
+) -> sp_consensus_grandpa::EquivocationProof<H256, u64> {
+	let signed_prevote = |round, hash, number, keyring: &Ed25519Keyring| {
+		let prevote = finality_grandpa::Prevote { target_hash: hash, target_number: number };
+
+		let prevote_msg = finality_grandpa::Message::Prevote(prevote.clone());
+		let payload = sp_consensus_grandpa::localized_payload(round, set_id, &prevote_msg);
+		let signed = keyring.sign(&payload).into();
+		(prevote, signed)
+	};
+
+	let (prevote1, signed1) = signed_prevote(vote1.0, vote1.1, vote1.2, vote1.3);
+	let (prevote2, signed2) = signed_prevote(vote2.0, vote2.1, vote2.2, vote2.3);
+
+	sp_consensus_grandpa::EquivocationProof::new(
+		set_id,
+		sp_consensus_grandpa::Equivocation::Prevote(finality_grandpa::Equivocation {
+			round_number: vote1.0,
+			identity: vote1.3.public().into(),
+			first: (prevote1, signed1),
+			second: (prevote2, signed2),
+		}),
+	)
+}
diff --git a/substrate/frame/grandpa/src/tests.rs b/substrate/frame/grandpa/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..59d73ee729ee8c9c9b9c04672ba05568986d5987
--- /dev/null
+++ b/substrate/frame/grandpa/src/tests.rs
@@ -0,0 +1,916 @@
+// 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 the module.
+
+#![cfg(test)]
+
+use super::{Call, Event, *};
+use crate::mock::*;
+use fg_primitives::ScheduledChange;
+use frame_support::{
+	assert_err, assert_noop, assert_ok,
+	dispatch::{GetDispatchInfo, Pays},
+	traits::{Currency, KeyOwnerProofSystem, OnFinalize, OneSessionHandler},
+};
+use frame_system::{EventRecord, Phase};
+use sp_core::H256;
+use sp_keyring::Ed25519Keyring;
+use sp_runtime::testing::Digest;
+
+#[test]
+fn authorities_change_logged() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		initialize_block(1, Default::default());
+		Grandpa::schedule_change(to_authorities(vec![(4, 1), (5, 1), (6, 1)]), 0, None).unwrap();
+
+		System::note_finished_extrinsics();
+		Grandpa::on_finalize(1);
+
+		let header = System::finalize();
+		assert_eq!(
+			header.digest,
+			Digest {
+				logs: vec![grandpa_log(ConsensusLog::ScheduledChange(ScheduledChange {
+					delay: 0,
+					next_authorities: to_authorities(vec![(4, 1), (5, 1), (6, 1)])
+				})),],
+			}
+		);
+
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Finalization,
+				event: Event::NewAuthorities {
+					authority_set: to_authorities(vec![(4, 1), (5, 1), (6, 1)])
+				}
+				.into(),
+				topics: vec![],
+			},]
+		);
+	});
+}
+
+#[test]
+fn authorities_change_logged_after_delay() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		initialize_block(1, Default::default());
+		Grandpa::schedule_change(to_authorities(vec![(4, 1), (5, 1), (6, 1)]), 1, None).unwrap();
+		Grandpa::on_finalize(1);
+		let header = System::finalize();
+		assert_eq!(
+			header.digest,
+			Digest {
+				logs: vec![grandpa_log(ConsensusLog::ScheduledChange(ScheduledChange {
+					delay: 1,
+					next_authorities: to_authorities(vec![(4, 1), (5, 1), (6, 1)])
+				})),],
+			}
+		);
+
+		// no change at this height.
+		assert_eq!(System::events(), vec![]);
+
+		initialize_block(2, header.hash());
+		System::note_finished_extrinsics();
+		Grandpa::on_finalize(2);
+
+		let _header = System::finalize();
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Finalization,
+				event: Event::NewAuthorities {
+					authority_set: to_authorities(vec![(4, 1), (5, 1), (6, 1)])
+				}
+				.into(),
+				topics: vec![],
+			},]
+		);
+	});
+}
+
+#[test]
+fn cannot_schedule_change_when_one_pending() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		initialize_block(1, Default::default());
+		Grandpa::schedule_change(to_authorities(vec![(4, 1), (5, 1), (6, 1)]), 1, None).unwrap();
+		assert!(<PendingChange<Test>>::exists());
+		assert_noop!(
+			Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None),
+			Error::<Test>::ChangePending
+		);
+
+		Grandpa::on_finalize(1);
+		let header = System::finalize();
+
+		initialize_block(2, header.hash());
+		assert!(<PendingChange<Test>>::exists());
+		assert_noop!(
+			Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None),
+			Error::<Test>::ChangePending
+		);
+
+		Grandpa::on_finalize(2);
+		let header = System::finalize();
+
+		initialize_block(3, header.hash());
+		assert!(!<PendingChange<Test>>::exists());
+		assert_ok!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None));
+
+		Grandpa::on_finalize(3);
+		let _header = System::finalize();
+	});
+}
+
+#[test]
+fn dispatch_forced_change() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		initialize_block(1, Default::default());
+		Grandpa::schedule_change(to_authorities(vec![(4, 1), (5, 1), (6, 1)]), 5, Some(0)).unwrap();
+
+		assert!(<PendingChange<Test>>::exists());
+		assert_noop!(
+			Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, Some(0)),
+			Error::<Test>::ChangePending
+		);
+
+		Grandpa::on_finalize(1);
+		let mut header = System::finalize();
+
+		for i in 2..7 {
+			initialize_block(i, header.hash());
+			assert!(<PendingChange<Test>>::get().unwrap().forced.is_some());
+			assert_eq!(Grandpa::next_forced(), Some(11));
+			assert_noop!(
+				Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None),
+				Error::<Test>::ChangePending
+			);
+			assert_noop!(
+				Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, Some(0)),
+				Error::<Test>::ChangePending
+			);
+
+			Grandpa::on_finalize(i);
+			header = System::finalize();
+		}
+
+		// change has been applied at the end of block 6.
+		// add a normal change.
+		{
+			initialize_block(7, header.hash());
+			assert!(!<PendingChange<Test>>::exists());
+			assert_eq!(
+				Grandpa::grandpa_authorities(),
+				to_authorities(vec![(4, 1), (5, 1), (6, 1)])
+			);
+			assert_ok!(Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None));
+			Grandpa::on_finalize(7);
+			header = System::finalize();
+		}
+
+		// run the normal change.
+		{
+			initialize_block(8, header.hash());
+			assert!(<PendingChange<Test>>::exists());
+			assert_eq!(
+				Grandpa::grandpa_authorities(),
+				to_authorities(vec![(4, 1), (5, 1), (6, 1)])
+			);
+			assert_noop!(
+				Grandpa::schedule_change(to_authorities(vec![(5, 1)]), 1, None),
+				Error::<Test>::ChangePending
+			);
+			Grandpa::on_finalize(8);
+			header = System::finalize();
+		}
+
+		// normal change applied. but we can't apply a new forced change for some
+		// time.
+		for i in 9..11 {
+			initialize_block(i, header.hash());
+			assert!(!<PendingChange<Test>>::exists());
+			assert_eq!(Grandpa::grandpa_authorities(), to_authorities(vec![(5, 1)]));
+			assert_eq!(Grandpa::next_forced(), Some(11));
+			assert_noop!(
+				Grandpa::schedule_change(to_authorities(vec![(5, 1), (6, 1)]), 5, Some(0)),
+				Error::<Test>::TooSoon
+			);
+			Grandpa::on_finalize(i);
+			header = System::finalize();
+		}
+
+		{
+			initialize_block(11, header.hash());
+			assert!(!<PendingChange<Test>>::exists());
+			assert_ok!(Grandpa::schedule_change(
+				to_authorities(vec![(5, 1), (6, 1), (7, 1)]),
+				5,
+				Some(0)
+			));
+			assert_eq!(Grandpa::next_forced(), Some(21));
+			Grandpa::on_finalize(11);
+			header = System::finalize();
+		}
+		let _ = header;
+	});
+}
+
+#[test]
+fn schedule_pause_only_when_live() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		// we schedule a pause at block 1 with delay of 1
+		initialize_block(1, Default::default());
+		Grandpa::schedule_pause(1).unwrap();
+
+		// we've switched to the pending pause state
+		assert_eq!(Grandpa::state(), StoredState::PendingPause { scheduled_at: 1u64, delay: 1 });
+
+		Grandpa::on_finalize(1);
+		let _ = System::finalize();
+
+		initialize_block(2, Default::default());
+
+		// signaling a pause now should fail
+		assert_noop!(Grandpa::schedule_pause(1), Error::<Test>::PauseFailed);
+
+		Grandpa::on_finalize(2);
+		let _ = System::finalize();
+
+		// after finalizing block 2 the set should have switched to paused state
+		assert_eq!(Grandpa::state(), StoredState::Paused);
+	});
+}
+
+#[test]
+fn schedule_resume_only_when_paused() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		initialize_block(1, Default::default());
+
+		// the set is currently live, resuming it is an error
+		assert_noop!(Grandpa::schedule_resume(1), Error::<Test>::ResumeFailed);
+
+		assert_eq!(Grandpa::state(), StoredState::Live);
+
+		// we schedule a pause to be applied instantly
+		Grandpa::schedule_pause(0).unwrap();
+		Grandpa::on_finalize(1);
+		let _ = System::finalize();
+
+		assert_eq!(Grandpa::state(), StoredState::Paused);
+
+		// we schedule the set to go back live in 2 blocks
+		initialize_block(2, Default::default());
+		Grandpa::schedule_resume(2).unwrap();
+		Grandpa::on_finalize(2);
+		let _ = System::finalize();
+
+		initialize_block(3, Default::default());
+		Grandpa::on_finalize(3);
+		let _ = System::finalize();
+
+		initialize_block(4, Default::default());
+		Grandpa::on_finalize(4);
+		let _ = System::finalize();
+
+		// it should be live at block 4
+		assert_eq!(Grandpa::state(), StoredState::Live);
+	});
+}
+
+#[test]
+fn time_slot_have_sane_ord() {
+	// Ensure that `Ord` implementation is sane.
+	const FIXTURE: &[TimeSlot] = &[
+		TimeSlot { set_id: 0, round: 0 },
+		TimeSlot { set_id: 0, round: 1 },
+		TimeSlot { set_id: 1, round: 0 },
+		TimeSlot { set_id: 1, round: 1 },
+		TimeSlot { set_id: 1, round: 2 },
+	];
+	assert!(FIXTURE.windows(2).all(|f| f[0] < f[1]));
+}
+
+/// Returns a list with 3 authorities with known keys:
+/// Alice, Bob and Charlie.
+pub fn test_authorities() -> AuthorityList {
+	let authorities = vec![Ed25519Keyring::Alice, Ed25519Keyring::Bob, Ed25519Keyring::Charlie];
+
+	authorities.into_iter().map(|id| (id.public().into(), 1u64)).collect()
+}
+
+#[test]
+fn report_equivocation_current_set_works() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		assert_eq!(Staking::current_era(), Some(0));
+		assert_eq!(Session::current_index(), 0);
+
+		start_era(1);
+
+		let authorities = Grandpa::grandpa_authorities();
+		let validators = Session::validators();
+
+		// make sure that all validators have the same balance
+		for validator in &validators {
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(1, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+
+		let set_id = Grandpa::current_set_id();
+
+		// generate an equivocation proof, with two votes in the same round for
+		// different block hashes signed by the same key
+		let equivocation_proof = generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &equivocation_keyring),
+		);
+
+		// create the key ownership proof
+		let key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &equivocation_key)).unwrap();
+
+		// report the equivocation and the tx should be dispatched successfully
+		assert_ok!(Grandpa::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		),);
+
+		start_era(2);
+
+		// check that the balance of 0-th validator is slashed 100%.
+		let equivocation_validator_id = validators[equivocation_authority_index];
+
+		assert_eq!(Balances::total_balance(&equivocation_validator_id), 10_000_000 - 10_000);
+		assert_eq!(Staking::slashable_balance_of(&equivocation_validator_id), 0);
+		assert_eq!(
+			Staking::eras_stakers(2, equivocation_validator_id),
+			pallet_staking::Exposure { total: 0, own: 0, others: vec![] },
+		);
+
+		// check that the balances of all other validators are left intact.
+		for validator in &validators {
+			if *validator == equivocation_validator_id {
+				continue
+			}
+
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(2, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+	});
+}
+
+#[test]
+fn report_equivocation_old_set_works() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let authorities = Grandpa::grandpa_authorities();
+		let validators = Session::validators();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+
+		// create the key ownership proof in the "old" set
+		let key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &equivocation_key)).unwrap();
+
+		start_era(2);
+
+		// make sure that all authorities have the same balance
+		for validator in &validators {
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(2, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+
+		let equivocation_keyring = extract_keyring(equivocation_key);
+
+		let set_id = Grandpa::current_set_id();
+
+		// generate an equivocation proof for the old set,
+		let equivocation_proof = generate_equivocation_proof(
+			set_id - 1,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &equivocation_keyring),
+		);
+
+		// report the equivocation using the key ownership proof generated on
+		// the old set, the tx should be dispatched successfully
+		assert_ok!(Grandpa::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		),);
+
+		start_era(3);
+
+		// check that the balance of 0-th validator is slashed 100%.
+		let equivocation_validator_id = validators[equivocation_authority_index];
+
+		assert_eq!(Balances::total_balance(&equivocation_validator_id), 10_000_000 - 10_000);
+		assert_eq!(Staking::slashable_balance_of(&equivocation_validator_id), 0);
+
+		assert_eq!(
+			Staking::eras_stakers(3, equivocation_validator_id),
+			pallet_staking::Exposure { total: 0, own: 0, others: vec![] },
+		);
+
+		// check that the balances of all other validators are left intact.
+		for validator in &validators {
+			if *validator == equivocation_validator_id {
+				continue
+			}
+
+			assert_eq!(Balances::total_balance(validator), 10_000_000);
+			assert_eq!(Staking::slashable_balance_of(validator), 10_000);
+
+			assert_eq!(
+				Staking::eras_stakers(3, validator),
+				pallet_staking::Exposure { total: 10_000, own: 10_000, others: vec![] },
+			);
+		}
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_set_id() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let authorities = Grandpa::grandpa_authorities();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+
+		let key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &equivocation_key)).unwrap();
+
+		let set_id = Grandpa::current_set_id();
+
+		// generate an equivocation for a future set
+		let equivocation_proof = generate_equivocation_proof(
+			set_id + 1,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &equivocation_keyring),
+		);
+
+		// the call for reporting the equivocation should error
+		assert_err!(
+			Grandpa::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof),
+				key_owner_proof,
+			),
+			Error::<Test>::InvalidEquivocationProof,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_session() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let authorities = Grandpa::grandpa_authorities();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+
+		// generate a key ownership proof at set id = 1
+		let key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &equivocation_key)).unwrap();
+
+		start_era(2);
+
+		let set_id = Grandpa::current_set_id();
+
+		// generate an equivocation proof at set id = 2
+		let equivocation_proof = generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &equivocation_keyring),
+		);
+
+		// report an equivocation for the current set using an key ownership
+		// proof from the previous set, the session should be invalid.
+		assert_err!(
+			Grandpa::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof),
+				key_owner_proof,
+			),
+			Error::<Test>::InvalidEquivocationProof,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_key_owner_proof() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+		let authorities = Grandpa::grandpa_authorities();
+
+		let invalid_owner_authority_index = 1;
+		let invalid_owner_key = &authorities[invalid_owner_authority_index].0;
+
+		// generate a key ownership proof for the authority at index 1
+		let invalid_key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &invalid_owner_key)).unwrap();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+
+		let set_id = Grandpa::current_set_id();
+
+		// generate an equivocation proof for the authority at index 0
+		let equivocation_proof = generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &equivocation_keyring),
+		);
+
+		// we need to start a new era otherwise the key ownership proof won't be
+		// checked since the authorities are part of the current session
+		start_era(2);
+
+		// report an equivocation for the current set using a key ownership
+		// proof for a different key than the one in the equivocation proof.
+		assert_err!(
+			Grandpa::report_equivocation_unsigned(
+				RuntimeOrigin::none(),
+				Box::new(equivocation_proof),
+				invalid_key_owner_proof,
+			),
+			Error::<Test>::InvalidKeyOwnershipProof,
+		);
+	});
+}
+
+#[test]
+fn report_equivocation_invalid_equivocation_proof() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let authorities = Grandpa::grandpa_authorities();
+
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+
+		// generate a key ownership proof at set id = 1
+		let key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &equivocation_key)).unwrap();
+
+		let set_id = Grandpa::current_set_id();
+
+		let assert_invalid_equivocation_proof = |equivocation_proof| {
+			assert_err!(
+				Grandpa::report_equivocation_unsigned(
+					RuntimeOrigin::none(),
+					Box::new(equivocation_proof),
+					key_owner_proof.clone(),
+				),
+				Error::<Test>::InvalidEquivocationProof,
+			);
+		};
+
+		start_era(2);
+
+		// both votes target the same block number and hash,
+		// there is no equivocation.
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			set_id,
+			(1, H256::zero(), 10, &equivocation_keyring),
+			(1, H256::zero(), 10, &equivocation_keyring),
+		));
+
+		// votes targetting different rounds, there is no equivocation.
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(2, H256::random(), 10, &equivocation_keyring),
+		));
+
+		// votes signed with different authority keys
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &Ed25519Keyring::Charlie),
+		));
+
+		// votes signed with a key that isn't part of the authority set
+		assert_invalid_equivocation_proof(generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &Ed25519Keyring::Dave),
+		));
+	});
+}
+
+#[test]
+fn report_equivocation_validate_unsigned_prevents_duplicates() {
+	use sp_runtime::transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionSource, TransactionValidity,
+		ValidTransaction,
+	};
+
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let authorities = Grandpa::grandpa_authorities();
+
+		// generate and report an equivocation for the validator at index 0
+		let equivocation_authority_index = 0;
+		let equivocation_key = &authorities[equivocation_authority_index].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+		let set_id = Grandpa::current_set_id();
+
+		let equivocation_proof = generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &equivocation_keyring),
+		);
+
+		let key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &equivocation_key)).unwrap();
+
+		let call = Call::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof.clone()),
+			key_owner_proof: key_owner_proof.clone(),
+		};
+
+		// only local/inblock reports are allowed
+		assert_eq!(
+			<Grandpa as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::External,
+				&call,
+			),
+			InvalidTransaction::Call.into(),
+		);
+
+		// the transaction is valid when passed as local
+		let tx_tag = (equivocation_key, set_id, 1u64);
+
+		assert_eq!(
+			<Grandpa as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&call,
+			),
+			TransactionValidity::Ok(ValidTransaction {
+				priority: TransactionPriority::max_value(),
+				requires: vec![],
+				provides: vec![("GrandpaEquivocation", tx_tag).encode()],
+				longevity: ReportLongevity::get(),
+				propagate: false,
+			})
+		);
+
+		// the pre dispatch checks should also pass
+		assert_ok!(<Grandpa as sp_runtime::traits::ValidateUnsigned>::pre_dispatch(&call));
+
+		// we submit the report
+		Grandpa::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.unwrap();
+
+		// the report should now be considered stale and the transaction is invalid
+		// the check for staleness should be done on both `validate_unsigned` and on `pre_dispatch`
+		assert_err!(
+			<Grandpa as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+				TransactionSource::Local,
+				&call,
+			),
+			InvalidTransaction::Stale,
+		);
+
+		assert_err!(
+			<Grandpa as sp_runtime::traits::ValidateUnsigned>::pre_dispatch(&call),
+			InvalidTransaction::Stale,
+		);
+	});
+}
+
+#[test]
+fn on_new_session_doesnt_start_new_set_if_schedule_change_failed() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		assert_eq!(Grandpa::current_set_id(), 0);
+
+		// starting a new era should lead to a change in the session
+		// validators and trigger a new set
+		start_era(1);
+		assert_eq!(Grandpa::current_set_id(), 1);
+
+		// we schedule a change delayed by 2 blocks, this should make it so that
+		// when we try to rotate the session at the beginning of the era we will
+		// fail to schedule a change (there's already one pending), so we should
+		// not increment the set id.
+		Grandpa::schedule_change(to_authorities(vec![(1, 1)]), 2, None).unwrap();
+		start_era(2);
+		assert_eq!(Grandpa::current_set_id(), 1);
+
+		// everything should go back to normal after.
+		start_era(3);
+		assert_eq!(Grandpa::current_set_id(), 2);
+
+		// session rotation might also fail to schedule a change if it's for a
+		// forced change (i.e. grandpa is stalled) and it is too soon.
+		<NextForced<Test>>::put(1000);
+		<Stalled<Test>>::put((30, 1));
+
+		// NOTE: we cannot go through normal era rotation since having `Stalled`
+		// defined will also trigger a new set (regardless of whether the
+		// session validators changed)
+		Grandpa::on_new_session(true, std::iter::empty(), std::iter::empty());
+		assert_eq!(Grandpa::current_set_id(), 2);
+	});
+}
+
+#[test]
+fn cleans_up_old_set_id_session_mappings() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		let max_set_id_session_entries = MaxSetIdSessionEntries::get();
+
+		start_era(max_set_id_session_entries);
+
+		// we should have a session id mapping for all the set ids from
+		// `max_set_id_session_entries` eras we have observed
+		for i in 1..=max_set_id_session_entries {
+			assert!(Grandpa::session_for_set(i as u64).is_some());
+		}
+
+		start_era(max_set_id_session_entries * 2);
+
+		// we should keep tracking the new mappings for new eras
+		for i in max_set_id_session_entries + 1..=max_set_id_session_entries * 2 {
+			assert!(Grandpa::session_for_set(i as u64).is_some());
+		}
+
+		// but the old ones should have been pruned by now
+		for i in 1..=max_set_id_session_entries {
+			assert!(Grandpa::session_for_set(i as u64).is_none());
+		}
+	});
+}
+
+#[test]
+fn always_schedules_a_change_on_new_session_when_stalled() {
+	new_test_ext(vec![(1, 1), (2, 1), (3, 1)]).execute_with(|| {
+		start_era(1);
+
+		assert!(Grandpa::pending_change().is_none());
+		assert_eq!(Grandpa::current_set_id(), 1);
+
+		// if the session handler reports no change then we should not schedule
+		// any pending change
+		Grandpa::on_new_session(false, std::iter::empty(), std::iter::empty());
+
+		assert!(Grandpa::pending_change().is_none());
+		assert_eq!(Grandpa::current_set_id(), 1);
+
+		// if grandpa is stalled then we should **always** schedule a forced
+		// change on a new session
+		<Stalled<Test>>::put((10, 1));
+		Grandpa::on_new_session(false, std::iter::empty(), std::iter::empty());
+
+		assert!(Grandpa::pending_change().is_some());
+		assert!(Grandpa::pending_change().unwrap().forced.is_some());
+		assert_eq!(Grandpa::current_set_id(), 2);
+	});
+}
+
+#[test]
+fn report_equivocation_has_valid_weight() {
+	// the weight depends on the size of the validator set,
+	// but there's a lower bound of 100 validators.
+	assert!((1..=100)
+		.map(|validators| <Test as Config>::WeightInfo::report_equivocation(validators, 1000))
+		.collect::<Vec<_>>()
+		.windows(2)
+		.all(|w| w[0] == w[1]));
+
+	// after 100 validators the weight should keep increasing
+	// with every extra validator.
+	assert!((100..=1000)
+		.map(|validators| <Test as Config>::WeightInfo::report_equivocation(validators, 1000))
+		.collect::<Vec<_>>()
+		.windows(2)
+		.all(|w| w[0].ref_time() < w[1].ref_time()));
+}
+
+#[test]
+fn valid_equivocation_reports_dont_pay_fees() {
+	let authorities = test_authorities();
+
+	new_test_ext_raw_authorities(authorities).execute_with(|| {
+		start_era(1);
+
+		let equivocation_key = &Grandpa::grandpa_authorities()[0].0;
+		let equivocation_keyring = extract_keyring(equivocation_key);
+		let set_id = Grandpa::current_set_id();
+
+		// generate an equivocation proof.
+		let equivocation_proof = generate_equivocation_proof(
+			set_id,
+			(1, H256::random(), 10, &equivocation_keyring),
+			(1, H256::random(), 10, &equivocation_keyring),
+		);
+
+		// create the key ownership proof.
+		let key_owner_proof =
+			Historical::prove((sp_consensus_grandpa::KEY_TYPE, &equivocation_key)).unwrap();
+
+		// check the dispatch info for the call.
+		let info = Call::<Test>::report_equivocation_unsigned {
+			equivocation_proof: Box::new(equivocation_proof.clone()),
+			key_owner_proof: key_owner_proof.clone(),
+		}
+		.get_dispatch_info();
+
+		// it should have non-zero weight and the fee has to be paid.
+		assert!(info.weight.any_gt(Weight::zero()));
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// report the equivocation.
+		let post_info = Grandpa::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof.clone()),
+			key_owner_proof.clone(),
+		)
+		.unwrap();
+
+		// the original weight should be kept, but given that the report
+		// is valid the fee is waived.
+		assert!(post_info.actual_weight.is_none());
+		assert_eq!(post_info.pays_fee, Pays::No);
+
+		// report the equivocation again which is invalid now since it is
+		// duplicate.
+		let post_info = Grandpa::report_equivocation_unsigned(
+			RuntimeOrigin::none(),
+			Box::new(equivocation_proof),
+			key_owner_proof,
+		)
+		.err()
+		.unwrap()
+		.post_info;
+
+		// the fee is not waived and the original weight is kept.
+		assert!(post_info.actual_weight.is_none());
+		assert_eq!(post_info.pays_fee, Pays::Yes);
+	})
+}
diff --git a/substrate/frame/identity/Cargo.toml b/substrate/frame/identity/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fef4ed400a55a144e8e12318a1ab35a4c5e7f45d
--- /dev/null
+++ b/substrate/frame/identity/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "pallet-identity"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME identity management pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+enumflags2 = { version = "0.7.7" }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/identity/README.md b/substrate/frame/identity/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a67c259e2537af20118e194dbb31b66bfdbb1353
--- /dev/null
+++ b/substrate/frame/identity/README.md
@@ -0,0 +1,56 @@
+# Identity Module
+
+- [`identity::Config`](https://docs.rs/pallet-identity/latest/pallet_identity/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-identity/latest/pallet_identity/enum.Call.html)
+
+## Overview
+
+A federated naming system, allowing for multiple registrars to be added from a specified origin.
+Registrars can set a fee to provide identity-verification service. Anyone can put forth a
+proposed identity for a fixed deposit and ask for review by any number of registrars (paying
+each of their fees). Registrar judgements are given as an `enum`, allowing for sophisticated,
+multi-tier opinions.
+
+Some judgements are identified as *sticky*, which means they cannot be removed except by
+complete removal of the identity, or by the registrar. Judgements are allowed to represent a
+portion of funds that have been reserved for the registrar.
+
+A super-user can remove accounts and in doing so, slash the deposit.
+
+All accounts may also have a limited number of sub-accounts which may be specified by the owner;
+by definition, these have equivalent ownership and each has an individual name.
+
+The number of registrars should be limited, and the deposit made sufficiently large, to ensure
+no state-bloat attack is viable.
+
+## Interface
+
+### Dispatchable Functions
+
+#### For general users
+* `set_identity` - Set the associated identity of an account; a small deposit is reserved if not
+  already taken.
+* `clear_identity` - Remove an account's associated identity; the deposit is returned.
+* `request_judgement` - Request a judgement from a registrar, paying a fee.
+* `cancel_request` - Cancel the previous request for a judgement.
+
+#### For general users with sub-identities
+* `set_subs` - Set the sub-accounts of an identity.
+* `add_sub` - Add a sub-identity to an identity.
+* `remove_sub` - Remove a sub-identity of an identity.
+* `rename_sub` - Rename a sub-identity of an identity.
+* `quit_sub` - Remove a sub-identity of an identity (called by the sub-identity).
+
+#### For registrars
+* `set_fee` - Set the fee required to be paid for a judgement to be given by the registrar.
+* `set_fields` - Set the fields that a registrar cares about in their judgements.
+* `provide_judgement` - Provide a judgement to an identity.
+
+#### For super-users
+* `add_registrar` - Add a new registrar to the system.
+* `kill_identity` - Forcibly remove the associated identity; the deposit is lost.
+
+[`Call`]: ./enum.Call.html
+[`Config`]: ./trait.Config.html
+
+License: Apache-2.0
diff --git a/substrate/frame/identity/src/benchmarking.rs b/substrate/frame/identity/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b51d23f6b34f99463e29bb8054628ff62bd2945
--- /dev/null
+++ b/substrate/frame/identity/src/benchmarking.rs
@@ -0,0 +1,452 @@
+// 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.
+
+//! Identity pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use crate::Pallet as Identity;
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller, BenchmarkError};
+use frame_support::{
+	ensure,
+	traits::{EnsureOrigin, Get},
+};
+use frame_system::RawOrigin;
+use sp_runtime::traits::Bounded;
+
+const SEED: u32 = 0;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+// Adds `r` registrars to the Identity Pallet. These registrars will have set fees and fields.
+fn add_registrars<T: Config>(r: u32) -> Result<(), &'static str> {
+	for i in 0..r {
+		let registrar: T::AccountId = account("registrar", i, SEED);
+		let registrar_lookup = T::Lookup::unlookup(registrar.clone());
+		let _ = T::Currency::make_free_balance_be(&registrar, BalanceOf::<T>::max_value());
+		let registrar_origin = T::RegistrarOrigin::try_successful_origin()
+			.expect("RegistrarOrigin has no successful origin required for the benchmark");
+		Identity::<T>::add_registrar(registrar_origin, registrar_lookup)?;
+		Identity::<T>::set_fee(RawOrigin::Signed(registrar.clone()).into(), i, 10u32.into())?;
+		let fields =
+			IdentityFields(
+				IdentityField::Display |
+					IdentityField::Legal | IdentityField::Web |
+					IdentityField::Riot | IdentityField::Email |
+					IdentityField::PgpFingerprint |
+					IdentityField::Image | IdentityField::Twitter,
+			);
+		Identity::<T>::set_fields(RawOrigin::Signed(registrar.clone()).into(), i, fields)?;
+	}
+
+	assert_eq!(Registrars::<T>::get().len(), r as usize);
+	Ok(())
+}
+
+// Create `s` sub-accounts for the identity of `who` and return them.
+// Each will have 32 bytes of raw data added to it.
+fn create_sub_accounts<T: Config>(
+	who: &T::AccountId,
+	s: u32,
+) -> Result<Vec<(T::AccountId, Data)>, &'static str> {
+	let mut subs = Vec::new();
+	let who_origin = RawOrigin::Signed(who.clone());
+	let data = Data::Raw(vec![0; 32].try_into().unwrap());
+
+	for i in 0..s {
+		let sub_account = account("sub", i, SEED);
+		subs.push((sub_account, data.clone()));
+	}
+
+	// Set identity so `set_subs` does not fail.
+	if IdentityOf::<T>::get(who).is_none() {
+		let _ = T::Currency::make_free_balance_be(who, BalanceOf::<T>::max_value() / 2u32.into());
+		let info = create_identity_info::<T>(1);
+		Identity::<T>::set_identity(who_origin.into(), Box::new(info))?;
+	}
+
+	Ok(subs)
+}
+
+// Adds `s` sub-accounts to the identity of `who`. Each will have 32 bytes of raw data added to it.
+// This additionally returns the vector of sub-accounts so it can be modified if needed.
+fn add_sub_accounts<T: Config>(
+	who: &T::AccountId,
+	s: u32,
+) -> Result<Vec<(T::AccountId, Data)>, &'static str> {
+	let who_origin = RawOrigin::Signed(who.clone());
+	let subs = create_sub_accounts::<T>(who, s)?;
+
+	Identity::<T>::set_subs(who_origin.into(), subs.clone())?;
+
+	Ok(subs)
+}
+
+// This creates an `IdentityInfo` object with `num_fields` extra fields.
+// All data is pre-populated with some arbitrary bytes.
+fn create_identity_info<T: Config>(num_fields: u32) -> IdentityInfo<T::MaxAdditionalFields> {
+	let data = Data::Raw(vec![0; 32].try_into().unwrap());
+
+	IdentityInfo {
+		additional: vec![(data.clone(), data.clone()); num_fields as usize].try_into().unwrap(),
+		display: data.clone(),
+		legal: data.clone(),
+		web: data.clone(),
+		riot: data.clone(),
+		email: data.clone(),
+		pgp_fingerprint: Some([0; 20]),
+		image: data.clone(),
+		twitter: data,
+	}
+}
+
+benchmarks! {
+	add_registrar {
+		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+		ensure!(Registrars::<T>::get().len() as u32 == r, "Registrars not set up correctly.");
+		let origin =
+			T::RegistrarOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let account = T::Lookup::unlookup(account("registrar", r + 1, SEED));
+	}: _<T::RuntimeOrigin>(origin, account)
+	verify {
+		ensure!(Registrars::<T>::get().len() as u32 == r + 1, "Registrars not added.");
+	}
+
+	set_identity {
+		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
+		let x in 0 .. T::MaxAdditionalFields::get();
+		let caller = {
+			// The target user
+			let caller: T::AccountId = whitelisted_caller();
+			let caller_lookup = T::Lookup::unlookup(caller.clone());
+			let caller_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(caller.clone()).into();
+			let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+			// Add an initial identity
+			let initial_info = create_identity_info::<T>(1);
+			Identity::<T>::set_identity(caller_origin.clone(), Box::new(initial_info.clone()))?;
+
+			// User requests judgement from all the registrars, and they approve
+			for i in 0..r {
+				let registrar: T::AccountId = account("registrar", i, SEED);
+				let registrar_lookup = T::Lookup::unlookup(registrar.clone());
+				let balance_to_use =  T::Currency::minimum_balance() * 10u32.into();
+				let _ = T::Currency::make_free_balance_be(&registrar, balance_to_use);
+
+				Identity::<T>::request_judgement(caller_origin.clone(), i, 10u32.into())?;
+				Identity::<T>::provide_judgement(
+					RawOrigin::Signed(registrar).into(),
+					i,
+					caller_lookup.clone(),
+					Judgement::Reasonable,
+					T::Hashing::hash_of(&initial_info),
+				)?;
+			}
+			caller
+		};
+	}: _(RawOrigin::Signed(caller.clone()), Box::new(create_identity_info::<T>(x)))
+	verify {
+		assert_last_event::<T>(Event::<T>::IdentitySet { who: caller }.into());
+	}
+
+	// We need to split `set_subs` into two benchmarks to accurately isolate the potential
+	// writes caused by new or old sub accounts. The actual weight should simply be
+	// the sum of these two weights.
+	set_subs_new {
+		let caller: T::AccountId = whitelisted_caller();
+		// Create a new subs vec with s sub accounts
+		let s in 0 .. T::MaxSubAccounts::get() => ();
+		let subs = create_sub_accounts::<T>(&caller, s)?;
+		ensure!(SubsOf::<T>::get(&caller).1.len() == 0, "Caller already has subs");
+	}: set_subs(RawOrigin::Signed(caller.clone()), subs)
+	verify {
+		ensure!(SubsOf::<T>::get(&caller).1.len() as u32 == s, "Subs not added");
+	}
+
+	set_subs_old {
+		let caller: T::AccountId = whitelisted_caller();
+		// Give them p many previous sub accounts.
+		let p in 0 .. T::MaxSubAccounts::get() => {
+			let _ = add_sub_accounts::<T>(&caller, p)?;
+		};
+		// Remove all subs.
+		let subs = create_sub_accounts::<T>(&caller, 0)?;
+		ensure!(
+			SubsOf::<T>::get(&caller).1.len() as u32 == p,
+			"Caller does have subs",
+		);
+	}: set_subs(RawOrigin::Signed(caller.clone()), subs)
+	verify {
+		ensure!(SubsOf::<T>::get(&caller).1.len() == 0, "Subs not removed");
+	}
+
+	clear_identity {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
+		let caller_lookup = <T::Lookup as StaticLookup>::unlookup(caller.clone());
+		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
+		let s in 0 .. T::MaxSubAccounts::get() => {
+			// Give them s many sub accounts
+			let caller: T::AccountId = whitelisted_caller();
+			let _ = add_sub_accounts::<T>(&caller, s)?;
+		};
+		let x in 0 .. T::MaxAdditionalFields::get();
+
+		// Create their main identity with x additional fields
+		let info = create_identity_info::<T>(x);
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
+		Identity::<T>::set_identity(caller_origin.clone(), Box::new(info.clone()))?;
+
+		// User requests judgement from all the registrars, and they approve
+		for i in 0..r {
+			let registrar: T::AccountId = account("registrar", i, SEED);
+			let balance_to_use =  T::Currency::minimum_balance() * 10u32.into();
+			let _ = T::Currency::make_free_balance_be(&registrar, balance_to_use);
+
+			Identity::<T>::request_judgement(caller_origin.clone(), i, 10u32.into())?;
+			Identity::<T>::provide_judgement(
+				RawOrigin::Signed(registrar).into(),
+				i,
+				caller_lookup.clone(),
+				Judgement::Reasonable,
+				T::Hashing::hash_of(&info),
+			)?;
+		}
+		ensure!(IdentityOf::<T>::contains_key(&caller), "Identity does not exist.");
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		ensure!(!IdentityOf::<T>::contains_key(&caller), "Identity not cleared.");
+	}
+
+	request_judgement {
+		let caller: T::AccountId = whitelisted_caller();
+		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
+		let x in 0 .. T::MaxAdditionalFields::get() => {
+			// Create their main identity with x additional fields
+			let info = create_identity_info::<T>(x);
+			let caller: T::AccountId = whitelisted_caller();
+			let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller));
+			Identity::<T>::set_identity(caller_origin, Box::new(info))?;
+		};
+	}: _(RawOrigin::Signed(caller.clone()), r - 1, 10u32.into())
+	verify {
+		assert_last_event::<T>(Event::<T>::JudgementRequested { who: caller, registrar_index: r-1 }.into());
+	}
+
+	cancel_request {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller.clone()));
+		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
+		let x in 0 .. T::MaxAdditionalFields::get() => {
+			// Create their main identity with x additional fields
+			let info = create_identity_info::<T>(x);
+			let caller: T::AccountId = whitelisted_caller();
+			let caller_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(caller));
+			Identity::<T>::set_identity(caller_origin, Box::new(info))?;
+		};
+
+		Identity::<T>::request_judgement(caller_origin, r - 1, 10u32.into())?;
+	}: _(RawOrigin::Signed(caller.clone()), r - 1)
+	verify {
+		assert_last_event::<T>(Event::<T>::JudgementUnrequested { who: caller, registrar_index: r-1 }.into());
+	}
+
+	set_fee {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+
+		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+
+		let registrar_origin = T::RegistrarOrigin::try_successful_origin()
+			.expect("RegistrarOrigin has no successful origin required for the benchmark");
+		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
+		let registrars = Registrars::<T>::get();
+		ensure!(registrars[r as usize].as_ref().unwrap().fee == 0u32.into(), "Fee already set.");
+	}: _(RawOrigin::Signed(caller), r, 100u32.into())
+	verify {
+		let registrars = Registrars::<T>::get();
+		ensure!(registrars[r as usize].as_ref().unwrap().fee == 100u32.into(), "Fee not changed.");
+	}
+
+	set_account_id {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+
+		let registrar_origin = T::RegistrarOrigin::try_successful_origin()
+			.expect("RegistrarOrigin has no successful origin required for the benchmark");
+		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
+		let registrars = Registrars::<T>::get();
+		ensure!(registrars[r as usize].as_ref().unwrap().account == caller, "id not set.");
+		let new_account = T::Lookup::unlookup(account("new", 0, SEED));
+	}: _(RawOrigin::Signed(caller), r, new_account)
+	verify {
+		let registrars = Registrars::<T>::get();
+		ensure!(registrars[r as usize].as_ref().unwrap().account == account("new", 0, SEED), "id not changed.");
+	}
+
+	set_fields {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+
+		let registrar_origin = T::RegistrarOrigin::try_successful_origin()
+			.expect("RegistrarOrigin has no successful origin required for the benchmark");
+		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
+		let fields = IdentityFields(
+			IdentityField::Display | IdentityField::Legal | IdentityField::Web | IdentityField::Riot
+			| IdentityField::Email | IdentityField::PgpFingerprint | IdentityField::Image | IdentityField::Twitter
+		);
+		let registrars = Registrars::<T>::get();
+		ensure!(registrars[r as usize].as_ref().unwrap().fields == Default::default(), "fields already set.");
+	}: _(RawOrigin::Signed(caller), r, fields)
+	verify {
+		let registrars = Registrars::<T>::get();
+		ensure!(registrars[r as usize].as_ref().unwrap().fields != Default::default(), "fields not set.");
+	}
+
+	provide_judgement {
+		// The user
+		let user: T::AccountId = account("user", r, SEED);
+		let user_origin = <T as frame_system::Config>::RuntimeOrigin::from(RawOrigin::Signed(user.clone()));
+		let user_lookup = <T::Lookup as StaticLookup>::unlookup(user.clone());
+		let _ = T::Currency::make_free_balance_be(&user, BalanceOf::<T>::max_value());
+
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		let _ = T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let r in 1 .. T::MaxRegistrars::get() - 1 => add_registrars::<T>(r)?;
+		let x in 0 .. T::MaxAdditionalFields::get();
+
+		let info = create_identity_info::<T>(x);
+		let info_hash = T::Hashing::hash_of(&info);
+		Identity::<T>::set_identity(user_origin.clone(), Box::new(info))?;
+
+		let registrar_origin = T::RegistrarOrigin::try_successful_origin()
+			.expect("RegistrarOrigin has no successful origin required for the benchmark");
+		Identity::<T>::add_registrar(registrar_origin, caller_lookup)?;
+		Identity::<T>::request_judgement(user_origin, r, 10u32.into())?;
+	}: _(RawOrigin::Signed(caller), r, user_lookup, Judgement::Reasonable, info_hash)
+	verify {
+		assert_last_event::<T>(Event::<T>::JudgementGiven { target: user, registrar_index: r }.into())
+	}
+
+	kill_identity {
+		let r in 1 .. T::MaxRegistrars::get() => add_registrars::<T>(r)?;
+		let s in 0 .. T::MaxSubAccounts::get();
+		let x in 0 .. T::MaxAdditionalFields::get();
+
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_origin: <T as frame_system::Config>::RuntimeOrigin = RawOrigin::Signed(target.clone()).into();
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		let _ = T::Currency::make_free_balance_be(&target, BalanceOf::<T>::max_value());
+
+		let info = create_identity_info::<T>(x);
+		Identity::<T>::set_identity(target_origin.clone(), Box::new(info.clone()))?;
+		let _ = add_sub_accounts::<T>(&target, s)?;
+
+		// User requests judgement from all the registrars, and they approve
+		for i in 0..r {
+			let registrar: T::AccountId = account("registrar", i, SEED);
+			let balance_to_use =  T::Currency::minimum_balance() * 10u32.into();
+			let _ = T::Currency::make_free_balance_be(&registrar, balance_to_use);
+
+			Identity::<T>::request_judgement(target_origin.clone(), i, 10u32.into())?;
+			Identity::<T>::provide_judgement(
+				RawOrigin::Signed(registrar).into(),
+				i,
+				target_lookup.clone(),
+				Judgement::Reasonable,
+				T::Hashing::hash_of(&info),
+			)?;
+		}
+		ensure!(IdentityOf::<T>::contains_key(&target), "Identity not set");
+		let origin =
+			T::ForceOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: _<T::RuntimeOrigin>(origin, target_lookup)
+	verify {
+		ensure!(!IdentityOf::<T>::contains_key(&target), "Identity not removed");
+	}
+
+	add_sub {
+		let s in 0 .. T::MaxSubAccounts::get() - 1;
+
+		let caller: T::AccountId = whitelisted_caller();
+		let _ = add_sub_accounts::<T>(&caller, s)?;
+		let sub = account("new_sub", 0, SEED);
+		let data = Data::Raw(vec![0; 32].try_into().unwrap());
+		ensure!(SubsOf::<T>::get(&caller).1.len() as u32 == s, "Subs not set.");
+	}: _(RawOrigin::Signed(caller.clone()), T::Lookup::unlookup(sub), data)
+	verify {
+		ensure!(SubsOf::<T>::get(&caller).1.len() as u32 == s + 1, "Subs not added.");
+	}
+
+	rename_sub {
+		let s in 1 .. T::MaxSubAccounts::get();
+
+		let caller: T::AccountId = whitelisted_caller();
+		let (sub, _) = add_sub_accounts::<T>(&caller, s)?.remove(0);
+		let data = Data::Raw(vec![1; 32].try_into().unwrap());
+		ensure!(SuperOf::<T>::get(&sub).unwrap().1 != data, "data already set");
+	}: _(RawOrigin::Signed(caller), T::Lookup::unlookup(sub.clone()), data.clone())
+	verify {
+		ensure!(SuperOf::<T>::get(&sub).unwrap().1 == data, "data not set");
+	}
+
+	remove_sub {
+		let s in 1 .. T::MaxSubAccounts::get();
+
+		let caller: T::AccountId = whitelisted_caller();
+		let (sub, _) = add_sub_accounts::<T>(&caller, s)?.remove(0);
+		ensure!(SuperOf::<T>::contains_key(&sub), "Sub doesn't exists");
+	}: _(RawOrigin::Signed(caller), T::Lookup::unlookup(sub.clone()))
+	verify {
+		ensure!(!SuperOf::<T>::contains_key(&sub), "Sub not removed");
+	}
+
+	quit_sub {
+		let s in 0 .. T::MaxSubAccounts::get() - 1;
+
+		let caller: T::AccountId = whitelisted_caller();
+		let sup = account("super", 0, SEED);
+		let _ = add_sub_accounts::<T>(&sup, s)?;
+		let sup_origin = RawOrigin::Signed(sup).into();
+		Identity::<T>::add_sub(sup_origin, T::Lookup::unlookup(caller.clone()), Data::Raw(vec![0; 32].try_into().unwrap()))?;
+		ensure!(SuperOf::<T>::contains_key(&caller), "Sub doesn't exists");
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		ensure!(!SuperOf::<T>::contains_key(&caller), "Sub not removed");
+	}
+
+	impl_benchmark_test_suite!(Identity, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/identity/src/lib.rs b/substrate/frame/identity/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f192ee2b461b3f6309fb4001079efd9f80344121
--- /dev/null
+++ b/substrate/frame/identity/src/lib.rs
@@ -0,0 +1,980 @@
+// 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.
+
+//! # Identity Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! A federated naming system, allowing for multiple registrars to be added from a specified origin.
+//! Registrars can set a fee to provide identity-verification service. Anyone can put forth a
+//! proposed identity for a fixed deposit and ask for review by any number of registrars (paying
+//! each of their fees). Registrar judgements are given as an `enum`, allowing for sophisticated,
+//! multi-tier opinions.
+//!
+//! Some judgements are identified as *sticky*, which means they cannot be removed except by
+//! complete removal of the identity, or by the registrar. Judgements are allowed to represent a
+//! portion of funds that have been reserved for the registrar.
+//!
+//! A super-user can remove accounts and in doing so, slash the deposit.
+//!
+//! All accounts may also have a limited number of sub-accounts which may be specified by the owner;
+//! by definition, these have equivalent ownership and each has an individual name.
+//!
+//! The number of registrars should be limited, and the deposit made sufficiently large, to ensure
+//! no state-bloat attack is viable.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! #### For general users
+//! * `set_identity` - Set the associated identity of an account; a small deposit is reserved if not
+//!   already taken.
+//! * `clear_identity` - Remove an account's associated identity; the deposit is returned.
+//! * `request_judgement` - Request a judgement from a registrar, paying a fee.
+//! * `cancel_request` - Cancel the previous request for a judgement.
+//!
+//! #### For general users with sub-identities
+//! * `set_subs` - Set the sub-accounts of an identity.
+//! * `add_sub` - Add a sub-identity to an identity.
+//! * `remove_sub` - Remove a sub-identity of an identity.
+//! * `rename_sub` - Rename a sub-identity of an identity.
+//! * `quit_sub` - Remove a sub-identity of an identity (called by the sub-identity).
+//!
+//! #### For registrars
+//! * `set_fee` - Set the fee required to be paid for a judgement to be given by the registrar.
+//! * `set_fields` - Set the fields that a registrar cares about in their judgements.
+//! * `provide_judgement` - Provide a judgement to an identity.
+//!
+//! #### For super-users
+//! * `add_registrar` - Add a new registrar to the system.
+//! * `kill_identity` - Forcibly remove the associated identity; the deposit is lost.
+//!
+//! [`Call`]: ./enum.Call.html
+//! [`Config`]: ./trait.Config.html
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+#[cfg(test)]
+mod tests;
+mod types;
+pub mod weights;
+
+use frame_support::traits::{BalanceStatus, Currency, OnUnbalanced, ReservableCurrency};
+use sp_runtime::traits::{AppendZerosInput, Hash, Saturating, StaticLookup, Zero};
+use sp_std::prelude::*;
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+pub use types::{
+	Data, IdentityField, IdentityFields, IdentityInfo, Judgement, RegistrarIndex, RegistrarInfo,
+	Registration,
+};
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The currency trait.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// The amount held on deposit for a registered identity
+		#[pallet::constant]
+		type BasicDeposit: Get<BalanceOf<Self>>;
+
+		/// The amount held on deposit per additional field for a registered identity.
+		#[pallet::constant]
+		type FieldDeposit: Get<BalanceOf<Self>>;
+
+		/// The amount held on deposit for a registered subaccount. This should account for the fact
+		/// that one storage item's value will increase by the size of an account ID, and there will
+		/// be another trie item whose value is the size of an account ID plus 32 bytes.
+		#[pallet::constant]
+		type SubAccountDeposit: Get<BalanceOf<Self>>;
+
+		/// The maximum number of sub-accounts allowed per identified account.
+		#[pallet::constant]
+		type MaxSubAccounts: Get<u32>;
+
+		/// Maximum number of additional fields that may be stored in an ID. Needed to bound the I/O
+		/// required to access an identity, but can be pretty high.
+		#[pallet::constant]
+		type MaxAdditionalFields: Get<u32>;
+
+		/// Maxmimum number of registrars allowed in the system. Needed to bound the complexity
+		/// of, e.g., updating judgements.
+		#[pallet::constant]
+		type MaxRegistrars: Get<u32>;
+
+		/// What to do with slashed funds.
+		type Slashed: OnUnbalanced<NegativeImbalanceOf<Self>>;
+
+		/// The origin which may forcibly set or remove a name. Root can always do this.
+		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin which may add or remove registrars. Root can always do this.
+		type RegistrarOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Information that is pertinent to identify the entity behind an account.
+	///
+	/// TWOX-NOTE: OK ― `AccountId` is a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn identity)]
+	pub(super) type IdentityOf<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Registration<BalanceOf<T>, T::MaxRegistrars, T::MaxAdditionalFields>,
+		OptionQuery,
+	>;
+
+	/// The super-identity of an alternative "sub" identity together with its name, within that
+	/// context. If the account is not some other account's sub-identity, then just `None`.
+	#[pallet::storage]
+	#[pallet::getter(fn super_of)]
+	pub(super) type SuperOf<T: Config> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, (T::AccountId, Data), OptionQuery>;
+
+	/// Alternative "sub" identities of this account.
+	///
+	/// The first item is the deposit, the second is a vector of the accounts.
+	///
+	/// TWOX-NOTE: OK ― `AccountId` is a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn subs_of)]
+	pub(super) type SubsOf<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		(BalanceOf<T>, BoundedVec<T::AccountId, T::MaxSubAccounts>),
+		ValueQuery,
+	>;
+
+	/// The set of registrars. Not expected to get very big as can only be added through a
+	/// special origin (likely a council motion).
+	///
+	/// The index into this can be cast to `RegistrarIndex` to get a valid value.
+	#[pallet::storage]
+	#[pallet::getter(fn registrars)]
+	pub(super) type Registrars<T: Config> = StorageValue<
+		_,
+		BoundedVec<Option<RegistrarInfo<BalanceOf<T>, T::AccountId>>, T::MaxRegistrars>,
+		ValueQuery,
+	>;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Too many subs-accounts.
+		TooManySubAccounts,
+		/// Account isn't found.
+		NotFound,
+		/// Account isn't named.
+		NotNamed,
+		/// Empty index.
+		EmptyIndex,
+		/// Fee is changed.
+		FeeChanged,
+		/// No identity found.
+		NoIdentity,
+		/// Sticky judgement.
+		StickyJudgement,
+		/// Judgement given.
+		JudgementGiven,
+		/// Invalid judgement.
+		InvalidJudgement,
+		/// The index is invalid.
+		InvalidIndex,
+		/// The target is invalid.
+		InvalidTarget,
+		/// Too many additional fields.
+		TooManyFields,
+		/// Maximum amount of registrars reached. Cannot add any more.
+		TooManyRegistrars,
+		/// Account ID is already named.
+		AlreadyClaimed,
+		/// Sender is not a sub-account.
+		NotSub,
+		/// Sub-account isn't owned by sender.
+		NotOwned,
+		/// The provided judgement was for a different identity.
+		JudgementForDifferentIdentity,
+		/// Error that occurs when there is an issue paying for judgement.
+		JudgementPaymentFailed,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A name was set or reset (which will remove all judgements).
+		IdentitySet { who: T::AccountId },
+		/// A name was cleared, and the given balance returned.
+		IdentityCleared { who: T::AccountId, deposit: BalanceOf<T> },
+		/// A name was removed and the given balance slashed.
+		IdentityKilled { who: T::AccountId, deposit: BalanceOf<T> },
+		/// A judgement was asked from a registrar.
+		JudgementRequested { who: T::AccountId, registrar_index: RegistrarIndex },
+		/// A judgement request was retracted.
+		JudgementUnrequested { who: T::AccountId, registrar_index: RegistrarIndex },
+		/// A judgement was given by a registrar.
+		JudgementGiven { target: T::AccountId, registrar_index: RegistrarIndex },
+		/// A registrar was added.
+		RegistrarAdded { registrar_index: RegistrarIndex },
+		/// A sub-identity was added to an identity and the deposit paid.
+		SubIdentityAdded { sub: T::AccountId, main: T::AccountId, deposit: BalanceOf<T> },
+		/// A sub-identity was removed from an identity and the deposit freed.
+		SubIdentityRemoved { sub: T::AccountId, main: T::AccountId, deposit: BalanceOf<T> },
+		/// A sub-identity was cleared, and the given deposit repatriated from the
+		/// main identity account to the sub-identity account.
+		SubIdentityRevoked { sub: T::AccountId, main: T::AccountId, deposit: BalanceOf<T> },
+	}
+
+	#[pallet::call]
+	/// Identity pallet declaration.
+	impl<T: Config> Pallet<T> {
+		/// Add a registrar to the system.
+		///
+		/// The dispatch origin for this call must be `T::RegistrarOrigin`.
+		///
+		/// - `account`: the account of the registrar.
+		///
+		/// Emits `RegistrarAdded` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R)` where `R` registrar-count (governance-bounded and code-bounded).
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::add_registrar(T::MaxRegistrars::get()))]
+		pub fn add_registrar(
+			origin: OriginFor<T>,
+			account: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			T::RegistrarOrigin::ensure_origin(origin)?;
+			let account = T::Lookup::lookup(account)?;
+
+			let (i, registrar_count) = <Registrars<T>>::try_mutate(
+				|registrars| -> Result<(RegistrarIndex, usize), DispatchError> {
+					registrars
+						.try_push(Some(RegistrarInfo {
+							account,
+							fee: Zero::zero(),
+							fields: Default::default(),
+						}))
+						.map_err(|_| Error::<T>::TooManyRegistrars)?;
+					Ok(((registrars.len() - 1) as RegistrarIndex, registrars.len()))
+				},
+			)?;
+
+			Self::deposit_event(Event::RegistrarAdded { registrar_index: i });
+
+			Ok(Some(T::WeightInfo::add_registrar(registrar_count as u32)).into())
+		}
+
+		/// Set an account's identity information and reserve the appropriate deposit.
+		///
+		/// If the account already has identity information, the deposit is taken as part payment
+		/// for the new deposit.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `info`: The identity information.
+		///
+		/// Emits `IdentitySet` if successful.
+		///
+		/// ## Complexity
+		/// - `O(X + X' + R)`
+		///   - where `X` additional-field-count (deposit-bounded and code-bounded)
+		///   - where `R` judgements-count (registrar-count-bounded)
+		#[pallet::call_index(1)]
+		#[pallet::weight( T::WeightInfo::set_identity(
+			T::MaxRegistrars::get(), // R
+			T::MaxAdditionalFields::get(), // X
+		))]
+		pub fn set_identity(
+			origin: OriginFor<T>,
+			info: Box<IdentityInfo<T::MaxAdditionalFields>>,
+		) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+			let extra_fields = info.additional.len() as u32;
+			ensure!(extra_fields <= T::MaxAdditionalFields::get(), Error::<T>::TooManyFields);
+			let fd = <BalanceOf<T>>::from(extra_fields) * T::FieldDeposit::get();
+
+			let mut id = match <IdentityOf<T>>::get(&sender) {
+				Some(mut id) => {
+					// Only keep non-positive judgements.
+					id.judgements.retain(|j| j.1.is_sticky());
+					id.info = *info;
+					id
+				},
+				None => Registration {
+					info: *info,
+					judgements: BoundedVec::default(),
+					deposit: Zero::zero(),
+				},
+			};
+
+			let old_deposit = id.deposit;
+			id.deposit = T::BasicDeposit::get() + fd;
+			if id.deposit > old_deposit {
+				T::Currency::reserve(&sender, id.deposit - old_deposit)?;
+			}
+			if old_deposit > id.deposit {
+				let err_amount = T::Currency::unreserve(&sender, old_deposit - id.deposit);
+				debug_assert!(err_amount.is_zero());
+			}
+
+			let judgements = id.judgements.len();
+			<IdentityOf<T>>::insert(&sender, id);
+			Self::deposit_event(Event::IdentitySet { who: sender });
+
+			Ok(Some(T::WeightInfo::set_identity(
+				judgements as u32, // R
+				extra_fields,      // X
+			))
+			.into())
+		}
+
+		/// Set the sub-accounts of the sender.
+		///
+		/// Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned
+		/// and an amount `SubAccountDeposit` will be reserved for each item in `subs`.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered
+		/// identity.
+		///
+		/// - `subs`: The identity's (new) sub-accounts.
+		///
+		/// ## Complexity
+		/// - `O(P + S)`
+		///   - where `P` old-subs-count (hard- and deposit-bounded).
+		///   - where `S` subs-count (hard- and deposit-bounded).
+		// TODO: This whole extrinsic screams "not optimized". For example we could
+		// filter any overlap between new and old subs, and avoid reading/writing
+		// to those values... We could also ideally avoid needing to write to
+		// N storage items for N sub accounts. Right now the weight on this function
+		// is a large overestimate due to the fact that it could potentially write
+		// to 2 x T::MaxSubAccounts::get().
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::set_subs_old(T::MaxSubAccounts::get()) // P: Assume max sub accounts removed.
+			.saturating_add(T::WeightInfo::set_subs_new(subs.len() as u32)) // S: Assume all subs are new.
+		)]
+		pub fn set_subs(
+			origin: OriginFor<T>,
+			subs: Vec<(T::AccountId, Data)>,
+		) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+			ensure!(<IdentityOf<T>>::contains_key(&sender), Error::<T>::NotFound);
+			ensure!(
+				subs.len() <= T::MaxSubAccounts::get() as usize,
+				Error::<T>::TooManySubAccounts
+			);
+
+			let (old_deposit, old_ids) = <SubsOf<T>>::get(&sender);
+			let new_deposit = T::SubAccountDeposit::get() * <BalanceOf<T>>::from(subs.len() as u32);
+
+			let not_other_sub =
+				subs.iter().filter_map(|i| SuperOf::<T>::get(&i.0)).all(|i| i.0 == sender);
+			ensure!(not_other_sub, Error::<T>::AlreadyClaimed);
+
+			if old_deposit < new_deposit {
+				T::Currency::reserve(&sender, new_deposit - old_deposit)?;
+			} else if old_deposit > new_deposit {
+				let err_amount = T::Currency::unreserve(&sender, old_deposit - new_deposit);
+				debug_assert!(err_amount.is_zero());
+			}
+			// do nothing if they're equal.
+
+			for s in old_ids.iter() {
+				<SuperOf<T>>::remove(s);
+			}
+			let mut ids = BoundedVec::<T::AccountId, T::MaxSubAccounts>::default();
+			for (id, name) in subs {
+				<SuperOf<T>>::insert(&id, (sender.clone(), name));
+				ids.try_push(id).expect("subs length is less than T::MaxSubAccounts; qed");
+			}
+			let new_subs = ids.len();
+
+			if ids.is_empty() {
+				<SubsOf<T>>::remove(&sender);
+			} else {
+				<SubsOf<T>>::insert(&sender, (new_deposit, ids));
+			}
+
+			Ok(Some(
+				T::WeightInfo::set_subs_old(old_ids.len() as u32) // P: Real number of old accounts removed.
+					// S: New subs added
+					.saturating_add(T::WeightInfo::set_subs_new(new_subs as u32)),
+			)
+			.into())
+		}
+
+		/// Clear an account's identity info and all sub-accounts and return all deposits.
+		///
+		/// Payment: All reserved balances on the account are returned.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered
+		/// identity.
+		///
+		/// Emits `IdentityCleared` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R + S + X)`
+		///   - where `R` registrar-count (governance-bounded).
+		///   - where `S` subs-count (hard- and deposit-bounded).
+		///   - where `X` additional-field-count (deposit-bounded and code-bounded).
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::clear_identity(
+			T::MaxRegistrars::get(), // R
+			T::MaxSubAccounts::get(), // S
+			T::MaxAdditionalFields::get(), // X
+		))]
+		pub fn clear_identity(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+
+			let (subs_deposit, sub_ids) = <SubsOf<T>>::take(&sender);
+			let id = <IdentityOf<T>>::take(&sender).ok_or(Error::<T>::NotNamed)?;
+			let deposit = id.total_deposit() + subs_deposit;
+			for sub in sub_ids.iter() {
+				<SuperOf<T>>::remove(sub);
+			}
+
+			let err_amount = T::Currency::unreserve(&sender, deposit);
+			debug_assert!(err_amount.is_zero());
+
+			Self::deposit_event(Event::IdentityCleared { who: sender, deposit });
+
+			Ok(Some(T::WeightInfo::clear_identity(
+				id.judgements.len() as u32,      // R
+				sub_ids.len() as u32,            // S
+				id.info.additional.len() as u32, // X
+			))
+			.into())
+		}
+
+		/// Request a judgement from a registrar.
+		///
+		/// Payment: At most `max_fee` will be reserved for payment to the registrar if judgement
+		/// given.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a
+		/// registered identity.
+		///
+		/// - `reg_index`: The index of the registrar whose judgement is requested.
+		/// - `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:
+		///
+		/// ```nocompile
+		/// Self::registrars().get(reg_index).unwrap().fee
+		/// ```
+		///
+		/// Emits `JudgementRequested` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R + X)`.
+		///   - where `R` registrar-count (governance-bounded).
+		///   - where `X` additional-field-count (deposit-bounded and code-bounded).
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::request_judgement(
+			T::MaxRegistrars::get(), // R
+			T::MaxAdditionalFields::get(), // X
+		))]
+		pub fn request_judgement(
+			origin: OriginFor<T>,
+			#[pallet::compact] reg_index: RegistrarIndex,
+			#[pallet::compact] max_fee: BalanceOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+			let registrars = <Registrars<T>>::get();
+			let registrar = registrars
+				.get(reg_index as usize)
+				.and_then(Option::as_ref)
+				.ok_or(Error::<T>::EmptyIndex)?;
+			ensure!(max_fee >= registrar.fee, Error::<T>::FeeChanged);
+			let mut id = <IdentityOf<T>>::get(&sender).ok_or(Error::<T>::NoIdentity)?;
+
+			let item = (reg_index, Judgement::FeePaid(registrar.fee));
+			match id.judgements.binary_search_by_key(&reg_index, |x| x.0) {
+				Ok(i) =>
+					if id.judgements[i].1.is_sticky() {
+						return Err(Error::<T>::StickyJudgement.into())
+					} else {
+						id.judgements[i] = item
+					},
+				Err(i) =>
+					id.judgements.try_insert(i, item).map_err(|_| Error::<T>::TooManyRegistrars)?,
+			}
+
+			T::Currency::reserve(&sender, registrar.fee)?;
+
+			let judgements = id.judgements.len();
+			let extra_fields = id.info.additional.len();
+			<IdentityOf<T>>::insert(&sender, id);
+
+			Self::deposit_event(Event::JudgementRequested {
+				who: sender,
+				registrar_index: reg_index,
+			});
+
+			Ok(Some(T::WeightInfo::request_judgement(judgements as u32, extra_fields as u32))
+				.into())
+		}
+
+		/// Cancel a previous request.
+		///
+		/// Payment: A previously reserved deposit is returned on success.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a
+		/// registered identity.
+		///
+		/// - `reg_index`: The index of the registrar whose judgement is no longer requested.
+		///
+		/// Emits `JudgementUnrequested` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R + X)`.
+		///   - where `R` registrar-count (governance-bounded).
+		///   - where `X` additional-field-count (deposit-bounded and code-bounded).
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::cancel_request(
+			T::MaxRegistrars::get(), // R
+			T::MaxAdditionalFields::get(), // X
+		))]
+		pub fn cancel_request(
+			origin: OriginFor<T>,
+			reg_index: RegistrarIndex,
+		) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+			let mut id = <IdentityOf<T>>::get(&sender).ok_or(Error::<T>::NoIdentity)?;
+
+			let pos = id
+				.judgements
+				.binary_search_by_key(&reg_index, |x| x.0)
+				.map_err(|_| Error::<T>::NotFound)?;
+			let fee = if let Judgement::FeePaid(fee) = id.judgements.remove(pos).1 {
+				fee
+			} else {
+				return Err(Error::<T>::JudgementGiven.into())
+			};
+
+			let err_amount = T::Currency::unreserve(&sender, fee);
+			debug_assert!(err_amount.is_zero());
+			let judgements = id.judgements.len();
+			let extra_fields = id.info.additional.len();
+			<IdentityOf<T>>::insert(&sender, id);
+
+			Self::deposit_event(Event::JudgementUnrequested {
+				who: sender,
+				registrar_index: reg_index,
+			});
+
+			Ok(Some(T::WeightInfo::cancel_request(judgements as u32, extra_fields as u32)).into())
+		}
+
+		/// Set the fee required for a judgement to be requested from a registrar.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must be the account
+		/// of the registrar whose index is `index`.
+		///
+		/// - `index`: the index of the registrar whose fee is to be set.
+		/// - `fee`: the new fee.
+		///
+		/// ## Complexity
+		/// - `O(R)`.
+		///   - where `R` registrar-count (governance-bounded).
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::set_fee(T::MaxRegistrars::get()))] // R
+		pub fn set_fee(
+			origin: OriginFor<T>,
+			#[pallet::compact] index: RegistrarIndex,
+			#[pallet::compact] fee: BalanceOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+
+			let registrars = <Registrars<T>>::mutate(|rs| -> Result<usize, DispatchError> {
+				rs.get_mut(index as usize)
+					.and_then(|x| x.as_mut())
+					.and_then(|r| {
+						if r.account == who {
+							r.fee = fee;
+							Some(())
+						} else {
+							None
+						}
+					})
+					.ok_or_else(|| DispatchError::from(Error::<T>::InvalidIndex))?;
+				Ok(rs.len())
+			})?;
+			Ok(Some(T::WeightInfo::set_fee(registrars as u32)).into()) // R
+		}
+
+		/// Change the account associated with a registrar.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must be the account
+		/// of the registrar whose index is `index`.
+		///
+		/// - `index`: the index of the registrar whose fee is to be set.
+		/// - `new`: the new account ID.
+		///
+		/// ## Complexity
+		/// - `O(R)`.
+		///   - where `R` registrar-count (governance-bounded).
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::set_account_id(T::MaxRegistrars::get()))] // R
+		pub fn set_account_id(
+			origin: OriginFor<T>,
+			#[pallet::compact] index: RegistrarIndex,
+			new: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let new = T::Lookup::lookup(new)?;
+
+			let registrars = <Registrars<T>>::mutate(|rs| -> Result<usize, DispatchError> {
+				rs.get_mut(index as usize)
+					.and_then(|x| x.as_mut())
+					.and_then(|r| {
+						if r.account == who {
+							r.account = new;
+							Some(())
+						} else {
+							None
+						}
+					})
+					.ok_or_else(|| DispatchError::from(Error::<T>::InvalidIndex))?;
+				Ok(rs.len())
+			})?;
+			Ok(Some(T::WeightInfo::set_account_id(registrars as u32)).into()) // R
+		}
+
+		/// Set the field information for a registrar.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must be the account
+		/// of the registrar whose index is `index`.
+		///
+		/// - `index`: the index of the registrar whose fee is to be set.
+		/// - `fields`: the fields that the registrar concerns themselves with.
+		///
+		/// ## Complexity
+		/// - `O(R)`.
+		///   - where `R` registrar-count (governance-bounded).
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::set_fields(T::MaxRegistrars::get()))] // R
+		pub fn set_fields(
+			origin: OriginFor<T>,
+			#[pallet::compact] index: RegistrarIndex,
+			fields: IdentityFields,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+
+			let registrars = <Registrars<T>>::mutate(|rs| -> Result<usize, DispatchError> {
+				rs.get_mut(index as usize)
+					.and_then(|x| x.as_mut())
+					.and_then(|r| {
+						if r.account == who {
+							r.fields = fields;
+							Some(())
+						} else {
+							None
+						}
+					})
+					.ok_or_else(|| DispatchError::from(Error::<T>::InvalidIndex))?;
+				Ok(rs.len())
+			})?;
+			Ok(Some(T::WeightInfo::set_fields(
+				registrars as u32, // R
+			))
+			.into())
+		}
+
+		/// Provide a judgement for an account's identity.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must be the account
+		/// of the registrar whose index is `reg_index`.
+		///
+		/// - `reg_index`: the index of the registrar whose judgement is being made.
+		/// - `target`: the account whose identity the judgement is upon. This must be an account
+		///   with a registered identity.
+		/// - `judgement`: the judgement of the registrar of index `reg_index` about `target`.
+		/// - `identity`: The hash of the [`IdentityInfo`] for that the judgement is provided.
+		///
+		/// Emits `JudgementGiven` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R + X)`.
+		///   - where `R` registrar-count (governance-bounded).
+		///   - where `X` additional-field-count (deposit-bounded and code-bounded).
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::provide_judgement(
+			T::MaxRegistrars::get(), // R
+			T::MaxAdditionalFields::get(), // X
+		))]
+		pub fn provide_judgement(
+			origin: OriginFor<T>,
+			#[pallet::compact] reg_index: RegistrarIndex,
+			target: AccountIdLookupOf<T>,
+			judgement: Judgement<BalanceOf<T>>,
+			identity: T::Hash,
+		) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+			let target = T::Lookup::lookup(target)?;
+			ensure!(!judgement.has_deposit(), Error::<T>::InvalidJudgement);
+			<Registrars<T>>::get()
+				.get(reg_index as usize)
+				.and_then(Option::as_ref)
+				.filter(|r| r.account == sender)
+				.ok_or(Error::<T>::InvalidIndex)?;
+			let mut id = <IdentityOf<T>>::get(&target).ok_or(Error::<T>::InvalidTarget)?;
+
+			if T::Hashing::hash_of(&id.info) != identity {
+				return Err(Error::<T>::JudgementForDifferentIdentity.into())
+			}
+
+			let item = (reg_index, judgement);
+			match id.judgements.binary_search_by_key(&reg_index, |x| x.0) {
+				Ok(position) => {
+					if let Judgement::FeePaid(fee) = id.judgements[position].1 {
+						T::Currency::repatriate_reserved(
+							&target,
+							&sender,
+							fee,
+							BalanceStatus::Free,
+						)
+						.map_err(|_| Error::<T>::JudgementPaymentFailed)?;
+					}
+					id.judgements[position] = item
+				},
+				Err(position) => id
+					.judgements
+					.try_insert(position, item)
+					.map_err(|_| Error::<T>::TooManyRegistrars)?,
+			}
+
+			let judgements = id.judgements.len();
+			let extra_fields = id.info.additional.len();
+			<IdentityOf<T>>::insert(&target, id);
+			Self::deposit_event(Event::JudgementGiven { target, registrar_index: reg_index });
+
+			Ok(Some(T::WeightInfo::provide_judgement(judgements as u32, extra_fields as u32))
+				.into())
+		}
+
+		/// Remove an account's identity and sub-account information and slash the deposits.
+		///
+		/// Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled by
+		/// `Slash`. Verification request deposits are not returned; they should be cancelled
+		/// manually using `cancel_request`.
+		///
+		/// The dispatch origin for this call must match `T::ForceOrigin`.
+		///
+		/// - `target`: the account whose identity the judgement is upon. This must be an account
+		///   with a registered identity.
+		///
+		/// Emits `IdentityKilled` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R + S + X)`
+		///   - where `R` registrar-count (governance-bounded).
+		///   - where `S` subs-count (hard- and deposit-bounded).
+		///   - where `X` additional-field-count (deposit-bounded and code-bounded).
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::kill_identity(
+			T::MaxRegistrars::get(), // R
+			T::MaxSubAccounts::get(), // S
+			T::MaxAdditionalFields::get(), // X
+		))]
+		pub fn kill_identity(
+			origin: OriginFor<T>,
+			target: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			T::ForceOrigin::ensure_origin(origin)?;
+
+			// Figure out who we're meant to be clearing.
+			let target = T::Lookup::lookup(target)?;
+			// Grab their deposit (and check that they have one).
+			let (subs_deposit, sub_ids) = <SubsOf<T>>::take(&target);
+			let id = <IdentityOf<T>>::take(&target).ok_or(Error::<T>::NotNamed)?;
+			let deposit = id.total_deposit() + subs_deposit;
+			for sub in sub_ids.iter() {
+				<SuperOf<T>>::remove(sub);
+			}
+			// Slash their deposit from them.
+			T::Slashed::on_unbalanced(T::Currency::slash_reserved(&target, deposit).0);
+
+			Self::deposit_event(Event::IdentityKilled { who: target, deposit });
+
+			Ok(Some(T::WeightInfo::kill_identity(
+				id.judgements.len() as u32,      // R
+				sub_ids.len() as u32,            // S
+				id.info.additional.len() as u32, // X
+			))
+			.into())
+		}
+
+		/// Add the given account to the sender's subs.
+		///
+		/// Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
+		/// to the sender.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered
+		/// sub identity of `sub`.
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::add_sub(T::MaxSubAccounts::get()))]
+		pub fn add_sub(
+			origin: OriginFor<T>,
+			sub: AccountIdLookupOf<T>,
+			data: Data,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			let sub = T::Lookup::lookup(sub)?;
+			ensure!(IdentityOf::<T>::contains_key(&sender), Error::<T>::NoIdentity);
+
+			// Check if it's already claimed as sub-identity.
+			ensure!(!SuperOf::<T>::contains_key(&sub), Error::<T>::AlreadyClaimed);
+
+			SubsOf::<T>::try_mutate(&sender, |(ref mut subs_deposit, ref mut sub_ids)| {
+				// Ensure there is space and that the deposit is paid.
+				ensure!(
+					sub_ids.len() < T::MaxSubAccounts::get() as usize,
+					Error::<T>::TooManySubAccounts
+				);
+				let deposit = T::SubAccountDeposit::get();
+				T::Currency::reserve(&sender, deposit)?;
+
+				SuperOf::<T>::insert(&sub, (sender.clone(), data));
+				sub_ids.try_push(sub.clone()).expect("sub ids length checked above; qed");
+				*subs_deposit = subs_deposit.saturating_add(deposit);
+
+				Self::deposit_event(Event::SubIdentityAdded { sub, main: sender.clone(), deposit });
+				Ok(())
+			})
+		}
+
+		/// Alter the associated name of the given sub-account.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered
+		/// sub identity of `sub`.
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::rename_sub(T::MaxSubAccounts::get()))]
+		pub fn rename_sub(
+			origin: OriginFor<T>,
+			sub: AccountIdLookupOf<T>,
+			data: Data,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			let sub = T::Lookup::lookup(sub)?;
+			ensure!(IdentityOf::<T>::contains_key(&sender), Error::<T>::NoIdentity);
+			ensure!(SuperOf::<T>::get(&sub).map_or(false, |x| x.0 == sender), Error::<T>::NotOwned);
+			SuperOf::<T>::insert(&sub, (sender, data));
+			Ok(())
+		}
+
+		/// Remove the given account from the sender's subs.
+		///
+		/// Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
+		/// to the sender.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered
+		/// sub identity of `sub`.
+		#[pallet::call_index(13)]
+		#[pallet::weight(T::WeightInfo::remove_sub(T::MaxSubAccounts::get()))]
+		pub fn remove_sub(origin: OriginFor<T>, sub: AccountIdLookupOf<T>) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			ensure!(IdentityOf::<T>::contains_key(&sender), Error::<T>::NoIdentity);
+			let sub = T::Lookup::lookup(sub)?;
+			let (sup, _) = SuperOf::<T>::get(&sub).ok_or(Error::<T>::NotSub)?;
+			ensure!(sup == sender, Error::<T>::NotOwned);
+			SuperOf::<T>::remove(&sub);
+			SubsOf::<T>::mutate(&sup, |(ref mut subs_deposit, ref mut sub_ids)| {
+				sub_ids.retain(|x| x != &sub);
+				let deposit = T::SubAccountDeposit::get().min(*subs_deposit);
+				*subs_deposit -= deposit;
+				let err_amount = T::Currency::unreserve(&sender, deposit);
+				debug_assert!(err_amount.is_zero());
+				Self::deposit_event(Event::SubIdentityRemoved { sub, main: sender, deposit });
+			});
+			Ok(())
+		}
+
+		/// Remove the sender as a sub-account.
+		///
+		/// Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated
+		/// to the sender (*not* the original depositor).
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have a registered
+		/// super-identity.
+		///
+		/// NOTE: This should not normally be used, but is provided in the case that the non-
+		/// controller of an account is maliciously registered as a sub-account.
+		#[pallet::call_index(14)]
+		#[pallet::weight(T::WeightInfo::quit_sub(T::MaxSubAccounts::get()))]
+		pub fn quit_sub(origin: OriginFor<T>) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			let (sup, _) = SuperOf::<T>::take(&sender).ok_or(Error::<T>::NotSub)?;
+			SubsOf::<T>::mutate(&sup, |(ref mut subs_deposit, ref mut sub_ids)| {
+				sub_ids.retain(|x| x != &sender);
+				let deposit = T::SubAccountDeposit::get().min(*subs_deposit);
+				*subs_deposit -= deposit;
+				let _ =
+					T::Currency::repatriate_reserved(&sup, &sender, deposit, BalanceStatus::Free);
+				Self::deposit_event(Event::SubIdentityRevoked {
+					sub: sender,
+					main: sup.clone(),
+					deposit,
+				});
+			});
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Get the subs of an account.
+	pub fn subs(who: &T::AccountId) -> Vec<(T::AccountId, Data)> {
+		SubsOf::<T>::get(who)
+			.1
+			.into_iter()
+			.filter_map(|a| SuperOf::<T>::get(&a).map(|x| (a, x.1)))
+			.collect()
+	}
+
+	/// Check if the account has corresponding identity information by the identity field.
+	pub fn has_identity(who: &T::AccountId, fields: u64) -> bool {
+		IdentityOf::<T>::get(who)
+			.map_or(false, |registration| (registration.info.fields().0.bits() & fields) == fields)
+	}
+}
diff --git a/substrate/frame/identity/src/tests.rs b/substrate/frame/identity/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1532980574c2a58cb37f81807f306ac6f85ae96d
--- /dev/null
+++ b/substrate/frame/identity/src/tests.rs
@@ -0,0 +1,621 @@
+// 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 Identity Pallet
+
+use super::*;
+use crate as pallet_identity;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	assert_noop, assert_ok, ord_parameter_types, parameter_types,
+	traits::{ConstU32, ConstU64, EitherOfDiverse},
+	BoundedVec,
+};
+use frame_system::{EnsureRoot, EnsureSignedBy};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BadOrigin, BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Identity: pallet_identity::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	type Hashing = BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	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 = ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+parameter_types! {
+	pub const MaxAdditionalFields: u32 = 2;
+	pub const MaxRegistrars: u32 = 20;
+}
+
+ord_parameter_types! {
+	pub const One: u64 = 1;
+	pub const Two: u64 = 2;
+}
+type EnsureOneOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<One, u64>>;
+type EnsureTwoOrRoot = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<Two, u64>>;
+impl pallet_identity::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type Slashed = ();
+	type BasicDeposit = ConstU64<10>;
+	type FieldDeposit = ConstU64<10>;
+	type SubAccountDeposit = ConstU64<10>;
+	type MaxSubAccounts = ConstU32<2>;
+	type MaxAdditionalFields = MaxAdditionalFields;
+	type MaxRegistrars = MaxRegistrars;
+	type RegistrarOrigin = EnsureOneOrRoot;
+	type ForceOrigin = EnsureTwoOrRoot;
+	type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 10), (3, 10), (10, 100), (20, 100), (30, 100)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
+
+fn ten() -> IdentityInfo<MaxAdditionalFields> {
+	IdentityInfo {
+		display: Data::Raw(b"ten".to_vec().try_into().unwrap()),
+		legal: Data::Raw(b"The Right Ordinal Ten, Esq.".to_vec().try_into().unwrap()),
+		..Default::default()
+	}
+}
+
+fn twenty() -> IdentityInfo<MaxAdditionalFields> {
+	IdentityInfo {
+		display: Data::Raw(b"twenty".to_vec().try_into().unwrap()),
+		legal: Data::Raw(b"The Right Ordinal Twenty, Esq.".to_vec().try_into().unwrap()),
+		..Default::default()
+	}
+}
+
+#[test]
+fn editing_subaccounts_should_work() {
+	new_test_ext().execute_with(|| {
+		let data = |x| Data::Raw(vec![x; 1].try_into().unwrap());
+
+		assert_noop!(
+			Identity::add_sub(RuntimeOrigin::signed(10), 20, data(1)),
+			Error::<Test>::NoIdentity
+		);
+
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+
+		// first sub account
+		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));
+		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(1))));
+		assert_eq!(Balances::free_balance(10), 80);
+
+		// second sub account
+		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 2, data(2)));
+		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(1))));
+		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));
+		assert_eq!(Balances::free_balance(10), 70);
+
+		// third sub account is too many
+		assert_noop!(
+			Identity::add_sub(RuntimeOrigin::signed(10), 3, data(3)),
+			Error::<Test>::TooManySubAccounts
+		);
+
+		// rename first sub account
+		assert_ok!(Identity::rename_sub(RuntimeOrigin::signed(10), 1, data(11)));
+		assert_eq!(SuperOf::<Test>::get(1), Some((10, data(11))));
+		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));
+		assert_eq!(Balances::free_balance(10), 70);
+
+		// remove first sub account
+		assert_ok!(Identity::remove_sub(RuntimeOrigin::signed(10), 1));
+		assert_eq!(SuperOf::<Test>::get(1), None);
+		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));
+		assert_eq!(Balances::free_balance(10), 80);
+
+		// add third sub account
+		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 3, data(3)));
+		assert_eq!(SuperOf::<Test>::get(1), None);
+		assert_eq!(SuperOf::<Test>::get(2), Some((10, data(2))));
+		assert_eq!(SuperOf::<Test>::get(3), Some((10, data(3))));
+		assert_eq!(Balances::free_balance(10), 70);
+	});
+}
+
+#[test]
+fn resolving_subaccount_ownership_works() {
+	new_test_ext().execute_with(|| {
+		let data = |x| Data::Raw(vec![x; 1].try_into().unwrap());
+
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(20), Box::new(twenty())));
+
+		// 10 claims 1 as a subaccount
+		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(10), 1, data(1)));
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(10), 80);
+		assert_eq!(Balances::reserved_balance(10), 20);
+		// 20 cannot claim 1 now
+		assert_noop!(
+			Identity::add_sub(RuntimeOrigin::signed(20), 1, data(1)),
+			Error::<Test>::AlreadyClaimed
+		);
+		// 1 wants to be with 20 so it quits from 10
+		assert_ok!(Identity::quit_sub(RuntimeOrigin::signed(1)));
+		// 1 gets the 10 that 10 paid.
+		assert_eq!(Balances::free_balance(1), 20);
+		assert_eq!(Balances::free_balance(10), 80);
+		assert_eq!(Balances::reserved_balance(10), 10);
+		// 20 can claim 1 now
+		assert_ok!(Identity::add_sub(RuntimeOrigin::signed(20), 1, data(1)));
+	});
+}
+
+#[test]
+fn trailing_zeros_decodes_into_default_data() {
+	let encoded = Data::Raw(b"Hello".to_vec().try_into().unwrap()).encode();
+	assert!(<(Data, Data)>::decode(&mut &encoded[..]).is_err());
+	let input = &mut &encoded[..];
+	let (a, b) = <(Data, Data)>::decode(&mut AppendZerosInput::new(input)).unwrap();
+	assert_eq!(a, Data::Raw(b"Hello".to_vec().try_into().unwrap()));
+	assert_eq!(b, Data::None);
+}
+
+#[test]
+fn adding_registrar_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
+		let fields = IdentityFields(IdentityField::Display | IdentityField::Legal);
+		assert_ok!(Identity::set_fields(RuntimeOrigin::signed(3), 0, fields));
+		assert_eq!(
+			Identity::registrars(),
+			vec![Some(RegistrarInfo { account: 3, fee: 10, fields })]
+		);
+	});
+}
+
+#[test]
+fn amount_of_registrars_is_limited() {
+	new_test_ext().execute_with(|| {
+		for i in 1..MaxRegistrars::get() + 1 {
+			assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), i as u64));
+		}
+		let last_registrar = MaxRegistrars::get() as u64 + 1;
+		assert_noop!(
+			Identity::add_registrar(RuntimeOrigin::signed(1), last_registrar),
+			Error::<Test>::TooManyRegistrars
+		);
+	});
+}
+
+#[test]
+fn registration_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
+		let mut three_fields = ten();
+		three_fields.additional.try_push(Default::default()).unwrap();
+		three_fields.additional.try_push(Default::default()).unwrap();
+		assert!(three_fields.additional.try_push(Default::default()).is_err());
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_eq!(Identity::identity(10).unwrap().info, ten());
+		assert_eq!(Balances::free_balance(10), 90);
+		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));
+		assert_eq!(Balances::free_balance(10), 100);
+		assert_noop!(Identity::clear_identity(RuntimeOrigin::signed(10)), Error::<Test>::NotNamed);
+	});
+}
+
+#[test]
+fn uninvited_judgement_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Identity::provide_judgement(
+				RuntimeOrigin::signed(3),
+				0,
+				10,
+				Judgement::Reasonable,
+				H256::random()
+			),
+			Error::<Test>::InvalidIndex
+		);
+
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_noop!(
+			Identity::provide_judgement(
+				RuntimeOrigin::signed(3),
+				0,
+				10,
+				Judgement::Reasonable,
+				H256::random()
+			),
+			Error::<Test>::InvalidTarget
+		);
+
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_noop!(
+			Identity::provide_judgement(
+				RuntimeOrigin::signed(3),
+				0,
+				10,
+				Judgement::Reasonable,
+				H256::random()
+			),
+			Error::<Test>::JudgementForDifferentIdentity
+		);
+
+		let identity_hash = BlakeTwo256::hash_of(&ten());
+
+		assert_noop!(
+			Identity::provide_judgement(
+				RuntimeOrigin::signed(10),
+				0,
+				10,
+				Judgement::Reasonable,
+				identity_hash
+			),
+			Error::<Test>::InvalidIndex
+		);
+		assert_noop!(
+			Identity::provide_judgement(
+				RuntimeOrigin::signed(3),
+				0,
+				10,
+				Judgement::FeePaid(1),
+				identity_hash
+			),
+			Error::<Test>::InvalidJudgement
+		);
+
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(3),
+			0,
+			10,
+			Judgement::Reasonable,
+			identity_hash
+		));
+		assert_eq!(Identity::identity(10).unwrap().judgements, vec![(0, Judgement::Reasonable)]);
+	});
+}
+
+#[test]
+fn clearing_judgement_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(3),
+			0,
+			10,
+			Judgement::Reasonable,
+			BlakeTwo256::hash_of(&ten())
+		));
+		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));
+		assert_eq!(Identity::identity(10), None);
+	});
+}
+
+#[test]
+fn killing_slashing_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_noop!(Identity::kill_identity(RuntimeOrigin::signed(1), 10), BadOrigin);
+		assert_ok!(Identity::kill_identity(RuntimeOrigin::signed(2), 10));
+		assert_eq!(Identity::identity(10), None);
+		assert_eq!(Balances::free_balance(10), 90);
+		assert_noop!(
+			Identity::kill_identity(RuntimeOrigin::signed(2), 10),
+			Error::<Test>::NotNamed
+		);
+	});
+}
+
+#[test]
+fn setting_subaccounts_should_work() {
+	new_test_ext().execute_with(|| {
+		let mut subs = vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))];
+		assert_noop!(
+			Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()),
+			Error::<Test>::NotFound
+		);
+
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));
+		assert_eq!(Balances::free_balance(10), 80);
+		assert_eq!(Identity::subs_of(10), (10, vec![20].try_into().unwrap()));
+		assert_eq!(Identity::super_of(20), Some((10, Data::Raw(vec![40; 1].try_into().unwrap()))));
+
+		// push another item and re-set it.
+		subs.push((30, Data::Raw(vec![50; 1].try_into().unwrap())));
+		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));
+		assert_eq!(Balances::free_balance(10), 70);
+		assert_eq!(Identity::subs_of(10), (20, vec![20, 30].try_into().unwrap()));
+		assert_eq!(Identity::super_of(20), Some((10, Data::Raw(vec![40; 1].try_into().unwrap()))));
+		assert_eq!(Identity::super_of(30), Some((10, Data::Raw(vec![50; 1].try_into().unwrap()))));
+
+		// switch out one of the items and re-set.
+		subs[0] = (40, Data::Raw(vec![60; 1].try_into().unwrap()));
+		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()));
+		assert_eq!(Balances::free_balance(10), 70); // no change in the balance
+		assert_eq!(Identity::subs_of(10), (20, vec![40, 30].try_into().unwrap()));
+		assert_eq!(Identity::super_of(20), None);
+		assert_eq!(Identity::super_of(30), Some((10, Data::Raw(vec![50; 1].try_into().unwrap()))));
+		assert_eq!(Identity::super_of(40), Some((10, Data::Raw(vec![60; 1].try_into().unwrap()))));
+
+		// clear
+		assert_ok!(Identity::set_subs(RuntimeOrigin::signed(10), vec![]));
+		assert_eq!(Balances::free_balance(10), 90);
+		assert_eq!(Identity::subs_of(10), (0, BoundedVec::default()));
+		assert_eq!(Identity::super_of(30), None);
+		assert_eq!(Identity::super_of(40), None);
+
+		subs.push((20, Data::Raw(vec![40; 1].try_into().unwrap())));
+		assert_noop!(
+			Identity::set_subs(RuntimeOrigin::signed(10), subs.clone()),
+			Error::<Test>::TooManySubAccounts
+		);
+	});
+}
+
+#[test]
+fn clearing_account_should_remove_subaccounts_and_refund() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_subs(
+			RuntimeOrigin::signed(10),
+			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]
+		));
+		assert_ok!(Identity::clear_identity(RuntimeOrigin::signed(10)));
+		assert_eq!(Balances::free_balance(10), 100);
+		assert!(Identity::super_of(20).is_none());
+	});
+}
+
+#[test]
+fn killing_account_should_remove_subaccounts_and_not_refund() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::set_subs(
+			RuntimeOrigin::signed(10),
+			vec![(20, Data::Raw(vec![40; 1].try_into().unwrap()))]
+		));
+		assert_ok!(Identity::kill_identity(RuntimeOrigin::signed(2), 10));
+		assert_eq!(Balances::free_balance(10), 80);
+		assert!(Identity::super_of(20).is_none());
+	});
+}
+
+#[test]
+fn cancelling_requested_judgement_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
+		assert_noop!(
+			Identity::cancel_request(RuntimeOrigin::signed(10), 0),
+			Error::<Test>::NoIdentity
+		);
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+		assert_ok!(Identity::cancel_request(RuntimeOrigin::signed(10), 0));
+		assert_eq!(Balances::free_balance(10), 90);
+		assert_noop!(
+			Identity::cancel_request(RuntimeOrigin::signed(10), 0),
+			Error::<Test>::NotFound
+		);
+
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(3),
+			0,
+			10,
+			Judgement::Reasonable,
+			BlakeTwo256::hash_of(&ten())
+		));
+		assert_noop!(
+			Identity::cancel_request(RuntimeOrigin::signed(10), 0),
+			Error::<Test>::JudgementGiven
+		);
+	});
+}
+
+#[test]
+fn requesting_judgement_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_noop!(
+			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 9),
+			Error::<Test>::FeeChanged
+		);
+		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+		// 10 for the judgement request, 10 for the identity.
+		assert_eq!(Balances::free_balance(10), 80);
+
+		// Re-requesting won't work as we already paid.
+		assert_noop!(
+			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10),
+			Error::<Test>::StickyJudgement
+		);
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(3),
+			0,
+			10,
+			Judgement::Erroneous,
+			BlakeTwo256::hash_of(&ten())
+		));
+		// Registrar got their payment now.
+		assert_eq!(Balances::free_balance(3), 20);
+
+		// Re-requesting still won't work as it's erroneous.
+		assert_noop!(
+			Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10),
+			Error::<Test>::StickyJudgement
+		);
+
+		// Requesting from a second registrar still works.
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 4));
+		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 1, 10));
+
+		// Re-requesting after the judgement has been reduced works.
+		assert_ok!(Identity::provide_judgement(
+			RuntimeOrigin::signed(3),
+			0,
+			10,
+			Judgement::OutOfDate,
+			BlakeTwo256::hash_of(&ten())
+		));
+		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+	});
+}
+
+#[test]
+fn provide_judgement_should_return_judgement_payment_failed_error() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert_ok!(Identity::request_judgement(RuntimeOrigin::signed(10), 0, 10));
+		// 10 for the judgement request, 10 for the identity.
+		assert_eq!(Balances::free_balance(10), 80);
+
+		// This forces judgement payment failed error
+		Balances::make_free_balance_be(&3, 0);
+		assert_noop!(
+			Identity::provide_judgement(
+				RuntimeOrigin::signed(3),
+				0,
+				10,
+				Judgement::Erroneous,
+				BlakeTwo256::hash_of(&ten())
+			),
+			Error::<Test>::JudgementPaymentFailed
+		);
+	});
+}
+
+#[test]
+fn field_deposit_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		assert_ok!(Identity::set_fee(RuntimeOrigin::signed(3), 0, 10));
+		assert_ok!(Identity::set_identity(
+			RuntimeOrigin::signed(10),
+			Box::new(IdentityInfo {
+				additional: vec![
+					(
+						Data::Raw(b"number".to_vec().try_into().unwrap()),
+						Data::Raw(10u32.encode().try_into().unwrap())
+					),
+					(
+						Data::Raw(b"text".to_vec().try_into().unwrap()),
+						Data::Raw(b"10".to_vec().try_into().unwrap())
+					),
+				]
+				.try_into()
+				.unwrap(),
+				..Default::default()
+			})
+		));
+		assert_eq!(Balances::free_balance(10), 70);
+	});
+}
+
+#[test]
+fn setting_account_id_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::add_registrar(RuntimeOrigin::signed(1), 3));
+		// account 4 cannot change the first registrar's identity since it's owned by 3.
+		assert_noop!(
+			Identity::set_account_id(RuntimeOrigin::signed(4), 0, 3),
+			Error::<Test>::InvalidIndex
+		);
+		// account 3 can, because that's the registrar's current account.
+		assert_ok!(Identity::set_account_id(RuntimeOrigin::signed(3), 0, 4));
+		// account 4 can now, because that's their new ID.
+		assert_ok!(Identity::set_account_id(RuntimeOrigin::signed(4), 0, 3));
+	});
+}
+
+#[test]
+fn test_has_identity() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Identity::set_identity(RuntimeOrigin::signed(10), Box::new(ten())));
+		assert!(Identity::has_identity(&10, IdentityField::Display as u64));
+		assert!(Identity::has_identity(&10, IdentityField::Legal as u64));
+		assert!(Identity::has_identity(
+			&10,
+			IdentityField::Display as u64 | IdentityField::Legal as u64
+		));
+		assert!(!Identity::has_identity(
+			&10,
+			IdentityField::Display as u64 | IdentityField::Legal as u64 | IdentityField::Web as u64
+		));
+	});
+}
diff --git a/substrate/frame/identity/src/types.rs b/substrate/frame/identity/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1837b30b027f9eca4327919c81c34917ab168f3b
--- /dev/null
+++ b/substrate/frame/identity/src/types.rs
@@ -0,0 +1,501 @@
+// 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 codec::{Decode, Encode, MaxEncodedLen};
+use enumflags2::{bitflags, BitFlags};
+use frame_support::{
+	traits::{ConstU32, Get},
+	BoundedVec, CloneNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+use scale_info::{
+	build::{Fields, Variants},
+	meta_type, Path, Type, TypeInfo, TypeParameter,
+};
+use sp_runtime::{traits::Zero, RuntimeDebug};
+use sp_std::{fmt::Debug, iter::once, ops::Add, prelude::*};
+
+/// Either underlying data blob if it is at most 32 bytes, or a hash of it. If the data is greater
+/// than 32-bytes then it will be truncated when encoding.
+///
+/// Can also be `None`.
+#[derive(Clone, Eq, PartialEq, RuntimeDebug, MaxEncodedLen)]
+pub enum Data {
+	/// No data here.
+	None,
+	/// The data is stored directly.
+	Raw(BoundedVec<u8, ConstU32<32>>),
+	/// Only the Blake2 hash of the data is stored. The preimage of the hash may be retrieved
+	/// through some hash-lookup service.
+	BlakeTwo256([u8; 32]),
+	/// Only the SHA2-256 hash of the data is stored. The preimage of the hash may be retrieved
+	/// through some hash-lookup service.
+	Sha256([u8; 32]),
+	/// Only the Keccak-256 hash of the data is stored. The preimage of the hash may be retrieved
+	/// through some hash-lookup service.
+	Keccak256([u8; 32]),
+	/// Only the SHA3-256 hash of the data is stored. The preimage of the hash may be retrieved
+	/// through some hash-lookup service.
+	ShaThree256([u8; 32]),
+}
+
+impl Data {
+	pub fn is_none(&self) -> bool {
+		self == &Data::None
+	}
+}
+
+impl Decode for Data {
+	fn decode<I: codec::Input>(input: &mut I) -> sp_std::result::Result<Self, codec::Error> {
+		let b = input.read_byte()?;
+		Ok(match b {
+			0 => Data::None,
+			n @ 1..=33 => {
+				let mut r: BoundedVec<_, _> = vec![0u8; n as usize - 1]
+					.try_into()
+					.expect("bound checked in match arm condition; qed");
+				input.read(&mut r[..])?;
+				Data::Raw(r)
+			},
+			34 => Data::BlakeTwo256(<[u8; 32]>::decode(input)?),
+			35 => Data::Sha256(<[u8; 32]>::decode(input)?),
+			36 => Data::Keccak256(<[u8; 32]>::decode(input)?),
+			37 => Data::ShaThree256(<[u8; 32]>::decode(input)?),
+			_ => return Err(codec::Error::from("invalid leading byte")),
+		})
+	}
+}
+
+impl Encode for Data {
+	fn encode(&self) -> Vec<u8> {
+		match self {
+			Data::None => vec![0u8; 1],
+			Data::Raw(ref x) => {
+				let l = x.len().min(32);
+				let mut r = vec![l as u8 + 1; l + 1];
+				r[1..].copy_from_slice(&x[..l as usize]);
+				r
+			},
+			Data::BlakeTwo256(ref h) => once(34u8).chain(h.iter().cloned()).collect(),
+			Data::Sha256(ref h) => once(35u8).chain(h.iter().cloned()).collect(),
+			Data::Keccak256(ref h) => once(36u8).chain(h.iter().cloned()).collect(),
+			Data::ShaThree256(ref h) => once(37u8).chain(h.iter().cloned()).collect(),
+		}
+	}
+}
+impl codec::EncodeLike for Data {}
+
+/// Add a Raw variant with the given index and a fixed sized byte array
+macro_rules! data_raw_variants {
+    ($variants:ident, $(($index:literal, $size:literal)),* ) => {
+		$variants
+		$(
+			.variant(concat!("Raw", stringify!($size)), |v| v
+				.index($index)
+				.fields(Fields::unnamed().field(|f| f.ty::<[u8; $size]>()))
+			)
+		)*
+    }
+}
+
+impl TypeInfo for Data {
+	type Identity = Self;
+
+	fn type_info() -> Type {
+		let variants = Variants::new().variant("None", |v| v.index(0));
+
+		// create a variant for all sizes of Raw data from 0-32
+		let variants = data_raw_variants!(
+			variants,
+			(1, 0),
+			(2, 1),
+			(3, 2),
+			(4, 3),
+			(5, 4),
+			(6, 5),
+			(7, 6),
+			(8, 7),
+			(9, 8),
+			(10, 9),
+			(11, 10),
+			(12, 11),
+			(13, 12),
+			(14, 13),
+			(15, 14),
+			(16, 15),
+			(17, 16),
+			(18, 17),
+			(19, 18),
+			(20, 19),
+			(21, 20),
+			(22, 21),
+			(23, 22),
+			(24, 23),
+			(25, 24),
+			(26, 25),
+			(27, 26),
+			(28, 27),
+			(29, 28),
+			(30, 29),
+			(31, 30),
+			(32, 31),
+			(33, 32)
+		);
+
+		let variants = variants
+			.variant("BlakeTwo256", |v| {
+				v.index(34).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+			})
+			.variant("Sha256", |v| {
+				v.index(35).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+			})
+			.variant("Keccak256", |v| {
+				v.index(36).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+			})
+			.variant("ShaThree256", |v| {
+				v.index(37).fields(Fields::unnamed().field(|f| f.ty::<[u8; 32]>()))
+			});
+
+		Type::builder().path(Path::new("Data", module_path!())).variant(variants)
+	}
+}
+
+impl Default for Data {
+	fn default() -> Self {
+		Self::None
+	}
+}
+
+/// An identifier for a single name registrar/identity verification service.
+pub type RegistrarIndex = u32;
+
+/// An attestation of a registrar over how accurate some `IdentityInfo` is in describing an account.
+///
+/// NOTE: Registrars may pay little attention to some fields. Registrars may want to make clear
+/// which fields their attestation is relevant for by off-chain means.
+#[derive(Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub enum Judgement<Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq>
+{
+	/// The default value; no opinion is held.
+	Unknown,
+	/// No judgement is yet in place, but a deposit is reserved as payment for providing one.
+	FeePaid(Balance),
+	/// The data appears to be reasonably acceptable in terms of its accuracy, however no in depth
+	/// checks (such as in-person meetings or formal KYC) have been conducted.
+	Reasonable,
+	/// The target is known directly by the registrar and the registrar can fully attest to the
+	/// the data's accuracy.
+	KnownGood,
+	/// The data was once good but is currently out of date. There is no malicious intent in the
+	/// inaccuracy. This judgement can be removed through updating the data.
+	OutOfDate,
+	/// The data is imprecise or of sufficiently low-quality to be problematic. It is not
+	/// indicative of malicious intent. This judgement can be removed through updating the data.
+	LowQuality,
+	/// The data is erroneous. This may be indicative of malicious intent. This cannot be removed
+	/// except by the registrar.
+	Erroneous,
+}
+
+impl<Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq>
+	Judgement<Balance>
+{
+	/// Returns `true` if this judgement is indicative of a deposit being currently held. This means
+	/// it should not be cleared or replaced except by an operation which utilizes the deposit.
+	pub(crate) fn has_deposit(&self) -> bool {
+		matches!(self, Judgement::FeePaid(_))
+	}
+
+	/// Returns `true` if this judgement is one that should not be generally be replaced outside
+	/// of specialized handlers. Examples include "malicious" judgements and deposit-holding
+	/// judgements.
+	pub(crate) fn is_sticky(&self) -> bool {
+		matches!(self, Judgement::FeePaid(_) | Judgement::Erroneous)
+	}
+}
+
+/// The fields that we use to identify the owner of an account with. Each corresponds to a field
+/// in the `IdentityInfo` struct.
+#[bitflags]
+#[repr(u64)]
+#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub enum IdentityField {
+	Display = 0b0000000000000000000000000000000000000000000000000000000000000001,
+	Legal = 0b0000000000000000000000000000000000000000000000000000000000000010,
+	Web = 0b0000000000000000000000000000000000000000000000000000000000000100,
+	Riot = 0b0000000000000000000000000000000000000000000000000000000000001000,
+	Email = 0b0000000000000000000000000000000000000000000000000000000000010000,
+	PgpFingerprint = 0b0000000000000000000000000000000000000000000000000000000000100000,
+	Image = 0b0000000000000000000000000000000000000000000000000000000001000000,
+	Twitter = 0b0000000000000000000000000000000000000000000000000000000010000000,
+}
+
+/// Wrapper type for `BitFlags<IdentityField>` that implements `Codec`.
+#[derive(Clone, Copy, PartialEq, Default, RuntimeDebug)]
+pub struct IdentityFields(pub BitFlags<IdentityField>);
+
+impl MaxEncodedLen for IdentityFields {
+	fn max_encoded_len() -> usize {
+		u64::max_encoded_len()
+	}
+}
+
+impl Eq for IdentityFields {}
+impl Encode for IdentityFields {
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.bits().using_encoded(f)
+	}
+}
+impl Decode for IdentityFields {
+	fn decode<I: codec::Input>(input: &mut I) -> sp_std::result::Result<Self, codec::Error> {
+		let field = u64::decode(input)?;
+		Ok(Self(<BitFlags<IdentityField>>::from_bits(field as u64).map_err(|_| "invalid value")?))
+	}
+}
+impl TypeInfo for IdentityFields {
+	type Identity = Self;
+
+	fn type_info() -> Type {
+		Type::builder()
+			.path(Path::new("BitFlags", module_path!()))
+			.type_params(vec![TypeParameter::new("T", Some(meta_type::<IdentityField>()))])
+			.composite(Fields::unnamed().field(|f| f.ty::<u64>().type_name("IdentityField")))
+	}
+}
+
+/// Information concerning the identity of the controller of an account.
+///
+/// NOTE: This should be stored at the end of the storage item to facilitate the addition of extra
+/// fields in a backwards compatible way through a specialized `Decode` impl.
+#[derive(
+	CloneNoBound, Encode, Decode, Eq, MaxEncodedLen, PartialEqNoBound, RuntimeDebugNoBound, TypeInfo,
+)]
+#[codec(mel_bound())]
+#[cfg_attr(test, derive(frame_support::DefaultNoBound))]
+#[scale_info(skip_type_params(FieldLimit))]
+pub struct IdentityInfo<FieldLimit: Get<u32>> {
+	/// Additional fields of the identity that are not catered for with the struct's explicit
+	/// fields.
+	pub additional: BoundedVec<(Data, Data), FieldLimit>,
+
+	/// A reasonable display name for the controller of the account. This should be whatever it is
+	/// that it is typically known as and should not be confusable with other entities, given
+	/// reasonable context.
+	///
+	/// Stored as UTF-8.
+	pub display: Data,
+
+	/// The full legal name in the local jurisdiction of the entity. This might be a bit
+	/// long-winded.
+	///
+	/// Stored as UTF-8.
+	pub legal: Data,
+
+	/// A representative website held by the controller of the account.
+	///
+	/// NOTE: `https://` is automatically prepended.
+	///
+	/// Stored as UTF-8.
+	pub web: Data,
+
+	/// The Riot/Matrix handle held by the controller of the account.
+	///
+	/// Stored as UTF-8.
+	pub riot: Data,
+
+	/// The email address of the controller of the account.
+	///
+	/// Stored as UTF-8.
+	pub email: Data,
+
+	/// The PGP/GPG public key of the controller of the account.
+	pub pgp_fingerprint: Option<[u8; 20]>,
+
+	/// A graphic image representing the controller of the account. Should be a company,
+	/// organization or project logo or a headshot in the case of a human.
+	pub image: Data,
+
+	/// The Twitter identity. The leading `@` character may be elided.
+	pub twitter: Data,
+}
+
+impl<FieldLimit: Get<u32>> IdentityInfo<FieldLimit> {
+	pub(crate) fn fields(&self) -> IdentityFields {
+		let mut res = <BitFlags<IdentityField>>::empty();
+		if !self.display.is_none() {
+			res.insert(IdentityField::Display);
+		}
+		if !self.legal.is_none() {
+			res.insert(IdentityField::Legal);
+		}
+		if !self.web.is_none() {
+			res.insert(IdentityField::Web);
+		}
+		if !self.riot.is_none() {
+			res.insert(IdentityField::Riot);
+		}
+		if !self.email.is_none() {
+			res.insert(IdentityField::Email);
+		}
+		if self.pgp_fingerprint.is_some() {
+			res.insert(IdentityField::PgpFingerprint);
+		}
+		if !self.image.is_none() {
+			res.insert(IdentityField::Image);
+		}
+		if !self.twitter.is_none() {
+			res.insert(IdentityField::Twitter);
+		}
+		IdentityFields(res)
+	}
+}
+
+/// Information concerning the identity of the controller of an account.
+///
+/// NOTE: This is stored separately primarily to facilitate the addition of extra fields in a
+/// backwards compatible way through a specialized `Decode` impl.
+#[derive(
+	CloneNoBound, Encode, Eq, MaxEncodedLen, PartialEqNoBound, RuntimeDebugNoBound, TypeInfo,
+)]
+#[codec(mel_bound())]
+#[scale_info(skip_type_params(MaxJudgements, MaxAdditionalFields))]
+pub struct Registration<
+	Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq,
+	MaxJudgements: Get<u32>,
+	MaxAdditionalFields: Get<u32>,
+> {
+	/// Judgements from the registrars on this identity. Stored ordered by `RegistrarIndex`. There
+	/// may be only a single judgement from each registrar.
+	pub judgements: BoundedVec<(RegistrarIndex, Judgement<Balance>), MaxJudgements>,
+
+	/// Amount held on deposit for this information.
+	pub deposit: Balance,
+
+	/// Information on the identity.
+	pub info: IdentityInfo<MaxAdditionalFields>,
+}
+
+impl<
+		Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq + Zero + Add,
+		MaxJudgements: Get<u32>,
+		MaxAdditionalFields: Get<u32>,
+	> Registration<Balance, MaxJudgements, MaxAdditionalFields>
+{
+	pub(crate) fn total_deposit(&self) -> Balance {
+		self.deposit +
+			self.judgements
+				.iter()
+				.map(|(_, ref j)| if let Judgement::FeePaid(fee) = j { *fee } else { Zero::zero() })
+				.fold(Zero::zero(), |a, i| a + i)
+	}
+}
+
+impl<
+		Balance: Encode + Decode + MaxEncodedLen + Copy + Clone + Debug + Eq + PartialEq,
+		MaxJudgements: Get<u32>,
+		MaxAdditionalFields: Get<u32>,
+	> Decode for Registration<Balance, MaxJudgements, MaxAdditionalFields>
+{
+	fn decode<I: codec::Input>(input: &mut I) -> sp_std::result::Result<Self, codec::Error> {
+		let (judgements, deposit, info) = Decode::decode(&mut AppendZerosInput::new(input))?;
+		Ok(Self { judgements, deposit, info })
+	}
+}
+
+/// Information concerning a registrar.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct RegistrarInfo<
+	Balance: Encode + Decode + Clone + Debug + Eq + PartialEq,
+	AccountId: Encode + Decode + Clone + Debug + Eq + PartialEq,
+> {
+	/// The account of the registrar.
+	pub account: AccountId,
+
+	/// Amount required to be given to the registrar for them to provide judgement.
+	pub fee: Balance,
+
+	/// Relevant fields for this registrar. Registrar judgements are limited to attestations on
+	/// these fields.
+	pub fields: IdentityFields,
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn manual_data_type_info() {
+		let mut registry = scale_info::Registry::new();
+		let type_id = registry.register_type(&scale_info::meta_type::<Data>());
+		let registry: scale_info::PortableRegistry = registry.into();
+		let type_info = registry.resolve(type_id.id).unwrap();
+
+		let check_type_info = |data: &Data| {
+			let variant_name = match data {
+				Data::None => "None".to_string(),
+				Data::BlakeTwo256(_) => "BlakeTwo256".to_string(),
+				Data::Sha256(_) => "Sha256".to_string(),
+				Data::Keccak256(_) => "Keccak256".to_string(),
+				Data::ShaThree256(_) => "ShaThree256".to_string(),
+				Data::Raw(bytes) => format!("Raw{}", bytes.len()),
+			};
+			if let scale_info::TypeDef::Variant(variant) = &type_info.type_def {
+				let variant = variant
+					.variants
+					.iter()
+					.find(|v| v.name == variant_name)
+					.expect(&format!("Expected to find variant {}", variant_name));
+
+				let field_arr_len = variant
+					.fields
+					.first()
+					.and_then(|f| registry.resolve(f.ty.id))
+					.map(|ty| {
+						if let scale_info::TypeDef::Array(arr) = &ty.type_def {
+							arr.len
+						} else {
+							panic!("Should be an array type")
+						}
+					})
+					.unwrap_or(0);
+
+				let encoded = data.encode();
+				assert_eq!(encoded[0], variant.index);
+				assert_eq!(encoded.len() as u32 - 1, field_arr_len);
+			} else {
+				panic!("Should be a variant type")
+			};
+		};
+
+		let mut data = vec![
+			Data::None,
+			Data::BlakeTwo256(Default::default()),
+			Data::Sha256(Default::default()),
+			Data::Keccak256(Default::default()),
+			Data::ShaThree256(Default::default()),
+		];
+
+		// A Raw instance for all possible sizes of the Raw data
+		for n in 0..32 {
+			data.push(Data::Raw(vec![0u8; n as usize].try_into().unwrap()))
+		}
+
+		for d in data.iter() {
+			check_type_info(d);
+		}
+	}
+}
diff --git a/substrate/frame/identity/src/weights.rs b/substrate/frame/identity/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..02fcd7db3c95371ee32e050f37c2db7a3490063a
--- /dev/null
+++ b/substrate/frame/identity/src/weights.rs
@@ -0,0 +1,660 @@
+// 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.
+
+//! Autogenerated weights for pallet_identity
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_identity
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/identity/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_identity.
+pub trait WeightInfo {
+	fn add_registrar(r: u32, ) -> Weight;
+	fn set_identity(r: u32, x: u32, ) -> Weight;
+	fn set_subs_new(s: u32, ) -> Weight;
+	fn set_subs_old(p: u32, ) -> Weight;
+	fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight;
+	fn request_judgement(r: u32, x: u32, ) -> Weight;
+	fn cancel_request(r: u32, x: u32, ) -> Weight;
+	fn set_fee(r: u32, ) -> Weight;
+	fn set_account_id(r: u32, ) -> Weight;
+	fn set_fields(r: u32, ) -> Weight;
+	fn provide_judgement(r: u32, x: u32, ) -> Weight;
+	fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight;
+	fn add_sub(s: u32, ) -> Weight;
+	fn rename_sub(s: u32, ) -> Weight;
+	fn remove_sub(s: u32, ) -> Weight;
+	fn quit_sub(s: u32, ) -> Weight;
+}
+
+/// Weights for pallet_identity using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn add_registrar(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 11_683_000 picoseconds.
+		Weight::from_parts(12_515_830, 2626)
+			// Standard Error: 2_154
+			.saturating_add(Weight::from_parts(147_919, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn set_identity(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `442 + r * (5 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 32_949_000 picoseconds.
+		Weight::from_parts(31_329_634, 11003)
+			// Standard Error: 4_496
+			.saturating_add(Weight::from_parts(203_570, 0).saturating_mul(r.into()))
+			// Standard Error: 877
+			.saturating_add(Weight::from_parts(429_346, 0).saturating_mul(x.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:100 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn set_subs_new(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `101`
+		//  Estimated: `11003 + s * (2589 ±0)`
+		// Minimum execution time: 9_157_000 picoseconds.
+		Weight::from_parts(24_917_444, 11003)
+			// Standard Error: 4_554
+			.saturating_add(Weight::from_parts(3_279_868, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(s.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 2589).saturating_mul(s.into()))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:0 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `p` is `[0, 100]`.
+	fn set_subs_old(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `194 + p * (32 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 9_240_000 picoseconds.
+		Weight::from_parts(23_326_035, 11003)
+			// Standard Error: 3_664
+			.saturating_add(Weight::from_parts(1_439_873, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into())))
+	}
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:0 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `469 + r * (5 ±0) + s * (32 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 55_687_000 picoseconds.
+		Weight::from_parts(30_695_182, 11003)
+			// Standard Error: 9_921
+			.saturating_add(Weight::from_parts(162_357, 0).saturating_mul(r.into()))
+			// Standard Error: 1_937
+			.saturating_add(Weight::from_parts(1_427_998, 0).saturating_mul(s.into()))
+			// Standard Error: 1_937
+			.saturating_add(Weight::from_parts(247_578, 0).saturating_mul(x.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+	}
+	/// Storage: Identity Registrars (r:1 w:0)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn request_judgement(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `367 + r * (57 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 34_876_000 picoseconds.
+		Weight::from_parts(32_207_018, 11003)
+			// Standard Error: 5_247
+			.saturating_add(Weight::from_parts(249_156, 0).saturating_mul(r.into()))
+			// Standard Error: 1_023
+			.saturating_add(Weight::from_parts(458_329, 0).saturating_mul(x.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn cancel_request(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `398 + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 30_689_000 picoseconds.
+		Weight::from_parts(31_967_170, 11003)
+			// Standard Error: 5_387
+			.saturating_add(Weight::from_parts(42_676, 0).saturating_mul(r.into()))
+			// Standard Error: 1_051
+			.saturating_add(Weight::from_parts(446_213, 0).saturating_mul(x.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_fee(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 7_357_000 picoseconds.
+		Weight::from_parts(7_932_950, 2626)
+			// Standard Error: 1_804
+			.saturating_add(Weight::from_parts(132_653, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_account_id(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 7_437_000 picoseconds.
+		Weight::from_parts(8_051_889, 2626)
+			// Standard Error: 1_997
+			.saturating_add(Weight::from_parts(129_592, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_fields(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 7_385_000 picoseconds.
+		Weight::from_parts(7_911_589, 2626)
+			// Standard Error: 1_791
+			.saturating_add(Weight::from_parts(125_788, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:0)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn provide_judgement(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `445 + r * (57 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 24_073_000 picoseconds.
+		Weight::from_parts(17_817_684, 11003)
+			// Standard Error: 8_612
+			.saturating_add(Weight::from_parts(406_251, 0).saturating_mul(r.into()))
+			// Standard Error: 1_593
+			.saturating_add(Weight::from_parts(755_225, 0).saturating_mul(x.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:0 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `676 + r * (5 ±0) + s * (32 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 73_981_000 picoseconds.
+		Weight::from_parts(51_684_057, 11003)
+			// Standard Error: 12_662
+			.saturating_add(Weight::from_parts(145_285, 0).saturating_mul(r.into()))
+			// Standard Error: 2_472
+			.saturating_add(Weight::from_parts(1_421_039, 0).saturating_mul(s.into()))
+			// Standard Error: 2_472
+			.saturating_add(Weight::from_parts(240_907, 0).saturating_mul(x.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 99]`.
+	fn add_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `475 + s * (36 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 29_367_000 picoseconds.
+		Weight::from_parts(34_214_998, 11003)
+			// Standard Error: 1_522
+			.saturating_add(Weight::from_parts(114_551, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 100]`.
+	fn rename_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `591 + s * (3 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 12_384_000 picoseconds.
+		Weight::from_parts(14_417_903, 11003)
+			// Standard Error: 539
+			.saturating_add(Weight::from_parts(38_371, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 100]`.
+	fn remove_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `638 + s * (35 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 33_327_000 picoseconds.
+		Weight::from_parts(36_208_941, 11003)
+			// Standard Error: 1_240
+			.saturating_add(Weight::from_parts(105_805, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 99]`.
+	fn quit_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `704 + s * (37 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 23_764_000 picoseconds.
+		Weight::from_parts(26_407_731, 6723)
+			// Standard Error: 1_025
+			.saturating_add(Weight::from_parts(101_112, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn add_registrar(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 11_683_000 picoseconds.
+		Weight::from_parts(12_515_830, 2626)
+			// Standard Error: 2_154
+			.saturating_add(Weight::from_parts(147_919, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn set_identity(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `442 + r * (5 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 32_949_000 picoseconds.
+		Weight::from_parts(31_329_634, 11003)
+			// Standard Error: 4_496
+			.saturating_add(Weight::from_parts(203_570, 0).saturating_mul(r.into()))
+			// Standard Error: 877
+			.saturating_add(Weight::from_parts(429_346, 0).saturating_mul(x.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:100 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn set_subs_new(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `101`
+		//  Estimated: `11003 + s * (2589 ±0)`
+		// Minimum execution time: 9_157_000 picoseconds.
+		Weight::from_parts(24_917_444, 11003)
+			// Standard Error: 4_554
+			.saturating_add(Weight::from_parts(3_279_868, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(s.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 2589).saturating_mul(s.into()))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:0 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `p` is `[0, 100]`.
+	fn set_subs_old(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `194 + p * (32 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 9_240_000 picoseconds.
+		Weight::from_parts(23_326_035, 11003)
+			// Standard Error: 3_664
+			.saturating_add(Weight::from_parts(1_439_873, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(p.into())))
+	}
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:0 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `469 + r * (5 ±0) + s * (32 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 55_687_000 picoseconds.
+		Weight::from_parts(30_695_182, 11003)
+			// Standard Error: 9_921
+			.saturating_add(Weight::from_parts(162_357, 0).saturating_mul(r.into()))
+			// Standard Error: 1_937
+			.saturating_add(Weight::from_parts(1_427_998, 0).saturating_mul(s.into()))
+			// Standard Error: 1_937
+			.saturating_add(Weight::from_parts(247_578, 0).saturating_mul(x.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
+	}
+	/// Storage: Identity Registrars (r:1 w:0)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn request_judgement(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `367 + r * (57 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 34_876_000 picoseconds.
+		Weight::from_parts(32_207_018, 11003)
+			// Standard Error: 5_247
+			.saturating_add(Weight::from_parts(249_156, 0).saturating_mul(r.into()))
+			// Standard Error: 1_023
+			.saturating_add(Weight::from_parts(458_329, 0).saturating_mul(x.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn cancel_request(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `398 + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 30_689_000 picoseconds.
+		Weight::from_parts(31_967_170, 11003)
+			// Standard Error: 5_387
+			.saturating_add(Weight::from_parts(42_676, 0).saturating_mul(r.into()))
+			// Standard Error: 1_051
+			.saturating_add(Weight::from_parts(446_213, 0).saturating_mul(x.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_fee(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 7_357_000 picoseconds.
+		Weight::from_parts(7_932_950, 2626)
+			// Standard Error: 1_804
+			.saturating_add(Weight::from_parts(132_653, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_account_id(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 7_437_000 picoseconds.
+		Weight::from_parts(8_051_889, 2626)
+			// Standard Error: 1_997
+			.saturating_add(Weight::from_parts(129_592, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:1)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	fn set_fields(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `89 + r * (57 ±0)`
+		//  Estimated: `2626`
+		// Minimum execution time: 7_385_000 picoseconds.
+		Weight::from_parts(7_911_589, 2626)
+			// Standard Error: 1_791
+			.saturating_add(Weight::from_parts(125_788, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity Registrars (r:1 w:0)
+	/// Proof: Identity Registrars (max_values: Some(1), max_size: Some(1141), added: 1636, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 19]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn provide_judgement(r: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `445 + r * (57 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 24_073_000 picoseconds.
+		Weight::from_parts(17_817_684, 11003)
+			// Standard Error: 8_612
+			.saturating_add(Weight::from_parts(406_251, 0).saturating_mul(r.into()))
+			// Standard Error: 1_593
+			.saturating_add(Weight::from_parts(755_225, 0).saturating_mul(x.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: Identity IdentityOf (r:1 w:1)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:0 w:100)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `r` is `[1, 20]`.
+	/// The range of component `s` is `[0, 100]`.
+	/// The range of component `x` is `[0, 100]`.
+	fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `676 + r * (5 ±0) + s * (32 ±0) + x * (66 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 73_981_000 picoseconds.
+		Weight::from_parts(51_684_057, 11003)
+			// Standard Error: 12_662
+			.saturating_add(Weight::from_parts(145_285, 0).saturating_mul(r.into()))
+			// Standard Error: 2_472
+			.saturating_add(Weight::from_parts(1_421_039, 0).saturating_mul(s.into()))
+			// Standard Error: 2_472
+			.saturating_add(Weight::from_parts(240_907, 0).saturating_mul(x.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 99]`.
+	fn add_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `475 + s * (36 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 29_367_000 picoseconds.
+		Weight::from_parts(34_214_998, 11003)
+			// Standard Error: 1_522
+			.saturating_add(Weight::from_parts(114_551, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 100]`.
+	fn rename_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `591 + s * (3 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 12_384_000 picoseconds.
+		Weight::from_parts(14_417_903, 11003)
+			// Standard Error: 539
+			.saturating_add(Weight::from_parts(38_371, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Identity IdentityOf (r:1 w:0)
+	/// Proof: Identity IdentityOf (max_values: None, max_size: Some(7538), added: 10013, mode: MaxEncodedLen)
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 100]`.
+	fn remove_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `638 + s * (35 ±0)`
+		//  Estimated: `11003`
+		// Minimum execution time: 33_327_000 picoseconds.
+		Weight::from_parts(36_208_941, 11003)
+			// Standard Error: 1_240
+			.saturating_add(Weight::from_parts(105_805, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Identity SuperOf (r:1 w:1)
+	/// Proof: Identity SuperOf (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: Identity SubsOf (r:1 w:1)
+	/// Proof: Identity SubsOf (max_values: None, max_size: Some(3258), added: 5733, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 99]`.
+	fn quit_sub(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `704 + s * (37 ±0)`
+		//  Estimated: `6723`
+		// Minimum execution time: 23_764_000 picoseconds.
+		Weight::from_parts(26_407_731, 6723)
+			// Standard Error: 1_025
+			.saturating_add(Weight::from_parts(101_112, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/im-online/Cargo.toml b/substrate/frame/im-online/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..23e0563a190db3e4ad608f750bd4730dab80265a
--- /dev/null
+++ b/substrate/frame/im-online/Cargo.toml
@@ -0,0 +1,64 @@
+[package]
+name = "pallet-im-online"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME's I'm online pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-authorship = { version = "4.0.0-dev", default-features = false, path = "../authorship" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto", features = ["serde"] }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core", features = ["serde"] }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-session = { version = "4.0.0-dev", path = "../session" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-authorship/std",
+	"pallet-session/std",
+	"scale-info/std",
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-authorship/try-runtime",
+	"pallet-session/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/im-online/README.md b/substrate/frame/im-online/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..be11e0c49dff3c1669b87f07391b31ead05c05ca
--- /dev/null
+++ b/substrate/frame/im-online/README.md
@@ -0,0 +1,59 @@
+# I'm online Module
+
+If the local node is a validator (i.e. contains an authority key), this module
+gossips a heartbeat transaction with each new session. The heartbeat functions
+as a simple mechanism to signal that the node is online in the current era.
+
+Received heartbeats are tracked for one era and reset with each new era. The
+module exposes two public functions to query if a heartbeat has been received
+in the current era or session.
+
+The heartbeat is a signed transaction, which was signed using the session key
+and includes the recent best block number of the local validators chain as well
+as the `NetworkState`.
+It is submitted as an Unsigned Transaction via off-chain workers.
+
+- [`im_online::Config`](https://docs.rs/pallet-im-online/latest/pallet_im_online/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-im-online/latest/pallet_im_online/enum.Call.html)
+- [`Module`](https://docs.rs/pallet-im-online/latest/pallet_im_online/struct.Module.html)
+
+## Interface
+
+### Public Functions
+
+- `is_online` - True if the validator sent a heartbeat in the current session.
+
+## Usage
+
+```rust
+use pallet_im_online::{self as im_online};
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config + im_online::Config {}
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::weight(0)]
+        pub fn is_online(origin: OriginFor<T>, authority_index: u32) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+            let _is_online = <im_online::Pallet<T>>::is_online(authority_index);
+            Ok(())
+        }
+    }
+}
+```
+
+## Dependencies
+
+This module depends on the [Session module](https://docs.rs/pallet-session/latest/pallet_session/).
+
+License: Apache-2.0
diff --git a/substrate/frame/im-online/src/benchmarking.rs b/substrate/frame/im-online/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d8170d4817e3e5f6b53db44076f7896089d6ee57
--- /dev/null
+++ b/substrate/frame/im-online/src/benchmarking.rs
@@ -0,0 +1,97 @@
+// 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.
+
+//! I'm Online pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use frame_benchmarking::v1::benchmarks;
+use frame_support::{traits::UnfilteredDispatchable, WeakBoundedVec};
+use frame_system::RawOrigin;
+use sp_runtime::{
+	traits::{ValidateUnsigned, Zero},
+	transaction_validity::TransactionSource,
+};
+
+use crate::Pallet as ImOnline;
+
+const MAX_KEYS: u32 = 1000;
+
+pub fn create_heartbeat<T: Config>(
+	k: u32,
+) -> Result<
+	(
+		crate::Heartbeat<frame_system::pallet_prelude::BlockNumberFor<T>>,
+		<T::AuthorityId as RuntimeAppPublic>::Signature,
+	),
+	&'static str,
+> {
+	let mut keys = Vec::new();
+	for _ in 0..k {
+		keys.push(T::AuthorityId::generate_pair(None));
+	}
+	let bounded_keys = WeakBoundedVec::<_, T::MaxKeys>::try_from(keys.clone())
+		.map_err(|()| "More than the maximum number of keys provided")?;
+	Keys::<T>::put(bounded_keys);
+
+	let input_heartbeat = Heartbeat {
+		block_number: frame_system::pallet_prelude::BlockNumberFor::<T>::zero(),
+		session_index: 0,
+		authority_index: k - 1,
+		validators_len: keys.len() as u32,
+	};
+
+	let encoded_heartbeat = input_heartbeat.encode();
+	let authority_id = keys.get((k - 1) as usize).ok_or("out of range")?;
+	let signature = authority_id.sign(&encoded_heartbeat).ok_or("couldn't make signature")?;
+
+	Ok((input_heartbeat, signature))
+}
+
+benchmarks! {
+	#[extra]
+	heartbeat {
+		let k in 1 .. MAX_KEYS;
+		let (input_heartbeat, signature) = create_heartbeat::<T>(k)?;
+	}: _(RawOrigin::None, input_heartbeat, signature)
+
+	#[extra]
+	validate_unsigned {
+		let k in 1 .. MAX_KEYS;
+		let (input_heartbeat, signature) = create_heartbeat::<T>(k)?;
+		let call = Call::heartbeat { heartbeat: input_heartbeat, signature };
+	}: {
+		ImOnline::<T>::validate_unsigned(TransactionSource::InBlock, &call)
+			.map_err(<&str>::from)?;
+	}
+
+	validate_unsigned_and_then_heartbeat {
+		let k in 1 .. MAX_KEYS;
+		let (input_heartbeat, signature) = create_heartbeat::<T>(k)?;
+		let call = Call::heartbeat { heartbeat: input_heartbeat, signature };
+		let call_enc = call.encode();
+	}: {
+		ImOnline::<T>::validate_unsigned(TransactionSource::InBlock, &call).map_err(<&str>::from)?;
+		<Call<T> as Decode>::decode(&mut &*call_enc)
+			.expect("call is encoded above, encoding must be correct")
+			.dispatch_bypass_filter(RawOrigin::None.into())?;
+	}
+
+	impl_benchmark_test_suite!(ImOnline, crate::mock::new_test_ext(), crate::mock::Runtime);
+}
diff --git a/substrate/frame/im-online/src/lib.rs b/substrate/frame/im-online/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1de89dd00c8121c64a19f8b45f24fc6500126dce
--- /dev/null
+++ b/substrate/frame/im-online/src/lib.rs
@@ -0,0 +1,869 @@
+// 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.
+
+//! # I'm online Pallet
+//!
+//! If the local node is a validator (i.e. contains an authority key), this pallet
+//! gossips a heartbeat transaction with each new session. The heartbeat functions
+//! as a simple mechanism to signal that the node is online in the current era.
+//!
+//! Received heartbeats are tracked for one era and reset with each new era. The
+//! pallet exposes two public functions to query if a heartbeat has been received
+//! in the current era or session.
+//!
+//! The heartbeat is a signed transaction, which was signed using the session key
+//! and includes the recent best block number of the local validators chain.
+//! It is submitted as an Unsigned Transaction via off-chain workers.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Interface
+//!
+//! ### Public Functions
+//!
+//! - `is_online` - True if the validator sent a heartbeat in the current session.
+//!
+//! ## Usage
+//!
+//! ```
+//! use pallet_im_online::{self as im_online};
+//!
+//! #[frame_support::pallet]
+//! pub mod pallet {
+//! 	use super::*;
+//! 	use frame_support::pallet_prelude::*;
+//! 	use frame_system::pallet_prelude::*;
+//!
+//! 	#[pallet::pallet]
+//! 	pub struct Pallet<T>(_);
+//!
+//! 	#[pallet::config]
+//! 	pub trait Config: frame_system::Config + im_online::Config {}
+//!
+//! 	#[pallet::call]
+//! 	impl<T: Config> Pallet<T> {
+//! 		#[pallet::weight(0)]
+//! 		pub fn is_online(origin: OriginFor<T>, authority_index: u32) -> DispatchResult {
+//! 			let _sender = ensure_signed(origin)?;
+//! 			let _is_online = <im_online::Pallet<T>>::is_online(authority_index);
+//! 			Ok(())
+//! 		}
+//! 	}
+//! }
+//! # fn main() { }
+//! ```
+//!
+//! ## Dependencies
+//!
+//! This pallet depends on the [Session pallet](../pallet_session/index.html).
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+pub mod migration;
+mod mock;
+mod tests;
+pub mod weights;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	pallet_prelude::*,
+	traits::{
+		EstimateNextSessionRotation, Get, OneSessionHandler, ValidatorSet,
+		ValidatorSetWithIdentification,
+	},
+	BoundedSlice, WeakBoundedVec,
+};
+use frame_system::{
+	offchain::{SendTransactionTypes, SubmitTransaction},
+	pallet_prelude::*,
+};
+pub use pallet::*;
+use scale_info::TypeInfo;
+use sp_application_crypto::RuntimeAppPublic;
+use sp_runtime::{
+	offchain::storage::{MutateStorageError, StorageRetrievalError, StorageValueRef},
+	traits::{AtLeast32BitUnsigned, Convert, Saturating, TrailingZeroInput},
+	PerThing, Perbill, Permill, RuntimeDebug, SaturatedConversion,
+};
+use sp_staking::{
+	offence::{DisableStrategy, Kind, Offence, ReportOffence},
+	SessionIndex,
+};
+use sp_std::prelude::*;
+pub use weights::WeightInfo;
+
+pub mod sr25519 {
+	mod app_sr25519 {
+		use sp_application_crypto::{app_crypto, key_types::IM_ONLINE, sr25519};
+		app_crypto!(sr25519, IM_ONLINE);
+	}
+
+	sp_application_crypto::with_pair! {
+		/// An i'm online keypair using sr25519 as its crypto.
+		pub type AuthorityPair = app_sr25519::Pair;
+	}
+
+	/// An i'm online signature using sr25519 as its crypto.
+	pub type AuthoritySignature = app_sr25519::Signature;
+
+	/// An i'm online identifier using sr25519 as its crypto.
+	pub type AuthorityId = app_sr25519::Public;
+}
+
+pub mod ed25519 {
+	mod app_ed25519 {
+		use sp_application_crypto::{app_crypto, ed25519, key_types::IM_ONLINE};
+		app_crypto!(ed25519, IM_ONLINE);
+	}
+
+	sp_application_crypto::with_pair! {
+		/// An i'm online keypair using ed25519 as its crypto.
+		pub type AuthorityPair = app_ed25519::Pair;
+	}
+
+	/// An i'm online signature using ed25519 as its crypto.
+	pub type AuthoritySignature = app_ed25519::Signature;
+
+	/// An i'm online identifier using ed25519 as its crypto.
+	pub type AuthorityId = app_ed25519::Public;
+}
+
+const DB_PREFIX: &[u8] = b"parity/im-online-heartbeat/";
+/// How many blocks do we wait for heartbeat transaction to be included
+/// before sending another one.
+const INCLUDE_THRESHOLD: u32 = 3;
+
+/// Status of the offchain worker code.
+///
+/// This stores the block number at which heartbeat was requested and when the worker
+/// has actually managed to produce it.
+/// Note we store such status for every `authority_index` separately.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+struct HeartbeatStatus<BlockNumber> {
+	/// An index of the session that we are supposed to send heartbeat for.
+	pub session_index: SessionIndex,
+	/// A block number at which the heartbeat for that session has been actually sent.
+	///
+	/// It may be 0 in case the sending failed. In such case we should just retry
+	/// as soon as possible (i.e. in a worker running for the next block).
+	pub sent_at: BlockNumber,
+}
+
+impl<BlockNumber: PartialEq + AtLeast32BitUnsigned + Copy> HeartbeatStatus<BlockNumber> {
+	/// Returns true if heartbeat has been recently sent.
+	///
+	/// Parameters:
+	/// `session_index` - index of current session.
+	/// `now` - block at which the offchain worker is running.
+	///
+	/// This function will return `true` iff:
+	/// 1. the session index is the same (we don't care if it went up or down)
+	/// 2. the heartbeat has been sent recently (within the threshold)
+	///
+	/// The reasoning for 1. is that it's better to send an extra heartbeat than
+	/// to stall or not send one in case of a bug.
+	fn is_recent(&self, session_index: SessionIndex, now: BlockNumber) -> bool {
+		self.session_index == session_index && self.sent_at + INCLUDE_THRESHOLD.into() > now
+	}
+}
+
+/// Error which may occur while executing the off-chain code.
+#[cfg_attr(test, derive(PartialEq))]
+enum OffchainErr<BlockNumber> {
+	TooEarly,
+	WaitingForInclusion(BlockNumber),
+	AlreadyOnline(u32),
+	FailedSigning,
+	FailedToAcquireLock,
+	SubmitTransaction,
+}
+
+impl<BlockNumber: sp_std::fmt::Debug> sp_std::fmt::Debug for OffchainErr<BlockNumber> {
+	fn fmt(&self, fmt: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		match *self {
+			OffchainErr::TooEarly => write!(fmt, "Too early to send heartbeat."),
+			OffchainErr::WaitingForInclusion(ref block) => {
+				write!(fmt, "Heartbeat already sent at {:?}. Waiting for inclusion.", block)
+			},
+			OffchainErr::AlreadyOnline(auth_idx) => {
+				write!(fmt, "Authority {} is already online", auth_idx)
+			},
+			OffchainErr::FailedSigning => write!(fmt, "Failed to sign heartbeat"),
+			OffchainErr::FailedToAcquireLock => write!(fmt, "Failed to acquire lock"),
+			OffchainErr::SubmitTransaction => write!(fmt, "Failed to submit transaction"),
+		}
+	}
+}
+
+pub type AuthIndex = u32;
+
+/// Heartbeat which is sent/received.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Heartbeat<BlockNumber>
+where
+	BlockNumber: PartialEq + Eq + Decode + Encode,
+{
+	/// Block number at the time heartbeat is created..
+	pub block_number: BlockNumber,
+	/// Index of the current session.
+	pub session_index: SessionIndex,
+	/// An index of the authority on the list of validators.
+	pub authority_index: AuthIndex,
+	/// The length of session validator set
+	pub validators_len: u32,
+}
+
+/// A type for representing the validator id in a session.
+pub type ValidatorId<T> = <<T as Config>::ValidatorSet as ValidatorSet<
+	<T as frame_system::Config>::AccountId,
+>>::ValidatorId;
+
+/// A tuple of (ValidatorId, Identification) where `Identification` is the full identification of
+/// `ValidatorId`.
+pub type IdentificationTuple<T> = (
+	ValidatorId<T>,
+	<<T as Config>::ValidatorSet as ValidatorSetWithIdentification<
+		<T as frame_system::Config>::AccountId,
+	>>::Identification,
+);
+
+type OffchainResult<T, A> = Result<A, OffchainErr<BlockNumberFor<T>>>;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: SendTransactionTypes<Call<Self>> + frame_system::Config {
+		/// The identifier type for an authority.
+		type AuthorityId: Member
+			+ Parameter
+			+ RuntimeAppPublic
+			+ Ord
+			+ MaybeSerializeDeserialize
+			+ MaxEncodedLen;
+
+		/// The maximum number of keys that can be added.
+		type MaxKeys: Get<u32>;
+
+		/// The maximum number of peers to be stored in `ReceivedHeartbeats`
+		type MaxPeerInHeartbeats: Get<u32>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// A type for retrieving the validators supposed to be online in a session.
+		type ValidatorSet: ValidatorSetWithIdentification<Self::AccountId>;
+
+		/// A trait that allows us to estimate the current session progress and also the
+		/// average session length.
+		///
+		/// This parameter is used to determine the longevity of `heartbeat` transaction and a
+		/// rough time when we should start considering sending heartbeats, since the workers
+		/// avoids sending them at the very beginning of the session, assuming there is a
+		/// chance the authority will produce a block and they won't be necessary.
+		type NextSessionRotation: EstimateNextSessionRotation<BlockNumberFor<Self>>;
+
+		/// A type that gives us the ability to submit unresponsiveness offence reports.
+		type ReportUnresponsiveness: ReportOffence<
+			Self::AccountId,
+			IdentificationTuple<Self>,
+			UnresponsivenessOffence<IdentificationTuple<Self>>,
+		>;
+
+		/// A configuration for base priority of unsigned transactions.
+		///
+		/// This is exposed so that it can be tuned for particular runtime, when
+		/// multiple pallets send unsigned transactions.
+		#[pallet::constant]
+		type UnsignedPriority: Get<TransactionPriority>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A new heartbeat was received from `AuthorityId`.
+		HeartbeatReceived { authority_id: T::AuthorityId },
+		/// At the end of the session, no offence was committed.
+		AllGood,
+		/// At the end of the session, at least one validator was found to be offline.
+		SomeOffline { offline: Vec<IdentificationTuple<T>> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Non existent public key.
+		InvalidKey,
+		/// Duplicated heartbeat.
+		DuplicatedHeartbeat,
+	}
+
+	/// The block number after which it's ok to send heartbeats in the current
+	/// session.
+	///
+	/// At the beginning of each session we set this to a value that should fall
+	/// roughly in the middle of the session duration. The idea is to first wait for
+	/// the validators to produce a block in the current session, so that the
+	/// heartbeat later on will not be necessary.
+	///
+	/// This value will only be used as a fallback if we fail to get a proper session
+	/// progress estimate from `NextSessionRotation`, as those estimates should be
+	/// more accurate then the value we calculate for `HeartbeatAfter`.
+	#[pallet::storage]
+	#[pallet::getter(fn heartbeat_after)]
+	pub(super) type HeartbeatAfter<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;
+
+	/// The current set of keys that may issue a heartbeat.
+	#[pallet::storage]
+	#[pallet::getter(fn keys)]
+	pub(super) type Keys<T: Config> =
+		StorageValue<_, WeakBoundedVec<T::AuthorityId, T::MaxKeys>, ValueQuery>;
+
+	/// For each session index, we keep a mapping of `SessionIndex` and `AuthIndex`.
+	#[pallet::storage]
+	#[pallet::getter(fn received_heartbeats)]
+	pub(super) type ReceivedHeartbeats<T: Config> =
+		StorageDoubleMap<_, Twox64Concat, SessionIndex, Twox64Concat, AuthIndex, bool>;
+
+	/// For each session index, we keep a mapping of `ValidatorId<T>` to the
+	/// number of blocks authored by the given authority.
+	#[pallet::storage]
+	#[pallet::getter(fn authored_blocks)]
+	pub(super) type AuthoredBlocks<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		SessionIndex,
+		Twox64Concat,
+		ValidatorId<T>,
+		u32,
+		ValueQuery,
+	>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub keys: Vec<T::AuthorityId>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			Pallet::<T>::initialize_keys(&self.keys);
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// ## Complexity:
+		/// - `O(K)` where K is length of `Keys` (heartbeat.validators_len)
+		///   - `O(K)`: decoding of length `K`
+		// NOTE: the weight includes the cost of validate_unsigned as it is part of the cost to
+		// import block with such an extrinsic.
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config>::WeightInfo::validate_unsigned_and_then_heartbeat(
+			heartbeat.validators_len,
+		))]
+		pub fn heartbeat(
+			origin: OriginFor<T>,
+			heartbeat: Heartbeat<BlockNumberFor<T>>,
+			// since signature verification is done in `validate_unsigned`
+			// we can skip doing it here again.
+			_signature: <T::AuthorityId as RuntimeAppPublic>::Signature,
+		) -> DispatchResult {
+			ensure_none(origin)?;
+
+			let current_session = T::ValidatorSet::session_index();
+			let exists =
+				ReceivedHeartbeats::<T>::contains_key(current_session, heartbeat.authority_index);
+			let keys = Keys::<T>::get();
+			let public = keys.get(heartbeat.authority_index as usize);
+			if let (false, Some(public)) = (exists, public) {
+				Self::deposit_event(Event::<T>::HeartbeatReceived { authority_id: public.clone() });
+
+				ReceivedHeartbeats::<T>::insert(current_session, heartbeat.authority_index, true);
+
+				Ok(())
+			} else if exists {
+				Err(Error::<T>::DuplicatedHeartbeat.into())
+			} else {
+				Err(Error::<T>::InvalidKey.into())
+			}
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn offchain_worker(now: BlockNumberFor<T>) {
+			// Only send messages if we are a potential validator.
+			if sp_io::offchain::is_validator() {
+				for res in Self::send_heartbeats(now).into_iter().flatten() {
+					if let Err(e) = res {
+						log::debug!(
+							target: "runtime::im-online",
+							"Skipping heartbeat at {:?}: {:?}",
+							now,
+							e,
+						)
+					}
+				}
+			} else {
+				log::trace!(
+					target: "runtime::im-online",
+					"Skipping heartbeat at {:?}. Not a validator.",
+					now,
+				)
+			}
+		}
+	}
+
+	/// Invalid transaction custom error. Returned when validators_len field in heartbeat is
+	/// incorrect.
+	pub(crate) const INVALID_VALIDATORS_LEN: u8 = 10;
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+
+		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			if let Call::heartbeat { heartbeat, signature } = call {
+				if <Pallet<T>>::is_online(heartbeat.authority_index) {
+					// we already received a heartbeat for this authority
+					return InvalidTransaction::Stale.into()
+				}
+
+				// check if session index from heartbeat is recent
+				let current_session = T::ValidatorSet::session_index();
+				if heartbeat.session_index != current_session {
+					return InvalidTransaction::Stale.into()
+				}
+
+				// verify that the incoming (unverified) pubkey is actually an authority id
+				let keys = Keys::<T>::get();
+				if keys.len() as u32 != heartbeat.validators_len {
+					return InvalidTransaction::Custom(INVALID_VALIDATORS_LEN).into()
+				}
+				let authority_id = match keys.get(heartbeat.authority_index as usize) {
+					Some(id) => id,
+					None => return InvalidTransaction::BadProof.into(),
+				};
+
+				// check signature (this is expensive so we do it last).
+				let signature_valid = heartbeat.using_encoded(|encoded_heartbeat| {
+					authority_id.verify(&encoded_heartbeat, signature)
+				});
+
+				if !signature_valid {
+					return InvalidTransaction::BadProof.into()
+				}
+
+				ValidTransaction::with_tag_prefix("ImOnline")
+					.priority(T::UnsignedPriority::get())
+					.and_provides((current_session, authority_id))
+					.longevity(
+						TryInto::<u64>::try_into(
+							T::NextSessionRotation::average_session_length() / 2u32.into(),
+						)
+						.unwrap_or(64_u64),
+					)
+					.propagate(true)
+					.build()
+			} else {
+				InvalidTransaction::Call.into()
+			}
+		}
+	}
+}
+
+/// Keep track of number of authored blocks per authority, uncles are counted as
+/// well since they're a valid proof of being online.
+impl<T: Config + pallet_authorship::Config>
+	pallet_authorship::EventHandler<ValidatorId<T>, BlockNumberFor<T>> for Pallet<T>
+{
+	fn note_author(author: ValidatorId<T>) {
+		Self::note_authorship(author);
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Returns `true` if a heartbeat has been received for the authority at
+	/// `authority_index` in the authorities series or if the authority has
+	/// authored at least one block, during the current session. Otherwise
+	/// `false`.
+	pub fn is_online(authority_index: AuthIndex) -> bool {
+		let current_validators = T::ValidatorSet::validators();
+
+		if authority_index >= current_validators.len() as u32 {
+			return false
+		}
+
+		let authority = &current_validators[authority_index as usize];
+
+		Self::is_online_aux(authority_index, authority)
+	}
+
+	fn is_online_aux(authority_index: AuthIndex, authority: &ValidatorId<T>) -> bool {
+		let current_session = T::ValidatorSet::session_index();
+
+		ReceivedHeartbeats::<T>::contains_key(current_session, authority_index) ||
+			AuthoredBlocks::<T>::get(current_session, authority) != 0
+	}
+
+	/// Returns `true` if a heartbeat has been received for the authority at `authority_index` in
+	/// the authorities series, during the current session. Otherwise `false`.
+	pub fn received_heartbeat_in_current_session(authority_index: AuthIndex) -> bool {
+		let current_session = T::ValidatorSet::session_index();
+		ReceivedHeartbeats::<T>::contains_key(current_session, authority_index)
+	}
+
+	/// Note that the given authority has authored a block in the current session.
+	fn note_authorship(author: ValidatorId<T>) {
+		let current_session = T::ValidatorSet::session_index();
+
+		AuthoredBlocks::<T>::mutate(current_session, author, |authored| *authored += 1);
+	}
+
+	pub(crate) fn send_heartbeats(
+		block_number: BlockNumberFor<T>,
+	) -> OffchainResult<T, impl Iterator<Item = OffchainResult<T, ()>>> {
+		const START_HEARTBEAT_RANDOM_PERIOD: Permill = Permill::from_percent(10);
+		const START_HEARTBEAT_FINAL_PERIOD: Permill = Permill::from_percent(80);
+
+		// this should give us a residual probability of 1/SESSION_LENGTH of sending an heartbeat,
+		// i.e. all heartbeats spread uniformly, over most of the session. as the session progresses
+		// the probability of sending an heartbeat starts to increase exponentially.
+		let random_choice = |progress: Permill| {
+			// given session progress `p` and session length `l`
+			// the threshold formula is: p^6 + 1/l
+			let session_length = T::NextSessionRotation::average_session_length();
+			let residual = Permill::from_rational(1u32, session_length.saturated_into());
+			let threshold: Permill = progress.saturating_pow(6).saturating_add(residual);
+
+			let seed = sp_io::offchain::random_seed();
+			let random = <u32>::decode(&mut TrailingZeroInput::new(seed.as_ref()))
+				.expect("input is padded with zeroes; qed");
+			let random = Permill::from_parts(random % Permill::ACCURACY);
+
+			random <= threshold
+		};
+
+		let should_heartbeat = if let (Some(progress), _) =
+			T::NextSessionRotation::estimate_current_session_progress(block_number)
+		{
+			// we try to get an estimate of the current session progress first since it should
+			// provide more accurate results. we will start an early heartbeat period where we'll
+			// randomly pick whether to heartbeat. after 80% of the session has elapsed, if we
+			// haven't sent an heartbeat yet we'll send one unconditionally. the idea is to prevent
+			// all nodes from sending the heartbeats at the same block and causing a temporary (but
+			// deterministic) spike in transactions.
+			progress >= START_HEARTBEAT_FINAL_PERIOD ||
+				progress >= START_HEARTBEAT_RANDOM_PERIOD && random_choice(progress)
+		} else {
+			// otherwise we fallback to using the block number calculated at the beginning
+			// of the session that should roughly correspond to the middle of the session
+			let heartbeat_after = <HeartbeatAfter<T>>::get();
+			block_number >= heartbeat_after
+		};
+
+		if !should_heartbeat {
+			return Err(OffchainErr::TooEarly)
+		}
+
+		let session_index = T::ValidatorSet::session_index();
+		let validators_len = Keys::<T>::decode_len().unwrap_or_default() as u32;
+
+		Ok(Self::local_authority_keys().map(move |(authority_index, key)| {
+			Self::send_single_heartbeat(
+				authority_index,
+				key,
+				session_index,
+				block_number,
+				validators_len,
+			)
+		}))
+	}
+
+	fn send_single_heartbeat(
+		authority_index: u32,
+		key: T::AuthorityId,
+		session_index: SessionIndex,
+		block_number: BlockNumberFor<T>,
+		validators_len: u32,
+	) -> OffchainResult<T, ()> {
+		// A helper function to prepare heartbeat call.
+		let prepare_heartbeat = || -> OffchainResult<T, Call<T>> {
+			let heartbeat =
+				Heartbeat { block_number, session_index, authority_index, validators_len };
+
+			let signature = key.sign(&heartbeat.encode()).ok_or(OffchainErr::FailedSigning)?;
+
+			Ok(Call::heartbeat { heartbeat, signature })
+		};
+
+		if Self::is_online(authority_index) {
+			return Err(OffchainErr::AlreadyOnline(authority_index))
+		}
+
+		// acquire lock for that authority at current heartbeat to make sure we don't
+		// send concurrent heartbeats.
+		Self::with_heartbeat_lock(authority_index, session_index, block_number, || {
+			let call = prepare_heartbeat()?;
+			log::info!(
+				target: "runtime::im-online",
+				"[index: {:?}] Reporting im-online at block: {:?} (session: {:?}): {:?}",
+				authority_index,
+				block_number,
+				session_index,
+				call,
+			);
+
+			SubmitTransaction::<T, Call<T>>::submit_unsigned_transaction(call.into())
+				.map_err(|_| OffchainErr::SubmitTransaction)?;
+
+			Ok(())
+		})
+	}
+
+	fn local_authority_keys() -> impl Iterator<Item = (u32, T::AuthorityId)> {
+		// on-chain storage
+		//
+		// At index `idx`:
+		// 1. A (ImOnline) public key to be used by a validator at index `idx` to send im-online
+		//    heartbeats.
+		let authorities = Keys::<T>::get();
+
+		// local keystore
+		//
+		// All `ImOnline` public (+private) keys currently in the local keystore.
+		let mut local_keys = T::AuthorityId::all();
+
+		local_keys.sort();
+
+		authorities.into_iter().enumerate().filter_map(move |(index, authority)| {
+			local_keys
+				.binary_search(&authority)
+				.ok()
+				.map(|location| (index as u32, local_keys[location].clone()))
+		})
+	}
+
+	fn with_heartbeat_lock<R>(
+		authority_index: u32,
+		session_index: SessionIndex,
+		now: BlockNumberFor<T>,
+		f: impl FnOnce() -> OffchainResult<T, R>,
+	) -> OffchainResult<T, R> {
+		let key = {
+			let mut key = DB_PREFIX.to_vec();
+			key.extend(authority_index.encode());
+			key
+		};
+		let storage = StorageValueRef::persistent(&key);
+		let res = storage.mutate(
+			|status: Result<Option<HeartbeatStatus<BlockNumberFor<T>>>, StorageRetrievalError>| {
+				// Check if there is already a lock for that particular block.
+				// This means that the heartbeat has already been sent, and we are just waiting
+				// for it to be included. However if it doesn't get included for INCLUDE_THRESHOLD
+				// we will re-send it.
+				match status {
+					// we are still waiting for inclusion.
+					Ok(Some(status)) if status.is_recent(session_index, now) =>
+						Err(OffchainErr::WaitingForInclusion(status.sent_at)),
+					// attempt to set new status
+					_ => Ok(HeartbeatStatus { session_index, sent_at: now }),
+				}
+			},
+		);
+		if let Err(MutateStorageError::ValueFunctionFailed(err)) = res {
+			return Err(err)
+		}
+
+		let mut new_status = res.map_err(|_| OffchainErr::FailedToAcquireLock)?;
+
+		// we got the lock, let's try to send the heartbeat.
+		let res = f();
+
+		// clear the lock in case we have failed to send transaction.
+		if res.is_err() {
+			new_status.sent_at = 0u32.into();
+			storage.set(&new_status);
+		}
+
+		res
+	}
+
+	fn initialize_keys(keys: &[T::AuthorityId]) {
+		if !keys.is_empty() {
+			assert!(Keys::<T>::get().is_empty(), "Keys are already initialized!");
+			let bounded_keys = <BoundedSlice<'_, _, T::MaxKeys>>::try_from(keys)
+				.expect("More than the maximum number of keys provided");
+			Keys::<T>::put(bounded_keys);
+		}
+	}
+
+	#[cfg(test)]
+	fn set_keys(keys: Vec<T::AuthorityId>) {
+		let bounded_keys = WeakBoundedVec::<_, T::MaxKeys>::try_from(keys)
+			.expect("More than the maximum number of keys provided");
+		Keys::<T>::put(bounded_keys);
+	}
+}
+
+impl<T: Config> sp_runtime::BoundToRuntimeAppPublic for Pallet<T> {
+	type Public = T::AuthorityId;
+}
+
+impl<T: Config> OneSessionHandler<T::AccountId> for Pallet<T> {
+	type Key = T::AuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
+	{
+		let keys = validators.map(|x| x.1).collect::<Vec<_>>();
+		Self::initialize_keys(&keys);
+	}
+
+	fn on_new_session<'a, I: 'a>(_changed: bool, validators: I, _queued_validators: I)
+	where
+		I: Iterator<Item = (&'a T::AccountId, T::AuthorityId)>,
+	{
+		// Tell the offchain worker to start making the next session's heartbeats.
+		// Since we consider producing blocks as being online,
+		// the heartbeat is deferred a bit to prevent spamming.
+		let block_number = <frame_system::Pallet<T>>::block_number();
+		let half_session = T::NextSessionRotation::average_session_length() / 2u32.into();
+		<HeartbeatAfter<T>>::put(block_number + half_session);
+
+		// Remember who the authorities are for the new session.
+		let keys = validators.map(|x| x.1).collect::<Vec<_>>();
+		let bounded_keys = WeakBoundedVec::<_, T::MaxKeys>::force_from(
+			keys,
+			Some(
+				"Warning: The session has more keys than expected. \
+  				A runtime configuration adjustment may be needed.",
+			),
+		);
+		Keys::<T>::put(bounded_keys);
+	}
+
+	fn on_before_session_ending() {
+		let session_index = T::ValidatorSet::session_index();
+		let keys = Keys::<T>::get();
+		let current_validators = T::ValidatorSet::validators();
+
+		let offenders = current_validators
+			.into_iter()
+			.enumerate()
+			.filter(|(index, id)| !Self::is_online_aux(*index as u32, id))
+			.filter_map(|(_, id)| {
+				<T::ValidatorSet as ValidatorSetWithIdentification<T::AccountId>>::IdentificationOf::convert(
+					id.clone()
+				).map(|full_id| (id, full_id))
+			})
+			.collect::<Vec<IdentificationTuple<T>>>();
+
+		// Remove all received heartbeats and number of authored blocks from the
+		// current session, they have already been processed and won't be needed
+		// anymore.
+		#[allow(deprecated)]
+		ReceivedHeartbeats::<T>::remove_prefix(T::ValidatorSet::session_index(), None);
+		#[allow(deprecated)]
+		AuthoredBlocks::<T>::remove_prefix(T::ValidatorSet::session_index(), None);
+
+		if offenders.is_empty() {
+			Self::deposit_event(Event::<T>::AllGood);
+		} else {
+			Self::deposit_event(Event::<T>::SomeOffline { offline: offenders.clone() });
+
+			let validator_set_count = keys.len() as u32;
+			let offence = UnresponsivenessOffence { session_index, validator_set_count, offenders };
+			if let Err(e) = T::ReportUnresponsiveness::report_offence(vec![], offence) {
+				sp_runtime::print(e);
+			}
+		}
+	}
+
+	fn on_disabled(_i: u32) {
+		// ignore
+	}
+}
+
+/// An offence that is filed if a validator didn't send a heartbeat message.
+#[derive(RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Clone, PartialEq, Eq))]
+pub struct UnresponsivenessOffence<Offender> {
+	/// The current session index in which we report the unresponsive validators.
+	///
+	/// It acts as a time measure for unresponsiveness reports and effectively will always point
+	/// at the end of the session.
+	pub session_index: SessionIndex,
+	/// The size of the validator set in current session/era.
+	pub validator_set_count: u32,
+	/// Authorities that were unresponsive during the current era.
+	pub offenders: Vec<Offender>,
+}
+
+impl<Offender: Clone> Offence<Offender> for UnresponsivenessOffence<Offender> {
+	const ID: Kind = *b"im-online:offlin";
+	type TimeSlot = SessionIndex;
+
+	fn offenders(&self) -> Vec<Offender> {
+		self.offenders.clone()
+	}
+
+	fn session_index(&self) -> SessionIndex {
+		self.session_index
+	}
+
+	fn validator_set_count(&self) -> u32 {
+		self.validator_set_count
+	}
+
+	fn time_slot(&self) -> Self::TimeSlot {
+		self.session_index
+	}
+
+	fn disable_strategy(&self) -> DisableStrategy {
+		DisableStrategy::Never
+	}
+
+	fn slash_fraction(&self, offenders: u32) -> Perbill {
+		// the formula is min((3 * (k - (n / 10 + 1))) / n, 1) * 0.07
+		// basically, 10% can be offline with no slash, but after that, it linearly climbs up to 7%
+		// when 13/30 are offline (around 5% when 1/3 are offline).
+		if let Some(threshold) = offenders.checked_sub(self.validator_set_count / 10 + 1) {
+			let x = Perbill::from_rational(3 * threshold, self.validator_set_count);
+			x.saturating_mul(Perbill::from_percent(7))
+		} else {
+			Perbill::default()
+		}
+	}
+}
diff --git a/substrate/frame/im-online/src/migration.rs b/substrate/frame/im-online/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..84652965972e3aecbdd8edba67cb3f5f1b33e49c
--- /dev/null
+++ b/substrate/frame/im-online/src/migration.rs
@@ -0,0 +1,161 @@
+// 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.
+
+//! Storage migrations for the im-online pallet.
+
+use super::*;
+use frame_support::{storage_alias, traits::OnRuntimeUpgrade};
+
+#[cfg(feature = "try-runtime")]
+use frame_support::ensure;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// The log target.
+const TARGET: &str = "runtime::im-online::migration::v1";
+
+/// The original data layout of the im-online pallet (`ReceivedHeartbeats` storage item).
+mod v0 {
+	use super::*;
+	use frame_support::traits::WrapperOpaque;
+
+	#[derive(Encode, Decode, Default)]
+	pub(super) struct BoundedOpaqueNetworkState {
+		/// PeerId of the local node in SCALE encoded.
+		pub peer_id: Vec<u8>,
+		/// List of addresses the node knows it can be reached as.
+		pub external_addresses: Vec<Vec<u8>>,
+	}
+
+	#[storage_alias]
+	pub(super) type ReceivedHeartbeats<T: Config> = StorageDoubleMap<
+		Pallet<T>,
+		Twox64Concat,
+		SessionIndex,
+		Twox64Concat,
+		AuthIndex,
+		WrapperOpaque<BoundedOpaqueNetworkState>,
+	>;
+}
+
+pub mod v1 {
+	use super::*;
+
+	/// Simple migration that replaces `ReceivedHeartbeats` values with `true`.
+	pub struct Migration<T>(sp_std::marker::PhantomData<T>);
+
+	impl<T: Config> OnRuntimeUpgrade for Migration<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			let count = v0::ReceivedHeartbeats::<T>::iter().count();
+			log::info!(target: TARGET, "Migrating {} received heartbeats", count);
+
+			Ok((count as u32).encode())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			let mut weight = T::DbWeight::get().reads(1);
+			if StorageVersion::get::<Pallet<T>>() != 0 {
+				log::warn!(
+					target: TARGET,
+					"Skipping migration because current storage version is not 0"
+				);
+				return weight
+			}
+
+			let heartbeats = v0::ReceivedHeartbeats::<T>::drain().collect::<Vec<_>>();
+
+			weight.saturating_accrue(T::DbWeight::get().reads(heartbeats.len() as u64));
+			weight.saturating_accrue(T::DbWeight::get().writes(heartbeats.len() as u64));
+
+			for (session_index, auth_index, _) in heartbeats {
+				log::trace!(
+					target: TARGET,
+					"Migrated received heartbeat for {:?}...",
+					(session_index, auth_index)
+				);
+				crate::ReceivedHeartbeats::<T>::insert(session_index, auth_index, true);
+			}
+
+			StorageVersion::new(1).put::<Pallet<T>>();
+			weight.saturating_add(T::DbWeight::get().writes(1))
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(state: Vec<u8>) -> DispatchResult {
+			let old_received_heartbeats: u32 =
+				Decode::decode(&mut &state[..]).expect("pre_upgrade provides a valid state; qed");
+			let new_received_heartbeats = crate::ReceivedHeartbeats::<T>::iter().count();
+
+			if new_received_heartbeats != old_received_heartbeats as usize {
+				log::error!(
+					target: TARGET,
+					"migrated {} received heartbeats, expected {}",
+					new_received_heartbeats,
+					old_received_heartbeats
+				);
+			}
+			ensure!(StorageVersion::get::<Pallet<T>>() >= 1, "must upgrade");
+
+			Ok(())
+		}
+	}
+}
+
+#[cfg(all(feature = "try-runtime", test))]
+mod test {
+	use super::*;
+	use crate::mock::{new_test_ext, Runtime as T};
+	use frame_support::traits::WrapperOpaque;
+
+	#[test]
+	fn migration_works() {
+		new_test_ext().execute_with(|| {
+			assert_eq!(StorageVersion::get::<Pallet<T>>(), 0);
+
+			// Insert some received heartbeats into the v0 storage:
+			let current_session = <T as pallet::Config>::ValidatorSet::session_index();
+			v0::ReceivedHeartbeats::<T>::insert(
+				&current_session,
+				0,
+				WrapperOpaque(v0::BoundedOpaqueNetworkState::default()),
+			);
+			v0::ReceivedHeartbeats::<T>::insert(
+				&current_session,
+				1,
+				WrapperOpaque(v0::BoundedOpaqueNetworkState::default()),
+			);
+
+			// Check that the v0 storage is populated
+			assert_eq!(v0::ReceivedHeartbeats::<T>::iter().count(), 2);
+			assert_eq!(crate::ReceivedHeartbeats::<T>::iter().count(), 0, "V1 storage corrupted");
+
+			// Perform the migration
+			let state = v1::Migration::<T>::pre_upgrade().unwrap();
+			let _w = v1::Migration::<T>::on_runtime_upgrade();
+			v1::Migration::<T>::post_upgrade(state).unwrap();
+
+			// Check that the v1 storage is populated and v0 storage is empty
+			assert_eq!(v0::ReceivedHeartbeats::<T>::iter().count(), 0);
+			assert_eq!(crate::ReceivedHeartbeats::<T>::iter().count(), 2);
+			assert!(crate::ReceivedHeartbeats::<T>::contains_key(&current_session, 0));
+			assert_eq!(Some(true), crate::ReceivedHeartbeats::<T>::get(&current_session, 1));
+
+			assert_eq!(StorageVersion::get::<Pallet<T>>(), 1);
+		});
+	}
+}
diff --git a/substrate/frame/im-online/src/mock.rs b/substrate/frame/im-online/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..85da061fe904af384a1bbce3bec113d8b8dd6114
--- /dev/null
+++ b/substrate/frame/im-online/src/mock.rs
@@ -0,0 +1,232 @@
+// 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.
+
+//! Test utilities
+
+#![cfg(test)]
+
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+	weights::Weight,
+};
+use pallet_session::historical as pallet_session_historical;
+use sp_core::H256;
+use sp_runtime::{
+	testing::{TestXt, UintAuthorityId},
+	traits::{BlakeTwo256, ConvertInto, IdentityLookup},
+	BuildStorage, Permill,
+};
+use sp_staking::{
+	offence::{OffenceError, ReportOffence},
+	SessionIndex,
+};
+
+use crate as imonline;
+use crate::Config;
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+		ImOnline: imonline::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Historical: pallet_session_historical::{Pallet},
+	}
+);
+
+parameter_types! {
+	pub static Validators: Option<Vec<u64>> = Some(vec![
+		1,
+		2,
+		3,
+	]);
+}
+
+pub struct TestSessionManager;
+impl pallet_session::SessionManager<u64> for TestSessionManager {
+	fn new_session(_new_index: SessionIndex) -> Option<Vec<u64>> {
+		Validators::mutate(|l| l.take())
+	}
+	fn end_session(_: SessionIndex) {}
+	fn start_session(_: SessionIndex) {}
+}
+
+impl pallet_session::historical::SessionManager<u64, u64> for TestSessionManager {
+	fn new_session(_new_index: SessionIndex) -> Option<Vec<(u64, u64)>> {
+		Validators::mutate(|l| {
+			l.take().map(|validators| validators.iter().map(|v| (*v, *v)).collect())
+		})
+	}
+	fn end_session(_: SessionIndex) {}
+	fn start_session(_: SessionIndex) {}
+}
+
+/// An extrinsic type used for tests.
+pub type Extrinsic = TestXt<RuntimeCall, ()>;
+type IdentificationTuple = (u64, u64);
+type Offence = crate::UnresponsivenessOffence<IdentificationTuple>;
+
+parameter_types! {
+	pub static Offences: Vec<(Vec<u64>, Offence)> = vec![];
+}
+
+/// A mock offence report handler.
+pub struct OffenceHandler;
+impl ReportOffence<u64, IdentificationTuple, Offence> for OffenceHandler {
+	fn report_offence(reporters: Vec<u64>, offence: Offence) -> Result<(), OffenceError> {
+		Offences::mutate(|l| l.push((reporters, offence)));
+		Ok(())
+	}
+
+	fn is_known_offence(_offenders: &[IdentificationTuple], _time_slot: &SessionIndex) -> bool {
+		false
+	}
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+	let mut result: sp_io::TestExternalities = t.into();
+	// Set the default keys, otherwise session will discard the validator.
+	result.execute_with(|| {
+		for i in 1..=6 {
+			System::inc_providers(&i);
+			assert_eq!(Session::set_keys(RuntimeOrigin::signed(i), (i - 1).into(), vec![]), Ok(()));
+		}
+	});
+	result
+}
+
+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! {
+	pub const Period: u64 = 1;
+	pub const Offset: u64 = 0;
+}
+
+impl pallet_session::Config for Runtime {
+	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+	type SessionManager =
+		pallet_session::historical::NoteHistoricalRoot<Runtime, TestSessionManager>;
+	type SessionHandler = (ImOnline,);
+	type ValidatorId = u64;
+	type ValidatorIdOf = ConvertInto;
+	type Keys = UintAuthorityId;
+	type RuntimeEvent = RuntimeEvent;
+	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+	type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Runtime {
+	type FullIdentification = u64;
+	type FullIdentificationOf = ConvertInto;
+}
+
+impl pallet_authorship::Config for Runtime {
+	type FindAuthor = ();
+	type EventHandler = ImOnline;
+}
+
+parameter_types! {
+	pub static MockCurrentSessionProgress: Option<Option<Permill>> = None;
+}
+
+parameter_types! {
+	pub static MockAverageSessionLength: Option<u64> = None;
+}
+
+pub struct TestNextSessionRotation;
+
+impl frame_support::traits::EstimateNextSessionRotation<u64> for TestNextSessionRotation {
+	fn average_session_length() -> u64 {
+		// take the mock result if any and return it
+		let mock = MockAverageSessionLength::mutate(|p| p.take());
+
+		mock.unwrap_or(pallet_session::PeriodicSessions::<Period, Offset>::average_session_length())
+	}
+
+	fn estimate_current_session_progress(now: u64) -> (Option<Permill>, Weight) {
+		let (estimate, weight) =
+			pallet_session::PeriodicSessions::<Period, Offset>::estimate_current_session_progress(
+				now,
+			);
+
+		// take the mock result if any and return it
+		let mock = MockCurrentSessionProgress::mutate(|p| p.take());
+
+		(mock.unwrap_or(estimate), weight)
+	}
+
+	fn estimate_next_session_rotation(now: u64) -> (Option<u64>, Weight) {
+		pallet_session::PeriodicSessions::<Period, Offset>::estimate_next_session_rotation(now)
+	}
+}
+
+impl Config for Runtime {
+	type AuthorityId = UintAuthorityId;
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorSet = Historical;
+	type NextSessionRotation = TestNextSessionRotation;
+	type ReportUnresponsiveness = OffenceHandler;
+	type UnsignedPriority = ConstU64<{ 1 << 20 }>;
+	type WeightInfo = ();
+	type MaxKeys = ConstU32<10_000>;
+	type MaxPeerInHeartbeats = ConstU32<10_000>;
+}
+
+impl<LocalCall> frame_system::offchain::SendTransactionTypes<LocalCall> for Runtime
+where
+	RuntimeCall: From<LocalCall>,
+{
+	type OverarchingCall = RuntimeCall;
+	type Extrinsic = Extrinsic;
+}
+
+pub fn advance_session() {
+	let now = System::block_number().max(1);
+	System::set_block_number(now + 1);
+	Session::rotate_session();
+	let keys = Session::validators().into_iter().map(UintAuthorityId).collect();
+	ImOnline::set_keys(keys);
+	assert_eq!(Session::current_index(), (now / Period::get()) as u32);
+}
diff --git a/substrate/frame/im-online/src/tests.rs b/substrate/frame/im-online/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..79036760c2d427c2895163b150f3806bf17222f2
--- /dev/null
+++ b/substrate/frame/im-online/src/tests.rs
@@ -0,0 +1,511 @@
+// 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 the im-online module.
+
+#![cfg(test)]
+
+use super::*;
+use crate::mock::*;
+use frame_support::{assert_noop, dispatch};
+use sp_core::offchain::{
+	testing::{TestOffchainExt, TestTransactionPoolExt},
+	OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
+};
+use sp_runtime::{
+	testing::UintAuthorityId,
+	transaction_validity::{InvalidTransaction, TransactionValidityError},
+};
+
+#[test]
+fn test_unresponsiveness_slash_fraction() {
+	let dummy_offence =
+		UnresponsivenessOffence { session_index: 0, validator_set_count: 50, offenders: vec![()] };
+	// A single case of unresponsiveness is not slashed.
+	assert_eq!(dummy_offence.slash_fraction(1), Perbill::zero());
+
+	assert_eq!(
+		dummy_offence.slash_fraction(5),
+		Perbill::zero(), // 0%
+	);
+
+	assert_eq!(
+		dummy_offence.slash_fraction(7),
+		Perbill::from_parts(4200000), // 0.42%
+	);
+
+	// One third offline should be punished around 5%.
+	assert_eq!(
+		dummy_offence.slash_fraction(17),
+		Perbill::from_parts(46200000), // 4.62%
+	);
+
+	// Offline offences should never lead to being disabled.
+	assert_eq!(dummy_offence.disable_strategy(), DisableStrategy::Never);
+}
+
+#[test]
+fn should_report_offline_validators() {
+	new_test_ext().execute_with(|| {
+		// given
+		let block = 1;
+		System::set_block_number(block);
+		// buffer new validators
+		advance_session();
+		// enact the change and buffer another one
+		let validators = vec![1, 2, 3, 4, 5, 6];
+		Validators::mutate(|l| *l = Some(validators.clone()));
+		advance_session();
+
+		// when
+		// we end current session and start the next one
+		advance_session();
+
+		// then
+		let offences = Offences::take();
+		assert_eq!(
+			offences,
+			vec![(
+				vec![],
+				UnresponsivenessOffence {
+					session_index: 2,
+					validator_set_count: 3,
+					offenders: vec![(1, 1), (2, 2), (3, 3),],
+				}
+			)]
+		);
+
+		// should not report when heartbeat is sent
+		for (idx, v) in validators.into_iter().take(4).enumerate() {
+			let _ = heartbeat(block, 3, idx as u32, v.into(), Session::validators()).unwrap();
+		}
+		advance_session();
+
+		// then
+		let offences = Offences::take();
+		assert_eq!(
+			offences,
+			vec![(
+				vec![],
+				UnresponsivenessOffence {
+					session_index: 3,
+					validator_set_count: 6,
+					offenders: vec![(5, 5), (6, 6),],
+				}
+			)]
+		);
+	});
+}
+
+fn heartbeat(
+	block_number: u64,
+	session_index: u32,
+	authority_index: u32,
+	id: UintAuthorityId,
+	validators: Vec<u64>,
+) -> dispatch::DispatchResult {
+	let heartbeat = Heartbeat {
+		block_number,
+		session_index,
+		authority_index,
+		validators_len: validators.len() as u32,
+	};
+	let signature = id.sign(&heartbeat.encode()).unwrap();
+
+	ImOnline::pre_dispatch(&crate::Call::heartbeat {
+		heartbeat: heartbeat.clone(),
+		signature: signature.clone(),
+	})
+	.map_err(|e| match e {
+		TransactionValidityError::Invalid(InvalidTransaction::Custom(INVALID_VALIDATORS_LEN)) =>
+			"invalid validators len",
+		e @ _ => <&'static str>::from(e),
+	})?;
+	ImOnline::heartbeat(RuntimeOrigin::none(), heartbeat, signature)
+}
+
+#[test]
+fn should_mark_online_validator_when_heartbeat_is_received() {
+	new_test_ext().execute_with(|| {
+		advance_session();
+		// given
+		Validators::mutate(|l| *l = Some(vec![1, 2, 3, 4, 5, 6]));
+		assert_eq!(Session::validators(), Vec::<u64>::new());
+		// enact the change and buffer another one
+		advance_session();
+
+		assert_eq!(Session::current_index(), 2);
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+
+		assert!(!ImOnline::is_online(0));
+		assert!(!ImOnline::is_online(1));
+		assert!(!ImOnline::is_online(2));
+
+		// when
+		let _ = heartbeat(1, 2, 0, 1.into(), Session::validators()).unwrap();
+
+		// then
+		assert!(ImOnline::is_online(0));
+		assert!(!ImOnline::is_online(1));
+		assert!(!ImOnline::is_online(2));
+
+		// and when
+		let _ = heartbeat(1, 2, 2, 3.into(), Session::validators()).unwrap();
+
+		// then
+		assert!(ImOnline::is_online(0));
+		assert!(!ImOnline::is_online(1));
+		assert!(ImOnline::is_online(2));
+	});
+}
+
+#[test]
+fn late_heartbeat_and_invalid_keys_len_should_fail() {
+	new_test_ext().execute_with(|| {
+		advance_session();
+		// given
+		Validators::mutate(|l| *l = Some(vec![1, 2, 3, 4, 5, 6]));
+		assert_eq!(Session::validators(), Vec::<u64>::new());
+		// enact the change and buffer another one
+		advance_session();
+
+		assert_eq!(Session::current_index(), 2);
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+
+		// when
+		assert_noop!(
+			heartbeat(1, 3, 0, 1.into(), Session::validators()),
+			"Transaction is outdated"
+		);
+		assert_noop!(
+			heartbeat(1, 1, 0, 1.into(), Session::validators()),
+			"Transaction is outdated"
+		);
+
+		// invalid validators_len
+		assert_noop!(heartbeat(1, 2, 0, 1.into(), vec![]), "invalid validators len");
+	});
+}
+
+#[test]
+fn should_generate_heartbeats() {
+	let mut ext = new_test_ext();
+	let (offchain, _state) = TestOffchainExt::new();
+	let (pool, state) = TestTransactionPoolExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	ext.register_extension(TransactionPoolExt::new(pool));
+
+	ext.execute_with(|| {
+		// given
+		let block = 1;
+		System::set_block_number(block);
+		UintAuthorityId::set_all_keys(vec![0, 1, 2]);
+		// buffer new validators
+		Session::rotate_session();
+		// enact the change and buffer another one
+		Validators::mutate(|l| *l = Some(vec![1, 2, 3, 4, 5, 6]));
+		Session::rotate_session();
+
+		// when
+		ImOnline::offchain_worker(block);
+
+		// then
+		let transaction = state.write().transactions.pop().unwrap();
+		// All validators have `0` as their session key, so we generate 2 transactions.
+		assert_eq!(state.read().transactions.len(), 2);
+
+		// check stuff about the transaction.
+		let ex: Extrinsic = Decode::decode(&mut &*transaction).unwrap();
+		let heartbeat = match ex.call {
+			crate::mock::RuntimeCall::ImOnline(crate::Call::heartbeat { heartbeat, .. }) =>
+				heartbeat,
+			e => panic!("Unexpected call: {:?}", e),
+		};
+
+		assert_eq!(
+			heartbeat,
+			Heartbeat {
+				block_number: block,
+				session_index: 2,
+				authority_index: 2,
+				validators_len: 3,
+			}
+		);
+	});
+}
+
+#[test]
+fn should_cleanup_received_heartbeats_on_session_end() {
+	new_test_ext().execute_with(|| {
+		advance_session();
+
+		Validators::mutate(|l| *l = Some(vec![1, 2, 3]));
+		assert_eq!(Session::validators(), Vec::<u64>::new());
+
+		// enact the change and buffer another one
+		advance_session();
+
+		assert_eq!(Session::current_index(), 2);
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+
+		// send an heartbeat from authority id 0 at session 2
+		let _ = heartbeat(1, 2, 0, 1.into(), Session::validators()).unwrap();
+
+		// the heartbeat is stored
+		assert!(!ImOnline::received_heartbeats(&2, &0).is_none());
+
+		advance_session();
+
+		// after the session has ended we have already processed the heartbeat
+		// message, so any messages received on the previous session should have
+		// been pruned.
+		assert!(ImOnline::received_heartbeats(&2, &0).is_none());
+	});
+}
+
+#[test]
+fn should_mark_online_validator_when_block_is_authored() {
+	use pallet_authorship::EventHandler;
+
+	new_test_ext().execute_with(|| {
+		advance_session();
+		// given
+		Validators::mutate(|l| *l = Some(vec![1, 2, 3, 4, 5, 6]));
+		assert_eq!(Session::validators(), Vec::<u64>::new());
+		// enact the change and buffer another one
+		advance_session();
+
+		assert_eq!(Session::current_index(), 2);
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+
+		for i in 0..3 {
+			assert!(!ImOnline::is_online(i));
+		}
+
+		// when
+		ImOnline::note_author(1);
+
+		// then
+		assert!(ImOnline::is_online(0));
+		assert!(!ImOnline::is_online(1));
+		assert!(!ImOnline::is_online(2));
+	});
+}
+
+#[test]
+fn should_not_send_a_report_if_already_online() {
+	use pallet_authorship::EventHandler;
+
+	let mut ext = new_test_ext();
+	let (offchain, _state) = TestOffchainExt::new();
+	let (pool, pool_state) = TestTransactionPoolExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	ext.register_extension(TransactionPoolExt::new(pool));
+
+	ext.execute_with(|| {
+		advance_session();
+		// given
+		Validators::mutate(|l| *l = Some(vec![1, 2, 3, 4, 5, 6]));
+		assert_eq!(Session::validators(), Vec::<u64>::new());
+		// enact the change and buffer another one
+		advance_session();
+		assert_eq!(Session::current_index(), 2);
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+		ImOnline::note_author(2);
+		ImOnline::note_author(3);
+
+		// when
+		UintAuthorityId::set_all_keys(vec![1, 2, 3]);
+		// we expect error, since the authority is already online.
+		let mut res = ImOnline::send_heartbeats(4).unwrap();
+		res.next().unwrap().unwrap();
+		assert_eq!(res.next().unwrap().unwrap_err(), OffchainErr::AlreadyOnline(1));
+		assert_eq!(res.next().unwrap().unwrap_err(), OffchainErr::AlreadyOnline(2));
+		assert_eq!(res.next(), None);
+
+		// then
+		let transaction = pool_state.write().transactions.pop().unwrap();
+		// All validators have `0` as their session key, but we should only produce 1 heartbeat.
+		assert_eq!(pool_state.read().transactions.len(), 0);
+		// check stuff about the transaction.
+		let ex: Extrinsic = Decode::decode(&mut &*transaction).unwrap();
+		let heartbeat = match ex.call {
+			crate::mock::RuntimeCall::ImOnline(crate::Call::heartbeat { heartbeat, .. }) =>
+				heartbeat,
+			e => panic!("Unexpected call: {:?}", e),
+		};
+
+		assert_eq!(
+			heartbeat,
+			Heartbeat { block_number: 4, session_index: 2, authority_index: 0, validators_len: 3 }
+		);
+	});
+}
+
+#[test]
+fn should_handle_missing_progress_estimates() {
+	let mut ext = new_test_ext();
+	let (offchain, _state) = TestOffchainExt::new();
+	let (pool, state) = TestTransactionPoolExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	ext.register_extension(TransactionPoolExt::new(pool));
+
+	ext.execute_with(|| {
+		let block = 1;
+
+		System::set_block_number(block);
+		UintAuthorityId::set_all_keys(vec![0, 1, 2]);
+
+		// buffer new validators
+		Session::rotate_session();
+
+		// enact the change and buffer another one
+		Validators::mutate(|l| *l = Some(vec![0, 1, 2]));
+		Session::rotate_session();
+
+		// we will return `None` on the next call to `estimate_current_session_progress`
+		// and the offchain worker should fallback to checking `HeartbeatAfter`
+		MockCurrentSessionProgress::mutate(|p| *p = Some(None));
+		ImOnline::offchain_worker(block);
+
+		assert_eq!(state.read().transactions.len(), 3);
+	});
+}
+
+#[test]
+fn should_handle_non_linear_session_progress() {
+	// NOTE: this is the reason why we started using `EstimateNextSessionRotation` to figure out if
+	// we should send a heartbeat, it's possible that between successive blocks we progress through
+	// the session more than just one block increment (in BABE session length is defined in slots,
+	// not block numbers).
+
+	let mut ext = new_test_ext();
+	let (offchain, _state) = TestOffchainExt::new();
+	let (pool, _) = TestTransactionPoolExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	ext.register_extension(TransactionPoolExt::new(pool));
+
+	ext.execute_with(|| {
+		UintAuthorityId::set_all_keys(vec![0, 1, 2]);
+
+		// buffer new validator
+		Session::rotate_session();
+
+		// mock the session length as being 10 blocks long,
+		// enact the change and buffer another one
+		Validators::mutate(|l| *l = Some(vec![0, 1, 2]));
+
+		// mock the session length has being 10 which should make us assume the fallback for half
+		// session will be reached by block 5.
+		MockAverageSessionLength::mutate(|p| *p = Some(10));
+
+		Session::rotate_session();
+
+		// if we don't have valid results for the current session progres then
+		// we'll fallback to `HeartbeatAfter` and only heartbeat on block 5.
+		MockCurrentSessionProgress::mutate(|p| *p = Some(None));
+		assert_eq!(ImOnline::send_heartbeats(2).err(), Some(OffchainErr::TooEarly));
+
+		MockCurrentSessionProgress::mutate(|p| *p = Some(None));
+		assert!(ImOnline::send_heartbeats(5).ok().is_some());
+
+		// if we have a valid current session progress then we'll heartbeat as soon
+		// as we're past 80% of the session regardless of the block number
+		MockCurrentSessionProgress::mutate(|p| *p = Some(Some(Permill::from_percent(81))));
+
+		assert!(ImOnline::send_heartbeats(2).ok().is_some());
+	});
+}
+
+#[test]
+fn test_does_not_heartbeat_early_in_the_session() {
+	let mut ext = new_test_ext();
+	let (offchain, _state) = TestOffchainExt::new();
+	let (pool, _) = TestTransactionPoolExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	ext.register_extension(TransactionPoolExt::new(pool));
+
+	ext.execute_with(|| {
+		// mock current session progress as being 5%. we only randomly start
+		// heartbeating after 10% of the session has elapsed.
+		MockCurrentSessionProgress::mutate(|p| *p = Some(Some(Permill::from_float(0.05))));
+		assert_eq!(ImOnline::send_heartbeats(2).err(), Some(OffchainErr::TooEarly));
+	});
+}
+
+#[test]
+fn test_probability_of_heartbeating_increases_with_session_progress() {
+	let mut ext = new_test_ext();
+	let (offchain, state) = TestOffchainExt::new();
+	let (pool, _) = TestTransactionPoolExt::new();
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+	ext.register_extension(TransactionPoolExt::new(pool));
+
+	ext.execute_with(|| {
+		let set_test = |progress, random: f64| {
+			// the average session length is 100 blocks, therefore the residual
+			// probability of sending a heartbeat is 1%
+			MockAverageSessionLength::mutate(|p| *p = Some(100));
+			MockCurrentSessionProgress::mutate(|p| *p = Some(Some(Permill::from_float(progress))));
+
+			let mut seed = [0u8; 32];
+			let encoded = ((random * Permill::ACCURACY as f64) as u32).encode();
+			seed[0..4].copy_from_slice(&encoded);
+			state.write().seed = seed;
+		};
+
+		let assert_too_early = |progress, random| {
+			set_test(progress, random);
+			assert_eq!(ImOnline::send_heartbeats(2).err(), Some(OffchainErr::TooEarly));
+		};
+
+		let assert_heartbeat_ok = |progress, random| {
+			set_test(progress, random);
+			assert!(ImOnline::send_heartbeats(2).ok().is_some());
+		};
+
+		assert_too_early(0.05, 1.0);
+
+		assert_too_early(0.1, 0.1);
+		assert_too_early(0.1, 0.011);
+		assert_heartbeat_ok(0.1, 0.010);
+
+		assert_too_early(0.4, 0.015);
+		assert_heartbeat_ok(0.4, 0.014);
+
+		assert_too_early(0.5, 0.026);
+		assert_heartbeat_ok(0.5, 0.025);
+
+		assert_too_early(0.6, 0.057);
+		assert_heartbeat_ok(0.6, 0.056);
+
+		assert_too_early(0.65, 0.086);
+		assert_heartbeat_ok(0.65, 0.085);
+
+		assert_too_early(0.7, 0.13);
+		assert_heartbeat_ok(0.7, 0.12);
+
+		assert_too_early(0.75, 0.19);
+		assert_heartbeat_ok(0.75, 0.18);
+	});
+}
diff --git a/substrate/frame/im-online/src/weights.rs b/substrate/frame/im-online/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3db02af2578209d9ab97a777ef4a7447d45b738
--- /dev/null
+++ b/substrate/frame/im-online/src/weights.rs
@@ -0,0 +1,111 @@
+// 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.
+
+//! Autogenerated weights for pallet_im_online
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_im_online
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/im-online/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_im_online.
+pub trait WeightInfo {
+	fn validate_unsigned_and_then_heartbeat(k: u32, ) -> Weight;
+}
+
+/// Weights for pallet_im_online using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Session Validators (r:1 w:0)
+	/// Proof Skipped: Session Validators (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Session CurrentIndex (r:1 w:0)
+	/// Proof Skipped: Session CurrentIndex (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ImOnline Keys (r:1 w:0)
+	/// Proof: ImOnline Keys (max_values: Some(1), max_size: Some(320002), added: 320497, mode: MaxEncodedLen)
+	/// Storage: ImOnline ReceivedHeartbeats (r:1 w:1)
+	/// Proof: ImOnline ReceivedHeartbeats (max_values: None, max_size: Some(25), added: 2500, mode: MaxEncodedLen)
+	/// Storage: ImOnline AuthoredBlocks (r:1 w:0)
+	/// Proof: ImOnline AuthoredBlocks (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen)
+	/// The range of component `k` is `[1, 1000]`.
+	fn validate_unsigned_and_then_heartbeat(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `295 + k * (32 ±0)`
+		//  Estimated: `321487 + k * (1761 ±0)`
+		// Minimum execution time: 80_568_000 picoseconds.
+		Weight::from_parts(95_175_595, 321487)
+			// Standard Error: 627
+			.saturating_add(Weight::from_parts(39_094, 0).saturating_mul(k.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 1761).saturating_mul(k.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Session Validators (r:1 w:0)
+	/// Proof Skipped: Session Validators (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Session CurrentIndex (r:1 w:0)
+	/// Proof Skipped: Session CurrentIndex (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: ImOnline Keys (r:1 w:0)
+	/// Proof: ImOnline Keys (max_values: Some(1), max_size: Some(320002), added: 320497, mode: MaxEncodedLen)
+	/// Storage: ImOnline ReceivedHeartbeats (r:1 w:1)
+	/// Proof: ImOnline ReceivedHeartbeats (max_values: None, max_size: Some(25), added: 2500, mode: MaxEncodedLen)
+	/// Storage: ImOnline AuthoredBlocks (r:1 w:0)
+	/// Proof: ImOnline AuthoredBlocks (max_values: None, max_size: Some(56), added: 2531, mode: MaxEncodedLen)
+	/// The range of component `k` is `[1, 1000]`.
+	fn validate_unsigned_and_then_heartbeat(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `295 + k * (32 ±0)`
+		//  Estimated: `321487 + k * (1761 ±0)`
+		// Minimum execution time: 80_568_000 picoseconds.
+		Weight::from_parts(95_175_595, 321487)
+			// Standard Error: 627
+			.saturating_add(Weight::from_parts(39_094, 0).saturating_mul(k.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 1761).saturating_mul(k.into()))
+	}
+}
diff --git a/substrate/frame/indices/Cargo.toml b/substrate/frame/indices/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..84e41a0cbed20be55b4b1a4f2ae61abd31247756
--- /dev/null
+++ b/substrate/frame/indices/Cargo.toml
@@ -0,0 +1,57 @@
+[package]
+name = "pallet-indices"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME indices management pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-keyring = { version = "24.0.0", optional = true, path = "../../primitives/keyring" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-keyring",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/indices/README.md b/substrate/frame/indices/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..243392780db28e9e6b941a5bb1e7d3c79d78887d
--- /dev/null
+++ b/substrate/frame/indices/README.md
@@ -0,0 +1,4 @@
+An index is a short form of an address. This module handles allocation
+of indices for a newly created accounts.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/indices/src/benchmarking.rs b/substrate/frame/indices/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bd173815cb347b9259c2972f1ffb1ad7c3af63a4
--- /dev/null
+++ b/substrate/frame/indices/src/benchmarking.rs
@@ -0,0 +1,98 @@
+// 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.
+
+// Benchmarks for Indices Pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller};
+use frame_system::RawOrigin;
+use sp_runtime::traits::Bounded;
+
+use crate::Pallet as Indices;
+
+const SEED: u32 = 0;
+
+benchmarks! {
+	claim {
+		let account_index = T::AccountIndex::from(SEED);
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+	}: _(RawOrigin::Signed(caller.clone()), account_index)
+	verify {
+		assert_eq!(Accounts::<T>::get(account_index).unwrap().0, caller);
+	}
+
+	transfer {
+		let account_index = T::AccountIndex::from(SEED);
+		// Setup accounts
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+		T::Currency::make_free_balance_be(&recipient, BalanceOf::<T>::max_value());
+		// Claim the index
+		Indices::<T>::claim(RawOrigin::Signed(caller.clone()).into(), account_index)?;
+	}: _(RawOrigin::Signed(caller.clone()), recipient_lookup, account_index)
+	verify {
+		assert_eq!(Accounts::<T>::get(account_index).unwrap().0, recipient);
+	}
+
+	free {
+		let account_index = T::AccountIndex::from(SEED);
+		// Setup accounts
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		// Claim the index
+		Indices::<T>::claim(RawOrigin::Signed(caller.clone()).into(), account_index)?;
+	}: _(RawOrigin::Signed(caller.clone()), account_index)
+	verify {
+		assert_eq!(Accounts::<T>::get(account_index), None);
+	}
+
+	force_transfer {
+		let account_index = T::AccountIndex::from(SEED);
+		// Setup accounts
+		let original: T::AccountId = account("original", 0, SEED);
+		T::Currency::make_free_balance_be(&original, BalanceOf::<T>::max_value());
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		let recipient_lookup = T::Lookup::unlookup(recipient.clone());
+		T::Currency::make_free_balance_be(&recipient, BalanceOf::<T>::max_value());
+		// Claim the index
+		Indices::<T>::claim(RawOrigin::Signed(original).into(), account_index)?;
+	}: _(RawOrigin::Root, recipient_lookup, account_index, false)
+	verify {
+		assert_eq!(Accounts::<T>::get(account_index).unwrap().0, recipient);
+	}
+
+	freeze {
+		let account_index = T::AccountIndex::from(SEED);
+		// Setup accounts
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		// Claim the index
+		Indices::<T>::claim(RawOrigin::Signed(caller.clone()).into(), account_index)?;
+	}: _(RawOrigin::Signed(caller.clone()), account_index)
+	verify {
+		assert_eq!(Accounts::<T>::get(account_index).unwrap().2, true);
+	}
+
+	// TODO in another PR: lookup and unlookup trait weights (not critical)
+
+	impl_benchmark_test_suite!(Indices, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/indices/src/lib.rs b/substrate/frame/indices/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3c0b49304131f58ee64fc1e2824f9e2b9b6a33c9
--- /dev/null
+++ b/substrate/frame/indices/src/lib.rs
@@ -0,0 +1,310 @@
+// 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.
+
+//! An index is a short form of an address. This module handles allocation
+//! of indices for a newly created accounts.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod mock;
+mod tests;
+pub mod weights;
+
+use codec::Codec;
+use frame_support::traits::{BalanceStatus::Reserved, Currency, ReservableCurrency};
+use sp_runtime::{
+	traits::{AtLeast32Bit, LookupError, Saturating, StaticLookup, Zero},
+	MultiAddress,
+};
+use sp_std::prelude::*;
+pub use weights::WeightInfo;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The module's config trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Type used for storing an account's index; implies the maximum number of accounts the
+		/// system can hold.
+		type AccountIndex: Parameter
+			+ Member
+			+ MaybeSerializeDeserialize
+			+ Codec
+			+ Default
+			+ AtLeast32Bit
+			+ Copy
+			+ MaxEncodedLen;
+
+		/// The currency trait.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// The deposit needed for reserving an index.
+		#[pallet::constant]
+		type Deposit: Get<BalanceOf<Self>>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Assign an previously unassigned index.
+		///
+		/// Payment: `Deposit` is reserved from the sender account.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `index`: the index to be claimed. This must not be in use.
+		///
+		/// Emits `IndexAssigned` if successful.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::claim())]
+		pub fn claim(origin: OriginFor<T>, index: T::AccountIndex) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			Accounts::<T>::try_mutate(index, |maybe_value| {
+				ensure!(maybe_value.is_none(), Error::<T>::InUse);
+				*maybe_value = Some((who.clone(), T::Deposit::get(), false));
+				T::Currency::reserve(&who, T::Deposit::get())
+			})?;
+			Self::deposit_event(Event::IndexAssigned { who, index });
+			Ok(())
+		}
+
+		/// Assign an index already owned by the sender to another account. The balance reservation
+		/// is effectively transferred to the new account.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `index`: the index to be re-assigned. This must be owned by the sender.
+		/// - `new`: the new owner of the index. This function is a no-op if it is equal to sender.
+		///
+		/// Emits `IndexAssigned` if successful.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::transfer())]
+		pub fn transfer(
+			origin: OriginFor<T>,
+			new: AccountIdLookupOf<T>,
+			index: T::AccountIndex,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let new = T::Lookup::lookup(new)?;
+			ensure!(who != new, Error::<T>::NotTransfer);
+
+			Accounts::<T>::try_mutate(index, |maybe_value| -> DispatchResult {
+				let (account, amount, perm) = maybe_value.take().ok_or(Error::<T>::NotAssigned)?;
+				ensure!(!perm, Error::<T>::Permanent);
+				ensure!(account == who, Error::<T>::NotOwner);
+				let lost = T::Currency::repatriate_reserved(&who, &new, amount, Reserved)?;
+				*maybe_value = Some((new.clone(), amount.saturating_sub(lost), false));
+				Ok(())
+			})?;
+			Self::deposit_event(Event::IndexAssigned { who: new, index });
+			Ok(())
+		}
+
+		/// Free up an index owned by the sender.
+		///
+		/// Payment: Any previous deposit placed for the index is unreserved in the sender account.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must own the index.
+		///
+		/// - `index`: the index to be freed. This must be owned by the sender.
+		///
+		/// Emits `IndexFreed` if successful.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::free())]
+		pub fn free(origin: OriginFor<T>, index: T::AccountIndex) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			Accounts::<T>::try_mutate(index, |maybe_value| -> DispatchResult {
+				let (account, amount, perm) = maybe_value.take().ok_or(Error::<T>::NotAssigned)?;
+				ensure!(!perm, Error::<T>::Permanent);
+				ensure!(account == who, Error::<T>::NotOwner);
+				T::Currency::unreserve(&who, amount);
+				Ok(())
+			})?;
+			Self::deposit_event(Event::IndexFreed { index });
+			Ok(())
+		}
+
+		/// Force an index to an account. This doesn't require a deposit. If the index is already
+		/// held, then any deposit is reimbursed to its current owner.
+		///
+		/// The dispatch origin for this call must be _Root_.
+		///
+		/// - `index`: the index to be (re-)assigned.
+		/// - `new`: the new owner of the index. This function is a no-op if it is equal to sender.
+		/// - `freeze`: if set to `true`, will freeze the index so it cannot be transferred.
+		///
+		/// Emits `IndexAssigned` if successful.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::force_transfer())]
+		pub fn force_transfer(
+			origin: OriginFor<T>,
+			new: AccountIdLookupOf<T>,
+			index: T::AccountIndex,
+			freeze: bool,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let new = T::Lookup::lookup(new)?;
+
+			Accounts::<T>::mutate(index, |maybe_value| {
+				if let Some((account, amount, _)) = maybe_value.take() {
+					T::Currency::unreserve(&account, amount);
+				}
+				*maybe_value = Some((new.clone(), Zero::zero(), freeze));
+			});
+			Self::deposit_event(Event::IndexAssigned { who: new, index });
+			Ok(())
+		}
+
+		/// Freeze an index so it will always point to the sender account. This consumes the
+		/// deposit.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the signing account must have a
+		/// non-frozen account `index`.
+		///
+		/// - `index`: the index to be frozen in place.
+		///
+		/// Emits `IndexFrozen` if successful.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::freeze())]
+		pub fn freeze(origin: OriginFor<T>, index: T::AccountIndex) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			Accounts::<T>::try_mutate(index, |maybe_value| -> DispatchResult {
+				let (account, amount, perm) = maybe_value.take().ok_or(Error::<T>::NotAssigned)?;
+				ensure!(!perm, Error::<T>::Permanent);
+				ensure!(account == who, Error::<T>::NotOwner);
+				T::Currency::slash_reserved(&who, amount);
+				*maybe_value = Some((account, Zero::zero(), true));
+				Ok(())
+			})?;
+			Self::deposit_event(Event::IndexFrozen { index, who });
+			Ok(())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A account index was assigned.
+		IndexAssigned { who: T::AccountId, index: T::AccountIndex },
+		/// A account index has been freed up (unassigned).
+		IndexFreed { index: T::AccountIndex },
+		/// A account index has been frozen to its current account ID.
+		IndexFrozen { index: T::AccountIndex, who: T::AccountId },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The index was not already assigned.
+		NotAssigned,
+		/// The index is assigned to another account.
+		NotOwner,
+		/// The index was not available.
+		InUse,
+		/// The source and destination accounts are identical.
+		NotTransfer,
+		/// The index is permanent and may not be freed/changed.
+		Permanent,
+	}
+
+	/// The lookup from index to account.
+	#[pallet::storage]
+	pub type Accounts<T: Config> =
+		StorageMap<_, Blake2_128Concat, T::AccountIndex, (T::AccountId, BalanceOf<T>, bool)>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub indices: Vec<(T::AccountIndex, T::AccountId)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			for (a, b) in &self.indices {
+				<Accounts<T>>::insert(a, (b, <BalanceOf<T>>::zero(), false))
+			}
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	// PUBLIC IMMUTABLES
+
+	/// Lookup an T::AccountIndex to get an Id, if there's one there.
+	pub fn lookup_index(index: T::AccountIndex) -> Option<T::AccountId> {
+		Accounts::<T>::get(index).map(|x| x.0)
+	}
+
+	/// Lookup an address to get an Id, if there's one there.
+	pub fn lookup_address(a: MultiAddress<T::AccountId, T::AccountIndex>) -> Option<T::AccountId> {
+		match a {
+			MultiAddress::Id(i) => Some(i),
+			MultiAddress::Index(i) => Self::lookup_index(i),
+			_ => None,
+		}
+	}
+}
+
+impl<T: Config> StaticLookup for Pallet<T> {
+	type Source = MultiAddress<T::AccountId, T::AccountIndex>;
+	type Target = T::AccountId;
+
+	fn lookup(a: Self::Source) -> Result<Self::Target, LookupError> {
+		Self::lookup_address(a).ok_or(LookupError)
+	}
+
+	fn unlookup(a: Self::Target) -> Self::Source {
+		MultiAddress::Id(a)
+	}
+}
diff --git a/substrate/frame/indices/src/mock.rs b/substrate/frame/indices/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d63081e0b73f8d3425f0a017cb7544705065d433
--- /dev/null
+++ b/substrate/frame/indices/src/mock.rs
@@ -0,0 +1,96 @@
+// 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.
+
+//! Test utilities
+
+#![cfg(test)]
+
+use crate::{self as pallet_indices, Config};
+use frame_support::traits::{ConstU32, ConstU64};
+use sp_core::H256;
+use sp_runtime::BuildStorage;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Indices: pallet_indices::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+);
+
+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>;
+}
+
+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 MaxHolds = ();
+}
+
+impl Config for Test {
+	type AccountIndex = u64;
+	type Currency = Balances;
+	type Deposit = ConstU64<1>;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
diff --git a/substrate/frame/indices/src/tests.rs b/substrate/frame/indices/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..56b1019000389e18834e11bdf5b43d1fef5adbd0
--- /dev/null
+++ b/substrate/frame/indices/src/tests.rs
@@ -0,0 +1,121 @@
+// 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 the module.
+
+#![cfg(test)]
+
+use super::{mock::*, *};
+use frame_support::{assert_noop, assert_ok};
+use pallet_balances::Error as BalancesError;
+use sp_runtime::MultiAddress::Id;
+
+#[test]
+fn claiming_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Indices::claim(Some(0).into(), 0),
+			BalancesError::<Test, _>::InsufficientBalance
+		);
+		assert_ok!(Indices::claim(Some(1).into(), 0));
+		assert_noop!(Indices::claim(Some(2).into(), 0), Error::<Test>::InUse);
+		assert_eq!(Balances::reserved_balance(1), 1);
+	});
+}
+
+#[test]
+fn freeing_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Indices::claim(Some(1).into(), 0));
+		assert_ok!(Indices::claim(Some(2).into(), 1));
+		assert_noop!(Indices::free(Some(0).into(), 0), Error::<Test>::NotOwner);
+		assert_noop!(Indices::free(Some(1).into(), 1), Error::<Test>::NotOwner);
+		assert_noop!(Indices::free(Some(1).into(), 2), Error::<Test>::NotAssigned);
+		assert_ok!(Indices::free(Some(1).into(), 0));
+		assert_eq!(Balances::reserved_balance(1), 0);
+		assert_noop!(Indices::free(Some(1).into(), 0), Error::<Test>::NotAssigned);
+	});
+}
+
+#[test]
+fn freezing_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Indices::claim(Some(1).into(), 0));
+		assert_noop!(Indices::freeze(Some(1).into(), 1), Error::<Test>::NotAssigned);
+		assert_noop!(Indices::freeze(Some(2).into(), 0), Error::<Test>::NotOwner);
+		assert_ok!(Indices::freeze(Some(1).into(), 0));
+		assert_noop!(Indices::freeze(Some(1).into(), 0), Error::<Test>::Permanent);
+
+		assert_noop!(Indices::free(Some(1).into(), 0), Error::<Test>::Permanent);
+		assert_noop!(Indices::transfer(Some(1).into(), Id(2), 0), Error::<Test>::Permanent);
+	});
+}
+
+#[test]
+fn indexing_lookup_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Indices::claim(Some(1).into(), 0));
+		assert_ok!(Indices::claim(Some(2).into(), 1));
+		assert_eq!(Indices::lookup_index(0), Some(1));
+		assert_eq!(Indices::lookup_index(1), Some(2));
+		assert_eq!(Indices::lookup_index(2), None);
+	});
+}
+
+#[test]
+fn reclaim_index_on_accounts_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Indices::claim(Some(1).into(), 0));
+		assert_ok!(Indices::free(Some(1).into(), 0));
+		assert_ok!(Indices::claim(Some(2).into(), 0));
+		assert_eq!(Indices::lookup_index(0), Some(2));
+		assert_eq!(Balances::reserved_balance(2), 1);
+	});
+}
+
+#[test]
+fn transfer_index_on_accounts_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Indices::claim(Some(1).into(), 0));
+		assert_noop!(Indices::transfer(Some(1).into(), Id(2), 1), Error::<Test>::NotAssigned);
+		assert_noop!(Indices::transfer(Some(2).into(), Id(3), 0), Error::<Test>::NotOwner);
+		assert_ok!(Indices::transfer(Some(1).into(), Id(3), 0));
+		assert_eq!(Balances::reserved_balance(1), 0);
+		assert_eq!(Balances::reserved_balance(3), 1);
+		assert_eq!(Indices::lookup_index(0), Some(3));
+	});
+}
+
+#[test]
+fn force_transfer_index_on_preowned_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Indices::claim(Some(1).into(), 0));
+		assert_ok!(Indices::force_transfer(RuntimeOrigin::root(), Id(3), 0, false));
+		assert_eq!(Balances::reserved_balance(1), 0);
+		assert_eq!(Balances::reserved_balance(3), 0);
+		assert_eq!(Indices::lookup_index(0), Some(3));
+	});
+}
+
+#[test]
+fn force_transfer_index_on_free_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Indices::force_transfer(RuntimeOrigin::root(), Id(3), 0, false));
+		assert_eq!(Balances::reserved_balance(3), 0);
+		assert_eq!(Indices::lookup_index(0), Some(3));
+	});
+}
diff --git a/substrate/frame/indices/src/weights.rs b/substrate/frame/indices/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d081cc738b1dbe6c1991b30ccb454307e4ca19ab
--- /dev/null
+++ b/substrate/frame/indices/src/weights.rs
@@ -0,0 +1,187 @@
+// 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.
+
+//! Autogenerated weights for pallet_indices
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_indices
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/indices/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_indices.
+pub trait WeightInfo {
+	fn claim() -> Weight;
+	fn transfer() -> Weight;
+	fn free() -> Weight;
+	fn force_transfer() -> Weight;
+	fn freeze() -> Weight;
+}
+
+/// Weights for pallet_indices using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn claim() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3534`
+		// Minimum execution time: 25_491_000 picoseconds.
+		Weight::from_parts(26_456_000, 3534)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `275`
+		//  Estimated: `3593`
+		// Minimum execution time: 38_027_000 picoseconds.
+		Weight::from_parts(38_749_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn free() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `172`
+		//  Estimated: `3534`
+		// Minimum execution time: 26_652_000 picoseconds.
+		Weight::from_parts(27_273_000, 3534)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `275`
+		//  Estimated: `3593`
+		// Minimum execution time: 29_464_000 picoseconds.
+		Weight::from_parts(30_959_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn freeze() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `172`
+		//  Estimated: `3534`
+		// Minimum execution time: 29_015_000 picoseconds.
+		Weight::from_parts(29_714_000, 3534)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn claim() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3534`
+		// Minimum execution time: 25_491_000 picoseconds.
+		Weight::from_parts(26_456_000, 3534)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `275`
+		//  Estimated: `3593`
+		// Minimum execution time: 38_027_000 picoseconds.
+		Weight::from_parts(38_749_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn free() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `172`
+		//  Estimated: `3534`
+		// Minimum execution time: 26_652_000 picoseconds.
+		Weight::from_parts(27_273_000, 3534)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn force_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `275`
+		//  Estimated: `3593`
+		// Minimum execution time: 29_464_000 picoseconds.
+		Weight::from_parts(30_959_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Indices Accounts (r:1 w:1)
+	/// Proof: Indices Accounts (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn freeze() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `172`
+		//  Estimated: `3534`
+		// Minimum execution time: 29_015_000 picoseconds.
+		Weight::from_parts(29_714_000, 3534)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/insecure-randomness-collective-flip/Cargo.toml b/substrate/frame/insecure-randomness-collective-flip/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6676dac91527dc3793dd621630f29f63819647a6
--- /dev/null
+++ b/substrate/frame/insecure-randomness-collective-flip/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "pallet-insecure-randomness-collective-flip"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Insecure do not use in production: FRAME randomness collective flip pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+safe-mix = { version = "1.0", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"safe-mix/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/insecure-randomness-collective-flip/README.md b/substrate/frame/insecure-randomness-collective-flip/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ef02e4b5c8445132be938e7b84dddc845551b49e
--- /dev/null
+++ b/substrate/frame/insecure-randomness-collective-flip/README.md
@@ -0,0 +1,52 @@
+# DO NOT USE IN PRODUCTION
+
+The produced values do not fulfill the cryptographic requirements for random numbers. Should not be used for high-stake production use-cases.
+
+# Randomness Module
+
+The Randomness Collective Flip module provides a [`random`](https://docs.rs/pallet-insecure-randomness-collective-flip/latest/pallet_insecure_randomness_collective_flip/struct.Module.html#method.random)
+function that generates low-influence random values based on the block hashes from the previous
+`81` blocks. Low-influence randomness can be useful when defending against relatively weak
+adversaries. Using this pallet as a randomness source is advisable primarily in low-security
+situations like testing.
+
+## Public Functions
+
+See the [`Module`](https://docs.rs/pallet-insecure-randomness-collective-flip/latest/pallet_insecure_randomness_collective_flip/struct.Module.html) struct for details of publicly available functions.
+
+## Usage
+
+### Prerequisites
+
+Import the Randomness Collective Flip module and derive your module's configuration trait from
+the system trait.
+
+### Example - Get random seed for the current block
+
+```rust
+use frame_support::traits::Randomness;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config + pallet_insecure_randomness_collective_flip::Config {}
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::weight(0)]
+        pub fn random_module_example(origin: OriginFor<T>) -> DispatchResult {
+            let _random_value = <pallet_insecure_randomness_collective_flip::Pallet<T>>::random(&b"my context"[..]);
+            Ok(())
+        }
+    }
+}
+```
+
+License: Apache-2.0
diff --git a/substrate/frame/insecure-randomness-collective-flip/src/lib.rs b/substrate/frame/insecure-randomness-collective-flip/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..474087777c46e42e61a099de3721859d314e6624
--- /dev/null
+++ b/substrate/frame/insecure-randomness-collective-flip/src/lib.rs
@@ -0,0 +1,306 @@
+// 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.
+
+//! # DO NOT USE IN PRODUCTION
+//!
+//! The produced values do not fulfill the cryptographic requirements for random numbers.
+//! Should not be used for high-stake production use-cases.
+//!
+//! # Randomness Pallet
+//!
+//! The Randomness Collective Flip pallet provides a [`random`](./struct.Module.html#method.random)
+//! function that generates low-influence random values based on the block hashes from the previous
+//! `81` blocks. Low-influence randomness can be useful when defending against relatively weak
+//! adversaries. Using this pallet as a randomness source is advisable primarily in low-security
+//! situations like testing.
+//!
+//! ## Public Functions
+//!
+//! See the [`Module`] struct for details of publicly available functions.
+//!
+//! ## Usage
+//!
+//! ### Prerequisites
+//!
+//! Import the Randomness Collective Flip pallet and derive your pallet's configuration trait from
+//! the system trait.
+//!
+//! ### Example - Get random seed for the current block
+//!
+//! ```
+//! use frame_support::traits::Randomness;
+//!
+//! #[frame_support::pallet]
+//! pub mod pallet {
+//!     use super::*;
+//!     use frame_support::pallet_prelude::*;
+//!     use frame_system::pallet_prelude::*;
+//!
+//!     #[pallet::pallet]
+//!     pub struct Pallet<T>(_);
+//!
+//!     #[pallet::config]
+//!     pub trait Config: frame_system::Config + pallet_insecure_randomness_collective_flip::Config {}
+//!
+//!     #[pallet::call]
+//!     impl<T: Config> Pallet<T> {
+//!         #[pallet::weight(0)]
+//!         pub fn random_module_example(origin: OriginFor<T>) -> DispatchResult {
+//!             let _random_value = <pallet_insecure_randomness_collective_flip::Pallet<T>>::random(&b"my context"[..]);
+//!             Ok(())
+//!         }
+//!     }
+//! }
+//! # fn main() { }
+//! ```
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use safe_mix::TripletMix;
+
+use codec::Encode;
+use frame_support::{pallet_prelude::Weight, traits::Randomness};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_runtime::traits::{Hash, Saturating};
+
+const RANDOM_MATERIAL_LEN: u32 = 81;
+
+fn block_number_to_index<T: Config>(block_number: BlockNumberFor<T>) -> usize {
+	// on_initialize is called on the first block after genesis
+	let index = (block_number - 1u32.into()) % RANDOM_MATERIAL_LEN.into();
+	index.try_into().ok().expect("Something % 81 is always smaller than usize; qed")
+}
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(block_number: BlockNumberFor<T>) -> Weight {
+			let parent_hash = <frame_system::Pallet<T>>::parent_hash();
+
+			<RandomMaterial<T>>::mutate(|ref mut values| {
+				if values.try_push(parent_hash).is_err() {
+					let index = block_number_to_index::<T>(block_number);
+					values[index] = parent_hash;
+				}
+			});
+
+			T::DbWeight::get().reads_writes(1, 1)
+		}
+	}
+
+	/// Series of block headers from the last 81 blocks that acts as random seed material. This
+	/// is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of
+	/// the oldest hash.
+	#[pallet::storage]
+	#[pallet::getter(fn random_material)]
+	pub(super) type RandomMaterial<T: Config> =
+		StorageValue<_, BoundedVec<T::Hash, ConstU32<RANDOM_MATERIAL_LEN>>, ValueQuery>;
+}
+
+impl<T: Config> Randomness<T::Hash, BlockNumberFor<T>> for Pallet<T> {
+	/// This randomness uses a low-influence function, drawing upon the block hashes from the
+	/// previous 81 blocks. Its result for any given subject will be known far in advance by anyone
+	/// observing the chain. Any block producer has significant influence over their block hashes
+	/// bounded only by their computational resources. Our low-influence function reduces the actual
+	/// block producer's influence over the randomness, but increases the influence of small
+	/// colluding groups of recent block producers.
+	///
+	/// WARNING: Hashing the result of this function will remove any low-influence properties it has
+	/// and mean that all bits of the resulting value are entirely manipulatable by the author of
+	/// the parent block, who can determine the value of `parent_hash`.
+	fn random(subject: &[u8]) -> (T::Hash, BlockNumberFor<T>) {
+		let block_number = <frame_system::Pallet<T>>::block_number();
+		let index = block_number_to_index::<T>(block_number);
+
+		let hash_series = <RandomMaterial<T>>::get();
+		let seed = if !hash_series.is_empty() {
+			// Always the case after block 1 is initialized.
+			hash_series
+				.iter()
+				.cycle()
+				.skip(index)
+				.take(RANDOM_MATERIAL_LEN as usize)
+				.enumerate()
+				.map(|(i, h)| (i as i8, subject, h).using_encoded(T::Hashing::hash))
+				.triplet_mix()
+		} else {
+			T::Hash::default()
+		};
+
+		(seed, block_number.saturating_sub(RANDOM_MATERIAL_LEN.into()))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate as pallet_insecure_randomness_collective_flip;
+
+	use sp_core::H256;
+	use sp_runtime::{
+		traits::{BlakeTwo256, Header as _, IdentityLookup},
+		BuildStorage,
+	};
+
+	use frame_support::{
+		parameter_types,
+		traits::{ConstU32, ConstU64, OnInitialize, Randomness},
+	};
+	use frame_system::limits;
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+			CollectiveFlip: pallet_insecure_randomness_collective_flip::{Pallet, Storage},
+		}
+	);
+
+	parameter_types! {
+		pub BlockLength: limits::BlockLength = limits::BlockLength
+			::max(2 * 1024);
+	}
+
+	impl frame_system::Config for Test {
+		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 pallet_insecure_randomness_collective_flip::Config for Test {}
+
+	fn new_test_ext() -> sp_io::TestExternalities {
+		let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		t.into()
+	}
+
+	#[test]
+	fn test_block_number_to_index() {
+		for i in 1..1000 {
+			assert_eq!((i - 1) as usize % 81, block_number_to_index::<Test>(i));
+		}
+	}
+
+	fn setup_blocks(blocks: u64) {
+		let mut parent_hash = System::parent_hash();
+
+		for i in 1..(blocks + 1) {
+			System::reset_events();
+			System::initialize(&i, &parent_hash, &Default::default());
+			CollectiveFlip::on_initialize(i);
+
+			let header = System::finalize();
+			parent_hash = header.hash();
+			System::set_block_number(*header.number());
+		}
+	}
+
+	#[test]
+	fn test_random_material_partial() {
+		new_test_ext().execute_with(|| {
+			let genesis_hash = System::parent_hash();
+
+			setup_blocks(38);
+
+			let random_material = CollectiveFlip::random_material();
+
+			assert_eq!(random_material.len(), 38);
+			assert_eq!(random_material[0], genesis_hash);
+		});
+	}
+
+	#[test]
+	fn test_random_material_filled() {
+		new_test_ext().execute_with(|| {
+			let genesis_hash = System::parent_hash();
+
+			setup_blocks(81);
+
+			let random_material = CollectiveFlip::random_material();
+
+			assert_eq!(random_material.len(), 81);
+			assert_ne!(random_material[0], random_material[1]);
+			assert_eq!(random_material[0], genesis_hash);
+		});
+	}
+
+	#[test]
+	fn test_random_material_filled_twice() {
+		new_test_ext().execute_with(|| {
+			let genesis_hash = System::parent_hash();
+
+			setup_blocks(162);
+
+			let random_material = CollectiveFlip::random_material();
+
+			assert_eq!(random_material.len(), 81);
+			assert_ne!(random_material[0], random_material[1]);
+			assert_ne!(random_material[0], genesis_hash);
+		});
+	}
+
+	#[test]
+	fn test_random() {
+		new_test_ext().execute_with(|| {
+			setup_blocks(162);
+
+			assert_eq!(System::block_number(), 162);
+			assert_eq!(CollectiveFlip::random_seed(), CollectiveFlip::random_seed());
+			assert_ne!(CollectiveFlip::random(b"random_1"), CollectiveFlip::random(b"random_2"));
+
+			let (random, known_since) = CollectiveFlip::random_seed();
+
+			assert_eq!(known_since, 162 - RANDOM_MATERIAL_LEN as u64);
+			assert_ne!(random, H256::zero());
+			assert!(!CollectiveFlip::random_material().contains(&random));
+		});
+	}
+}
diff --git a/substrate/frame/lottery/Cargo.toml b/substrate/frame/lottery/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..85503edaee45c3fed03b8c3b44b2f6238a327f97
--- /dev/null
+++ b/substrate/frame/lottery/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-lottery"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME Participation Lottery Pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+frame-support-test = { version = "3.0.0", path = "../support/test" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support-test/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support-test/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/lottery/src/benchmarking.rs b/substrate/frame/lottery/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1510d250dbeaf6814a35f1262f08ba727b340ee2
--- /dev/null
+++ b/substrate/frame/lottery/src/benchmarking.rs
@@ -0,0 +1,218 @@
+// 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.
+
+//! Lottery pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use crate::Pallet as Lottery;
+use frame_benchmarking::{
+	impl_benchmark_test_suite,
+	v1::{account, whitelisted_caller, BenchmarkError},
+	v2::*,
+};
+use frame_support::{
+	storage::bounded_vec::BoundedVec,
+	traits::{EnsureOrigin, OnInitialize},
+};
+use frame_system::RawOrigin;
+use sp_runtime::traits::{Bounded, Zero};
+
+// Set up and start a lottery
+fn setup_lottery<T: Config>(repeat: bool) -> Result<(), &'static str> {
+	let price = T::Currency::minimum_balance();
+	let length = 10u32.into();
+	let delay = 5u32.into();
+	// Calls will be maximum length...
+	let mut calls = vec![
+		frame_system::Call::<T>::set_code { code: vec![] }.into();
+		T::MaxCalls::get().saturating_sub(1) as usize
+	];
+	// Last call will be the match for worst case scenario.
+	calls.push(frame_system::Call::<T>::remark { remark: vec![] }.into());
+	let origin = T::ManagerOrigin::try_successful_origin()
+		.expect("ManagerOrigin has no successful origin required for the benchmark");
+	Lottery::<T>::set_calls(origin.clone(), calls)?;
+	Lottery::<T>::start_lottery(origin, price, length, delay, repeat)?;
+	Ok(())
+}
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn buy_ticket() -> Result<(), BenchmarkError> {
+		let caller = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		setup_lottery::<T>(false)?;
+		// force user to have a long vec of calls participating
+		let set_code_index: CallIndex = Lottery::<T>::call_to_index(
+			&frame_system::Call::<T>::set_code { code: vec![] }.into(),
+		)?;
+		let already_called: (u32, BoundedVec<CallIndex, T::MaxCalls>) = (
+			LotteryIndex::<T>::get(),
+			BoundedVec::<CallIndex, T::MaxCalls>::try_from(vec![
+				set_code_index;
+				T::MaxCalls::get().saturating_sub(1)
+					as usize
+			])
+			.unwrap(),
+		);
+		Participants::<T>::insert(&caller, already_called);
+
+		let call = frame_system::Call::<T>::remark { remark: vec![] };
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), Box::new(call.into()));
+
+		assert_eq!(TicketsCount::<T>::get(), 1);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn set_calls(n: Linear<0, { T::MaxCalls::get() }>) -> Result<(), BenchmarkError> {
+		let calls = vec![frame_system::Call::<T>::remark { remark: vec![] }.into(); n as usize];
+		let origin =
+			T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		assert!(CallIndices::<T>::get().is_empty());
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, calls);
+
+		if !n.is_zero() {
+			assert!(!CallIndices::<T>::get().is_empty());
+		}
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn start_lottery() -> Result<(), BenchmarkError> {
+		let price = BalanceOf::<T>::max_value();
+		let end = 10u32.into();
+		let payout = 5u32.into();
+		let origin =
+			T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, price, end, payout, true);
+
+		assert!(crate::Lottery::<T>::get().is_some());
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn stop_repeat() -> Result<(), BenchmarkError> {
+		setup_lottery::<T>(true)?;
+		assert_eq!(crate::Lottery::<T>::get().unwrap().repeat, true);
+		let origin =
+			T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin);
+
+		assert_eq!(crate::Lottery::<T>::get().unwrap().repeat, false);
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn on_initialize_end() -> Result<(), BenchmarkError> {
+		setup_lottery::<T>(false)?;
+		let winner = account("winner", 0, 0);
+		// User needs more than min balance to get ticket
+		T::Currency::make_free_balance_be(&winner, T::Currency::minimum_balance() * 10u32.into());
+		// Make sure lottery account has at least min balance too
+		let lottery_account = Lottery::<T>::account_id();
+		T::Currency::make_free_balance_be(
+			&lottery_account,
+			T::Currency::minimum_balance() * 10u32.into(),
+		);
+		// Buy a ticket
+		let call = frame_system::Call::<T>::remark { remark: vec![] };
+		Lottery::<T>::buy_ticket(RawOrigin::Signed(winner.clone()).into(), Box::new(call.into()))?;
+		// Kill user account for worst case
+		T::Currency::make_free_balance_be(&winner, 0u32.into());
+		// Assert that lotto is set up for winner
+		assert_eq!(TicketsCount::<T>::get(), 1);
+		assert!(!Lottery::<T>::pot().1.is_zero());
+
+		#[block]
+		{
+			// Generate `MaxGenerateRandom` numbers for worst case scenario
+			for i in 0..T::MaxGenerateRandom::get() {
+				Lottery::<T>::generate_random_number(i);
+			}
+			// Start lottery has block 15 configured for payout
+			Lottery::<T>::on_initialize(15u32.into());
+		}
+
+		assert!(crate::Lottery::<T>::get().is_none());
+		assert_eq!(TicketsCount::<T>::get(), 0);
+		assert_eq!(Lottery::<T>::pot().1, 0u32.into());
+		assert!(!T::Currency::free_balance(&winner).is_zero());
+
+		Ok(())
+	}
+
+	#[benchmark]
+	fn on_initialize_repeat() -> Result<(), BenchmarkError> {
+		setup_lottery::<T>(true)?;
+		let winner = account("winner", 0, 0);
+		// User needs more than min balance to get ticket
+		T::Currency::make_free_balance_be(&winner, T::Currency::minimum_balance() * 10u32.into());
+		// Make sure lottery account has at least min balance too
+		let lottery_account = Lottery::<T>::account_id();
+		T::Currency::make_free_balance_be(
+			&lottery_account,
+			T::Currency::minimum_balance() * 10u32.into(),
+		);
+		// Buy a ticket
+		let call = frame_system::Call::<T>::remark { remark: vec![] };
+		Lottery::<T>::buy_ticket(RawOrigin::Signed(winner.clone()).into(), Box::new(call.into()))?;
+		// Kill user account for worst case
+		T::Currency::make_free_balance_be(&winner, 0u32.into());
+		// Assert that lotto is set up for winner
+		assert_eq!(TicketsCount::<T>::get(), 1);
+		assert!(!Lottery::<T>::pot().1.is_zero());
+
+		#[block]
+		{
+			// Generate `MaxGenerateRandom` numbers for worst case scenario
+			for i in 0..T::MaxGenerateRandom::get() {
+				Lottery::<T>::generate_random_number(i);
+			}
+			// Start lottery has block 15 configured for payout
+			Lottery::<T>::on_initialize(15u32.into());
+		}
+
+		assert!(crate::Lottery::<T>::get().is_some());
+		assert_eq!(LotteryIndex::<T>::get(), 2);
+		assert_eq!(TicketsCount::<T>::get(), 0);
+		assert_eq!(Lottery::<T>::pot().1, 0u32.into());
+		assert!(!T::Currency::free_balance(&winner).is_zero());
+
+		Ok(())
+	}
+
+	impl_benchmark_test_suite!(Lottery, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/lottery/src/lib.rs b/substrate/frame/lottery/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c9c0254042424c7d5b46b386e942c9ed662250b7
--- /dev/null
+++ b/substrate/frame/lottery/src/lib.rs
@@ -0,0 +1,521 @@
+// 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 lottery pallet that uses participation in the network to purchase tickets.
+//!
+//! With this pallet, you can configure a lottery, which is a pot of money that
+//! users contribute to, and that is reallocated to a single user at the end of
+//! the lottery period. Just like a normal lottery system, to participate, you
+//! need to "buy a ticket", which is used to fund the pot.
+//!
+//! The unique feature of this lottery system is that tickets can only be
+//! purchased by making a "valid call" dispatched through this pallet.
+//! By configuring certain calls to be valid for the lottery, you can encourage
+//! users to make those calls on your network. An example of how this could be
+//! used is to set validator nominations as a valid lottery call. If the lottery
+//! is set to repeat every month, then users would be encouraged to re-nominate
+//! validators every month. A user can only purchase one ticket per valid call
+//! per lottery.
+//!
+//! This pallet can be configured to use dynamically set calls or statically set
+//! calls. Call validation happens through the `ValidateCall` implementation.
+//! This pallet provides one implementation of this using the `CallIndices`
+//! storage item. You can also make your own implementation at the runtime level
+//! which can contain much more complex logic, such as validation of the
+//! parameters, which this pallet alone cannot do.
+//!
+//! This pallet uses the modulus operator to pick a random winner. It is known
+//! that this might introduce a bias if the random number chosen in a range that
+//! is not perfectly divisible by the total number of participants. The
+//! `MaxGenerateRandom` configuration can help mitigate this by generating new
+//! numbers until we hit the limit or we find a "fair" number. This is best
+//! effort only.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{DispatchResult, Dispatchable, GetDispatchInfo},
+	ensure,
+	pallet_prelude::MaxEncodedLen,
+	storage::bounded_vec::BoundedVec,
+	traits::{Currency, ExistenceRequirement::KeepAlive, Get, Randomness, ReservableCurrency},
+	PalletId,
+};
+pub use pallet::*;
+use sp_runtime::{
+	traits::{AccountIdConversion, Saturating, Zero},
+	ArithmeticError, DispatchError, RuntimeDebug,
+};
+use sp_std::prelude::*;
+pub use weights::WeightInfo;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+// Any runtime call can be encoded into two bytes which represent the pallet and call index.
+// We use this to uniquely match someone's incoming call with the calls configured for the lottery.
+type CallIndex = (u8, u8);
+
+#[derive(
+	Encode, Decode, Default, Eq, PartialEq, RuntimeDebug, scale_info::TypeInfo, MaxEncodedLen,
+)]
+pub struct LotteryConfig<BlockNumber, Balance> {
+	/// Price per entry.
+	price: Balance,
+	/// Starting block of the lottery.
+	start: BlockNumber,
+	/// Length of the lottery (start + length = end).
+	length: BlockNumber,
+	/// Delay for choosing the winner of the lottery. (start + length + delay = payout).
+	/// Randomness in the "payout" block will be used to determine the winner.
+	delay: BlockNumber,
+	/// Whether this lottery will repeat after it completes.
+	repeat: bool,
+}
+
+pub trait ValidateCall<T: Config> {
+	fn validate_call(call: &<T as Config>::RuntimeCall) -> bool;
+}
+
+impl<T: Config> ValidateCall<T> for () {
+	fn validate_call(_: &<T as Config>::RuntimeCall) -> bool {
+		false
+	}
+}
+
+impl<T: Config> ValidateCall<T> for Pallet<T> {
+	fn validate_call(call: &<T as Config>::RuntimeCall) -> bool {
+		let valid_calls = CallIndices::<T>::get();
+		let call_index = match Self::call_to_index(call) {
+			Ok(call_index) => call_index,
+			Err(_) => return false,
+		};
+		valid_calls.iter().any(|c| call_index == *c)
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// The pallet's config trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The Lottery's pallet id
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// A dispatchable call.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ GetDispatchInfo
+			+ From<frame_system::Call<Self>>;
+
+		/// The currency trait.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// Something that provides randomness in the runtime.
+		type Randomness: Randomness<Self::Hash, BlockNumberFor<Self>>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The manager origin.
+		type ManagerOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The max number of calls available in a single lottery.
+		#[pallet::constant]
+		type MaxCalls: Get<u32>;
+
+		/// Used to determine if a call would be valid for purchasing a ticket.
+		///
+		/// Be conscious of the implementation used here. We assume at worst that
+		/// a vector of `MaxCalls` indices are queried for any call validation.
+		/// You may need to provide a custom benchmark if this assumption is broken.
+		type ValidateCall: ValidateCall<Self>;
+
+		/// Number of time we should try to generate a random number that has no modulo bias.
+		/// The larger this number, the more potential computation is used for picking the winner,
+		/// but also the more likely that the chosen winner is done fairly.
+		#[pallet::constant]
+		type MaxGenerateRandom: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A lottery has been started!
+		LotteryStarted,
+		/// A new set of calls have been set!
+		CallsUpdated,
+		/// A winner has been chosen!
+		Winner { winner: T::AccountId, lottery_balance: BalanceOf<T> },
+		/// A ticket has been bought!
+		TicketBought { who: T::AccountId, call_index: CallIndex },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// A lottery has not been configured.
+		NotConfigured,
+		/// A lottery is already in progress.
+		InProgress,
+		/// A lottery has already ended.
+		AlreadyEnded,
+		/// The call is not valid for an open lottery.
+		InvalidCall,
+		/// You are already participating in the lottery with this call.
+		AlreadyParticipating,
+		/// Too many calls for a single lottery.
+		TooManyCalls,
+		/// Failed to encode calls
+		EncodingFailed,
+	}
+
+	#[pallet::storage]
+	pub(crate) type LotteryIndex<T> = StorageValue<_, u32, ValueQuery>;
+
+	/// The configuration for the current lottery.
+	#[pallet::storage]
+	pub(crate) type Lottery<T: Config> =
+		StorageValue<_, LotteryConfig<BlockNumberFor<T>, BalanceOf<T>>>;
+
+	/// Users who have purchased a ticket. (Lottery Index, Tickets Purchased)
+	#[pallet::storage]
+	pub(crate) type Participants<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		(u32, BoundedVec<CallIndex, T::MaxCalls>),
+		ValueQuery,
+	>;
+
+	/// Total number of tickets sold.
+	#[pallet::storage]
+	pub(crate) type TicketsCount<T> = StorageValue<_, u32, ValueQuery>;
+
+	/// Each ticket's owner.
+	///
+	/// May have residual storage from previous lotteries. Use `TicketsCount` to see which ones
+	/// are actually valid ticket mappings.
+	#[pallet::storage]
+	pub(crate) type Tickets<T: Config> = StorageMap<_, Twox64Concat, u32, T::AccountId>;
+
+	/// The calls stored in this pallet to be used in an active lottery if configured
+	/// by `Config::ValidateCall`.
+	#[pallet::storage]
+	pub(crate) type CallIndices<T: Config> =
+		StorageValue<_, BoundedVec<CallIndex, T::MaxCalls>, ValueQuery>;
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+			Lottery::<T>::mutate(|mut lottery| -> Weight {
+				if let Some(config) = &mut lottery {
+					let payout_block =
+						config.start.saturating_add(config.length).saturating_add(config.delay);
+					if payout_block <= n {
+						let (lottery_account, lottery_balance) = Self::pot();
+
+						let winner = Self::choose_account().unwrap_or(lottery_account);
+						// Not much we can do if this fails...
+						let res = T::Currency::transfer(
+							&Self::account_id(),
+							&winner,
+							lottery_balance,
+							KeepAlive,
+						);
+						debug_assert!(res.is_ok());
+
+						Self::deposit_event(Event::<T>::Winner { winner, lottery_balance });
+
+						TicketsCount::<T>::kill();
+
+						if config.repeat {
+							// If lottery should repeat, increment index by 1.
+							LotteryIndex::<T>::mutate(|index| *index = index.saturating_add(1));
+							// Set a new start with the current block.
+							config.start = n;
+							return T::WeightInfo::on_initialize_repeat()
+						} else {
+							// Else, kill the lottery storage.
+							*lottery = None;
+							return T::WeightInfo::on_initialize_end()
+						}
+						// We choose not need to kill Participants and Tickets to avoid a large
+						// number of writes at one time. Instead, data persists between lotteries,
+						// but is not used if it is not relevant.
+					}
+				}
+				T::DbWeight::get().reads(1)
+			})
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Buy a ticket to enter the lottery.
+		///
+		/// This extrinsic acts as a passthrough function for `call`. In all
+		/// situations where `call` alone would succeed, this extrinsic should
+		/// succeed.
+		///
+		/// If `call` is successful, then we will attempt to purchase a ticket,
+		/// which may fail silently. To detect success of a ticket purchase, you
+		/// should listen for the `TicketBought` event.
+		///
+		/// This extrinsic must be called by a signed origin.
+		#[pallet::call_index(0)]
+		#[pallet::weight(
+			T::WeightInfo::buy_ticket()
+				.saturating_add(call.get_dispatch_info().weight)
+		)]
+		pub fn buy_ticket(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			let caller = ensure_signed(origin.clone())?;
+			call.clone().dispatch(origin).map_err(|e| e.error)?;
+
+			let _ = Self::do_buy_ticket(&caller, &call);
+			Ok(())
+		}
+
+		/// Set calls in storage which can be used to purchase a lottery ticket.
+		///
+		/// This function only matters if you use the `ValidateCall` implementation
+		/// provided by this pallet, which uses storage to determine the valid calls.
+		///
+		/// This extrinsic must be called by the Manager origin.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::set_calls(calls.len() as u32))]
+		pub fn set_calls(
+			origin: OriginFor<T>,
+			calls: Vec<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			T::ManagerOrigin::ensure_origin(origin)?;
+			ensure!(calls.len() <= T::MaxCalls::get() as usize, Error::<T>::TooManyCalls);
+			if calls.is_empty() {
+				CallIndices::<T>::kill();
+			} else {
+				let indices = Self::calls_to_indices(&calls)?;
+				CallIndices::<T>::put(indices);
+			}
+			Self::deposit_event(Event::<T>::CallsUpdated);
+			Ok(())
+		}
+
+		/// Start a lottery using the provided configuration.
+		///
+		/// This extrinsic must be called by the `ManagerOrigin`.
+		///
+		/// Parameters:
+		///
+		/// * `price`: The cost of a single ticket.
+		/// * `length`: How long the lottery should run for starting at the current block.
+		/// * `delay`: How long after the lottery end we should wait before picking a winner.
+		/// * `repeat`: If the lottery should repeat when completed.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::start_lottery())]
+		pub fn start_lottery(
+			origin: OriginFor<T>,
+			price: BalanceOf<T>,
+			length: BlockNumberFor<T>,
+			delay: BlockNumberFor<T>,
+			repeat: bool,
+		) -> DispatchResult {
+			T::ManagerOrigin::ensure_origin(origin)?;
+			Lottery::<T>::try_mutate(|lottery| -> DispatchResult {
+				ensure!(lottery.is_none(), Error::<T>::InProgress);
+				let index = LotteryIndex::<T>::get();
+				let new_index = index.checked_add(1).ok_or(ArithmeticError::Overflow)?;
+				let start = frame_system::Pallet::<T>::block_number();
+				// Use new_index to more easily track everything with the current state.
+				*lottery = Some(LotteryConfig { price, start, length, delay, repeat });
+				LotteryIndex::<T>::put(new_index);
+				Ok(())
+			})?;
+			// Make sure pot exists.
+			let lottery_account = Self::account_id();
+			if T::Currency::total_balance(&lottery_account).is_zero() {
+				T::Currency::deposit_creating(&lottery_account, T::Currency::minimum_balance());
+			}
+			Self::deposit_event(Event::<T>::LotteryStarted);
+			Ok(())
+		}
+
+		/// If a lottery is repeating, you can use this to stop the repeat.
+		/// The lottery will continue to run to completion.
+		///
+		/// This extrinsic must be called by the `ManagerOrigin`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::stop_repeat())]
+		pub fn stop_repeat(origin: OriginFor<T>) -> DispatchResult {
+			T::ManagerOrigin::ensure_origin(origin)?;
+			Lottery::<T>::mutate(|mut lottery| {
+				if let Some(config) = &mut lottery {
+					config.repeat = false
+				}
+			});
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// The account ID of the lottery pot.
+	///
+	/// This actually does computation. If you need to keep using it, then make sure you cache the
+	/// value and only call this once.
+	pub fn account_id() -> T::AccountId {
+		T::PalletId::get().into_account_truncating()
+	}
+
+	/// Return the pot account and amount of money in the pot.
+	/// The existential deposit is not part of the pot so lottery account never gets deleted.
+	fn pot() -> (T::AccountId, BalanceOf<T>) {
+		let account_id = Self::account_id();
+		let balance =
+			T::Currency::free_balance(&account_id).saturating_sub(T::Currency::minimum_balance());
+
+		(account_id, balance)
+	}
+
+	/// Converts a vector of calls into a vector of call indices.
+	fn calls_to_indices(
+		calls: &[<T as Config>::RuntimeCall],
+	) -> Result<BoundedVec<CallIndex, T::MaxCalls>, DispatchError> {
+		let mut indices = BoundedVec::<CallIndex, T::MaxCalls>::with_bounded_capacity(calls.len());
+		for c in calls.iter() {
+			let index = Self::call_to_index(c)?;
+			indices.try_push(index).map_err(|_| Error::<T>::TooManyCalls)?;
+		}
+		Ok(indices)
+	}
+
+	/// Convert a call to it's call index by encoding the call and taking the first two bytes.
+	fn call_to_index(call: &<T as Config>::RuntimeCall) -> Result<CallIndex, DispatchError> {
+		let encoded_call = call.encode();
+		if encoded_call.len() < 2 {
+			return Err(Error::<T>::EncodingFailed.into())
+		}
+		Ok((encoded_call[0], encoded_call[1]))
+	}
+
+	/// Logic for buying a ticket.
+	fn do_buy_ticket(caller: &T::AccountId, call: &<T as Config>::RuntimeCall) -> DispatchResult {
+		// Check the call is valid lottery
+		let config = Lottery::<T>::get().ok_or(Error::<T>::NotConfigured)?;
+		let block_number = frame_system::Pallet::<T>::block_number();
+		ensure!(
+			block_number < config.start.saturating_add(config.length),
+			Error::<T>::AlreadyEnded
+		);
+		ensure!(T::ValidateCall::validate_call(call), Error::<T>::InvalidCall);
+		let call_index = Self::call_to_index(call)?;
+		let ticket_count = TicketsCount::<T>::get();
+		let new_ticket_count = ticket_count.checked_add(1).ok_or(ArithmeticError::Overflow)?;
+		// Try to update the participant status
+		Participants::<T>::try_mutate(
+			&caller,
+			|(lottery_index, participating_calls)| -> DispatchResult {
+				let index = LotteryIndex::<T>::get();
+				// If lottery index doesn't match, then reset participating calls and index.
+				if *lottery_index != index {
+					*participating_calls = Default::default();
+					*lottery_index = index;
+				} else {
+					// Check that user is not already participating under this call.
+					ensure!(
+						!participating_calls.iter().any(|c| call_index == *c),
+						Error::<T>::AlreadyParticipating
+					);
+				}
+				participating_calls.try_push(call_index).map_err(|_| Error::<T>::TooManyCalls)?;
+				// Check user has enough funds and send it to the Lottery account.
+				T::Currency::transfer(caller, &Self::account_id(), config.price, KeepAlive)?;
+				// Create a new ticket.
+				TicketsCount::<T>::put(new_ticket_count);
+				Tickets::<T>::insert(ticket_count, caller.clone());
+				Ok(())
+			},
+		)?;
+
+		Self::deposit_event(Event::<T>::TicketBought { who: caller.clone(), call_index });
+
+		Ok(())
+	}
+
+	/// Randomly choose a winning ticket and return the account that purchased it.
+	/// The more tickets an account bought, the higher are its chances of winning.
+	/// Returns `None` if there is no winner.
+	fn choose_account() -> Option<T::AccountId> {
+		match Self::choose_ticket(TicketsCount::<T>::get()) {
+			None => None,
+			Some(ticket) => Tickets::<T>::get(ticket),
+		}
+	}
+
+	/// Randomly choose a winning ticket from among the total number of tickets.
+	/// Returns `None` if there are no tickets.
+	fn choose_ticket(total: u32) -> Option<u32> {
+		if total == 0 {
+			return None
+		}
+		let mut random_number = Self::generate_random_number(0);
+
+		// Best effort attempt to remove bias from modulus operator.
+		for i in 1..T::MaxGenerateRandom::get() {
+			if random_number < u32::MAX - u32::MAX % total {
+				break
+			}
+
+			random_number = Self::generate_random_number(i);
+		}
+
+		Some(random_number % total)
+	}
+
+	/// Generate a random number from a given seed.
+	/// Note that there is potential bias introduced by using modulus operator.
+	/// You should call this function with different seed values until the random
+	/// number lies within `u32::MAX - u32::MAX % n`.
+	/// TODO: deal with randomness freshness
+	/// https://github.com/paritytech/substrate/issues/8311
+	fn generate_random_number(seed: u32) -> u32 {
+		let (random_seed, _) = T::Randomness::random(&(T::PalletId::get(), seed).encode());
+		let random_number = <u32>::decode(&mut random_seed.as_ref())
+			.expect("secure hashes should always be bigger than u32; qed");
+		random_number
+	}
+}
diff --git a/substrate/frame/lottery/src/mock.rs b/substrate/frame/lottery/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aefb6a1cce2bfc7de0677513c0ef55217e4fdd8c
--- /dev/null
+++ b/substrate/frame/lottery/src/mock.rs
@@ -0,0 +1,133 @@
+// 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.
+
+//! Test utilities
+
+use super::*;
+use crate as pallet_lottery;
+
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64, OnFinalize, OnInitialize},
+};
+use frame_support_test::TestRandomness;
+use frame_system::EnsureRoot;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Lottery: pallet_lottery::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub const AvailableBlockRatio: Perbill = Perbill::one();
+}
+
+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 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>;
+}
+
+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 MaxHolds = ();
+}
+
+parameter_types! {
+	pub const LotteryPalletId: PalletId = PalletId(*b"py/lotto");
+}
+
+impl Config for Test {
+	type PalletId = LotteryPalletId;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type Randomness = TestRandomness<Self>;
+	type RuntimeEvent = RuntimeEvent;
+	type ManagerOrigin = EnsureRoot<u64>;
+	type MaxCalls = ConstU32<2>;
+	type ValidateCall = Lottery;
+	type MaxGenerateRandom = ConstU32<10>;
+	type WeightInfo = ();
+}
+
+pub type SystemCall = frame_system::Call<Test>;
+pub type BalancesCall = pallet_balances::Call<Test>;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 100), (2, 100), (3, 100), (4, 100), (5, 100)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
+
+/// Run until a particular block.
+pub fn run_to_block(n: u64) {
+	while System::block_number() < n {
+		if System::block_number() > 1 {
+			Lottery::on_finalize(System::block_number());
+			System::on_finalize(System::block_number());
+		}
+		System::set_block_number(System::block_number() + 1);
+		System::on_initialize(System::block_number());
+		Lottery::on_initialize(System::block_number());
+	}
+}
diff --git a/substrate/frame/lottery/src/tests.rs b/substrate/frame/lottery/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ae3a6c858f2426e2119f090a5c3e4f53b51a333b
--- /dev/null
+++ b/substrate/frame/lottery/src/tests.rs
@@ -0,0 +1,451 @@
+// 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 the module.
+
+use super::*;
+use frame_support::{assert_noop, assert_ok, assert_storage_noop};
+use mock::{
+	new_test_ext, run_to_block, Balances, BalancesCall, Lottery, RuntimeCall, RuntimeOrigin,
+	SystemCall, Test,
+};
+use sp_runtime::{traits::BadOrigin, TokenError};
+
+#[test]
+fn initial_state() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(Lottery::account_id()), 0);
+		assert!(crate::Lottery::<Test>::get().is_none());
+		assert_eq!(Participants::<Test>::get(&1), (0, Default::default()));
+		assert_eq!(TicketsCount::<Test>::get(), 0);
+		assert!(Tickets::<Test>::get(0).is_none());
+	});
+}
+
+#[test]
+fn basic_end_to_end_works() {
+	new_test_ext().execute_with(|| {
+		let price = 10;
+		let length = 20;
+		let delay = 5;
+		let calls = vec![
+			RuntimeCall::Balances(BalancesCall::force_transfer { source: 0, dest: 0, value: 0 }),
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 }),
+		];
+
+		// Set calls for the lottery
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
+
+		// Start lottery, it repeats
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, true));
+		assert!(crate::Lottery::<Test>::get().is_some());
+
+		assert_eq!(Balances::free_balance(&1), 100);
+		let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 2,
+			value: 20,
+		}));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
+		// 20 from the transfer, 10 from buying a ticket
+		assert_eq!(Balances::free_balance(&1), 100 - 20 - 10);
+		assert_eq!(Participants::<Test>::get(&1).1.len(), 1);
+		assert_eq!(TicketsCount::<Test>::get(), 1);
+		// 1 owns the 0 ticket
+		assert_eq!(Tickets::<Test>::get(0), Some(1));
+
+		// More ticket purchases
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), call.clone()));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(3), call.clone()));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(4), call.clone()));
+		assert_eq!(TicketsCount::<Test>::get(), 4);
+
+		// Go to end
+		run_to_block(20);
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(5), call.clone()));
+		// Ticket isn't bought
+		assert_eq!(TicketsCount::<Test>::get(), 4);
+
+		// Go to payout
+		run_to_block(25);
+		// User 1 wins
+		assert_eq!(Balances::free_balance(&1), 70 + 40);
+		// Lottery is reset and restarted
+		assert_eq!(TicketsCount::<Test>::get(), 0);
+		assert_eq!(LotteryIndex::<Test>::get(), 2);
+		assert_eq!(
+			crate::Lottery::<Test>::get().unwrap(),
+			LotteryConfig { price, start: 25, length, delay, repeat: true }
+		);
+	});
+}
+
+/// Only the manager can stop the Lottery from repeating via `stop_repeat`.
+#[test]
+fn stop_repeat_works() {
+	new_test_ext().execute_with(|| {
+		let price = 10;
+		let length = 20;
+		let delay = 5;
+
+		// Set no calls for the lottery.
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), vec![]));
+		// Start lottery, it repeats.
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, true));
+
+		// Non-manager fails to `stop_repeat`.
+		assert_noop!(Lottery::stop_repeat(RuntimeOrigin::signed(1)), DispatchError::BadOrigin);
+		// Manager can `stop_repeat`, even twice.
+		assert_ok!(Lottery::stop_repeat(RuntimeOrigin::root()));
+		assert_ok!(Lottery::stop_repeat(RuntimeOrigin::root()));
+
+		// Lottery still exists.
+		assert!(crate::Lottery::<Test>::get().is_some());
+		// End and pick a winner.
+		run_to_block(length + delay);
+
+		// Lottery stays dead and does not repeat.
+		assert!(crate::Lottery::<Test>::get().is_none());
+		run_to_block(length + delay + 1);
+		assert!(crate::Lottery::<Test>::get().is_none());
+	});
+}
+
+#[test]
+fn set_calls_works() {
+	new_test_ext().execute_with(|| {
+		assert!(!CallIndices::<Test>::exists());
+
+		let calls = vec![
+			RuntimeCall::Balances(BalancesCall::force_transfer { source: 0, dest: 0, value: 0 }),
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 }),
+		];
+
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
+		assert!(CallIndices::<Test>::exists());
+
+		let too_many_calls = vec![
+			RuntimeCall::Balances(BalancesCall::force_transfer { source: 0, dest: 0, value: 0 }),
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 }),
+			RuntimeCall::System(SystemCall::remark { remark: vec![] }),
+		];
+
+		assert_noop!(
+			Lottery::set_calls(RuntimeOrigin::root(), too_many_calls),
+			Error::<Test>::TooManyCalls,
+		);
+
+		// Clear calls
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), vec![]));
+		assert!(CallIndices::<Test>::get().is_empty());
+	});
+}
+
+#[test]
+fn call_to_indices_works() {
+	new_test_ext().execute_with(|| {
+		let calls = vec![
+			RuntimeCall::Balances(BalancesCall::force_transfer { source: 0, dest: 0, value: 0 }),
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 }),
+		];
+		let indices = Lottery::calls_to_indices(&calls).unwrap().into_inner();
+		// Only comparing the length since it is otherwise dependant on the API
+		// of `BalancesCall`.
+		assert_eq!(indices.len(), calls.len());
+
+		let too_many_calls = vec![
+			RuntimeCall::Balances(BalancesCall::force_transfer { source: 0, dest: 0, value: 0 }),
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 }),
+			RuntimeCall::System(SystemCall::remark { remark: vec![] }),
+		];
+		assert_noop!(Lottery::calls_to_indices(&too_many_calls), Error::<Test>::TooManyCalls);
+	});
+}
+
+#[test]
+fn start_lottery_works() {
+	new_test_ext().execute_with(|| {
+		let price = 10;
+		let length = 20;
+		let delay = 5;
+
+		// Setup ignores bad origin
+		assert_noop!(
+			Lottery::start_lottery(RuntimeOrigin::signed(1), price, length, delay, false),
+			BadOrigin,
+		);
+
+		// All good
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, false));
+
+		// Can't open another one if lottery is already present
+		assert_noop!(
+			Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, false),
+			Error::<Test>::InProgress,
+		);
+	});
+}
+
+#[test]
+fn buy_ticket_works_as_simple_passthrough() {
+	// This test checks that even if the user could not buy a ticket, that `buy_ticket` acts
+	// as a simple passthrough to the real call.
+	new_test_ext().execute_with(|| {
+		// No lottery set up
+		let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 2,
+			value: 20,
+		}));
+		// This is just a basic transfer then
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
+		assert_eq!(Balances::free_balance(&1), 100 - 20);
+		assert_eq!(TicketsCount::<Test>::get(), 0);
+
+		// Lottery is set up, but too expensive to enter, so `do_buy_ticket` fails.
+		let calls = vec![
+			RuntimeCall::Balances(BalancesCall::force_transfer { source: 0, dest: 0, value: 0 }),
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 }),
+		];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
+
+		// Ticket price of 60 would kill the user's account
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 60, 10, 5, false));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
+		assert_eq!(Balances::free_balance(&1), 100 - 20 - 20);
+		assert_eq!(TicketsCount::<Test>::get(), 0);
+
+		// If call would fail, the whole thing still fails the same
+		let fail_call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 2,
+			value: 1000,
+		}));
+		assert_noop!(
+			Lottery::buy_ticket(RuntimeOrigin::signed(1), fail_call),
+			ArithmeticError::Underflow,
+		);
+
+		let bad_origin_call = Box::new(RuntimeCall::Balances(BalancesCall::force_transfer {
+			source: 0,
+			dest: 0,
+			value: 0,
+		}));
+		assert_noop!(Lottery::buy_ticket(RuntimeOrigin::signed(1), bad_origin_call), BadOrigin,);
+
+		// User can call other txs, but doesn't get a ticket
+		let remark_call =
+			Box::new(RuntimeCall::System(SystemCall::remark { remark: b"hello, world!".to_vec() }));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), remark_call));
+		assert_eq!(TicketsCount::<Test>::get(), 0);
+
+		let successful_call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 2,
+			value: 1,
+		}));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), successful_call));
+		assert_eq!(TicketsCount::<Test>::get(), 1);
+	});
+}
+
+#[test]
+fn buy_ticket_works() {
+	new_test_ext().execute_with(|| {
+		// Set calls for the lottery.
+		let calls = vec![
+			RuntimeCall::System(SystemCall::remark { remark: vec![] }),
+			RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 }),
+		];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls));
+
+		// Can't buy ticket before start
+		let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 2,
+			value: 1,
+		}));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
+		assert_eq!(TicketsCount::<Test>::get(), 0);
+
+		// Start lottery
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 1, 20, 5, false));
+
+		// Go to start, buy ticket for transfer
+		run_to_block(5);
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call));
+		assert_eq!(TicketsCount::<Test>::get(), 1);
+
+		// Can't buy another of the same ticket (even if call is slightly changed)
+		let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 3,
+			value: 30,
+		}));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call));
+		assert_eq!(TicketsCount::<Test>::get(), 1);
+
+		// Buy ticket for remark
+		let call =
+			Box::new(RuntimeCall::System(SystemCall::remark { remark: b"hello, world!".to_vec() }));
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
+		assert_eq!(TicketsCount::<Test>::get(), 2);
+
+		// Go to end, can't buy tickets anymore
+		run_to_block(20);
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), call.clone()));
+		assert_eq!(TicketsCount::<Test>::get(), 2);
+
+		// Go to payout, can't buy tickets when there is no lottery open
+		run_to_block(25);
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(2), call.clone()));
+		assert_eq!(TicketsCount::<Test>::get(), 0);
+		assert_eq!(LotteryIndex::<Test>::get(), 1);
+	});
+}
+
+/// Test that `do_buy_ticket` returns an `AlreadyParticipating` error.
+/// Errors of `do_buy_ticket` are ignored by `buy_ticket`, therefore this white-box test.
+#[test]
+fn do_buy_ticket_already_participating() {
+	new_test_ext().execute_with(|| {
+		let calls =
+			vec![RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 })];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 1, 10, 10, false));
+
+		// Buying once works.
+		assert_ok!(Lottery::do_buy_ticket(&1, &calls[0]));
+		// Buying the same ticket again fails.
+		assert_noop!(Lottery::do_buy_ticket(&1, &calls[0]), Error::<Test>::AlreadyParticipating);
+	});
+}
+
+/// `buy_ticket` is a storage noop when called with the same ticket again.
+#[test]
+fn buy_ticket_already_participating() {
+	new_test_ext().execute_with(|| {
+		let calls =
+			vec![RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 })];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 1, 10, 10, false));
+
+		// Buying once works.
+		let call = Box::new(calls[0].clone());
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call.clone()));
+
+		// Buying the same ticket again returns Ok, but changes nothing.
+		assert_storage_noop!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call).unwrap());
+
+		// Exactly one ticket exists.
+		assert_eq!(TicketsCount::<Test>::get(), 1);
+	});
+}
+
+/// `buy_ticket` is a storage noop when called with insufficient balance.
+#[test]
+fn buy_ticket_insufficient_balance() {
+	new_test_ext().execute_with(|| {
+		let calls =
+			vec![RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 })];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
+		// Price set to 100.
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 100, 10, 10, false));
+		let call = Box::new(calls[0].clone());
+
+		// Buying a ticket returns Ok, but changes nothing.
+		assert_storage_noop!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call).unwrap());
+		assert!(TicketsCount::<Test>::get().is_zero());
+	});
+}
+
+#[test]
+fn do_buy_ticket_insufficient_balance() {
+	new_test_ext().execute_with(|| {
+		let calls =
+			vec![RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 })];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
+		// Price set to 101.
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 101, 10, 10, false));
+
+		// Buying fails with InsufficientBalance.
+		assert_noop!(Lottery::do_buy_ticket(&1, &calls[0]), TokenError::FundsUnavailable,);
+		assert!(TicketsCount::<Test>::get().is_zero());
+	});
+}
+
+#[test]
+fn do_buy_ticket_keep_alive() {
+	new_test_ext().execute_with(|| {
+		let calls =
+			vec![RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 })];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
+		// Price set to 100.
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 100, 10, 10, false));
+
+		assert_noop!(Lottery::do_buy_ticket(&1, &calls[0]), TokenError::NotExpendable);
+		assert!(TicketsCount::<Test>::get().is_zero());
+	});
+}
+
+/// The lottery handles the case that no one participated.
+#[test]
+fn no_participants_works() {
+	new_test_ext().execute_with(|| {
+		let length = 20;
+		let delay = 5;
+
+		// Set no calls for the lottery.
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), vec![]));
+		// Start lottery.
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 10, length, delay, false));
+
+		// End the lottery, no one wins.
+		run_to_block(length + delay);
+	});
+}
+
+#[test]
+fn start_lottery_will_create_account() {
+	new_test_ext().execute_with(|| {
+		let price = 10;
+		let length = 20;
+		let delay = 5;
+
+		assert_eq!(Balances::total_balance(&Lottery::account_id()), 0);
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), price, length, delay, false));
+		assert_eq!(Balances::total_balance(&Lottery::account_id()), 1);
+	});
+}
+
+#[test]
+fn choose_ticket_trivial_cases() {
+	new_test_ext().execute_with(|| {
+		assert!(Lottery::choose_ticket(0).is_none());
+		assert_eq!(Lottery::choose_ticket(1).unwrap(), 0);
+	});
+}
+
+#[test]
+fn choose_account_one_participant() {
+	new_test_ext().execute_with(|| {
+		let calls =
+			vec![RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 0, value: 0 })];
+		assert_ok!(Lottery::set_calls(RuntimeOrigin::root(), calls.clone()));
+		assert_ok!(Lottery::start_lottery(RuntimeOrigin::root(), 10, 10, 10, false));
+		let call = Box::new(calls[0].clone());
+
+		// Buy one ticket with account 1.
+		assert_ok!(Lottery::buy_ticket(RuntimeOrigin::signed(1), call));
+		// Account 1 is always the winner.
+		assert_eq!(Lottery::choose_account().unwrap(), 1);
+	});
+}
diff --git a/substrate/frame/lottery/src/weights.rs b/substrate/frame/lottery/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3b4e562375345befa93f431145a2aff776ec7517
--- /dev/null
+++ b/substrate/frame/lottery/src/weights.rs
@@ -0,0 +1,274 @@
+// 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.
+
+//! Autogenerated weights for pallet_lottery
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_lottery
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/lottery/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_lottery.
+pub trait WeightInfo {
+	fn buy_ticket() -> Weight;
+	fn set_calls(n: u32, ) -> Weight;
+	fn start_lottery() -> Weight;
+	fn stop_repeat() -> Weight;
+	fn on_initialize_end() -> Weight;
+	fn on_initialize_repeat() -> Weight;
+}
+
+/// Weights for pallet_lottery using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Lottery Lottery (r:1 w:0)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: Lottery CallIndices (r:1 w:0)
+	/// Proof: Lottery CallIndices (max_values: Some(1), max_size: Some(21), added: 516, mode: MaxEncodedLen)
+	/// Storage: Lottery TicketsCount (r:1 w:1)
+	/// Proof: Lottery TicketsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Lottery Participants (r:1 w:1)
+	/// Proof: Lottery Participants (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
+	/// Storage: Lottery LotteryIndex (r:1 w:0)
+	/// Proof: Lottery LotteryIndex (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)
+	/// Storage: Lottery Tickets (r:0 w:1)
+	/// Proof: Lottery Tickets (max_values: None, max_size: Some(44), added: 2519, mode: MaxEncodedLen)
+	fn buy_ticket() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `452`
+		//  Estimated: `3593`
+		// Minimum execution time: 60_298_000 picoseconds.
+		Weight::from_parts(62_058_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Lottery CallIndices (r:0 w:1)
+	/// Proof: Lottery CallIndices (max_values: Some(1), max_size: Some(21), added: 516, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 10]`.
+	fn set_calls(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_291_000 picoseconds.
+		Weight::from_parts(8_178_186, 0)
+			// Standard Error: 3_048
+			.saturating_add(Weight::from_parts(330_871, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: Lottery LotteryIndex (r:1 w:1)
+	/// Proof: Lottery LotteryIndex (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 start_lottery() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161`
+		//  Estimated: `3593`
+		// Minimum execution time: 36_741_000 picoseconds.
+		Weight::from_parts(38_288_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	fn stop_repeat() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `219`
+		//  Estimated: `1514`
+		// Minimum execution time: 7_270_000 picoseconds.
+		Weight::from_parts(7_578_000, 1514)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0)
+	/// Proof: RandomnessCollectiveFlip RandomMaterial (max_values: Some(1), max_size: Some(2594), added: 3089, mode: MaxEncodedLen)
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Lottery TicketsCount (r:1 w:1)
+	/// Proof: Lottery TicketsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Lottery Tickets (r:1 w:0)
+	/// Proof: Lottery Tickets (max_values: None, max_size: Some(44), added: 2519, mode: MaxEncodedLen)
+	fn on_initialize_end() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `558`
+		//  Estimated: `6196`
+		// Minimum execution time: 76_611_000 picoseconds.
+		Weight::from_parts(78_107_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0)
+	/// Proof: RandomnessCollectiveFlip RandomMaterial (max_values: Some(1), max_size: Some(2594), added: 3089, mode: MaxEncodedLen)
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Lottery TicketsCount (r:1 w:1)
+	/// Proof: Lottery TicketsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Lottery Tickets (r:1 w:0)
+	/// Proof: Lottery Tickets (max_values: None, max_size: Some(44), added: 2519, mode: MaxEncodedLen)
+	/// Storage: Lottery LotteryIndex (r:1 w:1)
+	/// Proof: Lottery LotteryIndex (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn on_initialize_repeat() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `558`
+		//  Estimated: `6196`
+		// Minimum execution time: 78_731_000 picoseconds.
+		Weight::from_parts(80_248_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Lottery Lottery (r:1 w:0)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: Lottery CallIndices (r:1 w:0)
+	/// Proof: Lottery CallIndices (max_values: Some(1), max_size: Some(21), added: 516, mode: MaxEncodedLen)
+	/// Storage: Lottery TicketsCount (r:1 w:1)
+	/// Proof: Lottery TicketsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Lottery Participants (r:1 w:1)
+	/// Proof: Lottery Participants (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
+	/// Storage: Lottery LotteryIndex (r:1 w:0)
+	/// Proof: Lottery LotteryIndex (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)
+	/// Storage: Lottery Tickets (r:0 w:1)
+	/// Proof: Lottery Tickets (max_values: None, max_size: Some(44), added: 2519, mode: MaxEncodedLen)
+	fn buy_ticket() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `452`
+		//  Estimated: `3593`
+		// Minimum execution time: 60_298_000 picoseconds.
+		Weight::from_parts(62_058_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Lottery CallIndices (r:0 w:1)
+	/// Proof: Lottery CallIndices (max_values: Some(1), max_size: Some(21), added: 516, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 10]`.
+	fn set_calls(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_291_000 picoseconds.
+		Weight::from_parts(8_178_186, 0)
+			// Standard Error: 3_048
+			.saturating_add(Weight::from_parts(330_871, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: Lottery LotteryIndex (r:1 w:1)
+	/// Proof: Lottery LotteryIndex (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 start_lottery() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161`
+		//  Estimated: `3593`
+		// Minimum execution time: 36_741_000 picoseconds.
+		Weight::from_parts(38_288_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	fn stop_repeat() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `219`
+		//  Estimated: `1514`
+		// Minimum execution time: 7_270_000 picoseconds.
+		Weight::from_parts(7_578_000, 1514)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0)
+	/// Proof: RandomnessCollectiveFlip RandomMaterial (max_values: Some(1), max_size: Some(2594), added: 3089, mode: MaxEncodedLen)
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Lottery TicketsCount (r:1 w:1)
+	/// Proof: Lottery TicketsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Lottery Tickets (r:1 w:0)
+	/// Proof: Lottery Tickets (max_values: None, max_size: Some(44), added: 2519, mode: MaxEncodedLen)
+	fn on_initialize_end() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `558`
+		//  Estimated: `6196`
+		// Minimum execution time: 76_611_000 picoseconds.
+		Weight::from_parts(78_107_000, 6196)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: RandomnessCollectiveFlip RandomMaterial (r:1 w:0)
+	/// Proof: RandomnessCollectiveFlip RandomMaterial (max_values: Some(1), max_size: Some(2594), added: 3089, mode: MaxEncodedLen)
+	/// Storage: Lottery Lottery (r:1 w:1)
+	/// Proof: Lottery Lottery (max_values: Some(1), max_size: Some(29), added: 524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Lottery TicketsCount (r:1 w:1)
+	/// Proof: Lottery TicketsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Lottery Tickets (r:1 w:0)
+	/// Proof: Lottery Tickets (max_values: None, max_size: Some(44), added: 2519, mode: MaxEncodedLen)
+	/// Storage: Lottery LotteryIndex (r:1 w:1)
+	/// Proof: Lottery LotteryIndex (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn on_initialize_repeat() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `558`
+		//  Estimated: `6196`
+		// Minimum execution time: 78_731_000 picoseconds.
+		Weight::from_parts(80_248_000, 6196)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+}
diff --git a/substrate/frame/membership/Cargo.toml b/substrate/frame/membership/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e2674cb64053bd84f61f8be221283219e4d91a70
--- /dev/null
+++ b/substrate/frame/membership/Cargo.toml
@@ -0,0 +1,51 @@
+[package]
+name = "pallet-membership"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME membership management pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core", features = ["serde"] }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/membership/README.md b/substrate/frame/membership/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3499a3f864e480f634de42cb4fc3eece1bc2ee51
--- /dev/null
+++ b/substrate/frame/membership/README.md
@@ -0,0 +1,6 @@
+# Membership Module
+
+Allows control of membership of a set of `AccountId`s, useful for managing membership of a
+collective. A prime member may be set.
+
+License: Apache-2.0
diff --git a/substrate/frame/membership/src/lib.rs b/substrate/frame/membership/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6fb61f0e491be1b507ef13a0b382741da882aa50
--- /dev/null
+++ b/substrate/frame/membership/src/lib.rs
@@ -0,0 +1,828 @@
+// 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.
+
+//! # Membership Module
+//!
+//! Allows control of membership of a set of `AccountId`s, useful for managing membership of a
+//! collective. A prime member may be set
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{
+	traits::{ChangeMembers, Contains, Get, InitializeMembers, SortedMembers},
+	BoundedVec,
+};
+use sp_runtime::traits::StaticLookup;
+use sp_std::prelude::*;
+
+pub mod migrations;
+pub mod weights;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+const LOG_TARGET: &str = "runtime::membership";
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Required origin for adding a member (though can always be Root).
+		type AddOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for removing a member (though can always be Root).
+		type RemoveOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for adding and removing a member in a single action.
+		type SwapOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for resetting membership.
+		type ResetOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for setting or resetting the prime member.
+		type PrimeOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The receiver of the signal for when the membership has been initialized. This happens
+		/// pre-genesis and will usually be the same as `MembershipChanged`. If you need to do
+		/// something different on initialization, then you can change this accordingly.
+		type MembershipInitialized: InitializeMembers<Self::AccountId>;
+
+		/// The receiver of the signal for when the membership has changed.
+		type MembershipChanged: ChangeMembers<Self::AccountId>;
+
+		/// The maximum number of members that this membership can have.
+		///
+		/// This is used for benchmarking. Re-run the benchmarks if this changes.
+		///
+		/// This is enforced in the code; the membership size can not exceed this limit.
+		type MaxMembers: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// The current membership, stored as an ordered Vec.
+	#[pallet::storage]
+	#[pallet::getter(fn members)]
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<T::AccountId, T::MaxMembers>, ValueQuery>;
+
+	/// The current prime member, if one exists.
+	#[pallet::storage]
+	#[pallet::getter(fn prime)]
+	pub type Prime<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub members: BoundedVec<T::AccountId, T::MaxMembers>,
+		#[serde(skip)]
+		pub phantom: PhantomData<I>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			use sp_std::collections::btree_set::BTreeSet;
+			let members_set: BTreeSet<_> = self.members.iter().collect();
+			assert_eq!(
+				members_set.len(),
+				self.members.len(),
+				"Members cannot contain duplicate accounts."
+			);
+
+			let mut members = self.members.clone();
+			members.sort();
+			T::MembershipInitialized::initialize_members(&members);
+			<Members<T, I>>::put(members);
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// The given member was added; see the transaction for who.
+		MemberAdded,
+		/// The given member was removed; see the transaction for who.
+		MemberRemoved,
+		/// Two members were swapped; see the transaction for who.
+		MembersSwapped,
+		/// The membership was reset; see the transaction for who the new set is.
+		MembersReset,
+		/// One of the members' keys changed.
+		KeyChanged,
+		/// Phantom member, never used.
+		Dummy { _phantom_data: PhantomData<(T::AccountId, <T as Config<I>>::RuntimeEvent)> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Already a member.
+		AlreadyMember,
+		/// Not a member.
+		NotMember,
+		/// Too many members.
+		TooManyMembers,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Add a member `who` to the set.
+		///
+		/// May only be called from `T::AddOrigin`.
+		#[pallet::call_index(0)]
+		#[pallet::weight({50_000_000})]
+		pub fn add_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			T::AddOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+
+			let mut members = <Members<T, I>>::get();
+			let location = members.binary_search(&who).err().ok_or(Error::<T, I>::AlreadyMember)?;
+			members
+				.try_insert(location, who.clone())
+				.map_err(|_| Error::<T, I>::TooManyMembers)?;
+
+			<Members<T, I>>::put(&members);
+
+			T::MembershipChanged::change_members_sorted(&[who], &[], &members[..]);
+
+			Self::deposit_event(Event::MemberAdded);
+			Ok(())
+		}
+
+		/// Remove a member `who` from the set.
+		///
+		/// May only be called from `T::RemoveOrigin`.
+		#[pallet::call_index(1)]
+		#[pallet::weight({50_000_000})]
+		pub fn remove_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			T::RemoveOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+
+			let mut members = <Members<T, I>>::get();
+			let location = members.binary_search(&who).ok().ok_or(Error::<T, I>::NotMember)?;
+			members.remove(location);
+
+			<Members<T, I>>::put(&members);
+
+			T::MembershipChanged::change_members_sorted(&[], &[who], &members[..]);
+			Self::rejig_prime(&members);
+
+			Self::deposit_event(Event::MemberRemoved);
+			Ok(())
+		}
+
+		/// Swap out one member `remove` for another `add`.
+		///
+		/// May only be called from `T::SwapOrigin`.
+		///
+		/// Prime membership is *not* passed from `remove` to `add`, if extant.
+		#[pallet::call_index(2)]
+		#[pallet::weight({50_000_000})]
+		pub fn swap_member(
+			origin: OriginFor<T>,
+			remove: AccountIdLookupOf<T>,
+			add: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			T::SwapOrigin::ensure_origin(origin)?;
+			let remove = T::Lookup::lookup(remove)?;
+			let add = T::Lookup::lookup(add)?;
+
+			if remove == add {
+				return Ok(())
+			}
+
+			let mut members = <Members<T, I>>::get();
+			let location = members.binary_search(&remove).ok().ok_or(Error::<T, I>::NotMember)?;
+			let _ = members.binary_search(&add).err().ok_or(Error::<T, I>::AlreadyMember)?;
+			members[location] = add.clone();
+			members.sort();
+
+			<Members<T, I>>::put(&members);
+
+			T::MembershipChanged::change_members_sorted(&[add], &[remove], &members[..]);
+			Self::rejig_prime(&members);
+
+			Self::deposit_event(Event::MembersSwapped);
+			Ok(())
+		}
+
+		/// Change the membership to a new set, disregarding the existing membership. Be nice and
+		/// pass `members` pre-sorted.
+		///
+		/// May only be called from `T::ResetOrigin`.
+		#[pallet::call_index(3)]
+		#[pallet::weight({50_000_000})]
+		pub fn reset_members(origin: OriginFor<T>, members: Vec<T::AccountId>) -> DispatchResult {
+			T::ResetOrigin::ensure_origin(origin)?;
+
+			let mut members: BoundedVec<T::AccountId, T::MaxMembers> =
+				BoundedVec::try_from(members).map_err(|_| Error::<T, I>::TooManyMembers)?;
+			members.sort();
+			<Members<T, I>>::mutate(|m| {
+				T::MembershipChanged::set_members_sorted(&members[..], m);
+				Self::rejig_prime(&members);
+				*m = members;
+			});
+
+			Self::deposit_event(Event::MembersReset);
+			Ok(())
+		}
+
+		/// Swap out the sending member for some other key `new`.
+		///
+		/// May only be called from `Signed` origin of a current member.
+		///
+		/// Prime membership is passed from the origin account to `new`, if extant.
+		#[pallet::call_index(4)]
+		#[pallet::weight({50_000_000})]
+		pub fn change_key(origin: OriginFor<T>, new: AccountIdLookupOf<T>) -> DispatchResult {
+			let remove = ensure_signed(origin)?;
+			let new = T::Lookup::lookup(new)?;
+
+			if remove != new {
+				let mut members = <Members<T, I>>::get();
+				let location =
+					members.binary_search(&remove).ok().ok_or(Error::<T, I>::NotMember)?;
+				let _ = members.binary_search(&new).err().ok_or(Error::<T, I>::AlreadyMember)?;
+				members[location] = new.clone();
+				members.sort();
+
+				<Members<T, I>>::put(&members);
+
+				T::MembershipChanged::change_members_sorted(
+					&[new.clone()],
+					&[remove.clone()],
+					&members[..],
+				);
+
+				if Prime::<T, I>::get() == Some(remove) {
+					Prime::<T, I>::put(&new);
+					T::MembershipChanged::set_prime(Some(new));
+				}
+			}
+
+			Self::deposit_event(Event::KeyChanged);
+			Ok(())
+		}
+
+		/// Set the prime member. Must be a current member.
+		///
+		/// May only be called from `T::PrimeOrigin`.
+		#[pallet::call_index(5)]
+		#[pallet::weight({50_000_000})]
+		pub fn set_prime(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			T::PrimeOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			Self::members().binary_search(&who).ok().ok_or(Error::<T, I>::NotMember)?;
+			Prime::<T, I>::put(&who);
+			T::MembershipChanged::set_prime(Some(who));
+			Ok(())
+		}
+
+		/// Remove the prime member if it exists.
+		///
+		/// May only be called from `T::PrimeOrigin`.
+		#[pallet::call_index(6)]
+		#[pallet::weight({50_000_000})]
+		pub fn clear_prime(origin: OriginFor<T>) -> DispatchResult {
+			T::PrimeOrigin::ensure_origin(origin)?;
+			Prime::<T, I>::kill();
+			T::MembershipChanged::set_prime(None);
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	fn rejig_prime(members: &[T::AccountId]) {
+		if let Some(prime) = Prime::<T, I>::get() {
+			match members.binary_search(&prime) {
+				Ok(_) => T::MembershipChanged::set_prime(Some(prime)),
+				Err(_) => Prime::<T, I>::kill(),
+			}
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Contains<T::AccountId> for Pallet<T, I> {
+	fn contains(t: &T::AccountId) -> bool {
+		Self::members().binary_search(t).is_ok()
+	}
+}
+
+impl<T: Config<I>, I: 'static> SortedMembers<T::AccountId> for Pallet<T, I> {
+	fn sorted_members() -> Vec<T::AccountId> {
+		Self::members().to_vec()
+	}
+
+	fn count() -> usize {
+		Members::<T, I>::decode_len().unwrap_or(0)
+	}
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmark {
+	use super::{Pallet as Membership, *};
+	use frame_benchmarking::v1::{account, benchmarks_instance_pallet, whitelist, BenchmarkError};
+	use frame_support::{assert_ok, traits::EnsureOrigin};
+	use frame_system::RawOrigin;
+
+	const SEED: u32 = 0;
+
+	fn set_members<T: Config<I>, I: 'static>(members: Vec<T::AccountId>, prime: Option<usize>) {
+		let reset_origin = T::ResetOrigin::try_successful_origin()
+			.expect("ResetOrigin has no successful origin required for the benchmark");
+		let prime_origin = T::PrimeOrigin::try_successful_origin()
+			.expect("PrimeOrigin has no successful origin required for the benchmark");
+
+		assert_ok!(<Membership<T, I>>::reset_members(reset_origin, members.clone()));
+		if let Some(prime) = prime.map(|i| members[i].clone()) {
+			let prime_lookup = T::Lookup::unlookup(prime);
+			assert_ok!(<Membership<T, I>>::set_prime(prime_origin, prime_lookup));
+		} else {
+			assert_ok!(<Membership<T, I>>::clear_prime(prime_origin));
+		}
+	}
+
+	benchmarks_instance_pallet! {
+		add_member {
+			let m in 1 .. (T::MaxMembers::get() - 1);
+
+			let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+			set_members::<T, I>(members, None);
+			let new_member = account::<T::AccountId>("add", m, SEED);
+			let new_member_lookup = T::Lookup::unlookup(new_member.clone());
+		}: {
+			assert_ok!(<Membership<T, I>>::add_member(
+				T::AddOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+				new_member_lookup,
+			));
+		} verify {
+			assert!(<Members<T, I>>::get().contains(&new_member));
+			#[cfg(test)] crate::tests::clean();
+		}
+
+		// the case of no prime or the prime being removed is surely cheaper than the case of
+		// reporting a new prime via `MembershipChanged`.
+		remove_member {
+			let m in 2 .. T::MaxMembers::get();
+
+			let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+			set_members::<T, I>(members.clone(), Some(members.len() - 1));
+
+			let to_remove = members.first().cloned().unwrap();
+			let to_remove_lookup = T::Lookup::unlookup(to_remove.clone());
+		}: {
+			assert_ok!(<Membership<T, I>>::remove_member(
+				T::RemoveOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+				to_remove_lookup,
+			));
+		} verify {
+			assert!(!<Members<T, I>>::get().contains(&to_remove));
+			// prime is rejigged
+			assert!(<Prime<T, I>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
+			#[cfg(test)] crate::tests::clean();
+		}
+
+		// we remove a non-prime to make sure it needs to be set again.
+		swap_member {
+			let m in 2 .. T::MaxMembers::get();
+
+			let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+			set_members::<T, I>(members.clone(), Some(members.len() - 1));
+			let add = account::<T::AccountId>("member", m, SEED);
+			let add_lookup = T::Lookup::unlookup(add.clone());
+			let remove = members.first().cloned().unwrap();
+			let remove_lookup = T::Lookup::unlookup(remove.clone());
+		}: {
+			assert_ok!(<Membership<T, I>>::swap_member(
+				T::SwapOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+				remove_lookup,
+				add_lookup,
+			));
+		} verify {
+			assert!(!<Members<T, I>>::get().contains(&remove));
+			assert!(<Members<T, I>>::get().contains(&add));
+			// prime is rejigged
+			assert!(<Prime<T, I>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
+			#[cfg(test)] crate::tests::clean();
+		}
+
+		// er keep the prime common between incoming and outgoing to make sure it is rejigged.
+		reset_member {
+			let m in 1 .. T::MaxMembers::get();
+
+			let members = (1..m+1).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+			set_members::<T, I>(members.clone(), Some(members.len() - 1));
+			let mut new_members = (m..2*m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+		}: {
+			assert_ok!(<Membership<T, I>>::reset_members(
+				T::ResetOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+				new_members.clone(),
+			));
+		} verify {
+			new_members.sort();
+			assert_eq!(<Members<T, I>>::get(), new_members);
+			// prime is rejigged
+			assert!(<Prime<T, I>>::get().is_some() && T::MembershipChanged::get_prime().is_some());
+			#[cfg(test)] crate::tests::clean();
+		}
+
+		change_key {
+			let m in 1 .. T::MaxMembers::get();
+
+			// worse case would be to change the prime
+			let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+			let prime = members.last().cloned().unwrap();
+			set_members::<T, I>(members.clone(), Some(members.len() - 1));
+
+			let add = account::<T::AccountId>("member", m, SEED);
+			let add_lookup = T::Lookup::unlookup(add.clone());
+			whitelist!(prime);
+		}: {
+			assert_ok!(<Membership<T, I>>::change_key(RawOrigin::Signed(prime.clone()).into(), add_lookup));
+		} verify {
+			assert!(!<Members<T, I>>::get().contains(&prime));
+			assert!(<Members<T, I>>::get().contains(&add));
+			// prime is rejigged
+			assert_eq!(<Prime<T, I>>::get().unwrap(), add);
+			#[cfg(test)] crate::tests::clean();
+		}
+
+		set_prime {
+			let m in 1 .. T::MaxMembers::get();
+			let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+			let prime = members.last().cloned().unwrap();
+			let prime_lookup = T::Lookup::unlookup(prime.clone());
+			set_members::<T, I>(members, None);
+		}: {
+			assert_ok!(<Membership<T, I>>::set_prime(
+				T::PrimeOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+				prime_lookup,
+			));
+		} verify {
+			assert!(<Prime<T, I>>::get().is_some());
+			assert!(<T::MembershipChanged>::get_prime().is_some());
+			#[cfg(test)] crate::tests::clean();
+		}
+
+		clear_prime {
+			let m in 1 .. T::MaxMembers::get();
+			let members = (0..m).map(|i| account("member", i, SEED)).collect::<Vec<T::AccountId>>();
+			let prime = members.last().cloned().unwrap();
+			set_members::<T, I>(members, None);
+		}: {
+			assert_ok!(<Membership<T, I>>::clear_prime(
+				T::PrimeOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+			));
+		} verify {
+			assert!(<Prime<T, I>>::get().is_none());
+			assert!(<T::MembershipChanged>::get_prime().is_none());
+			#[cfg(test)] crate::tests::clean();
+		}
+
+		impl_benchmark_test_suite!(Membership, crate::tests::new_bench_ext(), crate::tests::Test);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate as pallet_membership;
+
+	use sp_core::H256;
+	use sp_runtime::{
+		bounded_vec,
+		traits::{BadOrigin, BlakeTwo256, IdentityLookup},
+		BuildStorage,
+	};
+
+	use frame_support::{
+		assert_noop, assert_ok, ord_parameter_types, parameter_types,
+		traits::{ConstU32, ConstU64, StorageVersion},
+	};
+	use frame_system::EnsureSignedBy;
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+			Membership: pallet_membership::{Pallet, Call, Storage, Config<T>, Event<T>},
+		}
+	);
+
+	parameter_types! {
+		pub static Members: Vec<u64> = vec![];
+		pub static Prime: Option<u64> = None;
+	}
+
+	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 = 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>;
+	}
+	ord_parameter_types! {
+		pub const One: u64 = 1;
+		pub const Two: u64 = 2;
+		pub const Three: u64 = 3;
+		pub const Four: u64 = 4;
+		pub const Five: u64 = 5;
+	}
+
+	pub struct TestChangeMembers;
+	impl ChangeMembers<u64> for TestChangeMembers {
+		fn change_members_sorted(incoming: &[u64], outgoing: &[u64], new: &[u64]) {
+			let mut old_plus_incoming = Members::get();
+			old_plus_incoming.extend_from_slice(incoming);
+			old_plus_incoming.sort();
+			let mut new_plus_outgoing = new.to_vec();
+			new_plus_outgoing.extend_from_slice(outgoing);
+			new_plus_outgoing.sort();
+			assert_eq!(old_plus_incoming, new_plus_outgoing);
+
+			Members::set(new.to_vec());
+			Prime::set(None);
+		}
+		fn set_prime(who: Option<u64>) {
+			Prime::set(who);
+		}
+		fn get_prime() -> Option<u64> {
+			Prime::get()
+		}
+	}
+
+	impl InitializeMembers<u64> for TestChangeMembers {
+		fn initialize_members(members: &[u64]) {
+			MEMBERS.with(|m| *m.borrow_mut() = members.to_vec());
+		}
+	}
+
+	impl Config for Test {
+		type RuntimeEvent = RuntimeEvent;
+		type AddOrigin = EnsureSignedBy<One, u64>;
+		type RemoveOrigin = EnsureSignedBy<Two, u64>;
+		type SwapOrigin = EnsureSignedBy<Three, u64>;
+		type ResetOrigin = EnsureSignedBy<Four, u64>;
+		type PrimeOrigin = EnsureSignedBy<Five, u64>;
+		type MembershipInitialized = TestChangeMembers;
+		type MembershipChanged = TestChangeMembers;
+		type MaxMembers = ConstU32<10>;
+		type WeightInfo = ();
+	}
+
+	pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		// We use default for brevity, but you can configure as desired if needed.
+		pallet_membership::GenesisConfig::<Test> {
+			members: bounded_vec![10, 20, 30],
+			..Default::default()
+		}
+		.assimilate_storage(&mut t)
+		.unwrap();
+		t.into()
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	pub(crate) fn new_bench_ext() -> sp_io::TestExternalities {
+		frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	pub(crate) fn clean() {
+		Members::set(vec![]);
+		Prime::set(None);
+	}
+
+	#[test]
+	fn query_membership_works() {
+		new_test_ext().execute_with(|| {
+			assert_eq!(Membership::members(), vec![10, 20, 30]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), vec![10, 20, 30]);
+		});
+	}
+
+	#[test]
+	fn prime_member_works() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(Membership::set_prime(RuntimeOrigin::signed(4), 20), BadOrigin);
+			assert_noop!(
+				Membership::set_prime(RuntimeOrigin::signed(5), 15),
+				Error::<Test, _>::NotMember
+			);
+			assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+			assert_eq!(Membership::prime(), Some(20));
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+
+			assert_ok!(Membership::clear_prime(RuntimeOrigin::signed(5)));
+			assert_eq!(Membership::prime(), None);
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+		});
+	}
+
+	#[test]
+	fn add_member_works() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(Membership::add_member(RuntimeOrigin::signed(5), 15), BadOrigin);
+			assert_noop!(
+				Membership::add_member(RuntimeOrigin::signed(1), 10),
+				Error::<Test, _>::AlreadyMember
+			);
+			assert_ok!(Membership::add_member(RuntimeOrigin::signed(1), 15));
+			assert_eq!(Membership::members(), vec![10, 15, 20, 30]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+		});
+	}
+
+	#[test]
+	fn remove_member_works() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(Membership::remove_member(RuntimeOrigin::signed(5), 20), BadOrigin);
+			assert_noop!(
+				Membership::remove_member(RuntimeOrigin::signed(2), 15),
+				Error::<Test, _>::NotMember
+			);
+			assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+			assert_ok!(Membership::remove_member(RuntimeOrigin::signed(2), 20));
+			assert_eq!(Membership::members(), vec![10, 30]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+			assert_eq!(Membership::prime(), None);
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+		});
+	}
+
+	#[test]
+	fn swap_member_works() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(Membership::swap_member(RuntimeOrigin::signed(5), 10, 25), BadOrigin);
+			assert_noop!(
+				Membership::swap_member(RuntimeOrigin::signed(3), 15, 25),
+				Error::<Test, _>::NotMember
+			);
+			assert_noop!(
+				Membership::swap_member(RuntimeOrigin::signed(3), 10, 30),
+				Error::<Test, _>::AlreadyMember
+			);
+
+			assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+			assert_ok!(Membership::swap_member(RuntimeOrigin::signed(3), 20, 20));
+			assert_eq!(Membership::members(), vec![10, 20, 30]);
+			assert_eq!(Membership::prime(), Some(20));
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+
+			assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 10));
+			assert_ok!(Membership::swap_member(RuntimeOrigin::signed(3), 10, 25));
+			assert_eq!(Membership::members(), vec![20, 25, 30]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+			assert_eq!(Membership::prime(), None);
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+		});
+	}
+
+	#[test]
+	fn swap_member_works_that_does_not_change_order() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Membership::swap_member(RuntimeOrigin::signed(3), 10, 5));
+			assert_eq!(Membership::members(), vec![5, 20, 30]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+		});
+	}
+
+	#[test]
+	fn change_key_works() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 10));
+			assert_noop!(
+				Membership::change_key(RuntimeOrigin::signed(3), 25),
+				Error::<Test, _>::NotMember
+			);
+			assert_noop!(
+				Membership::change_key(RuntimeOrigin::signed(10), 20),
+				Error::<Test, _>::AlreadyMember
+			);
+			assert_ok!(Membership::change_key(RuntimeOrigin::signed(10), 40));
+			assert_eq!(Membership::members(), vec![20, 30, 40]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+			assert_eq!(Membership::prime(), Some(40));
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+		});
+	}
+
+	#[test]
+	fn change_key_works_that_does_not_change_order() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Membership::change_key(RuntimeOrigin::signed(10), 5));
+			assert_eq!(Membership::members(), vec![5, 20, 30]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+		});
+	}
+
+	#[test]
+	fn reset_members_works() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Membership::set_prime(RuntimeOrigin::signed(5), 20));
+			assert_noop!(
+				Membership::reset_members(RuntimeOrigin::signed(1), bounded_vec![20, 40, 30]),
+				BadOrigin
+			);
+
+			assert_ok!(Membership::reset_members(RuntimeOrigin::signed(4), vec![20, 40, 30]));
+			assert_eq!(Membership::members(), vec![20, 30, 40]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+			assert_eq!(Membership::prime(), Some(20));
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+
+			assert_ok!(Membership::reset_members(RuntimeOrigin::signed(4), vec![10, 40, 30]));
+			assert_eq!(Membership::members(), vec![10, 30, 40]);
+			assert_eq!(MEMBERS.with(|m| m.borrow().clone()), Membership::members().to_vec());
+			assert_eq!(Membership::prime(), None);
+			assert_eq!(PRIME.with(|m| *m.borrow()), Membership::prime());
+		});
+	}
+
+	#[test]
+	#[should_panic(expected = "Members cannot contain duplicate accounts.")]
+	fn genesis_build_panics_with_duplicate_members() {
+		pallet_membership::GenesisConfig::<Test> {
+			members: bounded_vec![1, 2, 3, 1],
+			phantom: Default::default(),
+		}
+		.build_storage()
+		.unwrap();
+	}
+
+	#[test]
+	fn migration_v4() {
+		new_test_ext().execute_with(|| {
+			use frame_support::traits::PalletInfo;
+			let old_pallet_name = "OldMembership";
+			let new_pallet_name =
+				<Test as frame_system::Config>::PalletInfo::name::<Membership>().unwrap();
+
+			frame_support::storage::migration::move_pallet(
+				new_pallet_name.as_bytes(),
+				old_pallet_name.as_bytes(),
+			);
+
+			StorageVersion::new(0).put::<Membership>();
+
+			crate::migrations::v4::pre_migrate::<Membership, _>(old_pallet_name, new_pallet_name);
+			crate::migrations::v4::migrate::<Test, Membership, _>(old_pallet_name, new_pallet_name);
+			crate::migrations::v4::post_migrate::<Membership, _>(old_pallet_name, new_pallet_name);
+		});
+	}
+}
diff --git a/substrate/frame/membership/src/migrations/mod.rs b/substrate/frame/membership/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2487ed1d5da5220522fc3d3143fe4166411a1dec
--- /dev/null
+++ b/substrate/frame/membership/src/migrations/mod.rs
@@ -0,0 +1,19 @@
+// 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.
+
+/// Version 4.
+pub mod v4;
diff --git a/substrate/frame/membership/src/migrations/v4.rs b/substrate/frame/membership/src/migrations/v4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..38e97af51a09d150482559efcdd2e557cfa1307b
--- /dev/null
+++ b/substrate/frame/membership/src/migrations/v4.rs
@@ -0,0 +1,149 @@
+// 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::super::LOG_TARGET;
+use sp_io::hashing::twox_128;
+
+use frame_support::{
+	traits::{
+		Get, GetStorageVersion, PalletInfoAccess, StorageVersion,
+		STORAGE_VERSION_STORAGE_KEY_POSTFIX,
+	},
+	weights::Weight,
+};
+
+/// Migrate the entire storage of this pallet to a new prefix.
+///
+/// This new prefix must be the same as the one set in construct_runtime. For safety, use
+/// `PalletInfo` to get it, as:
+/// `<Runtime as frame_system::Config>::PalletInfo::name::<MembershipPallet>`.
+///
+/// The migration will look into the storage version in order not to trigger a migration on an up
+/// to date storage. Thus the on chain storage version must be less than 4 in order to trigger the
+/// migration.
+pub fn migrate<T: frame_system::Config, P: GetStorageVersion + PalletInfoAccess, N: AsRef<str>>(
+	old_pallet_name: N,
+	new_pallet_name: N,
+) -> Weight {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+
+	if new_pallet_name == old_pallet_name {
+		log::info!(
+			target: LOG_TARGET,
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return Weight::zero()
+	}
+
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration to v4 for membership with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 4 {
+		frame_support::storage::migration::move_pallet(
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", old_pallet_name, new_pallet_name);
+
+		StorageVersion::new(4).put::<P>();
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to v4 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::pre_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migrate<P: GetStorageVersion, N: AsRef<str>>(old_pallet_name: N, new_pallet_name: N) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+	log_migration("pre-migration", old_pallet_name, new_pallet_name);
+
+	if new_pallet_name == old_pallet_name {
+		return
+	}
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let storage_version_key = twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX);
+
+	let mut new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|key| Ok(key.to_vec()),
+	);
+
+	// Ensure nothing except maybe the storage_version_key is stored in the new prefix.
+	assert!(new_pallet_prefix_iter.all(|key| key == storage_version_key));
+
+	assert!(<P as GetStorageVersion>::on_chain_storage_version() < 4);
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migrate<P: GetStorageVersion, N: AsRef<str>>(old_pallet_name: N, new_pallet_name: N) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = new_pallet_name.as_ref();
+	log_migration("post-migration", old_pallet_name, new_pallet_name);
+
+	if new_pallet_name == old_pallet_name {
+		return
+	}
+
+	// Assert that nothing remains at the old prefix.
+	let old_pallet_prefix = twox_128(old_pallet_name.as_bytes());
+	let old_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		old_pallet_prefix.to_vec(),
+		old_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert_eq!(old_pallet_prefix_iter.count(), 0);
+
+	// NOTE: storage_version_key is already in the new prefix.
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert!(new_pallet_prefix_iter.count() >= 1);
+
+	assert_eq!(<P as GetStorageVersion>::on_chain_storage_version(), 4);
+}
+
+fn log_migration(stage: &str, old_pallet_name: &str, new_pallet_name: &str) {
+	log::info!(
+		target: LOG_TARGET,
+		"{}, prefix: '{}' ==> '{}'",
+		stage,
+		old_pallet_name,
+		new_pallet_name,
+	);
+}
diff --git a/substrate/frame/membership/src/weights.rs b/substrate/frame/membership/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..18ea7fcb315a3134747743f1a913856d084e5ad6
--- /dev/null
+++ b/substrate/frame/membership/src/weights.rs
@@ -0,0 +1,365 @@
+// 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.
+
+//! Autogenerated weights for pallet_membership
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_membership
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/membership/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_membership.
+pub trait WeightInfo {
+	fn add_member(m: u32, ) -> Weight;
+	fn remove_member(m: u32, ) -> Weight;
+	fn swap_member(m: u32, ) -> Weight;
+	fn reset_member(m: u32, ) -> Weight;
+	fn change_key(m: u32, ) -> Weight;
+	fn set_prime(m: u32, ) -> Weight;
+	fn clear_prime(m: u32, ) -> Weight;
+}
+
+/// Weights for pallet_membership using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 99]`.
+	fn add_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `208 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 17_040_000 picoseconds.
+		Weight::from_parts(18_344_571, 4687)
+			// Standard Error: 847
+			.saturating_add(Weight::from_parts(50_842, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:0)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[2, 100]`.
+	fn remove_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 20_088_000 picoseconds.
+		Weight::from_parts(21_271_384, 4687)
+			// Standard Error: 786
+			.saturating_add(Weight::from_parts(44_806, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:0)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[2, 100]`.
+	fn swap_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 20_308_000 picoseconds.
+		Weight::from_parts(21_469_843, 4687)
+			// Standard Error: 782
+			.saturating_add(Weight::from_parts(56_893, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:0)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn reset_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 19_464_000 picoseconds.
+		Weight::from_parts(21_223_702, 4687)
+			// Standard Error: 1_068
+			.saturating_add(Weight::from_parts(165_438, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:1)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn change_key(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 20_965_000 picoseconds.
+		Weight::from_parts(22_551_007, 4687)
+			// Standard Error: 860
+			.saturating_add(Weight::from_parts(52_397, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:0)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalMembership Prime (r:0 w:1)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn set_prime(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32 + m * (32 ±0)`
+		//  Estimated: `4687 + m * (32 ±0)`
+		// Minimum execution time: 7_481_000 picoseconds.
+		Weight::from_parts(7_959_053, 4687)
+			// Standard Error: 364
+			.saturating_add(Weight::from_parts(18_653, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Prime (r:0 w:1)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn clear_prime(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_373_000 picoseconds.
+		Weight::from_parts(3_750_452, 0)
+			// Standard Error: 142
+			.saturating_add(Weight::from_parts(505, 0).saturating_mul(m.into()))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 99]`.
+	fn add_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `208 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 17_040_000 picoseconds.
+		Weight::from_parts(18_344_571, 4687)
+			// Standard Error: 847
+			.saturating_add(Weight::from_parts(50_842, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:0)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[2, 100]`.
+	fn remove_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 20_088_000 picoseconds.
+		Weight::from_parts(21_271_384, 4687)
+			// Standard Error: 786
+			.saturating_add(Weight::from_parts(44_806, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:0)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[2, 100]`.
+	fn swap_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 20_308_000 picoseconds.
+		Weight::from_parts(21_469_843, 4687)
+			// Standard Error: 782
+			.saturating_add(Weight::from_parts(56_893, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:0)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn reset_member(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 19_464_000 picoseconds.
+		Weight::from_parts(21_223_702, 4687)
+			// Standard Error: 1_068
+			.saturating_add(Weight::from_parts(165_438, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:1)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Proposals (r:1 w:0)
+	/// Proof Skipped: TechnicalCommittee Proposals (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalMembership Prime (r:1 w:1)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Members (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn change_key(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312 + m * (64 ±0)`
+		//  Estimated: `4687 + m * (64 ±0)`
+		// Minimum execution time: 20_965_000 picoseconds.
+		Weight::from_parts(22_551_007, 4687)
+			// Standard Error: 860
+			.saturating_add(Weight::from_parts(52_397, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Members (r:1 w:0)
+	/// Proof: TechnicalMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen)
+	/// Storage: TechnicalMembership Prime (r:0 w:1)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn set_prime(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32 + m * (32 ±0)`
+		//  Estimated: `4687 + m * (32 ±0)`
+		// Minimum execution time: 7_481_000 picoseconds.
+		Weight::from_parts(7_959_053, 4687)
+			// Standard Error: 364
+			.saturating_add(Weight::from_parts(18_653, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into()))
+	}
+	/// Storage: TechnicalMembership Prime (r:0 w:1)
+	/// Proof: TechnicalMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TechnicalCommittee Prime (r:0 w:1)
+	/// Proof Skipped: TechnicalCommittee Prime (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `m` is `[1, 100]`.
+	fn clear_prime(m: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_373_000 picoseconds.
+		Weight::from_parts(3_750_452, 0)
+			// Standard Error: 142
+			.saturating_add(Weight::from_parts(505, 0).saturating_mul(m.into()))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/merkle-mountain-range/Cargo.toml b/substrate/frame/merkle-mountain-range/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..3496b84350d0fa4059a7a8907473e4ef4953f69c
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/Cargo.toml
@@ -0,0 +1,57 @@
+[package]
+name = "pallet-mmr"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME Merkle Mountain Range pallet."
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-mmr-primitives = { version = "4.0.0-dev", default-features = false, path = "../../primitives/merkle-mountain-range" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+array-bytes = "6.1"
+env_logger = "0.9"
+itertools = "0.10.3"
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-mmr-primitives/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/merkle-mountain-range/src/benchmarking.rs b/substrate/frame/merkle-mountain-range/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9eb676a4ee44b21cef7ced59c40366067017f7ce
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/benchmarking.rs
@@ -0,0 +1,40 @@
+// 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.
+
+//! Benchmarks for the MMR pallet.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use crate::*;
+use frame_benchmarking::v1::benchmarks_instance_pallet;
+use frame_support::traits::OnInitialize;
+
+benchmarks_instance_pallet! {
+	on_initialize {
+		let x in 1 .. 1_000;
+
+		let leaves = x as NodeIndex;
+	}: {
+		for b in 0..leaves {
+			Pallet::<T, I>::on_initialize((b as u32).into());
+		}
+	} verify {
+		assert_eq!(crate::NumberOfLeaves::<T, I>::get(), leaves);
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::tests::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/merkle-mountain-range/src/default_weights.rs b/substrate/frame/merkle-mountain-range/src/default_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..52e3f130383fdf8d9267b9b34300014741677b9f
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/default_weights.rs
@@ -0,0 +1,40 @@
+// 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.
+
+//! Default weights for the MMR Pallet
+//! This file was not auto-generated.
+
+use frame_support::weights::{
+	constants::{RocksDbWeight as DbWeight, WEIGHT_REF_TIME_PER_NANOS},
+	Weight,
+};
+
+impl crate::WeightInfo for () {
+	fn on_initialize(peaks: u64) -> Weight {
+		// Reading the parent hash.
+		let leaf_weight = DbWeight::get().reads(1);
+		// Blake2 hash cost.
+		let hash_weight = Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_NANOS, 0);
+		// No-op hook.
+		let hook_weight = Weight::zero();
+
+		leaf_weight
+			.saturating_add(hash_weight)
+			.saturating_add(hook_weight)
+			.saturating_add(DbWeight::get().reads_writes(2 + peaks, 2 + peaks))
+	}
+}
diff --git a/substrate/frame/merkle-mountain-range/src/lib.rs b/substrate/frame/merkle-mountain-range/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..664f4bc73901b39f852e9fccf5685b48e402ec4b
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/lib.rs
@@ -0,0 +1,373 @@
+// 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.
+
+//! # Merkle Mountain Range
+//!
+//! ## Overview
+//!
+//! Details on Merkle Mountain Ranges (MMRs) can be found here:
+//! <https://github.com/mimblewimble/grin/blob/master/doc/mmr.md>
+//!
+//! The MMR pallet constructs an MMR from leaf data obtained on every block from
+//! `LeafDataProvider`. MMR nodes are stored both in:
+//! - on-chain storage - hashes only; not full leaf content;
+//! - off-chain storage - via Indexing API we push full leaf content (and all internal nodes as
+//! well) to the Off-chain DB, so that the data is available for Off-chain workers.
+//! Hashing used for MMR is configurable independently from the rest of the runtime (i.e. not using
+//! `frame_system::Hashing`) so something compatible with external chains can be used (like
+//! Keccak256 for Ethereum compatibility).
+//!
+//! Depending on the usage context (off-chain vs on-chain) the pallet is able to:
+//! - verify MMR leaf proofs (on-chain)
+//! - generate leaf proofs (off-chain)
+//!
+//! See [primitives::Compact] documentation for how you can optimize proof size for leafs that are
+//! composed from multiple elements.
+//!
+//! ## What for?
+//!
+//! Primary use case for this pallet is to generate MMR root hashes, that can latter on be used by
+//! BEEFY protocol (see <https://github.com/paritytech/grandpa-bridge-gadget>).
+//! MMR root hashes along with BEEFY will make it possible to build Super Light Clients (SLC) of
+//! Substrate-based chains. The SLC will be able to follow finality and can be shown proofs of more
+//! details that happened on the source chain.
+//! In that case the chain which contains the pallet generates the Root Hashes and Proofs, which
+//! are then presented to another chain acting as a light client which can verify them.
+//!
+//! Secondary use case is to archive historical data, but still be able to retrieve them on-demand
+//! if needed. For instance if parent block hashes are stored in the MMR it's possible at any point
+//! in time to provide an MMR proof about some past block hash, while this data can be safely pruned
+//! from on-chain storage.
+//!
+//! NOTE This pallet is experimental and not proven to work in production.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::weights::Weight;
+use frame_system::pallet_prelude::{BlockNumberFor, HeaderFor};
+use log;
+use sp_mmr_primitives::utils;
+use sp_runtime::{
+	traits::{self, One, Saturating},
+	SaturatedConversion,
+};
+use sp_std::prelude::*;
+
+pub use pallet::*;
+pub use sp_mmr_primitives::{
+	self as primitives, utils::NodesUtils, Error, LeafDataProvider, LeafIndex, NodeIndex,
+};
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+mod default_weights;
+mod mmr;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+/// The most common use case for MMRs is to store historical block hashes,
+/// so that any point in time in the future we can receive a proof about some past
+/// blocks without using excessive on-chain storage.
+///
+/// Hence we implement the [LeafDataProvider] for [ParentNumberAndHash] which is a
+/// crate-local wrapper over [frame_system::Pallet]. Since the current block hash
+/// is not available (since the block is not finished yet),
+/// we use the `parent_hash` here along with parent block number.
+pub struct ParentNumberAndHash<T: frame_system::Config> {
+	_phanthom: sp_std::marker::PhantomData<T>,
+}
+
+impl<T: frame_system::Config> LeafDataProvider for ParentNumberAndHash<T> {
+	type LeafData = (BlockNumberFor<T>, <T as frame_system::Config>::Hash);
+
+	fn leaf_data() -> Self::LeafData {
+		(
+			frame_system::Pallet::<T>::block_number().saturating_sub(One::one()),
+			frame_system::Pallet::<T>::parent_hash(),
+		)
+	}
+}
+
+pub trait WeightInfo {
+	fn on_initialize(peaks: NodeIndex) -> Weight;
+}
+
+/// An MMR specific to the pallet.
+type ModuleMmr<StorageType, T, I> = mmr::Mmr<StorageType, T, I, LeafOf<T, I>>;
+
+/// Leaf data.
+type LeafOf<T, I> = <<T as Config<I>>::LeafData as primitives::LeafDataProvider>::LeafData;
+
+/// Hashing used for the pallet.
+pub(crate) type HashingOf<T, I> = <T as Config<I>>::Hashing;
+/// Hash type used for the pallet.
+pub(crate) type HashOf<T, I> = <<T as Config<I>>::Hashing as traits::Hash>::Output;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	/// This pallet's configuration trait
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// Prefix for elements stored in the Off-chain DB via Indexing API.
+		///
+		/// Each node of the MMR is inserted both on-chain and off-chain via Indexing API.
+		/// The former does not store full leaf content, just its compact version (hash),
+		/// and some of the inner mmr nodes might be pruned from on-chain storage.
+		/// The latter will contain all the entries in their full form.
+		///
+		/// Each node is stored in the Off-chain DB under key derived from the
+		/// [`Self::INDEXING_PREFIX`] and its in-tree index (MMR position).
+		const INDEXING_PREFIX: &'static [u8];
+
+		/// A hasher type for MMR.
+		///
+		/// To construct trie nodes that result in merging (bagging) two peaks, depending on the
+		/// node kind we take either:
+		/// - The node (hash) itself if it's an inner node.
+		/// - The hash of SCALE-encoding of the leaf data if it's a leaf node.
+		///
+		/// Then we create a tuple of these two hashes, SCALE-encode it (concatenate) and
+		/// hash, to obtain a new MMR inner node - the new peak.
+		type Hashing: traits::Hash;
+
+		/// Data stored in the leaf nodes.
+		///
+		/// The [LeafData](primitives::LeafDataProvider) is responsible for returning the entire
+		/// leaf data that will be inserted to the MMR.
+		/// [LeafDataProvider](primitives::LeafDataProvider)s can be composed into tuples to put
+		/// multiple elements into the tree. In such a case it might be worth using
+		/// [primitives::Compact] to make MMR proof for one element of the tuple leaner.
+		///
+		/// Note that the leaf at each block MUST be unique. You may want to include a block hash or
+		/// block number as an easiest way to ensure that.
+		/// Also note that the leaf added by each block is expected to only reference data coming
+		/// from ancestor blocks (leaves are saved offchain using `(pos, parent_hash)` key to be
+		/// fork-resistant, as such conflicts could only happen on 1-block deep forks, which means
+		/// two forks with identical line of ancestors compete to write the same offchain key, but
+		/// that's fine as long as leaves only contain data coming from ancestors - conflicting
+		/// writes are identical).
+		type LeafData: primitives::LeafDataProvider;
+
+		/// A hook to act on the new MMR root.
+		///
+		/// For some applications it might be beneficial to make the MMR root available externally
+		/// apart from having it in the storage. For instance you might output it in the header
+		/// digest (see [`frame_system::Pallet::deposit_log`]) to make it available for Light
+		/// Clients. Hook complexity should be `O(1)`.
+		type OnNewRoot: primitives::OnNewRoot<HashOf<Self, I>>;
+
+		/// Weights for this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// Latest MMR Root hash.
+	#[pallet::storage]
+	#[pallet::getter(fn mmr_root_hash)]
+	pub type RootHash<T: Config<I>, I: 'static = ()> = StorageValue<_, HashOf<T, I>, ValueQuery>;
+
+	/// Current size of the MMR (number of leaves).
+	#[pallet::storage]
+	#[pallet::getter(fn mmr_leaves)]
+	pub type NumberOfLeaves<T, I = ()> = StorageValue<_, LeafIndex, ValueQuery>;
+
+	/// Hashes of the nodes in the MMR.
+	///
+	/// Note this collection only contains MMR peaks, the inner nodes (and leaves)
+	/// are pruned and only stored in the Offchain DB.
+	#[pallet::storage]
+	#[pallet::getter(fn mmr_peak)]
+	pub type Nodes<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Identity, NodeIndex, HashOf<T, I>, OptionQuery>;
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+			use primitives::LeafDataProvider;
+			let leaves = Self::mmr_leaves();
+			let peaks_before = sp_mmr_primitives::utils::NodesUtils::new(leaves).number_of_peaks();
+			let data = T::LeafData::leaf_data();
+
+			// append new leaf to MMR
+			let mut mmr: ModuleMmr<mmr::storage::RuntimeStorage, T, I> = mmr::Mmr::new(leaves);
+			// MMR push never fails, but better safe than sorry.
+			if mmr.push(data).is_none() {
+				log::error!(target: "runtime::mmr", "MMR push failed");
+				return T::WeightInfo::on_initialize(peaks_before)
+			}
+			// Update the size, `mmr.finalize()` should also never fail.
+			let (leaves, root) = match mmr.finalize() {
+				Ok((leaves, root)) => (leaves, root),
+				Err(e) => {
+					log::error!(target: "runtime::mmr", "MMR finalize failed: {:?}", e);
+					return T::WeightInfo::on_initialize(peaks_before)
+				},
+			};
+			<T::OnNewRoot as primitives::OnNewRoot<_>>::on_new_root(&root);
+
+			<NumberOfLeaves<T, I>>::put(leaves);
+			<RootHash<T, I>>::put(root);
+
+			let peaks_after = sp_mmr_primitives::utils::NodesUtils::new(leaves).number_of_peaks();
+
+			T::WeightInfo::on_initialize(peaks_before.max(peaks_after))
+		}
+	}
+}
+
+/// Stateless MMR proof verification for batch of leaves.
+///
+/// This function can be used to verify received MMR [primitives::Proof] (`proof`)
+/// for given leaves set (`leaves`) against a known MMR root hash (`root`).
+/// Note, the leaves should be sorted such that corresponding leaves and leaf indices have the
+/// same position in both the `leaves` vector and the `leaf_indices` vector contained in the
+/// [primitives::Proof].
+pub fn verify_leaves_proof<H, L>(
+	root: H::Output,
+	leaves: Vec<mmr::Node<H, L>>,
+	proof: primitives::Proof<H::Output>,
+) -> Result<(), primitives::Error>
+where
+	H: traits::Hash,
+	L: primitives::FullLeaf,
+{
+	let is_valid = mmr::verify_leaves_proof::<H, L>(root, leaves, proof)?;
+	if is_valid {
+		Ok(())
+	} else {
+		Err(primitives::Error::Verify.log_debug(("The proof is incorrect.", root)))
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Build offchain key from `parent_hash` of block that originally added node `pos` to MMR.
+	///
+	/// This combination makes the offchain (key,value) entry resilient to chain forks.
+	fn node_temp_offchain_key(
+		pos: NodeIndex,
+		parent_hash: <T as frame_system::Config>::Hash,
+	) -> sp_std::prelude::Vec<u8> {
+		NodesUtils::node_temp_offchain_key::<HeaderFor<T>>(&T::INDEXING_PREFIX, pos, parent_hash)
+	}
+
+	/// Build canonical offchain key for node `pos` in MMR.
+	///
+	/// Used for nodes added by now finalized blocks.
+	/// Never read keys using `node_canon_offchain_key` unless you sure that
+	/// there's no `node_offchain_key` key in the storage.
+	fn node_canon_offchain_key(pos: NodeIndex) -> sp_std::prelude::Vec<u8> {
+		NodesUtils::node_canon_offchain_key(&T::INDEXING_PREFIX, pos)
+	}
+
+	/// Provide the parent number for the block that added `leaf_index` to the MMR.
+	fn leaf_index_to_parent_block_num(
+		leaf_index: LeafIndex,
+		leaves_count: LeafIndex,
+	) -> BlockNumberFor<T> {
+		// leaves are zero-indexed and were added one per block since pallet activation,
+		// while block numbers are one-indexed, so block number that added `leaf_idx` is:
+		// `block_num = block_num_when_pallet_activated + leaf_idx + 1`
+		// `block_num = (current_block_num - leaves_count) + leaf_idx + 1`
+		// `parent_block_num = current_block_num - leaves_count + leaf_idx`.
+		<frame_system::Pallet<T>>::block_number()
+			.saturating_sub(leaves_count.saturated_into())
+			.saturating_add(leaf_index.saturated_into())
+	}
+
+	/// Convert a block number into a leaf index.
+	fn block_num_to_leaf_index(block_num: BlockNumberFor<T>) -> Result<LeafIndex, Error>
+	where
+		T: frame_system::Config,
+	{
+		let first_mmr_block = utils::first_mmr_block_num::<HeaderFor<T>>(
+			<frame_system::Pallet<T>>::block_number(),
+			Self::mmr_leaves(),
+		)?;
+
+		utils::block_num_to_leaf_index::<HeaderFor<T>>(block_num, first_mmr_block)
+	}
+
+	/// Generate an MMR proof for the given `block_numbers`.
+	/// If `best_known_block_number = Some(n)`, this generates a historical proof for
+	/// the chain with head at height `n`.
+	/// Else it generates a proof for the MMR at the current block height.
+	///
+	/// Note this method can only be used from an off-chain context
+	/// (Offchain Worker or Runtime API call), since it requires
+	/// all the leaves to be present.
+	/// It may return an error or panic if used incorrectly.
+	pub fn generate_proof(
+		block_numbers: Vec<BlockNumberFor<T>>,
+		best_known_block_number: Option<BlockNumberFor<T>>,
+	) -> Result<(Vec<LeafOf<T, I>>, primitives::Proof<HashOf<T, I>>), primitives::Error> {
+		// check whether best_known_block_number provided, else use current best block
+		let best_known_block_number =
+			best_known_block_number.unwrap_or_else(|| <frame_system::Pallet<T>>::block_number());
+
+		let leaves_count =
+			Self::block_num_to_leaf_index(best_known_block_number)?.saturating_add(1);
+
+		// we need to translate the block_numbers into leaf indices.
+		let leaf_indices = block_numbers
+			.iter()
+			.map(|block_num| -> Result<LeafIndex, primitives::Error> {
+				Self::block_num_to_leaf_index(*block_num)
+			})
+			.collect::<Result<Vec<LeafIndex>, _>>()?;
+
+		let mmr: ModuleMmr<mmr::storage::OffchainStorage, T, I> = mmr::Mmr::new(leaves_count);
+		mmr.generate_proof(leaf_indices)
+	}
+
+	/// Return the on-chain MMR root hash.
+	pub fn mmr_root() -> HashOf<T, I> {
+		Self::mmr_root_hash()
+	}
+
+	/// Verify MMR proof for given `leaves`.
+	///
+	/// This method is safe to use within the runtime code.
+	/// It will return `Ok(())` if the proof is valid
+	/// and an `Err(..)` if MMR is inconsistent (some leaves are missing)
+	/// or the proof is invalid.
+	pub fn verify_leaves(
+		leaves: Vec<LeafOf<T, I>>,
+		proof: primitives::Proof<HashOf<T, I>>,
+	) -> Result<(), primitives::Error> {
+		if proof.leaf_count > Self::mmr_leaves() ||
+			proof.leaf_count == 0 ||
+			(proof.items.len().saturating_add(leaves.len())) as u64 > proof.leaf_count
+		{
+			return Err(primitives::Error::Verify
+				.log_debug("The proof has incorrect number of leaves or proof items."))
+		}
+
+		let mmr: ModuleMmr<mmr::storage::OffchainStorage, T, I> = mmr::Mmr::new(proof.leaf_count);
+		let is_valid = mmr.verify_leaves_proof(leaves, proof)?;
+		if is_valid {
+			Ok(())
+		} else {
+			Err(primitives::Error::Verify.log_debug("The proof is incorrect."))
+		}
+	}
+}
diff --git a/substrate/frame/merkle-mountain-range/src/mmr/mmr.rs b/substrate/frame/merkle-mountain-range/src/mmr/mmr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aeb3e7ea66414a062a238da3f84795b53da4f68b
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/mmr/mmr.rs
@@ -0,0 +1,194 @@
+// 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::{
+	mmr::{
+		storage::{OffchainStorage, RuntimeStorage, Storage},
+		Hasher, Node, NodeOf,
+	},
+	primitives::{self, Error, NodeIndex},
+	Config, HashOf, HashingOf,
+};
+use sp_mmr_primitives::{mmr_lib, utils::NodesUtils};
+use sp_std::prelude::*;
+
+/// Stateless verification of the proof for a batch of leaves.
+/// Note, the leaves should be sorted such that corresponding leaves and leaf indices have the
+/// same position in both the `leaves` vector and the `leaf_indices` vector contained in the
+/// [primitives::Proof]
+pub fn verify_leaves_proof<H, L>(
+	root: H::Output,
+	leaves: Vec<Node<H, L>>,
+	proof: primitives::Proof<H::Output>,
+) -> Result<bool, Error>
+where
+	H: sp_runtime::traits::Hash,
+	L: primitives::FullLeaf,
+{
+	let size = NodesUtils::new(proof.leaf_count).size();
+
+	if leaves.len() != proof.leaf_indices.len() {
+		return Err(Error::Verify.log_debug("Proof leaf_indices not same length with leaves"))
+	}
+
+	let leaves_and_position_data = proof
+		.leaf_indices
+		.into_iter()
+		.map(|index| mmr_lib::leaf_index_to_pos(index))
+		.zip(leaves.into_iter())
+		.collect();
+
+	let p = mmr_lib::MerkleProof::<Node<H, L>, Hasher<H, L>>::new(
+		size,
+		proof.items.into_iter().map(Node::Hash).collect(),
+	);
+	p.verify(Node::Hash(root), leaves_and_position_data)
+		.map_err(|e| Error::Verify.log_debug(e))
+}
+
+/// A wrapper around an MMR library to expose limited functionality.
+///
+/// Available functions depend on the storage kind ([Runtime](crate::mmr::storage::RuntimeStorage)
+/// vs [Off-chain](crate::mmr::storage::OffchainStorage)).
+pub struct Mmr<StorageType, T, I, L>
+where
+	T: Config<I>,
+	I: 'static,
+	L: primitives::FullLeaf,
+	Storage<StorageType, T, I, L>: mmr_lib::MMRStore<NodeOf<T, I, L>>,
+{
+	mmr: mmr_lib::MMR<NodeOf<T, I, L>, Hasher<HashingOf<T, I>, L>, Storage<StorageType, T, I, L>>,
+	leaves: NodeIndex,
+}
+
+impl<StorageType, T, I, L> Mmr<StorageType, T, I, L>
+where
+	T: Config<I>,
+	I: 'static,
+	L: primitives::FullLeaf,
+	Storage<StorageType, T, I, L>: mmr_lib::MMRStore<NodeOf<T, I, L>>,
+{
+	/// Create a pointer to an existing MMR with given number of leaves.
+	pub fn new(leaves: NodeIndex) -> Self {
+		let size = NodesUtils::new(leaves).size();
+		Self { mmr: mmr_lib::MMR::new(size, Default::default()), leaves }
+	}
+
+	/// Verify proof for a set of leaves.
+	/// Note, the leaves should be sorted such that corresponding leaves and leaf indices have
+	/// the same position in both the `leaves` vector and the `leaf_indices` vector contained in the
+	/// [primitives::Proof]
+	pub fn verify_leaves_proof(
+		&self,
+		leaves: Vec<L>,
+		proof: primitives::Proof<HashOf<T, I>>,
+	) -> Result<bool, Error> {
+		let p = mmr_lib::MerkleProof::<NodeOf<T, I, L>, Hasher<HashingOf<T, I>, L>>::new(
+			self.mmr.mmr_size(),
+			proof.items.into_iter().map(Node::Hash).collect(),
+		);
+
+		if leaves.len() != proof.leaf_indices.len() {
+			return Err(Error::Verify.log_debug("Proof leaf_indices not same length with leaves"))
+		}
+
+		let leaves_positions_and_data = proof
+			.leaf_indices
+			.into_iter()
+			.map(|index| mmr_lib::leaf_index_to_pos(index))
+			.zip(leaves.into_iter().map(|leaf| Node::Data(leaf)))
+			.collect();
+		let root = self.mmr.get_root().map_err(|e| Error::GetRoot.log_error(e))?;
+		p.verify(root, leaves_positions_and_data)
+			.map_err(|e| Error::Verify.log_debug(e))
+	}
+
+	/// Return the internal size of the MMR (number of nodes).
+	#[cfg(test)]
+	pub fn size(&self) -> NodeIndex {
+		self.mmr.mmr_size()
+	}
+}
+
+/// Runtime specific MMR functions.
+impl<T, I, L> Mmr<RuntimeStorage, T, I, L>
+where
+	T: Config<I>,
+	I: 'static,
+	L: primitives::FullLeaf,
+{
+	/// Push another item to the MMR.
+	///
+	/// Returns element position (index) in the MMR.
+	pub fn push(&mut self, leaf: L) -> Option<NodeIndex> {
+		let position =
+			self.mmr.push(Node::Data(leaf)).map_err(|e| Error::Push.log_error(e)).ok()?;
+
+		self.leaves += 1;
+
+		Some(position)
+	}
+
+	/// Commit the changes to underlying storage, return current number of leaves and
+	/// calculate the new MMR's root hash.
+	pub fn finalize(self) -> Result<(NodeIndex, HashOf<T, I>), Error> {
+		let root = self.mmr.get_root().map_err(|e| Error::GetRoot.log_error(e))?;
+		self.mmr.commit().map_err(|e| Error::Commit.log_error(e))?;
+		Ok((self.leaves, root.hash()))
+	}
+}
+
+/// Off-chain specific MMR functions.
+impl<T, I, L> Mmr<OffchainStorage, T, I, L>
+where
+	T: Config<I>,
+	I: 'static,
+	L: primitives::FullLeaf + codec::Decode,
+{
+	/// Generate a proof for given leaf indices.
+	///
+	/// Proof generation requires all the nodes (or their hashes) to be available in the storage.
+	/// (i.e. you can't run the function in the pruned storage).
+	pub fn generate_proof(
+		&self,
+		leaf_indices: Vec<NodeIndex>,
+	) -> Result<(Vec<L>, primitives::Proof<HashOf<T, I>>), Error> {
+		let positions = leaf_indices
+			.iter()
+			.map(|index| mmr_lib::leaf_index_to_pos(*index))
+			.collect::<Vec<_>>();
+		let store = <Storage<OffchainStorage, T, I, L>>::default();
+		let leaves = positions
+			.iter()
+			.map(|pos| match mmr_lib::MMRStore::get_elem(&store, *pos) {
+				Ok(Some(Node::Data(leaf))) => Ok(leaf),
+				e => Err(Error::LeafNotFound.log_debug(e)),
+			})
+			.collect::<Result<Vec<_>, Error>>()?;
+
+		let leaf_count = self.leaves;
+		self.mmr
+			.gen_proof(positions)
+			.map_err(|e| Error::GenerateProof.log_error(e))
+			.map(|p| primitives::Proof {
+				leaf_indices,
+				leaf_count,
+				items: p.proof_items().iter().map(|x| x.hash()).collect(),
+			})
+			.map(|p| (leaves, p))
+	}
+}
diff --git a/substrate/frame/merkle-mountain-range/src/mmr/mod.rs b/substrate/frame/merkle-mountain-range/src/mmr/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..536faa68e4e9f05f8d11941bb5cd81fe48e1948f
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/mmr/mod.rs
@@ -0,0 +1,44 @@
+// 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.
+
+mod mmr;
+pub mod storage;
+
+use sp_mmr_primitives::{mmr_lib, DataOrHash, FullLeaf};
+use sp_runtime::traits;
+
+pub use self::mmr::{verify_leaves_proof, Mmr};
+
+/// Node type for runtime `T`.
+pub type NodeOf<T, I, L> = Node<<T as crate::Config<I>>::Hashing, L>;
+
+/// A node stored in the MMR.
+pub type Node<H, L> = DataOrHash<H, L>;
+
+/// Default Merging & Hashing behavior for MMR.
+pub struct Hasher<H, L>(sp_std::marker::PhantomData<(H, L)>);
+
+impl<H: traits::Hash, L: FullLeaf> mmr_lib::Merge for Hasher<H, L> {
+	type Item = Node<H, L>;
+
+	fn merge(left: &Self::Item, right: &Self::Item) -> mmr_lib::Result<Self::Item> {
+		let mut concat = left.hash().as_ref().to_vec();
+		concat.extend_from_slice(right.hash().as_ref());
+
+		Ok(Node::Hash(<H as traits::Hash>::hash(&concat)))
+	}
+}
diff --git a/substrate/frame/merkle-mountain-range/src/mmr/storage.rs b/substrate/frame/merkle-mountain-range/src/mmr/storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..03039be83ac1a13383313f7bc09c175705e6d02a
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/mmr/storage.rs
@@ -0,0 +1,223 @@
+// 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.
+
+//! An MMR storage implementation.
+
+use codec::Encode;
+use log::{debug, trace};
+use sp_core::offchain::StorageKind;
+use sp_io::offchain_index;
+use sp_mmr_primitives::{mmr_lib, mmr_lib::helper, utils::NodesUtils};
+use sp_std::iter::Peekable;
+#[cfg(not(feature = "std"))]
+use sp_std::prelude::*;
+
+use crate::{
+	mmr::{Node, NodeOf},
+	primitives::{self, NodeIndex},
+	Config, Nodes, NumberOfLeaves, Pallet,
+};
+
+/// A marker type for runtime-specific storage implementation.
+///
+/// Allows appending new items to the MMR and proof verification.
+/// MMR nodes are appended to two different storages:
+/// 1. We add nodes (leaves) hashes to the on-chain storage (see [crate::Nodes]).
+/// 2. We add full leaves (and all inner nodes as well) into the `IndexingAPI` during block
+///    processing, so the values end up in the Offchain DB if indexing is enabled.
+pub struct RuntimeStorage;
+
+/// A marker type for offchain-specific storage implementation.
+///
+/// Allows proof generation and verification, but does not support appending new items.
+/// MMR nodes are assumed to be stored in the Off-Chain DB. Note this storage type
+/// DOES NOT support adding new items to the MMR.
+pub struct OffchainStorage;
+
+/// A storage layer for MMR.
+///
+/// There are two different implementations depending on the use case.
+/// See docs for [RuntimeStorage] and [OffchainStorage].
+pub struct Storage<StorageType, T, I, L>(sp_std::marker::PhantomData<(StorageType, T, I, L)>);
+
+impl<StorageType, T, I, L> Default for Storage<StorageType, T, I, L> {
+	fn default() -> Self {
+		Self(Default::default())
+	}
+}
+
+impl<T, I, L> mmr_lib::MMRStore<NodeOf<T, I, L>> for Storage<OffchainStorage, T, I, L>
+where
+	T: Config<I>,
+	I: 'static,
+	L: primitives::FullLeaf + codec::Decode,
+{
+	fn get_elem(&self, pos: NodeIndex) -> mmr_lib::Result<Option<NodeOf<T, I, L>>> {
+		let leaves = NumberOfLeaves::<T, I>::get();
+		// Find out which leaf added node `pos` in the MMR.
+		let ancestor_leaf_idx = NodesUtils::leaf_index_that_added_node(pos);
+
+		// We should only get here when trying to generate proofs. The client requests
+		// for proofs for finalized blocks, which should usually be already canonicalized,
+		// unless the MMR client gadget has a delay.
+		let key = Pallet::<T, I>::node_canon_offchain_key(pos);
+		debug!(
+			target: "runtime::mmr::offchain", "offchain db get {}: leaf idx {:?}, canon key {:?}",
+			pos, ancestor_leaf_idx, key
+		);
+		// Try to retrieve the element from Off-chain DB.
+		if let Some(elem) = sp_io::offchain::local_storage_get(StorageKind::PERSISTENT, &key) {
+			return Ok(codec::Decode::decode(&mut &*elem).ok())
+		}
+
+		// Fall through to searching node using fork-specific key.
+		let ancestor_parent_block_num =
+			Pallet::<T, I>::leaf_index_to_parent_block_num(ancestor_leaf_idx, leaves);
+		let ancestor_parent_hash = <frame_system::Pallet<T>>::block_hash(ancestor_parent_block_num);
+		let temp_key = Pallet::<T, I>::node_temp_offchain_key(pos, ancestor_parent_hash);
+		debug!(
+			target: "runtime::mmr::offchain",
+			"offchain db get {}: leaf idx {:?}, hash {:?}, temp key {:?}",
+			pos, ancestor_leaf_idx, ancestor_parent_hash, temp_key
+		);
+		// Retrieve the element from Off-chain DB.
+		Ok(sp_io::offchain::local_storage_get(StorageKind::PERSISTENT, &temp_key)
+			.and_then(|v| codec::Decode::decode(&mut &*v).ok()))
+	}
+
+	fn append(&mut self, _: NodeIndex, _: Vec<NodeOf<T, I, L>>) -> mmr_lib::Result<()> {
+		panic!("MMR must not be altered in the off-chain context.")
+	}
+}
+
+impl<T, I, L> mmr_lib::MMRStore<NodeOf<T, I, L>> for Storage<RuntimeStorage, T, I, L>
+where
+	T: Config<I>,
+	I: 'static,
+	L: primitives::FullLeaf,
+{
+	fn get_elem(&self, pos: NodeIndex) -> mmr_lib::Result<Option<NodeOf<T, I, L>>> {
+		Ok(<Nodes<T, I>>::get(pos).map(Node::Hash))
+	}
+
+	fn append(&mut self, pos: NodeIndex, elems: Vec<NodeOf<T, I, L>>) -> mmr_lib::Result<()> {
+		if elems.is_empty() {
+			return Ok(())
+		}
+
+		trace!(
+			target: "runtime::mmr", "elems: {:?}",
+			elems.iter().map(|elem| elem.hash()).collect::<Vec<_>>()
+		);
+
+		let leaves = NumberOfLeaves::<T, I>::get();
+		let size = NodesUtils::new(leaves).size();
+
+		if pos != size {
+			return Err(mmr_lib::Error::InconsistentStore)
+		}
+
+		let new_size = size + elems.len() as NodeIndex;
+
+		// A sorted (ascending) iterator over peak indices to prune and persist.
+		let (peaks_to_prune, mut peaks_to_store) = peaks_to_prune_and_store(size, new_size);
+
+		// Now we are going to iterate over elements to insert
+		// and keep track of the current `node_index` and `leaf_index`.
+		let mut leaf_index = leaves;
+		let mut node_index = size;
+
+		// Use parent hash of block adding new nodes (this block) as extra identifier
+		// in offchain DB to avoid DB collisions and overwrites in case of forks.
+		let parent_hash = <frame_system::Pallet<T>>::parent_hash();
+		for elem in elems {
+			// On-chain we are going to only store new peaks.
+			if peaks_to_store.next_if_eq(&node_index).is_some() {
+				<Nodes<T, I>>::insert(node_index, elem.hash());
+			}
+			// We are storing full node off-chain (using indexing API).
+			Self::store_to_offchain(node_index, parent_hash, &elem);
+
+			// Increase the indices.
+			if let Node::Data(..) = elem {
+				leaf_index += 1;
+			}
+			node_index += 1;
+		}
+
+		// Update current number of leaves.
+		NumberOfLeaves::<T, I>::put(leaf_index);
+
+		// And remove all remaining items from `peaks_before` collection.
+		for pos in peaks_to_prune {
+			<Nodes<T, I>>::remove(pos);
+		}
+
+		Ok(())
+	}
+}
+
+impl<T, I, L> Storage<RuntimeStorage, T, I, L>
+where
+	T: Config<I>,
+	I: 'static,
+	L: primitives::FullLeaf,
+{
+	fn store_to_offchain(
+		pos: NodeIndex,
+		parent_hash: <T as frame_system::Config>::Hash,
+		node: &NodeOf<T, I, L>,
+	) {
+		let encoded_node = node.encode();
+		// We store this leaf offchain keyed by `(parent_hash, node_index)` to make it
+		// fork-resistant. The MMR client gadget task will "canonicalize" it on the first
+		// finality notification that follows, when we are not worried about forks anymore.
+		let temp_key = Pallet::<T, I>::node_temp_offchain_key(pos, parent_hash);
+		debug!(
+			target: "runtime::mmr::offchain", "offchain db set: pos {} parent_hash {:?} key {:?}",
+			pos, parent_hash, temp_key
+		);
+		// Indexing API is used to store the full node content.
+		offchain_index::set(&temp_key, &encoded_node);
+	}
+}
+
+fn peaks_to_prune_and_store(
+	old_size: NodeIndex,
+	new_size: NodeIndex,
+) -> (impl Iterator<Item = NodeIndex>, Peekable<impl Iterator<Item = NodeIndex>>) {
+	// A sorted (ascending) collection of peak indices before and after insertion.
+	// both collections may share a common prefix.
+	let peaks_before = if old_size == 0 { vec![] } else { helper::get_peaks(old_size) };
+	let peaks_after = helper::get_peaks(new_size);
+	trace!(target: "runtime::mmr", "peaks_before: {:?}", peaks_before);
+	trace!(target: "runtime::mmr", "peaks_after: {:?}", peaks_after);
+	let mut peaks_before = peaks_before.into_iter().peekable();
+	let mut peaks_after = peaks_after.into_iter().peekable();
+
+	// Consume a common prefix between `peaks_before` and `peaks_after`,
+	// since that's something we will not be touching anyway.
+	while peaks_before.peek() == peaks_after.peek() {
+		peaks_before.next();
+		peaks_after.next();
+	}
+
+	// what's left in both collections is:
+	// 1. Old peaks to remove from storage
+	// 2. New peaks to persist in storage
+	(peaks_before, peaks_after)
+}
diff --git a/substrate/frame/merkle-mountain-range/src/mock.rs b/substrate/frame/merkle-mountain-range/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ecc254278bf0fa1661d57e1fd2f1b97edbf181c1
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/mock.rs
@@ -0,0 +1,97 @@
+// 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 as pallet_mmr;
+use crate::*;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_mmr_primitives::{Compact, LeafDataProvider};
+use sp_runtime::traits::{BlakeTwo256, IdentityLookup, Keccak256};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		MMR: pallet_mmr::{Pallet, Storage},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = sp_core::sr25519::Public;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type DbWeight = ();
+	type BlockWeights = ();
+	type BlockLength = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl Config for Test {
+	const INDEXING_PREFIX: &'static [u8] = b"mmr-";
+
+	type Hashing = Keccak256;
+	type LeafData = Compact<Keccak256, (ParentNumberAndHash<Test>, LeafData)>;
+	type OnNewRoot = ();
+	type WeightInfo = ();
+}
+
+#[derive(Encode, Decode, Clone, Default, Eq, PartialEq, Debug)]
+pub struct LeafData {
+	pub a: u64,
+	pub b: Vec<u8>,
+}
+
+impl LeafData {
+	pub fn new(a: u64) -> Self {
+		Self { a, b: Default::default() }
+	}
+}
+
+parameter_types! {
+	pub static LeafDataTestValue: LeafData = Default::default();
+}
+
+impl LeafDataProvider for LeafData {
+	type LeafData = Self;
+
+	fn leaf_data() -> Self::LeafData {
+		LeafDataTestValue::get().clone()
+	}
+}
diff --git a/substrate/frame/merkle-mountain-range/src/tests.rs b/substrate/frame/merkle-mountain-range/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..429df75182eeeefb3411d5eb6aeb8c9b62968186
--- /dev/null
+++ b/substrate/frame/merkle-mountain-range/src/tests.rs
@@ -0,0 +1,792 @@
+// 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::{mock::*, *};
+
+use frame_support::traits::{Get, OnInitialize};
+use sp_core::{
+	offchain::{testing::TestOffchainExt, OffchainDbExt, OffchainWorkerExt},
+	H256,
+};
+use sp_mmr_primitives::{mmr_lib::helper, utils, Compact, Proof};
+use sp_runtime::BuildStorage;
+
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
+
+fn register_offchain_ext(ext: &mut sp_io::TestExternalities) {
+	let (offchain, _offchain_state) = TestOffchainExt::with_offchain_db(ext.offchain_db());
+	ext.register_extension(OffchainDbExt::new(offchain.clone()));
+	ext.register_extension(OffchainWorkerExt::new(offchain));
+}
+
+fn new_block() -> Weight {
+	let number = frame_system::Pallet::<Test>::block_number() + 1;
+	let hash = H256::repeat_byte(number as u8);
+	LeafDataTestValue::mutate(|r| r.a = number);
+
+	frame_system::Pallet::<Test>::reset_events();
+	frame_system::Pallet::<Test>::initialize(&number, &hash, &Default::default());
+	MMR::on_initialize(number)
+}
+
+fn peaks_from_leaves_count(leaves_count: NodeIndex) -> Vec<NodeIndex> {
+	let size = utils::NodesUtils::new(leaves_count).size();
+	helper::get_peaks(size)
+}
+
+pub(crate) fn hex(s: &str) -> H256 {
+	s.parse().unwrap()
+}
+
+type BlockNumber = frame_system::pallet_prelude::BlockNumberFor<Test>;
+
+fn decode_node(
+	v: Vec<u8>,
+) -> mmr::Node<<Test as Config>::Hashing, ((BlockNumber, H256), LeafData)> {
+	use crate::primitives::DataOrHash;
+	type A = DataOrHash<<Test as Config>::Hashing, (BlockNumber, H256)>;
+	type B = DataOrHash<<Test as Config>::Hashing, LeafData>;
+	type Node = mmr::Node<<Test as Config>::Hashing, (A, B)>;
+	let tuple: Node = codec::Decode::decode(&mut &v[..]).unwrap();
+
+	match tuple {
+		mmr::Node::Data((DataOrHash::Data(a), DataOrHash::Data(b))) => mmr::Node::Data((a, b)),
+		mmr::Node::Hash(hash) => mmr::Node::Hash(hash),
+		_ => unreachable!(),
+	}
+}
+
+fn add_blocks(blocks: usize) {
+	// given
+	for _ in 0..blocks {
+		new_block();
+	}
+}
+
+#[test]
+fn should_start_empty() {
+	let _ = env_logger::try_init();
+	new_test_ext().execute_with(|| {
+		// given
+		assert_eq!(
+			crate::RootHash::<Test>::get(),
+			"0000000000000000000000000000000000000000000000000000000000000000"
+				.parse()
+				.unwrap()
+		);
+		assert_eq!(crate::NumberOfLeaves::<Test>::get(), 0);
+		assert_eq!(crate::Nodes::<Test>::get(0), None);
+
+		// when
+		let weight = new_block();
+
+		// then
+		assert_eq!(crate::NumberOfLeaves::<Test>::get(), 1);
+		assert_eq!(
+			crate::Nodes::<Test>::get(0),
+			Some(hex("4320435e8c3318562dba60116bdbcc0b82ffcecb9bb39aae3300cfda3ad0b8b0"))
+		);
+		assert_eq!(
+			crate::RootHash::<Test>::get(),
+			hex("4320435e8c3318562dba60116bdbcc0b82ffcecb9bb39aae3300cfda3ad0b8b0")
+		);
+		assert!(weight != Weight::zero());
+	});
+}
+
+#[test]
+fn should_append_to_mmr_when_on_initialize_is_called() {
+	let _ = env_logger::try_init();
+	let mut ext = new_test_ext();
+	let (parent_b1, parent_b2) = ext.execute_with(|| {
+		// when
+		new_block();
+		let parent_b1 = <frame_system::Pallet<Test>>::parent_hash();
+
+		// then
+		assert_eq!(crate::NumberOfLeaves::<Test>::get(), 1);
+		assert_eq!(
+			(
+				crate::Nodes::<Test>::get(0),
+				crate::Nodes::<Test>::get(1),
+				crate::RootHash::<Test>::get(),
+			),
+			(
+				Some(hex("4320435e8c3318562dba60116bdbcc0b82ffcecb9bb39aae3300cfda3ad0b8b0")),
+				None,
+				hex("0x4320435e8c3318562dba60116bdbcc0b82ffcecb9bb39aae3300cfda3ad0b8b0"),
+			)
+		);
+
+		// when
+		new_block();
+		let parent_b2 = <frame_system::Pallet<Test>>::parent_hash();
+
+		// then
+		assert_eq!(crate::NumberOfLeaves::<Test>::get(), 2);
+		let peaks = peaks_from_leaves_count(2);
+		assert_eq!(peaks, vec![2]);
+		assert_eq!(
+			(
+				crate::Nodes::<Test>::get(0),
+				crate::Nodes::<Test>::get(1),
+				crate::Nodes::<Test>::get(2),
+				crate::Nodes::<Test>::get(3),
+				crate::RootHash::<Test>::get(),
+			),
+			(
+				None,
+				None,
+				Some(hex("672c04a9cd05a644789d769daa552d35d8de7c33129f8a7cbf49e595234c4854")),
+				None,
+				hex("672c04a9cd05a644789d769daa552d35d8de7c33129f8a7cbf49e595234c4854"),
+			)
+		);
+
+		(parent_b1, parent_b2)
+	});
+	// make sure the leaves end up in the offchain DB
+	ext.persist_offchain_overlay();
+
+	let offchain_db = ext.offchain_db();
+
+	let expected = Some(mmr::Node::Data(((0, H256::repeat_byte(1)), LeafData::new(1))));
+	assert_eq!(
+		offchain_db.get(&MMR::node_temp_offchain_key(0, parent_b1)).map(decode_node),
+		expected
+	);
+
+	let expected = Some(mmr::Node::Data(((1, H256::repeat_byte(2)), LeafData::new(2))));
+	assert_eq!(
+		offchain_db.get(&MMR::node_temp_offchain_key(1, parent_b2)).map(decode_node),
+		expected
+	);
+
+	let expected = Some(mmr::Node::Hash(hex(
+		"672c04a9cd05a644789d769daa552d35d8de7c33129f8a7cbf49e595234c4854",
+	)));
+	assert_eq!(
+		offchain_db.get(&MMR::node_temp_offchain_key(2, parent_b2)).map(decode_node),
+		expected
+	);
+
+	assert_eq!(offchain_db.get(&MMR::node_temp_offchain_key(3, parent_b2)), None);
+}
+
+#[test]
+fn should_construct_larger_mmr_correctly() {
+	let _ = env_logger::try_init();
+	new_test_ext().execute_with(|| {
+		// when
+		add_blocks(7);
+
+		// then
+		assert_eq!(crate::NumberOfLeaves::<Test>::get(), 7);
+		let peaks = peaks_from_leaves_count(7);
+		assert_eq!(peaks, vec![6, 9, 10]);
+		for i in (0..=10).filter(|p| !peaks.contains(p)) {
+			assert!(crate::Nodes::<Test>::get(i).is_none());
+		}
+		assert_eq!(
+			(
+				crate::Nodes::<Test>::get(6),
+				crate::Nodes::<Test>::get(9),
+				crate::Nodes::<Test>::get(10),
+				crate::RootHash::<Test>::get(),
+			),
+			(
+				Some(hex("ae88a0825da50e953e7a359c55fe13c8015e48d03d301b8bdfc9193874da9252")),
+				Some(hex("7e4316ae2ebf7c3b6821cb3a46ca8b7a4f9351a9b40fcf014bb0a4fd8e8f29da")),
+				Some(hex("611c2174c6164952a66d985cfe1ec1a623794393e3acff96b136d198f37a648c")),
+				hex("e45e25259f7930626431347fa4dd9aae7ac83b4966126d425ca70ab343709d2c"),
+			)
+		);
+	});
+}
+
+#[test]
+fn should_calculate_the_size_correctly() {
+	let _ = env_logger::try_init();
+
+	let leaves = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 21];
+	let sizes = vec![0, 1, 3, 4, 7, 8, 10, 11, 15, 16, 18, 19, 22, 23, 25, 26, 39];
+
+	// size cross-check
+	let mut actual_sizes = vec![];
+	for s in &leaves[1..] {
+		new_test_ext().execute_with(|| {
+			let mut mmr = mmr::Mmr::<mmr::storage::RuntimeStorage, crate::mock::Test, _, _>::new(0);
+			for i in 0..*s {
+				mmr.push(i);
+			}
+			actual_sizes.push(mmr.size());
+		})
+	}
+	assert_eq!(sizes[1..], actual_sizes[..]);
+}
+
+#[test]
+fn should_generate_proofs_correctly() {
+	let _ = env_logger::try_init();
+	let mut ext = new_test_ext();
+	// given
+	let num_blocks: u64 = 7;
+	ext.execute_with(|| add_blocks(num_blocks as usize));
+	ext.persist_offchain_overlay();
+
+	// Try to generate proofs now. This requires the offchain extensions to be present
+	// to retrieve full leaf data.
+	register_offchain_ext(&mut ext);
+	ext.execute_with(|| {
+		let best_block_number = frame_system::Pallet::<Test>::block_number();
+		// when generate proofs for all leaves.
+		let proofs = (1_u64..=best_block_number)
+			.into_iter()
+			.map(|block_num| crate::Pallet::<Test>::generate_proof(vec![block_num], None).unwrap())
+			.collect::<Vec<_>>();
+		// when generate historical proofs for all leaves
+		let historical_proofs = (1_u64..best_block_number)
+			.into_iter()
+			.map(|block_num| {
+				let mut proofs = vec![];
+				for historical_best_block in block_num..=num_blocks {
+					proofs.push(
+						crate::Pallet::<Test>::generate_proof(
+							vec![block_num],
+							Some(historical_best_block),
+						)
+						.unwrap(),
+					)
+				}
+				proofs
+			})
+			.collect::<Vec<_>>();
+
+		// then
+		assert_eq!(
+			proofs[0],
+			(
+				vec![Compact::new(((0, H256::repeat_byte(1)).into(), LeafData::new(1).into(),))],
+				Proof {
+					leaf_indices: vec![0],
+					leaf_count: 7,
+					items: vec![
+						hex("ad4cbc033833612ccd4626d5f023b9dfc50a35e838514dd1f3c86f8506728705"),
+						hex("cb24f4614ad5b2a5430344c99545b421d9af83c46fd632d70a332200884b4d46"),
+						hex("dca421199bdcc55bb773c6b6967e8d16675de69062b52285ca63685241fdf626"),
+					],
+				}
+			)
+		);
+		assert_eq!(
+			historical_proofs[0][0],
+			(
+				vec![Compact::new(((0, H256::repeat_byte(1)).into(), LeafData::new(1).into(),))],
+				Proof { leaf_indices: vec![0], leaf_count: 1, items: vec![] }
+			)
+		);
+
+		//       D
+		//     /   \
+		//    /     \
+		//   A       B       C
+		//  / \     / \     / \
+		// 1   2   3   4   5   6  7
+		//
+		// we're proving 3 => we need { 4, A, C++7 }
+		assert_eq!(
+			proofs[2],
+			(
+				vec![Compact::new(((2, H256::repeat_byte(3)).into(), LeafData::new(3).into(),))],
+				Proof {
+					leaf_indices: vec![2],
+					leaf_count: 7,
+					items: vec![
+						hex("1b14c1dc7d3e4def11acdf31be0584f4b85c3673f1ff72a3af467b69a3b0d9d0"),
+						hex("672c04a9cd05a644789d769daa552d35d8de7c33129f8a7cbf49e595234c4854"),
+						hex("dca421199bdcc55bb773c6b6967e8d16675de69062b52285ca63685241fdf626"),
+					],
+				}
+			)
+		);
+		//   A
+		//  / \
+		// 1   2   3
+		//
+		// we're proving 3 => we need { A }
+		assert_eq!(
+			historical_proofs[2][0],
+			(
+				vec![Compact::new(((2, H256::repeat_byte(3)).into(), LeafData::new(3).into(),))],
+				Proof {
+					leaf_indices: vec![2],
+					leaf_count: 3,
+					items: vec![hex(
+						"672c04a9cd05a644789d769daa552d35d8de7c33129f8a7cbf49e595234c4854"
+					)],
+				}
+			)
+		);
+		//       D
+		//     /   \
+		//    /     \
+		//   A       B
+		//  / \     / \
+		// 1   2   3   4   5
+		// we're proving 3 => we need { 4, A, 5 }
+		assert_eq!(
+			historical_proofs[2][2],
+			(
+				vec![Compact::new(((2, H256::repeat_byte(3)).into(), LeafData::new(3).into(),))],
+				Proof {
+					leaf_indices: vec![2],
+					leaf_count: 5,
+					items: vec![
+						hex("1b14c1dc7d3e4def11acdf31be0584f4b85c3673f1ff72a3af467b69a3b0d9d0"),
+						hex("672c04a9cd05a644789d769daa552d35d8de7c33129f8a7cbf49e595234c4854"),
+						hex("3b031d22e24f1126c8f7d2f394b663f9b960ed7abbedb7152e17ce16112656d0")
+					],
+				}
+			)
+		);
+		assert_eq!(historical_proofs[2][4], proofs[2]);
+
+		assert_eq!(
+			proofs[4],
+			(
+				// NOTE: the leaf index is equivalent to the block number(in this case 5) - 1
+				vec![Compact::new(((4, H256::repeat_byte(5)).into(), LeafData::new(5).into(),))],
+				Proof {
+					leaf_indices: vec![4],
+					leaf_count: 7,
+					items: vec![
+						hex("ae88a0825da50e953e7a359c55fe13c8015e48d03d301b8bdfc9193874da9252"),
+						hex("8ed25570209d8f753d02df07c1884ddb36a3d9d4770e4608b188322151c657fe"),
+						hex("611c2174c6164952a66d985cfe1ec1a623794393e3acff96b136d198f37a648c"),
+					],
+				}
+			)
+		);
+		assert_eq!(
+			historical_proofs[4][0],
+			(
+				vec![Compact::new(((4, H256::repeat_byte(5)).into(), LeafData::new(5).into(),))],
+				Proof {
+					leaf_indices: vec![4],
+					leaf_count: 5,
+					items: vec![hex(
+						"ae88a0825da50e953e7a359c55fe13c8015e48d03d301b8bdfc9193874da9252"
+					),],
+				}
+			)
+		);
+		assert_eq!(historical_proofs[4][2], proofs[4]);
+
+		assert_eq!(
+			proofs[6],
+			(
+				vec![Compact::new(((6, H256::repeat_byte(7)).into(), LeafData::new(7).into(),))],
+				Proof {
+					leaf_indices: vec![6],
+					leaf_count: 7,
+					items: vec![
+						hex("ae88a0825da50e953e7a359c55fe13c8015e48d03d301b8bdfc9193874da9252"),
+						hex("7e4316ae2ebf7c3b6821cb3a46ca8b7a4f9351a9b40fcf014bb0a4fd8e8f29da"),
+					],
+				}
+			)
+		);
+		assert_eq!(historical_proofs[5][1], proofs[5]);
+	});
+}
+
+#[test]
+fn should_generate_batch_proof_correctly() {
+	let _ = env_logger::try_init();
+	let mut ext = new_test_ext();
+	// given
+	ext.execute_with(|| add_blocks(7));
+	ext.persist_offchain_overlay();
+
+	// Try to generate proofs now. This requires the offchain extensions to be present
+	// to retrieve full leaf data.
+	register_offchain_ext(&mut ext);
+	ext.execute_with(|| {
+		// when generate proofs for a batch of leaves
+		let (.., proof) = crate::Pallet::<Test>::generate_proof(vec![1, 5, 6], None).unwrap();
+		// then
+		assert_eq!(
+			proof,
+			Proof {
+				// the leaf indices are equivalent to the above specified block numbers - 1.
+				leaf_indices: vec![0, 4, 5],
+				leaf_count: 7,
+				items: vec![
+					hex("ad4cbc033833612ccd4626d5f023b9dfc50a35e838514dd1f3c86f8506728705"),
+					hex("cb24f4614ad5b2a5430344c99545b421d9af83c46fd632d70a332200884b4d46"),
+					hex("611c2174c6164952a66d985cfe1ec1a623794393e3acff96b136d198f37a648c"),
+				],
+			}
+		);
+
+		// when generate historical proofs for a batch of leaves
+		let (.., historical_proof) =
+			crate::Pallet::<Test>::generate_proof(vec![1, 5, 6], Some(6)).unwrap();
+		// then
+		assert_eq!(
+			historical_proof,
+			Proof {
+				leaf_indices: vec![0, 4, 5],
+				leaf_count: 6,
+				items: vec![
+					hex("ad4cbc033833612ccd4626d5f023b9dfc50a35e838514dd1f3c86f8506728705"),
+					hex("cb24f4614ad5b2a5430344c99545b421d9af83c46fd632d70a332200884b4d46"),
+				],
+			}
+		);
+
+		// when generate historical proofs for a batch of leaves
+		let (.., historical_proof) =
+			crate::Pallet::<Test>::generate_proof(vec![1, 5, 6], None).unwrap();
+		// then
+		assert_eq!(historical_proof, proof);
+	});
+}
+
+#[test]
+fn should_verify() {
+	let _ = env_logger::try_init();
+
+	// Start off with chain initialisation and storing indexing data off-chain
+	// (MMR Leafs)
+	let mut ext = new_test_ext();
+	ext.execute_with(|| add_blocks(7));
+	ext.persist_offchain_overlay();
+
+	// Try to generate proof now. This requires the offchain extensions to be present
+	// to retrieve full leaf data.
+	register_offchain_ext(&mut ext);
+	let (leaves, proof5) = ext.execute_with(|| {
+		// when
+		crate::Pallet::<Test>::generate_proof(vec![5], None).unwrap()
+	});
+	let (simple_historical_leaves, simple_historical_proof5) = ext.execute_with(|| {
+		// when
+		crate::Pallet::<Test>::generate_proof(vec![5], Some(6)).unwrap()
+	});
+	let (advanced_historical_leaves, advanced_historical_proof5) = ext.execute_with(|| {
+		// when
+		crate::Pallet::<Test>::generate_proof(vec![5], Some(7)).unwrap()
+	});
+
+	ext.execute_with(|| {
+		add_blocks(7);
+		// then
+		assert_eq!(crate::Pallet::<Test>::verify_leaves(leaves, proof5), Ok(()));
+		assert_eq!(
+			crate::Pallet::<Test>::verify_leaves(
+				simple_historical_leaves,
+				simple_historical_proof5
+			),
+			Ok(())
+		);
+		assert_eq!(
+			crate::Pallet::<Test>::verify_leaves(
+				advanced_historical_leaves,
+				advanced_historical_proof5
+			),
+			Ok(())
+		);
+	});
+}
+
+#[test]
+fn should_verify_batch_proofs() {
+	fn generate_and_verify_batch_proof(
+		ext: &mut sp_io::TestExternalities,
+		block_numbers: &Vec<u64>,
+		blocks_to_add: usize,
+	) {
+		let (leaves, proof) = ext.execute_with(|| {
+			crate::Pallet::<Test>::generate_proof(block_numbers.to_vec(), None).unwrap()
+		});
+
+		let max_block_number = ext.execute_with(|| frame_system::Pallet::<Test>::block_number());
+		let min_block_number = block_numbers.iter().max().unwrap();
+
+		// generate all possible historical proofs for the given blocks
+		let historical_proofs = (*min_block_number..=max_block_number)
+			.map(|best_block| {
+				ext.execute_with(|| {
+					crate::Pallet::<Test>::generate_proof(block_numbers.to_vec(), Some(best_block))
+						.unwrap()
+				})
+			})
+			.collect::<Vec<_>>();
+
+		ext.execute_with(|| {
+			add_blocks(blocks_to_add);
+			// then
+			assert_eq!(crate::Pallet::<Test>::verify_leaves(leaves, proof), Ok(()));
+			historical_proofs.iter().for_each(|(leaves, proof)| {
+				assert_eq!(
+					crate::Pallet::<Test>::verify_leaves(leaves.clone(), proof.clone()),
+					Ok(())
+				);
+			});
+		})
+	}
+
+	let _ = env_logger::try_init();
+
+	use itertools::Itertools;
+
+	let mut ext = new_test_ext();
+	// require the offchain extensions to be present
+	// to retrieve full leaf data when generating proofs
+	register_offchain_ext(&mut ext);
+
+	// verify that up to n=10, valid proofs are generated for all possible block number
+	// combinations.
+	for n in 1..=10 {
+		ext.execute_with(|| new_block());
+		ext.persist_offchain_overlay();
+
+		// generate powerset (skipping empty set) of all possible block number combinations for mmr
+		// size n.
+		let blocks_set: Vec<Vec<u64>> = (1..=n).into_iter().powerset().skip(1).collect();
+
+		blocks_set.iter().for_each(|blocks_subset| {
+			generate_and_verify_batch_proof(&mut ext, &blocks_subset, 0);
+			ext.persist_offchain_overlay();
+		});
+	}
+
+	// verify that up to n=15, valid proofs are generated for all possible 2-block number
+	// combinations.
+	for n in 11..=15 {
+		ext.execute_with(|| new_block());
+		ext.persist_offchain_overlay();
+
+		// generate all possible 2-block number combinations for mmr size n.
+		let blocks_set: Vec<Vec<u64>> = (1..=n).into_iter().combinations(2).collect();
+
+		blocks_set.iter().for_each(|blocks_subset| {
+			generate_and_verify_batch_proof(&mut ext, &blocks_subset, 0);
+			ext.persist_offchain_overlay();
+		});
+	}
+
+	generate_and_verify_batch_proof(&mut ext, &vec![8, 12], 20);
+	ext.execute_with(|| add_blocks(1000));
+	ext.persist_offchain_overlay();
+	generate_and_verify_batch_proof(&mut ext, &vec![8, 12, 100, 800], 100);
+}
+
+#[test]
+fn verification_should_be_stateless() {
+	let _ = env_logger::try_init();
+
+	// Start off with chain initialisation and storing indexing data off-chain
+	// (MMR Leafs)
+	let mut ext = new_test_ext();
+	let (root_6, root_7) = ext.execute_with(|| {
+		add_blocks(6);
+		let root_6 = crate::Pallet::<Test>::mmr_root_hash();
+		add_blocks(1);
+		let root_7 = crate::Pallet::<Test>::mmr_root_hash();
+		(root_6, root_7)
+	});
+	ext.persist_offchain_overlay();
+
+	// Try to generate proof now. This requires the offchain extensions to be present
+	// to retrieve full leaf data.
+	register_offchain_ext(&mut ext);
+	let (leaves, proof5) = ext.execute_with(|| {
+		// when
+		crate::Pallet::<Test>::generate_proof(vec![5], None).unwrap()
+	});
+	let (_, historical_proof5) = ext.execute_with(|| {
+		// when
+		crate::Pallet::<Test>::generate_proof(vec![5], Some(6)).unwrap()
+	});
+
+	// Verify proof without relying on any on-chain data.
+	let leaf = crate::primitives::DataOrHash::Data(leaves[0].clone());
+	assert_eq!(
+		crate::verify_leaves_proof::<<Test as Config>::Hashing, _>(
+			root_7,
+			vec![leaf.clone()],
+			proof5
+		),
+		Ok(())
+	);
+	assert_eq!(
+		crate::verify_leaves_proof::<<Test as Config>::Hashing, _>(
+			root_6,
+			vec![leaf],
+			historical_proof5
+		),
+		Ok(())
+	);
+}
+
+#[test]
+fn should_verify_batch_proof_statelessly() {
+	let _ = env_logger::try_init();
+
+	// Start off with chain initialisation and storing indexing data off-chain
+	// (MMR Leafs)
+	let mut ext = new_test_ext();
+	let (root_6, root_7) = ext.execute_with(|| {
+		add_blocks(6);
+		let root_6 = crate::Pallet::<Test>::mmr_root_hash();
+		add_blocks(1);
+		let root_7 = crate::Pallet::<Test>::mmr_root_hash();
+		(root_6, root_7)
+	});
+	ext.persist_offchain_overlay();
+
+	// Try to generate proof now. This requires the offchain extensions to be present
+	// to retrieve full leaf data.
+	register_offchain_ext(&mut ext);
+	let (leaves, proof) = ext.execute_with(|| {
+		// when
+		crate::Pallet::<Test>::generate_proof(vec![1, 4, 5], None).unwrap()
+	});
+	let (historical_leaves, historical_proof) = ext.execute_with(|| {
+		// when
+		crate::Pallet::<Test>::generate_proof(vec![1, 4, 5], Some(6)).unwrap()
+	});
+
+	// Verify proof without relying on any on-chain data.
+	assert_eq!(
+		crate::verify_leaves_proof::<<Test as Config>::Hashing, _>(
+			root_7,
+			leaves
+				.into_iter()
+				.map(|leaf| crate::primitives::DataOrHash::Data(leaf))
+				.collect(),
+			proof
+		),
+		Ok(())
+	);
+	assert_eq!(
+		crate::verify_leaves_proof::<<Test as Config>::Hashing, _>(
+			root_6,
+			historical_leaves
+				.into_iter()
+				.map(|leaf| crate::primitives::DataOrHash::Data(leaf))
+				.collect(),
+			historical_proof
+		),
+		Ok(())
+	);
+}
+
+#[test]
+fn should_verify_on_the_next_block_since_there_is_no_pruning_yet() {
+	let _ = env_logger::try_init();
+	let mut ext = new_test_ext();
+	// given
+	ext.execute_with(|| add_blocks(7));
+
+	ext.persist_offchain_overlay();
+	register_offchain_ext(&mut ext);
+
+	ext.execute_with(|| {
+		// when
+		let (leaves, proof5) = crate::Pallet::<Test>::generate_proof(vec![5], None).unwrap();
+		new_block();
+
+		// then
+		assert_eq!(crate::Pallet::<Test>::verify_leaves(leaves, proof5), Ok(()));
+	});
+}
+
+#[test]
+fn should_verify_canonicalized() {
+	use frame_support::traits::Hooks;
+	let _ = env_logger::try_init();
+
+	// How deep is our fork-aware storage (in terms of blocks/leaves, nodes will be more).
+	let block_hash_size: u64 = <Test as frame_system::Config>::BlockHashCount::get();
+
+	// Start off with chain initialisation and storing indexing data off-chain.
+	// Create twice as many leaf entries than our fork-aware capacity,
+	// resulting in ~half of MMR storage to use canonical keys and the other half fork-aware keys.
+	// Verify that proofs can be generated (using leaves and nodes from full set) and verified.
+	let mut ext = new_test_ext();
+	register_offchain_ext(&mut ext);
+	for blocknum in 0u32..(2 * block_hash_size).try_into().unwrap() {
+		ext.execute_with(|| {
+			new_block();
+			<Pallet<Test> as Hooks<BlockNumber>>::offchain_worker(blocknum.into());
+		});
+		ext.persist_offchain_overlay();
+	}
+
+	// Generate proofs for some blocks.
+	let (leaves, proofs) =
+		ext.execute_with(|| crate::Pallet::<Test>::generate_proof(vec![1, 4, 5, 7], None).unwrap());
+	// Verify all previously generated proofs.
+	ext.execute_with(|| {
+		assert_eq!(crate::Pallet::<Test>::verify_leaves(leaves, proofs), Ok(()));
+	});
+
+	// Generate proofs for some new blocks.
+	let (leaves, proofs) = ext.execute_with(|| {
+		crate::Pallet::<Test>::generate_proof(vec![block_hash_size + 7], None).unwrap()
+	});
+	// Add some more blocks then verify all previously generated proofs.
+	ext.execute_with(|| {
+		add_blocks(7);
+		assert_eq!(crate::Pallet::<Test>::verify_leaves(leaves, proofs), Ok(()));
+	});
+}
+
+#[test]
+fn does_not_panic_when_generating_historical_proofs() {
+	let _ = env_logger::try_init();
+	let mut ext = new_test_ext();
+
+	// given 7 blocks (7 MMR leaves)
+	ext.execute_with(|| add_blocks(7));
+	ext.persist_offchain_overlay();
+
+	// Try to generate historical proof with invalid arguments. This requires the offchain
+	// extensions to be present to retrieve full leaf data.
+	register_offchain_ext(&mut ext);
+	ext.execute_with(|| {
+		// when leaf index is invalid
+		assert_eq!(crate::Pallet::<Test>::generate_proof(vec![10], None), Err(Error::LeafNotFound),);
+
+		// when leaves count is invalid
+		assert_eq!(
+			crate::Pallet::<Test>::generate_proof(vec![3], Some(100)),
+			Err(Error::GenerateProof),
+		);
+
+		// when both leaf index and leaves count are invalid
+		assert_eq!(
+			crate::Pallet::<Test>::generate_proof(vec![10], Some(100)),
+			Err(Error::LeafNotFound),
+		);
+	});
+}
diff --git a/substrate/frame/message-queue/Cargo.toml b/substrate/frame/message-queue/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4fe2b4636667d6c522dd0d0e72492c2858721af6
--- /dev/null
+++ b/substrate/frame/message-queue/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+name = "pallet-message-queue"
+version = "7.0.0-dev"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to queue and process messages"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-weights = { version = "20.0.0", default-features = false, path = "../../primitives/weights" }
+
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+
+[dev-dependencies]
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+rand = "0.8.5"
+rand_distr = "0.4.3"
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-tracing/std",
+	"sp-weights/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/message-queue/src/benchmarking.rs b/substrate/frame/message-queue/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bbd321ceadd1abd622eff7c342170be4cf6b1376
--- /dev/null
+++ b/substrate/frame/message-queue/src/benchmarking.rs
@@ -0,0 +1,282 @@
+// 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.
+
+//! Benchmarking for the message queue pallet.
+
+#![cfg(feature = "runtime-benchmarks")]
+#![allow(unused_assignments)] // Needed for `ready_ring_knit`.
+
+use super::{mock_helpers::*, Pallet as MessageQueue, *};
+
+use frame_benchmarking::v2::*;
+use frame_support::traits::Get;
+use frame_system::RawOrigin;
+use sp_std::prelude::*;
+
+#[benchmarks(
+	where
+		<<T as Config>::MessageProcessor as ProcessMessage>::Origin: From<u32> + PartialEq,
+		<T as Config>::Size: From<u32>,
+		// NOTE: We need to generate multiple origins, therefore Origin is `From<u32>`. The
+		// `PartialEq` is for asserting the outcome of the ring (un)knitting and *could* be
+		// removed if really necessary.
+)]
+mod benchmarks {
+	use super::*;
+
+	// Worst case path of `ready_ring_knit`.
+	#[benchmark]
+	fn ready_ring_knit() {
+		let mid: MessageOriginOf<T> = 1.into();
+		build_ring::<T>(&[0.into(), mid.clone(), 2.into()]);
+		unknit::<T>(&mid);
+		assert_ring::<T>(&[0.into(), 2.into()]);
+		let mut neighbours = None;
+
+		#[block]
+		{
+			neighbours = MessageQueue::<T>::ready_ring_knit(&mid).ok();
+		}
+
+		// The neighbours needs to be modified manually.
+		BookStateFor::<T>::mutate(&mid, |b| b.ready_neighbours = neighbours);
+		assert_ring::<T>(&[0.into(), 2.into(), mid]);
+	}
+
+	// Worst case path of `ready_ring_unknit`.
+	#[benchmark]
+	fn ready_ring_unknit() {
+		build_ring::<T>(&[0.into(), 1.into(), 2.into()]);
+		assert_ring::<T>(&[0.into(), 1.into(), 2.into()]);
+		let o: MessageOriginOf<T> = 0.into();
+		let neighbours = BookStateFor::<T>::get(&o).ready_neighbours.unwrap();
+
+		#[block]
+		{
+			MessageQueue::<T>::ready_ring_unknit(&o, neighbours);
+		}
+
+		assert_ring::<T>(&[1.into(), 2.into()]);
+	}
+
+	// `service_queues` without any queue processing.
+	#[benchmark]
+	fn service_queue_base() {
+		#[block]
+		{
+			MessageQueue::<T>::service_queue(0.into(), &mut WeightMeter::max_limit(), Weight::MAX);
+		}
+	}
+
+	// `service_page` without any message processing but with page completion.
+	#[benchmark]
+	fn service_page_base_completion() {
+		let origin: MessageOriginOf<T> = 0.into();
+		let page = PageOf::<T>::default();
+		Pages::<T>::insert(&origin, 0, &page);
+		let mut book_state = single_page_book::<T>();
+		let mut meter = WeightMeter::max_limit();
+		let limit = Weight::MAX;
+
+		#[block]
+		{
+			MessageQueue::<T>::service_page(&origin, &mut book_state, &mut meter, limit);
+		}
+	}
+
+	// `service_page` without any message processing and without page completion.
+	#[benchmark]
+	fn service_page_base_no_completion() {
+		let origin: MessageOriginOf<T> = 0.into();
+		let mut page = PageOf::<T>::default();
+		// Mock the storage such that `is_complete` returns `false` but `peek_first` returns `None`.
+		page.first = 1.into();
+		page.remaining = 1.into();
+		Pages::<T>::insert(&origin, 0, &page);
+		let mut book_state = single_page_book::<T>();
+		let mut meter = WeightMeter::max_limit();
+		let limit = Weight::MAX;
+
+		#[block]
+		{
+			MessageQueue::<T>::service_page(&origin, &mut book_state, &mut meter, limit);
+		}
+	}
+
+	// Processing a single message from a page.
+	#[benchmark]
+	fn service_page_item() {
+		let msg = vec![1u8; MaxMessageLenOf::<T>::get() as usize];
+		let mut page = page::<T>(&msg.clone());
+		let mut book = book_for::<T>(&page);
+		assert!(page.peek_first().is_some(), "There is one message");
+		let mut weight = WeightMeter::max_limit();
+
+		#[block]
+		{
+			let status = MessageQueue::<T>::service_page_item(
+				&0u32.into(),
+				0,
+				&mut book,
+				&mut page,
+				&mut weight,
+				Weight::MAX,
+			);
+			assert_eq!(status, ItemExecutionStatus::Executed(true));
+		}
+
+		// Check that it was processed.
+		assert_last_event::<T>(
+			Event::Processed {
+				id: sp_io::hashing::blake2_256(&msg),
+				origin: 0.into(),
+				weight_used: 1.into_weight(),
+				success: true,
+			}
+			.into(),
+		);
+		let (_, processed, _) = page.peek_index(0).unwrap();
+		assert!(processed);
+		assert_eq!(book.message_count, 0);
+	}
+
+	// Worst case for calling `bump_service_head`.
+	#[benchmark]
+	fn bump_service_head() {
+		setup_bump_service_head::<T>(0.into(), 10.into());
+		let mut weight = WeightMeter::max_limit();
+
+		#[block]
+		{
+			MessageQueue::<T>::bump_service_head(&mut weight);
+		}
+
+		assert_eq!(ServiceHead::<T>::get().unwrap(), 10u32.into());
+		assert_eq!(weight.consumed(), T::WeightInfo::bump_service_head());
+	}
+
+	#[benchmark]
+	fn reap_page() {
+		// Mock the storage to get a *cullable* but not *reapable* page.
+		let origin: MessageOriginOf<T> = 0.into();
+		let mut book = single_page_book::<T>();
+		let (page, msgs) = full_page::<T>();
+
+		for p in 0..T::MaxStale::get() * T::MaxStale::get() {
+			if p == 0 {
+				Pages::<T>::insert(&origin, p, &page);
+			}
+			book.end += 1;
+			book.count += 1;
+			book.message_count += msgs as u64;
+			book.size += page.remaining_size.into() as u64;
+		}
+		book.begin = book.end - T::MaxStale::get();
+		BookStateFor::<T>::insert(&origin, &book);
+		assert!(Pages::<T>::contains_key(&origin, 0));
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(whitelisted_caller()), 0u32.into(), 0);
+
+		assert_last_event::<T>(Event::PageReaped { origin: 0.into(), index: 0 }.into());
+		assert!(!Pages::<T>::contains_key(&origin, 0));
+	}
+
+	// Worst case for `execute_overweight` where the page is removed as completed.
+	//
+	// The worst case occurs when executing the last message in a page of which all are skipped
+	// since it is using `peek_index` which has linear complexities.
+	#[benchmark]
+	fn execute_overweight_page_removed() {
+		let origin: MessageOriginOf<T> = 0.into();
+		let (mut page, msgs) = full_page::<T>();
+		// Skip all messages.
+		for _ in 1..msgs {
+			page.skip_first(true);
+		}
+		page.skip_first(false);
+		let book = book_for::<T>(&page);
+		Pages::<T>::insert(&origin, 0, &page);
+		BookStateFor::<T>::insert(&origin, &book);
+
+		#[block]
+		{
+			MessageQueue::<T>::execute_overweight(
+				RawOrigin::Signed(whitelisted_caller()).into(),
+				0u32.into(),
+				0u32,
+				((msgs - 1) as u32).into(),
+				Weight::MAX,
+			)
+			.unwrap();
+		}
+
+		assert_last_event::<T>(
+			Event::Processed {
+				id: sp_io::hashing::blake2_256(&((msgs - 1) as u32).encode()),
+				origin: 0.into(),
+				weight_used: Weight::from_parts(1, 1),
+				success: true,
+			}
+			.into(),
+		);
+		assert!(!Pages::<T>::contains_key(&origin, 0), "Page must be removed");
+	}
+
+	// Worst case for `execute_overweight` where the page is updated.
+	#[benchmark]
+	fn execute_overweight_page_updated() {
+		let origin: MessageOriginOf<T> = 0.into();
+		let (mut page, msgs) = full_page::<T>();
+		// Skip all messages.
+		for _ in 0..msgs {
+			page.skip_first(false);
+		}
+		let book = book_for::<T>(&page);
+		Pages::<T>::insert(&origin, 0, &page);
+		BookStateFor::<T>::insert(&origin, &book);
+
+		#[block]
+		{
+			MessageQueue::<T>::execute_overweight(
+				RawOrigin::Signed(whitelisted_caller()).into(),
+				0u32.into(),
+				0u32,
+				((msgs - 1) as u32).into(),
+				Weight::MAX,
+			)
+			.unwrap();
+		}
+
+		assert_last_event::<T>(
+			Event::Processed {
+				id: sp_io::hashing::blake2_256(&((msgs - 1) as u32).encode()),
+				origin: 0.into(),
+				weight_used: Weight::from_parts(1, 1),
+				success: true,
+			}
+			.into(),
+		);
+		assert!(Pages::<T>::contains_key(&origin, 0), "Page must be updated");
+	}
+
+	impl_benchmark_test_suite! {
+		MessageQueue,
+		crate::mock::new_test_ext::<crate::integration_test::Test>(),
+		crate::integration_test::Test
+	}
+}
diff --git a/substrate/frame/message-queue/src/integration_test.rs b/substrate/frame/message-queue/src/integration_test.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a1003edf3c92f20e57142ecb978cc62cfef28a28
--- /dev/null
+++ b/substrate/frame/message-queue/src/integration_test.rs
@@ -0,0 +1,329 @@
+// 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.
+
+//! Stress tests pallet-message-queue. Defines its own runtime config to use larger constants for
+//! `HeapSize` and `MaxStale`.
+
+#![cfg(test)]
+
+use crate::{
+	mock::{
+		build_and_execute, CountingMessageProcessor, IntoWeight, MockedWeightInfo,
+		NumMessagesProcessed, YieldingQueues,
+	},
+	mock_helpers::MessageOrigin,
+	*,
+};
+
+use crate as pallet_message_queue;
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use rand_distr::Pareto;
+use sp_core::H256;
+use sp_runtime::traits::{BlakeTwo256, IdentityLookup};
+use std::collections::{BTreeMap, BTreeSet};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		MessageQueue: pallet_message_queue::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+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 = 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! {
+	pub const HeapSize: u32 = 32 * 1024;
+	pub const MaxStale: u32 = 32;
+	pub static ServiceWeight: Option<Weight> = Some(Weight::from_parts(100, 100));
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = MockedWeightInfo;
+	type MessageProcessor = CountingMessageProcessor;
+	type Size = u32;
+	type QueueChangeHandler = ();
+	type QueuePausedQuery = ();
+	type HeapSize = HeapSize;
+	type MaxStale = MaxStale;
+	type ServiceWeight = ServiceWeight;
+}
+
+/// Simulates heavy usage by enqueueing and processing large amounts of messages.
+///
+/// Best to run with `RUST_LOG=info RUSTFLAGS='-Cdebug-assertions=y' cargo test -r -p
+/// pallet-message-queue -- --ignored`.
+///
+/// # Example output
+///
+/// ```pre
+/// Enqueued 1189 messages across 176 queues. Payload 46.97 KiB    
+/// Processing 772 of 1189 messages    
+/// Enqueued 9270 messages across 1559 queues. Payload 131.85 KiB    
+/// Processing 6262 of 9687 messages    
+/// Enqueued 5025 messages across 1225 queues. Payload 100.23 KiB    
+/// Processing 1739 of 8450 messages    
+/// Enqueued 42061 messages across 6357 queues. Payload 536.29 KiB    
+/// Processing 11675 of 48772 messages    
+/// Enqueued 20253 messages across 2420 queues. Payload 288.34 KiB    
+/// Processing 28711 of 57350 messages
+/// Processing all remaining 28639 messages
+/// ```
+#[test]
+#[ignore] // Only run in the CI.
+fn stress_test_enqueue_and_service() {
+	let blocks = 20;
+	let max_queues = 10_000;
+	let max_messages_per_queue = 10_000;
+	let max_msg_len = MaxMessageLenOf::<Test>::get();
+	let mut rng = StdRng::seed_from_u64(42);
+
+	build_and_execute::<Test>(|| {
+		let mut msgs_remaining = 0;
+		for _ in 0..blocks {
+			// Start by enqueuing a large number of messages.
+			let enqueued =
+				enqueue_messages(max_queues, max_messages_per_queue, max_msg_len, &mut rng);
+			msgs_remaining += enqueued;
+
+			// Pick a fraction of all messages currently in queue and process them.
+			let processed = rng.gen_range(1..=msgs_remaining);
+			log::info!("Processing {} of all messages {}", processed, msgs_remaining);
+			process_some_messages(processed); // This also advances the block.
+			msgs_remaining -= processed;
+		}
+		log::info!("Processing all remaining {} messages", msgs_remaining);
+		process_all_messages(msgs_remaining);
+		post_conditions();
+	});
+}
+
+/// Simulates heavy usage of the suspension logic via `Yield`.
+///
+/// Best to run with `RUST_LOG=info RUSTFLAGS='-Cdebug-assertions=y' cargo test -r -p
+/// pallet-message-queue -- --ignored`.
+///
+/// # Example output
+///
+/// ```pre
+/// Enqueued 11776 messages across 2526 queues. Payload 173.94 KiB    
+/// Suspended 63 and resumed 7 queues of 2526 in total    
+/// Processing 593 messages. Resumed msgs: 11599, All msgs: 11776    
+/// Enqueued 30104 messages across 5533 queues. Payload 416.62 KiB    
+/// Suspended 24 and resumed 15 queues of 5533 in total    
+/// Processing 12841 messages. Resumed msgs: 40857, All msgs: 41287    
+/// Processing all 28016 remaining resumed messages    
+/// Resumed all 64 suspended queues    
+/// Processing all remaining 430 messages
+/// ```
+#[test]
+#[ignore] // Only run in the CI.
+fn stress_test_queue_suspension() {
+	let blocks = 20;
+	let max_queues = 10_000;
+	let max_messages_per_queue = 10_000;
+	let (max_suspend_per_block, max_resume_per_block) = (100, 50);
+	let max_msg_len = MaxMessageLenOf::<Test>::get();
+	let mut rng = StdRng::seed_from_u64(41);
+
+	build_and_execute::<Test>(|| {
+		let mut suspended = BTreeSet::<u32>::new();
+		let mut msgs_remaining = 0;
+
+		for _ in 0..blocks {
+			// Start by enqueuing a large number of messages.
+			let enqueued =
+				enqueue_messages(max_queues, max_messages_per_queue, max_msg_len, &mut rng);
+			msgs_remaining += enqueued;
+			let per_queue = msgs_per_queue();
+
+			// Suspend a random subset of queues.
+			let to_suspend = rng.gen_range(0..max_suspend_per_block).min(per_queue.len());
+			for _ in 0..to_suspend {
+				let q = rng.gen_range(0..per_queue.len());
+				suspended.insert(*per_queue.iter().nth(q).map(|(q, _)| q).unwrap());
+			}
+			// Resume a random subst of suspended queues.
+			let to_resume = rng.gen_range(0..max_resume_per_block).min(suspended.len());
+			for _ in 0..to_resume {
+				let q = rng.gen_range(0..suspended.len());
+				suspended.remove(&suspended.iter().nth(q).unwrap().clone());
+			}
+			log::info!(
+				"Suspended {} and resumed {} queues of {} in total",
+				to_suspend,
+				to_resume,
+				per_queue.len()
+			);
+			YieldingQueues::set(suspended.iter().map(|q| MessageOrigin::Everywhere(*q)).collect());
+
+			// Pick a fraction of all messages currently in queue and process them.
+			let resumed_messages =
+				per_queue.iter().filter(|(q, _)| !suspended.contains(q)).map(|(_, n)| n).sum();
+			let processed = rng.gen_range(1..=resumed_messages);
+			log::info!(
+				"Processing {} messages. Resumed msgs: {}, All msgs: {}",
+				processed,
+				resumed_messages,
+				msgs_remaining
+			);
+			process_some_messages(processed); // This also advances the block.
+			msgs_remaining -= processed;
+		}
+		let per_queue = msgs_per_queue();
+		let resumed_messages =
+			per_queue.iter().filter(|(q, _)| !suspended.contains(q)).map(|(_, n)| n).sum();
+		log::info!("Processing all {} remaining resumed messages", resumed_messages);
+		process_all_messages(resumed_messages);
+		msgs_remaining -= resumed_messages;
+
+		let resumed = YieldingQueues::take();
+		log::info!("Resumed all {} suspended queues", resumed.len());
+		log::info!("Processing all remaining {} messages", msgs_remaining);
+		process_all_messages(msgs_remaining);
+		post_conditions();
+	});
+}
+
+/// How many messages are in each queue.
+fn msgs_per_queue() -> BTreeMap<u32, u32> {
+	let mut per_queue = BTreeMap::new();
+	for (o, q) in BookStateFor::<Test>::iter() {
+		let MessageOrigin::Everywhere(o) = o else {
+			unreachable!();
+		};
+		per_queue.insert(o, q.message_count as u32);
+	}
+	per_queue
+}
+
+/// Enqueue a random number of random messages into a random number of queues.
+///
+/// Returns the total number of enqueued messages, their combined length and the number of messages
+/// per queue.
+fn enqueue_messages(
+	max_queues: u32,
+	max_per_queue: u32,
+	max_msg_len: u32,
+	rng: &mut StdRng,
+) -> u32 {
+	let num_queues = rng.gen_range(1..max_queues);
+	let mut num_messages = 0;
+	let mut total_msg_len = 0;
+	for origin in 0..num_queues {
+		let num_messages_per_queue =
+			(rng.sample(Pareto::new(1.0, 1.1).unwrap()) as u32).min(max_per_queue);
+
+		for m in 0..num_messages_per_queue {
+			let mut message = format!("{}:{}", &origin, &m).into_bytes();
+			let msg_len = (rng.sample(Pareto::new(1.0, 1.0).unwrap()) as u32)
+				.clamp(message.len() as u32, max_msg_len);
+			message.resize(msg_len as usize, 0);
+			MessageQueue::enqueue_message(
+				BoundedSlice::defensive_truncate_from(&message),
+				origin.into(),
+			);
+			total_msg_len += msg_len;
+		}
+		num_messages += num_messages_per_queue;
+	}
+	log::info!(
+		"Enqueued {} messages across {} queues. Payload {:.2} KiB",
+		num_messages,
+		num_queues,
+		total_msg_len as f64 / 1024.0
+	);
+	num_messages
+}
+
+/// Process the number of messages.
+fn process_some_messages(num_msgs: u32) {
+	let weight = (num_msgs as u64).into_weight();
+	ServiceWeight::set(Some(weight));
+	let consumed = next_block();
+
+	assert_eq!(consumed, weight, "\n{}", MessageQueue::debug_info());
+	assert_eq!(NumMessagesProcessed::take(), num_msgs as usize);
+}
+
+/// Process all remaining messages and assert their number.
+fn process_all_messages(expected: u32) {
+	ServiceWeight::set(Some(Weight::MAX));
+	let consumed = next_block();
+
+	assert_eq!(consumed, Weight::from_all(expected as u64));
+	assert_eq!(NumMessagesProcessed::take(), expected as usize);
+}
+
+/// Returns the weight consumed by `MessageQueue::on_initialize()`.
+fn next_block() -> Weight {
+	MessageQueue::on_finalize(System::block_number());
+	System::on_finalize(System::block_number());
+	System::set_block_number(System::block_number() + 1);
+	System::on_initialize(System::block_number());
+	MessageQueue::on_initialize(System::block_number())
+}
+
+/// Assert that the pallet is in the expected post state.
+fn post_conditions() {
+	// All queues are empty.
+	for (_, book) in BookStateFor::<Test>::iter() {
+		assert!(book.end >= book.begin);
+		assert_eq!(book.count, 0);
+		assert_eq!(book.size, 0);
+		assert_eq!(book.message_count, 0);
+		assert!(book.ready_neighbours.is_none());
+	}
+	// No pages remain.
+	assert_eq!(Pages::<Test>::iter().count(), 0);
+	// Service head is gone.
+	assert!(ServiceHead::<Test>::get().is_none());
+	// This still works fine.
+	assert_eq!(MessageQueue::service_queues(Weight::MAX), Weight::zero(), "Nothing left");
+	next_block();
+}
diff --git a/substrate/frame/message-queue/src/lib.rs b/substrate/frame/message-queue/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5acc3e9d5a1385245e5fbe95305fd24ad2436cd5
--- /dev/null
+++ b/substrate/frame/message-queue/src/lib.rs
@@ -0,0 +1,1469 @@
+// 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.
+
+//! # Generalized Message Queue Pallet
+//!
+//! Provides generalized message queuing and processing capabilities on a per-queue basis for
+//! arbitrary use-cases.
+//!
+//! # Design Goals
+//!
+//! 1. Minimal assumptions about `Message`s and `MessageOrigin`s. Both should be MEL bounded blobs.
+//!  This ensures the generality and reusability of the pallet.
+//! 2. Well known and tightly limited pre-dispatch PoV weights, especially for message execution.
+//!  This is paramount for the success of the pallet since message execution is done in
+//!  `on_initialize` which must _never_ under-estimate its PoV weight. It also needs a frugal PoV
+//!  footprint since PoV is scarce and this is (possibly) done in every block. This must also hold
+//! in  the presence of unpredictable message size distributions.
+//! 3. Usable as XCMP, DMP and UMP message/dispatch queue - possibly through adapter types.
+//!
+//! # Design
+//!
+//! The pallet has means to enqueue, store and process messages. This is implemented by having
+//! *queues* which store enqueued messages and can be *served* to process said messages. A queue is
+//! identified by its origin in the `BookStateFor`. Each message has an origin which defines into
+//! which queue it will be stored. Messages are stored by being appended to the last [`Page`] of a
+//! book. Each book keeps track of its pages by indexing `Pages`. The `ReadyRing` contains all
+//! queues which hold at least one unprocessed message and are thereby *ready* to be serviced. The
+//! `ServiceHead` indicates which *ready* queue is the next to be serviced.
+//! The pallet implements [`frame_support::traits::EnqueueMessage`],
+//! [`frame_support::traits::ServiceQueues`] and has [`frame_support::traits::ProcessMessage`] and
+//! [`OnQueueChanged`] hooks to communicate with the outside world.
+//!
+//! NOTE: The storage items are not linked since they are not public.
+//!
+//! **Message Execution**
+//!
+//! Executing a message is offloaded to the [`Config::MessageProcessor`] which contains the actual
+//! logic of how to handle the message since they are blobs. A message can be temporarily or
+//! permanently overweight. The pallet will perpetually try to execute a temporarily overweight
+//! message. A permanently overweight message is skipped and must be executed manually.
+//!
+//! **Pagination**
+//!
+//! Queues are stored in a *paged* manner by splitting their messages into [`Page`]s. This results
+//! in a lot of complexity when implementing the pallet but is completely necessary to achieve the
+//! second #[Design Goal](design-goals). The problem comes from the fact a message can *possibly* be
+//! quite large, lets say 64KiB. This then results in a *MEL* of at least 64KiB which results in a
+//! PoV of at least 64KiB. Now we have the assumption that most messages are much shorter than their
+//! maximum allowed length. This would result in most messages having a pre-dispatch PoV size which
+//! is much larger than their post-dispatch PoV size, possibly by a factor of thousand. Disregarding
+//! this observation would cripple the processing power of the pallet since it cannot straighten out
+//! this discrepancy at runtime. Conceptually, the implementation is packing as many messages into a
+//! single bounded vec, as actually fit into the bounds. This reduces the wasted PoV.
+//!
+//! **Page Data Layout**
+//!
+//! A Page contains a heap which holds all its messages. The heap is built by concatenating
+//! `(ItemHeader, Message)` pairs. The [`ItemHeader`] contains the length of the message which is
+//! needed for retrieving it. This layout allows for constant access time of the next message and
+//! linear access time for any message in the page. The header must remain minimal to reduce its PoV
+//! impact.
+//!
+//! **Weight Metering**
+//!
+//! The pallet utilizes the [`sp_weights::WeightMeter`] to manually track its consumption to always
+//! stay within the required limit. This implies that the message processor hook can calculate the
+//! weight of a message without executing it. This restricts the possible use-cases but is necessary
+//! since the pallet runs in `on_initialize` which has a hard weight limit. The weight meter is used
+//! in a way that `can_accrue` and `check_accrue` are always used to check the remaining weight of
+//! an operation before committing to it. The process of exiting due to insufficient weight is
+//! termed "bailing".
+//!
+//! # Scenario: Message enqueuing
+//!
+//! A message `m` is enqueued for origin `o` into queue `Q[o]` through
+//! [`frame_support::traits::EnqueueMessage::enqueue_message`]`(m, o)`.
+//!
+//! First the queue is either loaded if it exists or otherwise created with empty default values.
+//! The message is then inserted to the queue by appended it into its last `Page` or by creating a
+//! new `Page` just for `m` if it does not fit in there. The number of messages in the `Book` is
+//! incremented.
+//!
+//! `Q[o]` is now *ready* which will eventually result in `m` being processed.
+//!
+//! # Scenario: Message processing
+//!
+//! The pallet runs each block in `on_initialize` or when being manually called through
+//! [`frame_support::traits::ServiceQueues::service_queues`].
+//!
+//! First it tries to "rotate" the `ReadyRing` by one through advancing the `ServiceHead` to the
+//! next *ready* queue. It then starts to service this queue by servicing as many pages of it as
+//! possible. Servicing a page means to execute as many message of it as possible. Each executed
+//! message is marked as *processed* if the [`Config::MessageProcessor`] return Ok. An event
+//! [`Event::Processed`] is emitted afterwards. It is possible that the weight limit of the pallet
+//! will never allow a specific message to be executed. In this case it remains as unprocessed and
+//! is skipped. This process stops if either there are no more messages in the queue or the
+//! remaining weight became insufficient to service this queue. If there is enough weight it tries
+//! to advance to the next *ready* queue and service it. This continues until there are no more
+//! queues on which it can make progress or not enough weight to check that.
+//!
+//! # Scenario: Overweight execution
+//!
+//! A permanently over-weight message which was skipped by the message processing will never be
+//! executed automatically through `on_initialize` nor by calling
+//! [`frame_support::traits::ServiceQueues::service_queues`].
+//!
+//! Manual intervention in the form of
+//! [`frame_support::traits::ServiceQueues::execute_overweight`] is necessary. Overweight messages
+//! emit an [`Event::OverweightEnqueued`] event which can be used to extract the arguments for
+//! manual execution. This only works on permanently overweight messages. There is no guarantee that
+//! this will work since the message could be part of a stale page and be reaped before execution
+//! commences.
+//!
+//! # Terminology
+//!
+//! - `Message`: A blob of data into which the pallet has no introspection, defined as
+//! [`BoundedSlice<u8, MaxMessageLenOf<T>>`]. The message length is limited by [`MaxMessageLenOf`]
+//! which is calculated from [`Config::HeapSize`] and [`ItemHeader::max_encoded_len()`].
+//! - `MessageOrigin`: A generic *origin* of a message, defined as [`MessageOriginOf`]. The
+//! requirements for it are kept minimal to remain as generic as possible. The type is defined in
+//! [`frame_support::traits::ProcessMessage::Origin`].
+//! - `Page`: An array of `Message`s, see [`Page`]. Can never be empty.
+//! - `Book`: A list of `Page`s, see [`BookState`]. Can be empty.
+//! - `Queue`: A `Book` together with an `MessageOrigin` which can be part of the `ReadyRing`. Can
+//!   be empty.
+//! - `ReadyRing`: A double-linked list which contains all *ready* `Queue`s. It chains together the
+//!   queues via their `ready_neighbours` fields. A `Queue` is *ready* if it contains at least one
+//!   `Message` which can be processed. Can be empty.
+//! - `ServiceHead`: A pointer into the `ReadyRing` to the next `Queue` to be serviced.
+//! - (`un`)`processed`: A message is marked as *processed* after it was executed by the pallet. A
+//!   message which was either: not yet executed or could not be executed remains as `unprocessed`
+//!   which is the default state for a message after being enqueued.
+//! - `knitting`/`unknitting`: The means of adding or removing a `Queue` from the `ReadyRing`.
+//! - `MEL`: The Max Encoded Length of a type, see [`codec::MaxEncodedLen`].
+//!
+//! # Properties
+//!
+//! **Liveness - Enqueueing**
+//!
+//! It is always possible to enqueue any message for any `MessageOrigin`.
+//!
+//! **Liveness - Processing**
+//!
+//! `on_initialize` always respects its finite weight-limit.
+//!
+//! **Progress - Enqueueing**
+//!
+//! An enqueued message immediately becomes *unprocessed* and thereby eligible for execution.
+//!
+//! **Progress - Processing**
+//!
+//! The pallet will execute at least one unprocessed message per block, if there is any. Ensuring
+//! this property needs careful consideration of the concrete weights, since it is possible that the
+//! weight limit of `on_initialize` never allows for the execution of even one message; trivially if
+//! the limit is set to zero. `integrity_test` can be used to ensure that this property holds.
+//!
+//! **Fairness - Enqueuing**
+//!
+//! Enqueueing a message for a specific `MessageOrigin` does not influence the ability to enqueue a
+//! message for the same of any other `MessageOrigin`; guaranteed by **Liveness - Enqueueing**.
+//!
+//! **Fairness - Processing**
+//!
+//! The average amount of weight available for message processing is the same for each queue if the
+//! number of queues is constant. Creating a new queue must therefore be, possibly economically,
+//! expensive. Currently this is archived by having one queue per para-chain/thread, which keeps the
+//! number of queues within `O(n)` and should be "good enough".
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod integration_test;
+mod mock;
+pub mod mock_helpers;
+mod tests;
+pub mod weights;
+
+use codec::{Codec, Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	defensive,
+	pallet_prelude::*,
+	traits::{
+		DefensiveTruncateFrom, EnqueueMessage, ExecuteOverweightError, Footprint, ProcessMessage,
+		ProcessMessageError, QueuePausedQuery, ServiceQueues,
+	},
+	BoundedSlice, CloneNoBound, DefaultNoBound,
+};
+use frame_system::pallet_prelude::*;
+pub use pallet::*;
+use scale_info::TypeInfo;
+use sp_arithmetic::traits::{BaseArithmetic, Unsigned};
+use sp_runtime::{
+	traits::{One, Zero},
+	SaturatedConversion, Saturating,
+};
+use sp_std::{fmt::Debug, ops::Deref, prelude::*, vec};
+use sp_weights::WeightMeter;
+pub use weights::WeightInfo;
+
+/// Type for identifying a page.
+type PageIndex = u32;
+
+/// Data encoded and prefixed to the encoded `MessageItem`.
+#[derive(Encode, Decode, PartialEq, MaxEncodedLen, Debug)]
+pub struct ItemHeader<Size> {
+	/// The length of this item, not including the size of this header. The next item of the page
+	/// follows immediately after the payload of this item.
+	payload_len: Size,
+	/// Whether this item has been processed.
+	is_processed: bool,
+}
+
+/// A page of messages. Pages always contain at least one item.
+#[derive(
+	CloneNoBound, Encode, Decode, RuntimeDebugNoBound, DefaultNoBound, TypeInfo, MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(HeapSize))]
+#[codec(mel_bound(Size: MaxEncodedLen))]
+pub struct Page<Size: Into<u32> + Debug + Clone + Default, HeapSize: Get<Size>> {
+	/// Messages remaining to be processed; this includes overweight messages which have been
+	/// skipped.
+	remaining: Size,
+	/// The size of all remaining messages to be processed.
+	///
+	/// Includes overweight messages outside of the `first` to `last` window.
+	remaining_size: Size,
+	/// The number of items before the `first` item in this page.
+	first_index: Size,
+	/// The heap-offset of the header of the first message item in this page which is ready for
+	/// processing.
+	first: Size,
+	/// The heap-offset of the header of the last message item in this page.
+	last: Size,
+	/// The heap. If `self.offset == self.heap.len()` then the page is empty and should be deleted.
+	heap: BoundedVec<u8, IntoU32<HeapSize, Size>>,
+}
+
+impl<
+		Size: BaseArithmetic + Unsigned + Copy + Into<u32> + Codec + MaxEncodedLen + Debug + Default,
+		HeapSize: Get<Size>,
+	> Page<Size, HeapSize>
+{
+	/// Create a [`Page`] from one unprocessed message.
+	fn from_message<T: Config>(message: BoundedSlice<u8, MaxMessageLenOf<T>>) -> Self {
+		let payload_len = message.len();
+		let data_len = ItemHeader::<Size>::max_encoded_len().saturating_add(payload_len);
+		let payload_len = payload_len.saturated_into();
+		let header = ItemHeader::<Size> { payload_len, is_processed: false };
+
+		let mut heap = Vec::with_capacity(data_len);
+		header.using_encoded(|h| heap.extend_from_slice(h));
+		heap.extend_from_slice(message.deref());
+
+		Page {
+			remaining: One::one(),
+			remaining_size: payload_len,
+			first_index: Zero::zero(),
+			first: Zero::zero(),
+			last: Zero::zero(),
+			heap: BoundedVec::defensive_truncate_from(heap),
+		}
+	}
+
+	/// Try to append one message to a page.
+	fn try_append_message<T: Config>(
+		&mut self,
+		message: BoundedSlice<u8, MaxMessageLenOf<T>>,
+	) -> Result<(), ()> {
+		let pos = self.heap.len();
+		let payload_len = message.len();
+		let data_len = ItemHeader::<Size>::max_encoded_len().saturating_add(payload_len);
+		let payload_len = payload_len.saturated_into();
+		let header = ItemHeader::<Size> { payload_len, is_processed: false };
+		let heap_size: u32 = HeapSize::get().into();
+		if (heap_size as usize).saturating_sub(self.heap.len()) < data_len {
+			// Can't fit.
+			return Err(())
+		}
+
+		let mut heap = sp_std::mem::take(&mut self.heap).into_inner();
+		header.using_encoded(|h| heap.extend_from_slice(h));
+		heap.extend_from_slice(message.deref());
+		self.heap = BoundedVec::defensive_truncate_from(heap);
+		self.last = pos.saturated_into();
+		self.remaining.saturating_inc();
+		self.remaining_size.saturating_accrue(payload_len);
+		Ok(())
+	}
+
+	/// Returns the first message in the page without removing it.
+	///
+	/// SAFETY: Does not panic even on corrupted storage.
+	fn peek_first(&self) -> Option<BoundedSlice<u8, IntoU32<HeapSize, Size>>> {
+		if self.first > self.last {
+			return None
+		}
+		let f = (self.first.into() as usize).min(self.heap.len());
+		let mut item_slice = &self.heap[f..];
+		if let Ok(h) = ItemHeader::<Size>::decode(&mut item_slice) {
+			let payload_len = h.payload_len.into() as usize;
+			if payload_len <= item_slice.len() {
+				// impossible to truncate since is sliced up from `self.heap: BoundedVec<u8,
+				// HeapSize>`
+				return Some(BoundedSlice::defensive_truncate_from(&item_slice[..payload_len]))
+			}
+		}
+		defensive!("message-queue: heap corruption");
+		None
+	}
+
+	/// Point `first` at the next message, marking the first as processed if `is_processed` is true.
+	fn skip_first(&mut self, is_processed: bool) {
+		let f = (self.first.into() as usize).min(self.heap.len());
+		if let Ok(mut h) = ItemHeader::decode(&mut &self.heap[f..]) {
+			if is_processed && !h.is_processed {
+				h.is_processed = true;
+				h.using_encoded(|d| self.heap[f..f + d.len()].copy_from_slice(d));
+				self.remaining.saturating_dec();
+				self.remaining_size.saturating_reduce(h.payload_len);
+			}
+			self.first
+				.saturating_accrue(ItemHeader::<Size>::max_encoded_len().saturated_into());
+			self.first.saturating_accrue(h.payload_len);
+			self.first_index.saturating_inc();
+		}
+	}
+
+	/// Return the message with index `index` in the form of `(position, processed, message)`.
+	fn peek_index(&self, index: usize) -> Option<(usize, bool, &[u8])> {
+		let mut pos = 0;
+		let mut item_slice = &self.heap[..];
+		let header_len: usize = ItemHeader::<Size>::max_encoded_len().saturated_into();
+		for _ in 0..index {
+			let h = ItemHeader::<Size>::decode(&mut item_slice).ok()?;
+			let item_len = h.payload_len.into() as usize;
+			if item_slice.len() < item_len {
+				return None
+			}
+			item_slice = &item_slice[item_len..];
+			pos.saturating_accrue(header_len.saturating_add(item_len));
+		}
+		let h = ItemHeader::<Size>::decode(&mut item_slice).ok()?;
+		if item_slice.len() < h.payload_len.into() as usize {
+			return None
+		}
+		item_slice = &item_slice[..h.payload_len.into() as usize];
+		Some((pos, h.is_processed, item_slice))
+	}
+
+	/// Set the `is_processed` flag for the item at `pos` to be `true` if not already and decrement
+	/// the `remaining` counter of the page.
+	///
+	/// Does nothing if no [`ItemHeader`] could be decoded at the given position.
+	fn note_processed_at_pos(&mut self, pos: usize) {
+		if let Ok(mut h) = ItemHeader::<Size>::decode(&mut &self.heap[pos..]) {
+			if !h.is_processed {
+				h.is_processed = true;
+				h.using_encoded(|d| self.heap[pos..pos + d.len()].copy_from_slice(d));
+				self.remaining.saturating_dec();
+				self.remaining_size.saturating_reduce(h.payload_len);
+			}
+		}
+	}
+
+	/// Returns whether the page is *complete* which means that no messages remain.
+	fn is_complete(&self) -> bool {
+		self.remaining.is_zero()
+	}
+}
+
+/// A single link in the double-linked Ready Ring list.
+#[derive(Clone, Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebug, PartialEq)]
+pub struct Neighbours<MessageOrigin> {
+	/// The previous queue.
+	prev: MessageOrigin,
+	/// The next queue.
+	next: MessageOrigin,
+}
+
+/// The state of a queue as represented by a book of its pages.
+///
+/// Each queue has exactly one book which holds all of its pages. All pages of a book combined
+/// contain all of the messages of its queue; hence the name *Book*.
+/// Books can be chained together in a double-linked fashion through their `ready_neighbours` field.
+#[derive(Clone, Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebug)]
+pub struct BookState<MessageOrigin> {
+	/// The first page with some items to be processed in it. If this is `>= end`, then there are
+	/// no pages with items to be processing in them.
+	begin: PageIndex,
+	/// One more than the last page with some items to be processed in it.
+	end: PageIndex,
+	/// The number of pages stored at present.
+	///
+	/// This might be larger than `end-begin`, because we keep pages with unprocessed overweight
+	/// messages outside of the end/begin window.
+	count: PageIndex,
+	/// If this book has any ready pages, then this will be `Some` with the previous and next
+	/// neighbours. This wraps around.
+	ready_neighbours: Option<Neighbours<MessageOrigin>>,
+	/// The number of unprocessed messages stored at present.
+	message_count: u64,
+	/// The total size of all unprocessed messages stored at present.
+	size: u64,
+}
+
+impl<MessageOrigin> Default for BookState<MessageOrigin> {
+	fn default() -> Self {
+		Self { begin: 0, end: 0, count: 0, ready_neighbours: None, message_count: 0, size: 0 }
+	}
+}
+
+/// Handler code for when the items in a queue change.
+pub trait OnQueueChanged<Id> {
+	/// Note that the queue `id` now has `item_count` items in it, taking up `items_size` bytes.
+	fn on_queue_changed(id: Id, items_count: u64, items_size: u64);
+}
+
+impl<Id> OnQueueChanged<Id> for () {
+	fn on_queue_changed(_: Id, _: u64, _: u64) {}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// The module configuration trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Processor for a message.
+		///
+		/// Must be set to [`mock_helpers::NoopMessageProcessor`] for benchmarking.
+		/// Other message processors that consumes exactly (1, 1) weight for any give message will
+		/// work as well. Otherwise the benchmarking will also measure the weight of the message
+		/// processor, which is not desired.
+		type MessageProcessor: ProcessMessage;
+
+		/// Page/heap size type.
+		type Size: BaseArithmetic
+			+ Unsigned
+			+ Copy
+			+ Into<u32>
+			+ Member
+			+ Encode
+			+ Decode
+			+ MaxEncodedLen
+			+ TypeInfo
+			+ Default;
+
+		/// Code to be called when a message queue changes - either with items introduced or
+		/// removed.
+		type QueueChangeHandler: OnQueueChanged<<Self::MessageProcessor as ProcessMessage>::Origin>;
+
+		/// Queried by the pallet to check whether a queue can be serviced.
+		///
+		/// This also applies to manual servicing via `execute_overweight` and `service_queues`. The
+		/// value of this is only polled once before servicing the queue. This means that changes to
+		/// it that happen *within* the servicing will not be reflected.
+		type QueuePausedQuery: QueuePausedQuery<<Self::MessageProcessor as ProcessMessage>::Origin>;
+
+		/// The size of the page; this implies the maximum message size which can be sent.
+		///
+		/// A good value depends on the expected message sizes, their weights, the weight that is
+		/// available for processing them and the maximal needed message size. The maximal message
+		/// size is slightly lower than this as defined by [`MaxMessageLenOf`].
+		#[pallet::constant]
+		type HeapSize: Get<Self::Size>;
+
+		/// The maximum number of stale pages (i.e. of overweight messages) allowed before culling
+		/// can happen. Once there are more stale pages than this, then historical pages may be
+		/// dropped, even if they contain unprocessed overweight messages.
+		#[pallet::constant]
+		type MaxStale: Get<u32>;
+
+		/// The amount of weight (if any) which should be provided to the message queue for
+		/// servicing enqueued items.
+		///
+		/// This may be legitimately `None` in the case that you will call
+		/// `ServiceQueues::service_queues` manually.
+		#[pallet::constant]
+		type ServiceWeight: Get<Option<Weight>>;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Message discarded due to an error in the `MessageProcessor` (usually a format error).
+		ProcessingFailed { id: [u8; 32], origin: MessageOriginOf<T>, error: ProcessMessageError },
+		/// Message is processed.
+		Processed { id: [u8; 32], origin: MessageOriginOf<T>, weight_used: Weight, success: bool },
+		/// Message placed in overweight queue.
+		OverweightEnqueued {
+			id: [u8; 32],
+			origin: MessageOriginOf<T>,
+			page_index: PageIndex,
+			message_index: T::Size,
+		},
+		/// This page was reaped.
+		PageReaped { origin: MessageOriginOf<T>, index: PageIndex },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Page is not reapable because it has items remaining to be processed and is not old
+		/// enough.
+		NotReapable,
+		/// Page to be reaped does not exist.
+		NoPage,
+		/// The referenced message could not be found.
+		NoMessage,
+		/// The message was already processed and cannot be processed again.
+		AlreadyProcessed,
+		/// The message is queued for future execution.
+		Queued,
+		/// There is temporarily not enough weight to continue servicing messages.
+		InsufficientWeight,
+		/// This message is temporarily unprocessable.
+		///
+		/// Such errors are expected, but not guaranteed, to resolve themselves eventually through
+		/// retrying.
+		TemporarilyUnprocessable,
+		/// The queue is paused and no message can be executed from it.
+		///
+		/// This can change at any time and may resolve in the future by re-trying.
+		QueuePaused,
+	}
+
+	/// The index of the first and last (non-empty) pages.
+	#[pallet::storage]
+	pub(super) type BookStateFor<T: Config> =
+		StorageMap<_, Twox64Concat, MessageOriginOf<T>, BookState<MessageOriginOf<T>>, ValueQuery>;
+
+	/// The origin at which we should begin servicing.
+	#[pallet::storage]
+	pub(super) type ServiceHead<T: Config> = StorageValue<_, MessageOriginOf<T>, OptionQuery>;
+
+	/// The map of page indices to pages.
+	#[pallet::storage]
+	pub(super) type Pages<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		MessageOriginOf<T>,
+		Twox64Concat,
+		PageIndex,
+		Page<T::Size, T::HeapSize>,
+		OptionQuery,
+	>;
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+			if let Some(weight_limit) = T::ServiceWeight::get() {
+				Self::service_queues(weight_limit)
+			} else {
+				Weight::zero()
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
+			Self::do_try_state()
+		}
+
+		/// Check all compile-time assumptions about [`crate::Config`].
+		fn integrity_test() {
+			assert!(!MaxMessageLenOf::<T>::get().is_zero(), "HeapSize too low");
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Remove a page which has no more messages remaining to be processed or is stale.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::reap_page())]
+		pub fn reap_page(
+			origin: OriginFor<T>,
+			message_origin: MessageOriginOf<T>,
+			page_index: PageIndex,
+		) -> DispatchResult {
+			let _ = ensure_signed(origin)?;
+			Self::do_reap_page(&message_origin, page_index)
+		}
+
+		/// Execute an overweight message.
+		///
+		/// Temporary processing errors will be propagated whereas permanent errors are treated
+		/// as success condition.
+		///
+		/// - `origin`: Must be `Signed`.
+		/// - `message_origin`: The origin from which the message to be executed arrived.
+		/// - `page`: The page in the queue in which the message to be executed is sitting.
+		/// - `index`: The index into the queue of the message to be executed.
+		/// - `weight_limit`: The maximum amount of weight allowed to be consumed in the execution
+		///   of the message.
+		///
+		/// Benchmark complexity considerations: O(index + weight_limit).
+		#[pallet::call_index(1)]
+		#[pallet::weight(
+			T::WeightInfo::execute_overweight_page_updated().max(
+			T::WeightInfo::execute_overweight_page_removed()).saturating_add(*weight_limit)
+		)]
+		pub fn execute_overweight(
+			origin: OriginFor<T>,
+			message_origin: MessageOriginOf<T>,
+			page: PageIndex,
+			index: T::Size,
+			weight_limit: Weight,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			let actual_weight =
+				Self::do_execute_overweight(message_origin, page, index, weight_limit)?;
+			Ok(Some(actual_weight).into())
+		}
+	}
+}
+
+/// The status of a page after trying to execute its next message.
+#[derive(PartialEq, Debug)]
+enum PageExecutionStatus {
+	/// The execution bailed because there was not enough weight remaining.
+	Bailed,
+	/// The page did not make any progress on its execution.
+	///
+	/// This is a transient condition and can be handled by retrying - exactly like [Bailed].
+	NoProgress,
+	/// No more messages could be loaded. This does _not_ imply `page.is_complete()`.
+	///
+	/// The reasons for this status are:
+	///  - The end of the page is reached but there could still be skipped messages.
+	///  - The storage is corrupted.
+	NoMore,
+}
+
+/// The status after trying to execute the next item of a [`Page`].
+#[derive(PartialEq, Debug)]
+enum ItemExecutionStatus {
+	/// The execution bailed because there was not enough weight remaining.
+	Bailed,
+	/// The item did not make any progress on its execution.
+	///
+	/// This is a transient condition and can be handled by retrying - exactly like [Bailed].
+	NoProgress,
+	/// The item was not found.
+	NoItem,
+	/// Whether the execution of an item resulted in it being processed.
+	///
+	/// One reason for `false` would be permanently overweight.
+	Executed(bool),
+}
+
+/// The status of an attempt to process a message.
+#[derive(PartialEq)]
+enum MessageExecutionStatus {
+	/// There is not enough weight remaining at present.
+	InsufficientWeight,
+	/// There will never be enough weight.
+	Overweight,
+	/// The message was processed successfully.
+	Processed,
+	/// The message was processed and resulted in a, possibly permanent, error.
+	Unprocessable { permanent: bool },
+}
+
+impl<T: Config> Pallet<T> {
+	/// Knit `origin` into the ready ring right at the end.
+	///
+	/// Return the two ready ring neighbours of `origin`.
+	fn ready_ring_knit(origin: &MessageOriginOf<T>) -> Result<Neighbours<MessageOriginOf<T>>, ()> {
+		if let Some(head) = ServiceHead::<T>::get() {
+			let mut head_book_state = BookStateFor::<T>::get(&head);
+			let mut head_neighbours = head_book_state.ready_neighbours.take().ok_or(())?;
+			let tail = head_neighbours.prev;
+			head_neighbours.prev = origin.clone();
+			head_book_state.ready_neighbours = Some(head_neighbours);
+			BookStateFor::<T>::insert(&head, head_book_state);
+
+			let mut tail_book_state = BookStateFor::<T>::get(&tail);
+			let mut tail_neighbours = tail_book_state.ready_neighbours.take().ok_or(())?;
+			tail_neighbours.next = origin.clone();
+			tail_book_state.ready_neighbours = Some(tail_neighbours);
+			BookStateFor::<T>::insert(&tail, tail_book_state);
+
+			Ok(Neighbours { next: head, prev: tail })
+		} else {
+			ServiceHead::<T>::put(origin);
+			Ok(Neighbours { next: origin.clone(), prev: origin.clone() })
+		}
+	}
+
+	fn ready_ring_unknit(origin: &MessageOriginOf<T>, neighbours: Neighbours<MessageOriginOf<T>>) {
+		if origin == &neighbours.next {
+			debug_assert!(
+				origin == &neighbours.prev,
+				"unknitting from single item ring; outgoing must be only item"
+			);
+			// Service queue empty.
+			ServiceHead::<T>::kill();
+		} else {
+			BookStateFor::<T>::mutate(&neighbours.next, |book_state| {
+				if let Some(ref mut n) = book_state.ready_neighbours {
+					n.prev = neighbours.prev.clone()
+				}
+			});
+			BookStateFor::<T>::mutate(&neighbours.prev, |book_state| {
+				if let Some(ref mut n) = book_state.ready_neighbours {
+					n.next = neighbours.next.clone()
+				}
+			});
+			if let Some(head) = ServiceHead::<T>::get() {
+				if &head == origin {
+					ServiceHead::<T>::put(neighbours.next);
+				}
+			} else {
+				defensive!("`ServiceHead` must be some if there was a ready queue");
+			}
+		}
+	}
+
+	/// Tries to bump the current `ServiceHead` to the next ready queue.
+	///
+	/// Returns the current head if it got be bumped and `None` otherwise.
+	fn bump_service_head(weight: &mut WeightMeter) -> Option<MessageOriginOf<T>> {
+		if weight.try_consume(T::WeightInfo::bump_service_head()).is_err() {
+			return None
+		}
+
+		if let Some(head) = ServiceHead::<T>::get() {
+			let mut head_book_state = BookStateFor::<T>::get(&head);
+			if let Some(head_neighbours) = head_book_state.ready_neighbours.take() {
+				ServiceHead::<T>::put(&head_neighbours.next);
+				Some(head)
+			} else {
+				None
+			}
+		} else {
+			None
+		}
+	}
+
+	fn do_enqueue_message(
+		origin: &MessageOriginOf<T>,
+		message: BoundedSlice<u8, MaxMessageLenOf<T>>,
+	) {
+		let mut book_state = BookStateFor::<T>::get(origin);
+		book_state.message_count.saturating_inc();
+		book_state
+			.size
+			// This should be payload size, but here the payload *is* the message.
+			.saturating_accrue(message.len() as u64);
+
+		if book_state.end > book_state.begin {
+			debug_assert!(book_state.ready_neighbours.is_some(), "Must be in ready ring if ready");
+			// Already have a page in progress - attempt to append.
+			let last = book_state.end - 1;
+			let mut page = match Pages::<T>::get(origin, last) {
+				Some(p) => p,
+				None => {
+					defensive!("Corruption: referenced page doesn't exist.");
+					return
+				},
+			};
+			if page.try_append_message::<T>(message).is_ok() {
+				Pages::<T>::insert(origin, last, &page);
+				BookStateFor::<T>::insert(origin, book_state);
+				return
+			}
+		} else {
+			debug_assert!(
+				book_state.ready_neighbours.is_none(),
+				"Must not be in ready ring if not ready"
+			);
+			// insert into ready queue.
+			match Self::ready_ring_knit(origin) {
+				Ok(neighbours) => book_state.ready_neighbours = Some(neighbours),
+				Err(()) => {
+					defensive!("Ring state invalid when knitting");
+				},
+			}
+		}
+		// No room on the page or no page - link in a new page.
+		book_state.end.saturating_inc();
+		book_state.count.saturating_inc();
+		let page = Page::from_message::<T>(message);
+		Pages::<T>::insert(origin, book_state.end - 1, page);
+		// NOTE: `T::QueueChangeHandler` is called by the caller.
+		BookStateFor::<T>::insert(origin, book_state);
+	}
+
+	/// Try to execute a single message that was marked as overweight.
+	///
+	/// The `weight_limit` is the weight that can be consumed to execute the message. The base
+	/// weight of the function it self must be measured by the caller.
+	pub fn do_execute_overweight(
+		origin: MessageOriginOf<T>,
+		page_index: PageIndex,
+		index: T::Size,
+		weight_limit: Weight,
+	) -> Result<Weight, Error<T>> {
+		let mut book_state = BookStateFor::<T>::get(&origin);
+		ensure!(!T::QueuePausedQuery::is_paused(&origin), Error::<T>::QueuePaused);
+
+		let mut page = Pages::<T>::get(&origin, page_index).ok_or(Error::<T>::NoPage)?;
+		let (pos, is_processed, payload) =
+			page.peek_index(index.into() as usize).ok_or(Error::<T>::NoMessage)?;
+		let payload_len = payload.len() as u64;
+		ensure!(
+			page_index < book_state.begin ||
+				(page_index == book_state.begin && pos < page.first.into() as usize),
+			Error::<T>::Queued
+		);
+		ensure!(!is_processed, Error::<T>::AlreadyProcessed);
+		use MessageExecutionStatus::*;
+		let mut weight_counter = WeightMeter::from_limit(weight_limit);
+		match Self::process_message_payload(
+			origin.clone(),
+			page_index,
+			index,
+			payload,
+			&mut weight_counter,
+			Weight::MAX,
+			// ^^^ We never recognise it as permanently overweight, since that would result in an
+			// additional overweight event being deposited.
+		) {
+			Overweight | InsufficientWeight => Err(Error::<T>::InsufficientWeight),
+			Unprocessable { permanent: false } => Err(Error::<T>::TemporarilyUnprocessable),
+			Unprocessable { permanent: true } | Processed => {
+				page.note_processed_at_pos(pos);
+				book_state.message_count.saturating_dec();
+				book_state.size.saturating_reduce(payload_len);
+				let page_weight = if page.remaining.is_zero() {
+					debug_assert!(
+						page.remaining_size.is_zero(),
+						"no messages remaining; no space taken; qed"
+					);
+					Pages::<T>::remove(&origin, page_index);
+					debug_assert!(book_state.count >= 1, "page exists, so book must have pages");
+					book_state.count.saturating_dec();
+					T::WeightInfo::execute_overweight_page_removed()
+				// no need to consider .first or ready ring since processing an overweight page
+				// would not alter that state.
+				} else {
+					Pages::<T>::insert(&origin, page_index, page);
+					T::WeightInfo::execute_overweight_page_updated()
+				};
+				BookStateFor::<T>::insert(&origin, &book_state);
+				T::QueueChangeHandler::on_queue_changed(
+					origin,
+					book_state.message_count,
+					book_state.size,
+				);
+				Ok(weight_counter.consumed().saturating_add(page_weight))
+			},
+		}
+	}
+
+	/// Remove a stale page or one which has no more messages remaining to be processed.
+	fn do_reap_page(origin: &MessageOriginOf<T>, page_index: PageIndex) -> DispatchResult {
+		let mut book_state = BookStateFor::<T>::get(origin);
+		// definitely not reapable if the page's index is no less than the `begin`ning of ready
+		// pages.
+		ensure!(page_index < book_state.begin, Error::<T>::NotReapable);
+
+		let page = Pages::<T>::get(origin, page_index).ok_or(Error::<T>::NoPage)?;
+
+		// definitely reapable if the page has no messages in it.
+		let reapable = page.remaining.is_zero();
+
+		// also reapable if the page index has dropped below our watermark.
+		let cullable = || {
+			let total_pages = book_state.count;
+			let ready_pages = book_state.end.saturating_sub(book_state.begin).min(total_pages);
+
+			// The number of stale pages - i.e. pages which contain unprocessed overweight messages.
+			// We would prefer to keep these around but will restrict how far into history they can
+			// extend if we notice that there's too many of them.
+			//
+			// We don't know *where* in history these pages are so we use a dynamic formula which
+			// reduces the historical time horizon as the stale pages pile up and increases it as
+			// they reduce.
+			let stale_pages = total_pages - ready_pages;
+
+			// The maximum number of stale pages (i.e. of overweight messages) allowed before
+			// culling can happen at all. Once there are more stale pages than this, then historical
+			// pages may be dropped, even if they contain unprocessed overweight messages.
+			let max_stale = T::MaxStale::get();
+
+			// The amount beyond the maximum which are being used. If it's not beyond the maximum
+			// then we exit now since no culling is needed.
+			let overflow = match stale_pages.checked_sub(max_stale + 1) {
+				Some(x) => x + 1,
+				None => return false,
+			};
+
+			// The special formula which tells us how deep into index-history we will pages. As
+			// the overflow is greater (and thus the need to drop items from storage is more urgent)
+			// this is reduced, allowing a greater range of pages to be culled.
+			// With a minimum `overflow` (`1`), this returns `max_stale ** 2`, indicating we only
+			// cull beyond that number of indices deep into history.
+			// At this overflow increases, our depth reduces down to a limit of `max_stale`. We
+			// never want to reduce below this since this will certainly allow enough pages to be
+			// culled in order to bring `overflow` back to zero.
+			let backlog = (max_stale * max_stale / overflow).max(max_stale);
+
+			let watermark = book_state.begin.saturating_sub(backlog);
+			page_index < watermark
+		};
+		ensure!(reapable || cullable(), Error::<T>::NotReapable);
+
+		Pages::<T>::remove(origin, page_index);
+		debug_assert!(book_state.count > 0, "reaping a page implies there are pages");
+		book_state.count.saturating_dec();
+		book_state.message_count.saturating_reduce(page.remaining.into() as u64);
+		book_state.size.saturating_reduce(page.remaining_size.into() as u64);
+		BookStateFor::<T>::insert(origin, &book_state);
+		T::QueueChangeHandler::on_queue_changed(
+			origin.clone(),
+			book_state.message_count,
+			book_state.size,
+		);
+		Self::deposit_event(Event::PageReaped { origin: origin.clone(), index: page_index });
+
+		Ok(())
+	}
+
+	/// Execute any messages remaining to be processed in the queue of `origin`, using up to
+	/// `weight_limit` to do so. Any messages which would take more than `overweight_limit` to
+	/// execute are deemed overweight and ignored.
+	fn service_queue(
+		origin: MessageOriginOf<T>,
+		weight: &mut WeightMeter,
+		overweight_limit: Weight,
+	) -> (bool, Option<MessageOriginOf<T>>) {
+		use PageExecutionStatus::*;
+		if weight
+			.try_consume(
+				T::WeightInfo::service_queue_base()
+					.saturating_add(T::WeightInfo::ready_ring_unknit()),
+			)
+			.is_err()
+		{
+			return (false, None)
+		}
+
+		let mut book_state = BookStateFor::<T>::get(&origin);
+		let mut total_processed = 0;
+		if T::QueuePausedQuery::is_paused(&origin) {
+			let next_ready = book_state.ready_neighbours.as_ref().map(|x| x.next.clone());
+			return (false, next_ready)
+		}
+
+		while book_state.end > book_state.begin {
+			let (processed, status) =
+				Self::service_page(&origin, &mut book_state, weight, overweight_limit);
+			total_processed.saturating_accrue(processed);
+			match status {
+				// Store the page progress and do not go to the next one.
+				Bailed | NoProgress => break,
+				// Go to the next page if this one is at the end.
+				NoMore => (),
+			};
+			book_state.begin.saturating_inc();
+		}
+		let next_ready = book_state.ready_neighbours.as_ref().map(|x| x.next.clone());
+		if book_state.begin >= book_state.end {
+			// No longer ready - unknit.
+			if let Some(neighbours) = book_state.ready_neighbours.take() {
+				Self::ready_ring_unknit(&origin, neighbours);
+			} else if total_processed > 0 {
+				defensive!("Freshly processed queue must have been ready");
+			}
+		}
+		BookStateFor::<T>::insert(&origin, &book_state);
+		if total_processed > 0 {
+			T::QueueChangeHandler::on_queue_changed(
+				origin,
+				book_state.message_count,
+				book_state.size,
+			);
+		}
+		(total_processed > 0, next_ready)
+	}
+
+	/// Service as many messages of a page as possible.
+	///
+	/// Returns how many messages were processed and the page's status.
+	fn service_page(
+		origin: &MessageOriginOf<T>,
+		book_state: &mut BookStateOf<T>,
+		weight: &mut WeightMeter,
+		overweight_limit: Weight,
+	) -> (u32, PageExecutionStatus) {
+		use PageExecutionStatus::*;
+		if weight
+			.try_consume(
+				T::WeightInfo::service_page_base_completion()
+					.max(T::WeightInfo::service_page_base_no_completion()),
+			)
+			.is_err()
+		{
+			return (0, Bailed)
+		}
+
+		let page_index = book_state.begin;
+		let mut page = match Pages::<T>::get(origin, page_index) {
+			Some(p) => p,
+			None => {
+				defensive!("message-queue: referenced page not found");
+				return (0, NoMore)
+			},
+		};
+
+		let mut total_processed = 0;
+
+		// Execute as many messages as possible.
+		let status = loop {
+			use ItemExecutionStatus::*;
+			match Self::service_page_item(
+				origin,
+				page_index,
+				book_state,
+				&mut page,
+				weight,
+				overweight_limit,
+			) {
+				Bailed => break PageExecutionStatus::Bailed,
+				NoItem => break PageExecutionStatus::NoMore,
+				NoProgress => break PageExecutionStatus::NoProgress,
+				// Keep going as long as we make progress...
+				Executed(true) => total_processed.saturating_inc(),
+				Executed(false) => (),
+			}
+		};
+
+		if page.is_complete() {
+			debug_assert!(status != Bailed, "we never bail if a page became complete");
+			Pages::<T>::remove(origin, page_index);
+			debug_assert!(book_state.count > 0, "completing a page implies there are pages");
+			book_state.count.saturating_dec();
+		} else {
+			Pages::<T>::insert(origin, page_index, page);
+		}
+		(total_processed, status)
+	}
+
+	/// Execute the next message of a page.
+	pub(crate) fn service_page_item(
+		origin: &MessageOriginOf<T>,
+		page_index: PageIndex,
+		book_state: &mut BookStateOf<T>,
+		page: &mut PageOf<T>,
+		weight: &mut WeightMeter,
+		overweight_limit: Weight,
+	) -> ItemExecutionStatus {
+		// This ugly pre-checking is needed for the invariant
+		// "we never bail if a page became complete".
+		if page.is_complete() {
+			return ItemExecutionStatus::NoItem
+		}
+		if weight.try_consume(T::WeightInfo::service_page_item()).is_err() {
+			return ItemExecutionStatus::Bailed
+		}
+
+		let payload = &match page.peek_first() {
+			Some(m) => m,
+			None => return ItemExecutionStatus::NoItem,
+		}[..];
+
+		use MessageExecutionStatus::*;
+		let is_processed = match Self::process_message_payload(
+			origin.clone(),
+			page_index,
+			page.first_index,
+			payload.deref(),
+			weight,
+			overweight_limit,
+		) {
+			InsufficientWeight => return ItemExecutionStatus::Bailed,
+			Unprocessable { permanent: false } => return ItemExecutionStatus::NoProgress,
+			Processed | Unprocessable { permanent: true } => true,
+			Overweight => false,
+		};
+
+		if is_processed {
+			book_state.message_count.saturating_dec();
+			book_state.size.saturating_reduce(payload.len() as u64);
+		}
+		page.skip_first(is_processed);
+		ItemExecutionStatus::Executed(is_processed)
+	}
+
+	/// Ensure the correctness of state of this pallet.
+	///
+	/// # Assumptions-
+	///
+	/// If `serviceHead` points to a ready Queue, then BookState of that Queue has:
+	///
+	/// * `message_count` > 0
+	/// * `size` > 0
+	/// * `end` > `begin`
+	/// * Some(ready_neighbours)
+	/// * If `ready_neighbours.next` == self.origin, then `ready_neighbours.prev` == self.origin
+	///   (only queue in ring)
+	///
+	/// For Pages(begin to end-1) in BookState:
+	///
+	/// * `remaining` > 0
+	/// * `remaining_size` > 0
+	/// * `first` <= `last`
+	/// * Every page can be decoded into peek_* functions
+	#[cfg(any(test, feature = "try-runtime"))]
+	pub fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> {
+		// Checking memory corruption for BookStateFor
+		ensure!(
+			BookStateFor::<T>::iter_keys().count() == BookStateFor::<T>::iter_values().count(),
+			"Memory Corruption in BookStateFor"
+		);
+		// Checking memory corruption for Pages
+		ensure!(
+			Pages::<T>::iter_keys().count() == Pages::<T>::iter_values().count(),
+			"Memory Corruption in Pages"
+		);
+
+		// No state to check
+		if ServiceHead::<T>::get().is_none() {
+			return Ok(())
+		}
+
+		//loop around this origin
+		let starting_origin = ServiceHead::<T>::get().unwrap();
+
+		while let Some(head) = Self::bump_service_head(&mut WeightMeter::max_limit()) {
+			ensure!(
+				BookStateFor::<T>::contains_key(&head),
+				"Service head must point to an existing book"
+			);
+
+			let head_book_state = BookStateFor::<T>::get(&head);
+			ensure!(
+				head_book_state.message_count > 0,
+				"There must be some messages if in ReadyRing"
+			);
+			ensure!(head_book_state.size > 0, "There must be some message size if in ReadyRing");
+			ensure!(
+				head_book_state.end > head_book_state.begin,
+				"End > Begin if unprocessed messages exists"
+			);
+			ensure!(
+				head_book_state.ready_neighbours.is_some(),
+				"There must be neighbours if in ReadyRing"
+			);
+
+			if head_book_state.ready_neighbours.as_ref().unwrap().next == head {
+				ensure!(
+					head_book_state.ready_neighbours.as_ref().unwrap().prev == head,
+					"Can only happen if only queue in ReadyRing"
+				);
+			}
+
+			for page_index in head_book_state.begin..head_book_state.end {
+				let page = Pages::<T>::get(&head, page_index).unwrap();
+				let remaining_messages = page.remaining;
+				let mut counted_remaining_messages = 0;
+				ensure!(
+					remaining_messages > 0.into(),
+					"These must be some messages that have not been processed yet!"
+				);
+
+				for i in 0..u32::MAX {
+					if let Some((_, processed, _)) = page.peek_index(i as usize) {
+						if !processed {
+							counted_remaining_messages += 1;
+						}
+					} else {
+						break
+					}
+				}
+
+				ensure!(
+					remaining_messages == counted_remaining_messages.into(),
+					"Memory Corruption"
+				);
+			}
+
+			if head_book_state.ready_neighbours.as_ref().unwrap().next == starting_origin {
+				break
+			}
+		}
+		Ok(())
+	}
+
+	/// Print the pages in each queue and the messages in each page.
+	///
+	/// Processed messages are prefixed with a `*` and the current `begin`ning page with a `>`.
+	///
+	/// # Example output
+	///
+	/// ```text
+	/// queue Here:
+	///   page 0: []
+	/// > page 1: []
+	///   page 2: ["\0weight=4", "\0c", ]
+	///   page 3: ["\0bigbig 1", ]
+	///   page 4: ["\0bigbig 2", ]
+	///   page 5: ["\0bigbig 3", ]
+	/// ```
+	#[cfg(feature = "std")]
+	pub fn debug_info() -> String {
+		let mut info = String::new();
+		for (origin, book_state) in BookStateFor::<T>::iter() {
+			let mut queue = format!("queue {:?}:\n", &origin);
+			let mut pages = Pages::<T>::iter_prefix(&origin).collect::<Vec<_>>();
+			pages.sort_by(|(a, _), (b, _)| a.cmp(b));
+			for (page_index, mut page) in pages.into_iter() {
+				let page_info = if book_state.begin == page_index { ">" } else { " " };
+				let mut page_info = format!(
+					"{} page {} ({:?} first, {:?} last, {:?} remain): [ ",
+					page_info, page_index, page.first, page.last, page.remaining
+				);
+				for i in 0..u32::MAX {
+					if let Some((_, processed, message)) =
+						page.peek_index(i.try_into().expect("std-only code"))
+					{
+						let msg = String::from_utf8_lossy(message.deref());
+						if processed {
+							page_info.push('*');
+						}
+						page_info.push_str(&format!("{:?}, ", msg));
+						page.skip_first(true);
+					} else {
+						break
+					}
+				}
+				page_info.push_str("]\n");
+				queue.push_str(&page_info);
+			}
+			info.push_str(&queue);
+		}
+		info
+	}
+
+	/// Process a single message.
+	///
+	/// The base weight of this function needs to be accounted for by the caller. `weight` is the
+	/// remaining weight to process the message. `overweight_limit` is the maximum weight that a
+	/// message can ever consume. Messages above this limit are marked as permanently overweight.
+	fn process_message_payload(
+		origin: MessageOriginOf<T>,
+		page_index: PageIndex,
+		message_index: T::Size,
+		message: &[u8],
+		meter: &mut WeightMeter,
+		overweight_limit: Weight,
+	) -> MessageExecutionStatus {
+		let hash = sp_io::hashing::blake2_256(message);
+		use ProcessMessageError::*;
+		let prev_consumed = meter.consumed();
+		let mut id = hash;
+
+		match T::MessageProcessor::process_message(message, origin.clone(), meter, &mut id) {
+			Err(Overweight(w)) if w.any_gt(overweight_limit) => {
+				// Permanently overweight.
+				Self::deposit_event(Event::<T>::OverweightEnqueued {
+					id,
+					origin,
+					page_index,
+					message_index,
+				});
+				MessageExecutionStatus::Overweight
+			},
+			Err(Overweight(_)) => {
+				// Temporarily overweight - save progress and stop processing this
+				// queue.
+				MessageExecutionStatus::InsufficientWeight
+			},
+			Err(Yield) => {
+				// Processing should be reattempted later.
+				MessageExecutionStatus::Unprocessable { permanent: false }
+			},
+			Err(error @ BadFormat | error @ Corrupt | error @ Unsupported) => {
+				// Permanent error - drop
+				Self::deposit_event(Event::<T>::ProcessingFailed { id, origin, error });
+				MessageExecutionStatus::Unprocessable { permanent: true }
+			},
+			Ok(success) => {
+				// Success
+				let weight_used = meter.consumed().saturating_sub(prev_consumed);
+				Self::deposit_event(Event::<T>::Processed { id, origin, weight_used, success });
+				MessageExecutionStatus::Processed
+			},
+		}
+	}
+}
+
+/// Provides a [`sp_core::Get`] to access the `MEL` of a [`codec::MaxEncodedLen`] type.
+pub struct MaxEncodedLenOf<T>(sp_std::marker::PhantomData<T>);
+impl<T: MaxEncodedLen> Get<u32> for MaxEncodedLenOf<T> {
+	fn get() -> u32 {
+		T::max_encoded_len() as u32
+	}
+}
+
+/// Calculates the maximum message length and exposed it through the [`codec::MaxEncodedLen`] trait.
+pub struct MaxMessageLen<Origin, Size, HeapSize>(
+	sp_std::marker::PhantomData<(Origin, Size, HeapSize)>,
+);
+impl<Origin: MaxEncodedLen, Size: MaxEncodedLen + Into<u32>, HeapSize: Get<Size>> Get<u32>
+	for MaxMessageLen<Origin, Size, HeapSize>
+{
+	fn get() -> u32 {
+		(HeapSize::get().into()).saturating_sub(ItemHeader::<Size>::max_encoded_len() as u32)
+	}
+}
+
+/// The maximal message length.
+pub type MaxMessageLenOf<T> =
+	MaxMessageLen<MessageOriginOf<T>, <T as Config>::Size, <T as Config>::HeapSize>;
+/// The maximal encoded origin length.
+pub type MaxOriginLenOf<T> = MaxEncodedLenOf<MessageOriginOf<T>>;
+/// The `MessageOrigin` of this pallet.
+pub type MessageOriginOf<T> = <<T as Config>::MessageProcessor as ProcessMessage>::Origin;
+/// The maximal heap size of a page.
+pub type HeapSizeU32Of<T> = IntoU32<<T as Config>::HeapSize, <T as Config>::Size>;
+/// The [`Page`] of this pallet.
+pub type PageOf<T> = Page<<T as Config>::Size, <T as Config>::HeapSize>;
+/// The [`BookState`] of this pallet.
+pub type BookStateOf<T> = BookState<MessageOriginOf<T>>;
+
+/// Converts a [`sp_core::Get`] with returns a type that can be cast into an `u32` into a `Get`
+/// which returns an `u32`.
+pub struct IntoU32<T, O>(sp_std::marker::PhantomData<(T, O)>);
+impl<T: Get<O>, O: Into<u32>> Get<u32> for IntoU32<T, O> {
+	fn get() -> u32 {
+		T::get().into()
+	}
+}
+
+impl<T: Config> ServiceQueues for Pallet<T> {
+	type OverweightMessageAddress = (MessageOriginOf<T>, PageIndex, T::Size);
+
+	fn service_queues(weight_limit: Weight) -> Weight {
+		// The maximum weight that processing a single message may take.
+		let overweight_limit = weight_limit;
+		let mut weight = WeightMeter::from_limit(weight_limit);
+
+		let mut next = match Self::bump_service_head(&mut weight) {
+			Some(h) => h,
+			None => return weight.consumed(),
+		};
+		// The last queue that did not make any progress.
+		// The loop aborts as soon as it arrives at this queue again without making any progress
+		// on other queues in between.
+		let mut last_no_progress = None;
+
+		loop {
+			let (progressed, n) = Self::service_queue(next.clone(), &mut weight, overweight_limit);
+			next = match n {
+				Some(n) =>
+					if !progressed {
+						if last_no_progress == Some(n.clone()) {
+							break
+						}
+						if last_no_progress.is_none() {
+							last_no_progress = Some(next.clone())
+						}
+						n
+					} else {
+						last_no_progress = None;
+						n
+					},
+				None => break,
+			}
+		}
+		weight.consumed()
+	}
+
+	/// Execute a single overweight message.
+	///
+	/// The weight limit must be enough for `execute_overweight` and the message execution itself.
+	fn execute_overweight(
+		weight_limit: Weight,
+		(message_origin, page, index): Self::OverweightMessageAddress,
+	) -> Result<Weight, ExecuteOverweightError> {
+		let mut weight = WeightMeter::from_limit(weight_limit);
+		if weight
+			.try_consume(
+				T::WeightInfo::execute_overweight_page_removed()
+					.max(T::WeightInfo::execute_overweight_page_updated()),
+			)
+			.is_err()
+		{
+			return Err(ExecuteOverweightError::InsufficientWeight)
+		}
+
+		Pallet::<T>::do_execute_overweight(message_origin, page, index, weight.remaining()).map_err(
+			|e| match e {
+				Error::<T>::InsufficientWeight => ExecuteOverweightError::InsufficientWeight,
+				Error::<T>::AlreadyProcessed => ExecuteOverweightError::AlreadyProcessed,
+				Error::<T>::QueuePaused => ExecuteOverweightError::QueuePaused,
+				Error::<T>::NoPage | Error::<T>::NoMessage | Error::<T>::Queued =>
+					ExecuteOverweightError::NotFound,
+				_ => ExecuteOverweightError::Other,
+			},
+		)
+	}
+}
+
+impl<T: Config> EnqueueMessage<MessageOriginOf<T>> for Pallet<T> {
+	type MaxMessageLen =
+		MaxMessageLen<<T::MessageProcessor as ProcessMessage>::Origin, T::Size, T::HeapSize>;
+
+	fn enqueue_message(
+		message: BoundedSlice<u8, Self::MaxMessageLen>,
+		origin: <T::MessageProcessor as ProcessMessage>::Origin,
+	) {
+		Self::do_enqueue_message(&origin, message);
+		let book_state = BookStateFor::<T>::get(&origin);
+		T::QueueChangeHandler::on_queue_changed(origin, book_state.message_count, book_state.size);
+	}
+
+	fn enqueue_messages<'a>(
+		messages: impl Iterator<Item = BoundedSlice<'a, u8, Self::MaxMessageLen>>,
+		origin: <T::MessageProcessor as ProcessMessage>::Origin,
+	) {
+		for message in messages {
+			Self::do_enqueue_message(&origin, message);
+		}
+		let book_state = BookStateFor::<T>::get(&origin);
+		T::QueueChangeHandler::on_queue_changed(origin, book_state.message_count, book_state.size);
+	}
+
+	fn sweep_queue(origin: MessageOriginOf<T>) {
+		if !BookStateFor::<T>::contains_key(&origin) {
+			return
+		}
+		let mut book_state = BookStateFor::<T>::get(&origin);
+		book_state.begin = book_state.end;
+		if let Some(neighbours) = book_state.ready_neighbours.take() {
+			Self::ready_ring_unknit(&origin, neighbours);
+		}
+		BookStateFor::<T>::insert(&origin, &book_state);
+	}
+
+	fn footprint(origin: MessageOriginOf<T>) -> Footprint {
+		let book_state = BookStateFor::<T>::get(&origin);
+		Footprint { count: book_state.message_count, size: book_state.size }
+	}
+}
diff --git a/substrate/frame/message-queue/src/mock.rs b/substrate/frame/message-queue/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..473c5faac4c5d045cc18cca43b88afd11325c2d0
--- /dev/null
+++ b/substrate/frame/message-queue/src/mock.rs
@@ -0,0 +1,352 @@
+// 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.
+
+//! Test helpers and runtime setup for the message queue pallet.
+
+#![cfg(test)]
+
+pub use super::mock_helpers::*;
+use super::*;
+
+use crate as pallet_message_queue;
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+use sp_std::collections::btree_map::BTreeMap;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		MessageQueue: pallet_message_queue::{Pallet, Call, Storage, Event<T>},
+	}
+);
+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 = 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! {
+	pub const HeapSize: u32 = 24;
+	pub const MaxStale: u32 = 2;
+	pub const ServiceWeight: Option<Weight> = Some(Weight::from_parts(10, 10));
+}
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = MockedWeightInfo;
+	type MessageProcessor = RecordingMessageProcessor;
+	type Size = u32;
+	type QueueChangeHandler = RecordingQueueChangeHandler;
+	type QueuePausedQuery = MockedQueuePauser;
+	type HeapSize = HeapSize;
+	type MaxStale = MaxStale;
+	type ServiceWeight = ServiceWeight;
+}
+
+/// Mocked `WeightInfo` impl with allows to set the weight per call.
+pub struct MockedWeightInfo;
+
+parameter_types! {
+	/// Storage for `MockedWeightInfo`, do not use directly.
+	pub static WeightForCall: BTreeMap<String, Weight> = Default::default();
+}
+
+/// Set the return value for a function from the `WeightInfo` trait.
+impl MockedWeightInfo {
+	/// Set the weight of a specific weight function.
+	pub fn set_weight<T: Config>(call_name: &str, weight: Weight) {
+		let mut calls = WeightForCall::get();
+		calls.insert(call_name.into(), weight);
+		WeightForCall::set(calls);
+	}
+}
+
+impl crate::weights::WeightInfo for MockedWeightInfo {
+	fn reap_page() -> Weight {
+		WeightForCall::get().get("reap_page").copied().unwrap_or_default()
+	}
+	fn execute_overweight_page_updated() -> Weight {
+		WeightForCall::get()
+			.get("execute_overweight_page_updated")
+			.copied()
+			.unwrap_or_default()
+	}
+	fn execute_overweight_page_removed() -> Weight {
+		WeightForCall::get()
+			.get("execute_overweight_page_removed")
+			.copied()
+			.unwrap_or_default()
+	}
+	fn service_page_base_completion() -> Weight {
+		WeightForCall::get()
+			.get("service_page_base_completion")
+			.copied()
+			.unwrap_or_default()
+	}
+	fn service_page_base_no_completion() -> Weight {
+		WeightForCall::get()
+			.get("service_page_base_no_completion")
+			.copied()
+			.unwrap_or_default()
+	}
+	fn service_queue_base() -> Weight {
+		WeightForCall::get().get("service_queue_base").copied().unwrap_or_default()
+	}
+	fn bump_service_head() -> Weight {
+		WeightForCall::get().get("bump_service_head").copied().unwrap_or_default()
+	}
+	fn service_page_item() -> Weight {
+		WeightForCall::get().get("service_page_item").copied().unwrap_or_default()
+	}
+	fn ready_ring_knit() -> Weight {
+		WeightForCall::get().get("ready_ring_knit").copied().unwrap_or_default()
+	}
+	fn ready_ring_unknit() -> Weight {
+		WeightForCall::get().get("ready_ring_unknit").copied().unwrap_or_default()
+	}
+}
+
+parameter_types! {
+	pub static MessagesProcessed: Vec<(Vec<u8>, MessageOrigin)> = vec![];
+	/// Queues that should return `Yield` upon being processed.
+	pub static YieldingQueues: Vec<MessageOrigin> = vec![];
+}
+
+/// A message processor which records all processed messages into [`MessagesProcessed`].
+pub struct RecordingMessageProcessor;
+impl ProcessMessage for RecordingMessageProcessor {
+	/// The transport from where a message originates.
+	type Origin = MessageOrigin;
+
+	/// Process the given message, using no more than `weight_limit` in weight to do so.
+	///
+	/// Consumes exactly `n` weight of all components if it starts `weight=n` and `1` otherwise.
+	/// Errors if given the `weight_limit` is insufficient to process the message or if the message
+	/// is `badformat`, `corrupt` or `unsupported` with the respective error.
+	fn process_message(
+		message: &[u8],
+		origin: Self::Origin,
+		meter: &mut WeightMeter,
+		_id: &mut [u8; 32],
+	) -> Result<bool, ProcessMessageError> {
+		processing_message(message, &origin)?;
+
+		let weight = if message.starts_with(&b"weight="[..]) {
+			let mut w: u64 = 0;
+			for &c in &message[7..] {
+				if (b'0'..=b'9').contains(&c) {
+					w = w * 10 + (c - b'0') as u64;
+				} else {
+					break
+				}
+			}
+			w
+		} else {
+			1
+		};
+		let required = Weight::from_parts(weight, weight);
+
+		if meter.try_consume(required).is_ok() {
+			let mut m = MessagesProcessed::get();
+			m.push((message.to_vec(), origin));
+			MessagesProcessed::set(m);
+			Ok(true)
+		} else {
+			Err(ProcessMessageError::Overweight(required))
+		}
+	}
+}
+
+/// Processed a mocked message. Messages that end with `badformat`, `corrupt`, `unsupported` or
+/// `yield` will fail with an error respectively.
+fn processing_message(msg: &[u8], origin: &MessageOrigin) -> Result<(), ProcessMessageError> {
+	if YieldingQueues::get().contains(&origin) {
+		return Err(ProcessMessageError::Yield)
+	}
+
+	let msg = String::from_utf8_lossy(msg);
+	if msg.ends_with("badformat") {
+		Err(ProcessMessageError::BadFormat)
+	} else if msg.ends_with("corrupt") {
+		Err(ProcessMessageError::Corrupt)
+	} else if msg.ends_with("unsupported") {
+		Err(ProcessMessageError::Unsupported)
+	} else if msg.ends_with("yield") {
+		Err(ProcessMessageError::Yield)
+	} else {
+		Ok(())
+	}
+}
+
+parameter_types! {
+	pub static NumMessagesProcessed: usize = 0;
+	pub static NumMessagesErrored: usize = 0;
+}
+
+/// Similar to [`RecordingMessageProcessor`] but only counts the number of messages processed and
+/// does always consume one weight per message.
+///
+/// The [`RecordingMessageProcessor`] is a bit too slow for the integration tests.
+pub struct CountingMessageProcessor;
+impl ProcessMessage for CountingMessageProcessor {
+	type Origin = MessageOrigin;
+
+	fn process_message(
+		message: &[u8],
+		origin: Self::Origin,
+		meter: &mut WeightMeter,
+		_id: &mut [u8; 32],
+	) -> Result<bool, ProcessMessageError> {
+		if let Err(e) = processing_message(message, &origin) {
+			NumMessagesErrored::set(NumMessagesErrored::get() + 1);
+			return Err(e)
+		}
+		let required = Weight::from_parts(1, 1);
+
+		if meter.try_consume(required).is_ok() {
+			NumMessagesProcessed::set(NumMessagesProcessed::get() + 1);
+			Ok(true)
+		} else {
+			Err(ProcessMessageError::Overweight(required))
+		}
+	}
+}
+
+parameter_types! {
+	/// Storage for `RecordingQueueChangeHandler`, do not use directly.
+	pub static QueueChanges: Vec<(MessageOrigin, u64, u64)> = vec![];
+}
+
+/// Records all queue changes into [`QueueChanges`].
+pub struct RecordingQueueChangeHandler;
+impl OnQueueChanged<MessageOrigin> for RecordingQueueChangeHandler {
+	fn on_queue_changed(id: MessageOrigin, items_count: u64, items_size: u64) {
+		QueueChanges::mutate(|cs| cs.push((id, items_count, items_size)));
+	}
+}
+
+parameter_types! {
+	pub static PausedQueues: Vec<MessageOrigin> = vec![];
+}
+
+pub struct MockedQueuePauser;
+impl QueuePausedQuery<MessageOrigin> for MockedQueuePauser {
+	fn is_paused(id: &MessageOrigin) -> bool {
+		PausedQueues::get().contains(id)
+	}
+}
+
+/// Create new test externalities.
+///
+/// Is generic since it is used by the unit test, integration tests and benchmarks.
+pub fn new_test_ext<T: Config>() -> sp_io::TestExternalities
+where
+	frame_system::pallet_prelude::BlockNumberFor<T>: From<u32>,
+{
+	sp_tracing::try_init_simple();
+	WeightForCall::take();
+	QueueChanges::take();
+	NumMessagesErrored::take();
+	let t = frame_system::GenesisConfig::<T>::default().build_storage().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| frame_system::Pallet::<T>::set_block_number(1.into()));
+	ext
+}
+
+/// Run the function pointer inside externalities and asserts the try_state hook at the end.
+pub fn build_and_execute<T: Config>(test: impl FnOnce() -> ())
+where
+	BlockNumberFor<T>: From<u32>,
+{
+	new_test_ext::<T>().execute_with(|| {
+		test();
+		MessageQueue::do_try_state().expect("All invariants must hold after a test");
+	});
+}
+
+/// Set the weight of a specific weight function.
+pub fn set_weight(name: &str, w: Weight) {
+	MockedWeightInfo::set_weight::<Test>(name, w);
+}
+
+/// Assert that exactly these pages are present. Assumes `Here` origin.
+pub fn assert_pages(indices: &[u32]) {
+	assert_eq!(
+		Pages::<Test>::iter_keys().count(),
+		indices.len(),
+		"Wrong number of pages in the queue"
+	);
+	for i in indices {
+		assert!(Pages::<Test>::contains_key(MessageOrigin::Here, i));
+	}
+}
+
+/// Build a ring with three queues: `Here`, `There` and `Everywhere(0)`.
+pub fn build_triple_ring() {
+	use MessageOrigin::*;
+	build_ring::<Test>(&[Here, There, Everywhere(0)])
+}
+
+/// Shim to get rid of the annoying `::<Test>` everywhere.
+pub fn assert_ring(queues: &[MessageOrigin]) {
+	super::mock_helpers::assert_ring::<Test>(queues);
+}
+
+pub fn knit(queue: &MessageOrigin) {
+	super::mock_helpers::knit::<Test>(queue);
+}
+
+pub fn unknit(queue: &MessageOrigin) {
+	super::mock_helpers::unknit::<Test>(queue);
+}
+
+pub fn num_overweight_enqueued_events() -> u32 {
+	frame_system::Pallet::<Test>::events()
+		.into_iter()
+		.filter(|e| {
+			matches!(e.event, RuntimeEvent::MessageQueue(crate::Event::OverweightEnqueued { .. }))
+		})
+		.count() as u32
+}
diff --git a/substrate/frame/message-queue/src/mock_helpers.rs b/substrate/frame/message-queue/src/mock_helpers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f6109c127be123c427e075d78bf80fbe04baada3
--- /dev/null
+++ b/substrate/frame/message-queue/src/mock_helpers.rs
@@ -0,0 +1,188 @@
+// 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.
+
+//! Std setup helpers for testing and benchmarking.
+//!
+//! Cannot be put into mock.rs since benchmarks require no-std and mock.rs is std.
+
+use crate::*;
+use frame_support::traits::Defensive;
+
+/// Converts `Self` into a `Weight` by using `Self` for all components.
+pub trait IntoWeight {
+	fn into_weight(self) -> Weight;
+}
+
+impl IntoWeight for u64 {
+	fn into_weight(self) -> Weight {
+		Weight::from_parts(self, self)
+	}
+}
+
+/// Mocked message origin for testing.
+#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, MaxEncodedLen, TypeInfo, Debug)]
+pub enum MessageOrigin {
+	Here,
+	There,
+	Everywhere(u32),
+}
+
+impl From<u32> for MessageOrigin {
+	fn from(i: u32) -> Self {
+		Self::Everywhere(i)
+	}
+}
+
+/// Processes any message and consumes `(REQUIRED_WEIGHT, REQUIRED_WEIGHT)` weight.
+///
+/// Returns [ProcessMessageError::Overweight] error if the weight limit is not sufficient.
+pub struct NoopMessageProcessor<Origin, const REQUIRED_WEIGHT: u64 = 1>(PhantomData<Origin>);
+impl<Origin, const REQUIRED_WEIGHT: u64> ProcessMessage
+	for NoopMessageProcessor<Origin, REQUIRED_WEIGHT>
+where
+	Origin: codec::FullCodec + MaxEncodedLen + Clone + Eq + PartialEq + TypeInfo + Debug,
+{
+	type Origin = Origin;
+
+	fn process_message(
+		_message: &[u8],
+		_origin: Self::Origin,
+		meter: &mut WeightMeter,
+		_id: &mut [u8; 32],
+	) -> Result<bool, ProcessMessageError> {
+		let required = Weight::from_parts(REQUIRED_WEIGHT, REQUIRED_WEIGHT);
+
+		if meter.try_consume(required).is_ok() {
+			Ok(true)
+		} else {
+			Err(ProcessMessageError::Overweight(required))
+		}
+	}
+}
+
+/// Create a message from the given data.
+pub fn msg<N: Get<u32>>(x: &str) -> BoundedSlice<u8, N> {
+	BoundedSlice::defensive_truncate_from(x.as_bytes())
+}
+
+pub fn vmsg(x: &str) -> Vec<u8> {
+	x.as_bytes().to_vec()
+}
+
+/// Create a page from a single message.
+pub fn page<T: Config>(msg: &[u8]) -> PageOf<T> {
+	PageOf::<T>::from_message::<T>(msg.try_into().unwrap())
+}
+
+pub fn single_page_book<T: Config>() -> BookStateOf<T> {
+	BookState { begin: 0, end: 1, count: 1, message_count: 1, size: 1, ..Default::default() }
+}
+
+pub fn empty_book<T: Config>() -> BookStateOf<T> {
+	BookState { begin: 0, end: 1, count: 1, ..Default::default() }
+}
+
+/// Returns a full page of messages with their index as payload and the number of messages.
+pub fn full_page<T: Config>() -> (PageOf<T>, usize) {
+	let mut msgs = 0;
+	let mut page = PageOf::<T>::default();
+	for i in 0..u32::MAX {
+		let r = i.using_encoded(|d| page.try_append_message::<T>(d.try_into().unwrap()));
+		if r.is_err() {
+			break
+		} else {
+			msgs += 1;
+		}
+	}
+	assert!(msgs > 0, "page must hold at least one message");
+	(page, msgs)
+}
+
+/// Returns a page filled with empty messages and the number of messages.
+pub fn book_for<T: Config>(page: &PageOf<T>) -> BookStateOf<T> {
+	BookState {
+		count: 1,
+		begin: 0,
+		end: 1,
+		message_count: page.remaining.into() as u64,
+		size: page.remaining_size.into() as u64,
+		..Default::default()
+	}
+}
+
+/// Assert the last event that was emitted.
+#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
+pub fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	assert!(
+		!frame_system::Pallet::<T>::block_number().is_zero(),
+		"The genesis block has n o events"
+	);
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+/// Provide a setup for `bump_service_head`.
+pub fn setup_bump_service_head<T: Config>(
+	current: <<T as Config>::MessageProcessor as ProcessMessage>::Origin,
+	next: <<T as Config>::MessageProcessor as ProcessMessage>::Origin,
+) {
+	crate::Pallet::<T>::enqueue_message(msg("1"), current);
+	crate::Pallet::<T>::enqueue_message(msg("1"), next);
+}
+
+/// Knit a queue into the ready-ring and write it back to storage.
+pub fn knit<T: Config>(o: &<<T as Config>::MessageProcessor as ProcessMessage>::Origin) {
+	let mut b = BookStateFor::<T>::get(o);
+	b.ready_neighbours = crate::Pallet::<T>::ready_ring_knit(o).ok().defensive();
+	BookStateFor::<T>::insert(o, b);
+}
+
+/// Unknit a queue into the ready-ring and write it back to storage.
+pub fn unknit<T: Config>(o: &<<T as Config>::MessageProcessor as ProcessMessage>::Origin) {
+	let mut b = BookStateFor::<T>::get(o);
+	crate::Pallet::<T>::ready_ring_unknit(o, b.ready_neighbours.unwrap());
+	b.ready_neighbours = None;
+	BookStateFor::<T>::insert(o, b);
+}
+
+/// Build a ring with three queues: `Here`, `There` and `Everywhere(0)`.
+pub fn build_ring<T: Config>(
+	queues: &[<<T as Config>::MessageProcessor as ProcessMessage>::Origin],
+) {
+	for queue in queues.iter() {
+		crate::Pallet::<T>::enqueue_message(msg("1"), queue.clone());
+	}
+	assert_ring::<T>(queues);
+}
+
+/// Check that the Ready Ring consists of `queues` in that exact order.
+///
+/// Also check that all backlinks are valid and that the first element is the service head.
+pub fn assert_ring<T: Config>(
+	queues: &[<<T as Config>::MessageProcessor as ProcessMessage>::Origin],
+) {
+	for (i, origin) in queues.iter().enumerate() {
+		let book = BookStateFor::<T>::get(origin);
+		assert_eq!(
+			book.ready_neighbours,
+			Some(Neighbours {
+				prev: queues[(i + queues.len() - 1) % queues.len()].clone(),
+				next: queues[(i + 1) % queues.len()].clone(),
+			})
+		);
+	}
+	assert_eq!(ServiceHead::<T>::get(), queues.first().cloned());
+}
diff --git a/substrate/frame/message-queue/src/tests.rs b/substrate/frame/message-queue/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bcb099a6accd12b29abe5a6865e551fab5c23627
--- /dev/null
+++ b/substrate/frame/message-queue/src/tests.rs
@@ -0,0 +1,1449 @@
+// 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 Message Queue Pallet.
+
+#![cfg(test)]
+
+use crate::{mock::*, *};
+
+use frame_support::{assert_noop, assert_ok, assert_storage_noop, StorageNoopGuard};
+use rand::{rngs::StdRng, Rng, SeedableRng};
+use sp_core::blake2_256;
+
+#[test]
+fn mocked_weight_works() {
+	build_and_execute::<Test>(|| {
+		assert!(<Test as Config>::WeightInfo::service_queue_base().is_zero());
+	});
+	build_and_execute::<Test>(|| {
+		set_weight("service_queue_base", Weight::MAX);
+		assert_eq!(<Test as Config>::WeightInfo::service_queue_base(), Weight::MAX);
+	});
+	// The externalities reset it.
+	build_and_execute::<Test>(|| {
+		assert!(<Test as Config>::WeightInfo::service_queue_base().is_zero());
+	});
+}
+
+#[test]
+fn enqueue_within_one_page_works() {
+	build_and_execute::<Test>(|| {
+		use MessageOrigin::*;
+		MessageQueue::enqueue_message(msg("a"), Here);
+		MessageQueue::enqueue_message(msg("b"), Here);
+		MessageQueue::enqueue_message(msg("c"), Here);
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(b"a".to_vec(), Here), (b"b".to_vec(), Here)]);
+
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(b"c".to_vec(), Here)]);
+
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 0.into_weight());
+		assert!(MessagesProcessed::get().is_empty());
+
+		MessageQueue::enqueue_messages([msg("a"), msg("b"), msg("c")].into_iter(), There);
+
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(
+			MessagesProcessed::take(),
+			vec![(b"a".to_vec(), There), (b"b".to_vec(), There),]
+		);
+
+		MessageQueue::enqueue_message(msg("d"), Everywhere(1));
+
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 0.into_weight());
+		assert_eq!(
+			MessagesProcessed::take(),
+			vec![(b"c".to_vec(), There), (b"d".to_vec(), Everywhere(1))]
+		);
+	});
+}
+
+#[test]
+fn queue_priority_retains() {
+	build_and_execute::<Test>(|| {
+		use MessageOrigin::*;
+		assert_ring(&[]);
+		MessageQueue::enqueue_message(msg("a"), Everywhere(1));
+		assert_ring(&[Everywhere(1)]);
+		MessageQueue::enqueue_message(msg("b"), Everywhere(2));
+		assert_ring(&[Everywhere(1), Everywhere(2)]);
+		MessageQueue::enqueue_message(msg("c"), Everywhere(3));
+		assert_ring(&[Everywhere(1), Everywhere(2), Everywhere(3)]);
+		MessageQueue::enqueue_message(msg("d"), Everywhere(2));
+		assert_ring(&[Everywhere(1), Everywhere(2), Everywhere(3)]);
+		// service head is 1, it will process a, leaving service head at 2. it also processes b but
+		// doees not empty queue 2, so service head will end at 2.
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(
+			MessagesProcessed::take(),
+			vec![(vmsg("a"), Everywhere(1)), (vmsg("b"), Everywhere(2)),]
+		);
+		assert_ring(&[Everywhere(2), Everywhere(3)]);
+		// service head is 2, so will process d first, then c.
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(
+			MessagesProcessed::get(),
+			vec![(vmsg("d"), Everywhere(2)), (vmsg("c"), Everywhere(3)),]
+		);
+		assert_ring(&[]);
+	});
+}
+
+#[test]
+fn queue_priority_reset_once_serviced() {
+	build_and_execute::<Test>(|| {
+		use MessageOrigin::*;
+		MessageQueue::enqueue_message(msg("a"), Everywhere(1));
+		MessageQueue::enqueue_message(msg("b"), Everywhere(2));
+		MessageQueue::enqueue_message(msg("c"), Everywhere(3));
+		MessageQueue::do_try_state().unwrap();
+		println!("{}", MessageQueue::debug_info());
+		// service head is 1, it will process a, leaving service head at 2. it also processes b and
+		// empties queue 2, so service head will end at 3.
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		MessageQueue::enqueue_message(msg("d"), Everywhere(2));
+		// service head is 3, so will process c first, then d.
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+
+		assert_eq!(
+			MessagesProcessed::get(),
+			vec![
+				(vmsg("a"), Everywhere(1)),
+				(vmsg("b"), Everywhere(2)),
+				(vmsg("c"), Everywhere(3)),
+				(vmsg("d"), Everywhere(2)),
+			]
+		);
+	});
+}
+
+#[test]
+fn service_queues_basic_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		MessageQueue::enqueue_messages(vec![msg("a"), msg("ab"), msg("abc")].into_iter(), Here);
+		MessageQueue::enqueue_messages(vec![msg("x"), msg("xy"), msg("xyz")].into_iter(), There);
+		assert_eq!(QueueChanges::take(), vec![(Here, 3, 6), (There, 3, 6)]);
+
+		// Service one message from `Here`.
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("a"), Here)]);
+		assert_eq!(QueueChanges::take(), vec![(Here, 2, 5)]);
+
+		// Service one message from `There`.
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("x"), There)]);
+		assert_eq!(QueueChanges::take(), vec![(There, 2, 5)]);
+
+		// Service the remaining from `Here`.
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("ab"), Here), (vmsg("abc"), Here)]);
+		assert_eq!(QueueChanges::take(), vec![(Here, 0, 0)]);
+
+		// Service all remaining messages.
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), 2.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("xy"), There), (vmsg("xyz"), There)]);
+		assert_eq!(QueueChanges::take(), vec![(There, 0, 0)]);
+		MessageQueue::do_try_state().unwrap();
+	});
+}
+
+#[test]
+fn service_queues_failing_messages_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		set_weight("service_page_item", 1.into_weight());
+		MessageQueue::enqueue_message(msg("badformat"), Here);
+		MessageQueue::enqueue_message(msg("corrupt"), Here);
+		MessageQueue::enqueue_message(msg("unsupported"), Here);
+		MessageQueue::enqueue_message(msg("yield"), Here);
+		// Starts with four pages.
+		assert_pages(&[0, 1, 2, 3]);
+
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_last_event::<Test>(
+			Event::ProcessingFailed {
+				id: blake2_256(b"badformat"),
+				origin: MessageOrigin::Here,
+				error: ProcessMessageError::BadFormat,
+			}
+			.into(),
+		);
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_last_event::<Test>(
+			Event::ProcessingFailed {
+				id: blake2_256(b"corrupt"),
+				origin: MessageOrigin::Here,
+				error: ProcessMessageError::Corrupt,
+			}
+			.into(),
+		);
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_last_event::<Test>(
+			Event::ProcessingFailed {
+				id: blake2_256(b"unsupported"),
+				origin: MessageOrigin::Here,
+				error: ProcessMessageError::Unsupported,
+			}
+			.into(),
+		);
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(System::events().len(), 3);
+		// Last page with the `yield` stays in.
+		assert_pages(&[3]);
+	});
+}
+
+#[test]
+fn service_queues_suspension_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		MessageQueue::enqueue_messages(vec![msg("a"), msg("b"), msg("c")].into_iter(), Here);
+		MessageQueue::enqueue_messages(vec![msg("x"), msg("y"), msg("z")].into_iter(), There);
+		MessageQueue::enqueue_messages(
+			vec![msg("m"), msg("n"), msg("o")].into_iter(),
+			Everywhere(0),
+		);
+		assert_eq!(QueueChanges::take(), vec![(Here, 3, 3), (There, 3, 3), (Everywhere(0), 3, 3)]);
+
+		// Service one message from `Here`.
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("a"), Here)]);
+		assert_eq!(QueueChanges::take(), vec![(Here, 2, 2)]);
+
+		// Make queue `Here` and `Everywhere(0)` yield.
+		YieldingQueues::set(vec![Here, Everywhere(0)]);
+
+		// Service one message from `There`.
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("x"), There)]);
+		assert_eq!(QueueChanges::take(), vec![(There, 2, 2)]);
+
+		// Now it would normally swap to `Everywhere(0)` and `Here`, but they are paused so we
+		// expect `There` again.
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("y"), There), (vmsg("z"), There)]);
+
+		// Processing with max-weight won't do anything.
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), Weight::zero());
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), Weight::zero());
+
+		// ... until we resume `Here`:
+		YieldingQueues::set(vec![Everywhere(0)]);
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), 2.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("b"), Here), (vmsg("c"), Here)]);
+
+		// Everywhere still won't move.
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), Weight::zero());
+		YieldingQueues::take();
+		// Resume `Everywhere(0)` makes it work.
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), 3.into_weight());
+		assert_eq!(
+			MessagesProcessed::take(),
+			vec![
+				(vmsg("m"), Everywhere(0)),
+				(vmsg("n"), Everywhere(0)),
+				(vmsg("o"), Everywhere(0))
+			]
+		);
+	});
+}
+
+#[test]
+fn reap_page_permanent_overweight_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		// Create 10 pages more than the stale limit.
+		let n = (MaxStale::get() + 10) as usize;
+		for _ in 0..n {
+			MessageQueue::enqueue_message(msg("weight=2"), Here);
+		}
+		assert_eq!(Pages::<Test>::iter().count(), n);
+		assert_eq!(QueueChanges::take().len(), n);
+		// Mark all pages as stale since their message is permanently overweight.
+		MessageQueue::service_queues(1.into_weight());
+
+		// Check that we can reap everything below the watermark.
+		let max_stale = MaxStale::get();
+		for i in 0..n as u32 {
+			let b = BookStateFor::<Test>::get(Here);
+			let stale_pages = n as u32 - i;
+			let overflow = stale_pages.saturating_sub(max_stale + 1) + 1;
+			let backlog = (max_stale * max_stale / overflow).max(max_stale);
+			let watermark = b.begin.saturating_sub(backlog);
+
+			if i >= watermark {
+				break
+			}
+			assert_ok!(MessageQueue::do_reap_page(&Here, i));
+			assert_eq!(QueueChanges::take(), vec![(Here, b.message_count - 1, b.size - 8)]);
+		}
+
+		// Cannot reap any more pages.
+		for (o, i, _) in Pages::<Test>::iter() {
+			assert_noop!(MessageQueue::do_reap_page(&o, i), Error::<Test>::NotReapable);
+			assert!(QueueChanges::take().is_empty());
+		}
+	});
+}
+
+#[test]
+fn reaping_overweight_fails_properly() {
+	use MessageOrigin::*;
+	assert_eq!(MaxStale::get(), 2, "The stale limit is two");
+
+	build_and_execute::<Test>(|| {
+		// page 0
+		MessageQueue::enqueue_message(msg("weight=4"), Here);
+		MessageQueue::enqueue_message(msg("a"), Here);
+		// page 1
+		MessageQueue::enqueue_message(msg("weight=4"), Here);
+		MessageQueue::enqueue_message(msg("b"), Here);
+		// page 2
+		MessageQueue::enqueue_message(msg("weight=4"), Here);
+		MessageQueue::enqueue_message(msg("c"), Here);
+		// page 3
+		MessageQueue::enqueue_message(msg("bigbig 1"), Here);
+		// page 4
+		MessageQueue::enqueue_message(msg("bigbig 2"), Here);
+		// page 5
+		MessageQueue::enqueue_message(msg("bigbig 3"), Here);
+		// Double-check that exactly these pages exist.
+		assert_pages(&[0, 1, 2, 3, 4, 5]);
+
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("a"), Here), (vmsg("b"), Here)]);
+		// 2 stale now.
+
+		// Nothing reapable yet, because we haven't hit the stale limit.
+		for (o, i, _) in Pages::<Test>::iter() {
+			assert_noop!(MessageQueue::do_reap_page(&o, i), Error::<Test>::NotReapable);
+		}
+		assert_pages(&[0, 1, 2, 3, 4, 5]);
+
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("c"), Here)]);
+		// 3 stale now: can take something 4 pages in history.
+
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("bigbig 1"), Here)]);
+
+		// Nothing reapable yet, because we haven't hit the stale limit.
+		for (o, i, _) in Pages::<Test>::iter() {
+			assert_noop!(MessageQueue::do_reap_page(&o, i), Error::<Test>::NotReapable);
+		}
+		assert_pages(&[0, 1, 2, 4, 5]);
+
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("bigbig 2"), Here)]);
+		assert_pages(&[0, 1, 2, 5]);
+
+		// First is now reapable as it is too far behind the first ready page (5).
+		assert_ok!(MessageQueue::do_reap_page(&Here, 0));
+		// Others not reapable yet, because we haven't hit the stale limit.
+		for (o, i, _) in Pages::<Test>::iter() {
+			assert_noop!(MessageQueue::do_reap_page(&o, i), Error::<Test>::NotReapable);
+		}
+		assert_pages(&[1, 2, 5]);
+
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("bigbig 3"), Here)]);
+
+		assert_noop!(MessageQueue::do_reap_page(&Here, 0), Error::<Test>::NoPage);
+		assert_noop!(MessageQueue::do_reap_page(&Here, 3), Error::<Test>::NoPage);
+		assert_noop!(MessageQueue::do_reap_page(&Here, 4), Error::<Test>::NoPage);
+		// Still not reapable, since the number of stale pages is only 2.
+		for (o, i, _) in Pages::<Test>::iter() {
+			assert_noop!(MessageQueue::do_reap_page(&o, i), Error::<Test>::NotReapable);
+		}
+	});
+}
+
+#[test]
+fn service_queue_bails() {
+	// Not enough weight for `service_queue_base`.
+	build_and_execute::<Test>(|| {
+		set_weight("service_queue_base", 2.into_weight());
+		let mut meter = WeightMeter::from_limit(1.into_weight());
+
+		assert_storage_noop!(MessageQueue::service_queue(0u32.into(), &mut meter, Weight::MAX));
+		assert!(meter.consumed().is_zero());
+	});
+	// Not enough weight for `ready_ring_unknit`.
+	build_and_execute::<Test>(|| {
+		set_weight("ready_ring_unknit", 2.into_weight());
+		let mut meter = WeightMeter::from_limit(1.into_weight());
+
+		assert_storage_noop!(MessageQueue::service_queue(0u32.into(), &mut meter, Weight::MAX));
+		assert!(meter.consumed().is_zero());
+	});
+	// Not enough weight for `service_queue_base` and `ready_ring_unknit`.
+	build_and_execute::<Test>(|| {
+		set_weight("service_queue_base", 2.into_weight());
+		set_weight("ready_ring_unknit", 2.into_weight());
+
+		let mut meter = WeightMeter::from_limit(3.into_weight());
+		assert_storage_noop!(MessageQueue::service_queue(0.into(), &mut meter, Weight::MAX));
+		assert!(meter.consumed().is_zero());
+	});
+}
+
+#[test]
+fn service_page_works() {
+	use super::integration_test::Test; // Run with larger page size.
+	use MessageOrigin::*;
+	use PageExecutionStatus::*;
+	build_and_execute::<Test>(|| {
+		set_weight("service_page_base_completion", 2.into_weight());
+		set_weight("service_page_item", 3.into_weight());
+
+		let (page, mut msgs) = full_page::<Test>();
+		assert!(msgs >= 10, "pre-condition: need at least 10 msgs per page");
+		let mut book = book_for::<Test>(&page);
+		Pages::<Test>::insert(Here, 0, page);
+
+		// Call it a few times each with a random weight limit.
+		let mut rng = rand::rngs::StdRng::seed_from_u64(42);
+		while msgs > 0 {
+			let process = rng.gen_range(0..=msgs);
+			msgs -= process;
+
+			//  Enough weight to process `process` messages.
+			let mut meter = WeightMeter::from_limit(((2 + (3 + 1) * process) as u64).into_weight());
+			System::reset_events();
+			let (processed, status) =
+				crate::Pallet::<Test>::service_page(&Here, &mut book, &mut meter, Weight::MAX);
+			assert_eq!(processed as usize, process);
+			assert_eq!(NumMessagesProcessed::take(), process);
+			assert_eq!(System::events().len(), process);
+			if msgs == 0 {
+				assert_eq!(status, NoMore);
+			} else {
+				assert_eq!(status, Bailed);
+			}
+		}
+		assert_pages(&[]);
+	});
+}
+
+// `service_page` does nothing when called with an insufficient weight limit.
+#[test]
+fn service_page_bails() {
+	// Not enough weight for `service_page_base_completion`.
+	build_and_execute::<Test>(|| {
+		set_weight("service_page_base_completion", 2.into_weight());
+		let mut meter = WeightMeter::from_limit(1.into_weight());
+
+		let (page, _) = full_page::<Test>();
+		let mut book = book_for::<Test>(&page);
+		Pages::<Test>::insert(MessageOrigin::Here, 0, page);
+
+		assert_storage_noop!(MessageQueue::service_page(
+			&MessageOrigin::Here,
+			&mut book,
+			&mut meter,
+			Weight::MAX
+		));
+		assert!(meter.consumed().is_zero());
+	});
+	// Not enough weight for `service_page_base_no_completion`.
+	build_and_execute::<Test>(|| {
+		set_weight("service_page_base_no_completion", 2.into_weight());
+		let mut meter = WeightMeter::from_limit(1.into_weight());
+
+		let (page, _) = full_page::<Test>();
+		let mut book = book_for::<Test>(&page);
+		Pages::<Test>::insert(MessageOrigin::Here, 0, page);
+
+		assert_storage_noop!(MessageQueue::service_page(
+			&MessageOrigin::Here,
+			&mut book,
+			&mut meter,
+			Weight::MAX
+		));
+		assert!(meter.consumed().is_zero());
+	});
+}
+
+#[test]
+fn service_page_item_bails() {
+	build_and_execute::<Test>(|| {
+		let _guard = StorageNoopGuard::default();
+		let (mut page, _) = full_page::<Test>();
+		let mut weight = WeightMeter::from_limit(10.into_weight());
+		let overweight_limit = 10.into_weight();
+		set_weight("service_page_item", 11.into_weight());
+
+		assert_eq!(
+			MessageQueue::service_page_item(
+				&MessageOrigin::Here,
+				0,
+				&mut book_for::<Test>(&page),
+				&mut page,
+				&mut weight,
+				overweight_limit,
+			),
+			ItemExecutionStatus::Bailed
+		);
+	});
+}
+
+#[test]
+fn service_page_suspension_works() {
+	use super::integration_test::Test; // Run with larger page size.
+	use MessageOrigin::*;
+	use PageExecutionStatus::*;
+
+	build_and_execute::<Test>(|| {
+		let (page, mut msgs) = full_page::<Test>();
+		assert!(msgs >= 10, "pre-condition: need at least 10 msgs per page");
+		let mut book = book_for::<Test>(&page);
+		Pages::<Test>::insert(Here, 0, page);
+
+		// First we process 5 messages from this page.
+		let mut meter = WeightMeter::from_limit(5.into_weight());
+		let (_, status) =
+			crate::Pallet::<Test>::service_page(&Here, &mut book, &mut meter, Weight::MAX);
+
+		assert_eq!(NumMessagesProcessed::take(), 5);
+		assert!(meter.remaining().is_zero());
+		assert_eq!(status, Bailed); // It bailed since weight is missing.
+		msgs -= 5;
+
+		// Then we pause the queue.
+		YieldingQueues::set(vec![Here]);
+		// Noting happens...
+		for _ in 0..5 {
+			let (_, status) = crate::Pallet::<Test>::service_page(
+				&Here,
+				&mut book,
+				&mut WeightMeter::max_limit(),
+				Weight::MAX,
+			);
+			assert_eq!(status, NoProgress);
+			assert!(NumMessagesProcessed::take().is_zero());
+		}
+
+		// Resume and process all remaining.
+		YieldingQueues::take();
+		let (_, status) = crate::Pallet::<Test>::service_page(
+			&Here,
+			&mut book,
+			&mut WeightMeter::max_limit(),
+			Weight::MAX,
+		);
+		assert_eq!(status, NoMore);
+		assert_eq!(NumMessagesProcessed::take(), msgs);
+
+		assert!(Pages::<Test>::iter_keys().count().is_zero());
+	});
+}
+
+#[test]
+fn bump_service_head_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		build_triple_ring();
+
+		// Bump 99 times.
+		for i in 0..99 {
+			let current = MessageQueue::bump_service_head(&mut WeightMeter::max_limit()).unwrap();
+			assert_eq!(current, [Here, There, Everywhere(0)][i % 3]);
+		}
+
+		// The ready ring is intact and the service head is still `Here`.
+		assert_ring(&[Here, There, Everywhere(0)]);
+	});
+}
+
+/// `bump_service_head` does nothing when called with an insufficient weight limit.
+#[test]
+fn bump_service_head_bails() {
+	build_and_execute::<Test>(|| {
+		set_weight("bump_service_head", 2.into_weight());
+		setup_bump_service_head::<Test>(0.into(), 1.into());
+
+		let _guard = StorageNoopGuard::default();
+		let mut meter = WeightMeter::from_limit(1.into_weight());
+		assert!(MessageQueue::bump_service_head(&mut meter).is_none());
+		assert_eq!(meter.consumed(), 0.into_weight());
+	});
+}
+
+#[test]
+fn bump_service_head_trivial_works() {
+	build_and_execute::<Test>(|| {
+		set_weight("bump_service_head", 2.into_weight());
+		let mut meter = WeightMeter::max_limit();
+
+		assert_eq!(MessageQueue::bump_service_head(&mut meter), None, "Cannot bump");
+		assert_eq!(meter.consumed(), 2.into_weight());
+
+		setup_bump_service_head::<Test>(0.into(), 1.into());
+
+		assert_eq!(MessageQueue::bump_service_head(&mut meter), Some(0.into()));
+		assert_eq!(ServiceHead::<Test>::get().unwrap(), 1.into(), "Bumped the head");
+		assert_eq!(meter.consumed(), 4.into_weight());
+
+		assert_eq!(MessageQueue::bump_service_head(&mut meter), Some(1.into()), "Its a ring");
+		assert_eq!(meter.consumed(), 6.into_weight());
+	});
+}
+
+#[test]
+fn bump_service_head_no_head_noops() {
+	build_and_execute::<Test>(|| {
+		build_triple_ring();
+
+		// But remove the service head.
+		ServiceHead::<Test>::kill();
+
+		// Nothing happens.
+		assert_storage_noop!(MessageQueue::bump_service_head(&mut WeightMeter::max_limit()));
+	});
+}
+
+#[test]
+fn service_page_item_consumes_correct_weight() {
+	build_and_execute::<Test>(|| {
+		let mut page = page::<Test>(b"weight=3");
+		let mut weight = WeightMeter::from_limit(10.into_weight());
+		let overweight_limit = 0.into_weight();
+		set_weight("service_page_item", 2.into_weight());
+
+		assert_eq!(
+			MessageQueue::service_page_item(
+				&MessageOrigin::Here,
+				0,
+				&mut book_for::<Test>(&page),
+				&mut page,
+				&mut weight,
+				overweight_limit
+			),
+			ItemExecutionStatus::Executed(true)
+		);
+		assert_eq!(weight.consumed(), 5.into_weight());
+	});
+}
+
+/// `service_page_item` skips a permanently `Overweight` message and marks it as `unprocessed`.
+#[test]
+fn service_page_item_skips_perm_overweight_message() {
+	build_and_execute::<Test>(|| {
+		let mut page = page::<Test>(b"TooMuch");
+		let mut weight = WeightMeter::from_limit(2.into_weight());
+		let overweight_limit = 0.into_weight();
+		set_weight("service_page_item", 2.into_weight());
+
+		assert_eq!(
+			crate::Pallet::<Test>::service_page_item(
+				&MessageOrigin::Here,
+				0,
+				&mut book_for::<Test>(&page),
+				&mut page,
+				&mut weight,
+				overweight_limit
+			),
+			ItemExecutionStatus::Executed(false)
+		);
+		assert_eq!(weight.consumed(), 2.into_weight());
+		assert_last_event::<Test>(
+			Event::OverweightEnqueued {
+				id: blake2_256(b"TooMuch"),
+				origin: MessageOrigin::Here,
+				message_index: 0,
+				page_index: 0,
+			}
+			.into(),
+		);
+
+		// Check that the message was skipped.
+		let (pos, processed, payload) = page.peek_index(0).unwrap();
+		assert_eq!(pos, 0);
+		assert!(!processed);
+		assert_eq!(payload, b"TooMuch".encode());
+	});
+}
+
+#[test]
+fn peek_index_works() {
+	use super::integration_test::Test; // Run with larger page size.
+	build_and_execute::<Test>(|| {
+		// Fill a page with messages.
+		let (mut page, msgs) = full_page::<Test>();
+		let msg_enc_len = ItemHeader::<<Test as Config>::Size>::max_encoded_len() + 4;
+
+		for i in 0..msgs {
+			// Skip all even messages.
+			page.skip_first(i % 2 == 0);
+			// Peek each message and check that it is correct.
+			let (pos, processed, payload) = page.peek_index(i).unwrap();
+			assert_eq!(pos, msg_enc_len * i);
+			assert_eq!(processed, i % 2 == 0);
+			// `full_page` uses the index as payload.
+			assert_eq!(payload, (i as u32).encode());
+		}
+	});
+}
+
+#[test]
+fn peek_first_and_skip_first_works() {
+	use super::integration_test::Test; // Run with larger page size.
+	build_and_execute::<Test>(|| {
+		// Fill a page with messages.
+		let (mut page, msgs) = full_page::<Test>();
+
+		for i in 0..msgs {
+			let msg = page.peek_first().unwrap();
+			// `full_page` uses the index as payload.
+			assert_eq!(msg.deref(), (i as u32).encode());
+			page.skip_first(i % 2 == 0); // True of False should not matter here.
+		}
+		assert!(page.peek_first().is_none(), "Page must be at the end");
+
+		// Check that all messages were correctly marked as (un)processed.
+		for i in 0..msgs {
+			let (_, processed, _) = page.peek_index(i).unwrap();
+			assert_eq!(processed, i % 2 == 0);
+		}
+	});
+}
+
+#[test]
+fn note_processed_at_pos_works() {
+	use super::integration_test::Test; // Run with larger page size.
+	build_and_execute::<Test>(|| {
+		let (mut page, msgs) = full_page::<Test>();
+
+		for i in 0..msgs {
+			let (pos, processed, _) = page.peek_index(i).unwrap();
+			assert!(!processed);
+			assert_eq!(page.remaining as usize, msgs - i);
+
+			page.note_processed_at_pos(pos);
+
+			let (_, processed, _) = page.peek_index(i).unwrap();
+			assert!(processed);
+			assert_eq!(page.remaining as usize, msgs - i - 1);
+		}
+		// `skip_first` still works fine.
+		for _ in 0..msgs {
+			page.peek_first().unwrap();
+			page.skip_first(false);
+		}
+		assert!(page.peek_first().is_none());
+	});
+}
+
+#[test]
+fn note_processed_at_pos_idempotent() {
+	let (mut page, _) = full_page::<Test>();
+	page.note_processed_at_pos(0);
+
+	let original = page.clone();
+	page.note_processed_at_pos(0);
+	assert_eq!(page.heap, original.heap);
+}
+
+#[test]
+fn is_complete_works() {
+	use super::integration_test::Test; // Run with larger page size.
+	build_and_execute::<Test>(|| {
+		let (mut page, msgs) = full_page::<Test>();
+		assert!(msgs > 3, "Boring");
+		let msg_enc_len = ItemHeader::<<Test as Config>::Size>::max_encoded_len() + 4;
+
+		assert!(!page.is_complete());
+		for i in 0..msgs {
+			if i % 2 == 0 {
+				page.skip_first(false);
+			} else {
+				page.note_processed_at_pos(msg_enc_len * i);
+			}
+		}
+		// Not complete since `skip_first` was called with `false`.
+		assert!(!page.is_complete());
+		for i in 0..msgs {
+			if i % 2 == 0 {
+				assert!(!page.is_complete());
+				let (pos, _, _) = page.peek_index(i).unwrap();
+				page.note_processed_at_pos(pos);
+			}
+		}
+		assert!(page.is_complete());
+		assert_eq!(page.remaining_size, 0);
+		// Each message is marked as processed.
+		for i in 0..msgs {
+			let (_, processed, _) = page.peek_index(i).unwrap();
+			assert!(processed);
+		}
+	});
+}
+
+#[test]
+fn page_from_message_basic_works() {
+	assert!(MaxMessageLenOf::<Test>::get() > 0, "pre-condition unmet");
+	let mut msg: BoundedVec<u8, MaxMessageLenOf<Test>> = Default::default();
+	msg.bounded_resize(MaxMessageLenOf::<Test>::get() as usize, 123);
+
+	let page = PageOf::<Test>::from_message::<Test>(msg.as_bounded_slice());
+	assert_eq!(page.remaining, 1);
+	assert_eq!(page.remaining_size as usize, msg.len());
+	assert!(page.first_index == 0 && page.first == 0 && page.last == 0);
+
+	// Verify the content of the heap.
+	let mut heap = Vec::<u8>::new();
+	let header =
+		ItemHeader::<<Test as Config>::Size> { payload_len: msg.len() as u32, is_processed: false };
+	heap.extend(header.encode());
+	heap.extend(msg.deref());
+	assert_eq!(page.heap, heap);
+}
+
+#[test]
+fn page_try_append_message_basic_works() {
+	use super::integration_test::Test; // Run with larger page size.
+
+	let mut page = PageOf::<Test>::default();
+	let mut msgs = 0;
+	// Append as many 4-byte message as possible.
+	for i in 0..u32::MAX {
+		let r = i.using_encoded(|i| page.try_append_message::<Test>(i.try_into().unwrap()));
+		if r.is_err() {
+			break
+		} else {
+			msgs += 1;
+		}
+	}
+	let expected_msgs = (<Test as Config>::HeapSize::get()) /
+		(ItemHeader::<<Test as Config>::Size>::max_encoded_len() as u32 + 4);
+	assert_eq!(expected_msgs, msgs, "Wrong number of messages");
+	assert_eq!(page.remaining, msgs);
+	assert_eq!(page.remaining_size, msgs * 4);
+
+	// Verify that the heap content is correct.
+	let mut heap = Vec::<u8>::new();
+	for i in 0..msgs {
+		let header = ItemHeader::<<Test as Config>::Size> { payload_len: 4, is_processed: false };
+		heap.extend(header.encode());
+		heap.extend(i.encode());
+	}
+	assert_eq!(page.heap, heap);
+}
+
+#[test]
+fn page_try_append_message_max_msg_len_works_works() {
+	use super::integration_test::Test; // Run with larger page size.
+
+	// We start off with an empty page.
+	let mut page = PageOf::<Test>::default();
+	// … and append a message with maximum possible length.
+	let msg = vec![123u8; MaxMessageLenOf::<Test>::get() as usize];
+	// … which works.
+	page.try_append_message::<Test>(BoundedSlice::defensive_truncate_from(&msg))
+		.unwrap();
+	// Now we cannot append *anything* since the heap is full.
+	page.try_append_message::<Test>(BoundedSlice::defensive_truncate_from(&[]))
+		.unwrap_err();
+	assert_eq!(page.heap.len(), <Test as Config>::HeapSize::get() as usize);
+}
+
+#[test]
+fn page_try_append_message_with_remaining_size_works_works() {
+	use super::integration_test::Test; // Run with larger page size.
+	let header_size = ItemHeader::<<Test as Config>::Size>::max_encoded_len();
+
+	// We start off with an empty page.
+	let mut page = PageOf::<Test>::default();
+	let mut remaining = <Test as Config>::HeapSize::get() as usize;
+	let mut msgs = Vec::new();
+	let mut rng = StdRng::seed_from_u64(42);
+	// Now we keep appending messages with different lengths.
+	while remaining >= header_size {
+		let take = rng.gen_range(0..=(remaining - header_size));
+		let msg = vec![123u8; take];
+		page.try_append_message::<Test>(BoundedSlice::defensive_truncate_from(&msg))
+			.unwrap();
+		remaining -= take + header_size;
+		msgs.push(msg);
+	}
+	// Cannot even fit a single header in there now.
+	assert!(remaining < header_size);
+	assert_eq!(<Test as Config>::HeapSize::get() as usize - page.heap.len(), remaining);
+	assert_eq!(page.remaining as usize, msgs.len());
+	assert_eq!(
+		page.remaining_size as usize,
+		msgs.iter().fold(0, |mut a, m| {
+			a += m.len();
+			a
+		})
+	);
+	// Verify the heap content.
+	let mut heap = Vec::new();
+	for msg in msgs.into_iter() {
+		let header = ItemHeader::<<Test as Config>::Size> {
+			payload_len: msg.len() as u32,
+			is_processed: false,
+		};
+		heap.extend(header.encode());
+		heap.extend(msg);
+	}
+	assert_eq!(page.heap, heap);
+}
+
+// `Page::from_message` does not panic when called with the maximum message and origin lengths.
+#[test]
+fn page_from_message_max_len_works() {
+	let max_msg_len: usize = MaxMessageLenOf::<Test>::get() as usize;
+
+	let page = PageOf::<Test>::from_message::<Test>(vec![1; max_msg_len][..].try_into().unwrap());
+
+	assert_eq!(page.remaining, 1);
+}
+
+#[test]
+fn sweep_queue_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		build_triple_ring();
+		QueueChanges::take();
+
+		let book = BookStateFor::<Test>::get(Here);
+		assert!(book.begin != book.end);
+		// Removing the service head works
+		assert_eq!(ServiceHead::<Test>::get(), Some(Here));
+		MessageQueue::sweep_queue(Here);
+		assert_ring(&[There, Everywhere(0)]);
+		// The book still exits, but has updated begin and end.
+		let book = BookStateFor::<Test>::get(Here);
+		assert_eq!(book.begin, book.end);
+
+		// Removing something that is not the service head works.
+		assert!(ServiceHead::<Test>::get() != Some(Everywhere(0)));
+		MessageQueue::sweep_queue(Everywhere(0));
+		assert_ring(&[There]);
+		// The book still exits, but has updated begin and end.
+		let book = BookStateFor::<Test>::get(Everywhere(0));
+		assert_eq!(book.begin, book.end);
+
+		MessageQueue::sweep_queue(There);
+		// The book still exits, but has updated begin and end.
+		let book = BookStateFor::<Test>::get(There);
+		assert_eq!(book.begin, book.end);
+		assert_ring(&[]);
+
+		// Sweeping a queue never calls OnQueueChanged.
+		assert!(QueueChanges::take().is_empty());
+	})
+}
+
+/// Test that `sweep_queue` also works if the ReadyRing wraps around.
+#[test]
+fn sweep_queue_wraps_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		build_ring::<Test>(&[Here]);
+
+		MessageQueue::sweep_queue(Here);
+		let book = BookStateFor::<Test>::get(Here);
+		assert!(book.ready_neighbours.is_none());
+	});
+}
+
+#[test]
+fn sweep_queue_invalid_noops() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		assert_storage_noop!(MessageQueue::sweep_queue(Here));
+	});
+}
+
+#[test]
+fn footprint_works() {
+	build_and_execute::<Test>(|| {
+		let origin = MessageOrigin::Here;
+		let (page, msgs) = full_page::<Test>();
+		let book = book_for::<Test>(&page);
+		BookStateFor::<Test>::insert(origin, book);
+
+		let info = MessageQueue::footprint(origin);
+		assert_eq!(info.count as usize, msgs);
+		assert_eq!(info.size, page.remaining_size as u64);
+
+		// Sweeping a queue never calls OnQueueChanged.
+		assert!(QueueChanges::take().is_empty());
+	})
+}
+
+/// The footprint of an invalid queue is the default footprint.
+#[test]
+fn footprint_invalid_works() {
+	build_and_execute::<Test>(|| {
+		let origin = MessageOrigin::Here;
+		assert_eq!(MessageQueue::footprint(origin), Default::default());
+	})
+}
+
+/// The footprint of a swept queue is still correct.
+#[test]
+fn footprint_on_swept_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		let mut book = empty_book::<Test>();
+		book.message_count = 3;
+		book.size = 10;
+		BookStateFor::<Test>::insert(Here, &book);
+		knit(&Here);
+
+		MessageQueue::sweep_queue(Here);
+		let fp = MessageQueue::footprint(Here);
+		assert_eq!(fp.count, 3);
+		assert_eq!(fp.size, 10);
+	})
+}
+
+#[test]
+fn execute_overweight_works() {
+	build_and_execute::<Test>(|| {
+		set_weight("bump_service_head", 1.into_weight());
+		set_weight("service_queue_base", 1.into_weight());
+		set_weight("service_page_base_completion", 1.into_weight());
+
+		// Enqueue a message
+		let origin = MessageOrigin::Here;
+		MessageQueue::enqueue_message(msg("weight=6"), origin);
+		// Load the current book
+		let book = BookStateFor::<Test>::get(origin);
+		assert_eq!(book.message_count, 1);
+		assert!(Pages::<Test>::contains_key(origin, 0));
+
+		// Mark the message as permanently overweight.
+		assert_eq!(MessageQueue::service_queues(4.into_weight()), 4.into_weight());
+		assert_eq!(QueueChanges::take(), vec![(origin, 1, 8)]);
+		assert_last_event::<Test>(
+			Event::OverweightEnqueued {
+				id: blake2_256(b"weight=6"),
+				origin: MessageOrigin::Here,
+				message_index: 0,
+				page_index: 0,
+			}
+			.into(),
+		);
+
+		// Now try to execute it with too few weight.
+		let consumed =
+			<MessageQueue as ServiceQueues>::execute_overweight(5.into_weight(), (origin, 0, 0));
+		assert_eq!(consumed, Err(ExecuteOverweightError::InsufficientWeight));
+
+		// Execute it with enough weight.
+		assert_eq!(Pages::<Test>::iter().count(), 1);
+		assert!(QueueChanges::take().is_empty());
+		let consumed =
+			<MessageQueue as ServiceQueues>::execute_overweight(7.into_weight(), (origin, 0, 0))
+				.unwrap();
+		assert_eq!(consumed, 6.into_weight());
+		assert_eq!(QueueChanges::take(), vec![(origin, 0, 0)]);
+		// There is no message left in the book.
+		let book = BookStateFor::<Test>::get(origin);
+		assert_eq!(book.message_count, 0);
+		// And no more pages.
+		assert_eq!(Pages::<Test>::iter().count(), 0);
+
+		// Doing it again with enough weight will error.
+		let consumed =
+			<MessageQueue as ServiceQueues>::execute_overweight(70.into_weight(), (origin, 0, 0));
+		assert_eq!(consumed, Err(ExecuteOverweightError::NotFound));
+		assert!(QueueChanges::take().is_empty());
+		assert!(!Pages::<Test>::contains_key(origin, 0), "Page is gone");
+		// The book should have been unknit from the ready ring.
+		assert!(!ServiceHead::<Test>::exists(), "No ready book");
+	});
+}
+
+#[test]
+fn permanently_overweight_book_unknits() {
+	use MessageOrigin::*;
+
+	build_and_execute::<Test>(|| {
+		set_weight("bump_service_head", 1.into_weight());
+		set_weight("service_queue_base", 1.into_weight());
+		set_weight("service_page_base_completion", 1.into_weight());
+
+		MessageQueue::enqueue_messages([msg("weight=9")].into_iter(), Here);
+
+		// It is the only ready book.
+		assert_ring(&[Here]);
+		// Mark the message as overweight.
+		assert_eq!(MessageQueue::service_queues(8.into_weight()), 4.into_weight());
+		assert_last_event::<Test>(
+			Event::OverweightEnqueued {
+				id: blake2_256(b"weight=9"),
+				origin: Here,
+				message_index: 0,
+				page_index: 0,
+			}
+			.into(),
+		);
+		// The book is not ready anymore.
+		assert_ring(&[]);
+		assert_eq!(MessagesProcessed::take().len(), 0);
+		assert_eq!(BookStateFor::<Test>::get(Here).message_count, 1);
+		// Now if we enqueue another message, it will become ready again.
+		MessageQueue::enqueue_messages([msg("weight=1")].into_iter(), Here);
+		assert_ring(&[Here]);
+		assert_eq!(MessageQueue::service_queues(8.into_weight()), 5.into_weight());
+		assert_eq!(MessagesProcessed::take().len(), 1);
+		assert_ring(&[]);
+	});
+}
+
+#[test]
+fn permanently_overweight_book_unknits_multiple() {
+	use MessageOrigin::*;
+
+	build_and_execute::<Test>(|| {
+		set_weight("bump_service_head", 1.into_weight());
+		set_weight("service_queue_base", 1.into_weight());
+		set_weight("service_page_base_completion", 1.into_weight());
+
+		MessageQueue::enqueue_messages(
+			[msg("weight=1"), msg("weight=9"), msg("weight=9")].into_iter(),
+			Here,
+		);
+
+		assert_ring(&[Here]);
+		// Process the first message.
+		assert_eq!(MessageQueue::service_queues(4.into_weight()), 4.into_weight());
+		assert_eq!(num_overweight_enqueued_events(), 0);
+		assert_eq!(MessagesProcessed::take().len(), 1);
+
+		// Book is still ready since it was not marked as overweight yet.
+		assert_ring(&[Here]);
+		assert_eq!(MessageQueue::service_queues(8.into_weight()), 5.into_weight());
+		assert_eq!(num_overweight_enqueued_events(), 2);
+		assert_eq!(MessagesProcessed::take().len(), 0);
+		// Now it is overweight.
+		assert_ring(&[]);
+		// Enqueue another message.
+		MessageQueue::enqueue_messages([msg("weight=1")].into_iter(), Here);
+		assert_ring(&[Here]);
+		assert_eq!(MessageQueue::service_queues(4.into_weight()), 4.into_weight());
+		assert_eq!(MessagesProcessed::take().len(), 1);
+		assert_ring(&[]);
+	});
+}
+
+/// We don't want empty books in the ready ring, but if they somehow make their way in there, it
+/// should not panic.
+#[test]
+#[cfg(not(debug_assertions))] // Would trigger a defensive failure otherwise.
+fn ready_but_empty_does_not_panic() {
+	use MessageOrigin::*;
+
+	build_and_execute::<Test>(|| {
+		BookStateFor::<Test>::insert(Here, empty_book::<Test>());
+		BookStateFor::<Test>::insert(There, empty_book::<Test>());
+
+		knit(&Here);
+		knit(&There);
+		assert_ring(&[Here, There]);
+
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), 0.into_weight());
+		assert_ring(&[]);
+	});
+}
+
+/// We don't want permanently books in the ready ring, but if they somehow make their way in there,
+/// it should not panic.
+#[test]
+#[cfg(not(debug_assertions))] // Would trigger a defensive failure otherwise.
+fn ready_but_perm_overweight_does_not_panic() {
+	use MessageOrigin::*;
+
+	build_and_execute::<Test>(|| {
+		MessageQueue::enqueue_message(msg("weight=9"), Here);
+		assert_eq!(MessageQueue::service_queues(8.into_weight()), 0.into_weight());
+		assert_ring(&[]);
+		// Force it back into the ready ring.
+		knit(&Here);
+		assert_ring(&[Here]);
+		assert_eq!(MessageQueue::service_queues(Weight::MAX), 0.into_weight());
+		// Unready again.
+		assert_ring(&[]);
+	});
+}
+
+/// Checks that (un)knitting the ready ring works with just one queue.
+///
+/// This case is interesting since it wraps and a lot of `mutate` now operate on the same object.
+#[test]
+fn ready_ring_knit_basic_works() {
+	use MessageOrigin::*;
+
+	build_and_execute::<Test>(|| {
+		BookStateFor::<Test>::insert(Here, empty_book::<Test>());
+
+		for i in 0..10 {
+			if i % 2 == 0 {
+				knit(&Here);
+				assert_ring(&[Here]);
+			} else {
+				unknit(&Here);
+				assert_ring(&[]);
+			}
+		}
+		assert_ring(&[]);
+	});
+}
+
+#[test]
+fn ready_ring_knit_and_unknit_works() {
+	use MessageOrigin::*;
+
+	build_and_execute::<Test>(|| {
+		// Place three queues into the storage.
+		BookStateFor::<Test>::insert(Here, empty_book::<Test>());
+		BookStateFor::<Test>::insert(There, empty_book::<Test>());
+		BookStateFor::<Test>::insert(Everywhere(0), empty_book::<Test>());
+
+		// Pausing should make no difference:
+		PausedQueues::set(vec![Here, There, Everywhere(0)]);
+
+		// Knit them into the ready ring.
+		assert_ring(&[]);
+		knit(&Here);
+		assert_ring(&[Here]);
+		knit(&There);
+		assert_ring(&[Here, There]);
+		knit(&Everywhere(0));
+		assert_ring(&[Here, There, Everywhere(0)]);
+
+		// Now unknit…
+		unknit(&Here);
+		assert_ring(&[There, Everywhere(0)]);
+		unknit(&There);
+		assert_ring(&[Everywhere(0)]);
+		unknit(&Everywhere(0));
+		assert_ring(&[]);
+	});
+}
+
+#[test]
+fn enqueue_message_works() {
+	use MessageOrigin::*;
+	let max_msg_per_page = <Test as Config>::HeapSize::get() as u64 /
+		(ItemHeader::<<Test as Config>::Size>::max_encoded_len() as u64 + 1);
+
+	build_and_execute::<Test>(|| {
+		// Enqueue messages which should fill three pages.
+		let n = max_msg_per_page * 3;
+		for i in 1..=n {
+			MessageQueue::enqueue_message(msg("a"), Here);
+			assert_eq!(QueueChanges::take(), vec![(Here, i, i)], "OnQueueChanged not called");
+		}
+		assert_eq!(Pages::<Test>::iter().count(), 3);
+
+		// Enqueue one more onto page 4.
+		MessageQueue::enqueue_message(msg("abc"), Here);
+		assert_eq!(QueueChanges::take(), vec![(Here, n + 1, n + 3)]);
+		assert_eq!(Pages::<Test>::iter().count(), 4);
+
+		// Check the state.
+		assert_eq!(BookStateFor::<Test>::iter().count(), 1);
+		let book = BookStateFor::<Test>::get(Here);
+		assert_eq!(book.message_count, n + 1);
+		assert_eq!(book.size, n + 3);
+		assert_eq!((book.begin, book.end), (0, 4));
+		assert_eq!(book.count as usize, Pages::<Test>::iter().count());
+	});
+}
+
+#[test]
+fn enqueue_messages_works() {
+	use MessageOrigin::*;
+	let max_msg_per_page = <Test as Config>::HeapSize::get() as u64 /
+		(ItemHeader::<<Test as Config>::Size>::max_encoded_len() as u64 + 1);
+
+	build_and_execute::<Test>(|| {
+		// Enqueue messages which should fill three pages.
+		let n = max_msg_per_page * 3;
+		let msgs = vec![msg("a"); n as usize];
+
+		// Now queue all messages at once.
+		MessageQueue::enqueue_messages(msgs.into_iter(), Here);
+		// The changed handler should only be called once.
+		assert_eq!(QueueChanges::take(), vec![(Here, n, n)], "OnQueueChanged not called");
+		assert_eq!(Pages::<Test>::iter().count(), 3);
+
+		// Enqueue one more onto page 4.
+		MessageQueue::enqueue_message(msg("abc"), Here);
+		assert_eq!(QueueChanges::take(), vec![(Here, n + 1, n + 3)]);
+		assert_eq!(Pages::<Test>::iter().count(), 4);
+
+		// Check the state.
+		assert_eq!(BookStateFor::<Test>::iter().count(), 1);
+		let book = BookStateFor::<Test>::get(Here);
+		assert_eq!(book.message_count, n + 1);
+		assert_eq!(book.size, n + 3);
+		assert_eq!((book.begin, book.end), (0, 4));
+		assert_eq!(book.count as usize, Pages::<Test>::iter().count());
+	});
+}
+
+#[test]
+fn service_queues_suspend_works() {
+	use MessageOrigin::*;
+	build_and_execute::<Test>(|| {
+		MessageQueue::enqueue_messages(vec![msg("a"), msg("ab"), msg("abc")].into_iter(), Here);
+		MessageQueue::enqueue_messages(vec![msg("x"), msg("xy"), msg("xyz")].into_iter(), There);
+		assert_eq!(QueueChanges::take(), vec![(Here, 3, 6), (There, 3, 6)]);
+
+		// Pause `Here` - execution starts `There`.
+		PausedQueues::set(vec![Here]);
+		assert_eq!(
+			(true, false),
+			(
+				<Test as Config>::QueuePausedQuery::is_paused(&Here),
+				<Test as Config>::QueuePausedQuery::is_paused(&There)
+			)
+		);
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("x"), There)]);
+		assert_eq!(QueueChanges::take(), vec![(There, 2, 5)]);
+
+		// Unpause `Here` - execution continues `There`.
+		PausedQueues::take();
+		assert_eq!(
+			(false, false),
+			(
+				<Test as Config>::QueuePausedQuery::is_paused(&Here),
+				<Test as Config>::QueuePausedQuery::is_paused(&There)
+			)
+		);
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("xy"), There)]);
+		assert_eq!(QueueChanges::take(), vec![(There, 1, 3)]);
+
+		// Now it swaps to `Here`.
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("a"), Here)]);
+		assert_eq!(QueueChanges::take(), vec![(Here, 2, 5)]);
+
+		// Pause `There` - execution continues `Here`.
+		PausedQueues::set(vec![There]);
+		assert_eq!(
+			(false, true),
+			(
+				<Test as Config>::QueuePausedQuery::is_paused(&Here),
+				<Test as Config>::QueuePausedQuery::is_paused(&There)
+			)
+		);
+		assert_eq!(MessageQueue::service_queues(1.into_weight()), 1.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("ab"), Here)]);
+		assert_eq!(QueueChanges::take(), vec![(Here, 1, 3)]);
+
+		// Unpause `There` and service all remaining messages.
+		PausedQueues::take();
+		assert_eq!(
+			(false, false),
+			(
+				<Test as Config>::QueuePausedQuery::is_paused(&Here),
+				<Test as Config>::QueuePausedQuery::is_paused(&There)
+			)
+		);
+		assert_eq!(MessageQueue::service_queues(2.into_weight()), 2.into_weight());
+		assert_eq!(MessagesProcessed::take(), vec![(vmsg("abc"), Here), (vmsg("xyz"), There)]);
+		assert_eq!(QueueChanges::take(), vec![(Here, 0, 0), (There, 0, 0)]);
+	});
+}
+
+/// Tests that manual overweight execution on a suspended queue errors with `QueueSuspended`.
+#[test]
+fn execute_overweight_respects_suspension() {
+	build_and_execute::<Test>(|| {
+		let origin = MessageOrigin::Here;
+		MessageQueue::enqueue_message(msg("weight=5"), origin);
+		// Mark the message as permanently overweight.
+		MessageQueue::service_queues(4.into_weight());
+		assert_last_event::<Test>(
+			Event::OverweightEnqueued {
+				id: blake2_256(b"weight=5"),
+				origin,
+				message_index: 0,
+				page_index: 0,
+			}
+			.into(),
+		);
+		PausedQueues::set(vec![origin]);
+		assert!(<Test as Config>::QueuePausedQuery::is_paused(&origin));
+
+		// Execution should fail.
+		assert_eq!(
+			<MessageQueue as ServiceQueues>::execute_overweight(Weight::MAX, (origin, 0, 0)),
+			Err(ExecuteOverweightError::QueuePaused)
+		);
+
+		PausedQueues::take();
+		assert!(!<Test as Config>::QueuePausedQuery::is_paused(&origin));
+
+		// Execution should work again with same args.
+		assert_ok!(<MessageQueue as ServiceQueues>::execute_overweight(
+			Weight::MAX,
+			(origin, 0, 0)
+		));
+
+		assert_last_event::<Test>(
+			Event::Processed {
+				id: blake2_256(b"weight=5"),
+				origin,
+				weight_used: 5.into_weight(),
+				success: true,
+			}
+			.into(),
+		);
+	});
+}
+
+#[test]
+fn service_queue_suspension_ready_ring_works() {
+	build_and_execute::<Test>(|| {
+		let origin = MessageOrigin::Here;
+		PausedQueues::set(vec![origin]);
+		MessageQueue::enqueue_message(msg("weight=5"), origin);
+
+		MessageQueue::service_queues(Weight::MAX);
+		// It did not execute but is in the ready ring.
+		assert!(System::events().is_empty(), "Paused");
+		assert_ring(&[origin]);
+
+		// Now when we un-pause, it will execute.
+		PausedQueues::take();
+		MessageQueue::service_queues(Weight::MAX);
+		assert_last_event::<Test>(
+			Event::Processed {
+				id: blake2_256(b"weight=5"),
+				origin,
+				weight_used: 5.into_weight(),
+				success: true,
+			}
+			.into(),
+		);
+	});
+}
diff --git a/substrate/frame/message-queue/src/weights.rs b/substrate/frame/message-queue/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e86f23e274ff246aa9f557626e06a42a4930154c
--- /dev/null
+++ b/substrate/frame/message-queue/src/weights.rs
@@ -0,0 +1,310 @@
+// 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.
+
+//! Autogenerated weights for pallet_message_queue
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_message_queue
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/message-queue/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_message_queue.
+pub trait WeightInfo {
+	fn ready_ring_knit() -> Weight;
+	fn ready_ring_unknit() -> Weight;
+	fn service_queue_base() -> Weight;
+	fn service_page_base_completion() -> Weight;
+	fn service_page_base_no_completion() -> Weight;
+	fn service_page_item() -> Weight;
+	fn bump_service_head() -> Weight;
+	fn reap_page() -> Weight;
+	fn execute_overweight_page_removed() -> Weight;
+	fn execute_overweight_page_updated() -> Weight;
+}
+
+/// Weights for pallet_message_queue using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: MessageQueue ServiceHead (r:1 w:0)
+	/// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: MessageQueue BookStateFor (r:2 w:2)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn ready_ring_knit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `267`
+		//  Estimated: `6038`
+		// Minimum execution time: 12_025_000 picoseconds.
+		Weight::from_parts(12_597_000, 6038)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:2 w:2)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue ServiceHead (r:1 w:1)
+	/// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn ready_ring_unknit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `267`
+		//  Estimated: `6038`
+		// Minimum execution time: 11_563_000 picoseconds.
+		Weight::from_parts(11_785_000, 6038)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn service_queue_base() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3514`
+		// Minimum execution time: 4_467_000 picoseconds.
+		Weight::from_parts(4_655_000, 3514)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn service_page_base_completion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147`
+		//  Estimated: `69049`
+		// Minimum execution time: 6_103_000 picoseconds.
+		Weight::from_parts(6_254_000, 69049)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn service_page_base_no_completion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147`
+		//  Estimated: `69049`
+		// Minimum execution time: 6_320_000 picoseconds.
+		Weight::from_parts(6_565_000, 69049)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn service_page_item() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 66_062_000 picoseconds.
+		Weight::from_parts(66_371_000, 0)
+	}
+	/// Storage: MessageQueue ServiceHead (r:1 w:1)
+	/// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: MessageQueue BookStateFor (r:1 w:0)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn bump_service_head() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3514`
+		// Minimum execution time: 6_788_000 picoseconds.
+		Weight::from_parts(7_176_000, 3514)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn reap_page() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `65744`
+		//  Estimated: `69049`
+		// Minimum execution time: 52_865_000 picoseconds.
+		Weight::from_parts(54_398_000, 69049)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn execute_overweight_page_removed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `65744`
+		//  Estimated: `69049`
+		// Minimum execution time: 69_168_000 picoseconds.
+		Weight::from_parts(70_560_000, 69049)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn execute_overweight_page_updated() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `65744`
+		//  Estimated: `69049`
+		// Minimum execution time: 80_947_000 picoseconds.
+		Weight::from_parts(82_715_000, 69049)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: MessageQueue ServiceHead (r:1 w:0)
+	/// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: MessageQueue BookStateFor (r:2 w:2)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn ready_ring_knit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `267`
+		//  Estimated: `6038`
+		// Minimum execution time: 12_025_000 picoseconds.
+		Weight::from_parts(12_597_000, 6038)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:2 w:2)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue ServiceHead (r:1 w:1)
+	/// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn ready_ring_unknit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `267`
+		//  Estimated: `6038`
+		// Minimum execution time: 11_563_000 picoseconds.
+		Weight::from_parts(11_785_000, 6038)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn service_queue_base() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3514`
+		// Minimum execution time: 4_467_000 picoseconds.
+		Weight::from_parts(4_655_000, 3514)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn service_page_base_completion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147`
+		//  Estimated: `69049`
+		// Minimum execution time: 6_103_000 picoseconds.
+		Weight::from_parts(6_254_000, 69049)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn service_page_base_no_completion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `147`
+		//  Estimated: `69049`
+		// Minimum execution time: 6_320_000 picoseconds.
+		Weight::from_parts(6_565_000, 69049)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn service_page_item() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 66_062_000 picoseconds.
+		Weight::from_parts(66_371_000, 0)
+	}
+	/// Storage: MessageQueue ServiceHead (r:1 w:1)
+	/// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: MessageQueue BookStateFor (r:1 w:0)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	fn bump_service_head() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `3514`
+		// Minimum execution time: 6_788_000 picoseconds.
+		Weight::from_parts(7_176_000, 3514)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn reap_page() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `65744`
+		//  Estimated: `69049`
+		// Minimum execution time: 52_865_000 picoseconds.
+		Weight::from_parts(54_398_000, 69049)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn execute_overweight_page_removed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `65744`
+		//  Estimated: `69049`
+		// Minimum execution time: 69_168_000 picoseconds.
+		Weight::from_parts(70_560_000, 69049)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: MessageQueue Pages (r:1 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65584), added: 68059, mode: MaxEncodedLen)
+	fn execute_overweight_page_updated() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `65744`
+		//  Estimated: `69049`
+		// Minimum execution time: 80_947_000 picoseconds.
+		Weight::from_parts(82_715_000, 69049)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/multisig/Cargo.toml b/substrate/frame/multisig/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7927fea620758c89a42425ed50e62a2639c255ee
--- /dev/null
+++ b/substrate/frame/multisig/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "pallet-multisig"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME multi-signature dispatch pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+# third party
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/multisig/README.md b/substrate/frame/multisig/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5f320377d3454e5e2d09f9346ef6539a141ac76c
--- /dev/null
+++ b/substrate/frame/multisig/README.md
@@ -0,0 +1,29 @@
+# Multisig Module
+A module for doing multisig dispatch.
+
+- [`Config`](https://docs.rs/pallet-multisig/latest/pallet_multisig/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-multisig/latest/pallet_multisig/pallet/enum.Call.html)
+
+## Overview
+
+This module contains functionality for multi-signature dispatch, a (potentially) stateful
+operation, allowing multiple signed
+origins (accounts) to coordinate and dispatch a call from a well-known origin, derivable
+deterministically from the set of account IDs and the threshold number of accounts from the
+set that must approve it. In the case that the threshold is just one then this is a stateless
+operation. This is useful for multisig wallets where cryptographic threshold signatures are
+not available or desired.
+
+## Interface
+
+### Dispatchable Functions
+
+* `as_multi` - Approve and if possible dispatch a call from a composite origin formed from a
+  number of signed origins.
+* `approve_as_multi` - Approve a call from a composite origin.
+* `cancel_as_multi` - Cancel a call from a composite origin.
+
+[`Call`]: ./enum.Call.html
+[`Config`]: ./trait.Config.html
+
+License: Apache-2.0
diff --git a/substrate/frame/multisig/src/benchmarking.rs b/substrate/frame/multisig/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ebe19df5dc4367dd3d4d67d2f6cc2b65252895b3
--- /dev/null
+++ b/substrate/frame/multisig/src/benchmarking.rs
@@ -0,0 +1,214 @@
+// 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.
+
+// Benchmarks for Multisig Pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{account, benchmarks};
+use frame_system::RawOrigin;
+use sp_runtime::traits::Bounded;
+
+use crate::Pallet as Multisig;
+
+const SEED: u32 = 0;
+
+fn setup_multi<T: Config>(
+	s: u32,
+	z: u32,
+) -> Result<(Vec<T::AccountId>, Box<<T as Config>::RuntimeCall>), &'static str> {
+	let mut signatories: Vec<T::AccountId> = Vec::new();
+	for i in 0..s {
+		let signatory = account("signatory", i, SEED);
+		// Give them some balance for a possible deposit
+		let balance = BalanceOf::<T>::max_value();
+		T::Currency::make_free_balance_be(&signatory, balance);
+		signatories.push(signatory);
+	}
+	signatories.sort();
+	// Must first convert to runtime call type.
+	let call: <T as Config>::RuntimeCall =
+		frame_system::Call::<T>::remark { remark: vec![0; z as usize] }.into();
+	Ok((signatories, Box::new(call)))
+}
+
+benchmarks! {
+	as_multi_threshold_1 {
+		// Transaction Length
+		let z in 0 .. 10_000;
+		let max_signatories = T::MaxSignatories::get().into();
+		let (mut signatories, _) = setup_multi::<T>(max_signatories, z)?;
+		let call: <T as Config>::RuntimeCall = frame_system::Call::<T>::remark {
+			remark: vec![0; z as usize]
+		}.into();
+		let call_hash = call.using_encoded(blake2_256);
+		let multi_account_id = Multisig::<T>::multi_account_id(&signatories, 1);
+		let caller = signatories.pop().ok_or("signatories should have len 2 or more")?;
+		// 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());
+	}: _(RawOrigin::Signed(caller.clone()), signatories, Box::new(call))
+	verify {
+		// If the benchmark resolves, then the call was dispatched successfully.
+	}
+
+	as_multi_create {
+		// Signatories, need at least 2 total people
+		let s in 2 .. T::MaxSignatories::get();
+		// Transaction Length
+		let z in 0 .. 10_000;
+		let (mut signatories, call) = setup_multi::<T>(s, z)?;
+		let call_hash = call.using_encoded(blake2_256);
+		let multi_account_id = Multisig::<T>::multi_account_id(&signatories, s.try_into().unwrap());
+		let caller = signatories.pop().ok_or("signatories should have len 2 or more")?;
+		// 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());
+	}: as_multi(RawOrigin::Signed(caller), s as u16, signatories, None, call, Weight::zero())
+	verify {
+		assert!(Multisigs::<T>::contains_key(multi_account_id, call_hash));
+	}
+
+	as_multi_approve {
+		// Signatories, need at least 3 people (so we don't complete the multisig)
+		let s in 3 .. T::MaxSignatories::get();
+		// Transaction Length
+		let z in 0 .. 10_000;
+		let (mut signatories, call) = setup_multi::<T>(s, z)?;
+		let call_hash = call.using_encoded(blake2_256);
+		let multi_account_id = Multisig::<T>::multi_account_id(&signatories, s.try_into().unwrap());
+		let mut signatories2 = signatories.clone();
+		let caller = signatories.pop().ok_or("signatories should have len 2 or more")?;
+		// before the call, get the timepoint
+		let timepoint = Multisig::<T>::timepoint();
+		// Create the multi
+		Multisig::<T>::as_multi(RawOrigin::Signed(caller).into(), s as u16, signatories, None, call.clone(), Weight::zero())?;
+		let caller2 = signatories2.remove(0);
+		// Whitelist caller account from further DB operations.
+		let caller_key = frame_system::Account::<T>::hashed_key_for(&caller2);
+		frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into());
+	}: as_multi(RawOrigin::Signed(caller2), s as u16, signatories2, Some(timepoint), call, Weight::zero())
+	verify {
+		let multisig = Multisigs::<T>::get(multi_account_id, call_hash).ok_or("multisig not created")?;
+		assert_eq!(multisig.approvals.len(), 2);
+	}
+
+	as_multi_complete {
+		// Signatories, need at least 2 people
+		let s in 2 .. T::MaxSignatories::get();
+		// Transaction Length
+		let z in 0 .. 10_000;
+		let (mut signatories, call) = setup_multi::<T>(s, z)?;
+		let call_hash = call.using_encoded(blake2_256);
+		let multi_account_id = Multisig::<T>::multi_account_id(&signatories, s.try_into().unwrap());
+		let mut signatories2 = signatories.clone();
+		let caller = signatories.pop().ok_or("signatories should have len 2 or more")?;
+		// before the call, get the timepoint
+		let timepoint = Multisig::<T>::timepoint();
+		// Create the multi
+		Multisig::<T>::as_multi(RawOrigin::Signed(caller).into(), s as u16, signatories, None, call.clone(), Weight::zero())?;
+		// Everyone except the first person approves
+		for i in 1 .. s - 1 {
+			let mut signatories_loop = signatories2.clone();
+			let caller_loop = signatories_loop.remove(i as usize);
+			let o = RawOrigin::Signed(caller_loop).into();
+			Multisig::<T>::as_multi(o, s as u16, signatories_loop, Some(timepoint), call.clone(), Weight::zero())?;
+		}
+		let caller2 = signatories2.remove(0);
+		assert!(Multisigs::<T>::contains_key(&multi_account_id, call_hash));
+		// Whitelist caller account from further DB operations.
+		let caller_key = frame_system::Account::<T>::hashed_key_for(&caller2);
+		frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into());
+	}: as_multi(RawOrigin::Signed(caller2), s as u16, signatories2, Some(timepoint), call, Weight::MAX)
+	verify {
+		assert!(!Multisigs::<T>::contains_key(&multi_account_id, call_hash));
+	}
+
+	approve_as_multi_create {
+		// Signatories, need at least 2 people
+		let s in 2 .. T::MaxSignatories::get();
+		// Transaction Length, not a component
+		let z = 10_000;
+		let (mut signatories, call) = setup_multi::<T>(s, z)?;
+		let multi_account_id = Multisig::<T>::multi_account_id(&signatories, s.try_into().unwrap());
+		let caller = signatories.pop().ok_or("signatories should have len 2 or more")?;
+		let call_hash = call.using_encoded(blake2_256);
+		// 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());
+		// Create the multi
+	}: approve_as_multi(RawOrigin::Signed(caller), s as u16, signatories, None, call_hash, Weight::zero())
+	verify {
+		assert!(Multisigs::<T>::contains_key(multi_account_id, call_hash));
+	}
+
+	approve_as_multi_approve {
+		// Signatories, need at least 2 people
+		let s in 2 .. T::MaxSignatories::get();
+		// Transaction Length, not a component
+		let z = 10_000;
+		let (mut signatories, call) = setup_multi::<T>(s, z)?;
+		let mut signatories2 = signatories.clone();
+		let multi_account_id = Multisig::<T>::multi_account_id(&signatories, s.try_into().unwrap());
+		let caller = signatories.pop().ok_or("signatories should have len 2 or more")?;
+		let call_hash = call.using_encoded(blake2_256);
+		// before the call, get the timepoint
+		let timepoint = Multisig::<T>::timepoint();
+		// Create the multi
+		Multisig::<T>::as_multi(
+			RawOrigin::Signed(caller).into(),
+			s as u16,
+			signatories,
+			None,
+			call,
+			Weight::zero()
+		)?;
+		let caller2 = signatories2.remove(0);
+		// Whitelist caller account from further DB operations.
+		let caller_key = frame_system::Account::<T>::hashed_key_for(&caller2);
+		frame_benchmarking::benchmarking::add_to_whitelist(caller_key.into());
+	}: approve_as_multi(RawOrigin::Signed(caller2), s as u16, signatories2, Some(timepoint), call_hash, Weight::zero())
+	verify {
+		let multisig = Multisigs::<T>::get(multi_account_id, call_hash).ok_or("multisig not created")?;
+		assert_eq!(multisig.approvals.len(), 2);
+	}
+
+	cancel_as_multi {
+		// Signatories, need at least 2 people
+		let s in 2 .. T::MaxSignatories::get();
+		// Transaction Length, not a component
+		let z = 10_000;
+		let (mut signatories, call) = setup_multi::<T>(s, z)?;
+		let multi_account_id = Multisig::<T>::multi_account_id(&signatories, s.try_into().unwrap());
+		let caller = signatories.pop().ok_or("signatories should have len 2 or more")?;
+		let call_hash = call.using_encoded(blake2_256);
+		let timepoint = Multisig::<T>::timepoint();
+		// Create the multi
+		let o = RawOrigin::Signed(caller.clone()).into();
+		Multisig::<T>::as_multi(o, s as u16, signatories.clone(), None, call, Weight::zero())?;
+		assert!(Multisigs::<T>::contains_key(&multi_account_id, call_hash));
+		// 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());
+	}: _(RawOrigin::Signed(caller), s as u16, signatories, timepoint, call_hash)
+	verify {
+		assert!(!Multisigs::<T>::contains_key(multi_account_id, call_hash));
+	}
+
+	impl_benchmark_test_suite!(Multisig, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/multisig/src/lib.rs b/substrate/frame/multisig/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e4426c64b4125fe267a1e30a42a7196274b05e4e
--- /dev/null
+++ b/substrate/frame/multisig/src/lib.rs
@@ -0,0 +1,678 @@
+// 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.
+
+//! # Multisig pallet
+//! A pallet for doing multisig dispatch.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! This pallet contains functionality for multi-signature dispatch, a (potentially) stateful
+//! operation, allowing multiple signed
+//! origins (accounts) to coordinate and dispatch a call from a well-known origin, derivable
+//! deterministically from the set of account IDs and the threshold number of accounts from the
+//! set that must approve it. In the case that the threshold is just one then this is a stateless
+//! operation. This is useful for multisig wallets where cryptographic threshold signatures are
+//! not available or desired.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! * `as_multi` - Approve and if possible dispatch a call from a composite origin formed from a
+//!   number of signed origins.
+//! * `approve_as_multi` - Approve a call from a composite origin.
+//! * `cancel_as_multi` - Cancel a call from a composite origin.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+pub mod migrations;
+mod tests;
+pub mod weights;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{
+		DispatchErrorWithPostInfo, DispatchResult, DispatchResultWithPostInfo, GetDispatchInfo,
+		PostDispatchInfo,
+	},
+	ensure,
+	traits::{Currency, Get, ReservableCurrency},
+	weights::Weight,
+	BoundedVec,
+};
+use frame_system::{self as system, pallet_prelude::BlockNumberFor, RawOrigin};
+use scale_info::TypeInfo;
+use sp_io::hashing::blake2_256;
+use sp_runtime::{
+	traits::{Dispatchable, TrailingZeroInput, Zero},
+	DispatchError, RuntimeDebug,
+};
+use sp_std::prelude::*;
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+/// The log target of this pallet.
+pub const LOG_TARGET: &'static str = "runtime::multisig";
+
+// syntactic sugar for logging.
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: crate::LOG_TARGET,
+			concat!("[{:?}] �� ", $patter), <frame_system::Pallet<T>>::block_number() $(, $values)*
+		)
+	};
+}
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+/// A global extrinsic index, formed as the extrinsic index within a block, together with that
+/// block's height. This allows a transaction in which a multisig operation of a particular
+/// composite was created to be uniquely identified.
+#[derive(
+	Copy, Clone, Eq, PartialEq, Encode, Decode, Default, RuntimeDebug, TypeInfo, MaxEncodedLen,
+)]
+pub struct Timepoint<BlockNumber> {
+	/// The height of the chain at the point in time.
+	height: BlockNumber,
+	/// The index of the extrinsic at the point in time.
+	index: u32,
+}
+
+/// An open multisig operation.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, Default, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(MaxApprovals))]
+pub struct Multisig<BlockNumber, Balance, AccountId, MaxApprovals>
+where
+	MaxApprovals: Get<u32>,
+{
+	/// The extrinsic when the multisig operation was opened.
+	when: Timepoint<BlockNumber>,
+	/// The amount held in reserve of the `depositor`, to be returned once the operation ends.
+	deposit: Balance,
+	/// The account who opened it (i.e. the first to approve it).
+	depositor: AccountId,
+	/// The approvals achieved so far, including the depositor. Always sorted.
+	approvals: BoundedVec<AccountId, MaxApprovals>,
+}
+
+type CallHash = [u8; 32];
+
+enum CallOrHash<T: Config> {
+	Call(<T as Config>::RuntimeCall),
+	Hash([u8; 32]),
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The overarching call type.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ GetDispatchInfo
+			+ From<frame_system::Call<Self>>;
+
+		/// The currency mechanism.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// The base amount of currency needed to reserve for creating a multisig execution or to
+		/// store a dispatch call for later.
+		///
+		/// This is held for an additional storage item whose value size is
+		/// `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is
+		/// `32 + sizeof(AccountId)` bytes.
+		#[pallet::constant]
+		type DepositBase: Get<BalanceOf<Self>>;
+
+		/// The amount of currency needed per unit threshold when creating a multisig execution.
+		///
+		/// This is held for adding 32 bytes more into a pre-existing storage value.
+		#[pallet::constant]
+		type DepositFactor: Get<BalanceOf<Self>>;
+
+		/// The maximum amount of signatories allowed in the multisig.
+		#[pallet::constant]
+		type MaxSignatories: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	/// The set of open multisig operations.
+	#[pallet::storage]
+	pub type Multisigs<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Blake2_128Concat,
+		[u8; 32],
+		Multisig<BlockNumberFor<T>, BalanceOf<T>, T::AccountId, T::MaxSignatories>,
+	>;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Threshold must be 2 or greater.
+		MinimumThreshold,
+		/// Call is already approved by this signatory.
+		AlreadyApproved,
+		/// Call doesn't need any (more) approvals.
+		NoApprovalsNeeded,
+		/// There are too few signatories in the list.
+		TooFewSignatories,
+		/// There are too many signatories in the list.
+		TooManySignatories,
+		/// The signatories were provided out of order; they should be ordered.
+		SignatoriesOutOfOrder,
+		/// The sender was contained in the other signatories; it shouldn't be.
+		SenderInSignatories,
+		/// Multisig operation not found when attempting to cancel.
+		NotFound,
+		/// Only the account that originally created the multisig is able to cancel it.
+		NotOwner,
+		/// No timepoint was given, yet the multisig operation is already underway.
+		NoTimepoint,
+		/// A different timepoint was given to the multisig operation that is underway.
+		WrongTimepoint,
+		/// A timepoint was given, yet no multisig operation is underway.
+		UnexpectedTimepoint,
+		/// The maximum weight information provided was too low.
+		MaxWeightTooLow,
+		/// The data to be stored is already stored.
+		AlreadyStored,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A new multisig operation has begun.
+		NewMultisig { approving: T::AccountId, multisig: T::AccountId, call_hash: CallHash },
+		/// A multisig operation has been approved by someone.
+		MultisigApproval {
+			approving: T::AccountId,
+			timepoint: Timepoint<BlockNumberFor<T>>,
+			multisig: T::AccountId,
+			call_hash: CallHash,
+		},
+		/// A multisig operation has been executed.
+		MultisigExecuted {
+			approving: T::AccountId,
+			timepoint: Timepoint<BlockNumberFor<T>>,
+			multisig: T::AccountId,
+			call_hash: CallHash,
+			result: DispatchResult,
+		},
+		/// A multisig operation has been cancelled.
+		MultisigCancelled {
+			cancelling: T::AccountId,
+			timepoint: Timepoint<BlockNumberFor<T>>,
+			multisig: T::AccountId,
+			call_hash: CallHash,
+		},
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Immediately dispatch a multi-signature call using a single approval from the caller.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `other_signatories`: The accounts (other than the sender) who are part of the
+		/// multi-signature, but do not participate in the approval process.
+		/// - `call`: The call to be executed.
+		///
+		/// Result is equivalent to the dispatched result.
+		///
+		/// ## Complexity
+		/// O(Z + C) where Z is the length of the call and C its execution weight.
+		#[pallet::call_index(0)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::as_multi_threshold_1(call.using_encoded(|c| c.len() as u32))
+					// AccountData for inner call origin accountdata.
+					.saturating_add(T::DbWeight::get().reads_writes(1, 1))
+					.saturating_add(dispatch_info.weight),
+				dispatch_info.class,
+			)
+		})]
+		pub fn as_multi_threshold_1(
+			origin: OriginFor<T>,
+			other_signatories: Vec<T::AccountId>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let max_sigs = T::MaxSignatories::get() as usize;
+			ensure!(!other_signatories.is_empty(), Error::<T>::TooFewSignatories);
+			let other_signatories_len = other_signatories.len();
+			ensure!(other_signatories_len < max_sigs, Error::<T>::TooManySignatories);
+			let signatories = Self::ensure_sorted_and_insert(other_signatories, who)?;
+
+			let id = Self::multi_account_id(&signatories, 1);
+
+			let call_len = call.using_encoded(|c| c.len());
+			let result = call.dispatch(RawOrigin::Signed(id).into());
+
+			result
+				.map(|post_dispatch_info| {
+					post_dispatch_info
+						.actual_weight
+						.map(|actual_weight| {
+							T::WeightInfo::as_multi_threshold_1(call_len as u32)
+								.saturating_add(actual_weight)
+						})
+						.into()
+				})
+				.map_err(|err| match err.post_info.actual_weight {
+					Some(actual_weight) => {
+						let weight_used = T::WeightInfo::as_multi_threshold_1(call_len as u32)
+							.saturating_add(actual_weight);
+						let post_info = Some(weight_used).into();
+						DispatchErrorWithPostInfo { post_info, error: err.error }
+					},
+					None => err,
+				})
+		}
+
+		/// Register approval for a dispatch to be made from a deterministic composite account if
+		/// approved by a total of `threshold - 1` of `other_signatories`.
+		///
+		/// If there are enough, then dispatch the call.
+		///
+		/// Payment: `DepositBase` will be reserved if this is the first approval, plus
+		/// `threshold` times `DepositFactor`. It is returned once this dispatch happens or
+		/// is cancelled.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `threshold`: The total number of approvals for this dispatch before it is executed.
+		/// - `other_signatories`: The accounts (other than the sender) who can approve this
+		/// dispatch. May not be empty.
+		/// - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
+		/// not the first approval, then it must be `Some`, with the timepoint (block number and
+		/// transaction index) of the first approval transaction.
+		/// - `call`: The call to be executed.
+		///
+		/// NOTE: Unless this is the final approval, you will generally want to use
+		/// `approve_as_multi` instead, since it only requires a hash of the call.
+		///
+		/// Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise
+		/// on success, result is `Ok` and the result from the interior call, if it was executed,
+		/// may be found in the deposited `MultisigExecuted` event.
+		///
+		/// ## Complexity
+		/// - `O(S + Z + Call)`.
+		/// - Up to one balance-reserve or unreserve operation.
+		/// - One passthrough operation, one insert, both `O(S)` where `S` is the number of
+		///   signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
+		/// - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len.
+		/// - One encode & hash, both of complexity `O(S)`.
+		/// - Up to one binary search and insert (`O(logS + S)`).
+		/// - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
+		/// - One event.
+		/// - The weight of the `call`.
+		/// - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
+		///   taken for its lifetime of `DepositBase + threshold * DepositFactor`.
+		#[pallet::call_index(1)]
+		#[pallet::weight({
+			let s = other_signatories.len() as u32;
+			let z = call.using_encoded(|d| d.len()) as u32;
+
+			T::WeightInfo::as_multi_create(s, z)
+			.max(T::WeightInfo::as_multi_approve(s, z))
+			.max(T::WeightInfo::as_multi_complete(s, z))
+			.saturating_add(*max_weight)
+		})]
+		pub fn as_multi(
+			origin: OriginFor<T>,
+			threshold: u16,
+			other_signatories: Vec<T::AccountId>,
+			maybe_timepoint: Option<Timepoint<BlockNumberFor<T>>>,
+			call: Box<<T as Config>::RuntimeCall>,
+			max_weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::operate(
+				who,
+				threshold,
+				other_signatories,
+				maybe_timepoint,
+				CallOrHash::Call(*call),
+				max_weight,
+			)
+		}
+
+		/// Register approval for a dispatch to be made from a deterministic composite account if
+		/// approved by a total of `threshold - 1` of `other_signatories`.
+		///
+		/// Payment: `DepositBase` will be reserved if this is the first approval, plus
+		/// `threshold` times `DepositFactor`. It is returned once this dispatch happens or
+		/// is cancelled.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `threshold`: The total number of approvals for this dispatch before it is executed.
+		/// - `other_signatories`: The accounts (other than the sender) who can approve this
+		/// dispatch. May not be empty.
+		/// - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is
+		/// not the first approval, then it must be `Some`, with the timepoint (block number and
+		/// transaction index) of the first approval transaction.
+		/// - `call_hash`: The hash of the call to be executed.
+		///
+		/// NOTE: If this is the final approval, you will want to use `as_multi` instead.
+		///
+		/// ## Complexity
+		/// - `O(S)`.
+		/// - Up to one balance-reserve or unreserve operation.
+		/// - One passthrough operation, one insert, both `O(S)` where `S` is the number of
+		///   signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
+		/// - One encode & hash, both of complexity `O(S)`.
+		/// - Up to one binary search and insert (`O(logS + S)`).
+		/// - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.
+		/// - One event.
+		/// - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
+		///   taken for its lifetime of `DepositBase + threshold * DepositFactor`.
+		#[pallet::call_index(2)]
+		#[pallet::weight({
+			let s = other_signatories.len() as u32;
+
+			T::WeightInfo::approve_as_multi_create(s)
+				.max(T::WeightInfo::approve_as_multi_approve(s))
+				.saturating_add(*max_weight)
+		})]
+		pub fn approve_as_multi(
+			origin: OriginFor<T>,
+			threshold: u16,
+			other_signatories: Vec<T::AccountId>,
+			maybe_timepoint: Option<Timepoint<BlockNumberFor<T>>>,
+			call_hash: [u8; 32],
+			max_weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::operate(
+				who,
+				threshold,
+				other_signatories,
+				maybe_timepoint,
+				CallOrHash::Hash(call_hash),
+				max_weight,
+			)
+		}
+
+		/// Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously
+		/// for this operation will be unreserved on success.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `threshold`: The total number of approvals for this dispatch before it is executed.
+		/// - `other_signatories`: The accounts (other than the sender) who can approve this
+		/// dispatch. May not be empty.
+		/// - `timepoint`: The timepoint (block number and transaction index) of the first approval
+		/// transaction for this dispatch.
+		/// - `call_hash`: The hash of the call to be executed.
+		///
+		/// ## Complexity
+		/// - `O(S)`.
+		/// - Up to one balance-reserve or unreserve operation.
+		/// - One passthrough operation, one insert, both `O(S)` where `S` is the number of
+		///   signatories. `S` is capped by `MaxSignatories`, with weight being proportional.
+		/// - One encode & hash, both of complexity `O(S)`.
+		/// - One event.
+		/// - I/O: 1 read `O(S)`, one remove.
+		/// - Storage: removes one item.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::cancel_as_multi(other_signatories.len() as u32))]
+		pub fn cancel_as_multi(
+			origin: OriginFor<T>,
+			threshold: u16,
+			other_signatories: Vec<T::AccountId>,
+			timepoint: Timepoint<BlockNumberFor<T>>,
+			call_hash: [u8; 32],
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			ensure!(threshold >= 2, Error::<T>::MinimumThreshold);
+			let max_sigs = T::MaxSignatories::get() as usize;
+			ensure!(!other_signatories.is_empty(), Error::<T>::TooFewSignatories);
+			ensure!(other_signatories.len() < max_sigs, Error::<T>::TooManySignatories);
+			let signatories = Self::ensure_sorted_and_insert(other_signatories, who.clone())?;
+
+			let id = Self::multi_account_id(&signatories, threshold);
+
+			let m = <Multisigs<T>>::get(&id, call_hash).ok_or(Error::<T>::NotFound)?;
+			ensure!(m.when == timepoint, Error::<T>::WrongTimepoint);
+			ensure!(m.depositor == who, Error::<T>::NotOwner);
+
+			let err_amount = T::Currency::unreserve(&m.depositor, m.deposit);
+			debug_assert!(err_amount.is_zero());
+			<Multisigs<T>>::remove(&id, &call_hash);
+
+			Self::deposit_event(Event::MultisigCancelled {
+				cancelling: who,
+				timepoint,
+				multisig: id,
+				call_hash,
+			});
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Derive a multi-account ID from the sorted list of accounts and the threshold that are
+	/// required.
+	///
+	/// NOTE: `who` must be sorted. If it is not, then you'll get the wrong answer.
+	pub fn multi_account_id(who: &[T::AccountId], threshold: u16) -> T::AccountId {
+		let entropy = (b"modlpy/utilisuba", who, threshold).using_encoded(blake2_256);
+		Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+			.expect("infinite length input; no invalid inputs for type; qed")
+	}
+
+	fn operate(
+		who: T::AccountId,
+		threshold: u16,
+		other_signatories: Vec<T::AccountId>,
+		maybe_timepoint: Option<Timepoint<BlockNumberFor<T>>>,
+		call_or_hash: CallOrHash<T>,
+		max_weight: Weight,
+	) -> DispatchResultWithPostInfo {
+		ensure!(threshold >= 2, Error::<T>::MinimumThreshold);
+		let max_sigs = T::MaxSignatories::get() as usize;
+		ensure!(!other_signatories.is_empty(), Error::<T>::TooFewSignatories);
+		let other_signatories_len = other_signatories.len();
+		ensure!(other_signatories_len < max_sigs, Error::<T>::TooManySignatories);
+		let signatories = Self::ensure_sorted_and_insert(other_signatories, who.clone())?;
+
+		let id = Self::multi_account_id(&signatories, threshold);
+
+		// Threshold > 1; this means it's a multi-step operation. We extract the `call_hash`.
+		let (call_hash, call_len, maybe_call) = match call_or_hash {
+			CallOrHash::Call(call) => {
+				let (call_hash, call_len) = call.using_encoded(|d| (blake2_256(d), d.len()));
+				(call_hash, call_len, Some(call))
+			},
+			CallOrHash::Hash(h) => (h, 0, None),
+		};
+
+		// Branch on whether the operation has already started or not.
+		if let Some(mut m) = <Multisigs<T>>::get(&id, call_hash) {
+			// Yes; ensure that the timepoint exists and agrees.
+			let timepoint = maybe_timepoint.ok_or(Error::<T>::NoTimepoint)?;
+			ensure!(m.when == timepoint, Error::<T>::WrongTimepoint);
+
+			// Ensure that either we have not yet signed or that it is at threshold.
+			let mut approvals = m.approvals.len() as u16;
+			// We only bother with the approval if we're below threshold.
+			let maybe_pos = m.approvals.binary_search(&who).err().filter(|_| approvals < threshold);
+			// Bump approvals if not yet voted and the vote is needed.
+			if maybe_pos.is_some() {
+				approvals += 1;
+			}
+
+			// We only bother fetching/decoding call if we know that we're ready to execute.
+			if let Some(call) = maybe_call.filter(|_| approvals >= threshold) {
+				// verify weight
+				ensure!(
+					call.get_dispatch_info().weight.all_lte(max_weight),
+					Error::<T>::MaxWeightTooLow
+				);
+
+				// Clean up storage before executing call to avoid an possibility of reentrancy
+				// attack.
+				<Multisigs<T>>::remove(&id, call_hash);
+				T::Currency::unreserve(&m.depositor, m.deposit);
+
+				let result = call.dispatch(RawOrigin::Signed(id.clone()).into());
+				Self::deposit_event(Event::MultisigExecuted {
+					approving: who,
+					timepoint,
+					multisig: id,
+					call_hash,
+					result: result.map(|_| ()).map_err(|e| e.error),
+				});
+				Ok(get_result_weight(result)
+					.map(|actual_weight| {
+						T::WeightInfo::as_multi_complete(
+							other_signatories_len as u32,
+							call_len as u32,
+						)
+						.saturating_add(actual_weight)
+					})
+					.into())
+			} else {
+				// We cannot dispatch the call now; either it isn't available, or it is, but we
+				// don't have threshold approvals even with our signature.
+
+				if let Some(pos) = maybe_pos {
+					// Record approval.
+					m.approvals
+						.try_insert(pos, who.clone())
+						.map_err(|_| Error::<T>::TooManySignatories)?;
+					<Multisigs<T>>::insert(&id, call_hash, m);
+					Self::deposit_event(Event::MultisigApproval {
+						approving: who,
+						timepoint,
+						multisig: id,
+						call_hash,
+					});
+				} else {
+					// If we already approved and didn't store the Call, then this was useless and
+					// we report an error.
+					Err(Error::<T>::AlreadyApproved)?
+				}
+
+				let final_weight =
+					T::WeightInfo::as_multi_approve(other_signatories_len as u32, call_len as u32);
+				// Call is not made, so the actual weight does not include call
+				Ok(Some(final_weight).into())
+			}
+		} else {
+			// Not yet started; there should be no timepoint given.
+			ensure!(maybe_timepoint.is_none(), Error::<T>::UnexpectedTimepoint);
+
+			// Just start the operation by recording it in storage.
+			let deposit = T::DepositBase::get() + T::DepositFactor::get() * threshold.into();
+
+			T::Currency::reserve(&who, deposit)?;
+
+			let initial_approvals =
+				vec![who.clone()].try_into().map_err(|_| Error::<T>::TooManySignatories)?;
+
+			<Multisigs<T>>::insert(
+				&id,
+				call_hash,
+				Multisig {
+					when: Self::timepoint(),
+					deposit,
+					depositor: who.clone(),
+					approvals: initial_approvals,
+				},
+			);
+			Self::deposit_event(Event::NewMultisig { approving: who, multisig: id, call_hash });
+
+			let final_weight =
+				T::WeightInfo::as_multi_create(other_signatories_len as u32, call_len as u32);
+			// Call is not made, so the actual weight does not include call
+			Ok(Some(final_weight).into())
+		}
+	}
+
+	/// The current `Timepoint`.
+	pub fn timepoint() -> Timepoint<BlockNumberFor<T>> {
+		Timepoint {
+			height: <system::Pallet<T>>::block_number(),
+			index: <system::Pallet<T>>::extrinsic_index().unwrap_or_default(),
+		}
+	}
+
+	/// Check that signatories is sorted and doesn't contain sender, then insert sender.
+	fn ensure_sorted_and_insert(
+		other_signatories: Vec<T::AccountId>,
+		who: T::AccountId,
+	) -> Result<Vec<T::AccountId>, DispatchError> {
+		let mut signatories = other_signatories;
+		let mut maybe_last = None;
+		let mut index = 0;
+		for item in signatories.iter() {
+			if let Some(last) = maybe_last {
+				ensure!(last < item, Error::<T>::SignatoriesOutOfOrder);
+			}
+			if item <= &who {
+				ensure!(item != &who, Error::<T>::SenderInSignatories);
+				index += 1;
+			}
+			maybe_last = Some(item);
+		}
+		signatories.insert(index, who);
+		Ok(signatories)
+	}
+}
+
+/// Return the weight of a dispatch call result as an `Option`.
+///
+/// Will return the weight regardless of what the state of the result is.
+fn get_result_weight(result: DispatchResultWithPostInfo) -> Option<Weight> {
+	match result {
+		Ok(post_info) => post_info.actual_weight,
+		Err(err) => err.post_info.actual_weight,
+	}
+}
diff --git a/substrate/frame/multisig/src/migrations.rs b/substrate/frame/multisig/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..298e73c5d75762408229bfae29b7268e67a0185d
--- /dev/null
+++ b/substrate/frame/multisig/src/migrations.rs
@@ -0,0 +1,86 @@
+// 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.
+
+// Migrations for Multisig Pallet
+
+use super::*;
+use frame_support::{
+	dispatch::GetStorageVersion,
+	traits::{OnRuntimeUpgrade, WrapperKeepOpaque},
+	Identity,
+};
+
+#[cfg(feature = "try-runtime")]
+use frame_support::ensure;
+
+pub mod v1 {
+	use super::*;
+
+	type OpaqueCall<T> = WrapperKeepOpaque<<T as Config>::RuntimeCall>;
+
+	#[frame_support::storage_alias]
+	type Calls<T: Config> = StorageMap<
+		Pallet<T>,
+		Identity,
+		[u8; 32],
+		(OpaqueCall<T>, <T as frame_system::Config>::AccountId, BalanceOf<T>),
+	>;
+
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			ensure!(onchain < 1, "this migration can be deleted");
+
+			log!(info, "Number of calls to refund and delete: {}", Calls::<T>::iter().count());
+
+			Ok(Vec::new())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			if onchain > 0 {
+				log!(info, "MigrateToV1 should be removed");
+				return T::DbWeight::get().reads(1)
+			}
+
+			Calls::<T>::drain().for_each(|(_call_hash, (_data, caller, deposit))| {
+				T::Currency::unreserve(&caller, deposit);
+			});
+
+			current.put::<Pallet<T>>();
+
+			<T as frame_system::Config>::BlockWeights::get().max_block
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+			let onchain = Pallet::<T>::on_chain_storage_version();
+			ensure!(onchain < 2, "this migration needs to be removed");
+			ensure!(onchain == 1, "this migration needs to be run");
+			ensure!(
+				Calls::<T>::iter().count() == 0,
+				"there are some dangling calls that need to be destroyed and refunded"
+			);
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/multisig/src/tests.rs b/substrate/frame/multisig/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e7fc5b3e4aaea455be251d26e59877c0ec9e765a
--- /dev/null
+++ b/substrate/frame/multisig/src/tests.rs
@@ -0,0 +1,704 @@
+// 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 Multisig Pallet
+
+#![cfg(test)]
+
+use super::*;
+
+use crate as pallet_multisig;
+use frame_support::{
+	assert_noop, assert_ok, derive_impl,
+	traits::{ConstU32, ConstU64, Contains},
+};
+use sp_runtime::{BuildStorage, TokenError};
+
+type Block = frame_system::mocking::MockBlockU32<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Multisig: pallet_multisig::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+	type BlockHashCount = ConstU32<250>;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type BaseCallFilter = TestBaseCallFilter;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+
+	type AccountData = pallet_balances::AccountData<u64>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig as pallet_balances::DefaultConfig)]
+impl pallet_balances::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeHoldReason = ();
+	type ReserveIdentifier = [u8; 8];
+	type DustRemoval = ();
+	type AccountStore = System;
+	type ExistentialDeposit = ConstU64<1>;
+}
+
+pub struct TestBaseCallFilter;
+impl Contains<RuntimeCall> for TestBaseCallFilter {
+	fn contains(c: &RuntimeCall) -> bool {
+		match *c {
+			RuntimeCall::Balances(_) => true,
+			// Needed for benchmarking
+			RuntimeCall::System(frame_system::Call::remark { .. }) => true,
+			_ => false,
+		}
+	}
+}
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type DepositBase = ConstU64<1>;
+	type DepositFactor = ConstU64<1>;
+	type MaxSignatories = ConstU32<3>;
+	type WeightInfo = ();
+}
+
+use pallet_balances::Call as BalancesCall;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 10), (3, 10), (4, 10), (5, 2)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+fn now() -> Timepoint<u32> {
+	Multisig::timepoint()
+}
+
+fn call_transfer(dest: u64, value: u64) -> Box<RuntimeCall> {
+	Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest, value }))
+}
+
+#[test]
+fn multisig_deposit_is_taken_and_returned() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 2);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		let call_weight = call.get_dispatch_info().weight;
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			call.clone(),
+			Weight::zero()
+		));
+		assert_eq!(Balances::free_balance(1), 2);
+		assert_eq!(Balances::reserved_balance(1), 3);
+
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(2),
+			2,
+			vec![1, 3],
+			Some(now()),
+			call,
+			call_weight
+		));
+		assert_eq!(Balances::free_balance(1), 5);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn cancel_multisig_returns_deposit() {
+	new_test_ext().execute_with(|| {
+		let call = call_transfer(6, 15).encode();
+		let hash = blake2_256(&call);
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(1),
+			3,
+			vec![2, 3],
+			None,
+			hash,
+			Weight::zero()
+		));
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(2),
+			3,
+			vec![1, 3],
+			Some(now()),
+			hash,
+			Weight::zero()
+		));
+		assert_eq!(Balances::free_balance(1), 6);
+		assert_eq!(Balances::reserved_balance(1), 4);
+		assert_ok!(Multisig::cancel_as_multi(RuntimeOrigin::signed(1), 3, vec![2, 3], now(), hash));
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn timepoint_checking_works() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 2);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		let hash = blake2_256(&call.encode());
+
+		assert_noop!(
+			Multisig::approve_as_multi(
+				RuntimeOrigin::signed(2),
+				2,
+				vec![1, 3],
+				Some(now()),
+				hash,
+				Weight::zero()
+			),
+			Error::<Test>::UnexpectedTimepoint,
+		);
+
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			hash,
+			Weight::zero()
+		));
+
+		assert_noop!(
+			Multisig::as_multi(
+				RuntimeOrigin::signed(2),
+				2,
+				vec![1, 3],
+				None,
+				call.clone(),
+				Weight::zero()
+			),
+			Error::<Test>::NoTimepoint,
+		);
+		let later = Timepoint { index: 1, ..now() };
+		assert_noop!(
+			Multisig::as_multi(
+				RuntimeOrigin::signed(2),
+				2,
+				vec![1, 3],
+				Some(later),
+				call,
+				Weight::zero()
+			),
+			Error::<Test>::WrongTimepoint,
+		);
+	});
+}
+
+#[test]
+fn multisig_2_of_3_works() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 2);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		let call_weight = call.get_dispatch_info().weight;
+		let hash = blake2_256(&call.encode());
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			hash,
+			Weight::zero()
+		));
+		assert_eq!(Balances::free_balance(6), 0);
+
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(2),
+			2,
+			vec![1, 3],
+			Some(now()),
+			call,
+			call_weight
+		));
+		assert_eq!(Balances::free_balance(6), 15);
+	});
+}
+
+#[test]
+fn multisig_3_of_3_works() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 3);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		let call_weight = call.get_dispatch_info().weight;
+		let hash = blake2_256(&call.encode());
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(1),
+			3,
+			vec![2, 3],
+			None,
+			hash,
+			Weight::zero()
+		));
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(2),
+			3,
+			vec![1, 3],
+			Some(now()),
+			hash,
+			Weight::zero()
+		));
+		assert_eq!(Balances::free_balance(6), 0);
+
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(3),
+			3,
+			vec![1, 2],
+			Some(now()),
+			call,
+			call_weight
+		));
+		assert_eq!(Balances::free_balance(6), 15);
+	});
+}
+
+#[test]
+fn cancel_multisig_works() {
+	new_test_ext().execute_with(|| {
+		let call = call_transfer(6, 15).encode();
+		let hash = blake2_256(&call);
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(1),
+			3,
+			vec![2, 3],
+			None,
+			hash,
+			Weight::zero()
+		));
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(2),
+			3,
+			vec![1, 3],
+			Some(now()),
+			hash,
+			Weight::zero()
+		));
+		assert_noop!(
+			Multisig::cancel_as_multi(RuntimeOrigin::signed(2), 3, vec![1, 3], now(), hash),
+			Error::<Test>::NotOwner,
+		);
+		assert_ok!(Multisig::cancel_as_multi(RuntimeOrigin::signed(1), 3, vec![2, 3], now(), hash),);
+	});
+}
+
+#[test]
+fn multisig_2_of_3_as_multi_works() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 2);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		let call_weight = call.get_dispatch_info().weight;
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			call.clone(),
+			Weight::zero()
+		));
+		assert_eq!(Balances::free_balance(6), 0);
+
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(2),
+			2,
+			vec![1, 3],
+			Some(now()),
+			call,
+			call_weight
+		));
+		assert_eq!(Balances::free_balance(6), 15);
+	});
+}
+
+#[test]
+fn multisig_2_of_3_as_multi_with_many_calls_works() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 2);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call1 = call_transfer(6, 10);
+		let call1_weight = call1.get_dispatch_info().weight;
+		let call2 = call_transfer(7, 5);
+		let call2_weight = call2.get_dispatch_info().weight;
+
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			call1.clone(),
+			Weight::zero()
+		));
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(2),
+			2,
+			vec![1, 3],
+			None,
+			call2.clone(),
+			Weight::zero()
+		));
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(3),
+			2,
+			vec![1, 2],
+			Some(now()),
+			call1,
+			call1_weight
+		));
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(3),
+			2,
+			vec![1, 2],
+			Some(now()),
+			call2,
+			call2_weight
+		));
+
+		assert_eq!(Balances::free_balance(6), 10);
+		assert_eq!(Balances::free_balance(7), 5);
+	});
+}
+
+#[test]
+fn multisig_2_of_3_cannot_reissue_same_call() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 2);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 10);
+		let call_weight = call.get_dispatch_info().weight;
+		let hash = blake2_256(&call.encode());
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			call.clone(),
+			Weight::zero()
+		));
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(2),
+			2,
+			vec![1, 3],
+			Some(now()),
+			call.clone(),
+			call_weight
+		));
+		assert_eq!(Balances::free_balance(multi), 5);
+
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			call.clone(),
+			Weight::zero()
+		));
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(3),
+			2,
+			vec![1, 2],
+			Some(now()),
+			call.clone(),
+			call_weight
+		));
+
+		System::assert_last_event(
+			pallet_multisig::Event::MultisigExecuted {
+				approving: 3,
+				timepoint: now(),
+				multisig: multi,
+				call_hash: hash,
+				result: Err(TokenError::FundsUnavailable.into()),
+			}
+			.into(),
+		);
+	});
+}
+
+#[test]
+fn minimum_threshold_check_works() {
+	new_test_ext().execute_with(|| {
+		let call = call_transfer(6, 15);
+		assert_noop!(
+			Multisig::as_multi(
+				RuntimeOrigin::signed(1),
+				0,
+				vec![2],
+				None,
+				call.clone(),
+				Weight::zero()
+			),
+			Error::<Test>::MinimumThreshold,
+		);
+		assert_noop!(
+			Multisig::as_multi(
+				RuntimeOrigin::signed(1),
+				1,
+				vec![2],
+				None,
+				call.clone(),
+				Weight::zero()
+			),
+			Error::<Test>::MinimumThreshold,
+		);
+	});
+}
+
+#[test]
+fn too_many_signatories_fails() {
+	new_test_ext().execute_with(|| {
+		let call = call_transfer(6, 15);
+		assert_noop!(
+			Multisig::as_multi(
+				RuntimeOrigin::signed(1),
+				2,
+				vec![2, 3, 4],
+				None,
+				call.clone(),
+				Weight::zero()
+			),
+			Error::<Test>::TooManySignatories,
+		);
+	});
+}
+
+#[test]
+fn duplicate_approvals_are_ignored() {
+	new_test_ext().execute_with(|| {
+		let call = call_transfer(6, 15).encode();
+		let hash = blake2_256(&call);
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			hash,
+			Weight::zero()
+		));
+		assert_noop!(
+			Multisig::approve_as_multi(
+				RuntimeOrigin::signed(1),
+				2,
+				vec![2, 3],
+				Some(now()),
+				hash,
+				Weight::zero()
+			),
+			Error::<Test>::AlreadyApproved,
+		);
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(2),
+			2,
+			vec![1, 3],
+			Some(now()),
+			hash,
+			Weight::zero()
+		));
+		assert_noop!(
+			Multisig::approve_as_multi(
+				RuntimeOrigin::signed(3),
+				2,
+				vec![1, 2],
+				Some(now()),
+				hash,
+				Weight::zero()
+			),
+			Error::<Test>::AlreadyApproved,
+		);
+	});
+}
+
+#[test]
+fn multisig_1_of_3_works() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 1);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		let hash = blake2_256(&call.encode());
+		assert_noop!(
+			Multisig::approve_as_multi(
+				RuntimeOrigin::signed(1),
+				1,
+				vec![2, 3],
+				None,
+				hash,
+				Weight::zero()
+			),
+			Error::<Test>::MinimumThreshold,
+		);
+		assert_noop!(
+			Multisig::as_multi(
+				RuntimeOrigin::signed(1),
+				1,
+				vec![2, 3],
+				None,
+				call.clone(),
+				Weight::zero()
+			),
+			Error::<Test>::MinimumThreshold,
+		);
+		assert_ok!(Multisig::as_multi_threshold_1(
+			RuntimeOrigin::signed(1),
+			vec![2, 3],
+			call_transfer(6, 15)
+		));
+
+		assert_eq!(Balances::free_balance(6), 15);
+	});
+}
+
+#[test]
+fn multisig_filters() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(RuntimeCall::System(frame_system::Call::set_code { code: vec![] }));
+		assert_noop!(
+			Multisig::as_multi_threshold_1(RuntimeOrigin::signed(1), vec![2], call.clone()),
+			DispatchError::from(frame_system::Error::<Test>::CallFiltered),
+		);
+	});
+}
+
+#[test]
+fn weight_check_works() {
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 2);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(1),
+			2,
+			vec![2, 3],
+			None,
+			call.clone(),
+			Weight::zero()
+		));
+		assert_eq!(Balances::free_balance(6), 0);
+
+		assert_noop!(
+			Multisig::as_multi(
+				RuntimeOrigin::signed(2),
+				2,
+				vec![1, 3],
+				Some(now()),
+				call,
+				Weight::zero()
+			),
+			Error::<Test>::MaxWeightTooLow,
+		);
+	});
+}
+
+#[test]
+fn multisig_handles_no_preimage_after_all_approve() {
+	// This test checks the situation where everyone approves a multi-sig, but no-one provides the
+	// call data. In the end, any of the multisig callers can approve again with the call data and
+	// the call will go through.
+	new_test_ext().execute_with(|| {
+		let multi = Multisig::multi_account_id(&[1, 2, 3][..], 3);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(2), multi, 5));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), multi, 5));
+
+		let call = call_transfer(6, 15);
+		let call_weight = call.get_dispatch_info().weight;
+		let hash = blake2_256(&call.encode());
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(1),
+			3,
+			vec![2, 3],
+			None,
+			hash,
+			Weight::zero()
+		));
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(2),
+			3,
+			vec![1, 3],
+			Some(now()),
+			hash,
+			Weight::zero()
+		));
+		assert_ok!(Multisig::approve_as_multi(
+			RuntimeOrigin::signed(3),
+			3,
+			vec![1, 2],
+			Some(now()),
+			hash,
+			Weight::zero()
+		));
+		assert_eq!(Balances::free_balance(6), 0);
+
+		assert_ok!(Multisig::as_multi(
+			RuntimeOrigin::signed(3),
+			3,
+			vec![1, 2],
+			Some(now()),
+			call,
+			call_weight
+		));
+		assert_eq!(Balances::free_balance(6), 15);
+	});
+}
diff --git a/substrate/frame/multisig/src/weights.rs b/substrate/frame/multisig/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7b87d258d383d43aaf8ef8aaddc0546c60b5813e
--- /dev/null
+++ b/substrate/frame/multisig/src/weights.rs
@@ -0,0 +1,281 @@
+// 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.
+
+//! Autogenerated weights for pallet_multisig
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_multisig
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/multisig/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_multisig.
+pub trait WeightInfo {
+	fn as_multi_threshold_1(z: u32, ) -> Weight;
+	fn as_multi_create(s: u32, z: u32, ) -> Weight;
+	fn as_multi_approve(s: u32, z: u32, ) -> Weight;
+	fn as_multi_complete(s: u32, z: u32, ) -> Weight;
+	fn approve_as_multi_create(s: u32, ) -> Weight;
+	fn approve_as_multi_approve(s: u32, ) -> Weight;
+	fn cancel_as_multi(s: u32, ) -> Weight;
+}
+
+/// Weights for pallet_multisig using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_threshold_1(z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 13_452_000 picoseconds.
+		Weight::from_parts(14_425_869, 0)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(493, 0).saturating_mul(z.into()))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_create(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `301 + s * (2 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 46_012_000 picoseconds.
+		Weight::from_parts(34_797_344, 6811)
+			// Standard Error: 833
+			.saturating_add(Weight::from_parts(127_671, 0).saturating_mul(s.into()))
+			// Standard Error: 8
+			.saturating_add(Weight::from_parts(1_498, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[3, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_approve(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `320`
+		//  Estimated: `6811`
+		// Minimum execution time: 29_834_000 picoseconds.
+		Weight::from_parts(20_189_154, 6811)
+			// Standard Error: 637
+			.saturating_add(Weight::from_parts(110_080, 0).saturating_mul(s.into()))
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(1_483, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_complete(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `426 + s * (33 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 51_464_000 picoseconds.
+		Weight::from_parts(39_246_644, 6811)
+			// Standard Error: 1_251
+			.saturating_add(Weight::from_parts(143_313, 0).saturating_mul(s.into()))
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(1_523, 0).saturating_mul(z.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	fn approve_as_multi_create(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `301 + s * (2 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 33_275_000 picoseconds.
+		Weight::from_parts(34_073_221, 6811)
+			// Standard Error: 1_163
+			.saturating_add(Weight::from_parts(124_815, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	fn approve_as_multi_approve(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `320`
+		//  Estimated: `6811`
+		// Minimum execution time: 18_411_000 picoseconds.
+		Weight::from_parts(19_431_787, 6811)
+			// Standard Error: 694
+			.saturating_add(Weight::from_parts(107_220, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	fn cancel_as_multi(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `492 + s * (1 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 33_985_000 picoseconds.
+		Weight::from_parts(35_547_970, 6811)
+			// Standard Error: 1_135
+			.saturating_add(Weight::from_parts(116_537, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_threshold_1(z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 13_452_000 picoseconds.
+		Weight::from_parts(14_425_869, 0)
+			// Standard Error: 4
+			.saturating_add(Weight::from_parts(493, 0).saturating_mul(z.into()))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_create(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `301 + s * (2 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 46_012_000 picoseconds.
+		Weight::from_parts(34_797_344, 6811)
+			// Standard Error: 833
+			.saturating_add(Weight::from_parts(127_671, 0).saturating_mul(s.into()))
+			// Standard Error: 8
+			.saturating_add(Weight::from_parts(1_498, 0).saturating_mul(z.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[3, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_approve(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `320`
+		//  Estimated: `6811`
+		// Minimum execution time: 29_834_000 picoseconds.
+		Weight::from_parts(20_189_154, 6811)
+			// Standard Error: 637
+			.saturating_add(Weight::from_parts(110_080, 0).saturating_mul(s.into()))
+			// Standard Error: 6
+			.saturating_add(Weight::from_parts(1_483, 0).saturating_mul(z.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	/// The range of component `z` is `[0, 10000]`.
+	fn as_multi_complete(s: u32, z: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `426 + s * (33 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 51_464_000 picoseconds.
+		Weight::from_parts(39_246_644, 6811)
+			// Standard Error: 1_251
+			.saturating_add(Weight::from_parts(143_313, 0).saturating_mul(s.into()))
+			// Standard Error: 12
+			.saturating_add(Weight::from_parts(1_523, 0).saturating_mul(z.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	fn approve_as_multi_create(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `301 + s * (2 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 33_275_000 picoseconds.
+		Weight::from_parts(34_073_221, 6811)
+			// Standard Error: 1_163
+			.saturating_add(Weight::from_parts(124_815, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	fn approve_as_multi_approve(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `320`
+		//  Estimated: `6811`
+		// Minimum execution time: 18_411_000 picoseconds.
+		Weight::from_parts(19_431_787, 6811)
+			// Standard Error: 694
+			.saturating_add(Weight::from_parts(107_220, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Multisig Multisigs (r:1 w:1)
+	/// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen)
+	/// The range of component `s` is `[2, 100]`.
+	fn cancel_as_multi(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `492 + s * (1 ±0)`
+		//  Estimated: `6811`
+		// Minimum execution time: 33_985_000 picoseconds.
+		Weight::from_parts(35_547_970, 6811)
+			// Standard Error: 1_135
+			.saturating_add(Weight::from_parts(116_537, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/nft-fractionalization/Cargo.toml b/substrate/frame/nft-fractionalization/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b75f3262c2d01d064de4beb2a885bcb671163493
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/Cargo.toml
@@ -0,0 +1,66 @@
+[package]
+name = "pallet-nft-fractionalization"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to convert non-fungible to fungible tokens."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-assets = { version = "4.0.0-dev", default-features = false, path = "../assets" }
+pallet-nfts = { version = "4.0.0-dev", default-features = false, path = "../nfts" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-std = { version = "8.0.0", path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-assets/std",
+	"pallet-balances/std",
+	"pallet-nfts/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-assets/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-nfts/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-assets/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-nfts/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/nft-fractionalization/README.md b/substrate/frame/nft-fractionalization/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..180eef22cc46f5e1237975244b582b3be03f2200
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/README.md
@@ -0,0 +1,6 @@
+### Lock NFT
+
+Lock an NFT from `pallet-nfts` and mint fungible assets from `pallet-assets`.
+
+The NFT gets locked by putting a system-level attribute named `Locked`. This prevents the NFT from being transferred further.
+The NFT becomes unlocked when the `Locked` attribute is removed. In order to unify the fungible asset and unlock the NFT, an account must hold the full issuance of the asset the NFT was fractionalised into. Holding less of the fungible asset will not allow the unlocking of the NFT. 
diff --git a/substrate/frame/nft-fractionalization/src/benchmarking.rs b/substrate/frame/nft-fractionalization/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0b54acdab49ea7d66fe0f8646c29a254ecd84cbd
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/src/benchmarking.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.
+
+//! Nft fractionalization pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::{benchmarks, whitelisted_caller};
+use frame_support::{
+	assert_ok,
+	traits::{
+		fungible::{Inspect as InspectFungible, Mutate as MutateFungible},
+		tokens::nonfungibles_v2::{Create, Mutate},
+		Get,
+	},
+};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin as SystemOrigin};
+use pallet_nfts::{CollectionConfig, CollectionSettings, ItemConfig, MintSettings};
+use sp_runtime::traits::StaticLookup;
+use sp_std::prelude::*;
+
+use crate::Pallet as NftFractionalization;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as InspectFungible<<T as SystemConfig>::AccountId>>::Balance;
+
+type CollectionConfigOf<T> =
+	CollectionConfig<BalanceOf<T>, BlockNumberFor<T>, <T as Config>::NftCollectionId>;
+
+fn default_collection_config<T: Config>() -> CollectionConfigOf<T>
+where
+	T::Currency: InspectFungible<T::AccountId>,
+{
+	CollectionConfig {
+		settings: CollectionSettings::all_enabled(),
+		max_supply: None,
+		mint_settings: MintSettings::default(),
+	}
+}
+
+fn mint_nft<T: Config>(nft_id: T::NftId) -> (T::AccountId, AccountIdLookupOf<T>)
+where
+	T::Nfts: Create<T::AccountId, CollectionConfig<BalanceOf<T>, BlockNumberFor<T>, T::NftCollectionId>>
+		+ Mutate<T::AccountId, ItemConfig>,
+{
+	let caller: T::AccountId = whitelisted_caller();
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let ed = T::Currency::minimum_balance();
+	let multiplier = BalanceOf::<T>::from(100u8);
+	T::Currency::set_balance(&caller, ed * multiplier + T::Deposit::get() * multiplier);
+
+	assert_ok!(T::Nfts::create_collection(&caller, &caller, &default_collection_config::<T>()));
+	let collection = T::BenchmarkHelper::collection(0);
+	assert_ok!(T::Nfts::mint_into(&collection, &nft_id, &caller, &ItemConfig::default(), true));
+	(caller, caller_lookup)
+}
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+benchmarks! {
+	where_clause {
+		where
+			T::Nfts: Create<T::AccountId, CollectionConfig<BalanceOf<T>, frame_system::pallet_prelude::BlockNumberFor::<T>, T::NftCollectionId>>
+				+ Mutate<T::AccountId, ItemConfig>,
+	}
+
+	fractionalize {
+		let asset = T::BenchmarkHelper::asset(0);
+		let collection = T::BenchmarkHelper::collection(0);
+		let nft = T::BenchmarkHelper::nft(0);
+		let (caller, caller_lookup) = mint_nft::<T>(nft);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, nft, asset.clone(), caller_lookup, 1000u32.into())
+	verify {
+		assert_last_event::<T>(
+			Event::NftFractionalized {
+				nft_collection: collection,
+				nft,
+				fractions: 1000u32.into(),
+				asset,
+				beneficiary: caller,
+			}.into()
+		);
+	}
+
+	unify {
+		let asset = T::BenchmarkHelper::asset(0);
+		let collection = T::BenchmarkHelper::collection(0);
+		let nft = T::BenchmarkHelper::nft(0);
+		let (caller, caller_lookup) = mint_nft::<T>(nft);
+		NftFractionalization::<T>::fractionalize(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection,
+			nft,
+			asset.clone(),
+			caller_lookup.clone(),
+			1000u32.into(),
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, nft, asset.clone(), caller_lookup)
+	verify {
+		assert_last_event::<T>(
+			Event::NftUnified {
+				nft_collection: collection,
+				nft,
+				asset,
+				beneficiary: caller,
+			}.into()
+		);
+	}
+
+	impl_benchmark_test_suite!(NftFractionalization, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/nft-fractionalization/src/lib.rs b/substrate/frame/nft-fractionalization/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b1663e95d855d8af6def429236e11b55ba3ab891
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/src/lib.rs
@@ -0,0 +1,407 @@
+// 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.
+
+//! # NFT Fractionalization Pallet
+//!
+//! This pallet provides the basic functionality that should allow users
+//! to leverage partial ownership, transfers, and sales, of illiquid assets,
+//! whether real-world assets represented by their digital twins, or NFTs,
+//! or original NFTs.
+//!
+//! The functionality allows a user to lock an NFT they own, create a new
+//! fungible asset, and mint a set amount of tokens (`fractions`).
+//!
+//! It also allows the user to burn 100% of the asset and to unlock the NFT
+//! into their account.
+//!
+//! ### Functions
+//!
+//! * `fractionalize`: Lock the NFT and create and mint a new fungible asset.
+//! * `unify`: Return 100% of the asset and unlock the NFT.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod types;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+pub mod mock;
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+
+use frame_system::Config as SystemConfig;
+pub use pallet::*;
+pub use scale_info::Type;
+pub use types::*;
+pub use weights::WeightInfo;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{
+		dispatch::DispatchResult,
+		ensure,
+		pallet_prelude::*,
+		sp_runtime::traits::{AccountIdConversion, StaticLookup},
+		traits::{
+			fungible::{
+				hold::Mutate as HoldMutateFungible, Inspect as InspectFungible,
+				Mutate as MutateFungible,
+			},
+			fungibles::{
+				metadata::{MetadataDeposit, Mutate as MutateMetadata},
+				Create, Destroy, Inspect, Mutate,
+			},
+			tokens::{
+				nonfungibles_v2::{Inspect as NonFungiblesInspect, Transfer},
+				AssetId, Balance as AssetBalance,
+				Fortitude::Polite,
+				Precision::{BestEffort, Exact},
+				Preservation::Preserve,
+			},
+		},
+		BoundedVec, PalletId,
+	};
+	use frame_system::pallet_prelude::*;
+	use scale_info::prelude::{format, string::String};
+	use sp_runtime::traits::{One, Zero};
+	use sp_std::{fmt::Display, prelude::*};
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The currency mechanism, used for paying for deposits.
+		type Currency: InspectFungible<Self::AccountId>
+			+ MutateFungible<Self::AccountId>
+			+ HoldMutateFungible<Self::AccountId, Reason = Self::RuntimeHoldReason>;
+
+		/// Overarching hold reason.
+		type RuntimeHoldReason: From<HoldReason>;
+
+		/// The deposit paid by the user locking an NFT. The deposit is returned to the original NFT
+		/// owner when the asset is unified and the NFT is unlocked.
+		#[pallet::constant]
+		type Deposit: Get<DepositOf<Self>>;
+
+		/// Identifier for the collection of NFT.
+		type NftCollectionId: Member + Parameter + MaxEncodedLen + Copy + Display;
+
+		/// The type used to identify an NFT within a collection.
+		type NftId: Member + Parameter + MaxEncodedLen + Copy + Display;
+
+		/// The type used to describe the amount of fractions converted into assets.
+		type AssetBalance: AssetBalance;
+
+		/// The type used to identify the assets created during fractionalization.
+		type AssetId: AssetId;
+
+		/// Registry for the minted assets.
+		type Assets: Inspect<Self::AccountId, AssetId = Self::AssetId, Balance = Self::AssetBalance>
+			+ Create<Self::AccountId>
+			+ Destroy<Self::AccountId>
+			+ Mutate<Self::AccountId>
+			+ MutateMetadata<Self::AccountId>
+			+ MetadataDeposit<DepositOf<Self>>;
+
+		/// Registry for minted NFTs.
+		type Nfts: NonFungiblesInspect<
+				Self::AccountId,
+				ItemId = Self::NftId,
+				CollectionId = Self::NftCollectionId,
+			> + Transfer<Self::AccountId>;
+
+		/// The pallet's id, used for deriving its sovereign account ID.
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// The newly created asset's symbol.
+		#[pallet::constant]
+		type NewAssetSymbol: Get<BoundedVec<u8, Self::StringLimit>>;
+
+		/// The newly created asset's name.
+		#[pallet::constant]
+		type NewAssetName: Get<BoundedVec<u8, Self::StringLimit>>;
+
+		/// The maximum length of a name or symbol stored on-chain.
+		#[pallet::constant]
+		type StringLimit: Get<u32>;
+
+		/// A set of helper functions for benchmarking.
+		#[cfg(feature = "runtime-benchmarks")]
+		type BenchmarkHelper: BenchmarkHelper<Self::AssetId, Self::NftCollectionId, Self::NftId>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// Keeps track of the corresponding NFT ID, asset ID and amount minted.
+	#[pallet::storage]
+	#[pallet::getter(fn nft_to_asset)]
+	pub type NftToAsset<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		(T::NftCollectionId, T::NftId),
+		Details<AssetIdOf<T>, AssetBalanceOf<T>, DepositOf<T>, T::AccountId>,
+		OptionQuery,
+	>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// An NFT was successfully fractionalized.
+		NftFractionalized {
+			nft_collection: T::NftCollectionId,
+			nft: T::NftId,
+			fractions: AssetBalanceOf<T>,
+			asset: AssetIdOf<T>,
+			beneficiary: T::AccountId,
+		},
+		/// An NFT was successfully returned back.
+		NftUnified {
+			nft_collection: T::NftCollectionId,
+			nft: T::NftId,
+			asset: AssetIdOf<T>,
+			beneficiary: T::AccountId,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Asset ID does not correspond to locked NFT.
+		IncorrectAssetId,
+		/// The signing account has no permission to do the operation.
+		NoPermission,
+		/// NFT doesn't exist.
+		NftNotFound,
+		/// NFT has not yet been fractionalised.
+		NftNotFractionalized,
+	}
+
+	/// A reason for the pallet placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// Reserved for a fractionalized NFT.
+		#[codec(index = 0)]
+		Fractionalized,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Lock the NFT and mint a new fungible asset.
+		///
+		/// The dispatch origin for this call must be Signed.
+		/// The origin must be the owner of the NFT they are trying to lock.
+		///
+		/// `Deposit` funds of sender are reserved.
+		///
+		/// - `nft_collection_id`: The ID used to identify the collection of the NFT.
+		/// Is used within the context of `pallet_nfts`.
+		/// - `nft_id`: The ID used to identify the NFT within the given collection.
+		/// Is used within the context of `pallet_nfts`.
+		/// - `asset_id`: The ID of the new asset. It must not exist.
+		/// Is used within the context of `pallet_assets`.
+		/// - `beneficiary`: The account that will receive the newly created asset.
+		/// - `fractions`: The total issuance of the newly created asset class.
+		///
+		/// Emits `NftFractionalized` event when successful.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::fractionalize())]
+		pub fn fractionalize(
+			origin: OriginFor<T>,
+			nft_collection_id: T::NftCollectionId,
+			nft_id: T::NftId,
+			asset_id: AssetIdOf<T>,
+			beneficiary: AccountIdLookupOf<T>,
+			fractions: AssetBalanceOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+
+			let nft_owner =
+				T::Nfts::owner(&nft_collection_id, &nft_id).ok_or(Error::<T>::NftNotFound)?;
+			ensure!(nft_owner == who, Error::<T>::NoPermission);
+
+			let pallet_account = Self::get_pallet_account();
+			let deposit = T::Deposit::get();
+			T::Currency::hold(&HoldReason::Fractionalized.into(), &nft_owner, deposit)?;
+			Self::do_lock_nft(nft_collection_id, nft_id)?;
+			Self::do_create_asset(asset_id.clone(), pallet_account.clone())?;
+			Self::do_mint_asset(asset_id.clone(), &beneficiary, fractions)?;
+			Self::do_set_metadata(
+				asset_id.clone(),
+				&who,
+				&pallet_account,
+				&nft_collection_id,
+				&nft_id,
+			)?;
+
+			NftToAsset::<T>::insert(
+				(nft_collection_id, nft_id),
+				Details { asset: asset_id.clone(), fractions, asset_creator: nft_owner, deposit },
+			);
+
+			Self::deposit_event(Event::NftFractionalized {
+				nft_collection: nft_collection_id,
+				nft: nft_id,
+				fractions,
+				asset: asset_id,
+				beneficiary,
+			});
+
+			Ok(())
+		}
+
+		/// Burn the total issuance of the fungible asset and return (unlock) the locked NFT.
+		///
+		/// The dispatch origin for this call must be Signed.
+		///
+		/// `Deposit` funds will be returned to `asset_creator`.
+		///
+		/// - `nft_collection_id`: The ID used to identify the collection of the NFT.
+		/// Is used within the context of `pallet_nfts`.
+		/// - `nft_id`: The ID used to identify the NFT within the given collection.
+		/// Is used within the context of `pallet_nfts`.
+		/// - `asset_id`: The ID of the asset being returned and destroyed. Must match
+		/// the original ID of the created asset, corresponding to the NFT.
+		/// Is used within the context of `pallet_assets`.
+		/// - `beneficiary`: The account that will receive the unified NFT.
+		///
+		/// Emits `NftUnified` event when successful.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::unify())]
+		pub fn unify(
+			origin: OriginFor<T>,
+			nft_collection_id: T::NftCollectionId,
+			nft_id: T::NftId,
+			asset_id: AssetIdOf<T>,
+			beneficiary: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+
+			NftToAsset::<T>::try_mutate_exists((nft_collection_id, nft_id), |maybe_details| {
+				let details = maybe_details.take().ok_or(Error::<T>::NftNotFractionalized)?;
+				ensure!(details.asset == asset_id, Error::<T>::IncorrectAssetId);
+
+				let deposit = details.deposit;
+				let asset_creator = details.asset_creator;
+				Self::do_burn_asset(asset_id.clone(), &who, details.fractions)?;
+				Self::do_unlock_nft(nft_collection_id, nft_id, &beneficiary)?;
+				T::Currency::release(
+					&HoldReason::Fractionalized.into(),
+					&asset_creator,
+					deposit,
+					BestEffort,
+				)?;
+
+				Self::deposit_event(Event::NftUnified {
+					nft_collection: nft_collection_id,
+					nft: nft_id,
+					asset: asset_id,
+					beneficiary,
+				});
+
+				Ok(())
+			})
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// The account ID of the pallet.
+		///
+		/// This actually does computation. If you need to keep using it, then make sure you cache
+		/// the value and only call this once.
+		fn get_pallet_account() -> T::AccountId {
+			T::PalletId::get().into_account_truncating()
+		}
+
+		/// Prevent further transferring of NFT.
+		fn do_lock_nft(nft_collection_id: T::NftCollectionId, nft_id: T::NftId) -> DispatchResult {
+			T::Nfts::disable_transfer(&nft_collection_id, &nft_id)
+		}
+
+		/// Remove the transfer lock and transfer the NFT to the account returning the tokens.
+		fn do_unlock_nft(
+			nft_collection_id: T::NftCollectionId,
+			nft_id: T::NftId,
+			account: &T::AccountId,
+		) -> DispatchResult {
+			T::Nfts::enable_transfer(&nft_collection_id, &nft_id)?;
+			T::Nfts::transfer(&nft_collection_id, &nft_id, account)
+		}
+
+		/// Create the new asset.
+		fn do_create_asset(asset_id: AssetIdOf<T>, admin: T::AccountId) -> DispatchResult {
+			T::Assets::create(asset_id, admin, false, One::one())
+		}
+
+		/// Mint the `amount` of tokens with `asset_id` into the beneficiary's account.
+		fn do_mint_asset(
+			asset_id: AssetIdOf<T>,
+			beneficiary: &T::AccountId,
+			amount: AssetBalanceOf<T>,
+		) -> DispatchResult {
+			T::Assets::mint_into(asset_id, beneficiary, amount)?;
+			Ok(())
+		}
+
+		/// Burn tokens from the account.
+		fn do_burn_asset(
+			asset_id: AssetIdOf<T>,
+			account: &T::AccountId,
+			amount: AssetBalanceOf<T>,
+		) -> DispatchResult {
+			T::Assets::burn_from(asset_id.clone(), account, amount, Exact, Polite)?;
+			T::Assets::start_destroy(asset_id, None)
+		}
+
+		/// Set the metadata for the newly created asset.
+		fn do_set_metadata(
+			asset_id: AssetIdOf<T>,
+			depositor: &T::AccountId,
+			pallet_account: &T::AccountId,
+			nft_collection_id: &T::NftCollectionId,
+			nft_id: &T::NftId,
+		) -> DispatchResult {
+			let name = format!(
+				"{} {nft_collection_id}-{nft_id}",
+				String::from_utf8_lossy(&T::NewAssetName::get())
+			);
+			let symbol: &[u8] = &T::NewAssetSymbol::get();
+			let existential_deposit = T::Currency::minimum_balance();
+			let pallet_account_balance = T::Currency::balance(&pallet_account);
+
+			if pallet_account_balance < existential_deposit {
+				T::Currency::transfer(&depositor, &pallet_account, existential_deposit, Preserve)?;
+			}
+			let metadata_deposit = T::Assets::calc_metadata_deposit(name.as_bytes(), symbol);
+			if !metadata_deposit.is_zero() {
+				T::Currency::transfer(&depositor, &pallet_account, metadata_deposit, Preserve)?;
+			}
+			T::Assets::set(asset_id, &pallet_account, name.into(), symbol.into(), 0)
+		}
+	}
+}
diff --git a/substrate/frame/nft-fractionalization/src/mock.rs b/substrate/frame/nft-fractionalization/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6565adaf6fc7e6bc1ebdcc6f7e7f223ea005e16d
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/src/mock.rs
@@ -0,0 +1,186 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! Test environment for Nft fractionalization pallet.
+
+use super::*;
+use crate as pallet_nft_fractionalization;
+
+use frame_support::{
+	construct_runtime, parameter_types,
+	traits::{AsEnsureOriginWithArg, ConstU32, ConstU64},
+	BoundedVec, PalletId,
+};
+use frame_system::EnsureSigned;
+use pallet_nfts::PalletFeatures;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify},
+	BuildStorage, MultiSignature,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+type Signature = MultiSignature;
+type AccountPublic = <Signature as Verify>::Signer;
+type AccountId = <AccountPublic as IdentifyAccount>::AccountId;
+
+// Configure a mock runtime to test the pallet.
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		NftFractionalization: pallet_nft_fractionalization,
+		Assets: pallet_assets,
+		Balances: pallet_balances,
+		Nfts: pallet_nfts,
+	}
+);
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	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 DbWeight = ();
+	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>;
+}
+
+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 MaxHolds = ConstU32<1>;
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+}
+
+impl pallet_assets::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u64;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<Self::AccountId>>;
+	type ForceOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type AssetDeposit = ConstU64<1>;
+	type AssetAccountDeposit = ConstU64<10>;
+	type MetadataDepositBase = ConstU64<1>;
+	type MetadataDepositPerByte = ConstU64<1>;
+	type ApprovalDeposit = ConstU64<1>;
+	type StringLimit = ConstU32<50>;
+	type Freezer = ();
+	type Extra = ();
+	type CallbackHandle = ();
+	type WeightInfo = ();
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+parameter_types! {
+	pub storage Features: PalletFeatures = PalletFeatures::all_enabled();
+}
+
+impl pallet_nfts::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<Self::AccountId>>;
+	type ForceOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type Locker = ();
+	type CollectionDeposit = ConstU64<2>;
+	type ItemDeposit = ConstU64<1>;
+	type MetadataDepositBase = ConstU64<1>;
+	type AttributeDepositBase = ConstU64<1>;
+	type DepositPerByte = ConstU64<1>;
+	type StringLimit = ConstU32<50>;
+	type KeyLimit = ConstU32<50>;
+	type ValueLimit = ConstU32<50>;
+	type ApprovalsLimit = ConstU32<10>;
+	type ItemAttributesApprovalsLimit = ConstU32<2>;
+	type MaxTips = ConstU32<10>;
+	type MaxDeadlineDuration = ConstU64<10000>;
+	type MaxAttributesPerCall = ConstU32<2>;
+	type Features = Features;
+	type OffchainSignature = Signature;
+	type OffchainPublic = AccountPublic;
+	type WeightInfo = ();
+	pallet_nfts::runtime_benchmarks_enabled! {
+		type Helper = ();
+	}
+}
+
+parameter_types! {
+	pub const StringLimit: u32 = 50;
+	pub const NftFractionalizationPalletId: PalletId = PalletId(*b"fraction");
+	pub NewAssetSymbol: BoundedVec<u8, StringLimit> = (*b"FRAC").to_vec().try_into().unwrap();
+	pub NewAssetName: BoundedVec<u8, StringLimit> = (*b"Frac").to_vec().try_into().unwrap();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Deposit = ConstU64<1>;
+	type Currency = Balances;
+	type NewAssetSymbol = NewAssetSymbol;
+	type NewAssetName = NewAssetName;
+	type NftCollectionId = <Self as pallet_nfts::Config>::CollectionId;
+	type NftId = <Self as pallet_nfts::Config>::ItemId;
+	type AssetBalance = <Self as pallet_balances::Config>::Balance;
+	type AssetId = <Self as pallet_assets::Config>::AssetId;
+	type Assets = Assets;
+	type Nfts = Nfts;
+	type PalletId = NftFractionalizationPalletId;
+	type WeightInfo = ();
+	type StringLimit = StringLimit;
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+	type RuntimeHoldReason = RuntimeHoldReason;
+}
+
+// Build genesis storage according to the mock runtime.
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
diff --git a/substrate/frame/nft-fractionalization/src/tests.rs b/substrate/frame/nft-fractionalization/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b82402bda1e678a34a248378424ef02be6416e10
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/src/tests.rs
@@ -0,0 +1,305 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! Tests for Nft fractionalization pallet.
+
+use crate::{mock::*, *};
+use frame_support::{
+	assert_noop, assert_ok,
+	traits::{
+		fungible::{hold::Inspect as InspectHold, Mutate as MutateFungible},
+		fungibles::{metadata::Inspect, InspectEnumerable},
+	},
+};
+use pallet_nfts::CollectionConfig;
+use sp_runtime::{DispatchError, ModuleError, TokenError::FundsUnavailable};
+
+fn assets() -> Vec<u32> {
+	let mut s: Vec<_> = <<Test as Config>::Assets>::asset_ids().collect();
+	s.sort();
+	s
+}
+
+fn events() -> Vec<Event<Test>> {
+	let result = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| {
+			if let mock::RuntimeEvent::NftFractionalization(inner) = e {
+				Some(inner)
+			} else {
+				None
+			}
+		})
+		.collect();
+
+	System::reset_events();
+
+	result
+}
+
+type AccountIdOf<Test> = <Test as frame_system::Config>::AccountId;
+
+fn account(id: u8) -> AccountIdOf<Test> {
+	[id; 32].into()
+}
+
+#[test]
+fn fractionalize_should_work() {
+	new_test_ext().execute_with(|| {
+		let nft_collection_id = 0;
+		let nft_id = 0;
+		let asset_id = 0;
+		let fractions = 1000;
+
+		Balances::set_balance(&account(1), 100);
+		Balances::set_balance(&account(2), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			CollectionConfig::default(),
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			account(1),
+			None,
+		));
+
+		assert_ok!(NftFractionalization::fractionalize(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(2),
+			fractions,
+		));
+		assert_eq!(assets(), vec![asset_id]);
+		assert_eq!(Assets::balance(asset_id, account(2)), fractions);
+		assert_eq!(Balances::total_balance_on_hold(&account(1)), 2);
+		assert_eq!(String::from_utf8(Assets::name(0)).unwrap(), "Frac 0-0");
+		assert_eq!(String::from_utf8(Assets::symbol(0)).unwrap(), "FRAC");
+		assert_eq!(Nfts::owner(nft_collection_id, nft_id), Some(account(1)));
+		assert_noop!(
+			Nfts::transfer(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				account(2),
+			),
+			DispatchError::Module(ModuleError {
+				index: 4,
+				error: [12, 0, 0, 0],
+				message: Some("ItemLocked")
+			})
+		);
+
+		let details = NftToAsset::<Test>::get((&nft_collection_id, &nft_id)).unwrap();
+		assert_eq!(details.asset, asset_id);
+		assert_eq!(details.fractions, fractions);
+
+		assert!(events().contains(&Event::<Test>::NftFractionalized {
+			nft_collection: nft_collection_id,
+			nft: nft_id,
+			fractions,
+			asset: asset_id,
+			beneficiary: account(2),
+		}));
+
+		// owner can't burn an already fractionalized NFT
+		assert_noop!(
+			Nfts::burn(RuntimeOrigin::signed(account(1)), nft_collection_id, nft_id),
+			DispatchError::Module(ModuleError {
+				index: 4,
+				error: [12, 0, 0, 0],
+				message: Some("ItemLocked")
+			})
+		);
+
+		// can't fractionalize twice
+		assert_noop!(
+			NftFractionalization::fractionalize(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id + 1,
+				account(2),
+				fractions,
+			),
+			DispatchError::Module(ModuleError {
+				index: 4,
+				error: [12, 0, 0, 0],
+				message: Some("ItemLocked")
+			})
+		);
+
+		let nft_id = nft_id + 1;
+		assert_noop!(
+			NftFractionalization::fractionalize(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(2),
+				fractions,
+			),
+			Error::<Test>::NftNotFound
+		);
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			account(2),
+			None
+		));
+		assert_noop!(
+			NftFractionalization::fractionalize(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(2),
+				fractions,
+			),
+			Error::<Test>::NoPermission
+		);
+	});
+}
+
+#[test]
+fn unify_should_work() {
+	new_test_ext().execute_with(|| {
+		let nft_collection_id = 0;
+		let nft_id = 0;
+		let asset_id = 0;
+		let fractions = 1000;
+
+		Balances::set_balance(&account(1), 100);
+		Balances::set_balance(&account(2), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			CollectionConfig::default(),
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			account(1),
+			None,
+		));
+		assert_ok!(NftFractionalization::fractionalize(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(2),
+			fractions,
+		));
+
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(2)),
+				nft_collection_id + 1,
+				nft_id,
+				asset_id,
+				account(1),
+			),
+			Error::<Test>::NftNotFractionalized
+		);
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(2)),
+				nft_collection_id,
+				nft_id,
+				asset_id + 1,
+				account(1),
+			),
+			Error::<Test>::IncorrectAssetId
+		);
+
+		// can't unify the asset a user doesn't hold
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(1),
+			),
+			DispatchError::Token(FundsUnavailable)
+		);
+
+		assert_ok!(NftFractionalization::unify(
+			RuntimeOrigin::signed(account(2)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(1),
+		));
+
+		assert_eq!(Assets::balance(asset_id, account(2)), 0);
+		assert_eq!(Balances::reserved_balance(&account(1)), 1);
+		assert_eq!(Nfts::owner(nft_collection_id, nft_id), Some(account(1)));
+		assert!(!NftToAsset::<Test>::contains_key((&nft_collection_id, &nft_id)));
+
+		assert!(events().contains(&Event::<Test>::NftUnified {
+			nft_collection: nft_collection_id,
+			nft: nft_id,
+			asset: asset_id,
+			beneficiary: account(1),
+		}));
+
+		// validate we need to hold the full balance to un-fractionalize the NFT
+		let asset_id = asset_id + 1;
+		assert_ok!(NftFractionalization::fractionalize(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(1),
+			fractions,
+		));
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(account(1)), asset_id, account(2), 1));
+		assert_eq!(Assets::balance(asset_id, account(1)), fractions - 1);
+		assert_eq!(Assets::balance(asset_id, account(2)), 1);
+		assert_noop!(
+			NftFractionalization::unify(
+				RuntimeOrigin::signed(account(1)),
+				nft_collection_id,
+				nft_id,
+				asset_id,
+				account(1),
+			),
+			DispatchError::Token(FundsUnavailable)
+		);
+
+		assert_ok!(Assets::transfer(RuntimeOrigin::signed(account(2)), asset_id, account(1), 1));
+		assert_ok!(NftFractionalization::unify(
+			RuntimeOrigin::signed(account(1)),
+			nft_collection_id,
+			nft_id,
+			asset_id,
+			account(2),
+		));
+		assert_eq!(Nfts::owner(nft_collection_id, nft_id), Some(account(2)));
+	});
+}
diff --git a/substrate/frame/nft-fractionalization/src/types.rs b/substrate/frame/nft-fractionalization/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cbaaf5f5160d3168127b1883b52e879fb92696f1
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/src/types.rs
@@ -0,0 +1,76 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Various basic types for use in the Nft fractionalization pallet.
+
+use super::*;
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::traits::{fungible::Inspect as FunInspect, fungibles::Inspect};
+use scale_info::TypeInfo;
+use sp_runtime::traits::StaticLookup;
+
+pub type AssetIdOf<T> = <<T as Config>::Assets as Inspect<<T as SystemConfig>::AccountId>>::AssetId;
+pub type AssetBalanceOf<T> =
+	<<T as Config>::Assets as Inspect<<T as SystemConfig>::AccountId>>::Balance;
+pub type DepositOf<T> =
+	<<T as Config>::Currency as FunInspect<<T as SystemConfig>::AccountId>>::Balance;
+pub type AccountIdLookupOf<T> = <<T as SystemConfig>::Lookup as StaticLookup>::Source;
+
+/// Stores the details of a fractionalized item.
+#[derive(Decode, Encode, Default, PartialEq, Eq, MaxEncodedLen, TypeInfo)]
+pub struct Details<AssetId, Fractions, Deposit, AccountId> {
+	/// Minted asset.
+	pub asset: AssetId,
+
+	/// Number of fractions minted.
+	pub fractions: Fractions,
+
+	/// Reserved deposit for creating a new asset.
+	pub deposit: Deposit,
+
+	/// Account that fractionalized an item.
+	pub asset_creator: AccountId,
+}
+
+/// Benchmark Helper
+#[cfg(feature = "runtime-benchmarks")]
+pub trait BenchmarkHelper<AssetId, CollectionId, ItemId> {
+	/// Returns an asset id from a given integer.
+	fn asset(id: u32) -> AssetId;
+	/// Returns a collection id from a given integer.
+	fn collection(id: u32) -> CollectionId;
+	/// Returns an nft id from a given integer.
+	fn nft(id: u32) -> ItemId;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<AssetId, CollectionId, ItemId> BenchmarkHelper<AssetId, CollectionId, ItemId> for ()
+where
+	AssetId: From<u32>,
+	CollectionId: From<u32>,
+	ItemId: From<u32>,
+{
+	fn asset(id: u32) -> AssetId {
+		id.into()
+	}
+	fn collection(id: u32) -> CollectionId {
+		id.into()
+	}
+	fn nft(id: u32) -> ItemId {
+		id.into()
+	}
+}
diff --git a/substrate/frame/nft-fractionalization/src/weights.rs b/substrate/frame/nft-fractionalization/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ebb4aa0fbcfba2df71b6b7ecb9368540ef8b9ffa
--- /dev/null
+++ b/substrate/frame/nft-fractionalization/src/weights.rs
@@ -0,0 +1,186 @@
+// 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.
+
+//! Autogenerated weights for pallet_nft_fractionalization
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_nft_fractionalization
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/nft-fractionalization/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_nft_fractionalization.
+pub trait WeightInfo {
+	fn fractionalize() -> Weight;
+	fn unify() -> Weight;
+}
+
+/// Weights for pallet_nft_fractionalization using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: NftFractionalization NftToAsset (r:0 w:1)
+	/// Proof: NftFractionalization NftToAsset (max_values: None, max_size: Some(92), added: 2567, mode: MaxEncodedLen)
+	fn fractionalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `609`
+		//  Estimated: `4326`
+		// Minimum execution time: 187_416_000 picoseconds.
+		Weight::from_parts(191_131_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(8_u64))
+	}
+	/// Storage: NftFractionalization NftToAsset (r:1 w:1)
+	/// Proof: NftFractionalization NftToAsset (max_values: None, max_size: Some(92), added: 2567, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn unify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1422`
+		//  Estimated: `4326`
+		// Minimum execution time: 134_159_000 picoseconds.
+		Weight::from_parts(136_621_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(10_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Metadata (r:1 w:1)
+	/// Proof: Assets Metadata (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: NftFractionalization NftToAsset (r:0 w:1)
+	/// Proof: NftFractionalization NftToAsset (max_values: None, max_size: Some(92), added: 2567, mode: MaxEncodedLen)
+	fn fractionalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `609`
+		//  Estimated: `4326`
+		// Minimum execution time: 187_416_000 picoseconds.
+		Weight::from_parts(191_131_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(8_u64))
+	}
+	/// Storage: NftFractionalization NftToAsset (r:1 w:1)
+	/// Proof: NftFractionalization NftToAsset (max_values: None, max_size: Some(92), added: 2567, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn unify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1422`
+		//  Estimated: `4326`
+		// Minimum execution time: 134_159_000 picoseconds.
+		Weight::from_parts(136_621_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(10_u64))
+	}
+}
diff --git a/substrate/frame/nfts/Cargo.toml b/substrate/frame/nfts/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..126e4439b50243591c626ae234c8e58870195d0a
--- /dev/null
+++ b/substrate/frame/nfts/Cargo.toml
@@ -0,0 +1,60 @@
+[package]
+name = "pallet-nfts"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME NFTs pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+enumflags2 = { version = "0.7.7" }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-keystore/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/nfts/README.md b/substrate/frame/nfts/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7de4b9440e7f50a30aee080601df44537defc282
--- /dev/null
+++ b/substrate/frame/nfts/README.md
@@ -0,0 +1,106 @@
+# NFTs pallet
+
+A pallet for dealing with non-fungible assets.
+
+## Overview
+
+The NFTs pallet provides functionality for non-fungible tokens' management, including:
+
+* Collection Creation
+* NFT Minting
+* NFT Transfers and Atomic Swaps
+* NFT Trading methods
+* Attributes Management
+* NFT Burning
+
+To use it in your runtime, you need to implement [`nfts::Config`](https://paritytech.github.io/substrate/master/pallet_nfts/pallet/trait.Config.html).
+
+The supported dispatchable functions are documented in the [`nfts::Call`](https://paritytech.github.io/substrate/master/pallet_nfts/pallet/enum.Call.html) enum.
+
+### Terminology
+
+* **Collection creation:** The creation of a new collection.
+* **NFT minting:** The action of creating a new item within a collection.
+* **NFT transfer:** The action of sending an item from one account to another.
+* **Atomic swap:** The action of exchanging items between accounts without needing a 3rd party service.
+* **NFT burning:** The destruction of an item.
+* **Non-fungible token (NFT):** An item for which each unit has unique characteristics. There is exactly
+  one instance of such an item in existence and there is exactly one owning account (though that owning account could be a proxy account or multi-sig account).
+* **Soul Bound NFT:** An item that is non-transferable from the account which it is minted into.
+
+### Goals
+
+The NFTs pallet in Substrate is designed to make the following possible:
+
+* Allow accounts to permissionlessly create nft collections.
+* Allow a named (permissioned) account to mint and burn unique items within a collection.
+* Move items between accounts permissionlessly.
+* Allow a named (permissioned) account to freeze and unfreeze items within a
+  collection or the entire collection.
+* Allow the owner of an item to delegate the ability to transfer the item to some
+  named third-party.
+* Allow third-parties to store information in an NFT _without_ owning it (Eg. save game state).
+
+## Interface
+
+### Permissionless dispatchables
+
+* `create`: Create a new collection by placing a deposit.
+* `mint`: Mint a new item within a collection (when the minting is public).
+* `transfer`: Send an item to a new owner.
+* `redeposit`: Update the deposit amount of an item, potentially freeing funds.
+* `approve_transfer`: Name a delegate who may authorize a transfer.
+* `cancel_approval`: Revert the effects of a previous `approve_transfer`.
+* `approve_item_attributes`: Name a delegate who may change item's attributes within a namespace.
+* `cancel_item_attributes_approval`: Revert the effects of a previous `approve_item_attributes`.
+* `set_price`: Set the price for an item.
+* `buy_item`: Buy an item.
+* `pay_tips`: Pay tips, could be used for paying the creator royalties.
+* `create_swap`: Create an offer to swap an NFT for another NFT and optionally some fungibles.
+* `cancel_swap`: Cancel previously created swap offer.
+* `claim_swap`: Swap items in an atomic way.
+
+
+### Permissioned dispatchables
+
+* `destroy`: Destroy a collection. This destroys all the items inside the collection and refunds the deposit.
+* `force_mint`: Mint a new item within a collection.
+* `burn`: Destroy an item within a collection.
+* `lock_item_transfer`: Prevent an individual item from being transferred.
+* `unlock_item_transfer`: Revert the effects of a previous `lock_item_transfer`.
+* `clear_all_transfer_approvals`: Clears all transfer approvals set by calling the `approve_transfer`.
+* `lock_collection`: Prevent all items within a collection from being transferred (making them all `soul bound`).
+* `lock_item_properties`: Lock item's metadata or attributes.
+* `transfer_ownership`: Alter the owner of a collection, moving all associated deposits. (Ownership of individual items will not be affected.)
+* `set_team`: Alter the permissioned accounts of a collection.
+* `set_collection_max_supply`: Change the max supply of a collection.
+* `update_mint_settings`: Update the minting settings for collection.
+
+
+### Metadata (permissioned) dispatchables
+
+* `set_attribute`: Set a metadata attribute of an item or collection.
+* `clear_attribute`: Remove a metadata attribute of an item or collection.
+* `set_metadata`: Set general metadata of an item (E.g. an IPFS address of an image url).
+* `clear_metadata`: Remove general metadata of an item.
+* `set_collection_metadata`: Set general metadata of a collection.
+* `clear_collection_metadata`: Remove general metadata of a collection.
+
+
+### Force (i.e. governance) dispatchables
+
+* `force_create`: Create a new collection (the collection id can not be chosen).
+* `force_collection_owner`: Change collection's owner.
+* `force_collection_config`: Change collection's config.
+* `force_set_attribute`: Set an attribute.
+
+Please refer to the [`Call`](https://paritytech.github.io/substrate/master/pallet_nfts/pallet/enum.Call.html) enum
+and its associated variants for documentation on each function.
+
+## Related Modules
+
+* [`System`](https://docs.rs/frame-system/latest/frame_system/)
+* [`Support`](https://docs.rs/frame-support/latest/frame_support/)
+* [`Assets`](https://docs.rs/pallet-assets/latest/pallet_assets/)
+
+License: Apache-2.0
diff --git a/substrate/frame/nfts/runtime-api/Cargo.toml b/substrate/frame/nfts/runtime-api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a3e08708ae1782453e4e0ee6335f4c0b8d74b8e3
--- /dev/null
+++ b/substrate/frame/nfts/runtime-api/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "pallet-nfts-runtime-api"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Runtime API for the FRAME NFTs pallet."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+pallet-nfts = { version = "4.0.0-dev", default-features = false, path = "../../nfts" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/api" }
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "frame-support/std", "pallet-nfts/std", "sp-api/std" ]
diff --git a/substrate/frame/nfts/runtime-api/README.md b/substrate/frame/nfts/runtime-api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..289036d2c0d27a4bf3349dccaf0128ff7005f0b8
--- /dev/null
+++ b/substrate/frame/nfts/runtime-api/README.md
@@ -0,0 +1,3 @@
+RPC runtime API for the FRAME NFTs pallet.
+
+License: Apache-2.0
diff --git a/substrate/frame/nfts/runtime-api/src/lib.rs b/substrate/frame/nfts/runtime-api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0c23d178107e714e44a78b41b74d1210b56178d4
--- /dev/null
+++ b/substrate/frame/nfts/runtime-api/src/lib.rs
@@ -0,0 +1,57 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2023 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.
+
+//! Runtime API definition for the FRAME NFTs pallet.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+use frame_support::dispatch::Vec;
+
+sp_api::decl_runtime_apis! {
+	pub trait NftsApi<AccountId, CollectionId, ItemId>
+	where
+		AccountId: Encode + Decode,
+		CollectionId: Encode,
+		ItemId: Encode,
+	{
+		fn owner(collection: CollectionId, item: ItemId) -> Option<AccountId>;
+
+		fn collection_owner(collection: CollectionId) -> Option<AccountId>;
+
+		fn attribute(
+			collection: CollectionId,
+			item: ItemId,
+			key: Vec<u8>,
+		) -> Option<Vec<u8>>;
+
+		fn custom_attribute(
+			account: AccountId,
+			collection: CollectionId,
+			item: ItemId,
+			key: Vec<u8>,
+		) -> Option<Vec<u8>>;
+
+		fn system_attribute(
+			collection: CollectionId,
+			item: ItemId,
+			key: Vec<u8>,
+		) -> Option<Vec<u8>>;
+
+		fn collection_attribute(collection: CollectionId, key: Vec<u8>) -> Option<Vec<u8>>;
+	}
+}
diff --git a/substrate/frame/nfts/src/benchmarking.rs b/substrate/frame/nfts/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..995c842036746c86ca9ab3441a72fe4a52f2a820
--- /dev/null
+++ b/substrate/frame/nfts/src/benchmarking.rs
@@ -0,0 +1,896 @@
+// 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.
+
+//! Nfts pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use enumflags2::{BitFlag, BitFlags};
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelist_account, whitelisted_caller, BenchmarkError,
+};
+use frame_support::{
+	assert_ok,
+	dispatch::UnfilteredDispatchable,
+	traits::{EnsureOrigin, Get},
+	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_std::prelude::*;
+
+use crate::Pallet as Nfts;
+
+const SEED: u32 = 0;
+
+fn create_collection<T: Config<I>, I: 'static>(
+) -> (T::CollectionId, T::AccountId, AccountIdLookupOf<T>) {
+	let caller: T::AccountId = whitelisted_caller();
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let collection = T::Helper::collection(0);
+	T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+	assert_ok!(Nfts::<T, I>::force_create(
+		SystemOrigin::Root.into(),
+		caller_lookup.clone(),
+		default_collection_config::<T, I>()
+	));
+	(collection, caller, caller_lookup)
+}
+
+fn add_collection_metadata<T: Config<I>, I: 'static>() -> (T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	assert_ok!(Nfts::<T, I>::set_collection_metadata(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
+	));
+	(caller, caller_lookup)
+}
+
+fn mint_item<T: Config<I>, I: 'static>(
+	index: u16,
+) -> (T::ItemId, T::AccountId, AccountIdLookupOf<T>) {
+	let item = T::Helper::item(index);
+	let collection = T::Helper::collection(0);
+	let caller = Collection::<T, I>::get(collection).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let item_exists = Item::<T, I>::contains_key(&collection, &item);
+	let item_config = ItemConfigOf::<T, I>::get(&collection, &item);
+	if item_exists {
+		return (item, caller, caller_lookup)
+	} else if let Some(item_config) = item_config {
+		assert_ok!(Nfts::<T, I>::force_mint(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection,
+			item,
+			caller_lookup.clone(),
+			item_config,
+		));
+	} else {
+		assert_ok!(Nfts::<T, I>::mint(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection,
+			item,
+			caller_lookup.clone(),
+			None,
+		));
+	}
+	(item, caller, caller_lookup)
+}
+
+fn lock_item<T: Config<I>, I: 'static>(
+	index: u16,
+) -> (T::ItemId, T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let item = T::Helper::item(index);
+	assert_ok!(Nfts::<T, I>::lock_item_transfer(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		item,
+	));
+	(item, caller, caller_lookup)
+}
+
+fn burn_item<T: Config<I>, I: 'static>(
+	index: u16,
+) -> (T::ItemId, T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let item = T::Helper::item(index);
+	assert_ok!(Nfts::<T, I>::burn(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		item,
+	));
+	(item, caller, caller_lookup)
+}
+
+fn add_item_metadata<T: Config<I>, I: 'static>(
+	item: T::ItemId,
+) -> (T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	assert_ok!(Nfts::<T, I>::set_metadata(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		item,
+		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
+	));
+	(caller, caller_lookup)
+}
+
+fn add_item_attribute<T: Config<I>, I: 'static>(
+	item: T::ItemId,
+) -> (BoundedVec<u8, T::KeyLimit>, T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let key: BoundedVec<_, _> = vec![0; T::KeyLimit::get() as usize].try_into().unwrap();
+	assert_ok!(Nfts::<T, I>::set_attribute(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		Some(item),
+		AttributeNamespace::CollectionOwner,
+		key.clone(),
+		vec![0; T::ValueLimit::get() as usize].try_into().unwrap(),
+	));
+	(key, caller, caller_lookup)
+}
+
+fn add_collection_attribute<T: Config<I>, I: 'static>(
+	i: u16,
+) -> (BoundedVec<u8, T::KeyLimit>, T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let key: BoundedVec<_, _> = make_filled_vec(i, T::KeyLimit::get() as usize).try_into().unwrap();
+	assert_ok!(Nfts::<T, I>::set_attribute(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		None,
+		AttributeNamespace::CollectionOwner,
+		key.clone(),
+		vec![0; T::ValueLimit::get() as usize].try_into().unwrap(),
+	));
+	(key, caller, caller_lookup)
+}
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	let events = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+fn make_collection_config<T: Config<I>, I: 'static>(
+	disable_settings: BitFlags<CollectionSetting>,
+) -> CollectionConfigFor<T, I> {
+	CollectionConfig {
+		settings: CollectionSettings::from_disabled(disable_settings),
+		max_supply: None,
+		mint_settings: MintSettings::default(),
+	}
+}
+
+fn default_collection_config<T: Config<I>, I: 'static>() -> CollectionConfigFor<T, I> {
+	make_collection_config::<T, I>(CollectionSetting::empty())
+}
+
+fn default_item_config() -> ItemConfig {
+	ItemConfig { settings: ItemSettings::all_enabled() }
+}
+
+fn make_filled_vec(value: u16, length: usize) -> Vec<u8> {
+	let mut vec = vec![0u8; length];
+	let mut s = Vec::from(value.to_be_bytes());
+	vec.truncate(length - s.len());
+	vec.append(&mut s);
+	vec
+}
+
+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)
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let caller = T::CreateOrigin::ensure_origin(origin.clone(), &collection).unwrap();
+		whitelist_account!(caller);
+		let admin = T::Lookup::unlookup(caller.clone());
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+		let call = Call::<T, I>::create { admin, config: default_collection_config::<T, I>() };
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::NextCollectionIdIncremented { next_id: Some(T::Helper::collection(1)) }.into());
+	}
+
+	force_create {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+	}: _(SystemOrigin::Root, caller_lookup, default_collection_config::<T, I>())
+	verify {
+		assert_last_event::<T, I>(Event::NextCollectionIdIncremented { next_id: Some(T::Helper::collection(1)) }.into());
+	}
+
+	destroy {
+		let m in 0 .. 1_000;
+		let c in 0 .. 1_000;
+		let a in 0 .. 1_000;
+
+		let (collection, caller, _) = create_collection::<T, I>();
+		add_collection_metadata::<T, I>();
+		for i in 0..m {
+			mint_item::<T, I>(i as u16);
+			add_item_metadata::<T, I>(T::Helper::item(i as u16));
+			lock_item::<T, I>(i as u16);
+			burn_item::<T, I>(i as u16);
+		}
+		for i in 0..c {
+			mint_item::<T, I>(i as u16);
+			lock_item::<T, I>(i as u16);
+			burn_item::<T, I>(i as u16);
+		}
+		for i in 0..a {
+			add_collection_attribute::<T, I>(i as u16);
+		}
+		let witness = Collection::<T, I>::get(collection).unwrap().destroy_witness();
+	}: _(SystemOrigin::Signed(caller), collection, witness)
+	verify {
+		assert_last_event::<T, I>(Event::Destroyed { collection }.into());
+	}
+
+	mint {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let item = T::Helper::item(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, caller_lookup, None)
+	verify {
+		assert_last_event::<T, I>(Event::Issued { collection, item, owner: caller }.into());
+	}
+
+	force_mint {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let item = T::Helper::item(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, caller_lookup, default_item_config())
+	verify {
+		assert_last_event::<T, I>(Event::Issued { collection, item, owner: caller }.into());
+	}
+
+	burn {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item)
+	verify {
+		assert_last_event::<T, I>(Event::Burned { collection, item, owner: caller }.into());
+	}
+
+	transfer {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, target_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::Transferred { collection, item, from: caller, to: target }.into());
+	}
+
+	redeposit {
+		let i in 0 .. 5_000;
+		let (collection, caller, _) = create_collection::<T, I>();
+		let items = (0..i).map(|x| mint_item::<T, I>(x as u16).0).collect::<Vec<_>>();
+		Nfts::<T, I>::force_collection_config(
+			SystemOrigin::Root.into(),
+			collection,
+			make_collection_config::<T, I>(CollectionSetting::DepositRequired.into()),
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, items.clone())
+	verify {
+		assert_last_event::<T, I>(Event::Redeposited { collection, successful_items: items }.into());
+	}
+
+	lock_item_transfer {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller.clone()), T::Helper::collection(0), T::Helper::item(0))
+	verify {
+		assert_last_event::<T, I>(Event::ItemTransferLocked { collection: T::Helper::collection(0), item: T::Helper::item(0) }.into());
+	}
+
+	unlock_item_transfer {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		Nfts::<T, I>::lock_item_transfer(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection,
+			item,
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item)
+	verify {
+		assert_last_event::<T, I>(Event::ItemTransferUnlocked { collection, item }.into());
+	}
+
+	lock_collection {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let lock_settings = CollectionSettings::from_disabled(
+			CollectionSetting::TransferableItems |
+				CollectionSetting::UnlockedMetadata |
+				CollectionSetting::UnlockedAttributes |
+				CollectionSetting::UnlockedMaxSupply,
+		);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, lock_settings)
+	verify {
+		assert_last_event::<T, I>(Event::CollectionLocked { collection }.into());
+	}
+
+	transfer_ownership {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
+		let origin = SystemOrigin::Signed(target.clone()).into();
+		Nfts::<T, I>::set_accept_ownership(origin, Some(collection))?;
+	}: _(SystemOrigin::Signed(caller), collection, target_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::OwnerChanged { collection, new_owner: target }.into());
+	}
+
+	set_team {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let target0 = Some(T::Lookup::unlookup(account("target", 0, SEED)));
+		let target1 = Some(T::Lookup::unlookup(account("target", 1, SEED)));
+		let target2 = Some(T::Lookup::unlookup(account("target", 2, SEED)));
+	}: _(SystemOrigin::Signed(caller), collection, target0, target1, target2)
+	verify {
+		assert_last_event::<T, I>(Event::TeamChanged{
+			collection,
+			issuer: Some(account("target", 0, SEED)),
+			admin: Some(account("target", 1, SEED)),
+			freezer: Some(account("target", 2, SEED)),
+		}.into());
+	}
+
+	force_collection_owner {
+		let (collection, _, _) = create_collection::<T, I>();
+		let origin =
+			T::ForceOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
+		let call = Call::<T, I>::force_collection_owner {
+			collection,
+			owner: target_lookup,
+		};
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::OwnerChanged { collection, new_owner: target }.into());
+	}
+
+	force_collection_config {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let origin =
+			T::ForceOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::force_collection_config {
+			collection,
+			config: make_collection_config::<T, I>(CollectionSetting::DepositRequired.into()),
+		};
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::CollectionConfigChanged { collection }.into());
+	}
+
+	lock_item_properties {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let lock_metadata = true;
+		let lock_attributes = true;
+	}: _(SystemOrigin::Signed(caller), collection, item, lock_metadata, lock_attributes)
+	verify {
+		assert_last_event::<T, I>(Event::ItemPropertiesLocked { collection, item, lock_metadata, lock_attributes }.into());
+	}
+
+	set_attribute {
+		let key: BoundedVec<_, _> = vec![0u8; T::KeyLimit::get() as usize].try_into().unwrap();
+		let value: BoundedVec<_, _> = vec![0u8; T::ValueLimit::get() as usize].try_into().unwrap();
+
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller), collection, Some(item), AttributeNamespace::CollectionOwner, key.clone(), value.clone())
+	verify {
+		assert_last_event::<T, I>(
+			Event::AttributeSet {
+				collection,
+				maybe_item: Some(item),
+				namespace: AttributeNamespace::CollectionOwner,
+				key,
+				value,
+			}
+			.into(),
+		);
+	}
+
+	force_set_attribute {
+		let key: BoundedVec<_, _> = vec![0u8; T::KeyLimit::get() as usize].try_into().unwrap();
+		let value: BoundedVec<_, _> = vec![0u8; T::ValueLimit::get() as usize].try_into().unwrap();
+
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Root, Some(caller), collection, Some(item), AttributeNamespace::CollectionOwner, key.clone(), value.clone())
+	verify {
+		assert_last_event::<T, I>(
+			Event::AttributeSet {
+				collection,
+				maybe_item: Some(item),
+				namespace: AttributeNamespace::CollectionOwner,
+				key,
+				value,
+			}
+			.into(),
+		);
+	}
+
+	clear_attribute {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+		let (key, ..) = add_item_attribute::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection, Some(item), AttributeNamespace::CollectionOwner, key.clone())
+	verify {
+		assert_last_event::<T, I>(
+			Event::AttributeCleared {
+				collection,
+				maybe_item: Some(item),
+				namespace: AttributeNamespace::CollectionOwner,
+				key,
+			}.into(),
+		);
+	}
+
+	approve_item_attributes {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+	}: _(SystemOrigin::Signed(caller), collection, item, target_lookup)
+	verify {
+		assert_last_event::<T, I>(
+			Event::ItemAttributesApprovalAdded {
+				collection,
+				item,
+				delegate: target,
+			}
+			.into(),
+		);
+	}
+
+	cancel_item_attributes_approval {
+		let n in 0 .. 1_000;
+
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		Nfts::<T, I>::approve_item_attributes(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection,
+			item,
+			target_lookup.clone(),
+		)?;
+		T::Currency::make_free_balance_be(&target, DepositBalanceOf::<T, I>::max_value());
+		let value: BoundedVec<_, _> = vec![0u8; T::ValueLimit::get() as usize].try_into().unwrap();
+		for i in 0..n {
+			let key = make_filled_vec(i as u16, T::KeyLimit::get() as usize);
+			Nfts::<T, I>::set_attribute(
+				SystemOrigin::Signed(target.clone()).into(),
+				T::Helper::collection(0),
+				Some(item),
+				AttributeNamespace::Account(target.clone()),
+				key.try_into().unwrap(),
+				value.clone(),
+			)?;
+		}
+		let witness = CancelAttributesApprovalWitness { account_attributes: n };
+	}: _(SystemOrigin::Signed(caller), collection, item, target_lookup, witness)
+	verify {
+		assert_last_event::<T, I>(
+			Event::ItemAttributesApprovalRemoved {
+				collection,
+				item,
+				delegate: target,
+			}
+			.into(),
+		);
+	}
+
+	set_metadata {
+		let data: BoundedVec<_, _> = vec![0u8; T::StringLimit::get() as usize].try_into().unwrap();
+
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller), collection, item, data.clone())
+	verify {
+		assert_last_event::<T, I>(Event::ItemMetadataSet { collection, item, data }.into());
+	}
+
+	clear_metadata {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection, item)
+	verify {
+		assert_last_event::<T, I>(Event::ItemMetadataCleared { collection, item }.into());
+	}
+
+	set_collection_metadata {
+		let data: BoundedVec<_, _> = vec![0u8; T::StringLimit::get() as usize].try_into().unwrap();
+
+		let (collection, caller, _) = create_collection::<T, I>();
+	}: _(SystemOrigin::Signed(caller), collection, data.clone())
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMetadataSet { collection, data }.into());
+	}
+
+	clear_collection_metadata {
+		let (collection, caller, _) = create_collection::<T, I>();
+		add_collection_metadata::<T, I>();
+	}: _(SystemOrigin::Signed(caller), collection)
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMetadataCleared { collection }.into());
+	}
+
+	approve_transfer {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let deadline = BlockNumberFor::<T>::max_value();
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, delegate_lookup, Some(deadline))
+	verify {
+		assert_last_event::<T, I>(Event::TransferApproved { collection, item, owner: caller, delegate, deadline: Some(deadline) }.into());
+	}
+
+	cancel_approval {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		let deadline = BlockNumberFor::<T>::max_value();
+		Nfts::<T, I>::approve_transfer(origin, collection, item, delegate_lookup.clone(), Some(deadline))?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, delegate_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::ApprovalCancelled { collection, item, owner: caller, delegate }.into());
+	}
+
+	clear_all_transfer_approvals {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		let deadline = BlockNumberFor::<T>::max_value();
+		Nfts::<T, I>::approve_transfer(origin, collection, item, delegate_lookup.clone(), Some(deadline))?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item)
+	verify {
+		assert_last_event::<T, I>(Event::AllApprovalsCancelled {collection, item, owner: caller}.into());
+	}
+
+	set_accept_ownership {
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+		let collection = T::Helper::collection(0);
+	}: _(SystemOrigin::Signed(caller.clone()), Some(collection))
+	verify {
+		assert_last_event::<T, I>(Event::OwnershipAcceptanceChanged {
+			who: caller,
+			maybe_collection: Some(collection),
+		}.into());
+	}
+
+	set_collection_max_supply {
+		let (collection, caller, _) = create_collection::<T, I>();
+	}: _(SystemOrigin::Signed(caller.clone()), collection, u32::MAX)
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMaxSupplySet {
+			collection,
+			max_supply: u32::MAX,
+		}.into());
+	}
+
+	update_mint_settings {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let mint_settings = MintSettings {
+			mint_type: MintType::HolderOf(T::Helper::collection(0)),
+			start_block: Some(One::one()),
+			end_block: Some(One::one()),
+			price: Some(ItemPrice::<T, I>::from(1u32)),
+			default_item_settings: ItemSettings::all_enabled(),
+		};
+	}: _(SystemOrigin::Signed(caller.clone()), collection, mint_settings)
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMintSettingsUpdated { collection }.into());
+	}
+
+	set_price {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let price = ItemPrice::<T, I>::from(100u32);
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item, Some(price), Some(delegate_lookup))
+	verify {
+		assert_last_event::<T, I>(Event::ItemPriceSet {
+			collection,
+			item,
+			price,
+			whitelisted_buyer: Some(delegate),
+		}.into());
+	}
+
+	buy_item {
+		let (collection, seller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let buyer: T::AccountId = account("buyer", 0, SEED);
+		let buyer_lookup = T::Lookup::unlookup(buyer.clone());
+		let price = ItemPrice::<T, I>::from(0u32);
+		let origin = SystemOrigin::Signed(seller.clone()).into();
+		Nfts::<T, I>::set_price(origin, collection, item, Some(price), Some(buyer_lookup))?;
+		T::Currency::make_free_balance_be(&buyer, DepositBalanceOf::<T, I>::max_value());
+	}: _(SystemOrigin::Signed(buyer.clone()), collection, item, price)
+	verify {
+		assert_last_event::<T, I>(Event::ItemBought {
+			collection,
+			item,
+			price,
+			seller,
+			buyer,
+		}.into());
+	}
+
+	pay_tips {
+		let n in 0 .. T::MaxTips::get() as u32;
+		let amount = BalanceOf::<T, I>::from(100u32);
+		let caller: T::AccountId = whitelisted_caller();
+		let collection = T::Helper::collection(0);
+		let item = T::Helper::item(0);
+		let tips: BoundedVec<_, _> = vec![
+			ItemTip
+				{ collection, item, receiver: caller.clone(), amount }; n as usize
+		].try_into().unwrap();
+	}: _(SystemOrigin::Signed(caller.clone()), tips)
+	verify {
+		if !n.is_zero() {
+			assert_last_event::<T, I>(Event::TipSent {
+				collection,
+				item,
+				sender: caller.clone(),
+				receiver: caller.clone(),
+				amount,
+			}.into());
+		}
+	}
+
+	create_swap {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item1, ..) = mint_item::<T, I>(0);
+		let (item2, ..) = mint_item::<T, I>(1);
+		let price = ItemPrice::<T, I>::from(100u32);
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		let duration = T::MaxDeadlineDuration::get();
+		frame_system::Pallet::<T>::set_block_number(One::one());
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item1, collection, Some(item2), Some(price_with_direction.clone()), duration)
+	verify {
+		let current_block = frame_system::Pallet::<T>::block_number();
+		assert_last_event::<T, I>(Event::SwapCreated {
+			offered_collection: collection,
+			offered_item: item1,
+			desired_collection: collection,
+			desired_item: Some(item2),
+			price: Some(price_with_direction),
+			deadline: current_block.saturating_add(duration),
+		}.into());
+	}
+
+	cancel_swap {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item1, ..) = mint_item::<T, I>(0);
+		let (item2, ..) = mint_item::<T, I>(1);
+		let price = ItemPrice::<T, I>::from(100u32);
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		let duration = T::MaxDeadlineDuration::get();
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		frame_system::Pallet::<T>::set_block_number(One::one());
+		Nfts::<T, I>::create_swap(origin, collection, item1, collection, Some(item2), Some(price_with_direction.clone()), duration)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection, item1)
+	verify {
+		assert_last_event::<T, I>(Event::SwapCancelled {
+			offered_collection: collection,
+			offered_item: item1,
+			desired_collection: collection,
+			desired_item: Some(item2),
+			price: Some(price_with_direction),
+			deadline: duration.saturating_add(One::one()),
+		}.into());
+	}
+
+	claim_swap {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item1, ..) = mint_item::<T, I>(0);
+		let (item2, ..) = mint_item::<T, I>(1);
+		let price = ItemPrice::<T, I>::from(0u32);
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		let duration = T::MaxDeadlineDuration::get();
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
+		let origin = SystemOrigin::Signed(caller.clone());
+		frame_system::Pallet::<T>::set_block_number(One::one());
+		Nfts::<T, I>::transfer(origin.clone().into(), collection, item2, target_lookup)?;
+		Nfts::<T, I>::create_swap(
+			origin.clone().into(),
+			collection,
+			item1,
+			collection,
+			Some(item2),
+			Some(price_with_direction.clone()),
+			duration,
+		)?;
+	}: _(SystemOrigin::Signed(target.clone()), collection, item2, collection, item1, Some(price_with_direction.clone()))
+	verify {
+		let current_block = frame_system::Pallet::<T>::block_number();
+		assert_last_event::<T, I>(Event::SwapClaimed {
+			sent_collection: collection,
+			sent_item: item2,
+			sent_item_owner: target,
+			received_collection: collection,
+			received_item: item1,
+			received_item_owner: caller,
+			price: Some(price_with_direction),
+			deadline: duration.saturating_add(One::one()),
+		}.into());
+	}
+
+	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();
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+
+		let collection = T::Helper::collection(0);
+		let item = T::Helper::item(0);
+		assert_ok!(Nfts::<T, I>::force_create(
+			SystemOrigin::Root.into(),
+			caller_lookup.clone(),
+			default_collection_config::<T, I>()
+		));
+
+		let metadata = vec![0u8; T::StringLimit::get() as usize];
+		let mut attributes = vec![];
+		let attribute_value = vec![0u8; T::ValueLimit::get() as usize];
+		for i in 0..n {
+			let attribute_key = make_filled_vec(i as u16, T::KeyLimit::get() as usize);
+			attributes.push((attribute_key, attribute_value.clone()));
+		}
+		let mint_data = PreSignedMint {
+			collection,
+			item,
+			attributes,
+			metadata: metadata.clone(),
+			only_account: None,
+			deadline: One::one(),
+			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 target: T::AccountId = account("target", 0, SEED);
+		T::Currency::make_free_balance_be(&target, DepositBalanceOf::<T, I>::max_value());
+		frame_system::Pallet::<T>::set_block_number(One::one());
+	}: _(SystemOrigin::Signed(target.clone()), Box::new(mint_data), signature.into(), caller)
+	verify {
+		let metadata: BoundedVec<_, _> = metadata.try_into().unwrap();
+		assert_last_event::<T, I>(Event::ItemMetadataSet { collection, item, data: metadata }.into());
+	}
+
+	set_attributes_pre_signed {
+		let n in 0 .. T::MaxAttributesPerCall::get() as u32;
+		let (collection, _, _) = create_collection::<T, I>();
+
+		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();
+
+		T::Currency::make_free_balance_be(&item_owner, DepositBalanceOf::<T, I>::max_value());
+
+		let item = T::Helper::item(0);
+		assert_ok!(Nfts::<T, I>::force_mint(
+			SystemOrigin::Root.into(),
+			collection,
+			item,
+			item_owner_lookup.clone(),
+			default_item_config(),
+		));
+
+		let mut attributes = vec![];
+		let attribute_value = vec![0u8; T::ValueLimit::get() as usize];
+		for i in 0..n {
+			let attribute_key = make_filled_vec(i as u16, T::KeyLimit::get() as usize);
+			attributes.push((attribute_key, attribute_value.clone()));
+		}
+		let pre_signed_data = PreSignedAttributes {
+			collection,
+			item,
+			attributes,
+			namespace: AttributeNamespace::Account(signer.clone()),
+			deadline: One::one(),
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(sr25519_sign(0.into(), &signer_public, &message).unwrap());
+
+		frame_system::Pallet::<T>::set_block_number(One::one());
+	}: _(SystemOrigin::Signed(item_owner.clone()), pre_signed_data, signature.into(), signer.clone())
+	verify {
+		assert_last_event::<T, I>(
+			Event::PreSignedAttributesSet {
+				collection,
+				item,
+				namespace: AttributeNamespace::Account(signer.clone()),
+			}
+			.into(),
+		);
+	}
+
+	impl_benchmark_test_suite!(Nfts, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/nfts/src/common_functions.rs b/substrate/frame/nfts/src/common_functions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ad523d664c7cf884d1a3da7368db776c311958a
--- /dev/null
+++ b/substrate/frame/nfts/src/common_functions.rs
@@ -0,0 +1,80 @@
+// 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.
+
+//! Various pieces of common functionality.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Get the owner of the item, if the item exists.
+	pub fn owner(collection: T::CollectionId, item: T::ItemId) -> Option<T::AccountId> {
+		Item::<T, I>::get(collection, item).map(|i| i.owner)
+	}
+
+	/// Get the owner of the collection, if the collection exists.
+	pub fn collection_owner(collection: T::CollectionId) -> Option<T::AccountId> {
+		Collection::<T, I>::get(collection).map(|i| i.owner)
+	}
+
+	/// Validates the signature of the given data with the provided signer's account ID.
+	///
+	/// # Errors
+	///
+	/// This function returns a [`WrongSignature`](crate::Error::WrongSignature) error if the
+	/// signature is invalid or the verification process fails.
+	pub fn validate_signature(
+		data: &Vec<u8>,
+		signature: &T::OffchainSignature,
+		signer: &T::AccountId,
+	) -> DispatchResult {
+		if signature.verify(&**data, &signer) {
+			return Ok(())
+		}
+
+		// NOTE: for security reasons modern UIs implicitly wrap the data requested to sign into
+		// <Bytes></Bytes>, that's why we support both wrapped and raw versions.
+		let prefix = b"<Bytes>";
+		let suffix = b"</Bytes>";
+		let mut wrapped: Vec<u8> = Vec::with_capacity(data.len() + prefix.len() + suffix.len());
+		wrapped.extend(prefix);
+		wrapped.extend(data);
+		wrapped.extend(suffix);
+
+		ensure!(signature.verify(&*wrapped, &signer), Error::<T, I>::WrongSignature);
+
+		Ok(())
+	}
+
+	pub(crate) fn set_next_collection_id(collection: T::CollectionId) {
+		let next_id = collection.increment();
+		NextCollectionId::<T, I>::set(next_id);
+		Self::deposit_event(Event::NextCollectionIdIncremented { next_id });
+	}
+
+	#[cfg(any(test, feature = "runtime-benchmarks"))]
+	pub fn set_next_id(id: T::CollectionId) {
+		NextCollectionId::<T, I>::set(Some(id));
+	}
+
+	#[cfg(test)]
+	pub fn get_next_id() -> T::CollectionId {
+		NextCollectionId::<T, I>::get()
+			.or(T::CollectionId::initial_value())
+			.expect("Failed to get next collection ID")
+	}
+}
diff --git a/substrate/frame/nfts/src/features/approvals.rs b/substrate/frame/nfts/src/features/approvals.rs
new file mode 100644
index 0000000000000000000000000000000000000000..053fa67163b99119ebfd08b9feb6a5e88808eb7e
--- /dev/null
+++ b/substrate/frame/nfts/src/features/approvals.rs
@@ -0,0 +1,175 @@
+// 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 module contains helper functions for the approval logic implemented in the NFTs pallet.
+//! The bitflag [`PalletFeature::Approvals`] needs to be set in [`Config::Features`] for NFTs
+//! to have the functionality defined in this module.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Approves the transfer of an item to a delegate.
+	///
+	/// This function is used to approve the transfer of the specified `item` in the `collection` to
+	/// a `delegate`. If `maybe_check_origin` is specified, the function ensures that the
+	/// `check_origin` account is the owner of the item, granting them permission to approve the
+	/// transfer. The `delegate` is the account that will be allowed to take control of the item.
+	/// Optionally, a `deadline` can be specified to set a time limit for the approval. The
+	/// `deadline` is expressed in block numbers and is added to the current block number to
+	/// determine the absolute deadline for the approval. After approving the transfer, the function
+	/// emits the `TransferApproved` event.
+	///
+	/// - `maybe_check_origin`: The optional account that is required to be the owner of the item,
+	///   granting permission to approve the transfer. If `None`, no permission check is performed.
+	/// - `collection`: The identifier of the collection containing the item to be transferred.
+	/// - `item`: The identifier of the item to be transferred.
+	/// - `delegate`: The account that will be allowed to take control of the item.
+	/// - `maybe_deadline`: The optional deadline (in block numbers) specifying the time limit for
+	///   the approval.
+	pub(crate) fn do_approve_transfer(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		delegate: T::AccountId,
+		maybe_deadline: Option<frame_system::pallet_prelude::BlockNumberFor<T>>,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Approvals),
+			Error::<T, I>::MethodDisabled
+		);
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+
+		let collection_config = Self::get_collection_config(&collection)?;
+		ensure!(
+			collection_config.is_setting_enabled(CollectionSetting::TransferableItems),
+			Error::<T, I>::ItemsNonTransferable
+		);
+
+		if let Some(check_origin) = maybe_check_origin {
+			ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
+		}
+
+		let now = frame_system::Pallet::<T>::block_number();
+		let deadline = maybe_deadline.map(|d| d.saturating_add(now));
+
+		details
+			.approvals
+			.try_insert(delegate.clone(), deadline)
+			.map_err(|_| Error::<T, I>::ReachedApprovalLimit)?;
+		Item::<T, I>::insert(&collection, &item, &details);
+
+		Self::deposit_event(Event::TransferApproved {
+			collection,
+			item,
+			owner: details.owner,
+			delegate,
+			deadline,
+		});
+
+		Ok(())
+	}
+
+	/// Cancels the approval for the transfer of an item to a delegate.
+	///
+	/// This function is used to cancel the approval for the transfer of the specified `item` in the
+	/// `collection` to a `delegate`. If `maybe_check_origin` is specified, the function ensures
+	/// that the `check_origin` account is the owner of the item or that the approval is past its
+	/// deadline, granting permission to cancel the approval. After canceling the approval, the
+	/// function emits the `ApprovalCancelled` event.
+	///
+	/// - `maybe_check_origin`: The optional account that is required to be the owner of the item or
+	///   that the approval is past its deadline, granting permission to cancel the approval. If
+	///   `None`, no permission check is performed.
+	/// - `collection`: The identifier of the collection containing the item.
+	/// - `item`: The identifier of the item.
+	/// - `delegate`: The account that was previously allowed to take control of the item.
+	pub(crate) fn do_cancel_approval(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		delegate: T::AccountId,
+	) -> DispatchResult {
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+
+		let maybe_deadline = details.approvals.get(&delegate).ok_or(Error::<T, I>::NotDelegate)?;
+
+		let is_past_deadline = if let Some(deadline) = maybe_deadline {
+			let now = frame_system::Pallet::<T>::block_number();
+			now > *deadline
+		} else {
+			false
+		};
+
+		if !is_past_deadline {
+			if let Some(check_origin) = maybe_check_origin {
+				ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
+			}
+		}
+
+		details.approvals.remove(&delegate);
+		Item::<T, I>::insert(&collection, &item, &details);
+
+		Self::deposit_event(Event::ApprovalCancelled {
+			collection,
+			item,
+			owner: details.owner,
+			delegate,
+		});
+
+		Ok(())
+	}
+
+	/// Clears all transfer approvals for an item.
+	///
+	/// This function is used to clear all transfer approvals for the specified `item` in the
+	/// `collection`. If `maybe_check_origin` is specified, the function ensures that the
+	/// `check_origin` account is the owner of the item, granting permission to clear all transfer
+	/// approvals. After clearing all approvals, the function emits the `AllApprovalsCancelled`
+	/// event.
+	///
+	/// - `maybe_check_origin`: The optional account that is required to be the owner of the item,
+	///   granting permission to clear all transfer approvals. If `None`, no permission check is
+	///   performed.
+	/// - `collection`: The collection ID containing the item.
+	/// - `item`: The item ID for which transfer approvals will be cleared.
+	pub(crate) fn do_clear_all_transfer_approvals(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+	) -> DispatchResult {
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		if let Some(check_origin) = maybe_check_origin {
+			ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
+		}
+
+		details.approvals.clear();
+		Item::<T, I>::insert(&collection, &item, &details);
+
+		Self::deposit_event(Event::AllApprovalsCancelled {
+			collection,
+			item,
+			owner: details.owner,
+		});
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/nfts/src/features/atomic_swap.rs b/substrate/frame/nfts/src/features/atomic_swap.rs
new file mode 100644
index 0000000000000000000000000000000000000000..830283b73c2aa64dc5b619eb324e0a0ab7b7d3e8
--- /dev/null
+++ b/substrate/frame/nfts/src/features/atomic_swap.rs
@@ -0,0 +1,234 @@
+// 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 module contains helper functions for performing atomic swaps implemented in the NFTs
+//! pallet.
+//! The bitflag [`PalletFeature::Swaps`] needs to be set in [`Config::Features`] for NFTs
+//! to have the functionality defined in this module.
+
+use crate::*;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{Currency, ExistenceRequirement::KeepAlive},
+};
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Creates a new swap offer for the specified item.
+	///
+	/// This function is used to create a new swap offer for the specified item. The `caller`
+	/// account must be the owner of the item. The swap offer specifies the `offered_collection`,
+	/// `offered_item`, `desired_collection`, `maybe_desired_item`, `maybe_price`, and `duration`.
+	/// The `duration` specifies the deadline by which the swap must be claimed. If
+	/// `maybe_desired_item` is `Some`, the specified item is expected in return for the swap. If
+	/// `maybe_desired_item` is `None`, it indicates that any item from the `desired_collection` can
+	/// be offered in return. The `maybe_price` specifies an optional price for the swap. If
+	/// specified, the other party must offer the specified `price` or higher for the swap. After
+	/// creating the swap, the function emits the `SwapCreated` event.
+	///
+	/// - `caller`: The account creating the swap offer, which must be the owner of the item.
+	/// - `offered_collection_id`: The collection ID containing the offered item.
+	/// - `offered_item_id`: The item ID offered for the swap.
+	/// - `desired_collection_id`: The collection ID containing the desired item (if any).
+	/// - `maybe_desired_item_id`: The ID of the desired item (if any).
+	/// - `maybe_price`: The optional price for the swap.
+	/// - `duration`: The duration (in block numbers) specifying the deadline for the swap claim.
+	pub(crate) fn do_create_swap(
+		caller: T::AccountId,
+		offered_collection_id: T::CollectionId,
+		offered_item_id: T::ItemId,
+		desired_collection_id: T::CollectionId,
+		maybe_desired_item_id: Option<T::ItemId>,
+		maybe_price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+		duration: frame_system::pallet_prelude::BlockNumberFor<T>,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Swaps),
+			Error::<T, I>::MethodDisabled
+		);
+		ensure!(duration <= T::MaxDeadlineDuration::get(), Error::<T, I>::WrongDuration);
+
+		let item = Item::<T, I>::get(&offered_collection_id, &offered_item_id)
+			.ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(item.owner == caller, Error::<T, I>::NoPermission);
+
+		match maybe_desired_item_id {
+			Some(desired_item_id) => ensure!(
+				Item::<T, I>::contains_key(&desired_collection_id, &desired_item_id),
+				Error::<T, I>::UnknownItem
+			),
+			None => ensure!(
+				Collection::<T, I>::contains_key(&desired_collection_id),
+				Error::<T, I>::UnknownCollection
+			),
+		};
+
+		let now = frame_system::Pallet::<T>::block_number();
+		let deadline = duration.saturating_add(now);
+
+		PendingSwapOf::<T, I>::insert(
+			&offered_collection_id,
+			&offered_item_id,
+			PendingSwap {
+				desired_collection: desired_collection_id,
+				desired_item: maybe_desired_item_id,
+				price: maybe_price.clone(),
+				deadline,
+			},
+		);
+
+		Self::deposit_event(Event::SwapCreated {
+			offered_collection: offered_collection_id,
+			offered_item: offered_item_id,
+			desired_collection: desired_collection_id,
+			desired_item: maybe_desired_item_id,
+			price: maybe_price,
+			deadline,
+		});
+
+		Ok(())
+	}
+	/// Cancels the specified swap offer.
+	///
+	/// This function is used to cancel the specified swap offer created by the `caller` account. If
+	/// the swap offer's deadline has not yet passed, the `caller` must be the owner of the offered
+	/// item; otherwise, anyone can cancel an expired offer.
+	/// After canceling the swap offer, the function emits the `SwapCancelled` event.
+	///
+	/// - `caller`: The account canceling the swap offer.
+	/// - `offered_collection_id`: The collection ID containing the offered item.
+	/// - `offered_item_id`: The item ID offered for the swap.
+	pub(crate) fn do_cancel_swap(
+		caller: T::AccountId,
+		offered_collection_id: T::CollectionId,
+		offered_item_id: T::ItemId,
+	) -> DispatchResult {
+		let swap = PendingSwapOf::<T, I>::get(&offered_collection_id, &offered_item_id)
+			.ok_or(Error::<T, I>::UnknownSwap)?;
+
+		let now = frame_system::Pallet::<T>::block_number();
+		if swap.deadline > now {
+			let item = Item::<T, I>::get(&offered_collection_id, &offered_item_id)
+				.ok_or(Error::<T, I>::UnknownItem)?;
+			ensure!(item.owner == caller, Error::<T, I>::NoPermission);
+		}
+
+		PendingSwapOf::<T, I>::remove(&offered_collection_id, &offered_item_id);
+
+		Self::deposit_event(Event::SwapCancelled {
+			offered_collection: offered_collection_id,
+			offered_item: offered_item_id,
+			desired_collection: swap.desired_collection,
+			desired_item: swap.desired_item,
+			price: swap.price,
+			deadline: swap.deadline,
+		});
+
+		Ok(())
+	}
+
+	/// Claims the specified swap offer.
+	///
+	/// This function is used to claim a swap offer specified by the `send_collection_id`,
+	/// `send_item_id`, `receive_collection_id`, and `receive_item_id`. The `caller` account must be
+	/// the owner of the item specified by `send_collection_id` and `send_item_id`. If the claimed
+	/// swap has an associated `price`, it will be transferred between the owners of the two items
+	/// based on the `price.direction`. After the swap is completed, the function emits the
+	/// `SwapClaimed` event.
+	///
+	/// - `caller`: The account claiming the swap offer, which must be the owner of the sent item.
+	/// - `send_collection_id`: The identifier of the collection containing the item being sent.
+	/// - `send_item_id`: The identifier of the item being sent for the swap.
+	/// - `receive_collection_id`: The identifier of the collection containing the item being
+	///   received.
+	/// - `receive_item_id`: The identifier of the item being received in the swap.
+	/// - `witness_price`: The optional witness price for the swap (price that was offered in the
+	///   swap).
+	pub(crate) fn do_claim_swap(
+		caller: T::AccountId,
+		send_collection_id: T::CollectionId,
+		send_item_id: T::ItemId,
+		receive_collection_id: T::CollectionId,
+		receive_item_id: T::ItemId,
+		witness_price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Swaps),
+			Error::<T, I>::MethodDisabled
+		);
+
+		let send_item = Item::<T, I>::get(&send_collection_id, &send_item_id)
+			.ok_or(Error::<T, I>::UnknownItem)?;
+		let receive_item = Item::<T, I>::get(&receive_collection_id, &receive_item_id)
+			.ok_or(Error::<T, I>::UnknownItem)?;
+		let swap = PendingSwapOf::<T, I>::get(&receive_collection_id, &receive_item_id)
+			.ok_or(Error::<T, I>::UnknownSwap)?;
+
+		ensure!(send_item.owner == caller, Error::<T, I>::NoPermission);
+		ensure!(
+			swap.desired_collection == send_collection_id && swap.price == witness_price,
+			Error::<T, I>::UnknownSwap
+		);
+
+		if let Some(desired_item) = swap.desired_item {
+			ensure!(desired_item == send_item_id, Error::<T, I>::UnknownSwap);
+		}
+
+		let now = frame_system::Pallet::<T>::block_number();
+		ensure!(now <= swap.deadline, Error::<T, I>::DeadlineExpired);
+
+		if let Some(ref price) = swap.price {
+			match price.direction {
+				PriceDirection::Send => T::Currency::transfer(
+					&receive_item.owner,
+					&send_item.owner,
+					price.amount,
+					KeepAlive,
+				)?,
+				PriceDirection::Receive => T::Currency::transfer(
+					&send_item.owner,
+					&receive_item.owner,
+					price.amount,
+					KeepAlive,
+				)?,
+			};
+		}
+
+		// This also removes the swap.
+		Self::do_transfer(send_collection_id, send_item_id, receive_item.owner.clone(), |_, _| {
+			Ok(())
+		})?;
+		Self::do_transfer(
+			receive_collection_id,
+			receive_item_id,
+			send_item.owner.clone(),
+			|_, _| Ok(()),
+		)?;
+
+		Self::deposit_event(Event::SwapClaimed {
+			sent_collection: send_collection_id,
+			sent_item: send_item_id,
+			sent_item_owner: send_item.owner,
+			received_collection: receive_collection_id,
+			received_item: receive_item_id,
+			received_item_owner: receive_item.owner,
+			price: swap.price,
+			deadline: swap.deadline,
+		});
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/nfts/src/features/attributes.rs b/substrate/frame/nfts/src/features/attributes.rs
new file mode 100644
index 0000000000000000000000000000000000000000..28f7bd2c58ce78663fa22cb28e8cf7e95c61f705
--- /dev/null
+++ b/substrate/frame/nfts/src/features/attributes.rs
@@ -0,0 +1,525 @@
+// 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 module contains helper methods to configure attributes for items and collections in the
+//! NFTs pallet.
+//! The bitflag [`PalletFeature::Attributes`] needs to be set in [`Config::Features`] for NFTs
+//! to have the functionality defined in this module.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Sets the attribute of an item or a collection.
+	///
+	/// This function is used to set an attribute for an item or a collection. It checks the
+	/// provided `namespace` and verifies the permission of the caller to perform the action. The
+	/// `collection` and `maybe_item` parameters specify the target for the attribute.
+	///
+	/// - `origin`: The account attempting to set the attribute.
+	/// - `collection`: The identifier of the collection to which the item belongs, or the
+	///   collection itself if setting a collection attribute.
+	/// - `maybe_item`: The identifier of the item to which the attribute belongs, or `None` if
+	///   setting a collection attribute.
+	/// - `namespace`: The namespace in which the attribute is being set. It can be either
+	///   `CollectionOwner`, `ItemOwner`, or `Account` (pre-approved external address).
+	/// - `key`: The key of the attribute. It should be a vector of bytes within the limits defined
+	///   by `T::KeyLimit`.
+	/// - `value`: The value of the attribute. It should be a vector of bytes within the limits
+	///   defined by `T::ValueLimit`.
+	/// - `depositor`: The account that is paying the deposit for the attribute.
+	///
+	/// Note: For the `CollectionOwner` namespace, the collection/item must have the
+	/// `UnlockedAttributes` setting enabled.
+	/// The deposit for setting an attribute is based on the `T::DepositPerByte` and
+	/// `T::AttributeDepositBase` configuration.
+	pub(crate) fn do_set_attribute(
+		origin: T::AccountId,
+		collection: T::CollectionId,
+		maybe_item: Option<T::ItemId>,
+		namespace: AttributeNamespace<T::AccountId>,
+		key: BoundedVec<u8, T::KeyLimit>,
+		value: BoundedVec<u8, T::ValueLimit>,
+		depositor: T::AccountId,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Attributes),
+			Error::<T, I>::MethodDisabled
+		);
+
+		ensure!(
+			Self::is_valid_namespace(&origin, &namespace, &collection, &maybe_item)?,
+			Error::<T, I>::NoPermission
+		);
+
+		let collection_config = Self::get_collection_config(&collection)?;
+		// for the `CollectionOwner` namespace we need to check if the collection/item is not locked
+		match namespace {
+			AttributeNamespace::CollectionOwner => match maybe_item {
+				None => {
+					ensure!(
+						collection_config.is_setting_enabled(CollectionSetting::UnlockedAttributes),
+						Error::<T, I>::LockedCollectionAttributes
+					)
+				},
+				Some(item) => {
+					let maybe_is_locked = Self::get_item_config(&collection, &item)
+						.map(|c| c.has_disabled_setting(ItemSetting::UnlockedAttributes))?;
+					ensure!(!maybe_is_locked, Error::<T, I>::LockedItemAttributes);
+				},
+			},
+			_ => (),
+		}
+
+		let mut collection_details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		let attribute = Attribute::<T, I>::get((collection, maybe_item, &namespace, &key));
+		let attribute_exists = attribute.is_some();
+		if !attribute_exists {
+			collection_details.attributes.saturating_inc();
+		}
+
+		let old_deposit =
+			attribute.map_or(AttributeDeposit { account: None, amount: Zero::zero() }, |m| m.1);
+
+		let mut deposit = Zero::zero();
+		// disabled DepositRequired setting only affects the CollectionOwner namespace
+		if collection_config.is_setting_enabled(CollectionSetting::DepositRequired) ||
+			namespace != AttributeNamespace::CollectionOwner
+		{
+			deposit = T::DepositPerByte::get()
+				.saturating_mul(((key.len() + value.len()) as u32).into())
+				.saturating_add(T::AttributeDepositBase::get());
+		}
+
+		let is_collection_owner_namespace = namespace == AttributeNamespace::CollectionOwner;
+		let is_depositor_collection_owner =
+			is_collection_owner_namespace && collection_details.owner == depositor;
+
+		// NOTE: in the CollectionOwner namespace if the depositor is `None` that means the deposit
+		// was paid by the collection's owner.
+		let old_depositor =
+			if is_collection_owner_namespace && old_deposit.account.is_none() && attribute_exists {
+				Some(collection_details.owner.clone())
+			} else {
+				old_deposit.account
+			};
+		let depositor_has_changed = old_depositor != Some(depositor.clone());
+
+		// NOTE: when we transfer an item, we don't move attributes in the ItemOwner namespace.
+		// When the new owner updates the same attribute, we will update the depositor record
+		// and return the deposit to the previous owner.
+		if depositor_has_changed {
+			if let Some(old_depositor) = old_depositor {
+				T::Currency::unreserve(&old_depositor, old_deposit.amount);
+			}
+			T::Currency::reserve(&depositor, deposit)?;
+		} else if deposit > old_deposit.amount {
+			T::Currency::reserve(&depositor, deposit - old_deposit.amount)?;
+		} else if deposit < old_deposit.amount {
+			T::Currency::unreserve(&depositor, old_deposit.amount - deposit);
+		}
+
+		if is_depositor_collection_owner {
+			if !depositor_has_changed {
+				collection_details.owner_deposit.saturating_reduce(old_deposit.amount);
+			}
+			collection_details.owner_deposit.saturating_accrue(deposit);
+		}
+
+		let new_deposit_owner = match is_depositor_collection_owner {
+			true => None,
+			false => Some(depositor),
+		};
+		Attribute::<T, I>::insert(
+			(&collection, maybe_item, &namespace, &key),
+			(&value, AttributeDeposit { account: new_deposit_owner, amount: deposit }),
+		);
+
+		Collection::<T, I>::insert(collection, &collection_details);
+		Self::deposit_event(Event::AttributeSet { collection, maybe_item, key, value, namespace });
+		Ok(())
+	}
+
+	/// Sets the attribute of an item or a collection without performing deposit checks.
+	///
+	/// This function is used to force-set an attribute for an item or a collection without
+	/// performing the deposit checks. It bypasses the deposit requirement and should only be used
+	/// in specific situations where deposit checks are not necessary or handled separately.
+	///
+	/// - `set_as`: The account that would normally pay for the deposit.
+	/// - `collection`: The identifier of the collection to which the item belongs, or the
+	///   collection itself if setting a collection attribute.
+	/// - `maybe_item`: The identifier of the item to which the attribute belongs, or `None` if
+	///   setting a collection attribute.
+	/// - `namespace`: The namespace in which the attribute is being set. It can be either
+	///   `CollectionOwner`, `ItemOwner`, or `Account` (pre-approved external address).
+	/// - `key`: The key of the attribute. It should be a vector of bytes within the limits defined
+	///   by `T::KeyLimit`.
+	/// - `value`: The value of the attribute. It should be a vector of bytes within the limits
+	///   defined by `T::ValueLimit`.
+	pub(crate) fn do_force_set_attribute(
+		set_as: Option<T::AccountId>,
+		collection: T::CollectionId,
+		maybe_item: Option<T::ItemId>,
+		namespace: AttributeNamespace<T::AccountId>,
+		key: BoundedVec<u8, T::KeyLimit>,
+		value: BoundedVec<u8, T::ValueLimit>,
+	) -> DispatchResult {
+		let mut collection_details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		let attribute = Attribute::<T, I>::get((collection, maybe_item, &namespace, &key));
+		if let Some((_, deposit)) = attribute {
+			if deposit.account != set_as && deposit.amount != Zero::zero() {
+				if let Some(deposit_account) = deposit.account {
+					T::Currency::unreserve(&deposit_account, deposit.amount);
+				}
+			}
+		} else {
+			collection_details.attributes.saturating_inc();
+		}
+
+		Attribute::<T, I>::insert(
+			(&collection, maybe_item, &namespace, &key),
+			(&value, AttributeDeposit { account: set_as, amount: Zero::zero() }),
+		);
+		Collection::<T, I>::insert(collection, &collection_details);
+		Self::deposit_event(Event::AttributeSet { collection, maybe_item, key, value, namespace });
+		Ok(())
+	}
+
+	/// Sets multiple attributes for an item or a collection.
+	///
+	/// This function checks the pre-signed data is valid and updates the attributes of an item or
+	/// collection. It is limited by [`Config::MaxAttributesPerCall`] to prevent excessive storage
+	/// consumption in a single transaction.
+	///
+	/// - `origin`: The account initiating the transaction.
+	/// - `data`: The data containing the details of the pre-signed attributes to be set.
+	/// - `signer`: The account of the pre-signed attributes signer.
+	pub(crate) fn do_set_attributes_pre_signed(
+		origin: T::AccountId,
+		data: PreSignedAttributesOf<T, I>,
+		signer: T::AccountId,
+	) -> DispatchResult {
+		let PreSignedAttributes { collection, item, attributes, namespace, deadline } = data;
+
+		ensure!(
+			attributes.len() <= T::MaxAttributesPerCall::get() as usize,
+			Error::<T, I>::MaxAttributesLimitReached
+		);
+
+		let now = frame_system::Pallet::<T>::block_number();
+		ensure!(deadline >= now, Error::<T, I>::DeadlineExpired);
+
+		let item_details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(item_details.owner == origin, Error::<T, I>::NoPermission);
+
+		// Only the CollectionOwner and Account() namespaces could be updated in this way.
+		// For the Account() namespace we check and set the approval if it wasn't set before.
+		match &namespace {
+			AttributeNamespace::CollectionOwner => {},
+			AttributeNamespace::Account(account) => {
+				ensure!(account == &signer, Error::<T, I>::NoPermission);
+				let approvals = ItemAttributesApprovalsOf::<T, I>::get(&collection, &item);
+				if !approvals.contains(account) {
+					Self::do_approve_item_attributes(
+						origin.clone(),
+						collection,
+						item,
+						account.clone(),
+					)?;
+				}
+			},
+			_ => return Err(Error::<T, I>::WrongNamespace.into()),
+		}
+
+		for (key, value) in attributes {
+			Self::do_set_attribute(
+				signer.clone(),
+				collection,
+				Some(item),
+				namespace.clone(),
+				Self::construct_attribute_key(key)?,
+				Self::construct_attribute_value(value)?,
+				origin.clone(),
+			)?;
+		}
+		Self::deposit_event(Event::PreSignedAttributesSet { collection, item, namespace });
+		Ok(())
+	}
+
+	/// Clears an attribute of an item or a collection.
+	///
+	/// This function allows clearing an attribute from an item or a collection. It verifies the
+	/// permission of the caller to perform the action based on the provided `namespace` and
+	/// `depositor` account. The deposit associated with the attribute, if any, will be unreserved.
+	///
+	/// - `maybe_check_origin`: An optional account that acts as an additional security check when
+	/// clearing the attribute. This can be `None` if no additional check is required.
+	/// - `collection`: The identifier of the collection to which the item belongs, or the
+	///   collection itself if clearing a collection attribute.
+	/// - `maybe_item`: The identifier of the item to which the attribute belongs, or `None` if
+	///   clearing a collection attribute.
+	/// - `namespace`: The namespace in which the attribute is being cleared. It can be either
+	///   `CollectionOwner`, `ItemOwner`, or `Account`.
+	/// - `key`: The key of the attribute to be cleared. It should be a vector of bytes within the
+	///   limits defined by `T::KeyLimit`.
+	pub(crate) fn do_clear_attribute(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		maybe_item: Option<T::ItemId>,
+		namespace: AttributeNamespace<T::AccountId>,
+		key: BoundedVec<u8, T::KeyLimit>,
+	) -> DispatchResult {
+		let (_, deposit) = Attribute::<T, I>::take((collection, maybe_item, &namespace, &key))
+			.ok_or(Error::<T, I>::AttributeNotFound)?;
+
+		if let Some(check_origin) = &maybe_check_origin {
+			// validate the provided namespace when it's not a root call and the caller is not
+			// the same as the `deposit.account` (e.g. the deposit was paid by different account)
+			if deposit.account != maybe_check_origin {
+				ensure!(
+					Self::is_valid_namespace(&check_origin, &namespace, &collection, &maybe_item)?,
+					Error::<T, I>::NoPermission
+				);
+			}
+
+			// can't clear `CollectionOwner` type attributes if the collection/item is locked
+			match namespace {
+				AttributeNamespace::CollectionOwner => match maybe_item {
+					None => {
+						let collection_config = Self::get_collection_config(&collection)?;
+						ensure!(
+							collection_config
+								.is_setting_enabled(CollectionSetting::UnlockedAttributes),
+							Error::<T, I>::LockedCollectionAttributes
+						)
+					},
+					Some(item) => {
+						// NOTE: if the item was previously burned, the ItemConfigOf record
+						// might not exist. In that case, we allow to clear the attribute.
+						let maybe_is_locked = Self::get_item_config(&collection, &item)
+							.map_or(None, |c| {
+								Some(c.has_disabled_setting(ItemSetting::UnlockedAttributes))
+							});
+						if let Some(is_locked) = maybe_is_locked {
+							ensure!(!is_locked, Error::<T, I>::LockedItemAttributes);
+							// Only the collection's admin can clear attributes in that namespace.
+							// e.g. in off-chain mints, the attribute's depositor will be the item's
+							// owner, that's why we need to do this extra check.
+							ensure!(
+								Self::has_role(&collection, &check_origin, CollectionRole::Admin),
+								Error::<T, I>::NoPermission
+							);
+						}
+					},
+				},
+				_ => (),
+			};
+		}
+
+		let mut collection_details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		collection_details.attributes.saturating_dec();
+
+		match deposit.account {
+			Some(deposit_account) => {
+				T::Currency::unreserve(&deposit_account, deposit.amount);
+			},
+			None if namespace == AttributeNamespace::CollectionOwner => {
+				collection_details.owner_deposit.saturating_reduce(deposit.amount);
+				T::Currency::unreserve(&collection_details.owner, deposit.amount);
+			},
+			_ => (),
+		}
+
+		Collection::<T, I>::insert(collection, &collection_details);
+		Self::deposit_event(Event::AttributeCleared { collection, maybe_item, key, namespace });
+
+		Ok(())
+	}
+
+	/// Approves a delegate to set attributes on behalf of the item's owner.
+	///
+	/// This function allows the owner of an item to approve a delegate to set attributes in the
+	/// `Account(delegate)` namespace. The maximum number of approvals is determined by
+	/// the configuration `T::MaxAttributesApprovals`.
+	///
+	/// - `check_origin`: The account of the item's owner attempting to approve the delegate.
+	/// - `collection`: The identifier of the collection to which the item belongs.
+	/// - `item`: The identifier of the item for which the delegate is being approved.
+	/// - `delegate`: The account that is being approved to set attributes on behalf of the item's
+	///   owner.
+	pub(crate) fn do_approve_item_attributes(
+		check_origin: T::AccountId,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		delegate: T::AccountId,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Attributes),
+			Error::<T, I>::MethodDisabled
+		);
+
+		let details = Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
+
+		ItemAttributesApprovalsOf::<T, I>::try_mutate(collection, item, |approvals| {
+			approvals
+				.try_insert(delegate.clone())
+				.map_err(|_| Error::<T, I>::ReachedApprovalLimit)?;
+
+			Self::deposit_event(Event::ItemAttributesApprovalAdded { collection, item, delegate });
+			Ok(())
+		})
+	}
+
+	/// Cancels the approval of an item's attributes by a delegate.
+	///
+	/// This function allows the owner of an item to cancel the approval of a delegate to set
+	/// attributes in the `Account(delegate)` namespace. The delegate's approval is removed, in
+	/// addition to attributes the `delegate` previously created, and any unreserved deposit
+	/// is returned. The number of attributes that the delegate has set for the item must
+	/// not exceed the `account_attributes` provided in the `witness`.
+	/// This function is used to prevent unintended or malicious cancellations.
+	///
+	/// - `check_origin`: The account of the item's owner attempting to cancel the delegate's
+	///   approval.
+	/// - `collection`: The identifier of the collection to which the item belongs.
+	/// - `item`: The identifier of the item for which the delegate's approval is being canceled.
+	/// - `delegate`: The account whose approval is being canceled.
+	/// - `witness`: The witness containing the number of attributes set by the delegate for the
+	///   item.
+	pub(crate) fn do_cancel_item_attributes_approval(
+		check_origin: T::AccountId,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		delegate: T::AccountId,
+		witness: CancelAttributesApprovalWitness,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Attributes),
+			Error::<T, I>::MethodDisabled
+		);
+
+		let details = Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
+
+		ItemAttributesApprovalsOf::<T, I>::try_mutate(collection, item, |approvals| {
+			approvals.remove(&delegate);
+
+			let mut attributes: u32 = 0;
+			let mut deposited: DepositBalanceOf<T, I> = Zero::zero();
+			for (_, (_, deposit)) in Attribute::<T, I>::drain_prefix((
+				&collection,
+				Some(item),
+				AttributeNamespace::Account(delegate.clone()),
+			)) {
+				attributes.saturating_inc();
+				deposited = deposited.saturating_add(deposit.amount);
+			}
+			ensure!(attributes <= witness.account_attributes, Error::<T, I>::BadWitness);
+
+			if !deposited.is_zero() {
+				T::Currency::unreserve(&delegate, deposited);
+			}
+
+			Self::deposit_event(Event::ItemAttributesApprovalRemoved {
+				collection,
+				item,
+				delegate,
+			});
+			Ok(())
+		})
+	}
+
+	/// A helper method to check whether an attribute namespace is valid.
+	fn is_valid_namespace(
+		origin: &T::AccountId,
+		namespace: &AttributeNamespace<T::AccountId>,
+		collection: &T::CollectionId,
+		maybe_item: &Option<T::ItemId>,
+	) -> Result<bool, DispatchError> {
+		let mut result = false;
+		match namespace {
+			AttributeNamespace::CollectionOwner =>
+				result = Self::has_role(&collection, &origin, CollectionRole::Admin),
+			AttributeNamespace::ItemOwner =>
+				if let Some(item) = maybe_item {
+					let item_details =
+						Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+					result = origin == &item_details.owner
+				},
+			AttributeNamespace::Account(account_id) =>
+				if let Some(item) = maybe_item {
+					let approvals = ItemAttributesApprovalsOf::<T, I>::get(&collection, &item);
+					result = account_id == origin && approvals.contains(&origin)
+				},
+			_ => (),
+		};
+		Ok(result)
+	}
+
+	/// A helper method to construct an attribute's key.
+	///
+	/// # Errors
+	///
+	/// This function returns an [`IncorrectData`](crate::Error::IncorrectData) error if the
+	/// provided attribute `key` is too long.
+	pub fn construct_attribute_key(
+		key: Vec<u8>,
+	) -> Result<BoundedVec<u8, T::KeyLimit>, DispatchError> {
+		Ok(BoundedVec::try_from(key).map_err(|_| Error::<T, I>::IncorrectData)?)
+	}
+
+	/// A helper method to construct an attribute's value.
+	///
+	/// # Errors
+	///
+	/// This function returns an [`IncorrectData`](crate::Error::IncorrectData) error if the
+	/// provided `value` is too long.
+	pub fn construct_attribute_value(
+		value: Vec<u8>,
+	) -> Result<BoundedVec<u8, T::ValueLimit>, DispatchError> {
+		Ok(BoundedVec::try_from(value).map_err(|_| Error::<T, I>::IncorrectData)?)
+	}
+
+	/// A helper method to check whether a system attribute is set for a given item.
+	///
+	/// # Errors
+	///
+	/// This function returns an [`IncorrectData`](crate::Error::IncorrectData) error if the
+	/// provided pallet attribute is too long.
+	pub fn has_system_attribute(
+		collection: &T::CollectionId,
+		item: &T::ItemId,
+		attribute_key: PalletAttributes<T::CollectionId>,
+	) -> Result<bool, DispatchError> {
+		let attribute = (
+			&collection,
+			Some(item),
+			AttributeNamespace::Pallet,
+			&Self::construct_attribute_key(attribute_key.encode())?,
+		);
+		Ok(Attribute::<T, I>::contains_key(attribute))
+	}
+}
diff --git a/substrate/frame/nfts/src/features/buy_sell.rs b/substrate/frame/nfts/src/features/buy_sell.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d6ec6f50d2724d7ed43eb4d9e071a046427d349f
--- /dev/null
+++ b/substrate/frame/nfts/src/features/buy_sell.rs
@@ -0,0 +1,172 @@
+// 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 module contains helper functions to perform the buy and sell functionalities of the NFTs
+//! pallet.
+//! The bitflag [`PalletFeature::Trading`] needs to be set in the [`Config::Features`] for NFTs
+//! to have the functionality defined in this module.
+
+use crate::*;
+use frame_support::{
+	pallet_prelude::*,
+	traits::{Currency, ExistenceRequirement, ExistenceRequirement::KeepAlive},
+};
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Pays the specified tips to the corresponding receivers.
+	///
+	/// This function is used to pay tips from the `sender` account to multiple receivers. The tips
+	/// are specified as a `BoundedVec` of `ItemTipOf` with a maximum length of `T::MaxTips`. For
+	/// each tip, the function transfers the `amount` to the `receiver` account. The sender is
+	/// responsible for ensuring the validity of the provided tips.
+	///
+	/// - `sender`: The account that pays the tips.
+	/// - `tips`: A `BoundedVec` containing the tips to be paid, where each tip contains the
+	///   `collection`, `item`, `receiver`, and `amount`.
+	pub(crate) fn do_pay_tips(
+		sender: T::AccountId,
+		tips: BoundedVec<ItemTipOf<T, I>, T::MaxTips>,
+	) -> DispatchResult {
+		for tip in tips {
+			let ItemTip { collection, item, receiver, amount } = tip;
+			T::Currency::transfer(&sender, &receiver, amount, KeepAlive)?;
+			Self::deposit_event(Event::TipSent {
+				collection,
+				item,
+				sender: sender.clone(),
+				receiver,
+				amount,
+			});
+		}
+		Ok(())
+	}
+
+	/// Sets the price and whitelists a buyer for an item in the specified collection.
+	///
+	/// This function is used to set the price and whitelist a buyer for an item in the
+	/// specified `collection`. The `sender` account must be the owner of the item. The item's price
+	/// and the whitelisted buyer can be set to allow trading the item. If `price` is `None`, the
+	/// item will be marked as not for sale.
+	///
+	/// - `collection`: The identifier of the collection containing the item.
+	/// - `item`: The identifier of the item for which the price and whitelist information will be
+	///   set.
+	/// - `sender`: The account that sets the price and whitelist information for the item.
+	/// - `price`: The optional price for the item.
+	/// - `whitelisted_buyer`: The optional account that is whitelisted to buy the item at the set
+	///   price.
+	pub(crate) fn do_set_price(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		sender: T::AccountId,
+		price: Option<ItemPrice<T, I>>,
+		whitelisted_buyer: Option<T::AccountId>,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Trading),
+			Error::<T, I>::MethodDisabled
+		);
+
+		let details = Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(details.owner == sender, Error::<T, I>::NoPermission);
+
+		let collection_config = Self::get_collection_config(&collection)?;
+		ensure!(
+			collection_config.is_setting_enabled(CollectionSetting::TransferableItems),
+			Error::<T, I>::ItemsNonTransferable
+		);
+
+		let item_config = Self::get_item_config(&collection, &item)?;
+		ensure!(
+			item_config.is_setting_enabled(ItemSetting::Transferable),
+			Error::<T, I>::ItemLocked
+		);
+
+		if let Some(ref price) = price {
+			ItemPriceOf::<T, I>::insert(&collection, &item, (price, whitelisted_buyer.clone()));
+			Self::deposit_event(Event::ItemPriceSet {
+				collection,
+				item,
+				price: *price,
+				whitelisted_buyer,
+			});
+		} else {
+			ItemPriceOf::<T, I>::remove(&collection, &item);
+			Self::deposit_event(Event::ItemPriceRemoved { collection, item });
+		}
+
+		Ok(())
+	}
+
+	/// Buys the specified item from the collection.
+	///
+	/// This function is used to buy an item from the specified `collection`. The `buyer` account
+	/// will attempt to buy the item with the provided `bid_price`. The item's current owner will
+	/// receive the bid price if it is equal to or higher than the item's set price. If
+	/// `whitelisted_buyer` is specified in the item's price information, only that account is
+	/// allowed to buy the item. If the item is not for sale, or the bid price is too low, the
+	/// function will return an error.
+	///
+	/// - `collection`: The identifier of the collection containing the item to be bought.
+	/// - `item`: The identifier of the item to be bought.
+	/// - `buyer`: The account that attempts to buy the item.
+	/// - `bid_price`: The bid price offered by the buyer for the item.
+	pub(crate) fn do_buy_item(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		buyer: T::AccountId,
+		bid_price: ItemPrice<T, I>,
+	) -> DispatchResult {
+		ensure!(
+			Self::is_pallet_feature_enabled(PalletFeature::Trading),
+			Error::<T, I>::MethodDisabled
+		);
+
+		let details = Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(details.owner != buyer, Error::<T, I>::NoPermission);
+
+		let price_info =
+			ItemPriceOf::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::NotForSale)?;
+
+		ensure!(bid_price >= price_info.0, Error::<T, I>::BidTooLow);
+
+		if let Some(only_buyer) = price_info.1 {
+			ensure!(only_buyer == buyer, Error::<T, I>::NoPermission);
+		}
+
+		T::Currency::transfer(
+			&buyer,
+			&details.owner,
+			price_info.0,
+			ExistenceRequirement::KeepAlive,
+		)?;
+
+		let old_owner = details.owner.clone();
+
+		Self::do_transfer(collection, item, buyer.clone(), |_, _| Ok(()))?;
+
+		Self::deposit_event(Event::ItemBought {
+			collection,
+			item,
+			price: price_info.0,
+			seller: old_owner,
+			buyer,
+		});
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/nfts/src/features/create_delete_collection.rs b/substrate/frame/nfts/src/features/create_delete_collection.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e343ad18e504f68991bbbac2df1ffa077e836222
--- /dev/null
+++ b/substrate/frame/nfts/src/features/create_delete_collection.rs
@@ -0,0 +1,147 @@
+// 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 module contains helper methods to perform functionality associated with creating and
+//! destroying collections for the NFTs pallet.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Create a new collection with the given `collection`, `owner`, `admin`, `config`, `deposit`,
+	/// and `event`.
+	///
+	/// This function creates a new collection with the provided parameters. It reserves the
+	/// required deposit from the owner's account, sets the collection details, assigns admin roles,
+	/// and inserts the provided configuration. Finally, it emits the specified event upon success.
+	///
+	/// # Errors
+	///
+	/// This function returns a [`CollectionIdInUse`](crate::Error::CollectionIdInUse) error if the
+	/// collection ID is already in use.
+	pub fn do_create_collection(
+		collection: T::CollectionId,
+		owner: T::AccountId,
+		admin: T::AccountId,
+		config: CollectionConfigFor<T, I>,
+		deposit: DepositBalanceOf<T, I>,
+		event: Event<T, I>,
+	) -> DispatchResult {
+		ensure!(!Collection::<T, I>::contains_key(collection), Error::<T, I>::CollectionIdInUse);
+
+		T::Currency::reserve(&owner, deposit)?;
+
+		Collection::<T, I>::insert(
+			collection,
+			CollectionDetails {
+				owner: owner.clone(),
+				owner_deposit: deposit,
+				items: 0,
+				item_metadatas: 0,
+				item_configs: 0,
+				attributes: 0,
+			},
+		);
+		CollectionRoleOf::<T, I>::insert(
+			collection,
+			admin,
+			CollectionRoles(
+				CollectionRole::Admin | CollectionRole::Freezer | CollectionRole::Issuer,
+			),
+		);
+
+		CollectionConfigOf::<T, I>::insert(&collection, config);
+		CollectionAccount::<T, I>::insert(&owner, &collection, ());
+		Self::deposit_event(event);
+		Ok(())
+	}
+
+	/// Destroy the specified collection with the given `collection`, `witness`, and
+	/// `maybe_check_owner`.
+	///
+	/// This function destroys the specified collection if it exists and meets the necessary
+	/// conditions. It checks the provided `witness` against the actual collection details and
+	/// removes the collection along with its associated metadata, attributes, and configurations.
+	/// The necessary deposits are returned to the corresponding accounts, and the roles and
+	/// configurations for the collection are cleared. Finally, it emits the `Destroyed` event upon
+	/// successful destruction.
+	///
+	/// # Errors
+	///
+	/// This function returns a dispatch error in the following cases:
+	/// - If the collection ID is not found
+	///   ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - If the provided `maybe_check_owner` does not match the actual owner
+	///   ([`NoPermission`](crate::Error::NoPermission)).
+	/// - If the collection is not empty (contains items)
+	///   ([`CollectionNotEmpty`](crate::Error::CollectionNotEmpty)).
+	/// - If the `witness` does not match the actual collection details
+	///   ([`BadWitness`](crate::Error::BadWitness)).
+	pub fn do_destroy_collection(
+		collection: T::CollectionId,
+		witness: DestroyWitness,
+		maybe_check_owner: Option<T::AccountId>,
+	) -> Result<DestroyWitness, DispatchError> {
+		Collection::<T, I>::try_mutate_exists(collection, |maybe_details| {
+			let collection_details =
+				maybe_details.take().ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = maybe_check_owner {
+				ensure!(collection_details.owner == check_owner, Error::<T, I>::NoPermission);
+			}
+			ensure!(collection_details.items == 0, Error::<T, I>::CollectionNotEmpty);
+			ensure!(collection_details.attributes == witness.attributes, Error::<T, I>::BadWitness);
+			ensure!(
+				collection_details.item_metadatas == witness.item_metadatas,
+				Error::<T, I>::BadWitness
+			);
+			ensure!(
+				collection_details.item_configs == witness.item_configs,
+				Error::<T, I>::BadWitness
+			);
+
+			for (_, metadata) in ItemMetadataOf::<T, I>::drain_prefix(&collection) {
+				if let Some(depositor) = metadata.deposit.account {
+					T::Currency::unreserve(&depositor, metadata.deposit.amount);
+				}
+			}
+
+			CollectionMetadataOf::<T, I>::remove(&collection);
+			Self::clear_roles(&collection)?;
+
+			for (_, (_, deposit)) in Attribute::<T, I>::drain_prefix((&collection,)) {
+				if !deposit.amount.is_zero() {
+					if let Some(account) = deposit.account {
+						T::Currency::unreserve(&account, deposit.amount);
+					}
+				}
+			}
+
+			CollectionAccount::<T, I>::remove(&collection_details.owner, &collection);
+			T::Currency::unreserve(&collection_details.owner, collection_details.owner_deposit);
+			CollectionConfigOf::<T, I>::remove(&collection);
+			let _ = ItemConfigOf::<T, I>::clear_prefix(&collection, witness.item_configs, None);
+
+			Self::deposit_event(Event::Destroyed { collection });
+
+			Ok(DestroyWitness {
+				item_metadatas: collection_details.item_metadatas,
+				item_configs: collection_details.item_configs,
+				attributes: collection_details.attributes,
+			})
+		})
+	}
+}
diff --git a/substrate/frame/nfts/src/features/create_delete_item.rs b/substrate/frame/nfts/src/features/create_delete_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..37f64ae1b1b99c69b110359e1b609ce1f8685aa3
--- /dev/null
+++ b/substrate/frame/nfts/src/features/create_delete_item.rs
@@ -0,0 +1,273 @@
+// 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 module contains helper methods to perform functionality associated with minting and burning
+//! items for the NFTs pallet.
+
+use crate::*;
+use frame_support::{pallet_prelude::*, traits::ExistenceRequirement};
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Mint a new unique item with the given `collection`, `item`, and other minting configuration
+	/// details.
+	///
+	/// This function performs the minting of a new unique item. It checks if the item does not
+	/// already exist in the given collection, and if the max supply limit (if configured) is not
+	/// reached. It also reserves the required deposit for the item and sets the item details
+	/// accordingly.
+	///
+	/// # Errors
+	///
+	/// This function returns a dispatch error in the following cases:
+	/// - If the collection ID is invalid ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - If the item already exists in the collection
+	///   ([`AlreadyExists`](crate::Error::AlreadyExists)).
+	/// - If the item configuration already exists
+	///   ([`InconsistentItemConfig`](crate::Error::InconsistentItemConfig)).
+	/// - If the max supply limit (if configured) for the collection is reached
+	///   ([`MaxSupplyReached`](crate::Error::MaxSupplyReached)).
+	/// - If any error occurs in the `with_details_and_config` closure.
+	pub fn do_mint(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		maybe_depositor: Option<T::AccountId>,
+		mint_to: T::AccountId,
+		item_config: ItemConfig,
+		with_details_and_config: impl FnOnce(
+			&CollectionDetailsFor<T, I>,
+			&CollectionConfigFor<T, I>,
+		) -> DispatchResult,
+	) -> DispatchResult {
+		ensure!(!Item::<T, I>::contains_key(collection, item), Error::<T, I>::AlreadyExists);
+
+		Collection::<T, I>::try_mutate(
+			&collection,
+			|maybe_collection_details| -> DispatchResult {
+				let collection_details =
+					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+
+				let collection_config = Self::get_collection_config(&collection)?;
+				with_details_and_config(collection_details, &collection_config)?;
+
+				if let Some(max_supply) = collection_config.max_supply {
+					ensure!(collection_details.items < max_supply, Error::<T, I>::MaxSupplyReached);
+				}
+
+				collection_details.items.saturating_inc();
+
+				let collection_config = Self::get_collection_config(&collection)?;
+				let deposit_amount = match collection_config
+					.is_setting_enabled(CollectionSetting::DepositRequired)
+				{
+					true => T::ItemDeposit::get(),
+					false => Zero::zero(),
+				};
+				let deposit_account = match maybe_depositor {
+					None => collection_details.owner.clone(),
+					Some(depositor) => depositor,
+				};
+
+				let item_owner = mint_to.clone();
+				Account::<T, I>::insert((&item_owner, &collection, &item), ());
+
+				if let Ok(existing_config) = ItemConfigOf::<T, I>::try_get(&collection, &item) {
+					ensure!(existing_config == item_config, Error::<T, I>::InconsistentItemConfig);
+				} else {
+					ItemConfigOf::<T, I>::insert(&collection, &item, item_config);
+					collection_details.item_configs.saturating_inc();
+				}
+
+				T::Currency::reserve(&deposit_account, deposit_amount)?;
+
+				let deposit = ItemDeposit { account: deposit_account, amount: deposit_amount };
+				let details = ItemDetails {
+					owner: item_owner,
+					approvals: ApprovalsOf::<T, I>::default(),
+					deposit,
+				};
+				Item::<T, I>::insert(&collection, &item, details);
+				Ok(())
+			},
+		)?;
+
+		Self::deposit_event(Event::Issued { collection, item, owner: mint_to });
+		Ok(())
+	}
+
+	/// Mints a new item using a pre-signed message.
+	///
+	/// This function allows minting a new item using a pre-signed message. The minting process is
+	/// similar to the regular minting process, but it is performed by a pre-authorized account. The
+	/// `mint_to` account receives the newly minted item. The minting process is configurable
+	/// through the provided `mint_data`. The attributes, metadata, and price of the item are set
+	/// according to the provided `mint_data`. The `with_details_and_config` closure is called to
+	/// validate the provided `collection_details` and `collection_config` before minting the item.
+	///
+	/// - `mint_to`: The account that receives the newly minted item.
+	/// - `mint_data`: The pre-signed minting data containing the `collection`, `item`,
+	///   `attributes`, `metadata`, `deadline`, `only_account`, and `mint_price`.
+	/// - `signer`: The account that is authorized to mint the item using the pre-signed message.
+	pub(crate) fn do_mint_pre_signed(
+		mint_to: T::AccountId,
+		mint_data: PreSignedMintOf<T, I>,
+		signer: T::AccountId,
+	) -> DispatchResult {
+		let PreSignedMint {
+			collection,
+			item,
+			attributes,
+			metadata,
+			deadline,
+			only_account,
+			mint_price,
+		} = mint_data;
+		let metadata = Self::construct_metadata(metadata)?;
+
+		ensure!(
+			attributes.len() <= T::MaxAttributesPerCall::get() as usize,
+			Error::<T, I>::MaxAttributesLimitReached
+		);
+		if let Some(account) = only_account {
+			ensure!(account == mint_to, Error::<T, I>::WrongOrigin);
+		}
+
+		let now = frame_system::Pallet::<T>::block_number();
+		ensure!(deadline >= now, Error::<T, I>::DeadlineExpired);
+
+		ensure!(
+			Self::has_role(&collection, &signer, CollectionRole::Issuer),
+			Error::<T, I>::NoPermission
+		);
+
+		let item_config = ItemConfig { settings: Self::get_default_item_settings(&collection)? };
+		Self::do_mint(
+			collection,
+			item,
+			Some(mint_to.clone()),
+			mint_to.clone(),
+			item_config,
+			|collection_details, _| {
+				if let Some(price) = mint_price {
+					T::Currency::transfer(
+						&mint_to,
+						&collection_details.owner,
+						price,
+						ExistenceRequirement::KeepAlive,
+					)?;
+				}
+				Ok(())
+			},
+		)?;
+		let admin_account = Self::find_account_by_role(&collection, CollectionRole::Admin);
+		if let Some(admin_account) = admin_account {
+			for (key, value) in attributes {
+				Self::do_set_attribute(
+					admin_account.clone(),
+					collection,
+					Some(item),
+					AttributeNamespace::CollectionOwner,
+					Self::construct_attribute_key(key)?,
+					Self::construct_attribute_value(value)?,
+					mint_to.clone(),
+				)?;
+			}
+			if !metadata.len().is_zero() {
+				Self::do_set_item_metadata(
+					Some(admin_account.clone()),
+					collection,
+					item,
+					metadata,
+					Some(mint_to.clone()),
+				)?;
+			}
+		}
+		Ok(())
+	}
+
+	/// Burns the specified item with the given `collection`, `item`, and `with_details`.
+	///
+	/// # Errors
+	///
+	/// This function returns a dispatch error in the following cases:
+	/// - If the collection ID is invalid ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - If the item is locked ([`ItemLocked`](crate::Error::ItemLocked)).
+	pub fn do_burn(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		with_details: impl FnOnce(&ItemDetailsFor<T, I>) -> DispatchResult,
+	) -> DispatchResult {
+		ensure!(!T::Locker::is_locked(collection, item), Error::<T, I>::ItemLocked);
+		ensure!(
+			!Self::has_system_attribute(&collection, &item, PalletAttributes::TransferDisabled)?,
+			Error::<T, I>::ItemLocked
+		);
+		let item_config = Self::get_item_config(&collection, &item)?;
+		// NOTE: if item's settings are not empty (e.g. item's metadata is locked)
+		// then we keep the config record and don't remove it
+		let remove_config = !item_config.has_disabled_settings();
+		let owner = Collection::<T, I>::try_mutate(
+			&collection,
+			|maybe_collection_details| -> Result<T::AccountId, DispatchError> {
+				let collection_details =
+					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+				let details = Item::<T, I>::get(&collection, &item)
+					.ok_or(Error::<T, I>::UnknownCollection)?;
+				with_details(&details)?;
+
+				// Return the deposit.
+				T::Currency::unreserve(&details.deposit.account, details.deposit.amount);
+				collection_details.items.saturating_dec();
+
+				if remove_config {
+					collection_details.item_configs.saturating_dec();
+				}
+
+				// Clear the metadata if it's not locked.
+				if item_config.is_setting_enabled(ItemSetting::UnlockedMetadata) {
+					if let Some(metadata) = ItemMetadataOf::<T, I>::take(&collection, &item) {
+						let depositor_account =
+							metadata.deposit.account.unwrap_or(collection_details.owner.clone());
+
+						T::Currency::unreserve(&depositor_account, metadata.deposit.amount);
+						collection_details.item_metadatas.saturating_dec();
+
+						if depositor_account == collection_details.owner {
+							collection_details
+								.owner_deposit
+								.saturating_reduce(metadata.deposit.amount);
+						}
+					}
+				}
+
+				Ok(details.owner)
+			},
+		)?;
+
+		Item::<T, I>::remove(&collection, &item);
+		Account::<T, I>::remove((&owner, &collection, &item));
+		ItemPriceOf::<T, I>::remove(&collection, &item);
+		PendingSwapOf::<T, I>::remove(&collection, &item);
+		ItemAttributesApprovalsOf::<T, I>::remove(&collection, &item);
+
+		if remove_config {
+			ItemConfigOf::<T, I>::remove(&collection, &item);
+		}
+
+		Self::deposit_event(Event::Burned { collection, item, owner });
+		Ok(())
+	}
+}
diff --git a/substrate/frame/nfts/src/features/lock.rs b/substrate/frame/nfts/src/features/lock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1c3c9c8672fbd11ab81b41a3c56f52309c4e3f67
--- /dev/null
+++ b/substrate/frame/nfts/src/features/lock.rs
@@ -0,0 +1,167 @@
+// 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 module contains helper methods to configure locks on collections and items for the NFTs
+//! pallet.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Locks a collection with specified settings.
+	///
+	/// The origin must be the owner of the collection to lock it. This function disables certain
+	/// settings on the collection. The only setting that can't be disabled is `DepositRequired`.
+	///
+	/// Note: it's possible only to lock the setting, but not to unlock it after.
+
+	///
+	/// - `origin`: The origin of the transaction, representing the account attempting to lock the
+	///   collection.
+	/// - `collection`: The identifier of the collection to be locked.
+	/// - `lock_settings`: The collection settings to be locked.
+	pub(crate) fn do_lock_collection(
+		origin: T::AccountId,
+		collection: T::CollectionId,
+		lock_settings: CollectionSettings,
+	) -> DispatchResult {
+		ensure!(Self::collection_owner(collection) == Some(origin), Error::<T, I>::NoPermission);
+		ensure!(
+			!lock_settings.is_disabled(CollectionSetting::DepositRequired),
+			Error::<T, I>::WrongSetting
+		);
+		CollectionConfigOf::<T, I>::try_mutate(collection, |maybe_config| {
+			let config = maybe_config.as_mut().ok_or(Error::<T, I>::NoConfig)?;
+
+			for setting in lock_settings.get_disabled() {
+				config.disable_setting(setting);
+			}
+
+			Self::deposit_event(Event::<T, I>::CollectionLocked { collection });
+			Ok(())
+		})
+	}
+
+	/// Locks the transfer of an item within a collection.
+	///
+	/// The origin must have the `Freezer` role within the collection to lock the transfer of the
+	/// item. This function disables the `Transferable` setting on the item, preventing it from
+	/// being transferred to other accounts.
+	///
+	/// - `origin`: The origin of the transaction, representing the account attempting to lock the
+	///   item transfer.
+	/// - `collection`: The identifier of the collection to which the item belongs.
+	/// - `item`: The identifier of the item to be locked for transfer.
+	pub(crate) fn do_lock_item_transfer(
+		origin: T::AccountId,
+		collection: T::CollectionId,
+		item: T::ItemId,
+	) -> DispatchResult {
+		ensure!(
+			Self::has_role(&collection, &origin, CollectionRole::Freezer),
+			Error::<T, I>::NoPermission
+		);
+
+		let mut config = Self::get_item_config(&collection, &item)?;
+		if !config.has_disabled_setting(ItemSetting::Transferable) {
+			config.disable_setting(ItemSetting::Transferable);
+		}
+		ItemConfigOf::<T, I>::insert(&collection, &item, config);
+
+		Self::deposit_event(Event::<T, I>::ItemTransferLocked { collection, item });
+		Ok(())
+	}
+
+	/// Unlocks the transfer of an item within a collection.
+	///
+	/// The origin must have the `Freezer` role within the collection to unlock the transfer of the
+	/// item. This function enables the `Transferable` setting on the item, allowing it to be
+	/// transferred to other accounts.
+	///
+	/// - `origin`: The origin of the transaction, representing the account attempting to unlock the
+	///   item transfer.
+	/// - `collection`: The identifier of the collection to which the item belongs.
+	/// - `item`: The identifier of the item to be unlocked for transfer.
+	pub(crate) fn do_unlock_item_transfer(
+		origin: T::AccountId,
+		collection: T::CollectionId,
+		item: T::ItemId,
+	) -> DispatchResult {
+		ensure!(
+			Self::has_role(&collection, &origin, CollectionRole::Freezer),
+			Error::<T, I>::NoPermission
+		);
+
+		let mut config = Self::get_item_config(&collection, &item)?;
+		if config.has_disabled_setting(ItemSetting::Transferable) {
+			config.enable_setting(ItemSetting::Transferable);
+		}
+		ItemConfigOf::<T, I>::insert(&collection, &item, config);
+
+		Self::deposit_event(Event::<T, I>::ItemTransferUnlocked { collection, item });
+		Ok(())
+	}
+
+	/// Locks the metadata and attributes of an item within a collection.
+	///
+	/// The origin must have the `Admin` role within the collection to lock the metadata and
+	/// attributes of the item. This function disables the `UnlockedMetadata` and
+	/// `UnlockedAttributes` settings on the item, preventing modifications to its metadata and
+	/// attributes.
+	///
+	/// - `maybe_check_origin`: An optional origin representing the account attempting to lock the
+	///   item properties. If provided, this account must have the `Admin` role within the
+	///   collection. If `None`, no permission check is performed, and the function can be called
+	///   from any origin.
+	/// - `collection`: The identifier of the collection to which the item belongs.
+	/// - `item`: The identifier of the item to be locked for properties.
+	/// - `lock_metadata`: A boolean indicating whether to lock the metadata of the item.
+	/// - `lock_attributes`: A boolean indicating whether to lock the attributes of the item.
+	pub(crate) fn do_lock_item_properties(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		lock_metadata: bool,
+		lock_attributes: bool,
+	) -> DispatchResult {
+		if let Some(check_origin) = &maybe_check_origin {
+			ensure!(
+				Self::has_role(&collection, &check_origin, CollectionRole::Admin),
+				Error::<T, I>::NoPermission
+			);
+		}
+
+		ItemConfigOf::<T, I>::try_mutate(collection, item, |maybe_config| {
+			let config = maybe_config.as_mut().ok_or(Error::<T, I>::UnknownItem)?;
+
+			if lock_metadata {
+				config.disable_setting(ItemSetting::UnlockedMetadata);
+			}
+			if lock_attributes {
+				config.disable_setting(ItemSetting::UnlockedAttributes);
+			}
+
+			Self::deposit_event(Event::<T, I>::ItemPropertiesLocked {
+				collection,
+				item,
+				lock_metadata,
+				lock_attributes,
+			});
+			Ok(())
+		})
+	}
+}
diff --git a/substrate/frame/nfts/src/features/metadata.rs b/substrate/frame/nfts/src/features/metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e177f39bb8b813f5f3698bca7c70abd1e0660fa5
--- /dev/null
+++ b/substrate/frame/nfts/src/features/metadata.rs
@@ -0,0 +1,279 @@
+// 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 module contains helper methods to configure the metadata of collections and items.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Sets the metadata for a specific item within a collection.
+	///
+	/// - `maybe_check_origin`: An optional account ID that is allowed to set the metadata. If
+	///   `None`, it's considered the root account.
+	/// - `collection`: The ID of the collection to which the item belongs.
+	/// - `item`: The ID of the item to set the metadata for.
+	/// - `data`: The metadata to set for the item.
+	/// - `maybe_depositor`: An optional account ID that will provide the deposit for the metadata.
+	///   If `None`, the collection's owner provides the deposit.
+	///
+	/// Emits `ItemMetadataSet` event upon successful setting of the metadata.
+	/// Returns `Ok(())` on success, or one of the following dispatch errors:
+	/// - `UnknownCollection`: The specified collection does not exist.
+	/// - `UnknownItem`: The specified item does not exist within the collection.
+	/// - `LockedItemMetadata`: The metadata for the item is locked and cannot be modified.
+	/// - `NoPermission`: The caller does not have the required permission to set the metadata.
+	/// - `DepositExceeded`: The deposit amount exceeds the maximum allowed value.
+	pub(crate) fn do_set_item_metadata(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+		data: BoundedVec<u8, T::StringLimit>,
+		maybe_depositor: Option<T::AccountId>,
+	) -> DispatchResult {
+		if let Some(check_origin) = &maybe_check_origin {
+			ensure!(
+				Self::has_role(&collection, &check_origin, CollectionRole::Admin),
+				Error::<T, I>::NoPermission
+			);
+		}
+
+		let is_root = maybe_check_origin.is_none();
+		let mut collection_details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		let item_config = Self::get_item_config(&collection, &item)?;
+		ensure!(
+			is_root || item_config.is_setting_enabled(ItemSetting::UnlockedMetadata),
+			Error::<T, I>::LockedItemMetadata
+		);
+
+		let collection_config = Self::get_collection_config(&collection)?;
+
+		ItemMetadataOf::<T, I>::try_mutate_exists(collection, item, |metadata| {
+			if metadata.is_none() {
+				collection_details.item_metadatas.saturating_inc();
+			}
+
+			let old_deposit = metadata
+				.take()
+				.map_or(ItemMetadataDeposit { account: None, amount: Zero::zero() }, |m| m.deposit);
+
+			let mut deposit = Zero::zero();
+			if collection_config.is_setting_enabled(CollectionSetting::DepositRequired) && !is_root
+			{
+				deposit = T::DepositPerByte::get()
+					.saturating_mul(((data.len()) as u32).into())
+					.saturating_add(T::MetadataDepositBase::get());
+			}
+
+			let depositor = maybe_depositor.clone().unwrap_or(collection_details.owner.clone());
+			let old_depositor = old_deposit.account.unwrap_or(collection_details.owner.clone());
+
+			if depositor != old_depositor {
+				T::Currency::unreserve(&old_depositor, old_deposit.amount);
+				T::Currency::reserve(&depositor, deposit)?;
+			} else if deposit > old_deposit.amount {
+				T::Currency::reserve(&depositor, deposit - old_deposit.amount)?;
+			} else if deposit < old_deposit.amount {
+				T::Currency::unreserve(&depositor, old_deposit.amount - deposit);
+			}
+
+			if maybe_depositor.is_none() {
+				collection_details.owner_deposit.saturating_accrue(deposit);
+				collection_details.owner_deposit.saturating_reduce(old_deposit.amount);
+			}
+
+			*metadata = Some(ItemMetadata {
+				deposit: ItemMetadataDeposit { account: maybe_depositor, amount: deposit },
+				data: data.clone(),
+			});
+
+			Collection::<T, I>::insert(&collection, &collection_details);
+			Self::deposit_event(Event::ItemMetadataSet { collection, item, data });
+			Ok(())
+		})
+	}
+
+	/// Clears the metadata for a specific item within a collection.
+	///
+	/// - `maybe_check_origin`: An optional account ID that is allowed to clear the metadata. If
+	///   `None`, it's considered the root account.
+	/// - `collection`: The ID of the collection to which the item belongs.
+	/// - `item`: The ID of the item for which to clear the metadata.
+	///
+	/// Emits `ItemMetadataCleared` event upon successful clearing of the metadata.
+	/// Returns `Ok(())` on success, or one of the following dispatch errors:
+	/// - `UnknownCollection`: The specified collection does not exist.
+	/// - `MetadataNotFound`: The metadata for the specified item was not found.
+	/// - `LockedItemMetadata`: The metadata for the item is locked and cannot be modified.
+	/// - `NoPermission`: The caller does not have the required permission to clear the metadata.
+	pub(crate) fn do_clear_item_metadata(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		item: T::ItemId,
+	) -> DispatchResult {
+		if let Some(check_origin) = &maybe_check_origin {
+			ensure!(
+				Self::has_role(&collection, &check_origin, CollectionRole::Admin),
+				Error::<T, I>::NoPermission
+			);
+		}
+
+		let is_root = maybe_check_origin.is_none();
+		let metadata = ItemMetadataOf::<T, I>::take(collection, item)
+			.ok_or(Error::<T, I>::MetadataNotFound)?;
+		let mut collection_details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		let depositor_account =
+			metadata.deposit.account.unwrap_or(collection_details.owner.clone());
+
+		// NOTE: if the item was previously burned, the ItemConfigOf record might not exist
+		let is_locked = Self::get_item_config(&collection, &item)
+			.map_or(false, |c| c.has_disabled_setting(ItemSetting::UnlockedMetadata));
+
+		ensure!(is_root || !is_locked, Error::<T, I>::LockedItemMetadata);
+
+		collection_details.item_metadatas.saturating_dec();
+		T::Currency::unreserve(&depositor_account, metadata.deposit.amount);
+
+		if depositor_account == collection_details.owner {
+			collection_details.owner_deposit.saturating_reduce(metadata.deposit.amount);
+		}
+
+		Collection::<T, I>::insert(&collection, &collection_details);
+		Self::deposit_event(Event::ItemMetadataCleared { collection, item });
+
+		Ok(())
+	}
+
+	/// Sets the metadata for a specific collection.
+	///
+	/// - `maybe_check_origin`: An optional account ID that is allowed to set the collection
+	///   metadata. If `None`, it's considered the root account.
+	/// - `collection`: The ID of the collection for which to set the metadata.
+	/// - `data`: The metadata to set for the collection.
+	///
+	/// Emits `CollectionMetadataSet` event upon successful setting of the metadata.
+	/// Returns `Ok(())` on success, or one of the following dispatch errors:
+	/// - `UnknownCollection`: The specified collection does not exist.
+	/// - `LockedCollectionMetadata`: The metadata for the collection is locked and cannot be
+	///   modified.
+	/// - `NoPermission`: The caller does not have the required permission to set the metadata.
+	pub(crate) fn do_set_collection_metadata(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		data: BoundedVec<u8, T::StringLimit>,
+	) -> DispatchResult {
+		if let Some(check_origin) = &maybe_check_origin {
+			ensure!(
+				Self::has_role(&collection, &check_origin, CollectionRole::Admin),
+				Error::<T, I>::NoPermission
+			);
+		}
+
+		let is_root = maybe_check_origin.is_none();
+		let collection_config = Self::get_collection_config(&collection)?;
+		ensure!(
+			is_root || collection_config.is_setting_enabled(CollectionSetting::UnlockedMetadata),
+			Error::<T, I>::LockedCollectionMetadata
+		);
+
+		let mut details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		CollectionMetadataOf::<T, I>::try_mutate_exists(collection, |metadata| {
+			let old_deposit = metadata.take().map_or(Zero::zero(), |m| m.deposit);
+			details.owner_deposit.saturating_reduce(old_deposit);
+			let mut deposit = Zero::zero();
+			if !is_root && collection_config.is_setting_enabled(CollectionSetting::DepositRequired)
+			{
+				deposit = T::DepositPerByte::get()
+					.saturating_mul(((data.len()) as u32).into())
+					.saturating_add(T::MetadataDepositBase::get());
+			}
+			if deposit > old_deposit {
+				T::Currency::reserve(&details.owner, deposit - old_deposit)?;
+			} else if deposit < old_deposit {
+				T::Currency::unreserve(&details.owner, old_deposit - deposit);
+			}
+			details.owner_deposit.saturating_accrue(deposit);
+
+			Collection::<T, I>::insert(&collection, details);
+
+			*metadata = Some(CollectionMetadata { deposit, data: data.clone() });
+
+			Self::deposit_event(Event::CollectionMetadataSet { collection, data });
+			Ok(())
+		})
+	}
+
+	/// Clears the metadata for a specific collection.
+	///
+	/// - `maybe_check_origin`: An optional account ID that is allowed to clear the collection
+	///   metadata. If `None`, it's considered the root account.
+	/// - `collection`: The ID of the collection for which to clear the metadata.
+	///
+	/// Emits `CollectionMetadataCleared` event upon successful clearing of the metadata.
+	/// Returns `Ok(())` on success, or one of the following dispatch errors:
+	/// - `UnknownCollection`: The specified collection does not exist.
+	/// - `MetadataNotFound`: The metadata for the collection was not found.
+	/// - `LockedCollectionMetadata`: The metadata for the collection is locked and cannot be
+	///   modified.
+	/// - `NoPermission`: The caller does not have the required permission to clear the metadata.
+	pub(crate) fn do_clear_collection_metadata(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+	) -> DispatchResult {
+		if let Some(check_origin) = &maybe_check_origin {
+			ensure!(
+				Self::has_role(&collection, &check_origin, CollectionRole::Admin),
+				Error::<T, I>::NoPermission
+			);
+		}
+
+		let details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+		let collection_config = Self::get_collection_config(&collection)?;
+
+		ensure!(
+			maybe_check_origin.is_none() ||
+				collection_config.is_setting_enabled(CollectionSetting::UnlockedMetadata),
+			Error::<T, I>::LockedCollectionMetadata
+		);
+
+		CollectionMetadataOf::<T, I>::try_mutate_exists(collection, |metadata| {
+			let deposit = metadata.take().ok_or(Error::<T, I>::UnknownCollection)?.deposit;
+			T::Currency::unreserve(&details.owner, deposit);
+			Self::deposit_event(Event::CollectionMetadataCleared { collection });
+			Ok(())
+		})
+	}
+
+	/// A helper method to construct metadata.
+	///
+	/// # Errors
+	///
+	/// This function returns an [`IncorrectMetadata`](crate::Error::IncorrectMetadata) dispatch
+	/// error if the provided metadata is too long.
+	pub fn construct_metadata(
+		metadata: Vec<u8>,
+	) -> Result<BoundedVec<u8, T::StringLimit>, DispatchError> {
+		Ok(BoundedVec::try_from(metadata).map_err(|_| Error::<T, I>::IncorrectMetadata)?)
+	}
+}
diff --git a/substrate/frame/nfts/src/features/mod.rs b/substrate/frame/nfts/src/features/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..752feaf5db858a79978a152a2faf413d67998009
--- /dev/null
+++ b/substrate/frame/nfts/src/features/mod.rs
@@ -0,0 +1,28 @@
+// 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.
+
+pub mod approvals;
+pub mod atomic_swap;
+pub mod attributes;
+pub mod buy_sell;
+pub mod create_delete_collection;
+pub mod create_delete_item;
+pub mod lock;
+pub mod metadata;
+pub mod roles;
+pub mod settings;
+pub mod transfer;
diff --git a/substrate/frame/nfts/src/features/roles.rs b/substrate/frame/nfts/src/features/roles.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f6d2785fd9cb4094d8565489099097ece7b4377a
--- /dev/null
+++ b/substrate/frame/nfts/src/features/roles.rs
@@ -0,0 +1,152 @@
+// 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 module contains helper methods to configure account roles for existing collections.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+use sp_std::collections::btree_map::BTreeMap;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Set the team roles for a specific collection.
+	///
+	/// - `maybe_check_owner`: An optional account ID used to check ownership permission. If `None`,
+	///   it is considered as the root.
+	/// - `collection`: The ID of the collection for which to set the team roles.
+	/// - `issuer`: An optional account ID representing the issuer role.
+	/// - `admin`: An optional account ID representing the admin role.
+	/// - `freezer`: An optional account ID representing the freezer role.
+	///
+	/// This function allows the owner or the root (when `maybe_check_owner` is `None`) to set the
+	/// team roles for a specific collection. The root can change the role from `None` to
+	/// `Some(account)`, but other roles can only be updated by the root or an account with an
+	/// existing role in the collection.
+	pub(crate) fn do_set_team(
+		maybe_check_owner: Option<T::AccountId>,
+		collection: T::CollectionId,
+		issuer: Option<T::AccountId>,
+		admin: Option<T::AccountId>,
+		freezer: Option<T::AccountId>,
+	) -> DispatchResult {
+		Collection::<T, I>::try_mutate(collection, |maybe_details| {
+			let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+			let is_root = maybe_check_owner.is_none();
+			if let Some(check_origin) = maybe_check_owner {
+				ensure!(check_origin == details.owner, Error::<T, I>::NoPermission);
+			}
+
+			let roles_map = [
+				(issuer.clone(), CollectionRole::Issuer),
+				(admin.clone(), CollectionRole::Admin),
+				(freezer.clone(), CollectionRole::Freezer),
+			];
+
+			// only root can change the role from `None` to `Some(account)`
+			if !is_root {
+				for (account, role) in roles_map.iter() {
+					if account.is_some() {
+						ensure!(
+							Self::find_account_by_role(&collection, *role).is_some(),
+							Error::<T, I>::NoPermission
+						);
+					}
+				}
+			}
+
+			let roles = roles_map
+				.into_iter()
+				.filter_map(|(account, role)| account.map(|account| (account, role)))
+				.collect();
+
+			let account_to_role = Self::group_roles_by_account(roles);
+
+			// Delete the previous records.
+			Self::clear_roles(&collection)?;
+
+			// Insert new records.
+			for (account, roles) in account_to_role {
+				CollectionRoleOf::<T, I>::insert(&collection, &account, roles);
+			}
+
+			Self::deposit_event(Event::TeamChanged { collection, issuer, admin, freezer });
+			Ok(())
+		})
+	}
+
+	/// Clears all the roles in a specified collection.
+	///
+	/// - `collection_id`: A collection to clear the roles in.
+	///
+	/// This function clears all the roles associated with the given `collection_id`. It throws an
+	/// error if some of the roles were left in storage, indicating that the maximum number of roles
+	/// may need to be adjusted.
+	pub(crate) fn clear_roles(collection_id: &T::CollectionId) -> Result<(), DispatchError> {
+		let res = CollectionRoleOf::<T, I>::clear_prefix(
+			&collection_id,
+			CollectionRoles::max_roles() as u32,
+			None,
+		);
+		ensure!(res.maybe_cursor.is_none(), Error::<T, I>::RolesNotCleared);
+		Ok(())
+	}
+
+	/// Returns true if a specified account has a provided role within that collection.
+	///
+	/// - `collection_id`: A collection to check the role in.
+	/// - `account_id`: An account to check the role for.
+	/// - `role`: A role to validate.
+	///
+	/// Returns `true` if the account has the specified role, `false` otherwise.
+	pub(crate) fn has_role(
+		collection_id: &T::CollectionId,
+		account_id: &T::AccountId,
+		role: CollectionRole,
+	) -> bool {
+		CollectionRoleOf::<T, I>::get(&collection_id, &account_id)
+			.map_or(false, |roles| roles.has_role(role))
+	}
+
+	/// Finds the account by a provided role within a collection.
+	///
+	/// - `collection_id`: A collection to check the role in.
+	/// - `role`: A role to find the account for.
+	///
+	/// Returns `Some(T::AccountId)` if the record was found, `None` otherwise.
+	pub(crate) fn find_account_by_role(
+		collection_id: &T::CollectionId,
+		role: CollectionRole,
+	) -> Option<T::AccountId> {
+		CollectionRoleOf::<T, I>::iter_prefix(&collection_id).into_iter().find_map(
+			|(account, roles)| if roles.has_role(role) { Some(account.clone()) } else { None },
+		)
+	}
+
+	/// Groups provided roles by account, given one account could have multiple roles.
+	///
+	/// - `input`: A vector of (Account, Role) tuples.
+	///
+	/// Returns a grouped vector of `(Account, Roles)` tuples.
+	pub fn group_roles_by_account(
+		input: Vec<(T::AccountId, CollectionRole)>,
+	) -> Vec<(T::AccountId, CollectionRoles)> {
+		let mut result = BTreeMap::new();
+		for (account, role) in input.into_iter() {
+			result.entry(account).or_insert(CollectionRoles::none()).add_role(role);
+		}
+		result.into_iter().collect()
+	}
+}
diff --git a/substrate/frame/nfts/src/features/settings.rs b/substrate/frame/nfts/src/features/settings.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d4f7533ffa4eb0d46c1e818acaca742d283f9706
--- /dev/null
+++ b/substrate/frame/nfts/src/features/settings.rs
@@ -0,0 +1,178 @@
+// 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 module provides helper methods to configure collection settings for the NFTs pallet.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Forcefully change the configuration of a collection.
+	///
+	/// - `collection`: The ID of the collection for which to update the configuration.
+	/// - `config`: The new collection configuration to set.
+	///
+	/// This function allows for changing the configuration of a collection without any checks.
+	/// It updates the collection configuration and emits a `CollectionConfigChanged` event.
+	pub(crate) fn do_force_collection_config(
+		collection: T::CollectionId,
+		config: CollectionConfigFor<T, I>,
+	) -> DispatchResult {
+		ensure!(Collection::<T, I>::contains_key(&collection), Error::<T, I>::UnknownCollection);
+		CollectionConfigOf::<T, I>::insert(&collection, config);
+		Self::deposit_event(Event::CollectionConfigChanged { collection });
+		Ok(())
+	}
+
+	/// Set the maximum supply for a collection.
+	///
+	/// - `maybe_check_owner`: An optional account ID used to check permissions.
+	/// - `collection`: The ID of the collection for which to set the maximum supply.
+	/// - `max_supply`: The new maximum supply to set for the collection.
+	///
+	/// This function checks if the setting `UnlockedMaxSupply` is enabled in the collection
+	/// configuration. If it is not enabled, it returns an `Error::MaxSupplyLocked`. If
+	/// `maybe_check_owner` is `Some(owner)`, it checks if the caller of the function is the
+	/// owner of the collection. If the caller is not the owner and the `maybe_check_owner`
+	/// parameter is provided, it returns an `Error::NoPermission`.
+	///
+	/// It also checks if the new maximum supply is greater than the current number of items in
+	/// the collection, and if not, it returns an `Error::MaxSupplyTooSmall`. If all checks pass,
+	/// it updates the collection configuration with the new maximum supply and emits a
+	/// `CollectionMaxSupplySet` event.
+	pub(crate) fn do_set_collection_max_supply(
+		maybe_check_owner: Option<T::AccountId>,
+		collection: T::CollectionId,
+		max_supply: u32,
+	) -> DispatchResult {
+		let collection_config = Self::get_collection_config(&collection)?;
+		ensure!(
+			collection_config.is_setting_enabled(CollectionSetting::UnlockedMaxSupply),
+			Error::<T, I>::MaxSupplyLocked
+		);
+
+		let details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+		if let Some(check_owner) = &maybe_check_owner {
+			ensure!(check_owner == &details.owner, Error::<T, I>::NoPermission);
+		}
+
+		ensure!(details.items <= max_supply, Error::<T, I>::MaxSupplyTooSmall);
+
+		CollectionConfigOf::<T, I>::try_mutate(collection, |maybe_config| {
+			let config = maybe_config.as_mut().ok_or(Error::<T, I>::NoConfig)?;
+			config.max_supply = Some(max_supply);
+			Self::deposit_event(Event::CollectionMaxSupplySet { collection, max_supply });
+			Ok(())
+		})
+	}
+
+	/// Update the mint settings for a collection.
+	///
+	/// - `maybe_check_origin`: An optional account ID used to check issuer permissions.
+	/// - `collection`: The ID of the collection for which to update the mint settings.
+	/// - `mint_settings`: The new mint settings to set for the collection.
+	///
+	/// This function updates the mint settings for a collection. If `maybe_check_origin` is
+	/// `Some(origin)`, it checks if the caller of the function has the `CollectionRole::Issuer`
+	/// for the given collection. If the caller doesn't have the required permission and
+	/// `maybe_check_origin` is provided, it returns an `Error::NoPermission`. If all checks
+	/// pass, it updates the collection configuration with the new mint settings and emits a
+	/// `CollectionMintSettingsUpdated` event.
+	pub(crate) fn do_update_mint_settings(
+		maybe_check_origin: Option<T::AccountId>,
+		collection: T::CollectionId,
+		mint_settings: MintSettings<
+			BalanceOf<T, I>,
+			frame_system::pallet_prelude::BlockNumberFor<T>,
+			T::CollectionId,
+		>,
+	) -> DispatchResult {
+		if let Some(check_origin) = &maybe_check_origin {
+			ensure!(
+				Self::has_role(&collection, &check_origin, CollectionRole::Issuer),
+				Error::<T, I>::NoPermission
+			);
+		}
+
+		CollectionConfigOf::<T, I>::try_mutate(collection, |maybe_config| {
+			let config = maybe_config.as_mut().ok_or(Error::<T, I>::NoConfig)?;
+			config.mint_settings = mint_settings;
+			Self::deposit_event(Event::CollectionMintSettingsUpdated { collection });
+			Ok(())
+		})
+	}
+
+	/// Get the configuration for a specific collection.
+	///
+	/// - `collection_id`: The ID of the collection for which to retrieve the configuration.
+	///
+	/// This function attempts to fetch the configuration (`CollectionConfigFor`) associated
+	/// with the given `collection_id`. If the configuration exists, it returns `Ok(config)`,
+	/// otherwise, it returns a `DispatchError` with `Error::NoConfig`.
+	pub(crate) fn get_collection_config(
+		collection_id: &T::CollectionId,
+	) -> Result<CollectionConfigFor<T, I>, DispatchError> {
+		let config =
+			CollectionConfigOf::<T, I>::get(&collection_id).ok_or(Error::<T, I>::NoConfig)?;
+		Ok(config)
+	}
+
+	/// Get the configuration for a specific item within a collection.
+	///
+	/// - `collection_id`: The ID of the collection to which the item belongs.
+	/// - `item_id`: The ID of the item for which to retrieve the configuration.
+	///
+	/// This function attempts to fetch the configuration (`ItemConfig`) associated with the given
+	/// `collection_id` and `item_id`. If the configuration exists, it returns `Ok(config)`,
+	/// otherwise, it returns a `DispatchError` with `Error::UnknownItem`.
+	pub(crate) fn get_item_config(
+		collection_id: &T::CollectionId,
+		item_id: &T::ItemId,
+	) -> Result<ItemConfig, DispatchError> {
+		let config = ItemConfigOf::<T, I>::get(&collection_id, &item_id)
+			.ok_or(Error::<T, I>::UnknownItem)?;
+		Ok(config)
+	}
+
+	/// Get the default item settings for a specific collection.
+	///
+	/// - `collection_id`: The ID of the collection for which to retrieve the default item settings.
+	///
+	/// This function fetches the `default_item_settings` from the collection configuration
+	/// associated with the given `collection_id`. If the collection configuration exists, it
+	/// returns `Ok(default_item_settings)`, otherwise, it returns a `DispatchError` with
+	/// `Error::NoConfig`.
+	pub(crate) fn get_default_item_settings(
+		collection_id: &T::CollectionId,
+	) -> Result<ItemSettings, DispatchError> {
+		let collection_config = Self::get_collection_config(collection_id)?;
+		Ok(collection_config.mint_settings.default_item_settings)
+	}
+
+	/// Check if a specified pallet feature is enabled.
+	///
+	/// - `feature`: The feature to check.
+	///
+	/// This function checks if the given `feature` is enabled in the runtime using the
+	/// pallet's `T::Features::get()` function. It returns `true` if the feature is enabled,
+	/// otherwise it returns `false`.
+	pub(crate) fn is_pallet_feature_enabled(feature: PalletFeature) -> bool {
+		let features = T::Features::get();
+		return features.is_enabled(feature)
+	}
+}
diff --git a/substrate/frame/nfts/src/features/transfer.rs b/substrate/frame/nfts/src/features/transfer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0471bd67b29164358069d27c2239a2010795b7d0
--- /dev/null
+++ b/substrate/frame/nfts/src/features/transfer.rs
@@ -0,0 +1,233 @@
+// 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 module contains helper methods to perform the transfer functionalities
+//! of the NFTs pallet.
+
+use crate::*;
+use frame_support::pallet_prelude::*;
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Transfer an NFT to the specified destination account.
+	///
+	/// - `collection`: The ID of the collection to which the NFT belongs.
+	/// - `item`: The ID of the NFT to transfer.
+	/// - `dest`: The destination account to which the NFT will be transferred.
+	/// - `with_details`: A closure that provides access to the collection and item details,
+	///   allowing customization of the transfer process.
+	///
+	/// This function performs the actual transfer of an NFT to the destination account.
+	/// It checks various conditions like item lock status and transferability settings
+	/// for the collection and item before transferring the NFT.
+	///
+	/// # Errors
+	///
+	/// This function returns a dispatch error in the following cases:
+	/// - If the collection ID is invalid ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - If the item ID is invalid ([`UnknownItem`](crate::Error::UnknownItem)).
+	/// - If the item is locked or transferring it is disabled
+	///   ([`ItemLocked`](crate::Error::ItemLocked)).
+	/// - If the collection or item is non-transferable
+	///   ([`ItemsNonTransferable`](crate::Error::ItemsNonTransferable)).
+	pub fn do_transfer(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		dest: T::AccountId,
+		with_details: impl FnOnce(
+			&CollectionDetailsFor<T, I>,
+			&mut ItemDetailsFor<T, I>,
+		) -> DispatchResult,
+	) -> DispatchResult {
+		// Retrieve collection details.
+		let collection_details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+		// Ensure the item is not locked.
+		ensure!(!T::Locker::is_locked(collection, item), Error::<T, I>::ItemLocked);
+
+		// Ensure the item is not transfer disabled on the system level attribute.
+		ensure!(
+			!Self::has_system_attribute(&collection, &item, PalletAttributes::TransferDisabled)?,
+			Error::<T, I>::ItemLocked
+		);
+
+		// Retrieve collection config and check if items are transferable.
+		let collection_config = Self::get_collection_config(&collection)?;
+		ensure!(
+			collection_config.is_setting_enabled(CollectionSetting::TransferableItems),
+			Error::<T, I>::ItemsNonTransferable
+		);
+
+		// Retrieve item config and check if the item is transferable.
+		let item_config = Self::get_item_config(&collection, &item)?;
+		ensure!(
+			item_config.is_setting_enabled(ItemSetting::Transferable),
+			Error::<T, I>::ItemLocked
+		);
+
+		// Retrieve the item details.
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+
+		// Perform the transfer with custom details using the provided closure.
+		with_details(&collection_details, &mut details)?;
+
+		// Update account ownership information.
+		Account::<T, I>::remove((&details.owner, &collection, &item));
+		Account::<T, I>::insert((&dest, &collection, &item), ());
+		let origin = details.owner;
+		details.owner = dest;
+
+		// The approved accounts have to be reset to `None`, because otherwise pre-approve attack
+		// would be possible, where the owner can approve their second account before making the
+		// transaction and then claiming the item back.
+		details.approvals.clear();
+
+		// Update item details.
+		Item::<T, I>::insert(&collection, &item, &details);
+		ItemPriceOf::<T, I>::remove(&collection, &item);
+		PendingSwapOf::<T, I>::remove(&collection, &item);
+
+		// Emit `Transferred` event.
+		Self::deposit_event(Event::Transferred {
+			collection,
+			item,
+			from: origin,
+			to: details.owner,
+		});
+		Ok(())
+	}
+
+	/// Transfer ownership of a collection to another account.
+	///
+	/// - `origin`: The account requesting the transfer.
+	/// - `collection`: The ID of the collection to transfer ownership.
+	/// - `owner`: The new account that will become the owner of the collection.
+	///
+	/// This function transfers the ownership of a collection to the specified account.
+	/// It performs checks to ensure that the `origin` is the current owner and that the
+	/// new owner is an acceptable account based on the collection's acceptance settings.
+	pub(crate) fn do_transfer_ownership(
+		origin: T::AccountId,
+		collection: T::CollectionId,
+		owner: T::AccountId,
+	) -> DispatchResult {
+		// Check if the new owner is acceptable based on the collection's acceptance settings.
+		let acceptable_collection = OwnershipAcceptance::<T, I>::get(&owner);
+		ensure!(acceptable_collection.as_ref() == Some(&collection), Error::<T, I>::Unaccepted);
+
+		// Try to retrieve and mutate the collection details.
+		Collection::<T, I>::try_mutate(collection, |maybe_details| {
+			let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+			// Check if the `origin` is the current owner of the collection.
+			ensure!(origin == details.owner, Error::<T, I>::NoPermission);
+			if details.owner == owner {
+				return Ok(())
+			}
+
+			// Move the deposit to the new owner.
+			T::Currency::repatriate_reserved(
+				&details.owner,
+				&owner,
+				details.owner_deposit,
+				Reserved,
+			)?;
+
+			// Update account ownership information.
+			CollectionAccount::<T, I>::remove(&details.owner, &collection);
+			CollectionAccount::<T, I>::insert(&owner, &collection, ());
+
+			details.owner = owner.clone();
+			OwnershipAcceptance::<T, I>::remove(&owner);
+
+			// Emit `OwnerChanged` event.
+			Self::deposit_event(Event::OwnerChanged { collection, new_owner: owner });
+			Ok(())
+		})
+	}
+	/// Set or unset the ownership acceptance for an account regarding a specific collection.
+	///
+	/// - `who`: The account for which to set or unset the ownership acceptance.
+	/// - `maybe_collection`: An optional collection ID to set the ownership acceptance.
+	///
+	/// If `maybe_collection` is `Some(collection)`, then the account `who` will accept
+	/// ownership transfers for the specified collection. If `maybe_collection` is `None`,
+	/// then the account `who` will unset the ownership acceptance, effectively refusing
+	/// ownership transfers for any collection.
+	pub(crate) fn do_set_accept_ownership(
+		who: T::AccountId,
+		maybe_collection: Option<T::CollectionId>,
+	) -> DispatchResult {
+		let old = OwnershipAcceptance::<T, I>::get(&who);
+		match (old.is_some(), maybe_collection.is_some()) {
+			(false, true) => {
+				frame_system::Pallet::<T>::inc_consumers(&who)?;
+			},
+			(true, false) => {
+				frame_system::Pallet::<T>::dec_consumers(&who);
+			},
+			_ => {},
+		}
+		if let Some(collection) = maybe_collection.as_ref() {
+			OwnershipAcceptance::<T, I>::insert(&who, collection);
+		} else {
+			OwnershipAcceptance::<T, I>::remove(&who);
+		}
+
+		// Emit `OwnershipAcceptanceChanged` event.
+		Self::deposit_event(Event::OwnershipAcceptanceChanged { who, maybe_collection });
+		Ok(())
+	}
+
+	/// Forcefully change the owner of a collection.
+	///
+	/// - `collection`: The ID of the collection to change ownership.
+	/// - `owner`: The new account that will become the owner of the collection.
+	///
+	/// This function allows for changing the ownership of a collection without any checks.
+	/// It moves the deposit to the new owner, updates the collection's owner, and emits
+	/// an `OwnerChanged` event.
+	pub(crate) fn do_force_collection_owner(
+		collection: T::CollectionId,
+		owner: T::AccountId,
+	) -> DispatchResult {
+		// Try to retrieve and mutate the collection details.
+		Collection::<T, I>::try_mutate(collection, |maybe_details| {
+			let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+			if details.owner == owner {
+				return Ok(())
+			}
+
+			// Move the deposit to the new owner.
+			T::Currency::repatriate_reserved(
+				&details.owner,
+				&owner,
+				details.owner_deposit,
+				Reserved,
+			)?;
+
+			// Update collection accounts and set the new owner.
+			CollectionAccount::<T, I>::remove(&details.owner, &collection);
+			CollectionAccount::<T, I>::insert(&owner, &collection, ());
+			details.owner = owner.clone();
+
+			// Emit `OwnerChanged` event.
+			Self::deposit_event(Event::OwnerChanged { collection, new_owner: owner });
+			Ok(())
+		})
+	}
+}
diff --git a/substrate/frame/nfts/src/impl_nonfungibles.rs b/substrate/frame/nfts/src/impl_nonfungibles.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e2593b4057d7b59510fc336589d7af77994566c
--- /dev/null
+++ b/substrate/frame/nfts/src/impl_nonfungibles.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.
+
+//! Implementations for `nonfungibles` traits.
+
+use super::*;
+use frame_support::{
+	ensure,
+	storage::KeyPrefixIterator,
+	traits::{tokens::nonfungibles_v2::*, Get},
+	BoundedSlice,
+};
+use sp_runtime::{DispatchError, DispatchResult};
+use sp_std::prelude::*;
+
+impl<T: Config<I>, I: 'static> Inspect<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	type ItemId = T::ItemId;
+	type CollectionId = T::CollectionId;
+
+	fn owner(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+	) -> Option<<T as SystemConfig>::AccountId> {
+		Item::<T, I>::get(collection, item).map(|a| a.owner)
+	}
+
+	fn collection_owner(collection: &Self::CollectionId) -> Option<<T as SystemConfig>::AccountId> {
+		Collection::<T, I>::get(collection).map(|a| a.owner)
+	}
+
+	/// Returns the attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// When `key` is empty, we return the item metadata value.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn attribute(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &[u8],
+	) -> Option<Vec<u8>> {
+		if key.is_empty() {
+			// We make the empty key map to the item metadata value.
+			ItemMetadataOf::<T, I>::get(collection, item).map(|m| m.data.into())
+		} else {
+			let namespace = AttributeNamespace::CollectionOwner;
+			let key = BoundedSlice::<_, _>::try_from(key).ok()?;
+			Attribute::<T, I>::get((collection, Some(item), namespace, key)).map(|a| a.0.into())
+		}
+	}
+
+	/// Returns the custom attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn custom_attribute(
+		account: &T::AccountId,
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &[u8],
+	) -> Option<Vec<u8>> {
+		let namespace = Account::<T, I>::get((account, collection, item))
+			.map(|_| AttributeNamespace::ItemOwner)
+			.unwrap_or_else(|| AttributeNamespace::Account(account.clone()));
+
+		let key = BoundedSlice::<_, _>::try_from(key).ok()?;
+		Attribute::<T, I>::get((collection, Some(item), namespace, key)).map(|a| a.0.into())
+	}
+
+	/// Returns the system attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn system_attribute(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &[u8],
+	) -> Option<Vec<u8>> {
+		let namespace = AttributeNamespace::Pallet;
+		let key = BoundedSlice::<_, _>::try_from(key).ok()?;
+		Attribute::<T, I>::get((collection, Some(item), namespace, key)).map(|a| a.0.into())
+	}
+
+	/// Returns the attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// When `key` is empty, we return the item metadata value.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn collection_attribute(collection: &Self::CollectionId, key: &[u8]) -> Option<Vec<u8>> {
+		if key.is_empty() {
+			// We make the empty key map to the item metadata value.
+			CollectionMetadataOf::<T, I>::get(collection).map(|m| m.data.into())
+		} else {
+			let key = BoundedSlice::<_, _>::try_from(key).ok()?;
+			Attribute::<T, I>::get((
+				collection,
+				Option::<T::ItemId>::None,
+				AttributeNamespace::CollectionOwner,
+				key,
+			))
+			.map(|a| a.0.into())
+		}
+	}
+
+	/// Returns `true` if the `item` of `collection` may be transferred.
+	///
+	/// Default implementation is that all items are transferable.
+	fn can_transfer(collection: &Self::CollectionId, item: &Self::ItemId) -> bool {
+		use PalletAttributes::TransferDisabled;
+		match Self::has_system_attribute(&collection, &item, TransferDisabled) {
+			Ok(transfer_disabled) if transfer_disabled => return false,
+			_ => (),
+		}
+		match (
+			CollectionConfigOf::<T, I>::get(collection),
+			ItemConfigOf::<T, I>::get(collection, item),
+		) {
+			(Some(cc), Some(ic))
+				if cc.is_setting_enabled(CollectionSetting::TransferableItems) &&
+					ic.is_setting_enabled(ItemSetting::Transferable) =>
+				true,
+			_ => false,
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> InspectRole<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	fn is_issuer(collection: &Self::CollectionId, who: &<T as SystemConfig>::AccountId) -> bool {
+		Self::has_role(collection, who, CollectionRole::Issuer)
+	}
+	fn is_admin(collection: &Self::CollectionId, who: &<T as SystemConfig>::AccountId) -> bool {
+		Self::has_role(collection, who, CollectionRole::Admin)
+	}
+	fn is_freezer(collection: &Self::CollectionId, who: &<T as SystemConfig>::AccountId) -> bool {
+		Self::has_role(collection, who, CollectionRole::Freezer)
+	}
+}
+
+impl<T: Config<I>, I: 'static> Create<<T as SystemConfig>::AccountId, CollectionConfigFor<T, I>>
+	for Pallet<T, I>
+{
+	/// Create a `collection` of nonfungible items to be owned by `who` and managed by `admin`.
+	fn create_collection(
+		who: &T::AccountId,
+		admin: &T::AccountId,
+		config: &CollectionConfigFor<T, I>,
+	) -> Result<T::CollectionId, DispatchError> {
+		// DepositRequired can be disabled by calling the force_create() only
+		ensure!(
+			!config.has_disabled_setting(CollectionSetting::DepositRequired),
+			Error::<T, I>::WrongSetting
+		);
+
+		let collection = NextCollectionId::<T, I>::get()
+			.or(T::CollectionId::initial_value())
+			.ok_or(Error::<T, I>::UnknownCollection)?;
+
+		Self::do_create_collection(
+			collection,
+			who.clone(),
+			admin.clone(),
+			*config,
+			T::CollectionDeposit::get(),
+			Event::Created { collection, creator: who.clone(), owner: admin.clone() },
+		)?;
+
+		Self::set_next_collection_id(collection);
+
+		Ok(collection)
+	}
+
+	/// Create a collection of nonfungible items with `collection` Id to be owned by `who` and
+	/// managed by `admin`. Should be only used for applications that do not have an
+	/// incremental order for the collection IDs and is a replacement for the auto id creation.
+	///
+	///
+	/// SAFETY: This function can break the pallet if it is used in combination with the auto
+	/// increment functionality, as it can claim a value in the ID sequence.
+	fn create_collection_with_id(
+		collection: T::CollectionId,
+		who: &T::AccountId,
+		admin: &T::AccountId,
+		config: &CollectionConfigFor<T, I>,
+	) -> Result<(), DispatchError> {
+		// DepositRequired can be disabled by calling the force_create() only
+		ensure!(
+			!config.has_disabled_setting(CollectionSetting::DepositRequired),
+			Error::<T, I>::WrongSetting
+		);
+
+		Self::do_create_collection(
+			collection,
+			who.clone(),
+			admin.clone(),
+			*config,
+			T::CollectionDeposit::get(),
+			Event::Created { collection, creator: who.clone(), owner: admin.clone() },
+		)
+	}
+}
+
+impl<T: Config<I>, I: 'static> Destroy<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	type DestroyWitness = DestroyWitness;
+
+	fn get_destroy_witness(collection: &Self::CollectionId) -> Option<DestroyWitness> {
+		Collection::<T, I>::get(collection).map(|a| a.destroy_witness())
+	}
+
+	fn destroy(
+		collection: Self::CollectionId,
+		witness: Self::DestroyWitness,
+		maybe_check_owner: Option<T::AccountId>,
+	) -> Result<Self::DestroyWitness, DispatchError> {
+		Self::do_destroy_collection(collection, witness, maybe_check_owner)
+	}
+}
+
+impl<T: Config<I>, I: 'static> Mutate<<T as SystemConfig>::AccountId, ItemConfig> for Pallet<T, I> {
+	fn mint_into(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		who: &T::AccountId,
+		item_config: &ItemConfig,
+		deposit_collection_owner: bool,
+	) -> DispatchResult {
+		Self::do_mint(
+			*collection,
+			*item,
+			match deposit_collection_owner {
+				true => None,
+				false => Some(who.clone()),
+			},
+			who.clone(),
+			*item_config,
+			|_, _| Ok(()),
+		)
+	}
+
+	fn burn(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		maybe_check_owner: Option<&T::AccountId>,
+	) -> DispatchResult {
+		Self::do_burn(*collection, *item, |d| {
+			if let Some(check_owner) = maybe_check_owner {
+				if &d.owner != check_owner {
+					return Err(Error::<T, I>::NoPermission.into())
+				}
+			}
+			Ok(())
+		})
+	}
+
+	fn set_attribute(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &[u8],
+		value: &[u8],
+	) -> DispatchResult {
+		Self::do_force_set_attribute(
+			None,
+			*collection,
+			Some(*item),
+			AttributeNamespace::Pallet,
+			Self::construct_attribute_key(key.to_vec())?,
+			Self::construct_attribute_value(value.to_vec())?,
+		)
+	}
+
+	fn set_typed_attribute<K: Encode, V: Encode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| {
+			value.using_encoded(|v| {
+				<Self as Mutate<T::AccountId, ItemConfig>>::set_attribute(collection, item, k, v)
+			})
+		})
+	}
+
+	fn set_collection_attribute(
+		collection: &Self::CollectionId,
+		key: &[u8],
+		value: &[u8],
+	) -> DispatchResult {
+		Self::do_force_set_attribute(
+			None,
+			*collection,
+			None,
+			AttributeNamespace::Pallet,
+			Self::construct_attribute_key(key.to_vec())?,
+			Self::construct_attribute_value(value.to_vec())?,
+		)
+	}
+
+	fn set_typed_collection_attribute<K: Encode, V: Encode>(
+		collection: &Self::CollectionId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| {
+			value.using_encoded(|v| {
+				<Self as Mutate<T::AccountId, ItemConfig>>::set_collection_attribute(
+					collection, k, v,
+				)
+			})
+		})
+	}
+
+	fn clear_attribute(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &[u8],
+	) -> DispatchResult {
+		Self::do_clear_attribute(
+			None,
+			*collection,
+			Some(*item),
+			AttributeNamespace::Pallet,
+			Self::construct_attribute_key(key.to_vec())?,
+		)
+	}
+
+	fn clear_typed_attribute<K: Encode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> DispatchResult {
+		key.using_encoded(|k| {
+			<Self as Mutate<T::AccountId, ItemConfig>>::clear_attribute(collection, item, k)
+		})
+	}
+
+	fn clear_collection_attribute(collection: &Self::CollectionId, key: &[u8]) -> DispatchResult {
+		Self::do_clear_attribute(
+			None,
+			*collection,
+			None,
+			AttributeNamespace::Pallet,
+			Self::construct_attribute_key(key.to_vec())?,
+		)
+	}
+
+	fn clear_typed_collection_attribute<K: Encode>(
+		collection: &Self::CollectionId,
+		key: &K,
+	) -> DispatchResult {
+		key.using_encoded(|k| {
+			<Self as Mutate<T::AccountId, ItemConfig>>::clear_collection_attribute(collection, k)
+		})
+	}
+}
+
+impl<T: Config<I>, I: 'static> Transfer<T::AccountId> for Pallet<T, I> {
+	fn transfer(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		destination: &T::AccountId,
+	) -> DispatchResult {
+		Self::do_transfer(*collection, *item, destination.clone(), |_, _| Ok(()))
+	}
+
+	fn disable_transfer(collection: &Self::CollectionId, item: &Self::ItemId) -> DispatchResult {
+		let transfer_disabled =
+			Self::has_system_attribute(&collection, &item, PalletAttributes::TransferDisabled)?;
+		// Can't lock the item twice
+		if transfer_disabled {
+			return Err(Error::<T, I>::ItemLocked.into())
+		}
+
+		<Self as Mutate<T::AccountId, ItemConfig>>::set_attribute(
+			collection,
+			item,
+			&PalletAttributes::<Self::CollectionId>::TransferDisabled.encode(),
+			&[],
+		)
+	}
+
+	fn enable_transfer(collection: &Self::CollectionId, item: &Self::ItemId) -> DispatchResult {
+		<Self as Mutate<T::AccountId, ItemConfig>>::clear_attribute(
+			collection,
+			item,
+			&PalletAttributes::<Self::CollectionId>::TransferDisabled.encode(),
+		)
+	}
+}
+
+impl<T: Config<I>, I: 'static> InspectEnumerable<T::AccountId> for Pallet<T, I> {
+	type CollectionsIterator = KeyPrefixIterator<<T as Config<I>>::CollectionId>;
+	type ItemsIterator = KeyPrefixIterator<<T as Config<I>>::ItemId>;
+	type OwnedIterator =
+		KeyPrefixIterator<(<T as Config<I>>::CollectionId, <T as Config<I>>::ItemId)>;
+	type OwnedInCollectionIterator = KeyPrefixIterator<<T as Config<I>>::ItemId>;
+
+	/// Returns an iterator of the collections in existence.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn collections() -> Self::CollectionsIterator {
+		Collection::<T, I>::iter_keys()
+	}
+
+	/// Returns an iterator of the items of a `collection` in existence.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn items(collection: &Self::CollectionId) -> Self::ItemsIterator {
+		Item::<T, I>::iter_key_prefix(collection)
+	}
+
+	/// Returns an iterator of the items of all collections owned by `who`.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn owned(who: &T::AccountId) -> Self::OwnedIterator {
+		Account::<T, I>::iter_key_prefix((who,))
+	}
+
+	/// Returns an iterator of the items of `collection` owned by `who`.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn owned_in_collection(
+		collection: &Self::CollectionId,
+		who: &T::AccountId,
+	) -> Self::OwnedInCollectionIterator {
+		Account::<T, I>::iter_key_prefix((who, collection))
+	}
+}
diff --git a/substrate/frame/nfts/src/lib.rs b/substrate/frame/nfts/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..92b27432ab215ced08a8dd92ddff40f3db38415f
--- /dev/null
+++ b/substrate/frame/nfts/src/lib.rs
@@ -0,0 +1,1901 @@
+// 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.
+
+//! # Nfts Module
+//!
+//! A simple, secure module for dealing with non-fungible items.
+//!
+//! ## Related Modules
+//!
+//! * [`System`](../frame_system/index.html)
+//! * [`Support`](../frame_support/index.html)
+
+#![recursion_limit = "256"]
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod migration;
+#[cfg(test)]
+pub mod mock;
+#[cfg(test)]
+mod tests;
+
+mod common_functions;
+/// A library providing the feature set of this pallet. It contains modules with helper methods that
+/// perform storage updates and checks required by this pallet's dispatchables. To use pallet level
+/// features, make sure to set appropriate bitflags for [`Config::Features`] in your runtime
+/// configuration trait.
+mod features;
+mod impl_nonfungibles;
+mod types;
+
+pub mod macros;
+pub mod weights;
+
+use codec::{Decode, Encode};
+use frame_support::traits::{
+	tokens::Locker, BalanceStatus::Reserved, Currency, EnsureOriginWithArg, Incrementable,
+	ReservableCurrency,
+};
+use frame_system::Config as SystemConfig;
+use sp_runtime::{
+	traits::{IdentifyAccount, Saturating, StaticLookup, Verify, Zero},
+	RuntimeDebug,
+};
+use sp_std::prelude::*;
+
+pub use pallet::*;
+pub use types::*;
+pub use weights::WeightInfo;
+
+/// The log target of this pallet.
+pub const LOG_TARGET: &'static str = "runtime::nfts";
+
+/// A type alias for the account ID type used in the dispatchable functions of this pallet.
+type AccountIdLookupOf<T> = <<T as SystemConfig>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{pallet_prelude::*, traits::ExistenceRequirement};
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[cfg(feature = "runtime-benchmarks")]
+	pub trait BenchmarkHelper<CollectionId, ItemId> {
+		fn collection(i: u16) -> CollectionId;
+		fn item(i: u16) -> ItemId;
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	impl<CollectionId: From<u16>, ItemId: From<u16>> BenchmarkHelper<CollectionId, ItemId> for () {
+		fn collection(i: u16) -> CollectionId {
+			i.into()
+		}
+		fn item(i: u16) -> ItemId {
+			i.into()
+		}
+	}
+
+	#[pallet::config]
+	/// The module configuration trait.
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Identifier for the collection of item.
+		///
+		/// SAFETY: The functions in the `Incrementable` trait are fallible. If the functions
+		/// of the implementation both return `None`, the automatic CollectionId generation
+		/// should not be used. So the `create` and `force_create` extrinsics and the
+		/// `create_collection` function will return an `UnknownCollection` Error. Instead use
+		/// the `create_collection_with_id` function. However, if the `Incrementable` trait
+		/// implementation has an incremental order, the `create_collection_with_id` function
+		/// should not be used as it can claim a value in the ID sequence.
+		type CollectionId: Member + Parameter + MaxEncodedLen + Copy + Incrementable;
+
+		/// The type used to identify a unique item within a collection.
+		type ItemId: Member + Parameter + MaxEncodedLen + Copy;
+
+		/// The currency mechanism, used for paying for reserves.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// The origin which may forcibly create or destroy an item or otherwise alter privileged
+		/// attributes.
+		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Standard collection creation is only allowed if the origin attempting it and the
+		/// collection are in this set.
+		type CreateOrigin: EnsureOriginWithArg<
+			Self::RuntimeOrigin,
+			Self::CollectionId,
+			Success = Self::AccountId,
+		>;
+
+		/// Locker trait to enable Locking mechanism downstream.
+		type Locker: Locker<Self::CollectionId, Self::ItemId>;
+
+		/// The basic amount of funds that must be reserved for collection.
+		#[pallet::constant]
+		type CollectionDeposit: Get<DepositBalanceOf<Self, I>>;
+
+		/// The basic amount of funds that must be reserved for an item.
+		#[pallet::constant]
+		type ItemDeposit: Get<DepositBalanceOf<Self, I>>;
+
+		/// The basic amount of funds that must be reserved when adding metadata to your item.
+		#[pallet::constant]
+		type MetadataDepositBase: Get<DepositBalanceOf<Self, I>>;
+
+		/// The basic amount of funds that must be reserved when adding an attribute to an item.
+		#[pallet::constant]
+		type AttributeDepositBase: Get<DepositBalanceOf<Self, I>>;
+
+		/// The additional funds that must be reserved for the number of bytes store in metadata,
+		/// either "normal" metadata or attribute metadata.
+		#[pallet::constant]
+		type DepositPerByte: Get<DepositBalanceOf<Self, I>>;
+
+		/// The maximum length of data stored on-chain.
+		#[pallet::constant]
+		type StringLimit: Get<u32>;
+
+		/// The maximum length of an attribute key.
+		#[pallet::constant]
+		type KeyLimit: Get<u32>;
+
+		/// The maximum length of an attribute value.
+		#[pallet::constant]
+		type ValueLimit: Get<u32>;
+
+		/// The maximum approvals an item could have.
+		#[pallet::constant]
+		type ApprovalsLimit: Get<u32>;
+
+		/// The maximum attributes approvals an item could have.
+		#[pallet::constant]
+		type ItemAttributesApprovalsLimit: Get<u32>;
+
+		/// The max number of tips a user could send.
+		#[pallet::constant]
+		type MaxTips: Get<u32>;
+
+		/// The max duration in blocks for deadlines.
+		#[pallet::constant]
+		type MaxDeadlineDuration: Get<BlockNumberFor<Self>>;
+
+		/// The max number of attributes a user could set per call.
+		#[pallet::constant]
+		type MaxAttributesPerCall: Get<u32>;
+
+		/// Disables some of pallet's features.
+		#[pallet::constant]
+		type Features: Get<PalletFeatures>;
+
+		/// Off-Chain signature type.
+		///
+		/// Can verify whether an `Self::OffchainPublic` created a signature.
+		type OffchainSignature: Verify<Signer = Self::OffchainPublic> + Parameter;
+
+		/// Off-Chain public key.
+		///
+		/// Must identify as an on-chain `Self::AccountId`.
+		type OffchainPublic: IdentifyAccount<AccountId = Self::AccountId>;
+
+		#[cfg(feature = "runtime-benchmarks")]
+		/// A set of helper functions for benchmarking.
+		type Helper: BenchmarkHelper<Self::CollectionId, Self::ItemId>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// Details of a collection.
+	#[pallet::storage]
+	pub type Collection<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		CollectionDetails<T::AccountId, DepositBalanceOf<T, I>>,
+	>;
+
+	/// The collection, if any, of which an account is willing to take ownership.
+	#[pallet::storage]
+	pub type OwnershipAcceptance<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, T::CollectionId>;
+
+	/// The items held by any given account; set out this way so that items owned by a single
+	/// account can be enumerated.
+	#[pallet::storage]
+	pub type Account<T: Config<I>, I: 'static = ()> = StorageNMap<
+		_,
+		(
+			NMapKey<Blake2_128Concat, T::AccountId>, // owner
+			NMapKey<Blake2_128Concat, T::CollectionId>,
+			NMapKey<Blake2_128Concat, T::ItemId>,
+		),
+		(),
+		OptionQuery,
+	>;
+
+	/// The collections owned by any given account; set out this way so that collections owned by
+	/// a single account can be enumerated.
+	#[pallet::storage]
+	pub type CollectionAccount<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		Blake2_128Concat,
+		T::CollectionId,
+		(),
+		OptionQuery,
+	>;
+
+	/// The items in existence and their ownership details.
+	#[pallet::storage]
+	/// Stores collection roles as per account.
+	pub type CollectionRoleOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::AccountId,
+		CollectionRoles,
+		OptionQuery,
+	>;
+
+	/// The items in existence and their ownership details.
+	#[pallet::storage]
+	pub type Item<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		ItemDetails<T::AccountId, ItemDepositOf<T, I>, ApprovalsOf<T, I>>,
+		OptionQuery,
+	>;
+
+	/// Metadata of a collection.
+	#[pallet::storage]
+	pub type CollectionMetadataOf<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		CollectionMetadata<DepositBalanceOf<T, I>, T::StringLimit>,
+		OptionQuery,
+	>;
+
+	/// Metadata of an item.
+	#[pallet::storage]
+	pub type ItemMetadataOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		ItemMetadata<ItemMetadataDepositOf<T, I>, T::StringLimit>,
+		OptionQuery,
+	>;
+
+	/// Attributes of a collection.
+	#[pallet::storage]
+	pub type Attribute<T: Config<I>, I: 'static = ()> = StorageNMap<
+		_,
+		(
+			NMapKey<Blake2_128Concat, T::CollectionId>,
+			NMapKey<Blake2_128Concat, Option<T::ItemId>>,
+			NMapKey<Blake2_128Concat, AttributeNamespace<T::AccountId>>,
+			NMapKey<Blake2_128Concat, BoundedVec<u8, T::KeyLimit>>,
+		),
+		(BoundedVec<u8, T::ValueLimit>, AttributeDepositOf<T, I>),
+		OptionQuery,
+	>;
+
+	/// A price of an item.
+	#[pallet::storage]
+	pub type ItemPriceOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		(ItemPrice<T, I>, Option<T::AccountId>),
+		OptionQuery,
+	>;
+
+	/// Item attribute approvals.
+	#[pallet::storage]
+	pub type ItemAttributesApprovalsOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		ItemAttributesApprovals<T, I>,
+		ValueQuery,
+	>;
+
+	/// Stores the `CollectionId` that is going to be used for the next collection.
+	/// This gets incremented whenever a new collection is created.
+	#[pallet::storage]
+	pub type NextCollectionId<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, T::CollectionId, OptionQuery>;
+
+	/// Handles all the pending swaps.
+	#[pallet::storage]
+	pub type PendingSwapOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		PendingSwap<
+			T::CollectionId,
+			T::ItemId,
+			PriceWithDirection<ItemPrice<T, I>>,
+			BlockNumberFor<T>,
+		>,
+		OptionQuery,
+	>;
+
+	/// Config of a collection.
+	#[pallet::storage]
+	pub type CollectionConfigOf<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, T::CollectionId, CollectionConfigFor<T, I>, OptionQuery>;
+
+	/// Config of an item.
+	#[pallet::storage]
+	pub type ItemConfigOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		ItemConfig,
+		OptionQuery,
+	>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A `collection` was created.
+		Created { collection: T::CollectionId, creator: T::AccountId, owner: T::AccountId },
+		/// A `collection` was force-created.
+		ForceCreated { collection: T::CollectionId, owner: T::AccountId },
+		/// A `collection` was destroyed.
+		Destroyed { collection: T::CollectionId },
+		/// An `item` was issued.
+		Issued { collection: T::CollectionId, item: T::ItemId, owner: T::AccountId },
+		/// An `item` was transferred.
+		Transferred {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			from: T::AccountId,
+			to: T::AccountId,
+		},
+		/// An `item` was destroyed.
+		Burned { collection: T::CollectionId, item: T::ItemId, owner: T::AccountId },
+		/// An `item` became non-transferable.
+		ItemTransferLocked { collection: T::CollectionId, item: T::ItemId },
+		/// An `item` became transferable.
+		ItemTransferUnlocked { collection: T::CollectionId, item: T::ItemId },
+		/// `item` metadata or attributes were locked.
+		ItemPropertiesLocked {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			lock_metadata: bool,
+			lock_attributes: bool,
+		},
+		/// Some `collection` was locked.
+		CollectionLocked { collection: T::CollectionId },
+		/// The owner changed.
+		OwnerChanged { collection: T::CollectionId, new_owner: T::AccountId },
+		/// The management team changed.
+		TeamChanged {
+			collection: T::CollectionId,
+			issuer: Option<T::AccountId>,
+			admin: Option<T::AccountId>,
+			freezer: Option<T::AccountId>,
+		},
+		/// An `item` of a `collection` has been approved by the `owner` for transfer by
+		/// a `delegate`.
+		TransferApproved {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			owner: T::AccountId,
+			delegate: T::AccountId,
+			deadline: Option<BlockNumberFor<T>>,
+		},
+		/// An approval for a `delegate` account to transfer the `item` of an item
+		/// `collection` was cancelled by its `owner`.
+		ApprovalCancelled {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			owner: T::AccountId,
+			delegate: T::AccountId,
+		},
+		/// All approvals of an item got cancelled.
+		AllApprovalsCancelled { collection: T::CollectionId, item: T::ItemId, owner: T::AccountId },
+		/// A `collection` has had its config changed by the `Force` origin.
+		CollectionConfigChanged { collection: T::CollectionId },
+		/// New metadata has been set for a `collection`.
+		CollectionMetadataSet { collection: T::CollectionId, data: BoundedVec<u8, T::StringLimit> },
+		/// Metadata has been cleared for a `collection`.
+		CollectionMetadataCleared { collection: T::CollectionId },
+		/// New metadata has been set for an item.
+		ItemMetadataSet {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			data: BoundedVec<u8, T::StringLimit>,
+		},
+		/// Metadata has been cleared for an item.
+		ItemMetadataCleared { collection: T::CollectionId, item: T::ItemId },
+		/// The deposit for a set of `item`s within a `collection` has been updated.
+		Redeposited { collection: T::CollectionId, successful_items: Vec<T::ItemId> },
+		/// New attribute metadata has been set for a `collection` or `item`.
+		AttributeSet {
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+			value: BoundedVec<u8, T::ValueLimit>,
+			namespace: AttributeNamespace<T::AccountId>,
+		},
+		/// Attribute metadata has been cleared for a `collection` or `item`.
+		AttributeCleared {
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+			namespace: AttributeNamespace<T::AccountId>,
+		},
+		/// A new approval to modify item attributes was added.
+		ItemAttributesApprovalAdded {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			delegate: T::AccountId,
+		},
+		/// A new approval to modify item attributes was removed.
+		ItemAttributesApprovalRemoved {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			delegate: T::AccountId,
+		},
+		/// Ownership acceptance has changed for an account.
+		OwnershipAcceptanceChanged { who: T::AccountId, maybe_collection: Option<T::CollectionId> },
+		/// Max supply has been set for a collection.
+		CollectionMaxSupplySet { collection: T::CollectionId, max_supply: u32 },
+		/// Mint settings for a collection had changed.
+		CollectionMintSettingsUpdated { collection: T::CollectionId },
+		/// Event gets emitted when the `NextCollectionId` gets incremented.
+		NextCollectionIdIncremented { next_id: Option<T::CollectionId> },
+		/// The price was set for the item.
+		ItemPriceSet {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			price: ItemPrice<T, I>,
+			whitelisted_buyer: Option<T::AccountId>,
+		},
+		/// The price for the item was removed.
+		ItemPriceRemoved { collection: T::CollectionId, item: T::ItemId },
+		/// An item was bought.
+		ItemBought {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			price: ItemPrice<T, I>,
+			seller: T::AccountId,
+			buyer: T::AccountId,
+		},
+		/// A tip was sent.
+		TipSent {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			sender: T::AccountId,
+			receiver: T::AccountId,
+			amount: DepositBalanceOf<T, I>,
+		},
+		/// An `item` swap intent was created.
+		SwapCreated {
+			offered_collection: T::CollectionId,
+			offered_item: T::ItemId,
+			desired_collection: T::CollectionId,
+			desired_item: Option<T::ItemId>,
+			price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+			deadline: BlockNumberFor<T>,
+		},
+		/// The swap was cancelled.
+		SwapCancelled {
+			offered_collection: T::CollectionId,
+			offered_item: T::ItemId,
+			desired_collection: T::CollectionId,
+			desired_item: Option<T::ItemId>,
+			price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+			deadline: BlockNumberFor<T>,
+		},
+		/// The swap has been claimed.
+		SwapClaimed {
+			sent_collection: T::CollectionId,
+			sent_item: T::ItemId,
+			sent_item_owner: T::AccountId,
+			received_collection: T::CollectionId,
+			received_item: T::ItemId,
+			received_item_owner: T::AccountId,
+			price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+			deadline: BlockNumberFor<T>,
+		},
+		/// New attributes have been set for an `item` of the `collection`.
+		PreSignedAttributesSet {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			namespace: AttributeNamespace<T::AccountId>,
+		},
+		/// A new attribute in the `Pallet` namespace was set for the `collection` or an `item`
+		/// within that `collection`.
+		PalletAttributeSet {
+			collection: T::CollectionId,
+			item: Option<T::ItemId>,
+			attribute: PalletAttributes<T::CollectionId>,
+			value: BoundedVec<u8, T::ValueLimit>,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// The signing account has no permission to do the operation.
+		NoPermission,
+		/// The given item ID is unknown.
+		UnknownCollection,
+		/// The item ID has already been used for an item.
+		AlreadyExists,
+		/// The approval had a deadline that expired, so the approval isn't valid anymore.
+		ApprovalExpired,
+		/// The owner turned out to be different to what was expected.
+		WrongOwner,
+		/// The witness data given does not match the current state of the chain.
+		BadWitness,
+		/// Collection ID is already taken.
+		CollectionIdInUse,
+		/// Items within that collection are non-transferable.
+		ItemsNonTransferable,
+		/// The provided account is not a delegate.
+		NotDelegate,
+		/// The delegate turned out to be different to what was expected.
+		WrongDelegate,
+		/// No approval exists that would allow the transfer.
+		Unapproved,
+		/// The named owner has not signed ownership acceptance of the collection.
+		Unaccepted,
+		/// The item is locked (non-transferable).
+		ItemLocked,
+		/// Item's attributes are locked.
+		LockedItemAttributes,
+		/// Collection's attributes are locked.
+		LockedCollectionAttributes,
+		/// Item's metadata is locked.
+		LockedItemMetadata,
+		/// Collection's metadata is locked.
+		LockedCollectionMetadata,
+		/// All items have been minted.
+		MaxSupplyReached,
+		/// The max supply is locked and can't be changed.
+		MaxSupplyLocked,
+		/// The provided max supply is less than the number of items a collection already has.
+		MaxSupplyTooSmall,
+		/// The given item ID is unknown.
+		UnknownItem,
+		/// Swap doesn't exist.
+		UnknownSwap,
+		/// The given item has no metadata set.
+		MetadataNotFound,
+		/// The provided attribute can't be found.
+		AttributeNotFound,
+		/// Item is not for sale.
+		NotForSale,
+		/// The provided bid is too low.
+		BidTooLow,
+		/// The item has reached its approval limit.
+		ReachedApprovalLimit,
+		/// The deadline has already expired.
+		DeadlineExpired,
+		/// The duration provided should be less than or equal to `MaxDeadlineDuration`.
+		WrongDuration,
+		/// The method is disabled by system settings.
+		MethodDisabled,
+		/// The provided setting can't be set.
+		WrongSetting,
+		/// Item's config already exists and should be equal to the provided one.
+		InconsistentItemConfig,
+		/// Config for a collection or an item can't be found.
+		NoConfig,
+		/// Some roles were not cleared.
+		RolesNotCleared,
+		/// Mint has not started yet.
+		MintNotStarted,
+		/// Mint has already ended.
+		MintEnded,
+		/// The provided Item was already used for claiming.
+		AlreadyClaimed,
+		/// The provided data is incorrect.
+		IncorrectData,
+		/// The extrinsic was sent by the wrong origin.
+		WrongOrigin,
+		/// The provided signature is incorrect.
+		WrongSignature,
+		/// The provided metadata might be too long.
+		IncorrectMetadata,
+		/// Can't set more attributes per one call.
+		MaxAttributesLimitReached,
+		/// The provided namespace isn't supported in this call.
+		WrongNamespace,
+		/// Can't delete non-empty collections.
+		CollectionNotEmpty,
+		/// The witness data should be provided.
+		WitnessRequired,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Issue a new collection of non-fungible items from a public origin.
+		///
+		/// This new collection has no items initially and its owner is the origin.
+		///
+		/// The origin must be Signed and the sender must have sufficient funds free.
+		///
+		/// `CollectionDeposit` funds of sender are reserved.
+		///
+		/// Parameters:
+		/// - `admin`: The admin of this collection. The admin is the initial address of each
+		/// member of the collection's admin team.
+		///
+		/// Emits `Created` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::create())]
+		pub fn create(
+			origin: OriginFor<T>,
+			admin: AccountIdLookupOf<T>,
+			config: CollectionConfigFor<T, I>,
+		) -> DispatchResult {
+			let collection = NextCollectionId::<T, I>::get()
+				.or(T::CollectionId::initial_value())
+				.ok_or(Error::<T, I>::UnknownCollection)?;
+
+			let owner = T::CreateOrigin::ensure_origin(origin, &collection)?;
+			let admin = T::Lookup::lookup(admin)?;
+
+			// DepositRequired can be disabled by calling the force_create() only
+			ensure!(
+				!config.has_disabled_setting(CollectionSetting::DepositRequired),
+				Error::<T, I>::WrongSetting
+			);
+
+			Self::do_create_collection(
+				collection,
+				owner.clone(),
+				admin.clone(),
+				config,
+				T::CollectionDeposit::get(),
+				Event::Created { collection, creator: owner, owner: admin },
+			)?;
+
+			Self::set_next_collection_id(collection);
+			Ok(())
+		}
+
+		/// Issue a new collection of non-fungible items from a privileged origin.
+		///
+		/// This new collection has no items initially.
+		///
+		/// The origin must conform to `ForceOrigin`.
+		///
+		/// Unlike `create`, no funds are reserved.
+		///
+		/// - `owner`: The owner of this collection of items. The owner has full superuser
+		///   permissions over this item, but may later change and configure the permissions using
+		///   `transfer_ownership` and `set_team`.
+		///
+		/// Emits `ForceCreated` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::force_create())]
+		pub fn force_create(
+			origin: OriginFor<T>,
+			owner: AccountIdLookupOf<T>,
+			config: CollectionConfigFor<T, I>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+
+			let collection = NextCollectionId::<T, I>::get()
+				.or(T::CollectionId::initial_value())
+				.ok_or(Error::<T, I>::UnknownCollection)?;
+
+			Self::do_create_collection(
+				collection,
+				owner.clone(),
+				owner.clone(),
+				config,
+				Zero::zero(),
+				Event::ForceCreated { collection, owner },
+			)?;
+
+			Self::set_next_collection_id(collection);
+			Ok(())
+		}
+
+		/// Destroy a collection of fungible items.
+		///
+		/// The origin must conform to `ForceOrigin` or must be `Signed` and the sender must be the
+		/// owner of the `collection`.
+		///
+		/// NOTE: The collection must have 0 items to be destroyed.
+		///
+		/// - `collection`: The identifier of the collection to be destroyed.
+		/// - `witness`: Information on the items minted in the collection. This must be
+		/// correct.
+		///
+		/// Emits `Destroyed` event when successful.
+		///
+		/// Weight: `O(m + c + a)` where:
+		/// - `m = witness.item_metadatas`
+		/// - `c = witness.item_configs`
+		/// - `a = witness.attributes`
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::destroy(
+			witness.item_metadatas,
+			witness.item_configs,
+			witness.attributes,
+ 		))]
+		pub fn destroy(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			witness: DestroyWitness,
+		) -> DispatchResultWithPostInfo {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			let details = Self::do_destroy_collection(collection, witness, maybe_check_owner)?;
+
+			Ok(Some(T::WeightInfo::destroy(
+				details.item_metadatas,
+				details.item_configs,
+				details.attributes,
+			))
+			.into())
+		}
+
+		/// Mint an item of a particular collection.
+		///
+		/// The origin must be Signed and the sender must comply with the `mint_settings` rules.
+		///
+		/// - `collection`: The collection of the item to be minted.
+		/// - `item`: An identifier of the new item.
+		/// - `mint_to`: Account into which the item will be minted.
+		/// - `witness_data`: When the mint type is `HolderOf(collection_id)`, then the owned
+		///   item_id from that collection needs to be provided within the witness data object. If
+		///   the mint price is set, then it should be additionally confirmed in the `witness_data`.
+		///
+		/// Note: the deposit will be taken from the `origin` and not the `owner` of the `item`.
+		///
+		/// Emits `Issued` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::mint())]
+		pub fn mint(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			mint_to: AccountIdLookupOf<T>,
+			witness_data: Option<MintWitness<T::ItemId, DepositBalanceOf<T, I>>>,
+		) -> DispatchResult {
+			let caller = ensure_signed(origin)?;
+			let mint_to = T::Lookup::lookup(mint_to)?;
+			let item_config =
+				ItemConfig { settings: Self::get_default_item_settings(&collection)? };
+
+			Self::do_mint(
+				collection,
+				item,
+				Some(caller.clone()),
+				mint_to.clone(),
+				item_config,
+				|collection_details, collection_config| {
+					let mint_settings = collection_config.mint_settings;
+					let now = frame_system::Pallet::<T>::block_number();
+
+					if let Some(start_block) = mint_settings.start_block {
+						ensure!(start_block <= now, Error::<T, I>::MintNotStarted);
+					}
+					if let Some(end_block) = mint_settings.end_block {
+						ensure!(end_block >= now, Error::<T, I>::MintEnded);
+					}
+
+					match mint_settings.mint_type {
+						MintType::Issuer => {
+							ensure!(
+								Self::has_role(&collection, &caller, CollectionRole::Issuer),
+								Error::<T, I>::NoPermission
+							);
+						},
+						MintType::HolderOf(collection_id) => {
+							let MintWitness { owned_item, .. } =
+								witness_data.clone().ok_or(Error::<T, I>::WitnessRequired)?;
+							let owned_item = owned_item.ok_or(Error::<T, I>::BadWitness)?;
+
+							let owns_item = Account::<T, I>::contains_key((
+								&caller,
+								&collection_id,
+								&owned_item,
+							));
+							ensure!(owns_item, Error::<T, I>::BadWitness);
+
+							let pallet_attribute =
+								PalletAttributes::<T::CollectionId>::UsedToClaim(collection);
+
+							let key = (
+								&collection_id,
+								Some(owned_item),
+								AttributeNamespace::Pallet,
+								&Self::construct_attribute_key(pallet_attribute.encode())?,
+							);
+							let already_claimed = Attribute::<T, I>::contains_key(key.clone());
+							ensure!(!already_claimed, Error::<T, I>::AlreadyClaimed);
+
+							let attribute_value = Self::construct_attribute_value(vec![])?;
+							Attribute::<T, I>::insert(
+								key,
+								(
+									attribute_value.clone(),
+									AttributeDeposit { account: None, amount: Zero::zero() },
+								),
+							);
+							Self::deposit_event(Event::PalletAttributeSet {
+								collection,
+								item: Some(item),
+								attribute: pallet_attribute,
+								value: attribute_value,
+							});
+						},
+						_ => {},
+					}
+
+					if let Some(price) = mint_settings.price {
+						let MintWitness { mint_price, .. } =
+							witness_data.clone().ok_or(Error::<T, I>::WitnessRequired)?;
+						let mint_price = mint_price.ok_or(Error::<T, I>::BadWitness)?;
+						ensure!(mint_price >= price, Error::<T, I>::BadWitness);
+						T::Currency::transfer(
+							&caller,
+							&collection_details.owner,
+							price,
+							ExistenceRequirement::KeepAlive,
+						)?;
+					}
+
+					Ok(())
+				},
+			)
+		}
+
+		/// Mint an item of a particular collection from a privileged origin.
+		///
+		/// The origin must conform to `ForceOrigin` or must be `Signed` and the sender must be the
+		/// Issuer of the `collection`.
+		///
+		/// - `collection`: The collection of the item to be minted.
+		/// - `item`: An identifier of the new item.
+		/// - `mint_to`: Account into which the item will be minted.
+		/// - `item_config`: A config of the new item.
+		///
+		/// Emits `Issued` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::force_mint())]
+		pub fn force_mint(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			mint_to: AccountIdLookupOf<T>,
+			item_config: ItemConfig,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			let mint_to = T::Lookup::lookup(mint_to)?;
+
+			if let Some(check_origin) = maybe_check_origin {
+				ensure!(
+					Self::has_role(&collection, &check_origin, CollectionRole::Issuer),
+					Error::<T, I>::NoPermission
+				);
+			}
+			Self::do_mint(collection, item, None, mint_to, item_config, |_, _| Ok(()))
+		}
+
+		/// Destroy a single item.
+		///
+		/// The origin must conform to `ForceOrigin` or must be Signed and the signing account must
+		/// be the owner of the `item`.
+		///
+		/// - `collection`: The collection of the item to be burned.
+		/// - `item`: The item to be burned.
+		///
+		/// Emits `Burned`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::burn())]
+		pub fn burn(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+
+			Self::do_burn(collection, item, |details| {
+				if let Some(check_origin) = maybe_check_origin {
+					ensure!(details.owner == check_origin, Error::<T, I>::NoPermission);
+				}
+				Ok(())
+			})
+		}
+
+		/// Move an item from the sender account to another.
+		///
+		/// Origin must be Signed and the signing account must be either:
+		/// - the Owner of the `item`;
+		/// - the approved delegate for the `item` (in this case, the approval is reset).
+		///
+		/// Arguments:
+		/// - `collection`: The collection of the item to be transferred.
+		/// - `item`: The item to be transferred.
+		/// - `dest`: The account to receive ownership of the item.
+		///
+		/// Emits `Transferred`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::transfer())]
+		pub fn transfer(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			dest: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let dest = T::Lookup::lookup(dest)?;
+
+			Self::do_transfer(collection, item, dest, |_, details| {
+				if details.owner != origin {
+					let deadline =
+						details.approvals.get(&origin).ok_or(Error::<T, I>::NoPermission)?;
+					if let Some(d) = deadline {
+						let block_number = frame_system::Pallet::<T>::block_number();
+						ensure!(block_number <= *d, Error::<T, I>::ApprovalExpired);
+					}
+				}
+				Ok(())
+			})
+		}
+
+		/// Re-evaluate the deposits on some items.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the `collection`.
+		///
+		/// - `collection`: The collection of the items to be reevaluated.
+		/// - `items`: The items of the collection whose deposits will be reevaluated.
+		///
+		/// NOTE: This exists as a best-effort function. Any items which are unknown or
+		/// in the case that the owner account does not have reservable funds to pay for a
+		/// deposit increase are ignored. Generally the owner isn't going to call this on items
+		/// whose existing deposit is less than the refreshed deposit as it would only cost them,
+		/// so it's of little consequence.
+		///
+		/// It will still return an error in the case that the collection is unknown or the signer
+		/// is not permitted to call it.
+		///
+		/// Weight: `O(items.len())`
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::redeposit(items.len() as u32))]
+		pub fn redeposit(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			items: Vec<T::ItemId>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+
+			let collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			ensure!(collection_details.owner == origin, Error::<T, I>::NoPermission);
+
+			let config = Self::get_collection_config(&collection)?;
+			let deposit = match config.is_setting_enabled(CollectionSetting::DepositRequired) {
+				true => T::ItemDeposit::get(),
+				false => Zero::zero(),
+			};
+
+			let mut successful = Vec::with_capacity(items.len());
+			for item in items.into_iter() {
+				let mut details = match Item::<T, I>::get(&collection, &item) {
+					Some(x) => x,
+					None => continue,
+				};
+				let old = details.deposit.amount;
+				if old > deposit {
+					T::Currency::unreserve(&details.deposit.account, old - deposit);
+				} else if deposit > old {
+					if T::Currency::reserve(&details.deposit.account, deposit - old).is_err() {
+						// NOTE: No alterations made to collection_details in this iteration so far,
+						// so this is OK to do.
+						continue
+					}
+				} else {
+					continue
+				}
+				details.deposit.amount = deposit;
+				Item::<T, I>::insert(&collection, &item, &details);
+				successful.push(item);
+			}
+
+			Self::deposit_event(Event::<T, I>::Redeposited {
+				collection,
+				successful_items: successful,
+			});
+
+			Ok(())
+		}
+
+		/// Disallow further unprivileged transfer of an item.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the `collection`.
+		///
+		/// - `collection`: The collection of the item to be changed.
+		/// - `item`: The item to become non-transferable.
+		///
+		/// Emits `ItemTransferLocked`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::lock_item_transfer())]
+		pub fn lock_item_transfer(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_lock_item_transfer(origin, collection, item)
+		}
+
+		/// Re-allow unprivileged transfer of an item.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the `collection`.
+		///
+		/// - `collection`: The collection of the item to be changed.
+		/// - `item`: The item to become transferable.
+		///
+		/// Emits `ItemTransferUnlocked`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::unlock_item_transfer())]
+		pub fn unlock_item_transfer(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_unlock_item_transfer(origin, collection, item)
+		}
+
+		/// Disallows specified settings for the whole collection.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the `collection`.
+		///
+		/// - `collection`: The collection to be locked.
+		/// - `lock_settings`: The settings to be locked.
+		///
+		/// Note: it's possible to only lock(set) the setting, but not to unset it.
+		///
+		/// Emits `CollectionLocked`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::lock_collection())]
+		pub fn lock_collection(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			lock_settings: CollectionSettings,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_lock_collection(origin, collection, lock_settings)
+		}
+
+		/// Change the Owner of a collection.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the `collection`.
+		///
+		/// - `collection`: The collection whose owner should be changed.
+		/// - `owner`: The new Owner of this collection. They must have called
+		///   `set_accept_ownership` with `collection` in order for this operation to succeed.
+		///
+		/// Emits `OwnerChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::transfer_ownership())]
+		pub fn transfer_ownership(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			owner: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+			Self::do_transfer_ownership(origin, collection, owner)
+		}
+
+		/// Change the Issuer, Admin and Freezer of a collection.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
+		/// `collection`.
+		///
+		/// Note: by setting the role to `None` only the `ForceOrigin` will be able to change it
+		/// after to `Some(account)`.
+		///
+		/// - `collection`: The collection whose team should be changed.
+		/// - `issuer`: The new Issuer of this collection.
+		/// - `admin`: The new Admin of this collection.
+		/// - `freezer`: The new Freezer of this collection.
+		///
+		/// Emits `TeamChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::set_team())]
+		pub fn set_team(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			issuer: Option<AccountIdLookupOf<T>>,
+			admin: Option<AccountIdLookupOf<T>>,
+			freezer: Option<AccountIdLookupOf<T>>,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			let issuer = issuer.map(T::Lookup::lookup).transpose()?;
+			let admin = admin.map(T::Lookup::lookup).transpose()?;
+			let freezer = freezer.map(T::Lookup::lookup).transpose()?;
+			Self::do_set_team(maybe_check_owner, collection, issuer, admin, freezer)
+		}
+
+		/// Change the Owner of a collection.
+		///
+		/// Origin must be `ForceOrigin`.
+		///
+		/// - `collection`: The identifier of the collection.
+		/// - `owner`: The new Owner of this collection.
+		///
+		/// Emits `OwnerChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(13)]
+		#[pallet::weight(T::WeightInfo::force_collection_owner())]
+		pub fn force_collection_owner(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			owner: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			let new_owner = T::Lookup::lookup(owner)?;
+			Self::do_force_collection_owner(collection, new_owner)
+		}
+
+		/// Change the config of a collection.
+		///
+		/// Origin must be `ForceOrigin`.
+		///
+		/// - `collection`: The identifier of the collection.
+		/// - `config`: The new config of this collection.
+		///
+		/// Emits `CollectionConfigChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(14)]
+		#[pallet::weight(T::WeightInfo::force_collection_config())]
+		pub fn force_collection_config(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			config: CollectionConfigFor<T, I>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			Self::do_force_collection_config(collection, config)
+		}
+
+		/// Approve an item to be transferred by a delegated third-party account.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
+		/// `item`.
+		///
+		/// - `collection`: The collection of the item to be approved for delegated transfer.
+		/// - `item`: The item to be approved for delegated transfer.
+		/// - `delegate`: The account to delegate permission to transfer the item.
+		/// - `maybe_deadline`: Optional deadline for the approval. Specified by providing the
+		/// 	number of blocks after which the approval will expire
+		///
+		/// Emits `TransferApproved` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(15)]
+		#[pallet::weight(T::WeightInfo::approve_transfer())]
+		pub fn approve_transfer(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			delegate: AccountIdLookupOf<T>,
+			maybe_deadline: Option<BlockNumberFor<T>>,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			Self::do_approve_transfer(
+				maybe_check_origin,
+				collection,
+				item,
+				delegate,
+				maybe_deadline,
+			)
+		}
+
+		/// Cancel one of the transfer approvals for a specific item.
+		///
+		/// Origin must be either:
+		/// - the `Force` origin;
+		/// - `Signed` with the signer being the Owner of the `item`;
+		///
+		/// Arguments:
+		/// - `collection`: The collection of the item of whose approval will be cancelled.
+		/// - `item`: The item of the collection of whose approval will be cancelled.
+		/// - `delegate`: The account that is going to loose their approval.
+		///
+		/// Emits `ApprovalCancelled` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(16)]
+		#[pallet::weight(T::WeightInfo::cancel_approval())]
+		pub fn cancel_approval(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			delegate: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			Self::do_cancel_approval(maybe_check_origin, collection, item, delegate)
+		}
+
+		/// Cancel all the approvals of a specific item.
+		///
+		/// Origin must be either:
+		/// - the `Force` origin;
+		/// - `Signed` with the signer being the Owner of the `item`;
+		///
+		/// Arguments:
+		/// - `collection`: The collection of the item of whose approvals will be cleared.
+		/// - `item`: The item of the collection of whose approvals will be cleared.
+		///
+		/// Emits `AllApprovalsCancelled` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(17)]
+		#[pallet::weight(T::WeightInfo::clear_all_transfer_approvals())]
+		pub fn clear_all_transfer_approvals(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_clear_all_transfer_approvals(maybe_check_origin, collection, item)
+		}
+
+		/// Disallows changing the metadata or attributes of the item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Admin
+		/// of the `collection`.
+		///
+		/// - `collection`: The collection if the `item`.
+		/// - `item`: An item to be locked.
+		/// - `lock_metadata`: Specifies whether the metadata should be locked.
+		/// - `lock_attributes`: Specifies whether the attributes in the `CollectionOwner` namespace
+		///   should be locked.
+		///
+		/// Note: `lock_attributes` affects the attributes in the `CollectionOwner` namespace only.
+		/// When the metadata or attributes are locked, it won't be possible the unlock them.
+		///
+		/// Emits `ItemPropertiesLocked`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(18)]
+		#[pallet::weight(T::WeightInfo::lock_item_properties())]
+		pub fn lock_item_properties(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			lock_metadata: bool,
+			lock_attributes: bool,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_lock_item_properties(
+				maybe_check_origin,
+				collection,
+				item,
+				lock_metadata,
+				lock_attributes,
+			)
+		}
+
+		/// Set an attribute for a collection or item.
+		///
+		/// Origin must be Signed and must conform to the namespace ruleset:
+		/// - `CollectionOwner` namespace could be modified by the `collection` Admin only;
+		/// - `ItemOwner` namespace could be modified by the `maybe_item` owner only. `maybe_item`
+		///   should be set in that case;
+		/// - `Account(AccountId)` namespace could be modified only when the `origin` was given a
+		///   permission to do so;
+		///
+		/// The funds of `origin` are reserved according to the formula:
+		/// `AttributeDepositBase + DepositPerByte * (key.len + value.len)` taking into
+		/// account any already reserved funds.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to set.
+		/// - `maybe_item`: The identifier of the item whose metadata to set.
+		/// - `namespace`: Attribute's namespace.
+		/// - `key`: The key of the attribute.
+		/// - `value`: The value to which to set the attribute.
+		///
+		/// Emits `AttributeSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(19)]
+		#[pallet::weight(T::WeightInfo::set_attribute())]
+		pub fn set_attribute(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			namespace: AttributeNamespace<T::AccountId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+			value: BoundedVec<u8, T::ValueLimit>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let depositor = match namespace {
+				AttributeNamespace::CollectionOwner =>
+					Self::collection_owner(collection).ok_or(Error::<T, I>::UnknownCollection)?,
+				_ => origin.clone(),
+			};
+			Self::do_set_attribute(origin, collection, maybe_item, namespace, key, value, depositor)
+		}
+
+		/// Force-set an attribute for a collection or item.
+		///
+		/// Origin must be `ForceOrigin`.
+		///
+		/// If the attribute already exists and it was set by another account, the deposit
+		/// will be returned to the previous owner.
+		///
+		/// - `set_as`: An optional owner of the attribute.
+		/// - `collection`: The identifier of the collection whose item's metadata to set.
+		/// - `maybe_item`: The identifier of the item whose metadata to set.
+		/// - `namespace`: Attribute's namespace.
+		/// - `key`: The key of the attribute.
+		/// - `value`: The value to which to set the attribute.
+		///
+		/// Emits `AttributeSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(20)]
+		#[pallet::weight(T::WeightInfo::force_set_attribute())]
+		pub fn force_set_attribute(
+			origin: OriginFor<T>,
+			set_as: Option<T::AccountId>,
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			namespace: AttributeNamespace<T::AccountId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+			value: BoundedVec<u8, T::ValueLimit>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			Self::do_force_set_attribute(set_as, collection, maybe_item, namespace, key, value)
+		}
+
+		/// Clear an attribute for a collection or item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
+		/// attribute.
+		///
+		/// Any deposit is freed for the collection's owner.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to clear.
+		/// - `maybe_item`: The identifier of the item whose metadata to clear.
+		/// - `namespace`: Attribute's namespace.
+		/// - `key`: The key of the attribute.
+		///
+		/// Emits `AttributeCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(21)]
+		#[pallet::weight(T::WeightInfo::clear_attribute())]
+		pub fn clear_attribute(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			namespace: AttributeNamespace<T::AccountId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_clear_attribute(maybe_check_owner, collection, maybe_item, namespace, key)
+		}
+
+		/// Approve item's attributes to be changed by a delegated third-party account.
+		///
+		/// Origin must be Signed and must be an owner of the `item`.
+		///
+		/// - `collection`: A collection of the item.
+		/// - `item`: The item that holds attributes.
+		/// - `delegate`: The account to delegate permission to change attributes of the item.
+		///
+		/// Emits `ItemAttributesApprovalAdded` on success.
+		#[pallet::call_index(22)]
+		#[pallet::weight(T::WeightInfo::approve_item_attributes())]
+		pub fn approve_item_attributes(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			delegate: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			Self::do_approve_item_attributes(origin, collection, item, delegate)
+		}
+
+		/// Cancel the previously provided approval to change item's attributes.
+		/// All the previously set attributes by the `delegate` will be removed.
+		///
+		/// Origin must be Signed and must be an owner of the `item`.
+		///
+		/// - `collection`: Collection that the item is contained within.
+		/// - `item`: The item that holds attributes.
+		/// - `delegate`: The previously approved account to remove.
+		///
+		/// Emits `ItemAttributesApprovalRemoved` on success.
+		#[pallet::call_index(23)]
+		#[pallet::weight(T::WeightInfo::cancel_item_attributes_approval(
+			witness.account_attributes
+		))]
+		pub fn cancel_item_attributes_approval(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			delegate: AccountIdLookupOf<T>,
+			witness: CancelAttributesApprovalWitness,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			Self::do_cancel_item_attributes_approval(origin, collection, item, delegate, witness)
+		}
+
+		/// Set the metadata for an item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Admin of the
+		/// `collection`.
+		///
+		/// If the origin is Signed, then funds of signer are reserved according to the formula:
+		/// `MetadataDepositBase + DepositPerByte * data.len` taking into
+		/// account any already reserved funds.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to set.
+		/// - `item`: The identifier of the item whose metadata to set.
+		/// - `data`: The general information of this item. Limited in length by `StringLimit`.
+		///
+		/// Emits `ItemMetadataSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(24)]
+		#[pallet::weight(T::WeightInfo::set_metadata())]
+		pub fn set_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			data: BoundedVec<u8, T::StringLimit>,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_set_item_metadata(maybe_check_origin, collection, item, data, None)
+		}
+
+		/// Clear the metadata for an item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Admin of the
+		/// `collection`.
+		///
+		/// Any deposit is freed for the collection's owner.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to clear.
+		/// - `item`: The identifier of the item whose metadata to clear.
+		///
+		/// Emits `ItemMetadataCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(25)]
+		#[pallet::weight(T::WeightInfo::clear_metadata())]
+		pub fn clear_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_clear_item_metadata(maybe_check_origin, collection, item)
+		}
+
+		/// Set the metadata for a collection.
+		///
+		/// Origin must be either `ForceOrigin` or `Signed` and the sender should be the Admin of
+		/// the `collection`.
+		///
+		/// If the origin is `Signed`, then funds of signer are reserved according to the formula:
+		/// `MetadataDepositBase + DepositPerByte * data.len` taking into
+		/// account any already reserved funds.
+		///
+		/// - `collection`: The identifier of the item whose metadata to update.
+		/// - `data`: The general information of this item. Limited in length by `StringLimit`.
+		///
+		/// Emits `CollectionMetadataSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(26)]
+		#[pallet::weight(T::WeightInfo::set_collection_metadata())]
+		pub fn set_collection_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			data: BoundedVec<u8, T::StringLimit>,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_set_collection_metadata(maybe_check_origin, collection, data)
+		}
+
+		/// Clear the metadata for a collection.
+		///
+		/// Origin must be either `ForceOrigin` or `Signed` and the sender should be the Admin of
+		/// the `collection`.
+		///
+		/// Any deposit is freed for the collection's owner.
+		///
+		/// - `collection`: The identifier of the collection whose metadata to clear.
+		///
+		/// Emits `CollectionMetadataCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(27)]
+		#[pallet::weight(T::WeightInfo::clear_collection_metadata())]
+		pub fn clear_collection_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_clear_collection_metadata(maybe_check_origin, collection)
+		}
+
+		/// Set (or reset) the acceptance of ownership for a particular account.
+		///
+		/// Origin must be `Signed` and if `maybe_collection` is `Some`, then the signer must have a
+		/// provider reference.
+		///
+		/// - `maybe_collection`: The identifier of the collection whose ownership the signer is
+		///   willing to accept, or if `None`, an indication that the signer is willing to accept no
+		///   ownership transferal.
+		///
+		/// Emits `OwnershipAcceptanceChanged`.
+		#[pallet::call_index(28)]
+		#[pallet::weight(T::WeightInfo::set_accept_ownership())]
+		pub fn set_accept_ownership(
+			origin: OriginFor<T>,
+			maybe_collection: Option<T::CollectionId>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_set_accept_ownership(who, maybe_collection)
+		}
+
+		/// Set the maximum number of items a collection could have.
+		///
+		/// Origin must be either `ForceOrigin` or `Signed` and the sender should be the Owner of
+		/// the `collection`.
+		///
+		/// - `collection`: The identifier of the collection to change.
+		/// - `max_supply`: The maximum number of items a collection could have.
+		///
+		/// Emits `CollectionMaxSupplySet` event when successful.
+		#[pallet::call_index(29)]
+		#[pallet::weight(T::WeightInfo::set_collection_max_supply())]
+		pub fn set_collection_max_supply(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			max_supply: u32,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_set_collection_max_supply(maybe_check_owner, collection, max_supply)
+		}
+
+		/// Update mint settings.
+		///
+		/// Origin must be either `ForceOrigin` or `Signed` and the sender should be the Issuer
+		/// of the `collection`.
+		///
+		/// - `collection`: The identifier of the collection to change.
+		/// - `mint_settings`: The new mint settings.
+		///
+		/// Emits `CollectionMintSettingsUpdated` event when successful.
+		#[pallet::call_index(30)]
+		#[pallet::weight(T::WeightInfo::update_mint_settings())]
+		pub fn update_mint_settings(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			mint_settings: MintSettings<BalanceOf<T, I>, BlockNumberFor<T>, T::CollectionId>,
+		) -> DispatchResult {
+			let maybe_check_origin = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+			Self::do_update_mint_settings(maybe_check_origin, collection, mint_settings)
+		}
+
+		/// Set (or reset) the price for an item.
+		///
+		/// Origin must be Signed and must be the owner of the `item`.
+		///
+		/// - `collection`: The collection of the item.
+		/// - `item`: The item to set the price for.
+		/// - `price`: The price for the item. Pass `None`, to reset the price.
+		/// - `buyer`: Restricts the buy operation to a specific account.
+		///
+		/// Emits `ItemPriceSet` on success if the price is not `None`.
+		/// Emits `ItemPriceRemoved` on success if the price is `None`.
+		#[pallet::call_index(31)]
+		#[pallet::weight(T::WeightInfo::set_price())]
+		pub fn set_price(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			price: Option<ItemPrice<T, I>>,
+			whitelisted_buyer: Option<AccountIdLookupOf<T>>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let whitelisted_buyer = whitelisted_buyer.map(T::Lookup::lookup).transpose()?;
+			Self::do_set_price(collection, item, origin, price, whitelisted_buyer)
+		}
+
+		/// Allows to buy an item if it's up for sale.
+		///
+		/// Origin must be Signed and must not be the owner of the `item`.
+		///
+		/// - `collection`: The collection of the item.
+		/// - `item`: The item the sender wants to buy.
+		/// - `bid_price`: The price the sender is willing to pay.
+		///
+		/// Emits `ItemBought` on success.
+		#[pallet::call_index(32)]
+		#[pallet::weight(T::WeightInfo::buy_item())]
+		pub fn buy_item(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			bid_price: ItemPrice<T, I>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_buy_item(collection, item, origin, bid_price)
+		}
+
+		/// Allows to pay the tips.
+		///
+		/// Origin must be Signed.
+		///
+		/// - `tips`: Tips array.
+		///
+		/// Emits `TipSent` on every tip transfer.
+		#[pallet::call_index(33)]
+		#[pallet::weight(T::WeightInfo::pay_tips(tips.len() as u32))]
+		pub fn pay_tips(
+			origin: OriginFor<T>,
+			tips: BoundedVec<ItemTipOf<T, I>, T::MaxTips>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_pay_tips(origin, tips)
+		}
+
+		/// Register a new atomic swap, declaring an intention to send an `item` in exchange for
+		/// `desired_item` from origin to target on the current blockchain.
+		/// The target can execute the swap during the specified `duration` of blocks (if set).
+		/// Additionally, the price could be set for the desired `item`.
+		///
+		/// Origin must be Signed and must be an owner of the `item`.
+		///
+		/// - `collection`: The collection of the item.
+		/// - `item`: The item an owner wants to give.
+		/// - `desired_collection`: The collection of the desired item.
+		/// - `desired_item`: The desired item an owner wants to receive.
+		/// - `maybe_price`: The price an owner is willing to pay or receive for the desired `item`.
+		/// - `duration`: A deadline for the swap. Specified by providing the number of blocks
+		/// 	after which the swap will expire.
+		///
+		/// Emits `SwapCreated` on success.
+		#[pallet::call_index(34)]
+		#[pallet::weight(T::WeightInfo::create_swap())]
+		pub fn create_swap(
+			origin: OriginFor<T>,
+			offered_collection: T::CollectionId,
+			offered_item: T::ItemId,
+			desired_collection: T::CollectionId,
+			maybe_desired_item: Option<T::ItemId>,
+			maybe_price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+			duration: BlockNumberFor<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_create_swap(
+				origin,
+				offered_collection,
+				offered_item,
+				desired_collection,
+				maybe_desired_item,
+				maybe_price,
+				duration,
+			)
+		}
+
+		/// Cancel an atomic swap.
+		///
+		/// Origin must be Signed.
+		/// Origin must be an owner of the `item` if the deadline hasn't expired.
+		///
+		/// - `collection`: The collection of the item.
+		/// - `item`: The item an owner wants to give.
+		///
+		/// Emits `SwapCancelled` on success.
+		#[pallet::call_index(35)]
+		#[pallet::weight(T::WeightInfo::cancel_swap())]
+		pub fn cancel_swap(
+			origin: OriginFor<T>,
+			offered_collection: T::CollectionId,
+			offered_item: T::ItemId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_cancel_swap(origin, offered_collection, offered_item)
+		}
+
+		/// Claim an atomic swap.
+		/// This method executes a pending swap, that was created by a counterpart before.
+		///
+		/// Origin must be Signed and must be an owner of the `item`.
+		///
+		/// - `send_collection`: The collection of the item to be sent.
+		/// - `send_item`: The item to be sent.
+		/// - `receive_collection`: The collection of the item to be received.
+		/// - `receive_item`: The item to be received.
+		/// - `witness_price`: A price that was previously agreed on.
+		///
+		/// Emits `SwapClaimed` on success.
+		#[pallet::call_index(36)]
+		#[pallet::weight(T::WeightInfo::claim_swap())]
+		pub fn claim_swap(
+			origin: OriginFor<T>,
+			send_collection: T::CollectionId,
+			send_item: T::ItemId,
+			receive_collection: T::CollectionId,
+			receive_item: T::ItemId,
+			witness_price: Option<PriceWithDirection<ItemPrice<T, I>>>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_claim_swap(
+				origin,
+				send_collection,
+				send_item,
+				receive_collection,
+				receive_item,
+				witness_price,
+			)
+		}
+
+		/// Mint an item by providing the pre-signed approval.
+		///
+		/// Origin must be Signed.
+		///
+		/// - `mint_data`: The pre-signed approval that consists of the information about the item,
+		///   its metadata, attributes, who can mint it (`None` for anyone) and until what block
+		///   number.
+		/// - `signature`: The signature of the `data` object.
+		/// - `signer`: The `data` object's signer. Should be an Issuer of the collection.
+		///
+		/// Emits `Issued` on success.
+		/// Emits `AttributeSet` if the attributes were provided.
+		/// Emits `ItemMetadataSet` if the metadata was not empty.
+		#[pallet::call_index(37)]
+		#[pallet::weight(T::WeightInfo::mint_pre_signed(mint_data.attributes.len() as u32))]
+		pub fn mint_pre_signed(
+			origin: OriginFor<T>,
+			mint_data: Box<PreSignedMintOf<T, I>>,
+			signature: T::OffchainSignature,
+			signer: T::AccountId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::validate_signature(&Encode::encode(&mint_data), &signature, &signer)?;
+			Self::do_mint_pre_signed(origin, *mint_data, signer)
+		}
+
+		/// Set attributes for an item by providing the pre-signed approval.
+		///
+		/// Origin must be Signed and must be an owner of the `data.item`.
+		///
+		/// - `data`: The pre-signed approval that consists of the information about the item,
+		///   attributes to update and until what block number.
+		/// - `signature`: The signature of the `data` object.
+		/// - `signer`: The `data` object's signer. Should be an Admin of the collection for the
+		///   `CollectionOwner` namespace.
+		///
+		/// Emits `AttributeSet` for each provided attribute.
+		/// Emits `ItemAttributesApprovalAdded` if the approval wasn't set before.
+		/// Emits `PreSignedAttributesSet` on success.
+		#[pallet::call_index(38)]
+		#[pallet::weight(T::WeightInfo::set_attributes_pre_signed(data.attributes.len() as u32))]
+		pub fn set_attributes_pre_signed(
+			origin: OriginFor<T>,
+			data: PreSignedAttributesOf<T, I>,
+			signature: T::OffchainSignature,
+			signer: T::AccountId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::validate_signature(&Encode::encode(&data), &signature, &signer)?;
+			Self::do_set_attributes_pre_signed(origin, data, signer)
+		}
+	}
+}
+
+sp_core::generate_feature_enabled_macro!(runtime_benchmarks_enabled, feature = "runtime-benchmarks", $);
diff --git a/substrate/frame/nfts/src/macros.rs b/substrate/frame/nfts/src/macros.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1a601ce0927fa2f4c3cfae880d91e892e83d62fd
--- /dev/null
+++ b/substrate/frame/nfts/src/macros.rs
@@ -0,0 +1,66 @@
+// 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.
+
+/// Implements encoding and decoding traits for a wrapper type that represents
+/// bitflags. The wrapper type should contain a field of type `$size`, where
+/// `$size` is an integer type (e.g., u8, u16, u32) that can represent the bitflags.
+/// The `$bitflag_enum` type is the enumeration type that defines the individual bitflags.
+///
+/// This macro provides implementations for the following traits:
+/// - `MaxEncodedLen`: Calculates the maximum encoded length for the wrapper type.
+/// - `Encode`: Encodes the wrapper type using the provided encoding function.
+/// - `EncodeLike`: Trait indicating the type can be encoded as is.
+/// - `Decode`: Decodes the wrapper type from the input.
+/// - `TypeInfo`: Provides type information for the wrapper type.
+macro_rules! impl_codec_bitflags {
+	($wrapper:ty, $size:ty, $bitflag_enum:ty) => {
+		impl MaxEncodedLen for $wrapper {
+			fn max_encoded_len() -> usize {
+				<$size>::max_encoded_len()
+			}
+		}
+		impl Encode for $wrapper {
+			fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+				self.0.bits().using_encoded(f)
+			}
+		}
+		impl EncodeLike for $wrapper {}
+		impl Decode for $wrapper {
+			fn decode<I: codec::Input>(
+				input: &mut I,
+			) -> sp_std::result::Result<Self, codec::Error> {
+				let field = <$size>::decode(input)?;
+				Ok(Self(BitFlags::from_bits(field as $size).map_err(|_| "invalid value")?))
+			}
+		}
+
+		impl TypeInfo for $wrapper {
+			type Identity = Self;
+
+			fn type_info() -> Type {
+				Type::builder()
+					.path(Path::new("BitFlags", module_path!()))
+					.type_params(vec![TypeParameter::new("T", Some(meta_type::<$bitflag_enum>()))])
+					.composite(
+						Fields::unnamed()
+							.field(|f| f.ty::<$size>().type_name(stringify!($bitflag_enum))),
+					)
+			}
+		}
+	};
+}
+pub(crate) use impl_codec_bitflags;
diff --git a/substrate/frame/nfts/src/migration.rs b/substrate/frame/nfts/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f90d332062a2cbd1f12e629518847394598efdb7
--- /dev/null
+++ b/substrate/frame/nfts/src/migration.rs
@@ -0,0 +1,123 @@
+// 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::OnRuntimeUpgrade;
+use log;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+pub mod v1 {
+	use frame_support::{pallet_prelude::*, weights::Weight};
+
+	use super::*;
+
+	#[derive(Decode)]
+	pub struct OldCollectionDetails<AccountId, DepositBalance> {
+		pub owner: AccountId,
+		pub owner_deposit: DepositBalance,
+		pub items: u32,
+		pub item_metadatas: u32,
+		pub attributes: u32,
+	}
+
+	impl<AccountId, DepositBalance> OldCollectionDetails<AccountId, DepositBalance> {
+		/// Migrates the old collection details to the new v1 format.
+		fn migrate_to_v1(self, item_configs: u32) -> CollectionDetails<AccountId, DepositBalance> {
+			CollectionDetails {
+				owner: self.owner,
+				owner_deposit: self.owner_deposit,
+				items: self.items,
+				item_metadatas: self.item_metadatas,
+				item_configs,
+				attributes: self.attributes,
+			}
+		}
+	}
+
+	/// A migration utility to update the storage version from v0 to v1 for the pallet.
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current_version = Pallet::<T>::current_storage_version();
+			let onchain_version = Pallet::<T>::on_chain_storage_version();
+
+			log::info!(
+				target: LOG_TARGET,
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current_version,
+				onchain_version
+			);
+
+			if onchain_version == 0 && current_version == 1 {
+				let mut translated = 0u64;
+				let mut configs_iterated = 0u64;
+				Collection::<T>::translate::<
+					OldCollectionDetails<T::AccountId, DepositBalanceOf<T>>,
+					_,
+				>(|key, old_value| {
+					let item_configs = ItemConfigOf::<T>::iter_prefix(&key).count() as u32;
+					configs_iterated += item_configs as u64;
+					translated.saturating_inc();
+					Some(old_value.migrate_to_v1(item_configs))
+				});
+
+				current_version.put::<Pallet<T>>();
+
+				log::info!(
+					target: LOG_TARGET,
+					"Upgraded {} records, storage to version {:?}",
+					translated,
+					current_version
+				);
+				T::DbWeight::get().reads_writes(translated + configs_iterated + 1, translated + 1)
+			} else {
+				log::info!(
+					target: LOG_TARGET,
+					"Migration did not execute. This probably should be removed"
+				);
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			let current_version = Pallet::<T>::current_storage_version();
+			let onchain_version = Pallet::<T>::on_chain_storage_version();
+			ensure!(onchain_version == 0 && current_version == 1, "migration from version 0 to 1.");
+			let prev_count = Collection::<T>::iter().count();
+			Ok((prev_count as u32).encode())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(prev_count: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let prev_count: u32 = Decode::decode(&mut prev_count.as_slice()).expect(
+				"the state parameter should be something that was generated by pre_upgrade",
+			);
+			let post_count = Collection::<T>::iter().count() as u32;
+			ensure!(
+				prev_count == post_count,
+				"the records count before and after the migration should be the same"
+			);
+
+			ensure!(Pallet::<T>::on_chain_storage_version() == 1, "wrong storage version");
+
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/nfts/src/mock.rs b/substrate/frame/nfts/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f091a53f8d7c7938b80c8fe8406cd0aa309d5d82
--- /dev/null
+++ b/substrate/frame/nfts/src/mock.rs
@@ -0,0 +1,134 @@
+// 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.
+
+//! Test environment for Nfts pallet.
+
+use super::*;
+use crate as pallet_nfts;
+
+use frame_support::{
+	construct_runtime, parameter_types,
+	traits::{AsEnsureOriginWithArg, ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_keystore::{testing::MemoryKeystore, KeystoreExt};
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify},
+	BuildStorage, MultiSignature,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Nfts: pallet_nfts::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+pub type Signature = MultiSignature;
+pub type AccountPublic = <Signature as Verify>::Signer;
+pub type AccountId = <AccountPublic as IdentifyAccount>::AccountId;
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	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 DbWeight = ();
+	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>;
+}
+
+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 MaxHolds = ();
+}
+
+parameter_types! {
+	pub storage Features: PalletFeatures = PalletFeatures::all_enabled();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<Self::AccountId>>;
+	type ForceOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type Locker = ();
+	type CollectionDeposit = ConstU64<2>;
+	type ItemDeposit = ConstU64<1>;
+	type MetadataDepositBase = ConstU64<1>;
+	type AttributeDepositBase = ConstU64<1>;
+	type DepositPerByte = ConstU64<1>;
+	type StringLimit = ConstU32<50>;
+	type KeyLimit = ConstU32<50>;
+	type ValueLimit = ConstU32<50>;
+	type ApprovalsLimit = ConstU32<10>;
+	type ItemAttributesApprovalsLimit = ConstU32<2>;
+	type MaxTips = ConstU32<10>;
+	type MaxDeadlineDuration = ConstU64<10000>;
+	type MaxAttributesPerCall = ConstU32<2>;
+	type Features = Features;
+	/// Off-chain = signature On-chain - therefore no conversion needed.
+	/// It needs to be From<MultiSignature> for benchmarking.
+	type OffchainSignature = Signature;
+	/// Using `AccountPublic` here makes it trivial to convert to `AccountId` via `into_account()`.
+	type OffchainPublic = AccountPublic;
+	type WeightInfo = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type Helper = ();
+}
+
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.register_extension(KeystoreExt::new(MemoryKeystore::new()));
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
diff --git a/substrate/frame/nfts/src/tests.rs b/substrate/frame/nfts/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f7879570a4cb74efc2714d35b0d42d2c4a80b946
--- /dev/null
+++ b/substrate/frame/nfts/src/tests.rs
@@ -0,0 +1,3718 @@
+// 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 Nfts pallet.
+
+use crate::{mock::*, Event, *};
+use enumflags2::BitFlags;
+use frame_support::{
+	assert_noop, assert_ok,
+	dispatch::Dispatchable,
+	traits::{
+		tokens::nonfungibles_v2::{Create, Destroy, Mutate},
+		Currency, Get,
+	},
+};
+use pallet_balances::Error as BalancesError;
+use sp_core::{bounded::BoundedVec, Pair};
+use sp_runtime::{traits::IdentifyAccount, MultiSignature, MultiSigner};
+use sp_std::prelude::*;
+
+type AccountIdOf<Test> = <Test as frame_system::Config>::AccountId;
+
+fn account(id: u8) -> AccountIdOf<Test> {
+	[id; 32].into()
+}
+
+fn items() -> Vec<(AccountIdOf<Test>, u32, u32)> {
+	let mut r: Vec<_> = Account::<Test>::iter().map(|x| x.0).collect();
+	r.sort();
+	let mut s: Vec<_> = Item::<Test>::iter().map(|x| (x.2.owner, x.0, x.1)).collect();
+	s.sort();
+	assert_eq!(r, s);
+	for collection in Item::<Test>::iter()
+		.map(|x| x.0)
+		.scan(None, |s, item| {
+			if s.map_or(false, |last| last == item) {
+				*s = Some(item);
+				Some(None)
+			} else {
+				Some(Some(item))
+			}
+		})
+		.flatten()
+	{
+		let details = Collection::<Test>::get(collection).unwrap();
+		let items = Item::<Test>::iter_prefix(collection).count() as u32;
+		assert_eq!(details.items, items);
+	}
+	r
+}
+
+fn collections() -> Vec<(AccountIdOf<Test>, u32)> {
+	let mut r: Vec<_> = CollectionAccount::<Test>::iter().map(|x| (x.0, x.1)).collect();
+	r.sort();
+	let mut s: Vec<_> = Collection::<Test>::iter().map(|x| (x.1.owner, x.0)).collect();
+	s.sort();
+	assert_eq!(r, s);
+	r
+}
+
+macro_rules! bvec {
+	($( $x:tt )*) => {
+		vec![$( $x )*].try_into().unwrap()
+	}
+}
+
+fn attributes(
+	collection: u32,
+) -> Vec<(Option<u32>, AttributeNamespace<AccountIdOf<Test>>, Vec<u8>, Vec<u8>)> {
+	let mut s: Vec<_> = Attribute::<Test>::iter_prefix((collection,))
+		.map(|(k, v)| (k.0, k.1, k.2.into(), v.0.into()))
+		.collect();
+	s.sort_by_key(|k: &(Option<u32>, AttributeNamespace<AccountIdOf<Test>>, Vec<u8>, Vec<u8>)| k.0);
+	s.sort_by_key(|k: &(Option<u32>, AttributeNamespace<AccountIdOf<Test>>, Vec<u8>, Vec<u8>)| {
+		k.2.clone()
+	});
+	s
+}
+
+fn approvals(collection_id: u32, item_id: u32) -> Vec<(AccountIdOf<Test>, Option<u64>)> {
+	let item = Item::<Test>::get(collection_id, item_id).unwrap();
+	let s: Vec<_> = item.approvals.into_iter().collect();
+	s
+}
+
+fn item_attributes_approvals(collection_id: u32, item_id: u32) -> Vec<AccountIdOf<Test>> {
+	let approvals = ItemAttributesApprovalsOf::<Test>::get(collection_id, item_id);
+	let s: Vec<_> = approvals.into_iter().collect();
+	s
+}
+
+fn events() -> Vec<Event<Test>> {
+	let result = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let mock::RuntimeEvent::Nfts(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>();
+
+	System::reset_events();
+
+	result
+}
+
+fn collection_config_from_disabled_settings(
+	settings: BitFlags<CollectionSetting>,
+) -> CollectionConfigFor<Test> {
+	CollectionConfig {
+		settings: CollectionSettings::from_disabled(settings),
+		max_supply: None,
+		mint_settings: MintSettings::default(),
+	}
+}
+
+fn collection_config_with_all_settings_enabled() -> CollectionConfigFor<Test> {
+	CollectionConfig {
+		settings: CollectionSettings::all_enabled(),
+		max_supply: None,
+		mint_settings: MintSettings::default(),
+	}
+}
+
+fn default_collection_config() -> CollectionConfigFor<Test> {
+	collection_config_from_disabled_settings(CollectionSetting::DepositRequired.into())
+}
+
+fn default_item_config() -> ItemConfig {
+	ItemConfig { settings: ItemSettings::all_enabled() }
+}
+
+fn item_config_from_disabled_settings(settings: BitFlags<ItemSetting>) -> ItemConfig {
+	ItemConfig { settings: ItemSettings::from_disabled(settings) }
+}
+
+#[test]
+fn basic_setup_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(items(), vec![]);
+	});
+}
+
+#[test]
+fn basic_minting_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_eq!(collections(), vec![(account(1), 0)]);
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
+		assert_eq!(items(), vec![(account(1), 0, 42)]);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(2),
+			default_collection_config()
+		));
+		assert_eq!(collections(), vec![(account(1), 0), (account(2), 1)]);
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(2)), 1, 69, account(1), None));
+		assert_eq!(items(), vec![(account(1), 0, 42), (account(1), 1, 69)]);
+	});
+}
+
+#[test]
+fn lifecycle_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		Balances::make_free_balance_be(&account(2), 100);
+		assert_ok!(Nfts::create(
+			RuntimeOrigin::signed(account(1)),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_eq!(Balances::reserved_balance(&account(1)), 2);
+		assert_eq!(collections(), vec![(account(1), 0)]);
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			bvec![0, 0]
+		));
+		assert_eq!(Balances::reserved_balance(&account(1)), 5);
+		assert!(CollectionMetadataOf::<Test>::contains_key(0));
+
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(10),
+			default_item_config()
+		));
+		assert_eq!(Balances::reserved_balance(&account(1)), 6);
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			69,
+			account(20),
+			default_item_config()
+		));
+		assert_eq!(Balances::reserved_balance(&account(1)), 7);
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 70, account(1), None));
+		assert_eq!(items(), vec![(account(1), 0, 70), (account(10), 0, 42), (account(20), 0, 69)]);
+		assert_eq!(Collection::<Test>::get(0).unwrap().items, 3);
+		assert_eq!(Collection::<Test>::get(0).unwrap().item_metadatas, 0);
+		assert_eq!(Collection::<Test>::get(0).unwrap().item_configs, 3);
+
+		assert_eq!(Balances::reserved_balance(&account(1)), 8);
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(1)), 0, 70, account(2)));
+		assert_eq!(Balances::reserved_balance(&account(1)), 8);
+		assert_eq!(Balances::reserved_balance(&account(2)), 0);
+
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![42, 42]));
+		assert_eq!(Balances::reserved_balance(&account(1)), 11);
+		assert!(ItemMetadataOf::<Test>::contains_key(0, 42));
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 69, bvec![69, 69]));
+		assert_eq!(Balances::reserved_balance(&account(1)), 14);
+		assert!(ItemMetadataOf::<Test>::contains_key(0, 69));
+		assert!(ItemConfigOf::<Test>::contains_key(0, 69));
+		let w = Nfts::get_destroy_witness(&0).unwrap();
+		assert_eq!(w.item_metadatas, 2);
+		assert_eq!(w.item_configs, 3);
+		assert_noop!(
+			Nfts::destroy(RuntimeOrigin::signed(account(1)), 0, w),
+			Error::<Test>::CollectionNotEmpty
+		);
+
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(69),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(10)), 0, 42));
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(20)), 0, 69));
+		assert_ok!(Nfts::burn(RuntimeOrigin::root(), 0, 70));
+
+		let w = Nfts::get_destroy_witness(&0).unwrap();
+		assert_eq!(w.attributes, 1);
+		assert_eq!(w.item_metadatas, 0);
+		assert_eq!(w.item_configs, 0);
+		assert_ok!(Nfts::destroy(RuntimeOrigin::signed(account(1)), 0, w));
+		assert_eq!(Balances::reserved_balance(&account(1)), 0);
+
+		assert!(!Collection::<Test>::contains_key(0));
+		assert!(!CollectionConfigOf::<Test>::contains_key(0));
+		assert!(!Item::<Test>::contains_key(0, 42));
+		assert!(!Item::<Test>::contains_key(0, 69));
+		assert!(!CollectionMetadataOf::<Test>::contains_key(0));
+		assert!(!ItemMetadataOf::<Test>::contains_key(0, 42));
+		assert!(!ItemMetadataOf::<Test>::contains_key(0, 69));
+		assert!(!ItemConfigOf::<Test>::contains_key(0, 69));
+		assert_eq!(attributes(0), vec![]);
+		assert_eq!(collections(), vec![]);
+		assert_eq!(items(), vec![]);
+	});
+}
+
+#[test]
+fn destroy_with_bad_witness_should_not_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		assert_ok!(Nfts::create(
+			RuntimeOrigin::signed(account(1)),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+
+		let w = Collection::<Test>::get(0).unwrap().destroy_witness();
+		assert_noop!(
+			Nfts::destroy(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				DestroyWitness { item_configs: 1, ..w }
+			),
+			Error::<Test>::BadWitness
+		);
+	});
+}
+
+#[test]
+fn destroy_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		assert_ok!(Nfts::create(
+			RuntimeOrigin::signed(account(1)),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(2), None));
+		assert_noop!(
+			Nfts::destroy(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				Nfts::get_destroy_witness(&0).unwrap()
+			),
+			Error::<Test>::CollectionNotEmpty
+		);
+		assert_ok!(Nfts::lock_item_transfer(RuntimeOrigin::signed(account(1)), 0, 42));
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(2)), 0, 42));
+		assert_eq!(Collection::<Test>::get(0).unwrap().item_configs, 1);
+		assert_eq!(ItemConfigOf::<Test>::iter_prefix(0).count() as u32, 1);
+		assert!(ItemConfigOf::<Test>::contains_key(0, 42));
+		assert_ok!(Nfts::destroy(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Nfts::get_destroy_witness(&0).unwrap()
+		));
+		assert!(!ItemConfigOf::<Test>::contains_key(0, 42));
+		assert_eq!(ItemConfigOf::<Test>::iter_prefix(0).count() as u32, 0);
+	});
+}
+
+#[test]
+fn mint_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
+		assert_eq!(Nfts::owner(0, 42).unwrap(), account(1));
+		assert_eq!(collections(), vec![(account(1), 0)]);
+		assert_eq!(items(), vec![(account(1), 0, 42)]);
+
+		// validate minting start and end settings
+		assert_ok!(Nfts::update_mint_settings(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			MintSettings {
+				start_block: Some(2),
+				end_block: Some(3),
+				mint_type: MintType::Public,
+				..Default::default()
+			}
+		));
+
+		System::set_block_number(1);
+		assert_noop!(
+			Nfts::mint(RuntimeOrigin::signed(account(2)), 0, 43, account(1), None),
+			Error::<Test>::MintNotStarted
+		);
+		System::set_block_number(4);
+		assert_noop!(
+			Nfts::mint(RuntimeOrigin::signed(account(2)), 0, 43, account(1), None),
+			Error::<Test>::MintEnded
+		);
+
+		// validate price
+		assert_ok!(Nfts::update_mint_settings(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			MintSettings { mint_type: MintType::Public, price: Some(1), ..Default::default() }
+		));
+		Balances::make_free_balance_be(&account(2), 100);
+		assert_noop!(
+			Nfts::mint(RuntimeOrigin::signed(account(2)), 0, 43, account(2), None,),
+			Error::<Test>::WitnessRequired
+		);
+		assert_noop!(
+			Nfts::mint(
+				RuntimeOrigin::signed(account(2)),
+				0,
+				43,
+				account(2),
+				Some(MintWitness { ..Default::default() })
+			),
+			Error::<Test>::BadWitness
+		);
+		assert_noop!(
+			Nfts::mint(
+				RuntimeOrigin::signed(account(2)),
+				0,
+				43,
+				account(2),
+				Some(MintWitness { mint_price: Some(0), ..Default::default() })
+			),
+			Error::<Test>::BadWitness
+		);
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			43,
+			account(2),
+			Some(MintWitness { mint_price: Some(1), ..Default::default() })
+		));
+		assert_eq!(Balances::total_balance(&account(2)), 99);
+
+		// validate types
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::update_mint_settings(
+			RuntimeOrigin::signed(account(1)),
+			1,
+			MintSettings { mint_type: MintType::HolderOf(0), ..Default::default() }
+		));
+		assert_noop!(
+			Nfts::mint(RuntimeOrigin::signed(account(3)), 1, 42, account(3), None),
+			Error::<Test>::WitnessRequired
+		);
+		assert_noop!(
+			Nfts::mint(RuntimeOrigin::signed(account(2)), 1, 42, account(2), None),
+			Error::<Test>::WitnessRequired
+		);
+		assert_noop!(
+			Nfts::mint(
+				RuntimeOrigin::signed(account(2)),
+				1,
+				42,
+				account(2),
+				Some(MintWitness { owned_item: Some(42), ..Default::default() })
+			),
+			Error::<Test>::BadWitness
+		);
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(2)),
+			1,
+			42,
+			account(2),
+			Some(MintWitness { owned_item: Some(43), ..Default::default() })
+		));
+
+		// can't mint twice
+		assert_noop!(
+			Nfts::mint(
+				RuntimeOrigin::signed(account(2)),
+				1,
+				46,
+				account(2),
+				Some(MintWitness { owned_item: Some(43), ..Default::default() })
+			),
+			Error::<Test>::AlreadyClaimed
+		);
+	});
+}
+
+#[test]
+fn transfer_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(3)));
+		assert_eq!(items(), vec![(account(3), 0, 42)]);
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(4)),
+			Error::<Test>::NoPermission
+		);
+
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(3)),
+			0,
+			42,
+			account(2),
+			None
+		));
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(4)));
+
+		// validate we can't transfer non-transferable items
+		let collection_id = 1;
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_from_disabled_settings(
+				CollectionSetting::TransferableItems | CollectionSetting::DepositRequired
+			)
+		));
+
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			1,
+			1,
+			account(42),
+			default_item_config()
+		));
+
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(1)), collection_id, 42, account(3)),
+			Error::<Test>::ItemsNonTransferable
+		);
+	});
+}
+
+#[test]
+fn locking_transfer_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
+		assert_ok!(Nfts::lock_item_transfer(RuntimeOrigin::signed(account(1)), 0, 42));
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(1)), 0, 42, account(2)),
+			Error::<Test>::ItemLocked
+		);
+
+		assert_ok!(Nfts::unlock_item_transfer(RuntimeOrigin::signed(account(1)), 0, 42));
+		assert_ok!(Nfts::lock_collection(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			CollectionSettings::from_disabled(CollectionSetting::TransferableItems.into())
+		));
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(1)), 0, 42, account(2)),
+			Error::<Test>::ItemsNonTransferable
+		);
+
+		assert_ok!(Nfts::force_collection_config(
+			RuntimeOrigin::root(),
+			0,
+			collection_config_with_all_settings_enabled(),
+		));
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(1)), 0, 42, account(2)));
+	});
+}
+
+#[test]
+fn origin_guards_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
+
+		Balances::make_free_balance_be(&account(2), 100);
+		assert_ok!(Nfts::set_accept_ownership(RuntimeOrigin::signed(account(2)), Some(0)));
+		assert_noop!(
+			Nfts::transfer_ownership(RuntimeOrigin::signed(account(2)), 0, account(2)),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::set_team(
+				RuntimeOrigin::signed(account(2)),
+				0,
+				Some(account(2)),
+				Some(account(2)),
+				Some(account(2)),
+			),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::lock_item_transfer(RuntimeOrigin::signed(account(2)), 0, 42),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::unlock_item_transfer(RuntimeOrigin::signed(account(2)), 0, 42),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::mint(RuntimeOrigin::signed(account(2)), 0, 69, account(2), None),
+			Error::<Test>::NoPermission
+		);
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 43, account(2), None));
+		assert_noop!(
+			Nfts::burn(RuntimeOrigin::signed(account(1)), 0, 43),
+			Error::<Test>::NoPermission
+		);
+		let w = Nfts::get_destroy_witness(&0).unwrap();
+		assert_noop!(
+			Nfts::destroy(RuntimeOrigin::signed(account(2)), 0, w),
+			Error::<Test>::NoPermission
+		);
+	});
+}
+
+#[test]
+fn transfer_owner_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		Balances::make_free_balance_be(&account(2), 100);
+		Balances::make_free_balance_be(&account(3), 100);
+		assert_ok!(Nfts::create(
+			RuntimeOrigin::signed(account(1)),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_eq!(collections(), vec![(account(1), 0)]);
+		assert_noop!(
+			Nfts::transfer_ownership(RuntimeOrigin::signed(account(1)), 0, account(2)),
+			Error::<Test>::Unaccepted
+		);
+		assert_ok!(Nfts::set_accept_ownership(RuntimeOrigin::signed(account(2)), Some(0)));
+		assert_ok!(Nfts::transfer_ownership(RuntimeOrigin::signed(account(1)), 0, account(2)));
+
+		assert_eq!(collections(), vec![(account(2), 0)]);
+		assert_eq!(Balances::total_balance(&account(1)), 98);
+		assert_eq!(Balances::total_balance(&account(2)), 102);
+		assert_eq!(Balances::reserved_balance(&account(1)), 0);
+		assert_eq!(Balances::reserved_balance(&account(2)), 2);
+
+		assert_ok!(Nfts::set_accept_ownership(RuntimeOrigin::signed(account(1)), Some(0)));
+		assert_noop!(
+			Nfts::transfer_ownership(RuntimeOrigin::signed(account(1)), 0, account(1)),
+			Error::<Test>::NoPermission
+		);
+
+		// Mint and set metadata now and make sure that deposit gets transferred back.
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			bvec![0u8; 20],
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
+		assert_eq!(Balances::reserved_balance(&account(1)), 1);
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0u8; 20]));
+		assert_ok!(Nfts::set_accept_ownership(RuntimeOrigin::signed(account(3)), Some(0)));
+		assert_ok!(Nfts::transfer_ownership(RuntimeOrigin::signed(account(2)), 0, account(3)));
+		assert_eq!(collections(), vec![(account(3), 0)]);
+		assert_eq!(Balances::total_balance(&account(2)), 58);
+		assert_eq!(Balances::total_balance(&account(3)), 144);
+		assert_eq!(Balances::reserved_balance(&account(2)), 0);
+		assert_eq!(Balances::reserved_balance(&account(3)), 44);
+
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(1)), 0, 42, account(2)));
+		// reserved_balance of accounts 1 & 2 should be unchanged:
+		assert_eq!(Balances::reserved_balance(&account(1)), 1);
+		assert_eq!(Balances::reserved_balance(&account(2)), 0);
+
+		// 2's acceptance from before is reset when it became an owner, so it cannot be transferred
+		// without a fresh acceptance.
+		assert_noop!(
+			Nfts::transfer_ownership(RuntimeOrigin::signed(account(3)), 0, account(2)),
+			Error::<Test>::Unaccepted
+		);
+	});
+}
+
+#[test]
+fn set_team_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config(),
+		));
+		assert_ok!(Nfts::set_team(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(account(2)),
+			Some(account(3)),
+			Some(account(4)),
+		));
+
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(2)), 0, 42, account(2), None));
+
+		// admin can't transfer/burn items he doesn't own
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(3)),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::burn(RuntimeOrigin::signed(account(3)), 0, 42),
+			Error::<Test>::NoPermission
+		);
+
+		assert_ok!(Nfts::lock_item_transfer(RuntimeOrigin::signed(account(4)), 0, 42));
+		assert_ok!(Nfts::unlock_item_transfer(RuntimeOrigin::signed(account(4)), 0, 42));
+
+		// validate we can set any role to None
+		assert_ok!(Nfts::set_team(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(account(2)),
+			Some(account(3)),
+			None,
+		));
+		assert_noop!(
+			Nfts::lock_item_transfer(RuntimeOrigin::signed(account(4)), 0, 42),
+			Error::<Test>::NoPermission
+		);
+
+		// set all the roles to None
+		assert_ok!(Nfts::set_team(RuntimeOrigin::signed(account(1)), 0, None, None, None,));
+
+		// validate we can't set the roles back
+		assert_noop!(
+			Nfts::set_team(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				Some(account(2)),
+				Some(account(3)),
+				None,
+			),
+			Error::<Test>::NoPermission
+		);
+
+		// only the root account can change the roles from None to Some()
+		assert_ok!(Nfts::set_team(
+			RuntimeOrigin::root(),
+			0,
+			Some(account(2)),
+			Some(account(3)),
+			None,
+		));
+	});
+}
+
+#[test]
+fn set_collection_metadata_should_work() {
+	new_test_ext().execute_with(|| {
+		// Cannot add metadata to unknown item
+		assert_noop!(
+			Nfts::set_collection_metadata(RuntimeOrigin::signed(account(1)), 0, bvec![0u8; 20]),
+			Error::<Test>::NoPermission,
+		);
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		// Cannot add metadata to unowned item
+		assert_noop!(
+			Nfts::set_collection_metadata(RuntimeOrigin::signed(account(2)), 0, bvec![0u8; 20]),
+			Error::<Test>::NoPermission,
+		);
+
+		// Successfully add metadata and take deposit
+		Balances::make_free_balance_be(&account(1), 30);
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			bvec![0u8; 20]
+		));
+		assert_eq!(Balances::free_balance(&account(1)), 9);
+		assert!(CollectionMetadataOf::<Test>::contains_key(0));
+
+		// Force origin works, too.
+		assert_ok!(Nfts::set_collection_metadata(RuntimeOrigin::root(), 0, bvec![0u8; 18]));
+
+		// Update deposit
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			bvec![0u8; 15]
+		));
+		assert_eq!(Balances::free_balance(&account(1)), 14);
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			bvec![0u8; 25]
+		));
+		assert_eq!(Balances::free_balance(&account(1)), 4);
+
+		// Cannot over-reserve
+		assert_noop!(
+			Nfts::set_collection_metadata(RuntimeOrigin::signed(account(1)), 0, bvec![0u8; 40]),
+			BalancesError::<Test, _>::InsufficientBalance,
+		);
+
+		// Can't set or clear metadata once frozen
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			bvec![0u8; 15]
+		));
+		assert_ok!(Nfts::lock_collection(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			CollectionSettings::from_disabled(CollectionSetting::UnlockedMetadata.into())
+		));
+		assert_noop!(
+			Nfts::set_collection_metadata(RuntimeOrigin::signed(account(1)), 0, bvec![0u8; 15]),
+			Error::<Test, _>::LockedCollectionMetadata,
+		);
+		assert_noop!(
+			Nfts::clear_collection_metadata(RuntimeOrigin::signed(account(1)), 0),
+			Error::<Test>::LockedCollectionMetadata
+		);
+
+		// Clear Metadata
+		assert_ok!(Nfts::set_collection_metadata(RuntimeOrigin::root(), 0, bvec![0u8; 15]));
+		assert_noop!(
+			Nfts::clear_collection_metadata(RuntimeOrigin::signed(account(2)), 0),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::clear_collection_metadata(RuntimeOrigin::signed(account(1)), 1),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::clear_collection_metadata(RuntimeOrigin::signed(account(1)), 0),
+			Error::<Test>::LockedCollectionMetadata
+		);
+		assert_ok!(Nfts::clear_collection_metadata(RuntimeOrigin::root(), 0));
+		assert!(!CollectionMetadataOf::<Test>::contains_key(0));
+	});
+}
+
+#[test]
+fn set_item_metadata_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 30);
+
+		// Cannot add metadata to unknown item
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
+		// Cannot add metadata to unowned item
+		assert_noop!(
+			Nfts::set_metadata(RuntimeOrigin::signed(account(2)), 0, 42, bvec![0u8; 20]),
+			Error::<Test>::NoPermission,
+		);
+
+		// Successfully add metadata and take deposit
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0u8; 20]));
+		assert_eq!(Balances::free_balance(&account(1)), 8);
+		assert!(ItemMetadataOf::<Test>::contains_key(0, 42));
+
+		// Force origin works, too.
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::root(), 0, 42, bvec![0u8; 18]));
+
+		// Update deposit
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0u8; 15]));
+		assert_eq!(Balances::free_balance(&account(1)), 13);
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0u8; 25]));
+		assert_eq!(Balances::free_balance(&account(1)), 3);
+
+		// Cannot over-reserve
+		assert_noop!(
+			Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0u8; 40]),
+			BalancesError::<Test, _>::InsufficientBalance,
+		);
+
+		// Can't set or clear metadata once frozen
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0u8; 15]));
+		assert_ok!(Nfts::lock_item_properties(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			true,
+			false
+		));
+		assert_noop!(
+			Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0u8; 15]),
+			Error::<Test, _>::LockedItemMetadata,
+		);
+		assert_noop!(
+			Nfts::clear_metadata(RuntimeOrigin::signed(account(1)), 0, 42),
+			Error::<Test>::LockedItemMetadata,
+		);
+
+		// Clear Metadata
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::root(), 0, 42, bvec![0u8; 15]));
+		assert_noop!(
+			Nfts::clear_metadata(RuntimeOrigin::signed(account(2)), 0, 42),
+			Error::<Test>::NoPermission,
+		);
+		assert_noop!(
+			Nfts::clear_metadata(RuntimeOrigin::signed(account(1)), 1, 42),
+			Error::<Test>::NoPermission,
+		);
+		assert_ok!(Nfts::clear_metadata(RuntimeOrigin::root(), 0, 42));
+		assert!(!ItemMetadataOf::<Test>::contains_key(0, 42));
+	});
+}
+
+#[test]
+fn set_collection_owner_attributes_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 0, account(1), None));
+
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			None,
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			bvec![1],
+			bvec![0],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![1], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(1)), 10);
+		assert_eq!(Collection::<Test>::get(0).unwrap().owner_deposit, 9);
+
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			None,
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0; 10],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, AttributeNamespace::CollectionOwner, bvec![0], bvec![0; 10]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![1], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(1)), 19);
+		assert_eq!(Collection::<Test>::get(0).unwrap().owner_deposit, 18);
+
+		assert_ok!(Nfts::clear_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			bvec![1],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, AttributeNamespace::CollectionOwner, bvec![0], bvec![0; 10]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(1)), 16);
+
+		assert_ok!(Nfts::burn(RuntimeOrigin::root(), 0, 0));
+		let w = Nfts::get_destroy_witness(&0).unwrap();
+		assert_ok!(Nfts::destroy(RuntimeOrigin::signed(account(1)), 0, w));
+		assert_eq!(attributes(0), vec![]);
+		assert_eq!(Balances::reserved_balance(account(1)), 0);
+	});
+}
+
+#[test]
+fn set_item_owner_attributes_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		Balances::make_free_balance_be(&account(2), 100);
+		Balances::make_free_balance_be(&account(3), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			0,
+			account(2),
+			default_item_config()
+		));
+
+		// can't set for the collection
+		assert_noop!(
+			Nfts::set_attribute(
+				RuntimeOrigin::signed(account(2)),
+				0,
+				None,
+				AttributeNamespace::ItemOwner,
+				bvec![0],
+				bvec![0],
+			),
+			Error::<Test>::NoPermission,
+		);
+		// can't set for the non-owned item
+		assert_noop!(
+			Nfts::set_attribute(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				Some(0),
+				AttributeNamespace::ItemOwner,
+				bvec![0],
+				bvec![0],
+			),
+			Error::<Test>::NoPermission,
+		);
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![1],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![2],
+			bvec![0],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::ItemOwner, bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![1], bvec![0]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![2], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(2)), 9);
+
+		// validate an attribute can be updated
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![0],
+			bvec![0; 10],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::ItemOwner, bvec![0], bvec![0; 10]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![1], bvec![0]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![2], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(2)), 18);
+
+		// validate only item's owner (or the root) can remove an attribute
+		assert_noop!(
+			Nfts::clear_attribute(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				Some(0),
+				AttributeNamespace::ItemOwner,
+				bvec![1],
+			),
+			Error::<Test>::NoPermission,
+		);
+		assert_ok!(Nfts::clear_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![1],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::ItemOwner, bvec![0], bvec![0; 10]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![2], bvec![0])
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(2)), 15);
+
+		// transfer item
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 0, account(3)));
+
+		// validate the attribute are still here & the deposit belongs to the previous owner
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::ItemOwner, bvec![0], bvec![0; 10]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![2], bvec![0])
+			]
+		);
+		let key: BoundedVec<_, _> = bvec![0];
+		let (_, deposit) =
+			Attribute::<Test>::get((0, Some(0), AttributeNamespace::ItemOwner, &key)).unwrap();
+		assert_eq!(deposit.account, Some(account(2)));
+		assert_eq!(deposit.amount, 12);
+
+		// on attribute update the deposit should be returned to the previous owner
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(3)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![0],
+			bvec![0; 11],
+		));
+		let (_, deposit) =
+			Attribute::<Test>::get((0, Some(0), AttributeNamespace::ItemOwner, &key)).unwrap();
+		assert_eq!(deposit.account, Some(account(3)));
+		assert_eq!(deposit.amount, 13);
+		assert_eq!(Balances::reserved_balance(account(2)), 3);
+		assert_eq!(Balances::reserved_balance(account(3)), 13);
+
+		// validate attributes on item deletion
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(3)), 0, 0));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::ItemOwner, bvec![0], bvec![0; 11]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![2], bvec![0])
+			]
+		);
+		assert_ok!(Nfts::clear_attribute(
+			RuntimeOrigin::signed(account(3)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![0],
+		));
+		assert_ok!(Nfts::clear_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![2],
+		));
+		assert_eq!(Balances::reserved_balance(account(2)), 0);
+		assert_eq!(Balances::reserved_balance(account(3)), 0);
+	});
+}
+
+#[test]
+fn set_external_account_attributes_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		Balances::make_free_balance_be(&account(2), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			0,
+			account(1),
+			default_item_config()
+		));
+		assert_ok!(Nfts::approve_item_attributes(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			0,
+			account(2)
+		));
+
+		assert_noop!(
+			Nfts::set_attribute(
+				RuntimeOrigin::signed(account(2)),
+				0,
+				Some(0),
+				AttributeNamespace::Account(account(1)),
+				bvec![0],
+				bvec![0],
+			),
+			Error::<Test>::NoPermission,
+		);
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::Account(account(2)),
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::Account(account(2)),
+			bvec![1],
+			bvec![0],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::Account(account(2)), bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::Account(account(2)), bvec![1], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(2)), 6);
+
+		// remove permission to set attributes
+		assert_ok!(Nfts::cancel_item_attributes_approval(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			0,
+			account(2),
+			CancelAttributesApprovalWitness { account_attributes: 2 },
+		));
+		assert_eq!(attributes(0), vec![]);
+		assert_eq!(Balances::reserved_balance(account(2)), 0);
+		assert_noop!(
+			Nfts::set_attribute(
+				RuntimeOrigin::signed(account(2)),
+				0,
+				Some(0),
+				AttributeNamespace::Account(account(2)),
+				bvec![0],
+				bvec![0],
+			),
+			Error::<Test>::NoPermission,
+		);
+	});
+}
+
+#[test]
+fn validate_deposit_required_setting() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		Balances::make_free_balance_be(&account(2), 100);
+		Balances::make_free_balance_be(&account(3), 100);
+
+		// with the disabled DepositRequired setting, only the collection's owner can set the
+		// attributes for free.
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			0,
+			account(2),
+			default_item_config()
+		));
+		assert_ok!(Nfts::approve_item_attributes(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			0,
+			account(3)
+		));
+
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			Some(0),
+			AttributeNamespace::ItemOwner,
+			bvec![1],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(3)),
+			0,
+			Some(0),
+			AttributeNamespace::Account(account(3)),
+			bvec![2],
+			bvec![0],
+		));
+		assert_ok!(<Nfts as Mutate<<Test as SystemConfig>::AccountId, ItemConfig>>::set_attribute(
+			&0,
+			&0,
+			&[3],
+			&[0],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![1], bvec![0]),
+				(Some(0), AttributeNamespace::Account(account(3)), bvec![2], bvec![0]),
+				(Some(0), AttributeNamespace::Pallet, bvec![3], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(1)), 0);
+		assert_eq!(Balances::reserved_balance(account(2)), 3);
+		assert_eq!(Balances::reserved_balance(account(3)), 3);
+
+		assert_ok!(
+			<Nfts as Mutate<<Test as SystemConfig>::AccountId, ItemConfig>>::clear_attribute(
+				&0,
+				&0,
+				&[3],
+			)
+		);
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::ItemOwner, bvec![1], bvec![0]),
+				(Some(0), AttributeNamespace::Account(account(3)), bvec![2], bvec![0]),
+			]
+		);
+	});
+}
+
+#[test]
+fn set_attribute_should_respect_lock() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled(),
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 0, account(1), None));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 1, account(1), None));
+
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			None,
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(1),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![0],
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+				(Some(1), AttributeNamespace::CollectionOwner, bvec![0], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(account(1)), 11);
+
+		assert_ok!(Nfts::set_collection_metadata(RuntimeOrigin::signed(account(1)), 0, bvec![]));
+		assert_ok!(Nfts::lock_collection(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			CollectionSettings::from_disabled(CollectionSetting::UnlockedAttributes.into())
+		));
+
+		let e = Error::<Test>::LockedCollectionAttributes;
+		assert_noop!(
+			Nfts::set_attribute(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				None,
+				AttributeNamespace::CollectionOwner,
+				bvec![0],
+				bvec![0],
+			),
+			e
+		);
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![1],
+		));
+
+		assert_ok!(Nfts::lock_item_properties(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			0,
+			false,
+			true
+		));
+		let e = Error::<Test>::LockedItemAttributes;
+		assert_noop!(
+			Nfts::set_attribute(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				Some(0),
+				AttributeNamespace::CollectionOwner,
+				bvec![0],
+				bvec![1],
+			),
+			e
+		);
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(1),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![1],
+		));
+	});
+}
+
+#[test]
+fn preserve_config_for_frozen_items() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 0, account(1), None));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 1, account(1), None));
+
+		// if the item is not locked/frozen then the config gets deleted on item burn
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(1)), 0, 1));
+		assert!(!ItemConfigOf::<Test>::contains_key(0, 1));
+
+		// lock the item and ensure the config stays unchanged
+		assert_ok!(Nfts::lock_item_properties(RuntimeOrigin::signed(account(1)), 0, 0, true, true));
+
+		let expect_config = item_config_from_disabled_settings(
+			ItemSetting::UnlockedAttributes | ItemSetting::UnlockedMetadata,
+		);
+		let config = ItemConfigOf::<Test>::get(0, 0).unwrap();
+		assert_eq!(config, expect_config);
+
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(1)), 0, 0));
+		let config = ItemConfigOf::<Test>::get(0, 0).unwrap();
+		assert_eq!(config, expect_config);
+
+		// can't mint with the different config
+		assert_noop!(
+			Nfts::force_mint(
+				RuntimeOrigin::signed(account(1)),
+				0,
+				0,
+				account(2),
+				default_item_config()
+			),
+			Error::<Test>::InconsistentItemConfig
+		);
+
+		assert_ok!(Nfts::update_mint_settings(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			MintSettings {
+				default_item_settings: ItemSettings::from_disabled(
+					ItemSetting::UnlockedAttributes | ItemSetting::UnlockedMetadata
+				),
+				..Default::default()
+			}
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 0, account(1), None));
+	});
+}
+
+#[test]
+fn force_update_collection_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 42, account(1), None));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			69,
+			account(2),
+			default_item_config(),
+		));
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			bvec![0; 20]
+		));
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 42, bvec![0; 20]));
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 69, bvec![0; 20]));
+		assert_eq!(Balances::reserved_balance(account(1)), 65);
+
+		// force item status to be free holding
+		assert_ok!(Nfts::force_collection_config(
+			RuntimeOrigin::root(),
+			0,
+			collection_config_from_disabled_settings(CollectionSetting::DepositRequired.into()),
+		));
+		assert_ok!(Nfts::mint(RuntimeOrigin::signed(account(1)), 0, 142, account(1), None));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			169,
+			account(2),
+			default_item_config(),
+		));
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 142, bvec![0; 20]));
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(1)), 0, 169, bvec![0; 20]));
+
+		Balances::make_free_balance_be(&account(5), 100);
+		assert_ok!(Nfts::force_collection_owner(RuntimeOrigin::root(), 0, account(5)));
+		assert_ok!(Nfts::set_team(
+			RuntimeOrigin::root(),
+			0,
+			Some(account(2)),
+			Some(account(5)),
+			Some(account(4)),
+		));
+		assert_eq!(collections(), vec![(account(5), 0)]);
+		assert_eq!(Balances::reserved_balance(account(1)), 2);
+		assert_eq!(Balances::reserved_balance(account(5)), 63);
+
+		assert_ok!(Nfts::redeposit(
+			RuntimeOrigin::signed(account(5)),
+			0,
+			bvec![0, 42, 50, 69, 100]
+		));
+		assert_eq!(Balances::reserved_balance(account(1)), 0);
+
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(5)), 0, 42, bvec![0; 20]));
+		assert_eq!(Balances::reserved_balance(account(5)), 42);
+
+		assert_ok!(Nfts::set_metadata(RuntimeOrigin::signed(account(5)), 0, 69, bvec![0; 20]));
+		assert_eq!(Balances::reserved_balance(account(5)), 21);
+
+		assert_ok!(Nfts::set_collection_metadata(
+			RuntimeOrigin::signed(account(5)),
+			0,
+			bvec![0; 20]
+		));
+		assert_eq!(Balances::reserved_balance(account(5)), 0);
+
+		// validate new roles
+		assert_ok!(Nfts::set_team(
+			RuntimeOrigin::root(),
+			0,
+			Some(account(2)),
+			Some(account(3)),
+			Some(account(4)),
+		));
+		assert_eq!(
+			CollectionRoleOf::<Test>::get(0, account(2)).unwrap(),
+			CollectionRoles(CollectionRole::Issuer.into())
+		);
+		assert_eq!(
+			CollectionRoleOf::<Test>::get(0, account(3)).unwrap(),
+			CollectionRoles(CollectionRole::Admin.into())
+		);
+		assert_eq!(
+			CollectionRoleOf::<Test>::get(0, account(4)).unwrap(),
+			CollectionRoles(CollectionRole::Freezer.into())
+		);
+
+		assert_ok!(Nfts::set_team(
+			RuntimeOrigin::root(),
+			0,
+			Some(account(3)),
+			Some(account(2)),
+			Some(account(3)),
+		));
+
+		assert_eq!(
+			CollectionRoleOf::<Test>::get(0, account(2)).unwrap(),
+			CollectionRoles(CollectionRole::Admin.into())
+		);
+		assert_eq!(
+			CollectionRoleOf::<Test>::get(0, account(3)).unwrap(),
+			CollectionRoles(CollectionRole::Issuer | CollectionRole::Freezer)
+		);
+	});
+}
+
+#[test]
+fn burn_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&account(1), 100);
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_with_all_settings_enabled()
+		));
+		assert_ok!(Nfts::set_team(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			Some(account(2)),
+			Some(account(3)),
+			Some(account(4)),
+		));
+
+		assert_noop!(
+			Nfts::burn(RuntimeOrigin::signed(account(5)), 0, 42),
+			Error::<Test>::UnknownItem
+		);
+
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(5),
+			default_item_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			69,
+			account(5),
+			default_item_config()
+		));
+		assert_eq!(Balances::reserved_balance(account(1)), 2);
+
+		assert_noop!(
+			Nfts::burn(RuntimeOrigin::signed(account(0)), 0, 42),
+			Error::<Test>::NoPermission
+		);
+
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(5)), 0, 42));
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(account(5)), 0, 69));
+		assert_eq!(Balances::reserved_balance(account(1)), 0);
+	});
+}
+
+#[test]
+fn approval_lifecycle_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			None
+		));
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(4)));
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(3)),
+			Error::<Test>::NoPermission
+		);
+		assert!(Item::<Test>::get(0, 42).unwrap().approvals.is_empty());
+
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(4)),
+			0,
+			42,
+			account(2),
+			None
+		));
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(2)));
+
+		// ensure we can't buy an item when the collection has a NonTransferableItems flag
+		let collection_id = 1;
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_from_disabled_settings(
+				CollectionSetting::TransferableItems | CollectionSetting::DepositRequired
+			)
+		));
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(account(1)),
+			1,
+			collection_id,
+			account(1),
+			None,
+		));
+
+		assert_noop!(
+			Nfts::approve_transfer(
+				RuntimeOrigin::signed(account(1)),
+				collection_id,
+				1,
+				account(2),
+				None
+			),
+			Error::<Test>::ItemsNonTransferable
+		);
+	});
+}
+
+#[test]
+fn cancel_approval_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			None
+		));
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 1, 42, account(3)),
+			Error::<Test>::UnknownItem
+		);
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 43, account(3)),
+			Error::<Test>::UnknownItem
+		);
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(3)), 0, 42, account(3)),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(4)),
+			Error::<Test>::NotDelegate
+		);
+
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(3)));
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(3)),
+			Error::<Test>::NotDelegate
+		);
+
+		let current_block = 1;
+		System::set_block_number(current_block);
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			69,
+			account(2),
+			default_item_config()
+		));
+		// approval expires after 2 blocks.
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			Some(2)
+		));
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(5)), 0, 42, account(3)),
+			Error::<Test>::NoPermission
+		);
+
+		System::set_block_number(current_block + 3);
+		// 5 can cancel the approval since the deadline has passed.
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::signed(account(5)), 0, 42, account(3)));
+		assert_eq!(approvals(0, 69), vec![]);
+	});
+}
+
+#[test]
+fn approving_multiple_accounts_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		let current_block = 1;
+		System::set_block_number(current_block);
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			None
+		));
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(4),
+			None
+		));
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(5),
+			Some(2)
+		));
+		assert_eq!(
+			approvals(0, 42),
+			vec![(account(3), None), (account(4), None), (account(5), Some(current_block + 2))]
+		);
+
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(4)), 0, 42, account(6)));
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(7)),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(5)), 0, 42, account(8)),
+			Error::<Test>::NoPermission
+		);
+	});
+}
+
+#[test]
+fn approvals_limit_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		for i in 3..13 {
+			assert_ok!(Nfts::approve_transfer(
+				RuntimeOrigin::signed(account(2)),
+				0,
+				42,
+				account(i),
+				None
+			));
+		}
+		// the limit is 10
+		assert_noop!(
+			Nfts::approve_transfer(RuntimeOrigin::signed(account(2)), 0, 42, account(14), None),
+			Error::<Test>::ReachedApprovalLimit
+		);
+	});
+}
+
+#[test]
+fn approval_deadline_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(0);
+		assert!(System::block_number().is_zero());
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			collection_config_from_disabled_settings(CollectionSetting::DepositRequired.into())
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		// the approval expires after the 2nd block.
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			Some(2)
+		));
+
+		System::set_block_number(3);
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(4)),
+			Error::<Test>::ApprovalExpired
+		);
+		System::set_block_number(1);
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(4)));
+
+		assert_eq!(System::block_number(), 1);
+		// make a new approval with a deadline after 4 blocks, so it will expire after the 5th
+		// block.
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(4)),
+			0,
+			42,
+			account(6),
+			Some(4)
+		));
+		// this should still work.
+		System::set_block_number(5);
+		assert_ok!(Nfts::transfer(RuntimeOrigin::signed(account(6)), 0, 42, account(5)));
+	});
+}
+
+#[test]
+fn cancel_approval_works_with_admin() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			None
+		));
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 1, 42, account(1)),
+			Error::<Test>::UnknownItem
+		);
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 43, account(1)),
+			Error::<Test>::UnknownItem
+		);
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(4)),
+			Error::<Test>::NotDelegate
+		);
+
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(3)));
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::signed(account(2)), 0, 42, account(1)),
+			Error::<Test>::NotDelegate
+		);
+	});
+}
+
+#[test]
+fn cancel_approval_works_with_force() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			None
+		));
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::root(), 1, 42, account(1)),
+			Error::<Test>::UnknownItem
+		);
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::root(), 0, 43, account(1)),
+			Error::<Test>::UnknownItem
+		);
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::root(), 0, 42, account(4)),
+			Error::<Test>::NotDelegate
+		);
+
+		assert_ok!(Nfts::cancel_approval(RuntimeOrigin::root(), 0, 42, account(3)));
+		assert_noop!(
+			Nfts::cancel_approval(RuntimeOrigin::root(), 0, 42, account(1)),
+			Error::<Test>::NotDelegate
+		);
+	});
+}
+
+#[test]
+fn clear_all_transfer_approvals_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(account(1)),
+			0,
+			42,
+			account(2),
+			default_item_config()
+		));
+
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(3),
+			None
+		));
+		assert_ok!(Nfts::approve_transfer(
+			RuntimeOrigin::signed(account(2)),
+			0,
+			42,
+			account(4),
+			None
+		));
+
+		assert_noop!(
+			Nfts::clear_all_transfer_approvals(RuntimeOrigin::signed(account(3)), 0, 42),
+			Error::<Test>::NoPermission
+		);
+
+		assert_ok!(Nfts::clear_all_transfer_approvals(RuntimeOrigin::signed(account(2)), 0, 42));
+
+		assert!(events().contains(&Event::<Test>::AllApprovalsCancelled {
+			collection: 0,
+			item: 42,
+			owner: account(2),
+		}));
+		assert_eq!(approvals(0, 42), vec![]);
+
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(3)), 0, 42, account(5)),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::transfer(RuntimeOrigin::signed(account(4)), 0, 42, account(5)),
+			Error::<Test>::NoPermission
+		);
+	});
+}
+
+#[test]
+fn max_supply_should_work() {
+	new_test_ext().execute_with(|| {
+		let collection_id = 0;
+		let user_id = account(1);
+		let max_supply = 1;
+
+		// validate set_collection_max_supply
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			default_collection_config()
+		));
+		assert_eq!(CollectionConfigOf::<Test>::get(collection_id).unwrap().max_supply, None);
+
+		assert_ok!(Nfts::set_collection_max_supply(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			max_supply
+		));
+		assert_eq!(
+			CollectionConfigOf::<Test>::get(collection_id).unwrap().max_supply,
+			Some(max_supply)
+		);
+
+		assert!(events().contains(&Event::<Test>::CollectionMaxSupplySet {
+			collection: collection_id,
+			max_supply,
+		}));
+
+		assert_ok!(Nfts::set_collection_max_supply(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			max_supply + 1
+		));
+		assert_ok!(Nfts::lock_collection(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			CollectionSettings::from_disabled(CollectionSetting::UnlockedMaxSupply.into())
+		));
+		assert_noop!(
+			Nfts::set_collection_max_supply(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				max_supply + 2
+			),
+			Error::<Test>::MaxSupplyLocked
+		);
+
+		// validate we can't mint more to max supply
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			0,
+			user_id.clone(),
+			None
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			1,
+			user_id.clone(),
+			None
+		));
+		assert_noop!(
+			Nfts::mint(RuntimeOrigin::signed(user_id.clone()), collection_id, 2, user_id, None),
+			Error::<Test>::MaxSupplyReached
+		);
+	});
+}
+
+#[test]
+fn mint_settings_should_work() {
+	new_test_ext().execute_with(|| {
+		let collection_id = 0;
+		let user_id = account(1);
+		let item_id = 0;
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_id,
+			user_id.clone(),
+			None,
+		));
+		assert_eq!(
+			ItemConfigOf::<Test>::get(collection_id, item_id)
+				.unwrap()
+				.settings
+				.get_disabled(),
+			ItemSettings::all_enabled().get_disabled()
+		);
+
+		let collection_id = 1;
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			CollectionConfig {
+				mint_settings: MintSettings {
+					default_item_settings: ItemSettings::from_disabled(
+						ItemSetting::Transferable | ItemSetting::UnlockedMetadata
+					),
+					..Default::default()
+				},
+				..default_collection_config()
+			}
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_id,
+			user_id.clone(),
+			None,
+		));
+		assert_eq!(
+			ItemConfigOf::<Test>::get(collection_id, item_id)
+				.unwrap()
+				.settings
+				.get_disabled(),
+			ItemSettings::from_disabled(ItemSetting::Transferable | ItemSetting::UnlockedMetadata)
+				.get_disabled()
+		);
+	});
+}
+
+#[test]
+fn set_price_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_id = account(1);
+		let collection_id = 0;
+		let item_1 = 1;
+		let item_2 = 2;
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			default_collection_config()
+		));
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_1,
+			user_id.clone(),
+			None,
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_2,
+			user_id.clone(),
+			None,
+		));
+
+		assert_ok!(Nfts::set_price(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_1,
+			Some(1),
+			None,
+		));
+
+		assert_ok!(Nfts::set_price(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_2,
+			Some(2),
+			Some(account(3)),
+		));
+
+		let item = ItemPriceOf::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(item.0, 1);
+		assert_eq!(item.1, None);
+
+		let item = ItemPriceOf::<Test>::get(collection_id, item_2).unwrap();
+		assert_eq!(item.0, 2);
+		assert_eq!(item.1, Some(account(3)));
+
+		assert!(events().contains(&Event::<Test>::ItemPriceSet {
+			collection: collection_id,
+			item: item_1,
+			price: 1,
+			whitelisted_buyer: None,
+		}));
+
+		// validate we can unset the price
+		assert_ok!(Nfts::set_price(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_2,
+			None,
+			None
+		));
+		assert!(events().contains(&Event::<Test>::ItemPriceRemoved {
+			collection: collection_id,
+			item: item_2
+		}));
+		assert!(!ItemPriceOf::<Test>::contains_key(collection_id, item_2));
+
+		// ensure we can't set price when the items are non-transferable
+		let collection_id = 1;
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			collection_config_from_disabled_settings(
+				CollectionSetting::TransferableItems | CollectionSetting::DepositRequired
+			)
+		));
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_1,
+			user_id.clone(),
+			None,
+		));
+
+		assert_noop!(
+			Nfts::set_price(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				item_1,
+				Some(2),
+				None
+			),
+			Error::<Test>::ItemsNonTransferable
+		);
+	});
+}
+
+#[test]
+fn buy_item_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_1 = account(1);
+		let user_2 = account(2);
+		let user_3 = account(3);
+		let collection_id = 0;
+		let item_1 = 1;
+		let item_2 = 2;
+		let item_3 = 3;
+		let price_1 = 20;
+		let price_2 = 30;
+		let initial_balance = 100;
+
+		Balances::make_free_balance_be(&user_1, initial_balance);
+		Balances::make_free_balance_be(&user_2, initial_balance);
+		Balances::make_free_balance_be(&user_3, initial_balance);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_1.clone(),
+			default_collection_config()
+		));
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_1,
+			user_1.clone(),
+			None
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_2,
+			user_1.clone(),
+			None
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_3,
+			user_1.clone(),
+			None
+		));
+
+		assert_ok!(Nfts::set_price(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_1,
+			Some(price_1),
+			None,
+		));
+
+		assert_ok!(Nfts::set_price(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_2,
+			Some(price_2),
+			Some(user_3.clone()),
+		));
+
+		// can't buy for less
+		assert_noop!(
+			Nfts::buy_item(RuntimeOrigin::signed(user_2.clone()), collection_id, item_1, 1),
+			Error::<Test>::BidTooLow
+		);
+
+		// pass the higher price to validate it will still deduct correctly
+		assert_ok!(Nfts::buy_item(
+			RuntimeOrigin::signed(user_2.clone()),
+			collection_id,
+			item_1,
+			price_1 + 1,
+		));
+
+		// validate the new owner & balances
+		let item = Item::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(item.owner, user_2.clone());
+		assert_eq!(Balances::total_balance(&user_1.clone()), initial_balance + price_1);
+		assert_eq!(Balances::total_balance(&user_2.clone()), initial_balance - price_1);
+
+		// can't buy from yourself
+		assert_noop!(
+			Nfts::buy_item(RuntimeOrigin::signed(user_1.clone()), collection_id, item_2, price_2),
+			Error::<Test>::NoPermission
+		);
+
+		// can't buy when the item is listed for a specific buyer
+		assert_noop!(
+			Nfts::buy_item(RuntimeOrigin::signed(user_2.clone()), collection_id, item_2, price_2),
+			Error::<Test>::NoPermission
+		);
+
+		// can buy when I'm a whitelisted buyer
+		assert_ok!(Nfts::buy_item(
+			RuntimeOrigin::signed(user_3.clone()),
+			collection_id,
+			item_2,
+			price_2
+		));
+
+		assert!(events().contains(&Event::<Test>::ItemBought {
+			collection: collection_id,
+			item: item_2,
+			price: price_2,
+			seller: user_1.clone(),
+			buyer: user_3.clone(),
+		}));
+
+		// ensure we reset the buyer field
+		assert!(!ItemPriceOf::<Test>::contains_key(collection_id, item_2));
+
+		// can't buy when item is not for sale
+		assert_noop!(
+			Nfts::buy_item(RuntimeOrigin::signed(user_2.clone()), collection_id, item_3, price_2),
+			Error::<Test>::NotForSale
+		);
+
+		// ensure we can't buy an item when the collection or an item are frozen
+		{
+			assert_ok!(Nfts::set_price(
+				RuntimeOrigin::signed(user_1.clone()),
+				collection_id,
+				item_3,
+				Some(price_1),
+				None,
+			));
+
+			// lock the collection
+			assert_ok!(Nfts::lock_collection(
+				RuntimeOrigin::signed(user_1.clone()),
+				collection_id,
+				CollectionSettings::from_disabled(CollectionSetting::TransferableItems.into())
+			));
+
+			let buy_item_call = mock::RuntimeCall::Nfts(crate::Call::<Test>::buy_item {
+				collection: collection_id,
+				item: item_3,
+				bid_price: price_1,
+			});
+			assert_noop!(
+				buy_item_call.dispatch(RuntimeOrigin::signed(user_2.clone())),
+				Error::<Test>::ItemsNonTransferable
+			);
+
+			// unlock the collection
+			assert_ok!(Nfts::force_collection_config(
+				RuntimeOrigin::root(),
+				collection_id,
+				collection_config_with_all_settings_enabled(),
+			));
+
+			// lock the transfer
+			assert_ok!(Nfts::lock_item_transfer(
+				RuntimeOrigin::signed(user_1.clone()),
+				collection_id,
+				item_3,
+			));
+
+			let buy_item_call = mock::RuntimeCall::Nfts(crate::Call::<Test>::buy_item {
+				collection: collection_id,
+				item: item_3,
+				bid_price: price_1,
+			});
+			assert_noop!(
+				buy_item_call.dispatch(RuntimeOrigin::signed(user_2)),
+				Error::<Test>::ItemLocked
+			);
+		}
+	});
+}
+
+#[test]
+fn pay_tips_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_1 = account(1);
+		let user_2 = account(2);
+		let user_3 = account(3);
+		let collection_id = 0;
+		let item_id = 1;
+		let tip = 2;
+		let initial_balance = 100;
+
+		Balances::make_free_balance_be(&user_1, initial_balance);
+		Balances::make_free_balance_be(&user_2, initial_balance);
+		Balances::make_free_balance_be(&user_3, initial_balance);
+
+		assert_ok!(Nfts::pay_tips(
+			RuntimeOrigin::signed(user_1.clone()),
+			bvec![
+				ItemTip {
+					collection: collection_id,
+					item: item_id,
+					receiver: user_2.clone(),
+					amount: tip
+				},
+				ItemTip {
+					collection: collection_id,
+					item: item_id,
+					receiver: user_3.clone(),
+					amount: tip
+				},
+			]
+		));
+
+		assert_eq!(Balances::total_balance(&user_1), initial_balance - tip * 2);
+		assert_eq!(Balances::total_balance(&user_2), initial_balance + tip);
+		assert_eq!(Balances::total_balance(&user_3), initial_balance + tip);
+
+		let events = events();
+		assert!(events.contains(&Event::<Test>::TipSent {
+			collection: collection_id,
+			item: item_id,
+			sender: user_1.clone(),
+			receiver: user_2.clone(),
+			amount: tip,
+		}));
+		assert!(events.contains(&Event::<Test>::TipSent {
+			collection: collection_id,
+			item: item_id,
+			sender: user_1.clone(),
+			receiver: user_3.clone(),
+			amount: tip,
+		}));
+	});
+}
+
+#[test]
+fn create_cancel_swap_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		let user_id = account(1);
+		let collection_id = 0;
+		let item_1 = 1;
+		let item_2 = 2;
+		let price = 1;
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		let duration = 2;
+		let expect_deadline = 3;
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			default_collection_config()
+		));
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_1,
+			user_id.clone(),
+			None,
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_2,
+			user_id.clone(),
+			None,
+		));
+
+		// validate desired item and the collection exists
+		assert_noop!(
+			Nfts::create_swap(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				item_1,
+				collection_id,
+				Some(item_2 + 1),
+				Some(price_with_direction.clone()),
+				duration,
+			),
+			Error::<Test>::UnknownItem
+		);
+		assert_noop!(
+			Nfts::create_swap(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				item_1,
+				collection_id + 1,
+				None,
+				Some(price_with_direction.clone()),
+				duration,
+			),
+			Error::<Test>::UnknownCollection
+		);
+
+		let max_duration: u64 = <Test as Config>::MaxDeadlineDuration::get();
+		assert_noop!(
+			Nfts::create_swap(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				item_1,
+				collection_id,
+				Some(item_2),
+				Some(price_with_direction.clone()),
+				max_duration.saturating_add(1),
+			),
+			Error::<Test>::WrongDuration
+		);
+
+		assert_ok!(Nfts::create_swap(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_1,
+			collection_id,
+			Some(item_2),
+			Some(price_with_direction.clone()),
+			duration,
+		));
+
+		let swap = PendingSwapOf::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(swap.desired_collection, collection_id);
+		assert_eq!(swap.desired_item, Some(item_2));
+		assert_eq!(swap.price, Some(price_with_direction.clone()));
+		assert_eq!(swap.deadline, expect_deadline);
+
+		assert!(events().contains(&Event::<Test>::SwapCreated {
+			offered_collection: collection_id,
+			offered_item: item_1,
+			desired_collection: collection_id,
+			desired_item: Some(item_2),
+			price: Some(price_with_direction.clone()),
+			deadline: expect_deadline,
+		}));
+
+		// validate we can cancel the swap
+		assert_ok!(Nfts::cancel_swap(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_1
+		));
+		assert!(events().contains(&Event::<Test>::SwapCancelled {
+			offered_collection: collection_id,
+			offered_item: item_1,
+			desired_collection: collection_id,
+			desired_item: Some(item_2),
+			price: Some(price_with_direction.clone()),
+			deadline: expect_deadline,
+		}));
+		assert!(!PendingSwapOf::<Test>::contains_key(collection_id, item_1));
+
+		// validate anyone can cancel the expired swap
+		assert_ok!(Nfts::create_swap(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_1,
+			collection_id,
+			Some(item_2),
+			Some(price_with_direction.clone()),
+			duration,
+		));
+		assert_noop!(
+			Nfts::cancel_swap(RuntimeOrigin::signed(account(2)), collection_id, item_1),
+			Error::<Test>::NoPermission
+		);
+		System::set_block_number(expect_deadline + 1);
+		assert_ok!(Nfts::cancel_swap(RuntimeOrigin::signed(account(2)), collection_id, item_1));
+
+		// validate optional desired_item param
+		assert_ok!(Nfts::create_swap(
+			RuntimeOrigin::signed(user_id),
+			collection_id,
+			item_1,
+			collection_id,
+			None,
+			Some(price_with_direction),
+			duration,
+		));
+
+		let swap = PendingSwapOf::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(swap.desired_item, None);
+	});
+}
+
+#[test]
+fn claim_swap_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		let user_1 = account(1);
+		let user_2 = account(2);
+		let collection_id = 0;
+		let item_1 = 1;
+		let item_2 = 2;
+		let item_3 = 3;
+		let item_4 = 4;
+		let item_5 = 5;
+		let price = 100;
+		let price_direction = PriceDirection::Receive;
+		let price_with_direction =
+			PriceWithDirection { amount: price, direction: price_direction.clone() };
+		let duration = 2;
+		let initial_balance = 1000;
+		let deadline = 1 + duration;
+
+		Balances::make_free_balance_be(&user_1, initial_balance);
+		Balances::make_free_balance_be(&user_2, initial_balance);
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_1.clone(),
+			default_collection_config()
+		));
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_1,
+			user_1.clone(),
+			None,
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_2,
+			user_2.clone(),
+			default_item_config(),
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_3,
+			user_2.clone(),
+			default_item_config(),
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_4,
+			user_1.clone(),
+			None,
+		));
+		assert_ok!(Nfts::force_mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_5,
+			user_2.clone(),
+			default_item_config(),
+		));
+
+		assert_ok!(Nfts::create_swap(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_1,
+			collection_id,
+			Some(item_2),
+			Some(price_with_direction.clone()),
+			duration,
+		));
+
+		// validate the deadline
+		System::set_block_number(5);
+		assert_noop!(
+			Nfts::claim_swap(
+				RuntimeOrigin::signed(user_2.clone()),
+				collection_id,
+				item_2,
+				collection_id,
+				item_1,
+				Some(price_with_direction.clone()),
+			),
+			Error::<Test>::DeadlineExpired
+		);
+		System::set_block_number(1);
+
+		// validate edge cases
+		assert_noop!(
+			Nfts::claim_swap(
+				RuntimeOrigin::signed(user_2.clone()),
+				collection_id,
+				item_2,
+				collection_id,
+				item_4, // no swap was created for that asset
+				Some(price_with_direction.clone()),
+			),
+			Error::<Test>::UnknownSwap
+		);
+		assert_noop!(
+			Nfts::claim_swap(
+				RuntimeOrigin::signed(user_2.clone()),
+				collection_id,
+				item_4, // not my item
+				collection_id,
+				item_1,
+				Some(price_with_direction.clone()),
+			),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Nfts::claim_swap(
+				RuntimeOrigin::signed(user_2.clone()),
+				collection_id,
+				item_5, // my item, but not the one another part wants
+				collection_id,
+				item_1,
+				Some(price_with_direction.clone()),
+			),
+			Error::<Test>::UnknownSwap
+		);
+		assert_noop!(
+			Nfts::claim_swap(
+				RuntimeOrigin::signed(user_2.clone()),
+				collection_id,
+				item_2,
+				collection_id,
+				item_1,
+				Some(PriceWithDirection { amount: price + 1, direction: price_direction.clone() }), // wrong price
+			),
+			Error::<Test>::UnknownSwap
+		);
+		assert_noop!(
+			Nfts::claim_swap(
+				RuntimeOrigin::signed(user_2.clone()),
+				collection_id,
+				item_2,
+				collection_id,
+				item_1,
+				Some(PriceWithDirection { amount: price, direction: PriceDirection::Send }), // wrong direction
+			),
+			Error::<Test>::UnknownSwap
+		);
+
+		assert_ok!(Nfts::claim_swap(
+			RuntimeOrigin::signed(user_2.clone()),
+			collection_id,
+			item_2,
+			collection_id,
+			item_1,
+			Some(price_with_direction.clone()),
+		));
+
+		// validate the new owner
+		let item = Item::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(item.owner, user_2.clone());
+		let item = Item::<Test>::get(collection_id, item_2).unwrap();
+		assert_eq!(item.owner, user_1.clone());
+
+		// validate the balances
+		assert_eq!(Balances::total_balance(&user_1), initial_balance + price);
+		assert_eq!(Balances::total_balance(&user_2), initial_balance - price);
+
+		// ensure we reset the swap
+		assert!(!PendingSwapOf::<Test>::contains_key(collection_id, item_1));
+
+		// validate the event
+		assert!(events().contains(&Event::<Test>::SwapClaimed {
+			sent_collection: collection_id,
+			sent_item: item_2,
+			sent_item_owner: user_2.clone(),
+			received_collection: collection_id,
+			received_item: item_1,
+			received_item_owner: user_1.clone(),
+			price: Some(price_with_direction.clone()),
+			deadline,
+		}));
+
+		// validate the optional desired_item param and another price direction
+		let price_direction = PriceDirection::Send;
+		let price_with_direction = PriceWithDirection { amount: price, direction: price_direction };
+		Balances::make_free_balance_be(&user_1, initial_balance);
+		Balances::make_free_balance_be(&user_2, initial_balance);
+
+		assert_ok!(Nfts::create_swap(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_4,
+			collection_id,
+			None,
+			Some(price_with_direction.clone()),
+			duration,
+		));
+		assert_ok!(Nfts::claim_swap(
+			RuntimeOrigin::signed(user_2.clone()),
+			collection_id,
+			item_1,
+			collection_id,
+			item_4,
+			Some(price_with_direction),
+		));
+		let item = Item::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(item.owner, user_1);
+		let item = Item::<Test>::get(collection_id, item_4).unwrap();
+		assert_eq!(item.owner, user_2);
+
+		assert_eq!(Balances::total_balance(&user_1), initial_balance - price);
+		assert_eq!(Balances::total_balance(&user_2), initial_balance + price);
+	});
+}
+
+#[test]
+fn various_collection_settings() {
+	new_test_ext().execute_with(|| {
+		// when we set only one value it's required to call .into() on it
+		let config =
+			collection_config_from_disabled_settings(CollectionSetting::TransferableItems.into());
+		assert_ok!(Nfts::force_create(RuntimeOrigin::root(), account(1), config));
+
+		let config = CollectionConfigOf::<Test>::get(0).unwrap();
+		assert!(!config.is_setting_enabled(CollectionSetting::TransferableItems));
+		assert!(config.is_setting_enabled(CollectionSetting::UnlockedMetadata));
+
+		// no need to call .into() for multiple values
+		let config = collection_config_from_disabled_settings(
+			CollectionSetting::UnlockedMetadata | CollectionSetting::TransferableItems,
+		);
+		assert_ok!(Nfts::force_create(RuntimeOrigin::root(), account(1), config));
+
+		let config = CollectionConfigOf::<Test>::get(1).unwrap();
+		assert!(!config.is_setting_enabled(CollectionSetting::TransferableItems));
+		assert!(!config.is_setting_enabled(CollectionSetting::UnlockedMetadata));
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			account(1),
+			default_collection_config()
+		));
+	});
+}
+
+#[test]
+fn collection_locking_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_id = account(1);
+		let collection_id = 0;
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			collection_config_with_all_settings_enabled()
+		));
+
+		let lock_config =
+			collection_config_from_disabled_settings(CollectionSetting::DepositRequired.into());
+		assert_noop!(
+			Nfts::lock_collection(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				lock_config.settings,
+			),
+			Error::<Test>::WrongSetting
+		);
+
+		// validate partial lock
+		let lock_config = collection_config_from_disabled_settings(
+			CollectionSetting::TransferableItems | CollectionSetting::UnlockedAttributes,
+		);
+		assert_ok!(Nfts::lock_collection(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			lock_config.settings,
+		));
+
+		let stored_config = CollectionConfigOf::<Test>::get(collection_id).unwrap();
+		assert_eq!(stored_config, lock_config);
+
+		// validate full lock
+		assert_ok!(Nfts::lock_collection(
+			RuntimeOrigin::signed(user_id),
+			collection_id,
+			CollectionSettings::from_disabled(CollectionSetting::UnlockedMetadata.into()),
+		));
+
+		let stored_config = CollectionConfigOf::<Test>::get(collection_id).unwrap();
+		let full_lock_config = collection_config_from_disabled_settings(
+			CollectionSetting::TransferableItems |
+				CollectionSetting::UnlockedMetadata |
+				CollectionSetting::UnlockedAttributes,
+		);
+		assert_eq!(stored_config, full_lock_config);
+	});
+}
+
+#[test]
+fn pallet_level_feature_flags_should_work() {
+	new_test_ext().execute_with(|| {
+		Features::set(&PalletFeatures::from_disabled(
+			PalletFeature::Trading | PalletFeature::Approvals | PalletFeature::Attributes,
+		));
+
+		let user_id = account(1);
+		let collection_id = 0;
+		let item_id = 1;
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_id.clone(),
+			default_collection_config()
+		));
+
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_id.clone()),
+			collection_id,
+			item_id,
+			user_id.clone(),
+			None,
+		));
+
+		// PalletFeature::Trading
+		assert_noop!(
+			Nfts::set_price(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				item_id,
+				Some(1),
+				None
+			),
+			Error::<Test>::MethodDisabled
+		);
+		assert_noop!(
+			Nfts::buy_item(RuntimeOrigin::signed(user_id.clone()), collection_id, item_id, 1),
+			Error::<Test>::MethodDisabled
+		);
+
+		// PalletFeature::Approvals
+		assert_noop!(
+			Nfts::approve_transfer(
+				RuntimeOrigin::signed(user_id.clone()),
+				collection_id,
+				item_id,
+				account(2),
+				None
+			),
+			Error::<Test>::MethodDisabled
+		);
+
+		// PalletFeature::Attributes
+		assert_noop!(
+			Nfts::set_attribute(
+				RuntimeOrigin::signed(user_id),
+				collection_id,
+				None,
+				AttributeNamespace::CollectionOwner,
+				bvec![0],
+				bvec![0],
+			),
+			Error::<Test>::MethodDisabled
+		);
+	})
+}
+
+#[test]
+fn group_roles_by_account_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Nfts::group_roles_by_account(vec![]), vec![]);
+
+		let account_to_role = Nfts::group_roles_by_account(vec![
+			(account(3), CollectionRole::Freezer),
+			(account(1), CollectionRole::Issuer),
+			(account(2), CollectionRole::Admin),
+		]);
+		let expect = vec![
+			(account(1), CollectionRoles(CollectionRole::Issuer.into())),
+			(account(2), CollectionRoles(CollectionRole::Admin.into())),
+			(account(3), CollectionRoles(CollectionRole::Freezer.into())),
+		];
+		assert_eq!(account_to_role, expect);
+
+		let account_to_role = Nfts::group_roles_by_account(vec![
+			(account(3), CollectionRole::Freezer),
+			(account(2), CollectionRole::Issuer),
+			(account(2), CollectionRole::Admin),
+		]);
+		let expect = vec![
+			(account(2), CollectionRoles(CollectionRole::Issuer | CollectionRole::Admin)),
+			(account(3), CollectionRoles(CollectionRole::Freezer.into())),
+		];
+		assert_eq!(account_to_role, expect);
+	})
+}
+
+#[test]
+fn add_remove_item_attributes_approval_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_1 = account(1);
+		let user_2 = account(2);
+		let user_3 = account(3);
+		let user_4 = account(4);
+		let collection_id = 0;
+		let item_id = 0;
+
+		assert_ok!(Nfts::force_create(
+			RuntimeOrigin::root(),
+			user_1.clone(),
+			default_collection_config()
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_id,
+			user_1.clone(),
+			None
+		));
+		assert_ok!(Nfts::approve_item_attributes(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_id,
+			user_2.clone(),
+		));
+		assert_eq!(item_attributes_approvals(collection_id, item_id), vec![user_2.clone()]);
+
+		assert_ok!(Nfts::approve_item_attributes(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_id,
+			user_3.clone(),
+		));
+		assert_ok!(Nfts::approve_item_attributes(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_id,
+			user_2.clone(),
+		));
+		assert_eq!(
+			item_attributes_approvals(collection_id, item_id),
+			vec![user_2.clone(), user_3.clone()]
+		);
+
+		assert_noop!(
+			Nfts::approve_item_attributes(
+				RuntimeOrigin::signed(user_1.clone()),
+				collection_id,
+				item_id,
+				user_4,
+			),
+			Error::<Test>::ReachedApprovalLimit
+		);
+
+		assert_ok!(Nfts::cancel_item_attributes_approval(
+			RuntimeOrigin::signed(user_1),
+			collection_id,
+			item_id,
+			user_2,
+			CancelAttributesApprovalWitness { account_attributes: 1 },
+		));
+		assert_eq!(item_attributes_approvals(collection_id, item_id), vec![user_3]);
+	})
+}
+
+#[test]
+fn validate_signature() {
+	new_test_ext().execute_with(|| {
+		let user_1_pair = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let user_1_signer = MultiSigner::Sr25519(user_1_pair.public());
+		let user_1 = user_1_signer.clone().into_account();
+		let mint_data: PreSignedMint<u32, u32, AccountId, u32, u64> = PreSignedMint {
+			collection: 0,
+			item: 0,
+			attributes: vec![],
+			metadata: vec![],
+			only_account: None,
+			deadline: 100000,
+			mint_price: None,
+		};
+		let encoded_data = Encode::encode(&mint_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&encoded_data));
+		assert_ok!(Nfts::validate_signature(&encoded_data, &signature, &user_1));
+
+		let mut wrapped_data: Vec<u8> = Vec::new();
+		wrapped_data.extend(b"<Bytes>");
+		wrapped_data.extend(&encoded_data);
+		wrapped_data.extend(b"</Bytes>");
+
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&wrapped_data));
+		assert_ok!(Nfts::validate_signature(&encoded_data, &signature, &user_1));
+	})
+}
+
+#[test]
+fn pre_signed_mints_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_0 = account(0);
+		let user_1_pair = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let user_1_signer = MultiSigner::Sr25519(user_1_pair.public());
+		let user_1 = user_1_signer.clone().into_account();
+		let mint_data = PreSignedMint {
+			collection: 0,
+			item: 0,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3])],
+			metadata: vec![0, 1],
+			only_account: None,
+			deadline: 10000000,
+			mint_price: Some(10),
+		};
+		let message = Encode::encode(&mint_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+		let user_2 = account(2);
+		let user_3 = account(3);
+
+		Balances::make_free_balance_be(&user_0, 100);
+		Balances::make_free_balance_be(&user_2, 100);
+		assert_ok!(Nfts::create(
+			RuntimeOrigin::signed(user_0.clone()),
+			user_1.clone(),
+			collection_config_with_all_settings_enabled(),
+		));
+
+		assert_ok!(Nfts::mint_pre_signed(
+			RuntimeOrigin::signed(user_2.clone()),
+			Box::new(mint_data.clone()),
+			signature.clone(),
+			user_1.clone(),
+		));
+		assert_eq!(items(), vec![(user_2.clone(), 0, 0)]);
+		let metadata = ItemMetadataOf::<Test>::get(0, 0).unwrap();
+		assert_eq!(
+			metadata.deposit,
+			ItemMetadataDeposit { account: Some(user_2.clone()), amount: 3 }
+		);
+		assert_eq!(metadata.data, vec![0, 1]);
+
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![1]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![2], bvec![3]),
+			]
+		);
+		let attribute_key: BoundedVec<_, _> = bvec![0];
+		let (_, deposit) = Attribute::<Test>::get((
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			&attribute_key,
+		))
+		.unwrap();
+		assert_eq!(deposit.account, Some(user_2.clone()));
+		assert_eq!(deposit.amount, 3);
+
+		assert_eq!(Balances::free_balance(&user_0), 100 - 2 + 10); // 2 - collection deposit, 10 - mint price
+		assert_eq!(Balances::free_balance(&user_2), 100 - 1 - 3 - 6 - 10); // 1 - item deposit, 3 - metadata, 6 - attributes, 10 - mint price
+
+		assert_noop!(
+			Nfts::mint_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				Box::new(mint_data),
+				signature.clone(),
+				user_1.clone(),
+			),
+			Error::<Test>::AlreadyExists
+		);
+
+		assert_ok!(Nfts::burn(RuntimeOrigin::signed(user_2.clone()), 0, 0));
+		assert_eq!(Balances::free_balance(&user_2), 100 - 6 - 10);
+
+		// validate the `only_account` field
+		let mint_data = PreSignedMint {
+			collection: 0,
+			item: 0,
+			attributes: vec![],
+			metadata: vec![],
+			only_account: Some(account(2)),
+			deadline: 10000000,
+			mint_price: None,
+		};
+
+		// can't mint with the wrong signature
+		assert_noop!(
+			Nfts::mint_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				Box::new(mint_data.clone()),
+				signature.clone(),
+				user_1.clone(),
+			),
+			Error::<Test>::WrongSignature
+		);
+
+		let message = Encode::encode(&mint_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+
+		assert_noop!(
+			Nfts::mint_pre_signed(
+				RuntimeOrigin::signed(user_3),
+				Box::new(mint_data.clone()),
+				signature.clone(),
+				user_1.clone(),
+			),
+			Error::<Test>::WrongOrigin
+		);
+
+		// validate signature's expiration
+		System::set_block_number(10000001);
+		assert_noop!(
+			Nfts::mint_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				Box::new(mint_data),
+				signature,
+				user_1.clone(),
+			),
+			Error::<Test>::DeadlineExpired
+		);
+		System::set_block_number(1);
+
+		// validate the collection
+		let mint_data = PreSignedMint {
+			collection: 1,
+			item: 0,
+			attributes: vec![],
+			metadata: vec![],
+			only_account: Some(account(2)),
+			deadline: 10000000,
+			mint_price: None,
+		};
+		let message = Encode::encode(&mint_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+
+		assert_noop!(
+			Nfts::mint_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				Box::new(mint_data),
+				signature,
+				user_1.clone(),
+			),
+			Error::<Test>::NoPermission
+		);
+
+		// validate max attributes limit
+		let mint_data = PreSignedMint {
+			collection: 0,
+			item: 0,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3]), (vec![2], vec![3])],
+			metadata: vec![0, 1],
+			only_account: None,
+			deadline: 10000000,
+			mint_price: None,
+		};
+		let message = Encode::encode(&mint_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+		assert_noop!(
+			Nfts::mint_pre_signed(
+				RuntimeOrigin::signed(user_2),
+				Box::new(mint_data),
+				signature,
+				user_1.clone(),
+			),
+			Error::<Test>::MaxAttributesLimitReached
+		);
+	})
+}
+
+#[test]
+fn pre_signed_attributes_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_1_pair = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let user_1_signer = MultiSigner::Sr25519(user_1_pair.public());
+		let user_1 = user_1_signer.clone().into_account();
+		let user_2 = account(2);
+		let user_3_pair = sp_core::sr25519::Pair::from_string("//Bob", None).unwrap();
+		let user_3_signer = MultiSigner::Sr25519(user_3_pair.public());
+		let user_3 = user_3_signer.clone().into_account();
+		let collection_id = 0;
+		let item_id = 0;
+
+		Balances::make_free_balance_be(&user_1, 100);
+		Balances::make_free_balance_be(&user_2, 100);
+		Balances::make_free_balance_be(&user_3, 100);
+		assert_ok!(Nfts::create(
+			RuntimeOrigin::signed(user_1.clone()),
+			user_1.clone(),
+			collection_config_with_all_settings_enabled(),
+		));
+		assert_ok!(Nfts::mint(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			item_id,
+			user_2.clone(),
+			None,
+		));
+
+		// validate the CollectionOwner namespace
+		let pre_signed_data = PreSignedAttributes {
+			collection: 0,
+			item: 0,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3])],
+			namespace: AttributeNamespace::CollectionOwner,
+			deadline: 10000000,
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+
+		assert_ok!(Nfts::set_attributes_pre_signed(
+			RuntimeOrigin::signed(user_2.clone()),
+			pre_signed_data.clone(),
+			signature.clone(),
+			user_1.clone(),
+		));
+
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![1]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![2], bvec![3]),
+			]
+		);
+		let attribute_key: BoundedVec<_, _> = bvec![0];
+		let (_, deposit) = Attribute::<Test>::get((
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			&attribute_key,
+		))
+		.unwrap();
+		assert_eq!(deposit.account, Some(user_2.clone()));
+		assert_eq!(deposit.amount, 3);
+
+		assert_eq!(Balances::free_balance(&user_1), 100 - 2 - 1); // 2 - collection deposit, 1 - item deposit
+		assert_eq!(Balances::free_balance(&user_2), 100 - 6); // 6 - attributes
+
+		// validate the deposit gets returned on attribute update from collection's owner
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(user_1.clone()),
+			collection_id,
+			Some(item_id),
+			AttributeNamespace::CollectionOwner,
+			bvec![0],
+			bvec![1],
+		));
+		let (_, deposit) = Attribute::<Test>::get((
+			0,
+			Some(0),
+			AttributeNamespace::CollectionOwner,
+			&attribute_key,
+		))
+		.unwrap();
+		assert_eq!(deposit.account, None);
+		assert_eq!(deposit.amount, 3);
+
+		// validate we don't partially modify the state
+		assert_eq!(item_attributes_approvals(collection_id, item_id), vec![]);
+		let pre_signed_data = PreSignedAttributes {
+			collection: 0,
+			item: 0,
+			attributes: vec![(vec![0], vec![1]), (vec![2; 51], vec![3])],
+			namespace: AttributeNamespace::Account(user_3.clone()),
+			deadline: 10000000,
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(user_3_pair.sign(&message));
+
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_3.clone(),
+			),
+			Error::<Test>::IncorrectData
+		);
+
+		// no new approval was set
+		assert_eq!(item_attributes_approvals(collection_id, item_id), vec![]);
+
+		// no new attributes were added
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![1]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![2], bvec![3]),
+			]
+		);
+
+		// validate the Account namespace
+		let pre_signed_data = PreSignedAttributes {
+			collection: 0,
+			item: 0,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3])],
+			namespace: AttributeNamespace::Account(user_3.clone()),
+			deadline: 10000000,
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(user_3_pair.sign(&message));
+
+		assert_ok!(Nfts::set_attributes_pre_signed(
+			RuntimeOrigin::signed(user_2.clone()),
+			pre_signed_data.clone(),
+			signature.clone(),
+			user_3.clone(),
+		));
+
+		assert_eq!(
+			attributes(0),
+			vec![
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![0], bvec![1]),
+				(Some(0), AttributeNamespace::Account(user_3.clone()), bvec![0], bvec![1]),
+				(Some(0), AttributeNamespace::CollectionOwner, bvec![2], bvec![3]),
+				(Some(0), AttributeNamespace::Account(user_3.clone()), bvec![2], bvec![3]),
+			]
+		);
+		assert_eq!(item_attributes_approvals(collection_id, item_id), vec![user_3.clone()]);
+
+		let attribute_key: BoundedVec<_, _> = bvec![0];
+		let (_, deposit) = Attribute::<Test>::get((
+			0,
+			Some(0),
+			AttributeNamespace::Account(user_3.clone()),
+			&attribute_key,
+		))
+		.unwrap();
+		assert_eq!(deposit.account, Some(user_2.clone()));
+		assert_eq!(deposit.amount, 3);
+
+		assert_eq!(Balances::free_balance(&user_2), 100 - 9);
+		assert_eq!(Balances::free_balance(&user_3), 100);
+
+		// validate the deposit gets returned on attribute update from user_3
+		assert_ok!(Nfts::set_attribute(
+			RuntimeOrigin::signed(user_3.clone()),
+			collection_id,
+			Some(item_id),
+			AttributeNamespace::Account(user_3.clone()),
+			bvec![0],
+			bvec![1],
+		));
+		let (_, deposit) = Attribute::<Test>::get((
+			0,
+			Some(0),
+			AttributeNamespace::Account(user_3.clone()),
+			&attribute_key,
+		))
+		.unwrap();
+		assert_eq!(deposit.account, Some(user_3.clone()));
+		assert_eq!(deposit.amount, 3);
+
+		assert_eq!(Balances::free_balance(&user_2), 100 - 6);
+		assert_eq!(Balances::free_balance(&user_3), 100 - 3);
+
+		// can't update with the wrong signature
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_1.clone(),
+			),
+			Error::<Test>::WrongSignature
+		);
+
+		// can't update if I don't own that item
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_3.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_3.clone(),
+			),
+			Error::<Test>::NoPermission
+		);
+
+		// can't update the CollectionOwner namespace if the signer is not an owner of that
+		// collection
+		let pre_signed_data = PreSignedAttributes {
+			collection: 0,
+			item: 0,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3])],
+			namespace: AttributeNamespace::CollectionOwner,
+			deadline: 10000000,
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(user_3_pair.sign(&message));
+
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_3.clone(),
+			),
+			Error::<Test>::NoPermission
+		);
+
+		// validate signature's expiration
+		System::set_block_number(10000001);
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_3.clone(),
+			),
+			Error::<Test>::DeadlineExpired
+		);
+		System::set_block_number(1);
+
+		// validate item & collection
+		let pre_signed_data = PreSignedAttributes {
+			collection: 1,
+			item: 1,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3])],
+			namespace: AttributeNamespace::CollectionOwner,
+			deadline: 10000000,
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_1.clone(),
+			),
+			Error::<Test>::UnknownItem
+		);
+
+		// validate max attributes limit
+		let pre_signed_data = PreSignedAttributes {
+			collection: 1,
+			item: 1,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3]), (vec![2], vec![3])],
+			namespace: AttributeNamespace::CollectionOwner,
+			deadline: 10000000,
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_1.clone(),
+			),
+			Error::<Test>::MaxAttributesLimitReached
+		);
+
+		// validate the attribute's value length
+		let pre_signed_data = PreSignedAttributes {
+			collection: 0,
+			item: 0,
+			attributes: vec![(vec![0], vec![1]), (vec![2], vec![3; 51])],
+			namespace: AttributeNamespace::CollectionOwner,
+			deadline: 10000000,
+		};
+		let message = Encode::encode(&pre_signed_data);
+		let signature = MultiSignature::Sr25519(user_1_pair.sign(&message));
+
+		assert_noop!(
+			Nfts::set_attributes_pre_signed(
+				RuntimeOrigin::signed(user_2.clone()),
+				pre_signed_data.clone(),
+				signature.clone(),
+				user_1.clone(),
+			),
+			Error::<Test>::IncorrectData
+		);
+	})
+}
+
+#[test]
+fn basic_create_collection_with_id_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Nfts::create_collection_with_id(
+				0u32,
+				&account(1),
+				&account(1),
+				&default_collection_config(),
+			),
+			Error::<Test>::WrongSetting
+		);
+
+		Balances::make_free_balance_be(&account(1), 100);
+		Balances::make_free_balance_be(&account(2), 100);
+
+		assert_ok!(Nfts::create_collection_with_id(
+			0u32,
+			&account(1),
+			&account(1),
+			&collection_config_with_all_settings_enabled(),
+		));
+
+		assert_eq!(collections(), vec![(account(1), 0)]);
+
+		// CollectionId already taken.
+		assert_noop!(
+			Nfts::create_collection_with_id(
+				0u32,
+				&account(2),
+				&account(2),
+				&collection_config_with_all_settings_enabled(),
+			),
+			Error::<Test>::CollectionIdInUse
+		);
+	});
+}
diff --git a/substrate/frame/nfts/src/types.rs b/substrate/frame/nfts/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5a9f6ae2f0e215341aba160fc24cd5eebe6dd682
--- /dev/null
+++ b/substrate/frame/nfts/src/types.rs
@@ -0,0 +1,547 @@
+// 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 module contains various basic types and data structures used in the NFTs pallet.
+
+use super::*;
+use crate::macros::*;
+use codec::EncodeLike;
+use enumflags2::{bitflags, BitFlags};
+use frame_support::{
+	pallet_prelude::{BoundedVec, MaxEncodedLen},
+	traits::Get,
+	BoundedBTreeMap, BoundedBTreeSet,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use scale_info::{build::Fields, meta_type, Path, Type, TypeInfo, TypeParameter};
+
+/// A type alias for handling balance deposits.
+pub(super) type DepositBalanceOf<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance;
+/// A type alias representing the details of a collection.
+pub(super) type CollectionDetailsFor<T, I> =
+	CollectionDetails<<T as SystemConfig>::AccountId, DepositBalanceOf<T, I>>;
+/// A type alias for keeping track of approvals used by a single item.
+pub(super) type ApprovalsOf<T, I = ()> = BoundedBTreeMap<
+	<T as SystemConfig>::AccountId,
+	Option<BlockNumberFor<T>>,
+	<T as Config<I>>::ApprovalsLimit,
+>;
+/// A type alias for keeping track of approvals for an item's attributes.
+pub(super) type ItemAttributesApprovals<T, I = ()> =
+	BoundedBTreeSet<<T as SystemConfig>::AccountId, <T as Config<I>>::ItemAttributesApprovalsLimit>;
+/// A type that holds the deposit for a single item.
+pub(super) type ItemDepositOf<T, I> =
+	ItemDeposit<DepositBalanceOf<T, I>, <T as SystemConfig>::AccountId>;
+/// A type that holds the deposit amount for an item's attribute.
+pub(super) type AttributeDepositOf<T, I> =
+	AttributeDeposit<DepositBalanceOf<T, I>, <T as SystemConfig>::AccountId>;
+/// A type that holds the deposit amount for an item's metadata.
+pub(super) type ItemMetadataDepositOf<T, I> =
+	ItemMetadataDeposit<DepositBalanceOf<T, I>, <T as SystemConfig>::AccountId>;
+/// A type that holds the details of a single item.
+pub(super) type ItemDetailsFor<T, I> =
+	ItemDetails<<T as SystemConfig>::AccountId, ItemDepositOf<T, I>, ApprovalsOf<T, I>>;
+/// A type alias for an accounts balance.
+pub(super) type BalanceOf<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance;
+/// A type alias to represent the price of an item.
+pub(super) type ItemPrice<T, I = ()> = BalanceOf<T, I>;
+/// A type alias for the tips held by a single item.
+pub(super) type ItemTipOf<T, I = ()> = ItemTip<
+	<T as Config<I>>::CollectionId,
+	<T as Config<I>>::ItemId,
+	<T as SystemConfig>::AccountId,
+	BalanceOf<T, I>,
+>;
+/// A type alias for the settings configuration of a collection.
+pub(super) type CollectionConfigFor<T, I = ()> =
+	CollectionConfig<BalanceOf<T, I>, BlockNumberFor<T>, <T as Config<I>>::CollectionId>;
+/// A type alias for the pre-signed minting configuration for a specified collection.
+pub(super) type PreSignedMintOf<T, I = ()> = PreSignedMint<
+	<T as Config<I>>::CollectionId,
+	<T as Config<I>>::ItemId,
+	<T as SystemConfig>::AccountId,
+	BlockNumberFor<T>,
+	BalanceOf<T, I>,
+>;
+/// A type alias for the pre-signed minting configuration on the attribute level of an item.
+pub(super) type PreSignedAttributesOf<T, I = ()> = PreSignedAttributes<
+	<T as Config<I>>::CollectionId,
+	<T as Config<I>>::ItemId,
+	<T as SystemConfig>::AccountId,
+	BlockNumberFor<T>,
+>;
+
+/// Information about a collection.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct CollectionDetails<AccountId, DepositBalance> {
+	/// Collection's owner.
+	pub(super) owner: AccountId,
+	/// The total balance deposited by the owner for all the storage data associated with this
+	/// collection. Used by `destroy`.
+	pub(super) owner_deposit: DepositBalance,
+	/// The total number of outstanding items of this collection.
+	pub(super) items: u32,
+	/// The total number of outstanding item metadata of this collection.
+	pub(super) item_metadatas: u32,
+	/// The total number of outstanding item configs of this collection.
+	pub(super) item_configs: u32,
+	/// The total number of attributes for this collection.
+	pub(super) attributes: u32,
+}
+
+/// Witness data for the destroy transactions.
+#[derive(Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct DestroyWitness {
+	/// The total number of items in this collection that have outstanding item metadata.
+	#[codec(compact)]
+	pub item_metadatas: u32,
+	/// The total number of outstanding item configs of this collection.
+	#[codec(compact)]
+	pub item_configs: u32,
+	/// The total number of attributes for this collection.
+	#[codec(compact)]
+	pub attributes: u32,
+}
+
+impl<AccountId, DepositBalance> CollectionDetails<AccountId, DepositBalance> {
+	pub fn destroy_witness(&self) -> DestroyWitness {
+		DestroyWitness {
+			item_metadatas: self.item_metadatas,
+			item_configs: self.item_configs,
+			attributes: self.attributes,
+		}
+	}
+}
+
+/// Witness data for items mint transactions.
+#[derive(Clone, Encode, Decode, Default, Eq, PartialEq, RuntimeDebug, TypeInfo)]
+pub struct MintWitness<ItemId, Balance> {
+	/// Provide the id of the item in a required collection.
+	pub owned_item: Option<ItemId>,
+	/// The price specified in mint settings.
+	pub mint_price: Option<Balance>,
+}
+
+/// Information concerning the ownership of a single unique item.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, TypeInfo, MaxEncodedLen)]
+pub struct ItemDetails<AccountId, Deposit, Approvals> {
+	/// The owner of this item.
+	pub(super) owner: AccountId,
+	/// The approved transferrer of this item, if one is set.
+	pub(super) approvals: Approvals,
+	/// The amount held in the pallet's default account for this item. Free-hold items will have
+	/// this as zero.
+	pub(super) deposit: Deposit,
+}
+
+/// Information about the reserved item deposit.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ItemDeposit<DepositBalance, AccountId> {
+	/// A depositor account.
+	pub(super) account: AccountId,
+	/// An amount that gets reserved.
+	pub(super) amount: DepositBalance,
+}
+
+/// Information about the collection's metadata.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(StringLimit))]
+#[codec(mel_bound(Deposit: MaxEncodedLen))]
+pub struct CollectionMetadata<Deposit, StringLimit: Get<u32>> {
+	/// The balance deposited for this metadata.
+	///
+	/// This pays for the data stored in this struct.
+	pub(super) deposit: Deposit,
+	/// General information concerning this collection. Limited in length by `StringLimit`. This
+	/// will generally be either a JSON dump or the hash of some JSON which can be found on a
+	/// hash-addressable global publication system such as IPFS.
+	pub(super) data: BoundedVec<u8, StringLimit>,
+}
+
+/// Information about the item's metadata.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(StringLimit))]
+pub struct ItemMetadata<Deposit, StringLimit: Get<u32>> {
+	/// The balance deposited for this metadata.
+	///
+	/// This pays for the data stored in this struct.
+	pub(super) deposit: Deposit,
+	/// General information concerning this item. Limited in length by `StringLimit`. This will
+	/// generally be either a JSON dump or the hash of some JSON which can be found on a
+	/// hash-addressable global publication system such as IPFS.
+	pub(super) data: BoundedVec<u8, StringLimit>,
+}
+
+/// Information about the tip.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ItemTip<CollectionId, ItemId, AccountId, Amount> {
+	/// The collection of the item.
+	pub(super) collection: CollectionId,
+	/// An item of which the tip is sent for.
+	pub(super) item: ItemId,
+	/// A sender of the tip.
+	pub(super) receiver: AccountId,
+	/// An amount the sender is willing to tip.
+	pub(super) amount: Amount,
+}
+
+/// Information about the pending swap.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, TypeInfo, MaxEncodedLen)]
+pub struct PendingSwap<CollectionId, ItemId, ItemPriceWithDirection, Deadline> {
+	/// The collection that contains the item that the user wants to receive.
+	pub(super) desired_collection: CollectionId,
+	/// The item the user wants to receive.
+	pub(super) desired_item: Option<ItemId>,
+	/// A price for the desired `item` with the direction.
+	pub(super) price: Option<ItemPriceWithDirection>,
+	/// A deadline for the swap.
+	pub(super) deadline: Deadline,
+}
+
+/// Information about the reserved attribute deposit.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct AttributeDeposit<DepositBalance, AccountId> {
+	/// A depositor account.
+	pub(super) account: Option<AccountId>,
+	/// An amount that gets reserved.
+	pub(super) amount: DepositBalance,
+}
+
+/// Information about the reserved item's metadata deposit.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ItemMetadataDeposit<DepositBalance, AccountId> {
+	/// A depositor account, None means the deposit is collection's owner.
+	pub(super) account: Option<AccountId>,
+	/// An amount that gets reserved.
+	pub(super) amount: DepositBalance,
+}
+
+/// Specifies whether the tokens will be sent or received.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum PriceDirection {
+	/// Tokens will be sent.
+	Send,
+	/// Tokens will be received.
+	Receive,
+}
+
+/// Holds the details about the price.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct PriceWithDirection<Amount> {
+	/// An amount.
+	pub(super) amount: Amount,
+	/// A direction (send or receive).
+	pub(super) direction: PriceDirection,
+}
+
+/// Support for up to 64 user-enabled features on a collection.
+#[bitflags]
+#[repr(u64)]
+#[derive(Copy, Clone, RuntimeDebug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub enum CollectionSetting {
+	/// Items in this collection are transferable.
+	TransferableItems,
+	/// The metadata of this collection can be modified.
+	UnlockedMetadata,
+	/// Attributes of this collection can be modified.
+	UnlockedAttributes,
+	/// The supply of this collection can be modified.
+	UnlockedMaxSupply,
+	/// When this isn't set then the deposit is required to hold the items of this collection.
+	DepositRequired,
+}
+
+/// Wrapper type for `BitFlags<CollectionSetting>` that implements `Codec`.
+#[derive(Clone, Copy, PartialEq, Eq, Default, RuntimeDebug)]
+pub struct CollectionSettings(pub BitFlags<CollectionSetting>);
+
+impl CollectionSettings {
+	pub fn all_enabled() -> Self {
+		Self(BitFlags::EMPTY)
+	}
+	pub fn get_disabled(&self) -> BitFlags<CollectionSetting> {
+		self.0
+	}
+	pub fn is_disabled(&self, setting: CollectionSetting) -> bool {
+		self.0.contains(setting)
+	}
+	pub fn from_disabled(settings: BitFlags<CollectionSetting>) -> Self {
+		Self(settings)
+	}
+}
+
+impl_codec_bitflags!(CollectionSettings, u64, CollectionSetting);
+
+/// Mint type. Can the NFT be create by anyone, or only the creator of the collection,
+/// or only by wallets that already hold an NFT from a certain collection?
+/// The ownership of a privately minted NFT is still publicly visible.
+#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum MintType<CollectionId> {
+	/// Only an `Issuer` could mint items.
+	Issuer,
+	/// Anyone could mint items.
+	Public,
+	/// Only holders of items in specified collection could mint new items.
+	HolderOf(CollectionId),
+}
+
+/// Holds the information about minting.
+#[derive(Clone, Copy, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct MintSettings<Price, BlockNumber, CollectionId> {
+	/// Whether anyone can mint or if minters are restricted to some subset.
+	pub mint_type: MintType<CollectionId>,
+	/// An optional price per mint.
+	pub price: Option<Price>,
+	/// When the mint starts.
+	pub start_block: Option<BlockNumber>,
+	/// When the mint ends.
+	pub end_block: Option<BlockNumber>,
+	/// Default settings each item will get during the mint.
+	pub default_item_settings: ItemSettings,
+}
+
+impl<Price, BlockNumber, CollectionId> Default for MintSettings<Price, BlockNumber, CollectionId> {
+	fn default() -> Self {
+		Self {
+			mint_type: MintType::Issuer,
+			price: None,
+			start_block: None,
+			end_block: None,
+			default_item_settings: ItemSettings::all_enabled(),
+		}
+	}
+}
+
+/// Attribute namespaces for non-fungible tokens.
+#[derive(
+	Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, scale_info::TypeInfo, MaxEncodedLen,
+)]
+pub enum AttributeNamespace<AccountId> {
+	/// An attribute was set by the pallet.
+	Pallet,
+	/// An attribute was set by collection's owner.
+	CollectionOwner,
+	/// An attribute was set by item's owner.
+	ItemOwner,
+	/// An attribute was set by pre-approved account.
+	Account(AccountId),
+}
+
+/// A witness data to cancel attributes approval operation.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo)]
+pub struct CancelAttributesApprovalWitness {
+	/// An amount of attributes previously created by account.
+	pub account_attributes: u32,
+}
+
+/// A list of possible pallet-level attributes.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum PalletAttributes<CollectionId> {
+	/// Marks an item as being used in order to claim another item.
+	UsedToClaim(CollectionId),
+	/// Marks an item as being restricted from transferring.
+	TransferDisabled,
+}
+
+/// Collection's configuration.
+#[derive(
+	Clone, Copy, Decode, Default, Encode, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo,
+)]
+pub struct CollectionConfig<Price, BlockNumber, CollectionId> {
+	/// Collection's settings.
+	pub settings: CollectionSettings,
+	/// Collection's max supply.
+	pub max_supply: Option<u32>,
+	/// Default settings each item will get during the mint.
+	pub mint_settings: MintSettings<Price, BlockNumber, CollectionId>,
+}
+
+impl<Price, BlockNumber, CollectionId> CollectionConfig<Price, BlockNumber, CollectionId> {
+	pub fn is_setting_enabled(&self, setting: CollectionSetting) -> bool {
+		!self.settings.is_disabled(setting)
+	}
+	pub fn has_disabled_setting(&self, setting: CollectionSetting) -> bool {
+		self.settings.is_disabled(setting)
+	}
+	pub fn enable_setting(&mut self, setting: CollectionSetting) {
+		self.settings.0.remove(setting);
+	}
+	pub fn disable_setting(&mut self, setting: CollectionSetting) {
+		self.settings.0.insert(setting);
+	}
+}
+
+/// Support for up to 64 user-enabled features on an item.
+#[bitflags]
+#[repr(u64)]
+#[derive(Copy, Clone, RuntimeDebug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub enum ItemSetting {
+	/// This item is transferable.
+	Transferable,
+	/// The metadata of this item can be modified.
+	UnlockedMetadata,
+	/// Attributes of this item can be modified.
+	UnlockedAttributes,
+}
+
+/// Wrapper type for `BitFlags<ItemSetting>` that implements `Codec`.
+#[derive(Clone, Copy, PartialEq, Eq, Default, RuntimeDebug)]
+pub struct ItemSettings(pub BitFlags<ItemSetting>);
+
+impl ItemSettings {
+	pub fn all_enabled() -> Self {
+		Self(BitFlags::EMPTY)
+	}
+	pub fn get_disabled(&self) -> BitFlags<ItemSetting> {
+		self.0
+	}
+	pub fn is_disabled(&self, setting: ItemSetting) -> bool {
+		self.0.contains(setting)
+	}
+	pub fn from_disabled(settings: BitFlags<ItemSetting>) -> Self {
+		Self(settings)
+	}
+}
+
+impl_codec_bitflags!(ItemSettings, u64, ItemSetting);
+
+/// Item's configuration.
+#[derive(
+	Encode, Decode, Default, PartialEq, RuntimeDebug, Clone, Copy, MaxEncodedLen, TypeInfo,
+)]
+pub struct ItemConfig {
+	/// Item's settings.
+	pub settings: ItemSettings,
+}
+
+impl ItemConfig {
+	pub fn is_setting_enabled(&self, setting: ItemSetting) -> bool {
+		!self.settings.is_disabled(setting)
+	}
+	pub fn has_disabled_setting(&self, setting: ItemSetting) -> bool {
+		self.settings.is_disabled(setting)
+	}
+	pub fn has_disabled_settings(&self) -> bool {
+		!self.settings.get_disabled().is_empty()
+	}
+	pub fn enable_setting(&mut self, setting: ItemSetting) {
+		self.settings.0.remove(setting);
+	}
+	pub fn disable_setting(&mut self, setting: ItemSetting) {
+		self.settings.0.insert(setting);
+	}
+}
+
+/// Support for up to 64 system-enabled features on a collection.
+#[bitflags]
+#[repr(u64)]
+#[derive(Copy, Clone, RuntimeDebug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub enum PalletFeature {
+	/// Enable/disable trading operations.
+	Trading,
+	/// Allow/disallow setting attributes.
+	Attributes,
+	/// Allow/disallow transfer approvals.
+	Approvals,
+	/// Allow/disallow atomic items swap.
+	Swaps,
+}
+
+/// Wrapper type for `BitFlags<PalletFeature>` that implements `Codec`.
+#[derive(Default, RuntimeDebug)]
+pub struct PalletFeatures(pub BitFlags<PalletFeature>);
+
+impl PalletFeatures {
+	pub fn all_enabled() -> Self {
+		Self(BitFlags::EMPTY)
+	}
+	pub fn from_disabled(features: BitFlags<PalletFeature>) -> Self {
+		Self(features)
+	}
+	pub fn is_enabled(&self, feature: PalletFeature) -> bool {
+		!self.0.contains(feature)
+	}
+}
+impl_codec_bitflags!(PalletFeatures, u64, PalletFeature);
+
+/// Support for up to 8 different roles for collections.
+#[bitflags]
+#[repr(u8)]
+#[derive(Copy, Clone, RuntimeDebug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub enum CollectionRole {
+	/// Can mint items.
+	Issuer,
+	/// Can freeze items.
+	Freezer,
+	/// Can thaw items, force transfers and burn items from any account.
+	Admin,
+}
+
+/// A wrapper type that implements `Codec`.
+#[derive(Clone, Copy, PartialEq, Eq, Default, RuntimeDebug)]
+pub struct CollectionRoles(pub BitFlags<CollectionRole>);
+
+impl CollectionRoles {
+	pub fn none() -> Self {
+		Self(BitFlags::EMPTY)
+	}
+	pub fn has_role(&self, role: CollectionRole) -> bool {
+		self.0.contains(role)
+	}
+	pub fn add_role(&mut self, role: CollectionRole) {
+		self.0.insert(role);
+	}
+	pub fn max_roles() -> u8 {
+		let all: BitFlags<CollectionRole> = BitFlags::all();
+		all.len() as u8
+	}
+}
+impl_codec_bitflags!(CollectionRoles, u8, CollectionRole);
+
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct PreSignedMint<CollectionId, ItemId, AccountId, Deadline, Balance> {
+	/// A collection of the item to be minted.
+	pub(super) collection: CollectionId,
+	/// Item's ID.
+	pub(super) item: ItemId,
+	/// Additional item's key-value attributes.
+	pub(super) attributes: Vec<(Vec<u8>, Vec<u8>)>,
+	/// Additional item's metadata.
+	pub(super) metadata: Vec<u8>,
+	/// Restrict the claim to a particular account.
+	pub(super) only_account: Option<AccountId>,
+	/// A deadline for the signature.
+	pub(super) deadline: Deadline,
+	/// An optional price the claimer would need to pay for the mint.
+	pub(super) mint_price: Option<Balance>,
+}
+
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct PreSignedAttributes<CollectionId, ItemId, AccountId, Deadline> {
+	/// Collection's ID.
+	pub(super) collection: CollectionId,
+	/// Item's ID.
+	pub(super) item: ItemId,
+	/// Key-value attributes.
+	pub(super) attributes: Vec<(Vec<u8>, Vec<u8>)>,
+	/// Attributes' namespace.
+	pub(super) namespace: AttributeNamespace<AccountId>,
+	/// A deadline for the signature.
+	pub(super) deadline: Deadline,
+}
diff --git a/substrate/frame/nfts/src/weights.rs b/substrate/frame/nfts/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6b8c577bb12e5d19bf5751d2a5019d60aea743b0
--- /dev/null
+++ b/substrate/frame/nfts/src/weights.rs
@@ -0,0 +1,1460 @@
+// 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.
+
+//! Autogenerated weights for pallet_nfts
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_nfts
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/nfts/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_nfts.
+pub trait WeightInfo {
+	fn create() -> Weight;
+	fn force_create() -> Weight;
+	fn destroy(m: u32, c: u32, a: u32, ) -> Weight;
+	fn mint() -> Weight;
+	fn force_mint() -> Weight;
+	fn burn() -> Weight;
+	fn transfer() -> Weight;
+	fn redeposit(i: u32, ) -> Weight;
+	fn lock_item_transfer() -> Weight;
+	fn unlock_item_transfer() -> Weight;
+	fn lock_collection() -> Weight;
+	fn transfer_ownership() -> Weight;
+	fn set_team() -> Weight;
+	fn force_collection_owner() -> Weight;
+	fn force_collection_config() -> Weight;
+	fn lock_item_properties() -> Weight;
+	fn set_attribute() -> Weight;
+	fn force_set_attribute() -> Weight;
+	fn clear_attribute() -> Weight;
+	fn approve_item_attributes() -> Weight;
+	fn cancel_item_attributes_approval(n: u32, ) -> Weight;
+	fn set_metadata() -> Weight;
+	fn clear_metadata() -> Weight;
+	fn set_collection_metadata() -> Weight;
+	fn clear_collection_metadata() -> Weight;
+	fn approve_transfer() -> Weight;
+	fn cancel_approval() -> Weight;
+	fn clear_all_transfer_approvals() -> Weight;
+	fn set_accept_ownership() -> Weight;
+	fn set_collection_max_supply() -> Weight;
+	fn update_mint_settings() -> Weight;
+	fn set_price() -> Weight;
+	fn buy_item() -> Weight;
+	fn pay_tips(n: u32, ) -> Weight;
+	fn create_swap() -> Weight;
+	fn cancel_swap() -> Weight;
+	fn claim_swap() -> Weight;
+	fn mint_pre_signed(n: u32, ) -> Weight;
+	fn set_attributes_pre_signed(n: u32, ) -> Weight;
+}
+
+/// Weights for pallet_nfts using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Nfts NextCollectionId (r:1 w:1)
+	/// Proof: Nfts NextCollectionId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:0 w:1)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:1)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `216`
+		//  Estimated: `3549`
+		// Minimum execution time: 40_489_000 picoseconds.
+		Weight::from_parts(41_320_000, 3549)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts NextCollectionId (r:1 w:1)
+	/// Proof: Nfts NextCollectionId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:0 w:1)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:1)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn force_create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3549`
+		// Minimum execution time: 23_257_000 picoseconds.
+		Weight::from_parts(23_770_000, 3549)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:0)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:1)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1001 w:1000)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1000 w:1000)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionMetadataOf (r:0 w:1)
+	/// Proof: Nfts CollectionMetadataOf (max_values: None, max_size: Some(87), added: 2562, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:1)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	/// The range of component `m` is `[0, 1000]`.
+	/// The range of component `c` is `[0, 1000]`.
+	/// The range of component `a` is `[0, 1000]`.
+	fn destroy(_m: u32, _c: u32, a: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32220 + a * (332 ±0)`
+		//  Estimated: `2523990 + a * (2921 ±0)`
+		// Minimum execution time: 1_310_198_000 picoseconds.
+		Weight::from_parts(1_479_261_043, 2523990)
+			// Standard Error: 4_415
+			.saturating_add(Weight::from_parts(6_016_212, 0).saturating_mul(a.into()))
+			.saturating_add(T::DbWeight::get().reads(1004_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(a.into())))
+			.saturating_add(T::DbWeight::get().writes(1005_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(a.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(a.into()))
+	}
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	fn mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `455`
+		//  Estimated: `4326`
+		// Minimum execution time: 51_910_000 picoseconds.
+		Weight::from_parts(53_441_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	fn force_mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `455`
+		//  Estimated: `4326`
+		// Minimum execution time: 50_168_000 picoseconds.
+		Weight::from_parts(51_380_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:0)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:0 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn burn() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `564`
+		//  Estimated: `4326`
+		// Minimum execution time: 50_738_000 picoseconds.
+		Weight::from_parts(51_850_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:0)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:2)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `593`
+		//  Estimated: `4326`
+		// Minimum execution time: 41_055_000 picoseconds.
+		Weight::from_parts(42_336_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:5000 w:5000)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// The range of component `i` is `[0, 5000]`.
+	fn redeposit(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `763 + i * (108 ±0)`
+		//  Estimated: `3549 + i * (3336 ±0)`
+		// Minimum execution time: 15_688_000 picoseconds.
+		Weight::from_parts(15_921_000, 3549)
+			// Standard Error: 14_827
+			.saturating_add(Weight::from_parts(17_105_395, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(i.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
+			.saturating_add(Weight::from_parts(0, 3336).saturating_mul(i.into()))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn lock_item_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `435`
+		//  Estimated: `3534`
+		// Minimum execution time: 19_981_000 picoseconds.
+		Weight::from_parts(20_676_000, 3534)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn unlock_item_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `435`
+		//  Estimated: `3534`
+		// Minimum execution time: 19_911_000 picoseconds.
+		Weight::from_parts(20_612_000, 3534)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn lock_collection() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 16_441_000 picoseconds.
+		Weight::from_parts(16_890_000, 3549)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts OwnershipAcceptance (r:1 w:1)
+	/// Proof: Nfts OwnershipAcceptance (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:2)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn transfer_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3549`
+		// Minimum execution time: 22_610_000 picoseconds.
+		Weight::from_parts(23_422_000, 3549)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:2 w:4)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn set_team() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `369`
+		//  Estimated: `6078`
+		// Minimum execution time: 39_739_000 picoseconds.
+		Weight::from_parts(41_306_000, 6078)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:2)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn force_collection_owner() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `311`
+		//  Estimated: `3549`
+		// Minimum execution time: 17_685_000 picoseconds.
+		Weight::from_parts(18_258_000, 3549)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn force_collection_config() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `276`
+		//  Estimated: `3549`
+		// Minimum execution time: 13_734_000 picoseconds.
+		Weight::from_parts(14_337_000, 3549)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn lock_item_properties() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `435`
+		//  Estimated: `3534`
+		// Minimum execution time: 19_269_000 picoseconds.
+		Weight::from_parts(19_859_000, 3534)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	fn set_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `539`
+		//  Estimated: `3911`
+		// Minimum execution time: 51_540_000 picoseconds.
+		Weight::from_parts(52_663_000, 3911)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	fn force_set_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `344`
+		//  Estimated: `3911`
+		// Minimum execution time: 26_529_000 picoseconds.
+		Weight::from_parts(27_305_000, 3911)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	fn clear_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `950`
+		//  Estimated: `3911`
+		// Minimum execution time: 46_951_000 picoseconds.
+		Weight::from_parts(48_481_000, 3911)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:1 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	fn approve_item_attributes() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `4326`
+		// Minimum execution time: 17_222_000 picoseconds.
+		Weight::from_parts(17_819_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:1 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1001 w:1000)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1000]`.
+	fn cancel_item_attributes_approval(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `837 + n * (364 ±0)`
+		//  Estimated: `4326 + n * (2921 ±0)`
+		// Minimum execution time: 26_185_000 picoseconds.
+		Weight::from_parts(27_038_000, 4326)
+			// Standard Error: 2_378
+			.saturating_add(Weight::from_parts(6_067_888, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(n.into()))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:1)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn set_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `539`
+		//  Estimated: `3605`
+		// Minimum execution time: 42_120_000 picoseconds.
+		Weight::from_parts(43_627_000, 3605)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:1)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `642`
+		//  Estimated: `3605`
+		// Minimum execution time: 40_732_000 picoseconds.
+		Weight::from_parts(42_760_000, 3605)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionMetadataOf (r:1 w:1)
+	/// Proof: Nfts CollectionMetadataOf (max_values: None, max_size: Some(87), added: 2562, mode: MaxEncodedLen)
+	fn set_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `398`
+		//  Estimated: `3552`
+		// Minimum execution time: 39_443_000 picoseconds.
+		Weight::from_parts(40_482_000, 3552)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionMetadataOf (r:1 w:1)
+	/// Proof: Nfts CollectionMetadataOf (max_values: None, max_size: Some(87), added: 2562, mode: MaxEncodedLen)
+	fn clear_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `509`
+		//  Estimated: `3552`
+		// Minimum execution time: 37_676_000 picoseconds.
+		Weight::from_parts(39_527_000, 3552)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `410`
+		//  Estimated: `4326`
+		// Minimum execution time: 20_787_000 picoseconds.
+		Weight::from_parts(21_315_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418`
+		//  Estimated: `4326`
+		// Minimum execution time: 18_200_000 picoseconds.
+		Weight::from_parts(19_064_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	fn clear_all_transfer_approvals() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418`
+		//  Estimated: `4326`
+		// Minimum execution time: 17_128_000 picoseconds.
+		Weight::from_parts(17_952_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts OwnershipAcceptance (r:1 w:1)
+	/// Proof: Nfts OwnershipAcceptance (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn set_accept_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3517`
+		// Minimum execution time: 14_667_000 picoseconds.
+		Weight::from_parts(15_262_000, 3517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionConfigOf (r:1 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	fn set_collection_max_supply() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 18_435_000 picoseconds.
+		Weight::from_parts(18_775_000, 3549)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn update_mint_settings() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `323`
+		//  Estimated: `3538`
+		// Minimum execution time: 18_125_000 picoseconds.
+		Weight::from_parts(18_415_000, 3538)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	fn set_price() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `518`
+		//  Estimated: `4326`
+		// Minimum execution time: 23_237_000 picoseconds.
+		Weight::from_parts(24_128_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:1 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:0)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:2)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn buy_item() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `705`
+		//  Estimated: `4326`
+		// Minimum execution time: 53_291_000 picoseconds.
+		Weight::from_parts(54_614_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// The range of component `n` is `[0, 10]`.
+	fn pay_tips(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_192_000 picoseconds.
+		Weight::from_parts(4_039_901, 0)
+			// Standard Error: 10_309
+			.saturating_add(Weight::from_parts(3_934_017, 0).saturating_mul(n.into()))
+	}
+	/// Storage: Nfts Item (r:2 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn create_swap() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `494`
+		//  Estimated: `7662`
+		// Minimum execution time: 21_011_000 picoseconds.
+		Weight::from_parts(22_065_000, 7662)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts PendingSwapOf (r:1 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	fn cancel_swap() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `513`
+		//  Estimated: `4326`
+		// Minimum execution time: 21_423_000 picoseconds.
+		Weight::from_parts(21_743_000, 4326)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:2 w:2)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:1 w:2)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:2 w:0)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:2 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:4)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:2)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	fn claim_swap() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `834`
+		//  Estimated: `7662`
+		// Minimum execution time: 86_059_000 picoseconds.
+		Weight::from_parts(88_401_000, 7662)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(10_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:2 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:10 w:10)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:1)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 10]`.
+	fn mint_pre_signed(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `629`
+		//  Estimated: `6078 + n * (2921 ±0)`
+		// Minimum execution time: 146_746_000 picoseconds.
+		Weight::from_parts(152_885_862, 6078)
+			// Standard Error: 40_442
+			.saturating_add(Weight::from_parts(32_887_800, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(n.into()))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:1 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:10 w:10)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 10]`.
+	fn set_attributes_pre_signed(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `659`
+		//  Estimated: `4326 + n * (2921 ±0)`
+		// Minimum execution time: 83_960_000 picoseconds.
+		Weight::from_parts(98_609_885, 4326)
+			// Standard Error: 85_991
+			.saturating_add(Weight::from_parts(32_633_495, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(n.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Nfts NextCollectionId (r:1 w:1)
+	/// Proof: Nfts NextCollectionId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:0 w:1)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:1)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `216`
+		//  Estimated: `3549`
+		// Minimum execution time: 40_489_000 picoseconds.
+		Weight::from_parts(41_320_000, 3549)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts NextCollectionId (r:1 w:1)
+	/// Proof: Nfts NextCollectionId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:0 w:1)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:1)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn force_create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3549`
+		// Minimum execution time: 23_257_000 picoseconds.
+		Weight::from_parts(23_770_000, 3549)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:0)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:1)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1001 w:1000)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1000 w:1000)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionMetadataOf (r:0 w:1)
+	/// Proof: Nfts CollectionMetadataOf (max_values: None, max_size: Some(87), added: 2562, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:1)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	/// The range of component `m` is `[0, 1000]`.
+	/// The range of component `c` is `[0, 1000]`.
+	/// The range of component `a` is `[0, 1000]`.
+	fn destroy(_m: u32, _c: u32, a: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `32220 + a * (332 ±0)`
+		//  Estimated: `2523990 + a * (2921 ±0)`
+		// Minimum execution time: 1_310_198_000 picoseconds.
+		Weight::from_parts(1_479_261_043, 2523990)
+			// Standard Error: 4_415
+			.saturating_add(Weight::from_parts(6_016_212, 0).saturating_mul(a.into()))
+			.saturating_add(RocksDbWeight::get().reads(1004_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(a.into())))
+			.saturating_add(RocksDbWeight::get().writes(1005_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(a.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(a.into()))
+	}
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	fn mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `455`
+		//  Estimated: `4326`
+		// Minimum execution time: 51_910_000 picoseconds.
+		Weight::from_parts(53_441_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	fn force_mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `455`
+		//  Estimated: `4326`
+		// Minimum execution time: 50_168_000 picoseconds.
+		Weight::from_parts(51_380_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:0)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:0 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn burn() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `564`
+		//  Estimated: `4326`
+		// Minimum execution time: 50_738_000 picoseconds.
+		Weight::from_parts(51_850_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:0)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:2)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `593`
+		//  Estimated: `4326`
+		// Minimum execution time: 41_055_000 picoseconds.
+		Weight::from_parts(42_336_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:5000 w:5000)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// The range of component `i` is `[0, 5000]`.
+	fn redeposit(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `763 + i * (108 ±0)`
+		//  Estimated: `3549 + i * (3336 ±0)`
+		// Minimum execution time: 15_688_000 picoseconds.
+		Weight::from_parts(15_921_000, 3549)
+			// Standard Error: 14_827
+			.saturating_add(Weight::from_parts(17_105_395, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(i.into())))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
+			.saturating_add(Weight::from_parts(0, 3336).saturating_mul(i.into()))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn lock_item_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `435`
+		//  Estimated: `3534`
+		// Minimum execution time: 19_981_000 picoseconds.
+		Weight::from_parts(20_676_000, 3534)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn unlock_item_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `435`
+		//  Estimated: `3534`
+		// Minimum execution time: 19_911_000 picoseconds.
+		Weight::from_parts(20_612_000, 3534)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn lock_collection() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 16_441_000 picoseconds.
+		Weight::from_parts(16_890_000, 3549)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts OwnershipAcceptance (r:1 w:1)
+	/// Proof: Nfts OwnershipAcceptance (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:2)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn transfer_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `388`
+		//  Estimated: `3549`
+		// Minimum execution time: 22_610_000 picoseconds.
+		Weight::from_parts(23_422_000, 3549)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:2 w:4)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	fn set_team() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `369`
+		//  Estimated: `6078`
+		// Minimum execution time: 39_739_000 picoseconds.
+		Weight::from_parts(41_306_000, 6078)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionAccount (r:0 w:2)
+	/// Proof: Nfts CollectionAccount (max_values: None, max_size: Some(68), added: 2543, mode: MaxEncodedLen)
+	fn force_collection_owner() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `311`
+		//  Estimated: `3549`
+		// Minimum execution time: 17_685_000 picoseconds.
+		Weight::from_parts(18_258_000, 3549)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:0 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn force_collection_config() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `276`
+		//  Estimated: `3549`
+		// Minimum execution time: 13_734_000 picoseconds.
+		Weight::from_parts(14_337_000, 3549)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn lock_item_properties() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `435`
+		//  Estimated: `3534`
+		// Minimum execution time: 19_269_000 picoseconds.
+		Weight::from_parts(19_859_000, 3534)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	fn set_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `539`
+		//  Estimated: `3911`
+		// Minimum execution time: 51_540_000 picoseconds.
+		Weight::from_parts(52_663_000, 3911)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	fn force_set_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `344`
+		//  Estimated: `3911`
+		// Minimum execution time: 26_529_000 picoseconds.
+		Weight::from_parts(27_305_000, 3911)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts Attribute (r:1 w:1)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	fn clear_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `950`
+		//  Estimated: `3911`
+		// Minimum execution time: 46_951_000 picoseconds.
+		Weight::from_parts(48_481_000, 3911)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:1 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	fn approve_item_attributes() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `4326`
+		// Minimum execution time: 17_222_000 picoseconds.
+		Weight::from_parts(17_819_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:1 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1001 w:1000)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 1000]`.
+	fn cancel_item_attributes_approval(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `837 + n * (364 ±0)`
+		//  Estimated: `4326 + n * (2921 ±0)`
+		// Minimum execution time: 26_185_000 picoseconds.
+		Weight::from_parts(27_038_000, 4326)
+			// Standard Error: 2_378
+			.saturating_add(Weight::from_parts(6_067_888, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(n.into()))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:1)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	fn set_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `539`
+		//  Estimated: `3605`
+		// Minimum execution time: 42_120_000 picoseconds.
+		Weight::from_parts(43_627_000, 3605)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:1)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `642`
+		//  Estimated: `3605`
+		// Minimum execution time: 40_732_000 picoseconds.
+		Weight::from_parts(42_760_000, 3605)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionMetadataOf (r:1 w:1)
+	/// Proof: Nfts CollectionMetadataOf (max_values: None, max_size: Some(87), added: 2562, mode: MaxEncodedLen)
+	fn set_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `398`
+		//  Estimated: `3552`
+		// Minimum execution time: 39_443_000 picoseconds.
+		Weight::from_parts(40_482_000, 3552)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionMetadataOf (r:1 w:1)
+	/// Proof: Nfts CollectionMetadataOf (max_values: None, max_size: Some(87), added: 2562, mode: MaxEncodedLen)
+	fn clear_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `509`
+		//  Estimated: `3552`
+		// Minimum execution time: 37_676_000 picoseconds.
+		Weight::from_parts(39_527_000, 3552)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `410`
+		//  Estimated: `4326`
+		// Minimum execution time: 20_787_000 picoseconds.
+		Weight::from_parts(21_315_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418`
+		//  Estimated: `4326`
+		// Minimum execution time: 18_200_000 picoseconds.
+		Weight::from_parts(19_064_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	fn clear_all_transfer_approvals() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418`
+		//  Estimated: `4326`
+		// Minimum execution time: 17_128_000 picoseconds.
+		Weight::from_parts(17_952_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts OwnershipAcceptance (r:1 w:1)
+	/// Proof: Nfts OwnershipAcceptance (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn set_accept_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `3517`
+		// Minimum execution time: 14_667_000 picoseconds.
+		Weight::from_parts(15_262_000, 3517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionConfigOf (r:1 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	fn set_collection_max_supply() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `340`
+		//  Estimated: `3549`
+		// Minimum execution time: 18_435_000 picoseconds.
+		Weight::from_parts(18_775_000, 3549)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:1 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:1)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn update_mint_settings() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `323`
+		//  Estimated: `3538`
+		// Minimum execution time: 18_125_000 picoseconds.
+		Weight::from_parts(18_415_000, 3538)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	fn set_price() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `518`
+		//  Estimated: `4326`
+		// Minimum execution time: 23_237_000 picoseconds.
+		Weight::from_parts(24_128_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:1 w:1)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:1 w:0)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:2)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn buy_item() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `705`
+		//  Estimated: `4326`
+		// Minimum execution time: 53_291_000 picoseconds.
+		Weight::from_parts(54_614_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// The range of component `n` is `[0, 10]`.
+	fn pay_tips(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_192_000 picoseconds.
+		Weight::from_parts(4_039_901, 0)
+			// Standard Error: 10_309
+			.saturating_add(Weight::from_parts(3_934_017, 0).saturating_mul(n.into()))
+	}
+	/// Storage: Nfts Item (r:2 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:0 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	fn create_swap() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `494`
+		//  Estimated: `7662`
+		// Minimum execution time: 21_011_000 picoseconds.
+		Weight::from_parts(22_065_000, 7662)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts PendingSwapOf (r:1 w:1)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	fn cancel_swap() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `513`
+		//  Estimated: `4326`
+		// Minimum execution time: 21_423_000 picoseconds.
+		Weight::from_parts(21_743_000, 4326)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nfts Item (r:2 w:2)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts PendingSwapOf (r:1 w:2)
+	/// Proof: Nfts PendingSwapOf (max_values: None, max_size: Some(71), added: 2546, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:0)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:2 w:0)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:2 w:0)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:4)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemPriceOf (r:0 w:2)
+	/// Proof: Nfts ItemPriceOf (max_values: None, max_size: Some(89), added: 2564, mode: MaxEncodedLen)
+	fn claim_swap() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `834`
+		//  Estimated: `7662`
+		// Minimum execution time: 86_059_000 picoseconds.
+		Weight::from_parts(88_401_000, 7662)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(10_u64))
+	}
+	/// Storage: Nfts CollectionRoleOf (r:2 w:0)
+	/// Proof: Nfts CollectionRoleOf (max_values: None, max_size: Some(69), added: 2544, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Item (r:1 w:1)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemConfigOf (r:1 w:1)
+	/// Proof: Nfts ItemConfigOf (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:10 w:10)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemMetadataOf (r:1 w:1)
+	/// Proof: Nfts ItemMetadataOf (max_values: None, max_size: Some(140), added: 2615, mode: MaxEncodedLen)
+	/// Storage: Nfts Account (r:0 w:1)
+	/// Proof: Nfts Account (max_values: None, max_size: Some(88), added: 2563, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 10]`.
+	fn mint_pre_signed(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `629`
+		//  Estimated: `6078 + n * (2921 ±0)`
+		// Minimum execution time: 146_746_000 picoseconds.
+		Weight::from_parts(152_885_862, 6078)
+			// Standard Error: 40_442
+			.saturating_add(Weight::from_parts(32_887_800, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(n.into()))
+	}
+	/// Storage: Nfts Item (r:1 w:0)
+	/// Proof: Nfts Item (max_values: None, max_size: Some(861), added: 3336, mode: MaxEncodedLen)
+	/// Storage: Nfts ItemAttributesApprovalsOf (r:1 w:1)
+	/// Proof: Nfts ItemAttributesApprovalsOf (max_values: None, max_size: Some(681), added: 3156, mode: MaxEncodedLen)
+	/// Storage: Nfts CollectionConfigOf (r:1 w:0)
+	/// Proof: Nfts CollectionConfigOf (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Nfts Collection (r:1 w:1)
+	/// Proof: Nfts Collection (max_values: None, max_size: Some(84), added: 2559, mode: MaxEncodedLen)
+	/// Storage: Nfts Attribute (r:10 w:10)
+	/// Proof: Nfts Attribute (max_values: None, max_size: Some(446), added: 2921, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 10]`.
+	fn set_attributes_pre_signed(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `659`
+		//  Estimated: `4326 + n * (2921 ±0)`
+		// Minimum execution time: 83_960_000 picoseconds.
+		Weight::from_parts(98_609_885, 4326)
+			// Standard Error: 85_991
+			.saturating_add(Weight::from_parts(32_633_495, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2921).saturating_mul(n.into()))
+	}
+}
diff --git a/substrate/frame/nicks/Cargo.toml b/substrate/frame/nicks/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..129c99d310d97dbd1806a42daf5215af98d7b30f
--- /dev/null
+++ b/substrate/frame/nicks/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "pallet-nicks"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for nick management"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/nicks/README.md b/substrate/frame/nicks/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..768043ffb9bf96964abbc60a2b39e124143d1e9c
--- /dev/null
+++ b/substrate/frame/nicks/README.md
@@ -0,0 +1,25 @@
+# Nicks Module
+
+- [`Config`](https://docs.rs/pallet-nicks/latest/pallet_nicks/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-nicks/latest/pallet_nicks/pallet/enum.Call.html)
+
+## Overview
+
+Nicks is an example module for keeping track of account names on-chain. It makes no effort to
+create a name hierarchy, be a DNS replacement or provide reverse lookups. Furthermore, the
+weights attached to this module's dispatchable functions are for demonstration purposes only and
+have not been designed to be economically secure. Do not use this pallet as-is in production.
+
+## Interface
+
+### Dispatchable Functions
+
+* `set_name` - Set the associated name of an account; a small deposit is reserved if not already
+  taken.
+* `clear_name` - Remove an account's associated name; the deposit is returned.
+* `kill_name` - Forcibly remove the associated name; the deposit is lost.
+
+[`Call`]: ./enum.Call.html
+[`Config`]: ./trait.Config.html
+
+License: Apache-2.0
diff --git a/substrate/frame/nicks/src/lib.rs b/substrate/frame/nicks/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0a68f7d7142dc45cebbddcdef8ab90da05a3552c
--- /dev/null
+++ b/substrate/frame/nicks/src/lib.rs
@@ -0,0 +1,422 @@
+// 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.
+
+//! # Nicks Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! Nicks is an example pallet for keeping track of account names on-chain. It makes no effort to
+//! create a name hierarchy, be a DNS replacement or provide reverse lookups. Furthermore, the
+//! weights attached to this pallet's dispatchable functions are for demonstration purposes only and
+//! have not been designed to be economically secure. Do not use this pallet as-is in production.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! * `set_name` - Set the associated name of an account; a small deposit is reserved if not already
+//!   taken.
+//! * `clear_name` - Remove an account's associated name; the deposit is returned.
+//! * `kill_name` - Forcibly remove the associated name; the deposit is lost.
+
+#![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::traits::{Currency, OnUnbalanced, ReservableCurrency};
+pub use pallet::*;
+use sp_runtime::traits::{StaticLookup, Zero};
+use sp_std::prelude::*;
+
+type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
+type BalanceOf<T> = <<T as Config>::Currency as Currency<AccountIdOf<T>>>::Balance;
+type NegativeImbalanceOf<T> =
+	<<T as Config>::Currency as Currency<AccountIdOf<T>>>::NegativeImbalance;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The currency trait.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// Reservation fee.
+		#[pallet::constant]
+		type ReservationFee: Get<BalanceOf<Self>>;
+
+		/// What to do with slashed funds.
+		type Slashed: OnUnbalanced<NegativeImbalanceOf<Self>>;
+
+		/// The origin which may forcibly set or remove a name. Root can always do this.
+		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The minimum length a name may be.
+		#[pallet::constant]
+		type MinLength: Get<u32>;
+
+		/// The maximum length a name may be.
+		#[pallet::constant]
+		type MaxLength: Get<u32>;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A name was set.
+		NameSet {
+			/// The account for which the name was set.
+			who: T::AccountId,
+		},
+		/// A name was forcibly set.
+		NameForced {
+			/// The account whose name was forcibly set.
+			target: T::AccountId,
+		},
+		/// A name was changed.
+		NameChanged {
+			/// The account for which the name was changed.
+			who: T::AccountId,
+		},
+		/// A name was cleared, and the given balance returned.
+		NameCleared {
+			/// The account for which the name was cleared.
+			who: T::AccountId,
+			/// The deposit returned.
+			deposit: BalanceOf<T>,
+		},
+		/// A name was removed and the given balance slashed.
+		NameKilled {
+			/// The account for which the name was removed.
+			target: T::AccountId,
+			/// The deposit returned.
+			deposit: BalanceOf<T>,
+		},
+	}
+
+	/// Error for the Nicks pallet.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// A name is too short.
+		TooShort,
+		/// A name is too long.
+		TooLong,
+		/// An account isn't named.
+		Unnamed,
+	}
+
+	/// The lookup table for names.
+	#[pallet::storage]
+	pub(super) type NameOf<T: Config> =
+		StorageMap<_, Twox64Concat, T::AccountId, (BoundedVec<u8, T::MaxLength>, BalanceOf<T>)>;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Set an account's name. The name should be a UTF-8-encoded string by convention, though
+		/// we don't check it.
+		///
+		/// The name may not be more than `T::MaxLength` bytes, nor less than `T::MinLength` bytes.
+		///
+		/// If the account doesn't already have a name, then a fee of `ReservationFee` is reserved
+		/// in the account.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(0)]
+		#[pallet::weight({50_000_000})]
+		pub fn set_name(origin: OriginFor<T>, name: Vec<u8>) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			let bounded_name: BoundedVec<_, _> =
+				name.try_into().map_err(|_| Error::<T>::TooLong)?;
+			ensure!(bounded_name.len() >= T::MinLength::get() as usize, Error::<T>::TooShort);
+
+			let deposit = if let Some((_, deposit)) = <NameOf<T>>::get(&sender) {
+				Self::deposit_event(Event::<T>::NameChanged { who: sender.clone() });
+				deposit
+			} else {
+				let deposit = T::ReservationFee::get();
+				T::Currency::reserve(&sender, deposit)?;
+				Self::deposit_event(Event::<T>::NameSet { who: sender.clone() });
+				deposit
+			};
+
+			<NameOf<T>>::insert(&sender, (bounded_name, deposit));
+			Ok(())
+		}
+
+		/// Clear an account's name and return the deposit. Fails if the account was not named.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(1)]
+		#[pallet::weight({70_000_000})]
+		pub fn clear_name(origin: OriginFor<T>) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			let deposit = <NameOf<T>>::take(&sender).ok_or(Error::<T>::Unnamed)?.1;
+
+			let err_amount = T::Currency::unreserve(&sender, deposit);
+			debug_assert!(err_amount.is_zero());
+
+			Self::deposit_event(Event::<T>::NameCleared { who: sender, deposit });
+			Ok(())
+		}
+
+		/// Remove an account's name and take charge of the deposit.
+		///
+		/// Fails if `target` has not been named. The deposit is dealt with through `T::Slashed`
+		/// imbalance handler.
+		///
+		/// The dispatch origin for this call must match `T::ForceOrigin`.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(2)]
+		#[pallet::weight({70_000_000})]
+		pub fn kill_name(origin: OriginFor<T>, target: AccountIdLookupOf<T>) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+
+			// Figure out who we're meant to be clearing.
+			let target = T::Lookup::lookup(target)?;
+			// Grab their deposit (and check that they have one).
+			let deposit = <NameOf<T>>::take(&target).ok_or(Error::<T>::Unnamed)?.1;
+			// Slash their deposit from them.
+			T::Slashed::on_unbalanced(T::Currency::slash_reserved(&target, deposit).0);
+
+			Self::deposit_event(Event::<T>::NameKilled { target, deposit });
+			Ok(())
+		}
+
+		/// Set a third-party account's name with no deposit.
+		///
+		/// No length checking is done on the name.
+		///
+		/// The dispatch origin for this call must match `T::ForceOrigin`.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(3)]
+		#[pallet::weight({70_000_000})]
+		pub fn force_name(
+			origin: OriginFor<T>,
+			target: AccountIdLookupOf<T>,
+			name: Vec<u8>,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+
+			let bounded_name: BoundedVec<_, _> =
+				name.try_into().map_err(|_| Error::<T>::TooLong)?;
+			let target = T::Lookup::lookup(target)?;
+			let deposit = <NameOf<T>>::get(&target).map(|x| x.1).unwrap_or_else(Zero::zero);
+			<NameOf<T>>::insert(&target, (bounded_name, deposit));
+
+			Self::deposit_event(Event::<T>::NameForced { target });
+			Ok(())
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate as pallet_nicks;
+
+	use frame_support::{
+		assert_noop, assert_ok, ord_parameter_types,
+		traits::{ConstU32, ConstU64},
+	};
+	use frame_system::EnsureSignedBy;
+	use sp_core::H256;
+	use sp_runtime::{
+		traits::{BadOrigin, BlakeTwo256, IdentityLookup},
+		BuildStorage,
+	};
+
+	type Block = frame_system::mocking::MockBlock<Test>;
+
+	frame_support::construct_runtime!(
+		pub enum Test
+		{
+			System: frame_system,
+			Balances: pallet_balances,
+			Nicks: pallet_nicks,
+		}
+	);
+
+	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 = 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>;
+	}
+
+	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 MaxHolds = ();
+	}
+
+	ord_parameter_types! {
+		pub const One: u64 = 1;
+	}
+	impl Config for Test {
+		type RuntimeEvent = RuntimeEvent;
+		type Currency = Balances;
+		type ReservationFee = ConstU64<2>;
+		type Slashed = ();
+		type ForceOrigin = EnsureSignedBy<One, u64>;
+		type MinLength = ConstU32<3>;
+		type MaxLength = ConstU32<16>;
+	}
+
+	fn new_test_ext() -> sp_io::TestExternalities {
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Test> { balances: vec![(1, 10), (2, 10)] }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		t.into()
+	}
+
+	#[test]
+	fn kill_name_should_work() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Nicks::set_name(RuntimeOrigin::signed(2), b"Dave".to_vec()));
+			assert_eq!(Balances::total_balance(&2), 10);
+			assert_ok!(Nicks::kill_name(RuntimeOrigin::signed(1), 2));
+			assert_eq!(Balances::total_balance(&2), 8);
+			assert_eq!(<NameOf<Test>>::get(2), None);
+		});
+	}
+
+	#[test]
+	fn force_name_should_work() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(
+				Nicks::set_name(RuntimeOrigin::signed(2), b"Dr. David Brubeck, III".to_vec()),
+				Error::<Test>::TooLong,
+			);
+
+			assert_ok!(Nicks::set_name(RuntimeOrigin::signed(2), b"Dave".to_vec()));
+			assert_eq!(Balances::reserved_balance(2), 2);
+			assert_noop!(
+				Nicks::force_name(RuntimeOrigin::signed(1), 2, b"Dr. David Brubeck, III".to_vec()),
+				Error::<Test>::TooLong,
+			);
+			assert_ok!(Nicks::force_name(
+				RuntimeOrigin::signed(1),
+				2,
+				b"Dr. Brubeck, III".to_vec()
+			));
+			assert_eq!(Balances::reserved_balance(2), 2);
+			let (name, amount) = <NameOf<Test>>::get(2).unwrap();
+			assert_eq!(name, b"Dr. Brubeck, III".to_vec());
+			assert_eq!(amount, 2);
+		});
+	}
+
+	#[test]
+	fn normal_operation_should_work() {
+		new_test_ext().execute_with(|| {
+			assert_ok!(Nicks::set_name(RuntimeOrigin::signed(1), b"Gav".to_vec()));
+			assert_eq!(Balances::reserved_balance(1), 2);
+			assert_eq!(Balances::free_balance(1), 8);
+			assert_eq!(<NameOf<Test>>::get(1).unwrap().0, b"Gav".to_vec());
+
+			assert_ok!(Nicks::set_name(RuntimeOrigin::signed(1), b"Gavin".to_vec()));
+			assert_eq!(Balances::reserved_balance(1), 2);
+			assert_eq!(Balances::free_balance(1), 8);
+			assert_eq!(<NameOf<Test>>::get(1).unwrap().0, b"Gavin".to_vec());
+
+			assert_ok!(Nicks::clear_name(RuntimeOrigin::signed(1)));
+			assert_eq!(Balances::reserved_balance(1), 0);
+			assert_eq!(Balances::free_balance(1), 10);
+		});
+	}
+
+	#[test]
+	fn error_catching_should_work() {
+		new_test_ext().execute_with(|| {
+			assert_noop!(Nicks::clear_name(RuntimeOrigin::signed(1)), Error::<Test>::Unnamed);
+
+			assert_noop!(
+				Nicks::set_name(RuntimeOrigin::signed(3), b"Dave".to_vec()),
+				pallet_balances::Error::<Test, _>::InsufficientBalance
+			);
+
+			assert_noop!(
+				Nicks::set_name(RuntimeOrigin::signed(1), b"Ga".to_vec()),
+				Error::<Test>::TooShort
+			);
+			assert_noop!(
+				Nicks::set_name(RuntimeOrigin::signed(1), b"Gavin James Wood, Esquire".to_vec()),
+				Error::<Test>::TooLong
+			);
+			assert_ok!(Nicks::set_name(RuntimeOrigin::signed(1), b"Dave".to_vec()));
+			assert_noop!(Nicks::kill_name(RuntimeOrigin::signed(2), 1), BadOrigin);
+			assert_noop!(
+				Nicks::force_name(RuntimeOrigin::signed(2), 1, b"Whatever".to_vec()),
+				BadOrigin
+			);
+		});
+	}
+}
diff --git a/substrate/frame/nis/Cargo.toml b/substrate/frame/nis/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2b012bbe91a832b40ffd175fc17214fb3ca26ace
--- /dev/null
+++ b/substrate/frame/nis/Cargo.toml
@@ -0,0 +1,57 @@
+[package]
+name = "pallet-nis"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for rewarding account freezing."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/nis/README.md b/substrate/frame/nis/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0c3f0c383a16cf9cb3bc92e201c2844acc21e1c4
--- /dev/null
+++ b/substrate/frame/nis/README.md
@@ -0,0 +1,5 @@
+# NIS Module
+
+Provides a non-interactiove variant of staking.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/nis/src/benchmarking.rs b/substrate/frame/nis/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0cc9e7421d0e664235e9d697fac20c69d88727a7
--- /dev/null
+++ b/substrate/frame/nis/src/benchmarking.rs
@@ -0,0 +1,244 @@
+// 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.
+
+//! Benchmarks for NIS Pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller, BenchmarkError};
+use frame_support::traits::{
+	fungible::Inspect as FunInspect, nonfungible::Inspect, EnsureOrigin, Get,
+};
+use frame_system::RawOrigin;
+use sp_arithmetic::Perquintill;
+use sp_runtime::{
+	traits::{Bounded, One, Zero},
+	DispatchError, PerThing,
+};
+use sp_std::prelude::*;
+
+use crate::Pallet as Nis;
+
+const SEED: u32 = 0;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as FunInspect<<T as frame_system::Config>::AccountId>>::Balance;
+
+fn fill_queues<T: Config>() -> Result<(), DispatchError> {
+	// filling queues involves filling the first queue entirely and placing a single item in all
+	// other queues.
+
+	let queues = T::QueueCount::get();
+	let bids = T::MaxQueueLen::get();
+
+	let caller: T::AccountId = whitelisted_caller();
+	T::Currency::set_balance(&caller, T::MinBid::get() * BalanceOf::<T>::from(queues + bids));
+
+	for _ in 0..bids {
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), T::MinBid::get(), 1)?;
+	}
+	for d in 1..queues {
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), T::MinBid::get(), 1 + d)?;
+	}
+	Ok(())
+}
+
+benchmarks! {
+	place_bid {
+		let l in 0..(T::MaxQueueLen::get() - 1);
+		let caller: T::AccountId = whitelisted_caller();
+		let ed = T::Currency::minimum_balance();
+		let bid = T::MinBid::get();
+		T::Currency::set_balance(&caller, (ed + bid) * BalanceOf::<T>::from(l + 1) + bid);
+		for i in 0..l {
+			Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), T::MinBid::get(), 1)?;
+		}
+	}: _(RawOrigin::Signed(caller.clone()), T::MinBid::get() * BalanceOf::<T>::from(2u32), 1)
+	verify {
+		assert_eq!(QueueTotals::<T>::get()[0], (l + 1, T::MinBid::get() * BalanceOf::<T>::from(l + 2)));
+	}
+
+	place_bid_max {
+		let caller: T::AccountId = whitelisted_caller();
+		let origin = RawOrigin::Signed(caller.clone());
+		let ed = T::Currency::minimum_balance();
+		let bid = T::MinBid::get();
+		let ql = T::MaxQueueLen::get();
+		T::Currency::set_balance(&caller, (ed + bid) * BalanceOf::<T>::from(ql + 1) + bid);
+		for i in 0..T::MaxQueueLen::get() {
+			Nis::<T>::place_bid(origin.clone().into(), T::MinBid::get(), 1)?;
+		}
+	}: place_bid(origin, T::MinBid::get() * BalanceOf::<T>::from(2u32), 1)
+	verify {
+		assert_eq!(QueueTotals::<T>::get()[0], (
+			T::MaxQueueLen::get(),
+			T::MinBid::get() * BalanceOf::<T>::from(T::MaxQueueLen::get() + 1),
+		));
+	}
+
+	retract_bid {
+		let l in 1..T::MaxQueueLen::get();
+		let caller: T::AccountId = whitelisted_caller();
+		let ed = T::Currency::minimum_balance();
+		let bid = T::MinBid::get();
+		T::Currency::set_balance(&caller, (ed + bid) * BalanceOf::<T>::from(l + 1) + bid);
+		for i in 0..l {
+			Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), T::MinBid::get(), 1)?;
+		}
+	}: _(RawOrigin::Signed(caller.clone()), T::MinBid::get(), 1)
+	verify {
+		assert_eq!(QueueTotals::<T>::get()[0], (l - 1, T::MinBid::get() * BalanceOf::<T>::from(l - 1)));
+	}
+
+	fund_deficit {
+		let origin =
+			T::FundOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let caller: T::AccountId = whitelisted_caller();
+		let bid = T::MinBid::get().max(One::one());
+		let ed = T::Currency::minimum_balance();
+		T::Currency::set_balance(&caller, ed + bid);
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::process_queues(Perquintill::one(), 1, 1, &mut WeightCounter::unlimited());
+		Nis::<T>::communify(RawOrigin::Signed(caller.clone()).into(), 0)?;
+		let original = T::Currency::balance(&Nis::<T>::account_id());
+		T::Currency::set_balance(&Nis::<T>::account_id(), BalanceOf::<T>::min_value());
+	}: _<T::RuntimeOrigin>(origin)
+	verify {
+		// Must fund at least 99.999% of the required amount.
+		let missing = Perquintill::from_rational(
+			T::Currency::balance(&Nis::<T>::account_id()), original).left_from_one();
+		assert!(missing <= Perquintill::one() / 100_000);
+	}
+
+	communify {
+		let caller: T::AccountId = whitelisted_caller();
+		let bid = T::MinBid::get().max(One::one()) * 100u32.into();
+		let ed = T::Currency::minimum_balance();
+		T::Currency::set_balance(&caller, ed + bid + bid);
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::process_queues(Perquintill::one(), 1, 2, &mut WeightCounter::unlimited());
+	}: _(RawOrigin::Signed(caller.clone()), 0)
+	verify {
+		assert_eq!(Nis::<T>::owner(&0), None);
+	}
+
+	privatize {
+		let caller: T::AccountId = whitelisted_caller();
+		let bid = T::MinBid::get().max(One::one());
+		let ed = T::Currency::minimum_balance();
+		T::Currency::set_balance(&caller, ed + bid + bid);
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::process_queues(Perquintill::one(), 1, 2, &mut WeightCounter::unlimited());
+		Nis::<T>::communify(RawOrigin::Signed(caller.clone()).into(), 0)?;
+	}: _(RawOrigin::Signed(caller.clone()), 0)
+	verify {
+		assert_eq!(Nis::<T>::owner(&0), Some(caller));
+	}
+
+	thaw_private {
+		let whale: T::AccountId = account("whale", 0, SEED);
+		let caller: T::AccountId = whitelisted_caller();
+		let bid = T::MinBid::get().max(One::one());
+		let ed = T::Currency::minimum_balance();
+		T::Currency::set_balance(&caller, ed + bid + bid);
+		// Ensure we don't get throttled.
+		T::Currency::set_balance(&whale, T::ThawThrottle::get().0.saturating_reciprocal_mul_ceil(T::Currency::balance(&caller)));
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::process_queues(Perquintill::one(), 1, 2, &mut WeightCounter::unlimited());
+		frame_system::Pallet::<T>::set_block_number(Receipts::<T>::get(0).unwrap().expiry);
+	}: _(RawOrigin::Signed(caller.clone()), 0, None)
+	verify {
+		assert!(Receipts::<T>::get(0).is_none());
+	}
+
+	thaw_communal {
+		let whale: T::AccountId = account("whale", 0, SEED);
+		let caller: T::AccountId = whitelisted_caller();
+		let bid = T::MinBid::get().max(One::one());
+		let ed = T::Currency::minimum_balance();
+		T::Currency::set_balance(&caller, ed + bid + bid);
+		// Ensure we don't get throttled.
+		T::Currency::set_balance(&whale, T::ThawThrottle::get().0.saturating_reciprocal_mul_ceil(T::Currency::balance(&caller)));
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::place_bid(RawOrigin::Signed(caller.clone()).into(), bid, 1)?;
+		Nis::<T>::process_queues(Perquintill::one(), 1, 2, &mut WeightCounter::unlimited());
+		frame_system::Pallet::<T>::set_block_number(Receipts::<T>::get(0).unwrap().expiry);
+		Nis::<T>::communify(RawOrigin::Signed(caller.clone()).into(), 0)?;
+	}: _(RawOrigin::Signed(caller.clone()), 0)
+	verify {
+		assert!(Receipts::<T>::get(0).is_none());
+	}
+
+	process_queues {
+		fill_queues::<T>()?;
+	}: {
+		Nis::<T>::process_queues(
+			Perquintill::one(),
+			Zero::zero(),
+			u32::max_value(),
+			&mut WeightCounter::unlimited(),
+		)
+	}
+
+	process_queue {
+		let our_account = Nis::<T>::account_id();
+		let issuance = Nis::<T>::issuance();
+		let mut summary = Summary::<T>::get();
+	}: {
+		Nis::<T>::process_queue(
+			1u32,
+			1u32.into(),
+			&our_account,
+			&issuance,
+			0,
+			&mut Bounded::max_value(),
+			&mut (T::MaxQueueLen::get(), Bounded::max_value()),
+			&mut summary,
+			&mut WeightCounter::unlimited(),
+		)
+	}
+
+	process_bid {
+		let who = account::<T::AccountId>("bidder", 0, SEED);
+		let min_bid = T::MinBid::get().max(One::one());
+		let ed = T::Currency::minimum_balance();
+		T::Currency::set_balance(&who, ed + min_bid);
+		let bid = Bid {
+			amount: T::MinBid::get(),
+			who,
+		};
+		let our_account = Nis::<T>::account_id();
+		let issuance = Nis::<T>::issuance();
+		let mut summary = Summary::<T>::get();
+	}: {
+		Nis::<T>::process_bid(
+			bid,
+			2u32.into(),
+			&our_account,
+			&issuance,
+			&mut Bounded::max_value(),
+			&mut Bounded::max_value(),
+			&mut summary,
+		)
+	}
+
+	impl_benchmark_test_suite!(Nis, crate::mock::new_test_ext_empty(), crate::mock::Test);
+}
diff --git a/substrate/frame/nis/src/lib.rs b/substrate/frame/nis/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..decebbd56762ed19750450d2d2c70b063956729b
--- /dev/null
+++ b/substrate/frame/nis/src/lib.rs
@@ -0,0 +1,1140 @@
+// 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.
+
+//! # Non-Interactive Staking (NIS) Pallet
+//! A pallet allowing accounts to auction for being frozen and receive open-ended
+//! inflation-protection in return.
+//!
+//! ## Overview
+//!
+//! Lock up tokens, for at least as long as you offer, and be free from both inflation and
+//! intermediate reward or exchange until the tokens become unlocked.
+//!
+//! ## Design
+//!
+//! Queues for each of `1..QueueCount` periods, given in blocks (`Period`). Queues are limited in
+//! size to something sensible, `MaxQueueLen`. A secondary storage item with `QueueCount` x `u32`
+//! elements with the number of items in each queue.
+//!
+//! Queues are split into two parts. The first part is a priority queue based on bid size. The
+//! second part is just a FIFO (the size of the second part is set with `FifoQueueLen`). Items are
+//! always prepended so that removal is always O(1) since removal often happens many times under a
+//! single weighed function (`on_initialize`) yet placing bids only ever happens once per weighed
+//! function (`place_bid`). If the queue has a priority portion, then it remains sorted in order of
+//! bid size so that smaller bids fall off as it gets too large.
+//!
+//! Account may enqueue a balance with some number of `Period`s lock up, up to a maximum of
+//! `QueueCount`. The balance gets reserved. There's a minimum of `MinBid` to avoid dust.
+//!
+//! Until your bid is consolidated and you receive a receipt, you can retract it instantly and the
+//! funds are unreserved.
+//!
+//! There's a target proportion of effective total issuance (i.e. accounting for existing receipts)
+//! which the pallet attempts to have frozen at any one time. It will likely be gradually increased
+//! over time by governance.
+//!
+//! As the proportion of effective total issuance represented by outstanding receipts drops below
+//! `FrozenFraction`, then bids are taken from queues and consolidated into receipts, with the queue
+//! of the greatest period taking priority. If the item in the queue's locked amount is greater than
+//! the amount remaining to achieve `FrozenFraction`, then it is split up into multiple bids and
+//! becomes partially consolidated.
+//!
+//! With the consolidation of a bid, the bid amount is taken from the owner and a receipt is issued.
+//! The receipt records the proportion of the bid compared to effective total issuance at the time
+//! of consolidation. The receipt has two independent elements: a "main" non-fungible receipt and
+//! a second set of fungible "counterpart" tokens. The accounting functionality of the latter must
+//! be provided through the `Counterpart` trait item. The main non-fungible receipt may have its
+//! owner transferred through the pallet's implementation of `nonfungible::Transfer`.
+//!
+//! A later `thaw` function may be called in order to reduce the recorded proportion or entirely
+//! remove the receipt in return for the appropriate proportion of the effective total issuance.
+//! This may happen no earlier than queue's period after the point at which the receipt was issued.
+//! The call must be made by the owner of both the "main" non-fungible receipt and the appropriate
+//! amount of counterpart tokens.
+//!
+//! `NoCounterpart` may be provided as an implementation for the counterpart token system in which
+//! case they are completely disregarded from the thawing logic.
+//!
+//! ## Terms
+//!
+//! - *Effective total issuance*: The total issuance of balances in the system, equal to the active
+//!   issuance plus the value of all outstanding receipts, less `IgnoredIssuance`.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::traits::{
+	fungible::{self, Inspect as FunInspect, Mutate as FunMutate},
+	tokens::{DepositConsequence, Fortitude, Preservation, Provenance, WithdrawConsequence},
+};
+pub use pallet::*;
+use sp_arithmetic::{traits::Unsigned, RationalArg};
+use sp_core::TypedGet;
+use sp_runtime::{
+	traits::{Convert, ConvertBack},
+	DispatchError, Perquintill,
+};
+
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+pub struct WithMaximumOf<A: TypedGet>(sp_std::marker::PhantomData<A>);
+impl<A: TypedGet> Convert<Perquintill, A::Type> for WithMaximumOf<A>
+where
+	A::Type: Clone + Unsigned + From<u64>,
+	u64: TryFrom<A::Type>,
+{
+	fn convert(a: Perquintill) -> A::Type {
+		a * A::get()
+	}
+}
+impl<A: TypedGet> ConvertBack<Perquintill, A::Type> for WithMaximumOf<A>
+where
+	A::Type: RationalArg + From<u64>,
+	u64: TryFrom<A::Type>,
+	u128: TryFrom<A::Type>,
+{
+	fn convert_back(a: A::Type) -> Perquintill {
+		Perquintill::from_rational(a, A::get())
+	}
+}
+
+pub struct NoCounterpart<T>(sp_std::marker::PhantomData<T>);
+impl<T> FunInspect<T> for NoCounterpart<T> {
+	type Balance = u32;
+	fn total_issuance() -> u32 {
+		0
+	}
+	fn minimum_balance() -> u32 {
+		0
+	}
+	fn balance(_: &T) -> u32 {
+		0
+	}
+	fn total_balance(_: &T) -> u32 {
+		0
+	}
+	fn reducible_balance(_: &T, _: Preservation, _: Fortitude) -> u32 {
+		0
+	}
+	fn can_deposit(_: &T, _: u32, _: Provenance) -> DepositConsequence {
+		DepositConsequence::Success
+	}
+	fn can_withdraw(_: &T, _: u32) -> WithdrawConsequence<u32> {
+		WithdrawConsequence::Success
+	}
+}
+impl<T> fungible::Unbalanced<T> for NoCounterpart<T> {
+	fn handle_dust(_: fungible::Dust<T, Self>) {}
+	fn write_balance(_: &T, _: Self::Balance) -> Result<Option<Self::Balance>, DispatchError> {
+		Ok(None)
+	}
+	fn set_total_issuance(_: Self::Balance) {}
+}
+impl<T> FunMutate<T> for NoCounterpart<T> {}
+impl<T> Convert<Perquintill, u32> for NoCounterpart<T> {
+	fn convert(_: Perquintill) -> u32 {
+		0
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::{FunInspect, FunMutate};
+	pub use crate::weights::WeightInfo;
+	use frame_support::{
+		pallet_prelude::*,
+		traits::{
+			fungible::{self, hold::Mutate as FunHoldMutate, Balanced as FunBalanced},
+			nonfungible::{Inspect as NftInspect, Transfer as NftTransfer},
+			tokens::{
+				Balance,
+				Fortitude::Polite,
+				Precision::{BestEffort, Exact},
+				Preservation::Expendable,
+				Restriction::{Free, OnHold},
+			},
+			Defensive, DefensiveSaturating, OnUnbalanced,
+		},
+		PalletId,
+	};
+	use frame_system::pallet_prelude::*;
+	use sp_arithmetic::{PerThing, Perquintill};
+	use sp_runtime::{
+		traits::{AccountIdConversion, Bounded, Convert, ConvertBack, Saturating, Zero},
+		Rounding, TokenError,
+	};
+	use sp_std::prelude::*;
+
+	type BalanceOf<T> =
+		<<T as Config>::Currency as FunInspect<<T as frame_system::Config>::AccountId>>::Balance;
+	type DebtOf<T> =
+		fungible::Debt<<T as frame_system::Config>::AccountId, <T as Config>::Currency>;
+	type ReceiptRecordOf<T> =
+		ReceiptRecord<<T as frame_system::Config>::AccountId, BlockNumberFor<T>, BalanceOf<T>>;
+	type IssuanceInfoOf<T> = IssuanceInfo<BalanceOf<T>>;
+	type SummaryRecordOf<T> = SummaryRecord<BlockNumberFor<T>, BalanceOf<T>>;
+	type BidOf<T> = Bid<BalanceOf<T>, <T as frame_system::Config>::AccountId>;
+	type QueueTotalsTypeOf<T> = BoundedVec<(u32, BalanceOf<T>), <T as Config>::QueueCount>;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Information on runtime weights.
+		type WeightInfo: WeightInfo;
+
+		/// Overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The treasury's pallet id, used for deriving its sovereign account ID.
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// Currency type that this works on.
+		type Currency: FunInspect<Self::AccountId, Balance = Self::CurrencyBalance>
+			+ FunMutate<Self::AccountId>
+			+ FunBalanced<Self::AccountId>
+			+ FunHoldMutate<Self::AccountId, Reason = Self::RuntimeHoldReason>;
+
+		/// Overarching hold reason.
+		type RuntimeHoldReason: From<HoldReason>;
+
+		/// Just the [`Balance`] type; we have this item to allow us to constrain it to
+		/// [`From<u64>`].
+		type CurrencyBalance: Balance + From<u64>;
+
+		/// Origin required for auto-funding the deficit.
+		type FundOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The issuance to ignore. This is subtracted from the `Currency`'s `total_issuance` to get
+		/// the issuance with which we determine the thawed value of a given proportion.
+		type IgnoredIssuance: Get<BalanceOf<Self>>;
+
+		/// The accounting system for the fungible counterpart tokens.
+		type Counterpart: FunMutate<Self::AccountId>;
+
+		/// The system to convert an overall proportion of issuance into a number of fungible
+		/// counterpart tokens.
+		///
+		/// In general it's best to use `WithMaximumOf`.
+		type CounterpartAmount: ConvertBack<
+			Perquintill,
+			<Self::Counterpart as FunInspect<Self::AccountId>>::Balance,
+		>;
+
+		/// Unbalanced handler to account for funds created (in case of a higher total issuance over
+		/// freezing period).
+		type Deficit: OnUnbalanced<DebtOf<Self>>;
+
+		/// The target sum of all receipts' proportions.
+		type Target: Get<Perquintill>;
+
+		/// Number of duration queues in total. This sets the maximum duration supported, which is
+		/// this value multiplied by `Period`.
+		#[pallet::constant]
+		type QueueCount: Get<u32>;
+
+		/// Maximum number of items that may be in each duration queue.
+		///
+		/// Must be larger than zero.
+		#[pallet::constant]
+		type MaxQueueLen: Get<u32>;
+
+		/// Portion of the queue which is free from ordering and just a FIFO.
+		///
+		/// Must be no greater than `MaxQueueLen`.
+		#[pallet::constant]
+		type FifoQueueLen: Get<u32>;
+
+		/// The base period for the duration queues. This is the common multiple across all
+		/// supported freezing durations that can be bid upon.
+		#[pallet::constant]
+		type BasePeriod: Get<BlockNumberFor<Self>>;
+
+		/// The minimum amount of funds that may be placed in a bid. Note that this
+		/// does not actually limit the amount which may be represented in a receipt since bids may
+		/// be split up by the system.
+		///
+		/// It should be at least big enough to ensure that there is no possible storage spam attack
+		/// or queue-filling attack.
+		#[pallet::constant]
+		type MinBid: Get<BalanceOf<Self>>;
+
+		/// The minimum amount of funds which may intentionally be left remaining under a single
+		/// receipt.
+		#[pallet::constant]
+		type MinReceipt: Get<Perquintill>;
+
+		/// The number of blocks between consecutive attempts to dequeue bids and create receipts.
+		///
+		/// A larger value results in fewer storage hits each block, but a slower period to get to
+		/// the target.
+		#[pallet::constant]
+		type IntakePeriod: Get<BlockNumberFor<Self>>;
+
+		/// The maximum amount of bids that can consolidated into receipts in a single intake. A
+		/// larger value here means less of the block available for transactions should there be a
+		/// glut of bids.
+		#[pallet::constant]
+		type MaxIntakeWeight: Get<Weight>;
+
+		/// The maximum proportion which may be thawed and the period over which it is reset.
+		#[pallet::constant]
+		type ThawThrottle: Get<(Perquintill, BlockNumberFor<Self>)>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// A single bid, an item of a *queue* in `Queues`.
+	#[derive(
+		Clone, Eq, PartialEq, Default, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen,
+	)]
+	pub struct Bid<Balance, AccountId> {
+		/// The amount bid.
+		pub amount: Balance,
+		/// The owner of the bid.
+		pub who: AccountId,
+	}
+
+	/// Information representing a receipt.
+	#[derive(
+		Clone, Eq, PartialEq, Default, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen,
+	)]
+	pub struct ReceiptRecord<AccountId, BlockNumber, Balance> {
+		/// The proportion of the effective total issuance.
+		pub proportion: Perquintill,
+		/// The account to whom this receipt belongs and the amount of funds on hold in their
+		/// account for servicing this receipt. If `None`, then it is a communal receipt and
+		/// fungible counterparts have been issued.
+		pub owner: Option<(AccountId, Balance)>,
+		/// The time after which this receipt can be thawed.
+		pub expiry: BlockNumber,
+	}
+
+	/// An index for a receipt.
+	pub type ReceiptIndex = u32;
+
+	/// Overall information package on the outstanding receipts.
+	///
+	/// The way of determining the net issuance (i.e. after factoring in all maturing frozen funds)
+	/// is:
+	///
+	/// `issuance - frozen + proportion * issuance`
+	///
+	/// where `issuance = active_issuance - IgnoredIssuance`
+	#[derive(
+		Clone, Eq, PartialEq, Default, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen,
+	)]
+	pub struct SummaryRecord<BlockNumber, Balance> {
+		/// The total proportion over all outstanding receipts.
+		pub proportion_owed: Perquintill,
+		/// The total number of receipts created so far.
+		pub index: ReceiptIndex,
+		/// The amount (as a proportion of ETI) which has been thawed in this period so far.
+		pub thawed: Perquintill,
+		/// The current thaw period's beginning.
+		pub last_period: BlockNumber,
+		/// The total amount of funds on hold for receipts. This doesn't include the pot or funds
+		/// on hold for bids.
+		pub receipts_on_hold: Balance,
+	}
+
+	pub struct OnEmptyQueueTotals<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> Get<QueueTotalsTypeOf<T>> for OnEmptyQueueTotals<T> {
+		fn get() -> QueueTotalsTypeOf<T> {
+			BoundedVec::truncate_from(vec![
+				(0, Zero::zero());
+				<T as Config>::QueueCount::get() as usize
+			])
+		}
+	}
+
+	/// The totals of items and balances within each queue. Saves a lot of storage reads in the
+	/// case of sparsely packed queues.
+	///
+	/// The vector is indexed by duration in `Period`s, offset by one, so information on the queue
+	/// whose duration is one `Period` would be storage `0`.
+	#[pallet::storage]
+	pub type QueueTotals<T: Config> =
+		StorageValue<_, QueueTotalsTypeOf<T>, ValueQuery, OnEmptyQueueTotals<T>>;
+
+	/// The queues of bids. Indexed by duration (in `Period`s).
+	#[pallet::storage]
+	pub type Queues<T: Config> =
+		StorageMap<_, Blake2_128Concat, u32, BoundedVec<BidOf<T>, T::MaxQueueLen>, ValueQuery>;
+
+	/// Summary information over the general state.
+	#[pallet::storage]
+	pub type Summary<T> = StorageValue<_, SummaryRecordOf<T>, ValueQuery>;
+
+	/// The currently outstanding receipts, indexed according to the order of creation.
+	#[pallet::storage]
+	pub type Receipts<T> =
+		StorageMap<_, Blake2_128Concat, ReceiptIndex, ReceiptRecordOf<T>, OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A bid was successfully placed.
+		BidPlaced { who: T::AccountId, amount: BalanceOf<T>, duration: u32 },
+		/// A bid was successfully removed (before being accepted).
+		BidRetracted { who: T::AccountId, amount: BalanceOf<T>, duration: u32 },
+		/// A bid was dropped from a queue because of another, more substantial, bid was present.
+		BidDropped { who: T::AccountId, amount: BalanceOf<T>, duration: u32 },
+		/// A bid was accepted. The balance may not be released until expiry.
+		Issued {
+			/// The identity of the receipt.
+			index: ReceiptIndex,
+			/// The block number at which the receipt may be thawed.
+			expiry: BlockNumberFor<T>,
+			/// The owner of the receipt.
+			who: T::AccountId,
+			/// The proportion of the effective total issuance which the receipt represents.
+			proportion: Perquintill,
+			/// The amount of funds which were debited from the owner.
+			amount: BalanceOf<T>,
+		},
+		/// An receipt has been (at least partially) thawed.
+		Thawed {
+			/// The identity of the receipt.
+			index: ReceiptIndex,
+			/// The owner.
+			who: T::AccountId,
+			/// The proportion of the effective total issuance by which the owner was debited.
+			proportion: Perquintill,
+			/// The amount by which the owner was credited.
+			amount: BalanceOf<T>,
+			/// If `true` then the receipt is done.
+			dropped: bool,
+		},
+		/// An automatic funding of the deficit was made.
+		Funded { deficit: BalanceOf<T> },
+		/// A receipt was transfered.
+		Transferred { from: T::AccountId, to: T::AccountId, index: ReceiptIndex },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The duration of the bid is less than one.
+		DurationTooSmall,
+		/// The duration is the bid is greater than the number of queues.
+		DurationTooBig,
+		/// The amount of the bid is less than the minimum allowed.
+		AmountTooSmall,
+		/// The queue for the bid's duration is full and the amount bid is too low to get in
+		/// through replacing an existing bid.
+		BidTooLow,
+		/// Receipt index is unknown.
+		UnknownReceipt,
+		/// Not the owner of the receipt.
+		NotOwner,
+		/// Bond not yet at expiry date.
+		NotExpired,
+		/// The given bid for retraction is not found.
+		UnknownBid,
+		/// The portion supplied is beyond the value of the receipt.
+		PortionTooBig,
+		/// Not enough funds are held to pay out.
+		Unfunded,
+		/// There are enough funds for what is required.
+		AlreadyFunded,
+		/// The thaw throttle has been reached for this period.
+		Throttled,
+		/// The operation would result in a receipt worth an insignficant value.
+		MakesDust,
+		/// The receipt is already communal.
+		AlreadyCommunal,
+		/// The receipt is already private.
+		AlreadyPrivate,
+	}
+
+	/// A reason for the NIS pallet placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// The NIS Pallet has reserved it for a non-fungible receipt.
+		#[codec(index = 0)]
+		NftReceipt,
+	}
+
+	pub(crate) struct WeightCounter {
+		pub(crate) used: Weight,
+		pub(crate) limit: Weight,
+	}
+	impl WeightCounter {
+		#[allow(dead_code)]
+		pub(crate) fn unlimited() -> Self {
+			WeightCounter { used: Weight::zero(), limit: Weight::max_value() }
+		}
+		fn check_accrue(&mut self, w: Weight) -> bool {
+			let test = self.used.saturating_add(w);
+			if test.any_gt(self.limit) {
+				false
+			} else {
+				self.used = test;
+				true
+			}
+		}
+		fn can_accrue(&mut self, w: Weight) -> bool {
+			self.used.saturating_add(w).all_lte(self.limit)
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+			let mut weight_counter =
+				WeightCounter { used: Weight::zero(), limit: T::MaxIntakeWeight::get() };
+			if T::IntakePeriod::get().is_zero() || (n % T::IntakePeriod::get()).is_zero() {
+				if weight_counter.check_accrue(T::WeightInfo::process_queues()) {
+					Self::process_queues(
+						T::Target::get(),
+						T::QueueCount::get(),
+						u32::max_value(),
+						&mut weight_counter,
+					)
+				}
+			}
+			weight_counter.used
+		}
+
+		fn integrity_test() {
+			assert!(!T::IntakePeriod::get().is_zero());
+			assert!(!T::MaxQueueLen::get().is_zero());
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Place a bid.
+		///
+		/// Origin must be Signed, and account must have at least `amount` in free balance.
+		///
+		/// - `amount`: The amount of the bid; these funds will be reserved, and if/when
+		///   consolidated, removed. Must be at least `MinBid`.
+		/// - `duration`: The number of periods before which the newly consolidated bid may be
+		///   thawed. Must be greater than 1 and no more than `QueueCount`.
+		///
+		/// Complexities:
+		/// - `Queues[duration].len()` (just take max).
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::place_bid_max())]
+		pub fn place_bid(
+			origin: OriginFor<T>,
+			#[pallet::compact] amount: BalanceOf<T>,
+			duration: u32,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			ensure!(amount >= T::MinBid::get(), Error::<T>::AmountTooSmall);
+			let queue_count = T::QueueCount::get() as usize;
+			let queue_index = duration.checked_sub(1).ok_or(Error::<T>::DurationTooSmall)? as usize;
+			ensure!(queue_index < queue_count, Error::<T>::DurationTooBig);
+
+			let net = Queues::<T>::try_mutate(
+				duration,
+				|q| -> Result<(u32, BalanceOf<T>), DispatchError> {
+					let queue_full = q.len() == T::MaxQueueLen::get() as usize;
+					ensure!(!queue_full || q[0].amount < amount, Error::<T>::BidTooLow);
+					T::Currency::hold(&HoldReason::NftReceipt.into(), &who, amount)?;
+
+					// queue is <Ordered: Lowest ... Highest><Fifo: Last ... First>
+					let mut bid = Bid { amount, who: who.clone() };
+					let net = if queue_full {
+						sp_std::mem::swap(&mut q[0], &mut bid);
+						let _ = T::Currency::release(
+							&HoldReason::NftReceipt.into(),
+							&bid.who,
+							bid.amount,
+							BestEffort,
+						);
+						Self::deposit_event(Event::<T>::BidDropped {
+							who: bid.who,
+							amount: bid.amount,
+							duration,
+						});
+						(0, amount - bid.amount)
+					} else {
+						q.try_insert(0, bid).expect("verified queue was not full above. qed.");
+						(1, amount)
+					};
+
+					let sorted_item_count = q.len().saturating_sub(T::FifoQueueLen::get() as usize);
+					if sorted_item_count > 1 {
+						q[0..sorted_item_count].sort_by_key(|x| x.amount);
+					}
+
+					Ok(net)
+				},
+			)?;
+			QueueTotals::<T>::mutate(|qs| {
+				qs.bounded_resize(queue_count, (0, Zero::zero()));
+				qs[queue_index].0 += net.0;
+				qs[queue_index].1.saturating_accrue(net.1);
+			});
+			Self::deposit_event(Event::BidPlaced { who, amount, duration });
+
+			Ok(())
+		}
+
+		/// Retract a previously placed bid.
+		///
+		/// Origin must be Signed, and the account should have previously issued a still-active bid
+		/// of `amount` for `duration`.
+		///
+		/// - `amount`: The amount of the previous bid.
+		/// - `duration`: The duration of the previous bid.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::retract_bid(T::MaxQueueLen::get()))]
+		pub fn retract_bid(
+			origin: OriginFor<T>,
+			#[pallet::compact] amount: BalanceOf<T>,
+			duration: u32,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let queue_count = T::QueueCount::get() as usize;
+			let queue_index = duration.checked_sub(1).ok_or(Error::<T>::DurationTooSmall)? as usize;
+			ensure!(queue_index < queue_count, Error::<T>::DurationTooBig);
+
+			let bid = Bid { amount, who };
+
+			let mut queue = Queues::<T>::get(duration);
+			let pos = queue.iter().position(|i| i == &bid).ok_or(Error::<T>::UnknownBid)?;
+			queue.remove(pos);
+			let new_len = queue.len() as u32;
+
+			T::Currency::release(&HoldReason::NftReceipt.into(), &bid.who, bid.amount, BestEffort)?;
+
+			Queues::<T>::insert(duration, queue);
+			QueueTotals::<T>::mutate(|qs| {
+				qs.bounded_resize(queue_count, (0, Zero::zero()));
+				qs[queue_index].0 = new_len;
+				qs[queue_index].1.saturating_reduce(bid.amount);
+			});
+
+			Self::deposit_event(Event::BidRetracted { who: bid.who, amount: bid.amount, duration });
+
+			Ok(())
+		}
+
+		/// Ensure we have sufficient funding for all potential payouts.
+		///
+		/// - `origin`: Must be accepted by `FundOrigin`.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::fund_deficit())]
+		pub fn fund_deficit(origin: OriginFor<T>) -> DispatchResult {
+			T::FundOrigin::ensure_origin(origin)?;
+			let summary: SummaryRecordOf<T> = Summary::<T>::get();
+			let our_account = Self::account_id();
+			let issuance = Self::issuance_with(&our_account, &summary);
+			let deficit = issuance.required.saturating_sub(issuance.holdings);
+			ensure!(!deficit.is_zero(), Error::<T>::AlreadyFunded);
+			T::Deficit::on_unbalanced(T::Currency::deposit(&our_account, deficit, Exact)?);
+			Self::deposit_event(Event::<T>::Funded { deficit });
+			Ok(())
+		}
+
+		/// Reduce or remove an outstanding receipt, placing the according proportion of funds into
+		/// the account of the owner.
+		///
+		/// - `origin`: Must be Signed and the account must be the owner of the receipt `index` as
+		///   well as any fungible counterpart.
+		/// - `index`: The index of the receipt.
+		/// - `portion`: If `Some`, then only the given portion of the receipt should be thawed. If
+		///   `None`, then all of it should be.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::thaw_private())]
+		pub fn thaw_private(
+			origin: OriginFor<T>,
+			#[pallet::compact] index: ReceiptIndex,
+			maybe_proportion: Option<Perquintill>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			// Look for `index`
+			let mut receipt: ReceiptRecordOf<T> =
+				Receipts::<T>::get(index).ok_or(Error::<T>::UnknownReceipt)?;
+			// If found, check the owner is `who`.
+			let (owner, mut on_hold) = receipt.owner.ok_or(Error::<T>::AlreadyCommunal)?;
+			ensure!(owner == who, Error::<T>::NotOwner);
+
+			let now = frame_system::Pallet::<T>::block_number();
+			ensure!(now >= receipt.expiry, Error::<T>::NotExpired);
+
+			let mut summary: SummaryRecordOf<T> = Summary::<T>::get();
+
+			let proportion = if let Some(proportion) = maybe_proportion {
+				ensure!(proportion <= receipt.proportion, Error::<T>::PortionTooBig);
+				let remaining = receipt.proportion.saturating_sub(proportion);
+				ensure!(
+					remaining.is_zero() || remaining >= T::MinReceipt::get(),
+					Error::<T>::MakesDust
+				);
+				proportion
+			} else {
+				receipt.proportion
+			};
+
+			let (throttle, throttle_period) = T::ThawThrottle::get();
+			if now.saturating_sub(summary.last_period) >= throttle_period {
+				summary.thawed = Zero::zero();
+				summary.last_period = now;
+			}
+			summary.thawed.saturating_accrue(proportion);
+			ensure!(summary.thawed <= throttle, Error::<T>::Throttled);
+
+			// Multiply the proportion it is by the total issued.
+			let our_account = Self::account_id();
+			let effective_issuance = Self::issuance_with(&our_account, &summary).effective;
+			//			let amount = proportion.mul_ceil(effective_issuance);
+			let amount = proportion * effective_issuance;
+
+			receipt.proportion.saturating_reduce(proportion);
+			summary.proportion_owed.saturating_reduce(proportion);
+
+			let dropped = receipt.proportion.is_zero();
+
+			if amount > on_hold {
+				T::Currency::release(&HoldReason::NftReceipt.into(), &who, on_hold, Exact)?;
+				let deficit = amount - on_hold;
+				// Try to transfer deficit from pot to receipt owner.
+				summary.receipts_on_hold.saturating_reduce(on_hold);
+				on_hold = Zero::zero();
+				T::Currency::transfer(&our_account, &who, deficit, Expendable)
+					.map_err(|_| Error::<T>::Unfunded)?;
+			} else {
+				on_hold.saturating_reduce(amount);
+				summary.receipts_on_hold.saturating_reduce(amount);
+				if dropped && !on_hold.is_zero() {
+					// Reclaim any remainder:
+					// Transfer excess of `on_hold` to the pot if we have now fully compensated for
+					// the receipt.
+					T::Currency::transfer_on_hold(
+						&HoldReason::NftReceipt.into(),
+						&who,
+						&our_account,
+						on_hold,
+						Exact,
+						Free,
+						Polite,
+					)
+					.map(|_| ())
+					// We ignore this error as it just means the amount we're trying to deposit is
+					// dust and the beneficiary account doesn't exist.
+					.or_else(
+						|e| if e == TokenError::CannotCreate.into() { Ok(()) } else { Err(e) },
+					)?;
+					summary.receipts_on_hold.saturating_reduce(on_hold);
+				}
+				T::Currency::release(&HoldReason::NftReceipt.into(), &who, amount, Exact)?;
+			}
+
+			if dropped {
+				Receipts::<T>::remove(index);
+			} else {
+				receipt.owner = Some((owner, on_hold));
+				Receipts::<T>::insert(index, &receipt);
+			}
+			Summary::<T>::put(&summary);
+
+			Self::deposit_event(Event::Thawed { index, who, amount, proportion, dropped });
+
+			Ok(())
+		}
+
+		/// Reduce or remove an outstanding receipt, placing the according proportion of funds into
+		/// the account of the owner.
+		///
+		/// - `origin`: Must be Signed and the account must be the owner of the fungible counterpart
+		///   for receipt `index`.
+		/// - `index`: The index of the receipt.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::thaw_communal())]
+		pub fn thaw_communal(
+			origin: OriginFor<T>,
+			#[pallet::compact] index: ReceiptIndex,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			// Look for `index`
+			let receipt: ReceiptRecordOf<T> =
+				Receipts::<T>::get(index).ok_or(Error::<T>::UnknownReceipt)?;
+			// If found, check it is actually communal.
+			ensure!(receipt.owner.is_none(), Error::<T>::NotOwner);
+			let now = frame_system::Pallet::<T>::block_number();
+			ensure!(now >= receipt.expiry, Error::<T>::NotExpired);
+
+			let mut summary: SummaryRecordOf<T> = Summary::<T>::get();
+
+			let (throttle, throttle_period) = T::ThawThrottle::get();
+			if now.saturating_sub(summary.last_period) >= throttle_period {
+				summary.thawed = Zero::zero();
+				summary.last_period = now;
+			}
+			summary.thawed.saturating_accrue(receipt.proportion);
+			ensure!(summary.thawed <= throttle, Error::<T>::Throttled);
+
+			let cp_amount = T::CounterpartAmount::convert(receipt.proportion);
+			T::Counterpart::burn_from(&who, cp_amount, Exact, Polite)?;
+
+			// Multiply the proportion it is by the total issued.
+			let our_account = Self::account_id();
+			let effective_issuance = Self::issuance_with(&our_account, &summary).effective;
+			let amount = receipt.proportion * effective_issuance;
+
+			summary.proportion_owed.saturating_reduce(receipt.proportion);
+
+			// Try to transfer amount owed from pot to receipt owner.
+			T::Currency::transfer(&our_account, &who, amount, Expendable)
+				.map_err(|_| Error::<T>::Unfunded)?;
+
+			Receipts::<T>::remove(index);
+			Summary::<T>::put(&summary);
+
+			let e =
+				Event::Thawed { index, who, amount, proportion: receipt.proportion, dropped: true };
+			Self::deposit_event(e);
+
+			Ok(())
+		}
+
+		/// Make a private receipt communal and create fungible counterparts for its owner.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::communify())]
+		pub fn communify(
+			origin: OriginFor<T>,
+			#[pallet::compact] index: ReceiptIndex,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			// Look for `index`
+			let mut receipt: ReceiptRecordOf<T> =
+				Receipts::<T>::get(index).ok_or(Error::<T>::UnknownReceipt)?;
+
+			// Check it's not already communal and make it so.
+			let (owner, on_hold) = receipt.owner.take().ok_or(Error::<T>::AlreadyCommunal)?;
+
+			// If found, check the owner is `who`.
+			ensure!(owner == who, Error::<T>::NotOwner);
+
+			// Unreserve and transfer the funds to the pot.
+			let reason = HoldReason::NftReceipt.into();
+			let us = Self::account_id();
+			T::Currency::transfer_on_hold(&reason, &who, &us, on_hold, Exact, Free, Polite)
+				.map_err(|_| Error::<T>::Unfunded)?;
+
+			// Record that we've moved the amount reserved.
+			let mut summary: SummaryRecordOf<T> = Summary::<T>::get();
+			summary.receipts_on_hold.saturating_reduce(on_hold);
+			Summary::<T>::put(&summary);
+			Receipts::<T>::insert(index, &receipt);
+
+			// Mint fungibles.
+			let fung_eq = T::CounterpartAmount::convert(receipt.proportion);
+			let _ = T::Counterpart::mint_into(&who, fung_eq).defensive();
+
+			Ok(())
+		}
+
+		/// Make a communal receipt private and burn fungible counterparts from its owner.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::privatize())]
+		pub fn privatize(
+			origin: OriginFor<T>,
+			#[pallet::compact] index: ReceiptIndex,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			// Look for `index`
+			let mut receipt: ReceiptRecordOf<T> =
+				Receipts::<T>::get(index).ok_or(Error::<T>::UnknownReceipt)?;
+
+			// If found, check there is no owner.
+			ensure!(receipt.owner.is_none(), Error::<T>::AlreadyPrivate);
+
+			// Multiply the proportion it is by the total issued.
+			let mut summary: SummaryRecordOf<T> = Summary::<T>::get();
+			let our_account = Self::account_id();
+			let effective_issuance = Self::issuance_with(&our_account, &summary).effective;
+			let max_amount = receipt.proportion * effective_issuance;
+			// Avoid trying to place more in the account's reserve than we have available in the pot
+			let amount = max_amount.min(T::Currency::balance(&our_account));
+
+			// Burn fungible counterparts.
+			T::Counterpart::burn_from(
+				&who,
+				T::CounterpartAmount::convert(receipt.proportion),
+				Exact,
+				Polite,
+			)?;
+
+			// Transfer the funds from the pot to the owner and reserve
+			let reason = HoldReason::NftReceipt.into();
+			let us = Self::account_id();
+			T::Currency::transfer_and_hold(&reason, &us, &who, amount, Exact, Expendable, Polite)?;
+
+			// Record that we've moved the amount reserved.
+			summary.receipts_on_hold.saturating_accrue(amount);
+
+			receipt.owner = Some((who, amount));
+
+			Summary::<T>::put(&summary);
+			Receipts::<T>::insert(index, &receipt);
+
+			Ok(())
+		}
+	}
+
+	/// Issuance information returned by `issuance()`.
+	#[derive(Debug)]
+	pub struct IssuanceInfo<Balance> {
+		/// The balance held by this pallet instance together with the balances on hold across
+		/// all receipt-owning accounts.
+		pub holdings: Balance,
+		/// The (non-ignored) issuance in the system, not including this pallet's account.
+		pub other: Balance,
+		/// The effective total issuance, hypothetically if all outstanding receipts were thawed at
+		/// present.
+		pub effective: Balance,
+		/// The amount needed to be accessible to this pallet in case all outstanding receipts were
+		/// thawed at present. If it is more than `holdings`, then the pallet will need funding.
+		pub required: Balance,
+	}
+
+	impl<T: Config> NftInspect<T::AccountId> for Pallet<T> {
+		type ItemId = ReceiptIndex;
+
+		fn owner(item: &ReceiptIndex) -> Option<T::AccountId> {
+			Receipts::<T>::get(item).and_then(|r| r.owner).map(|(who, _)| who)
+		}
+
+		fn attribute(item: &Self::ItemId, key: &[u8]) -> Option<Vec<u8>> {
+			let item = Receipts::<T>::get(item)?;
+			match key {
+				b"proportion" => Some(item.proportion.encode()),
+				b"expiry" => Some(item.expiry.encode()),
+				b"owner" => item.owner.as_ref().map(|x| x.0.encode()),
+				b"on_hold" => item.owner.as_ref().map(|x| x.1.encode()),
+				_ => None,
+			}
+		}
+	}
+
+	impl<T: Config> NftTransfer<T::AccountId> for Pallet<T> {
+		fn transfer(index: &ReceiptIndex, dest: &T::AccountId) -> DispatchResult {
+			let mut item = Receipts::<T>::get(index).ok_or(TokenError::UnknownAsset)?;
+			let (owner, on_hold) = item.owner.take().ok_or(Error::<T>::AlreadyCommunal)?;
+
+			let reason = HoldReason::NftReceipt.into();
+			T::Currency::transfer_on_hold(&reason, &owner, dest, on_hold, Exact, OnHold, Polite)?;
+
+			item.owner = Some((dest.clone(), on_hold));
+			Receipts::<T>::insert(&index, &item);
+			Pallet::<T>::deposit_event(Event::<T>::Transferred {
+				from: owner,
+				to: dest.clone(),
+				index: *index,
+			});
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// The account ID of the reserves.
+		///
+		/// This actually does computation. If you need to keep using it, then make sure you cache
+		/// the value and only call this once.
+		pub fn account_id() -> T::AccountId {
+			T::PalletId::get().into_account_truncating()
+		}
+
+		/// Returns information on the issuance within the system.
+		pub fn issuance() -> IssuanceInfo<BalanceOf<T>> {
+			Self::issuance_with(&Self::account_id(), &Summary::<T>::get())
+		}
+
+		/// Returns information on the issuance within the system
+		///
+		/// This function is equivalent to `issuance`, except that it accepts arguments rather than
+		/// queries state. If the arguments are already known, then this may be slightly more
+		/// performant.
+		///
+		/// - `our_account`: The value returned by `Self::account_id()`.
+		/// - `summary`: The value returned by `Summary::<T>::get()`.
+		pub fn issuance_with(
+			our_account: &T::AccountId,
+			summary: &SummaryRecordOf<T>,
+		) -> IssuanceInfo<BalanceOf<T>> {
+			let total_issuance =
+				T::Currency::active_issuance().saturating_sub(T::IgnoredIssuance::get());
+			let holdings =
+				T::Currency::balance(our_account).saturating_add(summary.receipts_on_hold);
+			let other = total_issuance.saturating_sub(holdings);
+			let effective =
+				summary.proportion_owed.left_from_one().saturating_reciprocal_mul(other);
+			let required = summary.proportion_owed * effective;
+			IssuanceInfo { holdings, other, effective, required }
+		}
+
+		/// Process some bids into receipts up to a `target` total of all receipts.
+		///
+		/// Touch at most `max_queues`.
+		///
+		/// Return the weight used.
+		pub(crate) fn process_queues(
+			target: Perquintill,
+			max_queues: u32,
+			max_bids: u32,
+			weight: &mut WeightCounter,
+		) {
+			let mut summary: SummaryRecordOf<T> = Summary::<T>::get();
+			if summary.proportion_owed >= target {
+				return
+			}
+
+			let now = frame_system::Pallet::<T>::block_number();
+			let our_account = Self::account_id();
+			let issuance: IssuanceInfoOf<T> = Self::issuance_with(&our_account, &summary);
+			let mut remaining = target.saturating_sub(summary.proportion_owed) * issuance.effective;
+
+			let mut queues_hit = 0;
+			let mut bids_hit = 0;
+			let mut totals = QueueTotals::<T>::get();
+			let queue_count = T::QueueCount::get();
+			totals.bounded_resize(queue_count as usize, (0, Zero::zero()));
+			for duration in (1..=queue_count).rev() {
+				if totals[duration as usize - 1].0.is_zero() {
+					continue
+				}
+				if remaining.is_zero() || queues_hit >= max_queues
+					|| !weight.check_accrue(T::WeightInfo::process_queue())
+					// No point trying to process a queue if we can't process a single bid.
+					|| !weight.can_accrue(T::WeightInfo::process_bid())
+				{
+					break
+				}
+
+				let b = Self::process_queue(
+					duration,
+					now,
+					&our_account,
+					&issuance,
+					max_bids.saturating_sub(bids_hit),
+					&mut remaining,
+					&mut totals[duration as usize - 1],
+					&mut summary,
+					weight,
+				);
+
+				bids_hit.saturating_accrue(b);
+				queues_hit.saturating_inc();
+			}
+			QueueTotals::<T>::put(&totals);
+			Summary::<T>::put(&summary);
+		}
+
+		pub(crate) fn process_queue(
+			duration: u32,
+			now: BlockNumberFor<T>,
+			our_account: &T::AccountId,
+			issuance: &IssuanceInfo<BalanceOf<T>>,
+			max_bids: u32,
+			remaining: &mut BalanceOf<T>,
+			queue_total: &mut (u32, BalanceOf<T>),
+			summary: &mut SummaryRecordOf<T>,
+			weight: &mut WeightCounter,
+		) -> u32 {
+			let mut queue: BoundedVec<BidOf<T>, _> = Queues::<T>::get(&duration);
+			let expiry = now.saturating_add(T::BasePeriod::get().saturating_mul(duration.into()));
+			let mut count = 0;
+
+			while count < max_bids &&
+				!queue.is_empty() &&
+				!remaining.is_zero() &&
+				weight.check_accrue(T::WeightInfo::process_bid())
+			{
+				let bid = match queue.pop() {
+					Some(b) => b,
+					None => break,
+				};
+				if let Some(bid) = Self::process_bid(
+					bid,
+					expiry,
+					our_account,
+					issuance,
+					remaining,
+					&mut queue_total.1,
+					summary,
+				) {
+					queue.try_push(bid).expect("just popped, so there must be space. qed");
+					// This should exit at the next iteration (though nothing will break if it
+					// doesn't).
+				}
+				count.saturating_inc();
+			}
+			queue_total.0 = queue.len() as u32;
+			Queues::<T>::insert(&duration, &queue);
+			count
+		}
+
+		pub(crate) fn process_bid(
+			mut bid: BidOf<T>,
+			expiry: BlockNumberFor<T>,
+			_our_account: &T::AccountId,
+			issuance: &IssuanceInfo<BalanceOf<T>>,
+			remaining: &mut BalanceOf<T>,
+			queue_amount: &mut BalanceOf<T>,
+			summary: &mut SummaryRecordOf<T>,
+		) -> Option<BidOf<T>> {
+			let result = if *remaining < bid.amount {
+				let overflow = bid.amount - *remaining;
+				bid.amount = *remaining;
+				Some(Bid { amount: overflow, who: bid.who.clone() })
+			} else {
+				None
+			};
+			let amount = bid.amount;
+			summary.receipts_on_hold.saturating_accrue(amount);
+
+			// Can never overflow due to block above.
+			remaining.saturating_reduce(amount);
+			// Should never underflow since it should track the total of the
+			// bids exactly, but we'll be defensive.
+			queue_amount.defensive_saturating_reduce(amount);
+
+			// Now to activate the bid...
+			let n = amount;
+			let d = issuance.effective;
+			let proportion = Perquintill::from_rational_with_rounding(n, d, Rounding::Down)
+				.defensive_unwrap_or_default();
+			let who = bid.who;
+			let index = summary.index;
+			summary.proportion_owed.defensive_saturating_accrue(proportion);
+			summary.index += 1;
+
+			let e = Event::Issued { index, expiry, who: who.clone(), amount, proportion };
+			Self::deposit_event(e);
+			let receipt = ReceiptRecord { proportion, owner: Some((who, amount)), expiry };
+			Receipts::<T>::insert(index, receipt);
+
+			result
+		}
+	}
+}
diff --git a/substrate/frame/nis/src/mock.rs b/substrate/frame/nis/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76fdf5f3f069376f4c42325685fe8d282672c5d1
--- /dev/null
+++ b/substrate/frame/nis/src/mock.rs
@@ -0,0 +1,181 @@
+// 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.
+
+//! Test environment for NIS pallet.
+
+use crate::{self as pallet_nis, Perquintill, WithMaximumOf};
+
+use frame_support::{
+	ord_parameter_types, parameter_types,
+	traits::{
+		fungible::Inspect, ConstU16, ConstU32, ConstU64, Everything, OnFinalize, OnInitialize,
+		StorageMapShim,
+	},
+	weights::Weight,
+	PalletId,
+};
+use pallet_balances::{Instance1, Instance2};
+use sp_core::{ConstU128, H256};
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+pub type Balance = u64;
+
+// Configure a mock runtime to test the pallet.
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances::<Instance1>,
+		NisBalances: pallet_balances::<Instance2>,
+		Nis: pallet_nis,
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = Everything;
+	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 Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<Balance>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ConstU16<42>;
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl pallet_balances::Config<Instance1> for Test {
+	type Balance = Balance;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = ConstU64<1>;
+	type AccountStore = System;
+	type WeightInfo = ();
+	type MaxLocks = ();
+	type MaxReserves = ConstU32<1>;
+	type ReserveIdentifier = [u8; 8];
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type MaxHolds = ConstU32<1>;
+}
+
+impl pallet_balances::Config<Instance2> for Test {
+	type Balance = u128;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = ConstU128<1>;
+	type AccountStore = StorageMapShim<
+		pallet_balances::Account<Test, Instance2>,
+		u64,
+		pallet_balances::AccountData<u128>,
+	>;
+	type WeightInfo = ();
+	type MaxLocks = ();
+	type MaxReserves = ();
+	type ReserveIdentifier = [u8; 8];
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+
+parameter_types! {
+	pub IgnoredIssuance: Balance = Balances::total_balance(&0); // Account zero is ignored.
+	pub const NisPalletId: PalletId = PalletId(*b"py/nis  ");
+	pub static Target: Perquintill = Perquintill::zero();
+	pub const MinReceipt: Perquintill = Perquintill::from_percent(1);
+	pub const ThawThrottle: (Perquintill, u64) = (Perquintill::from_percent(25), 5);
+	pub static MaxIntakeWeight: Weight = Weight::from_parts(2_000_000_000_000, 0);
+}
+
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+impl pallet_nis::Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = NisPalletId;
+	type Currency = Balances;
+	type CurrencyBalance = <Self as pallet_balances::Config<Instance1>>::Balance;
+	type FundOrigin = frame_system::EnsureSigned<Self::AccountId>;
+	type Deficit = ();
+	type IgnoredIssuance = IgnoredIssuance;
+	type Counterpart = NisBalances;
+	type CounterpartAmount = WithMaximumOf<ConstU128<21_000_000u128>>;
+	type Target = Target;
+	type QueueCount = ConstU32<3>;
+	type MaxQueueLen = ConstU32<3>;
+	type FifoQueueLen = ConstU32<1>;
+	type BasePeriod = ConstU64<3>;
+	type MinBid = ConstU64<2>;
+	type IntakePeriod = ConstU64<2>;
+	type MaxIntakeWeight = MaxIntakeWeight;
+	type MinReceipt = MinReceipt;
+	type ThawThrottle = ThawThrottle;
+	type RuntimeHoldReason = RuntimeHoldReason;
+}
+
+// This function basically just builds a genesis storage key/value store according to
+// our desired mockup.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test, Instance1> {
+		balances: vec![(1, 100), (2, 100), (3, 100), (4, 100)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
+
+// This function basically just builds a genesis storage key/value store according to
+// our desired mockup, but without any balances.
+#[cfg(feature = "runtime-benchmarks")]
+pub fn new_test_ext_empty() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
+
+pub fn run_to_block(n: u64) {
+	while System::block_number() < n {
+		Nis::on_finalize(System::block_number());
+		Balances::on_finalize(System::block_number());
+		System::on_finalize(System::block_number());
+		System::set_block_number(System::block_number() + 1);
+		System::on_initialize(System::block_number());
+		Balances::on_initialize(System::block_number());
+		Nis::on_initialize(System::block_number());
+	}
+}
diff --git a/substrate/frame/nis/src/tests.rs b/substrate/frame/nis/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7350da97dc60a65747dc6b195510781ea149b73b
--- /dev/null
+++ b/substrate/frame/nis/src/tests.rs
@@ -0,0 +1,861 @@
+// 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 NIS pallet.
+
+use super::*;
+use crate::{mock::*, Error};
+use frame_support::{
+	assert_noop, assert_ok,
+	traits::{
+		fungible::{hold::Inspect as InspectHold, Inspect as FunInspect, Mutate as FunMutate},
+		nonfungible::{Inspect, Transfer},
+		tokens::{Fortitude::Force, Precision::Exact},
+	},
+};
+use sp_arithmetic::Perquintill;
+use sp_runtime::{
+	Saturating,
+	TokenError::{self, FundsUnavailable},
+};
+
+fn pot() -> Balance {
+	Balances::free_balance(&Nis::account_id())
+}
+
+fn holdings() -> Balance {
+	Nis::issuance().holdings
+}
+
+fn signed(who: u64) -> RuntimeOrigin {
+	RuntimeOrigin::signed(who)
+}
+
+fn enlarge(amount: Balance, max_bids: u32) {
+	let summary: SummaryRecord<u64, Balance> = Summary::<Test>::get();
+	let increase_in_proportion_owed = Perquintill::from_rational(amount, Nis::issuance().effective);
+	let target = summary.proportion_owed.saturating_add(increase_in_proportion_owed);
+	Nis::process_queues(target, u32::max_value(), max_bids, &mut WeightCounter::unlimited());
+}
+
+#[test]
+fn basic_setup_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+
+		for q in 0..3 {
+			assert!(Queues::<Test>::get(q).is_empty());
+		}
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::zero(),
+				index: 0,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 0,
+			}
+		);
+	});
+}
+
+#[test]
+fn place_bid_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_noop!(Nis::place_bid(signed(1), 1, 2), Error::<Test>::AmountTooSmall);
+		assert_noop!(Nis::place_bid(signed(1), 101, 2), FundsUnavailable);
+		assert_noop!(Nis::place_bid(signed(1), 10, 4), Error::<Test>::DurationTooBig);
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_eq!(Balances::reserved_balance(1), 10);
+		assert_eq!(Queues::<Test>::get(2), vec![Bid { amount: 10, who: 1 }]);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(0, 0), (1, 10), (0, 0)]);
+	});
+}
+
+#[test]
+fn place_bid_queuing_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 20, 2));
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_ok!(Nis::place_bid(signed(1), 5, 2));
+		assert_noop!(Nis::place_bid(signed(1), 5, 2), Error::<Test>::BidTooLow);
+		assert_ok!(Nis::place_bid(signed(1), 15, 2));
+		assert_eq!(Balances::reserved_balance(1), 45);
+
+		assert_ok!(Nis::place_bid(signed(1), 25, 2));
+		assert_eq!(Balances::reserved_balance(1), 60);
+		assert_noop!(Nis::place_bid(signed(1), 10, 2), Error::<Test>::BidTooLow);
+		assert_eq!(
+			Queues::<Test>::get(2),
+			vec![
+				Bid { amount: 15, who: 1 },
+				Bid { amount: 25, who: 1 },
+				Bid { amount: 20, who: 1 },
+			]
+		);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(0, 0), (3, 60), (0, 0)]);
+	});
+}
+
+#[test]
+fn place_bid_fails_when_queue_full() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_ok!(Nis::place_bid(signed(2), 10, 2));
+		assert_ok!(Nis::place_bid(signed(3), 10, 2));
+		assert_noop!(Nis::place_bid(signed(4), 10, 2), Error::<Test>::BidTooLow);
+		assert_ok!(Nis::place_bid(signed(4), 10, 3));
+	});
+}
+
+#[test]
+fn multiple_place_bids_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 10, 1));
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_ok!(Nis::place_bid(signed(1), 10, 3));
+		assert_ok!(Nis::place_bid(signed(2), 10, 2));
+
+		assert_eq!(Balances::reserved_balance(1), 40);
+		assert_eq!(Balances::reserved_balance(2), 10);
+		assert_eq!(Queues::<Test>::get(1), vec![Bid { amount: 10, who: 1 },]);
+		assert_eq!(
+			Queues::<Test>::get(2),
+			vec![
+				Bid { amount: 10, who: 2 },
+				Bid { amount: 10, who: 1 },
+				Bid { amount: 10, who: 1 },
+			]
+		);
+		assert_eq!(Queues::<Test>::get(3), vec![Bid { amount: 10, who: 1 },]);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(1, 10), (3, 30), (1, 10)]);
+	});
+}
+
+#[test]
+fn retract_single_item_queue_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 10, 1));
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_ok!(Nis::retract_bid(signed(1), 10, 1));
+
+		assert_eq!(Balances::reserved_balance(1), 10);
+		assert_eq!(Queues::<Test>::get(1), vec![]);
+		assert_eq!(Queues::<Test>::get(2), vec![Bid { amount: 10, who: 1 }]);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(0, 0), (1, 10), (0, 0)]);
+	});
+}
+
+#[test]
+fn retract_with_other_and_duplicate_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 10, 1));
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_ok!(Nis::place_bid(signed(1), 10, 2));
+		assert_ok!(Nis::place_bid(signed(2), 10, 2));
+
+		assert_ok!(Nis::retract_bid(signed(1), 10, 2));
+		assert_eq!(Balances::reserved_balance(1), 20);
+		assert_eq!(Balances::reserved_balance(2), 10);
+		assert_eq!(Queues::<Test>::get(1), vec![Bid { amount: 10, who: 1 },]);
+		assert_eq!(
+			Queues::<Test>::get(2),
+			vec![Bid { amount: 10, who: 2 }, Bid { amount: 10, who: 1 },]
+		);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(1, 10), (2, 20), (0, 0)]);
+	});
+}
+
+#[test]
+fn retract_non_existent_item_fails() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_noop!(Nis::retract_bid(signed(1), 10, 1), Error::<Test>::UnknownBid);
+		assert_ok!(Nis::place_bid(signed(1), 10, 1));
+		assert_noop!(Nis::retract_bid(signed(1), 20, 1), Error::<Test>::UnknownBid);
+		assert_noop!(Nis::retract_bid(signed(1), 10, 2), Error::<Test>::UnknownBid);
+		assert_noop!(Nis::retract_bid(signed(2), 10, 1), Error::<Test>::UnknownBid);
+	});
+}
+
+#[test]
+fn basic_enlarge_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		assert_ok!(Nis::place_bid(signed(2), 40, 2));
+		enlarge(40, 2);
+
+		// Takes 2/2, then stopped because it reaches its max amount
+		assert_eq!(Balances::reserved_balance(1), 40);
+		assert_eq!(Balances::reserved_balance(2), 40);
+		assert_eq!(holdings(), 40);
+
+		assert_eq!(Queues::<Test>::get(1), vec![Bid { amount: 40, who: 1 }]);
+		assert_eq!(Queues::<Test>::get(2), vec![]);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(1, 40), (0, 0), (0, 0)]);
+
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(10),
+				index: 1,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 40,
+			}
+		);
+		assert_eq!(
+			Receipts::<Test>::get(0).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((2, 40)),
+				expiry: 7
+			}
+		);
+	});
+}
+
+#[test]
+fn enlarge_respects_bids_limit() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		assert_ok!(Nis::place_bid(signed(2), 40, 2));
+		assert_ok!(Nis::place_bid(signed(3), 40, 2));
+		assert_ok!(Nis::place_bid(signed(4), 40, 3));
+		enlarge(100, 2);
+
+		// Should have taken 4/3 and 2/2, then stopped because it's only allowed 2.
+		assert_eq!(Queues::<Test>::get(1), vec![Bid { amount: 40, who: 1 }]);
+		assert_eq!(Queues::<Test>::get(2), vec![Bid { amount: 40, who: 3 }]);
+		assert_eq!(Queues::<Test>::get(3), vec![]);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(1, 40), (1, 40), (0, 0)]);
+
+		assert_eq!(
+			Receipts::<Test>::get(0).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((4, 40)),
+				expiry: 10
+			}
+		);
+		assert_eq!(
+			Receipts::<Test>::get(1).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((2, 40)),
+				expiry: 7
+			}
+		);
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(20),
+				index: 2,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 80,
+			}
+		);
+	});
+}
+
+#[test]
+fn enlarge_respects_amount_limit_and_will_split() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 80, 1));
+		enlarge(40, 2);
+
+		// Takes 2/2, then stopped because it reaches its max amount
+		assert_eq!(Queues::<Test>::get(1), vec![Bid { amount: 40, who: 1 }]);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(1, 40), (0, 0), (0, 0)]);
+
+		assert_eq!(
+			Receipts::<Test>::get(0).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((1, 40)),
+				expiry: 4
+			}
+		);
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(10),
+				index: 1,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 40,
+			}
+		);
+	});
+}
+
+#[test]
+fn basic_thaw_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		assert_eq!(Nis::issuance().effective, 400);
+		assert_eq!(Balances::free_balance(1), 60);
+		assert_eq!(Balances::reserved_balance(1), 40);
+		assert_eq!(holdings(), 0);
+
+		enlarge(40, 1);
+		assert_eq!(Nis::issuance().effective, 400);
+		assert_eq!(Balances::free_balance(1), 60);
+		assert_eq!(Balances::reserved_balance(1), 40);
+		assert_eq!(holdings(), 40);
+
+		run_to_block(3);
+		assert_noop!(Nis::thaw_private(signed(1), 0, None), Error::<Test>::NotExpired);
+		run_to_block(4);
+		assert_noop!(Nis::thaw_private(signed(1), 1, None), Error::<Test>::UnknownReceipt);
+		assert_noop!(Nis::thaw_private(signed(2), 0, None), Error::<Test>::NotOwner);
+
+		assert_ok!(Nis::thaw_private(signed(1), 0, None));
+		assert_eq!(NisBalances::free_balance(1), 0);
+		assert_eq!(Nis::typed_attribute::<_, Perquintill>(&0, b"proportion"), None);
+		assert_eq!(Nis::issuance().effective, 400);
+		assert_eq!(Balances::free_balance(1), 100);
+		assert_eq!(pot(), 0);
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::zero(),
+				index: 1,
+				last_period: 0,
+				thawed: Perquintill::from_percent(10),
+				receipts_on_hold: 0,
+			}
+		);
+		assert_eq!(Receipts::<Test>::get(0), None);
+	});
+}
+
+#[test]
+fn partial_thaw_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 80, 1));
+		enlarge(80, 1);
+		assert_eq!(holdings(), 80);
+
+		run_to_block(4);
+		let prop = Perquintill::from_rational(4_100_000, 21_000_000u64);
+		assert_noop!(Nis::thaw_private(signed(1), 0, Some(prop)), Error::<Test>::MakesDust);
+		let prop = Perquintill::from_rational(1_050_000, 21_000_000u64);
+		assert_ok!(Nis::thaw_private(signed(1), 0, Some(prop)));
+
+		assert_eq!(
+			Nis::typed_attribute::<_, Perquintill>(&0, b"proportion"),
+			Some(Perquintill::from_rational(3_150_000u64, 21_000_000u64)),
+		);
+
+		assert_eq!(Nis::issuance().effective, 400);
+		assert_eq!(Balances::free_balance(1), 40);
+		assert_eq!(holdings(), 60);
+
+		assert_ok!(Nis::thaw_private(signed(1), 0, None));
+
+		assert_eq!(Nis::issuance().effective, 400);
+		assert_eq!(Balances::free_balance(1), 100);
+		assert_eq!(pot(), 0);
+
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::zero(),
+				index: 1,
+				last_period: 0,
+				thawed: Perquintill::from_percent(20),
+				receipts_on_hold: 0,
+			}
+		);
+		assert_eq!(Receipts::<Test>::get(0), None);
+	});
+}
+
+#[test]
+fn thaw_respects_transfers() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		enlarge(40, 1);
+		run_to_block(4);
+
+		assert_eq!(Nis::owner(&0), Some(1));
+		assert_eq!(Balances::reserved_balance(&1), 40);
+		assert_eq!(Balances::reserved_balance(&2), 0);
+		assert_ok!(Nis::transfer(&0, &2));
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert_eq!(Balances::reserved_balance(&2), 40);
+
+		// Transfering the receipt...
+		assert_noop!(Nis::thaw_private(signed(1), 0, None), Error::<Test>::NotOwner);
+
+		// ...and thawing is possible.
+		assert_ok!(Nis::thaw_private(signed(2), 0, None));
+
+		assert_eq!(Balances::total_balance(&2), 140);
+		assert_eq!(Balances::total_balance(&1), 60);
+	});
+}
+
+#[test]
+fn communify_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		enlarge(40, 1);
+		run_to_block(4);
+
+		assert_eq!(Nis::owner(&0), Some(1));
+		assert_eq!(Balances::reserved_balance(&1), 40);
+		assert_eq!(pot(), 0);
+		assert_eq!(NisBalances::free_balance(&1), 0);
+		assert_ok!(Nis::communify(signed(1), 0));
+		assert_eq!(Nis::owner(&0), None);
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert_eq!(pot(), 40);
+		// We now have fungibles.
+		assert_eq!(NisBalances::free_balance(&1), 2_100_000);
+
+		// Can't transfer the NFT or thaw it as a private.
+		assert_noop!(Nis::thaw_private(signed(1), 0, None), Error::<Test>::AlreadyCommunal);
+		assert_noop!(Nis::transfer(&0, &2), Error::<Test>::AlreadyCommunal);
+		// Communal thawing would be possible, except it's the wrong receipt.
+		assert_noop!(Nis::thaw_communal(signed(1), 1), Error::<Test>::UnknownReceipt);
+
+		// Transfer some of the fungibles away.
+		assert_ok!(NisBalances::transfer_allow_death(signed(1), 2, 100_000));
+		assert_eq!(NisBalances::free_balance(&1), 2_000_000);
+		assert_eq!(NisBalances::free_balance(&2), 100_000);
+
+		// Communal thawing with the correct index is not possible now.
+		assert_noop!(Nis::thaw_communal(signed(1), 0), TokenError::FundsUnavailable);
+		assert_noop!(Nis::thaw_communal(signed(2), 0), TokenError::FundsUnavailable);
+
+		// Transfer the rest to 2...
+		assert_ok!(NisBalances::transfer_allow_death(signed(1), 2, 2_000_000));
+		assert_eq!(NisBalances::free_balance(&1), 0);
+		assert_eq!(NisBalances::free_balance(&2), 2_100_000);
+
+		// ...and thawing becomes possible.
+		assert_ok!(Nis::thaw_communal(signed(2), 0));
+		assert_eq!(NisBalances::free_balance(&1), 0);
+		assert_eq!(NisBalances::free_balance(&2), 0);
+		assert_eq!(pot(), 0);
+		assert_eq!(Balances::total_balance(&1), 60);
+		assert_eq!(Balances::total_balance(&2), 140);
+
+		assert_noop!(Nis::thaw_communal(signed(2), 0), Error::<Test>::UnknownReceipt);
+	});
+}
+
+#[test]
+fn privatize_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		enlarge(40, 1);
+		run_to_block(4);
+		assert_noop!(Nis::privatize(signed(2), 0), Error::<Test>::AlreadyPrivate);
+		assert_ok!(Nis::communify(signed(1), 0));
+
+		// Transfer the fungibles to #2
+		assert_ok!(NisBalances::transfer_allow_death(signed(1), 2, 2_100_000));
+		assert_noop!(Nis::privatize(signed(1), 0), TokenError::FundsUnavailable);
+
+		// Privatize
+		assert_ok!(Nis::privatize(signed(2), 0));
+		assert_noop!(Nis::privatize(signed(2), 0), Error::<Test>::AlreadyPrivate);
+		assert_eq!(NisBalances::free_balance(&2), 0);
+		assert_eq!(Nis::owner(&0), Some(2));
+		assert_eq!(Balances::reserved_balance(&2), 40);
+		assert_eq!(pot(), 0);
+	});
+}
+
+#[test]
+fn privatize_and_thaw_with_another_receipt_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		assert_ok!(Nis::place_bid(signed(2), 40, 1));
+		enlarge(80, 2);
+		run_to_block(4);
+
+		assert_ok!(Nis::communify(signed(1), 0));
+		assert_ok!(Nis::communify(signed(2), 1));
+
+		// Transfer half of fungibles to #3 from each of #1 and #2, and the other half from #2 to #4
+		assert_ok!(NisBalances::transfer_allow_death(signed(1), 3, 1_050_000));
+		assert_ok!(NisBalances::transfer_allow_death(signed(2), 3, 1_050_000));
+		assert_ok!(NisBalances::transfer_allow_death(signed(2), 4, 1_050_000));
+
+		// #3 privatizes, partially thaws, then re-communifies with #0, then transfers the fungibles
+		// to #2
+		assert_ok!(Nis::privatize(signed(3), 0));
+		assert_ok!(Nis::thaw_private(signed(3), 0, Some(Perquintill::from_percent(5))));
+		assert_ok!(Nis::communify(signed(3), 0));
+		assert_ok!(NisBalances::transfer_allow_death(signed(3), 1, 1_050_000));
+
+		// #1 now has enough to thaw using receipt 1
+		assert_ok!(Nis::thaw_communal(signed(1), 1));
+
+		// #4 now has enough to thaw using receipt 0
+		assert_ok!(Nis::thaw_communal(signed(4), 0));
+	});
+}
+
+#[test]
+fn communal_thaw_when_issuance_higher_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Balances::transfer_allow_death(signed(2), 1, 1));
+		assert_ok!(Nis::place_bid(signed(1), 100, 1));
+		enlarge(100, 1);
+		assert_eq!(Balances::total_balance(&1), 101);
+
+		assert_ok!(Nis::communify(signed(1), 0));
+		assert_eq!(Balances::total_balance_on_hold(&1), 0);
+		assert_eq!(Balances::total_balance(&1), 1);
+
+		assert_eq!(NisBalances::free_balance(1), 5_250_000); // (12.5% of 21m)
+
+		// Everybody else's balances goes up by 50%
+		assert_ok!(Balances::mint_into(&2, 50));
+		assert_ok!(Balances::mint_into(&3, 50));
+		assert_ok!(Balances::mint_into(&4, 50));
+
+		run_to_block(4);
+
+		// Unfunded initially...
+		assert_noop!(Nis::thaw_communal(signed(1), 0), Error::<Test>::Unfunded);
+		// ...so we fund.
+		assert_ok!(Nis::fund_deficit(signed(1)));
+
+		// Transfer counterparts away...
+		assert_ok!(NisBalances::transfer_allow_death(signed(1), 2, 125_000));
+		// ...and it's not thawable.
+		assert_noop!(Nis::thaw_communal(signed(1), 0), TokenError::FundsUnavailable);
+
+		// Transfer counterparts back...
+		assert_ok!(NisBalances::transfer_allow_death(signed(2), 1, 125_000));
+		// ...and it is.
+		assert_ok!(Nis::thaw_communal(signed(1), 0));
+		assert_eq!(Balances::total_balance(&1), 151);
+
+		assert_ok!(Balances::transfer_allow_death(signed(1), 2, 1));
+		assert_eq!(Balances::total_balance(&1), 150);
+		assert_eq!(Balances::free_balance(1), 150);
+		assert_eq!(Balances::total_balance_on_hold(&1), 0);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn private_thaw_when_issuance_higher_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Balances::transfer_allow_death(signed(2), 1, 1));
+		assert_ok!(Nis::place_bid(signed(1), 100, 1));
+		enlarge(100, 1);
+
+		// Everybody else's balances goes up by 50%
+		assert_ok!(Balances::mint_into(&2, 50));
+		assert_ok!(Balances::mint_into(&3, 50));
+		assert_ok!(Balances::mint_into(&4, 50));
+
+		run_to_block(4);
+
+		// Unfunded initially...
+		assert_noop!(Nis::thaw_private(signed(1), 0, None), Error::<Test>::Unfunded);
+		// ...so we fund.
+		assert_ok!(Nis::fund_deficit(signed(1)));
+
+		assert_ok!(Nis::thaw_private(signed(1), 0, None));
+
+		assert_ok!(Balances::transfer_allow_death(signed(1), 2, 1));
+		assert_eq!(Balances::free_balance(1), 150);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn thaw_with_ignored_issuance_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		// Give account zero some balance.
+		assert_ok!(Balances::mint_into(&0, 200));
+
+		assert_ok!(Balances::transfer_allow_death(signed(2), 1, 1));
+		assert_ok!(Nis::place_bid(signed(1), 100, 1));
+		enlarge(100, 1);
+
+		// Account zero transfers 50 into everyone else's accounts.
+		assert_ok!(Balances::transfer_allow_death(signed(0), 2, 50));
+		assert_ok!(Balances::transfer_allow_death(signed(0), 3, 50));
+		assert_ok!(Balances::transfer_allow_death(signed(0), 4, 50));
+
+		run_to_block(4);
+		// Unfunded initially...
+		assert_noop!(Nis::thaw_private(signed(1), 0, None), Error::<Test>::Unfunded);
+		// ...so we fund...
+		assert_ok!(Nis::fund_deficit(signed(1)));
+		// ...and then it's ok.
+		assert_ok!(Nis::thaw_private(signed(1), 0, None));
+
+		// Account zero changes have been ignored.
+		assert_ok!(Balances::transfer_allow_death(signed(1), 2, 1));
+		assert_eq!(Balances::free_balance(1), 150);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn thaw_when_issuance_lower_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Balances::transfer_allow_death(signed(2), 1, 1));
+		assert_ok!(Nis::place_bid(signed(1), 100, 1));
+		enlarge(100, 1);
+
+		// Everybody else's balances goes down by 25%
+		assert_ok!(Balances::burn_from(&2, 25, Exact, Force));
+		assert_ok!(Balances::burn_from(&3, 25, Exact, Force));
+		assert_ok!(Balances::burn_from(&4, 25, Exact, Force));
+
+		run_to_block(4);
+		assert_ok!(Nis::thaw_private(signed(1), 0, None));
+
+		assert_ok!(Balances::transfer_allow_death(signed(1), 2, 1));
+		assert_eq!(Balances::free_balance(1), 75);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn multiple_thaws_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Balances::transfer_allow_death(signed(3), 1, 1));
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		assert_ok!(Nis::place_bid(signed(1), 60, 1));
+		assert_ok!(Nis::place_bid(signed(2), 50, 1));
+		enlarge(200, 3);
+
+		// Double everyone's free balances.
+		assert_ok!(Balances::mint_into(&2, 50));
+		assert_ok!(Balances::mint_into(&3, 100));
+		assert_ok!(Balances::mint_into(&4, 100));
+		assert_ok!(Nis::fund_deficit(signed(1)));
+
+		run_to_block(4);
+		assert_ok!(Nis::thaw_private(signed(1), 0, None));
+		assert_ok!(Nis::thaw_private(signed(1), 1, None));
+		assert_noop!(Nis::thaw_private(signed(2), 2, None), Error::<Test>::Throttled);
+		run_to_block(5);
+		assert_ok!(Nis::thaw_private(signed(2), 2, None));
+
+		assert_ok!(Balances::transfer_allow_death(signed(1), 3, 1));
+		assert_eq!(Balances::free_balance(1), 200);
+		assert_eq!(Balances::free_balance(2), 200);
+		assert_eq!(Balances::total_balance(&1), 200);
+		assert_eq!(Balances::total_balance(&2), 200);
+	});
+}
+
+#[test]
+fn multiple_thaws_works_in_alternative_thaw_order() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1);
+		assert_ok!(Balances::transfer_allow_death(signed(3), 1, 1));
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		assert_ok!(Nis::place_bid(signed(1), 60, 1));
+		assert_ok!(Nis::place_bid(signed(2), 50, 1));
+		enlarge(200, 3);
+
+		// Double everyone's free balances.
+		assert_ok!(Balances::mint_into(&2, 50));
+		assert_ok!(Balances::mint_into(&3, 100));
+		assert_ok!(Balances::mint_into(&4, 100));
+		assert_ok!(Nis::fund_deficit(signed(1)));
+
+		run_to_block(4);
+		assert_ok!(Nis::thaw_private(signed(2), 2, None));
+		assert_noop!(Nis::thaw_private(signed(1), 1, None), Error::<Test>::Throttled);
+		assert_ok!(Nis::thaw_private(signed(1), 0, None));
+
+		run_to_block(5);
+		assert_ok!(Nis::thaw_private(signed(1), 1, None));
+
+		assert_ok!(Balances::transfer_allow_death(signed(1), 3, 1));
+		assert_eq!(Balances::free_balance(1), 200);
+		assert_eq!(Balances::free_balance(2), 200);
+		assert_eq!(Balances::total_balance(&1), 200);
+		assert_eq!(Balances::total_balance(&2), 200);
+	});
+}
+
+#[test]
+fn enlargement_to_target_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(2);
+		let w = <() as WeightInfo>::process_queues() +
+			<() as WeightInfo>::process_queue() +
+			(<() as WeightInfo>::process_bid() * 2);
+		super::mock::MaxIntakeWeight::set(w);
+		assert_ok!(Nis::place_bid(signed(1), 40, 1));
+		assert_ok!(Nis::place_bid(signed(1), 40, 2));
+		assert_ok!(Nis::place_bid(signed(2), 40, 2));
+		assert_ok!(Nis::place_bid(signed(2), 40, 3));
+		assert_ok!(Nis::place_bid(signed(3), 40, 3));
+		Target::set(Perquintill::from_percent(40));
+
+		run_to_block(3);
+		assert_eq!(Queues::<Test>::get(1), vec![Bid { amount: 40, who: 1 },]);
+		assert_eq!(
+			Queues::<Test>::get(2),
+			vec![Bid { amount: 40, who: 2 }, Bid { amount: 40, who: 1 },]
+		);
+		assert_eq!(
+			Queues::<Test>::get(3),
+			vec![Bid { amount: 40, who: 3 }, Bid { amount: 40, who: 2 },]
+		);
+		assert_eq!(QueueTotals::<Test>::get(), vec![(1, 40), (2, 80), (2, 80)]);
+
+		run_to_block(4);
+		// Two new items should have been issued to 2 & 3 for 40 each & duration of 3.
+		assert_eq!(
+			Receipts::<Test>::get(0).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((2, 40)),
+				expiry: 13
+			}
+		);
+		assert_eq!(
+			Receipts::<Test>::get(1).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((3, 40)),
+				expiry: 13
+			}
+		);
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(20),
+				index: 2,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 80,
+			}
+		);
+
+		run_to_block(5);
+		// No change
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(20),
+				index: 2,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 80,
+			}
+		);
+
+		run_to_block(6);
+		// Two new items should have been issued to 1 & 2 for 40 each & duration of 2.
+		assert_eq!(
+			Receipts::<Test>::get(2).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((1, 40)),
+				expiry: 12
+			}
+		);
+		assert_eq!(
+			Receipts::<Test>::get(3).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((2, 40)),
+				expiry: 12
+			}
+		);
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(40),
+				index: 4,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 160,
+			}
+		);
+
+		run_to_block(8);
+		// No change now.
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(40),
+				index: 4,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 160,
+			}
+		);
+
+		// Set target a bit higher to use up the remaining bid.
+		Target::set(Perquintill::from_percent(60));
+		run_to_block(10);
+
+		// One new item should have been issued to 1 for 40 each & duration of 2.
+		assert_eq!(
+			Receipts::<Test>::get(4).unwrap(),
+			ReceiptRecord {
+				proportion: Perquintill::from_percent(10),
+				owner: Some((1, 40)),
+				expiry: 13
+			}
+		);
+
+		assert_eq!(
+			Summary::<Test>::get(),
+			SummaryRecord {
+				proportion_owed: Perquintill::from_percent(50),
+				index: 5,
+				last_period: 0,
+				thawed: Perquintill::zero(),
+				receipts_on_hold: 200,
+			}
+		);
+	});
+}
diff --git a/substrate/frame/nis/src/weights.rs b/substrate/frame/nis/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cba2f0049055b8f3e69aeba7d7d572ba19030801
--- /dev/null
+++ b/substrate/frame/nis/src/weights.rs
@@ -0,0 +1,431 @@
+// 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.
+
+//! Autogenerated weights for pallet_nis
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_nis
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/nis/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_nis.
+pub trait WeightInfo {
+	fn place_bid(l: u32, ) -> Weight;
+	fn place_bid_max() -> Weight;
+	fn retract_bid(l: u32, ) -> Weight;
+	fn fund_deficit() -> Weight;
+	fn communify() -> Weight;
+	fn privatize() -> Weight;
+	fn thaw_private() -> Weight;
+	fn thaw_communal() -> Weight;
+	fn process_queues() -> Weight;
+	fn process_queue() -> Weight;
+	fn process_bid() -> Weight;
+}
+
+/// Weights for pallet_nis using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 999]`.
+	fn place_bid(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6176 + l * (48 ±0)`
+		//  Estimated: `51487`
+		// Minimum execution time: 49_410_000 picoseconds.
+		Weight::from_parts(57_832_282, 51487)
+			// Standard Error: 288
+			.saturating_add(Weight::from_parts(51_621, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	fn place_bid_max() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `54178`
+		//  Estimated: `51487`
+		// Minimum execution time: 119_696_000 picoseconds.
+		Weight::from_parts(121_838_000, 51487)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	/// The range of component `l` is `[1, 1000]`.
+	fn retract_bid(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6176 + l * (48 ±0)`
+		//  Estimated: `51487`
+		// Minimum execution time: 50_843_000 picoseconds.
+		Weight::from_parts(54_237_365, 51487)
+			// Standard Error: 243
+			.saturating_add(Weight::from_parts(67_732, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Summary (r:1 w:0)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn fund_deficit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `191`
+		//  Estimated: `3593`
+		// Minimum execution time: 40_752_000 picoseconds.
+		Weight::from_parts(41_899_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, 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)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn communify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `668`
+		//  Estimated: `3675`
+		// Minimum execution time: 79_779_000 picoseconds.
+		Weight::from_parts(82_478_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	fn privatize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829`
+		//  Estimated: `3675`
+		// Minimum execution time: 99_588_000 picoseconds.
+		Weight::from_parts(102_340_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	fn thaw_private() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `354`
+		//  Estimated: `3593`
+		// Minimum execution time: 53_094_000 picoseconds.
+		Weight::from_parts(54_543_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn thaw_communal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `773`
+		//  Estimated: `3675`
+		// Minimum execution time: 107_248_000 picoseconds.
+		Weight::from_parts(109_923_000, 3675)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	fn process_queues() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6624`
+		//  Estimated: `7487`
+		// Minimum execution time: 27_169_000 picoseconds.
+		Weight::from_parts(29_201_000, 7487)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	fn process_queue() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `42`
+		//  Estimated: `51487`
+		// Minimum execution time: 4_540_000 picoseconds.
+		Weight::from_parts(4_699_000, 51487)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nis Receipts (r:0 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	fn process_bid() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_085_000 picoseconds.
+		Weight::from_parts(7_336_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 999]`.
+	fn place_bid(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6176 + l * (48 ±0)`
+		//  Estimated: `51487`
+		// Minimum execution time: 49_410_000 picoseconds.
+		Weight::from_parts(57_832_282, 51487)
+			// Standard Error: 288
+			.saturating_add(Weight::from_parts(51_621, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	fn place_bid_max() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `54178`
+		//  Estimated: `51487`
+		// Minimum execution time: 119_696_000 picoseconds.
+		Weight::from_parts(121_838_000, 51487)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	/// The range of component `l` is `[1, 1000]`.
+	fn retract_bid(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6176 + l * (48 ±0)`
+		//  Estimated: `51487`
+		// Minimum execution time: 50_843_000 picoseconds.
+		Weight::from_parts(54_237_365, 51487)
+			// Standard Error: 243
+			.saturating_add(Weight::from_parts(67_732, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Summary (r:1 w:0)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn fund_deficit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `191`
+		//  Estimated: `3593`
+		// Minimum execution time: 40_752_000 picoseconds.
+		Weight::from_parts(41_899_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, 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)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	fn communify() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `668`
+		//  Estimated: `3675`
+		// Minimum execution time: 79_779_000 picoseconds.
+		Weight::from_parts(82_478_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	fn privatize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `829`
+		//  Estimated: `3675`
+		// Minimum execution time: 99_588_000 picoseconds.
+		Weight::from_parts(102_340_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Balances Holds (r:1 w:1)
+	/// Proof: Balances Holds (max_values: None, max_size: Some(85), added: 2560, mode: MaxEncodedLen)
+	fn thaw_private() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `354`
+		//  Estimated: `3593`
+		// Minimum execution time: 53_094_000 picoseconds.
+		Weight::from_parts(54_543_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Nis Receipts (r:1 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:1 w:1)
+	/// Proof: Assets Account (max_values: None, max_size: Some(134), added: 2609, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn thaw_communal() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `773`
+		//  Estimated: `3675`
+		// Minimum execution time: 107_248_000 picoseconds.
+		Weight::from_parts(109_923_000, 3675)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Nis Summary (r:1 w:1)
+	/// Proof: Nis Summary (max_values: Some(1), max_size: Some(40), added: 535, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Nis QueueTotals (r:1 w:1)
+	/// Proof: Nis QueueTotals (max_values: Some(1), max_size: Some(6002), added: 6497, mode: MaxEncodedLen)
+	fn process_queues() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `6624`
+		//  Estimated: `7487`
+		// Minimum execution time: 27_169_000 picoseconds.
+		Weight::from_parts(29_201_000, 7487)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Nis Queues (r:1 w:1)
+	/// Proof: Nis Queues (max_values: None, max_size: Some(48022), added: 50497, mode: MaxEncodedLen)
+	fn process_queue() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `42`
+		//  Estimated: `51487`
+		// Minimum execution time: 4_540_000 picoseconds.
+		Weight::from_parts(4_699_000, 51487)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Nis Receipts (r:0 w:1)
+	/// Proof: Nis Receipts (max_values: None, max_size: Some(81), added: 2556, mode: MaxEncodedLen)
+	fn process_bid() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_085_000 picoseconds.
+		Weight::from_parts(7_336_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/node-authorization/Cargo.toml b/substrate/frame/node-authorization/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b801d736498c3f369a10b1c1245c311c47a881c1
--- /dev/null
+++ b/substrate/frame/node-authorization/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "pallet-node-authorization"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for node authorization"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/node-authorization/src/lib.rs b/substrate/frame/node-authorization/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8a823d29f2355bc6b3cbf4fe8e25906448f2888b
--- /dev/null
+++ b/substrate/frame/node-authorization/src/lib.rs
@@ -0,0 +1,467 @@
+// 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.
+
+//! # Node authorization pallet
+//!
+//! This pallet manages a configurable set of nodes for a permissioned network.
+//! Each node is dentified by a PeerId (i.e. `Vec<u8>`). It provides two ways to
+//! authorize a node,
+//!
+//! - a set of well known nodes across different organizations in which the
+//! connections are allowed.
+//! - users can claim the ownership for each node, then manage the connections of
+//! the node.
+//!
+//! A node must have an owner. The owner can additionally change the connections
+//! for the node. Only one user is allowed to claim a specific node. To eliminate
+//! false claim, the maintainer of the node should claim it before even starting the
+//! node. This pallet uses offchain worker to set reserved nodes, if the node is not
+//! an authority, make sure to enable offchain worker with the right CLI flag. The
+//! node can be lagged with the latest block, in this case you need to disable offchain
+//! worker and manually set reserved nodes when starting it.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+pub mod weights;
+
+pub use pallet::*;
+use sp_core::OpaquePeerId as PeerId;
+use sp_runtime::traits::StaticLookup;
+use sp_std::{collections::btree_set::BTreeSet, iter::FromIterator, prelude::*};
+pub use weights::WeightInfo;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(_);
+
+	/// The module configuration trait
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The maximum number of well known nodes that are allowed to set
+		#[pallet::constant]
+		type MaxWellKnownNodes: Get<u32>;
+
+		/// The maximum length in bytes of PeerId
+		#[pallet::constant]
+		type MaxPeerIdLength: Get<u32>;
+
+		/// The origin which can add a well known node.
+		type AddOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin which can remove a well known node.
+		type RemoveOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin which can swap the well known nodes.
+		type SwapOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The origin which can reset the well known nodes.
+		type ResetOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// The set of well known nodes. This is stored sorted (just by value).
+	#[pallet::storage]
+	#[pallet::getter(fn well_known_nodes)]
+	pub type WellKnownNodes<T> = StorageValue<_, BTreeSet<PeerId>, ValueQuery>;
+
+	/// A map that maintains the ownership of each node.
+	#[pallet::storage]
+	#[pallet::getter(fn owners)]
+	pub type Owners<T: Config> = StorageMap<_, Blake2_128Concat, PeerId, T::AccountId>;
+
+	/// The additional adapative connections of each node.
+	#[pallet::storage]
+	#[pallet::getter(fn additional_connection)]
+	pub type AdditionalConnections<T> =
+		StorageMap<_, Blake2_128Concat, PeerId, BTreeSet<PeerId>, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub nodes: Vec<(PeerId, T::AccountId)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			Pallet::<T>::initialize_nodes(&self.nodes);
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// The given well known node was added.
+		NodeAdded { peer_id: PeerId, who: T::AccountId },
+		/// The given well known node was removed.
+		NodeRemoved { peer_id: PeerId },
+		/// The given well known node was swapped; first item was removed,
+		/// the latter was added.
+		NodeSwapped { removed: PeerId, added: PeerId },
+		/// The given well known nodes were reset.
+		NodesReset { nodes: Vec<(PeerId, T::AccountId)> },
+		/// The given node was claimed by a user.
+		NodeClaimed { peer_id: PeerId, who: T::AccountId },
+		/// The given claim was removed by its owner.
+		ClaimRemoved { peer_id: PeerId, who: T::AccountId },
+		/// The node was transferred to another account.
+		NodeTransferred { peer_id: PeerId, target: T::AccountId },
+		/// The allowed connections were added to a node.
+		ConnectionsAdded { peer_id: PeerId, allowed_connections: Vec<PeerId> },
+		/// The allowed connections were removed from a node.
+		ConnectionsRemoved { peer_id: PeerId, allowed_connections: Vec<PeerId> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The PeerId is too long.
+		PeerIdTooLong,
+		/// Too many well known nodes.
+		TooManyNodes,
+		/// The node is already joined in the list.
+		AlreadyJoined,
+		/// The node doesn't exist in the list.
+		NotExist,
+		/// The node is already claimed by a user.
+		AlreadyClaimed,
+		/// The node hasn't been claimed yet.
+		NotClaimed,
+		/// You are not the owner of the node.
+		NotOwner,
+		/// No permisson to perform specific operation.
+		PermissionDenied,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// Set reserved node every block. It may not be enabled depends on the offchain
+		/// worker settings when starting the node.
+		fn offchain_worker(now: frame_system::pallet_prelude::BlockNumberFor<T>) {
+			let network_state = sp_io::offchain::network_state();
+			match network_state {
+				Err(_) => log::error!(
+					target: "runtime::node-authorization",
+					"Error: failed to get network state of node at {:?}",
+					now,
+				),
+				Ok(state) => {
+					let encoded_peer = state.peer_id.0;
+					match Decode::decode(&mut &encoded_peer[..]) {
+						Err(_) => log::error!(
+							target: "runtime::node-authorization",
+							"Error: failed to decode PeerId at {:?}",
+							now,
+						),
+						Ok(node) => sp_io::offchain::set_authorized_nodes(
+							Self::get_authorized_nodes(&PeerId(node)),
+							true,
+						),
+					}
+				},
+			}
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Add a node to the set of well known nodes. If the node is already claimed, the owner
+		/// will be updated and keep the existing additional connection unchanged.
+		///
+		/// May only be called from `T::AddOrigin`.
+		///
+		/// - `node`: identifier of the node.
+		#[pallet::call_index(0)]
+		#[pallet::weight((T::WeightInfo::add_well_known_node(), DispatchClass::Operational))]
+		pub fn add_well_known_node(
+			origin: OriginFor<T>,
+			node: PeerId,
+			owner: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			T::AddOrigin::ensure_origin(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+
+			let mut nodes = WellKnownNodes::<T>::get();
+			ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
+			ensure!(!nodes.contains(&node), Error::<T>::AlreadyJoined);
+
+			nodes.insert(node.clone());
+
+			WellKnownNodes::<T>::put(&nodes);
+			<Owners<T>>::insert(&node, &owner);
+
+			Self::deposit_event(Event::NodeAdded { peer_id: node, who: owner });
+			Ok(())
+		}
+
+		/// Remove a node from the set of well known nodes. The ownership and additional
+		/// connections of the node will also be removed.
+		///
+		/// May only be called from `T::RemoveOrigin`.
+		///
+		/// - `node`: identifier of the node.
+		#[pallet::call_index(1)]
+		#[pallet::weight((T::WeightInfo::remove_well_known_node(), DispatchClass::Operational))]
+		pub fn remove_well_known_node(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
+			T::RemoveOrigin::ensure_origin(origin)?;
+			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+
+			let mut nodes = WellKnownNodes::<T>::get();
+			ensure!(nodes.contains(&node), Error::<T>::NotExist);
+
+			nodes.remove(&node);
+
+			WellKnownNodes::<T>::put(&nodes);
+			<Owners<T>>::remove(&node);
+			AdditionalConnections::<T>::remove(&node);
+
+			Self::deposit_event(Event::NodeRemoved { peer_id: node });
+			Ok(())
+		}
+
+		/// Swap a well known node to another. Both the ownership and additional connections
+		/// stay untouched.
+		///
+		/// May only be called from `T::SwapOrigin`.
+		///
+		/// - `remove`: the node which will be moved out from the list.
+		/// - `add`: the node which will be put in the list.
+		#[pallet::call_index(2)]
+		#[pallet::weight((T::WeightInfo::swap_well_known_node(), DispatchClass::Operational))]
+		pub fn swap_well_known_node(
+			origin: OriginFor<T>,
+			remove: PeerId,
+			add: PeerId,
+		) -> DispatchResult {
+			T::SwapOrigin::ensure_origin(origin)?;
+			ensure!(remove.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+			ensure!(add.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+
+			if remove == add {
+				return Ok(())
+			}
+
+			let mut nodes = WellKnownNodes::<T>::get();
+			ensure!(nodes.contains(&remove), Error::<T>::NotExist);
+			ensure!(!nodes.contains(&add), Error::<T>::AlreadyJoined);
+
+			nodes.remove(&remove);
+			nodes.insert(add.clone());
+
+			WellKnownNodes::<T>::put(&nodes);
+			Owners::<T>::swap(&remove, &add);
+			AdditionalConnections::<T>::swap(&remove, &add);
+
+			Self::deposit_event(Event::NodeSwapped { removed: remove, added: add });
+			Ok(())
+		}
+
+		/// Reset all the well known nodes. This will not remove the ownership and additional
+		/// connections for the removed nodes. The node owner can perform further cleaning if
+		/// they decide to leave the network.
+		///
+		/// May only be called from `T::ResetOrigin`.
+		///
+		/// - `nodes`: the new nodes for the allow list.
+		#[pallet::call_index(3)]
+		#[pallet::weight((T::WeightInfo::reset_well_known_nodes(), DispatchClass::Operational))]
+		pub fn reset_well_known_nodes(
+			origin: OriginFor<T>,
+			nodes: Vec<(PeerId, T::AccountId)>,
+		) -> DispatchResult {
+			T::ResetOrigin::ensure_origin(origin)?;
+			ensure!(nodes.len() < T::MaxWellKnownNodes::get() as usize, Error::<T>::TooManyNodes);
+
+			Self::initialize_nodes(&nodes);
+
+			Self::deposit_event(Event::NodesReset { nodes });
+			Ok(())
+		}
+
+		/// A given node can be claimed by anyone. The owner should be the first to know its
+		/// PeerId, so claim it right away!
+		///
+		/// - `node`: identifier of the node.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::claim_node())]
+		pub fn claim_node(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+			ensure!(!Owners::<T>::contains_key(&node), Error::<T>::AlreadyClaimed);
+
+			Owners::<T>::insert(&node, &sender);
+			Self::deposit_event(Event::NodeClaimed { peer_id: node, who: sender });
+			Ok(())
+		}
+
+		/// A claim can be removed by its owner and get back the reservation. The additional
+		/// connections are also removed. You can't remove a claim on well known nodes, as it
+		/// needs to reach consensus among the network participants.
+		///
+		/// - `node`: identifier of the node.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::remove_claim())]
+		pub fn remove_claim(origin: OriginFor<T>, node: PeerId) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+			let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
+			ensure!(owner == sender, Error::<T>::NotOwner);
+			ensure!(!WellKnownNodes::<T>::get().contains(&node), Error::<T>::PermissionDenied);
+
+			Owners::<T>::remove(&node);
+			AdditionalConnections::<T>::remove(&node);
+
+			Self::deposit_event(Event::ClaimRemoved { peer_id: node, who: sender });
+			Ok(())
+		}
+
+		/// A node can be transferred to a new owner.
+		///
+		/// - `node`: identifier of the node.
+		/// - `owner`: new owner of the node.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::transfer_node())]
+		pub fn transfer_node(
+			origin: OriginFor<T>,
+			node: PeerId,
+			owner: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+
+			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+			let pre_owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
+			ensure!(pre_owner == sender, Error::<T>::NotOwner);
+
+			Owners::<T>::insert(&node, &owner);
+
+			Self::deposit_event(Event::NodeTransferred { peer_id: node, target: owner });
+			Ok(())
+		}
+
+		/// Add additional connections to a given node.
+		///
+		/// - `node`: identifier of the node.
+		/// - `connections`: additonal nodes from which the connections are allowed.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::add_connections())]
+		pub fn add_connections(
+			origin: OriginFor<T>,
+			node: PeerId,
+			connections: Vec<PeerId>,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+			let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
+			ensure!(owner == sender, Error::<T>::NotOwner);
+
+			let mut nodes = AdditionalConnections::<T>::get(&node);
+
+			for add_node in connections.iter() {
+				if *add_node == node {
+					continue
+				}
+				nodes.insert(add_node.clone());
+			}
+
+			AdditionalConnections::<T>::insert(&node, nodes);
+
+			Self::deposit_event(Event::ConnectionsAdded {
+				peer_id: node,
+				allowed_connections: connections,
+			});
+			Ok(())
+		}
+
+		/// Remove additional connections of a given node.
+		///
+		/// - `node`: identifier of the node.
+		/// - `connections`: additonal nodes from which the connections are not allowed anymore.
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::remove_connections())]
+		pub fn remove_connections(
+			origin: OriginFor<T>,
+			node: PeerId,
+			connections: Vec<PeerId>,
+		) -> DispatchResult {
+			let sender = ensure_signed(origin)?;
+
+			ensure!(node.0.len() < T::MaxPeerIdLength::get() as usize, Error::<T>::PeerIdTooLong);
+			let owner = Owners::<T>::get(&node).ok_or(Error::<T>::NotClaimed)?;
+			ensure!(owner == sender, Error::<T>::NotOwner);
+
+			let mut nodes = AdditionalConnections::<T>::get(&node);
+
+			for remove_node in connections.iter() {
+				nodes.remove(remove_node);
+			}
+
+			AdditionalConnections::<T>::insert(&node, nodes);
+
+			Self::deposit_event(Event::ConnectionsRemoved {
+				peer_id: node,
+				allowed_connections: connections,
+			});
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	fn initialize_nodes(nodes: &Vec<(PeerId, T::AccountId)>) {
+		let peer_ids = nodes.iter().map(|item| item.0.clone()).collect::<BTreeSet<PeerId>>();
+		WellKnownNodes::<T>::put(&peer_ids);
+
+		for (node, who) in nodes.iter() {
+			Owners::<T>::insert(node, who);
+		}
+	}
+
+	fn get_authorized_nodes(node: &PeerId) -> Vec<PeerId> {
+		let mut nodes = AdditionalConnections::<T>::get(node);
+
+		let mut well_known_nodes = WellKnownNodes::<T>::get();
+		if well_known_nodes.contains(node) {
+			well_known_nodes.remove(node);
+			nodes.extend(well_known_nodes);
+		}
+
+		Vec::from_iter(nodes)
+	}
+}
diff --git a/substrate/frame/node-authorization/src/mock.rs b/substrate/frame/node-authorization/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..84e3336b3bd68b2e60ba15e9df06f48b8f299e98
--- /dev/null
+++ b/substrate/frame/node-authorization/src/mock.rs
@@ -0,0 +1,102 @@
+// 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.
+
+//! Test environment for node-authorization pallet.
+
+use super::*;
+use crate as pallet_node_authorization;
+
+use frame_support::{
+	ord_parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use frame_system::EnsureSignedBy;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		NodeAuthorization: pallet_node_authorization::{
+			Pallet, Call, Storage, Config<T>, Event<T>,
+		},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type DbWeight = ();
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	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>;
+}
+
+ord_parameter_types! {
+	pub const One: u64 = 1;
+	pub const Two: u64 = 2;
+	pub const Three: u64 = 3;
+	pub const Four: u64 = 4;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type MaxWellKnownNodes = ConstU32<4>;
+	type MaxPeerIdLength = ConstU32<2>;
+	type AddOrigin = EnsureSignedBy<One, u64>;
+	type RemoveOrigin = EnsureSignedBy<Two, u64>;
+	type SwapOrigin = EnsureSignedBy<Three, u64>;
+	type ResetOrigin = EnsureSignedBy<Four, u64>;
+	type WeightInfo = ();
+}
+
+pub fn test_node(id: u8) -> PeerId {
+	PeerId(vec![id])
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_node_authorization::GenesisConfig::<Test> {
+		nodes: vec![(test_node(10), 10), (test_node(20), 20), (test_node(30), 30)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
diff --git a/substrate/frame/node-authorization/src/tests.rs b/substrate/frame/node-authorization/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4704b5adf2690f842480eb86356ee9c77437b010
--- /dev/null
+++ b/substrate/frame/node-authorization/src/tests.rs
@@ -0,0 +1,392 @@
+// 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 node-authorization pallet.
+
+use super::*;
+use crate::mock::*;
+use frame_support::{assert_noop, assert_ok};
+use sp_runtime::traits::BadOrigin;
+
+#[test]
+fn add_well_known_node_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::add_well_known_node(RuntimeOrigin::signed(2), test_node(15), 15),
+			BadOrigin
+		);
+		assert_noop!(
+			NodeAuthorization::add_well_known_node(
+				RuntimeOrigin::signed(1),
+				PeerId(vec![1, 2, 3]),
+				15
+			),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::add_well_known_node(RuntimeOrigin::signed(1), test_node(20), 20),
+			Error::<Test>::AlreadyJoined
+		);
+
+		assert_ok!(NodeAuthorization::add_well_known_node(
+			RuntimeOrigin::signed(1),
+			test_node(15),
+			15
+		));
+		assert_eq!(
+			WellKnownNodes::<Test>::get(),
+			BTreeSet::from_iter(vec![test_node(10), test_node(15), test_node(20), test_node(30)])
+		);
+		assert_eq!(Owners::<Test>::get(test_node(10)), Some(10));
+		assert_eq!(Owners::<Test>::get(test_node(20)), Some(20));
+		assert_eq!(Owners::<Test>::get(test_node(30)), Some(30));
+		assert_eq!(Owners::<Test>::get(test_node(15)), Some(15));
+
+		assert_noop!(
+			NodeAuthorization::add_well_known_node(RuntimeOrigin::signed(1), test_node(25), 25),
+			Error::<Test>::TooManyNodes
+		);
+	});
+}
+
+#[test]
+fn remove_well_known_node_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::remove_well_known_node(RuntimeOrigin::signed(3), test_node(20)),
+			BadOrigin
+		);
+		assert_noop!(
+			NodeAuthorization::remove_well_known_node(
+				RuntimeOrigin::signed(2),
+				PeerId(vec![1, 2, 3])
+			),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::remove_well_known_node(RuntimeOrigin::signed(2), test_node(40)),
+			Error::<Test>::NotExist
+		);
+
+		AdditionalConnections::<Test>::insert(
+			test_node(20),
+			BTreeSet::from_iter(vec![test_node(40)]),
+		);
+		assert!(AdditionalConnections::<Test>::contains_key(test_node(20)));
+
+		assert_ok!(NodeAuthorization::remove_well_known_node(
+			RuntimeOrigin::signed(2),
+			test_node(20)
+		));
+		assert_eq!(
+			WellKnownNodes::<Test>::get(),
+			BTreeSet::from_iter(vec![test_node(10), test_node(30)])
+		);
+		assert!(!Owners::<Test>::contains_key(test_node(20)));
+		assert!(!AdditionalConnections::<Test>::contains_key(test_node(20)));
+	});
+}
+
+#[test]
+fn swap_well_known_node_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::swap_well_known_node(
+				RuntimeOrigin::signed(4),
+				test_node(20),
+				test_node(5)
+			),
+			BadOrigin
+		);
+		assert_noop!(
+			NodeAuthorization::swap_well_known_node(
+				RuntimeOrigin::signed(3),
+				PeerId(vec![1, 2, 3]),
+				test_node(20)
+			),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::swap_well_known_node(
+				RuntimeOrigin::signed(3),
+				test_node(20),
+				PeerId(vec![1, 2, 3])
+			),
+			Error::<Test>::PeerIdTooLong
+		);
+
+		assert_ok!(NodeAuthorization::swap_well_known_node(
+			RuntimeOrigin::signed(3),
+			test_node(20),
+			test_node(20)
+		));
+		assert_eq!(
+			WellKnownNodes::<Test>::get(),
+			BTreeSet::from_iter(vec![test_node(10), test_node(20), test_node(30)])
+		);
+
+		assert_noop!(
+			NodeAuthorization::swap_well_known_node(
+				RuntimeOrigin::signed(3),
+				test_node(15),
+				test_node(5)
+			),
+			Error::<Test>::NotExist
+		);
+		assert_noop!(
+			NodeAuthorization::swap_well_known_node(
+				RuntimeOrigin::signed(3),
+				test_node(20),
+				test_node(30)
+			),
+			Error::<Test>::AlreadyJoined
+		);
+
+		AdditionalConnections::<Test>::insert(
+			test_node(20),
+			BTreeSet::from_iter(vec![test_node(15)]),
+		);
+		assert_ok!(NodeAuthorization::swap_well_known_node(
+			RuntimeOrigin::signed(3),
+			test_node(20),
+			test_node(5)
+		));
+		assert_eq!(
+			WellKnownNodes::<Test>::get(),
+			BTreeSet::from_iter(vec![test_node(5), test_node(10), test_node(30)])
+		);
+		assert!(!Owners::<Test>::contains_key(test_node(20)));
+		assert_eq!(Owners::<Test>::get(test_node(5)), Some(20));
+		assert!(!AdditionalConnections::<Test>::contains_key(test_node(20)));
+		assert_eq!(
+			AdditionalConnections::<Test>::get(test_node(5)),
+			BTreeSet::from_iter(vec![test_node(15)])
+		);
+	});
+}
+
+#[test]
+fn reset_well_known_nodes_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::reset_well_known_nodes(
+				RuntimeOrigin::signed(3),
+				vec![(test_node(15), 15), (test_node(5), 5), (test_node(20), 20)]
+			),
+			BadOrigin
+		);
+		assert_noop!(
+			NodeAuthorization::reset_well_known_nodes(
+				RuntimeOrigin::signed(4),
+				vec![
+					(test_node(15), 15),
+					(test_node(5), 5),
+					(test_node(20), 20),
+					(test_node(25), 25),
+				]
+			),
+			Error::<Test>::TooManyNodes
+		);
+
+		assert_ok!(NodeAuthorization::reset_well_known_nodes(
+			RuntimeOrigin::signed(4),
+			vec![(test_node(15), 15), (test_node(5), 5), (test_node(20), 20)]
+		));
+		assert_eq!(
+			WellKnownNodes::<Test>::get(),
+			BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(20)])
+		);
+		assert_eq!(Owners::<Test>::get(test_node(5)), Some(5));
+		assert_eq!(Owners::<Test>::get(test_node(15)), Some(15));
+		assert_eq!(Owners::<Test>::get(test_node(20)), Some(20));
+	});
+}
+
+#[test]
+fn claim_node_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::claim_node(RuntimeOrigin::signed(1), PeerId(vec![1, 2, 3])),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::claim_node(RuntimeOrigin::signed(1), test_node(20)),
+			Error::<Test>::AlreadyClaimed
+		);
+
+		assert_ok!(NodeAuthorization::claim_node(RuntimeOrigin::signed(15), test_node(15)));
+		assert_eq!(Owners::<Test>::get(test_node(15)), Some(15));
+	});
+}
+
+#[test]
+fn remove_claim_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::remove_claim(RuntimeOrigin::signed(15), PeerId(vec![1, 2, 3])),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::remove_claim(RuntimeOrigin::signed(15), test_node(15)),
+			Error::<Test>::NotClaimed
+		);
+
+		assert_noop!(
+			NodeAuthorization::remove_claim(RuntimeOrigin::signed(15), test_node(20)),
+			Error::<Test>::NotOwner
+		);
+
+		assert_noop!(
+			NodeAuthorization::remove_claim(RuntimeOrigin::signed(20), test_node(20)),
+			Error::<Test>::PermissionDenied
+		);
+
+		Owners::<Test>::insert(test_node(15), 15);
+		AdditionalConnections::<Test>::insert(
+			test_node(15),
+			BTreeSet::from_iter(vec![test_node(20)]),
+		);
+		assert_ok!(NodeAuthorization::remove_claim(RuntimeOrigin::signed(15), test_node(15)));
+		assert!(!Owners::<Test>::contains_key(test_node(15)));
+		assert!(!AdditionalConnections::<Test>::contains_key(test_node(15)));
+	});
+}
+
+#[test]
+fn transfer_node_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::transfer_node(RuntimeOrigin::signed(15), PeerId(vec![1, 2, 3]), 10),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::transfer_node(RuntimeOrigin::signed(15), test_node(15), 10),
+			Error::<Test>::NotClaimed
+		);
+
+		assert_noop!(
+			NodeAuthorization::transfer_node(RuntimeOrigin::signed(15), test_node(20), 10),
+			Error::<Test>::NotOwner
+		);
+
+		assert_ok!(NodeAuthorization::transfer_node(RuntimeOrigin::signed(20), test_node(20), 15));
+		assert_eq!(Owners::<Test>::get(test_node(20)), Some(15));
+	});
+}
+
+#[test]
+fn add_connections_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::add_connections(
+				RuntimeOrigin::signed(15),
+				PeerId(vec![1, 2, 3]),
+				vec![test_node(5)]
+			),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::add_connections(
+				RuntimeOrigin::signed(15),
+				test_node(15),
+				vec![test_node(5)]
+			),
+			Error::<Test>::NotClaimed
+		);
+
+		assert_noop!(
+			NodeAuthorization::add_connections(
+				RuntimeOrigin::signed(15),
+				test_node(20),
+				vec![test_node(5)]
+			),
+			Error::<Test>::NotOwner
+		);
+
+		assert_ok!(NodeAuthorization::add_connections(
+			RuntimeOrigin::signed(20),
+			test_node(20),
+			vec![test_node(15), test_node(5), test_node(25), test_node(20)]
+		));
+		assert_eq!(
+			AdditionalConnections::<Test>::get(test_node(20)),
+			BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(25)])
+		);
+	});
+}
+
+#[test]
+fn remove_connections_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			NodeAuthorization::remove_connections(
+				RuntimeOrigin::signed(15),
+				PeerId(vec![1, 2, 3]),
+				vec![test_node(5)]
+			),
+			Error::<Test>::PeerIdTooLong
+		);
+		assert_noop!(
+			NodeAuthorization::remove_connections(
+				RuntimeOrigin::signed(15),
+				test_node(15),
+				vec![test_node(5)]
+			),
+			Error::<Test>::NotClaimed
+		);
+
+		assert_noop!(
+			NodeAuthorization::remove_connections(
+				RuntimeOrigin::signed(15),
+				test_node(20),
+				vec![test_node(5)]
+			),
+			Error::<Test>::NotOwner
+		);
+
+		AdditionalConnections::<Test>::insert(
+			test_node(20),
+			BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(25)]),
+		);
+		assert_ok!(NodeAuthorization::remove_connections(
+			RuntimeOrigin::signed(20),
+			test_node(20),
+			vec![test_node(15), test_node(5)]
+		));
+		assert_eq!(
+			AdditionalConnections::<Test>::get(test_node(20)),
+			BTreeSet::from_iter(vec![test_node(25)])
+		);
+	});
+}
+
+#[test]
+fn get_authorized_nodes_works() {
+	new_test_ext().execute_with(|| {
+		AdditionalConnections::<Test>::insert(
+			test_node(20),
+			BTreeSet::from_iter(vec![test_node(5), test_node(15), test_node(25)]),
+		);
+
+		let mut authorized_nodes = Pallet::<Test>::get_authorized_nodes(&test_node(20));
+		authorized_nodes.sort();
+		assert_eq!(
+			authorized_nodes,
+			vec![test_node(5), test_node(10), test_node(15), test_node(25), test_node(30)]
+		);
+	});
+}
diff --git a/substrate/frame/node-authorization/src/weights.rs b/substrate/frame/node-authorization/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a4529c845c7c0e4b15a542cdaa07fc01e5279efe
--- /dev/null
+++ b/substrate/frame/node-authorization/src/weights.rs
@@ -0,0 +1,49 @@
+// 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.
+
+//! Autogenerated weights for pallet_node_authorization
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+pub trait WeightInfo {
+	fn add_well_known_node() -> Weight;
+	fn remove_well_known_node() -> Weight;
+	fn swap_well_known_node() -> Weight;
+	fn reset_well_known_nodes() -> Weight;
+	fn claim_node() -> Weight;
+	fn remove_claim() -> Weight;
+	fn transfer_node() -> Weight;
+	fn add_connections() -> Weight;
+	fn remove_connections() -> Weight;
+}
+
+impl WeightInfo for () {
+	fn add_well_known_node() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn remove_well_known_node() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn swap_well_known_node() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn reset_well_known_nodes() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn claim_node() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn remove_claim() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn transfer_node() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn add_connections() -> Weight { Weight::from_parts(50_000_000, 0) }
+	fn remove_connections() -> Weight { Weight::from_parts(50_000_000, 0) }
+}
diff --git a/substrate/frame/nomination-pools/Cargo.toml b/substrate/frame/nomination-pools/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e0158215e797aafaed7197ab57498bea7ac08e2d
--- /dev/null
+++ b/substrate/frame/nomination-pools/Cargo.toml
@@ -0,0 +1,66 @@
+[package]
+name = "pallet-nomination-pools"
+version = "1.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME nomination pools pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+# parity
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+# FRAME
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+log = { version = "0.4.0", default-features = false }
+
+# Optional: use for testing and/or fuzzing
+pallet-balances = { version = "4.0.0-dev", path = "../balances", optional = true }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing", optional = true }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+
+[features]
+default = [ "std" ]
+fuzzing = [ "pallet-balances", "sp-tracing" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances?/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+	"sp-tracing?/std",
+]
+runtime-benchmarks = [
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances?/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances?/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/nomination-pools/benchmarking/Cargo.toml b/substrate/frame/nomination-pools/benchmarking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..836f65e849fe0cd63b3c459952fcfcef05b67adb
--- /dev/null
+++ b/substrate/frame/nomination-pools/benchmarking/Cargo.toml
@@ -0,0 +1,75 @@
+[package]
+name = "pallet-nomination-pools-benchmarking"
+version = "1.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME nomination pools pallet benchmarking"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+# parity
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+# FRAME
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../benchmarking" }
+frame-election-provider-support = { version = "4.0.0-dev", default-features = false, path = "../../election-provider-support" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+pallet-bags-list = { version = "4.0.0-dev", default-features = false, path = "../../bags-list" }
+pallet-staking = { version = "4.0.0-dev", default-features = false, path = "../../staking" }
+pallet-nomination-pools = { version = "1.0.0", default-features = false, path = "../" }
+
+# Substrate Primitives
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../../../primitives/runtime-interface" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/staking" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../balances" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../../timestamp" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../../staking/reward-curve" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+
+[features]
+default = [ "std" ]
+
+std = [
+	"frame-benchmarking/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-bags-list/std",
+	"pallet-balances/std",
+	"pallet-nomination-pools/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime-interface/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-bags-list/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-nomination-pools/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
diff --git a/substrate/frame/nomination-pools/benchmarking/README.md b/substrate/frame/nomination-pools/benchmarking/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/substrate/frame/nomination-pools/benchmarking/src/lib.rs b/substrate/frame/nomination-pools/benchmarking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..45f0ca0ecfe6ef050953f484bf98a43a1f5dd2bb
--- /dev/null
+++ b/substrate/frame/nomination-pools/benchmarking/src/lib.rs
@@ -0,0 +1,808 @@
+// 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.
+
+//! Benchmarks for the nomination pools coupled with the staking and bags list pallets.
+
+#![cfg(feature = "runtime-benchmarks")]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+
+use frame_benchmarking::v1::{account, whitelist_account};
+use frame_election_provider_support::SortedListProvider;
+use frame_support::{
+	assert_ok, ensure,
+	traits::{Currency, Get},
+};
+use frame_system::RawOrigin as RuntimeOrigin;
+use pallet_nomination_pools::{
+	BalanceOf, BondExtra, BondedPoolInner, BondedPools, ClaimPermission, ClaimPermissions,
+	Commission, CommissionChangeRate, ConfigOp, GlobalMaxCommission, MaxPoolMembers,
+	MaxPoolMembersPerPool, MaxPools, Metadata, MinCreateBond, MinJoinBond, Pallet as Pools,
+	PoolMembers, PoolRoles, PoolState, RewardPools, SubPoolsStorage,
+};
+use pallet_staking::MaxNominationsOf;
+use sp_runtime::{
+	traits::{Bounded, StaticLookup, Zero},
+	Perbill,
+};
+use sp_staking::{EraIndex, StakingInterface};
+use sp_std::{vec, vec::Vec};
+// `frame_benchmarking::benchmarks!` macro needs this
+use pallet_nomination_pools::Call;
+
+type CurrencyOf<T> = <T as pallet_nomination_pools::Config>::Currency;
+
+const USER_SEED: u32 = 0;
+const MAX_SPANS: u32 = 100;
+
+type VoterBagsListInstance = pallet_bags_list::Instance1;
+pub trait Config:
+	pallet_nomination_pools::Config
+	+ pallet_staking::Config
+	+ pallet_bags_list::Config<VoterBagsListInstance>
+{
+}
+
+pub struct Pallet<T: Config>(Pools<T>);
+
+fn create_funded_user_with_balance<T: pallet_nomination_pools::Config>(
+	string: &'static str,
+	n: u32,
+	balance: BalanceOf<T>,
+) -> T::AccountId {
+	let user = account(string, n, USER_SEED);
+	T::Currency::make_free_balance_be(&user, balance);
+	user
+}
+
+// Create a bonded pool account, bonding `balance` and giving the account `balance * 2` free
+// balance.
+fn create_pool_account<T: pallet_nomination_pools::Config>(
+	n: u32,
+	balance: BalanceOf<T>,
+	commission: Option<Perbill>,
+) -> (T::AccountId, T::AccountId) {
+	let ed = CurrencyOf::<T>::minimum_balance();
+	let pool_creator: T::AccountId =
+		create_funded_user_with_balance::<T>("pool_creator", n, ed + balance * 2u32.into());
+	let pool_creator_lookup = T::Lookup::unlookup(pool_creator.clone());
+
+	Pools::<T>::create(
+		RuntimeOrigin::Signed(pool_creator.clone()).into(),
+		balance,
+		pool_creator_lookup.clone(),
+		pool_creator_lookup.clone(),
+		pool_creator_lookup,
+	)
+	.unwrap();
+
+	if let Some(c) = commission {
+		let pool_id = pallet_nomination_pools::LastPoolId::<T>::get();
+		Pools::<T>::set_commission(
+			RuntimeOrigin::Signed(pool_creator.clone()).into(),
+			pool_id,
+			Some((c, pool_creator.clone())),
+		)
+		.expect("pool just created, commission can be set by root; qed");
+	}
+
+	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))
+		.expect("pool_creator created a pool above");
+
+	(pool_creator, pool_account)
+}
+
+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")
+}
+
+#[allow(unused)]
+struct ListScenario<T: pallet_nomination_pools::Config> {
+	/// Stash/Controller that is expected to be moved.
+	origin1: T::AccountId,
+	creator1: T::AccountId,
+	dest_weight: BalanceOf<T>,
+	origin1_member: Option<T::AccountId>,
+}
+
+impl<T: Config> ListScenario<T> {
+	/// An expensive scenario for bags-list implementation:
+	///
+	/// - the node to be updated (r) is the head of a bag that has at least one other node. The bag
+	///   itself will need to be read and written to update its head. The node pointed to by r.next
+	///   will need to be read and written as it will need to have its prev pointer updated. Note
+	///   that there are two other worst case scenarios for bag removal: 1) the node is a tail and
+	///   2) the node is a middle node with prev and next; all scenarios end up with the same number
+	///   of storage reads and writes.
+	///
+	/// - the destination bag has at least one node, which will need its next pointer updated.
+	pub(crate) fn new(
+		origin_weight: BalanceOf<T>,
+		is_increase: bool,
+	) -> Result<Self, &'static str> {
+		ensure!(!origin_weight.is_zero(), "origin weight must be greater than 0");
+
+		ensure!(
+			pallet_nomination_pools::MaxPools::<T>::get().unwrap_or(0) >= 3,
+			"must allow at least three pools for benchmarks"
+		);
+
+		// Burn the entire issuance.
+		let i = CurrencyOf::<T>::burn(CurrencyOf::<T>::total_issuance());
+		sp_std::mem::forget(i);
+
+		// Create accounts with the origin weight
+		let (pool_creator1, pool_origin1) =
+			create_pool_account::<T>(USER_SEED + 1, origin_weight, Some(Perbill::from_percent(50)));
+
+		T::Staking::nominate(
+			&pool_origin1,
+			// NOTE: these don't really need to be validators.
+			vec![account("random_validator", 0, USER_SEED)],
+		)?;
+
+		let (_, pool_origin2) =
+			create_pool_account::<T>(USER_SEED + 2, origin_weight, Some(Perbill::from_percent(50)));
+
+		T::Staking::nominate(
+			&pool_origin2,
+			vec![account("random_validator", 0, USER_SEED)].clone(),
+		)?;
+
+		// Find a destination weight that will trigger the worst case scenario
+		let dest_weight_as_vote = <T as pallet_staking::Config>::VoterList::score_update_worst_case(
+			&pool_origin1,
+			is_increase,
+		);
+
+		let dest_weight: BalanceOf<T> =
+			dest_weight_as_vote.try_into().map_err(|_| "could not convert u64 to Balance")?;
+
+		// Create an account with the worst case destination weight
+		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)])?;
+
+		let weight_of = pallet_staking::Pallet::<T>::weight_of_fn();
+		assert_eq!(vote_to_balance::<T>(weight_of(&pool_origin1)).unwrap(), origin_weight);
+		assert_eq!(vote_to_balance::<T>(weight_of(&pool_origin2)).unwrap(), origin_weight);
+		assert_eq!(vote_to_balance::<T>(weight_of(&pool_dest1)).unwrap(), dest_weight);
+
+		Ok(ListScenario {
+			origin1: pool_origin1,
+			creator1: pool_creator1,
+			dest_weight,
+			origin1_member: None,
+		})
+	}
+
+	fn add_joiner(mut self, amount: BalanceOf<T>) -> Self {
+		let amount = MinJoinBond::<T>::get()
+			.max(CurrencyOf::<T>::minimum_balance())
+			// Max `amount` with minimum thresholds for account balance and joining a pool
+			// to ensure 1) the user can be created and 2) can join the pool
+			.max(amount);
+
+		let joiner: T::AccountId = account("joiner", USER_SEED, 0);
+		self.origin1_member = Some(joiner.clone());
+		CurrencyOf::<T>::make_free_balance_be(&joiner, amount * 2u32.into());
+
+		let original_bonded = T::Staking::active_stake(&self.origin1).unwrap();
+
+		// 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`.");
+
+		// Account pool points for the unbonded balance.
+		BondedPools::<T>::mutate(&1, |maybe_pool| {
+			maybe_pool.as_mut().map(|pool| pool.points -= amount)
+		});
+
+		Pools::<T>::join(RuntimeOrigin::Signed(joiner.clone()).into(), amount, 1).unwrap();
+
+		// check that the vote weight is still the same as the original bonded
+		let weight_of = pallet_staking::Pallet::<T>::weight_of_fn();
+		assert_eq!(vote_to_balance::<T>(weight_of(&self.origin1)).unwrap(), original_bonded);
+
+		// check the member was added correctly
+		let member = PoolMembers::<T>::get(&joiner).unwrap();
+		assert_eq!(member.points, amount);
+		assert_eq!(member.pool_id, 1);
+
+		self
+	}
+}
+
+frame_benchmarking::benchmarks! {
+	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(),
+			origin_weight
+		);
+
+		let max_additional = scenario.dest_weight - origin_weight;
+		let joiner_free = CurrencyOf::<T>::minimum_balance() + max_additional;
+
+		let joiner: T::AccountId
+			= create_funded_user_with_balance::<T>("joiner", 0, joiner_free);
+
+		whitelist_account!(joiner);
+	}: _(RuntimeOrigin::Signed(joiner.clone()), max_additional, 1)
+	verify {
+		assert_eq!(CurrencyOf::<T>::free_balance(&joiner), joiner_free - max_additional);
+		assert_eq!(
+			T::Staking::active_stake(&scenario.origin1).unwrap(),
+			scenario.dest_weight
+		);
+	}
+
+	bond_extra_transfer {
+		let origin_weight = Pools::<T>::depositor_min_bond() * 2u32.into();
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let extra = scenario.dest_weight - origin_weight;
+
+		// creator of the src pool will bond-extra, bumping itself to dest bag.
+
+	}: bond_extra(RuntimeOrigin::Signed(scenario.creator1.clone()), BondExtra::FreeBalance(extra))
+	verify {
+		assert!(
+			T::Staking::active_stake(&scenario.origin1).unwrap() >=
+			scenario.dest_weight
+		);
+	}
+
+	bond_extra_other {
+		let claimer: T::AccountId = account("claimer", USER_SEED + 4, 0);
+
+		let origin_weight = Pools::<T>::depositor_min_bond() * 2u32.into();
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let extra = (scenario.dest_weight - origin_weight).max(CurrencyOf::<T>::minimum_balance());
+
+		// set claim preferences to `PermissionlessAll` to any account to bond extra on member's behalf.
+		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);
+		assert!(extra >= CurrencyOf::<T>::minimum_balance());
+		CurrencyOf::<T>::deposit_creating(&reward_account1, extra);
+
+	}: _(RuntimeOrigin::Signed(claimer), T::Lookup::unlookup(scenario.creator1.clone()), BondExtra::Rewards)
+	verify {
+		 // commission of 50% deducted here.
+		assert!(
+			T::Staking::active_stake(&scenario.origin1).unwrap() >=
+			scenario.dest_weight / 2u32.into()
+		);
+	}
+
+	claim_payout {
+		let claimer: T::AccountId = account("claimer", USER_SEED + 4, 0);
+		let commission = Perbill::from_percent(50);
+		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);
+
+		// Send funds to the reward account of the pool
+		CurrencyOf::<T>::make_free_balance_be(&reward_account, ed + origin_weight);
+
+		// set claim preferences to `PermissionlessAll` so any account can claim rewards on member's
+		// behalf.
+		let _ = Pools::<T>::set_claim_permission(RuntimeOrigin::Signed(depositor.clone()).into(), ClaimPermission::PermissionlessAll);
+
+		// Sanity check
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&depositor),
+			origin_weight
+		);
+
+		whitelist_account!(depositor);
+	}:claim_payout_other(RuntimeOrigin::Signed(claimer), depositor.clone())
+	verify {
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&depositor),
+			origin_weight + commission * origin_weight
+		);
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&reward_account),
+			ed + commission * origin_weight
+		);
+	}
+
+
+	unbond {
+		// The weight the nominator will start at. The value used here is expected to be
+		// significantly higher than the first position in a list (e.g. the first bag threshold).
+		let origin_weight = Pools::<T>::depositor_min_bond() * 200u32.into();
+		let scenario = ListScenario::<T>::new(origin_weight, false)?;
+		let amount = origin_weight - scenario.dest_weight;
+
+		let scenario = scenario.add_joiner(amount);
+		let member_id = scenario.origin1_member.unwrap().clone();
+		let member_id_lookup = T::Lookup::unlookup(member_id.clone());
+		let all_points = PoolMembers::<T>::get(&member_id).unwrap().points;
+		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();
+		// We at least went down to the destination bag
+		assert!(bonded_after <= scenario.dest_weight);
+		let member = PoolMembers::<T>::get(
+			&member_id
+		)
+		.unwrap();
+		assert_eq!(
+			member.unbonding_eras.keys().cloned().collect::<Vec<_>>(),
+			vec![0 + T::Staking::bonding_duration()]
+		);
+		assert_eq!(
+			member.unbonding_eras.values().cloned().collect::<Vec<_>>(),
+			vec![all_points]
+		);
+	}
+
+	pool_withdraw_unbonded {
+		let s in 0 .. MAX_SPANS;
+
+		let min_create_bond = Pools::<T>::depositor_min_bond();
+		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond, None);
+
+		// Add a new member
+		let min_join_bond = MinJoinBond::<T>::get().max(CurrencyOf::<T>::minimum_balance());
+		let joiner = create_funded_user_with_balance::<T>("joiner", 0, min_join_bond * 2u32.into());
+		Pools::<T>::join(RuntimeOrigin::Signed(joiner.clone()).into(), min_join_bond, 1)
+			.unwrap();
+
+		// Sanity check join worked
+		assert_eq!(
+			T::Staking::active_stake(&pool_account).unwrap(),
+			min_create_bond + min_join_bond
+		);
+		assert_eq!(CurrencyOf::<T>::free_balance(&joiner), min_join_bond);
+
+		// Unbond the new member
+		Pools::<T>::fully_unbond(RuntimeOrigin::Signed(joiner.clone()).into(), joiner.clone()).unwrap();
+
+		// Sanity check that unbond worked
+		assert_eq!(
+			T::Staking::active_stake(&pool_account).unwrap(),
+			min_create_bond
+		);
+		assert_eq!(pallet_staking::Ledger::<T>::get(&pool_account).unwrap().unlocking.len(), 1);
+		// Set the current era
+		pallet_staking::CurrentEra::<T>::put(EraIndex::max_value());
+
+		// Add `s` count of slashing spans to storage.
+		pallet_staking::benchmarking::add_slashing_spans::<T>(&pool_account, s);
+		whitelist_account!(pool_account);
+	}: _(RuntimeOrigin::Signed(pool_account.clone()), 1, s)
+	verify {
+		// The joiners funds didn't change
+		assert_eq!(CurrencyOf::<T>::free_balance(&joiner), min_join_bond);
+		// The unlocking chunk was removed
+		assert_eq!(pallet_staking::Ledger::<T>::get(pool_account).unwrap().unlocking.len(), 0);
+	}
+
+	withdraw_unbonded_update {
+		let s in 0 .. MAX_SPANS;
+
+		let min_create_bond = Pools::<T>::depositor_min_bond();
+		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond, None);
+
+		// Add a new member
+		let min_join_bond = MinJoinBond::<T>::get().max(CurrencyOf::<T>::minimum_balance());
+		let joiner = create_funded_user_with_balance::<T>("joiner", 0, min_join_bond * 2u32.into());
+		let joiner_lookup = T::Lookup::unlookup(joiner.clone());
+		Pools::<T>::join(RuntimeOrigin::Signed(joiner.clone()).into(), min_join_bond, 1)
+			.unwrap();
+
+		// Sanity check join worked
+		assert_eq!(
+			T::Staking::active_stake(&pool_account).unwrap(),
+			min_create_bond + min_join_bond
+		);
+		assert_eq!(CurrencyOf::<T>::free_balance(&joiner), min_join_bond);
+
+		// Unbond the new member
+		pallet_staking::CurrentEra::<T>::put(0);
+		Pools::<T>::fully_unbond(RuntimeOrigin::Signed(joiner.clone()).into(), joiner.clone()).unwrap();
+
+		// Sanity check that unbond worked
+		assert_eq!(
+			T::Staking::active_stake(&pool_account).unwrap(),
+			min_create_bond
+		);
+		assert_eq!(pallet_staking::Ledger::<T>::get(&pool_account).unwrap().unlocking.len(), 1);
+
+		// Set the current era to ensure we can withdraw unbonded funds
+		pallet_staking::CurrentEra::<T>::put(EraIndex::max_value());
+
+		pallet_staking::benchmarking::add_slashing_spans::<T>(&pool_account, s);
+		whitelist_account!(joiner);
+	}: withdraw_unbonded(RuntimeOrigin::Signed(joiner.clone()), joiner_lookup, s)
+	verify {
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&joiner),
+			min_join_bond * 2u32.into()
+		);
+		// The unlocking chunk was removed
+		assert_eq!(pallet_staking::Ledger::<T>::get(&pool_account).unwrap().unlocking.len(), 0);
+	}
+
+	withdraw_unbonded_kill {
+		let s in 0 .. MAX_SPANS;
+
+		let min_create_bond = Pools::<T>::depositor_min_bond();
+		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond, None);
+		let depositor_lookup = T::Lookup::unlookup(depositor.clone());
+
+		// We set the pool to the destroying state so the depositor can leave
+		BondedPools::<T>::try_mutate(&1, |maybe_bonded_pool| {
+			maybe_bonded_pool.as_mut().ok_or(()).map(|bonded_pool| {
+				bonded_pool.state = PoolState::Destroying;
+			})
+		})
+		.unwrap();
+
+		// Unbond the creator
+		pallet_staking::CurrentEra::<T>::put(0);
+		// Simulate some rewards so we can check if the rewards storage is cleaned up. We check this
+		// 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);
+		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(),
+			Zero::zero()
+		);
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&pool_account),
+			min_create_bond
+		);
+		assert_eq!(pallet_staking::Ledger::<T>::get(&pool_account).unwrap().unlocking.len(), 1);
+
+		// Set the current era to ensure we can withdraw unbonded funds
+		pallet_staking::CurrentEra::<T>::put(EraIndex::max_value());
+
+		// Some last checks that storage items we expect to get cleaned up are present
+		assert!(pallet_staking::Ledger::<T>::contains_key(&pool_account));
+		assert!(BondedPools::<T>::contains_key(&1));
+		assert!(SubPoolsStorage::<T>::contains_key(&1));
+		assert!(RewardPools::<T>::contains_key(&1));
+		assert!(PoolMembers::<T>::contains_key(&depositor));
+		assert!(frame_system::Account::<T>::contains_key(&reward_account));
+
+		whitelist_account!(depositor);
+	}: withdraw_unbonded(RuntimeOrigin::Signed(depositor.clone()), depositor_lookup, s)
+	verify {
+		// Pool removal worked
+		assert!(!pallet_staking::Ledger::<T>::contains_key(&pool_account));
+		assert!(!BondedPools::<T>::contains_key(&1));
+		assert!(!SubPoolsStorage::<T>::contains_key(&1));
+		assert!(!RewardPools::<T>::contains_key(&1));
+		assert!(!PoolMembers::<T>::contains_key(&depositor));
+		assert!(!frame_system::Account::<T>::contains_key(&pool_account));
+		assert!(!frame_system::Account::<T>::contains_key(&reward_account));
+
+		// Funds where transferred back correctly
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&depositor),
+			// gets bond back + rewards collecting when unbonding
+			min_create_bond * 2u32.into() + CurrencyOf::<T>::minimum_balance()
+		);
+	}
+
+	create {
+		let min_create_bond = Pools::<T>::depositor_min_bond();
+		let depositor: T::AccountId = account("depositor", USER_SEED, 0);
+		let depositor_lookup = T::Lookup::unlookup(depositor.clone());
+
+		// Give the depositor some balance to bond
+		CurrencyOf::<T>::make_free_balance_be(&depositor, min_create_bond * 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);
+
+		whitelist_account!(depositor);
+	}: _(
+			RuntimeOrigin::Signed(depositor.clone()),
+			min_create_bond,
+			depositor_lookup.clone(),
+			depositor_lookup.clone(),
+			depositor_lookup
+		)
+	verify {
+		assert_eq!(RewardPools::<T>::count(), 1);
+		assert_eq!(BondedPools::<T>::count(), 1);
+		let (_, new_pool) = BondedPools::<T>::iter().next().unwrap();
+		assert_eq!(
+			new_pool,
+			BondedPoolInner {
+				commission: Commission::default(),
+				member_counter: 1,
+				points: min_create_bond,
+				roles: PoolRoles {
+					depositor: depositor.clone(),
+					root: Some(depositor.clone()),
+					nominator: Some(depositor.clone()),
+					bouncer: Some(depositor.clone()),
+				},
+				state: PoolState::Open,
+			}
+		);
+		assert_eq!(
+			T::Staking::active_stake(&Pools::<T>::create_bonded_account(1)),
+			Ok(min_create_bond)
+		);
+	}
+
+	nominate {
+		let n in 1 .. MaxNominationsOf::<T>::get();
+
+		// Create a pool
+		let min_create_bond = Pools::<T>::depositor_min_bond() * 2u32.into();
+		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond, None);
+
+		// Create some accounts to nominate. For the sake of benchmarking they don't need to be
+		// actual validators
+		 let validators: Vec<_> = (0..n)
+			.map(|i| account("stash", USER_SEED, i))
+			.collect();
+
+		whitelist_account!(depositor);
+	}:_(RuntimeOrigin::Signed(depositor.clone()), 1, validators)
+	verify {
+		assert_eq!(RewardPools::<T>::count(), 1);
+		assert_eq!(BondedPools::<T>::count(), 1);
+		let (_, new_pool) = BondedPools::<T>::iter().next().unwrap();
+		assert_eq!(
+			new_pool,
+			BondedPoolInner {
+				commission: Commission::default(),
+				member_counter: 1,
+				points: min_create_bond,
+				roles: PoolRoles {
+					depositor: depositor.clone(),
+					root: Some(depositor.clone()),
+					nominator: Some(depositor.clone()),
+					bouncer: Some(depositor.clone()),
+				},
+				state: PoolState::Open,
+			}
+		);
+		assert_eq!(
+			T::Staking::active_stake(&Pools::<T>::create_bonded_account(1)),
+			Ok(min_create_bond)
+		);
+	}
+
+	set_state {
+		// Create a pool
+		let min_create_bond = Pools::<T>::depositor_min_bond();
+		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond, None);
+		BondedPools::<T>::mutate(&1, |maybe_pool| {
+			// Force the pool into an invalid state
+			maybe_pool.as_mut().map(|pool| pool.points = min_create_bond * 10u32.into());
+		});
+
+		let caller = account("caller", 0, USER_SEED);
+		whitelist_account!(caller);
+	}:_(RuntimeOrigin::Signed(caller), 1, PoolState::Destroying)
+	verify {
+		assert_eq!(BondedPools::<T>::get(1).unwrap().state, PoolState::Destroying);
+	}
+
+	set_metadata {
+		let n in 1 .. <T as pallet_nomination_pools::Config>::MaxMetadataLen::get();
+
+		// Create a pool
+		let (depositor, pool_account) = create_pool_account::<T>(0, Pools::<T>::depositor_min_bond() * 2u32.into(), None);
+
+		// Create metadata of the max possible size
+		let metadata: Vec<u8> = (0..n).map(|_| 42).collect();
+
+		whitelist_account!(depositor);
+	}:_(RuntimeOrigin::Signed(depositor), 1, metadata.clone())
+	verify {
+		assert_eq!(Metadata::<T>::get(&1), metadata);
+	}
+
+	set_configs {
+	}:_(
+		RuntimeOrigin::Root,
+		ConfigOp::Set(BalanceOf::<T>::max_value()),
+		ConfigOp::Set(BalanceOf::<T>::max_value()),
+		ConfigOp::Set(u32::MAX),
+		ConfigOp::Set(u32::MAX),
+		ConfigOp::Set(u32::MAX),
+		ConfigOp::Set(Perbill::max_value())
+	) verify {
+		assert_eq!(MinJoinBond::<T>::get(), BalanceOf::<T>::max_value());
+		assert_eq!(MinCreateBond::<T>::get(), BalanceOf::<T>::max_value());
+		assert_eq!(MaxPools::<T>::get(), Some(u32::MAX));
+		assert_eq!(MaxPoolMembers::<T>::get(), Some(u32::MAX));
+		assert_eq!(MaxPoolMembersPerPool::<T>::get(), Some(u32::MAX));
+		assert_eq!(GlobalMaxCommission::<T>::get(), Some(Perbill::max_value()));
+	}
+
+	update_roles {
+		let first_id = pallet_nomination_pools::LastPoolId::<T>::get() + 1;
+		let (root, _) = create_pool_account::<T>(0, Pools::<T>::depositor_min_bond() * 2u32.into(), None);
+		let random: T::AccountId = account("but is anything really random in computers..?", 0, USER_SEED);
+	}:_(
+		RuntimeOrigin::Signed(root.clone()),
+		first_id,
+		ConfigOp::Set(random.clone()),
+		ConfigOp::Set(random.clone()),
+		ConfigOp::Set(random.clone())
+	) verify {
+		assert_eq!(
+			pallet_nomination_pools::BondedPools::<T>::get(first_id).unwrap().roles,
+			pallet_nomination_pools::PoolRoles {
+				depositor: root,
+				nominator: Some(random.clone()),
+				bouncer: Some(random.clone()),
+				root: Some(random),
+			},
+		)
+	}
+
+	chill {
+		// Create a pool
+		let (depositor, pool_account) = create_pool_account::<T>(0, Pools::<T>::depositor_min_bond() * 2u32.into(), None);
+
+		// Nominate with the pool.
+		 let validators: Vec<_> = (0..MaxNominationsOf::<T>::get())
+			.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());
+
+		whitelist_account!(depositor);
+	}:_(RuntimeOrigin::Signed(depositor.clone()), 1)
+	verify {
+		assert!(T::Staking::nominations(&Pools::<T>::create_bonded_account(1)).is_none());
+	}
+
+	set_commission {
+		// Create a pool - do not set a commission yet.
+		let (depositor, pool_account) = create_pool_account::<T>(0, Pools::<T>::depositor_min_bond() * 2u32.into(), None);
+		// set a max commission
+		Pools::<T>::set_commission_max(RuntimeOrigin::Signed(depositor.clone()).into(), 1u32.into(), Perbill::from_percent(50)).unwrap();
+		// set a change rate
+		Pools::<T>::set_commission_change_rate(RuntimeOrigin::Signed(depositor.clone()).into(), 1u32.into(), CommissionChangeRate {
+			max_increase: Perbill::from_percent(20),
+			min_delay: 0u32.into(),
+		}).unwrap();
+
+	}:_(RuntimeOrigin::Signed(depositor.clone()), 1u32.into(), Some((Perbill::from_percent(20), depositor.clone())))
+	verify {
+		assert_eq!(BondedPools::<T>::get(1).unwrap().commission, Commission {
+			current: Some((Perbill::from_percent(20), depositor)),
+			max: Some(Perbill::from_percent(50)),
+			change_rate: Some(CommissionChangeRate {
+					max_increase: Perbill::from_percent(20),
+					min_delay: 0u32.into()
+			}),
+			throttle_from: Some(1u32.into()),
+		});
+	}
+
+	set_commission_max {
+		// Create a pool, setting a commission that will update when max commission is set.
+		let (depositor, pool_account) = create_pool_account::<T>(0, Pools::<T>::depositor_min_bond() * 2u32.into(), Some(Perbill::from_percent(50)));
+	}:_(RuntimeOrigin::Signed(depositor.clone()), 1u32.into(), Perbill::from_percent(50))
+	verify {
+		assert_eq!(
+			BondedPools::<T>::get(1).unwrap().commission, Commission {
+			current: Some((Perbill::from_percent(50), depositor)),
+			max: Some(Perbill::from_percent(50)),
+			change_rate: None,
+			throttle_from: Some(0u32.into()),
+		});
+	}
+
+	set_commission_change_rate {
+		// Create a pool
+		let (depositor, pool_account) = create_pool_account::<T>(0, Pools::<T>::depositor_min_bond() * 2u32.into(), None);
+	}:_(RuntimeOrigin::Signed(depositor.clone()), 1u32.into(), CommissionChangeRate {
+		max_increase: Perbill::from_percent(50),
+		min_delay: 1000u32.into(),
+	})
+	verify {
+		assert_eq!(
+			BondedPools::<T>::get(1).unwrap().commission, Commission {
+			current: None,
+			max: None,
+			change_rate: Some(CommissionChangeRate {
+				max_increase: Perbill::from_percent(50),
+				min_delay: 1000u32.into(),
+			}),
+			throttle_from: Some(1_u32.into()),
+		});
+  }
+
+	set_claim_permission {
+		// Create a pool
+		let min_create_bond = Pools::<T>::depositor_min_bond();
+		let (depositor, pool_account) = create_pool_account::<T>(0, min_create_bond, None);
+
+		// Join pool
+		let min_join_bond = MinJoinBond::<T>::get().max(CurrencyOf::<T>::minimum_balance());
+		let joiner = create_funded_user_with_balance::<T>("joiner", 0, min_join_bond * 4u32.into());
+		let joiner_lookup = T::Lookup::unlookup(joiner.clone());
+		Pools::<T>::join(RuntimeOrigin::Signed(joiner.clone()).into(), min_join_bond, 1)
+			.unwrap();
+
+		// Sanity check join worked
+		assert_eq!(
+			T::Staking::active_stake(&pool_account).unwrap(),
+			min_create_bond + min_join_bond
+		);
+	}:_(RuntimeOrigin::Signed(joiner.clone()), ClaimPermission::PermissionlessAll)
+	verify {
+		assert_eq!(ClaimPermissions::<T>::get(joiner), ClaimPermission::PermissionlessAll);
+	}
+
+	claim_commission {
+		let claimer: T::AccountId = account("claimer_member", USER_SEED + 4, 0);
+		let commission = Perbill::from_percent(50);
+		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);
+		CurrencyOf::<T>::make_free_balance_be(&reward_account, ed + origin_weight);
+
+		// member claims a payout to make some commission available.
+		let _ = Pools::<T>::claim_payout(RuntimeOrigin::Signed(claimer).into());
+
+		whitelist_account!(depositor);
+	}:_(RuntimeOrigin::Signed(depositor.clone()), 1u32.into())
+	verify {
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&depositor),
+			origin_weight + commission * origin_weight
+		);
+		assert_eq!(
+			CurrencyOf::<T>::free_balance(&reward_account),
+			ed + commission * origin_weight
+		);
+	}
+
+	impl_benchmark_test_suite!(
+		Pallet,
+		crate::mock::new_test_ext(),
+		crate::mock::Runtime
+	);
+}
diff --git a/substrate/frame/nomination-pools/benchmarking/src/mock.rs b/substrate/frame/nomination-pools/benchmarking/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2d75df63b518a698c5755cb12557e6aa7cb58b9e
--- /dev/null
+++ b/substrate/frame/nomination-pools/benchmarking/src/mock.rs
@@ -0,0 +1,202 @@
+// 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::VoterBagsListInstance;
+use frame_election_provider_support::VoteWeight;
+use frame_support::{pallet_prelude::*, parameter_types, traits::ConstU64, PalletId};
+use sp_runtime::{
+	traits::{Convert, IdentityLookup},
+	BuildStorage, FixedU128, Perbill,
+};
+
+type AccountId = u128;
+type Nonce = u32;
+type BlockNumber = u64;
+type Balance = u128;
+
+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 {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub const ExistentialDeposit: Balance = 10;
+}
+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 = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+
+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;
+}
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = ();
+	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 HistoryDepth = ConstU32<84>;
+	type EventListeners = Pools;
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub static BagThresholds: &'static [VoteWeight] = &[10, 20, 30, 40, 50, 60, 1_000, 2_000, 10_000];
+}
+
+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 static PostUnbondingPoolsWindow: u32 = 10;
+	pub const PoolsPalletId: PalletId = PalletId(*b"py/nopls");
+	pub const MaxPointsToBalance: u8 = 10;
+}
+
+impl pallet_nomination_pools::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type RewardCounter = FixedU128;
+	type BalanceToU256 = BalanceToU256;
+	type U256ToBalance = U256ToBalance;
+	type Staking = Staking;
+	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
+	type MaxMetadataLen = ConstU32<256>;
+	type MaxUnbonding = ConstU32<8>;
+	type PalletId = PoolsPalletId;
+	type MaxPointsToBalance = MaxPointsToBalance;
+}
+
+impl crate::Config for Runtime {}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Event<T>},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
+		VoterList: pallet_bags_list::<Instance1>::{Pallet, Call, Storage, Event<T>},
+		Pools: pallet_nomination_pools::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	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(3),
+		max_members: Some(3 * 3),
+		global_max_commission: Some(Perbill::from_percent(50)),
+	}
+	.assimilate_storage(&mut storage);
+	sp_io::TestExternalities::from(storage)
+}
diff --git a/substrate/frame/nomination-pools/fuzzer/Cargo.toml b/substrate/frame/nomination-pools/fuzzer/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7dde8733e3f6098011ecaf7844c23786871aad26
--- /dev/null
+++ b/substrate/frame/nomination-pools/fuzzer/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "pallet-nomination-pools-fuzzer"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Fuzzer for fixed point arithmetic primitives."
+documentation = "https://docs.rs/sp-arithmetic-fuzzer"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+honggfuzz = "0.5.54"
+
+pallet-nomination-pools = { path = "..", features = ["fuzzing"] }
+
+frame-system = { path = "../../system" }
+frame-support = { path = "../../support" }
+
+sp-runtime = { path = "../../../primitives/runtime" }
+sp-io = { path = "../../../primitives/io" }
+sp-tracing = { path = "../../../primitives/tracing" }
+
+rand = { version = "0.8.5", features = ["small_rng"] }
+log = "0.4.17"
+
+[[bin]]
+name = "call"
+path = "src/call.rs"
diff --git a/substrate/frame/nomination-pools/fuzzer/src/call.rs b/substrate/frame/nomination-pools/fuzzer/src/call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..027fb2b69138c64f8903f99737187b7cd65c12c2
--- /dev/null
+++ b/substrate/frame/nomination-pools/fuzzer/src/call.rs
@@ -0,0 +1,354 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run call`. `honggfuzz` CLI
+//! options can be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug per_thing_rational hfuzz_workspace/call/*.fuzz`.
+
+use frame_support::{
+	assert_ok,
+	traits::{Currency, GetCallName, UnfilteredDispatchable},
+};
+use honggfuzz::fuzz;
+use pallet_nomination_pools::{
+	log,
+	mock::*,
+	pallet as pools,
+	pallet::{BondedPools, Call as PoolsCall, Event as PoolsEvents, PoolMembers},
+	BondExtra, BondedPool, GlobalMaxCommission, LastPoolId, MaxPoolMembers, MaxPoolMembersPerPool,
+	MaxPools, MinCreateBond, MinJoinBond, PoolId,
+};
+use rand::{seq::SliceRandom, Rng};
+use sp_runtime::{assert_eq_error_rate, Perbill, Perquintill};
+
+const ERA: BlockNumber = 1000;
+const MAX_ED_MULTIPLE: Balance = 10_000;
+const MIN_ED_MULTIPLE: Balance = 10;
+
+// not quite elegant, just to make it available in random_signed_origin.
+const REWARD_AGENT_ACCOUNT: AccountId = 42;
+
+/// Grab random accounts, either known ones, or new ones.
+fn random_signed_origin<R: Rng>(rng: &mut R) -> (RuntimeOrigin, AccountId) {
+	let count = PoolMembers::<T>::count();
+	if rng.gen::<bool>() && count > 0 {
+		// take an existing account.
+		let skip = rng.gen_range(0..count as usize);
+
+		// this is tricky: the account might be our reward agent, which we never want to be
+		// randomly chosen here. Try another one, or, if it is only our agent, return a random
+		// one nonetheless.
+		let candidate = PoolMembers::<T>::iter_keys().skip(skip).take(1).next().unwrap();
+		let acc =
+			if candidate == REWARD_AGENT_ACCOUNT { rng.gen::<AccountId>() } else { candidate };
+
+		(RuntimeOrigin::signed(acc), acc)
+	} else {
+		// create a new account
+		let acc = rng.gen::<AccountId>();
+		(RuntimeOrigin::signed(acc), acc)
+	}
+}
+
+fn random_ed_multiple<R: Rng>(rng: &mut R) -> Balance {
+	let multiple = rng.gen_range(MIN_ED_MULTIPLE..MAX_ED_MULTIPLE);
+	ExistentialDeposit::get() * multiple
+}
+
+fn fund_account<R: Rng>(rng: &mut R, account: &AccountId) {
+	let target_amount = random_ed_multiple(rng);
+	if let Some(top_up) = target_amount.checked_sub(Balances::free_balance(account)) {
+		let _ = Balances::deposit_creating(account, top_up);
+	}
+	assert!(Balances::free_balance(account) >= target_amount);
+}
+
+fn random_existing_pool<R: Rng>(mut rng: &mut R) -> Option<PoolId> {
+	BondedPools::<T>::iter_keys().collect::<Vec<_>>().choose(&mut rng).map(|x| *x)
+}
+
+fn random_call<R: Rng>(mut rng: &mut R) -> (pools::Call<T>, RuntimeOrigin) {
+	let op = rng.gen::<usize>();
+	let mut op_count = <pools::Call<T> as GetCallName>::get_call_names().len();
+	// Exclude set_state, set_metadata, set_configs, update_roles and chill.
+	op_count -= 5;
+
+	match op % op_count {
+		0 => {
+			// join
+			let pool_id = random_existing_pool(&mut rng).unwrap_or_default();
+			let (origin, who) = random_signed_origin(&mut rng);
+			fund_account(&mut rng, &who);
+			let amount = random_ed_multiple(&mut rng);
+			(PoolsCall::<T>::join { amount, pool_id }, origin)
+		},
+		1 => {
+			// bond_extra
+			let (origin, who) = random_signed_origin(&mut rng);
+			let extra = if rng.gen::<bool>() {
+				BondExtra::Rewards
+			} else {
+				fund_account(&mut rng, &who);
+				let amount = random_ed_multiple(&mut rng);
+				BondExtra::FreeBalance(amount)
+			};
+			(PoolsCall::<T>::bond_extra { extra }, origin)
+		},
+		2 => {
+			// claim_payout
+			let (origin, _) = random_signed_origin(&mut rng);
+			(PoolsCall::<T>::claim_payout {}, origin)
+		},
+		3 => {
+			// unbond
+			let (origin, who) = random_signed_origin(&mut rng);
+			let amount = random_ed_multiple(&mut rng);
+			(PoolsCall::<T>::unbond { member_account: who, unbonding_points: amount }, origin)
+		},
+		4 => {
+			// pool_withdraw_unbonded
+			let pool_id = random_existing_pool(&mut rng).unwrap_or_default();
+			let (origin, _) = random_signed_origin(&mut rng);
+			(PoolsCall::<T>::pool_withdraw_unbonded { pool_id, num_slashing_spans: 0 }, origin)
+		},
+		5 => {
+			// withdraw_unbonded
+			let (origin, who) = random_signed_origin(&mut rng);
+			(
+				PoolsCall::<T>::withdraw_unbonded { member_account: who, num_slashing_spans: 0 },
+				origin,
+			)
+		},
+		6 => {
+			// create
+			let (origin, who) = random_signed_origin(&mut rng);
+			let amount = random_ed_multiple(&mut rng);
+			fund_account(&mut rng, &who);
+			let root = who;
+			let bouncer = who;
+			let nominator = who;
+			(PoolsCall::<T>::create { amount, root, bouncer, nominator }, origin)
+		},
+		7 => {
+			// nominate
+			let (origin, _) = random_signed_origin(&mut rng);
+			let pool_id = random_existing_pool(&mut rng).unwrap_or_default();
+			let validators = Default::default();
+			(PoolsCall::<T>::nominate { pool_id, validators }, origin)
+		},
+		_ => unreachable!(),
+	}
+}
+
+#[derive(Default)]
+struct RewardAgent {
+	who: AccountId,
+	pool_id: Option<PoolId>,
+	expected_reward: Balance,
+}
+
+// TODO: inject some slashes into the game.
+impl RewardAgent {
+	fn new(who: AccountId) -> Self {
+		Self { who, ..Default::default() }
+	}
+
+	fn join(&mut self) {
+		if self.pool_id.is_some() {
+			return
+		}
+		let pool_id = LastPoolId::<T>::get();
+		let amount = 10 * ExistentialDeposit::get();
+		let origin = RuntimeOrigin::signed(self.who);
+		let _ = Balances::deposit_creating(&self.who, 10 * amount);
+		self.pool_id = Some(pool_id);
+		log::info!(target: "reward-agent", "🤖 reward agent joining in {} with {}", pool_id, amount);
+		assert_ok!(PoolsCall::join::<T> { amount, pool_id }.dispatch_bypass_filter(origin));
+	}
+
+	fn claim_payout(&mut self) {
+		// 10 era later, we claim our payout. We expect our income to be roughly what we
+		// calculated.
+		if !PoolMembers::<T>::contains_key(&self.who) {
+			log!(warn, "reward agent is not in the pool yet, cannot claim");
+			return
+		}
+		let pre = Balances::free_balance(&42);
+		let origin = RuntimeOrigin::signed(42);
+		assert_ok!(PoolsCall::<T>::claim_payout {}.dispatch_bypass_filter(origin));
+		let post = Balances::free_balance(&42);
+
+		let income = post - pre;
+		log::info!(
+			target: "reward-agent", "🤖 CLAIM: actual: {}, expected: {}",
+			income,
+			self.expected_reward,
+		);
+		assert_eq_error_rate!(income, self.expected_reward, 10);
+		self.expected_reward = 0;
+	}
+}
+
+fn main() {
+	let mut reward_agent = RewardAgent::new(REWARD_AGENT_ACCOUNT);
+	sp_tracing::try_init_simple();
+	let mut ext = sp_io::TestExternalities::new_empty();
+	let mut events_histogram = Vec::<(PoolsEvents<T>, u32)>::default();
+	let mut iteration = 0 as BlockNumber;
+	let mut ok = 0;
+	let mut err = 0;
+
+	let dot: Balance = (10 as Balance).pow(10);
+	ExistentialDeposit::set(dot);
+	BondingDuration::set(8);
+
+	ext.execute_with(|| {
+		MaxPoolMembers::<T>::set(Some(10_000));
+		MaxPoolMembersPerPool::<T>::set(Some(1000));
+		MaxPools::<T>::set(Some(1_000));
+		GlobalMaxCommission::<T>::set(Some(Perbill::from_percent(25)));
+
+		MinCreateBond::<T>::set(10 * ExistentialDeposit::get());
+		MinJoinBond::<T>::set(5 * ExistentialDeposit::get());
+		System::set_block_number(1);
+	});
+
+	loop {
+		fuzz!(|seed: [u8; 32]| {
+			use ::rand::{rngs::SmallRng, SeedableRng};
+			let mut rng = SmallRng::from_seed(seed);
+
+			ext.execute_with(|| {
+				let (call, origin) = random_call(&mut rng);
+				let outcome = call.clone().dispatch_bypass_filter(origin.clone());
+				iteration += 1;
+				match outcome {
+					Ok(_) => ok += 1,
+					Err(_) => err += 1,
+				};
+
+				log!(
+					trace,
+					"iteration {}, call {:?}, origin {:?}, outcome: {:?}, so far {} ok {} err",
+					iteration,
+					call,
+					origin,
+					outcome,
+					ok,
+					err,
+				);
+
+				// possibly join the reward_agent
+				if iteration > ERA / 2 && BondedPools::<T>::count() > 0 {
+					reward_agent.join();
+				}
+				// and possibly roughly every 4 era, trigger payout for the agent. Doing this more
+				// frequent is also harmless.
+				if rng.gen_range(0..(4 * ERA)) == 0 {
+					reward_agent.claim_payout();
+				}
+
+				// execute sanity checks at a fixed interval, possibly on every block.
+				if iteration %
+					(std::env::var("SANITY_CHECK_INTERVAL")
+						.ok()
+						.and_then(|x| x.parse::<u64>().ok()))
+					.unwrap_or(1) == 0
+				{
+					log!(info, "running sanity checks at {}", iteration);
+					Pools::do_try_state(u8::MAX).unwrap();
+				}
+
+				// collect and reset events.
+				System::events()
+					.into_iter()
+					.map(|r| r.event)
+					.filter_map(|e| {
+						if let pallet_nomination_pools::mock::RuntimeEvent::Pools(inner) = e {
+							Some(inner)
+						} else {
+							None
+						}
+					})
+					.for_each(|e| {
+						if let Some((_, c)) = events_histogram
+							.iter_mut()
+							.find(|(x, _)| std::mem::discriminant(x) == std::mem::discriminant(&e))
+						{
+							*c += 1;
+						} else {
+							events_histogram.push((e, 1))
+						}
+					});
+				System::reset_events();
+
+				// trigger an era change, and check the status of the reward agent.
+				if iteration % ERA == 0 {
+					CurrentEra::mutate(|c| *c += 1);
+					BondedPools::<T>::iter().for_each(|(id, _)| {
+						let amount = random_ed_multiple(&mut rng);
+						let _ =
+							Balances::deposit_creating(&Pools::create_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) {
+							let all_points = BondedPool::<T>::get(id).map(|p| p.points).unwrap();
+							let member_points =
+								PoolMembers::<T>::get(reward_agent.who).map(|m| m.points).unwrap();
+							let agent_share = Perquintill::from_rational(member_points, all_points);
+							log::info!(
+								target: "reward-agent",
+								"🤖 REWARD = amount = {:?}, ratio: {:?}, share {:?}",
+								amount,
+								agent_share,
+								agent_share * amount,
+							);
+							reward_agent.expected_reward += agent_share * amount;
+						}
+					});
+
+					log!(
+						info,
+						"iteration {}, {} pools, {} members, {} ok {} err, events = {:?}",
+						iteration,
+						BondedPools::<T>::count(),
+						PoolMembers::<T>::count(),
+						ok,
+						err,
+						events_histogram
+							.iter()
+							.map(|(x, c)| (
+								format!("{:?}", x)
+									.split(" ")
+									.map(|x| x.to_string())
+									.collect::<Vec<_>>()
+									.first()
+									.cloned()
+									.unwrap(),
+								c,
+							))
+							.collect::<Vec<_>>(),
+					);
+				}
+			})
+		})
+	}
+}
diff --git a/substrate/frame/nomination-pools/runtime-api/Cargo.toml b/substrate/frame/nomination-pools/runtime-api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..eef1d42d4339737895d0c2ee088772df67528158
--- /dev/null
+++ b/substrate/frame/nomination-pools/runtime-api/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "pallet-nomination-pools-runtime-api"
+version = "1.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Runtime API for nomination-pools FRAME pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/api" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+pallet-nomination-pools = { version = "1.0.0", default-features = false, path = "../" }
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "pallet-nomination-pools/std", "sp-api/std", "sp-std/std" ]
diff --git a/substrate/frame/nomination-pools/runtime-api/README.md b/substrate/frame/nomination-pools/runtime-api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..af90b31733b0b306eec13f43ccbd6bb6a857f1ac
--- /dev/null
+++ b/substrate/frame/nomination-pools/runtime-api/README.md
@@ -0,0 +1,3 @@
+Runtime API definition for nomination-pools pallet.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/nomination-pools/runtime-api/src/lib.rs b/substrate/frame/nomination-pools/runtime-api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..881c3c36331b64168eceed8eeebfa5b62b7e5f41
--- /dev/null
+++ b/substrate/frame/nomination-pools/runtime-api/src/lib.rs
@@ -0,0 +1,42 @@
+// 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.
+
+//! Runtime API definition for nomination-pools pallet.
+//! Currently supports only one rpc endpoint.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::Codec;
+use pallet_nomination_pools::PoolId;
+
+sp_api::decl_runtime_apis! {
+	/// Runtime api for accessing information about nomination pools.
+	pub trait NominationPoolsApi<AccountId, Balance>
+		where
+			AccountId: Codec,
+			Balance: Codec,
+	{
+		/// Returns the pending rewards for the member that the AccountId was given for.
+		fn pending_rewards(who: AccountId) -> Balance;
+
+		/// Returns the equivalent balance of `points` for a given pool.
+		fn points_to_balance(pool_id: PoolId, points: Balance) -> Balance;
+
+		/// Returns the equivalent points of `new_funds` for a given pool.
+		fn balance_to_points(pool_id: PoolId, new_funds: Balance) -> Balance;
+	}
+}
diff --git a/substrate/frame/nomination-pools/src/lib.rs b/substrate/frame/nomination-pools/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c4bebc5a1d0304070b47bbc546dd7c56e90ecf63
--- /dev/null
+++ b/substrate/frame/nomination-pools/src/lib.rs
@@ -0,0 +1,3293 @@
+// 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.
+
+//! # Nomination Pools for Staking Delegation
+//!
+//! A pallet that allows members to delegate their stake to nominating pools. A nomination pool acts
+//! as nominator and nominates validators on the members behalf.
+//!
+//! # Index
+//!
+//! * [Key terms](#key-terms)
+//! * [Usage](#usage)
+//! * [Implementor's Guide](#implementors-guide)
+//! * [Design](#design)
+//!
+//! ## Key Terms
+//!
+//!  * pool id: A unique identifier of each pool. Set to u32.
+//!  * bonded pool: Tracks the distribution of actively staked funds. See [`BondedPool`] and
+//! [`BondedPoolInner`].
+//! * reward pool: Tracks rewards earned by actively staked funds. See [`RewardPool`] and
+//!   [`RewardPools`].
+//! * unbonding sub pools: Collection of pools at different phases of the unbonding lifecycle. See
+//!   [`SubPools`] and [`SubPoolsStorage`].
+//! * members: Accounts that are members of pools. See [`PoolMember`] and [`PoolMembers`].
+//! * roles: Administrative roles of each pool, capable of controlling nomination, and the state of
+//!   the pool.
+//! * point: A unit of measure for a members portion of a pool's funds. Points initially have a
+//!   ratio of 1 (as set by `POINTS_TO_BALANCE_INIT_RATIO`) to balance, but as slashing happens,
+//!   this can change.
+//! * kick: The act of a pool administrator forcibly ejecting a member.
+//! * bonded account: A key-less account id derived from the pool id that acts as the bonded
+//!   account. This account registers itself as a nominator in the staking system, and follows
+//!   exactly the same rules and conditions as a normal staker. Its bond increases or decreases as
+//!   members join, it can `nominate` or `chill`, and might not even earn staking rewards if it is
+//!   not nominating proper validators.
+//! * reward account: A similar key-less account, that is set as the `Payee` account for the bonded
+//!   account for all staking rewards.
+//! * change rate: The rate at which pool commission can be changed. A change rate consists of a
+//!   `max_increase` and `min_delay`, dictating the maximum percentage increase that can be applied
+//!   to the commission per number of blocks.
+//! * throttle: An attempted commission increase is throttled if the attempted change falls outside
+//!   the change rate bounds.
+//!
+//! ## Usage
+//!
+//! ### Join
+//!
+//! An account can stake funds with a nomination pool by calling [`Call::join`].
+//!
+//! ### Claim rewards
+//!
+//! After joining a pool, a member can claim rewards by calling [`Call::claim_payout`].
+//!
+//! A pool member can also set a `ClaimPermission` with [`Call::set_claim_permission`], to allow
+//! other members to permissionlessly bond or withdraw their rewards by calling
+//! [`Call::bond_extra_other`] or [`Call::claim_payout_other`] respectively.
+//!
+//! For design docs see the [reward pool](#reward-pool) section.
+//!
+//! ### Leave
+//!
+//! In order to leave, a member must take two steps.
+//!
+//! First, they must call [`Call::unbond`]. The unbond extrinsic will start the unbonding process by
+//! unbonding all or a portion of the members funds.
+//!
+//! > A member can have up to [`Config::MaxUnbonding`] distinct active unbonding requests.
+//!
+//! Second, once [`sp_staking::StakingInterface::bonding_duration`] eras have passed, the member can
+//! call [`Call::withdraw_unbonded`] to withdraw any funds that are free.
+//!
+//! For design docs see the [bonded pool](#bonded-pool) and [unbonding sub
+//! pools](#unbonding-sub-pools) sections.
+//!
+//! ### Slashes
+//!
+//! Slashes are distributed evenly across the bonded pool and the unbonding pools from slash era+1
+//! through the slash apply era. Thus, any member who either
+//!
+//! 1. unbonded, or
+//! 2. was actively bonded
+//
+//! in the aforementioned range of eras will be affected by the slash. A member is slashed pro-rata
+//! based on its stake relative to the total slash amount.
+//!
+//! Slashing does not change any single member's balance. Instead, the slash will only reduce the
+//! balance associated with a particular pool. But, we never change the total *points* of a pool
+//! because of slashing. Therefore, when a slash happens, the ratio of points to balance changes in
+//! a pool. In other words, the value of one point, which is initially 1-to-1 against a unit of
+//! balance, is now less than one balance because of the slash.
+//!
+//! ### Administration
+//!
+//! A pool can be created with the [`Call::create`] call. Once created, the pools nominator or root
+//! user must call [`Call::nominate`] to start nominating. [`Call::nominate`] can be called at
+//! anytime to update validator selection.
+//!
+//! Similar to [`Call::nominate`], [`Call::chill`] will chill to pool in the staking system, and
+//! [`Call::pool_withdraw_unbonded`] will withdraw any unbonding chunks of the pool bonded account.
+//! The latter call is permissionless and can be called by anyone at any time.
+//!
+//! To help facilitate pool administration the pool has one of three states (see [`PoolState`]):
+//!
+//! * Open: Anyone can join the pool and no members can be permissionlessly removed.
+//! * Blocked: No members can join and some admin roles can kick members. Kicking is not instant,
+//!   and follows the same process of `unbond` and then `withdraw_unbonded`. In other words,
+//!   administrators can permissionlessly unbond other members.
+//! * Destroying: No members can join and all members can be permissionlessly removed with
+//!   [`Call::unbond`] and [`Call::withdraw_unbonded`]. Once a pool is in destroying state, it
+//!   cannot be reverted to another state.
+//!
+//! A pool has 4 administrative roles (see [`PoolRoles`]):
+//!
+//! * Depositor: creates the pool and is the initial member. They can only leave the pool once all
+//!   other members have left. Once they fully withdraw their funds, the pool is destroyed.
+//! * Nominator: can select which validators the pool nominates.
+//! * Bouncer: can change the pools state and kick members if the pool is blocked.
+//! * Root: can change the nominator, bouncer, or itself, manage and claim commission, and can
+//!   perform any of the actions the nominator or bouncer can.
+//!
+//! ### Commission
+//!
+//! A pool can optionally have a commission configuration, via the `root` role, set with
+//! [`Call::set_commission`] and claimed with [`Call::claim_commission`]. A payee account must be
+//! supplied with the desired commission percentage. Beyond the commission itself, a pool can have a
+//! maximum commission and a change rate.
+//!
+//! Importantly, both max commission  [`Call::set_commission_max`] and change rate
+//! [`Call::set_commission_change_rate`] can not be removed once set, and can only be set to more
+//! restrictive values (i.e. a lower max commission or a slower change rate) in subsequent updates.
+//!
+//! If set, a pool's commission is bound to [`GlobalMaxCommission`] at the time it is applied to
+//! pending rewards. [`GlobalMaxCommission`] is intended to be updated only via governance.
+//!
+//! When a pool is dissolved, any outstanding pending commission that has not been claimed will be
+//! transferred to the depositor.
+//!
+//! Implementation note: Commission is analogous to a separate member account of the pool, with its
+//! own reward counter in the form of `current_pending_commission`.
+//!
+//! Crucially, commission is applied to rewards based on the current commission in effect at the
+//! time rewards are transferred into the reward pool. This is to prevent the malicious behaviour of
+//! changing the commission rate to a very high value after rewards are accumulated, and thus claim
+//! an unexpectedly high chunk of the reward.
+//!
+//! ### Dismantling
+//!
+//! As noted, a pool is destroyed once
+//!
+//! 1. First, all members need to fully unbond and withdraw. If the pool state is set to
+//!    `Destroying`, this can happen permissionlessly.
+//! 2. The depositor itself fully unbonds and withdraws.
+//!
+//! > Note that at this point, based on the requirements of the staking system, the pool's bonded
+//! > account's stake might not be able to ge below a certain threshold as a nominator. At this
+//! > point, the pool should `chill` itself to allow the depositor to leave. See [`Call::chill`].
+//!
+//! ## Implementor's Guide
+//!
+//! Some notes and common mistakes that wallets/apps wishing to implement this pallet should be
+//! aware of:
+//!
+//!
+//! ### Pool Members
+//!
+//! * In general, whenever a pool member changes their total point, the chain will automatically
+//!   claim all their pending rewards for them. This is not optional, and MUST happen for the reward
+//!   calculation to remain correct (see the documentation of `bond` as an example). So, make sure
+//!   you are warning your users about it. They might be surprised if they see that they bonded an
+//!   extra 100 DOTs, and now suddenly their 5.23 DOTs in pending reward is gone. It is not gone, it
+//!   has been paid out to you!
+//! * Joining a pool implies transferring funds to the pool account. So it might be (based on which
+//!   wallet that you are using) that you no longer see the funds that are moved to the pool in your
+//!   “free balance� section. Make sure the user is aware of this, and not surprised by seeing this.
+//!   Also, the transfer that happens here is configured to to never accidentally destroy the sender
+//!   account. So to join a Pool, your sender account must remain alive with 1 DOT left in it. This
+//!   means, with 1 DOT as existential deposit, and 1 DOT as minimum to join a pool, you need at
+//!   least 2 DOT to join a pool. Consequently, if you are suggesting members to join a pool with
+//!   “Maximum possible value�, you must subtract 1 DOT to remain in the sender account to not
+//!   accidentally kill it.
+//! * Points and balance are not the same! Any pool member, at any point in time, can have points in
+//!   either the bonded pool or any of the unbonding pools. The crucial fact is that in any of these
+//!   pools, the ratio of point to balance is different and might not be 1. Each pool starts with a
+//!   ratio of 1, but as time goes on, for reasons such as slashing, the ratio gets broken. Over
+//!   time, 100 points in a bonded pool can be worth 90 DOTs. Make sure you are either representing
+//!   points as points (not as DOTs), or even better, always display both: “You have x points in
+//!   pool y which is worth z DOTs�. See here and here for examples of how to calculate point to
+//!   balance ratio of each pool (it is almost trivial ;))
+//!
+//! ### Pool Management
+//!
+//! * The pool will be seen from the perspective of the rest of the system as a single nominator.
+//!   Ergo, This nominator must always respect the `staking.minNominatorBond` limit. Similar to a
+//!   normal nominator, who has to first `chill` before fully unbonding, the pool must also do the
+//!   same. The pool’s bonded account will be fully unbonded only when the depositor wants to leave
+//!   and dismantle the pool. All that said, the message is: the depositor can only leave the chain
+//!   when they chill the pool first.
+//!
+//! ## Design
+//!
+//! _Notes_: this section uses pseudo code to explain general design and does not necessarily
+//! reflect the exact implementation. Additionally, a working knowledge of `pallet-staking`'s api is
+//! assumed.
+//!
+//! ### Goals
+//!
+//! * Maintain network security by upholding integrity of slashing events, sufficiently penalizing
+//!   members that where in the pool while it was backing a validator that got slashed.
+//! * Maximize scalability in terms of member count.
+//!
+//! In order to maintain scalability, all operations are independent of the number of members. To do
+//! this, delegation specific information is stored local to the member while the pool data
+//! structures have bounded datum.
+//!
+//! ### Bonded pool
+//!
+//! A bonded pool nominates with its total balance, excluding that which has been withdrawn for
+//! unbonding. The total points of a bonded pool are always equal to the sum of points of the
+//! delegation members. A bonded pool tracks its points and reads its bonded balance.
+//!
+//! When a member joins a pool, `amount_transferred` is transferred from the members account to the
+//! bonded pools account. Then the pool calls `staking::bond_extra(amount_transferred)` and issues
+//! new points which are tracked by the member and added to the bonded pool's points.
+//!
+//! When the pool already has some balance, we want the value of a point before the transfer to
+//! equal the value of a point after the transfer. So, when a member joins a bonded pool with a
+//! given `amount_transferred`, we maintain the ratio of bonded balance to points such that:
+//!
+//! ```text
+//! balance_after_transfer / points_after_transfer == balance_before_transfer / points_before_transfer;
+//! ```
+//!
+//! To achieve this, we issue points based on the following:
+//!
+//! ```text
+//! points_issued = (points_before_transfer / balance_before_transfer) * amount_transferred;
+//! ```
+//!
+//! For new bonded pools we can set the points issued per balance arbitrarily. In this
+//! implementation we use a 1 points to 1 balance ratio for pool creation (see
+//! [`POINTS_TO_BALANCE_INIT_RATIO`]).
+//!
+//! **Relevant extrinsics:**
+//!
+//! * [`Call::create`]
+//! * [`Call::join`]
+//!
+//! ### Reward pool
+//!
+//! When a pool is first bonded it sets up a deterministic, inaccessible account as its reward
+//! destination. This reward account combined with `RewardPool` compose a reward pool.
+//!
+//! Reward pools are completely separate entities to bonded pools. Along with its account, a reward
+//! pool also tracks its outstanding and claimed rewards as counters, in addition to pending and
+//! claimed commission. These counters are updated with `RewardPool::update_records`. The current
+//! reward counter of the pool (the total outstanding rewards, in points) is also callable with the
+//! `RewardPool::current_reward_counter` method.
+//!
+//! See [this link](https://hackmd.io/PFGn6wI5TbCmBYoEA_f2Uw) for an in-depth explanation of the
+//! reward pool mechanism.
+//!
+//! **Relevant extrinsics:**
+//!
+//! * [`Call::claim_payout`]
+//!
+//! ### Unbonding sub pools
+//!
+//! When a member unbonds, it's balance is unbonded in the bonded pool's account and tracked in an
+//! unbonding pool associated with the active era. If no such pool exists, one is created. To track
+//! which unbonding sub pool a member belongs too, a member tracks it's `unbonding_era`.
+//!
+//! When a member initiates unbonding it's claim on the bonded pool (`balance_to_unbond`) is
+//! computed as:
+//!
+//! ```text
+//! balance_to_unbond = (bonded_pool.balance / bonded_pool.points) * member.points;
+//! ```
+//!
+//! If this is the first transfer into an unbonding pool arbitrary amount of points can be issued
+//! per balance. In this implementation unbonding pools are initialized with a 1 point to 1 balance
+//! ratio (see [`POINTS_TO_BALANCE_INIT_RATIO`]). Otherwise, the unbonding pools hold the same
+//! points to balance ratio properties as the bonded pool, so member points in the unbonding pool
+//! are issued based on
+//!
+//! ```text
+//! new_points_issued = (points_before_transfer / balance_before_transfer) * balance_to_unbond;
+//! ```
+//!
+//! For scalability, a bound is maintained on the number of unbonding sub pools (see
+//! [`TotalUnbondingPools`]). An unbonding pool is removed once its older than `current_era -
+//! TotalUnbondingPools`. An unbonding pool is merged into the unbonded pool with
+//!
+//! ```text
+//! unbounded_pool.balance = unbounded_pool.balance + unbonding_pool.balance;
+//! unbounded_pool.points = unbounded_pool.points + unbonding_pool.points;
+//! ```
+//!
+//! This scheme "averages" out the points value in the unbonded pool.
+//!
+//! Once a members `unbonding_era` is older than `current_era -
+//! [sp_staking::StakingInterface::bonding_duration]`, it can can cash it's points out of the
+//! corresponding unbonding pool. If it's `unbonding_era` is older than `current_era -
+//! TotalUnbondingPools`, it can cash it's points from the unbonded pool.
+//!
+//! **Relevant extrinsics:**
+//!
+//! * [`Call::unbond`]
+//! * [`Call::withdraw_unbonded`]
+//!
+//! ### Slashing
+//!
+//! This section assumes that the slash computation is executed by
+//! `pallet_staking::StakingLedger::slash`, which passes the information to this pallet via
+//! [`sp_staking::OnStakingUpdate::on_slash`].
+//!
+//! Unbonding pools need to be slashed to ensure all nominators whom where in the bonded pool while
+//! it was backing a validator that equivocated are punished. Without these measures a member could
+//! unbond right after a validator equivocated with no consequences.
+//!
+//! This strategy is unfair to members who joined after the slash, because they get slashed as well,
+//! but spares members who unbond. The latter is much more important for security: if a pool's
+//! validators are attacking the network, their members need to unbond fast! Avoiding slashes gives
+//! them an incentive to do that if validators get repeatedly slashed.
+//!
+//! To be fair to joiners, this implementation also need joining pools, which are actively staking,
+//! in addition to the unbonding pools. For maintenance simplicity these are not implemented.
+//! Related: <https://github.com/paritytech/substrate/issues/10860>
+//!
+//! ### Limitations
+//!
+//! * PoolMembers cannot vote with their staked funds because they are transferred into the pools
+//!   account. In the future this can be overcome by allowing the members to vote with their bonded
+//!   funds via vote splitting.
+//! * PoolMembers cannot quickly transfer to another pool if they do no like nominations, instead
+//!   they must wait for the unbonding duration.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::Codec;
+use frame_support::{
+	defensive, ensure,
+	pallet_prelude::{MaxEncodedLen, *},
+	storage::bounded_btree_map::BoundedBTreeMap,
+	traits::{
+		Currency, Defensive, DefensiveOption, DefensiveResult, DefensiveSaturating,
+		ExistenceRequirement, Get,
+	},
+	DefaultNoBound, PalletError,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use scale_info::TypeInfo;
+use sp_core::U256;
+use sp_runtime::{
+	traits::{
+		AccountIdConversion, Bounded, CheckedAdd, CheckedSub, Convert, Saturating, StaticLookup,
+		Zero,
+	},
+	FixedPointNumber, Perbill,
+};
+use sp_staking::{EraIndex, StakingInterface};
+use sp_std::{collections::btree_map::BTreeMap, fmt::Debug, ops::Div, vec::Vec};
+
+#[cfg(any(feature = "try-runtime", feature = "fuzzing", test, debug_assertions))]
+use sp_runtime::TryRuntimeError;
+
+/// The log target of this pallet.
+pub const LOG_TARGET: &str = "runtime::nomination-pools";
+
+// syntactic sugar for logging.
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: $crate::LOG_TARGET,
+			concat!("[{:?}] ��♂� ", $patter), <frame_system::Pallet<T>>::block_number() $(, $values)*
+		)
+	};
+}
+
+#[cfg(any(test, feature = "fuzzing"))]
+pub mod mock;
+#[cfg(test)]
+mod tests;
+
+pub mod migration;
+pub mod weights;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// The balance type used by the currency system.
+pub type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+/// Type used for unique identifier of each pool.
+pub type PoolId = u32;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+pub const POINTS_TO_BALANCE_INIT_RATIO: u32 = 1;
+
+/// Possible operations on the configuration values of this pallet.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebugNoBound, PartialEq, Clone)]
+pub enum ConfigOp<T: Codec + Debug> {
+	/// Don't change.
+	Noop,
+	/// Set the given value.
+	Set(T),
+	/// Remove from storage.
+	Remove,
+}
+
+/// The type of bonding that can happen to a pool.
+enum BondType {
+	/// Someone is bonding into the pool upon creation.
+	Create,
+	/// Someone is adding more funds later to this pool.
+	Later,
+}
+
+/// How to increase the bond of a member.
+#[derive(Encode, Decode, Clone, Copy, Debug, PartialEq, Eq, TypeInfo)]
+pub enum BondExtra<Balance> {
+	/// Take from the free balance.
+	FreeBalance(Balance),
+	/// Take the entire amount from the accumulated rewards.
+	Rewards,
+}
+
+/// The type of account being created.
+#[derive(Encode, Decode)]
+enum AccountType {
+	Bonded,
+	Reward,
+}
+
+/// The permission a pool member can set for other accounts to claim rewards on their behalf.
+#[derive(Encode, Decode, MaxEncodedLen, Clone, Copy, Debug, PartialEq, Eq, TypeInfo)]
+pub enum ClaimPermission {
+	/// Only the pool member themself can claim their rewards.
+	Permissioned,
+	/// Anyone can compound rewards on a pool member's behalf.
+	PermissionlessCompound,
+	/// Anyone can withdraw rewards on a pool member's behalf.
+	PermissionlessWithdraw,
+	/// Anyone can withdraw and compound rewards on a member's behalf.
+	PermissionlessAll,
+}
+
+impl ClaimPermission {
+	fn can_bond_extra(&self) -> bool {
+		matches!(self, ClaimPermission::PermissionlessAll | ClaimPermission::PermissionlessCompound)
+	}
+
+	fn can_claim_payout(&self) -> bool {
+		matches!(self, ClaimPermission::PermissionlessAll | ClaimPermission::PermissionlessWithdraw)
+	}
+}
+
+impl Default for ClaimPermission {
+	fn default() -> Self {
+		Self::Permissioned
+	}
+}
+
+/// A member in a pool.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebugNoBound, CloneNoBound)]
+#[cfg_attr(feature = "std", derive(frame_support::PartialEqNoBound, DefaultNoBound))]
+#[codec(mel_bound(T: Config))]
+#[scale_info(skip_type_params(T))]
+pub struct PoolMember<T: Config> {
+	/// The identifier of the pool to which `who` belongs.
+	pub pool_id: PoolId,
+	/// The quantity of points this member has in the bonded pool or in a sub pool if
+	/// `Self::unbonding_era` is some.
+	pub points: BalanceOf<T>,
+	/// The reward counter at the time of this member's last payout claim.
+	pub last_recorded_reward_counter: T::RewardCounter,
+	/// The eras in which this member is unbonding, mapped from era index to the number of
+	/// points scheduled to unbond in the given era.
+	pub unbonding_eras: BoundedBTreeMap<EraIndex, BalanceOf<T>, T::MaxUnbonding>,
+}
+
+impl<T: Config> PoolMember<T> {
+	/// The pending rewards of this member.
+	fn pending_rewards(
+		&self,
+		current_reward_counter: T::RewardCounter,
+	) -> Result<BalanceOf<T>, Error<T>> {
+		// accuracy note: Reward counters are `FixedU128` with base of 10^18. This value is being
+		// multiplied by a point. The worse case of a point is 10x the granularity of the balance
+		// (10x is the common configuration of `MaxPointsToBalance`).
+		//
+		// Assuming roughly the current issuance of polkadot (12,047,781,394,999,601,455, which is
+		// 1.2 * 10^9 * 10^10 = 1.2 * 10^19), the worse case point value is around 10^20.
+		//
+		// The final multiplication is:
+		//
+		// rc * 10^20 / 10^18 = rc * 100
+		//
+		// the implementation of `multiply_by_rational_with_rounding` shows that it will only fail
+		// if the final division is not enough to fit in u128. In other words, if `rc * 100` is more
+		// than u128::max. Given that RC is interpreted as reward per unit of point, and unit of
+		// point is equal to balance (normally), and rewards are usually a proportion of the points
+		// in the pool, the likelihood of rc reaching near u128::MAX is near impossible.
+
+		(current_reward_counter.defensive_saturating_sub(self.last_recorded_reward_counter))
+			.checked_mul_int(self.active_points())
+			.ok_or(Error::<T>::OverflowRisk)
+	}
+
+	/// Active balance of the member.
+	///
+	/// This is derived from the ratio of points in the pool to which the member belongs to.
+	/// Might return different values based on the pool state for the same member and points.
+	fn active_balance(&self) -> BalanceOf<T> {
+		if let Some(pool) = BondedPool::<T>::get(self.pool_id).defensive() {
+			pool.points_to_balance(self.points)
+		} else {
+			Zero::zero()
+		}
+	}
+
+	/// Total points of this member, both active and unbonding.
+	fn total_points(&self) -> BalanceOf<T> {
+		self.active_points().saturating_add(self.unbonding_points())
+	}
+
+	/// Active points of the member.
+	fn active_points(&self) -> BalanceOf<T> {
+		self.points
+	}
+
+	/// Inactive points of the member, waiting to be withdrawn.
+	fn unbonding_points(&self) -> BalanceOf<T> {
+		self.unbonding_eras
+			.as_ref()
+			.iter()
+			.fold(BalanceOf::<T>::zero(), |acc, (_, v)| acc.saturating_add(*v))
+	}
+
+	/// Try and unbond `points_dissolved` from self, and in return mint `points_issued` into the
+	/// corresponding `era`'s unlock schedule.
+	///
+	/// In the absence of slashing, these two points are always the same. In the presence of
+	/// slashing, the value of points in different pools varies.
+	///
+	/// Returns `Ok(())` and updates `unbonding_eras` and `points` if success, `Err(_)` otherwise.
+	fn try_unbond(
+		&mut self,
+		points_dissolved: BalanceOf<T>,
+		points_issued: BalanceOf<T>,
+		unbonding_era: EraIndex,
+	) -> Result<(), Error<T>> {
+		if let Some(new_points) = self.points.checked_sub(&points_dissolved) {
+			match self.unbonding_eras.get_mut(&unbonding_era) {
+				Some(already_unbonding_points) =>
+					*already_unbonding_points =
+						already_unbonding_points.saturating_add(points_issued),
+				None => self
+					.unbonding_eras
+					.try_insert(unbonding_era, points_issued)
+					.map(|old| {
+						if old.is_some() {
+							defensive!("value checked to not exist in the map; qed");
+						}
+					})
+					.map_err(|_| Error::<T>::MaxUnbondingLimit)?,
+			}
+			self.points = new_points;
+			Ok(())
+		} else {
+			Err(Error::<T>::MinimumBondNotMet)
+		}
+	}
+
+	/// Withdraw any funds in [`Self::unbonding_eras`] who's deadline in reached and is fully
+	/// unlocked.
+	///
+	/// Returns a a subset of [`Self::unbonding_eras`] that got withdrawn.
+	///
+	/// Infallible, noop if no unbonding eras exist.
+	fn withdraw_unlocked(
+		&mut self,
+		current_era: EraIndex,
+	) -> BoundedBTreeMap<EraIndex, BalanceOf<T>, T::MaxUnbonding> {
+		// NOTE: if only drain-filter was stable..
+		let mut removed_points =
+			BoundedBTreeMap::<EraIndex, BalanceOf<T>, T::MaxUnbonding>::default();
+		self.unbonding_eras.retain(|e, p| {
+			if *e > current_era {
+				true
+			} else {
+				removed_points
+					.try_insert(*e, *p)
+					.expect("source map is bounded, this is a subset, will be bounded; qed");
+				false
+			}
+		});
+		removed_points
+	}
+}
+
+/// A pool's possible states.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, PartialEq, RuntimeDebugNoBound, Clone, Copy)]
+pub enum PoolState {
+	/// The pool is open to be joined, and is working normally.
+	Open,
+	/// The pool is blocked. No one else can join.
+	Blocked,
+	/// The pool is in the process of being destroyed.
+	///
+	/// All members can now be permissionlessly unbonded, and the pool can never go back to any
+	/// other state other than being dissolved.
+	Destroying,
+}
+
+/// Pool administration roles.
+///
+/// Any pool has a depositor, which can never change. But, all the other roles are optional, and
+/// cannot exist. Note that if `root` is set to `None`, it basically means that the roles of this
+/// pool can never change again (except via governance).
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, Debug, PartialEq, Clone)]
+pub struct PoolRoles<AccountId> {
+	/// Creates the pool and is the initial member. They can only leave the pool once all other
+	/// members have left. Once they fully leave, the pool is destroyed.
+	pub depositor: AccountId,
+	/// Can change the nominator, bouncer, or itself and can perform any of the actions the
+	/// nominator or bouncer can.
+	pub root: Option<AccountId>,
+	/// Can select which validators the pool nominates.
+	pub nominator: Option<AccountId>,
+	/// Can change the pools state and kick members if the pool is blocked.
+	pub bouncer: Option<AccountId>,
+}
+
+/// Pool commission.
+///
+/// The pool `root` can set commission configuration after pool creation. By default, all commission
+/// values are `None`. Pool `root` can also set `max` and `change_rate` configurations before
+/// setting an initial `current` commission.
+///
+/// `current` is a tuple of the commission percentage and payee of commission. `throttle_from`
+/// keeps track of which block `current` was last updated. A `max` commission value can only be
+/// decreased after the initial value is set, to prevent commission from repeatedly increasing.
+///
+/// An optional commission `change_rate` allows the pool to set strict limits to how much commission
+/// can change in each update, and how often updates can take place.
+#[derive(
+	Encode, Decode, DefaultNoBound, MaxEncodedLen, TypeInfo, DebugNoBound, PartialEq, Copy, Clone,
+)]
+#[codec(mel_bound(T: Config))]
+#[scale_info(skip_type_params(T))]
+pub struct Commission<T: Config> {
+	/// Optional commission rate of the pool along with the account commission is paid to.
+	pub current: Option<(Perbill, T::AccountId)>,
+	/// Optional maximum commission that can be set by the pool `root`. Once set, this value can
+	/// only be updated to a decreased value.
+	pub max: Option<Perbill>,
+	/// Optional configuration around how often commission can be updated, and when the last
+	/// commission update took place.
+	pub change_rate: Option<CommissionChangeRate<BlockNumberFor<T>>>,
+	/// The block from where throttling should be checked from. This value will be updated on all
+	/// commission updates and when setting an initial `change_rate`.
+	pub throttle_from: Option<BlockNumberFor<T>>,
+}
+
+impl<T: Config> Commission<T> {
+	/// Returns true if the current commission updating to `to` would exhaust the change rate
+	/// limits.
+	///
+	/// A commission update will be throttled (disallowed) if:
+	/// 1. not enough blocks have passed since the `throttle_from` block, if exists, or
+	/// 2. the new commission is greater than the maximum allowed increase.
+	fn throttling(&self, to: &Perbill) -> bool {
+		if let Some(t) = self.change_rate.as_ref() {
+			let commission_as_percent =
+				self.current.as_ref().map(|(x, _)| *x).unwrap_or(Perbill::zero());
+
+			// do not throttle if `to` is the same or a decrease in commission.
+			if *to <= commission_as_percent {
+				return false
+			}
+			// Test for `max_increase` throttling.
+			//
+			// Throttled if the attempted increase in commission is greater than `max_increase`.
+			if (*to).saturating_sub(commission_as_percent) > t.max_increase {
+				return true
+			}
+
+			// Test for `min_delay` throttling.
+			//
+			// Note: matching `None` is defensive only. `throttle_from` should always exist where
+			// `change_rate` has already been set, so this scenario should never happen.
+			return self.throttle_from.map_or_else(
+				|| {
+					defensive!("throttle_from should exist if change_rate is set");
+					true
+				},
+				|f| {
+					// if `min_delay` is zero (no delay), not throttling.
+					if t.min_delay == Zero::zero() {
+						false
+					} else {
+						// throttling if blocks passed is less than `min_delay`.
+						let blocks_surpassed =
+							<frame_system::Pallet<T>>::block_number().saturating_sub(f);
+						blocks_surpassed < t.min_delay
+					}
+				},
+			)
+		}
+		false
+	}
+
+	/// Gets the pool's current commission, or returns Perbill::zero if none is set.
+	/// Bounded to global max if current is greater than `GlobalMaxCommission`.
+	fn current(&self) -> Perbill {
+		self.current
+			.as_ref()
+			.map_or(Perbill::zero(), |(c, _)| *c)
+			.min(GlobalMaxCommission::<T>::get().unwrap_or(Bounded::max_value()))
+	}
+
+	/// Set the pool's commission.
+	///
+	/// Update commission based on `current`. If a `None` is supplied, allow the commission to be
+	/// removed without any change rate restrictions. Updates `throttle_from` to the current block.
+	/// If the supplied commission is zero, `None` will be inserted and `payee` will be ignored.
+	fn try_update_current(&mut self, current: &Option<(Perbill, T::AccountId)>) -> DispatchResult {
+		self.current = match current {
+			None => None,
+			Some((commission, payee)) => {
+				ensure!(!self.throttling(commission), Error::<T>::CommissionChangeThrottled);
+				ensure!(
+					commission <= &GlobalMaxCommission::<T>::get().unwrap_or(Bounded::max_value()),
+					Error::<T>::CommissionExceedsGlobalMaximum
+				);
+				ensure!(
+					self.max.map_or(true, |m| commission <= &m),
+					Error::<T>::CommissionExceedsMaximum
+				);
+				if commission.is_zero() {
+					None
+				} else {
+					Some((*commission, payee.clone()))
+				}
+			},
+		};
+		self.register_update();
+		Ok(())
+	}
+
+	/// Set the pool's maximum commission.
+	///
+	/// The pool's maximum commission can initially be set to any value, and only smaller values
+	/// thereafter. If larger values are attempted, this function will return a dispatch error.
+	///
+	/// If `current.0` is larger than the updated max commission value, `current.0` will also be
+	/// updated to the new maximum. This will also register a `throttle_from` update.
+	/// A `PoolCommissionUpdated` event is triggered if `current.0` is updated.
+	fn try_update_max(&mut self, pool_id: PoolId, new_max: Perbill) -> DispatchResult {
+		ensure!(
+			new_max <= GlobalMaxCommission::<T>::get().unwrap_or(Bounded::max_value()),
+			Error::<T>::CommissionExceedsGlobalMaximum
+		);
+		if let Some(old) = self.max.as_mut() {
+			if new_max > *old {
+				return Err(Error::<T>::MaxCommissionRestricted.into())
+			}
+			*old = new_max;
+		} else {
+			self.max = Some(new_max)
+		};
+		let updated_current = self
+			.current
+			.as_mut()
+			.map(|(c, _)| {
+				let u = *c > new_max;
+				*c = (*c).min(new_max);
+				u
+			})
+			.unwrap_or(false);
+
+		if updated_current {
+			if let Some((_, payee)) = self.current.as_ref() {
+				Pallet::<T>::deposit_event(Event::<T>::PoolCommissionUpdated {
+					pool_id,
+					current: Some((new_max, payee.clone())),
+				});
+			}
+			self.register_update();
+		}
+		Ok(())
+	}
+
+	/// Set the pool's commission `change_rate`.
+	///
+	/// Once a change rate configuration has been set, only more restrictive values can be set
+	/// thereafter. These restrictions translate to increased `min_delay` values and decreased
+	/// `max_increase` values.
+	///
+	/// Update `throttle_from` to the current block upon setting change rate for the first time, so
+	/// throttling can be checked from this block.
+	fn try_update_change_rate(
+		&mut self,
+		change_rate: CommissionChangeRate<BlockNumberFor<T>>,
+	) -> DispatchResult {
+		ensure!(!&self.less_restrictive(&change_rate), Error::<T>::CommissionChangeRateNotAllowed);
+
+		if self.change_rate.is_none() {
+			self.register_update();
+		}
+		self.change_rate = Some(change_rate);
+		Ok(())
+	}
+
+	/// Updates a commission's `throttle_from` field to the current block.
+	fn register_update(&mut self) {
+		self.throttle_from = Some(<frame_system::Pallet<T>>::block_number());
+	}
+
+	/// Checks whether a change rate is less restrictive than the current change rate, if any.
+	///
+	/// No change rate will always be less restrictive than some change rate, so where no
+	/// `change_rate` is currently set, `false` is returned.
+	fn less_restrictive(&self, new: &CommissionChangeRate<BlockNumberFor<T>>) -> bool {
+		self.change_rate
+			.as_ref()
+			.map(|c| new.max_increase > c.max_increase || new.min_delay < c.min_delay)
+			.unwrap_or(false)
+	}
+}
+
+/// Pool commission change rate preferences.
+///
+/// The pool root is able to set a commission change rate for their pool. A commission change rate
+/// consists of 2 values; (1) the maximum allowed commission change, and (2) the minimum amount of
+/// blocks that must elapse before commission updates are allowed again.
+///
+/// Commission change rates are not applied to decreases in commission.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, Debug, PartialEq, Copy, Clone)]
+pub struct CommissionChangeRate<BlockNumber> {
+	/// The maximum amount the commission can be updated by per `min_delay` period.
+	pub max_increase: Perbill,
+	/// How often an update can take place.
+	pub min_delay: BlockNumber,
+}
+
+/// Pool permissions and state
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, DebugNoBound, PartialEq, Clone)]
+#[codec(mel_bound(T: Config))]
+#[scale_info(skip_type_params(T))]
+pub struct BondedPoolInner<T: Config> {
+	/// The commission rate of the pool.
+	pub commission: Commission<T>,
+	/// Count of members that belong to the pool.
+	pub member_counter: u32,
+	/// Total points of all the members in the pool who are actively bonded.
+	pub points: BalanceOf<T>,
+	/// See [`PoolRoles`].
+	pub roles: PoolRoles<T::AccountId>,
+	/// The current state of the pool.
+	pub state: PoolState,
+}
+
+/// A wrapper for bonded pools, with utility functions.
+///
+/// The main purpose of this is to wrap a [`BondedPoolInner`], with the account
+/// + id of the pool, for easier access.
+#[derive(RuntimeDebugNoBound)]
+#[cfg_attr(feature = "std", derive(Clone, PartialEq))]
+pub struct BondedPool<T: Config> {
+	/// The identifier of the pool.
+	id: PoolId,
+	/// The inner fields.
+	inner: BondedPoolInner<T>,
+}
+
+impl<T: Config> sp_std::ops::Deref for BondedPool<T> {
+	type Target = BondedPoolInner<T>;
+	fn deref(&self) -> &Self::Target {
+		&self.inner
+	}
+}
+
+impl<T: Config> sp_std::ops::DerefMut for BondedPool<T> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.inner
+	}
+}
+
+impl<T: Config> BondedPool<T> {
+	/// Create a new bonded pool with the given roles and identifier.
+	fn new(id: PoolId, roles: PoolRoles<T::AccountId>) -> Self {
+		Self {
+			id,
+			inner: BondedPoolInner {
+				commission: Commission::default(),
+				member_counter: Zero::zero(),
+				points: Zero::zero(),
+				roles,
+				state: PoolState::Open,
+			},
+		}
+	}
+
+	/// Get [`Self`] from storage. Returns `None` if no entry for `pool_account` exists.
+	pub fn get(id: PoolId) -> Option<Self> {
+		BondedPools::<T>::try_get(id).ok().map(|inner| Self { id, inner })
+	}
+
+	/// Get the bonded account id of this pool.
+	fn bonded_account(&self) -> T::AccountId {
+		Pallet::<T>::create_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)
+	}
+
+	/// Consume self and put into storage.
+	fn put(self) {
+		BondedPools::<T>::insert(self.id, self.inner);
+	}
+
+	/// Consume self and remove from storage.
+	fn remove(self) {
+		BondedPools::<T>::remove(self.id);
+	}
+
+	/// Convert the given amount of balance to points given the current pool state.
+	///
+	/// 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());
+		Pallet::<T>::balance_to_point(bonded_balance, self.points, new_funds)
+	}
+
+	/// Convert the given number of points to balance given the current pool state.
+	///
+	/// 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());
+		Pallet::<T>::point_to_balance(bonded_balance, self.points, points)
+	}
+
+	/// Issue points to [`Self`] for `new_funds`.
+	fn issue(&mut self, new_funds: BalanceOf<T>) -> BalanceOf<T> {
+		let points_to_issue = self.balance_to_point(new_funds);
+		self.points = self.points.saturating_add(points_to_issue);
+		points_to_issue
+	}
+
+	/// Dissolve some points from the pool i.e. unbond the given amount of points from this pool.
+	/// This is the opposite of issuing some funds into the pool.
+	///
+	/// Mutates self in place, but does not write anything to storage.
+	///
+	/// Returns the equivalent balance amount that actually needs to get unbonded.
+	fn dissolve(&mut self, points: BalanceOf<T>) -> BalanceOf<T> {
+		// NOTE: do not optimize by removing `balance`. it must be computed before mutating
+		// `self.point`.
+		let balance = self.points_to_balance(points);
+		self.points = self.points.saturating_sub(points);
+		balance
+	}
+
+	/// Increment the member counter. Ensures that the pool and system member limits are
+	/// respected.
+	fn try_inc_members(&mut self) -> Result<(), DispatchError> {
+		ensure!(
+			MaxPoolMembersPerPool::<T>::get()
+				.map_or(true, |max_per_pool| self.member_counter < max_per_pool),
+			Error::<T>::MaxPoolMembers
+		);
+		ensure!(
+			MaxPoolMembers::<T>::get().map_or(true, |max| PoolMembers::<T>::count() < max),
+			Error::<T>::MaxPoolMembers
+		);
+		self.member_counter = self.member_counter.checked_add(1).ok_or(Error::<T>::OverflowRisk)?;
+		Ok(())
+	}
+
+	/// Decrement the member counter.
+	fn dec_members(mut self) -> Self {
+		self.member_counter = self.member_counter.defensive_saturating_sub(1);
+		self
+	}
+
+	/// The pools balance that is transferrable.
+	fn transferrable_balance(&self) -> BalanceOf<T> {
+		let account = self.bonded_account();
+		T::Currency::free_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)
+	}
+
+	fn is_bouncer(&self, who: &T::AccountId) -> bool {
+		self.roles.bouncer.as_ref().map_or(false, |bouncer| bouncer == who)
+	}
+
+	fn can_update_roles(&self, who: &T::AccountId) -> bool {
+		self.is_root(who)
+	}
+
+	fn can_nominate(&self, who: &T::AccountId) -> bool {
+		self.is_root(who) ||
+			self.roles.nominator.as_ref().map_or(false, |nominator| nominator == who)
+	}
+
+	fn can_kick(&self, who: &T::AccountId) -> bool {
+		self.state == PoolState::Blocked && (self.is_root(who) || self.is_bouncer(who))
+	}
+
+	fn can_toggle_state(&self, who: &T::AccountId) -> bool {
+		(self.is_root(who) || self.is_bouncer(who)) && !self.is_destroying()
+	}
+
+	fn can_set_metadata(&self, who: &T::AccountId) -> bool {
+		self.is_root(who) || self.is_bouncer(who)
+	}
+
+	fn can_manage_commission(&self, who: &T::AccountId) -> bool {
+		self.is_root(who)
+	}
+
+	fn is_destroying(&self) -> bool {
+		matches!(self.state, PoolState::Destroying)
+	}
+
+	fn is_destroying_and_only_depositor(&self, alleged_depositor_points: BalanceOf<T>) -> bool {
+		// we need to ensure that `self.member_counter == 1` as well, because the depositor's
+		// initial `MinCreateBond` (or more) is what guarantees that the ledger of the pool does not
+		// get killed in the staking system, and that it does not fall below `MinimumNominatorBond`,
+		// which could prevent other non-depositor members from fully leaving. Thus, all members
+		// must withdraw, then depositor can unbond, and finally withdraw after waiting another
+		// cycle.
+		self.is_destroying() && self.points == alleged_depositor_points && self.member_counter == 1
+	}
+
+	/// Whether or not the pool is ok to be in `PoolSate::Open`. If this returns an `Err`, then the
+	/// pool is unrecoverable and should be in the destroying state.
+	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());
+		ensure!(!bonded_balance.is_zero(), Error::<T>::OverflowRisk);
+
+		let points_to_balance_ratio_floor = self
+			.points
+			// We checked for zero above
+			.div(bonded_balance);
+
+		let max_points_to_balance = T::MaxPointsToBalance::get();
+
+		// Pool points can inflate relative to balance, but only if the pool is slashed.
+		// If we cap the ratio of points:balance so one cannot join a pool that has been slashed
+		// by `max_points_to_balance`%, if not zero.
+		ensure!(
+			points_to_balance_ratio_floor < max_points_to_balance.into(),
+			Error::<T>::OverflowRisk
+		);
+
+		// then we can be decently confident the bonding pool points will not overflow
+		// `BalanceOf<T>`. Note that these are just heuristics.
+
+		Ok(())
+	}
+
+	/// Check that the pool can accept a member with `new_funds`.
+	fn ok_to_join(&self) -> Result<(), DispatchError> {
+		ensure!(self.state == PoolState::Open, Error::<T>::NotOpen);
+		self.ok_to_be_open()?;
+		Ok(())
+	}
+
+	fn ok_to_unbond_with(
+		&self,
+		caller: &T::AccountId,
+		target_account: &T::AccountId,
+		target_member: &PoolMember<T>,
+		unbonding_points: BalanceOf<T>,
+	) -> Result<(), DispatchError> {
+		let is_permissioned = caller == target_account;
+		let is_depositor = *target_account == self.roles.depositor;
+		let is_full_unbond = unbonding_points == target_member.active_points();
+
+		let balance_after_unbond = {
+			let new_depositor_points =
+				target_member.active_points().saturating_sub(unbonding_points);
+			let mut target_member_after_unbond = (*target_member).clone();
+			target_member_after_unbond.points = new_depositor_points;
+			target_member_after_unbond.active_balance()
+		};
+
+		// any partial unbonding is only ever allowed if this unbond is permissioned.
+		ensure!(
+			is_permissioned || is_full_unbond,
+			Error::<T>::PartialUnbondNotAllowedPermissionlessly
+		);
+
+		// any unbond must comply with the balance condition:
+		ensure!(
+			is_full_unbond ||
+				balance_after_unbond >=
+					if is_depositor {
+						Pallet::<T>::depositor_min_bond()
+					} else {
+						MinJoinBond::<T>::get()
+					},
+			Error::<T>::MinimumBondNotMet
+		);
+
+		// additional checks:
+		match (is_permissioned, is_depositor) {
+			(true, false) => (),
+			(true, true) => {
+				// permission depositor unbond: if destroying and pool is empty, always allowed,
+				// with no additional limits.
+				if self.is_destroying_and_only_depositor(target_member.active_points()) {
+					// everything good, let them unbond anything.
+				} else {
+					// depositor cannot fully unbond yet.
+					ensure!(!is_full_unbond, Error::<T>::MinimumBondNotMet);
+				}
+			},
+			(false, false) => {
+				// If the pool is blocked, then an admin with kicking permissions can remove a
+				// member. If the pool is being destroyed, anyone can remove a member
+				debug_assert!(is_full_unbond);
+				ensure!(
+					self.can_kick(caller) || self.is_destroying(),
+					Error::<T>::NotKickerOrDestroying
+				)
+			},
+			(false, true) => {
+				// the depositor can simply not be unbonded permissionlessly, period.
+				return Err(Error::<T>::DoesNotHavePermission.into())
+			},
+		};
+
+		Ok(())
+	}
+
+	/// # Returns
+	///
+	/// * Ok(()) if [`Call::withdraw_unbonded`] can be called, `Err(DispatchError)` otherwise.
+	fn ok_to_withdraw_unbonded_with(
+		&self,
+		caller: &T::AccountId,
+		target_account: &T::AccountId,
+	) -> Result<(), DispatchError> {
+		// This isn't a depositor
+		let is_permissioned = caller == target_account;
+		ensure!(
+			is_permissioned || self.can_kick(caller) || self.is_destroying(),
+			Error::<T>::NotKickerOrDestroying
+		);
+		Ok(())
+	}
+
+	/// Bond exactly `amount` from `who`'s funds into this pool.
+	///
+	/// If the bond type is `Create`, `Staking::bond` is called, and `who`
+	/// is allowed to be killed. Otherwise, `Staking::bond_extra` is called and `who`
+	/// cannot be killed.
+	///
+	/// Returns `Ok(points_issues)`, `Err` otherwise.
+	fn try_bond_funds(
+		&mut self,
+		who: &T::AccountId,
+		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 => ExistenceRequirement::AllowDeath,
+				BondType::Later => ExistenceRequirement::KeepAlive,
+			},
+		)?;
+		// 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)?,
+		}
+
+		Ok(points_issued)
+	}
+
+	// Set the state of `self`, and deposit an event if the state changed. State should never be set
+	// directly in in order to ensure a state change event is always correctly deposited.
+	fn set_state(&mut self, state: PoolState) {
+		if self.state != state {
+			self.state = state;
+			Pallet::<T>::deposit_event(Event::<T>::StateChanged {
+				pool_id: self.id,
+				new_state: state,
+			});
+		};
+	}
+}
+
+/// A reward pool.
+///
+/// A reward pool is not so much a pool anymore, since it does not contain any shares or points.
+/// Rather, simply to fit nicely next to bonded pool and unbonding pools in terms of terminology. In
+/// reality, a reward pool is just a container for a few pool-dependent data related to the rewards.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, RuntimeDebugNoBound)]
+#[cfg_attr(feature = "std", derive(Clone, PartialEq, DefaultNoBound))]
+#[codec(mel_bound(T: Config))]
+#[scale_info(skip_type_params(T))]
+pub struct RewardPool<T: Config> {
+	/// The last recorded value of the reward counter.
+	///
+	/// This is updated ONLY when the points in the bonded pool change, which means `join`,
+	/// `bond_extra` and `unbond`, all of which is done through `update_recorded`.
+	last_recorded_reward_counter: T::RewardCounter,
+	/// The last recorded total payouts of the reward pool.
+	///
+	/// Payouts is essentially income of the pool.
+	///
+	/// Update criteria is same as that of `last_recorded_reward_counter`.
+	last_recorded_total_payouts: BalanceOf<T>,
+	/// Total amount that this pool has paid out so far to the members.
+	total_rewards_claimed: BalanceOf<T>,
+	/// The amount of commission pending to be claimed.
+	total_commission_pending: BalanceOf<T>,
+	/// The amount of commission that has been claimed.
+	total_commission_claimed: BalanceOf<T>,
+}
+
+impl<T: Config> RewardPool<T> {
+	/// Getter for [`RewardPool::last_recorded_reward_counter`].
+	pub(crate) fn last_recorded_reward_counter(&self) -> T::RewardCounter {
+		self.last_recorded_reward_counter
+	}
+
+	/// Register some rewards that are claimed from the pool by the members.
+	fn register_claimed_reward(&mut self, reward: BalanceOf<T>) {
+		self.total_rewards_claimed = self.total_rewards_claimed.saturating_add(reward);
+	}
+
+	/// Update the recorded values of the reward pool.
+	///
+	/// This function MUST be called whenever the points in the bonded pool change, AND whenever the
+	/// the pools commission is updated. The reason for the former is that a change in pool points
+	/// will alter the share of the reward balance among pool members, and the reason for the latter
+	/// is that a change in commission will alter the share of the reward balance among the pool.
+	fn update_records(
+		&mut self,
+		id: PoolId,
+		bonded_points: BalanceOf<T>,
+		commission: Perbill,
+	) -> Result<(), Error<T>> {
+		let balance = Self::current_balance(id);
+
+		let (current_reward_counter, new_pending_commission) =
+			self.current_reward_counter(id, bonded_points, commission)?;
+
+		// Store the reward counter at the time of this update. This is used in subsequent calls to
+		// `current_reward_counter`, whereby newly pending rewards (in points) are added to this
+		// value.
+		self.last_recorded_reward_counter = current_reward_counter;
+
+		// Add any new pending commission that has been calculated from `current_reward_counter` to
+		// determine the total pending commission at the time of this update.
+		self.total_commission_pending =
+			self.total_commission_pending.saturating_add(new_pending_commission);
+
+		// Store the total payouts at the time of this update. Total payouts are essentially the
+		// entire historical balance of the reward pool, equating to the current balance + the total
+		// rewards that have left the pool + the total commission that has left the pool.
+		self.last_recorded_total_payouts = balance
+			.checked_add(&self.total_rewards_claimed.saturating_add(self.total_commission_claimed))
+			.ok_or(Error::<T>::OverflowRisk)?;
+
+		Ok(())
+	}
+
+	/// Get the current reward counter, based on the given `bonded_points` being the state of the
+	/// bonded pool at this time.
+	fn current_reward_counter(
+		&self,
+		id: PoolId,
+		bonded_points: BalanceOf<T>,
+		commission: Perbill,
+	) -> Result<(T::RewardCounter, BalanceOf<T>), Error<T>> {
+		let balance = Self::current_balance(id);
+
+		// Calculate the current payout balance. The first 3 values of this calculation added
+		// together represent what the balance would be if no payouts were made. The
+		// `last_recorded_total_payouts` is then subtracted from this value to cancel out previously
+		// recorded payouts, leaving only the remaining payouts that have not been claimed.
+		let current_payout_balance = balance
+			.saturating_add(self.total_rewards_claimed)
+			.saturating_add(self.total_commission_claimed)
+			.saturating_sub(self.last_recorded_total_payouts);
+
+		// Split the `current_payout_balance` into claimable rewards and claimable commission
+		// according to the current commission rate.
+		let new_pending_commission = commission * current_payout_balance;
+		let new_pending_rewards = current_payout_balance.saturating_sub(new_pending_commission);
+
+		// * accuracy notes regarding the multiplication in `checked_from_rational`:
+		// `current_payout_balance` is a subset of the total_issuance at the very worse.
+		// `bonded_points` are similarly, in a non-slashed pool, have the same granularity as
+		// balance, and are thus below within the range of total_issuance. In the worse case
+		// scenario, for `saturating_from_rational`, we have:
+		//
+		// dot_total_issuance * 10^18 / `minJoinBond`
+		//
+		// assuming `MinJoinBond == ED`
+		//
+		// dot_total_issuance * 10^18 / 10^10 = dot_total_issuance * 10^8
+		//
+		// which, with the current numbers, is a miniscule fraction of the u128 capacity.
+		//
+		// Thus, adding two values of type reward counter should be safe for ages in a chain like
+		// Polkadot. The important note here is that `reward_pool.last_recorded_reward_counter` only
+		// ever accumulates, but its semantics imply that it is less than total_issuance, when
+		// represented as `FixedU128`, which means it is less than `total_issuance * 10^18`.
+		//
+		// * accuracy notes regarding `checked_from_rational` collapsing to zero, meaning that no
+		//   reward can be claimed:
+		//
+		// largest `bonded_points`, such that the reward counter is non-zero, with `FixedU128` will
+		// be when the payout is being computed. This essentially means `payout/bonded_points` needs
+		// to be more than 1/1^18. Thus, assuming that `bonded_points` will always be less than `10
+		// * dot_total_issuance`, if the reward_counter is the smallest possible value, the value of
+		//   the
+		// reward being calculated is:
+		//
+		// x / 10^20 = 1/ 10^18
+		//
+		// x = 100
+		//
+		// which is basically 10^-8 DOTs. See `smallest_claimable_reward` for an example of this.
+		let current_reward_counter =
+			T::RewardCounter::checked_from_rational(new_pending_rewards, bonded_points)
+				.and_then(|ref r| self.last_recorded_reward_counter.checked_add(r))
+				.ok_or(Error::<T>::OverflowRisk)?;
+
+		Ok((current_reward_counter, new_pending_commission))
+	}
+
+	/// Current free balance of the reward pool.
+	///
+	/// This is sum of all the rewards that are claimable by pool members.
+	fn current_balance(id: PoolId) -> BalanceOf<T> {
+		T::Currency::free_balance(&Pallet::<T>::create_reward_account(id))
+			.saturating_sub(T::Currency::minimum_balance())
+	}
+}
+
+/// An unbonding pool. This is always mapped with an era.
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, DefaultNoBound, RuntimeDebugNoBound)]
+#[cfg_attr(feature = "std", derive(Clone, PartialEq, Eq))]
+#[codec(mel_bound(T: Config))]
+#[scale_info(skip_type_params(T))]
+pub struct UnbondPool<T: Config> {
+	/// The points in this pool.
+	points: BalanceOf<T>,
+	/// The funds in the pool.
+	balance: BalanceOf<T>,
+}
+
+impl<T: Config> UnbondPool<T> {
+	fn balance_to_point(&self, new_funds: BalanceOf<T>) -> BalanceOf<T> {
+		Pallet::<T>::balance_to_point(self.balance, self.points, new_funds)
+	}
+
+	fn point_to_balance(&self, points: BalanceOf<T>) -> BalanceOf<T> {
+		Pallet::<T>::point_to_balance(self.balance, self.points, points)
+	}
+
+	/// Issue the equivalent points of `new_funds` into self.
+	///
+	/// Returns the actual amounts of points issued.
+	fn issue(&mut self, new_funds: BalanceOf<T>) -> BalanceOf<T> {
+		let new_points = self.balance_to_point(new_funds);
+		self.points = self.points.saturating_add(new_points);
+		self.balance = self.balance.saturating_add(new_funds);
+		new_points
+	}
+
+	/// Dissolve some points from the unbonding pool, reducing the balance of the pool
+	/// proportionally.
+	///
+	/// This is the opposite of `issue`.
+	///
+	/// Returns the actual amount of `Balance` that was removed from the pool.
+	fn dissolve(&mut self, points: BalanceOf<T>) -> BalanceOf<T> {
+		let balance_to_unbond = self.point_to_balance(points);
+		self.points = self.points.saturating_sub(points);
+		self.balance = self.balance.saturating_sub(balance_to_unbond);
+
+		balance_to_unbond
+	}
+}
+
+#[derive(Encode, Decode, MaxEncodedLen, TypeInfo, DefaultNoBound, RuntimeDebugNoBound)]
+#[cfg_attr(feature = "std", derive(Clone, PartialEq))]
+#[codec(mel_bound(T: Config))]
+#[scale_info(skip_type_params(T))]
+pub struct SubPools<T: Config> {
+	/// A general, era agnostic pool of funds that have fully unbonded. The pools
+	/// of `Self::with_era` will lazily be merged into into this pool if they are
+	/// older then `current_era - TotalUnbondingPools`.
+	no_era: UnbondPool<T>,
+	/// Map of era in which a pool becomes unbonded in => unbond pools.
+	with_era: BoundedBTreeMap<EraIndex, UnbondPool<T>, TotalUnbondingPools<T>>,
+}
+
+impl<T: Config> SubPools<T> {
+	/// Merge the oldest `with_era` unbond pools into the `no_era` unbond pool.
+	///
+	/// This is often used whilst getting the sub-pool from storage, thus it consumes and returns
+	/// `Self` for ergonomic purposes.
+	fn maybe_merge_pools(mut self, current_era: EraIndex) -> Self {
+		// Ex: if `TotalUnbondingPools` is 5 and current era is 10, we only want to retain pools
+		// 6..=10. Note that in the first few eras where `checked_sub` is `None`, we don't remove
+		// anything.
+		if let Some(newest_era_to_remove) =
+			current_era.checked_sub(T::PostUnbondingPoolsWindow::get())
+		{
+			self.with_era.retain(|k, v| {
+				if *k > newest_era_to_remove {
+					// keep
+					true
+				} else {
+					// merge into the no-era pool
+					self.no_era.points = self.no_era.points.saturating_add(v.points);
+					self.no_era.balance = self.no_era.balance.saturating_add(v.balance);
+					false
+				}
+			});
+		}
+
+		self
+	}
+
+	/// The sum of all unbonding balance, regardless of whether they are actually unlocked or not.
+	#[cfg(any(feature = "try-runtime", feature = "fuzzing", test, debug_assertions))]
+	fn sum_unbonding_balance(&self) -> BalanceOf<T> {
+		self.no_era.balance.saturating_add(
+			self.with_era
+				.values()
+				.fold(BalanceOf::<T>::zero(), |acc, pool| acc.saturating_add(pool.balance)),
+		)
+	}
+}
+
+/// The maximum amount of eras an unbonding pool can exist prior to being merged with the
+/// `no_era` pool. This is guaranteed to at least be equal to the staking `UnbondingDuration`. For
+/// improved UX [`Config::PostUnbondingPoolsWindow`] should be configured to a non-zero value.
+pub struct TotalUnbondingPools<T: Config>(PhantomData<T>);
+impl<T: Config> Get<u32> for TotalUnbondingPools<T> {
+	fn get() -> u32 {
+		// 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()
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::traits::StorageVersion;
+	use frame_system::{ensure_signed, pallet_prelude::*};
+	use sp_runtime::Perbill;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(5);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: weights::WeightInfo;
+
+		/// The nominating balance.
+		type Currency: Currency<Self::AccountId>;
+
+		/// The type that is used for reward counter.
+		///
+		/// The arithmetic of the reward counter might saturate based on the size of the
+		/// `Currency::Balance`. If this happens, operations fails. Nonetheless, this type should be
+		/// chosen such that this failure almost never happens, as if it happens, the pool basically
+		/// needs to be dismantled (or all pools migrated to a larger `RewardCounter` type, which is
+		/// a PITA to do).
+		///
+		/// See the inline code docs of `Member::pending_rewards` and `RewardPool::update_recorded`
+		/// for example analysis. A [`sp_runtime::FixedU128`] should be fine for chains with balance
+		/// types similar to that of Polkadot and Kusama, in the absence of severe slashing (or
+		/// prevented via a reasonable `MaxPointsToBalance`), for many many years to come.
+		type RewardCounter: FixedPointNumber + MaxEncodedLen + TypeInfo + Default + codec::FullCodec;
+
+		/// The nomination pool's pallet id.
+		#[pallet::constant]
+		type PalletId: Get<frame_support::PalletId>;
+
+		/// The maximum pool points-to-balance ratio that an `open` pool can have.
+		///
+		/// This is important in the event slashing takes place and the pool's points-to-balance
+		/// ratio becomes disproportional.
+		///
+		/// Moreover, this relates to the `RewardCounter` type as well, as the arithmetic operations
+		/// are a function of number of points, and by setting this value to e.g. 10, you ensure
+		/// that the total number of points in the system are at most 10 times the total_issuance of
+		/// the chain, in the absolute worse case.
+		///
+		/// For a value of 10, the threshold would be a pool points-to-balance ratio of 10:1.
+		/// Such a scenario would also be the equivalent of the pool being 90% slashed.
+		#[pallet::constant]
+		type MaxPointsToBalance: Get<u8>;
+
+		/// Infallible method for converting `Currency::Balance` to `U256`.
+		type BalanceToU256: Convert<BalanceOf<Self>, U256>;
+
+		/// Infallible method for converting `U256` to `Currency::Balance`.
+		type U256ToBalance: Convert<U256, BalanceOf<Self>>;
+
+		/// The interface for nominating.
+		type Staking: StakingInterface<Balance = BalanceOf<Self>, AccountId = Self::AccountId>;
+
+		/// 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
+		/// able to withdraw from an unbonding pool which is guaranteed to have the correct ratio of
+		/// points to balance; once the `with_era` pool is merged into the `no_era` pool, the ratio
+		/// can become skewed due to some slashed ratio getting merged in at some point.
+		type PostUnbondingPoolsWindow: Get<u32>;
+
+		/// The maximum length, in bytes, that a pools metadata maybe.
+		type MaxMetadataLen: Get<u32>;
+
+		/// The maximum number of simultaneous unbonding chunks that can exist per member.
+		type MaxUnbonding: Get<u32>;
+	}
+
+	/// Minimum amount to bond to join a pool.
+	#[pallet::storage]
+	pub type MinJoinBond<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
+
+	/// Minimum bond required to create a pool.
+	///
+	/// This is the amount that the depositor must put as their initial stake in the pool, as an
+	/// indication of "skin in the game".
+	///
+	/// This is the value that will always exist in the staking ledger of the pool bonded account
+	/// while all other accounts leave.
+	#[pallet::storage]
+	pub type MinCreateBond<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
+
+	/// Maximum number of nomination pools that can exist. If `None`, then an unbounded number of
+	/// pools can exist.
+	#[pallet::storage]
+	pub type MaxPools<T: Config> = StorageValue<_, u32, OptionQuery>;
+
+	/// Maximum number of members that can exist in the system. If `None`, then the count
+	/// members are not bound on a system wide basis.
+	#[pallet::storage]
+	pub type MaxPoolMembers<T: Config> = StorageValue<_, u32, OptionQuery>;
+
+	/// Maximum number of members that may belong to pool. If `None`, then the count of
+	/// members is not bound on a per pool basis.
+	#[pallet::storage]
+	pub type MaxPoolMembersPerPool<T: Config> = StorageValue<_, u32, OptionQuery>;
+
+	/// The maximum commission that can be charged by a pool. Used on commission payouts to bound
+	/// pool commissions that are > `GlobalMaxCommission`, necessary if a future
+	/// `GlobalMaxCommission` is lower than some current pool commissions.
+	#[pallet::storage]
+	pub type GlobalMaxCommission<T: Config> = StorageValue<_, Perbill, OptionQuery>;
+
+	/// Active members.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+	#[pallet::storage]
+	pub type PoolMembers<T: Config> =
+		CountedStorageMap<_, Twox64Concat, T::AccountId, PoolMember<T>>;
+
+	/// Storage for bonded pools.
+	// To get or insert a pool see [`BondedPool::get`] and [`BondedPool::put`]
+	#[pallet::storage]
+	pub type BondedPools<T: Config> =
+		CountedStorageMap<_, Twox64Concat, PoolId, BondedPoolInner<T>>;
+
+	/// Reward pools. This is where there rewards for each pool accumulate. When a members payout is
+	/// claimed, the balance comes out fo the reward pool. Keyed by the bonded pools account.
+	#[pallet::storage]
+	pub type RewardPools<T: Config> = CountedStorageMap<_, Twox64Concat, PoolId, RewardPool<T>>;
+
+	/// Groups of unbonding pools. Each group of unbonding pools belongs to a
+	/// bonded pool, hence the name sub-pools. Keyed by the bonded pools account.
+	#[pallet::storage]
+	pub type SubPoolsStorage<T: Config> = CountedStorageMap<_, Twox64Concat, PoolId, SubPools<T>>;
+
+	/// Metadata for the pool.
+	#[pallet::storage]
+	pub type Metadata<T: Config> =
+		CountedStorageMap<_, Twox64Concat, PoolId, BoundedVec<u8, T::MaxMetadataLen>, ValueQuery>;
+
+	/// Ever increasing number of all pools created so far.
+	#[pallet::storage]
+	pub type LastPoolId<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	/// A reverse lookup from the pool's account id to its id.
+	///
+	/// This is only used for slashing. In all other instances, the pool id is used, and the
+	/// accounts are deterministically derived from it.
+	#[pallet::storage]
+	pub type ReversePoolIdLookup<T: Config> =
+		CountedStorageMap<_, Twox64Concat, T::AccountId, PoolId, OptionQuery>;
+
+	/// Map from a pool member account to their opted claim permission.
+	#[pallet::storage]
+	pub type ClaimPermissions<T: Config> =
+		StorageMap<_, Twox64Concat, T::AccountId, ClaimPermission, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub min_join_bond: BalanceOf<T>,
+		pub min_create_bond: BalanceOf<T>,
+		pub max_pools: Option<u32>,
+		pub max_members_per_pool: Option<u32>,
+		pub max_members: Option<u32>,
+		pub global_max_commission: Option<Perbill>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			Self {
+				min_join_bond: Zero::zero(),
+				min_create_bond: Zero::zero(),
+				max_pools: Some(16),
+				max_members_per_pool: Some(32),
+				max_members: Some(16 * 32),
+				global_max_commission: None,
+			}
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			MinJoinBond::<T>::put(self.min_join_bond);
+			MinCreateBond::<T>::put(self.min_create_bond);
+			if let Some(max_pools) = self.max_pools {
+				MaxPools::<T>::put(max_pools);
+			}
+			if let Some(max_members_per_pool) = self.max_members_per_pool {
+				MaxPoolMembersPerPool::<T>::put(max_members_per_pool);
+			}
+			if let Some(max_members) = self.max_members {
+				MaxPoolMembers::<T>::put(max_members);
+			}
+			if let Some(global_max_commission) = self.global_max_commission {
+				GlobalMaxCommission::<T>::put(global_max_commission);
+			}
+		}
+	}
+
+	/// Events of this pallet.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(crate) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A pool has been created.
+		Created { depositor: T::AccountId, pool_id: PoolId },
+		/// A member has became bonded in a pool.
+		Bonded { member: T::AccountId, pool_id: PoolId, bonded: BalanceOf<T>, joined: bool },
+		/// A payout has been made to a member.
+		PaidOut { member: T::AccountId, pool_id: PoolId, payout: BalanceOf<T> },
+		/// A member has unbonded from their pool.
+		///
+		/// - `balance` is the corresponding balance of the number of points that has been
+		///   requested to be unbonded (the argument of the `unbond` transaction) from the bonded
+		///   pool.
+		/// - `points` is the number of points that are issued as a result of `balance` being
+		/// dissolved into the corresponding unbonding pool.
+		/// - `era` is the era in which the balance will be unbonded.
+		/// In the absence of slashing, these values will match. In the presence of slashing, the
+		/// number of points that are issued in the unbonding pool will be less than the amount
+		/// requested to be unbonded.
+		Unbonded {
+			member: T::AccountId,
+			pool_id: PoolId,
+			balance: BalanceOf<T>,
+			points: BalanceOf<T>,
+			era: EraIndex,
+		},
+		/// A member has withdrawn from their pool.
+		///
+		/// The given number of `points` have been dissolved in return of `balance`.
+		///
+		/// Similar to `Unbonded` event, in the absence of slashing, the ratio of point to balance
+		/// will be 1.
+		Withdrawn {
+			member: T::AccountId,
+			pool_id: PoolId,
+			balance: BalanceOf<T>,
+			points: BalanceOf<T>,
+		},
+		/// A pool has been destroyed.
+		Destroyed { pool_id: PoolId },
+		/// The state of a pool has changed
+		StateChanged { pool_id: PoolId, new_state: PoolState },
+		/// A member has been removed from a pool.
+		///
+		/// The removal can be voluntary (withdrawn all unbonded funds) or involuntary (kicked).
+		MemberRemoved { pool_id: PoolId, member: T::AccountId },
+		/// The roles of a pool have been updated to the given new roles. Note that the depositor
+		/// can never change.
+		RolesUpdated {
+			root: Option<T::AccountId>,
+			bouncer: Option<T::AccountId>,
+			nominator: Option<T::AccountId>,
+		},
+		/// The active balance of pool `pool_id` has been slashed to `balance`.
+		PoolSlashed { pool_id: PoolId, balance: BalanceOf<T> },
+		/// The unbond pool at `era` of pool `pool_id` has been slashed to `balance`.
+		UnbondingPoolSlashed { pool_id: PoolId, era: EraIndex, balance: BalanceOf<T> },
+		/// A pool's commission setting has been changed.
+		PoolCommissionUpdated { pool_id: PoolId, current: Option<(Perbill, T::AccountId)> },
+		/// A pool's maximum commission setting has been changed.
+		PoolMaxCommissionUpdated { pool_id: PoolId, max_commission: Perbill },
+		/// A pool's commission `change_rate` has been changed.
+		PoolCommissionChangeRateUpdated {
+			pool_id: PoolId,
+			change_rate: CommissionChangeRate<BlockNumberFor<T>>,
+		},
+		/// Pool commission has been claimed.
+		PoolCommissionClaimed { pool_id: PoolId, commission: BalanceOf<T> },
+	}
+
+	#[pallet::error]
+	#[cfg_attr(test, derive(PartialEq))]
+	pub enum Error<T> {
+		/// A (bonded) pool id does not exist.
+		PoolNotFound,
+		/// An account is not a member.
+		PoolMemberNotFound,
+		/// A reward pool does not exist. In all cases this is a system logic error.
+		RewardPoolNotFound,
+		/// A sub pool does not exist.
+		SubPoolsNotFound,
+		/// An account is already delegating in another pool. An account may only belong to one
+		/// pool at a time.
+		AccountBelongsToOtherPool,
+		/// The member is fully unbonded (and thus cannot access the bonded and reward pool
+		/// anymore to, for example, collect rewards).
+		FullyUnbonding,
+		/// The member cannot unbond further chunks due to reaching the limit.
+		MaxUnbondingLimit,
+		/// None of the funds can be withdrawn yet because the bonding duration has not passed.
+		CannotWithdrawAny,
+		/// The amount does not meet the minimum bond to either join or create a pool.
+		///
+		/// The depositor can never unbond to a value less than
+		/// `Pallet::depositor_min_bond`. The caller does not have nominating
+		/// permissions for the pool. Members can never unbond to a value below `MinJoinBond`.
+		MinimumBondNotMet,
+		/// The transaction could not be executed due to overflow risk for the pool.
+		OverflowRisk,
+		/// A pool must be in [`PoolState::Destroying`] in order for the depositor to unbond or for
+		/// other members to be permissionlessly unbonded.
+		NotDestroying,
+		/// The caller does not have nominating permissions for the pool.
+		NotNominator,
+		/// Either a) the caller cannot make a valid kick or b) the pool is not destroying.
+		NotKickerOrDestroying,
+		/// The pool is not open to join
+		NotOpen,
+		/// The system is maxed out on pools.
+		MaxPools,
+		/// Too many members in the pool or system.
+		MaxPoolMembers,
+		/// The pools state cannot be changed.
+		CanNotChangeState,
+		/// The caller does not have adequate permissions.
+		DoesNotHavePermission,
+		/// Metadata exceeds [`Config::MaxMetadataLen`]
+		MetadataExceedsMaxLen,
+		/// Some error occurred that should never happen. This should be reported to the
+		/// maintainers.
+		Defensive(DefensiveError),
+		/// Partial unbonding now allowed permissionlessly.
+		PartialUnbondNotAllowedPermissionlessly,
+		/// The pool's max commission cannot be set higher than the existing value.
+		MaxCommissionRestricted,
+		/// The supplied commission exceeds the max allowed commission.
+		CommissionExceedsMaximum,
+		/// The supplied commission exceeds global maximum commission.
+		CommissionExceedsGlobalMaximum,
+		/// Not enough blocks have surpassed since the last commission update.
+		CommissionChangeThrottled,
+		/// The submitted changes to commission change rate are not allowed.
+		CommissionChangeRateNotAllowed,
+		/// There is no pending commission to claim.
+		NoPendingCommission,
+		/// No commission current has been set.
+		NoCommissionCurrentSet,
+		/// Pool id currently in use.
+		PoolIdInUse,
+		/// Pool id provided is not correct/usable.
+		InvalidPoolId,
+		/// Bonding extra is restricted to the exact pending reward amount.
+		BondExtraRestricted,
+	}
+
+	#[derive(Encode, Decode, PartialEq, TypeInfo, PalletError, RuntimeDebug)]
+	pub enum DefensiveError {
+		/// There isn't enough space in the unbond pool.
+		NotEnoughSpaceInUnbondPool,
+		/// A (bonded) pool id does not exist.
+		PoolNotFound,
+		/// A reward pool does not exist. In all cases this is a system logic error.
+		RewardPoolNotFound,
+		/// A sub pool does not exist.
+		SubPoolsNotFound,
+		/// The bonded account should only be killed by the staking system when the depositor is
+		/// withdrawing
+		BondedStashKilledPrematurely,
+	}
+
+	impl<T> From<DefensiveError> for Error<T> {
+		fn from(e: DefensiveError) -> Error<T> {
+			Error::<T>::Defensive(e)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Stake funds with a pool. The amount to bond is transferred from the member to the
+		/// pools account and immediately increases the pools bond.
+		///
+		/// # Note
+		///
+		/// * An account can only be a member of a single pool.
+		/// * An account cannot join the same pool multiple times.
+		/// * This call will *not* dust the member account, so the member must have at least
+		///   `existential deposit + amount` in their account.
+		/// * Only a pool with [`PoolState::Open`] can be joined
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::join())]
+		pub fn join(
+			origin: OriginFor<T>,
+			#[pallet::compact] amount: BalanceOf<T>,
+			pool_id: PoolId,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			ensure!(amount >= MinJoinBond::<T>::get(), Error::<T>::MinimumBondNotMet);
+			// If a member already exists that means they already belong to a pool
+			ensure!(!PoolMembers::<T>::contains_key(&who), Error::<T>::AccountBelongsToOtherPool);
+
+			let mut bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			bonded_pool.ok_to_join()?;
+
+			let mut reward_pool = RewardPools::<T>::get(pool_id)
+				.defensive_ok_or::<Error<T>>(DefensiveError::RewardPoolNotFound.into())?;
+			// IMPORTANT: reward pool records must be updated with the old points.
+			reward_pool.update_records(
+				pool_id,
+				bonded_pool.points,
+				bonded_pool.commission.current(),
+			)?;
+
+			bonded_pool.try_inc_members()?;
+			let points_issued = bonded_pool.try_bond_funds(&who, amount, BondType::Later)?;
+
+			PoolMembers::insert(
+				who.clone(),
+				PoolMember::<T> {
+					pool_id,
+					points: points_issued,
+					// we just updated `last_known_reward_counter` to the current one in
+					// `update_recorded`.
+					last_recorded_reward_counter: reward_pool.last_recorded_reward_counter(),
+					unbonding_eras: Default::default(),
+				},
+			);
+
+			Self::deposit_event(Event::<T>::Bonded {
+				member: who,
+				pool_id,
+				bonded: amount,
+				joined: true,
+			});
+
+			bonded_pool.put();
+			RewardPools::<T>::insert(pool_id, reward_pool);
+
+			Ok(())
+		}
+
+		/// Bond `extra` more funds from `origin` into the pool to which they already belong.
+		///
+		/// Additional funds can come from either the free balance of the account, of from the
+		/// accumulated rewards, see [`BondExtra`].
+		///
+		/// Bonding extra funds implies an automatic payout of all pending rewards as well.
+		/// See `bond_extra_other` to bond pending rewards of `other` members.
+		// NOTE: this transaction is implemented with the sole purpose of readability and
+		// correctness, not optimization. We read/write several storage items multiple times instead
+		// of just once, in the spirit reusing code.
+		#[pallet::call_index(1)]
+		#[pallet::weight(
+			T::WeightInfo::bond_extra_transfer()
+			.max(T::WeightInfo::bond_extra_other())
+		)]
+		pub fn bond_extra(origin: OriginFor<T>, extra: BondExtra<BalanceOf<T>>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_bond_extra(who.clone(), who, extra)
+		}
+
+		/// A bonded member can use this to claim their payout based on the rewards that the pool
+		/// has accumulated since their last claimed payout (OR since joining if this is their first
+		/// time claiming rewards). The payout will be transferred to the member's account.
+		///
+		/// The member will earn rewards pro rata based on the members stake vs the sum of the
+		/// members in the pools stake. Rewards do not "expire".
+		///
+		/// See `claim_payout_other` to caim rewards on bahalf of some `other` pool member.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::claim_payout())]
+		pub fn claim_payout(origin: OriginFor<T>) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+			Self::do_claim_payout(signer.clone(), signer)
+		}
+
+		/// Unbond up to `unbonding_points` of the `member_account`'s funds from the pool. It
+		/// implicitly collects the rewards one last time, since not doing so would mean some
+		/// rewards would be forfeited.
+		///
+		/// Under certain conditions, this call can be dispatched permissionlessly (i.e. by any
+		/// account).
+		///
+		/// # Conditions for a permissionless dispatch.
+		///
+		/// * The pool is blocked and the caller is either the root or bouncer. This is refereed to
+		///   as a kick.
+		/// * The pool is destroying and the member is not the depositor.
+		/// * The pool is destroying, the member is the depositor and no other members are in the
+		///   pool.
+		///
+		/// ## Conditions for permissioned dispatch (i.e. the caller is also the
+		/// `member_account`):
+		///
+		/// * The caller is not the depositor.
+		/// * The caller is the depositor, the pool is destroying and no other members are in the
+		///   pool.
+		///
+		/// # Note
+		///
+		/// If there are too many unlocking chunks to unbond with the pool account,
+		/// [`Call::pool_withdraw_unbonded`] can be called to try and minimize unlocking chunks.
+		/// The [`StakingInterface::unbond`] will implicitly call [`Call::pool_withdraw_unbonded`]
+		/// to try to free chunks if necessary (ie. if unbound was called and no unlocking chunks
+		/// are available). However, it may not be possible to release the current unlocking chunks,
+		/// in which case, the result of this call will likely be the `NoMoreChunks` error from the
+		/// staking system.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::unbond())]
+		pub fn unbond(
+			origin: OriginFor<T>,
+			member_account: AccountIdLookupOf<T>,
+			#[pallet::compact] unbonding_points: BalanceOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let member_account = T::Lookup::lookup(member_account)?;
+			let (mut member, mut bonded_pool, mut reward_pool) =
+				Self::get_member_with_pools(&member_account)?;
+
+			bonded_pool.ok_to_unbond_with(&who, &member_account, &member, unbonding_points)?;
+
+			// Claim the the payout prior to unbonding. Once the user is unbonding their points no
+			// longer exist in the bonded pool and thus they can no longer claim their payouts. It
+			// is not strictly necessary to claim the rewards, but we do it here for UX.
+			reward_pool.update_records(
+				bonded_pool.id,
+				bonded_pool.points,
+				bonded_pool.commission.current(),
+			)?;
+			let _ = Self::do_reward_payout(&who, &mut member, &mut bonded_pool, &mut reward_pool)?;
+
+			let current_era = T::Staking::current_era();
+			let unbond_era = T::Staking::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)?;
+
+			// 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)
+				.unwrap_or_default()
+				.maybe_merge_pools(current_era);
+
+			// Update the unbond pool associated with the current era with the unbonded funds. Note
+			// that we lazily create the unbond pool if it does not yet exist.
+			if !sub_pools.with_era.contains_key(&unbond_era) {
+				sub_pools
+					.with_era
+					.try_insert(unbond_era, UnbondPool::default())
+					// The above call to `maybe_merge_pools` should ensure there is
+					// always enough space to insert.
+					.defensive_map_err::<Error<T>, _>(|_| {
+						DefensiveError::NotEnoughSpaceInUnbondPool.into()
+					})?;
+			}
+
+			let points_unbonded = sub_pools
+				.with_era
+				.get_mut(&unbond_era)
+				// The above check ensures the pool exists.
+				.defensive_ok_or::<Error<T>>(DefensiveError::PoolNotFound.into())?
+				.issue(unbonding_balance);
+
+			// Try and unbond in the member map.
+			member.try_unbond(unbonding_points, points_unbonded, unbond_era)?;
+
+			Self::deposit_event(Event::<T>::Unbonded {
+				member: member_account.clone(),
+				pool_id: member.pool_id,
+				points: points_unbonded,
+				balance: unbonding_balance,
+				era: unbond_era,
+			});
+
+			// Now that we know everything has worked write the items to storage.
+			SubPoolsStorage::insert(member.pool_id, sub_pools);
+			Self::put_member_with_pools(&member_account, member, bonded_pool, reward_pool);
+			Ok(())
+		}
+
+		/// Call `withdraw_unbonded` for the pools account. This call can be made by any account.
+		///
+		/// This is useful if their are too many unlocking chunks to call `unbond`, and some
+		/// can be cleared by withdrawing. In the case there are too many unlocking chunks, the user
+		/// would probably see an error like `NoMoreChunks` emitted from the staking system when
+		/// they attempt to unbond.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::pool_withdraw_unbonded(*num_slashing_spans))]
+		pub fn pool_withdraw_unbonded(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			num_slashing_spans: u32,
+		) -> DispatchResult {
+			let _ = ensure_signed(origin)?;
+			let pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			// 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)?;
+			Ok(())
+		}
+
+		/// Withdraw unbonded funds from `member_account`. If no bonded funds can be unbonded, an
+		/// error is returned.
+		///
+		/// Under certain conditions, this call can be dispatched permissionlessly (i.e. by any
+		/// account).
+		///
+		/// # Conditions for a permissionless dispatch
+		///
+		/// * The pool is in destroy mode and the target is not the depositor.
+		/// * The target is the depositor and they are the only member in the sub pools.
+		/// * The pool is blocked and the caller is either the root or bouncer.
+		///
+		/// # Conditions for permissioned dispatch
+		///
+		/// * The caller is the target and they are not the depositor.
+		///
+		/// # Note
+		///
+		/// If the target is the depositor, the pool will be destroyed.
+		#[pallet::call_index(5)]
+		#[pallet::weight(
+			T::WeightInfo::withdraw_unbonded_kill(*num_slashing_spans)
+		)]
+		pub fn withdraw_unbonded(
+			origin: OriginFor<T>,
+			member_account: AccountIdLookupOf<T>,
+			num_slashing_spans: u32,
+		) -> DispatchResultWithPostInfo {
+			let caller = ensure_signed(origin)?;
+			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 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)?;
+
+			bonded_pool.ok_to_withdraw_unbonded_with(&caller, &member_account)?;
+
+			// NOTE: must do this after we have done the `ok_to_withdraw_unbonded_other_with` check.
+			let withdrawn_points = member.withdraw_unlocked(current_era);
+			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(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.
+			ensure!(
+				!stash_killed || caller == bonded_pool.roles.depositor,
+				Error::<T>::Defensive(DefensiveError::BondedStashKilledPrematurely)
+			);
+
+			let mut sum_unlocked_points: BalanceOf<T> = Zero::zero();
+			let balance_to_unbond = withdrawn_points
+				.iter()
+				.fold(BalanceOf::<T>::zero(), |accumulator, (era, unlocked_points)| {
+					sum_unlocked_points = sum_unlocked_points.saturating_add(*unlocked_points);
+					if let Some(era_pool) = sub_pools.with_era.get_mut(era) {
+						let balance_to_unbond = era_pool.dissolve(*unlocked_points);
+						if era_pool.points.is_zero() {
+							sub_pools.with_era.remove(era);
+						}
+						accumulator.saturating_add(balance_to_unbond)
+					} else {
+						// A pool does not belong to this era, so it must have been merged to the
+						// era-less pool.
+						accumulator.saturating_add(sub_pools.no_era.dissolve(*unlocked_points))
+					}
+				})
+				// A call to this transaction may cause the pool's stash to get dusted. If this
+				// happens before the last member has withdrawn, then all subsequent withdraws will
+				// be 0. However the unbond pools do no get updated to reflect this. In the
+				// aforementioned scenario, this check ensures we don't try to withdraw funds that
+				// 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.transferrable_balance());
+
+			T::Currency::transfer(
+				&bonded_pool.bonded_account(),
+				&member_account,
+				balance_to_unbond,
+				ExistenceRequirement::AllowDeath,
+			)
+			.defensive()?;
+
+			Self::deposit_event(Event::<T>::Withdrawn {
+				member: member_account.clone(),
+				pool_id: member.pool_id,
+				points: sum_unlocked_points,
+				balance: balance_to_unbond,
+			});
+
+			let post_info_weight = if member.total_points().is_zero() {
+				// remove any `ClaimPermission` associated with the member.
+				ClaimPermissions::<T>::remove(&member_account);
+
+				// member being reaped.
+				PoolMembers::<T>::remove(&member_account);
+				Self::deposit_event(Event::<T>::MemberRemoved {
+					pool_id: member.pool_id,
+					member: member_account.clone(),
+				});
+
+				if member_account == bonded_pool.roles.depositor {
+					Pallet::<T>::dissolve_pool(bonded_pool);
+					None
+				} else {
+					bonded_pool.dec_members().put();
+					SubPoolsStorage::<T>::insert(member.pool_id, sub_pools);
+					Some(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))
+			};
+
+			Ok(post_info_weight.into())
+		}
+
+		/// Create a new delegation pool.
+		///
+		/// # Arguments
+		///
+		/// * `amount` - The amount of funds to delegate to the pool. This also acts of a sort of
+		///   deposit since the pools creator cannot fully unbond funds until the pool is being
+		///   destroyed.
+		/// * `index` - A disambiguation index for creating the account. Likely only useful when
+		///   creating multiple pools in the same extrinsic.
+		/// * `root` - The account to set as [`PoolRoles::root`].
+		/// * `nominator` - The account to set as the [`PoolRoles::nominator`].
+		/// * `bouncer` - The account to set as the [`PoolRoles::bouncer`].
+		///
+		/// # Note
+		///
+		/// In addition to `amount`, the caller will transfer the existential deposit; so the caller
+		/// needs at have at least `amount + existential_deposit` transferrable.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::create())]
+		pub fn create(
+			origin: OriginFor<T>,
+			#[pallet::compact] amount: BalanceOf<T>,
+			root: AccountIdLookupOf<T>,
+			nominator: AccountIdLookupOf<T>,
+			bouncer: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let depositor = ensure_signed(origin)?;
+
+			let pool_id = LastPoolId::<T>::try_mutate::<_, Error<T>, _>(|id| {
+				*id = id.checked_add(1).ok_or(Error::<T>::OverflowRisk)?;
+				Ok(*id)
+			})?;
+
+			Self::do_create(depositor, amount, root, nominator, bouncer, pool_id)
+		}
+
+		/// Create a new delegation pool with a previously used pool id
+		///
+		/// # Arguments
+		///
+		/// same as `create` with the inclusion of
+		/// * `pool_id` - `A valid PoolId.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::create())]
+		pub fn create_with_pool_id(
+			origin: OriginFor<T>,
+			#[pallet::compact] amount: BalanceOf<T>,
+			root: AccountIdLookupOf<T>,
+			nominator: AccountIdLookupOf<T>,
+			bouncer: AccountIdLookupOf<T>,
+			pool_id: PoolId,
+		) -> DispatchResult {
+			let depositor = ensure_signed(origin)?;
+
+			ensure!(!BondedPools::<T>::contains_key(pool_id), Error::<T>::PoolIdInUse);
+			ensure!(pool_id < LastPoolId::<T>::get(), Error::<T>::InvalidPoolId);
+
+			Self::do_create(depositor, amount, root, nominator, bouncer, pool_id)
+		}
+
+		/// Nominate on behalf of the pool.
+		///
+		/// The dispatch origin of this call must be signed by the pool nominator or the pool
+		/// root role.
+		///
+		/// This directly forward the call to the staking pallet, on behalf of the pool bonded
+		/// account.
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::nominate(validators.len() as u32))]
+		pub fn nominate(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			validators: Vec<T::AccountId>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			ensure!(bonded_pool.can_nominate(&who), Error::<T>::NotNominator);
+			T::Staking::nominate(&bonded_pool.bonded_account(), validators)
+		}
+
+		/// Set a new state for the pool.
+		///
+		/// If a pool is already in the `Destroying` state, then under no condition can its state
+		/// change again.
+		///
+		/// The dispatch origin of this call must be either:
+		///
+		/// 1. signed by the bouncer, or the root role of the pool,
+		/// 2. if the pool conditions to be open are NOT met (as described by `ok_to_be_open`), and
+		///    then the state of the pool can be permissionlessly changed to `Destroying`.
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::set_state())]
+		pub fn set_state(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			state: PoolState,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let mut bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			ensure!(bonded_pool.state != PoolState::Destroying, Error::<T>::CanNotChangeState);
+
+			if bonded_pool.can_toggle_state(&who) {
+				bonded_pool.set_state(state);
+			} else if bonded_pool.ok_to_be_open().is_err() && state == PoolState::Destroying {
+				// If the pool has bad properties, then anyone can set it as destroying
+				bonded_pool.set_state(PoolState::Destroying);
+			} else {
+				Err(Error::<T>::CanNotChangeState)?;
+			}
+
+			bonded_pool.put();
+
+			Ok(())
+		}
+
+		/// Set a new metadata for the pool.
+		///
+		/// The dispatch origin of this call must be signed by the bouncer, or the root role of the
+		/// pool.
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::set_metadata(metadata.len() as u32))]
+		pub fn set_metadata(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			metadata: Vec<u8>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let metadata: BoundedVec<_, _> =
+				metadata.try_into().map_err(|_| Error::<T>::MetadataExceedsMaxLen)?;
+			ensure!(
+				BondedPool::<T>::get(pool_id)
+					.ok_or(Error::<T>::PoolNotFound)?
+					.can_set_metadata(&who),
+				Error::<T>::DoesNotHavePermission
+			);
+
+			Metadata::<T>::mutate(pool_id, |pool_meta| *pool_meta = metadata);
+
+			Ok(())
+		}
+
+		/// Update configurations for the nomination pools. The origin for this call must be
+		/// Root.
+		///
+		/// # Arguments
+		///
+		/// * `min_join_bond` - Set [`MinJoinBond`].
+		/// * `min_create_bond` - Set [`MinCreateBond`].
+		/// * `max_pools` - Set [`MaxPools`].
+		/// * `max_members` - Set [`MaxPoolMembers`].
+		/// * `max_members_per_pool` - Set [`MaxPoolMembersPerPool`].
+		/// * `global_max_commission` - Set [`GlobalMaxCommission`].
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::set_configs())]
+		pub fn set_configs(
+			origin: OriginFor<T>,
+			min_join_bond: ConfigOp<BalanceOf<T>>,
+			min_create_bond: ConfigOp<BalanceOf<T>>,
+			max_pools: ConfigOp<u32>,
+			max_members: ConfigOp<u32>,
+			max_members_per_pool: ConfigOp<u32>,
+			global_max_commission: ConfigOp<Perbill>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			macro_rules! config_op_exp {
+				($storage:ty, $op:ident) => {
+					match $op {
+						ConfigOp::Noop => (),
+						ConfigOp::Set(v) => <$storage>::put(v),
+						ConfigOp::Remove => <$storage>::kill(),
+					}
+				};
+			}
+
+			config_op_exp!(MinJoinBond::<T>, min_join_bond);
+			config_op_exp!(MinCreateBond::<T>, min_create_bond);
+			config_op_exp!(MaxPools::<T>, max_pools);
+			config_op_exp!(MaxPoolMembers::<T>, max_members);
+			config_op_exp!(MaxPoolMembersPerPool::<T>, max_members_per_pool);
+			config_op_exp!(GlobalMaxCommission::<T>, global_max_commission);
+			Ok(())
+		}
+
+		/// Update the roles of the pool.
+		///
+		/// The root is the only entity that can change any of the roles, including itself,
+		/// excluding the depositor, who can never change.
+		///
+		/// It emits an event, notifying UIs of the role change. This event is quite relevant to
+		/// most pool members and they should be informed of changes to pool roles.
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::update_roles())]
+		pub fn update_roles(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			new_root: ConfigOp<T::AccountId>,
+			new_nominator: ConfigOp<T::AccountId>,
+			new_bouncer: ConfigOp<T::AccountId>,
+		) -> DispatchResult {
+			let mut bonded_pool = match ensure_root(origin.clone()) {
+				Ok(()) => BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?,
+				Err(frame_support::error::BadOrigin) => {
+					let who = ensure_signed(origin)?;
+					let bonded_pool =
+						BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+					ensure!(bonded_pool.can_update_roles(&who), Error::<T>::DoesNotHavePermission);
+					bonded_pool
+				},
+			};
+
+			match new_root {
+				ConfigOp::Noop => (),
+				ConfigOp::Remove => bonded_pool.roles.root = None,
+				ConfigOp::Set(v) => bonded_pool.roles.root = Some(v),
+			};
+			match new_nominator {
+				ConfigOp::Noop => (),
+				ConfigOp::Remove => bonded_pool.roles.nominator = None,
+				ConfigOp::Set(v) => bonded_pool.roles.nominator = Some(v),
+			};
+			match new_bouncer {
+				ConfigOp::Noop => (),
+				ConfigOp::Remove => bonded_pool.roles.bouncer = None,
+				ConfigOp::Set(v) => bonded_pool.roles.bouncer = Some(v),
+			};
+
+			Self::deposit_event(Event::<T>::RolesUpdated {
+				root: bonded_pool.roles.root.clone(),
+				nominator: bonded_pool.roles.nominator.clone(),
+				bouncer: bonded_pool.roles.bouncer.clone(),
+			});
+
+			bonded_pool.put();
+			Ok(())
+		}
+
+		/// Chill on behalf of the pool.
+		///
+		/// The dispatch origin of this call must be signed by the pool nominator or the pool
+		/// root role, same as [`Pallet::nominate`].
+		///
+		/// This directly forward the call to the staking pallet, on behalf of the pool bonded
+		/// account.
+		#[pallet::call_index(13)]
+		#[pallet::weight(T::WeightInfo::chill())]
+		pub fn chill(origin: OriginFor<T>, pool_id: PoolId) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			ensure!(bonded_pool.can_nominate(&who), Error::<T>::NotNominator);
+			T::Staking::chill(&bonded_pool.bonded_account())
+		}
+
+		/// `origin` bonds funds from `extra` for some pool member `member` into their respective
+		/// pools.
+		///
+		/// `origin` can bond extra funds from free balance or pending rewards when `origin ==
+		/// other`.
+		///
+		/// In the case of `origin != other`, `origin` can only bond extra pending rewards of
+		/// `other` members assuming set_claim_permission for the given member is
+		/// `PermissionlessAll` or `PermissionlessCompound`.
+		#[pallet::call_index(14)]
+		#[pallet::weight(
+			T::WeightInfo::bond_extra_transfer()
+			.max(T::WeightInfo::bond_extra_other())
+		)]
+		pub fn bond_extra_other(
+			origin: OriginFor<T>,
+			member: AccountIdLookupOf<T>,
+			extra: BondExtra<BalanceOf<T>>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_bond_extra(who, T::Lookup::lookup(member)?, extra)
+		}
+
+		/// Allows a pool member to set a claim permission to allow or disallow permissionless
+		/// bonding and withdrawing.
+		///
+		/// By default, this is `Permissioned`, which implies only the pool member themselves can
+		/// claim their pending rewards. If a pool member wishes so, they can set this to
+		/// `PermissionlessAll` to allow any account to claim their rewards and bond extra to the
+		/// pool.
+		///
+		/// # Arguments
+		///
+		/// * `origin` - Member of a pool.
+		/// * `actor` - Account to claim reward. // improve this
+		#[pallet::call_index(15)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1))]
+		pub fn set_claim_permission(
+			origin: OriginFor<T>,
+			permission: ClaimPermission,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			ensure!(PoolMembers::<T>::contains_key(&who), Error::<T>::PoolMemberNotFound);
+			ClaimPermissions::<T>::mutate(who, |source| {
+				*source = permission;
+			});
+			Ok(())
+		}
+
+		/// `origin` can claim payouts on some pool member `other`'s behalf.
+		///
+		/// Pool member `other` must have a `PermissionlessAll` or `PermissionlessWithdraw` in order
+		/// for this call to be successful.
+		#[pallet::call_index(16)]
+		#[pallet::weight(T::WeightInfo::claim_payout())]
+		pub fn claim_payout_other(origin: OriginFor<T>, other: T::AccountId) -> DispatchResult {
+			let signer = ensure_signed(origin)?;
+			Self::do_claim_payout(signer, other)
+		}
+
+		/// Set the commission of a pool.
+		//
+		/// Both a commission percentage and a commission payee must be provided in the `current`
+		/// tuple. Where a `current` of `None` is provided, any current commission will be removed.
+		///
+		/// - If a `None` is supplied to `new_commission`, existing commission will be removed.
+		#[pallet::call_index(17)]
+		#[pallet::weight(T::WeightInfo::set_commission())]
+		pub fn set_commission(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			new_commission: Option<(Perbill, T::AccountId)>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let mut bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			ensure!(bonded_pool.can_manage_commission(&who), Error::<T>::DoesNotHavePermission);
+
+			let mut reward_pool = RewardPools::<T>::get(pool_id)
+				.defensive_ok_or::<Error<T>>(DefensiveError::RewardPoolNotFound.into())?;
+			// IMPORTANT: make sure that everything up to this point is using the current commission
+			// before it updates. Note that `try_update_current` could still fail at this point.
+			reward_pool.update_records(
+				pool_id,
+				bonded_pool.points,
+				bonded_pool.commission.current(),
+			)?;
+			RewardPools::insert(pool_id, reward_pool);
+
+			bonded_pool.commission.try_update_current(&new_commission)?;
+			bonded_pool.put();
+			Self::deposit_event(Event::<T>::PoolCommissionUpdated {
+				pool_id,
+				current: new_commission,
+			});
+			Ok(())
+		}
+
+		/// Set the maximum commission of a pool.
+		///
+		/// - Initial max can be set to any `Perbill`, and only smaller values thereafter.
+		/// - Current commission will be lowered in the event it is higher than a new max
+		///   commission.
+		#[pallet::call_index(18)]
+		#[pallet::weight(T::WeightInfo::set_commission_max())]
+		pub fn set_commission_max(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			max_commission: Perbill,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let mut bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			ensure!(bonded_pool.can_manage_commission(&who), Error::<T>::DoesNotHavePermission);
+
+			bonded_pool.commission.try_update_max(pool_id, max_commission)?;
+			bonded_pool.put();
+
+			Self::deposit_event(Event::<T>::PoolMaxCommissionUpdated { pool_id, max_commission });
+			Ok(())
+		}
+
+		/// Set the commission change rate for a pool.
+		///
+		/// Initial change rate is not bounded, whereas subsequent updates can only be more
+		/// restrictive than the current.
+		#[pallet::call_index(19)]
+		#[pallet::weight(T::WeightInfo::set_commission_change_rate())]
+		pub fn set_commission_change_rate(
+			origin: OriginFor<T>,
+			pool_id: PoolId,
+			change_rate: CommissionChangeRate<BlockNumberFor<T>>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let mut bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+			ensure!(bonded_pool.can_manage_commission(&who), Error::<T>::DoesNotHavePermission);
+
+			bonded_pool.commission.try_update_change_rate(change_rate)?;
+			bonded_pool.put();
+
+			Self::deposit_event(Event::<T>::PoolCommissionChangeRateUpdated {
+				pool_id,
+				change_rate,
+			});
+			Ok(())
+		}
+
+		/// Claim pending commission.
+		///
+		/// The dispatch origin of this call must be signed by the `root` role of the pool. Pending
+		/// commission is paid out and added to total claimed commission`. Total pending commission
+		/// is reset to zero. the current.
+		#[pallet::call_index(20)]
+		#[pallet::weight(T::WeightInfo::claim_commission())]
+		pub fn claim_commission(origin: OriginFor<T>, pool_id: PoolId) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_claim_commission(who, pool_id)
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_n: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+			Self::do_try_state(u8::MAX)
+		}
+
+		fn integrity_test() {
+			assert!(
+				T::MaxPointsToBalance::get() > 0,
+				"Minimum points to balance ratio must be greater than 0"
+			);
+			assert!(
+				T::Staking::bonding_duration() < TotalUnbondingPools::<T>::get(),
+				"There must be more unbonding pools then the bonding duration /
+				so a slash can be applied to relevant unboding pools. (We assume /
+				the bonding duration > slash deffer duration.",
+			);
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// The amount of bond that MUST REMAIN IN BONDED in ALL POOLS.
+	///
+	/// It is the responsibility of the depositor to put these funds into the pool initially. Upon
+	/// unbond, they can never unbond to a value below this amount.
+	///
+	/// 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()
+			.max(MinCreateBond::<T>::get())
+			.max(MinJoinBond::<T>::get())
+			.max(T::Currency::minimum_balance())
+	}
+	/// Remove everything related to the given bonded pool.
+	///
+	/// Metadata and all of the sub-pools are also deleted. All accounts are dusted and the leftover
+	/// of the reward account is returned to the depositor.
+	pub fn dissolve_pool(bonded_pool: BondedPool<T>) {
+		let reward_account = bonded_pool.reward_account();
+		let bonded_account = bonded_pool.bonded_account();
+
+		ReversePoolIdLookup::<T>::remove(&bonded_account);
+		RewardPools::<T>::remove(bonded_pool.id);
+		SubPoolsStorage::<T>::remove(bonded_pool.id);
+
+		// Kill accounts from storage by making their balance go below ED. We assume that the
+		// accounts have no references that would prevent destruction once we get to this point. We
+		// don't work with the system pallet directly, but
+		// 1. we drain the reward account and kill it. This account should never have any extra
+		// consumers anyway.
+		// 2. the bonded account should become a 'killed stash' in the staking system, and all of
+		//    its consumers removed.
+		debug_assert_eq!(frame_system::Pallet::<T>::consumers(&reward_account), 0);
+		debug_assert_eq!(frame_system::Pallet::<T>::consumers(&bonded_account), 0);
+		debug_assert_eq!(
+			T::Staking::total_stake(&bonded_account).unwrap_or_default(),
+			Zero::zero()
+		);
+
+		// This shouldn't fail, but if it does we don't really care. Remaining balance can consist
+		// of unclaimed pending commission, errorneous transfers to the reward account, etc.
+		let reward_pool_remaining = T::Currency::free_balance(&reward_account);
+		let _ = T::Currency::transfer(
+			&reward_account,
+			&bonded_pool.roles.depositor,
+			reward_pool_remaining,
+			ExistenceRequirement::AllowDeath,
+		);
+
+		// NOTE: this is purely defensive.
+		T::Currency::make_free_balance_be(&reward_account, Zero::zero());
+		T::Currency::make_free_balance_be(&bonded_pool.bonded_account(), Zero::zero());
+
+		Self::deposit_event(Event::<T>::Destroyed { pool_id: bonded_pool.id });
+		// Remove bonded pool metadata.
+		Metadata::<T>::remove(bonded_pool.id);
+
+		bonded_pool.remove();
+	}
+
+	/// Create the main, bonded account of a pool with the given id.
+	pub fn create_bonded_account(id: PoolId) -> T::AccountId {
+		T::PalletId::get().into_sub_account_truncating((AccountType::Bonded, id))
+	}
+
+	/// Create the reward account of a pool with the given id.
+	pub fn create_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))
+	}
+
+	/// Get the member with their associated bonded and reward pool.
+	fn get_member_with_pools(
+		who: &T::AccountId,
+	) -> Result<(PoolMember<T>, BondedPool<T>, RewardPool<T>), Error<T>> {
+		let member = PoolMembers::<T>::get(who).ok_or(Error::<T>::PoolMemberNotFound)?;
+		let bonded_pool =
+			BondedPool::<T>::get(member.pool_id).defensive_ok_or(DefensiveError::PoolNotFound)?;
+		let reward_pool =
+			RewardPools::<T>::get(member.pool_id).defensive_ok_or(DefensiveError::PoolNotFound)?;
+		Ok((member, bonded_pool, reward_pool))
+	}
+
+	/// Persist the member with their associated bonded and reward pool into storage, consuming
+	/// all of them.
+	fn put_member_with_pools(
+		member_account: &T::AccountId,
+		member: PoolMember<T>,
+		bonded_pool: BondedPool<T>,
+		reward_pool: RewardPool<T>,
+	) {
+		bonded_pool.put();
+		RewardPools::insert(member.pool_id, reward_pool);
+		PoolMembers::<T>::insert(member_account, member);
+	}
+
+	/// Calculate the equivalent point of `new_funds` in a pool with `current_balance` and
+	/// `current_points`.
+	fn balance_to_point(
+		current_balance: BalanceOf<T>,
+		current_points: BalanceOf<T>,
+		new_funds: BalanceOf<T>,
+	) -> BalanceOf<T> {
+		let u256 = T::BalanceToU256::convert;
+		let balance = T::U256ToBalance::convert;
+		match (current_balance.is_zero(), current_points.is_zero()) {
+			(_, true) => new_funds.saturating_mul(POINTS_TO_BALANCE_INIT_RATIO.into()),
+			(true, false) => {
+				// The pool was totally slashed.
+				// This is the equivalent of `(current_points / 1) * new_funds`.
+				new_funds.saturating_mul(current_points)
+			},
+			(false, false) => {
+				// Equivalent to (current_points / current_balance) * new_funds
+				balance(
+					u256(current_points)
+						.saturating_mul(u256(new_funds))
+						// We check for zero above
+						.div(u256(current_balance)),
+				)
+			},
+		}
+	}
+
+	/// Calculate the equivalent balance of `points` in a pool with `current_balance` and
+	/// `current_points`.
+	fn point_to_balance(
+		current_balance: BalanceOf<T>,
+		current_points: BalanceOf<T>,
+		points: BalanceOf<T>,
+	) -> BalanceOf<T> {
+		let u256 = T::BalanceToU256::convert;
+		let balance = T::U256ToBalance::convert;
+		if current_balance.is_zero() || current_points.is_zero() || points.is_zero() {
+			// There is nothing to unbond
+			return Zero::zero()
+		}
+
+		// Equivalent of (current_balance / current_points) * points
+		balance(u256(current_balance).saturating_mul(u256(points)))
+			// We check for zero above
+			.div(current_points)
+	}
+
+	/// If the member has some rewards, transfer a payout from the reward pool to the member.
+	// Emits events and potentially modifies pool state if any arithmetic saturates, but does
+	// not persist any of the mutable inputs to storage.
+	fn do_reward_payout(
+		member_account: &T::AccountId,
+		member: &mut PoolMember<T>,
+		bonded_pool: &mut BondedPool<T>,
+		reward_pool: &mut RewardPool<T>,
+	) -> Result<BalanceOf<T>, DispatchError> {
+		debug_assert_eq!(member.pool_id, bonded_pool.id);
+
+		// a member who has no skin in the game anymore cannot claim any rewards.
+		ensure!(!member.active_points().is_zero(), Error::<T>::FullyUnbonding);
+
+		let (current_reward_counter, _) = reward_pool.current_reward_counter(
+			bonded_pool.id,
+			bonded_pool.points,
+			bonded_pool.commission.current(),
+		)?;
+
+		// Determine the pending rewards. In scenarios where commission is 100%, `pending_rewards`
+		// will be zero.
+		let pending_rewards = member.pending_rewards(current_reward_counter)?;
+		if pending_rewards.is_zero() {
+			return Ok(pending_rewards)
+		}
+
+		// IFF the reward is non-zero alter the member and reward pool info.
+		member.last_recorded_reward_counter = current_reward_counter;
+		reward_pool.register_claimed_reward(pending_rewards);
+
+		T::Currency::transfer(
+			&bonded_pool.reward_account(),
+			member_account,
+			pending_rewards,
+			// defensive: the depositor has put existential deposit into the pool and it stays
+			// untouched, reward account shall not die.
+			ExistenceRequirement::KeepAlive,
+		)?;
+
+		Self::deposit_event(Event::<T>::PaidOut {
+			member: member_account.clone(),
+			pool_id: member.pool_id,
+			payout: pending_rewards,
+		});
+
+		Ok(pending_rewards)
+	}
+
+	fn do_create(
+		who: T::AccountId,
+		amount: BalanceOf<T>,
+		root: AccountIdLookupOf<T>,
+		nominator: AccountIdLookupOf<T>,
+		bouncer: AccountIdLookupOf<T>,
+		pool_id: PoolId,
+	) -> DispatchResult {
+		let root = T::Lookup::lookup(root)?;
+		let nominator = T::Lookup::lookup(nominator)?;
+		let bouncer = T::Lookup::lookup(bouncer)?;
+
+		ensure!(amount >= Pallet::<T>::depositor_min_bond(), Error::<T>::MinimumBondNotMet);
+		ensure!(
+			MaxPools::<T>::get().map_or(true, |max_pools| BondedPools::<T>::count() < max_pools),
+			Error::<T>::MaxPools
+		);
+		ensure!(!PoolMembers::<T>::contains_key(&who), Error::<T>::AccountBelongsToOtherPool);
+		let mut bonded_pool = BondedPool::<T>::new(
+			pool_id,
+			PoolRoles {
+				root: Some(root),
+				nominator: Some(nominator),
+				bouncer: Some(bouncer),
+				depositor: who.clone(),
+			},
+		);
+
+		bonded_pool.try_inc_members()?;
+		let points = bonded_pool.try_bond_funds(&who, amount, BondType::Create)?;
+
+		T::Currency::transfer(
+			&who,
+			&bonded_pool.reward_account(),
+			T::Currency::minimum_balance(),
+			ExistenceRequirement::AllowDeath,
+		)?;
+
+		PoolMembers::<T>::insert(
+			who.clone(),
+			PoolMember::<T> {
+				pool_id,
+				points,
+				last_recorded_reward_counter: Zero::zero(),
+				unbonding_eras: Default::default(),
+			},
+		);
+		RewardPools::<T>::insert(
+			pool_id,
+			RewardPool::<T> {
+				last_recorded_reward_counter: Zero::zero(),
+				last_recorded_total_payouts: Zero::zero(),
+				total_rewards_claimed: Zero::zero(),
+				total_commission_pending: Zero::zero(),
+				total_commission_claimed: Zero::zero(),
+			},
+		);
+		ReversePoolIdLookup::<T>::insert(bonded_pool.bonded_account(), pool_id);
+
+		Self::deposit_event(Event::<T>::Created { depositor: who.clone(), pool_id });
+
+		Self::deposit_event(Event::<T>::Bonded {
+			member: who,
+			pool_id,
+			bonded: amount,
+			joined: true,
+		});
+		bonded_pool.put();
+
+		Ok(())
+	}
+
+	fn do_bond_extra(
+		signer: T::AccountId,
+		who: T::AccountId,
+		extra: BondExtra<BalanceOf<T>>,
+	) -> DispatchResult {
+		if signer != who {
+			ensure!(
+				ClaimPermissions::<T>::get(&who).can_bond_extra(),
+				Error::<T>::DoesNotHavePermission
+			);
+			ensure!(extra == BondExtra::Rewards, Error::<T>::BondExtraRestricted);
+		}
+
+		let (mut member, mut bonded_pool, mut reward_pool) = Self::get_member_with_pools(&who)?;
+
+		// payout related stuff: we must claim the payouts, and updated recorded payout data
+		// before updating the bonded pool points, similar to that of `join` transaction.
+		reward_pool.update_records(
+			bonded_pool.id,
+			bonded_pool.points,
+			bonded_pool.commission.current(),
+		)?;
+		let claimed =
+			Self::do_reward_payout(&who, &mut member, &mut bonded_pool, &mut reward_pool)?;
+
+		let (points_issued, bonded) = match extra {
+			BondExtra::FreeBalance(amount) =>
+				(bonded_pool.try_bond_funds(&who, amount, BondType::Later)?, amount),
+			BondExtra::Rewards =>
+				(bonded_pool.try_bond_funds(&who, claimed, BondType::Later)?, claimed),
+		};
+
+		bonded_pool.ok_to_be_open()?;
+		member.points =
+			member.points.checked_add(&points_issued).ok_or(Error::<T>::OverflowRisk)?;
+
+		Self::deposit_event(Event::<T>::Bonded {
+			member: who.clone(),
+			pool_id: member.pool_id,
+			bonded,
+			joined: false,
+		});
+		Self::put_member_with_pools(&who, member, bonded_pool, reward_pool);
+
+		Ok(())
+	}
+
+	fn do_claim_commission(who: T::AccountId, pool_id: PoolId) -> DispatchResult {
+		let bonded_pool = BondedPool::<T>::get(pool_id).ok_or(Error::<T>::PoolNotFound)?;
+		ensure!(bonded_pool.can_manage_commission(&who), Error::<T>::DoesNotHavePermission);
+
+		let mut reward_pool = RewardPools::<T>::get(pool_id)
+			.defensive_ok_or::<Error<T>>(DefensiveError::RewardPoolNotFound.into())?;
+
+		// IMPORTANT: make sure that any newly pending commission not yet processed is added to
+		// `total_commission_pending`.
+		reward_pool.update_records(
+			pool_id,
+			bonded_pool.points,
+			bonded_pool.commission.current(),
+		)?;
+
+		let commission = reward_pool.total_commission_pending;
+		ensure!(!commission.is_zero(), Error::<T>::NoPendingCommission);
+
+		let payee = bonded_pool
+			.commission
+			.current
+			.as_ref()
+			.map(|(_, p)| p.clone())
+			.ok_or(Error::<T>::NoCommissionCurrentSet)?;
+
+		// Payout claimed commission.
+		T::Currency::transfer(
+			&bonded_pool.reward_account(),
+			&payee,
+			commission,
+			ExistenceRequirement::KeepAlive,
+		)?;
+
+		// Add pending commission to total claimed counter.
+		reward_pool.total_commission_claimed =
+			reward_pool.total_commission_claimed.saturating_add(commission);
+		// Reset total pending commission counter to zero.
+		reward_pool.total_commission_pending = Zero::zero();
+		// Commit reward pool updates
+		RewardPools::<T>::insert(pool_id, reward_pool);
+
+		Self::deposit_event(Event::<T>::PoolCommissionClaimed { pool_id, commission });
+		Ok(())
+	}
+
+	fn do_claim_payout(signer: T::AccountId, who: T::AccountId) -> DispatchResult {
+		if signer != who {
+			ensure!(
+				ClaimPermissions::<T>::get(&who).can_claim_payout(),
+				Error::<T>::DoesNotHavePermission
+			);
+		}
+		let (mut member, mut bonded_pool, mut reward_pool) = Self::get_member_with_pools(&who)?;
+
+		let _ = Self::do_reward_payout(&who, &mut member, &mut bonded_pool, &mut reward_pool)?;
+
+		Self::put_member_with_pools(&who, member, bonded_pool, reward_pool);
+		Ok(())
+	}
+
+	/// Ensure the correctness of the state of this pallet.
+	///
+	/// This should be valid before or after each state transition of this pallet.
+	///
+	/// ## Invariants:
+	///
+	/// First, let's consider pools:
+	///
+	/// * `BondedPools` and `RewardPools` must all have the EXACT SAME key-set.
+	/// * `SubPoolsStorage` must be a subset of the above superset.
+	/// * `Metadata` keys must be a subset of the above superset.
+	/// * the count of the above set must be less than `MaxPools`.
+	///
+	/// Then, considering members as well:
+	///
+	/// * each `BondedPool.member_counter` must be:
+	///   - correct (compared to actual count of member who have `.pool_id` this pool)
+	///   - less than `MaxPoolMembersPerPool`.
+	/// * each `member.pool_id` must correspond to an existing `BondedPool.id` (which implies the
+	///   existence of the reward pool as well).
+	/// * count of all members must be less than `MaxPoolMembers`.
+	///
+	/// Then, considering unbonding members:
+	///
+	/// for each pool:
+	///   * sum of the balance that's tracked in all unbonding pools must be the same as the
+	///     unbonded balance of the main account, as reported by the staking interface.
+	///   * sum of the balance that's tracked in all unbonding pools, plus the bonded balance of the
+	///     main account should be less than or qual to the total balance of the main account.
+	///
+	/// ## Sanity check level
+	///
+	/// To cater for tests that want to escape parts of these checks, this function is split into
+	/// multiple `level`s, where the higher the level, the more checks we performs. So,
+	/// `try_state(255)` is the strongest sanity check, and `0` performs no checks.
+	#[cfg(any(feature = "try-runtime", feature = "fuzzing", test, debug_assertions))]
+	pub fn do_try_state(level: u8) -> Result<(), TryRuntimeError> {
+		if level.is_zero() {
+			return Ok(())
+		}
+		// note: while a bit wacky, since they have the same key, even collecting to vec should
+		// result in the same set of keys, in the same order.
+		let bonded_pools = BondedPools::<T>::iter_keys().collect::<Vec<_>>();
+		let reward_pools = RewardPools::<T>::iter_keys().collect::<Vec<_>>();
+		ensure!(
+			bonded_pools == reward_pools,
+			"`BondedPools` and `RewardPools` must all have the EXACT SAME key-set."
+		);
+
+		ensure!(
+			SubPoolsStorage::<T>::iter_keys().all(|k| bonded_pools.contains(&k)),
+			"`SubPoolsStorage` must be a subset of the above superset."
+		);
+		ensure!(
+			Metadata::<T>::iter_keys().all(|k| bonded_pools.contains(&k)),
+			"`Metadata` keys must be a subset of the above superset."
+		);
+
+		ensure!(
+			MaxPools::<T>::get().map_or(true, |max| bonded_pools.len() <= (max as usize)),
+			Error::<T>::MaxPools
+		);
+
+		for id in reward_pools {
+			let account = Self::create_reward_account(id);
+			if T::Currency::free_balance(&account) < T::Currency::minimum_balance() {
+				log!(
+					warn,
+					"reward pool of {:?}: {:?} (ed = {:?}), should only happen because ED has \
+					changed recently. Pool operators should be notified to top up the reward \
+					account",
+					id,
+					T::Currency::free_balance(&account),
+					T::Currency::minimum_balance(),
+				)
+			}
+		}
+
+		let mut pools_members = BTreeMap::<PoolId, u32>::new();
+		let mut pools_members_pending_rewards = BTreeMap::<PoolId, BalanceOf<T>>::new();
+		let mut all_members = 0u32;
+		PoolMembers::<T>::iter().try_for_each(|(_, d)| -> Result<(), TryRuntimeError> {
+			let bonded_pool = BondedPools::<T>::get(d.pool_id).unwrap();
+			ensure!(!d.total_points().is_zero(), "No member should have zero points");
+			*pools_members.entry(d.pool_id).or_default() += 1;
+			all_members += 1;
+
+			let reward_pool = RewardPools::<T>::get(d.pool_id).unwrap();
+			if !bonded_pool.points.is_zero() {
+				let commission = bonded_pool.commission.current();
+				let (current_rc, _) = reward_pool
+					.current_reward_counter(d.pool_id, bonded_pool.points, commission)
+					.unwrap();
+				let pending_rewards = d.pending_rewards(current_rc).unwrap();
+				*pools_members_pending_rewards.entry(d.pool_id).or_default() += pending_rewards;
+			} // else this pool has been heavily slashed and cannot have any rewards anymore.
+
+			Ok(())
+		})?;
+
+		RewardPools::<T>::iter_keys().try_for_each(|id| -> Result<(), TryRuntimeError> {
+			// the sum of the pending rewards must be less than the leftover balance. Since the
+			// reward math rounds down, we might accumulate some dust here.
+			let pending_rewards_lt_leftover_bal = RewardPool::<T>::current_balance(id) >=
+				pools_members_pending_rewards.get(&id).copied().unwrap_or_default();
+			if !pending_rewards_lt_leftover_bal {
+				log::warn!(
+					"pool {:?}, sum pending rewards = {:?}, remaining balance = {:?}",
+					id,
+					pools_members_pending_rewards.get(&id),
+					RewardPool::<T>::current_balance(id)
+				);
+			}
+			ensure!(
+				pending_rewards_lt_leftover_bal,
+				"The sum of the pending rewards must be less than the leftover balance."
+			);
+			Ok(())
+		})?;
+
+		BondedPools::<T>::iter().try_for_each(|(id, inner)| -> Result<(), TryRuntimeError> {
+			let bonded_pool = BondedPool { id, inner };
+			ensure!(
+				pools_members.get(&id).copied().unwrap_or_default() ==
+				bonded_pool.member_counter,
+				"Each `BondedPool.member_counter` must be equal to the actual count of members of this pool"
+			);
+			ensure!(
+				MaxPoolMembersPerPool::<T>::get()
+					.map_or(true, |max| bonded_pool.member_counter <= max),
+				Error::<T>::MaxPoolMembers
+			);
+
+			let depositor = PoolMembers::<T>::get(&bonded_pool.roles.depositor).unwrap();
+			ensure!(
+				bonded_pool.is_destroying_and_only_depositor(depositor.active_points()) ||
+					depositor.active_points() >= MinCreateBond::<T>::get(),
+				"depositor must always have MinCreateBond stake in the pool, except for when the \
+				pool is being destroyed and the depositor is the last member",
+			);
+			Ok(())
+		})?;
+		ensure!(
+			MaxPoolMembers::<T>::get().map_or(true, |max| all_members <= max),
+			Error::<T>::MaxPoolMembers
+		);
+
+		if level <= 1 {
+			return Ok(())
+		}
+
+		for (pool_id, _pool) in BondedPools::<T>::iter() {
+			let pool_account = Pallet::<T>::create_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);
+
+			assert!(
+				total_balance >= bonded_balance + sum_unbonding_balance,
+				"faulty pool: {:?} / {:?}, total_balance {:?} >= bonded_balance {:?} + sum_unbonding_balance {:?}",
+				pool_id,
+				_pool,
+				total_balance,
+				bonded_balance,
+				sum_unbonding_balance
+			);
+		}
+
+		Ok(())
+	}
+
+	/// Fully unbond the shares of `member`, when executed from `origin`.
+	///
+	/// This is useful for backwards compatibility with the majority of tests that only deal with
+	/// full unbonding, not partial unbonding.
+	#[cfg(any(feature = "runtime-benchmarks", test))]
+	pub fn fully_unbond(
+		origin: frame_system::pallet_prelude::OriginFor<T>,
+		member: T::AccountId,
+	) -> DispatchResult {
+		let points = PoolMembers::<T>::get(&member).map(|d| d.active_points()).unwrap_or_default();
+		let member_lookup = T::Lookup::unlookup(member);
+		Self::unbond(origin, member_lookup, points)
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Returns the pending rewards for the specified `who` account.
+	///
+	/// In the case of error, `None` is returned. Used by runtime API.
+	pub fn api_pending_rewards(who: T::AccountId) -> Option<BalanceOf<T>> {
+		if let Some(pool_member) = PoolMembers::<T>::get(who) {
+			if let Some((reward_pool, bonded_pool)) = RewardPools::<T>::get(pool_member.pool_id)
+				.zip(BondedPools::<T>::get(pool_member.pool_id))
+			{
+				let commission = bonded_pool.commission.current();
+				let (current_reward_counter, _) = reward_pool
+					.current_reward_counter(pool_member.pool_id, bonded_pool.points, commission)
+					.ok()?;
+				return pool_member.pending_rewards(current_reward_counter).ok()
+			}
+		}
+
+		None
+	}
+
+	/// Returns the points to balance conversion for a specified pool.
+	///
+	/// If the pool ID does not exist, it returns 0 ratio points to balance. Used by runtime API.
+	pub fn api_points_to_balance(pool_id: PoolId, points: BalanceOf<T>) -> BalanceOf<T> {
+		if let Some(pool) = BondedPool::<T>::get(pool_id) {
+			pool.points_to_balance(points)
+		} else {
+			Zero::zero()
+		}
+	}
+
+	/// Returns the equivalent `new_funds` balance to point conversion for a specified pool.
+	///
+	/// If the pool ID does not exist, returns 0 ratio balance to points. Used by runtime API.
+	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());
+			Pallet::<T>::balance_to_point(bonded_balance, pool.points, new_funds)
+		} else {
+			Zero::zero()
+		}
+	}
+}
+
+impl<T: Config> sp_staking::OnStakingUpdate<T::AccountId, BalanceOf<T>> for Pallet<T> {
+	fn on_slash(
+		pool_account: &T::AccountId,
+		// Bonded balance is always read directly from staking, therefore we don't need to update
+		// anything here.
+		slashed_bonded: BalanceOf<T>,
+		slashed_unlocking: &BTreeMap<EraIndex, BalanceOf<T>>,
+	) {
+		if let Some(pool_id) = ReversePoolIdLookup::<T>::get(pool_account) {
+			let mut sub_pools = match SubPoolsStorage::<T>::get(pool_id).defensive() {
+				Some(sub_pools) => sub_pools,
+				None => return,
+			};
+			for (era, slashed_balance) in slashed_unlocking.iter() {
+				if let Some(pool) = sub_pools.with_era.get_mut(era) {
+					pool.balance = *slashed_balance;
+					Self::deposit_event(Event::<T>::UnbondingPoolSlashed {
+						era: *era,
+						pool_id,
+						balance: *slashed_balance,
+					});
+				}
+			}
+
+			Self::deposit_event(Event::<T>::PoolSlashed { pool_id, balance: slashed_bonded });
+			SubPoolsStorage::<T>::insert(pool_id, sub_pools);
+		}
+	}
+}
diff --git a/substrate/frame/nomination-pools/src/migration.rs b/substrate/frame/nomination-pools/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2ae4cd1b86857787ff98d72191785c8e8168339c
--- /dev/null
+++ b/substrate/frame/nomination-pools/src/migration.rs
@@ -0,0 +1,727 @@
+// 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 crate::log;
+use frame_support::traits::OnRuntimeUpgrade;
+use sp_std::{collections::btree_map::BTreeMap, vec::Vec};
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+pub mod v1 {
+	use super::*;
+
+	#[derive(Decode)]
+	pub struct OldPoolRoles<AccountId> {
+		pub depositor: AccountId,
+		pub root: AccountId,
+		pub nominator: AccountId,
+		pub bouncer: AccountId,
+	}
+
+	impl<AccountId> OldPoolRoles<AccountId> {
+		fn migrate_to_v1(self) -> PoolRoles<AccountId> {
+			PoolRoles {
+				depositor: self.depositor,
+				root: Some(self.root),
+				nominator: Some(self.nominator),
+				bouncer: Some(self.bouncer),
+			}
+		}
+	}
+
+	#[derive(Decode)]
+	pub struct OldBondedPoolInner<T: Config> {
+		pub points: BalanceOf<T>,
+		pub state: PoolState,
+		pub member_counter: u32,
+		pub roles: OldPoolRoles<T::AccountId>,
+	}
+
+	impl<T: Config> OldBondedPoolInner<T> {
+		fn migrate_to_v1(self) -> BondedPoolInner<T> {
+			// Note: `commission` field not introduced to `BondedPoolInner` until
+			// migration 4.
+			BondedPoolInner {
+				points: self.points,
+				commission: Commission::default(),
+				member_counter: self.member_counter,
+				state: self.state,
+				roles: self.roles.migrate_to_v1(),
+			}
+		}
+	}
+
+	/// Trivial migration which makes the roles of each pool optional.
+	///
+	/// Note: The depositor is not optional since they can never change.
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			log!(
+				info,
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current,
+				onchain
+			);
+
+			if current == 1 && onchain == 0 {
+				// this is safe to execute on any runtime that has a bounded number of pools.
+				let mut translated = 0u64;
+				BondedPools::<T>::translate::<OldBondedPoolInner<T>, _>(|_key, old_value| {
+					translated.saturating_inc();
+					Some(old_value.migrate_to_v1())
+				});
+
+				current.put::<Pallet<T>>();
+
+				log!(info, "Upgraded {} pools, storage to version {:?}", translated, current);
+
+				T::DbWeight::get().reads_writes(translated + 1, translated + 1)
+			} else {
+				log!(info, "Migration did not executed. This probably should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+			// new version must be set.
+			ensure!(
+				Pallet::<T>::on_chain_storage_version() == 1,
+				"The onchain version must be updated after the migration."
+			);
+			Pallet::<T>::try_state(frame_system::Pallet::<T>::block_number())?;
+			Ok(())
+		}
+	}
+}
+
+pub mod v2 {
+	use super::*;
+	use sp_runtime::Perbill;
+
+	#[test]
+	fn migration_assumption_is_correct() {
+		// this migrations cleans all the reward accounts to contain exactly ed, and all members
+		// having no claimable rewards. In this state, all fields of the `RewardPool` and
+		// `member.last_recorded_reward_counter` are all zero.
+		use crate::mock::*;
+		ExtBuilder::default().build_and_execute(|| {
+			let join = |x| {
+				Balances::make_free_balance_be(&x, Balances::minimum_balance() + 10);
+				frame_support::assert_ok!(Pools::join(RuntimeOrigin::signed(x), 10, 1));
+			};
+
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 10);
+			assert_eq!(
+				RewardPools::<Runtime>::get(1).unwrap(),
+				RewardPool { ..Default::default() }
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().last_recorded_reward_counter,
+				Zero::zero()
+			);
+
+			join(20);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 20);
+			assert_eq!(
+				RewardPools::<Runtime>::get(1).unwrap(),
+				RewardPool { ..Default::default() }
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().last_recorded_reward_counter,
+				Zero::zero()
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(20).unwrap().last_recorded_reward_counter,
+				Zero::zero()
+			);
+
+			join(30);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 30);
+			assert_eq!(
+				RewardPools::<Runtime>::get(1).unwrap(),
+				RewardPool { ..Default::default() }
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().last_recorded_reward_counter,
+				Zero::zero()
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(20).unwrap().last_recorded_reward_counter,
+				Zero::zero()
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(30).unwrap().last_recorded_reward_counter,
+				Zero::zero()
+			);
+		});
+	}
+
+	#[derive(Decode)]
+	pub struct OldRewardPool<B> {
+		pub balance: B,
+		pub total_earnings: B,
+		pub points: U256,
+	}
+
+	#[derive(Decode)]
+	pub struct OldPoolMember<T: Config> {
+		pub pool_id: PoolId,
+		pub points: BalanceOf<T>,
+		pub reward_pool_total_earnings: BalanceOf<T>,
+		pub unbonding_eras: BoundedBTreeMap<EraIndex, BalanceOf<T>, T::MaxUnbonding>,
+	}
+
+	/// Migrate the pool reward scheme to the new version, as per
+	/// <https://github.com/paritytech/substrate/pull/11669.>.
+	pub struct MigrateToV2<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> MigrateToV2<T> {
+		fn run(current: StorageVersion) -> Weight {
+			let mut reward_pools_translated = 0u64;
+			let mut members_translated = 0u64;
+			// just for logging.
+			let mut total_value_locked = BalanceOf::<T>::zero();
+			let mut total_points_locked = BalanceOf::<T>::zero();
+
+			// store each member of the pool, with their active points. In the process, migrate
+			// their data as well.
+			let mut temp_members = BTreeMap::<PoolId, Vec<(T::AccountId, BalanceOf<T>)>>::new();
+			PoolMembers::<T>::translate::<OldPoolMember<T>, _>(|key, old_member| {
+				let id = old_member.pool_id;
+				temp_members.entry(id).or_default().push((key, old_member.points));
+
+				total_points_locked += old_member.points;
+				members_translated += 1;
+				Some(PoolMember::<T> {
+					last_recorded_reward_counter: Zero::zero(),
+					pool_id: old_member.pool_id,
+					points: old_member.points,
+					unbonding_eras: old_member.unbonding_eras,
+				})
+			});
+
+			// translate all reward pools. In the process, do the last payout as well.
+			RewardPools::<T>::translate::<OldRewardPool<BalanceOf<T>>, _>(
+				|id, _old_reward_pool| {
+					// each pool should have at least one member.
+					let members = match temp_members.get(&id) {
+						Some(x) => x,
+						None => {
+							log!(error, "pool {} has no member! deleting it..", id);
+							return None
+						},
+					};
+					let bonded_pool = match BondedPools::<T>::get(id) {
+						Some(x) => x,
+						None => {
+							log!(error, "pool {} has no bonded pool! deleting it..", id);
+							return None
+						},
+					};
+
+					let accumulated_reward = RewardPool::<T>::current_balance(id);
+					let reward_account = Pallet::<T>::create_reward_account(id);
+					let mut sum_paid_out = BalanceOf::<T>::zero();
+
+					members
+						.into_iter()
+						.filter_map(|(who, points)| {
+							let bonded_pool = match BondedPool::<T>::get(id) {
+								Some(x) => x,
+								None => {
+									log!(error, "pool {} for member {:?} does not exist!", id, who);
+									return None
+								},
+							};
+
+							total_value_locked += bonded_pool.points_to_balance(*points);
+							let portion = Perbill::from_rational(*points, bonded_pool.points);
+							let last_claim = portion * accumulated_reward;
+
+							log!(
+								debug,
+								"{:?} has {:?} ({:?}) of pool {} with total reward of {:?}",
+								who,
+								portion,
+								last_claim,
+								id,
+								accumulated_reward
+							);
+
+							if last_claim.is_zero() {
+								None
+							} else {
+								Some((who, last_claim))
+							}
+						})
+						.for_each(|(who, last_claim)| {
+							let outcome = T::Currency::transfer(
+								&reward_account,
+								&who,
+								last_claim,
+								ExistenceRequirement::KeepAlive,
+							);
+
+							if let Err(reason) = outcome {
+								log!(warn, "last reward claim failed due to {:?}", reason,);
+							} else {
+								sum_paid_out = sum_paid_out.saturating_add(last_claim);
+							}
+
+							Pallet::<T>::deposit_event(Event::<T>::PaidOut {
+								member: who.clone(),
+								pool_id: id,
+								payout: last_claim,
+							});
+						});
+
+					// this can only be because of rounding down, or because the person we
+					// wanted to pay their reward to could not accept it (dust).
+					let leftover = accumulated_reward.saturating_sub(sum_paid_out);
+					if !leftover.is_zero() {
+						// pay it all to depositor.
+						let o = T::Currency::transfer(
+							&reward_account,
+							&bonded_pool.roles.depositor,
+							leftover,
+							ExistenceRequirement::KeepAlive,
+						);
+						log!(warn, "paying {:?} leftover to the depositor: {:?}", leftover, o);
+					}
+
+					// finally, migrate the reward pool.
+					reward_pools_translated += 1;
+
+					Some(RewardPool {
+						last_recorded_reward_counter: Zero::zero(),
+						last_recorded_total_payouts: Zero::zero(),
+						total_rewards_claimed: Zero::zero(),
+						total_commission_claimed: Zero::zero(),
+						total_commission_pending: Zero::zero(),
+					})
+				},
+			);
+
+			log!(
+				info,
+				"Upgraded {} members, {} reward pools, TVL {:?} TPL {:?}, storage to version {:?}",
+				members_translated,
+				reward_pools_translated,
+				total_value_locked,
+				total_points_locked,
+				current
+			);
+			current.put::<Pallet<T>>();
+
+			T::DbWeight::get().reads_writes(members_translated + 1, reward_pools_translated + 1)
+		}
+	}
+
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV2<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			log!(
+				info,
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current,
+				onchain
+			);
+
+			if current == 2 && onchain == 1 {
+				Self::run(current)
+			} else {
+				log!(info, "MigrateToV2 did not executed. This probably should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			// all reward accounts must have more than ED.
+			RewardPools::<T>::iter().try_for_each(|(id, _)| -> Result<(), TryRuntimeError> {
+				ensure!(
+					T::Currency::free_balance(&Pallet::<T>::create_reward_account(id)) >=
+						T::Currency::minimum_balance(),
+					"Reward accounts must have greater balance than ED."
+				);
+				Ok(())
+			})?;
+
+			Ok(Vec::new())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+			// new version must be set.
+			ensure!(
+				Pallet::<T>::on_chain_storage_version() == 2,
+				"The onchain version must be updated after the migration."
+			);
+
+			// no reward or bonded pool has been skipped.
+			ensure!(
+				RewardPools::<T>::iter().count() as u32 == RewardPools::<T>::count(),
+				"The count of reward pools must remain the same after the migration."
+			);
+			ensure!(
+				BondedPools::<T>::iter().count() as u32 == BondedPools::<T>::count(),
+				"The count of reward pools must remain the same after the migration."
+			);
+
+			// all reward pools must have exactly ED in them. This means no reward can be claimed,
+			// and that setting reward counters all over the board to zero will work henceforth.
+			RewardPools::<T>::iter().try_for_each(|(id, _)| -> Result<(), TryRuntimeError> {
+				ensure!(
+					RewardPool::<T>::current_balance(id) == Zero::zero(),
+					"Reward pool balance must be zero.",
+				);
+				Ok(())
+			})?;
+
+			log!(info, "post upgrade hook for MigrateToV2 executed.");
+			Ok(())
+		}
+	}
+}
+
+pub mod v3 {
+	use super::*;
+
+	/// This migration removes stale bonded-pool metadata, if any.
+	pub struct MigrateToV3<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV3<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			if onchain == 2 {
+				log!(
+					info,
+					"Running migration with current storage version {:?} / onchain {:?}",
+					current,
+					onchain
+				);
+
+				let mut metadata_iterated = 0u64;
+				let mut metadata_removed = 0u64;
+				Metadata::<T>::iter_keys()
+					.filter(|id| {
+						metadata_iterated += 1;
+						!BondedPools::<T>::contains_key(&id)
+					})
+					.collect::<Vec<_>>()
+					.into_iter()
+					.for_each(|id| {
+						metadata_removed += 1;
+						Metadata::<T>::remove(&id);
+					});
+				StorageVersion::new(3).put::<Pallet<T>>();
+				// metadata iterated + bonded pools read + a storage version read
+				let total_reads = metadata_iterated * 2 + 1;
+				// metadata removed + a storage version write
+				let total_writes = metadata_removed + 1;
+				T::DbWeight::get().reads_writes(total_reads, total_writes)
+			} else {
+				log!(info, "MigrateToV3 should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			Ok(Vec::new())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+			ensure!(
+				Metadata::<T>::iter_keys().all(|id| BondedPools::<T>::contains_key(&id)),
+				"not all of the stale metadata has been removed"
+			);
+			ensure!(
+				Pallet::<T>::on_chain_storage_version() >= 3,
+				"nomination-pools::migration::v3: wrong storage version"
+			);
+			Ok(())
+		}
+	}
+}
+
+pub mod v4 {
+	use super::*;
+
+	#[derive(Decode)]
+	pub struct OldBondedPoolInner<T: Config> {
+		pub points: BalanceOf<T>,
+		pub state: PoolState,
+		pub member_counter: u32,
+		pub roles: PoolRoles<T::AccountId>,
+	}
+
+	impl<T: Config> OldBondedPoolInner<T> {
+		fn migrate_to_v4(self) -> BondedPoolInner<T> {
+			BondedPoolInner {
+				commission: Commission::default(),
+				member_counter: self.member_counter,
+				points: self.points,
+				state: self.state,
+				roles: self.roles,
+			}
+		}
+	}
+
+	/// Migrates from `v3` directly to `v5` to avoid the broken `v4` migration.
+	#[allow(deprecated)]
+	pub type MigrateV3ToV5<T, U> = (v4::MigrateToV4<T, U>, v5::MigrateToV5<T>);
+
+	/// # Warning
+	///
+	/// To avoid mangled storage please use `MigrateV3ToV5` instead.
+	/// See: github.com/paritytech/substrate/pull/13715
+	///
+	/// This migration adds a `commission` field to every `BondedPoolInner`, if
+	/// any.
+	#[deprecated(
+		note = "To avoid mangled storage please use `MigrateV3ToV5` instead. See: github.com/paritytech/substrate/pull/13715"
+	)]
+	pub struct MigrateToV4<T, U>(sp_std::marker::PhantomData<(T, U)>);
+	#[allow(deprecated)]
+	impl<T: Config, U: Get<Perbill>> OnRuntimeUpgrade for MigrateToV4<T, U> {
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			log!(
+				info,
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current,
+				onchain
+			);
+
+			if onchain == 3 {
+				log!(warn, "Please run MigrateToV5 immediately after this migration. See github.com/paritytech/substrate/pull/13715");
+				let initial_global_max_commission = U::get();
+				GlobalMaxCommission::<T>::set(Some(initial_global_max_commission));
+				log!(
+					info,
+					"Set initial global max commission to {:?}.",
+					initial_global_max_commission
+				);
+
+				let mut translated = 0u64;
+				BondedPools::<T>::translate::<OldBondedPoolInner<T>, _>(|_key, old_value| {
+					translated.saturating_inc();
+					Some(old_value.migrate_to_v4())
+				});
+
+				StorageVersion::new(4).put::<Pallet<T>>();
+				log!(info, "Upgraded {} pools, storage to version {:?}", translated, current);
+
+				// reads: translated + onchain version.
+				// writes: translated + current.put + initial global commission.
+				T::DbWeight::get().reads_writes(translated + 1, translated + 2)
+			} else {
+				log!(info, "Migration did not execute. This probably should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			Ok(Vec::new())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+			// ensure all BondedPools items now contain an `inner.commission: Commission` field.
+			ensure!(
+				BondedPools::<T>::iter().all(|(_, inner)|
+					// Check current
+					(inner.commission.current.is_none() ||
+					inner.commission.current.is_some()) &&
+					// Check max
+					(inner.commission.max.is_none() || inner.commission.max.is_some()) &&
+					// Check change_rate
+					(inner.commission.change_rate.is_none() ||
+					inner.commission.change_rate.is_some()) &&
+					// Check throttle_from
+					(inner.commission.throttle_from.is_none() ||
+					inner.commission.throttle_from.is_some())),
+				"a commission value has not been set correctly"
+			);
+			ensure!(
+				GlobalMaxCommission::<T>::get() == Some(U::get()),
+				"global maximum commission error"
+			);
+			ensure!(
+				Pallet::<T>::on_chain_storage_version() >= 4,
+				"nomination-pools::migration::v4: wrong storage version"
+			);
+			Ok(())
+		}
+	}
+}
+
+pub mod v5 {
+	use super::*;
+
+	#[derive(Decode)]
+	pub struct OldRewardPool<T: Config> {
+		last_recorded_reward_counter: T::RewardCounter,
+		last_recorded_total_payouts: BalanceOf<T>,
+		total_rewards_claimed: BalanceOf<T>,
+	}
+
+	impl<T: Config> OldRewardPool<T> {
+		fn migrate_to_v5(self) -> RewardPool<T> {
+			RewardPool {
+				last_recorded_reward_counter: self.last_recorded_reward_counter,
+				last_recorded_total_payouts: self.last_recorded_total_payouts,
+				total_rewards_claimed: self.total_rewards_claimed,
+				total_commission_pending: Zero::zero(),
+				total_commission_claimed: Zero::zero(),
+			}
+		}
+	}
+
+	/// This migration adds `total_commission_pending` and `total_commission_claimed` field to every
+	/// `RewardPool`, if any.
+	pub struct MigrateToV5<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV5<T> {
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = Pallet::<T>::on_chain_storage_version();
+
+			log!(
+				info,
+				"Running migration with current storage version {:?} / onchain {:?}",
+				current,
+				onchain
+			);
+
+			if current == 5 && onchain == 4 {
+				let mut translated = 0u64;
+				RewardPools::<T>::translate::<OldRewardPool<T>, _>(|_id, old_value| {
+					translated.saturating_inc();
+					Some(old_value.migrate_to_v5())
+				});
+
+				current.put::<Pallet<T>>();
+				log!(info, "Upgraded {} pools, storage to version {:?}", translated, current);
+
+				// reads: translated + onchain version.
+				// writes: translated + current.put.
+				T::DbWeight::get().reads_writes(translated + 1, translated + 1)
+			} else {
+				log!(info, "Migration did not execute. This probably should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			let rpool_keys = RewardPools::<T>::iter_keys().count();
+			let rpool_values = RewardPools::<T>::iter_values().count();
+			if rpool_keys != rpool_values {
+				log!(info, "🔥 There are {} undecodable RewardPools in storage. This migration will try to correct them. keys: {}, values: {}", rpool_keys.saturating_sub(rpool_values), rpool_keys, rpool_values);
+			}
+
+			ensure!(
+				PoolMembers::<T>::iter_keys().count() == PoolMembers::<T>::iter_values().count(),
+				"There are undecodable PoolMembers in storage. This migration will not fix that."
+			);
+			ensure!(
+				BondedPools::<T>::iter_keys().count() == BondedPools::<T>::iter_values().count(),
+				"There are undecodable BondedPools in storage. This migration will not fix that."
+			);
+			ensure!(
+				SubPoolsStorage::<T>::iter_keys().count() ==
+					SubPoolsStorage::<T>::iter_values().count(),
+				"There are undecodable SubPools in storage. This migration will not fix that."
+			);
+			ensure!(
+				Metadata::<T>::iter_keys().count() == Metadata::<T>::iter_values().count(),
+				"There are undecodable Metadata in storage. This migration will not fix that."
+			);
+
+			Ok((rpool_values as u64).encode())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(data: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let old_rpool_values: u64 = Decode::decode(&mut &data[..]).unwrap();
+			let rpool_keys = RewardPools::<T>::iter_keys().count() as u64;
+			let rpool_values = RewardPools::<T>::iter_values().count() as u64;
+			ensure!(
+				rpool_keys == rpool_values,
+				"There are STILL undecodable RewardPools - migration failed"
+			);
+
+			if old_rpool_values != rpool_values {
+				log!(
+					info,
+					"🎉 Fixed {} undecodable RewardPools.",
+					rpool_values.saturating_sub(old_rpool_values)
+				);
+			}
+
+			// ensure all RewardPools items now contain `total_commission_pending` and
+			// `total_commission_claimed` field.
+			ensure!(
+				RewardPools::<T>::iter().all(|(_, reward_pool)| reward_pool
+					.total_commission_pending >=
+					Zero::zero() && reward_pool
+					.total_commission_claimed >=
+					Zero::zero()),
+				"a commission value has been incorrectly set"
+			);
+			ensure!(
+				Pallet::<T>::on_chain_storage_version() >= 5,
+				"nomination-pools::migration::v5: wrong storage version"
+			);
+
+			// These should not have been touched - just in case.
+			ensure!(
+				PoolMembers::<T>::iter_keys().count() == PoolMembers::<T>::iter_values().count(),
+				"There are undecodable PoolMembers in storage."
+			);
+			ensure!(
+				BondedPools::<T>::iter_keys().count() == BondedPools::<T>::iter_values().count(),
+				"There are undecodable BondedPools in storage."
+			);
+			ensure!(
+				SubPoolsStorage::<T>::iter_keys().count() ==
+					SubPoolsStorage::<T>::iter_values().count(),
+				"There are undecodable SubPools in storage."
+			);
+			ensure!(
+				Metadata::<T>::iter_keys().count() == Metadata::<T>::iter_values().count(),
+				"There are undecodable Metadata in storage."
+			);
+
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/nomination-pools/src/mock.rs b/substrate/frame/nomination-pools/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7d0d729a40d413edba5014f4cd27b507177e63f2
--- /dev/null
+++ b/substrate/frame/nomination-pools/src/mock.rs
@@ -0,0 +1,446 @@
+use super::*;
+use crate::{self as pools};
+use frame_support::{assert_ok, parameter_types, PalletId};
+use frame_system::RawOrigin;
+use sp_runtime::{BuildStorage, FixedU128};
+use sp_staking::Stake;
+
+pub type BlockNumber = u64;
+pub type AccountId = u128;
+pub type Balance = u128;
+pub type RewardCounter = FixedU128;
+// This sneaky little hack allows us to write code exactly as we would do in the pallet in the tests
+// as well, e.g. `StorageItem::<T>::get()`.
+pub type T = Runtime;
+
+// Ext builder creates a pool with id 1.
+pub fn default_bonded_account() -> AccountId {
+	Pools::create_bonded_account(1)
+}
+
+// Ext builder creates a pool with id 1.
+pub fn default_reward_account() -> AccountId {
+	Pools::create_reward_account(1)
+}
+
+parameter_types! {
+	pub static MinJoinBondConfig: Balance = 2;
+	pub static CurrentEra: EraIndex = 0;
+	pub static BondingDuration: EraIndex = 3;
+	pub storage BondedBalanceMap: BTreeMap<AccountId, Balance> = Default::default();
+	pub storage UnbondingBalanceMap: BTreeMap<AccountId, Balance> = Default::default();
+	#[derive(Clone, PartialEq)]
+	pub static MaxUnbonding: u32 = 8;
+	pub static StakingMinBond: Balance = 10;
+	pub storage Nominations: Option<Vec<AccountId>> = None;
+}
+
+pub struct StakingMock;
+impl StakingMock {
+	pub(crate) fn set_bonded_balance(who: AccountId, bonded: Balance) {
+		let mut x = BondedBalanceMap::get();
+		x.insert(who, bonded);
+		BondedBalanceMap::set(&x)
+	}
+}
+
+impl sp_staking::StakingInterface for StakingMock {
+	type Balance = Balance;
+	type AccountId = AccountId;
+	type CurrencyToVote = ();
+
+	fn minimum_nominator_bond() -> Self::Balance {
+		StakingMinBond::get()
+	}
+	fn minimum_validator_bond() -> Self::Balance {
+		StakingMinBond::get()
+	}
+
+	fn desired_validator_count() -> u32 {
+		unimplemented!("method currently not used in testing")
+	}
+
+	fn current_era() -> EraIndex {
+		CurrentEra::get()
+	}
+
+	fn bonding_duration() -> EraIndex {
+		BondingDuration::get()
+	}
+
+	fn status(
+		_: &Self::AccountId,
+	) -> Result<sp_staking::StakerStatus<Self::AccountId>, DispatchError> {
+		Nominations::get()
+			.map(|noms| sp_staking::StakerStatus::Nominator(noms))
+			.ok_or(DispatchError::Other("NotStash"))
+	}
+
+	fn bond_extra(who: &Self::AccountId, extra: Self::Balance) -> DispatchResult {
+		let mut x = BondedBalanceMap::get();
+		x.get_mut(who).map(|v| *v += extra);
+		BondedBalanceMap::set(&x);
+		Ok(())
+	}
+
+	fn unbond(who: &Self::AccountId, amount: Self::Balance) -> DispatchResult {
+		let mut x = BondedBalanceMap::get();
+		*x.get_mut(who).unwrap() = x.get_mut(who).unwrap().saturating_sub(amount);
+		BondedBalanceMap::set(&x);
+		let mut y = UnbondingBalanceMap::get();
+		*y.entry(*who).or_insert(Self::Balance::zero()) += amount;
+		UnbondingBalanceMap::set(&y);
+		Ok(())
+	}
+
+	fn chill(_: &Self::AccountId) -> sp_runtime::DispatchResult {
+		Ok(())
+	}
+
+	fn withdraw_unbonded(who: Self::AccountId, _: u32) -> Result<bool, DispatchError> {
+		// Simulates removing unlocking chunks and only having the bonded balance locked
+		let mut x = UnbondingBalanceMap::get();
+		x.remove(&who);
+		UnbondingBalanceMap::set(&x);
+
+		Ok(UnbondingBalanceMap::get().is_empty() && BondedBalanceMap::get().is_empty())
+	}
+
+	fn bond(stash: &Self::AccountId, value: Self::Balance, _: &Self::AccountId) -> DispatchResult {
+		StakingMock::set_bonded_balance(*stash, value);
+		Ok(())
+	}
+
+	fn nominate(_: &Self::AccountId, nominations: Vec<Self::AccountId>) -> DispatchResult {
+		Nominations::set(&Some(nominations));
+		Ok(())
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn nominations(_: &Self::AccountId) -> Option<Vec<Self::AccountId>> {
+		Nominations::get()
+	}
+
+	fn stash_by_ctrl(_controller: &Self::AccountId) -> Result<Self::AccountId, DispatchError> {
+		unimplemented!("method currently not used in testing")
+	}
+
+	fn stake(who: &Self::AccountId) -> Result<Stake<Balance>, DispatchError> {
+		match (
+			UnbondingBalanceMap::get().get(who).copied(),
+			BondedBalanceMap::get().get(who).copied(),
+		) {
+			(None, None) => Err(DispatchError::Other("balance not found")),
+			(Some(v), None) => Ok(Stake { total: v, active: 0 }),
+			(None, Some(v)) => Ok(Stake { total: v, active: v }),
+			(Some(a), Some(b)) => Ok(Stake { total: a + b, active: b }),
+		}
+	}
+
+	fn election_ongoing() -> bool {
+		unimplemented!("method currently not used in testing")
+	}
+
+	fn force_unstake(_who: Self::AccountId) -> sp_runtime::DispatchResult {
+		unimplemented!("method currently not used in testing")
+	}
+
+	fn is_exposed_in_era(_who: &Self::AccountId, _era: &EraIndex) -> bool {
+		unimplemented!("method currently not used in testing")
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add_era_stakers(
+		_current_era: &EraIndex,
+		_stash: &Self::AccountId,
+		_exposures: Vec<(Self::AccountId, Self::Balance)>,
+	) {
+		unimplemented!("method currently not used in testing")
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn set_current_era(_era: EraIndex) {
+		unimplemented!("method currently not used in testing")
+	}
+}
+
+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;
+}
+
+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 = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+
+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 PostUnbondingPoolsWindow: u32 = 2;
+	pub static MaxMetadataLen: u32 = 2;
+	pub static CheckLevel: u8 = 255;
+	pub const PoolsPalletId: PalletId = PalletId(*b"py/nopls");
+}
+impl pools::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type RewardCounter = RewardCounter;
+	type BalanceToU256 = BalanceToU256;
+	type U256ToBalance = U256ToBalance;
+	type Staking = StakingMock;
+	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
+	type PalletId = PoolsPalletId;
+	type MaxMetadataLen = MaxMetadataLen;
+	type MaxUnbonding = MaxUnbonding;
+	type MaxPointsToBalance = frame_support::traits::ConstU8<10>;
+}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Storage, Event<T>, Config<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pools: pools::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+pub struct ExtBuilder {
+	members: Vec<(AccountId, Balance)>,
+	max_members: Option<u32>,
+	max_members_per_pool: Option<u32>,
+	global_max_commission: Option<Perbill>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			members: Default::default(),
+			max_members: Some(4),
+			max_members_per_pool: Some(3),
+			global_max_commission: Some(Perbill::from_percent(90)),
+		}
+	}
+}
+
+#[cfg_attr(feature = "fuzzing", allow(dead_code))]
+impl ExtBuilder {
+	// Add members to pool 0.
+	pub fn add_members(mut self, members: Vec<(AccountId, Balance)>) -> Self {
+		self.members = members;
+		self
+	}
+
+	pub fn ed(self, ed: Balance) -> Self {
+		ExistentialDeposit::set(ed);
+		self
+	}
+
+	pub fn min_bond(self, min: Balance) -> Self {
+		StakingMinBond::set(min);
+		self
+	}
+
+	pub fn min_join_bond(self, min: Balance) -> Self {
+		MinJoinBondConfig::set(min);
+		self
+	}
+
+	pub fn with_check(self, level: u8) -> Self {
+		CheckLevel::set(level);
+		self
+	}
+
+	pub fn max_members(mut self, max: Option<u32>) -> Self {
+		self.max_members = max;
+		self
+	}
+
+	pub fn max_members_per_pool(mut self, max: Option<u32>) -> Self {
+		self.max_members_per_pool = max;
+		self
+	}
+
+	pub fn global_max_commission(mut self, commission: Option<Perbill>) -> Self {
+		self.global_max_commission = commission;
+		self
+	}
+
+	pub fn build(self) -> sp_io::TestExternalities {
+		sp_tracing::try_init_simple();
+		let mut storage =
+			frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+
+		let _ = crate::GenesisConfig::<Runtime> {
+			min_join_bond: MinJoinBondConfig::get(),
+			min_create_bond: 2,
+			max_pools: Some(2),
+			max_members_per_pool: self.max_members_per_pool,
+			max_members: self.max_members,
+			global_max_commission: self.global_max_commission,
+		}
+		.assimilate_storage(&mut storage);
+
+		let mut ext = sp_io::TestExternalities::from(storage);
+
+		ext.execute_with(|| {
+			// for events to be deposited.
+			frame_system::Pallet::<Runtime>::set_block_number(1);
+
+			// make a pool
+			let amount_to_bond = Pools::depositor_min_bond();
+			Balances::make_free_balance_be(&10, amount_to_bond * 5);
+			assert_ok!(Pools::create(RawOrigin::Signed(10).into(), amount_to_bond, 900, 901, 902));
+			assert_ok!(Pools::set_metadata(RuntimeOrigin::signed(900), 1, vec![1, 1]));
+			let last_pool = LastPoolId::<Runtime>::get();
+			for (account_id, bonded) in self.members {
+				Balances::make_free_balance_be(&account_id, bonded * 2);
+				assert_ok!(Pools::join(RawOrigin::Signed(account_id).into(), bonded, last_pool));
+			}
+		});
+
+		ext
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce()) {
+		self.build().execute_with(|| {
+			test();
+			Pools::do_try_state(CheckLevel::get()).unwrap();
+		})
+	}
+}
+
+pub fn unsafe_set_state(pool_id: PoolId, state: PoolState) {
+	BondedPools::<Runtime>::try_mutate(pool_id, |maybe_bonded_pool| {
+		maybe_bonded_pool.as_mut().ok_or(()).map(|bonded_pool| {
+			bonded_pool.state = state;
+		})
+	})
+	.unwrap()
+}
+
+parameter_types! {
+	storage PoolsEvents: u32 = 0;
+	storage BalancesEvents: u32 = 0;
+}
+
+/// Helper to run a specified amount of blocks.
+pub fn run_blocks(n: u64) {
+	let current_block = System::block_number();
+	run_to_block(n + current_block);
+}
+
+/// Helper to run to a specific block.
+pub fn run_to_block(n: u64) {
+	let current_block = System::block_number();
+	assert!(n > current_block);
+	while System::block_number() < n {
+		Pools::on_finalize(System::block_number());
+		System::set_block_number(System::block_number() + 1);
+		Pools::on_initialize(System::block_number());
+	}
+}
+
+/// All events of this pallet.
+pub fn pool_events_since_last_call() -> Vec<super::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 = PoolsEvents::get();
+	PoolsEvents::set(&(events.len() as u32));
+	events.into_iter().skip(already_seen as usize).collect()
+}
+
+/// All events of the `Balances` pallet.
+pub fn balances_events_since_last_call() -> Vec<pallet_balances::Event<Runtime>> {
+	let events = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::Balances(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>();
+	let already_seen = BalancesEvents::get();
+	BalancesEvents::set(&(events.len() as u32));
+	events.into_iter().skip(already_seen as usize).collect()
+}
+
+/// Same as `fully_unbond`, in permissioned setting.
+pub fn fully_unbond_permissioned(member: AccountId) -> DispatchResult {
+	let points = PoolMembers::<Runtime>::get(member)
+		.map(|d| d.active_points())
+		.unwrap_or_default();
+	Pools::unbond(RuntimeOrigin::signed(member), member, points)
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	#[test]
+	fn u256_to_balance_convert_works() {
+		assert_eq!(U256ToBalance::convert(0u32.into()), Zero::zero());
+		assert_eq!(U256ToBalance::convert(Balance::max_value().into()), Balance::max_value())
+	}
+
+	#[test]
+	#[should_panic]
+	fn u256_to_balance_convert_panics_correctly() {
+		U256ToBalance::convert(U256::from(Balance::max_value()).saturating_add(1u32.into()));
+	}
+
+	#[test]
+	fn balance_to_u256_convert_works() {
+		assert_eq!(BalanceToU256::convert(0u32.into()), U256::zero());
+		assert_eq!(BalanceToU256::convert(Balance::max_value()), Balance::max_value().into())
+	}
+}
diff --git a/substrate/frame/nomination-pools/src/tests.rs b/substrate/frame/nomination-pools/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d0fe4e40a18b75d90b639271f90b249596208d84
--- /dev/null
+++ b/substrate/frame/nomination-pools/src/tests.rs
@@ -0,0 +1,6729 @@
+// 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 crate::{mock::*, Event};
+use frame_support::{assert_err, assert_noop, assert_ok, assert_storage_noop};
+use pallet_balances::Event as BEvent;
+use sp_runtime::{bounded_btree_map, traits::Dispatchable, FixedU128};
+
+macro_rules! unbonding_pools_with_era {
+	($($k:expr => $v:expr),* $(,)?) => {{
+		use sp_std::iter::{Iterator, IntoIterator};
+		let not_bounded: BTreeMap<_, _> = Iterator::collect(IntoIterator::into_iter([$(($k, $v),)*]));
+		BoundedBTreeMap::<EraIndex, UnbondPool<T>, TotalUnbondingPools<T>>::try_from(not_bounded).unwrap()
+	}};
+}
+
+macro_rules! member_unbonding_eras {
+	($( $any:tt )*) => {{
+		let x: BoundedBTreeMap<EraIndex, Balance, MaxUnbonding> = bounded_btree_map!($( $any )*);
+		x
+	}};
+}
+
+pub const DEFAULT_ROLES: PoolRoles<AccountId> =
+	PoolRoles { depositor: 10, root: Some(900), nominator: Some(901), bouncer: Some(902) };
+
+fn deposit_rewards(r: u128) {
+	let b = Balances::free_balance(&default_reward_account()).checked_add(r).unwrap();
+	Balances::make_free_balance_be(&default_reward_account(), b);
+}
+
+fn remove_rewards(r: u128) {
+	let b = Balances::free_balance(&default_reward_account()).checked_sub(r).unwrap();
+	Balances::make_free_balance_be(&default_reward_account(), b);
+}
+
+#[test]
+fn test_setup_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(BondedPools::<Runtime>::count(), 1);
+		assert_eq!(RewardPools::<Runtime>::count(), 1);
+		assert_eq!(SubPoolsStorage::<Runtime>::count(), 0);
+		assert_eq!(PoolMembers::<Runtime>::count(), 1);
+		assert_eq!(StakingMock::bonding_duration(), 3);
+		assert!(Metadata::<T>::contains_key(1));
+
+		let last_pool = LastPoolId::<Runtime>::get();
+		assert_eq!(
+			BondedPool::<Runtime>::get(last_pool).unwrap(),
+			BondedPool::<Runtime> {
+				id: last_pool,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 10,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			}
+		);
+		assert_eq!(
+			RewardPools::<Runtime>::get(last_pool).unwrap(),
+			RewardPool::<Runtime> {
+				last_recorded_reward_counter: Zero::zero(),
+				last_recorded_total_payouts: 0,
+				total_rewards_claimed: 0,
+				total_commission_claimed: 0,
+				total_commission_pending: 0,
+			}
+		);
+		assert_eq!(
+			PoolMembers::<Runtime>::get(10).unwrap(),
+			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);
+
+		// the bonded_account should be bonded by the depositor's funds.
+		assert_eq!(StakingMock::active_stake(&bonded_account).unwrap(), 10);
+		assert_eq!(StakingMock::total_stake(&bonded_account).unwrap(), 10);
+
+		// but not nominating yet.
+		assert!(Nominations::get().is_none());
+
+		// reward account should have an initial ED in it.
+		assert_eq!(Balances::free_balance(&reward_account), Balances::minimum_balance());
+	})
+}
+
+mod bonded_pool {
+	use super::*;
+	#[test]
+	fn balance_to_point_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let mut bonded_pool = BondedPool::<Runtime> {
+				id: 123123,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 100,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			};
+
+			// 1 points : 1 balance ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 100);
+			assert_eq!(bonded_pool.balance_to_point(10), 10);
+			assert_eq!(bonded_pool.balance_to_point(0), 0);
+
+			// 2 points : 1 balance ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 50);
+			assert_eq!(bonded_pool.balance_to_point(10), 20);
+
+			// 1 points : 2 balance ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 100);
+			bonded_pool.points = 50;
+			assert_eq!(bonded_pool.balance_to_point(10), 5);
+
+			// 100 points : 0 balance ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 0);
+			bonded_pool.points = 100;
+			assert_eq!(bonded_pool.balance_to_point(10), 100 * 10);
+
+			// 0 points : 100 balance
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 100);
+			bonded_pool.points = 0;
+			assert_eq!(bonded_pool.balance_to_point(10), 10);
+
+			// 10 points : 3 balance ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 30);
+			bonded_pool.points = 100;
+			assert_eq!(bonded_pool.balance_to_point(10), 33);
+
+			// 2 points : 3 balance ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 300);
+			bonded_pool.points = 200;
+			assert_eq!(bonded_pool.balance_to_point(10), 6);
+
+			// 4 points : 9 balance ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 900);
+			bonded_pool.points = 400;
+			assert_eq!(bonded_pool.balance_to_point(90), 40);
+		})
+	}
+
+	#[test]
+	fn points_to_balance_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// 1 balance : 1 points ratio
+			let mut bonded_pool = BondedPool::<Runtime> {
+				id: 123123,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 100,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			};
+
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 100);
+			assert_eq!(bonded_pool.points_to_balance(10), 10);
+			assert_eq!(bonded_pool.points_to_balance(0), 0);
+
+			// 2 balance : 1 points ratio
+			bonded_pool.points = 50;
+			assert_eq!(bonded_pool.points_to_balance(10), 20);
+
+			// 100 balance : 0 points ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 100);
+			bonded_pool.points = 0;
+			assert_eq!(bonded_pool.points_to_balance(10), 0);
+
+			// 0 balance : 100 points ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 0);
+			bonded_pool.points = 100;
+			assert_eq!(bonded_pool.points_to_balance(10), 0);
+
+			// 10 balance : 3 points ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 100);
+			bonded_pool.points = 30;
+			assert_eq!(bonded_pool.points_to_balance(10), 33);
+
+			// 2 balance : 3 points ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 200);
+			bonded_pool.points = 300;
+			assert_eq!(bonded_pool.points_to_balance(10), 6);
+
+			// 4 balance : 9 points ratio
+			StakingMock::set_bonded_balance(bonded_pool.bonded_account(), 400);
+			bonded_pool.points = 900;
+			assert_eq!(bonded_pool.points_to_balance(90), 40);
+		})
+	}
+
+	#[test]
+	fn api_points_to_balance_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert!(BondedPool::<Runtime>::get(1).is_some());
+			assert_eq!(Pallet::<Runtime>::api_points_to_balance(1, 10), 10);
+
+			// slash half of the pool's balance. expected result of `fn api_points_to_balance`
+			// to be 1/2 of the pool's balance.
+			StakingMock::set_bonded_balance(
+				default_bonded_account(),
+				Pools::depositor_min_bond() / 2,
+			);
+			assert_eq!(Pallet::<Runtime>::api_points_to_balance(1, 10), 5);
+
+			// if pool does not exist, points to balance ratio is 0.
+			assert_eq!(BondedPool::<Runtime>::get(2), None);
+			assert_eq!(Pallet::<Runtime>::api_points_to_balance(2, 10), 0);
+		})
+	}
+
+	#[test]
+	fn api_balance_to_points_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(Pallet::<Runtime>::api_balance_to_points(1, 0), 0);
+			assert_eq!(Pallet::<Runtime>::api_balance_to_points(1, 10), 10);
+
+			// slash half of the pool's balance. expect result of `fn api_balance_to_points`
+			// to be 2 * of the balance to add to the pool.
+			StakingMock::set_bonded_balance(
+				default_bonded_account(),
+				Pools::depositor_min_bond() / 2,
+			);
+			assert_eq!(Pallet::<Runtime>::api_balance_to_points(1, 10), 20);
+
+			// if pool does not exist, balance to points ratio is 0.
+			assert_eq!(BondedPool::<Runtime>::get(2), None);
+			assert_eq!(Pallet::<Runtime>::api_points_to_balance(2, 10), 0);
+		})
+	}
+
+	#[test]
+	fn ok_to_join_with_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let pool = BondedPool::<Runtime> {
+				id: 123,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 100,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			};
+
+			let max_points_to_balance: u128 =
+				<<Runtime as Config>::MaxPointsToBalance as Get<u8>>::get().into();
+
+			// Simulate a 100% slashed pool
+			StakingMock::set_bonded_balance(pool.bonded_account(), 0);
+			assert_noop!(pool.ok_to_join(), Error::<Runtime>::OverflowRisk);
+
+			// Simulate a slashed pool at `MaxPointsToBalance` + 1 slashed pool
+			StakingMock::set_bonded_balance(
+				pool.bonded_account(),
+				max_points_to_balance.saturating_add(1),
+			);
+			assert_ok!(pool.ok_to_join());
+
+			// Simulate a slashed pool at `MaxPointsToBalance`
+			StakingMock::set_bonded_balance(pool.bonded_account(), max_points_to_balance);
+			assert_noop!(pool.ok_to_join(), Error::<Runtime>::OverflowRisk);
+
+			StakingMock::set_bonded_balance(
+				pool.bonded_account(),
+				Balance::MAX / max_points_to_balance,
+			);
+
+			// and a sanity check
+			StakingMock::set_bonded_balance(
+				pool.bonded_account(),
+				Balance::MAX / max_points_to_balance - 1,
+			);
+			assert_ok!(pool.ok_to_join());
+		});
+	}
+}
+
+mod reward_pool {
+	#[test]
+	fn current_balance_only_counts_balance_over_existential_deposit() {
+		use super::*;
+
+		ExtBuilder::default().build_and_execute(|| {
+			let reward_account = Pools::create_reward_account(2);
+
+			// Given
+			assert_eq!(Balances::free_balance(&reward_account), 0);
+
+			// Then
+			assert_eq!(RewardPool::<Runtime>::current_balance(2), 0);
+
+			// Given
+			Balances::make_free_balance_be(&reward_account, Balances::minimum_balance());
+
+			// Then
+			assert_eq!(RewardPool::<Runtime>::current_balance(2), 0);
+
+			// Given
+			Balances::make_free_balance_be(&reward_account, Balances::minimum_balance() + 1);
+
+			// Then
+			assert_eq!(RewardPool::<Runtime>::current_balance(2), 1);
+		});
+	}
+}
+
+mod unbond_pool {
+	use super::*;
+
+	#[test]
+	fn points_to_issue_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// 1 points : 1 balance ratio
+			let unbond_pool = UnbondPool::<Runtime> { points: 100, balance: 100 };
+			assert_eq!(unbond_pool.balance_to_point(10), 10);
+			assert_eq!(unbond_pool.balance_to_point(0), 0);
+
+			// 2 points : 1 balance ratio
+			let unbond_pool = UnbondPool::<Runtime> { points: 100, balance: 50 };
+			assert_eq!(unbond_pool.balance_to_point(10), 20);
+
+			// 1 points : 2 balance ratio
+			let unbond_pool = UnbondPool::<Runtime> { points: 50, balance: 100 };
+			assert_eq!(unbond_pool.balance_to_point(10), 5);
+
+			// 100 points : 0 balance ratio
+			let unbond_pool = UnbondPool::<Runtime> { points: 100, balance: 0 };
+			assert_eq!(unbond_pool.balance_to_point(10), 100 * 10);
+
+			// 0 points : 100 balance
+			let unbond_pool = UnbondPool::<Runtime> { points: 0, balance: 100 };
+			assert_eq!(unbond_pool.balance_to_point(10), 10);
+
+			// 10 points : 3 balance ratio
+			let unbond_pool = UnbondPool::<Runtime> { points: 100, balance: 30 };
+			assert_eq!(unbond_pool.balance_to_point(10), 33);
+
+			// 2 points : 3 balance ratio
+			let unbond_pool = UnbondPool::<Runtime> { points: 200, balance: 300 };
+			assert_eq!(unbond_pool.balance_to_point(10), 6);
+
+			// 4 points : 9 balance ratio
+			let unbond_pool = UnbondPool::<Runtime> { points: 400, balance: 900 };
+			assert_eq!(unbond_pool.balance_to_point(90), 40);
+		})
+	}
+
+	#[test]
+	fn balance_to_unbond_works() {
+		// 1 balance : 1 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 100, balance: 100 };
+		assert_eq!(unbond_pool.point_to_balance(10), 10);
+		assert_eq!(unbond_pool.point_to_balance(0), 0);
+
+		// 1 balance : 2 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 100, balance: 50 };
+		assert_eq!(unbond_pool.point_to_balance(10), 5);
+
+		// 2 balance : 1 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 50, balance: 100 };
+		assert_eq!(unbond_pool.point_to_balance(10), 20);
+
+		// 100 balance : 0 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 0, balance: 100 };
+		assert_eq!(unbond_pool.point_to_balance(10), 0);
+
+		// 0 balance : 100 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 100, balance: 0 };
+		assert_eq!(unbond_pool.point_to_balance(10), 0);
+
+		// 10 balance : 3 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 30, balance: 100 };
+		assert_eq!(unbond_pool.point_to_balance(10), 33);
+
+		// 2 balance : 3 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 300, balance: 200 };
+		assert_eq!(unbond_pool.point_to_balance(10), 6);
+
+		// 4 balance : 9 points ratio
+		let unbond_pool = UnbondPool::<Runtime> { points: 900, balance: 400 };
+		assert_eq!(unbond_pool.point_to_balance(90), 40);
+	}
+}
+
+mod sub_pools {
+	use super::*;
+
+	#[test]
+	fn maybe_merge_pools_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(TotalUnbondingPools::<Runtime>::get(), 5);
+			assert_eq!(BondingDuration::get(), 3);
+			assert_eq!(PostUnbondingPoolsWindow::get(), 2);
+
+			// Given
+			let mut sub_pool_0 = SubPools::<Runtime> {
+				no_era: UnbondPool::<Runtime>::default(),
+				with_era: unbonding_pools_with_era! {
+					0 => UnbondPool::<Runtime> { points: 10, balance: 10 },
+					1 => UnbondPool::<Runtime> { points: 10, balance: 10 },
+					2 => UnbondPool::<Runtime> { points: 20, balance: 20 },
+					3 => UnbondPool::<Runtime> { points: 30, balance: 30 },
+					4 => UnbondPool::<Runtime> { points: 40, balance: 40 },
+				},
+			};
+
+			// When `current_era < TotalUnbondingPools`,
+			let sub_pool_1 = sub_pool_0.clone().maybe_merge_pools(0);
+
+			// Then it exits early without modifications
+			assert_eq!(sub_pool_1, sub_pool_0);
+
+			// When `current_era == TotalUnbondingPools`,
+			let sub_pool_1 = sub_pool_1.maybe_merge_pools(1);
+
+			// Then it exits early without modifications
+			assert_eq!(sub_pool_1, sub_pool_0);
+
+			// When  `current_era - TotalUnbondingPools == 0`,
+			let mut sub_pool_1 = sub_pool_1.maybe_merge_pools(2);
+
+			// Then era 0 is merged into the `no_era` pool
+			sub_pool_0.no_era = sub_pool_0.with_era.remove(&0).unwrap();
+			assert_eq!(sub_pool_1, sub_pool_0);
+
+			// Given we have entries for era 1..=5
+			sub_pool_1
+				.with_era
+				.try_insert(5, UnbondPool::<Runtime> { points: 50, balance: 50 })
+				.unwrap();
+			sub_pool_0
+				.with_era
+				.try_insert(5, UnbondPool::<Runtime> { points: 50, balance: 50 })
+				.unwrap();
+
+			// When `current_era - TotalUnbondingPools == 1`
+			let sub_pool_2 = sub_pool_1.maybe_merge_pools(3);
+			let era_1_pool = sub_pool_0.with_era.remove(&1).unwrap();
+
+			// Then era 1 is merged into the `no_era` pool
+			sub_pool_0.no_era.points += era_1_pool.points;
+			sub_pool_0.no_era.balance += era_1_pool.balance;
+			assert_eq!(sub_pool_2, sub_pool_0);
+
+			// When `current_era - TotalUnbondingPools == 5`, so all pools with era <= 4 are removed
+			let sub_pool_3 = sub_pool_2.maybe_merge_pools(7);
+
+			// Then all eras <= 5 are merged into the `no_era` pool
+			for era in 2..=5 {
+				let to_merge = sub_pool_0.with_era.remove(&era).unwrap();
+				sub_pool_0.no_era.points += to_merge.points;
+				sub_pool_0.no_era.balance += to_merge.balance;
+			}
+			assert_eq!(sub_pool_3, sub_pool_0);
+		});
+	}
+}
+
+mod join {
+	use sp_runtime::TokenError;
+
+	use super::*;
+
+	#[test]
+	fn join_works() {
+		let bonded = |points, member_counter| BondedPool::<Runtime> {
+			id: 1,
+			inner: BondedPoolInner {
+				commission: Commission::default(),
+				member_counter,
+				points,
+				roles: DEFAULT_ROLES,
+				state: PoolState::Open,
+			},
+		};
+		ExtBuilder::default().with_check(0).build_and_execute(|| {
+			// Given
+			Balances::make_free_balance_be(&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() }
+			);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap(), bonded(12, 2));
+
+			// Given
+			// The bonded balance is slashed in half
+			StakingMock::set_bonded_balance(Pools::create_bonded_account(1), 6);
+
+			// And
+			Balances::make_free_balance_be(&12, ExistentialDeposit::get() + 12);
+			assert!(!PoolMembers::<Runtime>::contains_key(12));
+
+			// When
+			assert_ok!(Pools::join(RuntimeOrigin::signed(12), 12, 1));
+
+			// Then
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Bonded { member: 12, pool_id: 1, bonded: 12, joined: true }]
+			);
+
+			assert_eq!(
+				PoolMembers::<Runtime>::get(12).unwrap(),
+				PoolMember::<Runtime> { pool_id: 1, points: 24, ..Default::default() }
+			);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap(), bonded(12 + 24, 3));
+		});
+	}
+
+	#[test]
+	fn join_errors_correctly() {
+		ExtBuilder::default().with_check(0).build_and_execute(|| {
+			// 10 is already part of the default pool created.
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().pool_id, 1);
+
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(10), 420, 123),
+				Error::<Runtime>::AccountBelongsToOtherPool
+			);
+
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(11), 420, 123),
+				Error::<Runtime>::PoolNotFound
+			);
+
+			// Force the pools bonded balance to 0, simulating a 100% slash
+			StakingMock::set_bonded_balance(Pools::create_bonded_account(1), 0);
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(11), 420, 1),
+				Error::<Runtime>::OverflowRisk
+			);
+
+			// Given a mocked bonded pool
+			BondedPool::<Runtime> {
+				id: 123,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 100,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			}
+			.put();
+
+			// and reward pool
+			RewardPools::<Runtime>::insert(123, RewardPool::<Runtime> { ..Default::default() });
+
+			// Force the points:balance ratio to `MaxPointsToBalance` (100/10)
+			let max_points_to_balance: u128 =
+				<<Runtime as Config>::MaxPointsToBalance as Get<u8>>::get().into();
+
+			StakingMock::set_bonded_balance(
+				Pools::create_bonded_account(123),
+				max_points_to_balance,
+			);
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(11), 420, 123),
+				Error::<Runtime>::OverflowRisk
+			);
+
+			StakingMock::set_bonded_balance(
+				Pools::create_bonded_account(123),
+				Balance::MAX / max_points_to_balance,
+			);
+			// Balance needs to be gt Balance::MAX / `MaxPointsToBalance`
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(11), 5, 123),
+				TokenError::FundsUnavailable,
+			);
+
+			StakingMock::set_bonded_balance(Pools::create_bonded_account(1), max_points_to_balance);
+
+			// Cannot join a pool that isn't open
+			unsafe_set_state(123, PoolState::Blocked);
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(11), max_points_to_balance, 123),
+				Error::<Runtime>::NotOpen
+			);
+
+			unsafe_set_state(123, PoolState::Destroying);
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(11), max_points_to_balance, 123),
+				Error::<Runtime>::NotOpen
+			);
+
+			// Given
+			MinJoinBond::<Runtime>::put(100);
+
+			// Then
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(11), 99, 123),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+		});
+	}
+
+	#[test]
+	#[cfg_attr(debug_assertions, should_panic(expected = "Defensive failure has been triggered!"))]
+	#[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);
+			BondedPool::<Runtime> {
+				id: 123,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 100,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			}
+			.put();
+			let _ = Pools::join(RuntimeOrigin::signed(11), 420, 123);
+		});
+	}
+
+	#[test]
+	fn join_max_member_limits_are_respected() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Given
+			assert_eq!(MaxPoolMembersPerPool::<Runtime>::get(), Some(3));
+			for i in 1..3 {
+				let account = i + 100;
+				Balances::make_free_balance_be(&account, 100 + Balances::minimum_balance());
+
+				assert_ok!(Pools::join(RuntimeOrigin::signed(account), 100, 1));
+			}
+
+			Balances::make_free_balance_be(&103, 100 + Balances::minimum_balance());
+
+			// 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: 101, pool_id: 1, bonded: 100, joined: true },
+					Event::Bonded { member: 102, pool_id: 1, bonded: 100, joined: true }
+				]
+			);
+
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(103), 100, 1),
+				Error::<Runtime>::MaxPoolMembers
+			);
+
+			// Given
+			assert_eq!(PoolMembers::<Runtime>::count(), 3);
+			assert_eq!(MaxPoolMembers::<Runtime>::get(), Some(4));
+
+			Balances::make_free_balance_be(&104, 100 + Balances::minimum_balance());
+			assert_ok!(Pools::create(RuntimeOrigin::signed(104), 100, 104, 104, 104));
+
+			let pool_account = BondedPools::<Runtime>::iter()
+				.find(|(_, bonded_pool)| bonded_pool.roles.depositor == 104)
+				.map(|(pool_account, _)| pool_account)
+				.unwrap();
+
+			// Then
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 104, pool_id: 2 },
+					Event::Bonded { member: 104, pool_id: 2, bonded: 100, joined: true }
+				]
+			);
+
+			assert_noop!(
+				Pools::join(RuntimeOrigin::signed(103), 100, pool_account),
+				Error::<Runtime>::MaxPoolMembers
+			);
+		});
+	}
+}
+
+mod claim_payout {
+	use super::*;
+
+	fn del(points: Balance, last_recorded_reward_counter: u128) -> PoolMember<Runtime> {
+		PoolMember {
+			pool_id: 1,
+			points,
+			last_recorded_reward_counter: last_recorded_reward_counter.into(),
+			unbonding_eras: Default::default(),
+		}
+	}
+
+	fn del_float(points: Balance, last_recorded_reward_counter: f64) -> PoolMember<Runtime> {
+		PoolMember {
+			pool_id: 1,
+			points,
+			last_recorded_reward_counter: RewardCounter::from_float(last_recorded_reward_counter),
+			unbonding_eras: Default::default(),
+		}
+	}
+
+	fn rew(
+		last_recorded_reward_counter: u128,
+		last_recorded_total_payouts: Balance,
+		total_rewards_claimed: Balance,
+	) -> RewardPool<Runtime> {
+		RewardPool {
+			last_recorded_reward_counter: last_recorded_reward_counter.into(),
+			last_recorded_total_payouts,
+			total_rewards_claimed,
+			total_commission_claimed: 0,
+			total_commission_pending: 0,
+		}
+	}
+
+	#[test]
+	fn claim_payout_works() {
+		ExtBuilder::default()
+			.add_members(vec![(40, 40), (50, 50)])
+			.build_and_execute(|| {
+				// Given each member currently has a free balance of
+				Balances::make_free_balance_be(&10, 0);
+				Balances::make_free_balance_be(&40, 0);
+				Balances::make_free_balance_be(&50, 0);
+				let ed = Balances::minimum_balance();
+
+				// and the reward pool has earned 100 in rewards
+				assert_eq!(Balances::free_balance(default_reward_account()), ed);
+				deposit_rewards(100);
+
+				let _ = pool_events_since_last_call();
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 10 },]
+				);
+				// last recorded reward counter at the time of this member's payout is 1
+				assert_eq!(PoolMembers::<Runtime>::get(10).unwrap(), del(10, 1));
+				// pool's 'last_recorded_reward_counter' and 'last_recorded_total_payouts' don't
+				// really change unless if someone bonds/unbonds.
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 10));
+				assert_eq!(Balances::free_balance(&10), 10);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 90);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(40)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 40, pool_id: 1, payout: 40 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(40).unwrap(), del(40, 1));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 50));
+				assert_eq!(Balances::free_balance(&40), 40);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 50);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(50)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 50, pool_id: 1, payout: 50 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(50).unwrap(), del(50, 1));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 100));
+				assert_eq!(Balances::free_balance(&50), 50);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed);
+
+				// Given the reward pool has some new rewards
+				deposit_rewards(50);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 5 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(10).unwrap(), del_float(10, 1.5));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 105));
+				assert_eq!(Balances::free_balance(&10), 10 + 5);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 45);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(40)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 40, pool_id: 1, payout: 20 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(40).unwrap(), del_float(40, 1.5));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 125));
+				assert_eq!(Balances::free_balance(&40), 40 + 20);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 25);
+
+				// Given del 50 hasn't claimed and the reward pools has just earned 50
+				deposit_rewards(50);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 75);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(50)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 50, pool_id: 1, payout: 50 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(50).unwrap(), del_float(50, 2.0));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 175));
+				assert_eq!(Balances::free_balance(&50), 50 + 50);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 25);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 5 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(10).unwrap(), del(10, 2));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 180));
+				assert_eq!(Balances::free_balance(&10), 15 + 5);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 20);
+
+				// Given del 40 hasn't claimed and the reward pool has just earned 400
+				deposit_rewards(400);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 420);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 40 }]
+				);
+
+				// We expect a payout of 40
+				assert_eq!(PoolMembers::<Runtime>::get(10).unwrap(), del(10, 6));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 220));
+				assert_eq!(Balances::free_balance(&10), 20 + 40);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 380);
+
+				// Given del 40 + del 50 haven't claimed and the reward pool has earned 20
+				deposit_rewards(20);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 400);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 2 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(10).unwrap(), del_float(10, 6.2));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 222));
+				assert_eq!(Balances::free_balance(&10), 60 + 2);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 398);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(40)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 40, pool_id: 1, payout: 188 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(40).unwrap(), del_float(40, 6.2));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 410));
+				assert_eq!(Balances::free_balance(&40), 60 + 188);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed + 210);
+
+				// When
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(50)));
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 50, pool_id: 1, payout: 210 }]
+				);
+				assert_eq!(PoolMembers::<Runtime>::get(50).unwrap(), del_float(50, 6.2));
+				assert_eq!(RewardPools::<Runtime>::get(1).unwrap(), rew(0, 0, 620));
+				assert_eq!(Balances::free_balance(&50), 100 + 210);
+				assert_eq!(Balances::free_balance(&default_reward_account()), ed);
+			});
+	}
+
+	#[test]
+	fn reward_payout_errors_if_a_member_is_fully_unbonding() {
+		ExtBuilder::default().add_members(vec![(11, 11)]).build_and_execute(|| {
+			// fully unbond the member.
+			assert_ok!(fully_unbond_permissioned(11));
+
+			assert_noop!(
+				Pools::claim_payout(RuntimeOrigin::signed(11)),
+				Error::<Runtime>::FullyUnbonding
+			);
+
+			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: 11, joined: true },
+					Event::Unbonded { member: 11, pool_id: 1, points: 11, balance: 11, era: 3 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn claim_payout_bounds_commission_above_global() {
+		ExtBuilder::default().build_and_execute(|| {
+			let (mut member, bonded_pool, mut reward_pool) =
+				Pools::get_member_with_pools(&10).unwrap();
+
+			// top up commission payee account to existential deposit
+			let _ = Balances::deposit_creating(&2, 5);
+
+			// Set a commission pool 1 to 75%, with a payee set to `2`
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				bonded_pool.id,
+				Some((Perbill::from_percent(75), 2)),
+			));
+
+			// re-introduce the global maximum to 50% - 25% lower than the current commission of the
+			// pool.
+			GlobalMaxCommission::<Runtime>::set(Some(Perbill::from_percent(50)));
+
+			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::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(75), 2))
+					}
+				]
+			);
+
+			// The pool earns 10 points
+			deposit_rewards(10);
+
+			assert_ok!(Pools::do_reward_payout(
+				&10,
+				&mut member,
+				&mut BondedPool::<Runtime>::get(1).unwrap(),
+				&mut reward_pool
+			));
+
+			// commission applied is 50%, not 75%. Has been bounded by `GlobalMaxCommission`.
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 5 },]
+			);
+		})
+	}
+
+	#[test]
+	fn do_reward_payout_works_with_a_pool_of_1() {
+		let del = |last_recorded_reward_counter| del_float(10, last_recorded_reward_counter);
+
+		ExtBuilder::default().build_and_execute(|| {
+			let (mut member, mut bonded_pool, mut reward_pool) =
+				Pools::get_member_with_pools(&10).unwrap();
+			let ed = Balances::minimum_balance();
+
+			let payout =
+				Pools::do_reward_payout(&10, &mut member, &mut bonded_pool, &mut reward_pool)
+					.unwrap();
+
+			// Then
+			assert_eq!(payout, 0);
+			assert_eq!(member, del(0.0));
+			assert_eq!(reward_pool, rew(0, 0, 0));
+
+			// Given the pool has earned some rewards for the first time
+			deposit_rewards(5);
+
+			// When
+			let payout =
+				Pools::do_reward_payout(&10, &mut member, &mut bonded_pool, &mut reward_pool)
+					.unwrap();
+
+			// 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::PaidOut { member: 10, pool_id: 1, payout: 5 }
+				]
+			);
+			assert_eq!(payout, 5);
+			assert_eq!(reward_pool, rew(0, 0, 5));
+			assert_eq!(member, del(0.5));
+
+			// Given the pool has earned rewards again
+			deposit_rewards(10);
+
+			// When
+			let payout =
+				Pools::do_reward_payout(&10, &mut member, &mut bonded_pool, &mut reward_pool)
+					.unwrap();
+
+			// Then
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 10 }]
+			);
+			assert_eq!(payout, 10);
+			assert_eq!(reward_pool, rew(0, 0, 15));
+			assert_eq!(member, del(1.5));
+
+			// Given the pool has earned no new rewards
+			Balances::make_free_balance_be(&default_reward_account(), ed);
+
+			// When
+			let payout =
+				Pools::do_reward_payout(&10, &mut member, &mut bonded_pool, &mut reward_pool)
+					.unwrap();
+
+			// Then
+			assert_eq!(pool_events_since_last_call(), vec![]);
+			assert_eq!(payout, 0);
+			assert_eq!(reward_pool, rew(0, 0, 15));
+			assert_eq!(member, del(1.5));
+		});
+	}
+
+	#[test]
+	fn do_reward_payout_works_with_a_pool_of_3() {
+		ExtBuilder::default()
+			.add_members(vec![(40, 40), (50, 50)])
+			.build_and_execute(|| {
+				let mut bonded_pool = BondedPool::<Runtime>::get(1).unwrap();
+				let mut reward_pool = RewardPools::<Runtime>::get(1).unwrap();
+
+				let mut del_10 = PoolMembers::<Runtime>::get(10).unwrap();
+				let mut del_40 = PoolMembers::<Runtime>::get(40).unwrap();
+				let mut del_50 = PoolMembers::<Runtime>::get(50).unwrap();
+
+				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: 40, pool_id: 1, bonded: 40, joined: true },
+						Event::Bonded { member: 50, pool_id: 1, bonded: 50, joined: true }
+					]
+				);
+
+				// Given we have a total of 100 points split among the members
+				assert_eq!(del_50.points + del_40.points + del_10.points, 100);
+				assert_eq!(bonded_pool.points, 100);
+
+				// and the reward pool has earned 100 in rewards
+				deposit_rewards(100);
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&10, &mut del_10, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 10 }]
+				);
+				assert_eq!(payout, 10);
+				assert_eq!(del_10, del(10, 1));
+				assert_eq!(reward_pool, rew(0, 0, 10));
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&40, &mut del_40, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 40, pool_id: 1, payout: 40 }]
+				);
+				assert_eq!(payout, 40);
+				assert_eq!(del_40, del(40, 1));
+				assert_eq!(reward_pool, rew(0, 0, 50));
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&50, &mut del_50, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 50, pool_id: 1, payout: 50 }]
+				);
+				assert_eq!(payout, 50);
+				assert_eq!(del_50, del(50, 1));
+				assert_eq!(reward_pool, rew(0, 0, 100));
+
+				// Given the reward pool has some new rewards
+				deposit_rewards(50);
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&10, &mut del_10, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 5 }]
+				);
+				assert_eq!(payout, 5);
+				assert_eq!(del_10, del_float(10, 1.5));
+				assert_eq!(reward_pool, rew(0, 0, 105));
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&40, &mut del_40, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 40, pool_id: 1, payout: 20 }]
+				);
+				assert_eq!(payout, 20);
+				assert_eq!(del_40, del_float(40, 1.5));
+				assert_eq!(reward_pool, rew(0, 0, 125));
+
+				// Given del_50 hasn't claimed and the reward pools has just earned 50
+				deposit_rewards(50);
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&50, &mut del_50, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 50, pool_id: 1, payout: 50 }]
+				);
+				assert_eq!(payout, 50);
+				assert_eq!(del_50, del_float(50, 2.0));
+				assert_eq!(reward_pool, rew(0, 0, 175));
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&10, &mut del_10, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 5 }]
+				);
+				assert_eq!(payout, 5);
+				assert_eq!(del_10, del_float(10, 2.0));
+				assert_eq!(reward_pool, rew(0, 0, 180));
+
+				// Given del_40 hasn't claimed and the reward pool has just earned 400
+				deposit_rewards(400);
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&10, &mut del_10, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 40 }]
+				);
+				assert_eq!(payout, 40);
+				assert_eq!(del_10, del_float(10, 6.0));
+				assert_eq!(reward_pool, rew(0, 0, 220));
+
+				// Given del_40 + del_50 haven't claimed and the reward pool has earned 20
+				deposit_rewards(20);
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&10, &mut del_10, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(payout, 2);
+				assert_eq!(del_10, del_float(10, 6.2));
+				assert_eq!(reward_pool, rew(0, 0, 222));
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&40, &mut del_40, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(payout, 188); // 20 (from the 50) + 160 (from the 400) + 8 (from the 20)
+				assert_eq!(del_40, del_float(40, 6.2));
+				assert_eq!(reward_pool, rew(0, 0, 410));
+
+				// When
+				let payout =
+					Pools::do_reward_payout(&50, &mut del_50, &mut bonded_pool, &mut reward_pool)
+						.unwrap();
+
+				// Then
+				assert_eq!(payout, 210); // 200 (from the 400) + 10 (from the 20)
+				assert_eq!(del_50, del_float(50, 6.2));
+				assert_eq!(reward_pool, rew(0, 0, 620));
+			});
+	}
+
+	#[test]
+	fn rewards_distribution_is_fair_basic() {
+		ExtBuilder::default().build_and_execute(|| {
+			// reward pool by 10.
+			deposit_rewards(10);
+
+			// 20 joins afterwards.
+			Balances::make_free_balance_be(&20, Balances::minimum_balance() + 10);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10, 1));
+
+			// reward by another 20
+			deposit_rewards(20);
+
+			// 10 should claim 10 + 10, 20 should claim 20 / 2.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+			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: 20, pool_id: 1, bonded: 10, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 20 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 10 },
+				]
+			);
+
+			// any upcoming rewards are shared equally.
+			deposit_rewards(20);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 10 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 10 },
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn rewards_distribution_is_fair_basic_with_fractions() {
+		// basically checks the case where the amount of rewards is less than the pool shares. for
+		// this, we have to rely on fixed point arithmetic.
+		ExtBuilder::default().build_and_execute(|| {
+			deposit_rewards(3);
+
+			Balances::make_free_balance_be(&20, Balances::minimum_balance() + 10);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10, 1));
+
+			deposit_rewards(6);
+
+			// 10 should claim 3, 20 should claim 3 + 3.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			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: 20, pool_id: 1, bonded: 10, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 3 + 3 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 3 },
+				]
+			);
+
+			// any upcoming rewards are shared equally.
+			deposit_rewards(8);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 4 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 4 },
+				]
+			);
+
+			// uneven upcoming rewards are shared equally, rounded down.
+			deposit_rewards(7);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 3 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 3 },
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn rewards_distribution_is_fair_3() {
+		ExtBuilder::default().build_and_execute(|| {
+			let ed = Balances::minimum_balance();
+
+			deposit_rewards(30);
+
+			Balances::make_free_balance_be(&20, ed + 10);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10, 1));
+
+			deposit_rewards(100);
+
+			Balances::make_free_balance_be(&30, ed + 10);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(30), 10, 1));
+
+			deposit_rewards(60);
+
+			// 10 should claim 10, 20 should claim nothing.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+
+			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: 20, pool_id: 1, bonded: 10, joined: true },
+					Event::Bonded { member: 30, pool_id: 1, bonded: 10, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 30 + 100 / 2 + 60 / 3 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 100 / 2 + 60 / 3 },
+					Event::PaidOut { member: 30, pool_id: 1, payout: 60 / 3 },
+				]
+			);
+
+			// any upcoming rewards are shared equally.
+			deposit_rewards(30);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 10 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 10 },
+					Event::PaidOut { member: 30, pool_id: 1, payout: 10 },
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn pending_rewards_per_member_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let ed = Balances::minimum_balance();
+
+			assert_eq!(Pools::api_pending_rewards(10), Some(0));
+			deposit_rewards(30);
+			assert_eq!(Pools::api_pending_rewards(10), Some(30));
+			assert_eq!(Pools::api_pending_rewards(20), None);
+
+			Balances::make_free_balance_be(&20, ed + 10);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10, 1));
+
+			assert_eq!(Pools::api_pending_rewards(10), Some(30));
+			assert_eq!(Pools::api_pending_rewards(20), Some(0));
+
+			deposit_rewards(100);
+
+			assert_eq!(Pools::api_pending_rewards(10), Some(30 + 50));
+			assert_eq!(Pools::api_pending_rewards(20), Some(50));
+			assert_eq!(Pools::api_pending_rewards(30), None);
+
+			Balances::make_free_balance_be(&30, ed + 10);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(30), 10, 1));
+
+			assert_eq!(Pools::api_pending_rewards(10), Some(30 + 50));
+			assert_eq!(Pools::api_pending_rewards(20), Some(50));
+			assert_eq!(Pools::api_pending_rewards(30), Some(0));
+
+			deposit_rewards(60);
+
+			assert_eq!(Pools::api_pending_rewards(10), Some(30 + 50 + 20));
+			assert_eq!(Pools::api_pending_rewards(20), Some(50 + 20));
+			assert_eq!(Pools::api_pending_rewards(30), Some(20));
+
+			// 10 should claim 10, 20 should claim nothing.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_eq!(Pools::api_pending_rewards(10), Some(0));
+			assert_eq!(Pools::api_pending_rewards(20), Some(50 + 20));
+			assert_eq!(Pools::api_pending_rewards(30), Some(20));
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+			assert_eq!(Pools::api_pending_rewards(10), Some(0));
+			assert_eq!(Pools::api_pending_rewards(20), Some(0));
+			assert_eq!(Pools::api_pending_rewards(30), Some(20));
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+			assert_eq!(Pools::api_pending_rewards(10), Some(0));
+			assert_eq!(Pools::api_pending_rewards(20), Some(0));
+			assert_eq!(Pools::api_pending_rewards(30), Some(0));
+		});
+	}
+
+	#[test]
+	fn rewards_distribution_is_fair_bond_extra() {
+		ExtBuilder::default().build_and_execute(|| {
+			let ed = Balances::minimum_balance();
+
+			Balances::make_free_balance_be(&20, ed + 20);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 20, 1));
+			Balances::make_free_balance_be(&30, ed + 20);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(30), 10, 1));
+
+			deposit_rewards(40);
+
+			// everyone claims.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::Bonded { member: 30, pool_id: 1, bonded: 10, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 10 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 20 },
+					Event::PaidOut { member: 30, pool_id: 1, payout: 10 }
+				]
+			);
+
+			// 30 now bumps itself to be like 20.
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(30), BondExtra::FreeBalance(10)));
+
+			// more rewards come in.
+			deposit_rewards(100);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Bonded { member: 30, pool_id: 1, bonded: 10, joined: false },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 20 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 40 },
+					Event::PaidOut { member: 30, pool_id: 1, payout: 40 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn rewards_distribution_is_fair_unbond() {
+		ExtBuilder::default().build_and_execute(|| {
+			let ed = Balances::minimum_balance();
+
+			Balances::make_free_balance_be(&20, ed + 20);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 20, 1));
+
+			deposit_rewards(30);
+
+			// everyone claims.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 10 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 20 }
+				]
+			);
+
+			// 20 unbonds to be equal to 10 (10 points each).
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 10));
+
+			// more rewards come in.
+			deposit_rewards(100);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Unbonded { member: 20, pool_id: 1, balance: 10, points: 10, era: 3 },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 50 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 50 },
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn unclaimed_reward_is_safe() {
+		ExtBuilder::default().build_and_execute(|| {
+			let ed = Balances::minimum_balance();
+
+			Balances::make_free_balance_be(&20, ed + 20);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 20, 1));
+			Balances::make_free_balance_be(&30, ed + 20);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(30), 10, 1));
+
+			// 10 gets 10, 20 gets 20, 30 gets 10
+			deposit_rewards(40);
+
+			// some claim.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::Bonded { member: 30, pool_id: 1, bonded: 10, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 10 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 20 }
+				]
+			);
+
+			// 10 gets 20, 20 gets 40, 30 gets 20
+			deposit_rewards(80);
+
+			// some claim.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 20 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 40 }
+				]
+			);
+
+			// 10 gets 20, 20 gets 40, 30 gets 20
+			deposit_rewards(80);
+
+			// some claim.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 20 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 40 }
+				]
+			);
+
+			// now 30 claims all at once
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 30, pool_id: 1, payout: 10 + 20 + 20 }]
+			);
+		});
+	}
+
+	#[test]
+	fn bond_extra_and_delayed_claim() {
+		ExtBuilder::default().build_and_execute(|| {
+			let ed = Balances::minimum_balance();
+
+			Balances::make_free_balance_be(&20, ed + 200);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), 20, 1));
+
+			// 10 gets 10, 20 gets 20, 30 gets 10
+			deposit_rewards(30);
+
+			// some claim.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 10 }
+				]
+			);
+
+			// 20 has not claimed yet, more reward comes
+			deposit_rewards(60);
+
+			// and 20 bonds more -- they should not have more share of this reward.
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(20), BondExtra::FreeBalance(10)));
+
+			// everyone claim.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					// 20 + 40, which means the extra amount they bonded did not impact us.
+					Event::PaidOut { member: 20, pool_id: 1, payout: 60 },
+					Event::Bonded { member: 20, pool_id: 1, bonded: 10, joined: false },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 20 }
+				]
+			);
+
+			// but in the next round of rewards, the extra10 they bonded has an impact.
+			deposit_rewards(60);
+
+			// everyone claim.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 15 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 45 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn create_sets_recorded_data() {
+		ExtBuilder::default().build_and_execute(|| {
+			MaxPools::<Runtime>::set(None);
+			// pool 10 has already been created.
+			let (member_10, _, reward_pool_10) = Pools::get_member_with_pools(&10).unwrap();
+
+			assert_eq!(reward_pool_10.last_recorded_total_payouts, 0);
+			assert_eq!(reward_pool_10.total_rewards_claimed, 0);
+			assert_eq!(reward_pool_10.last_recorded_reward_counter, 0.into());
+
+			assert_eq!(member_10.last_recorded_reward_counter, 0.into());
+
+			// transfer some reward to pool 1.
+			deposit_rewards(60);
+
+			// create pool 2
+			Balances::make_free_balance_be(&20, 100);
+			assert_ok!(Pools::create(RuntimeOrigin::signed(20), 10, 20, 20, 20));
+
+			// has no impact -- initial
+			let (member_20, _, reward_pool_20) = Pools::get_member_with_pools(&20).unwrap();
+
+			assert_eq!(reward_pool_20.last_recorded_total_payouts, 0);
+			assert_eq!(reward_pool_20.total_rewards_claimed, 0);
+			assert_eq!(reward_pool_20.last_recorded_reward_counter, 0.into());
+
+			assert_eq!(member_20.last_recorded_reward_counter, 0.into());
+
+			// pre-fund the reward account of pool id 3 with some funds.
+			Balances::make_free_balance_be(&Pools::create_reward_account(3), 10);
+
+			// create pool 3
+			Balances::make_free_balance_be(&30, 100);
+			assert_ok!(Pools::create(RuntimeOrigin::signed(30), 10, 30, 30, 30));
+
+			// reward counter is still the same.
+			let (member_30, _, reward_pool_30) = Pools::get_member_with_pools(&30).unwrap();
+			assert_eq!(
+				Balances::free_balance(&Pools::create_reward_account(3)),
+				10 + Balances::minimum_balance()
+			);
+
+			assert_eq!(reward_pool_30.last_recorded_total_payouts, 0);
+			assert_eq!(reward_pool_30.total_rewards_claimed, 0);
+			assert_eq!(reward_pool_30.last_recorded_reward_counter, 0.into());
+
+			assert_eq!(member_30.last_recorded_reward_counter, 0.into());
+
+			// and 30 can claim the reward now.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+
+			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::Created { depositor: 20, pool_id: 2 },
+					Event::Bonded { member: 20, pool_id: 2, bonded: 10, joined: true },
+					Event::Created { depositor: 30, pool_id: 3 },
+					Event::Bonded { member: 30, pool_id: 3, bonded: 10, joined: true },
+					Event::PaidOut { member: 30, pool_id: 3, payout: 10 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn join_updates_recorded_data() {
+		ExtBuilder::default().build_and_execute(|| {
+			MaxPoolMembers::<Runtime>::set(None);
+			MaxPoolMembersPerPool::<Runtime>::set(None);
+			let join = |x, y| {
+				Balances::make_free_balance_be(&x, y + Balances::minimum_balance());
+				assert_ok!(Pools::join(RuntimeOrigin::signed(x), y, 1));
+			};
+
+			{
+				let (member_10, _, reward_pool_10) = Pools::get_member_with_pools(&10).unwrap();
+
+				assert_eq!(reward_pool_10.last_recorded_total_payouts, 0);
+				assert_eq!(reward_pool_10.total_rewards_claimed, 0);
+				assert_eq!(reward_pool_10.last_recorded_reward_counter, 0.into());
+
+				assert_eq!(member_10.last_recorded_reward_counter, 0.into());
+			}
+
+			// someone joins without any rewards being issued.
+			{
+				join(20, 10);
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&20).unwrap();
+				// reward counter is 0 both before..
+				assert_eq!(member.last_recorded_reward_counter, 0.into());
+				assert_eq!(reward_pool.last_recorded_total_payouts, 0);
+				assert_eq!(reward_pool.last_recorded_reward_counter, 0.into());
+			}
+
+			// transfer some reward to pool 1.
+			deposit_rewards(60);
+
+			{
+				join(30, 10);
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&30).unwrap();
+				assert_eq!(reward_pool.last_recorded_total_payouts, 60);
+				// explanation: we have a total of 20 points so far (excluding the 10 that just got
+				// bonded), and 60 unclaimed rewards. each share is then roughly worth of 3 units of
+				// rewards, thus reward counter is 3. member's reward counter is the same
+				assert_eq!(member.last_recorded_reward_counter, 3.into());
+				assert_eq!(reward_pool.last_recorded_reward_counter, 3.into());
+			}
+
+			// someone else joins
+			{
+				join(40, 10);
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&40).unwrap();
+				// reward counter does not change since no rewards have came in.
+				assert_eq!(member.last_recorded_reward_counter, 3.into());
+				assert_eq!(reward_pool.last_recorded_reward_counter, 3.into());
+				assert_eq!(reward_pool.last_recorded_total_payouts, 60);
+			}
+
+			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: 20, pool_id: 1, bonded: 10, joined: true },
+					Event::Bonded { member: 30, pool_id: 1, bonded: 10, joined: true },
+					Event::Bonded { member: 40, pool_id: 1, bonded: 10, joined: true }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn bond_extra_updates_recorded_data() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			MaxPoolMembers::<Runtime>::set(None);
+			MaxPoolMembersPerPool::<Runtime>::set(None);
+
+			// initial state of pool 1.
+			{
+				let (member_10, _, reward_pool_10) = Pools::get_member_with_pools(&10).unwrap();
+
+				assert_eq!(reward_pool_10.last_recorded_total_payouts, 0);
+				assert_eq!(reward_pool_10.total_rewards_claimed, 0);
+				assert_eq!(reward_pool_10.last_recorded_reward_counter, 0.into());
+
+				assert_eq!(member_10.last_recorded_reward_counter, 0.into());
+			}
+
+			Balances::make_free_balance_be(&10, 100);
+			Balances::make_free_balance_be(&20, 100);
+
+			// 10 bonds extra without any rewards.
+			{
+				assert_ok!(Pools::bond_extra(
+					RuntimeOrigin::signed(10),
+					BondExtra::FreeBalance(10)
+				));
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&10).unwrap();
+				assert_eq!(member.last_recorded_reward_counter, 0.into());
+				assert_eq!(reward_pool.last_recorded_total_payouts, 0);
+				assert_eq!(reward_pool.last_recorded_reward_counter, 0.into());
+			}
+
+			// 10 bonds extra again with some rewards. This reward should be split equally between
+			// 10 and 20, as they both have equal points now.
+			deposit_rewards(30);
+
+			{
+				assert_ok!(Pools::bond_extra(
+					RuntimeOrigin::signed(10),
+					BondExtra::FreeBalance(10)
+				));
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&10).unwrap();
+				// explanation: before bond_extra takes place, there is 40 points and 30 balance in
+				// the system, RewardCounter is therefore 7.5
+				assert_eq!(member.last_recorded_reward_counter, RewardCounter::from_float(0.75));
+				assert_eq!(
+					reward_pool.last_recorded_reward_counter,
+					RewardCounter::from_float(0.75)
+				);
+				assert_eq!(reward_pool.last_recorded_total_payouts, 30);
+			}
+
+			// 20 bonds extra again, without further rewards.
+			{
+				assert_ok!(Pools::bond_extra(
+					RuntimeOrigin::signed(20),
+					BondExtra::FreeBalance(10)
+				));
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&20).unwrap();
+				assert_eq!(member.last_recorded_reward_counter, RewardCounter::from_float(0.75));
+				assert_eq!(
+					reward_pool.last_recorded_reward_counter,
+					RewardCounter::from_float(0.75)
+				);
+				assert_eq!(reward_pool.last_recorded_total_payouts, 30);
+			}
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::Bonded { member: 10, pool_id: 1, bonded: 10, joined: false },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 15 },
+					Event::Bonded { member: 10, pool_id: 1, bonded: 10, joined: false },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 15 },
+					Event::Bonded { member: 20, pool_id: 1, bonded: 10, joined: false }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn bond_extra_pending_rewards_works() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			MaxPoolMembers::<Runtime>::set(None);
+			MaxPoolMembersPerPool::<Runtime>::set(None);
+
+			// pool receives some rewards.
+			deposit_rewards(30);
+			System::reset_events();
+
+			// 10 cashes it out, and bonds it.
+			{
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&10).unwrap();
+				// there is 30 points and 30 reward points in the system RC is 1.
+				assert_eq!(member.last_recorded_reward_counter, 1.into());
+				assert_eq!(reward_pool.total_rewards_claimed, 10);
+				// these two are not updated -- only updated when the points change.
+				assert_eq!(reward_pool.last_recorded_total_payouts, 0);
+				assert_eq!(reward_pool.last_recorded_reward_counter, 0.into());
+
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 10 }]
+				);
+			}
+
+			// 20 re-bonds it.
+			{
+				assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(20), BondExtra::Rewards));
+				let (member, _, reward_pool) = Pools::get_member_with_pools(&10).unwrap();
+				assert_eq!(member.last_recorded_reward_counter, 1.into());
+				assert_eq!(reward_pool.total_rewards_claimed, 30);
+				// since points change, these two are updated.
+				assert_eq!(reward_pool.last_recorded_total_payouts, 30);
+				assert_eq!(reward_pool.last_recorded_reward_counter, 1.into());
+
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::PaidOut { member: 20, pool_id: 1, payout: 20 },
+						Event::Bonded { member: 20, pool_id: 1, bonded: 20, joined: false }
+					]
+				);
+			}
+		})
+	}
+
+	#[test]
+	fn unbond_updates_recorded_data() {
+		ExtBuilder::default()
+			.add_members(vec![(20, 20), (30, 20)])
+			.build_and_execute(|| {
+				MaxPoolMembers::<Runtime>::set(None);
+				MaxPoolMembersPerPool::<Runtime>::set(None);
+
+				// initial state of pool 1.
+				{
+					let (member, _, reward_pool) = Pools::get_member_with_pools(&10).unwrap();
+
+					assert_eq!(reward_pool.last_recorded_total_payouts, 0);
+					assert_eq!(reward_pool.total_rewards_claimed, 0);
+					assert_eq!(reward_pool.last_recorded_reward_counter, 0.into());
+
+					assert_eq!(member.last_recorded_reward_counter, 0.into());
+				}
+
+				// 20 unbonds without any rewards.
+				{
+					assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 10));
+					let (member, _, reward_pool) = Pools::get_member_with_pools(&20).unwrap();
+					assert_eq!(member.last_recorded_reward_counter, 0.into());
+					assert_eq!(reward_pool.last_recorded_total_payouts, 0);
+					assert_eq!(reward_pool.last_recorded_reward_counter, 0.into());
+				}
+
+				// some rewards come in.
+				deposit_rewards(30);
+
+				// and 30 also unbonds half.
+				{
+					assert_ok!(Pools::unbond(RuntimeOrigin::signed(30), 30, 10));
+					let (member, _, reward_pool) = Pools::get_member_with_pools(&30).unwrap();
+					// 30 reward in the system, and 40 points before this unbond to collect it,
+					// RewardCounter is 3/4.
+					assert_eq!(
+						member.last_recorded_reward_counter,
+						RewardCounter::from_float(0.75)
+					);
+					assert_eq!(reward_pool.last_recorded_total_payouts, 30);
+					assert_eq!(
+						reward_pool.last_recorded_reward_counter,
+						RewardCounter::from_float(0.75)
+					);
+				}
+
+				// 30 unbonds again, not change this time.
+				{
+					assert_ok!(Pools::unbond(RuntimeOrigin::signed(30), 30, 5));
+					let (member, _, reward_pool) = Pools::get_member_with_pools(&30).unwrap();
+					assert_eq!(
+						member.last_recorded_reward_counter,
+						RewardCounter::from_float(0.75)
+					);
+					assert_eq!(reward_pool.last_recorded_total_payouts, 30);
+					assert_eq!(
+						reward_pool.last_recorded_reward_counter,
+						RewardCounter::from_float(0.75)
+					);
+				}
+
+				// 20 unbonds again, not change this time, just collecting their reward.
+				{
+					assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+					let (member, _, reward_pool) = Pools::get_member_with_pools(&20).unwrap();
+					assert_eq!(
+						member.last_recorded_reward_counter,
+						RewardCounter::from_float(0.75)
+					);
+					assert_eq!(reward_pool.last_recorded_total_payouts, 30);
+					assert_eq!(
+						reward_pool.last_recorded_reward_counter,
+						RewardCounter::from_float(0.75)
+					);
+				}
+
+				// trigger 10's reward as well to see all of the payouts.
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+				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: 20, pool_id: 1, bonded: 20, joined: true },
+						Event::Bonded { member: 30, pool_id: 1, bonded: 20, joined: true },
+						Event::Unbonded { member: 20, pool_id: 1, balance: 10, points: 10, era: 3 },
+						Event::PaidOut { member: 30, pool_id: 1, payout: 15 },
+						Event::Unbonded { member: 30, pool_id: 1, balance: 10, points: 10, era: 3 },
+						Event::Unbonded { member: 30, pool_id: 1, balance: 5, points: 5, era: 3 },
+						Event::PaidOut { member: 20, pool_id: 1, payout: 7 },
+						Event::Unbonded { member: 20, pool_id: 1, balance: 5, points: 5, era: 3 },
+						Event::PaidOut { member: 10, pool_id: 1, payout: 7 }
+					]
+				);
+			})
+	}
+
+	#[test]
+	fn rewards_are_rounded_down_depositor_collects_them() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			// initial balance of 10.
+
+			assert_eq!(Balances::free_balance(&10), 35);
+			assert_eq!(
+				Balances::free_balance(&default_reward_account()),
+				Balances::minimum_balance()
+			);
+
+			// some rewards come in.
+			deposit_rewards(40);
+
+			// everyone claims
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			// some dust (1) remains in the reward account.
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 13 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 26 }
+				]
+			);
+
+			// start dismantling the pool.
+			assert_ok!(Pools::set_state(RuntimeOrigin::signed(902), 1, PoolState::Destroying));
+			assert_ok!(fully_unbond_permissioned(20));
+
+			CurrentEra::set(3);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 0));
+			assert_ok!(fully_unbond_permissioned(10));
+
+			CurrentEra::set(6);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::StateChanged { pool_id: 1, new_state: PoolState::Destroying },
+					Event::Unbonded { member: 20, pool_id: 1, balance: 20, points: 20, era: 3 },
+					Event::Withdrawn { member: 20, pool_id: 1, balance: 20, points: 20 },
+					Event::MemberRemoved { pool_id: 1, member: 20 },
+					Event::Unbonded { member: 10, pool_id: 1, balance: 10, points: 10, era: 6 },
+					Event::Withdrawn { member: 10, pool_id: 1, balance: 10, points: 10 },
+					Event::MemberRemoved { pool_id: 1, member: 10 },
+					Event::Destroyed { pool_id: 1 }
+				]
+			);
+
+			assert!(!Metadata::<T>::contains_key(1));
+			// original ed + ed put into reward account + reward + bond + dust.
+			assert_eq!(Balances::free_balance(&10), 35 + 5 + 13 + 10 + 1);
+		})
+	}
+
+	#[test]
+	fn claim_payout_large_numbers() {
+		let unit = 10u128.pow(12); // akin to KSM
+		ExistentialDeposit::set(unit);
+		StakingMinBond::set(unit * 1000);
+
+		ExtBuilder::default()
+			.max_members(Some(4))
+			.max_members_per_pool(Some(4))
+			.add_members(vec![(20, 1500 * unit), (21, 2500 * unit), (22, 5000 * unit)])
+			.build_and_execute(|| {
+				// some rewards come in.
+				assert_eq!(Balances::free_balance(&default_reward_account()), unit);
+				deposit_rewards(unit / 1000);
+
+				// everyone claims
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(21)));
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(22)));
+
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Created { depositor: 10, pool_id: 1 },
+						Event::Bonded {
+							member: 10,
+							pool_id: 1,
+							bonded: 1000000000000000,
+							joined: true
+						},
+						Event::Bonded {
+							member: 20,
+							pool_id: 1,
+							bonded: 1500000000000000,
+							joined: true
+						},
+						Event::Bonded {
+							member: 21,
+							pool_id: 1,
+							bonded: 2500000000000000,
+							joined: true
+						},
+						Event::Bonded {
+							member: 22,
+							pool_id: 1,
+							bonded: 5000000000000000,
+							joined: true
+						},
+						Event::PaidOut { member: 10, pool_id: 1, payout: 100000000 },
+						Event::PaidOut { member: 20, pool_id: 1, payout: 150000000 },
+						Event::PaidOut { member: 21, pool_id: 1, payout: 250000000 },
+						Event::PaidOut { member: 22, pool_id: 1, payout: 500000000 }
+					]
+				);
+			})
+	}
+
+	#[test]
+	fn claim_payout_other_works() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			Balances::make_free_balance_be(&default_reward_account(), 8);
+			// ... of which only 3 are claimable to make sure the reward account does not die.
+			let claimable_reward = 8 - ExistentialDeposit::get();
+			// NOTE: easier to read if we use 3, so let's use the number instead of variable.
+			assert_eq!(claimable_reward, 3, "test is correct if rewards are divisible by 3");
+
+			// given
+			assert_eq!(Balances::free_balance(10), 35);
+
+			// Permissioned by default
+			assert_noop!(
+				Pools::claim_payout_other(RuntimeOrigin::signed(80), 10),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			assert_ok!(Pools::set_claim_permission(
+				RuntimeOrigin::signed(10),
+				ClaimPermission::PermissionlessWithdraw
+			));
+			assert_ok!(Pools::claim_payout_other(RuntimeOrigin::signed(80), 10));
+
+			// then
+			assert_eq!(Balances::free_balance(10), 36);
+			assert_eq!(Balances::free_balance(&default_reward_account()), 7);
+		})
+	}
+}
+
+mod unbond {
+	use super::*;
+
+	#[test]
+	fn member_unbond_open() {
+		// depositor in pool, pool state open
+		//   - member unbond above limit
+		//   - member unbonds to 0
+		//   - member cannot unbond between within limit and 0
+		ExtBuilder::default()
+			.min_join_bond(10)
+			.add_members(vec![(20, 20)])
+			.build_and_execute(|| {
+				// can unbond to above limit
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().active_points(), 15);
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_points(), 5);
+
+				// cannot go to below 10:
+				assert_noop!(
+					Pools::unbond(RuntimeOrigin::signed(20), 20, 10),
+					Error::<T>::MinimumBondNotMet
+				);
+
+				// Make permissionless
+				assert_eq!(ClaimPermissions::<Runtime>::get(10), ClaimPermission::Permissioned);
+				assert_ok!(Pools::set_claim_permission(
+					RuntimeOrigin::signed(20),
+					ClaimPermission::PermissionlessAll
+				));
+
+				// but can go to 0
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 15));
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().active_points(), 0);
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_points(), 20);
+				assert_eq!(
+					ClaimPermissions::<Runtime>::get(20),
+					ClaimPermission::PermissionlessAll
+				);
+			})
+	}
+
+	#[test]
+	fn member_kicked() {
+		// depositor in pool, pool state blocked
+		//   - member cannot be kicked to above limit
+		//   - member cannot be kicked between within limit and 0
+		//   - member kicked to 0
+		ExtBuilder::default()
+			.min_join_bond(10)
+			.add_members(vec![(20, 20)])
+			.build_and_execute(|| {
+				unsafe_set_state(1, PoolState::Blocked);
+				let kicker = DEFAULT_ROLES.bouncer.unwrap();
+
+				// cannot be kicked to above the limit.
+				assert_noop!(
+					Pools::unbond(RuntimeOrigin::signed(kicker), 20, 5),
+					Error::<T>::PartialUnbondNotAllowedPermissionlessly
+				);
+
+				// cannot go to below 10:
+				assert_noop!(
+					Pools::unbond(RuntimeOrigin::signed(kicker), 20, 15),
+					Error::<T>::PartialUnbondNotAllowedPermissionlessly
+				);
+
+				// but they themselves can do an unbond
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 2));
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().active_points(), 18);
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_points(), 2);
+
+				// can be kicked to 0.
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(kicker), 20, 18));
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().active_points(), 0);
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_points(), 20);
+			})
+	}
+
+	#[test]
+	fn member_unbond_destroying() {
+		// depositor in pool, pool state destroying
+		//   - member cannot be permissionlessly unbonded to above limit
+		//   - member cannot be permissionlessly unbonded between within limit and 0
+		//   - member permissionlessly unbonded to 0
+		ExtBuilder::default()
+			.min_join_bond(10)
+			.add_members(vec![(20, 20)])
+			.build_and_execute(|| {
+				unsafe_set_state(1, PoolState::Destroying);
+				let random = 123;
+
+				// cannot be kicked to above the limit.
+				assert_noop!(
+					Pools::unbond(RuntimeOrigin::signed(random), 20, 5),
+					Error::<T>::PartialUnbondNotAllowedPermissionlessly
+				);
+
+				// cannot go to below 10:
+				assert_noop!(
+					Pools::unbond(RuntimeOrigin::signed(random), 20, 15),
+					Error::<T>::PartialUnbondNotAllowedPermissionlessly
+				);
+
+				// but they themselves can do an unbond
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 2));
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().active_points(), 18);
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_points(), 2);
+
+				// but can go to 0
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(random), 20, 18));
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().active_points(), 0);
+				assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().unbonding_points(), 20);
+			})
+	}
+
+	#[test]
+	fn depositor_unbond_open() {
+		// depositor in pool, pool state open
+		//   - depositor  unbonds to above limit
+		//   - depositor cannot unbond to below limit or 0
+		ExtBuilder::default().min_join_bond(10).build_and_execute(|| {
+			// give the depositor some extra funds.
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+			assert_eq!(PoolMembers::<T>::get(10).unwrap().points, 20);
+
+			// can unbond to above the limit.
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 5));
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 15);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 5);
+
+			// cannot go to below 10:
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 10),
+				Error::<T>::MinimumBondNotMet
+			);
+
+			// cannot go to 0 either.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 15),
+				Error::<T>::MinimumBondNotMet
+			);
+		})
+	}
+
+	#[test]
+	fn depositor_kick() {
+		// depositor in pool, pool state blocked
+		//   - depositor can never be kicked.
+		ExtBuilder::default().min_join_bond(10).build_and_execute(|| {
+			// give the depositor some extra funds.
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+			assert_eq!(PoolMembers::<T>::get(10).unwrap().points, 20);
+
+			// set the stage
+			unsafe_set_state(1, PoolState::Blocked);
+			let kicker = DEFAULT_ROLES.bouncer.unwrap();
+
+			// cannot be kicked to above limit.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(kicker), 10, 5),
+				Error::<T>::PartialUnbondNotAllowedPermissionlessly
+			);
+
+			// or below the limit
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(kicker), 10, 15),
+				Error::<T>::PartialUnbondNotAllowedPermissionlessly
+			);
+
+			// or 0.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(kicker), 10, 20),
+				Error::<T>::DoesNotHavePermission
+			);
+
+			// they themselves cannot do it either
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 20),
+				Error::<T>::MinimumBondNotMet
+			);
+		})
+	}
+
+	#[test]
+	fn depositor_unbond_destroying_permissionless() {
+		// depositor can never be permissionlessly unbonded.
+		ExtBuilder::default().min_join_bond(10).build_and_execute(|| {
+			// give the depositor some extra funds.
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+			assert_eq!(PoolMembers::<T>::get(10).unwrap().points, 20);
+
+			// set the stage
+			unsafe_set_state(1, PoolState::Destroying);
+			let random = 123;
+
+			// cannot be kicked to above limit.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(random), 10, 5),
+				Error::<T>::PartialUnbondNotAllowedPermissionlessly
+			);
+
+			// or below the limit
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(random), 10, 15),
+				Error::<T>::PartialUnbondNotAllowedPermissionlessly
+			);
+
+			// or 0.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(random), 10, 20),
+				Error::<T>::DoesNotHavePermission
+			);
+
+			// they themselves can do it in this case though.
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 20));
+		})
+	}
+
+	#[test]
+	fn depositor_unbond_destroying_not_last_member() {
+		// deposit in pool, pool state destroying
+		//   - depositor can never leave if there is another member in the pool.
+		ExtBuilder::default()
+			.min_join_bond(10)
+			.add_members(vec![(20, 20)])
+			.build_and_execute(|| {
+				// give the depositor some extra funds.
+				assert_ok!(Pools::bond_extra(
+					RuntimeOrigin::signed(10),
+					BondExtra::FreeBalance(10)
+				));
+				assert_eq!(PoolMembers::<T>::get(10).unwrap().points, 20);
+
+				// set the stage
+				unsafe_set_state(1, PoolState::Destroying);
+
+				// can go above the limit
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 5));
+				assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 15);
+				assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 5);
+
+				// but not below the limit
+				assert_noop!(
+					Pools::unbond(RuntimeOrigin::signed(10), 10, 10),
+					Error::<T>::MinimumBondNotMet
+				);
+
+				// and certainly not zero
+				assert_noop!(
+					Pools::unbond(RuntimeOrigin::signed(10), 10, 15),
+					Error::<T>::MinimumBondNotMet
+				);
+			})
+	}
+
+	#[test]
+	fn depositor_unbond_destroying_last_member() {
+		// deposit in pool, pool state destroying
+		//   - depositor can unbond to above limit always.
+		//   - depositor cannot unbond to below limit if last.
+		//   - depositor can unbond to 0 if last and destroying.
+		ExtBuilder::default().min_join_bond(10).build_and_execute(|| {
+			// give the depositor some extra funds.
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+			assert_eq!(PoolMembers::<T>::get(10).unwrap().points, 20);
+
+			// set the stage
+			unsafe_set_state(1, PoolState::Destroying);
+
+			// can unbond to above the limit.
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 5));
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 15);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 5);
+
+			// still cannot go to below limit
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 10),
+				Error::<T>::MinimumBondNotMet
+			);
+
+			// can go to 0 too.
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 15));
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 0);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 20);
+		})
+	}
+
+	#[test]
+	fn unbond_of_1_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			unsafe_set_state(1, PoolState::Destroying);
+			assert_ok!(fully_unbond_permissioned(10));
+
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+				unbonding_pools_with_era! { 3 => UnbondPool::<Runtime> { points: 10, balance: 10 }}
+			);
+
+			assert_eq!(
+				BondedPool::<Runtime>::get(1).unwrap(),
+				BondedPool {
+					id: 1,
+					inner: BondedPoolInner {
+						commission: Commission::default(),
+						member_counter: 1,
+						points: 0,
+						roles: DEFAULT_ROLES,
+						state: PoolState::Destroying,
+					}
+				}
+			);
+
+			assert_eq!(StakingMock::active_stake(&default_bonded_account()).unwrap(), 0);
+		});
+	}
+
+	#[test]
+	fn unbond_of_3_works() {
+		ExtBuilder::default()
+			.add_members(vec![(40, 40), (550, 550)])
+			.build_and_execute(|| {
+				let ed = Balances::minimum_balance();
+				// Given a slash from 600 -> 100
+				StakingMock::set_bonded_balance(default_bonded_account(), 100);
+				// and unclaimed rewards of 600.
+				Balances::make_free_balance_be(&default_reward_account(), ed + 600);
+
+				// When
+				assert_ok!(fully_unbond_permissioned(40));
+
+				// Then
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+					unbonding_pools_with_era! { 3 => UnbondPool { points: 6, balance: 6 }}
+				);
+				assert_eq!(
+					BondedPool::<Runtime>::get(1).unwrap(),
+					BondedPool {
+						id: 1,
+						inner: BondedPoolInner {
+							commission: Commission::default(),
+							member_counter: 3,
+							points: 560,
+							roles: DEFAULT_ROLES,
+							state: PoolState::Open,
+						}
+					}
+				);
+				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: 40, pool_id: 1, bonded: 40, joined: true },
+						Event::Bonded { member: 550, pool_id: 1, bonded: 550, joined: true },
+						Event::PaidOut { member: 40, pool_id: 1, payout: 40 },
+						Event::Unbonded { member: 40, pool_id: 1, points: 6, balance: 6, era: 3 }
+					]
+				);
+
+				assert_eq!(StakingMock::active_stake(&default_bonded_account()).unwrap(), 94);
+				assert_eq!(
+					PoolMembers::<Runtime>::get(40).unwrap().unbonding_eras,
+					member_unbonding_eras!(3 => 6)
+				);
+				assert_eq!(Balances::free_balance(&40), 40 + 40); // We claim rewards when unbonding
+
+				// When
+				unsafe_set_state(1, PoolState::Destroying);
+				assert_ok!(fully_unbond_permissioned(550));
+
+				// Then
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+					unbonding_pools_with_era! { 3 => UnbondPool { points: 98, balance: 98 }}
+				);
+				assert_eq!(
+					BondedPool::<Runtime>::get(1).unwrap(),
+					BondedPool {
+						id: 1,
+						inner: BondedPoolInner {
+							commission: Commission::default(),
+							member_counter: 3,
+							points: 10,
+							roles: DEFAULT_ROLES,
+							state: PoolState::Destroying,
+						}
+					}
+				);
+				assert_eq!(StakingMock::active_stake(&default_bonded_account()).unwrap(), 2);
+				assert_eq!(
+					PoolMembers::<Runtime>::get(550).unwrap().unbonding_eras,
+					member_unbonding_eras!(3 => 92)
+				);
+				assert_eq!(Balances::free_balance(&550), 550 + 550);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::PaidOut { member: 550, pool_id: 1, payout: 550 },
+						Event::Unbonded {
+							member: 550,
+							pool_id: 1,
+							points: 92,
+							balance: 92,
+							era: 3
+						}
+					]
+				);
+
+				// When
+				CurrentEra::set(3);
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 40, 0));
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 550, 0));
+				assert_ok!(fully_unbond_permissioned(10));
+
+				// Then
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+					unbonding_pools_with_era! { 6 => UnbondPool { points: 2, balance: 2 }}
+				);
+				assert_eq!(
+					BondedPool::<Runtime>::get(1).unwrap(),
+					BondedPool {
+						id: 1,
+						inner: BondedPoolInner {
+							commission: Commission::default(),
+							member_counter: 1,
+							points: 0,
+							roles: DEFAULT_ROLES,
+							state: PoolState::Destroying,
+						}
+					}
+				);
+				assert_eq!(StakingMock::active_stake(&default_bonded_account()).unwrap(), 0);
+
+				assert_eq!(Balances::free_balance(&550), 550 + 550 + 92);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Withdrawn { member: 40, pool_id: 1, points: 6, balance: 6 },
+						Event::MemberRemoved { pool_id: 1, member: 40 },
+						Event::Withdrawn { member: 550, pool_id: 1, points: 92, balance: 92 },
+						Event::MemberRemoved { pool_id: 1, member: 550 },
+						Event::PaidOut { member: 10, pool_id: 1, payout: 10 },
+						Event::Unbonded { member: 10, pool_id: 1, points: 2, balance: 2, era: 6 }
+					]
+				);
+			});
+	}
+
+	#[test]
+	fn unbond_merges_older_pools() {
+		ExtBuilder::default().with_check(1).build_and_execute(|| {
+			// Given
+			assert_eq!(StakingMock::bonding_duration(), 3);
+			SubPoolsStorage::<Runtime>::insert(
+				1,
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 => UnbondPool { balance: 10, points: 100 },
+						1 + 3 => UnbondPool { balance: 20, points: 20 },
+						2 + 3 => UnbondPool { balance: 101, points: 101}
+					},
+				},
+			);
+			unsafe_set_state(1, PoolState::Destroying);
+
+			// When
+			let current_era = 1 + TotalUnbondingPools::<Runtime>::get();
+			CurrentEra::set(current_era);
+
+			assert_ok!(fully_unbond_permissioned(10));
+
+			// Then
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: UnbondPool { balance: 10 + 20, points: 100 + 20 },
+					with_era: unbonding_pools_with_era! {
+						2 + 3 => UnbondPool { balance: 101, points: 101},
+						current_era + 3 => UnbondPool { balance: 10, points: 10 },
+					},
+				},
+			);
+			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::Unbonded { member: 10, pool_id: 1, points: 10, balance: 10, era: 9 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn unbond_kick_works() {
+		// Kick: the pool is blocked and the caller is either the root or bouncer.
+		ExtBuilder::default()
+			.add_members(vec![(100, 100), (200, 200)])
+			.build_and_execute(|| {
+				// Given
+				unsafe_set_state(1, PoolState::Blocked);
+				let bonded_pool = BondedPool::<Runtime>::get(1).unwrap();
+				assert_eq!(bonded_pool.roles.root.unwrap(), 900);
+				assert_eq!(bonded_pool.roles.nominator.unwrap(), 901);
+				assert_eq!(bonded_pool.roles.bouncer.unwrap(), 902);
+
+				// When the nominator tries to kick, then its a noop
+				assert_noop!(
+					Pools::fully_unbond(RuntimeOrigin::signed(901), 100),
+					Error::<Runtime>::NotKickerOrDestroying
+				);
+
+				// When the root kicks then its ok
+				assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(900), 100));
+
+				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: 100, pool_id: 1, bonded: 100, joined: true },
+						Event::Bonded { member: 200, pool_id: 1, bonded: 200, joined: true },
+						Event::Unbonded {
+							member: 100,
+							pool_id: 1,
+							points: 100,
+							balance: 100,
+							era: 3
+						},
+					]
+				);
+
+				// When the bouncer kicks then its ok
+				assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(902), 200));
+
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::Unbonded {
+						member: 200,
+						pool_id: 1,
+						points: 200,
+						balance: 200,
+						era: 3
+					}]
+				);
+
+				assert_eq!(
+					BondedPool::<Runtime>::get(1).unwrap(),
+					BondedPool {
+						id: 1,
+						inner: BondedPoolInner {
+							commission: Commission::default(),
+							member_counter: 3,
+							points: 10, // Only 10 points because 200 + 100 was unbonded
+							roles: DEFAULT_ROLES,
+							state: PoolState::Blocked,
+						}
+					}
+				);
+				assert_eq!(StakingMock::active_stake(&default_bonded_account()).unwrap(), 10);
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						no_era: Default::default(),
+						with_era: unbonding_pools_with_era! {
+							3 => UnbondPool { points: 100 + 200, balance: 100 + 200 }
+						},
+					}
+				);
+				assert_eq!(
+					*UnbondingBalanceMap::get().get(&default_bonded_account()).unwrap(),
+					100 + 200
+				);
+			});
+	}
+
+	#[test]
+	fn unbond_permissionless_works() {
+		// Scenarios where non-admin accounts can unbond others
+		ExtBuilder::default().add_members(vec![(100, 100)]).build_and_execute(|| {
+			// Given the pool is blocked
+			unsafe_set_state(1, PoolState::Blocked);
+
+			// A permissionless unbond attempt errors
+			assert_noop!(
+				Pools::fully_unbond(RuntimeOrigin::signed(420), 100),
+				Error::<Runtime>::NotKickerOrDestroying
+			);
+
+			// permissionless unbond must be full
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(420), 100, 80),
+				Error::<Runtime>::PartialUnbondNotAllowedPermissionlessly,
+			);
+
+			// Given the pool is destroying
+			unsafe_set_state(1, PoolState::Destroying);
+
+			// The depositor cannot be fully unbonded until they are the last member
+			assert_noop!(
+				Pools::fully_unbond(RuntimeOrigin::signed(10), 10),
+				Error::<Runtime>::MinimumBondNotMet,
+			);
+
+			// Any account can unbond a member that is not the depositor
+			assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(420), 100));
+
+			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: 100, pool_id: 1, bonded: 100, joined: true },
+					Event::Unbonded { member: 100, pool_id: 1, points: 100, balance: 100, era: 3 }
+				]
+			);
+
+			// still permissionless unbond must be full
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(420), 100, 80),
+				Error::<Runtime>::PartialUnbondNotAllowedPermissionlessly,
+			);
+
+			// Given the pool is blocked
+			unsafe_set_state(1, PoolState::Blocked);
+
+			// The depositor cannot be unbonded
+			assert_noop!(
+				Pools::fully_unbond(RuntimeOrigin::signed(420), 10),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			// Given the pools is destroying
+			unsafe_set_state(1, PoolState::Destroying);
+
+			// The depositor cannot be unbonded yet.
+			assert_noop!(
+				Pools::fully_unbond(RuntimeOrigin::signed(420), 10),
+				Error::<Runtime>::DoesNotHavePermission,
+			);
+
+			// but when everyone is unbonded it can..
+			CurrentEra::set(3);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 100, 0));
+
+			// still permissionless unbond must be full.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(420), 10, 5),
+				Error::<Runtime>::PartialUnbondNotAllowedPermissionlessly,
+			);
+
+			// depositor can never be unbonded permissionlessly .
+			assert_noop!(
+				Pools::fully_unbond(RuntimeOrigin::signed(420), 10),
+				Error::<T>::DoesNotHavePermission
+			);
+			// but depositor itself can do it.
+			assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(10), 10));
+
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 0);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 + 3 => UnbondPool { points: 10, balance: 10 }
+					}
+				}
+			);
+			assert_eq!(StakingMock::active_stake(&default_bonded_account()).unwrap(), 0);
+			assert_eq!(*UnbondingBalanceMap::get().get(&default_bonded_account()).unwrap(), 10);
+		});
+	}
+
+	#[test]
+	#[cfg_attr(debug_assertions, should_panic(expected = "Defensive failure has been triggered!"))]
+	#[cfg_attr(not(debug_assertions), should_panic)]
+	fn unbond_errors_correctly() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_noop!(
+				Pools::fully_unbond(RuntimeOrigin::signed(11), 11),
+				Error::<Runtime>::PoolMemberNotFound
+			);
+
+			// Add the member
+			let member = PoolMember { pool_id: 2, points: 10, ..Default::default() };
+			PoolMembers::<Runtime>::insert(11, member);
+
+			let _ = Pools::fully_unbond(RuntimeOrigin::signed(11), 11);
+		});
+	}
+
+	#[test]
+	#[cfg_attr(debug_assertions, should_panic(expected = "Defensive failure has been triggered!"))]
+	#[cfg_attr(not(debug_assertions), should_panic)]
+	fn unbond_panics_when_reward_pool_not_found() {
+		ExtBuilder::default().build_and_execute(|| {
+			let member = PoolMember { pool_id: 2, points: 10, ..Default::default() };
+			PoolMembers::<Runtime>::insert(11, member);
+			BondedPool::<Runtime> {
+				id: 1,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 10,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			}
+			.put();
+
+			let _ = Pools::fully_unbond(RuntimeOrigin::signed(11), 11);
+		});
+	}
+
+	#[test]
+	fn partial_unbond_era_tracking() {
+		ExtBuilder::default().ed(1).build_and_execute(|| {
+			// to make the depositor capable of withdrawing.
+			StakingMinBond::set(1);
+			MinCreateBond::<T>::set(1);
+			MinJoinBond::<T>::set(1);
+			assert_eq!(Pools::depositor_min_bond(), 1);
+
+			// given
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 10);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 0);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().pool_id, 1);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!()
+			);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 10);
+			assert!(SubPoolsStorage::<Runtime>::get(1).is_none());
+			assert_eq!(CurrentEra::get(), 0);
+			assert_eq!(BondingDuration::get(), 3);
+
+			// so the depositor can leave, just keeps the test simpler.
+			unsafe_set_state(1, PoolState::Destroying);
+
+			// when: casual unbond
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 1));
+
+			// then
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 9);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 1);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 9);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 1)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 => UnbondPool { points: 1, balance: 1 }
+					}
+				}
+			);
+			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::Unbonded { member: 10, pool_id: 1, points: 1, balance: 1, era: 3 }
+				]
+			);
+
+			// when: casual further unbond, same era.
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 5));
+
+			// then
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 4);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 6);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 4);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 6)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 => UnbondPool { points: 6, balance: 6 }
+					}
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Unbonded { member: 10, pool_id: 1, points: 5, balance: 5, era: 3 }]
+			);
+
+			// when: casual further unbond, next era.
+			CurrentEra::set(1);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 1));
+
+			// then
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 3);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 7);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 3);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 6, 4 => 1)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 => UnbondPool { points: 6, balance: 6 },
+						4 => UnbondPool { points: 1, balance: 1 }
+					}
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Unbonded { member: 10, pool_id: 1, points: 1, balance: 1, era: 4 }]
+			);
+
+			// when: unbonding more than our active: error
+			assert_noop!(
+				frame_support::storage::with_storage_layer(|| Pools::unbond(
+					RuntimeOrigin::signed(10),
+					10,
+					5
+				)),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+			// instead:
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 3));
+
+			// then
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 0);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 10);
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().points, 0);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 6, 4 => 4)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 => UnbondPool { points: 6, balance: 6 },
+						4 => UnbondPool { points: 4, balance: 4 }
+					}
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Unbonded { member: 10, pool_id: 1, points: 3, balance: 3, era: 4 }]
+			);
+		});
+	}
+
+	#[test]
+	fn partial_unbond_max_chunks() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).ed(1).build_and_execute(|| {
+			MaxUnbonding::set(2);
+
+			// given
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 2));
+			CurrentEra::set(1);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 3));
+			assert_eq!(
+				PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 2, 4 => 3)
+			);
+
+			// when
+			CurrentEra::set(2);
+			assert_noop!(
+				frame_support::storage::with_storage_layer(|| Pools::unbond(
+					RuntimeOrigin::signed(20),
+					20,
+					4
+				)),
+				Error::<Runtime>::MaxUnbondingLimit
+			);
+
+			// when
+			MaxUnbonding::set(3);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 1));
+
+			assert_eq!(
+				PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 2, 4 => 3, 5 => 1)
+			);
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::Unbonded { member: 20, pool_id: 1, points: 2, balance: 2, era: 3 },
+					Event::Unbonded { member: 20, pool_id: 1, points: 3, balance: 3, era: 4 },
+					Event::Unbonded { member: 20, pool_id: 1, points: 1, balance: 1, era: 5 }
+				]
+			);
+		})
+	}
+
+	// depositor can unbond only up to `MinCreateBond`.
+	#[test]
+	fn depositor_permissioned_partial_unbond() {
+		ExtBuilder::default().ed(1).build_and_execute(|| {
+			// given
+			StakingMinBond::set(5);
+			assert_eq!(Pools::depositor_min_bond(), 5);
+
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 10);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 0);
+
+			// can unbond a bit..
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 3));
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 7);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 3);
+
+			// but not less than 2
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 6),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+
+			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::Unbonded { member: 10, pool_id: 1, points: 3, balance: 3, era: 3 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn depositor_permissioned_partial_unbond_slashed() {
+		ExtBuilder::default().ed(1).build_and_execute(|| {
+			// given
+			assert_eq!(MinCreateBond::<Runtime>::get(), 2);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 10);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 0);
+
+			// slash the default pool
+			StakingMock::set_bonded_balance(Pools::create_bonded_account(1), 5);
+
+			// cannot unbond even 7, because the value of shares is now less.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 7),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+		});
+	}
+
+	#[test]
+	fn every_unbonding_triggers_payout() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			let initial_reward_account = Balances::free_balance(default_reward_account());
+			assert_eq!(initial_reward_account, Balances::minimum_balance());
+			assert_eq!(initial_reward_account, 5);
+
+			Balances::make_free_balance_be(
+				&default_reward_account(),
+				4 * Balances::minimum_balance(),
+			);
+
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 2));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					// 2/3 of ed, which is 20's share.
+					Event::Created { depositor: 10, pool_id: 1 },
+					Event::Bonded { member: 10, pool_id: 1, bonded: 10, joined: true },
+					Event::Bonded { member: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 10 },
+					Event::Unbonded { member: 20, pool_id: 1, balance: 2, points: 2, era: 3 }
+				]
+			);
+
+			CurrentEra::set(1);
+			Balances::make_free_balance_be(
+				&default_reward_account(),
+				4 * Balances::minimum_balance(),
+			);
+
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 3));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					// 2/3 of ed, which is 20's share.
+					Event::PaidOut { member: 20, pool_id: 1, payout: 6 },
+					Event::Unbonded { member: 20, pool_id: 1, points: 3, balance: 3, era: 4 }
+				]
+			);
+
+			CurrentEra::set(2);
+			Balances::make_free_balance_be(
+				&default_reward_account(),
+				4 * Balances::minimum_balance(),
+			);
+
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 20, pool_id: 1, payout: 3 },
+					Event::Unbonded { member: 20, pool_id: 1, points: 5, balance: 5, era: 5 }
+				]
+			);
+
+			assert_eq!(
+				PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 2, 4 => 3, 5 => 5)
+			);
+		});
+	}
+}
+
+mod pool_withdraw_unbonded {
+	use super::*;
+
+	#[test]
+	fn pool_withdraw_unbonded_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Given 10 unbond'ed directly against the pool account
+			assert_ok!(StakingMock::unbond(&default_bonded_account(), 5));
+			// and the pool account only has 10 balance
+			assert_eq!(StakingMock::active_stake(&default_bonded_account()), Ok(5));
+			assert_eq!(StakingMock::total_stake(&default_bonded_account()), Ok(10));
+			assert_eq!(Balances::free_balance(&default_bonded_account()), 10);
+
+			// When
+			assert_ok!(Pools::pool_withdraw_unbonded(RuntimeOrigin::signed(10), 1, 0));
+
+			// Then there unbonding balance is no longer locked
+			assert_eq!(StakingMock::active_stake(&default_bonded_account()), Ok(5));
+			assert_eq!(StakingMock::total_stake(&default_bonded_account()), Ok(5));
+			assert_eq!(Balances::free_balance(&default_bonded_account()), 10);
+		});
+	}
+}
+
+mod withdraw_unbonded {
+	use super::*;
+	use sp_runtime::bounded_btree_map;
+
+	#[test]
+	fn withdraw_unbonded_works_against_slashed_no_era_sub_pool() {
+		ExtBuilder::default()
+			.add_members(vec![(40, 40), (550, 550)])
+			.build_and_execute(|| {
+				// reduce the noise a bit.
+				let _ = balances_events_since_last_call();
+
+				// Given
+				assert_eq!(StakingMock::bonding_duration(), 3);
+				assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(550), 550));
+				assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(40), 40));
+				assert_eq!(Balances::free_balance(&default_bonded_account()), 600);
+
+				let mut current_era = 1;
+				CurrentEra::set(current_era);
+
+				let mut sub_pools = SubPoolsStorage::<Runtime>::get(1).unwrap();
+				let unbond_pool = sub_pools.with_era.get_mut(&3).unwrap();
+				// Sanity check
+				assert_eq!(*unbond_pool, UnbondPool { points: 550 + 40, balance: 550 + 40 });
+
+				// Simulate a slash to the pool with_era(current_era), decreasing the balance by
+				// half
+				{
+					unbond_pool.balance /= 2; // 295
+					SubPoolsStorage::<Runtime>::insert(1, sub_pools);
+					// Update the equivalent of the unbonding chunks for the `StakingMock`
+					let mut x = UnbondingBalanceMap::get();
+					*x.get_mut(&default_bonded_account()).unwrap() /= 5;
+					UnbondingBalanceMap::set(&x);
+					Balances::make_free_balance_be(
+						&default_bonded_account(),
+						Balances::free_balance(&default_bonded_account()) / 2, // 300
+					);
+					StakingMock::set_bonded_balance(
+						default_bonded_account(),
+						StakingMock::active_stake(&default_bonded_account()).unwrap() / 2,
+					);
+				};
+
+				// Advance the current_era to ensure all `with_era` pools will be merged into
+				// `no_era` pool
+				current_era += TotalUnbondingPools::<Runtime>::get();
+				CurrentEra::set(current_era);
+
+				// Simulate some other call to unbond that would merge `with_era` pools into
+				// `no_era`
+				let sub_pools =
+					SubPoolsStorage::<Runtime>::get(1).unwrap().maybe_merge_pools(current_era);
+				SubPoolsStorage::<Runtime>::insert(1, sub_pools);
+
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						no_era: UnbondPool { points: 550 + 40, balance: 275 + 20 },
+						with_era: Default::default()
+					}
+				);
+				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: 40, pool_id: 1, bonded: 40, joined: true },
+						Event::Bonded { member: 550, pool_id: 1, bonded: 550, joined: true },
+						Event::Unbonded {
+							member: 550,
+							pool_id: 1,
+							points: 550,
+							balance: 550,
+							era: 3
+						},
+						Event::Unbonded { member: 40, pool_id: 1, points: 40, balance: 40, era: 3 },
+					]
+				);
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![BEvent::BalanceSet { who: default_bonded_account(), free: 300 }]
+				);
+
+				// When
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(550), 550, 0));
+
+				// Then
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().no_era,
+					UnbondPool { points: 40, balance: 20 }
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Withdrawn { member: 550, pool_id: 1, balance: 275, points: 550 },
+						Event::MemberRemoved { pool_id: 1, member: 550 }
+					]
+				);
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![BEvent::Transfer { from: default_bonded_account(), to: 550, amount: 275 }]
+				);
+
+				// When
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(40), 40, 0));
+
+				// Then
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().no_era,
+					UnbondPool { points: 0, balance: 0 }
+				);
+				assert!(!PoolMembers::<Runtime>::contains_key(40));
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Withdrawn { member: 40, pool_id: 1, balance: 20, points: 40 },
+						Event::MemberRemoved { pool_id: 1, member: 40 }
+					]
+				);
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![BEvent::Transfer { from: default_bonded_account(), to: 40, amount: 20 }]
+				);
+
+				// now, finally, the depositor can take out its share.
+				unsafe_set_state(1, PoolState::Destroying);
+				assert_ok!(fully_unbond_permissioned(10));
+
+				current_era += 3;
+				CurrentEra::set(current_era);
+
+				// when
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Unbonded { member: 10, pool_id: 1, balance: 5, points: 5, era: 9 },
+						Event::Withdrawn { member: 10, pool_id: 1, balance: 5, points: 5 },
+						Event::MemberRemoved { pool_id: 1, member: 10 },
+						Event::Destroyed { pool_id: 1 }
+					]
+				);
+				assert!(!Metadata::<T>::contains_key(1));
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![
+						BEvent::Transfer { from: default_bonded_account(), to: 10, amount: 5 },
+						BEvent::Transfer { from: default_reward_account(), to: 10, amount: 5 }
+					]
+				);
+			});
+	}
+
+	#[test]
+	fn withdraw_unbonded_works_against_slashed_with_era_sub_pools() {
+		ExtBuilder::default()
+			.add_members(vec![(40, 40), (550, 550)])
+			.build_and_execute(|| {
+				let _ = balances_events_since_last_call();
+
+				// Given
+				// current bond is 600, we slash it all to 300.
+				StakingMock::set_bonded_balance(default_bonded_account(), 300);
+				Balances::make_free_balance_be(&default_bonded_account(), 300);
+				assert_eq!(StakingMock::total_stake(&default_bonded_account()), Ok(300));
+
+				assert_ok!(fully_unbond_permissioned(40));
+				assert_ok!(fully_unbond_permissioned(550));
+
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+					unbonding_pools_with_era! { 3 => UnbondPool { points: 550 / 2 + 40 / 2, balance: 550 / 2 + 40 / 2
+					}}
+				);
+
+				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: 40, pool_id: 1, bonded: 40, joined: true },
+						Event::Bonded { member: 550, pool_id: 1, bonded: 550, joined: true },
+						Event::Unbonded { member: 40, pool_id: 1, balance: 20, points: 20, era: 3 },
+						Event::Unbonded {
+							member: 550,
+							pool_id: 1,
+							balance: 275,
+							points: 275,
+							era: 3,
+						}
+					]
+				);
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![BEvent::BalanceSet { who: default_bonded_account(), free: 300 },]
+				);
+
+				CurrentEra::set(StakingMock::bonding_duration());
+
+				// When
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(40), 40, 0));
+
+				// Then
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![BEvent::Transfer { from: default_bonded_account(), to: 40, amount: 20 },]
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Withdrawn { member: 40, pool_id: 1, balance: 20, points: 20 },
+						Event::MemberRemoved { pool_id: 1, member: 40 }
+					]
+				);
+
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+					unbonding_pools_with_era! { 3 => UnbondPool { points: 550 / 2, balance: 550 / 2 }}
+				);
+
+				// When
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(550), 550, 0));
+
+				// Then
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![BEvent::Transfer { from: default_bonded_account(), to: 550, amount: 275 },]
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Withdrawn { member: 550, pool_id: 1, balance: 275, points: 275 },
+						Event::MemberRemoved { pool_id: 1, member: 550 }
+					]
+				);
+				assert!(SubPoolsStorage::<Runtime>::get(1).unwrap().with_era.is_empty());
+
+				// now, finally, the depositor can take out its share.
+				unsafe_set_state(1, PoolState::Destroying);
+				assert_ok!(fully_unbond_permissioned(10));
+
+				// because everyone else has left, the points
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+					unbonding_pools_with_era! { 6 => UnbondPool { points: 5, balance: 5 }}
+				);
+
+				CurrentEra::set(CurrentEra::get() + 3);
+
+				// set metadata to check that it's being removed on dissolve
+				assert_ok!(Pools::set_metadata(RuntimeOrigin::signed(900), 1, vec![1, 1]));
+				assert!(Metadata::<T>::contains_key(1));
+
+				// when
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+				// then
+				assert_eq!(Balances::free_balance(&10), 10 + 35);
+				assert_eq!(Balances::free_balance(&default_bonded_account()), 0);
+
+				// in this test 10 also gets a fair share of the slash, because the slash was
+				// applied to the bonded account.
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Unbonded { member: 10, pool_id: 1, points: 5, balance: 5, era: 6 },
+						Event::Withdrawn { member: 10, pool_id: 1, points: 5, balance: 5 },
+						Event::MemberRemoved { pool_id: 1, member: 10 },
+						Event::Destroyed { pool_id: 1 }
+					]
+				);
+				assert!(!Metadata::<T>::contains_key(1));
+				assert_eq!(
+					balances_events_since_last_call(),
+					vec![
+						BEvent::Transfer { from: default_bonded_account(), to: 10, amount: 5 },
+						BEvent::Transfer { from: default_reward_account(), to: 10, amount: 5 }
+					]
+				);
+			});
+	}
+
+	#[test]
+	fn withdraw_unbonded_handles_faulty_sub_pool_accounting() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Given
+			assert_eq!(Balances::minimum_balance(), 5);
+			assert_eq!(Balances::free_balance(&10), 35);
+			assert_eq!(Balances::free_balance(&default_bonded_account()), 10);
+			unsafe_set_state(1, PoolState::Destroying);
+			assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(10), 10));
+
+			// Simulate a slash that is not accounted for in the sub pools.
+			Balances::make_free_balance_be(&default_bonded_account(), 5);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap().with_era,
+				//------------------------------balance decrease is not account for
+				unbonding_pools_with_era! { 3 => UnbondPool { points: 10, balance: 10 } }
+			);
+
+			CurrentEra::set(3);
+
+			// When
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+			// Then
+			assert_eq!(Balances::free_balance(10), 10 + 35);
+			assert_eq!(Balances::free_balance(&default_bonded_account()), 0);
+		});
+	}
+
+	#[test]
+	fn withdraw_unbonded_errors_correctly() {
+		ExtBuilder::default().with_check(0).build_and_execute(|| {
+			// Insert the sub-pool
+			let sub_pools = SubPools {
+				no_era: Default::default(),
+				with_era: unbonding_pools_with_era! { 3 => UnbondPool { points: 10, balance: 10  }},
+			};
+			SubPoolsStorage::<Runtime>::insert(1, sub_pools.clone());
+
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(11), 11, 0),
+				Error::<Runtime>::PoolMemberNotFound
+			);
+
+			let mut member = PoolMember { pool_id: 1, points: 10, ..Default::default() };
+			PoolMembers::<Runtime>::insert(11, member.clone());
+
+			// Simulate calling `unbond`
+			member.unbonding_eras = member_unbonding_eras!(3 => 10);
+			PoolMembers::<Runtime>::insert(11, member.clone());
+
+			// We are still in the bonding duration
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(11), 11, 0),
+				Error::<Runtime>::CannotWithdrawAny
+			);
+
+			// If we error the member does not get removed
+			assert_eq!(PoolMembers::<Runtime>::get(11), Some(member));
+			// and the sub pools do not get updated.
+			assert_eq!(SubPoolsStorage::<Runtime>::get(1).unwrap(), sub_pools)
+		});
+	}
+
+	#[test]
+	fn withdraw_unbonded_kick() {
+		ExtBuilder::default()
+			.add_members(vec![(100, 100), (200, 200)])
+			.build_and_execute(|| {
+				// Given
+				assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(100), 100));
+				assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(200), 200));
+				assert_eq!(
+					BondedPool::<Runtime>::get(1).unwrap(),
+					BondedPool {
+						id: 1,
+						inner: BondedPoolInner {
+							commission: Commission::default(),
+							member_counter: 3,
+							points: 10,
+							roles: DEFAULT_ROLES,
+							state: PoolState::Open,
+						}
+					}
+				);
+				CurrentEra::set(StakingMock::bonding_duration());
+
+				// Cannot kick when pool is open
+				assert_noop!(
+					Pools::withdraw_unbonded(RuntimeOrigin::signed(902), 100, 0),
+					Error::<Runtime>::NotKickerOrDestroying
+				);
+				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: 100, pool_id: 1, bonded: 100, joined: true },
+						Event::Bonded { member: 200, pool_id: 1, bonded: 200, joined: true },
+						Event::Unbonded {
+							member: 100,
+							pool_id: 1,
+							points: 100,
+							balance: 100,
+							era: 3
+						},
+						Event::Unbonded {
+							member: 200,
+							pool_id: 1,
+							points: 200,
+							balance: 200,
+							era: 3
+						}
+					]
+				);
+
+				// Given
+				unsafe_set_state(1, PoolState::Blocked);
+
+				// Cannot kick as a nominator
+				assert_noop!(
+					Pools::withdraw_unbonded(RuntimeOrigin::signed(901), 100, 0),
+					Error::<Runtime>::NotKickerOrDestroying
+				);
+
+				// Can kick as root
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(900), 100, 0));
+
+				// Can kick as bouncer
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(900), 200, 0));
+
+				assert_eq!(Balances::free_balance(100), 100 + 100);
+				assert_eq!(Balances::free_balance(200), 200 + 200);
+				assert!(!PoolMembers::<Runtime>::contains_key(100));
+				assert!(!PoolMembers::<Runtime>::contains_key(200));
+				assert_eq!(SubPoolsStorage::<Runtime>::get(1).unwrap(), Default::default());
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Withdrawn { member: 100, pool_id: 1, points: 100, balance: 100 },
+						Event::MemberRemoved { pool_id: 1, member: 100 },
+						Event::Withdrawn { member: 200, pool_id: 1, points: 200, balance: 200 },
+						Event::MemberRemoved { pool_id: 1, member: 200 }
+					]
+				);
+			});
+	}
+
+	#[test]
+	fn withdraw_unbonded_destroying_permissionless() {
+		ExtBuilder::default().add_members(vec![(100, 100)]).build_and_execute(|| {
+			// Given
+			assert_ok!(Pools::fully_unbond(RuntimeOrigin::signed(100), 100));
+			assert_eq!(
+				BondedPool::<Runtime>::get(1).unwrap(),
+				BondedPool {
+					id: 1,
+					inner: BondedPoolInner {
+						commission: Commission::default(),
+						member_counter: 2,
+						points: 10,
+						roles: DEFAULT_ROLES,
+						state: PoolState::Open,
+					}
+				}
+			);
+			CurrentEra::set(StakingMock::bonding_duration());
+			assert_eq!(Balances::free_balance(100), 100);
+
+			// Cannot permissionlessly withdraw
+			assert_noop!(
+				Pools::fully_unbond(RuntimeOrigin::signed(420), 100),
+				Error::<Runtime>::NotKickerOrDestroying
+			);
+
+			// Given
+			unsafe_set_state(1, PoolState::Destroying);
+
+			// Can permissionlesly withdraw a member that is not the depositor
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(420), 100, 0));
+
+			assert_eq!(SubPoolsStorage::<Runtime>::get(1).unwrap(), Default::default(),);
+			assert_eq!(Balances::free_balance(100), 100 + 100);
+			assert!(!PoolMembers::<Runtime>::contains_key(100));
+			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: 100, pool_id: 1, bonded: 100, joined: true },
+					Event::Unbonded { member: 100, pool_id: 1, points: 100, balance: 100, era: 3 },
+					Event::Withdrawn { member: 100, pool_id: 1, points: 100, balance: 100 },
+					Event::MemberRemoved { pool_id: 1, member: 100 }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn partial_withdraw_unbonded_depositor() {
+		ExtBuilder::default().ed(1).build_and_execute(|| {
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+			unsafe_set_state(1, PoolState::Destroying);
+
+			// given
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 6));
+			CurrentEra::set(1);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 1));
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 6, 4 => 1)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 => UnbondPool { points: 6, balance: 6 },
+						4 => UnbondPool { points: 1, balance: 1 }
+					}
+				}
+			);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().active_points(), 13);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().unbonding_points(), 7);
+			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: 10, pool_id: 1, bonded: 10, joined: false },
+					Event::Unbonded { member: 10, pool_id: 1, points: 6, balance: 6, era: 3 },
+					Event::Unbonded { member: 10, pool_id: 1, points: 1, balance: 1, era: 4 }
+				]
+			);
+
+			// when
+			CurrentEra::set(2);
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0),
+				Error::<Runtime>::CannotWithdrawAny
+			);
+
+			// when
+			CurrentEra::set(3);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+			// then
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(4 => 1)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						4 => UnbondPool { points: 1, balance: 1 }
+					}
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Withdrawn { member: 10, pool_id: 1, points: 6, balance: 6 }]
+			);
+
+			// when
+			CurrentEra::set(4);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+			// then
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!()
+			);
+			assert_eq!(SubPoolsStorage::<Runtime>::get(1).unwrap(), Default::default());
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Withdrawn { member: 10, pool_id: 1, points: 1, balance: 1 },]
+			);
+
+			// when repeating:
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0),
+				Error::<Runtime>::CannotWithdrawAny
+			);
+		});
+	}
+
+	#[test]
+	fn partial_withdraw_unbonded_non_depositor() {
+		ExtBuilder::default().add_members(vec![(11, 10)]).build_and_execute(|| {
+			// given
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(11), 11, 6));
+			CurrentEra::set(1);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(11), 11, 1));
+			assert_eq!(
+				PoolMembers::<Runtime>::get(11).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 6, 4 => 1)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						3 => UnbondPool { points: 6, balance: 6 },
+						4 => UnbondPool { points: 1, balance: 1 }
+					}
+				}
+			);
+			assert_eq!(PoolMembers::<Runtime>::get(11).unwrap().active_points(), 3);
+			assert_eq!(PoolMembers::<Runtime>::get(11).unwrap().unbonding_points(), 7);
+			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: 10, joined: true },
+					Event::Unbonded { member: 11, pool_id: 1, points: 6, balance: 6, era: 3 },
+					Event::Unbonded { member: 11, pool_id: 1, points: 1, balance: 1, era: 4 }
+				]
+			);
+
+			// when
+			CurrentEra::set(2);
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(11), 11, 0),
+				Error::<Runtime>::CannotWithdrawAny
+			);
+
+			// when
+			CurrentEra::set(3);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(11), 11, 0));
+
+			// then
+			assert_eq!(
+				PoolMembers::<Runtime>::get(11).unwrap().unbonding_eras,
+				member_unbonding_eras!(4 => 1)
+			);
+			assert_eq!(
+				SubPoolsStorage::<Runtime>::get(1).unwrap(),
+				SubPools {
+					no_era: Default::default(),
+					with_era: unbonding_pools_with_era! {
+						4 => UnbondPool { points: 1, balance: 1 }
+					}
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Withdrawn { member: 11, pool_id: 1, points: 6, balance: 6 }]
+			);
+
+			// when
+			CurrentEra::set(4);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(11), 11, 0));
+
+			// then
+			assert_eq!(
+				PoolMembers::<Runtime>::get(11).unwrap().unbonding_eras,
+				member_unbonding_eras!()
+			);
+			assert_eq!(SubPoolsStorage::<Runtime>::get(1).unwrap(), Default::default());
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Withdrawn { member: 11, pool_id: 1, points: 1, balance: 1 }]
+			);
+
+			// when repeating:
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(11), 11, 0),
+				Error::<Runtime>::CannotWithdrawAny
+			);
+		});
+	}
+
+	#[test]
+	fn full_multi_step_withdrawing_non_depositor() {
+		ExtBuilder::default().add_members(vec![(100, 100)]).build_and_execute(|| {
+			// given
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(100), 100, 75));
+			assert_eq!(
+				PoolMembers::<Runtime>::get(100).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 75)
+			);
+
+			// progress one era and unbond the leftover.
+			CurrentEra::set(1);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(100), 100, 25));
+			assert_eq!(
+				PoolMembers::<Runtime>::get(100).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 75, 4 => 25)
+			);
+
+			assert_noop!(
+				Pools::withdraw_unbonded(RuntimeOrigin::signed(100), 100, 0),
+				Error::<Runtime>::CannotWithdrawAny
+			);
+
+			// now the 75 should be free.
+			CurrentEra::set(3);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(100), 100, 0));
+			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: 100, pool_id: 1, bonded: 100, joined: true },
+					Event::Unbonded { member: 100, pool_id: 1, points: 75, balance: 75, era: 3 },
+					Event::Unbonded { member: 100, pool_id: 1, points: 25, balance: 25, era: 4 },
+					Event::Withdrawn { member: 100, pool_id: 1, points: 75, balance: 75 },
+				]
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(100).unwrap().unbonding_eras,
+				member_unbonding_eras!(4 => 25)
+			);
+
+			// the 25 should be free now, and the member removed.
+			CurrentEra::set(4);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(100), 100, 0));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Withdrawn { member: 100, pool_id: 1, points: 25, balance: 25 },
+					Event::MemberRemoved { pool_id: 1, member: 100 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn out_of_sync_unbonding_chunks() {
+		// the unbonding_eras in pool member are always fixed to the era at which they are unlocked,
+		// but the actual unbonding pools get pruned and might get combined in the no_era pool.
+		// Pools are only merged when one unbonds, so we unbond a little bit on every era to
+		// simulate this.
+		ExtBuilder::default()
+			.add_members(vec![(20, 100), (30, 100)])
+			.build_and_execute(|| {
+				System::reset_events();
+
+				// when
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(30), 30, 5));
+
+				// then member-local unbonding is pretty much in sync with the global pools.
+				assert_eq!(
+					PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+					member_unbonding_eras!(3 => 5)
+				);
+				assert_eq!(
+					PoolMembers::<Runtime>::get(30).unwrap().unbonding_eras,
+					member_unbonding_eras!(3 => 5)
+				);
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						no_era: Default::default(),
+						with_era: unbonding_pools_with_era! {
+							3 => UnbondPool { points: 10, balance: 10 }
+						}
+					}
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Unbonded { member: 20, pool_id: 1, points: 5, balance: 5, era: 3 },
+						Event::Unbonded { member: 30, pool_id: 1, points: 5, balance: 5, era: 3 },
+					]
+				);
+
+				// when
+				CurrentEra::set(1);
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+
+				// then still member-local unbonding is pretty much in sync with the global pools.
+				assert_eq!(
+					PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+					member_unbonding_eras!(3 => 5, 4 => 5)
+				);
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						no_era: Default::default(),
+						with_era: unbonding_pools_with_era! {
+							3 => UnbondPool { points: 10, balance: 10 },
+							4 => UnbondPool { points: 5, balance: 5 }
+						}
+					}
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::Unbonded { member: 20, pool_id: 1, points: 5, balance: 5, era: 4 }]
+				);
+
+				// when
+				CurrentEra::set(2);
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+
+				// then still member-local unbonding is pretty much in sync with the global pools.
+				assert_eq!(
+					PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+					member_unbonding_eras!(3 => 5, 4 => 5, 5 => 5)
+				);
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						no_era: Default::default(),
+						with_era: unbonding_pools_with_era! {
+							3 => UnbondPool { points: 10, balance: 10 },
+							4 => UnbondPool { points: 5, balance: 5 },
+							5 => UnbondPool { points: 5, balance: 5 }
+						}
+					}
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::Unbonded { member: 20, pool_id: 1, points: 5, balance: 5, era: 5 }]
+				);
+
+				// when
+				CurrentEra::set(5);
+				assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 5));
+
+				// then
+				assert_eq!(
+					PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+					member_unbonding_eras!(3 => 5, 4 => 5, 5 => 5, 8 => 5)
+				);
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						// era 3 is merged into no_era.
+						no_era: UnbondPool { points: 10, balance: 10 },
+						with_era: unbonding_pools_with_era! {
+							4 => UnbondPool { points: 5, balance: 5 },
+							5 => UnbondPool { points: 5, balance: 5 },
+							8 => UnbondPool { points: 5, balance: 5 }
+						}
+					}
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::Unbonded { member: 20, pool_id: 1, points: 5, balance: 5, era: 8 }]
+				);
+
+				// now we start withdrawing unlocked bonds.
+
+				// when
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 0));
+				// then
+				assert_eq!(
+					PoolMembers::<Runtime>::get(20).unwrap().unbonding_eras,
+					member_unbonding_eras!(8 => 5)
+				);
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						// era 3 is merged into no_era.
+						no_era: UnbondPool { points: 5, balance: 5 },
+						with_era: unbonding_pools_with_era! {
+							8 => UnbondPool { points: 5, balance: 5 }
+						}
+					}
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::Withdrawn { member: 20, pool_id: 1, points: 15, balance: 15 }]
+				);
+
+				// when
+				assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(30), 30, 0));
+				// then
+				assert_eq!(
+					PoolMembers::<Runtime>::get(30).unwrap().unbonding_eras,
+					member_unbonding_eras!()
+				);
+				assert_eq!(
+					SubPoolsStorage::<Runtime>::get(1).unwrap(),
+					SubPools {
+						// era 3 is merged into no_era.
+						no_era: Default::default(),
+						with_era: unbonding_pools_with_era! {
+							8 => UnbondPool { points: 5, balance: 5 }
+						}
+					}
+				);
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::Withdrawn { member: 30, pool_id: 1, points: 5, balance: 5 }]
+				);
+			})
+	}
+
+	#[test]
+	fn full_multi_step_withdrawing_depositor() {
+		ExtBuilder::default().ed(1).build_and_execute(|| {
+			// depositor now has 20, they can unbond to 10.
+			assert_eq!(Pools::depositor_min_bond(), 10);
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+
+			// now they can.
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 7));
+
+			// progress one era and unbond the leftover.
+			CurrentEra::set(1);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 3));
+
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(3 => 7, 4 => 3)
+			);
+
+			// they can't unbond to a value below 10 other than 0..
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 5),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+
+			// but not even full, because they pool is not yet destroying.
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 10),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+
+			// but now they can.
+			unsafe_set_state(1, PoolState::Destroying);
+			assert_noop!(
+				Pools::unbond(RuntimeOrigin::signed(10), 10, 5),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(10), 10, 10));
+
+			// now the 7 should be free.
+			CurrentEra::set(3);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+			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: 10, pool_id: 1, bonded: 10, joined: false },
+					Event::Unbonded { member: 10, pool_id: 1, balance: 7, points: 7, era: 3 },
+					Event::Unbonded { member: 10, pool_id: 1, balance: 3, points: 3, era: 4 },
+					Event::Unbonded { member: 10, pool_id: 1, balance: 10, points: 10, era: 4 },
+					Event::Withdrawn { member: 10, pool_id: 1, balance: 7, points: 7 }
+				]
+			);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap().unbonding_eras,
+				member_unbonding_eras!(4 => 13)
+			);
+
+			// the 13 should be free now, and the member removed.
+			CurrentEra::set(4);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 0));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Withdrawn { member: 10, pool_id: 1, points: 13, balance: 13 },
+					Event::MemberRemoved { pool_id: 1, member: 10 },
+					Event::Destroyed { pool_id: 1 },
+				]
+			);
+			assert!(!Metadata::<T>::contains_key(1));
+		})
+	}
+
+	#[test]
+	fn withdraw_unbonded_removes_claim_permissions_on_leave() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			// Given
+			CurrentEra::set(1);
+			assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 20);
+
+			assert_ok!(Pools::set_claim_permission(
+				RuntimeOrigin::signed(20),
+				ClaimPermission::PermissionlessAll
+			));
+			assert_ok!(Pools::unbond(RuntimeOrigin::signed(20), 20, 20));
+			assert_eq!(ClaimPermissions::<Runtime>::get(20), ClaimPermission::PermissionlessAll);
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::Unbonded { member: 20, pool_id: 1, balance: 20, points: 20, era: 4 },
+				]
+			);
+
+			CurrentEra::set(5);
+
+			// When
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(20), 20, 0));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Withdrawn { member: 20, pool_id: 1, balance: 20, points: 20 },
+					Event::MemberRemoved { pool_id: 1, member: 20 }
+				]
+			);
+
+			// Then
+			assert_eq!(PoolMembers::<Runtime>::get(20), None);
+			assert_eq!(ClaimPermissions::<Runtime>::contains_key(20), false);
+		});
+	}
+}
+
+mod create {
+	use super::*;
+
+	#[test]
+	fn create_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// next pool id is 2.
+			let next_pool_stash = Pools::create_bonded_account(2);
+			let ed = Balances::minimum_balance();
+
+			assert!(!BondedPools::<Runtime>::contains_key(2));
+			assert!(!RewardPools::<Runtime>::contains_key(2));
+			assert!(!PoolMembers::<Runtime>::contains_key(11));
+			assert_err!(StakingMock::active_stake(&next_pool_stash), "balance not found");
+
+			Balances::make_free_balance_be(&11, StakingMock::minimum_nominator_bond() + ed);
+			assert_ok!(Pools::create(
+				RuntimeOrigin::signed(11),
+				StakingMock::minimum_nominator_bond(),
+				123,
+				456,
+				789
+			));
+
+			assert_eq!(Balances::free_balance(&11), 0);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(11).unwrap(),
+				PoolMember {
+					pool_id: 2,
+					points: StakingMock::minimum_nominator_bond(),
+					..Default::default()
+				}
+			);
+			assert_eq!(
+				BondedPool::<Runtime>::get(2).unwrap(),
+				BondedPool {
+					id: 2,
+					inner: BondedPoolInner {
+						commission: Commission::default(),
+						points: StakingMock::minimum_nominator_bond(),
+						member_counter: 1,
+						roles: PoolRoles {
+							depositor: 11,
+							root: Some(123),
+							nominator: Some(456),
+							bouncer: Some(789)
+						},
+						state: PoolState::Open,
+					}
+				}
+			);
+			assert_eq!(
+				StakingMock::active_stake(&next_pool_stash).unwrap(),
+				StakingMock::minimum_nominator_bond()
+			);
+			assert_eq!(
+				RewardPools::<Runtime>::get(2).unwrap(),
+				RewardPool { ..Default::default() }
+			);
+
+			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::Created { depositor: 11, pool_id: 2 },
+					Event::Bonded { member: 11, pool_id: 2, bonded: 10, joined: true }
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn create_errors_correctly() {
+		ExtBuilder::default().with_check(0).build_and_execute(|| {
+			assert_noop!(
+				Pools::create(RuntimeOrigin::signed(10), 420, 123, 456, 789),
+				Error::<Runtime>::AccountBelongsToOtherPool
+			);
+
+			// Given
+			assert_eq!(MinCreateBond::<Runtime>::get(), 2);
+			assert_eq!(StakingMock::minimum_nominator_bond(), 10);
+
+			// Then
+			assert_noop!(
+				Pools::create(RuntimeOrigin::signed(11), 9, 123, 456, 789),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+
+			// Given
+			MinCreateBond::<Runtime>::put(20);
+
+			// Then
+			assert_noop!(
+				Pools::create(RuntimeOrigin::signed(11), 19, 123, 456, 789),
+				Error::<Runtime>::MinimumBondNotMet
+			);
+
+			// Given
+			BondedPool::<Runtime> {
+				id: 2,
+				inner: BondedPoolInner {
+					commission: Commission::default(),
+					member_counter: 1,
+					points: 10,
+					roles: DEFAULT_ROLES,
+					state: PoolState::Open,
+				},
+			}
+			.put();
+			assert_eq!(MaxPools::<Runtime>::get(), Some(2));
+			assert_eq!(BondedPools::<Runtime>::count(), 2);
+
+			// Then
+			assert_noop!(
+				Pools::create(RuntimeOrigin::signed(11), 20, 123, 456, 789),
+				Error::<Runtime>::MaxPools
+			);
+
+			// Given
+			assert_eq!(PoolMembers::<Runtime>::count(), 1);
+			MaxPools::<Runtime>::put(3);
+			MaxPoolMembers::<Runtime>::put(1);
+			Balances::make_free_balance_be(&11, 5 + 20);
+
+			// Then
+			let create = RuntimeCall::Pools(crate::Call::<Runtime>::create {
+				amount: 20,
+				root: 11,
+				nominator: 11,
+				bouncer: 11,
+			});
+			assert_noop!(
+				create.dispatch(RuntimeOrigin::signed(11)),
+				Error::<Runtime>::MaxPoolMembers
+			);
+		});
+	}
+
+	#[test]
+	fn create_with_pool_id_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let ed = Balances::minimum_balance();
+
+			Balances::make_free_balance_be(&11, StakingMock::minimum_nominator_bond() + ed);
+			assert_ok!(Pools::create(
+				RuntimeOrigin::signed(11),
+				StakingMock::minimum_nominator_bond(),
+				123,
+				456,
+				789
+			));
+
+			assert_eq!(Balances::free_balance(&11), 0);
+			// delete the initial pool created, then pool_Id `1` will be free
+
+			assert_noop!(
+				Pools::create_with_pool_id(RuntimeOrigin::signed(12), 20, 234, 654, 783, 1),
+				Error::<Runtime>::PoolIdInUse
+			);
+
+			assert_noop!(
+				Pools::create_with_pool_id(RuntimeOrigin::signed(12), 20, 234, 654, 783, 3),
+				Error::<Runtime>::InvalidPoolId
+			);
+
+			// start dismantling the pool.
+			assert_ok!(Pools::set_state(RuntimeOrigin::signed(902), 1, PoolState::Destroying));
+			assert_ok!(fully_unbond_permissioned(10));
+
+			CurrentEra::set(3);
+			assert_ok!(Pools::withdraw_unbonded(RuntimeOrigin::signed(10), 10, 10));
+
+			assert_ok!(Pools::create_with_pool_id(RuntimeOrigin::signed(10), 20, 234, 654, 783, 1));
+		});
+	}
+}
+
+#[test]
+fn set_claimable_actor_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// Given
+		Balances::make_free_balance_be(&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 },
+			]
+		);
+
+		// Make permissionless
+		assert_eq!(ClaimPermissions::<Runtime>::get(11), ClaimPermission::Permissioned);
+		assert_noop!(
+			Pools::set_claim_permission(
+				RuntimeOrigin::signed(12),
+				ClaimPermission::PermissionlessAll
+			),
+			Error::<T>::PoolMemberNotFound
+		);
+		assert_ok!(Pools::set_claim_permission(
+			RuntimeOrigin::signed(11),
+			ClaimPermission::PermissionlessAll
+		));
+
+		// then
+		assert_eq!(ClaimPermissions::<Runtime>::get(11), ClaimPermission::PermissionlessAll);
+	});
+}
+
+mod nominate {
+	use super::*;
+
+	#[test]
+	fn nominate_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Depositor can't nominate
+			assert_noop!(
+				Pools::nominate(RuntimeOrigin::signed(10), 1, vec![21]),
+				Error::<Runtime>::NotNominator
+			);
+
+			// bouncer can't nominate
+			assert_noop!(
+				Pools::nominate(RuntimeOrigin::signed(902), 1, vec![21]),
+				Error::<Runtime>::NotNominator
+			);
+
+			// Root can nominate
+			assert_ok!(Pools::nominate(RuntimeOrigin::signed(900), 1, vec![21]));
+			assert_eq!(Nominations::get().unwrap(), vec![21]);
+
+			// Nominator can nominate
+			assert_ok!(Pools::nominate(RuntimeOrigin::signed(901), 1, vec![31]));
+			assert_eq!(Nominations::get().unwrap(), vec![31]);
+
+			// Can't nominate for a pool that doesn't exist
+			assert_noop!(
+				Pools::nominate(RuntimeOrigin::signed(902), 123, vec![21]),
+				Error::<Runtime>::PoolNotFound
+			);
+		});
+	}
+}
+
+mod set_state {
+	use super::*;
+
+	#[test]
+	fn set_state_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Given
+			assert_ok!(BondedPool::<Runtime>::get(1).unwrap().ok_to_be_open());
+
+			// Only the root and bouncer can change the state when the pool is ok to be open.
+			assert_noop!(
+				Pools::set_state(RuntimeOrigin::signed(10), 1, PoolState::Blocked),
+				Error::<Runtime>::CanNotChangeState
+			);
+			assert_noop!(
+				Pools::set_state(RuntimeOrigin::signed(901), 1, PoolState::Blocked),
+				Error::<Runtime>::CanNotChangeState
+			);
+
+			// Root can change state
+			assert_ok!(Pools::set_state(RuntimeOrigin::signed(900), 1, PoolState::Blocked));
+
+			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::StateChanged { pool_id: 1, new_state: PoolState::Blocked }
+				]
+			);
+
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().state, PoolState::Blocked);
+
+			// bouncer can change state
+			assert_ok!(Pools::set_state(RuntimeOrigin::signed(902), 1, PoolState::Destroying));
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().state, PoolState::Destroying);
+
+			// If the pool is destroying, then no one can set state
+			assert_noop!(
+				Pools::set_state(RuntimeOrigin::signed(900), 1, PoolState::Blocked),
+				Error::<Runtime>::CanNotChangeState
+			);
+			assert_noop!(
+				Pools::set_state(RuntimeOrigin::signed(902), 1, PoolState::Blocked),
+				Error::<Runtime>::CanNotChangeState
+			);
+
+			// If the pool is not ok to be open, then anyone can set it to destroying
+
+			// Given
+			unsafe_set_state(1, PoolState::Open);
+			let mut bonded_pool = BondedPool::<Runtime>::get(1).unwrap();
+			bonded_pool.points = 100;
+			bonded_pool.put();
+			// When
+			assert_ok!(Pools::set_state(RuntimeOrigin::signed(11), 1, PoolState::Destroying));
+			// Then
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().state, PoolState::Destroying);
+
+			// Given
+			Balances::make_free_balance_be(&default_bonded_account(), Balance::max_value() / 10);
+			unsafe_set_state(1, PoolState::Open);
+			// When
+			assert_ok!(Pools::set_state(RuntimeOrigin::signed(11), 1, PoolState::Destroying));
+			// Then
+			assert_eq!(BondedPool::<Runtime>::get(1).unwrap().state, PoolState::Destroying);
+
+			// If the pool is not ok to be open, it cannot be permissionlessly set to a state that
+			// isn't destroying
+			unsafe_set_state(1, PoolState::Open);
+			assert_noop!(
+				Pools::set_state(RuntimeOrigin::signed(11), 1, PoolState::Blocked),
+				Error::<Runtime>::CanNotChangeState
+			);
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::StateChanged { pool_id: 1, new_state: PoolState::Destroying },
+					Event::StateChanged { pool_id: 1, new_state: PoolState::Destroying },
+					Event::StateChanged { pool_id: 1, new_state: PoolState::Destroying }
+				]
+			);
+		});
+	}
+}
+
+mod set_metadata {
+	use super::*;
+
+	#[test]
+	fn set_metadata_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Root can set metadata
+			assert_ok!(Pools::set_metadata(RuntimeOrigin::signed(900), 1, vec![1, 1]));
+			assert_eq!(Metadata::<Runtime>::get(1), vec![1, 1]);
+
+			// bouncer can set metadata
+			assert_ok!(Pools::set_metadata(RuntimeOrigin::signed(902), 1, vec![2, 2]));
+			assert_eq!(Metadata::<Runtime>::get(1), vec![2, 2]);
+
+			// Depositor can't set metadata
+			assert_noop!(
+				Pools::set_metadata(RuntimeOrigin::signed(10), 1, vec![3, 3]),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			// Nominator can't set metadata
+			assert_noop!(
+				Pools::set_metadata(RuntimeOrigin::signed(901), 1, vec![3, 3]),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			// Metadata cannot be longer than `MaxMetadataLen`
+			assert_noop!(
+				Pools::set_metadata(RuntimeOrigin::signed(900), 1, vec![1, 1, 1]),
+				Error::<Runtime>::MetadataExceedsMaxLen
+			);
+		});
+	}
+}
+
+mod set_configs {
+	use super::*;
+
+	#[test]
+	fn set_configs_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Setting works
+			assert_ok!(Pools::set_configs(
+				RuntimeOrigin::root(),
+				ConfigOp::Set(1 as Balance),
+				ConfigOp::Set(2 as Balance),
+				ConfigOp::Set(3u32),
+				ConfigOp::Set(4u32),
+				ConfigOp::Set(5u32),
+				ConfigOp::Set(Perbill::from_percent(6))
+			));
+			assert_eq!(MinJoinBond::<Runtime>::get(), 1);
+			assert_eq!(MinCreateBond::<Runtime>::get(), 2);
+			assert_eq!(MaxPools::<Runtime>::get(), Some(3));
+			assert_eq!(MaxPoolMembers::<Runtime>::get(), Some(4));
+			assert_eq!(MaxPoolMembersPerPool::<Runtime>::get(), Some(5));
+			assert_eq!(GlobalMaxCommission::<Runtime>::get(), Some(Perbill::from_percent(6)));
+
+			// Noop does nothing
+			assert_storage_noop!(assert_ok!(Pools::set_configs(
+				RuntimeOrigin::root(),
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+			)));
+
+			// Removing works
+			assert_ok!(Pools::set_configs(
+				RuntimeOrigin::root(),
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+			));
+			assert_eq!(MinJoinBond::<Runtime>::get(), 0);
+			assert_eq!(MinCreateBond::<Runtime>::get(), 0);
+			assert_eq!(MaxPools::<Runtime>::get(), None);
+			assert_eq!(MaxPoolMembers::<Runtime>::get(), None);
+			assert_eq!(MaxPoolMembersPerPool::<Runtime>::get(), None);
+			assert_eq!(GlobalMaxCommission::<Runtime>::get(), None);
+		});
+	}
+}
+
+mod bond_extra {
+	use super::*;
+	use crate::Event;
+
+	#[test]
+	fn bond_extra_from_free_balance_creator() {
+		ExtBuilder::default().build_and_execute(|| {
+			// 10 is the owner and a member in pool 1, give them some more funds.
+			Balances::make_free_balance_be(&10, 100);
+
+			// given
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 10);
+			assert_eq!(Balances::free_balance(10), 100);
+
+			// when
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(10)));
+
+			// then
+			assert_eq!(Balances::free_balance(10), 90);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 20);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 20);
+
+			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: 10, pool_id: 1, bonded: 10, joined: false }
+				]
+			);
+
+			// when
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::FreeBalance(20)));
+
+			// then
+			assert_eq!(Balances::free_balance(10), 70);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 40);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 40);
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Bonded { member: 10, pool_id: 1, bonded: 20, joined: false }]
+			);
+		})
+	}
+
+	#[test]
+	fn bond_extra_from_rewards_creator() {
+		ExtBuilder::default().build_and_execute(|| {
+			// put some money in the reward account, all of which will belong to 10 as the only
+			// member of the pool.
+			Balances::make_free_balance_be(&default_reward_account(), 7);
+			// ... if which only 2 is claimable to make sure the reward account does not die.
+			let claimable_reward = 7 - ExistentialDeposit::get();
+
+			// given
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 10);
+			assert_eq!(Balances::free_balance(10), 35);
+
+			// when
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::Rewards));
+
+			// then
+			assert_eq!(Balances::free_balance(10), 35);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10 + claimable_reward);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 10 + claimable_reward);
+
+			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::PaidOut { member: 10, pool_id: 1, payout: claimable_reward },
+					Event::Bonded {
+						member: 10,
+						pool_id: 1,
+						bonded: claimable_reward,
+						joined: false
+					}
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn bond_extra_from_rewards_joiner() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			// put some money in the reward account, all of which will belong to 10 as the only
+			// member of the pool.
+			Balances::make_free_balance_be(&default_reward_account(), 8);
+			// ... if which only 3 is claimable to make sure the reward account does not die.
+			let claimable_reward = 8 - ExistentialDeposit::get();
+			// NOTE: easier to read of we use 3, so let's use the number instead of variable.
+			assert_eq!(claimable_reward, 3, "test is correct if rewards are divisible by 3");
+
+			// given
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10);
+			assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 20);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 30);
+			assert_eq!(Balances::free_balance(10), 35);
+			assert_eq!(Balances::free_balance(20), 20);
+
+			// when
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(10), BondExtra::Rewards));
+			assert_eq!(Balances::free_balance(&default_reward_account()), 7);
+
+			// then
+			assert_eq!(Balances::free_balance(10), 35);
+			// 10's share of the reward is 1/3, since they gave 10/30 of the total shares.
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10 + 1);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 30 + 1);
+
+			// when
+			assert_ok!(Pools::bond_extra(RuntimeOrigin::signed(20), BondExtra::Rewards));
+
+			// then
+			assert_eq!(Balances::free_balance(20), 20);
+			// 20's share of the rewards is the other 2/3 of the rewards, since they have 20/30 of
+			// the shares
+			assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 20 + 2);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 30 + 3);
+
+			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: 20, pool_id: 1, bonded: 20, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 1 },
+					Event::Bonded { member: 10, pool_id: 1, bonded: 1, joined: false },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 2 },
+					Event::Bonded { member: 20, pool_id: 1, bonded: 2, joined: false }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn bond_extra_other() {
+		ExtBuilder::default().add_members(vec![(20, 20)]).build_and_execute(|| {
+			Balances::make_free_balance_be(&default_reward_account(), 8);
+			// ... of which only 3 are claimable to make sure the reward account does not die.
+			let claimable_reward = 8 - ExistentialDeposit::get();
+			// NOTE: easier to read if we use 3, so let's use the number instead of variable.
+			assert_eq!(claimable_reward, 3, "test is correct if rewards are divisible by 3");
+
+			// given
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10);
+			assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 20);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 30);
+			assert_eq!(Balances::free_balance(10), 35);
+			assert_eq!(Balances::free_balance(20), 20);
+
+			// Permissioned by default
+			assert_noop!(
+				Pools::bond_extra_other(RuntimeOrigin::signed(80), 20, BondExtra::Rewards),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			assert_ok!(Pools::set_claim_permission(
+				RuntimeOrigin::signed(10),
+				ClaimPermission::PermissionlessAll
+			));
+			assert_ok!(Pools::bond_extra_other(RuntimeOrigin::signed(50), 10, BondExtra::Rewards));
+			assert_eq!(Balances::free_balance(&default_reward_account()), 7);
+
+			// then
+			assert_eq!(Balances::free_balance(10), 35);
+			assert_eq!(PoolMembers::<Runtime>::get(10).unwrap().points, 10 + 1);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 30 + 1);
+
+			// when
+			assert_noop!(
+				Pools::bond_extra_other(RuntimeOrigin::signed(40), 40, BondExtra::Rewards),
+				Error::<Runtime>::PoolMemberNotFound
+			);
+
+			// when
+			assert_ok!(Pools::bond_extra_other(
+				RuntimeOrigin::signed(20),
+				20,
+				BondExtra::FreeBalance(10)
+			));
+
+			// then
+			assert_eq!(Balances::free_balance(20), 12);
+			assert_eq!(Balances::free_balance(&default_reward_account()), 5);
+			assert_eq!(PoolMembers::<Runtime>::get(20).unwrap().points, 30);
+			assert_eq!(BondedPools::<Runtime>::get(1).unwrap().points, 41);
+		})
+	}
+}
+
+mod update_roles {
+	use super::*;
+
+	#[test]
+	fn update_roles_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().roles,
+				PoolRoles {
+					depositor: 10,
+					root: Some(900),
+					nominator: Some(901),
+					bouncer: Some(902)
+				},
+			);
+
+			// non-existent pools
+			assert_noop!(
+				Pools::update_roles(
+					RuntimeOrigin::signed(1),
+					2,
+					ConfigOp::Set(5),
+					ConfigOp::Set(6),
+					ConfigOp::Set(7)
+				),
+				Error::<Runtime>::PoolNotFound,
+			);
+
+			// depositor cannot change roles.
+			assert_noop!(
+				Pools::update_roles(
+					RuntimeOrigin::signed(1),
+					1,
+					ConfigOp::Set(5),
+					ConfigOp::Set(6),
+					ConfigOp::Set(7)
+				),
+				Error::<Runtime>::DoesNotHavePermission,
+			);
+
+			// nominator cannot change roles.
+			assert_noop!(
+				Pools::update_roles(
+					RuntimeOrigin::signed(901),
+					1,
+					ConfigOp::Set(5),
+					ConfigOp::Set(6),
+					ConfigOp::Set(7)
+				),
+				Error::<Runtime>::DoesNotHavePermission,
+			);
+			// bouncer
+			assert_noop!(
+				Pools::update_roles(
+					RuntimeOrigin::signed(902),
+					1,
+					ConfigOp::Set(5),
+					ConfigOp::Set(6),
+					ConfigOp::Set(7)
+				),
+				Error::<Runtime>::DoesNotHavePermission,
+			);
+
+			// but root can
+			assert_ok!(Pools::update_roles(
+				RuntimeOrigin::signed(900),
+				1,
+				ConfigOp::Set(5),
+				ConfigOp::Set(6),
+				ConfigOp::Set(7)
+			));
+
+			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::RolesUpdated { root: Some(5), bouncer: Some(7), nominator: Some(6) }
+				]
+			);
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().roles,
+				PoolRoles { depositor: 10, root: Some(5), nominator: Some(6), bouncer: Some(7) },
+			);
+
+			// also root origin can
+			assert_ok!(Pools::update_roles(
+				RuntimeOrigin::root(),
+				1,
+				ConfigOp::Set(1),
+				ConfigOp::Set(2),
+				ConfigOp::Set(3)
+			));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::RolesUpdated { root: Some(1), bouncer: Some(3), nominator: Some(2) }]
+			);
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().roles,
+				PoolRoles { depositor: 10, root: Some(1), nominator: Some(2), bouncer: Some(3) },
+			);
+
+			// Noop works
+			assert_ok!(Pools::update_roles(
+				RuntimeOrigin::root(),
+				1,
+				ConfigOp::Set(11),
+				ConfigOp::Noop,
+				ConfigOp::Noop
+			));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::RolesUpdated { root: Some(11), bouncer: Some(3), nominator: Some(2) }]
+			);
+
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().roles,
+				PoolRoles { depositor: 10, root: Some(11), nominator: Some(2), bouncer: Some(3) },
+			);
+
+			// Remove works
+			assert_ok!(Pools::update_roles(
+				RuntimeOrigin::root(),
+				1,
+				ConfigOp::Set(69),
+				ConfigOp::Remove,
+				ConfigOp::Remove
+			));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::RolesUpdated { root: Some(69), bouncer: None, nominator: None }]
+			);
+
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().roles,
+				PoolRoles { depositor: 10, root: Some(69), nominator: None, bouncer: None },
+			);
+		})
+	}
+}
+
+mod reward_counter_precision {
+	use super::*;
+
+	const DOT: Balance = 10u128.pow(10u32);
+	const POLKADOT_TOTAL_ISSUANCE_GENESIS: Balance = DOT * 10u128.pow(9u32);
+
+	const fn inflation(years: u128) -> u128 {
+		let mut i = 0;
+		let mut start = POLKADOT_TOTAL_ISSUANCE_GENESIS;
+		while i < years {
+			start = start + start / 10;
+			i += 1
+		}
+		start
+	}
+
+	fn default_pool_reward_counter() -> FixedU128 {
+		let bonded_pool = BondedPools::<T>::get(1).unwrap();
+		RewardPools::<Runtime>::get(1)
+			.unwrap()
+			.current_reward_counter(1, bonded_pool.points, bonded_pool.commission.current())
+			.unwrap()
+			.0
+	}
+
+	fn pending_rewards(of: AccountId) -> Option<BalanceOf<T>> {
+		let member = PoolMembers::<T>::get(of).unwrap();
+		assert_eq!(member.pool_id, 1);
+		let rc = default_pool_reward_counter();
+		member.pending_rewards(rc).ok()
+	}
+
+	#[test]
+	fn smallest_claimable_reward() {
+		// create a pool that has all of the polkadot issuance in 50 years.
+		let pool_bond = inflation(50);
+		ExtBuilder::default().ed(DOT).min_bond(pool_bond).build_and_execute(|| {
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 10, pool_id: 1 },
+					Event::Bonded {
+						member: 10,
+						pool_id: 1,
+						bonded: 1173908528796953165005,
+						joined: true,
+					}
+				]
+			);
+
+			// the smallest reward that this pool can handle is
+			let expected_smallest_reward = inflation(50) / 10u128.pow(18);
+
+			// tad bit less. cannot be paid out.
+			deposit_rewards(expected_smallest_reward - 1);
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_eq!(pool_events_since_last_call(), vec![]);
+			// revert it.
+
+			remove_rewards(expected_smallest_reward - 1);
+
+			// tad bit more. can be claimed.
+			deposit_rewards(expected_smallest_reward + 1);
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 1173 }]
+			);
+		})
+	}
+
+	#[test]
+	fn massive_reward_in_small_pool() {
+		let tiny_bond = 1000 * DOT;
+		ExtBuilder::default().ed(DOT).min_bond(tiny_bond).build_and_execute(|| {
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 10, pool_id: 1 },
+					Event::Bonded { member: 10, pool_id: 1, bonded: 10000000000000, joined: true }
+				]
+			);
+
+			Balances::make_free_balance_be(&20, tiny_bond);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), tiny_bond / 2, 1));
+
+			// Suddenly, add a shit ton of rewards.
+			deposit_rewards(inflation(1));
+
+			// now claim.
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Bonded { member: 20, pool_id: 1, bonded: 5000000000000, joined: true },
+					Event::PaidOut { member: 10, pool_id: 1, payout: 7333333333333333333 },
+					Event::PaidOut { member: 20, pool_id: 1, payout: 3666666666666666666 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn reward_counter_calc_wont_fail_in_normal_polkadot_future() {
+		// create a pool that has roughly half of the polkadot issuance in 10 years.
+		let pool_bond = inflation(10) / 2;
+		ExtBuilder::default().ed(DOT).min_bond(pool_bond).build_and_execute(|| {
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 10, pool_id: 1 },
+					Event::Bonded {
+						member: 10,
+						pool_id: 1,
+						bonded: 12_968_712_300_500_000_000,
+						joined: true,
+					}
+				]
+			);
+
+			// in 10 years, the total claimed rewards are large values as well. assuming that a pool
+			// is earning all of the inflation per year (which is really unrealistic, but worse
+			// case), that will be:
+			let pool_total_earnings_10_years = inflation(10) - POLKADOT_TOTAL_ISSUANCE_GENESIS;
+			deposit_rewards(pool_total_earnings_10_years);
+
+			// some whale now joins with the other half ot the total issuance. This will bloat all
+			// the calculation regarding current reward counter.
+			Balances::make_free_balance_be(&20, pool_bond * 2);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(20), pool_bond, 1));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::Bonded {
+					member: 20,
+					pool_id: 1,
+					bonded: 12_968_712_300_500_000_000,
+					joined: true
+				}]
+			);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 15937424600999999996 }]
+			);
+
+			// now let a small member join with 10 DOTs.
+			Balances::make_free_balance_be(&30, 20 * DOT);
+			assert_ok!(Pools::join(RuntimeOrigin::signed(30), 10 * DOT, 1));
+
+			// and give a reasonably small reward to the pool.
+			deposit_rewards(DOT);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(30)));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Bonded { member: 30, pool_id: 1, bonded: 100000000000, joined: true },
+					// quite small, but working fine.
+					Event::PaidOut { member: 30, pool_id: 1, payout: 38 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn reward_counter_update_can_fail_if_pool_is_highly_slashed() {
+		// create a pool that has roughly half of the polkadot issuance in 10 years.
+		let pool_bond = inflation(10) / 2;
+		ExtBuilder::default().ed(DOT).min_bond(pool_bond).build_and_execute(|| {
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 10, pool_id: 1 },
+					Event::Bonded {
+						member: 10,
+						pool_id: 1,
+						bonded: 12_968_712_300_500_000_000,
+						joined: true,
+					}
+				]
+			);
+
+			// slash this pool by 99% of that.
+			StakingMock::set_bonded_balance(default_bonded_account(), DOT + pool_bond / 100);
+
+			// some whale now joins with the other half ot the total issuance. This will trigger an
+			// overflow. This test is actually a bit too lenient because all the reward counters are
+			// set to zero. In other tests that we want to assert a scenario won't fail, we should
+			// also set the reward counters to some large value.
+			Balances::make_free_balance_be(&20, pool_bond * 2);
+			assert_err!(
+				Pools::join(RuntimeOrigin::signed(20), pool_bond, 1),
+				Error::<T>::OverflowRisk
+			);
+		})
+	}
+
+	#[test]
+	fn if_small_member_waits_long_enough_they_will_earn_rewards() {
+		// create a pool that has a quarter of the current polkadot issuance
+		ExtBuilder::default()
+			.ed(DOT)
+			.min_bond(POLKADOT_TOTAL_ISSUANCE_GENESIS / 4)
+			.build_and_execute(|| {
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Created { depositor: 10, pool_id: 1 },
+						Event::Bonded {
+							member: 10,
+							pool_id: 1,
+							bonded: 2500000000000000000,
+							joined: true,
+						}
+					]
+				);
+
+				// and have a tiny fish join the pool as well..
+				Balances::make_free_balance_be(&20, 20 * DOT);
+				assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10 * DOT, 1));
+
+				// earn some small rewards
+				deposit_rewards(DOT / 1000);
+
+				// no point in claiming for 20 (nonetheless, it should be harmless)
+				assert!(pending_rewards(20).unwrap().is_zero());
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Bonded {
+							member: 20,
+							pool_id: 1,
+							bonded: 100000000000,
+							joined: true
+						},
+						Event::PaidOut { member: 10, pool_id: 1, payout: 9999997 }
+					]
+				);
+
+				// earn some small more, still nothing can be claimed for 20, but 10 claims their
+				// share.
+				deposit_rewards(DOT / 1000);
+				assert!(pending_rewards(20).unwrap().is_zero());
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![Event::PaidOut { member: 10, pool_id: 1, payout: 10000000 }]
+				);
+
+				// earn some more rewards, this time 20 can also claim.
+				deposit_rewards(DOT / 1000);
+				assert_eq!(pending_rewards(20).unwrap(), 1);
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::PaidOut { member: 10, pool_id: 1, payout: 10000000 },
+						Event::PaidOut { member: 20, pool_id: 1, payout: 1 }
+					]
+				);
+			});
+	}
+
+	#[test]
+	fn zero_reward_claim_does_not_update_reward_counter() {
+		// create a pool that has a quarter of the current polkadot issuance
+		ExtBuilder::default()
+			.ed(DOT)
+			.min_bond(POLKADOT_TOTAL_ISSUANCE_GENESIS / 4)
+			.build_and_execute(|| {
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Created { depositor: 10, pool_id: 1 },
+						Event::Bonded {
+							member: 10,
+							pool_id: 1,
+							bonded: 2500000000000000000,
+							joined: true,
+						}
+					]
+				);
+
+				// and have a tiny fish join the pool as well..
+				Balances::make_free_balance_be(&20, 20 * DOT);
+				assert_ok!(Pools::join(RuntimeOrigin::signed(20), 10 * DOT, 1));
+
+				// earn some small rewards
+				deposit_rewards(DOT / 1000);
+
+				// if 20 claims now, their reward counter should stay the same, so that they have a
+				// chance of claiming this if they let it accumulate. Also see
+				// `if_small_member_waits_long_enough_they_will_earn_rewards`
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+				assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(20)));
+				assert_eq!(
+					pool_events_since_last_call(),
+					vec![
+						Event::Bonded {
+							member: 20,
+							pool_id: 1,
+							bonded: 100000000000,
+							joined: true
+						},
+						Event::PaidOut { member: 10, pool_id: 1, payout: 9999997 }
+					]
+				);
+
+				let current_reward_counter = default_pool_reward_counter();
+				// has been updated, because they actually claimed something.
+				assert_eq!(
+					PoolMembers::<T>::get(10).unwrap().last_recorded_reward_counter,
+					current_reward_counter
+				);
+				// has not be updated, even though the claim transaction went through okay.
+				assert_eq!(
+					PoolMembers::<T>::get(20).unwrap().last_recorded_reward_counter,
+					Default::default()
+				);
+			});
+	}
+}
+
+mod commission {
+	use super::*;
+
+	#[test]
+	fn set_commission_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let pool_id = 1;
+			let root = 900;
+
+			// Commission can be set by the `root` role.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				pool_id,
+				Some((Perbill::from_percent(50), root))
+			));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 10, pool_id },
+					Event::Bonded { member: 10, pool_id, bonded: 10, joined: true },
+					Event::PoolCommissionUpdated {
+						pool_id,
+						current: Some((Perbill::from_percent(50), root))
+					},
+				]
+			);
+
+			// Commission can be updated only, while keeping the same payee.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				1,
+				Some((Perbill::from_percent(25), root))
+			));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id,
+					current: Some((Perbill::from_percent(25), root))
+				},]
+			);
+
+			// Payee can be updated only, while keeping the same commission.
+
+			// Given:
+			let payee = 901;
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				pool_id,
+				Some((Perbill::from_percent(25), payee))
+			));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id: 1,
+					current: Some((Perbill::from_percent(25), payee))
+				},]
+			);
+
+			// Pool earns 80 points and a payout is triggered.
+
+			// Given:
+			deposit_rewards(80);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap(),
+				PoolMember::<Runtime> { pool_id, points: 10, ..Default::default() }
+			);
+
+			// When:
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id, payout: 60 }]
+			);
+			assert_eq!(RewardPool::<Runtime>::current_balance(pool_id), 20);
+
+			// Pending pool commission can be claimed by the root role.
+
+			// When:
+			assert_ok!(Pools::claim_commission(RuntimeOrigin::signed(root), pool_id));
+
+			// Then:
+			assert_eq!(RewardPool::<Runtime>::current_balance(pool_id), 0);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionClaimed { pool_id: 1, commission: 20 }]
+			);
+
+			// Commission can be removed from the pool completely.
+
+			// When:
+			assert_ok!(Pools::set_commission(RuntimeOrigin::signed(root), pool_id, None));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated { pool_id, current: None },]
+			);
+
+			// Given a pool now has a reward counter history, additional rewards and payouts can be
+			// made while maintaining a correct ledger of the reward pool. Pool earns 100 points,
+			// payout is triggered.
+			//
+			// Note that the `total_commission_pending` will not be updated until `update_records`
+			// is next called, which is not done in this test segment..
+
+			// Given:
+			deposit_rewards(100);
+
+			// When:
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id, payout: 100 },]
+			);
+			assert_eq!(
+				RewardPools::<Runtime>::get(pool_id).unwrap(),
+				RewardPool {
+					last_recorded_reward_counter: FixedU128::from_float(6.0),
+					last_recorded_total_payouts: 80,
+					total_rewards_claimed: 160,
+					total_commission_pending: 0,
+					total_commission_claimed: 20
+				}
+			);
+
+			// When set commission is called again, update_records is called and
+			// `total_commission_pending` is updated, based on the current reward counter and pool
+			// balance.
+			//
+			// Note that commission is now 0%, so it should not come into play with subsequent
+			// payouts.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				1,
+				Some((Perbill::from_percent(10), root))
+			));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id,
+					current: Some((Perbill::from_percent(10), root))
+				},]
+			);
+			assert_eq!(
+				RewardPools::<Runtime>::get(pool_id).unwrap(),
+				RewardPool {
+					last_recorded_reward_counter: FixedU128::from_float(16.0),
+					last_recorded_total_payouts: 180,
+					total_rewards_claimed: 160,
+					total_commission_pending: 0,
+					total_commission_claimed: 20
+				}
+			);
+
+			// Supplying a 0% commission along with a payee results in a `None` current value.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				pool_id,
+				Some((Perbill::from_percent(0), root))
+			));
+
+			// Then:
+			assert_eq!(
+				BondedPool::<Runtime>::get(1).unwrap().commission,
+				Commission { current: None, max: None, change_rate: None, throttle_from: Some(1) }
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id,
+					current: Some((Perbill::from_percent(0), root))
+				},]
+			);
+
+			// The payee can be updated even when commission has reached maximum commission. Both
+			// commission and max commission are set to 10% to test this.
+
+			// Given:
+			assert_ok!(Pools::set_commission_max(
+				RuntimeOrigin::signed(root),
+				pool_id,
+				Perbill::from_percent(10)
+			));
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				pool_id,
+				Some((Perbill::from_percent(10), root))
+			));
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				pool_id,
+				Some((Perbill::from_percent(10), payee))
+			));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PoolMaxCommissionUpdated {
+						pool_id,
+						max_commission: Perbill::from_percent(10)
+					},
+					Event::PoolCommissionUpdated {
+						pool_id,
+						current: Some((Perbill::from_percent(10), root))
+					},
+					Event::PoolCommissionUpdated {
+						pool_id,
+						current: Some((Perbill::from_percent(10), payee))
+					}
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn commission_reward_counter_works_one_member() {
+		ExtBuilder::default().build_and_execute(|| {
+			let pool_id = 1;
+			let root = 900;
+			let member = 10;
+
+			// Set the pool commission to 10% to test commission shares. Pool is topped up 40 points
+			// and `member` immediately claims their pending rewards. Reward pooll should still have
+			// 10% share.
+
+			// Given:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				1,
+				Some((Perbill::from_percent(10), root)),
+			));
+			deposit_rewards(40);
+
+			// When:
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(RewardPool::<Runtime>::current_balance(pool_id), 4);
+
+			// Set pool commission to 20% and repeat the same process.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(root),
+				1,
+				Some((Perbill::from_percent(20), root)),
+			));
+
+			// Then:
+			assert_eq!(
+				RewardPools::<Runtime>::get(pool_id).unwrap(),
+				RewardPool {
+					last_recorded_reward_counter: FixedU128::from_float(3.6),
+					last_recorded_total_payouts: 40,
+					total_rewards_claimed: 36,
+					total_commission_pending: 4,
+					total_commission_claimed: 0
+				}
+			);
+
+			// The current reward counter should yield the correct pending rewards of zero.
+
+			// Given:
+			let (current_reward_counter, _) = RewardPools::<Runtime>::get(pool_id)
+				.unwrap()
+				.current_reward_counter(
+					pool_id,
+					BondedPools::<Runtime>::get(pool_id).unwrap().points,
+					Perbill::from_percent(20),
+				)
+				.unwrap();
+
+			// Then:
+			assert_eq!(
+				PoolMembers::<Runtime>::get(member)
+					.unwrap()
+					.pending_rewards(current_reward_counter)
+					.unwrap(),
+				0
+			);
+
+			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::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(10), 900))
+					},
+					Event::PaidOut { member: 10, pool_id: 1, payout: 36 },
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(20), 900))
+					}
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn set_commission_handles_errors() {
+		ExtBuilder::default().build_and_execute(|| {
+			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 },
+				]
+			);
+
+			// Provided pool does not exist.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					9999,
+					Some((Perbill::from_percent(1), 900)),
+				),
+				Error::<Runtime>::PoolNotFound
+			);
+
+			// Sender does not have permission to set commission.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(1),
+					1,
+					Some((Perbill::from_percent(5), 900)),
+				),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			// Commission increases will be throttled if outside of change_rate allowance.
+			// Commission is set to 5%.
+			// Change rate is set to 1% max increase, 2 block delay.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(5), 900)),
+			));
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(1), min_delay: 2_u64 }
+			));
+			assert_eq!(
+				BondedPool::<Runtime>::get(1).unwrap().commission,
+				Commission {
+					current: Some((Perbill::from_percent(5), 900)),
+					max: None,
+					change_rate: Some(CommissionChangeRate {
+						max_increase: Perbill::from_percent(1),
+						min_delay: 2_u64
+					}),
+					throttle_from: Some(1_u64),
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(5), 900))
+					},
+					Event::PoolCommissionChangeRateUpdated {
+						pool_id: 1,
+						change_rate: CommissionChangeRate {
+							max_increase: Perbill::from_percent(1),
+							min_delay: 2
+						}
+					}
+				]
+			);
+
+			// Now try to increase commission to 10% (5% increase). This should be throttled.
+			// Then:
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(10), 900))
+				),
+				Error::<Runtime>::CommissionChangeThrottled
+			);
+
+			run_blocks(2);
+
+			// Increase commission by 1% and provide an initial payee. This should succeed and set
+			// the `throttle_from` field.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(6), 900))
+			));
+			assert_eq!(
+				BondedPool::<Runtime>::get(1).unwrap().commission,
+				Commission {
+					current: Some((Perbill::from_percent(6), 900)),
+					max: None,
+					change_rate: Some(CommissionChangeRate {
+						max_increase: Perbill::from_percent(1),
+						min_delay: 2_u64
+					}),
+					throttle_from: Some(3_u64),
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id: 1,
+					current: Some((Perbill::from_percent(6), 900))
+				},]
+			);
+
+			// Attempt to increase the commission an additional 1% (now 7%). This will fail as
+			// `throttle_from` is now the current block. At least 2 blocks need to pass before we
+			// can set commission again.
+
+			// Then:
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(7), 900))
+				),
+				Error::<Runtime>::CommissionChangeThrottled
+			);
+
+			run_blocks(2);
+
+			// Can now successfully increase the commission again, to 7%.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(7), 900)),
+			));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id: 1,
+					current: Some((Perbill::from_percent(7), 900))
+				},]
+			);
+
+			run_blocks(2);
+
+			// Now surpassed the `min_delay` threshold, but the `max_increase` threshold is
+			// still at play. An attempted commission change now to 8% (+2% increase) should fail.
+
+			// Then:
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(9), 900)),
+				),
+				Error::<Runtime>::CommissionChangeThrottled
+			);
+
+			// Now set a max commission to the current 5%. This will also update the current
+			// commission to 5%.
+
+			// When:
+			assert_ok!(Pools::set_commission_max(
+				RuntimeOrigin::signed(900),
+				1,
+				Perbill::from_percent(5)
+			));
+			assert_eq!(
+				BondedPool::<Runtime>::get(1).unwrap().commission,
+				Commission {
+					current: Some((Perbill::from_percent(5), 900)),
+					max: Some(Perbill::from_percent(5)),
+					change_rate: Some(CommissionChangeRate {
+						max_increase: Perbill::from_percent(1),
+						min_delay: 2
+					}),
+					throttle_from: Some(7)
+				}
+			);
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(5), 900))
+					},
+					Event::PoolMaxCommissionUpdated {
+						pool_id: 1,
+						max_commission: Perbill::from_percent(5)
+					}
+				]
+			);
+
+			// Run 2 blocks into the future so we are eligible to update commission again.
+			run_blocks(2);
+
+			// Now attempt again to increase the commission by 1%, to 6%. This is within the change
+			// rate allowance, but `max_commission` will now prevent us from going any higher.
+
+			// Then:
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(6), 900)),
+				),
+				Error::<Runtime>::CommissionExceedsMaximum
+			);
+		});
+	}
+
+	#[test]
+	fn set_commission_max_works_with_error_tests() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Provided pool does not exist
+			assert_noop!(
+				Pools::set_commission_max(
+					RuntimeOrigin::signed(900),
+					9999,
+					Perbill::from_percent(1)
+				),
+				Error::<Runtime>::PoolNotFound
+			);
+			// Sender does not have permission to set commission
+			assert_noop!(
+				Pools::set_commission_max(RuntimeOrigin::signed(1), 1, Perbill::from_percent(5)),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			// Cannot set max commission above GlobalMaxCommission
+			assert_noop!(
+				Pools::set_commission_max(
+					RuntimeOrigin::signed(900),
+					1,
+					Perbill::from_percent(100)
+				),
+				Error::<Runtime>::CommissionExceedsGlobalMaximum
+			);
+
+			// Set a max commission commission pool 1 to 80%
+			assert_ok!(Pools::set_commission_max(
+				RuntimeOrigin::signed(900),
+				1,
+				Perbill::from_percent(80)
+			));
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().commission.max,
+				Some(Perbill::from_percent(80))
+			);
+
+			// We attempt to increase the max commission to 90%, but increasing is
+			// disallowed due to pool's max commission.
+			assert_noop!(
+				Pools::set_commission_max(RuntimeOrigin::signed(900), 1, Perbill::from_percent(90)),
+				Error::<Runtime>::MaxCommissionRestricted
+			);
+
+			// We will now set a commission to 75% and then amend the max commission
+			// to 50%. The max commission change should decrease the current
+			// commission to 50%.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(75), 900))
+			));
+			assert_ok!(Pools::set_commission_max(
+				RuntimeOrigin::signed(900),
+				1,
+				Perbill::from_percent(50)
+			));
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().commission,
+				Commission {
+					current: Some((Perbill::from_percent(50), 900)),
+					max: Some(Perbill::from_percent(50)),
+					change_rate: None,
+					throttle_from: Some(1),
+				}
+			);
+
+			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::PoolMaxCommissionUpdated {
+						pool_id: 1,
+						max_commission: Perbill::from_percent(80)
+					},
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(75), 900))
+					},
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(50), 900))
+					},
+					Event::PoolMaxCommissionUpdated {
+						pool_id: 1,
+						max_commission: Perbill::from_percent(50)
+					}
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn set_commission_change_rate_works_with_errors() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Provided pool does not exist
+			assert_noop!(
+				Pools::set_commission_change_rate(
+					RuntimeOrigin::signed(900),
+					9999,
+					CommissionChangeRate {
+						max_increase: Perbill::from_percent(5),
+						min_delay: 1000_u64
+					}
+				),
+				Error::<Runtime>::PoolNotFound
+			);
+			// Sender does not have permission to set commission
+			assert_noop!(
+				Pools::set_commission_change_rate(
+					RuntimeOrigin::signed(1),
+					1,
+					CommissionChangeRate {
+						max_increase: Perbill::from_percent(5),
+						min_delay: 1000_u64
+					}
+				),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			// Set a commission change rate for pool 1
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(5), min_delay: 10_u64 }
+			));
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().commission.change_rate,
+				Some(CommissionChangeRate {
+					max_increase: Perbill::from_percent(5),
+					min_delay: 10_u64
+				})
+			);
+			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::PoolCommissionChangeRateUpdated {
+						pool_id: 1,
+						change_rate: CommissionChangeRate {
+							max_increase: Perbill::from_percent(5),
+							min_delay: 10
+						}
+					},
+				]
+			);
+
+			// We now try to half the min_delay - this will be disallowed. A greater delay between
+			// commission changes is seen as more restrictive.
+			assert_noop!(
+				Pools::set_commission_change_rate(
+					RuntimeOrigin::signed(900),
+					1,
+					CommissionChangeRate {
+						max_increase: Perbill::from_percent(5),
+						min_delay: 5_u64
+					}
+				),
+				Error::<Runtime>::CommissionChangeRateNotAllowed
+			);
+
+			// We now try to increase the allowed max_increase - this will fail. A smaller allowed
+			// commission change is seen as more restrictive.
+			assert_noop!(
+				Pools::set_commission_change_rate(
+					RuntimeOrigin::signed(900),
+					1,
+					CommissionChangeRate {
+						max_increase: Perbill::from_percent(10),
+						min_delay: 10_u64
+					}
+				),
+				Error::<Runtime>::CommissionChangeRateNotAllowed
+			);
+
+			// Successful more restrictive change of min_delay with the current max_increase
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(5), min_delay: 20_u64 }
+			));
+
+			// Successful more restrictive change of max_increase with the current min_delay
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(4), min_delay: 20_u64 }
+			));
+
+			// Successful more restrictive change of both max_increase and min_delay
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(3), min_delay: 30_u64 }
+			));
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PoolCommissionChangeRateUpdated {
+						pool_id: 1,
+						change_rate: CommissionChangeRate {
+							max_increase: Perbill::from_percent(5),
+							min_delay: 20
+						}
+					},
+					Event::PoolCommissionChangeRateUpdated {
+						pool_id: 1,
+						change_rate: CommissionChangeRate {
+							max_increase: Perbill::from_percent(4),
+							min_delay: 20
+						}
+					},
+					Event::PoolCommissionChangeRateUpdated {
+						pool_id: 1,
+						change_rate: CommissionChangeRate {
+							max_increase: Perbill::from_percent(3),
+							min_delay: 30
+						}
+					}
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn change_rate_does_not_apply_to_decreasing_commission() {
+		ExtBuilder::default().build_and_execute(|| {
+			// set initial commission of the pool to 10%.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(10), 900))
+			));
+
+			// Set a commission change rate for pool 1, 1% every 10 blocks
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(1), min_delay: 10_u64 }
+			));
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().commission.change_rate,
+				Some(CommissionChangeRate {
+					max_increase: Perbill::from_percent(1),
+					min_delay: 10_u64
+				})
+			);
+
+			// run `min_delay` blocks to allow a commission update.
+			run_blocks(10_u64);
+
+			// Test `max_increase`: attempt to decrease the commission by 5%. Should succeed.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(5), 900))
+			));
+
+			// Test `min_delay`: *immediately* attempt to decrease the commission by 2%. Should
+			// succeed.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(3), 900))
+			));
+
+			// Attempt to *increase* the commission by 5%. Should fail.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(8), 900))
+				),
+				Error::<Runtime>::CommissionChangeThrottled
+			);
+
+			// Sanity check: the resulting pool Commission state.
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().commission,
+				Commission {
+					current: Some((Perbill::from_percent(3), 900)),
+					max: None,
+					change_rate: Some(CommissionChangeRate {
+						max_increase: Perbill::from_percent(1),
+						min_delay: 10_u64
+					}),
+					throttle_from: Some(11),
+				}
+			);
+
+			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::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(10), 900))
+					},
+					Event::PoolCommissionChangeRateUpdated {
+						pool_id: 1,
+						change_rate: CommissionChangeRate {
+							max_increase: Perbill::from_percent(1),
+							min_delay: 10
+						}
+					},
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(5), 900))
+					},
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(3), 900))
+					}
+				]
+			);
+		});
+	}
+
+	#[test]
+	fn set_commission_max_to_zero_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// 0% max commission test.
+			// set commission max 0%.
+			assert_ok!(Pools::set_commission_max(RuntimeOrigin::signed(900), 1, Zero::zero()));
+
+			// a max commission of 0% essentially freezes the current commission, even when None.
+			// All commission update attempts will fail.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(1), 900))
+				),
+				Error::<Runtime>::CommissionExceedsMaximum
+			);
+		})
+	}
+
+	#[test]
+	fn set_commission_change_rate_zero_max_increase_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// set commission change rate to 0% per 10 blocks
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(0), min_delay: 10_u64 }
+			));
+
+			// even though there is a min delay of 10 blocks, a max increase of 0% essentially
+			// freezes the commission. All commission update attempts will fail.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(1), 900))
+				),
+				Error::<Runtime>::CommissionChangeThrottled
+			);
+		})
+	}
+
+	#[test]
+	fn set_commission_change_rate_zero_min_delay_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// set commission change rate to 1% with a 0 block `min_delay`.
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(1), min_delay: 0_u64 }
+			));
+			assert_eq!(
+				BondedPools::<Runtime>::get(1).unwrap().commission,
+				Commission {
+					current: None,
+					max: None,
+					change_rate: Some(CommissionChangeRate {
+						max_increase: Perbill::from_percent(1),
+						min_delay: 0
+					}),
+					throttle_from: Some(1)
+				}
+			);
+
+			// since there is no min delay, we should be able to immediately set the commission.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				1,
+				Some((Perbill::from_percent(1), 900))
+			));
+
+			// sanity check: increasing again to more than +1% will fail.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(3), 900))
+				),
+				Error::<Runtime>::CommissionChangeThrottled
+			);
+		})
+	}
+
+	#[test]
+	fn set_commission_change_rate_zero_value_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Check zero values play nice. 0 `min_delay` and 0% max_increase test.
+			// set commission change rate to 0% per 0 blocks.
+			assert_ok!(Pools::set_commission_change_rate(
+				RuntimeOrigin::signed(900),
+				1,
+				CommissionChangeRate { max_increase: Perbill::from_percent(0), min_delay: 0_u64 }
+			));
+
+			// even though there is no min delay, a max increase of 0% essentially freezes the
+			// commission. All commission update attempts will fail.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					1,
+					Some((Perbill::from_percent(1), 900))
+				),
+				Error::<Runtime>::CommissionChangeThrottled
+			);
+
+			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::PoolCommissionChangeRateUpdated {
+						pool_id: 1,
+						change_rate: CommissionChangeRate {
+							max_increase: Perbill::from_percent(0),
+							min_delay: 0_u64
+						}
+					}
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn do_reward_payout_with_various_commissions() {
+		ExtBuilder::default().build_and_execute(|| {
+			// turn off GlobalMaxCommission for this test.
+			GlobalMaxCommission::<Runtime>::set(None);
+			let pool_id = 1;
+
+			// top up commission payee account to existential deposit
+			let _ = Balances::deposit_creating(&2, 5);
+
+			// Set a commission pool 1 to 33%, with a payee set to `2`
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				pool_id,
+				Some((Perbill::from_percent(33), 2)),
+			));
+			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::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(33), 2))
+					},
+				]
+			);
+
+			// The pool earns 10 points
+			deposit_rewards(10);
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 7 },]
+			);
+
+			// The pool earns 17 points
+			deposit_rewards(17);
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 11 },]
+			);
+
+			// The pool earns 50 points
+			deposit_rewards(50);
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 34 },]
+			);
+
+			// The pool earns 10439 points
+			deposit_rewards(10439);
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id: 1, payout: 6994 },]
+			);
+
+			// Set the commission to 100% and ensure the following payout to the pool member will
+			// not happen.
+
+			// When:
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				pool_id,
+				Some((Perbill::from_percent(100), 2)),
+			));
+
+			// Given:
+			deposit_rewards(200);
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id: 1,
+					current: Some((Perbill::from_percent(100), 2))
+				},]
+			);
+		})
+	}
+
+	#[test]
+	fn commission_accumulates_on_multiple_rewards() {
+		ExtBuilder::default().build_and_execute(|| {
+			let pool_id = 1;
+
+			// Given:
+
+			// Set initial commission of pool 1 to 10%.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				pool_id,
+				Some((Perbill::from_percent(10), 2)),
+			));
+			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::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(10), 2))
+					},
+				]
+			);
+
+			// When:
+
+			// The pool earns 100 points
+			deposit_rewards(100);
+
+			// Change commission to 20%
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				pool_id,
+				Some((Perbill::from_percent(20), 2)),
+			));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PoolCommissionUpdated {
+					pool_id: 1,
+					current: Some((Perbill::from_percent(20), 2))
+				},]
+			);
+
+			// The pool earns 100 points
+			deposit_rewards(100);
+
+			// Then:
+
+			// Claim payout:
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Claim commission:
+			assert_ok!(Pools::claim_commission(RuntimeOrigin::signed(900), pool_id));
+
+			// Then:
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 90 + 80 },
+					Event::PoolCommissionClaimed { pool_id: 1, commission: 30 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn last_recorded_total_payouts_needs_commission() {
+		ExtBuilder::default().build_and_execute(|| {
+			let pool_id = 1;
+
+			// Given:
+
+			// Set initial commission of pool 1 to 10%.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				pool_id,
+				Some((Perbill::from_percent(10), 2)),
+			));
+			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::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(10), 2))
+					},
+				]
+			);
+
+			// When:
+
+			// The pool earns 100 points
+			deposit_rewards(100);
+
+			// Claim payout:
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+
+			// Claim commission:
+			assert_ok!(Pools::claim_commission(RuntimeOrigin::signed(900), pool_id));
+
+			// Then:
+
+			assert_eq!(
+				RewardPools::<Runtime>::get(1).unwrap().last_recorded_total_payouts,
+				90 + 10
+			);
+
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PaidOut { member: 10, pool_id: 1, payout: 90 },
+					Event::PoolCommissionClaimed { pool_id: 1, commission: 10 }
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn do_reward_payout_with_100_percent_commission() {
+		ExtBuilder::default().build_and_execute(|| {
+			// turn off GlobalMaxCommission for this test.
+			GlobalMaxCommission::<Runtime>::set(None);
+
+			let (mut member, bonded_pool, mut reward_pool) =
+				Pools::get_member_with_pools(&10).unwrap();
+
+			// top up commission payee account to existential deposit
+			let _ = Balances::deposit_creating(&2, 5);
+
+			// Set a commission pool 1 to 100%, with a payee set to `2`
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				bonded_pool.id,
+				Some((Perbill::from_percent(100), 2)),
+			));
+
+			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::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(100), 2))
+					}
+				]
+			);
+
+			// The pool earns 10 points
+			deposit_rewards(10);
+
+			// execute the payout
+			assert_ok!(Pools::do_reward_payout(
+				&10,
+				&mut member,
+				&mut BondedPool::<Runtime>::get(1).unwrap(),
+				&mut reward_pool
+			));
+		})
+	}
+
+	#[test]
+	fn global_max_caps_max_commission_payout() {
+		ExtBuilder::default().build_and_execute(|| {
+			// Note: GlobalMaxCommission is set at 90%.
+
+			let (mut member, bonded_pool, mut reward_pool) =
+				Pools::get_member_with_pools(&10).unwrap();
+
+			// top up the commission payee account to existential deposit
+			let _ = Balances::deposit_creating(&2, 5);
+
+			// Set a commission pool 1 to 100% fails.
+			assert_noop!(
+				Pools::set_commission(
+					RuntimeOrigin::signed(900),
+					bonded_pool.id,
+					Some((Perbill::from_percent(100), 2)),
+				),
+				Error::<Runtime>::CommissionExceedsGlobalMaximum
+			);
+			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 },
+				]
+			);
+
+			// Set pool commission to 90% and then set global max commission to 80%.
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				bonded_pool.id,
+				Some((Perbill::from_percent(90), 2)),
+			));
+			GlobalMaxCommission::<Runtime>::set(Some(Perbill::from_percent(80)));
+
+			// The pool earns 10 points
+			deposit_rewards(10);
+
+			// execute the payout
+			assert_ok!(Pools::do_reward_payout(
+				&10,
+				&mut member,
+				&mut BondedPool::<Runtime>::get(1).unwrap(),
+				&mut reward_pool
+			));
+
+			// Confirm the commission was only 8 points out of 10 points, and the payout was 2 out
+			// of 10 points, reflecting the 80% global max commission.
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::PoolCommissionUpdated {
+						pool_id: 1,
+						current: Some((Perbill::from_percent(90), 2))
+					},
+					Event::PaidOut { member: 10, pool_id: 1, payout: 2 },
+				]
+			);
+		})
+	}
+
+	#[test]
+	fn claim_commission_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let pool_id = 1;
+
+			let _ = Balances::deposit_creating(&900, 5);
+			assert_ok!(Pools::set_commission(
+				RuntimeOrigin::signed(900),
+				pool_id,
+				Some((Perbill::from_percent(50), 900))
+			));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![
+					Event::Created { depositor: 10, pool_id },
+					Event::Bonded { member: 10, pool_id, bonded: 10, joined: true },
+					Event::PoolCommissionUpdated {
+						pool_id,
+						current: Some((Perbill::from_percent(50), 900))
+					},
+				]
+			);
+
+			// Pool earns 80 points, payout is triggered.
+			deposit_rewards(80);
+			assert_eq!(
+				PoolMembers::<Runtime>::get(10).unwrap(),
+				PoolMember::<Runtime> { pool_id, points: 10, ..Default::default() }
+			);
+
+			assert_ok!(Pools::claim_payout(RuntimeOrigin::signed(10)));
+			assert_eq!(
+				pool_events_since_last_call(),
+				vec![Event::PaidOut { member: 10, pool_id, payout: 40 }]
+			);
+
+			// Given:
+			assert_eq!(RewardPool::<Runtime>::current_balance(pool_id), 40);
+
+			// Pool does not exist
+			assert_noop!(
+				Pools::claim_commission(RuntimeOrigin::signed(900), 9999,),
+				Error::<Runtime>::PoolNotFound
+			);
+
+			// Does not have permission.
+			assert_noop!(
+				Pools::claim_commission(RuntimeOrigin::signed(10), pool_id,),
+				Error::<Runtime>::DoesNotHavePermission
+			);
+
+			// When:
+			assert_ok!(Pools::claim_commission(RuntimeOrigin::signed(900), pool_id));
+
+			// Then:
+			assert_eq!(RewardPool::<Runtime>::current_balance(pool_id), 0);
+
+			// No more pending commission.
+			assert_noop!(
+				Pools::claim_commission(RuntimeOrigin::signed(900), pool_id,),
+				Error::<Runtime>::NoPendingCommission
+			);
+		})
+	}
+}
diff --git a/substrate/frame/nomination-pools/src/weights.rs b/substrate/frame/nomination-pools/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb33c9adbbf9657a7ab71f9f33632d6e41499d4d
--- /dev/null
+++ b/substrate/frame/nomination-pools/src/weights.rs
@@ -0,0 +1,1140 @@
+// 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.
+
+//! Autogenerated weights for pallet_nomination_pools
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_nomination_pools
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/nomination-pools/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_nomination_pools.
+pub trait WeightInfo {
+	fn join() -> Weight;
+	fn bond_extra_transfer() -> Weight;
+	fn bond_extra_other() -> Weight;
+	fn claim_payout() -> Weight;
+	fn unbond() -> Weight;
+	fn pool_withdraw_unbonded(s: u32, ) -> Weight;
+	fn withdraw_unbonded_update(s: u32, ) -> Weight;
+	fn withdraw_unbonded_kill(s: u32, ) -> Weight;
+	fn create() -> Weight;
+	fn nominate(n: u32, ) -> Weight;
+	fn set_state() -> Weight;
+	fn set_metadata(n: u32, ) -> Weight;
+	fn set_configs() -> Weight;
+	fn update_roles() -> Weight;
+	fn chill() -> Weight;
+	fn set_commission() -> Weight;
+	fn set_commission_max() -> Weight;
+	fn set_commission_change_rate() -> Weight;
+	fn set_claim_permission() -> Weight;
+	fn claim_commission() -> Weight;
+}
+
+/// Weights for pallet_nomination_pools using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: NominationPools MinJoinBond (r:1 w:0)
+	/// Proof: NominationPools MinJoinBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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: NominationPools RewardPools (r:1 w:1)
+	/// 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)
+	/// 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)
+	/// Storage: NominationPools MaxPoolMembers (r:1 w:0)
+	/// 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn join() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3300`
+		//  Estimated: `8877`
+		// Minimum execution time: 200_966_000 picoseconds.
+		Weight::from_parts(208_322_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(19_u64))
+			.saturating_add(T::DbWeight::get().writes(12_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn bond_extra_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3310`
+		//  Estimated: `8877`
+		// Minimum execution time: 197_865_000 picoseconds.
+		Weight::from_parts(203_085_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(16_u64))
+			.saturating_add(T::DbWeight::get().writes(12_u64))
+	}
+	/// Storage: NominationPools ClaimPermissions (r:1 w:0)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn bond_extra_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3375`
+		//  Estimated: `8877`
+		// Minimum execution time: 235_496_000 picoseconds.
+		Weight::from_parts(242_104_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(17_u64))
+			.saturating_add(T::DbWeight::get().writes(13_u64))
+	}
+	/// Storage: NominationPools ClaimPermissions (r:1 w:0)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 GlobalMaxCommission (r:1 w:0)
+	/// Proof: NominationPools GlobalMaxCommission (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 claim_payout() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1171`
+		//  Estimated: `3702`
+		// Minimum execution time: 81_813_000 picoseconds.
+		Weight::from_parts(83_277_000, 3702)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: NominationPools RewardPools (r:1 w:1)
+	/// Proof: NominationPools RewardPools (max_values: None, max_size: Some(92), added: 2567, 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: 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)
+	/// 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)
+	/// Storage: Staking Nominators (r:1 w:0)
+	/// 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: NominationPools SubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools SubPoolsStorage (max_values: None, max_size: Some(24382), added: 26857, mode: MaxEncodedLen)
+	/// Storage: NominationPools CounterForSubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools CounterForSubPoolsStorage (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn unbond() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3586`
+		//  Estimated: `27847`
+		// Minimum execution time: 183_935_000 picoseconds.
+		Weight::from_parts(186_920_000, 27847)
+			.saturating_add(T::DbWeight::get().reads(20_u64))
+			.saturating_add(T::DbWeight::get().writes(13_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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: 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn pool_withdraw_unbonded(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1687`
+		//  Estimated: `4764`
+		// Minimum execution time: 64_962_000 picoseconds.
+		Weight::from_parts(67_936_216, 4764)
+			// Standard Error: 1_780
+			.saturating_add(Weight::from_parts(36_110, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, 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: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: NominationPools SubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools SubPoolsStorage (max_values: None, max_size: Some(24382), added: 26857, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_update(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2115`
+		//  Estimated: `27847`
+		// Minimum execution time: 136_073_000 picoseconds.
+		Weight::from_parts(141_448_439, 27847)
+			// Standard Error: 2_472
+			.saturating_add(Weight::from_parts(75_893, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(10_u64))
+			.saturating_add(T::DbWeight::get().writes(8_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, 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: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: NominationPools SubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools SubPoolsStorage (max_values: None, max_size: Some(24382), added: 26857, 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 Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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: 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(49), added: 2524, 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)
+	/// Proof: NominationPools RewardPools (max_values: None, max_size: Some(92), added: 2567, mode: MaxEncodedLen)
+	/// Storage: NominationPools CounterForRewardPools (r:1 w:1)
+	/// 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: 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)
+	/// Proof: NominationPools CounterForBondedPools (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)
+	/// Storage: NominationPools ClaimPermissions (r:0 w:1)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_kill(_s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2470`
+		//  Estimated: `27847`
+		// Minimum execution time: 230_871_000 picoseconds.
+		Weight::from_parts(239_533_976, 27847)
+			.saturating_add(T::DbWeight::get().reads(21_u64))
+			.saturating_add(T::DbWeight::get().writes(18_u64))
+	}
+	/// Storage: NominationPools LastPoolId (r:1 w:1)
+	/// Proof: NominationPools LastPoolId (max_values: Some(1), max_size: Some(4), added: 499, 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: NominationPools MaxPools (r:1 w:0)
+	/// Proof: NominationPools MaxPools (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools CounterForBondedPools (r:1 w:1)
+	/// Proof: NominationPools CounterForBondedPools (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembersPerPool (r:1 w:0)
+	/// Proof: NominationPools MaxPoolMembersPerPool (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembers (r:1 w:0)
+	/// 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: Staking Ledger (r:1 w:1)
+	/// 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(49), added: 2524, 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)
+	/// Proof: NominationPools CounterForRewardPools (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 BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1289`
+		//  Estimated: `6196`
+		// Minimum execution time: 194_272_000 picoseconds.
+		Weight::from_parts(197_933_000, 6196)
+			.saturating_add(T::DbWeight::get().reads(22_u64))
+			.saturating_add(T::DbWeight::get().writes(15_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:17 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, 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: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 16]`.
+	fn nominate(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1849`
+		//  Estimated: `4556 + n * (2520 ±0)`
+		// Minimum execution time: 70_256_000 picoseconds.
+		Weight::from_parts(71_045_351, 4556)
+			// Standard Error: 9_898
+			.saturating_add(Weight::from_parts(1_592_597, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(12_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(n.into()))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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)
+	fn set_state() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1438`
+		//  Estimated: `4556`
+		// Minimum execution time: 36_233_000 picoseconds.
+		Weight::from_parts(37_114_000, 4556)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 CounterForMetadata (r:1 w:1)
+	/// Proof: NominationPools CounterForMetadata (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 256]`.
+	fn set_metadata(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `531`
+		//  Estimated: `3735`
+		// Minimum execution time: 14_494_000 picoseconds.
+		Weight::from_parts(15_445_658, 3735)
+			// Standard Error: 211
+			.saturating_add(Weight::from_parts(1_523, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: NominationPools MinJoinBond (r:0 w:1)
+	/// Proof: NominationPools MinJoinBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembers (r:0 w:1)
+	/// Proof: NominationPools MaxPoolMembers (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembersPerPool (r:0 w:1)
+	/// Proof: NominationPools MaxPoolMembersPerPool (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MinCreateBond (r:0 w:1)
+	/// Proof: NominationPools MinCreateBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: NominationPools GlobalMaxCommission (r:0 w:1)
+	/// Proof: NominationPools GlobalMaxCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPools (r:0 w:1)
+	/// Proof: NominationPools MaxPools (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn set_configs() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_776_000 picoseconds.
+		Weight::from_parts(7_033_000, 0)
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	fn update_roles() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `531`
+		//  Estimated: `3685`
+		// Minimum execution time: 19_586_000 picoseconds.
+		Weight::from_parts(20_287_000, 3685)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn chill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2012`
+		//  Estimated: `4556`
+		// Minimum execution time: 68_086_000 picoseconds.
+		Weight::from_parts(70_784_000, 4556)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 GlobalMaxCommission (r:1 w:0)
+	/// Proof: NominationPools GlobalMaxCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn set_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `770`
+		//  Estimated: `3685`
+		// Minimum execution time: 33_353_000 picoseconds.
+		Weight::from_parts(34_519_000, 3685)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	fn set_commission_max() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `571`
+		//  Estimated: `3685`
+		// Minimum execution time: 19_020_000 picoseconds.
+		Weight::from_parts(19_630_000, 3685)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	fn set_commission_change_rate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `531`
+		//  Estimated: `3685`
+		// Minimum execution time: 19_693_000 picoseconds.
+		Weight::from_parts(20_114_000, 3685)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:0)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools ClaimPermissions (r:1 w:1)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	fn set_claim_permission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `542`
+		//  Estimated: `3702`
+		// Minimum execution time: 14_810_000 picoseconds.
+		Weight::from_parts(15_526_000, 3702)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 GlobalMaxCommission (r:1 w:0)
+	/// Proof: NominationPools GlobalMaxCommission (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 claim_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `968`
+		//  Estimated: `3685`
+		// Minimum execution time: 66_400_000 picoseconds.
+		Weight::from_parts(67_707_000, 3685)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: NominationPools MinJoinBond (r:1 w:0)
+	/// Proof: NominationPools MinJoinBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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: NominationPools RewardPools (r:1 w:1)
+	/// 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)
+	/// 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)
+	/// Storage: NominationPools MaxPoolMembers (r:1 w:0)
+	/// 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn join() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3300`
+		//  Estimated: `8877`
+		// Minimum execution time: 200_966_000 picoseconds.
+		Weight::from_parts(208_322_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(19_u64))
+			.saturating_add(RocksDbWeight::get().writes(12_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn bond_extra_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3310`
+		//  Estimated: `8877`
+		// Minimum execution time: 197_865_000 picoseconds.
+		Weight::from_parts(203_085_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(16_u64))
+			.saturating_add(RocksDbWeight::get().writes(12_u64))
+	}
+	/// Storage: NominationPools ClaimPermissions (r:1 w:0)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn bond_extra_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3375`
+		//  Estimated: `8877`
+		// Minimum execution time: 235_496_000 picoseconds.
+		Weight::from_parts(242_104_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(17_u64))
+			.saturating_add(RocksDbWeight::get().writes(13_u64))
+	}
+	/// Storage: NominationPools ClaimPermissions (r:1 w:0)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 GlobalMaxCommission (r:1 w:0)
+	/// Proof: NominationPools GlobalMaxCommission (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 claim_payout() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1171`
+		//  Estimated: `3702`
+		// Minimum execution time: 81_813_000 picoseconds.
+		Weight::from_parts(83_277_000, 3702)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: NominationPools RewardPools (r:1 w:1)
+	/// Proof: NominationPools RewardPools (max_values: None, max_size: Some(92), added: 2567, 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: 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)
+	/// 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)
+	/// Storage: Staking Nominators (r:1 w:0)
+	/// 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: NominationPools SubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools SubPoolsStorage (max_values: None, max_size: Some(24382), added: 26857, mode: MaxEncodedLen)
+	/// Storage: NominationPools CounterForSubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools CounterForSubPoolsStorage (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn unbond() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3586`
+		//  Estimated: `27847`
+		// Minimum execution time: 183_935_000 picoseconds.
+		Weight::from_parts(186_920_000, 27847)
+			.saturating_add(RocksDbWeight::get().reads(20_u64))
+			.saturating_add(RocksDbWeight::get().writes(13_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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: 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn pool_withdraw_unbonded(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1687`
+		//  Estimated: `4764`
+		// Minimum execution time: 64_962_000 picoseconds.
+		Weight::from_parts(67_936_216, 4764)
+			// Standard Error: 1_780
+			.saturating_add(Weight::from_parts(36_110, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, 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: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: NominationPools SubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools SubPoolsStorage (max_values: None, max_size: Some(24382), added: 26857, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_update(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2115`
+		//  Estimated: `27847`
+		// Minimum execution time: 136_073_000 picoseconds.
+		Weight::from_parts(141_448_439, 27847)
+			// Standard Error: 2_472
+			.saturating_add(Weight::from_parts(75_893, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(10_u64))
+			.saturating_add(RocksDbWeight::get().writes(8_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, 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: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: NominationPools SubPoolsStorage (r:1 w:1)
+	/// Proof: NominationPools SubPoolsStorage (max_values: None, max_size: Some(24382), added: 26857, 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 Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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: 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(49), added: 2524, 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)
+	/// Proof: NominationPools RewardPools (max_values: None, max_size: Some(92), added: 2567, mode: MaxEncodedLen)
+	/// Storage: NominationPools CounterForRewardPools (r:1 w:1)
+	/// 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: 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)
+	/// Proof: NominationPools CounterForBondedPools (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)
+	/// Storage: NominationPools ClaimPermissions (r:0 w:1)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_kill(_s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2470`
+		//  Estimated: `27847`
+		// Minimum execution time: 230_871_000 picoseconds.
+		Weight::from_parts(239_533_976, 27847)
+			.saturating_add(RocksDbWeight::get().reads(21_u64))
+			.saturating_add(RocksDbWeight::get().writes(18_u64))
+	}
+	/// Storage: NominationPools LastPoolId (r:1 w:1)
+	/// Proof: NominationPools LastPoolId (max_values: Some(1), max_size: Some(4), added: 499, 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: NominationPools MaxPools (r:1 w:0)
+	/// Proof: NominationPools MaxPools (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools CounterForBondedPools (r:1 w:1)
+	/// Proof: NominationPools CounterForBondedPools (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools PoolMembers (r:1 w:1)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembersPerPool (r:1 w:0)
+	/// Proof: NominationPools MaxPoolMembersPerPool (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembers (r:1 w:0)
+	/// 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: Staking Ledger (r:1 w:1)
+	/// 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(49), added: 2524, 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)
+	/// Proof: NominationPools CounterForRewardPools (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 BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1289`
+		//  Estimated: `6196`
+		// Minimum execution time: 194_272_000 picoseconds.
+		Weight::from_parts(197_933_000, 6196)
+			.saturating_add(RocksDbWeight::get().reads(22_u64))
+			.saturating_add(RocksDbWeight::get().writes(15_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:17 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, 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: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 16]`.
+	fn nominate(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1849`
+		//  Estimated: `4556 + n * (2520 ±0)`
+		// Minimum execution time: 70_256_000 picoseconds.
+		Weight::from_parts(71_045_351, 4556)
+			// Standard Error: 9_898
+			.saturating_add(Weight::from_parts(1_592_597, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(12_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(n.into()))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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)
+	fn set_state() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1438`
+		//  Estimated: `4556`
+		// Minimum execution time: 36_233_000 picoseconds.
+		Weight::from_parts(37_114_000, 4556)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 CounterForMetadata (r:1 w:1)
+	/// Proof: NominationPools CounterForMetadata (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 256]`.
+	fn set_metadata(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `531`
+		//  Estimated: `3735`
+		// Minimum execution time: 14_494_000 picoseconds.
+		Weight::from_parts(15_445_658, 3735)
+			// Standard Error: 211
+			.saturating_add(Weight::from_parts(1_523, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: NominationPools MinJoinBond (r:0 w:1)
+	/// Proof: NominationPools MinJoinBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembers (r:0 w:1)
+	/// Proof: NominationPools MaxPoolMembers (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPoolMembersPerPool (r:0 w:1)
+	/// Proof: NominationPools MaxPoolMembersPerPool (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MinCreateBond (r:0 w:1)
+	/// Proof: NominationPools MinCreateBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: NominationPools GlobalMaxCommission (r:0 w:1)
+	/// Proof: NominationPools GlobalMaxCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: NominationPools MaxPools (r:0 w:1)
+	/// Proof: NominationPools MaxPools (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn set_configs() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_776_000 picoseconds.
+		Weight::from_parts(7_033_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	fn update_roles() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `531`
+		//  Estimated: `3685`
+		// Minimum execution time: 19_586_000 picoseconds.
+		Weight::from_parts(20_287_000, 3685)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn chill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2012`
+		//  Estimated: `4556`
+		// Minimum execution time: 68_086_000 picoseconds.
+		Weight::from_parts(70_784_000, 4556)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 GlobalMaxCommission (r:1 w:0)
+	/// Proof: NominationPools GlobalMaxCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn set_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `770`
+		//  Estimated: `3685`
+		// Minimum execution time: 33_353_000 picoseconds.
+		Weight::from_parts(34_519_000, 3685)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	fn set_commission_max() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `571`
+		//  Estimated: `3685`
+		// Minimum execution time: 19_020_000 picoseconds.
+		Weight::from_parts(19_630_000, 3685)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:1)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, mode: MaxEncodedLen)
+	fn set_commission_change_rate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `531`
+		//  Estimated: `3685`
+		// Minimum execution time: 19_693_000 picoseconds.
+		Weight::from_parts(20_114_000, 3685)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools PoolMembers (r:1 w:0)
+	/// Proof: NominationPools PoolMembers (max_values: None, max_size: Some(237), added: 2712, mode: MaxEncodedLen)
+	/// Storage: NominationPools ClaimPermissions (r:1 w:1)
+	/// Proof: NominationPools ClaimPermissions (max_values: None, max_size: Some(41), added: 2516, mode: MaxEncodedLen)
+	fn set_claim_permission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `542`
+		//  Estimated: `3702`
+		// Minimum execution time: 14_810_000 picoseconds.
+		Weight::from_parts(15_526_000, 3702)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: NominationPools BondedPools (r:1 w:0)
+	/// Proof: NominationPools BondedPools (max_values: None, max_size: Some(220), added: 2695, 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 GlobalMaxCommission (r:1 w:0)
+	/// Proof: NominationPools GlobalMaxCommission (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 claim_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `968`
+		//  Estimated: `3685`
+		// Minimum execution time: 66_400_000 picoseconds.
+		Weight::from_parts(67_707_000, 3685)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/nomination-pools/test-staking/Cargo.toml b/substrate/frame/nomination-pools/test-staking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8ff7895a328dca89b0b1728ca46aa3d70fa651a6
--- /dev/null
+++ b/substrate/frame/nomination-pools/test-staking/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "pallet-nomination-pools-test-staking"
+version = "1.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME nomination pools pallet tests with the staking pallet"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dev-dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+scale-info = { version = "2.0.1", features = ["derive"] }
+
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+sp-std = { version = "8.0.0", path = "../../../primitives/std" }
+sp-staking = { version = "4.0.0-dev", path = "../../../primitives/staking" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+
+frame-system = { version = "4.0.0-dev", path = "../../system" }
+frame-support = { version = "4.0.0-dev", path = "../../support" }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../../election-provider-support" }
+
+pallet-timestamp = { version = "4.0.0-dev", path = "../../timestamp" }
+pallet-balances = { version = "4.0.0-dev", path = "../../balances" }
+pallet-staking = { version = "4.0.0-dev", path = "../../staking" }
+pallet-bags-list = { version = "4.0.0-dev", path = "../../bags-list" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../../staking/reward-curve" }
+pallet-nomination-pools = { version = "1.0.0-dev", path = ".." }
+
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+log = { version = "0.4.0" }
diff --git a/substrate/frame/nomination-pools/test-staking/src/lib.rs b/substrate/frame/nomination-pools/test-staking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9108da510a3a5339999046e772fecaa30cd11baa
--- /dev/null
+++ b/substrate/frame/nomination-pools/test-staking/src/lib.rs
@@ -0,0 +1,693 @@
+// 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::Currency};
+use mock::*;
+use pallet_nomination_pools::{
+	BondedPools, Error as PoolsError, Event as PoolsEvent, LastPoolId, PoolMember, PoolMembers,
+	PoolState,
+};
+use pallet_staking::{CurrentEra, Event as StakingEvent, Payee, RewardDestination};
+use sp_runtime::{bounded_btree_map, traits::Zero};
+
+#[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_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), 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!(
+			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!(
+			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);
+		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![
+				// 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 }
+			]
+		);
+	});
+}
+
+#[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 }
+			]
+		);
+	});
+}
diff --git a/substrate/frame/nomination-pools/test-staking/src/mock.rs b/substrate/frame/nomination-pools/test-staking/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..02c253e62c018914687467b3a55d2e317f6bf6d7
--- /dev/null
+++ b/substrate/frame/nomination-pools/test-staking/src/mock.rs
@@ -0,0 +1,269 @@
+// 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,
+	pallet_prelude::*,
+	parameter_types,
+	traits::{ConstU64, ConstU8},
+	PalletId,
+};
+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;
+
+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 {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	pub static ExistentialDeposit: Balance = 5;
+}
+
+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 = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+
+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;
+}
+
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = ();
+	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 HistoryDepth = ConstU32<84>;
+	type EventListeners = Pools;
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+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");
+}
+
+impl pallet_nomination_pools::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type RewardCounter = FixedU128;
+	type BalanceToU256 = BalanceToU256;
+	type U256ToBalance = U256ToBalance;
+	type Staking = Staking;
+	type PostUnbondingPoolsWindow = PostUnbondingPoolsWindow;
+	type MaxMetadataLen = ConstU32<256>;
+	type MaxUnbonding = ConstU32<8>;
+	type MaxPointsToBalance = ConstU8<10>;
+	type PalletId = PoolsPalletId;
+}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Event<T>},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
+		VoterList: pallet_bags_list::<Instance1>::{Pallet, Call, Storage, Event<T>},
+		Pools: pallet_nomination_pools::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+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,
+		));
+	});
+
+	ext
+}
+
+parameter_types! {
+	static ObservedEventsPools: usize = 0;
+	static ObservedEventsStaking: usize = 0;
+	static ObservedEventsBalances: 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()
+}
diff --git a/substrate/frame/offences/Cargo.toml b/substrate/frame/offences/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fb92f102940c2188c1b2a20709ceb404b63743d0
--- /dev/null
+++ b/substrate/frame/offences/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-offences"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME offences pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../balances" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/offences/README.md b/substrate/frame/offences/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..454c7effaf36cc599516feb5d047606415ee68d5
--- /dev/null
+++ b/substrate/frame/offences/README.md
@@ -0,0 +1,5 @@
+# Offences Module
+
+Tracks reported offences
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/offences/benchmarking/Cargo.toml b/substrate/frame/offences/benchmarking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..17309478d62ec79a5101209132f45e2c0276bec3
--- /dev/null
+++ b/substrate/frame/offences/benchmarking/Cargo.toml
@@ -0,0 +1,79 @@
+[package]
+name = "pallet-offences-benchmarking"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME offences pallet benchmarking"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.0.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../benchmarking" }
+frame-election-provider-support = { version = "4.0.0-dev", default-features = false, path = "../../election-provider-support" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+pallet-babe = { version = "4.0.0-dev", default-features = false, path = "../../babe" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../balances" }
+pallet-grandpa = { version = "4.0.0-dev", default-features = false, path = "../../grandpa" }
+pallet-im-online = { version = "4.0.0-dev", default-features = false, path = "../../im-online" }
+pallet-offences = { version = "4.0.0-dev", default-features = false, path = "../../offences" }
+pallet-session = { version = "4.0.0-dev", default-features = false, path = "../../session" }
+pallet-staking = { version = "4.0.0-dev", default-features = false, path = "../../staking" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/staking" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../../staking/reward-curve" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../../timestamp" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-babe/std",
+	"pallet-balances/std",
+	"pallet-grandpa/std",
+	"pallet-im-online/std",
+	"pallet-offences/std",
+	"pallet-session/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-babe/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-grandpa/runtime-benchmarks",
+	"pallet-im-online/runtime-benchmarks",
+	"pallet-offences/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
diff --git a/substrate/frame/offences/benchmarking/README.md b/substrate/frame/offences/benchmarking/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cbfe91d73a6a7cc5118f4e56a806f4c766c426d1
--- /dev/null
+++ b/substrate/frame/offences/benchmarking/README.md
@@ -0,0 +1,3 @@
+Offences pallet benchmarking.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/offences/benchmarking/src/lib.rs b/substrate/frame/offences/benchmarking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c190927b84bf10d6456a66c4a5d6df4a791d0525
--- /dev/null
+++ b/substrate/frame/offences/benchmarking/src/lib.rs
@@ -0,0 +1,476 @@
+// 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.
+
+//! Offences pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod mock;
+
+use sp_std::{prelude::*, vec};
+
+use frame_benchmarking::v1::{account, benchmarks};
+use frame_support::traits::{Currency, Get, ValidatorSet, ValidatorSetWithIdentification};
+use frame_system::{Config as SystemConfig, Pallet as System, RawOrigin};
+
+#[cfg(test)]
+use sp_runtime::traits::UniqueSaturatedInto;
+use sp_runtime::{
+	traits::{Convert, Saturating, StaticLookup},
+	Perbill,
+};
+use sp_staking::offence::{Offence, ReportOffence};
+
+use pallet_babe::EquivocationOffence as BabeEquivocationOffence;
+use pallet_balances::Config as BalancesConfig;
+use pallet_grandpa::{
+	EquivocationOffence as GrandpaEquivocationOffence, TimeSlot as GrandpaTimeSlot,
+};
+use pallet_im_online::{Config as ImOnlineConfig, Pallet as ImOnline, UnresponsivenessOffence};
+use pallet_offences::{Config as OffencesConfig, Pallet as Offences};
+use pallet_session::{
+	historical::{Config as HistoricalConfig, IdentificationTuple},
+	Config as SessionConfig, SessionManager,
+};
+#[cfg(test)]
+use pallet_staking::Event as StakingEvent;
+use pallet_staking::{
+	Config as StakingConfig, Exposure, IndividualExposure, MaxNominationsOf, Pallet as Staking,
+	RewardDestination, ValidatorPrefs,
+};
+
+const SEED: u32 = 0;
+
+const MAX_REPORTERS: u32 = 100;
+const MAX_OFFENDERS: u32 = 100;
+const MAX_NOMINATORS: u32 = 100;
+
+pub struct Pallet<T: Config>(Offences<T>);
+
+pub trait Config:
+	SessionConfig
+	+ StakingConfig
+	+ OffencesConfig
+	+ ImOnlineConfig
+	+ HistoricalConfig
+	+ BalancesConfig
+	+ IdTupleConvert<Self>
+{
+}
+
+/// A helper trait to make sure we can convert `IdentificationTuple` coming from historical
+/// and the one required by offences.
+pub trait IdTupleConvert<T: HistoricalConfig + OffencesConfig> {
+	/// Convert identification tuple from `historical` trait to the one expected by `offences`.
+	fn convert(id: IdentificationTuple<T>) -> <T as OffencesConfig>::IdentificationTuple;
+}
+
+impl<T: HistoricalConfig + OffencesConfig> IdTupleConvert<T> for T
+where
+	<T as OffencesConfig>::IdentificationTuple: From<IdentificationTuple<T>>,
+{
+	fn convert(id: IdentificationTuple<T>) -> <T as OffencesConfig>::IdentificationTuple {
+		id.into()
+	}
+}
+
+type LookupSourceOf<T> = <<T as SystemConfig>::Lookup as StaticLookup>::Source;
+type BalanceOf<T> =
+	<<T as StakingConfig>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance;
+
+struct Offender<T: Config> {
+	pub controller: T::AccountId,
+	#[allow(dead_code)]
+	pub stash: T::AccountId,
+	#[allow(dead_code)]
+	pub nominator_stashes: Vec<T::AccountId>,
+}
+
+fn bond_amount<T: Config>() -> BalanceOf<T> {
+	T::Currency::minimum_balance().saturating_mul(10_000u32.into())
+}
+
+fn create_offender<T: Config>(n: u32, nominators: u32) -> Result<Offender<T>, &'static str> {
+	let stash: T::AccountId = account("stash", n, SEED);
+	let stash_lookup: LookupSourceOf<T> = T::Lookup::unlookup(stash.clone());
+	let reward_destination = RewardDestination::Staked;
+	let amount = bond_amount::<T>();
+	// add twice as much balance to prevent the account from being killed.
+	let free_amount = amount.saturating_mul(2u32.into());
+	T::Currency::make_free_balance_be(&stash, free_amount);
+	Staking::<T>::bond(
+		RawOrigin::Signed(stash.clone()).into(),
+		amount,
+		reward_destination.clone(),
+	)?;
+
+	let validator_prefs =
+		ValidatorPrefs { commission: Perbill::from_percent(50), ..Default::default() };
+	Staking::<T>::validate(RawOrigin::Signed(stash.clone()).into(), validator_prefs)?;
+
+	let mut individual_exposures = vec![];
+	let mut nominator_stashes = vec![];
+	// Create n nominators
+	for i in 0..nominators {
+		let nominator_stash: T::AccountId =
+			account("nominator stash", n * MAX_NOMINATORS + i, SEED);
+		T::Currency::make_free_balance_be(&nominator_stash, free_amount);
+
+		Staking::<T>::bond(
+			RawOrigin::Signed(nominator_stash.clone()).into(),
+			amount,
+			reward_destination.clone(),
+		)?;
+
+		let selected_validators: Vec<LookupSourceOf<T>> = vec![stash_lookup.clone()];
+		Staking::<T>::nominate(
+			RawOrigin::Signed(nominator_stash.clone()).into(),
+			selected_validators,
+		)?;
+
+		individual_exposures
+			.push(IndividualExposure { who: nominator_stash.clone(), value: amount });
+		nominator_stashes.push(nominator_stash.clone());
+	}
+
+	let exposure = Exposure { total: amount * n.into(), own: amount, others: individual_exposures };
+	let current_era = 0u32;
+	Staking::<T>::add_era_stakers(current_era, stash.clone(), exposure);
+
+	Ok(Offender { controller: stash.clone(), stash, nominator_stashes })
+}
+
+fn make_offenders<T: Config>(
+	num_offenders: u32,
+	num_nominators: u32,
+) -> Result<(Vec<IdentificationTuple<T>>, Vec<Offender<T>>), &'static str> {
+	Staking::<T>::new_session(0);
+
+	let mut offenders = vec![];
+	for i in 0..num_offenders {
+		let offender = create_offender::<T>(i + 1, num_nominators)?;
+		offenders.push(offender);
+	}
+
+	Staking::<T>::start_session(0);
+
+	let id_tuples = offenders
+		.iter()
+		.map(|offender| {
+			<T as SessionConfig>::ValidatorIdOf::convert(offender.controller.clone())
+				.expect("failed to get validator id from account id")
+		})
+		.map(|validator_id| {
+			<T as HistoricalConfig>::FullIdentificationOf::convert(validator_id.clone())
+				.map(|full_id| (validator_id, full_id))
+				.expect("failed to convert validator id to full identification")
+		})
+		.collect::<Vec<IdentificationTuple<T>>>();
+	Ok((id_tuples, offenders))
+}
+
+fn make_offenders_im_online<T: Config>(
+	num_offenders: u32,
+	num_nominators: u32,
+) -> Result<(Vec<pallet_im_online::IdentificationTuple<T>>, Vec<Offender<T>>), &'static str> {
+	Staking::<T>::new_session(0);
+
+	let mut offenders = vec![];
+	for i in 0..num_offenders {
+		let offender = create_offender::<T>(i + 1, num_nominators)?;
+		offenders.push(offender);
+	}
+
+	Staking::<T>::start_session(0);
+
+	let id_tuples = offenders
+		.iter()
+		.map(|offender| {
+			<
+				<T as ImOnlineConfig>::ValidatorSet as ValidatorSet<T::AccountId>
+			>::ValidatorIdOf::convert(offender.controller.clone())
+			.expect("failed to get validator id from account id")
+		})
+		.map(|validator_id| {
+			<
+				<T as ImOnlineConfig>::ValidatorSet as ValidatorSetWithIdentification<T::AccountId>
+			>::IdentificationOf::convert(validator_id.clone())
+			.map(|full_id| (validator_id, full_id))
+			.expect("failed to convert validator id to full identification")
+		})
+		.collect::<Vec<pallet_im_online::IdentificationTuple<T>>>();
+	Ok((id_tuples, offenders))
+}
+
+#[cfg(test)]
+fn check_events<
+	T: Config,
+	I: Iterator<Item = Item>,
+	Item: sp_std::borrow::Borrow<<T as SystemConfig>::RuntimeEvent> + sp_std::fmt::Debug,
+>(
+	expected: I,
+) {
+	let events = System::<T>::events()
+		.into_iter()
+		.map(|frame_system::EventRecord { event, .. }| event)
+		.collect::<Vec<_>>();
+	let expected = expected.collect::<Vec<_>>();
+
+	fn pretty<D: sp_std::fmt::Debug>(header: &str, ev: &[D], offset: usize) {
+		log::info!("{}", header);
+		for (idx, ev) in ev.iter().enumerate() {
+			log::info!("\t[{:04}] {:?}", idx + offset, ev);
+		}
+	}
+	fn print_events<D: sp_std::fmt::Debug, E: sp_std::fmt::Debug>(
+		idx: usize,
+		events: &[D],
+		expected: &[E],
+	) {
+		let window = 10;
+		let start = idx.saturating_sub(window / 2);
+		let end_got = (idx + window / 2).min(events.len());
+		pretty("Got(window):", &events[start..end_got], start);
+		let end_expected = (idx + window / 2).min(expected.len());
+		pretty("Expected(window):", &expected[start..end_expected], start);
+		log::info!("---------------");
+		let start_got = events.len().saturating_sub(window);
+		pretty("Got(end):", &events[start_got..], start_got);
+		let start_expected = expected.len().saturating_sub(window);
+		pretty("Expected(end):", &expected[start_expected..], start_expected);
+	}
+
+	for (idx, (a, b)) in events.iter().zip(expected.iter()).enumerate() {
+		if a != sp_std::borrow::Borrow::borrow(b) {
+			print_events(idx, &events, &expected);
+			log::info!("Mismatch at: {}", idx);
+			log::info!("     Got: {:?}", b);
+			log::info!("Expected: {:?}", a);
+			if events.len() != expected.len() {
+				log::info!(
+					"Mismatching lengths. Got: {}, Expected: {}",
+					events.len(),
+					expected.len()
+				)
+			}
+			panic!("Mismatching events.");
+		}
+	}
+
+	if events.len() != expected.len() {
+		print_events(0, &events, &expected);
+		panic!("Mismatching lengths. Got: {}, Expected: {}", events.len(), expected.len(),)
+	}
+}
+
+benchmarks! {
+	report_offence_im_online {
+		let r in 1 .. MAX_REPORTERS;
+		// we skip 1 offender, because in such case there is no slashing
+		let o in 2 .. MAX_OFFENDERS;
+		let n in 0 .. MAX_NOMINATORS.min(MaxNominationsOf::<T>::get());
+
+		// Make r reporters
+		let mut reporters = vec![];
+		for i in 0 .. r {
+			let reporter = account("reporter", i, SEED);
+			reporters.push(reporter);
+		}
+
+		// make sure reporters actually get rewarded
+		Staking::<T>::set_slash_reward_fraction(Perbill::one());
+
+		let (offenders, raw_offenders) = make_offenders_im_online::<T>(o, n)?;
+		let keys =  ImOnline::<T>::keys();
+		let validator_set_count = keys.len() as u32;
+		let offenders_count = offenders.len() as u32;
+		let offence = UnresponsivenessOffence {
+			session_index: 0,
+			validator_set_count,
+			offenders,
+		};
+		let slash_fraction = offence.slash_fraction(offenders_count);
+		assert_eq!(System::<T>::event_count(), 0);
+	}: {
+		let _ = <T as ImOnlineConfig>::ReportUnresponsiveness::report_offence(
+			reporters.clone(),
+			offence
+		);
+	}
+	verify {
+		#[cfg(test)]
+		{
+			let bond_amount: u32 = UniqueSaturatedInto::<u32>::unique_saturated_into(bond_amount::<T>());
+			let slash_amount = slash_fraction * bond_amount;
+			let reward_amount = slash_amount.saturating_mul(1 + n) / 2;
+			let reward = reward_amount / r;
+			let slash_report = |id| core::iter::once(
+				<T as StakingConfig>::RuntimeEvent::from(StakingEvent::<T>::SlashReported{ validator: id, fraction: slash_fraction, slash_era: 0})
+			);
+			let slash = |id| core::iter::once(
+				<T as StakingConfig>::RuntimeEvent::from(StakingEvent::<T>::Slashed{ staker: id, amount: BalanceOf::<T>::from(slash_amount) })
+			);
+			let balance_slash = |id| core::iter::once(
+				<T as BalancesConfig>::RuntimeEvent::from(pallet_balances::Event::<T>::Slashed{ who: id, amount: slash_amount.into() })
+			);
+			let balance_locked = |id| core::iter::once(
+				<T as BalancesConfig>::RuntimeEvent::from(pallet_balances::Event::<T>::Locked{ who: id, amount: slash_amount.into() })
+			);
+			let balance_unlocked = |id| core::iter::once(
+				<T as BalancesConfig>::RuntimeEvent::from(pallet_balances::Event::<T>::Unlocked{ who: id, amount: slash_amount.into() })
+			);
+			let chill = |id| core::iter::once(
+				<T as StakingConfig>::RuntimeEvent::from(StakingEvent::<T>::Chilled{ stash: id })
+			);
+			let balance_deposit = |id, amount: u32|
+			<T as BalancesConfig>::RuntimeEvent::from(pallet_balances::Event::<T>::Deposit{ who: id, amount: amount.into() });
+			let mut first = true;
+
+			// We need to box all events to prevent running into too big allocations in wasm.
+			// The event in FRAME is represented as an enum and the size of the enum depends on the biggest variant.
+			// So, instead of requiring `size_of<Event>() * expected_events` we only need to
+			// allocate `size_of<Box<Event>>() * expected_events`.
+			let slash_events = raw_offenders.into_iter()
+				.flat_map(|offender| {
+					let nom_slashes = offender.nominator_stashes.into_iter().flat_map(|nom| {
+						balance_slash(nom.clone()).map(Into::into)
+						.chain(balance_unlocked(nom.clone()).map(Into::into))
+						.chain(slash(nom).map(Into::into)).map(Box::new)
+					});
+
+					let events = chill(offender.stash.clone()).map(Into::into).map(Box::new)
+						.chain(slash_report(offender.stash.clone()).map(Into::into).map(Box::new))
+						.chain(balance_slash(offender.stash.clone()).map(Into::into).map(Box::new))
+						.chain(balance_unlocked(offender.stash.clone()).map(Into::into).map(Box::new))
+						.chain(slash(offender.stash).map(Into::into).map(Box::new))
+						.chain(nom_slashes)
+						.collect::<Vec<_>>();
+
+					// the first deposit creates endowed events, see `endowed_reward_events`
+					if first {
+						first = false;
+						let reward_events = reporters.iter()
+							.flat_map(|reporter| vec![
+							 Box::new(balance_deposit(reporter.clone(), reward).into()),
+							 Box::new(frame_system::Event::<T>::NewAccount { account: reporter.clone() }.into()),
+							 Box::new(<T as BalancesConfig>::RuntimeEvent::from(
+								 pallet_balances::Event::<T>::Endowed{ account: reporter.clone(), free_balance: reward.into() }
+							 ).into()),
+							])
+							.collect::<Vec<_>>();
+						events.into_iter().chain(reward_events)
+					} else {
+						let reward_events = reporters.iter()
+							.map(|reporter| Box::new(balance_deposit(reporter.clone(), reward).into()))
+							.collect::<Vec<_>>();
+						events.into_iter().chain(reward_events)
+					}
+				});
+
+			// In case of error it's useful to see the inputs
+			log::info!("Inputs: r: {}, o: {}, n: {}", r, o, n);
+			// make sure that all slashes have been applied
+			check_events::<T, _, _>(
+				sp_std::iter::empty()
+					.chain(slash_events)
+					.chain(sp_std::iter::once(Box::new(<T as OffencesConfig>::RuntimeEvent::from(
+						pallet_offences::Event::Offence{
+							kind: UnresponsivenessOffence::<T>::ID,
+							timeslot: 0_u32.to_le_bytes().to_vec(),
+						}
+					).into())))
+			);
+		}
+	}
+
+	report_offence_grandpa {
+		let n in 0 .. MAX_NOMINATORS.min(MaxNominationsOf::<T>::get());
+
+		// for grandpa equivocation reports the number of reporters
+		// and offenders is always 1
+		let reporters = vec![account("reporter", 1, SEED)];
+
+		// make sure reporters actually get rewarded
+		Staking::<T>::set_slash_reward_fraction(Perbill::one());
+
+		let (mut offenders, raw_offenders) = make_offenders::<T>(1, n)?;
+		let keys = ImOnline::<T>::keys();
+
+		let offence = GrandpaEquivocationOffence {
+			time_slot: GrandpaTimeSlot { set_id: 0, round: 0 },
+			session_index: 0,
+			validator_set_count: keys.len() as u32,
+			offender: T::convert(offenders.pop().unwrap()),
+		};
+		assert_eq!(System::<T>::event_count(), 0);
+	}: {
+		let _ = Offences::<T>::report_offence(reporters, offence);
+	}
+	verify {
+		// make sure that all slashes have been applied
+		#[cfg(test)]
+		assert_eq!(
+			System::<T>::event_count(), 0
+			+ 1 // offence
+			+ 3 // reporter (reward + endowment)
+			+ 1 // offenders reported
+			+ 3 // offenders slashed
+			+ 1 // offenders chilled
+			+ 3 * n // nominators slashed
+		);
+	}
+
+	report_offence_babe {
+		let n in 0 .. MAX_NOMINATORS.min(MaxNominationsOf::<T>::get());
+
+		// for babe equivocation reports the number of reporters
+		// and offenders is always 1
+		let reporters = vec![account("reporter", 1, SEED)];
+
+		// make sure reporters actually get rewarded
+		Staking::<T>::set_slash_reward_fraction(Perbill::one());
+
+		let (mut offenders, raw_offenders) = make_offenders::<T>(1, n)?;
+		let keys =  ImOnline::<T>::keys();
+
+		let offence = BabeEquivocationOffence {
+			slot: 0u64.into(),
+			session_index: 0,
+			validator_set_count: keys.len() as u32,
+			offender: T::convert(offenders.pop().unwrap()),
+		};
+		assert_eq!(System::<T>::event_count(), 0);
+	}: {
+		let _ = Offences::<T>::report_offence(reporters, offence);
+	}
+	verify {
+		// make sure that all slashes have been applied
+		#[cfg(test)]
+		assert_eq!(
+			System::<T>::event_count(), 0
+			+ 1 // offence
+			+ 3 // reporter (reward + endowment)
+			+ 1 // offenders reported
+			+ 3 // offenders slashed
+			+ 1 // offenders chilled
+			+ 3 * n // nominators slashed
+		);
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/offences/benchmarking/src/mock.rs b/substrate/frame/offences/benchmarking/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..88f418dd3e2e89e8b846df8c8ee4dfd84e7cda95
--- /dev/null
+++ b/substrate/frame/offences/benchmarking/src/mock.rs
@@ -0,0 +1,239 @@
+// 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.
+
+//! Mock file for offences benchmarking.
+
+#![cfg(test)]
+
+use super::*;
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, SequentialPhragmen,
+};
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use frame_system as system;
+use pallet_session::historical as pallet_session_historical;
+use sp_runtime::{
+	testing::{Header, UintAuthorityId},
+	traits::IdentityLookup,
+	BuildStorage,
+};
+
+type AccountId = u64;
+type Nonce = u32;
+type Balance = u64;
+
+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>;
+}
+
+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 MaxHolds = ();
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+impl pallet_session::historical::Config for Test {
+	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Test>;
+}
+
+sp_runtime::impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub foo: sp_runtime::testing::UintAuthorityId,
+	}
+}
+
+pub struct TestSessionHandler;
+impl pallet_session::SessionHandler<AccountId> for TestSessionHandler {
+	const KEY_TYPE_IDS: &'static [sp_runtime::KeyTypeId] = &[];
+
+	fn on_genesis_session<Ks: sp_runtime::traits::OpaqueKeys>(_validators: &[(AccountId, Ks)]) {}
+
+	fn on_new_session<Ks: sp_runtime::traits::OpaqueKeys>(
+		_: bool,
+		_: &[(AccountId, Ks)],
+		_: &[(AccountId, Ks)],
+	) {
+	}
+
+	fn on_disabled(_: u32) {}
+}
+
+parameter_types! {
+	pub const Period: u64 = 1;
+	pub const Offset: u64 = 0;
+}
+
+impl pallet_session::Config for Test {
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Test, Staking>;
+	type Keys = SessionKeys;
+	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+	type SessionHandler = TestSessionHandler;
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = AccountId;
+	type ValidatorIdOf = pallet_staking::StashOf<Test>;
+	type WeightInfo = ();
+}
+
+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 ElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
+}
+
+pub type Extrinsic = sp_runtime::testing::TestXt<RuntimeCall, ()>;
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Test;
+	type Solver = SequentialPhragmen<AccountId, Perbill>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = ConstU32<100>;
+	type Bounds = ElectionsBounds;
+}
+
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = ();
+	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 HistoryDepth = ConstU32<84>;
+	type EventListeners = ();
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+impl pallet_im_online::Config for Test {
+	type AuthorityId = UintAuthorityId;
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorSet = Historical;
+	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+	type ReportUnresponsiveness = Offences;
+	type UnsignedPriority = ();
+	type WeightInfo = ();
+	type MaxKeys = ConstU32<10_000>;
+	type MaxPeerInHeartbeats = ConstU32<10_000>;
+}
+
+impl pallet_offences::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type IdentificationTuple = pallet_session::historical::IdentificationTuple<Self>;
+	type OnOffenceHandler = Staking;
+}
+
+impl<T> frame_system::offchain::SendTransactionTypes<T> for Test
+where
+	RuntimeCall: From<T>,
+{
+	type Extrinsic = Extrinsic;
+	type OverarchingCall = RuntimeCall;
+}
+
+impl crate::Config for Test {}
+
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, RuntimeCall, u64, ()>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: system::{Pallet, Call, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+		ImOnline: pallet_im_online::{Pallet, Call, Storage, Event<T>, ValidateUnsigned, Config<T>},
+		Offences: pallet_offences::{Pallet, Storage, Event},
+		Historical: pallet_session_historical::{Pallet},
+	}
+);
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	sp_io::TestExternalities::new(t)
+}
diff --git a/substrate/frame/offences/src/lib.rs b/substrate/frame/offences/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1c7ffeca7198325374f473cbae9e2f116697530c
--- /dev/null
+++ b/substrate/frame/offences/src/lib.rs
@@ -0,0 +1,247 @@
+// 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.
+
+//! # Offences Pallet
+//!
+//! Tracks reported offences
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod migration;
+mod mock;
+mod tests;
+
+use core::marker::PhantomData;
+
+use codec::Encode;
+use frame_support::weights::Weight;
+use sp_runtime::{traits::Hash, Perbill};
+use sp_staking::{
+	offence::{Kind, Offence, OffenceDetails, OffenceError, OnOffenceHandler, ReportOffence},
+	SessionIndex,
+};
+use sp_std::prelude::*;
+
+pub use pallet::*;
+
+/// A binary blob which represents a SCALE codec-encoded `O::TimeSlot`.
+type OpaqueTimeSlot = Vec<u8>;
+
+/// A type alias for a report identifier.
+type ReportIdOf<T> = <T as frame_system::Config>::Hash;
+
+const LOG_TARGET: &str = "runtime::offences";
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(_);
+
+	/// The pallet's config trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// Full identification of the validator.
+		type IdentificationTuple: Parameter;
+		/// A handler called for every offence report.
+		type OnOffenceHandler: OnOffenceHandler<Self::AccountId, Self::IdentificationTuple, Weight>;
+	}
+
+	/// The primary structure that holds all offence records keyed by report identifiers.
+	#[pallet::storage]
+	#[pallet::getter(fn reports)]
+	pub type Reports<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		ReportIdOf<T>,
+		OffenceDetails<T::AccountId, T::IdentificationTuple>,
+	>;
+
+	/// A vector of reports of the same kind that happened at the same time slot.
+	#[pallet::storage]
+	pub type ConcurrentReportsIndex<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		Kind,
+		Twox64Concat,
+		OpaqueTimeSlot,
+		Vec<ReportIdOf<T>>,
+		ValueQuery,
+	>;
+
+	/// Events type.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event {
+		/// There is an offence reported of the given `kind` happened at the `session_index` and
+		/// (kind-specific) time slot. This event is not deposited for duplicate slashes.
+		/// \[kind, timeslot\].
+		Offence { kind: Kind, timeslot: OpaqueTimeSlot },
+	}
+}
+
+impl<T, O> ReportOffence<T::AccountId, T::IdentificationTuple, O> for Pallet<T>
+where
+	T: Config,
+	O: Offence<T::IdentificationTuple>,
+{
+	fn report_offence(reporters: Vec<T::AccountId>, offence: O) -> Result<(), OffenceError> {
+		let offenders = offence.offenders();
+		let time_slot = offence.time_slot();
+
+		// Go through all offenders in the offence report and find all offenders that were spotted
+		// in unique reports.
+		let TriageOutcome { concurrent_offenders } =
+			match Self::triage_offence_report::<O>(reporters, &time_slot, offenders) {
+				Some(triage) => triage,
+				// The report contained only duplicates, so there is no need to slash again.
+				None => return Err(OffenceError::DuplicateReport),
+			};
+
+		let offenders_count = concurrent_offenders.len() as u32;
+
+		// The amount new offenders are slashed
+		let new_fraction = offence.slash_fraction(offenders_count);
+
+		let slash_perbill: Vec<_> = (0..concurrent_offenders.len()).map(|_| new_fraction).collect();
+
+		T::OnOffenceHandler::on_offence(
+			&concurrent_offenders,
+			&slash_perbill,
+			offence.session_index(),
+			offence.disable_strategy(),
+		);
+
+		// Deposit the event.
+		Self::deposit_event(Event::Offence { kind: O::ID, timeslot: time_slot.encode() });
+
+		Ok(())
+	}
+
+	fn is_known_offence(offenders: &[T::IdentificationTuple], time_slot: &O::TimeSlot) -> bool {
+		let any_unknown = offenders.iter().any(|offender| {
+			let report_id = Self::report_id::<O>(time_slot, offender);
+			!<Reports<T>>::contains_key(&report_id)
+		});
+
+		!any_unknown
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Compute the ID for the given report properties.
+	///
+	/// The report id depends on the offence kind, time slot and the id of offender.
+	fn report_id<O: Offence<T::IdentificationTuple>>(
+		time_slot: &O::TimeSlot,
+		offender: &T::IdentificationTuple,
+	) -> ReportIdOf<T> {
+		(O::ID, time_slot.encode(), offender).using_encoded(T::Hashing::hash)
+	}
+
+	/// Triages the offence report and returns the set of offenders that was involved in unique
+	/// reports along with the list of the concurrent offences.
+	fn triage_offence_report<O: Offence<T::IdentificationTuple>>(
+		reporters: Vec<T::AccountId>,
+		time_slot: &O::TimeSlot,
+		offenders: Vec<T::IdentificationTuple>,
+	) -> Option<TriageOutcome<T>> {
+		let mut storage = ReportIndexStorage::<T, O>::load(time_slot);
+
+		let mut any_new = false;
+		for offender in offenders {
+			let report_id = Self::report_id::<O>(time_slot, &offender);
+
+			if !<Reports<T>>::contains_key(&report_id) {
+				any_new = true;
+				<Reports<T>>::insert(
+					&report_id,
+					OffenceDetails { offender, reporters: reporters.clone() },
+				);
+
+				storage.insert(report_id);
+			}
+		}
+
+		if any_new {
+			// Load report details for the all reports happened at the same time.
+			let concurrent_offenders = storage
+				.concurrent_reports
+				.iter()
+				.filter_map(<Reports<T>>::get)
+				.collect::<Vec<_>>();
+
+			storage.save();
+
+			Some(TriageOutcome { concurrent_offenders })
+		} else {
+			None
+		}
+	}
+}
+
+struct TriageOutcome<T: Config> {
+	/// Other reports for the same report kinds.
+	concurrent_offenders: Vec<OffenceDetails<T::AccountId, T::IdentificationTuple>>,
+}
+
+/// An auxiliary struct for working with storage of indexes localized for a specific offence
+/// kind (specified by the `O` type parameter).
+///
+/// This struct is responsible for aggregating storage writes and the underlying storage should not
+/// accessed directly meanwhile.
+#[must_use = "The changes are not saved without called `save`"]
+struct ReportIndexStorage<T: Config, O: Offence<T::IdentificationTuple>> {
+	opaque_time_slot: OpaqueTimeSlot,
+	concurrent_reports: Vec<ReportIdOf<T>>,
+	_phantom: PhantomData<O>,
+}
+
+impl<T: Config, O: Offence<T::IdentificationTuple>> ReportIndexStorage<T, O> {
+	/// Preload indexes from the storage for the specific `time_slot` and the kind of the offence.
+	fn load(time_slot: &O::TimeSlot) -> Self {
+		let opaque_time_slot = time_slot.encode();
+
+		let concurrent_reports = <ConcurrentReportsIndex<T>>::get(&O::ID, &opaque_time_slot);
+
+		Self { opaque_time_slot, concurrent_reports, _phantom: Default::default() }
+	}
+
+	/// Insert a new report to the index.
+	fn insert(&mut self, report_id: ReportIdOf<T>) {
+		// Update the list of concurrent reports.
+		self.concurrent_reports.push(report_id);
+	}
+
+	/// Dump the indexes to the storage.
+	fn save(self) {
+		<ConcurrentReportsIndex<T>>::insert(
+			&O::ID,
+			&self.opaque_time_slot,
+			&self.concurrent_reports,
+		);
+	}
+}
diff --git a/substrate/frame/offences/src/migration.rs b/substrate/frame/offences/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3c0d243a55d98d4e6b47601def317939d03e40cc
--- /dev/null
+++ b/substrate/frame/offences/src/migration.rs
@@ -0,0 +1,188 @@
+// 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::{Config, Kind, OffenceDetails, Pallet, Perbill, SessionIndex, LOG_TARGET};
+use frame_support::{
+	dispatch::GetStorageVersion,
+	pallet_prelude::ValueQuery,
+	storage_alias,
+	traits::{Get, OnRuntimeUpgrade},
+	weights::Weight,
+	Twox64Concat,
+};
+use sp_staking::offence::{DisableStrategy, OnOffenceHandler};
+use sp_std::vec::Vec;
+
+#[cfg(feature = "try-runtime")]
+use frame_support::ensure;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+mod v0 {
+	use super::*;
+
+	#[storage_alias]
+	pub type ReportsByKindIndex<T: Config> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		Kind,
+		Vec<u8>, // (O::TimeSlot, ReportIdOf<T>)
+		ValueQuery,
+	>;
+}
+
+pub mod v1 {
+	use frame_support::traits::StorageVersion;
+
+	use super::*;
+
+	pub struct MigrateToV1<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV1<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			log::info!(
+				target: LOG_TARGET,
+				"Number of reports to refund and delete: {}",
+				v0::ReportsByKindIndex::<T>::iter_keys().count()
+			);
+
+			Ok(Vec::new())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			if Pallet::<T>::on_chain_storage_version() > 0 {
+				log::info!(target: LOG_TARGET, "pallet_offences::MigrateToV1 should be removed");
+				return T::DbWeight::get().reads(1)
+			}
+
+			let keys_removed = v0::ReportsByKindIndex::<T>::clear(u32::MAX, None).unique as u64;
+			StorageVersion::new(1).put::<Pallet<T>>();
+
+			// + 1 for reading/writing the new storage version
+			T::DbWeight::get().reads_writes(keys_removed + 1, keys_removed + 1)
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let onchain = Pallet::<T>::on_chain_storage_version();
+			ensure!(onchain == 1, "pallet_offences::MigrateToV1 needs to be run");
+			ensure!(
+				v0::ReportsByKindIndex::<T>::iter_keys().count() == 0,
+				"there are some dangling reports that need to be destroyed and refunded"
+			);
+			Ok(())
+		}
+	}
+}
+
+/// Type of data stored as a deferred offence
+type DeferredOffenceOf<T> = (
+	Vec<OffenceDetails<<T as frame_system::Config>::AccountId, <T as Config>::IdentificationTuple>>,
+	Vec<Perbill>,
+	SessionIndex,
+);
+
+// Deferred reports that have been rejected by the offence handler and need to be submitted
+// at a later time.
+#[storage_alias]
+type DeferredOffences<T: Config> =
+	StorageValue<crate::Pallet<T>, Vec<DeferredOffenceOf<T>>, ValueQuery>;
+
+pub fn remove_deferred_storage<T: Config>() -> Weight {
+	let mut weight = T::DbWeight::get().reads_writes(1, 1);
+	let deferred = <DeferredOffences<T>>::take();
+	log::info!(target: LOG_TARGET, "have {} deferred offences, applying.", deferred.len());
+	for (offences, perbill, session) in deferred.iter() {
+		let consumed = T::OnOffenceHandler::on_offence(
+			offences,
+			perbill,
+			*session,
+			DisableStrategy::WhenSlashed,
+		);
+		weight = weight.saturating_add(consumed);
+	}
+
+	weight
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::mock::{new_test_ext, with_on_offence_fractions, Runtime as T, KIND};
+	use codec::Encode;
+	use sp_runtime::Perbill;
+	use sp_staking::offence::OffenceDetails;
+
+	#[test]
+	fn migration_to_v1_works() {
+		let mut ext = new_test_ext();
+
+		ext.execute_with(|| {
+			<v0::ReportsByKindIndex<T>>::insert(KIND, 2u32.encode());
+			assert!(<v0::ReportsByKindIndex<T>>::iter_values().count() > 0);
+		});
+
+		ext.commit_all().unwrap();
+
+		ext.execute_with(|| {
+			assert_eq!(
+				v1::MigrateToV1::<T>::on_runtime_upgrade(),
+				<T as frame_system::Config>::DbWeight::get().reads_writes(2, 2),
+			);
+
+			assert!(<v0::ReportsByKindIndex<T>>::iter_values().count() == 0);
+		})
+	}
+
+	#[test]
+	fn should_resubmit_deferred_offences() {
+		new_test_ext().execute_with(|| {
+			// given
+			assert_eq!(<DeferredOffences<T>>::get().len(), 0);
+			with_on_offence_fractions(|f| {
+				assert_eq!(f.clone(), vec![]);
+			});
+
+			let offence_details = OffenceDetails::<
+				<T as frame_system::Config>::AccountId,
+				<T as Config>::IdentificationTuple,
+			> {
+				offender: 5,
+				reporters: vec![],
+			};
+
+			// push deferred offence
+			<DeferredOffences<T>>::append((
+				vec![offence_details],
+				vec![Perbill::from_percent(5 + 1 * 100 / 5)],
+				1,
+			));
+
+			// when
+			assert_eq!(
+				remove_deferred_storage::<T>(),
+				<T as frame_system::Config>::DbWeight::get().reads_writes(1, 1),
+			);
+
+			// then
+			assert!(!<DeferredOffences<T>>::exists());
+			with_on_offence_fractions(|f| {
+				assert_eq!(f.clone(), vec![Perbill::from_percent(5 + 1 * 100 / 5)]);
+			});
+		})
+	}
+}
diff --git a/substrate/frame/offences/src/mock.rs b/substrate/frame/offences/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..990ceae5ac01e18e779d6cbb9af9c3249c46cb78
--- /dev/null
+++ b/substrate/frame/offences/src/mock.rs
@@ -0,0 +1,160 @@
+// 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.
+
+//! Test utilities
+
+#![cfg(test)]
+
+use crate as offences;
+use crate::Config;
+use codec::Encode;
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+	weights::{constants::RocksDbWeight, Weight},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill,
+};
+use sp_staking::{
+	offence::{self, DisableStrategy, Kind, OffenceDetails},
+	SessionIndex,
+};
+
+pub struct OnOffenceHandler;
+
+parameter_types! {
+	pub static OnOffencePerbill: Vec<Perbill> = Default::default();
+	pub static OffenceWeight: Weight = Default::default();
+}
+
+impl<Reporter, Offender> offence::OnOffenceHandler<Reporter, Offender, Weight>
+	for OnOffenceHandler
+{
+	fn on_offence(
+		_offenders: &[OffenceDetails<Reporter, Offender>],
+		slash_fraction: &[Perbill],
+		_offence_session: SessionIndex,
+		_disable_strategy: DisableStrategy,
+	) -> Weight {
+		OnOffencePerbill::mutate(|f| {
+			*f = slash_fraction.to_vec();
+		});
+
+		OffenceWeight::get()
+	}
+}
+
+pub fn with_on_offence_fractions<R, F: FnOnce(&mut Vec<Perbill>) -> R>(f: F) -> R {
+	OnOffencePerbill::mutate(|fractions| f(fractions))
+}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Offences: offences::{Pallet, Storage, Event},
+	}
+);
+
+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 MaxConsumers = ConstU32<16>;
+}
+
+impl Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type IdentificationTuple = u64;
+	type OnOffenceHandler = OnOffenceHandler;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+pub const KIND: [u8; 16] = *b"test_report_1234";
+
+/// Returns all offence details for the specific `kind` happened at the specific time slot.
+pub fn offence_reports(kind: Kind, time_slot: u128) -> Vec<OffenceDetails<u64, u64>> {
+	<crate::ConcurrentReportsIndex<Runtime>>::get(&kind, &time_slot.encode())
+		.into_iter()
+		.map(|report_id| {
+			<crate::Reports<Runtime>>::get(&report_id)
+				.expect("dangling report id is found in ConcurrentReportsIndex")
+		})
+		.collect()
+}
+
+#[derive(Clone)]
+pub struct Offence {
+	pub validator_set_count: u32,
+	pub offenders: Vec<u64>,
+	pub time_slot: u128,
+}
+
+impl offence::Offence<u64> for Offence {
+	const ID: offence::Kind = KIND;
+	type TimeSlot = u128;
+
+	fn offenders(&self) -> Vec<u64> {
+		self.offenders.clone()
+	}
+
+	fn validator_set_count(&self) -> u32 {
+		self.validator_set_count
+	}
+
+	fn time_slot(&self) -> u128 {
+		self.time_slot
+	}
+
+	fn session_index(&self) -> SessionIndex {
+		1
+	}
+
+	fn slash_fraction(&self, offenders_count: u32) -> Perbill {
+		Perbill::from_percent(5 + offenders_count * 100 / self.validator_set_count)
+	}
+}
diff --git a/substrate/frame/offences/src/tests.rs b/substrate/frame/offences/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d525c7c3ab1d920e07273f26168d3711517e5827
--- /dev/null
+++ b/substrate/frame/offences/src/tests.rs
@@ -0,0 +1,247 @@
+// 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 the offences module.
+
+#![cfg(test)]
+
+use super::*;
+use crate::mock::{
+	new_test_ext, offence_reports, with_on_offence_fractions, Offence, Offences, RuntimeEvent,
+	System, KIND,
+};
+use frame_system::{EventRecord, Phase};
+use sp_runtime::Perbill;
+
+#[test]
+fn should_report_an_authority_and_trigger_on_offence() {
+	new_test_ext().execute_with(|| {
+		// given
+		let time_slot = 42;
+		assert_eq!(offence_reports(KIND, time_slot), vec![]);
+
+		let offence = Offence { validator_set_count: 5, time_slot, offenders: vec![5] };
+
+		// when
+		Offences::report_offence(vec![], offence).unwrap();
+
+		// then
+		with_on_offence_fractions(|f| {
+			assert_eq!(f.clone(), vec![Perbill::from_percent(25)]);
+		});
+	});
+}
+
+#[test]
+fn should_not_report_the_same_authority_twice_in_the_same_slot() {
+	new_test_ext().execute_with(|| {
+		// given
+		let time_slot = 42;
+		assert_eq!(offence_reports(KIND, time_slot), vec![]);
+
+		let offence = Offence { validator_set_count: 5, time_slot, offenders: vec![5] };
+		Offences::report_offence(vec![], offence.clone()).unwrap();
+		with_on_offence_fractions(|f| {
+			assert_eq!(f.clone(), vec![Perbill::from_percent(25)]);
+			f.clear();
+		});
+
+		// when
+		// report for the second time
+		assert_eq!(Offences::report_offence(vec![], offence), Err(OffenceError::DuplicateReport));
+
+		// then
+		with_on_offence_fractions(|f| {
+			assert_eq!(f.clone(), vec![]);
+		});
+	});
+}
+
+#[test]
+fn should_report_in_different_time_slot() {
+	new_test_ext().execute_with(|| {
+		// given
+		let time_slot = 42;
+		assert_eq!(offence_reports(KIND, time_slot), vec![]);
+
+		let mut offence = Offence { validator_set_count: 5, time_slot, offenders: vec![5] };
+		Offences::report_offence(vec![], offence.clone()).unwrap();
+		with_on_offence_fractions(|f| {
+			assert_eq!(f.clone(), vec![Perbill::from_percent(25)]);
+			f.clear();
+		});
+
+		// when
+		// report for the second time
+		offence.time_slot += 1;
+		Offences::report_offence(vec![], offence).unwrap();
+
+		// then
+		with_on_offence_fractions(|f| {
+			assert_eq!(f.clone(), vec![Perbill::from_percent(25)]);
+		});
+	});
+}
+
+#[test]
+fn should_deposit_event() {
+	new_test_ext().execute_with(|| {
+		// given
+		let time_slot = 42;
+		assert_eq!(offence_reports(KIND, time_slot), vec![]);
+
+		let offence = Offence { validator_set_count: 5, time_slot, offenders: vec![5] };
+
+		// when
+		Offences::report_offence(vec![], offence).unwrap();
+
+		// then
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Initialization,
+				event: RuntimeEvent::Offences(crate::Event::Offence {
+					kind: KIND,
+					timeslot: time_slot.encode()
+				}),
+				topics: vec![],
+			}]
+		);
+	});
+}
+
+#[test]
+fn doesnt_deposit_event_for_dups() {
+	new_test_ext().execute_with(|| {
+		// given
+		let time_slot = 42;
+		assert_eq!(offence_reports(KIND, time_slot), vec![]);
+
+		let offence = Offence { validator_set_count: 5, time_slot, offenders: vec![5] };
+		Offences::report_offence(vec![], offence.clone()).unwrap();
+		with_on_offence_fractions(|f| {
+			assert_eq!(f.clone(), vec![Perbill::from_percent(25)]);
+			f.clear();
+		});
+
+		// when
+		// report for the second time
+		assert_eq!(Offences::report_offence(vec![], offence), Err(OffenceError::DuplicateReport));
+
+		// then
+		// there is only one event.
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Initialization,
+				event: RuntimeEvent::Offences(crate::Event::Offence {
+					kind: KIND,
+					timeslot: time_slot.encode()
+				}),
+				topics: vec![],
+			}]
+		);
+	});
+}
+
+#[test]
+fn reports_if_an_offence_is_dup() {
+	new_test_ext().execute_with(|| {
+		let time_slot = 42;
+		assert_eq!(offence_reports(KIND, time_slot), vec![]);
+
+		let offence =
+			|time_slot, offenders| Offence { validator_set_count: 5, time_slot, offenders };
+
+		let mut test_offence = offence(time_slot, vec![0]);
+
+		// the report for authority 0 at time slot 42 should not be a known
+		// offence
+		assert!(!<Offences as ReportOffence<_, _, Offence>>::is_known_offence(
+			&test_offence.offenders,
+			&test_offence.time_slot
+		));
+
+		// we report an offence for authority 0 at time slot 42
+		Offences::report_offence(vec![], test_offence.clone()).unwrap();
+
+		// the same report should be a known offence now
+		assert!(<Offences as ReportOffence<_, _, Offence>>::is_known_offence(
+			&test_offence.offenders,
+			&test_offence.time_slot
+		));
+
+		// and reporting it again should yield a duplicate report error
+		assert_eq!(
+			Offences::report_offence(vec![], test_offence.clone()),
+			Err(OffenceError::DuplicateReport)
+		);
+
+		// after adding a new offender to the offence report
+		test_offence.offenders.push(1);
+
+		// it should not be a known offence anymore
+		assert!(!<Offences as ReportOffence<_, _, Offence>>::is_known_offence(
+			&test_offence.offenders,
+			&test_offence.time_slot
+		));
+
+		// and reporting it again should work without any error
+		assert_eq!(Offences::report_offence(vec![], test_offence.clone()), Ok(()));
+
+		// creating a new offence for the same authorities on the next slot
+		// should be considered a new offence and thefore not known
+		let test_offence_next_slot = offence(time_slot + 1, vec![0, 1]);
+		assert!(!<Offences as ReportOffence<_, _, Offence>>::is_known_offence(
+			&test_offence_next_slot.offenders,
+			&test_offence_next_slot.time_slot
+		));
+	});
+}
+
+#[test]
+fn should_properly_count_offences() {
+	// We report two different authorities for the same issue. Ultimately, the 1st authority
+	// should have `count` equal 2 and the count of the 2nd one should be equal to 1.
+	new_test_ext().execute_with(|| {
+		// given
+		let time_slot = 42;
+		assert_eq!(offence_reports(KIND, time_slot), vec![]);
+
+		let offence1 = Offence { validator_set_count: 5, time_slot, offenders: vec![5] };
+		let offence2 = Offence { validator_set_count: 5, time_slot, offenders: vec![4] };
+		Offences::report_offence(vec![], offence1).unwrap();
+		with_on_offence_fractions(|f| {
+			assert_eq!(f.clone(), vec![Perbill::from_percent(25)]);
+			f.clear();
+		});
+
+		// when
+		// report for the second time
+		Offences::report_offence(vec![], offence2).unwrap();
+
+		// then
+		// the 1st authority should have count 2 and the 2nd one should be reported only once.
+		assert_eq!(
+			offence_reports(KIND, time_slot),
+			vec![
+				OffenceDetails { offender: 5, reporters: vec![] },
+				OffenceDetails { offender: 4, reporters: vec![] },
+			]
+		);
+	});
+}
diff --git a/substrate/frame/paged-list/Cargo.toml b/substrate/frame/paged-list/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4f697b6333c8eb448f4190f4ecb9dd678fed5ff1
--- /dev/null
+++ b/substrate/frame/paged-list/Cargo.toml
@@ -0,0 +1,58 @@
+[package]
+name = "pallet-paged-list"
+version = "0.1.0"
+description = "FRAME pallet that provides a paged list data structure."
+authors = ["Parity Technologies <admin@parity.io>"]
+homepage = "https://substrate.io"
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/paritytech/substrate"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = [ "derive"] }
+docify = "0.2.1"
+scale-info = { version = "2.0.0", default-features = false, features = ["derive"] }
+
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-core = { version = "21.0.0", path = "../../primitives/core", default-features = false }
+sp-io = { version = "23.0.0", path = "../../primitives/io", default-features = false }
+sp-metadata-ir = { version = "0.1.0", default-features = false, optional = true, path = "../../primitives/metadata-ir" }
+
+[features]
+default = [ "std" ]
+
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-metadata-ir/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
+
+frame-metadata = [ "sp-metadata-ir" ]
diff --git a/substrate/frame/paged-list/fuzzer/Cargo.toml b/substrate/frame/paged-list/fuzzer/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9402ca8a48477eb95d942fe244bfd99e72a9634f
--- /dev/null
+++ b/substrate/frame/paged-list/fuzzer/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "pallet-paged-list-fuzzer"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Fuzz storage types of pallet-paged-list"
+publish = false
+
+[[bin]]
+name = "pallet-paged-list"
+path = "src/paged_list.rs"
+
+[dependencies]
+arbitrary = "1.3.0"
+honggfuzz = "0.5.49"
+
+frame-support = { version = "4.0.0-dev", default-features = false, features = [ "std" ], path = "../../support" }
+sp-io = { path = "../../../primitives/io", default-features = false, features = [ "std" ] }
+pallet-paged-list = { path = "../", default-features = false, features = [ "std" ] }
diff --git a/substrate/frame/paged-list/fuzzer/src/paged_list.rs b/substrate/frame/paged-list/fuzzer/src/paged_list.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43b797eee6bfb088412c90964d8f3332b0c039a7
--- /dev/null
+++ b/substrate/frame/paged-list/fuzzer/src/paged_list.rs
@@ -0,0 +1,103 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run pallet-paged-list`. `honggfuzz` CLI
+//! options can be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug pallet-paged-list hfuzz_workspace/pallet-paged-list/*.fuzz`.
+//!
+//! # More information
+//! More information about `honggfuzz` can be found
+//! [here](https://docs.rs/honggfuzz/).
+
+use arbitrary::Arbitrary;
+use honggfuzz::fuzz;
+
+use frame_support::{storage::StorageList, StorageNoopGuard};
+use pallet_paged_list::mock::{PagedList as List, *};
+use sp_io::TestExternalities;
+type Meta = MetaOf<Test, ()>;
+
+fn main() {
+	loop {
+		fuzz!(|data: (Vec<Op>, u8)| {
+			drain_append_work(data.0, data.1);
+		});
+	}
+}
+
+/// Appends and drains random number of elements in random order and checks storage invariants.
+///
+/// It also changes the maximal number of elements per page dynamically, hence the `page_size`.
+fn drain_append_work(ops: Vec<Op>, page_size: u8) {
+	if page_size == 0 {
+		return
+	}
+
+	TestExternalities::default().execute_with(|| {
+		ValuesPerNewPage::set(&page_size.into());
+		let _g = StorageNoopGuard::default();
+		let mut total: i64 = 0;
+
+		for op in ops.into_iter() {
+			total += op.exec();
+
+			assert!(total >= 0);
+			assert_eq!(List::iter().count(), total as usize);
+
+			// We have the assumption that the queue removes the metadata when empty.
+			if total == 0 {
+				assert_eq!(List::drain().count(), 0);
+				assert_eq!(Meta::from_storage().unwrap_or_default(), Default::default());
+			}
+		}
+
+		assert_eq!(List::drain().count(), total as usize);
+		// `StorageNoopGuard` checks that there is no storage leaked.
+	});
+}
+
+enum Op {
+	Append(Vec<u32>),
+	Drain(u8),
+}
+
+impl Arbitrary<'_> for Op {
+	fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
+		if u.arbitrary::<bool>()? {
+			Ok(Op::Append(Vec::<u32>::arbitrary(u)?))
+		} else {
+			Ok(Op::Drain(u.arbitrary::<u8>()?))
+		}
+	}
+}
+
+impl Op {
+	pub fn exec(self) -> i64 {
+		match self {
+			Op::Append(v) => {
+				let l = v.len();
+				List::append_many(v);
+				l as i64
+			},
+			Op::Drain(v) => -(List::drain().take(v as usize).count() as i64),
+		}
+	}
+}
diff --git a/substrate/frame/paged-list/src/lib.rs b/substrate/frame/paged-list/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ddeed174f34bb5afac01d0ad839e2cd980b5764a
--- /dev/null
+++ b/substrate/frame/paged-list/src/lib.rs
@@ -0,0 +1,136 @@
+// 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.
+
+//! > Made with *Substrate*, for *DotSama*.
+//!
+//! [![github]](https://github.com/paritytech/substrate/frame/fast-unstake) -
+//! [![polkadot]](https://polkadot.network)
+//!
+//! [polkadot]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//!
+//! # Paged List Pallet
+//!
+//! A thin wrapper pallet around a [`paged_list::StoragePagedList`]. It provides an API for a single
+//! paginated list. It can be instantiated multiple times to provide multiple lists.
+//!
+//! ## Overview
+//!
+//! The pallet is quite unique since it does not expose any `Call`s, `Error`s or `Event`s. All
+//! interaction goes through the implemented [`StorageList`][frame_support::storage::StorageList]
+//! trait.
+//!
+//! A fuzzer for testing is provided in crate `pallet-paged-list-fuzzer`.
+//!
+//! ## Examples
+//!
+//! 1. **Appending** some data to the list can happen either by [`Pallet::append_one`]:
+#![doc = docify::embed!("src/tests.rs", append_one_works)]
+//! 2. or by [`Pallet::append_many`]. This should always be preferred to repeated calls to
+//! [`Pallet::append_one`]:
+#![doc = docify::embed!("src/tests.rs", append_many_works)]
+//! 3. If you want to append many values (ie. in a loop), then best use the [`Pallet::appender`]:
+#![doc = docify::embed!("src/tests.rs", appender_works)]
+//! 4. **Iterating** over the list can be done with [`Pallet::iter`]. It uses the standard
+//! `Iterator` trait:
+#![doc = docify::embed!("src/tests.rs", iter_works)]
+//! 5. **Draining** elements happens through the [`Pallet::drain`] iterator. Note that even
+//! *peeking* a value will already remove it.
+#![doc = docify::embed!("src/tests.rs", drain_works)]
+//!
+//! ## Pallet API
+//!
+//! None. Only things to consider is the [`Config`] traits.
+//!
+//! ## Low Level / Implementation Details
+//!
+//! Implementation details are documented in [`paged_list::StoragePagedList`].  
+//! All storage entries are prefixed with a unique prefix that is generated by [`ListPrefix`].
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+pub mod mock;
+mod paged_list;
+mod tests;
+
+use codec::FullCodec;
+use frame_support::{
+	pallet_prelude::StorageList,
+	traits::{PalletInfoAccess, StorageInstance},
+};
+pub use paged_list::StoragePagedList;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The value type that can be stored in the list.
+		type Value: FullCodec;
+
+		/// The number of values that can be put into newly created pages.
+		///
+		/// Note that this does not retroactively affect already created pages. This value can be
+		/// changed at any time without requiring a runtime migration.
+		#[pallet::constant]
+		type ValuesPerNewPage: Get<u32>;
+	}
+
+	/// A storage paged list akin to what the FRAME macros would generate.
+	// Note that FRAME does natively support paged lists in storage.
+	pub type List<T, I> = StoragePagedList<
+		ListPrefix<T, I>,
+		<T as Config<I>>::Value,
+		<T as Config<I>>::ValuesPerNewPage,
+	>;
+}
+
+// This exposes the list functionality to other pallets.
+impl<T: Config<I>, I: 'static> StorageList<T::Value> for Pallet<T, I> {
+	type Iterator = <List<T, I> as StorageList<T::Value>>::Iterator;
+	type Appender = <List<T, I> as StorageList<T::Value>>::Appender;
+
+	fn iter() -> Self::Iterator {
+		List::<T, I>::iter()
+	}
+
+	fn drain() -> Self::Iterator {
+		List::<T, I>::drain()
+	}
+
+	fn appender() -> Self::Appender {
+		List::<T, I>::appender()
+	}
+}
+
+/// Generates a unique storage prefix for each instance of the pallet.
+pub struct ListPrefix<T, I>(core::marker::PhantomData<(T, I)>);
+
+impl<T: Config<I>, I: 'static> StorageInstance for ListPrefix<T, I> {
+	fn pallet_prefix() -> &'static str {
+		crate::Pallet::<T, I>::name()
+	}
+
+	const STORAGE_PREFIX: &'static str = "paged_list";
+}
diff --git a/substrate/frame/paged-list/src/mock.rs b/substrate/frame/paged-list/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..390b4a8530dce956ff281c9b7c752606a543d4e2
--- /dev/null
+++ b/substrate/frame/paged-list/src/mock.rs
@@ -0,0 +1,94 @@
+// 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.
+
+//! Helpers for tests.
+
+#![cfg(feature = "std")]
+
+use crate::{paged_list::StoragePagedListMeta, Config, ListPrefix};
+use frame_support::traits::{ConstU16, ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+// Configure a mock runtime to test the pallet.
+frame_support::construct_runtime!(
+	pub enum Test {
+		System: frame_system,
+		PagedList: crate,
+		PagedList2: crate::<Instance2>,
+	}
+);
+
+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! {
+	pub storage ValuesPerNewPage: u32 = 5;
+	pub const MaxPages: Option<u32> = Some(20);
+}
+
+impl crate::Config for Test {
+	type Value = u32;
+	type ValuesPerNewPage = ValuesPerNewPage;
+}
+
+impl crate::Config<crate::Instance2> for Test {
+	type Value = u32;
+	type ValuesPerNewPage = ValuesPerNewPage;
+}
+
+pub type MetaOf<T, I> =
+	StoragePagedListMeta<ListPrefix<T, I>, <T as Config>::Value, <T as Config>::ValuesPerNewPage>;
+
+/// Build genesis storage according to the mock runtime.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
+
+/// Run this closure in test externalities.
+pub fn test_closure<R>(f: impl FnOnce() -> R) -> R {
+	let mut ext = new_test_ext();
+	ext.execute_with(f)
+}
diff --git a/substrate/frame/paged-list/src/paged_list.rs b/substrate/frame/paged-list/src/paged_list.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3597c3dea682313f0b56c2ae11bdfa4a85ccfebc
--- /dev/null
+++ b/substrate/frame/paged-list/src/paged_list.rs
@@ -0,0 +1,581 @@
+// 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.
+
+//! Paged storage list.
+
+// links are better than no links - even when they refer to private stuff.
+#![allow(rustdoc::private_intra_doc_links)]
+#![deny(rustdoc::broken_intra_doc_links)]
+#![deny(missing_docs)]
+#![deny(unsafe_code)]
+
+use codec::{Decode, Encode, EncodeLike, FullCodec};
+use core::marker::PhantomData;
+use frame_support::{
+	defensive,
+	storage::StoragePrefixedContainer,
+	traits::{Get, StorageInstance},
+	CloneNoBound, DebugNoBound, DefaultNoBound, EqNoBound, PartialEqNoBound,
+};
+use sp_runtime::traits::Saturating;
+use sp_std::prelude::*;
+
+pub type PageIndex = u32;
+pub type ValueIndex = u32;
+
+/// A paginated storage list.
+///
+/// # Motivation
+///
+/// This type replaces `StorageValue<Vec<V>>` in situations where only iteration and appending is
+/// needed. There are a few places where this is the case. A paginated structure reduces the memory
+/// usage when a storage transactions needs to be rolled back. The main motivation is therefore a
+/// reduction of runtime memory on storage transaction rollback. Should be configured such that the
+/// size of a page is about 64KiB. This can only be ensured when `V` implements `MaxEncodedLen`.
+///
+/// # Implementation
+///
+/// The metadata of this struct is stored in [`StoragePagedListMeta`]. The data is stored in
+/// [`Page`]s.
+///
+/// Each [`Page`] holds at most `ValuesPerNewPage` values in its `values` vector. The last page is
+/// the only one that could have less than `ValuesPerNewPage` values.  
+/// **Iteration** happens by starting
+/// at [`first_page`][StoragePagedListMeta::first_page]/
+/// [`first_value_offset`][StoragePagedListMeta::first_value_offset] and incrementing these indices
+/// as long as there are elements in the page and there are pages in storage. All elements of a page
+/// are loaded once a page is read from storage. Iteration then happens on the cached elements. This
+/// reduces the number of storage `read` calls on the overlay. **Appending** to the list happens by
+/// appending to the last page by utilizing [`sp_io::storage::append`]. It allows to directly extend
+/// the elements of `values` vector of the page without loading the whole vector from storage. A new
+/// page is instantiated once [`Page::next`] overflows `ValuesPerNewPage`. Its vector will also be
+/// created through [`sp_io::storage::append`]. **Draining** advances the internal indices identical
+/// to Iteration. It additionally persists the increments to storage and thereby 'drains' elements.
+/// Completely drained pages are deleted from storage.
+///
+/// # Further Observations
+///
+/// - The encoded layout of a page is exactly its [`Page::values`]. The [`Page::next`] offset is
+///   stored in the [`StoragePagedListMeta`] instead. There is no particular reason for this,
+///   besides having all management state handy in one location.
+/// - The PoV complexity of iterating compared to a `StorageValue<Vec<V>>` is improved for
+///   "shortish" iterations and worse for total iteration. The append complexity is identical in the
+///   asymptotic case when using an `Appender`, and worse in all. For example when appending just
+///   one value.
+/// - It does incur a read overhead on the host side as compared to a `StorageValue<Vec<V>>`.
+pub struct StoragePagedList<Prefix, Value, ValuesPerNewPage> {
+	_phantom: PhantomData<(Prefix, Value, ValuesPerNewPage)>,
+}
+
+/// The state of a [`StoragePagedList`].
+///
+/// This struct doubles as [`frame_support::storage::StorageList::Appender`].
+#[derive(
+	Encode, Decode, CloneNoBound, PartialEqNoBound, EqNoBound, DebugNoBound, DefaultNoBound,
+)]
+// todo ignore scale bounds
+pub struct StoragePagedListMeta<Prefix, Value, ValuesPerNewPage> {
+	/// The first page that could contain a value.
+	///
+	/// Can be >0 when pages were deleted.
+	pub first_page: PageIndex,
+	/// The first index inside `first_page` that could contain a value.
+	///
+	/// Can be >0 when values were deleted.
+	pub first_value_offset: ValueIndex,
+
+	/// The last page that could contain data.
+	///
+	/// Appending starts at this page index.
+	pub last_page: PageIndex,
+	/// The last value inside `last_page` that could contain a value.
+	///
+	/// Appending starts at this index. If the page does not hold a value at this index, then the
+	/// whole list is empty. The only case where this can happen is when both are `0`.
+	pub last_page_len: ValueIndex,
+
+	_phantom: PhantomData<(Prefix, Value, ValuesPerNewPage)>,
+}
+
+impl<Prefix, Value, ValuesPerNewPage> frame_support::storage::StorageAppender<Value>
+	for StoragePagedListMeta<Prefix, Value, ValuesPerNewPage>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	ValuesPerNewPage: Get<u32>,
+{
+	fn append<EncodeLikeValue>(&mut self, item: EncodeLikeValue)
+	where
+		EncodeLikeValue: EncodeLike<Value>,
+	{
+		self.append_one(item);
+	}
+}
+
+impl<Prefix, Value, ValuesPerNewPage> StoragePagedListMeta<Prefix, Value, ValuesPerNewPage>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	ValuesPerNewPage: Get<u32>,
+{
+	pub fn from_storage() -> Option<Self> {
+		let key = Self::key();
+
+		sp_io::storage::get(&key).and_then(|raw| Self::decode(&mut &raw[..]).ok())
+	}
+
+	pub fn key() -> Vec<u8> {
+		meta_key::<Prefix>()
+	}
+
+	pub fn append_one<EncodeLikeValue>(&mut self, item: EncodeLikeValue)
+	where
+		EncodeLikeValue: EncodeLike<Value>,
+	{
+		// Note: we use >= here in case someone decreased it in a runtime upgrade.
+		if self.last_page_len >= ValuesPerNewPage::get() {
+			self.last_page.saturating_inc();
+			self.last_page_len = 0;
+		}
+		let key = page_key::<Prefix>(self.last_page);
+		self.last_page_len.saturating_inc();
+		sp_io::storage::append(&key, item.encode());
+		self.store();
+	}
+
+	pub fn store(&self) {
+		let key = Self::key();
+		self.using_encoded(|enc| sp_io::storage::set(&key, enc));
+	}
+
+	pub fn reset(&mut self) {
+		*self = Default::default();
+		Self::delete();
+	}
+
+	pub fn delete() {
+		sp_io::storage::clear(&Self::key());
+	}
+}
+
+/// A page that was decoded from storage and caches its values.
+pub struct Page<V> {
+	/// The index of the page.
+	index: PageIndex,
+	/// The remaining values of the page, to be drained by [`Page::next`].
+	values: sp_std::iter::Skip<sp_std::vec::IntoIter<V>>,
+}
+
+impl<V: FullCodec> Page<V> {
+	/// Read the page with `index` from storage and assume the first value at `value_index`.
+	pub fn from_storage<Prefix: StorageInstance>(
+		index: PageIndex,
+		value_index: ValueIndex,
+	) -> Option<Self> {
+		let key = page_key::<Prefix>(index);
+		let values = sp_io::storage::get(&key)
+			.and_then(|raw| sp_std::vec::Vec::<V>::decode(&mut &raw[..]).ok())?;
+		if values.is_empty() {
+			// Dont create empty pages.
+			return None
+		}
+		let values = values.into_iter().skip(value_index as usize);
+
+		Some(Self { index, values })
+	}
+
+	/// Whether no more values can be read from this page.
+	pub fn is_eof(&self) -> bool {
+		self.values.len() == 0
+	}
+
+	/// Delete this page from storage.
+	pub fn delete<Prefix: StorageInstance>(&self) {
+		delete_page::<Prefix>(self.index);
+	}
+}
+
+/// Delete a page with `index` from storage.
+// Does not live under `Page` since it does not require the `Value` generic.
+pub(crate) fn delete_page<Prefix: StorageInstance>(index: PageIndex) {
+	let key = page_key::<Prefix>(index);
+	sp_io::storage::clear(&key);
+}
+
+/// Storage key of a page with `index`.
+// Does not live under `Page` since it does not require the `Value` generic.
+pub(crate) fn page_key<Prefix: StorageInstance>(index: PageIndex) -> Vec<u8> {
+	(StoragePagedListPrefix::<Prefix>::final_prefix(), b"page", index).encode()
+}
+
+pub(crate) fn meta_key<Prefix: StorageInstance>() -> Vec<u8> {
+	(StoragePagedListPrefix::<Prefix>::final_prefix(), b"meta").encode()
+}
+
+impl<V> Iterator for Page<V> {
+	type Item = V;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.values.next()
+	}
+}
+
+/// Iterates over values of a [`StoragePagedList`].
+///
+/// Can optionally drain the iterated values.
+pub struct StoragePagedListIterator<Prefix, Value, ValuesPerNewPage> {
+	// Design: we put the Page into the iterator to have fewer storage look-ups. Yes, these
+	// look-ups would be cached anyway, but bugging the overlay on each `.next` call still seems
+	// like a poor trade-off than caching it in the iterator directly. Iterating and modifying is
+	// not allowed at the same time anyway, just like with maps. Note: if Page is empty then
+	// the iterator did not find any data upon setup or ran out of pages.
+	page: Option<Page<Value>>,
+	drain: bool,
+	meta: StoragePagedListMeta<Prefix, Value, ValuesPerNewPage>,
+}
+
+impl<Prefix, Value, ValuesPerNewPage> StoragePagedListIterator<Prefix, Value, ValuesPerNewPage>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	ValuesPerNewPage: Get<u32>,
+{
+	/// Read self from the storage.
+	pub fn from_meta(
+		meta: StoragePagedListMeta<Prefix, Value, ValuesPerNewPage>,
+		drain: bool,
+	) -> Self {
+		let page = Page::<Value>::from_storage::<Prefix>(meta.first_page, meta.first_value_offset);
+		Self { page, drain, meta }
+	}
+}
+
+impl<Prefix, Value, ValuesPerNewPage> Iterator
+	for StoragePagedListIterator<Prefix, Value, ValuesPerNewPage>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	ValuesPerNewPage: Get<u32>,
+{
+	type Item = Value;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		let page = self.page.as_mut()?;
+		let value = match page.next() {
+			Some(value) => value,
+			None => {
+				defensive!("There are no empty pages in storage; nuking the list");
+				self.meta.reset();
+				self.page = None;
+				return None
+			},
+		};
+
+		if page.is_eof() {
+			if self.drain {
+				page.delete::<Prefix>();
+				self.meta.first_value_offset = 0;
+				self.meta.first_page.saturating_inc();
+			}
+
+			debug_assert!(!self.drain || self.meta.first_page == page.index + 1);
+			self.page = Page::from_storage::<Prefix>(page.index.saturating_add(1), 0);
+			if self.drain {
+				if self.page.is_none() {
+					self.meta.reset();
+				} else {
+					self.meta.store();
+				}
+			}
+		} else {
+			if self.drain {
+				self.meta.first_value_offset.saturating_inc();
+				self.meta.store();
+			}
+		}
+		Some(value)
+	}
+}
+
+impl<Prefix, Value, ValuesPerNewPage> frame_support::storage::StorageList<Value>
+	for StoragePagedList<Prefix, Value, ValuesPerNewPage>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	ValuesPerNewPage: Get<u32>,
+{
+	type Iterator = StoragePagedListIterator<Prefix, Value, ValuesPerNewPage>;
+	type Appender = StoragePagedListMeta<Prefix, Value, ValuesPerNewPage>;
+
+	fn iter() -> Self::Iterator {
+		StoragePagedListIterator::from_meta(Self::read_meta(), false)
+	}
+
+	fn drain() -> Self::Iterator {
+		StoragePagedListIterator::from_meta(Self::read_meta(), true)
+	}
+
+	fn appender() -> Self::Appender {
+		Self::appender()
+	}
+}
+
+impl<Prefix, Value, ValuesPerNewPage> StoragePagedList<Prefix, Value, ValuesPerNewPage>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	ValuesPerNewPage: Get<u32>,
+{
+	fn read_meta() -> StoragePagedListMeta<Prefix, Value, ValuesPerNewPage> {
+		// Use default here to not require a setup migration.
+		StoragePagedListMeta::from_storage().unwrap_or_default()
+	}
+
+	/// Provides a fast append iterator.
+	///
+	/// The list should not be modified while appending. Also don't call it recursively.
+	fn appender() -> StoragePagedListMeta<Prefix, Value, ValuesPerNewPage> {
+		Self::read_meta()
+	}
+
+	/// Return the elements of the list.
+	#[cfg(test)]
+	fn as_vec() -> Vec<Value> {
+		<Self as frame_support::storage::StorageList<_>>::iter().collect()
+	}
+
+	/// Return and remove the elements of the list.
+	#[cfg(test)]
+	fn as_drained_vec() -> Vec<Value> {
+		<Self as frame_support::storage::StorageList<_>>::drain().collect()
+	}
+}
+
+/// Provides the final prefix for a [`StoragePagedList`].
+///
+/// It solely exists so that when re-using it from the iterator and meta struct, none of the un-used
+/// generics bleed through. Otherwise when only having the `StoragePrefixedContainer` implementation
+/// on the list directly, the iterator and metadata need to muster *all* generics, even the ones
+/// that are completely useless for prefix calculation.
+struct StoragePagedListPrefix<Prefix>(PhantomData<Prefix>);
+
+impl<Prefix> frame_support::storage::StoragePrefixedContainer for StoragePagedListPrefix<Prefix>
+where
+	Prefix: StorageInstance,
+{
+	fn module_prefix() -> &'static [u8] {
+		Prefix::pallet_prefix().as_bytes()
+	}
+
+	fn storage_prefix() -> &'static [u8] {
+		Prefix::STORAGE_PREFIX.as_bytes()
+	}
+}
+
+impl<Prefix, Value, ValuesPerNewPage> frame_support::storage::StoragePrefixedContainer
+	for StoragePagedList<Prefix, Value, ValuesPerNewPage>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	ValuesPerNewPage: Get<u32>,
+{
+	fn module_prefix() -> &'static [u8] {
+		StoragePagedListPrefix::<Prefix>::module_prefix()
+	}
+
+	fn storage_prefix() -> &'static [u8] {
+		StoragePagedListPrefix::<Prefix>::storage_prefix()
+	}
+}
+
+/// Prelude for (doc)tests.
+#[cfg(feature = "std")]
+#[allow(dead_code)]
+pub(crate) mod mock {
+	pub use super::*;
+	pub use frame_support::{
+		parameter_types,
+		storage::{types::ValueQuery, StorageList as _},
+		StorageNoopGuard,
+	};
+	pub use sp_io::{hashing::twox_128, TestExternalities};
+	pub use sp_metadata_ir::{StorageEntryModifierIR, StorageEntryTypeIR, StorageHasherIR};
+
+	parameter_types! {
+		pub const ValuesPerNewPage: u32 = 5;
+		pub const MaxPages: Option<u32> = Some(20);
+	}
+
+	pub struct Prefix;
+	impl StorageInstance for Prefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "foo";
+	}
+
+	pub type List = StoragePagedList<Prefix, u32, ValuesPerNewPage>;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::mock::*;
+
+	#[test]
+	fn append_works() {
+		TestExternalities::default().execute_with(|| {
+			List::append_many(0..1000);
+			assert_eq!(List::as_vec(), (0..1000).collect::<Vec<_>>());
+		});
+	}
+
+	/// Draining all works.
+	#[test]
+	fn simple_drain_works() {
+		TestExternalities::default().execute_with(|| {
+			let _g = StorageNoopGuard::default(); // All in all a No-Op
+			List::append_many(0..1000);
+
+			assert_eq!(List::as_drained_vec(), (0..1000).collect::<Vec<_>>());
+
+			assert_eq!(List::read_meta(), Default::default());
+
+			// all gone
+			assert_eq!(List::as_vec(), Vec::<u32>::new());
+			// Need to delete the metadata manually.
+			StoragePagedListMeta::<Prefix, u32, ValuesPerNewPage>::delete();
+		});
+	}
+
+	/// Drain half of the elements and iterator the rest.
+	#[test]
+	fn partial_drain_works() {
+		TestExternalities::default().execute_with(|| {
+			List::append_many(0..100);
+
+			let vals = List::drain().take(50).collect::<Vec<_>>();
+			assert_eq!(vals, (0..50).collect::<Vec<_>>());
+
+			let meta = List::read_meta();
+			// Will switch over to `10/0`, but will in the next call.
+			assert_eq!((meta.first_page, meta.first_value_offset), (10, 0));
+
+			// 50 gone, 50 to go
+			assert_eq!(List::as_vec(), (50..100).collect::<Vec<_>>());
+		});
+	}
+
+	/// Draining, appending and iterating work together.
+	#[test]
+	fn drain_append_iter_works() {
+		TestExternalities::default().execute_with(|| {
+			for r in 1..=100 {
+				List::append_many(0..12);
+				List::append_many(0..12);
+
+				let dropped = List::drain().take(12).collect::<Vec<_>>();
+				assert_eq!(dropped, (0..12).collect::<Vec<_>>());
+
+				assert_eq!(List::as_vec(), (0..12).cycle().take(r * 12).collect::<Vec<_>>());
+			}
+		});
+	}
+
+	/// Pages are removed ASAP.
+	#[test]
+	fn drain_eager_page_removal() {
+		TestExternalities::default().execute_with(|| {
+			List::append_many(0..9);
+
+			assert!(sp_io::storage::exists(&page_key::<Prefix>(0)));
+			assert!(sp_io::storage::exists(&page_key::<Prefix>(1)));
+
+			assert_eq!(List::drain().take(5).count(), 5);
+			// Page 0 is eagerly removed.
+			assert!(!sp_io::storage::exists(&page_key::<Prefix>(0)));
+			assert!(sp_io::storage::exists(&page_key::<Prefix>(1)));
+		});
+	}
+
+	/// Appending encodes pages as `Vec`.
+	#[test]
+	fn append_storage_layout() {
+		TestExternalities::default().execute_with(|| {
+			List::append_many(0..9);
+
+			let key = page_key::<Prefix>(0);
+			let raw = sp_io::storage::get(&key).expect("Page should be present");
+			let as_vec = Vec::<u32>::decode(&mut &raw[..]).unwrap();
+			assert_eq!(as_vec.len(), 5, "First page contains 5");
+
+			let key = page_key::<Prefix>(1);
+			let raw = sp_io::storage::get(&key).expect("Page should be present");
+			let as_vec = Vec::<u32>::decode(&mut &raw[..]).unwrap();
+			assert_eq!(as_vec.len(), 4, "Second page contains 4");
+
+			let meta = sp_io::storage::get(&meta_key::<Prefix>()).expect("Meta should be present");
+			let meta: StoragePagedListMeta<Prefix, u32, ValuesPerNewPage> =
+				Decode::decode(&mut &meta[..]).unwrap();
+			assert_eq!(meta.first_page, 0);
+			assert_eq!(meta.first_value_offset, 0);
+			assert_eq!(meta.last_page, 1);
+			assert_eq!(meta.last_page_len, 4);
+
+			let page = Page::<u32>::from_storage::<Prefix>(0, 0).unwrap();
+			assert_eq!(page.index, 0);
+			assert_eq!(page.values.count(), 5);
+
+			let page = Page::<u32>::from_storage::<Prefix>(1, 0).unwrap();
+			assert_eq!(page.index, 1);
+			assert_eq!(page.values.count(), 4);
+		});
+	}
+
+	#[test]
+	fn page_key_correct() {
+		let got = page_key::<Prefix>(0);
+		let pallet_prefix = StoragePagedListPrefix::<Prefix>::final_prefix();
+		let want = (pallet_prefix, b"page", 0).encode();
+
+		assert_eq!(want.len(), 32 + 4 + 4);
+		assert!(want.starts_with(&pallet_prefix[..]));
+		assert_eq!(got, want);
+	}
+
+	#[test]
+	fn meta_key_correct() {
+		let got = meta_key::<Prefix>();
+		let pallet_prefix = StoragePagedListPrefix::<Prefix>::final_prefix();
+		let want = (pallet_prefix, b"meta").encode();
+
+		assert_eq!(want.len(), 32 + 4);
+		assert!(want.starts_with(&pallet_prefix[..]));
+		assert_eq!(got, want);
+	}
+
+	#[test]
+	fn peekable_drain_also_deletes() {
+		TestExternalities::default().execute_with(|| {
+			List::append_many(0..10);
+
+			let mut iter = List::drain().peekable();
+			assert_eq!(iter.peek(), Some(&0));
+			// `peek` does remove one element...
+			assert_eq!(List::iter().count(), 9);
+		});
+	}
+}
diff --git a/substrate/frame/paged-list/src/tests.rs b/substrate/frame/paged-list/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..becb4b23508eff700c9d153fbd7e91efa8006ab4
--- /dev/null
+++ b/substrate/frame/paged-list/src/tests.rs
@@ -0,0 +1,108 @@
+// 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.
+
+//! Mostly pallet doc-tests. Real tests are in [`super::paged_list`] and crate
+//! `pallet-paged-list-fuzzer`.
+
+#![cfg(test)]
+
+use crate::{mock::*, *};
+use frame_support::storage::{StorageList, StoragePrefixedContainer};
+
+#[docify::export]
+#[test]
+fn append_one_works() {
+	test_closure(|| {
+		PagedList::append_one(1);
+
+		assert_eq!(PagedList::iter().collect::<Vec<_>>(), vec![1]);
+	});
+}
+
+#[docify::export]
+#[test]
+fn append_many_works() {
+	test_closure(|| {
+		PagedList::append_many(0..3);
+
+		assert_eq!(PagedList::iter().collect::<Vec<_>>(), vec![0, 1, 2]);
+	});
+}
+
+#[docify::export]
+#[test]
+fn appender_works() {
+	use frame_support::storage::StorageAppender;
+	test_closure(|| {
+		let mut appender = PagedList::appender();
+
+		appender.append(0);
+		appender.append(1); // Repeated calls are fine here.
+		appender.append_many(2..4);
+
+		assert_eq!(PagedList::iter().collect::<Vec<_>>(), vec![0, 1, 2, 3]);
+	});
+}
+
+#[docify::export]
+#[test]
+fn iter_works() {
+	test_closure(|| {
+		PagedList::append_many(0..10);
+		let mut iter = PagedList::iter();
+
+		assert_eq!(iter.next(), Some(0));
+		assert_eq!(iter.next(), Some(1));
+		assert_eq!(iter.collect::<Vec<_>>(), (2..10).collect::<Vec<_>>());
+	});
+}
+
+#[docify::export]
+#[test]
+fn drain_works() {
+	test_closure(|| {
+		PagedList::append_many(0..3);
+		PagedList::drain().next();
+		assert_eq!(PagedList::iter().collect::<Vec<_>>(), vec![1, 2], "0 is drained");
+		PagedList::drain().peekable().peek();
+		assert_eq!(PagedList::iter().collect::<Vec<_>>(), vec![2], "Peeking removed 1");
+	});
+}
+
+#[test]
+fn iter_independent_works() {
+	test_closure(|| {
+		PagedList::append_many(0..1000);
+		PagedList2::append_many(0..1000);
+
+		assert_eq!(PagedList::iter().collect::<Vec<_>>(), (0..1000).collect::<Vec<_>>());
+		assert_eq!(PagedList::iter().collect::<Vec<_>>(), (0..1000).collect::<Vec<_>>());
+
+		// drain
+		assert_eq!(PagedList::drain().collect::<Vec<_>>(), (0..1000).collect::<Vec<_>>());
+		assert_eq!(PagedList2::iter().collect::<Vec<_>>(), (0..1000).collect::<Vec<_>>());
+
+		assert_eq!(PagedList::iter().count(), 0);
+	});
+}
+
+#[test]
+fn prefix_distinct() {
+	let p1 = List::<Test, ()>::final_prefix();
+	let p2 = List::<Test, crate::Instance2>::final_prefix();
+	assert_ne!(p1, p2);
+}
diff --git a/substrate/frame/preimage/Cargo.toml b/substrate/frame/preimage/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f9ba45cedab2a9cb13f80d7d36d6098f1562beb0
--- /dev/null
+++ b/substrate/frame/preimage/Cargo.toml
@@ -0,0 +1,55 @@
+[package]
+name = "pallet-preimage"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for storing preimages of hashes"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, optional = true, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/preimage/src/benchmarking.rs b/substrate/frame/preimage/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b719c28be641bb3d57086798e1cd694c826dc317
--- /dev/null
+++ b/substrate/frame/preimage/src/benchmarking.rs
@@ -0,0 +1,225 @@
+// 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.
+
+//! Preimage pallet benchmarking.
+
+use super::*;
+use frame_benchmarking::v1::{account, benchmarks, whitelist_account, BenchmarkError};
+use frame_support::assert_ok;
+use frame_system::RawOrigin;
+use sp_runtime::traits::Bounded;
+use sp_std::{prelude::*, vec};
+
+use crate::Pallet as Preimage;
+
+const SEED: u32 = 0;
+
+fn funded_account<T: Config>(name: &'static str, index: u32) -> T::AccountId {
+	let caller: T::AccountId = account(name, index, SEED);
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+	caller
+}
+
+fn preimage_and_hash<T: Config>() -> (Vec<u8>, T::Hash) {
+	sized_preimage_and_hash::<T>(MAX_SIZE)
+}
+
+fn sized_preimage_and_hash<T: Config>(size: u32) -> (Vec<u8>, T::Hash) {
+	let mut preimage = vec![];
+	preimage.resize(size as usize, 0);
+	let hash = <T as frame_system::Config>::Hashing::hash(&preimage[..]);
+	(preimage, hash)
+}
+
+benchmarks! {
+	// Expensive note - will reserve.
+	note_preimage {
+		let s in 0 .. MAX_SIZE;
+		let caller = funded_account::<T>("caller", 0);
+		whitelist_account!(caller);
+		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
+	}: _(RawOrigin::Signed(caller), preimage)
+	verify {
+		assert!(Preimage::<T>::have_preimage(&hash));
+	}
+	// Cheap note - will not reserve since it was requested.
+	note_requested_preimage {
+		let s in 0 .. MAX_SIZE;
+		let caller = funded_account::<T>("caller", 0);
+		whitelist_account!(caller);
+		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
+		assert_ok!(Preimage::<T>::request_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			hash,
+		));
+	}: note_preimage(RawOrigin::Signed(caller), preimage)
+	verify {
+		assert!(Preimage::<T>::have_preimage(&hash));
+	}
+	// Cheap note - will not reserve since it's the manager.
+	note_no_deposit_preimage {
+		let s in 0 .. MAX_SIZE;
+		let (preimage, hash) = sized_preimage_and_hash::<T>(s);
+		assert_ok!(Preimage::<T>::request_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			hash,
+		));
+	}: note_preimage<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		preimage
+	) verify {
+		assert!(Preimage::<T>::have_preimage(&hash));
+	}
+
+	// Expensive unnote - will unreserve.
+	unnote_preimage {
+		let caller = funded_account::<T>("caller", 0);
+		whitelist_account!(caller);
+		let (preimage, hash) = preimage_and_hash::<T>();
+		assert_ok!(Preimage::<T>::note_preimage(RawOrigin::Signed(caller.clone()).into(), preimage));
+	}: _(RawOrigin::Signed(caller), hash)
+	verify {
+		assert!(!Preimage::<T>::have_preimage(&hash));
+	}
+	// Cheap unnote - will not unreserve since there's no deposit held.
+	unnote_no_deposit_preimage {
+		let (preimage, hash) = preimage_and_hash::<T>();
+		assert_ok!(Preimage::<T>::note_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			preimage,
+		));
+	}: unnote_preimage<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		assert!(!Preimage::<T>::have_preimage(&hash));
+	}
+
+	// Expensive request - will unreserve the noter's deposit.
+	request_preimage {
+		let (preimage, hash) = preimage_and_hash::<T>();
+		let noter = funded_account::<T>("noter", 0);
+		whitelist_account!(noter);
+		assert_ok!(Preimage::<T>::note_preimage(RawOrigin::Signed(noter.clone()).into(), preimage));
+	}: _<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		let deposit = T::BaseDeposit::get() + T::ByteDeposit::get() * MAX_SIZE.into();
+		let s = RequestStatus::Requested { deposit: Some((noter, deposit)), count: 1, len: Some(MAX_SIZE) };
+		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+	}
+	// Cheap request - would unreserve the deposit but none was held.
+	request_no_deposit_preimage {
+		let (preimage, hash) = preimage_and_hash::<T>();
+		assert_ok!(Preimage::<T>::note_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			preimage,
+		));
+	}: request_preimage<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		let s = RequestStatus::Requested { deposit: None, count: 2, len: Some(MAX_SIZE) };
+		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+	}
+	// Cheap request - the preimage is not yet noted, so deposit to unreserve.
+	request_unnoted_preimage {
+		let (_, hash) = preimage_and_hash::<T>();
+	}: request_preimage<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		let s = RequestStatus::Requested { deposit: None, count: 1, len: None };
+		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+	}
+	// Cheap request - the preimage is already requested, so just a counter bump.
+	request_requested_preimage {
+		let (_, hash) = preimage_and_hash::<T>();
+		assert_ok!(Preimage::<T>::request_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			hash,
+		));
+	}: request_preimage<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		let s = RequestStatus::Requested { deposit: None, count: 2, len: None };
+		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+	}
+
+	// Expensive unrequest - last reference and it's noted, so will destroy the preimage.
+	unrequest_preimage {
+		let (preimage, hash) = preimage_and_hash::<T>();
+		assert_ok!(Preimage::<T>::request_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			hash,
+		));
+		assert_ok!(Preimage::<T>::note_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			preimage,
+		));
+	}: _<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		assert_eq!(StatusFor::<T>::get(&hash), None);
+	}
+	// Cheap unrequest - last reference, but it's not noted.
+	unrequest_unnoted_preimage {
+		let (_, hash) = preimage_and_hash::<T>();
+		assert_ok!(Preimage::<T>::request_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			hash,
+		));
+	}: unrequest_preimage<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		assert_eq!(StatusFor::<T>::get(&hash), None);
+	}
+	// Cheap unrequest - not the last reference.
+	unrequest_multi_referenced_preimage {
+		let (_, hash) = preimage_and_hash::<T>();
+		assert_ok!(Preimage::<T>::request_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			hash,
+		));
+		assert_ok!(Preimage::<T>::request_preimage(
+			T::ManagerOrigin::try_successful_origin()
+				.expect("ManagerOrigin has no successful origin required for the benchmark"),
+			hash,
+		));
+	}: unrequest_preimage<T::RuntimeOrigin>(
+		T::ManagerOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		hash
+	) verify {
+		let s = RequestStatus::Requested { deposit: None, count: 1, len: None };
+		assert_eq!(StatusFor::<T>::get(&hash), Some(s));
+	}
+
+	impl_benchmark_test_suite!(Preimage, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/preimage/src/lib.rs b/substrate/frame/preimage/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5ab1e7643b2e7150c1a2f166f4ffcabf69fef882
--- /dev/null
+++ b/substrate/frame/preimage/src/lib.rs
@@ -0,0 +1,459 @@
+// 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.
+
+//! # Preimage Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! The Preimage pallet allows for the users and the runtime to store the preimage
+//! of a hash on chain. This can be used by other pallets for storing and managing
+//! large byte-blobs.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod migration;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use sp_runtime::traits::{BadOrigin, Hash, Saturating};
+use sp_std::{borrow::Cow, prelude::*};
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::Pays,
+	ensure,
+	pallet_prelude::Get,
+	traits::{
+		Currency, Defensive, FetchResult, Hash as PreimageHash, PreimageProvider,
+		PreimageRecipient, QueryPreimage, ReservableCurrency, StorePreimage,
+	},
+	BoundedSlice, BoundedVec,
+};
+use scale_info::TypeInfo;
+pub use weights::WeightInfo;
+
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+pub use pallet::*;
+
+/// A type to note whether a preimage is owned by a user or the system.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub enum RequestStatus<AccountId, Balance> {
+	/// The associated preimage has not yet been requested by the system. The given deposit (if
+	/// some) is being held until either it becomes requested or the user retracts the preimage.
+	Unrequested { deposit: (AccountId, Balance), len: u32 },
+	/// There are a non-zero number of outstanding requests for this hash by this chain. If there
+	/// is a preimage registered, then `len` is `Some` and it may be removed iff this counter
+	/// becomes zero.
+	Requested { deposit: Option<(AccountId, Balance)>, count: u32, len: Option<u32> },
+}
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+/// Maximum size of preimage we can store is 4mb.
+const MAX_SIZE: u32 = 4 * 1024 * 1024;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The Weight information for this pallet.
+		type WeightInfo: weights::WeightInfo;
+
+		/// Currency type for this pallet.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// An origin that can request a preimage be placed on-chain without a deposit or fee, or
+		/// manage existing preimages.
+		type ManagerOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The base deposit for placing a preimage on chain.
+		type BaseDeposit: Get<BalanceOf<Self>>;
+
+		/// The per-byte deposit for placing a preimage on chain.
+		type ByteDeposit: Get<BalanceOf<Self>>;
+	}
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A preimage has been noted.
+		Noted { hash: T::Hash },
+		/// A preimage has been requested.
+		Requested { hash: T::Hash },
+		/// A preimage has ben cleared.
+		Cleared { hash: T::Hash },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Preimage is too large to store on-chain.
+		TooBig,
+		/// Preimage has already been noted on-chain.
+		AlreadyNoted,
+		/// The user is not authorized to perform this action.
+		NotAuthorized,
+		/// The preimage cannot be removed since it has not yet been noted.
+		NotNoted,
+		/// A preimage may not be removed when there are outstanding requests.
+		Requested,
+		/// The preimage request cannot be removed since no outstanding requests exist.
+		NotRequested,
+	}
+
+	/// The request status of a given hash.
+	#[pallet::storage]
+	pub(super) type StatusFor<T: Config> =
+		StorageMap<_, Identity, T::Hash, RequestStatus<T::AccountId, BalanceOf<T>>>;
+
+	#[pallet::storage]
+	pub(super) type PreimageFor<T: Config> =
+		StorageMap<_, Identity, (T::Hash, u32), BoundedVec<u8, ConstU32<MAX_SIZE>>>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Register a preimage on-chain.
+		///
+		/// If the preimage was previously requested, no fees or deposits are taken for providing
+		/// the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::note_preimage(bytes.len() as u32))]
+		pub fn note_preimage(origin: OriginFor<T>, bytes: Vec<u8>) -> DispatchResultWithPostInfo {
+			// We accept a signed origin which will pay a deposit, or a root origin where a deposit
+			// is not taken.
+			let maybe_sender = Self::ensure_signed_or_manager(origin)?;
+			let (system_requested, _) = Self::note_bytes(bytes.into(), maybe_sender.as_ref())?;
+			if system_requested || maybe_sender.is_none() {
+				Ok(Pays::No.into())
+			} else {
+				Ok(().into())
+			}
+		}
+
+		/// Clear an unrequested preimage from the runtime storage.
+		///
+		/// If `len` is provided, then it will be a much cheaper operation.
+		///
+		/// - `hash`: The hash of the preimage to be removed from the store.
+		/// - `len`: The length of the preimage of `hash`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::unnote_preimage())]
+		pub fn unnote_preimage(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
+			let maybe_sender = Self::ensure_signed_or_manager(origin)?;
+			Self::do_unnote_preimage(&hash, maybe_sender)
+		}
+
+		/// Request a preimage be uploaded to the chain without paying any fees or deposits.
+		///
+		/// If the preimage requests has already been provided on-chain, we unreserve any deposit
+		/// a user may have paid, and take the control of the preimage out of their hands.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::request_preimage())]
+		pub fn request_preimage(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
+			T::ManagerOrigin::ensure_origin(origin)?;
+			Self::do_request_preimage(&hash);
+			Ok(())
+		}
+
+		/// Clear a previously made request for a preimage.
+		///
+		/// NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::unrequest_preimage())]
+		pub fn unrequest_preimage(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
+			T::ManagerOrigin::ensure_origin(origin)?;
+			Self::do_unrequest_preimage(&hash)
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Ensure that the origin is either the `ManagerOrigin` or a signed origin.
+	fn ensure_signed_or_manager(
+		origin: T::RuntimeOrigin,
+	) -> Result<Option<T::AccountId>, BadOrigin> {
+		if T::ManagerOrigin::ensure_origin(origin.clone()).is_ok() {
+			return Ok(None)
+		}
+		let who = ensure_signed(origin)?;
+		Ok(Some(who))
+	}
+
+	/// Store some preimage on chain.
+	///
+	/// If `maybe_depositor` is `None` then it is also requested. If `Some`, then it is not.
+	///
+	/// We verify that the preimage is within the bounds of what the pallet supports.
+	///
+	/// If the preimage was requested to be uploaded, then the user pays no deposits or tx fees.
+	fn note_bytes(
+		preimage: Cow<[u8]>,
+		maybe_depositor: Option<&T::AccountId>,
+	) -> Result<(bool, T::Hash), DispatchError> {
+		let hash = T::Hashing::hash(&preimage);
+		let len = preimage.len() as u32;
+		ensure!(len <= MAX_SIZE, Error::<T>::TooBig);
+
+		// We take a deposit only if there is a provided depositor and the preimage was not
+		// previously requested. This also allows the tx to pay no fee.
+		let status = match (StatusFor::<T>::get(hash), maybe_depositor) {
+			(Some(RequestStatus::Requested { count, deposit, .. }), _) =>
+				RequestStatus::Requested { count, deposit, len: Some(len) },
+			(Some(RequestStatus::Unrequested { .. }), Some(_)) =>
+				return Err(Error::<T>::AlreadyNoted.into()),
+			(Some(RequestStatus::Unrequested { len, deposit }), None) =>
+				RequestStatus::Requested { deposit: Some(deposit), count: 1, len: Some(len) },
+			(None, None) => RequestStatus::Requested { count: 1, len: Some(len), deposit: None },
+			(None, Some(depositor)) => {
+				let length = preimage.len() as u32;
+				let deposit = T::BaseDeposit::get()
+					.saturating_add(T::ByteDeposit::get().saturating_mul(length.into()));
+				T::Currency::reserve(depositor, deposit)?;
+				RequestStatus::Unrequested { deposit: (depositor.clone(), deposit), len }
+			},
+		};
+		let was_requested = matches!(status, RequestStatus::Requested { .. });
+		StatusFor::<T>::insert(hash, status);
+
+		let _ = Self::insert(&hash, preimage)
+			.defensive_proof("Unable to insert. Logic error in `note_bytes`?");
+
+		Self::deposit_event(Event::Noted { hash });
+
+		Ok((was_requested, hash))
+	}
+
+	// This function will add a hash to the list of requested preimages.
+	//
+	// If the preimage already exists before the request is made, the deposit for the preimage is
+	// returned to the user, and removed from their management.
+	fn do_request_preimage(hash: &T::Hash) {
+		let (count, len, deposit) =
+			StatusFor::<T>::get(hash).map_or((1, None, None), |x| match x {
+				RequestStatus::Requested { mut count, len, deposit } => {
+					count.saturating_inc();
+					(count, len, deposit)
+				},
+				RequestStatus::Unrequested { deposit, len } => (1, Some(len), Some(deposit)),
+			});
+		StatusFor::<T>::insert(hash, RequestStatus::Requested { count, len, deposit });
+		if count == 1 {
+			Self::deposit_event(Event::Requested { hash: *hash });
+		}
+	}
+
+	// Clear a preimage from the storage of the chain, returning any deposit that may be reserved.
+	//
+	// If `len` is provided, it will be a much cheaper operation.
+	//
+	// If `maybe_owner` is provided, we verify that it is the correct owner before clearing the
+	// data.
+	fn do_unnote_preimage(
+		hash: &T::Hash,
+		maybe_check_owner: Option<T::AccountId>,
+	) -> DispatchResult {
+		match StatusFor::<T>::get(hash).ok_or(Error::<T>::NotNoted)? {
+			RequestStatus::Requested { deposit: Some((owner, deposit)), count, len } => {
+				ensure!(maybe_check_owner.map_or(true, |c| c == owner), Error::<T>::NotAuthorized);
+				T::Currency::unreserve(&owner, deposit);
+				StatusFor::<T>::insert(
+					hash,
+					RequestStatus::Requested { deposit: None, count, len },
+				);
+				Ok(())
+			},
+			RequestStatus::Requested { deposit: None, .. } => {
+				ensure!(maybe_check_owner.is_none(), Error::<T>::NotAuthorized);
+				Self::do_unrequest_preimage(hash)
+			},
+			RequestStatus::Unrequested { deposit: (owner, deposit), len } => {
+				ensure!(maybe_check_owner.map_or(true, |c| c == owner), Error::<T>::NotAuthorized);
+				T::Currency::unreserve(&owner, deposit);
+				StatusFor::<T>::remove(hash);
+
+				Self::remove(hash, len);
+				Self::deposit_event(Event::Cleared { hash: *hash });
+				Ok(())
+			},
+		}
+	}
+
+	/// Clear a preimage request.
+	fn do_unrequest_preimage(hash: &T::Hash) -> DispatchResult {
+		match StatusFor::<T>::get(hash).ok_or(Error::<T>::NotRequested)? {
+			RequestStatus::Requested { mut count, len, deposit } if count > 1 => {
+				count.saturating_dec();
+				StatusFor::<T>::insert(hash, RequestStatus::Requested { count, len, deposit });
+			},
+			RequestStatus::Requested { count, len, deposit } => {
+				debug_assert!(count == 1, "preimage request counter at zero?");
+				match (len, deposit) {
+					// Preimage was never noted.
+					(None, _) => StatusFor::<T>::remove(hash),
+					// Preimage was noted without owner - just remove it.
+					(Some(len), None) => {
+						Self::remove(hash, len);
+						StatusFor::<T>::remove(hash);
+						Self::deposit_event(Event::Cleared { hash: *hash });
+					},
+					// Preimage was noted with owner - move to unrequested so they can get refund.
+					(Some(len), Some(deposit)) => {
+						StatusFor::<T>::insert(hash, RequestStatus::Unrequested { deposit, len });
+					},
+				}
+			},
+			RequestStatus::Unrequested { .. } => return Err(Error::<T>::NotRequested.into()),
+		}
+		Ok(())
+	}
+
+	fn insert(hash: &T::Hash, preimage: Cow<[u8]>) -> Result<(), ()> {
+		BoundedSlice::<u8, ConstU32<MAX_SIZE>>::try_from(preimage.as_ref())
+			.map_err(|_| ())
+			.map(|s| PreimageFor::<T>::insert((hash, s.len() as u32), s))
+	}
+
+	fn remove(hash: &T::Hash, len: u32) {
+		PreimageFor::<T>::remove((hash, len))
+	}
+
+	fn have(hash: &T::Hash) -> bool {
+		Self::len(hash).is_some()
+	}
+
+	fn len(hash: &T::Hash) -> Option<u32> {
+		use RequestStatus::*;
+		match StatusFor::<T>::get(hash) {
+			Some(Requested { len: Some(len), .. }) | Some(Unrequested { len, .. }) => Some(len),
+			_ => None,
+		}
+	}
+
+	fn fetch(hash: &T::Hash, len: Option<u32>) -> FetchResult {
+		let len = len.or_else(|| Self::len(hash)).ok_or(DispatchError::Unavailable)?;
+		PreimageFor::<T>::get((hash, len))
+			.map(|p| p.into_inner())
+			.map(Into::into)
+			.ok_or(DispatchError::Unavailable)
+	}
+}
+
+impl<T: Config> PreimageProvider<T::Hash> for Pallet<T> {
+	fn have_preimage(hash: &T::Hash) -> bool {
+		Self::have(hash)
+	}
+
+	fn preimage_requested(hash: &T::Hash) -> bool {
+		matches!(StatusFor::<T>::get(hash), Some(RequestStatus::Requested { .. }))
+	}
+
+	fn get_preimage(hash: &T::Hash) -> Option<Vec<u8>> {
+		Self::fetch(hash, None).ok().map(Cow::into_owned)
+	}
+
+	fn request_preimage(hash: &T::Hash) {
+		Self::do_request_preimage(hash)
+	}
+
+	fn unrequest_preimage(hash: &T::Hash) {
+		let res = Self::do_unrequest_preimage(hash);
+		debug_assert!(res.is_ok(), "do_unrequest_preimage failed - counter underflow?");
+	}
+}
+
+impl<T: Config> PreimageRecipient<T::Hash> for Pallet<T> {
+	type MaxSize = ConstU32<MAX_SIZE>; // 2**22
+
+	fn note_preimage(bytes: BoundedVec<u8, Self::MaxSize>) {
+		// We don't really care if this fails, since that's only the case if someone else has
+		// already noted it.
+		let _ = Self::note_bytes(bytes.into_inner().into(), None);
+	}
+
+	fn unnote_preimage(hash: &T::Hash) {
+		// Should never fail if authorization check is skipped.
+		let res = Self::do_unrequest_preimage(hash);
+		debug_assert!(res.is_ok(), "unnote_preimage failed - request outstanding?");
+	}
+}
+
+impl<T: Config<Hash = PreimageHash>> QueryPreimage for Pallet<T> {
+	fn len(hash: &T::Hash) -> Option<u32> {
+		Pallet::<T>::len(hash)
+	}
+
+	fn fetch(hash: &T::Hash, len: Option<u32>) -> FetchResult {
+		Pallet::<T>::fetch(hash, len)
+	}
+
+	fn is_requested(hash: &T::Hash) -> bool {
+		matches!(StatusFor::<T>::get(hash), Some(RequestStatus::Requested { .. }))
+	}
+
+	fn request(hash: &T::Hash) {
+		Self::do_request_preimage(hash)
+	}
+
+	fn unrequest(hash: &T::Hash) {
+		let res = Self::do_unrequest_preimage(hash);
+		debug_assert!(res.is_ok(), "do_unrequest_preimage failed - counter underflow?");
+	}
+}
+
+impl<T: Config<Hash = PreimageHash>> StorePreimage for Pallet<T> {
+	const MAX_LENGTH: usize = MAX_SIZE as usize;
+
+	fn note(bytes: Cow<[u8]>) -> Result<T::Hash, DispatchError> {
+		// We don't really care if this fails, since that's only the case if someone else has
+		// already noted it.
+		let maybe_hash = Self::note_bytes(bytes, None).map(|(_, h)| h);
+		// Map to the correct trait error.
+		if maybe_hash == Err(DispatchError::from(Error::<T>::TooBig)) {
+			Err(DispatchError::Exhausted)
+		} else {
+			maybe_hash
+		}
+	}
+
+	fn unnote(hash: &T::Hash) {
+		// Should never fail if authorization check is skipped.
+		let res = Self::do_unnote_preimage(hash, None);
+		debug_assert!(res.is_ok(), "unnote_preimage failed - request outstanding?");
+	}
+}
diff --git a/substrate/frame/preimage/src/migration.rs b/substrate/frame/preimage/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0f3337e39bf50ff742ef8a1d658e86f61939b856
--- /dev/null
+++ b/substrate/frame/preimage/src/migration.rs
@@ -0,0 +1,268 @@
+// 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.
+
+//! Storage migrations for the preimage pallet.
+
+use super::*;
+use frame_support::{
+	storage_alias,
+	traits::{ConstU32, OnRuntimeUpgrade},
+};
+use sp_std::collections::btree_map::BTreeMap;
+
+#[cfg(feature = "try-runtime")]
+use frame_support::ensure;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// The log target.
+const TARGET: &'static str = "runtime::preimage::migration::v1";
+
+/// The original data layout of the preimage pallet without a specific version number.
+mod v0 {
+	use super::*;
+
+	#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+	pub enum RequestStatus<AccountId, Balance> {
+		Unrequested(Option<(AccountId, Balance)>),
+		Requested(u32),
+	}
+
+	#[storage_alias]
+	pub type PreimageFor<T: Config> = StorageMap<
+		Pallet<T>,
+		Identity,
+		<T as frame_system::Config>::Hash,
+		BoundedVec<u8, ConstU32<MAX_SIZE>>,
+	>;
+
+	#[storage_alias]
+	pub type StatusFor<T: Config> = StorageMap<
+		Pallet<T>,
+		Identity,
+		<T as frame_system::Config>::Hash,
+		RequestStatus<<T as frame_system::Config>::AccountId, BalanceOf<T>>,
+	>;
+
+	/// Returns the number of images or `None` if the storage is corrupted.
+	#[cfg(feature = "try-runtime")]
+	pub fn image_count<T: Config>() -> Option<u32> {
+		let images = v0::PreimageFor::<T>::iter_values().count() as u32;
+		let status = v0::StatusFor::<T>::iter_values().count() as u32;
+
+		if images == status {
+			Some(images)
+		} else {
+			None
+		}
+	}
+}
+
+pub mod v1 {
+	use super::*;
+
+	/// Migration for moving preimage from V0 to V1 storage.
+	///
+	/// Note: This needs to be run with the same hashing algorithm as before
+	/// since it is not re-hashing the preimages.
+	pub struct Migration<T>(sp_std::marker::PhantomData<T>);
+
+	impl<T: Config> OnRuntimeUpgrade for Migration<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			ensure!(StorageVersion::get::<Pallet<T>>() == 0, "can only upgrade from version 0");
+
+			let images = v0::image_count::<T>().expect("v0 storage corrupted");
+			log::info!(target: TARGET, "Migrating {} images", &images);
+			Ok((images as u32).encode())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			let mut weight = T::DbWeight::get().reads(1);
+			if StorageVersion::get::<Pallet<T>>() != 0 {
+				log::warn!(
+					target: TARGET,
+					"skipping MovePreimagesIntoBuckets: executed on wrong storage version.\
+				Expected version 0"
+				);
+				return weight
+			}
+
+			let status = v0::StatusFor::<T>::drain().collect::<Vec<_>>();
+			weight.saturating_accrue(T::DbWeight::get().reads(status.len() as u64));
+
+			let preimages = v0::PreimageFor::<T>::drain().collect::<BTreeMap<_, _>>();
+			weight.saturating_accrue(T::DbWeight::get().reads(preimages.len() as u64));
+
+			for (hash, status) in status.into_iter() {
+				let preimage = if let Some(preimage) = preimages.get(&hash) {
+					preimage
+				} else {
+					log::error!(target: TARGET, "preimage not found for hash {:?}", &hash);
+					continue
+				};
+				let len = preimage.len() as u32;
+				if len > MAX_SIZE {
+					log::error!(
+						target: TARGET,
+						"preimage too large for hash {:?}, len: {}",
+						&hash,
+						len
+					);
+					continue
+				}
+
+				let status = match status {
+					v0::RequestStatus::Unrequested(deposit) => match deposit {
+						Some(deposit) => RequestStatus::Unrequested { deposit, len },
+						// `None` depositor becomes system-requested.
+						None =>
+							RequestStatus::Requested { deposit: None, count: 1, len: Some(len) },
+					},
+					v0::RequestStatus::Requested(count) if count == 0 => {
+						log::error!(target: TARGET, "preimage has counter of zero: {:?}", hash);
+						continue
+					},
+					v0::RequestStatus::Requested(count) =>
+						RequestStatus::Requested { deposit: None, count, len: Some(len) },
+				};
+				log::trace!(target: TARGET, "Moving preimage {:?} with len {}", hash, len);
+
+				crate::StatusFor::<T>::insert(hash, status);
+				crate::PreimageFor::<T>::insert(&(hash, len), preimage);
+
+				weight.saturating_accrue(T::DbWeight::get().writes(2));
+			}
+			StorageVersion::new(1).put::<Pallet<T>>();
+
+			weight.saturating_add(T::DbWeight::get().writes(1))
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(state: Vec<u8>) -> DispatchResult {
+			let old_images: u32 =
+				Decode::decode(&mut &state[..]).expect("pre_upgrade provides a valid state; qed");
+			let new_images = image_count::<T>().expect("V1 storage corrupted");
+
+			if new_images != old_images {
+				log::error!(
+					target: TARGET,
+					"migrated {} images, expected {}",
+					new_images,
+					old_images
+				);
+			}
+			ensure!(StorageVersion::get::<Pallet<T>>() == 1, "must upgrade");
+			Ok(())
+		}
+	}
+
+	/// Returns the number of images or `None` if the storage is corrupted.
+	#[cfg(feature = "try-runtime")]
+	pub fn image_count<T: Config>() -> Option<u32> {
+		// Use iter_values() to ensure that the values are decodable.
+		let images = crate::PreimageFor::<T>::iter_values().count() as u32;
+		let status = crate::StatusFor::<T>::iter_values().count() as u32;
+
+		if images == status {
+			Some(images)
+		} else {
+			None
+		}
+	}
+}
+
+#[cfg(test)]
+#[cfg(feature = "try-runtime")]
+mod test {
+	use super::*;
+	use crate::mock::{Test as T, *};
+
+	use sp_runtime::bounded_vec;
+
+	#[test]
+	fn migration_works() {
+		new_test_ext().execute_with(|| {
+			assert_eq!(StorageVersion::get::<Pallet<T>>(), 0);
+			// Insert some preimages into the v0 storage:
+
+			// Case 1: Unrequested without deposit
+			let (p, h) = preimage::<T>(128);
+			v0::PreimageFor::<T>::insert(h, p);
+			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Unrequested(None));
+			// Case 2: Unrequested with deposit
+			let (p, h) = preimage::<T>(1024);
+			v0::PreimageFor::<T>::insert(h, p);
+			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Unrequested(Some((1, 1))));
+			// Case 3: Requested by 0 (invalid)
+			let (p, h) = preimage::<T>(8192);
+			v0::PreimageFor::<T>::insert(h, p);
+			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Requested(0));
+			// Case 4: Requested by 10
+			let (p, h) = preimage::<T>(65536);
+			v0::PreimageFor::<T>::insert(h, p);
+			v0::StatusFor::<T>::insert(h, v0::RequestStatus::Requested(10));
+
+			assert_eq!(v0::image_count::<T>(), Some(4));
+			assert_eq!(v1::image_count::<T>(), None, "V1 storage should be corrupted");
+
+			let state = v1::Migration::<T>::pre_upgrade().unwrap();
+			let _w = v1::Migration::<T>::on_runtime_upgrade();
+			v1::Migration::<T>::post_upgrade(state).unwrap();
+
+			// V0 and V1 share the same prefix, so `iter_values` still counts the same.
+			assert_eq!(v0::image_count::<T>(), Some(3));
+			assert_eq!(v1::image_count::<T>(), Some(3)); // One gets skipped therefore 3.
+			assert_eq!(StorageVersion::get::<Pallet<T>>(), 1);
+
+			// Case 1: Unrequested without deposit becomes system-requested
+			let (p, h) = preimage::<T>(128);
+			assert_eq!(crate::PreimageFor::<T>::get(&(h, 128)), Some(p));
+			assert_eq!(
+				crate::StatusFor::<T>::get(h),
+				Some(RequestStatus::Requested { deposit: None, count: 1, len: Some(128) })
+			);
+			// Case 2: Unrequested with deposit becomes unrequested
+			let (p, h) = preimage::<T>(1024);
+			assert_eq!(crate::PreimageFor::<T>::get(&(h, 1024)), Some(p));
+			assert_eq!(
+				crate::StatusFor::<T>::get(h),
+				Some(RequestStatus::Unrequested { deposit: (1, 1), len: 1024 })
+			);
+			// Case 3: Requested by 0 should be skipped
+			let (_, h) = preimage::<T>(8192);
+			assert_eq!(crate::PreimageFor::<T>::get(&(h, 8192)), None);
+			assert_eq!(crate::StatusFor::<T>::get(h), None);
+			// Case 4: Requested by 10 becomes requested by 10
+			let (p, h) = preimage::<T>(65536);
+			assert_eq!(crate::PreimageFor::<T>::get(&(h, 65536)), Some(p));
+			assert_eq!(
+				crate::StatusFor::<T>::get(h),
+				Some(RequestStatus::Requested { deposit: None, count: 10, len: Some(65536) })
+			);
+		});
+	}
+
+	/// Returns a preimage with a given size and its hash.
+	fn preimage<T: Config>(
+		len: usize,
+	) -> (BoundedVec<u8, ConstU32<MAX_SIZE>>, <T as frame_system::Config>::Hash) {
+		let p = bounded_vec![1; len];
+		let h = <T as frame_system::Config>::Hashing::hash_of(&p);
+		(p, h)
+	}
+}
diff --git a/substrate/frame/preimage/src/mock.rs b/substrate/frame/preimage/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2fb9f36dec454c85b2e1cfca1b853ec7ac507b20
--- /dev/null
+++ b/substrate/frame/preimage/src/mock.rs
@@ -0,0 +1,112 @@
+// 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.
+
+//! # Preimage test environment.
+
+use super::*;
+
+use crate as pallet_preimage;
+use frame_support::{
+	ord_parameter_types,
+	traits::{ConstU32, ConstU64, Everything},
+	weights::constants::RocksDbWeight,
+};
+use frame_system::EnsureSignedBy;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Preimage: pallet_preimage,
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = RocksDbWeight;
+	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 = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+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 = ();
+	type MaxHolds = ();
+}
+
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type ManagerOrigin = EnsureSignedBy<One, u64>;
+	type BaseDeposit = ConstU64<2>;
+	type ByteDeposit = ConstU64<1>;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let balances = pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 100), (2, 100), (3, 100), (4, 100), (5, 100)],
+	};
+	balances.assimilate_storage(&mut t).unwrap();
+	t.into()
+}
+
+pub fn hashed(data: impl AsRef<[u8]>) -> H256 {
+	BlakeTwo256::hash(data.as_ref())
+}
diff --git a/substrate/frame/preimage/src/tests.rs b/substrate/frame/preimage/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fa621c8f5589e693a10d4c6694af177953375df9
--- /dev/null
+++ b/substrate/frame/preimage/src/tests.rs
@@ -0,0 +1,491 @@
+// 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.
+
+//! # Scheduler tests.
+
+#![cfg(test)]
+
+use super::*;
+use crate::mock::*;
+
+use frame_support::{
+	assert_err, assert_noop, assert_ok, assert_storage_noop,
+	traits::{Bounded, BoundedInline, Hash as PreimageHash},
+	StorageNoopGuard,
+};
+use pallet_balances::Error as BalancesError;
+use sp_core::{blake2_256, H256};
+use sp_runtime::bounded_vec;
+
+/// Returns one `Inline`, `Lookup` and `Legacy` item each with different data and hash.
+pub fn make_bounded_values() -> (Bounded<Vec<u8>>, Bounded<Vec<u8>>, Bounded<Vec<u8>>) {
+	let data: BoundedInline = bounded_vec![1];
+	let inline = Bounded::<Vec<u8>>::Inline(data);
+
+	let data = vec![1, 2];
+	let hash: H256 = blake2_256(&data[..]).into();
+	let len = data.len() as u32;
+	let lookup = Bounded::<Vec<u8>>::unrequested(hash, len);
+
+	let data = vec![1, 2, 3];
+	let hash: H256 = blake2_256(&data[..]).into();
+	let legacy = Bounded::<Vec<u8>>::Legacy { hash, dummy: Default::default() };
+
+	(inline, lookup, legacy)
+}
+
+#[test]
+fn user_note_preimage_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_eq!(Balances::reserved_balance(2), 3);
+		assert_eq!(Balances::free_balance(2), 97);
+
+		let h = hashed([1]);
+		assert!(Preimage::have_preimage(&h));
+		assert_eq!(Preimage::get_preimage(&h), Some(vec![1]));
+
+		assert_noop!(
+			Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]),
+			Error::<Test>::AlreadyNoted
+		);
+		assert_noop!(
+			Preimage::note_preimage(RuntimeOrigin::signed(0), vec![2]),
+			BalancesError::<Test>::InsufficientBalance
+		);
+	});
+}
+
+#[test]
+fn manager_note_preimage_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(1), vec![1]));
+		assert_eq!(Balances::reserved_balance(1), 0);
+		assert_eq!(Balances::free_balance(1), 100);
+
+		let h = hashed([1]);
+		assert!(Preimage::have_preimage(&h));
+		assert_eq!(Preimage::get_preimage(&h), Some(vec![1]));
+
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(1), vec![1]));
+	});
+}
+
+#[test]
+fn user_unnote_preimage_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_noop!(
+			Preimage::unnote_preimage(RuntimeOrigin::signed(3), hashed([1])),
+			Error::<Test>::NotAuthorized
+		);
+		assert_noop!(
+			Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([2])),
+			Error::<Test>::NotNoted
+		);
+
+		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])));
+		assert_noop!(
+			Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])),
+			Error::<Test>::NotNoted
+		);
+
+		let h = hashed([1]);
+		assert!(!Preimage::have_preimage(&h));
+		assert_eq!(Preimage::get_preimage(&h), None);
+	});
+}
+
+#[test]
+fn manager_unnote_preimage_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(1), vec![1]));
+		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_noop!(
+			Preimage::unnote_preimage(RuntimeOrigin::signed(1), hashed([1])),
+			Error::<Test>::NotNoted
+		);
+
+		let h = hashed([1]);
+		assert!(!Preimage::have_preimage(&h));
+		assert_eq!(Preimage::get_preimage(&h), None);
+	});
+}
+
+#[test]
+fn manager_unnote_user_preimage_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_noop!(
+			Preimage::unnote_preimage(RuntimeOrigin::signed(3), hashed([1])),
+			Error::<Test>::NotAuthorized
+		);
+		assert_noop!(
+			Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([2])),
+			Error::<Test>::NotNoted
+		);
+
+		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(1), hashed([1])));
+
+		let h = hashed([1]);
+		assert!(!Preimage::have_preimage(&h));
+		assert_eq!(Preimage::get_preimage(&h), None);
+	});
+}
+
+#[test]
+fn requested_then_noted_preimage_cannot_be_unnoted() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(1), vec![1]));
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		// it's still here.
+
+		let h = hashed([1]);
+		assert!(Preimage::have_preimage(&h));
+		assert_eq!(Preimage::get_preimage(&h), Some(vec![1]));
+
+		// now it's gone
+		assert_ok!(Preimage::unrequest_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert!(!Preimage::have_preimage(&hashed([1])));
+	});
+}
+
+#[test]
+fn request_note_order_makes_no_difference() {
+	let one_way = new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		(
+			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
+		)
+	});
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])));
+		let other_way = (
+			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
+		);
+		assert_eq!(one_way, other_way);
+	});
+}
+
+#[test]
+fn requested_then_user_noted_preimage_is_free() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_eq!(Balances::reserved_balance(2), 0);
+		assert_eq!(Balances::free_balance(2), 100);
+
+		let h = hashed([1]);
+		assert!(Preimage::have_preimage(&h));
+		assert_eq!(Preimage::get_preimage(&h), Some(vec![1]));
+	});
+}
+
+#[test]
+fn request_user_note_order_makes_no_difference() {
+	let one_way = new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		(
+			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
+		)
+	});
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])));
+		let other_way = (
+			StatusFor::<Test>::iter().collect::<Vec<_>>(),
+			PreimageFor::<Test>::iter().collect::<Vec<_>>(),
+		);
+		assert_eq!(one_way, other_way);
+	});
+}
+
+#[test]
+fn unrequest_preimage_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_noop!(
+			Preimage::unrequest_preimage(RuntimeOrigin::signed(1), hashed([2])),
+			Error::<Test>::NotRequested
+		);
+
+		assert_ok!(Preimage::unrequest_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert!(Preimage::have_preimage(&hashed([1])));
+
+		assert_ok!(Preimage::unrequest_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_noop!(
+			Preimage::unrequest_preimage(RuntimeOrigin::signed(1), hashed([1])),
+			Error::<Test>::NotRequested
+		);
+	});
+}
+
+#[test]
+fn user_noted_then_requested_preimage_is_refunded_once_only() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1; 3]));
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(2), vec![1]));
+		assert_ok!(Preimage::request_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::unrequest_preimage(RuntimeOrigin::signed(1), hashed([1])));
+		assert_ok!(Preimage::unnote_preimage(RuntimeOrigin::signed(2), hashed([1])));
+		// Still have reserve from `vec[1; 3]`.
+		assert_eq!(Balances::reserved_balance(2), 5);
+		assert_eq!(Balances::free_balance(2), 95);
+	});
+}
+
+#[test]
+fn noted_preimage_use_correct_map() {
+	new_test_ext().execute_with(|| {
+		// Add one preimage per bucket...
+		for i in 0..7 {
+			assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(1), vec![0; 128 << (i * 2)]));
+		}
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(1), vec![0; MAX_SIZE as usize]));
+		assert_eq!(PreimageFor::<Test>::iter().count(), 8);
+
+		// All are present
+		assert_eq!(StatusFor::<Test>::iter().count(), 8);
+
+		// Now start removing them again...
+		for i in 0..7 {
+			assert_ok!(Preimage::unnote_preimage(
+				RuntimeOrigin::signed(1),
+				hashed(vec![0; 128 << (i * 2)])
+			));
+		}
+		assert_eq!(PreimageFor::<Test>::iter().count(), 1);
+		assert_ok!(Preimage::unnote_preimage(
+			RuntimeOrigin::signed(1),
+			hashed(vec![0; MAX_SIZE as usize])
+		));
+		assert_eq!(PreimageFor::<Test>::iter().count(), 0);
+
+		// All are gone
+		assert_eq!(StatusFor::<Test>::iter().count(), 0);
+	});
+}
+
+/// The `StorePreimage` and `QueryPreimage` traits work together.
+#[test]
+fn query_and_store_preimage_workflow() {
+	new_test_ext().execute_with(|| {
+		let _guard = StorageNoopGuard::default();
+		let data: Vec<u8> = vec![1; 512];
+		let encoded = data.encode();
+
+		// Bound an unbound value.
+		let bound = Preimage::bound(data.clone()).unwrap();
+		let (len, hash) = (bound.len().unwrap(), bound.hash());
+
+		assert_eq!(hash, blake2_256(&encoded).into());
+		assert_eq!(bound.len(), Some(len));
+		assert!(bound.lookup_needed(), "Should not be Inlined");
+		assert_eq!(bound.lookup_len(), Some(len));
+
+		// The value is requested and available.
+		assert!(Preimage::is_requested(&hash));
+		assert!(<Preimage as QueryPreimage>::have(&bound));
+		assert_eq!(Preimage::len(&hash), Some(len));
+
+		// It can be fetched with length.
+		assert_eq!(Preimage::fetch(&hash, Some(len)).unwrap(), encoded);
+		// ... and without length.
+		assert_eq!(Preimage::fetch(&hash, None).unwrap(), encoded);
+		// ... but not with wrong length.
+		assert_err!(Preimage::fetch(&hash, Some(0)), DispatchError::Unavailable);
+
+		// It can be peeked and decoded correctly.
+		assert_eq!(Preimage::peek::<Vec<u8>>(&bound).unwrap(), (data.clone(), Some(len)));
+		// Request it two more times.
+		assert_eq!(Preimage::pick::<Vec<u8>>(hash, len), bound);
+		Preimage::request(&hash);
+		// It is requested thrice.
+		assert!(matches!(
+			StatusFor::<Test>::get(&hash).unwrap(),
+			RequestStatus::Requested { count: 3, .. }
+		));
+
+		// It can be realized and decoded correctly.
+		assert_eq!(Preimage::realize::<Vec<u8>>(&bound).unwrap(), (data.clone(), Some(len)));
+		assert!(matches!(
+			StatusFor::<Test>::get(&hash).unwrap(),
+			RequestStatus::Requested { count: 2, .. }
+		));
+		// Dropping should unrequest.
+		Preimage::drop(&bound);
+		assert!(matches!(
+			StatusFor::<Test>::get(&hash).unwrap(),
+			RequestStatus::Requested { count: 1, .. }
+		));
+
+		// Is still available.
+		assert!(<Preimage as QueryPreimage>::have(&bound));
+		// Manually unnote it.
+		Preimage::unnote(&hash);
+		// Is not available anymore.
+		assert!(!<Preimage as QueryPreimage>::have(&bound));
+		assert_err!(Preimage::fetch(&hash, Some(len)), DispatchError::Unavailable);
+		// And not requested since the traits assume permissioned origin.
+		assert!(!Preimage::is_requested(&hash));
+
+		// No storage changes remain. Checked by `StorageNoopGuard`.
+	});
+}
+
+/// The request function behaves as expected.
+#[test]
+fn query_preimage_request_works() {
+	new_test_ext().execute_with(|| {
+		let _guard = StorageNoopGuard::default();
+		let data: Vec<u8> = vec![1; 10];
+		let hash: PreimageHash = blake2_256(&data[..]).into();
+
+		// Request the preimage.
+		<Preimage as QueryPreimage>::request(&hash);
+
+		// The preimage is requested with unknown length and cannot be fetched.
+		assert!(<Preimage as QueryPreimage>::is_requested(&hash));
+		assert!(<Preimage as QueryPreimage>::len(&hash).is_none());
+		assert_noop!(<Preimage as QueryPreimage>::fetch(&hash, None), DispatchError::Unavailable);
+
+		// Request again.
+		<Preimage as QueryPreimage>::request(&hash);
+		// The preimage is still requested.
+		assert!(<Preimage as QueryPreimage>::is_requested(&hash));
+		assert!(<Preimage as QueryPreimage>::len(&hash).is_none());
+		assert_noop!(<Preimage as QueryPreimage>::fetch(&hash, None), DispatchError::Unavailable);
+		// But there is only one entry in the map.
+		assert_eq!(StatusFor::<Test>::iter().count(), 1);
+
+		// Un-request the preimage.
+		<Preimage as QueryPreimage>::unrequest(&hash);
+		// It is still requested.
+		assert!(<Preimage as QueryPreimage>::is_requested(&hash));
+		// Un-request twice.
+		<Preimage as QueryPreimage>::unrequest(&hash);
+		// It is not requested anymore.
+		assert!(!<Preimage as QueryPreimage>::is_requested(&hash));
+		// And there is no entry in the map.
+		assert_eq!(StatusFor::<Test>::iter().count(), 0);
+	});
+}
+
+/// The `QueryPreimage` functions can be used together with `Bounded` values.
+#[test]
+fn query_preimage_hold_and_drop_work() {
+	new_test_ext().execute_with(|| {
+		let _guard = StorageNoopGuard::default();
+		let (inline, lookup, legacy) = make_bounded_values();
+
+		// `hold` does nothing for `Inline` values.
+		assert_storage_noop!(<Preimage as QueryPreimage>::hold(&inline));
+		// `hold` requests `Lookup` values.
+		<Preimage as QueryPreimage>::hold(&lookup);
+		assert!(<Preimage as QueryPreimage>::is_requested(&lookup.hash()));
+		// `hold` requests `Legacy` values.
+		<Preimage as QueryPreimage>::hold(&legacy);
+		assert!(<Preimage as QueryPreimage>::is_requested(&legacy.hash()));
+
+		// There are two values requested in total.
+		assert_eq!(StatusFor::<Test>::iter().count(), 2);
+
+		// Cleanup by dropping both.
+		<Preimage as QueryPreimage>::drop(&lookup);
+		assert!(!<Preimage as QueryPreimage>::is_requested(&lookup.hash()));
+		<Preimage as QueryPreimage>::drop(&legacy);
+		assert!(!<Preimage as QueryPreimage>::is_requested(&legacy.hash()));
+
+		// There are no values requested anymore.
+		assert_eq!(StatusFor::<Test>::iter().count(), 0);
+	});
+}
+
+/// The `StorePreimage` trait works as expected.
+#[test]
+fn store_preimage_basic_works() {
+	new_test_ext().execute_with(|| {
+		let _guard = StorageNoopGuard::default();
+		let data: Vec<u8> = vec![1; 512]; // Too large to inline.
+		let encoded = Cow::from(data.encode());
+
+		// Bound the data.
+		let bound = <Preimage as StorePreimage>::bound(data.clone()).unwrap();
+		// The preimage can be peeked.
+		assert_ok!(<Preimage as QueryPreimage>::peek(&bound));
+		// Un-note the preimage.
+		<Preimage as StorePreimage>::unnote(&bound.hash());
+		// The preimage cannot be peeked anymore.
+		assert_err!(<Preimage as QueryPreimage>::peek(&bound), DispatchError::Unavailable);
+		// Noting the wrong pre-image does not make it peek-able.
+		assert_ok!(<Preimage as StorePreimage>::note(Cow::Borrowed(&data)));
+		assert_err!(<Preimage as QueryPreimage>::peek(&bound), DispatchError::Unavailable);
+
+		// Manually note the preimage makes it peek-able again.
+		assert_ok!(<Preimage as StorePreimage>::note(encoded.clone()));
+		// Noting again works.
+		assert_ok!(<Preimage as StorePreimage>::note(encoded));
+		assert_ok!(<Preimage as QueryPreimage>::peek(&bound));
+
+		// Cleanup.
+		<Preimage as StorePreimage>::unnote(&bound.hash());
+		let data_hash = blake2_256(&data);
+		<Preimage as StorePreimage>::unnote(&data_hash.into());
+
+		// No storage changes remain. Checked by `StorageNoopGuard`.
+	});
+}
+
+#[test]
+fn store_preimage_note_too_large_errors() {
+	new_test_ext().execute_with(|| {
+		// Works with `MAX_LENGTH`.
+		let len = <Preimage as StorePreimage>::MAX_LENGTH;
+		let data = vec![0u8; len];
+		assert_ok!(<Preimage as StorePreimage>::note(data.into()));
+
+		// Errors with `MAX_LENGTH+1`.
+		let data = vec![0u8; len + 1];
+		assert_err!(<Preimage as StorePreimage>::note(data.into()), DispatchError::Exhausted);
+	});
+}
+
+#[test]
+fn store_preimage_bound_too_large_errors() {
+	new_test_ext().execute_with(|| {
+		// Using `MAX_LENGTH` number of bytes in a vector does not work
+		// since SCALE prepends the length.
+		let len = <Preimage as StorePreimage>::MAX_LENGTH;
+		let data: Vec<u8> = vec![0; len];
+		assert_err!(<Preimage as StorePreimage>::bound(data.clone()), DispatchError::Exhausted);
+
+		// Works with `MAX_LENGTH-4`.
+		let data: Vec<u8> = vec![0; len - 4];
+		assert_ok!(<Preimage as StorePreimage>::bound(data.clone()));
+	});
+}
diff --git a/substrate/frame/preimage/src/weights.rs b/substrate/frame/preimage/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..41e58a1027800b15672da71f7c17b624471c3ebd
--- /dev/null
+++ b/substrate/frame/preimage/src/weights.rs
@@ -0,0 +1,382 @@
+// 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.
+
+//! Autogenerated weights for pallet_preimage
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_preimage
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/preimage/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_preimage.
+pub trait WeightInfo {
+	fn note_preimage(s: u32, ) -> Weight;
+	fn note_requested_preimage(s: u32, ) -> Weight;
+	fn note_no_deposit_preimage(s: u32, ) -> Weight;
+	fn unnote_preimage() -> Weight;
+	fn unnote_no_deposit_preimage() -> Weight;
+	fn request_preimage() -> Weight;
+	fn request_no_deposit_preimage() -> Weight;
+	fn request_unnoted_preimage() -> Weight;
+	fn request_requested_preimage() -> Weight;
+	fn unrequest_preimage() -> Weight;
+	fn unrequest_unnoted_preimage() -> Weight;
+	fn unrequest_multi_referenced_preimage() -> Weight;
+}
+
+/// Weights for pallet_preimage using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 4194304]`.
+	fn note_preimage(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `143`
+		//  Estimated: `3556`
+		// Minimum execution time: 30_479_000 picoseconds.
+		Weight::from_parts(23_381_775, 3556)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_670, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 4194304]`.
+	fn note_requested_preimage(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 16_104_000 picoseconds.
+		Weight::from_parts(18_393_879, 3556)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_669, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 4194304]`.
+	fn note_no_deposit_preimage(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 15_652_000 picoseconds.
+		Weight::from_parts(22_031_627, 3556)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_672, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	fn unnote_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `289`
+		//  Estimated: `3556`
+		// Minimum execution time: 37_148_000 picoseconds.
+		Weight::from_parts(40_247_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	fn unnote_no_deposit_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 19_909_000 picoseconds.
+		Weight::from_parts(21_572_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `188`
+		//  Estimated: `3556`
+		// Minimum execution time: 17_602_000 picoseconds.
+		Weight::from_parts(18_899_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_no_deposit_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 11_253_000 picoseconds.
+		Weight::from_parts(11_667_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_unnoted_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `42`
+		//  Estimated: `3556`
+		// Minimum execution time: 14_152_000 picoseconds.
+		Weight::from_parts(14_652_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_requested_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 8_267_000 picoseconds.
+		Weight::from_parts(8_969_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	fn unrequest_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 18_429_000 picoseconds.
+		Weight::from_parts(18_946_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn unrequest_unnoted_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 7_910_000 picoseconds.
+		Weight::from_parts(8_272_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn unrequest_multi_referenced_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 7_936_000 picoseconds.
+		Weight::from_parts(8_504_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 4194304]`.
+	fn note_preimage(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `143`
+		//  Estimated: `3556`
+		// Minimum execution time: 30_479_000 picoseconds.
+		Weight::from_parts(23_381_775, 3556)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_670, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 4194304]`.
+	fn note_requested_preimage(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 16_104_000 picoseconds.
+		Weight::from_parts(18_393_879, 3556)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_669, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 4194304]`.
+	fn note_no_deposit_preimage(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 15_652_000 picoseconds.
+		Weight::from_parts(22_031_627, 3556)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_672, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	fn unnote_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `289`
+		//  Estimated: `3556`
+		// Minimum execution time: 37_148_000 picoseconds.
+		Weight::from_parts(40_247_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	fn unnote_no_deposit_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 19_909_000 picoseconds.
+		Weight::from_parts(21_572_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `188`
+		//  Estimated: `3556`
+		// Minimum execution time: 17_602_000 picoseconds.
+		Weight::from_parts(18_899_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_no_deposit_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 11_253_000 picoseconds.
+		Weight::from_parts(11_667_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_unnoted_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `42`
+		//  Estimated: `3556`
+		// Minimum execution time: 14_152_000 picoseconds.
+		Weight::from_parts(14_652_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn request_requested_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 8_267_000 picoseconds.
+		Weight::from_parts(8_969_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:0 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen)
+	fn unrequest_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `144`
+		//  Estimated: `3556`
+		// Minimum execution time: 18_429_000 picoseconds.
+		Weight::from_parts(18_946_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn unrequest_unnoted_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 7_910_000 picoseconds.
+		Weight::from_parts(8_272_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn unrequest_multi_referenced_preimage() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `106`
+		//  Estimated: `3556`
+		// Minimum execution time: 7_936_000 picoseconds.
+		Weight::from_parts(8_504_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/proxy/Cargo.toml b/substrate/frame/proxy/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..734926c4a2f9202006e7dcd6ddfa50089e944eab
--- /dev/null
+++ b/substrate/frame/proxy/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-proxy"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME proxying pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["max-encoded-len"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-utility = { version = "4.0.0-dev", path = "../utility" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-utility/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-utility/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-utility/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/proxy/README.md b/substrate/frame/proxy/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..bfe26d9aefbc4329955301f9cbb820d2b74c6ef7
--- /dev/null
+++ b/substrate/frame/proxy/README.md
@@ -0,0 +1,21 @@
+# Proxy Module
+A module allowing accounts to give permission to other accounts to dispatch types of calls from
+their signed origin.
+
+The accounts to which permission is delegated may be requied to announce the action that they
+wish to execute some duration prior to execution happens. In this case, the target account may
+reject the announcement and in doing so, veto the execution.
+
+- [`Config`](https://docs.rs/pallet-proxy/latest/pallet_proxy/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-proxy/latest/pallet_proxy/pallet/enum.Call.html)
+
+## Overview
+
+## Interface
+
+### Dispatchable Functions
+
+[`Call`]: ./enum.Call.html
+[`Config`]: ./trait.Config.html
+
+License: Apache-2.0
diff --git a/substrate/frame/proxy/src/benchmarking.rs b/substrate/frame/proxy/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e0d14163d21b2c7e1d54a12f3027544a310be7b2
--- /dev/null
+++ b/substrate/frame/proxy/src/benchmarking.rs
@@ -0,0 +1,264 @@
+// 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.
+
+// Benchmarks for Proxy Pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use crate::Pallet as Proxy;
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use sp_runtime::traits::Bounded;
+
+const SEED: u32 = 0;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn add_proxies<T: Config>(n: u32, maybe_who: Option<T::AccountId>) -> Result<(), &'static str> {
+	let caller = maybe_who.unwrap_or_else(whitelisted_caller);
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
+	for i in 0..n {
+		let real = T::Lookup::unlookup(account("target", i, SEED));
+
+		Proxy::<T>::add_proxy(
+			RawOrigin::Signed(caller.clone()).into(),
+			real,
+			T::ProxyType::default(),
+			BlockNumberFor::<T>::zero(),
+		)?;
+	}
+	Ok(())
+}
+
+fn add_announcements<T: Config>(
+	n: u32,
+	maybe_who: Option<T::AccountId>,
+	maybe_real: Option<T::AccountId>,
+) -> Result<(), &'static str> {
+	let caller = maybe_who.unwrap_or_else(|| account("caller", 0, SEED));
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
+	let real = if let Some(real) = maybe_real {
+		real
+	} else {
+		let real = account("real", 0, SEED);
+		T::Currency::make_free_balance_be(&real, BalanceOf::<T>::max_value() / 2u32.into());
+		Proxy::<T>::add_proxy(
+			RawOrigin::Signed(real.clone()).into(),
+			caller_lookup,
+			T::ProxyType::default(),
+			BlockNumberFor::<T>::zero(),
+		)?;
+		real
+	};
+	let real_lookup = T::Lookup::unlookup(real);
+	for _ in 0..n {
+		Proxy::<T>::announce(
+			RawOrigin::Signed(caller.clone()).into(),
+			real_lookup.clone(),
+			T::CallHasher::hash_of(&("add_announcement", n)),
+		)?;
+	}
+	Ok(())
+}
+
+benchmarks! {
+	proxy {
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		// In this case the caller is the "target" proxy
+		let caller: T::AccountId = account("target", p - 1, SEED);
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
+		// ... and "real" is the traditional caller. This is not a typo.
+		let real: T::AccountId = whitelisted_caller();
+		let real_lookup = T::Lookup::unlookup(real);
+		let call: <T as Config>::RuntimeCall = frame_system::Call::<T>::remark { remark: vec![] }.into();
+	}: _(RawOrigin::Signed(caller), real_lookup, Some(T::ProxyType::default()), Box::new(call))
+	verify {
+		assert_last_event::<T>(Event::ProxyExecuted { result: Ok(()) }.into())
+	}
+
+	proxy_announced {
+		let a in 0 .. T::MaxPending::get() - 1;
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		// In this case the caller is the "target" proxy
+		let caller: T::AccountId = account("pure", 0, SEED);
+		let delegate: T::AccountId = account("target", p - 1, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		T::Currency::make_free_balance_be(&delegate, BalanceOf::<T>::max_value() / 2u32.into());
+		// ... and "real" is the traditional caller. This is not a typo.
+		let real: T::AccountId = whitelisted_caller();
+		let real_lookup = T::Lookup::unlookup(real);
+		let call: <T as Config>::RuntimeCall = frame_system::Call::<T>::remark { remark: vec![] }.into();
+		Proxy::<T>::announce(
+			RawOrigin::Signed(delegate.clone()).into(),
+			real_lookup.clone(),
+			T::CallHasher::hash_of(&call),
+		)?;
+		add_announcements::<T>(a, Some(delegate.clone()), None)?;
+	}: _(RawOrigin::Signed(caller), delegate_lookup, real_lookup, Some(T::ProxyType::default()), Box::new(call))
+	verify {
+		assert_last_event::<T>(Event::ProxyExecuted { result: Ok(()) }.into())
+	}
+
+	remove_announcement {
+		let a in 0 .. T::MaxPending::get() - 1;
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		// In this case the caller is the "target" proxy
+		let caller: T::AccountId = account("target", p - 1, SEED);
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
+		// ... and "real" is the traditional caller. This is not a typo.
+		let real: T::AccountId = whitelisted_caller();
+		let real_lookup = T::Lookup::unlookup(real);
+		let call: <T as Config>::RuntimeCall = frame_system::Call::<T>::remark { remark: vec![] }.into();
+		Proxy::<T>::announce(
+			RawOrigin::Signed(caller.clone()).into(),
+			real_lookup.clone(),
+			T::CallHasher::hash_of(&call),
+		)?;
+		add_announcements::<T>(a, Some(caller.clone()), None)?;
+	}: _(RawOrigin::Signed(caller.clone()), real_lookup, T::CallHasher::hash_of(&call))
+	verify {
+		let (announcements, _) = Announcements::<T>::get(&caller);
+		assert_eq!(announcements.len() as u32, a);
+	}
+
+	reject_announcement {
+		let a in 0 .. T::MaxPending::get() - 1;
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		// In this case the caller is the "target" proxy
+		let caller: T::AccountId = account("target", p - 1, SEED);
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
+		// ... and "real" is the traditional caller. This is not a typo.
+		let real: T::AccountId = whitelisted_caller();
+		let real_lookup = T::Lookup::unlookup(real.clone());
+		let call: <T as Config>::RuntimeCall = frame_system::Call::<T>::remark { remark: vec![] }.into();
+		Proxy::<T>::announce(
+			RawOrigin::Signed(caller.clone()).into(),
+			real_lookup,
+			T::CallHasher::hash_of(&call),
+		)?;
+		add_announcements::<T>(a, Some(caller.clone()), None)?;
+	}: _(RawOrigin::Signed(real), caller_lookup, T::CallHasher::hash_of(&call))
+	verify {
+		let (announcements, _) = Announcements::<T>::get(&caller);
+		assert_eq!(announcements.len() as u32, a);
+	}
+
+	announce {
+		let a in 0 .. T::MaxPending::get() - 1;
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		// In this case the caller is the "target" proxy
+		let caller: T::AccountId = account("target", p - 1, SEED);
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value() / 2u32.into());
+		// ... and "real" is the traditional caller. This is not a typo.
+		let real: T::AccountId = whitelisted_caller();
+		let real_lookup = T::Lookup::unlookup(real.clone());
+		add_announcements::<T>(a, Some(caller.clone()), None)?;
+		let call: <T as Config>::RuntimeCall = frame_system::Call::<T>::remark { remark: vec![] }.into();
+		let call_hash = T::CallHasher::hash_of(&call);
+	}: _(RawOrigin::Signed(caller.clone()), real_lookup, call_hash)
+	verify {
+		assert_last_event::<T>(Event::Announced { real, proxy: caller, call_hash }.into());
+	}
+
+	add_proxy {
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		let caller: T::AccountId = whitelisted_caller();
+		let real = T::Lookup::unlookup(account("target", T::MaxProxies::get(), SEED));
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		real,
+		T::ProxyType::default(),
+		BlockNumberFor::<T>::zero()
+	)
+	verify {
+		let (proxies, _) = Proxies::<T>::get(caller);
+		assert_eq!(proxies.len() as u32, p + 1);
+	}
+
+	remove_proxy {
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		let caller: T::AccountId = whitelisted_caller();
+		let delegate = T::Lookup::unlookup(account("target", 0, SEED));
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		delegate,
+		T::ProxyType::default(),
+		BlockNumberFor::<T>::zero()
+	)
+	verify {
+		let (proxies, _) = Proxies::<T>::get(caller);
+		assert_eq!(proxies.len() as u32, p - 1);
+	}
+
+	remove_proxies {
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		let caller: T::AccountId = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		let (proxies, _) = Proxies::<T>::get(caller);
+		assert_eq!(proxies.len() as u32, 0);
+	}
+
+	create_pure {
+		let p in 1 .. (T::MaxProxies::get() - 1) => add_proxies::<T>(p, None)?;
+		let caller: T::AccountId = whitelisted_caller();
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		T::ProxyType::default(),
+		BlockNumberFor::<T>::zero(),
+		0
+	)
+	verify {
+		let pure_account = Pallet::<T>::pure_account(&caller, &T::ProxyType::default(), 0, None);
+		assert_last_event::<T>(Event::PureCreated {
+			pure: pure_account,
+			who: caller,
+			proxy_type: T::ProxyType::default(),
+			disambiguation_index: 0,
+		}.into());
+	}
+
+	kill_pure {
+		let p in 0 .. (T::MaxProxies::get() - 2);
+
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		Pallet::<T>::create_pure(
+			RawOrigin::Signed(whitelisted_caller()).into(),
+			T::ProxyType::default(),
+			BlockNumberFor::<T>::zero(),
+			0
+		)?;
+		let height = system::Pallet::<T>::block_number();
+		let ext_index = system::Pallet::<T>::extrinsic_index().unwrap_or(0);
+		let pure_account = Pallet::<T>::pure_account(&caller, &T::ProxyType::default(), 0, None);
+
+		add_proxies::<T>(p, Some(pure_account.clone()))?;
+		ensure!(Proxies::<T>::contains_key(&pure_account), "pure proxy not created");
+	}: _(RawOrigin::Signed(pure_account.clone()), caller_lookup, T::ProxyType::default(), 0, height, ext_index)
+	verify {
+		assert!(!Proxies::<T>::contains_key(&pure_account));
+	}
+
+	impl_benchmark_test_suite!(Proxy, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/proxy/src/lib.rs b/substrate/frame/proxy/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..586d52fb62bddabc0f17bd46aeb77dc60d4cd9ec
--- /dev/null
+++ b/substrate/frame/proxy/src/lib.rs
@@ -0,0 +1,810 @@
+// 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.
+
+//! # Proxy Pallet
+//! A pallet allowing accounts to give permission to other accounts to dispatch types of calls from
+//! their signed origin.
+//!
+//! The accounts to which permission is delegated may be required to announce the action that they
+//! wish to execute some duration prior to execution happens. In this case, the target account may
+//! reject the announcement and in doing so, veto the execution.
+//!
+//! - [`Config`]
+//! - [`Call`]
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod tests;
+pub mod weights;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{DispatchError, GetDispatchInfo},
+	ensure,
+	traits::{Currency, Get, InstanceFilter, IsSubType, IsType, OriginTrait, ReservableCurrency},
+};
+use frame_system::{self as system, ensure_signed, pallet_prelude::BlockNumberFor};
+pub use pallet::*;
+use scale_info::TypeInfo;
+use sp_io::hashing::blake2_256;
+use sp_runtime::{
+	traits::{Dispatchable, Hash, Saturating, StaticLookup, TrailingZeroInput, Zero},
+	DispatchResult, RuntimeDebug,
+};
+use sp_std::prelude::*;
+pub use weights::WeightInfo;
+
+type CallHashOf<T> = <<T as Config>::CallHasher as Hash>::Output;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// The parameters under which a particular account has a proxy relationship with some other
+/// account.
+#[derive(
+	Encode,
+	Decode,
+	Clone,
+	Copy,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	RuntimeDebug,
+	MaxEncodedLen,
+	TypeInfo,
+)]
+pub struct ProxyDefinition<AccountId, ProxyType, BlockNumber> {
+	/// The account which may act on behalf of another.
+	pub delegate: AccountId,
+	/// A value defining the subset of calls that it is allowed to make.
+	pub proxy_type: ProxyType,
+	/// The number of blocks that an announcement must be in place for before the corresponding
+	/// call may be dispatched. If zero, then no announcement is needed.
+	pub delay: BlockNumber,
+}
+
+/// Details surrounding a specific instance of an announcement to make a call.
+#[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct Announcement<AccountId, Hash, BlockNumber> {
+	/// The account which made the announcement.
+	real: AccountId,
+	/// The hash of the call to be made.
+	call_hash: Hash,
+	/// The height at which the announcement was made.
+	height: BlockNumber,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::{DispatchResult, *};
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Configuration trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The overarching call type.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ GetDispatchInfo
+			+ From<frame_system::Call<Self>>
+			+ IsSubType<Call<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+
+		/// The currency mechanism.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// A kind of proxy; specified with the proxy and passed in to the `IsProxyable` fitler.
+		/// The instance filter determines whether a given call may be proxied under this type.
+		///
+		/// IMPORTANT: `Default` must be provided and MUST BE the the *most permissive* value.
+		type ProxyType: Parameter
+			+ Member
+			+ Ord
+			+ PartialOrd
+			+ InstanceFilter<<Self as Config>::RuntimeCall>
+			+ Default
+			+ MaxEncodedLen;
+
+		/// The base amount of currency needed to reserve for creating a proxy.
+		///
+		/// This is held for an additional storage item whose value size is
+		/// `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes.
+		#[pallet::constant]
+		type ProxyDepositBase: Get<BalanceOf<Self>>;
+
+		/// The amount of currency needed per proxy added.
+		///
+		/// This is held for adding 32 bytes plus an instance of `ProxyType` more into a
+		/// pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take
+		/// into account `32 + proxy_type.encode().len()` bytes of data.
+		#[pallet::constant]
+		type ProxyDepositFactor: Get<BalanceOf<Self>>;
+
+		/// The maximum amount of proxies allowed for a single account.
+		#[pallet::constant]
+		type MaxProxies: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The maximum amount of time-delayed announcements that are allowed to be pending.
+		#[pallet::constant]
+		type MaxPending: Get<u32>;
+
+		/// The type of hash used for hashing the call.
+		type CallHasher: Hash;
+
+		/// The base amount of currency needed to reserve for creating an announcement.
+		///
+		/// This is held when a new storage item holding a `Balance` is created (typically 16
+		/// bytes).
+		#[pallet::constant]
+		type AnnouncementDepositBase: Get<BalanceOf<Self>>;
+
+		/// The amount of currency needed per announcement made.
+		///
+		/// This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes)
+		/// into a pre-existing storage value.
+		#[pallet::constant]
+		type AnnouncementDepositFactor: Get<BalanceOf<Self>>;
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Dispatch the given `call` from an account that the sender is authorised for through
+		/// `add_proxy`.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `real`: The account that the proxy will make a call on behalf of.
+		/// - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+		/// - `call`: The call to be made by the `real` account.
+		#[pallet::call_index(0)]
+		#[pallet::weight({
+			let di = call.get_dispatch_info();
+			(T::WeightInfo::proxy(T::MaxProxies::get())
+				 // AccountData for inner call origin accountdata.
+				.saturating_add(T::DbWeight::get().reads_writes(1, 1))
+				.saturating_add(di.weight),
+			di.class)
+		})]
+		pub fn proxy(
+			origin: OriginFor<T>,
+			real: AccountIdLookupOf<T>,
+			force_proxy_type: Option<T::ProxyType>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let real = T::Lookup::lookup(real)?;
+			let def = Self::find_proxy(&real, &who, force_proxy_type)?;
+			ensure!(def.delay.is_zero(), Error::<T>::Unannounced);
+
+			Self::do_proxy(def, real, *call);
+
+			Ok(())
+		}
+
+		/// Register a proxy account for the sender that is able to make calls on its behalf.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `proxy`: The account that the `caller` would like to make a proxy.
+		/// - `proxy_type`: The permissions allowed for this proxy account.
+		/// - `delay`: The announcement period required of the initial proxy. Will generally be
+		/// zero.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::add_proxy(T::MaxProxies::get()))]
+		pub fn add_proxy(
+			origin: OriginFor<T>,
+			delegate: AccountIdLookupOf<T>,
+			proxy_type: T::ProxyType,
+			delay: BlockNumberFor<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			Self::add_proxy_delegate(&who, delegate, proxy_type, delay)
+		}
+
+		/// Unregister a proxy account for the sender.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `proxy`: The account that the `caller` would like to remove as a proxy.
+		/// - `proxy_type`: The permissions currently enabled for the removed proxy account.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::remove_proxy(T::MaxProxies::get()))]
+		pub fn remove_proxy(
+			origin: OriginFor<T>,
+			delegate: AccountIdLookupOf<T>,
+			proxy_type: T::ProxyType,
+			delay: BlockNumberFor<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			Self::remove_proxy_delegate(&who, delegate, proxy_type, delay)
+		}
+
+		/// Unregister all proxy accounts for the sender.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// WARNING: This may be called on accounts created by `pure`, however if done, then
+		/// the unreserved fees will be inaccessible. **All access to this account will be lost.**
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::remove_proxies(T::MaxProxies::get()))]
+		pub fn remove_proxies(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::remove_all_proxy_delegates(&who);
+			Ok(())
+		}
+
+		/// Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and
+		/// initialize it with a proxy of `proxy_type` for `origin` sender.
+		///
+		/// Requires a `Signed` origin.
+		///
+		/// - `proxy_type`: The type of the proxy that the sender will be registered as over the
+		/// new account. This will almost always be the most permissive `ProxyType` possible to
+		/// allow for maximum flexibility.
+		/// - `index`: A disambiguation index, in case this is called multiple times in the same
+		/// transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just
+		/// want to use `0`.
+		/// - `delay`: The announcement period required of the initial proxy. Will generally be
+		/// zero.
+		///
+		/// Fails with `Duplicate` if this has already been called in this transaction, from the
+		/// same sender, with the same parameters.
+		///
+		/// Fails if there are insufficient funds to pay for deposit.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::create_pure(T::MaxProxies::get()))]
+		pub fn create_pure(
+			origin: OriginFor<T>,
+			proxy_type: T::ProxyType,
+			delay: BlockNumberFor<T>,
+			index: u16,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let pure = Self::pure_account(&who, &proxy_type, index, None);
+			ensure!(!Proxies::<T>::contains_key(&pure), Error::<T>::Duplicate);
+
+			let proxy_def =
+				ProxyDefinition { delegate: who.clone(), proxy_type: proxy_type.clone(), delay };
+			let bounded_proxies: BoundedVec<_, T::MaxProxies> =
+				vec![proxy_def].try_into().map_err(|_| Error::<T>::TooMany)?;
+
+			let deposit = T::ProxyDepositBase::get() + T::ProxyDepositFactor::get();
+			T::Currency::reserve(&who, deposit)?;
+
+			Proxies::<T>::insert(&pure, (bounded_proxies, deposit));
+			Self::deposit_event(Event::PureCreated {
+				pure,
+				who,
+				proxy_type,
+				disambiguation_index: index,
+			});
+
+			Ok(())
+		}
+
+		/// Removes a previously spawned pure proxy.
+		///
+		/// WARNING: **All access to this account will be lost.** Any funds held in it will be
+		/// inaccessible.
+		///
+		/// Requires a `Signed` origin, and the sender account must have been created by a call to
+		/// `pure` with corresponding parameters.
+		///
+		/// - `spawner`: The account that originally called `pure` to create this account.
+		/// - `index`: The disambiguation index originally passed to `pure`. Probably `0`.
+		/// - `proxy_type`: The proxy type originally passed to `pure`.
+		/// - `height`: The height of the chain when the call to `pure` was processed.
+		/// - `ext_index`: The extrinsic index in which the call to `pure` was processed.
+		///
+		/// Fails with `NoPermission` in case the caller is not a previously created pure
+		/// account whose `pure` call has corresponding parameters.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::kill_pure(T::MaxProxies::get()))]
+		pub fn kill_pure(
+			origin: OriginFor<T>,
+			spawner: AccountIdLookupOf<T>,
+			proxy_type: T::ProxyType,
+			index: u16,
+			#[pallet::compact] height: BlockNumberFor<T>,
+			#[pallet::compact] ext_index: u32,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let spawner = T::Lookup::lookup(spawner)?;
+
+			let when = (height, ext_index);
+			let proxy = Self::pure_account(&spawner, &proxy_type, index, Some(when));
+			ensure!(proxy == who, Error::<T>::NoPermission);
+
+			let (_, deposit) = Proxies::<T>::take(&who);
+			T::Currency::unreserve(&spawner, deposit);
+
+			Ok(())
+		}
+
+		/// Publish the hash of a proxy-call that will be made in the future.
+		///
+		/// This must be called some number of blocks before the corresponding `proxy` is attempted
+		/// if the delay associated with the proxy relationship is greater than zero.
+		///
+		/// No more than `MaxPending` announcements may be made at any one time.
+		///
+		/// This will take a deposit of `AnnouncementDepositFactor` as well as
+		/// `AnnouncementDepositBase` if there are no other pending announcements.
+		///
+		/// The dispatch origin for this call must be _Signed_ and a proxy of `real`.
+		///
+		/// Parameters:
+		/// - `real`: The account that the proxy will make a call on behalf of.
+		/// - `call_hash`: The hash of the call to be made by the `real` account.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::announce(T::MaxPending::get(), T::MaxProxies::get()))]
+		pub fn announce(
+			origin: OriginFor<T>,
+			real: AccountIdLookupOf<T>,
+			call_hash: CallHashOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let real = T::Lookup::lookup(real)?;
+			Proxies::<T>::get(&real)
+				.0
+				.into_iter()
+				.find(|x| x.delegate == who)
+				.ok_or(Error::<T>::NotProxy)?;
+
+			let announcement = Announcement {
+				real: real.clone(),
+				call_hash,
+				height: system::Pallet::<T>::block_number(),
+			};
+
+			Announcements::<T>::try_mutate(&who, |(ref mut pending, ref mut deposit)| {
+				pending.try_push(announcement).map_err(|_| Error::<T>::TooMany)?;
+				Self::rejig_deposit(
+					&who,
+					*deposit,
+					T::AnnouncementDepositBase::get(),
+					T::AnnouncementDepositFactor::get(),
+					pending.len(),
+				)
+				.map(|d| {
+					d.expect("Just pushed; pending.len() > 0; rejig_deposit returns Some; qed")
+				})
+				.map(|d| *deposit = d)
+			})?;
+			Self::deposit_event(Event::Announced { real, proxy: who, call_hash });
+
+			Ok(())
+		}
+
+		/// Remove a given announcement.
+		///
+		/// May be called by a proxy account to remove a call they previously announced and return
+		/// the deposit.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `real`: The account that the proxy will make a call on behalf of.
+		/// - `call_hash`: The hash of the call to be made by the `real` account.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::remove_announcement(
+			T::MaxPending::get(),
+			T::MaxProxies::get()
+		))]
+		pub fn remove_announcement(
+			origin: OriginFor<T>,
+			real: AccountIdLookupOf<T>,
+			call_hash: CallHashOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let real = T::Lookup::lookup(real)?;
+			Self::edit_announcements(&who, |ann| ann.real != real || ann.call_hash != call_hash)?;
+
+			Ok(())
+		}
+
+		/// Remove the given announcement of a delegate.
+		///
+		/// May be called by a target (proxied) account to remove a call that one of their delegates
+		/// (`delegate`) has announced they want to execute. The deposit is returned.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `delegate`: The account that previously announced the call.
+		/// - `call_hash`: The hash of the call to be made.
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::reject_announcement(
+			T::MaxPending::get(),
+			T::MaxProxies::get()
+		))]
+		pub fn reject_announcement(
+			origin: OriginFor<T>,
+			delegate: AccountIdLookupOf<T>,
+			call_hash: CallHashOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			Self::edit_announcements(&delegate, |ann| {
+				ann.real != who || ann.call_hash != call_hash
+			})?;
+
+			Ok(())
+		}
+
+		/// Dispatch the given `call` from an account that the sender is authorized for through
+		/// `add_proxy`.
+		///
+		/// Removes any corresponding announcement(s).
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `real`: The account that the proxy will make a call on behalf of.
+		/// - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.
+		/// - `call`: The call to be made by the `real` account.
+		#[pallet::call_index(9)]
+		#[pallet::weight({
+			let di = call.get_dispatch_info();
+			(T::WeightInfo::proxy_announced(T::MaxPending::get(), T::MaxProxies::get())
+				 // AccountData for inner call origin accountdata.
+				.saturating_add(T::DbWeight::get().reads_writes(1, 1))
+				.saturating_add(di.weight),
+			di.class)
+		})]
+		pub fn proxy_announced(
+			origin: OriginFor<T>,
+			delegate: AccountIdLookupOf<T>,
+			real: AccountIdLookupOf<T>,
+			force_proxy_type: Option<T::ProxyType>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			ensure_signed(origin)?;
+			let delegate = T::Lookup::lookup(delegate)?;
+			let real = T::Lookup::lookup(real)?;
+			let def = Self::find_proxy(&real, &delegate, force_proxy_type)?;
+
+			let call_hash = T::CallHasher::hash_of(&call);
+			let now = system::Pallet::<T>::block_number();
+			Self::edit_announcements(&delegate, |ann| {
+				ann.real != real ||
+					ann.call_hash != call_hash ||
+					now.saturating_sub(ann.height) < def.delay
+			})
+			.map_err(|_| Error::<T>::Unannounced)?;
+
+			Self::do_proxy(def, real, *call);
+
+			Ok(())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A proxy was executed correctly, with the given.
+		ProxyExecuted { result: DispatchResult },
+		/// A pure account has been created by new proxy with given
+		/// disambiguation index and proxy type.
+		PureCreated {
+			pure: T::AccountId,
+			who: T::AccountId,
+			proxy_type: T::ProxyType,
+			disambiguation_index: u16,
+		},
+		/// An announcement was placed to make a call in the future.
+		Announced { real: T::AccountId, proxy: T::AccountId, call_hash: CallHashOf<T> },
+		/// A proxy was added.
+		ProxyAdded {
+			delegator: T::AccountId,
+			delegatee: T::AccountId,
+			proxy_type: T::ProxyType,
+			delay: BlockNumberFor<T>,
+		},
+		/// A proxy was removed.
+		ProxyRemoved {
+			delegator: T::AccountId,
+			delegatee: T::AccountId,
+			proxy_type: T::ProxyType,
+			delay: BlockNumberFor<T>,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// There are too many proxies registered or too many announcements pending.
+		TooMany,
+		/// Proxy registration not found.
+		NotFound,
+		/// Sender is not a proxy of the account to be proxied.
+		NotProxy,
+		/// A call which is incompatible with the proxy type's filter was attempted.
+		Unproxyable,
+		/// Account is already a proxy.
+		Duplicate,
+		/// Call may not be made by proxy because it may escalate its privileges.
+		NoPermission,
+		/// Announcement, if made at all, was made too recently.
+		Unannounced,
+		/// Cannot add self as proxy.
+		NoSelfProxy,
+	}
+
+	/// The set of account proxies. Maps the account which has delegated to the accounts
+	/// which are being delegated to, together with the amount held on deposit.
+	#[pallet::storage]
+	#[pallet::getter(fn proxies)]
+	pub type Proxies<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		(
+			BoundedVec<
+				ProxyDefinition<T::AccountId, T::ProxyType, BlockNumberFor<T>>,
+				T::MaxProxies,
+			>,
+			BalanceOf<T>,
+		),
+		ValueQuery,
+	>;
+
+	/// The announcements made by the proxy (key).
+	#[pallet::storage]
+	#[pallet::getter(fn announcements)]
+	pub type Announcements<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		(
+			BoundedVec<Announcement<T::AccountId, CallHashOf<T>, BlockNumberFor<T>>, T::MaxPending>,
+			BalanceOf<T>,
+		),
+		ValueQuery,
+	>;
+}
+
+impl<T: Config> Pallet<T> {
+	/// Calculate the address of an pure account.
+	///
+	/// - `who`: The spawner account.
+	/// - `proxy_type`: The type of the proxy that the sender will be registered as over the
+	/// new account. This will almost always be the most permissive `ProxyType` possible to
+	/// allow for maximum flexibility.
+	/// - `index`: A disambiguation index, in case this is called multiple times in the same
+	/// transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just
+	/// want to use `0`.
+	/// - `maybe_when`: The block height and extrinsic index of when the pure account was
+	/// created. None to use current block height and extrinsic index.
+	pub fn pure_account(
+		who: &T::AccountId,
+		proxy_type: &T::ProxyType,
+		index: u16,
+		maybe_when: Option<(BlockNumberFor<T>, u32)>,
+	) -> T::AccountId {
+		let (height, ext_index) = maybe_when.unwrap_or_else(|| {
+			(
+				system::Pallet::<T>::block_number(),
+				system::Pallet::<T>::extrinsic_index().unwrap_or_default(),
+			)
+		});
+		let entropy = (b"modlpy/proxy____", who, height, ext_index, proxy_type, index)
+			.using_encoded(blake2_256);
+		Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+			.expect("infinite length input; no invalid inputs for type; qed")
+	}
+
+	/// Register a proxy account for the delegator that is able to make calls on its behalf.
+	///
+	/// Parameters:
+	/// - `delegator`: The delegator account.
+	/// - `delegatee`: The account that the `delegator` would like to make a proxy.
+	/// - `proxy_type`: The permissions allowed for this proxy account.
+	/// - `delay`: The announcement period required of the initial proxy. Will generally be
+	/// zero.
+	pub fn add_proxy_delegate(
+		delegator: &T::AccountId,
+		delegatee: T::AccountId,
+		proxy_type: T::ProxyType,
+		delay: BlockNumberFor<T>,
+	) -> DispatchResult {
+		ensure!(delegator != &delegatee, Error::<T>::NoSelfProxy);
+		Proxies::<T>::try_mutate(delegator, |(ref mut proxies, ref mut deposit)| {
+			let proxy_def = ProxyDefinition {
+				delegate: delegatee.clone(),
+				proxy_type: proxy_type.clone(),
+				delay,
+			};
+			let i = proxies.binary_search(&proxy_def).err().ok_or(Error::<T>::Duplicate)?;
+			proxies.try_insert(i, proxy_def).map_err(|_| Error::<T>::TooMany)?;
+			let new_deposit = Self::deposit(proxies.len() as u32);
+			if new_deposit > *deposit {
+				T::Currency::reserve(delegator, new_deposit - *deposit)?;
+			} else if new_deposit < *deposit {
+				T::Currency::unreserve(delegator, *deposit - new_deposit);
+			}
+			*deposit = new_deposit;
+			Self::deposit_event(Event::<T>::ProxyAdded {
+				delegator: delegator.clone(),
+				delegatee,
+				proxy_type,
+				delay,
+			});
+			Ok(())
+		})
+	}
+
+	/// Unregister a proxy account for the delegator.
+	///
+	/// Parameters:
+	/// - `delegator`: The delegator account.
+	/// - `delegatee`: The account that the `delegator` would like to make a proxy.
+	/// - `proxy_type`: The permissions allowed for this proxy account.
+	/// - `delay`: The announcement period required of the initial proxy. Will generally be
+	/// zero.
+	pub fn remove_proxy_delegate(
+		delegator: &T::AccountId,
+		delegatee: T::AccountId,
+		proxy_type: T::ProxyType,
+		delay: BlockNumberFor<T>,
+	) -> DispatchResult {
+		Proxies::<T>::try_mutate_exists(delegator, |x| {
+			let (mut proxies, old_deposit) = x.take().ok_or(Error::<T>::NotFound)?;
+			let proxy_def = ProxyDefinition {
+				delegate: delegatee.clone(),
+				proxy_type: proxy_type.clone(),
+				delay,
+			};
+			let i = proxies.binary_search(&proxy_def).ok().ok_or(Error::<T>::NotFound)?;
+			proxies.remove(i);
+			let new_deposit = Self::deposit(proxies.len() as u32);
+			if new_deposit > old_deposit {
+				T::Currency::reserve(delegator, new_deposit - old_deposit)?;
+			} else if new_deposit < old_deposit {
+				T::Currency::unreserve(delegator, old_deposit - new_deposit);
+			}
+			if !proxies.is_empty() {
+				*x = Some((proxies, new_deposit))
+			}
+			Self::deposit_event(Event::<T>::ProxyRemoved {
+				delegator: delegator.clone(),
+				delegatee,
+				proxy_type,
+				delay,
+			});
+			Ok(())
+		})
+	}
+
+	pub fn deposit(num_proxies: u32) -> BalanceOf<T> {
+		if num_proxies == 0 {
+			Zero::zero()
+		} else {
+			T::ProxyDepositBase::get() + T::ProxyDepositFactor::get() * num_proxies.into()
+		}
+	}
+
+	fn rejig_deposit(
+		who: &T::AccountId,
+		old_deposit: BalanceOf<T>,
+		base: BalanceOf<T>,
+		factor: BalanceOf<T>,
+		len: usize,
+	) -> Result<Option<BalanceOf<T>>, DispatchError> {
+		let new_deposit =
+			if len == 0 { BalanceOf::<T>::zero() } else { base + factor * (len as u32).into() };
+		if new_deposit > old_deposit {
+			T::Currency::reserve(who, new_deposit - old_deposit)?;
+		} else if new_deposit < old_deposit {
+			T::Currency::unreserve(who, old_deposit - new_deposit);
+		}
+		Ok(if len == 0 { None } else { Some(new_deposit) })
+	}
+
+	fn edit_announcements<
+		F: FnMut(&Announcement<T::AccountId, CallHashOf<T>, BlockNumberFor<T>>) -> bool,
+	>(
+		delegate: &T::AccountId,
+		f: F,
+	) -> DispatchResult {
+		Announcements::<T>::try_mutate_exists(delegate, |x| {
+			let (mut pending, old_deposit) = x.take().ok_or(Error::<T>::NotFound)?;
+			let orig_pending_len = pending.len();
+			pending.retain(f);
+			ensure!(orig_pending_len > pending.len(), Error::<T>::NotFound);
+			*x = Self::rejig_deposit(
+				delegate,
+				old_deposit,
+				T::AnnouncementDepositBase::get(),
+				T::AnnouncementDepositFactor::get(),
+				pending.len(),
+			)?
+			.map(|deposit| (pending, deposit));
+			Ok(())
+		})
+	}
+
+	pub fn find_proxy(
+		real: &T::AccountId,
+		delegate: &T::AccountId,
+		force_proxy_type: Option<T::ProxyType>,
+	) -> Result<ProxyDefinition<T::AccountId, T::ProxyType, BlockNumberFor<T>>, DispatchError> {
+		let f = |x: &ProxyDefinition<T::AccountId, T::ProxyType, BlockNumberFor<T>>| -> bool {
+			&x.delegate == delegate &&
+				force_proxy_type.as_ref().map_or(true, |y| &x.proxy_type == y)
+		};
+		Ok(Proxies::<T>::get(real).0.into_iter().find(f).ok_or(Error::<T>::NotProxy)?)
+	}
+
+	fn do_proxy(
+		def: ProxyDefinition<T::AccountId, T::ProxyType, BlockNumberFor<T>>,
+		real: T::AccountId,
+		call: <T as Config>::RuntimeCall,
+	) {
+		// This is a freshly authenticated new account, the origin restrictions doesn't apply.
+		let mut origin: T::RuntimeOrigin = frame_system::RawOrigin::Signed(real).into();
+		origin.add_filter(move |c: &<T as frame_system::Config>::RuntimeCall| {
+			let c = <T as Config>::RuntimeCall::from_ref(c);
+			// We make sure the proxy call does access this pallet to change modify proxies.
+			match c.is_sub_type() {
+				// Proxy call cannot add or remove a proxy with more permissions than it already
+				// has.
+				Some(Call::add_proxy { ref proxy_type, .. }) |
+				Some(Call::remove_proxy { ref proxy_type, .. })
+					if !def.proxy_type.is_superset(proxy_type) =>
+					false,
+				// Proxy call cannot remove all proxies or kill pure proxies unless it has full
+				// permissions.
+				Some(Call::remove_proxies { .. }) | Some(Call::kill_pure { .. })
+					if def.proxy_type != T::ProxyType::default() =>
+					false,
+				_ => def.proxy_type.filter(c),
+			}
+		});
+		let e = call.dispatch(origin);
+		Self::deposit_event(Event::ProxyExecuted { result: e.map(|_| ()).map_err(|e| e.error) });
+	}
+
+	/// Removes all proxy delegates for a given delegator.
+	///
+	/// Parameters:
+	/// - `delegator`: The delegator account.
+	pub fn remove_all_proxy_delegates(delegator: &T::AccountId) {
+		let (_, old_deposit) = Proxies::<T>::take(&delegator);
+		T::Currency::unreserve(&delegator, old_deposit);
+	}
+}
diff --git a/substrate/frame/proxy/src/tests.rs b/substrate/frame/proxy/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..48a2a4ed0cc33b1d21fabb4a08d30a41046c70d3
--- /dev/null
+++ b/substrate/frame/proxy/src/tests.rs
@@ -0,0 +1,604 @@
+// 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 Proxy Pallet
+
+#![cfg(test)]
+
+use super::*;
+
+use crate as proxy;
+use codec::{Decode, Encode};
+use frame_support::{
+	assert_noop, assert_ok, derive_impl,
+	dispatch::DispatchError,
+	traits::{ConstU32, ConstU64, Contains},
+};
+use sp_core::H256;
+use sp_runtime::{traits::BlakeTwo256, BuildStorage, RuntimeDebug};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Proxy: proxy::{Pallet, Call, Storage, Event<T>},
+		Utility: pallet_utility::{Pallet, Call, Event},
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+	type Block = Block;
+	type BlockHashCount = ConstU64<250>;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+
+	type BaseCallFilter = BaseFilter;
+	type AccountData = pallet_balances::AccountData<u64>;
+}
+
+#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig as pallet_balances::DefaultConfig)]
+impl pallet_balances::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeHoldReason = ();
+	type ReserveIdentifier = [u8; 8];
+	type DustRemoval = ();
+	type AccountStore = System;
+	type ExistentialDeposit = ConstU64<1>;
+}
+
+impl pallet_utility::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+}
+
+#[derive(
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	Encode,
+	Decode,
+	RuntimeDebug,
+	MaxEncodedLen,
+	scale_info::TypeInfo,
+)]
+pub enum ProxyType {
+	Any,
+	JustTransfer,
+	JustUtility,
+}
+impl Default for ProxyType {
+	fn default() -> Self {
+		Self::Any
+	}
+}
+impl InstanceFilter<RuntimeCall> for ProxyType {
+	fn filter(&self, c: &RuntimeCall) -> bool {
+		match self {
+			ProxyType::Any => true,
+			ProxyType::JustTransfer => {
+				matches!(
+					c,
+					RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death { .. })
+				)
+			},
+			ProxyType::JustUtility => matches!(c, RuntimeCall::Utility { .. }),
+		}
+	}
+	fn is_superset(&self, o: &Self) -> bool {
+		self == &ProxyType::Any || self == o
+	}
+}
+pub struct BaseFilter;
+impl Contains<RuntimeCall> for BaseFilter {
+	fn contains(c: &RuntimeCall) -> bool {
+		match *c {
+			// Remark is used as a no-op call in the benchmarking
+			RuntimeCall::System(SystemCall::remark { .. }) => true,
+			RuntimeCall::System(_) => false,
+			_ => true,
+		}
+	}
+}
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type ProxyType = ProxyType;
+	type ProxyDepositBase = ConstU64<1>;
+	type ProxyDepositFactor = ConstU64<1>;
+	type MaxProxies = ConstU32<4>;
+	type WeightInfo = ();
+	type CallHasher = BlakeTwo256;
+	type MaxPending = ConstU32<2>;
+	type AnnouncementDepositBase = ConstU64<1>;
+	type AnnouncementDepositFactor = ConstU64<1>;
+}
+
+use super::{Call as ProxyCall, Event as ProxyEvent};
+use frame_system::Call as SystemCall;
+use pallet_balances::{Call as BalancesCall, Event as BalancesEvent};
+use pallet_utility::{Call as UtilityCall, Event as UtilityEvent};
+
+type SystemError = frame_system::Error<Test>;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 10), (3, 10), (4, 10), (5, 3)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+fn last_events(n: usize) -> Vec<RuntimeEvent> {
+	system::Pallet::<Test>::events()
+		.into_iter()
+		.rev()
+		.take(n)
+		.rev()
+		.map(|e| e.event)
+		.collect()
+}
+
+fn expect_events(e: Vec<RuntimeEvent>) {
+	assert_eq!(last_events(e.len()), e);
+}
+
+fn call_transfer(dest: u64, value: u64) -> RuntimeCall {
+	RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest, value })
+}
+
+#[test]
+fn announcement_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 3, ProxyType::Any, 1));
+		System::assert_last_event(
+			ProxyEvent::ProxyAdded {
+				delegator: 1,
+				delegatee: 3,
+				proxy_type: ProxyType::Any,
+				delay: 1,
+			}
+			.into(),
+		);
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(2), 3, ProxyType::Any, 1));
+		assert_eq!(Balances::reserved_balance(3), 0);
+
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 1, [1; 32].into()));
+		let announcements = Announcements::<Test>::get(3);
+		assert_eq!(
+			announcements.0,
+			vec![Announcement { real: 1, call_hash: [1; 32].into(), height: 1 }]
+		);
+		assert_eq!(Balances::reserved_balance(3), announcements.1);
+
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 2, [2; 32].into()));
+		let announcements = Announcements::<Test>::get(3);
+		assert_eq!(
+			announcements.0,
+			vec![
+				Announcement { real: 1, call_hash: [1; 32].into(), height: 1 },
+				Announcement { real: 2, call_hash: [2; 32].into(), height: 1 },
+			]
+		);
+		assert_eq!(Balances::reserved_balance(3), announcements.1);
+
+		assert_noop!(
+			Proxy::announce(RuntimeOrigin::signed(3), 2, [3; 32].into()),
+			Error::<Test>::TooMany
+		);
+	});
+}
+
+#[test]
+fn remove_announcement_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 3, ProxyType::Any, 1));
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(2), 3, ProxyType::Any, 1));
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 1, [1; 32].into()));
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 2, [2; 32].into()));
+		let e = Error::<Test>::NotFound;
+		assert_noop!(Proxy::remove_announcement(RuntimeOrigin::signed(3), 1, [0; 32].into()), e);
+		assert_ok!(Proxy::remove_announcement(RuntimeOrigin::signed(3), 1, [1; 32].into()));
+		let announcements = Announcements::<Test>::get(3);
+		assert_eq!(
+			announcements.0,
+			vec![Announcement { real: 2, call_hash: [2; 32].into(), height: 1 }]
+		);
+		assert_eq!(Balances::reserved_balance(3), announcements.1);
+	});
+}
+
+#[test]
+fn reject_announcement_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 3, ProxyType::Any, 1));
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(2), 3, ProxyType::Any, 1));
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 1, [1; 32].into()));
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 2, [2; 32].into()));
+		let e = Error::<Test>::NotFound;
+		assert_noop!(Proxy::reject_announcement(RuntimeOrigin::signed(1), 3, [0; 32].into()), e);
+		let e = Error::<Test>::NotFound;
+		assert_noop!(Proxy::reject_announcement(RuntimeOrigin::signed(4), 3, [1; 32].into()), e);
+		assert_ok!(Proxy::reject_announcement(RuntimeOrigin::signed(1), 3, [1; 32].into()));
+		let announcements = Announcements::<Test>::get(3);
+		assert_eq!(
+			announcements.0,
+			vec![Announcement { real: 2, call_hash: [2; 32].into(), height: 1 }]
+		);
+		assert_eq!(Balances::reserved_balance(3), announcements.1);
+	});
+}
+
+#[test]
+fn announcer_must_be_proxy() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			Proxy::announce(RuntimeOrigin::signed(2), 1, H256::zero()),
+			Error::<Test>::NotProxy
+		);
+	});
+}
+
+#[test]
+fn calling_proxy_doesnt_remove_announcement() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::Any, 0));
+
+		let call = Box::new(call_transfer(6, 1));
+		let call_hash = BlakeTwo256::hash_of(&call);
+
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(2), 1, call_hash));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call));
+
+		// The announcement is not removed by calling proxy.
+		let announcements = Announcements::<Test>::get(2);
+		assert_eq!(announcements.0, vec![Announcement { real: 1, call_hash, height: 1 }]);
+	});
+}
+
+#[test]
+fn delayed_requires_pre_announcement() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::Any, 1));
+		let call = Box::new(call_transfer(6, 1));
+		let e = Error::<Test>::Unannounced;
+		assert_noop!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call.clone()), e);
+		let e = Error::<Test>::Unannounced;
+		assert_noop!(Proxy::proxy_announced(RuntimeOrigin::signed(0), 2, 1, None, call.clone()), e);
+		let call_hash = BlakeTwo256::hash_of(&call);
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(2), 1, call_hash));
+		system::Pallet::<Test>::set_block_number(2);
+		assert_ok!(Proxy::proxy_announced(RuntimeOrigin::signed(0), 2, 1, None, call.clone()));
+	});
+}
+
+#[test]
+fn proxy_announced_removes_announcement_and_returns_deposit() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 3, ProxyType::Any, 1));
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(2), 3, ProxyType::Any, 1));
+		let call = Box::new(call_transfer(6, 1));
+		let call_hash = BlakeTwo256::hash_of(&call);
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 1, call_hash));
+		assert_ok!(Proxy::announce(RuntimeOrigin::signed(3), 2, call_hash));
+		// Too early to execute announced call
+		let e = Error::<Test>::Unannounced;
+		assert_noop!(Proxy::proxy_announced(RuntimeOrigin::signed(0), 3, 1, None, call.clone()), e);
+
+		system::Pallet::<Test>::set_block_number(2);
+		assert_ok!(Proxy::proxy_announced(RuntimeOrigin::signed(0), 3, 1, None, call.clone()));
+		let announcements = Announcements::<Test>::get(3);
+		assert_eq!(announcements.0, vec![Announcement { real: 2, call_hash, height: 1 }]);
+		assert_eq!(Balances::reserved_balance(3), announcements.1);
+	});
+}
+
+#[test]
+fn filtering_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 1000);
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::Any, 0));
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 3, ProxyType::JustTransfer, 0));
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 4, ProxyType::JustUtility, 0));
+
+		let call = Box::new(call_transfer(6, 1));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call.clone()));
+		System::assert_last_event(ProxyEvent::ProxyExecuted { result: Ok(()) }.into());
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(3), 1, None, call.clone()));
+		System::assert_last_event(ProxyEvent::ProxyExecuted { result: Ok(()) }.into());
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(4), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+
+		let derivative_id = Utility::derivative_account_id(1, 0);
+		Balances::make_free_balance_be(&derivative_id, 1000);
+		let inner = Box::new(call_transfer(6, 1));
+
+		let call = Box::new(RuntimeCall::Utility(UtilityCall::as_derivative {
+			index: 0,
+			call: inner.clone(),
+		}));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call.clone()));
+		System::assert_last_event(ProxyEvent::ProxyExecuted { result: Ok(()) }.into());
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(3), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(4), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+
+		let call = Box::new(RuntimeCall::Utility(UtilityCall::batch { calls: vec![*inner] }));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call.clone()));
+		expect_events(vec![
+			UtilityEvent::BatchCompleted.into(),
+			ProxyEvent::ProxyExecuted { result: Ok(()) }.into(),
+		]);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(3), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(4), 1, None, call.clone()));
+		expect_events(vec![
+			UtilityEvent::BatchInterrupted { index: 0, error: SystemError::CallFiltered.into() }
+				.into(),
+			ProxyEvent::ProxyExecuted { result: Ok(()) }.into(),
+		]);
+
+		let inner = Box::new(RuntimeCall::Proxy(ProxyCall::new_call_variant_add_proxy(
+			5,
+			ProxyType::Any,
+			0,
+		)));
+		let call = Box::new(RuntimeCall::Utility(UtilityCall::batch { calls: vec![*inner] }));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call.clone()));
+		expect_events(vec![
+			UtilityEvent::BatchCompleted.into(),
+			ProxyEvent::ProxyExecuted { result: Ok(()) }.into(),
+		]);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(3), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(4), 1, None, call.clone()));
+		expect_events(vec![
+			UtilityEvent::BatchInterrupted { index: 0, error: SystemError::CallFiltered.into() }
+				.into(),
+			ProxyEvent::ProxyExecuted { result: Ok(()) }.into(),
+		]);
+
+		let call = Box::new(RuntimeCall::Proxy(ProxyCall::remove_proxies {}));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(3), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(4), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call.clone()));
+		expect_events(vec![
+			BalancesEvent::<Test>::Unreserved { who: 1, amount: 5 }.into(),
+			ProxyEvent::ProxyExecuted { result: Ok(()) }.into(),
+		]);
+	});
+}
+
+#[test]
+fn add_remove_proxies_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::Any, 0));
+		assert_noop!(
+			Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::Any, 0),
+			Error::<Test>::Duplicate
+		);
+		assert_eq!(Balances::reserved_balance(1), 2);
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::JustTransfer, 0));
+		assert_eq!(Balances::reserved_balance(1), 3);
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 3, ProxyType::Any, 0));
+		assert_eq!(Balances::reserved_balance(1), 4);
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 4, ProxyType::JustUtility, 0));
+		assert_eq!(Balances::reserved_balance(1), 5);
+		assert_noop!(
+			Proxy::add_proxy(RuntimeOrigin::signed(1), 4, ProxyType::Any, 0),
+			Error::<Test>::TooMany
+		);
+		assert_noop!(
+			Proxy::remove_proxy(RuntimeOrigin::signed(1), 3, ProxyType::JustTransfer, 0),
+			Error::<Test>::NotFound
+		);
+		assert_ok!(Proxy::remove_proxy(RuntimeOrigin::signed(1), 4, ProxyType::JustUtility, 0));
+		System::assert_last_event(
+			ProxyEvent::ProxyRemoved {
+				delegator: 1,
+				delegatee: 4,
+				proxy_type: ProxyType::JustUtility,
+				delay: 0,
+			}
+			.into(),
+		);
+		assert_eq!(Balances::reserved_balance(1), 4);
+		assert_ok!(Proxy::remove_proxy(RuntimeOrigin::signed(1), 3, ProxyType::Any, 0));
+		assert_eq!(Balances::reserved_balance(1), 3);
+		System::assert_last_event(
+			ProxyEvent::ProxyRemoved {
+				delegator: 1,
+				delegatee: 3,
+				proxy_type: ProxyType::Any,
+				delay: 0,
+			}
+			.into(),
+		);
+		assert_ok!(Proxy::remove_proxy(RuntimeOrigin::signed(1), 2, ProxyType::Any, 0));
+		assert_eq!(Balances::reserved_balance(1), 2);
+		System::assert_last_event(
+			ProxyEvent::ProxyRemoved {
+				delegator: 1,
+				delegatee: 2,
+				proxy_type: ProxyType::Any,
+				delay: 0,
+			}
+			.into(),
+		);
+		assert_ok!(Proxy::remove_proxy(RuntimeOrigin::signed(1), 2, ProxyType::JustTransfer, 0));
+		assert_eq!(Balances::reserved_balance(1), 0);
+		System::assert_last_event(
+			ProxyEvent::ProxyRemoved {
+				delegator: 1,
+				delegatee: 2,
+				proxy_type: ProxyType::JustTransfer,
+				delay: 0,
+			}
+			.into(),
+		);
+		assert_noop!(
+			Proxy::add_proxy(RuntimeOrigin::signed(1), 1, ProxyType::Any, 0),
+			Error::<Test>::NoSelfProxy
+		);
+	});
+}
+
+#[test]
+fn cannot_add_proxy_without_balance() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(5), 3, ProxyType::Any, 0));
+		assert_eq!(Balances::reserved_balance(5), 2);
+		assert_noop!(
+			Proxy::add_proxy(RuntimeOrigin::signed(5), 4, ProxyType::Any, 0),
+			DispatchError::ConsumerRemaining,
+		);
+	});
+}
+
+#[test]
+fn proxying_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::JustTransfer, 0));
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 3, ProxyType::Any, 0));
+
+		let call = Box::new(call_transfer(6, 1));
+		assert_noop!(
+			Proxy::proxy(RuntimeOrigin::signed(4), 1, None, call.clone()),
+			Error::<Test>::NotProxy
+		);
+		assert_noop!(
+			Proxy::proxy(RuntimeOrigin::signed(2), 1, Some(ProxyType::Any), call.clone()),
+			Error::<Test>::NotProxy
+		);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, call.clone()));
+		System::assert_last_event(ProxyEvent::ProxyExecuted { result: Ok(()) }.into());
+		assert_eq!(Balances::free_balance(6), 1);
+
+		let call = Box::new(RuntimeCall::System(SystemCall::set_code { code: vec![] }));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(3), 1, None, call.clone()));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+
+		let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_keep_alive {
+			dest: 6,
+			value: 1,
+		}));
+		assert_ok!(RuntimeCall::Proxy(super::Call::new_call_variant_proxy(1, None, call.clone()))
+			.dispatch(RuntimeOrigin::signed(2)));
+		System::assert_last_event(
+			ProxyEvent::ProxyExecuted { result: Err(SystemError::CallFiltered.into()) }.into(),
+		);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(3), 1, None, call.clone()));
+		System::assert_last_event(ProxyEvent::ProxyExecuted { result: Ok(()) }.into());
+		assert_eq!(Balances::free_balance(6), 2);
+	});
+}
+
+#[test]
+fn pure_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 11); // An extra one for the ED.
+		assert_ok!(Proxy::create_pure(RuntimeOrigin::signed(1), ProxyType::Any, 0, 0));
+		let anon = Proxy::pure_account(&1, &ProxyType::Any, 0, None);
+		System::assert_last_event(
+			ProxyEvent::PureCreated {
+				pure: anon,
+				who: 1,
+				proxy_type: ProxyType::Any,
+				disambiguation_index: 0,
+			}
+			.into(),
+		);
+
+		// other calls to pure allowed as long as they're not exactly the same.
+		assert_ok!(Proxy::create_pure(RuntimeOrigin::signed(1), ProxyType::JustTransfer, 0, 0));
+		assert_ok!(Proxy::create_pure(RuntimeOrigin::signed(1), ProxyType::Any, 0, 1));
+		let anon2 = Proxy::pure_account(&2, &ProxyType::Any, 0, None);
+		assert_ok!(Proxy::create_pure(RuntimeOrigin::signed(2), ProxyType::Any, 0, 0));
+		assert_noop!(
+			Proxy::create_pure(RuntimeOrigin::signed(1), ProxyType::Any, 0, 0),
+			Error::<Test>::Duplicate
+		);
+		System::set_extrinsic_index(1);
+		assert_ok!(Proxy::create_pure(RuntimeOrigin::signed(1), ProxyType::Any, 0, 0));
+		System::set_extrinsic_index(0);
+		System::set_block_number(2);
+		assert_ok!(Proxy::create_pure(RuntimeOrigin::signed(1), ProxyType::Any, 0, 0));
+
+		let call = Box::new(call_transfer(6, 1));
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(3), anon, 5));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(1), anon, None, call));
+		System::assert_last_event(ProxyEvent::ProxyExecuted { result: Ok(()) }.into());
+		assert_eq!(Balances::free_balance(6), 1);
+
+		let call = Box::new(RuntimeCall::Proxy(ProxyCall::new_call_variant_kill_pure(
+			1,
+			ProxyType::Any,
+			0,
+			1,
+			0,
+		)));
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), anon2, None, call.clone()));
+		let de = DispatchError::from(Error::<Test>::NoPermission).stripped();
+		System::assert_last_event(ProxyEvent::ProxyExecuted { result: Err(de) }.into());
+		assert_noop!(
+			Proxy::kill_pure(RuntimeOrigin::signed(1), 1, ProxyType::Any, 0, 1, 0),
+			Error::<Test>::NoPermission
+		);
+		assert_eq!(Balances::free_balance(1), 1);
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(1), anon, None, call.clone()));
+		assert_eq!(Balances::free_balance(1), 3);
+		assert_noop!(
+			Proxy::proxy(RuntimeOrigin::signed(1), anon, None, call.clone()),
+			Error::<Test>::NotProxy
+		);
+	});
+}
diff --git a/substrate/frame/proxy/src/weights.rs b/substrate/frame/proxy/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f30fe73d27ae665fca89761585226d906fd5112c
--- /dev/null
+++ b/substrate/frame/proxy/src/weights.rs
@@ -0,0 +1,400 @@
+// 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.
+
+//! Autogenerated weights for pallet_proxy
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_proxy
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/proxy/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_proxy.
+pub trait WeightInfo {
+	fn proxy(p: u32, ) -> Weight;
+	fn proxy_announced(a: u32, p: u32, ) -> Weight;
+	fn remove_announcement(a: u32, p: u32, ) -> Weight;
+	fn reject_announcement(a: u32, p: u32, ) -> Weight;
+	fn announce(a: u32, p: u32, ) -> Weight;
+	fn add_proxy(p: u32, ) -> Weight;
+	fn remove_proxy(p: u32, ) -> Weight;
+	fn remove_proxies(p: u32, ) -> Weight;
+	fn create_pure(p: u32, ) -> Weight;
+	fn kill_pure(p: u32, ) -> Weight;
+}
+
+/// Weights for pallet_proxy using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Proxy Proxies (r:1 w:0)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 15_182_000 picoseconds.
+		Weight::from_parts(15_919_146, 4706)
+			// Standard Error: 1_586
+			.saturating_add(Weight::from_parts(31_768, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:0)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn proxy_announced(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `488 + a * (68 ±0) + p * (37 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 40_256_000 picoseconds.
+		Weight::from_parts(40_373_648, 5698)
+			// Standard Error: 3_978
+			.saturating_add(Weight::from_parts(166_936, 0).saturating_mul(a.into()))
+			// Standard Error: 4_110
+			.saturating_add(Weight::from_parts(54_329, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_announcement(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + a * (68 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 25_040_000 picoseconds.
+		Weight::from_parts(25_112_188, 5698)
+			// Standard Error: 2_143
+			.saturating_add(Weight::from_parts(189_027, 0).saturating_mul(a.into()))
+			// Standard Error: 2_214
+			.saturating_add(Weight::from_parts(26_683, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn reject_announcement(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + a * (68 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 24_884_000 picoseconds.
+		Weight::from_parts(25_359_291, 5698)
+			// Standard Error: 2_019
+			.saturating_add(Weight::from_parts(181_470, 0).saturating_mul(a.into()))
+			// Standard Error: 2_086
+			.saturating_add(Weight::from_parts(17_725, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:0)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn announce(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `420 + a * (68 ±0) + p * (37 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 35_039_000 picoseconds.
+		Weight::from_parts(36_727_868, 5698)
+			// Standard Error: 4_463
+			.saturating_add(Weight::from_parts(167_060, 0).saturating_mul(a.into()))
+			// Standard Error: 4_611
+			.saturating_add(Weight::from_parts(59_836, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn add_proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 25_697_000 picoseconds.
+		Weight::from_parts(26_611_090, 4706)
+			// Standard Error: 2_306
+			.saturating_add(Weight::from_parts(85_165, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 25_638_000 picoseconds.
+		Weight::from_parts(26_904_510, 4706)
+			// Standard Error: 2_669
+			.saturating_add(Weight::from_parts(61_668, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_proxies(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 22_737_000 picoseconds.
+		Weight::from_parts(23_618_441, 4706)
+			// Standard Error: 1_729
+			.saturating_add(Weight::from_parts(44_009, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn create_pure(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `173`
+		//  Estimated: `4706`
+		// Minimum execution time: 27_364_000 picoseconds.
+		Weight::from_parts(28_632_271, 4706)
+			// Standard Error: 1_613
+			.saturating_add(Weight::from_parts(2_453, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[0, 30]`.
+	fn kill_pure(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `198 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 23_552_000 picoseconds.
+		Weight::from_parts(24_874_553, 4706)
+			// Standard Error: 1_919
+			.saturating_add(Weight::from_parts(38_799, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Proxy Proxies (r:1 w:0)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 15_182_000 picoseconds.
+		Weight::from_parts(15_919_146, 4706)
+			// Standard Error: 1_586
+			.saturating_add(Weight::from_parts(31_768, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:0)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn proxy_announced(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `488 + a * (68 ±0) + p * (37 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 40_256_000 picoseconds.
+		Weight::from_parts(40_373_648, 5698)
+			// Standard Error: 3_978
+			.saturating_add(Weight::from_parts(166_936, 0).saturating_mul(a.into()))
+			// Standard Error: 4_110
+			.saturating_add(Weight::from_parts(54_329, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_announcement(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + a * (68 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 25_040_000 picoseconds.
+		Weight::from_parts(25_112_188, 5698)
+			// Standard Error: 2_143
+			.saturating_add(Weight::from_parts(189_027, 0).saturating_mul(a.into()))
+			// Standard Error: 2_214
+			.saturating_add(Weight::from_parts(26_683, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn reject_announcement(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `403 + a * (68 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 24_884_000 picoseconds.
+		Weight::from_parts(25_359_291, 5698)
+			// Standard Error: 2_019
+			.saturating_add(Weight::from_parts(181_470, 0).saturating_mul(a.into()))
+			// Standard Error: 2_086
+			.saturating_add(Weight::from_parts(17_725, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:0)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// Storage: Proxy Announcements (r:1 w:1)
+	/// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `a` is `[0, 31]`.
+	/// The range of component `p` is `[1, 31]`.
+	fn announce(a: u32, p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `420 + a * (68 ±0) + p * (37 ±0)`
+		//  Estimated: `5698`
+		// Minimum execution time: 35_039_000 picoseconds.
+		Weight::from_parts(36_727_868, 5698)
+			// Standard Error: 4_463
+			.saturating_add(Weight::from_parts(167_060, 0).saturating_mul(a.into()))
+			// Standard Error: 4_611
+			.saturating_add(Weight::from_parts(59_836, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn add_proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 25_697_000 picoseconds.
+		Weight::from_parts(26_611_090, 4706)
+			// Standard Error: 2_306
+			.saturating_add(Weight::from_parts(85_165, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_proxy(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 25_638_000 picoseconds.
+		Weight::from_parts(26_904_510, 4706)
+			// Standard Error: 2_669
+			.saturating_add(Weight::from_parts(61_668, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn remove_proxies(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 22_737_000 picoseconds.
+		Weight::from_parts(23_618_441, 4706)
+			// Standard Error: 1_729
+			.saturating_add(Weight::from_parts(44_009, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[1, 31]`.
+	fn create_pure(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `173`
+		//  Estimated: `4706`
+		// Minimum execution time: 27_364_000 picoseconds.
+		Weight::from_parts(28_632_271, 4706)
+			// Standard Error: 1_613
+			.saturating_add(Weight::from_parts(2_453, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Proxy Proxies (r:1 w:1)
+	/// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen)
+	/// The range of component `p` is `[0, 30]`.
+	fn kill_pure(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `198 + p * (37 ±0)`
+		//  Estimated: `4706`
+		// Minimum execution time: 23_552_000 picoseconds.
+		Weight::from_parts(24_874_553, 4706)
+			// Standard Error: 1_919
+			.saturating_add(Weight::from_parts(38_799, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/ranked-collective/Cargo.toml b/substrate/frame/ranked-collective/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1152aeea4fa06bd25956834eec56d8e861d0bc2b
--- /dev/null
+++ b/substrate/frame/ranked-collective/Cargo.toml
@@ -0,0 +1,53 @@
+[package]
+name = "pallet-ranked-collective"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "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."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.16", default-features = false }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/ranked-collective/README.md b/substrate/frame/ranked-collective/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5fe65ef34920f3eecd6f595a0c3144ca9450d2a
--- /dev/null
+++ b/substrate/frame/ranked-collective/README.md
@@ -0,0 +1,22 @@
+# Ranked collective system.
+
+This is a membership pallet providing a `Tally` implementation ready for use with polling
+systems such as the Referenda pallet. Members each have a rank, with zero being the lowest.
+There is no complexity limitation on either the number of members at a rank or the number of
+ranks in the system thus allowing potentially public membership. A member of at least a given
+rank can be selected at random in O(1) time, allowing for various games to constructed using
+this as a primitive. Members may only be promoted and demoted by one rank at a time, however
+all operations (save one) are O(1) in complexity. The only operation which is not O(1) is the
+`remove_member` since they must be removed from all ranks from the present down to zero.
+
+Different ranks have different voting power, and are able to vote in different polls. In general
+rank privileges are cumulative. Higher ranks are able to vote in any polls open to lower ranks.
+Similarly, higher ranks always have at least as much voting power in any given poll as lower
+ranks.
+
+Two `Config` trait items control these "rank privileges": `MinRankOfClass` and `VoteWeight`.
+The first controls which ranks are allowed to vote on a particular class of poll. The second
+controls the weight of a vote given the voters rank compared to the minimum rank of the poll.
+
+An origin control, `EnsureRank`, ensures that the origin is a member of the collective of at
+least a particular rank.
diff --git a/substrate/frame/ranked-collective/src/benchmarking.rs b/substrate/frame/ranked-collective/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b610d10009a0899aac26d7f832f319f00595e624
--- /dev/null
+++ b/substrate/frame/ranked-collective/src/benchmarking.rs
@@ -0,0 +1,177 @@
+// 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.
+
+//! Staking pallet benchmarking.
+
+use super::*;
+#[allow(unused_imports)]
+use crate::Pallet as RankedCollective;
+
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelisted_caller, BenchmarkError,
+};
+use frame_support::{assert_ok, dispatch::UnfilteredDispatchable};
+use frame_system::RawOrigin as SystemOrigin;
+
+const SEED: u32 = 0;
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn make_member<T: Config<I>, I: 'static>(rank: Rank) -> T::AccountId {
+	let who = account::<T::AccountId>("member", MemberCount::<T, I>::get(0), SEED);
+	let who_lookup = T::Lookup::unlookup(who.clone());
+	assert_ok!(Pallet::<T, I>::add_member(
+		T::PromoteOrigin::try_successful_origin()
+			.expect("PromoteOrigin has no successful origin required for the benchmark"),
+		who_lookup.clone(),
+	));
+	for _ in 0..rank {
+		assert_ok!(Pallet::<T, I>::promote_member(
+			T::PromoteOrigin::try_successful_origin()
+				.expect("PromoteOrigin has no successful origin required for the benchmark"),
+			who_lookup.clone(),
+		));
+	}
+	who
+}
+
+benchmarks_instance_pallet! {
+	add_member {
+		let who = account::<T::AccountId>("member", 0, SEED);
+		let who_lookup = T::Lookup::unlookup(who.clone());
+		let origin =
+			T::PromoteOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::add_member { who: who_lookup };
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_eq!(MemberCount::<T, I>::get(0), 1);
+		assert_last_event::<T, I>(Event::MemberAdded { who }.into());
+	}
+
+	remove_member {
+		let r in 0 .. 10;
+		let rank = r as u16;
+		let first = make_member::<T, I>(rank);
+		let who = make_member::<T, I>(rank);
+		let who_lookup = T::Lookup::unlookup(who.clone());
+		let last = make_member::<T, I>(rank);
+		let last_index = (0..=rank).map(|r| IdToIndex::<T, I>::get(r, &last).unwrap()).collect::<Vec<_>>();
+		let origin =
+			T::DemoteOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::remove_member { who: who_lookup, min_rank: rank };
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		for r in 0..=rank {
+			assert_eq!(MemberCount::<T, I>::get(r), 2);
+			assert_ne!(last_index[r as usize], IdToIndex::<T, I>::get(r, &last).unwrap());
+		}
+		assert_last_event::<T, I>(Event::MemberRemoved { who, rank }.into());
+	}
+
+	promote_member {
+		let r in 0 .. 10;
+		let rank = r as u16;
+		let who = make_member::<T, I>(rank);
+		let who_lookup = T::Lookup::unlookup(who.clone());
+		let origin =
+			T::PromoteOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::promote_member { who: who_lookup };
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_eq!(Members::<T, I>::get(&who).unwrap().rank, rank + 1);
+		assert_last_event::<T, I>(Event::RankChanged { who, rank: rank + 1 }.into());
+	}
+
+	demote_member {
+		let r in 0 .. 10;
+		let rank = r as u16;
+		let first = make_member::<T, I>(rank);
+		let who = make_member::<T, I>(rank);
+		let who_lookup = T::Lookup::unlookup(who.clone());
+		let last = make_member::<T, I>(rank);
+		let last_index = IdToIndex::<T, I>::get(rank, &last).unwrap();
+		let origin =
+			T::DemoteOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::demote_member { who: who_lookup };
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_eq!(Members::<T, I>::get(&who).map(|x| x.rank), rank.checked_sub(1));
+		assert_eq!(MemberCount::<T, I>::get(rank), 2);
+		assert_ne!(last_index, IdToIndex::<T, I>::get(rank, &last).unwrap());
+		assert_last_event::<T, I>(match rank {
+			0 => Event::MemberRemoved { who, rank: 0 },
+			r => Event::RankChanged { who, rank: r - 1 },
+		}.into());
+	}
+
+	vote {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		assert_ok!(Pallet::<T, I>::add_member(
+			T::PromoteOrigin::try_successful_origin()
+				.expect("PromoteOrigin has no successful origin required for the benchmark"),
+			caller_lookup.clone(),
+		));
+		// Create a poll
+		let class = T::Polls::classes().into_iter().next().unwrap();
+		let rank = T::MinRankOfClass::convert(class.clone());
+		for _ in 0..rank {
+			assert_ok!(Pallet::<T, I>::promote_member(
+				T::PromoteOrigin::try_successful_origin()
+					.expect("PromoteOrigin has no successful origin required for the benchmark"),
+				caller_lookup.clone(),
+			));
+		}
+
+		let poll = T::Polls::create_ongoing(class).expect("Must always be able to create a poll for rank 0");
+
+		// Vote once.
+		assert_ok!(Pallet::<T, I>::vote(SystemOrigin::Signed(caller.clone()).into(), poll, true));
+	}: _(SystemOrigin::Signed(caller.clone()), poll, false)
+	verify {
+		let tally = Tally::from_parts(0, 0, 1);
+		let ev = Event::Voted { who: caller, poll, vote: VoteRecord::Nay(1), tally };
+		assert_last_event::<T, I>(ev.into());
+	}
+
+	cleanup_poll {
+		let n in 0 .. 100;
+
+		// Create a poll
+		let class = T::Polls::classes().into_iter().next().unwrap();
+		let rank = T::MinRankOfClass::convert(class.clone());
+		let poll = T::Polls::create_ongoing(class).expect("Must always be able to create a poll");
+
+		// Vote in the poll by each of `n` members
+		for i in 0..n {
+			let who = make_member::<T, I>(rank);
+			assert_ok!(Pallet::<T, I>::vote(SystemOrigin::Signed(who).into(), poll, true));
+		}
+
+		// End the poll.
+		T::Polls::end_ongoing(poll, false).expect("Must always be able to end a poll");
+
+		assert_eq!(Voting::<T, I>::iter_prefix(poll).count(), n as usize);
+	}: _(SystemOrigin::Signed(whitelisted_caller()), poll, n)
+	verify {
+		assert_eq!(Voting::<T, I>::iter().count(), 0);
+	}
+
+	impl_benchmark_test_suite!(RankedCollective, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/ranked-collective/src/lib.rs b/substrate/frame/ranked-collective/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d94932a1dac71a7e14afde4f96d52544b890a7b7
--- /dev/null
+++ b/substrate/frame/ranked-collective/src/lib.rs
@@ -0,0 +1,787 @@
+// 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.
+
+//! Ranked collective system.
+//!
+//! This is a membership pallet providing a `Tally` implementation ready for use with polling
+//! systems such as the Referenda pallet. Members each have a rank, with zero being the lowest.
+//! There is no complexity limitation on either the number of members at a rank or the number of
+//! ranks in the system thus allowing potentially public membership. A member of at least a given
+//! rank can be selected at random in O(1) time, allowing for various games to be constructed using
+//! this as a primitive. Members may only be promoted and demoted by one rank at a time, however
+//! all operations (save one) are O(1) in complexity. The only operation which is not O(1) is the
+//! `remove_member` since they must be removed from all ranks from the present down to zero.
+//!
+//! Different ranks have different voting power, and are able to vote in different polls. In general
+//! rank privileges are cumulative. Higher ranks are able to vote in any polls open to lower ranks.
+//! Similarly, higher ranks always have at least as much voting power in any given poll as lower
+//! ranks.
+//!
+//! Two `Config` trait items control these "rank privileges": `MinRankOfClass` and `VoteWeight`.
+//! The first controls which ranks are allowed to vote on a particular class of poll. The second
+//! controls the weight of a vote given the voter's rank compared to the minimum rank of the poll.
+//!
+//! An origin control, `EnsureRank`, ensures that the origin is a member of the collective of at
+//! least a particular rank.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![recursion_limit = "128"]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_arithmetic::traits::Saturating;
+use sp_runtime::{
+	traits::{Convert, StaticLookup},
+	ArithmeticError::Overflow,
+	Perbill, RuntimeDebug,
+};
+use sp_std::{marker::PhantomData, prelude::*};
+
+use frame_support::{
+	dispatch::{DispatchError, DispatchResultWithPostInfo, PostDispatchInfo},
+	ensure, impl_ensure_origin_with_arg_ignoring_arg,
+	traits::{EnsureOrigin, EnsureOriginWithArg, PollStatus, Polling, RankedMembers, VoteTally},
+	CloneNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod weights;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// A number of members.
+pub type MemberIndex = u32;
+
+/// Member rank.
+pub type Rank = u16;
+
+/// Votes.
+pub type Votes = u32;
+
+/// Aggregated votes for an ongoing poll by members of the ranked collective.
+#[derive(
+	CloneNoBound,
+	PartialEqNoBound,
+	EqNoBound,
+	RuntimeDebugNoBound,
+	TypeInfo,
+	Encode,
+	Decode,
+	MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(T, I, M))]
+#[codec(mel_bound())]
+pub struct Tally<T, I, M: GetMaxVoters> {
+	bare_ayes: MemberIndex,
+	ayes: Votes,
+	nays: Votes,
+	dummy: PhantomData<(T, I, M)>,
+}
+
+impl<T: Config<I>, I: 'static, M: GetMaxVoters> Tally<T, I, M> {
+	pub fn from_parts(bare_ayes: MemberIndex, ayes: Votes, nays: Votes) -> Self {
+		Tally { bare_ayes, ayes, nays, dummy: PhantomData }
+	}
+}
+
+// Use (non-rank-weighted) ayes for calculating support.
+// Allow only promotion/demotion by one rank only.
+// Allow removal of member with rank zero only.
+// This keeps everything O(1) while still allowing arbitrary number of ranks.
+
+// All functions of VoteTally now include the class as a param.
+
+pub type TallyOf<T, I = ()> = Tally<T, I, Pallet<T, I>>;
+pub type PollIndexOf<T, I = ()> = <<T as Config<I>>::Polls as Polling<TallyOf<T, I>>>::Index;
+pub type ClassOf<T, I = ()> = <<T as Config<I>>::Polls as Polling<TallyOf<T, I>>>::Class;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+impl<T: Config<I>, I: 'static, M: GetMaxVoters<Class = ClassOf<T, I>>>
+	VoteTally<Votes, ClassOf<T, I>> for Tally<T, I, M>
+{
+	fn new(_: ClassOf<T, I>) -> Self {
+		Self { bare_ayes: 0, ayes: 0, nays: 0, dummy: PhantomData }
+	}
+	fn ayes(&self, _: ClassOf<T, I>) -> Votes {
+		self.bare_ayes
+	}
+	fn support(&self, class: ClassOf<T, I>) -> Perbill {
+		Perbill::from_rational(self.bare_ayes, M::get_max_voters(class))
+	}
+	fn approval(&self, _: ClassOf<T, I>) -> Perbill {
+		Perbill::from_rational(self.ayes, 1.max(self.ayes + self.nays))
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn unanimity(class: ClassOf<T, I>) -> Self {
+		Self {
+			bare_ayes: M::get_max_voters(class.clone()),
+			ayes: M::get_max_voters(class),
+			nays: 0,
+			dummy: PhantomData,
+		}
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn rejection(class: ClassOf<T, I>) -> Self {
+		Self { bare_ayes: 0, ayes: 0, nays: M::get_max_voters(class), dummy: PhantomData }
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn from_requirements(support: Perbill, approval: Perbill, class: ClassOf<T, I>) -> Self {
+		let c = M::get_max_voters(class);
+		let ayes = support * c;
+		let nays = ((ayes as u64) * 1_000_000_000u64 / approval.deconstruct() as u64) as u32 - ayes;
+		Self { bare_ayes: ayes, ayes, nays, dummy: PhantomData }
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn setup(class: ClassOf<T, I>, granularity: Perbill) {
+		if M::get_max_voters(class.clone()) == 0 {
+			let max_voters = granularity.saturating_reciprocal_mul(1u32);
+			for i in 0..max_voters {
+				let who: T::AccountId =
+					frame_benchmarking::account("ranked_collective_benchmarking", i, 0);
+				crate::Pallet::<T, I>::do_add_member_to_rank(
+					who,
+					T::MinRankOfClass::convert(class.clone()),
+				)
+				.expect("could not add members for benchmarks");
+			}
+			assert_eq!(M::get_max_voters(class), max_voters);
+		}
+	}
+}
+
+/// Record needed for every member.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct MemberRecord {
+	/// The rank of the member.
+	rank: Rank,
+}
+
+impl MemberRecord {
+	// Constructs a new instance of [`MemberRecord`].
+	pub fn new(rank: Rank) -> Self {
+		Self { rank }
+	}
+}
+
+/// Record needed for every vote.
+#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum VoteRecord {
+	/// Vote was an aye with given vote weight.
+	Aye(Votes),
+	/// Vote was a nay with given vote weight.
+	Nay(Votes),
+}
+
+impl From<(bool, Votes)> for VoteRecord {
+	fn from((aye, votes): (bool, Votes)) -> Self {
+		match aye {
+			true => VoteRecord::Aye(votes),
+			false => VoteRecord::Nay(votes),
+		}
+	}
+}
+
+/// Vote-weight scheme where all voters get one vote regardless of rank.
+pub struct Unit;
+impl Convert<Rank, Votes> for Unit {
+	fn convert(_: Rank) -> Votes {
+		1
+	}
+}
+
+/// Vote-weight scheme where all voters get one vote plus an additional vote for every excess rank
+/// they have. I.e.:
+///
+/// - Each member with an excess rank of 0 gets 1 vote;
+/// - ...with an excess rank of 1 gets 2 votes;
+/// - ...with an excess rank of 2 gets 3 votes;
+/// - ...with an excess rank of 3 gets 4 votes;
+/// - ...with an excess rank of 4 gets 5 votes.
+pub struct Linear;
+impl Convert<Rank, Votes> for Linear {
+	fn convert(r: Rank) -> Votes {
+		(r + 1) as Votes
+	}
+}
+
+/// Vote-weight scheme where all voters get one vote plus additional votes for every excess rank
+/// they have incrementing by one vote for each excess rank. I.e.:
+///
+/// - Each member with an excess rank of 0 gets 1 vote;
+/// - ...with an excess rank of 1 gets 3 votes;
+/// - ...with an excess rank of 2 gets 6 votes;
+/// - ...with an excess rank of 3 gets 10 votes;
+/// - ...with an excess rank of 4 gets 15 votes.
+pub struct Geometric;
+impl Convert<Rank, Votes> for Geometric {
+	fn convert(r: Rank) -> Votes {
+		let v = (r + 1) as Votes;
+		v * (v + 1) / 2
+	}
+}
+
+/// Trait for getting the maximum number of voters for a given poll class.
+pub trait GetMaxVoters {
+	/// Poll class type.
+	type Class;
+	/// Return the maximum number of voters for the poll class `c`.
+	fn get_max_voters(c: Self::Class) -> MemberIndex;
+}
+impl<T: Config<I>, I: 'static> GetMaxVoters for Pallet<T, I> {
+	type Class = ClassOf<T, I>;
+	fn get_max_voters(c: Self::Class) -> MemberIndex {
+		MemberCount::<T, I>::get(T::MinRankOfClass::convert(c))
+	}
+}
+
+/// Guard to ensure that the given origin is a member of the collective. The rank of the member is
+/// the `Success` value.
+pub struct EnsureRanked<T, I, const MIN_RANK: u16>(PhantomData<(T, I)>);
+impl<T: Config<I>, I: 'static, const MIN_RANK: u16> EnsureOrigin<T::RuntimeOrigin>
+	for EnsureRanked<T, I, MIN_RANK>
+{
+	type Success = Rank;
+
+	fn try_origin(o: T::RuntimeOrigin) -> Result<Self::Success, T::RuntimeOrigin> {
+		let who = <frame_system::EnsureSigned<_> as EnsureOrigin<_>>::try_origin(o)?;
+		match Members::<T, I>::get(&who) {
+			Some(MemberRecord { rank, .. }) if rank >= MIN_RANK => Ok(rank),
+			_ => Err(frame_system::RawOrigin::Signed(who).into()),
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<T::RuntimeOrigin, ()> {
+		<EnsureRankedMember<T, I, MIN_RANK> as EnsureOrigin<_>>::try_successful_origin()
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl<{ T: Config<I>, I: 'static, const MIN_RANK: u16, A }>
+		EnsureOriginWithArg<T::RuntimeOrigin, A> for EnsureRanked<T, I, MIN_RANK>
+	{}
+}
+
+/// Guard to ensure that the given origin is a member of the collective. The rank of the member is
+/// the `Success` value.
+pub struct EnsureOfRank<T, I>(PhantomData<(T, I)>);
+impl<T: Config<I>, I: 'static> EnsureOriginWithArg<T::RuntimeOrigin, Rank> for EnsureOfRank<T, I> {
+	type Success = (T::AccountId, Rank);
+
+	fn try_origin(o: T::RuntimeOrigin, min_rank: &Rank) -> Result<Self::Success, T::RuntimeOrigin> {
+		let who = <frame_system::EnsureSigned<_> as EnsureOrigin<_>>::try_origin(o)?;
+		match Members::<T, I>::get(&who) {
+			Some(MemberRecord { rank, .. }) if rank >= *min_rank => Ok((who, rank)),
+			_ => Err(frame_system::RawOrigin::Signed(who).into()),
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(min_rank: &Rank) -> Result<T::RuntimeOrigin, ()> {
+		let who = frame_benchmarking::account::<T::AccountId>("successful_origin", 0, 0);
+		crate::Pallet::<T, I>::do_add_member_to_rank(who.clone(), *min_rank)
+			.expect("Could not add members for benchmarks");
+		Ok(frame_system::RawOrigin::Signed(who).into())
+	}
+}
+
+/// Guard to ensure that the given origin is a member of the collective. The account ID of the
+/// member is the `Success` value.
+pub struct EnsureMember<T, I, const MIN_RANK: u16>(PhantomData<(T, I)>);
+impl<T: Config<I>, I: 'static, const MIN_RANK: u16> EnsureOrigin<T::RuntimeOrigin>
+	for EnsureMember<T, I, MIN_RANK>
+{
+	type Success = T::AccountId;
+
+	fn try_origin(o: T::RuntimeOrigin) -> Result<Self::Success, T::RuntimeOrigin> {
+		let who = <frame_system::EnsureSigned<_> as EnsureOrigin<_>>::try_origin(o)?;
+		match Members::<T, I>::get(&who) {
+			Some(MemberRecord { rank, .. }) if rank >= MIN_RANK => Ok(who),
+			_ => Err(frame_system::RawOrigin::Signed(who).into()),
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<T::RuntimeOrigin, ()> {
+		<EnsureRankedMember<T, I, MIN_RANK> as EnsureOrigin<_>>::try_successful_origin()
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl<{ T: Config<I>, I: 'static, const MIN_RANK: u16, A }>
+		EnsureOriginWithArg<T::RuntimeOrigin, A> for EnsureMember<T, I, MIN_RANK>
+	{}
+}
+
+/// Guard to ensure that the given origin is a member of the collective. The pair of both the
+/// account ID and the rank of the member is the `Success` value.
+pub struct EnsureRankedMember<T, I, const MIN_RANK: u16>(PhantomData<(T, I)>);
+impl<T: Config<I>, I: 'static, const MIN_RANK: u16> EnsureOrigin<T::RuntimeOrigin>
+	for EnsureRankedMember<T, I, MIN_RANK>
+{
+	type Success = (T::AccountId, Rank);
+
+	fn try_origin(o: T::RuntimeOrigin) -> Result<Self::Success, T::RuntimeOrigin> {
+		let who = <frame_system::EnsureSigned<_> as EnsureOrigin<_>>::try_origin(o)?;
+		match Members::<T, I>::get(&who) {
+			Some(MemberRecord { rank, .. }) if rank >= MIN_RANK => Ok((who, rank)),
+			_ => Err(frame_system::RawOrigin::Signed(who).into()),
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<T::RuntimeOrigin, ()> {
+		let who = frame_benchmarking::account::<T::AccountId>("successful_origin", 0, 0);
+		crate::Pallet::<T, I>::do_add_member_to_rank(who.clone(), MIN_RANK)
+			.expect("Could not add members for benchmarks");
+		Ok(frame_system::RawOrigin::Signed(who).into())
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl<{ T: Config<I>, I: 'static, const MIN_RANK: u16, A }>
+		EnsureOriginWithArg<T::RuntimeOrigin, A> for EnsureRankedMember<T, I, MIN_RANK>
+	{}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{pallet_prelude::*, storage::KeyLenOf};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The runtime event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The origin required to add or promote a mmember. The success value indicates the
+		/// maximum rank *to which* the promotion may be.
+		type PromoteOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Rank>;
+
+		/// The origin required to demote or remove a member. The success value indicates the
+		/// maximum rank *from which* the demotion/removal may be.
+		type DemoteOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = Rank>;
+
+		/// The polling system used for our voting.
+		type Polls: Polling<TallyOf<Self, I>, Votes = Votes, Moment = BlockNumberFor<Self>>;
+
+		/// Convert the tally class into the minimum rank required to vote on the poll. If
+		/// `Polls::Class` is the same type as `Rank`, then `Identity` can be used here to mean
+		/// "a rank of at least the poll class".
+		type MinRankOfClass: Convert<ClassOf<Self, I>, Rank>;
+
+		/// Convert a rank_delta into a number of votes the rank gets.
+		///
+		/// Rank_delta is defined as the number of ranks above the minimum required to take part
+		/// in the poll.
+		type VoteWeight: Convert<Rank, Votes>;
+	}
+
+	/// The number of members in the collective who have at least the rank according to the index
+	/// of the vec.
+	#[pallet::storage]
+	pub type MemberCount<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, Rank, MemberIndex, ValueQuery>;
+
+	/// The current members of the collective.
+	#[pallet::storage]
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, MemberRecord>;
+
+	/// The index of each ranks's member into the group of members who have at least that rank.
+	#[pallet::storage]
+	pub type IdToIndex<T: Config<I>, I: 'static = ()> =
+		StorageDoubleMap<_, Twox64Concat, Rank, Twox64Concat, T::AccountId, MemberIndex>;
+
+	/// The members in the collective by index. All indices in the range `0..MemberCount` will
+	/// return `Some`, however a member's index is not guaranteed to remain unchanged over time.
+	#[pallet::storage]
+	pub type IndexToId<T: Config<I>, I: 'static = ()> =
+		StorageDoubleMap<_, Twox64Concat, Rank, Twox64Concat, MemberIndex, T::AccountId>;
+
+	/// Votes on a given proposal, if it is ongoing.
+	#[pallet::storage]
+	pub type Voting<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		PollIndexOf<T, I>,
+		Twox64Concat,
+		T::AccountId,
+		VoteRecord,
+	>;
+
+	#[pallet::storage]
+	pub type VotingCleanup<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, PollIndexOf<T, I>, BoundedVec<u8, KeyLenOf<Voting<T, I>>>>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A member `who` has been added.
+		MemberAdded { who: T::AccountId },
+		/// The member `who`se rank has been changed to the given `rank`.
+		RankChanged { who: T::AccountId, rank: Rank },
+		/// The member `who` of given `rank` has been removed from the collective.
+		MemberRemoved { who: T::AccountId, rank: Rank },
+		/// The member `who` has voted for the `poll` with the given `vote` leading to an updated
+		/// `tally`.
+		Voted { who: T::AccountId, poll: PollIndexOf<T, I>, vote: VoteRecord, tally: TallyOf<T, I> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Account is already a member.
+		AlreadyMember,
+		/// Account is not a member.
+		NotMember,
+		/// The given poll index is unknown or has closed.
+		NotPolling,
+		/// The given poll is still ongoing.
+		Ongoing,
+		/// There are no further records to be removed.
+		NoneRemaining,
+		/// Unexpected error in state.
+		Corruption,
+		/// The member's rank is too low to vote.
+		RankTooLow,
+		/// The information provided is incorrect.
+		InvalidWitness,
+		/// The origin is not sufficiently privileged to do the operation.
+		NoPermission,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Introduce a new member.
+		///
+		/// - `origin`: Must be the `AdminOrigin`.
+		/// - `who`: Account of non-member which will become a member.
+		/// - `rank`: The rank to give the new member.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::add_member())]
+		pub fn add_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			let _ = T::PromoteOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			Self::do_add_member(who)
+		}
+
+		/// Increment the rank of an existing member by one.
+		///
+		/// - `origin`: Must be the `AdminOrigin`.
+		/// - `who`: Account of existing member.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::promote_member(0))]
+		pub fn promote_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			let max_rank = T::PromoteOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			Self::do_promote_member(who, Some(max_rank))
+		}
+
+		/// Decrement the rank of an existing member by one. If the member is already at rank zero,
+		/// then they are removed entirely.
+		///
+		/// - `origin`: Must be the `AdminOrigin`.
+		/// - `who`: Account of existing member of rank greater than zero.
+		///
+		/// Weight: `O(1)`, less if the member's index is highest in its rank.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::demote_member(0))]
+		pub fn demote_member(origin: OriginFor<T>, who: AccountIdLookupOf<T>) -> DispatchResult {
+			let max_rank = T::DemoteOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			Self::do_demote_member(who, Some(max_rank))
+		}
+
+		/// Remove the member entirely.
+		///
+		/// - `origin`: Must be the `AdminOrigin`.
+		/// - `who`: Account of existing member of rank greater than zero.
+		/// - `min_rank`: The rank of the member or greater.
+		///
+		/// Weight: `O(min_rank)`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::remove_member(*min_rank as u32))]
+		pub fn remove_member(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			min_rank: Rank,
+		) -> DispatchResultWithPostInfo {
+			let max_rank = T::DemoteOrigin::ensure_origin(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			let MemberRecord { rank, .. } = Self::ensure_member(&who)?;
+			ensure!(min_rank >= rank, Error::<T, I>::InvalidWitness);
+			ensure!(max_rank >= rank, Error::<T, I>::NoPermission);
+
+			for r in 0..=rank {
+				Self::remove_from_rank(&who, r)?;
+			}
+			Members::<T, I>::remove(&who);
+			Self::deposit_event(Event::MemberRemoved { who, rank });
+			Ok(PostDispatchInfo {
+				actual_weight: Some(T::WeightInfo::remove_member(rank as u32)),
+				pays_fee: Pays::Yes,
+			})
+		}
+
+		/// Add an aye or nay vote for the sender to the given proposal.
+		///
+		/// - `origin`: Must be `Signed` by a member account.
+		/// - `poll`: Index of a poll which is ongoing.
+		/// - `aye`: `true` if the vote is to approve the proposal, `false` otherwise.
+		///
+		/// Transaction fees are be waived if the member is voting on any particular proposal
+		/// for the first time and the call is successful. Subsequent vote changes will charge a
+		/// fee.
+		///
+		/// Weight: `O(1)`, less if there was no previous vote on the poll by the member.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::vote())]
+		pub fn vote(
+			origin: OriginFor<T>,
+			poll: PollIndexOf<T, I>,
+			aye: bool,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let record = Self::ensure_member(&who)?;
+			use VoteRecord::*;
+			let mut pays = Pays::Yes;
+
+			let (tally, vote) = T::Polls::try_access_poll(
+				poll,
+				|mut status| -> Result<(TallyOf<T, I>, VoteRecord), DispatchError> {
+					match status {
+						PollStatus::None | PollStatus::Completed(..) =>
+							Err(Error::<T, I>::NotPolling)?,
+						PollStatus::Ongoing(ref mut tally, class) => {
+							match Voting::<T, I>::get(&poll, &who) {
+								Some(Aye(votes)) => {
+									tally.bare_ayes.saturating_dec();
+									tally.ayes.saturating_reduce(votes);
+								},
+								Some(Nay(votes)) => tally.nays.saturating_reduce(votes),
+								None => pays = Pays::No,
+							}
+							let min_rank = T::MinRankOfClass::convert(class);
+							let votes = Self::rank_to_votes(record.rank, min_rank)?;
+							let vote = VoteRecord::from((aye, votes));
+							match aye {
+								true => {
+									tally.bare_ayes.saturating_inc();
+									tally.ayes.saturating_accrue(votes);
+								},
+								false => tally.nays.saturating_accrue(votes),
+							}
+							Voting::<T, I>::insert(&poll, &who, &vote);
+							Ok((tally.clone(), vote))
+						},
+					}
+				},
+			)?;
+			Self::deposit_event(Event::Voted { who, poll, vote, tally });
+			Ok(pays.into())
+		}
+
+		/// Remove votes from the given poll. It must have ended.
+		///
+		/// - `origin`: Must be `Signed` by any account.
+		/// - `poll_index`: Index of a poll which is completed and for which votes continue to
+		///   exist.
+		/// - `max`: Maximum number of vote items from remove in this call.
+		///
+		/// Transaction fees are waived if the operation is successful.
+		///
+		/// Weight `O(max)` (less if there are fewer items to remove than `max`).
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::cleanup_poll(*max))]
+		pub fn cleanup_poll(
+			origin: OriginFor<T>,
+			poll_index: PollIndexOf<T, I>,
+			max: u32,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			ensure!(T::Polls::as_ongoing(poll_index).is_none(), Error::<T, I>::Ongoing);
+
+			let r = Voting::<T, I>::clear_prefix(
+				poll_index,
+				max,
+				VotingCleanup::<T, I>::take(poll_index).as_ref().map(|c| &c[..]),
+			);
+			if r.unique == 0 {
+				// return Err(Error::<T, I>::NoneRemaining)
+				return Ok(Pays::Yes.into())
+			}
+			if let Some(cursor) = r.maybe_cursor {
+				VotingCleanup::<T, I>::insert(poll_index, BoundedVec::truncate_from(cursor));
+			}
+			Ok(PostDispatchInfo {
+				actual_weight: Some(T::WeightInfo::cleanup_poll(r.unique)),
+				pays_fee: Pays::No,
+			})
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		fn ensure_member(who: &T::AccountId) -> Result<MemberRecord, DispatchError> {
+			Members::<T, I>::get(who).ok_or(Error::<T, I>::NotMember.into())
+		}
+
+		fn rank_to_votes(rank: Rank, min: Rank) -> Result<Votes, DispatchError> {
+			let excess = rank.checked_sub(min).ok_or(Error::<T, I>::RankTooLow)?;
+			Ok(T::VoteWeight::convert(excess))
+		}
+
+		fn remove_from_rank(who: &T::AccountId, rank: Rank) -> DispatchResult {
+			let last_index = MemberCount::<T, I>::get(rank).saturating_sub(1);
+			let index = IdToIndex::<T, I>::get(rank, &who).ok_or(Error::<T, I>::Corruption)?;
+			if index != last_index {
+				let last =
+					IndexToId::<T, I>::get(rank, last_index).ok_or(Error::<T, I>::Corruption)?;
+				IdToIndex::<T, I>::insert(rank, &last, index);
+				IndexToId::<T, I>::insert(rank, index, &last);
+			}
+			MemberCount::<T, I>::mutate(rank, |r| r.saturating_dec());
+			Ok(())
+		}
+
+		/// Adds a member into the ranked collective at level 0.
+		///
+		/// No origin checks are executed.
+		pub fn do_add_member(who: T::AccountId) -> DispatchResult {
+			ensure!(!Members::<T, I>::contains_key(&who), Error::<T, I>::AlreadyMember);
+			let index = MemberCount::<T, I>::get(0);
+			let count = index.checked_add(1).ok_or(Overflow)?;
+
+			Members::<T, I>::insert(&who, MemberRecord { rank: 0 });
+			IdToIndex::<T, I>::insert(0, &who, index);
+			IndexToId::<T, I>::insert(0, index, &who);
+			MemberCount::<T, I>::insert(0, count);
+			Self::deposit_event(Event::MemberAdded { who });
+			Ok(())
+		}
+
+		/// Promotes a member in the ranked collective into the next higher rank.
+		///
+		/// A `maybe_max_rank` may be provided to check that the member does not get promoted beyond
+		/// a certain rank. Is `None` is provided, then the rank will be incremented without checks.
+		pub fn do_promote_member(
+			who: T::AccountId,
+			maybe_max_rank: Option<Rank>,
+		) -> DispatchResult {
+			let record = Self::ensure_member(&who)?;
+			let rank = record.rank.checked_add(1).ok_or(Overflow)?;
+			if let Some(max_rank) = maybe_max_rank {
+				ensure!(max_rank >= rank, Error::<T, I>::NoPermission);
+			}
+			let index = MemberCount::<T, I>::get(rank);
+			MemberCount::<T, I>::insert(rank, index.checked_add(1).ok_or(Overflow)?);
+			IdToIndex::<T, I>::insert(rank, &who, index);
+			IndexToId::<T, I>::insert(rank, index, &who);
+			Members::<T, I>::insert(&who, MemberRecord { rank });
+			Self::deposit_event(Event::RankChanged { who, rank });
+			Ok(())
+		}
+
+		/// Demotes a member in the ranked collective into the next lower rank.
+		///
+		/// A `maybe_max_rank` may be provided to check that the member does not get demoted from
+		/// a certain rank. Is `None` is provided, then the rank will be decremented without checks.
+		fn do_demote_member(who: T::AccountId, maybe_max_rank: Option<Rank>) -> DispatchResult {
+			let mut record = Self::ensure_member(&who)?;
+			let rank = record.rank;
+			if let Some(max_rank) = maybe_max_rank {
+				ensure!(max_rank >= rank, Error::<T, I>::NoPermission);
+			}
+
+			Self::remove_from_rank(&who, rank)?;
+			let maybe_rank = rank.checked_sub(1);
+			match maybe_rank {
+				None => {
+					Members::<T, I>::remove(&who);
+					Self::deposit_event(Event::MemberRemoved { who, rank: 0 });
+				},
+				Some(rank) => {
+					record.rank = rank;
+					Members::<T, I>::insert(&who, &record);
+					Self::deposit_event(Event::RankChanged { who, rank });
+				},
+			}
+			Ok(())
+		}
+
+		/// Add a member to the rank collective, and continue to promote them until a certain rank
+		/// is reached.
+		pub fn do_add_member_to_rank(who: T::AccountId, rank: Rank) -> DispatchResult {
+			Self::do_add_member(who.clone())?;
+			for _ in 0..rank {
+				Self::do_promote_member(who.clone(), None)?;
+			}
+			Ok(())
+		}
+
+		/// Determine the rank of the account behind the `Signed` origin `o`, `None` if the account
+		/// is unknown to this collective or `o` is not `Signed`.
+		pub fn as_rank(
+			o: &<T::RuntimeOrigin as frame_support::traits::OriginTrait>::PalletsOrigin,
+		) -> Option<u16> {
+			use frame_support::traits::CallerTrait;
+			o.as_signed().and_then(Self::rank_of)
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> RankedMembers for Pallet<T, I> {
+		type AccountId = T::AccountId;
+		type Rank = Rank;
+
+		fn min_rank() -> Self::Rank {
+			0
+		}
+
+		fn rank_of(who: &Self::AccountId) -> Option<Self::Rank> {
+			Some(Self::ensure_member(&who).ok()?.rank)
+		}
+
+		fn induct(who: &Self::AccountId) -> DispatchResult {
+			Self::do_add_member(who.clone())
+		}
+
+		fn promote(who: &Self::AccountId) -> DispatchResult {
+			Self::do_promote_member(who.clone(), None)
+		}
+
+		fn demote(who: &Self::AccountId) -> DispatchResult {
+			Self::do_demote_member(who.clone(), None)
+		}
+	}
+}
diff --git a/substrate/frame/ranked-collective/src/tests.rs b/substrate/frame/ranked-collective/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ba8c5a0f937badf8e51fff9a9fa897176c7e6207
--- /dev/null
+++ b/substrate/frame/ranked-collective/src/tests.rs
@@ -0,0 +1,568 @@
+// 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.
+
+//! The crate's tests.
+
+use std::collections::BTreeMap;
+
+use frame_support::{
+	assert_noop, assert_ok,
+	error::BadOrigin,
+	parameter_types,
+	traits::{ConstU16, ConstU32, ConstU64, EitherOf, Everything, MapSuccess, Polling},
+};
+use sp_core::{Get, H256};
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup, ReduceBy},
+	BuildStorage,
+};
+
+use super::*;
+use crate as pallet_ranked_collective;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+type Class = Rank;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Club: pallet_ranked_collective::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = 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>;
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum TestPollState {
+	Ongoing(TallyOf<Test>, Rank),
+	Completed(u64, bool),
+}
+use TestPollState::*;
+
+parameter_types! {
+	pub static Polls: BTreeMap<u8, TestPollState> = vec![
+		(1, Completed(1, true)),
+		(2, Completed(2, false)),
+		(3, Ongoing(Tally::from_parts(0, 0, 0), 1)),
+	].into_iter().collect();
+}
+
+pub struct TestPolls;
+impl Polling<TallyOf<Test>> for TestPolls {
+	type Index = u8;
+	type Votes = Votes;
+	type Moment = u64;
+	type Class = Class;
+	fn classes() -> Vec<Self::Class> {
+		vec![0, 1, 2]
+	}
+	fn as_ongoing(index: u8) -> Option<(TallyOf<Test>, Self::Class)> {
+		Polls::get().remove(&index).and_then(|x| {
+			if let TestPollState::Ongoing(t, c) = x {
+				Some((t, c))
+			} else {
+				None
+			}
+		})
+	}
+	fn access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(PollStatus<&mut TallyOf<Test>, Self::Moment, Self::Class>) -> R,
+	) -> R {
+		let mut polls = Polls::get();
+		let entry = polls.get_mut(&index);
+		let r = match entry {
+			Some(Ongoing(ref mut tally_mut_ref, class)) =>
+				f(PollStatus::Ongoing(tally_mut_ref, *class)),
+			Some(Completed(when, succeeded)) => f(PollStatus::Completed(*when, *succeeded)),
+			None => f(PollStatus::None),
+		};
+		Polls::set(polls);
+		r
+	}
+	fn try_access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(
+			PollStatus<&mut TallyOf<Test>, Self::Moment, Self::Class>,
+		) -> Result<R, DispatchError>,
+	) -> Result<R, DispatchError> {
+		let mut polls = Polls::get();
+		let entry = polls.get_mut(&index);
+		let r = match entry {
+			Some(Ongoing(ref mut tally_mut_ref, class)) =>
+				f(PollStatus::Ongoing(tally_mut_ref, *class)),
+			Some(Completed(when, succeeded)) => f(PollStatus::Completed(*when, *succeeded)),
+			None => f(PollStatus::None),
+		}?;
+		Polls::set(polls);
+		Ok(r)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn create_ongoing(class: Self::Class) -> Result<Self::Index, ()> {
+		let mut polls = Polls::get();
+		let i = polls.keys().rev().next().map_or(0, |x| x + 1);
+		polls.insert(i, Ongoing(Tally::new(class), class));
+		Polls::set(polls);
+		Ok(i)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn end_ongoing(index: Self::Index, approved: bool) -> Result<(), ()> {
+		let mut polls = Polls::get();
+		match polls.get(&index) {
+			Some(Ongoing(..)) => {},
+			_ => return Err(()),
+		}
+		let now = frame_system::Pallet::<Test>::block_number();
+		polls.insert(index, Completed(now, approved));
+		Polls::set(polls);
+		Ok(())
+	}
+}
+
+/// Convert the tally class into the minimum rank required to vote on the poll.
+/// MinRank(Class) = Class - Delta
+pub struct MinRankOfClass<Delta>(PhantomData<Delta>);
+impl<Delta: Get<Rank>> Convert<Class, Rank> for MinRankOfClass<Delta> {
+	fn convert(a: Class) -> Rank {
+		a.saturating_sub(Delta::get())
+	}
+}
+
+parameter_types! {
+	pub static MinRankOfClassDelta: Rank = 0;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type PromoteOrigin = EitherOf<
+		// Root can promote arbitrarily.
+		frame_system::EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>,
+		// Members can promote up to the rank of 2 below them.
+		MapSuccess<EnsureRanked<Test, (), 2>, ReduceBy<ConstU16<2>>>,
+	>;
+	type DemoteOrigin = EitherOf<
+		// Root can demote arbitrarily.
+		frame_system::EnsureRootWithSuccess<Self::AccountId, ConstU16<65535>>,
+		// Members can demote up to the rank of 3 below them.
+		MapSuccess<EnsureRanked<Test, (), 3>, ReduceBy<ConstU16<3>>>,
+	>;
+	type Polls = TestPolls;
+	type MinRankOfClass = MinRankOfClass<MinRankOfClassDelta>;
+	type VoteWeight = Geometric;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+}
+
+fn member_count(r: Rank) -> MemberIndex {
+	MemberCount::<Test>::get(r)
+}
+
+#[allow(dead_code)]
+fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+fn tally(index: u8) -> TallyOf<Test> {
+	<TestPolls as Polling<TallyOf<Test>>>::as_ongoing(index).expect("No poll").0
+}
+
+#[test]
+#[ignore]
+#[should_panic(expected = "No poll")]
+fn unknown_poll_should_panic() {
+	let _ = tally(0);
+}
+
+#[test]
+#[ignore]
+#[should_panic(expected = "No poll")]
+fn completed_poll_should_panic() {
+	let _ = tally(1);
+}
+
+#[test]
+fn basic_stuff() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
+	});
+}
+
+#[test]
+fn member_lifecycle_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 0);
+		assert_eq!(member_count(1), 0);
+	});
+}
+
+#[test]
+fn add_remove_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Club::add_member(RuntimeOrigin::signed(1), 1), DispatchError::BadOrigin);
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 1);
+
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 0);
+
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 1);
+
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
+		assert_eq!(member_count(0), 2);
+
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
+		assert_eq!(member_count(0), 3);
+
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 3));
+		assert_eq!(member_count(0), 2);
+
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 1);
+
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 2));
+		assert_eq!(member_count(0), 0);
+	});
+}
+
+#[test]
+fn promote_demote_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Club::add_member(RuntimeOrigin::signed(1), 1), DispatchError::BadOrigin);
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 1);
+		assert_eq!(member_count(1), 0);
+
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
+		assert_eq!(member_count(0), 2);
+		assert_eq!(member_count(1), 0);
+
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 2);
+		assert_eq!(member_count(1), 1);
+
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_eq!(member_count(0), 2);
+		assert_eq!(member_count(1), 2);
+
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 2);
+		assert_eq!(member_count(1), 1);
+
+		assert_noop!(Club::demote_member(RuntimeOrigin::signed(1), 1), DispatchError::BadOrigin);
+		assert_ok!(Club::demote_member(RuntimeOrigin::root(), 1));
+		assert_eq!(member_count(0), 1);
+		assert_eq!(member_count(1), 1);
+	});
+}
+
+#[test]
+fn promote_demote_by_rank_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		for _ in 0..7 {
+			assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+		}
+
+		// #1 can add #2 and promote to rank 1
+		assert_ok!(Club::add_member(RuntimeOrigin::signed(1), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
+		// #2 as rank 1 cannot do anything privileged
+		assert_noop!(Club::add_member(RuntimeOrigin::signed(2), 3), BadOrigin);
+
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
+		// #2 as rank 2 can add #3.
+		assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 3));
+
+		// #2 as rank 2 cannot promote #3 to rank 1
+		assert_noop!(
+			Club::promote_member(RuntimeOrigin::signed(2), 3),
+			Error::<Test>::NoPermission
+		);
+
+		// #1 as rank 7 can promote #2 only up to rank 5 and once there cannot demote them.
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(1), 2));
+		assert_noop!(
+			Club::promote_member(RuntimeOrigin::signed(1), 2),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(Club::demote_member(RuntimeOrigin::signed(1), 2), Error::<Test>::NoPermission);
+
+		// #2 as rank 5 can promote #3 only up to rank 3 and once there cannot demote them.
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 3));
+		assert_noop!(
+			Club::promote_member(RuntimeOrigin::signed(2), 3),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(Club::demote_member(RuntimeOrigin::signed(2), 3), Error::<Test>::NoPermission);
+
+		// #2 can add #4 & #5 as rank 0 and #6 & #7 as rank 1.
+		assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 4));
+		assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 5));
+		assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 6));
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 6));
+		assert_ok!(Club::add_member(RuntimeOrigin::signed(2), 7));
+		assert_ok!(Club::promote_member(RuntimeOrigin::signed(2), 7));
+
+		// #3 as rank 3 can demote/remove #4 & #5 but not #6 & #7
+		assert_ok!(Club::demote_member(RuntimeOrigin::signed(3), 4));
+		assert_ok!(Club::remove_member(RuntimeOrigin::signed(3), 5, 0));
+		assert_noop!(Club::demote_member(RuntimeOrigin::signed(3), 6), Error::<Test>::NoPermission);
+		assert_noop!(
+			Club::remove_member(RuntimeOrigin::signed(3), 7, 1),
+			Error::<Test>::NoPermission
+		);
+
+		// #2 as rank 5 can demote/remove #6 & #7
+		assert_ok!(Club::demote_member(RuntimeOrigin::signed(2), 6));
+		assert_ok!(Club::remove_member(RuntimeOrigin::signed(2), 7, 1));
+	});
+}
+
+#[test]
+fn voting_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 0));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+
+		assert_noop!(Club::vote(RuntimeOrigin::signed(0), 3, true), Error::<Test>::RankTooLow);
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 0));
+
+		assert_ok!(Club::vote(RuntimeOrigin::signed(1), 3, true));
+		assert_eq!(tally(3), Tally::from_parts(1, 1, 0));
+		assert_ok!(Club::vote(RuntimeOrigin::signed(1), 3, false));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 1));
+
+		assert_ok!(Club::vote(RuntimeOrigin::signed(2), 3, true));
+		assert_eq!(tally(3), Tally::from_parts(1, 3, 1));
+		assert_ok!(Club::vote(RuntimeOrigin::signed(2), 3, false));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 4));
+
+		assert_ok!(Club::vote(RuntimeOrigin::signed(3), 3, true));
+		assert_eq!(tally(3), Tally::from_parts(1, 6, 4));
+		assert_ok!(Club::vote(RuntimeOrigin::signed(3), 3, false));
+		assert_eq!(tally(3), Tally::from_parts(0, 0, 10));
+	});
+}
+
+#[test]
+fn cleanup_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+
+		assert_ok!(Club::vote(RuntimeOrigin::signed(1), 3, true));
+		assert_ok!(Club::vote(RuntimeOrigin::signed(2), 3, false));
+		assert_ok!(Club::vote(RuntimeOrigin::signed(3), 3, true));
+
+		assert_noop!(Club::cleanup_poll(RuntimeOrigin::signed(4), 3, 10), Error::<Test>::Ongoing);
+		Polls::set(
+			vec![(1, Completed(1, true)), (2, Completed(2, false)), (3, Completed(3, true))]
+				.into_iter()
+				.collect(),
+		);
+		assert_ok!(Club::cleanup_poll(RuntimeOrigin::signed(4), 3, 10));
+		// NOTE: This will fail until #10016 is merged.
+		//		assert_noop!(Club::cleanup_poll(RuntimeOrigin::signed(4), 3, 10),
+		// Error::<Test>::NoneRemaining);
+	});
+}
+
+#[test]
+fn ensure_ranked_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+
+		use frame_support::traits::OriginTrait;
+		type Rank1 = EnsureRanked<Test, (), 1>;
+		type Rank2 = EnsureRanked<Test, (), 2>;
+		type Rank3 = EnsureRanked<Test, (), 3>;
+		type Rank4 = EnsureRanked<Test, (), 4>;
+		assert_eq!(<Rank1 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1)).unwrap(), 1);
+		assert_eq!(<Rank1 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2)).unwrap(), 2);
+		assert_eq!(<Rank1 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3)).unwrap(), 3);
+		assert_eq!(
+			<Rank2 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1))
+				.unwrap_err()
+				.into_signer()
+				.unwrap(),
+			1
+		);
+		assert_eq!(<Rank2 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2)).unwrap(), 2);
+		assert_eq!(<Rank2 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3)).unwrap(), 3);
+		assert_eq!(
+			<Rank3 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1))
+				.unwrap_err()
+				.into_signer()
+				.unwrap(),
+			1
+		);
+		assert_eq!(
+			<Rank3 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2))
+				.unwrap_err()
+				.into_signer()
+				.unwrap(),
+			2
+		);
+		assert_eq!(<Rank3 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3)).unwrap(), 3);
+		assert_eq!(
+			<Rank4 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(1))
+				.unwrap_err()
+				.into_signer()
+				.unwrap(),
+			1
+		);
+		assert_eq!(
+			<Rank4 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(2))
+				.unwrap_err()
+				.into_signer()
+				.unwrap(),
+			2
+		);
+		assert_eq!(
+			<Rank4 as EnsureOrigin<_>>::try_origin(RuntimeOrigin::signed(3))
+				.unwrap_err()
+				.into_signer()
+				.unwrap(),
+			3
+		);
+	});
+}
+
+#[test]
+fn do_add_member_to_rank_works() {
+	new_test_ext().execute_with(|| {
+		let max_rank = 9u16;
+		assert_ok!(Club::do_add_member_to_rank(69, max_rank / 2));
+		assert_ok!(Club::do_add_member_to_rank(1337, max_rank));
+		for i in 0..=max_rank {
+			if i <= max_rank / 2 {
+				assert_eq!(member_count(i), 2);
+			} else {
+				assert_eq!(member_count(i), 1);
+			}
+		}
+		assert_eq!(member_count(max_rank + 1), 0);
+	})
+}
+
+#[test]
+fn tally_support_correct() {
+	new_test_ext().execute_with(|| {
+		// add members,
+		// rank 1: accounts 1, 2, 3
+		// rank 2: accounts 2, 3
+		// rank 3: accounts 3.
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 1));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 2));
+		assert_ok!(Club::add_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+		assert_ok!(Club::promote_member(RuntimeOrigin::root(), 3));
+
+		// init tally with 1 aye vote.
+		let tally: TallyOf<Test> = Tally::from_parts(1, 1, 0);
+
+		// with minRank(Class) = Class
+		// for class 3, 100% support.
+		MinRankOfClassDelta::set(0);
+		assert_eq!(tally.support(3), Perbill::from_rational(1u32, 1));
+
+		// with minRank(Class) = (Class - 1)
+		// for class 3, ~50% support.
+		MinRankOfClassDelta::set(1);
+		assert_eq!(tally.support(3), Perbill::from_rational(1u32, 2));
+
+		// with minRank(Class) = (Class - 2)
+		// for class 3, ~33% support.
+		MinRankOfClassDelta::set(2);
+		assert_eq!(tally.support(3), Perbill::from_rational(1u32, 3));
+
+		// reset back.
+		MinRankOfClassDelta::set(0);
+	});
+}
diff --git a/substrate/frame/ranked-collective/src/weights.rs b/substrate/frame/ranked-collective/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9f1a0a8180446cd81e13f1420e5db73e070a2739
--- /dev/null
+++ b/substrate/frame/ranked-collective/src/weights.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.
+
+//! Autogenerated weights for pallet_ranked_collective
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_ranked_collective
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/ranked-collective/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_ranked_collective.
+pub trait WeightInfo {
+	fn add_member() -> Weight;
+	fn remove_member(r: u32, ) -> Weight;
+	fn promote_member(r: u32, ) -> Weight;
+	fn demote_member(r: u32, ) -> Weight;
+	fn vote() -> Weight;
+	fn cleanup_poll(n: u32, ) -> Weight;
+}
+
+/// Weights for pallet_ranked_collective using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	fn add_member() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3507`
+		// Minimum execution time: 17_245_000 picoseconds.
+		Weight::from_parts(17_930_000, 3507)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:11 w:11)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:11 w:11)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:11 w:11)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 10]`.
+	fn remove_member(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `616 + r * (281 ±0)`
+		//  Estimated: `3519 + r * (2529 ±0)`
+		// Minimum execution time: 29_534_000 picoseconds.
+		Weight::from_parts(32_847_495, 3519)
+			// Standard Error: 24_211
+			.saturating_add(Weight::from_parts(13_949_639, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2529).saturating_mul(r.into()))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 10]`.
+	fn promote_member(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `314 + r * (17 ±0)`
+		//  Estimated: `3507`
+		// Minimum execution time: 20_333_000 picoseconds.
+		Weight::from_parts(21_592_224, 3507)
+			// Standard Error: 6_423
+			.saturating_add(Weight::from_parts(321_314, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:1 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:1 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 10]`.
+	fn demote_member(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `632 + r * (72 ±0)`
+		//  Estimated: `3519`
+		// Minimum execution time: 29_446_000 picoseconds.
+		Weight::from_parts(32_447_715, 3519)
+			// Standard Error: 28_791
+			.saturating_add(Weight::from_parts(822_890, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedPolls ReferendumInfoFor (r:1 w:1)
+	/// Proof: RankedPolls ReferendumInfoFor (max_values: None, max_size: Some(330), added: 2805, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Voting (r:1 w:1)
+	/// Proof: RankedCollective Voting (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn vote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `628`
+		//  Estimated: `219984`
+		// Minimum execution time: 45_474_000 picoseconds.
+		Weight::from_parts(47_228_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedPolls ReferendumInfoFor (r:1 w:0)
+	/// Proof: RankedPolls ReferendumInfoFor (max_values: None, max_size: Some(330), added: 2805, mode: MaxEncodedLen)
+	/// Storage: RankedCollective VotingCleanup (r:1 w:0)
+	/// Proof: RankedCollective VotingCleanup (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Voting (r:100 w:100)
+	/// Proof: RankedCollective Voting (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	fn cleanup_poll(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462 + n * (50 ±0)`
+		//  Estimated: `3795 + n * (2540 ±0)`
+		// Minimum execution time: 13_903_000 picoseconds.
+		Weight::from_parts(18_209_102, 3795)
+			// Standard Error: 2_556
+			.saturating_add(Weight::from_parts(1_237_454, 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((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2540).saturating_mul(n.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	fn add_member() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3507`
+		// Minimum execution time: 17_245_000 picoseconds.
+		Weight::from_parts(17_930_000, 3507)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:11 w:11)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:11 w:11)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:11 w:11)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 10]`.
+	fn remove_member(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `616 + r * (281 ±0)`
+		//  Estimated: `3519 + r * (2529 ±0)`
+		// Minimum execution time: 29_534_000 picoseconds.
+		Weight::from_parts(32_847_495, 3519)
+			// Standard Error: 24_211
+			.saturating_add(Weight::from_parts(13_949_639, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(r.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(r.into())))
+			.saturating_add(Weight::from_parts(0, 2529).saturating_mul(r.into()))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:0 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:0 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 10]`.
+	fn promote_member(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `314 + r * (17 ±0)`
+		//  Estimated: `3507`
+		// Minimum execution time: 20_333_000 picoseconds.
+		Weight::from_parts(21_592_224, 3507)
+			// Standard Error: 6_423
+			.saturating_add(Weight::from_parts(321_314, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:1)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedCollective MemberCount (r:1 w:1)
+	/// Proof: RankedCollective MemberCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IdToIndex (r:1 w:1)
+	/// Proof: RankedCollective IdToIndex (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// Storage: RankedCollective IndexToId (r:1 w:1)
+	/// Proof: RankedCollective IndexToId (max_values: None, max_size: Some(54), added: 2529, mode: MaxEncodedLen)
+	/// The range of component `r` is `[0, 10]`.
+	fn demote_member(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `632 + r * (72 ±0)`
+		//  Estimated: `3519`
+		// Minimum execution time: 29_446_000 picoseconds.
+		Weight::from_parts(32_447_715, 3519)
+			// Standard Error: 28_791
+			.saturating_add(Weight::from_parts(822_890, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: RankedPolls ReferendumInfoFor (r:1 w:1)
+	/// Proof: RankedPolls ReferendumInfoFor (max_values: None, max_size: Some(330), added: 2805, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Voting (r:1 w:1)
+	/// Proof: RankedCollective Voting (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn vote() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `628`
+		//  Estimated: `219984`
+		// Minimum execution time: 45_474_000 picoseconds.
+		Weight::from_parts(47_228_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: RankedPolls ReferendumInfoFor (r:1 w:0)
+	/// Proof: RankedPolls ReferendumInfoFor (max_values: None, max_size: Some(330), added: 2805, mode: MaxEncodedLen)
+	/// Storage: RankedCollective VotingCleanup (r:1 w:0)
+	/// Proof: RankedCollective VotingCleanup (max_values: None, max_size: Some(114), added: 2589, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Voting (r:100 w:100)
+	/// Proof: RankedCollective Voting (max_values: None, max_size: Some(65), added: 2540, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 100]`.
+	fn cleanup_poll(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462 + n * (50 ±0)`
+		//  Estimated: `3795 + n * (2540 ±0)`
+		// Minimum execution time: 13_903_000 picoseconds.
+		Weight::from_parts(18_209_102, 3795)
+			// Standard Error: 2_556
+			.saturating_add(Weight::from_parts(1_237_454, 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((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2540).saturating_mul(n.into()))
+	}
+}
diff --git a/substrate/frame/recovery/Cargo.toml b/substrate/frame/recovery/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9e86728bc897606adb0fc9bb54d2b19dc6c9a0db
--- /dev/null
+++ b/substrate/frame/recovery/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "pallet-recovery"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME account recovery pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+runtime-benchmarks = [
+	'frame-benchmarking',
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/recovery/README.md b/substrate/frame/recovery/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..31416c65c46a53e9aca2223321c1ee8a27c4eda8
--- /dev/null
+++ b/substrate/frame/recovery/README.md
@@ -0,0 +1,134 @@
+# Recovery Pallet
+
+- [`recovery::Config`](https://docs.rs/pallet-recovery/latest/pallet_recovery/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-recovery/latest/pallet_recovery/enum.Call.html)
+
+## Overview
+
+The Recovery pallet is an M-of-N social recovery tool for users to gain
+access to their accounts if the private key or other authentication mechanism
+is lost. Through this pallet, a user is able to make calls on-behalf-of another
+account which they have recovered. The recovery process is protected by trusted
+"friends" whom the original account owner chooses. A threshold (M) out of N
+friends are needed to give another account access to the recoverable account.
+
+### Recovery Configuration
+
+The recovery process for each recoverable account can be configured by the account owner.
+They are able to choose:
+* `friends` - The list of friends that the account owner trusts to protect the
+  recovery process for their account.
+* `threshold` - The number of friends that need to approve a recovery process for
+  the account to be successfully recovered.
+* `delay_period` - The minimum number of blocks after the beginning of the recovery
+  process that need to pass before the account can be successfully recovered.
+
+There is a configurable deposit that all users need to pay to create a recovery
+configuration. This deposit is composed of a base deposit plus a multiplier for
+the number of friends chosen. This deposit is returned in full when the account
+owner removes their recovery configuration.
+
+### Recovery Life Cycle
+
+The intended life cycle of a successful recovery takes the following steps:
+1. The account owner calls `create_recovery` to set up a recovery configuration
+   for their account.
+2. At some later time, the account owner loses access to their account and wants
+   to recover it. Likely, they will need to create a new account and fund it with
+   enough balance to support the transaction fees and the deposit for the
+   recovery process.
+3. Using this new account, they call `initiate_recovery`.
+4. Then the account owner would contact their configured friends to vouch for
+   the recovery attempt. The account owner would provide their old account id
+   and the new account id, and friends would call `vouch_recovery` with those
+   parameters.
+5. Once a threshold number of friends have vouched for the recovery attempt,
+   the account owner needs to wait until the delay period has passed, starting
+   when they initiated the recovery process.
+6. Now the account owner is able to call `claim_recovery`, which subsequently
+   allows them to call `as_recovered` and directly make calls on-behalf-of the lost
+   account.
+7. Using the now recovered account, the account owner can call `close_recovery`
+   on the recovery process they opened, reclaiming the recovery deposit they
+   placed.
+8. Then the account owner should then call `remove_recovery` to remove the recovery
+   configuration on the recovered account and reclaim the recovery configuration
+   deposit they placed.
+9. Using `as_recovered`, the account owner is able to call any other pallets
+   to clean up their state and reclaim any reserved or locked funds. They
+   can then transfer all funds from the recovered account to the new account.
+10. When the recovered account becomes reaped (i.e. its free and reserved
+    balance drops to zero), the final recovery link is removed.
+
+### Malicious Recovery Attempts
+
+Initializing a the recovery process for a recoverable account is open and
+permissionless. However, the recovery deposit is an economic deterrent that
+should disincentivize would-be attackers from trying to maliciously recover
+accounts.
+
+The recovery deposit can always be claimed by the account which is trying to
+to be recovered. In the case of a malicious recovery attempt, the account
+owner who still has access to their account can claim the deposit and
+essentially punish the malicious user.
+
+Furthermore, the malicious recovery attempt can only be successful if the
+attacker is also able to get enough friends to vouch for the recovery attempt.
+In the case where the account owner prevents a malicious recovery process,
+this pallet makes it near-zero cost to re-configure the recovery settings and
+remove/replace friends who are acting inappropriately.
+
+### Safety Considerations
+
+It is important to note that this is a powerful pallet that can compromise the
+security of an account if used incorrectly. Some recommended practices for users
+of this pallet are:
+
+* Configure a significant `delay_period` for your recovery process: As long as you
+  have access to your recoverable account, you need only check the blockchain once
+  every `delay_period` blocks to ensure that no recovery attempt is successful
+  against your account. Using off-chain notification systems can help with this,
+  but ultimately, setting a large `delay_period` means that even the most skilled
+  attacker will need to wait this long before they can access your account.
+* Use a high threshold of approvals: Setting a value of 1 for the threshold means
+  that any of your friends would be able to recover your account. They would
+  simply need to start a recovery process and approve their own process. Similarly,
+  a threshold of 2 would mean that any 2 friends could work together to gain
+  access to your account. The only way to prevent against these kinds of attacks
+  is to choose a high threshold of approvals and select from a diverse friend
+  group that would not be able to reasonably coordinate with one another.
+* Reset your configuration over time: Since the entire deposit of creating a
+  recovery configuration is returned to the user, the only cost of updating
+  your recovery configuration is the transaction fees for the calls. Thus,
+  it is strongly encouraged to regularly update your recovery configuration
+  as your life changes and your relationship with new and existing friends
+  change as well.
+
+## Interface
+
+### Dispatchable Functions
+
+#### For General Users
+
+* `create_recovery` - Create a recovery configuration for your account and make it recoverable.
+* `initiate_recovery` - Start the recovery process for a recoverable account.
+
+#### For Friends of a Recoverable Account
+* `vouch_recovery` - As a `friend` of a recoverable account, vouch for a recovery attempt on the account.
+
+#### For a User Who Successfully Recovered an Account
+
+* `claim_recovery` - Claim access to the account that you have successfully completed the recovery process for.
+* `as_recovered` - Send a transaction as an account that you have recovered. See other functions below.
+
+#### For the Recoverable Account
+
+* `close_recovery` - Close an active recovery process for your account and reclaim the recovery deposit.
+* `remove_recovery` - Remove the recovery configuration from the account, making it un-recoverable.
+
+#### For Super Users
+
+* `set_recovered` - The ROOT origin is able to skip the recovery process and directly allow
+  one account to access another.
+
+License: Apache-2.0
diff --git a/substrate/frame/recovery/src/benchmarking.rs b/substrate/frame/recovery/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2deb55bb69f24fb1ee3abeca44bbb356d682a7f4
--- /dev/null
+++ b/substrate/frame/recovery/src/benchmarking.rs
@@ -0,0 +1,381 @@
+// 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(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use crate::Pallet;
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller};
+use frame_support::traits::{Currency, Get};
+use frame_system::RawOrigin;
+use sp_runtime::traits::Bounded;
+
+const SEED: u32 = 0;
+const DEFAULT_DELAY: u32 = 0;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn get_total_deposit<T: Config>(
+	bounded_friends: &FriendsOf<T>,
+) -> Option<<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance>
+{
+	let friend_deposit = T::FriendDepositFactor::get()
+		.checked_mul(&bounded_friends.len().saturated_into())
+		.unwrap();
+
+	T::ConfigDepositBase::get().checked_add(&friend_deposit)
+}
+
+fn generate_friends<T: Config>(num: u32) -> Vec<<T as frame_system::Config>::AccountId> {
+	// Create friends
+	let mut friends = (0..num).map(|x| account("friend", x, SEED)).collect::<Vec<_>>();
+	// Sort
+	friends.sort();
+
+	for friend in 0..friends.len() {
+		// Top up accounts of friends
+		T::Currency::make_free_balance_be(
+			&friends.get(friend).unwrap(),
+			BalanceOf::<T>::max_value(),
+		);
+	}
+
+	friends
+}
+
+fn add_caller_and_generate_friends<T: Config>(
+	caller: T::AccountId,
+	num: u32,
+) -> Vec<<T as frame_system::Config>::AccountId> {
+	// Create friends
+	let mut friends = generate_friends::<T>(num - 1);
+
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+	friends.push(caller);
+
+	// Sort
+	friends.sort();
+
+	friends
+}
+
+fn insert_recovery_account<T: Config>(caller: &T::AccountId, account: &T::AccountId) {
+	T::Currency::make_free_balance_be(&account, BalanceOf::<T>::max_value());
+
+	let n = T::MaxFriends::get();
+
+	let friends = generate_friends::<T>(n);
+
+	let bounded_friends: FriendsOf<T> = friends.try_into().unwrap();
+
+	// Get deposit for recovery
+	let total_deposit = get_total_deposit::<T>(&bounded_friends).unwrap();
+
+	let recovery_config = RecoveryConfig {
+		delay_period: DEFAULT_DELAY.into(),
+		deposit: total_deposit,
+		friends: bounded_friends,
+		threshold: n as u16,
+	};
+
+	// Reserve deposit for recovery
+	T::Currency::reserve(&caller, total_deposit).unwrap();
+
+	<Recoverable<T>>::insert(&account, recovery_config);
+}
+
+benchmarks! {
+	as_recovered {
+		let caller: T::AccountId = whitelisted_caller();
+		let recovered_account: T::AccountId = account("recovered_account", 0, SEED);
+		let recovered_account_lookup = T::Lookup::unlookup(recovered_account.clone());
+		let call: <T as Config>::RuntimeCall = frame_system::Call::<T>::remark { remark: vec![] }.into();
+
+		Proxy::<T>::insert(&caller, &recovered_account);
+	}: _(
+		RawOrigin::Signed(caller),
+		recovered_account_lookup,
+		Box::new(call)
+	)
+
+	set_recovered {
+		let lost: T::AccountId = whitelisted_caller();
+		let lost_lookup = T::Lookup::unlookup(lost.clone());
+		let rescuer: T::AccountId = whitelisted_caller();
+		let rescuer_lookup = T::Lookup::unlookup(rescuer.clone());
+	}: _(
+		RawOrigin::Root,
+		lost_lookup,
+		rescuer_lookup
+	) verify {
+		assert_last_event::<T>(
+			Event::AccountRecovered {
+				lost_account: lost,
+				rescuer_account: rescuer,
+			}.into()
+		);
+	}
+
+	create_recovery {
+		let n in 1 .. T::MaxFriends::get();
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		// Create friends
+		let friends = generate_friends::<T>(n);
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		friends,
+		n as u16,
+		DEFAULT_DELAY.into()
+	) verify {
+		assert_last_event::<T>(Event::RecoveryCreated { account: caller }.into());
+	}
+
+	initiate_recovery {
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let lost_account: T::AccountId = account("lost_account", 0, SEED);
+		let lost_account_lookup = T::Lookup::unlookup(lost_account.clone());
+
+		insert_recovery_account::<T>(&caller, &lost_account);
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		lost_account_lookup
+	) verify {
+		assert_last_event::<T>(
+			Event::RecoveryInitiated {
+				lost_account: lost_account,
+				rescuer_account: caller,
+			}.into()
+		);
+	}
+
+	vouch_recovery {
+		let n in 1 .. T::MaxFriends::get();
+
+		let caller: T::AccountId = whitelisted_caller();
+		let lost_account: T::AccountId = account("lost_account", 0, SEED);
+		let lost_account_lookup = T::Lookup::unlookup(lost_account.clone());
+		let rescuer_account: T::AccountId = account("rescuer_account", 0, SEED);
+		let rescuer_account_lookup = T::Lookup::unlookup(rescuer_account.clone());
+
+
+		// Create friends
+		let friends = add_caller_and_generate_friends::<T>(caller.clone(), n);
+		let bounded_friends: FriendsOf<T> = friends.try_into().unwrap();
+
+		// Get deposit for recovery
+		let total_deposit = get_total_deposit::<T>(&bounded_friends).unwrap();
+
+		let recovery_config = RecoveryConfig {
+			delay_period: DEFAULT_DELAY.into(),
+			deposit: total_deposit.clone(),
+			friends: bounded_friends.clone(),
+			threshold: n as u16,
+		};
+
+		// Create the recovery config storage item
+		<Recoverable<T>>::insert(&lost_account, recovery_config.clone());
+
+		// Reserve deposit for recovery
+		T::Currency::reserve(&caller, total_deposit).unwrap();
+
+		// Create an active recovery status
+		let recovery_status = ActiveRecovery {
+			created: DEFAULT_DELAY.into(),
+			deposit: total_deposit,
+			friends: generate_friends::<T>(n - 1).try_into().unwrap(),
+		};
+
+		// Create the active recovery storage item
+		<ActiveRecoveries<T>>::insert(&lost_account, &rescuer_account, recovery_status);
+
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		lost_account_lookup,
+		rescuer_account_lookup
+	) verify {
+		assert_last_event::<T>(
+			Event::RecoveryVouched {
+				lost_account: lost_account,
+				rescuer_account: rescuer_account,
+				sender: caller,
+			}.into()
+		);
+	}
+
+	claim_recovery {
+		let n in 1 .. T::MaxFriends::get();
+
+		let caller: T::AccountId = whitelisted_caller();
+		let lost_account: T::AccountId = account("lost_account", 0, SEED);
+		let lost_account_lookup = T::Lookup::unlookup(lost_account.clone());
+
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		// Create friends
+		let friends = generate_friends::<T>(n);
+		let bounded_friends: FriendsOf<T> = friends.try_into().unwrap();
+
+		// Get deposit for recovery
+		let total_deposit = get_total_deposit::<T>(&bounded_friends).unwrap();
+
+		let recovery_config = RecoveryConfig {
+			delay_period: 0u32.into(),
+			deposit: total_deposit.clone(),
+			friends: bounded_friends.clone(),
+			threshold: n as u16,
+		};
+
+		// Create the recovery config storage item
+		<Recoverable<T>>::insert(&lost_account, recovery_config.clone());
+
+		// Reserve deposit for recovery
+		T::Currency::reserve(&caller, total_deposit).unwrap();
+
+		// Create an active recovery status
+		let recovery_status = ActiveRecovery {
+			created: 0u32.into(),
+			deposit: total_deposit,
+			friends: bounded_friends.clone(),
+		};
+
+		// Create the active recovery storage item
+		<ActiveRecoveries<T>>::insert(&lost_account, &caller, recovery_status);
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		lost_account_lookup
+	) verify {
+		assert_last_event::<T>(
+			Event::AccountRecovered {
+				lost_account: lost_account,
+				rescuer_account: caller,
+			}.into()
+		);
+	}
+
+	close_recovery {
+		let caller: T::AccountId = whitelisted_caller();
+		let rescuer_account: T::AccountId = account("rescuer_account", 0, SEED);
+		let rescuer_account_lookup = T::Lookup::unlookup(rescuer_account.clone());
+
+		let n in 1 .. T::MaxFriends::get();
+
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		T::Currency::make_free_balance_be(&rescuer_account, BalanceOf::<T>::max_value());
+
+		// Create friends
+		let friends = generate_friends::<T>(n);
+		let bounded_friends: FriendsOf<T> = friends.try_into().unwrap();
+
+		// Get deposit for recovery
+		let total_deposit = get_total_deposit::<T>(&bounded_friends).unwrap();
+
+		let recovery_config = RecoveryConfig {
+			delay_period: DEFAULT_DELAY.into(),
+			deposit: total_deposit.clone(),
+			friends: bounded_friends.clone(),
+			threshold: n as u16,
+		};
+
+		// Create the recovery config storage item
+		<Recoverable<T>>::insert(&caller, recovery_config.clone());
+
+		// Reserve deposit for recovery
+		T::Currency::reserve(&caller, total_deposit).unwrap();
+
+		// Create an active recovery status
+		let recovery_status = ActiveRecovery {
+			created: DEFAULT_DELAY.into(),
+			deposit: total_deposit,
+			friends: bounded_friends.clone(),
+		};
+
+		// Create the active recovery storage item
+		<ActiveRecoveries<T>>::insert(&caller, &rescuer_account, recovery_status);
+	}: _(
+		RawOrigin::Signed(caller.clone()),
+		rescuer_account_lookup
+	) verify {
+		assert_last_event::<T>(
+			Event::RecoveryClosed {
+				lost_account: caller,
+				rescuer_account: rescuer_account,
+			}.into()
+		);
+	}
+
+	remove_recovery {
+		let n in 1 .. T::MaxFriends::get();
+
+		let caller: T::AccountId = whitelisted_caller();
+
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		// Create friends
+		let friends = generate_friends::<T>(n);
+		let bounded_friends: FriendsOf<T> = friends.try_into().unwrap();
+
+		// Get deposit for recovery
+		let total_deposit = get_total_deposit::<T>(&bounded_friends).unwrap();
+
+		let recovery_config = RecoveryConfig {
+			delay_period: DEFAULT_DELAY.into(),
+			deposit: total_deposit.clone(),
+			friends: bounded_friends.clone(),
+			threshold: n as u16,
+		};
+
+		// Create the recovery config storage item
+		<Recoverable<T>>::insert(&caller, recovery_config);
+
+		// Reserve deposit for recovery
+		T::Currency::reserve(&caller, total_deposit).unwrap();
+	}: _(
+		RawOrigin::Signed(caller.clone())
+	) verify {
+		assert_last_event::<T>(
+			Event::RecoveryRemoved {
+				lost_account: caller
+			}.into()
+		);
+	}
+
+	cancel_recovered {
+		let caller: T::AccountId = whitelisted_caller();
+		let account: T::AccountId = account("account", 0, SEED);
+		let account_lookup = T::Lookup::unlookup(account.clone());
+
+		frame_system::Pallet::<T>::inc_providers(&caller);
+
+		frame_system::Pallet::<T>::inc_consumers(&caller)?;
+
+		Proxy::<T>::insert(&caller, &account);
+	}: _(
+		RawOrigin::Signed(caller),
+		account_lookup
+	)
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/recovery/src/lib.rs b/substrate/frame/recovery/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5673147c8e0055fcd445fffa6a29046b880e9e11
--- /dev/null
+++ b/substrate/frame/recovery/src/lib.rs
@@ -0,0 +1,718 @@
+// 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.
+
+//! # Recovery Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! The Recovery pallet is an M-of-N social recovery tool for users to gain
+//! access to their accounts if the private key or other authentication mechanism
+//! is lost. Through this pallet, a user is able to make calls on-behalf-of another
+//! account which they have recovered. The recovery process is protected by trusted
+//! "friends" whom the original account owner chooses. A threshold (M) out of N
+//! friends are needed to give another account access to the recoverable account.
+//!
+//! ### Recovery Configuration
+//!
+//! The recovery process for each recoverable account can be configured by the account owner.
+//! They are able to choose:
+//! * `friends` - The list of friends that the account owner trusts to protect the recovery process
+//!   for their account.
+//! * `threshold` - The number of friends that need to approve a recovery process for the account to
+//!   be successfully recovered.
+//! * `delay_period` - The minimum number of blocks after the beginning of the recovery process that
+//!   need to pass before the account can be successfully recovered.
+//!
+//! There is a configurable deposit that all users need to pay to create a recovery
+//! configuration. This deposit is composed of a base deposit plus a multiplier for
+//! the number of friends chosen. This deposit is returned in full when the account
+//! owner removes their recovery configuration.
+//!
+//! ### Recovery Life Cycle
+//!
+//! The intended life cycle of a successful recovery takes the following steps:
+//! 1. The account owner calls `create_recovery` to set up a recovery configuration for their
+//!    account.
+//! 2. At some later time, the account owner loses access to their account and wants to recover it.
+//!    Likely, they will need to create a new account and fund it with enough balance to support the
+//!    transaction fees and the deposit for the recovery process.
+//! 3. Using this new account, they call `initiate_recovery`.
+//! 4. Then the account owner would contact their configured friends to vouch for the recovery
+//!    attempt. The account owner would provide their old account id and the new account id, and
+//!    friends would call `vouch_recovery` with those parameters.
+//! 5. Once a threshold number of friends have vouched for the recovery attempt, the account owner
+//!    needs to wait until the delay period has passed, starting when they initiated the recovery
+//!    process.
+//! 6. Now the account owner is able to call `claim_recovery`, which subsequently allows them to
+//!    call `as_recovered` and directly make calls on-behalf-of the lost account.
+//! 7. Using the now recovered account, the account owner can call `close_recovery` on the recovery
+//!    process they opened, reclaiming the recovery deposit they placed.
+//! 8. Then the account owner should then call `remove_recovery` to remove the recovery
+//!    configuration on the recovered account and reclaim the recovery configuration deposit they
+//!    placed.
+//! 9. Using `as_recovered`, the account owner is able to call any other pallets to clean up their
+//!    state and reclaim any reserved or locked funds. They can then transfer all funds from the
+//!    recovered account to the new account.
+//! 10. When the recovered account becomes reaped (i.e. its free and reserved balance drops to
+//!     zero), the final recovery link is removed.
+//!
+//! ### Malicious Recovery Attempts
+//!
+//! Initializing a the recovery process for a recoverable account is open and
+//! permissionless. However, the recovery deposit is an economic deterrent that
+//! should disincentivize would-be attackers from trying to maliciously recover
+//! accounts.
+//!
+//! The recovery deposit can always be claimed by the account which is trying to
+//! to be recovered. In the case of a malicious recovery attempt, the account
+//! owner who still has access to their account can claim the deposit and
+//! essentially punish the malicious user.
+//!
+//! Furthermore, the malicious recovery attempt can only be successful if the
+//! attacker is also able to get enough friends to vouch for the recovery attempt.
+//! In the case where the account owner prevents a malicious recovery process,
+//! this pallet makes it near-zero cost to re-configure the recovery settings and
+//! remove/replace friends who are acting inappropriately.
+//!
+//! ### Safety Considerations
+//!
+//! It is important to note that this is a powerful pallet that can compromise the
+//! security of an account if used incorrectly. Some recommended practices for users
+//! of this pallet are:
+//!
+//! * Configure a significant `delay_period` for your recovery process: As long as you have access
+//!   to your recoverable account, you need only check the blockchain once every `delay_period`
+//!   blocks to ensure that no recovery attempt is successful against your account. Using off-chain
+//!   notification systems can help with this, but ultimately, setting a large `delay_period` means
+//!   that even the most skilled attacker will need to wait this long before they can access your
+//!   account.
+//! * Use a high threshold of approvals: Setting a value of 1 for the threshold means that any of
+//!   your friends would be able to recover your account. They would simply need to start a recovery
+//!   process and approve their own process. Similarly, a threshold of 2 would mean that any 2
+//!   friends could work together to gain access to your account. The only way to prevent against
+//!   these kinds of attacks is to choose a high threshold of approvals and select from a diverse
+//!   friend group that would not be able to reasonably coordinate with one another.
+//! * Reset your configuration over time: Since the entire deposit of creating a recovery
+//!   configuration is returned to the user, the only cost of updating your recovery configuration
+//!   is the transaction fees for the calls. Thus, it is strongly encouraged to regularly update
+//!   your recovery configuration as your life changes and your relationship with new and existing
+//!   friends change as well.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! #### For General Users
+//!
+//! * `create_recovery` - Create a recovery configuration for your account and make it recoverable.
+//! * `initiate_recovery` - Start the recovery process for a recoverable account.
+//!
+//! #### For Friends of a Recoverable Account
+//! * `vouch_recovery` - As a `friend` of a recoverable account, vouch for a recovery attempt on the
+//!   account.
+//!
+//! #### For a User Who Successfully Recovered an Account
+//!
+//! * `claim_recovery` - Claim access to the account that you have successfully completed the
+//!   recovery process for.
+//! * `as_recovered` - Send a transaction as an account that you have recovered. See other functions
+//!   below.
+//!
+//! #### For the Recoverable Account
+//!
+//! * `close_recovery` - Close an active recovery process for your account and reclaim the recovery
+//!   deposit.
+//! * `remove_recovery` - Remove the recovery configuration from the account, making it
+//!   un-recoverable.
+//!
+//! #### For Super Users
+//!
+//! * `set_recovered` - The ROOT origin is able to skip the recovery process and directly allow one
+//!   account to access another.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{CheckedAdd, CheckedMul, Dispatchable, SaturatedConversion, StaticLookup},
+	RuntimeDebug,
+};
+use sp_std::prelude::*;
+
+use frame_support::{
+	dispatch::{GetDispatchInfo, PostDispatchInfo},
+	traits::{BalanceStatus, Currency, ReservableCurrency},
+	BoundedVec,
+};
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+type FriendsOf<T> = BoundedVec<<T as frame_system::Config>::AccountId, <T as Config>::MaxFriends>;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// An active recovery process.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, Default, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ActiveRecovery<BlockNumber, Balance, Friends> {
+	/// The block number when the recovery process started.
+	created: BlockNumber,
+	/// The amount held in reserve of the `depositor`,
+	/// To be returned once this recovery process is closed.
+	deposit: Balance,
+	/// The friends which have vouched so far. Always sorted.
+	friends: Friends,
+}
+
+/// Configuration for recovering an account.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, Default, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct RecoveryConfig<BlockNumber, Balance, Friends> {
+	/// The minimum number of blocks since the start of the recovery process before the account
+	/// can be recovered.
+	delay_period: BlockNumber,
+	/// The amount held in reserve of the `depositor`,
+	/// to be returned once this configuration is removed.
+	deposit: Balance,
+	/// The list of friends which can help recover an account. Always sorted.
+	friends: Friends,
+	/// The number of approving friends needed to recover an account.
+	threshold: u16,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+	use sp_runtime::ArithmeticError;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Configuration trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The overarching call type.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ GetDispatchInfo
+			+ From<frame_system::Call<Self>>;
+
+		/// The currency mechanism.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// The base amount of currency needed to reserve for creating a recovery configuration.
+		///
+		/// This is held for an additional storage item whose value size is
+		/// `2 + sizeof(BlockNumber, Balance)` bytes.
+		#[pallet::constant]
+		type ConfigDepositBase: Get<BalanceOf<Self>>;
+
+		/// The amount of currency needed per additional user when creating a recovery
+		/// configuration.
+		///
+		/// This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage
+		/// value.
+		#[pallet::constant]
+		type FriendDepositFactor: Get<BalanceOf<Self>>;
+
+		/// The maximum amount of friends allowed in a recovery configuration.
+		///
+		/// NOTE: The threshold programmed in this Pallet uses u16, so it does
+		/// not really make sense to have a limit here greater than u16::MAX.
+		/// But also, that is a lot more than you should probably set this value
+		/// to anyway...
+		#[pallet::constant]
+		type MaxFriends: Get<u32>;
+
+		/// The base amount of currency needed to reserve for starting a recovery.
+		///
+		/// This is primarily held for deterring malicious recovery attempts, and should
+		/// have a value large enough that a bad actor would choose not to place this
+		/// deposit. It also acts to fund additional storage item whose value size is
+		/// `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable
+		/// threshold.
+		#[pallet::constant]
+		type RecoveryDeposit: Get<BalanceOf<Self>>;
+	}
+
+	/// Events type.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A recovery process has been set up for an account.
+		RecoveryCreated { account: T::AccountId },
+		/// A recovery process has been initiated for lost account by rescuer account.
+		RecoveryInitiated { lost_account: T::AccountId, rescuer_account: T::AccountId },
+		/// A recovery process for lost account by rescuer account has been vouched for by sender.
+		RecoveryVouched {
+			lost_account: T::AccountId,
+			rescuer_account: T::AccountId,
+			sender: T::AccountId,
+		},
+		/// A recovery process for lost account by rescuer account has been closed.
+		RecoveryClosed { lost_account: T::AccountId, rescuer_account: T::AccountId },
+		/// Lost account has been successfully recovered by rescuer account.
+		AccountRecovered { lost_account: T::AccountId, rescuer_account: T::AccountId },
+		/// A recovery process has been removed for an account.
+		RecoveryRemoved { lost_account: T::AccountId },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// User is not allowed to make a call on behalf of this account
+		NotAllowed,
+		/// Threshold must be greater than zero
+		ZeroThreshold,
+		/// Friends list must be greater than zero and threshold
+		NotEnoughFriends,
+		/// Friends list must be less than max friends
+		MaxFriends,
+		/// Friends list must be sorted and free of duplicates
+		NotSorted,
+		/// This account is not set up for recovery
+		NotRecoverable,
+		/// This account is already set up for recovery
+		AlreadyRecoverable,
+		/// A recovery process has already started for this account
+		AlreadyStarted,
+		/// A recovery process has not started for this rescuer
+		NotStarted,
+		/// This account is not a friend who can vouch
+		NotFriend,
+		/// The friend must wait until the delay period to vouch for this recovery
+		DelayPeriod,
+		/// This user has already vouched for this recovery
+		AlreadyVouched,
+		/// The threshold for recovering this account has not been met
+		Threshold,
+		/// There are still active recovery attempts that need to be closed
+		StillActive,
+		/// This account is already set up for recovery
+		AlreadyProxy,
+		/// Some internal state is broken.
+		BadState,
+	}
+
+	/// The set of recoverable accounts and their recovery configuration.
+	#[pallet::storage]
+	#[pallet::getter(fn recovery_config)]
+	pub type Recoverable<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		RecoveryConfig<BlockNumberFor<T>, BalanceOf<T>, FriendsOf<T>>,
+	>;
+
+	/// Active recovery attempts.
+	///
+	/// First account is the account to be recovered, and the second account
+	/// is the user trying to recover the account.
+	#[pallet::storage]
+	#[pallet::getter(fn active_recovery)]
+	pub type ActiveRecoveries<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Twox64Concat,
+		T::AccountId,
+		ActiveRecovery<BlockNumberFor<T>, BalanceOf<T>, FriendsOf<T>>,
+	>;
+
+	/// The list of allowed proxy accounts.
+	///
+	/// Map from the user who can access it to the recovered account.
+	#[pallet::storage]
+	#[pallet::getter(fn proxy)]
+	pub type Proxy<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, T::AccountId>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Send a call through a recovered account.
+		///
+		/// The dispatch origin for this call must be _Signed_ and registered to
+		/// be able to make calls on behalf of the recovered account.
+		///
+		/// Parameters:
+		/// - `account`: The recovered account you want to make a call on-behalf-of.
+		/// - `call`: The call you want to make with the recovered account.
+		#[pallet::call_index(0)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::as_recovered().saturating_add(dispatch_info.weight),
+				dispatch_info.class,
+			)})]
+		pub fn as_recovered(
+			origin: OriginFor<T>,
+			account: AccountIdLookupOf<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let account = T::Lookup::lookup(account)?;
+			// Check `who` is allowed to make a call on behalf of `account`
+			let target = Self::proxy(&who).ok_or(Error::<T>::NotAllowed)?;
+			ensure!(target == account, Error::<T>::NotAllowed);
+			call.dispatch(frame_system::RawOrigin::Signed(account).into())
+				.map(|_| ())
+				.map_err(|e| e.error)
+		}
+
+		/// Allow ROOT to bypass the recovery process and set an a rescuer account
+		/// for a lost account directly.
+		///
+		/// The dispatch origin for this call must be _ROOT_.
+		///
+		/// Parameters:
+		/// - `lost`: The "lost account" to be recovered.
+		/// - `rescuer`: The "rescuer account" which can call as the lost account.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::set_recovered())]
+		pub fn set_recovered(
+			origin: OriginFor<T>,
+			lost: AccountIdLookupOf<T>,
+			rescuer: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let lost = T::Lookup::lookup(lost)?;
+			let rescuer = T::Lookup::lookup(rescuer)?;
+			// Create the recovery storage item.
+			<Proxy<T>>::insert(&rescuer, &lost);
+			Self::deposit_event(Event::<T>::AccountRecovered {
+				lost_account: lost,
+				rescuer_account: rescuer,
+			});
+			Ok(())
+		}
+
+		/// Create a recovery configuration for your account. This makes your account recoverable.
+		///
+		/// Payment: `ConfigDepositBase` + `FriendDepositFactor` * #_of_friends balance
+		/// will be reserved for storing the recovery configuration. This deposit is returned
+		/// in full when the user calls `remove_recovery`.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `friends`: A list of friends you trust to vouch for recovery attempts. Should be
+		///   ordered and contain no duplicate values.
+		/// - `threshold`: The number of friends that must vouch for a recovery attempt before the
+		///   account can be recovered. Should be less than or equal to the length of the list of
+		///   friends.
+		/// - `delay_period`: The number of blocks after a recovery attempt is initialized that
+		///   needs to pass before the account can be recovered.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::create_recovery(friends.len() as u32))]
+		pub fn create_recovery(
+			origin: OriginFor<T>,
+			friends: Vec<T::AccountId>,
+			threshold: u16,
+			delay_period: BlockNumberFor<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			// Check account is not already set up for recovery
+			ensure!(!<Recoverable<T>>::contains_key(&who), Error::<T>::AlreadyRecoverable);
+			// Check user input is valid
+			ensure!(threshold >= 1, Error::<T>::ZeroThreshold);
+			ensure!(!friends.is_empty(), Error::<T>::NotEnoughFriends);
+			ensure!(threshold as usize <= friends.len(), Error::<T>::NotEnoughFriends);
+			let bounded_friends: FriendsOf<T> =
+				friends.try_into().map_err(|_| Error::<T>::MaxFriends)?;
+			ensure!(Self::is_sorted_and_unique(&bounded_friends), Error::<T>::NotSorted);
+			// Total deposit is base fee + number of friends * factor fee
+			let friend_deposit = T::FriendDepositFactor::get()
+				.checked_mul(&bounded_friends.len().saturated_into())
+				.ok_or(ArithmeticError::Overflow)?;
+			let total_deposit = T::ConfigDepositBase::get()
+				.checked_add(&friend_deposit)
+				.ok_or(ArithmeticError::Overflow)?;
+			// Reserve the deposit
+			T::Currency::reserve(&who, total_deposit)?;
+			// Create the recovery configuration
+			let recovery_config = RecoveryConfig {
+				delay_period,
+				deposit: total_deposit,
+				friends: bounded_friends,
+				threshold,
+			};
+			// Create the recovery configuration storage item
+			<Recoverable<T>>::insert(&who, recovery_config);
+
+			Self::deposit_event(Event::<T>::RecoveryCreated { account: who });
+			Ok(())
+		}
+
+		/// Initiate the process for recovering a recoverable account.
+		///
+		/// Payment: `RecoveryDeposit` balance will be reserved for initiating the
+		/// recovery process. This deposit will always be repatriated to the account
+		/// trying to be recovered. See `close_recovery`.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `account`: The lost account that you want to recover. This account needs to be
+		///   recoverable (i.e. have a recovery configuration).
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::initiate_recovery())]
+		pub fn initiate_recovery(
+			origin: OriginFor<T>,
+			account: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let account = T::Lookup::lookup(account)?;
+			// Check that the account is recoverable
+			ensure!(<Recoverable<T>>::contains_key(&account), Error::<T>::NotRecoverable);
+			// Check that the recovery process has not already been started
+			ensure!(
+				!<ActiveRecoveries<T>>::contains_key(&account, &who),
+				Error::<T>::AlreadyStarted
+			);
+			// Take recovery deposit
+			let recovery_deposit = T::RecoveryDeposit::get();
+			T::Currency::reserve(&who, recovery_deposit)?;
+			// Create an active recovery status
+			let recovery_status = ActiveRecovery {
+				created: <frame_system::Pallet<T>>::block_number(),
+				deposit: recovery_deposit,
+				friends: Default::default(),
+			};
+			// Create the active recovery storage item
+			<ActiveRecoveries<T>>::insert(&account, &who, recovery_status);
+			Self::deposit_event(Event::<T>::RecoveryInitiated {
+				lost_account: account,
+				rescuer_account: who,
+			});
+			Ok(())
+		}
+
+		/// Allow a "friend" of a recoverable account to vouch for an active recovery
+		/// process for that account.
+		///
+		/// The dispatch origin for this call must be _Signed_ and must be a "friend"
+		/// for the recoverable account.
+		///
+		/// Parameters:
+		/// - `lost`: The lost account that you want to recover.
+		/// - `rescuer`: The account trying to rescue the lost account that you want to vouch for.
+		///
+		/// The combination of these two parameters must point to an active recovery
+		/// process.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::vouch_recovery(T::MaxFriends::get()))]
+		pub fn vouch_recovery(
+			origin: OriginFor<T>,
+			lost: AccountIdLookupOf<T>,
+			rescuer: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let lost = T::Lookup::lookup(lost)?;
+			let rescuer = T::Lookup::lookup(rescuer)?;
+			// Get the recovery configuration for the lost account.
+			let recovery_config = Self::recovery_config(&lost).ok_or(Error::<T>::NotRecoverable)?;
+			// Get the active recovery process for the rescuer.
+			let mut active_recovery =
+				Self::active_recovery(&lost, &rescuer).ok_or(Error::<T>::NotStarted)?;
+			// Make sure the voter is a friend
+			ensure!(Self::is_friend(&recovery_config.friends, &who), Error::<T>::NotFriend);
+			// Either insert the vouch, or return an error that the user already vouched.
+			match active_recovery.friends.binary_search(&who) {
+				Ok(_pos) => return Err(Error::<T>::AlreadyVouched.into()),
+				Err(pos) => active_recovery
+					.friends
+					.try_insert(pos, who.clone())
+					.map_err(|_| Error::<T>::MaxFriends)?,
+			}
+			// Update storage with the latest details
+			<ActiveRecoveries<T>>::insert(&lost, &rescuer, active_recovery);
+			Self::deposit_event(Event::<T>::RecoveryVouched {
+				lost_account: lost,
+				rescuer_account: rescuer,
+				sender: who,
+			});
+			Ok(())
+		}
+
+		/// Allow a successful rescuer to claim their recovered account.
+		///
+		/// The dispatch origin for this call must be _Signed_ and must be a "rescuer"
+		/// who has successfully completed the account recovery process: collected
+		/// `threshold` or more vouches, waited `delay_period` blocks since initiation.
+		///
+		/// Parameters:
+		/// - `account`: The lost account that you want to claim has been successfully recovered by
+		///   you.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::claim_recovery(T::MaxFriends::get()))]
+		pub fn claim_recovery(
+			origin: OriginFor<T>,
+			account: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let account = T::Lookup::lookup(account)?;
+			// Get the recovery configuration for the lost account
+			let recovery_config =
+				Self::recovery_config(&account).ok_or(Error::<T>::NotRecoverable)?;
+			// Get the active recovery process for the rescuer
+			let active_recovery =
+				Self::active_recovery(&account, &who).ok_or(Error::<T>::NotStarted)?;
+			ensure!(!Proxy::<T>::contains_key(&who), Error::<T>::AlreadyProxy);
+			// Make sure the delay period has passed
+			let current_block_number = <frame_system::Pallet<T>>::block_number();
+			let recoverable_block_number = active_recovery
+				.created
+				.checked_add(&recovery_config.delay_period)
+				.ok_or(ArithmeticError::Overflow)?;
+			ensure!(recoverable_block_number <= current_block_number, Error::<T>::DelayPeriod);
+			// Make sure the threshold is met
+			ensure!(
+				recovery_config.threshold as usize <= active_recovery.friends.len(),
+				Error::<T>::Threshold
+			);
+			frame_system::Pallet::<T>::inc_consumers(&who).map_err(|_| Error::<T>::BadState)?;
+			// Create the recovery storage item
+			Proxy::<T>::insert(&who, &account);
+			Self::deposit_event(Event::<T>::AccountRecovered {
+				lost_account: account,
+				rescuer_account: who,
+			});
+			Ok(())
+		}
+
+		/// As the controller of a recoverable account, close an active recovery
+		/// process for your account.
+		///
+		/// Payment: By calling this function, the recoverable account will receive
+		/// the recovery deposit `RecoveryDeposit` placed by the rescuer.
+		///
+		/// The dispatch origin for this call must be _Signed_ and must be a
+		/// recoverable account with an active recovery process for it.
+		///
+		/// Parameters:
+		/// - `rescuer`: The account trying to rescue this recoverable account.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::close_recovery(T::MaxFriends::get()))]
+		pub fn close_recovery(
+			origin: OriginFor<T>,
+			rescuer: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let rescuer = T::Lookup::lookup(rescuer)?;
+			// Take the active recovery process started by the rescuer for this account.
+			let active_recovery =
+				<ActiveRecoveries<T>>::take(&who, &rescuer).ok_or(Error::<T>::NotStarted)?;
+			// Move the reserved funds from the rescuer to the rescued account.
+			// Acts like a slashing mechanism for those who try to maliciously recover accounts.
+			let res = T::Currency::repatriate_reserved(
+				&rescuer,
+				&who,
+				active_recovery.deposit,
+				BalanceStatus::Free,
+			);
+			debug_assert!(res.is_ok());
+			Self::deposit_event(Event::<T>::RecoveryClosed {
+				lost_account: who,
+				rescuer_account: rescuer,
+			});
+			Ok(())
+		}
+
+		/// Remove the recovery process for your account. Recovered accounts are still accessible.
+		///
+		/// NOTE: The user must make sure to call `close_recovery` on all active
+		/// recovery attempts before calling this function else it will fail.
+		///
+		/// Payment: By calling this function the recoverable account will unreserve
+		/// their recovery configuration deposit.
+		/// (`ConfigDepositBase` + `FriendDepositFactor` * #_of_friends)
+		///
+		/// The dispatch origin for this call must be _Signed_ and must be a
+		/// recoverable account (i.e. has a recovery configuration).
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::remove_recovery(T::MaxFriends::get()))]
+		pub fn remove_recovery(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			// Check there are no active recoveries
+			let mut active_recoveries = <ActiveRecoveries<T>>::iter_prefix_values(&who);
+			ensure!(active_recoveries.next().is_none(), Error::<T>::StillActive);
+			// Take the recovery configuration for this account.
+			let recovery_config = <Recoverable<T>>::take(&who).ok_or(Error::<T>::NotRecoverable)?;
+
+			// Unreserve the initial deposit for the recovery configuration.
+			T::Currency::unreserve(&who, recovery_config.deposit);
+			Self::deposit_event(Event::<T>::RecoveryRemoved { lost_account: who });
+			Ok(())
+		}
+
+		/// Cancel the ability to use `as_recovered` for `account`.
+		///
+		/// The dispatch origin for this call must be _Signed_ and registered to
+		/// be able to make calls on behalf of the recovered account.
+		///
+		/// Parameters:
+		/// - `account`: The recovered account you are able to call on-behalf-of.
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::cancel_recovered())]
+		pub fn cancel_recovered(
+			origin: OriginFor<T>,
+			account: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let account = T::Lookup::lookup(account)?;
+			// Check `who` is allowed to make a call on behalf of `account`
+			ensure!(Self::proxy(&who) == Some(account), Error::<T>::NotAllowed);
+			Proxy::<T>::remove(&who);
+
+			frame_system::Pallet::<T>::dec_consumers(&who);
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Check that friends list is sorted and has no duplicates.
+	fn is_sorted_and_unique(friends: &Vec<T::AccountId>) -> bool {
+		friends.windows(2).all(|w| w[0] < w[1])
+	}
+
+	/// Check that a user is a friend in the friends list.
+	fn is_friend(friends: &Vec<T::AccountId>, friend: &T::AccountId) -> bool {
+		friends.binary_search(&friend).is_ok()
+	}
+}
diff --git a/substrate/frame/recovery/src/mock.rs b/substrate/frame/recovery/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f2bd866a71986be89d49955c984c31e37fedbdc
--- /dev/null
+++ b/substrate/frame/recovery/src/mock.rs
@@ -0,0 +1,131 @@
+// 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.
+
+//! Test utilities
+
+use super::*;
+
+use crate as recovery;
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64, OnFinalize, OnInitialize},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Recovery: recovery::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+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 = pallet_balances::AccountData<u128>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+parameter_types! {
+	pub const ExistentialDeposit: u64 = 1;
+}
+
+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 MaxHolds = ();
+}
+
+parameter_types! {
+	pub const ConfigDepositBase: u64 = 10;
+	pub const FriendDepositFactor: u64 = 1;
+	pub const RecoveryDeposit: u64 = 10;
+	// Large number of friends for benchmarking.
+	pub const MaxFriends: u32 = 128;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type ConfigDepositBase = ConfigDepositBase;
+	type FriendDepositFactor = FriendDepositFactor;
+	type MaxFriends = MaxFriends;
+	type RecoveryDeposit = RecoveryDeposit;
+}
+
+pub type BalancesCall = pallet_balances::Call<Test>;
+pub type RecoveryCall = super::Call<Test>;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 100), (2, 100), (3, 100), (4, 100), (5, 100)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
+
+/// Run until a particular block.
+pub fn run_to_block(n: u64) {
+	while System::block_number() < n {
+		if System::block_number() > 1 {
+			System::on_finalize(System::block_number());
+		}
+		System::set_block_number(System::block_number() + 1);
+		System::on_initialize(System::block_number());
+	}
+}
diff --git a/substrate/frame/recovery/src/tests.rs b/substrate/frame/recovery/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..93df07015852e689db0ec02114642baa303ee349
--- /dev/null
+++ b/substrate/frame/recovery/src/tests.rs
@@ -0,0 +1,497 @@
+// 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 the module.
+
+use super::*;
+use frame_support::{assert_noop, assert_ok, traits::Currency};
+use mock::{
+	new_test_ext, run_to_block, Balances, BalancesCall, MaxFriends, Recovery, RecoveryCall,
+	RuntimeCall, RuntimeOrigin, Test,
+};
+use sp_runtime::{bounded_vec, traits::BadOrigin};
+
+#[test]
+fn basic_setup_works() {
+	new_test_ext().execute_with(|| {
+		// Nothing in storage to start
+		assert_eq!(Recovery::proxy(&2), None);
+		assert_eq!(Recovery::active_recovery(&1, &2), None);
+		assert_eq!(Recovery::recovery_config(&1), None);
+		// Everyone should have starting balance of 100
+		assert_eq!(Balances::free_balance(1), 100);
+	});
+}
+
+#[test]
+fn set_recovered_works() {
+	new_test_ext().execute_with(|| {
+		// Not accessible by a normal user
+		assert_noop!(Recovery::set_recovered(RuntimeOrigin::signed(1), 5, 1), BadOrigin);
+		// Root can set a recovered account though
+		assert_ok!(Recovery::set_recovered(RuntimeOrigin::root(), 5, 1));
+		// Account 1 should now be able to make a call through account 5
+		let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 1,
+			value: 100,
+		}));
+		assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
+		// Account 1 has successfully drained the funds from account 5
+		assert_eq!(Balances::free_balance(1), 200);
+		assert_eq!(Balances::free_balance(5), 0);
+	});
+}
+
+#[test]
+fn recovery_life_cycle_works() {
+	new_test_ext().execute_with(|| {
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		// Account 5 sets up a recovery configuration on their account
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends,
+			threshold,
+			delay_period
+		));
+		// Some time has passed, and the user lost their keys!
+		run_to_block(10);
+		// Using account 1, the user begins the recovery process to recover the lost account
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		// Off chain, the user contacts their friends and asks them to vouch for the recovery
+		// attempt
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
+		// We met the threshold, lets try to recover the account...?
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::DelayPeriod
+		);
+		// We need to wait at least the delay_period number of blocks before we can recover
+		run_to_block(20);
+		assert_ok!(Recovery::claim_recovery(RuntimeOrigin::signed(1), 5));
+		// Account 1 can use account 5 to close the active recovery process, claiming the deposited
+		// funds used to initiate the recovery process into account 5.
+		let call = Box::new(RuntimeCall::Recovery(RecoveryCall::close_recovery { rescuer: 1 }));
+		assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
+		// Account 1 can then use account 5 to remove the recovery configuration, claiming the
+		// deposited funds used to create the recovery configuration into account 5.
+		let call = Box::new(RuntimeCall::Recovery(RecoveryCall::remove_recovery {}));
+		assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
+		// Account 1 should now be able to make a call through account 5 to get all of their funds
+		assert_eq!(Balances::free_balance(5), 110);
+		let call = Box::new(RuntimeCall::Balances(BalancesCall::transfer_allow_death {
+			dest: 1,
+			value: 110,
+		}));
+		assert_ok!(Recovery::as_recovered(RuntimeOrigin::signed(1), 5, call));
+		// All funds have been fully recovered!
+		assert_eq!(Balances::free_balance(1), 200);
+		assert_eq!(Balances::free_balance(5), 0);
+		// Remove the proxy link.
+		assert_ok!(Recovery::cancel_recovered(RuntimeOrigin::signed(1), 5));
+
+		// All storage items are removed from the module
+		assert!(!<ActiveRecoveries<Test>>::contains_key(&5, &1));
+		assert!(!<Recoverable<Test>>::contains_key(&5));
+		assert!(!<Proxy<Test>>::contains_key(&1));
+	});
+}
+
+#[test]
+fn malicious_recovery_fails() {
+	new_test_ext().execute_with(|| {
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		// Account 5 sets up a recovery configuration on their account
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends,
+			threshold,
+			delay_period
+		));
+		// Some time has passed, and account 1 wants to try and attack this account!
+		run_to_block(10);
+		// Using account 1, the malicious user begins the recovery process on account 5
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		// Off chain, the user **tricks** their friends and asks them to vouch for the recovery
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
+		// shame on you
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
+		// shame on you
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
+		// shame on you
+		// We met the threshold, lets try to recover the account...?
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::DelayPeriod
+		);
+		// Account 1 needs to wait...
+		run_to_block(19);
+		// One more block to wait!
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::DelayPeriod
+		);
+		// Account 5 checks their account every `delay_period` and notices the malicious attack!
+		// Account 5 can close the recovery process before account 1 can claim it
+		assert_ok!(Recovery::close_recovery(RuntimeOrigin::signed(5), 1));
+		// By doing so, account 5 has now claimed the deposit originally reserved by account 1
+		assert_eq!(Balances::total_balance(&1), 90);
+		// Thanks for the free money!
+		assert_eq!(Balances::total_balance(&5), 110);
+		// The recovery process has been closed, so account 1 can't make the claim
+		run_to_block(20);
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::NotStarted
+		);
+		// Account 5 can remove their recovery config and pick some better friends
+		assert_ok!(Recovery::remove_recovery(RuntimeOrigin::signed(5)));
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			vec![22, 33, 44],
+			threshold,
+			delay_period
+		));
+	});
+}
+
+#[test]
+fn create_recovery_handles_basic_errors() {
+	new_test_ext().execute_with(|| {
+		// No friends
+		assert_noop!(
+			Recovery::create_recovery(RuntimeOrigin::signed(5), vec![], 1, 0),
+			Error::<Test>::NotEnoughFriends
+		);
+		// Zero threshold
+		assert_noop!(
+			Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2], 0, 0),
+			Error::<Test>::ZeroThreshold
+		);
+		// Threshold greater than friends length
+		assert_noop!(
+			Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 3, 4], 4, 0),
+			Error::<Test>::NotEnoughFriends
+		);
+		// Too many friends
+		assert_noop!(
+			Recovery::create_recovery(
+				RuntimeOrigin::signed(5),
+				vec![1; (MaxFriends::get() + 1) as usize],
+				1,
+				0
+			),
+			Error::<Test>::MaxFriends
+		);
+		// Unsorted friends
+		assert_noop!(
+			Recovery::create_recovery(RuntimeOrigin::signed(5), vec![3, 2, 4], 3, 0),
+			Error::<Test>::NotSorted
+		);
+		// Duplicate friends
+		assert_noop!(
+			Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 2, 4], 3, 0),
+			Error::<Test>::NotSorted
+		);
+		// Already configured
+		assert_ok!(Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 3, 4], 3, 10));
+		assert_noop!(
+			Recovery::create_recovery(RuntimeOrigin::signed(5), vec![2, 3, 4], 3, 10),
+			Error::<Test>::AlreadyRecoverable
+		);
+	});
+}
+
+#[test]
+fn create_recovery_works() {
+	new_test_ext().execute_with(|| {
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		// Account 5 sets up a recovery configuration on their account
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		// Deposit is taken, and scales with the number of friends they pick
+		// Base 10 + 1 per friends = 13 total reserved
+		assert_eq!(Balances::reserved_balance(5), 13);
+		// Recovery configuration is correctly stored
+		let recovery_config = RecoveryConfig {
+			delay_period,
+			deposit: 13,
+			friends: friends.try_into().unwrap(),
+			threshold,
+		};
+		assert_eq!(Recovery::recovery_config(5), Some(recovery_config));
+	});
+}
+
+#[test]
+fn initiate_recovery_handles_basic_errors() {
+	new_test_ext().execute_with(|| {
+		// No recovery process set up for the account
+		assert_noop!(
+			Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::NotRecoverable
+		);
+		// Create a recovery process for next test
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		// Same user cannot recover same account twice
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		assert_noop!(
+			Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::AlreadyStarted
+		);
+		// No double deposit
+		assert_eq!(Balances::reserved_balance(1), 10);
+	});
+}
+
+#[test]
+fn initiate_recovery_works() {
+	new_test_ext().execute_with(|| {
+		// Create a recovery process for the test
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		// Recovery can be initiated
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		// Deposit is reserved
+		assert_eq!(Balances::reserved_balance(1), 10);
+		// Recovery status object is created correctly
+		let recovery_status =
+			ActiveRecovery { created: 0, deposit: 10, friends: Default::default() };
+		assert_eq!(<ActiveRecoveries<Test>>::get(&5, &1), Some(recovery_status));
+		// Multiple users can attempt to recover the same account
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(2), 5));
+	});
+}
+
+#[test]
+fn vouch_recovery_handles_basic_errors() {
+	new_test_ext().execute_with(|| {
+		// Cannot vouch for non-recoverable account
+		assert_noop!(
+			Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1),
+			Error::<Test>::NotRecoverable
+		);
+		// Create a recovery process for next tests
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		// Cannot vouch a recovery process that has not started
+		assert_noop!(
+			Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1),
+			Error::<Test>::NotStarted
+		);
+		// Initiate a recovery process
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		// Cannot vouch if you are not a friend
+		assert_noop!(
+			Recovery::vouch_recovery(RuntimeOrigin::signed(22), 5, 1),
+			Error::<Test>::NotFriend
+		);
+		// Cannot vouch twice
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
+		assert_noop!(
+			Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1),
+			Error::<Test>::AlreadyVouched
+		);
+	});
+}
+
+#[test]
+fn vouch_recovery_works() {
+	new_test_ext().execute_with(|| {
+		// Create and initiate a recovery process for the test
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		// Vouching works
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
+		// Handles out of order vouches
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
+		// Final recovery status object is updated correctly
+		let recovery_status =
+			ActiveRecovery { created: 0, deposit: 10, friends: bounded_vec![2, 3, 4] };
+		assert_eq!(<ActiveRecoveries<Test>>::get(&5, &1), Some(recovery_status));
+	});
+}
+
+#[test]
+fn claim_recovery_handles_basic_errors() {
+	new_test_ext().execute_with(|| {
+		// Cannot claim a non-recoverable account
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::NotRecoverable
+		);
+		// Create a recovery process for the test
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		// Cannot claim an account which has not started the recovery process
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::NotStarted
+		);
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		// Cannot claim an account which has not passed the delay period
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::DelayPeriod
+		);
+		run_to_block(11);
+		// Cannot claim an account which has not passed the threshold number of votes
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
+		// Only 2/3 is not good enough
+		assert_noop!(
+			Recovery::claim_recovery(RuntimeOrigin::signed(1), 5),
+			Error::<Test>::Threshold
+		);
+	});
+}
+
+#[test]
+fn claim_recovery_works() {
+	new_test_ext().execute_with(|| {
+		// Create, initiate, and vouch recovery process for the test
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 1));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 1));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 1));
+
+		run_to_block(11);
+
+		// Account can be recovered.
+		assert_ok!(Recovery::claim_recovery(RuntimeOrigin::signed(1), 5));
+		// Recovered storage item is correctly created
+		assert_eq!(<Proxy<Test>>::get(&1), Some(5));
+		// Account could be re-recovered in the case that the recoverer account also gets lost.
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(4), 5));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(2), 5, 4));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(3), 5, 4));
+		assert_ok!(Recovery::vouch_recovery(RuntimeOrigin::signed(4), 5, 4));
+
+		run_to_block(21);
+
+		// Account is re-recovered.
+		assert_ok!(Recovery::claim_recovery(RuntimeOrigin::signed(4), 5));
+		// Recovered storage item is correctly updated
+		assert_eq!(<Proxy<Test>>::get(&4), Some(5));
+	});
+}
+
+#[test]
+fn close_recovery_handles_basic_errors() {
+	new_test_ext().execute_with(|| {
+		// Cannot close a non-active recovery
+		assert_noop!(
+			Recovery::close_recovery(RuntimeOrigin::signed(5), 1),
+			Error::<Test>::NotStarted
+		);
+	});
+}
+
+#[test]
+fn remove_recovery_works() {
+	new_test_ext().execute_with(|| {
+		// Cannot remove an unrecoverable account
+		assert_noop!(
+			Recovery::remove_recovery(RuntimeOrigin::signed(5)),
+			Error::<Test>::NotRecoverable
+		);
+		// Create and initiate a recovery process for the test
+		let friends = vec![2, 3, 4];
+		let threshold = 3;
+		let delay_period = 10;
+		assert_ok!(Recovery::create_recovery(
+			RuntimeOrigin::signed(5),
+			friends.clone(),
+			threshold,
+			delay_period
+		));
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(1), 5));
+		assert_ok!(Recovery::initiate_recovery(RuntimeOrigin::signed(2), 5));
+		// Cannot remove a recovery when there are active recoveries.
+		assert_noop!(
+			Recovery::remove_recovery(RuntimeOrigin::signed(5)),
+			Error::<Test>::StillActive
+		);
+		assert_ok!(Recovery::close_recovery(RuntimeOrigin::signed(5), 1));
+		// Still need to remove one more!
+		assert_noop!(
+			Recovery::remove_recovery(RuntimeOrigin::signed(5)),
+			Error::<Test>::StillActive
+		);
+		assert_ok!(Recovery::close_recovery(RuntimeOrigin::signed(5), 2));
+		// Finally removed
+		assert_ok!(Recovery::remove_recovery(RuntimeOrigin::signed(5)));
+	});
+}
diff --git a/substrate/frame/recovery/src/weights.rs b/substrate/frame/recovery/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..84b19ae694eec1107b9229c1894646cb8368bc0d
--- /dev/null
+++ b/substrate/frame/recovery/src/weights.rs
@@ -0,0 +1,321 @@
+// 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.
+
+//! Autogenerated weights for pallet_recovery
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_recovery
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/recovery/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_recovery.
+pub trait WeightInfo {
+	fn as_recovered() -> Weight;
+	fn set_recovered() -> Weight;
+	fn create_recovery(n: u32, ) -> Weight;
+	fn initiate_recovery() -> Weight;
+	fn vouch_recovery(n: u32, ) -> Weight;
+	fn claim_recovery(n: u32, ) -> Weight;
+	fn close_recovery(n: u32, ) -> Weight;
+	fn remove_recovery(n: u32, ) -> Weight;
+	fn cancel_recovered() -> Weight;
+}
+
+/// Weights for pallet_recovery using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Recovery Proxy (r:1 w:0)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	fn as_recovered() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `281`
+		//  Estimated: `3545`
+		// Minimum execution time: 9_360_000 picoseconds.
+		Weight::from_parts(9_773_000, 3545)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Recovery Proxy (r:0 w:1)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	fn set_recovered() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_146_000 picoseconds.
+		Weight::from_parts(9_507_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:1)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn create_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `175`
+		//  Estimated: `3816`
+		// Minimum execution time: 26_472_000 picoseconds.
+		Weight::from_parts(27_917_651, 3816)
+			// Standard Error: 7_129
+			.saturating_add(Weight::from_parts(59_239, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:0)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// Storage: Recovery ActiveRecoveries (r:1 w:1)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	fn initiate_recovery() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `272`
+		//  Estimated: `3854`
+		// Minimum execution time: 29_618_000 picoseconds.
+		Weight::from_parts(30_192_000, 3854)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:0)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// Storage: Recovery ActiveRecoveries (r:1 w:1)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn vouch_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `360 + n * (64 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 19_464_000 picoseconds.
+		Weight::from_parts(20_642_522, 3854)
+			// Standard Error: 5_974
+			.saturating_add(Weight::from_parts(142_308, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:0)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// Storage: Recovery ActiveRecoveries (r:1 w:0)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// Storage: Recovery Proxy (r:1 w:1)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn claim_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `392 + n * (64 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 23_656_000 picoseconds.
+		Weight::from_parts(24_903_269, 3854)
+			// Standard Error: 5_771
+			.saturating_add(Weight::from_parts(117_343, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery ActiveRecoveries (r:1 w:1)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn close_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `513 + n * (32 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 34_866_000 picoseconds.
+		Weight::from_parts(36_368_748, 3854)
+			// Standard Error: 6_600
+			.saturating_add(Weight::from_parts(118_610, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Recovery ActiveRecoveries (r:1 w:0)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// Storage: Recovery Recoverable (r:1 w:1)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn remove_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `270 + n * (32 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 31_405_000 picoseconds.
+		Weight::from_parts(32_552_838, 3854)
+			// Standard Error: 8_043
+			.saturating_add(Weight::from_parts(171_605, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Proxy (r:1 w:1)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	fn cancel_recovered() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `281`
+		//  Estimated: `3545`
+		// Minimum execution time: 11_530_000 picoseconds.
+		Weight::from_parts(11_851_000, 3545)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Recovery Proxy (r:1 w:0)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	fn as_recovered() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `281`
+		//  Estimated: `3545`
+		// Minimum execution time: 9_360_000 picoseconds.
+		Weight::from_parts(9_773_000, 3545)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Recovery Proxy (r:0 w:1)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	fn set_recovered() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_146_000 picoseconds.
+		Weight::from_parts(9_507_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:1)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn create_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `175`
+		//  Estimated: `3816`
+		// Minimum execution time: 26_472_000 picoseconds.
+		Weight::from_parts(27_917_651, 3816)
+			// Standard Error: 7_129
+			.saturating_add(Weight::from_parts(59_239, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:0)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// Storage: Recovery ActiveRecoveries (r:1 w:1)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	fn initiate_recovery() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `272`
+		//  Estimated: `3854`
+		// Minimum execution time: 29_618_000 picoseconds.
+		Weight::from_parts(30_192_000, 3854)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:0)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// Storage: Recovery ActiveRecoveries (r:1 w:1)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn vouch_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `360 + n * (64 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 19_464_000 picoseconds.
+		Weight::from_parts(20_642_522, 3854)
+			// Standard Error: 5_974
+			.saturating_add(Weight::from_parts(142_308, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Recoverable (r:1 w:0)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// Storage: Recovery ActiveRecoveries (r:1 w:0)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// Storage: Recovery Proxy (r:1 w:1)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn claim_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `392 + n * (64 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 23_656_000 picoseconds.
+		Weight::from_parts(24_903_269, 3854)
+			// Standard Error: 5_771
+			.saturating_add(Weight::from_parts(117_343, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery ActiveRecoveries (r:1 w:1)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn close_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `513 + n * (32 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 34_866_000 picoseconds.
+		Weight::from_parts(36_368_748, 3854)
+			// Standard Error: 6_600
+			.saturating_add(Weight::from_parts(118_610, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Recovery ActiveRecoveries (r:1 w:0)
+	/// Proof: Recovery ActiveRecoveries (max_values: None, max_size: Some(389), added: 2864, mode: MaxEncodedLen)
+	/// Storage: Recovery Recoverable (r:1 w:1)
+	/// Proof: Recovery Recoverable (max_values: None, max_size: Some(351), added: 2826, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 9]`.
+	fn remove_recovery(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `270 + n * (32 ±0)`
+		//  Estimated: `3854`
+		// Minimum execution time: 31_405_000 picoseconds.
+		Weight::from_parts(32_552_838, 3854)
+			// Standard Error: 8_043
+			.saturating_add(Weight::from_parts(171_605, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Recovery Proxy (r:1 w:1)
+	/// Proof: Recovery Proxy (max_values: None, max_size: Some(80), added: 2555, mode: MaxEncodedLen)
+	fn cancel_recovered() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `281`
+		//  Estimated: `3545`
+		// Minimum execution time: 11_530_000 picoseconds.
+		Weight::from_parts(11_851_000, 3545)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/referenda/Cargo.toml b/substrate/frame/referenda/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..abaed893ee54bc6c37470b0abe765c491aa3b98b
--- /dev/null
+++ b/substrate/frame/referenda/Cargo.toml
@@ -0,0 +1,75 @@
+[package]
+name = "pallet-referenda"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for inclusive on-chain decisions"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+assert_matches = { version = "1.5", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive"], optional = true }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+assert_matches = { version = "1.5" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-preimage = { version = "4.0.0-dev", path = "../preimage" }
+pallet-scheduler = { version = "4.0.0-dev", path = "../scheduler" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-preimage/std",
+	"pallet-scheduler/std",
+	"scale-info/std",
+	"serde",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"assert_matches",
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-preimage/runtime-benchmarks",
+	"pallet-scheduler/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-preimage/try-runtime",
+	"pallet-scheduler/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/referenda/README.md b/substrate/frame/referenda/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b9a8b022cbdb78bac9ac1471aa0d667e7c94f5fd
--- /dev/null
+++ b/substrate/frame/referenda/README.md
@@ -0,0 +1,8 @@
+# Referenda Pallet
+
+- [`Config`](https://docs.rs/pallet-referenda/latest/pallet_referenda/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-referenda/latest/pallet_referenda/pallet/enum.Call.html)
+
+## Overview
+
+The Referenda pallet handles the administration of general stakeholder voting.
diff --git a/substrate/frame/referenda/src/benchmarking.rs b/substrate/frame/referenda/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..78d14bd99d2ee6a3f03b94e3bcfe1293153e2d24
--- /dev/null
+++ b/substrate/frame/referenda/src/benchmarking.rs
@@ -0,0 +1,665 @@
+// 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.
+
+//! Democracy pallet benchmarking.
+
+use super::*;
+use crate::Pallet as Referenda;
+use assert_matches::assert_matches;
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelist_account, BenchmarkError,
+};
+use frame_support::{
+	assert_ok,
+	dispatch::UnfilteredDispatchable,
+	traits::{Bounded, Currency, EnsureOrigin, EnsureOriginWithArg},
+};
+use frame_system::RawOrigin;
+use sp_runtime::traits::Bounded as ArithBounded;
+
+const SEED: u32 = 0;
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+fn funded_account<T: Config<I>, I: 'static>(name: &'static str, index: u32) -> T::AccountId {
+	let caller: T::AccountId = account(name, index, SEED);
+	T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+	caller
+}
+
+fn dummy_call<T: Config<I>, I: 'static>() -> Bounded<<T as Config<I>>::RuntimeCall> {
+	let inner = frame_system::Call::remark { remark: vec![] };
+	let call = <T as Config<I>>::RuntimeCall::from(inner);
+	T::Preimages::bound(call).unwrap()
+}
+
+fn create_referendum<T: Config<I>, I: 'static>(origin: T::RuntimeOrigin) -> ReferendumIndex {
+	if let Ok(caller) = frame_system::ensure_signed(origin.clone()) {
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		whitelist_account!(caller);
+	}
+
+	let proposal_origin = Box::new(RawOrigin::Root.into());
+	let proposal = dummy_call::<T, I>();
+	let enactment_moment = DispatchTime::After(0u32.into());
+	let call = crate::Call::<T, I>::submit { proposal_origin, proposal, enactment_moment };
+	assert_ok!(call.dispatch_bypass_filter(origin.clone()));
+	let index = ReferendumCount::<T, I>::get() - 1;
+	index
+}
+
+fn place_deposit<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	let caller = funded_account::<T, I>("caller", 0);
+	whitelist_account!(caller);
+	assert_ok!(Referenda::<T, I>::place_decision_deposit(RawOrigin::Signed(caller).into(), index));
+}
+
+fn nudge<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	assert_ok!(Referenda::<T, I>::nudge_referendum(RawOrigin::Root.into(), index));
+}
+
+fn fill_queue<T: Config<I>, I: 'static>(
+	origin: T::RuntimeOrigin,
+	index: ReferendumIndex,
+	spaces: u32,
+	pass_after: u32,
+) -> Vec<ReferendumIndex> {
+	// First, create enough other referendums to fill the track.
+	let mut others = vec![];
+	for _ in 0..info::<T, I>(index).max_deciding {
+		let index = create_referendum::<T, I>(origin.clone());
+		place_deposit::<T, I>(index);
+		others.push(index);
+	}
+
+	// We will also need enough referenda which are queued and passing, we want `MaxQueued - 1`
+	// in order to force the maximum amount of work to insert ours into the queue.
+	for _ in spaces..T::MaxQueued::get() {
+		let index = create_referendum::<T, I>(origin.clone());
+		place_deposit::<T, I>(index);
+		make_passing_after::<T, I>(index, Perbill::from_percent(pass_after));
+		others.push(index);
+	}
+
+	// Skip to when they can start being decided.
+	skip_prepare_period::<T, I>(index);
+
+	// Manually nudge the other referenda first to ensure that they begin.
+	others.iter().for_each(|&i| nudge::<T, I>(i));
+
+	others
+}
+
+fn info<T: Config<I>, I: 'static>(index: ReferendumIndex) -> &'static TrackInfoOf<T, I> {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	T::Tracks::info(status.track).expect("Id value returned from T::Tracks")
+}
+
+fn make_passing_after<T: Config<I>, I: 'static>(index: ReferendumIndex, period_portion: Perbill) {
+	// We add an extra 1 percent to handle any perbill rounding errors which may cause
+	// a proposal to not actually pass.
+	let support = info::<T, I>(index)
+		.min_support
+		.threshold(period_portion)
+		.saturating_add(Perbill::from_percent(1));
+	let approval = info::<T, I>(index)
+		.min_approval
+		.threshold(period_portion)
+		.saturating_add(Perbill::from_percent(1));
+	Referenda::<T, I>::access_poll(index, |status| {
+		if let PollStatus::Ongoing(tally, class) = status {
+			T::Tally::setup(class, Perbill::from_rational(1u32, 1000u32));
+			*tally = T::Tally::from_requirements(support, approval, class);
+		}
+	});
+}
+
+fn make_passing<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	Referenda::<T, I>::access_poll(index, |status| {
+		if let PollStatus::Ongoing(tally, class) = status {
+			T::Tally::setup(class, Perbill::from_rational(1u32, 1000u32));
+			*tally = T::Tally::unanimity(class);
+		}
+	});
+}
+
+fn make_failing<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	Referenda::<T, I>::access_poll(index, |status| {
+		if let PollStatus::Ongoing(tally, class) = status {
+			T::Tally::setup(class, Perbill::from_rational(1u32, 1000u32));
+			*tally = T::Tally::rejection(class);
+		}
+	});
+}
+
+fn skip_prepare_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	let prepare_period_over = status.submitted + info::<T, I>(index).prepare_period;
+	frame_system::Pallet::<T>::set_block_number(prepare_period_over);
+}
+
+fn skip_decision_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	let decision_period_over = status.deciding.unwrap().since + info::<T, I>(index).decision_period;
+	frame_system::Pallet::<T>::set_block_number(decision_period_over);
+}
+
+fn skip_confirm_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	let confirm_period_over = status.deciding.unwrap().confirming.unwrap();
+	frame_system::Pallet::<T>::set_block_number(confirm_period_over);
+}
+
+fn skip_timeout_period<T: Config<I>, I: 'static>(index: ReferendumIndex) {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	let timeout_period_over = status.submitted + T::UndecidingTimeout::get();
+	frame_system::Pallet::<T>::set_block_number(timeout_period_over);
+}
+
+fn alarm_time<T: Config<I>, I: 'static>(
+	index: ReferendumIndex,
+) -> frame_system::pallet_prelude::BlockNumberFor<T> {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	status.alarm.unwrap().0
+}
+
+fn is_confirming<T: Config<I>, I: 'static>(index: ReferendumIndex) -> bool {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	matches!(
+		status,
+		ReferendumStatus { deciding: Some(DecidingStatus { confirming: Some(_), .. }), .. }
+	)
+}
+
+fn is_not_confirming<T: Config<I>, I: 'static>(index: ReferendumIndex) -> bool {
+	let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+	matches!(
+		status,
+		ReferendumStatus { deciding: Some(DecidingStatus { confirming: None, .. }), .. }
+	)
+}
+
+benchmarks_instance_pallet! {
+	submit {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		if let Ok(caller) = frame_system::ensure_signed(origin.clone()) {
+			T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+			whitelist_account!(caller);
+		}
+	}: _<T::RuntimeOrigin>(
+		origin,
+		Box::new(RawOrigin::Root.into()),
+		dummy_call::<T, I>(),
+		DispatchTime::After(0u32.into())
+	) verify {
+		let index = ReferendumCount::<T, I>::get().checked_sub(1).unwrap();
+		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Ongoing(_)));
+	}
+
+	place_decision_deposit_preparing {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		let index = create_referendum::<T, I>(origin.clone());
+	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
+	verify {
+		assert!(Referenda::<T, I>::ensure_ongoing(index).unwrap().decision_deposit.is_some());
+	}
+
+	place_decision_deposit_queued {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		let index = create_referendum::<T, I>(origin.clone());
+		fill_queue::<T, I>(origin.clone(), index, 1, 90);
+	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
+	verify {
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		assert!(TrackQueue::<T, I>::get(&track).contains(&(index, 0u32.into())));
+	}
+
+	place_decision_deposit_not_queued {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		let index = create_referendum::<T, I>(origin.clone());
+		fill_queue::<T, I>(origin.clone(), index, 0, 90);
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
+	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
+	verify {
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
+	}
+
+	place_decision_deposit_passing {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		let index = create_referendum::<T, I>(origin.clone());
+		skip_prepare_period::<T, I>(index);
+		make_passing::<T, I>(index);
+	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
+	verify {
+		assert!(is_confirming::<T, I>(index));
+	}
+
+	place_decision_deposit_failing {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		let index = create_referendum::<T, I>(origin.clone());
+		skip_prepare_period::<T, I>(index);
+	}: place_decision_deposit<T::RuntimeOrigin>(origin, index)
+	verify {
+		assert!(is_not_confirming::<T, I>(index));
+	}
+
+	refund_decision_deposit {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		let index = create_referendum::<T, I>(origin.clone());
+		place_deposit::<T, I>(index);
+		assert_ok!(Referenda::<T, I>::cancel(
+			T::CancelOrigin::try_successful_origin()
+				.expect("CancelOrigin has no successful origin required for the benchmark"),
+			index,
+		));
+	}: _<T::RuntimeOrigin>(origin, index)
+	verify {
+		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(_, _, None)));
+	}
+
+	refund_submission_deposit {
+		let origin =
+			T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into()).map_err(|_| BenchmarkError::Weightless)?;
+		let index = create_referendum::<T, I>(origin.clone());
+		let caller = frame_system::ensure_signed(origin.clone()).unwrap();
+		let balance = T::Currency::free_balance(&caller);
+		assert_ok!(Referenda::<T, I>::cancel(
+			T::CancelOrigin::try_successful_origin()
+				.expect("CancelOrigin has no successful origin required for the benchmark"),
+			index,
+		));
+		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(_, Some(_), _)));
+	}: _<T::RuntimeOrigin>(origin, index)
+	verify {
+		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(_, None, _)));
+		let new_balance = T::Currency::free_balance(&caller);
+		// the deposit is zero or make sure it was unreserved.
+		assert!(T::SubmissionDeposit::get().is_zero() || new_balance > balance);
+	}
+
+	cancel {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+	}: _<T::RuntimeOrigin>(
+		T::CancelOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		index
+	) verify {
+		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Cancelled(..)));
+	}
+
+	kill {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+	}: _<T::RuntimeOrigin>(
+		T::KillOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?,
+		index
+	) verify {
+		assert_matches!(ReferendumInfoFor::<T, I>::get(index), Some(ReferendumInfo::Killed(..)));
+	}
+
+	one_fewer_deciding_queue_empty {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+		nudge::<T, I>(index);
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_ok!(Referenda::<T, I>::cancel(
+			T::CancelOrigin::try_successful_origin()
+				.expect("CancelOrigin has no successful origin required for the benchmark"),
+			index,
+		));
+		assert_eq!(DecidingCount::<T, I>::get(&track), 1);
+	}: one_fewer_deciding(RawOrigin::Root, track)
+	verify {
+		assert_eq!(DecidingCount::<T, I>::get(&track), 0);
+	}
+
+	one_fewer_deciding_failing {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin.clone());
+		// No spaces free in the queue.
+		let queued = fill_queue::<T, I>(origin, index, 0, 90);
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_ok!(Referenda::<T, I>::cancel(
+			T::CancelOrigin::try_successful_origin()
+				.expect("CancelOrigin has no successful origin required for the benchmark"),
+			queued[0],
+		));
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		let deciding_count = DecidingCount::<T, I>::get(&track);
+	}: one_fewer_deciding(RawOrigin::Root, track)
+	verify {
+		assert_eq!(DecidingCount::<T, I>::get(&track), deciding_count);
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
+		assert!(queued.into_iter().skip(1).all(|i| Referenda::<T, I>::ensure_ongoing(i)
+			.unwrap()
+			.deciding
+			.map_or(true, |d| d.confirming.is_none())
+		));
+	}
+
+	one_fewer_deciding_passing {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin.clone());
+		// No spaces free in the queue.
+		let queued = fill_queue::<T, I>(origin, index, 0, 0);
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_ok!(Referenda::<T, I>::cancel(
+			T::CancelOrigin::try_successful_origin()
+				.expect("CancelOrigin has no successful origin required for the benchmark"),
+			queued[0],
+		));
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		let deciding_count = DecidingCount::<T, I>::get(&track);
+	}: one_fewer_deciding(RawOrigin::Root, track)
+	verify {
+		assert_eq!(DecidingCount::<T, I>::get(&track), deciding_count);
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
+		assert!(queued.into_iter().skip(1).filter(|i| Referenda::<T, I>::ensure_ongoing(*i)
+			.unwrap()
+			.deciding
+			.map_or(false, |d| d.confirming.is_some())
+		).count() == 1);
+	}
+
+	nudge_referendum_requeued_insertion {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		// First create our referendum and place the deposit. It will be failing.
+		let index = create_referendum::<T, I>(origin.clone());
+		place_deposit::<T, I>(index);
+		fill_queue::<T, I>(origin, index, 0, 90);
+
+		// Now nudge ours, with the track now full and the queue full of referenda with votes,
+		// ours will not be in the queue.
+		nudge::<T, I>(index);
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
+
+		// Now alter the voting, so that ours goes into pole-position and shifts others down.
+		make_passing::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		let t = TrackQueue::<T, I>::get(&track);
+		assert_eq!(t.len() as u32, T::MaxQueued::get());
+		assert_eq!(t[t.len() - 1].0, index);
+	}
+
+	nudge_referendum_requeued_slide {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		// First create our referendum and place the deposit. It will be failing.
+		let index = create_referendum::<T, I>(origin.clone());
+		place_deposit::<T, I>(index);
+		fill_queue::<T, I>(origin, index, 1, 90);
+
+		// Now nudge ours, with the track now full, ours will be queued, but with no votes, it
+		// will have the worst position.
+		nudge::<T, I>(index);
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		assert_eq!(TrackQueue::<T, I>::get(&track)[0], (index, 0u32.into()));
+
+		// Now alter the voting, so that ours leap-frogs all into the best position.
+		make_passing::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		let t = TrackQueue::<T, I>::get(&track);
+		assert_eq!(t.len() as u32, T::MaxQueued::get());
+		assert_eq!(t[t.len() - 1].0, index);
+	}
+
+	nudge_referendum_queued {
+		// NOTE: worst possible queue situation is with a queue full of passing refs with one slot
+		// free and this failing. It would result in `QUEUE_SIZE - 1` items being shifted for the
+		// insertion at the beginning.
+
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		// First create our referendum and place the deposit. It will be failing.
+		let index = create_referendum::<T, I>(origin.clone());
+		place_deposit::<T, I>(index);
+		fill_queue::<T, I>(origin, index, 1, 0);
+
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get() - 1);
+		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
+
+		// Then nudge ours, with the track now full, ours will be queued.
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		assert_eq!(TrackQueue::<T, I>::get(&track)[0], (index, 0u32.into()));
+	}
+
+	nudge_referendum_not_queued {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		// First create our referendum and place the deposit. It will be failing.
+		let index = create_referendum::<T, I>(origin.clone());
+		place_deposit::<T, I>(index);
+		fill_queue::<T, I>(origin, index, 0, 0);
+
+		let track = Referenda::<T, I>::ensure_ongoing(index).unwrap().track;
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(_, v)| v > 0u32.into()));
+
+		// Then nudge ours, with the track now full, ours will be queued.
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert_eq!(TrackQueue::<T, I>::get(&track).len() as u32, T::MaxQueued::get());
+		assert!(TrackQueue::<T, I>::get(&track).into_iter().all(|(i, _)| i != index));
+	}
+
+	nudge_referendum_no_deposit {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		skip_prepare_period::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+		assert_matches!(status, ReferendumStatus { deciding: None, .. });
+	}
+
+	nudge_referendum_preparing {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		let status = Referenda::<T, I>::ensure_ongoing(index).unwrap();
+		assert_matches!(status, ReferendumStatus { deciding: None, .. });
+	}
+
+	nudge_referendum_timed_out {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		skip_timeout_period::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
+		assert_matches!(info, ReferendumInfo::TimedOut(..));
+	}
+
+	nudge_referendum_begin_deciding_failing {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert!(is_not_confirming::<T, I>(index));
+	}
+
+	nudge_referendum_begin_deciding_passing {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		make_passing::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert!(is_confirming::<T, I>(index));
+	}
+
+	nudge_referendum_begin_confirming {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+		nudge::<T, I>(index);
+		assert!(!is_confirming::<T, I>(index));
+		make_passing::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert!(is_confirming::<T, I>(index));
+	}
+
+	nudge_referendum_end_confirming {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+		make_passing::<T, I>(index);
+		nudge::<T, I>(index);
+		assert!(is_confirming::<T, I>(index));
+		make_failing::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert!(!is_confirming::<T, I>(index));
+	}
+
+	nudge_referendum_continue_not_confirming {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+		nudge::<T, I>(index);
+		assert!(!is_confirming::<T, I>(index));
+		let old_alarm = alarm_time::<T, I>(index);
+		make_passing_after::<T, I>(index, Perbill::from_percent(50));
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert_ne!(old_alarm, alarm_time::<T, I>(index));
+		assert!(!is_confirming::<T, I>(index));
+	}
+
+	nudge_referendum_continue_confirming {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		make_passing::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+		nudge::<T, I>(index);
+		assert!(is_confirming::<T, I>(index));
+		let old_alarm = alarm_time::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		assert!(is_confirming::<T, I>(index));
+	}
+
+	nudge_referendum_approved {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+		make_passing::<T, I>(index);
+		nudge::<T, I>(index);
+		skip_confirm_period::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
+		assert_matches!(info, ReferendumInfo::Approved(..));
+	}
+
+	nudge_referendum_rejected {
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin);
+		place_deposit::<T, I>(index);
+		skip_prepare_period::<T, I>(index);
+		make_failing::<T, I>(index);
+		nudge::<T, I>(index);
+		skip_decision_period::<T, I>(index);
+	}: nudge_referendum(RawOrigin::Root, index)
+	verify {
+		let info = ReferendumInfoFor::<T, I>::get(index).unwrap();
+		assert_matches!(info, ReferendumInfo::Rejected(..));
+	}
+
+	set_some_metadata {
+		use sp_std::borrow::Cow;
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin.clone());
+		let hash = T::Preimages::note(Cow::from(vec![5, 6])).unwrap();
+	}: set_metadata<T::RuntimeOrigin>(origin, index, Some(hash))
+	verify {
+		assert_last_event::<T, I>(Event::MetadataSet { index, hash }.into());
+	}
+
+	clear_metadata {
+		use sp_std::borrow::Cow;
+		let origin = T::SubmitOrigin::try_successful_origin(&RawOrigin::Root.into())
+			.expect("SubmitOrigin has no successful origin required for the benchmark");
+		let index = create_referendum::<T, I>(origin.clone());
+		let hash = T::Preimages::note(Cow::from(vec![6, 7, 8])).unwrap();
+		assert_ok!(
+			Referenda::<T, I>::set_metadata(origin.clone(), index, Some(hash))
+		);
+	}: set_metadata<T::RuntimeOrigin>(origin, index, None)
+	verify {
+		assert_last_event::<T, I>(Event::MetadataCleared { index, hash }.into());
+	}
+
+	impl_benchmark_test_suite!(
+		Referenda,
+		crate::mock::ExtBuilder::default().build(),
+		crate::mock::Test
+	);
+}
diff --git a/substrate/frame/referenda/src/branch.rs b/substrate/frame/referenda/src/branch.rs
new file mode 100644
index 0000000000000000000000000000000000000000..499e62387831727e874a4bf8976d933dd37188eb
--- /dev/null
+++ b/substrate/frame/referenda/src/branch.rs
@@ -0,0 +1,180 @@
+// 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.
+
+//! Helpers for managing the different weights in various algorithmic branches.
+
+use super::Config;
+use crate::weights::WeightInfo;
+use frame_support::weights::Weight;
+
+/// Branches within the `begin_deciding` function.
+pub enum BeginDecidingBranch {
+	Passing,
+	Failing,
+}
+
+/// Branches within the `service_referendum` function.
+pub enum ServiceBranch {
+	Fail,
+	NoDeposit,
+	Preparing,
+	Queued,
+	NotQueued,
+	RequeuedInsertion,
+	RequeuedSlide,
+	BeginDecidingPassing,
+	BeginDecidingFailing,
+	BeginConfirming,
+	ContinueConfirming,
+	EndConfirming,
+	ContinueNotConfirming,
+	Approved,
+	Rejected,
+	TimedOut,
+}
+
+impl From<BeginDecidingBranch> for ServiceBranch {
+	fn from(x: BeginDecidingBranch) -> Self {
+		use BeginDecidingBranch::*;
+		use ServiceBranch::*;
+		match x {
+			Passing => BeginDecidingPassing,
+			Failing => BeginDecidingFailing,
+		}
+	}
+}
+
+impl ServiceBranch {
+	/// Return the weight of the `nudge` function when it takes the branch denoted by `self`.
+	pub fn weight_of_nudge<T: Config<I>, I: 'static>(self) -> frame_support::weights::Weight {
+		use ServiceBranch::*;
+		match self {
+			NoDeposit => T::WeightInfo::nudge_referendum_no_deposit(),
+			Preparing => T::WeightInfo::nudge_referendum_preparing(),
+			Queued => T::WeightInfo::nudge_referendum_queued(),
+			NotQueued => T::WeightInfo::nudge_referendum_not_queued(),
+			RequeuedInsertion => T::WeightInfo::nudge_referendum_requeued_insertion(),
+			RequeuedSlide => T::WeightInfo::nudge_referendum_requeued_slide(),
+			BeginDecidingPassing => T::WeightInfo::nudge_referendum_begin_deciding_passing(),
+			BeginDecidingFailing => T::WeightInfo::nudge_referendum_begin_deciding_failing(),
+			BeginConfirming => T::WeightInfo::nudge_referendum_begin_confirming(),
+			ContinueConfirming => T::WeightInfo::nudge_referendum_continue_confirming(),
+			EndConfirming => T::WeightInfo::nudge_referendum_end_confirming(),
+			ContinueNotConfirming => T::WeightInfo::nudge_referendum_continue_not_confirming(),
+			Approved => T::WeightInfo::nudge_referendum_approved(),
+			Rejected => T::WeightInfo::nudge_referendum_rejected(),
+			TimedOut | Fail => T::WeightInfo::nudge_referendum_timed_out(),
+		}
+	}
+
+	/// Return the maximum possible weight of the `nudge` function.
+	pub fn max_weight_of_nudge<T: Config<I>, I: 'static>() -> frame_support::weights::Weight {
+		Weight::zero()
+			.max(T::WeightInfo::nudge_referendum_no_deposit())
+			.max(T::WeightInfo::nudge_referendum_preparing())
+			.max(T::WeightInfo::nudge_referendum_queued())
+			.max(T::WeightInfo::nudge_referendum_not_queued())
+			.max(T::WeightInfo::nudge_referendum_requeued_insertion())
+			.max(T::WeightInfo::nudge_referendum_requeued_slide())
+			.max(T::WeightInfo::nudge_referendum_begin_deciding_passing())
+			.max(T::WeightInfo::nudge_referendum_begin_deciding_failing())
+			.max(T::WeightInfo::nudge_referendum_begin_confirming())
+			.max(T::WeightInfo::nudge_referendum_continue_confirming())
+			.max(T::WeightInfo::nudge_referendum_end_confirming())
+			.max(T::WeightInfo::nudge_referendum_continue_not_confirming())
+			.max(T::WeightInfo::nudge_referendum_approved())
+			.max(T::WeightInfo::nudge_referendum_rejected())
+			.max(T::WeightInfo::nudge_referendum_timed_out())
+	}
+
+	/// Return the weight of the `place_decision_deposit` function when it takes the branch denoted
+	/// by `self`.
+	pub fn weight_of_deposit<T: Config<I>, I: 'static>(
+		self,
+	) -> Option<frame_support::weights::Weight> {
+		use ServiceBranch::*;
+		let ref_time_weight = match self {
+			Preparing => T::WeightInfo::place_decision_deposit_preparing(),
+			Queued => T::WeightInfo::place_decision_deposit_queued(),
+			NotQueued => T::WeightInfo::place_decision_deposit_not_queued(),
+			BeginDecidingPassing => T::WeightInfo::place_decision_deposit_passing(),
+			BeginDecidingFailing => T::WeightInfo::place_decision_deposit_failing(),
+			BeginConfirming |
+			ContinueConfirming |
+			EndConfirming |
+			ContinueNotConfirming |
+			Approved |
+			Rejected |
+			RequeuedInsertion |
+			RequeuedSlide |
+			TimedOut |
+			Fail |
+			NoDeposit => return None,
+		};
+
+		Some(ref_time_weight)
+	}
+
+	/// Return the maximum possible weight of the `place_decision_deposit` function.
+	pub fn max_weight_of_deposit<T: Config<I>, I: 'static>() -> frame_support::weights::Weight {
+		Weight::zero()
+			.max(T::WeightInfo::place_decision_deposit_preparing())
+			.max(T::WeightInfo::place_decision_deposit_queued())
+			.max(T::WeightInfo::place_decision_deposit_not_queued())
+			.max(T::WeightInfo::place_decision_deposit_passing())
+			.max(T::WeightInfo::place_decision_deposit_failing())
+	}
+}
+
+/// Branches that the `one_fewer_deciding` function may take.
+pub enum OneFewerDecidingBranch {
+	QueueEmpty,
+	BeginDecidingPassing,
+	BeginDecidingFailing,
+}
+
+impl From<BeginDecidingBranch> for OneFewerDecidingBranch {
+	fn from(x: BeginDecidingBranch) -> Self {
+		use BeginDecidingBranch::*;
+		use OneFewerDecidingBranch::*;
+		match x {
+			Passing => BeginDecidingPassing,
+			Failing => BeginDecidingFailing,
+		}
+	}
+}
+
+impl OneFewerDecidingBranch {
+	/// Return the weight of the `one_fewer_deciding` function when it takes the branch denoted
+	/// by `self`.
+	pub fn weight<T: Config<I>, I: 'static>(self) -> frame_support::weights::Weight {
+		use OneFewerDecidingBranch::*;
+		match self {
+			QueueEmpty => T::WeightInfo::one_fewer_deciding_queue_empty(),
+			BeginDecidingPassing => T::WeightInfo::one_fewer_deciding_passing(),
+			BeginDecidingFailing => T::WeightInfo::one_fewer_deciding_failing(),
+		}
+	}
+
+	/// Return the maximum possible weight of the `one_fewer_deciding` function.
+	pub fn max_weight<T: Config<I>, I: 'static>() -> frame_support::weights::Weight {
+		Weight::zero()
+			.max(T::WeightInfo::one_fewer_deciding_queue_empty())
+			.max(T::WeightInfo::one_fewer_deciding_passing())
+			.max(T::WeightInfo::one_fewer_deciding_failing())
+	}
+}
diff --git a/substrate/frame/referenda/src/lib.rs b/substrate/frame/referenda/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d4dbbf8a3c998e845165fb7a3d2fa7132c1824d4
--- /dev/null
+++ b/substrate/frame/referenda/src/lib.rs
@@ -0,0 +1,1380 @@
+// 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.
+
+//! # Referenda Pallet
+//!
+//! ## Overview
+//!
+//! A pallet for executing referenda. No voting logic is present here, and the `Polling` and
+//! `PollStatus` traits are used to allow the voting logic (likely in a pallet) to be utilized.
+//!
+//! A referendum is a vote on whether a proposal should be dispatched from a particular origin. The
+//! origin is used to determine which one of several _tracks_ that a referendum happens under.
+//! Tracks each have their own configuration which governs the voting process and parameters.
+//!
+//! A referendum's lifecycle has three main stages: Preparation, deciding and conclusion.
+//! Referenda are considered "ongoing" immediately after submission until their eventual
+//! conclusion, and votes may be cast throughout.
+//!
+//! In order to progress from preparating to being decided, three things must be in place:
+//! - There must have been a *Decision Deposit* placed, an amount determined by the track. Anyone
+//! may place this deposit.
+//! - A period must have elapsed since submission of the referendum. This period is known as the
+//! *Preparation Period* and is determined by the track.
+//! - The track must not already be at capacity with referendum being decided. The maximum number of
+//! referenda which may be being decided simultaneously is determined by the track.
+//!
+//! In order to become concluded, one of three things must happen:
+//! - The referendum should remain in an unbroken _Passing_ state for a period of time. This
+//! is known as the _Confirmation Period_ and is determined by the track. A referendum is considered
+//! _Passing_ when there is a sufficiently high support and approval, given the amount of time it
+//! has been being decided. Generally the threshold for what counts as being "sufficiently high"
+//! will reduce over time. The curves setting these thresholds are determined by the track. In this
+//! case, the referendum is considered _Approved_ and the proposal is scheduled for dispatch.
+//! - The referendum reaches the end of its deciding phase outside not _Passing_. It ends in
+//! rejection and the proposal is not dispatched.
+//! - The referendum is cancelled.
+//!
+//! A general time-out is also in place and referenda which exist in preparation for too long may
+//! conclude without ever entering into a deciding stage.
+//!
+//! Once a referendum is concluded, the decision deposit may be refunded.
+//!
+//! ## Terms
+//! - *Support*: The number of aye-votes, pre-conviction, as a proportion of the total number of
+//!   pre-conviction votes able to be cast in the population.
+//!
+//! - [`Config`]
+//! - [`Call`]
+
+#![recursion_limit = "256"]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Codec, Encode};
+use frame_support::{
+	dispatch::DispatchResult,
+	ensure,
+	traits::{
+		schedule::{
+			v3::{Anon as ScheduleAnon, Named as ScheduleNamed},
+			DispatchTime,
+		},
+		Currency, Hash as PreimageHash, LockIdentifier, OnUnbalanced, OriginTrait, PollStatus,
+		Polling, QueryPreimage, ReservableCurrency, StorePreimage, VoteTally,
+	},
+	BoundedVec,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{AtLeast32BitUnsigned, Bounded, Dispatchable, One, Saturating, Zero},
+	DispatchError, Perbill,
+};
+use sp_std::{fmt::Debug, prelude::*};
+
+mod branch;
+pub mod migration;
+mod types;
+pub mod weights;
+
+use self::branch::{BeginDecidingBranch, OneFewerDecidingBranch, ServiceBranch};
+pub use self::{
+	pallet::*,
+	types::{
+		BalanceOf, BoundedCallOf, CallOf, Curve, DecidingStatus, DecidingStatusOf, Deposit,
+		InsertSorted, NegativeImbalanceOf, PalletsOriginOf, ReferendumIndex, ReferendumInfo,
+		ReferendumInfoOf, ReferendumStatus, ReferendumStatusOf, ScheduleAddressOf, TallyOf,
+		TrackIdOf, TrackInfo, TrackInfoOf, TracksInfo, VotesOf,
+	},
+	weights::WeightInfo,
+};
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+
+pub use frame_support::traits::Get;
+pub use sp_std::vec::Vec;
+
+#[macro_export]
+macro_rules! impl_tracksinfo_get {
+	($tracksinfo:ty, $balance:ty, $blocknumber:ty) => {
+		impl
+			$crate::Get<
+				$crate::Vec<(
+					<$tracksinfo as $crate::TracksInfo<$balance, $blocknumber>>::Id,
+					$crate::TrackInfo<$balance, $blocknumber>,
+				)>,
+			> for $tracksinfo
+		{
+			fn get() -> $crate::Vec<(
+				<$tracksinfo as $crate::TracksInfo<$balance, $blocknumber>>::Id,
+				$crate::TrackInfo<$balance, $blocknumber>,
+			)> {
+				<$tracksinfo as $crate::TracksInfo<$balance, $blocknumber>>::tracks().to_vec()
+			}
+		}
+	};
+}
+
+const ASSEMBLY_ID: LockIdentifier = *b"assembly";
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{pallet_prelude::*, traits::EnsureOriginWithArg};
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config + Sized {
+		// System level stuff.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ From<Call<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>
+			+ From<frame_system::Call<Self>>;
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+		/// The Scheduler.
+		type Scheduler: ScheduleAnon<BlockNumberFor<Self>, CallOf<Self, I>, PalletsOriginOf<Self>>
+			+ ScheduleNamed<BlockNumberFor<Self>, CallOf<Self, I>, PalletsOriginOf<Self>>;
+		/// Currency type for this pallet.
+		type Currency: ReservableCurrency<Self::AccountId>;
+		// Origins and unbalances.
+		/// Origin from which proposals may be submitted.
+		type SubmitOrigin: EnsureOriginWithArg<
+			Self::RuntimeOrigin,
+			PalletsOriginOf<Self>,
+			Success = Self::AccountId,
+		>;
+		/// Origin from which any vote may be cancelled.
+		type CancelOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		/// Origin from which any vote may be killed.
+		type KillOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		/// Handler for the unbalanced reduction when slashing a preimage deposit.
+		type Slash: OnUnbalanced<NegativeImbalanceOf<Self, I>>;
+		/// The counting type for votes. Usually just balance.
+		type Votes: AtLeast32BitUnsigned + Copy + Parameter + Member + MaxEncodedLen;
+		/// The tallying type.
+		type Tally: VoteTally<Self::Votes, TrackIdOf<Self, I>>
+			+ Clone
+			+ Codec
+			+ Eq
+			+ Debug
+			+ TypeInfo
+			+ MaxEncodedLen;
+
+		// Constants
+		/// The minimum amount to be used as a deposit for a public referendum proposal.
+		#[pallet::constant]
+		type SubmissionDeposit: Get<BalanceOf<Self, I>>;
+
+		/// Maximum size of the referendum queue for a single track.
+		#[pallet::constant]
+		type MaxQueued: Get<u32>;
+
+		/// The number of blocks after submission that a referendum must begin being decided by.
+		/// Once this passes, then anyone may cancel the referendum.
+		#[pallet::constant]
+		type UndecidingTimeout: Get<BlockNumberFor<Self>>;
+
+		/// Quantization level for the referendum wakeup scheduler. A higher number will result in
+		/// fewer storage reads/writes needed for smaller voters, but also result in delays to the
+		/// automatic referendum status changes. Explicit servicing instructions are unaffected.
+		#[pallet::constant]
+		type AlarmInterval: Get<BlockNumberFor<Self>>;
+
+		// The other stuff.
+		/// Information concerning the different referendum tracks.
+		#[pallet::constant]
+		type Tracks: Get<
+				Vec<(
+					<Self::Tracks as TracksInfo<BalanceOf<Self, I>, BlockNumberFor<Self>>>::Id,
+					TrackInfo<BalanceOf<Self, I>, BlockNumberFor<Self>>,
+				)>,
+			> + TracksInfo<
+				BalanceOf<Self, I>,
+				BlockNumberFor<Self>,
+				RuntimeOrigin = <Self::RuntimeOrigin as OriginTrait>::PalletsOrigin,
+			>;
+
+		/// The preimage provider.
+		type Preimages: QueryPreimage + StorePreimage;
+	}
+
+	/// The next free referendum index, aka the number of referenda started so far.
+	#[pallet::storage]
+	pub type ReferendumCount<T, I = ()> = StorageValue<_, ReferendumIndex, ValueQuery>;
+
+	/// Information concerning any given referendum.
+	#[pallet::storage]
+	pub type ReferendumInfoFor<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, ReferendumIndex, ReferendumInfoOf<T, I>>;
+
+	/// The sorted list of referenda ready to be decided but not yet being decided, ordered by
+	/// conviction-weighted approvals.
+	///
+	/// This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.
+	#[pallet::storage]
+	pub type TrackQueue<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Twox64Concat,
+		TrackIdOf<T, I>,
+		BoundedVec<(ReferendumIndex, T::Votes), T::MaxQueued>,
+		ValueQuery,
+	>;
+
+	/// The number of referenda being decided currently.
+	#[pallet::storage]
+	pub type DecidingCount<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, TrackIdOf<T, I>, u32, ValueQuery>;
+
+	/// The metadata is a general information concerning the referendum.
+	/// The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON
+	/// dump or IPFS hash of a JSON file.
+	///
+	/// Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
+	/// large preimages.
+	#[pallet::storage]
+	pub type MetadataOf<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, ReferendumIndex, PreimageHash>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A referendum has been submitted.
+		Submitted {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The track (and by extension proposal dispatch origin) of this referendum.
+			track: TrackIdOf<T, I>,
+			/// The proposal for the referendum.
+			proposal: BoundedCallOf<T, I>,
+		},
+		/// The decision deposit has been placed.
+		DecisionDepositPlaced {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The account who placed the deposit.
+			who: T::AccountId,
+			/// The amount placed by the account.
+			amount: BalanceOf<T, I>,
+		},
+		/// The decision deposit has been refunded.
+		DecisionDepositRefunded {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The account who placed the deposit.
+			who: T::AccountId,
+			/// The amount placed by the account.
+			amount: BalanceOf<T, I>,
+		},
+		/// A deposit has been slashaed.
+		DepositSlashed {
+			/// The account who placed the deposit.
+			who: T::AccountId,
+			/// The amount placed by the account.
+			amount: BalanceOf<T, I>,
+		},
+		/// A referendum has moved into the deciding phase.
+		DecisionStarted {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The track (and by extension proposal dispatch origin) of this referendum.
+			track: TrackIdOf<T, I>,
+			/// The proposal for the referendum.
+			proposal: BoundedCallOf<T, I>,
+			/// The current tally of votes in this referendum.
+			tally: T::Tally,
+		},
+		ConfirmStarted {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+		},
+		ConfirmAborted {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+		},
+		/// A referendum has ended its confirmation phase and is ready for approval.
+		Confirmed {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The final tally of votes in this referendum.
+			tally: T::Tally,
+		},
+		/// A referendum has been approved and its proposal has been scheduled.
+		Approved {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+		},
+		/// A proposal has been rejected by referendum.
+		Rejected {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The final tally of votes in this referendum.
+			tally: T::Tally,
+		},
+		/// A referendum has been timed out without being decided.
+		TimedOut {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The final tally of votes in this referendum.
+			tally: T::Tally,
+		},
+		/// A referendum has been cancelled.
+		Cancelled {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The final tally of votes in this referendum.
+			tally: T::Tally,
+		},
+		/// A referendum has been killed.
+		Killed {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The final tally of votes in this referendum.
+			tally: T::Tally,
+		},
+		/// The submission deposit has been refunded.
+		SubmissionDepositRefunded {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// The account who placed the deposit.
+			who: T::AccountId,
+			/// The amount placed by the account.
+			amount: BalanceOf<T, I>,
+		},
+		/// Metadata for a referendum has been set.
+		MetadataSet {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// Preimage hash.
+			hash: PreimageHash,
+		},
+		/// Metadata for a referendum has been cleared.
+		MetadataCleared {
+			/// Index of the referendum.
+			index: ReferendumIndex,
+			/// Preimage hash.
+			hash: PreimageHash,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Referendum is not ongoing.
+		NotOngoing,
+		/// Referendum's decision deposit is already paid.
+		HasDeposit,
+		/// The track identifier given was invalid.
+		BadTrack,
+		/// There are already a full complement of referenda in progress for this track.
+		Full,
+		/// The queue of the track is empty.
+		QueueEmpty,
+		/// The referendum index provided is invalid in this context.
+		BadReferendum,
+		/// There was nothing to do in the advancement.
+		NothingToDo,
+		/// No track exists for the proposal origin.
+		NoTrack,
+		/// Any deposit cannot be refunded until after the decision is over.
+		Unfinished,
+		/// The deposit refunder is not the depositor.
+		NoPermission,
+		/// The deposit cannot be refunded since none was made.
+		NoDeposit,
+		/// The referendum status is invalid for this operation.
+		BadStatus,
+		/// The preimage does not exist.
+		PreimageNotExist,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		#[cfg(feature = "try-runtime")]
+		fn try_state(_n: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
+			Self::do_try_state()?;
+			Ok(())
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Propose a referendum on a privileged action.
+		///
+		/// - `origin`: must be `SubmitOrigin` and the account must have `SubmissionDeposit` funds
+		///   available.
+		/// - `proposal_origin`: The origin from which the proposal should be executed.
+		/// - `proposal`: The proposal.
+		/// - `enactment_moment`: The moment that the proposal should be enacted.
+		///
+		/// Emits `Submitted`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::submit())]
+		pub fn submit(
+			origin: OriginFor<T>,
+			proposal_origin: Box<PalletsOriginOf<T>>,
+			proposal: BoundedCallOf<T, I>,
+			enactment_moment: DispatchTime<BlockNumberFor<T>>,
+		) -> DispatchResult {
+			let proposal_origin = *proposal_origin;
+			let who = T::SubmitOrigin::ensure_origin(origin, &proposal_origin)?;
+
+			let track =
+				T::Tracks::track_for(&proposal_origin).map_err(|_| Error::<T, I>::NoTrack)?;
+			let submission_deposit = Self::take_deposit(who, T::SubmissionDeposit::get())?;
+			let index = ReferendumCount::<T, I>::mutate(|x| {
+				let r = *x;
+				*x += 1;
+				r
+			});
+			let now = frame_system::Pallet::<T>::block_number();
+			let nudge_call =
+				T::Preimages::bound(CallOf::<T, I>::from(Call::nudge_referendum { index }))?;
+			let status = ReferendumStatus {
+				track,
+				origin: proposal_origin,
+				proposal: proposal.clone(),
+				enactment: enactment_moment,
+				submitted: now,
+				submission_deposit,
+				decision_deposit: None,
+				deciding: None,
+				tally: TallyOf::<T, I>::new(track),
+				in_queue: false,
+				alarm: Self::set_alarm(nudge_call, now.saturating_add(T::UndecidingTimeout::get())),
+			};
+			ReferendumInfoFor::<T, I>::insert(index, ReferendumInfo::Ongoing(status));
+
+			Self::deposit_event(Event::<T, I>::Submitted { index, track, proposal });
+			Ok(())
+		}
+
+		/// Post the Decision Deposit for a referendum.
+		///
+		/// - `origin`: must be `Signed` and the account must have funds available for the
+		///   referendum's track's Decision Deposit.
+		/// - `index`: The index of the submitted referendum whose Decision Deposit is yet to be
+		///   posted.
+		///
+		/// Emits `DecisionDepositPlaced`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(ServiceBranch::max_weight_of_deposit::<T, I>())]
+		pub fn place_decision_deposit(
+			origin: OriginFor<T>,
+			index: ReferendumIndex,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let mut status = Self::ensure_ongoing(index)?;
+			ensure!(status.decision_deposit.is_none(), Error::<T, I>::HasDeposit);
+			let track = Self::track(status.track).ok_or(Error::<T, I>::NoTrack)?;
+			status.decision_deposit =
+				Some(Self::take_deposit(who.clone(), track.decision_deposit)?);
+			let now = frame_system::Pallet::<T>::block_number();
+			let (info, _, branch) = Self::service_referendum(now, index, status);
+			ReferendumInfoFor::<T, I>::insert(index, info);
+			let e =
+				Event::<T, I>::DecisionDepositPlaced { index, who, amount: track.decision_deposit };
+			Self::deposit_event(e);
+			Ok(branch.weight_of_deposit::<T, I>().into())
+		}
+
+		/// Refund the Decision Deposit for a closed referendum back to the depositor.
+		///
+		/// - `origin`: must be `Signed` or `Root`.
+		/// - `index`: The index of a closed referendum whose Decision Deposit has not yet been
+		///   refunded.
+		///
+		/// Emits `DecisionDepositRefunded`.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::refund_decision_deposit())]
+		pub fn refund_decision_deposit(
+			origin: OriginFor<T>,
+			index: ReferendumIndex,
+		) -> DispatchResult {
+			ensure_signed_or_root(origin)?;
+			let mut info =
+				ReferendumInfoFor::<T, I>::get(index).ok_or(Error::<T, I>::BadReferendum)?;
+			let deposit = info
+				.take_decision_deposit()
+				.map_err(|_| Error::<T, I>::Unfinished)?
+				.ok_or(Error::<T, I>::NoDeposit)?;
+			Self::refund_deposit(Some(deposit.clone()));
+			ReferendumInfoFor::<T, I>::insert(index, info);
+			let e = Event::<T, I>::DecisionDepositRefunded {
+				index,
+				who: deposit.who,
+				amount: deposit.amount,
+			};
+			Self::deposit_event(e);
+			Ok(())
+		}
+
+		/// Cancel an ongoing referendum.
+		///
+		/// - `origin`: must be the `CancelOrigin`.
+		/// - `index`: The index of the referendum to be cancelled.
+		///
+		/// Emits `Cancelled`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::cancel())]
+		pub fn cancel(origin: OriginFor<T>, index: ReferendumIndex) -> DispatchResult {
+			T::CancelOrigin::ensure_origin(origin)?;
+			let status = Self::ensure_ongoing(index)?;
+			if let Some((_, last_alarm)) = status.alarm {
+				let _ = T::Scheduler::cancel(last_alarm);
+			}
+			Self::note_one_fewer_deciding(status.track);
+			Self::deposit_event(Event::<T, I>::Cancelled { index, tally: status.tally });
+			let info = ReferendumInfo::Cancelled(
+				frame_system::Pallet::<T>::block_number(),
+				Some(status.submission_deposit),
+				status.decision_deposit,
+			);
+			ReferendumInfoFor::<T, I>::insert(index, info);
+			Ok(())
+		}
+
+		/// Cancel an ongoing referendum and slash the deposits.
+		///
+		/// - `origin`: must be the `KillOrigin`.
+		/// - `index`: The index of the referendum to be cancelled.
+		///
+		/// Emits `Killed` and `DepositSlashed`.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::kill())]
+		pub fn kill(origin: OriginFor<T>, index: ReferendumIndex) -> DispatchResult {
+			T::KillOrigin::ensure_origin(origin)?;
+			let status = Self::ensure_ongoing(index)?;
+			if let Some((_, last_alarm)) = status.alarm {
+				let _ = T::Scheduler::cancel(last_alarm);
+			}
+			Self::note_one_fewer_deciding(status.track);
+			Self::deposit_event(Event::<T, I>::Killed { index, tally: status.tally });
+			Self::slash_deposit(Some(status.submission_deposit.clone()));
+			Self::slash_deposit(status.decision_deposit.clone());
+			Self::do_clear_metadata(index);
+			let info = ReferendumInfo::Killed(frame_system::Pallet::<T>::block_number());
+			ReferendumInfoFor::<T, I>::insert(index, info);
+			Ok(())
+		}
+
+		/// Advance a referendum onto its next logical state. Only used internally.
+		///
+		/// - `origin`: must be `Root`.
+		/// - `index`: the referendum to be advanced.
+		#[pallet::call_index(5)]
+		#[pallet::weight(ServiceBranch::max_weight_of_nudge::<T, I>())]
+		pub fn nudge_referendum(
+			origin: OriginFor<T>,
+			index: ReferendumIndex,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			let now = frame_system::Pallet::<T>::block_number();
+			let mut status = Self::ensure_ongoing(index)?;
+			// This is our wake-up, so we can disregard the alarm.
+			status.alarm = None;
+			let (info, dirty, branch) = Self::service_referendum(now, index, status);
+			if dirty {
+				ReferendumInfoFor::<T, I>::insert(index, info);
+			}
+			Ok(Some(branch.weight_of_nudge::<T, I>()).into())
+		}
+
+		/// Advance a track onto its next logical state. Only used internally.
+		///
+		/// - `origin`: must be `Root`.
+		/// - `track`: the track to be advanced.
+		///
+		/// Action item for when there is now one fewer referendum in the deciding phase and the
+		/// `DecidingCount` is not yet updated. This means that we should either:
+		/// - begin deciding another referendum (and leave `DecidingCount` alone); or
+		/// - decrement `DecidingCount`.
+		#[pallet::call_index(6)]
+		#[pallet::weight(OneFewerDecidingBranch::max_weight::<T, I>())]
+		pub fn one_fewer_deciding(
+			origin: OriginFor<T>,
+			track: TrackIdOf<T, I>,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			let track_info = T::Tracks::info(track).ok_or(Error::<T, I>::BadTrack)?;
+			let mut track_queue = TrackQueue::<T, I>::get(track);
+			let branch =
+				if let Some((index, mut status)) = Self::next_for_deciding(&mut track_queue) {
+					let now = frame_system::Pallet::<T>::block_number();
+					let (maybe_alarm, branch) =
+						Self::begin_deciding(&mut status, index, now, track_info);
+					if let Some(set_alarm) = maybe_alarm {
+						Self::ensure_alarm_at(&mut status, index, set_alarm);
+					}
+					ReferendumInfoFor::<T, I>::insert(index, ReferendumInfo::Ongoing(status));
+					TrackQueue::<T, I>::insert(track, track_queue);
+					branch.into()
+				} else {
+					DecidingCount::<T, I>::mutate(track, |x| x.saturating_dec());
+					OneFewerDecidingBranch::QueueEmpty
+				};
+			Ok(Some(branch.weight::<T, I>()).into())
+		}
+
+		/// Refund the Submission Deposit for a closed referendum back to the depositor.
+		///
+		/// - `origin`: must be `Signed` or `Root`.
+		/// - `index`: The index of a closed referendum whose Submission Deposit has not yet been
+		///   refunded.
+		///
+		/// Emits `SubmissionDepositRefunded`.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::refund_submission_deposit())]
+		pub fn refund_submission_deposit(
+			origin: OriginFor<T>,
+			index: ReferendumIndex,
+		) -> DispatchResult {
+			ensure_signed_or_root(origin)?;
+			let mut info =
+				ReferendumInfoFor::<T, I>::get(index).ok_or(Error::<T, I>::BadReferendum)?;
+			let deposit = info
+				.take_submission_deposit()
+				.map_err(|_| Error::<T, I>::BadStatus)?
+				.ok_or(Error::<T, I>::NoDeposit)?;
+			Self::refund_deposit(Some(deposit.clone()));
+			ReferendumInfoFor::<T, I>::insert(index, info);
+			let e = Event::<T, I>::SubmissionDepositRefunded {
+				index,
+				who: deposit.who,
+				amount: deposit.amount,
+			};
+			Self::deposit_event(e);
+			Ok(())
+		}
+
+		/// Set or clear metadata of a referendum.
+		///
+		/// Parameters:
+		/// - `origin`: Must be `Signed` by a creator of a referendum or by anyone to clear a
+		///   metadata of a finished referendum.
+		/// - `index`:  The index of a referendum to set or clear metadata for.
+		/// - `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.
+		#[pallet::call_index(8)]
+		#[pallet::weight(
+			maybe_hash.map_or(
+				T::WeightInfo::clear_metadata(), |_| T::WeightInfo::set_some_metadata())
+			)]
+		pub fn set_metadata(
+			origin: OriginFor<T>,
+			index: ReferendumIndex,
+			maybe_hash: Option<PreimageHash>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			if let Some(hash) = maybe_hash {
+				let status = Self::ensure_ongoing(index)?;
+				ensure!(status.submission_deposit.who == who, Error::<T, I>::NoPermission);
+				ensure!(T::Preimages::len(&hash).is_some(), Error::<T, I>::PreimageNotExist);
+				MetadataOf::<T, I>::insert(index, hash);
+				Self::deposit_event(Event::<T, I>::MetadataSet { index, hash });
+				Ok(())
+			} else {
+				if let Some(status) = Self::ensure_ongoing(index).ok() {
+					ensure!(status.submission_deposit.who == who, Error::<T, I>::NoPermission);
+				}
+				Self::do_clear_metadata(index);
+				Ok(())
+			}
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Polling<T::Tally> for Pallet<T, I> {
+	type Index = ReferendumIndex;
+	type Votes = VotesOf<T, I>;
+	type Moment = BlockNumberFor<T>;
+	type Class = TrackIdOf<T, I>;
+
+	fn classes() -> Vec<Self::Class> {
+		T::Tracks::tracks().iter().map(|x| x.0).collect()
+	}
+
+	fn access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(PollStatus<&mut T::Tally, BlockNumberFor<T>, TrackIdOf<T, I>>) -> R,
+	) -> R {
+		match ReferendumInfoFor::<T, I>::get(index) {
+			Some(ReferendumInfo::Ongoing(mut status)) => {
+				let result = f(PollStatus::Ongoing(&mut status.tally, status.track));
+				let now = frame_system::Pallet::<T>::block_number();
+				Self::ensure_alarm_at(&mut status, index, now + One::one());
+				ReferendumInfoFor::<T, I>::insert(index, ReferendumInfo::Ongoing(status));
+				result
+			},
+			Some(ReferendumInfo::Approved(end, ..)) => f(PollStatus::Completed(end, true)),
+			Some(ReferendumInfo::Rejected(end, ..)) => f(PollStatus::Completed(end, false)),
+			_ => f(PollStatus::None),
+		}
+	}
+
+	fn try_access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(
+			PollStatus<&mut T::Tally, BlockNumberFor<T>, TrackIdOf<T, I>>,
+		) -> Result<R, DispatchError>,
+	) -> Result<R, DispatchError> {
+		match ReferendumInfoFor::<T, I>::get(index) {
+			Some(ReferendumInfo::Ongoing(mut status)) => {
+				let result = f(PollStatus::Ongoing(&mut status.tally, status.track))?;
+				let now = frame_system::Pallet::<T>::block_number();
+				Self::ensure_alarm_at(&mut status, index, now + One::one());
+				ReferendumInfoFor::<T, I>::insert(index, ReferendumInfo::Ongoing(status));
+				Ok(result)
+			},
+			Some(ReferendumInfo::Approved(end, ..)) => f(PollStatus::Completed(end, true)),
+			Some(ReferendumInfo::Rejected(end, ..)) => f(PollStatus::Completed(end, false)),
+			_ => f(PollStatus::None),
+		}
+	}
+
+	fn as_ongoing(index: Self::Index) -> Option<(T::Tally, TrackIdOf<T, I>)> {
+		Self::ensure_ongoing(index).ok().map(|x| (x.tally, x.track))
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn create_ongoing(class: Self::Class) -> Result<Self::Index, ()> {
+		let index = ReferendumCount::<T, I>::mutate(|x| {
+			let r = *x;
+			*x += 1;
+			r
+		});
+		let now = frame_system::Pallet::<T>::block_number();
+		let dummy_account_id =
+			codec::Decode::decode(&mut sp_runtime::traits::TrailingZeroInput::new(&b"dummy"[..]))
+				.expect("infinite length input; no invalid inputs for type; qed");
+		let mut status = ReferendumStatusOf::<T, I> {
+			track: class,
+			origin: frame_support::dispatch::RawOrigin::Root.into(),
+			proposal: T::Preimages::bound(CallOf::<T, I>::from(Call::nudge_referendum { index }))
+				.map_err(|_| ())?,
+			enactment: DispatchTime::After(Zero::zero()),
+			submitted: now,
+			submission_deposit: Deposit { who: dummy_account_id, amount: Zero::zero() },
+			decision_deposit: None,
+			deciding: None,
+			tally: TallyOf::<T, I>::new(class),
+			in_queue: false,
+			alarm: None,
+		};
+		Self::ensure_alarm_at(&mut status, index, sp_runtime::traits::Bounded::max_value());
+		ReferendumInfoFor::<T, I>::insert(index, ReferendumInfo::Ongoing(status));
+		Ok(index)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn end_ongoing(index: Self::Index, approved: bool) -> Result<(), ()> {
+		let mut status = Self::ensure_ongoing(index).map_err(|_| ())?;
+		Self::ensure_no_alarm(&mut status);
+		Self::note_one_fewer_deciding(status.track);
+		let now = frame_system::Pallet::<T>::block_number();
+		let info = if approved {
+			ReferendumInfo::Approved(now, Some(status.submission_deposit), status.decision_deposit)
+		} else {
+			ReferendumInfo::Rejected(now, Some(status.submission_deposit), status.decision_deposit)
+		};
+		ReferendumInfoFor::<T, I>::insert(index, info);
+		Ok(())
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn max_ongoing() -> (Self::Class, u32) {
+		let r = T::Tracks::tracks()
+			.iter()
+			.max_by_key(|(_, info)| info.max_deciding)
+			.expect("Always one class");
+		(r.0, r.1.max_deciding)
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Check that referendum `index` is in the `Ongoing` state and return the `ReferendumStatus`
+	/// value, or `Err` otherwise.
+	pub fn ensure_ongoing(
+		index: ReferendumIndex,
+	) -> Result<ReferendumStatusOf<T, I>, DispatchError> {
+		match ReferendumInfoFor::<T, I>::get(index) {
+			Some(ReferendumInfo::Ongoing(status)) => Ok(status),
+			_ => Err(Error::<T, I>::NotOngoing.into()),
+		}
+	}
+
+	/// Returns whether the referendum is passing.
+	/// Referendum must be ongoing and its track must exist.
+	pub fn is_referendum_passing(ref_index: ReferendumIndex) -> Result<bool, DispatchError> {
+		let info = ReferendumInfoFor::<T, I>::get(ref_index).ok_or(Error::<T, I>::BadReferendum)?;
+		match info {
+			ReferendumInfo::Ongoing(status) => {
+				let track = Self::track(status.track).ok_or(Error::<T, I>::NoTrack)?;
+				let elapsed = if let Some(deciding) = status.deciding {
+					frame_system::Pallet::<T>::block_number().saturating_sub(deciding.since)
+				} else {
+					Zero::zero()
+				};
+				Ok(Self::is_passing(
+					&status.tally,
+					elapsed,
+					track.decision_period,
+					&track.min_support,
+					&track.min_approval,
+					status.track,
+				))
+			},
+			_ => Err(Error::<T, I>::NotOngoing.into()),
+		}
+	}
+
+	// Enqueue a proposal from a referendum which has presumably passed.
+	fn schedule_enactment(
+		index: ReferendumIndex,
+		track: &TrackInfoOf<T, I>,
+		desired: DispatchTime<BlockNumberFor<T>>,
+		origin: PalletsOriginOf<T>,
+		call: BoundedCallOf<T, I>,
+	) {
+		let now = frame_system::Pallet::<T>::block_number();
+		let earliest_allowed = now.saturating_add(track.min_enactment_period);
+		let desired = desired.evaluate(now);
+		let ok = T::Scheduler::schedule_named(
+			(ASSEMBLY_ID, "enactment", index).using_encoded(sp_io::hashing::blake2_256),
+			DispatchTime::At(desired.max(earliest_allowed)),
+			None,
+			63,
+			origin,
+			call,
+		)
+		.is_ok();
+		debug_assert!(ok, "LOGIC ERROR: bake_referendum/schedule_named failed");
+	}
+
+	/// Set an alarm to dispatch `call` at block number `when`.
+	fn set_alarm(
+		call: BoundedCallOf<T, I>,
+		when: BlockNumberFor<T>,
+	) -> Option<(BlockNumberFor<T>, ScheduleAddressOf<T, I>)> {
+		let alarm_interval = T::AlarmInterval::get().max(One::one());
+		// Alarm must go off no earlier than `when`.
+		// This rounds `when` upwards to the next multiple of `alarm_interval`.
+		let when = (when.saturating_add(alarm_interval.saturating_sub(One::one())) /
+			alarm_interval)
+			.saturating_mul(alarm_interval);
+		let result = T::Scheduler::schedule(
+			DispatchTime::At(when),
+			None,
+			128u8,
+			frame_system::RawOrigin::Root.into(),
+			call,
+		);
+		debug_assert!(
+			result.is_ok(),
+			"Unable to schedule a new alarm at #{:?} (now: #{:?}), scheduler error: `{:?}`",
+			when,
+			frame_system::Pallet::<T>::block_number(),
+			result.unwrap_err(),
+		);
+		result.ok().map(|x| (when, x))
+	}
+
+	/// Mutate a referendum's `status` into the correct deciding state.
+	///
+	/// - `now` is the current block number.
+	/// - `track` is the track info for the referendum.
+	///
+	/// This will properly set up the `confirming` item.
+	fn begin_deciding(
+		status: &mut ReferendumStatusOf<T, I>,
+		index: ReferendumIndex,
+		now: BlockNumberFor<T>,
+		track: &TrackInfoOf<T, I>,
+	) -> (Option<BlockNumberFor<T>>, BeginDecidingBranch) {
+		let is_passing = Self::is_passing(
+			&status.tally,
+			Zero::zero(),
+			track.decision_period,
+			&track.min_support,
+			&track.min_approval,
+			status.track,
+		);
+		status.in_queue = false;
+		Self::deposit_event(Event::<T, I>::DecisionStarted {
+			index,
+			tally: status.tally.clone(),
+			proposal: status.proposal.clone(),
+			track: status.track,
+		});
+		let confirming = if is_passing {
+			Self::deposit_event(Event::<T, I>::ConfirmStarted { index });
+			Some(now.saturating_add(track.confirm_period))
+		} else {
+			None
+		};
+		let deciding_status = DecidingStatus { since: now, confirming };
+		let alarm = Self::decision_time(&deciding_status, &status.tally, status.track, track)
+			.max(now.saturating_add(One::one()));
+		status.deciding = Some(deciding_status);
+		let branch =
+			if is_passing { BeginDecidingBranch::Passing } else { BeginDecidingBranch::Failing };
+		(Some(alarm), branch)
+	}
+
+	/// If it returns `Some`, deciding has begun and it needs waking at the given block number. The
+	/// second item is the flag for whether it is confirming or not.
+	///
+	/// If `None`, then it is queued and should be nudged automatically as the queue gets drained.
+	fn ready_for_deciding(
+		now: BlockNumberFor<T>,
+		track: &TrackInfoOf<T, I>,
+		index: ReferendumIndex,
+		status: &mut ReferendumStatusOf<T, I>,
+	) -> (Option<BlockNumberFor<T>>, ServiceBranch) {
+		let deciding_count = DecidingCount::<T, I>::get(status.track);
+		if deciding_count < track.max_deciding {
+			// Begin deciding.
+			DecidingCount::<T, I>::insert(status.track, deciding_count.saturating_add(1));
+			let r = Self::begin_deciding(status, index, now, track);
+			(r.0, r.1.into())
+		} else {
+			// Add to queue.
+			let item = (index, status.tally.ayes(status.track));
+			status.in_queue = true;
+			TrackQueue::<T, I>::mutate(status.track, |q| q.insert_sorted_by_key(item, |x| x.1));
+			(None, ServiceBranch::Queued)
+		}
+	}
+
+	/// Grab the index and status for the referendum which is the highest priority of those for the
+	/// given track which are ready for being decided.
+	fn next_for_deciding(
+		track_queue: &mut BoundedVec<(u32, VotesOf<T, I>), T::MaxQueued>,
+	) -> Option<(ReferendumIndex, ReferendumStatusOf<T, I>)> {
+		loop {
+			let (index, _) = track_queue.pop()?;
+			match Self::ensure_ongoing(index) {
+				Ok(s) => return Some((index, s)),
+				Err(_) => {}, // referendum already timedout or was cancelled.
+			}
+		}
+	}
+
+	/// Schedule a call to `one_fewer_deciding` function via the dispatchable
+	/// `defer_one_fewer_deciding`. We could theoretically call it immediately (and it would be
+	/// overall more efficient), however the weights become rather less easy to measure.
+	fn note_one_fewer_deciding(track: TrackIdOf<T, I>) {
+		// Set an alarm call for the next block to nudge the track along.
+		let now = frame_system::Pallet::<T>::block_number();
+		let next_block = now + One::one();
+		let call = match T::Preimages::bound(CallOf::<T, I>::from(Call::one_fewer_deciding {
+			track,
+		})) {
+			Ok(c) => c,
+			Err(_) => {
+				debug_assert!(false, "Unable to create a bounded call from `one_fewer_deciding`??",);
+				return
+			},
+		};
+		Self::set_alarm(call, next_block);
+	}
+
+	/// Ensure that a `service_referendum` alarm happens for the referendum `index` at `alarm`.
+	///
+	/// This will do nothing if the alarm is already set.
+	///
+	/// Returns `false` if nothing changed.
+	fn ensure_alarm_at(
+		status: &mut ReferendumStatusOf<T, I>,
+		index: ReferendumIndex,
+		alarm: BlockNumberFor<T>,
+	) -> bool {
+		if status.alarm.as_ref().map_or(true, |&(when, _)| when != alarm) {
+			// Either no alarm or one that was different
+			Self::ensure_no_alarm(status);
+			let call =
+				match T::Preimages::bound(CallOf::<T, I>::from(Call::nudge_referendum { index })) {
+					Ok(c) => c,
+					Err(_) => {
+						debug_assert!(
+							false,
+							"Unable to create a bounded call from `nudge_referendum`??",
+						);
+						return false
+					},
+				};
+			status.alarm = Self::set_alarm(call, alarm);
+			true
+		} else {
+			false
+		}
+	}
+
+	/// Advance the state of a referendum, which comes down to:
+	/// - If it's ready to be decided, start deciding;
+	/// - If it's not ready to be decided and non-deciding timeout has passed, fail;
+	/// - If it's ongoing and passing, ensure confirming; if at end of confirmation period, pass.
+	/// - If it's ongoing and not passing, stop confirming; if it has reached end time, fail.
+	///
+	/// Weight will be a bit different depending on what it does, but it's designed so as not to
+	/// differ dramatically, especially if `MaxQueue` is kept small. In particular _there are no
+	/// balance operations in here_.
+	///
+	/// In terms of storage, every call to it is expected to access:
+	/// - The scheduler, either to insert, remove or alter an entry;
+	/// - `TrackQueue`, which should be a `BoundedVec` with a low limit (8-16);
+	/// - `DecidingCount`.
+	///
+	/// Both of the two storage items will only have as many items as there are different tracks,
+	/// perhaps around 10 and should be whitelisted.
+	///
+	/// The heaviest branch is likely to be when a proposal is placed into, or moved within, the
+	/// `TrackQueue`. Basically this happens when a referendum is in the deciding queue and receives
+	/// a vote, or when it moves into the deciding queue.
+	fn service_referendum(
+		now: BlockNumberFor<T>,
+		index: ReferendumIndex,
+		mut status: ReferendumStatusOf<T, I>,
+	) -> (ReferendumInfoOf<T, I>, bool, ServiceBranch) {
+		let mut dirty = false;
+		// Should it begin being decided?
+		let track = match Self::track(status.track) {
+			Some(x) => x,
+			None => return (ReferendumInfo::Ongoing(status), false, ServiceBranch::Fail),
+		};
+		// Default the alarm to the end of the world.
+		let timeout = status.submitted + T::UndecidingTimeout::get();
+		let mut alarm = BlockNumberFor::<T>::max_value();
+		let branch;
+		match &mut status.deciding {
+			None => {
+				// Are we already queued for deciding?
+				if status.in_queue {
+					// Does our position in the queue need updating?
+					let ayes = status.tally.ayes(status.track);
+					let mut queue = TrackQueue::<T, I>::get(status.track);
+					let maybe_old_pos = queue.iter().position(|(x, _)| *x == index);
+					let new_pos = queue.binary_search_by_key(&ayes, |x| x.1).unwrap_or_else(|x| x);
+					branch = if maybe_old_pos.is_none() && new_pos > 0 {
+						// Just insert.
+						let _ = queue.force_insert_keep_right(new_pos, (index, ayes));
+						ServiceBranch::RequeuedInsertion
+					} else if let Some(old_pos) = maybe_old_pos {
+						// We were in the queue - slide into the correct position.
+						queue[old_pos].1 = ayes;
+						queue.slide(old_pos, new_pos);
+						ServiceBranch::RequeuedSlide
+					} else {
+						ServiceBranch::NotQueued
+					};
+					TrackQueue::<T, I>::insert(status.track, queue);
+				} else {
+					// Are we ready for deciding?
+					branch = if status.decision_deposit.is_some() {
+						let prepare_end = status.submitted.saturating_add(track.prepare_period);
+						if now >= prepare_end {
+							let (maybe_alarm, branch) =
+								Self::ready_for_deciding(now, track, index, &mut status);
+							if let Some(set_alarm) = maybe_alarm {
+								alarm = alarm.min(set_alarm);
+							}
+							dirty = true;
+							branch
+						} else {
+							alarm = alarm.min(prepare_end);
+							ServiceBranch::Preparing
+						}
+					} else {
+						alarm = timeout;
+						ServiceBranch::NoDeposit
+					}
+				}
+				// If we didn't move into being decided, then check the timeout.
+				if status.deciding.is_none() && now >= timeout && !status.in_queue {
+					// Too long without being decided - end it.
+					Self::ensure_no_alarm(&mut status);
+					Self::deposit_event(Event::<T, I>::TimedOut { index, tally: status.tally });
+					return (
+						ReferendumInfo::TimedOut(
+							now,
+							Some(status.submission_deposit),
+							status.decision_deposit,
+						),
+						true,
+						ServiceBranch::TimedOut,
+					)
+				}
+			},
+			Some(deciding) => {
+				let is_passing = Self::is_passing(
+					&status.tally,
+					now.saturating_sub(deciding.since),
+					track.decision_period,
+					&track.min_support,
+					&track.min_approval,
+					status.track,
+				);
+				branch = if is_passing {
+					match deciding.confirming {
+						Some(t) if now >= t => {
+							// Passed!
+							Self::ensure_no_alarm(&mut status);
+							Self::note_one_fewer_deciding(status.track);
+							let (desired, call) = (status.enactment, status.proposal);
+							Self::schedule_enactment(index, track, desired, status.origin, call);
+							Self::deposit_event(Event::<T, I>::Confirmed {
+								index,
+								tally: status.tally,
+							});
+							return (
+								ReferendumInfo::Approved(
+									now,
+									Some(status.submission_deposit),
+									status.decision_deposit,
+								),
+								true,
+								ServiceBranch::Approved,
+							)
+						},
+						Some(_) => ServiceBranch::ContinueConfirming,
+						None => {
+							// Start confirming
+							dirty = true;
+							deciding.confirming = Some(now.saturating_add(track.confirm_period));
+							Self::deposit_event(Event::<T, I>::ConfirmStarted { index });
+							ServiceBranch::BeginConfirming
+						},
+					}
+				} else {
+					if now >= deciding.since.saturating_add(track.decision_period) {
+						// Failed!
+						Self::ensure_no_alarm(&mut status);
+						Self::note_one_fewer_deciding(status.track);
+						Self::deposit_event(Event::<T, I>::Rejected { index, tally: status.tally });
+						return (
+							ReferendumInfo::Rejected(
+								now,
+								Some(status.submission_deposit),
+								status.decision_deposit,
+							),
+							true,
+							ServiceBranch::Rejected,
+						)
+					}
+					if deciding.confirming.is_some() {
+						// Stop confirming
+						dirty = true;
+						deciding.confirming = None;
+						Self::deposit_event(Event::<T, I>::ConfirmAborted { index });
+						ServiceBranch::EndConfirming
+					} else {
+						ServiceBranch::ContinueNotConfirming
+					}
+				};
+				alarm = Self::decision_time(deciding, &status.tally, status.track, track);
+			},
+		}
+
+		let dirty_alarm = if alarm < BlockNumberFor::<T>::max_value() {
+			Self::ensure_alarm_at(&mut status, index, alarm)
+		} else {
+			Self::ensure_no_alarm(&mut status)
+		};
+		(ReferendumInfo::Ongoing(status), dirty_alarm || dirty, branch)
+	}
+
+	/// Determine the point at which a referendum will be accepted, move into confirmation with the
+	/// given `tally` or end with rejection (whichever happens sooner).
+	fn decision_time(
+		deciding: &DecidingStatusOf<T>,
+		tally: &T::Tally,
+		track_id: TrackIdOf<T, I>,
+		track: &TrackInfoOf<T, I>,
+	) -> BlockNumberFor<T> {
+		deciding.confirming.unwrap_or_else(|| {
+			// Set alarm to the point where the current voting would make it pass.
+			let approval = tally.approval(track_id);
+			let support = tally.support(track_id);
+			let until_approval = track.min_approval.delay(approval);
+			let until_support = track.min_support.delay(support);
+			let offset = until_support.max(until_approval);
+			deciding.since.saturating_add(offset.mul_ceil(track.decision_period))
+		})
+	}
+
+	/// Cancel the alarm in `status`, if one exists.
+	fn ensure_no_alarm(status: &mut ReferendumStatusOf<T, I>) -> bool {
+		if let Some((_, last_alarm)) = status.alarm.take() {
+			// Incorrect alarm - cancel it.
+			let _ = T::Scheduler::cancel(last_alarm);
+			true
+		} else {
+			false
+		}
+	}
+
+	/// Reserve a deposit and return the `Deposit` instance.
+	fn take_deposit(
+		who: T::AccountId,
+		amount: BalanceOf<T, I>,
+	) -> Result<Deposit<T::AccountId, BalanceOf<T, I>>, DispatchError> {
+		T::Currency::reserve(&who, amount)?;
+		Ok(Deposit { who, amount })
+	}
+
+	/// Return a deposit, if `Some`.
+	fn refund_deposit(deposit: Option<Deposit<T::AccountId, BalanceOf<T, I>>>) {
+		if let Some(Deposit { who, amount }) = deposit {
+			T::Currency::unreserve(&who, amount);
+		}
+	}
+
+	/// Slash a deposit, if `Some`.
+	fn slash_deposit(deposit: Option<Deposit<T::AccountId, BalanceOf<T, I>>>) {
+		if let Some(Deposit { who, amount }) = deposit {
+			T::Slash::on_unbalanced(T::Currency::slash_reserved(&who, amount).0);
+			Self::deposit_event(Event::<T, I>::DepositSlashed { who, amount });
+		}
+	}
+
+	/// Get the track info value for the track `id`.
+	fn track(id: TrackIdOf<T, I>) -> Option<&'static TrackInfoOf<T, I>> {
+		let tracks = T::Tracks::tracks();
+		let index = tracks.binary_search_by_key(&id, |x| x.0).unwrap_or_else(|x| x);
+		Some(&tracks[index].1)
+	}
+
+	/// Determine whether the given `tally` would result in a referendum passing at `elapsed` blocks
+	/// into a total decision `period`, given the two curves for `support_needed` and
+	/// `approval_needed`.
+	fn is_passing(
+		tally: &T::Tally,
+		elapsed: BlockNumberFor<T>,
+		period: BlockNumberFor<T>,
+		support_needed: &Curve,
+		approval_needed: &Curve,
+		id: TrackIdOf<T, I>,
+	) -> bool {
+		let x = Perbill::from_rational(elapsed.min(period), period);
+		support_needed.passing(x, tally.support(id)) &&
+			approval_needed.passing(x, tally.approval(id))
+	}
+
+	/// Clear metadata if exist for a given referendum index.
+	fn do_clear_metadata(index: ReferendumIndex) {
+		if let Some(hash) = MetadataOf::<T, I>::take(index) {
+			Self::deposit_event(Event::<T, I>::MetadataCleared { index, hash });
+		}
+	}
+
+	/// Ensure the correctness of the state of this pallet.
+	///
+	/// The following assertions must always apply.
+	///
+	/// General assertions:
+	///
+	/// * [`ReferendumCount`] must always be equal to the number of referenda in
+	///   [`ReferendumInfoFor`].
+	/// * Referendum indices in [`MetadataOf`] must also be stored in [`ReferendumInfoFor`].
+	#[cfg(any(feature = "try-runtime", test))]
+	fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> {
+		ensure!(
+			ReferendumCount::<T, I>::get() as usize ==
+				ReferendumInfoFor::<T, I>::iter_keys().count(),
+			"Number of referenda in `ReferendumInfoFor` is different than `ReferendumCount`"
+		);
+
+		MetadataOf::<T, I>::iter_keys().try_for_each(|referendum_index| -> DispatchResult {
+			ensure!(
+				ReferendumInfoFor::<T, I>::contains_key(referendum_index),
+				"Referendum indices in `MetadataOf` must also be stored in `ReferendumInfoOf`"
+			);
+			Ok(())
+		})?;
+
+		Self::try_state_referenda_info()?;
+		Self::try_state_tracks()?;
+
+		Ok(())
+	}
+
+	/// Looking at referenda info:
+	///
+	/// - Data regarding ongoing phase:
+	///
+	/// * There must exist track info for the track of the referendum.
+	/// * The deciding stage has to begin before confirmation period.
+	/// * If alarm is set the nudge call has to be at most [`UndecidingTimeout`] blocks away
+	///  from the submission block.
+	#[cfg(any(feature = "try-runtime", test))]
+	fn try_state_referenda_info() -> Result<(), sp_runtime::TryRuntimeError> {
+		ReferendumInfoFor::<T, I>::iter().try_for_each(|(_, referendum)| {
+			match referendum {
+				ReferendumInfo::Ongoing(status) => {
+					ensure!(
+						Self::track(status.track).is_some(),
+						"No track info for the track of the referendum."
+					);
+
+					if let Some(deciding) = status.deciding {
+						ensure!(
+							deciding.since <
+								deciding.confirming.unwrap_or(BlockNumberFor::<T>::max_value()),
+							"Deciding status cannot begin before confirming stage."
+						)
+					}
+				},
+				_ => {},
+			}
+			Ok(())
+		})
+	}
+
+	/// Looking at tracks:
+	///
+	/// * The referendum indices stored in [`TrackQueue`] must exist as keys in the
+	///  [`ReferendumInfoFor`] storage map.
+	#[cfg(any(feature = "try-runtime", test))]
+	fn try_state_tracks() -> Result<(), sp_runtime::TryRuntimeError> {
+		T::Tracks::tracks().iter().try_for_each(|track| {
+			TrackQueue::<T, I>::get(track.0).iter().try_for_each(
+				|(referendum_index, _)| -> Result<(), sp_runtime::TryRuntimeError> {
+					ensure!(
+					ReferendumInfoFor::<T, I>::contains_key(referendum_index),
+					"`ReferendumIndex` inside the `TrackQueue` should be a key in `ReferendumInfoFor`"
+				);
+					Ok(())
+				},
+			)?;
+			Ok(())
+		})
+	}
+}
diff --git a/substrate/frame/referenda/src/migration.rs b/substrate/frame/referenda/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..281da83d6569ef83b348feaa18e487f9e4b26c72
--- /dev/null
+++ b/substrate/frame/referenda/src/migration.rs
@@ -0,0 +1,234 @@
+// 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.
+
+//! Storage migrations for the referenda pallet.
+
+use super::*;
+use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
+use frame_support::{pallet_prelude::*, storage_alias, traits::OnRuntimeUpgrade};
+use log;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// Initial version of storage types.
+pub mod v0 {
+	use super::*;
+	// ReferendumStatus and its dependency types referenced from the latest version while staying
+	// unchanged. [`super::test::referendum_status_v0()`] checks its immutability between v0 and
+	// latest version.
+	#[cfg(test)]
+	pub(super) use super::{ReferendumStatus, ReferendumStatusOf};
+
+	pub type ReferendumInfoOf<T, I> = ReferendumInfo<
+		TrackIdOf<T, I>,
+		PalletsOriginOf<T>,
+		frame_system::pallet_prelude::BlockNumberFor<T>,
+		BoundedCallOf<T, I>,
+		BalanceOf<T, I>,
+		TallyOf<T, I>,
+		<T as frame_system::Config>::AccountId,
+		ScheduleAddressOf<T, I>,
+	>;
+
+	/// Info regarding a referendum, present or past.
+	#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+	pub enum ReferendumInfo<
+		TrackId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		RuntimeOrigin: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		Moment: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone + EncodeLike,
+		Call: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		Balance: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		Tally: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	> {
+		/// Referendum has been submitted and is being voted on.
+		Ongoing(
+			ReferendumStatus<
+				TrackId,
+				RuntimeOrigin,
+				Moment,
+				Call,
+				Balance,
+				Tally,
+				AccountId,
+				ScheduleAddress,
+			>,
+		),
+		/// Referendum finished with approval. Submission deposit is held.
+		Approved(Moment, Deposit<AccountId, Balance>, Option<Deposit<AccountId, Balance>>),
+		/// Referendum finished with rejection. Submission deposit is held.
+		Rejected(Moment, Deposit<AccountId, Balance>, Option<Deposit<AccountId, Balance>>),
+		/// Referendum finished with cancellation. Submission deposit is held.
+		Cancelled(Moment, Deposit<AccountId, Balance>, Option<Deposit<AccountId, Balance>>),
+		/// Referendum finished and was never decided. Submission deposit is held.
+		TimedOut(Moment, Deposit<AccountId, Balance>, Option<Deposit<AccountId, Balance>>),
+		/// Referendum finished with a kill.
+		Killed(Moment),
+	}
+
+	#[storage_alias]
+	pub type ReferendumInfoFor<T: Config<I>, I: 'static> =
+		StorageMap<Pallet<T, I>, Blake2_128Concat, ReferendumIndex, ReferendumInfoOf<T, I>>;
+}
+
+pub mod v1 {
+	use super::*;
+
+	/// The log target.
+	const TARGET: &'static str = "runtime::referenda::migration::v1";
+
+	/// Transforms a submission deposit of ReferendumInfo(Approved|Rejected|Cancelled|TimedOut) to
+	/// optional value, making it refundable.
+	pub struct MigrateV0ToV1<T, I = ()>(PhantomData<(T, I)>);
+	impl<T: Config<I>, I: 'static> OnRuntimeUpgrade for MigrateV0ToV1<T, I> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			let onchain_version = Pallet::<T, I>::on_chain_storage_version();
+			ensure!(onchain_version == 0, "migration from version 0 to 1.");
+			let referendum_count = v0::ReferendumInfoFor::<T, I>::iter().count();
+			log::info!(
+				target: TARGET,
+				"pre-upgrade state contains '{}' referendums.",
+				referendum_count
+			);
+			Ok((referendum_count as u32).encode())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			let current_version = Pallet::<T, I>::current_storage_version();
+			let onchain_version = Pallet::<T, I>::on_chain_storage_version();
+			let mut weight = T::DbWeight::get().reads(1);
+			log::info!(
+				target: TARGET,
+				"running migration with current storage version {:?} / onchain {:?}.",
+				current_version,
+				onchain_version
+			);
+			if onchain_version != 0 {
+				log::warn!(target: TARGET, "skipping migration from v0 to v1.");
+				return weight
+			}
+			v0::ReferendumInfoFor::<T, I>::iter().for_each(|(key, value)| {
+				let maybe_new_value = match value {
+					v0::ReferendumInfo::Ongoing(_) | v0::ReferendumInfo::Killed(_) => None,
+					v0::ReferendumInfo::Approved(e, s, d) =>
+						Some(ReferendumInfo::Approved(e, Some(s), d)),
+					v0::ReferendumInfo::Rejected(e, s, d) =>
+						Some(ReferendumInfo::Rejected(e, Some(s), d)),
+					v0::ReferendumInfo::Cancelled(e, s, d) =>
+						Some(ReferendumInfo::Cancelled(e, Some(s), d)),
+					v0::ReferendumInfo::TimedOut(e, s, d) =>
+						Some(ReferendumInfo::TimedOut(e, Some(s), d)),
+				};
+				if let Some(new_value) = maybe_new_value {
+					weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+					log::info!(target: TARGET, "migrating referendum #{:?}", &key);
+					ReferendumInfoFor::<T, I>::insert(key, new_value);
+				} else {
+					weight.saturating_accrue(T::DbWeight::get().reads(1));
+				}
+			});
+			StorageVersion::new(1).put::<Pallet<T, I>>();
+			weight.saturating_accrue(T::DbWeight::get().writes(1));
+			weight
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let onchain_version = Pallet::<T, I>::on_chain_storage_version();
+			ensure!(onchain_version == 1, "must upgrade from version 0 to 1.");
+			let pre_referendum_count: u32 = Decode::decode(&mut &state[..])
+				.expect("failed to decode the state from pre-upgrade.");
+			let post_referendum_count = ReferendumInfoFor::<T, I>::iter().count() as u32;
+			ensure!(post_referendum_count == pre_referendum_count, "must migrate all referendums.");
+			log::info!(target: TARGET, "migrated all referendums.");
+			Ok(())
+		}
+	}
+}
+
+#[cfg(test)]
+pub mod test {
+	use super::*;
+	use crate::mock::{Test as T, *};
+	use core::str::FromStr;
+
+	// create referendum status v0.
+	fn create_status_v0() -> v0::ReferendumStatusOf<T, ()> {
+		let origin: OriginCaller = frame_system::RawOrigin::Root.into();
+		let track = <T as Config<()>>::Tracks::track_for(&origin).unwrap();
+		v0::ReferendumStatusOf::<T, ()> {
+			track,
+			in_queue: true,
+			origin,
+			proposal: set_balance_proposal_bounded(1),
+			enactment: DispatchTime::At(1),
+			tally: TallyOf::<T, ()>::new(track),
+			submission_deposit: Deposit { who: 1, amount: 10 },
+			submitted: 1,
+			decision_deposit: None,
+			alarm: None,
+			deciding: None,
+		}
+	}
+
+	#[test]
+	pub fn referendum_status_v0() {
+		// make sure the bytes of the encoded referendum v0 is decodable.
+		let ongoing_encoded = sp_core::Bytes::from_str("0x00000000012c01082a0000000000000004000100000000000000010000000000000001000000000000000a00000000000000000000000000000000000100").unwrap();
+		let ongoing_dec = v0::ReferendumInfoOf::<T, ()>::decode(&mut &*ongoing_encoded).unwrap();
+		let ongoing = v0::ReferendumInfoOf::<T, ()>::Ongoing(create_status_v0());
+		assert_eq!(ongoing, ongoing_dec);
+	}
+
+	#[test]
+	fn migration_v0_to_v1_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// create and insert into the storage an ongoing referendum v0.
+			let status_v0 = create_status_v0();
+			let ongoing_v0 = v0::ReferendumInfoOf::<T, ()>::Ongoing(status_v0.clone());
+			ReferendumCount::<T, ()>::mutate(|x| x.saturating_inc());
+			v0::ReferendumInfoFor::<T, ()>::insert(2, ongoing_v0);
+			// create and insert into the storage an approved referendum v0.
+			let approved_v0 = v0::ReferendumInfoOf::<T, ()>::Approved(
+				123,
+				Deposit { who: 1, amount: 10 },
+				Some(Deposit { who: 2, amount: 20 }),
+			);
+			ReferendumCount::<T, ()>::mutate(|x| x.saturating_inc());
+			v0::ReferendumInfoFor::<T, ()>::insert(5, approved_v0);
+			// run migration from v0 to v1.
+			v1::MigrateV0ToV1::<T, ()>::on_runtime_upgrade();
+			// fetch and assert migrated into v1 the ongoing referendum.
+			let ongoing_v1 = ReferendumInfoFor::<T, ()>::get(2).unwrap();
+			// referendum status schema is the same for v0 and v1.
+			assert_eq!(ReferendumInfoOf::<T, ()>::Ongoing(status_v0), ongoing_v1);
+			// fetch and assert migrated into v1 the approved referendum.
+			let approved_v1 = ReferendumInfoFor::<T, ()>::get(5).unwrap();
+			assert_eq!(
+				approved_v1,
+				ReferendumInfoOf::<T, ()>::Approved(
+					123,
+					Some(Deposit { who: 1, amount: 10 }),
+					Some(Deposit { who: 2, amount: 20 })
+				)
+			);
+		});
+	}
+}
diff --git a/substrate/frame/referenda/src/mock.rs b/substrate/frame/referenda/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e44167ed561c591236554bc86b7be50d0709d88b
--- /dev/null
+++ b/substrate/frame/referenda/src/mock.rs
@@ -0,0 +1,486 @@
+// 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.
+
+//! The crate's tests.
+
+use super::*;
+use crate as pallet_referenda;
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	assert_ok, ord_parameter_types, parameter_types,
+	traits::{
+		ConstU32, ConstU64, Contains, EqualPrivilegeOnly, OnInitialize, OriginTrait, Polling,
+		SortedMembers,
+	},
+	weights::Weight,
+};
+use frame_system::{EnsureRoot, EnsureSignedBy};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, Hash, IdentityLookup},
+	BuildStorage, DispatchResult, Perbill,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Preimage: pallet_preimage,
+		Scheduler: pallet_scheduler,
+		Referenda: pallet_referenda,
+	}
+);
+
+// Test that a fitlered call can be dispatched.
+pub struct BaseFilter;
+impl Contains<RuntimeCall> for BaseFilter {
+	fn contains(call: &RuntimeCall) -> bool {
+		!matches!(call, &RuntimeCall::Balances(pallet_balances::Call::force_set_balance { .. }))
+	}
+}
+
+parameter_types! {
+	pub MaxWeight: Weight = Weight::from_parts(2_000_000_000_000, u64::MAX);
+}
+impl frame_system::Config for Test {
+	type BaseCallFilter = BaseFilter;
+	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 = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+impl pallet_preimage::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = Balances;
+	type ManagerOrigin = EnsureRoot<u64>;
+	type BaseDeposit = ();
+	type ByteDeposit = ();
+}
+impl pallet_scheduler::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type PalletsOrigin = OriginCaller;
+	type RuntimeCall = RuntimeCall;
+	type MaximumWeight = MaxWeight;
+	type ScheduleOrigin = EnsureRoot<u64>;
+	type MaxScheduledPerBlock = ConstU32<100>;
+	type WeightInfo = ();
+	type OriginPrivilegeCmp = EqualPrivilegeOnly;
+	type Preimages = Preimage;
+}
+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 MaxHolds = ();
+}
+parameter_types! {
+	pub static AlarmInterval: u64 = 1;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+	pub const Two: u64 = 2;
+	pub const Three: u64 = 3;
+	pub const Four: u64 = 4;
+	pub const Five: u64 = 5;
+	pub const Six: u64 = 6;
+}
+pub struct OneToFive;
+impl SortedMembers<u64> for OneToFive {
+	fn sorted_members() -> Vec<u64> {
+		vec![1, 2, 3, 4, 5]
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add(_m: &u64) {}
+}
+
+pub struct TestTracksInfo;
+impl TracksInfo<u64, u64> for TestTracksInfo {
+	type Id = u8;
+	type RuntimeOrigin = <RuntimeOrigin as OriginTrait>::PalletsOrigin;
+	fn tracks() -> &'static [(Self::Id, TrackInfo<u64, u64>)] {
+		static DATA: [(u8, TrackInfo<u64, u64>); 2] = [
+			(
+				0u8,
+				TrackInfo {
+					name: "root",
+					max_deciding: 1,
+					decision_deposit: 10,
+					prepare_period: 4,
+					decision_period: 4,
+					confirm_period: 2,
+					min_enactment_period: 4,
+					min_approval: Curve::LinearDecreasing {
+						length: Perbill::from_percent(100),
+						floor: Perbill::from_percent(50),
+						ceil: Perbill::from_percent(100),
+					},
+					min_support: Curve::LinearDecreasing {
+						length: Perbill::from_percent(100),
+						floor: Perbill::from_percent(0),
+						ceil: Perbill::from_percent(100),
+					},
+				},
+			),
+			(
+				1u8,
+				TrackInfo {
+					name: "none",
+					max_deciding: 3,
+					decision_deposit: 1,
+					prepare_period: 2,
+					decision_period: 2,
+					confirm_period: 1,
+					min_enactment_period: 2,
+					min_approval: Curve::LinearDecreasing {
+						length: Perbill::from_percent(100),
+						floor: Perbill::from_percent(95),
+						ceil: Perbill::from_percent(100),
+					},
+					min_support: Curve::LinearDecreasing {
+						length: Perbill::from_percent(100),
+						floor: Perbill::from_percent(90),
+						ceil: Perbill::from_percent(100),
+					},
+				},
+			),
+		];
+		&DATA[..]
+	}
+	fn track_for(id: &Self::RuntimeOrigin) -> Result<Self::Id, ()> {
+		if let Ok(system_origin) = frame_system::RawOrigin::try_from(id.clone()) {
+			match system_origin {
+				frame_system::RawOrigin::Root => Ok(0),
+				frame_system::RawOrigin::None => Ok(1),
+				_ => Err(()),
+			}
+		} else {
+			Err(())
+		}
+	}
+}
+impl_tracksinfo_get!(TestTracksInfo, u64, u64);
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type Scheduler = Scheduler;
+	type Currency = pallet_balances::Pallet<Self>;
+	type SubmitOrigin = frame_system::EnsureSigned<u64>;
+	type CancelOrigin = EnsureSignedBy<Four, u64>;
+	type KillOrigin = EnsureRoot<u64>;
+	type Slash = ();
+	type Votes = u32;
+	type Tally = Tally;
+	type SubmissionDeposit = ConstU64<2>;
+	type MaxQueued = ConstU32<3>;
+	type UndecidingTimeout = ConstU64<20>;
+	type AlarmInterval = AlarmInterval;
+	type Tracks = TestTracksInfo;
+	type Preimages = Preimage;
+}
+pub struct ExtBuilder {}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {}
+	}
+}
+
+impl ExtBuilder {
+	pub fn build(self) -> sp_io::TestExternalities {
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		let balances = vec![(1, 100), (2, 100), (3, 100), (4, 100), (5, 100), (6, 100)];
+		pallet_balances::GenesisConfig::<Test> { balances }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		let mut ext = sp_io::TestExternalities::new(t);
+		ext.execute_with(|| System::set_block_number(1));
+		ext
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		self.build().execute_with(|| {
+			test();
+			Referenda::do_try_state().unwrap();
+		})
+	}
+}
+
+#[derive(Encode, Debug, Decode, TypeInfo, Eq, PartialEq, Clone, MaxEncodedLen)]
+pub struct Tally {
+	pub ayes: u32,
+	pub nays: u32,
+}
+
+impl<Class> VoteTally<u32, Class> for Tally {
+	fn new(_: Class) -> Self {
+		Self { ayes: 0, nays: 0 }
+	}
+
+	fn ayes(&self, _: Class) -> u32 {
+		self.ayes
+	}
+
+	fn support(&self, _: Class) -> Perbill {
+		Perbill::from_percent(self.ayes)
+	}
+
+	fn approval(&self, _: Class) -> Perbill {
+		if self.ayes + self.nays > 0 {
+			Perbill::from_rational(self.ayes, self.ayes + self.nays)
+		} else {
+			Perbill::zero()
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn unanimity(_: Class) -> Self {
+		Self { ayes: 100, nays: 0 }
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn rejection(_: Class) -> Self {
+		Self { ayes: 0, nays: 100 }
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn from_requirements(support: Perbill, approval: Perbill, _: Class) -> Self {
+		let ayes = support.mul_ceil(100u32);
+		let nays = ((ayes as u64) * 1_000_000_000u64 / approval.deconstruct() as u64) as u32 - ayes;
+		Self { ayes, nays }
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn setup(_: Class, _: Perbill) {}
+}
+
+pub fn set_balance_proposal(value: u64) -> Vec<u8> {
+	RuntimeCall::Balances(pallet_balances::Call::force_set_balance { who: 42, new_free: value })
+		.encode()
+}
+
+pub fn set_balance_proposal_bounded(value: u64) -> BoundedCallOf<Test, ()> {
+	let c = RuntimeCall::Balances(pallet_balances::Call::force_set_balance {
+		who: 42,
+		new_free: value,
+	});
+	<Preimage as StorePreimage>::bound(c).unwrap()
+}
+
+#[allow(dead_code)]
+pub fn propose_set_balance(who: u64, value: u64, delay: u64) -> DispatchResult {
+	Referenda::submit(
+		RuntimeOrigin::signed(who),
+		Box::new(frame_system::RawOrigin::Root.into()),
+		set_balance_proposal_bounded(value),
+		DispatchTime::After(delay),
+	)
+}
+
+pub fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+	Scheduler::on_initialize(System::block_number());
+}
+
+pub fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+#[allow(dead_code)]
+pub fn begin_referendum() -> ReferendumIndex {
+	System::set_block_number(0);
+	assert_ok!(propose_set_balance(1, 2, 1));
+	run_to(2);
+	0
+}
+
+#[allow(dead_code)]
+pub fn tally(r: ReferendumIndex) -> Tally {
+	Referenda::ensure_ongoing(r).unwrap().tally
+}
+
+pub fn set_tally(index: ReferendumIndex, ayes: u32, nays: u32) {
+	<Referenda as Polling<Tally>>::access_poll(index, |status| {
+		let tally = status.ensure_ongoing().unwrap().0;
+		tally.ayes = ayes;
+		tally.nays = nays;
+	});
+}
+
+pub fn waiting_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Ongoing(ReferendumStatus { submitted, deciding: None, .. }) => submitted,
+		_ => panic!("Not waiting"),
+	}
+}
+
+pub fn deciding_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Ongoing(ReferendumStatus {
+			deciding: Some(DecidingStatus { since, .. }),
+			..
+		}) => since,
+		_ => panic!("Not deciding"),
+	}
+}
+
+pub fn deciding_and_failing_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Ongoing(ReferendumStatus {
+			deciding: Some(DecidingStatus { since, confirming: None, .. }),
+			..
+		}) => since,
+		_ => panic!("Not deciding"),
+	}
+}
+
+pub fn confirming_until(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Ongoing(ReferendumStatus {
+			deciding: Some(DecidingStatus { confirming: Some(until), .. }),
+			..
+		}) => until,
+		_ => panic!("Not confirming"),
+	}
+}
+
+pub fn approved_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Approved(since, ..) => since,
+		_ => panic!("Not approved"),
+	}
+}
+
+pub fn rejected_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Rejected(since, ..) => since,
+		_ => panic!("Not rejected"),
+	}
+}
+
+pub fn cancelled_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Cancelled(since, ..) => since,
+		_ => panic!("Not cancelled"),
+	}
+}
+
+pub fn killed_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::Killed(since, ..) => since,
+		_ => panic!("Not killed"),
+	}
+}
+
+pub fn timed_out_since(i: ReferendumIndex) -> u64 {
+	match ReferendumInfoFor::<Test>::get(i).unwrap() {
+		ReferendumInfo::TimedOut(since, ..) => since,
+		_ => panic!("Not timed out"),
+	}
+}
+
+fn is_deciding(i: ReferendumIndex) -> bool {
+	matches!(
+		ReferendumInfoFor::<Test>::get(i),
+		Some(ReferendumInfo::Ongoing(ReferendumStatus { deciding: Some(_), .. }))
+	)
+}
+
+#[derive(Clone, Copy)]
+pub enum RefState {
+	Failing,
+	Passing,
+	Confirming { immediate: bool },
+}
+
+impl RefState {
+	pub fn create(self) -> ReferendumIndex {
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(frame_support::dispatch::RawOrigin::Root.into()),
+			set_balance_proposal_bounded(1),
+			DispatchTime::At(10),
+		));
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+		if matches!(self, RefState::Confirming { immediate: true }) {
+			set_tally(0, 100, 0);
+		}
+		let index = ReferendumCount::<Test>::get() - 1;
+		while !is_deciding(index) {
+			run_to(System::block_number() + 1);
+		}
+		if matches!(self, RefState::Confirming { immediate: false }) {
+			set_tally(0, 100, 0);
+			run_to(System::block_number() + 1);
+		}
+		if matches!(self, RefState::Confirming { .. }) {
+			assert_eq!(confirming_until(index), System::block_number() + 2);
+		}
+		if matches!(self, RefState::Passing) {
+			set_tally(0, 100, 99);
+			run_to(System::block_number() + 1);
+		}
+		index
+	}
+}
+
+/// note a new preimage without registering.
+pub fn note_preimage(who: u64) -> PreimageHash {
+	use std::sync::atomic::{AtomicU8, Ordering};
+	// note a new preimage on every function invoke.
+	static COUNTER: AtomicU8 = AtomicU8::new(0);
+	let data = vec![COUNTER.fetch_add(1, Ordering::Relaxed)];
+	assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(who), data.clone()));
+	let hash = BlakeTwo256::hash(&data);
+	assert!(!Preimage::is_requested(&hash));
+	hash
+}
diff --git a/substrate/frame/referenda/src/tests.rs b/substrate/frame/referenda/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c7469946c2dab84a6fc0f3bfa32b77c49d16596e
--- /dev/null
+++ b/substrate/frame/referenda/src/tests.rs
@@ -0,0 +1,672 @@
+// 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.
+
+//! The crate's tests.
+
+use super::*;
+use crate::mock::{RefState::*, *};
+use assert_matches::assert_matches;
+use codec::Decode;
+use frame_support::{
+	assert_noop, assert_ok,
+	dispatch::{DispatchError::BadOrigin, RawOrigin},
+	traits::Contains,
+};
+use pallet_balances::Error as BalancesError;
+
+#[test]
+fn params_should_work() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(ReferendumCount::<Test>::get(), 0);
+		assert_eq!(Balances::free_balance(42), 0);
+		assert_eq!(Balances::total_issuance(), 600);
+	});
+}
+
+#[test]
+fn basic_happy_path_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// #1: submit
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			set_balance_proposal_bounded(1),
+			DispatchTime::At(10),
+		));
+		assert_eq!(Balances::reserved_balance(&1), 2);
+		assert_eq!(ReferendumCount::<Test>::get(), 1);
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+		run_to(4);
+		assert_eq!(DecidingCount::<Test>::get(0), 0);
+		run_to(5);
+		// #5: 4 blocks after submit - vote should now be deciding.
+		assert_eq!(DecidingCount::<Test>::get(0), 1);
+		run_to(6);
+		// #6: Lots of ayes. Should now be confirming.
+		set_tally(0, 100, 0);
+		run_to(7);
+		assert_eq!(confirming_until(0), 9);
+		run_to(9);
+		// #8: Should be confirmed & ended.
+		assert_eq!(approved_since(0), 9);
+		assert_ok!(Referenda::refund_decision_deposit(RuntimeOrigin::signed(2), 0));
+		run_to(12);
+		// #9: Should not yet be enacted.
+		assert_eq!(Balances::free_balance(&42), 0);
+		run_to(13);
+		// #10: Proposal should be executed.
+		assert_eq!(Balances::free_balance(&42), 1);
+	});
+}
+
+#[test]
+fn insta_confirm_then_kill_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let r = Confirming { immediate: true }.create();
+		run_to(6);
+		assert_ok!(Referenda::kill(RuntimeOrigin::root(), r));
+		assert_eq!(killed_since(r), 6);
+	});
+}
+
+#[test]
+fn confirm_then_reconfirm_with_elapsed_trigger_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let r = Confirming { immediate: false }.create();
+		assert_eq!(confirming_until(r), 8);
+		run_to(7);
+		set_tally(r, 100, 99);
+		run_to(8);
+		assert_eq!(deciding_and_failing_since(r), 5);
+		run_to(11);
+		assert_eq!(approved_since(r), 11);
+	});
+}
+
+#[test]
+fn instaconfirm_then_reconfirm_with_elapsed_trigger_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let r = Confirming { immediate: true }.create();
+		run_to(6);
+		assert_eq!(confirming_until(r), 7);
+		set_tally(r, 100, 99);
+		run_to(7);
+		assert_eq!(deciding_and_failing_since(r), 5);
+		run_to(11);
+		assert_eq!(approved_since(r), 11);
+	});
+}
+
+#[test]
+fn instaconfirm_then_reconfirm_with_voting_trigger_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let r = Confirming { immediate: true }.create();
+		run_to(6);
+		assert_eq!(confirming_until(r), 7);
+		set_tally(r, 100, 99);
+		run_to(7);
+		assert_eq!(deciding_and_failing_since(r), 5);
+		run_to(8);
+		set_tally(r, 100, 0);
+		run_to(9);
+		assert_eq!(confirming_until(r), 11);
+		run_to(11);
+		assert_eq!(approved_since(r), 11);
+	});
+}
+
+#[test]
+fn voting_should_extend_for_late_confirmation() {
+	ExtBuilder::default().build_and_execute(|| {
+		let r = Passing.create();
+		run_to(10);
+		assert_eq!(confirming_until(r), 11);
+		run_to(11);
+		assert_eq!(approved_since(r), 11);
+	});
+}
+
+#[test]
+fn should_instafail_during_extension_confirmation() {
+	ExtBuilder::default().build_and_execute(|| {
+		let r = Passing.create();
+		run_to(10);
+		assert_eq!(confirming_until(r), 11);
+		// Should insta-fail since it's now past the normal voting time.
+		set_tally(r, 100, 101);
+		run_to(11);
+		assert_eq!(rejected_since(r), 11);
+	});
+}
+
+#[test]
+fn confirming_then_fail_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let r = Failing.create();
+		// Normally ends at 5 + 4 (voting period) = 9.
+		assert_eq!(deciding_and_failing_since(r), 5);
+		set_tally(r, 100, 0);
+		run_to(6);
+		assert_eq!(confirming_until(r), 8);
+		set_tally(r, 100, 101);
+		run_to(9);
+		assert_eq!(rejected_since(r), 9);
+	});
+}
+
+#[test]
+fn queueing_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// Submit a proposal into a track with a queue len of 1.
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(5),
+			Box::new(RawOrigin::Root.into()),
+			set_balance_proposal_bounded(0),
+			DispatchTime::After(0),
+		));
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(5), 0));
+
+		run_to(2);
+
+		// Submit 3 more proposals into the same queue.
+		for i in 1..=4 {
+			assert_ok!(Referenda::submit(
+				RuntimeOrigin::signed(i),
+				Box::new(RawOrigin::Root.into()),
+				set_balance_proposal_bounded(i),
+				DispatchTime::After(0),
+			));
+		}
+		for i in [1, 2, 4] {
+			assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(i), i as u32));
+			// TODO: decision deposit after some initial votes with a non-highest voted coming
+			// first.
+		}
+		assert_eq!(ReferendumCount::<Test>::get(), 5);
+
+		run_to(5);
+		// One should be being decided.
+		assert_eq!(DecidingCount::<Test>::get(0), 1);
+		assert_eq!(deciding_and_failing_since(0), 5);
+		for i in 1..=4 {
+			assert_eq!(waiting_since(i), 2);
+		}
+
+		// Vote to set order.
+		set_tally(1, 1, 10);
+		set_tally(2, 2, 20);
+		set_tally(3, 3, 30);
+		set_tally(4, 100, 0);
+		println!("Agenda #6: {:?}", pallet_scheduler::Agenda::<Test>::get(6));
+		run_to(6);
+		println!("{:?}", Vec::<_>::from(TrackQueue::<Test>::get(0)));
+
+		// Cancel the first.
+		assert_ok!(Referenda::cancel(RuntimeOrigin::signed(4), 0));
+		assert_eq!(cancelled_since(0), 6);
+
+		// The other with the most approvals (#4) should be being decided.
+		run_to(7);
+		assert_eq!(DecidingCount::<Test>::get(0), 1);
+		assert_eq!(deciding_since(4), 7);
+		assert_eq!(confirming_until(4), 9);
+
+		// Vote on the remaining two to change order.
+		println!("Set tally #1");
+		set_tally(1, 30, 31);
+		println!("{:?}", Vec::<_>::from(TrackQueue::<Test>::get(0)));
+		println!("Set tally #2");
+		set_tally(2, 20, 20);
+		println!("{:?}", Vec::<_>::from(TrackQueue::<Test>::get(0)));
+
+		// Let confirmation period end.
+		run_to(9);
+
+		// #4 should have been confirmed.
+		assert_eq!(approved_since(4), 9);
+
+		// On to the next block to select the new referendum
+		run_to(10);
+		// #1 (the one with the most approvals) should now be being decided.
+		assert_eq!(deciding_since(1), 10);
+
+		// Let it end unsuccessfully.
+		run_to(14);
+		assert_eq!(rejected_since(1), 14);
+
+		// Service queue.
+		run_to(15);
+		// #2 should now be being decided. It will (barely) pass.
+		assert_eq!(deciding_and_failing_since(2), 15);
+
+		// #2 moves into confirming at the last moment with a 50% approval.
+		run_to(19);
+		assert_eq!(confirming_until(2), 21);
+
+		// #2 gets approved.
+		run_to(21);
+		assert_eq!(approved_since(2), 21);
+
+		// The final one has since timed out.
+		run_to(22);
+		assert_eq!(timed_out_since(3), 22);
+	});
+}
+
+#[test]
+fn alarm_interval_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let call =
+			<Test as Config>::Preimages::bound(CallOf::<Test, ()>::from(Call::nudge_referendum {
+				index: 0,
+			}))
+			.unwrap();
+		for n in 0..10 {
+			let interval = n * n;
+			let now = 100 * (interval + 1);
+			System::set_block_number(now);
+			AlarmInterval::set(interval);
+			let when = now + 1;
+			let (actual, _) = Referenda::set_alarm(call.clone(), when).unwrap();
+			assert!(actual >= when);
+			assert!(actual - interval <= when);
+		}
+	});
+}
+
+#[test]
+fn decision_time_is_correct() {
+	ExtBuilder::default().build_and_execute(|| {
+		let decision_time = |since: u64| {
+			Pallet::<Test>::decision_time(
+				&DecidingStatus { since: since.into(), confirming: None },
+				&Tally { ayes: 100, nays: 5 },
+				TestTracksInfo::tracks()[0].0,
+				&TestTracksInfo::tracks()[0].1,
+			)
+		};
+
+		for i in 0u64..=100 {
+			assert!(decision_time(i) > i, "The decision time should be delayed by the curve");
+		}
+	});
+}
+
+#[test]
+fn auto_timeout_should_happen_with_nothing_but_submit() {
+	ExtBuilder::default().build_and_execute(|| {
+		// #1: submit
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			set_balance_proposal_bounded(1),
+			DispatchTime::At(20),
+		));
+		run_to(20);
+		assert_matches!(ReferendumInfoFor::<Test>::get(0), Some(ReferendumInfo::Ongoing(..)));
+		run_to(21);
+		// #11: Timed out - ended.
+		assert_matches!(
+			ReferendumInfoFor::<Test>::get(0),
+			Some(ReferendumInfo::TimedOut(21, _, None))
+		);
+	});
+}
+
+#[test]
+fn tracks_are_distinguished() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			set_balance_proposal_bounded(1),
+			DispatchTime::At(10),
+		));
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(2),
+			Box::new(RawOrigin::None.into()),
+			set_balance_proposal_bounded(2),
+			DispatchTime::At(20),
+		));
+
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(3), 0));
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(4), 1));
+
+		let mut i = ReferendumInfoFor::<Test>::iter().collect::<Vec<_>>();
+		i.sort_by_key(|x| x.0);
+		assert_eq!(
+			i,
+			vec![
+				(
+					0,
+					ReferendumInfo::Ongoing(ReferendumStatus {
+						track: 0,
+						origin: OriginCaller::system(RawOrigin::Root),
+						proposal: set_balance_proposal_bounded(1),
+						enactment: DispatchTime::At(10),
+						submitted: 1,
+						submission_deposit: Deposit { who: 1, amount: 2 },
+						decision_deposit: Some(Deposit { who: 3, amount: 10 }),
+						deciding: None,
+						tally: Tally { ayes: 0, nays: 0 },
+						in_queue: false,
+						alarm: Some((5, (5, 0))),
+					})
+				),
+				(
+					1,
+					ReferendumInfo::Ongoing(ReferendumStatus {
+						track: 1,
+						origin: OriginCaller::system(RawOrigin::None),
+						proposal: set_balance_proposal_bounded(2),
+						enactment: DispatchTime::At(20),
+						submitted: 1,
+						submission_deposit: Deposit { who: 2, amount: 2 },
+						decision_deposit: Some(Deposit { who: 4, amount: 1 }),
+						deciding: None,
+						tally: Tally { ayes: 0, nays: 0 },
+						in_queue: false,
+						alarm: Some((3, (3, 0))),
+					})
+				),
+			]
+		);
+	});
+}
+
+#[test]
+fn submit_errors_work() {
+	ExtBuilder::default().build_and_execute(|| {
+		let h = set_balance_proposal_bounded(1);
+		// No track for Signed origins.
+		assert_noop!(
+			Referenda::submit(
+				RuntimeOrigin::signed(1),
+				Box::new(RawOrigin::Signed(2).into()),
+				h.clone(),
+				DispatchTime::At(10),
+			),
+			Error::<Test>::NoTrack
+		);
+
+		// No funds for deposit
+		assert_noop!(
+			Referenda::submit(
+				RuntimeOrigin::signed(10),
+				Box::new(RawOrigin::Root.into()),
+				h,
+				DispatchTime::At(10),
+			),
+			BalancesError::<Test>::InsufficientBalance
+		);
+	});
+}
+
+#[test]
+fn decision_deposit_errors_work() {
+	ExtBuilder::default().build_and_execute(|| {
+		let e = Error::<Test>::NotOngoing;
+		assert_noop!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0), e);
+
+		let h = set_balance_proposal_bounded(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h,
+			DispatchTime::At(10),
+		));
+		let e = BalancesError::<Test>::InsufficientBalance;
+		assert_noop!(Referenda::place_decision_deposit(RuntimeOrigin::signed(10), 0), e);
+
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+		let e = Error::<Test>::HasDeposit;
+		assert_noop!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0), e);
+	});
+}
+
+#[test]
+fn refund_deposit_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let e = Error::<Test>::BadReferendum;
+		assert_noop!(Referenda::refund_decision_deposit(RuntimeOrigin::signed(1), 0), e);
+
+		let h = set_balance_proposal_bounded(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h,
+			DispatchTime::At(10),
+		));
+		let e = Error::<Test>::NoDeposit;
+		assert_noop!(Referenda::refund_decision_deposit(RuntimeOrigin::signed(2), 0), e);
+
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+		let e = Error::<Test>::Unfinished;
+		assert_noop!(Referenda::refund_decision_deposit(RuntimeOrigin::signed(3), 0), e);
+
+		run_to(11);
+		assert_ok!(Referenda::refund_decision_deposit(RuntimeOrigin::signed(3), 0));
+	});
+}
+
+#[test]
+fn refund_submission_deposit_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// refund of non existing referendum fails.
+		let e = Error::<Test>::BadReferendum;
+		assert_noop!(Referenda::refund_submission_deposit(RuntimeOrigin::signed(1), 0), e);
+		// create a referendum.
+		let h = set_balance_proposal_bounded(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h.clone(),
+			DispatchTime::At(10),
+		));
+		// refund of an ongoing referendum fails.
+		let e = Error::<Test>::BadStatus;
+		assert_noop!(Referenda::refund_submission_deposit(RuntimeOrigin::signed(3), 0), e);
+		// cancel referendum.
+		assert_ok!(Referenda::cancel(RuntimeOrigin::signed(4), 0));
+		// refund of canceled referendum works.
+		assert_ok!(Referenda::refund_submission_deposit(RuntimeOrigin::signed(3), 0));
+		// fails if already refunded.
+		let e = Error::<Test>::NoDeposit;
+		assert_noop!(Referenda::refund_submission_deposit(RuntimeOrigin::signed(2), 0), e);
+		// create second referendum.
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h,
+			DispatchTime::At(10),
+		));
+		// refund of a killed referendum fails.
+		assert_ok!(Referenda::kill(RuntimeOrigin::root(), 1));
+		let e = Error::<Test>::NoDeposit;
+		assert_noop!(Referenda::refund_submission_deposit(RuntimeOrigin::signed(2), 0), e);
+	});
+}
+
+#[test]
+fn cancel_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let h = set_balance_proposal_bounded(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h,
+			DispatchTime::At(10),
+		));
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+
+		run_to(8);
+		assert_ok!(Referenda::cancel(RuntimeOrigin::signed(4), 0));
+		assert_ok!(Referenda::refund_decision_deposit(RuntimeOrigin::signed(3), 0));
+		assert_eq!(cancelled_since(0), 8);
+	});
+}
+
+#[test]
+fn cancel_errors_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let h = set_balance_proposal_bounded(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h,
+			DispatchTime::At(10),
+		));
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+		assert_noop!(Referenda::cancel(RuntimeOrigin::signed(1), 0), BadOrigin);
+
+		run_to(11);
+		assert_noop!(Referenda::cancel(RuntimeOrigin::signed(4), 0), Error::<Test>::NotOngoing);
+	});
+}
+
+#[test]
+fn kill_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let h = set_balance_proposal_bounded(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h,
+			DispatchTime::At(10),
+		));
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+
+		run_to(8);
+		assert_ok!(Referenda::kill(RuntimeOrigin::root(), 0));
+		let e = Error::<Test>::NoDeposit;
+		assert_noop!(Referenda::refund_decision_deposit(RuntimeOrigin::signed(3), 0), e);
+		assert_eq!(killed_since(0), 8);
+	});
+}
+
+#[test]
+fn kill_errors_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let h = set_balance_proposal_bounded(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			h,
+			DispatchTime::At(10),
+		));
+		assert_ok!(Referenda::place_decision_deposit(RuntimeOrigin::signed(2), 0));
+		assert_noop!(Referenda::kill(RuntimeOrigin::signed(4), 0), BadOrigin);
+
+		run_to(11);
+		assert_noop!(Referenda::kill(RuntimeOrigin::root(), 0), Error::<Test>::NotOngoing);
+	});
+}
+
+#[test]
+fn set_balance_proposal_is_correctly_filtered_out() {
+	for i in 0..10 {
+		let call = crate::mock::RuntimeCall::decode(&mut &set_balance_proposal(i)[..]).unwrap();
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+	}
+}
+
+#[test]
+fn curve_handles_all_inputs() {
+	let test_curve = Curve::LinearDecreasing {
+		length: Perbill::one(),
+		floor: Perbill::zero(),
+		ceil: Perbill::from_percent(100),
+	};
+
+	let delay = test_curve.delay(Perbill::zero());
+	assert_eq!(delay, Perbill::one());
+
+	let threshold = test_curve.threshold(Perbill::one());
+	assert_eq!(threshold, Perbill::zero());
+}
+
+#[test]
+fn set_metadata_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		use frame_support::traits::Hash as PreimageHash;
+		// invalid preimage hash.
+		let invalid_hash: PreimageHash = [1u8; 32].into();
+		// fails to set metadata for a finished referendum.
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			set_balance_proposal_bounded(1),
+			DispatchTime::At(1),
+		));
+		let index = ReferendumCount::<Test>::get() - 1;
+		assert_ok!(Referenda::kill(RuntimeOrigin::root(), index));
+		assert_noop!(
+			Referenda::set_metadata(RuntimeOrigin::signed(1), index, Some(invalid_hash)),
+			Error::<Test>::NotOngoing,
+		);
+		// no permission to set metadata.
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			set_balance_proposal_bounded(1),
+			DispatchTime::At(1),
+		));
+		let index = ReferendumCount::<Test>::get() - 1;
+		assert_noop!(
+			Referenda::set_metadata(RuntimeOrigin::signed(2), index, Some(invalid_hash)),
+			Error::<Test>::NoPermission,
+		);
+		// preimage does not exist.
+		let index = ReferendumCount::<Test>::get() - 1;
+		assert_noop!(
+			Referenda::set_metadata(RuntimeOrigin::signed(1), index, Some(invalid_hash)),
+			Error::<Test>::PreimageNotExist,
+		);
+		// metadata set.
+		let index = ReferendumCount::<Test>::get() - 1;
+		let hash = note_preimage(1);
+		assert_ok!(Referenda::set_metadata(RuntimeOrigin::signed(1), index, Some(hash)));
+		System::assert_last_event(RuntimeEvent::Referenda(crate::Event::MetadataSet {
+			index,
+			hash,
+		}));
+	});
+}
+
+#[test]
+fn clear_metadata_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let hash = note_preimage(1);
+		assert_ok!(Referenda::submit(
+			RuntimeOrigin::signed(1),
+			Box::new(RawOrigin::Root.into()),
+			set_balance_proposal_bounded(1),
+			DispatchTime::At(1),
+		));
+		let index = ReferendumCount::<Test>::get() - 1;
+		assert_ok!(Referenda::set_metadata(RuntimeOrigin::signed(1), index, Some(hash)));
+		assert_noop!(
+			Referenda::set_metadata(RuntimeOrigin::signed(2), index, None),
+			Error::<Test>::NoPermission,
+		);
+		assert_ok!(Referenda::set_metadata(RuntimeOrigin::signed(1), index, None),);
+		System::assert_last_event(RuntimeEvent::Referenda(crate::Event::MetadataCleared {
+			index,
+			hash,
+		}));
+	});
+}
diff --git a/substrate/frame/referenda/src/types.rs b/substrate/frame/referenda/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ba89383888a7d7062267875095bbe439c01bb36b
--- /dev/null
+++ b/substrate/frame/referenda/src/types.rs
@@ -0,0 +1,672 @@
+// 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.
+
+//! Miscellaneous additional datatypes.
+
+use super::*;
+use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
+use frame_support::{
+	traits::{schedule::v3::Anon, Bounded},
+	Parameter,
+};
+use scale_info::TypeInfo;
+use sp_arithmetic::{Rounding::*, SignedRounding::*};
+use sp_runtime::{FixedI64, PerThing, RuntimeDebug};
+use sp_std::fmt::Debug;
+
+pub type BalanceOf<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+pub type NegativeImbalanceOf<T, I> = <<T as Config<I>>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+pub type CallOf<T, I> = <T as Config<I>>::RuntimeCall;
+pub type BoundedCallOf<T, I> = Bounded<<T as Config<I>>::RuntimeCall>;
+pub type VotesOf<T, I> = <T as Config<I>>::Votes;
+pub type TallyOf<T, I> = <T as Config<I>>::Tally;
+pub type PalletsOriginOf<T> =
+	<<T as frame_system::Config>::RuntimeOrigin as OriginTrait>::PalletsOrigin;
+pub type ReferendumInfoOf<T, I> = ReferendumInfo<
+	TrackIdOf<T, I>,
+	PalletsOriginOf<T>,
+	BlockNumberFor<T>,
+	BoundedCallOf<T, I>,
+	BalanceOf<T, I>,
+	TallyOf<T, I>,
+	<T as frame_system::Config>::AccountId,
+	ScheduleAddressOf<T, I>,
+>;
+pub type ReferendumStatusOf<T, I> = ReferendumStatus<
+	TrackIdOf<T, I>,
+	PalletsOriginOf<T>,
+	BlockNumberFor<T>,
+	BoundedCallOf<T, I>,
+	BalanceOf<T, I>,
+	TallyOf<T, I>,
+	<T as frame_system::Config>::AccountId,
+	ScheduleAddressOf<T, I>,
+>;
+pub type DecidingStatusOf<T> = DecidingStatus<BlockNumberFor<T>>;
+pub type TrackInfoOf<T, I = ()> = TrackInfo<BalanceOf<T, I>, BlockNumberFor<T>>;
+pub type TrackIdOf<T, I> =
+	<<T as Config<I>>::Tracks as TracksInfo<BalanceOf<T, I>, BlockNumberFor<T>>>::Id;
+pub type ScheduleAddressOf<T, I> = <<T as Config<I>>::Scheduler as Anon<
+	BlockNumberFor<T>,
+	CallOf<T, I>,
+	PalletsOriginOf<T>,
+>>::Address;
+
+/// A referendum index.
+pub type ReferendumIndex = u32;
+
+pub trait InsertSorted<T> {
+	/// Inserts an item into a sorted series.
+	///
+	/// Returns `true` if it was inserted, `false` if it would belong beyond the bound of the
+	/// series.
+	fn insert_sorted_by_key<F: FnMut(&T) -> K, K: PartialOrd<K> + Ord>(
+		&mut self,
+		t: T,
+		f: F,
+	) -> bool;
+}
+impl<T: Ord, S: Get<u32>> InsertSorted<T> for BoundedVec<T, S> {
+	fn insert_sorted_by_key<F: FnMut(&T) -> K, K: PartialOrd<K> + Ord>(
+		&mut self,
+		t: T,
+		mut f: F,
+	) -> bool {
+		let index = self.binary_search_by_key::<K, F>(&f(&t), f).unwrap_or_else(|x| x);
+		self.force_insert_keep_right(index, t).is_ok()
+	}
+}
+
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct DecidingStatus<BlockNumber> {
+	/// When this referendum began being "decided". If confirming, then the
+	/// end will actually be delayed until the end of the confirmation period.
+	pub since: BlockNumber,
+	/// If `Some`, then the referendum has entered confirmation stage and will end at
+	/// the block number as long as it doesn't lose its approval in the meantime.
+	pub confirming: Option<BlockNumber>,
+}
+
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct Deposit<AccountId, Balance> {
+	pub who: AccountId,
+	pub amount: Balance,
+}
+
+#[derive(Clone, Encode, TypeInfo)]
+pub struct TrackInfo<Balance, Moment> {
+	/// Name of this track.
+	pub name: &'static str,
+	/// A limit for the number of referenda on this track that can be being decided at once.
+	/// For Root origin this should generally be just one.
+	pub max_deciding: u32,
+	/// Amount that must be placed on deposit before a decision can be made.
+	pub decision_deposit: Balance,
+	/// Amount of time this must be submitted for before a decision can be made.
+	pub prepare_period: Moment,
+	/// Amount of time that a decision may take to be approved prior to cancellation.
+	pub decision_period: Moment,
+	/// Amount of time that the approval criteria must hold before it can be approved.
+	pub confirm_period: Moment,
+	/// Minimum amount of time that an approved proposal must be in the dispatch queue.
+	pub min_enactment_period: Moment,
+	/// Minimum aye votes as percentage of overall conviction-weighted votes needed for
+	/// approval as a function of time into decision period.
+	pub min_approval: Curve,
+	/// Minimum pre-conviction aye-votes ("support") as percentage of overall population that is
+	/// needed for approval as a function of time into decision period.
+	pub min_support: Curve,
+}
+
+/// Information on the voting tracks.
+pub trait TracksInfo<Balance, Moment> {
+	/// The identifier for a track.
+	type Id: Copy + Parameter + Ord + PartialOrd + Send + Sync + 'static + MaxEncodedLen;
+
+	/// The origin type from which a track is implied.
+	type RuntimeOrigin;
+
+	/// Return the array of known tracks and their information.
+	fn tracks() -> &'static [(Self::Id, TrackInfo<Balance, Moment>)];
+
+	/// Determine the voting track for the given `origin`.
+	fn track_for(origin: &Self::RuntimeOrigin) -> Result<Self::Id, ()>;
+
+	/// Return the track info for track `id`, by default this just looks it up in `Self::tracks()`.
+	fn info(id: Self::Id) -> Option<&'static TrackInfo<Balance, Moment>> {
+		Self::tracks().iter().find(|x| x.0 == id).map(|x| &x.1)
+	}
+}
+
+/// Info regarding an ongoing referendum.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ReferendumStatus<
+	TrackId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	RuntimeOrigin: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	Moment: Parameter + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone + EncodeLike,
+	Call: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	Balance: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	Tally: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+> {
+	/// The track of this referendum.
+	pub track: TrackId,
+	/// The origin for this referendum.
+	pub origin: RuntimeOrigin,
+	/// The hash of the proposal up for referendum.
+	pub proposal: Call,
+	/// The time the proposal should be scheduled for enactment.
+	pub enactment: DispatchTime<Moment>,
+	/// The time of submission. Once `UndecidingTimeout` passes, it may be closed by anyone if
+	/// `deciding` is `None`.
+	pub submitted: Moment,
+	/// The deposit reserved for the submission of this referendum.
+	pub submission_deposit: Deposit<AccountId, Balance>,
+	/// The deposit reserved for this referendum to be decided.
+	pub decision_deposit: Option<Deposit<AccountId, Balance>>,
+	/// The status of a decision being made. If `None`, it has not entered the deciding period.
+	pub deciding: Option<DecidingStatus<Moment>>,
+	/// The current tally of votes in this referendum.
+	pub tally: Tally,
+	/// Whether we have been placed in the queue for being decided or not.
+	pub in_queue: bool,
+	/// The next scheduled wake-up, if `Some`.
+	pub alarm: Option<(Moment, ScheduleAddress)>,
+}
+
+/// Info regarding a referendum, present or past.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum ReferendumInfo<
+	TrackId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	RuntimeOrigin: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	Moment: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone + EncodeLike,
+	Call: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	Balance: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	Tally: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+> {
+	/// Referendum has been submitted and is being voted on.
+	Ongoing(
+		ReferendumStatus<
+			TrackId,
+			RuntimeOrigin,
+			Moment,
+			Call,
+			Balance,
+			Tally,
+			AccountId,
+			ScheduleAddress,
+		>,
+	),
+	/// Referendum finished with approval. Submission deposit is held.
+	Approved(Moment, Option<Deposit<AccountId, Balance>>, Option<Deposit<AccountId, Balance>>),
+	/// Referendum finished with rejection. Submission deposit is held.
+	Rejected(Moment, Option<Deposit<AccountId, Balance>>, Option<Deposit<AccountId, Balance>>),
+	/// Referendum finished with cancellation. Submission deposit is held.
+	Cancelled(Moment, Option<Deposit<AccountId, Balance>>, Option<Deposit<AccountId, Balance>>),
+	/// Referendum finished and was never decided. Submission deposit is held.
+	TimedOut(Moment, Option<Deposit<AccountId, Balance>>, Option<Deposit<AccountId, Balance>>),
+	/// Referendum finished with a kill.
+	Killed(Moment),
+}
+
+impl<
+		TrackId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		RuntimeOrigin: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		Moment: Parameter + Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone + EncodeLike,
+		Call: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		Balance: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		Tally: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		AccountId: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+		ScheduleAddress: Eq + PartialEq + Debug + Encode + Decode + TypeInfo + Clone,
+	> ReferendumInfo<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally, AccountId, ScheduleAddress>
+{
+	/// Take the Decision Deposit from `self`, if there is one. Returns an `Err` if `self` is not
+	/// in a valid state for the Decision Deposit to be refunded.
+	pub fn take_decision_deposit(&mut self) -> Result<Option<Deposit<AccountId, Balance>>, ()> {
+		use ReferendumInfo::*;
+		match self {
+			Ongoing(x) if x.decision_deposit.is_none() => Ok(None),
+			// Cannot refund deposit if Ongoing as this breaks assumptions.
+			Ongoing(_) => Err(()),
+			Approved(_, _, d) | Rejected(_, _, d) | TimedOut(_, _, d) | Cancelled(_, _, d) =>
+				Ok(d.take()),
+			Killed(_) => Ok(None),
+		}
+	}
+
+	/// Take the Submission Deposit from `self`, if there is one and it's in a valid state to be
+	/// taken. Returns an `Err` if `self` is not in a valid state for the Submission Deposit to be
+	/// refunded.
+	pub fn take_submission_deposit(&mut self) -> Result<Option<Deposit<AccountId, Balance>>, ()> {
+		use ReferendumInfo::*;
+		match self {
+			// Can only refund deposit if it's appoved or cancelled.
+			Approved(_, s, _) | Cancelled(_, s, _) => Ok(s.take()),
+			// Cannot refund deposit if Ongoing as this breaks assumptions.
+			Ongoing(..) | Rejected(..) | TimedOut(..) | Killed(..) => Err(()),
+		}
+	}
+}
+
+/// Type for describing a curve over the 2-dimensional space of axes between 0-1, as represented
+/// by `(Perbill, Perbill)`.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(not(feature = "std"), derive(RuntimeDebug))]
+pub enum Curve {
+	/// Linear curve starting at `(0, ceil)`, proceeding linearly to `(length, floor)`, then
+	/// remaining at `floor` until the end of the period.
+	LinearDecreasing { length: Perbill, floor: Perbill, ceil: Perbill },
+	/// Stepped curve, beginning at `(0, begin)`, then remaining constant for `period`, at which
+	/// point it steps down to `(period, begin - step)`. It then remains constant for another
+	/// `period` before stepping down to `(period * 2, begin - step * 2)`. This pattern continues
+	/// but the `y` component has a lower limit of `end`.
+	SteppedDecreasing { begin: Perbill, end: Perbill, step: Perbill, period: Perbill },
+	/// A recipocal (`K/(x+S)-T`) curve: `factor` is `K` and `x_offset` is `S`, `y_offset` is `T`.
+	Reciprocal { factor: FixedI64, x_offset: FixedI64, y_offset: FixedI64 },
+}
+
+/// Calculate the quadratic solution for the given curve.
+///
+/// WARNING: This is a `const` function designed for convenient use at build time and
+/// will panic on overflow. Ensure that any inputs are sensible.
+const fn pos_quad_solution(a: FixedI64, b: FixedI64, c: FixedI64) -> FixedI64 {
+	const TWO: FixedI64 = FixedI64::from_u32(2);
+	const FOUR: FixedI64 = FixedI64::from_u32(4);
+	b.neg().add(b.mul(b).sub(FOUR.mul(a).mul(c)).sqrt()).div(TWO.mul(a))
+}
+
+impl Curve {
+	/// Create a `Curve::Linear` instance from a high-level description.
+	///
+	/// WARNING: This is a `const` function designed for convenient use at build time and
+	/// will panic on overflow. Ensure that any inputs are sensible.
+	pub const fn make_linear(length: u128, period: u128, floor: FixedI64, ceil: FixedI64) -> Curve {
+		let length = FixedI64::from_rational(length, period).into_perbill();
+		let floor = floor.into_perbill();
+		let ceil = ceil.into_perbill();
+		Curve::LinearDecreasing { length, floor, ceil }
+	}
+
+	/// Create a `Curve::Reciprocal` instance from a high-level description.
+	///
+	/// WARNING: This is a `const` function designed for convenient use at build time and
+	/// will panic on overflow. Ensure that any inputs are sensible.
+	pub const fn make_reciprocal(
+		delay: u128,
+		period: u128,
+		level: FixedI64,
+		floor: FixedI64,
+		ceil: FixedI64,
+	) -> Curve {
+		let delay = FixedI64::from_rational(delay, period).into_perbill();
+		let mut bounds = (
+			(
+				FixedI64::from_u32(0),
+				Self::reciprocal_from_parts(FixedI64::from_u32(0), floor, ceil),
+				FixedI64::from_inner(i64::max_value()),
+			),
+			(
+				FixedI64::from_u32(1),
+				Self::reciprocal_from_parts(FixedI64::from_u32(1), floor, ceil),
+				FixedI64::from_inner(i64::max_value()),
+			),
+		);
+		const TWO: FixedI64 = FixedI64::from_u32(2);
+		while (bounds.1).0.sub((bounds.0).0).into_inner() > 1 {
+			let factor = (bounds.0).0.add((bounds.1).0).div(TWO);
+			let curve = Self::reciprocal_from_parts(factor, floor, ceil);
+			let curve_level = FixedI64::from_perbill(curve.const_threshold(delay));
+			if curve_level.into_inner() > level.into_inner() {
+				bounds = (bounds.0, (factor, curve, curve_level.sub(level)));
+			} else {
+				bounds = ((factor, curve, level.sub(curve_level)), bounds.1);
+			}
+		}
+		if (bounds.0).2.into_inner() < (bounds.1).2.into_inner() {
+			(bounds.0).1
+		} else {
+			(bounds.1).1
+		}
+	}
+
+	/// Create a `Curve::Reciprocal` instance from basic parameters.
+	///
+	/// WARNING: This is a `const` function designed for convenient use at build time and
+	/// will panic on overflow. Ensure that any inputs are sensible.
+	const fn reciprocal_from_parts(factor: FixedI64, floor: FixedI64, ceil: FixedI64) -> Self {
+		let delta = ceil.sub(floor);
+		let x_offset = pos_quad_solution(delta, delta, factor.neg());
+		let y_offset = floor.sub(factor.div(FixedI64::from_u32(1).add(x_offset)));
+		Curve::Reciprocal { factor, x_offset, y_offset }
+	}
+
+	/// Print some info on the curve.
+	#[cfg(feature = "std")]
+	pub fn info(&self, days: u32, name: impl std::fmt::Display) {
+		let hours = days * 24;
+		println!("Curve {} := {:?}:", name, self);
+		println!("   t + 0h:   {:?}", self.threshold(Perbill::zero()));
+		println!("   t + 1h:   {:?}", self.threshold(Perbill::from_rational(1, hours)));
+		println!("   t + 2h:   {:?}", self.threshold(Perbill::from_rational(2, hours)));
+		println!("   t + 3h:   {:?}", self.threshold(Perbill::from_rational(3, hours)));
+		println!("   t + 6h:   {:?}", self.threshold(Perbill::from_rational(6, hours)));
+		println!("   t + 12h:  {:?}", self.threshold(Perbill::from_rational(12, hours)));
+		println!("   t + 24h:  {:?}", self.threshold(Perbill::from_rational(24, hours)));
+		let mut l = 0;
+		for &(n, d) in [(1, 12), (1, 8), (1, 4), (1, 2), (3, 4), (1, 1)].iter() {
+			let t = days * n / d;
+			if t != l {
+				println!("   t + {}d:   {:?}", t, self.threshold(Perbill::from_rational(t, days)));
+				l = t;
+			}
+		}
+		let t = |p: Perbill| -> std::string::String {
+			if p.is_one() {
+				"never".into()
+			} else {
+				let minutes = p * (hours * 60);
+				if minutes < 60 {
+					format!("{} minutes", minutes)
+				} else if minutes < 8 * 60 && minutes % 60 != 0 {
+					format!("{} hours {} minutes", minutes / 60, minutes % 60)
+				} else if minutes < 72 * 60 {
+					format!("{} hours", minutes / 60)
+				} else if minutes / 60 % 24 == 0 {
+					format!("{} days", minutes / 60 / 24)
+				} else {
+					format!("{} days {} hours", minutes / 60 / 24, minutes / 60 % 24)
+				}
+			}
+		};
+		if self.delay(Perbill::from_percent(49)) < Perbill::one() {
+			println!("   30% threshold:   {}", t(self.delay(Perbill::from_percent(30))));
+			println!("   10% threshold:   {}", t(self.delay(Perbill::from_percent(10))));
+			println!("   3% threshold:    {}", t(self.delay(Perbill::from_percent(3))));
+			println!("   1% threshold:    {}", t(self.delay(Perbill::from_percent(1))));
+			println!("   0.1% threshold:  {}", t(self.delay(Perbill::from_rational(1u32, 1_000))));
+			println!("   0.01% threshold: {}", t(self.delay(Perbill::from_rational(1u32, 10_000))));
+		} else {
+			println!(
+				"   99.9% threshold: {}",
+				t(self.delay(Perbill::from_rational(999u32, 1_000)))
+			);
+			println!("   99% threshold:   {}", t(self.delay(Perbill::from_percent(99))));
+			println!("   95% threshold:   {}", t(self.delay(Perbill::from_percent(95))));
+			println!("   90% threshold:   {}", t(self.delay(Perbill::from_percent(90))));
+			println!("   75% threshold:   {}", t(self.delay(Perbill::from_percent(75))));
+			println!("   60% threshold:   {}", t(self.delay(Perbill::from_percent(60))));
+		}
+	}
+
+	/// Determine the `y` value for the given `x` value.
+	pub fn threshold(&self, x: Perbill) -> Perbill {
+		match self {
+			Self::LinearDecreasing { length, floor, ceil } =>
+				*ceil - (x.min(*length).saturating_div(*length, Down) * (*ceil - *floor)),
+			Self::SteppedDecreasing { begin, end, step, period } =>
+				(*begin - (step.int_mul(x.int_div(*period))).min(*begin)).max(*end),
+			Self::Reciprocal { factor, x_offset, y_offset } => factor
+				.checked_rounding_div(FixedI64::from(x) + *x_offset, Low)
+				.map(|yp| (yp + *y_offset).into_clamped_perthing())
+				.unwrap_or_else(Perbill::one),
+		}
+	}
+
+	/// Determine the `y` value for the given `x` value.
+	///
+	/// This is a partial implementation designed only for use in const functions.
+	const fn const_threshold(&self, x: Perbill) -> Perbill {
+		match self {
+			Self::Reciprocal { factor, x_offset, y_offset } => {
+				match factor.checked_rounding_div(FixedI64::from_perbill(x).add(*x_offset), Low) {
+					Some(yp) => (yp.add(*y_offset)).into_perbill(),
+					None => Perbill::one(),
+				}
+			},
+			_ => panic!("const_threshold cannot be used on this curve"),
+		}
+	}
+
+	/// Determine the smallest `x` value such that `passing` returns `true` when passed along with
+	/// the given `y` value.
+	///
+	/// If `passing` never returns `true` for any value of `x` when paired with `y`, then
+	/// `Perbill::one` may be returned.
+	///
+	/// ```nocompile
+	/// let c = Curve::LinearDecreasing { begin: Perbill::one(), delta: Perbill::one() };
+	/// //      ^^^ Can be any curve.
+	/// let y = Perbill::from_percent(50);
+	/// //      ^^^ Can be any value.
+	/// let x = c.delay(y);
+	/// assert!(c.passing(x, y));
+	/// ```
+	pub fn delay(&self, y: Perbill) -> Perbill {
+		match self {
+			Self::LinearDecreasing { length, floor, ceil } =>
+				if y < *floor {
+					Perbill::one()
+				} else if y > *ceil {
+					Perbill::zero()
+				} else {
+					(*ceil - y).saturating_div(*ceil - *floor, Up).saturating_mul(*length)
+				},
+			Self::SteppedDecreasing { begin, end, step, period } =>
+				if y < *end {
+					Perbill::one()
+				} else {
+					period.int_mul((*begin - y.min(*begin) + step.less_epsilon()).int_div(*step))
+				},
+			Self::Reciprocal { factor, x_offset, y_offset } => {
+				let y = FixedI64::from(y);
+				let maybe_term = factor.checked_rounding_div(y - *y_offset, High);
+				maybe_term
+					.and_then(|term| (term - *x_offset).try_into_perthing().ok())
+					.unwrap_or_else(Perbill::one)
+			},
+		}
+	}
+
+	/// Return `true` iff the `y` value is greater than the curve at the `x`.
+	pub fn passing(&self, x: Perbill, y: Perbill) -> bool {
+		y >= self.threshold(x)
+	}
+}
+
+#[cfg(feature = "std")]
+impl Debug for Curve {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		match self {
+			Self::LinearDecreasing { length, floor, ceil } => {
+				write!(
+					f,
+					"Linear[(0%, {:?}) -> ({:?}, {:?}) -> (100%, {:?})]",
+					ceil, length, floor, floor,
+				)
+			},
+			Self::SteppedDecreasing { begin, end, step, period } => {
+				write!(
+					f,
+					"Stepped[(0%, {:?}) -> (100%, {:?}) by ({:?}, {:?})]",
+					begin, end, period, step,
+				)
+			},
+			Self::Reciprocal { factor, x_offset, y_offset } => {
+				write!(
+					f,
+					"Reciprocal[factor of {:?}, x_offset of {:?}, y_offset of {:?}]",
+					factor, x_offset, y_offset,
+				)
+			},
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use frame_support::traits::ConstU32;
+	use sp_runtime::PerThing;
+
+	const fn percent(x: u128) -> FixedI64 {
+		FixedI64::from_rational(x, 100)
+	}
+
+	const TIP_APP: Curve = Curve::make_linear(10, 28, percent(50), percent(100));
+	const TIP_SUP: Curve = Curve::make_reciprocal(1, 28, percent(4), percent(0), percent(50));
+	const ROOT_APP: Curve = Curve::make_reciprocal(4, 28, percent(80), percent(50), percent(100));
+	const ROOT_SUP: Curve = Curve::make_linear(28, 28, percent(0), percent(50));
+	const WHITE_APP: Curve =
+		Curve::make_reciprocal(16, 28 * 24, percent(96), percent(50), percent(100));
+	const WHITE_SUP: Curve = Curve::make_reciprocal(1, 28, percent(20), percent(10), percent(50));
+	const SMALL_APP: Curve = Curve::make_linear(10, 28, percent(50), percent(100));
+	const SMALL_SUP: Curve = Curve::make_reciprocal(8, 28, percent(1), percent(0), percent(50));
+	const MID_APP: Curve = Curve::make_linear(17, 28, percent(50), percent(100));
+	const MID_SUP: Curve = Curve::make_reciprocal(12, 28, percent(1), percent(0), percent(50));
+	const BIG_APP: Curve = Curve::make_linear(23, 28, percent(50), percent(100));
+	const BIG_SUP: Curve = Curve::make_reciprocal(16, 28, percent(1), percent(0), percent(50));
+	const HUGE_APP: Curve = Curve::make_linear(28, 28, percent(50), percent(100));
+	const HUGE_SUP: Curve = Curve::make_reciprocal(20, 28, percent(1), percent(0), percent(50));
+	const PARAM_APP: Curve = Curve::make_reciprocal(4, 28, percent(80), percent(50), percent(100));
+	const PARAM_SUP: Curve = Curve::make_reciprocal(7, 28, percent(10), percent(0), percent(50));
+	const ADMIN_APP: Curve = Curve::make_linear(17, 28, percent(50), percent(100));
+	const ADMIN_SUP: Curve = Curve::make_reciprocal(12, 28, percent(1), percent(0), percent(50));
+
+	// TODO: ceil for linear.
+
+	#[test]
+	#[should_panic]
+	fn check_curves() {
+		TIP_APP.info(28u32, "Tip Approval");
+		TIP_SUP.info(28u32, "Tip Support");
+		ROOT_APP.info(28u32, "Root Approval");
+		ROOT_SUP.info(28u32, "Root Support");
+		WHITE_APP.info(28u32, "Whitelist Approval");
+		WHITE_SUP.info(28u32, "Whitelist Support");
+		SMALL_APP.info(28u32, "Small Spend Approval");
+		SMALL_SUP.info(28u32, "Small Spend Support");
+		MID_APP.info(28u32, "Mid Spend Approval");
+		MID_SUP.info(28u32, "Mid Spend Support");
+		BIG_APP.info(28u32, "Big Spend Approval");
+		BIG_SUP.info(28u32, "Big Spend Support");
+		HUGE_APP.info(28u32, "Huge Spend Approval");
+		HUGE_SUP.info(28u32, "Huge Spend Support");
+		PARAM_APP.info(28u32, "Mid-tier Parameter Change Approval");
+		PARAM_SUP.info(28u32, "Mid-tier Parameter Change Support");
+		ADMIN_APP.info(28u32, "Admin (e.g. Cancel Slash) Approval");
+		ADMIN_SUP.info(28u32, "Admin (e.g. Cancel Slash) Support");
+		assert!(false);
+	}
+
+	#[test]
+	fn insert_sorted_works() {
+		let mut b: BoundedVec<u32, ConstU32<6>> = vec![20, 30, 40].try_into().unwrap();
+		assert!(b.insert_sorted_by_key(10, |&x| x));
+		assert_eq!(&b[..], &[10, 20, 30, 40][..]);
+
+		assert!(b.insert_sorted_by_key(60, |&x| x));
+		assert_eq!(&b[..], &[10, 20, 30, 40, 60][..]);
+
+		assert!(b.insert_sorted_by_key(50, |&x| x));
+		assert_eq!(&b[..], &[10, 20, 30, 40, 50, 60][..]);
+
+		assert!(!b.insert_sorted_by_key(9, |&x| x));
+		assert_eq!(&b[..], &[10, 20, 30, 40, 50, 60][..]);
+
+		assert!(b.insert_sorted_by_key(11, |&x| x));
+		assert_eq!(&b[..], &[11, 20, 30, 40, 50, 60][..]);
+
+		assert!(b.insert_sorted_by_key(21, |&x| x));
+		assert_eq!(&b[..], &[20, 21, 30, 40, 50, 60][..]);
+
+		assert!(b.insert_sorted_by_key(61, |&x| x));
+		assert_eq!(&b[..], &[21, 30, 40, 50, 60, 61][..]);
+
+		assert!(b.insert_sorted_by_key(51, |&x| x));
+		assert_eq!(&b[..], &[30, 40, 50, 51, 60, 61][..]);
+	}
+
+	#[test]
+	fn translated_reciprocal_works() {
+		let c: Curve = Curve::Reciprocal {
+			factor: FixedI64::from_float(0.03125),
+			x_offset: FixedI64::from_float(0.0363306838226),
+			y_offset: FixedI64::from_float(0.139845532427),
+		};
+		c.info(28u32, "Test");
+
+		for i in 0..9_696_969u32 {
+			let query = Perbill::from_rational(i, 9_696_969);
+			// Determine the nearest point in time when the query will be above threshold.
+			let delay_needed = c.delay(query);
+			// Ensure that it actually does pass at that time, or that it will never pass.
+			assert!(delay_needed.is_one() || c.passing(delay_needed, query));
+		}
+	}
+
+	#[test]
+	fn stepped_decreasing_works() {
+		fn pc(x: u32) -> Perbill {
+			Perbill::from_percent(x)
+		}
+
+		let c =
+			Curve::SteppedDecreasing { begin: pc(80), end: pc(30), step: pc(10), period: pc(15) };
+
+		for i in 0..9_696_969u32 {
+			let query = Perbill::from_rational(i, 9_696_969);
+			// Determine the nearest point in time when the query will be above threshold.
+			let delay_needed = c.delay(query);
+			// Ensure that it actually does pass at that time, or that it will never pass.
+			assert!(delay_needed.is_one() || c.passing(delay_needed, query));
+		}
+
+		assert_eq!(c.threshold(pc(0)), pc(80));
+		assert_eq!(c.threshold(pc(15).less_epsilon()), pc(80));
+		assert_eq!(c.threshold(pc(15)), pc(70));
+		assert_eq!(c.threshold(pc(30).less_epsilon()), pc(70));
+		assert_eq!(c.threshold(pc(30)), pc(60));
+		assert_eq!(c.threshold(pc(45).less_epsilon()), pc(60));
+		assert_eq!(c.threshold(pc(45)), pc(50));
+		assert_eq!(c.threshold(pc(60).less_epsilon()), pc(50));
+		assert_eq!(c.threshold(pc(60)), pc(40));
+		assert_eq!(c.threshold(pc(75).less_epsilon()), pc(40));
+		assert_eq!(c.threshold(pc(75)), pc(30));
+		assert_eq!(c.threshold(pc(100)), pc(30));
+
+		assert_eq!(c.delay(pc(100)), pc(0));
+		assert_eq!(c.delay(pc(80)), pc(0));
+		assert_eq!(c.delay(pc(80).less_epsilon()), pc(15));
+		assert_eq!(c.delay(pc(70)), pc(15));
+		assert_eq!(c.delay(pc(70).less_epsilon()), pc(30));
+		assert_eq!(c.delay(pc(60)), pc(30));
+		assert_eq!(c.delay(pc(60).less_epsilon()), pc(45));
+		assert_eq!(c.delay(pc(50)), pc(45));
+		assert_eq!(c.delay(pc(50).less_epsilon()), pc(60));
+		assert_eq!(c.delay(pc(40)), pc(60));
+		assert_eq!(c.delay(pc(40).less_epsilon()), pc(75));
+		assert_eq!(c.delay(pc(30)), pc(75));
+		assert_eq!(c.delay(pc(30).less_epsilon()), pc(100));
+		assert_eq!(c.delay(pc(0)), pc(100));
+	}
+}
diff --git a/substrate/frame/referenda/src/weights.rs b/substrate/frame/referenda/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b89379b311da6ac8cd10fd84a127e3693ab00de
--- /dev/null
+++ b/substrate/frame/referenda/src/weights.rs
@@ -0,0 +1,926 @@
+// 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.
+
+//! Autogenerated weights for pallet_referenda
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_referenda
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/referenda/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_referenda.
+pub trait WeightInfo {
+	fn submit() -> Weight;
+	fn place_decision_deposit_preparing() -> Weight;
+	fn place_decision_deposit_queued() -> Weight;
+	fn place_decision_deposit_not_queued() -> Weight;
+	fn place_decision_deposit_passing() -> Weight;
+	fn place_decision_deposit_failing() -> Weight;
+	fn refund_decision_deposit() -> Weight;
+	fn refund_submission_deposit() -> Weight;
+	fn cancel() -> Weight;
+	fn kill() -> Weight;
+	fn one_fewer_deciding_queue_empty() -> Weight;
+	fn one_fewer_deciding_failing() -> Weight;
+	fn one_fewer_deciding_passing() -> Weight;
+	fn nudge_referendum_requeued_insertion() -> Weight;
+	fn nudge_referendum_requeued_slide() -> Weight;
+	fn nudge_referendum_queued() -> Weight;
+	fn nudge_referendum_not_queued() -> Weight;
+	fn nudge_referendum_no_deposit() -> Weight;
+	fn nudge_referendum_preparing() -> Weight;
+	fn nudge_referendum_timed_out() -> Weight;
+	fn nudge_referendum_begin_deciding_failing() -> Weight;
+	fn nudge_referendum_begin_deciding_passing() -> Weight;
+	fn nudge_referendum_begin_confirming() -> Weight;
+	fn nudge_referendum_end_confirming() -> Weight;
+	fn nudge_referendum_continue_not_confirming() -> Weight;
+	fn nudge_referendum_continue_confirming() -> Weight;
+	fn nudge_referendum_approved() -> Weight;
+	fn nudge_referendum_rejected() -> Weight;
+	fn set_some_metadata() -> Weight;
+	fn clear_metadata() -> Weight;
+}
+
+/// Weights for pallet_referenda using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Referenda ReferendumCount (r:1 w:1)
+	/// Proof: Referenda ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:0 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn submit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `220`
+		//  Estimated: `110487`
+		// Minimum execution time: 40_175_000 picoseconds.
+		Weight::from_parts(41_107_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_preparing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `473`
+		//  Estimated: `219984`
+		// Minimum execution time: 50_922_000 picoseconds.
+		Weight::from_parts(52_179_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3260`
+		//  Estimated: `110487`
+		// Minimum execution time: 69_559_000 picoseconds.
+		Weight::from_parts(72_143_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_not_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3280`
+		//  Estimated: `110487`
+		// Minimum execution time: 68_833_000 picoseconds.
+		Weight::from_parts(70_987_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_passing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `473`
+		//  Estimated: `219984`
+		// Minimum execution time: 61_794_000 picoseconds.
+		Weight::from_parts(62_846_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_failing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `473`
+		//  Estimated: `219984`
+		// Minimum execution time: 58_664_000 picoseconds.
+		Weight::from_parts(60_195_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn refund_decision_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3831`
+		// Minimum execution time: 30_850_000 picoseconds.
+		Weight::from_parts(32_130_000, 3831)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn refund_submission_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `341`
+		//  Estimated: `3831`
+		// Minimum execution time: 30_747_000 picoseconds.
+		Weight::from_parts(32_196_000, 3831)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn cancel() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `219984`
+		// Minimum execution time: 36_139_000 picoseconds.
+		Weight::from_parts(37_252_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Referenda MetadataOf (r:1 w:0)
+	/// Proof: Referenda MetadataOf (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn kill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `622`
+		//  Estimated: `219984`
+		// Minimum execution time: 80_862_000 picoseconds.
+		Weight::from_parts(83_045_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda TrackQueue (r:1 w:0)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	fn one_fewer_deciding_queue_empty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `5477`
+		// Minimum execution time: 10_136_000 picoseconds.
+		Weight::from_parts(10_638_000, 5477)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn one_fewer_deciding_failing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3150`
+		//  Estimated: `110487`
+		// Minimum execution time: 52_022_000 picoseconds.
+		Weight::from_parts(53_910_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn one_fewer_deciding_passing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3150`
+		//  Estimated: `110487`
+		// Minimum execution time: 53_683_000 picoseconds.
+		Weight::from_parts(55_707_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_requeued_insertion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3011`
+		//  Estimated: `5477`
+		// Minimum execution time: 24_043_000 picoseconds.
+		Weight::from_parts(24_512_000, 5477)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_requeued_slide() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3011`
+		//  Estimated: `5477`
+		// Minimum execution time: 23_588_000 picoseconds.
+		Weight::from_parts(24_422_000, 5477)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3015`
+		//  Estimated: `5477`
+		// Minimum execution time: 31_443_000 picoseconds.
+		Weight::from_parts(32_725_000, 5477)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_not_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3035`
+		//  Estimated: `5477`
+		// Minimum execution time: 30_319_000 picoseconds.
+		Weight::from_parts(31_652_000, 5477)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_no_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `333`
+		//  Estimated: `110487`
+		// Minimum execution time: 23_062_000 picoseconds.
+		Weight::from_parts(23_614_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_preparing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `110487`
+		// Minimum execution time: 23_537_000 picoseconds.
+		Weight::from_parts(24_267_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn nudge_referendum_timed_out() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `278`
+		//  Estimated: `3831`
+		// Minimum execution time: 16_388_000 picoseconds.
+		Weight::from_parts(16_676_000, 3831)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_begin_deciding_failing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `110487`
+		// Minimum execution time: 32_801_000 picoseconds.
+		Weight::from_parts(34_053_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_begin_deciding_passing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `110487`
+		// Minimum execution time: 35_704_000 picoseconds.
+		Weight::from_parts(36_451_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_begin_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `434`
+		//  Estimated: `110487`
+		// Minimum execution time: 29_151_000 picoseconds.
+		Weight::from_parts(30_055_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_end_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `417`
+		//  Estimated: `110487`
+		// Minimum execution time: 29_265_000 picoseconds.
+		Weight::from_parts(30_213_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_continue_not_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `434`
+		//  Estimated: `110487`
+		// Minimum execution time: 27_760_000 picoseconds.
+		Weight::from_parts(28_381_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_continue_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `438`
+		//  Estimated: `110487`
+		// Minimum execution time: 25_464_000 picoseconds.
+		Weight::from_parts(26_348_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Scheduler Lookup (r:1 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn nudge_referendum_approved() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `438`
+		//  Estimated: `219984`
+		// Minimum execution time: 42_629_000 picoseconds.
+		Weight::from_parts(43_732_000, 219984)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_rejected() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `434`
+		//  Estimated: `110487`
+		// Minimum execution time: 30_015_000 picoseconds.
+		Weight::from_parts(30_827_000, 110487)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Referenda MetadataOf (r:0 w:1)
+	/// Proof: Referenda MetadataOf (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn set_some_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `422`
+		//  Estimated: `3831`
+		// Minimum execution time: 19_901_000 picoseconds.
+		Weight::from_parts(20_681_000, 3831)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda MetadataOf (r:1 w:1)
+	/// Proof: Referenda MetadataOf (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `355`
+		//  Estimated: `3831`
+		// Minimum execution time: 17_323_000 picoseconds.
+		Weight::from_parts(18_227_000, 3831)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Referenda ReferendumCount (r:1 w:1)
+	/// Proof: Referenda ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:0 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn submit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `220`
+		//  Estimated: `110487`
+		// Minimum execution time: 40_175_000 picoseconds.
+		Weight::from_parts(41_107_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_preparing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `473`
+		//  Estimated: `219984`
+		// Minimum execution time: 50_922_000 picoseconds.
+		Weight::from_parts(52_179_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3260`
+		//  Estimated: `110487`
+		// Minimum execution time: 69_559_000 picoseconds.
+		Weight::from_parts(72_143_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_not_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3280`
+		//  Estimated: `110487`
+		// Minimum execution time: 68_833_000 picoseconds.
+		Weight::from_parts(70_987_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_passing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `473`
+		//  Estimated: `219984`
+		// Minimum execution time: 61_794_000 picoseconds.
+		Weight::from_parts(62_846_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn place_decision_deposit_failing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `473`
+		//  Estimated: `219984`
+		// Minimum execution time: 58_664_000 picoseconds.
+		Weight::from_parts(60_195_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn refund_decision_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `351`
+		//  Estimated: `3831`
+		// Minimum execution time: 30_850_000 picoseconds.
+		Weight::from_parts(32_130_000, 3831)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn refund_submission_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `341`
+		//  Estimated: `3831`
+		// Minimum execution time: 30_747_000 picoseconds.
+		Weight::from_parts(32_196_000, 3831)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn cancel() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `219984`
+		// Minimum execution time: 36_139_000 picoseconds.
+		Weight::from_parts(37_252_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Referenda MetadataOf (r:1 w:0)
+	/// Proof: Referenda MetadataOf (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn kill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `622`
+		//  Estimated: `219984`
+		// Minimum execution time: 80_862_000 picoseconds.
+		Weight::from_parts(83_045_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda TrackQueue (r:1 w:0)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	fn one_fewer_deciding_queue_empty() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `174`
+		//  Estimated: `5477`
+		// Minimum execution time: 10_136_000 picoseconds.
+		Weight::from_parts(10_638_000, 5477)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn one_fewer_deciding_failing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3150`
+		//  Estimated: `110487`
+		// Minimum execution time: 52_022_000 picoseconds.
+		Weight::from_parts(53_910_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn one_fewer_deciding_passing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3150`
+		//  Estimated: `110487`
+		// Minimum execution time: 53_683_000 picoseconds.
+		Weight::from_parts(55_707_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_requeued_insertion() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3011`
+		//  Estimated: `5477`
+		// Minimum execution time: 24_043_000 picoseconds.
+		Weight::from_parts(24_512_000, 5477)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_requeued_slide() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3011`
+		//  Estimated: `5477`
+		// Minimum execution time: 23_588_000 picoseconds.
+		Weight::from_parts(24_422_000, 5477)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3015`
+		//  Estimated: `5477`
+		// Minimum execution time: 31_443_000 picoseconds.
+		Weight::from_parts(32_725_000, 5477)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:0)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Referenda TrackQueue (r:1 w:1)
+	/// Proof: Referenda TrackQueue (max_values: None, max_size: Some(2012), added: 4487, mode: MaxEncodedLen)
+	fn nudge_referendum_not_queued() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3035`
+		//  Estimated: `5477`
+		// Minimum execution time: 30_319_000 picoseconds.
+		Weight::from_parts(31_652_000, 5477)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_no_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `333`
+		//  Estimated: `110487`
+		// Minimum execution time: 23_062_000 picoseconds.
+		Weight::from_parts(23_614_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_preparing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `110487`
+		// Minimum execution time: 23_537_000 picoseconds.
+		Weight::from_parts(24_267_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	fn nudge_referendum_timed_out() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `278`
+		//  Estimated: `3831`
+		// Minimum execution time: 16_388_000 picoseconds.
+		Weight::from_parts(16_676_000, 3831)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_begin_deciding_failing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `110487`
+		// Minimum execution time: 32_801_000 picoseconds.
+		Weight::from_parts(34_053_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda DecidingCount (r:1 w:1)
+	/// Proof: Referenda DecidingCount (max_values: None, max_size: Some(14), added: 2489, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_begin_deciding_passing() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381`
+		//  Estimated: `110487`
+		// Minimum execution time: 35_704_000 picoseconds.
+		Weight::from_parts(36_451_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_begin_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `434`
+		//  Estimated: `110487`
+		// Minimum execution time: 29_151_000 picoseconds.
+		Weight::from_parts(30_055_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_end_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `417`
+		//  Estimated: `110487`
+		// Minimum execution time: 29_265_000 picoseconds.
+		Weight::from_parts(30_213_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_continue_not_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `434`
+		//  Estimated: `110487`
+		// Minimum execution time: 27_760_000 picoseconds.
+		Weight::from_parts(28_381_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_continue_confirming() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `438`
+		//  Estimated: `110487`
+		// Minimum execution time: 25_464_000 picoseconds.
+		Weight::from_parts(26_348_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:2 w:2)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Scheduler Lookup (r:1 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn nudge_referendum_approved() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `438`
+		//  Estimated: `219984`
+		// Minimum execution time: 42_629_000 picoseconds.
+		Weight::from_parts(43_732_000, 219984)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:1)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	fn nudge_referendum_rejected() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `434`
+		//  Estimated: `110487`
+		// Minimum execution time: 30_015_000 picoseconds.
+		Weight::from_parts(30_827_000, 110487)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:0)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// Storage: Referenda MetadataOf (r:0 w:1)
+	/// Proof: Referenda MetadataOf (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn set_some_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `422`
+		//  Estimated: `3831`
+		// Minimum execution time: 19_901_000 picoseconds.
+		Weight::from_parts(20_681_000, 3831)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Referenda ReferendumInfoFor (r:1 w:0)
+	/// Proof: Referenda ReferendumInfoFor (max_values: None, max_size: Some(366), added: 2841, mode: MaxEncodedLen)
+	/// Storage: Referenda MetadataOf (r:1 w:1)
+	/// Proof: Referenda MetadataOf (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `355`
+		//  Estimated: `3831`
+		// Minimum execution time: 17_323_000 picoseconds.
+		Weight::from_parts(18_227_000, 3831)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/remark/Cargo.toml b/substrate/frame/remark/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..47078bddeb5ba15744e7dee0e16d2b258a8c498e
--- /dev/null
+++ b/substrate/frame/remark/Cargo.toml
@@ -0,0 +1,54 @@
+[package]
+name = "pallet-remark"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Remark storage pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/remark/README.md b/substrate/frame/remark/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f2341d6a0eaec45287957feab73a0199ddc17dff
--- /dev/null
+++ b/substrate/frame/remark/README.md
@@ -0,0 +1,6 @@
+# Remark Storage Pallet
+
+Allows storing arbitrary data off chain. 
+
+
+License: Apache-2.0
diff --git a/substrate/frame/remark/src/benchmarking.rs b/substrate/frame/remark/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..831946834963f96748b683c01a9673bdb83b5e11
--- /dev/null
+++ b/substrate/frame/remark/src/benchmarking.rs
@@ -0,0 +1,47 @@
+// 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.
+
+//! Benchmarks for remarks pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{benchmarks, whitelisted_caller};
+use frame_system::{EventRecord, Pallet as System, RawOrigin};
+use sp_std::*;
+
+#[cfg(test)]
+use crate::Pallet as Remark;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = System::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	let EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+benchmarks! {
+	store {
+		let l in 1 .. 1024*1024;
+		let caller: T::AccountId = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller.clone()), vec![0u8; l as usize])
+	verify {
+		assert_last_event::<T>(Event::Stored { sender: caller, content_hash: sp_io::hashing::blake2_256(&vec![0u8; l as usize]).into() }.into());
+	}
+
+	impl_benchmark_test_suite!(Remark, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/remark/src/lib.rs b/substrate/frame/remark/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8ca3cd395afb5063b6ac70e0c7b6412240e4faa2
--- /dev/null
+++ b/substrate/frame/remark/src/lib.rs
@@ -0,0 +1,85 @@
+// 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.
+
+//! Remark storage pallet. Indexes remarks and stores them off chain.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+pub mod weights;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+use sp_std::prelude::*;
+
+// Re-export pallet items so that they can be accessed from the crate namespace.
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Attempting to store empty data.
+		Empty,
+		/// Attempted to call `store` outside of block execution.
+		BadContext,
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Index and store data off chain.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::store(remark.len() as u32))]
+		pub fn store(origin: OriginFor<T>, remark: Vec<u8>) -> DispatchResultWithPostInfo {
+			ensure!(!remark.is_empty(), Error::<T>::Empty);
+			let sender = ensure_signed(origin)?;
+			let content_hash = sp_io::hashing::blake2_256(&remark);
+			let extrinsic_index = <frame_system::Pallet<T>>::extrinsic_index()
+				.ok_or_else(|| Error::<T>::BadContext)?;
+			sp_io::transaction_index::index(extrinsic_index, remark.len() as u32, content_hash);
+			Self::deposit_event(Event::Stored { sender, content_hash: content_hash.into() });
+			Ok(().into())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Stored data off chain.
+		Stored { sender: T::AccountId, content_hash: sp_core::H256 },
+	}
+}
diff --git a/substrate/frame/remark/src/mock.rs b/substrate/frame/remark/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e597a1ca4dfe80d09ee7b853a9cc22cf882d4531
--- /dev/null
+++ b/substrate/frame/remark/src/mock.rs
@@ -0,0 +1,73 @@
+// 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.
+
+//! Test environment for remarks pallet.
+
+use crate as pallet_remark;
+use frame_support::traits::{ConstU16, ConstU32, ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+pub type Block = frame_system::mocking::MockBlock<Test>;
+
+// 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>},
+		Remark: pallet_remark::{ Pallet, Call, Event<T> },
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	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 Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ConstU16<42>;
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl pallet_remark::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig { system: Default::default() }.build_storage().unwrap();
+	t.into()
+}
diff --git a/substrate/frame/remark/src/tests.rs b/substrate/frame/remark/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51fb32b60fc1fa88bd7cf76c36927a1f9179079b
--- /dev/null
+++ b/substrate/frame/remark/src/tests.rs
@@ -0,0 +1,58 @@
+// 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 remarks pallet.
+
+use super::{Error, Event, Pallet as Remark};
+use crate::mock::*;
+use frame_support::{assert_noop, assert_ok};
+use frame_system::RawOrigin;
+
+#[test]
+fn generates_event() {
+	new_test_ext().execute_with(|| {
+		let caller = 1;
+		let data = vec![0u8; 100];
+		System::set_block_number(System::block_number() + 1); //otherwise event won't be registered.
+		assert_ok!(Remark::<Test>::store(RawOrigin::Signed(caller).into(), data.clone(),));
+		let events = System::events();
+		// this one we create as we expect it
+		let system_event: <Test as frame_system::Config>::RuntimeEvent = Event::Stored {
+			content_hash: sp_io::hashing::blake2_256(&data).into(),
+			sender: caller,
+		}
+		.into();
+		// this one we actually go into the system pallet and get the last event
+		// because we know its there from block +1
+		let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+		assert_eq!(event, &system_event);
+	});
+}
+
+#[test]
+fn does_not_store_empty() {
+	new_test_ext().execute_with(|| {
+		let caller = 1;
+		let data = vec![];
+		System::set_block_number(System::block_number() + 1); //otherwise event won't be registered.
+		assert_noop!(
+			Remark::<Test>::store(RawOrigin::Signed(caller).into(), data.clone(),),
+			Error::<Test>::Empty
+		);
+		assert!(System::events().is_empty());
+	});
+}
diff --git a/substrate/frame/remark/src/weights.rs b/substrate/frame/remark/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..46475db163ffd5827486f8ad562c2f3ecc6deb3d
--- /dev/null
+++ b/substrate/frame/remark/src/weights.rs
@@ -0,0 +1,85 @@
+// 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.
+
+//! Autogenerated weights for pallet_remark
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_remark
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/remark/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_remark.
+pub trait WeightInfo {
+	fn store(l: u32, ) -> Weight;
+}
+
+/// Weights for pallet_remark using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// The range of component `l` is `[1, 1048576]`.
+	fn store(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_471_000 picoseconds.
+		Weight::from_parts(8_586_000, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_359, 0).saturating_mul(l.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// The range of component `l` is `[1, 1048576]`.
+	fn store(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_471_000 picoseconds.
+		Weight::from_parts(8_586_000, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_359, 0).saturating_mul(l.into()))
+	}
+}
diff --git a/substrate/frame/root-offences/Cargo.toml b/substrate/frame/root-offences/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e8f38f8aca34326486a33f82c72f07cda8fefd29
--- /dev/null
+++ b/substrate/frame/root-offences/Cargo.toml
@@ -0,0 +1,75 @@
+[package]
+name = "pallet-root-offences"
+version = "1.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME root offences pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+pallet-session = { version = "4.0.0-dev", features = [ "historical" ], path = "../../frame/session", default-features = false }
+pallet-staking = { version = "4.0.0-dev", default-features = false, path = "../../frame/staking" }
+
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../timestamp" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../staking/reward-curve" }
+
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
+
+[features]
+runtime-benchmarks = [
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-session/try-runtime",
+	"pallet-staking/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-session/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
diff --git a/substrate/frame/root-offences/README.md b/substrate/frame/root-offences/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c582158721816d6e16ee3d2f1a93d5daa555a1da
--- /dev/null
+++ b/substrate/frame/root-offences/README.md
@@ -0,0 +1,5 @@
+# Root Offences Pallet
+
+Pallet that allows the root to create an offence.
+
+NOTE: This pallet should only be used for testing purposes.
\ No newline at end of file
diff --git a/substrate/frame/root-offences/src/lib.rs b/substrate/frame/root-offences/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a93e7ff8487180eaa84f260272ec763b4756a00d
--- /dev/null
+++ b/substrate/frame/root-offences/src/lib.rs
@@ -0,0 +1,131 @@
+// 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.
+
+//! # Root Offences Pallet
+//! Pallet that allows the root to create an offence.
+//!
+//! NOTE: This pallet should be used for testing purposes.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+use pallet_session::historical::IdentificationTuple;
+use pallet_staking::{BalanceOf, Exposure, ExposureOf, Pallet as Staking};
+use sp_runtime::Perbill;
+use sp_staking::offence::{DisableStrategy, OnOffenceHandler};
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config:
+		frame_system::Config
+		+ pallet_staking::Config
+		+ pallet_session::Config<ValidatorId = <Self as frame_system::Config>::AccountId>
+		+ pallet_session::historical::Config<
+			FullIdentification = Exposure<
+				<Self as frame_system::Config>::AccountId,
+				BalanceOf<Self>,
+			>,
+			FullIdentificationOf = ExposureOf<Self>,
+		>
+	{
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// An offence was created by root.
+		OffenceCreated { offenders: Vec<(T::AccountId, Perbill)> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Failed to get the active era from the staking pallet.
+		FailedToGetActiveEra,
+	}
+
+	type OffenceDetails<T> = sp_staking::offence::OffenceDetails<
+		<T as frame_system::Config>::AccountId,
+		IdentificationTuple<T>,
+	>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Allows the `root`, for example sudo to create an offence.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::DbWeight::get().reads(2))]
+		pub fn create_offence(
+			origin: OriginFor<T>,
+			offenders: Vec<(T::AccountId, Perbill)>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			let slash_fraction =
+				offenders.clone().into_iter().map(|(_, fraction)| fraction).collect::<Vec<_>>();
+			let offence_details = Self::get_offence_details(offenders.clone())?;
+
+			Self::submit_offence(&offence_details, &slash_fraction);
+			Self::deposit_event(Event::OffenceCreated { offenders });
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// Returns a vector of offenders that are going to be slashed.
+		fn get_offence_details(
+			offenders: Vec<(T::AccountId, Perbill)>,
+		) -> Result<Vec<OffenceDetails<T>>, DispatchError> {
+			let now = Staking::<T>::active_era()
+				.map(|e| e.index)
+				.ok_or(Error::<T>::FailedToGetActiveEra)?;
+
+			Ok(offenders
+				.clone()
+				.into_iter()
+				.map(|(o, _)| OffenceDetails::<T> {
+					offender: (o.clone(), Staking::<T>::eras_stakers(now, o)),
+					reporters: vec![],
+				})
+				.collect())
+		}
+
+		/// Submits the offence by calling the `on_offence` function.
+		fn submit_offence(offenders: &[OffenceDetails<T>], slash_fraction: &[Perbill]) {
+			let session_index = <pallet_session::Pallet<T> as frame_support::traits::ValidatorSet<T::AccountId>>::session_index();
+
+			<pallet_staking::Pallet<T> as OnOffenceHandler<
+				T::AccountId,
+				IdentificationTuple<T>,
+				Weight,
+			>>::on_offence(&offenders, &slash_fraction, session_index, DisableStrategy::WhenSlashed);
+		}
+	}
+}
diff --git a/substrate/frame/root-offences/src/mock.rs b/substrate/frame/root-offences/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2d2a5476149f692dabd4bf2e87fcc9778e0cf72f
--- /dev/null
+++ b/substrate/frame/root-offences/src/mock.rs
@@ -0,0 +1,349 @@
+// 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 crate as root_offences;
+
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, SequentialPhragmen,
+};
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64, Hooks, OneSessionHandler},
+};
+use pallet_staking::StakerStatus;
+use sp_core::H256;
+use sp_runtime::{
+	curve::PiecewiseLinear,
+	testing::UintAuthorityId,
+	traits::{BlakeTwo256, IdentityLookup, Zero},
+	BuildStorage,
+};
+use sp_staking::{EraIndex, SessionIndex};
+use sp_std::collections::btree_map::BTreeMap;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+type AccountId = u64;
+type Balance = u64;
+type BlockNumber = u64;
+
+pub const INIT_TIMESTAMP: u64 = 30_000;
+pub const BLOCK_TIME: u64 = 1000;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+		RootOffences: root_offences::{Pallet, Call, Storage, Event<T>},
+		Historical: pallet_session::historical::{Pallet, Storage},
+	}
+);
+
+/// Another session handler struct to test on_disabled.
+pub struct OtherSessionHandler;
+impl OneSessionHandler<AccountId> for OtherSessionHandler {
+	type Key = UintAuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(_: I)
+	where
+		I: Iterator<Item = (&'a AccountId, Self::Key)>,
+		AccountId: 'a,
+	{
+	}
+
+	fn on_new_session<'a, I: 'a>(_: bool, _: I, _: I)
+	where
+		I: Iterator<Item = (&'a AccountId, Self::Key)>,
+		AccountId: 'a,
+	{
+	}
+
+	fn on_disabled(_validator_index: u32) {}
+}
+
+impl sp_runtime::BoundToRuntimeAppPublic for OtherSessionHandler {
+	type Public = UintAuthorityId;
+}
+
+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 = 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>;
+}
+
+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 MaxHolds = ();
+}
+
+pallet_staking_reward_curve::build! {
+	const REWARD_CURVE: PiecewiseLinear<'static> = curve!(
+		min_inflation: 0_025_000u64,
+		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 static ElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Test;
+	type Solver = SequentialPhragmen<AccountId, Perbill>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = ConstU32<100>;
+	type Bounds = ElectionsBounds;
+}
+
+parameter_types! {
+	pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE;
+	pub static Offset: BlockNumber = 0;
+	pub const Period: BlockNumber = 1;
+	pub static SessionsPerEra: SessionIndex = 3;
+	pub static SlashDeferDuration: EraIndex = 0;
+	pub const BondingDuration: EraIndex = 3;
+	pub static LedgerSlashPerEra: (BalanceOf<Test>, BTreeMap<EraIndex, BalanceOf<Test>>) = (Zero::zero(), BTreeMap::new());
+	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(75);
+}
+
+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>;
+	type BondingDuration = BondingDuration;
+	type SessionInterface = Self;
+	type EraPayout = pallet_staking::ConvertCurve<RewardCurve>;
+	type NextNewSession = Session;
+	type MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+	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 VoterList = pallet_staking::UseNominatorsAndValidatorsMap<Self>;
+	type EventListeners = ();
+	type BenchmarkingConfig = pallet_staking::TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Test {
+	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Test>;
+}
+
+sp_runtime::impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub other: OtherSessionHandler,
+	}
+}
+
+impl pallet_session::Config for Test {
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Test, Staking>;
+	type Keys = SessionKeys;
+	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+	type SessionHandler = (OtherSessionHandler,);
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = AccountId;
+	type ValidatorIdOf = pallet_staking::StashOf<Test>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+	type WeightInfo = ();
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+pub struct ExtBuilder {
+	validator_count: u32,
+	minimum_validator_count: u32,
+	invulnerables: Vec<AccountId>,
+	balance_factor: Balance,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			validator_count: 2,
+			minimum_validator_count: 0,
+			invulnerables: vec![],
+			balance_factor: 1,
+		}
+	}
+}
+
+impl ExtBuilder {
+	fn build(self) -> sp_io::TestExternalities {
+		let mut storage = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+		pallet_balances::GenesisConfig::<Test> {
+			balances: vec![
+				// controllers (still used in some tests. Soon to be deprecated).
+				(10, self.balance_factor * 50),
+				(20, self.balance_factor * 50),
+				(30, self.balance_factor * 50),
+				(40, self.balance_factor * 50),
+				// stashes
+				(11, self.balance_factor * 1000),
+				(21, self.balance_factor * 1000),
+				(31, self.balance_factor * 500),
+				(41, self.balance_factor * 1000),
+			],
+		}
+		.assimilate_storage(&mut storage)
+		.unwrap();
+
+		let stakers = vec![
+			// (stash, ctrl, stake, status)
+			// these two will be elected in the default test where we elect 2.
+			(11, 11, 1000, StakerStatus::<AccountId>::Validator),
+			(21, 21, 1000, StakerStatus::<AccountId>::Validator),
+			// a loser validator
+			(31, 31, 500, StakerStatus::<AccountId>::Validator),
+			// an idle validator
+			(41, 41, 1000, StakerStatus::<AccountId>::Idle),
+		];
+
+		let _ = pallet_staking::GenesisConfig::<Test> {
+			stakers: stakers.clone(),
+			..Default::default()
+		};
+
+		let _ = pallet_staking::GenesisConfig::<Test> {
+			stakers: stakers.clone(),
+			validator_count: self.validator_count,
+			minimum_validator_count: self.minimum_validator_count,
+			invulnerables: self.invulnerables,
+			slash_reward_fraction: Perbill::from_percent(10),
+			..Default::default()
+		}
+		.assimilate_storage(&mut storage);
+
+		let _ = pallet_session::GenesisConfig::<Test> {
+			keys: stakers
+				.into_iter()
+				.map(|(id, ..)| (id, id, SessionKeys { other: id.into() }))
+				.collect(),
+		}
+		.assimilate_storage(&mut storage);
+
+		storage.into()
+	}
+
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		let mut ext = self.build();
+		ext.execute_with(test);
+	}
+}
+
+/// Progresses from the current block number (whatever that may be) to the `P * session_index + 1`.
+pub(crate) fn start_session(session_index: SessionIndex) {
+	let end: u64 = if Offset::get().is_zero() {
+		(session_index as u64) * Period::get()
+	} else {
+		Offset::get() + (session_index.saturating_sub(1) as u64) * Period::get()
+	};
+	run_to_block(end);
+	// session must have progressed properly.
+	assert_eq!(
+		Session::current_index(),
+		session_index,
+		"current session index = {}, expected = {}",
+		Session::current_index(),
+		session_index,
+	);
+}
+
+/// Progress to the given block, triggering session and era changes as we progress.
+///
+/// This will finalize the previous block, initialize up to the given block, essentially simulating
+/// a block import/propose process where we first initialize the block, then execute some stuff (not
+/// in the function), and then finalize the block.
+pub(crate) fn run_to_block(n: BlockNumber) {
+	Staking::on_finalize(System::block_number());
+	for b in (System::block_number() + 1)..=n {
+		System::set_block_number(b);
+		Session::on_initialize(b);
+		<Staking as Hooks<u64>>::on_initialize(b);
+		Timestamp::set_timestamp(System::block_number() * BLOCK_TIME + INIT_TIMESTAMP);
+		if b != n {
+			Staking::on_finalize(System::block_number());
+		}
+	}
+}
+
+pub(crate) fn active_era() -> EraIndex {
+	Staking::active_era().unwrap().index
+}
diff --git a/substrate/frame/root-offences/src/tests.rs b/substrate/frame/root-offences/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f96884d750da8a7d101b650caf4607afbc51bd35
--- /dev/null
+++ b/substrate/frame/root-offences/src/tests.rs
@@ -0,0 +1,94 @@
+// 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::{assert_err, assert_ok};
+use mock::{active_era, start_session, Balances, ExtBuilder, RootOffences, RuntimeOrigin, System};
+
+#[test]
+fn create_offence_fails_given_signed_origin() {
+	use sp_runtime::traits::BadOrigin;
+	ExtBuilder::default().build_and_execute(|| {
+		let offenders = (&[]).to_vec();
+		assert_err!(RootOffences::create_offence(RuntimeOrigin::signed(1), offenders), BadOrigin);
+	})
+}
+
+#[test]
+fn create_offence_works_given_root_origin() {
+	ExtBuilder::default().build_and_execute(|| {
+		start_session(1);
+
+		assert_eq!(active_era(), 0);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+
+		let offenders = [(11, Perbill::from_percent(50))].to_vec();
+		assert_ok!(RootOffences::create_offence(RuntimeOrigin::root(), offenders.clone()));
+
+		System::assert_last_event(Event::OffenceCreated { offenders }.into());
+		// the slash should be applied right away.
+		assert_eq!(Balances::free_balance(11), 500);
+
+		// the other validator should keep their balance, because we only created
+		// an offences for the first validator.
+		assert_eq!(Balances::free_balance(21), 1000);
+	})
+}
+
+#[test]
+fn create_offence_wont_slash_non_active_validators() {
+	ExtBuilder::default().build_and_execute(|| {
+		start_session(1);
+
+		assert_eq!(active_era(), 0);
+
+		// 31 is not an active validator.
+		assert_eq!(Balances::free_balance(31), 500);
+
+		let offenders = [(31, Perbill::from_percent(20)), (11, Perbill::from_percent(20))].to_vec();
+		assert_ok!(RootOffences::create_offence(RuntimeOrigin::root(), offenders.clone()));
+
+		System::assert_last_event(Event::OffenceCreated { offenders }.into());
+
+		// so 31 didn't get slashed.
+		assert_eq!(Balances::free_balance(31), 500);
+
+		// but 11 is an active validator so they got slashed.
+		assert_eq!(Balances::free_balance(11), 800);
+	})
+}
+
+#[test]
+fn create_offence_wont_slash_idle() {
+	ExtBuilder::default().build_and_execute(|| {
+		start_session(1);
+
+		assert_eq!(active_era(), 0);
+
+		// 41 is idle.
+		assert_eq!(Balances::free_balance(41), 1000);
+
+		let offenders = [(41, Perbill::from_percent(50))].to_vec();
+		assert_ok!(RootOffences::create_offence(RuntimeOrigin::root(), offenders.clone()));
+
+		System::assert_last_event(Event::OffenceCreated { offenders }.into());
+
+		// 41 didn't get slashed.
+		assert_eq!(Balances::free_balance(41), 1000);
+	})
+}
diff --git a/substrate/frame/root-testing/Cargo.toml b/substrate/frame/root-testing/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b76cb5a059a3491e636e94fe97ff1a8cf2dd8313
--- /dev/null
+++ b/substrate/frame/root-testing/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "pallet-root-testing"
+version = "1.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME root testing pallet"
+readme = "README.md"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
diff --git a/substrate/frame/root-testing/README.md b/substrate/frame/root-testing/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..637430445a22f6046f6a20bd6fc8ba58901373bc
--- /dev/null
+++ b/substrate/frame/root-testing/README.md
@@ -0,0 +1,5 @@
+# Root Testing Pallet
+
+Pallet that contains extrinsics that can be usefull in testing.
+
+NOTE: This pallet should only be used for testing purposes and should not be used in production runtimes!
\ No newline at end of file
diff --git a/substrate/frame/root-testing/src/lib.rs b/substrate/frame/root-testing/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e04c7bfa13d26f5e40a8d5625d234c0a7ae93de7
--- /dev/null
+++ b/substrate/frame/root-testing/src/lib.rs
@@ -0,0 +1,54 @@
+// 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.
+
+//! # Root Testing Pallet
+//!
+//! Pallet that contains extrinsics that can be usefull in testing.
+//!
+//! NOTE: This pallet should only be used for testing purposes and should not be used in production
+//! runtimes!
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::dispatch::DispatchResult;
+use sp_runtime::Perbill;
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// A dispatch that will fill the block weight up to the given ratio.
+		#[pallet::call_index(0)]
+		#[pallet::weight(*_ratio * T::BlockWeights::get().max_block)]
+		pub fn fill_block(origin: OriginFor<T>, _ratio: Perbill) -> DispatchResult {
+			ensure_root(origin)?;
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/safe-mode/Cargo.toml b/substrate/frame/safe-mode/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ca04a3e1b93d3d685ca4808c7da68a196beec17d
--- /dev/null
+++ b/substrate/frame/safe-mode/Cargo.toml
@@ -0,0 +1,67 @@
+[package]
+name = "pallet-safe-mode"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME safe-mode pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances", default-features = false, optional = true }
+pallet-utility = { version = "4.0.0-dev", path = "../utility", default-features = false, optional = true  }
+pallet-proxy = { version = "4.0.0-dev", path = "../proxy", default-features = false, optional = true  }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-utility = { version = "4.0.0-dev", path = "../utility" }
+pallet-proxy = { version = "4.0.0-dev", path = "../proxy" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances?/std",
+	"pallet-proxy?/std",
+	"pallet-utility?/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-proxy/runtime-benchmarks",
+	"pallet-utility/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances?/try-runtime",
+	"pallet-proxy?/try-runtime",
+	"pallet-utility?/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/safe-mode/src/benchmarking.rs b/substrate/frame/safe-mode/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..566150e982afca39748f987e135222b43bc7b1a1
--- /dev/null
+++ b/substrate/frame/safe-mode/src/benchmarking.rs
@@ -0,0 +1,236 @@
+// 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(feature = "runtime-benchmarks")]
+
+use super::{Pallet as SafeMode, *};
+
+use frame_benchmarking::v2::*;
+use frame_support::traits::{fungible::Mutate as FunMutate, UnfilteredDispatchable};
+use frame_system::{Pallet as System, RawOrigin};
+use sp_runtime::traits::{Bounded, One, Zero};
+
+#[benchmarks(where T::Currency: FunMutate<T::AccountId>)]
+mod benchmarks {
+	use super::*;
+
+	/// `on_initialize` doing nothing.
+	#[benchmark]
+	fn on_initialize_noop() {
+		#[block]
+		{
+			SafeMode::<T>::on_initialize(1u32.into());
+		}
+	}
+
+	/// `on_initialize` exiting since the until block is in the past.
+	#[benchmark]
+	fn on_initialize_exit() {
+		EnteredUntil::<T>::put(&BlockNumberFor::<T>::zero());
+		assert!(SafeMode::<T>::is_entered());
+
+		#[block]
+		{
+			SafeMode::<T>::on_initialize(1u32.into());
+		}
+
+		assert!(!SafeMode::<T>::is_entered());
+	}
+
+	/// Permissionless enter - if configured.
+	#[benchmark]
+	fn enter() -> Result<(), BenchmarkError> {
+		T::EnterDepositAmount::get().ok_or_else(|| BenchmarkError::Weightless)?;
+
+		let caller: T::AccountId = whitelisted_caller();
+		let origin = RawOrigin::Signed(caller.clone());
+		T::Currency::set_balance(&caller, init_bal::<T>());
+
+		#[extrinsic_call]
+		_(origin);
+
+		assert_eq!(
+			EnteredUntil::<T>::get().unwrap(),
+			System::<T>::block_number() + T::EnterDuration::get()
+		);
+		Ok(())
+	}
+
+	/// Forceful enter - if configured.
+	#[benchmark]
+	fn force_enter() -> Result<(), BenchmarkError> {
+		let force_origin =
+			T::ForceEnterOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+
+		let duration = T::ForceEnterOrigin::ensure_origin(force_origin.clone()).unwrap();
+
+		#[extrinsic_call]
+		_(force_origin as T::RuntimeOrigin);
+
+		assert_eq!(EnteredUntil::<T>::get().unwrap(), System::<T>::block_number() + duration);
+		Ok(())
+	}
+
+	/// Permissionless extend - if configured.
+	#[benchmark]
+	fn extend() -> Result<(), BenchmarkError> {
+		T::ExtendDepositAmount::get().ok_or_else(|| BenchmarkError::Weightless)?;
+
+		let alice: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(&alice, init_bal::<T>());
+
+		System::<T>::set_block_number(1u32.into());
+		assert!(SafeMode::<T>::do_enter(None, 1u32.into()).is_ok());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(alice));
+
+		assert_eq!(
+			EnteredUntil::<T>::get().unwrap(),
+			System::<T>::block_number() + 1u32.into() + T::ExtendDuration::get()
+		);
+		Ok(())
+	}
+
+	/// Forceful extend - if configured.
+	#[benchmark]
+	fn force_extend() -> Result<(), BenchmarkError> {
+		let force_origin = T::ForceExtendOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		System::<T>::set_block_number(1u32.into());
+		assert!(SafeMode::<T>::do_enter(None, 1u32.into()).is_ok());
+
+		let duration = T::ForceExtendOrigin::ensure_origin(force_origin.clone()).unwrap();
+		let call = Call::<T>::force_extend {};
+
+		#[block]
+		{
+			call.dispatch_bypass_filter(force_origin)?;
+		}
+
+		assert_eq!(
+			EnteredUntil::<T>::get().unwrap(),
+			System::<T>::block_number() + 1u32.into() + duration
+		);
+		Ok(())
+	}
+
+	/// Forceful exit - if configured.
+	#[benchmark]
+	fn force_exit() -> Result<(), BenchmarkError> {
+		let force_origin =
+			T::ForceExitOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		assert!(SafeMode::<T>::do_enter(None, 1u32.into()).is_ok());
+
+		#[extrinsic_call]
+		_(force_origin as T::RuntimeOrigin);
+
+		assert_eq!(EnteredUntil::<T>::get(), None);
+		Ok(())
+	}
+
+	/// Permissionless release of a deposit - if configured.
+	#[benchmark]
+	fn release_deposit() -> Result<(), BenchmarkError> {
+		let delay = T::ReleaseDelay::get().ok_or_else(|| BenchmarkError::Weightless)?;
+
+		let alice: T::AccountId = whitelisted_caller();
+		let origin = RawOrigin::Signed(alice.clone());
+
+		T::Currency::set_balance(&alice, init_bal::<T>());
+		// Mock the storage. This is needed in case the `EnterDepositAmount` is zero.
+		let block: BlockNumberFor<T> = 1u32.into();
+		let bal: BalanceOf<T> = 1u32.into();
+		Deposits::<T>::insert(&alice, &block, &bal);
+		T::Currency::hold(&HoldReason::EnterOrExtend.into(), &alice, bal)?;
+		EnteredUntil::<T>::put(&block);
+		assert!(SafeMode::<T>::do_exit(ExitReason::Force).is_ok());
+
+		System::<T>::set_block_number(delay + One::one() + 2u32.into());
+		System::<T>::on_initialize(System::<T>::block_number());
+		SafeMode::<T>::on_initialize(System::<T>::block_number());
+
+		#[extrinsic_call]
+		_(origin, alice.clone(), 1u32.into());
+
+		assert!(!Deposits::<T>::contains_key(&alice, &block));
+		assert_eq!(T::Currency::balance(&alice), init_bal::<T>());
+		Ok(())
+	}
+
+	/// Forceful release of a deposit - if configured.
+	#[benchmark]
+	fn force_release_deposit() -> Result<(), BenchmarkError> {
+		let force_origin = T::ForceDepositOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let alice: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(&alice, init_bal::<T>());
+
+		// Mock the storage. This is needed in case the `EnterDepositAmount` is zero.
+		let block: BlockNumberFor<T> = 1u32.into();
+		let bal: BalanceOf<T> = 1u32.into();
+		Deposits::<T>::insert(&alice, &block, &bal);
+		T::Currency::hold(&&HoldReason::EnterOrExtend.into(), &alice, bal)?;
+		EnteredUntil::<T>::put(&block);
+
+		assert_eq!(T::Currency::balance(&alice), init_bal::<T>() - 1u32.into());
+		assert!(SafeMode::<T>::do_exit(ExitReason::Force).is_ok());
+
+		System::<T>::set_block_number(System::<T>::block_number() + One::one());
+		System::<T>::on_initialize(System::<T>::block_number());
+		SafeMode::<T>::on_initialize(System::<T>::block_number());
+
+		#[extrinsic_call]
+		_(force_origin as T::RuntimeOrigin, alice.clone(), block);
+
+		assert!(!Deposits::<T>::contains_key(&alice, block));
+		assert_eq!(T::Currency::balance(&alice), init_bal::<T>());
+		Ok(())
+	}
+
+	#[benchmark]
+	fn force_slash_deposit() -> Result<(), BenchmarkError> {
+		let force_origin = T::ForceDepositOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+
+		let alice: T::AccountId = whitelisted_caller();
+		T::Currency::set_balance(&alice, init_bal::<T>());
+
+		// Mock the storage. This is needed in case the `EnterDepositAmount` is zero.
+		let block: BlockNumberFor<T> = 1u32.into();
+		let bal: BalanceOf<T> = 1u32.into();
+		Deposits::<T>::insert(&alice, &block, &bal);
+		T::Currency::hold(&&HoldReason::EnterOrExtend.into(), &alice, bal)?;
+		EnteredUntil::<T>::put(&block);
+		assert!(SafeMode::<T>::do_exit(ExitReason::Force).is_ok());
+
+		#[extrinsic_call]
+		_(force_origin as T::RuntimeOrigin, alice.clone(), block);
+
+		assert!(!Deposits::<T>::contains_key(&alice, block));
+		assert_eq!(T::Currency::balance(&alice), init_bal::<T>() - 1u32.into());
+		Ok(())
+	}
+
+	fn init_bal<T: Config>() -> BalanceOf<T> {
+		BalanceOf::<T>::max_value() / 10u32.into()
+	}
+
+	impl_benchmark_test_suite!(SafeMode, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/safe-mode/src/lib.rs b/substrate/frame/safe-mode/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ff045b964afbb6bec04075314d53832451e7472c
--- /dev/null
+++ b/substrate/frame/safe-mode/src/lib.rs
@@ -0,0 +1,596 @@
+// 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)]
+#![deny(rustdoc::broken_intra_doc_links)]
+
+mod benchmarking;
+pub mod mock;
+mod tests;
+pub mod weights;
+
+use frame_support::{
+	defensive_assert,
+	pallet_prelude::*,
+	traits::{
+		fungible::{
+			hold::{Inspect as FunHoldInspect, Mutate as FunHoldMutate},
+			Inspect as FunInspect,
+		},
+		tokens::{Fortitude, Precision},
+		CallMetadata, Contains, Defensive, GetCallMetadata, PalletInfoAccess, SafeModeNotify,
+	},
+	weights::Weight,
+	DefaultNoBound,
+};
+use frame_system::pallet_prelude::*;
+use sp_arithmetic::traits::Zero;
+use sp_runtime::traits::Saturating;
+use sp_std::{convert::TryInto, prelude::*};
+
+pub use pallet::*;
+pub use weights::*;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as FunInspect<<T as frame_system::Config>::AccountId>>::Balance;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(PhantomData<T>);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Currency type for this pallet, used for Deposits.
+		type Currency: FunHoldInspect<Self::AccountId>
+			+ FunHoldMutate<Self::AccountId, Reason = Self::RuntimeHoldReason>;
+
+		/// The hold reason when reserving funds for entering or extending the safe-mode.
+		type RuntimeHoldReason: From<HoldReason>;
+
+		/// Contains all runtime calls in any pallet that can be dispatched even while the safe-mode
+		/// is entered.
+		///
+		/// The safe-mode pallet cannot disable it's own calls, and does not need to be explicitly
+		/// added here.
+		type WhitelistedCalls: Contains<Self::RuntimeCall>;
+
+		/// For how many blocks the safe-mode will be entered by [`Pallet::enter`].
+		#[pallet::constant]
+		type EnterDuration: Get<BlockNumberFor<Self>>;
+
+		/// For how many blocks the safe-mode can be extended by each [`Pallet::extend`] call.
+		///
+		/// This does not impose a hard limit as the safe-mode can be extended multiple times.
+		#[pallet::constant]
+		type ExtendDuration: Get<BlockNumberFor<Self>>;
+
+		/// The amount that will be reserved upon calling [`Pallet::enter`].
+		///
+		/// `None` disallows permissionlessly enabling the safe-mode and is a sane default.
+		#[pallet::constant]
+		type EnterDepositAmount: Get<Option<BalanceOf<Self>>>;
+
+		/// The amount that will be reserved upon calling [`Pallet::extend`].
+		///
+		/// `None` disallows permissionlessly extending the safe-mode and is a sane default.
+		#[pallet::constant]
+		type ExtendDepositAmount: Get<Option<BalanceOf<Self>>>;
+
+		/// The origin that may call [`Pallet::force_enter`].
+		///
+		/// The `Success` value is the number of blocks that this origin can enter safe-mode for.
+		type ForceEnterOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = BlockNumberFor<Self>>;
+
+		/// The origin that may call [`Pallet::force_extend`].
+		///
+		/// The `Success` value is the number of blocks that this origin can extend the safe-mode.
+		type ForceExtendOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = BlockNumberFor<Self>>;
+
+		/// The origin that may call [`Pallet::force_enter`].
+		type ForceExitOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The only origin that can force to release or slash a deposit.
+		type ForceDepositOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Notifies external logic when the safe-mode is being entered or exited.
+		type Notify: SafeModeNotify;
+
+		/// The minimal duration a deposit will remain reserved after safe-mode is entered or
+		/// extended, unless [`Pallet::force_release_deposit`] is successfully called sooner.
+		///
+		/// Every deposit is tied to a specific activation or extension, thus each deposit can be
+		/// released independently after the delay for it has passed.
+		///
+		/// `None` disallows permissionlessly releasing the safe-mode deposits and is a sane
+		/// default.
+		#[pallet::constant]
+		type ReleaseDelay: Get<Option<BlockNumberFor<Self>>>;
+
+		// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The safe-mode is (already or still) entered.
+		Entered,
+
+		/// The safe-mode is (already or still) exited.
+		Exited,
+
+		/// This functionality of the pallet is disabled by the configuration.
+		NotConfigured,
+
+		/// There is no balance reserved.
+		NoDeposit,
+
+		/// The account already has a deposit reserved and can therefore not enter or extend again.
+		AlreadyDeposited,
+
+		/// This deposit cannot be released yet.
+		CannotReleaseYet,
+
+		/// An error from the underlying `Currency`.
+		CurrencyError,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// The safe-mode was entered until inclusively this block.
+		Entered { until: BlockNumberFor<T> },
+
+		/// The safe-mode was extended until inclusively this block.
+		Extended { until: BlockNumberFor<T> },
+
+		/// Exited the safe-mode for a specific reason.
+		Exited { reason: ExitReason },
+
+		/// An account reserved funds for either entering or extending the safe-mode.
+		DepositPlaced { account: T::AccountId, amount: BalanceOf<T> },
+
+		/// An account had a reserve released that was reserved.
+		DepositReleased { account: T::AccountId, amount: BalanceOf<T> },
+
+		/// An account had reserve slashed that was reserved.
+		DepositSlashed { account: T::AccountId, amount: BalanceOf<T> },
+
+		/// Could not hold funds for entering or extending the safe-mode.
+		///
+		/// This error comes from the underlying `Currency`.
+		CannotDeposit,
+
+		/// Could not release funds for entering or extending the safe-mode.
+		///
+		/// This error comes from the underlying `Currency`.
+		CannotRelease,
+	}
+
+	/// The reason why the safe-mode was deactivated.
+	#[derive(Copy, Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+	pub enum ExitReason {
+		/// The safe-mode was automatically deactivated after it's duration ran out.
+		Timeout,
+
+		/// The safe-mode was forcefully deactivated by [`Pallet::force_exit`].
+		Force,
+	}
+
+	/// Contains the last block number that the safe-mode will remain entered in.
+	///
+	///  Set to `None` when safe-mode is exited.
+	///
+	/// Safe-mode is automatically exited when the current block number exceeds this value.
+	#[pallet::storage]
+	pub type EnteredUntil<T: Config> = StorageValue<_, BlockNumberFor<T>, OptionQuery>;
+
+	/// Holds the reserve that was taken from an account at a specific block number.
+	///
+	/// This helps governance to have an overview of outstanding deposits that should be returned or
+	/// slashed.
+	#[pallet::storage]
+	pub type Deposits<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Twox64Concat,
+		BlockNumberFor<T>,
+		BalanceOf<T>,
+		OptionQuery,
+	>;
+
+	/// Configure the initial state of this pallet in the genesis block.
+	#[pallet::genesis_config]
+	#[derive(DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub entered_until: Option<BlockNumberFor<T>>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			if let Some(block) = self.entered_until {
+				EnteredUntil::<T>::put(block);
+			}
+		}
+	}
+
+	/// A reason for the pallet placing a hold on funds.
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		/// Funds are held for entering or extending the safe-mode.
+		#[codec(index = 0)]
+		EnterOrExtend,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Enter safe-mode permissionlessly for [`Config::EnterDuration`] blocks.
+		///
+		/// Reserves [`Config::EnterDepositAmount`] from the caller's account.
+		/// Emits an [`Event::Entered`] event on success.
+		/// Errors with [`Error::Entered`] if the safe-mode is already entered.
+		/// Errors with [`Error::NotConfigured`] if the deposit amount is `None`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::enter())]
+		pub fn enter(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			Self::do_enter(Some(who), T::EnterDuration::get()).map_err(Into::into)
+		}
+
+		/// Enter safe-mode by force for a per-origin configured number of blocks.
+		///
+		/// Emits an [`Event::Entered`] event on success.
+		/// Errors with [`Error::Entered`] if the safe-mode is already entered.
+		///
+		/// Can only be called by the [`Config::ForceEnterOrigin`] origin.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::force_enter())]
+		pub fn force_enter(origin: OriginFor<T>) -> DispatchResult {
+			let duration = T::ForceEnterOrigin::ensure_origin(origin)?;
+
+			Self::do_enter(None, duration).map_err(Into::into)
+		}
+
+		/// Extend the safe-mode permissionlessly for [`Config::ExtendDuration`] blocks.
+		///
+		/// This accumulates on top of the current remaining duration.
+		/// Reserves [`Config::ExtendDepositAmount`] from the caller's account.
+		/// Emits an [`Event::Extended`] event on success.
+		/// Errors with [`Error::Exited`] if the safe-mode is entered.
+		/// Errors with [`Error::NotConfigured`] if the deposit amount is `None`.
+		///
+		/// This may be called by any signed origin with [`Config::ExtendDepositAmount`] free
+		/// currency to reserve. This call can be disabled for all origins by configuring
+		/// [`Config::ExtendDepositAmount`] to `None`.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::extend())]
+		pub fn extend(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			Self::do_extend(Some(who), T::ExtendDuration::get()).map_err(Into::into)
+		}
+
+		/// Extend the safe-mode by force for a per-origin configured number of blocks.
+		///
+		/// Emits an [`Event::Extended`] event on success.
+		/// Errors with [`Error::Exited`] if the safe-mode is inactive.
+		///
+		/// Can only be called by the [`Config::ForceExtendOrigin`] origin.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::force_extend())]
+		pub fn force_extend(origin: OriginFor<T>) -> DispatchResult {
+			let duration = T::ForceExtendOrigin::ensure_origin(origin)?;
+
+			Self::do_extend(None, duration).map_err(Into::into)
+		}
+
+		/// Exit safe-mode by force.
+		///
+		/// Emits an [`Event::Exited`] with [`ExitReason::Force`] event on success.
+		/// Errors with [`Error::Exited`] if the safe-mode is inactive.
+		///
+		/// Note: `safe-mode` will be automatically deactivated by [`Pallet::on_initialize`] hook
+		/// after the block height is greater than the [`EnteredUntil`] storage item.
+		/// Emits an [`Event::Exited`] with [`ExitReason::Timeout`] event when deactivated in the
+		/// hook.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::force_exit())]
+		pub fn force_exit(origin: OriginFor<T>) -> DispatchResult {
+			T::ForceExitOrigin::ensure_origin(origin)?;
+
+			Self::do_exit(ExitReason::Force).map_err(Into::into)
+		}
+
+		/// Slash a deposit for an account that entered or extended safe-mode at a given
+		/// historical block.
+		///
+		/// This can only be called while safe-mode is entered.
+		///
+		/// Emits a [`Event::DepositSlashed`] event on success.
+		/// Errors with [`Error::Entered`] if safe-mode is entered.
+		///
+		/// Can only be called by the [`Config::ForceDepositOrigin`] origin.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::force_slash_deposit())]
+		pub fn force_slash_deposit(
+			origin: OriginFor<T>,
+			account: T::AccountId,
+			block: BlockNumberFor<T>,
+		) -> DispatchResult {
+			T::ForceDepositOrigin::ensure_origin(origin)?;
+
+			Self::do_force_deposit(account, block).map_err(Into::into)
+		}
+
+		/// Permissionlessly release a deposit for an account that entered safe-mode at a
+		/// given historical block.
+		///
+		/// The call can be completely disabled by setting [`Config::ReleaseDelay`] to `None`.
+		/// This cannot be called while safe-mode is entered and not until
+		/// [`Config::ReleaseDelay`] blocks have passed since safe-mode was entered.
+		///
+		/// Emits a [`Event::DepositReleased`] event on success.
+		/// Errors with [`Error::Entered`] if the safe-mode is entered.
+		/// Errors with [`Error::CannotReleaseYet`] if [`Config::ReleaseDelay`] block have not
+		/// passed since safe-mode was entered. Errors with [`Error::NoDeposit`] if the payee has no
+		/// reserved currency at the block specified.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::release_deposit())]
+		pub fn release_deposit(
+			origin: OriginFor<T>,
+			account: T::AccountId,
+			block: BlockNumberFor<T>,
+		) -> DispatchResult {
+			ensure_signed(origin)?;
+
+			Self::do_release(false, account, block).map_err(Into::into)
+		}
+
+		/// Force to release a deposit for an account that entered safe-mode at a given
+		/// historical block.
+		///
+		/// This can be called while safe-mode is still entered.
+		///
+		/// Emits a [`Event::DepositReleased`] event on success.
+		/// Errors with [`Error::Entered`] if safe-mode is entered.
+		/// Errors with [`Error::NoDeposit`] if the payee has no reserved currency at the
+		/// specified block.
+		///
+		/// Can only be called by the [`Config::ForceDepositOrigin`] origin.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::force_release_deposit())]
+		pub fn force_release_deposit(
+			origin: OriginFor<T>,
+			account: T::AccountId,
+			block: BlockNumberFor<T>,
+		) -> DispatchResult {
+			T::ForceDepositOrigin::ensure_origin(origin)?;
+
+			Self::do_release(true, account, block).map_err(Into::into)
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// Automatically exits safe-mode when the current block number is greater than
+		/// [`EnteredUntil`].
+		fn on_initialize(current: BlockNumberFor<T>) -> Weight {
+			let Some(limit) = EnteredUntil::<T>::get() else {
+				return T::WeightInfo::on_initialize_noop();
+			};
+
+			if current > limit {
+				let _ = Self::do_exit(ExitReason::Timeout).defensive_proof("Only Errors if safe-mode is not entered. Safe-mode has already been checked to be entered; qed");
+				T::WeightInfo::on_initialize_exit()
+			} else {
+				T::WeightInfo::on_initialize_noop()
+			}
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Logic for the [`crate::Pallet::enter`] and [`crate::Pallet::force_enter`] calls.
+	pub(crate) fn do_enter(
+		who: Option<T::AccountId>,
+		duration: BlockNumberFor<T>,
+	) -> Result<(), Error<T>> {
+		ensure!(!Self::is_entered(), Error::<T>::Entered);
+
+		if let Some(who) = who {
+			let amount = T::EnterDepositAmount::get().ok_or(Error::<T>::NotConfigured)?;
+			Self::hold(who, amount)?;
+		}
+
+		let until = <frame_system::Pallet<T>>::block_number().saturating_add(duration);
+		EnteredUntil::<T>::put(until);
+		Self::deposit_event(Event::Entered { until });
+		T::Notify::entered();
+		Ok(())
+	}
+
+	/// Logic for the [`crate::Pallet::extend`] and [`crate::Pallet::force_extend`] calls.
+	pub(crate) fn do_extend(
+		who: Option<T::AccountId>,
+		duration: BlockNumberFor<T>,
+	) -> Result<(), Error<T>> {
+		let mut until = EnteredUntil::<T>::get().ok_or(Error::<T>::Exited)?;
+
+		if let Some(who) = who {
+			let amount = T::ExtendDepositAmount::get().ok_or(Error::<T>::NotConfigured)?;
+			Self::hold(who, amount)?;
+		}
+
+		until.saturating_accrue(duration);
+		EnteredUntil::<T>::put(until);
+		Self::deposit_event(Event::<T>::Extended { until });
+		Ok(())
+	}
+
+	/// Logic for the [`crate::Pallet::force_exit`] call.
+	///
+	/// Errors if safe-mode is already exited.
+	pub(crate) fn do_exit(reason: ExitReason) -> Result<(), Error<T>> {
+		let _until = EnteredUntil::<T>::take().ok_or(Error::<T>::Exited)?;
+		Self::deposit_event(Event::Exited { reason });
+		T::Notify::exited();
+		Ok(())
+	}
+
+	/// Logic for the [`crate::Pallet::release_deposit`] and
+	/// [`crate::Pallet::force_release_deposit`] calls.
+	pub(crate) fn do_release(
+		force: bool,
+		account: T::AccountId,
+		block: BlockNumberFor<T>,
+	) -> Result<(), Error<T>> {
+		let amount = Deposits::<T>::take(&account, &block).ok_or(Error::<T>::NoDeposit)?;
+
+		if !force {
+			ensure!(!Self::is_entered(), Error::<T>::Entered);
+
+			let delay = T::ReleaseDelay::get().ok_or(Error::<T>::NotConfigured)?;
+			let now = <frame_system::Pallet<T>>::block_number();
+			ensure!(now > block.saturating_add(delay), Error::<T>::CannotReleaseYet);
+		}
+
+		let amount = T::Currency::release(
+			&&HoldReason::EnterOrExtend.into(),
+			&account,
+			amount,
+			Precision::BestEffort,
+		)
+		.map_err(|_| Error::<T>::CurrencyError)?;
+		Self::deposit_event(Event::<T>::DepositReleased { account, amount });
+		Ok(())
+	}
+
+	/// Logic for the [`crate::Pallet::slash_deposit`] call.
+	pub(crate) fn do_force_deposit(
+		account: T::AccountId,
+		block: BlockNumberFor<T>,
+	) -> Result<(), Error<T>> {
+		let amount = Deposits::<T>::take(&account, block).ok_or(Error::<T>::NoDeposit)?;
+
+		let burned = T::Currency::burn_held(
+			&&HoldReason::EnterOrExtend.into(),
+			&account,
+			amount,
+			Precision::BestEffort,
+			Fortitude::Force,
+		)
+		.map_err(|_| Error::<T>::CurrencyError)?;
+		defensive_assert!(burned == amount, "Could not burn the full held amount");
+		Self::deposit_event(Event::<T>::DepositSlashed { account, amount });
+		Ok(())
+	}
+
+	/// Place a hold for exactly `amount` and store it in `Deposits`.
+	///
+	/// Errors if the account already has a hold for the same reason.
+	fn hold(who: T::AccountId, amount: BalanceOf<T>) -> Result<(), Error<T>> {
+		let block = <frame_system::Pallet<T>>::block_number();
+		if !T::Currency::balance_on_hold(&HoldReason::EnterOrExtend.into(), &who).is_zero() {
+			return Err(Error::<T>::AlreadyDeposited.into())
+		}
+
+		T::Currency::hold(&HoldReason::EnterOrExtend.into(), &who, amount)
+			.map_err(|_| Error::<T>::CurrencyError)?;
+		Deposits::<T>::insert(&who, block, amount);
+		Self::deposit_event(Event::<T>::DepositPlaced { account: who, amount });
+
+		Ok(())
+	}
+
+	/// Return whether `safe-mode` is entered.
+	pub fn is_entered() -> bool {
+		EnteredUntil::<T>::exists()
+	}
+
+	/// Return whether the given call is allowed to be dispatched.
+	pub fn is_allowed(call: &T::RuntimeCall) -> bool
+	where
+		T::RuntimeCall: GetCallMetadata,
+	{
+		let CallMetadata { pallet_name, .. } = call.get_call_metadata();
+		// SAFETY: The `SafeMode` pallet is always allowed.
+		if pallet_name == <Pallet<T> as PalletInfoAccess>::name() {
+			return true
+		}
+
+		if Self::is_entered() {
+			T::WhitelistedCalls::contains(call)
+		} else {
+			true
+		}
+	}
+}
+
+impl<T: Config> Contains<T::RuntimeCall> for Pallet<T>
+where
+	T::RuntimeCall: GetCallMetadata,
+{
+	/// Return whether the given call is allowed to be dispatched.
+	fn contains(call: &T::RuntimeCall) -> bool {
+		Pallet::<T>::is_allowed(call)
+	}
+}
+
+impl<T: Config> frame_support::traits::SafeMode for Pallet<T> {
+	type BlockNumber = BlockNumberFor<T>;
+
+	fn is_entered() -> bool {
+		Self::is_entered()
+	}
+
+	fn remaining() -> Option<BlockNumberFor<T>> {
+		EnteredUntil::<T>::get().map(|until| {
+			let now = <frame_system::Pallet<T>>::block_number();
+			until.saturating_sub(now)
+		})
+	}
+
+	fn enter(duration: BlockNumberFor<T>) -> Result<(), frame_support::traits::SafeModeError> {
+		Self::do_enter(None, duration).map_err(Into::into)
+	}
+
+	fn extend(duration: BlockNumberFor<T>) -> Result<(), frame_support::traits::SafeModeError> {
+		Self::do_extend(None, duration).map_err(Into::into)
+	}
+
+	fn exit() -> Result<(), frame_support::traits::SafeModeError> {
+		Self::do_exit(ExitReason::Force).map_err(Into::into)
+	}
+}
+
+impl<T: Config> From<Error<T>> for frame_support::traits::SafeModeError {
+	fn from(err: Error<T>) -> Self {
+		match err {
+			Error::<T>::Entered => Self::AlreadyEntered,
+			Error::<T>::Exited => Self::AlreadyExited,
+			_ => Self::Unknown,
+		}
+	}
+}
diff --git a/substrate/frame/safe-mode/src/mock.rs b/substrate/frame/safe-mode/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..337b6076f84b994bde73691deb55cc80fe141747
--- /dev/null
+++ b/substrate/frame/safe-mode/src/mock.rs
@@ -0,0 +1,270 @@
+// 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 and test utilities for safe mode pallet.
+
+#![cfg(test)]
+
+use super::*;
+use crate as pallet_safe_mode;
+
+use frame_support::{
+	parameter_types,
+	traits::{ConstU64, Everything, InsideBoth, InstanceFilter, IsInVec, SafeModeNotify},
+};
+use frame_system::EnsureSignedBy;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = InsideBoth<Everything, SafeMode>;
+	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 Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	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>;
+}
+
+/// Identifies a hold on an account's balance.
+#[derive(
+	Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, Debug, TypeInfo,
+)]
+pub enum HoldReason {
+	/// The safe-mode pallet holds funds since an account either entered or extended the safe-mode.
+	SafeMode,
+}
+
+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 FreezeIdentifier = ();
+	type MaxHolds = ConstU32<10>;
+	type MaxFreezes = ConstU32<0>;
+}
+
+impl pallet_utility::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+}
+
+/// Mocked proxies to check that the safe-mode also works with the proxy pallet.
+#[derive(
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	Encode,
+	Decode,
+	RuntimeDebug,
+	MaxEncodedLen,
+	scale_info::TypeInfo,
+)]
+pub enum ProxyType {
+	Any,
+	JustTransfer,
+	JustUtility,
+}
+
+impl Default for ProxyType {
+	fn default() -> Self {
+		Self::Any
+	}
+}
+
+impl InstanceFilter<RuntimeCall> for ProxyType {
+	fn filter(&self, c: &RuntimeCall) -> bool {
+		match self {
+			ProxyType::Any => true,
+			ProxyType::JustTransfer => {
+				matches!(c, RuntimeCall::Balances(pallet_balances::Call::transfer { .. }))
+			},
+			ProxyType::JustUtility => matches!(c, RuntimeCall::Utility { .. }),
+		}
+	}
+	fn is_superset(&self, o: &Self) -> bool {
+		self == &ProxyType::Any || self == o
+	}
+}
+
+impl pallet_proxy::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type ProxyType = ProxyType;
+	type ProxyDepositBase = ConstU64<1>;
+	type ProxyDepositFactor = ConstU64<1>;
+	type MaxProxies = ConstU32<4>;
+	type WeightInfo = ();
+	type CallHasher = BlakeTwo256;
+	type MaxPending = ConstU32<2>;
+	type AnnouncementDepositBase = ConstU64<1>;
+	type AnnouncementDepositFactor = ConstU64<1>;
+}
+
+/// The calls that can always bypass safe-mode.
+pub struct WhitelistedCalls;
+impl Contains<RuntimeCall> for WhitelistedCalls {
+	fn contains(call: &RuntimeCall) -> bool {
+		match call {
+			RuntimeCall::Balances(_) => false,
+			_ => true,
+		}
+	}
+}
+
+parameter_types! {
+	pub const EnterDuration: u64 = 7;
+	pub const ExtendDuration: u64 = 10;
+	pub const EnterDepositAmount: u64 = 100;
+	pub const ExtendDepositAmount: u64 = 100;
+	pub const ReleaseDelay: u64 = 20;
+	pub const SafeModeHoldReason: HoldReason = HoldReason::SafeMode;
+
+	pub const ForceEnterWeak: u64 = 3;
+	pub const ForceEnterStrong: u64 = 5;
+
+	pub const ForceExtendWeak: u64 = 11;
+	pub const ForceExtendStrong: u64 = 15;
+
+	// NOTE: The account ID maps to the duration. Easy for testing.
+	pub ForceEnterOrigins: Vec<u64> = vec![ForceEnterWeak::get(), ForceEnterStrong::get()];
+	pub ForceExtendOrigins: Vec<u64> = vec![ForceExtendWeak::get(), ForceExtendStrong::get()];
+
+	pub storage Notifications: Vec<(u64, bool)> = vec![];
+}
+
+pub struct MockedNotify;
+impl SafeModeNotify for MockedNotify {
+	fn entered() {
+		let mut ns = Notifications::get();
+		ns.push((<frame_system::Pallet<Test>>::block_number(), true));
+		Notifications::set(&ns);
+	}
+
+	fn exited() {
+		let mut ns = Notifications::get();
+		ns.push((<frame_system::Pallet<Test>>::block_number(), false));
+		Notifications::set(&ns);
+	}
+}
+
+frame_support::ord_parameter_types! {
+	pub const ForceExitOrigin: u64 = 100;
+	pub const ForceDepositOrigin: u64 = 200;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type WhitelistedCalls = WhitelistedCalls;
+	type EnterDuration = EnterDuration;
+	type EnterDepositAmount = EnterDepositAmount;
+	type ExtendDuration = ExtendDuration;
+	type ExtendDepositAmount = ExtendDepositAmount;
+	type ForceEnterOrigin = EnsureSignedBy<IsInVec<ForceEnterOrigins>, u64>;
+	type ForceExtendOrigin = EnsureSignedBy<IsInVec<ForceExtendOrigins>, u64>;
+	type ForceExitOrigin = EnsureSignedBy<ForceExitOrigin, Self::AccountId>;
+	type ForceDepositOrigin = EnsureSignedBy<ForceDepositOrigin, Self::AccountId>;
+	type ReleaseDelay = ReleaseDelay;
+	type Notify = MockedNotify;
+	type WeightInfo = ();
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Utility: pallet_utility,
+		Proxy: pallet_proxy,
+		SafeMode: pallet_safe_mode,
+	}
+);
+
+pub const BAL_ACC0: u64 = 1234;
+pub const BAL_ACC1: u64 = 5678;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	pallet_balances::GenesisConfig::<Test> {
+		// The 0 account is NOT a special origin, the rest may be.
+		balances: vec![(0, BAL_ACC0), (1, BAL_ACC1), (2, 5678), (3, 5678), (4, 5678)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	pallet_safe_mode::GenesisConfig::<Test> { entered_until: None }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| {
+		System::set_block_number(1);
+	});
+	ext
+}
+
+pub fn next_block() {
+	SafeMode::on_finalize(System::block_number());
+	Balances::on_finalize(System::block_number());
+	System::on_finalize(System::block_number());
+	System::set_block_number(System::block_number() + 1);
+	System::on_initialize(System::block_number());
+	Balances::on_initialize(System::block_number());
+	SafeMode::on_initialize(System::block_number());
+}
+
+pub fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
diff --git a/substrate/frame/safe-mode/src/tests.rs b/substrate/frame/safe-mode/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4ce9922d3b65c70646caec497a394704973edcc9
--- /dev/null
+++ b/substrate/frame/safe-mode/src/tests.rs
@@ -0,0 +1,613 @@
+// 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.
+
+//! Test utilities for the safe mode pallet.
+
+#![cfg(test)]
+
+use super::*;
+use crate::mock::{RuntimeCall, *};
+
+use frame_support::{assert_err, assert_noop, assert_ok, dispatch::Dispatchable, traits::Currency};
+use sp_runtime::TransactionOutcome;
+
+/// Do something hypothetically by rolling back any changes afterwards.
+///
+/// Returns the original result of the closure.
+macro_rules! hypothetically {
+	( $e:expr ) => {
+		frame_support::storage::transactional::with_transaction(
+			|| -> TransactionOutcome<Result<_, sp_runtime::DispatchError>> {
+				sp_runtime::TransactionOutcome::Rollback(Ok($e))
+			},
+		)
+		.expect("Always returning Ok; qed")
+	};
+}
+
+/// Assert something to be [*hypothetically*] `Ok` without actually committing it.
+///
+/// Reverts any storage changes made by the closure.
+macro_rules! hypothetically_ok {
+	($e:expr $(, $args:expr)* $(,)?) => {
+		let result = hypothetically!($e);
+		assert_ok!(result $(, $args)*);
+	};
+}
+
+#[test]
+fn fails_to_filter_calls_to_safe_mode_pallet() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		let activated_at_block = System::block_number();
+
+		assert_err!(
+			call_transfer().dispatch(RuntimeOrigin::signed(0)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+
+		next_block();
+		assert_ok!(SafeMode::extend(RuntimeOrigin::signed(1)));
+		assert_ok!(SafeMode::force_extend(signed(ForceExtendStrong::get())));
+		assert_err!(
+			call_transfer().dispatch(RuntimeOrigin::signed(0)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+		assert_ok!(SafeMode::force_exit(RuntimeOrigin::signed(mock::ForceExitOrigin::get())));
+		assert_ok!(SafeMode::force_release_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_at_block
+		));
+
+		next_block();
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_err!(
+			call_transfer().dispatch(RuntimeOrigin::signed(0)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+		assert_ok!(SafeMode::force_exit(RuntimeOrigin::signed(mock::ForceExitOrigin::get())));
+		assert_ok!(SafeMode::force_slash_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_at_block + 2
+		));
+	});
+}
+
+#[test]
+fn fails_to_activate_if_activated() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_noop!(SafeMode::enter(RuntimeOrigin::signed(2)), Error::<Test>::Entered);
+	});
+}
+
+#[test]
+fn fails_to_extend_if_not_activated() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(EnteredUntil::<Test>::get(), None);
+		assert_noop!(SafeMode::extend(RuntimeOrigin::signed(2)), Error::<Test>::Exited);
+	});
+}
+
+#[test]
+fn fails_to_force_release_deposits_with_wrong_block() {
+	new_test_ext().execute_with(|| {
+		let activated_at_block = System::block_number();
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		run_to(mock::EnterDuration::get() + activated_at_block + 1);
+
+		assert_err!(
+			SafeMode::force_release_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				0,
+				activated_at_block + 1
+			),
+			Error::<Test>::NoDeposit
+		);
+
+		assert_err!(
+			SafeMode::force_slash_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				0,
+				activated_at_block + 1
+			),
+			Error::<Test>::NoDeposit
+		);
+	});
+}
+
+#[test]
+fn fails_to_release_deposits_too_early() {
+	new_test_ext().execute_with(|| {
+		let activated_at_block = System::block_number();
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_ok!(SafeMode::force_exit(RuntimeOrigin::signed(mock::ForceExitOrigin::get())));
+		assert_err!(
+			SafeMode::release_deposit(RuntimeOrigin::signed(2), 0, activated_at_block),
+			Error::<Test>::CannotReleaseYet
+		);
+		run_to(activated_at_block + mock::ReleaseDelay::get() + 1);
+		assert_ok!(SafeMode::release_deposit(RuntimeOrigin::signed(2), 0, activated_at_block));
+	});
+}
+
+// GENERAL SUCCESS/POSITIVE TESTS ---------------------
+
+#[test]
+fn can_automatically_deactivate_after_timeout() {
+	new_test_ext().execute_with(|| {
+		let activated_at_block = System::block_number();
+		assert_ok!(SafeMode::force_enter(signed(ForceEnterWeak::get())));
+		run_to(1 + activated_at_block + ForceEnterWeak::get());
+
+		assert_eq!(EnteredUntil::<Test>::get(), None);
+	});
+}
+
+#[test]
+fn can_filter_balance_calls_when_activated() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(call_transfer().dispatch(RuntimeOrigin::signed(0)));
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_err!(
+			call_transfer().dispatch(RuntimeOrigin::signed(0)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+	});
+}
+
+#[test]
+fn can_filter_balance_in_batch_when_activated() {
+	new_test_ext().execute_with(|| {
+		let batch_call =
+			RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![call_transfer()] });
+
+		assert_ok!(batch_call.clone().dispatch(RuntimeOrigin::signed(0)));
+
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+
+		assert_ok!(batch_call.clone().dispatch(RuntimeOrigin::signed(0)));
+		System::assert_last_event(
+			pallet_utility::Event::BatchInterrupted {
+				index: 0,
+				error: frame_system::Error::<Test>::CallFiltered.into(),
+			}
+			.into(),
+		);
+	});
+}
+
+#[test]
+fn can_filter_balance_in_proxy_when_activated() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::JustTransfer, 0));
+
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, Box::new(call_transfer())));
+		System::assert_last_event(pallet_proxy::Event::ProxyExecuted { result: Ok(()) }.into());
+
+		assert_ok!(SafeMode::force_enter(signed(ForceEnterWeak::get())));
+
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, Box::new(call_transfer())));
+		System::assert_last_event(
+			pallet_proxy::Event::ProxyExecuted {
+				result: DispatchError::from(frame_system::Error::<Test>::CallFiltered).into(),
+			}
+			.into(),
+		);
+	});
+}
+
+#[test]
+fn can_activate() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_eq!(
+			EnteredUntil::<Test>::get().unwrap(),
+			System::block_number() + mock::EnterDuration::get()
+		);
+		assert_eq!(Balances::reserved_balance(0), mock::EnterDepositAmount::get());
+		assert_eq!(Notifications::get(), vec![(1, true)]);
+		assert_noop!(SafeMode::enter(RuntimeOrigin::signed(0)), Error::<Test>::Entered);
+		assert_eq!(Notifications::get(), vec![(1, true)]);
+		// Assert the deposit.
+		assert_eq!(Deposits::<Test>::get(0, 1), Some(mock::EnterDepositAmount::get()));
+	});
+}
+
+#[test]
+fn notify_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_eq!(Notifications::get(), vec![(1, true)]);
+		run_to(10);
+		assert_eq!(Notifications::get(), vec![(1, true), (9, false)]);
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(1)));
+		assert_ok!(SafeMode::extend(RuntimeOrigin::signed(2)));
+		run_to(30);
+		assert_eq!(Notifications::get(), vec![(1, true), (9, false), (10, true), (28, false)]);
+	});
+}
+
+#[test]
+fn cannot_extend() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_err!(SafeMode::extend(RuntimeOrigin::signed(0)), Error::<Test>::AlreadyDeposited);
+		assert_eq!(
+			EnteredUntil::<Test>::get().unwrap(),
+			System::block_number() + mock::EnterDuration::get()
+		);
+		assert_eq!(Balances::reserved_balance(0), mock::EnterDepositAmount::get());
+		assert_eq!(Notifications::get(), vec![(1, true)]);
+	});
+}
+
+#[test]
+fn fails_signed_origin_when_explicit_origin_required() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(EnteredUntil::<Test>::get(), None);
+		let activated_at_block = System::block_number();
+
+		assert_err!(SafeMode::force_enter(RuntimeOrigin::signed(0)), DispatchError::BadOrigin);
+		assert_err!(SafeMode::force_extend(RuntimeOrigin::signed(0)), DispatchError::BadOrigin);
+		assert_err!(SafeMode::force_exit(RuntimeOrigin::signed(0)), DispatchError::BadOrigin);
+		assert_err!(
+			SafeMode::force_slash_deposit(RuntimeOrigin::signed(0), 0, activated_at_block),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_release_deposit(RuntimeOrigin::signed(0), 0, activated_at_block),
+			DispatchError::BadOrigin
+		);
+	});
+}
+
+// CONFIGURED ORIGIN CALL TESTS ---------------------
+
+#[test]
+fn fails_force_deactivate_if_not_activated() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			SafeMode::force_exit(RuntimeOrigin::signed(mock::ForceExitOrigin::get())),
+			Error::<Test>::Exited
+		);
+		assert_noop!(
+			SafeMode::force_exit(RuntimeOrigin::signed(mock::ForceExitOrigin::get())),
+			Error::<Test>::Exited
+		);
+		assert!(Notifications::get().is_empty());
+	});
+}
+
+#[test]
+fn can_force_activate_with_config_origin() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(SafeMode::force_enter(signed(ForceEnterStrong::get())));
+		assert_eq!(Notifications::get(), vec![(1, true)]);
+		assert_eq!(
+			EnteredUntil::<Test>::get().unwrap(),
+			System::block_number() + ForceEnterStrong::get()
+		);
+		assert_noop!(
+			SafeMode::force_enter(signed(ForceEnterStrong::get())),
+			Error::<Test>::Entered
+		);
+		assert_eq!(Notifications::get(), vec![(1, true)]);
+	});
+}
+
+#[test]
+fn can_force_deactivate_with_config_origin() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(EnteredUntil::<Test>::get(), None);
+		assert_err!(
+			SafeMode::force_exit(RuntimeOrigin::signed(ForceExitOrigin::get())),
+			Error::<Test>::Exited
+		);
+		assert_ok!(SafeMode::force_enter(signed(ForceEnterWeak::get())));
+		assert_ok!(SafeMode::force_exit(RuntimeOrigin::signed(ForceExitOrigin::get())));
+		assert_eq!(Notifications::get(), vec![(1, true), (1, false)]);
+	});
+}
+
+#[test]
+fn can_force_extend_with_config_origin() {
+	new_test_ext().execute_with(|| {
+		// Activated by `Weak` and extended by `Medium`.
+		assert_ok!(SafeMode::force_enter(signed(ForceEnterWeak::get())));
+		assert_eq!(
+			EnteredUntil::<Test>::get().unwrap(),
+			System::block_number() + ForceEnterWeak::get()
+		);
+		assert_ok!(SafeMode::force_extend(signed(ForceExtendWeak::get())));
+		assert_eq!(
+			EnteredUntil::<Test>::get().unwrap(),
+			System::block_number() + ForceEnterWeak::get() + ForceExtendWeak::get()
+		);
+	});
+}
+
+#[test]
+fn can_force_release_deposit_with_config_origin() {
+	new_test_ext().execute_with(|| {
+		let activated_at_block = System::block_number();
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		hypothetically_ok!(SafeMode::force_release_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_at_block
+		),);
+		run_to(mock::EnterDuration::get() + activated_at_block + 1);
+
+		assert_ok!(SafeMode::force_release_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_at_block
+		));
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0); // accounts set in mock genesis
+
+		Balances::make_free_balance_be(&0, BAL_ACC0);
+		let activated_and_extended_at_block = System::block_number();
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_ok!(SafeMode::extend(RuntimeOrigin::signed(1)));
+		run_to(
+			mock::EnterDuration::get() +
+				mock::ExtendDuration::get() +
+				activated_and_extended_at_block +
+				1,
+		);
+
+		assert_ok!(SafeMode::force_release_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_and_extended_at_block
+		));
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0); // accounts set in mock genesis
+	});
+}
+
+#[test]
+fn can_release_deposit_while_entered() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(System::block_number(), 1);
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert!(SafeMode::is_entered());
+
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0 - mock::EnterDepositAmount::get());
+
+		// We could slash in the same block or any later.
+		for i in 0..mock::EnterDuration::get() + 10 {
+			run_to(i);
+			hypothetically_ok!(SafeMode::force_release_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				0,
+				1
+			));
+		}
+		// Now once we slash once
+		assert_ok!(SafeMode::force_release_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			1
+		),);
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0);
+		// ... it wont work ever again.
+		assert_err!(
+			SafeMode::force_release_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				0,
+				1
+			),
+			Error::<Test>::NoDeposit
+		);
+	});
+}
+
+#[test]
+fn can_slash_deposit_while_entered() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(System::block_number(), 1);
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert!(SafeMode::is_entered());
+
+		// We could slash in the same block or any later.
+		for i in 0..mock::EnterDuration::get() + 10 {
+			run_to(i);
+			hypothetically_ok!(SafeMode::force_slash_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				0,
+				1
+			));
+		}
+		// Now once we slash once
+		assert_ok!(SafeMode::force_slash_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			1
+		),);
+		// ... it wont work ever again.
+		assert_err!(
+			SafeMode::force_slash_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				0,
+				1
+			),
+			Error::<Test>::NoDeposit
+		);
+	});
+}
+
+#[test]
+fn can_slash_deposit_from_extend_block() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_ok!(SafeMode::extend(RuntimeOrigin::signed(1)));
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0 - mock::EnterDepositAmount::get());
+		assert_eq!(Balances::free_balance(&1), BAL_ACC1 - mock::ExtendDepositAmount::get());
+
+		assert_ok!(SafeMode::force_slash_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			1
+		),);
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0 - mock::EnterDepositAmount::get());
+
+		assert_ok!(SafeMode::force_slash_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			1,
+			1
+		),);
+		assert_eq!(Balances::free_balance(&1), BAL_ACC1 - mock::ExtendDepositAmount::get());
+
+		// But never again.
+		assert_err!(
+			SafeMode::force_slash_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				0,
+				1
+			),
+			Error::<Test>::NoDeposit
+		);
+		assert_err!(
+			SafeMode::force_slash_deposit(
+				RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+				1,
+				1
+			),
+			Error::<Test>::NoDeposit
+		);
+	});
+}
+
+#[test]
+fn can_slash_deposit_with_config_origin() {
+	new_test_ext().execute_with(|| {
+		let activated_at_block = System::block_number();
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		hypothetically_ok!(SafeMode::force_slash_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_at_block
+		),);
+		run_to(mock::EnterDuration::get() + activated_at_block + 1);
+
+		assert_ok!(SafeMode::force_slash_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_at_block
+		));
+		// accounts set in mock genesis
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0 - mock::EnterDepositAmount::get());
+
+		Balances::make_free_balance_be(&0, BAL_ACC0);
+		let activated_and_extended_at_block = System::block_number();
+		assert_ok!(SafeMode::enter(RuntimeOrigin::signed(0)));
+		assert_ok!(SafeMode::extend(RuntimeOrigin::signed(1)));
+		run_to(
+			mock::EnterDuration::get() +
+				mock::ExtendDuration::get() +
+				activated_and_extended_at_block +
+				1,
+		);
+
+		assert_ok!(SafeMode::force_slash_deposit(
+			RuntimeOrigin::signed(mock::ForceDepositOrigin::get()),
+			0,
+			activated_and_extended_at_block
+		));
+		// accounts set in mock genesis
+		assert_eq!(Balances::free_balance(&0), BAL_ACC0 - mock::EnterDepositAmount::get());
+	});
+}
+
+#[test]
+fn fails_when_explicit_origin_required() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(EnteredUntil::<Test>::get(), None);
+		let activated_at_block = System::block_number();
+
+		assert_err!(SafeMode::force_extend(signed(1)), DispatchError::BadOrigin);
+		assert_err!(SafeMode::force_exit(signed(1)), DispatchError::BadOrigin);
+		assert_err!(
+			SafeMode::force_slash_deposit(signed(1), 0, activated_at_block),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_release_deposit(signed(1), 0, activated_at_block),
+			DispatchError::BadOrigin
+		);
+
+		assert_err!(SafeMode::force_enter(signed(1)), DispatchError::BadOrigin);
+		assert_err!(SafeMode::force_exit(signed(1)), DispatchError::BadOrigin);
+		assert_err!(
+			SafeMode::force_slash_deposit(signed(1), 0, activated_at_block),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_release_deposit(signed(1), 0, activated_at_block),
+			DispatchError::BadOrigin
+		);
+
+		assert_err!(
+			SafeMode::force_enter(RuntimeOrigin::signed(mock::ForceExitOrigin::get())),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_extend(RuntimeOrigin::signed(mock::ForceExitOrigin::get())),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_slash_deposit(
+				RuntimeOrigin::signed(mock::ForceExitOrigin::get()),
+				0,
+				activated_at_block
+			),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_release_deposit(
+				RuntimeOrigin::signed(mock::ForceExitOrigin::get()),
+				0,
+				activated_at_block
+			),
+			DispatchError::BadOrigin
+		);
+
+		assert_err!(
+			SafeMode::force_enter(RuntimeOrigin::signed(mock::ForceDepositOrigin::get())),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_extend(RuntimeOrigin::signed(mock::ForceDepositOrigin::get())),
+			DispatchError::BadOrigin
+		);
+		assert_err!(
+			SafeMode::force_exit(RuntimeOrigin::signed(mock::ForceDepositOrigin::get())),
+			DispatchError::BadOrigin
+		);
+	});
+}
+
+fn call_transfer() -> RuntimeCall {
+	RuntimeCall::Balances(pallet_balances::Call::transfer { dest: 1, value: 1 })
+}
+
+fn signed(who: u64) -> RuntimeOrigin {
+	RuntimeOrigin::signed(who)
+}
diff --git a/substrate/frame/safe-mode/src/weights.rs b/substrate/frame/safe-mode/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f72bebcab9a4db74fba3ef282692324e32858fc3
--- /dev/null
+++ b/substrate/frame/safe-mode/src/weights.rs
@@ -0,0 +1,321 @@
+// 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.
+
+//! Autogenerated weights for `pallet_safe_mode`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-08-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-aahe6cbd-project-145-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
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_safe_mode
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/safe-mode/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pallet_safe_mode`.
+pub trait WeightInfo {
+	fn on_initialize_noop() -> Weight;
+	fn on_initialize_exit() -> Weight;
+	fn enter() -> Weight;
+	fn force_enter() -> Weight;
+	fn extend() -> Weight;
+	fn force_extend() -> Weight;
+	fn force_exit() -> Weight;
+	fn release_deposit() -> Weight;
+	fn force_release_deposit() -> Weight;
+	fn force_slash_deposit() -> Weight;
+}
+
+/// Weights for `pallet_safe_mode` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:0)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn on_initialize_noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1489`
+		// Minimum execution time: 2_500_000 picoseconds.
+		Weight::from_parts(2_594_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn on_initialize_exit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `1489`
+		// Minimum execution time: 8_868_000 picoseconds.
+		Weight::from_parts(9_415_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`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: `SafeMode::Deposits` (r:0 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn enter() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3550`
+		// Minimum execution time: 50_541_000 picoseconds.
+		Weight::from_parts(51_558_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn force_enter() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1489`
+		// Minimum execution time: 10_489_000 picoseconds.
+		Weight::from_parts(10_833_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`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: `SafeMode::Deposits` (r:0 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn extend() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `3550`
+		// Minimum execution time: 50_818_000 picoseconds.
+		Weight::from_parts(51_873_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn force_extend() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `1489`
+		// Minimum execution time: 10_843_000 picoseconds.
+		Weight::from_parts(11_314_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn force_exit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `1489`
+		// Minimum execution time: 10_382_000 picoseconds.
+		Weight::from_parts(10_814_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::Deposits` (r:1 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:0)
+	/// Proof: `SafeMode::EnteredUntil` (`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`)
+	fn release_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `292`
+		//  Estimated: `3550`
+		// Minimum execution time: 42_828_000 picoseconds.
+		Weight::from_parts(43_752_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `SafeMode::Deposits` (r:1 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	fn force_release_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `292`
+		//  Estimated: `3550`
+		// Minimum execution time: 40_196_000 picoseconds.
+		Weight::from_parts(41_298_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `SafeMode::Deposits` (r:1 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	fn force_slash_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `292`
+		//  Estimated: `3550`
+		// Minimum execution time: 33_660_000 picoseconds.
+		Weight::from_parts(34_426_000, 3550)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:0)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn on_initialize_noop() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1489`
+		// Minimum execution time: 2_500_000 picoseconds.
+		Weight::from_parts(2_594_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn on_initialize_exit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `1489`
+		// Minimum execution time: 8_868_000 picoseconds.
+		Weight::from_parts(9_415_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`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: `SafeMode::Deposits` (r:0 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn enter() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `3550`
+		// Minimum execution time: 50_541_000 picoseconds.
+		Weight::from_parts(51_558_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn force_enter() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `142`
+		//  Estimated: `1489`
+		// Minimum execution time: 10_489_000 picoseconds.
+		Weight::from_parts(10_833_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`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: `SafeMode::Deposits` (r:0 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn extend() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `3550`
+		// Minimum execution time: 50_818_000 picoseconds.
+		Weight::from_parts(51_873_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn force_extend() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `1489`
+		// Minimum execution time: 10_843_000 picoseconds.
+		Weight::from_parts(11_314_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:1)
+	/// Proof: `SafeMode::EnteredUntil` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	fn force_exit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `169`
+		//  Estimated: `1489`
+		// Minimum execution time: 10_382_000 picoseconds.
+		Weight::from_parts(10_814_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `SafeMode::Deposits` (r:1 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `SafeMode::EnteredUntil` (r:1 w:0)
+	/// Proof: `SafeMode::EnteredUntil` (`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`)
+	fn release_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `292`
+		//  Estimated: `3550`
+		// Minimum execution time: 42_828_000 picoseconds.
+		Weight::from_parts(43_752_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `SafeMode::Deposits` (r:1 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	fn force_release_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `292`
+		//  Estimated: `3550`
+		// Minimum execution time: 40_196_000 picoseconds.
+		Weight::from_parts(41_298_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `SafeMode::Deposits` (r:1 w:1)
+	/// Proof: `SafeMode::Deposits` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Balances::Holds` (r:1 w:1)
+	/// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`)
+	fn force_slash_deposit() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `292`
+		//  Estimated: `3550`
+		// Minimum execution time: 33_660_000 picoseconds.
+		Weight::from_parts(34_426_000, 3550)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/salary/Cargo.toml b/substrate/frame/salary/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..330b746fc1e3fd9e68c8fc72229784f9784f1c11
--- /dev/null
+++ b/substrate/frame/salary/Cargo.toml
@@ -0,0 +1,53 @@
+[package]
+name = "pallet-salary"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Paymaster"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.16", default-features = false }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/salary/README.md b/substrate/frame/salary/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..25c1be0e805d777be200a8ff8dae88199ce0935e
--- /dev/null
+++ b/substrate/frame/salary/README.md
@@ -0,0 +1,3 @@
+# Salary
+
+Make periodic payment to members of a ranked collective according to rank.
\ No newline at end of file
diff --git a/substrate/frame/salary/src/benchmarking.rs b/substrate/frame/salary/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7528293506aece90da5592d99208b36c86aceb5b
--- /dev/null
+++ b/substrate/frame/salary/src/benchmarking.rs
@@ -0,0 +1,183 @@
+// 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.
+
+//! Salary pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use crate::Pallet as Salary;
+
+use frame_benchmarking::v2::*;
+use frame_system::{Pallet as System, RawOrigin};
+use sp_core::Get;
+
+const SEED: u32 = 0;
+
+fn ensure_member_with_salary<T: Config<I>, I: 'static>(who: &T::AccountId) {
+	// induct if not a member.
+	if T::Members::rank_of(who).is_none() {
+		T::Members::induct(who).unwrap();
+	}
+	// promote until they have a salary.
+	for _ in 0..255 {
+		let r = T::Members::rank_of(who).expect("prior guard ensures `who` is a member; qed");
+		if !T::Salary::get_salary(r, &who).is_zero() {
+			break
+		}
+		T::Members::promote(who).unwrap();
+	}
+}
+
+#[instance_benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn init() {
+		let caller: T::AccountId = whitelisted_caller();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		assert!(Salary::<T, I>::status().is_some());
+	}
+
+	#[benchmark]
+	fn bump() {
+		let caller: T::AccountId = whitelisted_caller();
+		Salary::<T, I>::init(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + Salary::<T, I>::cycle_period());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		assert_eq!(Salary::<T, I>::status().unwrap().cycle_index, 1u32.into());
+	}
+
+	#[benchmark]
+	fn induct() {
+		let caller = whitelisted_caller();
+		ensure_member_with_salary::<T, I>(&caller);
+		Salary::<T, I>::init(RawOrigin::Signed(caller.clone()).into()).unwrap();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		assert!(Salary::<T, I>::last_active(&caller).is_ok());
+	}
+
+	#[benchmark]
+	fn register() {
+		let caller = whitelisted_caller();
+		ensure_member_with_salary::<T, I>(&caller);
+		Salary::<T, I>::init(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		Salary::<T, I>::induct(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + Salary::<T, I>::cycle_period());
+		Salary::<T, I>::bump(RawOrigin::Signed(caller.clone()).into()).unwrap();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		assert_eq!(Salary::<T, I>::last_active(&caller).unwrap(), 1u32.into());
+	}
+
+	#[benchmark]
+	fn payout() {
+		let caller = whitelisted_caller();
+		ensure_member_with_salary::<T, I>(&caller);
+		Salary::<T, I>::init(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		Salary::<T, I>::induct(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + Salary::<T, I>::cycle_period());
+		Salary::<T, I>::bump(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + T::RegistrationPeriod::get());
+
+		let salary = T::Salary::get_salary(T::Members::rank_of(&caller).unwrap(), &caller);
+		T::Paymaster::ensure_successful(&caller, (), salary);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		match Claimant::<T, I>::get(&caller) {
+			Some(ClaimantStatus { last_active, status: Attempted { id, .. } }) => {
+				assert_eq!(last_active, 1u32.into());
+				assert_ne!(T::Paymaster::check_payment(id), PaymentStatus::Failure);
+			},
+			_ => panic!("No claim made"),
+		}
+		assert!(Salary::<T, I>::payout(RawOrigin::Signed(caller.clone()).into()).is_err());
+	}
+
+	#[benchmark]
+	fn payout_other() {
+		let caller = whitelisted_caller();
+		ensure_member_with_salary::<T, I>(&caller);
+		Salary::<T, I>::init(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		Salary::<T, I>::induct(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + Salary::<T, I>::cycle_period());
+		Salary::<T, I>::bump(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + T::RegistrationPeriod::get());
+
+		let salary = T::Salary::get_salary(T::Members::rank_of(&caller).unwrap(), &caller);
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		T::Paymaster::ensure_successful(&recipient, (), salary);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), recipient.clone());
+
+		match Claimant::<T, I>::get(&caller) {
+			Some(ClaimantStatus { last_active, status: Attempted { id, .. } }) => {
+				assert_eq!(last_active, 1u32.into());
+				assert_ne!(T::Paymaster::check_payment(id), PaymentStatus::Failure);
+			},
+			_ => panic!("No claim made"),
+		}
+		assert!(Salary::<T, I>::payout(RawOrigin::Signed(caller.clone()).into()).is_err());
+	}
+
+	#[benchmark]
+	fn check_payment() {
+		let caller = whitelisted_caller();
+		ensure_member_with_salary::<T, I>(&caller);
+		Salary::<T, I>::init(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		Salary::<T, I>::induct(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + Salary::<T, I>::cycle_period());
+		Salary::<T, I>::bump(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		System::<T>::set_block_number(System::<T>::block_number() + T::RegistrationPeriod::get());
+
+		let salary = T::Salary::get_salary(T::Members::rank_of(&caller).unwrap(), &caller);
+		let recipient: T::AccountId = account("recipient", 0, SEED);
+		T::Paymaster::ensure_successful(&recipient, (), salary);
+		Salary::<T, I>::payout(RawOrigin::Signed(caller.clone()).into()).unwrap();
+		let id = match Claimant::<T, I>::get(&caller).unwrap().status {
+			Attempted { id, .. } => id,
+			_ => panic!("No claim made"),
+		};
+		T::Paymaster::ensure_concluded(id);
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()));
+
+		assert!(!matches!(Claimant::<T, I>::get(&caller).unwrap().status, Attempted { .. }));
+	}
+
+	impl_benchmark_test_suite! {
+		Salary,
+		crate::tests::new_test_ext(),
+		crate::tests::Test,
+	}
+}
diff --git a/substrate/frame/salary/src/lib.rs b/substrate/frame/salary/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..75d6fdd329ac82582edb7df0412a36bf0325a599
--- /dev/null
+++ b/substrate/frame/salary/src/lib.rs
@@ -0,0 +1,449 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Make periodic payment to members of a ranked collective according to rank.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![recursion_limit = "128"]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_arithmetic::traits::{Saturating, Zero};
+use sp_runtime::{Perbill, RuntimeDebug};
+use sp_std::{marker::PhantomData, prelude::*};
+
+use frame_support::{
+	dispatch::DispatchResultWithPostInfo,
+	ensure,
+	traits::{
+		tokens::{GetSalary, Pay, PaymentStatus},
+		RankedMembers,
+	},
+};
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod weights;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// Payroll cycle.
+pub type Cycle = u32;
+
+/// The status of the pallet instance.
+#[derive(Encode, Decode, Eq, PartialEq, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub struct StatusType<CycleIndex, BlockNumber, Balance> {
+	/// The index of the "current cycle" (i.e. the last cycle being processed).
+	cycle_index: CycleIndex,
+	/// The first block of the "current cycle" (i.e. the last cycle being processed).
+	cycle_start: BlockNumber,
+	/// The total budget available for all payments in the current cycle.
+	budget: Balance,
+	/// The total amount of the payments registered in the current cycle.
+	total_registrations: Balance,
+	/// The total amount of unregistered payments which have been made in the current cycle.
+	total_unregistered_paid: Balance,
+}
+
+/// The state of a specific payment claim.
+#[derive(Encode, Decode, Eq, PartialEq, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub enum ClaimState<Balance, Id> {
+	/// No claim recorded.
+	Nothing,
+	/// Amount reserved when last active.
+	Registered(Balance),
+	/// Amount attempted to be paid when last active as well as the identity of the payment.
+	Attempted { registered: Option<Balance>, id: Id, amount: Balance },
+}
+
+use ClaimState::*;
+
+/// The status of a single payee/claimant.
+#[derive(Encode, Decode, Eq, PartialEq, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub struct ClaimantStatus<CycleIndex, Balance, Id> {
+	/// The most recent cycle in which the claimant was active.
+	last_active: CycleIndex,
+	/// The state of the payment/claim with in the above cycle.
+	status: ClaimState<Balance, Id>,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{dispatch::Pays, pallet_prelude::*};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The runtime event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Means by which we can make payments to accounts. This also defines the currency and the
+		/// balance which we use to denote that currency.
+		type Paymaster: Pay<Beneficiary = <Self as frame_system::Config>::AccountId, AssetKind = ()>;
+
+		/// The current membership of payees.
+		type Members: RankedMembers<AccountId = <Self as frame_system::Config>::AccountId>;
+
+		/// The maximum payout to be made for a single period to an active member of the given rank.
+		///
+		/// The benchmarks require that this be non-zero for some rank at most 255.
+		type Salary: GetSalary<
+			<Self::Members as RankedMembers>::Rank,
+			Self::AccountId,
+			<Self::Paymaster as Pay>::Balance,
+		>;
+
+		/// The number of blocks within a cycle which accounts have to register their intent to
+		/// claim.
+		///
+		/// The number of blocks between sequential payout cycles is the sum of this and
+		/// `PayoutPeriod`.
+		#[pallet::constant]
+		type RegistrationPeriod: Get<BlockNumberFor<Self>>;
+
+		/// The number of blocks within a cycle which accounts have to claim the payout.
+		///
+		/// The number of blocks between sequential payout cycles is the sum of this and
+		/// `RegistrationPeriod`.
+		#[pallet::constant]
+		type PayoutPeriod: Get<BlockNumberFor<Self>>;
+
+		/// The total budget per cycle.
+		///
+		/// This may change over the course of a cycle without any problem.
+		#[pallet::constant]
+		type Budget: Get<BalanceOf<Self, I>>;
+	}
+
+	pub type CycleIndexOf<T> = BlockNumberFor<T>;
+	pub type BalanceOf<T, I> = <<T as Config<I>>::Paymaster as Pay>::Balance;
+	pub type IdOf<T, I> = <<T as Config<I>>::Paymaster as Pay>::Id;
+	pub type StatusOf<T, I> = StatusType<CycleIndexOf<T>, BlockNumberFor<T>, BalanceOf<T, I>>;
+	pub type ClaimantStatusOf<T, I> = ClaimantStatus<CycleIndexOf<T>, BalanceOf<T, I>, IdOf<T, I>>;
+
+	/// The overall status of the system.
+	#[pallet::storage]
+	pub(super) type Status<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, StatusOf<T, I>, OptionQuery>;
+
+	/// The status of a claimant.
+	#[pallet::storage]
+	pub(super) type Claimant<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, ClaimantStatusOf<T, I>, OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A member is inducted into the payroll.
+		Inducted { who: T::AccountId },
+		/// A member registered for a payout.
+		Registered { who: T::AccountId, amount: BalanceOf<T, I> },
+		/// A payment happened.
+		Paid {
+			who: T::AccountId,
+			beneficiary: T::AccountId,
+			amount: BalanceOf<T, I>,
+			id: <T::Paymaster as Pay>::Id,
+		},
+		/// The next cycle begins.
+		CycleStarted { index: CycleIndexOf<T> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// The salary system has already been started.
+		AlreadyStarted,
+		/// The account is not a ranked member.
+		NotMember,
+		/// The account is already inducted.
+		AlreadyInducted,
+		// The account is not yet inducted into the system.
+		NotInducted,
+		/// The member does not have a current valid claim.
+		NoClaim,
+		/// The member's claim is zero.
+		ClaimZero,
+		/// Current cycle's registration period is over.
+		TooLate,
+		/// Current cycle's payment period is not yet begun.
+		TooEarly,
+		/// Cycle is not yet over.
+		NotYet,
+		/// The payout cycles have not yet started.
+		NotStarted,
+		/// There is no budget left for the payout.
+		Bankrupt,
+		/// There was some issue with the mechanism of payment.
+		PayError,
+		/// The payment has neither failed nor succeeded yet.
+		Inconclusive,
+		/// The cycle is after that in which the payment was made.
+		NotCurrent,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Start the first payout cycle.
+		///
+		/// - `origin`: A `Signed` origin of an account.
+		#[pallet::weight(T::WeightInfo::init())]
+		#[pallet::call_index(0)]
+		pub fn init(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			let now = frame_system::Pallet::<T>::block_number();
+			ensure!(!Status::<T, I>::exists(), Error::<T, I>::AlreadyStarted);
+			let status = StatusType {
+				cycle_index: Zero::zero(),
+				cycle_start: now,
+				budget: T::Budget::get(),
+				total_registrations: Zero::zero(),
+				total_unregistered_paid: Zero::zero(),
+			};
+			Status::<T, I>::put(&status);
+
+			Self::deposit_event(Event::<T, I>::CycleStarted { index: status.cycle_index });
+			Ok(Pays::No.into())
+		}
+
+		/// Move to next payout cycle, assuming that the present block is now within that cycle.
+		///
+		/// - `origin`: A `Signed` origin of an account.
+		#[pallet::weight(T::WeightInfo::bump())]
+		#[pallet::call_index(1)]
+		pub fn bump(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			let now = frame_system::Pallet::<T>::block_number();
+			let cycle_period = Self::cycle_period();
+			let mut status = Status::<T, I>::get().ok_or(Error::<T, I>::NotStarted)?;
+			status.cycle_start.saturating_accrue(cycle_period);
+			ensure!(now >= status.cycle_start, Error::<T, I>::NotYet);
+			status.cycle_index.saturating_inc();
+			status.budget = T::Budget::get();
+			status.total_registrations = Zero::zero();
+			status.total_unregistered_paid = Zero::zero();
+			Status::<T, I>::put(&status);
+
+			Self::deposit_event(Event::<T, I>::CycleStarted { index: status.cycle_index });
+			Ok(Pays::No.into())
+		}
+
+		/// Induct oneself into the payout system.
+		#[pallet::weight(T::WeightInfo::induct())]
+		#[pallet::call_index(2)]
+		pub fn induct(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let cycle_index = Status::<T, I>::get().ok_or(Error::<T, I>::NotStarted)?.cycle_index;
+			let _ = T::Members::rank_of(&who).ok_or(Error::<T, I>::NotMember)?;
+			ensure!(!Claimant::<T, I>::contains_key(&who), Error::<T, I>::AlreadyInducted);
+
+			Claimant::<T, I>::insert(
+				&who,
+				ClaimantStatus { last_active: cycle_index, status: Nothing },
+			);
+
+			Self::deposit_event(Event::<T, I>::Inducted { who });
+			Ok(Pays::No.into())
+		}
+
+		/// Register for a payout.
+		///
+		/// Will only work if we are in the first `RegistrationPeriod` blocks since the cycle
+		/// started.
+		///
+		/// - `origin`: A `Signed` origin of an account which is a member of `Members`.
+		#[pallet::weight(T::WeightInfo::register())]
+		#[pallet::call_index(3)]
+		pub fn register(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let rank = T::Members::rank_of(&who).ok_or(Error::<T, I>::NotMember)?;
+			let mut status = Status::<T, I>::get().ok_or(Error::<T, I>::NotStarted)?;
+			let mut claimant = Claimant::<T, I>::get(&who).ok_or(Error::<T, I>::NotInducted)?;
+			let now = frame_system::Pallet::<T>::block_number();
+			ensure!(
+				now < status.cycle_start + T::RegistrationPeriod::get(),
+				Error::<T, I>::TooLate
+			);
+			ensure!(claimant.last_active < status.cycle_index, Error::<T, I>::NoClaim);
+			let payout = T::Salary::get_salary(rank, &who);
+			ensure!(!payout.is_zero(), Error::<T, I>::ClaimZero);
+			claimant.last_active = status.cycle_index;
+			claimant.status = Registered(payout);
+			status.total_registrations.saturating_accrue(payout);
+
+			Claimant::<T, I>::insert(&who, &claimant);
+			Status::<T, I>::put(&status);
+
+			Self::deposit_event(Event::<T, I>::Registered { who, amount: payout });
+			Ok(Pays::No.into())
+		}
+
+		/// Request a payout.
+		///
+		/// Will only work if we are after the first `RegistrationPeriod` blocks since the cycle
+		/// started but by no more than `PayoutPeriod` blocks.
+		///
+		/// - `origin`: A `Signed` origin of an account which is a member of `Members`.
+		#[pallet::weight(T::WeightInfo::payout())]
+		#[pallet::call_index(4)]
+		pub fn payout(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::do_payout(who.clone(), who)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Request a payout to a secondary account.
+		///
+		/// Will only work if we are after the first `RegistrationPeriod` blocks since the cycle
+		/// started but by no more than `PayoutPeriod` blocks.
+		///
+		/// - `origin`: A `Signed` origin of an account which is a member of `Members`.
+		/// - `beneficiary`: The account to receive payment.
+		#[pallet::weight(T::WeightInfo::payout_other())]
+		#[pallet::call_index(5)]
+		pub fn payout_other(
+			origin: OriginFor<T>,
+			beneficiary: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			Self::do_payout(who, beneficiary)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Update a payment's status; if it failed, alter the state so the payment can be retried.
+		///
+		/// This must be called within the same cycle as the failed payment. It will fail with
+		/// `Event::NotCurrent` otherwise.
+		///
+		/// - `origin`: A `Signed` origin of an account which is a member of `Members` who has
+		///   received a payment this cycle.
+		#[pallet::weight(T::WeightInfo::check_payment())]
+		#[pallet::call_index(6)]
+		pub fn check_payment(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+
+			let mut status = Status::<T, I>::get().ok_or(Error::<T, I>::NotStarted)?;
+			let mut claimant = Claimant::<T, I>::get(&who).ok_or(Error::<T, I>::NotInducted)?;
+			ensure!(claimant.last_active == status.cycle_index, Error::<T, I>::NotCurrent);
+			let (id, registered, amount) = match claimant.status {
+				Attempted { id, registered, amount } => (id, registered, amount),
+				_ => return Err(Error::<T, I>::NoClaim.into()),
+			};
+			match T::Paymaster::check_payment(id) {
+				PaymentStatus::Failure => {
+					// Payment failed: we reset back to the status prior to payment.
+					if let Some(amount) = registered {
+						// Account registered; this makes it simple to roll back and allow retry.
+						claimant.status = ClaimState::Registered(amount);
+					} else {
+						// Account didn't register; we set it to `Nothing` but must decrement
+						// the `last_active` also to ensure a retry works.
+						claimant.last_active.saturating_reduce(1u32.into());
+						claimant.status = ClaimState::Nothing;
+						// Since it is not registered, we must walk back our counter for what has
+						// been paid.
+						status.total_unregistered_paid.saturating_reduce(amount);
+					}
+				},
+				PaymentStatus::Success => claimant.status = ClaimState::Nothing,
+				_ => return Err(Error::<T, I>::Inconclusive.into()),
+			}
+			Claimant::<T, I>::insert(&who, &claimant);
+			Status::<T, I>::put(&status);
+
+			Ok(Pays::No.into())
+		}
+	}
+
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		pub fn status() -> Option<StatusOf<T, I>> {
+			Status::<T, I>::get()
+		}
+		pub fn last_active(who: &T::AccountId) -> Result<CycleIndexOf<T>, DispatchError> {
+			Ok(Claimant::<T, I>::get(&who).ok_or(Error::<T, I>::NotInducted)?.last_active)
+		}
+		pub fn cycle_period() -> BlockNumberFor<T> {
+			T::RegistrationPeriod::get() + T::PayoutPeriod::get()
+		}
+		fn do_payout(who: T::AccountId, beneficiary: T::AccountId) -> DispatchResult {
+			let mut status = Status::<T, I>::get().ok_or(Error::<T, I>::NotStarted)?;
+			let mut claimant = Claimant::<T, I>::get(&who).ok_or(Error::<T, I>::NotInducted)?;
+
+			let now = frame_system::Pallet::<T>::block_number();
+			ensure!(
+				now >= status.cycle_start + T::RegistrationPeriod::get(),
+				Error::<T, I>::TooEarly,
+			);
+
+			let (payout, registered) = match claimant.status {
+				Registered(unpaid) if claimant.last_active == status.cycle_index => {
+					// Registered for this cycle. Pay accordingly.
+					let payout = if status.total_registrations <= status.budget {
+						// Can pay in full.
+						unpaid
+					} else {
+						// Must be reduced pro-rata
+						Perbill::from_rational(status.budget, status.total_registrations)
+							.mul_floor(unpaid)
+					};
+					(payout, Some(unpaid))
+				},
+				Nothing | Attempted { .. } if claimant.last_active < status.cycle_index => {
+					// Not registered for this cycle. Pay from whatever is left.
+					let rank = T::Members::rank_of(&who).ok_or(Error::<T, I>::NotMember)?;
+					let ideal_payout = T::Salary::get_salary(rank, &who);
+
+					let pot = status
+						.budget
+						.saturating_sub(status.total_registrations)
+						.saturating_sub(status.total_unregistered_paid);
+
+					let payout = ideal_payout.min(pot);
+					ensure!(!payout.is_zero(), Error::<T, I>::ClaimZero);
+
+					status.total_unregistered_paid.saturating_accrue(payout);
+					(payout, None)
+				},
+				_ => return Err(Error::<T, I>::NoClaim.into()),
+			};
+
+			claimant.last_active = status.cycle_index;
+
+			let id =
+				T::Paymaster::pay(&beneficiary, (), payout).map_err(|_| Error::<T, I>::PayError)?;
+
+			claimant.status = Attempted { registered, id, amount: payout };
+
+			Claimant::<T, I>::insert(&who, &claimant);
+			Status::<T, I>::put(&status);
+
+			Self::deposit_event(Event::<T, I>::Paid { who, beneficiary, amount: payout, id });
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/salary/src/tests.rs b/substrate/frame/salary/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..034dce24b8b3883a768a54074f73510cab02a08a
--- /dev/null
+++ b/substrate/frame/salary/src/tests.rs
@@ -0,0 +1,641 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! The crate's tests.
+
+use std::collections::BTreeMap;
+
+use frame_support::{
+	assert_noop, assert_ok,
+	pallet_prelude::Weight,
+	parameter_types,
+	traits::{tokens::ConvertRank, ConstU32, ConstU64, Everything},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, Identity, IdentityLookup},
+	BuildStorage, DispatchResult,
+};
+use sp_std::cell::RefCell;
+
+use super::*;
+use crate as pallet_salary;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Salary: pallet_salary::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1_000_000, 0));
+}
+impl frame_system::Config for Test {
+	type BaseCallFilter = 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>;
+}
+
+thread_local! {
+	pub static PAID: RefCell<BTreeMap<u64, u64>> = RefCell::new(BTreeMap::new());
+	pub static STATUS: RefCell<BTreeMap<u64, PaymentStatus>> = RefCell::new(BTreeMap::new());
+	pub static LAST_ID: RefCell<u64> = RefCell::new(0u64);
+}
+
+fn paid(who: u64) -> u64 {
+	PAID.with(|p| p.borrow().get(&who).cloned().unwrap_or(0))
+}
+fn unpay(who: u64, amount: u64) {
+	PAID.with(|p| p.borrow_mut().entry(who).or_default().saturating_reduce(amount))
+}
+fn set_status(id: u64, s: PaymentStatus) {
+	STATUS.with(|m| m.borrow_mut().insert(id, s));
+}
+
+pub struct TestPay;
+impl Pay for TestPay {
+	type Beneficiary = u64;
+	type Balance = u64;
+	type Id = u64;
+	type AssetKind = ();
+	type Error = ();
+
+	fn pay(
+		who: &Self::Beneficiary,
+		_: Self::AssetKind,
+		amount: Self::Balance,
+	) -> Result<Self::Id, Self::Error> {
+		PAID.with(|paid| *paid.borrow_mut().entry(*who).or_default() += amount);
+		Ok(LAST_ID.with(|lid| {
+			let x = *lid.borrow();
+			lid.replace(x + 1);
+			x
+		}))
+	}
+	fn check_payment(id: Self::Id) -> PaymentStatus {
+		STATUS.with(|s| s.borrow().get(&id).cloned().unwrap_or(PaymentStatus::Unknown))
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_successful(_: &Self::Beneficiary, _: Self::AssetKind, _: Self::Balance) {}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_concluded(id: Self::Id) {
+		set_status(id, PaymentStatus::Failure)
+	}
+}
+
+thread_local! {
+	pub static CLUB: RefCell<BTreeMap<u64, u64>> = RefCell::new(BTreeMap::new());
+}
+
+pub struct TestClub;
+impl RankedMembers for TestClub {
+	type AccountId = u64;
+	type Rank = u64;
+	fn min_rank() -> Self::Rank {
+		0
+	}
+	fn rank_of(who: &Self::AccountId) -> Option<Self::Rank> {
+		CLUB.with(|club| club.borrow().get(who).cloned())
+	}
+	fn induct(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| club.borrow_mut().insert(*who, 0));
+		Ok(())
+	}
+	fn promote(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| {
+			club.borrow_mut().entry(*who).and_modify(|r| *r += 1);
+		});
+		Ok(())
+	}
+	fn demote(who: &Self::AccountId) -> DispatchResult {
+		CLUB.with(|club| match club.borrow().get(who) {
+			None => Err(sp_runtime::DispatchError::Unavailable),
+			Some(&0) => {
+				club.borrow_mut().remove(&who);
+				Ok(())
+			},
+			Some(_) => {
+				club.borrow_mut().entry(*who).and_modify(|x| *x -= 1);
+				Ok(())
+			},
+		})
+	}
+}
+
+fn set_rank(who: u64, rank: u64) {
+	CLUB.with(|club| club.borrow_mut().insert(who, rank));
+}
+
+parameter_types! {
+	pub static Budget: u64 = 10;
+}
+
+impl Config for Test {
+	type WeightInfo = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Paymaster = TestPay;
+	type Members = TestClub;
+	type Salary = ConvertRank<Identity>;
+	type RegistrationPeriod = ConstU64<2>;
+	type PayoutPeriod = ConstU64<2>;
+	type Budget = Budget;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+fn next_block() {
+	System::set_block_number(System::block_number() + 1);
+}
+
+#[allow(dead_code)]
+fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
+
+#[test]
+fn basic_stuff() {
+	new_test_ext().execute_with(|| {
+		assert!(Salary::last_active(&0).is_err());
+		assert_eq!(Salary::status(), None);
+	});
+}
+
+#[test]
+fn can_start() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_eq!(
+			Salary::status(),
+			Some(StatusType {
+				cycle_index: 0,
+				cycle_start: 1,
+				budget: 10,
+				total_registrations: 0,
+				total_unregistered_paid: 0,
+			})
+		);
+	});
+}
+
+#[test]
+fn bump_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		run_to(4);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_eq!(
+			Salary::status(),
+			Some(StatusType {
+				cycle_index: 1,
+				cycle_start: 5,
+				budget: 10,
+				total_registrations: 0,
+				total_unregistered_paid: 0
+			})
+		);
+
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+
+		BUDGET.with(|b| b.replace(5));
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_eq!(
+			Salary::status(),
+			Some(StatusType {
+				cycle_index: 2,
+				cycle_start: 9,
+				budget: 5,
+				total_registrations: 0,
+				total_unregistered_paid: 0
+			})
+		);
+	});
+}
+
+#[test]
+fn induct_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::NotMember);
+		set_rank(1, 1);
+		assert!(Salary::last_active(&1).is_err());
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::last_active(&1).unwrap(), 0);
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::AlreadyInducted);
+	});
+}
+
+#[test]
+fn unregistered_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::NotStarted);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NotInducted);
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		// No claim on the cycle active during induction.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::TooEarly);
+		run_to(3);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::TooEarly);
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(11);
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn retry_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		// Can't just retry.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		// Check status.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		// Allowed to try again.
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(11);
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn retry_registered_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		// Check status.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		// Allowed to try again.
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+	});
+}
+
+#[test]
+fn retry_payment_later_is_not_allowed() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		// Can't just retry.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		// Next cycle.
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+
+		// Payment did fail but now too late to retry.
+		assert_noop!(Salary::check_payment(RuntimeOrigin::signed(1)), Error::<Test>::NotCurrent);
+
+		// We do get this cycle's payout, but we must wait for the payout period to start.
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::TooEarly);
+
+		run_to(11);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+	});
+}
+
+#[test]
+fn retry_payment_later_without_bump_is_allowed() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		// Payment failed.
+		unpay(1, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		// Next cycle.
+		run_to(9);
+
+		// Payment did fail but we can still retry as long as we don't `bump`.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn retry_payment_to_other_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(6);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+
+		// Payment failed.
+		unpay(10, 1);
+		set_status(0, PaymentStatus::Failure);
+
+		// Can't just retry.
+		assert_noop!(Salary::payout_other(RuntimeOrigin::signed(1), 10), Error::<Test>::NoClaim);
+		// Check status.
+		assert_ok!(Salary::check_payment(RuntimeOrigin::signed(1)));
+		// Allowed to try again.
+		assert_ok!(Salary::payout_other(RuntimeOrigin::signed(1), 10));
+
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+
+		assert_noop!(Salary::payout_other(RuntimeOrigin::signed(1), 10), Error::<Test>::NoClaim);
+		run_to(8);
+		assert_noop!(Salary::bump(RuntimeOrigin::signed(1)), Error::<Test>::NotYet);
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		run_to(11);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(10), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 1);
+	});
+}
+
+#[test]
+fn registered_payment_works() {
+	new_test_ext().execute_with(|| {
+		set_rank(1, 1);
+		assert_noop!(Salary::induct(RuntimeOrigin::signed(1)), Error::<Test>::NotStarted);
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NotInducted);
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		// No claim on the cycle active during induction.
+		assert_noop!(Salary::register(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+		run_to(3);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::status().unwrap().total_registrations, 1);
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 1);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::NoClaim);
+
+		run_to(9);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::status().unwrap().total_registrations, 0);
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_eq!(Salary::status().unwrap().total_registrations, 1);
+		run_to(11);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_eq!(paid(1), 2);
+		assert_eq!(Salary::status().unwrap().total_unregistered_paid, 0);
+	});
+}
+
+#[test]
+fn zero_payment_fails() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 0);
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		run_to(7);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::ClaimZero);
+	});
+}
+
+#[test]
+fn unregistered_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(7);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+
+		assert_eq!(paid(1), 2);
+		assert_eq!(paid(2), 6);
+		assert_eq!(paid(3), 2);
+	});
+}
+
+#[test]
+fn registered_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(3)));
+
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+
+		assert_eq!(paid(1), 1);
+		assert_eq!(paid(2), 3);
+		assert_eq!(paid(3), 6);
+	});
+}
+
+#[test]
+fn mixed_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(2)));
+
+		run_to(7);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(1)));
+
+		assert_eq!(paid(1), 2);
+		assert_eq!(paid(2), 6);
+		assert_eq!(paid(3), 2);
+	});
+}
+
+#[test]
+fn other_mixed_bankrupcy_fails_gracefully() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Salary::init(RuntimeOrigin::signed(1)));
+		set_rank(1, 2);
+		set_rank(2, 6);
+		set_rank(3, 12);
+
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::induct(RuntimeOrigin::signed(3)));
+
+		run_to(5);
+		assert_ok!(Salary::bump(RuntimeOrigin::signed(1)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::register(RuntimeOrigin::signed(3)));
+
+		run_to(7);
+		assert_noop!(Salary::payout(RuntimeOrigin::signed(1)), Error::<Test>::ClaimZero);
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(2)));
+		assert_ok!(Salary::payout(RuntimeOrigin::signed(3)));
+
+		assert_eq!(paid(1), 0);
+		assert_eq!(paid(2), 3);
+		assert_eq!(paid(3), 6);
+	});
+}
diff --git a/substrate/frame/salary/src/weights.rs b/substrate/frame/salary/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3d3b9e315959be023cfe09ae00e993cabedea99a
--- /dev/null
+++ b/substrate/frame/salary/src/weights.rs
@@ -0,0 +1,265 @@
+// 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.
+
+//! Autogenerated weights for pallet_salary
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_salary
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/salary/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_salary.
+pub trait WeightInfo {
+	fn init() -> Weight;
+	fn bump() -> Weight;
+	fn induct() -> Weight;
+	fn register() -> Weight;
+	fn payout() -> Weight;
+	fn payout_other() -> Weight;
+	fn check_payment() -> Weight;
+}
+
+/// Weights for pallet_salary using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	fn init() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4`
+		//  Estimated: `1541`
+		// Minimum execution time: 10_778_000 picoseconds.
+		Weight::from_parts(11_084_000, 1541)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	fn bump() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `86`
+		//  Estimated: `1541`
+		// Minimum execution time: 12_042_000 picoseconds.
+		Weight::from_parts(12_645_000, 1541)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Salary Status (r:1 w:0)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	fn induct() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `395`
+		//  Estimated: `3543`
+		// Minimum execution time: 18_374_000 picoseconds.
+		Weight::from_parts(19_200_000, 3543)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	fn register() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462`
+		//  Estimated: `3543`
+		// Minimum execution time: 22_696_000 picoseconds.
+		Weight::from_parts(23_275_000, 3543)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	fn payout() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462`
+		//  Estimated: `3543`
+		// Minimum execution time: 63_660_000 picoseconds.
+		Weight::from_parts(65_006_000, 3543)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn payout_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462`
+		//  Estimated: `3593`
+		// Minimum execution time: 64_706_000 picoseconds.
+		Weight::from_parts(65_763_000, 3593)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	fn check_payment() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `170`
+		//  Estimated: `3543`
+		// Minimum execution time: 11_838_000 picoseconds.
+		Weight::from_parts(12_323_000, 3543)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	fn init() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4`
+		//  Estimated: `1541`
+		// Minimum execution time: 10_778_000 picoseconds.
+		Weight::from_parts(11_084_000, 1541)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	fn bump() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `86`
+		//  Estimated: `1541`
+		// Minimum execution time: 12_042_000 picoseconds.
+		Weight::from_parts(12_645_000, 1541)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Salary Status (r:1 w:0)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	fn induct() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `395`
+		//  Estimated: `3543`
+		// Minimum execution time: 18_374_000 picoseconds.
+		Weight::from_parts(19_200_000, 3543)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	fn register() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462`
+		//  Estimated: `3543`
+		// Minimum execution time: 22_696_000 picoseconds.
+		Weight::from_parts(23_275_000, 3543)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	fn payout() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462`
+		//  Estimated: `3543`
+		// Minimum execution time: 63_660_000 picoseconds.
+		Weight::from_parts(65_006_000, 3543)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	/// Storage: RankedCollective Members (r:1 w:0)
+	/// Proof: RankedCollective Members (max_values: None, max_size: Some(42), added: 2517, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	fn payout_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `462`
+		//  Estimated: `3593`
+		// Minimum execution time: 64_706_000 picoseconds.
+		Weight::from_parts(65_763_000, 3593)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Salary Status (r:1 w:1)
+	/// Proof: Salary Status (max_values: Some(1), max_size: Some(56), added: 551, mode: MaxEncodedLen)
+	/// Storage: Salary Claimant (r:1 w:1)
+	/// Proof: Salary Claimant (max_values: None, max_size: Some(78), added: 2553, mode: MaxEncodedLen)
+	fn check_payment() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `170`
+		//  Estimated: `3543`
+		// Minimum execution time: 11_838_000 picoseconds.
+		Weight::from_parts(12_323_000, 3543)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/scheduler/Cargo.toml b/substrate/frame/scheduler/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..edc39924319d1db5c67d0a88378904a118abd859
--- /dev/null
+++ b/substrate/frame/scheduler/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-scheduler"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME Scheduler pallet"
+readme = "README.md"
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-weights = { version = "20.0.0", default-features = false, path = "../../primitives/weights" }
+docify = "0.2.1"
+
+[dev-dependencies]
+pallet-preimage = { version = "4.0.0-dev", path = "../preimage" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+substrate-test-utils = { version = "4.0.0-dev", path = "../../test-utils" }
+
+[features]
+default = [ "std" ]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-preimage/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-preimage/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-weights/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-preimage/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/scheduler/README.md b/substrate/frame/scheduler/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..bdd2c2226c88e8318c54f9e61521cc6a0417a47b
--- /dev/null
+++ b/substrate/frame/scheduler/README.md
@@ -0,0 +1,34 @@
+# Scheduler
+A module for scheduling dispatches.
+
+- [`scheduler::Config`](https://docs.rs/pallet-scheduler/latest/pallet_scheduler/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-scheduler/latest/pallet_scheduler/enum.Call.html)
+- [`Module`](https://docs.rs/pallet-scheduler/latest/pallet_scheduler/struct.Module.html)
+
+## Overview
+
+This module exposes capabilities for scheduling dispatches to occur at a
+specified block number or at a specified period. These scheduled dispatches
+may be named or anonymous and may be canceled.
+
+**NOTE:** The scheduled calls will be dispatched with the default filter
+for the origin: namely `frame_system::Config::BaseCallFilter` for all origin
+except root which will get no filter. And not the filter contained in origin
+use to call `fn schedule`.
+
+If a call is scheduled using proxy or whatever mecanism which adds filter,
+then those filter will not be used when dispatching the schedule call.
+
+## Interface
+
+### Dispatchable Functions
+
+* `schedule` - schedule a dispatch, which may be periodic, to occur at a
+  specified block and with a specified priority.
+* `cancel` - cancel a scheduled dispatch, specified by block number and
+  index.
+* `schedule_named` - augments the `schedule` interface with an additional
+  `Vec<u8>` parameter that can be used for identification.
+* `cancel_named` - the named complement to the cancel function.
+
+License: Apache 2.0
diff --git a/substrate/frame/scheduler/src/benchmarking.rs b/substrate/frame/scheduler/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b41cea449654c5035e0cb2024177ae0db549c71b
--- /dev/null
+++ b/substrate/frame/scheduler/src/benchmarking.rs
@@ -0,0 +1,310 @@
+// 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.
+
+//! Scheduler pallet benchmarking.
+
+use super::*;
+use frame_benchmarking::v1::{account, benchmarks, BenchmarkError};
+use frame_support::{
+	ensure,
+	traits::{schedule::Priority, BoundedInline},
+};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use sp_std::{prelude::*, vec};
+
+use crate::Pallet as Scheduler;
+use frame_system::Call as SystemCall;
+
+const SEED: u32 = 0;
+
+const BLOCK_NUMBER: u32 = 2;
+
+type SystemOrigin<T> = <T as frame_system::Config>::RuntimeOrigin;
+
+/// Add `n` items to the schedule.
+///
+/// For `resolved`:
+/// - `
+/// - `None`: aborted (hash without preimage)
+/// - `Some(true)`: hash resolves into call if possible, plain call otherwise
+/// - `Some(false)`: plain call
+fn fill_schedule<T: Config>(
+	when: frame_system::pallet_prelude::BlockNumberFor<T>,
+	n: u32,
+) -> Result<(), &'static str> {
+	let t = DispatchTime::At(when);
+	let origin: <T as Config>::PalletsOrigin = frame_system::RawOrigin::Root.into();
+	for i in 0..n {
+		let call = make_call::<T>(None);
+		let period = Some(((i + 100).into(), 100));
+		let name = u32_to_name(i);
+		Scheduler::<T>::do_schedule_named(name, t, period, 0, origin.clone(), call)?;
+	}
+	ensure!(Agenda::<T>::get(when).len() == n as usize, "didn't fill schedule");
+	Ok(())
+}
+
+fn u32_to_name(i: u32) -> TaskName {
+	i.using_encoded(blake2_256)
+}
+
+fn make_task<T: Config>(
+	periodic: bool,
+	named: bool,
+	signed: bool,
+	maybe_lookup_len: Option<u32>,
+	priority: Priority,
+) -> ScheduledOf<T> {
+	let call = make_call::<T>(maybe_lookup_len);
+	let maybe_periodic = match periodic {
+		true => Some((100u32.into(), 100)),
+		false => None,
+	};
+	let maybe_id = match named {
+		true => Some(u32_to_name(0)),
+		false => None,
+	};
+	let origin = make_origin::<T>(signed);
+	Scheduled { maybe_id, priority, call, maybe_periodic, origin, _phantom: PhantomData }
+}
+
+fn bounded<T: Config>(len: u32) -> Option<Bounded<<T as Config>::RuntimeCall>> {
+	let call =
+		<<T as Config>::RuntimeCall>::from(SystemCall::remark { remark: vec![0; len as usize] });
+	T::Preimages::bound(call).ok()
+}
+
+fn make_call<T: Config>(maybe_lookup_len: Option<u32>) -> Bounded<<T as Config>::RuntimeCall> {
+	let bound = BoundedInline::bound() as u32;
+	let mut len = match maybe_lookup_len {
+		Some(len) => len.min(T::Preimages::MAX_LENGTH as u32 - 2).max(bound) - 3,
+		None => bound.saturating_sub(4),
+	};
+
+	loop {
+		let c = match bounded::<T>(len) {
+			Some(x) => x,
+			None => {
+				len -= 1;
+				continue
+			},
+		};
+		if c.lookup_needed() == maybe_lookup_len.is_some() {
+			break c
+		}
+		if maybe_lookup_len.is_some() {
+			len += 1;
+		} else {
+			if len > 0 {
+				len -= 1;
+			} else {
+				break c
+			}
+		}
+	}
+}
+
+fn make_origin<T: Config>(signed: bool) -> <T as Config>::PalletsOrigin {
+	match signed {
+		true => frame_system::RawOrigin::Signed(account("origin", 0, SEED)).into(),
+		false => frame_system::RawOrigin::Root.into(),
+	}
+}
+
+benchmarks! {
+	// `service_agendas` when no work is done.
+	service_agendas_base {
+		let now = BlockNumberFor::<T>::from(BLOCK_NUMBER);
+		IncompleteSince::<T>::put(now - One::one());
+	}: {
+		Scheduler::<T>::service_agendas(&mut WeightMeter::max_limit(), now, 0);
+	} verify {
+		assert_eq!(IncompleteSince::<T>::get(), Some(now - One::one()));
+	}
+
+	// `service_agenda` when no work is done.
+	service_agenda_base {
+		let now = BLOCK_NUMBER.into();
+		let s in 0 .. T::MaxScheduledPerBlock::get();
+		fill_schedule::<T>(now, s)?;
+		let mut executed = 0;
+	}: {
+		Scheduler::<T>::service_agenda(&mut WeightMeter::max_limit(), &mut executed, now, now, 0);
+	} verify {
+		assert_eq!(executed, 0);
+	}
+
+	// `service_task` when the task is a non-periodic, non-named, non-fetched call which is not
+	// dispatched (e.g. due to being overweight).
+	service_task_base {
+		let now = BLOCK_NUMBER.into();
+		let task = make_task::<T>(false, false, false, None, 0);
+		// prevent any tasks from actually being executed as we only want the surrounding weight.
+		let mut counter = WeightMeter::from_limit(Weight::zero());
+	}: {
+		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
+	} verify {
+		//assert_eq!(result, Ok(()));
+	}
+
+	// `service_task` when the task is a non-periodic, non-named, fetched call (with a known
+	// preimage length) and which is not dispatched (e.g. due to being overweight).
+	#[pov_mode = MaxEncodedLen {
+		// Use measured PoV size for the Preimages since we pass in a length witness.
+		Preimage::PreimageFor: Measured
+	}]
+	service_task_fetched {
+		let s in (BoundedInline::bound() as u32) .. (T::Preimages::MAX_LENGTH as u32);
+		let now = BLOCK_NUMBER.into();
+		let task = make_task::<T>(false, false, false, Some(s), 0);
+		// prevent any tasks from actually being executed as we only want the surrounding weight.
+		let mut counter = WeightMeter::from_limit(Weight::zero());
+	}: {
+		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
+	} verify {
+	}
+
+	// `service_task` when the task is a non-periodic, named, non-fetched call which is not
+	// dispatched (e.g. due to being overweight).
+	service_task_named {
+		let now = BLOCK_NUMBER.into();
+		let task = make_task::<T>(false, true, false, None, 0);
+		// prevent any tasks from actually being executed as we only want the surrounding weight.
+		let mut counter = WeightMeter::from_limit(Weight::zero());
+	}: {
+		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
+	} verify {
+	}
+
+	// `service_task` when the task is a periodic, non-named, non-fetched call which is not
+	// dispatched (e.g. due to being overweight).
+	service_task_periodic {
+		let now = BLOCK_NUMBER.into();
+		let task = make_task::<T>(true, false, false, None, 0);
+		// prevent any tasks from actually being executed as we only want the surrounding weight.
+		let mut counter = WeightMeter::from_limit(Weight::zero());
+	}: {
+		let result = Scheduler::<T>::service_task(&mut counter, now, now, 0, true, task);
+	} verify {
+	}
+
+	// `execute_dispatch` when the origin is `Signed`, not counting the dispatable's weight.
+	execute_dispatch_signed {
+		let mut counter = WeightMeter::max_limit();
+		let origin = make_origin::<T>(true);
+		let call = T::Preimages::realize(&make_call::<T>(None)).unwrap().0;
+	}: {
+		assert!(Scheduler::<T>::execute_dispatch(&mut counter, origin, call).is_ok());
+	}
+	verify {
+	}
+
+	// `execute_dispatch` when the origin is not `Signed`, not counting the dispatable's weight.
+	execute_dispatch_unsigned {
+		let mut counter = WeightMeter::max_limit();
+		let origin = make_origin::<T>(false);
+		let call = T::Preimages::realize(&make_call::<T>(None)).unwrap().0;
+	}: {
+		assert!(Scheduler::<T>::execute_dispatch(&mut counter, origin, call).is_ok());
+	}
+	verify {
+	}
+
+	schedule {
+		let s in 0 .. (T::MaxScheduledPerBlock::get() - 1);
+		let when = BLOCK_NUMBER.into();
+		let periodic = Some((BlockNumberFor::<T>::one(), 100));
+		let priority = 0;
+		// Essentially a no-op call.
+		let call = Box::new(SystemCall::set_storage { items: vec![] }.into());
+
+		fill_schedule::<T>(when, s)?;
+	}: _(RawOrigin::Root, when, periodic, priority, call)
+	verify {
+		ensure!(
+			Agenda::<T>::get(when).len() == (s + 1) as usize,
+			"didn't add to schedule"
+		);
+	}
+
+	cancel {
+		let s in 1 .. T::MaxScheduledPerBlock::get();
+		let when = BLOCK_NUMBER.into();
+
+		fill_schedule::<T>(when, s)?;
+		assert_eq!(Agenda::<T>::get(when).len(), s as usize);
+		let schedule_origin =
+			T::ScheduleOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: _<SystemOrigin<T>>(schedule_origin, when, 0)
+	verify {
+		ensure!(
+			s == 1 || Lookup::<T>::get(u32_to_name(0)).is_none(),
+			"didn't remove from lookup if more than 1 task scheduled for `when`"
+		);
+		// Removed schedule is NONE
+		ensure!(
+			s == 1 || Agenda::<T>::get(when)[0].is_none(),
+			"didn't remove from schedule if more than 1 task scheduled for `when`"
+		);
+		ensure!(
+			s > 1 || Agenda::<T>::get(when).len() == 0,
+			"remove from schedule if only 1 task scheduled for `when`"
+		);
+	}
+
+	schedule_named {
+		let s in 0 .. (T::MaxScheduledPerBlock::get() - 1);
+		let id = u32_to_name(s);
+		let when = BLOCK_NUMBER.into();
+		let periodic = Some((BlockNumberFor::<T>::one(), 100));
+		let priority = 0;
+		// Essentially a no-op call.
+		let call = Box::new(SystemCall::set_storage { items: vec![] }.into());
+
+		fill_schedule::<T>(when, s)?;
+	}: _(RawOrigin::Root, id, when, periodic, priority, call)
+	verify {
+		ensure!(
+			Agenda::<T>::get(when).len() == (s + 1) as usize,
+			"didn't add to schedule"
+		);
+	}
+
+	cancel_named {
+		let s in 1 .. T::MaxScheduledPerBlock::get();
+		let when = BLOCK_NUMBER.into();
+
+		fill_schedule::<T>(when, s)?;
+	}: _(RawOrigin::Root, u32_to_name(0))
+	verify {
+		ensure!(
+			s == 1 || Lookup::<T>::get(u32_to_name(0)).is_none(),
+			"didn't remove from lookup if more than 1 task scheduled for `when`"
+		);
+		// Removed schedule is NONE
+		ensure!(
+			s == 1 || Agenda::<T>::get(when)[0].is_none(),
+			"didn't remove from schedule if more than 1 task scheduled for `when`"
+		);
+		ensure!(
+			s > 1 || Agenda::<T>::get(when).len() == 0,
+			"remove from schedule if only 1 task scheduled for `when`"
+		);
+	}
+
+	impl_benchmark_test_suite!(Scheduler, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/scheduler/src/lib.rs b/substrate/frame/scheduler/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3538331bbd4ca0ebf9a3cf00712bdc9f12914cd6
--- /dev/null
+++ b/substrate/frame/scheduler/src/lib.rs
@@ -0,0 +1,1349 @@
+// 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.
+
+//! > Made with *Substrate*, for *Polkadot*.
+//!
+//! [![github]](https://github.com/paritytech/substrate/frame/fast-unstake) -
+//! [![polkadot]](https://polkadot.network)
+//!
+//! [polkadot]: https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
+//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//!
+//! # Scheduler Pallet
+//!
+//! A Pallet for scheduling runtime calls.
+//!
+//! ## Overview
+//!
+//! This Pallet exposes capabilities for scheduling runtime calls to occur at a specified block
+//! number or at a specified period. These scheduled runtime calls may be named or anonymous and may
+//! be canceled.
+//!
+//! __NOTE:__ Instead of using the filter contained in the origin to call `fn schedule`, scheduled
+//! runtime calls will be dispatched with the default filter for the origin: namely
+//! `frame_system::Config::BaseCallFilter` for all origin types (except root which will get no
+//! filter).
+//!
+//! If a call is scheduled using proxy or whatever mechanism which adds filter, then those filter
+//! will not be used when dispatching the schedule runtime call.
+//!
+//! ### Examples
+//!
+//! 1. Scheduling a runtime call at a specific block.
+#![doc = docify::embed!("src/tests.rs", basic_scheduling_works)]
+//!
+//! 2. Scheduling a preimage hash of a runtime call at a specifc block
+#![doc = docify::embed!("src/tests.rs", scheduling_with_preimages_works)]
+
+//!
+//! ## 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.
+//!
+//! ## Warning
+//!
+//! This Pallet executes all scheduled runtime calls in the [`on_initialize`] hook. Do not execute
+//! any runtime calls which should not be considered mandatory.
+//!
+//! Please be aware that any scheduled runtime calls executed in a future block may __fail__ or may
+//! result in __undefined behavior__ since the runtime could have upgraded between the time of
+//! scheduling and execution. For example, the runtime upgrade could have:
+//!
+//! * Modified the implementation of the runtime call (runtime specification upgrade).
+//!     * Could lead to undefined behavior.
+//! * Removed or changed the ordering/index of the runtime call.
+//!     * Could fail due to the runtime call index not being part of the `Call`.
+//!     * Could lead to undefined behavior, such as executing another runtime call with the same
+//!       index.
+//!
+//! [`on_initialize`]: frame_support::traits::Hooks::on_initialize
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod migration;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{
+		DispatchError, DispatchResult, Dispatchable, GetDispatchInfo, Parameter, RawOrigin,
+	},
+	ensure,
+	traits::{
+		schedule::{self, DispatchTime, MaybeHashed},
+		Bounded, CallerTrait, EnsureOrigin, Get, Hash as PreimageHash, IsType, OriginTrait,
+		PalletInfoAccess, PrivilegeCmp, QueryPreimage, StorageVersion, StorePreimage,
+	},
+	weights::{Weight, WeightMeter},
+};
+use frame_system::{
+	pallet_prelude::BlockNumberFor,
+	{self as system},
+};
+use scale_info::TypeInfo;
+use sp_io::hashing::blake2_256;
+use sp_runtime::{
+	traits::{BadOrigin, One, Saturating, Zero},
+	BoundedVec, RuntimeDebug,
+};
+use sp_std::{borrow::Borrow, cmp::Ordering, marker::PhantomData, prelude::*};
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// Just a simple index for naming period tasks.
+pub type PeriodicIndex = u32;
+/// The location of a scheduled task that can be used to remove it.
+pub type TaskAddress<BlockNumber> = (BlockNumber, u32);
+
+pub type CallOrHashOf<T> =
+	MaybeHashed<<T as Config>::RuntimeCall, <T as frame_system::Config>::Hash>;
+
+#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]
+#[derive(Clone, RuntimeDebug, Encode, Decode)]
+struct ScheduledV1<Call, BlockNumber> {
+	maybe_id: Option<Vec<u8>>,
+	priority: schedule::Priority,
+	call: Call,
+	maybe_periodic: Option<schedule::Period<BlockNumber>>,
+}
+
+/// Information regarding an item to be executed in the future.
+#[cfg_attr(any(feature = "std", test), derive(PartialEq, Eq))]
+#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub struct Scheduled<Name, Call, BlockNumber, PalletsOrigin, AccountId> {
+	/// The unique identity for this task, if there is one.
+	maybe_id: Option<Name>,
+	/// This task's priority.
+	priority: schedule::Priority,
+	/// The call to be dispatched.
+	call: Call,
+	/// If the call is periodic, then this points to the information concerning that.
+	maybe_periodic: Option<schedule::Period<BlockNumber>>,
+	/// The origin with which to dispatch the call.
+	origin: PalletsOrigin,
+	_phantom: PhantomData<AccountId>,
+}
+
+use crate::{Scheduled as ScheduledV3, Scheduled as ScheduledV2};
+
+pub type ScheduledV2Of<T> = ScheduledV2<
+	Vec<u8>,
+	<T as Config>::RuntimeCall,
+	BlockNumberFor<T>,
+	<T as Config>::PalletsOrigin,
+	<T as frame_system::Config>::AccountId,
+>;
+
+pub type ScheduledV3Of<T> = ScheduledV3<
+	Vec<u8>,
+	CallOrHashOf<T>,
+	BlockNumberFor<T>,
+	<T as Config>::PalletsOrigin,
+	<T as frame_system::Config>::AccountId,
+>;
+
+pub type ScheduledOf<T> = Scheduled<
+	TaskName,
+	Bounded<<T as Config>::RuntimeCall>,
+	BlockNumberFor<T>,
+	<T as Config>::PalletsOrigin,
+	<T as frame_system::Config>::AccountId,
+>;
+
+pub(crate) trait MarginalWeightInfo: WeightInfo {
+	fn service_task(maybe_lookup_len: Option<usize>, named: bool, periodic: bool) -> Weight {
+		let base = Self::service_task_base();
+		let mut total = match maybe_lookup_len {
+			None => base,
+			Some(l) => Self::service_task_fetched(l as u32),
+		};
+		if named {
+			total.saturating_accrue(Self::service_task_named().saturating_sub(base));
+		}
+		if periodic {
+			total.saturating_accrue(Self::service_task_periodic().saturating_sub(base));
+		}
+		total
+	}
+}
+impl<T: WeightInfo> MarginalWeightInfo for T {}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{dispatch::PostDispatchInfo, pallet_prelude::*};
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	/// `system::Config` should always be included in our implied traits.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The aggregated origin which the dispatch will take.
+		type RuntimeOrigin: OriginTrait<PalletsOrigin = Self::PalletsOrigin>
+			+ From<Self::PalletsOrigin>
+			+ IsType<<Self as system::Config>::RuntimeOrigin>;
+
+		/// The caller origin, overarching type of all pallets origins.
+		type PalletsOrigin: From<system::RawOrigin<Self::AccountId>>
+			+ CallerTrait<Self::AccountId>
+			+ MaxEncodedLen;
+
+		/// The aggregated call type.
+		type RuntimeCall: Parameter
+			+ Dispatchable<
+				RuntimeOrigin = <Self as Config>::RuntimeOrigin,
+				PostInfo = PostDispatchInfo,
+			> + GetDispatchInfo
+			+ From<system::Call<Self>>;
+
+		/// The maximum weight that may be scheduled per block for any dispatchables.
+		#[pallet::constant]
+		type MaximumWeight: Get<Weight>;
+
+		/// Required origin to schedule or cancel calls.
+		type ScheduleOrigin: EnsureOrigin<<Self as system::Config>::RuntimeOrigin>;
+
+		/// Compare the privileges of origins.
+		///
+		/// This will be used when canceling a task, to ensure that the origin that tries
+		/// to cancel has greater or equal privileges as the origin that created the scheduled task.
+		///
+		/// For simplicity the [`EqualPrivilegeOnly`](frame_support::traits::EqualPrivilegeOnly) can
+		/// be used. This will only check if two given origins are equal.
+		type OriginPrivilegeCmp: PrivilegeCmp<Self::PalletsOrigin>;
+
+		/// The maximum number of scheduled calls in the queue for a single block.
+		///
+		/// NOTE:
+		/// + Dependent pallets' benchmarks might require a higher limit for the setting. Set a
+		/// higher limit under `runtime-benchmarks` feature.
+		#[pallet::constant]
+		type MaxScheduledPerBlock: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// The preimage provider with which we look up call hashes to get the call.
+		type Preimages: QueryPreimage + StorePreimage;
+	}
+
+	#[pallet::storage]
+	pub type IncompleteSince<T: Config> = StorageValue<_, BlockNumberFor<T>>;
+
+	/// Items to be executed, indexed by the block number that they should be executed on.
+	#[pallet::storage]
+	pub type Agenda<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		BlockNumberFor<T>,
+		BoundedVec<Option<ScheduledOf<T>>, T::MaxScheduledPerBlock>,
+		ValueQuery,
+	>;
+
+	/// Lookup from a name to the block number and index of the task.
+	///
+	/// For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4
+	/// identities.
+	#[pallet::storage]
+	pub(crate) type Lookup<T: Config> =
+		StorageMap<_, Twox64Concat, TaskName, TaskAddress<BlockNumberFor<T>>>;
+
+	/// Events type.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Scheduled some task.
+		Scheduled { when: BlockNumberFor<T>, index: u32 },
+		/// Canceled some task.
+		Canceled { when: BlockNumberFor<T>, index: u32 },
+		/// Dispatched some task.
+		Dispatched {
+			task: TaskAddress<BlockNumberFor<T>>,
+			id: Option<TaskName>,
+			result: DispatchResult,
+		},
+		/// The call for the provided hash was not found so the task has been aborted.
+		CallUnavailable { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },
+		/// The given task was unable to be renewed since the agenda is full at that block.
+		PeriodicFailed { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },
+		/// The given task can never be executed since it is overweight.
+		PermanentlyOverweight { task: TaskAddress<BlockNumberFor<T>>, id: Option<TaskName> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Failed to schedule a call
+		FailedToSchedule,
+		/// Cannot find the scheduled call.
+		NotFound,
+		/// Given target block number is in the past.
+		TargetBlockNumberInPast,
+		/// Reschedule failed because it does not change scheduled time.
+		RescheduleNoChange,
+		/// Attempt to use a non-named function on a named task.
+		Named,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// Execute the scheduled calls
+		fn on_initialize(now: BlockNumberFor<T>) -> Weight {
+			let mut weight_counter = WeightMeter::from_limit(T::MaximumWeight::get());
+			Self::service_agendas(&mut weight_counter, now, u32::max_value());
+			weight_counter.consumed()
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Anonymously schedule a task.
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]
+		pub fn schedule(
+			origin: OriginFor<T>,
+			when: BlockNumberFor<T>,
+			maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+			priority: schedule::Priority,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			T::ScheduleOrigin::ensure_origin(origin.clone())?;
+			let origin = <T as Config>::RuntimeOrigin::from(origin);
+			Self::do_schedule(
+				DispatchTime::At(when),
+				maybe_periodic,
+				priority,
+				origin.caller().clone(),
+				T::Preimages::bound(*call)?,
+			)?;
+			Ok(())
+		}
+
+		/// Cancel an anonymously scheduled task.
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as Config>::WeightInfo::cancel(T::MaxScheduledPerBlock::get()))]
+		pub fn cancel(origin: OriginFor<T>, when: BlockNumberFor<T>, index: u32) -> DispatchResult {
+			T::ScheduleOrigin::ensure_origin(origin.clone())?;
+			let origin = <T as Config>::RuntimeOrigin::from(origin);
+			Self::do_cancel(Some(origin.caller().clone()), (when, index))?;
+			Ok(())
+		}
+
+		/// Schedule a named task.
+		#[pallet::call_index(2)]
+		#[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]
+		pub fn schedule_named(
+			origin: OriginFor<T>,
+			id: TaskName,
+			when: BlockNumberFor<T>,
+			maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+			priority: schedule::Priority,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			T::ScheduleOrigin::ensure_origin(origin.clone())?;
+			let origin = <T as Config>::RuntimeOrigin::from(origin);
+			Self::do_schedule_named(
+				id,
+				DispatchTime::At(when),
+				maybe_periodic,
+				priority,
+				origin.caller().clone(),
+				T::Preimages::bound(*call)?,
+			)?;
+			Ok(())
+		}
+
+		/// Cancel a named scheduled task.
+		#[pallet::call_index(3)]
+		#[pallet::weight(<T as Config>::WeightInfo::cancel_named(T::MaxScheduledPerBlock::get()))]
+		pub fn cancel_named(origin: OriginFor<T>, id: TaskName) -> DispatchResult {
+			T::ScheduleOrigin::ensure_origin(origin.clone())?;
+			let origin = <T as Config>::RuntimeOrigin::from(origin);
+			Self::do_cancel_named(Some(origin.caller().clone()), id)?;
+			Ok(())
+		}
+
+		/// Anonymously schedule a task after a delay.
+		#[pallet::call_index(4)]
+		#[pallet::weight(<T as Config>::WeightInfo::schedule(T::MaxScheduledPerBlock::get()))]
+		pub fn schedule_after(
+			origin: OriginFor<T>,
+			after: BlockNumberFor<T>,
+			maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+			priority: schedule::Priority,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			T::ScheduleOrigin::ensure_origin(origin.clone())?;
+			let origin = <T as Config>::RuntimeOrigin::from(origin);
+			Self::do_schedule(
+				DispatchTime::After(after),
+				maybe_periodic,
+				priority,
+				origin.caller().clone(),
+				T::Preimages::bound(*call)?,
+			)?;
+			Ok(())
+		}
+
+		/// Schedule a named task after a delay.
+		#[pallet::call_index(5)]
+		#[pallet::weight(<T as Config>::WeightInfo::schedule_named(T::MaxScheduledPerBlock::get()))]
+		pub fn schedule_named_after(
+			origin: OriginFor<T>,
+			id: TaskName,
+			after: BlockNumberFor<T>,
+			maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+			priority: schedule::Priority,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			T::ScheduleOrigin::ensure_origin(origin.clone())?;
+			let origin = <T as Config>::RuntimeOrigin::from(origin);
+			Self::do_schedule_named(
+				id,
+				DispatchTime::After(after),
+				maybe_periodic,
+				priority,
+				origin.caller().clone(),
+				T::Preimages::bound(*call)?,
+			)?;
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config<Hash = PreimageHash>> Pallet<T> {
+	/// Migrate storage format from V1 to V4.
+	///
+	/// Returns the weight consumed by this migration.
+	pub fn migrate_v1_to_v4() -> Weight {
+		use migration::v1 as old;
+		let mut weight = T::DbWeight::get().reads_writes(1, 1);
+
+		// Delete all undecodable values.
+		// `StorageMap::translate` is not enough since it just skips them and leaves the keys in.
+		let keys = old::Agenda::<T>::iter_keys().collect::<Vec<_>>();
+		for key in keys {
+			weight.saturating_accrue(T::DbWeight::get().reads(1));
+			if let Err(_) = old::Agenda::<T>::try_get(&key) {
+				weight.saturating_accrue(T::DbWeight::get().writes(1));
+				old::Agenda::<T>::remove(&key);
+				log::warn!("Deleted undecodable agenda");
+			}
+		}
+
+		Agenda::<T>::translate::<
+			Vec<Option<ScheduledV1<<T as Config>::RuntimeCall, BlockNumberFor<T>>>>,
+			_,
+		>(|_, agenda| {
+			Some(BoundedVec::truncate_from(
+				agenda
+					.into_iter()
+					.map(|schedule| {
+						weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+
+						schedule.and_then(|schedule| {
+							if let Some(id) = schedule.maybe_id.as_ref() {
+								let name = blake2_256(id);
+								if let Some(item) = old::Lookup::<T>::take(id) {
+									Lookup::<T>::insert(name, item);
+								}
+								weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+							}
+
+							let call = T::Preimages::bound(schedule.call).ok()?;
+
+							if call.lookup_needed() {
+								weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));
+							}
+
+							Some(Scheduled {
+								maybe_id: schedule.maybe_id.map(|x| blake2_256(&x[..])),
+								priority: schedule.priority,
+								call,
+								maybe_periodic: schedule.maybe_periodic,
+								origin: system::RawOrigin::Root.into(),
+								_phantom: Default::default(),
+							})
+						})
+					})
+					.collect::<Vec<_>>(),
+			))
+		});
+
+		#[allow(deprecated)]
+		frame_support::storage::migration::remove_storage_prefix(
+			Self::name().as_bytes(),
+			b"StorageVersion",
+			&[],
+		);
+
+		StorageVersion::new(4).put::<Self>();
+
+		weight + T::DbWeight::get().writes(2)
+	}
+
+	/// Migrate storage format from V2 to V4.
+	///
+	/// Returns the weight consumed by this migration.
+	pub fn migrate_v2_to_v4() -> Weight {
+		use migration::v2 as old;
+		let mut weight = T::DbWeight::get().reads_writes(1, 1);
+
+		// Delete all undecodable values.
+		// `StorageMap::translate` is not enough since it just skips them and leaves the keys in.
+		let keys = old::Agenda::<T>::iter_keys().collect::<Vec<_>>();
+		for key in keys {
+			weight.saturating_accrue(T::DbWeight::get().reads(1));
+			if let Err(_) = old::Agenda::<T>::try_get(&key) {
+				weight.saturating_accrue(T::DbWeight::get().writes(1));
+				old::Agenda::<T>::remove(&key);
+				log::warn!("Deleted undecodable agenda");
+			}
+		}
+
+		Agenda::<T>::translate::<Vec<Option<ScheduledV2Of<T>>>, _>(|_, agenda| {
+			Some(BoundedVec::truncate_from(
+				agenda
+					.into_iter()
+					.map(|schedule| {
+						weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+						schedule.and_then(|schedule| {
+							if let Some(id) = schedule.maybe_id.as_ref() {
+								let name = blake2_256(id);
+								if let Some(item) = old::Lookup::<T>::take(id) {
+									Lookup::<T>::insert(name, item);
+								}
+								weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+							}
+
+							let call = T::Preimages::bound(schedule.call).ok()?;
+							if call.lookup_needed() {
+								weight.saturating_accrue(T::DbWeight::get().reads_writes(0, 1));
+							}
+
+							Some(Scheduled {
+								maybe_id: schedule.maybe_id.map(|x| blake2_256(&x[..])),
+								priority: schedule.priority,
+								call,
+								maybe_periodic: schedule.maybe_periodic,
+								origin: schedule.origin,
+								_phantom: Default::default(),
+							})
+						})
+					})
+					.collect::<Vec<_>>(),
+			))
+		});
+
+		#[allow(deprecated)]
+		frame_support::storage::migration::remove_storage_prefix(
+			Self::name().as_bytes(),
+			b"StorageVersion",
+			&[],
+		);
+
+		StorageVersion::new(4).put::<Self>();
+
+		weight + T::DbWeight::get().writes(2)
+	}
+
+	/// Migrate storage format from V3 to V4.
+	///
+	/// Returns the weight consumed by this migration.
+	#[allow(deprecated)]
+	pub fn migrate_v3_to_v4() -> Weight {
+		use migration::v3 as old;
+		let mut weight = T::DbWeight::get().reads_writes(2, 1);
+
+		// Delete all undecodable values.
+		// `StorageMap::translate` is not enough since it just skips them and leaves the keys in.
+		let blocks = old::Agenda::<T>::iter_keys().collect::<Vec<_>>();
+		for block in blocks {
+			weight.saturating_accrue(T::DbWeight::get().reads(1));
+			if let Err(_) = old::Agenda::<T>::try_get(&block) {
+				weight.saturating_accrue(T::DbWeight::get().writes(1));
+				old::Agenda::<T>::remove(&block);
+				log::warn!("Deleted undecodable agenda of block: {:?}", block);
+			}
+		}
+
+		Agenda::<T>::translate::<Vec<Option<ScheduledV3Of<T>>>, _>(|block, agenda| {
+			log::info!("Migrating agenda of block: {:?}", &block);
+			Some(BoundedVec::truncate_from(
+				agenda
+					.into_iter()
+					.map(|schedule| {
+						weight.saturating_accrue(T::DbWeight::get().reads_writes(1, 1));
+						schedule
+							.and_then(|schedule| {
+								if let Some(id) = schedule.maybe_id.as_ref() {
+									let name = blake2_256(id);
+									if let Some(item) = old::Lookup::<T>::take(id) {
+										Lookup::<T>::insert(name, item);
+										log::info!("Migrated name for id: {:?}", id);
+									} else {
+										log::error!("No name in Lookup for id: {:?}", &id);
+									}
+									weight.saturating_accrue(T::DbWeight::get().reads_writes(2, 2));
+								} else {
+									log::info!("Schedule is unnamed");
+								}
+
+								let call = match schedule.call {
+									MaybeHashed::Hash(h) => {
+										let bounded = Bounded::from_legacy_hash(h);
+										// Check that the call can be decoded in the new runtime.
+										if let Err(err) = T::Preimages::peek::<
+											<T as Config>::RuntimeCall,
+										>(&bounded)
+										{
+											log::error!(
+												"Dropping undecodable call {}: {:?}",
+												&h,
+												&err
+											);
+											return None
+										}
+										weight.saturating_accrue(T::DbWeight::get().reads(1));
+										log::info!("Migrated call by hash, hash: {:?}", h);
+										bounded
+									},
+									MaybeHashed::Value(v) => {
+										let call = T::Preimages::bound(v)
+											.map_err(|e| {
+												log::error!("Could not bound Call: {:?}", e)
+											})
+											.ok()?;
+										if call.lookup_needed() {
+											weight.saturating_accrue(
+												T::DbWeight::get().reads_writes(0, 1),
+											);
+										}
+										log::info!(
+											"Migrated call by value, hash: {:?}",
+											call.hash()
+										);
+										call
+									},
+								};
+
+								Some(Scheduled {
+									maybe_id: schedule.maybe_id.map(|x| blake2_256(&x[..])),
+									priority: schedule.priority,
+									call,
+									maybe_periodic: schedule.maybe_periodic,
+									origin: schedule.origin,
+									_phantom: Default::default(),
+								})
+							})
+							.or_else(|| {
+								log::info!("Schedule in agenda for block {:?} is empty - nothing to do here.", &block);
+								None
+							})
+					})
+					.collect::<Vec<_>>(),
+			))
+		});
+
+		#[allow(deprecated)]
+		frame_support::storage::migration::remove_storage_prefix(
+			Self::name().as_bytes(),
+			b"StorageVersion",
+			&[],
+		);
+
+		StorageVersion::new(4).put::<Self>();
+
+		weight + T::DbWeight::get().writes(2)
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Helper to migrate scheduler when the pallet origin type has changed.
+	pub fn migrate_origin<OldOrigin: Into<T::PalletsOrigin> + codec::Decode>() {
+		Agenda::<T>::translate::<
+			Vec<
+				Option<
+					Scheduled<
+						TaskName,
+						Bounded<<T as Config>::RuntimeCall>,
+						BlockNumberFor<T>,
+						OldOrigin,
+						T::AccountId,
+					>,
+				>,
+			>,
+			_,
+		>(|_, agenda| {
+			Some(BoundedVec::truncate_from(
+				agenda
+					.into_iter()
+					.map(|schedule| {
+						schedule.map(|schedule| Scheduled {
+							maybe_id: schedule.maybe_id,
+							priority: schedule.priority,
+							call: schedule.call,
+							maybe_periodic: schedule.maybe_periodic,
+							origin: schedule.origin.into(),
+							_phantom: Default::default(),
+						})
+					})
+					.collect::<Vec<_>>(),
+			))
+		});
+	}
+
+	fn resolve_time(
+		when: DispatchTime<BlockNumberFor<T>>,
+	) -> Result<BlockNumberFor<T>, DispatchError> {
+		let now = frame_system::Pallet::<T>::block_number();
+
+		let when = match when {
+			DispatchTime::At(x) => x,
+			// The current block has already completed it's scheduled tasks, so
+			// Schedule the task at lest one block after this current block.
+			DispatchTime::After(x) => now.saturating_add(x).saturating_add(One::one()),
+		};
+
+		if when <= now {
+			return Err(Error::<T>::TargetBlockNumberInPast.into())
+		}
+
+		Ok(when)
+	}
+
+	fn place_task(
+		when: BlockNumberFor<T>,
+		what: ScheduledOf<T>,
+	) -> Result<TaskAddress<BlockNumberFor<T>>, (DispatchError, ScheduledOf<T>)> {
+		let maybe_name = what.maybe_id;
+		let index = Self::push_to_agenda(when, what)?;
+		let address = (when, index);
+		if let Some(name) = maybe_name {
+			Lookup::<T>::insert(name, address)
+		}
+		Self::deposit_event(Event::Scheduled { when: address.0, index: address.1 });
+		Ok(address)
+	}
+
+	fn push_to_agenda(
+		when: BlockNumberFor<T>,
+		what: ScheduledOf<T>,
+	) -> Result<u32, (DispatchError, ScheduledOf<T>)> {
+		let mut agenda = Agenda::<T>::get(when);
+		let index = if (agenda.len() as u32) < T::MaxScheduledPerBlock::get() {
+			// will always succeed due to the above check.
+			let _ = agenda.try_push(Some(what));
+			agenda.len() as u32 - 1
+		} else {
+			if let Some(hole_index) = agenda.iter().position(|i| i.is_none()) {
+				agenda[hole_index] = Some(what);
+				hole_index as u32
+			} else {
+				return Err((DispatchError::Exhausted, what))
+			}
+		};
+		Agenda::<T>::insert(when, agenda);
+		Ok(index)
+	}
+
+	/// Remove trailing `None` items of an agenda at `when`. If all items are `None` remove the
+	/// agenda record entirely.
+	fn cleanup_agenda(when: BlockNumberFor<T>) {
+		let mut agenda = Agenda::<T>::get(when);
+		match agenda.iter().rposition(|i| i.is_some()) {
+			Some(i) if agenda.len() > i + 1 => {
+				agenda.truncate(i + 1);
+				Agenda::<T>::insert(when, agenda);
+			},
+			Some(_) => {},
+			None => {
+				Agenda::<T>::remove(when);
+			},
+		}
+	}
+
+	fn do_schedule(
+		when: DispatchTime<BlockNumberFor<T>>,
+		maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+		priority: schedule::Priority,
+		origin: T::PalletsOrigin,
+		call: Bounded<<T as Config>::RuntimeCall>,
+	) -> Result<TaskAddress<BlockNumberFor<T>>, DispatchError> {
+		let when = Self::resolve_time(when)?;
+
+		let lookup_hash = call.lookup_hash();
+
+		// sanitize maybe_periodic
+		let maybe_periodic = maybe_periodic
+			.filter(|p| p.1 > 1 && !p.0.is_zero())
+			// Remove one from the number of repetitions since we will schedule one now.
+			.map(|(p, c)| (p, c - 1));
+		let task = Scheduled {
+			maybe_id: None,
+			priority,
+			call,
+			maybe_periodic,
+			origin,
+			_phantom: PhantomData,
+		};
+		let res = Self::place_task(when, task).map_err(|x| x.0)?;
+
+		if let Some(hash) = lookup_hash {
+			// Request the call to be made available.
+			T::Preimages::request(&hash);
+		}
+
+		Ok(res)
+	}
+
+	fn do_cancel(
+		origin: Option<T::PalletsOrigin>,
+		(when, index): TaskAddress<BlockNumberFor<T>>,
+	) -> Result<(), DispatchError> {
+		let scheduled = Agenda::<T>::try_mutate(when, |agenda| {
+			agenda.get_mut(index as usize).map_or(
+				Ok(None),
+				|s| -> Result<Option<Scheduled<_, _, _, _, _>>, DispatchError> {
+					if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {
+						if matches!(
+							T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),
+							Some(Ordering::Less) | None
+						) {
+							return Err(BadOrigin.into())
+						}
+					};
+					Ok(s.take())
+				},
+			)
+		})?;
+		if let Some(s) = scheduled {
+			T::Preimages::drop(&s.call);
+			if let Some(id) = s.maybe_id {
+				Lookup::<T>::remove(id);
+			}
+			Self::cleanup_agenda(when);
+			Self::deposit_event(Event::Canceled { when, index });
+			Ok(())
+		} else {
+			return Err(Error::<T>::NotFound.into())
+		}
+	}
+
+	fn do_reschedule(
+		(when, index): TaskAddress<BlockNumberFor<T>>,
+		new_time: DispatchTime<BlockNumberFor<T>>,
+	) -> Result<TaskAddress<BlockNumberFor<T>>, DispatchError> {
+		let new_time = Self::resolve_time(new_time)?;
+
+		if new_time == when {
+			return Err(Error::<T>::RescheduleNoChange.into())
+		}
+
+		let task = Agenda::<T>::try_mutate(when, |agenda| {
+			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;
+			ensure!(!matches!(task, Some(Scheduled { maybe_id: Some(_), .. })), Error::<T>::Named);
+			task.take().ok_or(Error::<T>::NotFound)
+		})?;
+		Self::cleanup_agenda(when);
+		Self::deposit_event(Event::Canceled { when, index });
+
+		Self::place_task(new_time, task).map_err(|x| x.0)
+	}
+
+	fn do_schedule_named(
+		id: TaskName,
+		when: DispatchTime<BlockNumberFor<T>>,
+		maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+		priority: schedule::Priority,
+		origin: T::PalletsOrigin,
+		call: Bounded<<T as Config>::RuntimeCall>,
+	) -> Result<TaskAddress<BlockNumberFor<T>>, DispatchError> {
+		// ensure id it is unique
+		if Lookup::<T>::contains_key(&id) {
+			return Err(Error::<T>::FailedToSchedule.into())
+		}
+
+		let when = Self::resolve_time(when)?;
+
+		let lookup_hash = call.lookup_hash();
+
+		// sanitize maybe_periodic
+		let maybe_periodic = maybe_periodic
+			.filter(|p| p.1 > 1 && !p.0.is_zero())
+			// Remove one from the number of repetitions since we will schedule one now.
+			.map(|(p, c)| (p, c - 1));
+
+		let task = Scheduled {
+			maybe_id: Some(id),
+			priority,
+			call,
+			maybe_periodic,
+			origin,
+			_phantom: Default::default(),
+		};
+		let res = Self::place_task(when, task).map_err(|x| x.0)?;
+
+		if let Some(hash) = lookup_hash {
+			// Request the call to be made available.
+			T::Preimages::request(&hash);
+		}
+
+		Ok(res)
+	}
+
+	fn do_cancel_named(origin: Option<T::PalletsOrigin>, id: TaskName) -> DispatchResult {
+		Lookup::<T>::try_mutate_exists(id, |lookup| -> DispatchResult {
+			if let Some((when, index)) = lookup.take() {
+				let i = index as usize;
+				Agenda::<T>::try_mutate(when, |agenda| -> DispatchResult {
+					if let Some(s) = agenda.get_mut(i) {
+						if let (Some(ref o), Some(ref s)) = (origin, s.borrow()) {
+							if matches!(
+								T::OriginPrivilegeCmp::cmp_privilege(o, &s.origin),
+								Some(Ordering::Less) | None
+							) {
+								return Err(BadOrigin.into())
+							}
+							T::Preimages::drop(&s.call);
+						}
+						*s = None;
+					}
+					Ok(())
+				})?;
+				Self::cleanup_agenda(when);
+				Self::deposit_event(Event::Canceled { when, index });
+				Ok(())
+			} else {
+				return Err(Error::<T>::NotFound.into())
+			}
+		})
+	}
+
+	fn do_reschedule_named(
+		id: TaskName,
+		new_time: DispatchTime<BlockNumberFor<T>>,
+	) -> Result<TaskAddress<BlockNumberFor<T>>, DispatchError> {
+		let new_time = Self::resolve_time(new_time)?;
+
+		let lookup = Lookup::<T>::get(id);
+		let (when, index) = lookup.ok_or(Error::<T>::NotFound)?;
+
+		if new_time == when {
+			return Err(Error::<T>::RescheduleNoChange.into())
+		}
+
+		let task = Agenda::<T>::try_mutate(when, |agenda| {
+			let task = agenda.get_mut(index as usize).ok_or(Error::<T>::NotFound)?;
+			task.take().ok_or(Error::<T>::NotFound)
+		})?;
+		Self::cleanup_agenda(when);
+		Self::deposit_event(Event::Canceled { when, index });
+		Self::place_task(new_time, task).map_err(|x| x.0)
+	}
+}
+
+enum ServiceTaskError {
+	/// Could not be executed due to missing preimage.
+	Unavailable,
+	/// Could not be executed due to weight limitations.
+	Overweight,
+}
+use ServiceTaskError::*;
+
+impl<T: Config> Pallet<T> {
+	/// Service up to `max` agendas queue starting from earliest incompletely executed agenda.
+	fn service_agendas(weight: &mut WeightMeter, now: BlockNumberFor<T>, max: u32) {
+		if weight.try_consume(T::WeightInfo::service_agendas_base()).is_err() {
+			return
+		}
+
+		let mut incomplete_since = now + One::one();
+		let mut when = IncompleteSince::<T>::take().unwrap_or(now);
+		let mut executed = 0;
+
+		let max_items = T::MaxScheduledPerBlock::get();
+		let mut count_down = max;
+		let service_agenda_base_weight = T::WeightInfo::service_agenda_base(max_items);
+		while count_down > 0 && when <= now && weight.can_consume(service_agenda_base_weight) {
+			if !Self::service_agenda(weight, &mut executed, now, when, u32::max_value()) {
+				incomplete_since = incomplete_since.min(when);
+			}
+			when.saturating_inc();
+			count_down.saturating_dec();
+		}
+		incomplete_since = incomplete_since.min(when);
+		if incomplete_since <= now {
+			IncompleteSince::<T>::put(incomplete_since);
+		}
+	}
+
+	/// Returns `true` if the agenda was fully completed, `false` if it should be revisited at a
+	/// later block.
+	fn service_agenda(
+		weight: &mut WeightMeter,
+		executed: &mut u32,
+		now: BlockNumberFor<T>,
+		when: BlockNumberFor<T>,
+		max: u32,
+	) -> bool {
+		let mut agenda = Agenda::<T>::get(when);
+		let mut ordered = agenda
+			.iter()
+			.enumerate()
+			.filter_map(|(index, maybe_item)| {
+				maybe_item.as_ref().map(|item| (index as u32, item.priority))
+			})
+			.collect::<Vec<_>>();
+		ordered.sort_by_key(|k| k.1);
+		let within_limit = weight
+			.try_consume(T::WeightInfo::service_agenda_base(ordered.len() as u32))
+			.is_ok();
+		debug_assert!(within_limit, "weight limit should have been checked in advance");
+
+		// Items which we know can be executed and have postponed for execution in a later block.
+		let mut postponed = (ordered.len() as u32).saturating_sub(max);
+		// Items which we don't know can ever be executed.
+		let mut dropped = 0;
+
+		for (agenda_index, _) in ordered.into_iter().take(max as usize) {
+			let task = match agenda[agenda_index as usize].take() {
+				None => continue,
+				Some(t) => t,
+			};
+			let base_weight = T::WeightInfo::service_task(
+				task.call.lookup_len().map(|x| x as usize),
+				task.maybe_id.is_some(),
+				task.maybe_periodic.is_some(),
+			);
+			if !weight.can_consume(base_weight) {
+				postponed += 1;
+				break
+			}
+			let result = Self::service_task(weight, now, when, agenda_index, *executed == 0, task);
+			agenda[agenda_index as usize] = match result {
+				Err((Unavailable, slot)) => {
+					dropped += 1;
+					slot
+				},
+				Err((Overweight, slot)) => {
+					postponed += 1;
+					slot
+				},
+				Ok(()) => {
+					*executed += 1;
+					None
+				},
+			};
+		}
+		if postponed > 0 || dropped > 0 {
+			Agenda::<T>::insert(when, agenda);
+		} else {
+			Agenda::<T>::remove(when);
+		}
+
+		postponed == 0
+	}
+
+	/// Service (i.e. execute) the given task, being careful not to overflow the `weight` counter.
+	///
+	/// This involves:
+	/// - removing and potentially replacing the `Lookup` entry for the task.
+	/// - realizing the task's call which can include a preimage lookup.
+	/// - Rescheduling the task for execution in a later agenda if periodic.
+	fn service_task(
+		weight: &mut WeightMeter,
+		now: BlockNumberFor<T>,
+		when: BlockNumberFor<T>,
+		agenda_index: u32,
+		is_first: bool,
+		mut task: ScheduledOf<T>,
+	) -> Result<(), (ServiceTaskError, Option<ScheduledOf<T>>)> {
+		if let Some(ref id) = task.maybe_id {
+			Lookup::<T>::remove(id);
+		}
+
+		let (call, lookup_len) = match T::Preimages::peek(&task.call) {
+			Ok(c) => c,
+			Err(_) => return Err((Unavailable, Some(task))),
+		};
+
+		let _ = weight.try_consume(T::WeightInfo::service_task(
+			lookup_len.map(|x| x as usize),
+			task.maybe_id.is_some(),
+			task.maybe_periodic.is_some(),
+		));
+
+		match Self::execute_dispatch(weight, task.origin.clone(), call) {
+			Err(Unavailable) => {
+				debug_assert!(false, "Checked to exist with `peek`");
+				Self::deposit_event(Event::CallUnavailable {
+					task: (when, agenda_index),
+					id: task.maybe_id,
+				});
+				Err((Unavailable, Some(task)))
+			},
+			Err(Overweight) if is_first => {
+				T::Preimages::drop(&task.call);
+				Self::deposit_event(Event::PermanentlyOverweight {
+					task: (when, agenda_index),
+					id: task.maybe_id,
+				});
+				Err((Unavailable, Some(task)))
+			},
+			Err(Overweight) => Err((Overweight, Some(task))),
+			Ok(result) => {
+				Self::deposit_event(Event::Dispatched {
+					task: (when, agenda_index),
+					id: task.maybe_id,
+					result,
+				});
+				if let &Some((period, count)) = &task.maybe_periodic {
+					if count > 1 {
+						task.maybe_periodic = Some((period, count - 1));
+					} else {
+						task.maybe_periodic = None;
+					}
+					let wake = now.saturating_add(period);
+					match Self::place_task(wake, task) {
+						Ok(_) => {},
+						Err((_, task)) => {
+							// TODO: Leave task in storage somewhere for it to be rescheduled
+							// manually.
+							T::Preimages::drop(&task.call);
+							Self::deposit_event(Event::PeriodicFailed {
+								task: (when, agenda_index),
+								id: task.maybe_id,
+							});
+						},
+					}
+				} else {
+					T::Preimages::drop(&task.call);
+				}
+				Ok(())
+			},
+		}
+	}
+
+	/// Make a dispatch to the given `call` from the given `origin`, ensuring that the `weight`
+	/// counter does not exceed its limit and that it is counted accurately (e.g. accounted using
+	/// post info if available).
+	///
+	/// NOTE: Only the weight for this function will be counted (origin lookup, dispatch and the
+	/// call itself).
+	fn execute_dispatch(
+		weight: &mut WeightMeter,
+		origin: T::PalletsOrigin,
+		call: <T as Config>::RuntimeCall,
+	) -> Result<DispatchResult, ServiceTaskError> {
+		let base_weight = match origin.as_system_ref() {
+			Some(&RawOrigin::Signed(_)) => T::WeightInfo::execute_dispatch_signed(),
+			_ => T::WeightInfo::execute_dispatch_unsigned(),
+		};
+		let call_weight = call.get_dispatch_info().weight;
+		// We only allow a scheduled call if it cannot push the weight past the limit.
+		let max_weight = base_weight.saturating_add(call_weight);
+
+		if !weight.can_consume(max_weight) {
+			return Err(Overweight)
+		}
+
+		let dispatch_origin = origin.into();
+		let (maybe_actual_call_weight, result) = match call.dispatch(dispatch_origin) {
+			Ok(post_info) => (post_info.actual_weight, Ok(())),
+			Err(error_and_info) =>
+				(error_and_info.post_info.actual_weight, Err(error_and_info.error)),
+		};
+		let call_weight = maybe_actual_call_weight.unwrap_or(call_weight);
+		let _ = weight.try_consume(base_weight);
+		let _ = weight.try_consume(call_weight);
+		Ok(result)
+	}
+}
+
+impl<T: Config<Hash = PreimageHash>>
+	schedule::v2::Anon<BlockNumberFor<T>, <T as Config>::RuntimeCall, T::PalletsOrigin> for Pallet<T>
+{
+	type Address = TaskAddress<BlockNumberFor<T>>;
+	type Hash = T::Hash;
+
+	fn schedule(
+		when: DispatchTime<BlockNumberFor<T>>,
+		maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+		priority: schedule::Priority,
+		origin: T::PalletsOrigin,
+		call: CallOrHashOf<T>,
+	) -> Result<Self::Address, DispatchError> {
+		let call = call.as_value().ok_or(DispatchError::CannotLookup)?;
+		let call = T::Preimages::bound(call)?.transmute();
+		Self::do_schedule(when, maybe_periodic, priority, origin, call)
+	}
+
+	fn cancel((when, index): Self::Address) -> Result<(), ()> {
+		Self::do_cancel(None, (when, index)).map_err(|_| ())
+	}
+
+	fn reschedule(
+		address: Self::Address,
+		when: DispatchTime<BlockNumberFor<T>>,
+	) -> Result<Self::Address, DispatchError> {
+		Self::do_reschedule(address, when)
+	}
+
+	fn next_dispatch_time((when, index): Self::Address) -> Result<BlockNumberFor<T>, ()> {
+		Agenda::<T>::get(when).get(index as usize).ok_or(()).map(|_| when)
+	}
+}
+
+impl<T: Config<Hash = PreimageHash>>
+	schedule::v2::Named<BlockNumberFor<T>, <T as Config>::RuntimeCall, T::PalletsOrigin> for Pallet<T>
+{
+	type Address = TaskAddress<BlockNumberFor<T>>;
+	type Hash = T::Hash;
+
+	fn schedule_named(
+		id: Vec<u8>,
+		when: DispatchTime<BlockNumberFor<T>>,
+		maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+		priority: schedule::Priority,
+		origin: T::PalletsOrigin,
+		call: CallOrHashOf<T>,
+	) -> Result<Self::Address, ()> {
+		let call = call.as_value().ok_or(())?;
+		let call = T::Preimages::bound(call).map_err(|_| ())?.transmute();
+		let name = blake2_256(&id[..]);
+		Self::do_schedule_named(name, when, maybe_periodic, priority, origin, call).map_err(|_| ())
+	}
+
+	fn cancel_named(id: Vec<u8>) -> Result<(), ()> {
+		let name = blake2_256(&id[..]);
+		Self::do_cancel_named(None, name).map_err(|_| ())
+	}
+
+	fn reschedule_named(
+		id: Vec<u8>,
+		when: DispatchTime<BlockNumberFor<T>>,
+	) -> Result<Self::Address, DispatchError> {
+		let name = blake2_256(&id[..]);
+		Self::do_reschedule_named(name, when)
+	}
+
+	fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumberFor<T>, ()> {
+		let name = blake2_256(&id[..]);
+		Lookup::<T>::get(name)
+			.and_then(|(when, index)| Agenda::<T>::get(when).get(index as usize).map(|_| when))
+			.ok_or(())
+	}
+}
+
+impl<T: Config> schedule::v3::Anon<BlockNumberFor<T>, <T as Config>::RuntimeCall, T::PalletsOrigin>
+	for Pallet<T>
+{
+	type Address = TaskAddress<BlockNumberFor<T>>;
+
+	fn schedule(
+		when: DispatchTime<BlockNumberFor<T>>,
+		maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+		priority: schedule::Priority,
+		origin: T::PalletsOrigin,
+		call: Bounded<<T as Config>::RuntimeCall>,
+	) -> Result<Self::Address, DispatchError> {
+		Self::do_schedule(when, maybe_periodic, priority, origin, call)
+	}
+
+	fn cancel((when, index): Self::Address) -> Result<(), DispatchError> {
+		Self::do_cancel(None, (when, index)).map_err(map_err_to_v3_err::<T>)
+	}
+
+	fn reschedule(
+		address: Self::Address,
+		when: DispatchTime<BlockNumberFor<T>>,
+	) -> Result<Self::Address, DispatchError> {
+		Self::do_reschedule(address, when).map_err(map_err_to_v3_err::<T>)
+	}
+
+	fn next_dispatch_time(
+		(when, index): Self::Address,
+	) -> Result<BlockNumberFor<T>, DispatchError> {
+		Agenda::<T>::get(when)
+			.get(index as usize)
+			.ok_or(DispatchError::Unavailable)
+			.map(|_| when)
+	}
+}
+
+use schedule::v3::TaskName;
+
+impl<T: Config> schedule::v3::Named<BlockNumberFor<T>, <T as Config>::RuntimeCall, T::PalletsOrigin>
+	for Pallet<T>
+{
+	type Address = TaskAddress<BlockNumberFor<T>>;
+
+	fn schedule_named(
+		id: TaskName,
+		when: DispatchTime<BlockNumberFor<T>>,
+		maybe_periodic: Option<schedule::Period<BlockNumberFor<T>>>,
+		priority: schedule::Priority,
+		origin: T::PalletsOrigin,
+		call: Bounded<<T as Config>::RuntimeCall>,
+	) -> Result<Self::Address, DispatchError> {
+		Self::do_schedule_named(id, when, maybe_periodic, priority, origin, call)
+	}
+
+	fn cancel_named(id: TaskName) -> Result<(), DispatchError> {
+		Self::do_cancel_named(None, id).map_err(map_err_to_v3_err::<T>)
+	}
+
+	fn reschedule_named(
+		id: TaskName,
+		when: DispatchTime<BlockNumberFor<T>>,
+	) -> Result<Self::Address, DispatchError> {
+		Self::do_reschedule_named(id, when).map_err(map_err_to_v3_err::<T>)
+	}
+
+	fn next_dispatch_time(id: TaskName) -> Result<BlockNumberFor<T>, DispatchError> {
+		Lookup::<T>::get(id)
+			.and_then(|(when, index)| Agenda::<T>::get(when).get(index as usize).map(|_| when))
+			.ok_or(DispatchError::Unavailable)
+	}
+}
+
+/// Maps a pallet error to an `schedule::v3` error.
+fn map_err_to_v3_err<T: Config>(err: DispatchError) -> DispatchError {
+	if err == DispatchError::from(Error::<T>::NotFound) {
+		DispatchError::Unavailable
+	} else {
+		err
+	}
+}
diff --git a/substrate/frame/scheduler/src/migration.rs b/substrate/frame/scheduler/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..06259768f0aa1be7ef836284c3aecf8e5070b117
--- /dev/null
+++ b/substrate/frame/scheduler/src/migration.rs
@@ -0,0 +1,563 @@
+// 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.
+
+//! Migrations for the scheduler pallet.
+
+use super::*;
+use frame_support::traits::OnRuntimeUpgrade;
+use frame_system::pallet_prelude::BlockNumberFor;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// The log target.
+const TARGET: &'static str = "runtime::scheduler::migration";
+
+pub mod v1 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type Agenda<T: Config> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		BlockNumberFor<T>,
+		Vec<Option<ScheduledV1<<T as Config>::RuntimeCall, BlockNumberFor<T>>>>,
+		ValueQuery,
+	>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type Lookup<T: Config> =
+		StorageMap<Pallet<T>, Twox64Concat, Vec<u8>, TaskAddress<BlockNumberFor<T>>>;
+}
+
+pub mod v2 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type Agenda<T: Config> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		BlockNumberFor<T>,
+		Vec<Option<ScheduledV2Of<T>>>,
+		ValueQuery,
+	>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type Lookup<T: Config> =
+		StorageMap<Pallet<T>, Twox64Concat, Vec<u8>, TaskAddress<BlockNumberFor<T>>>;
+}
+
+pub mod v3 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[frame_support::storage_alias]
+	pub(crate) type Agenda<T: Config> = StorageMap<
+		Pallet<T>,
+		Twox64Concat,
+		BlockNumberFor<T>,
+		Vec<Option<ScheduledV3Of<T>>>,
+		ValueQuery,
+	>;
+
+	#[frame_support::storage_alias]
+	pub(crate) type Lookup<T: Config> =
+		StorageMap<Pallet<T>, Twox64Concat, Vec<u8>, TaskAddress<BlockNumberFor<T>>>;
+
+	/// Migrate the scheduler pallet from V3 to V4.
+	pub struct MigrateToV4<T>(sp_std::marker::PhantomData<T>);
+
+	impl<T: Config<Hash = PreimageHash>> OnRuntimeUpgrade for MigrateToV4<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			ensure!(StorageVersion::get::<Pallet<T>>() == 3, "Can only upgrade from version 3");
+
+			let agendas = Agenda::<T>::iter_keys().count() as u32;
+			let decodable_agendas = Agenda::<T>::iter_values().count() as u32;
+			if agendas != decodable_agendas {
+				// This is not necessarily an error, but can happen when there are Calls
+				// in an Agenda that are not valid anymore with the new runtime.
+				log::error!(
+					target: TARGET,
+					"Can only decode {} of {} agendas - others will be dropped",
+					decodable_agendas,
+					agendas
+				);
+			}
+			log::info!(target: TARGET, "Trying to migrate {} agendas...", decodable_agendas);
+
+			// Check that no agenda overflows `MaxScheduledPerBlock`.
+			let max_scheduled_per_block = T::MaxScheduledPerBlock::get() as usize;
+			for (block_number, agenda) in Agenda::<T>::iter() {
+				if agenda.iter().cloned().filter_map(|s| s).count() > max_scheduled_per_block {
+					log::error!(
+						target: TARGET,
+						"Would truncate agenda of block {:?} from {} items to {} items.",
+						block_number,
+						agenda.len(),
+						max_scheduled_per_block,
+					);
+					return Err("Agenda would overflow `MaxScheduledPerBlock`.".into())
+				}
+			}
+			// Check that bounding the calls will not overflow `MAX_LENGTH`.
+			let max_length = T::Preimages::MAX_LENGTH as usize;
+			for (block_number, agenda) in Agenda::<T>::iter() {
+				for schedule in agenda.iter().cloned().filter_map(|s| s) {
+					match schedule.call {
+						frame_support::traits::schedule::MaybeHashed::Value(call) => {
+							let l = call.using_encoded(|c| c.len());
+							if l > max_length {
+								log::error!(
+									target: TARGET,
+									"Call in agenda of block {:?} is too large: {} byte",
+									block_number,
+									l,
+								);
+								return Err("Call is too large.".into())
+							}
+						},
+						_ => (),
+					}
+				}
+			}
+
+			Ok((decodable_agendas as u32).encode())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			let version = StorageVersion::get::<Pallet<T>>();
+			if version != 3 {
+				log::warn!(
+					target: TARGET,
+					"skipping v3 to v4 migration: executed on wrong storage version.\
+				Expected version 3, found {:?}",
+					version,
+				);
+				return T::DbWeight::get().reads(1)
+			}
+
+			crate::Pallet::<T>::migrate_v3_to_v4()
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			ensure!(StorageVersion::get::<Pallet<T>>() == 4, "Must upgrade");
+
+			// Check that everything decoded fine.
+			for k in crate::Agenda::<T>::iter_keys() {
+				ensure!(crate::Agenda::<T>::try_get(k).is_ok(), "Cannot decode V4 Agenda");
+			}
+
+			let old_agendas: u32 =
+				Decode::decode(&mut &state[..]).expect("pre_upgrade provides a valid state; qed");
+			let new_agendas = crate::Agenda::<T>::iter_keys().count() as u32;
+			if old_agendas != new_agendas {
+				// This is not necessarily an error, but can happen when there are Calls
+				// in an Agenda that are not valid anymore in the new runtime.
+				log::error!(
+					target: TARGET,
+					"Did not migrate all Agendas. Previous {}, Now {}",
+					old_agendas,
+					new_agendas,
+				);
+			} else {
+				log::info!(target: TARGET, "Migrated {} agendas.", new_agendas);
+			}
+
+			Ok(())
+		}
+	}
+}
+
+pub mod v4 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	/// This migration cleans up empty agendas of the V4 scheduler.
+	///
+	/// This should be run on a scheduler that does not have
+	/// <https://github.com/paritytech/substrate/pull/12989> since it piles up `None`-only agendas. This does not modify the pallet version.
+	pub struct CleanupAgendas<T>(sp_std::marker::PhantomData<T>);
+
+	impl<T: Config> OnRuntimeUpgrade for CleanupAgendas<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			assert_eq!(
+				StorageVersion::get::<Pallet<T>>(),
+				4,
+				"Can only cleanup agendas of the V4 scheduler"
+			);
+
+			let agendas = Agenda::<T>::iter_keys().count();
+			let non_empty_agendas =
+				Agenda::<T>::iter_values().filter(|a| a.iter().any(|s| s.is_some())).count();
+			log::info!(
+				target: TARGET,
+				"There are {} total and {} non-empty agendas",
+				agendas,
+				non_empty_agendas
+			);
+
+			Ok((agendas as u32, non_empty_agendas as u32).encode())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			let version = StorageVersion::get::<Pallet<T>>();
+			if version != 4 {
+				log::warn!(target: TARGET, "Skipping CleanupAgendas migration since it was run on the wrong version: {:?} != 4", version);
+				return T::DbWeight::get().reads(1)
+			}
+
+			let keys = Agenda::<T>::iter_keys().collect::<Vec<_>>();
+			let mut writes = 0;
+			for k in &keys {
+				let mut schedules = Agenda::<T>::get(k);
+				let all_schedules = schedules.len();
+				let suffix_none_schedules =
+					schedules.iter().rev().take_while(|s| s.is_none()).count();
+
+				match all_schedules.checked_sub(suffix_none_schedules) {
+					Some(0) => {
+						log::info!(
+							"Deleting None-only agenda {:?} with {} entries",
+							k,
+							all_schedules
+						);
+						Agenda::<T>::remove(k);
+						writes.saturating_inc();
+					},
+					Some(ne) if ne > 0 => {
+						log::info!(
+							"Removing {} schedules of {} from agenda {:?}, now {:?}",
+							suffix_none_schedules,
+							all_schedules,
+							ne,
+							k
+						);
+						schedules.truncate(ne);
+						Agenda::<T>::insert(k, schedules);
+						writes.saturating_inc();
+					},
+					Some(_) => {
+						frame_support::defensive!(
+							// Bad but let's not panic.
+							"Cannot have more None suffix schedules that schedules in total"
+						);
+					},
+					None => {
+						log::info!("Agenda {:?} does not have any None suffix schedules", k);
+					},
+				}
+			}
+
+			// We don't modify the pallet version.
+
+			T::DbWeight::get().reads_writes(1 + keys.len().saturating_mul(2) as u64, writes)
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			ensure!(StorageVersion::get::<Pallet<T>>() == 4, "Version must not change");
+
+			let (old_agendas, non_empty_agendas): (u32, u32) =
+				Decode::decode(&mut state.as_ref()).expect("Must decode pre_upgrade state");
+			let new_agendas = Agenda::<T>::iter_keys().count() as u32;
+
+			match old_agendas.checked_sub(new_agendas) {
+				Some(0) => log::warn!(
+					target: TARGET,
+					"Did not clean up any agendas. v4::CleanupAgendas can be removed."
+				),
+				Some(n) => {
+					log::info!(target: TARGET, "Cleaned up {} agendas, now {}", n, new_agendas)
+				},
+				None => unreachable!(
+					"Number of agendas cannot increase, old {} new {}",
+					old_agendas, new_agendas
+				),
+			}
+			ensure!(new_agendas == non_empty_agendas, "Expected to keep all non-empty agendas");
+
+			Ok(())
+		}
+	}
+}
+
+#[cfg(test)]
+#[cfg(feature = "try-runtime")]
+mod test {
+	use super::*;
+	use crate::mock::*;
+	use frame_support::Hashable;
+	use sp_std::borrow::Cow;
+	use substrate_test_utils::assert_eq_uvec;
+
+	#[test]
+	#[allow(deprecated)]
+	fn migration_v3_to_v4_works() {
+		new_test_ext().execute_with(|| {
+			// Assume that we are at V3.
+			StorageVersion::new(3).put::<Scheduler>();
+
+			// Call that will be bounded to a `Lookup`.
+			let large_call =
+				RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 1024] });
+			// Call that can be inlined.
+			let small_call =
+				RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 10] });
+			// Call that is already hashed and can will be converted to `Legacy`.
+			let hashed_call =
+				RuntimeCall::System(frame_system::Call::remark { remark: vec![0; 2048] });
+			let bound_hashed_call = Preimage::bound(hashed_call.clone()).unwrap();
+			assert!(bound_hashed_call.lookup_needed());
+			// A Call by hash that will fail to decode becomes `None`.
+			let trash_data = vec![255u8; 1024];
+			let undecodable_hash = Preimage::note(Cow::Borrowed(&trash_data)).unwrap();
+
+			for i in 0..2u64 {
+				let k = i.twox_64_concat();
+				let old = vec![
+					Some(ScheduledV3Of::<Test> {
+						maybe_id: None,
+						priority: i as u8 + 10,
+						call: small_call.clone().into(),
+						maybe_periodic: None, // 1
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+					None,
+					Some(ScheduledV3Of::<Test> {
+						maybe_id: Some(vec![i as u8; 32]),
+						priority: 123,
+						call: large_call.clone().into(),
+						maybe_periodic: Some((4u64, 20)),
+						origin: signed(i),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+					Some(ScheduledV3Of::<Test> {
+						maybe_id: Some(vec![255 - i as u8; 320]),
+						priority: 123,
+						call: MaybeHashed::Hash(bound_hashed_call.hash()),
+						maybe_periodic: Some((8u64, 10)),
+						origin: signed(i),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+					Some(ScheduledV3Of::<Test> {
+						maybe_id: Some(vec![i as u8; 320]),
+						priority: 123,
+						call: MaybeHashed::Hash(undecodable_hash.clone()),
+						maybe_periodic: Some((4u64, 20)),
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+				];
+				frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
+			}
+
+			let state = v3::MigrateToV4::<Test>::pre_upgrade().unwrap();
+			let _w = v3::MigrateToV4::<Test>::on_runtime_upgrade();
+			v3::MigrateToV4::<Test>::post_upgrade(state).unwrap();
+
+			let mut x = Agenda::<Test>::iter().map(|x| (x.0, x.1.into_inner())).collect::<Vec<_>>();
+			x.sort_by_key(|x| x.0);
+
+			let bound_large_call = Preimage::bound(large_call).unwrap();
+			assert!(bound_large_call.lookup_needed());
+			let bound_small_call = Preimage::bound(small_call).unwrap();
+			assert!(!bound_small_call.lookup_needed());
+
+			let expected = vec![
+				(
+					0,
+					vec![
+						Some(ScheduledOf::<Test> {
+							maybe_id: None,
+							priority: 10,
+							call: bound_small_call.clone(),
+							maybe_periodic: None,
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledOf::<Test> {
+							maybe_id: Some(blake2_256(&[0u8; 32])),
+							priority: 123,
+							call: bound_large_call.clone(),
+							maybe_periodic: Some((4u64, 20)),
+							origin: signed(0),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						Some(ScheduledOf::<Test> {
+							maybe_id: Some(blake2_256(&[255u8; 320])),
+							priority: 123,
+							call: Bounded::from_legacy_hash(bound_hashed_call.hash()),
+							maybe_periodic: Some((8u64, 10)),
+							origin: signed(0),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+					],
+				),
+				(
+					1,
+					vec![
+						Some(ScheduledOf::<Test> {
+							maybe_id: None,
+							priority: 11,
+							call: bound_small_call.clone(),
+							maybe_periodic: None,
+							origin: root(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(ScheduledOf::<Test> {
+							maybe_id: Some(blake2_256(&[1u8; 32])),
+							priority: 123,
+							call: bound_large_call.clone(),
+							maybe_periodic: Some((4u64, 20)),
+							origin: signed(1),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						Some(ScheduledOf::<Test> {
+							maybe_id: Some(blake2_256(&[254u8; 320])),
+							priority: 123,
+							call: Bounded::from_legacy_hash(bound_hashed_call.hash()),
+							maybe_periodic: Some((8u64, 10)),
+							origin: signed(1),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+					],
+				),
+			];
+			for (outer, (i, j)) in x.iter().zip(expected.iter()).enumerate() {
+				assert_eq!(i.0, j.0);
+				for (inner, (x, y)) in i.1.iter().zip(j.1.iter()).enumerate() {
+					assert_eq!(x, y, "at index: outer {} inner {}", outer, inner);
+				}
+			}
+			assert_eq_uvec!(x, expected);
+
+			assert_eq!(StorageVersion::get::<Scheduler>(), 4);
+		});
+	}
+
+	#[test]
+	#[allow(deprecated)]
+	fn migration_v3_to_v4_too_large_calls_are_ignored() {
+		new_test_ext().execute_with(|| {
+			// Assume that we are at V3.
+			StorageVersion::new(3).put::<Scheduler>();
+
+			let too_large_call = RuntimeCall::System(frame_system::Call::remark {
+				remark: vec![0; <Test as Config>::Preimages::MAX_LENGTH + 1],
+			});
+
+			let i = 0u64;
+			let k = i.twox_64_concat();
+			let old = vec![Some(ScheduledV3Of::<Test> {
+				maybe_id: None,
+				priority: 1,
+				call: too_large_call.clone().into(),
+				maybe_periodic: None,
+				origin: root(),
+				_phantom: PhantomData::<u64>::default(),
+			})];
+			frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
+
+			// The pre_upgrade hook fails:
+			let err = v3::MigrateToV4::<Test>::pre_upgrade().unwrap_err();
+			assert_eq!(DispatchError::from("Call is too large."), err);
+			// But the migration itself works:
+			let _w = v3::MigrateToV4::<Test>::on_runtime_upgrade();
+
+			let mut x = Agenda::<Test>::iter().map(|x| (x.0, x.1.into_inner())).collect::<Vec<_>>();
+			x.sort_by_key(|x| x.0);
+			// The call becomes `None`.
+			let expected = vec![(0, vec![None])];
+			assert_eq_uvec!(x, expected);
+
+			assert_eq!(StorageVersion::get::<Scheduler>(), 4);
+		});
+	}
+
+	#[test]
+	fn cleanup_agendas_works() {
+		use sp_core::bounded_vec;
+		new_test_ext().execute_with(|| {
+			StorageVersion::new(4).put::<Scheduler>();
+
+			let call = RuntimeCall::System(frame_system::Call::remark { remark: vec![] });
+			let bounded_call = Preimage::bound(call).unwrap();
+			let some = Some(ScheduledOf::<Test> {
+				maybe_id: None,
+				priority: 1,
+				call: bounded_call,
+				maybe_periodic: None,
+				origin: root(),
+				_phantom: Default::default(),
+			});
+
+			// Put some empty, and some non-empty agendas in there.
+			let test_data: Vec<(
+				BoundedVec<Option<ScheduledOf<Test>>, <Test as Config>::MaxScheduledPerBlock>,
+				Option<
+					BoundedVec<Option<ScheduledOf<Test>>, <Test as Config>::MaxScheduledPerBlock>,
+				>,
+			)> = vec![
+				(bounded_vec![some.clone()], Some(bounded_vec![some.clone()])),
+				(bounded_vec![None, some.clone()], Some(bounded_vec![None, some.clone()])),
+				(bounded_vec![None, some.clone(), None], Some(bounded_vec![None, some.clone()])),
+				(bounded_vec![some.clone(), None, None], Some(bounded_vec![some.clone()])),
+				(bounded_vec![None, None], None),
+				(bounded_vec![None, None, None], None),
+				(bounded_vec![], None),
+			];
+
+			// Insert all the agendas.
+			for (i, test) in test_data.iter().enumerate() {
+				Agenda::<Test>::insert(i as u64, test.0.clone());
+			}
+
+			// Run the migration.
+			let data = v4::CleanupAgendas::<Test>::pre_upgrade().unwrap();
+			let _w = v4::CleanupAgendas::<Test>::on_runtime_upgrade();
+			v4::CleanupAgendas::<Test>::post_upgrade(data).unwrap();
+
+			// Check that the post-state is correct.
+			for (i, test) in test_data.iter().enumerate() {
+				match test.1.clone() {
+					None => assert!(
+						!Agenda::<Test>::contains_key(i as u64),
+						"Agenda {} should be removed",
+						i
+					),
+					Some(new) => {
+						assert_eq!(Agenda::<Test>::get(i as u64), new, "Agenda wrong {}", i)
+					},
+				}
+			}
+		});
+	}
+
+	fn signed(i: u64) -> OriginCaller {
+		system::RawOrigin::Signed(i).into()
+	}
+}
diff --git a/substrate/frame/scheduler/src/mock.rs b/substrate/frame/scheduler/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..28e334958d924f927737a033f9e732fba66b4581
--- /dev/null
+++ b/substrate/frame/scheduler/src/mock.rs
@@ -0,0 +1,236 @@
+// 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.
+
+//! # Scheduler test environment.
+
+use super::*;
+
+use crate as scheduler;
+use frame_support::{
+	ord_parameter_types, parameter_types,
+	traits::{
+		ConstU32, ConstU64, Contains, EitherOfDiverse, EqualPrivilegeOnly, OnFinalize, OnInitialize,
+	},
+	weights::constants::RocksDbWeight,
+};
+use frame_system::{EnsureRoot, EnsureSignedBy};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill,
+};
+
+// Logger module to track execution.
+#[frame_support::pallet]
+pub mod logger {
+	use super::{OriginCaller, OriginTrait};
+	use frame_support::{pallet_prelude::*, parameter_types};
+	use frame_system::pallet_prelude::*;
+
+	parameter_types! {
+		static Log: Vec<(OriginCaller, u32)> = Vec::new();
+	}
+	pub fn log() -> Vec<(OriginCaller, u32)> {
+		Log::get().clone()
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		Logged(u32, Weight),
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T>
+	where
+		<T as frame_system::Config>::RuntimeOrigin: OriginTrait<PalletsOrigin = OriginCaller>,
+	{
+		#[pallet::call_index(0)]
+		#[pallet::weight(*weight)]
+		pub fn log(origin: OriginFor<T>, i: u32, weight: Weight) -> DispatchResult {
+			Self::deposit_event(Event::Logged(i, weight));
+			Log::mutate(|log| {
+				log.push((origin.caller().clone(), i));
+			});
+			Ok(())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight(*weight)]
+		pub fn log_without_filter(origin: OriginFor<T>, i: u32, weight: Weight) -> DispatchResult {
+			Self::deposit_event(Event::Logged(i, weight));
+			Log::mutate(|log| {
+				log.push((origin.caller().clone(), i));
+			});
+			Ok(())
+		}
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Logger: logger::{Pallet, Call, Event<T>},
+		Scheduler: scheduler::{Pallet, Call, Storage, Event<T>},
+		Preimage: pallet_preimage::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+// Scheduler must dispatch with root and no filter, this tests base filter is indeed not used.
+pub struct BaseFilter;
+impl Contains<RuntimeCall> for BaseFilter {
+	fn contains(call: &RuntimeCall) -> bool {
+		!matches!(call, RuntimeCall::Logger(LoggerCall::log { .. }))
+	}
+}
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(
+			Weight::from_parts(2_000_000_000_000, u64::MAX),
+		);
+}
+impl system::Config for Test {
+	type BaseCallFilter = BaseFilter;
+	type BlockWeights = BlockWeights;
+	type BlockLength = ();
+	type DbWeight = RocksDbWeight;
+	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 = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+impl logger::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+impl pallet_preimage::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	type Currency = ();
+	type ManagerOrigin = EnsureRoot<u64>;
+	type BaseDeposit = ();
+	type ByteDeposit = ();
+}
+
+pub struct TestWeightInfo;
+impl WeightInfo for TestWeightInfo {
+	fn service_agendas_base() -> Weight {
+		Weight::from_parts(0b0000_0001, 0)
+	}
+	fn service_agenda_base(i: u32) -> Weight {
+		Weight::from_parts((i << 8) as u64 + 0b0000_0010, 0)
+	}
+	fn service_task_base() -> Weight {
+		Weight::from_parts(0b0000_0100, 0)
+	}
+	fn service_task_periodic() -> Weight {
+		Weight::from_parts(0b0000_1100, 0)
+	}
+	fn service_task_named() -> Weight {
+		Weight::from_parts(0b0001_0100, 0)
+	}
+	fn service_task_fetched(s: u32) -> Weight {
+		Weight::from_parts((s << 8) as u64 + 0b0010_0100, 0)
+	}
+	fn execute_dispatch_signed() -> Weight {
+		Weight::from_parts(0b0100_0000, 0)
+	}
+	fn execute_dispatch_unsigned() -> Weight {
+		Weight::from_parts(0b1000_0000, 0)
+	}
+	fn schedule(_s: u32) -> Weight {
+		Weight::from_parts(50, 0)
+	}
+	fn cancel(_s: u32) -> Weight {
+		Weight::from_parts(50, 0)
+	}
+	fn schedule_named(_s: u32) -> Weight {
+		Weight::from_parts(50, 0)
+	}
+	fn cancel_named(_s: u32) -> Weight {
+		Weight::from_parts(50, 0)
+	}
+}
+parameter_types! {
+	pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) *
+		BlockWeights::get().max_block;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type PalletsOrigin = OriginCaller;
+	type RuntimeCall = RuntimeCall;
+	type MaximumWeight = MaximumSchedulerWeight;
+	type ScheduleOrigin = EitherOfDiverse<EnsureRoot<u64>, EnsureSignedBy<One, u64>>;
+	type MaxScheduledPerBlock = ConstU32<10>;
+	type WeightInfo = TestWeightInfo;
+	type OriginPrivilegeCmp = EqualPrivilegeOnly;
+	type Preimages = Preimage;
+}
+
+pub type LoggerCall = logger::Call<Test>;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	t.into()
+}
+
+pub fn run_to_block(n: u64) {
+	while System::block_number() < n {
+		Scheduler::on_finalize(System::block_number());
+		System::set_block_number(System::block_number() + 1);
+		Scheduler::on_initialize(System::block_number());
+	}
+}
+
+pub fn root() -> OriginCaller {
+	system::RawOrigin::Root.into()
+}
diff --git a/substrate/frame/scheduler/src/tests.rs b/substrate/frame/scheduler/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..477df5579dcf1d8f5984e7fb982b406f891e3323
--- /dev/null
+++ b/substrate/frame/scheduler/src/tests.rs
@@ -0,0 +1,1880 @@
+// 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.
+
+//! # Scheduler tests.
+
+use super::*;
+use crate::mock::{
+	logger, new_test_ext, root, run_to_block, LoggerCall, RuntimeCall, Scheduler, Test, *,
+};
+use frame_support::{
+	assert_err, assert_noop, assert_ok,
+	traits::{Contains, GetStorageVersion, OnInitialize, QueryPreimage, StorePreimage},
+	Hashable,
+};
+use sp_runtime::traits::Hash;
+use substrate_test_utils::assert_eq_uvec;
+
+#[test]
+#[docify::export]
+fn basic_scheduling_works() {
+	new_test_ext().execute_with(|| {
+		// Call to schedule
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+
+		// BaseCallFilter should be implemented to accept `Logger::log` runtime call which is
+		// implemented for `BaseFilter` in the mock runtime
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+
+		// Schedule call to be executed at the 4th block
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap()
+		));
+
+		// `log` runtime call should not have executed yet
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		run_to_block(4);
+		// `log` runtime call should have executed at block 4
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+#[docify::export]
+fn scheduling_with_preimages_works() {
+	new_test_ext().execute_with(|| {
+		// Call to schedule
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+
+		let hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
+		let len = call.using_encoded(|x| x.len()) as u32;
+
+		// Important to use here `Bounded::Lookup` to ensure that that the Scheduler can request the
+		// hash from PreImage to dispatch the call
+		let hashed = Bounded::Lookup { hash, len };
+
+		// Schedule call to be executed at block 4 with the PreImage hash
+		assert_ok!(Scheduler::do_schedule(DispatchTime::At(4), None, 127, root(), hashed));
+
+		// Register preimage on chain
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(0), call.encode()));
+		assert!(Preimage::is_requested(&hash));
+
+		// `log` runtime call should not have executed yet
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		run_to_block(4);
+		// preimage should not have been removed when executed by the scheduler
+		assert!(!Preimage::len(&hash).is_some());
+		assert!(!Preimage::is_requested(&hash));
+		// `log` runtime call should have executed at block 4
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn schedule_after_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(2);
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		// This will schedule the call 3 blocks after the next block... so block 3 + 3 = 6
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::After(3),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap()
+		));
+		run_to_block(5);
+		assert!(logger::log().is_empty());
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn schedule_after_zero_works() {
+	new_test_ext().execute_with(|| {
+		run_to_block(2);
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::After(0),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap()
+		));
+		// Will trigger on the next block.
+		run_to_block(3);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn periodic_scheduling_works() {
+	new_test_ext().execute_with(|| {
+		// at #4, every 3 blocks, 3 times.
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			Some((3, 3)),
+			127,
+			root(),
+			Preimage::bound(RuntimeCall::Logger(logger::Call::log {
+				i: 42,
+				weight: Weight::from_parts(10, 0)
+			}))
+			.unwrap()
+		));
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(7);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
+		run_to_block(9);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
+		run_to_block(10);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn reschedule_works() {
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_eq!(
+			Scheduler::do_schedule(
+				DispatchTime::At(4),
+				None,
+				127,
+				root(),
+				Preimage::bound(call).unwrap()
+			)
+			.unwrap(),
+			(4, 0)
+		);
+
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		assert_eq!(Scheduler::do_reschedule((4, 0), DispatchTime::At(6)).unwrap(), (6, 0));
+
+		assert_noop!(
+			Scheduler::do_reschedule((6, 0), DispatchTime::At(6)),
+			Error::<Test>::RescheduleNoChange
+		);
+
+		run_to_block(4);
+		assert!(logger::log().is_empty());
+
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn reschedule_named_works() {
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_eq!(
+			Scheduler::do_schedule_named(
+				[1u8; 32],
+				DispatchTime::At(4),
+				None,
+				127,
+				root(),
+				Preimage::bound(call).unwrap(),
+			)
+			.unwrap(),
+			(4, 0)
+		);
+
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		assert_eq!(Scheduler::do_reschedule_named([1u8; 32], DispatchTime::At(6)).unwrap(), (6, 0));
+
+		assert_noop!(
+			Scheduler::do_reschedule_named([1u8; 32], DispatchTime::At(6)),
+			Error::<Test>::RescheduleNoChange
+		);
+
+		run_to_block(4);
+		assert!(logger::log().is_empty());
+
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn reschedule_named_perodic_works() {
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		assert!(!<Test as frame_system::Config>::BaseCallFilter::contains(&call));
+		assert_eq!(
+			Scheduler::do_schedule_named(
+				[1u8; 32],
+				DispatchTime::At(4),
+				Some((3, 3)),
+				127,
+				root(),
+				Preimage::bound(call).unwrap(),
+			)
+			.unwrap(),
+			(4, 0)
+		);
+
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+
+		assert_eq!(Scheduler::do_reschedule_named([1u8; 32], DispatchTime::At(5)).unwrap(), (5, 0));
+		assert_eq!(Scheduler::do_reschedule_named([1u8; 32], DispatchTime::At(6)).unwrap(), (6, 0));
+
+		run_to_block(5);
+		assert!(logger::log().is_empty());
+
+		run_to_block(6);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		assert_eq!(
+			Scheduler::do_reschedule_named([1u8; 32], DispatchTime::At(10)).unwrap(),
+			(10, 0)
+		);
+
+		run_to_block(9);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+
+		run_to_block(10);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32)]);
+
+		run_to_block(13);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 42u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn cancel_named_scheduling_works_with_normal_cancel() {
+	new_test_ext().execute_with(|| {
+		// at #4.
+		Scheduler::do_schedule_named(
+			[1u8; 32],
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+				i: 69,
+				weight: Weight::from_parts(10, 0),
+			}))
+			.unwrap(),
+		)
+		.unwrap();
+		let i = Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+				i: 42,
+				weight: Weight::from_parts(10, 0),
+			}))
+			.unwrap(),
+		)
+		.unwrap();
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		assert_ok!(Scheduler::do_cancel_named(None, [1u8; 32]));
+		assert_ok!(Scheduler::do_cancel(None, i));
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+	});
+}
+
+#[test]
+fn cancel_named_periodic_scheduling_works() {
+	new_test_ext().execute_with(|| {
+		// at #4, every 3 blocks, 3 times.
+		Scheduler::do_schedule_named(
+			[1u8; 32],
+			DispatchTime::At(4),
+			Some((3, 3)),
+			127,
+			root(),
+			Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+				i: 42,
+				weight: Weight::from_parts(10, 0),
+			}))
+			.unwrap(),
+		)
+		.unwrap();
+		// same id results in error.
+		assert!(Scheduler::do_schedule_named(
+			[1u8; 32],
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+				i: 69,
+				weight: Weight::from_parts(10, 0)
+			}))
+			.unwrap(),
+		)
+		.is_err());
+		// different id is ok.
+		Scheduler::do_schedule_named(
+			[2u8; 32],
+			DispatchTime::At(8),
+			None,
+			127,
+			root(),
+			Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+				i: 69,
+				weight: Weight::from_parts(10, 0),
+			}))
+			.unwrap(),
+		)
+		.unwrap();
+		run_to_block(3);
+		assert!(logger::log().is_empty());
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(6);
+		assert_ok!(Scheduler::do_cancel_named(None, [1u8; 32]));
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
+	});
+}
+
+#[test]
+fn scheduler_respects_weight_limits() {
+	let max_weight: Weight = <Test as Config>::MaximumWeight::get();
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight / 3 * 2 });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 69, weight: max_weight / 3 * 2 });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		// 69 and 42 do not fit together
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		run_to_block(5);
+		assert_eq!(logger::log(), vec![(root(), 42u32), (root(), 69u32)]);
+	});
+}
+
+/// Permanently overweight calls are not deleted but also not executed.
+#[test]
+fn scheduler_does_not_delete_permanently_overweight_call() {
+	let max_weight: Weight = <Test as Config>::MaximumWeight::get();
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		// Never executes.
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![]);
+
+		// Assert the `PermanentlyOverweight` event.
+		assert_eq!(
+			System::events().last().unwrap().event,
+			crate::Event::PermanentlyOverweight { task: (4, 0), id: None }.into(),
+		);
+		// The call is still in the agenda.
+		assert!(Agenda::<Test>::get(4)[0].is_some());
+	});
+}
+
+#[test]
+fn scheduler_handles_periodic_failure() {
+	let max_weight: Weight = <Test as Config>::MaximumWeight::get();
+	let max_per_block = <Test as Config>::MaxScheduledPerBlock::get();
+
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: (max_weight / 3) * 2 });
+		let bound = Preimage::bound(call).unwrap();
+
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			Some((4, u32::MAX)),
+			127,
+			root(),
+			bound.clone(),
+		));
+		// Executes 5 times till block 20.
+		run_to_block(20);
+		assert_eq!(logger::log().len(), 5);
+
+		// Block 28 will already be full.
+		for _ in 0..max_per_block {
+			assert_ok!(Scheduler::do_schedule(
+				DispatchTime::At(28),
+				None,
+				120,
+				root(),
+				bound.clone(),
+			));
+		}
+
+		// Going to block 24 will emit a `PeriodicFailed` event.
+		run_to_block(24);
+		assert_eq!(logger::log().len(), 6);
+
+		assert_eq!(
+			System::events().last().unwrap().event,
+			crate::Event::PeriodicFailed { task: (24, 0), id: None }.into(),
+		);
+	});
+}
+
+#[test]
+fn scheduler_handles_periodic_unavailable_preimage() {
+	let max_weight: Weight = <Test as Config>::MaximumWeight::get();
+
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: (max_weight / 3) * 2 });
+		let hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
+		let len = call.using_encoded(|x| x.len()) as u32;
+		// Important to use here `Bounded::Lookup` to ensure that we request the hash.
+		let bound = Bounded::Lookup { hash, len };
+		// The preimage isn't requested yet.
+		assert!(!Preimage::is_requested(&hash));
+
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			Some((4, u32::MAX)),
+			127,
+			root(),
+			bound.clone(),
+		));
+
+		// The preimage is requested.
+		assert!(Preimage::is_requested(&hash));
+
+		// Note the preimage.
+		assert_ok!(Preimage::note_preimage(RuntimeOrigin::signed(1), call.encode()));
+
+		// Executes 1 times till block 4.
+		run_to_block(4);
+		assert_eq!(logger::log().len(), 1);
+
+		// Unnote the preimage
+		Preimage::unnote(&hash);
+
+		// Does not ever execute again.
+		run_to_block(100);
+		assert_eq!(logger::log().len(), 1);
+
+		// The preimage is not requested anymore.
+		assert!(!Preimage::is_requested(&hash));
+	});
+}
+
+#[test]
+fn scheduler_respects_priority_ordering() {
+	let max_weight: Weight = <Test as Config>::MaximumWeight::get();
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight / 3 });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			1,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 69, weight: max_weight / 3 });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			0,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 69u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn scheduler_respects_priority_ordering_with_soft_deadlines() {
+	new_test_ext().execute_with(|| {
+		let max_weight: Weight = <Test as Config>::MaximumWeight::get();
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 42, weight: max_weight / 5 * 2 });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			255,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 69, weight: max_weight / 5 * 2 });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		let call = RuntimeCall::Logger(LoggerCall::log { i: 2600, weight: max_weight / 5 * 4 });
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(4),
+			None,
+			126,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+
+		// 2600 does not fit with 69 or 42, but has higher priority, so will go through
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 2600u32)]);
+		// 69 and 42 fit together
+		run_to_block(5);
+		assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);
+	});
+}
+
+#[test]
+fn on_initialize_weight_is_correct() {
+	new_test_ext().execute_with(|| {
+		let call_weight = Weight::from_parts(25, 0);
+
+		// Named
+		let call = RuntimeCall::Logger(LoggerCall::log {
+			i: 3,
+			weight: call_weight + Weight::from_parts(1, 0),
+		});
+		assert_ok!(Scheduler::do_schedule_named(
+			[1u8; 32],
+			DispatchTime::At(3),
+			None,
+			255,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		let call = RuntimeCall::Logger(LoggerCall::log {
+			i: 42,
+			weight: call_weight + Weight::from_parts(2, 0),
+		});
+		// Anon Periodic
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(2),
+			Some((1000, 3)),
+			128,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		let call = RuntimeCall::Logger(LoggerCall::log {
+			i: 69,
+			weight: call_weight + Weight::from_parts(3, 0),
+		});
+		// Anon
+		assert_ok!(Scheduler::do_schedule(
+			DispatchTime::At(2),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+		// Named Periodic
+		let call = RuntimeCall::Logger(LoggerCall::log {
+			i: 2600,
+			weight: call_weight + Weight::from_parts(4, 0),
+		});
+		assert_ok!(Scheduler::do_schedule_named(
+			[2u8; 32],
+			DispatchTime::At(1),
+			Some((1000, 3)),
+			126,
+			root(),
+			Preimage::bound(call).unwrap(),
+		));
+
+		// Will include the named periodic only
+		assert_eq!(
+			Scheduler::on_initialize(1),
+			TestWeightInfo::service_agendas_base() +
+				TestWeightInfo::service_agenda_base(1) +
+				<TestWeightInfo as MarginalWeightInfo>::service_task(None, true, true) +
+				TestWeightInfo::execute_dispatch_unsigned() +
+				call_weight + Weight::from_parts(4, 0)
+		);
+		assert_eq!(IncompleteSince::<Test>::get(), None);
+		assert_eq!(logger::log(), vec![(root(), 2600u32)]);
+
+		// Will include anon and anon periodic
+		assert_eq!(
+			Scheduler::on_initialize(2),
+			TestWeightInfo::service_agendas_base() +
+				TestWeightInfo::service_agenda_base(2) +
+				<TestWeightInfo as MarginalWeightInfo>::service_task(None, false, true) +
+				TestWeightInfo::execute_dispatch_unsigned() +
+				call_weight + Weight::from_parts(3, 0) +
+				<TestWeightInfo as MarginalWeightInfo>::service_task(None, false, false) +
+				TestWeightInfo::execute_dispatch_unsigned() +
+				call_weight + Weight::from_parts(2, 0)
+		);
+		assert_eq!(IncompleteSince::<Test>::get(), None);
+		assert_eq!(logger::log(), vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32)]);
+
+		// Will include named only
+		assert_eq!(
+			Scheduler::on_initialize(3),
+			TestWeightInfo::service_agendas_base() +
+				TestWeightInfo::service_agenda_base(1) +
+				<TestWeightInfo as MarginalWeightInfo>::service_task(None, true, false) +
+				TestWeightInfo::execute_dispatch_unsigned() +
+				call_weight + Weight::from_parts(1, 0)
+		);
+		assert_eq!(IncompleteSince::<Test>::get(), None);
+		assert_eq!(
+			logger::log(),
+			vec![(root(), 2600u32), (root(), 69u32), (root(), 42u32), (root(), 3u32)]
+		);
+
+		// Will contain none
+		let actual_weight = Scheduler::on_initialize(4);
+		assert_eq!(
+			actual_weight,
+			TestWeightInfo::service_agendas_base() + TestWeightInfo::service_agenda_base(0)
+		);
+	});
+}
+
+#[test]
+fn root_calls_works() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 69,
+			weight: Weight::from_parts(10, 0),
+		}));
+		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 42,
+			weight: Weight::from_parts(10, 0),
+		}));
+		assert_ok!(
+			Scheduler::schedule_named(RuntimeOrigin::root(), [1u8; 32], 4, None, 127, call,)
+		);
+		assert_ok!(Scheduler::schedule(RuntimeOrigin::root(), 4, None, 127, call2));
+		run_to_block(3);
+		// Scheduled calls are in the agenda.
+		assert_eq!(Agenda::<Test>::get(4).len(), 2);
+		assert!(logger::log().is_empty());
+		assert_ok!(Scheduler::cancel_named(RuntimeOrigin::root(), [1u8; 32]));
+		assert_ok!(Scheduler::cancel(RuntimeOrigin::root(), 4, 1));
+		// Scheduled calls are made NONE, so should not effect state
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+	});
+}
+
+#[test]
+fn fails_to_schedule_task_in_the_past() {
+	new_test_ext().execute_with(|| {
+		run_to_block(3);
+
+		let call1 = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 69,
+			weight: Weight::from_parts(10, 0),
+		}));
+		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 42,
+			weight: Weight::from_parts(10, 0),
+		}));
+		let call3 = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 42,
+			weight: Weight::from_parts(10, 0),
+		}));
+
+		assert_noop!(
+			Scheduler::schedule_named(RuntimeOrigin::root(), [1u8; 32], 2, None, 127, call1),
+			Error::<Test>::TargetBlockNumberInPast,
+		);
+
+		assert_noop!(
+			Scheduler::schedule(RuntimeOrigin::root(), 2, None, 127, call2),
+			Error::<Test>::TargetBlockNumberInPast,
+		);
+
+		assert_noop!(
+			Scheduler::schedule(RuntimeOrigin::root(), 3, None, 127, call3),
+			Error::<Test>::TargetBlockNumberInPast,
+		);
+	});
+}
+
+#[test]
+fn should_use_origin() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 69,
+			weight: Weight::from_parts(10, 0),
+		}));
+		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 42,
+			weight: Weight::from_parts(10, 0),
+		}));
+		assert_ok!(Scheduler::schedule_named(
+			system::RawOrigin::Signed(1).into(),
+			[1u8; 32],
+			4,
+			None,
+			127,
+			call,
+		));
+		assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2,));
+		run_to_block(3);
+		// Scheduled calls are in the agenda.
+		assert_eq!(Agenda::<Test>::get(4).len(), 2);
+		assert!(logger::log().is_empty());
+		assert_ok!(Scheduler::cancel_named(system::RawOrigin::Signed(1).into(), [1u8; 32]));
+		assert_ok!(Scheduler::cancel(system::RawOrigin::Signed(1).into(), 4, 1));
+		// Scheduled calls are made NONE, so should not effect state
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+	});
+}
+
+#[test]
+fn should_check_origin() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 69,
+			weight: Weight::from_parts(10, 0),
+		}));
+		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log {
+			i: 42,
+			weight: Weight::from_parts(10, 0),
+		}));
+		assert_noop!(
+			Scheduler::schedule_named(
+				system::RawOrigin::Signed(2).into(),
+				[1u8; 32],
+				4,
+				None,
+				127,
+				call
+			),
+			BadOrigin
+		);
+		assert_noop!(
+			Scheduler::schedule(system::RawOrigin::Signed(2).into(), 4, None, 127, call2),
+			BadOrigin
+		);
+	});
+}
+
+#[test]
+fn should_check_origin_for_cancel() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::log_without_filter {
+			i: 69,
+			weight: Weight::from_parts(10, 0),
+		}));
+		let call2 = Box::new(RuntimeCall::Logger(LoggerCall::log_without_filter {
+			i: 42,
+			weight: Weight::from_parts(10, 0),
+		}));
+		assert_ok!(Scheduler::schedule_named(
+			system::RawOrigin::Signed(1).into(),
+			[1u8; 32],
+			4,
+			None,
+			127,
+			call,
+		));
+		assert_ok!(Scheduler::schedule(system::RawOrigin::Signed(1).into(), 4, None, 127, call2,));
+		run_to_block(3);
+		// Scheduled calls are in the agenda.
+		assert_eq!(Agenda::<Test>::get(4).len(), 2);
+		assert!(logger::log().is_empty());
+		assert_noop!(
+			Scheduler::cancel_named(system::RawOrigin::Signed(2).into(), [1u8; 32]),
+			BadOrigin
+		);
+		assert_noop!(Scheduler::cancel(system::RawOrigin::Signed(2).into(), 4, 1), BadOrigin);
+		assert_noop!(Scheduler::cancel_named(system::RawOrigin::Root.into(), [1u8; 32]), BadOrigin);
+		assert_noop!(Scheduler::cancel(system::RawOrigin::Root.into(), 4, 1), BadOrigin);
+		run_to_block(5);
+		assert_eq!(
+			logger::log(),
+			vec![
+				(system::RawOrigin::Signed(1).into(), 69u32),
+				(system::RawOrigin::Signed(1).into(), 42u32)
+			]
+		);
+	});
+}
+
+#[test]
+fn migration_to_v4_works() {
+	new_test_ext().execute_with(|| {
+		for i in 0..3u64 {
+			let k = i.twox_64_concat();
+			let old = vec![
+				Some(ScheduledV1 {
+					maybe_id: None,
+					priority: i as u8 + 10,
+					call: RuntimeCall::Logger(LoggerCall::log {
+						i: 96,
+						weight: Weight::from_parts(100, 0),
+					}),
+					maybe_periodic: None,
+				}),
+				None,
+				Some(ScheduledV1 {
+					maybe_id: Some(b"test".to_vec()),
+					priority: 123,
+					call: RuntimeCall::Logger(LoggerCall::log {
+						i: 69,
+						weight: Weight::from_parts(10, 0),
+					}),
+					maybe_periodic: Some((456u64, 10)),
+				}),
+			];
+			frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
+		}
+
+		Scheduler::migrate_v1_to_v4();
+
+		let mut x = Agenda::<Test>::iter().map(|x| (x.0, x.1.into_inner())).collect::<Vec<_>>();
+		x.sort_by_key(|x| x.0);
+		let expected = vec![
+			(
+				0,
+				vec![
+					Some(ScheduledOf::<Test> {
+						maybe_id: None,
+						priority: 10,
+						call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+							i: 96,
+							weight: Weight::from_parts(100, 0),
+						}))
+						.unwrap(),
+						maybe_periodic: None,
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+					None,
+					Some(ScheduledOf::<Test> {
+						maybe_id: Some(blake2_256(&b"test"[..])),
+						priority: 123,
+						call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+							i: 69,
+							weight: Weight::from_parts(10, 0),
+						}))
+						.unwrap(),
+						maybe_periodic: Some((456u64, 10)),
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+				],
+			),
+			(
+				1,
+				vec![
+					Some(ScheduledOf::<Test> {
+						maybe_id: None,
+						priority: 11,
+						call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+							i: 96,
+							weight: Weight::from_parts(100, 0),
+						}))
+						.unwrap(),
+						maybe_periodic: None,
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+					None,
+					Some(ScheduledOf::<Test> {
+						maybe_id: Some(blake2_256(&b"test"[..])),
+						priority: 123,
+						call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+							i: 69,
+							weight: Weight::from_parts(10, 0),
+						}))
+						.unwrap(),
+						maybe_periodic: Some((456u64, 10)),
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+				],
+			),
+			(
+				2,
+				vec![
+					Some(ScheduledOf::<Test> {
+						maybe_id: None,
+						priority: 12,
+						call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+							i: 96,
+							weight: Weight::from_parts(100, 0),
+						}))
+						.unwrap(),
+						maybe_periodic: None,
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+					None,
+					Some(ScheduledOf::<Test> {
+						maybe_id: Some(blake2_256(&b"test"[..])),
+						priority: 123,
+						call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+							i: 69,
+							weight: Weight::from_parts(10, 0),
+						}))
+						.unwrap(),
+						maybe_periodic: Some((456u64, 10)),
+						origin: root(),
+						_phantom: PhantomData::<u64>::default(),
+					}),
+				],
+			),
+		];
+		for (i, j) in x.iter().zip(expected.iter()) {
+			assert_eq!(i.0, j.0);
+			for (x, y) in i.1.iter().zip(j.1.iter()) {
+				assert_eq!(x, y);
+			}
+		}
+		assert_eq_uvec!(x, expected);
+
+		assert_eq!(Scheduler::on_chain_storage_version(), 4);
+	});
+}
+
+#[test]
+fn test_migrate_origin() {
+	new_test_ext().execute_with(|| {
+		for i in 0..3u64 {
+			let k = i.twox_64_concat();
+			let old: Vec<Option<Scheduled<[u8; 32], Bounded<RuntimeCall>, u64, u32, u64>>> = vec![
+				Some(Scheduled {
+					maybe_id: None,
+					priority: i as u8 + 10,
+					call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+						i: 96,
+						weight: Weight::from_parts(100, 0),
+					}))
+					.unwrap(),
+					origin: 3u32,
+					maybe_periodic: None,
+					_phantom: Default::default(),
+				}),
+				None,
+				Some(Scheduled {
+					maybe_id: Some(blake2_256(&b"test"[..])),
+					priority: 123,
+					origin: 2u32,
+					call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+						i: 69,
+						weight: Weight::from_parts(10, 0),
+					}))
+					.unwrap(),
+					maybe_periodic: Some((456u64, 10)),
+					_phantom: Default::default(),
+				}),
+			];
+			frame_support::migration::put_storage_value(b"Scheduler", b"Agenda", &k, old);
+		}
+
+		impl Into<OriginCaller> for u32 {
+			fn into(self) -> OriginCaller {
+				match self {
+					3u32 => system::RawOrigin::Root.into(),
+					2u32 => system::RawOrigin::None.into(),
+					_ => unreachable!("test make no use of it"),
+				}
+			}
+		}
+
+		Scheduler::migrate_origin::<u32>();
+
+		assert_eq_uvec!(
+			Agenda::<Test>::iter().map(|x| (x.0, x.1.into_inner())).collect::<Vec<_>>(),
+			vec![
+				(
+					0,
+					vec![
+						Some(ScheduledOf::<Test> {
+							maybe_id: None,
+							priority: 10,
+							call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+								i: 96,
+								weight: Weight::from_parts(100, 0)
+							}))
+							.unwrap(),
+							maybe_periodic: None,
+							origin: system::RawOrigin::Root.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(Scheduled {
+							maybe_id: Some(blake2_256(&b"test"[..])),
+							priority: 123,
+							call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+								i: 69,
+								weight: Weight::from_parts(10, 0)
+							}))
+							.unwrap(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: system::RawOrigin::None.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				),
+				(
+					1,
+					vec![
+						Some(Scheduled {
+							maybe_id: None,
+							priority: 11,
+							call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+								i: 96,
+								weight: Weight::from_parts(100, 0)
+							}))
+							.unwrap(),
+							maybe_periodic: None,
+							origin: system::RawOrigin::Root.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(Scheduled {
+							maybe_id: Some(blake2_256(&b"test"[..])),
+							priority: 123,
+							call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+								i: 69,
+								weight: Weight::from_parts(10, 0)
+							}))
+							.unwrap(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: system::RawOrigin::None.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				),
+				(
+					2,
+					vec![
+						Some(Scheduled {
+							maybe_id: None,
+							priority: 12,
+							call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+								i: 96,
+								weight: Weight::from_parts(100, 0)
+							}))
+							.unwrap(),
+							maybe_periodic: None,
+							origin: system::RawOrigin::Root.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+						None,
+						Some(Scheduled {
+							maybe_id: Some(blake2_256(&b"test"[..])),
+							priority: 123,
+							call: Preimage::bound(RuntimeCall::Logger(LoggerCall::log {
+								i: 69,
+								weight: Weight::from_parts(10, 0)
+							}))
+							.unwrap(),
+							maybe_periodic: Some((456u64, 10)),
+							origin: system::RawOrigin::None.into(),
+							_phantom: PhantomData::<u64>::default(),
+						}),
+					]
+				)
+			]
+		);
+	});
+}
+
+#[test]
+fn postponed_named_task_cannot_be_rescheduled() {
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(1000, 0) });
+		let hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
+		let len = call.using_encoded(|x| x.len()) as u32;
+		// Important to use here `Bounded::Lookup` to ensure that we request the hash.
+		let hashed = Bounded::Lookup { hash, len };
+		let name: [u8; 32] = hash.as_ref().try_into().unwrap();
+
+		let address = Scheduler::do_schedule_named(
+			name,
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			hashed.clone(),
+		)
+		.unwrap();
+		assert!(Preimage::is_requested(&hash));
+		assert!(Lookup::<Test>::contains_key(name));
+
+		// Run to a very large block.
+		run_to_block(10);
+		// It was not executed.
+		assert!(logger::log().is_empty());
+		assert!(Preimage::is_requested(&hash));
+		// Postponing removes the lookup.
+		assert!(!Lookup::<Test>::contains_key(name));
+
+		// The agenda still contains the call.
+		let agenda = Agenda::<Test>::iter().collect::<Vec<_>>();
+		assert_eq!(agenda.len(), 1);
+		assert_eq!(
+			agenda[0].1,
+			vec![Some(Scheduled {
+				maybe_id: Some(name),
+				priority: 127,
+				call: hashed,
+				maybe_periodic: None,
+				origin: root().into(),
+				_phantom: Default::default(),
+			})]
+		);
+
+		// Finally add the preimage.
+		assert_ok!(Preimage::note(call.encode().into()));
+		run_to_block(1000);
+		// It did not execute.
+		assert!(logger::log().is_empty());
+		assert!(Preimage::is_requested(&hash));
+
+		// Manually re-schedule the call by name does not work.
+		assert_err!(
+			Scheduler::do_reschedule_named(name, DispatchTime::At(1001)),
+			Error::<Test>::NotFound
+		);
+		// Manually re-scheduling the call by address errors.
+		assert_err!(
+			Scheduler::do_reschedule(address, DispatchTime::At(1001)),
+			Error::<Test>::Named
+		);
+	});
+}
+
+/// Using the scheduler as `v3::Anon` works.
+#[test]
+fn scheduler_v3_anon_basic_works() {
+	use frame_support::traits::schedule::v3::Anon;
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+
+		// Schedule a call.
+		let _address = <Scheduler as Anon<_, _, _>>::schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+
+		run_to_block(3);
+		// Did not execute till block 3.
+		assert!(logger::log().is_empty());
+		// Executes in block 4.
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		// ... but not again.
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+#[test]
+fn scheduler_v3_anon_cancel_works() {
+	use frame_support::traits::schedule::v3::Anon;
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+
+		// Schedule a call.
+		let address = <Scheduler as Anon<_, _, _>>::schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			bound.clone(),
+		)
+		.unwrap();
+		// Cancel the call.
+		assert_ok!(<Scheduler as Anon<_, _, _>>::cancel(address));
+		// It did not get executed.
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+		// Cannot cancel again.
+		assert_err!(<Scheduler as Anon<_, _, _>>::cancel(address), DispatchError::Unavailable);
+	});
+}
+
+#[test]
+fn scheduler_v3_anon_reschedule_works() {
+	use frame_support::traits::schedule::v3::Anon;
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+
+		// Schedule a call.
+		let address = <Scheduler as Anon<_, _, _>>::schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+
+		run_to_block(3);
+		// Did not execute till block 3.
+		assert!(logger::log().is_empty());
+
+		// Cannot re-schedule into the same block.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::reschedule(address, DispatchTime::At(4)),
+			Error::<Test>::RescheduleNoChange
+		);
+		// Cannot re-schedule into the past.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::reschedule(address, DispatchTime::At(3)),
+			Error::<Test>::TargetBlockNumberInPast
+		);
+		// Re-schedule to block 5.
+		assert_ok!(<Scheduler as Anon<_, _, _>>::reschedule(address, DispatchTime::At(5)));
+		// Scheduled for block 5.
+		run_to_block(4);
+		assert!(logger::log().is_empty());
+		run_to_block(5);
+		// Does execute in block 5.
+		assert_eq!(logger::log(), vec![(root(), 42)]);
+		// Cannot re-schedule executed task.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::reschedule(address, DispatchTime::At(10)),
+			DispatchError::Unavailable
+		);
+	});
+}
+
+#[test]
+fn scheduler_v3_anon_next_schedule_time_works() {
+	use frame_support::traits::schedule::v3::Anon;
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+
+		// Schedule a call.
+		let address = <Scheduler as Anon<_, _, _>>::schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			bound.clone(),
+		)
+		.unwrap();
+
+		run_to_block(3);
+		// Did not execute till block 3.
+		assert!(logger::log().is_empty());
+
+		// Scheduled for block 4.
+		assert_eq!(<Scheduler as Anon<_, _, _>>::next_dispatch_time(address), Ok(4));
+		// Block 4 executes it.
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42)]);
+
+		// It has no dispatch time anymore.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::next_dispatch_time(address),
+			DispatchError::Unavailable
+		);
+	});
+}
+
+/// Re-scheduling a task changes its next dispatch time.
+#[test]
+fn scheduler_v3_anon_reschedule_and_next_schedule_time_work() {
+	use frame_support::traits::schedule::v3::Anon;
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+
+		// Schedule a call.
+		let old_address = <Scheduler as Anon<_, _, _>>::schedule(
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			bound.clone(),
+		)
+		.unwrap();
+
+		run_to_block(3);
+		// Did not execute till block 3.
+		assert!(logger::log().is_empty());
+
+		// Scheduled for block 4.
+		assert_eq!(<Scheduler as Anon<_, _, _>>::next_dispatch_time(old_address), Ok(4));
+		// Re-schedule to block 5.
+		let address =
+			<Scheduler as Anon<_, _, _>>::reschedule(old_address, DispatchTime::At(5)).unwrap();
+		assert!(address != old_address);
+		// Scheduled for block 5.
+		assert_eq!(<Scheduler as Anon<_, _, _>>::next_dispatch_time(address), Ok(5));
+
+		// Block 4 does nothing.
+		run_to_block(4);
+		assert!(logger::log().is_empty());
+		// Block 5 executes it.
+		run_to_block(5);
+		assert_eq!(logger::log(), vec![(root(), 42)]);
+	});
+}
+
+#[test]
+fn scheduler_v3_anon_schedule_agenda_overflows() {
+	use frame_support::traits::schedule::v3::Anon;
+	let max: u32 = <Test as Config>::MaxScheduledPerBlock::get();
+
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+
+		// Schedule the maximal number allowed per block.
+		for _ in 0..max {
+			<Scheduler as Anon<_, _, _>>::schedule(
+				DispatchTime::At(4),
+				None,
+				127,
+				root(),
+				bound.clone(),
+			)
+			.unwrap();
+		}
+
+		// One more time and it errors.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::schedule(DispatchTime::At(4), None, 127, root(), bound,),
+			DispatchError::Exhausted
+		);
+
+		run_to_block(4);
+		// All scheduled calls are executed.
+		assert_eq!(logger::log().len() as u32, max);
+	});
+}
+
+/// Cancelling and scheduling does not overflow the agenda but fills holes.
+#[test]
+fn scheduler_v3_anon_cancel_and_schedule_fills_holes() {
+	use frame_support::traits::schedule::v3::Anon;
+	let max: u32 = <Test as Config>::MaxScheduledPerBlock::get();
+	assert!(max > 3, "This test only makes sense for MaxScheduledPerBlock > 3");
+
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+		let mut addrs = Vec::<_>::default();
+
+		// Schedule the maximal number allowed per block.
+		for _ in 0..max {
+			addrs.push(
+				<Scheduler as Anon<_, _, _>>::schedule(
+					DispatchTime::At(4),
+					None,
+					127,
+					root(),
+					bound.clone(),
+				)
+				.unwrap(),
+			);
+		}
+		// Cancel three of them.
+		for addr in addrs.into_iter().take(3) {
+			<Scheduler as Anon<_, _, _>>::cancel(addr).unwrap();
+		}
+		// Schedule three new ones.
+		for i in 0..3 {
+			let (_block, index) = <Scheduler as Anon<_, _, _>>::schedule(
+				DispatchTime::At(4),
+				None,
+				127,
+				root(),
+				bound.clone(),
+			)
+			.unwrap();
+			assert_eq!(i, index);
+		}
+
+		run_to_block(4);
+		// Maximum number of calls are executed.
+		assert_eq!(logger::log().len() as u32, max);
+	});
+}
+
+/// Re-scheduling does not overflow the agenda but fills holes.
+#[test]
+fn scheduler_v3_anon_reschedule_fills_holes() {
+	use frame_support::traits::schedule::v3::Anon;
+	let max: u32 = <Test as Config>::MaxScheduledPerBlock::get();
+	assert!(max > 3, "pre-condition: This test only makes sense for MaxScheduledPerBlock > 3");
+
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+		let mut addrs = Vec::<_>::default();
+
+		// Schedule the maximal number allowed per block.
+		for _ in 0..max {
+			addrs.push(
+				<Scheduler as Anon<_, _, _>>::schedule(
+					DispatchTime::At(4),
+					None,
+					127,
+					root(),
+					bound.clone(),
+				)
+				.unwrap(),
+			);
+		}
+		let mut new_addrs = Vec::<_>::default();
+		// Reversed last three elements of block 4.
+		let last_three = addrs.into_iter().rev().take(3).collect::<Vec<_>>();
+		// Re-schedule three of them to block 5.
+		for addr in last_three.iter().cloned() {
+			new_addrs
+				.push(<Scheduler as Anon<_, _, _>>::reschedule(addr, DispatchTime::At(5)).unwrap());
+		}
+		// Re-scheduling them back into block 3 should result in the same addrs.
+		for (old, want) in new_addrs.into_iter().zip(last_three.into_iter().rev()) {
+			let new = <Scheduler as Anon<_, _, _>>::reschedule(old, DispatchTime::At(4)).unwrap();
+			assert_eq!(new, want);
+		}
+
+		run_to_block(4);
+		// Maximum number of calls are executed.
+		assert_eq!(logger::log().len() as u32, max);
+	});
+}
+
+/// The scheduler can be used as `v3::Named` trait.
+#[test]
+fn scheduler_v3_named_basic_works() {
+	use frame_support::traits::schedule::v3::Named;
+
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let name = [1u8; 32];
+
+		// Schedule a call.
+		let _address = <Scheduler as Named<_, _, _>>::schedule_named(
+			name,
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+
+		run_to_block(3);
+		// Did not execute till block 3.
+		assert!(logger::log().is_empty());
+		// Executes in block 4.
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+		// ... but not again.
+		run_to_block(100);
+		assert_eq!(logger::log(), vec![(root(), 42u32)]);
+	});
+}
+
+/// A named task can be cancelled by its name.
+#[test]
+fn scheduler_v3_named_cancel_named_works() {
+	use frame_support::traits::schedule::v3::Named;
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+		let name = [1u8; 32];
+
+		// Schedule a call.
+		<Scheduler as Named<_, _, _>>::schedule_named(
+			name,
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			bound.clone(),
+		)
+		.unwrap();
+		// Cancel the call by name.
+		assert_ok!(<Scheduler as Named<_, _, _>>::cancel_named(name));
+		// It did not get executed.
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+		// Cannot cancel again.
+		assert_noop!(<Scheduler as Named<_, _, _>>::cancel_named(name), DispatchError::Unavailable);
+	});
+}
+
+/// A named task can also be cancelled by its address.
+#[test]
+fn scheduler_v3_named_cancel_without_name_works() {
+	use frame_support::traits::schedule::v3::{Anon, Named};
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+		let name = [1u8; 32];
+
+		// Schedule a call.
+		let address = <Scheduler as Named<_, _, _>>::schedule_named(
+			name,
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			bound.clone(),
+		)
+		.unwrap();
+		// Cancel the call by address.
+		assert_ok!(<Scheduler as Anon<_, _, _>>::cancel(address));
+		// It did not get executed.
+		run_to_block(100);
+		assert!(logger::log().is_empty());
+		// Cannot cancel again.
+		assert_err!(<Scheduler as Anon<_, _, _>>::cancel(address), DispatchError::Unavailable);
+	});
+}
+
+/// A named task can be re-scheduled by its name but not by its address.
+#[test]
+fn scheduler_v3_named_reschedule_named_works() {
+	use frame_support::traits::schedule::v3::{Anon, Named};
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let name = [1u8; 32];
+
+		// Schedule a call.
+		let address = <Scheduler as Named<_, _, _>>::schedule_named(
+			name,
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+
+		run_to_block(3);
+		// Did not execute till block 3.
+		assert!(logger::log().is_empty());
+
+		// Cannot re-schedule by address.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::reschedule(address, DispatchTime::At(10)),
+			Error::<Test>::Named,
+		);
+		// Cannot re-schedule into the same block.
+		assert_noop!(
+			<Scheduler as Named<_, _, _>>::reschedule_named(name, DispatchTime::At(4)),
+			Error::<Test>::RescheduleNoChange
+		);
+		// Cannot re-schedule into the past.
+		assert_noop!(
+			<Scheduler as Named<_, _, _>>::reschedule_named(name, DispatchTime::At(3)),
+			Error::<Test>::TargetBlockNumberInPast
+		);
+		// Re-schedule to block 5.
+		assert_ok!(<Scheduler as Named<_, _, _>>::reschedule_named(name, DispatchTime::At(5)));
+		// Scheduled for block 5.
+		run_to_block(4);
+		assert!(logger::log().is_empty());
+		run_to_block(5);
+		// Does execute in block 5.
+		assert_eq!(logger::log(), vec![(root(), 42)]);
+		// Cannot re-schedule executed task.
+		assert_noop!(
+			<Scheduler as Named<_, _, _>>::reschedule_named(name, DispatchTime::At(10)),
+			DispatchError::Unavailable
+		);
+		// Also not by address.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::reschedule(address, DispatchTime::At(10)),
+			DispatchError::Unavailable
+		);
+	});
+}
+
+#[test]
+fn scheduler_v3_named_next_schedule_time_works() {
+	use frame_support::traits::schedule::v3::{Anon, Named};
+	new_test_ext().execute_with(|| {
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let bound = Preimage::bound(call).unwrap();
+		let name = [1u8; 32];
+
+		// Schedule a call.
+		let address = <Scheduler as Named<_, _, _>>::schedule_named(
+			name,
+			DispatchTime::At(4),
+			None,
+			127,
+			root(),
+			bound.clone(),
+		)
+		.unwrap();
+
+		run_to_block(3);
+		// Did not execute till block 3.
+		assert!(logger::log().is_empty());
+
+		// Scheduled for block 4.
+		assert_eq!(<Scheduler as Named<_, _, _>>::next_dispatch_time(name), Ok(4));
+		// Also works by address.
+		assert_eq!(<Scheduler as Anon<_, _, _>>::next_dispatch_time(address), Ok(4));
+		// Block 4 executes it.
+		run_to_block(4);
+		assert_eq!(logger::log(), vec![(root(), 42)]);
+
+		// It has no dispatch time anymore.
+		assert_noop!(
+			<Scheduler as Named<_, _, _>>::next_dispatch_time(name),
+			DispatchError::Unavailable
+		);
+		// Also not by address.
+		assert_noop!(
+			<Scheduler as Anon<_, _, _>>::next_dispatch_time(address),
+			DispatchError::Unavailable
+		);
+	});
+}
+
+#[test]
+fn cancel_last_task_removes_agenda() {
+	new_test_ext().execute_with(|| {
+		let when = 4;
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let address = Scheduler::do_schedule(
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call.clone()).unwrap(),
+		)
+		.unwrap();
+		let address2 = Scheduler::do_schedule(
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+		// two tasks at agenda.
+		assert!(Agenda::<Test>::get(when).len() == 2);
+		assert_ok!(Scheduler::do_cancel(None, address));
+		// still two tasks at agenda, `None` and `Some`.
+		assert!(Agenda::<Test>::get(when).len() == 2);
+		// cancel last task from `when` agenda.
+		assert_ok!(Scheduler::do_cancel(None, address2));
+		// if all tasks `None`, agenda fully removed.
+		assert!(Agenda::<Test>::get(when).len() == 0);
+	});
+}
+
+#[test]
+fn cancel_named_last_task_removes_agenda() {
+	new_test_ext().execute_with(|| {
+		let when = 4;
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		Scheduler::do_schedule_named(
+			[1u8; 32],
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call.clone()).unwrap(),
+		)
+		.unwrap();
+		Scheduler::do_schedule_named(
+			[2u8; 32],
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+		// two tasks at agenda.
+		assert!(Agenda::<Test>::get(when).len() == 2);
+		assert_ok!(Scheduler::do_cancel_named(None, [2u8; 32]));
+		// removes trailing `None` and leaves one task.
+		assert!(Agenda::<Test>::get(when).len() == 1);
+		// cancel last task from `when` agenda.
+		assert_ok!(Scheduler::do_cancel_named(None, [1u8; 32]));
+		// if all tasks `None`, agenda fully removed.
+		assert!(Agenda::<Test>::get(when).len() == 0);
+	});
+}
+
+#[test]
+fn reschedule_last_task_removes_agenda() {
+	new_test_ext().execute_with(|| {
+		let when = 4;
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		let address = Scheduler::do_schedule(
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call.clone()).unwrap(),
+		)
+		.unwrap();
+		let address2 = Scheduler::do_schedule(
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+		// two tasks at agenda.
+		assert!(Agenda::<Test>::get(when).len() == 2);
+		assert_ok!(Scheduler::do_cancel(None, address));
+		// still two tasks at agenda, `None` and `Some`.
+		assert!(Agenda::<Test>::get(when).len() == 2);
+		// reschedule last task from `when` agenda.
+		assert_eq!(
+			Scheduler::do_reschedule(address2, DispatchTime::At(when + 1)).unwrap(),
+			(when + 1, 0)
+		);
+		// if all tasks `None`, agenda fully removed.
+		assert!(Agenda::<Test>::get(when).len() == 0);
+	});
+}
+
+#[test]
+fn reschedule_named_last_task_removes_agenda() {
+	new_test_ext().execute_with(|| {
+		let when = 4;
+		let call =
+			RuntimeCall::Logger(LoggerCall::log { i: 42, weight: Weight::from_parts(10, 0) });
+		Scheduler::do_schedule_named(
+			[1u8; 32],
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call.clone()).unwrap(),
+		)
+		.unwrap();
+		Scheduler::do_schedule_named(
+			[2u8; 32],
+			DispatchTime::At(when),
+			None,
+			127,
+			root(),
+			Preimage::bound(call).unwrap(),
+		)
+		.unwrap();
+		// two tasks at agenda.
+		assert!(Agenda::<Test>::get(when).len() == 2);
+		assert_ok!(Scheduler::do_cancel_named(None, [1u8; 32]));
+		// still two tasks at agenda, `None` and `Some`.
+		assert!(Agenda::<Test>::get(when).len() == 2);
+		// reschedule last task from `when` agenda.
+		assert_eq!(
+			Scheduler::do_reschedule_named([2u8; 32], DispatchTime::At(when + 1)).unwrap(),
+			(when + 1, 0)
+		);
+		// if all tasks `None`, agenda fully removed.
+		assert!(Agenda::<Test>::get(when).len() == 0);
+	});
+}
diff --git a/substrate/frame/scheduler/src/weights.rs b/substrate/frame/scheduler/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..58d711862591d033b66251def364acd5ebbac7a7
--- /dev/null
+++ b/substrate/frame/scheduler/src/weights.rs
@@ -0,0 +1,360 @@
+// 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.
+
+//! Autogenerated weights for pallet_scheduler
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_scheduler
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/scheduler/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_scheduler.
+pub trait WeightInfo {
+	fn service_agendas_base() -> Weight;
+	fn service_agenda_base(s: u32, ) -> Weight;
+	fn service_task_base() -> Weight;
+	fn service_task_fetched(s: u32, ) -> Weight;
+	fn service_task_named() -> Weight;
+	fn service_task_periodic() -> Weight;
+	fn execute_dispatch_signed() -> Weight;
+	fn execute_dispatch_unsigned() -> Weight;
+	fn schedule(s: u32, ) -> Weight;
+	fn cancel(s: u32, ) -> Weight;
+	fn schedule_named(s: u32, ) -> Weight;
+	fn cancel_named(s: u32, ) -> Weight;
+}
+
+/// Weights for pallet_scheduler using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Scheduler IncompleteSince (r:1 w:1)
+	/// Proof: Scheduler IncompleteSince (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn service_agendas_base() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `31`
+		//  Estimated: `1489`
+		// Minimum execution time: 3_991_000 picoseconds.
+		Weight::from_parts(4_174_000, 1489)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 512]`.
+	fn service_agenda_base(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `81 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 3_581_000 picoseconds.
+		Weight::from_parts(7_413_174, 110487)
+			// Standard Error: 971
+			.saturating_add(Weight::from_parts(348_077, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn service_task_base() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_250_000 picoseconds.
+		Weight::from_parts(5_549_000, 0)
+	}
+	/// Storage: Preimage PreimageFor (r:1 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: Measured)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// The range of component `s` is `[128, 4194304]`.
+	fn service_task_fetched(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `179 + s * (1 ±0)`
+		//  Estimated: `3644 + s * (1 ±0)`
+		// Minimum execution time: 20_089_000 picoseconds.
+		Weight::from_parts(20_376_000, 3644)
+			// Standard Error: 3
+			.saturating_add(Weight::from_parts(1_170, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(s.into()))
+	}
+	/// Storage: Scheduler Lookup (r:0 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn service_task_named() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_998_000 picoseconds.
+		Weight::from_parts(7_303_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn service_task_periodic() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_078_000 picoseconds.
+		Weight::from_parts(5_315_000, 0)
+	}
+	fn execute_dispatch_signed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_228_000 picoseconds.
+		Weight::from_parts(2_352_000, 0)
+	}
+	fn execute_dispatch_unsigned() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_226_000 picoseconds.
+		Weight::from_parts(2_371_000, 0)
+	}
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 511]`.
+	fn schedule(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `81 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 12_683_000 picoseconds.
+		Weight::from_parts(16_951_846, 110487)
+			// Standard Error: 1_046
+			.saturating_add(Weight::from_parts(380_842, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Scheduler Lookup (r:0 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 512]`.
+	fn cancel(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `81 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 16_201_000 picoseconds.
+		Weight::from_parts(18_259_422, 110487)
+			// Standard Error: 1_344
+			.saturating_add(Weight::from_parts(545_863, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Scheduler Lookup (r:1 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 511]`.
+	fn schedule_named(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `596 + s * (178 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 16_180_000 picoseconds.
+		Weight::from_parts(25_128_925, 110487)
+			// Standard Error: 1_118
+			.saturating_add(Weight::from_parts(375_631, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Scheduler Lookup (r:1 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 512]`.
+	fn cancel_named(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `709 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 18_244_000 picoseconds.
+		Weight::from_parts(21_439_366, 110487)
+			// Standard Error: 1_084
+			.saturating_add(Weight::from_parts(557_691, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Scheduler IncompleteSince (r:1 w:1)
+	/// Proof: Scheduler IncompleteSince (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn service_agendas_base() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `31`
+		//  Estimated: `1489`
+		// Minimum execution time: 3_991_000 picoseconds.
+		Weight::from_parts(4_174_000, 1489)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 512]`.
+	fn service_agenda_base(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `81 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 3_581_000 picoseconds.
+		Weight::from_parts(7_413_174, 110487)
+			// Standard Error: 971
+			.saturating_add(Weight::from_parts(348_077, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn service_task_base() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_250_000 picoseconds.
+		Weight::from_parts(5_549_000, 0)
+	}
+	/// Storage: Preimage PreimageFor (r:1 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: Measured)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// The range of component `s` is `[128, 4194304]`.
+	fn service_task_fetched(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `179 + s * (1 ±0)`
+		//  Estimated: `3644 + s * (1 ±0)`
+		// Minimum execution time: 20_089_000 picoseconds.
+		Weight::from_parts(20_376_000, 3644)
+			// Standard Error: 3
+			.saturating_add(Weight::from_parts(1_170, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(s.into()))
+	}
+	/// Storage: Scheduler Lookup (r:0 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	fn service_task_named() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_998_000 picoseconds.
+		Weight::from_parts(7_303_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn service_task_periodic() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_078_000 picoseconds.
+		Weight::from_parts(5_315_000, 0)
+	}
+	fn execute_dispatch_signed() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_228_000 picoseconds.
+		Weight::from_parts(2_352_000, 0)
+	}
+	fn execute_dispatch_unsigned() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_226_000 picoseconds.
+		Weight::from_parts(2_371_000, 0)
+	}
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 511]`.
+	fn schedule(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `81 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 12_683_000 picoseconds.
+		Weight::from_parts(16_951_846, 110487)
+			// Standard Error: 1_046
+			.saturating_add(Weight::from_parts(380_842, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// Storage: Scheduler Lookup (r:0 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 512]`.
+	fn cancel(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `81 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 16_201_000 picoseconds.
+		Weight::from_parts(18_259_422, 110487)
+			// Standard Error: 1_344
+			.saturating_add(Weight::from_parts(545_863, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Scheduler Lookup (r:1 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 511]`.
+	fn schedule_named(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `596 + s * (178 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 16_180_000 picoseconds.
+		Weight::from_parts(25_128_925, 110487)
+			// Standard Error: 1_118
+			.saturating_add(Weight::from_parts(375_631, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Scheduler Lookup (r:1 w:1)
+	/// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen)
+	/// Storage: Scheduler Agenda (r:1 w:1)
+	/// Proof: Scheduler Agenda (max_values: None, max_size: Some(107022), added: 109497, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 512]`.
+	fn cancel_named(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `709 + s * (177 ±0)`
+		//  Estimated: `110487`
+		// Minimum execution time: 18_244_000 picoseconds.
+		Weight::from_parts(21_439_366, 110487)
+			// Standard Error: 1_084
+			.saturating_add(Weight::from_parts(557_691, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/scored-pool/Cargo.toml b/substrate/frame/scored-pool/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6bed5b04aef876b7474a8bfff0d13d5383c7fd4c
--- /dev/null
+++ b/substrate/frame/scored-pool/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "pallet-scored-pool"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for scored pools"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/scored-pool/README.md b/substrate/frame/scored-pool/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..455bae24e79510fd8c2b47c866f579ff8c923652
--- /dev/null
+++ b/substrate/frame/scored-pool/README.md
@@ -0,0 +1,73 @@
+# Scored Pool Module
+
+The module maintains a scored membership pool. Each entity in the
+pool can be attributed a `Score`. From this pool a set `Members`
+is constructed. This set contains the `MemberCount` highest
+scoring entities. Unscored entities are never part of `Members`.
+
+If an entity wants to be part of the pool a deposit is required.
+The deposit is returned when the entity withdraws or when it
+is removed by an entity with the appropriate authority.
+
+Every `Period` blocks the set of `Members` is refreshed from the
+highest scoring members in the pool and, no matter if changes
+occurred, `T::MembershipChanged::set_members_sorted` is invoked.
+On first load `T::MembershipInitialized::initialize_members` is
+invoked with the initial `Members` set.
+
+It is possible to withdraw candidacy/resign your membership at any
+time. If an entity is currently a member, this results in removal
+from the `Pool` and `Members`; the entity is immediately replaced
+by the next highest scoring candidate in the pool, if available.
+
+- [`scored_pool::Trait`](https://docs.rs/pallet-scored-pool/latest/pallet_scored_pool/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-scored-pool/latest/pallet_scored_pool/enum.Call.html)
+- [`Module`](https://docs.rs/pallet-scored-pool/latest/pallet_scored_pool/struct.Module.html)
+
+## Interface
+
+### Public Functions
+
+- `submit_candidacy` - Submit candidacy to become a member. Requires a deposit.
+- `withdraw_candidacy` - Withdraw candidacy. Deposit is returned.
+- `score` - Attribute a quantitative score to an entity.
+- `kick` - Remove an entity from the pool and members. Deposit is returned.
+- `change_member_count` - Changes the amount of candidates taken into `Members`.
+
+## Usage
+
+```rust
+use pallet_scored_pool::{self as scored_pool};
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config + scored_pool::Config {}
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::weight(0)]
+        pub fn candidate(origin: OriginFor<T>) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+
+            let _ = <scored_pool::Pallet<T>>::submit_candidacy(
+                T::RuntimeOrigin::from(Some(who.clone()).into())
+            );
+            Ok(())
+        }
+    }
+}
+```
+
+## Dependencies
+
+This module depends on the [System module](https://docs.rs/frame-system/latest/frame_system/).
+
+License: Apache-2.0
diff --git a/substrate/frame/scored-pool/src/lib.rs b/substrate/frame/scored-pool/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2bf70cbc574c8ff4e2f06abeaba51a6eecb88881
--- /dev/null
+++ b/substrate/frame/scored-pool/src/lib.rs
@@ -0,0 +1,512 @@
+// 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.
+
+//! # Scored Pool Pallet
+//!
+//! The pallet maintains a scored membership pool. Each entity in the
+//! pool can be attributed a `Score`. From this pool a set `Members`
+//! is constructed. This set contains the `MemberCount` highest
+//! scoring entities. Unscored entities are never part of `Members`.
+//!
+//! If an entity wants to be part of the pool a deposit is required.
+//! The deposit is returned when the entity withdraws or when it
+//! is removed by an entity with the appropriate authority.
+//!
+//! Every `Period` blocks the set of `Members` is refreshed from the
+//! highest scoring members in the pool and, no matter if changes
+//! occurred, `T::MembershipChanged::set_members_sorted` is invoked.
+//! On first load `T::MembershipInitialized::initialize_members` is
+//! invoked with the initial `Members` set.
+//!
+//! It is possible to withdraw candidacy/resign your membership at any
+//! time. If an entity is currently a member, this results in removal
+//! from the `Pool` and `Members`; the entity is immediately replaced
+//! by the next highest scoring candidate in the pool, if available.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Interface
+//!
+//! ### Public Functions
+//!
+//! - `submit_candidacy` - Submit candidacy to become a member. Requires a deposit.
+//! - `withdraw_candidacy` - Withdraw candidacy. Deposit is returned.
+//! - `score` - Attribute a quantitative score to an entity.
+//! - `kick` - Remove an entity from the pool and members. Deposit is returned.
+//! - `change_member_count` - Changes the amount of candidates taken into `Members`.
+//!
+//! ## Usage
+//!
+//! ```
+//! use pallet_scored_pool::{self as scored_pool};
+//!
+//! #[frame_support::pallet]
+//! pub mod pallet {
+//! 	use super::*;
+//! 	use frame_support::pallet_prelude::*;
+//! 	use frame_system::pallet_prelude::*;
+//!
+//! 	#[pallet::pallet]
+//! 	pub struct Pallet<T>(_);
+//!
+//! 	#[pallet::config]
+//! 	pub trait Config: frame_system::Config + scored_pool::Config {}
+//!
+//! 	#[pallet::call]
+//! 	impl<T: Config> Pallet<T> {
+//! 		#[pallet::weight({0})]
+//! 		pub fn candidate(origin: OriginFor<T>) -> DispatchResult {
+//! 			let who = ensure_signed(origin)?;
+//!
+//! 			let _ = <scored_pool::Pallet<T>>::submit_candidacy(
+//! 				T::RuntimeOrigin::from(Some(who.clone()).into())
+//! 			);
+//! 			Ok(())
+//! 		}
+//! 	}
+//! }
+//!
+//! # fn main() { }
+//! ```
+//!
+//! ## Dependencies
+//!
+//! This pallet depends on the [System pallet](../frame_system/index.html).
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+use codec::{FullCodec, MaxEncodedLen};
+use frame_support::{
+	ensure,
+	traits::{ChangeMembers, Currency, Get, InitializeMembers, ReservableCurrency},
+	BoundedVec,
+};
+pub use pallet::*;
+use sp_runtime::traits::{AtLeast32Bit, StaticLookup, Zero};
+use sp_std::{fmt::Debug, prelude::*};
+
+type BalanceOf<T, I> =
+	<<T as Config<I>>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type PoolT<T, I> = BoundedVec<
+	(<T as frame_system::Config>::AccountId, Option<<T as Config<I>>::Score>),
+	<T as Config<I>>::MaximumMembers,
+>;
+type MembersT<T, I> =
+	BoundedVec<<T as frame_system::Config>::AccountId, <T as Config<I>>::MaximumMembers>;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// The enum is supplied when refreshing the members set.
+/// Depending on the enum variant the corresponding associated
+/// type function will be invoked.
+enum ChangeReceiver {
+	/// Should call `T::MembershipInitialized`.
+	MembershipInitialized,
+	/// Should call `T::MembershipChanged`.
+	MembershipChanged,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The currency used for deposits.
+		type Currency: Currency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
+
+		/// Maximum members length allowed.
+		#[pallet::constant]
+		type MaximumMembers: Get<u32>;
+
+		/// The score attributed to a member or candidate.
+		type Score: AtLeast32Bit
+			+ Clone
+			+ Copy
+			+ Default
+			+ FullCodec
+			+ MaybeSerializeDeserialize
+			+ Debug
+			+ scale_info::TypeInfo
+			+ MaxEncodedLen;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		// The deposit which is reserved from candidates if they want to
+		// start a candidacy. The deposit gets returned when the candidacy is
+		// withdrawn or when the candidate is kicked.
+		#[pallet::constant]
+		type CandidateDeposit: Get<BalanceOf<Self, I>>;
+
+		/// Every `Period` blocks the `Members` are filled with the highest scoring
+		/// members in the `Pool`.
+		#[pallet::constant]
+		type Period: Get<BlockNumberFor<Self>>;
+
+		/// The receiver of the signal for when the membership has been initialized.
+		/// This happens pre-genesis and will usually be the same as `MembershipChanged`.
+		/// If you need to do something different on initialization, then you can change
+		/// this accordingly.
+		type MembershipInitialized: InitializeMembers<Self::AccountId>;
+
+		/// The receiver of the signal for when the members have changed.
+		type MembershipChanged: ChangeMembers<Self::AccountId>;
+
+		/// Allows a configurable origin type to set a score to a candidate in the pool.
+		type ScoreOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for removing a member (though can always be Root).
+		/// Configurable origin which enables removing an entity. If the entity
+		/// is part of the `Members` it is immediately replaced by the next
+		/// highest scoring candidate, if available.
+		type KickOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// The given member was removed. See the transaction for who.
+		MemberRemoved,
+		/// An entity has issued a candidacy. See the transaction for who.
+		CandidateAdded,
+		/// An entity withdrew candidacy. See the transaction for who.
+		CandidateWithdrew,
+		/// The candidacy was forcefully removed for an entity.
+		/// See the transaction for who.
+		CandidateKicked,
+		/// A score was attributed to the candidate.
+		/// See the transaction for who.
+		CandidateScored,
+	}
+
+	/// Error for the scored-pool pallet.
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Already a member.
+		AlreadyInPool,
+		/// Index out of bounds.
+		InvalidIndex,
+		/// Index does not match requested account.
+		WrongAccountIndex,
+		/// Number of members exceeds `MaximumMembers`.
+		TooManyMembers,
+	}
+
+	/// The current pool of candidates, stored as an ordered Bounded Vec
+	/// (ordered descending by score, `None` last, highest first).
+	#[pallet::storage]
+	#[pallet::getter(fn pool)]
+	pub(crate) type Pool<T: Config<I>, I: 'static = ()> = StorageValue<_, PoolT<T, I>, ValueQuery>;
+
+	/// A Map of the candidates. The information in this Map is redundant
+	/// to the information in the `Pool`. But the Map enables us to easily
+	/// check if a candidate is already in the pool, without having to
+	/// iterate over the entire pool (the `Pool` is not sorted by
+	/// `T::AccountId`, but by `T::Score` instead).
+	#[pallet::storage]
+	#[pallet::getter(fn candidate_exists)]
+	pub(crate) type CandidateExists<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, bool, ValueQuery>;
+
+	/// The current membership, stored as an ordered Vec.
+	#[pallet::storage]
+	#[pallet::getter(fn members)]
+	pub(crate) type Members<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, MembersT<T, I>, ValueQuery>;
+
+	/// Size of the `Members` set.
+	#[pallet::storage]
+	#[pallet::getter(fn member_count)]
+	pub(crate) type MemberCount<T, I = ()> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub pool: PoolT<T, I>,
+		pub member_count: u32,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			let mut pool = self.pool.clone();
+
+			// reserve balance for each candidate in the pool.
+			// panicking here is ok, since this just happens one time, pre-genesis.
+			pool.iter().for_each(|(who, _)| {
+				T::Currency::reserve(who, T::CandidateDeposit::get())
+					.expect("balance too low to create candidacy");
+				<CandidateExists<T, I>>::insert(who, true);
+			});
+
+			// Sorts the `Pool` by score in a descending order. Entities which
+			// have a score of `None` are sorted to the end of the bounded vec.
+			pool.sort_by_key(|(_, maybe_score)| Reverse(maybe_score.unwrap_or_default()));
+			<Pallet<T, I>>::update_member_count(self.member_count)
+				.expect("Number of allowed members exceeded");
+			<Pool<T, I>>::put(&pool);
+			<Pallet<T, I>>::refresh_members(pool, ChangeReceiver::MembershipInitialized);
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		/// Every `Period` blocks the `Members` set is refreshed from the
+		/// highest scoring members in the pool.
+		fn on_initialize(n: frame_system::pallet_prelude::BlockNumberFor<T>) -> Weight {
+			if n % T::Period::get() == Zero::zero() {
+				let pool = <Pool<T, I>>::get();
+				<Pallet<T, I>>::refresh_members(pool, ChangeReceiver::MembershipChanged);
+			}
+			Weight::zero()
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Add `origin` to the pool of candidates.
+		///
+		/// This results in `CandidateDeposit` being reserved from
+		/// the `origin` account. The deposit is returned once
+		/// candidacy is withdrawn by the candidate or the entity
+		/// is kicked by `KickOrigin`.
+		///
+		/// The dispatch origin of this function must be signed.
+		///
+		/// The `index` parameter of this function must be set to
+		/// the index of the transactor in the `Pool`.
+		#[pallet::call_index(0)]
+		#[pallet::weight({0})]
+		pub fn submit_candidacy(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			ensure!(!<CandidateExists<T, I>>::contains_key(&who), Error::<T, I>::AlreadyInPool);
+
+			let deposit = T::CandidateDeposit::get();
+			T::Currency::reserve(&who, deposit)?;
+
+			// can be inserted as last element in pool, since entities with
+			// `None` are always sorted to the end.
+			<Pool<T, I>>::try_append((who.clone(), Option::<<T as Config<I>>::Score>::None))
+				.map_err(|_| Error::<T, I>::TooManyMembers)?;
+
+			<CandidateExists<T, I>>::insert(&who, true);
+
+			Self::deposit_event(Event::<T, I>::CandidateAdded);
+			Ok(())
+		}
+
+		/// An entity withdraws candidacy and gets its deposit back.
+		///
+		/// If the entity is part of the `Members`, then the highest member
+		/// of the `Pool` that is not currently in `Members` is immediately
+		/// placed in the set instead.
+		///
+		/// The dispatch origin of this function must be signed.
+		///
+		/// The `index` parameter of this function must be set to
+		/// the index of the transactor in the `Pool`.
+		#[pallet::call_index(1)]
+		#[pallet::weight({0})]
+		pub fn withdraw_candidacy(origin: OriginFor<T>, index: u32) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let pool = <Pool<T, I>>::get();
+			Self::ensure_index(&pool, &who, index)?;
+
+			Self::remove_member(pool, who, index)?;
+			Self::deposit_event(Event::<T, I>::CandidateWithdrew);
+			Ok(())
+		}
+
+		/// Kick a member `who` from the set.
+		///
+		/// May only be called from `T::KickOrigin`.
+		///
+		/// The `index` parameter of this function must be set to
+		/// the index of `dest` in the `Pool`.
+		#[pallet::call_index(2)]
+		#[pallet::weight({0})]
+		pub fn kick(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			index: u32,
+		) -> DispatchResult {
+			T::KickOrigin::ensure_origin(origin)?;
+
+			let who = T::Lookup::lookup(dest)?;
+
+			let pool = <Pool<T, I>>::get();
+			Self::ensure_index(&pool, &who, index)?;
+
+			Self::remove_member(pool, who, index)?;
+			Self::deposit_event(Event::<T, I>::CandidateKicked);
+			Ok(())
+		}
+
+		/// Score a member `who` with `score`.
+		///
+		/// May only be called from `T::ScoreOrigin`.
+		///
+		/// The `index` parameter of this function must be set to
+		/// the index of the `dest` in the `Pool`.
+		#[pallet::call_index(3)]
+		#[pallet::weight({0})]
+		pub fn score(
+			origin: OriginFor<T>,
+			dest: AccountIdLookupOf<T>,
+			index: u32,
+			score: T::Score,
+		) -> DispatchResult {
+			T::ScoreOrigin::ensure_origin(origin)?;
+
+			let who = T::Lookup::lookup(dest)?;
+
+			let mut pool = <Pool<T, I>>::get();
+			Self::ensure_index(&pool, &who, index)?;
+
+			pool.remove(index as usize);
+
+			// we binary search the pool (which is sorted descending by score).
+			// if there is already an element with `score`, we insert
+			// right before that. if not, the search returns a location
+			// where we can insert while maintaining order.
+			let item = (who, Some(score));
+			let location = pool
+				.binary_search_by_key(&Reverse(score), |(_, maybe_score)| {
+					Reverse(maybe_score.unwrap_or_default())
+				})
+				.unwrap_or_else(|l| l);
+			pool.try_insert(location, item).map_err(|_| Error::<T, I>::TooManyMembers)?;
+
+			<Pool<T, I>>::put(&pool);
+			Self::deposit_event(Event::<T, I>::CandidateScored);
+			Ok(())
+		}
+
+		/// Dispatchable call to change `MemberCount`.
+		///
+		/// This will only have an effect the next time a refresh happens
+		/// (this happens each `Period`).
+		///
+		/// May only be called from root.
+		#[pallet::call_index(4)]
+		#[pallet::weight({0})]
+		pub fn change_member_count(origin: OriginFor<T>, count: u32) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::update_member_count(count).map_err(Into::into)
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Fetches the `MemberCount` highest scoring members from
+	/// `Pool` and puts them into `Members`.
+	///
+	/// The `notify` parameter is used to deduct which associated
+	/// type function to invoke at the end of the method.
+	fn refresh_members(pool: PoolT<T, I>, notify: ChangeReceiver) {
+		let count = MemberCount::<T, I>::get();
+		let old_members = <Members<T, I>>::get();
+
+		let new_members: Vec<T::AccountId> = pool
+			.into_iter()
+			.filter(|(_, score)| score.is_some())
+			.take(count as usize)
+			.map(|(account_id, _)| account_id)
+			.collect();
+
+		// It's safe to truncate_from at this point since MemberCount
+		// is verified that it does not exceed the MaximumMembers value
+		let mut new_members_bounded: MembersT<T, I> = BoundedVec::truncate_from(new_members);
+
+		new_members_bounded.sort();
+
+		<Members<T, I>>::put(&new_members_bounded);
+
+		match notify {
+			ChangeReceiver::MembershipInitialized =>
+				T::MembershipInitialized::initialize_members(&new_members_bounded),
+			ChangeReceiver::MembershipChanged =>
+				T::MembershipChanged::set_members_sorted(&new_members_bounded[..], &old_members[..]),
+		}
+	}
+
+	/// Removes an entity `remove` at `index` from the `Pool`.
+	///
+	/// If the entity is a member it is also removed from `Members` and
+	/// the deposit is returned.
+	fn remove_member(
+		mut pool: PoolT<T, I>,
+		remove: T::AccountId,
+		index: u32,
+	) -> Result<(), Error<T, I>> {
+		// all callers of this function in this pallet also check
+		// the index for validity before calling this function.
+		// nevertheless we check again here, to assert that there was
+		// no mistake when invoking this sensible function.
+		Self::ensure_index(&pool, &remove, index)?;
+
+		pool.remove(index as usize);
+		<Pool<T, I>>::put(&pool);
+
+		// remove from set, if it was in there
+		let members = <Members<T, I>>::get();
+		if members.binary_search(&remove).is_ok() {
+			Self::refresh_members(pool, ChangeReceiver::MembershipChanged);
+		}
+
+		<CandidateExists<T, I>>::remove(&remove);
+
+		T::Currency::unreserve(&remove, T::CandidateDeposit::get());
+
+		Self::deposit_event(Event::<T, I>::MemberRemoved);
+		Ok(())
+	}
+
+	/// Checks if `index` is a valid number and if the element found
+	/// at `index` in `Pool` is equal to `who`.
+	fn ensure_index(pool: &PoolT<T, I>, who: &T::AccountId, index: u32) -> Result<(), Error<T, I>> {
+		ensure!(index < pool.len() as u32, Error::<T, I>::InvalidIndex);
+
+		let (index_who, _index_score) = &pool[index as usize];
+		ensure!(index_who == who, Error::<T, I>::WrongAccountIndex);
+
+		Ok(())
+	}
+
+	/// Make sure the new member count value does not exceed the MaximumMembers
+	fn update_member_count(new_member_count: u32) -> Result<(), Error<T, I>> {
+		ensure!(new_member_count <= T::MaximumMembers::get(), Error::<T, I>::TooManyMembers);
+		<MemberCount<T, I>>::put(new_member_count);
+		Ok(())
+	}
+}
diff --git a/substrate/frame/scored-pool/src/mock.rs b/substrate/frame/scored-pool/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..591c910488b16c59660d354ed361774bf02ff187
--- /dev/null
+++ b/substrate/frame/scored-pool/src/mock.rs
@@ -0,0 +1,169 @@
+// 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.
+
+//! Test utilities
+
+use super::*;
+use crate as pallet_scored_pool;
+
+use frame_support::{
+	construct_runtime, ord_parameter_types, parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use frame_system::EnsureSignedBy;
+use sp_core::H256;
+use sp_runtime::{
+	bounded_vec,
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		ScoredPool: pallet_scored_pool::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub const CandidateDeposit: u64 = 25;
+}
+ord_parameter_types! {
+	pub const KickOrigin: u64 = 2;
+	pub const ScoreOrigin: u64 = 3;
+}
+
+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 = 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>;
+}
+
+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 MaxHolds = ();
+}
+
+parameter_types! {
+	pub static MembersTestValue: BoundedVec<u64,ConstU32<10_u32>> = bounded_vec![0,10];
+}
+
+pub struct TestChangeMembers;
+impl ChangeMembers<u64> for TestChangeMembers {
+	fn change_members_sorted(incoming: &[u64], outgoing: &[u64], new: &[u64]) {
+		let mut old_plus_incoming = MembersTestValue::get().into_inner();
+		old_plus_incoming.extend_from_slice(incoming);
+		old_plus_incoming.sort();
+
+		let mut new_plus_outgoing = new.to_vec();
+		new_plus_outgoing.extend_from_slice(outgoing);
+		new_plus_outgoing.sort();
+
+		assert_eq!(old_plus_incoming, new_plus_outgoing);
+
+		MembersTestValue::set(<BoundedVec<u64, ConstU32<10_u32>>>::truncate_from(new.to_vec()));
+	}
+}
+
+impl InitializeMembers<u64> for TestChangeMembers {
+	fn initialize_members(new_members: &[u64]) {
+		MembersTestValue::set(<BoundedVec<u64, ConstU32<10_u32>>>::truncate_from(
+			new_members.to_vec(),
+		));
+	}
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type KickOrigin = EnsureSignedBy<KickOrigin, u64>;
+	type MembershipInitialized = TestChangeMembers;
+	type MembershipChanged = TestChangeMembers;
+	type Currency = Balances;
+	type CandidateDeposit = CandidateDeposit;
+	type Period = ConstU64<4>;
+	type Score = u64;
+	type ScoreOrigin = EnsureSignedBy<ScoreOrigin, u64>;
+	type MaximumMembers = ConstU32<10>;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let mut balances = vec![];
+	for i in 1..31 {
+		balances.push((i, 500_000));
+	}
+	balances.push((31, 500_000));
+	balances.push((40, 500_000));
+	balances.push((99, 1));
+
+	pallet_balances::GenesisConfig::<Test> { balances }
+		.assimilate_storage(&mut t)
+		.unwrap();
+	pallet_scored_pool::GenesisConfig::<Test> {
+		pool: bounded_vec![(10, Some(1)), (20, Some(2)), (31, Some(2)), (40, Some(3)), (5, None)],
+		member_count: 2,
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	t.into()
+}
+
+/// Fetch an entity from the pool, if existent.
+pub fn fetch_from_pool(who: u64) -> Option<(u64, Option<u64>)> {
+	<Pallet<Test>>::pool().into_iter().find(|item| item.0 == who)
+}
+
+/// Find an entity in the pool.
+/// Returns its position in the `Pool` vec, if existent.
+pub fn find_in_pool(who: u64) -> Option<usize> {
+	<Pallet<Test>>::pool().into_iter().position(|item| item.0 == who)
+}
diff --git a/substrate/frame/scored-pool/src/tests.rs b/substrate/frame/scored-pool/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..96c94a6c1c652902758c3c7b56c99dc72e5392c8
--- /dev/null
+++ b/substrate/frame/scored-pool/src/tests.rs
@@ -0,0 +1,321 @@
+// 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 the pallet.
+
+use super::*;
+use mock::*;
+
+use frame_support::{assert_noop, assert_ok, traits::OnInitialize};
+use sp_runtime::traits::BadOrigin;
+
+type ScoredPool = Pallet<Test>;
+type System = frame_system::Pallet<Test>;
+type Balances = pallet_balances::Pallet<Test>;
+
+#[test]
+fn query_membership_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(ScoredPool::members(), vec![20, 40]);
+		assert_eq!(Balances::reserved_balance(31), CandidateDeposit::get());
+		assert_eq!(Balances::reserved_balance(40), CandidateDeposit::get());
+		assert_eq!(MembersTestValue::get().clone(), vec![20, 40]);
+	});
+}
+
+#[test]
+fn submit_candidacy_must_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			ScoredPool::submit_candidacy(RuntimeOrigin::signed(99)),
+			pallet_balances::Error::<Test, _>::InsufficientBalance,
+		);
+		assert_noop!(
+			ScoredPool::submit_candidacy(RuntimeOrigin::signed(40)),
+			Error::<Test, _>::AlreadyInPool
+		);
+	});
+}
+
+#[test]
+fn submit_candidacy_works() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 15;
+
+		// when
+		assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(who)));
+		assert_eq!(fetch_from_pool(15), Some((who, None)));
+
+		// then
+		assert_eq!(Balances::reserved_balance(who), CandidateDeposit::get());
+	});
+}
+
+#[test]
+fn scoring_works() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 15;
+		let score = 99;
+		assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(who)));
+
+		// when
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		assert_ok!(ScoredPool::score(RuntimeOrigin::signed(ScoreOrigin::get()), who, index, score));
+
+		// then
+		assert_eq!(fetch_from_pool(who), Some((who, Some(score))));
+		assert_eq!(find_in_pool(who), Some(0)); // must be first element, since highest scored
+	});
+}
+
+#[test]
+fn scoring_same_element_with_same_score_works() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 31;
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		let score = 2;
+
+		// when
+		assert_ok!(ScoredPool::score(RuntimeOrigin::signed(ScoreOrigin::get()), who, index, score));
+
+		// then
+		assert_eq!(fetch_from_pool(who), Some((who, Some(score))));
+
+		// must have been inserted right before the `20` element which is
+		// of the same score as `31`. so sort order is maintained.
+		assert_eq!(find_in_pool(who), Some(1));
+	});
+}
+
+#[test]
+fn kicking_works_only_for_authorized() {
+	new_test_ext().execute_with(|| {
+		let who = 40;
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		assert_noop!(ScoredPool::kick(RuntimeOrigin::signed(99), who, index), BadOrigin);
+	});
+}
+
+#[test]
+fn kicking_works() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 40;
+		assert_eq!(Balances::reserved_balance(who), CandidateDeposit::get());
+		assert_eq!(find_in_pool(who), Some(0));
+
+		// when
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		assert_ok!(ScoredPool::kick(RuntimeOrigin::signed(KickOrigin::get()), who, index));
+
+		// then
+		assert_eq!(find_in_pool(who), None);
+		assert_eq!(ScoredPool::members(), vec![20, 31]);
+		assert_eq!(MembersTestValue::get().clone(), ScoredPool::members());
+		assert_eq!(Balances::reserved_balance(who), 0); // deposit must have been returned
+	});
+}
+
+#[test]
+fn unscored_entities_must_not_be_used_for_filling_members() {
+	new_test_ext().execute_with(|| {
+		// given
+		// we submit a candidacy, score will be `None`
+		assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(15)));
+
+		// when
+		// we remove every scored member
+		ScoredPool::pool().into_iter().for_each(|(who, score)| {
+			if let Some(_) = score {
+				let index = find_in_pool(who).expect("entity must be in pool") as u32;
+				assert_ok!(ScoredPool::kick(RuntimeOrigin::signed(KickOrigin::get()), who, index));
+			}
+		});
+
+		// then
+		// the `None` candidates should not have been filled in
+		assert!(ScoredPool::members().is_empty());
+		assert_eq!(MembersTestValue::get().clone(), ScoredPool::members());
+	});
+}
+
+#[test]
+fn refreshing_works() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 15;
+		assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(who)));
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		assert_ok!(ScoredPool::score(RuntimeOrigin::signed(ScoreOrigin::get()), who, index, 99));
+
+		// when
+		ScoredPool::refresh_members(ScoredPool::pool(), ChangeReceiver::MembershipChanged);
+
+		// then
+		assert_eq!(ScoredPool::members(), vec![15, 40]);
+		assert_eq!(MembersTestValue::get().clone(), ScoredPool::members());
+	});
+}
+
+#[test]
+fn refreshing_happens_every_period() {
+	new_test_ext().execute_with(|| {
+		// given
+		System::set_block_number(1);
+		assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(15)));
+		let index = find_in_pool(15).expect("entity must be in pool") as u32;
+		assert_ok!(ScoredPool::score(RuntimeOrigin::signed(ScoreOrigin::get()), 15, index, 99));
+		assert_eq!(ScoredPool::members(), vec![20, 40]);
+
+		// when
+		System::set_block_number(4);
+		ScoredPool::on_initialize(4);
+
+		// then
+		assert_eq!(ScoredPool::members(), vec![15, 40]);
+		assert_eq!(MembersTestValue::get().clone(), ScoredPool::members());
+	});
+}
+
+#[test]
+fn withdraw_candidacy_must_only_work_for_members() {
+	new_test_ext().execute_with(|| {
+		let who = 77;
+		let index = 0;
+		assert_noop!(
+			ScoredPool::withdraw_candidacy(RuntimeOrigin::signed(who), index),
+			Error::<Test, _>::WrongAccountIndex
+		);
+	});
+}
+
+#[test]
+fn oob_index_should_abort() {
+	new_test_ext().execute_with(|| {
+		let who = 40;
+		let oob_index = ScoredPool::pool().len() as u32;
+		assert_noop!(
+			ScoredPool::withdraw_candidacy(RuntimeOrigin::signed(who), oob_index),
+			Error::<Test, _>::InvalidIndex
+		);
+		assert_noop!(
+			ScoredPool::score(RuntimeOrigin::signed(ScoreOrigin::get()), who, oob_index, 99),
+			Error::<Test, _>::InvalidIndex
+		);
+		assert_noop!(
+			ScoredPool::kick(RuntimeOrigin::signed(KickOrigin::get()), who, oob_index),
+			Error::<Test, _>::InvalidIndex
+		);
+	});
+}
+
+#[test]
+fn index_mismatches_should_abort() {
+	new_test_ext().execute_with(|| {
+		let who = 40;
+		let index = 3;
+		assert_noop!(
+			ScoredPool::withdraw_candidacy(RuntimeOrigin::signed(who), index),
+			Error::<Test, _>::WrongAccountIndex
+		);
+		assert_noop!(
+			ScoredPool::score(RuntimeOrigin::signed(ScoreOrigin::get()), who, index, 99),
+			Error::<Test, _>::WrongAccountIndex
+		);
+		assert_noop!(
+			ScoredPool::kick(RuntimeOrigin::signed(KickOrigin::get()), who, index),
+			Error::<Test, _>::WrongAccountIndex
+		);
+	});
+}
+
+#[test]
+fn withdraw_unscored_candidacy_must_work() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 5;
+
+		// when
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		assert_ok!(ScoredPool::withdraw_candidacy(RuntimeOrigin::signed(who), index));
+
+		// then
+		assert_eq!(fetch_from_pool(5), None);
+	});
+}
+
+#[test]
+fn withdraw_scored_candidacy_must_work() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 40;
+		assert_eq!(Balances::reserved_balance(who), CandidateDeposit::get());
+
+		// when
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		assert_ok!(ScoredPool::withdraw_candidacy(RuntimeOrigin::signed(who), index));
+
+		// then
+		assert_eq!(fetch_from_pool(who), None);
+		assert_eq!(ScoredPool::members(), vec![20, 31]);
+		assert_eq!(Balances::reserved_balance(who), 0);
+	});
+}
+
+#[test]
+fn candidacy_resubmitting_works() {
+	new_test_ext().execute_with(|| {
+		// given
+		let who = 15;
+
+		// when
+		assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(who)));
+		assert_eq!(ScoredPool::candidate_exists(who), true);
+		let index = find_in_pool(who).expect("entity must be in pool") as u32;
+		assert_ok!(ScoredPool::withdraw_candidacy(RuntimeOrigin::signed(who), index));
+		assert_eq!(ScoredPool::candidate_exists(who), false);
+		assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(who)));
+
+		// then
+		assert_eq!(ScoredPool::candidate_exists(who), true);
+	});
+}
+
+#[test]
+fn pool_candidates_exceeded() {
+	new_test_ext().execute_with(|| {
+		for i in [1, 2, 3, 4, 6] {
+			let who = i as u64;
+			assert_ok!(ScoredPool::submit_candidacy(RuntimeOrigin::signed(who)));
+			let index = find_in_pool(who).expect("entity must be in pool") as u32;
+			assert_ok!(ScoredPool::score(
+				RuntimeOrigin::signed(ScoreOrigin::get()),
+				who,
+				index,
+				99
+			));
+		}
+
+		assert_noop!(
+			ScoredPool::submit_candidacy(RuntimeOrigin::signed(8)),
+			Error::<Test, _>::TooManyMembers
+		);
+	});
+}
diff --git a/substrate/frame/session/Cargo.toml b/substrate/frame/session/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1fc5f4c1ab8c2405cd4832cd8eccf1649bf51fa2
--- /dev/null
+++ b/substrate/frame/session/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "pallet-session"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME sessions pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+impl-trait-for-tuples = "0.2.2"
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-timestamp = { version = "4.0.0-dev", default-features = false, path = "../timestamp" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core", features = ["serde"] }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../primitives/session" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-trie = { version = "22.0.0", default-features = false, optional = true, path = "../../primitives/trie" }
+sp-state-machine = { version = "0.28.0", default-features = false, path = "../../primitives/state-machine" }
+
+[features]
+default = [ "historical", "std" ]
+historical = [ "sp-trie" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-staking/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-trie/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/session/README.md b/substrate/frame/session/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..09132470d4433e71141b8efea9de9c5cc3eddef5
--- /dev/null
+++ b/substrate/frame/session/README.md
@@ -0,0 +1,83 @@
+# Session Pallet
+
+The Session module allows validators to manage their session keys, provides a function for changing
+the session length, and handles session rotation.
+
+- [`session::Trait`](https://docs.rs/pallet-session/latest/pallet_session/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-session/latest/pallet_session/enum.Call.html)
+- [`Pallet`](https://docs.rs/pallet-session/latest/pallet_session/struct.Pallet.html)
+
+## Overview
+
+### Terminology
+<!-- Original author of paragraph: @gavofyork -->
+
+- **Session:** A session is a period of time that has a constant set of validators. Validators can only join
+or exit the validator set at a session change. It is measured in block numbers. The block where a session is
+ended is determined by the `ShouldEndSession` trait. When the session is ending, a new validator set
+can be chosen by `OnSessionEnding` implementations.
+- **Session key:** A session key is actually several keys kept together that provide the various signing
+functions required by network authorities/validators in pursuit of their duties.
+- **Validator ID:** Every account has an associated validator ID. For some simple staking systems, this
+may just be the same as the account ID. For staking systems using a stash/controller model,
+the validator ID would be the stash account ID of the controller.
+- **Session key configuration process:** Session keys are set using `set_keys` for use not in
+the next session, but the session after next. They are stored in `NextKeys`, a mapping between
+the caller's `ValidatorId` and the session keys provided. `set_keys` allows users to set their
+session key prior to being selected as validator.
+It is a public call since it uses `ensure_signed`, which checks that the origin is a signed account.
+As such, the account ID of the origin stored in `NextKeys` may not necessarily be associated with
+a block author or a validator. The session keys of accounts are removed once their account balance is zero.
+- **Session length:** This pallet does not assume anything about the length of each session.
+Rather, it relies on an implementation of `ShouldEndSession` to dictate a new session's start.
+This pallet provides the `PeriodicSessions` struct for simple periodic sessions.
+- **Session rotation configuration:** Configure as either a 'normal' (rewardable session where rewards are
+applied) or 'exceptional' (slashable) session rotation.
+- **Session rotation process:** At the beginning of each block, the `on_initialize` function
+queries the provided implementation of `ShouldEndSession`. If the session is to end the newly
+activated validator IDs and session keys are taken from storage and passed to the
+`SessionHandler`. The validator set supplied by `SessionManager::new_session` and the corresponding session
+keys, which may have been registered via `set_keys` during the previous session, are written
+to storage where they will wait one session before being passed to the `SessionHandler`
+themselves.
+
+### Goals
+
+The Session pallet is designed to make the following possible:
+
+- Set session keys of the validator set for upcoming sessions.
+- Control the length of sessions.
+- Configure and switch between either normal or exceptional session rotations.
+
+## Interface
+
+### Dispatchable Functions
+
+- `set_keys` - Set a validator's session keys for upcoming sessions.
+
+### Public Functions
+
+- `rotate_session` - Change to the next session. Register the new authority set. Queue changes
+for next session rotation.
+- `disable_index` - Disable a validator by index.
+- `disable` - Disable a validator by Validator ID
+
+## Usage
+
+### Example from the FRAME
+
+The [Staking pallet](https://docs.rs/pallet-staking/latest/pallet_staking/) uses the Session pallet to get the validator set.
+
+```rust
+use pallet_session as session;
+
+fn validators<T: pallet_session::Config>() -> Vec<<T as pallet_session::Config>::ValidatorId> {
+	<pallet_session::Pallet<T>>::validators()
+}
+```
+
+## Related Pallets
+
+- [Staking](https://docs.rs/pallet-staking/latest/pallet_staking/)
+
+License: Apache-2.0
diff --git a/substrate/frame/session/benchmarking/Cargo.toml b/substrate/frame/session/benchmarking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5db6821da1fab01be2f504645292840f04562a5f
--- /dev/null
+++ b/substrate/frame/session/benchmarking/Cargo.toml
@@ -0,0 +1,65 @@
+[package]
+name = "pallet-session-benchmarking"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME sessions pallet benchmarking"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+rand = { version = "0.8.5", default-features = false, features = ["std_rng"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+pallet-session = { version = "4.0.0-dev", default-features = false, path = "../../session" }
+pallet-staking = { version = "4.0.0-dev", default-features = false, path = "../../staking" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/session" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[dev-dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
+scale-info = "2.1.1"
+frame-election-provider-support = { version = "4.0.0-dev", path = "../../election-provider-support" }
+pallet-balances = { version = "4.0.0-dev", path = "../../balances" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../../staking/reward-curve" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../../timestamp" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"frame-benchmarking/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-session/std",
+	"pallet-staking/std",
+	"pallet-timestamp/std",
+	"rand/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-std/std",
+]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-staking/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
diff --git a/substrate/frame/session/benchmarking/README.md b/substrate/frame/session/benchmarking/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d034a9ec73284fee91c5a2a8c397f5d4bc551a0e
--- /dev/null
+++ b/substrate/frame/session/benchmarking/README.md
@@ -0,0 +1,3 @@
+Benchmarks for the Session Pallet.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/session/benchmarking/src/lib.rs b/substrate/frame/session/benchmarking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..722bb14fb56edcccf735b6554a50e8ece9023d2d
--- /dev/null
+++ b/substrate/frame/session/benchmarking/src/lib.rs
@@ -0,0 +1,167 @@
+// 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.
+
+//! Benchmarks for the Session Pallet.
+// This is separated into its own crate due to cyclic dependency issues.
+
+#![cfg(feature = "runtime-benchmarks")]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod mock;
+
+use sp_runtime::traits::{One, StaticLookup, TrailingZeroInput};
+use sp_std::{prelude::*, vec};
+
+use codec::Decode;
+use frame_benchmarking::v1::benchmarks;
+use frame_support::traits::{Get, KeyOwnerProofSystem, OnInitialize};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use pallet_session::{historical::Pallet as Historical, Pallet as Session, *};
+use pallet_staking::{
+	benchmarking::create_validator_with_nominators, testing_utils::create_validators,
+	MaxNominationsOf, RewardDestination,
+};
+
+const MAX_VALIDATORS: u32 = 1000;
+
+pub struct Pallet<T: Config>(pallet_session::Pallet<T>);
+pub trait Config:
+	pallet_session::Config + pallet_session::historical::Config + pallet_staking::Config
+{
+}
+
+impl<T: Config> OnInitialize<BlockNumberFor<T>> for Pallet<T> {
+	fn on_initialize(n: BlockNumberFor<T>) -> frame_support::weights::Weight {
+		pallet_session::Pallet::<T>::on_initialize(n)
+	}
+}
+
+benchmarks! {
+	set_keys {
+		let n = MaxNominationsOf::<T>::get();
+		let (v_stash, _) = create_validator_with_nominators::<T>(
+			n,
+			MaxNominationsOf::<T>::get(),
+			false,
+			true,
+			RewardDestination::Staked,
+		)?;
+		let v_controller = pallet_staking::Pallet::<T>::bonded(&v_stash).ok_or("not stash")?;
+
+		let keys = T::Keys::decode(&mut TrailingZeroInput::zeroes()).unwrap();
+		let proof: Vec<u8> = vec![0,1,2,3];
+		// Whitelist controller account from further DB operations.
+		let v_controller_key = frame_system::Account::<T>::hashed_key_for(&v_controller);
+		frame_benchmarking::benchmarking::add_to_whitelist(v_controller_key.into());
+	}: _(RawOrigin::Signed(v_controller), keys, proof)
+
+	purge_keys {
+		let n = MaxNominationsOf::<T>::get();
+		let (v_stash, _) = create_validator_with_nominators::<T>(
+			n,
+			MaxNominationsOf::<T>::get(),
+			false,
+			true,
+			RewardDestination::Staked,
+		)?;
+		let v_controller = pallet_staking::Pallet::<T>::bonded(&v_stash).ok_or("not stash")?;
+		let keys = T::Keys::decode(&mut TrailingZeroInput::zeroes()).unwrap();
+		let proof: Vec<u8> = vec![0,1,2,3];
+		Session::<T>::set_keys(RawOrigin::Signed(v_controller.clone()).into(), keys, proof)?;
+		// Whitelist controller account from further DB operations.
+		let v_controller_key = frame_system::Account::<T>::hashed_key_for(&v_controller);
+		frame_benchmarking::benchmarking::add_to_whitelist(v_controller_key.into());
+	}: _(RawOrigin::Signed(v_controller))
+
+	#[extra]
+	check_membership_proof_current_session {
+		let n in 2 .. MAX_VALIDATORS as u32;
+
+		let (key, key_owner_proof1) = check_membership_proof_setup::<T>(n);
+		let key_owner_proof2 = key_owner_proof1.clone();
+	}: {
+		Historical::<T>::check_proof(key, key_owner_proof1);
+	}
+	verify {
+		assert!(Historical::<T>::check_proof(key, key_owner_proof2).is_some());
+	}
+
+	#[extra]
+	check_membership_proof_historical_session {
+		let n in 2 .. MAX_VALIDATORS as u32;
+
+		let (key, key_owner_proof1) = check_membership_proof_setup::<T>(n);
+
+		// skip to the next session so that the session is historical
+		// and the membership merkle proof must be checked.
+		Session::<T>::rotate_session();
+
+		let key_owner_proof2 = key_owner_proof1.clone();
+	}: {
+		Historical::<T>::check_proof(key, key_owner_proof1);
+	}
+	verify {
+		assert!(Historical::<T>::check_proof(key, key_owner_proof2).is_some());
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test, extra = false);
+}
+
+/// Sets up the benchmark for checking a membership proof. It creates the given
+/// number of validators, sets random session keys and then creates a membership
+/// proof for the first authority and returns its key and the proof.
+fn check_membership_proof_setup<T: Config>(
+	n: u32,
+) -> ((sp_runtime::KeyTypeId, &'static [u8; 32]), sp_session::MembershipProof) {
+	pallet_staking::ValidatorCount::<T>::put(n);
+
+	// create validators and set random session keys
+	for (n, who) in create_validators::<T>(n, 1000).unwrap().into_iter().enumerate() {
+		use rand::{RngCore, SeedableRng};
+
+		let validator = T::Lookup::lookup(who).unwrap();
+		let controller = pallet_staking::Pallet::<T>::bonded(validator).unwrap();
+
+		let keys = {
+			let mut keys = [0u8; 128];
+
+			// we keep the keys for the first validator as 0x00000...
+			if n > 0 {
+				let mut rng = rand::rngs::StdRng::seed_from_u64(n as u64);
+				rng.fill_bytes(&mut keys);
+			}
+
+			keys
+		};
+
+		let keys: T::Keys = Decode::decode(&mut &keys[..]).unwrap();
+		let proof: Vec<u8> = vec![];
+
+		Session::<T>::set_keys(RawOrigin::Signed(controller).into(), keys, proof).unwrap();
+	}
+
+	Pallet::<T>::on_initialize(frame_system::pallet_prelude::BlockNumberFor::<T>::one());
+
+	// skip sessions until the new validator set is enacted
+	while Session::<T>::validators().len() < n as usize {
+		Session::<T>::rotate_session();
+	}
+
+	let key = (sp_runtime::KeyTypeId(*b"babe"), &[0u8; 32]);
+
+	(key, Historical::<T>::prove(key).unwrap())
+}
diff --git a/substrate/frame/session/benchmarking/src/mock.rs b/substrate/frame/session/benchmarking/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..24a821ac87af50377d1ed51a65b5400fb3635404
--- /dev/null
+++ b/substrate/frame/session/benchmarking/src/mock.rs
@@ -0,0 +1,194 @@
+// 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.
+
+//! Mock file for session benchmarking.
+
+#![cfg(test)]
+
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, SequentialPhragmen,
+};
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use sp_runtime::{traits::IdentityLookup, BuildStorage};
+
+type AccountId = u64;
+type Nonce = u32;
+type Balance = u64;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Staking: pallet_staking::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+	}
+);
+
+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>;
+}
+
+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 MaxHolds = ();
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+impl pallet_session::historical::Config for Test {
+	type FullIdentification = pallet_staking::Exposure<AccountId, Balance>;
+	type FullIdentificationOf = pallet_staking::ExposureOf<Test>;
+}
+
+sp_runtime::impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub foo: sp_runtime::testing::UintAuthorityId,
+	}
+}
+
+pub struct TestSessionHandler;
+impl pallet_session::SessionHandler<AccountId> for TestSessionHandler {
+	const KEY_TYPE_IDS: &'static [sp_runtime::KeyTypeId] = &[];
+
+	fn on_genesis_session<Ks: sp_runtime::traits::OpaqueKeys>(_validators: &[(AccountId, Ks)]) {}
+
+	fn on_new_session<Ks: sp_runtime::traits::OpaqueKeys>(
+		_: bool,
+		_: &[(AccountId, Ks)],
+		_: &[(AccountId, Ks)],
+	) {
+	}
+
+	fn on_disabled(_: u32) {}
+}
+
+impl pallet_session::Config for Test {
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Test, Staking>;
+	type Keys = SessionKeys;
+	type ShouldEndSession = pallet_session::PeriodicSessions<(), ()>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<(), ()>;
+	type SessionHandler = TestSessionHandler;
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = AccountId;
+	type ValidatorIdOf = pallet_staking::StashOf<Test>;
+	type WeightInfo = ();
+}
+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 ElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Test;
+	type Solver = SequentialPhragmen<AccountId, sp_runtime::Perbill>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = ConstU32<100>;
+	type Bounds = ElectionsBounds;
+}
+
+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 MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = ();
+	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type GenesisElectionProvider = Self::ElectionProvider;
+	type MaxUnlockingChunks = ConstU32<32>;
+	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 = ();
+}
+
+impl crate::Config for Test {}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	sp_io::TestExternalities::new(t)
+}
diff --git a/substrate/frame/session/src/historical/mod.rs b/substrate/frame/session/src/historical/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d74e9dd0b7c54042840c62feff0693359f97c6c9
--- /dev/null
+++ b/substrate/frame/session/src/historical/mod.rs
@@ -0,0 +1,495 @@
+// 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.
+
+//! An opt-in utility for tracking historical sessions in FRAME-session.
+//!
+//! This is generally useful when implementing blockchains that require accountable
+//! safety where validators from some amount f prior sessions must remain slashable.
+//!
+//! Rather than store the full session data for any given session, we instead commit
+//! to the roots of merkle tries containing the session data.
+//!
+//! These roots and proofs of inclusion can be generated at any time during the current session.
+//! Afterwards, the proofs can be fed to a consensus module when reporting misbehavior.
+
+pub mod offchain;
+pub mod onchain;
+mod shared;
+
+use codec::{Decode, Encode};
+use sp_runtime::{
+	traits::{Convert, OpaqueKeys},
+	KeyTypeId,
+};
+use sp_session::{MembershipProof, ValidatorCount};
+use sp_staking::SessionIndex;
+use sp_std::prelude::*;
+use sp_trie::{
+	trie_types::{TrieDBBuilder, TrieDBMutBuilderV0},
+	LayoutV0, MemoryDB, Recorder, Trie, TrieMut, EMPTY_PREFIX,
+};
+
+use frame_support::{
+	print,
+	traits::{KeyOwnerProofSystem, ValidatorSet, ValidatorSetWithIdentification},
+	Parameter,
+};
+
+use crate::{self as pallet_session, Pallet as Session};
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	/// Config necessary for the historical pallet.
+	#[pallet::config]
+	pub trait Config: pallet_session::Config + frame_system::Config {
+		/// Full identification of the validator.
+		type FullIdentification: Parameter;
+
+		/// A conversion from validator ID to full identification.
+		///
+		/// This should contain any references to economic actors associated with the
+		/// validator, since they may be outdated by the time this is queried from a
+		/// historical trie.
+		///
+		/// It must return the identification for the current session index.
+		type FullIdentificationOf: Convert<Self::ValidatorId, Option<Self::FullIdentification>>;
+	}
+
+	/// Mapping from historical session indices to session-data root hash and validator count.
+	#[pallet::storage]
+	#[pallet::getter(fn historical_root)]
+	pub type HistoricalSessions<T: Config> =
+		StorageMap<_, Twox64Concat, SessionIndex, (T::Hash, ValidatorCount), OptionQuery>;
+
+	/// The range of historical sessions we store. [first, last)
+	#[pallet::storage]
+	pub type StoredRange<T> = StorageValue<_, (SessionIndex, SessionIndex), OptionQuery>;
+}
+
+impl<T: Config> Pallet<T> {
+	/// Prune historical stored session roots up to (but not including)
+	/// `up_to`.
+	pub fn prune_up_to(up_to: SessionIndex) {
+		StoredRange::<T>::mutate(|range| {
+			let (start, end) = match *range {
+				Some(range) => range,
+				None => return, // nothing to prune.
+			};
+
+			let up_to = sp_std::cmp::min(up_to, end);
+
+			if up_to < start {
+				return // out of bounds. harmless.
+			}
+
+			(start..up_to).for_each(HistoricalSessions::<T>::remove);
+
+			let new_start = up_to;
+			*range = if new_start == end {
+				None // nothing is stored.
+			} else {
+				Some((new_start, end))
+			}
+		})
+	}
+}
+
+impl<T: Config> ValidatorSet<T::AccountId> for Pallet<T> {
+	type ValidatorId = T::ValidatorId;
+	type ValidatorIdOf = T::ValidatorIdOf;
+
+	fn session_index() -> sp_staking::SessionIndex {
+		super::Pallet::<T>::current_index()
+	}
+
+	fn validators() -> Vec<Self::ValidatorId> {
+		super::Pallet::<T>::validators()
+	}
+}
+
+impl<T: Config> ValidatorSetWithIdentification<T::AccountId> for Pallet<T> {
+	type Identification = T::FullIdentification;
+	type IdentificationOf = T::FullIdentificationOf;
+}
+
+/// Specialization of the crate-level `SessionManager` which returns the set of full identification
+/// when creating a new session.
+pub trait SessionManager<ValidatorId, FullIdentification>:
+	pallet_session::SessionManager<ValidatorId>
+{
+	/// If there was a validator set change, its returns the set of new validators along with their
+	/// full identifications.
+	fn new_session(new_index: SessionIndex) -> Option<Vec<(ValidatorId, FullIdentification)>>;
+	fn new_session_genesis(
+		new_index: SessionIndex,
+	) -> Option<Vec<(ValidatorId, FullIdentification)>> {
+		<Self as SessionManager<_, _>>::new_session(new_index)
+	}
+	fn start_session(start_index: SessionIndex);
+	fn end_session(end_index: SessionIndex);
+}
+
+/// An `SessionManager` implementation that wraps an inner `I` and also
+/// sets the historical trie root of the ending session.
+pub struct NoteHistoricalRoot<T, I>(sp_std::marker::PhantomData<(T, I)>);
+
+impl<T: Config, I: SessionManager<T::ValidatorId, T::FullIdentification>> NoteHistoricalRoot<T, I> {
+	fn do_new_session(new_index: SessionIndex, is_genesis: bool) -> Option<Vec<T::ValidatorId>> {
+		<StoredRange<T>>::mutate(|range| {
+			range.get_or_insert_with(|| (new_index, new_index)).1 = new_index + 1;
+		});
+
+		let new_validators_and_id = if is_genesis {
+			<I as SessionManager<_, _>>::new_session_genesis(new_index)
+		} else {
+			<I as SessionManager<_, _>>::new_session(new_index)
+		};
+		let new_validators_opt = new_validators_and_id
+			.as_ref()
+			.map(|new_validators| new_validators.iter().map(|(v, _id)| v.clone()).collect());
+
+		if let Some(new_validators) = new_validators_and_id {
+			let count = new_validators.len() as ValidatorCount;
+			match ProvingTrie::<T>::generate_for(new_validators) {
+				Ok(trie) => <HistoricalSessions<T>>::insert(new_index, &(trie.root, count)),
+				Err(reason) => {
+					print("Failed to generate historical ancestry-inclusion proof.");
+					print(reason);
+				},
+			};
+		} else {
+			let previous_index = new_index.saturating_sub(1);
+			if let Some(previous_session) = <HistoricalSessions<T>>::get(previous_index) {
+				<HistoricalSessions<T>>::insert(new_index, previous_session);
+			}
+		}
+
+		new_validators_opt
+	}
+}
+
+impl<T: Config, I> pallet_session::SessionManager<T::ValidatorId> for NoteHistoricalRoot<T, I>
+where
+	I: SessionManager<T::ValidatorId, T::FullIdentification>,
+{
+	fn new_session(new_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {
+		Self::do_new_session(new_index, false)
+	}
+
+	fn new_session_genesis(new_index: SessionIndex) -> Option<Vec<T::ValidatorId>> {
+		Self::do_new_session(new_index, true)
+	}
+
+	fn start_session(start_index: SessionIndex) {
+		<I as SessionManager<_, _>>::start_session(start_index)
+	}
+
+	fn end_session(end_index: SessionIndex) {
+		onchain::store_session_validator_set_to_offchain::<T>(end_index);
+		<I as SessionManager<_, _>>::end_session(end_index)
+	}
+}
+
+/// A tuple of the validator's ID and their full identification.
+pub type IdentificationTuple<T> =
+	(<T as pallet_session::Config>::ValidatorId, <T as Config>::FullIdentification);
+
+/// A trie instance for checking and generating proofs.
+pub struct ProvingTrie<T: Config> {
+	db: MemoryDB<T::Hashing>,
+	root: T::Hash,
+}
+
+impl<T: Config> ProvingTrie<T> {
+	fn generate_for<I>(validators: I) -> Result<Self, &'static str>
+	where
+		I: IntoIterator<Item = (T::ValidatorId, T::FullIdentification)>,
+	{
+		let mut db = MemoryDB::default();
+		let mut root = Default::default();
+
+		{
+			let mut trie = TrieDBMutBuilderV0::new(&mut db, &mut root).build();
+			for (i, (validator, full_id)) in validators.into_iter().enumerate() {
+				let i = i as u32;
+				let keys = match <Session<T>>::load_keys(&validator) {
+					None => continue,
+					Some(k) => k,
+				};
+
+				let full_id = (validator, full_id);
+
+				// map each key to the owner index.
+				for key_id in T::Keys::key_ids() {
+					let key = keys.get_raw(*key_id);
+					let res =
+						(key_id, key).using_encoded(|k| i.using_encoded(|v| trie.insert(k, v)));
+
+					let _ = res.map_err(|_| "failed to insert into trie")?;
+				}
+
+				// map each owner index to the full identification.
+				let _ = i
+					.using_encoded(|k| full_id.using_encoded(|v| trie.insert(k, v)))
+					.map_err(|_| "failed to insert into trie")?;
+			}
+		}
+
+		Ok(ProvingTrie { db, root })
+	}
+
+	fn from_nodes(root: T::Hash, nodes: &[Vec<u8>]) -> Self {
+		use sp_trie::HashDBT;
+
+		let mut memory_db = MemoryDB::default();
+		for node in nodes {
+			HashDBT::insert(&mut memory_db, EMPTY_PREFIX, &node[..]);
+		}
+
+		ProvingTrie { db: memory_db, root }
+	}
+
+	/// Prove the full verification data for a given key and key ID.
+	pub fn prove(&self, key_id: KeyTypeId, key_data: &[u8]) -> Option<Vec<Vec<u8>>> {
+		let mut recorder = Recorder::<LayoutV0<T::Hashing>>::new();
+		{
+			let trie =
+				TrieDBBuilder::new(&self.db, &self.root).with_recorder(&mut recorder).build();
+			let val_idx = (key_id, key_data).using_encoded(|s| {
+				trie.get(s).ok()?.and_then(|raw| u32::decode(&mut &*raw).ok())
+			})?;
+
+			val_idx.using_encoded(|s| {
+				trie.get(s)
+					.ok()?
+					.and_then(|raw| <IdentificationTuple<T>>::decode(&mut &*raw).ok())
+			})?;
+		}
+
+		Some(recorder.drain().into_iter().map(|r| r.data).collect())
+	}
+
+	/// Access the underlying trie root.
+	pub fn root(&self) -> &T::Hash {
+		&self.root
+	}
+
+	// Check a proof contained within the current memory-db. Returns `None` if the
+	// nodes within the current `MemoryDB` are insufficient to query the item.
+	fn query(&self, key_id: KeyTypeId, key_data: &[u8]) -> Option<IdentificationTuple<T>> {
+		let trie = TrieDBBuilder::new(&self.db, &self.root).build();
+		let val_idx = (key_id, key_data)
+			.using_encoded(|s| trie.get(s))
+			.ok()?
+			.and_then(|raw| u32::decode(&mut &*raw).ok())?;
+
+		val_idx
+			.using_encoded(|s| trie.get(s))
+			.ok()?
+			.and_then(|raw| <IdentificationTuple<T>>::decode(&mut &*raw).ok())
+	}
+}
+
+impl<T: Config, D: AsRef<[u8]>> KeyOwnerProofSystem<(KeyTypeId, D)> for Pallet<T> {
+	type Proof = MembershipProof;
+	type IdentificationTuple = IdentificationTuple<T>;
+
+	fn prove(key: (KeyTypeId, D)) -> Option<Self::Proof> {
+		let session = <Session<T>>::current_index();
+		let validators = <Session<T>>::validators()
+			.into_iter()
+			.filter_map(|validator| {
+				T::FullIdentificationOf::convert(validator.clone())
+					.map(|full_id| (validator, full_id))
+			})
+			.collect::<Vec<_>>();
+
+		let count = validators.len() as ValidatorCount;
+
+		let trie = ProvingTrie::<T>::generate_for(validators).ok()?;
+
+		let (id, data) = key;
+		trie.prove(id, data.as_ref()).map(|trie_nodes| MembershipProof {
+			session,
+			trie_nodes,
+			validator_count: count,
+		})
+	}
+
+	fn check_proof(key: (KeyTypeId, D), proof: Self::Proof) -> Option<IdentificationTuple<T>> {
+		let (id, data) = key;
+
+		if proof.session == <Session<T>>::current_index() {
+			<Session<T>>::key_owner(id, data.as_ref()).and_then(|owner| {
+				T::FullIdentificationOf::convert(owner.clone()).and_then(move |id| {
+					let count = <Session<T>>::validators().len() as ValidatorCount;
+
+					if count != proof.validator_count {
+						return None
+					}
+
+					Some((owner, id))
+				})
+			})
+		} else {
+			let (root, count) = <HistoricalSessions<T>>::get(&proof.session)?;
+
+			if count != proof.validator_count {
+				return None
+			}
+
+			let trie = ProvingTrie::<T>::from_nodes(root, &proof.trie_nodes);
+			trie.query(id, data.as_ref())
+		}
+	}
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+	use super::*;
+	use crate::mock::{
+		force_new_session, set_next_validators, NextValidators, Session, System, Test,
+	};
+
+	use sp_runtime::{key_types::DUMMY, testing::UintAuthorityId, BuildStorage};
+	use sp_state_machine::BasicExternalities;
+
+	use frame_support::traits::{KeyOwnerProofSystem, OnInitialize};
+
+	type Historical = Pallet<Test>;
+
+	pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		let keys: Vec<_> = NextValidators::get()
+			.iter()
+			.cloned()
+			.map(|i| (i, i, UintAuthorityId(i).into()))
+			.collect();
+		BasicExternalities::execute_with_storage(&mut t, || {
+			for (ref k, ..) in &keys {
+				frame_system::Pallet::<Test>::inc_providers(k);
+			}
+		});
+		pallet_session::GenesisConfig::<Test> { keys }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		sp_io::TestExternalities::new(t)
+	}
+
+	#[test]
+	fn generated_proof_is_good() {
+		new_test_ext().execute_with(|| {
+			set_next_validators(vec![1, 2]);
+			force_new_session();
+
+			System::set_block_number(1);
+			Session::on_initialize(1);
+
+			let encoded_key_1 = UintAuthorityId(1).encode();
+			let proof = Historical::prove((DUMMY, &encoded_key_1[..])).unwrap();
+
+			// proof-checking in the same session is OK.
+			assert!(Historical::check_proof((DUMMY, &encoded_key_1[..]), proof.clone()).is_some());
+
+			set_next_validators(vec![1, 2, 4]);
+			force_new_session();
+
+			System::set_block_number(2);
+			Session::on_initialize(2);
+
+			assert!(Historical::historical_root(proof.session).is_some());
+			assert!(Session::current_index() > proof.session);
+
+			// proof-checking in the next session is also OK.
+			assert!(Historical::check_proof((DUMMY, &encoded_key_1[..]), proof.clone()).is_some());
+
+			set_next_validators(vec![1, 2, 5]);
+
+			force_new_session();
+			System::set_block_number(3);
+			Session::on_initialize(3);
+		});
+	}
+
+	#[test]
+	fn prune_up_to_works() {
+		new_test_ext().execute_with(|| {
+			for i in 1..99u64 {
+				set_next_validators(vec![i]);
+				force_new_session();
+
+				System::set_block_number(i);
+				Session::on_initialize(i);
+			}
+
+			assert_eq!(<StoredRange<Test>>::get(), Some((0, 100)));
+
+			for i in 0..100 {
+				assert!(Historical::historical_root(i).is_some())
+			}
+
+			Historical::prune_up_to(10);
+			assert_eq!(<StoredRange<Test>>::get(), Some((10, 100)));
+
+			Historical::prune_up_to(9);
+			assert_eq!(<StoredRange<Test>>::get(), Some((10, 100)));
+
+			for i in 10..100 {
+				assert!(Historical::historical_root(i).is_some())
+			}
+
+			Historical::prune_up_to(99);
+			assert_eq!(<StoredRange<Test>>::get(), Some((99, 100)));
+
+			Historical::prune_up_to(100);
+			assert_eq!(<StoredRange<Test>>::get(), None);
+
+			for i in 99..199u64 {
+				set_next_validators(vec![i]);
+				force_new_session();
+
+				System::set_block_number(i);
+				Session::on_initialize(i);
+			}
+
+			assert_eq!(<StoredRange<Test>>::get(), Some((100, 200)));
+
+			for i in 100..200 {
+				assert!(Historical::historical_root(i).is_some())
+			}
+
+			Historical::prune_up_to(9999);
+			assert_eq!(<StoredRange<Test>>::get(), None);
+
+			for i in 100..200 {
+				assert!(Historical::historical_root(i).is_none())
+			}
+		});
+	}
+}
diff --git a/substrate/frame/session/src/historical/offchain.rs b/substrate/frame/session/src/historical/offchain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1b4d53b74b45e64e958bc2703ca8aab6297c7ef4
--- /dev/null
+++ b/substrate/frame/session/src/historical/offchain.rs
@@ -0,0 +1,262 @@
+// 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.
+
+//! Off-chain logic for creating a proof based data provided by on-chain logic.
+//!
+//! Validator-set extracting an iterator from an off-chain worker stored list containing
+//! historical validator-sets.
+//! Based on the logic of historical slashing, but the validation is done off-chain.
+//! Use [`fn store_current_session_validator_set_to_offchain()`](super::onchain) to store the
+//! required data to the offchain validator set.
+//! This is used in conjunction with [`ProvingTrie`](super::ProvingTrie) and
+//! the off-chain indexing API.
+
+use sp_runtime::{
+	offchain::storage::{MutateStorageError, StorageRetrievalError, StorageValueRef},
+	KeyTypeId,
+};
+use sp_session::MembershipProof;
+use sp_std::prelude::*;
+
+use super::{shared, Config, IdentificationTuple, ProvingTrie};
+use crate::{Pallet as SessionModule, SessionIndex};
+
+/// A set of validators, which was used for a fixed session index.
+struct ValidatorSet<T: Config> {
+	validator_set: Vec<IdentificationTuple<T>>,
+}
+
+impl<T: Config> ValidatorSet<T> {
+	/// Load the set of validators for a particular session index from the off-chain storage.
+	///
+	/// If none is found or decodable given `prefix` and `session`, it will return `None`.
+	/// Empty validator sets should only ever exist for genesis blocks.
+	pub fn load_from_offchain_db(session_index: SessionIndex) -> Option<Self> {
+		let derived_key = shared::derive_key(shared::PREFIX, session_index);
+		StorageValueRef::persistent(derived_key.as_ref())
+			.get::<Vec<(T::ValidatorId, T::FullIdentification)>>()
+			.ok()
+			.flatten()
+			.map(|validator_set| Self { validator_set })
+	}
+
+	#[inline]
+	fn len(&self) -> usize {
+		self.validator_set.len()
+	}
+}
+
+/// Implement conversion into iterator for usage
+/// with [ProvingTrie](super::ProvingTrie::generate_for).
+impl<T: Config> sp_std::iter::IntoIterator for ValidatorSet<T> {
+	type Item = (T::ValidatorId, T::FullIdentification);
+	type IntoIter = sp_std::vec::IntoIter<Self::Item>;
+	fn into_iter(self) -> Self::IntoIter {
+		self.validator_set.into_iter()
+	}
+}
+
+/// Create a proof based on the data available in the off-chain database.
+///
+/// Based on the yielded `MembershipProof` the implementer may decide what
+/// to do, i.e. in case of a failed proof, enqueue a transaction back on
+/// chain reflecting that, with all its consequences such as i.e. slashing.
+pub fn prove_session_membership<T: Config, D: AsRef<[u8]>>(
+	session_index: SessionIndex,
+	session_key: (KeyTypeId, D),
+) -> Option<MembershipProof> {
+	let validators = ValidatorSet::<T>::load_from_offchain_db(session_index)?;
+	let count = validators.len() as u32;
+	let trie = ProvingTrie::<T>::generate_for(validators.into_iter()).ok()?;
+
+	let (id, data) = session_key;
+	trie.prove(id, data.as_ref()).map(|trie_nodes| MembershipProof {
+		session: session_index,
+		trie_nodes,
+		validator_count: count,
+	})
+}
+
+/// Attempt to prune anything that is older than `first_to_keep` session index.
+///
+/// Due to re-organisation it could be that the `first_to_keep` might be less
+/// than the stored one, in which case the conservative choice is made to keep records
+/// up to the one that is the lesser.
+pub fn prune_older_than<T: Config>(first_to_keep: SessionIndex) {
+	let derived_key = shared::LAST_PRUNE.to_vec();
+	let entry = StorageValueRef::persistent(derived_key.as_ref());
+	match entry.mutate(
+		|current: Result<Option<SessionIndex>, StorageRetrievalError>| -> Result<_, ()> {
+			match current {
+				Ok(Some(current)) if current < first_to_keep => Ok(first_to_keep),
+				// do not move the cursor, if the new one would be behind ours
+				Ok(Some(current)) => Ok(current),
+				Ok(None) => Ok(first_to_keep),
+				// if the storage contains undecodable data, overwrite with current anyways
+				// which might leak some entries being never purged, but that is acceptable
+				// in this context
+				Err(_) => Ok(first_to_keep),
+			}
+		},
+	) {
+		Ok(new_value) => {
+			// on a re-org this is not necessarily true, with the above they might be equal
+			if new_value < first_to_keep {
+				for session_index in new_value..first_to_keep {
+					let derived_key = shared::derive_key(shared::PREFIX, session_index);
+					let _ = StorageValueRef::persistent(derived_key.as_ref()).clear();
+				}
+			}
+		},
+		Err(MutateStorageError::ConcurrentModification(_)) => {},
+		Err(MutateStorageError::ValueFunctionFailed(_)) => {},
+	}
+}
+
+/// Keep the newest `n` items, and prune all items older than that.
+pub fn keep_newest<T: Config>(n_to_keep: usize) {
+	let session_index = <SessionModule<T>>::current_index();
+	let n_to_keep = n_to_keep as SessionIndex;
+	if n_to_keep < session_index {
+		prune_older_than::<T>(session_index - n_to_keep)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		historical::{onchain, Pallet},
+		mock::{force_new_session, set_next_validators, NextValidators, Session, System, Test},
+	};
+
+	use codec::Encode;
+	use sp_core::{
+		crypto::key_types::DUMMY,
+		offchain::{testing::TestOffchainExt, OffchainDbExt, OffchainWorkerExt, StorageKind},
+	};
+	use sp_runtime::{testing::UintAuthorityId, BuildStorage};
+	use sp_state_machine::BasicExternalities;
+
+	use frame_support::traits::{KeyOwnerProofSystem, OnInitialize};
+
+	type Historical = Pallet<Test>;
+
+	pub fn new_test_ext() -> sp_io::TestExternalities {
+		let mut t = frame_system::GenesisConfig::<Test>::default()
+			.build_storage()
+			.expect("Failed to create test externalities.");
+
+		let keys: Vec<_> = NextValidators::get()
+			.iter()
+			.cloned()
+			.map(|i| (i, i, UintAuthorityId(i).into()))
+			.collect();
+
+		BasicExternalities::execute_with_storage(&mut t, || {
+			for (ref k, ..) in &keys {
+				frame_system::Pallet::<Test>::inc_providers(k);
+			}
+		});
+
+		crate::GenesisConfig::<Test> { keys }.assimilate_storage(&mut t).unwrap();
+
+		let mut ext = sp_io::TestExternalities::new(t);
+
+		let (offchain, offchain_state) = TestOffchainExt::with_offchain_db(ext.offchain_db());
+
+		const ITERATIONS: u32 = 5u32;
+		let mut seed = [0u8; 32];
+		seed[0..4].copy_from_slice(&ITERATIONS.to_le_bytes());
+		offchain_state.write().seed = seed;
+
+		ext.register_extension(OffchainDbExt::new(offchain.clone()));
+		ext.register_extension(OffchainWorkerExt::new(offchain));
+		ext
+	}
+
+	#[test]
+	fn encode_decode_roundtrip() {
+		use super::super::{super::Config as SessionConfig, Config as HistoricalConfig};
+		use codec::{Decode, Encode};
+
+		let sample = (
+			22u32 as <Test as SessionConfig>::ValidatorId,
+			7_777_777 as <Test as HistoricalConfig>::FullIdentification,
+		);
+
+		let encoded = sample.encode();
+		let decoded = Decode::decode(&mut encoded.as_slice()).expect("Must decode");
+		assert_eq!(sample, decoded);
+	}
+
+	#[test]
+	fn onchain_to_offchain() {
+		let mut ext = new_test_ext();
+
+		const DATA: &[u8] = &[7, 8, 9, 10, 11];
+		ext.execute_with(|| {
+			b"alphaomega"[..].using_encoded(|key| sp_io::offchain_index::set(key, DATA));
+		});
+
+		ext.persist_offchain_overlay();
+
+		ext.execute_with(|| {
+			let data = b"alphaomega"[..].using_encoded(|key| {
+				sp_io::offchain::local_storage_get(StorageKind::PERSISTENT, key)
+			});
+			assert_eq!(data, Some(DATA.to_vec()));
+		});
+	}
+
+	#[test]
+	fn historical_proof_offchain() {
+		let mut ext = new_test_ext();
+		let encoded_key_1 = UintAuthorityId(1).encode();
+
+		ext.execute_with(|| {
+			set_next_validators(vec![1, 2]);
+			force_new_session();
+
+			System::set_block_number(1);
+			Session::on_initialize(1);
+
+			// "on-chain"
+			onchain::store_current_session_validator_set_to_offchain::<Test>();
+			assert_eq!(<SessionModule<Test>>::current_index(), 1);
+
+			set_next_validators(vec![7, 8]);
+
+			force_new_session();
+		});
+
+		ext.persist_offchain_overlay();
+
+		ext.execute_with(|| {
+			System::set_block_number(2);
+			Session::on_initialize(2);
+			assert_eq!(<SessionModule<Test>>::current_index(), 2);
+
+			// "off-chain"
+			let proof = prove_session_membership::<Test, _>(1, (DUMMY, &encoded_key_1));
+			assert!(proof.is_some());
+			let proof = proof.expect("Must be Some(Proof)");
+
+			assert!(Historical::check_proof((DUMMY, &encoded_key_1[..]), proof.clone()).is_some());
+		});
+	}
+}
diff --git a/substrate/frame/session/src/historical/onchain.rs b/substrate/frame/session/src/historical/onchain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..97a7f02bd096e2ab65d2b0afa2e2004eec56ca8e
--- /dev/null
+++ b/substrate/frame/session/src/historical/onchain.rs
@@ -0,0 +1,59 @@
+// 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.
+
+//! On-chain logic to store a validator-set for deferred validation using an off-chain worker.
+
+use codec::Encode;
+use sp_runtime::traits::Convert;
+use sp_std::prelude::*;
+
+use super::{shared, Config as HistoricalConfig};
+use crate::{Config as SessionConfig, Pallet as SessionModule, SessionIndex};
+
+/// Store the validator-set associated to the `session_index` to the off-chain database.
+///
+/// Further processing is then done [`off-chain side`](super::offchain).
+///
+/// **Must** be called from on-chain, i.e. a call that originates from
+/// `on_initialize(..)` or `on_finalization(..)`.
+/// **Must** be called during the session, which validator-set is to be stored for further
+/// off-chain processing. Otherwise the `FullIdentification` might not be available.
+pub fn store_session_validator_set_to_offchain<T: HistoricalConfig + SessionConfig>(
+	session_index: SessionIndex,
+) {
+	let encoded_validator_list = <SessionModule<T>>::validators()
+		.into_iter()
+		.filter_map(|validator_id: <T as SessionConfig>::ValidatorId| {
+			let full_identification =
+				<<T as HistoricalConfig>::FullIdentificationOf>::convert(validator_id.clone());
+			full_identification.map(|full_identification| (validator_id, full_identification))
+		})
+		.collect::<Vec<_>>();
+
+	encoded_validator_list.using_encoded(|encoded_validator_list| {
+		let derived_key = shared::derive_key(shared::PREFIX, session_index);
+		sp_io::offchain_index::set(derived_key.as_slice(), encoded_validator_list);
+	});
+}
+
+/// Store the validator set associated to the _current_ session index to the off-chain database.
+///
+/// See [`store_session_validator_set_to_offchain`]
+/// for further information and restrictions.
+pub fn store_current_session_validator_set_to_offchain<T: HistoricalConfig + SessionConfig>() {
+	store_session_validator_set_to_offchain::<T>(<SessionModule<T>>::current_index());
+}
diff --git a/substrate/frame/session/src/historical/shared.rs b/substrate/frame/session/src/historical/shared.rs
new file mode 100644
index 0000000000000000000000000000000000000000..297385dfb426e5026cae9db478a074070019501d
--- /dev/null
+++ b/substrate/frame/session/src/historical/shared.rs
@@ -0,0 +1,36 @@
+// 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.
+
+//! Shared logic between on-chain and off-chain components used for slashing using an off-chain
+//! worker.
+
+use codec::Encode;
+use sp_staking::SessionIndex;
+use sp_std::prelude::*;
+
+pub(super) const PREFIX: &[u8] = b"session_historical";
+pub(super) const LAST_PRUNE: &[u8] = b"session_historical_last_prune";
+
+/// Derive the key used to store the list of validators
+pub(super) fn derive_key<P: AsRef<[u8]>>(prefix: P, session_index: SessionIndex) -> Vec<u8> {
+	session_index.using_encoded(|encoded_session_index| {
+		let mut key = prefix.as_ref().to_owned();
+		key.push(b'/');
+		key.extend_from_slice(encoded_session_index);
+		key
+	})
+}
diff --git a/substrate/frame/session/src/lib.rs b/substrate/frame/session/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1c0093c1df64f36aaee8f8a188f7acef9ba7acce
--- /dev/null
+++ b/substrate/frame/session/src/lib.rs
@@ -0,0 +1,940 @@
+// 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.
+
+//! # Session Pallet
+//!
+//! The Session pallet allows validators to manage their session keys, provides a function for
+//! changing the session length, and handles session rotation.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! ### Terminology
+//! <!-- Original author of paragraph: @gavofyork -->
+//!
+//! - **Session:** A session is a period of time that has a constant set of validators. Validators
+//!   can only join or exit the validator set at a session change. It is measured in block numbers.
+//!   The block where a session is ended is determined by the `ShouldEndSession` trait. When the
+//!   session is ending, a new validator set can be chosen by `OnSessionEnding` implementations.
+//!
+//! - **Session key:** A session key is actually several keys kept together that provide the various
+//!   signing functions required by network authorities/validators in pursuit of their duties.
+//! - **Validator ID:** Every account has an associated validator ID. For some simple staking
+//!   systems, this may just be the same as the account ID. For staking systems using a
+//!   stash/controller model, the validator ID would be the stash account ID of the controller.
+//!
+//! - **Session key configuration process:** Session keys are set using `set_keys` for use not in
+//!   the next session, but the session after next. They are stored in `NextKeys`, a mapping between
+//!   the caller's `ValidatorId` and the session keys provided. `set_keys` allows users to set their
+//!   session key prior to being selected as validator. It is a public call since it uses
+//!   `ensure_signed`, which checks that the origin is a signed account. As such, the account ID of
+//!   the origin stored in `NextKeys` may not necessarily be associated with a block author or a
+//!   validator. The session keys of accounts are removed once their account balance is zero.
+//!
+//! - **Session length:** This pallet does not assume anything about the length of each session.
+//!   Rather, it relies on an implementation of `ShouldEndSession` to dictate a new session's start.
+//!   This pallet provides the `PeriodicSessions` struct for simple periodic sessions.
+//!
+//! - **Session rotation configuration:** Configure as either a 'normal' (rewardable session where
+//!   rewards are applied) or 'exceptional' (slashable) session rotation.
+//!
+//! - **Session rotation process:** At the beginning of each block, the `on_initialize` function
+//!   queries the provided implementation of `ShouldEndSession`. If the session is to end the newly
+//!   activated validator IDs and session keys are taken from storage and passed to the
+//!   `SessionHandler`. The validator set supplied by `SessionManager::new_session` and the
+//!   corresponding session keys, which may have been registered via `set_keys` during the previous
+//!   session, are written to storage where they will wait one session before being passed to the
+//!   `SessionHandler` themselves.
+//!
+//! ### Goals
+//!
+//! The Session pallet is designed to make the following possible:
+//!
+//! - Set session keys of the validator set for upcoming sessions.
+//! - Control the length of sessions.
+//! - Configure and switch between either normal or exceptional session rotations.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! - `set_keys` - Set a validator's session keys for upcoming sessions.
+//!
+//! ### Public Functions
+//!
+//! - `rotate_session` - Change to the next session. Register the new authority set. Queue changes
+//!   for next session rotation.
+//! - `disable_index` - Disable a validator by index.
+//! - `disable` - Disable a validator by Validator ID
+//!
+//! ## Usage
+//!
+//! ### Example from the FRAME
+//!
+//! The [Staking pallet](../pallet_staking/index.html) uses the Session pallet to get the validator
+//! set.
+//!
+//! ```
+//! use pallet_session as session;
+//!
+//! fn validators<T: pallet_session::Config>() -> Vec<<T as pallet_session::Config>::ValidatorId> {
+//! 	<pallet_session::Pallet<T>>::validators()
+//! }
+//! # fn main(){}
+//! ```
+//!
+//! ## Related Pallets
+//!
+//! - [Staking](../pallet_staking/index.html)
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "historical")]
+pub mod historical;
+pub mod migrations;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use codec::{Decode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{DispatchError, DispatchResult},
+	ensure,
+	traits::{
+		EstimateNextNewSession, EstimateNextSessionRotation, FindAuthor, Get, OneSessionHandler,
+		ValidatorRegistration, ValidatorSet,
+	},
+	weights::Weight,
+	Parameter,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_runtime::{
+	traits::{AtLeast32BitUnsigned, Convert, Member, One, OpaqueKeys, Zero},
+	ConsensusEngineId, KeyTypeId, Permill, RuntimeAppPublic,
+};
+use sp_staking::SessionIndex;
+use sp_std::{
+	marker::PhantomData,
+	ops::{Rem, Sub},
+	prelude::*,
+};
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// Decides whether the session should be ended.
+pub trait ShouldEndSession<BlockNumber> {
+	/// Return `true` if the session should be ended.
+	fn should_end_session(now: BlockNumber) -> bool;
+}
+
+/// Ends the session after a fixed period of blocks.
+///
+/// The first session will have length of `Offset`, and
+/// the following sessions will have length of `Period`.
+/// This may prove nonsensical if `Offset` >= `Period`.
+pub struct PeriodicSessions<Period, Offset>(PhantomData<(Period, Offset)>);
+
+impl<
+		BlockNumber: Rem<Output = BlockNumber> + Sub<Output = BlockNumber> + Zero + PartialOrd,
+		Period: Get<BlockNumber>,
+		Offset: Get<BlockNumber>,
+	> ShouldEndSession<BlockNumber> for PeriodicSessions<Period, Offset>
+{
+	fn should_end_session(now: BlockNumber) -> bool {
+		let offset = Offset::get();
+		now >= offset && ((now - offset) % Period::get()).is_zero()
+	}
+}
+
+impl<
+		BlockNumber: AtLeast32BitUnsigned + Clone,
+		Period: Get<BlockNumber>,
+		Offset: Get<BlockNumber>,
+	> EstimateNextSessionRotation<BlockNumber> for PeriodicSessions<Period, Offset>
+{
+	fn average_session_length() -> BlockNumber {
+		Period::get()
+	}
+
+	fn estimate_current_session_progress(now: BlockNumber) -> (Option<Permill>, Weight) {
+		let offset = Offset::get();
+		let period = Period::get();
+
+		// NOTE: we add one since we assume that the current block has already elapsed,
+		// i.e. when evaluating the last block in the session the progress should be 100%
+		// (0% is never returned).
+		let progress = if now >= offset {
+			let current = (now - offset) % period.clone() + One::one();
+			Some(Permill::from_rational(current, period))
+		} else {
+			Some(Permill::from_rational(now + One::one(), offset))
+		};
+
+		// Weight note: `estimate_current_session_progress` has no storage reads and trivial
+		// computational overhead. There should be no risk to the chain having this weight value be
+		// zero for now. However, this value of zero was not properly calculated, and so it would be
+		// reasonable to come back here and properly calculate the weight of this function.
+		(progress, Zero::zero())
+	}
+
+	fn estimate_next_session_rotation(now: BlockNumber) -> (Option<BlockNumber>, Weight) {
+		let offset = Offset::get();
+		let period = Period::get();
+
+		let next_session = if now > offset {
+			let block_after_last_session = (now.clone() - offset) % period.clone();
+			if block_after_last_session > Zero::zero() {
+				now.saturating_add(period.saturating_sub(block_after_last_session))
+			} else {
+				// this branch happens when the session is already rotated or will rotate in this
+				// block (depending on being called before or after `session::on_initialize`). Here,
+				// we assume the latter, namely that this is called after `session::on_initialize`,
+				// and thus we add period to it as well.
+				now + period
+			}
+		} else {
+			offset
+		};
+
+		// Weight note: `estimate_next_session_rotation` has no storage reads and trivial
+		// computational overhead. There should be no risk to the chain having this weight value be
+		// zero for now. However, this value of zero was not properly calculated, and so it would be
+		// reasonable to come back here and properly calculate the weight of this function.
+		(Some(next_session), Zero::zero())
+	}
+}
+
+/// A trait for managing creation of new validator set.
+pub trait SessionManager<ValidatorId> {
+	/// Plan a new session, and optionally provide the new validator set.
+	///
+	/// Even if the validator-set is the same as before, if any underlying economic conditions have
+	/// changed (i.e. stake-weights), the new validator set must be returned. This is necessary for
+	/// consensus engines making use of the session pallet to issue a validator-set change so
+	/// misbehavior can be provably associated with the new economic conditions as opposed to the
+	/// old. The returned validator set, if any, will not be applied until `new_index`. `new_index`
+	/// is strictly greater than from previous call.
+	///
+	/// The first session start at index 0.
+	///
+	/// `new_session(session)` is guaranteed to be called before `end_session(session-1)`. In other
+	/// words, a new session must always be planned before an ongoing one can be finished.
+	fn new_session(new_index: SessionIndex) -> Option<Vec<ValidatorId>>;
+	/// Same as `new_session`, but it this should only be called at genesis.
+	///
+	/// The session manager might decide to treat this in a different way. Default impl is simply
+	/// using [`new_session`](Self::new_session).
+	fn new_session_genesis(new_index: SessionIndex) -> Option<Vec<ValidatorId>> {
+		Self::new_session(new_index)
+	}
+	/// End the session.
+	///
+	/// Because the session pallet can queue validator set the ending session can be lower than the
+	/// last new session index.
+	fn end_session(end_index: SessionIndex);
+	/// Start an already planned session.
+	///
+	/// The session start to be used for validation.
+	fn start_session(start_index: SessionIndex);
+}
+
+impl<A> SessionManager<A> for () {
+	fn new_session(_: SessionIndex) -> Option<Vec<A>> {
+		None
+	}
+	fn start_session(_: SessionIndex) {}
+	fn end_session(_: SessionIndex) {}
+}
+
+/// Handler for session life cycle events.
+pub trait SessionHandler<ValidatorId> {
+	/// All the key type ids this session handler can process.
+	///
+	/// The order must be the same as it expects them in
+	/// [`on_new_session`](Self::on_new_session<Ks>) and
+	/// [`on_genesis_session`](Self::on_genesis_session<Ks>).
+	const KEY_TYPE_IDS: &'static [KeyTypeId];
+
+	/// The given validator set will be used for the genesis session.
+	/// It is guaranteed that the given validator set will also be used
+	/// for the second session, therefore the first call to `on_new_session`
+	/// should provide the same validator set.
+	fn on_genesis_session<Ks: OpaqueKeys>(validators: &[(ValidatorId, Ks)]);
+
+	/// Session set has changed; act appropriately. Note that this can be called
+	/// before initialization of your pallet.
+	///
+	/// `changed` is true whenever any of the session keys or underlying economic
+	/// identities or weightings behind those keys has changed.
+	fn on_new_session<Ks: OpaqueKeys>(
+		changed: bool,
+		validators: &[(ValidatorId, Ks)],
+		queued_validators: &[(ValidatorId, Ks)],
+	);
+
+	/// A notification for end of the session.
+	///
+	/// Note it is triggered before any [`SessionManager::end_session`] handlers,
+	/// so we can still affect the validator set.
+	fn on_before_session_ending() {}
+
+	/// A validator got disabled. Act accordingly until a new session begins.
+	fn on_disabled(validator_index: u32);
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(1, 30)]
+#[tuple_types_custom_trait_bound(OneSessionHandler<AId>)]
+impl<AId> SessionHandler<AId> for Tuple {
+	for_tuples!(
+		const KEY_TYPE_IDS: &'static [KeyTypeId] = &[ #( <Tuple::Key as RuntimeAppPublic>::ID ),* ];
+	);
+
+	fn on_genesis_session<Ks: OpaqueKeys>(validators: &[(AId, Ks)]) {
+		for_tuples!(
+			#(
+				let our_keys: Box<dyn Iterator<Item=_>> = Box::new(validators.iter()
+					.filter_map(|k|
+						k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID).map(|k1| (&k.0, k1))
+					)
+				);
+
+				Tuple::on_genesis_session(our_keys);
+			)*
+		)
+	}
+
+	fn on_new_session<Ks: OpaqueKeys>(
+		changed: bool,
+		validators: &[(AId, Ks)],
+		queued_validators: &[(AId, Ks)],
+	) {
+		for_tuples!(
+			#(
+				let our_keys: Box<dyn Iterator<Item=_>> = Box::new(validators.iter()
+					.filter_map(|k|
+						k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID).map(|k1| (&k.0, k1))
+					));
+				let queued_keys: Box<dyn Iterator<Item=_>> = Box::new(queued_validators.iter()
+					.filter_map(|k|
+						k.1.get::<Tuple::Key>(<Tuple::Key as RuntimeAppPublic>::ID).map(|k1| (&k.0, k1))
+					));
+				Tuple::on_new_session(changed, our_keys, queued_keys);
+			)*
+		)
+	}
+
+	fn on_before_session_ending() {
+		for_tuples!( #( Tuple::on_before_session_ending(); )* )
+	}
+
+	fn on_disabled(i: u32) {
+		for_tuples!( #( Tuple::on_disabled(i); )* )
+	}
+}
+
+/// `SessionHandler` for tests that use `UintAuthorityId` as `Keys`.
+pub struct TestSessionHandler;
+impl<AId> SessionHandler<AId> for TestSessionHandler {
+	const KEY_TYPE_IDS: &'static [KeyTypeId] = &[sp_runtime::key_types::DUMMY];
+	fn on_genesis_session<Ks: OpaqueKeys>(_: &[(AId, Ks)]) {}
+	fn on_new_session<Ks: OpaqueKeys>(_: bool, _: &[(AId, Ks)], _: &[(AId, Ks)]) {}
+	fn on_before_session_ending() {}
+	fn on_disabled(_: u32) {}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// A stable ID for a validator.
+		type ValidatorId: Member
+			+ Parameter
+			+ MaybeSerializeDeserialize
+			+ MaxEncodedLen
+			+ TryFrom<Self::AccountId>;
+
+		/// A conversion from account ID to validator ID.
+		///
+		/// Its cost must be at most one storage read.
+		type ValidatorIdOf: Convert<Self::AccountId, Option<Self::ValidatorId>>;
+
+		/// Indicator for when to end the session.
+		type ShouldEndSession: ShouldEndSession<BlockNumberFor<Self>>;
+
+		/// Something that can predict the next session rotation. This should typically come from
+		/// the same logical unit that provides [`ShouldEndSession`], yet, it gives a best effort
+		/// estimate. It is helpful to implement [`EstimateNextNewSession`].
+		type NextSessionRotation: EstimateNextSessionRotation<BlockNumberFor<Self>>;
+
+		/// Handler for managing new session.
+		type SessionManager: SessionManager<Self::ValidatorId>;
+
+		/// Handler when a session has changed.
+		type SessionHandler: SessionHandler<Self::ValidatorId>;
+
+		/// The keys.
+		type Keys: OpaqueKeys + Member + Parameter + MaybeSerializeDeserialize;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub keys: Vec<(T::AccountId, T::ValidatorId, T::Keys)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			if T::SessionHandler::KEY_TYPE_IDS.len() != T::Keys::key_ids().len() {
+				panic!("Number of keys in session handler and session keys does not match");
+			}
+
+			T::SessionHandler::KEY_TYPE_IDS
+				.iter()
+				.zip(T::Keys::key_ids())
+				.enumerate()
+				.for_each(|(i, (sk, kk))| {
+					if sk != kk {
+						panic!(
+							"Session handler and session key expect different key type at index: {}",
+							i,
+						);
+					}
+				});
+
+			for (account, val, keys) in self.keys.iter().cloned() {
+				<Pallet<T>>::inner_set_keys(&val, keys)
+					.expect("genesis config must not contain duplicates; qed");
+				if frame_system::Pallet::<T>::inc_consumers_without_limit(&account).is_err() {
+					// This will leak a provider reference, however it only happens once (at
+					// genesis) so it's really not a big deal and we assume that the user wants to
+					// do this since it's the only way a non-endowed account can contain a session
+					// key.
+					frame_system::Pallet::<T>::inc_providers(&account);
+				}
+			}
+
+			let initial_validators_0 =
+				T::SessionManager::new_session_genesis(0).unwrap_or_else(|| {
+					frame_support::print(
+						"No initial validator provided by `SessionManager`, use \
+						session config keys to generate initial validator set.",
+					);
+					self.keys.iter().map(|x| x.1.clone()).collect()
+				});
+			assert!(
+				!initial_validators_0.is_empty(),
+				"Empty validator set for session 0 in genesis block!"
+			);
+
+			let initial_validators_1 = T::SessionManager::new_session_genesis(1)
+				.unwrap_or_else(|| initial_validators_0.clone());
+			assert!(
+				!initial_validators_1.is_empty(),
+				"Empty validator set for session 1 in genesis block!"
+			);
+
+			let queued_keys: Vec<_> = initial_validators_1
+				.iter()
+				.cloned()
+				.map(|v| {
+					(
+						v.clone(),
+						Pallet::<T>::load_keys(&v).expect("Validator in session 1 missing keys!"),
+					)
+				})
+				.collect();
+
+			// Tell everyone about the genesis session keys
+			T::SessionHandler::on_genesis_session::<T::Keys>(&queued_keys);
+
+			Validators::<T>::put(initial_validators_0);
+			<QueuedKeys<T>>::put(queued_keys);
+
+			T::SessionManager::start_session(0);
+		}
+	}
+
+	/// The current set of validators.
+	#[pallet::storage]
+	#[pallet::getter(fn validators)]
+	pub type Validators<T: Config> = StorageValue<_, Vec<T::ValidatorId>, ValueQuery>;
+
+	/// Current index of the session.
+	#[pallet::storage]
+	#[pallet::getter(fn current_index)]
+	pub type CurrentIndex<T> = StorageValue<_, SessionIndex, ValueQuery>;
+
+	/// True if the underlying economic identities or weighting behind the validators
+	/// has changed in the queued validator set.
+	#[pallet::storage]
+	pub type QueuedChanged<T> = StorageValue<_, bool, ValueQuery>;
+
+	/// The queued keys for the next session. When the next session begins, these keys
+	/// will be used to determine the validator's session keys.
+	#[pallet::storage]
+	#[pallet::getter(fn queued_keys)]
+	pub type QueuedKeys<T: Config> = StorageValue<_, Vec<(T::ValidatorId, T::Keys)>, ValueQuery>;
+
+	/// Indices of disabled validators.
+	///
+	/// The vec is always kept sorted so that we can find whether a given validator is
+	/// disabled using binary search. It gets cleared when `on_session_ending` returns
+	/// a new set of identities.
+	#[pallet::storage]
+	#[pallet::getter(fn disabled_validators)]
+	pub type DisabledValidators<T> = StorageValue<_, Vec<u32>, ValueQuery>;
+
+	/// The next session keys for a validator.
+	#[pallet::storage]
+	pub type NextKeys<T: Config> =
+		StorageMap<_, Twox64Concat, T::ValidatorId, T::Keys, OptionQuery>;
+
+	/// The owner of a key. The key is the `KeyTypeId` + the encoded key.
+	#[pallet::storage]
+	pub type KeyOwner<T: Config> =
+		StorageMap<_, Twox64Concat, (KeyTypeId, Vec<u8>), T::ValidatorId, OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event {
+		/// New session has happened. Note that the argument is the session index, not the
+		/// block number as the type might suggest.
+		NewSession { session_index: SessionIndex },
+	}
+
+	/// Error for the session pallet.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Invalid ownership proof.
+		InvalidProof,
+		/// No associated validator ID for account.
+		NoAssociatedValidatorId,
+		/// Registered duplicate key.
+		DuplicatedKey,
+		/// No keys are associated with this account.
+		NoKeys,
+		/// Key setting account is not live, so it's impossible to associate keys.
+		NoAccount,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// Called when a block is initialized. Will rotate session if it is the last
+		/// block of the current session.
+		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+			if T::ShouldEndSession::should_end_session(n) {
+				Self::rotate_session();
+				T::BlockWeights::get().max_block
+			} else {
+				// NOTE: the non-database part of the weight for `should_end_session(n)` is
+				// included as weight for empty block, the database part is expected to be in
+				// cache.
+				Weight::zero()
+			}
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Sets the session key(s) of the function caller to `keys`.
+		/// Allows an account to set its session key prior to becoming a validator.
+		/// This doesn't take effect until the next session.
+		///
+		/// The dispatch origin of this function must be signed.
+		///
+		/// ## Complexity
+		/// - `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is
+		///   fixed.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::set_keys())]
+		pub fn set_keys(origin: OriginFor<T>, keys: T::Keys, proof: Vec<u8>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			ensure!(keys.ownership_proof_is_valid(&proof), Error::<T>::InvalidProof);
+
+			Self::do_set_keys(&who, keys)?;
+			Ok(())
+		}
+
+		/// Removes any session key(s) of the function caller.
+		///
+		/// This doesn't take effect until the next session.
+		///
+		/// The dispatch origin of this function must be Signed and the account must be either be
+		/// convertible to a validator ID using the chain's typical addressing system (this usually
+		/// means being a controller account) or directly convertible into a validator ID (which
+		/// usually means being a stash account).
+		///
+		/// ## Complexity
+		/// - `O(1)` in number of key types. Actual cost depends on the number of length of
+		///   `T::Keys::key_ids()` which is fixed.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::purge_keys())]
+		pub fn purge_keys(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_purge_keys(&who)?;
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Move on to next session. Register new validator set and session keys. Changes to the
+	/// validator set have a session of delay to take effect. This allows for equivocation
+	/// punishment after a fork.
+	pub fn rotate_session() {
+		let session_index = <CurrentIndex<T>>::get();
+		log::trace!(target: "runtime::session", "rotating session {:?}", session_index);
+
+		let changed = <QueuedChanged<T>>::get();
+
+		// Inform the session handlers that a session is going to end.
+		T::SessionHandler::on_before_session_ending();
+		T::SessionManager::end_session(session_index);
+
+		// Get queued session keys and validators.
+		let session_keys = <QueuedKeys<T>>::get();
+		let validators =
+			session_keys.iter().map(|(validator, _)| validator.clone()).collect::<Vec<_>>();
+		Validators::<T>::put(&validators);
+
+		if changed {
+			// reset disabled validators
+			<DisabledValidators<T>>::take();
+		}
+
+		// Increment session index.
+		let session_index = session_index + 1;
+		<CurrentIndex<T>>::put(session_index);
+
+		T::SessionManager::start_session(session_index);
+
+		// Get next validator set.
+		let maybe_next_validators = T::SessionManager::new_session(session_index + 1);
+		let (next_validators, next_identities_changed) =
+			if let Some(validators) = maybe_next_validators {
+				// NOTE: as per the documentation on `OnSessionEnding`, we consider
+				// the validator set as having changed even if the validators are the
+				// same as before, as underlying economic conditions may have changed.
+				(validators, true)
+			} else {
+				(Validators::<T>::get(), false)
+			};
+
+		// Queue next session keys.
+		let (queued_amalgamated, next_changed) = {
+			// until we are certain there has been a change, iterate the prior
+			// validators along with the current and check for changes
+			let mut changed = next_identities_changed;
+
+			let mut now_session_keys = session_keys.iter();
+			let mut check_next_changed = |keys: &T::Keys| {
+				if changed {
+					return
+				}
+				// since a new validator set always leads to `changed` starting
+				// as true, we can ensure that `now_session_keys` and `next_validators`
+				// have the same length. this function is called once per iteration.
+				if let Some((_, old_keys)) = now_session_keys.next() {
+					if old_keys != keys {
+						changed = true;
+					}
+				}
+			};
+			let queued_amalgamated = next_validators
+				.into_iter()
+				.filter_map(|a| {
+					let k = Self::load_keys(&a)?;
+					check_next_changed(&k);
+					Some((a, k))
+				})
+				.collect::<Vec<_>>();
+
+			(queued_amalgamated, changed)
+		};
+
+		<QueuedKeys<T>>::put(queued_amalgamated.clone());
+		<QueuedChanged<T>>::put(next_changed);
+
+		// Record that this happened.
+		Self::deposit_event(Event::NewSession { session_index });
+
+		// Tell everyone about the new session keys.
+		T::SessionHandler::on_new_session::<T::Keys>(changed, &session_keys, &queued_amalgamated);
+	}
+
+	/// Disable the validator of index `i`, returns `false` if the validator was already disabled.
+	pub fn disable_index(i: u32) -> bool {
+		if i >= Validators::<T>::decode_len().unwrap_or(0) as u32 {
+			return false
+		}
+
+		<DisabledValidators<T>>::mutate(|disabled| {
+			if let Err(index) = disabled.binary_search(&i) {
+				disabled.insert(index, i);
+				T::SessionHandler::on_disabled(i);
+				return true
+			}
+
+			false
+		})
+	}
+
+	/// Disable the validator identified by `c`. (If using with the staking pallet,
+	/// this would be their *stash* account.)
+	///
+	/// Returns `false` either if the validator could not be found or it was already
+	/// disabled.
+	pub fn disable(c: &T::ValidatorId) -> bool {
+		Self::validators()
+			.iter()
+			.position(|i| i == c)
+			.map(|i| Self::disable_index(i as u32))
+			.unwrap_or(false)
+	}
+
+	/// Upgrade the key type from some old type to a new type. Supports adding
+	/// and removing key types.
+	///
+	/// This function should be used with extreme care and only during an
+	/// `on_runtime_upgrade` block. Misuse of this function can put your blockchain
+	/// into an unrecoverable state.
+	///
+	/// Care should be taken that the raw versions of the
+	/// added keys are unique for every `ValidatorId, KeyTypeId` combination.
+	/// This is an invariant that the session pallet typically maintains internally.
+	///
+	/// As the actual values of the keys are typically not known at runtime upgrade,
+	/// it's recommended to initialize the keys to a (unique) dummy value with the expectation
+	/// that all validators should invoke `set_keys` before those keys are actually
+	/// required.
+	pub fn upgrade_keys<Old, F>(upgrade: F)
+	where
+		Old: OpaqueKeys + Member + Decode,
+		F: Fn(T::ValidatorId, Old) -> T::Keys,
+	{
+		let old_ids = Old::key_ids();
+		let new_ids = T::Keys::key_ids();
+
+		// Translate NextKeys, and key ownership relations at the same time.
+		<NextKeys<T>>::translate::<Old, _>(|val, old_keys| {
+			// Clear all key ownership relations. Typically the overlap should
+			// stay the same, but no guarantees by the upgrade function.
+			for i in old_ids.iter() {
+				Self::clear_key_owner(*i, old_keys.get_raw(*i));
+			}
+
+			let new_keys = upgrade(val.clone(), old_keys);
+
+			// And now set the new ones.
+			for i in new_ids.iter() {
+				Self::put_key_owner(*i, new_keys.get_raw(*i), &val);
+			}
+
+			Some(new_keys)
+		});
+
+		let _ = <QueuedKeys<T>>::translate::<Vec<(T::ValidatorId, Old)>, _>(|k| {
+			k.map(|k| {
+				k.into_iter()
+					.map(|(val, old_keys)| (val.clone(), upgrade(val, old_keys)))
+					.collect::<Vec<_>>()
+			})
+		});
+	}
+
+	/// Perform the set_key operation, checking for duplicates. Does not set `Changed`.
+	///
+	/// This ensures that the reference counter in system is incremented appropriately and as such
+	/// must accept an account ID, rather than a validator ID.
+	fn do_set_keys(account: &T::AccountId, keys: T::Keys) -> DispatchResult {
+		let who = T::ValidatorIdOf::convert(account.clone())
+			.ok_or(Error::<T>::NoAssociatedValidatorId)?;
+
+		ensure!(frame_system::Pallet::<T>::can_inc_consumer(account), Error::<T>::NoAccount);
+		let old_keys = Self::inner_set_keys(&who, keys)?;
+		if old_keys.is_none() {
+			let assertion = frame_system::Pallet::<T>::inc_consumers(account).is_ok();
+			debug_assert!(assertion, "can_inc_consumer() returned true; no change since; qed");
+		}
+
+		Ok(())
+	}
+
+	/// Perform the set_key operation, checking for duplicates. Does not set `Changed`.
+	///
+	/// The old keys for this validator are returned, or `None` if there were none.
+	///
+	/// This does not ensure that the reference counter in system is incremented appropriately, it
+	/// must be done by the caller or the keys will be leaked in storage.
+	fn inner_set_keys(
+		who: &T::ValidatorId,
+		keys: T::Keys,
+	) -> Result<Option<T::Keys>, DispatchError> {
+		let old_keys = Self::load_keys(who);
+
+		for id in T::Keys::key_ids() {
+			let key = keys.get_raw(*id);
+
+			// ensure keys are without duplication.
+			ensure!(
+				Self::key_owner(*id, key).map_or(true, |owner| &owner == who),
+				Error::<T>::DuplicatedKey,
+			);
+		}
+
+		for id in T::Keys::key_ids() {
+			let key = keys.get_raw(*id);
+
+			if let Some(old) = old_keys.as_ref().map(|k| k.get_raw(*id)) {
+				if key == old {
+					continue
+				}
+
+				Self::clear_key_owner(*id, old);
+			}
+
+			Self::put_key_owner(*id, key, who);
+		}
+
+		Self::put_keys(who, &keys);
+		Ok(old_keys)
+	}
+
+	fn do_purge_keys(account: &T::AccountId) -> DispatchResult {
+		let who = T::ValidatorIdOf::convert(account.clone())
+			// `purge_keys` may not have a controller-stash pair any more. If so then we expect the
+			// stash account to be passed in directly and convert that to a `ValidatorId` using the
+			// `TryFrom` trait if supported.
+			.or_else(|| T::ValidatorId::try_from(account.clone()).ok())
+			.ok_or(Error::<T>::NoAssociatedValidatorId)?;
+
+		let old_keys = Self::take_keys(&who).ok_or(Error::<T>::NoKeys)?;
+		for id in T::Keys::key_ids() {
+			let key_data = old_keys.get_raw(*id);
+			Self::clear_key_owner(*id, key_data);
+		}
+		frame_system::Pallet::<T>::dec_consumers(account);
+
+		Ok(())
+	}
+
+	fn load_keys(v: &T::ValidatorId) -> Option<T::Keys> {
+		<NextKeys<T>>::get(v)
+	}
+
+	fn take_keys(v: &T::ValidatorId) -> Option<T::Keys> {
+		<NextKeys<T>>::take(v)
+	}
+
+	fn put_keys(v: &T::ValidatorId, keys: &T::Keys) {
+		<NextKeys<T>>::insert(v, keys);
+	}
+
+	/// Query the owner of a session key by returning the owner's validator ID.
+	pub fn key_owner(id: KeyTypeId, key_data: &[u8]) -> Option<T::ValidatorId> {
+		<KeyOwner<T>>::get((id, key_data))
+	}
+
+	fn put_key_owner(id: KeyTypeId, key_data: &[u8], v: &T::ValidatorId) {
+		<KeyOwner<T>>::insert((id, key_data), v)
+	}
+
+	fn clear_key_owner(id: KeyTypeId, key_data: &[u8]) {
+		<KeyOwner<T>>::remove((id, key_data));
+	}
+}
+
+impl<T: Config> ValidatorRegistration<T::ValidatorId> for Pallet<T> {
+	fn is_registered(id: &T::ValidatorId) -> bool {
+		Self::load_keys(id).is_some()
+	}
+}
+
+impl<T: Config> ValidatorSet<T::AccountId> for Pallet<T> {
+	type ValidatorId = T::ValidatorId;
+	type ValidatorIdOf = T::ValidatorIdOf;
+
+	fn session_index() -> sp_staking::SessionIndex {
+		Pallet::<T>::current_index()
+	}
+
+	fn validators() -> Vec<Self::ValidatorId> {
+		Pallet::<T>::validators()
+	}
+}
+
+impl<T: Config> EstimateNextNewSession<BlockNumberFor<T>> for Pallet<T> {
+	fn average_session_length() -> BlockNumberFor<T> {
+		T::NextSessionRotation::average_session_length()
+	}
+
+	/// This session pallet always calls new_session and next_session at the same time, hence we
+	/// do a simple proxy and pass the function to next rotation.
+	fn estimate_next_new_session(now: BlockNumberFor<T>) -> (Option<BlockNumberFor<T>>, Weight) {
+		T::NextSessionRotation::estimate_next_session_rotation(now)
+	}
+}
+
+impl<T: Config> frame_support::traits::DisabledValidators for Pallet<T> {
+	fn is_disabled(index: u32) -> bool {
+		<Pallet<T>>::disabled_validators().binary_search(&index).is_ok()
+	}
+}
+
+/// Wraps the author-scraping logic for consensus engines that can recover
+/// the canonical index of an author. This then transforms it into the
+/// registering account-ID of that session key index.
+pub struct FindAccountFromAuthorIndex<T, Inner>(sp_std::marker::PhantomData<(T, Inner)>);
+
+impl<T: Config, Inner: FindAuthor<u32>> FindAuthor<T::ValidatorId>
+	for FindAccountFromAuthorIndex<T, Inner>
+{
+	fn find_author<'a, I>(digests: I) -> Option<T::ValidatorId>
+	where
+		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+	{
+		let i = Inner::find_author(digests)?;
+
+		let validators = <Pallet<T>>::validators();
+		validators.get(i as usize).cloned()
+	}
+}
diff --git a/substrate/frame/session/src/migrations/mod.rs b/substrate/frame/session/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3b15d0ac4646abaef577e136fd35a4d1a8840344
--- /dev/null
+++ b/substrate/frame/session/src/migrations/mod.rs
@@ -0,0 +1,24 @@
+// 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.
+
+/// Version 1.
+///
+/// In version 0 session historical pallet uses `Session` for storage module prefix.
+/// In version 1 it uses its name as configured in `construct_runtime`.
+/// This migration moves session historical pallet storages from old prefix to new prefix.
+#[cfg(feature = "historical")]
+pub mod v1;
diff --git a/substrate/frame/session/src/migrations/v1.rs b/substrate/frame/session/src/migrations/v1.rs
new file mode 100644
index 0000000000000000000000000000000000000000..394a1f4a5227c2bc3bedf0d177e1f9ee88a89528
--- /dev/null
+++ b/substrate/frame/session/src/migrations/v1.rs
@@ -0,0 +1,196 @@
+// 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 sp_io::hashing::twox_128;
+use sp_std::str;
+
+use frame_support::{
+	storage::{generator::StorageValue, StoragePrefixedMap},
+	traits::{
+		Get, GetStorageVersion, PalletInfoAccess, StorageVersion,
+		STORAGE_VERSION_STORAGE_KEY_POSTFIX,
+	},
+	weights::Weight,
+};
+
+use crate::historical as pallet_session_historical;
+
+const LOG_TARGET: &str = "runtime::session_historical";
+
+const OLD_PREFIX: &str = "Session";
+
+/// Migrate the entire storage of this pallet to a new prefix.
+///
+/// This new prefix must be the same as the one set in construct_runtime.
+///
+/// The migration will look into the storage version in order not to trigger a migration on an up
+/// to date storage. Thus the on chain storage version must be less than 1 in order to trigger the
+/// migration.
+pub fn migrate<T: pallet_session_historical::Config, P: GetStorageVersion + PalletInfoAccess>(
+) -> Weight {
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+
+	if new_pallet_name == OLD_PREFIX {
+		log::info!(
+			target: LOG_TARGET,
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return Weight::zero()
+	}
+
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration to v1 for session_historical with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 1 {
+		let storage_prefix = pallet_session_historical::HistoricalSessions::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			OLD_PREFIX.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, OLD_PREFIX, new_pallet_name);
+
+		let storage_prefix = pallet_session_historical::StoredRange::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			OLD_PREFIX.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, OLD_PREFIX, new_pallet_name);
+
+		StorageVersion::new(1).put::<P>();
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to v1 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// `frame_support::traits::OnRuntimeUpgrade::pre_upgrade` for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migrate<
+	T: pallet_session_historical::Config,
+	P: GetStorageVersion + PalletInfoAccess,
+>() {
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+
+	let storage_prefix_historical_sessions =
+		pallet_session_historical::HistoricalSessions::<T>::storage_prefix();
+	let storage_prefix_stored_range = pallet_session_historical::StoredRange::<T>::storage_prefix();
+
+	log_migration("pre-migration", storage_prefix_historical_sessions, OLD_PREFIX, new_pallet_name);
+	log_migration("pre-migration", storage_prefix_stored_range, OLD_PREFIX, new_pallet_name);
+
+	if new_pallet_name == OLD_PREFIX {
+		return
+	}
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let storage_version_key = twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX);
+
+	let mut new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|key| Ok(key.to_vec()),
+	);
+
+	// Ensure nothing except the storage_version_key is stored in the new prefix.
+	assert!(new_pallet_prefix_iter.all(|key| key == storage_version_key));
+
+	assert!(<P as GetStorageVersion>::on_chain_storage_version() < 1);
+}
+
+/// Some checks for after migration. This can be linked to
+/// `frame_support::traits::OnRuntimeUpgrade::post_upgrade` for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migrate<
+	T: pallet_session_historical::Config,
+	P: GetStorageVersion + PalletInfoAccess,
+>() {
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+
+	let storage_prefix_historical_sessions =
+		pallet_session_historical::HistoricalSessions::<T>::storage_prefix();
+	let storage_prefix_stored_range = pallet_session_historical::StoredRange::<T>::storage_prefix();
+
+	log_migration(
+		"post-migration",
+		storage_prefix_historical_sessions,
+		OLD_PREFIX,
+		new_pallet_name,
+	);
+	log_migration("post-migration", storage_prefix_stored_range, OLD_PREFIX, new_pallet_name);
+
+	if new_pallet_name == OLD_PREFIX {
+		return
+	}
+
+	// Assert that no `HistoricalSessions` and `StoredRange` storages remains at the old prefix.
+	let old_pallet_prefix = twox_128(OLD_PREFIX.as_bytes());
+	let old_historical_sessions_key =
+		[&old_pallet_prefix, &twox_128(storage_prefix_historical_sessions)[..]].concat();
+	let old_historical_sessions_key_iter = frame_support::storage::KeyPrefixIterator::new(
+		old_historical_sessions_key.to_vec(),
+		old_historical_sessions_key.to_vec(),
+		|_| Ok(()),
+	);
+	assert_eq!(old_historical_sessions_key_iter.count(), 0);
+
+	let old_stored_range_key =
+		[&old_pallet_prefix, &twox_128(storage_prefix_stored_range)[..]].concat();
+	let old_stored_range_key_iter = frame_support::storage::KeyPrefixIterator::new(
+		old_stored_range_key.to_vec(),
+		old_stored_range_key.to_vec(),
+		|_| Ok(()),
+	);
+	assert_eq!(old_stored_range_key_iter.count(), 0);
+
+	// Assert that the `HistoricalSessions` and `StoredRange` storages (if they exist) have been
+	// moved to the new prefix.
+	// NOTE: storage_version_key is already in the new prefix.
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert!(new_pallet_prefix_iter.count() >= 1);
+
+	assert_eq!(<P as GetStorageVersion>::on_chain_storage_version(), 1);
+}
+
+fn log_migration(stage: &str, storage_prefix: &[u8], old_pallet_name: &str, new_pallet_name: &str) {
+	log::info!(
+		target: LOG_TARGET,
+		"{} prefix of storage '{}': '{}' ==> '{}'",
+		stage,
+		str::from_utf8(storage_prefix).unwrap_or("<Invalid UTF8>"),
+		old_pallet_name,
+		new_pallet_name,
+	);
+}
diff --git a/substrate/frame/session/src/mock.rs b/substrate/frame/session/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2db54e1a59756c7915e9e8b03c8a5fa8728afcb7
--- /dev/null
+++ b/substrate/frame/session/src/mock.rs
@@ -0,0 +1,299 @@
+// 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.
+
+//! Mock helpers for Session.
+
+use super::*;
+use crate as pallet_session;
+#[cfg(feature = "historical")]
+use crate::historical as pallet_session_historical;
+
+use std::collections::BTreeMap;
+
+use sp_core::{crypto::key_types::DUMMY, H256};
+use sp_runtime::{
+	impl_opaque_keys,
+	testing::UintAuthorityId,
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+use sp_staking::SessionIndex;
+use sp_state_machine::BasicExternalities;
+
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+
+impl_opaque_keys! {
+	pub struct MockSessionKeys {
+		pub dummy: UintAuthorityId,
+	}
+}
+
+impl From<UintAuthorityId> for MockSessionKeys {
+	fn from(dummy: UintAuthorityId) -> Self {
+		Self { dummy }
+	}
+}
+
+pub const KEY_ID_A: KeyTypeId = KeyTypeId([4; 4]);
+pub const KEY_ID_B: KeyTypeId = KeyTypeId([9; 4]);
+
+#[derive(Debug, Clone, codec::Encode, codec::Decode, PartialEq, Eq)]
+pub struct PreUpgradeMockSessionKeys {
+	pub a: [u8; 32],
+	pub b: [u8; 64],
+}
+
+impl OpaqueKeys for PreUpgradeMockSessionKeys {
+	type KeyTypeIdProviders = ();
+
+	fn key_ids() -> &'static [KeyTypeId] {
+		&[KEY_ID_A, KEY_ID_B]
+	}
+
+	fn get_raw(&self, i: KeyTypeId) -> &[u8] {
+		match i {
+			i if i == KEY_ID_A => &self.a[..],
+			i if i == KEY_ID_B => &self.b[..],
+			_ => &[],
+		}
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+#[cfg(feature = "historical")]
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+		Historical: pallet_session_historical::{Pallet},
+	}
+);
+
+#[cfg(not(feature = "historical"))]
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Session: pallet_session::{Pallet, Call, Storage, Event, Config<T>},
+	}
+);
+
+parameter_types! {
+	pub static Validators: Vec<u64> = vec![1, 2, 3];
+	pub static NextValidators: Vec<u64> = vec![1, 2, 3];
+	pub static Authorities: Vec<UintAuthorityId> =
+		vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)];
+	pub static ForceSessionEnd: bool = false;
+	pub static SessionLength: u64 = 2;
+	pub static SessionChanged: bool = false;
+	pub static TestSessionChanged: bool = false;
+	pub static Disabled: bool = false;
+	// Stores if `on_before_session_end` was called
+	pub static BeforeSessionEndCalled: bool = false;
+	pub static ValidatorAccounts: BTreeMap<u64, u64> = BTreeMap::new();
+}
+
+pub struct TestShouldEndSession;
+impl ShouldEndSession<u64> for TestShouldEndSession {
+	fn should_end_session(now: u64) -> bool {
+		let l = SessionLength::get();
+		now % l == 0 ||
+			ForceSessionEnd::mutate(|l| {
+				let r = *l;
+				*l = false;
+				r
+			})
+	}
+}
+
+pub struct TestSessionHandler;
+impl SessionHandler<u64> for TestSessionHandler {
+	const KEY_TYPE_IDS: &'static [sp_runtime::KeyTypeId] = &[UintAuthorityId::ID];
+	fn on_genesis_session<T: OpaqueKeys>(_validators: &[(u64, T)]) {}
+	fn on_new_session<T: OpaqueKeys>(
+		changed: bool,
+		validators: &[(u64, T)],
+		_queued_validators: &[(u64, T)],
+	) {
+		SessionChanged::mutate(|l| *l = changed);
+		Authorities::mutate(|l| {
+			*l = validators
+				.iter()
+				.map(|(_, id)| id.get::<UintAuthorityId>(DUMMY).unwrap_or_default())
+				.collect()
+		});
+	}
+	fn on_disabled(_validator_index: u32) {
+		Disabled::mutate(|l| *l = true)
+	}
+	fn on_before_session_ending() {
+		BeforeSessionEndCalled::mutate(|b| *b = true);
+	}
+}
+
+pub struct TestSessionManager;
+impl SessionManager<u64> for TestSessionManager {
+	fn end_session(_: SessionIndex) {}
+	fn start_session(_: SessionIndex) {}
+	fn new_session(_: SessionIndex) -> Option<Vec<u64>> {
+		if !TestSessionChanged::get() {
+			Validators::mutate(|v| {
+				*v = NextValidators::get().clone();
+				Some(v.clone())
+			})
+		} else if Disabled::mutate(|l| std::mem::replace(&mut *l, false)) {
+			// If there was a disabled validator, underlying conditions have changed
+			// so we return `Some`.
+			Some(Validators::get().clone())
+		} else {
+			None
+		}
+	}
+}
+
+#[cfg(feature = "historical")]
+impl crate::historical::SessionManager<u64, u64> for TestSessionManager {
+	fn end_session(_: SessionIndex) {}
+	fn start_session(_: SessionIndex) {}
+	fn new_session(new_index: SessionIndex) -> Option<Vec<(u64, u64)>> {
+		<Self as SessionManager<_>>::new_session(new_index)
+			.map(|vals| vals.into_iter().map(|val| (val, val)).collect())
+	}
+}
+
+pub fn authorities() -> Vec<UintAuthorityId> {
+	Authorities::get().to_vec()
+}
+
+pub fn force_new_session() {
+	ForceSessionEnd::mutate(|l| *l = true)
+}
+
+pub fn set_session_length(x: u64) {
+	SessionLength::mutate(|l| *l = x)
+}
+
+pub fn session_changed() -> bool {
+	SessionChanged::get()
+}
+
+pub fn set_next_validators(next: Vec<u64>) {
+	NextValidators::mutate(|v| *v = next);
+}
+
+pub fn before_session_end_called() -> bool {
+	BeforeSessionEndCalled::get()
+}
+
+pub fn reset_before_session_end_called() {
+	BeforeSessionEndCalled::mutate(|b| *b = false);
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let keys: Vec<_> = NextValidators::get()
+		.iter()
+		.cloned()
+		.map(|i| (i, i, UintAuthorityId(i).into()))
+		.collect();
+	BasicExternalities::execute_with_storage(&mut t, || {
+		for (ref k, ..) in &keys {
+			frame_system::Pallet::<Test>::inc_providers(k);
+		}
+		frame_system::Pallet::<Test>::inc_providers(&4);
+		// An additional identity that we use.
+		frame_system::Pallet::<Test>::inc_providers(&69);
+	});
+	pallet_session::GenesisConfig::<Test> { keys }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	let v = NextValidators::get().iter().map(|&i| (i, i)).collect();
+	ValidatorAccounts::mutate(|m| *m = v);
+	sp_io::TestExternalities::new(t)
+}
+
+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 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 pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+pub struct TestValidatorIdOf;
+impl TestValidatorIdOf {
+	pub fn set(v: BTreeMap<u64, u64>) {
+		ValidatorAccounts::mutate(|m| *m = v);
+	}
+}
+impl Convert<u64, Option<u64>> for TestValidatorIdOf {
+	fn convert(x: u64) -> Option<u64> {
+		ValidatorAccounts::get().get(&x).cloned()
+	}
+}
+
+impl Config for Test {
+	type ShouldEndSession = TestShouldEndSession;
+	#[cfg(feature = "historical")]
+	type SessionManager = crate::historical::NoteHistoricalRoot<Test, TestSessionManager>;
+	#[cfg(not(feature = "historical"))]
+	type SessionManager = TestSessionManager;
+	type SessionHandler = TestSessionHandler;
+	type ValidatorId = u64;
+	type ValidatorIdOf = TestValidatorIdOf;
+	type Keys = MockSessionKeys;
+	type RuntimeEvent = RuntimeEvent;
+	type NextSessionRotation = ();
+	type WeightInfo = ();
+}
+
+#[cfg(feature = "historical")]
+impl crate::historical::Config for Test {
+	type FullIdentification = u64;
+	type FullIdentificationOf = sp_runtime::traits::ConvertInto;
+}
diff --git a/substrate/frame/session/src/tests.rs b/substrate/frame/session/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..69337e016ea8aa4671c2ccd3cd5f509f43aa9934
--- /dev/null
+++ b/substrate/frame/session/src/tests.rs
@@ -0,0 +1,484 @@
+// 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 the Session Pallet
+
+use super::*;
+use crate::mock::{
+	authorities, before_session_end_called, force_new_session, new_test_ext,
+	reset_before_session_end_called, session_changed, set_next_validators, set_session_length,
+	PreUpgradeMockSessionKeys, RuntimeOrigin, Session, SessionChanged, System, Test,
+	TestSessionChanged, TestValidatorIdOf,
+};
+
+use codec::Decode;
+use sp_core::crypto::key_types::DUMMY;
+use sp_runtime::testing::UintAuthorityId;
+
+use frame_support::{
+	assert_noop, assert_ok,
+	traits::{ConstU64, OnInitialize},
+};
+
+fn initialize_block(block: u64) {
+	SessionChanged::mutate(|l| *l = false);
+	System::set_block_number(block);
+	Session::on_initialize(block);
+}
+
+#[test]
+fn simple_setup_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)]);
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+	});
+}
+
+#[test]
+fn put_get_keys() {
+	new_test_ext().execute_with(|| {
+		Session::put_keys(&10, &UintAuthorityId(10).into());
+		assert_eq!(Session::load_keys(&10), Some(UintAuthorityId(10).into()));
+	})
+}
+
+#[test]
+fn keys_cleared_on_kill() {
+	let mut ext = new_test_ext();
+	ext.execute_with(|| {
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+		assert_eq!(Session::load_keys(&1), Some(UintAuthorityId(1).into()));
+
+		let id = DUMMY;
+		assert_eq!(Session::key_owner(id, UintAuthorityId(1).get_raw(id)), Some(1));
+
+		assert!(System::is_provider_required(&1));
+		assert_ok!(Session::purge_keys(RuntimeOrigin::signed(1)));
+		assert!(!System::is_provider_required(&1));
+
+		assert_eq!(Session::load_keys(&1), None);
+		assert_eq!(Session::key_owner(id, UintAuthorityId(1).get_raw(id)), None);
+	})
+}
+
+#[test]
+fn purge_keys_works_for_stash_id() {
+	let mut ext = new_test_ext();
+	ext.execute_with(|| {
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+		TestValidatorIdOf::set(vec![(10, 1), (20, 2), (3, 3)].into_iter().collect());
+		assert_eq!(Session::load_keys(&1), Some(UintAuthorityId(1).into()));
+		assert_eq!(Session::load_keys(&2), Some(UintAuthorityId(2).into()));
+
+		let id = DUMMY;
+		assert_eq!(Session::key_owner(id, UintAuthorityId(1).get_raw(id)), Some(1));
+
+		assert_ok!(Session::purge_keys(RuntimeOrigin::signed(10)));
+		assert_ok!(Session::purge_keys(RuntimeOrigin::signed(2)));
+
+		assert_eq!(Session::load_keys(&10), None);
+		assert_eq!(Session::load_keys(&20), None);
+		assert_eq!(Session::key_owner(id, UintAuthorityId(10).get_raw(id)), None);
+		assert_eq!(Session::key_owner(id, UintAuthorityId(20).get_raw(id)), None);
+	})
+}
+
+#[test]
+fn authorities_should_track_validators() {
+	reset_before_session_end_called();
+
+	new_test_ext().execute_with(|| {
+		TestValidatorIdOf::set(vec![(1, 1), (2, 2), (3, 3), (4, 4)].into_iter().collect());
+
+		set_next_validators(vec![1, 2]);
+		force_new_session();
+		initialize_block(1);
+		assert_eq!(
+			Session::queued_keys(),
+			vec![(1, UintAuthorityId(1).into()), (2, UintAuthorityId(2).into()),]
+		);
+		assert_eq!(Session::validators(), vec![1, 2, 3]);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)]);
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		force_new_session();
+		initialize_block(2);
+		assert_eq!(
+			Session::queued_keys(),
+			vec![(1, UintAuthorityId(1).into()), (2, UintAuthorityId(2).into()),]
+		);
+		assert_eq!(Session::validators(), vec![1, 2]);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2)]);
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		set_next_validators(vec![1, 2, 4]);
+		assert_ok!(Session::set_keys(RuntimeOrigin::signed(4), UintAuthorityId(4).into(), vec![]));
+		force_new_session();
+		initialize_block(3);
+		assert_eq!(
+			Session::queued_keys(),
+			vec![
+				(1, UintAuthorityId(1).into()),
+				(2, UintAuthorityId(2).into()),
+				(4, UintAuthorityId(4).into()),
+			]
+		);
+		assert_eq!(Session::validators(), vec![1, 2]);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2)]);
+		assert!(before_session_end_called());
+
+		force_new_session();
+		initialize_block(4);
+		assert_eq!(
+			Session::queued_keys(),
+			vec![
+				(1, UintAuthorityId(1).into()),
+				(2, UintAuthorityId(2).into()),
+				(4, UintAuthorityId(4).into()),
+			]
+		);
+		assert_eq!(Session::validators(), vec![1, 2, 4]);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(4)]);
+	});
+}
+
+#[test]
+fn should_work_with_early_exit() {
+	new_test_ext().execute_with(|| {
+		set_session_length(10);
+
+		initialize_block(1);
+		assert_eq!(Session::current_index(), 0);
+
+		initialize_block(2);
+		assert_eq!(Session::current_index(), 0);
+
+		force_new_session();
+		initialize_block(3);
+		assert_eq!(Session::current_index(), 1);
+
+		initialize_block(9);
+		assert_eq!(Session::current_index(), 1);
+
+		initialize_block(10);
+		assert_eq!(Session::current_index(), 2);
+	});
+}
+
+#[test]
+fn session_change_should_work() {
+	new_test_ext().execute_with(|| {
+		// Block 1: No change
+		initialize_block(1);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)]);
+
+		// Block 2: Session rollover, but no change.
+		initialize_block(2);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)]);
+
+		// Block 3: Set new key for validator 2; no visible change.
+		initialize_block(3);
+		assert_ok!(Session::set_keys(RuntimeOrigin::signed(2), UintAuthorityId(5).into(), vec![]));
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)]);
+
+		// Block 4: Session rollover; no visible change.
+		initialize_block(4);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)]);
+
+		// Block 5: No change.
+		initialize_block(5);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(2), UintAuthorityId(3)]);
+
+		// Block 6: Session rollover; authority 2 changes.
+		initialize_block(6);
+		assert_eq!(authorities(), vec![UintAuthorityId(1), UintAuthorityId(5), UintAuthorityId(3)]);
+	});
+}
+
+#[test]
+fn duplicates_are_not_allowed() {
+	new_test_ext().execute_with(|| {
+		TestValidatorIdOf::set(vec![(1, 1), (2, 2), (3, 3), (4, 4)].into_iter().collect());
+
+		System::set_block_number(1);
+		Session::on_initialize(1);
+		assert_noop!(
+			Session::set_keys(RuntimeOrigin::signed(4), UintAuthorityId(1).into(), vec![]),
+			Error::<Test>::DuplicatedKey,
+		);
+		assert_ok!(Session::set_keys(RuntimeOrigin::signed(1), UintAuthorityId(10).into(), vec![]));
+
+		// is fine now that 1 has migrated off.
+		assert_ok!(Session::set_keys(RuntimeOrigin::signed(4), UintAuthorityId(1).into(), vec![]));
+	});
+}
+
+#[test]
+fn session_changed_flag_works() {
+	reset_before_session_end_called();
+
+	new_test_ext().execute_with(|| {
+		TestValidatorIdOf::set(vec![(1, 1), (2, 2), (3, 3), (69, 69)].into_iter().collect());
+		TestSessionChanged::mutate(|l| *l = true);
+
+		force_new_session();
+		initialize_block(1);
+		assert!(!session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		force_new_session();
+		initialize_block(2);
+		assert!(!session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		Session::disable_index(0);
+		force_new_session();
+		initialize_block(3);
+		assert!(!session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		force_new_session();
+		initialize_block(4);
+		assert!(session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		force_new_session();
+		initialize_block(5);
+		assert!(!session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		assert_ok!(Session::set_keys(RuntimeOrigin::signed(2), UintAuthorityId(5).into(), vec![]));
+		force_new_session();
+		initialize_block(6);
+		assert!(!session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		// changing the keys of a validator leads to change.
+		assert_ok!(Session::set_keys(
+			RuntimeOrigin::signed(69),
+			UintAuthorityId(69).into(),
+			vec![]
+		));
+		force_new_session();
+		initialize_block(7);
+		assert!(session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+
+		// while changing the keys of a non-validator does not.
+		force_new_session();
+		initialize_block(7);
+		assert!(!session_changed());
+		assert!(before_session_end_called());
+		reset_before_session_end_called();
+	});
+}
+
+#[test]
+fn periodic_session_works() {
+	type P = PeriodicSessions<ConstU64<10>, ConstU64<3>>;
+
+	// make sure that offset phase behaves correctly
+	for i in 0u64..3 {
+		assert!(!P::should_end_session(i));
+		assert_eq!(P::estimate_next_session_rotation(i).0.unwrap(), 3);
+
+		// the last block of the session (i.e. the one before session rotation)
+		// should have progress 100%.
+		if P::estimate_next_session_rotation(i).0.unwrap() - 1 == i {
+			assert_eq!(
+				P::estimate_current_session_progress(i).0.unwrap(),
+				Permill::from_percent(100)
+			);
+		} else {
+			assert!(
+				P::estimate_current_session_progress(i).0.unwrap() < Permill::from_percent(100)
+			);
+		}
+	}
+
+	// we end the session at block #3 and we consider this block the first one
+	// from the next session. since we're past the offset phase it represents
+	// 1/10 of progress.
+	assert!(P::should_end_session(3u64));
+	assert_eq!(P::estimate_next_session_rotation(3u64).0.unwrap(), 3);
+	assert_eq!(P::estimate_current_session_progress(3u64).0.unwrap(), Permill::from_percent(10));
+
+	for i in (1u64..10).map(|i| 3 + i) {
+		assert!(!P::should_end_session(i));
+		assert_eq!(P::estimate_next_session_rotation(i).0.unwrap(), 13);
+
+		// as with the offset phase the last block of the session must have 100%
+		// progress.
+		if P::estimate_next_session_rotation(i).0.unwrap() - 1 == i {
+			assert_eq!(
+				P::estimate_current_session_progress(i).0.unwrap(),
+				Permill::from_percent(100)
+			);
+		} else {
+			assert!(
+				P::estimate_current_session_progress(i).0.unwrap() < Permill::from_percent(100)
+			);
+		}
+	}
+
+	// the new session starts and we proceed in 1/10 increments.
+	assert!(P::should_end_session(13u64));
+	assert_eq!(P::estimate_next_session_rotation(13u64).0.unwrap(), 23);
+	assert_eq!(P::estimate_current_session_progress(13u64).0.unwrap(), Permill::from_percent(10));
+
+	assert!(!P::should_end_session(14u64));
+	assert_eq!(P::estimate_next_session_rotation(14u64).0.unwrap(), 23);
+	assert_eq!(P::estimate_current_session_progress(14u64).0.unwrap(), Permill::from_percent(20));
+}
+
+#[test]
+fn session_keys_generate_output_works_as_set_keys_input() {
+	new_test_ext().execute_with(|| {
+		let new_keys = mock::MockSessionKeys::generate(None);
+		assert_ok!(Session::set_keys(
+			RuntimeOrigin::signed(2),
+			<mock::Test as Config>::Keys::decode(&mut &new_keys[..]).expect("Decode keys"),
+			vec![],
+		));
+	});
+}
+
+#[test]
+fn disable_index_returns_false_if_already_disabled() {
+	new_test_ext().execute_with(|| {
+		set_next_validators(vec![1, 2, 3, 4, 5, 6, 7]);
+		force_new_session();
+		initialize_block(1);
+		// apply the new validator set
+		force_new_session();
+		initialize_block(2);
+
+		assert_eq!(Session::disable_index(0), true);
+		assert_eq!(Session::disable_index(0), false);
+		assert_eq!(Session::disable_index(1), true);
+	});
+}
+
+#[test]
+fn upgrade_keys() {
+	use frame_support::storage;
+	use sp_core::crypto::key_types::DUMMY;
+
+	// This test assumes certain mocks.
+	assert_eq!(mock::NextValidators::get().clone(), vec![1, 2, 3]);
+	assert_eq!(mock::Validators::get().clone(), vec![1, 2, 3]);
+
+	new_test_ext().execute_with(|| {
+		let pre_one = PreUpgradeMockSessionKeys { a: [1u8; 32], b: [1u8; 64] };
+
+		let pre_two = PreUpgradeMockSessionKeys { a: [2u8; 32], b: [2u8; 64] };
+
+		let pre_three = PreUpgradeMockSessionKeys { a: [3u8; 32], b: [3u8; 64] };
+
+		let val_keys = vec![(1u64, pre_one), (2u64, pre_two), (3u64, pre_three)];
+
+		// Set `QueuedKeys`.
+		{
+			let storage_key = <super::QueuedKeys<Test>>::hashed_key();
+			assert!(storage::unhashed::exists(&storage_key));
+			storage::unhashed::put(&storage_key, &val_keys);
+		}
+
+		// Set `NextKeys`.
+		{
+			for &(i, ref keys) in val_keys.iter() {
+				let storage_key = <super::NextKeys<Test>>::hashed_key_for(i);
+				assert!(storage::unhashed::exists(&storage_key));
+				storage::unhashed::put(&storage_key, keys);
+			}
+		}
+
+		// Set `KeyOwner`.
+		{
+			for &(i, ref keys) in val_keys.iter() {
+				// clear key owner for `UintAuthorityId` keys set in genesis.
+				let presumed = UintAuthorityId(i);
+				let raw_prev = presumed.as_ref();
+
+				assert_eq!(Session::key_owner(DUMMY, raw_prev), Some(i));
+				Session::clear_key_owner(DUMMY, raw_prev);
+
+				Session::put_key_owner(mock::KEY_ID_A, keys.get_raw(mock::KEY_ID_A), &i);
+				Session::put_key_owner(mock::KEY_ID_B, keys.get_raw(mock::KEY_ID_B), &i);
+			}
+		}
+
+		// Do the upgrade and check sanity.
+		let mock_keys_for = |val| mock::MockSessionKeys { dummy: UintAuthorityId(val) };
+		Session::upgrade_keys::<PreUpgradeMockSessionKeys, _>(|val, _old_keys| mock_keys_for(val));
+
+		// Check key ownership.
+		for (i, ref keys) in val_keys.iter() {
+			assert!(Session::key_owner(mock::KEY_ID_A, keys.get_raw(mock::KEY_ID_A)).is_none());
+			assert!(Session::key_owner(mock::KEY_ID_B, keys.get_raw(mock::KEY_ID_B)).is_none());
+
+			let migrated_key = UintAuthorityId(*i);
+			assert_eq!(Session::key_owner(DUMMY, migrated_key.as_ref()), Some(*i));
+		}
+
+		// Check queued keys.
+		assert_eq!(
+			Session::queued_keys(),
+			vec![(1, mock_keys_for(1)), (2, mock_keys_for(2)), (3, mock_keys_for(3)),],
+		);
+
+		for i in 1u64..4 {
+			assert_eq!(<super::NextKeys<Test>>::get(&i), Some(mock_keys_for(i)));
+		}
+	})
+}
+
+#[cfg(feature = "historical")]
+#[test]
+fn test_migration_v1() {
+	use crate::{
+		historical::{HistoricalSessions, StoredRange},
+		mock::Historical,
+	};
+	use frame_support::traits::{PalletInfoAccess, StorageVersion};
+
+	new_test_ext().execute_with(|| {
+		assert!(<HistoricalSessions<Test>>::iter_values().count() > 0);
+		assert!(<StoredRange<Test>>::exists());
+
+		let old_pallet = "Session";
+		let new_pallet = <Historical as PalletInfoAccess>::name();
+		frame_support::storage::migration::move_pallet(
+			new_pallet.as_bytes(),
+			old_pallet.as_bytes(),
+		);
+		StorageVersion::new(0).put::<Historical>();
+
+		crate::migrations::v1::pre_migrate::<Test, Historical>();
+		crate::migrations::v1::migrate::<Test, Historical>();
+		crate::migrations::v1::post_migrate::<Test, Historical>();
+	});
+}
diff --git a/substrate/frame/session/src/weights.rs b/substrate/frame/session/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dd9848fd2c177913f9121f98ab269bdae7e0f40e
--- /dev/null
+++ b/substrate/frame/session/src/weights.rs
@@ -0,0 +1,126 @@
+// 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.
+
+//! Autogenerated weights for pallet_session
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_session
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/session/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_session.
+pub trait WeightInfo {
+	fn set_keys() -> Weight;
+	fn purge_keys() -> Weight;
+}
+
+/// Weights for pallet_session using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Session NextKeys (r:1 w:1)
+	/// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Session KeyOwner (r:4 w:4)
+	/// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured)
+	fn set_keys() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1924`
+		//  Estimated: `12814`
+		// Minimum execution time: 55_459_000 picoseconds.
+		Weight::from_parts(56_180_000, 12814)
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Session NextKeys (r:1 w:1)
+	/// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Session KeyOwner (r:0 w:4)
+	/// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured)
+	fn purge_keys() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1791`
+		//  Estimated: `5256`
+		// Minimum execution time: 40_194_000 picoseconds.
+		Weight::from_parts(41_313_000, 5256)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Session NextKeys (r:1 w:1)
+	/// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Session KeyOwner (r:4 w:4)
+	/// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured)
+	fn set_keys() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1924`
+		//  Estimated: `12814`
+		// Minimum execution time: 55_459_000 picoseconds.
+		Weight::from_parts(56_180_000, 12814)
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Session NextKeys (r:1 w:1)
+	/// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Session KeyOwner (r:0 w:4)
+	/// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured)
+	fn purge_keys() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1791`
+		//  Estimated: `5256`
+		// Minimum execution time: 40_194_000 picoseconds.
+		Weight::from_parts(41_313_000, 5256)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+}
diff --git a/substrate/frame/society/Cargo.toml b/substrate/frame/society/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..55e5c1e01cb1903c5785a7c20057afbdb92d97aa
--- /dev/null
+++ b/substrate/frame/society/Cargo.toml
@@ -0,0 +1,68 @@
+[package]
+name = "pallet-society"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME society pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+log = { version = "0.4.17", default-features = false }
+rand_chacha = { version = "0.2", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+
+[dev-dependencies]
+frame-support-test = { version = "3.0.0", path = "../support/test" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+# Enable `VersionedRuntimeUpgrade` for the migrations that is currently still experimental.
+experimental = [ "frame-support/experimental" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support-test/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"rand_chacha/std",
+	"scale-info/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support-test/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/society/README.md b/substrate/frame/society/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..80998618664297f05d4dd87405b03cbfad1c4600
--- /dev/null
+++ b/substrate/frame/society/README.md
@@ -0,0 +1,228 @@
+# Society Module
+
+- [`society::Config`](https://docs.rs/pallet-society/latest/pallet_society/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-society/latest/pallet_society/enum.Call.html)
+
+## Overview
+
+The Society module is an economic game which incentivizes users to participate
+and maintain a membership society.
+
+### User Types
+
+At any point, a user in the society can be one of a:
+* Bidder - A user who has submitted intention of joining the society.
+* Candidate - A user who will be voted on to join the society.
+* Suspended Candidate - A user who failed to win a vote.
+* Member - A user who is a member of the society.
+* Suspended Member - A member of the society who has accumulated too many strikes
+or failed their membership challenge.
+
+Of the non-suspended members, there is always a:
+* Head - A member who is exempt from suspension.
+* Defender - A member whose membership is under question and voted on again.
+
+Of the non-suspended members of the society, a random set of them are chosen as
+"skeptics". The mechanics of skeptics is explained in the
+[member phase](https://docs.rs/pallet-society/latest/pallet_society/#member-phase) below.
+
+### Mechanics
+
+#### Rewards
+
+Members are incentivized to participate in the society through rewards paid
+by the Society treasury. These payments have a maturity period that the user
+must wait before they are able to access the funds.
+
+#### Punishments
+
+Members can be punished by slashing the reward payouts that have not been
+collected. Additionally, members can accumulate "strikes", and when they
+reach a max strike limit, they become suspended.
+
+#### Skeptics
+
+During the voting period, a random set of members are selected as "skeptics".
+These skeptics are expected to vote on the current candidates. If they do not vote,
+their skeptic status is treated as a rejection vote, the member is deemed
+"lazy", and are given a strike per missing vote.
+
+#### Membership Challenges
+
+Every challenge rotation period, an existing member will be randomly selected
+to defend their membership into society. Then, other members can vote whether
+this defender should stay in society. A simple majority wins vote will determine
+the outcome of the user. Ties are treated as a failure of the challenge, but
+assuming no one else votes, the defender always get a free vote on their
+own challenge keeping them in the society. The Head member is exempt from the
+negative outcome of a membership challenge.
+
+#### Society Treasury
+
+The membership society is independently funded by a treasury managed by this
+module. Some subset of this treasury is placed in a Society Pot, which is used
+to determine the number of accepted bids.
+
+#### Rate of Growth
+
+The membership society can grow at a rate of 10 accepted candidates per rotation period up
+to the max membership threshold. Once this threshold is met, candidate selections
+are stalled until there is space for new members to join. This can be resolved by
+voting out existing members through the random challenges or by using governance
+to increase the maximum membership count.
+
+### User Life Cycle
+
+A user can go through the following phases:
+
+```rust
+          +------->  User  <----------+
+          |           +               |
+          |           |               |
++----------------------------------------------+
+|         |           |               |        |
+|         |           v               |        |
+|         |        Bidder <-----------+        |
+|         |           +               |        |
+|         |           |               +        |
+|         |           v            Suspended   |
+|         |       Candidate +----> Candidate   |
+|         |           +               +        |
+|         |           |               |        |
+|         +           |               |        |
+|   Suspended +------>|               |        |
+|      Member         |               |        |
+|         ^           |               |        |
+|         |           v               |        |
+|         +-------+ Member <----------+        |
+|                                              |
+|                                              |
++------------------Society---------------------+
+```
+
+#### Initialization
+
+The society is initialized with a single member who is automatically chosen as the Head.
+
+#### Bid Phase
+
+New users must have a bid to join the society.
+
+A user can make a bid by reserving a deposit. Alternatively, an already existing member
+can create a bid on a user's behalf by "vouching" for them.
+
+A bid includes reward information that the user would like to receive for joining
+the society. A vouching bid can additionally request some portion of that reward as a tip
+to the voucher for vouching for the prospective candidate.
+
+Every rotation period, Bids are ordered by reward amount, and the module
+selects as many bids the Society Pot can support for that period.
+
+These selected bids become candidates and move on to the Candidate phase.
+Bids that were not selected stay in the bidder pool until they are selected or
+a user chooses to "unbid".
+
+#### Candidate Phase
+
+Once a bidder becomes a candidate, members vote whether to approve or reject
+that candidate into society. This voting process also happens during a rotation period.
+
+The approval and rejection criteria for candidates are not set on chain,
+and may change for different societies.
+
+At the end of the rotation period, we collect the votes for a candidate
+and randomly select a vote as the final outcome.
+
+```rust
+ [ a-accept, r-reject, s-skeptic ]
++----------------------------------+
+|                                  |
+|  Member   |0|1|2|3|4|5|6|7|8|9|  |
+|  -----------------------------   |
+|  Vote     |a|a|a|r|s|r|a|a|s|a|  |
+|  -----------------------------   |
+|  Selected | | | |x| | | | | | |  |
+|                                  |
++----------------------------------+
+
+Result: Rejected
+```
+
+Each member that voted opposite to this randomly selected vote is punished by
+slashing their unclaimed payouts and increasing the number of strikes they have.
+
+These slashed funds are given to a random user who voted the same as the
+selected vote as a reward for participating in the vote.
+
+If the candidate wins the vote, they receive their bid reward as a future payout.
+If the bid was placed by a voucher, they will receive their portion of the reward,
+before the rest is paid to the winning candidate.
+
+One winning candidate is selected as the Head of the members. This is randomly
+chosen, weighted by the number of approvals the winning candidates accumulated.
+
+If the candidate loses the vote, they are suspended and it is up to the Suspension
+Judgement origin to determine if the candidate should go through the bidding process
+again, should be accepted into the membership society, or rejected and their deposit
+slashed.
+
+#### Member Phase
+
+Once a candidate becomes a member, their role is to participate in society.
+
+Regular participation involves voting on candidates who want to join the membership
+society, and by voting in the right way, a member will accumulate future payouts.
+When a payout matures, members are able to claim those payouts.
+
+Members can also vouch for users to join the society, and request a "tip" from
+the fees the new member would collect by joining the society. This vouching
+process is useful in situations where a user may not have enough balance to
+satisfy the bid deposit. A member can only vouch one user at a time.
+
+During rotation periods, a random group of members are selected as "skeptics".
+These skeptics are expected to vote on the current candidates. If they do not vote,
+their skeptic status is treated as a rejection vote, the member is deemed
+"lazy", and are given a strike per missing vote.
+
+There is a challenge period in parallel to the rotation period. During a challenge period,
+a random member is selected to defend their membership to the society. Other members
+make a traditional majority-wins vote to determine if the member should stay in the society.
+Ties are treated as a failure of the challenge.
+
+If a member accumulates too many strikes or fails their membership challenge,
+they will become suspended. While a member is suspended, they are unable to
+claim matured payouts. It is up to the Suspension Judgement origin to determine
+if the member should re-enter society or be removed from society with all their
+future payouts slashed.
+
+## Interface
+
+### Dispatchable Functions
+
+#### For General Users
+
+* `bid` - A user can make a bid to join the membership society by reserving a deposit.
+* `unbid` - A user can withdraw their bid for entry, the deposit is returned.
+
+#### For Members
+
+* `vouch` - A member can place a bid on behalf of a user to join the membership society.
+* `unvouch` - A member can revoke their vouch for a user.
+* `vote` - A member can vote to approve or reject a candidate's request to join the society.
+* `defender_vote` - A member can vote to approve or reject a defender's continued membership
+to the society.
+* `payout` - A member can claim their first matured payment.
+* `unfound` - Allow the founder to unfound the society when they are the only member.
+
+#### For Super Users
+
+* `found` - The founder origin can initiate this society. Useful for bootstrapping the Society
+pallet on an already running chain.
+* `judge_suspended_member` - The suspension judgement origin is able to make
+judgement on a suspended member.
+* `judge_suspended_candidate` - The suspension judgement origin is able to
+make judgement on a suspended candidate.
+* `set_max_membership` - The ROOT origin can update the maximum member count for the society.
+The max membership count must be greater than 1.
+
+License: Apache-2.0
diff --git a/substrate/frame/society/src/benchmarking.rs b/substrate/frame/society/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..20af6e35ada52136f4ad14459afc0eeb1d19ca45
--- /dev/null
+++ b/substrate/frame/society/src/benchmarking.rs
@@ -0,0 +1,379 @@
+// 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.
+
+//! Society pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+
+use frame_benchmarking::{account, benchmarks_instance_pallet, whitelisted_caller};
+use frame_system::RawOrigin;
+
+use sp_runtime::traits::Bounded;
+
+use crate::Pallet as Society;
+
+fn mock_balance_deposit<T: Config<I>, I: 'static>() -> BalanceOf<T, I> {
+	T::Currency::minimum_balance().saturating_mul(1_000u32.into())
+}
+
+fn make_deposit<T: Config<I>, I: 'static>(who: &T::AccountId) -> BalanceOf<T, I> {
+	let amount = mock_balance_deposit::<T, I>();
+	let required = amount.saturating_add(T::Currency::minimum_balance());
+	if T::Currency::free_balance(who) < required {
+		T::Currency::make_free_balance_be(who, required);
+	}
+	T::Currency::reserve(who, amount).expect("Pre-funded account; qed");
+	amount
+}
+
+fn make_bid<T: Config<I>, I: 'static>(
+	who: &T::AccountId,
+) -> BidKind<T::AccountId, BalanceOf<T, I>> {
+	BidKind::Deposit(make_deposit::<T, I>(who))
+}
+
+fn fund_society<T: Config<I>, I: 'static>() {
+	T::Currency::make_free_balance_be(
+		&Society::<T, I>::account_id(),
+		BalanceOf::<T, I>::max_value(),
+	);
+	Pot::<T, I>::put(&BalanceOf::<T, I>::max_value());
+}
+
+// Set up Society
+fn setup_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static str> {
+	let origin = T::FounderSetOrigin::try_successful_origin().map_err(|_| "No origin")?;
+	let founder: T::AccountId = account("founder", 0, 0);
+	let founder_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(founder.clone());
+	let max_members = 5u32;
+	let max_intake = 3u32;
+	let max_strikes = 3u32;
+	Society::<T, I>::found_society(
+		origin,
+		founder_lookup,
+		max_members,
+		max_intake,
+		max_strikes,
+		mock_balance_deposit::<T, I>(),
+		b"benchmarking-society".to_vec(),
+	)?;
+	T::Currency::make_free_balance_be(
+		&Society::<T, I>::account_id(),
+		T::Currency::minimum_balance(),
+	);
+	T::Currency::make_free_balance_be(&Society::<T, I>::payouts(), T::Currency::minimum_balance());
+	Ok(founder)
+}
+
+fn setup_funded_society<T: Config<I>, I: 'static>() -> Result<T::AccountId, &'static str> {
+	let founder = setup_society::<T, I>()?;
+	fund_society::<T, I>();
+	Ok(founder)
+}
+
+fn add_candidate<T: Config<I>, I: 'static>(
+	name: &'static str,
+	tally: Tally,
+	skeptic_struck: bool,
+) -> T::AccountId {
+	let candidate: T::AccountId = account(name, 0, 0);
+	let candidacy = Candidacy {
+		round: RoundCount::<T, I>::get(),
+		kind: make_bid::<T, I>(&candidate),
+		bid: 0u32.into(),
+		tally,
+		skeptic_struck,
+	};
+	Candidates::<T, I>::insert(&candidate, &candidacy);
+	candidate
+}
+
+fn increment_round<T: Config<I>, I: 'static>() {
+	let mut round_count = RoundCount::<T, I>::get();
+	round_count.saturating_inc();
+	RoundCount::<T, I>::put(round_count);
+}
+
+benchmarks_instance_pallet! {
+	bid {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+	}: _(RawOrigin::Signed(caller.clone()), 10u32.into())
+	verify {
+		let first_bid: Bid<T::AccountId, BalanceOf<T, I>> = Bid {
+			who: caller.clone(),
+			kind: BidKind::Deposit(mock_balance_deposit::<T, I>()),
+			value: 10u32.into(),
+		};
+		assert_eq!(Bids::<T, I>::get(), vec![first_bid]);
+	}
+
+	unbid {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let mut bids = Bids::<T, I>::get();
+		Society::<T, I>::insert_bid(&mut bids, &caller, 10u32.into(), make_bid::<T, I>(&caller));
+		Bids::<T, I>::put(bids);
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		assert_eq!(Bids::<T, I>::get(), vec![]);
+	}
+
+	vouch {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		let vouched: T::AccountId = account("vouched", 0, 0);
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 1u32.into());
+		let vouched_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(vouched.clone());
+	}: _(RawOrigin::Signed(caller.clone()), vouched_lookup, 0u32.into(), 0u32.into())
+	verify {
+		let bids = Bids::<T, I>::get();
+		let vouched_bid: Bid<T::AccountId, BalanceOf<T, I>> = Bid {
+			who: vouched.clone(),
+			kind: BidKind::Vouch(caller.clone(), 0u32.into()),
+			value: 0u32.into(),
+		};
+		assert_eq!(bids, vec![vouched_bid]);
+	}
+
+	unvouch {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		let vouched: T::AccountId = account("vouched", 0, 0);
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let mut bids = Bids::<T, I>::get();
+		Society::<T, I>::insert_bid(&mut bids, &caller, 10u32.into(), BidKind::Vouch(caller.clone(), 0u32.into()));
+		Bids::<T, I>::put(bids);
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		assert_eq!(Bids::<T, I>::get(), vec![]);
+	}
+
+	vote {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 1u32.into());
+		let candidate = add_candidate::<T, I>("candidate", Default::default(), false);
+		let candidate_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(candidate.clone());
+	}: _(RawOrigin::Signed(caller.clone()), candidate_lookup, true)
+	verify {
+		let maybe_vote: Vote = <Votes<T, I>>::get(candidate.clone(), caller).unwrap();
+		assert_eq!(maybe_vote.approve, true);
+	}
+
+	defender_vote {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 1u32.into());
+		let defender: T::AccountId = account("defender", 0, 0);
+		Defending::<T, I>::put((defender, caller.clone(), Tally::default()));
+	}: _(RawOrigin::Signed(caller.clone()), false)
+	verify {
+		let round = RoundCount::<T, I>::get();
+		let skeptic_vote: Vote = DefenderVotes::<T, I>::get(round, &caller).unwrap();
+		assert_eq!(skeptic_vote.approve, false);
+	}
+
+	payout {
+		let founder = setup_funded_society::<T, I>()?;
+		// Payee's account already exists and is a member.
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, mock_balance_deposit::<T, I>());
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		// Introduce payout.
+		Society::<T, I>::bump_payout(&caller, 0u32.into(), 1u32.into());
+	}: _(RawOrigin::Signed(caller.clone()))
+	verify {
+		let record = Payouts::<T, I>::get(caller);
+		assert!(record.payouts.is_empty());
+	}
+
+	waive_repay {
+		let founder = setup_funded_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T, I>::max_value());
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		Society::<T, I>::bump_payout(&caller, 0u32.into(), 1u32.into());
+	}: _(RawOrigin::Signed(caller.clone()), 1u32.into())
+	verify {
+		let record = Payouts::<T, I>::get(caller);
+		assert!(record.payouts.is_empty());
+	}
+
+	found_society {
+		let founder: T::AccountId = whitelisted_caller();
+		let can_found = T::FounderSetOrigin::try_successful_origin().map_err(|_| "No origin")?;
+		let founder_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(founder.clone());
+	}: _<T::RuntimeOrigin>(can_found, founder_lookup, 5, 3, 3, mock_balance_deposit::<T, I>(), b"benchmarking-society".to_vec())
+	verify {
+		assert_eq!(Founder::<T, I>::get(), Some(founder.clone()));
+	}
+
+	dissolve {
+		let founder = setup_society::<T, I>()?;
+		let members_and_candidates = vec![("m1", "c1"), ("m2", "c2"), ("m3", "c3"), ("m4", "c4")];
+		let members_count = members_and_candidates.clone().len() as u32;
+		for (m, c) in members_and_candidates {
+			let member: T::AccountId = account(m, 0, 0);
+			let _ = Society::<T, I>::insert_member(&member, 100u32.into());
+			let candidate = add_candidate::<T, I>(c, Tally { approvals: 1u32.into(), rejections: 1u32.into() }, false);
+			let candidate_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(candidate);
+			let _ = Society::<T, I>::vote(RawOrigin::Signed(member).into(), candidate_lookup, true);
+		}
+		// Leaving only Founder member.
+		MemberCount::<T, I>::mutate(|i| { i.saturating_reduce(members_count) });
+	}: _(RawOrigin::Signed(founder))
+	verify {
+		assert_eq!(Founder::<T, I>::get(), None);
+	}
+
+	judge_suspended_member {
+		let founder = setup_society::<T, I>()?;
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(caller.clone());
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		let _ = Society::<T, I>::suspend_member(&caller);
+	}: _(RawOrigin::Signed(founder), caller_lookup, false)
+	verify {
+		assert_eq!(SuspendedMembers::<T, I>::contains_key(&caller), false);
+	}
+
+	set_parameters {
+		let founder = setup_society::<T, I>()?;
+		let max_members = 10u32;
+		let max_intake = 10u32;
+		let max_strikes = 10u32;
+		let candidate_deposit: BalanceOf<T, I> = 10u32.into();
+		let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
+	}: _(RawOrigin::Signed(founder), max_members, max_intake, max_strikes, candidate_deposit)
+	verify {
+		assert_eq!(Parameters::<T, I>::get(), Some(params));
+	}
+
+	punish_skeptic {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Default::default(), false);
+		let skeptic: T::AccountId = account("skeptic", 0, 0);
+		let _ = Society::<T, I>::insert_member(&skeptic, 0u32.into());
+		Skeptic::<T, I>::put(&skeptic);
+		if let Period::Voting { more, .. } = Society::<T, I>::period() {
+			frame_system::Pallet::<T>::set_block_number(frame_system::Pallet::<T>::block_number() + more);
+		}
+		}: _(RawOrigin::Signed(candidate.clone()))
+	verify {
+		let candidacy = Candidates::<T, I>::get(&candidate).unwrap();
+		assert_eq!(candidacy.skeptic_struck, true);
+	}
+
+	claim_membership {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 3u32.into(), rejections: 0u32.into() }, false);
+		increment_round::<T, I>();
+	}: _(RawOrigin::Signed(candidate.clone()))
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+		assert!(Members::<T, I>::contains_key(&candidate));
+	}
+
+	bestow_membership {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 3u32.into(), rejections: 1u32.into() }, false);
+		increment_round::<T, I>();
+	}: _(RawOrigin::Signed(founder), candidate.clone())
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+		assert!(Members::<T, I>::contains_key(&candidate));
+	}
+
+	kick_candidate {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 1u32.into(), rejections: 1u32.into() }, false);
+		increment_round::<T, I>();
+	}: _(RawOrigin::Signed(founder), candidate.clone())
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+	}
+
+	resign_candidacy {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 0u32.into(), rejections: 0u32.into() }, false);
+	}: _(RawOrigin::Signed(candidate.clone()))
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+	}
+
+	drop_candidate {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 0u32.into(), rejections: 3u32.into() }, false);
+		let caller: T::AccountId = whitelisted_caller();
+		let _ = Society::<T, I>::insert_member(&caller, 0u32.into());
+		let mut round_count = RoundCount::<T, I>::get();
+		round_count = round_count.saturating_add(2u32);
+		RoundCount::<T, I>::put(round_count);
+	}: _(RawOrigin::Signed(caller), candidate.clone())
+	verify {
+		assert!(!Candidates::<T, I>::contains_key(&candidate));
+	}
+
+	cleanup_candidacy {
+		let founder = setup_society::<T, I>()?;
+		let candidate = add_candidate::<T, I>("candidate", Tally { approvals: 0u32.into(), rejections: 0u32.into() }, false);
+		let member_one: T::AccountId = account("one", 0, 0);
+		let member_two: T::AccountId = account("two", 0, 0);
+		let _ = Society::<T, I>::insert_member(&member_one, 0u32.into());
+		let _ = Society::<T, I>::insert_member(&member_two, 0u32.into());
+		let candidate_lookup: <T::Lookup as StaticLookup>::Source = T::Lookup::unlookup(candidate.clone());
+		let _ = Society::<T, I>::vote(RawOrigin::Signed(member_one.clone()).into(), candidate_lookup.clone(), true);
+		let _ = Society::<T, I>::vote(RawOrigin::Signed(member_two.clone()).into(), candidate_lookup, true);
+		Candidates::<T, I>::remove(&candidate);
+	}: _(RawOrigin::Signed(member_one), candidate.clone(), 5)
+	verify {
+		assert_eq!(Votes::<T, I>::get(&candidate, &member_two), None);
+	}
+
+	cleanup_challenge {
+		let founder = setup_society::<T, I>()?;
+		ChallengeRoundCount::<T, I>::put(1u32);
+		let member: T::AccountId = whitelisted_caller();
+		let _ = Society::<T, I>::insert_member(&member, 0u32.into());
+		let defender: T::AccountId = account("defender", 0, 0);
+		Defending::<T, I>::put((defender.clone(), member.clone(), Tally::default()));
+		let _ = Society::<T, I>::defender_vote(RawOrigin::Signed(member.clone()).into(), true);
+		ChallengeRoundCount::<T, I>::put(2u32);
+		let mut challenge_round = ChallengeRoundCount::<T, I>::get();
+		challenge_round = challenge_round.saturating_sub(1u32);
+	}: _(RawOrigin::Signed(member.clone()), challenge_round, 1u32)
+	verify {
+		assert_eq!(DefenderVotes::<T, I>::get(challenge_round, &defender), None);
+	}
+
+	impl_benchmark_test_suite!(
+		Society,
+		sp_io::TestExternalities::from(
+			<frame_system::GenesisConfig::<crate::mock::Test> as sp_runtime::BuildStorage>::build_storage(
+				&frame_system::GenesisConfig::default()).unwrap()
+			),
+		crate::mock::Test
+	);
+}
diff --git a/substrate/frame/society/src/lib.rs b/substrate/frame/society/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ca8d96e193c843e5a6bad59cf8807e2eb16260bf
--- /dev/null
+++ b/substrate/frame/society/src/lib.rs
@@ -0,0 +1,2035 @@
+// 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.
+
+//! # Society Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! The Society pallet is an economic game which incentivizes users to participate
+//! and maintain a membership society.
+//!
+//! ### User Types
+//!
+//! At any point, a user in the society can be one of a:
+//! * Bidder - A user who has submitted intention of joining the society.
+//! * Candidate - A user who will be voted on to join the society.
+//! * Member - A user who is a member of the society.
+//! * Suspended Member - A member of the society who has accumulated too many strikes
+//! or failed their membership challenge.
+//!
+//! Of the non-suspended members, there is always a:
+//! * Head - A member who is exempt from suspension.
+//! * Defender - A member whose membership is under question and voted on again.
+//!
+//! Of the non-suspended members of the society, a random set of them are chosen as
+//! "skeptics". The mechanics of skeptics is explained in the
+//! [member phase](#member-phase) below.
+//!
+//! ### Mechanics
+//!
+//! #### Rewards
+//!
+//! Members are incentivized to participate in the society through rewards paid
+//! by the Society treasury. These payments have a maturity period that the user
+//! must wait before they are able to access the funds.
+//!
+//! #### Punishments
+//!
+//! Members can be punished by slashing the reward payouts that have not been
+//! collected. Additionally, members can accumulate "strikes", and when they
+//! reach a max strike limit, they become suspended.
+//!
+//! #### Skeptics
+//!
+//! During the voting period, a random set of members are selected as "skeptics".
+//! These skeptics are expected to vote on the current candidates. If they do not vote,
+//! their skeptic status is treated as a rejection vote, the member is deemed
+//! "lazy", and are given a strike per missing vote.
+//!
+//! #### Membership Challenges
+//!
+//! Every challenge rotation period, an existing member will be randomly selected
+//! to defend their membership into society. Then, other members can vote whether
+//! this defender should stay in society. A simple majority wins vote will determine
+//! the outcome of the user. Ties are treated as a failure of the challenge, but
+//! assuming no one else votes, the defender always get a free vote on their
+//! own challenge keeping them in the society. The Head member is exempt from the
+//! negative outcome of a membership challenge.
+//!
+//! #### Society Treasury
+//!
+//! The membership society is independently funded by a treasury managed by this
+//! pallet. Some subset of this treasury is placed in a Society Pot, which is used
+//! to determine the number of accepted bids.
+//!
+//! #### Rate of Growth
+//!
+//! The membership society can grow at a rate of 10 accepted candidates per rotation period up
+//! to the max membership threshold. Once this threshold is met, candidate selections
+//! are stalled until there is space for new members to join. This can be resolved by
+//! voting out existing members through the random challenges or by using governance
+//! to increase the maximum membership count.
+//!
+//! ### User Life Cycle
+//!
+//! A user can go through the following phases:
+//!
+//! ```ignore
+//!           +------->  User  <----------+
+//!           |           +               |
+//!           |           |               |
+//! +----------------------------------------------+
+//! |         |           |               |        |
+//! |         |           v               |        |
+//! |         |        Bidder <-----------+        |
+//! |         |           +               |        |
+//! |         |           |               +        |
+//! |         |           v            Suspended   |
+//! |         |       Candidate +----> Candidate   |
+//! |         |           +               +        |
+//! |         |           |               |        |
+//! |         +           |               |        |
+//! |   Suspended +------>|               |        |
+//! |      Member         |               |        |
+//! |         ^           |               |        |
+//! |         |           v               |        |
+//! |         +-------+ Member <----------+        |
+//! |                                              |
+//! |                                              |
+//! +------------------Society---------------------+
+//! ```
+//!
+//! #### Initialization
+//!
+//! The society is initialized with a single member who is automatically chosen as the Head.
+//!
+//! #### Bid Phase
+//!
+//! New users must have a bid to join the society.
+//!
+//! A user can make a bid by reserving a deposit. Alternatively, an already existing member
+//! can create a bid on a user's behalf by "vouching" for them.
+//!
+//! A bid includes reward information that the user would like to receive for joining
+//! the society. A vouching bid can additionally request some portion of that reward as a tip
+//! to the voucher for vouching for the prospective candidate.
+//!
+//! Every rotation period, Bids are ordered by reward amount, and the pallet
+//! selects as many bids the Society Pot can support for that period.
+//!
+//! These selected bids become candidates and move on to the Candidate phase.
+//! Bids that were not selected stay in the bidder pool until they are selected or
+//! a user chooses to "unbid".
+//!
+//! #### Candidate Phase
+//!
+//! Once a bidder becomes a candidate, members vote whether to approve or reject
+//! that candidate into society. This voting process also happens during a rotation period.
+//!
+//! The approval and rejection criteria for candidates are not set on chain,
+//! and may change for different societies.
+//!
+//! At the end of the rotation period, we collect the votes for a candidate
+//! and randomly select a vote as the final outcome.
+//!
+//! ```ignore
+//!  [ a-accept, r-reject, s-skeptic ]
+//! +----------------------------------+
+//! |                                  |
+//! |  Member   |0|1|2|3|4|5|6|7|8|9|  |
+//! |  -----------------------------   |
+//! |  Vote     |a|a|a|r|s|r|a|a|s|a|  |
+//! |  -----------------------------   |
+//! |  Selected | | | |x| | | | | | |  |
+//! |                                  |
+//! +----------------------------------+
+//!
+//! Result: Rejected
+//! ```
+//!
+//! Each member that voted opposite to this randomly selected vote is punished by
+//! slashing their unclaimed payouts and increasing the number of strikes they have.
+//!
+//! These slashed funds are given to a random user who voted the same as the
+//! selected vote as a reward for participating in the vote.
+//!
+//! If the candidate wins the vote, they receive their bid reward as a future payout.
+//! If the bid was placed by a voucher, they will receive their portion of the reward,
+//! before the rest is paid to the winning candidate.
+//!
+//! One winning candidate is selected as the Head of the members. This is randomly
+//! chosen, weighted by the number of approvals the winning candidates accumulated.
+//!
+//! If the candidate loses the vote, they are suspended and it is up to the Suspension
+//! Judgement origin to determine if the candidate should go through the bidding process
+//! again, should be accepted into the membership society, or rejected and their deposit
+//! slashed.
+//!
+//! #### Member Phase
+//!
+//! Once a candidate becomes a member, their role is to participate in society.
+//!
+//! Regular participation involves voting on candidates who want to join the membership
+//! society, and by voting in the right way, a member will accumulate future payouts.
+//! When a payout matures, members are able to claim those payouts.
+//!
+//! Members can also vouch for users to join the society, and request a "tip" from
+//! the fees the new member would collect by joining the society. This vouching
+//! process is useful in situations where a user may not have enough balance to
+//! satisfy the bid deposit. A member can only vouch one user at a time.
+//!
+//! During rotation periods, a random group of members are selected as "skeptics".
+//! These skeptics are expected to vote on the current candidates. If they do not vote,
+//! their skeptic status is treated as a rejection vote, the member is deemed
+//! "lazy", and are given a strike per missing vote.
+//!
+//! There is a challenge period in parallel to the rotation period. During a challenge period,
+//! a random member is selected to defend their membership to the society. Other members
+//! make a traditional majority-wins vote to determine if the member should stay in the society.
+//! Ties are treated as a failure of the challenge.
+//!
+//! If a member accumulates too many strikes or fails their membership challenge,
+//! they will become suspended. While a member is suspended, they are unable to
+//! claim matured payouts. It is up to the Suspension Judgement origin to determine
+//! if the member should re-enter society or be removed from society with all their
+//! future payouts slashed.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! #### For General Users
+//!
+//! * `bid` - A user can make a bid to join the membership society by reserving a deposit.
+//! * `unbid` - A user can withdraw their bid for entry, the deposit is returned.
+//!
+//! #### For Members
+//!
+//! * `vouch` - A member can place a bid on behalf of a user to join the membership society.
+//! * `unvouch` - A member can revoke their vouch for a user.
+//! * `vote` - A member can vote to approve or reject a candidate's request to join the society.
+//! * `defender_vote` - A member can vote to approve or reject a defender's continued membership
+//! to the society.
+//! * `payout` - A member can claim their first matured payment.
+//! * `unfound` - Allow the founder to unfound the society when they are the only member.
+//!
+//! #### For Super Users
+//!
+//! * `found` - The founder origin can initiate this society. Useful for bootstrapping the Society
+//! pallet on an already running chain.
+//! * `judge_suspended_member` - The suspension judgement origin is able to make
+//! judgement on a suspended member.
+//! * `judge_suspended_candidate` - The suspension judgement origin is able to
+//! make judgement on a suspended candidate.
+//! * `set_max_membership` - The ROOT origin can update the maximum member count for the society.
+//! The max membership count must be greater than 1.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+pub mod weights;
+
+pub mod migrations;
+
+use frame_support::{
+	impl_ensure_origin_with_arg_ignoring_arg,
+	pallet_prelude::*,
+	storage::KeyLenOf,
+	traits::{
+		BalanceStatus, Currency, EnsureOrigin, EnsureOriginWithArg,
+		ExistenceRequirement::AllowDeath, Imbalance, OnUnbalanced, Randomness, ReservableCurrency,
+		StorageVersion,
+	},
+	PalletId,
+};
+use frame_system::pallet_prelude::*;
+use rand_chacha::{
+	rand_core::{RngCore, SeedableRng},
+	ChaChaRng,
+};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{
+		AccountIdConversion, CheckedAdd, CheckedSub, Hash, Saturating, StaticLookup,
+		TrailingZeroInput, Zero,
+	},
+	ArithmeticError::Overflow,
+	Percent, RuntimeDebug,
+};
+use sp_std::prelude::*;
+
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+type BalanceOf<T, I> =
+	<<T as Config<I>>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type NegativeImbalanceOf<T, I> = <<T as Config<I>>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Vote {
+	approve: bool,
+	weight: u32,
+}
+
+/// A judgement by the suspension judgement origin on a suspended candidate.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub enum Judgement {
+	/// The suspension judgement origin takes no direct judgment
+	/// and places the candidate back into the bid pool.
+	Rebid,
+	/// The suspension judgement origin has rejected the candidate's application.
+	Reject,
+	/// The suspension judgement origin approves of the candidate's application.
+	Approve,
+}
+
+/// Details of a payout given as a per-block linear "trickle".
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, Default, TypeInfo)]
+pub struct Payout<Balance, BlockNumber> {
+	/// Total value of the payout.
+	value: Balance,
+	/// Block number at which the payout begins.
+	begin: BlockNumber,
+	/// Total number of blocks over which the payout is spread.
+	duration: BlockNumber,
+	/// Total value paid out so far.
+	paid: Balance,
+}
+
+/// Status of a vouching member.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub enum VouchingStatus {
+	/// Member is currently vouching for a user.
+	Vouching,
+	/// Member is banned from vouching for other members.
+	Banned,
+}
+
+/// Number of strikes that a member has against them.
+pub type StrikeCount = u32;
+
+/// A bid for entry into society.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Bid<AccountId, Balance> {
+	/// The bidder/candidate trying to enter society
+	who: AccountId,
+	/// The kind of bid placed for this bidder/candidate. See `BidKind`.
+	kind: BidKind<AccountId, Balance>,
+	/// The reward that the bidder has requested for successfully joining the society.
+	value: Balance,
+}
+
+/// The index of a round of candidates.
+pub type RoundIndex = u32;
+
+/// The rank of a member.
+pub type Rank = u32;
+
+/// The number of votes.
+pub type VoteCount = u32;
+
+/// Tally of votes.
+#[derive(Default, Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Tally {
+	/// The approval votes.
+	approvals: VoteCount,
+	/// The rejection votes.
+	rejections: VoteCount,
+}
+
+impl Tally {
+	fn more_approvals(&self) -> bool {
+		self.approvals > self.rejections
+	}
+
+	fn more_rejections(&self) -> bool {
+		self.rejections > self.approvals
+	}
+
+	fn clear_approval(&self) -> bool {
+		self.approvals >= (2 * self.rejections).max(1)
+	}
+
+	fn clear_rejection(&self) -> bool {
+		self.rejections >= (2 * self.approvals).max(1)
+	}
+}
+
+/// A bid for entry into society.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct Candidacy<AccountId, Balance> {
+	/// The index of the round where the candidacy began.
+	round: RoundIndex,
+	/// The kind of bid placed for this bidder/candidate. See `BidKind`.
+	kind: BidKind<AccountId, Balance>,
+	/// The reward that the bidder has requested for successfully joining the society.
+	bid: Balance,
+	/// The tally of votes so far.
+	tally: Tally,
+	/// True if the skeptic was already punished for note voting.
+	skeptic_struck: bool,
+}
+
+/// A vote by a member on a candidate application.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub enum BidKind<AccountId, Balance> {
+	/// The given deposit was paid for this bid.
+	Deposit(Balance),
+	/// A member vouched for this bid. The account should be reinstated into `Members` once the
+	/// bid is successful (or if it is rescinded prior to launch).
+	Vouch(AccountId, Balance),
+}
+
+impl<AccountId: PartialEq, Balance> BidKind<AccountId, Balance> {
+	fn is_vouch(&self, v: &AccountId) -> bool {
+		matches!(self, BidKind::Vouch(ref a, _) if a == v)
+	}
+}
+
+pub type PayoutsFor<T, I> =
+	BoundedVec<(BlockNumberFor<T>, BalanceOf<T, I>), <T as Config<I>>::MaxPayouts>;
+
+/// Information concerning a member.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct MemberRecord {
+	rank: Rank,
+	strikes: StrikeCount,
+	vouching: Option<VouchingStatus>,
+	index: u32,
+}
+
+/// Information concerning a member.
+#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, Default)]
+pub struct PayoutRecord<Balance, PayoutsVec> {
+	paid: Balance,
+	payouts: PayoutsVec,
+}
+
+pub type PayoutRecordFor<T, I> = PayoutRecord<
+	BalanceOf<T, I>,
+	BoundedVec<(BlockNumberFor<T>, BalanceOf<T, I>), <T as Config<I>>::MaxPayouts>,
+>;
+
+/// Record for an individual new member who was elevated from a candidate recently.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct IntakeRecord<AccountId, Balance> {
+	who: AccountId,
+	bid: Balance,
+	round: RoundIndex,
+}
+
+pub type IntakeRecordFor<T, I> =
+	IntakeRecord<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>;
+
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+pub struct GroupParams<Balance> {
+	max_members: u32,
+	max_intake: u32,
+	max_strikes: u32,
+	candidate_deposit: Balance,
+}
+
+pub type GroupParamsFor<T, I> = GroupParams<BalanceOf<T, I>>;
+
+pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The societies's pallet id
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// The currency type used for bidding.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// Something that provides randomness in the runtime.
+		type Randomness: Randomness<Self::Hash, BlockNumberFor<Self>>;
+
+		/// The maximum number of strikes before a member gets funds slashed.
+		#[pallet::constant]
+		type GraceStrikes: Get<u32>;
+
+		/// The amount of incentive paid within each period. Doesn't include VoterTip.
+		#[pallet::constant]
+		type PeriodSpend: Get<BalanceOf<Self, I>>;
+
+		/// The number of blocks on which new candidates should be voted on. Together with
+		/// `ClaimPeriod`, this sums to the number of blocks between candidate intake periods.
+		#[pallet::constant]
+		type VotingPeriod: Get<BlockNumberFor<Self>>;
+
+		/// The number of blocks on which new candidates can claim their membership and be the
+		/// named head.
+		#[pallet::constant]
+		type ClaimPeriod: Get<BlockNumberFor<Self>>;
+
+		/// The maximum duration of the payout lock.
+		#[pallet::constant]
+		type MaxLockDuration: Get<BlockNumberFor<Self>>;
+
+		/// The origin that is allowed to call `found`.
+		type FounderSetOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The number of blocks between membership challenges.
+		#[pallet::constant]
+		type ChallengePeriod: Get<BlockNumberFor<Self>>;
+
+		/// The maximum number of payouts a member may have waiting unclaimed.
+		#[pallet::constant]
+		type MaxPayouts: Get<u32>;
+
+		/// The maximum number of bids at once.
+		#[pallet::constant]
+		type MaxBids: Get<u32>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// User is not a member.
+		NotMember,
+		/// User is already a member.
+		AlreadyMember,
+		/// User is suspended.
+		Suspended,
+		/// User is not suspended.
+		NotSuspended,
+		/// Nothing to payout.
+		NoPayout,
+		/// Society already founded.
+		AlreadyFounded,
+		/// Not enough in pot to accept candidate.
+		InsufficientPot,
+		/// Member is already vouching or banned from vouching again.
+		AlreadyVouching,
+		/// Member is not vouching.
+		NotVouchingOnBidder,
+		/// Cannot remove the head of the chain.
+		Head,
+		/// Cannot remove the founder.
+		Founder,
+		/// User has already made a bid.
+		AlreadyBid,
+		/// User is already a candidate.
+		AlreadyCandidate,
+		/// User is not a candidate.
+		NotCandidate,
+		/// Too many members in the society.
+		MaxMembers,
+		/// The caller is not the founder.
+		NotFounder,
+		/// The caller is not the head.
+		NotHead,
+		/// The membership cannot be claimed as the candidate was not clearly approved.
+		NotApproved,
+		/// The candidate cannot be kicked as the candidate was not clearly rejected.
+		NotRejected,
+		/// The candidacy cannot be dropped as the candidate was clearly approved.
+		Approved,
+		/// The candidacy cannot be bestowed as the candidate was clearly rejected.
+		Rejected,
+		/// The candidacy cannot be concluded as the voting is still in progress.
+		InProgress,
+		/// The candidacy cannot be pruned until a full additional intake period has passed.
+		TooEarly,
+		/// The skeptic already voted.
+		Voted,
+		/// The skeptic need not vote on candidates from expired rounds.
+		Expired,
+		/// User is not a bidder.
+		NotBidder,
+		/// There is no defender currently.
+		NoDefender,
+		/// Group doesn't exist.
+		NotGroup,
+		/// The member is already elevated to this rank.
+		AlreadyElevated,
+		/// The skeptic has already been punished for this offence.
+		AlreadyPunished,
+		/// Funds are insufficient to pay off society debts.
+		InsufficientFunds,
+		/// The candidate/defender has no stale votes to remove.
+		NoVotes,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// The society is founded by the given identity.
+		Founded { founder: T::AccountId },
+		/// A membership bid just happened. The given account is the candidate's ID and their offer
+		/// is the second.
+		Bid { candidate_id: T::AccountId, offer: BalanceOf<T, I> },
+		/// A membership bid just happened by vouching. The given account is the candidate's ID and
+		/// their offer is the second. The vouching party is the third.
+		Vouch { candidate_id: T::AccountId, offer: BalanceOf<T, I>, vouching: T::AccountId },
+		/// A candidate was dropped (due to an excess of bids in the system).
+		AutoUnbid { candidate: T::AccountId },
+		/// A candidate was dropped (by their request).
+		Unbid { candidate: T::AccountId },
+		/// A candidate was dropped (by request of who vouched for them).
+		Unvouch { candidate: T::AccountId },
+		/// A group of candidates have been inducted. The batch's primary is the first value, the
+		/// batch in full is the second.
+		Inducted { primary: T::AccountId, candidates: Vec<T::AccountId> },
+		/// A suspended member has been judged.
+		SuspendedMemberJudgement { who: T::AccountId, judged: bool },
+		/// A candidate has been suspended
+		CandidateSuspended { candidate: T::AccountId },
+		/// A member has been suspended
+		MemberSuspended { member: T::AccountId },
+		/// A member has been challenged
+		Challenged { member: T::AccountId },
+		/// A vote has been placed
+		Vote { candidate: T::AccountId, voter: T::AccountId, vote: bool },
+		/// A vote has been placed for a defending member
+		DefenderVote { voter: T::AccountId, vote: bool },
+		/// A new set of \[params\] has been set for the group.
+		NewParams { params: GroupParamsFor<T, I> },
+		/// Society is unfounded.
+		Unfounded { founder: T::AccountId },
+		/// Some funds were deposited into the society account.
+		Deposit { value: BalanceOf<T, I> },
+		/// A \[member\] got elevated to \[rank\].
+		Elevated { member: T::AccountId, rank: Rank },
+	}
+
+	/// Old name generated by `decl_event`.
+	#[deprecated(note = "use `Event` instead")]
+	pub type RawEvent<T, I = ()> = Event<T, I>;
+
+	/// The max number of members for the society at one time.
+	#[pallet::storage]
+	pub(super) type Parameters<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, GroupParamsFor<T, I>, OptionQuery>;
+
+	/// Amount of our account balance that is specifically for the next round's bid(s).
+	#[pallet::storage]
+	pub type Pot<T: Config<I>, I: 'static = ()> = StorageValue<_, BalanceOf<T, I>, ValueQuery>;
+
+	/// The first member.
+	#[pallet::storage]
+	pub type Founder<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
+
+	/// The most primary from the most recently approved rank 0 members in the society.
+	#[pallet::storage]
+	pub type Head<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId>;
+
+	/// A hash of the rules of this society concerning membership. Can only be set once and
+	/// only by the founder.
+	#[pallet::storage]
+	pub type Rules<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Hash>;
+
+	/// The current members and their rank. Doesn't include `SuspendedMembers`.
+	#[pallet::storage]
+	pub type Members<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, MemberRecord, OptionQuery>;
+
+	/// Information regarding rank-0 payouts, past and future.
+	#[pallet::storage]
+	pub type Payouts<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, PayoutRecordFor<T, I>, ValueQuery>;
+
+	/// The number of items in `Members` currently. (Doesn't include `SuspendedMembers`.)
+	#[pallet::storage]
+	pub type MemberCount<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
+
+	/// The current items in `Members` keyed by their unique index. Keys are densely populated
+	/// `0..MemberCount` (does not include `MemberCount`).
+	#[pallet::storage]
+	pub type MemberByIndex<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, u32, T::AccountId, OptionQuery>;
+
+	/// The set of suspended members, with their old membership record.
+	#[pallet::storage]
+	pub type SuspendedMembers<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, MemberRecord, OptionQuery>;
+
+	/// The number of rounds which have passed.
+	#[pallet::storage]
+	pub type RoundCount<T: Config<I>, I: 'static = ()> = StorageValue<_, RoundIndex, ValueQuery>;
+
+	/// The current bids, stored ordered by the value of the bid.
+	#[pallet::storage]
+	pub(super) type Bids<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<Bid<T::AccountId, BalanceOf<T, I>>, T::MaxBids>, ValueQuery>;
+
+	#[pallet::storage]
+	pub type Candidates<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		Candidacy<T::AccountId, BalanceOf<T, I>>,
+		OptionQuery,
+	>;
+
+	/// The current skeptic.
+	#[pallet::storage]
+	pub type Skeptic<T: Config<I>, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	/// Double map from Candidate -> Voter -> (Maybe) Vote.
+	#[pallet::storage]
+	pub(super) type Votes<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Twox64Concat,
+		T::AccountId,
+		Vote,
+		OptionQuery,
+	>;
+
+	/// Clear-cursor for Vote, map from Candidate -> (Maybe) Cursor.
+	#[pallet::storage]
+	pub(super) type VoteClearCursor<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, T::AccountId, BoundedVec<u8, KeyLenOf<Votes<T, I>>>>;
+
+	/// At the end of the claim period, this contains the most recently approved members (along with
+	/// their bid and round ID) who is from the most recent round with the lowest bid. They will
+	/// become the new `Head`.
+	#[pallet::storage]
+	pub type NextHead<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, IntakeRecordFor<T, I>, OptionQuery>;
+
+	/// The number of challenge rounds there have been. Used to identify stale DefenderVotes.
+	#[pallet::storage]
+	pub(super) type ChallengeRoundCount<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, RoundIndex, ValueQuery>;
+
+	/// The defending member currently being challenged, along with a running tally of votes.
+	#[pallet::storage]
+	pub(super) type Defending<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, (T::AccountId, T::AccountId, Tally)>;
+
+	/// Votes for the defender, keyed by challenge round.
+	#[pallet::storage]
+	pub(super) type DefenderVotes<T: Config<I>, I: 'static = ()> =
+		StorageDoubleMap<_, Twox64Concat, RoundIndex, Twox64Concat, T::AccountId, Vote>;
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+			let mut weight = Weight::zero();
+			let weights = T::BlockWeights::get();
+
+			let phrase = b"society_rotation";
+			// we'll need a random seed here.
+			// TODO: deal with randomness freshness
+			// https://github.com/paritytech/substrate/issues/8312
+			let (seed, _) = T::Randomness::random(phrase);
+			// seed needs to be guaranteed to be 32 bytes.
+			let seed = <[u8; 32]>::decode(&mut TrailingZeroInput::new(seed.as_ref()))
+				.expect("input is padded with zeroes; qed");
+			let mut rng = ChaChaRng::from_seed(seed);
+
+			// Run a candidate/membership rotation
+			match Self::period() {
+				Period::Voting { elapsed, .. } if elapsed.is_zero() => {
+					Self::rotate_intake(&mut rng);
+					weight.saturating_accrue(weights.max_block / 20);
+				},
+				_ => {},
+			}
+
+			// Run a challenge rotation
+			if (n % T::ChallengePeriod::get()).is_zero() {
+				Self::rotate_challenge(&mut rng);
+				weight.saturating_accrue(weights.max_block / 20);
+			}
+
+			weight
+		}
+	}
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub pot: BalanceOf<T, I>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			Pot::<T, I>::put(self.pot);
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// A user outside of the society can make a bid for entry.
+		///
+		/// Payment: The group's Candidate Deposit will be reserved for making a bid. It is returned
+		/// when the bid becomes a member, or if the bid calls `unbid`.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Parameters:
+		/// - `value`: A one time payment the bid would like to receive when joining the society.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::bid())]
+		pub fn bid(origin: OriginFor<T>, value: BalanceOf<T, I>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let mut bids = Bids::<T, I>::get();
+			ensure!(!Self::has_bid(&bids, &who), Error::<T, I>::AlreadyBid);
+			ensure!(!Candidates::<T, I>::contains_key(&who), Error::<T, I>::AlreadyCandidate);
+			ensure!(!Members::<T, I>::contains_key(&who), Error::<T, I>::AlreadyMember);
+			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
+
+			let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
+			let deposit = params.candidate_deposit;
+			// NOTE: Reserve must happen before `insert_bid` since that could end up unreserving.
+			T::Currency::reserve(&who, deposit)?;
+			Self::insert_bid(&mut bids, &who, value, BidKind::Deposit(deposit));
+
+			Bids::<T, I>::put(bids);
+			Self::deposit_event(Event::<T, I>::Bid { candidate_id: who, offer: value });
+			Ok(())
+		}
+
+		/// A bidder can remove their bid for entry into society.
+		/// By doing so, they will have their candidate deposit returned or
+		/// they will unvouch their voucher.
+		///
+		/// Payment: The bid deposit is unreserved if the user made a bid.
+		///
+		/// The dispatch origin for this call must be _Signed_ and a bidder.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::unbid())]
+		pub fn unbid(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let mut bids = Bids::<T, I>::get();
+			let pos = bids.iter().position(|bid| bid.who == who).ok_or(Error::<T, I>::NotBidder)?;
+			Self::clean_bid(&bids.remove(pos));
+			Bids::<T, I>::put(bids);
+			Self::deposit_event(Event::<T, I>::Unbid { candidate: who });
+			Ok(())
+		}
+
+		/// As a member, vouch for someone to join society by placing a bid on their behalf.
+		///
+		/// There is no deposit required to vouch for a new bid, but a member can only vouch for
+		/// one bid at a time. If the bid becomes a suspended candidate and ultimately rejected by
+		/// the suspension judgement origin, the member will be banned from vouching again.
+		///
+		/// As a vouching member, you can claim a tip if the candidate is accepted. This tip will
+		/// be paid as a portion of the reward the member will receive for joining the society.
+		///
+		/// The dispatch origin for this call must be _Signed_ and a member.
+		///
+		/// Parameters:
+		/// - `who`: The user who you would like to vouch for.
+		/// - `value`: The total reward to be paid between you and the candidate if they become
+		/// a member in the society.
+		/// - `tip`: Your cut of the total `value` payout when the candidate is inducted into
+		/// the society. Tips larger than `value` will be saturated upon payout.
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::vouch())]
+		pub fn vouch(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			value: BalanceOf<T, I>,
+			tip: BalanceOf<T, I>,
+		) -> DispatchResult {
+			let voucher = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
+
+			// Get bids and check user is not bidding.
+			let mut bids = Bids::<T, I>::get();
+			ensure!(!Self::has_bid(&bids, &who), Error::<T, I>::AlreadyBid);
+
+			// Check user is not already a candidate, member or suspended member.
+			ensure!(!Candidates::<T, I>::contains_key(&who), Error::<T, I>::AlreadyCandidate);
+			ensure!(!Members::<T, I>::contains_key(&who), Error::<T, I>::AlreadyMember);
+			ensure!(!SuspendedMembers::<T, I>::contains_key(&who), Error::<T, I>::Suspended);
+
+			// Check sender can vouch.
+			let mut record = Members::<T, I>::get(&voucher).ok_or(Error::<T, I>::NotMember)?;
+			ensure!(record.vouching.is_none(), Error::<T, I>::AlreadyVouching);
+
+			// Update voucher record.
+			record.vouching = Some(VouchingStatus::Vouching);
+			// Update bids
+			Self::insert_bid(&mut bids, &who, value, BidKind::Vouch(voucher.clone(), tip));
+
+			// Write new state.
+			Members::<T, I>::insert(&voucher, &record);
+			Bids::<T, I>::put(bids);
+			Self::deposit_event(Event::<T, I>::Vouch {
+				candidate_id: who,
+				offer: value,
+				vouching: voucher,
+			});
+			Ok(())
+		}
+
+		/// As a vouching member, unvouch a bid. This only works while vouched user is
+		/// only a bidder (and not a candidate).
+		///
+		/// The dispatch origin for this call must be _Signed_ and a vouching member.
+		///
+		/// Parameters:
+		/// - `pos`: Position in the `Bids` vector of the bid who should be unvouched.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::unvouch())]
+		pub fn unvouch(origin: OriginFor<T>) -> DispatchResult {
+			let voucher = ensure_signed(origin)?;
+
+			let mut bids = Bids::<T, I>::get();
+			let pos = bids
+				.iter()
+				.position(|bid| bid.kind.is_vouch(&voucher))
+				.ok_or(Error::<T, I>::NotVouchingOnBidder)?;
+			let bid = bids.remove(pos);
+			Self::clean_bid(&bid);
+
+			Bids::<T, I>::put(bids);
+			Self::deposit_event(Event::<T, I>::Unvouch { candidate: bid.who });
+			Ok(())
+		}
+
+		/// As a member, vote on a candidate.
+		///
+		/// The dispatch origin for this call must be _Signed_ and a member.
+		///
+		/// Parameters:
+		/// - `candidate`: The candidate that the member would like to bid on.
+		/// - `approve`: A boolean which says if the candidate should be approved (`true`) or
+		///   rejected (`false`).
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::vote())]
+		pub fn vote(
+			origin: OriginFor<T>,
+			candidate: AccountIdLookupOf<T>,
+			approve: bool,
+		) -> DispatchResultWithPostInfo {
+			let voter = ensure_signed(origin)?;
+			let candidate = T::Lookup::lookup(candidate)?;
+
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
+
+			let first_time = Votes::<T, I>::mutate(&candidate, &voter, |v| {
+				let first_time = v.is_none();
+				*v = Some(Self::do_vote(*v, approve, record.rank, &mut candidacy.tally));
+				first_time
+			});
+
+			Candidates::<T, I>::insert(&candidate, &candidacy);
+			Self::deposit_event(Event::<T, I>::Vote { candidate, voter, vote: approve });
+			Ok(if first_time { Pays::No } else { Pays::Yes }.into())
+		}
+
+		/// As a member, vote on the defender.
+		///
+		/// The dispatch origin for this call must be _Signed_ and a member.
+		///
+		/// Parameters:
+		/// - `approve`: A boolean which says if the candidate should be
+		/// approved (`true`) or rejected (`false`).
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::defender_vote())]
+		pub fn defender_vote(origin: OriginFor<T>, approve: bool) -> DispatchResultWithPostInfo {
+			let voter = ensure_signed(origin)?;
+
+			let mut defending = Defending::<T, I>::get().ok_or(Error::<T, I>::NoDefender)?;
+			let record = Members::<T, I>::get(&voter).ok_or(Error::<T, I>::NotMember)?;
+
+			let round = ChallengeRoundCount::<T, I>::get();
+			let first_time = DefenderVotes::<T, I>::mutate(round, &voter, |v| {
+				let first_time = v.is_none();
+				*v = Some(Self::do_vote(*v, approve, record.rank, &mut defending.2));
+				first_time
+			});
+
+			Defending::<T, I>::put(defending);
+			Self::deposit_event(Event::<T, I>::DefenderVote { voter, vote: approve });
+			Ok(if first_time { Pays::No } else { Pays::Yes }.into())
+		}
+
+		/// Transfer the first matured payout for the sender and remove it from the records.
+		///
+		/// NOTE: This extrinsic needs to be called multiple times to claim multiple matured
+		/// payouts.
+		///
+		/// Payment: The member will receive a payment equal to their first matured
+		/// payout to their free balance.
+		///
+		/// The dispatch origin for this call must be _Signed_ and a member with
+		/// payouts remaining.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::payout())]
+		pub fn payout(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			ensure!(
+				Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?.rank == 0,
+				Error::<T, I>::NoPayout
+			);
+			let mut record = Payouts::<T, I>::get(&who);
+
+			if let Some((when, amount)) = record.payouts.first() {
+				if when <= &<frame_system::Pallet<T>>::block_number() {
+					record.paid = record.paid.checked_add(amount).ok_or(Overflow)?;
+					T::Currency::transfer(&Self::payouts(), &who, *amount, AllowDeath)?;
+					record.payouts.remove(0);
+					Payouts::<T, I>::insert(&who, record);
+					return Ok(())
+				}
+			}
+			Err(Error::<T, I>::NoPayout)?
+		}
+
+		/// Repay the payment previously given to the member with the signed origin, remove any
+		/// pending payments, and elevate them from rank 0 to rank 1.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::waive_repay())]
+		pub fn waive_repay(origin: OriginFor<T>, amount: BalanceOf<T, I>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let mut record = Members::<T, I>::get(&who).ok_or(Error::<T, I>::NotMember)?;
+			let mut payout_record = Payouts::<T, I>::get(&who);
+			ensure!(record.rank == 0, Error::<T, I>::AlreadyElevated);
+			ensure!(amount >= payout_record.paid, Error::<T, I>::InsufficientFunds);
+
+			T::Currency::transfer(&who, &Self::account_id(), payout_record.paid, AllowDeath)?;
+			payout_record.paid = Zero::zero();
+			payout_record.payouts.clear();
+			record.rank = 1;
+			Members::<T, I>::insert(&who, record);
+			Payouts::<T, I>::insert(&who, payout_record);
+			Self::deposit_event(Event::<T, I>::Elevated { member: who, rank: 1 });
+
+			Ok(())
+		}
+
+		/// Found the society.
+		///
+		/// This is done as a discrete action in order to allow for the
+		/// pallet to be included into a running chain and can only be done once.
+		///
+		/// The dispatch origin for this call must be from the _FounderSetOrigin_.
+		///
+		/// Parameters:
+		/// - `founder` - The first member and head of the newly founded society.
+		/// - `max_members` - The initial max number of members for the society.
+		/// - `max_intake` - The maximum number of candidates per intake period.
+		/// - `max_strikes`: The maximum number of strikes a member may get before they become
+		///   suspended and may only be reinstated by the founder.
+		/// - `candidate_deposit`: The deposit required to make a bid for membership of the group.
+		/// - `rules` - The rules of this society concerning membership.
+		///
+		/// Complexity: O(1)
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::found_society())]
+		pub fn found_society(
+			origin: OriginFor<T>,
+			founder: AccountIdLookupOf<T>,
+			max_members: u32,
+			max_intake: u32,
+			max_strikes: u32,
+			candidate_deposit: BalanceOf<T, I>,
+			rules: Vec<u8>,
+		) -> DispatchResult {
+			T::FounderSetOrigin::ensure_origin(origin)?;
+			let founder = T::Lookup::lookup(founder)?;
+			ensure!(!Head::<T, I>::exists(), Error::<T, I>::AlreadyFounded);
+			ensure!(max_members > 1, Error::<T, I>::MaxMembers);
+			// This should never fail in the context of this function...
+			let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
+			Parameters::<T, I>::put(params);
+			Self::insert_member(&founder, 1)?;
+			Head::<T, I>::put(&founder);
+			Founder::<T, I>::put(&founder);
+			Rules::<T, I>::put(T::Hashing::hash(&rules));
+			Self::deposit_event(Event::<T, I>::Founded { founder });
+			Ok(())
+		}
+
+		/// Dissolve the society and remove all members.
+		///
+		/// The dispatch origin for this call must be Signed, and the signing account must be both
+		/// the `Founder` and the `Head`. This implies that it may only be done when there is one
+		/// member.
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::dissolve())]
+		pub fn dissolve(origin: OriginFor<T>) -> DispatchResult {
+			let founder = ensure_signed(origin)?;
+			ensure!(Founder::<T, I>::get().as_ref() == Some(&founder), Error::<T, I>::NotFounder);
+			ensure!(MemberCount::<T, I>::get() == 1, Error::<T, I>::NotHead);
+
+			let _ = Members::<T, I>::clear(u32::MAX, None);
+			MemberCount::<T, I>::kill();
+			let _ = MemberByIndex::<T, I>::clear(u32::MAX, None);
+			let _ = SuspendedMembers::<T, I>::clear(u32::MAX, None);
+			let _ = Payouts::<T, I>::clear(u32::MAX, None);
+			let _ = Votes::<T, I>::clear(u32::MAX, None);
+			let _ = VoteClearCursor::<T, I>::clear(u32::MAX, None);
+			Head::<T, I>::kill();
+			NextHead::<T, I>::kill();
+			Founder::<T, I>::kill();
+			Rules::<T, I>::kill();
+			Parameters::<T, I>::kill();
+			Pot::<T, I>::kill();
+			RoundCount::<T, I>::kill();
+			Bids::<T, I>::kill();
+			Skeptic::<T, I>::kill();
+			ChallengeRoundCount::<T, I>::kill();
+			Defending::<T, I>::kill();
+			let _ = DefenderVotes::<T, I>::clear(u32::MAX, None);
+			let _ = Candidates::<T, I>::clear(u32::MAX, None);
+			Self::deposit_event(Event::<T, I>::Unfounded { founder });
+			Ok(())
+		}
+
+		/// Allow suspension judgement origin to make judgement on a suspended member.
+		///
+		/// If a suspended member is forgiven, we simply add them back as a member, not affecting
+		/// any of the existing storage items for that member.
+		///
+		/// If a suspended member is rejected, remove all associated storage items, including
+		/// their payouts, and remove any vouched bids they currently have.
+		///
+		/// The dispatch origin for this call must be Signed from the Founder.
+		///
+		/// Parameters:
+		/// - `who` - The suspended member to be judged.
+		/// - `forgive` - A boolean representing whether the suspension judgement origin forgives
+		///   (`true`) or rejects (`false`) a suspended member.
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::judge_suspended_member())]
+		pub fn judge_suspended_member(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			forgive: bool,
+		) -> DispatchResultWithPostInfo {
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
+			let who = T::Lookup::lookup(who)?;
+			let record = SuspendedMembers::<T, I>::get(&who).ok_or(Error::<T, I>::NotSuspended)?;
+			if forgive {
+				// Try to add member back to society. Can fail with `MaxMembers` limit.
+				Self::reinstate_member(&who, record.rank)?;
+			} else {
+				let payout_record = Payouts::<T, I>::take(&who);
+				let total = payout_record
+					.payouts
+					.into_iter()
+					.map(|x| x.1)
+					.fold(Zero::zero(), |acc: BalanceOf<T, I>, x| acc.saturating_add(x));
+				Self::unreserve_payout(total);
+			}
+			SuspendedMembers::<T, I>::remove(&who);
+			Self::deposit_event(Event::<T, I>::SuspendedMemberJudgement { who, judged: forgive });
+			Ok(Pays::No.into())
+		}
+
+		/// Change the maximum number of members in society and the maximum number of new candidates
+		/// in a single intake period.
+		///
+		/// The dispatch origin for this call must be Signed by the Founder.
+		///
+		/// Parameters:
+		/// - `max_members` - The maximum number of members for the society. This must be no less
+		///   than the current number of members.
+		/// - `max_intake` - The maximum number of candidates per intake period.
+		/// - `max_strikes`: The maximum number of strikes a member may get before they become
+		///   suspended and may only be reinstated by the founder.
+		/// - `candidate_deposit`: The deposit required to make a bid for membership of the group.
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::set_parameters())]
+		pub fn set_parameters(
+			origin: OriginFor<T>,
+			max_members: u32,
+			max_intake: u32,
+			max_strikes: u32,
+			candidate_deposit: BalanceOf<T, I>,
+		) -> DispatchResult {
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
+			ensure!(max_members >= MemberCount::<T, I>::get(), Error::<T, I>::MaxMembers);
+			let params = GroupParams { max_members, max_intake, max_strikes, candidate_deposit };
+			Parameters::<T, I>::put(&params);
+			Self::deposit_event(Event::<T, I>::NewParams { params });
+			Ok(())
+		}
+
+		/// Punish the skeptic with a strike if they did not vote on a candidate. Callable by the
+		/// candidate.
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::punish_skeptic())]
+		pub fn punish_skeptic(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let candidate = ensure_signed(origin)?;
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!candidacy.skeptic_struck, Error::<T, I>::AlreadyPunished);
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			let punished = Self::check_skeptic(&candidate, &mut candidacy);
+			Candidates::<T, I>::insert(&candidate, candidacy);
+			Ok(if punished { Pays::No } else { Pays::Yes }.into())
+		}
+
+		/// Transform an approved candidate into a member. Callable only by the
+		/// the candidate, and only after the period for voting has ended.
+		#[pallet::call_index(13)]
+		#[pallet::weight(T::WeightInfo::claim_membership())]
+		pub fn claim_membership(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let candidate = ensure_signed(origin)?;
+			let candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(candidacy.tally.clear_approval(), Error::<T, I>::NotApproved);
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			Self::induct_member(candidate, candidacy, 0)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Transform an approved candidate into a member. Callable only by the Signed origin of the
+		/// Founder, only after the period for voting has ended and only when the candidate is not
+		/// clearly rejected.
+		#[pallet::call_index(14)]
+		#[pallet::weight(T::WeightInfo::bestow_membership())]
+		pub fn bestow_membership(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
+			let candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!candidacy.tally.clear_rejection(), Error::<T, I>::Rejected);
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			Self::induct_member(candidate, candidacy, 0)?;
+			Ok(Pays::No.into())
+		}
+
+		/// Remove the candidate's application from the society. Callable only by the Signed origin
+		/// of the Founder, only after the period for voting has ended, and only when they do not
+		/// have a clear approval.
+		///
+		/// Any bid deposit is lost and voucher is banned.
+		#[pallet::call_index(15)]
+		#[pallet::weight(T::WeightInfo::kick_candidate())]
+		pub fn kick_candidate(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			ensure!(
+				Some(ensure_signed(origin)?) == Founder::<T, I>::get(),
+				Error::<T, I>::NotFounder
+			);
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(!Self::in_progress(candidacy.round), Error::<T, I>::InProgress);
+			ensure!(!candidacy.tally.clear_approval(), Error::<T, I>::Approved);
+			Self::check_skeptic(&candidate, &mut candidacy);
+			Self::reject_candidate(&candidate, &candidacy.kind);
+			Candidates::<T, I>::remove(&candidate);
+			Ok(Pays::No.into())
+		}
+
+		/// Remove the candidate's application from the society. Callable only by the candidate.
+		///
+		/// Any bid deposit is lost and voucher is banned.
+		#[pallet::call_index(16)]
+		#[pallet::weight(T::WeightInfo::resign_candidacy())]
+		pub fn resign_candidacy(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			let candidate = ensure_signed(origin)?;
+			let mut candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			if !Self::in_progress(candidacy.round) {
+				Self::check_skeptic(&candidate, &mut candidacy);
+			}
+			Self::reject_candidate(&candidate, &candidacy.kind);
+			Candidates::<T, I>::remove(&candidate);
+			Ok(Pays::No.into())
+		}
+
+		/// Remove a `candidate`'s failed application from the society. Callable by any
+		/// signed origin but only at the end of the subsequent round and only for
+		/// a candidate with more rejections than approvals.
+		///
+		/// The bid deposit is lost and the voucher is banned.
+		#[pallet::call_index(17)]
+		#[pallet::weight(T::WeightInfo::drop_candidate())]
+		pub fn drop_candidate(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			let candidacy =
+				Candidates::<T, I>::get(&candidate).ok_or(Error::<T, I>::NotCandidate)?;
+			ensure!(candidacy.tally.clear_rejection(), Error::<T, I>::NotRejected);
+			ensure!(RoundCount::<T, I>::get() > candidacy.round + 1, Error::<T, I>::TooEarly);
+			Self::reject_candidate(&candidate, &candidacy.kind);
+			Candidates::<T, I>::remove(&candidate);
+			Ok(Pays::No.into())
+		}
+
+		/// Remove up to `max` stale votes for the given `candidate`.
+		///
+		/// May be called by any Signed origin, but only after the candidate's candidacy is ended.
+		#[pallet::call_index(18)]
+		#[pallet::weight(T::WeightInfo::cleanup_candidacy())]
+		pub fn cleanup_candidacy(
+			origin: OriginFor<T>,
+			candidate: T::AccountId,
+			max: u32,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			ensure!(!Candidates::<T, I>::contains_key(&candidate), Error::<T, I>::InProgress);
+			let maybe_cursor = VoteClearCursor::<T, I>::get(&candidate);
+			let r =
+				Votes::<T, I>::clear_prefix(&candidate, max, maybe_cursor.as_ref().map(|x| &x[..]));
+			if let Some(cursor) = r.maybe_cursor {
+				VoteClearCursor::<T, I>::insert(&candidate, BoundedVec::truncate_from(cursor));
+			}
+			Ok(if r.loops == 0 { Pays::Yes } else { Pays::No }.into())
+		}
+
+		/// Remove up to `max` stale votes for the defender in the given `challenge_round`.
+		///
+		/// May be called by any Signed origin, but only after the challenge round is ended.
+		#[pallet::call_index(19)]
+		#[pallet::weight(T::WeightInfo::cleanup_challenge())]
+		pub fn cleanup_challenge(
+			origin: OriginFor<T>,
+			challenge_round: RoundIndex,
+			max: u32,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			ensure!(
+				challenge_round < ChallengeRoundCount::<T, I>::get(),
+				Error::<T, I>::InProgress
+			);
+			let _ = DefenderVotes::<T, I>::clear_prefix(challenge_round, max, None);
+			// clear_prefix() v2 is always returning backend = 0, ignoring it till v3.
+			// let (_, backend, _, _) = r.deconstruct();
+			// if backend == 0 { return Err(Error::<T, I>::NoVotes.into()); };
+			Ok(Pays::No.into())
+		}
+	}
+}
+
+/// Simple ensure origin struct to filter for the founder account.
+pub struct EnsureFounder<T>(sp_std::marker::PhantomData<T>);
+impl<T: Config> EnsureOrigin<<T as frame_system::Config>::RuntimeOrigin> for EnsureFounder<T> {
+	type Success = T::AccountId;
+	fn try_origin(o: T::RuntimeOrigin) -> Result<Self::Success, T::RuntimeOrigin> {
+		o.into().and_then(|o| match (o, Founder::<T>::get()) {
+			(frame_system::RawOrigin::Signed(ref who), Some(ref f)) if who == f => Ok(who.clone()),
+			(r, _) => Err(T::RuntimeOrigin::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<T::RuntimeOrigin, ()> {
+		let founder = Founder::<T>::get().ok_or(())?;
+		Ok(T::RuntimeOrigin::from(frame_system::RawOrigin::Signed(founder)))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl<{ T: Config, A }>
+		EnsureOriginWithArg<T::RuntimeOrigin, A> for EnsureFounder<T>
+	{}
+}
+
+struct InputFromRng<'a, T>(&'a mut T);
+impl<'a, T: RngCore> codec::Input for InputFromRng<'a, T> {
+	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
+		return Ok(None)
+	}
+
+	fn read(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
+		self.0.fill_bytes(into);
+		Ok(())
+	}
+}
+
+pub enum Period<BlockNumber> {
+	Voting { elapsed: BlockNumber, more: BlockNumber },
+	Claim { elapsed: BlockNumber, more: BlockNumber },
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Get the period we are currently in.
+	fn period() -> Period<BlockNumberFor<T>> {
+		let claim_period = T::ClaimPeriod::get();
+		let voting_period = T::VotingPeriod::get();
+		let rotation_period = voting_period + claim_period;
+		let now = frame_system::Pallet::<T>::block_number();
+		let phase = now % rotation_period;
+		if phase < voting_period {
+			Period::Voting { elapsed: phase, more: voting_period - phase }
+		} else {
+			Period::Claim { elapsed: phase - voting_period, more: rotation_period - phase }
+		}
+	}
+
+	/// Returns true if the given `target_round` is still in its initial voting phase.
+	fn in_progress(target_round: RoundIndex) -> bool {
+		let round = RoundCount::<T, I>::get();
+		target_round == round && matches!(Self::period(), Period::Voting { .. })
+	}
+
+	/// Returns the new vote.
+	fn do_vote(maybe_old: Option<Vote>, approve: bool, rank: Rank, tally: &mut Tally) -> Vote {
+		match maybe_old {
+			Some(Vote { approve: true, weight }) => tally.approvals.saturating_reduce(weight),
+			Some(Vote { approve: false, weight }) => tally.rejections.saturating_reduce(weight),
+			_ => {},
+		}
+		let weight_root = rank + 1;
+		let weight = weight_root * weight_root;
+		match approve {
+			true => tally.approvals.saturating_accrue(1),
+			false => tally.rejections.saturating_accrue(1),
+		}
+		Vote { approve, weight }
+	}
+
+	/// Returns `true` if a punishment was given.
+	fn check_skeptic(
+		candidate: &T::AccountId,
+		candidacy: &mut Candidacy<T::AccountId, BalanceOf<T, I>>,
+	) -> bool {
+		if RoundCount::<T, I>::get() != candidacy.round || candidacy.skeptic_struck {
+			return false
+		}
+		// We expect the skeptic to have voted.
+		let skeptic = match Skeptic::<T, I>::get() {
+			Some(s) => s,
+			None => return false,
+		};
+		let maybe_vote = Votes::<T, I>::get(&candidate, &skeptic);
+		let approved = candidacy.tally.clear_approval();
+		let rejected = candidacy.tally.clear_rejection();
+		match (maybe_vote, approved, rejected) {
+			(None, _, _) |
+			(Some(Vote { approve: true, .. }), false, true) |
+			(Some(Vote { approve: false, .. }), true, false) => {
+				// Can't do much if the punishment doesn't work out.
+				if Self::strike_member(&skeptic).is_ok() {
+					candidacy.skeptic_struck = true;
+					true
+				} else {
+					false
+				}
+			},
+			_ => false,
+		}
+	}
+
+	/// End the current challenge period and start a new one.
+	fn rotate_challenge(rng: &mut impl RngCore) {
+		let mut next_defender = None;
+		let mut round = ChallengeRoundCount::<T, I>::get();
+
+		// End current defender rotation
+		if let Some((defender, skeptic, tally)) = Defending::<T, I>::get() {
+			// We require strictly more approvals, since the member should be voting for themselves.
+			if !tally.more_approvals() {
+				// Member has failed the challenge: Suspend them. This will fail if they are Head
+				// or Founder, in which case we ignore.
+				let _ = Self::suspend_member(&defender);
+			}
+
+			// Check defender skeptic voted and that their vote was with the majority.
+			let skeptic_vote = DefenderVotes::<T, I>::get(round, &skeptic);
+			match (skeptic_vote, tally.more_approvals(), tally.more_rejections()) {
+				(None, _, _) |
+				(Some(Vote { approve: true, .. }), false, true) |
+				(Some(Vote { approve: false, .. }), true, false) => {
+					// Punish skeptic and challenge them next.
+					let _ = Self::strike_member(&skeptic);
+					let founder = Founder::<T, I>::get();
+					let head = Head::<T, I>::get();
+					if Some(&skeptic) != founder.as_ref() && Some(&skeptic) != head.as_ref() {
+						next_defender = Some(skeptic);
+					}
+				},
+				_ => {},
+			}
+			round.saturating_inc();
+			ChallengeRoundCount::<T, I>::put(round);
+		}
+
+		// Avoid challenging if there's only two members since we never challenge the Head or
+		// the Founder.
+		if MemberCount::<T, I>::get() > 2 {
+			let defender = next_defender
+				.or_else(|| Self::pick_defendent(rng))
+				.expect("exited if members empty; qed");
+			let skeptic =
+				Self::pick_member_except(rng, &defender).expect("exited if members empty; qed");
+			Self::deposit_event(Event::<T, I>::Challenged { member: defender.clone() });
+			Defending::<T, I>::put((defender, skeptic, Tally::default()));
+		} else {
+			Defending::<T, I>::kill();
+		}
+	}
+
+	/// End the current intake period and begin a new one.
+	///
+	/// ---------------------------------------------
+	///  #10  || #11           _              || #12
+	///       || Voting        | Claiming     ||
+	/// ---------------------------------------------
+	fn rotate_intake(rng: &mut impl RngCore) {
+		// We assume there's at least one member or this logic won't work.
+		let member_count = MemberCount::<T, I>::get();
+		if member_count < 1 {
+			return
+		}
+		let maybe_head = NextHead::<T, I>::take();
+		if let Some(head) = maybe_head {
+			Head::<T, I>::put(&head.who);
+		}
+
+		// Bump the pot by at most `PeriodSpend`, but less if there's not very much left in our
+		// account.
+		let mut pot = Pot::<T, I>::get();
+		let unaccounted = T::Currency::free_balance(&Self::account_id()).saturating_sub(pot);
+		pot.saturating_accrue(T::PeriodSpend::get().min(unaccounted / 2u8.into()));
+		Pot::<T, I>::put(&pot);
+
+		// Bump round and create the new intake.
+		let mut round_count = RoundCount::<T, I>::get();
+		round_count.saturating_inc();
+		let candidate_count = Self::select_new_candidates(round_count, member_count, pot);
+		if candidate_count > 0 {
+			// Select a member at random and make them the skeptic for this round.
+			let skeptic = Self::pick_member(rng).expect("exited if members empty; qed");
+			Skeptic::<T, I>::put(skeptic);
+		}
+		RoundCount::<T, I>::put(round_count);
+	}
+
+	/// Remove a selection of bidding accounts such that the total bids is no greater than `Pot` and
+	/// the number of bids would not surpass `MaxMembers` if all were accepted. At most one bid may
+	/// be zero.
+	///
+	/// Candidates are inserted from each bidder.
+	///
+	/// The number of candidates inserted are returned.
+	pub fn select_new_candidates(
+		round: RoundIndex,
+		member_count: u32,
+		pot: BalanceOf<T, I>,
+	) -> u32 {
+		// Get the number of left-most bidders whose bids add up to less than `pot`.
+		let mut bids = Bids::<T, I>::get();
+		let params = match Parameters::<T, I>::get() {
+			Some(params) => params,
+			None => return 0,
+		};
+		let max_selections: u32 = params
+			.max_intake
+			.min(params.max_members.saturating_sub(member_count))
+			.min(bids.len() as u32);
+
+		let mut selections = 0;
+		// A running total of the cost to onboard these bids
+		let mut total_cost: BalanceOf<T, I> = Zero::zero();
+
+		bids.retain(|bid| {
+			// We only accept a zero bid as the first selection.
+			total_cost.saturating_accrue(bid.value);
+			let accept = selections < max_selections &&
+				(!bid.value.is_zero() || selections == 0) &&
+				total_cost <= pot;
+			if accept {
+				let candidacy = Candidacy {
+					round,
+					kind: bid.kind.clone(),
+					bid: bid.value,
+					tally: Default::default(),
+					skeptic_struck: false,
+				};
+				Candidates::<T, I>::insert(&bid.who, candidacy);
+				selections.saturating_inc();
+			}
+			!accept
+		});
+
+		// No need to reset Bids if we're not taking anything.
+		Bids::<T, I>::put(&bids);
+		selections
+	}
+
+	/// Puts a bid into storage ordered by smallest to largest value.
+	/// Allows a maximum of 1000 bids in queue, removing largest value people first.
+	fn insert_bid(
+		bids: &mut BoundedVec<Bid<T::AccountId, BalanceOf<T, I>>, T::MaxBids>,
+		who: &T::AccountId,
+		value: BalanceOf<T, I>,
+		bid_kind: BidKind<T::AccountId, BalanceOf<T, I>>,
+	) {
+		let pos = bids.iter().position(|bid| bid.value > value).unwrap_or(bids.len());
+		let r = bids.force_insert_keep_left(pos, Bid { value, who: who.clone(), kind: bid_kind });
+		let maybe_discarded = match r {
+			Ok(x) => x,
+			Err(x) => Some(x),
+		};
+		if let Some(discarded) = maybe_discarded {
+			Self::clean_bid(&discarded);
+			Self::deposit_event(Event::<T, I>::AutoUnbid { candidate: discarded.who });
+		}
+	}
+
+	/// Either unreserve the deposit or free up the vouching member.
+	///
+	/// In neither case can we do much if the action isn't completable, but there's
+	/// no reason that either should fail.
+	///
+	/// WARNING: This alters the voucher item of `Members`. You must ensure that you do not
+	/// accidentally overwrite it with an older value after calling this.
+	fn clean_bid(bid: &Bid<T::AccountId, BalanceOf<T, I>>) {
+		match &bid.kind {
+			BidKind::Deposit(deposit) => {
+				let err_amount = T::Currency::unreserve(&bid.who, *deposit);
+				debug_assert!(err_amount.is_zero());
+			},
+			BidKind::Vouch(voucher, _) => {
+				Members::<T, I>::mutate_extant(voucher, |record| record.vouching = None);
+			},
+		}
+	}
+
+	/// Either repatriate the deposit into the Society account or ban the vouching member.
+	///
+	/// In neither case can we do much if the action isn't completable, but there's
+	/// no reason that either should fail.
+	///
+	/// WARNING: This alters the voucher item of `Members`. You must ensure that you do not
+	/// accidentally overwrite it with an older value after calling this.
+	fn reject_candidate(who: &T::AccountId, kind: &BidKind<T::AccountId, BalanceOf<T, I>>) {
+		match kind {
+			BidKind::Deposit(deposit) => {
+				let pot = Self::account_id();
+				let free = BalanceStatus::Free;
+				let r = T::Currency::repatriate_reserved(&who, &pot, *deposit, free);
+				debug_assert!(r.is_ok());
+			},
+			BidKind::Vouch(voucher, _) => {
+				Members::<T, I>::mutate_extant(voucher, |record| {
+					record.vouching = Some(VouchingStatus::Banned)
+				});
+			},
+		}
+	}
+
+	/// Check a user has a bid.
+	fn has_bid(bids: &Vec<Bid<T::AccountId, BalanceOf<T, I>>>, who: &T::AccountId) -> bool {
+		// Bids are ordered by `value`, so we cannot binary search for a user.
+		bids.iter().any(|bid| bid.who == *who)
+	}
+
+	/// Add a member to the members list. If the user is already a member, do nothing. Can fail when
+	/// `MaxMember` limit is reached, but in that case it has no side-effects.
+	///
+	/// Set the `payouts` for the member. NOTE: This *WILL NOT RESERVE THE FUNDS TO MAKE THE
+	/// PAYOUT*. Only set this to be non-empty if you already have the funds reserved in the Payouts
+	/// account.
+	///
+	/// NOTE: Generally you should not use this, and instead use `add_new_member` or
+	/// `reinstate_member`, whose names clearly match the desired intention.
+	fn insert_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
+		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
+		ensure!(MemberCount::<T, I>::get() < params.max_members, Error::<T, I>::MaxMembers);
+		let index = MemberCount::<T, I>::mutate(|i| {
+			i.saturating_accrue(1);
+			*i - 1
+		});
+		let record = MemberRecord { rank, strikes: 0, vouching: None, index };
+		Members::<T, I>::insert(who, record);
+		MemberByIndex::<T, I>::insert(index, who);
+		Ok(())
+	}
+
+	/// Add a member back to the members list, setting their `rank` and `payouts`.
+	///
+	/// Can fail when `MaxMember` limit is reached, but in that case it has no side-effects.
+	///
+	/// The `payouts` value must be exactly as it was prior to suspension since no further funds
+	/// will be reserved.
+	fn reinstate_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
+		Self::insert_member(who, rank)
+	}
+
+	/// Add a member to the members list. If the user is already a member, do nothing. Can fail when
+	/// `MaxMember` limit is reached, but in that case it has no side-effects.
+	fn add_new_member(who: &T::AccountId, rank: Rank) -> DispatchResult {
+		Self::insert_member(who, rank)
+	}
+
+	/// Induct a new member into the set.
+	fn induct_member(
+		candidate: T::AccountId,
+		mut candidacy: Candidacy<T::AccountId, BalanceOf<T, I>>,
+		rank: Rank,
+	) -> DispatchResult {
+		Self::add_new_member(&candidate, rank)?;
+		Self::check_skeptic(&candidate, &mut candidacy);
+
+		let next_head = NextHead::<T, I>::get()
+			.filter(|old| {
+				old.round > candidacy.round ||
+					old.round == candidacy.round && old.bid < candidacy.bid
+			})
+			.unwrap_or_else(|| IntakeRecord {
+				who: candidate.clone(),
+				bid: candidacy.bid,
+				round: candidacy.round,
+			});
+		NextHead::<T, I>::put(next_head);
+
+		let now = <frame_system::Pallet<T>>::block_number();
+		let maturity = now + Self::lock_duration(MemberCount::<T, I>::get());
+		Self::reward_bidder(&candidate, candidacy.bid, candidacy.kind, maturity);
+
+		Candidates::<T, I>::remove(&candidate);
+		Ok(())
+	}
+
+	fn strike_member(who: &T::AccountId) -> DispatchResult {
+		let mut record = Members::<T, I>::get(who).ok_or(Error::<T, I>::NotMember)?;
+		record.strikes.saturating_inc();
+		Members::<T, I>::insert(who, &record);
+		// ^^^ Keep the member record mutation self-contained as we might be suspending them later
+		// in this function.
+
+		if record.strikes >= T::GraceStrikes::get() {
+			// Too many strikes: slash the payout in half.
+			let total_payout = Payouts::<T, I>::get(who)
+				.payouts
+				.iter()
+				.fold(BalanceOf::<T, I>::zero(), |acc, x| acc.saturating_add(x.1));
+			Self::slash_payout(who, total_payout / 2u32.into());
+		}
+
+		let params = Parameters::<T, I>::get().ok_or(Error::<T, I>::NotGroup)?;
+		if record.strikes >= params.max_strikes {
+			// Way too many strikes: suspend.
+			let _ = Self::suspend_member(who);
+		}
+		Ok(())
+	}
+
+	/// Remove a member from the members list and return the candidacy.
+	///
+	/// If the member was vouching, then this will be reset. Any bidders that the member was
+	/// vouching for will be cancelled unless they are already selected as candidates (in which case
+	/// they will be able to stand).
+	///
+	/// If the member has existing payouts, they will be retained in the resultant `MemberRecord`
+	/// and the funds will remain reserved.
+	///
+	/// The Head and the Founder may never be removed.
+	pub fn remove_member(m: &T::AccountId) -> Result<MemberRecord, DispatchError> {
+		ensure!(Head::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Head);
+		ensure!(Founder::<T, I>::get().as_ref() != Some(m), Error::<T, I>::Founder);
+		if let Some(mut record) = Members::<T, I>::get(m) {
+			let index = record.index;
+			let last_index = MemberCount::<T, I>::mutate(|i| {
+				i.saturating_reduce(1);
+				*i
+			});
+			if index != last_index {
+				// Move the member with the last index down to the index of the member to be
+				// removed.
+				if let Some(other) = MemberByIndex::<T, I>::get(last_index) {
+					MemberByIndex::<T, I>::insert(index, &other);
+					Members::<T, I>::mutate(other, |m_r| {
+						if let Some(r) = m_r {
+							r.index = index
+						}
+					});
+				} else {
+					debug_assert!(false, "ERROR: No member at the last index position?");
+				}
+			}
+
+			MemberByIndex::<T, I>::remove(last_index);
+			Members::<T, I>::remove(m);
+			// Remove their vouching status, potentially unbanning them in the future.
+			if record.vouching.take() == Some(VouchingStatus::Vouching) {
+				// Try to remove their bid if they are vouching.
+				// If their vouch is already a candidate, do nothing.
+				Bids::<T, I>::mutate(|bids|
+					// Try to find the matching bid
+					if let Some(pos) = bids.iter().position(|b| b.kind.is_vouch(&m)) {
+						// Remove the bid, and emit an event
+						let vouched = bids.remove(pos).who;
+						Self::deposit_event(Event::<T, I>::Unvouch { candidate: vouched });
+					}
+				);
+			}
+			Ok(record)
+		} else {
+			Err(Error::<T, I>::NotMember.into())
+		}
+	}
+
+	/// Remove a member from the members set and add them to the suspended members.
+	///
+	/// If the member was vouching, then this will be reset. Any bidders that the member was
+	/// vouching for will be cancelled unless they are already selected as candidates (in which case
+	/// they will be able to stand).
+	fn suspend_member(who: &T::AccountId) -> DispatchResult {
+		let record = Self::remove_member(&who)?;
+		SuspendedMembers::<T, I>::insert(who, record);
+		Self::deposit_event(Event::<T, I>::MemberSuspended { member: who.clone() });
+		Ok(())
+	}
+
+	/// Select a member at random, given the RNG `rng`.
+	///
+	/// If no members exist (or the state is inconsistent), then `None` may be returned.
+	fn pick_member(rng: &mut impl RngCore) -> Option<T::AccountId> {
+		let member_count = MemberCount::<T, I>::get();
+		if member_count == 0 {
+			return None
+		}
+		let random_index = rng.next_u32() % member_count;
+		MemberByIndex::<T, I>::get(random_index)
+	}
+
+	/// Select a member at random except `exception`, given the RNG `rng`.
+	///
+	/// If `exception` is the only member (or the state is inconsistent), then `None` may be
+	/// returned.
+	fn pick_member_except(
+		rng: &mut impl RngCore,
+		exception: &T::AccountId,
+	) -> Option<T::AccountId> {
+		let member_count = MemberCount::<T, I>::get();
+		if member_count <= 1 {
+			return None
+		}
+		let random_index = rng.next_u32() % (member_count - 1);
+		let pick = MemberByIndex::<T, I>::get(random_index);
+		if pick.as_ref() == Some(exception) {
+			MemberByIndex::<T, I>::get(member_count - 1)
+		} else {
+			pick
+		}
+	}
+
+	/// Select a member who is able to defend at random, given the RNG `rng`.
+	///
+	/// If only the Founder and Head members exist (or the state is inconsistent), then `None`
+	/// may be returned.
+	fn pick_defendent(rng: &mut impl RngCore) -> Option<T::AccountId> {
+		let member_count = MemberCount::<T, I>::get();
+		if member_count <= 2 {
+			return None
+		}
+		// Founder is always at index 0, so we should never pick that one.
+		// Head will typically but not always be the highest index. We assume it is for now and
+		// fix it up later if not.
+		let head = Head::<T, I>::get();
+		let pickable_count = member_count - if head.is_some() { 2 } else { 1 };
+		let random_index = rng.next_u32() % pickable_count + 1;
+		let pick = MemberByIndex::<T, I>::get(random_index);
+		if pick == head && head.is_some() {
+			// Turns out that head was not the last index since we managed to pick it. Exchange our
+			// pick for the last index.
+			MemberByIndex::<T, I>::get(member_count - 1)
+		} else {
+			pick
+		}
+	}
+
+	/// Pay an accepted candidate their bid value.
+	fn reward_bidder(
+		candidate: &T::AccountId,
+		value: BalanceOf<T, I>,
+		kind: BidKind<T::AccountId, BalanceOf<T, I>>,
+		maturity: BlockNumberFor<T>,
+	) {
+		let value = match kind {
+			BidKind::Deposit(deposit) => {
+				// In the case that a normal deposit bid is accepted we unreserve
+				// the deposit.
+				let err_amount = T::Currency::unreserve(candidate, deposit);
+				debug_assert!(err_amount.is_zero());
+				value
+			},
+			BidKind::Vouch(voucher, tip) => {
+				// Check that the voucher is still vouching, else some other logic may have removed
+				// their status.
+				if let Some(mut record) = Members::<T, I>::get(&voucher) {
+					if let Some(VouchingStatus::Vouching) = record.vouching {
+						// In the case that a vouched-for bid is accepted we unset the
+						// vouching status and transfer the tip over to the voucher.
+						record.vouching = None;
+						Self::bump_payout(&voucher, maturity, tip.min(value));
+						Members::<T, I>::insert(&voucher, record);
+						value.saturating_sub(tip)
+					} else {
+						value
+					}
+				} else {
+					value
+				}
+			},
+		};
+
+		Self::bump_payout(candidate, maturity, value);
+	}
+
+	/// Bump the payout amount of `who`, to be unlocked at the given block number.
+	///
+	/// It is the caller's duty to ensure that `who` is already a member. This does nothing if `who`
+	/// is not a member or if `value` is zero.
+	fn bump_payout(who: &T::AccountId, when: BlockNumberFor<T>, value: BalanceOf<T, I>) {
+		if value.is_zero() {
+			return
+		}
+		if let Some(MemberRecord { rank: 0, .. }) = Members::<T, I>::get(who) {
+			Payouts::<T, I>::mutate(who, |record| {
+				// Members of rank 1 never get payouts.
+				match record.payouts.binary_search_by_key(&when, |x| x.0) {
+					Ok(index) => record.payouts[index].1.saturating_accrue(value),
+					Err(index) => {
+						// If they have too many pending payouts, then we take discard the payment.
+						let _ = record.payouts.try_insert(index, (when, value));
+					},
+				}
+			});
+			Self::reserve_payout(value);
+		}
+	}
+
+	/// Attempt to slash the payout of some member. Return the total amount that was deducted.
+	fn slash_payout(who: &T::AccountId, value: BalanceOf<T, I>) -> BalanceOf<T, I> {
+		let mut record = Payouts::<T, I>::get(who);
+		let mut rest = value;
+		while !record.payouts.is_empty() {
+			if let Some(new_rest) = rest.checked_sub(&record.payouts[0].1) {
+				// not yet totally slashed after this one; drop it completely.
+				rest = new_rest;
+				record.payouts.remove(0);
+			} else {
+				// whole slash is accounted for.
+				record.payouts[0].1.saturating_reduce(rest);
+				rest = Zero::zero();
+				break
+			}
+		}
+		Payouts::<T, I>::insert(who, record);
+		value - rest
+	}
+
+	/// Transfer some `amount` from the main account into the payouts account and reduce the Pot
+	/// by this amount.
+	fn reserve_payout(amount: BalanceOf<T, I>) {
+		// Tramsfer payout from the Pot into the payouts account.
+		Pot::<T, I>::mutate(|pot| pot.saturating_reduce(amount));
+
+		// this should never fail since we ensure we can afford the payouts in a previous
+		// block, but there's not much we can do to recover if it fails anyway.
+		let res = T::Currency::transfer(&Self::account_id(), &Self::payouts(), amount, AllowDeath);
+		debug_assert!(res.is_ok());
+	}
+
+	/// Transfer some `amount` from the main account into the payouts account and increase the Pot
+	/// by this amount.
+	fn unreserve_payout(amount: BalanceOf<T, I>) {
+		// Tramsfer payout from the Pot into the payouts account.
+		Pot::<T, I>::mutate(|pot| pot.saturating_accrue(amount));
+
+		// this should never fail since we ensure we can afford the payouts in a previous
+		// block, but there's not much we can do to recover if it fails anyway.
+		let res = T::Currency::transfer(&Self::payouts(), &Self::account_id(), amount, AllowDeath);
+		debug_assert!(res.is_ok());
+	}
+
+	/// The account ID of the treasury pot.
+	///
+	/// This actually does computation. If you need to keep using it, then make sure you cache the
+	/// value and only call this once.
+	pub fn account_id() -> T::AccountId {
+		T::PalletId::get().into_account_truncating()
+	}
+
+	/// The account ID of the payouts pot. This is where payouts are made from.
+	///
+	/// This actually does computation. If you need to keep using it, then make sure you cache the
+	/// value and only call this once.
+	pub fn payouts() -> T::AccountId {
+		T::PalletId::get().into_sub_account_truncating(b"payouts")
+	}
+
+	/// Return the duration of the lock, in blocks, with the given number of members.
+	///
+	/// This is a rather opaque calculation based on the formula here:
+	/// https://www.desmos.com/calculator/9itkal1tce
+	fn lock_duration(x: u32) -> BlockNumberFor<T> {
+		let lock_pc = 100 - 50_000 / (x + 500);
+		Percent::from_percent(lock_pc as u8) * T::MaxLockDuration::get()
+	}
+}
+
+impl<T: Config<I>, I: 'static> OnUnbalanced<NegativeImbalanceOf<T, I>> for Pallet<T, I> {
+	fn on_nonzero_unbalanced(amount: NegativeImbalanceOf<T, I>) {
+		let numeric_amount = amount.peek();
+
+		// Must resolve into existing but better to be safe.
+		let _ = T::Currency::resolve_creating(&Self::account_id(), amount);
+
+		Self::deposit_event(Event::<T, I>::Deposit { value: numeric_amount });
+	}
+}
diff --git a/substrate/frame/society/src/migrations.rs b/substrate/frame/society/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4685167dcbcfd34fb595605f14a540a1c8ec24aa
--- /dev/null
+++ b/substrate/frame/society/src/migrations.rs
@@ -0,0 +1,358 @@
+// 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.
+
+//! # Migrations for Society Pallet
+
+use super::*;
+use codec::{Decode, Encode};
+use frame_support::traits::{Defensive, DefensiveOption, Instance, OnRuntimeUpgrade};
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// The log target.
+const TARGET: &'static str = "runtime::society::migration";
+
+/// This migration moves all the state to v2 of Society.
+pub struct VersionUncheckedMigrateToV2<T: Config<I>, I: 'static, PastPayouts>(
+	sp_std::marker::PhantomData<(T, I, PastPayouts)>,
+);
+
+impl<
+		T: Config<I>,
+		I: Instance + 'static,
+		PastPayouts: Get<Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)>>,
+	> OnRuntimeUpgrade for VersionUncheckedMigrateToV2<T, I, PastPayouts>
+{
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		let current = Pallet::<T, I>::current_storage_version();
+		let onchain = Pallet::<T, I>::on_chain_storage_version();
+		ensure!(onchain == 0 && current == 2, "pallet_society: invalid version");
+
+		Ok((old::Candidates::<T, I>::get(), old::Members::<T, I>::get()).encode())
+	}
+
+	fn on_runtime_upgrade() -> Weight {
+		let onchain = Pallet::<T, I>::on_chain_storage_version();
+		if onchain < 2 {
+			log::info!(
+				target: TARGET,
+				"Running migration against onchain version {:?}",
+				onchain
+			);
+			from_original::<T, I>(&mut PastPayouts::get()).defensive_unwrap_or(Weight::MAX)
+		} else {
+			log::warn!("Unexpected onchain version: {:?} (expected 0)", onchain);
+			T::DbWeight::get().reads(1)
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(data: Vec<u8>) -> Result<(), TryRuntimeError> {
+		let old: (
+			Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
+			Vec<<T as frame_system::Config>::AccountId>,
+		) = Decode::decode(&mut &data[..]).expect("Bad data");
+		let mut old_candidates =
+			old.0.into_iter().map(|x| (x.who, x.kind, x.value)).collect::<Vec<_>>();
+		let mut old_members = old.1;
+		let mut candidates =
+			Candidates::<T, I>::iter().map(|(k, v)| (k, v.kind, v.bid)).collect::<Vec<_>>();
+		let mut members = Members::<T, I>::iter_keys().collect::<Vec<_>>();
+
+		old_candidates.sort_by_key(|x| x.0.clone());
+		candidates.sort_by_key(|x| x.0.clone());
+		assert_eq!(candidates, old_candidates);
+
+		members.sort();
+		old_members.sort();
+		assert_eq!(members, old_members);
+
+		ensure!(
+			Pallet::<T, I>::on_chain_storage_version() == 2,
+			"The onchain version must be updated after the migration."
+		);
+
+		assert_internal_consistency::<T, I>();
+		Ok(())
+	}
+}
+
+/// [`VersionUncheckedMigrateToV2`] wrapped in a
+/// [`frame_support::migrations::VersionedRuntimeUpgrade`], ensuring the migration is only performed
+/// when on-chain version is 0.
+#[cfg(feature = "experimental")]
+pub type VersionCheckedMigrateToV2<T, I, PastPayouts> =
+	frame_support::migrations::VersionedRuntimeUpgrade<
+		0,
+		2,
+		VersionUncheckedMigrateToV2<T, I, PastPayouts>,
+		crate::pallet::Pallet<T, I>,
+		<T as frame_system::Config>::DbWeight,
+	>;
+
+pub(crate) mod old {
+	use super::*;
+	use frame_support::storage_alias;
+
+	/// A vote by a member on a candidate application.
+	#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo)]
+	pub enum Vote {
+		/// The member has been chosen to be skeptic and has not yet taken any action.
+		Skeptic,
+		/// The member has rejected the candidate's application.
+		Reject,
+		/// The member approves of the candidate's application.
+		Approve,
+	}
+
+	#[storage_alias]
+	pub type Bids<T: Config<I>, I: 'static> = StorageValue<
+		Pallet<T, I>,
+		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
+		ValueQuery,
+	>;
+	#[storage_alias]
+	pub type Candidates<T: Config<I>, I: 'static> = StorageValue<
+		Pallet<T, I>,
+		Vec<Bid<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>>,
+		ValueQuery,
+	>;
+	#[storage_alias]
+	pub type Votes<T: Config<I>, I: 'static> = StorageDoubleMap<
+		Pallet<T, I>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		Vote,
+	>;
+	#[storage_alias]
+	pub type SuspendedCandidates<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		(BalanceOf<T, I>, BidKind<<T as frame_system::Config>::AccountId, BalanceOf<T, I>>),
+	>;
+	#[storage_alias]
+	pub type Members<T: Config<I>, I: 'static> =
+		StorageValue<Pallet<T, I>, Vec<<T as frame_system::Config>::AccountId>, ValueQuery>;
+	#[storage_alias]
+	pub type Vouching<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		VouchingStatus,
+	>;
+	#[storage_alias]
+	pub type Strikes<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		StrikeCount,
+		ValueQuery,
+	>;
+	#[storage_alias]
+	pub type Payouts<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		Vec<(frame_system::pallet_prelude::BlockNumberFor<T>, BalanceOf<T, I>)>,
+		ValueQuery,
+	>;
+	#[storage_alias]
+	pub type SuspendedMembers<T: Config<I>, I: 'static> = StorageMap<
+		Pallet<T, I>,
+		Twox64Concat,
+		<T as frame_system::Config>::AccountId,
+		bool,
+		ValueQuery,
+	>;
+	#[storage_alias]
+	pub type Defender<T: Config<I>, I: 'static> =
+		StorageValue<Pallet<T, I>, <T as frame_system::Config>::AccountId>;
+	#[storage_alias]
+	pub type DefenderVotes<T: Config<I>, I: 'static> =
+		StorageMap<Pallet<T, I>, Twox64Concat, <T as frame_system::Config>::AccountId, Vote>;
+}
+
+/// Will panic if there are any inconsistencies in the pallet's state or old keys remaining.
+pub fn assert_internal_consistency<T: Config<I>, I: Instance + 'static>() {
+	// Check all members are valid data.
+	let mut members = vec![];
+	for m in Members::<T, I>::iter_keys() {
+		let r = Members::<T, I>::get(&m).expect("Member data must be valid");
+		members.push((m, r));
+	}
+	assert_eq!(MemberCount::<T, I>::get(), members.len() as u32);
+	for (who, record) in members.iter() {
+		assert_eq!(MemberByIndex::<T, I>::get(record.index).as_ref(), Some(who));
+	}
+	if let Some(founder) = Founder::<T, I>::get() {
+		assert_eq!(Members::<T, I>::get(founder).expect("founder is member").index, 0);
+	}
+	if let Some(head) = Head::<T, I>::get() {
+		assert!(Members::<T, I>::contains_key(head));
+	}
+	// Check all votes are valid data.
+	for (k1, k2) in Votes::<T, I>::iter_keys() {
+		assert!(Votes::<T, I>::get(k1, k2).is_some());
+	}
+	// Check all defender votes are valid data.
+	for (k1, k2) in DefenderVotes::<T, I>::iter_keys() {
+		assert!(DefenderVotes::<T, I>::get(k1, k2).is_some());
+	}
+	// Check all candidates are valid data.
+	for k in Candidates::<T, I>::iter_keys() {
+		assert!(Candidates::<T, I>::get(k).is_some());
+	}
+	// Check all suspended members are valid data.
+	for m in SuspendedMembers::<T, I>::iter_keys() {
+		assert!(SuspendedMembers::<T, I>::get(m).is_some());
+	}
+	// Check all payouts are valid data.
+	for p in Payouts::<T, I>::iter_keys() {
+		let k = Payouts::<T, I>::hashed_key_for(&p);
+		let v = frame_support::storage::unhashed::get_raw(&k[..]).expect("value is in map");
+		assert!(PayoutRecordFor::<T, I>::decode(&mut &v[..]).is_ok());
+	}
+
+	// We don't use these - make sure they don't exist.
+	assert_eq!(old::SuspendedCandidates::<T, I>::iter().count(), 0);
+	assert_eq!(old::Strikes::<T, I>::iter().count(), 0);
+	assert_eq!(old::Vouching::<T, I>::iter().count(), 0);
+	assert!(!old::Defender::<T, I>::exists());
+	assert!(!old::Members::<T, I>::exists());
+}
+
+pub fn from_original<T: Config<I>, I: Instance + 'static>(
+	past_payouts: &mut [(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)],
+) -> Result<Weight, &'static str> {
+	// Migrate Bids from old::Bids (just a trunctation).
+	Bids::<T, I>::put(BoundedVec::<_, T::MaxBids>::truncate_from(old::Bids::<T, I>::take()));
+
+	// Initialise round counter.
+	RoundCount::<T, I>::put(0);
+
+	// Migrate Candidates from old::Candidates
+	for Bid { who: candidate, kind, value } in old::Candidates::<T, I>::take().into_iter() {
+		let mut tally = Tally::default();
+		// Migrate Votes from old::Votes
+		// No need to drain, since we're overwriting values.
+		for (voter, vote) in old::Votes::<T, I>::iter_prefix(&candidate) {
+			Votes::<T, I>::insert(
+				&candidate,
+				&voter,
+				Vote { approve: vote == old::Vote::Approve, weight: 1 },
+			);
+			match vote {
+				old::Vote::Approve => tally.approvals.saturating_inc(),
+				old::Vote::Reject => tally.rejections.saturating_inc(),
+				old::Vote::Skeptic => Skeptic::<T, I>::put(&voter),
+			}
+		}
+		Candidates::<T, I>::insert(
+			&candidate,
+			Candidacy { round: 0, kind, tally, skeptic_struck: false, bid: value },
+		);
+	}
+
+	// Migrate Members from old::Members old::Strikes old::Vouching
+	let mut member_count = 0;
+	for member in old::Members::<T, I>::take() {
+		let strikes = old::Strikes::<T, I>::take(&member);
+		let vouching = old::Vouching::<T, I>::take(&member);
+		let record = MemberRecord { index: member_count, rank: 0, strikes, vouching };
+		Members::<T, I>::insert(&member, record);
+		MemberByIndex::<T, I>::insert(member_count, &member);
+
+		// The founder must be the first member in Society V2. If we find the founder not in index
+		// zero, we swap it with the first member.
+		if member == Founder::<T, I>::get().defensive_ok_or("founder must always be set")? &&
+			member_count > 0
+		{
+			let member_to_swap = MemberByIndex::<T, I>::get(0)
+				.defensive_ok_or("member_count > 0, we must have at least 1 member")?;
+			// Swap the founder with the first member in MemberByIndex.
+			MemberByIndex::<T, I>::swap(0, member_count);
+			// Update the indicies of the swapped member MemberRecords.
+			Members::<T, I>::mutate(&member, |m| {
+				if let Some(member) = m {
+					member.index = 0;
+				} else {
+					frame_support::defensive!(
+						"Member somehow disapeared from storage after it was inserted"
+					);
+				}
+			});
+			Members::<T, I>::mutate(&member_to_swap, |m| {
+				if let Some(member) = m {
+					member.index = member_count;
+				} else {
+					frame_support::defensive!(
+						"Member somehow disapeared from storage after it was queried"
+					);
+				}
+			});
+		}
+		member_count.saturating_inc();
+	}
+	MemberCount::<T, I>::put(member_count);
+
+	// Migrate Payouts from: old::Payouts and raw info (needed since we can't query old chain
+	// state).
+	past_payouts.sort();
+	for (who, mut payouts) in old::Payouts::<T, I>::iter() {
+		payouts.truncate(T::MaxPayouts::get() as usize);
+		// ^^ Safe since we already truncated.
+		let paid = past_payouts
+			.binary_search_by_key(&&who, |x| &x.0)
+			.ok()
+			.map(|p| past_payouts[p].1)
+			.unwrap_or(Zero::zero());
+		match BoundedVec::try_from(payouts) {
+			Ok(payouts) => Payouts::<T, I>::insert(who, PayoutRecord { paid, payouts }),
+			Err(_) => debug_assert!(false, "Truncation of Payouts ineffective??"),
+		}
+	}
+
+	// Migrate SuspendedMembers from old::SuspendedMembers old::Strikes old::Vouching.
+	for who in old::SuspendedMembers::<T, I>::iter_keys() {
+		let strikes = old::Strikes::<T, I>::take(&who);
+		let vouching = old::Vouching::<T, I>::take(&who);
+		let record = MemberRecord { index: 0, rank: 0, strikes, vouching };
+		SuspendedMembers::<T, I>::insert(&who, record);
+	}
+
+	// Any suspended candidates remaining are rejected.
+	let _ = old::SuspendedCandidates::<T, I>::clear(u32::MAX, None);
+
+	// We give the current defender the benefit of the doubt.
+	old::Defender::<T, I>::kill();
+	let _ = old::DefenderVotes::<T, I>::clear(u32::MAX, None);
+
+	Ok(T::BlockWeights::get().max_block)
+}
+
+pub fn from_raw_past_payouts<T: Config<I>, I: Instance + 'static>(
+	past_payouts_raw: impl Iterator<Item = ([u8; 32], u128)>,
+) -> Vec<(<T as frame_system::Config>::AccountId, BalanceOf<T, I>)> {
+	past_payouts_raw
+		.filter_map(|(x, y)| Some((Decode::decode(&mut &x[..]).ok()?, y.try_into().ok()?)))
+		.collect()
+}
diff --git a/substrate/frame/society/src/mock.rs b/substrate/frame/society/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a318c2e794b7a854a03cd8b6052d2070741f41cf
--- /dev/null
+++ b/substrate/frame/society/src/mock.rs
@@ -0,0 +1,303 @@
+// 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.
+
+//! Test utilities
+
+use super::*;
+use crate as pallet_society;
+
+use frame_support::{
+	assert_noop, assert_ok, ord_parameter_types, parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use frame_support_test::TestRandomness;
+use frame_system::EnsureSignedBy;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+use RuntimeOrigin as Origin;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Society: pallet_society::{Pallet, Call, Storage, Event<T>, Config<T>},
+	}
+);
+
+parameter_types! {
+	pub const SocietyPalletId: PalletId = PalletId(*b"py/socie");
+}
+
+ord_parameter_types! {
+	pub const ChallengePeriod: u64 = 8;
+	pub const ClaimPeriod: u64 = 1;
+	pub const FounderSetAccount: u128 = 1;
+	pub const SuspensionJudgementSetAccount: u128 = 2;
+	pub const MaxPayouts: u32 = 10;
+	pub const MaxBids: u32 = 10;
+}
+
+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 = u128;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type AccountData = pallet_balances::AccountData<u64>;
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type PalletId = SocietyPalletId;
+	type Currency = pallet_balances::Pallet<Self>;
+	type Randomness = TestRandomness<Self>;
+	type GraceStrikes = ConstU32<1>;
+	type PeriodSpend = ConstU64<1000>;
+	type VotingPeriod = ConstU64<3>;
+	type ClaimPeriod = ClaimPeriod;
+	type MaxLockDuration = ConstU64<100>;
+	type FounderSetOrigin = EnsureSignedBy<FounderSetAccount, u128>;
+	type ChallengePeriod = ChallengePeriod;
+	type MaxPayouts = MaxPayouts;
+	type MaxBids = MaxBids;
+	type WeightInfo = ();
+}
+
+pub struct EnvBuilder {
+	balance: u64,
+	balances: Vec<(u128, u64)>,
+	pot: u64,
+	founded: bool,
+}
+
+impl EnvBuilder {
+	pub fn new() -> Self {
+		Self {
+			balance: 10_000,
+			balances: vec![
+				(10, 50),
+				(20, 50),
+				(30, 50),
+				(40, 50),
+				(50, 50),
+				(60, 50),
+				(70, 50),
+				(80, 50),
+				(90, 50),
+			],
+			pot: 0,
+			founded: true,
+		}
+	}
+
+	pub fn execute<R, F: FnOnce() -> R>(mut self, f: F) -> R {
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		self.balances.push((Society::account_id(), self.balance.max(self.pot)));
+		pallet_balances::GenesisConfig::<Test> { balances: self.balances }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		pallet_society::GenesisConfig::<Test> { pot: self.pot }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		let mut ext: sp_io::TestExternalities = t.into();
+		ext.execute_with(|| {
+			if self.founded {
+				let r = b"be cool".to_vec();
+				assert!(Society::found_society(Origin::signed(1), 10, 10, 8, 2, 25, r).is_ok());
+			}
+			let r = f();
+			migrations::assert_internal_consistency::<Test, ()>();
+			r
+		})
+	}
+	pub fn founded(mut self, f: bool) -> Self {
+		self.founded = f;
+		self
+	}
+}
+
+/// Run until a particular block.
+pub fn run_to_block(n: u64) {
+	while System::block_number() < n {
+		if System::block_number() > 1 {
+			System::on_finalize(System::block_number());
+		}
+		System::set_block_number(System::block_number() + 1);
+		System::on_initialize(System::block_number());
+		Society::on_initialize(System::block_number());
+	}
+}
+
+/// Creates a bid struct using input parameters.
+pub fn bid<AccountId, Balance>(
+	who: AccountId,
+	kind: BidKind<AccountId, Balance>,
+	value: Balance,
+) -> Bid<AccountId, Balance> {
+	Bid { who, kind, value }
+}
+
+/// Creates a candidate struct using input parameters.
+pub fn candidacy<AccountId, Balance>(
+	round: RoundIndex,
+	bid: Balance,
+	kind: BidKind<AccountId, Balance>,
+	approvals: VoteCount,
+	rejections: VoteCount,
+) -> Candidacy<AccountId, Balance> {
+	Candidacy { round, kind, bid, tally: Tally { approvals, rejections }, skeptic_struck: false }
+}
+
+pub fn next_challenge() {
+	let challenge_period: u64 = <Test as Config>::ChallengePeriod::get();
+	let now = System::block_number();
+	run_to_block(now + challenge_period - now % challenge_period);
+}
+
+pub fn next_voting() {
+	if let Period::Voting { more, .. } = Society::period() {
+		run_to_block(System::block_number() + more);
+	}
+}
+
+pub fn conclude_intake(allow_resignation: bool, judge_intake: Option<bool>) {
+	next_voting();
+	let round = RoundCount::<Test>::get();
+	for (who, candidacy) in Candidates::<Test>::iter() {
+		if candidacy.tally.clear_approval() {
+			assert_ok!(Society::claim_membership(Origin::signed(who)));
+			assert_noop!(
+				Society::claim_membership(Origin::signed(who)),
+				Error::<Test>::NotCandidate
+			);
+			continue
+		}
+		if candidacy.tally.clear_rejection() && allow_resignation {
+			assert_noop!(
+				Society::claim_membership(Origin::signed(who)),
+				Error::<Test>::NotApproved
+			);
+			assert_ok!(Society::resign_candidacy(Origin::signed(who)));
+			continue
+		}
+		if let (Some(founder), Some(approve)) = (Founder::<Test>::get(), judge_intake) {
+			if !candidacy.tally.clear_approval() && !approve {
+				// can be rejected by founder
+				assert_ok!(Society::kick_candidate(Origin::signed(founder), who));
+				continue
+			}
+			if !candidacy.tally.clear_rejection() && approve {
+				// can be rejected by founder
+				assert_ok!(Society::bestow_membership(Origin::signed(founder), who));
+				continue
+			}
+		}
+		if candidacy.tally.clear_rejection() && round > candidacy.round + 1 {
+			assert_noop!(
+				Society::claim_membership(Origin::signed(who)),
+				Error::<Test>::NotApproved
+			);
+			assert_ok!(Society::drop_candidate(Origin::signed(0), who));
+			assert_noop!(
+				Society::drop_candidate(Origin::signed(0), who),
+				Error::<Test>::NotCandidate
+			);
+			continue
+		}
+		if !candidacy.skeptic_struck {
+			assert_ok!(Society::punish_skeptic(Origin::signed(who)));
+		}
+	}
+}
+
+pub fn next_intake() {
+	let claim_period: u64 = <Test as Config>::ClaimPeriod::get();
+	match Society::period() {
+		Period::Voting { more, .. } => run_to_block(System::block_number() + more + claim_period),
+		Period::Claim { more, .. } => run_to_block(System::block_number() + more),
+	}
+}
+
+pub fn place_members(members: impl AsRef<[u128]>) {
+	for who in members.as_ref() {
+		assert_ok!(Society::insert_member(who, 0));
+	}
+}
+
+pub fn members() -> Vec<u128> {
+	let mut r = Members::<Test>::iter_keys().collect::<Vec<_>>();
+	r.sort();
+	r
+}
+
+pub fn membership() -> Vec<(u128, MemberRecord)> {
+	let mut r = Members::<Test>::iter().collect::<Vec<_>>();
+	r.sort_by_key(|x| x.0);
+	r
+}
+
+pub fn candidacies() -> Vec<(u128, Candidacy<u128, u64>)> {
+	let mut r = Candidates::<Test>::iter().collect::<Vec<_>>();
+	r.sort_by_key(|x| x.0);
+	r
+}
+
+pub fn candidates() -> Vec<u128> {
+	let mut r = Candidates::<Test>::iter_keys().collect::<Vec<_>>();
+	r.sort();
+	r
+}
diff --git a/substrate/frame/society/src/tests.rs b/substrate/frame/society/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ea2afef3b32b5b7ad188742408befe3fff29a338
--- /dev/null
+++ b/substrate/frame/society/src/tests.rs
@@ -0,0 +1,1294 @@
+// 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 the module.
+
+use super::*;
+use migrations::old;
+use mock::*;
+
+use frame_support::{assert_noop, assert_ok};
+use sp_core::blake2_256;
+use sp_runtime::traits::BadOrigin;
+use BidKind::*;
+use VouchingStatus::*;
+
+use RuntimeOrigin as Origin;
+
+#[test]
+fn migration_works() {
+	EnvBuilder::new().founded(false).execute(|| {
+		use old::Vote::*;
+
+		// Initialise the old storage items.
+		Founder::<Test>::put(10);
+		Head::<Test>::put(30);
+		old::Members::<Test, ()>::put(vec![10, 20, 30]);
+		old::Vouching::<Test, ()>::insert(30, Vouching);
+		old::Vouching::<Test, ()>::insert(40, Banned);
+		old::Strikes::<Test, ()>::insert(20, 1);
+		old::Strikes::<Test, ()>::insert(30, 2);
+		old::Strikes::<Test, ()>::insert(40, 5);
+		old::Payouts::<Test, ()>::insert(20, vec![(1, 1)]);
+		old::Payouts::<Test, ()>::insert(
+			30,
+			(0..=<Test as Config>::MaxPayouts::get())
+				.map(|i| (i as u64, i as u64))
+				.collect::<Vec<_>>(),
+		);
+		old::SuspendedMembers::<Test, ()>::insert(40, true);
+
+		old::Defender::<Test, ()>::put(20);
+		old::DefenderVotes::<Test, ()>::insert(10, Approve);
+		old::DefenderVotes::<Test, ()>::insert(20, Approve);
+		old::DefenderVotes::<Test, ()>::insert(30, Reject);
+
+		old::SuspendedCandidates::<Test, ()>::insert(50, (10, Deposit(100)));
+
+		old::Candidates::<Test, ()>::put(vec![
+			Bid { who: 60, kind: Deposit(100), value: 200 },
+			Bid { who: 70, kind: Vouch(30, 30), value: 100 },
+		]);
+		old::Votes::<Test, ()>::insert(60, 10, Approve);
+		old::Votes::<Test, ()>::insert(70, 10, Reject);
+		old::Votes::<Test, ()>::insert(70, 20, Approve);
+		old::Votes::<Test, ()>::insert(70, 30, Approve);
+
+		let bids = (0..=<Test as Config>::MaxBids::get())
+			.map(|i| Bid {
+				who: 100u128 + i as u128,
+				kind: Deposit(20u64 + i as u64),
+				value: 10u64 + i as u64,
+			})
+			.collect::<Vec<_>>();
+		old::Bids::<Test, ()>::put(bids);
+
+		migrations::from_original::<Test, ()>(&mut [][..]).expect("migration failed");
+		migrations::assert_internal_consistency::<Test, ()>();
+
+		assert_eq!(
+			membership(),
+			vec![
+				(10, MemberRecord { rank: 0, strikes: 0, vouching: None, index: 0 }),
+				(20, MemberRecord { rank: 0, strikes: 1, vouching: None, index: 1 }),
+				(30, MemberRecord { rank: 0, strikes: 2, vouching: Some(Vouching), index: 2 }),
+			]
+		);
+		assert_eq!(Payouts::<Test>::get(10), PayoutRecord::default());
+		let payouts = vec![(1, 1)].try_into().unwrap();
+		assert_eq!(Payouts::<Test>::get(20), PayoutRecord { paid: 0, payouts });
+		let payouts = (0..<Test as Config>::MaxPayouts::get())
+			.map(|i| (i as u64, i as u64))
+			.collect::<Vec<_>>()
+			.try_into()
+			.unwrap();
+		assert_eq!(Payouts::<Test>::get(30), PayoutRecord { paid: 0, payouts });
+		assert_eq!(
+			SuspendedMembers::<Test>::iter().collect::<Vec<_>>(),
+			vec![(40, MemberRecord { rank: 0, strikes: 5, vouching: Some(Banned), index: 0 }),]
+		);
+		let bids: BoundedVec<_, <Test as Config>::MaxBids> = (0..<Test as Config>::MaxBids::get())
+			.map(|i| Bid {
+				who: 100u128 + i as u128,
+				kind: Deposit(20u64 + i as u64),
+				value: 10u64 + i as u64,
+			})
+			.collect::<Vec<_>>()
+			.try_into()
+			.unwrap();
+		assert_eq!(Bids::<Test>::get(), bids);
+		assert_eq!(RoundCount::<Test, ()>::get(), 0);
+		assert_eq!(
+			candidacies(),
+			vec![
+				(
+					60,
+					Candidacy {
+						round: 0,
+						kind: Deposit(100),
+						bid: 200,
+						tally: Tally { approvals: 1, rejections: 0 },
+						skeptic_struck: false,
+					}
+				),
+				(
+					70,
+					Candidacy {
+						round: 0,
+						kind: Vouch(30, 30),
+						bid: 100,
+						tally: Tally { approvals: 2, rejections: 1 },
+						skeptic_struck: false,
+					}
+				),
+			]
+		);
+		assert_eq!(Votes::<Test>::get(60, 10), Some(Vote { approve: true, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(70, 10), Some(Vote { approve: false, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(70, 20), Some(Vote { approve: true, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(70, 30), Some(Vote { approve: true, weight: 1 }));
+	});
+}
+
+#[test]
+fn founding_works() {
+	EnvBuilder::new().founded(false).execute(|| {
+		// Not set up initially.
+		assert_eq!(Founder::<Test>::get(), None);
+		assert_eq!(Parameters::<Test>::get(), None);
+		assert_eq!(Pot::<Test>::get(), 0);
+		// Account 1 is set as the founder origin
+		// Account 5 cannot start a society
+		assert_noop!(
+			Society::found_society(Origin::signed(5), 20, 100, 10, 2, 25, vec![]),
+			BadOrigin
+		);
+		// Account 1 can start a society, where 10 is the founding member
+		assert_ok!(Society::found_society(
+			Origin::signed(1),
+			10,
+			100,
+			10,
+			2,
+			25,
+			b"be cool".to_vec()
+		));
+		// Society members only include 10
+		assert_eq!(members(), vec![10]);
+		// 10 is the head of the society
+		assert_eq!(Head::<Test>::get(), Some(10));
+		// ...and also the founder
+		assert_eq!(Founder::<Test>::get(), Some(10));
+		// 100 members max
+		assert_eq!(Parameters::<Test>::get().unwrap().max_members, 100);
+		// rules are correct
+		assert_eq!(Rules::<Test>::get(), Some(blake2_256(b"be cool").into()));
+		// Pot grows after first rotation period
+		next_intake();
+		assert_eq!(Pot::<Test>::get(), 1000);
+		// Cannot start another society
+		assert_noop!(
+			Society::found_society(Origin::signed(1), 20, 100, 10, 2, 25, vec![]),
+			Error::<Test>::AlreadyFounded
+		);
+	});
+}
+
+#[test]
+fn unfounding_works() {
+	EnvBuilder::new().founded(false).execute(|| {
+		// Account 1 sets the founder...
+		assert_ok!(Society::found_society(Origin::signed(1), 10, 100, 10, 2, 25, vec![]));
+		// Account 2 cannot unfound it as it's not the founder.
+		assert_noop!(Society::dissolve(Origin::signed(2)), Error::<Test>::NotFounder);
+		// Account 10 can, though.
+		assert_ok!(Society::dissolve(Origin::signed(10)));
+
+		// 1 sets the founder to 20 this time
+		assert_ok!(Society::found_society(Origin::signed(1), 20, 100, 10, 2, 25, vec![]));
+		// Bring in a new member...
+		assert_ok!(Society::bid(Origin::signed(10), 0));
+		next_intake();
+		assert_ok!(Society::vote(Origin::signed(20), 10, true));
+		conclude_intake(true, None);
+
+		// Unfounding won't work now, even though it's from 20.
+		assert_noop!(Society::dissolve(Origin::signed(20)), Error::<Test>::NotHead);
+	});
+}
+
+#[test]
+fn basic_new_member_works() {
+	EnvBuilder::new().execute(|| {
+		assert_eq!(Balances::free_balance(20), 50);
+		// Bid causes Candidate Deposit to be reserved.
+		assert_ok!(Society::bid(RuntimeOrigin::signed(20), 0));
+		assert_eq!(Balances::free_balance(20), 25);
+		assert_eq!(Balances::reserved_balance(20), 25);
+		// Rotate period every 4 blocks
+		next_intake();
+		// 20 is now a candidate
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, Deposit(25), 0, 0))]);
+		// 10 (a member) can vote for the candidate
+		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		conclude_intake(true, None);
+		// Rotate period every 4 blocks
+		next_intake();
+		// 20 is now a member of the society
+		assert_eq!(members(), vec![10, 20]);
+		// Reserved balance is returned
+		assert_eq!(Balances::free_balance(20), 50);
+		assert_eq!(Balances::reserved_balance(20), 0);
+	});
+}
+
+#[test]
+fn bidding_works() {
+	EnvBuilder::new().execute(|| {
+		// Users make bids of various amounts
+		assert_ok!(Society::bid(RuntimeOrigin::signed(60), 1900));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(50), 500));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(40), 400));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(30), 300));
+		// Rotate period
+		next_intake();
+		// Pot is 1000 after "PeriodSpend"
+		assert_eq!(Pot::<Test>::get(), 1000);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10_000);
+		// Choose smallest bidding users whose total is less than pot
+		assert_eq!(
+			candidacies(),
+			vec![
+				(30, candidacy(1, 300, Deposit(25), 0, 0)),
+				(40, candidacy(1, 400, Deposit(25), 0, 0)),
+			]
+		);
+		// A member votes for these candidates to join the society
+		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		assert_ok!(Society::vote(Origin::signed(10), 40, true));
+		conclude_intake(true, None);
+		next_intake();
+		// Candidates become members after a period rotation
+		assert_eq!(members(), vec![10, 30, 40]);
+		// Pot is increased by 1000, but pays out 700 to the members
+		assert_eq!(Balances::free_balance(Society::account_id()), 9_300);
+		assert_eq!(Pot::<Test>::get(), 1_300);
+		// Left over from the original bids is 50 who satisfies the condition of bid less than pot.
+		assert_eq!(candidacies(), vec![(50, candidacy(2, 500, Deposit(25), 0, 0))]);
+		// 40, now a member, can vote for 50
+		assert_ok!(Society::vote(Origin::signed(40), 50, true));
+		conclude_intake(true, None);
+		run_to_block(12);
+		// 50 is now a member
+		assert_eq!(members(), vec![10, 30, 40, 50]);
+		// Pot is increased by 1000, and 500 is paid out. Total payout so far is 1200.
+		assert_eq!(Pot::<Test>::get(), 1_800);
+		assert_eq!(Balances::free_balance(Society::account_id()), 8_800);
+		// No more candidates satisfy the requirements
+		assert_eq!(candidacies(), vec![]);
+		assert_ok!(Society::defender_vote(Origin::signed(10), true)); // Keep defender around
+															  // Next period
+		run_to_block(16);
+		// Same members
+		assert_eq!(members(), vec![10, 30, 40, 50]);
+		// Pot is increased by 1000 again
+		assert_eq!(Pot::<Test>::get(), 2_800);
+		// No payouts
+		assert_eq!(Balances::free_balance(Society::account_id()), 8_800);
+		// Candidate 60 now qualifies based on the increased pot size.
+		assert_eq!(candidacies(), vec![(60, candidacy(4, 1900, Deposit(25), 0, 0))]);
+		// Candidate 60 is voted in.
+		assert_ok!(Society::vote(Origin::signed(50), 60, true));
+		conclude_intake(true, None);
+		run_to_block(20);
+		// 60 joins as a member
+		assert_eq!(members(), vec![10, 30, 40, 50, 60]);
+		// Pay them
+		assert_eq!(Pot::<Test>::get(), 1_900);
+		assert_eq!(Balances::free_balance(Society::account_id()), 6_900);
+	});
+}
+
+#[test]
+fn unbidding_works() {
+	EnvBuilder::new().execute(|| {
+		// 20 and 30 make bids
+		assert_ok!(Society::bid(RuntimeOrigin::signed(20), 1000));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(30), 0));
+		// Balances are reserved
+		assert_eq!(Balances::free_balance(30), 25);
+		assert_eq!(Balances::reserved_balance(30), 25);
+		// Can unbid themselves with the right position
+		assert_ok!(Society::unbid(Origin::signed(30)));
+		assert_noop!(Society::unbid(Origin::signed(30)), Error::<Test>::NotBidder);
+		// Balance is returned
+		assert_eq!(Balances::free_balance(30), 50);
+		assert_eq!(Balances::reserved_balance(30), 0);
+		// 20 wins candidacy
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, Deposit(25), 0, 0))]);
+	});
+}
+
+#[test]
+fn payout_works() {
+	EnvBuilder::new().execute(|| {
+		// Original balance of 50
+		assert_eq!(Balances::free_balance(20), 50);
+		assert_ok!(Society::bid(Origin::signed(20), 1000));
+		next_intake();
+		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		conclude_intake(true, None);
+		// payout not ready
+		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NoPayout);
+		next_intake();
+		// payout should be here
+		assert_ok!(Society::payout(RuntimeOrigin::signed(20)));
+		assert_eq!(Balances::free_balance(20), 1050);
+	});
+}
+
+#[test]
+fn non_voting_skeptic_is_punished() {
+	EnvBuilder::new().execute(|| {
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, Deposit(25), 0, 0))]);
+		conclude_intake(true, None);
+		next_intake();
+		assert_eq!(members(), vec![10]);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 1);
+	});
+}
+
+#[test]
+fn rejecting_skeptic_on_approved_is_punished() {
+	EnvBuilder::new().execute(|| {
+		place_members([20, 30]);
+		assert_ok!(Society::bid(Origin::signed(40), 0));
+		next_intake();
+		let skeptic = Skeptic::<Test>::get().unwrap();
+		for &i in &[10, 20, 30][..] {
+			assert_ok!(Society::vote(Origin::signed(i), 40, i != skeptic));
+		}
+		conclude_intake(true, None);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 0);
+		run_to_block(12);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		assert_eq!(Members::<Test>::get(skeptic).unwrap().strikes, 1);
+	});
+}
+
+#[test]
+fn basic_new_member_reject_works() {
+	EnvBuilder::new().execute(|| {
+		// Starting Balance
+		assert_eq!(Balances::free_balance(20), 50);
+		// 20 makes a bid
+		assert_ok!(Society::bid(RuntimeOrigin::signed(20), 0));
+		assert_eq!(Balances::free_balance(20), 25);
+		assert_eq!(Balances::reserved_balance(20), 25);
+		// Rotation Period
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 0, Deposit(25), 0, 0))]);
+		// We say no
+		assert_ok!(Society::vote(Origin::signed(10), 20, false));
+		conclude_intake(true, None);
+		next_intake();
+		// User is not added as member
+		assert_eq!(members(), vec![10]);
+		// User is rejected.
+		assert_eq!(candidacies(), vec![]);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
+	});
+}
+
+#[test]
+fn slash_payout_works() {
+	EnvBuilder::new().execute(|| {
+		assert_eq!(Balances::free_balance(20), 50);
+		assert_ok!(Society::bid(Origin::signed(20), 1000));
+		next_intake();
+		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		conclude_intake(true, None);
+		// payout in queue
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() }
+		);
+		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NoPayout);
+		// slash payout
+		assert_eq!(Society::slash_payout(&20, 500), 500);
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 500)].try_into().unwrap() }
+		);
+		run_to_block(8);
+		// payout should be here, but 500 less
+		assert_ok!(Society::payout(RuntimeOrigin::signed(20)));
+		assert_eq!(Balances::free_balance(20), 550);
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 500, payouts: Default::default() }
+		);
+	});
+}
+
+#[test]
+fn slash_payout_multi_works() {
+	EnvBuilder::new().execute(|| {
+		assert_eq!(Balances::free_balance(20), 50);
+		place_members([20]);
+		// create a few payouts
+		Society::bump_payout(&20, 5, 100);
+		Society::bump_payout(&20, 10, 100);
+		Society::bump_payout(&20, 15, 100);
+		Society::bump_payout(&20, 20, 100);
+		// payouts in queue
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord {
+				paid: 0,
+				payouts: vec![(5, 100), (10, 100), (15, 100), (20, 100)].try_into().unwrap()
+			}
+		);
+		// slash payout
+		assert_eq!(Society::slash_payout(&20, 250), 250);
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(15, 50), (20, 100)].try_into().unwrap() }
+		);
+		// slash again
+		assert_eq!(Society::slash_payout(&20, 50), 50);
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(20, 100)].try_into().unwrap() }
+		);
+	});
+}
+
+#[test]
+fn suspended_member_life_cycle_works() {
+	EnvBuilder::new().execute(|| {
+		// Add 20 to members, who is not the head and can be suspended/removed.
+		place_members([20]);
+		assert_eq!(members(), vec![10, 20]);
+		assert_eq!(Members::<Test>::get(20).unwrap().strikes, 0);
+		assert!(!SuspendedMembers::<Test>::contains_key(20));
+
+		// Let's suspend account 20 by giving them 2 strikes by not voting
+		assert_ok!(Society::bid(Origin::signed(30), 0));
+		assert_ok!(Society::bid(Origin::signed(40), 1));
+		next_intake();
+		conclude_intake(false, None);
+
+		// 2 strikes are accumulated, and 20 is suspended :(
+		assert!(SuspendedMembers::<Test>::contains_key(20));
+		assert_eq!(members(), vec![10]);
+
+		// Suspended members cannot get payout
+		Society::bump_payout(&20, 10, 100);
+		assert_noop!(Society::payout(Origin::signed(20)), Error::<Test>::NotMember);
+
+		// Normal people cannot make judgement
+		assert_noop!(
+			Society::judge_suspended_member(Origin::signed(20), 20, true),
+			Error::<Test>::NotFounder
+		);
+
+		// Suspension judgment origin can judge thee
+		// Suspension judgement origin forgives the suspended member
+		assert_ok!(Society::judge_suspended_member(Origin::signed(10), 20, true));
+		assert!(!SuspendedMembers::<Test>::contains_key(20));
+		assert_eq!(members(), vec![10, 20]);
+
+		// Let's suspend them again, directly
+		assert_ok!(Society::suspend_member(&20));
+		assert!(SuspendedMembers::<Test>::contains_key(20));
+		// Suspension judgement origin does not forgive the suspended member
+		assert_ok!(Society::judge_suspended_member(Origin::signed(10), 20, false));
+		// Cleaned up
+		assert!(!SuspendedMembers::<Test>::contains_key(20));
+		assert_eq!(members(), vec![10]);
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
+	});
+}
+
+#[test]
+fn suspended_candidate_rejected_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20, 30]);
+		// 40, 50, 60, 70, 80 make bids
+		for &x in &[40u128, 50, 60, 70] {
+			assert_ok!(Society::bid(Origin::signed(x), 10));
+			assert_eq!(Balances::free_balance(x), 25);
+			assert_eq!(Balances::reserved_balance(x), 25);
+		}
+
+		// Rotation Period
+		next_intake();
+		assert_eq!(
+			candidacies(),
+			vec![
+				(40, candidacy(1, 10, Deposit(25), 0, 0)),
+				(50, candidacy(1, 10, Deposit(25), 0, 0)),
+				(60, candidacy(1, 10, Deposit(25), 0, 0)),
+				(70, candidacy(1, 10, Deposit(25), 0, 0)),
+			]
+		);
+
+		// Split vote over all.
+		for &x in &[40, 50, 60, 70] {
+			assert_ok!(Society::vote(Origin::signed(20), x, false));
+			assert_ok!(Society::vote(Origin::signed(30), x, true));
+		}
+
+		// Voting continues, as no canidate is clearly accepted yet and the founder chooses not to
+		// act.
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30]);
+		assert_eq!(candidates(), vec![40, 50, 60, 70]);
+
+		// 40 gets approved after founder weighs in giving it a clear approval.
+		// but the founder's rejection of 60 doesn't do much for now.
+		assert_ok!(Society::vote(Origin::signed(10), 40, true));
+		assert_ok!(Society::vote(Origin::signed(10), 60, false));
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		assert_eq!(candidates(), vec![50, 60, 70]);
+		assert_eq!(Balances::free_balance(40), 50);
+		assert_eq!(Balances::reserved_balance(40), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 9990);
+
+		// Founder manually bestows membership on 50 and and kicks 70.
+		assert_ok!(Society::bestow_membership(Origin::signed(10), 50));
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		assert_eq!(candidates(), vec![60, 70]);
+		assert_eq!(Balances::free_balance(50), 50);
+		assert_eq!(Balances::reserved_balance(50), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 9980);
+
+		assert_eq!(Balances::free_balance(70), 25);
+		assert_eq!(Balances::reserved_balance(70), 25);
+
+		assert_ok!(Society::kick_candidate(Origin::signed(10), 70));
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		assert_eq!(candidates(), vec![60]);
+		assert_eq!(Balances::free_balance(70), 25);
+		assert_eq!(Balances::reserved_balance(70), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10005);
+
+		// Next round doesn't make much difference.
+		next_intake();
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		assert_eq!(candidates(), vec![60]);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10005);
+
+		// But after two rounds, the clearly rejected 60 gets dropped and slashed.
+		next_intake();
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		assert_eq!(candidates(), vec![]);
+		assert_eq!(Balances::free_balance(60), 25);
+		assert_eq!(Balances::reserved_balance(60), 0);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10030);
+	});
+}
+
+#[test]
+fn unpaid_vouch_works() {
+	EnvBuilder::new().execute(|| {
+		// 10 is the only member
+		assert_eq!(members(), vec![10]);
+		// A non-member cannot vouch
+		assert_noop!(Society::vouch(Origin::signed(1), 20, 1000, 100), Error::<Test>::NotMember);
+		// A member can though
+		assert_ok!(Society::vouch(Origin::signed(10), 20, 1000, 100));
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+		// A member cannot vouch twice at the same time
+		assert_noop!(
+			Society::vouch(Origin::signed(10), 30, 100, 0),
+			Error::<Test>::AlreadyVouching
+		);
+		// Vouching creates the right kind of bid
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, Vouch(10, 100), 1000)]);
+		// Vouched user can become candidate
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 1000, Vouch(10, 100), 0, 0))]);
+		// Vote yes
+		assert_ok!(Society::vote(RuntimeOrigin::signed(10), 20, true));
+		// Vouched user can win
+		conclude_intake(true, None);
+		assert_eq!(members(), vec![10, 20]);
+		// Vouched user gets whatever remains after the voucher's reservation.
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() }
+		);
+		// 10 is no longer vouching
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, None);
+	});
+}
+
+#[test]
+fn paid_vouch_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20]);
+		assert_eq!(members(), vec![10, 20]);
+
+		assert_ok!(Society::vouch(Origin::signed(20), 30, 1000, 100));
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 100), 1000)]);
+
+		next_intake();
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, Vouch(20, 100), 0, 0))]);
+		assert_ok!(Society::vote(Origin::signed(20), 30, true));
+		conclude_intake(true, None);
+
+		assert_eq!(members(), vec![10, 20, 30]);
+		// Voucher wins a portion of the payment
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() }
+		);
+		// Vouched user wins the rest
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(8, 900)].try_into().unwrap() }
+		);
+		// 20 is no longer vouching
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, None);
+	});
+}
+
+#[test]
+fn voucher_cannot_win_more_than_bid() {
+	EnvBuilder::new().execute(|| {
+		place_members([20]);
+		// 20 vouches, but asks for more than the bid
+		assert_ok!(Society::vouch(Origin::signed(20), 30, 100, 1000));
+		// Vouching creates the right kind of bid
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 1000), 100)]);
+		// Vouched user can become candidate
+		next_intake();
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 100, Vouch(20, 1000), 0, 0))]);
+		// Vote yes
+		assert_ok!(Society::vote(Origin::signed(20), 30, true));
+		// Vouched user can win
+		conclude_intake(true, None);
+		assert_eq!(members(), vec![10, 20, 30]);
+		// Voucher wins as much as the bid
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(8, 100)].try_into().unwrap() }
+		);
+		// Vouched user gets nothing
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
+	});
+}
+
+#[test]
+fn unvouch_works() {
+	EnvBuilder::new().execute(|| {
+		// 10 is the only member
+		assert_eq!(members(), vec![10]);
+		// 10 vouches for 20
+		assert_ok!(Society::vouch(RuntimeOrigin::signed(10), 20, 100, 0));
+		// 20 has a bid
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, Vouch(10, 0), 100)]);
+		// 10 is vouched
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+		// 10 can unvouch
+		assert_ok!(Society::unvouch(Origin::signed(10)));
+		// 20 no longer has a bid
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
+		// 10 is no longer vouching
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, None);
+
+		// Cannot unvouch after they become candidate
+		assert_ok!(Society::vouch(Origin::signed(10), 20, 100, 0));
+		next_intake();
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, Vouch(10, 0), 0, 0))]);
+		assert_noop!(Society::unvouch(Origin::signed(10)), Error::<Test>::NotVouchingOnBidder);
+
+		// 10 is still vouching until candidate is approved or rejected
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+		// Voucher inexplicably votes against their pick.
+		assert_ok!(Society::vote(Origin::signed(10), 20, false));
+		// But their pick doesn't resign (yet).
+		conclude_intake(false, None);
+		// Voting still happening and voucher cannot unvouch.
+		assert_eq!(candidacies(), vec![(20, candidacy(1, 100, Vouch(10, 0), 0, 1))]);
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+
+		// Candidate gives in and resigns.
+		conclude_intake(true, None);
+		// Vouxher (10) is banned from vouching.
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Banned));
+		assert_eq!(members(), vec![10]);
+
+		// 10 cannot vouch again
+		assert_noop!(
+			Society::vouch(Origin::signed(10), 30, 100, 0),
+			Error::<Test>::AlreadyVouching
+		);
+		// 10 cannot unvouch either, so they are banned forever.
+		assert_noop!(Society::unvouch(Origin::signed(10)), Error::<Test>::NotVouchingOnBidder);
+	});
+}
+
+#[test]
+fn unbid_vouch_works() {
+	EnvBuilder::new().execute(|| {
+		// 10 is the only member
+		assert_eq!(members(), vec![10]);
+		// 10 vouches for 20
+		assert_ok!(Society::vouch(RuntimeOrigin::signed(10), 20, 100, 0));
+		// 20 has a bid
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(20, Vouch(10, 0), 100)]);
+		// 10 is vouched
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, Some(VouchingStatus::Vouching));
+		// 20 doesn't want to be a member and can unbid themselves.
+		assert_ok!(Society::unbid(Origin::signed(20)));
+		// Everything is cleaned up
+		assert_eq!(Members::<Test>::get(10).unwrap().vouching, None);
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
+	});
+}
+
+#[test]
+fn founder_and_head_cannot_be_removed() {
+	EnvBuilder::new().execute(|| {
+		// 10 is the only member, founder, and head
+		assert_eq!(members(), vec![10]);
+		assert_eq!(Founder::<Test>::get(), Some(10));
+		assert_eq!(Head::<Test>::get(), Some(10));
+		// 10 can still accumulate strikes
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		next_intake();
+		conclude_intake(false, None);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 1);
+		assert_ok!(Society::bid(Origin::signed(30), 0));
+		next_intake();
+		conclude_intake(false, None);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 2);
+		// Awkwardly they can obtain more than MAX_STRIKES...
+		assert_ok!(Society::bid(Origin::signed(40), 0));
+		next_intake();
+		conclude_intake(false, None);
+		assert_eq!(Members::<Test>::get(10).unwrap().strikes, 3);
+
+		// Replace the head
+		assert_ok!(Society::bid(Origin::signed(50), 0));
+		next_intake();
+		assert_ok!(Society::vote(Origin::signed(10), 50, true));
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 50]);
+		assert_eq!(Head::<Test>::get(), Some(10));
+		next_intake();
+		assert_eq!(Head::<Test>::get(), Some(50));
+		// Founder is unchanged
+		assert_eq!(Founder::<Test>::get(), Some(10));
+
+		// 50 can still accumulate strikes
+		assert_ok!(Society::bid(Origin::signed(60), 0));
+		next_intake();
+		// Force 50 to be Skeptic so it gets a strike.
+		Skeptic::<Test>::put(50);
+		conclude_intake(false, None);
+		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 1);
+		assert_ok!(Society::bid(Origin::signed(70), 0));
+		next_intake();
+		// Force 50 to be Skeptic so it gets a strike.
+		Skeptic::<Test>::put(50);
+		conclude_intake(false, None);
+		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 2);
+
+		// Replace the head
+		assert_ok!(Society::bid(Origin::signed(80), 0));
+		next_intake();
+		assert_ok!(Society::vote(Origin::signed(10), 80, true));
+		assert_ok!(Society::vote(Origin::signed(50), 80, true));
+		conclude_intake(false, None);
+		next_intake();
+		assert_eq!(members(), vec![10, 50, 80]);
+		assert_eq!(Head::<Test>::get(), Some(80));
+		assert_eq!(Founder::<Test>::get(), Some(10));
+
+		// 50 can now be suspended for strikes
+		assert_ok!(Society::bid(Origin::signed(90), 0));
+		next_intake();
+		// Force 50 to be Skeptic and get it a strike.
+		Skeptic::<Test>::put(50);
+		conclude_intake(false, None);
+		next_intake();
+		assert_eq!(
+			SuspendedMembers::<Test>::get(50),
+			Some(MemberRecord { rank: 0, strikes: 3, vouching: None, index: 1 })
+		);
+		assert_eq!(members(), vec![10, 80]);
+	});
+}
+
+#[test]
+fn challenges_work() {
+	EnvBuilder::new().execute(|| {
+		// Add some members
+		place_members([20, 30, 40]);
+		// Votes are empty
+		assert_eq!(DefenderVotes::<Test>::get(0, 10), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 20), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 30), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 40), None);
+		// Check starting point
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		assert_eq!(Defending::<Test>::get(), None);
+
+		// 30 will be challenged during the challenge rotation
+		next_challenge();
+		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
+		// They can always free vote for themselves
+		assert_ok!(Society::defender_vote(Origin::signed(30), true));
+
+		// If no one else votes, nothing happens
+		next_challenge();
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		// Reset votes for last challenge
+		assert_ok!(Society::cleanup_challenge(Origin::signed(0), 0, 10));
+		// New challenge period
+		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
+		// Non-member cannot vote
+		assert_noop!(Society::defender_vote(Origin::signed(1), true), Error::<Test>::NotMember);
+		// 3 people say accept, 1 reject
+		assert_ok!(Society::defender_vote(Origin::signed(10), true));
+		assert_ok!(Society::defender_vote(Origin::signed(20), true));
+		assert_ok!(Society::defender_vote(Origin::signed(30), true));
+		assert_ok!(Society::defender_vote(Origin::signed(40), false));
+
+		next_challenge();
+		// 30 survives
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		// Reset votes for last challenge
+		assert_ok!(Society::cleanup_challenge(Origin::signed(0), 1, 10));
+		// Votes are reset
+		assert_eq!(DefenderVotes::<Test>::get(0, 10), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 20), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 30), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 40), None);
+
+		// One more time
+		assert_eq!(Defending::<Test>::get().unwrap().0, 30);
+		// 2 people say accept, 2 reject
+		assert_ok!(Society::defender_vote(Origin::signed(10), true));
+		assert_ok!(Society::defender_vote(Origin::signed(20), true));
+		assert_ok!(Society::defender_vote(Origin::signed(30), false));
+		assert_ok!(Society::defender_vote(Origin::signed(40), false));
+
+		next_challenge();
+		// 30 is suspended
+		assert_eq!(members(), vec![10, 20, 40]);
+		assert_eq!(
+			SuspendedMembers::<Test>::get(30),
+			Some(MemberRecord { rank: 0, strikes: 0, vouching: None, index: 2 })
+		);
+		// Reset votes for last challenge
+		assert_ok!(Society::cleanup_challenge(Origin::signed(0), 2, 10));
+		// New defender is chosen
+		assert_eq!(Defending::<Test>::get().unwrap().0, 20);
+		// Votes are reset
+		assert_eq!(DefenderVotes::<Test>::get(0, 10), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 20), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 30), None);
+		assert_eq!(DefenderVotes::<Test>::get(0, 40), None);
+	});
+}
+
+#[test]
+fn bad_vote_slash_works() {
+	EnvBuilder::new().execute(|| {
+		// Add some members
+		place_members([20, 30, 40, 50]);
+		assert_eq!(members(), vec![10, 20, 30, 40, 50]);
+		// Create some payouts
+		Society::bump_payout(&20, 5, 100);
+		Society::bump_payout(&30, 5, 100);
+		Society::bump_payout(&40, 5, 100);
+		Society::bump_payout(&50, 5, 100);
+		// Check starting point
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(40),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(50),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		// Create a new bid
+		assert_ok!(Society::bid(Origin::signed(60), 1000));
+		next_intake();
+		// Force 20 to be the skeptic, and make it vote against the settled majority.
+		Skeptic::<Test>::put(20);
+		assert_ok!(Society::vote(Origin::signed(20), 60, true));
+		assert_ok!(Society::vote(Origin::signed(30), 60, false));
+		assert_ok!(Society::vote(Origin::signed(40), 60, false));
+		assert_ok!(Society::vote(Origin::signed(50), 60, false));
+		conclude_intake(false, None);
+		// Wrong voter gained a strike
+		assert_eq!(Members::<Test>::get(20).unwrap().strikes, 1);
+		assert_eq!(Members::<Test>::get(30).unwrap().strikes, 0);
+		assert_eq!(Members::<Test>::get(40).unwrap().strikes, 0);
+		assert_eq!(Members::<Test>::get(50).unwrap().strikes, 0);
+		// Their payout is slashed, a random person is rewarded
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(5, 50)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(40),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(50),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+	});
+}
+
+#[test]
+fn user_cannot_bid_twice() {
+	EnvBuilder::new().execute(|| {
+		// Cannot bid twice
+		assert_ok!(Society::bid(Origin::signed(20), 100));
+		assert_noop!(Society::bid(Origin::signed(20), 100), Error::<Test>::AlreadyBid);
+		// Cannot bid when vouched
+		assert_ok!(Society::vouch(Origin::signed(10), 30, 100, 100));
+		assert_noop!(Society::bid(Origin::signed(30), 100), Error::<Test>::AlreadyBid);
+		// Cannot vouch when already bid
+		place_members([50]);
+		assert_noop!(Society::vouch(Origin::signed(50), 20, 100, 100), Error::<Test>::AlreadyBid);
+	});
+}
+
+#[test]
+fn vouching_handles_removed_member_with_bid() {
+	EnvBuilder::new().execute(|| {
+		// Add a member
+		place_members([20]);
+		// Have that member vouch for a user
+		assert_ok!(Society::vouch(RuntimeOrigin::signed(20), 30, 1000, 100));
+		// That user is now a bid and the member is vouching
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 100), 1000)]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
+		// Suspend that member
+		assert_ok!(Society::suspend_member(&20));
+		// Bid is removed, vouching status is removed
+		let r = MemberRecord { rank: 0, strikes: 0, vouching: None, index: 1 };
+		assert_eq!(SuspendedMembers::<Test>::get(20), Some(r));
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![]);
+		assert_eq!(Members::<Test>::get(20), None);
+	});
+}
+
+#[test]
+fn vouching_handles_removed_member_with_candidate() {
+	EnvBuilder::new().execute(|| {
+		// Add a member
+		place_members([20]);
+		// Have that member vouch for a user
+		assert_ok!(Society::vouch(RuntimeOrigin::signed(20), 30, 1000, 100));
+		// That user is now a bid and the member is vouching
+		assert_eq!(Bids::<Test>::get().into_inner(), vec![bid(30, Vouch(20, 100), 1000)]);
+		assert_eq!(Members::<Test>::get(20).unwrap().vouching, Some(VouchingStatus::Vouching));
+
+		// Make that bid a candidate
+		next_intake();
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, Vouch(20, 100), 0, 0))]);
+		// Suspend that member
+		assert_ok!(Society::suspend_member(&20));
+		assert_eq!(SuspendedMembers::<Test>::contains_key(20), true);
+
+		// Nothing changes yet in the candidacy, though the member now forgets.
+		assert_eq!(candidacies(), vec![(30, candidacy(1, 1000, Vouch(20, 100), 0, 0))]);
+
+		// Candidate wins
+		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		conclude_intake(false, None);
+		assert_eq!(members(), vec![10, 30]);
+		// Payout does not go to removed member
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
+		assert_eq!(
+			Payouts::<Test>::get(30),
+			PayoutRecord { paid: 0, payouts: vec![(8, 1000)].try_into().unwrap() }
+		);
+	});
+}
+
+#[test]
+fn votes_are_working() {
+	EnvBuilder::new().execute(|| {
+		place_members([20]);
+		// Users make bids of various amounts
+		assert_ok!(Society::bid(RuntimeOrigin::signed(50), 500));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(40), 400));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(30), 300));
+		// Rotate period
+		next_intake();
+		// A member votes for these candidates to join the society
+		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		assert_ok!(Society::vote(Origin::signed(20), 30, true));
+		assert_ok!(Society::vote(Origin::signed(10), 40, true));
+		// You cannot vote for a non-candidate
+		assert_noop!(Society::vote(Origin::signed(10), 50, true), Error::<Test>::NotCandidate);
+		// Votes are stored
+		assert_eq!(Votes::<Test>::get(30, 10), Some(Vote { approve: true, weight: 4 }));
+		assert_eq!(Votes::<Test>::get(30, 20), Some(Vote { approve: true, weight: 1 }));
+		assert_eq!(Votes::<Test>::get(40, 10), Some(Vote { approve: true, weight: 4 }));
+		assert_eq!(Votes::<Test>::get(50, 10), None);
+		conclude_intake(false, None);
+		// Cleanup the candidacy
+		assert_ok!(Society::cleanup_candidacy(Origin::signed(0), 30, 10));
+		assert_ok!(Society::cleanup_candidacy(Origin::signed(0), 40, 10));
+		// Candidates become members after a period rotation
+		assert_eq!(members(), vec![10, 20, 30, 40]);
+		// Votes are cleaned up
+		assert_eq!(Votes::<Test>::get(30, 10), None);
+		assert_eq!(Votes::<Test>::get(30, 20), None);
+		assert_eq!(Votes::<Test>::get(40, 10), None);
+	});
+}
+
+#[test]
+fn max_bids_work() {
+	EnvBuilder::new().execute(|| {
+		// Max bids is 1000, when extra bids come in, it pops the larger ones off the stack.
+		// Try to put 1010 users into the bid pool
+		for i in (0..=10).rev() {
+			// Give them some funds and bid
+			let _ = Balances::make_free_balance_be(&((i + 100) as u128), 1000);
+			assert_ok!(Society::bid(Origin::signed((i + 100) as u128), i));
+		}
+		let bids = Bids::<Test>::get();
+		// Length is 1000
+		assert_eq!(bids.len(), 10);
+		// First bid is smallest number (100)
+		assert_eq!(bids[0], bid(100, Deposit(25), 0));
+		// Last bid is smallest number + 99 (1099)
+		assert_eq!(bids[9], bid(109, Deposit(25), 9));
+	});
+}
+
+#[test]
+fn candidates_are_limited_by_membership_size() {
+	EnvBuilder::new().execute(|| {
+		// Fill up some membership
+		place_members([1, 2, 3, 4, 5, 6, 7, 8]);
+		// One place left from 10
+		assert_eq!(members().len(), 9);
+
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		assert_ok!(Society::bid(Origin::signed(30), 1));
+		next_intake();
+		assert_eq!(candidates().len(), 1);
+	});
+}
+
+#[test]
+fn candidates_are_limited_by_maximum() {
+	EnvBuilder::new().execute(|| {
+		// Nine places left from 10
+		assert_eq!(members().len(), 1);
+
+		// Nine bids
+		for i in (1..=9).rev() {
+			// Give them some funds and bid
+			let _ = Balances::make_free_balance_be(&((i + 100) as u128), 1000);
+			assert_ok!(Society::bid(Origin::signed((i + 100) as u128), i));
+		}
+		next_intake();
+
+		// Still only 8 candidates.
+		assert_eq!(candidates().len(), 8);
+	});
+}
+
+#[test]
+fn too_many_candidates_cannot_overflow_membership() {
+	EnvBuilder::new().execute(|| {
+		// One place left
+		place_members([1, 2, 3, 4, 5, 6, 7, 8]);
+		assert_ok!(Society::bid(Origin::signed(20), 0));
+		assert_ok!(Society::bid(Origin::signed(30), 1));
+		next_intake();
+		// Candidate says a candidate.
+		next_intake();
+		// Another candidate taken.
+		// Both approved.
+		assert_ok!(Society::vote(Origin::signed(10), 20, true));
+		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		next_voting();
+		assert_ok!(Society::claim_membership(Origin::signed(20)));
+		assert_noop!(Society::claim_membership(Origin::signed(30)), Error::<Test>::MaxMembers);
+
+		// Maximum members.
+		assert_eq!(members().len(), 10);
+		// Still 1 candidate.
+		assert_eq!(candidates().len(), 1);
+
+		// Increase max-members and the candidate can get in.
+		assert_ok!(Society::set_parameters(Origin::signed(10), 11, 8, 3, 25));
+		assert_ok!(Society::claim_membership(Origin::signed(30)));
+	});
+}
+
+#[test]
+fn zero_bid_works() {
+	// This tests:
+	// * Only one zero bid is selected.
+	// * That zero bid is placed as head when accepted.
+	EnvBuilder::new().execute(|| {
+		// Users make bids of various amounts
+		assert_ok!(Society::bid(RuntimeOrigin::signed(60), 400));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(50), 300));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(30), 0));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(20), 0));
+		assert_ok!(Society::bid(RuntimeOrigin::signed(40), 0));
+
+		// Rotate period
+		next_intake();
+		// Pot is 1000 after "PeriodSpend"
+		assert_eq!(Pot::<Test>::get(), 1000);
+		assert_eq!(Balances::free_balance(Society::account_id()), 10_000);
+		// Choose smallest bidding users whose total is less than pot, with only one zero bid.
+		assert_eq!(
+			candidacies(),
+			vec![
+				(30, candidacy(1, 0, Deposit(25), 0, 0)),
+				(50, candidacy(1, 300, Deposit(25), 0, 0)),
+				(60, candidacy(1, 400, Deposit(25), 0, 0)),
+			]
+		);
+		assert_eq!(Bids::<Test>::get(), vec![bid(20, Deposit(25), 0), bid(40, Deposit(25), 0),],);
+		// A member votes for these candidates to join the society
+		assert_ok!(Society::vote(Origin::signed(10), 30, true));
+		assert_ok!(Society::vote(Origin::signed(10), 50, true));
+		assert_ok!(Society::vote(Origin::signed(10), 60, true));
+		conclude_intake(false, None);
+		// Candidates become members after a period rotation
+		assert_eq!(members(), vec![10, 30, 50, 60]);
+		next_intake();
+		// The zero bid is selected as head
+		assert_eq!(Head::<Test>::get(), Some(30));
+	});
+}
+
+#[test]
+fn bids_ordered_correctly() {
+	// This tests that bids with the same value are placed in the list ordered
+	// with bidders who bid first earlier on the list.
+	EnvBuilder::new().execute(|| {
+		for i in 0..5 {
+			for j in 0..5 {
+				// Give them some funds
+				let who = 100 + (i * 5 + j) as u128;
+				let _ = Balances::make_free_balance_be(&who, 1000);
+				assert_ok!(Society::bid(Origin::signed(who), j));
+			}
+		}
+
+		let mut final_list = Vec::new();
+
+		for j in 0..5 {
+			for i in 0..5 {
+				final_list.push(bid(100 + (i * 5 + j) as u128, Deposit(25), j));
+			}
+		}
+		let max_bids: u32 = <Test as Config>::MaxBids::get();
+		final_list.truncate(max_bids as usize);
+		assert_eq!(Bids::<Test>::get(), final_list);
+	});
+}
+
+#[test]
+fn waive_repay_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20, 30]);
+		Society::bump_payout(&20, 5, 100);
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![(5, 100)].try_into().unwrap() }
+		);
+		assert_eq!(Members::<Test>::get(20).unwrap().rank, 0);
+		assert_ok!(Society::waive_repay(Origin::signed(20), 100));
+		assert_eq!(
+			Payouts::<Test>::get(20),
+			PayoutRecord { paid: 0, payouts: vec![].try_into().unwrap() }
+		);
+		assert_eq!(Members::<Test>::get(10).unwrap().rank, 1);
+		assert_eq!(Balances::free_balance(20), 50);
+	});
+}
+
+#[test]
+fn punish_skeptic_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20]);
+		assert_ok!(Society::bid(Origin::signed(30), 0));
+		next_intake();
+		// Force 20 to be Skeptic so it gets a strike.
+		Skeptic::<Test>::put(20);
+		next_voting();
+		// 30 decides to punish the skeptic (20).
+		assert_ok!(Society::punish_skeptic(Origin::signed(30)));
+		// 20 gets 1 strike.
+		assert_eq!(Members::<Test>::get(20).unwrap().strikes, 1);
+		let candidacy = Candidates::<Test>::get(&30).unwrap();
+		// 30 candidacy has changed.
+		assert_eq!(candidacy.skeptic_struck, true);
+	});
+}
+
+#[test]
+fn resign_candidacy_works() {
+	EnvBuilder::new().execute(|| {
+		assert_ok!(Society::bid(Origin::signed(30), 45));
+		next_intake();
+		assert_eq!(candidates(), vec![30]);
+		assert_ok!(Society::resign_candidacy(Origin::signed(30)));
+		// 30 candidacy has gone.
+		assert_eq!(candidates(), vec![]);
+	});
+}
+
+#[test]
+fn drop_candidate_works() {
+	EnvBuilder::new().execute(|| {
+		place_members([20, 30]);
+		assert_ok!(Society::bid(Origin::signed(40), 45));
+		next_intake();
+		assert_eq!(candidates(), vec![40]);
+		assert_ok!(Society::vote(Origin::signed(10), 40, false));
+		assert_ok!(Society::vote(Origin::signed(20), 40, false));
+		assert_ok!(Society::vote(Origin::signed(30), 40, false));
+		run_to_block(12);
+		assert_ok!(Society::drop_candidate(Origin::signed(50), 40));
+		// 40 candidacy has gone.
+		assert_eq!(candidates(), vec![]);
+	});
+}
diff --git a/substrate/frame/society/src/weights.rs b/substrate/frame/society/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d113f617c886ca7f694e0601d7bc6531800296db
--- /dev/null
+++ b/substrate/frame/society/src/weights.rs
@@ -0,0 +1,375 @@
+// 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.
+
+//! Autogenerated weights for pallet_society
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2022-09-13, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_society
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --template=./.maintain/frame-weight-template.hbs
+// --header=./HEADER-APACHE2
+// --output=./frame/society/src/weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_society.
+pub trait WeightInfo {
+	fn bid() -> Weight;
+	fn unbid() -> Weight;
+	fn vouch() -> Weight;
+	fn unvouch() -> Weight;
+	fn vote() -> Weight;
+	fn defender_vote() -> Weight;
+	fn payout() -> Weight;
+	fn waive_repay() -> Weight;
+	fn found_society() -> Weight;
+	fn dissolve() -> Weight;
+	fn judge_suspended_member() -> Weight;
+	fn set_parameters() -> Weight;
+	fn punish_skeptic() -> Weight;
+	fn claim_membership() -> Weight;
+	fn bestow_membership() -> Weight;
+	fn kick_candidate() -> Weight;
+	fn resign_candidacy() -> Weight;
+	fn drop_candidate() -> Weight;
+	fn cleanup_candidacy() -> Weight;
+	fn cleanup_challenge() -> Weight;
+}
+
+/// Weights for pallet_society using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	fn bid() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Bids (r:1 w:1)
+	fn unbid() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:2 w:1)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	fn vouch() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Members (r:1 w:1)
+	fn unvouch() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Votes (r:1 w:1)
+	fn vote() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Defending (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:1 w:1)
+	fn defender_vote() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Payouts (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	fn payout() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:1)
+	fn waive_repay() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Head (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Founder (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	fn found_society() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society Head (r:0 w:1)
+	// Storage: Society Defending (r:0 w:1)
+	// Storage: Society ChallengeRoundCount (r:0 w:1)
+	// Storage: Society MemberByIndex (r:0 w:5)
+	// Storage: Society Skeptic (r:0 w:1)
+	// Storage: Society Candidates (r:0 w:4)
+	// Storage: Society Pot (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Votes (r:0 w:4)
+	// Storage: Society Members (r:0 w:5)
+	// Storage: Society RoundCount (r:0 w:1)
+	// Storage: Society Bids (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	// Storage: Society NextHead (r:0 w:1)
+	fn dissolve() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:0)
+	// Storage: Society Pot (r:1 w:1)
+	fn judge_suspended_member() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:0)
+	// Storage: Society Parameters (r:0 w:1)
+	fn set_parameters() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Skeptic (r:1 w:0)
+	// Storage: Society Votes (r:1 w:0)
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Parameters (r:1 w:0)
+	fn punish_skeptic() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn claim_membership() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn bestow_membership() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn kick_candidate() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn resign_candidacy() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn drop_candidate() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society VoteClearCursor (r:1 w:0)
+	// Storage: Society Votes (r:0 w:2)
+	fn cleanup_candidacy() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:0 w:1)
+	fn cleanup_challenge() -> Weight {
+		Weight::zero()
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	fn bid() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Bids (r:1 w:1)
+	fn unbid() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society Members (r:2 w:1)
+	// Storage: Society SuspendedMembers (r:1 w:0)
+	fn vouch() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Bids (r:1 w:1)
+	// Storage: Society Members (r:1 w:1)
+	fn unvouch() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Votes (r:1 w:1)
+	fn vote() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Defending (r:1 w:1)
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:1 w:1)
+	fn defender_vote() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Members (r:1 w:0)
+	// Storage: Society Payouts (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	fn payout() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:1)
+	fn waive_repay() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Head (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Founder (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	fn found_society() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:1)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society Head (r:0 w:1)
+	// Storage: Society Defending (r:0 w:1)
+	// Storage: Society ChallengeRoundCount (r:0 w:1)
+	// Storage: Society MemberByIndex (r:0 w:5)
+	// Storage: Society Skeptic (r:0 w:1)
+	// Storage: Society Candidates (r:0 w:4)
+	// Storage: Society Pot (r:0 w:1)
+	// Storage: Society Rules (r:0 w:1)
+	// Storage: Society Votes (r:0 w:4)
+	// Storage: Society Members (r:0 w:5)
+	// Storage: Society RoundCount (r:0 w:1)
+	// Storage: Society Bids (r:0 w:1)
+	// Storage: Society Parameters (r:0 w:1)
+	// Storage: Society NextHead (r:0 w:1)
+	fn dissolve() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society SuspendedMembers (r:1 w:1)
+	// Storage: Society Payouts (r:1 w:0)
+	// Storage: Society Pot (r:1 w:1)
+	fn judge_suspended_member() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:0)
+	// Storage: Society Parameters (r:0 w:1)
+	fn set_parameters() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Skeptic (r:1 w:0)
+	// Storage: Society Votes (r:1 w:0)
+	// Storage: Society Members (r:1 w:1)
+	// Storage: Society Parameters (r:1 w:0)
+	fn punish_skeptic() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn claim_membership() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	// Storage: Society Parameters (r:1 w:0)
+	// Storage: Society MemberCount (r:1 w:1)
+	// Storage: Society NextHead (r:1 w:1)
+	// Storage: System Account (r:1 w:1)
+	// Storage: Society MemberByIndex (r:0 w:1)
+	// Storage: Society Members (r:0 w:1)
+	fn bestow_membership() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Founder (r:1 w:0)
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn kick_candidate() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn resign_candidacy() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:1)
+	// Storage: Society RoundCount (r:1 w:0)
+	fn drop_candidate() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society Candidates (r:1 w:0)
+	// Storage: Society VoteClearCursor (r:1 w:0)
+	// Storage: Society Votes (r:0 w:2)
+	fn cleanup_candidacy() -> Weight {
+		Weight::zero()
+	}
+	// Storage: Society ChallengeRoundCount (r:1 w:0)
+	// Storage: Society DefenderVotes (r:0 w:1)
+	fn cleanup_challenge() -> Weight {
+		Weight::zero()
+	}
+}
diff --git a/substrate/frame/staking/Cargo.toml b/substrate/frame/staking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2ad9b44d7b4b2016d2540eb14367fea5448a764d
--- /dev/null
+++ b/substrate/frame/staking/Cargo.toml
@@ -0,0 +1,99 @@
+[package]
+name = "pallet-staking"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet staking"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+serde = { version = "1.0.163", default-features = false, features = ["alloc", "derive"]}
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-session = { version = "4.0.0-dev", default-features = false, features = [
+	"historical",
+], path = "../session" }
+pallet-authorship = { version = "4.0.0-dev", default-features = false, path = "../authorship" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto", features = ["serde"] }
+frame-election-provider-support = { version = "4.0.0-dev", default-features = false, path = "../election-provider-support" }
+log = { version = "0.4.17", default-features = false }
+
+# Optional imports for benchmarking
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
+rand_chacha = { version = "0.2", default-features = false, optional = true }
+
+[dev-dependencies]
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-npos-elections = { version = "4.0.0-dev", path = "../../primitives/npos-elections" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../timestamp" }
+pallet-staking-reward-curve = { version = "4.0.0-dev", path = "../staking/reward-curve" }
+pallet-bags-list = { version = "4.0.0-dev", path = "../bags-list" }
+substrate-test-utils = { version = "4.0.0-dev", path = "../../test-utils" }
+frame-benchmarking = { version = "4.0.0-dev", path = "../benchmarking" }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../election-provider-support" }
+rand_chacha = { version = "0.2" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-election-provider-support/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-authorship/std",
+	"pallet-bags-list/std",
+	"pallet-balances/std",
+	"pallet-session/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-npos-elections/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+	"sp-tracing/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-election-provider-support/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-bags-list/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"rand_chacha",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-election-provider-support/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-authorship/try-runtime",
+	"pallet-bags-list/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-session/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/staking/README.md b/substrate/frame/staking/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ccb9901a6796ed3e97a139806770531ebef9f5ae
--- /dev/null
+++ b/substrate/frame/staking/README.md
@@ -0,0 +1,261 @@
+# Staking Module
+
+The Staking module is used to manage funds at stake by network maintainers.
+
+- [`staking::Config`](https://docs.rs/pallet-staking/latest/pallet_staking/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html)
+- [`Module`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.Module.html)
+
+## Overview
+
+The Staking module is the means by which a set of network maintainers (known as _authorities_ in
+some contexts and _validators_ in others) are chosen based upon those who voluntarily place
+funds under deposit. Under deposit, those funds are rewarded under normal operation but are held
+at pain of _slash_ (expropriation) should the staked maintainer be found not to be discharging
+its duties properly.
+
+### Terminology
+<!-- Original author of paragraph: @gavofyork -->
+
+- Staking: The process of locking up funds for some time, placing them at risk of slashing
+  (loss) in order to become a rewarded maintainer of the network.
+- Validating: The process of running a node to actively maintain the network, either by
+  producing blocks or guaranteeing finality of the chain.
+- Nominating: The process of placing staked funds behind one or more validators in order to
+  share in any reward, and punishment, they take.
+- Stash account: The account holding an owner's funds used for staking.
+- Controller account: The account that controls an owner's funds for staking.
+- Era: A (whole) number of sessions, which is the period that the validator set (and each
+  validator's active nominator set) is recalculated and where rewards are paid out.
+- Slash: The punishment of a staker by reducing its funds.
+
+### Goals
+<!-- Original author of paragraph: @gavofyork -->
+
+The staking system in Substrate NPoS is designed to make the following possible:
+
+- Stake funds that are controlled by a cold wallet.
+- Withdraw some, or deposit more, funds without interrupting the role of an entity.
+- Switch between roles (nominator, validator, idle) with minimal overhead.
+
+### Scenarios
+
+#### Staking
+
+Almost any interaction with the Staking module requires a process of _**bonding**_ (also known
+as being a _staker_). To become *bonded*, a fund-holding account known as the _stash account_,
+which holds some or all of the funds that become frozen in place as part of the staking process,
+is paired with an active **controller** account, which issues instructions on how they shall be
+used.
+
+An account pair can become bonded using the [`bond`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.bond) call.
+
+Stash accounts can update their associated controller back to their stash account using the
+[`set_controller`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.set_controller)
+call. 
+
+Note: Controller accounts are being deprecated in favor of proxy accounts, so it is no longer
+possible to set a unique address for a stash's controller.
+
+There are three possible roles that any staked account pair can be in: `Validator`, `Nominator`
+and `Idle` (defined in [`StakerStatus`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.StakerStatus.html)). There are three
+corresponding instructions to change between roles, namely:
+[`validate`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.validate),
+[`nominate`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.nominate), and [`chill`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.chill).
+
+#### Validating
+
+A **validator** takes the role of either validating blocks or ensuring their finality,
+maintaining the veracity of the network. A validator should avoid both any sort of malicious
+misbehavior and going offline. Bonded accounts that state interest in being a validator do NOT
+get immediately chosen as a validator. Instead, they are declared as a _candidate_ and they
+_might_ get elected at the _next era_ as a validator. The result of the election is determined
+by nominators and their votes.
+
+An account can become a validator candidate via the
+[`validate`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.validate) call.
+
+#### Nomination
+
+A **nominator** does not take any _direct_ role in maintaining the network, instead, it votes on
+a set of validators  to be elected. Once interest in nomination is stated by an account, it
+takes effect at the next election round. The funds in the nominator's stash account indicate the
+_weight_ of its vote. Both the rewards and any punishment that a validator earns are shared
+between the validator and its nominators. This rule incentivizes the nominators to NOT vote for
+the misbehaving/offline validators as much as possible, simply because the nominators will also
+lose funds if they vote poorly.
+
+An account can become a nominator via the [`nominate`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.nominate) call.
+
+#### Rewards and Slash
+
+The **reward and slashing** procedure is the core of the Staking module, attempting to _embrace
+valid behavior_ while _punishing any misbehavior or lack of availability_.
+
+Rewards must be claimed for each era before it gets too old by `$HISTORY_DEPTH` using the
+`payout_stakers` call. Any account can call `payout_stakers`, which pays the reward to the
+validator as well as its nominators. Only the [`Config::MaxNominatorRewardedPerValidator`]
+biggest stakers can claim their reward. This is to limit the i/o cost to mutate storage for each
+nominator's account.
+
+Slashing can occur at any point in time, once misbehavior is reported. Once slashing is
+determined, a value is deducted from the balance of the validator and all the nominators who
+voted for this validator (values are deducted from the _stash_ account of the slashed entity).
+
+Slashing logic is further described in the documentation of the `slashing` module.
+
+Similar to slashing, rewards are also shared among a validator and its associated nominators.
+Yet, the reward funds are not always transferred to the stash account and can be configured. See
+[Reward Calculation](https://docs.rs/pallet-staking/latest/pallet_staking/#reward-calculation) for more details.
+
+#### Chilling
+
+Finally, any of the roles above can choose to step back temporarily and just chill for a while.
+This means that if they are a nominator, they will not be considered as voters anymore and if
+they are validators, they will no longer be a candidate for the next election.
+
+An account can step back via the [`chill`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.chill) call.
+
+### Session managing
+
+The module implement the trait `SessionManager`. Which is the only API to query new validator
+set and allowing these validator set to be rewarded once their era is ended.
+
+## Interface
+
+### Dispatchable Functions
+
+The dispatchable functions of the Staking module enable the steps needed for entities to accept
+and change their role, alongside some helper functions to get/set the metadata of the module.
+
+### Public Functions
+
+The Staking module contains many public storage items and (im)mutable functions.
+
+## Usage
+
+### Example: Rewarding a validator by id.
+
+```rust
+use pallet_staking::{self as staking};
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config + staking::Config {}
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        /// Reward a validator.
+        #[pallet::weight(0)]
+        pub fn reward_myself(origin: OriginFor<T>) -> DispatchResult {
+            let reported = ensure_signed(origin)?;
+            <staking::Pallet<T>>::reward_by_ids(vec![(reported, 10)]);
+            Ok(())
+        }
+    }
+}
+```
+
+## Implementation Details
+
+### Era payout
+
+The era payout is computed using yearly inflation curve defined at
+[`T::RewardCurve`](https://docs.rs/pallet-staking/latest/pallet_staking/trait.Config.html#associatedtype.RewardCurve) as such:
+
+```nocompile
+staker_payout = yearly_inflation(npos_token_staked / total_tokens) * total_tokens / era_per_year
+```
+This payout is used to reward stakers as defined in next section
+
+```nocompile
+remaining_payout = max_yearly_inflation * total_tokens / era_per_year - staker_payout
+```
+The remaining reward is send to the configurable end-point
+[`T::RewardRemainder`](https://docs.rs/pallet-staking/latest/pallet_staking/trait.Config.html#associatedtype.RewardRemainder).
+
+### Reward Calculation
+
+Validators and nominators are rewarded at the end of each era. The total reward of an era is
+calculated using the era duration and the staking rate (the total amount of tokens staked by
+nominators and validators, divided by the total token supply). It aims to incentivize toward a
+defined staking rate. The full specification can be found
+[here](https://research.web3.foundation/en/latest/polkadot/economics/1-token-economics.html#inflation-model).
+
+Total reward is split among validators and their nominators depending on the number of points
+they received during the era. Points are added to a validator using
+[`reward_by_ids`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.reward_by_ids) or
+[`reward_by_indices`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.reward_by_indices).
+
+[`Module`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.Module.html) implements
+[`pallet_authorship::EventHandler`](https://docs.rs/pallet-authorship/latest/pallet_authorship/trait.EventHandler.html) to add reward
+points to block producer and block producer of referenced uncles.
+
+The validator and its nominator split their reward as following:
+
+The validator can declare an amount, named
+[`commission`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.ValidatorPrefs.html#structfield.commission), that does not get shared
+with the nominators at each reward payout through its
+[`ValidatorPrefs`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.ValidatorPrefs.html). This value gets deducted from the total reward
+that is paid to the validator and its nominators. The remaining portion is split among the
+validator and all of the nominators that nominated the validator, proportional to the value
+staked behind this validator (_i.e._ dividing the
+[`own`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.Exposure.html#structfield.own) or
+[`others`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.Exposure.html#structfield.others) by
+[`total`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.Exposure.html#structfield.total) in [`Exposure`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.Exposure.html)).
+
+All entities who receive a reward have the option to choose their reward destination through the
+[`Payee`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.Payee.html) storage item (see
+[`set_payee`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.set_payee)), to be one of the following:
+
+- Controller account, (obviously) not increasing the staked value.
+- Stash account, not increasing the staked value.
+- Stash account, also increasing the staked value.
+
+### Additional Fund Management Operations
+
+Any funds already placed into stash can be the target of the following operations:
+
+The controller account can free a portion (or all) of the funds using the
+[`unbond`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.unbond) call. Note that the funds are not immediately
+accessible. Instead, a duration denoted by [`BondingDuration`](https://docs.rs/pallet-staking/latest/pallet_staking/trait.Config.html#associatedtype.BondingDuration)
+(in number of eras) must pass until the funds can actually be removed. Once the
+`BondingDuration` is over, the [`withdraw_unbonded`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.withdraw_unbonded)
+call can be used to actually withdraw the funds.
+
+Note that there is a limitation to the number of fund-chunks that can be scheduled to be
+unlocked in the future via [`unbond`](https://docs.rs/pallet-staking/latest/pallet_staking/enum.Call.html#variant.unbond). In case this maximum
+(`MAX_UNLOCKING_CHUNKS`) is reached, the bonded account _must_ first wait until a successful
+call to `withdraw_unbonded` to remove some of the chunks.
+
+### Election Algorithm
+
+The current election algorithm is implemented based on Phragmén. The reference implementation
+can be found [here](https://github.com/w3f/consensus/tree/master/NPoS).
+
+The election algorithm, aside from electing the validators with the most stake value and votes,
+tries to divide the nominator votes among candidates in an equal manner. To further assure this,
+an optional post-processing can be applied that iteratively normalizes the nominator staked
+values until the total difference among votes of a particular nominator are less than a
+threshold.
+
+## GenesisConfig
+
+The Staking module depends on the [`GenesisConfig`](https://docs.rs/pallet-staking/latest/pallet_staking/struct.GenesisConfig.html). The
+`GenesisConfig` is optional and allow to set some initial stakers.
+
+## Related Modules
+
+- [Balances](https://docs.rs/pallet-balances/latest/pallet_balances/): Used to manage values at stake.
+- [Session](https://docs.rs/pallet-session/latest/pallet_session/): Used to manage sessions. Also, a list of new
+  validators is stored in the Session module's `Validators` at the end of each era.
+
+License: Apache-2.0
diff --git a/substrate/frame/staking/reward-curve/Cargo.toml b/substrate/frame/staking/reward-curve/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b98ab8caef3113d81299357f02719b6c81da7b9b
--- /dev/null
+++ b/substrate/frame/staking/reward-curve/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "pallet-staking-reward-curve"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Reward Curve for FRAME staking pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro-crate = "1.1.3"
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full", "visit"] }
+
+[dev-dependencies]
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
diff --git a/substrate/frame/staking/reward-curve/src/lib.rs b/substrate/frame/staking/reward-curve/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ecf3af55379145cc85dea57cc1be998dc4d07079
--- /dev/null
+++ b/substrate/frame/staking/reward-curve/src/lib.rs
@@ -0,0 +1,444 @@
+// 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.
+
+//! Proc macro to generate the reward curve functions and tests.
+
+mod log;
+
+use log::log2;
+use proc_macro::TokenStream;
+use proc_macro2::{Span, TokenStream as TokenStream2};
+use proc_macro_crate::{crate_name, FoundCrate};
+use quote::{quote, ToTokens};
+use syn::parse::{Parse, ParseStream};
+
+/// Accepts a number of expressions to create a instance of PiecewiseLinear which represents the
+/// NPoS curve (as detailed
+/// [here](https://research.web3.foundation/en/latest/polkadot/overview/2-token-economics.html#inflation-model))
+/// for those parameters. Parameters are:
+/// - `min_inflation`: the minimal amount to be rewarded between validators, expressed as a fraction
+///   of total issuance. Known as `I_0` in the literature. Expressed in millionth, must be between 0
+///   and 1_000_000.
+///
+/// - `max_inflation`: the maximum amount to be rewarded between validators, expressed as a fraction
+///   of total issuance. This is attained only when `ideal_stake` is achieved. Expressed in
+///   millionth, must be between min_inflation and 1_000_000.
+///
+/// - `ideal_stake`: the fraction of total issued tokens that should be actively staked behind
+///   validators. Known as `x_ideal` in the literature. Expressed in millionth, must be between
+///   0_100_000 and 0_900_000.
+///
+/// - `falloff`: Known as `decay_rate` in the literature. A co-efficient dictating the strength of
+///   the global incentivization to get the `ideal_stake`. A higher number results in less typical
+///   inflation at the cost of greater volatility for validators. Expressed in millionth, must be
+///   between 0 and 1_000_000.
+///
+/// - `max_piece_count`: The maximum number of pieces in the curve. A greater number uses more
+///   resources but results in higher accuracy. Must be between 2 and 1_000.
+///
+/// - `test_precision`: The maximum error allowed in the generated test. Expressed in millionth,
+///   must be between 0 and 1_000_000.
+///
+/// # Example
+///
+/// ```
+/// # fn main() {}
+/// use sp_runtime::curve::PiecewiseLinear;
+///
+/// pallet_staking_reward_curve::build! {
+///     const I_NPOS: 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,
+///     );
+/// }
+/// ```
+#[proc_macro]
+pub fn build(input: TokenStream) -> TokenStream {
+	let input = syn::parse_macro_input!(input as INposInput);
+
+	let points = compute_points(&input);
+
+	let declaration = generate_piecewise_linear(points);
+	let test_module = generate_test_module(&input);
+
+	let imports = match crate_name("sp-runtime") {
+		Ok(FoundCrate::Itself) => quote!(
+			extern crate sp_runtime as _sp_runtime;
+		),
+		Ok(FoundCrate::Name(sp_runtime)) => {
+			let ident = syn::Ident::new(&sp_runtime, Span::call_site());
+			quote!( extern crate #ident as _sp_runtime; )
+		},
+		Err(e) => syn::Error::new(Span::call_site(), e).to_compile_error(),
+	};
+
+	let const_name = input.ident;
+	let const_type = input.typ;
+
+	quote!(
+		const #const_name: #const_type = {
+			#imports
+			#declaration
+		};
+		#test_module
+	)
+	.into()
+}
+
+const MILLION: u32 = 1_000_000;
+
+mod keyword {
+	syn::custom_keyword!(curve);
+	syn::custom_keyword!(min_inflation);
+	syn::custom_keyword!(max_inflation);
+	syn::custom_keyword!(ideal_stake);
+	syn::custom_keyword!(falloff);
+	syn::custom_keyword!(max_piece_count);
+	syn::custom_keyword!(test_precision);
+}
+
+struct INposInput {
+	ident: syn::Ident,
+	typ: syn::Type,
+	min_inflation: u32,
+	ideal_stake: u32,
+	max_inflation: u32,
+	falloff: u32,
+	max_piece_count: u32,
+	test_precision: u32,
+}
+
+struct Bounds {
+	min: u32,
+	min_strict: bool,
+	max: u32,
+	max_strict: bool,
+}
+
+impl Bounds {
+	fn check(&self, value: u32) -> bool {
+		let wrong = (self.min_strict && value <= self.min) ||
+			(!self.min_strict && value < self.min) ||
+			(self.max_strict && value >= self.max) ||
+			(!self.max_strict && value > self.max);
+
+		!wrong
+	}
+}
+
+impl core::fmt::Display for Bounds {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		write!(
+			f,
+			"{}{:07}; {:07}{}",
+			if self.min_strict { "]" } else { "[" },
+			self.min,
+			self.max,
+			if self.max_strict { "[" } else { "]" },
+		)
+	}
+}
+
+fn parse_field<Token: Parse + Default + ToTokens>(
+	input: ParseStream,
+	bounds: Bounds,
+) -> syn::Result<u32> {
+	<Token>::parse(input)?;
+	<syn::Token![:]>::parse(input)?;
+	let value_lit = syn::LitInt::parse(input)?;
+	let value: u32 = value_lit.base10_parse()?;
+	if !bounds.check(value) {
+		return Err(syn::Error::new(
+			value_lit.span(),
+			format!(
+				"Invalid {}: {},  must be in {}",
+				Token::default().to_token_stream(),
+				value,
+				bounds,
+			),
+		))
+	}
+
+	Ok(value)
+}
+
+impl Parse for INposInput {
+	fn parse(input: ParseStream) -> syn::Result<Self> {
+		let args_input;
+
+		<syn::Token![const]>::parse(input)?;
+		let ident = <syn::Ident>::parse(input)?;
+		<syn::Token![:]>::parse(input)?;
+		let typ = <syn::Type>::parse(input)?;
+		<syn::Token![=]>::parse(input)?;
+		<keyword::curve>::parse(input)?;
+		<syn::Token![!]>::parse(input)?;
+		syn::parenthesized!(args_input in input);
+		<syn::Token![;]>::parse(input)?;
+
+		if !input.is_empty() {
+			return Err(input.error("expected end of input stream, no token expected"))
+		}
+
+		let min_inflation = parse_field::<keyword::min_inflation>(
+			&args_input,
+			Bounds { min: 0, min_strict: true, max: 1_000_000, max_strict: false },
+		)?;
+		<syn::Token![,]>::parse(&args_input)?;
+		let max_inflation = parse_field::<keyword::max_inflation>(
+			&args_input,
+			Bounds { min: min_inflation, min_strict: true, max: 1_000_000, max_strict: false },
+		)?;
+		<syn::Token![,]>::parse(&args_input)?;
+		let ideal_stake = parse_field::<keyword::ideal_stake>(
+			&args_input,
+			Bounds { min: 0_100_000, min_strict: false, max: 0_900_000, max_strict: false },
+		)?;
+		<syn::Token![,]>::parse(&args_input)?;
+		let falloff = parse_field::<keyword::falloff>(
+			&args_input,
+			Bounds { min: 0_010_000, min_strict: false, max: 1_000_000, max_strict: false },
+		)?;
+		<syn::Token![,]>::parse(&args_input)?;
+		let max_piece_count = parse_field::<keyword::max_piece_count>(
+			&args_input,
+			Bounds { min: 2, min_strict: false, max: 1_000, max_strict: false },
+		)?;
+		<syn::Token![,]>::parse(&args_input)?;
+		let test_precision = parse_field::<keyword::test_precision>(
+			&args_input,
+			Bounds { min: 0, min_strict: false, max: 1_000_000, max_strict: false },
+		)?;
+		<Option<syn::Token![,]>>::parse(&args_input)?;
+
+		if !args_input.is_empty() {
+			return Err(args_input.error("expected end of input stream, no token expected"))
+		}
+
+		Ok(Self {
+			ident,
+			typ,
+			min_inflation,
+			ideal_stake,
+			max_inflation,
+			falloff,
+			max_piece_count,
+			test_precision,
+		})
+	}
+}
+
+struct INPoS {
+	i_0: u32,
+	i_ideal_times_x_ideal: u32,
+	i_ideal: u32,
+	x_ideal: u32,
+	d: u32,
+}
+
+impl INPoS {
+	fn from_input(input: &INposInput) -> Self {
+		INPoS {
+			i_0: input.min_inflation,
+			i_ideal: (input.max_inflation as u64 * MILLION as u64 / input.ideal_stake as u64)
+				.try_into()
+				.unwrap(),
+			i_ideal_times_x_ideal: input.max_inflation,
+			x_ideal: input.ideal_stake,
+			d: input.falloff,
+		}
+	}
+
+	// calculates x from:
+	// y = i_0 + (i_ideal * x_ideal - i_0) * 2^((x_ideal - x)/d)
+	// See web3 docs for the details
+	fn compute_opposite_after_x_ideal(&self, y: u32) -> u32 {
+		if y == self.i_0 {
+			return u32::MAX
+		}
+		// Note: the log term calculated here represents a per_million value
+		let log = log2(self.i_ideal_times_x_ideal - self.i_0, y - self.i_0);
+
+		let term: u32 = ((self.d as u64 * log as u64) / 1_000_000).try_into().unwrap();
+
+		self.x_ideal + term
+	}
+}
+
+fn compute_points(input: &INposInput) -> Vec<(u32, u32)> {
+	let inpos = INPoS::from_input(input);
+
+	let mut points = vec![(0, inpos.i_0), (inpos.x_ideal, inpos.i_ideal_times_x_ideal)];
+
+	// For each point p: (next_p.0 - p.0) < segment_length && (next_p.1 - p.1) < segment_length.
+	// This ensures that the total number of segment doesn't overflow max_piece_count.
+	let max_length = (input.max_inflation - input.min_inflation + 1_000_000 - inpos.x_ideal) /
+		(input.max_piece_count - 1);
+
+	let mut delta_y = max_length;
+	let mut y = input.max_inflation;
+
+	// The algorithm divide the curve in segment with vertical len and horizontal len less
+	// than `max_length`. This is not very accurate in case of very consequent steep.
+	while delta_y != 0 {
+		let next_y = y - delta_y;
+
+		if next_y <= input.min_inflation {
+			delta_y = delta_y.saturating_sub(1);
+			continue
+		}
+
+		let next_x = inpos.compute_opposite_after_x_ideal(next_y);
+
+		if (next_x - points.last().unwrap().0) > max_length {
+			delta_y = delta_y.saturating_sub(1);
+			continue
+		}
+
+		if next_x >= 1_000_000 {
+			let prev = points.last().unwrap();
+			// Compute the y corresponding to x=1_000_000 using the this point and the previous one.
+
+			let delta_y: u32 = ((next_x - 1_000_000) as u64 * (prev.1 - next_y) as u64 /
+				(next_x - prev.0) as u64)
+				.try_into()
+				.unwrap();
+
+			let y = next_y + delta_y;
+
+			points.push((1_000_000, y));
+			return points
+		}
+		points.push((next_x, next_y));
+		y = next_y;
+	}
+
+	points.push((1_000_000, inpos.i_0));
+
+	points
+}
+
+fn generate_piecewise_linear(points: Vec<(u32, u32)>) -> TokenStream2 {
+	let mut points_tokens = quote!();
+
+	let max = points
+		.iter()
+		.map(|&(_, x)| x)
+		.max()
+		.unwrap_or(0)
+		.checked_mul(1_000)
+		// clip at 1.0 for sanity only since it'll panic later if too high.
+		.unwrap_or(1_000_000_000);
+
+	for (x, y) in points {
+		let error = || {
+			panic!(
+				"Generated reward curve approximation doesn't fit into [0, 1] -> [0, 1] because \
+				 of point:
+			x = {:07} per million
+			y = {:07} per million",
+				x, y
+			)
+		};
+
+		let x_perbill = x.checked_mul(1_000).unwrap_or_else(error);
+		let y_perbill = y.checked_mul(1_000).unwrap_or_else(error);
+
+		points_tokens.extend(quote!(
+			(
+				_sp_runtime::Perbill::from_parts(#x_perbill),
+				_sp_runtime::Perbill::from_parts(#y_perbill),
+			),
+		));
+	}
+
+	quote!(
+		_sp_runtime::curve::PiecewiseLinear::<'static> {
+			points: & [ #points_tokens ],
+			maximum: _sp_runtime::Perbill::from_parts(#max),
+		}
+	)
+}
+
+fn generate_test_module(input: &INposInput) -> TokenStream2 {
+	let inpos = INPoS::from_input(input);
+
+	let ident = &input.ident;
+	let precision = input.test_precision;
+	let i_0 = inpos.i_0 as f64 / MILLION as f64;
+	let i_ideal_times_x_ideal = inpos.i_ideal_times_x_ideal as f64 / MILLION as f64;
+	let i_ideal = inpos.i_ideal as f64 / MILLION as f64;
+	let x_ideal = inpos.x_ideal as f64 / MILLION as f64;
+	let d = inpos.d as f64 / MILLION as f64;
+	let max_piece_count = input.max_piece_count;
+
+	quote!(
+		#[cfg(test)]
+		mod __pallet_staking_reward_curve_test_module {
+			fn i_npos(x: f64) -> f64 {
+				if x <= #x_ideal {
+					#i_0 + x * (#i_ideal - #i_0 / #x_ideal)
+				} else {
+					#i_0 + (#i_ideal_times_x_ideal - #i_0) * 2_f64.powf((#x_ideal - x) / #d)
+				}
+			}
+
+			const MILLION: u32 = 1_000_000;
+
+			#[test]
+			fn reward_curve_precision() {
+				for &base in [MILLION, u32::MAX].iter() {
+					let number_of_check = 100_000.min(base);
+					for check_index in 0..=number_of_check {
+						let i = (check_index as u64 * base as u64 / number_of_check as u64) as u32;
+						let x = i as f64 / base as f64;
+						let float_res = (i_npos(x) * base as f64).round() as u32;
+						let int_res = super::#ident.calculate_for_fraction_times_denominator(i, base);
+						let err = (
+							(float_res.max(int_res) - float_res.min(int_res)) as u64
+							* MILLION as u64
+							/ float_res as u64
+						) as u32;
+						if err > #precision {
+							panic!("\n\
+								Generated reward curve approximation differ from real one:\n\t\
+								for i = {} and base = {}, f(i/base) * base = {},\n\t\
+								but approximation = {},\n\t\
+								err = {:07} millionth,\n\t\
+								try increase the number of segment: {} or the test_error: {}.\n",
+								i, base, float_res, int_res, err, #max_piece_count, #precision
+							);
+						}
+					}
+				}
+			}
+
+			#[test]
+			fn reward_curve_piece_count() {
+				assert!(
+					super::#ident.points.len() as u32 - 1 <= #max_piece_count,
+					"Generated reward curve approximation is invalid: \
+					has more points than specified, please fill an issue."
+				);
+			}
+		}
+	)
+}
diff --git a/substrate/frame/staking/reward-curve/src/log.rs b/substrate/frame/staking/reward-curve/src/log.rs
new file mode 100644
index 0000000000000000000000000000000000000000..248a1e3c36a6e226b6c4f95bbff2b383c012ea17
--- /dev/null
+++ b/substrate/frame/staking/reward-curve/src/log.rs
@@ -0,0 +1,125 @@
+/// Simple u32 power of 2 function - simply uses a bit shift
+macro_rules! pow2 {
+	($n:expr) => {
+		1_u32 << $n
+	};
+}
+
+/// Returns the k_th per_million taylor term for a log2 function
+fn taylor_term(k: u32, y_num: u128, y_den: u128) -> u32 {
+	let _2_div_ln_2: u128 = 2_885_390u128;
+
+	if k == 0 {
+		(_2_div_ln_2 * (y_num).pow(1) / (y_den).pow(1)).try_into().unwrap()
+	} else {
+		let mut res = _2_div_ln_2 * (y_num).pow(3) / (y_den).pow(3);
+		for _ in 1..k {
+			res = res * (y_num).pow(2) / (y_den).pow(2);
+		}
+		res /= 2 * k as u128 + 1;
+
+		res.try_into().unwrap()
+	}
+}
+
+/// Performs a log2 operation using a rational fraction
+///
+/// result = log2(p/q) where p/q is bound to [1, 1_000_000]
+/// Where:
+/// * q represents the numerator of the rational fraction input
+/// * p represents the denominator of the rational fraction input
+/// * result represents a per-million output of log2
+pub fn log2(p: u32, q: u32) -> u32 {
+	assert!(p >= q); // keep p/q bound to [1, inf)
+	assert!(p <= u32::MAX / 2);
+
+	// This restriction should not be mandatory. But function is only tested and used for this.
+	assert!(p <= 1_000_000);
+	assert!(q <= 1_000_000);
+
+	// log2(1) = 0
+	if p == q {
+		return 0
+	}
+
+	// find the power of 2 where q * 2^n <= p < q * 2^(n+1)
+	let mut n = 0u32;
+	while (p < pow2!(n) * q) || (p >= pow2!(n + 1) * q) {
+		n += 1;
+		assert!(n < 32); // cannot represent 2^32 in u32
+	}
+	assert!(p < pow2!(n + 1) * q);
+
+	let y_num: u32 = p - pow2!(n) * q;
+	let y_den: u32 = p + pow2!(n) * q;
+
+	// Loop through each Taylor series coefficient until it reaches 10^-6
+	let mut res = n * 1_000_000u32;
+	let mut k = 0;
+	loop {
+		let term = taylor_term(k, y_num.into(), y_den.into());
+		if term == 0 {
+			break
+		}
+
+		res += term;
+		k += 1;
+	}
+
+	res
+}
+
+#[test]
+fn test_log() {
+	let div = 1_000;
+	for p in 0..=div {
+		for q in 1..=p {
+			let p: u32 = (1_000_000 as u64 * p as u64 / div as u64).try_into().unwrap();
+			let q: u32 = (1_000_000 as u64 * q as u64 / div as u64).try_into().unwrap();
+
+			let res = -(log2(p, q) as i64);
+			let expected = ((q as f64 / p as f64).log(2.0) * 1_000_000 as f64).round() as i64;
+			assert!((res - expected).abs() <= 6);
+		}
+	}
+}
+
+#[test]
+#[should_panic]
+fn test_log_p_must_be_greater_than_q() {
+	let p: u32 = 1_000;
+	let q: u32 = 1_001;
+	let _ = log2(p, q);
+}
+
+#[test]
+#[should_panic]
+fn test_log_p_upper_bound() {
+	let p: u32 = 1_000_001;
+	let q: u32 = 1_000_000;
+	let _ = log2(p, q);
+}
+
+#[test]
+#[should_panic]
+fn test_log_q_limit() {
+	let p: u32 = 1_000_000;
+	let q: u32 = 0;
+	let _ = log2(p, q);
+}
+
+#[test]
+fn test_log_of_one_boundary() {
+	let p: u32 = 1_000_000;
+	let q: u32 = 1_000_000;
+	assert_eq!(log2(p, q), 0);
+}
+
+#[test]
+fn test_log_of_largest_input() {
+	let p: u32 = 1_000_000;
+	let q: u32 = 1;
+	let expected = 19_931_568;
+	let tolerance = 100;
+	assert!((log2(p, q) as i32 - expected as i32).abs() < tolerance);
+}
diff --git a/substrate/frame/staking/reward-curve/tests/test.rs b/substrate/frame/staking/reward-curve/tests/test.rs
new file mode 100644
index 0000000000000000000000000000000000000000..339e0032224920b9fbb872aba8740e3d1e261831
--- /dev/null
+++ b/substrate/frame/staking/reward-curve/tests/test.rs
@@ -0,0 +1,45 @@
+// 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.
+
+//! Test crate for pallet-staking-reward-curve. Allows to test for procedural macro.
+//! See tests directory.
+
+mod test_small_falloff {
+	pallet_staking_reward_curve::build! {
+		const REWARD_CURVE: sp_runtime::curve::PiecewiseLinear<'static> = curve!(
+			min_inflation: 0_020_000,
+			max_inflation: 0_200_000,
+			ideal_stake: 0_600_000,
+			falloff: 0_010_000,
+			max_piece_count: 200,
+			test_precision: 0_005_000,
+			);
+	}
+}
+
+mod test_big_falloff {
+	pallet_staking_reward_curve::build! {
+		const REWARD_CURVE: sp_runtime::curve::PiecewiseLinear<'static> = curve!(
+			min_inflation: 0_100_000,
+			max_inflation: 0_400_000,
+			ideal_stake: 0_400_000,
+			falloff: 1_000_000,
+			max_piece_count: 40,
+			test_precision: 0_005_000,
+			);
+	}
+}
diff --git a/substrate/frame/staking/reward-fn/Cargo.toml b/substrate/frame/staking/reward-fn/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a80210f7d9f1959ecc68ff764778bc4b596bcfd0
--- /dev/null
+++ b/substrate/frame/staking/reward-fn/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "pallet-staking-reward-fn"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Reward function for FRAME staking pallet"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+
+[dependencies]
+log = { version = "0.4.17", default-features = false }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../../primitives/arithmetic" }
+
+[features]
+default = [ "std" ]
+std = [ "log/std", "sp-arithmetic/std" ]
diff --git a/substrate/frame/staking/reward-fn/src/lib.rs b/substrate/frame/staking/reward-fn/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d34a534c0425df884b276969dfbc4da730d63630
--- /dev/null
+++ b/substrate/frame/staking/reward-fn/src/lib.rs
@@ -0,0 +1,224 @@
+// 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)]
+
+//! Useful function for inflation for nominated proof of stake.
+
+use sp_arithmetic::{
+	biguint::BigUint,
+	traits::{SaturatedConversion, Zero},
+	PerThing, Perquintill,
+};
+
+/// Compute yearly inflation using function
+///
+/// ```ignore
+/// I(x) = for x between 0 and x_ideal: x / x_ideal,
+/// for x between x_ideal and 1: 2^((x_ideal - x) / d)
+/// ```
+///
+/// where:
+/// * x is the stake rate, i.e. fraction of total issued tokens that actively staked behind
+///   validators.
+/// * d is the falloff or `decay_rate`
+/// * x_ideal: the ideal stake rate.
+///
+/// The result is meant to be scaled with minimum inflation and maximum inflation.
+///
+/// (as detailed
+/// [here](https://research.web3.foundation/Polkadot/overview/token-economics#inflation-model-with-parachains))
+///
+/// Arguments are:
+/// * `stake`: The fraction of total issued tokens that actively staked behind validators. Known as
+///   `x` in the literature. Must be between 0 and 1.
+/// * `ideal_stake`: The fraction of total issued tokens that should be actively staked behind
+///   validators. Known as `x_ideal` in the literature. Must be between 0 and 1.
+/// * `falloff`: Known as `decay_rate` in the literature. A co-efficient dictating the strength of
+///   the global incentivization to get the `ideal_stake`. A higher number results in less typical
+///   inflation at the cost of greater volatility for validators. Must be more than 0.01.
+pub fn compute_inflation<P: PerThing>(stake: P, ideal_stake: P, falloff: P) -> P {
+	if stake < ideal_stake {
+		// ideal_stake is more than 0 because it is strictly more than stake
+		return stake / ideal_stake
+	}
+
+	if falloff < P::from_percent(1.into()) {
+		log::error!("Invalid inflation computation: falloff less than 1% is not supported");
+		return PerThing::zero()
+	}
+
+	let accuracy = {
+		let mut a = BigUint::from(Into::<u128>::into(P::ACCURACY));
+		a.lstrip();
+		a
+	};
+
+	let mut falloff = BigUint::from(falloff.deconstruct().into());
+	falloff.lstrip();
+
+	let ln2 = {
+		/// `ln(2)` expressed in as perquintillionth.
+		const LN2: u64 = 0_693_147_180_559_945_309;
+		let ln2 = P::from_rational(LN2.into(), Perquintill::ACCURACY.into());
+		BigUint::from(ln2.deconstruct().into())
+	};
+
+	// falloff is stripped above.
+	let ln2_div_d = div_by_stripped(ln2.mul(&accuracy), &falloff);
+
+	let inpos_param = INPoSParam {
+		x_ideal: BigUint::from(ideal_stake.deconstruct().into()),
+		x: BigUint::from(stake.deconstruct().into()),
+		accuracy,
+		ln2_div_d,
+	};
+
+	let res = compute_taylor_serie_part(&inpos_param);
+
+	match u128::try_from(res.clone()) {
+		Ok(res) if res <= Into::<u128>::into(P::ACCURACY) => P::from_parts(res.saturated_into()),
+		// If result is beyond bounds there is nothing we can do
+		_ => {
+			log::error!("Invalid inflation computation: unexpected result {:?}", res);
+			P::zero()
+		},
+	}
+}
+
+/// Internal struct holding parameter info alongside other cached value.
+///
+/// All expressed in part from `accuracy`
+struct INPoSParam {
+	ln2_div_d: BigUint,
+	x_ideal: BigUint,
+	x: BigUint,
+	/// Must be stripped and have no leading zeros.
+	accuracy: BigUint,
+}
+
+/// Compute `2^((x_ideal - x) / d)` using taylor serie.
+///
+/// x must be strictly more than x_ideal.
+///
+/// result is expressed with accuracy `INPoSParam.accuracy`
+fn compute_taylor_serie_part(p: &INPoSParam) -> BigUint {
+	// The last computed taylor term.
+	let mut last_taylor_term = p.accuracy.clone();
+
+	// Whereas taylor sum is positive.
+	let mut taylor_sum_positive = true;
+
+	// The sum of all taylor term.
+	let mut taylor_sum = last_taylor_term.clone();
+
+	for k in 1..300 {
+		last_taylor_term = compute_taylor_term(k, &last_taylor_term, p);
+
+		if last_taylor_term.is_zero() {
+			break
+		}
+
+		let last_taylor_term_positive = k % 2 == 0;
+
+		if taylor_sum_positive == last_taylor_term_positive {
+			taylor_sum = taylor_sum.add(&last_taylor_term);
+		} else if taylor_sum >= last_taylor_term {
+			taylor_sum = taylor_sum
+				.sub(&last_taylor_term)
+				// NOTE: Should never happen as checked above
+				.unwrap_or_else(|e| e);
+		} else {
+			taylor_sum_positive = !taylor_sum_positive;
+			taylor_sum = last_taylor_term
+				.clone()
+				.sub(&taylor_sum)
+				// NOTE: Should never happen as checked above
+				.unwrap_or_else(|e| e);
+		}
+	}
+
+	if !taylor_sum_positive {
+		return BigUint::zero()
+	}
+
+	taylor_sum.lstrip();
+	taylor_sum
+}
+
+/// Return the absolute value of k-th taylor term of `2^((x_ideal - x))/d` i.e.
+/// `((x - x_ideal) * ln(2) / d)^k / k!`
+///
+/// x must be strictly more x_ideal.
+///
+/// We compute the term from the last term using this formula:
+///
+/// `((x - x_ideal) * ln(2) / d)^k / k! == previous_term * (x - x_ideal) * ln(2) / d / k`
+///
+/// `previous_taylor_term` and result are expressed with accuracy `INPoSParam.accuracy`
+fn compute_taylor_term(k: u32, previous_taylor_term: &BigUint, p: &INPoSParam) -> BigUint {
+	let x_minus_x_ideal =
+		p.x.clone()
+			.sub(&p.x_ideal)
+			// NOTE: Should never happen, as x must be more than x_ideal
+			.unwrap_or_else(|_| BigUint::zero());
+
+	let res = previous_taylor_term.clone().mul(&x_minus_x_ideal).mul(&p.ln2_div_d).div_unit(k);
+
+	// p.accuracy is stripped by definition.
+	let res = div_by_stripped(res, &p.accuracy);
+	let mut res = div_by_stripped(res, &p.accuracy);
+
+	res.lstrip();
+	res
+}
+
+/// Compute a div b.
+///
+/// requires `b` to be stripped and have no leading zeros.
+fn div_by_stripped(mut a: BigUint, b: &BigUint) -> BigUint {
+	a.lstrip();
+
+	if b.len() == 0 {
+		log::error!("Computation error: Invalid division");
+		return BigUint::zero()
+	}
+
+	if b.len() == 1 {
+		return a.div_unit(b.checked_get(0).unwrap_or(1))
+	}
+
+	if b.len() > a.len() {
+		return BigUint::zero()
+	}
+
+	if b.len() == a.len() {
+		// 100_000^2 is more than 2^32-1, thus `new_a` has more limbs than `b`.
+		let mut new_a = a.mul(&BigUint::from(100_000u64.pow(2)));
+		new_a.lstrip();
+
+		debug_assert!(new_a.len() > b.len());
+		return new_a
+			.div(b, false)
+			.map(|res| res.0)
+			.unwrap_or_else(BigUint::zero)
+			.div_unit(100_000)
+			.div_unit(100_000)
+	}
+
+	a.div(b, false).map(|res| res.0).unwrap_or_else(BigUint::zero)
+}
diff --git a/substrate/frame/staking/reward-fn/tests/test.rs b/substrate/frame/staking/reward-fn/tests/test.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d76d2ce5e8c09dd7f50e887a5357938c3f881e3e
--- /dev/null
+++ b/substrate/frame/staking/reward-fn/tests/test.rs
@@ -0,0 +1,101 @@
+// 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 sp_arithmetic::{PerThing, PerU16, Perbill, Percent, Perquintill};
+
+/// This test the precision and panics if error too big error.
+///
+/// error is asserted to be less or equal to 8/accuracy or 8*f64::EPSILON
+fn test_precision<P: PerThing>(stake: P, ideal_stake: P, falloff: P) {
+	let accuracy_f64 = Into::<u128>::into(P::ACCURACY) as f64;
+	let res = pallet_staking_reward_fn::compute_inflation(stake, ideal_stake, falloff);
+	let res = Into::<u128>::into(res.deconstruct()) as f64 / accuracy_f64;
+
+	let expect = float_i_npos(stake, ideal_stake, falloff);
+
+	let error = (res - expect).abs();
+
+	if error > 8f64 / accuracy_f64 && error > 8.0 * f64::EPSILON {
+		panic!(
+			"stake: {:?}, ideal_stake: {:?}, falloff: {:?}, res: {}, expect: {}",
+			stake, ideal_stake, falloff, res, expect
+		);
+	}
+}
+
+/// compute the inflation using floats
+fn float_i_npos<P: PerThing>(stake: P, ideal_stake: P, falloff: P) -> f64 {
+	let accuracy_f64 = Into::<u128>::into(P::ACCURACY) as f64;
+
+	let ideal_stake = Into::<u128>::into(ideal_stake.deconstruct()) as f64 / accuracy_f64;
+	let stake = Into::<u128>::into(stake.deconstruct()) as f64 / accuracy_f64;
+	let falloff = Into::<u128>::into(falloff.deconstruct()) as f64 / accuracy_f64;
+
+	let x_ideal = ideal_stake;
+	let x = stake;
+	let d = falloff;
+
+	if x < x_ideal {
+		x / x_ideal
+	} else {
+		2_f64.powf((x_ideal - x) / d)
+	}
+}
+
+#[test]
+fn test_precision_for_minimum_falloff() {
+	fn test_falloff_precision_for_minimum_falloff<P: PerThing>() {
+		for stake in 0..1_000 {
+			let stake = P::from_rational(stake, 1_000);
+			let ideal_stake = P::zero();
+			let falloff = P::from_rational(1, 100);
+			test_precision(stake, ideal_stake, falloff);
+		}
+	}
+
+	test_falloff_precision_for_minimum_falloff::<Perquintill>();
+
+	test_falloff_precision_for_minimum_falloff::<PerU16>();
+
+	test_falloff_precision_for_minimum_falloff::<Perbill>();
+
+	test_falloff_precision_for_minimum_falloff::<Percent>();
+}
+
+#[test]
+fn compute_inflation_works() {
+	fn compute_inflation_works<P: PerThing>() {
+		for stake in 0..100 {
+			for ideal_stake in 0..10 {
+				for falloff in 1..10 {
+					let stake = P::from_rational(stake, 100);
+					let ideal_stake = P::from_rational(ideal_stake, 10);
+					let falloff = P::from_rational(falloff, 100);
+					test_precision(stake, ideal_stake, falloff);
+				}
+			}
+		}
+	}
+
+	compute_inflation_works::<Perquintill>();
+
+	compute_inflation_works::<PerU16>();
+
+	compute_inflation_works::<Perbill>();
+
+	compute_inflation_works::<Percent>();
+}
diff --git a/substrate/frame/staking/runtime-api/Cargo.toml b/substrate/frame/staking/runtime-api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..afb7ce721cd2ea635585485305f0a5201ad31b6c
--- /dev/null
+++ b/substrate/frame/staking/runtime-api/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "pallet-staking-runtime-api"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "RPC runtime API for transaction payment FRAME pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/api" }
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "sp-api/std" ]
diff --git a/substrate/frame/staking/runtime-api/README.md b/substrate/frame/staking/runtime-api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a999e519f8cbfae23ba0742d6849a533022fbadb
--- /dev/null
+++ b/substrate/frame/staking/runtime-api/README.md
@@ -0,0 +1,3 @@
+Runtime API definition for the staking pallet.
+
+License: Apache-2.0
diff --git a/substrate/frame/staking/runtime-api/src/lib.rs b/substrate/frame/staking/runtime-api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..378599c665506007ddae5ea227829d4af2483103
--- /dev/null
+++ b/substrate/frame/staking/runtime-api/src/lib.rs
@@ -0,0 +1,32 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2023 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.
+
+//! Runtime API definition for the staking pallet.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::Codec;
+
+sp_api::decl_runtime_apis! {
+	pub trait StakingApi<Balance>
+		where
+			Balance: Codec,
+	{
+		/// Returns the nominations quota for a nominator with a given balance.
+		fn nominations_quota(balance: Balance) -> u32;
+	}
+}
diff --git a/substrate/frame/staking/src/benchmarking.rs b/substrate/frame/staking/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e72a9baf044fefdef9610ef02dac3f054ff965e4
--- /dev/null
+++ b/substrate/frame/staking/src/benchmarking.rs
@@ -0,0 +1,1068 @@
+// 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.
+
+//! Staking pallet benchmarking.
+
+use super::*;
+use crate::{ConfigOp, Pallet as Staking};
+use testing_utils::*;
+
+use codec::Decode;
+use frame_election_provider_support::{bounds::DataProviderBounds, SortedListProvider};
+use frame_support::{
+	dispatch::UnfilteredDispatchable,
+	pallet_prelude::*,
+	traits::{Currency, Get, Imbalance},
+};
+use sp_runtime::{
+	traits::{Bounded, One, StaticLookup, TrailingZeroInput, Zero},
+	Perbill, Percent,
+};
+use sp_staking::{currency_to_vote::CurrencyToVote, SessionIndex};
+use sp_std::prelude::*;
+
+pub use frame_benchmarking::v1::{
+	account, benchmarks, impl_benchmark_test_suite, whitelist_account, whitelisted_caller,
+};
+use frame_system::RawOrigin;
+
+const SEED: u32 = 0;
+const MAX_SPANS: u32 = 100;
+const MAX_SLASHES: u32 = 1000;
+
+type MaxValidators<T> = <<T as Config>::BenchmarkingConfig as BenchmarkingConfig>::MaxValidators;
+type MaxNominators<T> = <<T as Config>::BenchmarkingConfig as BenchmarkingConfig>::MaxNominators;
+
+// Add slashing spans to a user account. Not relevant for actual use, only to benchmark
+// read and write operations.
+pub fn add_slashing_spans<T: Config>(who: &T::AccountId, spans: u32) {
+	if spans == 0 {
+		return
+	}
+
+	// For the first slashing span, we initialize
+	let mut slashing_spans = crate::slashing::SlashingSpans::new(0);
+	SpanSlash::<T>::insert((who, 0), crate::slashing::SpanRecord::default());
+
+	for i in 1..spans {
+		assert!(slashing_spans.end_span(i));
+		SpanSlash::<T>::insert((who, i), crate::slashing::SpanRecord::default());
+	}
+	SlashingSpans::<T>::insert(who, slashing_spans);
+}
+
+// This function clears all existing validators and nominators from the set, and generates one new
+// validator being nominated by n nominators, and returns the validator stash account and the
+// nominators' stash and controller. It also starts an era and creates pending payouts.
+pub fn create_validator_with_nominators<T: Config>(
+	n: u32,
+	upper_bound: u32,
+	dead_controller: bool,
+	unique_controller: bool,
+	destination: RewardDestination<T::AccountId>,
+) -> Result<(T::AccountId, Vec<(T::AccountId, T::AccountId)>), &'static str> {
+	// Clean up any existing state.
+	clear_validators_and_nominators::<T>();
+	let mut points_total = 0;
+	let mut points_individual = Vec::new();
+
+	let (v_stash, v_controller) = if unique_controller {
+		create_unique_stash_controller::<T>(0, 100, destination.clone(), false)?
+	} else {
+		create_stash_controller::<T>(0, 100, destination.clone())?
+	};
+
+	let validator_prefs =
+		ValidatorPrefs { commission: Perbill::from_percent(50), ..Default::default() };
+	Staking::<T>::validate(RawOrigin::Signed(v_controller).into(), validator_prefs)?;
+	let stash_lookup = T::Lookup::unlookup(v_stash.clone());
+
+	points_total += 10;
+	points_individual.push((v_stash.clone(), 10));
+
+	let original_nominator_count = Nominators::<T>::count();
+	let mut nominators = Vec::new();
+
+	// Give the validator n nominators, but keep total users in the system the same.
+	for i in 0..upper_bound {
+		let (n_stash, n_controller) = if !dead_controller {
+			create_stash_controller::<T>(u32::MAX - i, 100, destination.clone())?
+		} else {
+			create_unique_stash_controller::<T>(u32::MAX - i, 100, destination.clone(), true)?
+		};
+		if i < n {
+			Staking::<T>::nominate(
+				RawOrigin::Signed(n_controller.clone()).into(),
+				vec![stash_lookup.clone()],
+			)?;
+			nominators.push((n_stash, n_controller));
+		}
+	}
+
+	ValidatorCount::<T>::put(1);
+
+	// Start a new Era
+	let new_validators = Staking::<T>::try_trigger_new_era(SessionIndex::one(), true).unwrap();
+
+	assert_eq!(new_validators.len(), 1);
+	assert_eq!(new_validators[0], v_stash, "Our validator was not selected!");
+	assert_ne!(Validators::<T>::count(), 0);
+	assert_eq!(Nominators::<T>::count(), original_nominator_count + nominators.len() as u32);
+
+	// Give Era Points
+	let reward = EraRewardPoints::<T::AccountId> {
+		total: points_total,
+		individual: points_individual.into_iter().collect(),
+	};
+
+	let current_era = CurrentEra::<T>::get().unwrap();
+	ErasRewardPoints::<T>::insert(current_era, reward);
+
+	// Create reward pool
+	let total_payout = T::Currency::minimum_balance()
+		.saturating_mul(upper_bound.into())
+		.saturating_mul(1000u32.into());
+	<ErasValidatorReward<T>>::insert(current_era, total_payout);
+
+	Ok((v_stash, nominators))
+}
+
+struct ListScenario<T: Config> {
+	/// Stash that is expected to be moved.
+	origin_stash1: T::AccountId,
+	/// Controller of the Stash that is expected to be moved.
+	origin_controller1: T::AccountId,
+	dest_weight: BalanceOf<T>,
+}
+
+impl<T: Config> ListScenario<T> {
+	/// An expensive scenario for bags-list implementation:
+	///
+	/// - the node to be updated (r) is the head of a bag that has at least one other node. The bag
+	///   itself will need to be read and written to update its head. The node pointed to by r.next
+	///   will need to be read and written as it will need to have its prev pointer updated. Note
+	///   that there are two other worst case scenarios for bag removal: 1) the node is a tail and
+	///   2) the node is a middle node with prev and next; all scenarios end up with the same number
+	///   of storage reads and writes.
+	///
+	/// - the destination bag has at least one node, which will need its next pointer updated.
+	///
+	/// NOTE: while this scenario specifically targets a worst case for the bags-list, it should
+	/// also elicit a worst case for other known `VoterList` implementations; although
+	/// this may not be true against unknown `VoterList` implementations.
+	fn new(origin_weight: BalanceOf<T>, is_increase: bool) -> Result<Self, &'static str> {
+		ensure!(!origin_weight.is_zero(), "origin weight must be greater than 0");
+
+		// burn the entire issuance.
+		let i = T::Currency::burn(T::Currency::total_issuance());
+		sp_std::mem::forget(i);
+
+		// create accounts with the origin weight
+
+		let (origin_stash1, origin_controller1) = create_stash_controller_with_balance::<T>(
+			USER_SEED + 2,
+			origin_weight,
+			Default::default(),
+		)?;
+		Staking::<T>::nominate(
+			RawOrigin::Signed(origin_controller1.clone()).into(),
+			// NOTE: these don't really need to be validators.
+			vec![T::Lookup::unlookup(account("random_validator", 0, SEED))],
+		)?;
+
+		let (_origin_stash2, origin_controller2) = create_stash_controller_with_balance::<T>(
+			USER_SEED + 3,
+			origin_weight,
+			Default::default(),
+		)?;
+		Staking::<T>::nominate(
+			RawOrigin::Signed(origin_controller2).into(),
+			vec![T::Lookup::unlookup(account("random_validator", 0, SEED))],
+		)?;
+
+		// find a destination weight that will trigger the worst case scenario
+		let dest_weight_as_vote =
+			T::VoterList::score_update_worst_case(&origin_stash1, is_increase);
+
+		let total_issuance = T::Currency::total_issuance();
+
+		let dest_weight =
+			T::CurrencyToVote::to_currency(dest_weight_as_vote as u128, total_issuance);
+
+		// create an account with the worst case destination weight
+		let (_dest_stash1, dest_controller1) = create_stash_controller_with_balance::<T>(
+			USER_SEED + 1,
+			dest_weight,
+			Default::default(),
+		)?;
+		Staking::<T>::nominate(
+			RawOrigin::Signed(dest_controller1).into(),
+			vec![T::Lookup::unlookup(account("random_validator", 0, SEED))],
+		)?;
+
+		Ok(ListScenario { origin_stash1, origin_controller1, dest_weight })
+	}
+}
+
+const USER_SEED: u32 = 999666;
+
+benchmarks! {
+	bond {
+		let stash = create_funded_user::<T>("stash", USER_SEED, 100);
+		let reward_destination = RewardDestination::Staked;
+		let amount = T::Currency::minimum_balance() * 10u32.into();
+		whitelist_account!(stash);
+	}: _(RawOrigin::Signed(stash.clone()), amount, reward_destination)
+	verify {
+		assert!(Bonded::<T>::contains_key(stash.clone()));
+		assert!(Ledger::<T>::contains_key(stash));
+	}
+
+	bond_extra {
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get().max(T::Currency::minimum_balance());
+
+		// setup the worst case list scenario.
+
+		// the weight the nominator will start at.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+
+		let max_additional = scenario.dest_weight - origin_weight;
+
+		let stash = scenario.origin_stash1.clone();
+		let controller = scenario.origin_controller1;
+		let original_bonded: BalanceOf<T>
+			= Ledger::<T>::get(&controller).map(|l| l.active).ok_or("ledger not created after")?;
+
+		T::Currency::deposit_into_existing(&stash, max_additional).unwrap();
+
+		whitelist_account!(stash);
+	}: _(RawOrigin::Signed(stash), max_additional)
+	verify {
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created after")?;
+		let new_bonded: BalanceOf<T> = ledger.active;
+		assert!(original_bonded < new_bonded);
+	}
+
+	unbond {
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		// setup the worst case list scenario.
+		let total_issuance = T::Currency::total_issuance();
+		// the weight the nominator will start at. The value used here is expected to be
+		// significantly higher than the first position in a list (e.g. the first bag threshold).
+		let origin_weight = BalanceOf::<T>::try_from(952_994_955_240_703u128)
+			.map_err(|_| "balance expected to be a u128")
+			.unwrap();
+		let scenario = ListScenario::<T>::new(origin_weight, false)?;
+
+		let stash = scenario.origin_stash1.clone();
+		let controller = scenario.origin_controller1.clone();
+		let amount = origin_weight - scenario.dest_weight;
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created before")?;
+		let original_bonded: BalanceOf<T> = ledger.active;
+
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller.clone()), amount)
+	verify {
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created after")?;
+		let new_bonded: BalanceOf<T> = ledger.active;
+		assert!(original_bonded > new_bonded);
+	}
+
+	// Withdraw only updates the ledger
+	withdraw_unbonded_update {
+		// Slashing Spans
+		let s in 0 .. MAX_SPANS;
+		let (stash, controller) = create_stash_controller::<T>(0, 100, Default::default())?;
+		add_slashing_spans::<T>(&stash, s);
+		let amount = T::Currency::minimum_balance() * 5u32.into(); // Half of total
+		Staking::<T>::unbond(RawOrigin::Signed(controller.clone()).into(), amount)?;
+		CurrentEra::<T>::put(EraIndex::max_value());
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created before")?;
+		let original_total: BalanceOf<T> = ledger.total;
+		whitelist_account!(controller);
+	}: withdraw_unbonded(RawOrigin::Signed(controller.clone()), s)
+	verify {
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created after")?;
+		let new_total: BalanceOf<T> = ledger.total;
+		assert!(original_total > new_total);
+	}
+
+	// Worst case scenario, everything is removed after the bonding duration
+	withdraw_unbonded_kill {
+		// Slashing Spans
+		let s in 0 .. MAX_SPANS;
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get().max(T::Currency::minimum_balance());
+
+		// setup a worst case list scenario. Note that we don't care about the setup of the
+		// destination position because we are doing a removal from the list but no insert.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let controller = scenario.origin_controller1.clone();
+		let stash = scenario.origin_stash1;
+		add_slashing_spans::<T>(&stash, s);
+		assert!(T::VoterList::contains(&stash));
+
+		let ed = T::Currency::minimum_balance();
+		let mut ledger = Ledger::<T>::get(&controller).unwrap();
+		ledger.active = ed - One::one();
+		Ledger::<T>::insert(&controller, ledger);
+		CurrentEra::<T>::put(EraIndex::max_value());
+
+		whitelist_account!(controller);
+	}: withdraw_unbonded(RawOrigin::Signed(controller.clone()), s)
+	verify {
+		assert!(!Ledger::<T>::contains_key(controller));
+		assert!(!T::VoterList::contains(&stash));
+	}
+
+	validate {
+		let (stash, controller) = create_stash_controller::<T>(
+			MaxNominationsOf::<T>::get() - 1,
+			100,
+			Default::default(),
+		)?;
+		// because it is chilled.
+		assert!(!T::VoterList::contains(&stash));
+
+		let prefs = ValidatorPrefs::default();
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller), prefs)
+	verify {
+		assert!(Validators::<T>::contains_key(&stash));
+		assert!(T::VoterList::contains(&stash));
+	}
+
+	kick {
+		// scenario: we want to kick `k` nominators from nominating us (we are a validator).
+		// we'll assume that `k` is under 128 for the purposes of determining the slope.
+		// each nominator should have `T::MaxNominations::get()` validators nominated, and our validator
+		// should be somewhere in there.
+		let k in 1 .. 128;
+
+		// these are the other validators; there are `T::MaxNominations::get() - 1` of them, so
+		// there are a total of `T::MaxNominations::get()` validators in the system.
+		let rest_of_validators = create_validators_with_seed::<T>(MaxNominationsOf::<T>::get() - 1, 100, 415)?;
+
+		// this is the validator that will be kicking.
+		let (stash, controller) = create_stash_controller::<T>(
+			MaxNominationsOf::<T>::get() - 1,
+			100,
+			Default::default(),
+		)?;
+		let stash_lookup = T::Lookup::unlookup(stash.clone());
+
+		// they start validating.
+		Staking::<T>::validate(RawOrigin::Signed(controller.clone()).into(), Default::default())?;
+
+		// we now create the nominators. there will be `k` of them; each will nominate all
+		// validators. we will then kick each of the `k` nominators from the main validator.
+		let mut nominator_stashes = Vec::with_capacity(k as usize);
+		for i in 0 .. k {
+			// create a nominator stash.
+			let (n_stash, n_controller) = create_stash_controller::<T>(
+				MaxNominationsOf::<T>::get() + i,
+				100,
+				Default::default(),
+			)?;
+
+			// bake the nominations; we first clone them from the rest of the validators.
+			let mut nominations = rest_of_validators.clone();
+			// then insert "our" validator somewhere in there (we vary it) to avoid accidental
+			// optimisations/pessimisations.
+			nominations.insert(i as usize % (nominations.len() + 1), stash_lookup.clone());
+			// then we nominate.
+			Staking::<T>::nominate(RawOrigin::Signed(n_controller.clone()).into(), nominations)?;
+
+			nominator_stashes.push(n_stash);
+		}
+
+		// all nominators now should be nominating our validator...
+		for n in nominator_stashes.iter() {
+			assert!(Nominators::<T>::get(n).unwrap().targets.contains(&stash));
+		}
+
+		// we need the unlookuped version of the nominator stash for the kick.
+		let kicks = nominator_stashes.iter()
+			.map(|n| T::Lookup::unlookup(n.clone()))
+			.collect::<Vec<_>>();
+
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller), kicks)
+	verify {
+		// all nominators now should *not* be nominating our validator...
+		for n in nominator_stashes.iter() {
+			assert!(!Nominators::<T>::get(n).unwrap().targets.contains(&stash));
+		}
+	}
+
+	// Worst case scenario, T::MaxNominations::get()
+	nominate {
+		let n in 1 .. MaxNominationsOf::<T>::get();
+
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get().max(T::Currency::minimum_balance());
+
+		// setup a worst case list scenario. Note we don't care about the destination position, because
+		// we are just doing an insert into the origin position.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let (stash, controller) = create_stash_controller_with_balance::<T>(
+			SEED + MaxNominationsOf::<T>::get() + 1, // make sure the account does not conflict with others
+			origin_weight,
+			Default::default(),
+		).unwrap();
+
+		assert!(!Nominators::<T>::contains_key(&stash));
+		assert!(!T::VoterList::contains(&stash));
+
+		let validators = create_validators::<T>(n, 100).unwrap();
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller), validators)
+	verify {
+		assert!(Nominators::<T>::contains_key(&stash));
+		assert!(T::VoterList::contains(&stash))
+	}
+
+	chill {
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get().max(T::Currency::minimum_balance());
+
+		// setup a worst case list scenario. Note that we don't care about the setup of the
+		// destination position because we are doing a removal from the list but no insert.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let controller = scenario.origin_controller1.clone();
+		let stash = scenario.origin_stash1;
+		assert!(T::VoterList::contains(&stash));
+
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller))
+	verify {
+		assert!(!T::VoterList::contains(&stash));
+	}
+
+	set_payee {
+		let (stash, controller) = create_stash_controller::<T>(USER_SEED, 100, Default::default())?;
+		assert_eq!(Payee::<T>::get(&stash), RewardDestination::Staked);
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller), RewardDestination::Controller)
+	verify {
+		assert_eq!(Payee::<T>::get(&stash), RewardDestination::Controller);
+	}
+
+	set_controller {
+		let (stash, ctlr) = create_unique_stash_controller::<T>(9000, 100, Default::default(), false)?;
+		// ensure `ctlr` is the currently stored controller.
+		assert!(!Ledger::<T>::contains_key(&stash));
+		assert!(Ledger::<T>::contains_key(&ctlr));
+		assert_eq!(Bonded::<T>::get(&stash), Some(ctlr.clone()));
+
+		whitelist_account!(stash);
+	}: _(RawOrigin::Signed(stash.clone()))
+	verify {
+		assert!(Ledger::<T>::contains_key(&stash));
+	}
+
+	set_validator_count {
+		let validator_count = MaxValidators::<T>::get();
+	}: _(RawOrigin::Root, validator_count)
+	verify {
+		assert_eq!(ValidatorCount::<T>::get(), validator_count);
+	}
+
+	force_no_eras {}: _(RawOrigin::Root)
+	verify { assert_eq!(ForceEra::<T>::get(), Forcing::ForceNone); }
+
+	force_new_era {}: _(RawOrigin::Root)
+	verify { assert_eq!(ForceEra::<T>::get(), Forcing::ForceNew); }
+
+	force_new_era_always {}: _(RawOrigin::Root)
+	verify { assert_eq!(ForceEra::<T>::get(), Forcing::ForceAlways); }
+
+	// Worst case scenario, the list of invulnerables is very long.
+	set_invulnerables {
+		let v in 0 .. MaxValidators::<T>::get();
+		let mut invulnerables = Vec::new();
+		for i in 0 .. v {
+			invulnerables.push(account("invulnerable", i, SEED));
+		}
+	}: _(RawOrigin::Root, invulnerables)
+	verify {
+		assert_eq!(Invulnerables::<T>::get().len(), v as usize);
+	}
+
+	force_unstake {
+		// Slashing Spans
+		let s in 0 .. MAX_SPANS;
+		// Clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get().max(T::Currency::minimum_balance());
+
+		// setup a worst case list scenario. Note that we don't care about the setup of the
+		// destination position because we are doing a removal from the list but no insert.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let controller = scenario.origin_controller1.clone();
+		let stash = scenario.origin_stash1;
+		assert!(T::VoterList::contains(&stash));
+		add_slashing_spans::<T>(&stash, s);
+
+	}: _(RawOrigin::Root, stash.clone(), s)
+	verify {
+		assert!(!Ledger::<T>::contains_key(&controller));
+		assert!(!T::VoterList::contains(&stash));
+	}
+
+	cancel_deferred_slash {
+		let s in 1 .. MAX_SLASHES;
+		let mut unapplied_slashes = Vec::new();
+		let era = EraIndex::one();
+		let dummy = || T::AccountId::decode(&mut TrailingZeroInput::zeroes()).unwrap();
+		for _ in 0 .. MAX_SLASHES {
+			unapplied_slashes.push(UnappliedSlash::<T::AccountId, BalanceOf<T>>::default_from(dummy()));
+		}
+		UnappliedSlashes::<T>::insert(era, &unapplied_slashes);
+
+		let slash_indices: Vec<u32> = (0 .. s).collect();
+	}: _(RawOrigin::Root, era, slash_indices)
+	verify {
+		assert_eq!(UnappliedSlashes::<T>::get(&era).len(), (MAX_SLASHES - s) as usize);
+	}
+
+	payout_stakers_dead_controller {
+		let n in 0 .. T::MaxNominatorRewardedPerValidator::get() as u32;
+		let (validator, nominators) = create_validator_with_nominators::<T>(
+			n,
+			T::MaxNominatorRewardedPerValidator::get() as u32,
+			true,
+			true,
+			RewardDestination::Controller,
+		)?;
+
+		let current_era = CurrentEra::<T>::get().unwrap();
+		// set the commission for this particular era as well.
+		<ErasValidatorPrefs<T>>::insert(current_era, validator.clone(), <Staking<T>>::validators(&validator));
+
+		let caller = whitelisted_caller();
+		let validator_controller = <Bonded<T>>::get(&validator).unwrap();
+		let balance_before = T::Currency::free_balance(&validator_controller);
+		for (_, controller) in &nominators {
+			let balance = T::Currency::free_balance(controller);
+			ensure!(balance.is_zero(), "Controller has balance, but should be dead.");
+		}
+	}: payout_stakers(RawOrigin::Signed(caller), validator, current_era)
+	verify {
+		let balance_after = T::Currency::free_balance(&validator_controller);
+		ensure!(
+			balance_before < balance_after,
+			"Balance of validator controller should have increased after payout.",
+		);
+		for (_, controller) in &nominators {
+			let balance = T::Currency::free_balance(controller);
+			ensure!(!balance.is_zero(), "Payout not given to controller.");
+		}
+	}
+
+	payout_stakers_alive_staked {
+		let n in 0 .. T::MaxNominatorRewardedPerValidator::get() as u32;
+		let (validator, nominators) = create_validator_with_nominators::<T>(
+			n,
+			T::MaxNominatorRewardedPerValidator::get() as u32,
+			false,
+			true,
+			RewardDestination::Staked,
+		)?;
+
+		let current_era = CurrentEra::<T>::get().unwrap();
+		// set the commission for this particular era as well.
+		<ErasValidatorPrefs<T>>::insert(current_era, validator.clone(), <Staking<T>>::validators(&validator));
+
+		let caller = whitelisted_caller();
+		let balance_before = T::Currency::free_balance(&validator);
+		let mut nominator_balances_before = Vec::new();
+		for (stash, _) in &nominators {
+			let balance = T::Currency::free_balance(stash);
+			nominator_balances_before.push(balance);
+		}
+	}: payout_stakers(RawOrigin::Signed(caller), validator.clone(), current_era)
+	verify {
+		let balance_after = T::Currency::free_balance(&validator);
+		ensure!(
+			balance_before < balance_after,
+			"Balance of validator stash should have increased after payout.",
+		);
+		for ((stash, _), balance_before) in nominators.iter().zip(nominator_balances_before.iter()) {
+			let balance_after = T::Currency::free_balance(stash);
+			ensure!(
+				balance_before < &balance_after,
+				"Balance of nominator stash should have increased after payout.",
+			);
+		}
+	}
+
+	rebond {
+		let l in 1 .. T::MaxUnlockingChunks::get() as u32;
+
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get()
+			.max(T::Currency::minimum_balance())
+			// we use 100 to play friendly with the list threshold values in the mock
+			.max(100u32.into());
+
+		// setup a worst case list scenario.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let dest_weight = scenario.dest_weight;
+
+		// rebond an amount that will give the user dest_weight
+		let rebond_amount = dest_weight - origin_weight;
+
+		// spread that amount to rebond across `l` unlocking chunks,
+		let value = rebond_amount / l.into();
+		// if `value` is zero, we need a greater delta between dest <=> origin weight
+		assert_ne!(value, Zero::zero());
+		// so the sum of unlocking chunks puts voter into the dest bag.
+		assert!(value * l.into() + origin_weight > origin_weight);
+		assert!(value * l.into() + origin_weight <= dest_weight);
+		let unlock_chunk = UnlockChunk::<BalanceOf<T>> {
+			value,
+			era: EraIndex::zero(),
+		};
+
+		let stash = scenario.origin_stash1.clone();
+		let controller = scenario.origin_controller1;
+		let mut staking_ledger = Ledger::<T>::get(controller.clone()).unwrap();
+
+		for _ in 0 .. l {
+			staking_ledger.unlocking.try_push(unlock_chunk.clone()).unwrap()
+		}
+		Ledger::<T>::insert(controller.clone(), staking_ledger.clone());
+		let original_bonded: BalanceOf<T> = staking_ledger.active;
+
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller.clone()), rebond_amount)
+	verify {
+		let ledger = Ledger::<T>::get(&controller).ok_or("ledger not created after")?;
+		let new_bonded: BalanceOf<T> = ledger.active;
+		assert!(original_bonded < new_bonded);
+	}
+
+	reap_stash {
+		let s in 1 .. MAX_SPANS;
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get().max(T::Currency::minimum_balance());
+
+		// setup a worst case list scenario. Note that we don't care about the setup of the
+		// destination position because we are doing a removal from the list but no insert.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let controller = scenario.origin_controller1.clone();
+		let stash = scenario.origin_stash1;
+
+		add_slashing_spans::<T>(&stash, s);
+		let l = StakingLedger {
+			stash: stash.clone(),
+			active: T::Currency::minimum_balance() - One::one(),
+			total: T::Currency::minimum_balance() - One::one(),
+			unlocking: Default::default(),
+			claimed_rewards: Default::default(),
+		};
+		Ledger::<T>::insert(&controller, l);
+
+		assert!(Bonded::<T>::contains_key(&stash));
+		assert!(T::VoterList::contains(&stash));
+
+		whitelist_account!(controller);
+	}: _(RawOrigin::Signed(controller), stash.clone(), s)
+	verify {
+		assert!(!Bonded::<T>::contains_key(&stash));
+		assert!(!T::VoterList::contains(&stash));
+	}
+
+	new_era {
+		let v in 1 .. 10;
+		let n in 0 .. 100;
+
+		create_validators_with_nominators_for_era::<T>(
+			v,
+			n,
+			MaxNominationsOf::<T>::get() as usize,
+			false,
+			None,
+		)?;
+		let session_index = SessionIndex::one();
+	}: {
+		let validators = Staking::<T>::try_trigger_new_era(session_index, true)
+			.ok_or("`new_era` failed")?;
+		assert!(validators.len() == v as usize);
+	}
+
+	#[extra]
+	payout_all {
+		let v in 1 .. 10;
+		let n in 0 .. 100;
+		create_validators_with_nominators_for_era::<T>(
+			v,
+			n,
+			MaxNominationsOf::<T>::get() as usize,
+			false,
+			None,
+		)?;
+		// Start a new Era
+		let new_validators = Staking::<T>::try_trigger_new_era(SessionIndex::one(), true).unwrap();
+		assert!(new_validators.len() == v as usize);
+
+		let current_era = CurrentEra::<T>::get().unwrap();
+		let mut points_total = 0;
+		let mut points_individual = Vec::new();
+		let mut payout_calls_arg = Vec::new();
+
+		for validator in new_validators.iter() {
+			points_total += 10;
+			points_individual.push((validator.clone(), 10));
+			payout_calls_arg.push((validator.clone(), current_era));
+		}
+
+		// Give Era Points
+		let reward = EraRewardPoints::<T::AccountId> {
+			total: points_total,
+			individual: points_individual.into_iter().collect(),
+		};
+
+		ErasRewardPoints::<T>::insert(current_era, reward);
+
+		// Create reward pool
+		let total_payout = T::Currency::minimum_balance() * 1000u32.into();
+		<ErasValidatorReward<T>>::insert(current_era, total_payout);
+
+		let caller: T::AccountId = whitelisted_caller();
+		let origin = RawOrigin::Signed(caller);
+		let calls: Vec<_> = payout_calls_arg.iter().map(|arg|
+			Call::<T>::payout_stakers { validator_stash: arg.0.clone(), era: arg.1 }.encode()
+		).collect();
+	}: {
+		for call in calls {
+			<Call<T> as Decode>::decode(&mut &*call)
+				.expect("call is encoded above, encoding must be correct")
+				.dispatch_bypass_filter(origin.clone().into())?;
+		}
+	}
+
+	#[extra]
+	do_slash {
+		let l in 1 .. T::MaxUnlockingChunks::get() as u32;
+		let (stash, controller) = create_stash_controller::<T>(0, 100, Default::default())?;
+		let mut staking_ledger = Ledger::<T>::get(controller.clone()).unwrap();
+		let unlock_chunk = UnlockChunk::<BalanceOf<T>> {
+			value: 1u32.into(),
+			era: EraIndex::zero(),
+		};
+		for _ in 0 .. l {
+			staking_ledger.unlocking.try_push(unlock_chunk.clone()).unwrap();
+		}
+		Ledger::<T>::insert(controller, staking_ledger);
+		let slash_amount = T::Currency::minimum_balance() * 10u32.into();
+		let balance_before = T::Currency::free_balance(&stash);
+	}: {
+		crate::slashing::do_slash::<T>(
+			&stash,
+			slash_amount,
+			&mut BalanceOf::<T>::zero(),
+			&mut NegativeImbalanceOf::<T>::zero(),
+			EraIndex::zero()
+		);
+	} verify {
+		let balance_after = T::Currency::free_balance(&stash);
+		assert!(balance_before > balance_after);
+	}
+
+	get_npos_voters {
+		// number of validator intention. we will iterate all of them.
+		let v in (MaxValidators::<T>::get() / 2) .. MaxValidators::<T>::get();
+		// number of nominator intention. we will iterate all of them.
+		let n in (MaxNominators::<T>::get() / 2) .. MaxNominators::<T>::get();
+
+		let validators = create_validators_with_nominators_for_era::<T>(
+			v, n, MaxNominationsOf::<T>::get() as usize, false, None
+		)?
+		.into_iter()
+		.map(|v| T::Lookup::lookup(v).unwrap())
+		.collect::<Vec<_>>();
+
+		assert_eq!(Validators::<T>::count(), v);
+		assert_eq!(Nominators::<T>::count(), n);
+
+		let num_voters = (v + n) as usize;
+	}: {
+		// default bounds are unbounded.
+		let voters = <Staking<T>>::get_npos_voters(DataProviderBounds::default());
+		assert_eq!(voters.len(), num_voters);
+	}
+
+	get_npos_targets {
+		// number of validator intention.
+		let v in (MaxValidators::<T>::get() / 2) .. MaxValidators::<T>::get();
+		// number of nominator intention.
+		let n = MaxNominators::<T>::get();
+
+		let _ = create_validators_with_nominators_for_era::<T>(
+			v, n, MaxNominationsOf::<T>::get() as usize, false, None
+		)?;
+	}: {
+		// default bounds are unbounded.
+		let targets = <Staking<T>>::get_npos_targets(DataProviderBounds::default());
+		assert_eq!(targets.len() as u32, v);
+	}
+
+	set_staking_configs_all_set {
+	}: set_staking_configs(
+		RawOrigin::Root,
+		ConfigOp::Set(BalanceOf::<T>::max_value()),
+		ConfigOp::Set(BalanceOf::<T>::max_value()),
+		ConfigOp::Set(u32::MAX),
+		ConfigOp::Set(u32::MAX),
+		ConfigOp::Set(Percent::max_value()),
+		ConfigOp::Set(Perbill::max_value())
+	) verify {
+		assert_eq!(MinNominatorBond::<T>::get(), BalanceOf::<T>::max_value());
+		assert_eq!(MinValidatorBond::<T>::get(), BalanceOf::<T>::max_value());
+		assert_eq!(MaxNominatorsCount::<T>::get(), Some(u32::MAX));
+		assert_eq!(MaxValidatorsCount::<T>::get(), Some(u32::MAX));
+		assert_eq!(ChillThreshold::<T>::get(), Some(Percent::from_percent(100)));
+		assert_eq!(MinCommission::<T>::get(), Perbill::from_percent(100));
+	}
+
+	set_staking_configs_all_remove {
+	}: set_staking_configs(
+		RawOrigin::Root,
+		ConfigOp::Remove,
+		ConfigOp::Remove,
+		ConfigOp::Remove,
+		ConfigOp::Remove,
+		ConfigOp::Remove,
+		ConfigOp::Remove
+	) verify {
+		assert!(!MinNominatorBond::<T>::exists());
+		assert!(!MinValidatorBond::<T>::exists());
+		assert!(!MaxNominatorsCount::<T>::exists());
+		assert!(!MaxValidatorsCount::<T>::exists());
+		assert!(!ChillThreshold::<T>::exists());
+		assert!(!MinCommission::<T>::exists());
+	}
+
+	chill_other {
+		// clean up any existing state.
+		clear_validators_and_nominators::<T>();
+
+		let origin_weight = MinNominatorBond::<T>::get().max(T::Currency::minimum_balance());
+
+		// setup a worst case list scenario. Note that we don't care about the setup of the
+		// destination position because we are doing a removal from the list but no insert.
+		let scenario = ListScenario::<T>::new(origin_weight, true)?;
+		let controller = scenario.origin_controller1.clone();
+		let stash = scenario.origin_stash1;
+		assert!(T::VoterList::contains(&stash));
+
+		Staking::<T>::set_staking_configs(
+			RawOrigin::Root.into(),
+			ConfigOp::Set(BalanceOf::<T>::max_value()),
+			ConfigOp::Set(BalanceOf::<T>::max_value()),
+			ConfigOp::Set(0),
+			ConfigOp::Set(0),
+			ConfigOp::Set(Percent::from_percent(0)),
+			ConfigOp::Set(Zero::zero()),
+		)?;
+
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), controller)
+	verify {
+		assert!(!T::VoterList::contains(&stash));
+	}
+
+	force_apply_min_commission {
+		// Clean up any existing state
+		clear_validators_and_nominators::<T>();
+
+		// Create a validator with a commission of 50%
+		let (stash, controller) =
+			create_stash_controller::<T>(1, 1, RewardDestination::Staked)?;
+		let validator_prefs =
+			ValidatorPrefs { commission: Perbill::from_percent(50), ..Default::default() };
+		Staking::<T>::validate(RawOrigin::Signed(controller).into(), validator_prefs)?;
+
+		// Sanity check
+		assert_eq!(
+			Validators::<T>::get(&stash),
+			ValidatorPrefs { commission: Perbill::from_percent(50), ..Default::default() }
+		);
+
+		// Set the min commission to 75%
+		MinCommission::<T>::set(Perbill::from_percent(75));
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), stash.clone())
+	verify {
+		// The validators commission has been bumped to 75%
+		assert_eq!(
+			Validators::<T>::get(&stash),
+			ValidatorPrefs { commission: Perbill::from_percent(75), ..Default::default() }
+		);
+	}
+
+	set_min_commission {
+		let min_commission = Perbill::max_value();
+	}: _(RawOrigin::Root, min_commission)
+	verify {
+		assert_eq!(MinCommission::<T>::get(), Perbill::from_percent(100));
+	}
+
+	impl_benchmark_test_suite!(
+		Staking,
+		crate::mock::ExtBuilder::default().has_stakers(true),
+		crate::mock::Test,
+		exec_name = build_and_execute
+	);
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{Balances, ExtBuilder, RuntimeOrigin, Staking, Test};
+	use frame_support::assert_ok;
+
+	#[test]
+	fn create_validators_with_nominators_for_era_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let v = 10;
+			let n = 100;
+
+			create_validators_with_nominators_for_era::<Test>(
+				v,
+				n,
+				MaxNominationsOf::<Test>::get() as usize,
+				false,
+				None,
+			)
+			.unwrap();
+
+			let count_validators = Validators::<Test>::iter().count();
+			let count_nominators = Nominators::<Test>::iter().count();
+
+			assert_eq!(count_validators, Validators::<Test>::count() as usize);
+			assert_eq!(count_nominators, Nominators::<Test>::count() as usize);
+
+			assert_eq!(count_validators, v as usize);
+			assert_eq!(count_nominators, n as usize);
+		});
+	}
+
+	#[test]
+	fn create_validator_with_nominators_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let n = 10;
+
+			let (validator_stash, nominators) = create_validator_with_nominators::<Test>(
+				n,
+				<<Test as Config>::MaxNominatorRewardedPerValidator as Get<_>>::get(),
+				false,
+				false,
+				RewardDestination::Staked,
+			)
+			.unwrap();
+
+			assert_eq!(nominators.len() as u32, n);
+
+			let current_era = CurrentEra::<Test>::get().unwrap();
+
+			let original_free_balance = Balances::free_balance(&validator_stash);
+			assert_ok!(Staking::payout_stakers(
+				RuntimeOrigin::signed(1337),
+				validator_stash,
+				current_era
+			));
+			let new_free_balance = Balances::free_balance(&validator_stash);
+
+			assert!(original_free_balance < new_free_balance);
+		});
+	}
+
+	#[test]
+	fn add_slashing_spans_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			let n = 10;
+
+			let (validator_stash, _nominators) = create_validator_with_nominators::<Test>(
+				n,
+				<<Test as Config>::MaxNominatorRewardedPerValidator as Get<_>>::get(),
+				false,
+				false,
+				RewardDestination::Staked,
+			)
+			.unwrap();
+
+			// Add 20 slashing spans
+			let num_of_slashing_spans = 20;
+			add_slashing_spans::<Test>(&validator_stash, num_of_slashing_spans);
+
+			let slashing_spans = SlashingSpans::<Test>::get(&validator_stash).unwrap();
+			assert_eq!(slashing_spans.iter().count(), num_of_slashing_spans as usize);
+			for i in 0..num_of_slashing_spans {
+				assert!(SpanSlash::<Test>::contains_key((&validator_stash, i)));
+			}
+
+			// Test everything is cleaned up
+			assert_ok!(Staking::kill_stash(&validator_stash, num_of_slashing_spans));
+			assert!(SlashingSpans::<Test>::get(&validator_stash).is_none());
+			for i in 0..num_of_slashing_spans {
+				assert!(!SpanSlash::<Test>::contains_key((&validator_stash, i)));
+			}
+		});
+	}
+
+	#[test]
+	fn test_payout_all() {
+		ExtBuilder::default().build_and_execute(|| {
+			let v = 10;
+			let n = 100;
+
+			let selected_benchmark = SelectedBenchmark::payout_all;
+			let c = vec![
+				(frame_benchmarking::BenchmarkParameter::v, v),
+				(frame_benchmarking::BenchmarkParameter::n, n),
+			];
+			let closure_to_benchmark =
+				<SelectedBenchmark as frame_benchmarking::BenchmarkingSetup<Test>>::instance(
+					&selected_benchmark,
+					&c,
+					true,
+				)
+				.unwrap();
+
+			assert_ok!(closure_to_benchmark());
+		});
+	}
+}
diff --git a/substrate/frame/staking/src/election_size_tracker.rs b/substrate/frame/staking/src/election_size_tracker.rs
new file mode 100644
index 0000000000000000000000000000000000000000..283ae0140ee6894b19dce2f6bb67bbcc771029f0
--- /dev/null
+++ b/substrate/frame/staking/src/election_size_tracker.rs
@@ -0,0 +1,259 @@
+// 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 static size tracker for the election snapshot data.
+//!
+//! ### Overview
+//!
+//! The goal of the size tracker is to provide a static, no-allocation byte tracker to be
+//! used by the election data provider when preparing the results of
+//! [`ElectionDataProvider::electing_voters`]. The [`StaticTracker`] implementation uses
+//! [`codec::Encode::size_hint`] to estimate the SCALE encoded size of the snapshot voters struct
+//! as it is being constructed without requiring extra stack allocations.
+//!
+//! The [`StaticTracker::try_register_voter`] is called to update the static tracker internal
+//! state, if It will return an error if the resulting SCALE encoded size (in bytes) is larger than
+//! the provided `DataProviderBounds`.
+//!
+//! ### Example
+//!
+//! ```ignore
+//! use pallet_staking::election_size_tracker::*;
+//!
+//! // instantiates a new tracker.
+//! let mut size_tracker = StaticTracker::<Staking>::default();
+//!
+//! let voter_bounds = ElectionBoundsBuilder::default().voter_size(1_00.into()).build().voters;
+//!
+//! let mut sorted_voters = T::VoterList.iter();
+//! let mut selected_voters = vec![];
+//!
+//! // fit as many voters in the vec as the bounds permit.
+//! for v in sorted_voters {
+//!     let voter = (v, weight_of(&v), targets_of(&v));
+//!     if size_tracker.try_register_voter(&voter, &voter_bounds).is_err() {
+//!         // voter bounds size exhausted
+//!         break;
+//!     }
+//!     selected_voters.push(voter);
+//! }
+//!
+//! // The SCALE encoded size in bytes of `selected_voters` is guaranteed to be below
+//! // `voter_bounds`.
+//! debug_assert!(
+//!     selected_voters.encoded_size() <=
+//!     SizeTracker::<Staking>::final_byte_size_of(size_tracker.num_voters, size_tracker.size)
+//! );
+//! ```
+//!
+//! ### Implementation Details
+//!
+//! The current implementation of the static tracker is tightly coupled with the staking pallet
+//! implementation, namely the representation of a voter ([`VoterOf`]). The SCALE encoded byte size
+//! is calculated using [`Encode::size_hint`] of each type in the voter tuple. Each voter's byte
+//! size is the sum of:
+//! - 1 * [`Encode::size_hint`] of the `AccountId` type;
+//! - 1 * [`Encode::size_hint`] of the `VoteWeight` type;
+//! - `num_votes` * [`Encode::size_hint`] of the `AccountId` type.
+
+use codec::Encode;
+use frame_election_provider_support::{
+	bounds::{DataProviderBounds, SizeBound},
+	ElectionDataProvider, VoterOf,
+};
+
+/// Keeps track of the SCALE encoded byte length of the snapshot's voters or targets.
+///
+/// The tracker calculates the bytes used based on static rules, without requiring any actual
+/// encoding or extra allocations.
+#[derive(Clone, Copy, Debug)]
+pub struct StaticTracker<DataProvider> {
+	pub size: usize,
+	pub counter: usize,
+	_marker: sp_std::marker::PhantomData<DataProvider>,
+}
+
+impl<DataProvider> Default for StaticTracker<DataProvider> {
+	fn default() -> Self {
+		Self { size: 0, counter: 0, _marker: Default::default() }
+	}
+}
+
+impl<DataProvider> StaticTracker<DataProvider>
+where
+	DataProvider: ElectionDataProvider,
+{
+	/// Tries to register a new voter.
+	///
+	/// If the new voter exhausts the provided bounds, return an error. Otherwise, the internal
+	/// state of the tracker is updated with the new registered voter.
+	pub fn try_register_voter(
+		&mut self,
+		voter: &VoterOf<DataProvider>,
+		bounds: &DataProviderBounds,
+	) -> Result<(), ()> {
+		let tracker_size_after = {
+			let voter_hint = Self::voter_size_hint(voter);
+			Self::final_byte_size_of(self.counter + 1, self.size.saturating_add(voter_hint))
+		};
+
+		match bounds.size_exhausted(SizeBound(tracker_size_after as u32)) {
+			true => Err(()),
+			false => {
+				self.size = tracker_size_after;
+				self.counter += 1;
+				Ok(())
+			},
+		}
+	}
+
+	/// Calculates the size of the voter to register based on [`Encode::size_hint`].
+	fn voter_size_hint(voter: &VoterOf<DataProvider>) -> usize {
+		let (voter_account, vote_weight, targets) = voter;
+
+		voter_account
+			.size_hint()
+			.saturating_add(vote_weight.size_hint())
+			.saturating_add(voter_account.size_hint().saturating_mul(targets.len()))
+	}
+
+	/// Tries to register a new target.
+	///
+	/// If the new target exhausts the provided bounds, return an error. Otherwise, the internal
+	/// state of the tracker is updated with the new registered target.
+	pub fn try_register_target(
+		&mut self,
+		target: DataProvider::AccountId,
+		bounds: &DataProviderBounds,
+	) -> Result<(), ()> {
+		let tracker_size_after = Self::final_byte_size_of(
+			self.counter + 1,
+			self.size.saturating_add(target.size_hint()),
+		);
+
+		match bounds.size_exhausted(SizeBound(tracker_size_after as u32)) {
+			true => Err(()),
+			false => {
+				self.size = tracker_size_after;
+				self.counter += 1;
+				Ok(())
+			},
+		}
+	}
+
+	/// Size of the SCALE encoded prefix with a given length.
+	#[inline]
+	fn length_prefix(len: usize) -> usize {
+		use codec::{Compact, CompactLen};
+		Compact::<u32>::compact_len(&(len as u32))
+	}
+
+	/// Calculates the final size in bytes of the SCALE encoded snapshot voter struct.
+	fn final_byte_size_of(num_voters: usize, size: usize) -> usize {
+		Self::length_prefix(num_voters).saturating_add(size)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		mock::{AccountId, Staking, Test},
+		BoundedVec, MaxNominationsOf,
+	};
+	use frame_election_provider_support::bounds::ElectionBoundsBuilder;
+	use sp_core::bounded_vec;
+
+	type Voters = BoundedVec<AccountId, MaxNominationsOf<Test>>;
+
+	#[test]
+	pub fn election_size_tracker_works() {
+		let mut voters: Vec<(u64, u64, Voters)> = vec![];
+		let mut size_tracker = StaticTracker::<Staking>::default();
+		let voter_bounds = ElectionBoundsBuilder::default().voters_size(1_50.into()).build().voters;
+
+		// register 1 voter with 1 vote.
+		let voter = (1, 10, bounded_vec![2]);
+		assert!(size_tracker.try_register_voter(&voter, &voter_bounds).is_ok());
+		voters.push(voter);
+
+		assert_eq!(
+			StaticTracker::<Staking>::final_byte_size_of(size_tracker.counter, size_tracker.size),
+			voters.encoded_size()
+		);
+
+		// register another voter, now with 3 votes.
+		let voter = (2, 20, bounded_vec![3, 4, 5]);
+		assert!(size_tracker.try_register_voter(&voter, &voter_bounds).is_ok());
+		voters.push(voter);
+
+		assert_eq!(
+			StaticTracker::<Staking>::final_byte_size_of(size_tracker.counter, size_tracker.size),
+			voters.encoded_size()
+		);
+
+		// register noop vote (unlikely to happen).
+		let voter = (3, 30, bounded_vec![]);
+		assert!(size_tracker.try_register_voter(&voter, &voter_bounds).is_ok());
+		voters.push(voter);
+
+		assert_eq!(
+			StaticTracker::<Staking>::final_byte_size_of(size_tracker.counter, size_tracker.size),
+			voters.encoded_size()
+		);
+	}
+
+	#[test]
+	pub fn election_size_tracker_bounds_works() {
+		let mut voters: Vec<(u64, u64, Voters)> = vec![];
+		let mut size_tracker = StaticTracker::<Staking>::default();
+		let voter_bounds = ElectionBoundsBuilder::default().voters_size(1_00.into()).build().voters;
+
+		let voter = (1, 10, bounded_vec![2]);
+		assert!(size_tracker.try_register_voter(&voter, &voter_bounds).is_ok());
+		voters.push(voter);
+
+		assert_eq!(
+			StaticTracker::<Staking>::final_byte_size_of(size_tracker.counter, size_tracker.size),
+			voters.encoded_size()
+		);
+
+		assert!(size_tracker.size > 0 && size_tracker.size < 1_00);
+		let size_before_overflow = size_tracker.size;
+
+		// try many voters that will overflow the tracker's buffer.
+		let voter = (2, 10, bounded_vec![2, 3, 4, 5, 6, 7, 8, 9]);
+		voters.push(voter.clone());
+
+		assert!(size_tracker.try_register_voter(&voter, &voter_bounds).is_err());
+		assert!(size_tracker.size > 0 && size_tracker.size < 1_00);
+
+		// size of the tracker did not update when trying to register votes failed.
+		assert_eq!(size_tracker.size, size_before_overflow);
+	}
+
+	#[test]
+	fn len_prefix_works() {
+		let length_samples =
+			vec![0usize, 1, 62, 63, 64, 16383, 16384, 16385, 1073741822, 1073741823, 1073741824];
+
+		for s in length_samples {
+			// the encoded size of a vector of n bytes should be n + the length prefix
+			assert_eq!(vec![1u8; s].encoded_size(), StaticTracker::<Staking>::length_prefix(s) + s);
+		}
+	}
+}
diff --git a/substrate/frame/staking/src/inflation.rs b/substrate/frame/staking/src/inflation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8b4a85b6c2d81c8a393d221c7138ed5a10f4f317
--- /dev/null
+++ b/substrate/frame/staking/src/inflation.rs
@@ -0,0 +1,108 @@
+// 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 module expose one function `P_NPoS` (Payout NPoS) or `compute_total_payout` which returns
+//! the total payout for the era given the era duration and the staking rate in NPoS.
+//! The staking rate in NPoS is the total amount of tokens staked by nominators and validators,
+//! divided by the total token supply.
+
+use sp_runtime::{curve::PiecewiseLinear, traits::AtLeast32BitUnsigned, Perbill};
+
+/// The total payout to all validators (and their nominators) per era and maximum payout.
+///
+/// Defined as such:
+/// `staker-payout = yearly_inflation(npos_token_staked / total_tokens) * total_tokens /
+/// era_per_year` `maximum-payout = max_yearly_inflation * total_tokens / era_per_year`
+///
+/// `era_duration` is expressed in millisecond.
+pub fn compute_total_payout<N>(
+	yearly_inflation: &PiecewiseLinear<'static>,
+	npos_token_staked: N,
+	total_tokens: N,
+	era_duration: u64,
+) -> (N, N)
+where
+	N: AtLeast32BitUnsigned + Clone,
+{
+	// Milliseconds per year for the Julian year (365.25 days).
+	const MILLISECONDS_PER_YEAR: u64 = 1000 * 3600 * 24 * 36525 / 100;
+
+	let portion = Perbill::from_rational(era_duration as u64, MILLISECONDS_PER_YEAR);
+	let payout = portion *
+		yearly_inflation
+			.calculate_for_fraction_times_denominator(npos_token_staked, total_tokens.clone());
+	let maximum = portion * (yearly_inflation.maximum * total_tokens);
+	(payout, maximum)
+}
+
+#[cfg(test)]
+mod test {
+	use sp_runtime::curve::PiecewiseLinear;
+
+	pallet_staking_reward_curve::build! {
+		const I_NPOS: 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,
+		);
+	}
+
+	#[test]
+	fn npos_curve_is_sensible() {
+		const YEAR: u64 = 365 * 24 * 60 * 60 * 1000;
+
+		// check maximum inflation.
+		// not 10_000 due to rounding error.
+		assert_eq!(super::compute_total_payout(&I_NPOS, 0, 100_000u64, YEAR).1, 9_993);
+
+		// super::I_NPOS.calculate_for_fraction_times_denominator(25, 100)
+		assert_eq!(super::compute_total_payout(&I_NPOS, 0, 100_000u64, YEAR).0, 2_498);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 5_000, 100_000u64, YEAR).0, 3_248);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 25_000, 100_000u64, YEAR).0, 6_246);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 40_000, 100_000u64, YEAR).0, 8_494);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 50_000, 100_000u64, YEAR).0, 9_993);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 60_000, 100_000u64, YEAR).0, 4_379);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 75_000, 100_000u64, YEAR).0, 2_733);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 95_000, 100_000u64, YEAR).0, 2_513);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 100_000, 100_000u64, YEAR).0, 2_505);
+
+		const DAY: u64 = 24 * 60 * 60 * 1000;
+		assert_eq!(super::compute_total_payout(&I_NPOS, 25_000, 100_000u64, DAY).0, 17);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 50_000, 100_000u64, DAY).0, 27);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 75_000, 100_000u64, DAY).0, 7);
+
+		const SIX_HOURS: u64 = 6 * 60 * 60 * 1000;
+		assert_eq!(super::compute_total_payout(&I_NPOS, 25_000, 100_000u64, SIX_HOURS).0, 4);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 50_000, 100_000u64, SIX_HOURS).0, 7);
+		assert_eq!(super::compute_total_payout(&I_NPOS, 75_000, 100_000u64, SIX_HOURS).0, 2);
+
+		const HOUR: u64 = 60 * 60 * 1000;
+		assert_eq!(
+			super::compute_total_payout(
+				&I_NPOS,
+				2_500_000_000_000_000_000_000_000_000u128,
+				5_000_000_000_000_000_000_000_000_000u128,
+				HOUR
+			)
+			.0,
+			57_038_500_000_000_000_000_000
+		);
+	}
+}
diff --git a/substrate/frame/staking/src/lib.rs b/substrate/frame/staking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e59b2a3324a62b69aa2f0577a63e7f399076324e
--- /dev/null
+++ b/substrate/frame/staking/src/lib.rs
@@ -0,0 +1,994 @@
+// 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.
+
+//! # Staking Pallet
+//!
+//! The Staking pallet is used to manage funds at stake by network maintainers.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! The Staking pallet is the means by which a set of network maintainers (known as _authorities_ in
+//! some contexts and _validators_ in others) are chosen based upon those who voluntarily place
+//! funds under deposit. Under deposit, those funds are rewarded under normal operation but are held
+//! at pain of _slash_ (expropriation) should the staked maintainer be found not to be discharging
+//! its duties properly.
+//!
+//! ### Terminology
+//! <!-- Original author of paragraph: @gavofyork -->
+//!
+//! - Staking: The process of locking up funds for some time, placing them at risk of slashing
+//!   (loss) in order to become a rewarded maintainer of the network.
+//! - Validating: The process of running a node to actively maintain the network, either by
+//!   producing blocks or guaranteeing finality of the chain.
+//! - Nominating: The process of placing staked funds behind one or more validators in order to
+//!   share in any reward, and punishment, they take.
+//! - Stash account: The account holding an owner's funds used for staking.
+//! - Controller account: The account that controls an owner's funds for staking.
+//! - Era: A (whole) number of sessions, which is the period that the validator set (and each
+//!   validator's active nominator set) is recalculated and where rewards are paid out.
+//! - Slash: The punishment of a staker by reducing its funds.
+//!
+//! ### Goals
+//! <!-- Original author of paragraph: @gavofyork -->
+//!
+//! The staking system in Substrate NPoS is designed to make the following possible:
+//!
+//! - Stake funds that are controlled by a cold wallet.
+//! - Withdraw some, or deposit more, funds without interrupting the role of an entity.
+//! - Switch between roles (nominator, validator, idle) with minimal overhead.
+//!
+//! ### Scenarios
+//!
+//! #### Staking
+//!
+//! Almost any interaction with the Staking pallet requires a process of _**bonding**_ (also known
+//! as being a _staker_). To become *bonded*, a fund-holding register known as the _stash account_,
+//! which holds some or all of the funds that become frozen in place as part of the staking process,
+//! is paired with an active **controller** account, which issues instructions on how they shall be
+//! used.
+//!
+//! An account pair can become bonded using the [`bond`](Call::bond) call.
+//!
+//! Stash accounts can update their associated controller back to the stash account using the
+//! [`set_controller`](Call::set_controller) call.
+//!
+//! There are three possible roles that any staked account pair can be in: `Validator`, `Nominator`
+//! and `Idle` (defined in [`StakerStatus`]). There are three
+//! corresponding instructions to change between roles, namely:
+//! [`validate`](Call::validate),
+//! [`nominate`](Call::nominate), and [`chill`](Call::chill).
+//!
+//! #### Validating
+//!
+//! A **validator** takes the role of either validating blocks or ensuring their finality,
+//! maintaining the veracity of the network. A validator should avoid both any sort of malicious
+//! misbehavior and going offline. Bonded accounts that state interest in being a validator do NOT
+//! get immediately chosen as a validator. Instead, they are declared as a _candidate_ and they
+//! _might_ get elected at the _next era_ as a validator. The result of the election is determined
+//! by nominators and their votes.
+//!
+//! An account can become a validator candidate via the
+//! [`validate`](Call::validate) call.
+//!
+//! #### Nomination
+//!
+//! A **nominator** does not take any _direct_ role in maintaining the network, instead, it votes on
+//! a set of validators  to be elected. Once interest in nomination is stated by an account, it
+//! takes effect at the next election round. The funds in the nominator's stash account indicate the
+//! _weight_ of its vote. Both the rewards and any punishment that a validator earns are shared
+//! between the validator and its nominators. This rule incentivizes the nominators to NOT vote for
+//! the misbehaving/offline validators as much as possible, simply because the nominators will also
+//! lose funds if they vote poorly.
+//!
+//! An account can become a nominator via the [`nominate`](Call::nominate) call.
+//!
+//! #### Voting
+//!
+//! Staking is closely related to elections; actual validators are chosen from among all potential
+//! validators via election by the potential validators and nominators. To reduce use of the phrase
+//! "potential validators and nominators", we often use the term **voters**, who are simply
+//! the union of potential validators and nominators.
+//!
+//! #### Rewards and Slash
+//!
+//! The **reward and slashing** procedure is the core of the Staking pallet, attempting to _embrace
+//! valid behavior_ while _punishing any misbehavior or lack of availability_.
+//!
+//! Rewards must be claimed for each era before it gets too old by `$HISTORY_DEPTH` using the
+//! `payout_stakers` call. Any account can call `payout_stakers`, which pays the reward to the
+//! validator as well as its nominators. Only the [`Config::MaxNominatorRewardedPerValidator`]
+//! biggest stakers can claim their reward. This is to limit the i/o cost to mutate storage for each
+//! nominator's account.
+//!
+//! Slashing can occur at any point in time, once misbehavior is reported. Once slashing is
+//! determined, a value is deducted from the balance of the validator and all the nominators who
+//! voted for this validator (values are deducted from the _stash_ account of the slashed entity).
+//!
+//! Slashing logic is further described in the documentation of the `slashing` pallet.
+//!
+//! Similar to slashing, rewards are also shared among a validator and its associated nominators.
+//! Yet, the reward funds are not always transferred to the stash account and can be configured. See
+//! [Reward Calculation](#reward-calculation) for more details.
+//!
+//! #### Chilling
+//!
+//! Finally, any of the roles above can choose to step back temporarily and just chill for a while.
+//! This means that if they are a nominator, they will not be considered as voters anymore and if
+//! they are validators, they will no longer be a candidate for the next election.
+//!
+//! An account can step back via the [`chill`](Call::chill) call.
+//!
+//! ### Session managing
+//!
+//! The pallet implement the trait `SessionManager`. Which is the only API to query new validator
+//! set and allowing these validator set to be rewarded once their era is ended.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! The dispatchable functions of the Staking pallet enable the steps needed for entities to accept
+//! and change their role, alongside some helper functions to get/set the metadata of the pallet.
+//!
+//! ### Public Functions
+//!
+//! The Staking pallet contains many public storage items and (im)mutable functions.
+//!
+//! ## Usage
+//!
+//! ### Example: Rewarding a validator by id.
+//!
+//! ```
+//! use pallet_staking::{self as staking};
+//!
+//! #[frame_support::pallet(dev_mode)]
+//! pub mod pallet {
+//! 	use super::*;
+//! 	use frame_support::pallet_prelude::*;
+//! 	use frame_system::pallet_prelude::*;
+//!
+//! 	#[pallet::pallet]
+//! 	pub struct Pallet<T>(_);
+//!
+//! 	#[pallet::config]
+//! 	pub trait Config: frame_system::Config + staking::Config {}
+//!
+//! 	#[pallet::call]
+//! 	impl<T: Config> Pallet<T> {
+//!         /// Reward a validator.
+//!         #[pallet::weight(0)]
+//!         pub fn reward_myself(origin: OriginFor<T>) -> DispatchResult {
+//!             let reported = ensure_signed(origin)?;
+//!             <staking::Pallet<T>>::reward_by_ids(vec![(reported, 10)]);
+//!             Ok(())
+//!         }
+//!     }
+//! }
+//! # fn main() { }
+//! ```
+//!
+//! ## Implementation Details
+//!
+//! ### Era payout
+//!
+//! The era payout is computed using yearly inflation curve defined at
+//! [`Config::EraPayout`] as such:
+//!
+//! ```nocompile
+//! staker_payout = yearly_inflation(npos_token_staked / total_tokens) * total_tokens / era_per_year
+//! ```
+//! This payout is used to reward stakers as defined in next section
+//!
+//! ```nocompile
+//! remaining_payout = max_yearly_inflation * total_tokens / era_per_year - staker_payout
+//! ```
+//! The remaining reward is send to the configurable end-point
+//! [`Config::RewardRemainder`].
+//!
+//! ### Reward Calculation
+//!
+//! Validators and nominators are rewarded at the end of each era. The total reward of an era is
+//! calculated using the era duration and the staking rate (the total amount of tokens staked by
+//! nominators and validators, divided by the total token supply). It aims to incentivize toward a
+//! defined staking rate. The full specification can be found
+//! [here](https://research.web3.foundation/en/latest/polkadot/Token%20Economics.html#inflation-model).
+//!
+//! Total reward is split among validators and their nominators depending on the number of points
+//! they received during the era. Points are added to a validator using
+//! [`reward_by_ids`](Pallet::reward_by_ids).
+//!
+//! [`Pallet`] implements
+//! [`pallet_authorship::EventHandler`] to add reward
+//! points to block producer and block producer of referenced uncles.
+//!
+//! The validator and its nominator split their reward as following:
+//!
+//! The validator can declare an amount, named [`commission`](ValidatorPrefs::commission), that does
+//! not get shared with the nominators at each reward payout through its [`ValidatorPrefs`]. This
+//! value gets deducted from the total reward that is paid to the validator and its nominators. The
+//! remaining portion is split pro rata among the validator and the top
+//! [`Config::MaxNominatorRewardedPerValidator`] nominators that nominated the validator,
+//! proportional to the value staked behind the validator (_i.e._ dividing the
+//! [`own`](Exposure::own) or [`others`](Exposure::others) by [`total`](Exposure::total) in
+//! [`Exposure`]). Note that the pro rata division of rewards uses the total exposure behind the
+//! validator, *not* just the exposure of the validator and the top
+//! [`Config::MaxNominatorRewardedPerValidator`] nominators.
+//!
+//! All entities who receive a reward have the option to choose their reward destination through the
+//! [`Payee`] storage item (see
+//! [`set_payee`](Call::set_payee)), to be one of the following:
+//!
+//! - Controller account, (obviously) not increasing the staked value.
+//! - Stash account, not increasing the staked value.
+//! - Stash account, also increasing the staked value.
+//!
+//! ### Additional Fund Management Operations
+//!
+//! Any funds already placed into stash can be the target of the following operations:
+//!
+//! The controller account can free a portion (or all) of the funds using the
+//! [`unbond`](Call::unbond) call. Note that the funds are not immediately
+//! accessible. Instead, a duration denoted by
+//! [`Config::BondingDuration`] (in number of eras) must
+//! pass until the funds can actually be removed. Once the `BondingDuration` is over, the
+//! [`withdraw_unbonded`](Call::withdraw_unbonded) call can be used to actually
+//! withdraw the funds.
+//!
+//! Note that there is a limitation to the number of fund-chunks that can be scheduled to be
+//! unlocked in the future via [`unbond`](Call::unbond). In case this maximum
+//! (`MAX_UNLOCKING_CHUNKS`) is reached, the bonded account _must_ first wait until a successful
+//! call to `withdraw_unbonded` to remove some of the chunks.
+//!
+//! ### Election Algorithm
+//!
+//! The current election algorithm is implemented based on Phragmén. The reference implementation
+//! can be found [here](https://github.com/w3f/consensus/tree/master/NPoS).
+//!
+//! The election algorithm, aside from electing the validators with the most stake value and votes,
+//! tries to divide the nominator votes among candidates in an equal manner. To further assure this,
+//! an optional post-processing can be applied that iteratively normalizes the nominator staked
+//! values until the total difference among votes of a particular nominator are less than a
+//! threshold.
+//!
+//! ## GenesisConfig
+//!
+//! The Staking pallet depends on the [`GenesisConfig`]. The
+//! `GenesisConfig` is optional and allow to set some initial stakers.
+//!
+//! ## Related Modules
+//!
+//! - [Balances](../pallet_balances/index.html): Used to manage values at stake.
+//! - [Session](../pallet_session/index.html): Used to manage sessions. Also, a list of new
+//!   validators is stored in the Session pallet's `Validators` at the end of each era.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![recursion_limit = "256"]
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+#[cfg(any(feature = "runtime-benchmarks", test))]
+pub mod testing_utils;
+
+#[cfg(test)]
+pub(crate) mod mock;
+#[cfg(test)]
+mod tests;
+
+pub mod election_size_tracker;
+pub mod inflation;
+pub mod migrations;
+pub mod slashing;
+pub mod weights;
+
+mod pallet;
+
+use codec::{Decode, Encode, HasCompact, MaxEncodedLen};
+use frame_support::{
+	traits::{ConstU32, Currency, Defensive, Get},
+	weights::Weight,
+	BoundedVec, CloneNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	curve::PiecewiseLinear,
+	traits::{AtLeast32BitUnsigned, Convert, Saturating, StaticLookup, Zero},
+	Perbill, Perquintill, Rounding, RuntimeDebug,
+};
+pub use sp_staking::StakerStatus;
+use sp_staking::{
+	offence::{Offence, OffenceError, ReportOffence},
+	EraIndex, OnStakingUpdate, SessionIndex,
+};
+use sp_std::{collections::btree_map::BTreeMap, prelude::*};
+pub use weights::WeightInfo;
+
+pub use pallet::{pallet::*, UseNominatorsAndValidatorsMap, UseValidatorsMap};
+
+pub(crate) const LOG_TARGET: &str = "runtime::staking";
+
+// syntactic sugar for logging.
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: crate::LOG_TARGET,
+			concat!("[{:?}] 💸 ", $patter), <frame_system::Pallet<T>>::block_number() $(, $values)*
+		)
+	};
+}
+
+/// Maximum number of winners (aka. active validators), as defined in the election provider of this
+/// pallet.
+pub type MaxWinnersOf<T> = <<T as Config>::ElectionProvider as frame_election_provider_support::ElectionProviderBase>::MaxWinners;
+
+/// Maximum number of nominations per nominator.
+pub type MaxNominationsOf<T> =
+	<<T as Config>::NominationsQuota as NominationsQuota<BalanceOf<T>>>::MaxNominations;
+
+/// Counter for the number of "reward" points earned by a given validator.
+pub type RewardPoint = u32;
+
+/// The balance type of this pallet.
+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<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// Information regarding the active era (era in used in session).
+#[derive(Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct ActiveEraInfo {
+	/// Index of era.
+	pub index: EraIndex,
+	/// Moment of start expressed as millisecond from `$UNIX_EPOCH`.
+	///
+	/// Start can be none if start hasn't been set for the era yet,
+	/// Start is set on the first on_finalize of the era to guarantee usage of `Time`.
+	start: Option<u64>,
+}
+
+/// Reward points of an era. Used to split era total payout between validators.
+///
+/// This points will be used to reward validators and their respective nominators.
+#[derive(PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct EraRewardPoints<AccountId: Ord> {
+	/// Total number of points. Equals the sum of reward points for each validator.
+	pub total: RewardPoint,
+	/// The reward points earned by a given validator.
+	pub individual: BTreeMap<AccountId, RewardPoint>,
+}
+
+impl<AccountId: Ord> Default for EraRewardPoints<AccountId> {
+	fn default() -> Self {
+		EraRewardPoints { total: Default::default(), individual: BTreeMap::new() }
+	}
+}
+
+/// A destination account for payment.
+#[derive(PartialEq, Eq, Copy, Clone, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum RewardDestination<AccountId> {
+	/// Pay into the stash account, increasing the amount at stake accordingly.
+	Staked,
+	/// Pay into the stash account, not increasing the amount at stake.
+	Stash,
+	/// Pay into the controller account.
+	Controller,
+	/// Pay into a specified account.
+	Account(AccountId),
+	/// Receive no reward.
+	None,
+}
+
+impl<AccountId> Default for RewardDestination<AccountId> {
+	fn default() -> Self {
+		RewardDestination::Staked
+	}
+}
+
+/// Preference of what happens regarding validation.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo, Default, MaxEncodedLen)]
+pub struct ValidatorPrefs {
+	/// Reward that validator takes up-front; only the rest is split between themselves and
+	/// nominators.
+	#[codec(compact)]
+	pub commission: Perbill,
+	/// Whether or not this validator is accepting more nominations. If `true`, then no nominator
+	/// who is not already nominating this validator may nominate them. By default, validators
+	/// are accepting nominations.
+	pub blocked: bool,
+}
+
+/// Just a Balance/BlockNumber tuple to encode when a chunk of funds will be unlocked.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct UnlockChunk<Balance: HasCompact + MaxEncodedLen> {
+	/// Amount of funds to be unlocked.
+	#[codec(compact)]
+	value: Balance,
+	/// Era number at which point it'll be unlocked.
+	#[codec(compact)]
+	era: EraIndex,
+}
+
+/// The ledger of a (bonded) stash.
+#[derive(
+	PartialEqNoBound,
+	EqNoBound,
+	CloneNoBound,
+	Encode,
+	Decode,
+	RuntimeDebugNoBound,
+	TypeInfo,
+	MaxEncodedLen,
+)]
+#[scale_info(skip_type_params(T))]
+pub struct StakingLedger<T: Config> {
+	/// The stash account whose balance is actually locked and at stake.
+	pub stash: T::AccountId,
+	/// The total amount of the stash's balance that we are currently accounting for.
+	/// It's just `active` plus all the `unlocking` balances.
+	#[codec(compact)]
+	pub total: BalanceOf<T>,
+	/// The total amount of the stash's balance that will be at stake in any forthcoming
+	/// rounds.
+	#[codec(compact)]
+	pub active: BalanceOf<T>,
+	/// Any balance that is becoming free, which may eventually be transferred out of the stash
+	/// (assuming it doesn't get slashed first). It is assumed that this will be treated as a first
+	/// in, first out queue where the new (higher value) eras get pushed on the back.
+	pub unlocking: BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>,
+	/// List of eras for which the stakers behind a validator have claimed rewards. Only updated
+	/// for validators.
+	pub claimed_rewards: BoundedVec<EraIndex, T::HistoryDepth>,
+}
+
+impl<T: Config> StakingLedger<T> {
+	/// Initializes the default object using the given `validator`.
+	pub fn default_from(stash: T::AccountId) -> Self {
+		Self {
+			stash,
+			total: Zero::zero(),
+			active: Zero::zero(),
+			unlocking: Default::default(),
+			claimed_rewards: Default::default(),
+		}
+	}
+
+	/// Remove entries from `unlocking` that are sufficiently old and reduce the
+	/// total by the sum of their balances.
+	fn consolidate_unlocked(self, current_era: EraIndex) -> Self {
+		let mut total = self.total;
+		let unlocking: BoundedVec<_, _> = self
+			.unlocking
+			.into_iter()
+			.filter(|chunk| {
+				if chunk.era > current_era {
+					true
+				} else {
+					total = total.saturating_sub(chunk.value);
+					false
+				}
+			})
+			.collect::<Vec<_>>()
+			.try_into()
+			.expect(
+				"filtering items from a bounded vec always leaves length less than bounds. qed",
+			);
+
+		Self {
+			stash: self.stash,
+			total,
+			active: self.active,
+			unlocking,
+			claimed_rewards: self.claimed_rewards,
+		}
+	}
+
+	/// Re-bond funds that were scheduled for unlocking.
+	///
+	/// Returns the updated ledger, and the amount actually rebonded.
+	fn rebond(mut self, value: BalanceOf<T>) -> (Self, BalanceOf<T>) {
+		let mut unlocking_balance = BalanceOf::<T>::zero();
+
+		while let Some(last) = self.unlocking.last_mut() {
+			if unlocking_balance + last.value <= value {
+				unlocking_balance += last.value;
+				self.active += last.value;
+				self.unlocking.pop();
+			} else {
+				let diff = value - unlocking_balance;
+
+				unlocking_balance += diff;
+				self.active += diff;
+				last.value -= diff;
+			}
+
+			if unlocking_balance >= value {
+				break
+			}
+		}
+
+		(self, unlocking_balance)
+	}
+
+	/// Slash the staker for a given amount of balance.
+	///
+	/// This implements a proportional slashing system, whereby we set our preference to slash as
+	/// such:
+	///
+	/// - If any unlocking chunks exist that are scheduled to be unlocked at `slash_era +
+	///   bonding_duration` and onwards, the slash is divided equally between the active ledger and
+	///   the unlocking chunks.
+	/// - If no such chunks exist, then only the active balance is slashed.
+	///
+	/// Note that the above is only a *preference*. If for any reason the active ledger, with or
+	/// without some portion of the unlocking chunks that are more justified to be slashed are not
+	/// enough, then the slashing will continue and will consume as much of the active and unlocking
+	/// chunks as needed.
+	///
+	/// This will never slash more than the given amount. If any of the chunks become dusted, the
+	/// last chunk is slashed slightly less to compensate. Returns the amount of funds actually
+	/// slashed.
+	///
+	/// `slash_era` is the era in which the slash (which is being enacted now) actually happened.
+	///
+	/// This calls `Config::OnStakingUpdate::on_slash` with information as to how the slash was
+	/// applied.
+	pub fn slash(
+		&mut self,
+		slash_amount: BalanceOf<T>,
+		minimum_balance: BalanceOf<T>,
+		slash_era: EraIndex,
+	) -> BalanceOf<T> {
+		if slash_amount.is_zero() {
+			return Zero::zero()
+		}
+
+		use sp_runtime::PerThing as _;
+		let mut remaining_slash = slash_amount;
+		let pre_slash_total = self.total;
+
+		// for a `slash_era = x`, any chunk that is scheduled to be unlocked at era `x + 28`
+		// (assuming 28 is the bonding duration) onwards should be slashed.
+		let slashable_chunks_start = slash_era + T::BondingDuration::get();
+
+		// `Some(ratio)` if this is proportional, with `ratio`, `None` otherwise. In both cases, we
+		// slash first the active chunk, and then `slash_chunks_priority`.
+		let (maybe_proportional, slash_chunks_priority) = {
+			if let Some(first_slashable_index) =
+				self.unlocking.iter().position(|c| c.era >= slashable_chunks_start)
+			{
+				// If there exists a chunk who's after the first_slashable_start, then this is a
+				// proportional slash, because we want to slash active and these chunks
+				// proportionally.
+
+				// The indices of the first chunk after the slash up through the most recent chunk.
+				// (The most recent chunk is at greatest from this era)
+				let affected_indices = first_slashable_index..self.unlocking.len();
+				let unbonding_affected_balance =
+					affected_indices.clone().fold(BalanceOf::<T>::zero(), |sum, i| {
+						if let Some(chunk) = self.unlocking.get(i).defensive() {
+							sum.saturating_add(chunk.value)
+						} else {
+							sum
+						}
+					});
+				let affected_balance = self.active.saturating_add(unbonding_affected_balance);
+				let ratio = Perquintill::from_rational_with_rounding(
+					slash_amount,
+					affected_balance,
+					Rounding::Up,
+				)
+				.unwrap_or_else(|_| Perquintill::one());
+				(
+					Some(ratio),
+					affected_indices.chain((0..first_slashable_index).rev()).collect::<Vec<_>>(),
+				)
+			} else {
+				// We just slash from the last chunk to the most recent one, if need be.
+				(None, (0..self.unlocking.len()).rev().collect::<Vec<_>>())
+			}
+		};
+
+		// Helper to update `target` and the ledgers total after accounting for slashing `target`.
+		log!(
+			debug,
+			"slashing {:?} for era {:?} out of {:?}, priority: {:?}, proportional = {:?}",
+			slash_amount,
+			slash_era,
+			self,
+			slash_chunks_priority,
+			maybe_proportional,
+		);
+
+		let mut slash_out_of = |target: &mut BalanceOf<T>, slash_remaining: &mut BalanceOf<T>| {
+			let mut slash_from_target = if let Some(ratio) = maybe_proportional {
+				ratio.mul_ceil(*target)
+			} else {
+				*slash_remaining
+			}
+			// this is the total that that the slash target has. We can't slash more than
+			// this anyhow!
+			.min(*target)
+			// this is the total amount that we would have wanted to slash
+			// non-proportionally, a proportional slash should never exceed this either!
+			.min(*slash_remaining);
+
+			// slash out from *target exactly `slash_from_target`.
+			*target = *target - slash_from_target;
+			if *target < minimum_balance {
+				// Slash the rest of the target if it's dust. This might cause the last chunk to be
+				// slightly under-slashed, by at most `MaxUnlockingChunks * ED`, which is not a big
+				// deal.
+				slash_from_target =
+					sp_std::mem::replace(target, Zero::zero()).saturating_add(slash_from_target)
+			}
+
+			self.total = self.total.saturating_sub(slash_from_target);
+			*slash_remaining = slash_remaining.saturating_sub(slash_from_target);
+		};
+
+		// If this is *not* a proportional slash, the active will always wiped to 0.
+		slash_out_of(&mut self.active, &mut remaining_slash);
+
+		let mut slashed_unlocking = BTreeMap::<_, _>::new();
+		for i in slash_chunks_priority {
+			if remaining_slash.is_zero() {
+				break
+			}
+
+			if let Some(chunk) = self.unlocking.get_mut(i).defensive() {
+				slash_out_of(&mut chunk.value, &mut remaining_slash);
+				// write the new slashed value of this chunk to the map.
+				slashed_unlocking.insert(chunk.era, chunk.value);
+			} else {
+				break
+			}
+		}
+
+		// clean unlocking chunks that are set to zero.
+		self.unlocking.retain(|c| !c.value.is_zero());
+
+		T::EventListeners::on_slash(&self.stash, self.active, &slashed_unlocking);
+		pre_slash_total.saturating_sub(self.total)
+	}
+}
+
+/// A record of the nominations made by a specific account.
+#[derive(
+	PartialEqNoBound, EqNoBound, Clone, Encode, Decode, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen,
+)]
+#[codec(mel_bound())]
+#[scale_info(skip_type_params(T))]
+pub struct Nominations<T: Config> {
+	/// The targets of nomination.
+	pub targets: BoundedVec<T::AccountId, MaxNominationsOf<T>>,
+	/// The era the nominations were submitted.
+	///
+	/// Except for initial nominations which are considered submitted at era 0.
+	pub submitted_in: EraIndex,
+	/// Whether the nominations have been suppressed. This can happen due to slashing of the
+	/// validators, or other events that might invalidate the nomination.
+	///
+	/// NOTE: this for future proofing and is thus far not used.
+	pub suppressed: bool,
+}
+
+/// The amount of exposure (to slashing) than an individual nominator has.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct IndividualExposure<AccountId, Balance: HasCompact> {
+	/// The stash account of the nominator in question.
+	pub who: AccountId,
+	/// Amount of funds exposed.
+	#[codec(compact)]
+	pub value: Balance,
+}
+
+/// A snapshot of the stake backing a single validator in the system.
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct Exposure<AccountId, Balance: HasCompact> {
+	/// The total balance backing this validator.
+	#[codec(compact)]
+	pub total: Balance,
+	/// The validator's own stash that is exposed.
+	#[codec(compact)]
+	pub own: Balance,
+	/// The portions of nominators stashes that are exposed.
+	pub others: Vec<IndividualExposure<AccountId, Balance>>,
+}
+
+impl<AccountId, Balance: Default + HasCompact> Default for Exposure<AccountId, Balance> {
+	fn default() -> Self {
+		Self { total: Default::default(), own: Default::default(), others: vec![] }
+	}
+}
+
+/// A pending slash record. The value of the slash has been computed but not applied yet,
+/// rather deferred for several eras.
+#[derive(Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct UnappliedSlash<AccountId, Balance: HasCompact> {
+	/// The stash ID of the offending validator.
+	validator: AccountId,
+	/// The validator's own slash.
+	own: Balance,
+	/// All other slashed stakers and amounts.
+	others: Vec<(AccountId, Balance)>,
+	/// Reporters of the offence; bounty payout recipients.
+	reporters: Vec<AccountId>,
+	/// The amount of payout.
+	payout: Balance,
+}
+
+impl<AccountId, Balance: HasCompact + Zero> UnappliedSlash<AccountId, Balance> {
+	/// Initializes the default object using the given `validator`.
+	pub fn default_from(validator: AccountId) -> Self {
+		Self {
+			validator,
+			own: Zero::zero(),
+			others: vec![],
+			reporters: vec![],
+			payout: Zero::zero(),
+		}
+	}
+}
+
+/// Something that defines the maximum number of nominations per nominator based on a curve.
+///
+/// The method `curve` implements the nomination quota curve and should not be used directly.
+/// However, `get_quota` returns the bounded maximum number of nominations based on `fn curve` and
+/// the nominator's balance.
+pub trait NominationsQuota<Balance> {
+	/// Strict maximum number of nominations that caps the nominations curve. This value can be
+	/// used as the upper bound of the number of votes per nominator.
+	type MaxNominations: Get<u32>;
+
+	/// Returns the voter's nomination quota within reasonable bounds [`min`, `max`], where `min`
+	/// is 1 and `max` is `Self::MaxNominations`.
+	fn get_quota(balance: Balance) -> u32 {
+		Self::curve(balance).clamp(1, Self::MaxNominations::get())
+	}
+
+	/// Returns the voter's nomination quota based on its balance and a curve.
+	fn curve(balance: Balance) -> u32;
+}
+
+/// A nomination quota that allows up to MAX nominations for all validators.
+pub struct FixedNominationsQuota<const MAX: u32>;
+impl<Balance, const MAX: u32> NominationsQuota<Balance> for FixedNominationsQuota<MAX> {
+	type MaxNominations = ConstU32<MAX>;
+
+	fn curve(_: Balance) -> u32 {
+		MAX
+	}
+}
+
+/// Means for interacting with a specialized version of the `session` trait.
+///
+/// This is needed because `Staking` sets the `ValidatorIdOf` of the `pallet_session::Config`
+pub trait SessionInterface<AccountId> {
+	/// Disable the validator at the given index, returns `false` if the validator was already
+	/// disabled or the index is out of bounds.
+	fn disable_validator(validator_index: u32) -> bool;
+	/// Get the validators from session.
+	fn validators() -> Vec<AccountId>;
+	/// Prune historical session tries up to but not including the given index.
+	fn prune_historical_up_to(up_to: SessionIndex);
+}
+
+impl<T: Config> SessionInterface<<T as frame_system::Config>::AccountId> for T
+where
+	T: pallet_session::Config<ValidatorId = <T as frame_system::Config>::AccountId>,
+	T: pallet_session::historical::Config<
+		FullIdentification = Exposure<<T as frame_system::Config>::AccountId, BalanceOf<T>>,
+		FullIdentificationOf = ExposureOf<T>,
+	>,
+	T::SessionHandler: pallet_session::SessionHandler<<T as frame_system::Config>::AccountId>,
+	T::SessionManager: pallet_session::SessionManager<<T as frame_system::Config>::AccountId>,
+	T::ValidatorIdOf: Convert<
+		<T as frame_system::Config>::AccountId,
+		Option<<T as frame_system::Config>::AccountId>,
+	>,
+{
+	fn disable_validator(validator_index: u32) -> bool {
+		<pallet_session::Pallet<T>>::disable_index(validator_index)
+	}
+
+	fn validators() -> Vec<<T as frame_system::Config>::AccountId> {
+		<pallet_session::Pallet<T>>::validators()
+	}
+
+	fn prune_historical_up_to(up_to: SessionIndex) {
+		<pallet_session::historical::Pallet<T>>::prune_up_to(up_to);
+	}
+}
+
+impl<AccountId> SessionInterface<AccountId> for () {
+	fn disable_validator(_: u32) -> bool {
+		true
+	}
+	fn validators() -> Vec<AccountId> {
+		Vec::new()
+	}
+	fn prune_historical_up_to(_: SessionIndex) {
+		()
+	}
+}
+
+/// Handler for determining how much of a balance should be paid out on the current era.
+pub trait EraPayout<Balance> {
+	/// Determine the payout for this era.
+	///
+	/// Returns the amount to be paid to stakers in this era, as well as whatever else should be
+	/// paid out ("the rest").
+	fn era_payout(
+		total_staked: Balance,
+		total_issuance: Balance,
+		era_duration_millis: u64,
+	) -> (Balance, Balance);
+}
+
+impl<Balance: Default> EraPayout<Balance> for () {
+	fn era_payout(
+		_total_staked: Balance,
+		_total_issuance: Balance,
+		_era_duration_millis: u64,
+	) -> (Balance, Balance) {
+		(Default::default(), Default::default())
+	}
+}
+
+/// Adaptor to turn a `PiecewiseLinear` curve definition into an `EraPayout` impl, used for
+/// backwards compatibility.
+pub struct ConvertCurve<T>(sp_std::marker::PhantomData<T>);
+impl<Balance: AtLeast32BitUnsigned + Clone, T: Get<&'static PiecewiseLinear<'static>>>
+	EraPayout<Balance> for ConvertCurve<T>
+{
+	fn era_payout(
+		total_staked: Balance,
+		total_issuance: Balance,
+		era_duration_millis: u64,
+	) -> (Balance, Balance) {
+		let (validator_payout, max_payout) = inflation::compute_total_payout(
+			T::get(),
+			total_staked,
+			total_issuance,
+			// Duration of era; more than u64::MAX is rewarded as u64::MAX.
+			era_duration_millis,
+		);
+		let rest = max_payout.saturating_sub(validator_payout.clone());
+		(validator_payout, rest)
+	}
+}
+
+/// Mode of era-forcing.
+#[derive(
+	Copy,
+	Clone,
+	PartialEq,
+	Eq,
+	Encode,
+	Decode,
+	RuntimeDebug,
+	TypeInfo,
+	MaxEncodedLen,
+	serde::Serialize,
+	serde::Deserialize,
+)]
+pub enum Forcing {
+	/// Not forcing anything - just let whatever happen.
+	NotForcing,
+	/// Force a new era, then reset to `NotForcing` as soon as it is done.
+	/// Note that this will force to trigger an election until a new era is triggered, if the
+	/// election failed, the next session end will trigger a new election again, until success.
+	ForceNew,
+	/// Avoid a new era indefinitely.
+	ForceNone,
+	/// Force a new era at the end of all sessions indefinitely.
+	ForceAlways,
+}
+
+impl Default for Forcing {
+	fn default() -> Self {
+		Forcing::NotForcing
+	}
+}
+
+/// A `Convert` implementation that finds the stash of the given controller account,
+/// if any.
+pub struct StashOf<T>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config> Convert<T::AccountId, Option<T::AccountId>> for StashOf<T> {
+	fn convert(controller: T::AccountId) -> Option<T::AccountId> {
+		<Pallet<T>>::ledger(&controller).map(|l| l.stash)
+	}
+}
+
+/// A typed conversion from stash account ID to the active exposure of nominators
+/// on that account.
+///
+/// Active exposure is the exposure of the validator set currently validating, i.e. in
+/// `active_era`. It can differ from the latest planned exposure in `current_era`.
+pub struct ExposureOf<T>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config> Convert<T::AccountId, Option<Exposure<T::AccountId, BalanceOf<T>>>>
+	for ExposureOf<T>
+{
+	fn convert(validator: T::AccountId) -> Option<Exposure<T::AccountId, BalanceOf<T>>> {
+		<Pallet<T>>::active_era()
+			.map(|active_era| <Pallet<T>>::eras_stakers(active_era.index, &validator))
+	}
+}
+
+/// Filter historical offences out and only allow those from the bonding period.
+pub struct FilterHistoricalOffences<T, R> {
+	_inner: sp_std::marker::PhantomData<(T, R)>,
+}
+
+impl<T, Reporter, Offender, R, O> ReportOffence<Reporter, Offender, O>
+	for FilterHistoricalOffences<Pallet<T>, R>
+where
+	T: Config,
+	R: ReportOffence<Reporter, Offender, O>,
+	O: Offence<Offender>,
+{
+	fn report_offence(reporters: Vec<Reporter>, offence: O) -> Result<(), OffenceError> {
+		// Disallow any slashing from before the current bonding period.
+		let offence_session = offence.session_index();
+		let bonded_eras = BondedEras::<T>::get();
+
+		if bonded_eras.first().filter(|(_, start)| offence_session >= *start).is_some() {
+			R::report_offence(reporters, offence)
+		} else {
+			<Pallet<T>>::deposit_event(Event::<T>::OldSlashingReportDiscarded {
+				session_index: offence_session,
+			});
+			Ok(())
+		}
+	}
+
+	fn is_known_offence(offenders: &[Offender], time_slot: &O::TimeSlot) -> bool {
+		R::is_known_offence(offenders, time_slot)
+	}
+}
+
+/// Configurations of the benchmarking of the pallet.
+pub trait BenchmarkingConfig {
+	/// The maximum number of validators to use.
+	type MaxValidators: Get<u32>;
+	/// The maximum number of nominators to use.
+	type MaxNominators: Get<u32>;
+}
+
+/// A mock benchmarking config for pallet-staking.
+///
+/// Should only be used for testing.
+#[cfg(feature = "std")]
+pub struct TestBenchmarkingConfig;
+
+#[cfg(feature = "std")]
+impl BenchmarkingConfig for TestBenchmarkingConfig {
+	type MaxValidators = frame_support::traits::ConstU32<100>;
+	type MaxNominators = frame_support::traits::ConstU32<100>;
+}
diff --git a/substrate/frame/staking/src/migrations.rs b/substrate/frame/staking/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..332da506f01ed6ebb2bfcf9b449cd243b83ceba6
--- /dev/null
+++ b/substrate/frame/staking/src/migrations.rs
@@ -0,0 +1,509 @@
+// 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
+
+//! Storage migrations for the Staking pallet.
+
+use super::*;
+use frame_election_provider_support::SortedListProvider;
+use frame_support::{
+	dispatch::GetStorageVersion, pallet_prelude::ValueQuery, storage_alias,
+	traits::OnRuntimeUpgrade,
+};
+
+#[cfg(feature = "try-runtime")]
+use frame_support::ensure;
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// Used for release versioning upto v12.
+///
+/// Obsolete from v13. Keeping around to make encoding/decoding of old migration code easier.
+#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+enum ObsoleteReleases {
+	V1_0_0Ancient,
+	V2_0_0,
+	V3_0_0,
+	V4_0_0,
+	V5_0_0,  // blockable validators.
+	V6_0_0,  // removal of all storage associated with offchain phragmen.
+	V7_0_0,  // keep track of number of nominators / validators in map
+	V8_0_0,  // populate `VoterList`.
+	V9_0_0,  // inject validators into `VoterList` as well.
+	V10_0_0, // remove `EarliestUnappliedSlash`.
+	V11_0_0, // Move pallet storage prefix, e.g. BagsList -> VoterBagsList
+	V12_0_0, // remove `HistoryDepth`.
+}
+
+impl Default for ObsoleteReleases {
+	fn default() -> Self {
+		ObsoleteReleases::V12_0_0
+	}
+}
+
+/// Alias to the old storage item used for release versioning. Obsolete since v13.
+#[storage_alias]
+type StorageVersion<T: Config> = StorageValue<Pallet<T>, ObsoleteReleases, ValueQuery>;
+
+pub mod v13 {
+	use super::*;
+
+	pub struct MigrateToV13<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV13<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			frame_support::ensure!(
+				StorageVersion::<T>::get() == ObsoleteReleases::V12_0_0,
+				"Required v12 before upgrading to v13"
+			);
+
+			Ok(Default::default())
+		}
+
+		fn on_runtime_upgrade() -> Weight {
+			let current = Pallet::<T>::current_storage_version();
+			let onchain = StorageVersion::<T>::get();
+
+			if current == 13 && onchain == ObsoleteReleases::V12_0_0 {
+				StorageVersion::<T>::kill();
+				current.put::<Pallet<T>>();
+
+				log!(info, "v13 applied successfully");
+				T::DbWeight::get().reads_writes(1, 2)
+			} else {
+				log!(warn, "Skipping v13, should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			frame_support::ensure!(
+				Pallet::<T>::on_chain_storage_version() == 13,
+				"v13 not applied"
+			);
+
+			frame_support::ensure!(
+				!StorageVersion::<T>::exists(),
+				"Storage version not migrated correctly"
+			);
+
+			Ok(())
+		}
+	}
+}
+
+pub mod v12 {
+	use super::*;
+	use frame_support::{pallet_prelude::ValueQuery, storage_alias};
+
+	#[storage_alias]
+	type HistoryDepth<T: Config> = StorageValue<Pallet<T>, u32, ValueQuery>;
+
+	/// Clean up `HistoryDepth` from storage.
+	///
+	/// We will be depending on the configurable value of `HistoryDepth` post
+	/// this release.
+	pub struct MigrateToV12<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV12<T> {
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			frame_support::ensure!(
+				StorageVersion::<T>::get() == ObsoleteReleases::V11_0_0,
+				"Expected v11 before upgrading to v12"
+			);
+
+			if HistoryDepth::<T>::exists() {
+				frame_support::ensure!(
+					T::HistoryDepth::get() == HistoryDepth::<T>::get(),
+					"Provided value of HistoryDepth should be same as the existing storage value"
+				);
+			} else {
+				log::info!("No HistoryDepth in storage; nothing to remove");
+			}
+
+			Ok(Default::default())
+		}
+
+		fn on_runtime_upgrade() -> frame_support::weights::Weight {
+			if StorageVersion::<T>::get() == ObsoleteReleases::V11_0_0 {
+				HistoryDepth::<T>::kill();
+				StorageVersion::<T>::put(ObsoleteReleases::V12_0_0);
+
+				log!(info, "v12 applied successfully");
+				T::DbWeight::get().reads_writes(1, 2)
+			} else {
+				log!(warn, "Skipping v12, should be removed");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			frame_support::ensure!(
+				StorageVersion::<T>::get() == ObsoleteReleases::V12_0_0,
+				"v12 not applied"
+			);
+			Ok(())
+		}
+	}
+}
+
+pub mod v11 {
+	use super::*;
+	use frame_support::{
+		storage::migration::move_pallet,
+		traits::{GetStorageVersion, PalletInfoAccess},
+	};
+	#[cfg(feature = "try-runtime")]
+	use sp_io::hashing::twox_128;
+
+	pub struct MigrateToV11<T, P, N>(sp_std::marker::PhantomData<(T, P, N)>);
+	impl<T: Config, P: GetStorageVersion + PalletInfoAccess, N: Get<&'static str>> OnRuntimeUpgrade
+		for MigrateToV11<T, P, N>
+	{
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			frame_support::ensure!(
+				StorageVersion::<T>::get() == ObsoleteReleases::V10_0_0,
+				"must upgrade linearly"
+			);
+			let old_pallet_prefix = twox_128(N::get().as_bytes());
+
+			frame_support::ensure!(
+				sp_io::storage::next_key(&old_pallet_prefix).is_some(),
+				"no data for the old pallet name has been detected"
+			);
+
+			Ok(Default::default())
+		}
+
+		/// Migrate the entire storage of this pallet to a new prefix.
+		///
+		/// This new prefix must be the same as the one set in construct_runtime. For safety, use
+		/// `PalletInfo` to get it, as:
+		/// `<Runtime as frame_system::Config>::PalletInfo::name::<VoterBagsList>`.
+		///
+		/// The migration will look into the storage version in order to avoid triggering a
+		/// migration on an up to date storage.
+		fn on_runtime_upgrade() -> Weight {
+			let old_pallet_name = N::get();
+			let new_pallet_name = <P as PalletInfoAccess>::name();
+
+			if StorageVersion::<T>::get() == ObsoleteReleases::V10_0_0 {
+				// bump version anyway, even if we don't need to move the prefix
+				StorageVersion::<T>::put(ObsoleteReleases::V11_0_0);
+				if new_pallet_name == old_pallet_name {
+					log!(
+						warn,
+						"new bags-list name is equal to the old one, only bumping the version"
+					);
+					return T::DbWeight::get().reads(1).saturating_add(T::DbWeight::get().writes(1))
+				}
+
+				move_pallet(old_pallet_name.as_bytes(), new_pallet_name.as_bytes());
+				<T as frame_system::Config>::BlockWeights::get().max_block
+			} else {
+				log!(warn, "v11::migrate should be removed.");
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+			frame_support::ensure!(
+				StorageVersion::<T>::get() == ObsoleteReleases::V11_0_0,
+				"wrong version after the upgrade"
+			);
+
+			let old_pallet_name = N::get();
+			let new_pallet_name = <P as PalletInfoAccess>::name();
+
+			// skip storage prefix checks for the same pallet names
+			if new_pallet_name == old_pallet_name {
+				return Ok(())
+			}
+
+			let old_pallet_prefix = twox_128(N::get().as_bytes());
+			frame_support::ensure!(
+				sp_io::storage::next_key(&old_pallet_prefix).is_none(),
+				"old pallet data hasn't been removed"
+			);
+
+			let new_pallet_name = <P as PalletInfoAccess>::name();
+			let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+			frame_support::ensure!(
+				sp_io::storage::next_key(&new_pallet_prefix).is_some(),
+				"new pallet data hasn't been created"
+			);
+
+			Ok(())
+		}
+	}
+}
+
+pub mod v10 {
+	use super::*;
+	use frame_support::storage_alias;
+
+	#[storage_alias]
+	type EarliestUnappliedSlash<T: Config> = StorageValue<Pallet<T>, EraIndex>;
+
+	/// Apply any pending slashes that where queued.
+	///
+	/// That means we might slash someone a bit too early, but we will definitely
+	/// won't forget to slash them. The cap of 512 is somewhat randomly taken to
+	/// prevent us from iterating over an arbitrary large number of keys `on_runtime_upgrade`.
+	pub struct MigrateToV10<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for MigrateToV10<T> {
+		fn on_runtime_upgrade() -> frame_support::weights::Weight {
+			if StorageVersion::<T>::get() == ObsoleteReleases::V9_0_0 {
+				let pending_slashes = UnappliedSlashes::<T>::iter().take(512);
+				for (era, slashes) in pending_slashes {
+					for slash in slashes {
+						// in the old slashing scheme, the slash era was the key at which we read
+						// from `UnappliedSlashes`.
+						log!(warn, "prematurely applying a slash ({:?}) for era {:?}", slash, era);
+						slashing::apply_slash::<T>(slash, era);
+					}
+				}
+
+				EarliestUnappliedSlash::<T>::kill();
+				StorageVersion::<T>::put(ObsoleteReleases::V10_0_0);
+
+				log!(info, "MigrateToV10 executed successfully");
+				T::DbWeight::get().reads_writes(1, 1)
+			} else {
+				log!(warn, "MigrateToV10 should be removed.");
+				T::DbWeight::get().reads(1)
+			}
+		}
+	}
+}
+
+pub mod v9 {
+	use super::*;
+	#[cfg(feature = "try-runtime")]
+	use codec::{Decode, Encode};
+	#[cfg(feature = "try-runtime")]
+	use sp_std::vec::Vec;
+
+	/// Migration implementation that injects all validators into sorted list.
+	///
+	/// This is only useful for chains that started their `VoterList` just based on nominators.
+	pub struct InjectValidatorsIntoVoterList<T>(sp_std::marker::PhantomData<T>);
+	impl<T: Config> OnRuntimeUpgrade for InjectValidatorsIntoVoterList<T> {
+		fn on_runtime_upgrade() -> Weight {
+			if StorageVersion::<T>::get() == ObsoleteReleases::V8_0_0 {
+				let prev_count = T::VoterList::count();
+				let weight_of_cached = Pallet::<T>::weight_of_fn();
+				for (v, _) in Validators::<T>::iter() {
+					let weight = weight_of_cached(&v);
+					let _ = T::VoterList::on_insert(v.clone(), weight).map_err(|err| {
+						log!(warn, "failed to insert {:?} into VoterList: {:?}", v, err)
+					});
+				}
+
+				log!(
+					info,
+					"injected a total of {} new voters, prev count: {} next count: {}, updating to version 9",
+					Validators::<T>::count(),
+					prev_count,
+					T::VoterList::count(),
+				);
+
+				StorageVersion::<T>::put(ObsoleteReleases::V9_0_0);
+				T::BlockWeights::get().max_block
+			} else {
+				log!(
+					warn,
+					"InjectValidatorsIntoVoterList being executed on the wrong storage \
+				version, expected ObsoleteReleases::V8_0_0"
+				);
+				T::DbWeight::get().reads(1)
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+			frame_support::ensure!(
+				StorageVersion::<T>::get() == ObsoleteReleases::V8_0_0,
+				"must upgrade linearly"
+			);
+
+			let prev_count = T::VoterList::count();
+			Ok(prev_count.encode())
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn post_upgrade(prev_count: Vec<u8>) -> Result<(), TryRuntimeError> {
+			let prev_count: u32 = Decode::decode(&mut prev_count.as_slice()).expect(
+				"the state parameter should be something that was generated by pre_upgrade",
+			);
+			let post_count = T::VoterList::count();
+			let validators = Validators::<T>::count();
+			ensure!(
+				post_count == prev_count + validators,
+				"`VoterList` count after the migration must equal to the sum of \
+				previous count and the current number of validators"
+			);
+
+			frame_support::ensure!(
+				StorageVersion::<T>::get() == ObsoleteReleases::V9_0_0,
+				"must upgrade"
+			);
+			Ok(())
+		}
+	}
+}
+
+pub mod v8 {
+	use super::*;
+	use crate::{Config, Nominators, Pallet, Weight};
+	use frame_election_provider_support::SortedListProvider;
+	use frame_support::traits::Get;
+
+	#[cfg(feature = "try-runtime")]
+	pub fn pre_migrate<T: Config>() -> Result<(), &'static str> {
+		frame_support::ensure!(
+			StorageVersion::<T>::get() == ObsoleteReleases::V7_0_0,
+			"must upgrade linearly"
+		);
+
+		crate::log!(info, "👜 staking bags-list migration passes PRE migrate checks ✅",);
+		Ok(())
+	}
+
+	/// Migration to sorted `VoterList`.
+	pub fn migrate<T: Config>() -> Weight {
+		if StorageVersion::<T>::get() == ObsoleteReleases::V7_0_0 {
+			crate::log!(info, "migrating staking to ObsoleteReleases::V8_0_0");
+
+			let migrated = T::VoterList::unsafe_regenerate(
+				Nominators::<T>::iter().map(|(id, _)| id),
+				Pallet::<T>::weight_of_fn(),
+			);
+
+			StorageVersion::<T>::put(ObsoleteReleases::V8_0_0);
+			crate::log!(
+				info,
+				"👜 completed staking migration to ObsoleteReleases::V8_0_0 with {} voters migrated",
+				migrated,
+			);
+
+			T::BlockWeights::get().max_block
+		} else {
+			T::DbWeight::get().reads(1)
+		}
+	}
+
+	#[cfg(feature = "try-runtime")]
+	pub fn post_migrate<T: Config>() -> Result<(), &'static str> {
+		T::VoterList::try_state().map_err(|_| "VoterList is not in a sane state.")?;
+		crate::log!(info, "👜 staking bags-list migration passes POST migrate checks ✅",);
+		Ok(())
+	}
+}
+
+pub mod v7 {
+	use super::*;
+	use frame_support::storage_alias;
+
+	#[storage_alias]
+	type CounterForValidators<T: Config> = StorageValue<Pallet<T>, u32>;
+	#[storage_alias]
+	type CounterForNominators<T: Config> = StorageValue<Pallet<T>, u32>;
+
+	pub fn pre_migrate<T: Config>() -> Result<(), &'static str> {
+		assert!(
+			CounterForValidators::<T>::get().unwrap().is_zero(),
+			"CounterForValidators already set."
+		);
+		assert!(
+			CounterForNominators::<T>::get().unwrap().is_zero(),
+			"CounterForNominators already set."
+		);
+		assert!(Validators::<T>::count().is_zero(), "Validators already set.");
+		assert!(Nominators::<T>::count().is_zero(), "Nominators already set.");
+		assert!(StorageVersion::<T>::get() == ObsoleteReleases::V6_0_0);
+		Ok(())
+	}
+
+	pub fn migrate<T: Config>() -> Weight {
+		log!(info, "Migrating staking to ObsoleteReleases::V7_0_0");
+		let validator_count = Validators::<T>::iter().count() as u32;
+		let nominator_count = Nominators::<T>::iter().count() as u32;
+
+		CounterForValidators::<T>::put(validator_count);
+		CounterForNominators::<T>::put(nominator_count);
+
+		StorageVersion::<T>::put(ObsoleteReleases::V7_0_0);
+		log!(info, "Completed staking migration to ObsoleteReleases::V7_0_0");
+
+		T::DbWeight::get().reads_writes(validator_count.saturating_add(nominator_count).into(), 2)
+	}
+}
+
+pub mod v6 {
+	use super::*;
+	use frame_support::{storage_alias, traits::Get, weights::Weight};
+
+	// NOTE: value type doesn't matter, we just set it to () here.
+	#[storage_alias]
+	type SnapshotValidators<T: Config> = StorageValue<Pallet<T>, ()>;
+	#[storage_alias]
+	type SnapshotNominators<T: Config> = StorageValue<Pallet<T>, ()>;
+	#[storage_alias]
+	type QueuedElected<T: Config> = StorageValue<Pallet<T>, ()>;
+	#[storage_alias]
+	type QueuedScore<T: Config> = StorageValue<Pallet<T>, ()>;
+	#[storage_alias]
+	type EraElectionStatus<T: Config> = StorageValue<Pallet<T>, ()>;
+	#[storage_alias]
+	type IsCurrentSessionFinal<T: Config> = StorageValue<Pallet<T>, ()>;
+
+	/// check to execute prior to migration.
+	pub fn pre_migrate<T: Config>() -> Result<(), &'static str> {
+		// these may or may not exist.
+		log!(info, "SnapshotValidators.exits()? {:?}", SnapshotValidators::<T>::exists());
+		log!(info, "SnapshotNominators.exits()? {:?}", SnapshotNominators::<T>::exists());
+		log!(info, "QueuedElected.exits()? {:?}", QueuedElected::<T>::exists());
+		log!(info, "QueuedScore.exits()? {:?}", QueuedScore::<T>::exists());
+		// these must exist.
+		assert!(
+			IsCurrentSessionFinal::<T>::exists(),
+			"IsCurrentSessionFinal storage item not found!"
+		);
+		assert!(EraElectionStatus::<T>::exists(), "EraElectionStatus storage item not found!");
+		Ok(())
+	}
+
+	/// Migrate storage to v6.
+	pub fn migrate<T: Config>() -> Weight {
+		log!(info, "Migrating staking to ObsoleteReleases::V6_0_0");
+
+		SnapshotValidators::<T>::kill();
+		SnapshotNominators::<T>::kill();
+		QueuedElected::<T>::kill();
+		QueuedScore::<T>::kill();
+		EraElectionStatus::<T>::kill();
+		IsCurrentSessionFinal::<T>::kill();
+
+		StorageVersion::<T>::put(ObsoleteReleases::V6_0_0);
+
+		log!(info, "Done.");
+		T::DbWeight::get().writes(6 + 1)
+	}
+}
diff --git a/substrate/frame/staking/src/mock.rs b/substrate/frame/staking/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cf08f8be1f27dec6a2d29d9343360f0a6675a2ea
--- /dev/null
+++ b/substrate/frame/staking/src/mock.rs
@@ -0,0 +1,829 @@
+// 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.
+
+//! Test utilities
+
+use crate::{self as pallet_staking, *};
+use frame_election_provider_support::{
+	bounds::{ElectionBounds, ElectionBoundsBuilder},
+	onchain, SequentialPhragmen, VoteWeight,
+};
+use frame_support::{
+	assert_ok, ord_parameter_types, parameter_types,
+	traits::{
+		ConstU32, ConstU64, Currency, EitherOfDiverse, FindAuthor, Get, Hooks, Imbalance,
+		OnUnbalanced, OneSessionHandler,
+	},
+	weights::constants::RocksDbWeight,
+};
+use frame_system::{EnsureRoot, EnsureSignedBy};
+use sp_core::H256;
+use sp_io;
+use sp_runtime::{
+	curve::PiecewiseLinear,
+	testing::UintAuthorityId,
+	traits::{IdentityLookup, Zero},
+	BuildStorage,
+};
+use sp_staking::offence::{DisableStrategy, OffenceDetails, OnOffenceHandler};
+
+pub const INIT_TIMESTAMP: u64 = 30_000;
+pub const BLOCK_TIME: u64 = 1000;
+
+/// The AccountId alias in this test module.
+pub(crate) type AccountId = u64;
+pub(crate) type Nonce = u64;
+pub(crate) type BlockNumber = u64;
+pub(crate) type Balance = u128;
+
+/// Another session handler struct to test on_disabled.
+pub struct OtherSessionHandler;
+impl OneSessionHandler<AccountId> for OtherSessionHandler {
+	type Key = UintAuthorityId;
+
+	fn on_genesis_session<'a, I: 'a>(_: I)
+	where
+		I: Iterator<Item = (&'a AccountId, Self::Key)>,
+		AccountId: 'a,
+	{
+	}
+
+	fn on_new_session<'a, I: 'a>(_: bool, _: I, _: I)
+	where
+		I: Iterator<Item = (&'a AccountId, Self::Key)>,
+		AccountId: 'a,
+	{
+	}
+
+	fn on_disabled(_validator_index: u32) {}
+}
+
+impl sp_runtime::BoundToRuntimeAppPublic for OtherSessionHandler {
+	type Public = UintAuthorityId;
+}
+
+pub fn is_disabled(controller: AccountId) -> bool {
+	let stash = Staking::ledger(&controller).unwrap().stash;
+	let validator_index = match Session::validators().iter().position(|v| *v == stash) {
+		Some(index) => index as u32,
+		None => return false,
+	};
+
+	Session::disabled_validators().contains(&validator_index)
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Authorship: pallet_authorship,
+		Timestamp: pallet_timestamp,
+		Balances: pallet_balances,
+		Staking: pallet_staking,
+		Session: pallet_session,
+		Historical: pallet_session::historical,
+		VoterBagsList: pallet_bags_list::<Instance1>,
+	}
+);
+
+/// Author of block is always 11
+pub struct Author11;
+impl FindAuthor<AccountId> for Author11 {
+	fn find_author<'a, I>(_digests: I) -> Option<AccountId>
+	where
+		I: 'a + IntoIterator<Item = (frame_support::ConsensusEngineId, &'a [u8])>,
+	{
+		Some(11)
+	}
+}
+
+parameter_types! {
+	pub static SessionsPerEra: SessionIndex = 3;
+	pub static ExistentialDeposit: Balance = 1;
+	pub static SlashDeferDuration: EraIndex = 0;
+	pub static Period: BlockNumber = 5;
+	pub static Offset: BlockNumber = 0;
+}
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = RocksDbWeight;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = Nonce;
+	type RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Hashing = ::sp_runtime::traits::BlakeTwo256;
+	type AccountId = AccountId;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU64<250>;
+	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_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 MaxHolds = ();
+}
+
+sp_runtime::impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub other: OtherSessionHandler,
+	}
+}
+impl pallet_session::Config for Test {
+	type SessionManager = pallet_session::historical::NoteHistoricalRoot<Test, Staking>;
+	type Keys = SessionKeys;
+	type ShouldEndSession = pallet_session::PeriodicSessions<Period, Offset>;
+	type SessionHandler = (OtherSessionHandler,);
+	type RuntimeEvent = RuntimeEvent;
+	type ValidatorId = AccountId;
+	type ValidatorIdOf = crate::StashOf<Test>;
+	type NextSessionRotation = pallet_session::PeriodicSessions<Period, Offset>;
+	type WeightInfo = ();
+}
+
+impl pallet_session::historical::Config for Test {
+	type FullIdentification = crate::Exposure<AccountId, Balance>;
+	type FullIdentificationOf = crate::ExposureOf<Test>;
+}
+impl pallet_authorship::Config for Test {
+	type FindAuthor = Author11;
+	type EventHandler = Pallet<Test>;
+}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+pallet_staking_reward_curve::build! {
+	const I_NPOS: 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 BondingDuration: EraIndex = 3;
+	pub const RewardCurve: &'static PiecewiseLinear<'static> = &I_NPOS;
+	pub const OffendingValidatorsThreshold: Perbill = Perbill::from_percent(75);
+}
+
+parameter_types! {
+	pub static RewardRemainderUnbalanced: u128 = 0;
+}
+
+pub struct RewardRemainderMock;
+
+impl OnUnbalanced<NegativeImbalanceOf<Test>> for RewardRemainderMock {
+	fn on_nonzero_unbalanced(amount: NegativeImbalanceOf<Test>) {
+		RewardRemainderUnbalanced::mutate(|v| {
+			*v += amount.peek();
+		});
+		drop(amount);
+	}
+}
+
+const THRESHOLDS: [sp_npos_elections::VoteWeight; 9] =
+	[10, 20, 30, 40, 50, 60, 1_000, 2_000, 10_000];
+
+parameter_types! {
+	pub static BagThresholds: &'static [sp_npos_elections::VoteWeight] = &THRESHOLDS;
+	pub static HistoryDepth: u32 = 80;
+	pub static MaxUnlockingChunks: u32 = 32;
+	pub static RewardOnUnbalanceWasCalled: bool = false;
+	pub static MaxWinners: u32 = 100;
+	pub static ElectionsBounds: ElectionBounds = ElectionBoundsBuilder::default().build();
+	pub static AbsoluteMaxNominations: u32 = 16;
+}
+
+type VoterBagsListInstance = pallet_bags_list::Instance1;
+impl pallet_bags_list::Config<VoterBagsListInstance> for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+	// Staking is the source of truth for voter bags list, since they are not kept up to date.
+	type ScoreProvider = Staking;
+	type BagThresholds = BagThresholds;
+	type Score = VoteWeight;
+}
+
+pub struct OnChainSeqPhragmen;
+impl onchain::Config for OnChainSeqPhragmen {
+	type System = Test;
+	type Solver = SequentialPhragmen<AccountId, Perbill>;
+	type DataProvider = Staking;
+	type WeightInfo = ();
+	type MaxWinners = MaxWinners;
+	type Bounds = ElectionsBounds;
+}
+
+pub struct MockReward {}
+impl OnUnbalanced<PositiveImbalanceOf<Test>> for MockReward {
+	fn on_unbalanced(_: PositiveImbalanceOf<Test>) {
+		RewardOnUnbalanceWasCalled::set(true);
+	}
+}
+
+parameter_types! {
+	pub static LedgerSlashPerEra:
+		(BalanceOf<Test>, BTreeMap<EraIndex, BalanceOf<Test>>) =
+		(Zero::zero(), BTreeMap::new());
+}
+
+pub struct EventListenerMock;
+impl OnStakingUpdate<AccountId, Balance> for EventListenerMock {
+	fn on_slash(
+		_pool_account: &AccountId,
+		slashed_bonded: Balance,
+		slashed_chunks: &BTreeMap<EraIndex, Balance>,
+	) {
+		LedgerSlashPerEra::set((slashed_bonded, slashed_chunks.clone()));
+	}
+}
+
+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;
+	type MaxNominatorRewardedPerValidator = ConstU32<64>;
+	type OffendingValidatorsThreshold = OffendingValidatorsThreshold;
+	type ElectionProvider = onchain::OnChainExecution<OnChainSeqPhragmen>;
+	type GenesisElectionProvider = Self::ElectionProvider;
+	// NOTE: consider a macro and use `UseNominatorsAndValidatorsMap<Self>` as well.
+	type VoterList = VoterBagsList;
+	type TargetList = UseValidatorsMap<Self>;
+	type NominationsQuota = WeightedNominationsQuota<16>;
+	type MaxUnlockingChunks = MaxUnlockingChunks;
+	type HistoryDepth = HistoryDepth;
+	type EventListeners = EventListenerMock;
+	type BenchmarkingConfig = TestBenchmarkingConfig;
+	type WeightInfo = ();
+}
+
+pub struct WeightedNominationsQuota<const MAX: u32>;
+impl<Balance, const MAX: u32> NominationsQuota<Balance> for WeightedNominationsQuota<MAX>
+where
+	u128: From<Balance>,
+{
+	type MaxNominations = AbsoluteMaxNominations;
+
+	fn curve(balance: Balance) -> u32 {
+		match balance.into() {
+			// random curve for testing.
+			0..=110 => MAX,
+			111 => 0,
+			222 => 2,
+			333 => MAX + 10,
+			_ => MAX,
+		}
+	}
+}
+
+pub(crate) type StakingCall = crate::Call<Test>;
+pub(crate) type TestCall = <Test as frame_system::Config>::RuntimeCall;
+
+pub struct ExtBuilder {
+	nominate: bool,
+	validator_count: u32,
+	minimum_validator_count: u32,
+	invulnerables: Vec<AccountId>,
+	has_stakers: bool,
+	initialize_first_session: bool,
+	pub min_nominator_bond: Balance,
+	min_validator_bond: Balance,
+	balance_factor: Balance,
+	status: BTreeMap<AccountId, StakerStatus<AccountId>>,
+	stakes: BTreeMap<AccountId, Balance>,
+	stakers: Vec<(AccountId, AccountId, Balance, StakerStatus<AccountId>)>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			nominate: true,
+			validator_count: 2,
+			minimum_validator_count: 0,
+			balance_factor: 1,
+			invulnerables: vec![],
+			has_stakers: true,
+			initialize_first_session: true,
+			min_nominator_bond: ExistentialDeposit::get(),
+			min_validator_bond: ExistentialDeposit::get(),
+			status: Default::default(),
+			stakes: Default::default(),
+			stakers: Default::default(),
+		}
+	}
+}
+
+impl ExtBuilder {
+	pub fn existential_deposit(self, existential_deposit: Balance) -> Self {
+		EXISTENTIAL_DEPOSIT.with(|v| *v.borrow_mut() = existential_deposit);
+		self
+	}
+	pub fn nominate(mut self, nominate: bool) -> Self {
+		self.nominate = nominate;
+		self
+	}
+	pub fn validator_count(mut self, count: u32) -> Self {
+		self.validator_count = count;
+		self
+	}
+	pub fn minimum_validator_count(mut self, count: u32) -> Self {
+		self.minimum_validator_count = count;
+		self
+	}
+	pub fn slash_defer_duration(self, eras: EraIndex) -> Self {
+		SLASH_DEFER_DURATION.with(|v| *v.borrow_mut() = eras);
+		self
+	}
+	pub fn invulnerables(mut self, invulnerables: Vec<AccountId>) -> Self {
+		self.invulnerables = invulnerables;
+		self
+	}
+	pub fn session_per_era(self, length: SessionIndex) -> Self {
+		SESSIONS_PER_ERA.with(|v| *v.borrow_mut() = length);
+		self
+	}
+	pub fn period(self, length: BlockNumber) -> Self {
+		PERIOD.with(|v| *v.borrow_mut() = length);
+		self
+	}
+	pub fn has_stakers(mut self, has: bool) -> Self {
+		self.has_stakers = has;
+		self
+	}
+	pub fn initialize_first_session(mut self, init: bool) -> Self {
+		self.initialize_first_session = init;
+		self
+	}
+	pub fn offset(self, offset: BlockNumber) -> Self {
+		OFFSET.with(|v| *v.borrow_mut() = offset);
+		self
+	}
+	pub fn min_nominator_bond(mut self, amount: Balance) -> Self {
+		self.min_nominator_bond = amount;
+		self
+	}
+	pub fn min_validator_bond(mut self, amount: Balance) -> Self {
+		self.min_validator_bond = amount;
+		self
+	}
+	pub fn set_status(mut self, who: AccountId, status: StakerStatus<AccountId>) -> Self {
+		self.status.insert(who, status);
+		self
+	}
+	pub fn set_stake(mut self, who: AccountId, stake: Balance) -> Self {
+		self.stakes.insert(who, stake);
+		self
+	}
+	pub fn add_staker(
+		mut self,
+		stash: AccountId,
+		ctrl: AccountId,
+		stake: Balance,
+		status: StakerStatus<AccountId>,
+	) -> Self {
+		self.stakers.push((stash, ctrl, stake, status));
+		self
+	}
+	pub fn balance_factor(mut self, factor: Balance) -> Self {
+		self.balance_factor = factor;
+		self
+	}
+	fn build(self) -> sp_io::TestExternalities {
+		sp_tracing::try_init_simple();
+		let mut storage = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+		let _ = pallet_balances::GenesisConfig::<Test> {
+			balances: vec![
+				(1, 10 * self.balance_factor),
+				(2, 20 * self.balance_factor),
+				(3, 300 * self.balance_factor),
+				(4, 400 * self.balance_factor),
+				// controllers (still used in some tests. Soon to be deprecated).
+				(10, self.balance_factor),
+				(20, self.balance_factor),
+				(30, self.balance_factor),
+				(40, self.balance_factor),
+				(50, self.balance_factor),
+				// stashes
+				(11, self.balance_factor * 1000),
+				(21, self.balance_factor * 2000),
+				(31, self.balance_factor * 2000),
+				(41, self.balance_factor * 2000),
+				(51, self.balance_factor * 2000),
+				// optional nominator
+				(100, self.balance_factor * 2000),
+				(101, self.balance_factor * 2000),
+				// aux accounts
+				(60, self.balance_factor),
+				(61, self.balance_factor * 2000),
+				(70, self.balance_factor),
+				(71, self.balance_factor * 2000),
+				(80, self.balance_factor),
+				(81, self.balance_factor * 2000),
+				// This allows us to have a total_payout different from 0.
+				(999, 1_000_000_000_000),
+			],
+		}
+		.assimilate_storage(&mut storage);
+
+		let mut stakers = vec![];
+		if self.has_stakers {
+			stakers = vec![
+				// (stash, ctrl, stake, status)
+				// these two will be elected in the default test where we elect 2.
+				(11, 11, self.balance_factor * 1000, StakerStatus::<AccountId>::Validator),
+				(21, 21, self.balance_factor * 1000, StakerStatus::<AccountId>::Validator),
+				// a loser validator
+				(31, 31, self.balance_factor * 500, StakerStatus::<AccountId>::Validator),
+				// an idle validator
+				(41, 41, self.balance_factor * 1000, StakerStatus::<AccountId>::Idle),
+			];
+			// optionally add a nominator
+			if self.nominate {
+				stakers.push((
+					101,
+					101,
+					self.balance_factor * 500,
+					StakerStatus::<AccountId>::Nominator(vec![11, 21]),
+				))
+			}
+			// replace any of the status if needed.
+			self.status.into_iter().for_each(|(stash, status)| {
+				let (_, _, _, ref mut prev_status) = stakers
+					.iter_mut()
+					.find(|s| s.0 == stash)
+					.expect("set_status staker should exist; qed");
+				*prev_status = status;
+			});
+			// replaced any of the stakes if needed.
+			self.stakes.into_iter().for_each(|(stash, stake)| {
+				let (_, _, ref mut prev_stake, _) = stakers
+					.iter_mut()
+					.find(|s| s.0 == stash)
+					.expect("set_stake staker should exits; qed.");
+				*prev_stake = stake;
+			});
+			// extend stakers if needed.
+			stakers.extend(self.stakers)
+		}
+
+		let _ = pallet_staking::GenesisConfig::<Test> {
+			stakers: stakers.clone(),
+			validator_count: self.validator_count,
+			minimum_validator_count: self.minimum_validator_count,
+			invulnerables: self.invulnerables,
+			slash_reward_fraction: Perbill::from_percent(10),
+			min_nominator_bond: self.min_nominator_bond,
+			min_validator_bond: self.min_validator_bond,
+			..Default::default()
+		}
+		.assimilate_storage(&mut storage);
+
+		let _ = pallet_session::GenesisConfig::<Test> {
+			keys: if self.has_stakers {
+				// set the keys for the first session.
+				stakers
+					.into_iter()
+					.map(|(id, ..)| (id, id, SessionKeys { other: id.into() }))
+					.collect()
+			} else {
+				// set some dummy validators in genesis.
+				(0..self.validator_count as u64)
+					.map(|id| (id, id, SessionKeys { other: id.into() }))
+					.collect()
+			},
+		}
+		.assimilate_storage(&mut storage);
+
+		let mut ext = sp_io::TestExternalities::from(storage);
+
+		if self.initialize_first_session {
+			// We consider all test to start after timestamp is initialized This must be ensured by
+			// having `timestamp::on_initialize` called before `staking::on_initialize`. Also, if
+			// session length is 1, then it is already triggered.
+			ext.execute_with(|| {
+				System::set_block_number(1);
+				Session::on_initialize(1);
+				<Staking as Hooks<u64>>::on_initialize(1);
+				Timestamp::set_timestamp(INIT_TIMESTAMP);
+			});
+		}
+
+		ext
+	}
+	pub fn build_and_execute(self, test: impl FnOnce() -> ()) {
+		sp_tracing::try_init_simple();
+		let mut ext = self.build();
+		ext.execute_with(test);
+		ext.execute_with(|| {
+			Staking::do_try_state(System::block_number()).unwrap();
+		});
+	}
+}
+
+pub(crate) fn active_era() -> EraIndex {
+	Staking::active_era().unwrap().index
+}
+
+pub(crate) fn current_era() -> EraIndex {
+	Staking::current_era().unwrap()
+}
+
+pub(crate) fn bond(who: AccountId, val: Balance) {
+	let _ = Balances::make_free_balance_be(&who, val);
+	assert_ok!(Staking::bond(RuntimeOrigin::signed(who), val, RewardDestination::Controller));
+}
+
+pub(crate) fn bond_validator(who: AccountId, val: Balance) {
+	bond(who, val);
+	assert_ok!(Staking::validate(RuntimeOrigin::signed(who), ValidatorPrefs::default()));
+	assert_ok!(Session::set_keys(
+		RuntimeOrigin::signed(who),
+		SessionKeys { other: who.into() },
+		vec![]
+	));
+}
+
+pub(crate) fn bond_nominator(who: AccountId, val: Balance, target: Vec<AccountId>) {
+	bond(who, val);
+	assert_ok!(Staking::nominate(RuntimeOrigin::signed(who), target));
+}
+
+/// Progress to the given block, triggering session and era changes as we progress.
+///
+/// This will finalize the previous block, initialize up to the given block, essentially simulating
+/// a block import/propose process where we first initialize the block, then execute some stuff (not
+/// in the function), and then finalize the block.
+pub(crate) fn run_to_block(n: BlockNumber) {
+	Staking::on_finalize(System::block_number());
+	for b in (System::block_number() + 1)..=n {
+		System::set_block_number(b);
+		Session::on_initialize(b);
+		<Staking as Hooks<u64>>::on_initialize(b);
+		Timestamp::set_timestamp(System::block_number() * BLOCK_TIME + INIT_TIMESTAMP);
+		if b != n {
+			Staking::on_finalize(System::block_number());
+		}
+	}
+}
+
+/// Progresses from the current block number (whatever that may be) to the `P * session_index + 1`.
+pub(crate) fn start_session(session_index: SessionIndex) {
+	let end: u64 = if Offset::get().is_zero() {
+		(session_index as u64) * Period::get()
+	} else {
+		Offset::get() + (session_index.saturating_sub(1) as u64) * Period::get()
+	};
+	run_to_block(end);
+	// session must have progressed properly.
+	assert_eq!(
+		Session::current_index(),
+		session_index,
+		"current session index = {}, expected = {}",
+		Session::current_index(),
+		session_index,
+	);
+}
+
+/// Go one session forward.
+pub(crate) fn advance_session() {
+	let current_index = Session::current_index();
+	start_session(current_index + 1);
+}
+
+/// Progress until the given era.
+pub(crate) fn start_active_era(era_index: EraIndex) {
+	start_session((era_index * <SessionsPerEra as Get<u32>>::get()).into());
+	assert_eq!(active_era(), era_index);
+	// One way or another, current_era must have changed before the active era, so they must match
+	// at this point.
+	assert_eq!(current_era(), active_era());
+}
+
+pub(crate) fn current_total_payout_for_duration(duration: u64) -> Balance {
+	let (payout, _rest) = <Test as Config>::EraPayout::era_payout(
+		Staking::eras_total_stake(active_era()),
+		Balances::total_issuance(),
+		duration,
+	);
+	assert!(payout > 0);
+	payout
+}
+
+pub(crate) fn maximum_payout_for_duration(duration: u64) -> Balance {
+	let (payout, rest) = <Test as Config>::EraPayout::era_payout(
+		Staking::eras_total_stake(active_era()),
+		Balances::total_issuance(),
+		duration,
+	);
+	payout + rest
+}
+
+/// Time it takes to finish a session.
+///
+/// Note, if you see `time_per_session() - BLOCK_TIME`, it is fine. This is because we set the
+/// timestamp after on_initialize, so the timestamp is always one block old.
+pub(crate) fn time_per_session() -> u64 {
+	Period::get() * BLOCK_TIME
+}
+
+/// Time it takes to finish an era.
+///
+/// Note, if you see `time_per_era() - BLOCK_TIME`, it is fine. This is because we set the
+/// timestamp after on_initialize, so the timestamp is always one block old.
+pub(crate) fn time_per_era() -> u64 {
+	time_per_session() * SessionsPerEra::get() as u64
+}
+
+/// Time that will be calculated for the reward per era.
+pub(crate) fn reward_time_per_era() -> u64 {
+	time_per_era() - BLOCK_TIME
+}
+
+pub(crate) fn reward_all_elected() {
+	let rewards = <Test as Config>::SessionInterface::validators().into_iter().map(|v| (v, 1));
+
+	<Pallet<Test>>::reward_by_ids(rewards)
+}
+
+pub(crate) fn validator_controllers() -> Vec<AccountId> {
+	Session::validators()
+		.into_iter()
+		.map(|s| Staking::bonded(&s).expect("no controller for validator"))
+		.collect()
+}
+
+pub(crate) fn on_offence_in_era(
+	offenders: &[OffenceDetails<
+		AccountId,
+		pallet_session::historical::IdentificationTuple<Test>,
+	>],
+	slash_fraction: &[Perbill],
+	era: EraIndex,
+	disable_strategy: DisableStrategy,
+) {
+	let bonded_eras = crate::BondedEras::<Test>::get();
+	for &(bonded_era, start_session) in bonded_eras.iter() {
+		if bonded_era == era {
+			let _ = Staking::on_offence(offenders, slash_fraction, start_session, disable_strategy);
+			return
+		} else if bonded_era > era {
+			break
+		}
+	}
+
+	if Staking::active_era().unwrap().index == era {
+		let _ = Staking::on_offence(
+			offenders,
+			slash_fraction,
+			Staking::eras_start_session_index(era).unwrap(),
+			disable_strategy,
+		);
+	} else {
+		panic!("cannot slash in era {}", era);
+	}
+}
+
+pub(crate) fn on_offence_now(
+	offenders: &[OffenceDetails<
+		AccountId,
+		pallet_session::historical::IdentificationTuple<Test>,
+	>],
+	slash_fraction: &[Perbill],
+) {
+	let now = Staking::active_era().unwrap().index;
+	on_offence_in_era(offenders, slash_fraction, now, DisableStrategy::WhenSlashed)
+}
+
+pub(crate) fn add_slash(who: &AccountId) {
+	on_offence_now(
+		&[OffenceDetails {
+			offender: (*who, Staking::eras_stakers(active_era(), *who)),
+			reporters: vec![],
+		}],
+		&[Perbill::from_percent(10)],
+	);
+}
+
+/// Make all validator and nominator request their payment
+pub(crate) fn make_all_reward_payment(era: EraIndex) {
+	let validators_with_reward = ErasRewardPoints::<Test>::get(era)
+		.individual
+		.keys()
+		.cloned()
+		.collect::<Vec<_>>();
+
+	// reward validators
+	for validator_controller in validators_with_reward.iter().filter_map(Staking::bonded) {
+		let ledger = <Ledger<Test>>::get(&validator_controller).unwrap();
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), ledger.stash, era));
+	}
+}
+
+#[macro_export]
+macro_rules! assert_session_era {
+	($session:expr, $era:expr) => {
+		assert_eq!(
+			Session::current_index(),
+			$session,
+			"wrong session {} != {}",
+			Session::current_index(),
+			$session,
+		);
+		assert_eq!(
+			Staking::current_era().unwrap(),
+			$era,
+			"wrong current era {} != {}",
+			Staking::current_era().unwrap(),
+			$era,
+		);
+	};
+}
+
+pub(crate) fn staking_events() -> Vec<crate::Event<Test>> {
+	System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::Staking(inner) = e { Some(inner) } else { None })
+		.collect()
+}
+
+parameter_types! {
+	static StakingEventsIndex: usize = 0;
+}
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+type EnsureOneOrRoot = EitherOfDiverse<EnsureRoot<AccountId>, EnsureSignedBy<One, AccountId>>;
+
+pub(crate) fn staking_events_since_last_call() -> Vec<crate::Event<Test>> {
+	let all: Vec<_> = System::events()
+		.into_iter()
+		.filter_map(|r| if let RuntimeEvent::Staking(inner) = r.event { Some(inner) } else { None })
+		.collect();
+	let seen = StakingEventsIndex::get();
+	StakingEventsIndex::set(all.len());
+	all.into_iter().skip(seen).collect()
+}
+
+pub(crate) fn balances(who: &AccountId) -> (Balance, Balance) {
+	(Balances::free_balance(who), Balances::reserved_balance(who))
+}
diff --git a/substrate/frame/staking/src/pallet/impls.rs b/substrate/frame/staking/src/pallet/impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e0f5c9558781856e97730d93ab38c769242acdd4
--- /dev/null
+++ b/substrate/frame/staking/src/pallet/impls.rs
@@ -0,0 +1,1885 @@
+// 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.
+
+//! Implementations for the Staking FRAME Pallet.
+
+use frame_election_provider_support::{
+	bounds::{CountBound, SizeBound},
+	data_provider, BoundedSupportsOf, DataProviderBounds, ElectionDataProvider, ElectionProvider,
+	ScoreProvider, SortedListProvider, VoteWeight, VoterOf,
+};
+use frame_support::{
+	defensive,
+	dispatch::WithPostDispatchInfo,
+	pallet_prelude::*,
+	traits::{
+		Currency, Defensive, DefensiveResult, EstimateNextNewSession, Get, Imbalance,
+		LockableCurrency, OnUnbalanced, TryCollect, UnixTime, WithdrawReasons,
+	},
+	weights::Weight,
+};
+use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin};
+use pallet_session::historical;
+use sp_runtime::{
+	traits::{Bounded, Convert, One, SaturatedConversion, Saturating, StaticLookup, Zero},
+	Perbill,
+};
+use sp_staking::{
+	currency_to_vote::CurrencyToVote,
+	offence::{DisableStrategy, OffenceDetails, OnOffenceHandler},
+	EraIndex, SessionIndex, Stake, StakingInterface,
+};
+use sp_std::prelude::*;
+
+use crate::{
+	election_size_tracker::StaticTracker, log, slashing, weights::WeightInfo, ActiveEraInfo,
+	BalanceOf, EraPayout, Exposure, ExposureOf, Forcing, IndividualExposure, MaxNominationsOf,
+	MaxWinnersOf, Nominations, NominationsQuota, PositiveImbalanceOf, RewardDestination,
+	SessionInterface, StakingLedger, ValidatorPrefs,
+};
+
+use super::{pallet::*, STAKING_ID};
+
+#[cfg(feature = "try-runtime")]
+use frame_support::ensure;
+#[cfg(any(test, feature = "try-runtime"))]
+use sp_runtime::TryRuntimeError;
+
+/// The maximum number of iterations that we do whilst iterating over `T::VoterList` in
+/// `get_npos_voters`.
+///
+/// In most cases, if we want n items, we iterate exactly n times. In rare cases, if a voter is
+/// invalid (for any reason) the iteration continues. With this constant, we iterate at most 2 * n
+/// times and then give up.
+const NPOS_MAX_ITERATIONS_COEFFICIENT: u32 = 2;
+
+impl<T: Config> Pallet<T> {
+	/// The total balance that can be slashed from a stash account as of right now.
+	pub fn slashable_balance_of(stash: &T::AccountId) -> BalanceOf<T> {
+		// Weight note: consider making the stake accessible through stash.
+		Self::bonded(stash).and_then(Self::ledger).map(|l| l.active).unwrap_or_default()
+	}
+
+	/// Internal impl of [`Self::slashable_balance_of`] that returns [`VoteWeight`].
+	pub fn slashable_balance_of_vote_weight(
+		stash: &T::AccountId,
+		issuance: BalanceOf<T>,
+	) -> VoteWeight {
+		T::CurrencyToVote::to_vote(Self::slashable_balance_of(stash), issuance)
+	}
+
+	/// Returns a closure around `slashable_balance_of_vote_weight` that can be passed around.
+	///
+	/// This prevents call sites from repeatedly requesting `total_issuance` from backend. But it is
+	/// important to be only used while the total issuance is not changing.
+	pub fn weight_of_fn() -> Box<dyn Fn(&T::AccountId) -> VoteWeight> {
+		// NOTE: changing this to unboxed `impl Fn(..)` return type and the pallet will still
+		// compile, while some types in mock fail to resolve.
+		let issuance = T::Currency::total_issuance();
+		Box::new(move |who: &T::AccountId| -> VoteWeight {
+			Self::slashable_balance_of_vote_weight(who, issuance)
+		})
+	}
+
+	/// Same as `weight_of_fn`, but made for one time use.
+	pub fn weight_of(who: &T::AccountId) -> VoteWeight {
+		let issuance = T::Currency::total_issuance();
+		Self::slashable_balance_of_vote_weight(who, issuance)
+	}
+
+	pub(super) fn do_withdraw_unbonded(
+		controller: &T::AccountId,
+		num_slashing_spans: u32,
+	) -> Result<Weight, DispatchError> {
+		let mut ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+		let (stash, old_total) = (ledger.stash.clone(), ledger.total);
+		if let Some(current_era) = Self::current_era() {
+			ledger = ledger.consolidate_unlocked(current_era)
+		}
+
+		let used_weight =
+			if ledger.unlocking.is_empty() && ledger.active < T::Currency::minimum_balance() {
+				// This account must have called `unbond()` with some value that caused the active
+				// portion to fall below existential deposit + will have no more unlocking chunks
+				// left. We can now safely remove all staking-related information.
+				Self::kill_stash(&stash, num_slashing_spans)?;
+				// Remove the lock.
+				T::Currency::remove_lock(STAKING_ID, &stash);
+
+				T::WeightInfo::withdraw_unbonded_kill(num_slashing_spans)
+			} else {
+				// This was the consequence of a partial unbond. just update the ledger and move on.
+				Self::update_ledger(&controller, &ledger);
+
+				// This is only an update, so we use less overall weight.
+				T::WeightInfo::withdraw_unbonded_update(num_slashing_spans)
+			};
+
+		// `old_total` should never be less than the new total because
+		// `consolidate_unlocked` strictly subtracts balance.
+		if ledger.total < old_total {
+			// Already checked that this won't overflow by entry condition.
+			let value = old_total - ledger.total;
+			Self::deposit_event(Event::<T>::Withdrawn { stash, amount: value });
+		}
+
+		Ok(used_weight)
+	}
+
+	pub(super) fn do_payout_stakers(
+		validator_stash: T::AccountId,
+		era: EraIndex,
+	) -> DispatchResultWithPostInfo {
+		// Validate input data
+		let current_era = CurrentEra::<T>::get().ok_or_else(|| {
+			Error::<T>::InvalidEraToReward
+				.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))
+		})?;
+		let history_depth = T::HistoryDepth::get();
+		ensure!(
+			era <= current_era && era >= current_era.saturating_sub(history_depth),
+			Error::<T>::InvalidEraToReward
+				.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))
+		);
+
+		// Note: if era has no reward to be claimed, era may be future. better not to update
+		// `ledger.claimed_rewards` in this case.
+		let era_payout = <ErasValidatorReward<T>>::get(&era).ok_or_else(|| {
+			Error::<T>::InvalidEraToReward
+				.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))
+		})?;
+
+		let controller = Self::bonded(&validator_stash).ok_or_else(|| {
+			Error::<T>::NotStash.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))
+		})?;
+		let mut ledger = <Ledger<T>>::get(&controller).ok_or(Error::<T>::NotController)?;
+
+		ledger
+			.claimed_rewards
+			.retain(|&x| x >= current_era.saturating_sub(history_depth));
+
+		match ledger.claimed_rewards.binary_search(&era) {
+			Ok(_) =>
+				return Err(Error::<T>::AlreadyClaimed
+					.with_weight(T::WeightInfo::payout_stakers_alive_staked(0))),
+			Err(pos) => ledger
+				.claimed_rewards
+				.try_insert(pos, era)
+				// Since we retain era entries in `claimed_rewards` only upto
+				// `HistoryDepth`, following bound is always expected to be
+				// satisfied.
+				.defensive_map_err(|_| Error::<T>::BoundNotMet)?,
+		}
+
+		let exposure = <ErasStakersClipped<T>>::get(&era, &ledger.stash);
+
+		// Input data seems good, no errors allowed after this point
+
+		<Ledger<T>>::insert(&controller, &ledger);
+
+		// Get Era reward points. It has TOTAL and INDIVIDUAL
+		// Find the fraction of the era reward that belongs to the validator
+		// Take that fraction of the eras rewards to split to nominator and validator
+		//
+		// Then look at the validator, figure out the proportion of their reward
+		// which goes to them and each of their nominators.
+
+		let era_reward_points = <ErasRewardPoints<T>>::get(&era);
+		let total_reward_points = era_reward_points.total;
+		let validator_reward_points = era_reward_points
+			.individual
+			.get(&ledger.stash)
+			.copied()
+			.unwrap_or_else(Zero::zero);
+
+		// Nothing to do if they have no reward points.
+		if validator_reward_points.is_zero() {
+			return Ok(Some(T::WeightInfo::payout_stakers_alive_staked(0)).into())
+		}
+
+		// This is the fraction of the total reward that the validator and the
+		// nominators will get.
+		let validator_total_reward_part =
+			Perbill::from_rational(validator_reward_points, total_reward_points);
+
+		// This is how much validator + nominators are entitled to.
+		let validator_total_payout = validator_total_reward_part * era_payout;
+
+		let validator_prefs = Self::eras_validator_prefs(&era, &validator_stash);
+		// Validator first gets a cut off the top.
+		let validator_commission = validator_prefs.commission;
+		let validator_commission_payout = validator_commission * validator_total_payout;
+
+		let validator_leftover_payout = validator_total_payout - validator_commission_payout;
+		// Now let's calculate how this is split to the validator.
+		let validator_exposure_part = Perbill::from_rational(exposure.own, exposure.total);
+		let validator_staking_payout = validator_exposure_part * validator_leftover_payout;
+
+		Self::deposit_event(Event::<T>::PayoutStarted {
+			era_index: era,
+			validator_stash: ledger.stash.clone(),
+		});
+
+		let mut total_imbalance = PositiveImbalanceOf::<T>::zero();
+		// We can now make total validator payout:
+		if let Some(imbalance) =
+			Self::make_payout(&ledger.stash, validator_staking_payout + validator_commission_payout)
+		{
+			Self::deposit_event(Event::<T>::Rewarded {
+				stash: ledger.stash,
+				amount: imbalance.peek(),
+			});
+			total_imbalance.subsume(imbalance);
+		}
+
+		// Track the number of payout ops to nominators. Note:
+		// `WeightInfo::payout_stakers_alive_staked` always assumes at least a validator is paid
+		// out, so we do not need to count their payout op.
+		let mut nominator_payout_count: u32 = 0;
+
+		// Lets now calculate how this is split to the nominators.
+		// Reward only the clipped exposures. Note this is not necessarily sorted.
+		for nominator in exposure.others.iter() {
+			let nominator_exposure_part = Perbill::from_rational(nominator.value, exposure.total);
+
+			let nominator_reward: BalanceOf<T> =
+				nominator_exposure_part * validator_leftover_payout;
+			// We can now make nominator payout:
+			if let Some(imbalance) = Self::make_payout(&nominator.who, nominator_reward) {
+				// Note: this logic does not count payouts for `RewardDestination::None`.
+				nominator_payout_count += 1;
+				let e =
+					Event::<T>::Rewarded { stash: nominator.who.clone(), amount: imbalance.peek() };
+				Self::deposit_event(e);
+				total_imbalance.subsume(imbalance);
+			}
+		}
+
+		T::Reward::on_unbalanced(total_imbalance);
+		debug_assert!(nominator_payout_count <= T::MaxNominatorRewardedPerValidator::get());
+		Ok(Some(T::WeightInfo::payout_stakers_alive_staked(nominator_payout_count)).into())
+	}
+
+	/// Update the ledger for a controller.
+	///
+	/// This will also update the stash lock.
+	pub(crate) fn update_ledger(controller: &T::AccountId, ledger: &StakingLedger<T>) {
+		T::Currency::set_lock(STAKING_ID, &ledger.stash, ledger.total, WithdrawReasons::all());
+		<Ledger<T>>::insert(controller, ledger);
+	}
+
+	/// Chill a stash account.
+	pub(crate) fn chill_stash(stash: &T::AccountId) {
+		let chilled_as_validator = Self::do_remove_validator(stash);
+		let chilled_as_nominator = Self::do_remove_nominator(stash);
+		if chilled_as_validator || chilled_as_nominator {
+			Self::deposit_event(Event::<T>::Chilled { stash: stash.clone() });
+		}
+	}
+
+	/// Actually make a payment to a staker. This uses the currency's reward function
+	/// to pay the right payee for the given staker account.
+	fn make_payout(stash: &T::AccountId, amount: BalanceOf<T>) -> Option<PositiveImbalanceOf<T>> {
+		let dest = Self::payee(stash);
+		match dest {
+			RewardDestination::Controller => Self::bonded(stash)
+				.map(|controller| T::Currency::deposit_creating(&controller, amount)),
+			RewardDestination::Stash => T::Currency::deposit_into_existing(stash, amount).ok(),
+			RewardDestination::Staked => Self::bonded(stash)
+				.and_then(|c| Self::ledger(&c).map(|l| (c, l)))
+				.and_then(|(controller, mut l)| {
+					l.active += amount;
+					l.total += amount;
+					let r = T::Currency::deposit_into_existing(stash, amount).ok();
+					Self::update_ledger(&controller, &l);
+					r
+				}),
+			RewardDestination::Account(dest_account) =>
+				Some(T::Currency::deposit_creating(&dest_account, amount)),
+			RewardDestination::None => None,
+		}
+	}
+
+	/// Plan a new session potentially trigger a new era.
+	fn new_session(
+		session_index: SessionIndex,
+		is_genesis: bool,
+	) -> Option<BoundedVec<T::AccountId, MaxWinnersOf<T>>> {
+		if let Some(current_era) = Self::current_era() {
+			// Initial era has been set.
+			let current_era_start_session_index = Self::eras_start_session_index(current_era)
+				.unwrap_or_else(|| {
+					frame_support::print("Error: start_session_index must be set for current_era");
+					0
+				});
+
+			let era_length = session_index.saturating_sub(current_era_start_session_index); // Must never happen.
+
+			match ForceEra::<T>::get() {
+				// Will be set to `NotForcing` again if a new era has been triggered.
+				Forcing::ForceNew => (),
+				// Short circuit to `try_trigger_new_era`.
+				Forcing::ForceAlways => (),
+				// Only go to `try_trigger_new_era` if deadline reached.
+				Forcing::NotForcing if era_length >= T::SessionsPerEra::get() => (),
+				_ => {
+					// Either `Forcing::ForceNone`,
+					// or `Forcing::NotForcing if era_length >= T::SessionsPerEra::get()`.
+					return None
+				},
+			}
+
+			// New era.
+			let maybe_new_era_validators = Self::try_trigger_new_era(session_index, is_genesis);
+			if maybe_new_era_validators.is_some() &&
+				matches!(ForceEra::<T>::get(), Forcing::ForceNew)
+			{
+				Self::set_force_era(Forcing::NotForcing);
+			}
+
+			maybe_new_era_validators
+		} else {
+			// Set initial era.
+			log!(debug, "Starting the first era.");
+			Self::try_trigger_new_era(session_index, is_genesis)
+		}
+	}
+
+	/// Start a session potentially starting an era.
+	fn start_session(start_session: SessionIndex) {
+		let next_active_era = Self::active_era().map(|e| e.index + 1).unwrap_or(0);
+		// This is only `Some` when current era has already progressed to the next era, while the
+		// active era is one behind (i.e. in the *last session of the active era*, or *first session
+		// of the new current era*, depending on how you look at it).
+		if let Some(next_active_era_start_session_index) =
+			Self::eras_start_session_index(next_active_era)
+		{
+			if next_active_era_start_session_index == start_session {
+				Self::start_era(start_session);
+			} else if next_active_era_start_session_index < start_session {
+				// This arm should never happen, but better handle it than to stall the staking
+				// pallet.
+				frame_support::print("Warning: A session appears to have been skipped.");
+				Self::start_era(start_session);
+			}
+		}
+
+		// disable all offending validators that have been disabled for the whole era
+		for (index, disabled) in <OffendingValidators<T>>::get() {
+			if disabled {
+				T::SessionInterface::disable_validator(index);
+			}
+		}
+	}
+
+	/// End a session potentially ending an era.
+	fn end_session(session_index: SessionIndex) {
+		if let Some(active_era) = Self::active_era() {
+			if let Some(next_active_era_start_session_index) =
+				Self::eras_start_session_index(active_era.index + 1)
+			{
+				if next_active_era_start_session_index == session_index + 1 {
+					Self::end_era(active_era, session_index);
+				}
+			}
+		}
+	}
+
+	/// Start a new era. It does:
+	///
+	/// * Increment `active_era.index`,
+	/// * reset `active_era.start`,
+	/// * update `BondedEras` and apply slashes.
+	fn start_era(start_session: SessionIndex) {
+		let active_era = ActiveEra::<T>::mutate(|active_era| {
+			let new_index = active_era.as_ref().map(|info| info.index + 1).unwrap_or(0);
+			*active_era = Some(ActiveEraInfo {
+				index: new_index,
+				// Set new active era start in next `on_finalize`. To guarantee usage of `Time`
+				start: None,
+			});
+			new_index
+		});
+
+		let bonding_duration = T::BondingDuration::get();
+
+		BondedEras::<T>::mutate(|bonded| {
+			bonded.push((active_era, start_session));
+
+			if active_era > bonding_duration {
+				let first_kept = active_era - bonding_duration;
+
+				// Prune out everything that's from before the first-kept index.
+				let n_to_prune =
+					bonded.iter().take_while(|&&(era_idx, _)| era_idx < first_kept).count();
+
+				// Kill slashing metadata.
+				for (pruned_era, _) in bonded.drain(..n_to_prune) {
+					slashing::clear_era_metadata::<T>(pruned_era);
+				}
+
+				if let Some(&(_, first_session)) = bonded.first() {
+					T::SessionInterface::prune_historical_up_to(first_session);
+				}
+			}
+		});
+
+		Self::apply_unapplied_slashes(active_era);
+	}
+
+	/// Compute payout for era.
+	fn end_era(active_era: ActiveEraInfo, _session_index: SessionIndex) {
+		// Note: active_era_start can be None if end era is called during genesis config.
+		if let Some(active_era_start) = active_era.start {
+			let now_as_millis_u64 = T::UnixTime::now().as_millis().saturated_into::<u64>();
+
+			let era_duration = (now_as_millis_u64 - active_era_start).saturated_into::<u64>();
+			let staked = Self::eras_total_stake(&active_era.index);
+			let issuance = T::Currency::total_issuance();
+			let (validator_payout, remainder) =
+				T::EraPayout::era_payout(staked, issuance, era_duration);
+
+			Self::deposit_event(Event::<T>::EraPaid {
+				era_index: active_era.index,
+				validator_payout,
+				remainder,
+			});
+
+			// Set ending era reward.
+			<ErasValidatorReward<T>>::insert(&active_era.index, validator_payout);
+			T::RewardRemainder::on_unbalanced(T::Currency::issue(remainder));
+
+			// Clear offending validators.
+			<OffendingValidators<T>>::kill();
+		}
+	}
+
+	/// Plan a new era.
+	///
+	/// * Bump the current era storage (which holds the latest planned era).
+	/// * Store start session index for the new planned era.
+	/// * Clean old era information.
+	/// * Store staking information for the new planned era
+	///
+	/// Returns the new validator set.
+	pub fn trigger_new_era(
+		start_session_index: SessionIndex,
+		exposures: BoundedVec<
+			(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>),
+			MaxWinnersOf<T>,
+		>,
+	) -> BoundedVec<T::AccountId, MaxWinnersOf<T>> {
+		// Increment or set current era.
+		let new_planned_era = CurrentEra::<T>::mutate(|s| {
+			*s = Some(s.map(|s| s + 1).unwrap_or(0));
+			s.unwrap()
+		});
+		ErasStartSessionIndex::<T>::insert(&new_planned_era, &start_session_index);
+
+		// Clean old era information.
+		if let Some(old_era) = new_planned_era.checked_sub(T::HistoryDepth::get() + 1) {
+			Self::clear_era_information(old_era);
+		}
+
+		// Set staking information for the new era.
+		Self::store_stakers_info(exposures, new_planned_era)
+	}
+
+	/// Potentially plan a new era.
+	///
+	/// Get election result from `T::ElectionProvider`.
+	/// In case election result has more than [`MinimumValidatorCount`] validator trigger a new era.
+	///
+	/// In case a new era is planned, the new validator set is returned.
+	pub(crate) fn try_trigger_new_era(
+		start_session_index: SessionIndex,
+		is_genesis: bool,
+	) -> Option<BoundedVec<T::AccountId, MaxWinnersOf<T>>> {
+		let election_result: BoundedVec<_, MaxWinnersOf<T>> = if is_genesis {
+			let result = <T::GenesisElectionProvider>::elect().map_err(|e| {
+				log!(warn, "genesis election provider failed due to {:?}", e);
+				Self::deposit_event(Event::StakingElectionFailed);
+			});
+
+			result
+				.ok()?
+				.into_inner()
+				.try_into()
+				// both bounds checked in integrity test to be equal
+				.defensive_unwrap_or_default()
+		} else {
+			let result = <T::ElectionProvider>::elect().map_err(|e| {
+				log!(warn, "election provider failed due to {:?}", e);
+				Self::deposit_event(Event::StakingElectionFailed);
+			});
+			result.ok()?
+		};
+
+		let exposures = Self::collect_exposures(election_result);
+		if (exposures.len() as u32) < Self::minimum_validator_count().max(1) {
+			// Session will panic if we ever return an empty validator set, thus max(1) ^^.
+			match CurrentEra::<T>::get() {
+				Some(current_era) if current_era > 0 => log!(
+					warn,
+					"chain does not have enough staking candidates to operate for era {:?} ({} \
+					elected, minimum is {})",
+					CurrentEra::<T>::get().unwrap_or(0),
+					exposures.len(),
+					Self::minimum_validator_count(),
+				),
+				None => {
+					// The initial era is allowed to have no exposures.
+					// In this case the SessionManager is expected to choose a sensible validator
+					// set.
+					// TODO: this should be simplified #8911
+					CurrentEra::<T>::put(0);
+					ErasStartSessionIndex::<T>::insert(&0, &start_session_index);
+				},
+				_ => (),
+			}
+
+			Self::deposit_event(Event::StakingElectionFailed);
+			return None
+		}
+
+		Self::deposit_event(Event::StakersElected);
+		Some(Self::trigger_new_era(start_session_index, exposures))
+	}
+
+	/// Process the output of the election.
+	///
+	/// Store staking information for the new planned era
+	pub fn store_stakers_info(
+		exposures: BoundedVec<
+			(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>),
+			MaxWinnersOf<T>,
+		>,
+		new_planned_era: EraIndex,
+	) -> BoundedVec<T::AccountId, MaxWinnersOf<T>> {
+		let elected_stashes: BoundedVec<_, MaxWinnersOf<T>> = exposures
+			.iter()
+			.cloned()
+			.map(|(x, _)| x)
+			.collect::<Vec<_>>()
+			.try_into()
+			.expect("since we only map through exposures, size of elected_stashes is always same as exposures; qed");
+
+		// Populate stakers, exposures, and the snapshot of validator prefs.
+		let mut total_stake: BalanceOf<T> = Zero::zero();
+		exposures.into_iter().for_each(|(stash, exposure)| {
+			total_stake = total_stake.saturating_add(exposure.total);
+			<ErasStakers<T>>::insert(new_planned_era, &stash, &exposure);
+
+			let mut exposure_clipped = exposure;
+			let clipped_max_len = T::MaxNominatorRewardedPerValidator::get() as usize;
+			if exposure_clipped.others.len() > clipped_max_len {
+				exposure_clipped.others.sort_by(|a, b| a.value.cmp(&b.value).reverse());
+				exposure_clipped.others.truncate(clipped_max_len);
+			}
+			<ErasStakersClipped<T>>::insert(&new_planned_era, &stash, exposure_clipped);
+		});
+
+		// Insert current era staking information
+		<ErasTotalStake<T>>::insert(&new_planned_era, total_stake);
+
+		// Collect the pref of all winners.
+		for stash in &elected_stashes {
+			let pref = Self::validators(stash);
+			<ErasValidatorPrefs<T>>::insert(&new_planned_era, stash, pref);
+		}
+
+		if new_planned_era > 0 {
+			log!(
+				info,
+				"new validator set of size {:?} has been processed for era {:?}",
+				elected_stashes.len(),
+				new_planned_era,
+			);
+		}
+
+		elected_stashes
+	}
+
+	/// Consume a set of [`BoundedSupports`] from [`sp_npos_elections`] and collect them into a
+	/// [`Exposure`].
+	fn collect_exposures(
+		supports: BoundedSupportsOf<T::ElectionProvider>,
+	) -> BoundedVec<(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>), MaxWinnersOf<T>> {
+		let total_issuance = T::Currency::total_issuance();
+		let to_currency = |e: frame_election_provider_support::ExtendedBalance| {
+			T::CurrencyToVote::to_currency(e, total_issuance)
+		};
+
+		supports
+			.into_iter()
+			.map(|(validator, support)| {
+				// Build `struct exposure` from `support`.
+				let mut others = Vec::with_capacity(support.voters.len());
+				let mut own: BalanceOf<T> = Zero::zero();
+				let mut total: BalanceOf<T> = Zero::zero();
+				support
+					.voters
+					.into_iter()
+					.map(|(nominator, weight)| (nominator, to_currency(weight)))
+					.for_each(|(nominator, stake)| {
+						if nominator == validator {
+							own = own.saturating_add(stake);
+						} else {
+							others.push(IndividualExposure { who: nominator, value: stake });
+						}
+						total = total.saturating_add(stake);
+					});
+
+				let exposure = Exposure { own, others, total };
+				(validator, exposure)
+			})
+			.try_collect()
+			.expect("we only map through support vector which cannot change the size; qed")
+	}
+
+	/// Remove all associated data of a stash account from the staking system.
+	///
+	/// Assumes storage is upgraded before calling.
+	///
+	/// This is called:
+	/// - after a `withdraw_unbonded()` call that frees all of a stash's bonded balance.
+	/// - through `reap_stash()` if the balance has fallen to zero (through slashing).
+	pub(crate) fn kill_stash(stash: &T::AccountId, num_slashing_spans: u32) -> DispatchResult {
+		let controller = <Bonded<T>>::get(stash).ok_or(Error::<T>::NotStash)?;
+
+		slashing::clear_stash_metadata::<T>(stash, num_slashing_spans)?;
+
+		<Bonded<T>>::remove(stash);
+		<Ledger<T>>::remove(&controller);
+
+		<Payee<T>>::remove(stash);
+		Self::do_remove_validator(stash);
+		Self::do_remove_nominator(stash);
+
+		frame_system::Pallet::<T>::dec_consumers(stash);
+
+		Ok(())
+	}
+
+	/// Clear all era information for given era.
+	pub(crate) fn clear_era_information(era_index: EraIndex) {
+		let mut cursor = <ErasStakers<T>>::clear_prefix(era_index, u32::MAX, None);
+		debug_assert!(cursor.maybe_cursor.is_none());
+		cursor = <ErasStakersClipped<T>>::clear_prefix(era_index, u32::MAX, None);
+		debug_assert!(cursor.maybe_cursor.is_none());
+		cursor = <ErasValidatorPrefs<T>>::clear_prefix(era_index, u32::MAX, None);
+		debug_assert!(cursor.maybe_cursor.is_none());
+		<ErasValidatorReward<T>>::remove(era_index);
+		<ErasRewardPoints<T>>::remove(era_index);
+		<ErasTotalStake<T>>::remove(era_index);
+		ErasStartSessionIndex::<T>::remove(era_index);
+	}
+
+	/// Apply previously-unapplied slashes on the beginning of a new era, after a delay.
+	fn apply_unapplied_slashes(active_era: EraIndex) {
+		let era_slashes = UnappliedSlashes::<T>::take(&active_era);
+		log!(
+			debug,
+			"found {} slashes scheduled to be executed in era {:?}",
+			era_slashes.len(),
+			active_era,
+		);
+		for slash in era_slashes {
+			let slash_era = active_era.saturating_sub(T::SlashDeferDuration::get());
+			slashing::apply_slash::<T>(slash, slash_era);
+		}
+	}
+
+	/// Add reward points to validators using their stash account ID.
+	///
+	/// Validators are keyed by stash account ID and must be in the current elected set.
+	///
+	/// For each element in the iterator the given number of points in u32 is added to the
+	/// validator, thus duplicates are handled.
+	///
+	/// At the end of the era each the total payout will be distributed among validator
+	/// relatively to their points.
+	///
+	/// COMPLEXITY: Complexity is `number_of_validator_to_reward x current_elected_len`.
+	pub fn reward_by_ids(validators_points: impl IntoIterator<Item = (T::AccountId, u32)>) {
+		if let Some(active_era) = Self::active_era() {
+			<ErasRewardPoints<T>>::mutate(active_era.index, |era_rewards| {
+				for (validator, points) in validators_points.into_iter() {
+					*era_rewards.individual.entry(validator).or_default() += points;
+					era_rewards.total += points;
+				}
+			});
+		}
+	}
+
+	/// Helper to set a new `ForceEra` mode.
+	pub(crate) fn set_force_era(mode: Forcing) {
+		log!(info, "Setting force era mode {:?}.", mode);
+		ForceEra::<T>::put(mode);
+		Self::deposit_event(Event::<T>::ForceEra { mode });
+	}
+
+	/// Ensures that at the end of the current session there will be a new era.
+	pub(crate) fn ensure_new_era() {
+		match ForceEra::<T>::get() {
+			Forcing::ForceAlways | Forcing::ForceNew => (),
+			_ => Self::set_force_era(Forcing::ForceNew),
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	pub fn add_era_stakers(
+		current_era: EraIndex,
+		stash: T::AccountId,
+		exposure: Exposure<T::AccountId, BalanceOf<T>>,
+	) {
+		<ErasStakers<T>>::insert(&current_era, &stash, &exposure);
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	pub fn set_slash_reward_fraction(fraction: Perbill) {
+		SlashRewardFraction::<T>::put(fraction);
+	}
+
+	/// Get all of the voters that are eligible for the npos election.
+	///
+	/// `maybe_max_len` can imposes a cap on the number of voters returned;
+	///
+	/// Sets `MinimumActiveStake` to the minimum active nominator stake in the returned set of
+	/// nominators.
+	///
+	/// This function is self-weighing as [`DispatchClass::Mandatory`].
+	pub fn get_npos_voters(bounds: DataProviderBounds) -> Vec<VoterOf<Self>> {
+		let mut voters_size_tracker: StaticTracker<Self> = StaticTracker::default();
+
+		let final_predicted_len = {
+			let all_voter_count = T::VoterList::count();
+			bounds.count.unwrap_or(all_voter_count.into()).min(all_voter_count.into()).0
+		};
+
+		let mut all_voters = Vec::<_>::with_capacity(final_predicted_len as usize);
+
+		// cache a few things.
+		let weight_of = Self::weight_of_fn();
+
+		let mut voters_seen = 0u32;
+		let mut validators_taken = 0u32;
+		let mut nominators_taken = 0u32;
+		let mut min_active_stake = u64::MAX;
+
+		let mut sorted_voters = T::VoterList::iter();
+		while all_voters.len() < final_predicted_len as usize &&
+			voters_seen < (NPOS_MAX_ITERATIONS_COEFFICIENT * final_predicted_len as u32)
+		{
+			let voter = match sorted_voters.next() {
+				Some(voter) => {
+					voters_seen.saturating_inc();
+					voter
+				},
+				None => break,
+			};
+
+			let voter_weight = weight_of(&voter);
+			// if voter weight is zero, do not consider this voter for the snapshot.
+			if voter_weight.is_zero() {
+				log!(debug, "voter's active balance is 0. skip this voter.");
+				continue
+			}
+
+			if let Some(Nominations { targets, .. }) = <Nominators<T>>::get(&voter) {
+				if !targets.is_empty() {
+					// Note on lazy nomination quota: we do not check the nomination quota of the
+					// voter at this point and accept all the current nominations. The nomination
+					// quota is only enforced at `nominate` time.
+
+					let voter = (voter, voter_weight, targets);
+					if voters_size_tracker.try_register_voter(&voter, &bounds).is_err() {
+						// no more space left for the election result, stop iterating.
+						Self::deposit_event(Event::<T>::SnapshotVotersSizeExceeded {
+							size: voters_size_tracker.size as u32,
+						});
+						break
+					}
+
+					all_voters.push(voter);
+					nominators_taken.saturating_inc();
+				} else {
+					// technically should never happen, but not much we can do about it.
+				}
+				min_active_stake =
+					if voter_weight < min_active_stake { voter_weight } else { min_active_stake };
+			} else if Validators::<T>::contains_key(&voter) {
+				// if this voter is a validator:
+				let self_vote = (
+					voter.clone(),
+					voter_weight,
+					vec![voter.clone()]
+						.try_into()
+						.expect("`MaxVotesPerVoter` must be greater than or equal to 1"),
+				);
+
+				if voters_size_tracker.try_register_voter(&self_vote, &bounds).is_err() {
+					// no more space left for the election snapshot, stop iterating.
+					Self::deposit_event(Event::<T>::SnapshotVotersSizeExceeded {
+						size: voters_size_tracker.size as u32,
+					});
+					break
+				}
+				all_voters.push(self_vote);
+				validators_taken.saturating_inc();
+			} else {
+				// this can only happen if: 1. there a bug in the bags-list (or whatever is the
+				// sorted list) logic and the state of the two pallets is no longer compatible, or
+				// because the nominators is not decodable since they have more nomination than
+				// `T::NominationsQuota::get_quota`. The latter can rarely happen, and is not
+				// really an emergency or bug if it does.
+				defensive!(
+				    "DEFENSIVE: invalid item in `VoterList`: {:?}, this nominator probably has too many nominations now",
+                    voter,
+                );
+			}
+		}
+
+		// all_voters should have not re-allocated.
+		debug_assert!(all_voters.capacity() == final_predicted_len as usize);
+
+		Self::register_weight(T::WeightInfo::get_npos_voters(validators_taken, nominators_taken));
+
+		let min_active_stake: T::CurrencyBalance =
+			if all_voters.is_empty() { Zero::zero() } else { min_active_stake.into() };
+
+		MinimumActiveStake::<T>::put(min_active_stake);
+
+		log!(
+			info,
+			"generated {} npos voters, {} from validators and {} nominators",
+			all_voters.len(),
+			validators_taken,
+			nominators_taken
+		);
+
+		all_voters
+	}
+
+	/// Get the targets for an upcoming npos election.
+	///
+	/// This function is self-weighing as [`DispatchClass::Mandatory`].
+	pub fn get_npos_targets(bounds: DataProviderBounds) -> Vec<T::AccountId> {
+		let mut targets_size_tracker: StaticTracker<Self> = StaticTracker::default();
+
+		let final_predicted_len = {
+			let all_target_count = T::TargetList::count();
+			bounds.count.unwrap_or(all_target_count.into()).min(all_target_count.into()).0
+		};
+
+		let mut all_targets = Vec::<T::AccountId>::with_capacity(final_predicted_len as usize);
+		let mut targets_seen = 0;
+
+		let mut targets_iter = T::TargetList::iter();
+		while all_targets.len() < final_predicted_len as usize &&
+			targets_seen < (NPOS_MAX_ITERATIONS_COEFFICIENT * final_predicted_len as u32)
+		{
+			let target = match targets_iter.next() {
+				Some(target) => {
+					targets_seen.saturating_inc();
+					target
+				},
+				None => break,
+			};
+
+			if targets_size_tracker.try_register_target(target.clone(), &bounds).is_err() {
+				// no more space left for the election snapshot, stop iterating.
+				Self::deposit_event(Event::<T>::SnapshotTargetsSizeExceeded {
+					size: targets_size_tracker.size as u32,
+				});
+				break
+			}
+
+			if Validators::<T>::contains_key(&target) {
+				all_targets.push(target);
+			}
+		}
+
+		Self::register_weight(T::WeightInfo::get_npos_targets(all_targets.len() as u32));
+		log!(info, "generated {} npos targets", all_targets.len());
+
+		all_targets
+	}
+
+	/// This function will add a nominator to the `Nominators` storage map,
+	/// and `VoterList`.
+	///
+	/// If the nominator already exists, their nominations will be updated.
+	///
+	/// NOTE: you must ALWAYS use this function to add nominator or update their targets. Any access
+	/// to `Nominators` or `VoterList` outside of this function is almost certainly
+	/// wrong.
+	pub fn do_add_nominator(who: &T::AccountId, nominations: Nominations<T>) {
+		if !Nominators::<T>::contains_key(who) {
+			// maybe update sorted list.
+			let _ = T::VoterList::on_insert(who.clone(), Self::weight_of(who))
+				.defensive_unwrap_or_default();
+		}
+		Nominators::<T>::insert(who, nominations);
+
+		debug_assert_eq!(
+			Nominators::<T>::count() + Validators::<T>::count(),
+			T::VoterList::count()
+		);
+	}
+
+	/// This function will remove a nominator from the `Nominators` storage map,
+	/// and `VoterList`.
+	///
+	/// Returns true if `who` was removed from `Nominators`, otherwise false.
+	///
+	/// NOTE: you must ALWAYS use this function to remove a nominator from the system. Any access to
+	/// `Nominators` or `VoterList` outside of this function is almost certainly
+	/// wrong.
+	pub fn do_remove_nominator(who: &T::AccountId) -> bool {
+		let outcome = if Nominators::<T>::contains_key(who) {
+			Nominators::<T>::remove(who);
+			let _ = T::VoterList::on_remove(who).defensive();
+			true
+		} else {
+			false
+		};
+
+		debug_assert_eq!(
+			Nominators::<T>::count() + Validators::<T>::count(),
+			T::VoterList::count()
+		);
+
+		outcome
+	}
+
+	/// This function will add a validator to the `Validators` storage map.
+	///
+	/// If the validator already exists, their preferences will be updated.
+	///
+	/// NOTE: you must ALWAYS use this function to add a validator to the system. Any access to
+	/// `Validators` or `VoterList` outside of this function is almost certainly
+	/// wrong.
+	pub fn do_add_validator(who: &T::AccountId, prefs: ValidatorPrefs) {
+		if !Validators::<T>::contains_key(who) {
+			// maybe update sorted list.
+			let _ = T::VoterList::on_insert(who.clone(), Self::weight_of(who))
+				.defensive_unwrap_or_default();
+		}
+		Validators::<T>::insert(who, prefs);
+
+		debug_assert_eq!(
+			Nominators::<T>::count() + Validators::<T>::count(),
+			T::VoterList::count()
+		);
+	}
+
+	/// This function will remove a validator from the `Validators` storage map.
+	///
+	/// Returns true if `who` was removed from `Validators`, otherwise false.
+	///
+	/// NOTE: you must ALWAYS use this function to remove a validator from the system. Any access to
+	/// `Validators` or `VoterList` outside of this function is almost certainly
+	/// wrong.
+	pub fn do_remove_validator(who: &T::AccountId) -> bool {
+		let outcome = if Validators::<T>::contains_key(who) {
+			Validators::<T>::remove(who);
+			let _ = T::VoterList::on_remove(who).defensive();
+			true
+		} else {
+			false
+		};
+
+		debug_assert_eq!(
+			Nominators::<T>::count() + Validators::<T>::count(),
+			T::VoterList::count()
+		);
+
+		outcome
+	}
+
+	/// Register some amount of weight directly with the system pallet.
+	///
+	/// This is always mandatory weight.
+	fn register_weight(weight: Weight) {
+		<frame_system::Pallet<T>>::register_extra_weight_unchecked(
+			weight,
+			DispatchClass::Mandatory,
+		);
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Returns the current nominations quota for nominators.
+	///
+	/// Used by the runtime API.
+	pub fn api_nominations_quota(balance: BalanceOf<T>) -> u32 {
+		T::NominationsQuota::get_quota(balance)
+	}
+}
+
+impl<T: Config> ElectionDataProvider for Pallet<T> {
+	type AccountId = T::AccountId;
+	type BlockNumber = BlockNumberFor<T>;
+	type MaxVotesPerVoter = MaxNominationsOf<T>;
+
+	fn desired_targets() -> data_provider::Result<u32> {
+		Self::register_weight(T::DbWeight::get().reads(1));
+		Ok(Self::validator_count())
+	}
+
+	fn electing_voters(bounds: DataProviderBounds) -> data_provider::Result<Vec<VoterOf<Self>>> {
+		// This can never fail -- if `maybe_max_len` is `Some(_)` we handle it.
+		let voters = Self::get_npos_voters(bounds);
+
+		debug_assert!(!bounds.exhausted(
+			SizeBound(voters.encoded_size() as u32).into(),
+			CountBound(voters.len() as u32).into()
+		));
+
+		Ok(voters)
+	}
+
+	fn electable_targets(bounds: DataProviderBounds) -> data_provider::Result<Vec<T::AccountId>> {
+		let targets = Self::get_npos_targets(bounds);
+
+		// We can't handle this case yet -- return an error. WIP to improve handling this case in
+		// <https://github.com/paritytech/substrate/pull/13195>.
+		if bounds.exhausted(None, CountBound(T::TargetList::count() as u32).into()) {
+			return Err("Target snapshot too big")
+		}
+
+		debug_assert!(!bounds.exhausted(
+			SizeBound(targets.encoded_size() as u32).into(),
+			CountBound(targets.len() as u32).into()
+		));
+
+		Ok(targets)
+	}
+
+	fn next_election_prediction(now: BlockNumberFor<T>) -> BlockNumberFor<T> {
+		let current_era = Self::current_era().unwrap_or(0);
+		let current_session = Self::current_planned_session();
+		let current_era_start_session_index =
+			Self::eras_start_session_index(current_era).unwrap_or(0);
+		// Number of session in the current era or the maximum session per era if reached.
+		let era_progress = current_session
+			.saturating_sub(current_era_start_session_index)
+			.min(T::SessionsPerEra::get());
+
+		let until_this_session_end = T::NextNewSession::estimate_next_new_session(now)
+			.0
+			.unwrap_or_default()
+			.saturating_sub(now);
+
+		let session_length = T::NextNewSession::average_session_length();
+
+		let sessions_left: BlockNumberFor<T> = match ForceEra::<T>::get() {
+			Forcing::ForceNone => Bounded::max_value(),
+			Forcing::ForceNew | Forcing::ForceAlways => Zero::zero(),
+			Forcing::NotForcing if era_progress >= T::SessionsPerEra::get() => Zero::zero(),
+			Forcing::NotForcing => T::SessionsPerEra::get()
+				.saturating_sub(era_progress)
+				// One session is computed in this_session_end.
+				.saturating_sub(1)
+				.into(),
+		};
+
+		now.saturating_add(
+			until_this_session_end.saturating_add(sessions_left.saturating_mul(session_length)),
+		)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add_voter(
+		voter: T::AccountId,
+		weight: VoteWeight,
+		targets: BoundedVec<T::AccountId, Self::MaxVotesPerVoter>,
+	) {
+		let stake = <BalanceOf<T>>::try_from(weight).unwrap_or_else(|_| {
+			panic!("cannot convert a VoteWeight into BalanceOf, benchmark needs reconfiguring.")
+		});
+		<Bonded<T>>::insert(voter.clone(), voter.clone());
+		<Ledger<T>>::insert(
+			voter.clone(),
+			StakingLedger {
+				stash: voter.clone(),
+				active: stake,
+				total: stake,
+				unlocking: Default::default(),
+				claimed_rewards: Default::default(),
+			},
+		);
+
+		Self::do_add_nominator(&voter, Nominations { targets, submitted_in: 0, suppressed: false });
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add_target(target: T::AccountId) {
+		let stake = MinValidatorBond::<T>::get() * 100u32.into();
+		<Bonded<T>>::insert(target.clone(), target.clone());
+		<Ledger<T>>::insert(
+			target.clone(),
+			StakingLedger {
+				stash: target.clone(),
+				active: stake,
+				total: stake,
+				unlocking: Default::default(),
+				claimed_rewards: Default::default(),
+			},
+		);
+		Self::do_add_validator(
+			&target,
+			ValidatorPrefs { commission: Perbill::zero(), blocked: false },
+		);
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn clear() {
+		#[allow(deprecated)]
+		<Bonded<T>>::remove_all(None);
+		#[allow(deprecated)]
+		<Ledger<T>>::remove_all(None);
+		#[allow(deprecated)]
+		<Validators<T>>::remove_all();
+		#[allow(deprecated)]
+		<Nominators<T>>::remove_all();
+
+		T::VoterList::unsafe_clear();
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn put_snapshot(
+		voters: Vec<VoterOf<Self>>,
+		targets: Vec<T::AccountId>,
+		target_stake: Option<VoteWeight>,
+	) {
+		targets.into_iter().for_each(|v| {
+			let stake: BalanceOf<T> = target_stake
+				.and_then(|w| <BalanceOf<T>>::try_from(w).ok())
+				.unwrap_or_else(|| MinNominatorBond::<T>::get() * 100u32.into());
+			<Bonded<T>>::insert(v.clone(), v.clone());
+			<Ledger<T>>::insert(
+				v.clone(),
+				StakingLedger {
+					stash: v.clone(),
+					active: stake,
+					total: stake,
+					unlocking: Default::default(),
+					claimed_rewards: Default::default(),
+				},
+			);
+			Self::do_add_validator(
+				&v,
+				ValidatorPrefs { commission: Perbill::zero(), blocked: false },
+			);
+		});
+
+		voters.into_iter().for_each(|(v, s, t)| {
+			let stake = <BalanceOf<T>>::try_from(s).unwrap_or_else(|_| {
+				panic!("cannot convert a VoteWeight into BalanceOf, benchmark needs reconfiguring.")
+			});
+			<Bonded<T>>::insert(v.clone(), v.clone());
+			<Ledger<T>>::insert(
+				v.clone(),
+				StakingLedger {
+					stash: v.clone(),
+					active: stake,
+					total: stake,
+					unlocking: Default::default(),
+					claimed_rewards: Default::default(),
+				},
+			);
+			Self::do_add_nominator(
+				&v,
+				Nominations { targets: t, submitted_in: 0, suppressed: false },
+			);
+		});
+	}
+}
+
+/// In this implementation `new_session(session)` must be called before `end_session(session-1)`
+/// i.e. the new session must be planned before the ending of the previous session.
+///
+/// Once the first new_session is planned, all session must start and then end in order, though
+/// some session can lag in between the newest session planned and the latest session started.
+impl<T: Config> pallet_session::SessionManager<T::AccountId> for Pallet<T> {
+	fn new_session(new_index: SessionIndex) -> Option<Vec<T::AccountId>> {
+		log!(trace, "planning new session {}", new_index);
+		CurrentPlannedSession::<T>::put(new_index);
+		Self::new_session(new_index, false).map(|v| v.into_inner())
+	}
+	fn new_session_genesis(new_index: SessionIndex) -> Option<Vec<T::AccountId>> {
+		log!(trace, "planning new session {} at genesis", new_index);
+		CurrentPlannedSession::<T>::put(new_index);
+		Self::new_session(new_index, true).map(|v| v.into_inner())
+	}
+	fn start_session(start_index: SessionIndex) {
+		log!(trace, "starting session {}", start_index);
+		Self::start_session(start_index)
+	}
+	fn end_session(end_index: SessionIndex) {
+		log!(trace, "ending session {}", end_index);
+		Self::end_session(end_index)
+	}
+}
+
+impl<T: Config> historical::SessionManager<T::AccountId, Exposure<T::AccountId, BalanceOf<T>>>
+	for Pallet<T>
+{
+	fn new_session(
+		new_index: SessionIndex,
+	) -> Option<Vec<(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>)>> {
+		<Self as pallet_session::SessionManager<_>>::new_session(new_index).map(|validators| {
+			let current_era = Self::current_era()
+				// Must be some as a new era has been created.
+				.unwrap_or(0);
+
+			validators
+				.into_iter()
+				.map(|v| {
+					let exposure = Self::eras_stakers(current_era, &v);
+					(v, exposure)
+				})
+				.collect()
+		})
+	}
+	fn new_session_genesis(
+		new_index: SessionIndex,
+	) -> Option<Vec<(T::AccountId, Exposure<T::AccountId, BalanceOf<T>>)>> {
+		<Self as pallet_session::SessionManager<_>>::new_session_genesis(new_index).map(
+			|validators| {
+				let current_era = Self::current_era()
+					// Must be some as a new era has been created.
+					.unwrap_or(0);
+
+				validators
+					.into_iter()
+					.map(|v| {
+						let exposure = Self::eras_stakers(current_era, &v);
+						(v, exposure)
+					})
+					.collect()
+			},
+		)
+	}
+	fn start_session(start_index: SessionIndex) {
+		<Self as pallet_session::SessionManager<_>>::start_session(start_index)
+	}
+	fn end_session(end_index: SessionIndex) {
+		<Self as pallet_session::SessionManager<_>>::end_session(end_index)
+	}
+}
+
+/// Add reward points to block authors:
+/// * 20 points to the block producer for producing a (non-uncle) block,
+impl<T> pallet_authorship::EventHandler<T::AccountId, BlockNumberFor<T>> for Pallet<T>
+where
+	T: Config + pallet_authorship::Config + pallet_session::Config,
+{
+	fn note_author(author: T::AccountId) {
+		Self::reward_by_ids(vec![(author, 20)])
+	}
+}
+
+/// This is intended to be used with `FilterHistoricalOffences`.
+impl<T: Config>
+	OnOffenceHandler<T::AccountId, pallet_session::historical::IdentificationTuple<T>, Weight>
+	for Pallet<T>
+where
+	T: pallet_session::Config<ValidatorId = <T as frame_system::Config>::AccountId>,
+	T: pallet_session::historical::Config<
+		FullIdentification = Exposure<<T as frame_system::Config>::AccountId, BalanceOf<T>>,
+		FullIdentificationOf = ExposureOf<T>,
+	>,
+	T::SessionHandler: pallet_session::SessionHandler<<T as frame_system::Config>::AccountId>,
+	T::SessionManager: pallet_session::SessionManager<<T as frame_system::Config>::AccountId>,
+	T::ValidatorIdOf: Convert<
+		<T as frame_system::Config>::AccountId,
+		Option<<T as frame_system::Config>::AccountId>,
+	>,
+{
+	fn on_offence(
+		offenders: &[OffenceDetails<
+			T::AccountId,
+			pallet_session::historical::IdentificationTuple<T>,
+		>],
+		slash_fraction: &[Perbill],
+		slash_session: SessionIndex,
+		disable_strategy: DisableStrategy,
+	) -> Weight {
+		let reward_proportion = SlashRewardFraction::<T>::get();
+		let mut consumed_weight = Weight::from_parts(0, 0);
+		let mut add_db_reads_writes = |reads, writes| {
+			consumed_weight += T::DbWeight::get().reads_writes(reads, writes);
+		};
+
+		let active_era = {
+			let active_era = Self::active_era();
+			add_db_reads_writes(1, 0);
+			if active_era.is_none() {
+				// This offence need not be re-submitted.
+				return consumed_weight
+			}
+			active_era.expect("value checked not to be `None`; qed").index
+		};
+		let active_era_start_session_index = Self::eras_start_session_index(active_era)
+			.unwrap_or_else(|| {
+				frame_support::print("Error: start_session_index must be set for current_era");
+				0
+			});
+		add_db_reads_writes(1, 0);
+
+		let window_start = active_era.saturating_sub(T::BondingDuration::get());
+
+		// Fast path for active-era report - most likely.
+		// `slash_session` cannot be in a future active era. It must be in `active_era` or before.
+		let slash_era = if slash_session >= active_era_start_session_index {
+			active_era
+		} else {
+			let eras = BondedEras::<T>::get();
+			add_db_reads_writes(1, 0);
+
+			// Reverse because it's more likely to find reports from recent eras.
+			match eras.iter().rev().find(|&(_, sesh)| sesh <= &slash_session) {
+				Some((slash_era, _)) => *slash_era,
+				// Before bonding period. defensive - should be filtered out.
+				None => return consumed_weight,
+			}
+		};
+
+		add_db_reads_writes(1, 1);
+
+		let slash_defer_duration = T::SlashDeferDuration::get();
+
+		let invulnerables = Self::invulnerables();
+		add_db_reads_writes(1, 0);
+
+		for (details, slash_fraction) in offenders.iter().zip(slash_fraction) {
+			let (stash, exposure) = &details.offender;
+
+			// Skip if the validator is invulnerable.
+			if invulnerables.contains(stash) {
+				continue
+			}
+
+			let unapplied = slashing::compute_slash::<T>(slashing::SlashParams {
+				stash,
+				slash: *slash_fraction,
+				exposure,
+				slash_era,
+				window_start,
+				now: active_era,
+				reward_proportion,
+				disable_strategy,
+			});
+
+			Self::deposit_event(Event::<T>::SlashReported {
+				validator: stash.clone(),
+				fraction: *slash_fraction,
+				slash_era,
+			});
+
+			if let Some(mut unapplied) = unapplied {
+				let nominators_len = unapplied.others.len() as u64;
+				let reporters_len = details.reporters.len() as u64;
+
+				{
+					let upper_bound = 1 /* Validator/NominatorSlashInEra */ + 2 /* fetch_spans */;
+					let rw = upper_bound + nominators_len * upper_bound;
+					add_db_reads_writes(rw, rw);
+				}
+				unapplied.reporters = details.reporters.clone();
+				if slash_defer_duration == 0 {
+					// Apply right away.
+					slashing::apply_slash::<T>(unapplied, slash_era);
+					{
+						let slash_cost = (6, 5);
+						let reward_cost = (2, 2);
+						add_db_reads_writes(
+							(1 + nominators_len) * slash_cost.0 + reward_cost.0 * reporters_len,
+							(1 + nominators_len) * slash_cost.1 + reward_cost.1 * reporters_len,
+						);
+					}
+				} else {
+					// Defer to end of some `slash_defer_duration` from now.
+					log!(
+						debug,
+						"deferring slash of {:?}% happened in {:?} (reported in {:?}) to {:?}",
+						slash_fraction,
+						slash_era,
+						active_era,
+						slash_era + slash_defer_duration + 1,
+					);
+					UnappliedSlashes::<T>::mutate(
+						slash_era.saturating_add(slash_defer_duration).saturating_add(One::one()),
+						move |for_later| for_later.push(unapplied),
+					);
+					add_db_reads_writes(1, 1);
+				}
+			} else {
+				add_db_reads_writes(4 /* fetch_spans */, 5 /* kick_out_if_recent */)
+			}
+		}
+
+		consumed_weight
+	}
+}
+
+impl<T: Config> ScoreProvider<T::AccountId> for Pallet<T> {
+	type Score = VoteWeight;
+
+	fn score(who: &T::AccountId) -> Self::Score {
+		Self::weight_of(who)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn set_score_of(who: &T::AccountId, weight: Self::Score) {
+		// this will clearly results in an inconsistent state, but it should not matter for a
+		// benchmark.
+		let active: BalanceOf<T> = weight.try_into().map_err(|_| ()).unwrap();
+		let mut ledger = match Self::ledger(who) {
+			None => StakingLedger::default_from(who.clone()),
+			Some(l) => l,
+		};
+		ledger.active = active;
+
+		<Ledger<T>>::insert(who, ledger);
+		<Bonded<T>>::insert(who, who);
+
+		// also, we play a trick to make sure that a issuance based-`CurrencyToVote` behaves well:
+		// This will make sure that total issuance is zero, thus the currency to vote will be a 1-1
+		// conversion.
+		let imbalance = T::Currency::burn(T::Currency::total_issuance());
+		// kinda ugly, but gets the job done. The fact that this works here is a HUGE exception.
+		// Don't try this pattern in other places.
+		sp_std::mem::forget(imbalance);
+	}
+}
+
+/// A simple sorted list implementation that does not require any additional pallets. Note, this
+/// does not provide validators in sorted order. If you desire nominators in a sorted order take
+/// a look at [`pallet-bags-list`].
+pub struct UseValidatorsMap<T>(sp_std::marker::PhantomData<T>);
+impl<T: Config> SortedListProvider<T::AccountId> for UseValidatorsMap<T> {
+	type Score = BalanceOf<T>;
+	type Error = ();
+
+	/// Returns iterator over voter list, which can have `take` called on it.
+	fn iter() -> Box<dyn Iterator<Item = T::AccountId>> {
+		Box::new(Validators::<T>::iter().map(|(v, _)| v))
+	}
+	fn iter_from(
+		start: &T::AccountId,
+	) -> Result<Box<dyn Iterator<Item = T::AccountId>>, Self::Error> {
+		if Validators::<T>::contains_key(start) {
+			let start_key = Validators::<T>::hashed_key_for(start);
+			Ok(Box::new(Validators::<T>::iter_from(start_key).map(|(n, _)| n)))
+		} else {
+			Err(())
+		}
+	}
+	fn count() -> u32 {
+		Validators::<T>::count()
+	}
+	fn contains(id: &T::AccountId) -> bool {
+		Validators::<T>::contains_key(id)
+	}
+	fn on_insert(_: T::AccountId, _weight: Self::Score) -> Result<(), Self::Error> {
+		// nothing to do on insert.
+		Ok(())
+	}
+	fn get_score(id: &T::AccountId) -> Result<Self::Score, Self::Error> {
+		Ok(Pallet::<T>::weight_of(id).into())
+	}
+	fn on_update(_: &T::AccountId, _weight: Self::Score) -> Result<(), Self::Error> {
+		// nothing to do on update.
+		Ok(())
+	}
+	fn on_remove(_: &T::AccountId) -> Result<(), Self::Error> {
+		// nothing to do on remove.
+		Ok(())
+	}
+	fn unsafe_regenerate(
+		_: impl IntoIterator<Item = T::AccountId>,
+		_: Box<dyn Fn(&T::AccountId) -> Self::Score>,
+	) -> u32 {
+		// nothing to do upon regenerate.
+		0
+	}
+	#[cfg(feature = "try-runtime")]
+	fn try_state() -> Result<(), TryRuntimeError> {
+		Ok(())
+	}
+
+	fn unsafe_clear() {
+		#[allow(deprecated)]
+		Validators::<T>::remove_all();
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn score_update_worst_case(_who: &T::AccountId, _is_increase: bool) -> Self::Score {
+		unimplemented!()
+	}
+}
+
+/// A simple voter list implementation that does not require any additional pallets. Note, this
+/// does not provided nominators in sorted ordered. If you desire nominators in a sorted order take
+/// a look at [`pallet-bags-list].
+pub struct UseNominatorsAndValidatorsMap<T>(sp_std::marker::PhantomData<T>);
+impl<T: Config> SortedListProvider<T::AccountId> for UseNominatorsAndValidatorsMap<T> {
+	type Error = ();
+	type Score = VoteWeight;
+
+	fn iter() -> Box<dyn Iterator<Item = T::AccountId>> {
+		Box::new(
+			Validators::<T>::iter()
+				.map(|(v, _)| v)
+				.chain(Nominators::<T>::iter().map(|(n, _)| n)),
+		)
+	}
+	fn iter_from(
+		start: &T::AccountId,
+	) -> Result<Box<dyn Iterator<Item = T::AccountId>>, Self::Error> {
+		if Validators::<T>::contains_key(start) {
+			let start_key = Validators::<T>::hashed_key_for(start);
+			Ok(Box::new(
+				Validators::<T>::iter_from(start_key)
+					.map(|(n, _)| n)
+					.chain(Nominators::<T>::iter().map(|(x, _)| x)),
+			))
+		} else if Nominators::<T>::contains_key(start) {
+			let start_key = Nominators::<T>::hashed_key_for(start);
+			Ok(Box::new(Nominators::<T>::iter_from(start_key).map(|(n, _)| n)))
+		} else {
+			Err(())
+		}
+	}
+	fn count() -> u32 {
+		Nominators::<T>::count().saturating_add(Validators::<T>::count())
+	}
+	fn contains(id: &T::AccountId) -> bool {
+		Nominators::<T>::contains_key(id) || Validators::<T>::contains_key(id)
+	}
+	fn on_insert(_: T::AccountId, _weight: Self::Score) -> Result<(), Self::Error> {
+		// nothing to do on insert.
+		Ok(())
+	}
+	fn get_score(id: &T::AccountId) -> Result<Self::Score, Self::Error> {
+		Ok(Pallet::<T>::weight_of(id))
+	}
+	fn on_update(_: &T::AccountId, _weight: Self::Score) -> Result<(), Self::Error> {
+		// nothing to do on update.
+		Ok(())
+	}
+	fn on_remove(_: &T::AccountId) -> Result<(), Self::Error> {
+		// nothing to do on remove.
+		Ok(())
+	}
+	fn unsafe_regenerate(
+		_: impl IntoIterator<Item = T::AccountId>,
+		_: Box<dyn Fn(&T::AccountId) -> Self::Score>,
+	) -> u32 {
+		// nothing to do upon regenerate.
+		0
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn try_state() -> Result<(), TryRuntimeError> {
+		Ok(())
+	}
+
+	fn unsafe_clear() {
+		// NOTE: Caller must ensure this doesn't lead to too many storage accesses. This is a
+		// condition of SortedListProvider::unsafe_clear.
+		#[allow(deprecated)]
+		Nominators::<T>::remove_all();
+		#[allow(deprecated)]
+		Validators::<T>::remove_all();
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn score_update_worst_case(_who: &T::AccountId, _is_increase: bool) -> Self::Score {
+		unimplemented!()
+	}
+}
+
+impl<T: Config> StakingInterface for Pallet<T> {
+	type AccountId = T::AccountId;
+	type Balance = BalanceOf<T>;
+	type CurrencyToVote = T::CurrencyToVote;
+
+	fn minimum_nominator_bond() -> Self::Balance {
+		MinNominatorBond::<T>::get()
+	}
+
+	fn minimum_validator_bond() -> Self::Balance {
+		MinValidatorBond::<T>::get()
+	}
+
+	fn desired_validator_count() -> u32 {
+		ValidatorCount::<T>::get()
+	}
+
+	fn election_ongoing() -> bool {
+		T::ElectionProvider::ongoing()
+	}
+
+	fn force_unstake(who: Self::AccountId) -> sp_runtime::DispatchResult {
+		let num_slashing_spans = Self::slashing_spans(&who).map_or(0, |s| s.iter().count() as u32);
+		Self::force_unstake(RawOrigin::Root.into(), who.clone(), num_slashing_spans)
+	}
+
+	fn stash_by_ctrl(controller: &Self::AccountId) -> Result<Self::AccountId, DispatchError> {
+		Self::ledger(controller)
+			.map(|l| l.stash)
+			.ok_or(Error::<T>::NotController.into())
+	}
+
+	fn is_exposed_in_era(who: &Self::AccountId, era: &EraIndex) -> bool {
+		ErasStakers::<T>::iter_prefix(era).any(|(validator, exposures)| {
+			validator == *who || exposures.others.iter().any(|i| i.who == *who)
+		})
+	}
+
+	fn bonding_duration() -> EraIndex {
+		T::BondingDuration::get()
+	}
+
+	fn current_era() -> EraIndex {
+		Self::current_era().unwrap_or(Zero::zero())
+	}
+
+	fn stake(who: &Self::AccountId) -> Result<Stake<BalanceOf<T>>, DispatchError> {
+		Self::bonded(who)
+			.and_then(|c| Self::ledger(c))
+			.map(|l| Stake { total: l.total, active: l.active })
+			.ok_or(Error::<T>::NotStash.into())
+	}
+
+	fn bond_extra(who: &Self::AccountId, extra: Self::Balance) -> DispatchResult {
+		Self::bond_extra(RawOrigin::Signed(who.clone()).into(), extra)
+	}
+
+	fn unbond(who: &Self::AccountId, value: Self::Balance) -> DispatchResult {
+		let ctrl = Self::bonded(who).ok_or(Error::<T>::NotStash)?;
+		Self::unbond(RawOrigin::Signed(ctrl).into(), value)
+			.map_err(|with_post| with_post.error)
+			.map(|_| ())
+	}
+
+	fn chill(who: &Self::AccountId) -> DispatchResult {
+		// defensive-only: any account bonded via this interface has the stash set as the
+		// controller, but we have to be sure. Same comment anywhere else that we read this.
+		let ctrl = Self::bonded(who).ok_or(Error::<T>::NotStash)?;
+		Self::chill(RawOrigin::Signed(ctrl).into())
+	}
+
+	fn withdraw_unbonded(
+		who: Self::AccountId,
+		num_slashing_spans: u32,
+	) -> Result<bool, DispatchError> {
+		let ctrl = Self::bonded(who).ok_or(Error::<T>::NotStash)?;
+		Self::withdraw_unbonded(RawOrigin::Signed(ctrl.clone()).into(), num_slashing_spans)
+			.map(|_| !Ledger::<T>::contains_key(&ctrl))
+			.map_err(|with_post| with_post.error)
+	}
+
+	fn bond(
+		who: &Self::AccountId,
+		value: Self::Balance,
+		payee: &Self::AccountId,
+	) -> DispatchResult {
+		Self::bond(
+			RawOrigin::Signed(who.clone()).into(),
+			value,
+			RewardDestination::Account(payee.clone()),
+		)
+	}
+
+	fn nominate(who: &Self::AccountId, targets: Vec<Self::AccountId>) -> DispatchResult {
+		let ctrl = Self::bonded(who).ok_or(Error::<T>::NotStash)?;
+		let targets = targets.into_iter().map(T::Lookup::unlookup).collect::<Vec<_>>();
+		Self::nominate(RawOrigin::Signed(ctrl).into(), targets)
+	}
+
+	fn status(
+		who: &Self::AccountId,
+	) -> Result<sp_staking::StakerStatus<Self::AccountId>, DispatchError> {
+		let is_bonded = Self::bonded(who).is_some();
+		if !is_bonded {
+			return Err(Error::<T>::NotStash.into())
+		}
+
+		let is_validator = Validators::<T>::contains_key(&who);
+		let is_nominator = Nominators::<T>::get(&who);
+
+		use sp_staking::StakerStatus;
+		match (is_validator, is_nominator.is_some()) {
+			(false, false) => Ok(StakerStatus::Idle),
+			(true, false) => Ok(StakerStatus::Validator),
+			(false, true) => Ok(StakerStatus::Nominator(
+				is_nominator.expect("is checked above; qed").targets.into_inner(),
+			)),
+			(true, true) => {
+				defensive!("cannot be both validators and nominator");
+				Err(Error::<T>::BadState.into())
+			},
+		}
+	}
+
+	sp_staking::runtime_benchmarks_enabled! {
+		fn nominations(who: &Self::AccountId) -> Option<Vec<T::AccountId>> {
+			Nominators::<T>::get(who).map(|n| n.targets.into_inner())
+		}
+
+		fn add_era_stakers(
+			current_era: &EraIndex,
+			stash: &T::AccountId,
+			exposures: Vec<(Self::AccountId, Self::Balance)>,
+		) {
+			let others = exposures
+				.iter()
+				.map(|(who, value)| IndividualExposure { who: who.clone(), value: value.clone() })
+				.collect::<Vec<_>>();
+			let exposure = Exposure { total: Default::default(), own: Default::default(), others };
+			<ErasStakers<T>>::insert(&current_era, &stash, &exposure);
+		}
+
+		fn set_current_era(era: EraIndex) {
+			CurrentEra::<T>::put(era);
+		}
+	}
+}
+
+#[cfg(any(test, feature = "try-runtime"))]
+impl<T: Config> Pallet<T> {
+	pub(crate) fn do_try_state(_: BlockNumberFor<T>) -> Result<(), TryRuntimeError> {
+		ensure!(
+			T::VoterList::iter()
+				.all(|x| <Nominators<T>>::contains_key(&x) || <Validators<T>>::contains_key(&x)),
+			"VoterList contains non-staker"
+		);
+
+		Self::check_nominators()?;
+		Self::check_exposures()?;
+		Self::check_ledgers()?;
+		Self::check_count()
+	}
+
+	fn check_count() -> Result<(), TryRuntimeError> {
+		ensure!(
+			<T as Config>::VoterList::count() ==
+				Nominators::<T>::count() + Validators::<T>::count(),
+			"wrong external count"
+		);
+		ensure!(
+			<T as Config>::TargetList::count() == Validators::<T>::count(),
+			"wrong external count"
+		);
+		ensure!(
+			ValidatorCount::<T>::get() <=
+				<T::ElectionProvider as frame_election_provider_support::ElectionProviderBase>::MaxWinners::get(),
+			Error::<T>::TooManyValidators
+		);
+		Ok(())
+	}
+
+	fn check_ledgers() -> Result<(), TryRuntimeError> {
+		Bonded::<T>::iter()
+			.map(|(_, ctrl)| Self::ensure_ledger_consistent(ctrl))
+			.collect::<Result<Vec<_>, _>>()?;
+		Ok(())
+	}
+
+	fn check_exposures() -> Result<(), TryRuntimeError> {
+		// a check per validator to ensure the exposure struct is always sane.
+		let era = Self::active_era().unwrap().index;
+		ErasStakers::<T>::iter_prefix_values(era)
+			.map(|expo| {
+				ensure!(
+					expo.total ==
+						expo.own +
+							expo.others
+								.iter()
+								.map(|e| e.value)
+								.fold(Zero::zero(), |acc, x| acc + x),
+					"wrong total exposure.",
+				);
+				Ok(())
+			})
+			.collect::<Result<(), TryRuntimeError>>()
+	}
+
+	fn check_nominators() -> Result<(), TryRuntimeError> {
+		// a check per nominator to ensure their entire stake is correctly distributed. Will only
+		// kick-in if the nomination was submitted before the current era.
+		let era = Self::active_era().unwrap().index;
+		<Nominators<T>>::iter()
+			.filter_map(
+				|(nominator, nomination)| {
+					if nomination.submitted_in < era {
+						Some(nominator)
+					} else {
+						None
+					}
+				},
+			)
+			.map(|nominator| -> Result<(), TryRuntimeError> {
+				// must be bonded.
+				Self::ensure_is_stash(&nominator)?;
+				let mut sum = BalanceOf::<T>::zero();
+				T::SessionInterface::validators()
+					.iter()
+					.map(|v| Self::eras_stakers(era, v))
+					.map(|e| -> Result<(), TryRuntimeError> {
+						let individual =
+							e.others.iter().filter(|e| e.who == nominator).collect::<Vec<_>>();
+						let len = individual.len();
+						match len {
+							0 => { /* not supporting this validator at all. */ },
+							1 => sum += individual[0].value,
+							_ =>
+								return Err(
+									"nominator cannot back a validator more than once.".into()
+								),
+						};
+						Ok(())
+					})
+					.collect::<Result<Vec<_>, _>>()?;
+				Ok(())
+			})
+			.collect::<Result<Vec<_>, _>>()?;
+
+		Ok(())
+	}
+
+	fn ensure_is_stash(who: &T::AccountId) -> Result<(), &'static str> {
+		ensure!(Self::bonded(who).is_some(), "Not a stash.");
+		Ok(())
+	}
+
+	fn ensure_ledger_consistent(ctrl: T::AccountId) -> Result<(), TryRuntimeError> {
+		// ensures ledger.total == ledger.active + sum(ledger.unlocking).
+		let ledger = Self::ledger(ctrl.clone()).ok_or("Not a controller.")?;
+		let real_total: BalanceOf<T> =
+			ledger.unlocking.iter().fold(ledger.active, |a, c| a + c.value);
+		ensure!(real_total == ledger.total, "ledger.total corrupt");
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/staking/src/pallet/mod.rs b/substrate/frame/staking/src/pallet/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..40a2f5cf73eb186d2e188cb36c7583184457a284
--- /dev/null
+++ b/substrate/frame/staking/src/pallet/mod.rs
@@ -0,0 +1,1785 @@
+// 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.
+
+//! Staking FRAME Pallet.
+
+use frame_election_provider_support::{
+	ElectionProvider, ElectionProviderBase, SortedListProvider, VoteWeight,
+};
+use frame_support::{
+	dispatch::Codec,
+	pallet_prelude::*,
+	traits::{
+		Currency, Defensive, DefensiveResult, DefensiveSaturating, EnsureOrigin,
+		EstimateNextNewSession, Get, LockIdentifier, LockableCurrency, OnUnbalanced, TryCollect,
+		UnixTime,
+	},
+	weights::Weight,
+	BoundedVec,
+};
+use frame_system::{ensure_root, ensure_signed, pallet_prelude::*};
+use sp_runtime::{
+	traits::{CheckedSub, SaturatedConversion, StaticLookup, Zero},
+	ArithmeticError, Perbill, Percent,
+};
+use sp_staking::{EraIndex, SessionIndex};
+use sp_std::prelude::*;
+
+mod impls;
+
+pub use impls::*;
+
+use crate::{
+	slashing, weights::WeightInfo, AccountIdLookupOf, ActiveEraInfo, BalanceOf, EraPayout,
+	EraRewardPoints, Exposure, Forcing, MaxNominationsOf, NegativeImbalanceOf, Nominations,
+	NominationsQuota, PositiveImbalanceOf, RewardDestination, SessionInterface, StakingLedger,
+	UnappliedSlash, UnlockChunk, ValidatorPrefs,
+};
+
+const STAKING_ID: LockIdentifier = *b"staking ";
+// The speculative number of spans are used as an input of the weight annotation of
+// [`Call::unbond`], as the post dipatch weight may depend on the number of slashing span on the
+// account which is not provided as an input. The value set should be conservative but sensible.
+pub(crate) const SPECULATIVE_NUM_SPANS: u32 = 32;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_election_provider_support::ElectionDataProvider;
+
+	use crate::BenchmarkingConfig;
+
+	use super::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(13);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	/// Possible operations on the configuration values of this pallet.
+	#[derive(TypeInfo, Debug, Clone, Encode, Decode, PartialEq)]
+	pub enum ConfigOp<T: Default + Codec> {
+		/// Don't change.
+		Noop,
+		/// Set the given value.
+		Set(T),
+		/// Remove from storage.
+		Remove,
+	}
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The staking balance.
+		type Currency: LockableCurrency<
+			Self::AccountId,
+			Moment = BlockNumberFor<Self>,
+			Balance = Self::CurrencyBalance,
+		>;
+		/// Just the `Currency::Balance` type; we have this item to allow us to constrain it to
+		/// `From<u64>`.
+		type CurrencyBalance: sp_runtime::traits::AtLeast32BitUnsigned
+			+ codec::FullCodec
+			+ Copy
+			+ MaybeSerializeDeserialize
+			+ sp_std::fmt::Debug
+			+ Default
+			+ From<u64>
+			+ TypeInfo
+			+ MaxEncodedLen;
+		/// Time used for computing era duration.
+		///
+		/// It is guaranteed to start being called from the first `on_finalize`. Thus value at
+		/// genesis is not used.
+		type UnixTime: UnixTime;
+
+		/// Convert a balance into a number used for election calculation. This must fit into a
+		/// `u64` but is allowed to be sensibly lossy. The `u64` is used to communicate with the
+		/// [`frame_election_provider_support`] crate which accepts u64 numbers and does operations
+		/// in 128.
+		/// Consequently, the backward convert is used convert the u128s from sp-elections back to a
+		/// [`BalanceOf`].
+		type CurrencyToVote: sp_staking::currency_to_vote::CurrencyToVote<BalanceOf<Self>>;
+
+		/// Something that provides the election functionality.
+		type ElectionProvider: ElectionProvider<
+			AccountId = Self::AccountId,
+			BlockNumber = BlockNumberFor<Self>,
+			// we only accept an election provider that has staking as data provider.
+			DataProvider = Pallet<Self>,
+		>;
+		/// Something that provides the election functionality at genesis.
+		type GenesisElectionProvider: ElectionProvider<
+			AccountId = Self::AccountId,
+			BlockNumber = BlockNumberFor<Self>,
+			DataProvider = Pallet<Self>,
+		>;
+
+		/// Something that defines the maximum number of nominations per nominator.
+		type NominationsQuota: NominationsQuota<BalanceOf<Self>>;
+
+		/// Number of eras to keep in history.
+		///
+		/// Following information is kept for eras in `[current_era -
+		/// HistoryDepth, current_era]`: `ErasStakers`, `ErasStakersClipped`,
+		/// `ErasValidatorPrefs`, `ErasValidatorReward`, `ErasRewardPoints`,
+		/// `ErasTotalStake`, `ErasStartSessionIndex`,
+		/// `StakingLedger.claimed_rewards`.
+		///
+		/// Must be more than the number of eras delayed by session.
+		/// I.e. active era must always be in history. I.e. `active_era >
+		/// current_era - history_depth` must be guaranteed.
+		///
+		/// If migrating an existing pallet from storage value to config value,
+		/// this should be set to same value or greater as in storage.
+		///
+		/// Note: `HistoryDepth` is used as the upper bound for the `BoundedVec`
+		/// item `StakingLedger.claimed_rewards`. Setting this value lower than
+		/// the existing value can lead to inconsistencies in the
+		/// `StakingLedger` and will need to be handled properly in a migration.
+		/// The test `reducing_history_depth_abrupt` shows this effect.
+		#[pallet::constant]
+		type HistoryDepth: Get<u32>;
+
+		/// Tokens have been minted and are unused for validator-reward.
+		/// See [Era payout](./index.html#era-payout).
+		type RewardRemainder: OnUnbalanced<NegativeImbalanceOf<Self>>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Handler for the unbalanced reduction when slashing a staker.
+		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.
+		type Reward: OnUnbalanced<PositiveImbalanceOf<Self>>;
+
+		/// Number of sessions per era.
+		#[pallet::constant]
+		type SessionsPerEra: Get<SessionIndex>;
+
+		/// Number of eras that staked funds must remain bonded for.
+		#[pallet::constant]
+		type BondingDuration: Get<EraIndex>;
+
+		/// Number of eras that slashes are deferred by, after computation.
+		///
+		/// This should be less than the bonding duration. Set to 0 if slashes
+		/// should be applied immediately, without opportunity for intervention.
+		#[pallet::constant]
+		type SlashDeferDuration: Get<EraIndex>;
+
+		/// The origin which can manage less critical staking parameters that does not require root.
+		///
+		/// Supported actions: (1) cancel deferred slash, (2) set minimum commission.
+		type AdminOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Interface for interacting with a session pallet.
+		type SessionInterface: SessionInterface<Self::AccountId>;
+
+		/// The payout for validators and the system for the current era.
+		/// See [Era payout](./index.html#era-payout).
+		type EraPayout: EraPayout<BalanceOf<Self>>;
+
+		/// Something that can estimate the next session change, accurately or as a best effort
+		/// guess.
+		type NextNewSession: EstimateNextNewSession<BlockNumberFor<Self>>;
+
+		/// The maximum number of nominators rewarded for each validator.
+		///
+		/// For each validator only the `$MaxNominatorRewardedPerValidator` biggest stakers can
+		/// claim their reward. This used to limit the i/o cost for the nominator payout.
+		#[pallet::constant]
+		type MaxNominatorRewardedPerValidator: Get<u32>;
+
+		/// The fraction of the validator set that is safe to be offending.
+		/// After the threshold is reached a new era will be forced.
+		type OffendingValidatorsThreshold: Get<Perbill>;
+
+		/// Something that provides a best-effort sorted list of voters aka electing nominators,
+		/// used for NPoS election.
+		///
+		/// The changes to nominators are reported to this. Moreover, each validator's self-vote is
+		/// also reported as one independent vote.
+		///
+		/// To keep the load off the chain as much as possible, changes made to the staked amount
+		/// via rewards and slashes are not reported and thus need to be manually fixed by the
+		/// 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.
+		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
+		/// to be introduced in a follow-up PR.
+		///
+		/// Something that provides a best-effort sorted list of targets aka electable validators,
+		/// used for NPoS election.
+		///
+		/// The changes to the approval stake of each validator are reported to this. This means any
+		/// change to:
+		/// 1. The stake of any validator or nominator.
+		/// 2. The targets of any nominator
+		/// 3. The role of any staker (e.g. validator -> chilled, nominator -> validator, etc)
+		///
+		/// Unlike `VoterList`, the values in this list are always kept up to date with reward and
+		/// slash as well, and thus represent the accurate approval stake of all account being
+		/// nominated by nominators.
+		///
+		/// Note that while at the time of nomination, all targets are checked to be real
+		/// 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.
+		type TargetList: SortedListProvider<Self::AccountId, Score = BalanceOf<Self>>;
+
+		/// The maximum number of `unlocking` chunks a [`StakingLedger`] can
+		/// have. Effectively determines how many unique eras a staker may be
+		/// unbonding in.
+		///
+		/// Note: `MaxUnlockingChunks` is used as the upper bound for the
+		/// `BoundedVec` item `StakingLedger.unlocking`. Setting this value
+		/// lower than the existing value can lead to inconsistencies in the
+		/// `StakingLedger` and will need to be handled properly in a runtime
+		/// migration. The test `reducing_max_unlocking_chunks_abrupt` shows
+		/// this effect.
+		#[pallet::constant]
+		type MaxUnlockingChunks: Get<u32>;
+
+		/// Something that listens to staking updates and performs actions based on the data it
+		/// receives.
+		///
+		/// WARNING: this only reports slashing events for the time being.
+		type EventListeners: sp_staking::OnStakingUpdate<Self::AccountId, BalanceOf<Self>>;
+
+		/// Some parameters of the benchmarking.
+		type BenchmarkingConfig: BenchmarkingConfig;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// The ideal number of active validators.
+	#[pallet::storage]
+	#[pallet::getter(fn validator_count)]
+	pub type ValidatorCount<T> = StorageValue<_, u32, ValueQuery>;
+
+	/// Minimum number of staking participants before emergency conditions are imposed.
+	#[pallet::storage]
+	#[pallet::getter(fn minimum_validator_count)]
+	pub type MinimumValidatorCount<T> = StorageValue<_, u32, ValueQuery>;
+
+	/// Any validators that may never be slashed or forcibly kicked. It's a Vec since they're
+	/// easy to initialize and the performance hit is minimal (we expect no more than four
+	/// invulnerables) and restricted to testnets.
+	#[pallet::storage]
+	#[pallet::getter(fn invulnerables)]
+	#[pallet::unbounded]
+	pub type Invulnerables<T: Config> = StorageValue<_, Vec<T::AccountId>, ValueQuery>;
+
+	/// Map from all locked "stash" accounts to the controller account.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn bonded)]
+	pub type Bonded<T: Config> = StorageMap<_, Twox64Concat, T::AccountId, T::AccountId>;
+
+	/// The minimum active bond to become and maintain the role of a nominator.
+	#[pallet::storage]
+	pub type MinNominatorBond<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
+
+	/// The minimum active bond to become and maintain the role of a validator.
+	#[pallet::storage]
+	pub type MinValidatorBond<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
+
+	/// The minimum active nominator stake of the last successful election.
+	#[pallet::storage]
+	pub type MinimumActiveStake<T> = StorageValue<_, BalanceOf<T>, ValueQuery>;
+
+	/// The minimum amount of commission that validators can set.
+	///
+	/// If set to `0`, no limit exists.
+	#[pallet::storage]
+	pub type MinCommission<T: Config> = StorageValue<_, Perbill, ValueQuery>;
+
+	/// Map from all (unlocked) "controller" accounts to the info regarding the staking.
+	#[pallet::storage]
+	#[pallet::getter(fn ledger)]
+	pub type Ledger<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, StakingLedger<T>>;
+
+	/// Where the reward payment should be made. Keyed by stash.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn payee)]
+	pub type Payee<T: Config> =
+		StorageMap<_, Twox64Concat, T::AccountId, RewardDestination<T::AccountId>, ValueQuery>;
+
+	/// The map from (wannabe) validator stash key to the preferences of that validator.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn validators)]
+	pub type Validators<T: Config> =
+		CountedStorageMap<_, Twox64Concat, T::AccountId, ValidatorPrefs, ValueQuery>;
+
+	/// The maximum validator count before we stop allowing new validators to join.
+	///
+	/// When this value is not set, no limits are enforced.
+	#[pallet::storage]
+	pub type MaxValidatorsCount<T> = StorageValue<_, u32, OptionQuery>;
+
+	/// The map from nominator stash key to their nomination preferences, namely the validators that
+	/// they wish to support.
+	///
+	/// Note that the keys of this storage map might become non-decodable in case the
+	/// account's [`NominationsQuota::MaxNominations`] configuration is decreased.
+	/// In this rare case, these nominators
+	/// are still existent in storage, their key is correct and retrievable (i.e. `contains_key`
+	/// indicates that they exist), but their value cannot be decoded. Therefore, the non-decodable
+	/// nominators will effectively not-exist, until they re-submit their preferences such that it
+	/// is within the bounds of the newly set `Config::MaxNominations`.
+	///
+	/// This implies that `::iter_keys().count()` and `::iter().count()` might return different
+	/// values for this map. Moreover, the main `::count()` is aligned with the former, namely the
+	/// number of keys that exist.
+	///
+	/// Lastly, if any of the nominators become non-decodable, they can be chilled immediately via
+	/// [`Call::chill_other`] dispatchable by anyone.
+	///
+	/// TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn nominators)]
+	pub type Nominators<T: Config> =
+		CountedStorageMap<_, Twox64Concat, T::AccountId, Nominations<T>>;
+
+	/// The maximum nominator count before we stop allowing new validators to join.
+	///
+	/// When this value is not set, no limits are enforced.
+	#[pallet::storage]
+	pub type MaxNominatorsCount<T> = StorageValue<_, u32, OptionQuery>;
+
+	/// The current era index.
+	///
+	/// This is the latest planned era, depending on how the Session pallet queues the validator
+	/// set, it might be active or not.
+	#[pallet::storage]
+	#[pallet::getter(fn current_era)]
+	pub type CurrentEra<T> = StorageValue<_, EraIndex>;
+
+	/// The active era information, it holds index and start.
+	///
+	/// The active era is the era being currently rewarded. Validator set of this era must be
+	/// equal to [`SessionInterface::validators`].
+	#[pallet::storage]
+	#[pallet::getter(fn active_era)]
+	pub type ActiveEra<T> = StorageValue<_, ActiveEraInfo>;
+
+	/// The session index at which the era start for the last `HISTORY_DEPTH` eras.
+	///
+	/// Note: This tracks the starting session (i.e. session index when era start being active)
+	/// for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.
+	#[pallet::storage]
+	#[pallet::getter(fn eras_start_session_index)]
+	pub type ErasStartSessionIndex<T> = StorageMap<_, Twox64Concat, EraIndex, SessionIndex>;
+
+	/// Exposure of validator at era.
+	///
+	/// This is keyed first by the era index to allow bulk deletion and then the stash account.
+	///
+	/// Is it removed after `HISTORY_DEPTH` eras.
+	/// If stakers hasn't been set or has been removed then empty exposure is returned.
+	#[pallet::storage]
+	#[pallet::getter(fn eras_stakers)]
+	#[pallet::unbounded]
+	pub type ErasStakers<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		EraIndex,
+		Twox64Concat,
+		T::AccountId,
+		Exposure<T::AccountId, BalanceOf<T>>,
+		ValueQuery,
+	>;
+
+	/// Clipped Exposure of validator at era.
+	///
+	/// This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the
+	/// `T::MaxNominatorRewardedPerValidator` biggest stakers.
+	/// (Note: the field `total` and `own` of the exposure remains unchanged).
+	/// This is used to limit the i/o cost for the nominator payout.
+	///
+	/// This is keyed fist by the era index to allow bulk deletion and then the stash account.
+	///
+	/// Is it removed after `HISTORY_DEPTH` eras.
+	/// If stakers hasn't been set or has been removed then empty exposure is returned.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	#[pallet::getter(fn eras_stakers_clipped)]
+	pub type ErasStakersClipped<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		EraIndex,
+		Twox64Concat,
+		T::AccountId,
+		Exposure<T::AccountId, BalanceOf<T>>,
+		ValueQuery,
+	>;
+
+	/// Similar to `ErasStakers`, this holds the preferences of validators.
+	///
+	/// This is keyed first by the era index to allow bulk deletion and then the stash account.
+	///
+	/// Is it removed after `HISTORY_DEPTH` eras.
+	// If prefs hasn't been set or has been removed then 0 commission is returned.
+	#[pallet::storage]
+	#[pallet::getter(fn eras_validator_prefs)]
+	pub type ErasValidatorPrefs<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		EraIndex,
+		Twox64Concat,
+		T::AccountId,
+		ValidatorPrefs,
+		ValueQuery,
+	>;
+
+	/// The total validator era payout for the last `HISTORY_DEPTH` eras.
+	///
+	/// Eras that haven't finished yet or has been removed doesn't have reward.
+	#[pallet::storage]
+	#[pallet::getter(fn eras_validator_reward)]
+	pub type ErasValidatorReward<T: Config> = StorageMap<_, Twox64Concat, EraIndex, BalanceOf<T>>;
+
+	/// Rewards for the last `HISTORY_DEPTH` eras.
+	/// If reward hasn't been set or has been removed then 0 reward is returned.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	#[pallet::getter(fn eras_reward_points)]
+	pub type ErasRewardPoints<T: Config> =
+		StorageMap<_, Twox64Concat, EraIndex, EraRewardPoints<T::AccountId>, ValueQuery>;
+
+	/// The total amount staked for the last `HISTORY_DEPTH` eras.
+	/// If total hasn't been set or has been removed then 0 stake is returned.
+	#[pallet::storage]
+	#[pallet::getter(fn eras_total_stake)]
+	pub type ErasTotalStake<T: Config> =
+		StorageMap<_, Twox64Concat, EraIndex, BalanceOf<T>, ValueQuery>;
+
+	/// Mode of era forcing.
+	#[pallet::storage]
+	#[pallet::getter(fn force_era)]
+	pub type ForceEra<T> = StorageValue<_, Forcing, ValueQuery>;
+
+	/// The percentage of the slash that is distributed to reporters.
+	///
+	/// The rest of the slashed value is handled by the `Slash`.
+	#[pallet::storage]
+	#[pallet::getter(fn slash_reward_fraction)]
+	pub type SlashRewardFraction<T> = StorageValue<_, Perbill, ValueQuery>;
+
+	/// The amount of currency given to reporters of a slash event which was
+	/// canceled by extraordinary circumstances (e.g. governance).
+	#[pallet::storage]
+	#[pallet::getter(fn canceled_payout)]
+	pub type CanceledSlashPayout<T: Config> = StorageValue<_, BalanceOf<T>, ValueQuery>;
+
+	/// All unapplied slashes that are queued for later.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub type UnappliedSlashes<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		EraIndex,
+		Vec<UnappliedSlash<T::AccountId, BalanceOf<T>>>,
+		ValueQuery,
+	>;
+
+	/// A mapping from still-bonded eras to the first session index of that era.
+	///
+	/// Must contains information for eras for the range:
+	/// `[active_era - bounding_duration; active_era]`
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub(crate) type BondedEras<T: Config> =
+		StorageValue<_, Vec<(EraIndex, SessionIndex)>, ValueQuery>;
+
+	/// All slashing events on validators, mapped by era to the highest slash proportion
+	/// and slash value of the era.
+	#[pallet::storage]
+	pub(crate) type ValidatorSlashInEra<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		EraIndex,
+		Twox64Concat,
+		T::AccountId,
+		(Perbill, BalanceOf<T>),
+	>;
+
+	/// All slashing events on nominators, mapped by era to the highest slash value of the era.
+	#[pallet::storage]
+	pub(crate) type NominatorSlashInEra<T: Config> =
+		StorageDoubleMap<_, Twox64Concat, EraIndex, Twox64Concat, T::AccountId, BalanceOf<T>>;
+
+	/// Slashing spans for stash accounts.
+	#[pallet::storage]
+	#[pallet::getter(fn slashing_spans)]
+	#[pallet::unbounded]
+	pub type SlashingSpans<T: Config> =
+		StorageMap<_, Twox64Concat, T::AccountId, slashing::SlashingSpans>;
+
+	/// Records information about the maximum slash of a stash within a slashing span,
+	/// as well as how much reward has been paid out.
+	#[pallet::storage]
+	pub(crate) type SpanSlash<T: Config> = StorageMap<
+		_,
+		Twox64Concat,
+		(T::AccountId, slashing::SpanIndex),
+		slashing::SpanRecord<BalanceOf<T>>,
+		ValueQuery,
+	>;
+
+	/// The last planned session scheduled by the session pallet.
+	///
+	/// This is basically in sync with the call to [`pallet_session::SessionManager::new_session`].
+	#[pallet::storage]
+	#[pallet::getter(fn current_planned_session)]
+	pub type CurrentPlannedSession<T> = StorageValue<_, SessionIndex, ValueQuery>;
+
+	/// Indices of validators that have offended in the active era and whether they are currently
+	/// disabled.
+	///
+	/// This value should be a superset of disabled validators since not all offences lead to the
+	/// validator being disabled (if there was no slash). This is needed to track the percentage of
+	/// validators that have offended in the current era, ensuring a new era is forced if
+	/// `OffendingValidatorsThreshold` is reached. The vec is always kept sorted so that we can find
+	/// whether a given validator has previously offended using binary search. It gets cleared when
+	/// the era ends.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	#[pallet::getter(fn offending_validators)]
+	pub type OffendingValidators<T: Config> = StorageValue<_, Vec<(u32, bool)>, ValueQuery>;
+
+	/// The threshold for when users can start calling `chill_other` for other validators /
+	/// nominators. The threshold is compared to the actual number of validators / nominators
+	/// (`CountFor*`) in the system compared to the configured max (`Max*Count`).
+	#[pallet::storage]
+	pub(crate) type ChillThreshold<T: Config> = StorageValue<_, Percent, OptionQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub validator_count: u32,
+		pub minimum_validator_count: u32,
+		pub invulnerables: Vec<T::AccountId>,
+		pub force_era: Forcing,
+		pub slash_reward_fraction: Perbill,
+		pub canceled_payout: BalanceOf<T>,
+		pub stakers:
+			Vec<(T::AccountId, T::AccountId, BalanceOf<T>, crate::StakerStatus<T::AccountId>)>,
+		pub min_nominator_bond: BalanceOf<T>,
+		pub min_validator_bond: BalanceOf<T>,
+		pub max_validator_count: Option<u32>,
+		pub max_nominator_count: Option<u32>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			ValidatorCount::<T>::put(self.validator_count);
+			MinimumValidatorCount::<T>::put(self.minimum_validator_count);
+			Invulnerables::<T>::put(&self.invulnerables);
+			ForceEra::<T>::put(self.force_era);
+			CanceledSlashPayout::<T>::put(self.canceled_payout);
+			SlashRewardFraction::<T>::put(self.slash_reward_fraction);
+			MinNominatorBond::<T>::put(self.min_nominator_bond);
+			MinValidatorBond::<T>::put(self.min_validator_bond);
+			if let Some(x) = self.max_validator_count {
+				MaxValidatorsCount::<T>::put(x);
+			}
+			if let Some(x) = self.max_nominator_count {
+				MaxNominatorsCount::<T>::put(x);
+			}
+
+			for &(ref stash, _, balance, ref status) in &self.stakers {
+				crate::log!(
+					trace,
+					"inserting genesis staker: {:?} => {:?} => {:?}",
+					stash,
+					balance,
+					status
+				);
+				assert!(
+					T::Currency::free_balance(stash) >= balance,
+					"Stash does not have enough balance to bond."
+				);
+				frame_support::assert_ok!(<Pallet<T>>::bond(
+					T::RuntimeOrigin::from(Some(stash.clone()).into()),
+					balance,
+					RewardDestination::Staked,
+				));
+				frame_support::assert_ok!(match status {
+					crate::StakerStatus::Validator => <Pallet<T>>::validate(
+						T::RuntimeOrigin::from(Some(stash.clone()).into()),
+						Default::default(),
+					),
+					crate::StakerStatus::Nominator(votes) => <Pallet<T>>::nominate(
+						T::RuntimeOrigin::from(Some(stash.clone()).into()),
+						votes.iter().map(|l| T::Lookup::unlookup(l.clone())).collect(),
+					),
+					_ => Ok(()),
+				});
+				assert!(
+					ValidatorCount::<T>::get() <=
+						<T::ElectionProvider as ElectionProviderBase>::MaxWinners::get()
+				);
+			}
+
+			// all voters are reported to the `VoterList`.
+			assert_eq!(
+				T::VoterList::count(),
+				Nominators::<T>::count() + Validators::<T>::count(),
+				"not all genesis stakers were inserted into sorted list provider, something is wrong."
+			);
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(crate) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// The era payout has been set; the first balance is the validator-payout; the second is
+		/// the remainder from the maximum amount of reward.
+		EraPaid { era_index: EraIndex, validator_payout: BalanceOf<T>, remainder: BalanceOf<T> },
+		/// The nominator has been rewarded by this amount.
+		Rewarded { stash: T::AccountId, amount: BalanceOf<T> },
+		/// A staker (validator or nominator) has been slashed by the given amount.
+		Slashed { staker: T::AccountId, amount: BalanceOf<T> },
+		/// A slash for the given validator, for the given percentage of their stake, at the given
+		/// era as been reported.
+		SlashReported { validator: T::AccountId, fraction: Perbill, slash_era: EraIndex },
+		/// An old slashing report from a prior era was discarded because it could
+		/// not be processed.
+		OldSlashingReportDiscarded { session_index: SessionIndex },
+		/// A new set of stakers was elected.
+		StakersElected,
+		/// An account has bonded this amount. \[stash, amount\]
+		///
+		/// NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,
+		/// it will not be emitted for staking rewards when they are added to stake.
+		Bonded { stash: T::AccountId, amount: BalanceOf<T> },
+		/// An account has unbonded this amount.
+		Unbonded { stash: T::AccountId, amount: BalanceOf<T> },
+		/// An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`
+		/// from the unlocking queue.
+		Withdrawn { stash: T::AccountId, amount: BalanceOf<T> },
+		/// A nominator has been kicked from a validator.
+		Kicked { nominator: T::AccountId, stash: T::AccountId },
+		/// The election failed. No new era is planned.
+		StakingElectionFailed,
+		/// An account has stopped participating as either a validator or nominator.
+		Chilled { stash: T::AccountId },
+		/// The stakers' rewards are getting paid.
+		PayoutStarted { era_index: EraIndex, validator_stash: T::AccountId },
+		/// A validator has set their preferences.
+		ValidatorPrefsSet { stash: T::AccountId, prefs: ValidatorPrefs },
+		/// Voters size limit reached.
+		SnapshotVotersSizeExceeded { size: u32 },
+		/// Targets size limit reached.
+		SnapshotTargetsSizeExceeded { size: u32 },
+		/// A new force era mode was set.
+		ForceEra { mode: Forcing },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Not a controller account.
+		NotController,
+		/// Not a stash account.
+		NotStash,
+		/// Stash is already bonded.
+		AlreadyBonded,
+		/// Controller is already paired.
+		AlreadyPaired,
+		/// Targets cannot be empty.
+		EmptyTargets,
+		/// Duplicate index.
+		DuplicateIndex,
+		/// Slash record index out of bounds.
+		InvalidSlashIndex,
+		/// Cannot have a validator or nominator role, with value less than the minimum defined by
+		/// governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the
+		/// intention, `chill` first to remove one's role as validator/nominator.
+		InsufficientBond,
+		/// Can not schedule more unlock chunks.
+		NoMoreChunks,
+		/// Can not rebond without unlocking chunks.
+		NoUnlockChunk,
+		/// Attempting to target a stash that still has funds.
+		FundedTarget,
+		/// Invalid era to reward.
+		InvalidEraToReward,
+		/// Invalid number of nominations.
+		InvalidNumberOfNominations,
+		/// Items are not sorted and unique.
+		NotSortedAndUnique,
+		/// Rewards for this era have already been claimed for this validator.
+		AlreadyClaimed,
+		/// Incorrect previous history depth input provided.
+		IncorrectHistoryDepth,
+		/// Incorrect number of slashing spans provided.
+		IncorrectSlashingSpans,
+		/// Internal state has become somehow corrupted and the operation cannot continue.
+		BadState,
+		/// Too many nomination targets supplied.
+		TooManyTargets,
+		/// A nomination target was supplied that was blocked or otherwise not a validator.
+		BadTarget,
+		/// The user has enough bond and thus cannot be chilled forcefully by an external person.
+		CannotChillOther,
+		/// There are too many nominators in the system. Governance needs to adjust the staking
+		/// settings to keep things safe for the runtime.
+		TooManyNominators,
+		/// There are too many validator candidates in the system. Governance needs to adjust the
+		/// staking settings to keep things safe for the runtime.
+		TooManyValidators,
+		/// Commission is too low. Must be at least `MinCommission`.
+		CommissionTooLow,
+		/// Some bound is not met.
+		BoundNotMet,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_now: BlockNumberFor<T>) -> Weight {
+			// just return the weight of the on_finalize.
+			T::DbWeight::get().reads(1)
+		}
+
+		fn on_finalize(_n: BlockNumberFor<T>) {
+			// Set the start of the first era.
+			if let Some(mut active_era) = Self::active_era() {
+				if active_era.start.is_none() {
+					let now_as_millis_u64 = T::UnixTime::now().as_millis().saturated_into::<u64>();
+					active_era.start = Some(now_as_millis_u64);
+					// This write only ever happens once, we don't include it in the weight in
+					// general
+					ActiveEra::<T>::put(active_era);
+				}
+			}
+			// `on_finalize` weight is tracked in `on_initialize`
+		}
+
+		fn integrity_test() {
+			// ensure that we funnel the correct value to the `DataProvider::MaxVotesPerVoter`;
+			assert_eq!(
+				MaxNominationsOf::<T>::get(),
+				<Self as ElectionDataProvider>::MaxVotesPerVoter::get()
+			);
+			// and that MaxNominations is always greater than 1, since we count on this.
+			assert!(!MaxNominationsOf::<T>::get().is_zero());
+
+			// ensure election results are always bounded with the same value
+			assert!(
+				<T::ElectionProvider as ElectionProviderBase>::MaxWinners::get() ==
+					<T::GenesisElectionProvider as ElectionProviderBase>::MaxWinners::get()
+			);
+
+			assert!(
+				T::SlashDeferDuration::get() < T::BondingDuration::get() || T::BondingDuration::get() == 0,
+				"As per documentation, slash defer duration ({}) should be less than bonding duration ({}).",
+				T::SlashDeferDuration::get(),
+				T::BondingDuration::get(),
+			)
+		}
+
+		#[cfg(feature = "try-runtime")]
+		fn try_state(n: BlockNumberFor<T>) -> Result<(), sp_runtime::TryRuntimeError> {
+			Self::do_try_state(n)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Take the origin account as a stash and lock up `value` of its balance. `controller` will
+		/// be the account that controls it.
+		///
+		/// `value` must be more than the `minimum_balance` specified by `T::Currency`.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the stash account.
+		///
+		/// Emits `Bonded`.
+		/// ## Complexity
+		/// - Independent of the arguments. Moderate complexity.
+		/// - O(1).
+		/// - Three extra DB entries.
+		///
+		/// NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleaned
+		/// unless the `origin` falls below _existential deposit_ and gets removed as dust.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::bond())]
+		pub fn bond(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+			payee: RewardDestination<T::AccountId>,
+		) -> DispatchResult {
+			let stash = ensure_signed(origin)?;
+			let controller_to_be_deprecated = stash.clone();
+
+			if <Bonded<T>>::contains_key(&stash) {
+				return Err(Error::<T>::AlreadyBonded.into())
+			}
+
+			if <Ledger<T>>::contains_key(&controller_to_be_deprecated) {
+				return Err(Error::<T>::AlreadyPaired.into())
+			}
+
+			// Reject a bond which is considered to be _dust_.
+			if value < T::Currency::minimum_balance() {
+				return Err(Error::<T>::InsufficientBond.into())
+			}
+
+			frame_system::Pallet::<T>::inc_consumers(&stash).map_err(|_| Error::<T>::BadState)?;
+
+			// You're auto-bonded forever, here. We might improve this by only bonding when
+			// you actually validate/nominate and remove once you unbond __everything__.
+			<Bonded<T>>::insert(&stash, &stash);
+			<Payee<T>>::insert(&stash, payee);
+
+			let current_era = CurrentEra::<T>::get().unwrap_or(0);
+			let history_depth = T::HistoryDepth::get();
+			let last_reward_era = current_era.saturating_sub(history_depth);
+
+			let stash_balance = T::Currency::free_balance(&stash);
+			let value = value.min(stash_balance);
+			Self::deposit_event(Event::<T>::Bonded { stash: stash.clone(), amount: value });
+			let item = StakingLedger {
+				stash: stash.clone(),
+				total: value,
+				active: value,
+				unlocking: Default::default(),
+				claimed_rewards: (last_reward_era..current_era)
+					.try_collect()
+					// Since last_reward_era is calculated as `current_era -
+					// HistoryDepth`, following bound is always expected to be
+					// satisfied.
+					.defensive_map_err(|_| Error::<T>::BoundNotMet)?,
+			};
+			Self::update_ledger(&controller_to_be_deprecated, &item);
+			Ok(())
+		}
+
+		/// Add some extra amount that have appeared in the stash `free_balance` into the balance up
+		/// for staking.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the stash, not the controller.
+		///
+		/// Use this if there are additional funds in your stash account that you wish to bond.
+		/// Unlike [`bond`](Self::bond) or [`unbond`](Self::unbond) this function does not impose
+		/// any limitation on the amount that can be added.
+		///
+		/// Emits `Bonded`.
+		///
+		/// ## Complexity
+		/// - Independent of the arguments. Insignificant complexity.
+		/// - O(1).
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::bond_extra())]
+		pub fn bond_extra(
+			origin: OriginFor<T>,
+			#[pallet::compact] max_additional: BalanceOf<T>,
+		) -> DispatchResult {
+			let stash = ensure_signed(origin)?;
+
+			let controller = Self::bonded(&stash).ok_or(Error::<T>::NotStash)?;
+			let mut ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+
+			let stash_balance = T::Currency::free_balance(&stash);
+			if let Some(extra) = stash_balance.checked_sub(&ledger.total) {
+				let extra = extra.min(max_additional);
+				ledger.total += extra;
+				ledger.active += extra;
+				// Last check: the new active amount of ledger must be more than ED.
+				ensure!(
+					ledger.active >= T::Currency::minimum_balance(),
+					Error::<T>::InsufficientBond
+				);
+
+				// NOTE: ledger must be updated prior to calling `Self::weight_of`.
+				Self::update_ledger(&controller, &ledger);
+				// update this staker in the sorted list, if they exist in it.
+				if T::VoterList::contains(&stash) {
+					let _ =
+						T::VoterList::on_update(&stash, Self::weight_of(&ledger.stash)).defensive();
+				}
+
+				Self::deposit_event(Event::<T>::Bonded { stash, amount: extra });
+			}
+			Ok(())
+		}
+
+		/// Schedule a portion of the stash to be unlocked ready for transfer out after the bond
+		/// period ends. If this leaves an amount actively bonded less than
+		/// T::Currency::minimum_balance(), then it is increased to the full amount.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+		///
+		/// Once the unlock period is done, you can call `withdraw_unbonded` to actually move
+		/// the funds out of management ready for transfer.
+		///
+		/// No more than a limited number of unlocking chunks (see `MaxUnlockingChunks`)
+		/// can co-exists at the same time. If there are no unlocking chunks slots available
+		/// [`Call::withdraw_unbonded`] is called to remove some of the chunks (if possible).
+		///
+		/// If a user encounters the `InsufficientBond` error when calling this extrinsic,
+		/// they should call `chill` first in order to free up their bonded funds.
+		///
+		/// Emits `Unbonded`.
+		///
+		/// See also [`Call::withdraw_unbonded`].
+		#[pallet::call_index(2)]
+		#[pallet::weight(
+            T::WeightInfo::withdraw_unbonded_kill(SPECULATIVE_NUM_SPANS).saturating_add(T::WeightInfo::unbond()))
+        ]
+		pub fn unbond(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let controller = ensure_signed(origin)?;
+			let unlocking = Self::ledger(&controller)
+				.map(|l| l.unlocking.len())
+				.ok_or(Error::<T>::NotController)?;
+
+			// if there are no unlocking chunks available, try to withdraw chunks older than
+			// `BondingDuration` to proceed with the unbonding.
+			let maybe_withdraw_weight = {
+				if unlocking == T::MaxUnlockingChunks::get() as usize {
+					let real_num_slashing_spans =
+						Self::slashing_spans(&controller).map_or(0, |s| s.iter().count());
+					Some(Self::do_withdraw_unbonded(&controller, real_num_slashing_spans as u32)?)
+				} else {
+					None
+				}
+			};
+
+			// we need to fetch the ledger again because it may have been mutated in the call
+			// to `Self::do_withdraw_unbonded` above.
+			let mut ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			let mut value = value.min(ledger.active);
+
+			ensure!(
+				ledger.unlocking.len() < T::MaxUnlockingChunks::get() as usize,
+				Error::<T>::NoMoreChunks,
+			);
+
+			if !value.is_zero() {
+				ledger.active -= value;
+
+				// Avoid there being a dust balance left in the staking system.
+				if ledger.active < T::Currency::minimum_balance() {
+					value += ledger.active;
+					ledger.active = Zero::zero();
+				}
+
+				let min_active_bond = if Nominators::<T>::contains_key(&ledger.stash) {
+					MinNominatorBond::<T>::get()
+				} else if Validators::<T>::contains_key(&ledger.stash) {
+					MinValidatorBond::<T>::get()
+				} else {
+					Zero::zero()
+				};
+
+				// Make sure that the user maintains enough active bond for their role.
+				// If a user runs into this error, they should chill first.
+				ensure!(ledger.active >= min_active_bond, Error::<T>::InsufficientBond);
+
+				// Note: in case there is no current era it is fine to bond one era more.
+				let era = Self::current_era().unwrap_or(0) + T::BondingDuration::get();
+				if let Some(chunk) = ledger.unlocking.last_mut().filter(|chunk| chunk.era == era) {
+					// To keep the chunk count down, we only keep one chunk per era. Since
+					// `unlocking` is a FiFo queue, if a chunk exists for `era` we know that it will
+					// be the last one.
+					chunk.value = chunk.value.defensive_saturating_add(value)
+				} else {
+					ledger
+						.unlocking
+						.try_push(UnlockChunk { value, era })
+						.map_err(|_| Error::<T>::NoMoreChunks)?;
+				};
+				// NOTE: ledger must be updated prior to calling `Self::weight_of`.
+				Self::update_ledger(&controller, &ledger);
+
+				// update this staker in the sorted list, if they exist in it.
+				if T::VoterList::contains(&ledger.stash) {
+					let _ = T::VoterList::on_update(&ledger.stash, Self::weight_of(&ledger.stash))
+						.defensive();
+				}
+
+				Self::deposit_event(Event::<T>::Unbonded { stash: ledger.stash, amount: value });
+			}
+
+			let actual_weight = if let Some(withdraw_weight) = maybe_withdraw_weight {
+				Some(T::WeightInfo::unbond().saturating_add(withdraw_weight))
+			} else {
+				Some(T::WeightInfo::unbond())
+			};
+
+			Ok(actual_weight.into())
+		}
+
+		/// Remove any unlocked chunks from the `unlocking` queue from our management.
+		///
+		/// This essentially frees up that balance to be used by the stash account to do whatever
+		/// it wants.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the controller.
+		///
+		/// Emits `Withdrawn`.
+		///
+		/// See also [`Call::unbond`].
+		///
+		/// ## Parameters
+		///
+		/// - `num_slashing_spans` indicates the number of metadata slashing spans to clear when
+		/// this call results in a complete removal of all the data related to the stash account.
+		/// In this case, the `num_slashing_spans` must be larger or equal to the number of
+		/// slashing spans associated with the stash account in the [`SlashingSpans`] storage type,
+		/// otherwise the call will fail. The call weight is directly propotional to
+		/// `num_slashing_spans`.
+		///
+		/// ## Complexity
+		/// O(S) where S is the number of slashing spans to remove
+		/// NOTE: Weight annotation is the kill scenario, we refund otherwise.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::withdraw_unbonded_kill(*num_slashing_spans))]
+		pub fn withdraw_unbonded(
+			origin: OriginFor<T>,
+			num_slashing_spans: u32,
+		) -> DispatchResultWithPostInfo {
+			let controller = ensure_signed(origin)?;
+
+			let actual_weight = Self::do_withdraw_unbonded(&controller, num_slashing_spans)?;
+			Ok(Some(actual_weight).into())
+		}
+
+		/// Declare the desire to validate for the origin controller.
+		///
+		/// Effects will be felt at the beginning of the next era.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::validate())]
+		pub fn validate(origin: OriginFor<T>, prefs: ValidatorPrefs) -> DispatchResult {
+			let controller = ensure_signed(origin)?;
+
+			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+
+			ensure!(ledger.active >= MinValidatorBond::<T>::get(), Error::<T>::InsufficientBond);
+			let stash = &ledger.stash;
+
+			// ensure their commission is correct.
+			ensure!(prefs.commission >= MinCommission::<T>::get(), Error::<T>::CommissionTooLow);
+
+			// Only check limits if they are not already a validator.
+			if !Validators::<T>::contains_key(stash) {
+				// If this error is reached, we need to adjust the `MinValidatorBond` and start
+				// calling `chill_other`. Until then, we explicitly block new validators to protect
+				// the runtime.
+				if let Some(max_validators) = MaxValidatorsCount::<T>::get() {
+					ensure!(
+						Validators::<T>::count() < max_validators,
+						Error::<T>::TooManyValidators
+					);
+				}
+			}
+
+			Self::do_remove_nominator(stash);
+			Self::do_add_validator(stash, prefs.clone());
+			Self::deposit_event(Event::<T>::ValidatorPrefsSet { stash: ledger.stash, prefs });
+
+			Ok(())
+		}
+
+		/// Declare the desire to nominate `targets` for the origin controller.
+		///
+		/// Effects will be felt at the beginning of the next era.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+		///
+		/// ## Complexity
+		/// - The transaction's complexity is proportional to the size of `targets` (N)
+		/// which is capped at CompactAssignments::LIMIT (T::MaxNominations).
+		/// - Both the reads and writes follow a similar pattern.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::nominate(targets.len() as u32))]
+		pub fn nominate(
+			origin: OriginFor<T>,
+			targets: Vec<AccountIdLookupOf<T>>,
+		) -> DispatchResult {
+			let controller = ensure_signed(origin)?;
+
+			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			ensure!(ledger.active >= MinNominatorBond::<T>::get(), Error::<T>::InsufficientBond);
+			let stash = &ledger.stash;
+
+			// Only check limits if they are not already a nominator.
+			if !Nominators::<T>::contains_key(stash) {
+				// If this error is reached, we need to adjust the `MinNominatorBond` and start
+				// calling `chill_other`. Until then, we explicitly block new nominators to protect
+				// the runtime.
+				if let Some(max_nominators) = MaxNominatorsCount::<T>::get() {
+					ensure!(
+						Nominators::<T>::count() < max_nominators,
+						Error::<T>::TooManyNominators
+					);
+				}
+			}
+
+			ensure!(!targets.is_empty(), Error::<T>::EmptyTargets);
+			ensure!(
+				targets.len() <= T::NominationsQuota::get_quota(ledger.active) as usize,
+				Error::<T>::TooManyTargets
+			);
+
+			let old = Nominators::<T>::get(stash).map_or_else(Vec::new, |x| x.targets.into_inner());
+
+			let targets: BoundedVec<_, _> = targets
+				.into_iter()
+				.map(|t| T::Lookup::lookup(t).map_err(DispatchError::from))
+				.map(|n| {
+					n.and_then(|n| {
+						if old.contains(&n) || !Validators::<T>::get(&n).blocked {
+							Ok(n)
+						} else {
+							Err(Error::<T>::BadTarget.into())
+						}
+					})
+				})
+				.collect::<Result<Vec<_>, _>>()?
+				.try_into()
+				.map_err(|_| Error::<T>::TooManyNominators)?;
+
+			let nominations = Nominations {
+				targets,
+				// Initial nominations are considered submitted at era 0. See `Nominations` doc.
+				submitted_in: Self::current_era().unwrap_or(0),
+				suppressed: false,
+			};
+
+			Self::do_remove_validator(stash);
+			Self::do_add_nominator(stash, nominations);
+			Ok(())
+		}
+
+		/// Declare no desire to either validate or nominate.
+		///
+		/// Effects will be felt at the beginning of the next era.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+		///
+		/// ## Complexity
+		/// - Independent of the arguments. Insignificant complexity.
+		/// - Contains one read.
+		/// - Writes are limited to the `origin` account key.
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::chill())]
+		pub fn chill(origin: OriginFor<T>) -> DispatchResult {
+			let controller = ensure_signed(origin)?;
+			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			Self::chill_stash(&ledger.stash);
+			Ok(())
+		}
+
+		/// (Re-)set the payment target for a controller.
+		///
+		/// Effects will be felt instantly (as soon as this function is completed successfully).
+		///
+		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+		///
+		/// ## Complexity
+		/// - O(1)
+		/// - Independent of the arguments. Insignificant complexity.
+		/// - Contains a limited number of reads.
+		/// - Writes are limited to the `origin` account key.
+		/// ---------
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::set_payee())]
+		pub fn set_payee(
+			origin: OriginFor<T>,
+			payee: RewardDestination<T::AccountId>,
+		) -> DispatchResult {
+			let controller = ensure_signed(origin)?;
+			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			let stash = &ledger.stash;
+			<Payee<T>>::insert(stash, payee);
+			Ok(())
+		}
+
+		/// (Re-)sets the controller of a stash to the stash itself. This function previously
+		/// accepted a `controller` argument to set the controller to an account other than the
+		/// stash itself. This functionality has now been removed, now only setting the controller
+		/// to the stash, if it is not already.
+		///
+		/// Effects will be felt instantly (as soon as this function is completed successfully).
+		///
+		/// The dispatch origin for this call must be _Signed_ by the stash, not the controller.
+		///
+		/// ## Complexity
+		/// O(1)
+		/// - Independent of the arguments. Insignificant complexity.
+		/// - Contains a limited number of reads.
+		/// - Writes are limited to the `origin` account key.
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::set_controller())]
+		pub fn set_controller(origin: OriginFor<T>) -> DispatchResult {
+			let stash = ensure_signed(origin)?;
+			let old_controller = Self::bonded(&stash).ok_or(Error::<T>::NotStash)?;
+
+			if <Ledger<T>>::contains_key(&stash) {
+				return Err(Error::<T>::AlreadyPaired.into())
+			}
+			if old_controller != stash {
+				<Bonded<T>>::insert(&stash, &stash);
+				if let Some(l) = <Ledger<T>>::take(&old_controller) {
+					<Ledger<T>>::insert(&stash, l);
+				}
+			}
+			Ok(())
+		}
+
+		/// Sets the ideal number of validators.
+		///
+		/// The dispatch origin must be Root.
+		///
+		/// ## Complexity
+		/// O(1)
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::set_validator_count())]
+		pub fn set_validator_count(
+			origin: OriginFor<T>,
+			#[pallet::compact] new: u32,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			// ensure new validator count does not exceed maximum winners
+			// support by election provider.
+			ensure!(
+				new <= <T::ElectionProvider as ElectionProviderBase>::MaxWinners::get(),
+				Error::<T>::TooManyValidators
+			);
+			ValidatorCount::<T>::put(new);
+			Ok(())
+		}
+
+		/// Increments the ideal number of validators upto maximum of
+		/// `ElectionProviderBase::MaxWinners`.
+		///
+		/// The dispatch origin must be Root.
+		///
+		/// ## Complexity
+		/// Same as [`Self::set_validator_count`].
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::set_validator_count())]
+		pub fn increase_validator_count(
+			origin: OriginFor<T>,
+			#[pallet::compact] additional: u32,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let old = ValidatorCount::<T>::get();
+			let new = old.checked_add(additional).ok_or(ArithmeticError::Overflow)?;
+			ensure!(
+				new <= <T::ElectionProvider as ElectionProviderBase>::MaxWinners::get(),
+				Error::<T>::TooManyValidators
+			);
+
+			ValidatorCount::<T>::put(new);
+			Ok(())
+		}
+
+		/// Scale up the ideal number of validators by a factor upto maximum of
+		/// `ElectionProviderBase::MaxWinners`.
+		///
+		/// The dispatch origin must be Root.
+		///
+		/// ## Complexity
+		/// Same as [`Self::set_validator_count`].
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::set_validator_count())]
+		pub fn scale_validator_count(origin: OriginFor<T>, factor: Percent) -> DispatchResult {
+			ensure_root(origin)?;
+			let old = ValidatorCount::<T>::get();
+			let new = old.checked_add(factor.mul_floor(old)).ok_or(ArithmeticError::Overflow)?;
+
+			ensure!(
+				new <= <T::ElectionProvider as ElectionProviderBase>::MaxWinners::get(),
+				Error::<T>::TooManyValidators
+			);
+
+			ValidatorCount::<T>::put(new);
+			Ok(())
+		}
+
+		/// Force there to be no new eras indefinitely.
+		///
+		/// The dispatch origin must be Root.
+		///
+		/// # Warning
+		///
+		/// The election process starts multiple blocks before the end of the era.
+		/// Thus the election process may be ongoing when this is called. In this case the
+		/// election will continue until the next era is triggered.
+		///
+		/// ## Complexity
+		/// - No arguments.
+		/// - Weight: O(1)
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::force_no_eras())]
+		pub fn force_no_eras(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::set_force_era(Forcing::ForceNone);
+			Ok(())
+		}
+
+		/// Force there to be a new era at the end of the next session. After this, it will be
+		/// reset to normal (non-forced) behaviour.
+		///
+		/// The dispatch origin must be Root.
+		///
+		/// # Warning
+		///
+		/// The election process starts multiple blocks before the end of the era.
+		/// If this is called just before a new era is triggered, the election process may not
+		/// have enough blocks to get a result.
+		///
+		/// ## Complexity
+		/// - No arguments.
+		/// - Weight: O(1)
+		#[pallet::call_index(13)]
+		#[pallet::weight(T::WeightInfo::force_new_era())]
+		pub fn force_new_era(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::set_force_era(Forcing::ForceNew);
+			Ok(())
+		}
+
+		/// Set the validators who cannot be slashed (if any).
+		///
+		/// The dispatch origin must be Root.
+		#[pallet::call_index(14)]
+		#[pallet::weight(T::WeightInfo::set_invulnerables(invulnerables.len() as u32))]
+		pub fn set_invulnerables(
+			origin: OriginFor<T>,
+			invulnerables: Vec<T::AccountId>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			<Invulnerables<T>>::put(invulnerables);
+			Ok(())
+		}
+
+		/// Force a current staker to become completely unstaked, immediately.
+		///
+		/// The dispatch origin must be Root.
+		///
+		/// ## Parameters
+		///
+		/// - `num_slashing_spans`: Refer to comments on [`Call::withdraw_unbonded`] for more
+		/// details.
+		#[pallet::call_index(15)]
+		#[pallet::weight(T::WeightInfo::force_unstake(*num_slashing_spans))]
+		pub fn force_unstake(
+			origin: OriginFor<T>,
+			stash: T::AccountId,
+			num_slashing_spans: u32,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			// Remove all staking-related information.
+			Self::kill_stash(&stash, num_slashing_spans)?;
+
+			// Remove the lock.
+			T::Currency::remove_lock(STAKING_ID, &stash);
+			Ok(())
+		}
+
+		/// Force there to be a new era at the end of sessions indefinitely.
+		///
+		/// The dispatch origin must be Root.
+		///
+		/// # Warning
+		///
+		/// The election process starts multiple blocks before the end of the era.
+		/// If this is called just before a new era is triggered, the election process may not
+		/// have enough blocks to get a result.
+		#[pallet::call_index(16)]
+		#[pallet::weight(T::WeightInfo::force_new_era_always())]
+		pub fn force_new_era_always(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::set_force_era(Forcing::ForceAlways);
+			Ok(())
+		}
+
+		/// Cancel enactment of a deferred slash.
+		///
+		/// Can be called by the `T::AdminOrigin`.
+		///
+		/// Parameters: era and indices of the slashes for that era to kill.
+		#[pallet::call_index(17)]
+		#[pallet::weight(T::WeightInfo::cancel_deferred_slash(slash_indices.len() as u32))]
+		pub fn cancel_deferred_slash(
+			origin: OriginFor<T>,
+			era: EraIndex,
+			slash_indices: Vec<u32>,
+		) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+
+			ensure!(!slash_indices.is_empty(), Error::<T>::EmptyTargets);
+			ensure!(is_sorted_and_unique(&slash_indices), Error::<T>::NotSortedAndUnique);
+
+			let mut unapplied = UnappliedSlashes::<T>::get(&era);
+			let last_item = slash_indices[slash_indices.len() - 1];
+			ensure!((last_item as usize) < unapplied.len(), Error::<T>::InvalidSlashIndex);
+
+			for (removed, index) in slash_indices.into_iter().enumerate() {
+				let index = (index as usize) - removed;
+				unapplied.remove(index);
+			}
+
+			UnappliedSlashes::<T>::insert(&era, &unapplied);
+			Ok(())
+		}
+
+		/// Pay out all the stakers behind a single validator for a single era.
+		///
+		/// - `validator_stash` is the stash account of the validator. Their nominators, up to
+		///   `T::MaxNominatorRewardedPerValidator`, will also receive their rewards.
+		/// - `era` may be any era between `[current_era - history_depth; current_era]`.
+		///
+		/// The origin of this call must be _Signed_. Any account can call this function, even if
+		/// it is not one of the stakers.
+		///
+		/// ## Complexity
+		/// - At most O(MaxNominatorRewardedPerValidator).
+		#[pallet::call_index(18)]
+		#[pallet::weight(T::WeightInfo::payout_stakers_alive_staked(
+			T::MaxNominatorRewardedPerValidator::get()
+		))]
+		pub fn payout_stakers(
+			origin: OriginFor<T>,
+			validator_stash: T::AccountId,
+			era: EraIndex,
+		) -> DispatchResultWithPostInfo {
+			ensure_signed(origin)?;
+			Self::do_payout_stakers(validator_stash, era)
+		}
+
+		/// Rebond a portion of the stash scheduled to be unlocked.
+		///
+		/// The dispatch origin must be signed by the controller.
+		///
+		/// ## Complexity
+		/// - Time complexity: O(L), where L is unlocking chunks
+		/// - Bounded by `MaxUnlockingChunks`.
+		#[pallet::call_index(19)]
+		#[pallet::weight(T::WeightInfo::rebond(T::MaxUnlockingChunks::get() as u32))]
+		pub fn rebond(
+			origin: OriginFor<T>,
+			#[pallet::compact] value: BalanceOf<T>,
+		) -> DispatchResultWithPostInfo {
+			let controller = ensure_signed(origin)?;
+			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			ensure!(!ledger.unlocking.is_empty(), Error::<T>::NoUnlockChunk);
+
+			let initial_unlocking = ledger.unlocking.len() as u32;
+			let (ledger, rebonded_value) = ledger.rebond(value);
+			// Last check: the new active amount of ledger must be more than ED.
+			ensure!(ledger.active >= T::Currency::minimum_balance(), Error::<T>::InsufficientBond);
+
+			Self::deposit_event(Event::<T>::Bonded {
+				stash: ledger.stash.clone(),
+				amount: rebonded_value,
+			});
+
+			// NOTE: ledger must be updated prior to calling `Self::weight_of`.
+			Self::update_ledger(&controller, &ledger);
+			if T::VoterList::contains(&ledger.stash) {
+				let _ = T::VoterList::on_update(&ledger.stash, Self::weight_of(&ledger.stash))
+					.defensive();
+			}
+
+			let removed_chunks = 1u32 // for the case where the last iterated chunk is not removed
+				.saturating_add(initial_unlocking)
+				.saturating_sub(ledger.unlocking.len() as u32);
+			Ok(Some(T::WeightInfo::rebond(removed_chunks)).into())
+		}
+
+		/// Remove all data structures concerning a staker/stash once it is at a state where it can
+		/// be considered `dust` in the staking system. The requirements are:
+		///
+		/// 1. the `total_balance` of the stash is below existential deposit.
+		/// 2. or, the `ledger.total` of the stash is below existential deposit.
+		///
+		/// The former can happen in cases like a slash; the latter when a fully unbonded account
+		/// is still receiving staking rewards in `RewardDestination::Staked`.
+		///
+		/// It can be called by anyone, as long as `stash` meets the above requirements.
+		///
+		/// Refunds the transaction fees upon successful execution.
+		///
+		/// ## Parameters
+		///
+		/// - `num_slashing_spans`: Refer to comments on [`Call::withdraw_unbonded`] for more
+		/// details.
+		#[pallet::call_index(20)]
+		#[pallet::weight(T::WeightInfo::reap_stash(*num_slashing_spans))]
+		pub fn reap_stash(
+			origin: OriginFor<T>,
+			stash: T::AccountId,
+			num_slashing_spans: u32,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+
+			let ed = T::Currency::minimum_balance();
+			let reapable = T::Currency::total_balance(&stash) < ed ||
+				Self::ledger(Self::bonded(stash.clone()).ok_or(Error::<T>::NotStash)?)
+					.map(|l| l.total)
+					.unwrap_or_default() < ed;
+			ensure!(reapable, Error::<T>::FundedTarget);
+
+			Self::kill_stash(&stash, num_slashing_spans)?;
+			T::Currency::remove_lock(STAKING_ID, &stash);
+
+			Ok(Pays::No.into())
+		}
+
+		/// Remove the given nominations from the calling validator.
+		///
+		/// Effects will be felt at the beginning of the next era.
+		///
+		/// The dispatch origin for this call must be _Signed_ by the controller, not the stash.
+		///
+		/// - `who`: A list of nominator stash accounts who are nominating this validator which
+		///   should no longer be nominating this validator.
+		///
+		/// Note: Making this call only makes sense if you first set the validator preferences to
+		/// block any further nominations.
+		#[pallet::call_index(21)]
+		#[pallet::weight(T::WeightInfo::kick(who.len() as u32))]
+		pub fn kick(origin: OriginFor<T>, who: Vec<AccountIdLookupOf<T>>) -> DispatchResult {
+			let controller = ensure_signed(origin)?;
+			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			let stash = &ledger.stash;
+
+			for nom_stash in who
+				.into_iter()
+				.map(T::Lookup::lookup)
+				.collect::<Result<Vec<T::AccountId>, _>>()?
+				.into_iter()
+			{
+				Nominators::<T>::mutate(&nom_stash, |maybe_nom| {
+					if let Some(ref mut nom) = maybe_nom {
+						if let Some(pos) = nom.targets.iter().position(|v| v == stash) {
+							nom.targets.swap_remove(pos);
+							Self::deposit_event(Event::<T>::Kicked {
+								nominator: nom_stash.clone(),
+								stash: stash.clone(),
+							});
+						}
+					}
+				});
+			}
+
+			Ok(())
+		}
+
+		/// Update the various staking configurations .
+		///
+		/// * `min_nominator_bond`: The minimum active bond needed to be a nominator.
+		/// * `min_validator_bond`: The minimum active bond needed to be a validator.
+		/// * `max_nominator_count`: The max number of users who can be a nominator at once. When
+		///   set to `None`, no limit is enforced.
+		/// * `max_validator_count`: The max number of users who can be a validator at once. When
+		///   set to `None`, no limit is enforced.
+		/// * `chill_threshold`: The ratio of `max_nominator_count` or `max_validator_count` which
+		///   should be filled in order for the `chill_other` transaction to work.
+		/// * `min_commission`: The minimum amount of commission that each validators must maintain.
+		///   This is checked only upon calling `validate`. Existing validators are not affected.
+		///
+		/// RuntimeOrigin must be Root to call this function.
+		///
+		/// NOTE: Existing nominators and validators will not be affected by this update.
+		/// to kick people under the new limits, `chill_other` should be called.
+		// We assume the worst case for this call is either: all items are set or all items are
+		// removed.
+		#[pallet::call_index(22)]
+		#[pallet::weight(
+			T::WeightInfo::set_staking_configs_all_set()
+				.max(T::WeightInfo::set_staking_configs_all_remove())
+		)]
+		pub fn set_staking_configs(
+			origin: OriginFor<T>,
+			min_nominator_bond: ConfigOp<BalanceOf<T>>,
+			min_validator_bond: ConfigOp<BalanceOf<T>>,
+			max_nominator_count: ConfigOp<u32>,
+			max_validator_count: ConfigOp<u32>,
+			chill_threshold: ConfigOp<Percent>,
+			min_commission: ConfigOp<Perbill>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			macro_rules! config_op_exp {
+				($storage:ty, $op:ident) => {
+					match $op {
+						ConfigOp::Noop => (),
+						ConfigOp::Set(v) => <$storage>::put(v),
+						ConfigOp::Remove => <$storage>::kill(),
+					}
+				};
+			}
+
+			config_op_exp!(MinNominatorBond<T>, min_nominator_bond);
+			config_op_exp!(MinValidatorBond<T>, min_validator_bond);
+			config_op_exp!(MaxNominatorsCount<T>, max_nominator_count);
+			config_op_exp!(MaxValidatorsCount<T>, max_validator_count);
+			config_op_exp!(ChillThreshold<T>, chill_threshold);
+			config_op_exp!(MinCommission<T>, min_commission);
+			Ok(())
+		}
+		/// Declare a `controller` to stop participating as either a validator or nominator.
+		///
+		/// Effects will be felt at the beginning of the next era.
+		///
+		/// The dispatch origin for this call must be _Signed_, but can be called by anyone.
+		///
+		/// If the caller is the same as the controller being targeted, then no further checks are
+		/// enforced, and this function behaves just like `chill`.
+		///
+		/// If the caller is different than the controller being targeted, the following conditions
+		/// must be met:
+		///
+		/// * `controller` must belong to a nominator who has become non-decodable,
+		///
+		/// Or:
+		///
+		/// * A `ChillThreshold` must be set and checked which defines how close to the max
+		///   nominators or validators we must reach before users can start chilling one-another.
+		/// * A `MaxNominatorCount` and `MaxValidatorCount` must be set which is used to determine
+		///   how close we are to the threshold.
+		/// * A `MinNominatorBond` and `MinValidatorBond` must be set and checked, which determines
+		///   if this is a person that should be chilled because they have not met the threshold
+		///   bond required.
+		///
+		/// This can be helpful if bond requirements are updated, and we need to remove old users
+		/// who do not satisfy these requirements.
+		#[pallet::call_index(23)]
+		#[pallet::weight(T::WeightInfo::chill_other())]
+		pub fn chill_other(origin: OriginFor<T>, controller: T::AccountId) -> DispatchResult {
+			// Anyone can call this function.
+			let caller = ensure_signed(origin)?;
+			let ledger = Self::ledger(&controller).ok_or(Error::<T>::NotController)?;
+			let stash = ledger.stash;
+
+			// In order for one user to chill another user, the following conditions must be met:
+			//
+			// * `controller` belongs to a nominator who has become non-decodable,
+			//
+			// Or
+			//
+			// * A `ChillThreshold` is set which defines how close to the max nominators or
+			//   validators we must reach before users can start chilling one-another.
+			// * A `MaxNominatorCount` and `MaxValidatorCount` which is used to determine how close
+			//   we are to the threshold.
+			// * A `MinNominatorBond` and `MinValidatorBond` which is the final condition checked to
+			//   determine this is a person that should be chilled because they have not met the
+			//   threshold bond required.
+			//
+			// Otherwise, if caller is the same as the controller, this is just like `chill`.
+
+			if Nominators::<T>::contains_key(&stash) && Nominators::<T>::get(&stash).is_none() {
+				Self::chill_stash(&stash);
+				return Ok(())
+			}
+
+			if caller != controller {
+				let threshold = ChillThreshold::<T>::get().ok_or(Error::<T>::CannotChillOther)?;
+				let min_active_bond = if Nominators::<T>::contains_key(&stash) {
+					let max_nominator_count =
+						MaxNominatorsCount::<T>::get().ok_or(Error::<T>::CannotChillOther)?;
+					let current_nominator_count = Nominators::<T>::count();
+					ensure!(
+						threshold * max_nominator_count < current_nominator_count,
+						Error::<T>::CannotChillOther
+					);
+					MinNominatorBond::<T>::get()
+				} else if Validators::<T>::contains_key(&stash) {
+					let max_validator_count =
+						MaxValidatorsCount::<T>::get().ok_or(Error::<T>::CannotChillOther)?;
+					let current_validator_count = Validators::<T>::count();
+					ensure!(
+						threshold * max_validator_count < current_validator_count,
+						Error::<T>::CannotChillOther
+					);
+					MinValidatorBond::<T>::get()
+				} else {
+					Zero::zero()
+				};
+
+				ensure!(ledger.active < min_active_bond, Error::<T>::CannotChillOther);
+			}
+
+			Self::chill_stash(&stash);
+			Ok(())
+		}
+
+		/// Force a validator to have at least the minimum commission. This will not affect a
+		/// validator who already has a commission greater than or equal to the minimum. Any account
+		/// can call this.
+		#[pallet::call_index(24)]
+		#[pallet::weight(T::WeightInfo::force_apply_min_commission())]
+		pub fn force_apply_min_commission(
+			origin: OriginFor<T>,
+			validator_stash: T::AccountId,
+		) -> DispatchResult {
+			ensure_signed(origin)?;
+			let min_commission = MinCommission::<T>::get();
+			Validators::<T>::try_mutate_exists(validator_stash, |maybe_prefs| {
+				maybe_prefs
+					.as_mut()
+					.map(|prefs| {
+						(prefs.commission < min_commission)
+							.then(|| prefs.commission = min_commission)
+					})
+					.ok_or(Error::<T>::NotStash)
+			})?;
+			Ok(())
+		}
+
+		/// Sets the minimum amount of commission that each validators must maintain.
+		///
+		/// This call has lower privilege requirements than `set_staking_config` and can be called
+		/// by the `T::AdminOrigin`. Root can always call this.
+		#[pallet::call_index(25)]
+		#[pallet::weight(T::WeightInfo::set_min_commission())]
+		pub fn set_min_commission(origin: OriginFor<T>, new: Perbill) -> DispatchResult {
+			T::AdminOrigin::ensure_origin(origin)?;
+			MinCommission::<T>::put(new);
+			Ok(())
+		}
+	}
+}
+
+/// Check that list is sorted and has no duplicates.
+fn is_sorted_and_unique(list: &[u32]) -> bool {
+	list.windows(2).all(|w| w[0] < w[1])
+}
diff --git a/substrate/frame/staking/src/slashing.rs b/substrate/frame/staking/src/slashing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bb02da73f6e5d5ddb96f23f61a7ac4ca463e0f03
--- /dev/null
+++ b/substrate/frame/staking/src/slashing.rs
@@ -0,0 +1,860 @@
+// 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 slashing implementation for NPoS systems.
+//!
+//! For the purposes of the economic model, it is easiest to think of each validator as a nominator
+//! which nominates only its own identity.
+//!
+//! The act of nomination signals intent to unify economic identity with the validator - to take
+//! part in the rewards of a job well done, and to take part in the punishment of a job done badly.
+//!
+//! There are 3 main difficulties to account for with slashing in NPoS:
+//!   - A nominator can nominate multiple validators and be slashed via any of them.
+//!   - Until slashed, stake is reused from era to era. Nominating with N coins for E eras in a row
+//!     does not mean you have N*E coins to be slashed - you've only ever had N.
+//!   - Slashable offences can be found after the fact and out of order.
+//!
+//! The algorithm implemented in this module tries to balance these 3 difficulties.
+//!
+//! First, we only slash participants for the _maximum_ slash they receive in some time period,
+//! rather than the sum. This ensures a protection from overslashing.
+//!
+//! Second, we do not want the time period (or "span") that the maximum is computed
+//! over to last indefinitely. That would allow participants to begin acting with
+//! impunity after some point, fearing no further repercussions. For that reason, we
+//! automatically "chill" validators and withdraw a nominator's nomination after a slashing event,
+//! requiring them to re-enlist voluntarily (acknowledging the slash) and begin a new
+//! slashing span.
+//!
+//! Typically, you will have a single slashing event per slashing span. Only in the case
+//! where a validator releases many misbehaviors at once, or goes "back in time" to misbehave in
+//! eras that have already passed, would you encounter situations where a slashing span
+//! has multiple misbehaviors. However, accounting for such cases is necessary
+//! to deter a class of "rage-quit" attacks.
+//!
+//! Based on research at <https://research.web3.foundation/en/latest/polkadot/slashing/npos.html>
+
+use crate::{
+	BalanceOf, Config, Error, Exposure, NegativeImbalanceOf, NominatorSlashInEra,
+	OffendingValidators, Pallet, Perbill, SessionInterface, SpanSlash, UnappliedSlash,
+	ValidatorSlashInEra,
+};
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	ensure,
+	traits::{Currency, Defensive, Get, Imbalance, OnUnbalanced},
+};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{Saturating, Zero},
+	DispatchResult, RuntimeDebug,
+};
+use sp_staking::{offence::DisableStrategy, EraIndex};
+use sp_std::vec::Vec;
+
+/// The proportion of the slashing reward to be paid out on the first slashing detection.
+/// This is f_1 in the paper.
+const REWARD_F1: Perbill = Perbill::from_percent(50);
+
+/// The index of a slashing span - unique to each stash.
+pub type SpanIndex = u32;
+
+// A range of start..end eras for a slashing span.
+#[derive(Encode, Decode, TypeInfo)]
+#[cfg_attr(test, derive(Debug, PartialEq))]
+pub(crate) struct SlashingSpan {
+	pub(crate) index: SpanIndex,
+	pub(crate) start: EraIndex,
+	pub(crate) length: Option<EraIndex>, // the ongoing slashing span has indeterminate length.
+}
+
+impl SlashingSpan {
+	fn contains_era(&self, era: EraIndex) -> bool {
+		self.start <= era && self.length.map_or(true, |l| self.start + l > era)
+	}
+}
+
+/// An encoding of all of a nominator's slashing spans.
+#[derive(Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct SlashingSpans {
+	// the index of the current slashing span of the nominator. different for
+	// every stash, resets when the account hits free balance 0.
+	span_index: SpanIndex,
+	// the start era of the most recent (ongoing) slashing span.
+	last_start: EraIndex,
+	// the last era at which a non-zero slash occurred.
+	last_nonzero_slash: EraIndex,
+	// all prior slashing spans' start indices, in reverse order (most recent first)
+	// encoded as offsets relative to the slashing span after it.
+	prior: Vec<EraIndex>,
+}
+
+impl SlashingSpans {
+	// creates a new record of slashing spans for a stash, starting at the beginning
+	// of the bonding period, relative to now.
+	pub(crate) fn new(window_start: EraIndex) -> Self {
+		SlashingSpans {
+			span_index: 0,
+			last_start: window_start,
+			// initialize to zero, as this structure is lazily created until
+			// the first slash is applied. setting equal to `window_start` would
+			// put a time limit on nominations.
+			last_nonzero_slash: 0,
+			prior: Vec::new(),
+		}
+	}
+
+	// update the slashing spans to reflect the start of a new span at the era after `now`
+	// returns `true` if a new span was started, `false` otherwise. `false` indicates
+	// that internal state is unchanged.
+	pub(crate) fn end_span(&mut self, now: EraIndex) -> bool {
+		let next_start = now + 1;
+		if next_start <= self.last_start {
+			return false
+		}
+
+		let last_length = next_start - self.last_start;
+		self.prior.insert(0, last_length);
+		self.last_start = next_start;
+		self.span_index += 1;
+		true
+	}
+
+	// an iterator over all slashing spans in _reverse_ order - most recent first.
+	pub(crate) fn iter(&'_ self) -> impl Iterator<Item = SlashingSpan> + '_ {
+		let mut last_start = self.last_start;
+		let mut index = self.span_index;
+		let last = SlashingSpan { index, start: last_start, length: None };
+		let prior = self.prior.iter().cloned().map(move |length| {
+			let start = last_start - length;
+			last_start = start;
+			index -= 1;
+
+			SlashingSpan { index, start, length: Some(length) }
+		});
+
+		sp_std::iter::once(last).chain(prior)
+	}
+
+	/// Yields the era index where the most recent non-zero slash occurred.
+	pub fn last_nonzero_slash(&self) -> EraIndex {
+		self.last_nonzero_slash
+	}
+
+	// prune the slashing spans against a window, whose start era index is given.
+	//
+	// If this returns `Some`, then it includes a range start..end of all the span
+	// indices which were pruned.
+	fn prune(&mut self, window_start: EraIndex) -> Option<(SpanIndex, SpanIndex)> {
+		let old_idx = self
+			.iter()
+			.skip(1) // skip ongoing span.
+			.position(|span| span.length.map_or(false, |len| span.start + len <= window_start));
+
+		let earliest_span_index = self.span_index - self.prior.len() as SpanIndex;
+		let pruned = match old_idx {
+			Some(o) => {
+				self.prior.truncate(o);
+				let new_earliest = self.span_index - self.prior.len() as SpanIndex;
+				Some((earliest_span_index, new_earliest))
+			},
+			None => None,
+		};
+
+		// readjust the ongoing span, if it started before the beginning of the window.
+		self.last_start = sp_std::cmp::max(self.last_start, window_start);
+		pruned
+	}
+}
+
+/// A slashing-span record for a particular stash.
+#[derive(Encode, Decode, Default, TypeInfo, MaxEncodedLen)]
+pub(crate) struct SpanRecord<Balance> {
+	slashed: Balance,
+	paid_out: Balance,
+}
+
+impl<Balance> SpanRecord<Balance> {
+	/// The value of stash balance slashed in this span.
+	#[cfg(test)]
+	pub(crate) fn amount(&self) -> &Balance {
+		&self.slashed
+	}
+}
+
+/// Parameters for performing a slash.
+#[derive(Clone)]
+pub(crate) struct SlashParams<'a, T: 'a + Config> {
+	/// The stash account being slashed.
+	pub(crate) stash: &'a T::AccountId,
+	/// The proportion of the slash.
+	pub(crate) slash: Perbill,
+	/// The exposure of the stash and all nominators.
+	pub(crate) exposure: &'a Exposure<T::AccountId, BalanceOf<T>>,
+	/// The era where the offence occurred.
+	pub(crate) slash_era: EraIndex,
+	/// The first era in the current bonding period.
+	pub(crate) window_start: EraIndex,
+	/// The current era.
+	pub(crate) now: EraIndex,
+	/// The maximum percentage of a slash that ever gets paid out.
+	/// This is f_inf in the paper.
+	pub(crate) reward_proportion: Perbill,
+	/// When to disable offenders.
+	pub(crate) disable_strategy: DisableStrategy,
+}
+
+/// Computes a slash of a validator and nominators. It returns an unapplied
+/// record to be applied at some later point. Slashing metadata is updated in storage,
+/// since unapplied records are only rarely intended to be dropped.
+///
+/// The pending slash record returned does not have initialized reporters. Those have
+/// to be set at a higher level, if any.
+pub(crate) fn compute_slash<T: Config>(
+	params: SlashParams<T>,
+) -> Option<UnappliedSlash<T::AccountId, BalanceOf<T>>> {
+	let mut reward_payout = Zero::zero();
+	let mut val_slashed = Zero::zero();
+
+	// is the slash amount here a maximum for the era?
+	let own_slash = params.slash * params.exposure.own;
+	if params.slash * params.exposure.total == Zero::zero() {
+		// kick out the validator even if they won't be slashed,
+		// as long as the misbehavior is from their most recent slashing span.
+		kick_out_if_recent::<T>(params);
+		return None
+	}
+
+	let prior_slash_p = ValidatorSlashInEra::<T>::get(&params.slash_era, params.stash)
+		.map_or(Zero::zero(), |(prior_slash_proportion, _)| prior_slash_proportion);
+
+	// compare slash proportions rather than slash values to avoid issues due to rounding
+	// error.
+	if params.slash.deconstruct() > prior_slash_p.deconstruct() {
+		ValidatorSlashInEra::<T>::insert(
+			&params.slash_era,
+			params.stash,
+			&(params.slash, own_slash),
+		);
+	} else {
+		// we slash based on the max in era - this new event is not the max,
+		// so neither the validator or any nominators will need an update.
+		//
+		// this does lead to a divergence of our system from the paper, which
+		// pays out some reward even if the latest report is not max-in-era.
+		// we opt to avoid the nominator lookups and edits and leave more rewards
+		// for more drastic misbehavior.
+		return None
+	}
+
+	// apply slash to validator.
+	{
+		let mut spans = fetch_spans::<T>(
+			params.stash,
+			params.window_start,
+			&mut reward_payout,
+			&mut val_slashed,
+			params.reward_proportion,
+		);
+
+		let target_span = spans.compare_and_update_span_slash(params.slash_era, own_slash);
+
+		if target_span == Some(spans.span_index()) {
+			// misbehavior occurred within the current slashing span - take appropriate
+			// actions.
+
+			// chill the validator - it misbehaved in the current span and should
+			// not continue in the next election. also end the slashing span.
+			spans.end_span(params.now);
+			<Pallet<T>>::chill_stash(params.stash);
+		}
+	}
+
+	let disable_when_slashed = params.disable_strategy != DisableStrategy::Never;
+	add_offending_validator::<T>(params.stash, disable_when_slashed);
+
+	let mut nominators_slashed = Vec::new();
+	reward_payout += slash_nominators::<T>(params.clone(), prior_slash_p, &mut nominators_slashed);
+
+	Some(UnappliedSlash {
+		validator: params.stash.clone(),
+		own: val_slashed,
+		others: nominators_slashed,
+		reporters: Vec::new(),
+		payout: reward_payout,
+	})
+}
+
+// doesn't apply any slash, but kicks out the validator if the misbehavior is from
+// the most recent slashing span.
+fn kick_out_if_recent<T: Config>(params: SlashParams<T>) {
+	// these are not updated by era-span or end-span.
+	let mut reward_payout = Zero::zero();
+	let mut val_slashed = Zero::zero();
+	let mut spans = fetch_spans::<T>(
+		params.stash,
+		params.window_start,
+		&mut reward_payout,
+		&mut val_slashed,
+		params.reward_proportion,
+	);
+
+	if spans.era_span(params.slash_era).map(|s| s.index) == Some(spans.span_index()) {
+		spans.end_span(params.now);
+		<Pallet<T>>::chill_stash(params.stash);
+	}
+
+	let disable_without_slash = params.disable_strategy == DisableStrategy::Always;
+	add_offending_validator::<T>(params.stash, disable_without_slash);
+}
+
+/// Add the given validator to the offenders list and optionally disable it.
+/// If after adding the validator `OffendingValidatorsThreshold` is reached
+/// a new era will be forced.
+fn add_offending_validator<T: Config>(stash: &T::AccountId, disable: bool) {
+	OffendingValidators::<T>::mutate(|offending| {
+		let validators = T::SessionInterface::validators();
+		let validator_index = match validators.iter().position(|i| i == stash) {
+			Some(index) => index,
+			None => return,
+		};
+
+		let validator_index_u32 = validator_index as u32;
+
+		match offending.binary_search_by_key(&validator_index_u32, |(index, _)| *index) {
+			// this is a new offending validator
+			Err(index) => {
+				offending.insert(index, (validator_index_u32, disable));
+
+				let offending_threshold =
+					T::OffendingValidatorsThreshold::get() * validators.len() as u32;
+
+				if offending.len() >= offending_threshold as usize {
+					// force a new era, to select a new validator set
+					<Pallet<T>>::ensure_new_era()
+				}
+
+				if disable {
+					T::SessionInterface::disable_validator(validator_index_u32);
+				}
+			},
+			Ok(index) => {
+				if disable && !offending[index].1 {
+					// the validator had previously offended without being disabled,
+					// let's make sure we disable it now
+					offending[index].1 = true;
+					T::SessionInterface::disable_validator(validator_index_u32);
+				}
+			},
+		}
+	});
+}
+
+/// Slash nominators. Accepts general parameters and the prior slash percentage of the validator.
+///
+/// Returns the amount of reward to pay out.
+fn slash_nominators<T: Config>(
+	params: SlashParams<T>,
+	prior_slash_p: Perbill,
+	nominators_slashed: &mut Vec<(T::AccountId, BalanceOf<T>)>,
+) -> BalanceOf<T> {
+	let mut reward_payout = Zero::zero();
+
+	nominators_slashed.reserve(params.exposure.others.len());
+	for nominator in &params.exposure.others {
+		let stash = &nominator.who;
+		let mut nom_slashed = Zero::zero();
+
+		// the era slash of a nominator always grows, if the validator
+		// had a new max slash for the era.
+		let era_slash = {
+			let own_slash_prior = prior_slash_p * nominator.value;
+			let own_slash_by_validator = params.slash * nominator.value;
+			let own_slash_difference = own_slash_by_validator.saturating_sub(own_slash_prior);
+
+			let mut era_slash =
+				NominatorSlashInEra::<T>::get(&params.slash_era, stash).unwrap_or_else(Zero::zero);
+			era_slash += own_slash_difference;
+			NominatorSlashInEra::<T>::insert(&params.slash_era, stash, &era_slash);
+
+			era_slash
+		};
+
+		// compare the era slash against other eras in the same span.
+		{
+			let mut spans = fetch_spans::<T>(
+				stash,
+				params.window_start,
+				&mut reward_payout,
+				&mut nom_slashed,
+				params.reward_proportion,
+			);
+
+			let target_span = spans.compare_and_update_span_slash(params.slash_era, era_slash);
+
+			if target_span == Some(spans.span_index()) {
+				// end the span, but don't chill the nominator.
+				spans.end_span(params.now);
+			}
+		}
+		nominators_slashed.push((stash.clone(), nom_slashed));
+	}
+
+	reward_payout
+}
+
+// helper struct for managing a set of spans we are currently inspecting.
+// writes alterations to disk on drop, but only if a slash has been carried out.
+//
+// NOTE: alterations to slashing metadata should not be done after this is dropped.
+// dropping this struct applies any necessary slashes, which can lead to free balance
+// being 0, and the account being garbage-collected -- a dead account should get no new
+// metadata.
+struct InspectingSpans<'a, T: Config + 'a> {
+	dirty: bool,
+	window_start: EraIndex,
+	stash: &'a T::AccountId,
+	spans: SlashingSpans,
+	paid_out: &'a mut BalanceOf<T>,
+	slash_of: &'a mut BalanceOf<T>,
+	reward_proportion: Perbill,
+	_marker: sp_std::marker::PhantomData<T>,
+}
+
+// fetches the slashing spans record for a stash account, initializing it if necessary.
+fn fetch_spans<'a, T: Config + 'a>(
+	stash: &'a T::AccountId,
+	window_start: EraIndex,
+	paid_out: &'a mut BalanceOf<T>,
+	slash_of: &'a mut BalanceOf<T>,
+	reward_proportion: Perbill,
+) -> InspectingSpans<'a, T> {
+	let spans = crate::SlashingSpans::<T>::get(stash).unwrap_or_else(|| {
+		let spans = SlashingSpans::new(window_start);
+		crate::SlashingSpans::<T>::insert(stash, &spans);
+		spans
+	});
+
+	InspectingSpans {
+		dirty: false,
+		window_start,
+		stash,
+		spans,
+		slash_of,
+		paid_out,
+		reward_proportion,
+		_marker: sp_std::marker::PhantomData,
+	}
+}
+
+impl<'a, T: 'a + Config> InspectingSpans<'a, T> {
+	fn span_index(&self) -> SpanIndex {
+		self.spans.span_index
+	}
+
+	fn end_span(&mut self, now: EraIndex) {
+		self.dirty = self.spans.end_span(now) || self.dirty;
+	}
+
+	// add some value to the slash of the staker.
+	// invariant: the staker is being slashed for non-zero value here
+	// although `amount` may be zero, as it is only a difference.
+	fn add_slash(&mut self, amount: BalanceOf<T>, slash_era: EraIndex) {
+		*self.slash_of += amount;
+		self.spans.last_nonzero_slash = sp_std::cmp::max(self.spans.last_nonzero_slash, slash_era);
+	}
+
+	// find the span index of the given era, if covered.
+	fn era_span(&self, era: EraIndex) -> Option<SlashingSpan> {
+		self.spans.iter().find(|span| span.contains_era(era))
+	}
+
+	// compares the slash in an era to the overall current span slash.
+	// if it's higher, applies the difference of the slashes and then updates the span on disk.
+	//
+	// returns the span index of the era where the slash occurred, if any.
+	fn compare_and_update_span_slash(
+		&mut self,
+		slash_era: EraIndex,
+		slash: BalanceOf<T>,
+	) -> Option<SpanIndex> {
+		let target_span = self.era_span(slash_era)?;
+		let span_slash_key = (self.stash.clone(), target_span.index);
+		let mut span_record = SpanSlash::<T>::get(&span_slash_key);
+		let mut changed = false;
+
+		let reward = if span_record.slashed < slash {
+			// new maximum span slash. apply the difference.
+			let difference = slash - span_record.slashed;
+			span_record.slashed = slash;
+
+			// compute reward.
+			let reward =
+				REWARD_F1 * (self.reward_proportion * slash).saturating_sub(span_record.paid_out);
+
+			self.add_slash(difference, slash_era);
+			changed = true;
+
+			reward
+		} else if span_record.slashed == slash {
+			// compute reward. no slash difference to apply.
+			REWARD_F1 * (self.reward_proportion * slash).saturating_sub(span_record.paid_out)
+		} else {
+			Zero::zero()
+		};
+
+		if !reward.is_zero() {
+			changed = true;
+			span_record.paid_out += reward;
+			*self.paid_out += reward;
+		}
+
+		if changed {
+			self.dirty = true;
+			SpanSlash::<T>::insert(&span_slash_key, &span_record);
+		}
+
+		Some(target_span.index)
+	}
+}
+
+impl<'a, T: 'a + Config> Drop for InspectingSpans<'a, T> {
+	fn drop(&mut self) {
+		// only update on disk if we slashed this account.
+		if !self.dirty {
+			return
+		}
+
+		if let Some((start, end)) = self.spans.prune(self.window_start) {
+			for span_index in start..end {
+				SpanSlash::<T>::remove(&(self.stash.clone(), span_index));
+			}
+		}
+
+		crate::SlashingSpans::<T>::insert(self.stash, &self.spans);
+	}
+}
+
+/// Clear slashing metadata for an obsolete era.
+pub(crate) fn clear_era_metadata<T: Config>(obsolete_era: EraIndex) {
+	#[allow(deprecated)]
+	ValidatorSlashInEra::<T>::remove_prefix(&obsolete_era, None);
+	#[allow(deprecated)]
+	NominatorSlashInEra::<T>::remove_prefix(&obsolete_era, None);
+}
+
+/// Clear slashing metadata for a dead account.
+pub(crate) fn clear_stash_metadata<T: Config>(
+	stash: &T::AccountId,
+	num_slashing_spans: u32,
+) -> DispatchResult {
+	let spans = match crate::SlashingSpans::<T>::get(stash) {
+		None => return Ok(()),
+		Some(s) => s,
+	};
+
+	ensure!(
+		num_slashing_spans as usize >= spans.iter().count(),
+		Error::<T>::IncorrectSlashingSpans
+	);
+
+	crate::SlashingSpans::<T>::remove(stash);
+
+	// kill slashing-span metadata for account.
+	//
+	// this can only happen while the account is staked _if_ they are completely slashed.
+	// in that case, they may re-bond, but it would count again as span 0. Further ancient
+	// slashes would slash into this new bond, since metadata has now been cleared.
+	for span in spans.iter() {
+		SpanSlash::<T>::remove(&(stash.clone(), span.index));
+	}
+
+	Ok(())
+}
+
+// apply the slash to a stash account, deducting any missing funds from the reward
+// payout, saturating at 0. this is mildly unfair but also an edge-case that
+// can only occur when overlapping locked funds have been slashed.
+pub fn do_slash<T: Config>(
+	stash: &T::AccountId,
+	value: BalanceOf<T>,
+	reward_payout: &mut BalanceOf<T>,
+	slashed_imbalance: &mut NegativeImbalanceOf<T>,
+	slash_era: EraIndex,
+) {
+	let controller = match <Pallet<T>>::bonded(stash).defensive() {
+		None => return,
+		Some(c) => c,
+	};
+
+	let mut ledger = match <Pallet<T>>::ledger(&controller) {
+		Some(ledger) => ledger,
+		None => return, // nothing to do.
+	};
+
+	let value = ledger.slash(value, T::Currency::minimum_balance(), slash_era);
+
+	if !value.is_zero() {
+		let (imbalance, missing) = T::Currency::slash(stash, value);
+		slashed_imbalance.subsume(imbalance);
+
+		if !missing.is_zero() {
+			// deduct overslash from the reward payout
+			*reward_payout = reward_payout.saturating_sub(missing);
+		}
+
+		<Pallet<T>>::update_ledger(&controller, &ledger);
+
+		// trigger the event
+		<Pallet<T>>::deposit_event(super::Event::<T>::Slashed {
+			staker: stash.clone(),
+			amount: value,
+		});
+	}
+}
+
+/// Apply a previously-unapplied slash.
+pub(crate) fn apply_slash<T: Config>(
+	unapplied_slash: UnappliedSlash<T::AccountId, BalanceOf<T>>,
+	slash_era: EraIndex,
+) {
+	let mut slashed_imbalance = NegativeImbalanceOf::<T>::zero();
+	let mut reward_payout = unapplied_slash.payout;
+
+	do_slash::<T>(
+		&unapplied_slash.validator,
+		unapplied_slash.own,
+		&mut reward_payout,
+		&mut slashed_imbalance,
+		slash_era,
+	);
+
+	for &(ref nominator, nominator_slash) in &unapplied_slash.others {
+		do_slash::<T>(
+			nominator,
+			nominator_slash,
+			&mut reward_payout,
+			&mut slashed_imbalance,
+			slash_era,
+		);
+	}
+
+	pay_reporters::<T>(reward_payout, slashed_imbalance, &unapplied_slash.reporters);
+}
+
+/// Apply a reward payout to some reporters, paying the rewards out of the slashed imbalance.
+fn pay_reporters<T: Config>(
+	reward_payout: BalanceOf<T>,
+	slashed_imbalance: NegativeImbalanceOf<T>,
+	reporters: &[T::AccountId],
+) {
+	if reward_payout.is_zero() || reporters.is_empty() {
+		// nobody to pay out to or nothing to pay;
+		// just treat the whole value as slashed.
+		T::Slash::on_unbalanced(slashed_imbalance);
+		return
+	}
+
+	// take rewards out of the slashed imbalance.
+	let reward_payout = reward_payout.min(slashed_imbalance.peek());
+	let (mut reward_payout, mut value_slashed) = slashed_imbalance.split(reward_payout);
+
+	let per_reporter = reward_payout.peek() / (reporters.len() as u32).into();
+	for reporter in reporters {
+		let (reporter_reward, rest) = reward_payout.split(per_reporter);
+		reward_payout = rest;
+
+		// this cancels out the reporter reward imbalance internally, leading
+		// to no change in total issuance.
+		T::Currency::resolve_creating(reporter, reporter_reward);
+	}
+
+	// the rest goes to the on-slash imbalance handler (e.g. treasury)
+	value_slashed.subsume(reward_payout); // remainder of reward division remains.
+	T::Slash::on_unbalanced(value_slashed);
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn span_contains_era() {
+		// unbounded end
+		let span = SlashingSpan { index: 0, start: 1000, length: None };
+		assert!(!span.contains_era(0));
+		assert!(!span.contains_era(999));
+
+		assert!(span.contains_era(1000));
+		assert!(span.contains_era(1001));
+		assert!(span.contains_era(10000));
+
+		// bounded end - non-inclusive range.
+		let span = SlashingSpan { index: 0, start: 1000, length: Some(10) };
+		assert!(!span.contains_era(0));
+		assert!(!span.contains_era(999));
+
+		assert!(span.contains_era(1000));
+		assert!(span.contains_era(1001));
+		assert!(span.contains_era(1009));
+		assert!(!span.contains_era(1010));
+		assert!(!span.contains_era(1011));
+	}
+
+	#[test]
+	fn single_slashing_span() {
+		let spans = SlashingSpans {
+			span_index: 0,
+			last_start: 1000,
+			last_nonzero_slash: 0,
+			prior: Vec::new(),
+		};
+
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![SlashingSpan { index: 0, start: 1000, length: None }],
+		);
+	}
+
+	#[test]
+	fn many_prior_spans() {
+		let spans = SlashingSpans {
+			span_index: 10,
+			last_start: 1000,
+			last_nonzero_slash: 0,
+			prior: vec![10, 9, 8, 10],
+		};
+
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![
+				SlashingSpan { index: 10, start: 1000, length: None },
+				SlashingSpan { index: 9, start: 990, length: Some(10) },
+				SlashingSpan { index: 8, start: 981, length: Some(9) },
+				SlashingSpan { index: 7, start: 973, length: Some(8) },
+				SlashingSpan { index: 6, start: 963, length: Some(10) },
+			],
+		)
+	}
+
+	#[test]
+	fn pruning_spans() {
+		let mut spans = SlashingSpans {
+			span_index: 10,
+			last_start: 1000,
+			last_nonzero_slash: 0,
+			prior: vec![10, 9, 8, 10],
+		};
+
+		assert_eq!(spans.prune(981), Some((6, 8)));
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![
+				SlashingSpan { index: 10, start: 1000, length: None },
+				SlashingSpan { index: 9, start: 990, length: Some(10) },
+				SlashingSpan { index: 8, start: 981, length: Some(9) },
+			],
+		);
+
+		assert_eq!(spans.prune(982), None);
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![
+				SlashingSpan { index: 10, start: 1000, length: None },
+				SlashingSpan { index: 9, start: 990, length: Some(10) },
+				SlashingSpan { index: 8, start: 981, length: Some(9) },
+			],
+		);
+
+		assert_eq!(spans.prune(989), None);
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![
+				SlashingSpan { index: 10, start: 1000, length: None },
+				SlashingSpan { index: 9, start: 990, length: Some(10) },
+				SlashingSpan { index: 8, start: 981, length: Some(9) },
+			],
+		);
+
+		assert_eq!(spans.prune(1000), Some((8, 10)));
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![SlashingSpan { index: 10, start: 1000, length: None },],
+		);
+
+		assert_eq!(spans.prune(2000), None);
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![SlashingSpan { index: 10, start: 2000, length: None },],
+		);
+
+		// now all in one shot.
+		let mut spans = SlashingSpans {
+			span_index: 10,
+			last_start: 1000,
+			last_nonzero_slash: 0,
+			prior: vec![10, 9, 8, 10],
+		};
+		assert_eq!(spans.prune(2000), Some((6, 10)));
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![SlashingSpan { index: 10, start: 2000, length: None },],
+		);
+	}
+
+	#[test]
+	fn ending_span() {
+		let mut spans = SlashingSpans {
+			span_index: 1,
+			last_start: 10,
+			last_nonzero_slash: 0,
+			prior: Vec::new(),
+		};
+
+		assert!(spans.end_span(10));
+
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![
+				SlashingSpan { index: 2, start: 11, length: None },
+				SlashingSpan { index: 1, start: 10, length: Some(1) },
+			],
+		);
+
+		assert!(spans.end_span(15));
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![
+				SlashingSpan { index: 3, start: 16, length: None },
+				SlashingSpan { index: 2, start: 11, length: Some(5) },
+				SlashingSpan { index: 1, start: 10, length: Some(1) },
+			],
+		);
+
+		// does nothing if not a valid end.
+		assert!(!spans.end_span(15));
+		assert_eq!(
+			spans.iter().collect::<Vec<_>>(),
+			vec![
+				SlashingSpan { index: 3, start: 16, length: None },
+				SlashingSpan { index: 2, start: 11, length: Some(5) },
+				SlashingSpan { index: 1, start: 10, length: Some(1) },
+			],
+		);
+	}
+}
diff --git a/substrate/frame/staking/src/testing_utils.rs b/substrate/frame/staking/src/testing_utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..28e08230d701d6cc477c840311b274d0535a88bf
--- /dev/null
+++ b/substrate/frame/staking/src/testing_utils.rs
@@ -0,0 +1,240 @@
+// 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.
+
+//! Testing utils for staking. Provides some common functions to setup staking state, such as
+//! bonding validators, nominators, and generating different types of solutions.
+
+use crate::{Pallet as Staking, *};
+use frame_benchmarking::account;
+use frame_system::RawOrigin;
+use rand_chacha::{
+	rand_core::{RngCore, SeedableRng},
+	ChaChaRng,
+};
+use sp_io::hashing::blake2_256;
+
+use frame_election_provider_support::SortedListProvider;
+use frame_support::{pallet_prelude::*, traits::Currency};
+use sp_runtime::{traits::StaticLookup, Perbill};
+use sp_std::prelude::*;
+
+const SEED: u32 = 0;
+
+/// This function removes all validators and nominators from storage.
+pub fn clear_validators_and_nominators<T: Config>() {
+	#[allow(deprecated)]
+	Validators::<T>::remove_all();
+
+	// whenever we touch nominators counter we should update `T::VoterList` as well.
+	#[allow(deprecated)]
+	Nominators::<T>::remove_all();
+
+	// NOTE: safe to call outside block production
+	T::VoterList::unsafe_clear();
+}
+
+/// Grab a funded user.
+pub fn create_funded_user<T: Config>(
+	string: &'static str,
+	n: u32,
+	balance_factor: u32,
+) -> T::AccountId {
+	let user = account(string, n, SEED);
+	let balance = T::Currency::minimum_balance() * balance_factor.into();
+	let _ = T::Currency::make_free_balance_be(&user, balance);
+	user
+}
+
+/// Grab a funded user with max Balance.
+pub fn create_funded_user_with_balance<T: Config>(
+	string: &'static str,
+	n: u32,
+	balance: BalanceOf<T>,
+) -> T::AccountId {
+	let user = account(string, n, SEED);
+	let _ = T::Currency::make_free_balance_be(&user, balance);
+	user
+}
+
+/// Create a stash and controller pair.
+pub fn create_stash_controller<T: Config>(
+	n: u32,
+	balance_factor: u32,
+	destination: RewardDestination<T::AccountId>,
+) -> Result<(T::AccountId, T::AccountId), &'static str> {
+	let staker = create_funded_user::<T>("stash", n, balance_factor);
+	let amount = T::Currency::minimum_balance() * (balance_factor / 10).max(1).into();
+	Staking::<T>::bond(RawOrigin::Signed(staker.clone()).into(), amount, destination)?;
+	Ok((staker.clone(), staker))
+}
+
+/// Create a unique stash and controller pair.
+pub fn create_unique_stash_controller<T: Config>(
+	n: u32,
+	balance_factor: u32,
+	destination: RewardDestination<T::AccountId>,
+	dead_controller: bool,
+) -> Result<(T::AccountId, T::AccountId), &'static str> {
+	let stash = create_funded_user::<T>("stash", n, balance_factor);
+
+	let controller = if dead_controller {
+		create_funded_user::<T>("controller", n, 0)
+	} else {
+		create_funded_user::<T>("controller", n, balance_factor)
+	};
+	let amount = T::Currency::minimum_balance() * (balance_factor / 10).max(1).into();
+	Staking::<T>::bond(RawOrigin::Signed(stash.clone()).into(), amount, destination)?;
+
+	// update ledger to be a *different* controller to stash
+	if let Some(l) = Ledger::<T>::take(&stash) {
+		<Ledger<T>>::insert(&controller, l);
+	}
+	// update bonded account to be unique controller
+	<Bonded<T>>::insert(&stash, &controller);
+
+	Ok((stash, controller))
+}
+
+/// Create a stash and controller pair with fixed balance.
+pub fn create_stash_controller_with_balance<T: Config>(
+	n: u32,
+	balance: crate::BalanceOf<T>,
+	destination: RewardDestination<T::AccountId>,
+) -> Result<(T::AccountId, T::AccountId), &'static str> {
+	let staker = create_funded_user_with_balance::<T>("stash", n, balance);
+	Staking::<T>::bond(RawOrigin::Signed(staker.clone()).into(), balance, destination)?;
+	Ok((staker.clone(), staker))
+}
+
+/// Create a stash and controller pair, where payouts go to a dead payee account. This is used to
+/// test worst case payout scenarios.
+pub fn create_stash_and_dead_payee<T: Config>(
+	n: u32,
+	balance_factor: u32,
+) -> Result<(T::AccountId, T::AccountId), &'static str> {
+	let staker = create_funded_user::<T>("stash", n, 0);
+	// payee has no funds
+	let payee = create_funded_user::<T>("payee", n, 0);
+	let amount = T::Currency::minimum_balance() * (balance_factor / 10).max(1).into();
+	Staking::<T>::bond(
+		RawOrigin::Signed(staker.clone()).into(),
+		amount,
+		RewardDestination::Account(payee),
+	)?;
+	Ok((staker.clone(), staker))
+}
+
+/// create `max` validators.
+pub fn create_validators<T: Config>(
+	max: u32,
+	balance_factor: u32,
+) -> Result<Vec<AccountIdLookupOf<T>>, &'static str> {
+	create_validators_with_seed::<T>(max, balance_factor, 0)
+}
+
+/// create `max` validators, with a seed to help unintentional prevent account collisions.
+pub fn create_validators_with_seed<T: Config>(
+	max: u32,
+	balance_factor: u32,
+	seed: u32,
+) -> Result<Vec<AccountIdLookupOf<T>>, &'static str> {
+	let mut validators: Vec<AccountIdLookupOf<T>> = Vec::with_capacity(max as usize);
+	for i in 0..max {
+		let (stash, controller) =
+			create_stash_controller::<T>(i + seed, balance_factor, RewardDestination::Staked)?;
+		let validator_prefs =
+			ValidatorPrefs { commission: Perbill::from_percent(50), ..Default::default() };
+		Staking::<T>::validate(RawOrigin::Signed(controller).into(), validator_prefs)?;
+		let stash_lookup = T::Lookup::unlookup(stash);
+		validators.push(stash_lookup);
+	}
+	Ok(validators)
+}
+
+/// This function generates validators and nominators who are randomly nominating
+/// `edge_per_nominator` random validators (until `to_nominate` if provided).
+///
+/// NOTE: This function will remove any existing validators or nominators to ensure
+/// we are working with a clean state.
+///
+/// Parameters:
+/// - `validators`: number of bonded validators
+/// - `nominators`: number of bonded nominators.
+/// - `edge_per_nominator`: number of edge (vote) per nominator.
+/// - `randomize_stake`: whether to randomize the stakes.
+/// - `to_nominate`: if `Some(n)`, only the first `n` bonded validator are voted upon. Else, all of
+///   them are considered and `edge_per_nominator` random validators are voted for.
+///
+/// Return the validators chosen to be nominated.
+pub fn create_validators_with_nominators_for_era<T: Config>(
+	validators: u32,
+	nominators: u32,
+	edge_per_nominator: usize,
+	randomize_stake: bool,
+	to_nominate: Option<u32>,
+) -> Result<Vec<AccountIdLookupOf<T>>, &'static str> {
+	clear_validators_and_nominators::<T>();
+
+	let mut validators_stash: Vec<AccountIdLookupOf<T>> = Vec::with_capacity(validators as usize);
+	let mut rng = ChaChaRng::from_seed(SEED.using_encoded(blake2_256));
+
+	// Create validators
+	for i in 0..validators {
+		let balance_factor = if randomize_stake { rng.next_u32() % 255 + 10 } else { 100u32 };
+		let (v_stash, v_controller) =
+			create_stash_controller::<T>(i, balance_factor, RewardDestination::Staked)?;
+		let validator_prefs =
+			ValidatorPrefs { commission: Perbill::from_percent(50), ..Default::default() };
+		Staking::<T>::validate(RawOrigin::Signed(v_controller.clone()).into(), validator_prefs)?;
+		let stash_lookup = T::Lookup::unlookup(v_stash.clone());
+		validators_stash.push(stash_lookup.clone());
+	}
+
+	let to_nominate = to_nominate.unwrap_or(validators_stash.len() as u32) as usize;
+	let validator_chosen = validators_stash[0..to_nominate].to_vec();
+
+	// Create nominators
+	for j in 0..nominators {
+		let balance_factor = if randomize_stake { rng.next_u32() % 255 + 10 } else { 100u32 };
+		let (_n_stash, n_controller) =
+			create_stash_controller::<T>(u32::MAX - j, balance_factor, RewardDestination::Staked)?;
+
+		// Have them randomly validate
+		let mut available_validators = validator_chosen.clone();
+		let mut selected_validators: Vec<AccountIdLookupOf<T>> =
+			Vec::with_capacity(edge_per_nominator);
+
+		for _ in 0..validators.min(edge_per_nominator as u32) {
+			let selected = rng.next_u32() as usize % available_validators.len();
+			let validator = available_validators.remove(selected);
+			selected_validators.push(validator);
+		}
+		Staking::<T>::nominate(
+			RawOrigin::Signed(n_controller.clone()).into(),
+			selected_validators,
+		)?;
+	}
+
+	ValidatorCount::<T>::put(validators);
+
+	Ok(validator_chosen)
+}
+
+/// get the current era.
+pub fn current_era<T: Config>() -> EraIndex {
+	<Pallet<T>>::current_era().unwrap_or(0)
+}
diff --git a/substrate/frame/staking/src/tests.rs b/substrate/frame/staking/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fd7dabac74d8de2e17753040720e04b5476a9b5a
--- /dev/null
+++ b/substrate/frame/staking/src/tests.rs
@@ -0,0 +1,6126 @@
+// 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 the module.
+
+use super::{ConfigOp, Event, *};
+use frame_election_provider_support::{
+	bounds::{DataProviderBounds, ElectionBoundsBuilder},
+	ElectionProvider, SortedListProvider, Support,
+};
+use frame_support::{
+	assert_noop, assert_ok, assert_storage_noop,
+	dispatch::{extract_actual_weight, GetDispatchInfo, WithPostDispatchInfo},
+	pallet_prelude::*,
+	traits::{Currency, Get, ReservableCurrency},
+};
+use mock::*;
+use pallet_balances::Error as BalancesError;
+use sp_runtime::{
+	assert_eq_error_rate, bounded_vec,
+	traits::{BadOrigin, Dispatchable},
+	Perbill, Percent, Rounding, TokenError,
+};
+use sp_staking::{
+	offence::{DisableStrategy, OffenceDetails, OnOffenceHandler},
+	SessionIndex,
+};
+use sp_std::prelude::*;
+use substrate_test_utils::assert_eq_uvec;
+
+#[test]
+fn set_staking_configs_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// setting works
+		assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			ConfigOp::Set(1_500),
+			ConfigOp::Set(2_000),
+			ConfigOp::Set(10),
+			ConfigOp::Set(20),
+			ConfigOp::Set(Percent::from_percent(75)),
+			ConfigOp::Set(Zero::zero())
+		));
+		assert_eq!(MinNominatorBond::<Test>::get(), 1_500);
+		assert_eq!(MinValidatorBond::<Test>::get(), 2_000);
+		assert_eq!(MaxNominatorsCount::<Test>::get(), Some(10));
+		assert_eq!(MaxValidatorsCount::<Test>::get(), Some(20));
+		assert_eq!(ChillThreshold::<Test>::get(), Some(Percent::from_percent(75)));
+		assert_eq!(MinCommission::<Test>::get(), Perbill::from_percent(0));
+
+		// noop does nothing
+		assert_storage_noop!(assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			ConfigOp::Noop,
+			ConfigOp::Noop,
+			ConfigOp::Noop,
+			ConfigOp::Noop,
+			ConfigOp::Noop,
+			ConfigOp::Noop
+		)));
+
+		// removing works
+		assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Remove
+		));
+		assert_eq!(MinNominatorBond::<Test>::get(), 0);
+		assert_eq!(MinValidatorBond::<Test>::get(), 0);
+		assert_eq!(MaxNominatorsCount::<Test>::get(), None);
+		assert_eq!(MaxValidatorsCount::<Test>::get(), None);
+		assert_eq!(ChillThreshold::<Test>::get(), None);
+		assert_eq!(MinCommission::<Test>::get(), Perbill::from_percent(0));
+	});
+}
+
+#[test]
+fn force_unstake_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// Account 11 (also controller) is stashed and locked
+		assert_eq!(Staking::bonded(&11), Some(11));
+		// Adds 2 slashing spans
+		add_slash(&11);
+		// Cant transfer
+		assert_noop!(
+			Balances::transfer_allow_death(RuntimeOrigin::signed(11), 1, 10),
+			TokenError::Frozen,
+		);
+		// Force unstake requires root.
+		assert_noop!(Staking::force_unstake(RuntimeOrigin::signed(11), 11, 2), BadOrigin);
+		// Force unstake needs correct number of slashing spans (for weight calculation)
+		assert_noop!(
+			Staking::force_unstake(RuntimeOrigin::root(), 11, 0),
+			Error::<Test>::IncorrectSlashingSpans
+		);
+		// We now force them to unstake
+		assert_ok!(Staking::force_unstake(RuntimeOrigin::root(), 11, 2));
+		// No longer bonded.
+		assert_eq!(Staking::bonded(&11), None);
+		// Transfer works.
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(11), 1, 10));
+	});
+}
+
+#[test]
+fn kill_stash_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// Account 11 (also controller) is stashed and locked
+		assert_eq!(Staking::bonded(&11), Some(11));
+		// Adds 2 slashing spans
+		add_slash(&11);
+		// Only can kill a stash account
+		assert_noop!(Staking::kill_stash(&12, 0), Error::<Test>::NotStash);
+		// Respects slashing span count
+		assert_noop!(Staking::kill_stash(&11, 0), Error::<Test>::IncorrectSlashingSpans);
+		// Correct inputs, everything works
+		assert_ok!(Staking::kill_stash(&11, 2));
+		// No longer bonded.
+		assert_eq!(Staking::bonded(&11), None);
+	});
+}
+
+#[test]
+fn basic_setup_works() {
+	// Verifies initial conditions of mock
+	ExtBuilder::default().build_and_execute(|| {
+		// Account 11 is stashed and locked, and is the controller
+		assert_eq!(Staking::bonded(&11), Some(11));
+		// Account 21 is stashed and locked and is the controller
+		assert_eq!(Staking::bonded(&21), Some(21));
+		// Account 1 is not a stashed
+		assert_eq!(Staking::bonded(&1), None);
+
+		// Account 11 controls its own stash, which is 100 * balance_factor units
+		assert_eq!(
+			Staking::ledger(&11).unwrap(),
+			StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			}
+		);
+		// Account 21 controls its own stash, which is 200 * balance_factor units
+		assert_eq!(
+			Staking::ledger(&21),
+			Some(StakingLedger {
+				stash: 21,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		// Account 1 does not control any stash
+		assert_eq!(Staking::ledger(&1), None);
+
+		// ValidatorPrefs are default
+		assert_eq_uvec!(
+			<Validators<Test>>::iter().collect::<Vec<_>>(),
+			vec![
+				(31, ValidatorPrefs::default()),
+				(21, ValidatorPrefs::default()),
+				(11, ValidatorPrefs::default())
+			]
+		);
+
+		assert_eq!(
+			Staking::ledger(101),
+			Some(StakingLedger {
+				stash: 101,
+				total: 500,
+				active: 500,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+		assert_eq!(
+			Staking::eras_stakers(active_era(), 11),
+			Exposure {
+				total: 1125,
+				own: 1000,
+				others: vec![IndividualExposure { who: 101, value: 125 }]
+			},
+		);
+		assert_eq!(
+			Staking::eras_stakers(active_era(), 21),
+			Exposure {
+				total: 1375,
+				own: 1000,
+				others: vec![IndividualExposure { who: 101, value: 375 }]
+			},
+		);
+
+		// initial total stake = 1125 + 1375
+		assert_eq!(Staking::eras_total_stake(active_era()), 2500);
+
+		// The number of validators required.
+		assert_eq!(Staking::validator_count(), 2);
+
+		// Initial Era and session
+		assert_eq!(active_era(), 0);
+
+		// Account 10 has `balance_factor` free balance
+		assert_eq!(Balances::free_balance(10), 1);
+		assert_eq!(Balances::free_balance(10), 1);
+
+		// New era is not being forced
+		assert_eq!(Staking::force_era(), Forcing::NotForcing);
+	});
+}
+
+#[test]
+fn change_controller_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let (stash, controller) = testing_utils::create_unique_stash_controller::<Test>(
+			0,
+			100,
+			RewardDestination::Staked,
+			false,
+		)
+		.unwrap();
+
+		// ensure `stash` and `controller` are bonded as stash controller pair.
+		assert_eq!(Staking::bonded(&stash), Some(controller));
+
+		// `controller` can control `stash` who is initially a validator.
+		assert_ok!(Staking::chill(RuntimeOrigin::signed(controller)));
+
+		// sets controller back to `stash`.
+		assert_ok!(Staking::set_controller(RuntimeOrigin::signed(stash)));
+		assert_eq!(Staking::bonded(&stash), Some(stash));
+		mock::start_active_era(1);
+
+		// `controller` is no longer in control. `stash` is now controller.
+		assert_noop!(
+			Staking::validate(RuntimeOrigin::signed(controller), ValidatorPrefs::default()),
+			Error::<Test>::NotController,
+		);
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(stash), ValidatorPrefs::default()));
+	})
+}
+
+#[test]
+fn change_controller_already_paired_once_stash() {
+	ExtBuilder::default().build_and_execute(|| {
+		// 10 and 11 are bonded as controller and stash respectively.
+		assert_eq!(Staking::bonded(&11), Some(11));
+
+		// 11 is initially a validator.
+		assert_ok!(Staking::chill(RuntimeOrigin::signed(11)));
+
+		// Controller cannot change once matching with stash.
+		assert_noop!(
+			Staking::set_controller(RuntimeOrigin::signed(11)),
+			Error::<Test>::AlreadyPaired
+		);
+		assert_eq!(Staking::bonded(&11), Some(11));
+		mock::start_active_era(1);
+
+		// 10 is no longer in control.
+		assert_noop!(
+			Staking::validate(RuntimeOrigin::signed(10), ValidatorPrefs::default()),
+			Error::<Test>::NotController,
+		);
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(11), ValidatorPrefs::default()));
+	})
+}
+
+#[test]
+fn rewards_should_work() {
+	ExtBuilder::default().nominate(true).session_per_era(3).build_and_execute(|| {
+		let init_balance_11 = Balances::total_balance(&11);
+		let init_balance_21 = Balances::total_balance(&21);
+		let init_balance_101 = Balances::total_balance(&101);
+
+		// Set payees
+		Payee::<Test>::insert(11, RewardDestination::Controller);
+		Payee::<Test>::insert(21, RewardDestination::Controller);
+		Payee::<Test>::insert(101, RewardDestination::Controller);
+
+		Pallet::<Test>::reward_by_ids(vec![(11, 50)]);
+		Pallet::<Test>::reward_by_ids(vec![(11, 50)]);
+		// This is the second validator of the current elected set.
+		Pallet::<Test>::reward_by_ids(vec![(21, 50)]);
+
+		// Compute total payout now for whole duration of the session.
+		let total_payout_0 = current_total_payout_for_duration(reward_time_per_era());
+		let maximum_payout = maximum_payout_for_duration(reward_time_per_era());
+
+		start_session(1);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+
+		assert_eq!(Balances::total_balance(&11), init_balance_11);
+		assert_eq!(Balances::total_balance(&21), init_balance_21);
+		assert_eq!(Balances::total_balance(&101), init_balance_101);
+		assert_eq!(
+			Staking::eras_reward_points(active_era()),
+			EraRewardPoints {
+				total: 50 * 3,
+				individual: vec![(11, 100), (21, 50)].into_iter().collect(),
+			}
+		);
+		let part_for_11 = Perbill::from_rational::<u32>(1000, 1125);
+		let part_for_21 = Perbill::from_rational::<u32>(1000, 1375);
+		let part_for_101_from_11 = Perbill::from_rational::<u32>(125, 1125);
+		let part_for_101_from_21 = Perbill::from_rational::<u32>(375, 1375);
+
+		start_session(2);
+		start_session(3);
+
+		assert_eq!(active_era(), 1);
+		assert_eq!(mock::RewardRemainderUnbalanced::get(), maximum_payout - total_payout_0,);
+		assert_eq!(
+			*mock::staking_events().last().unwrap(),
+			Event::EraPaid {
+				era_index: 0,
+				validator_payout: total_payout_0,
+				remainder: maximum_payout - total_payout_0
+			}
+		);
+		mock::make_all_reward_payment(0);
+
+		assert_eq_error_rate!(
+			Balances::total_balance(&11),
+			init_balance_11 + part_for_11 * total_payout_0 * 2 / 3,
+			2,
+		);
+		assert_eq_error_rate!(
+			Balances::total_balance(&21),
+			init_balance_21 + part_for_21 * total_payout_0 * 1 / 3,
+			2,
+		);
+		assert_eq_error_rate!(
+			Balances::total_balance(&101),
+			init_balance_101 +
+				part_for_101_from_11 * total_payout_0 * 2 / 3 +
+				part_for_101_from_21 * total_payout_0 * 1 / 3,
+			2
+		);
+
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_1 = current_total_payout_for_duration(reward_time_per_era());
+
+		mock::start_active_era(2);
+		assert_eq!(
+			mock::RewardRemainderUnbalanced::get(),
+			maximum_payout * 2 - total_payout_0 - total_payout_1,
+		);
+		assert_eq!(
+			*mock::staking_events().last().unwrap(),
+			Event::EraPaid {
+				era_index: 1,
+				validator_payout: total_payout_1,
+				remainder: maximum_payout - total_payout_1
+			}
+		);
+		mock::make_all_reward_payment(1);
+
+		assert_eq_error_rate!(
+			Balances::total_balance(&11),
+			init_balance_11 + part_for_11 * (total_payout_0 * 2 / 3 + total_payout_1),
+			2,
+		);
+		assert_eq_error_rate!(
+			Balances::total_balance(&21),
+			init_balance_21 + part_for_21 * total_payout_0 * 1 / 3,
+			2,
+		);
+		assert_eq_error_rate!(
+			Balances::total_balance(&101),
+			init_balance_101 +
+				part_for_101_from_11 * (total_payout_0 * 2 / 3 + total_payout_1) +
+				part_for_101_from_21 * total_payout_0 * 1 / 3,
+			2
+		);
+	});
+}
+
+#[test]
+fn staking_should_work() {
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// remember + compare this along with the test.
+		assert_eq_uvec!(validator_controllers(), vec![21, 11]);
+
+		// put some money in account that we'll use.
+		for i in 1..5 {
+			let _ = Balances::make_free_balance_be(&i, 2000);
+		}
+
+		// --- Block 2:
+		start_session(2);
+		// add a new candidate for being a validator. account 3 controlled by 4.
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(3), 1500, RewardDestination::Controller));
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(3), ValidatorPrefs::default()));
+		assert_ok!(Session::set_keys(
+			RuntimeOrigin::signed(3),
+			SessionKeys { other: 4.into() },
+			vec![]
+		));
+
+		// No effects will be seen so far.
+		assert_eq_uvec!(validator_controllers(), vec![21, 11]);
+
+		// --- Block 3:
+		start_session(3);
+
+		// No effects will be seen so far. Era has not been yet triggered.
+		assert_eq_uvec!(validator_controllers(), vec![21, 11]);
+
+		// --- Block 4: the validators will now be queued.
+		start_session(4);
+		assert_eq!(active_era(), 1);
+
+		// --- Block 5: the validators are still in queue.
+		start_session(5);
+
+		// --- Block 6: the validators will now be changed.
+		start_session(6);
+
+		assert_eq_uvec!(validator_controllers(), vec![21, 3]);
+		// --- Block 6: Unstake 4 as a validator, freeing up the balance stashed in 3
+		// 4 will chill
+		Staking::chill(RuntimeOrigin::signed(3)).unwrap();
+
+		// --- Block 7: nothing. 3 is still there.
+		start_session(7);
+		assert_eq_uvec!(validator_controllers(), vec![21, 3]);
+
+		// --- Block 8:
+		start_session(8);
+
+		// --- Block 9: 4 will not be a validator.
+		start_session(9);
+		assert_eq_uvec!(validator_controllers(), vec![21, 11]);
+
+		// Note: the stashed value of 4 is still lock
+		assert_eq!(
+			Staking::ledger(&3),
+			Some(StakingLedger {
+				stash: 3,
+				total: 1500,
+				active: 1500,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![0],
+			})
+		);
+		// e.g. it cannot reserve more than 500 that it has free from the total 2000
+		assert_noop!(Balances::reserve(&3, 501), BalancesError::<Test, _>::LiquidityRestrictions);
+		assert_ok!(Balances::reserve(&3, 409));
+	});
+}
+
+#[test]
+fn blocking_and_kicking_works() {
+	ExtBuilder::default()
+		.minimum_validator_count(1)
+		.validator_count(4)
+		.nominate(true)
+		.build_and_execute(|| {
+			// block validator 10/11
+			assert_ok!(Staking::validate(
+				RuntimeOrigin::signed(11),
+				ValidatorPrefs { blocked: true, ..Default::default() }
+			));
+			// attempt to nominate from 100/101...
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(101), vec![11]));
+			// should have worked since we're already nominated them
+			assert_eq!(Nominators::<Test>::get(&101).unwrap().targets, vec![11]);
+			// kick the nominator
+			assert_ok!(Staking::kick(RuntimeOrigin::signed(11), vec![101]));
+			// should have been kicked now
+			assert!(Nominators::<Test>::get(&101).unwrap().targets.is_empty());
+			// attempt to nominate from 100/101...
+			assert_noop!(
+				Staking::nominate(RuntimeOrigin::signed(101), vec![11]),
+				Error::<Test>::BadTarget
+			);
+		});
+}
+
+#[test]
+fn less_than_needed_candidates_works() {
+	ExtBuilder::default()
+		.minimum_validator_count(1)
+		.validator_count(4)
+		.nominate(false)
+		.build_and_execute(|| {
+			assert_eq!(Staking::validator_count(), 4);
+			assert_eq!(Staking::minimum_validator_count(), 1);
+			assert_eq_uvec!(validator_controllers(), vec![31, 21, 11]);
+
+			mock::start_active_era(1);
+
+			// Previous set is selected. NO election algorithm is even executed.
+			assert_eq_uvec!(validator_controllers(), vec![31, 21, 11]);
+
+			// But the exposure is updated in a simple way. No external votes exists.
+			// This is purely self-vote.
+			assert!(ErasStakers::<Test>::iter_prefix_values(active_era())
+				.all(|exposure| exposure.others.is_empty()));
+		});
+}
+
+#[test]
+fn no_candidate_emergency_condition() {
+	ExtBuilder::default()
+		.minimum_validator_count(1)
+		.validator_count(15)
+		.set_status(41, StakerStatus::Validator)
+		.nominate(false)
+		.build_and_execute(|| {
+			// initial validators
+			assert_eq_uvec!(validator_controllers(), vec![11, 21, 31, 41]);
+			let prefs = ValidatorPrefs { commission: Perbill::one(), ..Default::default() };
+			Validators::<Test>::insert(11, prefs.clone());
+
+			// set the minimum validator count.
+			MinimumValidatorCount::<Test>::put(11);
+
+			// try to chill
+			let res = Staking::chill(RuntimeOrigin::signed(11));
+			assert_ok!(res);
+
+			let current_era = CurrentEra::<Test>::get();
+
+			// try trigger new era
+			mock::run_to_block(21);
+			assert_eq!(*staking_events().last().unwrap(), Event::StakingElectionFailed);
+			// No new era is created
+			assert_eq!(current_era, CurrentEra::<Test>::get());
+
+			// Go to far further session to see if validator have changed
+			mock::run_to_block(100);
+
+			// Previous ones are elected. chill is not effective in active era (as era hasn't
+			// changed)
+			assert_eq_uvec!(validator_controllers(), vec![11, 21, 31, 41]);
+			// The chill is still pending.
+			assert!(!Validators::<Test>::contains_key(11));
+			// No new era is created.
+			assert_eq!(current_era, CurrentEra::<Test>::get());
+		});
+}
+
+#[test]
+fn nominating_and_rewards_should_work() {
+	ExtBuilder::default()
+		.nominate(false)
+		.set_status(41, StakerStatus::Validator)
+		.set_status(11, StakerStatus::Idle)
+		.set_status(31, StakerStatus::Idle)
+		.build_and_execute(|| {
+			// initial validators.
+			assert_eq_uvec!(validator_controllers(), vec![41, 21]);
+
+			// re-validate with 11 and 31.
+			assert_ok!(Staking::validate(RuntimeOrigin::signed(11), Default::default()));
+			assert_ok!(Staking::validate(RuntimeOrigin::signed(31), Default::default()));
+
+			// Set payee to controller.
+			assert_ok!(Staking::set_payee(
+				RuntimeOrigin::signed(11),
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::set_payee(
+				RuntimeOrigin::signed(21),
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::set_payee(
+				RuntimeOrigin::signed(31),
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::set_payee(
+				RuntimeOrigin::signed(41),
+				RewardDestination::Controller
+			));
+
+			// give the man some money
+			let initial_balance = 1000;
+			for i in [1, 3, 5, 11, 21].iter() {
+				let _ = Balances::make_free_balance_be(i, initial_balance);
+			}
+
+			// bond two account pairs and state interest in nomination.
+			assert_ok!(Staking::bond(
+				RuntimeOrigin::signed(1),
+				1000,
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(1), vec![11, 21, 31]));
+
+			assert_ok!(Staking::bond(
+				RuntimeOrigin::signed(3),
+				1000,
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(3), vec![11, 21, 41]));
+
+			// the total reward for era 0
+			let total_payout_0 = current_total_payout_for_duration(reward_time_per_era());
+			Pallet::<Test>::reward_by_ids(vec![(41, 1)]);
+			Pallet::<Test>::reward_by_ids(vec![(21, 1)]);
+
+			mock::start_active_era(1);
+
+			// 10 and 20 have more votes, they will be chosen.
+			assert_eq_uvec!(validator_controllers(), vec![21, 11]);
+
+			// old validators must have already received some rewards.
+			let initial_balance_41 = Balances::total_balance(&41);
+			let mut initial_balance_21 = Balances::total_balance(&21);
+			mock::make_all_reward_payment(0);
+			assert_eq!(Balances::total_balance(&41), initial_balance_41 + total_payout_0 / 2);
+			assert_eq!(Balances::total_balance(&21), initial_balance_21 + total_payout_0 / 2);
+			initial_balance_21 = Balances::total_balance(&21);
+
+			assert_eq!(ErasStakers::<Test>::iter_prefix_values(active_era()).count(), 2);
+			assert_eq!(
+				Staking::eras_stakers(active_era(), 11),
+				Exposure {
+					total: 1000 + 800,
+					own: 1000,
+					others: vec![
+						IndividualExposure { who: 1, value: 400 },
+						IndividualExposure { who: 3, value: 400 },
+					]
+				},
+			);
+			assert_eq!(
+				Staking::eras_stakers(active_era(), 21),
+				Exposure {
+					total: 1000 + 1200,
+					own: 1000,
+					others: vec![
+						IndividualExposure { who: 1, value: 600 },
+						IndividualExposure { who: 3, value: 600 },
+					]
+				},
+			);
+
+			// the total reward for era 1
+			let total_payout_1 = current_total_payout_for_duration(reward_time_per_era());
+			Pallet::<Test>::reward_by_ids(vec![(21, 2)]);
+			Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+
+			mock::start_active_era(2);
+
+			// nothing else will happen, era ends and rewards are paid again, it is expected that
+			// nominators will also be paid. See below
+
+			mock::make_all_reward_payment(1);
+			let payout_for_11 = total_payout_1 / 3;
+			let payout_for_21 = 2 * total_payout_1 / 3;
+			// Nominator 2: has [400/1800 ~ 2/9 from 10] + [600/2200 ~ 3/11 from 21]'s reward. ==>
+			// 2/9 + 3/11
+			assert_eq_error_rate!(
+				Balances::total_balance(&1),
+				initial_balance + (2 * payout_for_11 / 9 + 3 * payout_for_21 / 11),
+				2,
+			);
+			// Nominator 3: has [400/1800 ~ 2/9 from 10] + [600/2200 ~ 3/11 from 21]'s reward. ==>
+			// 2/9 + 3/11
+			assert_eq_error_rate!(
+				Balances::total_balance(&3),
+				initial_balance + (2 * payout_for_11 / 9 + 3 * payout_for_21 / 11),
+				2,
+			);
+
+			// Validator 11: got 800 / 1800 external stake => 8/18 =? 4/9 => Validator's share = 5/9
+			assert_eq_error_rate!(
+				Balances::total_balance(&11),
+				initial_balance + 5 * payout_for_11 / 9,
+				2,
+			);
+			// Validator 21: got 1200 / 2200 external stake => 12/22 =? 6/11 => Validator's share =
+			// 5/11
+			assert_eq_error_rate!(
+				Balances::total_balance(&21),
+				initial_balance_21 + 5 * payout_for_21 / 11,
+				2,
+			);
+		});
+}
+
+#[test]
+fn nominators_also_get_slashed_pro_rata() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+		let slash_percent = Perbill::from_percent(5);
+		let initial_exposure = Staking::eras_stakers(active_era(), 11);
+		// 101 is a nominator for 11
+		assert_eq!(initial_exposure.others.first().unwrap().who, 101);
+
+		// staked values;
+		let nominator_stake = Staking::ledger(101).unwrap().active;
+		let nominator_balance = balances(&101).0;
+		let validator_stake = Staking::ledger(11).unwrap().active;
+		let validator_balance = balances(&11).0;
+		let exposed_stake = initial_exposure.total;
+		let exposed_validator = initial_exposure.own;
+		let exposed_nominator = initial_exposure.others.first().unwrap().value;
+
+		// 11 goes offline
+		on_offence_now(
+			&[OffenceDetails { offender: (11, initial_exposure.clone()), reporters: vec![] }],
+			&[slash_percent],
+		);
+
+		// both stakes must have been decreased.
+		assert!(Staking::ledger(101).unwrap().active < nominator_stake);
+		assert!(Staking::ledger(11).unwrap().active < validator_stake);
+
+		let slash_amount = slash_percent * exposed_stake;
+		let validator_share =
+			Perbill::from_rational(exposed_validator, exposed_stake) * slash_amount;
+		let nominator_share =
+			Perbill::from_rational(exposed_nominator, exposed_stake) * slash_amount;
+
+		// both slash amounts need to be positive for the test to make sense.
+		assert!(validator_share > 0);
+		assert!(nominator_share > 0);
+
+		// both stakes must have been decreased pro-rata.
+		assert_eq!(Staking::ledger(101).unwrap().active, nominator_stake - nominator_share);
+		assert_eq!(Staking::ledger(11).unwrap().active, validator_stake - validator_share);
+		assert_eq!(
+			balances(&101).0, // free balance
+			nominator_balance - nominator_share,
+		);
+		assert_eq!(
+			balances(&11).0, // free balance
+			validator_balance - validator_share,
+		);
+		// Because slashing happened.
+		assert!(is_disabled(11));
+	});
+}
+
+#[test]
+fn double_staking_should_fail() {
+	// should test (in the same order):
+	// * an account already bonded as stash cannot be be stashed again.
+	// * an account already bonded as stash cannot nominate.
+	// * an account already bonded as controller can nominate.
+	ExtBuilder::default().build_and_execute(|| {
+		let arbitrary_value = 5;
+		let (stash, controller) = testing_utils::create_unique_stash_controller::<Test>(
+			0,
+			arbitrary_value,
+			RewardDestination::default(),
+			false,
+		)
+		.unwrap();
+
+		// 4 = not used so far,  stash => not allowed.
+		assert_noop!(
+			Staking::bond(
+				RuntimeOrigin::signed(stash),
+				arbitrary_value.into(),
+				RewardDestination::default()
+			),
+			Error::<Test>::AlreadyBonded,
+		);
+		// stash => attempting to nominate should fail.
+		assert_noop!(
+			Staking::nominate(RuntimeOrigin::signed(stash), vec![1]),
+			Error::<Test>::NotController
+		);
+		// controller => nominating should work.
+		assert_ok!(Staking::nominate(RuntimeOrigin::signed(controller), vec![1]));
+	});
+}
+
+#[test]
+fn double_controlling_attempt_should_fail() {
+	// should test (in the same order):
+	// * an account already bonded as controller CANNOT be reused as the controller of another
+	//   account.
+	ExtBuilder::default().build_and_execute(|| {
+		let arbitrary_value = 5;
+		let (stash, _) = testing_utils::create_unique_stash_controller::<Test>(
+			0,
+			arbitrary_value,
+			RewardDestination::default(),
+			false,
+		)
+		.unwrap();
+
+		// Note that controller (same as stash) is reused => no-op.
+		assert_noop!(
+			Staking::bond(
+				RuntimeOrigin::signed(stash),
+				arbitrary_value.into(),
+				RewardDestination::default()
+			),
+			Error::<Test>::AlreadyBonded,
+		);
+	});
+}
+
+#[test]
+fn session_and_eras_work_simple() {
+	ExtBuilder::default().period(1).build_and_execute(|| {
+		assert_eq!(active_era(), 0);
+		assert_eq!(current_era(), 0);
+		assert_eq!(Session::current_index(), 1);
+		assert_eq!(System::block_number(), 1);
+
+		// Session 1: this is basically a noop. This has already been started.
+		start_session(1);
+		assert_eq!(Session::current_index(), 1);
+		assert_eq!(active_era(), 0);
+		assert_eq!(System::block_number(), 1);
+
+		// Session 2: No change.
+		start_session(2);
+		assert_eq!(Session::current_index(), 2);
+		assert_eq!(active_era(), 0);
+		assert_eq!(System::block_number(), 2);
+
+		// Session 3: Era increment.
+		start_session(3);
+		assert_eq!(Session::current_index(), 3);
+		assert_eq!(active_era(), 1);
+		assert_eq!(System::block_number(), 3);
+
+		// Session 4: No change.
+		start_session(4);
+		assert_eq!(Session::current_index(), 4);
+		assert_eq!(active_era(), 1);
+		assert_eq!(System::block_number(), 4);
+
+		// Session 5: No change.
+		start_session(5);
+		assert_eq!(Session::current_index(), 5);
+		assert_eq!(active_era(), 1);
+		assert_eq!(System::block_number(), 5);
+
+		// Session 6: Era increment.
+		start_session(6);
+		assert_eq!(Session::current_index(), 6);
+		assert_eq!(active_era(), 2);
+		assert_eq!(System::block_number(), 6);
+	});
+}
+
+#[test]
+fn session_and_eras_work_complex() {
+	ExtBuilder::default().period(5).build_and_execute(|| {
+		assert_eq!(active_era(), 0);
+		assert_eq!(Session::current_index(), 0);
+		assert_eq!(System::block_number(), 1);
+
+		start_session(1);
+		assert_eq!(Session::current_index(), 1);
+		assert_eq!(active_era(), 0);
+		assert_eq!(System::block_number(), 5);
+
+		start_session(2);
+		assert_eq!(Session::current_index(), 2);
+		assert_eq!(active_era(), 0);
+		assert_eq!(System::block_number(), 10);
+
+		start_session(3);
+		assert_eq!(Session::current_index(), 3);
+		assert_eq!(active_era(), 1);
+		assert_eq!(System::block_number(), 15);
+
+		start_session(4);
+		assert_eq!(Session::current_index(), 4);
+		assert_eq!(active_era(), 1);
+		assert_eq!(System::block_number(), 20);
+
+		start_session(5);
+		assert_eq!(Session::current_index(), 5);
+		assert_eq!(active_era(), 1);
+		assert_eq!(System::block_number(), 25);
+
+		start_session(6);
+		assert_eq!(Session::current_index(), 6);
+		assert_eq!(active_era(), 2);
+		assert_eq!(System::block_number(), 30);
+	});
+}
+
+#[test]
+fn forcing_new_era_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// normal flow of session.
+		start_session(1);
+		assert_eq!(active_era(), 0);
+
+		start_session(2);
+		assert_eq!(active_era(), 0);
+
+		start_session(3);
+		assert_eq!(active_era(), 1);
+
+		// no era change.
+		Staking::set_force_era(Forcing::ForceNone);
+
+		start_session(4);
+		assert_eq!(active_era(), 1);
+
+		start_session(5);
+		assert_eq!(active_era(), 1);
+
+		start_session(6);
+		assert_eq!(active_era(), 1);
+
+		start_session(7);
+		assert_eq!(active_era(), 1);
+
+		// back to normal.
+		// this immediately starts a new session.
+		Staking::set_force_era(Forcing::NotForcing);
+
+		start_session(8);
+		assert_eq!(active_era(), 1);
+
+		start_session(9);
+		assert_eq!(active_era(), 2);
+		// forceful change
+		Staking::set_force_era(Forcing::ForceAlways);
+
+		start_session(10);
+		assert_eq!(active_era(), 2);
+
+		start_session(11);
+		assert_eq!(active_era(), 3);
+
+		start_session(12);
+		assert_eq!(active_era(), 4);
+
+		// just one forceful change
+		Staking::set_force_era(Forcing::ForceNew);
+		start_session(13);
+		assert_eq!(active_era(), 5);
+		assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
+
+		start_session(14);
+		assert_eq!(active_era(), 6);
+
+		start_session(15);
+		assert_eq!(active_era(), 6);
+	});
+}
+
+#[test]
+fn cannot_transfer_staked_balance() {
+	// Tests that a stash account cannot transfer funds
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Confirm account 11 is stashed
+		assert_eq!(Staking::bonded(&11), Some(11));
+		// Confirm account 11 has some free balance
+		assert_eq!(Balances::free_balance(11), 1000);
+		// Confirm account 11 (via controller) is totally staked
+		assert_eq!(Staking::eras_stakers(active_era(), 11).total, 1000);
+		// Confirm account 11 cannot transfer as a result
+		assert_noop!(
+			Balances::transfer_allow_death(RuntimeOrigin::signed(11), 21, 1),
+			TokenError::Frozen,
+		);
+
+		// Give account 11 extra free balance
+		let _ = Balances::make_free_balance_be(&11, 10000);
+		// Confirm that account 11 can now transfer some balance
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(11), 21, 1));
+	});
+}
+
+#[test]
+fn cannot_transfer_staked_balance_2() {
+	// Tests that a stash account cannot transfer funds
+	// Same test as above but with 20, and more accurate.
+	// 21 has 2000 free balance but 1000 at stake
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Confirm account 21 is stashed
+		assert_eq!(Staking::bonded(&21), Some(21));
+		// Confirm account 21 has some free balance
+		assert_eq!(Balances::free_balance(21), 2000);
+		// Confirm account 21 (via controller) is totally staked
+		assert_eq!(Staking::eras_stakers(active_era(), 21).total, 1000);
+		// Confirm account 21 can transfer at most 1000
+		assert_noop!(
+			Balances::transfer_allow_death(RuntimeOrigin::signed(21), 21, 1001),
+			TokenError::Frozen,
+		);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(21), 21, 1000));
+	});
+}
+
+#[test]
+fn cannot_reserve_staked_balance() {
+	// Checks that a bonded account cannot reserve balance from free balance
+	ExtBuilder::default().build_and_execute(|| {
+		// Confirm account 11 is stashed
+		assert_eq!(Staking::bonded(&11), Some(11));
+		// Confirm account 11 has some free balance
+		assert_eq!(Balances::free_balance(11), 1000);
+		// Confirm account 11 (via controller 10) is totally staked
+		assert_eq!(Staking::eras_stakers(active_era(), 11).own, 1000);
+		// Confirm account 11 cannot reserve as a result
+		assert_noop!(Balances::reserve(&11, 1), BalancesError::<Test, _>::LiquidityRestrictions);
+
+		// Give account 11 extra free balance
+		let _ = Balances::make_free_balance_be(&11, 10000);
+		// Confirm account 11 can now reserve balance
+		assert_ok!(Balances::reserve(&11, 1));
+	});
+}
+
+#[test]
+fn reward_destination_works() {
+	// Rewards go to the correct destination as determined in Payee
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Check that account 11 is a validator
+		assert!(Session::validators().contains(&11));
+		// Check the balance of the validator account
+		assert_eq!(Balances::free_balance(10), 1);
+		// Check the balance of the stash account
+		assert_eq!(Balances::free_balance(11), 1000);
+		// Check how much is at stake
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_0 = current_total_payout_for_duration(reward_time_per_era());
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+
+		mock::start_active_era(1);
+		mock::make_all_reward_payment(0);
+
+		// Check that RewardDestination is Staked (default)
+		assert_eq!(Staking::payee(&11), RewardDestination::Staked);
+		// Check that reward went to the stash account of validator
+		assert_eq!(Balances::free_balance(11), 1000 + total_payout_0);
+		// Check that amount at stake increased accordingly
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + total_payout_0,
+				active: 1000 + total_payout_0,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![0],
+			})
+		);
+
+		// Change RewardDestination to Stash
+		<Payee<Test>>::insert(&11, RewardDestination::Stash);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_1 = current_total_payout_for_duration(reward_time_per_era());
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+
+		mock::start_active_era(2);
+		mock::make_all_reward_payment(1);
+
+		// Check that RewardDestination is Stash
+		assert_eq!(Staking::payee(&11), RewardDestination::Stash);
+		// Check that reward went to the stash account
+		assert_eq!(Balances::free_balance(11), 1000 + total_payout_0 + total_payout_1);
+		// Check that amount at stake is NOT increased
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + total_payout_0,
+				active: 1000 + total_payout_0,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![0, 1],
+			})
+		);
+
+		// Change RewardDestination to Controller
+		<Payee<Test>>::insert(&11, RewardDestination::Controller);
+
+		// Check controller balance
+		assert_eq!(Balances::free_balance(11), 23150);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_2 = current_total_payout_for_duration(reward_time_per_era());
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+
+		mock::start_active_era(3);
+		mock::make_all_reward_payment(2);
+
+		// Check that RewardDestination is Controller
+		assert_eq!(Staking::payee(&11), RewardDestination::Controller);
+		// Check that reward went to the controller account
+		assert_eq!(Balances::free_balance(11), 23150 + total_payout_2);
+		// Check that amount at stake is NOT increased
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + total_payout_0,
+				active: 1000 + total_payout_0,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![0, 1, 2],
+			})
+		);
+	});
+}
+
+#[test]
+fn validator_payment_prefs_work() {
+	// Test that validator preferences are correctly honored
+	// Note: unstake threshold is being directly tested in slashing tests.
+	// This test will focus on validator payment.
+	ExtBuilder::default().build_and_execute(|| {
+		let commission = Perbill::from_percent(40);
+		<Validators<Test>>::insert(&11, ValidatorPrefs { commission, ..Default::default() });
+
+		// Reward controller so staked ratio doesn't change.
+		<Payee<Test>>::insert(&11, RewardDestination::Controller);
+		<Payee<Test>>::insert(&101, RewardDestination::Controller);
+
+		mock::start_active_era(1);
+		mock::make_all_reward_payment(0);
+
+		let balance_era_1_11 = Balances::total_balance(&11);
+		let balance_era_1_101 = Balances::total_balance(&101);
+
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_1 = current_total_payout_for_duration(reward_time_per_era());
+		let exposure_1 = Staking::eras_stakers(active_era(), 11);
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+
+		mock::start_active_era(2);
+		mock::make_all_reward_payment(1);
+
+		let taken_cut = commission * total_payout_1;
+		let shared_cut = total_payout_1 - taken_cut;
+		let reward_of_10 = shared_cut * exposure_1.own / exposure_1.total + taken_cut;
+		let reward_of_100 = shared_cut * exposure_1.others[0].value / exposure_1.total;
+		assert_eq_error_rate!(Balances::total_balance(&11), balance_era_1_11 + reward_of_10, 2);
+		assert_eq_error_rate!(Balances::total_balance(&101), balance_era_1_101 + reward_of_100, 2);
+	});
+}
+
+#[test]
+fn bond_extra_works() {
+	// Tests that extra `free_balance` in the stash can be added to stake
+	// NOTE: this tests only verifies `StakingLedger` for correct updates
+	// See `bond_extra_and_withdraw_unbonded_works` for more details and updates on `Exposure`.
+	ExtBuilder::default().build_and_execute(|| {
+		// Check that account 10 is a validator
+		assert!(<Validators<Test>>::contains_key(11));
+		// Check that account 10 is bonded to account 11
+		assert_eq!(Staking::bonded(&11), Some(11));
+		// Check how much is at stake
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Give account 11 some large free balance greater than total
+		let _ = Balances::make_free_balance_be(&11, 1000000);
+
+		// Call the bond_extra function from controller, add only 100
+		assert_ok!(Staking::bond_extra(RuntimeOrigin::signed(11), 100));
+		// There should be 100 more `total` and `active` in the ledger
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + 100,
+				active: 1000 + 100,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Call the bond_extra function with a large number, should handle it
+		assert_ok!(Staking::bond_extra(RuntimeOrigin::signed(11), Balance::max_value()));
+		// The full amount of the funds should now be in the total and active
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000000,
+				active: 1000000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+	});
+}
+
+#[test]
+fn bond_extra_and_withdraw_unbonded_works() {
+	//
+	// * Should test
+	// * Given an account being bonded [and chosen as a validator](not mandatory)
+	// * It can add extra funds to the bonded account.
+	// * it can unbond a portion of its funds from the stash account.
+	// * Once the unbonding period is done, it can actually take the funds out of the stash.
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Set payee to controller. avoids confusion
+		assert_ok!(Staking::set_payee(RuntimeOrigin::signed(11), RewardDestination::Controller));
+
+		// Give account 11 some large free balance greater than total
+		let _ = Balances::make_free_balance_be(&11, 1000000);
+
+		// Initial config should be correct
+		assert_eq!(active_era(), 0);
+
+		// check the balance of a validator accounts.
+		assert_eq!(Balances::total_balance(&11), 1000000);
+
+		// confirm that 10 is a normal validator and gets paid at the end of the era.
+		mock::start_active_era(1);
+
+		// Initial state of 11
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		assert_eq!(
+			Staking::eras_stakers(active_era(), 11),
+			Exposure { total: 1000, own: 1000, others: vec![] }
+		);
+
+		// deposit the extra 100 units
+		Staking::bond_extra(RuntimeOrigin::signed(11), 100).unwrap();
+
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + 100,
+				active: 1000 + 100,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		// Exposure is a snapshot! only updated after the next era update.
+		assert_ne!(
+			Staking::eras_stakers(active_era(), 11),
+			Exposure { total: 1000 + 100, own: 1000 + 100, others: vec![] }
+		);
+
+		// trigger next era.
+		mock::start_active_era(2);
+		assert_eq!(active_era(), 2);
+
+		// ledger should be the same.
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + 100,
+				active: 1000 + 100,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		// Exposure is now updated.
+		assert_eq!(
+			Staking::eras_stakers(active_era(), 11),
+			Exposure { total: 1000 + 100, own: 1000 + 100, others: vec![] }
+		);
+
+		// Unbond almost all of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 1000).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + 100,
+				active: 100,
+				unlocking: bounded_vec![UnlockChunk { value: 1000, era: 2 + 3 }],
+				claimed_rewards: bounded_vec![],
+			}),
+		);
+
+		// Attempting to free the balances now will fail. 2 eras need to pass.
+		assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(11), 0));
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + 100,
+				active: 100,
+				unlocking: bounded_vec![UnlockChunk { value: 1000, era: 2 + 3 }],
+				claimed_rewards: bounded_vec![],
+			}),
+		);
+
+		// trigger next era.
+		mock::start_active_era(3);
+
+		// nothing yet
+		assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(11), 0));
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000 + 100,
+				active: 100,
+				unlocking: bounded_vec![UnlockChunk { value: 1000, era: 2 + 3 }],
+				claimed_rewards: bounded_vec![],
+			}),
+		);
+
+		// trigger next era.
+		mock::start_active_era(5);
+
+		assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(11), 0));
+		// Now the value is free and the staking ledger is updated.
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 100,
+				active: 100,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			}),
+		);
+	})
+}
+
+#[test]
+fn many_unbond_calls_should_work() {
+	ExtBuilder::default().build_and_execute(|| {
+		let mut current_era = 0;
+		// locked at era MaxUnlockingChunks - 1 until 3
+
+		let max_unlocking_chunks = <<Test as Config>::MaxUnlockingChunks as Get<u32>>::get();
+
+		for i in 0..max_unlocking_chunks - 1 {
+			// There is only 1 chunk per era, so we need to be in a new era to create a chunk.
+			current_era = i as u32;
+			mock::start_active_era(current_era);
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 1));
+		}
+
+		current_era += 1;
+		mock::start_active_era(current_era);
+
+		// This chunk is locked at `current_era` through `current_era + 2` (because
+		// `BondingDuration` == 3).
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 1));
+		assert_eq!(
+			Staking::ledger(&11).map(|l| l.unlocking.len()).unwrap(),
+			<<Test as Config>::MaxUnlockingChunks as Get<u32>>::get() as usize
+		);
+
+		// even though the number of unlocked chunks is the same as `MaxUnlockingChunks`,
+		// unbonding works as expected.
+		for i in current_era..(current_era + max_unlocking_chunks) - 1 {
+			// There is only 1 chunk per era, so we need to be in a new era to create a chunk.
+			current_era = i as u32;
+			mock::start_active_era(current_era);
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 1));
+		}
+
+		// only slots within last `BondingDuration` are filled.
+		assert_eq!(
+			Staking::ledger(&11).map(|l| l.unlocking.len()).unwrap(),
+			<<Test as Config>::BondingDuration>::get() as usize
+		);
+	})
+}
+
+#[test]
+fn auto_withdraw_may_not_unlock_all_chunks() {
+	ExtBuilder::default().build_and_execute(|| {
+		// set `MaxUnlockingChunks` to a low number to test case when the unbonding period
+		// is larger than the number of unlocking chunks available, which may result on a
+		// `Error::NoMoreChunks`, even when the auto-withdraw tries to release locked chunks.
+		MaxUnlockingChunks::set(1);
+
+		let mut current_era = 0;
+
+		// fills the chunking slots for account
+		mock::start_active_era(current_era);
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 1));
+
+		current_era += 1;
+		mock::start_active_era(current_era);
+
+		// unbonding will fail because i) there are no remaining chunks and ii) no filled chunks
+		// can be released because current chunk hasn't stay in the queue for at least
+		// `BondingDuration`
+		assert_noop!(Staking::unbond(RuntimeOrigin::signed(11), 1), Error::<Test>::NoMoreChunks);
+
+		// fast-forward a few eras for unbond to be successful with implicit withdraw
+		current_era += 10;
+		mock::start_active_era(current_era);
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 1));
+	})
+}
+
+#[test]
+fn rebond_works() {
+	//
+	// * Should test
+	// * Given an account being bonded [and chosen as a validator](not mandatory)
+	// * it can unbond a portion of its funds from the stash account.
+	// * it can re-bond a portion of the funds scheduled to unlock.
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Set payee to controller. avoids confusion
+		assert_ok!(Staking::set_payee(RuntimeOrigin::signed(11), RewardDestination::Controller));
+
+		// Give account 11 some large free balance greater than total
+		let _ = Balances::make_free_balance_be(&11, 1000000);
+
+		// confirm that 10 is a normal validator and gets paid at the end of the era.
+		mock::start_active_era(1);
+
+		// Initial state of 11
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		mock::start_active_era(2);
+		assert_eq!(active_era(), 2);
+
+		// Try to rebond some funds. We get an error since no fund is unbonded.
+		assert_noop!(Staking::rebond(RuntimeOrigin::signed(11), 500), Error::<Test>::NoUnlockChunk);
+
+		// Unbond almost all of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 900).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 100,
+				unlocking: bounded_vec![UnlockChunk { value: 900, era: 2 + 3 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Re-bond all the funds unbonded.
+		Staking::rebond(RuntimeOrigin::signed(11), 900).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Unbond almost all of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 900).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 100,
+				unlocking: bounded_vec![UnlockChunk { value: 900, era: 5 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Re-bond part of the funds unbonded.
+		Staking::rebond(RuntimeOrigin::signed(11), 500).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 600,
+				unlocking: bounded_vec![UnlockChunk { value: 400, era: 5 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Re-bond the remainder of the funds unbonded.
+		Staking::rebond(RuntimeOrigin::signed(11), 500).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Unbond parts of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 300).unwrap();
+		Staking::unbond(RuntimeOrigin::signed(11), 300).unwrap();
+		Staking::unbond(RuntimeOrigin::signed(11), 300).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 100,
+				unlocking: bounded_vec![UnlockChunk { value: 900, era: 5 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Re-bond part of the funds unbonded.
+		Staking::rebond(RuntimeOrigin::signed(11), 500).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 600,
+				unlocking: bounded_vec![UnlockChunk { value: 400, era: 5 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+	})
+}
+
+#[test]
+fn rebond_is_fifo() {
+	// Rebond should proceed by reversing the most recent bond operations.
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Set payee to controller. avoids confusion
+		assert_ok!(Staking::set_payee(RuntimeOrigin::signed(11), RewardDestination::Controller));
+
+		// Give account 11 some large free balance greater than total
+		let _ = Balances::make_free_balance_be(&11, 1000000);
+
+		// confirm that 10 is a normal validator and gets paid at the end of the era.
+		mock::start_active_era(1);
+
+		// Initial state of 10
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		mock::start_active_era(2);
+
+		// Unbond some of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 400).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 600,
+				unlocking: bounded_vec![UnlockChunk { value: 400, era: 2 + 3 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		mock::start_active_era(3);
+
+		// Unbond more of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 300).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 300,
+				unlocking: bounded_vec![
+					UnlockChunk { value: 400, era: 2 + 3 },
+					UnlockChunk { value: 300, era: 3 + 3 },
+				],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		mock::start_active_era(4);
+
+		// Unbond yet more of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 200).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 100,
+				unlocking: bounded_vec![
+					UnlockChunk { value: 400, era: 2 + 3 },
+					UnlockChunk { value: 300, era: 3 + 3 },
+					UnlockChunk { value: 200, era: 4 + 3 },
+				],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Re-bond half of the unbonding funds.
+		Staking::rebond(RuntimeOrigin::signed(11), 400).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 500,
+				unlocking: bounded_vec![
+					UnlockChunk { value: 400, era: 2 + 3 },
+					UnlockChunk { value: 100, era: 3 + 3 },
+				],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+	})
+}
+
+#[test]
+fn rebond_emits_right_value_in_event() {
+	// When a user calls rebond with more than can be rebonded, things succeed,
+	// and the rebond event emits the actual value rebonded.
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Set payee to controller. avoids confusion
+		assert_ok!(Staking::set_payee(RuntimeOrigin::signed(11), RewardDestination::Controller));
+
+		// Give account 11 some large free balance greater than total
+		let _ = Balances::make_free_balance_be(&11, 1000000);
+
+		// confirm that 10 is a normal validator and gets paid at the end of the era.
+		mock::start_active_era(1);
+
+		// Unbond almost all of the funds in stash.
+		Staking::unbond(RuntimeOrigin::signed(11), 900).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 100,
+				unlocking: bounded_vec![UnlockChunk { value: 900, era: 1 + 3 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+
+		// Re-bond less than the total
+		Staking::rebond(RuntimeOrigin::signed(11), 100).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 200,
+				unlocking: bounded_vec![UnlockChunk { value: 800, era: 1 + 3 }],
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		// Event emitted should be correct
+		assert_eq!(*staking_events().last().unwrap(), Event::Bonded { stash: 11, amount: 100 });
+
+		// Re-bond way more than available
+		Staking::rebond(RuntimeOrigin::signed(11), 100_000).unwrap();
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		// Event emitted should be correct, only 800
+		assert_eq!(*staking_events().last().unwrap(), Event::Bonded { stash: 11, amount: 800 });
+	});
+}
+
+#[test]
+fn reward_to_stake_works() {
+	ExtBuilder::default()
+		.nominate(false)
+		.set_status(31, StakerStatus::Idle)
+		.set_status(41, StakerStatus::Idle)
+		.set_stake(21, 2000)
+		.build_and_execute(|| {
+			assert_eq!(Staking::validator_count(), 2);
+			// Confirm account 10 and 20 are validators
+			assert!(<Validators<Test>>::contains_key(&11) && <Validators<Test>>::contains_key(&21));
+
+			assert_eq!(Staking::eras_stakers(active_era(), 11).total, 1000);
+			assert_eq!(Staking::eras_stakers(active_era(), 21).total, 2000);
+
+			// Give the man some money.
+			let _ = Balances::make_free_balance_be(&10, 1000);
+			let _ = Balances::make_free_balance_be(&20, 1000);
+
+			// Bypass logic and change current exposure
+			ErasStakers::<Test>::insert(0, 21, Exposure { total: 69, own: 69, others: vec![] });
+			<Ledger<Test>>::insert(
+				&20,
+				StakingLedger {
+					stash: 21,
+					total: 69,
+					active: 69,
+					unlocking: Default::default(),
+					claimed_rewards: bounded_vec![],
+				},
+			);
+
+			// Compute total payout now for whole duration as other parameter won't change
+			let total_payout_0 = current_total_payout_for_duration(reward_time_per_era());
+			Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+			Pallet::<Test>::reward_by_ids(vec![(21, 1)]);
+
+			// New era --> rewards are paid --> stakes are changed
+			mock::start_active_era(1);
+			mock::make_all_reward_payment(0);
+
+			assert_eq!(Staking::eras_stakers(active_era(), 11).total, 1000);
+			assert_eq!(Staking::eras_stakers(active_era(), 21).total, 2000);
+
+			let _11_balance = Balances::free_balance(&11);
+			let _21_balance = Balances::free_balance(&21);
+
+			assert_eq!(_11_balance, 1000 + total_payout_0 / 2);
+			assert_eq!(_21_balance, 2000 + total_payout_0 / 2);
+
+			// Trigger another new era as the info are frozen before the era start.
+			mock::start_active_era(2);
+
+			// -- new infos
+			assert_eq!(Staking::eras_stakers(active_era(), 11).total, _11_balance);
+			assert_eq!(Staking::eras_stakers(active_era(), 21).total, _21_balance);
+		});
+}
+
+#[test]
+fn reap_stash_works() {
+	ExtBuilder::default()
+		.existential_deposit(10)
+		.balance_factor(10)
+		.build_and_execute(|| {
+			// given
+			assert_eq!(Balances::free_balance(11), 10 * 1000);
+			assert_eq!(Staking::bonded(&11), Some(11));
+
+			assert!(<Ledger<Test>>::contains_key(&11));
+			assert!(<Bonded<Test>>::contains_key(&11));
+			assert!(<Validators<Test>>::contains_key(&11));
+			assert!(<Payee<Test>>::contains_key(&11));
+
+			// stash is not reapable
+			assert_noop!(
+				Staking::reap_stash(RuntimeOrigin::signed(20), 11, 0),
+				Error::<Test>::FundedTarget
+			);
+
+			// no easy way to cause an account to go below ED, we tweak their staking ledger
+			// instead.
+			Ledger::<Test>::insert(
+				11,
+				StakingLedger {
+					stash: 11,
+					total: 5,
+					active: 5,
+					unlocking: Default::default(),
+					claimed_rewards: bounded_vec![],
+				},
+			);
+
+			// reap-able
+			assert_ok!(Staking::reap_stash(RuntimeOrigin::signed(20), 11, 0));
+
+			// then
+			assert!(!<Ledger<Test>>::contains_key(&11));
+			assert!(!<Bonded<Test>>::contains_key(&11));
+			assert!(!<Validators<Test>>::contains_key(&11));
+			assert!(!<Payee<Test>>::contains_key(&11));
+		});
+}
+
+#[test]
+fn switching_roles() {
+	// Test that it should be possible to switch between roles (nominator, validator, idle) with
+	// minimal overhead.
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// Reset reward destination
+		for i in &[11, 21] {
+			assert_ok!(Staking::set_payee(
+				RuntimeOrigin::signed(*i),
+				RewardDestination::Controller
+			));
+		}
+
+		assert_eq_uvec!(validator_controllers(), vec![21, 11]);
+
+		// put some money in account that we'll use.
+		for i in 1..7 {
+			let _ = Balances::deposit_creating(&i, 5000);
+		}
+
+		// add 2 nominators
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(1), 2000, RewardDestination::Controller));
+		assert_ok!(Staking::nominate(RuntimeOrigin::signed(1), vec![11, 5]));
+
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(3), 500, RewardDestination::Controller));
+		assert_ok!(Staking::nominate(RuntimeOrigin::signed(3), vec![21, 1]));
+
+		// add a new validator candidate
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(5), 1000, RewardDestination::Controller));
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(5), ValidatorPrefs::default()));
+		assert_ok!(Session::set_keys(
+			RuntimeOrigin::signed(5),
+			SessionKeys { other: 6.into() },
+			vec![]
+		));
+
+		mock::start_active_era(1);
+
+		// with current nominators 11 and 5 have the most stake
+		assert_eq_uvec!(validator_controllers(), vec![5, 11]);
+
+		// 2 decides to be a validator. Consequences:
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(1), ValidatorPrefs::default()));
+		assert_ok!(Session::set_keys(
+			RuntimeOrigin::signed(1),
+			SessionKeys { other: 2.into() },
+			vec![]
+		));
+		// new stakes:
+		// 11: 1000 self vote
+		// 21: 1000 self vote + 250 vote
+		// 5 : 1000 self vote
+		// 1 : 2000 self vote + 250 vote.
+		// Winners: 21 and 1
+
+		mock::start_active_era(2);
+
+		assert_eq_uvec!(validator_controllers(), vec![1, 21]);
+	});
+}
+
+#[test]
+fn wrong_vote_is_moot() {
+	ExtBuilder::default()
+		.add_staker(
+			61,
+			61,
+			500,
+			StakerStatus::Nominator(vec![
+				11, 21, // good votes
+				1, 2, 15, 1000, 25, // crap votes. No effect.
+			]),
+		)
+		.build_and_execute(|| {
+			// the genesis validators already reflect the above vote, nonetheless start a new era.
+			mock::start_active_era(1);
+
+			// new validators
+			assert_eq_uvec!(validator_controllers(), vec![21, 11]);
+
+			// our new voter is taken into account
+			assert!(Staking::eras_stakers(active_era(), 11).others.iter().any(|i| i.who == 61));
+			assert!(Staking::eras_stakers(active_era(), 21).others.iter().any(|i| i.who == 61));
+		});
+}
+
+#[test]
+fn bond_with_no_staked_value() {
+	// Behavior when someone bonds with no staked value.
+	// Particularly when they votes and the candidate is elected.
+	ExtBuilder::default()
+		.validator_count(3)
+		.existential_deposit(5)
+		.balance_factor(5)
+		.nominate(false)
+		.minimum_validator_count(1)
+		.build_and_execute(|| {
+			// Can't bond with 1
+			assert_noop!(
+				Staking::bond(RuntimeOrigin::signed(1), 1, RewardDestination::Controller),
+				Error::<Test>::InsufficientBond,
+			);
+			// bonded with absolute minimum value possible.
+			assert_ok!(Staking::bond(RuntimeOrigin::signed(1), 5, RewardDestination::Controller));
+			assert_eq!(Balances::locks(&1)[0].amount, 5);
+
+			// unbonding even 1 will cause all to be unbonded.
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(1), 1));
+			assert_eq!(
+				Staking::ledger(1),
+				Some(StakingLedger {
+					stash: 1,
+					active: 0,
+					total: 5,
+					unlocking: bounded_vec![UnlockChunk { value: 5, era: 3 }],
+					claimed_rewards: bounded_vec![],
+				})
+			);
+
+			mock::start_active_era(1);
+			mock::start_active_era(2);
+
+			// not yet removed.
+			assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(1), 0));
+			assert!(Staking::ledger(1).is_some());
+			assert_eq!(Balances::locks(&1)[0].amount, 5);
+
+			mock::start_active_era(3);
+
+			// poof. Account 1 is removed from the staking system.
+			assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(1), 0));
+			assert!(Staking::ledger(1).is_none());
+			assert_eq!(Balances::locks(&1).len(), 0);
+		});
+}
+
+#[test]
+fn bond_with_little_staked_value_bounded() {
+	ExtBuilder::default()
+		.validator_count(3)
+		.nominate(false)
+		.minimum_validator_count(1)
+		.build_and_execute(|| {
+			// setup
+			assert_ok!(Staking::chill(RuntimeOrigin::signed(31)));
+			assert_ok!(Staking::set_payee(
+				RuntimeOrigin::signed(11),
+				RewardDestination::Controller
+			));
+			let init_balance_1 = Balances::free_balance(&1);
+			let init_balance_11 = Balances::free_balance(&11);
+
+			// Stingy validator.
+			assert_ok!(Staking::bond(RuntimeOrigin::signed(1), 1, RewardDestination::Controller));
+			assert_ok!(Staking::validate(RuntimeOrigin::signed(1), ValidatorPrefs::default()));
+			assert_ok!(Session::set_keys(
+				RuntimeOrigin::signed(1),
+				SessionKeys { other: 1.into() },
+				vec![]
+			));
+
+			// 1 era worth of reward. BUT, we set the timestamp after on_initialize, so outdated by
+			// one block.
+			let total_payout_0 = current_total_payout_for_duration(reward_time_per_era());
+
+			reward_all_elected();
+			mock::start_active_era(1);
+			mock::make_all_reward_payment(0);
+
+			// 2 is elected.
+			assert_eq_uvec!(validator_controllers(), vec![21, 11, 1]);
+			assert_eq!(Staking::eras_stakers(active_era(), 2).total, 0);
+
+			// Old ones are rewarded.
+			assert_eq_error_rate!(
+				Balances::free_balance(11),
+				init_balance_11 + total_payout_0 / 3,
+				1
+			);
+			// no rewards paid to 2. This was initial election.
+			assert_eq!(Balances::free_balance(1), init_balance_1);
+
+			// reward era 2
+			let total_payout_1 = current_total_payout_for_duration(reward_time_per_era());
+			reward_all_elected();
+			mock::start_active_era(2);
+			mock::make_all_reward_payment(1);
+
+			assert_eq_uvec!(validator_controllers(), vec![21, 11, 1]);
+			assert_eq!(Staking::eras_stakers(active_era(), 2).total, 0);
+
+			// 2 is now rewarded.
+			assert_eq_error_rate!(
+				Balances::free_balance(1),
+				init_balance_1 + total_payout_1 / 3,
+				1
+			);
+			assert_eq_error_rate!(
+				Balances::free_balance(&11),
+				init_balance_11 + total_payout_0 / 3 + total_payout_1 / 3,
+				2,
+			);
+		});
+}
+
+#[test]
+fn bond_with_duplicate_vote_should_be_ignored_by_election_provider() {
+	ExtBuilder::default()
+		.validator_count(2)
+		.nominate(false)
+		.minimum_validator_count(1)
+		.set_stake(31, 1000)
+		.build_and_execute(|| {
+			// ensure all have equal stake.
+			assert_eq!(
+				<Validators<Test>>::iter()
+					.map(|(v, _)| (v, Staking::ledger(v).unwrap().total))
+					.collect::<Vec<_>>(),
+				vec![(31, 1000), (21, 1000), (11, 1000)],
+			);
+			// no nominators shall exist.
+			assert!(<Nominators<Test>>::iter().map(|(n, _)| n).collect::<Vec<_>>().is_empty());
+
+			// give the man some money.
+			let initial_balance = 1000;
+			for i in [1, 2, 3, 4].iter() {
+				let _ = Balances::make_free_balance_be(i, initial_balance);
+			}
+
+			assert_ok!(Staking::bond(
+				RuntimeOrigin::signed(1),
+				1000,
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(1), vec![11, 11, 11, 21, 31]));
+
+			assert_ok!(Staking::bond(
+				RuntimeOrigin::signed(3),
+				1000,
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(3), vec![21, 31]));
+
+			// winners should be 21 and 31. Otherwise this election is taking duplicates into
+			// account.
+			let supports = <Test as Config>::ElectionProvider::elect().unwrap();
+			assert_eq!(
+				supports,
+				vec![
+					(21, Support { total: 1800, voters: vec![(21, 1000), (1, 400), (3, 400)] }),
+					(31, Support { total: 2200, voters: vec![(31, 1000), (1, 600), (3, 600)] })
+				],
+			);
+		});
+}
+
+#[test]
+fn bond_with_duplicate_vote_should_be_ignored_by_election_provider_elected() {
+	// same as above but ensures that even when the dupe is being elected, everything is sane.
+	ExtBuilder::default()
+		.validator_count(2)
+		.nominate(false)
+		.set_stake(31, 1000)
+		.minimum_validator_count(1)
+		.build_and_execute(|| {
+			// ensure all have equal stake.
+			assert_eq!(
+				<Validators<Test>>::iter()
+					.map(|(v, _)| (v, Staking::ledger(v).unwrap().total))
+					.collect::<Vec<_>>(),
+				vec![(31, 1000), (21, 1000), (11, 1000)],
+			);
+
+			// no nominators shall exist.
+			assert!(<Nominators<Test>>::iter().collect::<Vec<_>>().is_empty());
+
+			// give the man some money.
+			let initial_balance = 1000;
+			for i in [1, 2, 3, 4].iter() {
+				let _ = Balances::make_free_balance_be(i, initial_balance);
+			}
+
+			assert_ok!(Staking::bond(
+				RuntimeOrigin::signed(1),
+				1000,
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(1), vec![11, 11, 11, 21]));
+
+			assert_ok!(Staking::bond(
+				RuntimeOrigin::signed(3),
+				1000,
+				RewardDestination::Controller
+			));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(3), vec![21]));
+
+			// winners should be 21 and 11.
+			let supports = <Test as Config>::ElectionProvider::elect().unwrap();
+			assert_eq!(
+				supports,
+				vec![
+					(11, Support { total: 1500, voters: vec![(11, 1000), (1, 500)] }),
+					(21, Support { total: 2500, voters: vec![(21, 1000), (1, 500), (3, 1000)] })
+				],
+			);
+		});
+}
+
+#[test]
+fn new_era_elects_correct_number_of_validators() {
+	ExtBuilder::default().nominate(true).validator_count(1).build_and_execute(|| {
+		assert_eq!(Staking::validator_count(), 1);
+		assert_eq!(validator_controllers().len(), 1);
+
+		Session::on_initialize(System::block_number());
+
+		assert_eq!(validator_controllers().len(), 1);
+	})
+}
+
+#[test]
+fn phragmen_should_not_overflow() {
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		// This is the maximum value that we can have as the outcome of CurrencyToVote.
+		type Votes = u64;
+
+		let _ = Staking::chill(RuntimeOrigin::signed(10));
+		let _ = Staking::chill(RuntimeOrigin::signed(20));
+
+		bond_validator(3, Votes::max_value() as Balance);
+		bond_validator(5, Votes::max_value() as Balance);
+
+		bond_nominator(7, Votes::max_value() as Balance, vec![3, 5]);
+		bond_nominator(9, Votes::max_value() as Balance, vec![3, 5]);
+
+		mock::start_active_era(1);
+
+		assert_eq_uvec!(validator_controllers(), vec![3, 5]);
+
+		// We can safely convert back to values within [u64, u128].
+		assert!(Staking::eras_stakers(active_era(), 3).total > Votes::max_value() as Balance);
+		assert!(Staking::eras_stakers(active_era(), 5).total > Votes::max_value() as Balance);
+	})
+}
+
+#[test]
+fn reward_validator_slashing_validator_does_not_overflow() {
+	ExtBuilder::default().build_and_execute(|| {
+		let stake = u64::MAX as Balance * 2;
+		let reward_slash = u64::MAX as Balance * 2;
+
+		// Assert multiplication overflows in balance arithmetic.
+		assert!(stake.checked_mul(reward_slash).is_none());
+
+		// Set staker
+		let _ = Balances::make_free_balance_be(&11, stake);
+
+		let exposure = Exposure::<AccountId, Balance> { total: stake, own: stake, others: vec![] };
+		let reward = EraRewardPoints::<AccountId> {
+			total: 1,
+			individual: vec![(11, 1)].into_iter().collect(),
+		};
+
+		// Check reward
+		ErasRewardPoints::<Test>::insert(0, reward);
+		ErasStakers::<Test>::insert(0, 11, &exposure);
+		ErasStakersClipped::<Test>::insert(0, 11, exposure);
+		ErasValidatorReward::<Test>::insert(0, stake);
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 0));
+		assert_eq!(Balances::total_balance(&11), stake * 2);
+
+		// Set staker
+		let _ = Balances::make_free_balance_be(&11, stake);
+		let _ = Balances::make_free_balance_be(&2, stake);
+
+		// only slashes out of bonded stake are applied. without this line, it is 0.
+		Staking::bond(RuntimeOrigin::signed(2), stake - 1, RewardDestination::default()).unwrap();
+		// Override exposure of 11
+		ErasStakers::<Test>::insert(
+			0,
+			11,
+			Exposure {
+				total: stake,
+				own: 1,
+				others: vec![IndividualExposure { who: 2, value: stake - 1 }],
+			},
+		);
+
+		// Check slashing
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(100)],
+		);
+
+		assert_eq!(Balances::total_balance(&11), stake - 1);
+		assert_eq!(Balances::total_balance(&2), 1);
+	})
+}
+
+#[test]
+fn reward_from_authorship_event_handler_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		use pallet_authorship::EventHandler;
+
+		assert_eq!(<pallet_authorship::Pallet<Test>>::author(), Some(11));
+
+		Pallet::<Test>::note_author(11);
+		Pallet::<Test>::note_author(11);
+
+		// Not mandatory but must be coherent with rewards
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+
+		// 21 is rewarded as an uncle producer
+		// 11 is rewarded as a block producer and uncle referencer and uncle producer
+		assert_eq!(
+			ErasRewardPoints::<Test>::get(active_era()),
+			EraRewardPoints { individual: vec![(11, 20 * 2)].into_iter().collect(), total: 40 },
+		);
+	})
+}
+
+#[test]
+fn add_reward_points_fns_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// Not mandatory but must be coherent with rewards
+		assert_eq_uvec!(Session::validators(), vec![21, 11]);
+
+		Pallet::<Test>::reward_by_ids(vec![(21, 1), (11, 1), (11, 1)]);
+
+		Pallet::<Test>::reward_by_ids(vec![(21, 1), (11, 1), (11, 1)]);
+
+		assert_eq!(
+			ErasRewardPoints::<Test>::get(active_era()),
+			EraRewardPoints { individual: vec![(11, 4), (21, 2)].into_iter().collect(), total: 6 },
+		);
+	})
+}
+
+#[test]
+fn unbonded_balance_is_not_slashable() {
+	ExtBuilder::default().build_and_execute(|| {
+		// total amount staked is slashable.
+		assert_eq!(Staking::slashable_balance_of(&11), 1000);
+
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 800));
+
+		// only the active portion.
+		assert_eq!(Staking::slashable_balance_of(&11), 200);
+	})
+}
+
+#[test]
+fn era_is_always_same_length() {
+	// This ensures that the sessions is always of the same length if there is no forcing no
+	// session changes.
+	ExtBuilder::default().build_and_execute(|| {
+		let session_per_era = <SessionsPerEra as Get<SessionIndex>>::get();
+
+		mock::start_active_era(1);
+		assert_eq!(Staking::eras_start_session_index(current_era()).unwrap(), session_per_era);
+
+		mock::start_active_era(2);
+		assert_eq!(
+			Staking::eras_start_session_index(current_era()).unwrap(),
+			session_per_era * 2u32
+		);
+
+		let session = Session::current_index();
+		Staking::set_force_era(Forcing::ForceNew);
+		advance_session();
+		advance_session();
+		assert_eq!(current_era(), 3);
+		assert_eq!(Staking::eras_start_session_index(current_era()).unwrap(), session + 2);
+
+		mock::start_active_era(4);
+		assert_eq!(
+			Staking::eras_start_session_index(current_era()).unwrap(),
+			session + 2u32 + session_per_era
+		);
+	});
+}
+
+#[test]
+fn offence_forces_new_era() {
+	ExtBuilder::default().build_and_execute(|| {
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(5)],
+		);
+
+		assert_eq!(Staking::force_era(), Forcing::ForceNew);
+	});
+}
+
+#[test]
+fn offence_ensures_new_era_without_clobbering() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_ok!(Staking::force_new_era_always(RuntimeOrigin::root()));
+		assert_eq!(Staking::force_era(), Forcing::ForceAlways);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(5)],
+		);
+
+		assert_eq!(Staking::force_era(), Forcing::ForceAlways);
+	});
+}
+
+#[test]
+fn offence_deselects_validator_even_when_slash_is_zero() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert!(Session::validators().contains(&11));
+		assert!(<Validators<Test>>::contains_key(11));
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(0)],
+		);
+
+		assert_eq!(Staking::force_era(), Forcing::ForceNew);
+		assert!(!<Validators<Test>>::contains_key(11));
+
+		mock::start_active_era(1);
+
+		assert!(!Session::validators().contains(&11));
+		assert!(!<Validators<Test>>::contains_key(11));
+	});
+}
+
+#[test]
+fn slashing_performed_according_exposure() {
+	// This test checks that slashing is performed according the exposure (or more precisely,
+	// historical exposure), not the current balance.
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(Staking::eras_stakers(active_era(), 11).own, 1000);
+
+		// Handle an offence with a historical exposure.
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Exposure { total: 500, own: 500, others: vec![] }),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(50)],
+		);
+
+		// The stash account should be slashed for 250 (50% of 500).
+		assert_eq!(Balances::free_balance(11), 1000 - 250);
+	});
+}
+
+#[test]
+fn slash_in_old_span_does_not_deselect() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+
+		assert!(<Validators<Test>>::contains_key(11));
+		assert!(Session::validators().contains(&11));
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(0)],
+		);
+
+		assert_eq!(Staking::force_era(), Forcing::ForceNew);
+		assert!(!<Validators<Test>>::contains_key(11));
+
+		mock::start_active_era(2);
+
+		Staking::validate(RuntimeOrigin::signed(11), Default::default()).unwrap();
+		assert_eq!(Staking::force_era(), Forcing::NotForcing);
+		assert!(<Validators<Test>>::contains_key(11));
+		assert!(!Session::validators().contains(&11));
+
+		mock::start_active_era(3);
+
+		// this staker is in a new slashing span now, having re-registered after
+		// their prior slash.
+
+		on_offence_in_era(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(0)],
+			1,
+			DisableStrategy::WhenSlashed,
+		);
+
+		// the validator doesn't get chilled again
+		assert!(Validators::<Test>::iter().any(|(stash, _)| stash == 11));
+
+		// but we are still forcing a new era
+		assert_eq!(Staking::force_era(), Forcing::ForceNew);
+
+		on_offence_in_era(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			// NOTE: A 100% slash here would clean up the account, causing de-registration.
+			&[Perbill::from_percent(95)],
+			1,
+			DisableStrategy::WhenSlashed,
+		);
+
+		// the validator doesn't get chilled again
+		assert!(Validators::<Test>::iter().any(|(stash, _)| stash == 11));
+
+		// but it's disabled
+		assert!(is_disabled(11));
+		// and we are still forcing a new era
+		assert_eq!(Staking::force_era(), Forcing::ForceNew);
+	});
+}
+
+#[test]
+fn reporters_receive_their_slice() {
+	// This test verifies that the reporters of the offence receive their slice from the slashed
+	// amount.
+	ExtBuilder::default().build_and_execute(|| {
+		// The reporters' reward is calculated from the total exposure.
+		let initial_balance = 1125;
+
+		assert_eq!(Staking::eras_stakers(active_era(), 11).total, initial_balance);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![1, 2],
+			}],
+			&[Perbill::from_percent(50)],
+		);
+
+		// F1 * (reward_proportion * slash - 0)
+		// 50% * (10% * initial_balance / 2)
+		let reward = (initial_balance / 20) / 2;
+		let reward_each = reward / 2; // split into two pieces.
+		assert_eq!(Balances::free_balance(1), 10 + reward_each);
+		assert_eq!(Balances::free_balance(2), 20 + reward_each);
+	});
+}
+
+#[test]
+fn subsequent_reports_in_same_span_pay_out_less() {
+	// This test verifies that the reporters of the offence receive their slice from the slashed
+	// amount, but less and less if they submit multiple reports in one span.
+	ExtBuilder::default().build_and_execute(|| {
+		// The reporters' reward is calculated from the total exposure.
+		let initial_balance = 1125;
+
+		assert_eq!(Staking::eras_stakers(active_era(), 11).total, initial_balance);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![1],
+			}],
+			&[Perbill::from_percent(20)],
+		);
+
+		// F1 * (reward_proportion * slash - 0)
+		// 50% * (10% * initial_balance * 20%)
+		let reward = (initial_balance / 5) / 20;
+		assert_eq!(Balances::free_balance(1), 10 + reward);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![1],
+			}],
+			&[Perbill::from_percent(50)],
+		);
+
+		let prior_payout = reward;
+
+		// F1 * (reward_proportion * slash - prior_payout)
+		// 50% * (10% * (initial_balance / 2) - prior_payout)
+		let reward = ((initial_balance / 20) - prior_payout) / 2;
+		assert_eq!(Balances::free_balance(1), 10 + prior_payout + reward);
+	});
+}
+
+#[test]
+fn invulnerables_are_not_slashed() {
+	// For invulnerable validators no slashing is performed.
+	ExtBuilder::default().invulnerables(vec![11]).build_and_execute(|| {
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(21), 2000);
+
+		let exposure = Staking::eras_stakers(active_era(), 21);
+		let initial_balance = Staking::slashable_balance_of(&21);
+
+		let nominator_balances: Vec<_> =
+			exposure.others.iter().map(|o| Balances::free_balance(&o.who)).collect();
+
+		on_offence_now(
+			&[
+				OffenceDetails {
+					offender: (11, Staking::eras_stakers(active_era(), 11)),
+					reporters: vec![],
+				},
+				OffenceDetails {
+					offender: (21, Staking::eras_stakers(active_era(), 21)),
+					reporters: vec![],
+				},
+			],
+			&[Perbill::from_percent(50), Perbill::from_percent(20)],
+		);
+
+		// The validator 11 hasn't been slashed, but 21 has been.
+		assert_eq!(Balances::free_balance(11), 1000);
+		// 2000 - (0.2 * initial_balance)
+		assert_eq!(Balances::free_balance(21), 2000 - (2 * initial_balance / 10));
+
+		// ensure that nominators were slashed as well.
+		for (initial_balance, other) in nominator_balances.into_iter().zip(exposure.others) {
+			assert_eq!(
+				Balances::free_balance(&other.who),
+				initial_balance - (2 * other.value / 10),
+			);
+		}
+	});
+}
+
+#[test]
+fn dont_slash_if_fraction_is_zero() {
+	// Don't slash if the fraction is zero.
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(Balances::free_balance(11), 1000);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(0)],
+		);
+
+		// The validator hasn't been slashed. The new era is not forced.
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Staking::force_era(), Forcing::ForceNew);
+	});
+}
+
+#[test]
+fn only_slash_for_max_in_era() {
+	// multiple slashes within one era are only applied if it is more than any previous slash in the
+	// same era.
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(Balances::free_balance(11), 1000);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(50)],
+		);
+
+		// The validator has been slashed and has been force-chilled.
+		assert_eq!(Balances::free_balance(11), 500);
+		assert_eq!(Staking::force_era(), Forcing::ForceNew);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(25)],
+		);
+
+		// The validator has not been slashed additionally.
+		assert_eq!(Balances::free_balance(11), 500);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(60)],
+		);
+
+		// The validator got slashed 10% more.
+		assert_eq!(Balances::free_balance(11), 400);
+	})
+}
+
+#[test]
+fn garbage_collection_after_slashing() {
+	// ensures that `SlashingSpans` and `SpanSlash` of an account is removed after reaping.
+	ExtBuilder::default()
+		.existential_deposit(2)
+		.balance_factor(2)
+		.build_and_execute(|| {
+			assert_eq!(Balances::free_balance(11), 2000);
+
+			on_offence_now(
+				&[OffenceDetails {
+					offender: (11, Staking::eras_stakers(active_era(), 11)),
+					reporters: vec![],
+				}],
+				&[Perbill::from_percent(10)],
+			);
+
+			assert_eq!(Balances::free_balance(11), 2000 - 200);
+			assert!(SlashingSpans::<Test>::get(&11).is_some());
+			assert_eq!(SpanSlash::<Test>::get(&(11, 0)).amount(), &200);
+
+			on_offence_now(
+				&[OffenceDetails {
+					offender: (11, Staking::eras_stakers(active_era(), 11)),
+					reporters: vec![],
+				}],
+				&[Perbill::from_percent(100)],
+			);
+
+			// validator and nominator slash in era are garbage-collected by era change,
+			// so we don't test those here.
+
+			assert_eq!(Balances::free_balance(11), 2);
+			assert_eq!(Balances::total_balance(&11), 2);
+
+			let slashing_spans = SlashingSpans::<Test>::get(&11).unwrap();
+			assert_eq!(slashing_spans.iter().count(), 2);
+
+			// reap_stash respects num_slashing_spans so that weight is accurate
+			assert_noop!(
+				Staking::reap_stash(RuntimeOrigin::signed(20), 11, 0),
+				Error::<Test>::IncorrectSlashingSpans
+			);
+			assert_ok!(Staking::reap_stash(RuntimeOrigin::signed(20), 11, 2));
+
+			assert!(SlashingSpans::<Test>::get(&11).is_none());
+			assert_eq!(SpanSlash::<Test>::get(&(11, 0)).amount(), &0);
+		})
+}
+
+#[test]
+fn garbage_collection_on_window_pruning() {
+	// ensures that `ValidatorSlashInEra` and `NominatorSlashInEra` are cleared after
+	// `BondingDuration`.
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		let now = active_era();
+
+		let exposure = Staking::eras_stakers(now, 11);
+		assert_eq!(Balances::free_balance(101), 2000);
+		let nominated_value = exposure.others.iter().find(|o| o.who == 101).unwrap().value;
+
+		on_offence_now(
+			&[OffenceDetails { offender: (11, Staking::eras_stakers(now, 11)), reporters: vec![] }],
+			&[Perbill::from_percent(10)],
+		);
+
+		assert_eq!(Balances::free_balance(11), 900);
+		assert_eq!(Balances::free_balance(101), 2000 - (nominated_value / 10));
+
+		assert!(ValidatorSlashInEra::<Test>::get(&now, &11).is_some());
+		assert!(NominatorSlashInEra::<Test>::get(&now, &101).is_some());
+
+		// + 1 because we have to exit the bonding window.
+		for era in (0..(BondingDuration::get() + 1)).map(|offset| offset + now + 1) {
+			assert!(ValidatorSlashInEra::<Test>::get(&now, &11).is_some());
+			assert!(NominatorSlashInEra::<Test>::get(&now, &101).is_some());
+
+			mock::start_active_era(era);
+		}
+
+		assert!(ValidatorSlashInEra::<Test>::get(&now, &11).is_none());
+		assert!(NominatorSlashInEra::<Test>::get(&now, &101).is_none());
+	})
+}
+
+#[test]
+fn slashing_nominators_by_span_max() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+		mock::start_active_era(2);
+		mock::start_active_era(3);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(21), 2000);
+		assert_eq!(Balances::free_balance(101), 2000);
+		assert_eq!(Staking::slashable_balance_of(&21), 1000);
+
+		let exposure_11 = Staking::eras_stakers(active_era(), 11);
+		let exposure_21 = Staking::eras_stakers(active_era(), 21);
+		let nominated_value_11 = exposure_11.others.iter().find(|o| o.who == 101).unwrap().value;
+		let nominated_value_21 = exposure_21.others.iter().find(|o| o.who == 101).unwrap().value;
+
+		on_offence_in_era(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(10)],
+			2,
+			DisableStrategy::WhenSlashed,
+		);
+
+		assert_eq!(Balances::free_balance(11), 900);
+
+		let slash_1_amount = Perbill::from_percent(10) * nominated_value_11;
+		assert_eq!(Balances::free_balance(101), 2000 - slash_1_amount);
+
+		let expected_spans = vec![
+			slashing::SlashingSpan { index: 1, start: 4, length: None },
+			slashing::SlashingSpan { index: 0, start: 0, length: Some(4) },
+		];
+
+		let get_span = |account| SlashingSpans::<Test>::get(&account).unwrap();
+
+		assert_eq!(get_span(11).iter().collect::<Vec<_>>(), expected_spans);
+
+		assert_eq!(get_span(101).iter().collect::<Vec<_>>(), expected_spans);
+
+		// second slash: higher era, higher value, same span.
+		on_offence_in_era(
+			&[OffenceDetails {
+				offender: (21, Staking::eras_stakers(active_era(), 21)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(30)],
+			3,
+			DisableStrategy::WhenSlashed,
+		);
+
+		// 11 was not further slashed, but 21 and 101 were.
+		assert_eq!(Balances::free_balance(11), 900);
+		assert_eq!(Balances::free_balance(21), 1700);
+
+		let slash_2_amount = Perbill::from_percent(30) * nominated_value_21;
+		assert!(slash_2_amount > slash_1_amount);
+
+		// only the maximum slash in a single span is taken.
+		assert_eq!(Balances::free_balance(101), 2000 - slash_2_amount);
+
+		// third slash: in same era and on same validator as first, higher
+		// in-era value, but lower slash value than slash 2.
+		on_offence_in_era(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(20)],
+			2,
+			DisableStrategy::WhenSlashed,
+		);
+
+		// 11 was further slashed, but 21 and 101 were not.
+		assert_eq!(Balances::free_balance(11), 800);
+		assert_eq!(Balances::free_balance(21), 1700);
+
+		let slash_3_amount = Perbill::from_percent(20) * nominated_value_21;
+		assert!(slash_3_amount < slash_2_amount);
+		assert!(slash_3_amount > slash_1_amount);
+
+		// only the maximum slash in a single span is taken.
+		assert_eq!(Balances::free_balance(101), 2000 - slash_2_amount);
+	});
+}
+
+#[test]
+fn slashes_are_summed_across_spans() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+		mock::start_active_era(2);
+		mock::start_active_era(3);
+
+		assert_eq!(Balances::free_balance(21), 2000);
+		assert_eq!(Staking::slashable_balance_of(&21), 1000);
+
+		let get_span = |account| SlashingSpans::<Test>::get(&account).unwrap();
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (21, Staking::eras_stakers(active_era(), 21)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(10)],
+		);
+
+		let expected_spans = vec![
+			slashing::SlashingSpan { index: 1, start: 4, length: None },
+			slashing::SlashingSpan { index: 0, start: 0, length: Some(4) },
+		];
+
+		assert_eq!(get_span(21).iter().collect::<Vec<_>>(), expected_spans);
+		assert_eq!(Balances::free_balance(21), 1900);
+
+		// 21 has been force-chilled. re-signal intent to validate.
+		Staking::validate(RuntimeOrigin::signed(21), Default::default()).unwrap();
+
+		mock::start_active_era(4);
+
+		assert_eq!(Staking::slashable_balance_of(&21), 900);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (21, Staking::eras_stakers(active_era(), 21)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(10)],
+		);
+
+		let expected_spans = vec![
+			slashing::SlashingSpan { index: 2, start: 5, length: None },
+			slashing::SlashingSpan { index: 1, start: 4, length: Some(1) },
+			slashing::SlashingSpan { index: 0, start: 0, length: Some(4) },
+		];
+
+		assert_eq!(get_span(21).iter().collect::<Vec<_>>(), expected_spans);
+		assert_eq!(Balances::free_balance(21), 1810);
+	});
+}
+
+#[test]
+fn deferred_slashes_are_deferred() {
+	ExtBuilder::default().slash_defer_duration(2).build_and_execute(|| {
+		mock::start_active_era(1);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+
+		let exposure = Staking::eras_stakers(active_era(), 11);
+		assert_eq!(Balances::free_balance(101), 2000);
+		let nominated_value = exposure.others.iter().find(|o| o.who == 101).unwrap().value;
+
+		System::reset_events();
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(10)],
+		);
+
+		// nominations are not removed regardless of the deferring.
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		mock::start_active_era(2);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		mock::start_active_era(3);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		// at the start of era 4, slashes from era 1 are processed,
+		// after being deferred for at least 2 full eras.
+		mock::start_active_era(4);
+
+		assert_eq!(Balances::free_balance(11), 900);
+		assert_eq!(Balances::free_balance(101), 2000 - (nominated_value / 10));
+
+		assert!(matches!(
+			staking_events_since_last_call().as_slice(),
+			&[
+				Event::Chilled { stash: 11 },
+				Event::ForceEra { mode: Forcing::ForceNew },
+				Event::SlashReported { validator: 11, slash_era: 1, .. },
+				Event::StakersElected,
+				Event::ForceEra { mode: Forcing::NotForcing },
+				..,
+				Event::Slashed { staker: 11, amount: 100 },
+				Event::Slashed { staker: 101, amount: 12 }
+			]
+		));
+	})
+}
+
+#[test]
+fn retroactive_deferred_slashes_two_eras_before() {
+	ExtBuilder::default().slash_defer_duration(2).build_and_execute(|| {
+		assert_eq!(BondingDuration::get(), 3);
+
+		mock::start_active_era(1);
+		let exposure_11_at_era1 = Staking::eras_stakers(active_era(), 11);
+
+		mock::start_active_era(3);
+
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+		System::reset_events();
+		on_offence_in_era(
+			&[OffenceDetails { offender: (11, exposure_11_at_era1), reporters: vec![] }],
+			&[Perbill::from_percent(10)],
+			1, // should be deferred for two full eras, and applied at the beginning of era 4.
+			DisableStrategy::Never,
+		);
+
+		mock::start_active_era(4);
+
+		assert!(matches!(
+			staking_events_since_last_call().as_slice(),
+			&[
+				Event::Chilled { stash: 11 },
+				Event::ForceEra { mode: Forcing::ForceNew },
+				Event::SlashReported { validator: 11, slash_era: 1, .. },
+				..,
+				Event::Slashed { staker: 11, amount: 100 },
+				Event::Slashed { staker: 101, amount: 12 }
+			]
+		));
+	})
+}
+
+#[test]
+fn retroactive_deferred_slashes_one_before() {
+	ExtBuilder::default().slash_defer_duration(2).build_and_execute(|| {
+		assert_eq!(BondingDuration::get(), 3);
+
+		mock::start_active_era(1);
+		let exposure_11_at_era1 = Staking::eras_stakers(active_era(), 11);
+
+		// unbond at slash era.
+		mock::start_active_era(2);
+		assert_ok!(Staking::chill(RuntimeOrigin::signed(11)));
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 100));
+
+		mock::start_active_era(3);
+		System::reset_events();
+		on_offence_in_era(
+			&[OffenceDetails { offender: (11, exposure_11_at_era1), reporters: vec![] }],
+			&[Perbill::from_percent(10)],
+			2, // should be deferred for two full eras, and applied at the beginning of era 5.
+			DisableStrategy::Never,
+		);
+
+		mock::start_active_era(4);
+
+		assert_eq!(Staking::ledger(11).unwrap().total, 1000);
+		// slash happens after the next line.
+
+		mock::start_active_era(5);
+		assert!(matches!(
+			staking_events_since_last_call().as_slice(),
+			&[
+				Event::SlashReported { validator: 11, slash_era: 2, .. },
+				..,
+				Event::Slashed { staker: 11, amount: 100 },
+				Event::Slashed { staker: 101, amount: 12 }
+			]
+		));
+
+		// their ledger has already been slashed.
+		assert_eq!(Staking::ledger(11).unwrap().total, 900);
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(11), 1000));
+		assert_eq!(Staking::ledger(11).unwrap().total, 900);
+	})
+}
+
+#[test]
+fn staker_cannot_bail_deferred_slash() {
+	// as long as SlashDeferDuration is less than BondingDuration, this should not be possible.
+	ExtBuilder::default().slash_defer_duration(2).build_and_execute(|| {
+		mock::start_active_era(1);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		let exposure = Staking::eras_stakers(active_era(), 11);
+		let nominated_value = exposure.others.iter().find(|o| o.who == 101).unwrap().value;
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (11, Staking::eras_stakers(active_era(), 11)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(10)],
+		);
+
+		// now we chill
+		assert_ok!(Staking::chill(RuntimeOrigin::signed(101)));
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(101), 500));
+
+		assert_eq!(Staking::current_era().unwrap(), 1);
+		assert_eq!(active_era(), 1);
+
+		assert_eq!(
+			Ledger::<Test>::get(101).unwrap(),
+			StakingLedger {
+				active: 0,
+				total: 500,
+				stash: 101,
+				claimed_rewards: bounded_vec![],
+				unlocking: bounded_vec![UnlockChunk { era: 4u32, value: 500 }],
+			}
+		);
+
+		// no slash yet.
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		// no slash yet.
+		mock::start_active_era(2);
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+		assert_eq!(Staking::current_era().unwrap(), 2);
+		assert_eq!(active_era(), 2);
+
+		// no slash yet.
+		mock::start_active_era(3);
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+		assert_eq!(Staking::current_era().unwrap(), 3);
+		assert_eq!(active_era(), 3);
+
+		// and cannot yet unbond:
+		assert_storage_noop!(assert!(
+			Staking::withdraw_unbonded(RuntimeOrigin::signed(101), 0).is_ok()
+		));
+		assert_eq!(
+			Ledger::<Test>::get(101).unwrap().unlocking.into_inner(),
+			vec![UnlockChunk { era: 4u32, value: 500 as Balance }],
+		);
+
+		// at the start of era 4, slashes from era 1 are processed,
+		// after being deferred for at least 2 full eras.
+		mock::start_active_era(4);
+
+		assert_eq!(Balances::free_balance(11), 900);
+		assert_eq!(Balances::free_balance(101), 2000 - (nominated_value / 10));
+
+		// and the leftover of the funds can now be unbonded.
+	})
+}
+
+#[test]
+fn remove_deferred() {
+	ExtBuilder::default().slash_defer_duration(2).build_and_execute(|| {
+		mock::start_active_era(1);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+
+		let exposure = Staking::eras_stakers(active_era(), 11);
+		assert_eq!(Balances::free_balance(101), 2000);
+		let nominated_value = exposure.others.iter().find(|o| o.who == 101).unwrap().value;
+
+		// deferred to start of era 4.
+		on_offence_now(
+			&[OffenceDetails { offender: (11, exposure.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(10)],
+		);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		mock::start_active_era(2);
+
+		// reported later, but deferred to start of era 4 as well.
+		System::reset_events();
+		on_offence_in_era(
+			&[OffenceDetails { offender: (11, exposure.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(15)],
+			1,
+			DisableStrategy::WhenSlashed,
+		);
+
+		// fails if empty
+		assert_noop!(
+			Staking::cancel_deferred_slash(RuntimeOrigin::root(), 1, vec![]),
+			Error::<Test>::EmptyTargets
+		);
+
+		// cancel one of them.
+		assert_ok!(Staking::cancel_deferred_slash(RuntimeOrigin::root(), 4, vec![0]));
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		mock::start_active_era(3);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		// at the start of era 4, slashes from era 1 are processed,
+		// after being deferred for at least 2 full eras.
+		mock::start_active_era(4);
+
+		// the first slash for 10% was cancelled, but the 15% one not.
+		assert!(matches!(
+			staking_events_since_last_call().as_slice(),
+			&[
+				Event::SlashReported { validator: 11, slash_era: 1, .. },
+				..,
+				Event::Slashed { staker: 11, amount: 50 },
+				Event::Slashed { staker: 101, amount: 7 }
+			]
+		));
+
+		let slash_10 = Perbill::from_percent(10);
+		let slash_15 = Perbill::from_percent(15);
+		let initial_slash = slash_10 * nominated_value;
+
+		let total_slash = slash_15 * nominated_value;
+		let actual_slash = total_slash - initial_slash;
+
+		// 5% slash (15 - 10) processed now.
+		assert_eq!(Balances::free_balance(11), 950);
+		assert_eq!(Balances::free_balance(101), 2000 - actual_slash);
+	})
+}
+
+#[test]
+fn remove_multi_deferred() {
+	ExtBuilder::default().slash_defer_duration(2).build_and_execute(|| {
+		mock::start_active_era(1);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+
+		let exposure = Staking::eras_stakers(active_era(), 11);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		on_offence_now(
+			&[OffenceDetails { offender: (11, exposure.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(10)],
+		);
+
+		on_offence_now(
+			&[OffenceDetails {
+				offender: (21, Staking::eras_stakers(active_era(), 21)),
+				reporters: vec![],
+			}],
+			&[Perbill::from_percent(10)],
+		);
+
+		on_offence_now(
+			&[OffenceDetails { offender: (11, exposure.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(25)],
+		);
+
+		on_offence_now(
+			&[OffenceDetails { offender: (42, exposure.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(25)],
+		);
+
+		on_offence_now(
+			&[OffenceDetails { offender: (69, exposure.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(25)],
+		);
+
+		assert_eq!(UnappliedSlashes::<Test>::get(&4).len(), 5);
+
+		// fails if list is not sorted
+		assert_noop!(
+			Staking::cancel_deferred_slash(RuntimeOrigin::root(), 1, vec![2, 0, 4]),
+			Error::<Test>::NotSortedAndUnique
+		);
+		// fails if list is not unique
+		assert_noop!(
+			Staking::cancel_deferred_slash(RuntimeOrigin::root(), 1, vec![0, 2, 2]),
+			Error::<Test>::NotSortedAndUnique
+		);
+		// fails if bad index
+		assert_noop!(
+			Staking::cancel_deferred_slash(RuntimeOrigin::root(), 1, vec![1, 2, 3, 4, 5]),
+			Error::<Test>::InvalidSlashIndex
+		);
+
+		assert_ok!(Staking::cancel_deferred_slash(RuntimeOrigin::root(), 4, vec![0, 2, 4]));
+
+		let slashes = UnappliedSlashes::<Test>::get(&4);
+		assert_eq!(slashes.len(), 2);
+		assert_eq!(slashes[0].validator, 21);
+		assert_eq!(slashes[1].validator, 42);
+	})
+}
+
+#[test]
+fn slash_kicks_validators_not_nominators_and_disables_nominator_for_kicked_validator() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+
+		// pre-slash balance
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		// 100 has approval for 11 as of now
+		assert!(Staking::nominators(101).unwrap().targets.contains(&11));
+
+		// 11 and 21 both have the support of 100
+		let exposure_11 = Staking::eras_stakers(active_era(), &11);
+		let exposure_21 = Staking::eras_stakers(active_era(), &21);
+
+		assert_eq!(exposure_11.total, 1000 + 125);
+		assert_eq!(exposure_21.total, 1000 + 375);
+
+		on_offence_now(
+			&[OffenceDetails { offender: (11, exposure_11.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(10)],
+		);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				Event::StakersElected,
+				Event::EraPaid { era_index: 0, validator_payout: 11075, remainder: 33225 },
+				Event::Chilled { stash: 11 },
+				Event::ForceEra { mode: Forcing::ForceNew },
+				Event::SlashReported {
+					validator: 11,
+					fraction: Perbill::from_percent(10),
+					slash_era: 1
+				},
+				Event::Slashed { staker: 11, amount: 100 },
+				Event::Slashed { staker: 101, amount: 12 },
+			]
+		);
+
+		// post-slash balance
+		let nominator_slash_amount_11 = 125 / 10;
+		assert_eq!(Balances::free_balance(11), 900);
+		assert_eq!(Balances::free_balance(101), 2000 - nominator_slash_amount_11);
+
+		// check that validator was chilled.
+		assert!(Validators::<Test>::iter().all(|(stash, _)| stash != 11));
+
+		// actually re-bond the slashed validator
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(11), Default::default()));
+
+		mock::start_active_era(2);
+		let exposure_11 = Staking::eras_stakers(active_era(), &11);
+		let exposure_21 = Staking::eras_stakers(active_era(), &21);
+
+		// 11's own expo is reduced. sum of support from 11 is less (448), which is 500
+		// 900 + 146
+		assert!(matches!(exposure_11, Exposure { own: 900, total: 1046, .. }));
+		// 1000 + 342
+		assert!(matches!(exposure_21, Exposure { own: 1000, total: 1342, .. }));
+		assert_eq!(500 - 146 - 342, nominator_slash_amount_11);
+	});
+}
+
+#[test]
+fn non_slashable_offence_doesnt_disable_validator() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+
+		let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
+		let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
+
+		// offence with no slash associated
+		on_offence_now(
+			&[OffenceDetails { offender: (11, exposure_11.clone()), reporters: vec![] }],
+			&[Perbill::zero()],
+		);
+
+		// it does NOT affect the nominator.
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+		// offence that slashes 25% of the bond
+		on_offence_now(
+			&[OffenceDetails { offender: (21, exposure_21.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(25)],
+		);
+
+		// it DOES NOT affect the nominator.
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				Event::StakersElected,
+				Event::EraPaid { era_index: 0, validator_payout: 11075, remainder: 33225 },
+				Event::Chilled { stash: 11 },
+				Event::ForceEra { mode: Forcing::ForceNew },
+				Event::SlashReported {
+					validator: 11,
+					fraction: Perbill::from_percent(0),
+					slash_era: 1
+				},
+				Event::Chilled { stash: 21 },
+				Event::SlashReported {
+					validator: 21,
+					fraction: Perbill::from_percent(25),
+					slash_era: 1
+				},
+				Event::Slashed { staker: 21, amount: 250 },
+				Event::Slashed { staker: 101, amount: 94 }
+			]
+		);
+
+		// the offence for validator 10 wasn't slashable so it wasn't disabled
+		assert!(!is_disabled(11));
+		// whereas validator 20 gets disabled
+		assert!(is_disabled(21));
+	});
+}
+
+#[test]
+fn slashing_independent_of_disabling_validator() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+		assert_eq_uvec!(Session::validators(), vec![11, 21]);
+
+		let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
+		let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
+
+		let now = Staking::active_era().unwrap().index;
+
+		// offence with no slash associated, BUT disabling
+		on_offence_in_era(
+			&[OffenceDetails { offender: (11, exposure_11.clone()), reporters: vec![] }],
+			&[Perbill::zero()],
+			now,
+			DisableStrategy::Always,
+		);
+
+		// nomination remains untouched.
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+		// offence that slashes 25% of the bond, BUT not disabling
+		on_offence_in_era(
+			&[OffenceDetails { offender: (21, exposure_21.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(25)],
+			now,
+			DisableStrategy::Never,
+		);
+
+		// nomination remains untouched.
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+		assert_eq!(
+			staking_events_since_last_call(),
+			vec![
+				Event::StakersElected,
+				Event::EraPaid { era_index: 0, validator_payout: 11075, remainder: 33225 },
+				Event::Chilled { stash: 11 },
+				Event::ForceEra { mode: Forcing::ForceNew },
+				Event::SlashReported {
+					validator: 11,
+					fraction: Perbill::from_percent(0),
+					slash_era: 1
+				},
+				Event::Chilled { stash: 21 },
+				Event::SlashReported {
+					validator: 21,
+					fraction: Perbill::from_percent(25),
+					slash_era: 1
+				},
+				Event::Slashed { staker: 21, amount: 250 },
+				Event::Slashed { staker: 101, amount: 94 }
+			]
+		);
+
+		// the offence for validator 10 was explicitly disabled
+		assert!(is_disabled(11));
+		// whereas validator 21 is explicitly not disabled
+		assert!(!is_disabled(21));
+	});
+}
+
+#[test]
+fn offence_threshold_triggers_new_era() {
+	ExtBuilder::default()
+		.validator_count(4)
+		.set_status(41, StakerStatus::Validator)
+		.build_and_execute(|| {
+			mock::start_active_era(1);
+			assert_eq_uvec!(Session::validators(), vec![11, 21, 31, 41]);
+
+			assert_eq!(
+				<Test as Config>::OffendingValidatorsThreshold::get(),
+				Perbill::from_percent(75),
+			);
+
+			// we have 4 validators and an offending validator threshold of 75%,
+			// once the third validator commits an offence a new era should be forced
+
+			let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
+			let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
+			let exposure_31 = Staking::eras_stakers(Staking::active_era().unwrap().index, &31);
+
+			on_offence_now(
+				&[OffenceDetails { offender: (11, exposure_11.clone()), reporters: vec![] }],
+				&[Perbill::zero()],
+			);
+
+			assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
+
+			on_offence_now(
+				&[OffenceDetails { offender: (21, exposure_21.clone()), reporters: vec![] }],
+				&[Perbill::zero()],
+			);
+
+			assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
+
+			on_offence_now(
+				&[OffenceDetails { offender: (31, exposure_31.clone()), reporters: vec![] }],
+				&[Perbill::zero()],
+			);
+
+			assert_eq!(ForceEra::<Test>::get(), Forcing::ForceNew);
+		});
+}
+
+#[test]
+fn disabled_validators_are_kept_disabled_for_whole_era() {
+	ExtBuilder::default()
+		.validator_count(4)
+		.set_status(41, StakerStatus::Validator)
+		.build_and_execute(|| {
+			mock::start_active_era(1);
+			assert_eq_uvec!(Session::validators(), vec![11, 21, 31, 41]);
+			assert_eq!(<Test as Config>::SessionsPerEra::get(), 3);
+
+			let exposure_11 = Staking::eras_stakers(Staking::active_era().unwrap().index, &11);
+			let exposure_21 = Staking::eras_stakers(Staking::active_era().unwrap().index, &21);
+
+			on_offence_now(
+				&[OffenceDetails { offender: (11, exposure_11.clone()), reporters: vec![] }],
+				&[Perbill::zero()],
+			);
+
+			on_offence_now(
+				&[OffenceDetails { offender: (21, exposure_21.clone()), reporters: vec![] }],
+				&[Perbill::from_percent(25)],
+			);
+
+			// nominations are not updated.
+			assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+			// validator 11 should not be disabled since the offence wasn't slashable
+			assert!(!is_disabled(11));
+			// validator 21 gets disabled since it got slashed
+			assert!(is_disabled(21));
+
+			advance_session();
+
+			// disabled validators should carry-on through all sessions in the era
+			assert!(!is_disabled(11));
+			assert!(is_disabled(21));
+
+			// validator 11 should now get disabled
+			on_offence_now(
+				&[OffenceDetails { offender: (11, exposure_11.clone()), reporters: vec![] }],
+				&[Perbill::from_percent(25)],
+			);
+
+			// nominations are not updated.
+			assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+
+			advance_session();
+
+			// and both are disabled in the last session of the era
+			assert!(is_disabled(11));
+			assert!(is_disabled(21));
+
+			mock::start_active_era(2);
+
+			// when a new era starts disabled validators get cleared
+			assert!(!is_disabled(11));
+			assert!(!is_disabled(21));
+		});
+}
+
+#[test]
+fn claim_reward_at_the_last_era_and_no_double_claim_and_invalid_claim() {
+	// should check that:
+	// * rewards get paid until history_depth for both validators and nominators
+	// * an invalid era to claim doesn't update last_reward
+	// * double claim of one era fails
+	ExtBuilder::default().nominate(true).build_and_execute(|| {
+		// Consumed weight for all payout_stakers dispatches that fail
+		let err_weight = <Test as Config>::WeightInfo::payout_stakers_alive_staked(0);
+
+		let init_balance_11 = Balances::total_balance(&11);
+		let init_balance_101 = Balances::total_balance(&101);
+
+		let part_for_11 = Perbill::from_rational::<u32>(1000, 1125);
+		let part_for_101 = Perbill::from_rational::<u32>(125, 1125);
+
+		// Check state
+		Payee::<Test>::insert(11, RewardDestination::Controller);
+		Payee::<Test>::insert(101, RewardDestination::Controller);
+
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_0 = current_total_payout_for_duration(reward_time_per_era());
+
+		mock::start_active_era(1);
+
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+		// Change total issuance in order to modify total payout
+		let _ = Balances::deposit_creating(&999, 1_000_000_000);
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_1 = current_total_payout_for_duration(reward_time_per_era());
+		assert!(total_payout_1 != total_payout_0);
+
+		mock::start_active_era(2);
+
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+		// Change total issuance in order to modify total payout
+		let _ = Balances::deposit_creating(&999, 1_000_000_000);
+		// Compute total payout now for whole duration as other parameter won't change
+		let total_payout_2 = current_total_payout_for_duration(reward_time_per_era());
+		assert!(total_payout_2 != total_payout_0);
+		assert!(total_payout_2 != total_payout_1);
+
+		mock::start_active_era(HistoryDepth::get() + 1);
+
+		let active_era = active_era();
+
+		// This is the latest planned era in staking, not the active era
+		let current_era = Staking::current_era().unwrap();
+
+		// Last kept is 1:
+		assert!(current_era - HistoryDepth::get() == 1);
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 0),
+			// Fail: Era out of history
+			Error::<Test>::InvalidEraToReward.with_weight(err_weight)
+		);
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 1));
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 2));
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 2),
+			// Fail: Double claim
+			Error::<Test>::AlreadyClaimed.with_weight(err_weight)
+		);
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, active_era),
+			// Fail: Era not finished yet
+			Error::<Test>::InvalidEraToReward.with_weight(err_weight)
+		);
+
+		// Era 0 can't be rewarded anymore and current era can't be rewarded yet
+		// only era 1 and 2 can be rewarded.
+
+		assert_eq!(
+			Balances::total_balance(&11),
+			init_balance_11 + part_for_11 * (total_payout_1 + total_payout_2),
+		);
+		assert_eq!(
+			Balances::total_balance(&101),
+			init_balance_101 + part_for_101 * (total_payout_1 + total_payout_2),
+		);
+	});
+}
+
+#[test]
+fn zero_slash_keeps_nominators() {
+	ExtBuilder::default().build_and_execute(|| {
+		mock::start_active_era(1);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+
+		let exposure = Staking::eras_stakers(active_era(), 11);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		on_offence_now(
+			&[OffenceDetails { offender: (11, exposure.clone()), reporters: vec![] }],
+			&[Perbill::from_percent(0)],
+		);
+
+		assert_eq!(Balances::free_balance(11), 1000);
+		assert_eq!(Balances::free_balance(101), 2000);
+
+		// 11 is still removed..
+		assert!(Validators::<Test>::iter().all(|(stash, _)| stash != 11));
+		// but their nominations are kept.
+		assert_eq!(Staking::nominators(101).unwrap().targets, vec![11, 21]);
+	});
+}
+
+#[test]
+fn six_session_delay() {
+	ExtBuilder::default().initialize_first_session(false).build_and_execute(|| {
+		use pallet_session::SessionManager;
+
+		let val_set = Session::validators();
+		let init_session = Session::current_index();
+		let init_active_era = active_era();
+
+		// pallet-session is delaying session by one, thus the next session to plan is +2.
+		assert_eq!(<Staking as SessionManager<_>>::new_session(init_session + 2), None);
+		assert_eq!(
+			<Staking as SessionManager<_>>::new_session(init_session + 3),
+			Some(val_set.clone())
+		);
+		assert_eq!(<Staking as SessionManager<_>>::new_session(init_session + 4), None);
+		assert_eq!(<Staking as SessionManager<_>>::new_session(init_session + 5), None);
+		assert_eq!(
+			<Staking as SessionManager<_>>::new_session(init_session + 6),
+			Some(val_set.clone())
+		);
+
+		<Staking as SessionManager<_>>::end_session(init_session);
+		<Staking as SessionManager<_>>::start_session(init_session + 1);
+		assert_eq!(active_era(), init_active_era);
+
+		<Staking as SessionManager<_>>::end_session(init_session + 1);
+		<Staking as SessionManager<_>>::start_session(init_session + 2);
+		assert_eq!(active_era(), init_active_era);
+
+		// Reward current era
+		Staking::reward_by_ids(vec![(11, 1)]);
+
+		// New active era is triggered here.
+		<Staking as SessionManager<_>>::end_session(init_session + 2);
+		<Staking as SessionManager<_>>::start_session(init_session + 3);
+		assert_eq!(active_era(), init_active_era + 1);
+
+		<Staking as SessionManager<_>>::end_session(init_session + 3);
+		<Staking as SessionManager<_>>::start_session(init_session + 4);
+		assert_eq!(active_era(), init_active_era + 1);
+
+		<Staking as SessionManager<_>>::end_session(init_session + 4);
+		<Staking as SessionManager<_>>::start_session(init_session + 5);
+		assert_eq!(active_era(), init_active_era + 1);
+
+		// Reward current era
+		Staking::reward_by_ids(vec![(21, 2)]);
+
+		// New active era is triggered here.
+		<Staking as SessionManager<_>>::end_session(init_session + 5);
+		<Staking as SessionManager<_>>::start_session(init_session + 6);
+		assert_eq!(active_era(), init_active_era + 2);
+
+		// That reward are correct
+		assert_eq!(Staking::eras_reward_points(init_active_era).total, 1);
+		assert_eq!(Staking::eras_reward_points(init_active_era + 1).total, 2);
+	});
+}
+
+#[test]
+fn test_max_nominator_rewarded_per_validator_and_cant_steal_someone_else_reward() {
+	ExtBuilder::default().build_and_execute(|| {
+		for i in 0..=<<Test as Config>::MaxNominatorRewardedPerValidator as Get<_>>::get() {
+			let stash = 10_000 + i as AccountId;
+			let balance = 10_000 + i as Balance;
+			Balances::make_free_balance_be(&stash, balance);
+			assert_ok!(Staking::bond(
+				RuntimeOrigin::signed(stash),
+				balance,
+				RewardDestination::Stash
+			));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(stash), vec![11]));
+		}
+		mock::start_active_era(1);
+
+		Pallet::<Test>::reward_by_ids(vec![(11, 1)]);
+		// compute and ensure the reward amount is greater than zero.
+		let _ = current_total_payout_for_duration(reward_time_per_era());
+
+		mock::start_active_era(2);
+		mock::make_all_reward_payment(1);
+
+		// Assert only nominators from 1 to Max are rewarded
+		for i in 0..=<<Test as Config>::MaxNominatorRewardedPerValidator as Get<_>>::get() {
+			let stash = 10_000 + i as AccountId;
+			let balance = 10_000 + i as Balance;
+			if stash == 10_000 {
+				assert!(Balances::free_balance(&stash) == balance);
+			} else {
+				assert!(Balances::free_balance(&stash) > balance);
+			}
+		}
+	});
+}
+
+#[test]
+fn test_payout_stakers() {
+	// Test that payout_stakers work in general, including that only the top
+	// `T::MaxNominatorRewardedPerValidator` nominators are rewarded.
+	ExtBuilder::default().has_stakers(false).build_and_execute(|| {
+		let balance = 1000;
+		// Track the exposure of the validator and all nominators.
+		let mut total_exposure = balance;
+		// Track the exposure of the validator and the nominators that will get paid out.
+		let mut payout_exposure = balance;
+		// Create a validator:
+		bond_validator(11, balance); // Default(64)
+		assert_eq!(Validators::<Test>::count(), 1);
+
+		// Create nominators, targeting stash of validators
+		for i in 0..100 {
+			let bond_amount = balance + i as Balance;
+			bond_nominator(1000 + i, bond_amount, vec![11]);
+			total_exposure += bond_amount;
+			if i >= 36 {
+				payout_exposure += bond_amount;
+			};
+		}
+		let payout_exposure_part = Perbill::from_rational(payout_exposure, total_exposure);
+
+		mock::start_active_era(1);
+		Staking::reward_by_ids(vec![(11, 1)]);
+
+		// compute and ensure the reward amount is greater than zero.
+		let payout = current_total_payout_for_duration(reward_time_per_era());
+		let actual_paid_out = payout_exposure_part * payout;
+
+		mock::start_active_era(2);
+
+		let pre_payout_total_issuance = Balances::total_issuance();
+		RewardOnUnbalanceWasCalled::set(false);
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 1));
+		assert_eq_error_rate!(
+			Balances::total_issuance(),
+			pre_payout_total_issuance + actual_paid_out,
+			1
+		);
+		assert!(RewardOnUnbalanceWasCalled::get());
+
+		// Top 64 nominators of validator 11 automatically paid out, including the validator
+		// Validator payout goes to controller.
+		assert!(Balances::free_balance(&11) > balance);
+		for i in 36..100 {
+			assert!(Balances::free_balance(&(1000 + i)) > balance + i as Balance);
+		}
+		// The bottom 36 do not
+		for i in 0..36 {
+			assert_eq!(Balances::free_balance(&(1000 + i)), balance + i as Balance);
+		}
+
+		// We track rewards in `claimed_rewards` vec
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![1]
+			})
+		);
+
+		for i in 3..16 {
+			Staking::reward_by_ids(vec![(11, 1)]);
+
+			// compute and ensure the reward amount is greater than zero.
+			let payout = current_total_payout_for_duration(reward_time_per_era());
+			let actual_paid_out = payout_exposure_part * payout;
+			let pre_payout_total_issuance = Balances::total_issuance();
+
+			mock::start_active_era(i);
+			RewardOnUnbalanceWasCalled::set(false);
+			assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, i - 1));
+			assert_eq_error_rate!(
+				Balances::total_issuance(),
+				pre_payout_total_issuance + actual_paid_out,
+				1
+			);
+			assert!(RewardOnUnbalanceWasCalled::get());
+		}
+
+		// We track rewards in `claimed_rewards` vec
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: (1..=14).collect::<Vec<_>>().try_into().unwrap()
+			})
+		);
+
+		let last_era = 99;
+		let history_depth = HistoryDepth::get();
+		let expected_last_reward_era = last_era - 1;
+		let expected_start_reward_era = last_era - history_depth;
+		for i in 16..=last_era {
+			Staking::reward_by_ids(vec![(11, 1)]);
+			// compute and ensure the reward amount is greater than zero.
+			let _ = current_total_payout_for_duration(reward_time_per_era());
+			mock::start_active_era(i);
+		}
+
+		// We clean it up as history passes
+		assert_ok!(Staking::payout_stakers(
+			RuntimeOrigin::signed(1337),
+			11,
+			expected_start_reward_era
+		));
+		assert_ok!(Staking::payout_stakers(
+			RuntimeOrigin::signed(1337),
+			11,
+			expected_last_reward_era
+		));
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![expected_start_reward_era, expected_last_reward_era]
+			})
+		);
+
+		// Out of order claims works.
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 69));
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 23));
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 42));
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![
+					expected_start_reward_era,
+					23,
+					42,
+					69,
+					expected_last_reward_era
+				]
+			})
+		);
+	});
+}
+
+#[test]
+fn payout_stakers_handles_basic_errors() {
+	// Here we will test payouts handle all errors.
+	ExtBuilder::default().has_stakers(false).build_and_execute(|| {
+		// Consumed weight for all payout_stakers dispatches that fail
+		let err_weight = <Test as Config>::WeightInfo::payout_stakers_alive_staked(0);
+
+		// Same setup as the test above
+		let balance = 1000;
+		bond_validator(11, balance); // Default(64)
+
+		// Create nominators, targeting stash
+		for i in 0..100 {
+			bond_nominator(1000 + i, balance + i as Balance, vec![11]);
+		}
+
+		mock::start_active_era(1);
+		Staking::reward_by_ids(vec![(11, 1)]);
+
+		// compute and ensure the reward amount is greater than zero.
+		let _ = current_total_payout_for_duration(reward_time_per_era());
+
+		mock::start_active_era(2);
+
+		// Wrong Era, too big
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 2),
+			Error::<Test>::InvalidEraToReward.with_weight(err_weight)
+		);
+		// Wrong Staker
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 10, 1),
+			Error::<Test>::NotStash.with_weight(err_weight)
+		);
+
+		let last_era = 99;
+		for i in 3..=last_era {
+			Staking::reward_by_ids(vec![(11, 1)]);
+			// compute and ensure the reward amount is greater than zero.
+			let _ = current_total_payout_for_duration(reward_time_per_era());
+			mock::start_active_era(i);
+		}
+
+		let history_depth = HistoryDepth::get();
+		let expected_last_reward_era = last_era - 1;
+		let expected_start_reward_era = last_era - history_depth;
+
+		// We are at era last_era=99. Given history_depth=80, we should be able
+		// to payout era starting from expected_start_reward_era=19 through
+		// expected_last_reward_era=98 (80 total eras), but not 18 or 99.
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, expected_start_reward_era - 1),
+			Error::<Test>::InvalidEraToReward.with_weight(err_weight)
+		);
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, expected_last_reward_era + 1),
+			Error::<Test>::InvalidEraToReward.with_weight(err_weight)
+		);
+		assert_ok!(Staking::payout_stakers(
+			RuntimeOrigin::signed(1337),
+			11,
+			expected_start_reward_era
+		));
+		assert_ok!(Staking::payout_stakers(
+			RuntimeOrigin::signed(1337),
+			11,
+			expected_last_reward_era
+		));
+
+		// Can't claim again
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, expected_start_reward_era),
+			Error::<Test>::AlreadyClaimed.with_weight(err_weight)
+		);
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, expected_last_reward_era),
+			Error::<Test>::AlreadyClaimed.with_weight(err_weight)
+		);
+	});
+}
+
+#[test]
+fn payout_stakers_handles_weight_refund() {
+	// Note: this test relies on the assumption that `payout_stakers_alive_staked` is solely used by
+	// `payout_stakers` to calculate the weight of each payout op.
+	ExtBuilder::default().has_stakers(false).build_and_execute(|| {
+		let max_nom_rewarded =
+			<<Test as Config>::MaxNominatorRewardedPerValidator as Get<_>>::get();
+		// Make sure the configured value is meaningful for our use.
+		assert!(max_nom_rewarded >= 4);
+		let half_max_nom_rewarded = max_nom_rewarded / 2;
+		// Sanity check our max and half max nominator quantities.
+		assert!(half_max_nom_rewarded > 0);
+		assert!(max_nom_rewarded > half_max_nom_rewarded);
+
+		let max_nom_rewarded_weight =
+			<Test as Config>::WeightInfo::payout_stakers_alive_staked(max_nom_rewarded);
+		let half_max_nom_rewarded_weight =
+			<Test as Config>::WeightInfo::payout_stakers_alive_staked(half_max_nom_rewarded);
+		let zero_nom_payouts_weight = <Test as Config>::WeightInfo::payout_stakers_alive_staked(0);
+		assert!(zero_nom_payouts_weight.any_gt(Weight::zero()));
+		assert!(half_max_nom_rewarded_weight.any_gt(zero_nom_payouts_weight));
+		assert!(max_nom_rewarded_weight.any_gt(half_max_nom_rewarded_weight));
+
+		let balance = 1000;
+		bond_validator(11, balance);
+
+		// Era 1
+		start_active_era(1);
+
+		// Reward just the validator.
+		Staking::reward_by_ids(vec![(11, 1)]);
+
+		// Add some `half_max_nom_rewarded` nominators who will start backing the validator in the
+		// next era.
+		for i in 0..half_max_nom_rewarded {
+			bond_nominator((1000 + i).into(), balance + i as Balance, vec![11]);
+		}
+
+		// Era 2
+		start_active_era(2);
+
+		// Collect payouts when there are no nominators
+		let call = TestCall::Staking(StakingCall::payout_stakers { validator_stash: 11, era: 1 });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(20));
+		assert_ok!(result);
+		assert_eq!(extract_actual_weight(&result, &info), zero_nom_payouts_weight);
+
+		// The validator is not rewarded in this era; so there will be zero payouts to claim for
+		// this era.
+
+		// Era 3
+		start_active_era(3);
+
+		// Collect payouts for an era where the validator did not receive any points.
+		let call = TestCall::Staking(StakingCall::payout_stakers { validator_stash: 11, era: 2 });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(20));
+		assert_ok!(result);
+		assert_eq!(extract_actual_weight(&result, &info), zero_nom_payouts_weight);
+
+		// Reward the validator and its nominators.
+		Staking::reward_by_ids(vec![(11, 1)]);
+
+		// Era 4
+		start_active_era(4);
+
+		// Collect payouts when the validator has `half_max_nom_rewarded` nominators.
+		let call = TestCall::Staking(StakingCall::payout_stakers { validator_stash: 11, era: 3 });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(20));
+		assert_ok!(result);
+		assert_eq!(extract_actual_weight(&result, &info), half_max_nom_rewarded_weight);
+
+		// Add enough nominators so that we are at the limit. They will be active nominators
+		// in the next era.
+		for i in half_max_nom_rewarded..max_nom_rewarded {
+			bond_nominator((1000 + i).into(), balance + i as Balance, vec![11]);
+		}
+
+		// Era 5
+		start_active_era(5);
+		// We now have `max_nom_rewarded` nominators actively nominating our validator.
+
+		// Reward the validator so we can collect for everyone in the next era.
+		Staking::reward_by_ids(vec![(11, 1)]);
+
+		// Era 6
+		start_active_era(6);
+
+		// Collect payouts when the validator had `half_max_nom_rewarded` nominators.
+		let call = TestCall::Staking(StakingCall::payout_stakers { validator_stash: 11, era: 5 });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(20));
+		assert_ok!(result);
+		assert_eq!(extract_actual_weight(&result, &info), max_nom_rewarded_weight);
+
+		// Try and collect payouts for an era that has already been collected.
+		let call = TestCall::Staking(StakingCall::payout_stakers { validator_stash: 11, era: 5 });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(20));
+		assert!(result.is_err());
+		// When there is an error the consumed weight == weight when there are 0 nominator payouts.
+		assert_eq!(extract_actual_weight(&result, &info), zero_nom_payouts_weight);
+	});
+}
+
+#[test]
+fn bond_during_era_correctly_populates_claimed_rewards() {
+	ExtBuilder::default().has_stakers(false).build_and_execute(|| {
+		// Era = None
+		bond_validator(9, 1000);
+		assert_eq!(
+			Staking::ledger(&9),
+			Some(StakingLedger {
+				stash: 9,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: bounded_vec![],
+			})
+		);
+		mock::start_active_era(5);
+		bond_validator(11, 1000);
+		assert_eq!(
+			Staking::ledger(&11),
+			Some(StakingLedger {
+				stash: 11,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: (0..5).collect::<Vec<_>>().try_into().unwrap(),
+			})
+		);
+
+		// make sure only era upto history depth is stored
+		let current_era = 99;
+		let last_reward_era = 99 - HistoryDepth::get();
+		mock::start_active_era(current_era);
+		bond_validator(13, 1000);
+		assert_eq!(
+			Staking::ledger(&13),
+			Some(StakingLedger {
+				stash: 13,
+				total: 1000,
+				active: 1000,
+				unlocking: Default::default(),
+				claimed_rewards: (last_reward_era..current_era)
+					.collect::<Vec<_>>()
+					.try_into()
+					.unwrap(),
+			})
+		);
+	});
+}
+
+#[test]
+fn offences_weight_calculated_correctly() {
+	ExtBuilder::default().nominate(true).build_and_execute(|| {
+		// On offence with zero offenders: 4 Reads, 1 Write
+		let zero_offence_weight =
+			<Test as frame_system::Config>::DbWeight::get().reads_writes(4, 1);
+		assert_eq!(
+			Staking::on_offence(&[], &[Perbill::from_percent(50)], 0, DisableStrategy::WhenSlashed),
+			zero_offence_weight
+		);
+
+		// On Offence with N offenders, Unapplied: 4 Reads, 1 Write + 4 Reads, 5 Writes
+		let n_offence_unapplied_weight = <Test as frame_system::Config>::DbWeight::get()
+			.reads_writes(4, 1) +
+			<Test as frame_system::Config>::DbWeight::get().reads_writes(4, 5);
+
+		let offenders: Vec<
+			OffenceDetails<
+				<Test as frame_system::Config>::AccountId,
+				pallet_session::historical::IdentificationTuple<Test>,
+			>,
+		> = (1..10)
+			.map(|i| OffenceDetails {
+				offender: (i, Staking::eras_stakers(active_era(), i)),
+				reporters: vec![],
+			})
+			.collect();
+		assert_eq!(
+			Staking::on_offence(
+				&offenders,
+				&[Perbill::from_percent(50)],
+				0,
+				DisableStrategy::WhenSlashed
+			),
+			n_offence_unapplied_weight
+		);
+
+		// On Offence with one offenders, Applied
+		let one_offender = [OffenceDetails {
+			offender: (11, Staking::eras_stakers(active_era(), 11)),
+			reporters: vec![1],
+		}];
+
+		let n = 1; // Number of offenders
+		let rw = 3 + 3 * n; // rw reads and writes
+		let one_offence_unapplied_weight =
+			<Test as frame_system::Config>::DbWeight::get().reads_writes(4, 1)
+		 +
+			<Test as frame_system::Config>::DbWeight::get().reads_writes(rw, rw)
+			// One `slash_cost`
+			+ <Test as frame_system::Config>::DbWeight::get().reads_writes(6, 5)
+			// `slash_cost` * nominators (1)
+			+ <Test as frame_system::Config>::DbWeight::get().reads_writes(6, 5)
+			// `reward_cost` * reporters (1)
+			+ <Test as frame_system::Config>::DbWeight::get().reads_writes(2, 2)
+		;
+
+		assert_eq!(
+			Staking::on_offence(
+				&one_offender,
+				&[Perbill::from_percent(50)],
+				0,
+				DisableStrategy::WhenSlashed{}
+			),
+			one_offence_unapplied_weight
+		);
+	});
+}
+
+#[test]
+fn payout_creates_controller() {
+	ExtBuilder::default().has_stakers(false).build_and_execute(|| {
+		let balance = 1000;
+		// Create a validator:
+		bond_validator(11, balance);
+
+		// create a stash/controller pair and nominate
+		let (stash, controller) = testing_utils::create_unique_stash_controller::<Test>(
+			0,
+			100,
+			RewardDestination::Controller,
+			false,
+		)
+		.unwrap();
+		assert_ok!(Staking::nominate(RuntimeOrigin::signed(controller), vec![11]));
+
+		// kill controller
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(controller), stash, 100));
+		assert_eq!(Balances::free_balance(controller), 0);
+
+		mock::start_active_era(1);
+		Staking::reward_by_ids(vec![(11, 1)]);
+		// compute and ensure the reward amount is greater than zero.
+		let _ = current_total_payout_for_duration(reward_time_per_era());
+		mock::start_active_era(2);
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(controller), 11, 1));
+
+		// Controller is created
+		assert!(Balances::free_balance(controller) > 0);
+	})
+}
+
+#[test]
+fn payout_to_any_account_works() {
+	ExtBuilder::default().has_stakers(false).build_and_execute(|| {
+		let balance = 1000;
+		// Create a validator:
+		bond_validator(11, balance); // Default(64)
+
+		// Create a stash/controller pair
+		bond_nominator(1234, 100, vec![11]);
+
+		// Update payout location
+		assert_ok!(Staking::set_payee(RuntimeOrigin::signed(1234), RewardDestination::Account(42)));
+
+		// Reward Destination account doesn't exist
+		assert_eq!(Balances::free_balance(42), 0);
+
+		mock::start_active_era(1);
+		Staking::reward_by_ids(vec![(11, 1)]);
+		// compute and ensure the reward amount is greater than zero.
+		let _ = current_total_payout_for_duration(reward_time_per_era());
+		mock::start_active_era(2);
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(1337), 11, 1));
+
+		// Payment is successful
+		assert!(Balances::free_balance(42) > 0);
+	})
+}
+
+#[test]
+fn session_buffering_with_offset() {
+	// similar to live-chains, have some offset for the first session
+	ExtBuilder::default()
+		.offset(2)
+		.period(5)
+		.session_per_era(5)
+		.build_and_execute(|| {
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 0);
+
+			start_session(1);
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 1);
+			assert_eq!(System::block_number(), 2);
+
+			start_session(2);
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 2);
+			assert_eq!(System::block_number(), 7);
+
+			start_session(3);
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 3);
+			assert_eq!(System::block_number(), 12);
+
+			// active era is lagging behind by one session, because of how session module works.
+			start_session(4);
+			assert_eq!(current_era(), 1);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 4);
+			assert_eq!(System::block_number(), 17);
+
+			start_session(5);
+			assert_eq!(current_era(), 1);
+			assert_eq!(active_era(), 1);
+			assert_eq!(Session::current_index(), 5);
+			assert_eq!(System::block_number(), 22);
+
+			// go all the way to active 2.
+			start_active_era(2);
+			assert_eq!(current_era(), 2);
+			assert_eq!(active_era(), 2);
+			assert_eq!(Session::current_index(), 10);
+		});
+}
+
+#[test]
+fn session_buffering_no_offset() {
+	// no offset, first session starts immediately
+	ExtBuilder::default()
+		.offset(0)
+		.period(5)
+		.session_per_era(5)
+		.build_and_execute(|| {
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 0);
+
+			start_session(1);
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 1);
+			assert_eq!(System::block_number(), 5);
+
+			start_session(2);
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 2);
+			assert_eq!(System::block_number(), 10);
+
+			start_session(3);
+			assert_eq!(current_era(), 0);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 3);
+			assert_eq!(System::block_number(), 15);
+
+			// active era is lagging behind by one session, because of how session module works.
+			start_session(4);
+			assert_eq!(current_era(), 1);
+			assert_eq!(active_era(), 0);
+			assert_eq!(Session::current_index(), 4);
+			assert_eq!(System::block_number(), 20);
+
+			start_session(5);
+			assert_eq!(current_era(), 1);
+			assert_eq!(active_era(), 1);
+			assert_eq!(Session::current_index(), 5);
+			assert_eq!(System::block_number(), 25);
+
+			// go all the way to active 2.
+			start_active_era(2);
+			assert_eq!(current_era(), 2);
+			assert_eq!(active_era(), 2);
+			assert_eq!(Session::current_index(), 10);
+		});
+}
+
+#[test]
+fn cannot_rebond_to_lower_than_ed() {
+	ExtBuilder::default()
+		.existential_deposit(11)
+		.balance_factor(11)
+		.build_and_execute(|| {
+			// initial stuff.
+			assert_eq!(
+				Staking::ledger(&21).unwrap(),
+				StakingLedger {
+					stash: 21,
+					total: 11 * 1000,
+					active: 11 * 1000,
+					unlocking: Default::default(),
+					claimed_rewards: bounded_vec![],
+				}
+			);
+
+			// unbond all of it. must be chilled first.
+			assert_ok!(Staking::chill(RuntimeOrigin::signed(21)));
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(21), 11 * 1000));
+			assert_eq!(
+				Staking::ledger(&21).unwrap(),
+				StakingLedger {
+					stash: 21,
+					total: 11 * 1000,
+					active: 0,
+					unlocking: bounded_vec![UnlockChunk { value: 11 * 1000, era: 3 }],
+					claimed_rewards: bounded_vec![],
+				}
+			);
+
+			// now bond a wee bit more
+			assert_noop!(
+				Staking::rebond(RuntimeOrigin::signed(21), 5),
+				Error::<Test>::InsufficientBond
+			);
+		})
+}
+
+#[test]
+fn cannot_bond_extra_to_lower_than_ed() {
+	ExtBuilder::default()
+		.existential_deposit(11)
+		.balance_factor(11)
+		.build_and_execute(|| {
+			// initial stuff.
+			assert_eq!(
+				Staking::ledger(&21).unwrap(),
+				StakingLedger {
+					stash: 21,
+					total: 11 * 1000,
+					active: 11 * 1000,
+					unlocking: Default::default(),
+					claimed_rewards: bounded_vec![],
+				}
+			);
+
+			// unbond all of it. must be chilled first.
+			assert_ok!(Staking::chill(RuntimeOrigin::signed(21)));
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(21), 11 * 1000));
+			assert_eq!(
+				Staking::ledger(&21).unwrap(),
+				StakingLedger {
+					stash: 21,
+					total: 11 * 1000,
+					active: 0,
+					unlocking: bounded_vec![UnlockChunk { value: 11 * 1000, era: 3 }],
+					claimed_rewards: bounded_vec![],
+				}
+			);
+
+			// now bond a wee bit more
+			assert_noop!(
+				Staking::bond_extra(RuntimeOrigin::signed(21), 5),
+				Error::<Test>::InsufficientBond,
+			);
+		})
+}
+
+#[test]
+fn do_not_die_when_active_is_ed() {
+	let ed = 10;
+	ExtBuilder::default()
+		.existential_deposit(ed)
+		.balance_factor(ed)
+		.build_and_execute(|| {
+			// given
+			assert_eq!(
+				Staking::ledger(&21).unwrap(),
+				StakingLedger {
+					stash: 21,
+					total: 1000 * ed,
+					active: 1000 * ed,
+					unlocking: Default::default(),
+					claimed_rewards: bounded_vec![],
+				}
+			);
+
+			// when unbond all of it except ed.
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(21), 999 * ed));
+			start_active_era(3);
+			assert_ok!(Staking::withdraw_unbonded(RuntimeOrigin::signed(21), 100));
+
+			// then
+			assert_eq!(
+				Staking::ledger(&21).unwrap(),
+				StakingLedger {
+					stash: 21,
+					total: ed,
+					active: ed,
+					unlocking: Default::default(),
+					claimed_rewards: bounded_vec![],
+				}
+			);
+		})
+}
+
+#[test]
+fn on_finalize_weight_is_nonzero() {
+	ExtBuilder::default().build_and_execute(|| {
+		let on_finalize_weight = <Test as frame_system::Config>::DbWeight::get().reads(1);
+		assert!(<Staking as Hooks<u64>>::on_initialize(1).all_gte(on_finalize_weight));
+	})
+}
+
+mod election_data_provider {
+	use super::*;
+	use frame_election_provider_support::ElectionDataProvider;
+
+	#[test]
+	fn targets_2sec_block() {
+		let mut validators = 1000;
+		while <Test as Config>::WeightInfo::get_npos_targets(validators).all_lt(Weight::from_parts(
+			2u64 * frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,
+			u64::MAX,
+		)) {
+			validators += 1;
+		}
+
+		println!("Can create a snapshot of {} validators in 2sec block", validators);
+	}
+
+	#[test]
+	fn voters_2sec_block() {
+		// we assume a network only wants up to 1000 validators in most cases, thus having 2000
+		// candidates is as high as it gets.
+		let validators = 2000;
+		let mut nominators = 1000;
+
+		while <Test as Config>::WeightInfo::get_npos_voters(validators, nominators).all_lt(
+			Weight::from_parts(
+				2u64 * frame_support::weights::constants::WEIGHT_REF_TIME_PER_SECOND,
+				u64::MAX,
+			),
+		) {
+			nominators += 1;
+		}
+
+		println!(
+			"Can create a snapshot of {} nominators [{} validators, each 1 slashing] in 2sec block",
+			nominators, validators
+		);
+	}
+
+	#[test]
+	fn set_minimum_active_stake_is_correct() {
+		ExtBuilder::default()
+			.nominate(false)
+			.add_staker(61, 61, 2_000, StakerStatus::<AccountId>::Nominator(vec![21]))
+			.add_staker(71, 71, 10, StakerStatus::<AccountId>::Nominator(vec![21]))
+			.add_staker(81, 81, 50, StakerStatus::<AccountId>::Nominator(vec![21]))
+			.build_and_execute(|| {
+				// default bounds are unbounded.
+				assert_ok!(<Staking as ElectionDataProvider>::electing_voters(
+					DataProviderBounds::default()
+				));
+				assert_eq!(MinimumActiveStake::<Test>::get(), 10);
+
+				// remove staker with lower bond by limiting the number of voters and check
+				// `MinimumActiveStake` again after electing voters.
+				let bounds = ElectionBoundsBuilder::default().voters_count(5.into()).build();
+				assert_ok!(<Staking as ElectionDataProvider>::electing_voters(bounds.voters));
+				assert_eq!(MinimumActiveStake::<Test>::get(), 50);
+			});
+	}
+
+	#[test]
+	fn set_minimum_active_stake_lower_bond_works() {
+		// if there are no voters, minimum active stake is zero (should not happen).
+		ExtBuilder::default().has_stakers(false).build_and_execute(|| {
+			// default bounds are unbounded.
+			assert_ok!(<Staking as ElectionDataProvider>::electing_voters(
+				DataProviderBounds::default()
+			));
+			assert_eq!(<Test as Config>::VoterList::count(), 0);
+			assert_eq!(MinimumActiveStake::<Test>::get(), 0);
+		});
+
+		// lower non-zero active stake below `MinNominatorBond` is the minimum active stake if
+		// it is selected as part of the npos voters.
+		ExtBuilder::default().has_stakers(true).nominate(true).build_and_execute(|| {
+			assert_eq!(MinNominatorBond::<Test>::get(), 1);
+			assert_eq!(<Test as Config>::VoterList::count(), 4);
+
+			assert_ok!(Staking::bond(RuntimeOrigin::signed(4), 5, Default::default(),));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(4), vec![1]));
+			assert_eq!(<Test as Config>::VoterList::count(), 5);
+
+			let voters_before =
+				<Staking as ElectionDataProvider>::electing_voters(DataProviderBounds::default())
+					.unwrap();
+			assert_eq!(MinimumActiveStake::<Test>::get(), 5);
+
+			// update minimum nominator bond.
+			MinNominatorBond::<Test>::set(10);
+			assert_eq!(MinNominatorBond::<Test>::get(), 10);
+			// voter list still considers nominator 4 for voting, even though its active stake is
+			// lower than `MinNominatorBond`.
+			assert_eq!(<Test as Config>::VoterList::count(), 5);
+
+			let voters =
+				<Staking as ElectionDataProvider>::electing_voters(DataProviderBounds::default())
+					.unwrap();
+			assert_eq!(voters_before, voters);
+
+			// minimum active stake is lower than `MinNominatorBond`.
+			assert_eq!(MinimumActiveStake::<Test>::get(), 5);
+		});
+	}
+
+	#[test]
+	fn set_minimum_active_bond_corrupt_state() {
+		ExtBuilder::default()
+			.has_stakers(true)
+			.nominate(true)
+			.add_staker(61, 61, 2_000, StakerStatus::<AccountId>::Nominator(vec![21]))
+			.build_and_execute(|| {
+				assert_eq!(Staking::weight_of(&101), 500);
+				let voters = <Staking as ElectionDataProvider>::electing_voters(
+					DataProviderBounds::default(),
+				)
+				.unwrap();
+				assert_eq!(voters.len(), 5);
+				assert_eq!(MinimumActiveStake::<Test>::get(), 500);
+
+				assert_ok!(Staking::unbond(RuntimeOrigin::signed(101), 200));
+				start_active_era(10);
+				assert_ok!(Staking::unbond(RuntimeOrigin::signed(101), 100));
+				start_active_era(20);
+
+				// corrupt ledger state by lowering max unlocking chunks bounds.
+				MaxUnlockingChunks::set(1);
+
+				let voters = <Staking as ElectionDataProvider>::electing_voters(
+					DataProviderBounds::default(),
+				)
+				.unwrap();
+				// number of returned voters decreases since ledger entry of stash 101 is now
+				// corrupt.
+				assert_eq!(voters.len(), 4);
+				// minimum active stake does not take into consideration the corrupt entry.
+				assert_eq!(MinimumActiveStake::<Test>::get(), 2_000);
+
+				// voter weight of corrupted ledger entry is 0.
+				assert_eq!(Staking::weight_of(&101), 0);
+
+				// reset max unlocking chunks for try_state to pass.
+				MaxUnlockingChunks::set(32);
+			})
+	}
+
+	#[test]
+	fn voters_include_self_vote() {
+		ExtBuilder::default().nominate(false).build_and_execute(|| {
+			// default bounds are unbounded.
+			assert!(<Validators<Test>>::iter().map(|(x, _)| x).all(|v| Staking::electing_voters(
+				DataProviderBounds::default()
+			)
+			.unwrap()
+			.into_iter()
+			.any(|(w, _, t)| { v == w && t[0] == w })))
+		})
+	}
+
+	// Tests the criteria that in `ElectionDataProvider::voters` function, we try to get at most
+	// `maybe_max_len` voters, and if some of them end up being skipped, we iterate at most `2 *
+	// maybe_max_len`.
+	#[test]
+	#[should_panic]
+	fn only_iterates_max_2_times_max_allowed_len() {
+		ExtBuilder::default()
+			.nominate(false)
+			// the best way to invalidate a bunch of nominators is to have them nominate a lot of
+			// ppl, but then lower the MaxNomination limit.
+			.add_staker(
+				61,
+				61,
+				2_000,
+				StakerStatus::<AccountId>::Nominator(vec![21, 22, 23, 24, 25]),
+			)
+			.add_staker(
+				71,
+				71,
+				2_000,
+				StakerStatus::<AccountId>::Nominator(vec![21, 22, 23, 24, 25]),
+			)
+			.add_staker(
+				81,
+				81,
+				2_000,
+				StakerStatus::<AccountId>::Nominator(vec![21, 22, 23, 24, 25]),
+			)
+			.build_and_execute(|| {
+				let bounds_builder = ElectionBoundsBuilder::default();
+				// all voters ordered by stake,
+				assert_eq!(
+					<Test as Config>::VoterList::iter().collect::<Vec<_>>(),
+					vec![61, 71, 81, 11, 21, 31]
+				);
+
+				AbsoluteMaxNominations::set(2);
+
+				// we want 2 voters now, and in maximum we allow 4 iterations. This is what happens:
+				// 61 is pruned;
+				// 71 is pruned;
+				// 81 is pruned;
+				// 11 is taken;
+				// we finish since the 2x limit is reached.
+				assert_eq!(
+					Staking::electing_voters(bounds_builder.voters_count(2.into()).build().voters)
+						.unwrap()
+						.iter()
+						.map(|(stash, _, _)| stash)
+						.copied()
+						.collect::<Vec<_>>(),
+					vec![11],
+				);
+			});
+	}
+
+	#[test]
+	fn respects_snapshot_count_limits() {
+		ExtBuilder::default()
+			.set_status(41, StakerStatus::Validator)
+			.build_and_execute(|| {
+				// sum of all nominators who'd be voters (1), plus the self-votes (4).
+				assert_eq!(<Test as Config>::VoterList::count(), 5);
+
+				let bounds_builder = ElectionBoundsBuilder::default();
+
+				// if voter count limit is less..
+				assert_eq!(
+					Staking::electing_voters(bounds_builder.voters_count(1.into()).build().voters)
+						.unwrap()
+						.len(),
+					1
+				);
+
+				// if voter count limit is equal..
+				assert_eq!(
+					Staking::electing_voters(bounds_builder.voters_count(5.into()).build().voters)
+						.unwrap()
+						.len(),
+					5
+				);
+
+				// if voter count limit is more.
+				assert_eq!(
+					Staking::electing_voters(bounds_builder.voters_count(55.into()).build().voters)
+						.unwrap()
+						.len(),
+					5
+				);
+
+				// if target count limit is more..
+				assert_eq!(
+					Staking::electable_targets(
+						bounds_builder.targets_count(6.into()).build().targets
+					)
+					.unwrap()
+					.len(),
+					4
+				);
+
+				// if target count limit is equal..
+				assert_eq!(
+					Staking::electable_targets(
+						bounds_builder.targets_count(4.into()).build().targets
+					)
+					.unwrap()
+					.len(),
+					4
+				);
+
+				// if target limit count is less, then we return an error.
+				assert_eq!(
+					Staking::electable_targets(
+						bounds_builder.targets_count(1.into()).build().targets
+					)
+					.unwrap_err(),
+					"Target snapshot too big"
+				);
+			});
+	}
+
+	#[test]
+	fn respects_snapshot_size_limits() {
+		ExtBuilder::default().build_and_execute(|| {
+			// voters: set size bounds that allows only for 1 voter.
+			let bounds = ElectionBoundsBuilder::default().voters_size(26.into()).build();
+			let elected = Staking::electing_voters(bounds.voters).unwrap();
+			assert!(elected.encoded_size() == 26 as usize);
+			let prev_len = elected.len();
+
+			// larger size bounds means more quota for voters.
+			let bounds = ElectionBoundsBuilder::default().voters_size(100.into()).build();
+			let elected = Staking::electing_voters(bounds.voters).unwrap();
+			assert!(elected.encoded_size() <= 100 as usize);
+			assert!(elected.len() > 1 && elected.len() > prev_len);
+
+			// targets: set size bounds that allows for only one target to fit in the snapshot.
+			let bounds = ElectionBoundsBuilder::default().targets_size(10.into()).build();
+			let elected = Staking::electable_targets(bounds.targets).unwrap();
+			assert!(elected.encoded_size() == 9 as usize);
+			let prev_len = elected.len();
+
+			// larger size bounds means more space for targets.
+			let bounds = ElectionBoundsBuilder::default().targets_size(100.into()).build();
+			let elected = Staking::electable_targets(bounds.targets).unwrap();
+			assert!(elected.encoded_size() <= 100 as usize);
+			assert!(elected.len() > 1 && elected.len() > prev_len);
+		});
+	}
+
+	#[test]
+	fn nomination_quota_checks_at_nominate_works() {
+		ExtBuilder::default().nominate(false).build_and_execute(|| {
+			// stash bond of 222 has a nomination quota of 2 targets.
+			bond(61, 222);
+			assert_eq!(Staking::api_nominations_quota(222), 2);
+
+			// nominating with targets below the nomination quota works.
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(61), vec![11]));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(61), vec![11, 12]));
+
+			// nominating with targets above the nomination quota returns error.
+			assert_noop!(
+				Staking::nominate(RuntimeOrigin::signed(61), vec![11, 12, 13]),
+				Error::<Test>::TooManyTargets
+			);
+		});
+	}
+
+	#[test]
+	fn lazy_quota_npos_voters_works_above_quota() {
+		ExtBuilder::default()
+			.nominate(false)
+			.add_staker(
+				61,
+				60,
+				300, // 300 bond has 16 nomination quota.
+				StakerStatus::<AccountId>::Nominator(vec![21, 22, 23, 24, 25]),
+			)
+			.build_and_execute(|| {
+				// unbond 78 from stash 60 so that it's bonded balance is 222, which has a lower
+				// nomination quota than at nomination time (max 2 targets).
+				assert_ok!(Staking::unbond(RuntimeOrigin::signed(61), 78));
+				assert_eq!(Staking::api_nominations_quota(300 - 78), 2);
+
+				// even through 61 has nomination quota of 2 at the time of the election, all the
+				// nominations (5) will be used.
+				assert_eq!(
+					Staking::electing_voters(DataProviderBounds::default())
+						.unwrap()
+						.iter()
+						.map(|(stash, _, targets)| (*stash, targets.len()))
+						.collect::<Vec<_>>(),
+					vec![(11, 1), (21, 1), (31, 1), (61, 5)],
+				);
+			});
+	}
+
+	#[test]
+	fn nominations_quota_limits_size_work() {
+		ExtBuilder::default()
+			.nominate(false)
+			.add_staker(
+				71,
+				70,
+				333,
+				StakerStatus::<AccountId>::Nominator(vec![16, 15, 14, 13, 12, 11, 10]),
+			)
+			.build_and_execute(|| {
+				// nominations of controller 70 won't be added due to voter size limit exceeded.
+				let bounds = ElectionBoundsBuilder::default().voters_size(100.into()).build();
+				assert_eq!(
+					Staking::electing_voters(bounds.voters)
+						.unwrap()
+						.iter()
+						.map(|(stash, _, targets)| (*stash, targets.len()))
+						.collect::<Vec<_>>(),
+					vec![(11, 1), (21, 1), (31, 1)],
+				);
+
+				assert_eq!(
+					*staking_events().last().unwrap(),
+					Event::SnapshotVotersSizeExceeded { size: 75 }
+				);
+
+				// however, if the election voter size bounds were largers, the snapshot would
+				// include the electing voters of 70.
+				let bounds = ElectionBoundsBuilder::default().voters_size(1_000.into()).build();
+				assert_eq!(
+					Staking::electing_voters(bounds.voters)
+						.unwrap()
+						.iter()
+						.map(|(stash, _, targets)| (*stash, targets.len()))
+						.collect::<Vec<_>>(),
+					vec![(11, 1), (21, 1), (31, 1), (71, 7)],
+				);
+			});
+	}
+
+	#[test]
+	fn estimate_next_election_works() {
+		ExtBuilder::default().session_per_era(5).period(5).build_and_execute(|| {
+			// first session is always length 0.
+			for b in 1..20 {
+				run_to_block(b);
+				assert_eq!(Staking::next_election_prediction(System::block_number()), 20);
+			}
+
+			// election
+			run_to_block(20);
+			assert_eq!(Staking::next_election_prediction(System::block_number()), 45);
+			assert_eq!(staking_events().len(), 1);
+			assert_eq!(*staking_events().last().unwrap(), Event::StakersElected);
+
+			for b in 21..45 {
+				run_to_block(b);
+				assert_eq!(Staking::next_election_prediction(System::block_number()), 45);
+			}
+
+			// election
+			run_to_block(45);
+			assert_eq!(Staking::next_election_prediction(System::block_number()), 70);
+			assert_eq!(staking_events().len(), 3);
+			assert_eq!(*staking_events().last().unwrap(), Event::StakersElected);
+
+			Staking::force_no_eras(RuntimeOrigin::root()).unwrap();
+			assert_eq!(Staking::next_election_prediction(System::block_number()), u64::MAX);
+
+			Staking::force_new_era_always(RuntimeOrigin::root()).unwrap();
+			assert_eq!(Staking::next_election_prediction(System::block_number()), 45 + 5);
+
+			Staking::force_new_era(RuntimeOrigin::root()).unwrap();
+			assert_eq!(Staking::next_election_prediction(System::block_number()), 45 + 5);
+
+			// Do a fail election
+			MinimumValidatorCount::<Test>::put(1000);
+			run_to_block(50);
+			// Election: failed, next session is a new election
+			assert_eq!(Staking::next_election_prediction(System::block_number()), 50 + 5);
+			// The new era is still forced until a new era is planned.
+			assert_eq!(ForceEra::<Test>::get(), Forcing::ForceNew);
+
+			MinimumValidatorCount::<Test>::put(2);
+			run_to_block(55);
+			assert_eq!(Staking::next_election_prediction(System::block_number()), 55 + 25);
+			assert_eq!(staking_events().len(), 10);
+			assert_eq!(
+				*staking_events().last().unwrap(),
+				Event::ForceEra { mode: Forcing::NotForcing }
+			);
+			assert_eq!(
+				*staking_events().get(staking_events().len() - 2).unwrap(),
+				Event::StakersElected
+			);
+			// The new era has been planned, forcing is changed from `ForceNew` to `NotForcing`.
+			assert_eq!(ForceEra::<Test>::get(), Forcing::NotForcing);
+		})
+	}
+}
+
+#[test]
+#[should_panic]
+fn count_check_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// We should never insert into the validators or nominators map directly as this will
+		// not keep track of the count. This test should panic as we verify the count is accurate
+		// after every test using the `post_checks` in `mock`.
+		Validators::<Test>::insert(987654321, ValidatorPrefs::default());
+		Nominators::<Test>::insert(
+			987654321,
+			Nominations {
+				targets: Default::default(),
+				submitted_in: Default::default(),
+				suppressed: false,
+			},
+		);
+	})
+}
+
+#[test]
+fn min_bond_checks_work() {
+	ExtBuilder::default()
+		.existential_deposit(100)
+		.balance_factor(100)
+		.min_nominator_bond(1_000)
+		.min_validator_bond(1_500)
+		.build_and_execute(|| {
+			// 500 is not enough for any role
+			assert_ok!(Staking::bond(RuntimeOrigin::signed(3), 500, RewardDestination::Controller));
+			assert_noop!(
+				Staking::nominate(RuntimeOrigin::signed(3), vec![1]),
+				Error::<Test>::InsufficientBond
+			);
+			assert_noop!(
+				Staking::validate(RuntimeOrigin::signed(3), ValidatorPrefs::default()),
+				Error::<Test>::InsufficientBond,
+			);
+
+			// 1000 is enough for nominator
+			assert_ok!(Staking::bond_extra(RuntimeOrigin::signed(3), 500));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(3), vec![1]));
+			assert_noop!(
+				Staking::validate(RuntimeOrigin::signed(3), ValidatorPrefs::default()),
+				Error::<Test>::InsufficientBond,
+			);
+
+			// 1500 is enough for validator
+			assert_ok!(Staking::bond_extra(RuntimeOrigin::signed(3), 500));
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(3), vec![1]));
+			assert_ok!(Staking::validate(RuntimeOrigin::signed(3), ValidatorPrefs::default()));
+
+			// Can't unbond anything as validator
+			assert_noop!(
+				Staking::unbond(RuntimeOrigin::signed(3), 500),
+				Error::<Test>::InsufficientBond
+			);
+
+			// Once they are a nominator, they can unbond 500
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(3), vec![1]));
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(3), 500));
+			assert_noop!(
+				Staking::unbond(RuntimeOrigin::signed(3), 500),
+				Error::<Test>::InsufficientBond
+			);
+
+			// Once they are chilled they can unbond everything
+			assert_ok!(Staking::chill(RuntimeOrigin::signed(3)));
+			assert_ok!(Staking::unbond(RuntimeOrigin::signed(3), 1000));
+		})
+}
+
+#[test]
+fn chill_other_works() {
+	ExtBuilder::default()
+		.existential_deposit(100)
+		.balance_factor(100)
+		.min_nominator_bond(1_000)
+		.min_validator_bond(1_500)
+		.build_and_execute(|| {
+			let initial_validators = Validators::<Test>::count();
+			let initial_nominators = Nominators::<Test>::count();
+			for i in 0..15 {
+				let a = 4 * i;
+				let b = 4 * i + 2;
+				let c = 4 * i + 3;
+				Balances::make_free_balance_be(&a, 100_000);
+				Balances::make_free_balance_be(&b, 100_000);
+				Balances::make_free_balance_be(&c, 100_000);
+
+				// Nominator
+				assert_ok!(Staking::bond(
+					RuntimeOrigin::signed(a),
+					1000,
+					RewardDestination::Controller
+				));
+				assert_ok!(Staking::nominate(RuntimeOrigin::signed(a), vec![1]));
+
+				// Validator
+				assert_ok!(Staking::bond(
+					RuntimeOrigin::signed(b),
+					1500,
+					RewardDestination::Controller
+				));
+				assert_ok!(Staking::validate(RuntimeOrigin::signed(b), ValidatorPrefs::default()));
+			}
+
+			// To chill other users, we need to:
+			// * Set a minimum bond amount
+			// * Set a limit
+			// * Set a threshold
+			//
+			// If any of these are missing, we do not have enough information to allow the
+			// `chill_other` to succeed from one user to another.
+
+			// Can't chill these users
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 0),
+				Error::<Test>::CannotChillOther
+			);
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 2),
+				Error::<Test>::CannotChillOther
+			);
+
+			// Change the minimum bond... but no limits.
+			assert_ok!(Staking::set_staking_configs(
+				RuntimeOrigin::root(),
+				ConfigOp::Set(1_500),
+				ConfigOp::Set(2_000),
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+				ConfigOp::Remove
+			));
+
+			// Still can't chill these users
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 0),
+				Error::<Test>::CannotChillOther
+			);
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 2),
+				Error::<Test>::CannotChillOther
+			);
+
+			// Add limits, but no threshold
+			assert_ok!(Staking::set_staking_configs(
+				RuntimeOrigin::root(),
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+				ConfigOp::Set(10),
+				ConfigOp::Set(10),
+				ConfigOp::Noop,
+				ConfigOp::Noop
+			));
+
+			// Still can't chill these users
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 0),
+				Error::<Test>::CannotChillOther
+			);
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 2),
+				Error::<Test>::CannotChillOther
+			);
+
+			// Add threshold, but no limits
+			assert_ok!(Staking::set_staking_configs(
+				RuntimeOrigin::root(),
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+				ConfigOp::Remove,
+				ConfigOp::Remove,
+				ConfigOp::Noop,
+				ConfigOp::Noop
+			));
+
+			// Still can't chill these users
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 0),
+				Error::<Test>::CannotChillOther
+			);
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 2),
+				Error::<Test>::CannotChillOther
+			);
+
+			// Add threshold and limits
+			assert_ok!(Staking::set_staking_configs(
+				RuntimeOrigin::root(),
+				ConfigOp::Noop,
+				ConfigOp::Noop,
+				ConfigOp::Set(10),
+				ConfigOp::Set(10),
+				ConfigOp::Set(Percent::from_percent(75)),
+				ConfigOp::Noop
+			));
+
+			// 16 people total because tests start with 2 active one
+			assert_eq!(Nominators::<Test>::count(), 15 + initial_nominators);
+			assert_eq!(Validators::<Test>::count(), 15 + initial_validators);
+
+			// Users can now be chilled down to 7 people, so we try to remove 9 of them (starting
+			// with 16)
+			for i in 6..15 {
+				let b = 4 * i;
+				let d = 4 * i + 2;
+				assert_ok!(Staking::chill_other(RuntimeOrigin::signed(1337), b));
+				assert_ok!(Staking::chill_other(RuntimeOrigin::signed(1337), d));
+			}
+
+			// chill a nominator. Limit is not reached, not chill-able
+			assert_eq!(Nominators::<Test>::count(), 7);
+			assert_noop!(
+				Staking::chill_other(RuntimeOrigin::signed(1337), 0),
+				Error::<Test>::CannotChillOther
+			);
+			// chill a validator. Limit is reached, chill-able.
+			assert_eq!(Validators::<Test>::count(), 9);
+			assert_ok!(Staking::chill_other(RuntimeOrigin::signed(1337), 2));
+		})
+}
+
+#[test]
+fn capped_stakers_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		let validator_count = Validators::<Test>::count();
+		assert_eq!(validator_count, 3);
+		let nominator_count = Nominators::<Test>::count();
+		assert_eq!(nominator_count, 1);
+
+		// Change the maximums
+		let max = 10;
+		assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			ConfigOp::Set(10),
+			ConfigOp::Set(10),
+			ConfigOp::Set(max),
+			ConfigOp::Set(max),
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+		));
+
+		// can create `max - validator_count` validators
+		let mut some_existing_validator = AccountId::default();
+		for i in 0..max - validator_count {
+			let (_, controller) = testing_utils::create_stash_controller::<Test>(
+				i + 10_000_000,
+				100,
+				RewardDestination::Controller,
+			)
+			.unwrap();
+			assert_ok!(Staking::validate(
+				RuntimeOrigin::signed(controller),
+				ValidatorPrefs::default()
+			));
+			some_existing_validator = controller;
+		}
+
+		// but no more
+		let (_, last_validator) = testing_utils::create_stash_controller::<Test>(
+			1337,
+			100,
+			RewardDestination::Controller,
+		)
+		.unwrap();
+
+		assert_noop!(
+			Staking::validate(RuntimeOrigin::signed(last_validator), ValidatorPrefs::default()),
+			Error::<Test>::TooManyValidators,
+		);
+
+		// same with nominators
+		let mut some_existing_nominator = AccountId::default();
+		for i in 0..max - nominator_count {
+			let (_, controller) = testing_utils::create_stash_controller::<Test>(
+				i + 20_000_000,
+				100,
+				RewardDestination::Controller,
+			)
+			.unwrap();
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(controller), vec![1]));
+			some_existing_nominator = controller;
+		}
+
+		// one more is too many.
+		let (_, last_nominator) = testing_utils::create_stash_controller::<Test>(
+			30_000_000,
+			100,
+			RewardDestination::Controller,
+		)
+		.unwrap();
+		assert_noop!(
+			Staking::nominate(RuntimeOrigin::signed(last_nominator), vec![1]),
+			Error::<Test>::TooManyNominators
+		);
+
+		// Re-nominate works fine
+		assert_ok!(Staking::nominate(RuntimeOrigin::signed(some_existing_nominator), vec![1]));
+		// Re-validate works fine
+		assert_ok!(Staking::validate(
+			RuntimeOrigin::signed(some_existing_validator),
+			ValidatorPrefs::default()
+		));
+
+		// No problem when we set to `None` again
+		assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			ConfigOp::Noop,
+			ConfigOp::Noop,
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Noop,
+			ConfigOp::Noop,
+		));
+		assert_ok!(Staking::nominate(RuntimeOrigin::signed(last_nominator), vec![1]));
+		assert_ok!(Staking::validate(
+			RuntimeOrigin::signed(last_validator),
+			ValidatorPrefs::default()
+		));
+	})
+}
+
+#[test]
+fn min_commission_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		// account 11 controls the stash of itself.
+		assert_ok!(Staking::validate(
+			RuntimeOrigin::signed(11),
+			ValidatorPrefs { commission: Perbill::from_percent(5), blocked: false }
+		));
+
+		// event emitted should be correct
+		assert_eq!(
+			*staking_events().last().unwrap(),
+			Event::ValidatorPrefsSet {
+				stash: 11,
+				prefs: ValidatorPrefs { commission: Perbill::from_percent(5), blocked: false }
+			}
+		);
+
+		assert_ok!(Staking::set_staking_configs(
+			RuntimeOrigin::root(),
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Remove,
+			ConfigOp::Set(Perbill::from_percent(10)),
+		));
+
+		// can't make it less than 10 now
+		assert_noop!(
+			Staking::validate(
+				RuntimeOrigin::signed(11),
+				ValidatorPrefs { commission: Perbill::from_percent(5), blocked: false }
+			),
+			Error::<Test>::CommissionTooLow
+		);
+
+		// can only change to higher.
+		assert_ok!(Staking::validate(
+			RuntimeOrigin::signed(11),
+			ValidatorPrefs { commission: Perbill::from_percent(10), blocked: false }
+		));
+
+		assert_ok!(Staking::validate(
+			RuntimeOrigin::signed(11),
+			ValidatorPrefs { commission: Perbill::from_percent(15), blocked: false }
+		));
+	})
+}
+
+#[test]
+#[should_panic]
+fn change_of_absolute_max_nominations() {
+	use frame_election_provider_support::ElectionDataProvider;
+	ExtBuilder::default()
+		.add_staker(61, 61, 10, StakerStatus::Nominator(vec![1]))
+		.add_staker(71, 71, 10, StakerStatus::Nominator(vec![1, 2, 3]))
+		.balance_factor(10)
+		.build_and_execute(|| {
+			// pre-condition
+			assert_eq!(AbsoluteMaxNominations::get(), 16);
+
+			assert_eq!(
+				Nominators::<Test>::iter()
+					.map(|(k, n)| (k, n.targets.len()))
+					.collect::<Vec<_>>(),
+				vec![(101, 2), (71, 3), (61, 1)]
+			);
+
+			// default bounds are unbounded.
+			let bounds = DataProviderBounds::default();
+
+			// 3 validators and 3 nominators
+			assert_eq!(Staking::electing_voters(bounds).unwrap().len(), 3 + 3);
+
+			// abrupt change from 16 to 4, everyone should be fine.
+			AbsoluteMaxNominations::set(4);
+
+			assert_eq!(
+				Nominators::<Test>::iter()
+					.map(|(k, n)| (k, n.targets.len()))
+					.collect::<Vec<_>>(),
+				vec![(101, 2), (71, 3), (61, 1)]
+			);
+			assert_eq!(Staking::electing_voters(bounds).unwrap().len(), 3 + 3);
+
+			// abrupt change from 4 to 3, everyone should be fine.
+			AbsoluteMaxNominations::set(3);
+
+			assert_eq!(
+				Nominators::<Test>::iter()
+					.map(|(k, n)| (k, n.targets.len()))
+					.collect::<Vec<_>>(),
+				vec![(101, 2), (71, 3), (61, 1)]
+			);
+			assert_eq!(Staking::electing_voters(bounds).unwrap().len(), 3 + 3);
+
+			// abrupt change from 3 to 2, this should cause some nominators to be non-decodable, and
+			// thus non-existent unless if they update.
+			AbsoluteMaxNominations::set(2);
+
+			assert_eq!(
+				Nominators::<Test>::iter()
+					.map(|(k, n)| (k, n.targets.len()))
+					.collect::<Vec<_>>(),
+				vec![(101, 2), (61, 1)]
+			);
+			// 70 is still in storage..
+			assert!(Nominators::<Test>::contains_key(71));
+			// but its value cannot be decoded and default is returned.
+			assert!(Nominators::<Test>::get(71).is_none());
+
+			assert_eq!(Staking::electing_voters(bounds).unwrap().len(), 3 + 2);
+			assert!(Nominators::<Test>::contains_key(101));
+
+			// abrupt change from 2 to 1, this should cause some nominators to be non-decodable, and
+			// thus non-existent unless if they update.
+			AbsoluteMaxNominations::set(1);
+
+			assert_eq!(
+				Nominators::<Test>::iter()
+					.map(|(k, n)| (k, n.targets.len()))
+					.collect::<Vec<_>>(),
+				vec![(61, 1)]
+			);
+			assert!(Nominators::<Test>::contains_key(71));
+			assert!(Nominators::<Test>::contains_key(61));
+			assert!(Nominators::<Test>::get(71).is_none());
+			assert!(Nominators::<Test>::get(61).is_some());
+			assert_eq!(Staking::electing_voters(bounds).unwrap().len(), 3 + 1);
+
+			// now one of them can revive themselves by re-nominating to a proper value.
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(71), vec![1]));
+			assert_eq!(
+				Nominators::<Test>::iter()
+					.map(|(k, n)| (k, n.targets.len()))
+					.collect::<Vec<_>>(),
+				vec![(71, 1), (61, 1)]
+			);
+
+			// or they can be chilled by any account.
+			assert!(Nominators::<Test>::contains_key(101));
+			assert!(Nominators::<Test>::get(101).is_none());
+			assert_ok!(Staking::chill_other(RuntimeOrigin::signed(71), 101));
+			assert!(!Nominators::<Test>::contains_key(101));
+			assert!(Nominators::<Test>::get(101).is_none());
+		})
+}
+
+#[test]
+fn nomination_quota_max_changes_decoding() {
+	use frame_election_provider_support::ElectionDataProvider;
+	ExtBuilder::default()
+		.add_staker(60, 61, 10, StakerStatus::Nominator(vec![1]))
+		.add_staker(70, 71, 10, StakerStatus::Nominator(vec![1, 2, 3]))
+		.add_staker(30, 330, 10, StakerStatus::Nominator(vec![1, 2, 3, 4]))
+		.add_staker(50, 550, 10, StakerStatus::Nominator(vec![1, 2, 3, 4]))
+		.balance_factor(10)
+		.build_and_execute(|| {
+			// pre-condition.
+			assert_eq!(MaxNominationsOf::<Test>::get(), 16);
+
+			let unbonded_election = DataProviderBounds::default();
+
+			assert_eq!(
+				Nominators::<Test>::iter()
+					.map(|(k, n)| (k, n.targets.len()))
+					.collect::<Vec<_>>(),
+				vec![(70, 3), (101, 2), (50, 4), (30, 4), (60, 1)]
+			);
+			// 4 validators and 4 nominators
+			assert_eq!(Staking::electing_voters(unbonded_election).unwrap().len(), 4 + 4);
+		});
+}
+
+#[test]
+fn api_nominations_quota_works() {
+	ExtBuilder::default().build_and_execute(|| {
+		assert_eq!(Staking::api_nominations_quota(10), MaxNominationsOf::<Test>::get());
+		assert_eq!(Staking::api_nominations_quota(333), MaxNominationsOf::<Test>::get());
+		assert_eq!(Staking::api_nominations_quota(222), 2);
+		assert_eq!(Staking::api_nominations_quota(111), 1);
+	})
+}
+
+mod sorted_list_provider {
+	use super::*;
+	use frame_election_provider_support::SortedListProvider;
+
+	#[test]
+	fn re_nominate_does_not_change_counters_or_list() {
+		ExtBuilder::default().nominate(true).build_and_execute(|| {
+			// given
+			let pre_insert_voter_count =
+				(Nominators::<Test>::count() + Validators::<Test>::count()) as u32;
+			assert_eq!(<Test as Config>::VoterList::count(), pre_insert_voter_count);
+
+			assert_eq!(
+				<Test as Config>::VoterList::iter().collect::<Vec<_>>(),
+				vec![11, 21, 31, 101]
+			);
+
+			// when account 101 renominates
+			assert_ok!(Staking::nominate(RuntimeOrigin::signed(101), vec![41]));
+
+			// then counts don't change
+			assert_eq!(<Test as Config>::VoterList::count(), pre_insert_voter_count);
+			// and the list is the same
+			assert_eq!(
+				<Test as Config>::VoterList::iter().collect::<Vec<_>>(),
+				vec![11, 21, 31, 101]
+			);
+		});
+	}
+
+	#[test]
+	fn re_validate_does_not_change_counters_or_list() {
+		ExtBuilder::default().nominate(false).build_and_execute(|| {
+			// given
+			let pre_insert_voter_count =
+				(Nominators::<Test>::count() + Validators::<Test>::count()) as u32;
+			assert_eq!(<Test as Config>::VoterList::count(), pre_insert_voter_count);
+
+			assert_eq!(<Test as Config>::VoterList::iter().collect::<Vec<_>>(), vec![11, 21, 31]);
+
+			// when account 11 re-validates
+			assert_ok!(Staking::validate(RuntimeOrigin::signed(11), Default::default()));
+
+			// then counts don't change
+			assert_eq!(<Test as Config>::VoterList::count(), pre_insert_voter_count);
+			// and the list is the same
+			assert_eq!(<Test as Config>::VoterList::iter().collect::<Vec<_>>(), vec![11, 21, 31]);
+		});
+	}
+}
+
+#[test]
+fn force_apply_min_commission_works() {
+	let prefs = |c| ValidatorPrefs { commission: Perbill::from_percent(c), blocked: false };
+	let validators = || Validators::<Test>::iter().collect::<Vec<_>>();
+	ExtBuilder::default().build_and_execute(|| {
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(31), prefs(10)));
+		assert_ok!(Staking::validate(RuntimeOrigin::signed(21), prefs(5)));
+
+		// Given
+		assert_eq!(validators(), vec![(31, prefs(10)), (21, prefs(5)), (11, prefs(0))]);
+		MinCommission::<Test>::set(Perbill::from_percent(5));
+
+		// When applying to a commission greater than min
+		assert_ok!(Staking::force_apply_min_commission(RuntimeOrigin::signed(1), 31));
+		// Then the commission is not changed
+		assert_eq!(validators(), vec![(31, prefs(10)), (21, prefs(5)), (11, prefs(0))]);
+
+		// When applying to a commission that is equal to min
+		assert_ok!(Staking::force_apply_min_commission(RuntimeOrigin::signed(1), 21));
+		// Then the commission is not changed
+		assert_eq!(validators(), vec![(31, prefs(10)), (21, prefs(5)), (11, prefs(0))]);
+
+		// When applying to a commission that is less than the min
+		assert_ok!(Staking::force_apply_min_commission(RuntimeOrigin::signed(1), 11));
+		// Then the commission is bumped to the min
+		assert_eq!(validators(), vec![(31, prefs(10)), (21, prefs(5)), (11, prefs(5))]);
+
+		// When applying commission to a validator that doesn't exist then storage is not altered
+		assert_noop!(
+			Staking::force_apply_min_commission(RuntimeOrigin::signed(1), 420),
+			Error::<Test>::NotStash
+		);
+	});
+}
+
+#[test]
+fn proportional_slash_stop_slashing_if_remaining_zero() {
+	let c = |era, value| UnlockChunk::<Balance> { era, value };
+	// Given
+	let mut ledger = StakingLedger::<Test> {
+		stash: 123,
+		total: 40,
+		active: 20,
+		// we have some chunks, but they are not affected.
+		unlocking: bounded_vec![c(1, 10), c(2, 10)],
+		claimed_rewards: bounded_vec![],
+	};
+
+	assert_eq!(BondingDuration::get(), 3);
+
+	// should not slash more than the amount requested, by accidentally slashing the first chunk.
+	assert_eq!(ledger.slash(18, 1, 0), 18);
+}
+
+#[test]
+fn proportional_ledger_slash_works() {
+	let c = |era, value| UnlockChunk::<Balance> { era, value };
+	// Given
+	let mut ledger = StakingLedger::<Test> {
+		stash: 123,
+		total: 10,
+		active: 10,
+		unlocking: bounded_vec![],
+		claimed_rewards: bounded_vec![],
+	};
+	assert_eq!(BondingDuration::get(), 3);
+
+	// When we slash a ledger with no unlocking chunks
+	assert_eq!(ledger.slash(5, 1, 0), 5);
+	// Then
+	assert_eq!(ledger.total, 5);
+	assert_eq!(ledger.active, 5);
+	assert_eq!(LedgerSlashPerEra::get().0, 5);
+	assert_eq!(LedgerSlashPerEra::get().1, Default::default());
+
+	// When we slash a ledger with no unlocking chunks and the slash amount is greater then the
+	// total
+	assert_eq!(ledger.slash(11, 1, 0), 5);
+	// Then
+	assert_eq!(ledger.total, 0);
+	assert_eq!(ledger.active, 0);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(LedgerSlashPerEra::get().1, Default::default());
+
+	// Given
+	ledger.unlocking = bounded_vec![c(4, 10), c(5, 10)];
+	ledger.total = 2 * 10;
+	ledger.active = 0;
+	// When all the chunks overlap with the slash eras
+	assert_eq!(ledger.slash(20, 0, 0), 20);
+	// Then
+	assert_eq!(ledger.unlocking, vec![]);
+	assert_eq!(ledger.total, 0);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(LedgerSlashPerEra::get().1, BTreeMap::from([(4, 0), (5, 0)]));
+
+	// Given
+	ledger.unlocking = bounded_vec![c(4, 100), c(5, 100), c(6, 100), c(7, 100)];
+	ledger.total = 4 * 100;
+	ledger.active = 0;
+	// When the first 2 chunks don't overlap with the affected range of unlock eras.
+	assert_eq!(ledger.slash(140, 0, 3), 140);
+	// Then
+	assert_eq!(ledger.unlocking, vec![c(4, 100), c(5, 100), c(6, 30), c(7, 30)]);
+	assert_eq!(ledger.total, 4 * 100 - 140);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(LedgerSlashPerEra::get().1, BTreeMap::from([(6, 30), (7, 30)]));
+
+	// Given
+	ledger.unlocking = bounded_vec![c(4, 100), c(5, 100), c(6, 100), c(7, 100)];
+	ledger.total = 4 * 100;
+	ledger.active = 0;
+	// When the first 2 chunks don't overlap with the affected range of unlock eras.
+	assert_eq!(ledger.slash(15, 0, 3), 15);
+	// Then
+	assert_eq!(ledger.unlocking, vec![c(4, 100), c(5, 100), c(6, 100 - 8), c(7, 100 - 7)]);
+	assert_eq!(ledger.total, 4 * 100 - 15);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(LedgerSlashPerEra::get().1, BTreeMap::from([(6, 92), (7, 93)]));
+
+	// Given
+	ledger.unlocking = bounded_vec![c(4, 40), c(5, 100), c(6, 10), c(7, 250)];
+	ledger.active = 500;
+	// 900
+	ledger.total = 40 + 10 + 100 + 250 + 500;
+	// When we have a partial slash that touches all chunks
+	assert_eq!(ledger.slash(900 / 2, 0, 0), 450);
+	// Then
+	assert_eq!(ledger.active, 500 / 2);
+	assert_eq!(ledger.unlocking, vec![c(4, 40 / 2), c(5, 100 / 2), c(6, 10 / 2), c(7, 250 / 2)]);
+	assert_eq!(ledger.total, 900 / 2);
+	assert_eq!(LedgerSlashPerEra::get().0, 500 / 2);
+	assert_eq!(
+		LedgerSlashPerEra::get().1,
+		BTreeMap::from([(4, 40 / 2), (5, 100 / 2), (6, 10 / 2), (7, 250 / 2)])
+	);
+
+	// slash 1/4th with not chunk.
+	ledger.unlocking = bounded_vec![];
+	ledger.active = 500;
+	ledger.total = 500;
+	// When we have a partial slash that touches all chunks
+	assert_eq!(ledger.slash(500 / 4, 0, 0), 500 / 4);
+	// Then
+	assert_eq!(ledger.active, 3 * 500 / 4);
+	assert_eq!(ledger.unlocking, vec![]);
+	assert_eq!(ledger.total, ledger.active);
+	assert_eq!(LedgerSlashPerEra::get().0, 3 * 500 / 4);
+	assert_eq!(LedgerSlashPerEra::get().1, Default::default());
+
+	// Given we have the same as above,
+	ledger.unlocking = bounded_vec![c(4, 40), c(5, 100), c(6, 10), c(7, 250)];
+	ledger.active = 500;
+	ledger.total = 40 + 10 + 100 + 250 + 500; // 900
+	assert_eq!(ledger.total, 900);
+	// When we have a higher min balance
+	assert_eq!(
+		ledger.slash(
+			900 / 2,
+			25, /* min balance - chunks with era 0 & 2 will be slashed to <=25, causing it to
+			     * get swept */
+			0
+		),
+		450
+	);
+	assert_eq!(ledger.active, 500 / 2);
+	// the last chunk was not slashed 50% like all the rest, because some other earlier chunks got
+	// dusted.
+	assert_eq!(ledger.unlocking, vec![c(5, 100 / 2), c(7, 150)]);
+	assert_eq!(ledger.total, 900 / 2);
+	assert_eq!(LedgerSlashPerEra::get().0, 500 / 2);
+	assert_eq!(
+		LedgerSlashPerEra::get().1,
+		BTreeMap::from([(4, 0), (5, 100 / 2), (6, 0), (7, 150)])
+	);
+
+	// Given
+	// slash order --------------------NA--------2----------0----------1----
+	ledger.unlocking = bounded_vec![c(4, 40), c(5, 100), c(6, 10), c(7, 250)];
+	ledger.active = 500;
+	ledger.total = 40 + 10 + 100 + 250 + 500; // 900
+	assert_eq!(
+		ledger.slash(
+			500 + 10 + 250 + 100 / 2, // active + era 6 + era 7 + era 5 / 2
+			0,
+			3 /* slash era 6 first, so the affected parts are era 6, era 7 and
+			   * ledge.active. This will cause the affected to go to zero, and then we will
+			   * start slashing older chunks */
+		),
+		500 + 250 + 10 + 100 / 2
+	);
+	// Then
+	assert_eq!(ledger.active, 0);
+	assert_eq!(ledger.unlocking, vec![c(4, 40), c(5, 100 / 2)]);
+	assert_eq!(ledger.total, 90);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(LedgerSlashPerEra::get().1, BTreeMap::from([(5, 100 / 2), (6, 0), (7, 0)]));
+
+	// Given
+	// iteration order------------------NA---------2----------0----------1----
+	ledger.unlocking = bounded_vec![c(4, 100), c(5, 100), c(6, 100), c(7, 100)];
+	ledger.active = 100;
+	ledger.total = 5 * 100;
+	// When
+	assert_eq!(
+		ledger.slash(
+			351, // active + era 6 + era 7 + era 5 / 2 + 1
+			50,  // min balance - everything slashed below 50 will get dusted
+			3    /* slash era 3+3 first, so the affected parts are era 6, era 7 and
+			      * ledge.active. This will cause the affected to go to zero, and then we will
+			      * start slashing older chunks */
+		),
+		400
+	);
+	// Then
+	assert_eq!(ledger.active, 0);
+	assert_eq!(ledger.unlocking, vec![c(4, 100)]);
+	assert_eq!(ledger.total, 100);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(LedgerSlashPerEra::get().1, BTreeMap::from([(5, 0), (6, 0), (7, 0)]));
+
+	// Tests for saturating arithmetic
+
+	// Given
+	let slash = u64::MAX as Balance * 2;
+	// The value of the other parts of ledger that will get slashed
+	let value = slash - (10 * 4);
+
+	ledger.active = 10;
+	ledger.unlocking = bounded_vec![c(4, 10), c(5, 10), c(6, 10), c(7, value)];
+	ledger.total = value + 40;
+	// When
+	let slash_amount = ledger.slash(slash, 0, 0);
+	assert_eq_error_rate!(slash_amount, slash, 5);
+	// Then
+	assert_eq!(ledger.active, 0); // slash of 9
+	assert_eq!(ledger.unlocking, vec![]);
+	assert_eq!(ledger.total, 0);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(LedgerSlashPerEra::get().1, BTreeMap::from([(4, 0), (5, 0), (6, 0), (7, 0)]));
+
+	// Given
+	use sp_runtime::PerThing as _;
+	let slash = u64::MAX as Balance * 2;
+	let value = u64::MAX as Balance * 2;
+	let unit = 100;
+	// slash * value that will saturate
+	assert!(slash.checked_mul(value).is_none());
+	// but slash * unit won't.
+	assert!(slash.checked_mul(unit).is_some());
+	ledger.unlocking = bounded_vec![c(4, unit), c(5, value), c(6, unit), c(7, unit)];
+	//--------------------------------------note value^^^
+	ledger.active = unit;
+	ledger.total = unit * 4 + value;
+	// When
+	assert_eq!(ledger.slash(slash, 0, 0), slash);
+	// Then
+	// The amount slashed out of `unit`
+	let affected_balance = value + unit * 4;
+	let ratio =
+		Perquintill::from_rational_with_rounding(slash, affected_balance, Rounding::Up).unwrap();
+	// `unit` after the slash is applied
+	let unit_slashed = {
+		let unit_slash = ratio.mul_ceil(unit);
+		unit - unit_slash
+	};
+	let value_slashed = {
+		let value_slash = ratio.mul_ceil(value);
+		value - value_slash
+	};
+	assert_eq!(ledger.active, unit_slashed);
+	assert_eq!(ledger.unlocking, vec![c(5, value_slashed), c(7, 32)]);
+	assert_eq!(ledger.total, value_slashed + 32);
+	assert_eq!(LedgerSlashPerEra::get().0, 0);
+	assert_eq!(
+		LedgerSlashPerEra::get().1,
+		BTreeMap::from([(4, 0), (5, value_slashed), (6, 0), (7, 32)])
+	);
+}
+
+#[test]
+fn pre_bonding_era_cannot_be_claimed() {
+	// Verifies initial conditions of mock
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		let history_depth = HistoryDepth::get();
+		// jump to some era above history_depth
+		let mut current_era = history_depth + 10;
+		let last_reward_era = current_era - 1;
+		let start_reward_era = current_era - history_depth;
+
+		// put some money in stash=3 and controller=4.
+		for i in 3..5 {
+			let _ = Balances::make_free_balance_be(&i, 2000);
+		}
+
+		mock::start_active_era(current_era);
+
+		// add a new candidate for being a validator. account 3 controlled by 4.
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(3), 1500, RewardDestination::Controller));
+
+		let claimed_rewards: BoundedVec<_, _> =
+			(start_reward_era..=last_reward_era).collect::<Vec<_>>().try_into().unwrap();
+		assert_eq!(
+			Staking::ledger(&3).unwrap(),
+			StakingLedger {
+				stash: 3,
+				total: 1500,
+				active: 1500,
+				unlocking: Default::default(),
+				claimed_rewards,
+			}
+		);
+
+		// start next era
+		current_era = current_era + 1;
+		mock::start_active_era(current_era);
+
+		// claiming reward for last era in which validator was active works
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(3), 3, current_era - 1));
+
+		// consumed weight for all payout_stakers dispatches that fail
+		let err_weight = <Test as Config>::WeightInfo::payout_stakers_alive_staked(0);
+		// cannot claim rewards for an era before bonding occured as it is
+		// already marked as claimed.
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(3), 3, current_era - 2),
+			Error::<Test>::AlreadyClaimed.with_weight(err_weight)
+		);
+
+		// decoding will fail now since Staking Ledger is in corrupt state
+		HistoryDepth::set(history_depth - 1);
+		assert_eq!(Staking::ledger(&4), None);
+
+		// make sure stakers still cannot claim rewards that they are not meant to
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(3), 3, current_era - 2),
+			Error::<Test>::NotController
+		);
+
+		// fix the corrupted state for post conditions check
+		HistoryDepth::set(history_depth);
+	});
+}
+
+#[test]
+fn reducing_history_depth_abrupt() {
+	// Verifies initial conditions of mock
+	ExtBuilder::default().nominate(false).build_and_execute(|| {
+		let original_history_depth = HistoryDepth::get();
+		let mut current_era = original_history_depth + 10;
+		let last_reward_era = current_era - 1;
+		let start_reward_era = current_era - original_history_depth;
+
+		// put some money in (stash, controller)=(3,3),(5,5).
+		for i in 3..7 {
+			let _ = Balances::make_free_balance_be(&i, 2000);
+		}
+
+		// start current era
+		mock::start_active_era(current_era);
+
+		// add a new candidate for being a staker. account 3 controlled by 3.
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(3), 1500, RewardDestination::Controller));
+
+		// all previous era before the bonding action should be marked as
+		// claimed.
+		let claimed_rewards: BoundedVec<_, _> =
+			(start_reward_era..=last_reward_era).collect::<Vec<_>>().try_into().unwrap();
+		assert_eq!(
+			Staking::ledger(&3).unwrap(),
+			StakingLedger {
+				stash: 3,
+				total: 1500,
+				active: 1500,
+				unlocking: Default::default(),
+				claimed_rewards,
+			}
+		);
+
+		// next era
+		current_era = current_era + 1;
+		mock::start_active_era(current_era);
+
+		// claiming reward for last era in which validator was active works
+		assert_ok!(Staking::payout_stakers(RuntimeOrigin::signed(3), 3, current_era - 1));
+
+		// next era
+		current_era = current_era + 1;
+		mock::start_active_era(current_era);
+
+		// history_depth reduced without migration
+		let history_depth = original_history_depth - 1;
+		HistoryDepth::set(history_depth);
+		// claiming reward does not work anymore
+		assert_noop!(
+			Staking::payout_stakers(RuntimeOrigin::signed(3), 3, current_era - 1),
+			Error::<Test>::NotController
+		);
+
+		// new stakers can still bond
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(5), 1200, RewardDestination::Controller));
+
+		// new staking ledgers created will be bounded by the current history depth
+		let last_reward_era = current_era - 1;
+		let start_reward_era = current_era - history_depth;
+		let claimed_rewards: BoundedVec<_, _> =
+			(start_reward_era..=last_reward_era).collect::<Vec<_>>().try_into().unwrap();
+		assert_eq!(
+			Staking::ledger(&5).unwrap(),
+			StakingLedger {
+				stash: 5,
+				total: 1200,
+				active: 1200,
+				unlocking: Default::default(),
+				claimed_rewards,
+			}
+		);
+
+		// fix the corrupted state for post conditions check
+		HistoryDepth::set(original_history_depth);
+	});
+}
+
+#[test]
+fn reducing_max_unlocking_chunks_abrupt() {
+	// Concern is on validators only
+	// By Default 11, 10 are stash and ctrl and 21,20
+	ExtBuilder::default().build_and_execute(|| {
+		// given a staker at era=10 and MaxUnlockChunks set to 2
+		MaxUnlockingChunks::set(2);
+		start_active_era(10);
+		assert_ok!(Staking::bond(RuntimeOrigin::signed(3), 300, RewardDestination::Staked));
+		assert!(matches!(Staking::ledger(3), Some(_)));
+
+		// when staker unbonds
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(3), 20));
+
+		// then an unlocking chunk is added at `current_era + bonding_duration`
+		// => 10 + 3 = 13
+		let expected_unlocking: BoundedVec<UnlockChunk<Balance>, MaxUnlockingChunks> =
+			bounded_vec![UnlockChunk { value: 20 as Balance, era: 13 as EraIndex }];
+		assert!(matches!(Staking::ledger(3),
+			Some(StakingLedger {
+				unlocking,
+				..
+			}) if unlocking==expected_unlocking));
+
+		// when staker unbonds at next era
+		start_active_era(11);
+		assert_ok!(Staking::unbond(RuntimeOrigin::signed(3), 50));
+		// then another unlock chunk is added
+		let expected_unlocking: BoundedVec<UnlockChunk<Balance>, MaxUnlockingChunks> =
+			bounded_vec![UnlockChunk { value: 20, era: 13 }, UnlockChunk { value: 50, era: 14 }];
+		assert!(matches!(Staking::ledger(3),
+			Some(StakingLedger {
+				unlocking,
+				..
+			}) if unlocking==expected_unlocking));
+
+		// when staker unbonds further
+		start_active_era(12);
+		// then further unbonding not possible
+		assert_noop!(Staking::unbond(RuntimeOrigin::signed(3), 20), Error::<Test>::NoMoreChunks);
+
+		// when max unlocking chunks is reduced abruptly to a low value
+		MaxUnlockingChunks::set(1);
+		// then unbond, rebond ops are blocked with ledger in corrupt state
+		assert_noop!(Staking::unbond(RuntimeOrigin::signed(3), 20), Error::<Test>::NotController);
+		assert_noop!(Staking::rebond(RuntimeOrigin::signed(3), 100), Error::<Test>::NotController);
+
+		// reset the ledger corruption
+		MaxUnlockingChunks::set(2);
+	})
+}
+
+#[test]
+fn cannot_set_unsupported_validator_count() {
+	ExtBuilder::default().build_and_execute(|| {
+		MaxWinners::set(50);
+		// set validator count works
+		assert_ok!(Staking::set_validator_count(RuntimeOrigin::root(), 30));
+		assert_ok!(Staking::set_validator_count(RuntimeOrigin::root(), 50));
+		// setting validator count above 100 does not work
+		assert_noop!(
+			Staking::set_validator_count(RuntimeOrigin::root(), 51),
+			Error::<Test>::TooManyValidators,
+		);
+	})
+}
+
+#[test]
+fn increase_validator_count_errors() {
+	ExtBuilder::default().build_and_execute(|| {
+		MaxWinners::set(50);
+		assert_ok!(Staking::set_validator_count(RuntimeOrigin::root(), 40));
+
+		// increase works
+		assert_ok!(Staking::increase_validator_count(RuntimeOrigin::root(), 6));
+		assert_eq!(ValidatorCount::<Test>::get(), 46);
+
+		// errors
+		assert_noop!(
+			Staking::increase_validator_count(RuntimeOrigin::root(), 5),
+			Error::<Test>::TooManyValidators,
+		);
+	})
+}
+
+#[test]
+fn scale_validator_count_errors() {
+	ExtBuilder::default().build_and_execute(|| {
+		MaxWinners::set(50);
+		assert_ok!(Staking::set_validator_count(RuntimeOrigin::root(), 20));
+
+		// scale value works
+		assert_ok!(Staking::scale_validator_count(
+			RuntimeOrigin::root(),
+			Percent::from_percent(200)
+		));
+		assert_eq!(ValidatorCount::<Test>::get(), 40);
+
+		// errors
+		assert_noop!(
+			Staking::scale_validator_count(RuntimeOrigin::root(), Percent::from_percent(126)),
+			Error::<Test>::TooManyValidators,
+		);
+	})
+}
+
+#[test]
+fn set_min_commission_works_with_admin_origin() {
+	ExtBuilder::default().build_and_execute(|| {
+		// no minimum commission set initially
+		assert_eq!(MinCommission::<Test>::get(), Zero::zero());
+
+		// root can set min commission
+		assert_ok!(Staking::set_min_commission(RuntimeOrigin::root(), Perbill::from_percent(10)));
+
+		assert_eq!(MinCommission::<Test>::get(), Perbill::from_percent(10));
+
+		// Non privileged origin can not set min_commission
+		assert_noop!(
+			Staking::set_min_commission(RuntimeOrigin::signed(2), Perbill::from_percent(15)),
+			BadOrigin
+		);
+
+		// Admin Origin can set min commission
+		assert_ok!(Staking::set_min_commission(
+			RuntimeOrigin::signed(1),
+			Perbill::from_percent(15),
+		));
+
+		// setting commission below min_commission fails
+		assert_noop!(
+			Staking::validate(
+				RuntimeOrigin::signed(11),
+				ValidatorPrefs { commission: Perbill::from_percent(14), blocked: false }
+			),
+			Error::<Test>::CommissionTooLow
+		);
+
+		// setting commission >= min_commission works
+		assert_ok!(Staking::validate(
+			RuntimeOrigin::signed(11),
+			ValidatorPrefs { commission: Perbill::from_percent(15), blocked: false }
+		));
+	})
+}
+
+mod staking_interface {
+	use frame_support::storage::with_storage_layer;
+	use sp_staking::StakingInterface;
+
+	use super::*;
+
+	#[test]
+	fn force_unstake_with_slash_works() {
+		ExtBuilder::default().build_and_execute(|| {
+			// without slash
+			let _ = with_storage_layer::<(), _, _>(|| {
+				// bond an account, can unstake
+				assert_eq!(Staking::bonded(&11), Some(11));
+				assert_ok!(<Staking as StakingInterface>::force_unstake(11));
+				Err(DispatchError::from("revert"))
+			});
+
+			// bond again and add a slash, still can unstake.
+			assert_eq!(Staking::bonded(&11), Some(11));
+			add_slash(&11);
+			assert_ok!(<Staking as StakingInterface>::force_unstake(11));
+		});
+	}
+
+	#[test]
+	fn do_withdraw_unbonded_with_wrong_slash_spans_works_as_expected() {
+		ExtBuilder::default().build_and_execute(|| {
+			on_offence_now(
+				&[OffenceDetails {
+					offender: (11, Staking::eras_stakers(active_era(), 11)),
+					reporters: vec![],
+				}],
+				&[Perbill::from_percent(100)],
+			);
+
+			assert_eq!(Staking::bonded(&11), Some(11));
+
+			assert_noop!(
+				Staking::withdraw_unbonded(RuntimeOrigin::signed(11), 0),
+				Error::<Test>::IncorrectSlashingSpans
+			);
+
+			let num_slashing_spans = Staking::slashing_spans(&11).map_or(0, |s| s.iter().count());
+			assert_ok!(Staking::withdraw_unbonded(
+				RuntimeOrigin::signed(11),
+				num_slashing_spans as u32
+			));
+		});
+	}
+
+	#[test]
+	fn status() {
+		ExtBuilder::default().build_and_execute(|| {
+			// stash of a validator is identified as a validator
+			assert_eq!(Staking::status(&11).unwrap(), StakerStatus::Validator);
+			// .. but not the controller.
+			assert!(Staking::status(&10).is_err());
+
+			// stash of nominator is identified as a nominator
+			assert_eq!(Staking::status(&101).unwrap(), StakerStatus::Nominator(vec![11, 21]));
+			// .. but not the controller.
+			assert!(Staking::status(&100).is_err());
+
+			// stash of chilled is identified as a chilled
+			assert_eq!(Staking::status(&41).unwrap(), StakerStatus::Idle);
+			// .. but not the controller.
+			assert!(Staking::status(&40).is_err());
+
+			// random other account.
+			assert!(Staking::status(&42).is_err());
+		})
+	}
+}
diff --git a/substrate/frame/staking/src/weights.rs b/substrate/frame/staking/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f2c65e677cac834a7e2b5d6a6d6ebadb54285014
--- /dev/null
+++ b/substrate/frame/staking/src/weights.rs
@@ -0,0 +1,1506 @@
+// 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.
+
+//! Autogenerated weights for pallet_staking
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_staking
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/staking/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_staking.
+pub trait WeightInfo {
+	fn bond() -> Weight;
+	fn bond_extra() -> Weight;
+	fn unbond() -> Weight;
+	fn withdraw_unbonded_update(s: u32, ) -> Weight;
+	fn withdraw_unbonded_kill(s: u32, ) -> Weight;
+	fn validate() -> Weight;
+	fn kick(k: u32, ) -> Weight;
+	fn nominate(n: u32, ) -> Weight;
+	fn chill() -> Weight;
+	fn set_payee() -> Weight;
+	fn set_controller() -> Weight;
+	fn set_validator_count() -> Weight;
+	fn force_no_eras() -> Weight;
+	fn force_new_era() -> Weight;
+	fn force_new_era_always() -> Weight;
+	fn set_invulnerables(v: u32, ) -> Weight;
+	fn force_unstake(s: u32, ) -> Weight;
+	fn cancel_deferred_slash(s: u32, ) -> Weight;
+	fn payout_stakers_dead_controller(n: u32, ) -> Weight;
+	fn payout_stakers_alive_staked(n: u32, ) -> Weight;
+	fn rebond(l: u32, ) -> Weight;
+	fn reap_stash(s: u32, ) -> Weight;
+	fn new_era(v: u32, n: u32, ) -> Weight;
+	fn get_npos_voters(v: u32, n: u32, ) -> Weight;
+	fn get_npos_targets(v: u32, ) -> Weight;
+	fn set_staking_configs_all_set() -> Weight;
+	fn set_staking_configs_all_remove() -> Weight;
+	fn chill_other() -> Weight;
+	fn force_apply_min_commission() -> Weight;
+	fn set_min_commission() -> Weight;
+}
+
+/// Weights for pallet_staking using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// 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 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn bond() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1047`
+		//  Estimated: `4764`
+		// Minimum execution time: 53_983_000 picoseconds.
+		Weight::from_parts(55_296_000, 4764)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn bond_extra() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2028`
+		//  Estimated: `8877`
+		// Minimum execution time: 96_590_000 picoseconds.
+		Weight::from_parts(98_921_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:1 w:0)
+	/// 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 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:3 w:3)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:2 w:2)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn unbond() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2233`
+		//  Estimated: `8877`
+		// Minimum execution time: 99_901_000 picoseconds.
+		Weight::from_parts(102_919_000, 8877)
+			.saturating_add(T::DbWeight::get().reads(12_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_update(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1021`
+		//  Estimated: `4764`
+		// Minimum execution time: 45_230_000 picoseconds.
+		Weight::from_parts(47_052_829, 4764)
+			// Standard Error: 1_044
+			.saturating_add(Weight::from_parts(43_887, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// 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 Bonded (r:1 w:1)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking SlashingSpans (r:1 w:1)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Staking SpanSlash (r:0 w:100)
+	/// Proof: Staking SpanSlash (max_values: None, max_size: Some(76), added: 2551, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_kill(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2294 + s * (4 ±0)`
+		//  Estimated: `6248 + s * (4 ±0)`
+		// Minimum execution time: 97_534_000 picoseconds.
+		Weight::from_parts(104_772_163, 6248)
+			// Standard Error: 3_674
+			.saturating_add(Weight::from_parts(1_470_124, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(13_u64))
+			.saturating_add(T::DbWeight::get().writes(11_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(s.into()))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking MinValidatorBond (r:1 w:0)
+	/// Proof: Staking MinValidatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Staking MinCommission (r:1 w:0)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1 w:1)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking MaxValidatorsCount (r:1 w:0)
+	/// Proof: Staking MaxValidatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:1 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForValidators (r:1 w:1)
+	/// Proof: Staking CounterForValidators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn validate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1414`
+		//  Estimated: `4556`
+		// Minimum execution time: 57_467_000 picoseconds.
+		Weight::from_parts(59_437_000, 4556)
+			.saturating_add(T::DbWeight::get().reads(11_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:128 w:128)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// The range of component `k` is `[1, 128]`.
+	fn kick(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1285 + k * (569 ±0)`
+		//  Estimated: `4556 + k * (3033 ±0)`
+		// Minimum execution time: 32_857_000 picoseconds.
+		Weight::from_parts(37_116_967, 4556)
+			// Standard Error: 9_522
+			.saturating_add(Weight::from_parts(8_796_167, 0).saturating_mul(k.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(k.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(k.into())))
+			.saturating_add(Weight::from_parts(0, 3033).saturating_mul(k.into()))
+	}
+	/// 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 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)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:17 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, 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 Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 16]`.
+	fn nominate(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1908 + n * (102 ±0)`
+		//  Estimated: `6248 + n * (2520 ±0)`
+		// Minimum execution time: 69_613_000 picoseconds.
+		Weight::from_parts(68_079_061, 6248)
+			// Standard Error: 18_554
+			.saturating_add(Weight::from_parts(4_012_761, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(12_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(n.into()))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn chill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1748`
+		//  Estimated: `6248`
+		// Minimum execution time: 60_430_000 picoseconds.
+		Weight::from_parts(62_702_000, 6248)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn set_payee() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `808`
+		//  Estimated: `4556`
+		// Minimum execution time: 14_276_000 picoseconds.
+		Weight::from_parts(14_766_000, 4556)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// 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:2 w:2)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	fn set_controller() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `907`
+		//  Estimated: `8122`
+		// Minimum execution time: 21_710_000 picoseconds.
+		Weight::from_parts(22_430_000, 8122)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Staking ValidatorCount (r:0 w:1)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn set_validator_count() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_970_000 picoseconds.
+		Weight::from_parts(3_120_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking ForceEra (r:0 w:1)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	fn force_no_eras() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_362_000 picoseconds.
+		Weight::from_parts(9_785_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking ForceEra (r:0 w:1)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	fn force_new_era() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_275_000 picoseconds.
+		Weight::from_parts(9_678_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking ForceEra (r:0 w:1)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	fn force_new_era_always() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_414_000 picoseconds.
+		Weight::from_parts(9_848_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking Invulnerables (r:0 w:1)
+	/// Proof Skipped: Staking Invulnerables (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[0, 1000]`.
+	fn set_invulnerables(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_061_000 picoseconds.
+		Weight::from_parts(3_618_535, 0)
+			// Standard Error: 44
+			.saturating_add(Weight::from_parts(10_774, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking Bonded (r:1 w:1)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking SlashingSpans (r:1 w:1)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (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)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:0 w:1)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Staking SpanSlash (r:0 w:100)
+	/// Proof: Staking SpanSlash (max_values: None, max_size: Some(76), added: 2551, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn force_unstake(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2018 + s * (4 ±0)`
+		//  Estimated: `6248 + s * (4 ±0)`
+		// Minimum execution time: 87_914_000 picoseconds.
+		Weight::from_parts(95_688_129, 6248)
+			// Standard Error: 5_030
+			.saturating_add(Weight::from_parts(1_487_249, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(12_u64))
+			.saturating_add(T::DbWeight::get().writes(12_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(s.into()))
+	}
+	/// Storage: Staking UnappliedSlashes (r:1 w:1)
+	/// Proof Skipped: Staking UnappliedSlashes (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `s` is `[1, 1000]`.
+	fn cancel_deferred_slash(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `66639`
+		//  Estimated: `70104`
+		// Minimum execution time: 99_269_000 picoseconds.
+		Weight::from_parts(1_154_264_637, 70104)
+			// Standard Error: 76_592
+			.saturating_add(Weight::from_parts(6_490_888, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasValidatorReward (r:1 w:0)
+	/// Proof: Staking ErasValidatorReward (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:257 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: Staking ErasStakersClipped (r:1 w:0)
+	/// Proof Skipped: Staking ErasStakersClipped (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasRewardPoints (r:1 w:0)
+	/// Proof Skipped: Staking ErasRewardPoints (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasValidatorPrefs (r:1 w:0)
+	/// Proof: Staking ErasValidatorPrefs (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:257 w:0)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: System Account (r:257 w:257)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 256]`.
+	fn payout_stakers_dead_controller(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `20217 + n * (143 ±0)`
+		//  Estimated: `19844 + n * (2603 ±1)`
+		// Minimum execution time: 91_767_000 picoseconds.
+		Weight::from_parts(146_781_264, 19844)
+			// Standard Error: 31_341
+			.saturating_add(Weight::from_parts(30_553_008, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(n.into()))
+	}
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasValidatorReward (r:1 w:0)
+	/// Proof: Staking ErasValidatorReward (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:257 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:257 w:257)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakersClipped (r:1 w:0)
+	/// Proof Skipped: Staking ErasStakersClipped (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasRewardPoints (r:1 w:0)
+	/// Proof Skipped: Staking ErasRewardPoints (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasValidatorPrefs (r:1 w:0)
+	/// Proof: Staking ErasValidatorPrefs (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:257 w:0)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: System Account (r:257 w:257)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Balances Locks (r:257 w:257)
+	/// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen)
+	/// Storage: Balances Freezes (r:257 w:0)
+	/// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 256]`.
+	fn payout_stakers_alive_staked(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `33190 + n * (377 ±0)`
+		//  Estimated: `30845 + n * (3774 ±0)`
+		// Minimum execution time: 121_303_000 picoseconds.
+		Weight::from_parts(151_046_907, 30845)
+			// Standard Error: 41_899
+			.saturating_add(Weight::from_parts(49_837_804, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(11_u64))
+			.saturating_add(T::DbWeight::get().reads((6_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 3774).saturating_mul(n.into()))
+	}
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:3 w:3)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:2 w:2)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// The range of component `l` is `[1, 32]`.
+	fn rebond(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2029 + l * (7 ±0)`
+		//  Estimated: `8877`
+		// Minimum execution time: 90_068_000 picoseconds.
+		Weight::from_parts(93_137_456, 8877)
+			// Standard Error: 4_799
+			.saturating_add(Weight::from_parts(54_421, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(9_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// 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:1)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Staking SpanSlash (r:0 w:100)
+	/// Proof: Staking SpanSlash (max_values: None, max_size: Some(76), added: 2551, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 100]`.
+	fn reap_stash(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2294 + s * (4 ±0)`
+		//  Estimated: `6248 + s * (4 ±0)`
+		// Minimum execution time: 103_139_000 picoseconds.
+		Weight::from_parts(107_036_296, 6248)
+			// Standard Error: 3_935
+			.saturating_add(Weight::from_parts(1_465_860, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(12_u64))
+			.saturating_add(T::DbWeight::get().writes(11_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(s.into()))
+	}
+	/// Storage: VoterList CounterForListNodes (r:1 w:0)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:200 w:0)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:110 w:0)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:110 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:11 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:110 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:110 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForValidators (r:1 w:0)
+	/// Proof: Staking CounterForValidators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ValidatorCount (r:1 w:0)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinimumValidatorCount (r:1 w:0)
+	/// Proof: Staking MinimumValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CurrentEra (r:1 w:1)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakersClipped (r:0 w:10)
+	/// Proof Skipped: Staking ErasStakersClipped (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasValidatorPrefs (r:0 w:10)
+	/// Proof: Staking ErasValidatorPrefs (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakers (r:0 w:10)
+	/// Proof Skipped: Staking ErasStakers (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasTotalStake (r:0 w:1)
+	/// Proof: Staking ErasTotalStake (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStartSessionIndex (r:0 w:1)
+	/// Proof: Staking ErasStartSessionIndex (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: Staking MinimumActiveStake (r:0 w:1)
+	/// Proof: Staking MinimumActiveStake (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// The range of component `v` is `[1, 10]`.
+	/// The range of component `n` is `[0, 100]`.
+	fn new_era(v: u32, n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + n * (720 ±0) + v * (3598 ±0)`
+		//  Estimated: `512390 + n * (3566 ±0) + v * (3566 ±0)`
+		// Minimum execution time: 587_156_000 picoseconds.
+		Weight::from_parts(590_176_000, 512390)
+			// Standard Error: 2_008_420
+			.saturating_add(Weight::from_parts(64_526_052, 0).saturating_mul(v.into()))
+			// Standard Error: 200_128
+			.saturating_add(Weight::from_parts(18_070_222, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(206_u64))
+			.saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(v.into())))
+			.saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(v.into())))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(v.into()))
+	}
+	/// Storage: VoterList CounterForListNodes (r:1 w:0)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:200 w:0)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:2000 w:0)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:2000 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1000 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:2000 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:2000 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking MinimumActiveStake (r:0 w:1)
+	/// Proof: Staking MinimumActiveStake (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// The range of component `v` is `[500, 1000]`.
+	/// The range of component `n` is `[500, 1000]`.
+	fn get_npos_voters(v: u32, n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3217 + n * (911 ±0) + v * (395 ±0)`
+		//  Estimated: `512390 + n * (3566 ±0) + v * (3566 ±0)`
+		// Minimum execution time: 34_399_721_000 picoseconds.
+		Weight::from_parts(34_605_803_000, 512390)
+			// Standard Error: 380_106
+			.saturating_add(Weight::from_parts(5_426_220, 0).saturating_mul(v.into()))
+			// Standard Error: 380_106
+			.saturating_add(Weight::from_parts(3_318_197, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(201_u64))
+			.saturating_add(T::DbWeight::get().reads((5_u64).saturating_mul(v.into())))
+			.saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(v.into()))
+	}
+	/// Storage: Staking CounterForValidators (r:1 w:0)
+	/// Proof: Staking CounterForValidators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1001 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// The range of component `v` is `[500, 1000]`.
+	fn get_npos_targets(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `983 + v * (50 ±0)`
+		//  Estimated: `3510 + v * (2520 ±0)`
+		// Minimum execution time: 2_392_849_000 picoseconds.
+		Weight::from_parts(64_373_879, 3510)
+			// Standard Error: 8_995
+			.saturating_add(Weight::from_parts(4_721_536, 0).saturating_mul(v.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(v.into())))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(v.into()))
+	}
+	/// Storage: Staking MinCommission (r:0 w:1)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinValidatorBond (r:0 w:1)
+	/// Proof: Staking MinValidatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Staking MaxValidatorsCount (r:0 w:1)
+	/// Proof: Staking MaxValidatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ChillThreshold (r:0 w:1)
+	/// Proof: Staking ChillThreshold (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Staking MaxNominatorsCount (r:0 w:1)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinNominatorBond (r:0 w:1)
+	/// Proof: Staking MinNominatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	fn set_staking_configs_all_set() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_529_000 picoseconds.
+		Weight::from_parts(7_970_000, 0)
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking MinCommission (r:0 w:1)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinValidatorBond (r:0 w:1)
+	/// Proof: Staking MinValidatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Staking MaxValidatorsCount (r:0 w:1)
+	/// Proof: Staking MaxValidatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ChillThreshold (r:0 w:1)
+	/// Proof: Staking ChillThreshold (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Staking MaxNominatorsCount (r:0 w:1)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinNominatorBond (r:0 w:1)
+	/// Proof: Staking MinNominatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	fn set_staking_configs_all_remove() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_011_000 picoseconds.
+		Weight::from_parts(7_317_000, 0)
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, 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 ChillThreshold (r:1 w:0)
+	/// Proof: Staking ChillThreshold (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Staking MaxNominatorsCount (r:1 w:0)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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: VoterList ListNodes (r:2 w:2)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn chill_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1871`
+		//  Estimated: `6248`
+		// Minimum execution time: 75_982_000 picoseconds.
+		Weight::from_parts(77_412_000, 6248)
+			.saturating_add(T::DbWeight::get().reads(11_u64))
+			.saturating_add(T::DbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking MinCommission (r:1 w:0)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1 w:1)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	fn force_apply_min_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `694`
+		//  Estimated: `3510`
+		// Minimum execution time: 13_923_000 picoseconds.
+		Weight::from_parts(14_356_000, 3510)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking MinCommission (r:0 w:1)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn set_min_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_415_000 picoseconds.
+		Weight::from_parts(3_679_000, 0)
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// 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 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn bond() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1047`
+		//  Estimated: `4764`
+		// Minimum execution time: 53_983_000 picoseconds.
+		Weight::from_parts(55_296_000, 4764)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// 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(49), added: 2524, 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)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn bond_extra() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2028`
+		//  Estimated: `8877`
+		// Minimum execution time: 96_590_000 picoseconds.
+		Weight::from_parts(98_921_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:1 w:0)
+	/// 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 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:3 w:3)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:2 w:2)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	fn unbond() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2233`
+		//  Estimated: `8877`
+		// Minimum execution time: 99_901_000 picoseconds.
+		Weight::from_parts(102_919_000, 8877)
+			.saturating_add(RocksDbWeight::get().reads(12_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_update(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1021`
+		//  Estimated: `4764`
+		// Minimum execution time: 45_230_000 picoseconds.
+		Weight::from_parts(47_052_829, 4764)
+			// Standard Error: 1_044
+			.saturating_add(Weight::from_parts(43_887, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:1)
+	/// 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 Bonded (r:1 w:1)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking SlashingSpans (r:1 w:1)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Staking SpanSlash (r:0 w:100)
+	/// Proof: Staking SpanSlash (max_values: None, max_size: Some(76), added: 2551, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn withdraw_unbonded_kill(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2294 + s * (4 ±0)`
+		//  Estimated: `6248 + s * (4 ±0)`
+		// Minimum execution time: 97_534_000 picoseconds.
+		Weight::from_parts(104_772_163, 6248)
+			// Standard Error: 3_674
+			.saturating_add(Weight::from_parts(1_470_124, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(13_u64))
+			.saturating_add(RocksDbWeight::get().writes(11_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(s.into()))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking MinValidatorBond (r:1 w:0)
+	/// Proof: Staking MinValidatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Staking MinCommission (r:1 w:0)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1 w:1)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking MaxValidatorsCount (r:1 w:0)
+	/// Proof: Staking MaxValidatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:1 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:1 w:1)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForValidators (r:1 w:1)
+	/// Proof: Staking CounterForValidators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn validate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1414`
+		//  Estimated: `4556`
+		// Minimum execution time: 57_467_000 picoseconds.
+		Weight::from_parts(59_437_000, 4556)
+			.saturating_add(RocksDbWeight::get().reads(11_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:128 w:128)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// The range of component `k` is `[1, 128]`.
+	fn kick(k: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1285 + k * (569 ±0)`
+		//  Estimated: `4556 + k * (3033 ±0)`
+		// Minimum execution time: 32_857_000 picoseconds.
+		Weight::from_parts(37_116_967, 4556)
+			// Standard Error: 9_522
+			.saturating_add(Weight::from_parts(8_796_167, 0).saturating_mul(k.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(k.into())))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(k.into())))
+			.saturating_add(Weight::from_parts(0, 3033).saturating_mul(k.into()))
+	}
+	/// 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 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)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:17 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, 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 Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 16]`.
+	fn nominate(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1908 + n * (102 ±0)`
+		//  Estimated: `6248 + n * (2520 ±0)`
+		// Minimum execution time: 69_613_000 picoseconds.
+		Weight::from_parts(68_079_061, 6248)
+			// Standard Error: 18_554
+			.saturating_add(Weight::from_parts(4_012_761, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(12_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(n.into()))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn chill() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1748`
+		//  Estimated: `6248`
+		// Minimum execution time: 60_430_000 picoseconds.
+		Weight::from_parts(62_702_000, 6248)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	fn set_payee() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `808`
+		//  Estimated: `4556`
+		// Minimum execution time: 14_276_000 picoseconds.
+		Weight::from_parts(14_766_000, 4556)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// 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:2 w:2)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	fn set_controller() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `907`
+		//  Estimated: `8122`
+		// Minimum execution time: 21_710_000 picoseconds.
+		Weight::from_parts(22_430_000, 8122)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Staking ValidatorCount (r:0 w:1)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn set_validator_count() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_970_000 picoseconds.
+		Weight::from_parts(3_120_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking ForceEra (r:0 w:1)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	fn force_no_eras() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_362_000 picoseconds.
+		Weight::from_parts(9_785_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking ForceEra (r:0 w:1)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	fn force_new_era() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_275_000 picoseconds.
+		Weight::from_parts(9_678_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking ForceEra (r:0 w:1)
+	/// Proof: Staking ForceEra (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	fn force_new_era_always() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_414_000 picoseconds.
+		Weight::from_parts(9_848_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking Invulnerables (r:0 w:1)
+	/// Proof Skipped: Staking Invulnerables (max_values: Some(1), max_size: None, mode: Measured)
+	/// The range of component `v` is `[0, 1000]`.
+	fn set_invulnerables(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_061_000 picoseconds.
+		Weight::from_parts(3_618_535, 0)
+			// Standard Error: 44
+			.saturating_add(Weight::from_parts(10_774, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking Bonded (r:1 w:1)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking SlashingSpans (r:1 w:1)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (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)
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:0 w:1)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Staking SpanSlash (r:0 w:100)
+	/// Proof: Staking SpanSlash (max_values: None, max_size: Some(76), added: 2551, mode: MaxEncodedLen)
+	/// The range of component `s` is `[0, 100]`.
+	fn force_unstake(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2018 + s * (4 ±0)`
+		//  Estimated: `6248 + s * (4 ±0)`
+		// Minimum execution time: 87_914_000 picoseconds.
+		Weight::from_parts(95_688_129, 6248)
+			// Standard Error: 5_030
+			.saturating_add(Weight::from_parts(1_487_249, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(12_u64))
+			.saturating_add(RocksDbWeight::get().writes(12_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(s.into()))
+	}
+	/// Storage: Staking UnappliedSlashes (r:1 w:1)
+	/// Proof Skipped: Staking UnappliedSlashes (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `s` is `[1, 1000]`.
+	fn cancel_deferred_slash(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `66639`
+		//  Estimated: `70104`
+		// Minimum execution time: 99_269_000 picoseconds.
+		Weight::from_parts(1_154_264_637, 70104)
+			// Standard Error: 76_592
+			.saturating_add(Weight::from_parts(6_490_888, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasValidatorReward (r:1 w:0)
+	/// Proof: Staking ErasValidatorReward (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:257 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: Staking ErasStakersClipped (r:1 w:0)
+	/// Proof Skipped: Staking ErasStakersClipped (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasRewardPoints (r:1 w:0)
+	/// Proof Skipped: Staking ErasRewardPoints (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasValidatorPrefs (r:1 w:0)
+	/// Proof: Staking ErasValidatorPrefs (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:257 w:0)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: System Account (r:257 w:257)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 256]`.
+	fn payout_stakers_dead_controller(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `20217 + n * (143 ±0)`
+		//  Estimated: `19844 + n * (2603 ±1)`
+		// Minimum execution time: 91_767_000 picoseconds.
+		Weight::from_parts(146_781_264, 19844)
+			// Standard Error: 31_341
+			.saturating_add(Weight::from_parts(30_553_008, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 2603).saturating_mul(n.into()))
+	}
+	/// Storage: Staking CurrentEra (r:1 w:0)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasValidatorReward (r:1 w:0)
+	/// Proof: Staking ErasValidatorReward (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:257 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:257 w:257)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakersClipped (r:1 w:0)
+	/// Proof Skipped: Staking ErasStakersClipped (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasRewardPoints (r:1 w:0)
+	/// Proof Skipped: Staking ErasRewardPoints (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasValidatorPrefs (r:1 w:0)
+	/// Proof: Staking ErasValidatorPrefs (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:257 w:0)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: System Account (r:257 w:257)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Balances Locks (r:257 w:257)
+	/// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen)
+	/// Storage: Balances Freezes (r:257 w:0)
+	/// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `n` is `[0, 256]`.
+	fn payout_stakers_alive_staked(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `33190 + n * (377 ±0)`
+		//  Estimated: `30845 + n * (3774 ±0)`
+		// Minimum execution time: 121_303_000 picoseconds.
+		Weight::from_parts(151_046_907, 30845)
+			// Standard Error: 41_899
+			.saturating_add(Weight::from_parts(49_837_804, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(11_u64))
+			.saturating_add(RocksDbWeight::get().reads((6_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(n.into())))
+			.saturating_add(Weight::from_parts(0, 3774).saturating_mul(n.into()))
+	}
+	/// 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:3 w:3)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:1 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:2 w:2)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// The range of component `l` is `[1, 32]`.
+	fn rebond(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2029 + l * (7 ±0)`
+		//  Estimated: `8877`
+		// Minimum execution time: 90_068_000 picoseconds.
+		Weight::from_parts(93_137_456, 8877)
+			// Standard Error: 4_799
+			.saturating_add(Weight::from_parts(54_421, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(9_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// 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:1)
+	/// Proof Skipped: Staking SlashingSpans (max_values: None, max_size: None, mode: Measured)
+	/// 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)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: Staking Payee (r:0 w:1)
+	/// Proof: Staking Payee (max_values: None, max_size: Some(73), added: 2548, mode: MaxEncodedLen)
+	/// Storage: Staking SpanSlash (r:0 w:100)
+	/// Proof: Staking SpanSlash (max_values: None, max_size: Some(76), added: 2551, mode: MaxEncodedLen)
+	/// The range of component `s` is `[1, 100]`.
+	fn reap_stash(s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2294 + s * (4 ±0)`
+		//  Estimated: `6248 + s * (4 ±0)`
+		// Minimum execution time: 103_139_000 picoseconds.
+		Weight::from_parts(107_036_296, 6248)
+			// Standard Error: 3_935
+			.saturating_add(Weight::from_parts(1_465_860, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(12_u64))
+			.saturating_add(RocksDbWeight::get().writes(11_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(s.into())))
+			.saturating_add(Weight::from_parts(0, 4).saturating_mul(s.into()))
+	}
+	/// Storage: VoterList CounterForListNodes (r:1 w:0)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:200 w:0)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:110 w:0)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:110 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:11 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:110 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:110 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForValidators (r:1 w:0)
+	/// Proof: Staking CounterForValidators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ValidatorCount (r:1 w:0)
+	/// Proof: Staking ValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinimumValidatorCount (r:1 w:0)
+	/// Proof: Staking MinimumValidatorCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CurrentEra (r:1 w:1)
+	/// Proof: Staking CurrentEra (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakersClipped (r:0 w:10)
+	/// Proof Skipped: Staking ErasStakersClipped (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasValidatorPrefs (r:0 w:10)
+	/// Proof: Staking ErasValidatorPrefs (max_values: None, max_size: Some(57), added: 2532, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStakers (r:0 w:10)
+	/// Proof Skipped: Staking ErasStakers (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Staking ErasTotalStake (r:0 w:1)
+	/// Proof: Staking ErasTotalStake (max_values: None, max_size: Some(28), added: 2503, mode: MaxEncodedLen)
+	/// Storage: Staking ErasStartSessionIndex (r:0 w:1)
+	/// Proof: Staking ErasStartSessionIndex (max_values: None, max_size: Some(16), added: 2491, mode: MaxEncodedLen)
+	/// Storage: Staking MinimumActiveStake (r:0 w:1)
+	/// Proof: Staking MinimumActiveStake (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// The range of component `v` is `[1, 10]`.
+	/// The range of component `n` is `[0, 100]`.
+	fn new_era(v: u32, n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0 + n * (720 ±0) + v * (3598 ±0)`
+		//  Estimated: `512390 + n * (3566 ±0) + v * (3566 ±0)`
+		// Minimum execution time: 587_156_000 picoseconds.
+		Weight::from_parts(590_176_000, 512390)
+			// Standard Error: 2_008_420
+			.saturating_add(Weight::from_parts(64_526_052, 0).saturating_mul(v.into()))
+			// Standard Error: 200_128
+			.saturating_add(Weight::from_parts(18_070_222, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(206_u64))
+			.saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(v.into())))
+			.saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(v.into())))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(v.into()))
+	}
+	/// Storage: VoterList CounterForListNodes (r:1 w:0)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:200 w:0)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList ListNodes (r:2000 w:0)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: Staking Nominators (r:2000 w:0)
+	/// Proof: Staking Nominators (max_values: None, max_size: Some(558), added: 3033, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1000 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// Storage: Staking Bonded (r:2000 w:0)
+	/// Proof: Staking Bonded (max_values: None, max_size: Some(72), added: 2547, mode: MaxEncodedLen)
+	/// Storage: Staking Ledger (r:2000 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, mode: MaxEncodedLen)
+	/// Storage: Staking MinimumActiveStake (r:0 w:1)
+	/// Proof: Staking MinimumActiveStake (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// The range of component `v` is `[500, 1000]`.
+	/// The range of component `n` is `[500, 1000]`.
+	fn get_npos_voters(v: u32, n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3217 + n * (911 ±0) + v * (395 ±0)`
+		//  Estimated: `512390 + n * (3566 ±0) + v * (3566 ±0)`
+		// Minimum execution time: 34_399_721_000 picoseconds.
+		Weight::from_parts(34_605_803_000, 512390)
+			// Standard Error: 380_106
+			.saturating_add(Weight::from_parts(5_426_220, 0).saturating_mul(v.into()))
+			// Standard Error: 380_106
+			.saturating_add(Weight::from_parts(3_318_197, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(201_u64))
+			.saturating_add(RocksDbWeight::get().reads((5_u64).saturating_mul(v.into())))
+			.saturating_add(RocksDbWeight::get().reads((4_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(n.into()))
+			.saturating_add(Weight::from_parts(0, 3566).saturating_mul(v.into()))
+	}
+	/// Storage: Staking CounterForValidators (r:1 w:0)
+	/// Proof: Staking CounterForValidators (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1001 w:0)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	/// The range of component `v` is `[500, 1000]`.
+	fn get_npos_targets(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `983 + v * (50 ±0)`
+		//  Estimated: `3510 + v * (2520 ±0)`
+		// Minimum execution time: 2_392_849_000 picoseconds.
+		Weight::from_parts(64_373_879, 3510)
+			// Standard Error: 8_995
+			.saturating_add(Weight::from_parts(4_721_536, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(v.into())))
+			.saturating_add(Weight::from_parts(0, 2520).saturating_mul(v.into()))
+	}
+	/// Storage: Staking MinCommission (r:0 w:1)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinValidatorBond (r:0 w:1)
+	/// Proof: Staking MinValidatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Staking MaxValidatorsCount (r:0 w:1)
+	/// Proof: Staking MaxValidatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ChillThreshold (r:0 w:1)
+	/// Proof: Staking ChillThreshold (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Staking MaxNominatorsCount (r:0 w:1)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinNominatorBond (r:0 w:1)
+	/// Proof: Staking MinNominatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	fn set_staking_configs_all_set() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_529_000 picoseconds.
+		Weight::from_parts(7_970_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking MinCommission (r:0 w:1)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinValidatorBond (r:0 w:1)
+	/// Proof: Staking MinValidatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Staking MaxValidatorsCount (r:0 w:1)
+	/// Proof: Staking MaxValidatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking ChillThreshold (r:0 w:1)
+	/// Proof: Staking ChillThreshold (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Staking MaxNominatorsCount (r:0 w:1)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking MinNominatorBond (r:0 w:1)
+	/// Proof: Staking MinNominatorBond (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	fn set_staking_configs_all_remove() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 7_011_000 picoseconds.
+		Weight::from_parts(7_317_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking Ledger (r:1 w:0)
+	/// Proof: Staking Ledger (max_values: None, max_size: Some(1091), added: 3566, 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 ChillThreshold (r:1 w:0)
+	/// Proof: Staking ChillThreshold (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: Staking MaxNominatorsCount (r:1 w:0)
+	/// Proof: Staking MaxNominatorsCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking CounterForNominators (r:1 w:1)
+	/// Proof: Staking CounterForNominators (max_values: Some(1), max_size: Some(4), added: 499, 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: VoterList ListNodes (r:2 w:2)
+	/// Proof: VoterList ListNodes (max_values: None, max_size: Some(154), added: 2629, mode: MaxEncodedLen)
+	/// Storage: VoterList ListBags (r:1 w:1)
+	/// Proof: VoterList ListBags (max_values: None, max_size: Some(82), added: 2557, mode: MaxEncodedLen)
+	/// Storage: VoterList CounterForListNodes (r:1 w:1)
+	/// Proof: VoterList CounterForListNodes (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn chill_other() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1871`
+		//  Estimated: `6248`
+		// Minimum execution time: 75_982_000 picoseconds.
+		Weight::from_parts(77_412_000, 6248)
+			.saturating_add(RocksDbWeight::get().reads(11_u64))
+			.saturating_add(RocksDbWeight::get().writes(6_u64))
+	}
+	/// Storage: Staking MinCommission (r:1 w:0)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Staking Validators (r:1 w:1)
+	/// Proof: Staking Validators (max_values: None, max_size: Some(45), added: 2520, mode: MaxEncodedLen)
+	fn force_apply_min_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `694`
+		//  Estimated: `3510`
+		// Minimum execution time: 13_923_000 picoseconds.
+		Weight::from_parts(14_356_000, 3510)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Staking MinCommission (r:0 w:1)
+	/// Proof: Staking MinCommission (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	fn set_min_commission() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 3_415_000 picoseconds.
+		Weight::from_parts(3_679_000, 0)
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/state-trie-migration/Cargo.toml b/substrate/frame/state-trie-migration/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d1bed941d4ccedd6d1151975dcb150d95003bec3
--- /dev/null
+++ b/substrate/frame/state-trie-migration/Cargo.toml
@@ -0,0 +1,74 @@
+[package]
+name = "pallet-state-trie-migration"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet migration of trie"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+thousands = { version = "0.2.0", optional = true }
+zstd = { version = "0.12.3", default-features = false, optional = true }
+frame-benchmarking = { default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { default-features = false, path = "../support" }
+frame-system = { default-features = false, path = "../system" }
+remote-externalities = { optional = true, path = "../../utils/frame/remote-externalities", package = "frame-remote-externalities" }
+sp-core = { default-features = false, path = "../../primitives/core" }
+sp-io = { default-features = false, path = "../../primitives/io" }
+sp-runtime = { default-features = false, path = "../../primitives/runtime" }
+sp-std = { default-features = false, path = "../../primitives/std" }
+substrate-state-trie-migration-rpc = { optional = true, path = "../../utils/frame/rpc/state-trie-migration-rpc" }
+
+[dev-dependencies]
+parking_lot = "0.12.1"
+tokio = { version = "1.22.0", features = ["macros"] }
+pallet-balances = { path = "../balances" }
+sp-tracing = { path = "../../primitives/tracing" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-tracing/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
+remote-test = [
+	"remote-externalities",
+	"serde",
+	"std",
+	"substrate-state-trie-migration-rpc",
+	"thousands",
+	"zstd",
+]
diff --git a/substrate/frame/state-trie-migration/src/lib.rs b/substrate/frame/state-trie-migration/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e22a47458b7d510b33baadb1894eab44ad1d8591
--- /dev/null
+++ b/substrate/frame/state-trie-migration/src/lib.rs
@@ -0,0 +1,1779 @@
+// 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.
+
+//! # Pallet State Trie Migration
+//!
+//! Reads and writes all keys and values in the entire state in a systematic way. This is useful for
+//! upgrading a chain to [`sp-core::StateVersion::V1`], where all keys need to be touched.
+//!
+//! ## Migration Types
+//!
+//! This pallet provides 2 ways to do this, each of which is suited for a particular use-case, and
+//! can be enabled independently.
+//!
+//! ### Auto migration
+//!
+//! This system will try and migrate all keys by continuously using `on_initialize`. It is only
+//! sensible for a relay chain or a solo chain, where going slightly over weight is not a problem.
+//! It can be configured so that the migration takes at most `n` items and tries to not go over `x`
+//! bytes, but the latter is not guaranteed.
+//!
+//! For example, if a chain contains keys of 1 byte size, the `on_initialize` could read up to `x -
+//! 1` bytes from `n` different keys, while the next key is suddenly `:code:`, and there is no way
+//! to bail out of this.
+//!
+//! ### Signed migration
+//!
+//! As a backup, the migration process can be set in motion via signed transactions that basically
+//! say in advance how many items and how many bytes they will consume, and pay for it as well. This
+//! can be a good safe alternative, if the former system is not desirable.
+//!
+//! The (minor) caveat of this approach is that we cannot know in advance how many bytes reading a
+//! certain number of keys will incur. To overcome this, the runtime needs to configure this pallet
+//! with a `SignedDepositPerItem`. This is the per-item deposit that the origin of the signed
+//! migration transactions need to have in their account (on top of the normal fee) and if the size
+//! witness data that they claim is incorrect, this deposit is slashed.
+//!
+//! ---
+//!
+//! Initially, this pallet does not contain any auto migration. They must be manually enabled by the
+//! `ControlOrigin`.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+pub mod weights;
+
+const LOG_TARGET: &str = "runtime::state-trie-migration";
+
+#[macro_export]
+macro_rules! log {
+	($level:tt, $patter:expr $(, $values:expr)* $(,)?) => {
+		log::$level!(
+			target: crate::LOG_TARGET,
+			concat!("[{:?}] 🤖 ", $patter), frame_system::Pallet::<T>::block_number() $(, $values)*
+		)
+	};
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+
+	pub use crate::weights::WeightInfo;
+
+	use frame_support::{
+		dispatch::{DispatchErrorWithPostInfo, PostDispatchInfo},
+		ensure,
+		pallet_prelude::*,
+		traits::{Currency, Get},
+	};
+	use frame_system::{self, pallet_prelude::*};
+	use sp_core::{
+		hexdisplay::HexDisplay, storage::well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX,
+	};
+	use sp_runtime::{
+		self,
+		traits::{Saturating, Zero},
+	};
+	use sp_std::{ops::Deref, prelude::*};
+
+	pub(crate) type BalanceOf<T> =
+		<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+	/// The progress of either the top or child keys.
+	#[derive(
+		CloneNoBound,
+		Encode,
+		Decode,
+		scale_info::TypeInfo,
+		PartialEqNoBound,
+		EqNoBound,
+		MaxEncodedLen,
+	)]
+	#[scale_info(skip_type_params(MaxKeyLen))]
+	#[codec(mel_bound())]
+	pub enum Progress<MaxKeyLen: Get<u32>> {
+		/// Yet to begin.
+		ToStart,
+		/// Ongoing, with the last key given.
+		LastKey(BoundedVec<u8, MaxKeyLen>),
+		/// All done.
+		Complete,
+	}
+
+	/// Convenience type for easier usage of [`Progress`].
+	pub type ProgressOf<T> = Progress<<T as Config>::MaxKeyLen>;
+
+	/// A migration task stored in state.
+	///
+	/// It tracks the last top and child keys read.
+	#[derive(Clone, Encode, Decode, scale_info::TypeInfo, PartialEq, Eq, MaxEncodedLen)]
+	#[codec(mel_bound(T: Config))]
+	#[scale_info(skip_type_params(T))]
+	pub struct MigrationTask<T: Config> {
+		/// The current top trie migration progress.
+		pub(crate) progress_top: ProgressOf<T>,
+		/// The current child trie migration progress.
+		///
+		/// If `ToStart`, no further top keys are processed until the child key migration is
+		/// `Complete`.
+		pub(crate) progress_child: ProgressOf<T>,
+
+		/// Dynamic counter for the number of items that we have processed in this execution from
+		/// the top trie.
+		///
+		/// It is not written to storage.
+		#[codec(skip)]
+		pub(crate) dyn_top_items: u32,
+		/// Dynamic counter for the number of items that we have processed in this execution from
+		/// any child trie.
+		///
+		/// It is not written to storage.
+		#[codec(skip)]
+		pub(crate) dyn_child_items: u32,
+
+		/// Dynamic counter for for the byte size of items that we have processed in this
+		/// execution.
+		///
+		/// It is not written to storage.
+		#[codec(skip)]
+		pub(crate) dyn_size: u32,
+
+		/// The total size of the migration, over all executions.
+		///
+		/// This only kept around for bookkeeping and debugging.
+		pub(crate) size: u32,
+		/// The total count of top keys in the migration, over all executions.
+		///
+		/// This only kept around for bookkeeping and debugging.
+		pub(crate) top_items: u32,
+		/// The total count of child keys in the migration, over all executions.
+		///
+		/// This only kept around for bookkeeping and debugging.
+		pub(crate) child_items: u32,
+
+		#[codec(skip)]
+		pub(crate) _ph: sp_std::marker::PhantomData<T>,
+	}
+
+	impl<Size: Get<u32>> sp_std::fmt::Debug for Progress<Size> {
+		fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+			match self {
+				Progress::ToStart => f.write_str("To start"),
+				Progress::LastKey(key) => write!(f, "Last: {:?}", HexDisplay::from(key.deref())),
+				Progress::Complete => f.write_str("Complete"),
+			}
+		}
+	}
+
+	impl<T: Config> sp_std::fmt::Debug for MigrationTask<T> {
+		fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+			f.debug_struct("MigrationTask")
+				.field("top", &self.progress_top)
+				.field("child", &self.progress_child)
+				.field("dyn_top_items", &self.dyn_top_items)
+				.field("dyn_child_items", &self.dyn_child_items)
+				.field("dyn_size", &self.dyn_size)
+				.field("size", &self.size)
+				.field("top_items", &self.top_items)
+				.field("child_items", &self.child_items)
+				.finish()
+		}
+	}
+
+	impl<T: Config> Default for MigrationTask<T> {
+		fn default() -> Self {
+			Self {
+				progress_top: Progress::ToStart,
+				progress_child: Progress::ToStart,
+				dyn_child_items: Default::default(),
+				dyn_top_items: Default::default(),
+				dyn_size: Default::default(),
+				_ph: Default::default(),
+				size: Default::default(),
+				top_items: Default::default(),
+				child_items: Default::default(),
+			}
+		}
+	}
+
+	impl<T: Config> MigrationTask<T> {
+		/// Return true if the task is finished.
+		pub(crate) fn finished(&self) -> bool {
+			matches!(self.progress_top, Progress::Complete)
+		}
+
+		/// Check if there's any work left, or if we have exhausted the limits already.
+		fn exhausted(&self, limits: MigrationLimits) -> bool {
+			self.dyn_total_items() >= limits.item || self.dyn_size >= limits.size
+		}
+
+		/// get the total number of keys affected by the current task.
+		pub(crate) fn dyn_total_items(&self) -> u32 {
+			self.dyn_child_items.saturating_add(self.dyn_top_items)
+		}
+
+		/// Migrate keys until either of the given limits are exhausted, or if no more top keys
+		/// exist.
+		///
+		/// Note that this can return after the **first** migration tick that causes exhaustion,
+		/// specifically in the case of the `size` constrain. The reason for this is that before
+		/// reading a key, we simply cannot know how many bytes it is. In other words, this should
+		/// not be used in any environment where resources are strictly bounded (e.g. a parachain),
+		/// but it is acceptable otherwise (relay chain, offchain workers).
+		pub fn migrate_until_exhaustion(
+			&mut self,
+			limits: MigrationLimits,
+		) -> Result<(), Error<T>> {
+			log!(debug, "running migrations on top of {:?} until {:?}", self, limits);
+
+			if limits.item.is_zero() || limits.size.is_zero() {
+				// handle this minor edge case, else we would call `migrate_tick` at least once.
+				log!(warn, "limits are zero. stopping");
+				return Ok(())
+			}
+
+			while !self.exhausted(limits) && !self.finished() {
+				if let Err(e) = self.migrate_tick() {
+					log!(error, "migrate_until_exhaustion failed: {:?}", e);
+					return Err(e)
+				}
+			}
+
+			// accumulate dynamic data into the storage items.
+			self.size = self.size.saturating_add(self.dyn_size);
+			self.child_items = self.child_items.saturating_add(self.dyn_child_items);
+			self.top_items = self.top_items.saturating_add(self.dyn_top_items);
+			log!(debug, "finished with {:?}", self);
+			Ok(())
+		}
+
+		/// Migrate AT MOST ONE KEY. This can be either a top or a child key.
+		///
+		/// This function is *the* core of this entire pallet.
+		fn migrate_tick(&mut self) -> Result<(), Error<T>> {
+			match (&self.progress_top, &self.progress_child) {
+				(Progress::ToStart, _) => self.migrate_top(),
+				(Progress::LastKey(_), Progress::LastKey(_)) => {
+					// we're in the middle of doing work on a child tree.
+					self.migrate_child()
+				},
+				(Progress::LastKey(top_key), Progress::ToStart) => {
+					// 3. this is the root of a child key, and we are finishing all child-keys (and
+					// should call `migrate_top`).
+
+					// NOTE: this block is written intentionally to verbosely for easy of
+					// verification.
+					if !top_key.starts_with(DEFAULT_CHILD_STORAGE_KEY_PREFIX) {
+						// we continue the top key migrations.
+						// continue the top key migration
+						self.migrate_top()
+					} else {
+						// this is the root of a child key, and we start processing child keys (and
+						// should call `migrate_child`).
+						self.migrate_child()
+					}
+				},
+				(Progress::LastKey(_), Progress::Complete) => {
+					// we're done with migrating a child-root.
+					self.migrate_top()?;
+					self.progress_child = Progress::ToStart;
+					Ok(())
+				},
+				(Progress::Complete, _) => {
+					// nada
+					Ok(())
+				},
+			}
+		}
+
+		/// Migrate the current child key, setting it to its new value, if one exists.
+		///
+		/// It updates the dynamic counters.
+		fn migrate_child(&mut self) -> Result<(), Error<T>> {
+			use sp_io::default_child_storage as child_io;
+			let (maybe_current_child, child_root) = match (&self.progress_child, &self.progress_top)
+			{
+				(Progress::LastKey(last_child), Progress::LastKey(last_top)) => {
+					let child_root = Pallet::<T>::transform_child_key_or_halt(last_top);
+					let maybe_current_child: Option<BoundedVec<u8, T::MaxKeyLen>> =
+						if let Some(next) = child_io::next_key(child_root, last_child) {
+							Some(next.try_into().map_err(|_| Error::<T>::KeyTooLong)?)
+						} else {
+							None
+						};
+
+					(maybe_current_child, child_root)
+				},
+				(Progress::ToStart, Progress::LastKey(last_top)) => {
+					let child_root = Pallet::<T>::transform_child_key_or_halt(last_top);
+					// Start with the empty key as first key.
+					(Some(Default::default()), child_root)
+				},
+				_ => {
+					// defensive: there must be an ongoing top migration.
+					frame_support::defensive!("cannot migrate child key.");
+					return Ok(())
+				},
+			};
+
+			if let Some(current_child) = maybe_current_child.as_ref() {
+				let added_size = if let Some(data) = child_io::get(child_root, current_child) {
+					child_io::set(child_root, current_child, &data);
+					data.len() as u32
+				} else {
+					Zero::zero()
+				};
+				self.dyn_size = self.dyn_size.saturating_add(added_size);
+				self.dyn_child_items.saturating_inc();
+			}
+
+			log!(trace, "migrated a child key, next_child_key: {:?}", maybe_current_child);
+			self.progress_child = match maybe_current_child {
+				Some(last_child) => Progress::LastKey(last_child),
+				None => Progress::Complete,
+			};
+			Ok(())
+		}
+
+		/// Migrate the current top key, setting it to its new value, if one exists.
+		///
+		/// It updates the dynamic counters.
+		fn migrate_top(&mut self) -> Result<(), Error<T>> {
+			let maybe_current_top = match &self.progress_top {
+				Progress::LastKey(last_top) => {
+					let maybe_top: Option<BoundedVec<u8, T::MaxKeyLen>> =
+						if let Some(next) = sp_io::storage::next_key(last_top) {
+							Some(next.try_into().map_err(|_| Error::<T>::KeyTooLong)?)
+						} else {
+							None
+						};
+					maybe_top
+				},
+				// Start with the empty key as first key.
+				Progress::ToStart => Some(Default::default()),
+				Progress::Complete => {
+					// defensive: there must be an ongoing top migration.
+					frame_support::defensive!("cannot migrate top key.");
+					return Ok(())
+				},
+			};
+
+			if let Some(current_top) = maybe_current_top.as_ref() {
+				let added_size = if let Some(data) = sp_io::storage::get(current_top) {
+					sp_io::storage::set(current_top, &data);
+					data.len() as u32
+				} else {
+					Zero::zero()
+				};
+				self.dyn_size = self.dyn_size.saturating_add(added_size);
+				self.dyn_top_items.saturating_inc();
+			}
+
+			log!(trace, "migrated a top key, next_top_key = {:?}", maybe_current_top);
+			self.progress_top = match maybe_current_top {
+				Some(last_top) => Progress::LastKey(last_top),
+				None => Progress::Complete,
+			};
+			Ok(())
+		}
+	}
+
+	/// The limits of a migration.
+	#[derive(
+		Clone,
+		Copy,
+		Encode,
+		Decode,
+		scale_info::TypeInfo,
+		Default,
+		Debug,
+		PartialEq,
+		Eq,
+		MaxEncodedLen,
+	)]
+	pub struct MigrationLimits {
+		/// The byte size limit.
+		pub size: u32,
+		/// The number of keys limit.
+		pub item: u32,
+	}
+
+	/// How a migration was computed.
+	#[derive(Clone, Copy, Encode, Decode, scale_info::TypeInfo, Debug, PartialEq, Eq)]
+	pub enum MigrationCompute {
+		/// A signed origin triggered the migration.
+		Signed,
+		/// An automatic task triggered the migration.
+		Auto,
+	}
+
+	/// Inner events of this pallet.
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Given number of `(top, child)` keys were migrated respectively, with the given
+		/// `compute`.
+		Migrated { top: u32, child: u32, compute: MigrationCompute },
+		/// Some account got slashed by the given amount.
+		Slashed { who: T::AccountId, amount: BalanceOf<T> },
+		/// The auto migration task finished.
+		AutoMigrationFinished,
+		/// Migration got halted due to an error or miss-configuration.
+		Halted { error: Error<T> },
+	}
+
+	/// The outer Pallet struct.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Configurations of this pallet.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Origin that can control the configurations of this pallet.
+		type ControlOrigin: frame_support::traits::EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Filter on which origin that trigger the manual migrations.
+		type SignedFilter: EnsureOrigin<Self::RuntimeOrigin, Success = Self::AccountId>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The currency provider type.
+		type Currency: Currency<Self::AccountId>;
+
+		/// Maximal number of bytes that a key can have.
+		///
+		/// FRAME itself does not limit the key length.
+		/// The concrete value must therefore depend on your storage usage.
+		/// A [`frame_support::storage::StorageNMap`] for example can have an arbitrary number of
+		/// keys which are then hashed and concatenated, resulting in arbitrarily long keys.
+		///
+		/// Use the *state migration RPC* to retrieve the length of the longest key in your
+		/// storage: <https://github.com/paritytech/substrate/issues/11642>
+		///
+		/// The migration will halt with a `Halted` event if this value is too small.
+		/// Since there is no real penalty from over-estimating, it is advised to use a large
+		/// value. The default is 512 byte.
+		///
+		/// Some key lengths for reference:
+		/// - [`frame_support::storage::StorageValue`]: 32 byte
+		/// - [`frame_support::storage::StorageMap`]: 64 byte
+		/// - [`frame_support::storage::StorageDoubleMap`]: 96 byte
+		///
+		/// For more info see
+		/// <https://www.shawntabrizi.com/substrate/querying-substrate-storage-via-rpc/>
+
+		#[pallet::constant]
+		type MaxKeyLen: Get<u32>;
+
+		/// The amount of deposit collected per item in advance, for signed migrations.
+		///
+		/// This should reflect the average storage value size in the worse case.
+		type SignedDepositPerItem: Get<BalanceOf<Self>>;
+
+		/// The base value of [`Config::SignedDepositPerItem`].
+		///
+		/// Final deposit is `items * SignedDepositPerItem + SignedDepositBase`.
+		type SignedDepositBase: Get<BalanceOf<Self>>;
+
+		/// The weight information of this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// Migration progress.
+	///
+	/// This stores the snapshot of the last migrated keys. It can be set into motion and move
+	/// forward by any of the means provided by this pallet.
+	#[pallet::storage]
+	#[pallet::getter(fn migration_process)]
+	pub type MigrationProcess<T> = StorageValue<_, MigrationTask<T>, ValueQuery>;
+
+	/// The limits that are imposed on automatic migrations.
+	///
+	/// If set to None, then no automatic migration happens.
+	#[pallet::storage]
+	#[pallet::getter(fn auto_limits)]
+	pub type AutoLimits<T> = StorageValue<_, Option<MigrationLimits>, ValueQuery>;
+
+	/// The maximum limits that the signed migration could use.
+	///
+	/// If not set, no signed submission is allowed.
+	#[pallet::storage]
+	#[pallet::getter(fn signed_migration_max_limits)]
+	pub type SignedMigrationMaxLimits<T> = StorageValue<_, MigrationLimits, OptionQuery>;
+
+	#[pallet::error]
+	#[derive(Clone, PartialEq)]
+	pub enum Error<T> {
+		/// Max signed limits not respected.
+		MaxSignedLimits,
+		/// A key was longer than the configured maximum.
+		///
+		/// This means that the migration halted at the current [`Progress`] and
+		/// can be resumed with a larger [`crate::Config::MaxKeyLen`] value.
+		/// Retrying with the same [`crate::Config::MaxKeyLen`] value will not work.
+		/// The value should only be increased to avoid a storage migration for the currently
+		/// stored [`crate::Progress::LastKey`].
+		KeyTooLong,
+		/// submitter does not have enough funds.
+		NotEnoughFunds,
+		/// Bad witness data provided.
+		BadWitness,
+		/// Signed migration is not allowed because the maximum limit is not set yet.
+		SignedMigrationNotAllowed,
+		/// Bad child root provided.
+		BadChildRoot,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Control the automatic migration.
+		///
+		/// The dispatch origin of this call must be [`Config::ControlOrigin`].
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1))]
+		pub fn control_auto_migration(
+			origin: OriginFor<T>,
+			maybe_config: Option<MigrationLimits>,
+		) -> DispatchResult {
+			T::ControlOrigin::ensure_origin(origin)?;
+			AutoLimits::<T>::put(maybe_config);
+			Ok(())
+		}
+
+		/// Continue the migration for the given `limits`.
+		///
+		/// The dispatch origin of this call can be any signed account.
+		///
+		/// This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+		/// Upon successful execution, the transaction fee is returned.
+		///
+		/// The (potentially over-estimated) of the byte length of all the data read must be
+		/// provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+		/// that executing the current `MigrationTask` with the given `limits` will not exceed
+		/// `real_size_upper` bytes of read data.
+		///
+		/// The `witness_task` is merely a helper to prevent the caller from being slashed or
+		/// generally trigger a migration that they do not intend. This parameter is just a message
+		/// from caller, saying that they believed `witness_task` was the last state of the
+		/// migration, and they only wish for their transaction to do anything, if this assumption
+		/// holds. In case `witness_task` does not match, the transaction fails.
+		///
+		/// Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+		/// recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+		/// `size` limit can always be overwritten.
+		#[pallet::call_index(1)]
+		#[pallet::weight(
+			// the migration process
+			Pallet::<T>::dynamic_weight(limits.item, * real_size_upper)
+			// rest of the operations, like deposit etc.
+			+ T::WeightInfo::continue_migrate()
+		)]
+		pub fn continue_migrate(
+			origin: OriginFor<T>,
+			limits: MigrationLimits,
+			real_size_upper: u32,
+			witness_task: MigrationTask<T>,
+		) -> DispatchResultWithPostInfo {
+			let who = T::SignedFilter::ensure_origin(origin)?;
+
+			let max_limits =
+				Self::signed_migration_max_limits().ok_or(Error::<T>::SignedMigrationNotAllowed)?;
+			ensure!(
+				limits.size <= max_limits.size && limits.item <= max_limits.item,
+				Error::<T>::MaxSignedLimits,
+			);
+
+			// ensure they can pay more than the fee.
+			let deposit = T::SignedDepositPerItem::get().saturating_mul(limits.item.into());
+			ensure!(T::Currency::can_slash(&who, deposit), Error::<T>::NotEnoughFunds);
+
+			let mut task = Self::migration_process();
+			ensure!(
+				task == witness_task,
+				DispatchErrorWithPostInfo {
+					error: Error::<T>::BadWitness.into(),
+					post_info: PostDispatchInfo {
+						actual_weight: Some(T::WeightInfo::continue_migrate_wrong_witness()),
+						pays_fee: Pays::Yes
+					}
+				}
+			);
+			let migration = task.migrate_until_exhaustion(limits);
+
+			// ensure that the migration witness data was correct.
+			if real_size_upper < task.dyn_size {
+				// let the imbalance burn.
+				let (_imbalance, _remainder) = T::Currency::slash(&who, deposit);
+				Self::deposit_event(Event::<T>::Slashed { who, amount: deposit });
+				debug_assert!(_remainder.is_zero());
+				return Ok(().into())
+			}
+
+			Self::deposit_event(Event::<T>::Migrated {
+				top: task.dyn_top_items,
+				child: task.dyn_child_items,
+				compute: MigrationCompute::Signed,
+			});
+
+			// refund and correct the weight.
+			let actual_weight = Some(
+				Pallet::<T>::dynamic_weight(limits.item, task.dyn_size)
+					.saturating_add(T::WeightInfo::continue_migrate()),
+			);
+
+			MigrationProcess::<T>::put(task);
+			let post_info = PostDispatchInfo { actual_weight, pays_fee: Pays::No };
+			if let Err(error) = migration {
+				Self::halt(error);
+			}
+			Ok(post_info)
+		}
+
+		/// Migrate the list of top keys by iterating each of them one by one.
+		///
+		/// This does not affect the global migration process tracker ([`MigrationProcess`]), and
+		/// should only be used in case any keys are leftover due to a bug.
+		#[pallet::call_index(2)]
+		#[pallet::weight(
+			T::WeightInfo::migrate_custom_top_success()
+				.max(T::WeightInfo::migrate_custom_top_fail())
+			.saturating_add(
+				Pallet::<T>::dynamic_weight(keys.len() as u32, *witness_size)
+			)
+		)]
+		pub fn migrate_custom_top(
+			origin: OriginFor<T>,
+			keys: Vec<Vec<u8>>,
+			witness_size: u32,
+		) -> DispatchResultWithPostInfo {
+			let who = T::SignedFilter::ensure_origin(origin)?;
+
+			// ensure they can pay more than the fee.
+			let deposit = T::SignedDepositBase::get().saturating_add(
+				T::SignedDepositPerItem::get().saturating_mul((keys.len() as u32).into()),
+			);
+			ensure!(T::Currency::can_slash(&who, deposit), "not enough funds");
+
+			let mut dyn_size = 0u32;
+			for key in &keys {
+				if let Some(data) = sp_io::storage::get(key) {
+					dyn_size = dyn_size.saturating_add(data.len() as u32);
+					sp_io::storage::set(key, &data);
+				}
+			}
+
+			if dyn_size > witness_size {
+				let (_imbalance, _remainder) = T::Currency::slash(&who, deposit);
+				Self::deposit_event(Event::<T>::Slashed { who, amount: deposit });
+				debug_assert!(_remainder.is_zero());
+				Ok(().into())
+			} else {
+				Self::deposit_event(Event::<T>::Migrated {
+					top: keys.len() as u32,
+					child: 0,
+					compute: MigrationCompute::Signed,
+				});
+				Ok(PostDispatchInfo {
+					actual_weight: Some(
+						T::WeightInfo::migrate_custom_top_success().saturating_add(
+							Pallet::<T>::dynamic_weight(keys.len() as u32, dyn_size),
+						),
+					),
+					pays_fee: Pays::Yes,
+				})
+			}
+		}
+
+		/// Migrate the list of child keys by iterating each of them one by one.
+		///
+		/// All of the given child keys must be present under one `child_root`.
+		///
+		/// This does not affect the global migration process tracker ([`MigrationProcess`]), and
+		/// should only be used in case any keys are leftover due to a bug.
+		#[pallet::call_index(3)]
+		#[pallet::weight(
+			T::WeightInfo::migrate_custom_child_success()
+				.max(T::WeightInfo::migrate_custom_child_fail())
+			.saturating_add(
+				Pallet::<T>::dynamic_weight(child_keys.len() as u32, *total_size)
+			)
+		)]
+		pub fn migrate_custom_child(
+			origin: OriginFor<T>,
+			root: Vec<u8>,
+			child_keys: Vec<Vec<u8>>,
+			total_size: u32,
+		) -> DispatchResultWithPostInfo {
+			use sp_io::default_child_storage as child_io;
+			let who = T::SignedFilter::ensure_origin(origin)?;
+
+			// ensure they can pay more than the fee.
+			let deposit = T::SignedDepositBase::get().saturating_add(
+				T::SignedDepositPerItem::get().saturating_mul((child_keys.len() as u32).into()),
+			);
+			sp_std::if_std! {
+				println!("+ {:?} / {:?} / {:?}", who, deposit, T::Currency::free_balance(&who));
+			}
+			ensure!(T::Currency::can_slash(&who, deposit), "not enough funds");
+
+			let mut dyn_size = 0u32;
+			let transformed_child_key = Self::transform_child_key(&root).ok_or("bad child key")?;
+			for child_key in &child_keys {
+				if let Some(data) = child_io::get(transformed_child_key, child_key) {
+					dyn_size = dyn_size.saturating_add(data.len() as u32);
+					child_io::set(transformed_child_key, child_key, &data);
+				}
+			}
+
+			if dyn_size != total_size {
+				let (_imbalance, _remainder) = T::Currency::slash(&who, deposit);
+				debug_assert!(_remainder.is_zero());
+				Self::deposit_event(Event::<T>::Slashed { who, amount: deposit });
+				Ok(PostDispatchInfo {
+					actual_weight: Some(T::WeightInfo::migrate_custom_child_fail()),
+					pays_fee: Pays::Yes,
+				})
+			} else {
+				Self::deposit_event(Event::<T>::Migrated {
+					top: 0,
+					child: child_keys.len() as u32,
+					compute: MigrationCompute::Signed,
+				});
+				Ok(PostDispatchInfo {
+					actual_weight: Some(
+						T::WeightInfo::migrate_custom_child_success().saturating_add(
+							Pallet::<T>::dynamic_weight(child_keys.len() as u32, total_size),
+						),
+					),
+					pays_fee: Pays::Yes,
+				})
+			}
+		}
+
+		/// Set the maximum limit of the signed migration.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1))]
+		pub fn set_signed_max_limits(
+			origin: OriginFor<T>,
+			limits: MigrationLimits,
+		) -> DispatchResult {
+			let _ = T::ControlOrigin::ensure_origin(origin)?;
+			SignedMigrationMaxLimits::<T>::put(limits);
+			Ok(())
+		}
+
+		/// Forcefully set the progress the running migration.
+		///
+		/// This is only useful in one case: the next key to migrate is too big to be migrated with
+		/// a signed account, in a parachain context, and we simply want to skip it. A reasonable
+		/// example of this would be `:code:`, which is both very expensive to migrate, and commonly
+		/// used, so probably it is already migrated.
+		///
+		/// In case you mess things up, you can also, in principle, use this to reset the migration
+		/// process.
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::DbWeight::get().reads_writes(1, 1))]
+		pub fn force_set_progress(
+			origin: OriginFor<T>,
+			progress_top: ProgressOf<T>,
+			progress_child: ProgressOf<T>,
+		) -> DispatchResult {
+			let _ = T::ControlOrigin::ensure_origin(origin)?;
+			MigrationProcess::<T>::mutate(|task| {
+				task.progress_top = progress_top;
+				task.progress_child = progress_child;
+			});
+			Ok(())
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
+			if let Some(limits) = Self::auto_limits() {
+				let mut task = Self::migration_process();
+				if let Err(e) = task.migrate_until_exhaustion(limits) {
+					Self::halt(e);
+				}
+				let weight = Self::dynamic_weight(task.dyn_total_items(), task.dyn_size);
+
+				log!(
+					info,
+					"migrated {} top keys, {} child keys, and a total of {} bytes.",
+					task.dyn_top_items,
+					task.dyn_child_items,
+					task.dyn_size,
+				);
+
+				if task.finished() {
+					Self::deposit_event(Event::<T>::AutoMigrationFinished);
+					AutoLimits::<T>::kill();
+				} else {
+					Self::deposit_event(Event::<T>::Migrated {
+						top: task.dyn_top_items,
+						child: task.dyn_child_items,
+						compute: MigrationCompute::Auto,
+					});
+				}
+
+				MigrationProcess::<T>::put(task);
+
+				weight
+			} else {
+				T::DbWeight::get().reads(1)
+			}
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// The real weight of a migration of the given number of `items` with total `size`.
+		fn dynamic_weight(items: u32, size: u32) -> frame_support::pallet_prelude::Weight {
+			let items = items as u64;
+			<T as frame_system::Config>::DbWeight::get()
+				.reads_writes(1, 1)
+				.saturating_mul(items)
+				// we assume that the read/write per-byte weight is the same for child and top tree.
+				.saturating_add(T::WeightInfo::process_top_key(size))
+		}
+
+		/// Put a stop to all ongoing migrations and logs an error.
+		fn halt(error: Error<T>) {
+			log!(error, "migration halted due to: {:?}", error);
+			AutoLimits::<T>::kill();
+			Self::deposit_event(Event::<T>::Halted { error });
+		}
+
+		/// Convert a child root key, aka. "Child-bearing top key" into the proper format.
+		fn transform_child_key(root: &Vec<u8>) -> Option<&[u8]> {
+			use sp_core::storage::{ChildType, PrefixedStorageKey};
+			match ChildType::from_prefixed_key(PrefixedStorageKey::new_ref(root)) {
+				Some((ChildType::ParentKeyId, root)) => Some(root),
+				_ => None,
+			}
+		}
+
+		/// Same as [`child_io_key`], and it halts the auto/unsigned migrations if a bad child root
+		/// is used.
+		///
+		/// This should be used when we are sure that `root` is a correct default child root.
+		fn transform_child_key_or_halt(root: &Vec<u8>) -> &[u8] {
+			let key = Self::transform_child_key(root);
+			if key.is_none() {
+				Self::halt(Error::<T>::BadChildRoot);
+			}
+			key.unwrap_or_default()
+		}
+
+		/// Convert a child root to be in the default child-tree.
+		#[cfg(any(test, feature = "runtime-benchmarks"))]
+		pub(crate) fn childify(root: &'static str) -> Vec<u8> {
+			let mut string = DEFAULT_CHILD_STORAGE_KEY_PREFIX.to_vec();
+			string.extend_from_slice(root.as_ref());
+			string
+		}
+	}
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarks {
+	use super::{pallet::Pallet as StateTrieMigration, *};
+	use frame_support::traits::{Currency, Get};
+	use sp_runtime::traits::Saturating;
+	use sp_std::prelude::*;
+
+	// The size of the key seemingly makes no difference in the read/write time, so we make it
+	// constant.
+	const KEY: &[u8] = b"key";
+
+	frame_benchmarking::benchmarks! {
+		continue_migrate {
+			// note that this benchmark should migrate nothing, as we only want the overhead weight
+			// of the bookkeeping, and the migration cost itself is noted via the `dynamic_weight`
+			// function.
+			let null = MigrationLimits::default();
+			let caller = frame_benchmarking::whitelisted_caller();
+			// Allow signed migrations.
+			SignedMigrationMaxLimits::<T>::put(MigrationLimits { size: 1024, item: 5 });
+		}: _(frame_system::RawOrigin::Signed(caller), null, 0, StateTrieMigration::<T>::migration_process())
+		verify {
+			assert_eq!(StateTrieMigration::<T>::migration_process(), Default::default())
+		}
+
+		continue_migrate_wrong_witness {
+			let null = MigrationLimits::default();
+			let caller = frame_benchmarking::whitelisted_caller();
+			let bad_witness = MigrationTask { progress_top: Progress::LastKey(vec![1u8].try_into().unwrap()), ..Default::default() };
+		}: {
+			assert!(
+				StateTrieMigration::<T>::continue_migrate(
+					frame_system::RawOrigin::Signed(caller).into(),
+					null,
+					0,
+					bad_witness,
+				)
+				.is_err()
+			)
+		}
+		verify {
+			assert_eq!(StateTrieMigration::<T>::migration_process(), Default::default())
+		}
+
+		migrate_custom_top_success {
+			let null = MigrationLimits::default();
+			let caller = frame_benchmarking::whitelisted_caller();
+			let deposit = T::SignedDepositBase::get().saturating_add(
+				T::SignedDepositPerItem::get().saturating_mul(1u32.into()),
+			);
+			let stash = T::Currency::minimum_balance() * BalanceOf::<T>::from(1000u32) + deposit;
+			T::Currency::make_free_balance_be(&caller, stash);
+		}: migrate_custom_top(frame_system::RawOrigin::Signed(caller.clone()), Default::default(), 0)
+		verify {
+			assert_eq!(StateTrieMigration::<T>::migration_process(), Default::default());
+			assert_eq!(T::Currency::free_balance(&caller), stash)
+		}
+
+		migrate_custom_top_fail {
+			let null = MigrationLimits::default();
+			let caller = frame_benchmarking::whitelisted_caller();
+			let deposit = T::SignedDepositBase::get().saturating_add(
+				T::SignedDepositPerItem::get().saturating_mul(1u32.into()),
+			);
+			let stash = T::Currency::minimum_balance() * BalanceOf::<T>::from(1000u32) + deposit;
+			T::Currency::make_free_balance_be(&caller, stash);
+			// for tests, we need to make sure there is _something_ in storage that is being
+			// migrated.
+			sp_io::storage::set(b"foo", vec![1u8;33].as_ref());
+		}: {
+			assert!(
+				StateTrieMigration::<T>::migrate_custom_top(
+					frame_system::RawOrigin::Signed(caller.clone()).into(),
+					vec![b"foo".to_vec()],
+					1,
+				).is_ok()
+			);
+
+			frame_system::Pallet::<T>::assert_last_event(
+				<T as Config>::RuntimeEvent::from(crate::Event::Slashed {
+					who: caller.clone(),
+					amount: T::SignedDepositBase::get()
+						.saturating_add(T::SignedDepositPerItem::get().saturating_mul(1u32.into())),
+				}).into(),
+			);
+		}
+		verify {
+			assert_eq!(StateTrieMigration::<T>::migration_process(), Default::default());
+			// must have gotten slashed
+			assert!(T::Currency::free_balance(&caller) < stash)
+		}
+
+		migrate_custom_child_success {
+			let caller = frame_benchmarking::whitelisted_caller();
+			let deposit = T::SignedDepositBase::get().saturating_add(
+				T::SignedDepositPerItem::get().saturating_mul(1u32.into()),
+			);
+			let stash = T::Currency::minimum_balance() * BalanceOf::<T>::from(1000u32) + deposit;
+			T::Currency::make_free_balance_be(&caller, stash);
+		}: migrate_custom_child(
+			frame_system::RawOrigin::Signed(caller.clone()),
+			StateTrieMigration::<T>::childify(Default::default()),
+			Default::default(),
+			0
+		)
+		verify {
+			assert_eq!(StateTrieMigration::<T>::migration_process(), Default::default());
+			assert_eq!(T::Currency::free_balance(&caller), stash);
+		}
+
+		migrate_custom_child_fail {
+			let caller = frame_benchmarking::whitelisted_caller();
+			let deposit = T::SignedDepositBase::get().saturating_add(
+				T::SignedDepositPerItem::get().saturating_mul(1u32.into()),
+			);
+			let stash = T::Currency::minimum_balance() * BalanceOf::<T>::from(1000u32) + deposit;
+			T::Currency::make_free_balance_be(&caller, stash);
+			// for tests, we need to make sure there is _something_ in storage that is being
+			// migrated.
+			sp_io::default_child_storage::set(b"top", b"foo", vec![1u8;33].as_ref());
+		}: {
+			assert!(
+				StateTrieMigration::<T>::migrate_custom_child(
+					frame_system::RawOrigin::Signed(caller.clone()).into(),
+					StateTrieMigration::<T>::childify("top"),
+					vec![b"foo".to_vec()],
+					1,
+				).is_ok()
+			)
+		}
+		verify {
+			assert_eq!(StateTrieMigration::<T>::migration_process(), Default::default());
+			// must have gotten slashed
+			assert!(T::Currency::free_balance(&caller) < stash)
+		}
+
+		process_top_key {
+			let v in 1 .. (4 * 1024 * 1024);
+
+			let value = sp_std::vec![1u8; v as usize];
+			sp_io::storage::set(KEY, &value);
+		}: {
+			let data = sp_io::storage::get(KEY).unwrap();
+			sp_io::storage::set(KEY, &data);
+			let _next = sp_io::storage::next_key(KEY);
+			assert_eq!(data, value);
+		}
+
+		impl_benchmark_test_suite!(
+			StateTrieMigration,
+			crate::mock::new_test_ext(sp_runtime::StateVersion::V0, true, None, None),
+			crate::mock::Test
+		);
+	}
+}
+
+#[cfg(test)]
+mod mock {
+	use super::*;
+	use crate as pallet_state_trie_migration;
+	use frame_support::{
+		parameter_types,
+		traits::{ConstU32, ConstU64, Hooks},
+		weights::Weight,
+	};
+	use frame_system::{EnsureRoot, EnsureSigned};
+	use sp_core::{
+		storage::{ChildInfo, StateVersion},
+		H256,
+	};
+	use sp_runtime::{
+		traits::{BlakeTwo256, Header as _, IdentityLookup},
+		BuildStorage, StorageChild,
+	};
+
+	type Block = frame_system::mocking::MockBlockU32<Test>;
+
+	// 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>},
+			Balances: pallet_balances::{Pallet, Call, Config<T>, Storage, Event<T>},
+			StateTrieMigration: pallet_state_trie_migration::{Pallet, Call, Storage, Event<T>},
+		}
+	);
+
+	parameter_types! {
+		pub const SS58Prefix: u8 = 42;
+	}
+
+	impl frame_system::Config for Test {
+		type BaseCallFilter = frame_support::traits::Everything;
+		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 Block = Block;
+		type RuntimeEvent = RuntimeEvent;
+		type BlockHashCount = ConstU32<250>;
+		type DbWeight = ();
+		type Version = ();
+		type PalletInfo = PalletInfo;
+		type AccountData = pallet_balances::AccountData<u64>;
+		type OnNewAccount = ();
+		type OnKilledAccount = ();
+		type SystemWeightInfo = ();
+		type SS58Prefix = SS58Prefix;
+		type OnSetCode = ();
+		type MaxConsumers = ConstU32<16>;
+	}
+
+	parameter_types! {
+		pub const SignedDepositPerItem: u64 = 1;
+		pub const SignedDepositBase: u64 = 5;
+		pub const MigrationMaxKeyLen: u32 = 512;
+	}
+
+	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 MaxHolds = ();
+	}
+
+	/// Test only Weights for state migration.
+	pub struct StateMigrationTestWeight;
+
+	impl WeightInfo for StateMigrationTestWeight {
+		fn process_top_key(_: u32) -> Weight {
+			Weight::from_parts(1000000, 0)
+		}
+		fn continue_migrate() -> Weight {
+			Weight::from_parts(1000000, 0)
+		}
+		fn continue_migrate_wrong_witness() -> Weight {
+			Weight::from_parts(1000000, 0)
+		}
+		fn migrate_custom_top_fail() -> Weight {
+			Weight::from_parts(1000000, 0)
+		}
+		fn migrate_custom_top_success() -> Weight {
+			Weight::from_parts(1000000, 0)
+		}
+		fn migrate_custom_child_fail() -> Weight {
+			Weight::from_parts(1000000, 0)
+		}
+		fn migrate_custom_child_success() -> Weight {
+			Weight::from_parts(1000000, 0)
+		}
+	}
+
+	impl pallet_state_trie_migration::Config for Test {
+		type RuntimeEvent = RuntimeEvent;
+		type ControlOrigin = EnsureRoot<u64>;
+		type Currency = Balances;
+		type MaxKeyLen = MigrationMaxKeyLen;
+		type SignedDepositPerItem = SignedDepositPerItem;
+		type SignedDepositBase = SignedDepositBase;
+		type SignedFilter = EnsureSigned<Self::AccountId>;
+		type WeightInfo = StateMigrationTestWeight;
+	}
+
+	pub fn new_test_ext(
+		version: StateVersion,
+		with_pallets: bool,
+		custom_keys: Option<Vec<(Vec<u8>, Vec<u8>)>>,
+		custom_child: Option<Vec<(Vec<u8>, Vec<u8>, Vec<u8>)>>,
+	) -> sp_io::TestExternalities {
+		let minimum_size = sp_core::storage::TRIE_VALUE_NODE_THRESHOLD as usize + 1;
+		let mut custom_storage = sp_core::storage::Storage {
+			top: vec![
+				(b"key1".to_vec(), vec![1u8; minimum_size + 1]), // 6b657931
+				(b"key2".to_vec(), vec![1u8; minimum_size + 2]), // 6b657931
+				(b"key3".to_vec(), vec![1u8; minimum_size + 3]), // 6b657931
+				(b"key4".to_vec(), vec![1u8; minimum_size + 4]), // 6b657931
+				(b"key5".to_vec(), vec![1u8; minimum_size + 5]), // 6b657932
+				(b"key6".to_vec(), vec![1u8; minimum_size + 6]), // 6b657934
+				(b"key7".to_vec(), vec![1u8; minimum_size + 7]), // 6b657934
+				(b"key8".to_vec(), vec![1u8; minimum_size + 8]), // 6b657934
+				(b"key9".to_vec(), vec![1u8; minimum_size + 9]), // 6b657934
+				(b"CODE".to_vec(), vec![1u8; minimum_size + 100]), // 434f4445
+			]
+			.into_iter()
+			.chain(custom_keys.unwrap_or_default())
+			.collect(),
+			children_default: vec![
+				(
+					b"chk1".to_vec(), // 63686b31
+					StorageChild {
+						data: vec![
+							(b"key1".to_vec(), vec![1u8; 55]),
+							(b"key2".to_vec(), vec![2u8; 66]),
+						]
+						.into_iter()
+						.collect(),
+						child_info: ChildInfo::new_default(b"chk1"),
+					},
+				),
+				(
+					b"chk2".to_vec(),
+					StorageChild {
+						data: vec![
+							(b"key1".to_vec(), vec![1u8; 54]),
+							(b"key2".to_vec(), vec![2u8; 64]),
+						]
+						.into_iter()
+						.collect(),
+						child_info: ChildInfo::new_default(b"chk2"),
+					},
+				),
+			]
+			.into_iter()
+			.chain(
+				custom_child
+					.unwrap_or_default()
+					.into_iter()
+					.map(|(r, k, v)| {
+						(
+							r.clone(),
+							StorageChild {
+								data: vec![(k, v)].into_iter().collect(),
+								child_info: ChildInfo::new_default(&r),
+							},
+						)
+					})
+					.collect::<Vec<_>>(),
+			)
+			.collect(),
+		};
+
+		if with_pallets {
+			frame_system::GenesisConfig::<Test>::default()
+				.assimilate_storage(&mut custom_storage)
+				.unwrap();
+			pallet_balances::GenesisConfig::<Test> { balances: vec![(1, 1000)] }
+				.assimilate_storage(&mut custom_storage)
+				.unwrap();
+		}
+
+		sp_tracing::try_init_simple();
+		(custom_storage, version).into()
+	}
+
+	pub(crate) fn run_to_block(n: u32) -> (H256, Weight) {
+		let mut root = Default::default();
+		let mut weight_sum = Weight::zero();
+		log::trace!(target: LOG_TARGET, "running from {:?} to {:?}", System::block_number(), n);
+		while System::block_number() < n {
+			System::set_block_number(System::block_number() + 1);
+			System::on_initialize(System::block_number());
+
+			weight_sum += StateTrieMigration::on_initialize(System::block_number());
+
+			root = *System::finalize().state_root();
+			System::on_finalize(System::block_number());
+		}
+		(root, weight_sum)
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::{mock::*, *};
+	use frame_support::dispatch::*;
+	use sp_runtime::{bounded_vec, traits::Bounded, StateVersion};
+
+	#[test]
+	fn fails_if_no_migration() {
+		let mut ext = new_test_ext(StateVersion::V0, false, None, None);
+		let root1 = ext.execute_with(|| run_to_block(30).0);
+
+		let mut ext2 = new_test_ext(StateVersion::V1, false, None, None);
+		let root2 = ext2.execute_with(|| run_to_block(30).0);
+
+		// these two roots should not be the same.
+		assert_ne!(root1, root2);
+	}
+
+	#[test]
+	fn halts_if_top_key_too_long() {
+		let bad_key = vec![1u8; MigrationMaxKeyLen::get() as usize + 1];
+		let bad_top_keys = vec![(bad_key.clone(), vec![])];
+
+		new_test_ext(StateVersion::V0, true, Some(bad_top_keys), None).execute_with(|| {
+			System::set_block_number(1);
+			assert_eq!(MigrationProcess::<Test>::get(), Default::default());
+
+			// Allow signed migrations.
+			SignedMigrationMaxLimits::<Test>::put(MigrationLimits { size: 1 << 20, item: 50 });
+
+			// fails if the top key is too long.
+			frame_support::assert_ok!(StateTrieMigration::continue_migrate(
+				RuntimeOrigin::signed(1),
+				MigrationLimits { item: 50, size: 1 << 20 },
+				Bounded::max_value(),
+				MigrationProcess::<Test>::get()
+			),);
+			// The auto migration halted.
+			System::assert_last_event(
+				crate::Event::Halted { error: Error::<Test>::KeyTooLong }.into(),
+			);
+			// Limits are killed.
+			assert!(AutoLimits::<Test>::get().is_none());
+
+			// Calling `migrate_until_exhaustion` also fails.
+			let mut task = StateTrieMigration::migration_process();
+			let result = task.migrate_until_exhaustion(
+				StateTrieMigration::signed_migration_max_limits().unwrap(),
+			);
+			assert!(result.is_err());
+		});
+	}
+
+	#[test]
+	fn halts_if_child_key_too_long() {
+		let bad_key = vec![1u8; MigrationMaxKeyLen::get() as usize + 1];
+		let bad_child_keys = vec![(bad_key.clone(), vec![], vec![])];
+
+		new_test_ext(StateVersion::V0, true, None, Some(bad_child_keys)).execute_with(|| {
+			System::set_block_number(1);
+			assert_eq!(MigrationProcess::<Test>::get(), Default::default());
+
+			// Allow signed migrations.
+			SignedMigrationMaxLimits::<Test>::put(MigrationLimits { size: 1 << 20, item: 50 });
+
+			// fails if the top key is too long.
+			frame_support::assert_ok!(StateTrieMigration::continue_migrate(
+				RuntimeOrigin::signed(1),
+				MigrationLimits { item: 50, size: 1 << 20 },
+				Bounded::max_value(),
+				MigrationProcess::<Test>::get()
+			));
+			// The auto migration halted.
+			System::assert_last_event(
+				crate::Event::Halted { error: Error::<Test>::KeyTooLong }.into(),
+			);
+			// Limits are killed.
+			assert!(AutoLimits::<Test>::get().is_none());
+
+			// Calling `migrate_until_exhaustion` also fails.
+			let mut task = StateTrieMigration::migration_process();
+			let result = task.migrate_until_exhaustion(
+				StateTrieMigration::signed_migration_max_limits().unwrap(),
+			);
+			assert!(result.is_err());
+		});
+	}
+
+	#[test]
+	fn detects_value_in_empty_top_key() {
+		let limit = MigrationLimits { item: 1, size: 1000 };
+		let initial_keys = Some(vec![(vec![], vec![66u8; 77])]);
+		let mut ext = new_test_ext(StateVersion::V0, false, initial_keys.clone(), None);
+
+		let root_upgraded = ext.execute_with(|| {
+			AutoLimits::<Test>::put(Some(limit));
+			let root = run_to_block(30).0;
+
+			// eventually everything is over.
+			assert!(StateTrieMigration::migration_process().finished());
+			root
+		});
+
+		let mut ext2 = new_test_ext(StateVersion::V1, false, initial_keys, None);
+		let root = ext2.execute_with(|| {
+			AutoLimits::<Test>::put(Some(limit));
+			run_to_block(30).0
+		});
+
+		assert_eq!(root, root_upgraded);
+	}
+
+	#[test]
+	fn detects_value_in_first_child_key() {
+		let limit = MigrationLimits { item: 1, size: 1000 };
+		let initial_child = Some(vec![(b"chk1".to_vec(), vec![], vec![66u8; 77])]);
+		let mut ext = new_test_ext(StateVersion::V0, false, None, initial_child.clone());
+
+		let root_upgraded = ext.execute_with(|| {
+			AutoLimits::<Test>::put(Some(limit));
+			let root = run_to_block(30).0;
+
+			// eventually everything is over.
+			assert!(StateTrieMigration::migration_process().finished());
+			root
+		});
+
+		let mut ext2 = new_test_ext(StateVersion::V1, false, None, initial_child);
+		let root = ext2.execute_with(|| {
+			AutoLimits::<Test>::put(Some(limit));
+			run_to_block(30).0
+		});
+
+		assert_eq!(root, root_upgraded);
+	}
+
+	#[test]
+	fn auto_migrate_works() {
+		let run_with_limits = |limit, from, until| {
+			let mut ext = new_test_ext(StateVersion::V0, false, None, None);
+			let root_upgraded = ext.execute_with(|| {
+				assert_eq!(AutoLimits::<Test>::get(), None);
+				assert_eq!(MigrationProcess::<Test>::get(), Default::default());
+
+				// nothing happens if we don't set the limits.
+				let _ = run_to_block(from);
+				assert_eq!(MigrationProcess::<Test>::get(), Default::default());
+
+				// this should allow 1 item per block to be migrated.
+				AutoLimits::<Test>::put(Some(limit));
+
+				let root = run_to_block(until).0;
+
+				// eventually everything is over.
+				assert!(matches!(
+					StateTrieMigration::migration_process(),
+					MigrationTask { progress_top: Progress::Complete, .. }
+				));
+				root
+			});
+
+			let mut ext2 = new_test_ext(StateVersion::V1, false, None, None);
+			let root = ext2.execute_with(|| {
+				// update ex2 to contain the new items
+				let _ = run_to_block(from);
+				AutoLimits::<Test>::put(Some(limit));
+				run_to_block(until).0
+			});
+			assert_eq!(root, root_upgraded);
+		};
+
+		// single item
+		run_with_limits(MigrationLimits { item: 1, size: 1000 }, 10, 100);
+		// multi-item
+		run_with_limits(MigrationLimits { item: 5, size: 1000 }, 10, 100);
+		// multi-item, based on size. Note that largest value is 100 bytes.
+		run_with_limits(MigrationLimits { item: 1000, size: 128 }, 10, 100);
+		// unbounded
+		run_with_limits(
+			MigrationLimits { item: Bounded::max_value(), size: Bounded::max_value() },
+			10,
+			100,
+		);
+	}
+
+	#[test]
+	fn signed_migrate_works() {
+		new_test_ext(StateVersion::V0, true, None, None).execute_with(|| {
+			assert_eq!(MigrationProcess::<Test>::get(), Default::default());
+
+			// Allow signed migrations.
+			SignedMigrationMaxLimits::<Test>::put(MigrationLimits { size: 1024, item: 5 });
+
+			// can't submit if limit is too high.
+			frame_support::assert_err!(
+				StateTrieMigration::continue_migrate(
+					RuntimeOrigin::signed(1),
+					MigrationLimits { item: 5, size: sp_runtime::traits::Bounded::max_value() },
+					Bounded::max_value(),
+					MigrationProcess::<Test>::get()
+				),
+				Error::<Test>::MaxSignedLimits,
+			);
+
+			// can't submit if poor.
+			frame_support::assert_err!(
+				StateTrieMigration::continue_migrate(
+					RuntimeOrigin::signed(2),
+					MigrationLimits { item: 5, size: 100 },
+					100,
+					MigrationProcess::<Test>::get()
+				),
+				Error::<Test>::NotEnoughFunds,
+			);
+
+			// can't submit with bad witness.
+			frame_support::assert_err_ignore_postinfo!(
+				StateTrieMigration::continue_migrate(
+					RuntimeOrigin::signed(1),
+					MigrationLimits { item: 5, size: 100 },
+					100,
+					MigrationTask {
+						progress_top: Progress::LastKey(bounded_vec![1u8]),
+						..Default::default()
+					}
+				),
+				Error::<Test>::BadWitness,
+			);
+
+			// migrate all keys in a series of submissions
+			while !MigrationProcess::<Test>::get().finished() {
+				// first we compute the task to get the accurate consumption.
+				let mut task = StateTrieMigration::migration_process();
+				let result = task.migrate_until_exhaustion(
+					StateTrieMigration::signed_migration_max_limits().unwrap(),
+				);
+				assert!(result.is_ok());
+
+				frame_support::assert_ok!(StateTrieMigration::continue_migrate(
+					RuntimeOrigin::signed(1),
+					StateTrieMigration::signed_migration_max_limits().unwrap(),
+					task.dyn_size,
+					MigrationProcess::<Test>::get()
+				));
+
+				// no funds should remain reserved.
+				assert_eq!(Balances::reserved_balance(&1), 0);
+
+				// and the task should be updated
+				assert!(matches!(
+					StateTrieMigration::migration_process(),
+					MigrationTask { size: x, .. } if x > 0,
+				));
+			}
+		});
+	}
+
+	#[test]
+	fn custom_migrate_top_works() {
+		let correct_witness = 3 + sp_core::storage::TRIE_VALUE_NODE_THRESHOLD * 3 + 1 + 2 + 3;
+		new_test_ext(StateVersion::V0, true, None, None).execute_with(|| {
+			frame_support::assert_ok!(StateTrieMigration::migrate_custom_top(
+				RuntimeOrigin::signed(1),
+				vec![b"key1".to_vec(), b"key2".to_vec(), b"key3".to_vec()],
+				correct_witness,
+			));
+
+			// no funds should remain reserved.
+			assert_eq!(Balances::reserved_balance(&1), 0);
+			assert_eq!(Balances::free_balance(&1), 1000);
+		});
+
+		new_test_ext(StateVersion::V0, true, None, None).execute_with(|| {
+			// works if the witness is an overestimate
+			frame_support::assert_ok!(StateTrieMigration::migrate_custom_top(
+				RuntimeOrigin::signed(1),
+				vec![b"key1".to_vec(), b"key2".to_vec(), b"key3".to_vec()],
+				correct_witness + 99,
+			));
+
+			// no funds should remain reserved.
+			assert_eq!(Balances::reserved_balance(&1), 0);
+			assert_eq!(Balances::free_balance(&1), 1000);
+		});
+
+		new_test_ext(StateVersion::V0, true, None, None).execute_with(|| {
+			assert_eq!(Balances::free_balance(&1), 1000);
+
+			// note that we don't expect this to be a noop -- we do slash.
+			frame_support::assert_ok!(StateTrieMigration::migrate_custom_top(
+				RuntimeOrigin::signed(1),
+				vec![b"key1".to_vec(), b"key2".to_vec(), b"key3".to_vec()],
+				correct_witness - 1,
+			),);
+
+			// no funds should remain reserved.
+			assert_eq!(Balances::reserved_balance(&1), 0);
+			assert_eq!(
+				Balances::free_balance(&1),
+				1000 - (3 * SignedDepositPerItem::get() + SignedDepositBase::get())
+			);
+		});
+	}
+
+	#[test]
+	fn custom_migrate_child_works() {
+		new_test_ext(StateVersion::V0, true, None, None).execute_with(|| {
+			frame_support::assert_ok!(StateTrieMigration::migrate_custom_child(
+				RuntimeOrigin::signed(1),
+				StateTrieMigration::childify("chk1"),
+				vec![b"key1".to_vec(), b"key2".to_vec()],
+				55 + 66,
+			));
+
+			// no funds should remain reserved.
+			assert_eq!(Balances::reserved_balance(&1), 0);
+			assert_eq!(Balances::free_balance(&1), 1000);
+		});
+
+		new_test_ext(StateVersion::V0, true, None, None).execute_with(|| {
+			assert_eq!(Balances::free_balance(&1), 1000);
+
+			// note that we don't expect this to be a noop -- we do slash.
+			frame_support::assert_ok!(StateTrieMigration::migrate_custom_child(
+				RuntimeOrigin::signed(1),
+				StateTrieMigration::childify("chk1"),
+				vec![b"key1".to_vec(), b"key2".to_vec()],
+				999999, // wrong witness
+			));
+
+			// no funds should remain reserved.
+			assert_eq!(Balances::reserved_balance(&1), 0);
+			assert_eq!(
+				Balances::free_balance(&1),
+				1000 - (2 * SignedDepositPerItem::get() + SignedDepositBase::get())
+			);
+		});
+	}
+}
+
+/// Exported set of tests to be called against different runtimes.
+#[cfg(feature = "remote-test")]
+pub(crate) mod remote_tests {
+	use crate::{AutoLimits, MigrationLimits, Pallet as StateTrieMigration, LOG_TARGET};
+	use codec::Encode;
+	use frame_support::{
+		traits::{Get, Hooks},
+		weights::Weight,
+	};
+	use frame_system::{pallet_prelude::BlockNumberFor, Pallet as System};
+	use remote_externalities::Mode;
+	use sp_core::H256;
+	use sp_runtime::{
+		traits::{Block as BlockT, HashingFor, Header as _, One, Zero},
+		DeserializeOwned,
+	};
+	use thousands::Separable;
+
+	#[allow(dead_code)]
+	fn run_to_block<Runtime: crate::Config<Hash = H256>>(
+		n: BlockNumberFor<Runtime>,
+	) -> (H256, Weight) {
+		let mut root = Default::default();
+		let mut weight_sum = Weight::zero();
+		while System::<Runtime>::block_number() < n {
+			System::<Runtime>::set_block_number(System::<Runtime>::block_number() + One::one());
+			System::<Runtime>::on_initialize(System::<Runtime>::block_number());
+
+			weight_sum +=
+				StateTrieMigration::<Runtime>::on_initialize(System::<Runtime>::block_number());
+
+			root = System::<Runtime>::finalize().state_root().clone();
+			System::<Runtime>::on_finalize(System::<Runtime>::block_number());
+		}
+		(root, weight_sum)
+	}
+
+	/// Run the entire migration, against the given `Runtime`, until completion.
+	///
+	/// This will print some very useful statistics, make sure [`crate::LOG_TARGET`] is enabled.
+	#[allow(dead_code)]
+	pub(crate) async fn run_with_limits<Runtime, Block>(limits: MigrationLimits, mode: Mode<Block>)
+	where
+		Runtime: crate::Config<Hash = H256>,
+		Block: BlockT<Hash = H256> + DeserializeOwned,
+		Block::Header: serde::de::DeserializeOwned,
+	{
+		let mut ext = remote_externalities::Builder::<Block>::new()
+			.mode(mode)
+			.overwrite_state_version(sp_core::storage::StateVersion::V0)
+			.build()
+			.await
+			.unwrap();
+
+		let mut now = ext.execute_with(|| {
+			AutoLimits::<Runtime>::put(Some(limits));
+			// requires the block number type in our tests to be same as with mainnet, u32.
+			frame_system::Pallet::<Runtime>::block_number()
+		});
+
+		let mut duration: BlockNumberFor<Runtime> = Zero::zero();
+		// set the version to 1, as if the upgrade happened.
+		ext.state_version = sp_core::storage::StateVersion::V1;
+
+		let status =
+			substrate_state_trie_migration_rpc::migration_status(&ext.as_backend()).unwrap();
+		assert!(
+			status.top_remaining_to_migrate > 0,
+			"no node needs migrating, this probably means that state was initialized with `StateVersion::V1`",
+		);
+
+		log::info!(
+			target: LOG_TARGET,
+			"initial check: top_left: {}, child_left: {}, total_top {}, total_child {}",
+			status.top_remaining_to_migrate.separate_with_commas(),
+			status.child_remaining_to_migrate.separate_with_commas(),
+			status.total_top.separate_with_commas(),
+			status.total_child.separate_with_commas(),
+		);
+
+		loop {
+			let last_state_root = ext.backend.root().clone();
+			let ((finished, weight), proof) = ext.execute_and_prove(|| {
+				let weight = run_to_block::<Runtime>(now + One::one()).1;
+				if StateTrieMigration::<Runtime>::migration_process().finished() {
+					return (true, weight)
+				}
+				duration += One::one();
+				now += One::one();
+				(false, weight)
+			});
+
+			let compact_proof =
+				proof.clone().into_compact_proof::<HashingFor<Block>>(last_state_root).unwrap();
+			log::info!(
+				target: LOG_TARGET,
+				"proceeded to #{}, weight: [{} / {}], proof: [{} / {} / {}]",
+				now,
+				weight.separate_with_commas(),
+				<Runtime as frame_system::Config>::BlockWeights::get()
+					.max_block
+					.separate_with_commas(),
+				proof.encoded_size().separate_with_commas(),
+				compact_proof.encoded_size().separate_with_commas(),
+				zstd::stream::encode_all(&compact_proof.encode()[..], 0)
+					.unwrap()
+					.len()
+					.separate_with_commas(),
+			);
+			ext.commit_all().unwrap();
+
+			if finished {
+				break
+			}
+		}
+
+		ext.execute_with(|| {
+			log::info!(
+				target: LOG_TARGET,
+				"finished on_initialize migration in {} block, final state of the task: {:?}",
+				duration,
+				StateTrieMigration::<Runtime>::migration_process(),
+			)
+		});
+
+		let status =
+			substrate_state_trie_migration_rpc::migration_status(&ext.as_backend()).unwrap();
+		assert_eq!(status.top_remaining_to_migrate, 0);
+		assert_eq!(status.child_remaining_to_migrate, 0);
+	}
+}
+
+#[cfg(all(test, feature = "remote-test"))]
+mod remote_tests_local {
+	use super::{
+		mock::{RuntimeCall as MockCall, *},
+		remote_tests::run_with_limits,
+		*,
+	};
+	use remote_externalities::{Mode, OfflineConfig, OnlineConfig, SnapshotConfig};
+	use sp_runtime::traits::Bounded;
+	use std::env::var as env_var;
+
+	// we only use the hash type from this, so using the mock should be fine.
+	type Extrinsic = sp_runtime::testing::TestXt<MockCall, ()>;
+	type Block = sp_runtime::testing::Block<Extrinsic>;
+
+	#[tokio::test]
+	async fn on_initialize_migration() {
+		let snap: SnapshotConfig = env_var("SNAP").expect("Need SNAP env var").into();
+		let ws_api = env_var("WS_API").expect("Need WS_API env var").into();
+
+		sp_tracing::try_init_simple();
+		let mode = Mode::OfflineOrElseOnline(
+			OfflineConfig { state_snapshot: snap.clone() },
+			OnlineConfig { transport: ws_api, state_snapshot: Some(snap), ..Default::default() },
+		);
+
+		// item being the bottleneck
+		run_with_limits::<Test, Block>(
+			MigrationLimits { item: 8 * 1024, size: 128 * 1024 * 1024 },
+			mode.clone(),
+		)
+		.await;
+		// size being the bottleneck
+		run_with_limits::<Test, Block>(
+			MigrationLimits { item: Bounded::max_value(), size: 64 * 1024 },
+			mode,
+		)
+		.await;
+	}
+}
diff --git a/substrate/frame/state-trie-migration/src/weights.rs b/substrate/frame/state-trie-migration/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..df3338fdc17d3154c6febfdcae51b702614edc49
--- /dev/null
+++ b/substrate/frame/state-trie-migration/src/weights.rs
@@ -0,0 +1,219 @@
+// 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.
+
+//! Autogenerated weights for pallet_state_trie_migration
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_state_trie_migration
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/state-trie-migration/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_state_trie_migration.
+pub trait WeightInfo {
+	fn continue_migrate() -> Weight;
+	fn continue_migrate_wrong_witness() -> Weight;
+	fn migrate_custom_top_success() -> Weight;
+	fn migrate_custom_top_fail() -> Weight;
+	fn migrate_custom_child_success() -> Weight;
+	fn migrate_custom_child_fail() -> Weight;
+	fn process_top_key(v: u32, ) -> Weight;
+}
+
+/// Weights for pallet_state_trie_migration using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: StateTrieMigration SignedMigrationMaxLimits (r:1 w:0)
+	/// Proof: StateTrieMigration SignedMigrationMaxLimits (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: StateTrieMigration MigrationProcess (r:1 w:1)
+	/// Proof: StateTrieMigration MigrationProcess (max_values: Some(1), max_size: Some(1042), added: 1537, mode: MaxEncodedLen)
+	fn continue_migrate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `108`
+		//  Estimated: `2527`
+		// Minimum execution time: 14_297_000 picoseconds.
+		Weight::from_parts(14_832_000, 2527)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: StateTrieMigration SignedMigrationMaxLimits (r:1 w:0)
+	/// Proof: StateTrieMigration SignedMigrationMaxLimits (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn continue_migrate_wrong_witness() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `1493`
+		// Minimum execution time: 4_237_000 picoseconds.
+		Weight::from_parts(4_646_000, 1493)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	fn migrate_custom_top_success() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_898_000 picoseconds.
+		Weight::from_parts(9_237_000, 0)
+	}
+	/// Storage: unknown `0x666f6f` (r:1 w:1)
+	/// Proof Skipped: unknown `0x666f6f` (r:1 w:1)
+	fn migrate_custom_top_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `113`
+		//  Estimated: `3578`
+		// Minimum execution time: 29_291_000 picoseconds.
+		Weight::from_parts(30_424_000, 3578)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn migrate_custom_child_success() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_094_000 picoseconds.
+		Weight::from_parts(9_544_000, 0)
+	}
+	/// Storage: unknown `0x666f6f` (r:1 w:1)
+	/// Proof Skipped: unknown `0x666f6f` (r:1 w:1)
+	fn migrate_custom_child_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `105`
+		//  Estimated: `3570`
+		// Minimum execution time: 30_286_000 picoseconds.
+		Weight::from_parts(30_948_000, 3570)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: unknown `0x6b6579` (r:1 w:1)
+	/// Proof Skipped: unknown `0x6b6579` (r:1 w:1)
+	/// The range of component `v` is `[1, 4194304]`.
+	fn process_top_key(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `197 + v * (1 ±0)`
+		//  Estimated: `3662 + v * (1 ±0)`
+		// Minimum execution time: 5_420_000 picoseconds.
+		Weight::from_parts(5_560_000, 3662)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_139, 0).saturating_mul(v.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(v.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: StateTrieMigration SignedMigrationMaxLimits (r:1 w:0)
+	/// Proof: StateTrieMigration SignedMigrationMaxLimits (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: StateTrieMigration MigrationProcess (r:1 w:1)
+	/// Proof: StateTrieMigration MigrationProcess (max_values: Some(1), max_size: Some(1042), added: 1537, mode: MaxEncodedLen)
+	fn continue_migrate() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `108`
+		//  Estimated: `2527`
+		// Minimum execution time: 14_297_000 picoseconds.
+		Weight::from_parts(14_832_000, 2527)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: StateTrieMigration SignedMigrationMaxLimits (r:1 w:0)
+	/// Proof: StateTrieMigration SignedMigrationMaxLimits (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn continue_migrate_wrong_witness() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `1493`
+		// Minimum execution time: 4_237_000 picoseconds.
+		Weight::from_parts(4_646_000, 1493)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	fn migrate_custom_top_success() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_898_000 picoseconds.
+		Weight::from_parts(9_237_000, 0)
+	}
+	/// Storage: unknown `0x666f6f` (r:1 w:1)
+	/// Proof Skipped: unknown `0x666f6f` (r:1 w:1)
+	fn migrate_custom_top_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `113`
+		//  Estimated: `3578`
+		// Minimum execution time: 29_291_000 picoseconds.
+		Weight::from_parts(30_424_000, 3578)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn migrate_custom_child_success() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_094_000 picoseconds.
+		Weight::from_parts(9_544_000, 0)
+	}
+	/// Storage: unknown `0x666f6f` (r:1 w:1)
+	/// Proof Skipped: unknown `0x666f6f` (r:1 w:1)
+	fn migrate_custom_child_fail() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `105`
+		//  Estimated: `3570`
+		// Minimum execution time: 30_286_000 picoseconds.
+		Weight::from_parts(30_948_000, 3570)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: unknown `0x6b6579` (r:1 w:1)
+	/// Proof Skipped: unknown `0x6b6579` (r:1 w:1)
+	/// The range of component `v` is `[1, 4194304]`.
+	fn process_top_key(v: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `197 + v * (1 ±0)`
+		//  Estimated: `3662 + v * (1 ±0)`
+		// Minimum execution time: 5_420_000 picoseconds.
+		Weight::from_parts(5_560_000, 3662)
+			// Standard Error: 1
+			.saturating_add(Weight::from_parts(1_139, 0).saturating_mul(v.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(v.into()))
+	}
+}
diff --git a/substrate/frame/statement/Cargo.toml b/substrate/frame/statement/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4740c421d7f46bc984be5aa6c104b557b850aa28
--- /dev/null
+++ b/substrate/frame/statement/Cargo.toml
@@ -0,0 +1,50 @@
+[package]
+name = "pallet-statement"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for statement store"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"]}
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false,  path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-statement-store = { version = "4.0.0-dev", default-features = false, path = "../../primitives/statement-store" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-statement-store/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/statement/src/lib.rs b/substrate/frame/statement/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c68dac2d297227f337d765c1cb3a361ad0a36322
--- /dev/null
+++ b/substrate/frame/statement/src/lib.rs
@@ -0,0 +1,222 @@
+// 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.
+
+//! Supporting pallet for the statement store.
+//!
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! The Statement pallet provides means to create and validate statements for the statement store.
+//!
+//! For each statement validation function calculates the following three values based on the
+//! statement author balance:
+//! `max_count`: Maximum number of statements allowed for the author (signer) of this statement.
+//! `max_size`: Maximum total size of statements allowed for the author (signer) of this statement.
+//!
+//! This pallet also contains an offchain worker that turns on-chain statement events into
+//! statements. These statements are placed in the store and propagated over the network.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::{
+	pallet_prelude::*,
+	sp_runtime::{traits::CheckedDiv, SaturatedConversion},
+	traits::fungible::Inspect,
+};
+use frame_system::pallet_prelude::*;
+use sp_statement_store::{
+	runtime_api::{InvalidStatement, StatementSource, ValidStatement},
+	Proof, SignatureVerificationResult, Statement,
+};
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+pub use pallet::*;
+
+const LOG_TARGET: &str = "runtime::statement";
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	pub type BalanceOf<T> =
+		<<T as Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
+
+	pub type AccountIdOf<T> = <T as frame_system::Config>::AccountId;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::AccountId: From<sp_statement_store::AccountId>,
+	{
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// The currency which is used to calculate account limits.
+		type Currency: Inspect<Self::AccountId>;
+		/// Min balance for priority statements.
+		#[pallet::constant]
+		type StatementCost: Get<BalanceOf<Self>>;
+		/// Cost of data byte used for priority calculation.
+		#[pallet::constant]
+		type ByteCost: Get<BalanceOf<Self>>;
+		/// Minimum number of statements allowed per account.
+		#[pallet::constant]
+		type MinAllowedStatements: Get<u32>;
+		/// Maximum number of statements allowed per account.
+		#[pallet::constant]
+		type MaxAllowedStatements: Get<u32>;
+		/// Minimum data bytes allowed per account.
+		#[pallet::constant]
+		type MinAllowedBytes: Get<u32>;
+		/// Maximum data bytes allowed per account.
+		#[pallet::constant]
+		type MaxAllowedBytes: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(sp_std::marker::PhantomData<T>);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config>
+	where
+		<T as frame_system::Config>::AccountId: From<sp_statement_store::AccountId>,
+	{
+		/// A new statement is submitted
+		NewStatement { account: T::AccountId, statement: Statement },
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T>
+	where
+		<T as frame_system::Config>::AccountId: From<sp_statement_store::AccountId>,
+		sp_statement_store::AccountId: From<<T as frame_system::Config>::AccountId>,
+		<T as frame_system::Config>::RuntimeEvent: From<pallet::Event<T>>,
+		<T as frame_system::Config>::RuntimeEvent: TryInto<pallet::Event<T>>,
+		sp_statement_store::BlockHash: From<<T as frame_system::Config>::Hash>,
+	{
+		fn offchain_worker(now: BlockNumberFor<T>) {
+			log::trace!(target: LOG_TARGET, "Collecting statements at #{:?}", now);
+			Pallet::<T>::collect_statements();
+		}
+	}
+}
+
+impl<T: Config> Pallet<T>
+where
+	<T as frame_system::Config>::AccountId: From<sp_statement_store::AccountId>,
+	sp_statement_store::AccountId: From<<T as frame_system::Config>::AccountId>,
+	<T as frame_system::Config>::RuntimeEvent: From<pallet::Event<T>>,
+	<T as frame_system::Config>::RuntimeEvent: TryInto<pallet::Event<T>>,
+	sp_statement_store::BlockHash: From<<T as frame_system::Config>::Hash>,
+{
+	/// Validate a statement against current state. This is supposed to be called by the statement
+	/// store on the host side.
+	pub fn validate_statement(
+		_source: StatementSource,
+		mut statement: Statement,
+	) -> Result<ValidStatement, InvalidStatement> {
+		sp_io::init_tracing();
+		log::debug!(target: LOG_TARGET, "Validating statement {:?}", statement);
+		let account: T::AccountId = match statement.proof() {
+			Some(Proof::OnChain { who, block_hash, event_index }) => {
+				if frame_system::Pallet::<T>::parent_hash().as_ref() != block_hash.as_slice() {
+					log::debug!(target: LOG_TARGET, "Bad block hash.");
+					return Err(InvalidStatement::BadProof)
+				}
+				let account: T::AccountId = (*who).into();
+				match frame_system::Pallet::<T>::event_no_consensus(*event_index as usize) {
+					Some(e) => {
+						statement.remove_proof();
+						if let Ok(Event::NewStatement { account: a, statement: s }) = e.try_into() {
+							if a != account || s != statement {
+								log::debug!(target: LOG_TARGET, "Event data mismatch");
+								return Err(InvalidStatement::BadProof)
+							}
+						} else {
+							log::debug!(target: LOG_TARGET, "Event type mismatch");
+							return Err(InvalidStatement::BadProof)
+						}
+					},
+					_ => {
+						log::debug!(target: LOG_TARGET, "Bad event index");
+						return Err(InvalidStatement::BadProof)
+					},
+				}
+				account
+			},
+			_ => match statement.verify_signature() {
+				SignatureVerificationResult::Valid(account) => account.into(),
+				SignatureVerificationResult::Invalid => {
+					log::debug!(target: LOG_TARGET, "Bad statement signature.");
+					return Err(InvalidStatement::BadProof)
+				},
+				SignatureVerificationResult::NoSignature => {
+					log::debug!(target: LOG_TARGET, "Missing statement signature.");
+					return Err(InvalidStatement::NoProof)
+				},
+			},
+		};
+		let statement_cost = T::StatementCost::get();
+		let byte_cost = T::ByteCost::get();
+		let balance = <T::Currency as Inspect<AccountIdOf<T>>>::balance(&account);
+		let min_allowed_statements = T::MinAllowedStatements::get();
+		let max_allowed_statements = T::MaxAllowedStatements::get();
+		let min_allowed_bytes = T::MinAllowedBytes::get();
+		let max_allowed_bytes = T::MaxAllowedBytes::get();
+		let max_count = balance
+			.checked_div(&statement_cost)
+			.unwrap_or_default()
+			.saturated_into::<u32>()
+			.clamp(min_allowed_statements, max_allowed_statements);
+		let max_size = balance
+			.checked_div(&byte_cost)
+			.unwrap_or_default()
+			.saturated_into::<u32>()
+			.clamp(min_allowed_bytes, max_allowed_bytes);
+
+		Ok(ValidStatement { max_count, max_size })
+	}
+
+	/// Submit a statement event. The statement will be picked up by the offchain worker and
+	/// broadcast to the network.
+	pub fn submit_statement(account: T::AccountId, statement: Statement) {
+		Self::deposit_event(Event::NewStatement { account, statement });
+	}
+
+	fn collect_statements() {
+		// Find `NewStatement` events and submit them to the store
+		for (index, event) in frame_system::Pallet::<T>::read_events_no_consensus().enumerate() {
+			if let Ok(Event::<T>::NewStatement { account, mut statement }) = event.event.try_into()
+			{
+				if statement.proof().is_none() {
+					let proof = Proof::OnChain {
+						who: account.into(),
+						block_hash: frame_system::Pallet::<T>::parent_hash().into(),
+						event_index: index as u64,
+					};
+					statement.set_proof(proof);
+				}
+				sp_statement_store::runtime_api::statement_store::submit_statement(statement);
+			}
+		}
+	}
+}
diff --git a/substrate/frame/statement/src/mock.rs b/substrate/frame/statement/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..79d2aa7d891d5015b20d71447e71ef42f287b141
--- /dev/null
+++ b/substrate/frame/statement/src/mock.rs
@@ -0,0 +1,120 @@
+// 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.
+
+//! # Statement pallet test environment.
+
+use super::*;
+
+use crate as pallet_statement;
+use frame_support::{
+	ord_parameter_types,
+	traits::{ConstU32, ConstU64, Everything},
+	weights::constants::RocksDbWeight,
+};
+use sp_core::{Pair, H256};
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	AccountId32, BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+pub const MIN_ALLOWED_STATEMENTS: u32 = 4;
+pub const MAX_ALLOWED_STATEMENTS: u32 = 10;
+pub const MIN_ALLOWED_BYTES: u32 = 1024;
+pub const MAX_ALLOWED_BYTES: u32 = 4096;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Statement: pallet_statement,
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = RocksDbWeight;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = u64;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = AccountId32;
+	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>;
+}
+
+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 MaxHolds = ();
+}
+
+ord_parameter_types! {
+	pub const One: u64 = 1;
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type StatementCost = ConstU64<1000>;
+	type ByteCost = ConstU64<2>;
+	type MinAllowedStatements = ConstU32<MIN_ALLOWED_STATEMENTS>;
+	type MaxAllowedStatements = ConstU32<MAX_ALLOWED_STATEMENTS>;
+	type MinAllowedBytes = ConstU32<MIN_ALLOWED_BYTES>;
+	type MaxAllowedBytes = ConstU32<MAX_ALLOWED_BYTES>;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let balances = pallet_balances::GenesisConfig::<Test> {
+		balances: vec![
+			(sp_core::sr25519::Pair::from_string("//Alice", None).unwrap().public().into(), 6000),
+			(
+				sp_core::sr25519::Pair::from_string("//Charlie", None).unwrap().public().into(),
+				500000,
+			),
+		],
+	};
+	balances.assimilate_storage(&mut t).unwrap();
+	t.into()
+}
diff --git a/substrate/frame/statement/src/tests.rs b/substrate/frame/statement/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51103caca60fa67b7c9cd0bcef237213b79ac574
--- /dev/null
+++ b/substrate/frame/statement/src/tests.rs
@@ -0,0 +1,159 @@
+// 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.
+
+//! # Statement runtime support tests.
+
+#![cfg(test)]
+
+use super::*;
+use crate::mock::*;
+use sp_core::Pair;
+use sp_runtime::AccountId32;
+use sp_statement_store::{
+	runtime_api::{InvalidStatement, StatementSource, ValidStatement},
+	Proof, Statement,
+};
+
+#[test]
+fn sign_and_validate_no_balance() {
+	new_test_ext().execute_with(|| {
+		let pair = sp_core::sr25519::Pair::from_string("//Bob", None).unwrap();
+		let mut statement = Statement::new();
+		statement.sign_sr25519_private(&pair);
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(
+			Ok(ValidStatement { max_count: MIN_ALLOWED_STATEMENTS, max_size: MIN_ALLOWED_BYTES }),
+			result
+		);
+
+		let pair = sp_core::ed25519::Pair::from_string("//Bob", None).unwrap();
+		let mut statement = Statement::new();
+		statement.sign_ed25519_private(&pair);
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(
+			Ok(ValidStatement { max_count: MIN_ALLOWED_STATEMENTS, max_size: MIN_ALLOWED_BYTES }),
+			result
+		);
+
+		let pair = sp_core::ecdsa::Pair::from_string("//Bob", None).unwrap();
+		let mut statement = Statement::new();
+		statement.sign_ecdsa_private(&pair);
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(
+			Ok(ValidStatement { max_count: MIN_ALLOWED_STATEMENTS, max_size: MIN_ALLOWED_BYTES }),
+			result
+		);
+	});
+}
+
+#[test]
+fn validate_with_balance() {
+	new_test_ext().execute_with(|| {
+		let pair = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let mut statement = Statement::new();
+		statement.sign_sr25519_private(&pair);
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(Ok(ValidStatement { max_count: 6, max_size: 3000 }), result);
+
+		let pair = sp_core::sr25519::Pair::from_string("//Charlie", None).unwrap();
+		let mut statement = Statement::new();
+		statement.sign_sr25519_private(&pair);
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(
+			Ok(ValidStatement { max_count: MAX_ALLOWED_STATEMENTS, max_size: MAX_ALLOWED_BYTES }),
+			result
+		);
+	});
+}
+
+#[test]
+fn validate_no_proof_fails() {
+	new_test_ext().execute_with(|| {
+		let statement = Statement::new();
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(Err(InvalidStatement::NoProof), result);
+	});
+}
+
+#[test]
+fn validate_bad_signature_fails() {
+	new_test_ext().execute_with(|| {
+		let statement = Statement::new_with_proof(Proof::Sr25519 {
+			signature: [0u8; 64],
+			signer: Default::default(),
+		});
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(Err(InvalidStatement::BadProof), result);
+	});
+}
+
+#[test]
+fn validate_event() {
+	new_test_ext().execute_with(|| {
+		let parent_hash = sp_core::H256::random();
+		System::reset_events();
+		System::initialize(&1, &parent_hash, &Default::default());
+		let mut statement = Statement::new();
+		let pair = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let account: AccountId32 = pair.public().into();
+		Pallet::<Test>::submit_statement(account.clone(), statement.clone());
+		statement.set_proof(Proof::OnChain {
+			who: account.clone().into(),
+			event_index: 0,
+			block_hash: parent_hash.into(),
+		});
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement.clone());
+		assert_eq!(Ok(ValidStatement { max_count: 6, max_size: 3000 }), result);
+
+		// Use wrong event index
+		statement.set_proof(Proof::OnChain {
+			who: account.clone().into(),
+			event_index: 1,
+			block_hash: parent_hash.into(),
+		});
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement.clone());
+		assert_eq!(Err(InvalidStatement::BadProof), result);
+
+		// Use wrong block hash
+		statement.set_proof(Proof::OnChain {
+			who: account.clone().into(),
+			event_index: 0,
+			block_hash: sp_core::H256::random().into(),
+		});
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement.clone());
+		assert_eq!(Err(InvalidStatement::BadProof), result);
+	});
+}
+
+#[test]
+fn validate_no_event_fails() {
+	new_test_ext().execute_with(|| {
+		let parent_hash = sp_core::H256::random();
+		System::reset_events();
+		System::initialize(&1, &parent_hash, &Default::default());
+		let mut statement = Statement::new();
+		let pair = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let account: AccountId32 = pair.public().into();
+		statement.set_proof(Proof::OnChain {
+			who: account.into(),
+			event_index: 0,
+			block_hash: parent_hash.into(),
+		});
+		let result = Pallet::<Test>::validate_statement(StatementSource::Chain, statement);
+		assert_eq!(Err(InvalidStatement::BadProof), result);
+	});
+}
diff --git a/substrate/frame/sudo/Cargo.toml b/substrate/frame/sudo/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ed46ad53c2f61dce29b4accc795c45a316384182
--- /dev/null
+++ b/substrate/frame/sudo/Cargo.toml
@@ -0,0 +1,51 @@
+[package]
+name = "pallet-sudo"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for sudo"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/sudo/README.md b/substrate/frame/sudo/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..886dc5981778d2c05dba38f6f711e23e9d5e7b50
--- /dev/null
+++ b/substrate/frame/sudo/README.md
@@ -0,0 +1,77 @@
+# Sudo Module
+
+- [`Config`](https://docs.rs/pallet-sudo/latest/pallet_sudo/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-sudo/latest/pallet_sudo/pallet/enum.Call.html)
+
+## Overview
+
+The Sudo module allows for a single account (called the "sudo key")
+to execute dispatchable functions that require a `Root` call
+or designate a new account to replace them as the sudo key.
+Only one account can be the sudo key at a time.
+
+## Interface
+
+### Dispatchable Functions
+
+Only the sudo key can call the dispatchable functions from the Sudo module.
+
+* `sudo` - Make a `Root` call to a dispatchable function.
+* `set_key` - Assign a new account to be the sudo key.
+
+## Usage
+
+### Executing Privileged Functions
+
+The Sudo module itself is not intended to be used within other modules.
+Instead, you can build "privileged functions" (i.e. functions that require `Root` origin) in other modules.
+You can execute these privileged functions by calling `sudo` with the sudo key account.
+Privileged functions cannot be directly executed via an extrinsic.
+
+Learn more about privileged functions and `Root` origin in the [`Origin`] type documentation.
+
+### Simple Code Snippet
+
+This is an example of a module that exposes a privileged function:
+
+```rust
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config {}
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::weight(0)]
+        pub fn privileged_function(origin: OriginFor<T>) -> DispatchResult {
+            ensure_root(origin)?;
+
+            // do something...
+
+            Ok(())
+        }
+    }
+}
+```
+
+## Genesis Config
+
+The Sudo module depends on the [`GenesisConfig`](https://docs.rs/pallet-sudo/latest/pallet_sudo/struct.GenesisConfig.html).
+You need to set an initial superuser account as the sudo `key`.
+
+## Related Modules
+
+* [Democracy](https://docs.rs/pallet-democracy/latest/pallet_democracy/)
+
+[`Call`]: ./enum.Call.html
+[`Config`]: ./trait.Config.html
+[`Origin`]: https://docs.substrate.io/main-docs/build/origins/
+
+License: Apache-2.0
diff --git a/substrate/frame/sudo/src/benchmarking.rs b/substrate/frame/sudo/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6a365c1873c1de4580f0f69310180ddc4df18d58
--- /dev/null
+++ b/substrate/frame/sudo/src/benchmarking.rs
@@ -0,0 +1,79 @@
+// 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.
+
+//! Benchmarks for Sudo Pallet
+
+use super::*;
+use crate::Pallet;
+use frame_benchmarking::v2::*;
+use frame_system::RawOrigin;
+
+const SEED: u32 = 0;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+#[benchmarks( where <T as Config>::RuntimeCall: From<frame_system::Call<T>>)]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn set_key() {
+		let caller: T::AccountId = whitelisted_caller();
+		Key::<T>::put(caller.clone());
+
+		let new_sudoer: T::AccountId = account("sudoer", 0, SEED);
+		let new_sudoer_lookup = T::Lookup::unlookup(new_sudoer.clone());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), new_sudoer_lookup);
+
+		assert_last_event::<T>(Event::KeyChanged { old_sudoer: Some(caller) }.into());
+	}
+
+	#[benchmark]
+	fn sudo() {
+		let caller: T::AccountId = whitelisted_caller();
+		Key::<T>::put(caller.clone());
+
+		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller.clone()), Box::new(call.clone()));
+
+		assert_last_event::<T>(Event::Sudid { sudo_result: Ok(()) }.into())
+	}
+
+	#[benchmark]
+	fn sudo_as() {
+		let caller: T::AccountId = whitelisted_caller();
+		Key::<T>::put(caller.clone());
+
+		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark: vec![] }.into();
+
+		let who: T::AccountId = account("as", 0, SEED);
+		let who_lookup = T::Lookup::unlookup(who.clone());
+
+		#[extrinsic_call]
+		_(RawOrigin::Signed(caller), who_lookup, Box::new(call.clone()));
+
+		assert_last_event::<T>(Event::SudoAsDone { sudo_result: Ok(()) }.into())
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_bench_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/sudo/src/extension.rs b/substrate/frame/sudo/src/extension.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c717ff3567268ae7bf868120d6411d1abe63c712
--- /dev/null
+++ b/substrate/frame/sudo/src/extension.rs
@@ -0,0 +1,107 @@
+// 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::{Config, Pallet};
+use codec::{Decode, Encode};
+use frame_support::{dispatch::DispatchInfo, ensure};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, Dispatchable, SignedExtension},
+	transaction_validity::{
+		InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,
+		UnknownTransaction, ValidTransaction,
+	},
+};
+use sp_std::{fmt, marker::PhantomData};
+
+/// Ensure that signed transactions are only valid if they are signed by sudo account.
+///
+/// In the initial phase of a chain without any tokens you can not prevent accounts from sending
+/// transactions.
+/// These transactions would enter the transaction pool as the succeed the validation, but would
+/// fail on applying them as they are not allowed/disabled/whatever. This would be some huge dos
+/// vector to any kind of chain. This extension solves the dos vector by preventing any kind of
+/// transaction entering the pool as long as it is not signed by the sudo account.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckOnlySudoAccount<T: Config + Send + Sync>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> Default for CheckOnlySudoAccount<T> {
+	fn default() -> Self {
+		Self(Default::default())
+	}
+}
+
+impl<T: Config + Send + Sync> fmt::Debug for CheckOnlySudoAccount<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "CheckOnlySudoAccount")
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> CheckOnlySudoAccount<T> {
+	/// Creates new `SignedExtension` to check sudo key.
+	pub fn new() -> Self {
+		Self::default()
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckOnlySudoAccount<T>
+where
+	<T as Config>::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+{
+	const IDENTIFIER: &'static str = "CheckOnlySudoAccount";
+	type AccountId = T::AccountId;
+	type Call = <T as Config>::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(())
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		_call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		let sudo_key: T::AccountId = <Pallet<T>>::key().ok_or(UnknownTransaction::CannotLookup)?;
+		ensure!(*who == sudo_key, InvalidTransaction::BadSigner);
+
+		Ok(ValidTransaction {
+			priority: info.weight.ref_time() as TransactionPriority,
+			..Default::default()
+		})
+	}
+
+	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/sudo/src/lib.rs b/substrate/frame/sudo/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f735469558c70b18c3cb6ea93a77c39979b4cb6a
--- /dev/null
+++ b/substrate/frame/sudo/src/lib.rs
@@ -0,0 +1,299 @@
+// 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.
+
+//! # Sudo Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! The Sudo pallet allows for a single account (called the "sudo key")
+//! to execute dispatchable functions that require a `Root` call
+//! or designate a new account to replace them as the sudo key.
+//! Only one account can be the sudo key at a time.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! Only the sudo key can call the dispatchable functions from the Sudo pallet.
+//!
+//! * `sudo` - Make a `Root` call to a dispatchable function.
+//! * `set_key` - Assign a new account to be the sudo key.
+//!
+//! ## Usage
+//!
+//! ### Executing Privileged Functions
+//!
+//! The Sudo pallet itself is not intended to be used within other pallets.
+//! Instead, you can build "privileged functions" (i.e. functions that require `Root` origin) in
+//! other pallets. You can execute these privileged functions by calling `sudo` with the sudo key
+//! account. Privileged functions cannot be directly executed via an extrinsic.
+//!
+//! Learn more about privileged functions and `Root` origin in the [`Origin`] type documentation.
+//!
+//! ### Simple Code Snippet
+//!
+//! This is an example of a pallet that exposes a privileged function:
+//!
+//! ```
+//! #[frame_support::pallet]
+//! pub mod pallet {
+//! 	use super::*;
+//! 	use frame_support::pallet_prelude::*;
+//! 	use frame_system::pallet_prelude::*;
+//!
+//! 	#[pallet::pallet]
+//! 	pub struct Pallet<T>(_);
+//!
+//! 	#[pallet::config]
+//! 	pub trait Config: frame_system::Config {}
+//!
+//! 	#[pallet::call]
+//! 	impl<T: Config> Pallet<T> {
+//! 		#[pallet::weight(0)]
+//!         pub fn privileged_function(origin: OriginFor<T>) -> DispatchResult {
+//!             ensure_root(origin)?;
+//!
+//!             // do something...
+//!
+//!             Ok(())
+//!         }
+//! 	}
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! ### Signed Extension
+//!
+//! The Sudo pallet defines the following extension:
+//!
+//!   - [`CheckOnlySudoAccount`]: Ensures that the signed transactions are only valid if they are
+//!     signed by sudo account.
+//!
+//! ## Genesis Config
+//!
+//! The Sudo pallet depends on the [`GenesisConfig`].
+//! You need to set an initial superuser account as the sudo `key`.
+//!
+//! ## Related Pallets
+//!
+//! * [Democracy](../pallet_democracy/index.html)
+//!
+//! [`Origin`]: https://docs.substrate.io/main-docs/build/origins/
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_runtime::{traits::StaticLookup, DispatchResult};
+use sp_std::prelude::*;
+
+use frame_support::{dispatch::GetDispatchInfo, traits::UnfilteredDispatchable};
+
+mod extension;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+pub mod weights;
+pub use weights::WeightInfo;
+
+pub use extension::CheckOnlySudoAccount;
+pub use pallet::*;
+
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::{DispatchResult, *};
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// A sudo-able call.
+		type RuntimeCall: Parameter
+			+ UnfilteredDispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ GetDispatchInfo;
+
+		/// Type representing the weight of this pallet
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Authenticates the sudo key and dispatches a function call with `Root` origin.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(0)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::sudo().saturating_add(dispatch_info.weight),
+				dispatch_info.class
+			)
+		})]
+		pub fn sudo(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			// This is a public call, so we ensure that the origin is some signed account.
+			let sender = ensure_signed(origin)?;
+			ensure!(Self::key().map_or(false, |k| sender == k), Error::<T>::RequireSudo);
+
+			let res = call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into());
+			Self::deposit_event(Event::Sudid { sudo_result: res.map(|_| ()).map_err(|e| e.error) });
+			// Sudo user does not pay a fee.
+			Ok(Pays::No.into())
+		}
+
+		/// Authenticates the sudo key and dispatches a function call with `Root` origin.
+		/// This function does not check the weight of the call, and instead allows the
+		/// Sudo user to specify the weight of the call.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(1)]
+		#[pallet::weight((*_weight, call.get_dispatch_info().class))]
+		pub fn sudo_unchecked_weight(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+			_weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			// This is a public call, so we ensure that the origin is some signed account.
+			let sender = ensure_signed(origin)?;
+			ensure!(Self::key().map_or(false, |k| sender == k), Error::<T>::RequireSudo);
+
+			let res = call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into());
+			Self::deposit_event(Event::Sudid { sudo_result: res.map(|_| ()).map_err(|e| e.error) });
+			// Sudo user does not pay a fee.
+			Ok(Pays::No.into())
+		}
+
+		/// Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo
+		/// key.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::set_key())]
+		pub fn set_key(
+			origin: OriginFor<T>,
+			new: AccountIdLookupOf<T>,
+		) -> DispatchResultWithPostInfo {
+			// This is a public call, so we ensure that the origin is some signed account.
+			let sender = ensure_signed(origin)?;
+			ensure!(Self::key().map_or(false, |k| sender == k), Error::<T>::RequireSudo);
+			let new = T::Lookup::lookup(new)?;
+
+			Self::deposit_event(Event::KeyChanged { old_sudoer: Key::<T>::get() });
+			Key::<T>::put(&new);
+			// Sudo user does not pay a fee.
+			Ok(Pays::No.into())
+		}
+
+		/// Authenticates the sudo key and dispatches a function call with `Signed` origin from
+		/// a given account.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(3)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::sudo_as().saturating_add(dispatch_info.weight),
+				dispatch_info.class,
+			)
+		})]
+		pub fn sudo_as(
+			origin: OriginFor<T>,
+			who: AccountIdLookupOf<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			// This is a public call, so we ensure that the origin is some signed account.
+			let sender = ensure_signed(origin)?;
+			ensure!(Self::key().map_or(false, |k| sender == k), Error::<T>::RequireSudo);
+
+			let who = T::Lookup::lookup(who)?;
+
+			let res = call.dispatch_bypass_filter(frame_system::RawOrigin::Signed(who).into());
+
+			Self::deposit_event(Event::SudoAsDone {
+				sudo_result: res.map(|_| ()).map_err(|e| e.error),
+			});
+			// Sudo user does not pay a fee.
+			Ok(Pays::No.into())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A sudo just took place. \[result\]
+		Sudid { sudo_result: DispatchResult },
+		/// The \[sudoer\] just switched identity; the old key is supplied if one existed.
+		KeyChanged { old_sudoer: Option<T::AccountId> },
+		/// A sudo just took place. \[result\]
+		SudoAsDone { sudo_result: DispatchResult },
+	}
+
+	#[pallet::error]
+	/// Error for the Sudo pallet
+	pub enum Error<T> {
+		/// Sender must be the Sudo account
+		RequireSudo,
+	}
+
+	/// The `AccountId` of the sudo key.
+	#[pallet::storage]
+	#[pallet::getter(fn key)]
+	pub(super) type Key<T: Config> = StorageValue<_, T::AccountId, OptionQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		/// The `AccountId` of the sudo key.
+		pub key: Option<T::AccountId>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			if let Some(ref key) = self.key {
+				Key::<T>::put(key);
+			}
+		}
+	}
+}
diff --git a/substrate/frame/sudo/src/mock.rs b/substrate/frame/sudo/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9e78e474f4e5a6dd030b39254f7fd7fb65cc7a54
--- /dev/null
+++ b/substrate/frame/sudo/src/mock.rs
@@ -0,0 +1,165 @@
+// 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.
+
+//! Test utilities
+
+use super::*;
+use crate as sudo;
+use frame_support::traits::{ConstU32, ConstU64, Contains};
+use sp_core::H256;
+use sp_io;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+// Logger module to track execution.
+#[frame_support::pallet]
+pub mod logger {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight(*weight)]
+		pub fn privileged_i32_log(
+			origin: OriginFor<T>,
+			i: i32,
+			weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			// Ensure that the `origin` is `Root`.
+			ensure_root(origin)?;
+			<I32Log<T>>::try_append(i).map_err(|_| "could not append")?;
+			Self::deposit_event(Event::AppendI32 { value: i, weight });
+			Ok(().into())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight(*weight)]
+		pub fn non_privileged_log(
+			origin: OriginFor<T>,
+			i: i32,
+			weight: Weight,
+		) -> DispatchResultWithPostInfo {
+			// Ensure that the `origin` is some signed account.
+			let sender = ensure_signed(origin)?;
+			<I32Log<T>>::try_append(i).map_err(|_| "could not append")?;
+			<AccountLog<T>>::try_append(sender.clone()).map_err(|_| "could not append")?;
+			Self::deposit_event(Event::AppendI32AndAccount { sender, value: i, weight });
+			Ok(().into())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		AppendI32 { value: i32, weight: Weight },
+		AppendI32AndAccount { sender: T::AccountId, value: i32, weight: Weight },
+	}
+
+	#[pallet::storage]
+	#[pallet::getter(fn account_log)]
+	pub(super) type AccountLog<T: Config> =
+		StorageValue<_, BoundedVec<T::AccountId, ConstU32<1_000>>, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn i32_log)]
+	pub(super) type I32Log<T> = StorageValue<_, BoundedVec<i32, ConstU32<1_000>>, ValueQuery>;
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Sudo: sudo::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Logger: logger::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+pub struct BlockEverything;
+impl Contains<RuntimeCall> for BlockEverything {
+	fn contains(_: &RuntimeCall) -> bool {
+		false
+	}
+}
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = BlockEverything;
+	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 = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+// Implement the logger module's `Config` on the Test runtime.
+impl logger::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+// Implement the sudo module's `Config` on the Test runtime.
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type WeightInfo = ();
+}
+
+// New types for dispatchable functions.
+pub type SudoCall = sudo::Call<Test>;
+pub type LoggerCall = logger::Call<Test>;
+
+// Build test environment by setting the root `key` for the Genesis.
+pub fn new_test_ext(root_key: u64) -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	sudo::GenesisConfig::<Test> { key: Some(root_key) }
+		.assimilate_storage(&mut t)
+		.unwrap();
+	t.into()
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+pub fn new_bench_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Test>::default().build_storage().unwrap().into()
+}
diff --git a/substrate/frame/sudo/src/tests.rs b/substrate/frame/sudo/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c854fed8f0736e7aedb523ccd6e49745dfca21b1
--- /dev/null
+++ b/substrate/frame/sudo/src/tests.rs
@@ -0,0 +1,212 @@
+// 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 the module.
+
+use super::*;
+use frame_support::{assert_noop, assert_ok, weights::Weight};
+use mock::{
+	new_test_ext, Logger, LoggerCall, RuntimeCall, RuntimeEvent as TestEvent, RuntimeOrigin, Sudo,
+	SudoCall, System, Test,
+};
+
+#[test]
+fn test_setup_works() {
+	// Environment setup, logger storage, and sudo `key` retrieval should work as expected.
+	new_test_ext(1).execute_with(|| {
+		assert_eq!(Sudo::key(), Some(1u64));
+		assert!(Logger::i32_log().is_empty());
+		assert!(Logger::account_log().is_empty());
+	});
+}
+
+#[test]
+fn sudo_basics() {
+	// Configure a default test environment and set the root `key` to 1.
+	new_test_ext(1).execute_with(|| {
+		// A privileged function should work when `sudo` is passed the root `key` as `origin`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_ok!(Sudo::sudo(RuntimeOrigin::signed(1), call));
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+
+		// A privileged function should not work when `sudo` is passed a non-root `key` as `origin`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_noop!(Sudo::sudo(RuntimeOrigin::signed(2), call), Error::<Test>::RequireSudo);
+	});
+}
+
+#[test]
+fn sudo_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		// Set block number to 1 because events are not emitted on block 0.
+		System::set_block_number(1);
+
+		// Should emit event to indicate success when called with the root `key` and `call` is `Ok`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo(RuntimeOrigin::signed(1), call));
+		System::assert_has_event(TestEvent::Sudo(Event::Sudid { sudo_result: Ok(()) }));
+	})
+}
+
+#[test]
+fn sudo_unchecked_weight_basics() {
+	new_test_ext(1).execute_with(|| {
+		// A privileged function should work when `sudo` is passed the root `key` as origin.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_ok!(Sudo::sudo_unchecked_weight(
+			RuntimeOrigin::signed(1),
+			call,
+			Weight::from_parts(1_000, 0)
+		));
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+
+		// A privileged function should not work when called with a non-root `key`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_noop!(
+			Sudo::sudo_unchecked_weight(
+				RuntimeOrigin::signed(2),
+				call,
+				Weight::from_parts(1_000, 0)
+			),
+			Error::<Test>::RequireSudo,
+		);
+		// `I32Log` is unchanged after unsuccessful call.
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+
+		// Controls the dispatched weight.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		let sudo_unchecked_weight_call =
+			SudoCall::sudo_unchecked_weight { call, weight: Weight::from_parts(1_000, 0) };
+		let info = sudo_unchecked_weight_call.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(1_000, 0));
+	});
+}
+
+#[test]
+fn sudo_unchecked_weight_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		// Set block number to 1 because events are not emitted on block 0.
+		System::set_block_number(1);
+
+		// Should emit event to indicate success when called with the root `key` and `call` is `Ok`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo_unchecked_weight(
+			RuntimeOrigin::signed(1),
+			call,
+			Weight::from_parts(1_000, 0)
+		));
+		System::assert_has_event(TestEvent::Sudo(Event::Sudid { sudo_result: Ok(()) }));
+	})
+}
+
+#[test]
+fn set_key_basics() {
+	new_test_ext(1).execute_with(|| {
+		// A root `key` can change the root `key`
+		assert_ok!(Sudo::set_key(RuntimeOrigin::signed(1), 2));
+		assert_eq!(Sudo::key(), Some(2u64));
+	});
+
+	new_test_ext(1).execute_with(|| {
+		// A non-root `key` will trigger a `RequireSudo` error and a non-root `key` cannot change
+		// the root `key`.
+		assert_noop!(Sudo::set_key(RuntimeOrigin::signed(2), 3), Error::<Test>::RequireSudo);
+	});
+}
+
+#[test]
+fn set_key_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		// Set block number to 1 because events are not emitted on block 0.
+		System::set_block_number(1);
+
+		// A root `key` can change the root `key`.
+		assert_ok!(Sudo::set_key(RuntimeOrigin::signed(1), 2));
+		System::assert_has_event(TestEvent::Sudo(Event::KeyChanged { old_sudoer: Some(1) }));
+		// Double check.
+		assert_ok!(Sudo::set_key(RuntimeOrigin::signed(2), 4));
+		System::assert_has_event(TestEvent::Sudo(Event::KeyChanged { old_sudoer: Some(2) }));
+	});
+}
+
+#[test]
+fn sudo_as_basics() {
+	new_test_ext(1).execute_with(|| {
+		// A privileged function will not work when passed to `sudo_as`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::privileged_i32_log {
+			i: 42,
+			weight: Weight::from_parts(1_000, 0),
+		}));
+		assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
+		assert!(Logger::i32_log().is_empty());
+		assert!(Logger::account_log().is_empty());
+
+		// A non-privileged function should not work when called with a non-root `key`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_noop!(Sudo::sudo_as(RuntimeOrigin::signed(3), 2, call), Error::<Test>::RequireSudo);
+
+		// A non-privileged function will work when passed to `sudo_as` with the root `key`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
+		assert_eq!(Logger::i32_log(), vec![42i32]);
+		// The correct user makes the call within `sudo_as`.
+		assert_eq!(Logger::account_log(), vec![2]);
+	});
+}
+
+#[test]
+fn sudo_as_emits_events_correctly() {
+	new_test_ext(1).execute_with(|| {
+		// Set block number to 1 because events are not emitted on block 0.
+		System::set_block_number(1);
+
+		// A non-privileged function will work when passed to `sudo_as` with the root `key`.
+		let call = Box::new(RuntimeCall::Logger(LoggerCall::non_privileged_log {
+			i: 42,
+			weight: Weight::from_parts(1, 0),
+		}));
+		assert_ok!(Sudo::sudo_as(RuntimeOrigin::signed(1), 2, call));
+		System::assert_has_event(TestEvent::Sudo(Event::SudoAsDone { sudo_result: Ok(()) }));
+	});
+}
diff --git a/substrate/frame/sudo/src/weights.rs b/substrate/frame/sudo/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6a0197d1469b4ac65d786255c3973e2e575a62d4
--- /dev/null
+++ b/substrate/frame/sudo/src/weights.rs
@@ -0,0 +1,129 @@
+// 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.
+
+//! Autogenerated weights for pallet_sudo
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_sudo
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/sudo/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_sudo.
+pub trait WeightInfo {
+	fn set_key() -> Weight;
+	fn sudo() -> Weight;
+	fn sudo_as() -> Weight;
+}
+
+/// Weights for pallet_sudo using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Sudo Key (r:1 w:1)
+	/// Proof: Sudo Key (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	fn set_key() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 12_918_000 picoseconds.
+		Weight::from_parts(13_403_000, 1517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Sudo Key (r:1 w:0)
+	/// Proof: Sudo Key (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	fn sudo() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 12_693_000 picoseconds.
+		Weight::from_parts(13_001_000, 1517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+	/// Storage: Sudo Key (r:1 w:0)
+	/// Proof: Sudo Key (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	fn sudo_as() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 12_590_000 picoseconds.
+		Weight::from_parts(12_994_000, 1517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Sudo Key (r:1 w:1)
+	/// Proof: Sudo Key (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	fn set_key() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 12_918_000 picoseconds.
+		Weight::from_parts(13_403_000, 1517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Sudo Key (r:1 w:0)
+	/// Proof: Sudo Key (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	fn sudo() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 12_693_000 picoseconds.
+		Weight::from_parts(13_001_000, 1517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+	/// Storage: Sudo Key (r:1 w:0)
+	/// Proof: Sudo Key (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	fn sudo_as() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `165`
+		//  Estimated: `1517`
+		// Minimum execution time: 12_590_000 picoseconds.
+		Weight::from_parts(12_994_000, 1517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+	}
+}
diff --git a/substrate/frame/support/Cargo.toml b/substrate/frame/support/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d115a83722ac8a947c1dcba6961cca3a73694812
--- /dev/null
+++ b/substrate/frame/support/Cargo.toml
@@ -0,0 +1,107 @@
+[package]
+name = "frame-support"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Support code for the runtime."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+serde = { version = "1.0.163", default-features = false, features = ["alloc", "derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-metadata = { version = "16.0.0", default-features = false, features = ["current"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api", features = [ "frame-metadata" ] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-tracing = { version = "10.0.0", default-features = false, path = "../../primitives/tracing" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../primitives/arithmetic" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../primitives/inherents" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../../primitives/staking" }
+sp-weights = { version = "20.0.0", default-features = false, path = "../../primitives/weights" }
+sp-debug-derive = { default-features = false, path = "../../primitives/debug-derive" }
+sp-metadata-ir = { version = "0.1.0", default-features = false, path = "../../primitives/metadata-ir" }
+tt-call = "1.0.8"
+macro_magic = "0.4.2"
+frame-support-procedural = { version = "4.0.0-dev", default-features = false, path = "./procedural" }
+paste = "1.0"
+sp-state-machine = { version = "0.28.0", default-features = false, optional = true, path = "../../primitives/state-machine" }
+bitflags = "1.3"
+impl-trait-for-tuples = "0.2.2"
+smallvec = "1.11.0"
+log = { version = "0.4.17", default-features = false }
+sp-core-hashing-proc-macro = { version = "9.0.0", path = "../../primitives/core/hashing/proc-macro" }
+k256 = { version = "0.13.1", default-features = false, features = ["ecdsa"] }
+environmental = { version = "1.1.4", default-features = false }
+sp-genesis-builder = { version = "0.1.0", default-features=false, path = "../../primitives/genesis-builder" }
+serde_json = { version = "1.0.85", default-features = false, features = ["alloc"] }
+docify = "0.2.1"
+static_assertions = "1.1.0"
+
+aquamarine = { version = "0.3.2" }
+
+[dev-dependencies]
+assert_matches = "1.3.0"
+pretty_assertions = "1.2.1"
+frame-system = { version = "4.0.0-dev", path = "../system" }
+array-bytes = "6.1"
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"environmental/std",
+	"frame-metadata/std",
+	"frame-support-procedural/std",
+	"frame-system/std",
+	"k256/std",
+	"log/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-api/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-debug-derive/std",
+	"sp-genesis-builder/std",
+	"sp-inherents/std",
+	"sp-io/std",
+	"sp-metadata-ir/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-tracing/std",
+	"sp-weights/std",
+]
+runtime-benchmarks = [
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"sp-staking/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-system/try-runtime",
+	"sp-debug-derive/force-debug",
+	"sp-runtime/try-runtime",
+]
+experimental = []
+# By default some types have documentation, `no-metadata-docs` allows to reduce the documentation
+# in the metadata.
+no-metadata-docs = [
+	"frame-support-procedural/no-metadata-docs",
+	"sp-api/no-metadata-docs",
+]
+# By default some types have documentation, `full-metadata-docs` allows to add documentation to
+# more types in the metadata.
+full-metadata-docs = [ "scale-info/docs" ]
+# Generate impl-trait for tuples with the given number of tuples. Will be needed as the number of
+# pallets in a runtime grows. Does increase the compile time!
+tuples-96 = [ "frame-support-procedural/tuples-96" ]
+tuples-128 = [ "frame-support-procedural/tuples-128" ]
diff --git a/substrate/frame/support/README.md b/substrate/frame/support/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2282870aca05ca8393e5d6bef1ddb059e0466a72
--- /dev/null
+++ b/substrate/frame/support/README.md
@@ -0,0 +1,3 @@
+Support code for the runtime.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/support/procedural/Cargo.toml b/substrate/frame/support/procedural/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a5d4e9e2e801f852318d8a26a7ec60d6744a90b6
--- /dev/null
+++ b/substrate/frame/support/procedural/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "frame-support-procedural"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Proc macro of Support code for the runtime."
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+derive-syn-parse = "0.1.5"
+Inflector = "0.11.4"
+cfg-expr = "0.15.4"
+itertools = "0.10.3"
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full"] }
+frame-support-procedural-tools = { version = "4.0.0-dev", path = "./tools" }
+proc-macro-warning = { version = "0.4.1", default-features = false }
+macro_magic = { version = "0.4.2", features = ["proc_support"] }
+expander = "2.0.0"
+
+[features]
+default = [ "std" ]
+std = []
+no-metadata-docs = []
+# Generate impl-trait for tuples with the given number of tuples. Will be needed as the number of
+# pallets in a runtime grows. Does increase the compile time!
+tuples-96 = []
+tuples-128 = []
diff --git a/substrate/frame/support/procedural/src/benchmark.rs b/substrate/frame/support/procedural/src/benchmark.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f8f1d155e1e5991038349597ee4e00516b92c0f
--- /dev/null
+++ b/substrate/frame/support/procedural/src/benchmark.rs
@@ -0,0 +1,1019 @@
+// 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.
+
+//! Home of the parsing and expansion code for the new pallet benchmarking syntax
+
+use derive_syn_parse::Parse;
+use frame_support_procedural_tools::generate_crate_access_2018;
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, Span, TokenStream as TokenStream2};
+use quote::{quote, ToTokens};
+use syn::{
+	parse::{Nothing, ParseStream},
+	parse_quote,
+	punctuated::Punctuated,
+	spanned::Spanned,
+	token::{Comma, Gt, Lt, PathSep},
+	Attribute, Error, Expr, ExprBlock, ExprCall, ExprPath, FnArg, Item, ItemFn, ItemMod, Pat, Path,
+	PathArguments, PathSegment, Result, ReturnType, Signature, Stmt, Token, Type, TypePath,
+	Visibility, WhereClause,
+};
+
+mod keywords {
+	use syn::custom_keyword;
+
+	custom_keyword!(benchmark);
+	custom_keyword!(benchmarks);
+	custom_keyword!(block);
+	custom_keyword!(extra);
+	custom_keyword!(extrinsic_call);
+	custom_keyword!(skip_meta);
+	custom_keyword!(BenchmarkError);
+	custom_keyword!(Result);
+
+	pub const BENCHMARK_TOKEN: &str = stringify!(benchmark);
+	pub const BENCHMARKS_TOKEN: &str = stringify!(benchmarks);
+}
+
+/// This represents the raw parsed data for a param definition such as `x: Linear<10, 20>`.
+#[derive(Clone)]
+struct ParamDef {
+	name: String,
+	_typ: Type,
+	start: syn::GenericArgument,
+	end: syn::GenericArgument,
+}
+
+/// Allows easy parsing of the `<10, 20>` component of `x: Linear<10, 20>`.
+#[derive(Parse)]
+struct RangeArgs {
+	_lt_token: Lt,
+	start: syn::GenericArgument,
+	_comma: Comma,
+	end: syn::GenericArgument,
+	_gt_token: Gt,
+}
+
+#[derive(Clone, Debug)]
+struct BenchmarkAttrs {
+	skip_meta: bool,
+	extra: bool,
+}
+
+/// Represents a single benchmark option
+enum BenchmarkAttrKeyword {
+	Extra,
+	SkipMeta,
+}
+
+impl syn::parse::Parse for BenchmarkAttrKeyword {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let lookahead = input.lookahead1();
+		if lookahead.peek(keywords::extra) {
+			let _extra: keywords::extra = input.parse()?;
+			return Ok(BenchmarkAttrKeyword::Extra)
+		} else if lookahead.peek(keywords::skip_meta) {
+			let _skip_meta: keywords::skip_meta = input.parse()?;
+			return Ok(BenchmarkAttrKeyword::SkipMeta)
+		} else {
+			return Err(lookahead.error())
+		}
+	}
+}
+
+impl syn::parse::Parse for BenchmarkAttrs {
+	fn parse(input: ParseStream) -> syn::Result<Self> {
+		let mut extra = false;
+		let mut skip_meta = false;
+		let args = Punctuated::<BenchmarkAttrKeyword, Token![,]>::parse_terminated(&input)?;
+		for arg in args.into_iter() {
+			match arg {
+				BenchmarkAttrKeyword::Extra => {
+					if extra {
+						return Err(input.error("`extra` can only be specified once"))
+					}
+					extra = true;
+				},
+				BenchmarkAttrKeyword::SkipMeta => {
+					if skip_meta {
+						return Err(input.error("`skip_meta` can only be specified once"))
+					}
+					skip_meta = true;
+				},
+			}
+		}
+		Ok(BenchmarkAttrs { extra, skip_meta })
+	}
+}
+
+/// Represents the parsed extrinsic call for a benchmark
+#[derive(Clone)]
+enum BenchmarkCallDef {
+	ExtrinsicCall { origin: Expr, expr_call: ExprCall, attr_span: Span }, // #[extrinsic_call]
+	Block { block: ExprBlock, attr_span: Span },                          // #[block]
+}
+
+impl BenchmarkCallDef {
+	/// Returns the `span()` for attribute
+	fn attr_span(&self) -> Span {
+		match self {
+			BenchmarkCallDef::ExtrinsicCall { origin: _, expr_call: _, attr_span } => *attr_span,
+			BenchmarkCallDef::Block { block: _, attr_span } => *attr_span,
+		}
+	}
+}
+
+/// Represents a parsed `#[benchmark]` or `#[instance_banchmark]` item.
+#[derive(Clone)]
+struct BenchmarkDef {
+	params: Vec<ParamDef>,
+	setup_stmts: Vec<Stmt>,
+	call_def: BenchmarkCallDef,
+	verify_stmts: Vec<Stmt>,
+	last_stmt: Option<Stmt>,
+	fn_sig: Signature,
+	fn_vis: Visibility,
+	fn_attrs: Vec<Attribute>,
+}
+
+/// used to parse something compatible with `Result<T, E>`
+#[derive(Parse)]
+struct ResultDef {
+	_result_kw: keywords::Result,
+	_lt: Token![<],
+	unit: Type,
+	_comma: Comma,
+	e_type: TypePath,
+	_gt: Token![>],
+}
+
+/// Ensures that `ReturnType` is a `Result<(), BenchmarkError>`, if specified
+fn ensure_valid_return_type(item_fn: &ItemFn) -> Result<()> {
+	if let ReturnType::Type(_, typ) = &item_fn.sig.output {
+		let non_unit = |span| return Err(Error::new(span, "expected `()`"));
+		let Type::Path(TypePath { path, qself: _ }) = &**typ else {
+			return Err(Error::new(
+					typ.span(),
+					"Only `Result<(), BenchmarkError>` or a blank return type is allowed on benchmark function definitions",
+				))
+		};
+		let seg = path
+			.segments
+			.last()
+			.expect("to be parsed as a TypePath, it must have at least one segment; qed");
+		let res: ResultDef = syn::parse2(seg.to_token_stream())?;
+		// ensure T in Result<T, E> is ()
+		let Type::Tuple(tup) = res.unit else { return non_unit(res.unit.span()) };
+		if !tup.elems.is_empty() {
+			return non_unit(tup.span())
+		}
+		let TypePath { path, qself: _ } = res.e_type;
+		let seg = path
+			.segments
+			.last()
+			.expect("to be parsed as a TypePath, it must have at least one segment; qed");
+		syn::parse2::<keywords::BenchmarkError>(seg.to_token_stream())?;
+	}
+	Ok(())
+}
+
+/// Parses params such as `x: Linear<0, 1>`
+fn parse_params(item_fn: &ItemFn) -> Result<Vec<ParamDef>> {
+	let mut params: Vec<ParamDef> = Vec::new();
+	for arg in &item_fn.sig.inputs {
+		let invalid_param = |span| {
+			return Err(Error::new(
+				span,
+				"Invalid benchmark function param. A valid example would be `x: Linear<5, 10>`.",
+			))
+		};
+
+		let FnArg::Typed(arg) = arg else { return invalid_param(arg.span()) };
+		let Pat::Ident(ident) = &*arg.pat else { return invalid_param(arg.span()) };
+
+		// check param name
+		let var_span = ident.span();
+		let invalid_param_name = || {
+			return Err(Error::new(
+					var_span,
+					"Benchmark parameter names must consist of a single lowercase letter (a-z) and no other characters.",
+				));
+		};
+		let name = ident.ident.to_token_stream().to_string();
+		if name.len() > 1 {
+			return invalid_param_name()
+		};
+		let Some(name_char) = name.chars().next() else { return invalid_param_name() };
+		if !name_char.is_alphabetic() || !name_char.is_lowercase() {
+			return invalid_param_name()
+		}
+
+		// parse type
+		let typ = &*arg.ty;
+		let Type::Path(tpath) = typ else { return invalid_param(typ.span()) };
+		let Some(segment) = tpath.path.segments.last() else { return invalid_param(typ.span()) };
+		let args = segment.arguments.to_token_stream().into();
+		let Ok(args) = syn::parse::<RangeArgs>(args) else { return invalid_param(typ.span()) };
+
+		params.push(ParamDef { name, _typ: typ.clone(), start: args.start, end: args.end });
+	}
+	Ok(params)
+}
+
+/// Used in several places where the `#[extrinsic_call]` or `#[body]` annotation is missing
+fn missing_call<T>(item_fn: &ItemFn) -> Result<T> {
+	return Err(Error::new(
+		item_fn.block.brace_token.span.join(),
+		"No valid #[extrinsic_call] or #[block] annotation could be found in benchmark function body."
+	));
+}
+
+/// Finds the `BenchmarkCallDef` and its index (within the list of stmts for the fn) and
+/// returns them. Also handles parsing errors for invalid / extra call defs. AKA this is
+/// general handling for `#[extrinsic_call]` and `#[block]`
+fn parse_call_def(item_fn: &ItemFn) -> Result<(usize, BenchmarkCallDef)> {
+	// #[extrinsic_call] / #[block] handling
+	let call_defs = item_fn.block.stmts.iter().enumerate().filter_map(|(i, child)| {
+			if let Stmt::Expr(Expr::Call(expr_call), _semi) = child {
+				// #[extrinsic_call] case
+				expr_call.attrs.iter().enumerate().find_map(|(k, attr)| {
+					let segment = attr.path().segments.last()?;
+					let _: keywords::extrinsic_call = syn::parse(segment.ident.to_token_stream().into()).ok()?;
+					let mut expr_call = expr_call.clone();
+
+					// consume #[extrinsic_call] tokens
+					expr_call.attrs.remove(k);
+
+					// extract origin from expr_call
+					let Some(origin) = expr_call.args.first().cloned() else {
+						return Some(Err(Error::new(expr_call.span(), "Single-item extrinsic calls must specify their origin as the first argument.")))
+					};
+
+					Some(Ok((i, BenchmarkCallDef::ExtrinsicCall { origin, expr_call, attr_span: attr.span() })))
+				})
+			} else if let Stmt::Expr(Expr::Block(block), _) = child {
+				// #[block] case
+				block.attrs.iter().enumerate().find_map(|(k, attr)| {
+					let segment = attr.path().segments.last()?;
+					let _: keywords::block = syn::parse(segment.ident.to_token_stream().into()).ok()?;
+					let mut block = block.clone();
+
+					// consume #[block] tokens
+					block.attrs.remove(k);
+
+					Some(Ok((i, BenchmarkCallDef::Block { block, attr_span: attr.span() })))
+				})
+			} else {
+				None
+			}
+		}).collect::<Result<Vec<_>>>()?;
+	Ok(match &call_defs[..] {
+		[(i, call_def)] => (*i, call_def.clone()), // = 1
+		[] => return missing_call(item_fn),
+		_ =>
+			return Err(Error::new(
+				call_defs[1].1.attr_span(),
+				"Only one #[extrinsic_call] or #[block] attribute is allowed per benchmark.",
+			)),
+	})
+}
+
+impl BenchmarkDef {
+	/// Constructs a [`BenchmarkDef`] by traversing an existing [`ItemFn`] node.
+	pub fn from(item_fn: &ItemFn) -> Result<BenchmarkDef> {
+		let params = parse_params(item_fn)?;
+		ensure_valid_return_type(item_fn)?;
+		let (i, call_def) = parse_call_def(&item_fn)?;
+
+		let (verify_stmts, last_stmt) = match item_fn.sig.output {
+			ReturnType::Default =>
+			// no return type, last_stmt should be None
+				(Vec::from(&item_fn.block.stmts[(i + 1)..item_fn.block.stmts.len()]), None),
+			ReturnType::Type(_, _) => {
+				// defined return type, last_stmt should be Result<(), BenchmarkError>
+				// compatible and should not be included in verify_stmts
+				if i + 1 >= item_fn.block.stmts.len() {
+					return Err(Error::new(
+						item_fn.block.span(),
+						"Benchmark `#[block]` or `#[extrinsic_call]` item cannot be the \
+						last statement of your benchmark function definition if you have \
+						defined a return type. You should return something compatible \
+						with Result<(), BenchmarkError> (i.e. `Ok(())`) as the last statement \
+						or change your signature to a blank return type.",
+					))
+				}
+				let Some(stmt) = item_fn.block.stmts.last() else { return missing_call(item_fn) };
+				(
+					Vec::from(&item_fn.block.stmts[(i + 1)..item_fn.block.stmts.len() - 1]),
+					Some(stmt.clone()),
+				)
+			},
+		};
+
+		Ok(BenchmarkDef {
+			params,
+			setup_stmts: Vec::from(&item_fn.block.stmts[0..i]),
+			call_def,
+			verify_stmts,
+			last_stmt,
+			fn_sig: item_fn.sig.clone(),
+			fn_vis: item_fn.vis.clone(),
+			fn_attrs: item_fn.attrs.clone(),
+		})
+	}
+}
+
+/// Parses and expands a `#[benchmarks]` or `#[instance_benchmarks]` invocation
+pub fn benchmarks(
+	attrs: TokenStream,
+	tokens: TokenStream,
+	instance: bool,
+) -> syn::Result<TokenStream> {
+	// gather module info
+	let module: ItemMod = syn::parse(tokens)?;
+	let mod_span = module.span();
+	let where_clause = match syn::parse::<Nothing>(attrs.clone()) {
+		Ok(_) => quote!(),
+		Err(_) => syn::parse::<WhereClause>(attrs)?.predicates.to_token_stream(),
+	};
+	let mod_vis = module.vis;
+	let mod_name = module.ident;
+
+	// consume #[benchmarks] attribute by exclusing it from mod_attrs
+	let mod_attrs: Vec<&Attribute> = module
+		.attrs
+		.iter()
+		.filter(|attr| !attr.path().is_ident(keywords::BENCHMARKS_TOKEN))
+		.collect();
+
+	let mut benchmark_names: Vec<Ident> = Vec::new();
+	let mut extra_benchmark_names: Vec<Ident> = Vec::new();
+	let mut skip_meta_benchmark_names: Vec<Ident> = Vec::new();
+
+	let (_brace, mut content) =
+		module.content.ok_or(syn::Error::new(mod_span, "Module cannot be empty!"))?;
+
+	// find all function defs marked with #[benchmark]
+	let benchmark_fn_metas = content.iter_mut().filter_map(|stmt| {
+		// parse as a function def first
+		let Item::Fn(func) = stmt else { return None };
+
+		// find #[benchmark] attribute on function def
+		let benchmark_attr =
+			func.attrs.iter().find(|attr| attr.path().is_ident(keywords::BENCHMARK_TOKEN))?;
+
+		Some((benchmark_attr.clone(), func.clone(), stmt))
+	});
+
+	// parse individual benchmark defs and args
+	for (benchmark_attr, func, stmt) in benchmark_fn_metas {
+		// parse benchmark def
+		let benchmark_def = BenchmarkDef::from(&func)?;
+
+		// record benchmark name
+		let name = &func.sig.ident;
+		benchmark_names.push(name.clone());
+
+		// Check if we need to parse any args
+		if benchmark_attr.meta.require_path_only().is_err() {
+			// parse any args provided to #[benchmark]
+			let benchmark_attrs: BenchmarkAttrs = benchmark_attr.parse_args()?;
+
+			// record name sets
+			if benchmark_attrs.extra {
+				extra_benchmark_names.push(name.clone());
+			} else if benchmark_attrs.skip_meta {
+				skip_meta_benchmark_names.push(name.clone());
+			}
+		}
+
+		// expand benchmark
+		let expanded = expand_benchmark(benchmark_def, name, instance, where_clause.clone());
+
+		// replace original function def with expanded code
+		*stmt = Item::Verbatim(expanded);
+	}
+
+	// generics
+	let type_use_generics = match instance {
+		false => quote!(T),
+		true => quote!(T, I),
+	};
+	let type_impl_generics = match instance {
+		false => quote!(T: Config),
+		true => quote!(T: Config<I>, I: 'static),
+	};
+
+	let krate = generate_crate_access_2018("frame-benchmarking")?;
+
+	// benchmark name variables
+	let benchmark_names_str: Vec<String> = benchmark_names.iter().map(|n| n.to_string()).collect();
+	let extra_benchmark_names_str: Vec<String> =
+		extra_benchmark_names.iter().map(|n| n.to_string()).collect();
+	let skip_meta_benchmark_names_str: Vec<String> =
+		skip_meta_benchmark_names.iter().map(|n| n.to_string()).collect();
+	let mut selected_benchmark_mappings: Vec<TokenStream2> = Vec::new();
+	let mut benchmarks_by_name_mappings: Vec<TokenStream2> = Vec::new();
+	let test_idents: Vec<Ident> = benchmark_names_str
+		.iter()
+		.map(|n| Ident::new(format!("test_{}", n).as_str(), Span::call_site()))
+		.collect();
+	for i in 0..benchmark_names.len() {
+		let name_ident = &benchmark_names[i];
+		let name_str = &benchmark_names_str[i];
+		let test_ident = &test_idents[i];
+		selected_benchmark_mappings.push(quote!(#name_str => SelectedBenchmark::#name_ident));
+		benchmarks_by_name_mappings.push(quote!(#name_str => Self::#test_ident()))
+	}
+
+	// emit final quoted tokens
+	let res = quote! {
+		#(#mod_attrs)
+		*
+		#mod_vis mod #mod_name {
+			#(#content)
+			*
+
+			#[allow(non_camel_case_types)]
+			enum SelectedBenchmark {
+				#(#benchmark_names),
+				*
+			}
+
+			impl<#type_impl_generics> #krate::BenchmarkingSetup<#type_use_generics> for SelectedBenchmark where #where_clause {
+				fn components(&self) -> #krate::__private::Vec<(#krate::BenchmarkParameter, u32, u32)> {
+					match self {
+						#(
+							Self::#benchmark_names => {
+								<#benchmark_names as #krate::BenchmarkingSetup<#type_use_generics>>::components(&#benchmark_names)
+							}
+						)
+						*
+					}
+				}
+
+				fn instance(
+					&self,
+					components: &[(#krate::BenchmarkParameter, u32)],
+					verify: bool,
+				) -> Result<
+					#krate::__private::Box<dyn FnOnce() -> Result<(), #krate::BenchmarkError>>,
+					#krate::BenchmarkError,
+				> {
+					match self {
+						#(
+							Self::#benchmark_names => {
+								<#benchmark_names as #krate::BenchmarkingSetup<
+									#type_use_generics
+								>>::instance(&#benchmark_names, components, verify)
+							}
+						)
+						*
+					}
+				}
+			}
+			#[cfg(any(feature = "runtime-benchmarks", test))]
+			impl<#type_impl_generics> #krate::Benchmarking for Pallet<#type_use_generics>
+			where T: frame_system::Config, #where_clause
+			{
+				fn benchmarks(
+					extra: bool,
+				) -> #krate::__private::Vec<#krate::BenchmarkMetadata> {
+					let mut all_names = #krate::__private::vec![
+						#(#benchmark_names_str),
+						*
+					];
+					if !extra {
+						let extra = [
+							#(#extra_benchmark_names_str),
+							*
+						];
+						all_names.retain(|x| !extra.contains(x));
+					}
+					all_names.into_iter().map(|benchmark| {
+						let selected_benchmark = match benchmark {
+							#(#selected_benchmark_mappings),
+							*,
+							_ => panic!("all benchmarks should be selectable")
+						};
+						let components = <SelectedBenchmark as #krate::BenchmarkingSetup<#type_use_generics>>::components(&selected_benchmark);
+						#krate::BenchmarkMetadata {
+							name: benchmark.as_bytes().to_vec(),
+							components,
+							// TODO: Not supported by V2 syntax as of yet.
+							// https://github.com/paritytech/substrate/issues/13132
+							pov_modes: vec![],
+						}
+					}).collect::<#krate::__private::Vec<_>>()
+				}
+
+				fn run_benchmark(
+					extrinsic: &[u8],
+					c: &[(#krate::BenchmarkParameter, u32)],
+					whitelist: &[#krate::__private::TrackedStorageKey],
+					verify: bool,
+					internal_repeats: u32,
+				) -> Result<#krate::__private::Vec<#krate::BenchmarkResult>, #krate::BenchmarkError> {
+					let extrinsic = #krate::__private::str::from_utf8(extrinsic).map_err(|_| "`extrinsic` is not a valid utf-8 string!")?;
+					let selected_benchmark = match extrinsic {
+						#(#selected_benchmark_mappings),
+						*,
+						_ => return Err("Could not find extrinsic.".into()),
+					};
+					let mut whitelist = whitelist.to_vec();
+					let whitelisted_caller_key = <frame_system::Account<
+						T,
+					> as #krate::__private::storage::StorageMap<_, _,>>::hashed_key_for(
+						#krate::whitelisted_caller::<T::AccountId>()
+					);
+					whitelist.push(whitelisted_caller_key.into());
+					let transactional_layer_key = #krate::__private::TrackedStorageKey::new(
+						#krate::__private::storage::transactional::TRANSACTION_LEVEL_KEY.into(),
+					);
+					whitelist.push(transactional_layer_key);
+					// Whitelist the `:extrinsic_index`.
+					let extrinsic_index = #krate::__private::TrackedStorageKey::new(
+						#krate::__private::well_known_keys::EXTRINSIC_INDEX.into()
+					);
+					whitelist.push(extrinsic_index);
+					// Whitelist the `:intrablock_entropy`.
+					let intrablock_entropy = #krate::__private::TrackedStorageKey::new(
+						#krate::__private::well_known_keys::INTRABLOCK_ENTROPY.into()
+					);
+					whitelist.push(intrablock_entropy);
+
+					#krate::benchmarking::set_whitelist(whitelist.clone());
+					let mut results: #krate::__private::Vec<#krate::BenchmarkResult> = #krate::__private::Vec::new();
+
+					// Always do at least one internal repeat...
+					for _ in 0 .. internal_repeats.max(1) {
+						// Always reset the state after the benchmark.
+						#krate::__private::defer!(#krate::benchmarking::wipe_db());
+
+						// Set up the externalities environment for the setup we want to
+						// benchmark.
+						let closure_to_benchmark = <
+							SelectedBenchmark as #krate::BenchmarkingSetup<#type_use_generics>
+						>::instance(&selected_benchmark, c, verify)?;
+
+						// Set the block number to at least 1 so events are deposited.
+						if #krate::__private::Zero::is_zero(&frame_system::Pallet::<T>::block_number()) {
+							frame_system::Pallet::<T>::set_block_number(1u32.into());
+						}
+
+						// Commit the externalities to the database, flushing the DB cache.
+						// This will enable worst case scenario for reading from the database.
+						#krate::benchmarking::commit_db();
+
+						// Access all whitelisted keys to get them into the proof recorder since the
+						// recorder does now have a whitelist.
+						for key in &whitelist {
+							#krate::__private::storage::unhashed::get_raw(&key.key);
+						}
+
+						// Reset the read/write counter so we don't count operations in the setup process.
+						#krate::benchmarking::reset_read_write_count();
+
+						// Time the extrinsic logic.
+						#krate::__private::log::trace!(
+							target: "benchmark",
+							"Start Benchmark: {} ({:?})",
+							extrinsic,
+							c
+						);
+
+						let start_pov = #krate::benchmarking::proof_size();
+						let start_extrinsic = #krate::benchmarking::current_time();
+
+						closure_to_benchmark()?;
+
+						let finish_extrinsic = #krate::benchmarking::current_time();
+						let end_pov = #krate::benchmarking::proof_size();
+
+						// Calculate the diff caused by the benchmark.
+						let elapsed_extrinsic = finish_extrinsic.saturating_sub(start_extrinsic);
+						let diff_pov = match (start_pov, end_pov) {
+							(Some(start), Some(end)) => end.saturating_sub(start),
+							_ => Default::default(),
+						};
+
+						// Commit the changes to get proper write count
+						#krate::benchmarking::commit_db();
+						#krate::__private::log::trace!(
+							target: "benchmark",
+							"End Benchmark: {} ns", elapsed_extrinsic
+						);
+						let read_write_count = #krate::benchmarking::read_write_count();
+						#krate::__private::log::trace!(
+							target: "benchmark",
+							"Read/Write Count {:?}", read_write_count
+						);
+
+						// Time the storage root recalculation.
+						let start_storage_root = #krate::benchmarking::current_time();
+						#krate::__private::storage_root(#krate::__private::StateVersion::V1);
+						let finish_storage_root = #krate::benchmarking::current_time();
+						let elapsed_storage_root = finish_storage_root - start_storage_root;
+
+						let skip_meta = [ #(#skip_meta_benchmark_names_str),* ];
+						let read_and_written_keys = if skip_meta.contains(&extrinsic) {
+							#krate::__private::vec![(b"Skipped Metadata".to_vec(), 0, 0, false)]
+						} else {
+							#krate::benchmarking::get_read_and_written_keys()
+						};
+
+						results.push(#krate::BenchmarkResult {
+							components: c.to_vec(),
+							extrinsic_time: elapsed_extrinsic,
+							storage_root_time: elapsed_storage_root,
+							reads: read_write_count.0,
+							repeat_reads: read_write_count.1,
+							writes: read_write_count.2,
+							repeat_writes: read_write_count.3,
+							proof_size: diff_pov,
+							keys: read_and_written_keys,
+						});
+					}
+
+					return Ok(results);
+				}
+			}
+
+			#[cfg(test)]
+			impl<#type_impl_generics> Pallet<#type_use_generics> where T: ::frame_system::Config, #where_clause {
+				/// Test a particular benchmark by name.
+				///
+				/// This isn't called `test_benchmark_by_name` just in case some end-user eventually
+				/// writes a benchmark, itself called `by_name`; the function would be shadowed in
+				/// that case.
+				///
+				/// This is generally intended to be used by child test modules such as those created
+				/// by the `impl_benchmark_test_suite` macro. However, it is not an error if a pallet
+				/// author chooses not to implement benchmarks.
+				#[allow(unused)]
+				fn test_bench_by_name(name: &[u8]) -> Result<(), #krate::BenchmarkError> {
+					let name = #krate::__private::str::from_utf8(name)
+						.map_err(|_| -> #krate::BenchmarkError { "`name` is not a valid utf8 string!".into() })?;
+					match name {
+						#(#benchmarks_by_name_mappings),
+						*,
+						_ => Err("Could not find test for requested benchmark.".into()),
+					}
+				}
+			}
+		}
+		#mod_vis use #mod_name::*;
+	};
+	Ok(res.into())
+}
+
+/// Prepares a [`Vec<ParamDef>`] to be interpolated by [`quote!`] by creating easily-iterable
+/// arrays formatted in such a way that they can be interpolated directly.
+struct UnrolledParams {
+	param_ranges: Vec<TokenStream2>,
+	param_names: Vec<TokenStream2>,
+}
+
+impl UnrolledParams {
+	/// Constructs an [`UnrolledParams`] from a [`Vec<ParamDef>`]
+	fn from(params: &Vec<ParamDef>) -> UnrolledParams {
+		let param_ranges: Vec<TokenStream2> = params
+			.iter()
+			.map(|p| {
+				let name = Ident::new(&p.name, Span::call_site());
+				let start = &p.start;
+				let end = &p.end;
+				quote!(#name, #start, #end)
+			})
+			.collect();
+		let param_names: Vec<TokenStream2> = params
+			.iter()
+			.map(|p| {
+				let name = Ident::new(&p.name, Span::call_site());
+				quote!(#name)
+			})
+			.collect();
+		UnrolledParams { param_ranges, param_names }
+	}
+}
+
+/// Performs expansion of an already-parsed [`BenchmarkDef`].
+fn expand_benchmark(
+	benchmark_def: BenchmarkDef,
+	name: &Ident,
+	is_instance: bool,
+	where_clause: TokenStream2,
+) -> TokenStream2 {
+	// set up variables needed during quoting
+	let krate = match generate_crate_access_2018("frame-benchmarking") {
+		Ok(ident) => ident,
+		Err(err) => return err.to_compile_error().into(),
+	};
+	let codec = quote!(#krate::__private::codec);
+	let traits = quote!(#krate::__private::traits);
+	let setup_stmts = benchmark_def.setup_stmts;
+	let verify_stmts = benchmark_def.verify_stmts;
+	let last_stmt = benchmark_def.last_stmt;
+	let test_ident = Ident::new(format!("test_{}", name.to_string()).as_str(), Span::call_site());
+
+	// unroll params (prepare for quoting)
+	let unrolled = UnrolledParams::from(&benchmark_def.params);
+	let param_names = unrolled.param_names;
+	let param_ranges = unrolled.param_ranges;
+
+	let type_use_generics = match is_instance {
+		false => quote!(T),
+		true => quote!(T, I),
+	};
+
+	let type_impl_generics = match is_instance {
+		false => quote!(T: Config),
+		true => quote!(T: Config<I>, I: 'static),
+	};
+
+	// used in the benchmarking impls
+	let (pre_call, post_call, fn_call_body) = match &benchmark_def.call_def {
+		BenchmarkCallDef::ExtrinsicCall { origin, expr_call, attr_span: _ } => {
+			let mut expr_call = expr_call.clone();
+
+			// remove first arg from expr_call
+			let mut final_args = Punctuated::<Expr, Comma>::new();
+			let args: Vec<&Expr> = expr_call.args.iter().collect();
+			for arg in &args[1..] {
+				final_args.push((*(*arg)).clone());
+			}
+			expr_call.args = final_args;
+
+			let origin = match origin {
+				Expr::Cast(t) => {
+					let ty = t.ty.clone();
+					quote! {
+						<<T as frame_system::Config>::RuntimeOrigin as From<#ty>>::from(#origin);
+					}
+				},
+				_ => quote! {
+					#origin.into();
+				},
+			};
+
+			// determine call name (handles `_` and normal call syntax)
+			let expr_span = expr_call.span();
+			let call_err = || {
+				syn::Error::new(expr_span, "Extrinsic call must be a function call or `_`")
+					.to_compile_error()
+			};
+			let call_name = match *expr_call.func {
+				Expr::Path(expr_path) => {
+					// normal function call
+					let Some(segment) = expr_path.path.segments.last() else { return call_err() };
+					segment.ident.to_string()
+				},
+				Expr::Infer(_) => {
+					// `_` style
+					// replace `_` with fn name
+					name.to_string()
+				},
+				_ => return call_err(),
+			};
+
+			// modify extrinsic call to be prefixed with "new_call_variant"
+			let call_name = format!("new_call_variant_{}", call_name);
+			let mut punct: Punctuated<PathSegment, PathSep> = Punctuated::new();
+			punct.push(PathSegment {
+				arguments: PathArguments::None,
+				ident: Ident::new(call_name.as_str(), Span::call_site()),
+			});
+			*expr_call.func = Expr::Path(ExprPath {
+				attrs: vec![],
+				qself: None,
+				path: Path { leading_colon: None, segments: punct },
+			});
+			let pre_call = quote! {
+				let __call = Call::<#type_use_generics>::#expr_call;
+				let __benchmarked_call_encoded = #codec::Encode::encode(&__call);
+			};
+			let post_call = quote! {
+				let __call_decoded = <Call<#type_use_generics> as #codec::Decode>
+					::decode(&mut &__benchmarked_call_encoded[..])
+					.expect("call is encoded above, encoding must be correct");
+				let __origin = #origin;
+				<Call<#type_use_generics> as #traits::UnfilteredDispatchable>::dispatch_bypass_filter(
+					__call_decoded,
+					__origin,
+				)
+			};
+			(
+				// (pre_call, post_call, fn_call_body):
+				pre_call.clone(),
+				quote!(#post_call?;),
+				quote! {
+					#pre_call
+					#post_call.unwrap();
+				},
+			)
+		},
+		BenchmarkCallDef::Block { block, attr_span: _ } =>
+			(quote!(), quote!(#block), quote!(#block)),
+	};
+
+	let vis = benchmark_def.fn_vis;
+
+	// remove #[benchmark] attribute
+	let fn_attrs = benchmark_def
+		.fn_attrs
+		.iter()
+		.filter(|attr| !attr.path().is_ident(keywords::BENCHMARK_TOKEN));
+
+	// modify signature generics, ident, and inputs, e.g:
+	// before: `fn bench(u: Linear<1, 100>) -> Result<(), BenchmarkError>`
+	// after: `fn _bench <T: Config<I>, I: 'static>(u: u32, verify: bool) -> Result<(),
+	// BenchmarkError>`
+	let mut sig = benchmark_def.fn_sig;
+	sig.generics = parse_quote!(<#type_impl_generics>);
+	if !where_clause.is_empty() {
+		sig.generics.where_clause = parse_quote!(where #where_clause);
+	}
+	sig.ident =
+		Ident::new(format!("_{}", name.to_token_stream().to_string()).as_str(), Span::call_site());
+	let mut fn_param_inputs: Vec<TokenStream2> =
+		param_names.iter().map(|name| quote!(#name: u32)).collect();
+	fn_param_inputs.push(quote!(verify: bool));
+	sig.inputs = parse_quote!(#(#fn_param_inputs),*);
+
+	// used in instance() impl
+	let impl_last_stmt = match &last_stmt {
+		Some(stmt) => quote!(#stmt),
+		None => quote!(Ok(())),
+	};
+	let fn_attrs_clone = fn_attrs.clone();
+
+	let fn_def = quote! {
+		#(
+			#fn_attrs_clone
+		)*
+		#vis #sig {
+			#(
+				#setup_stmts
+			)*
+			#fn_call_body
+			if verify {
+				#(
+					#verify_stmts
+				)*
+			}
+			#last_stmt
+		}
+	};
+
+	// generate final quoted tokens
+	let res = quote! {
+		// benchmark function definition
+		#fn_def
+
+		#[allow(non_camel_case_types)]
+		#(
+			#fn_attrs
+		)*
+		struct #name;
+
+		#[allow(unused_variables)]
+		impl<#type_impl_generics> #krate::BenchmarkingSetup<#type_use_generics>
+		for #name where #where_clause {
+			fn components(&self) -> #krate::__private::Vec<(#krate::BenchmarkParameter, u32, u32)> {
+				#krate::__private::vec! [
+					#(
+						(#krate::BenchmarkParameter::#param_ranges)
+					),*
+				]
+			}
+
+			fn instance(
+				&self,
+				components: &[(#krate::BenchmarkParameter, u32)],
+				verify: bool
+			) -> Result<#krate::__private::Box<dyn FnOnce() -> Result<(), #krate::BenchmarkError>>, #krate::BenchmarkError> {
+				#(
+					// prepare instance #param_names
+					let #param_names = components.iter()
+						.find(|&c| c.0 == #krate::BenchmarkParameter::#param_names)
+						.ok_or("Could not find component during benchmark preparation.")?
+						.1;
+				)*
+
+				// benchmark setup code
+				#(
+					#setup_stmts
+				)*
+				#pre_call
+				Ok(#krate::__private::Box::new(move || -> Result<(), #krate::BenchmarkError> {
+					#post_call
+					if verify {
+						#(
+							#verify_stmts
+						)*
+					}
+					#impl_last_stmt
+				}))
+			}
+		}
+
+		#[cfg(test)]
+		impl<#type_impl_generics> Pallet<#type_use_generics> where T: ::frame_system::Config, #where_clause {
+			#[allow(unused)]
+			fn #test_ident() -> Result<(), #krate::BenchmarkError> {
+				let selected_benchmark = SelectedBenchmark::#name;
+				let components = <
+					SelectedBenchmark as #krate::BenchmarkingSetup<T, _>
+				>::components(&selected_benchmark);
+				let execute_benchmark = |
+					c: #krate::__private::Vec<(#krate::BenchmarkParameter, u32)>
+				| -> Result<(), #krate::BenchmarkError> {
+					// Always reset the state after the benchmark.
+					#krate::__private::defer!(#krate::benchmarking::wipe_db());
+
+					// Set up the benchmark, return execution + verification function.
+					let closure_to_verify = <
+						SelectedBenchmark as #krate::BenchmarkingSetup<T, _>
+					>::instance(&selected_benchmark, &c, true)?;
+
+					// Set the block number to at least 1 so events are deposited.
+					if #krate::__private::Zero::is_zero(&frame_system::Pallet::<T>::block_number()) {
+						frame_system::Pallet::<T>::set_block_number(1u32.into());
+					}
+
+					// Run execution + verification
+					closure_to_verify()
+				};
+
+				if components.is_empty() {
+					execute_benchmark(Default::default())?;
+				} else {
+					let num_values: u32 = if let Ok(ev) = std::env::var("VALUES_PER_COMPONENT") {
+						ev.parse().map_err(|_| {
+							#krate::BenchmarkError::Stop(
+								"Could not parse env var `VALUES_PER_COMPONENT` as u32."
+							)
+						})?
+					} else {
+						6
+					};
+
+					if num_values < 2 {
+						return Err("`VALUES_PER_COMPONENT` must be at least 2".into());
+					}
+
+					for (name, low, high) in components.clone().into_iter() {
+						// Test the lowest, highest (if its different from the lowest)
+						// and up to num_values-2 more equidistant values in between.
+						// For 0..10 and num_values=6 this would mean: [0, 2, 4, 6, 8, 10]
+						if high < low {
+							return Err("The start of a `ParamRange` must be less than or equal to the end".into());
+						}
+
+						let mut values = #krate::__private::vec![low];
+						let diff = (high - low).min(num_values - 1);
+						let slope = (high - low) as f32 / diff as f32;
+
+						for i in 1..=diff {
+							let value = ((low as f32 + slope * i as f32) as u32)
+											.clamp(low, high);
+							values.push(value);
+						}
+
+						for component_value in values {
+							// Select the max value for all the other components.
+							let c: #krate::__private::Vec<(#krate::BenchmarkParameter, u32)> = components
+								.iter()
+								.map(|(n, _, h)|
+									if *n == name {
+										(*n, component_value)
+									} else {
+										(*n, *h)
+									}
+								)
+								.collect();
+
+							execute_benchmark(c)?;
+						}
+					}
+				}
+				return Ok(());
+			}
+		}
+	};
+	res
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/call.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cbf2ea9078535d87db6a92dba83870e4851b5160
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/call.rs
@@ -0,0 +1,211 @@
+// 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::construct_runtime::Pallet;
+use proc_macro2::TokenStream;
+use quote::quote;
+use std::str::FromStr;
+use syn::Ident;
+
+pub fn expand_outer_dispatch(
+	runtime: &Ident,
+	system_pallet: &Pallet,
+	pallet_decls: &[Pallet],
+	scrate: &TokenStream,
+) -> TokenStream {
+	let mut variant_defs = TokenStream::new();
+	let mut variant_patterns = Vec::new();
+	let mut query_call_part_macros = Vec::new();
+	let mut pallet_names = Vec::new();
+	let mut pallet_attrs = Vec::new();
+	let system_path = &system_pallet.path;
+
+	let pallets_with_call = pallet_decls.iter().filter(|decl| decl.exists_part("Call"));
+
+	for pallet_declaration in pallets_with_call {
+		let name = &pallet_declaration.name;
+		let path = &pallet_declaration.path;
+		let index = pallet_declaration.index;
+		let attr =
+			pallet_declaration.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+				let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+					.expect("was successfully parsed before; qed");
+				quote! {
+					#acc
+					#attr
+				}
+			});
+
+		variant_defs.extend(quote! {
+			#attr
+			#[codec(index = #index)]
+			#name( #scrate::dispatch::CallableCallFor<#name, #runtime> ),
+		});
+		variant_patterns.push(quote!(RuntimeCall::#name(call)));
+		pallet_names.push(name);
+		pallet_attrs.push(attr);
+		query_call_part_macros.push(quote! {
+			#path::__substrate_call_check::is_call_part_defined!(#name);
+		});
+	}
+
+	quote! {
+		#( #query_call_part_macros )*
+
+		#[derive(
+			Clone, PartialEq, Eq,
+			#scrate::__private::codec::Encode,
+			#scrate::__private::codec::Decode,
+			#scrate::__private::scale_info::TypeInfo,
+			#scrate::__private::RuntimeDebug,
+		)]
+		pub enum RuntimeCall {
+			#variant_defs
+		}
+		#[cfg(test)]
+		impl RuntimeCall {
+			/// Return a list of the module names together with their size in memory.
+			pub const fn sizes() -> &'static [( &'static str, usize )] {
+				use #scrate::dispatch::Callable;
+				use core::mem::size_of;
+				&[#(
+					#pallet_attrs
+					(
+						stringify!(#pallet_names),
+						size_of::< <#pallet_names as Callable<#runtime>>::RuntimeCall >(),
+					),
+				)*]
+			}
+
+			/// Panics with diagnostic information if the size is greater than the given `limit`.
+			pub fn assert_size_under(limit: usize) {
+				let size = core::mem::size_of::<Self>();
+				let call_oversize = size > limit;
+				if call_oversize {
+					println!("Size of `Call` is {} bytes (provided limit is {} bytes)", size, limit);
+					let mut sizes = Self::sizes().to_vec();
+					sizes.sort_by_key(|x| -(x.1 as isize));
+					for (i, &(name, size)) in sizes.iter().enumerate().take(5) {
+						println!("Offender #{}: {} at {} bytes", i + 1, name, size);
+					}
+					if let Some((_, next_size)) = sizes.get(5) {
+						println!("{} others of size {} bytes or less", sizes.len() - 5, next_size);
+					}
+					panic!(
+						"Size of `Call` is more than limit; use `Box` on complex parameter types to reduce the
+						size of `Call`.
+						If the limit is too strong, maybe consider providing a higher limit."
+					);
+				}
+			}
+		}
+		impl #scrate::dispatch::GetDispatchInfo for RuntimeCall {
+			fn get_dispatch_info(&self) -> #scrate::dispatch::DispatchInfo {
+				match self {
+					#(
+						#pallet_attrs
+						#variant_patterns => call.get_dispatch_info(),
+					)*
+				}
+			}
+		}
+
+		impl #scrate::dispatch::GetCallMetadata for RuntimeCall {
+			fn get_call_metadata(&self) -> #scrate::dispatch::CallMetadata {
+				use #scrate::dispatch::GetCallName;
+				match self {
+					#(
+						#pallet_attrs
+						#variant_patterns => {
+							let function_name = call.get_call_name();
+							let pallet_name = stringify!(#pallet_names);
+							#scrate::dispatch::CallMetadata { function_name, pallet_name }
+						}
+					)*
+				}
+			}
+
+			fn get_module_names() -> &'static [&'static str] {
+				&[#(
+					#pallet_attrs
+					stringify!(#pallet_names),
+				)*]
+			}
+
+			fn get_call_names(module: &str) -> &'static [&'static str] {
+				use #scrate::dispatch::{Callable, GetCallName};
+				match module {
+					#(
+						#pallet_attrs
+						stringify!(#pallet_names) =>
+							<<#pallet_names as Callable<#runtime>>::RuntimeCall
+								as GetCallName>::get_call_names(),
+					)*
+					_ => unreachable!(),
+				}
+			}
+		}
+		impl #scrate::dispatch::Dispatchable for RuntimeCall {
+			type RuntimeOrigin = RuntimeOrigin;
+			type Config = RuntimeCall;
+			type Info = #scrate::dispatch::DispatchInfo;
+			type PostInfo = #scrate::dispatch::PostDispatchInfo;
+			fn dispatch(self, origin: RuntimeOrigin) -> #scrate::dispatch::DispatchResultWithPostInfo {
+				if !<Self::RuntimeOrigin as #scrate::traits::OriginTrait>::filter_call(&origin, &self) {
+					return #scrate::__private::sp_std::result::Result::Err(
+						#system_path::Error::<#runtime>::CallFiltered.into()
+					);
+				}
+
+				#scrate::traits::UnfilteredDispatchable::dispatch_bypass_filter(self, origin)
+			}
+		}
+		impl #scrate::traits::UnfilteredDispatchable for RuntimeCall {
+			type RuntimeOrigin = RuntimeOrigin;
+			fn dispatch_bypass_filter(self, origin: RuntimeOrigin) -> #scrate::dispatch::DispatchResultWithPostInfo {
+				match self {
+					#(
+						#pallet_attrs
+						#variant_patterns =>
+							#scrate::traits::UnfilteredDispatchable::dispatch_bypass_filter(call, origin),
+					)*
+				}
+			}
+		}
+
+		#(
+			#pallet_attrs
+			impl #scrate::traits::IsSubType<#scrate::dispatch::CallableCallFor<#pallet_names, #runtime>> for RuntimeCall {
+				#[allow(unreachable_patterns)]
+				fn is_sub_type(&self) -> Option<&#scrate::dispatch::CallableCallFor<#pallet_names, #runtime>> {
+					match self {
+						#variant_patterns => Some(call),
+						// May be unreachable
+						_ => None,
+					}
+				}
+			}
+
+			#pallet_attrs
+			impl From<#scrate::dispatch::CallableCallFor<#pallet_names, #runtime>> for RuntimeCall {
+				fn from(call: #scrate::dispatch::CallableCallFor<#pallet_names, #runtime>) -> Self {
+					#variant_patterns
+				}
+			}
+		)*
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/config.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ffe55bceb80ef96bc9e7814cfbd8bec6c62ab562
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/config.rs
@@ -0,0 +1,140 @@
+// 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::construct_runtime::Pallet;
+use inflector::Inflector;
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote, ToTokens};
+use std::str::FromStr;
+use syn::Ident;
+
+pub fn expand_outer_config(
+	runtime: &Ident,
+	pallet_decls: &[Pallet],
+	scrate: &TokenStream,
+) -> TokenStream {
+	let mut types = TokenStream::new();
+	let mut fields = TokenStream::new();
+	let mut genesis_build_calls = TokenStream::new();
+	let mut query_genesis_config_part_macros = Vec::new();
+
+	for decl in pallet_decls {
+		if let Some(pallet_entry) = decl.find_part("Config") {
+			let path = &decl.path;
+			let pallet_name = &decl.name;
+			let path_str = path.into_token_stream().to_string();
+			let config = format_ident!("{}Config", pallet_name);
+			let field_name =
+				&Ident::new(&pallet_name.to_string().to_snake_case(), decl.name.span());
+			let part_is_generic = !pallet_entry.generics.params.is_empty();
+			let attr = &decl.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+				let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+					.expect("was successfully parsed before; qed");
+				quote! {
+					#acc
+					#attr
+				}
+			});
+
+			types.extend(expand_config_types(attr, runtime, decl, &config, part_is_generic));
+			fields.extend(quote!(#attr pub #field_name: #config,));
+			genesis_build_calls
+				.extend(expand_config_build_storage_call(scrate, &config, attr, field_name));
+			query_genesis_config_part_macros.push(quote! {
+				#path::__substrate_genesis_config_check::is_genesis_config_defined!(#pallet_name);
+				#[cfg(feature = "std")]
+				#path::__substrate_genesis_config_check::is_std_enabled_for_genesis!(#pallet_name, #path_str);
+			});
+		}
+	}
+
+	quote! {
+		#( #query_genesis_config_part_macros )*
+
+		#types
+
+		use #scrate::__private::serde as __genesis_config_serde_import__;
+		#[derive(#scrate::__private::serde::Serialize, #scrate::__private::serde::Deserialize, Default)]
+		#[serde(rename_all = "camelCase")]
+		#[serde(deny_unknown_fields)]
+		#[serde(crate = "__genesis_config_serde_import__")]
+		pub struct RuntimeGenesisConfig {
+			#fields
+		}
+
+		#[cfg(any(feature = "std", test))]
+		#[deprecated(note = "GenesisConfig is planned to be removed in December 2023. Use `RuntimeGenesisConfig` instead.")]
+		pub type GenesisConfig = RuntimeGenesisConfig;
+
+		#[cfg(any(feature = "std", test))]
+		impl #scrate::sp_runtime::BuildStorage for RuntimeGenesisConfig {
+			fn assimilate_storage(
+				&self,
+				storage: &mut #scrate::sp_runtime::Storage,
+			) -> std::result::Result<(), String> {
+				#scrate::__private::BasicExternalities::execute_with_storage(storage, || {
+					<Self as #scrate::traits::BuildGenesisConfig>::build(&self);
+					Ok(())
+				})
+			}
+		}
+
+		impl #scrate::traits::BuildGenesisConfig for RuntimeGenesisConfig {
+			fn build(&self) {
+				#genesis_build_calls
+				<AllPalletsWithSystem as #scrate::traits::OnGenesis>::on_genesis();
+			}
+		}
+	}
+}
+
+fn expand_config_types(
+	attr: &TokenStream,
+	runtime: &Ident,
+	decl: &Pallet,
+	config: &Ident,
+	part_is_generic: bool,
+) -> TokenStream {
+	let path = &decl.path;
+
+	match (decl.instance.as_ref(), part_is_generic) {
+		(Some(inst), true) => quote! {
+			#attr
+			pub type #config = #path::GenesisConfig<#runtime, #path::#inst>;
+		},
+		(None, true) => quote! {
+			#attr
+			pub type #config = #path::GenesisConfig<#runtime>;
+		},
+		(_, false) => quote! {
+			#attr
+			pub type #config = #path::GenesisConfig;
+		},
+	}
+}
+
+fn expand_config_build_storage_call(
+	scrate: &TokenStream,
+	pallet_genesis_config: &Ident,
+	attr: &TokenStream,
+	field_name: &Ident,
+) -> TokenStream {
+	quote! {
+		#attr
+		<#pallet_genesis_config as #scrate::traits::BuildGenesisConfig>::build(&self.#field_name);
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/freeze_reason.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/freeze_reason.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b142f8e84c92f1fb9d09f33b710c724c5a84eff2
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/freeze_reason.rs
@@ -0,0 +1,68 @@
+// 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::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_freeze_reason(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut freeze_reason_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("FreezeReason") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			freeze_reason_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		/// A reason for placing a freeze on funds.
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::__private::codec::Encode, #scrate::__private::codec::Decode, #scrate::__private::codec::MaxEncodedLen,
+			#scrate::__private::scale_info::TypeInfo,
+			#scrate::__private::RuntimeDebug,
+		)]
+		pub enum RuntimeFreezeReason {
+			#( #freeze_reason_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::FreezeReason> for RuntimeFreezeReason {
+			fn from(hr: #path::FreezeReason) -> Self {
+				RuntimeFreezeReason::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::FreezeReason),
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/hold_reason.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/hold_reason.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ed7183c4a150d80dcc69ab0b06a4c4fd73ff765b
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/hold_reason.rs
@@ -0,0 +1,68 @@
+// 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::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_hold_reason(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut hold_reason_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("HoldReason") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			hold_reason_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		/// A reason for placing a hold on funds.
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::__private::codec::Encode, #scrate::__private::codec::Decode, #scrate::__private::codec::MaxEncodedLen,
+			#scrate::__private::scale_info::TypeInfo,
+			#scrate::__private::RuntimeDebug,
+		)]
+		pub enum RuntimeHoldReason {
+			#( #hold_reason_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::HoldReason> for RuntimeHoldReason {
+			fn from(hr: #path::HoldReason) -> Self {
+				RuntimeHoldReason::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::HoldReason),
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/inherent.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/inherent.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a77aad66dcfc2db3d25e27d422c60c5aa8a8e2a5
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/inherent.rs
@@ -0,0 +1,252 @@
+// 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::construct_runtime::Pallet;
+use proc_macro2::TokenStream;
+use quote::quote;
+use std::str::FromStr;
+use syn::Ident;
+
+pub fn expand_outer_inherent(
+	runtime: &Ident,
+	block: &TokenStream,
+	unchecked_extrinsic: &TokenStream,
+	pallet_decls: &[Pallet],
+	scrate: &TokenStream,
+) -> TokenStream {
+	let mut pallet_names = Vec::new();
+	let mut pallet_attrs = Vec::new();
+	let mut query_inherent_part_macros = Vec::new();
+
+	for pallet_decl in pallet_decls {
+		if pallet_decl.exists_part("Inherent") {
+			let name = &pallet_decl.name;
+			let path = &pallet_decl.path;
+			let attr = pallet_decl.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+				let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+					.expect("was successfully parsed before; qed");
+				quote! {
+					#acc
+					#attr
+				}
+			});
+
+			pallet_names.push(name);
+			pallet_attrs.push(attr);
+			query_inherent_part_macros.push(quote! {
+				#path::__substrate_inherent_check::is_inherent_part_defined!(#name);
+			});
+		}
+	}
+
+	quote! {
+		#( #query_inherent_part_macros )*
+
+		trait InherentDataExt {
+			fn create_extrinsics(&self) ->
+				#scrate::__private::sp_std::vec::Vec<<#block as #scrate::sp_runtime::traits::Block>::Extrinsic>;
+			fn check_extrinsics(&self, block: &#block) -> #scrate::inherent::CheckInherentsResult;
+		}
+
+		impl InherentDataExt for #scrate::inherent::InherentData {
+			fn create_extrinsics(&self) ->
+				#scrate::__private::sp_std::vec::Vec<<#block as #scrate::sp_runtime::traits::Block>::Extrinsic>
+			{
+				use #scrate::inherent::ProvideInherent;
+
+				let mut inherents = #scrate::__private::sp_std::vec::Vec::new();
+
+				#(
+					#pallet_attrs
+					if let Some(inherent) = #pallet_names::create_inherent(self) {
+						let inherent = <#unchecked_extrinsic as #scrate::sp_runtime::traits::Extrinsic>::new(
+							inherent.into(),
+							None,
+						).expect("Runtime UncheckedExtrinsic is not Opaque, so it has to return \
+							`Some`; qed");
+
+						inherents.push(inherent);
+					}
+				)*
+
+				inherents
+			}
+
+			fn check_extrinsics(&self, block: &#block) -> #scrate::inherent::CheckInherentsResult {
+				use #scrate::inherent::{ProvideInherent, IsFatalError};
+				use #scrate::traits::{IsSubType, ExtrinsicCall};
+				use #scrate::sp_runtime::traits::Block as _;
+				use #scrate::_private::sp_inherents::Error;
+				use #scrate::__private::log;
+
+				let mut result = #scrate::inherent::CheckInherentsResult::new();
+
+				// This handle assume we abort on the first fatal error.
+				fn handle_put_error_result(res: Result<(), Error>) {
+					const LOG_TARGET: &str = "runtime::inherent";
+					match res {
+						Ok(()) => (),
+						Err(Error::InherentDataExists(id)) =>
+							log::debug!(
+								target: LOG_TARGET,
+								"Some error already reported for inherent {:?}, new non fatal \
+								error is ignored",
+								id
+							),
+						Err(Error::FatalErrorReported) =>
+							log::error!(
+								target: LOG_TARGET,
+								"Fatal error already reported, unexpected considering there is \
+								only one fatal error",
+							),
+						Err(_) =>
+							log::error!(
+								target: LOG_TARGET,
+								"Unexpected error from `put_error` operation",
+							),
+					}
+				}
+
+				for xt in block.extrinsics() {
+					// Inherents are before any other extrinsics.
+					// And signed extrinsics are not inherents.
+					if #scrate::sp_runtime::traits::Extrinsic::is_signed(xt).unwrap_or(false) {
+						break
+					}
+
+					let mut is_inherent = false;
+
+					#(
+						#pallet_attrs
+						{
+							let call = <#unchecked_extrinsic as ExtrinsicCall>::call(xt);
+							if let Some(call) = IsSubType::<_>::is_sub_type(call) {
+								if #pallet_names::is_inherent(call) {
+									is_inherent = true;
+									if let Err(e) = #pallet_names::check_inherent(call, self) {
+										handle_put_error_result(result.put_error(
+											#pallet_names::INHERENT_IDENTIFIER, &e
+										));
+										if e.is_fatal_error() {
+											return result;
+										}
+									}
+								}
+							}
+						}
+					)*
+
+					// Inherents are before any other extrinsics.
+					// No module marked it as inherent thus it is not.
+					if !is_inherent {
+						break
+					}
+				}
+
+				#(
+					#pallet_attrs
+					match #pallet_names::is_inherent_required(self) {
+						Ok(Some(e)) => {
+							let found = block.extrinsics().iter().any(|xt| {
+								let is_signed = #scrate::sp_runtime::traits::Extrinsic::is_signed(xt)
+									.unwrap_or(false);
+
+								if !is_signed {
+									let call = <
+										#unchecked_extrinsic as ExtrinsicCall
+									>::call(xt);
+									if let Some(call) = IsSubType::<_>::is_sub_type(call) {
+										#pallet_names::is_inherent(&call)
+									} else {
+										false
+									}
+								} else {
+									// Signed extrinsics are not inherents.
+									false
+								}
+							});
+
+							if !found {
+								handle_put_error_result(result.put_error(
+									#pallet_names::INHERENT_IDENTIFIER, &e
+								));
+								if e.is_fatal_error() {
+									return result;
+								}
+							}
+						},
+						Ok(None) => (),
+						Err(e) => {
+							handle_put_error_result(result.put_error(
+								#pallet_names::INHERENT_IDENTIFIER, &e
+							));
+							if e.is_fatal_error() {
+								return result;
+							}
+						},
+					}
+				)*
+
+				result
+			}
+		}
+
+		impl #scrate::traits::EnsureInherentsAreFirst<#block> for #runtime {
+			fn ensure_inherents_are_first(block: &#block) -> Result<(), u32> {
+				use #scrate::inherent::ProvideInherent;
+				use #scrate::traits::{IsSubType, ExtrinsicCall};
+				use #scrate::sp_runtime::traits::Block as _;
+
+				let mut first_signed_observed = false;
+
+				for (i, xt) in block.extrinsics().iter().enumerate() {
+					let is_signed = #scrate::sp_runtime::traits::Extrinsic::is_signed(xt)
+						.unwrap_or(false);
+
+					let is_inherent = if is_signed {
+						// Signed extrinsics are not inherents.
+						false
+					} else {
+						let mut is_inherent = false;
+						#(
+							#pallet_attrs
+							{
+								let call = <#unchecked_extrinsic as ExtrinsicCall>::call(xt);
+								if let Some(call) = IsSubType::<_>::is_sub_type(call) {
+									if #pallet_names::is_inherent(&call) {
+										is_inherent = true;
+									}
+								}
+							}
+						)*
+						is_inherent
+					};
+
+					if !is_inherent {
+						first_signed_observed = true;
+					}
+
+					if first_signed_observed && is_inherent {
+						return Err(i as u32)
+					}
+				}
+
+				Ok(())
+			}
+		}
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/lock_id.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/lock_id.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ba35147a051fbc7347be8cc45508b975b5245f25
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/lock_id.rs
@@ -0,0 +1,68 @@
+// 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::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_lock_id(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut lock_id_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("LockId") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			lock_id_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		/// An identifier for each lock placed on funds.
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::__private::codec::Encode, #scrate::__private::codec::Decode, #scrate::__private::codec::MaxEncodedLen,
+			#scrate::__private::scale_info::TypeInfo,
+			#scrate::__private::RuntimeDebug,
+		)]
+		pub enum RuntimeLockId {
+			#( #lock_id_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::LockId> for RuntimeLockId {
+			fn from(hr: #path::LockId) -> Self {
+				RuntimeLockId::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::LockId),
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/metadata.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0e76f9a92469a73d3a616da454dc46ded5034afc
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/metadata.rs
@@ -0,0 +1,258 @@
+// 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::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::TokenStream;
+use quote::quote;
+use std::str::FromStr;
+use syn::Ident;
+
+pub fn expand_runtime_metadata(
+	runtime: &Ident,
+	pallet_declarations: &[Pallet],
+	scrate: &TokenStream,
+	extrinsic: &TokenStream,
+	system_path: &PalletPath,
+) -> TokenStream {
+	let pallets = pallet_declarations
+		.iter()
+		.filter_map(|pallet_declaration| {
+			pallet_declaration.find_part("Pallet").map(|_| {
+				let filtered_names: Vec<_> = pallet_declaration
+					.pallet_parts()
+					.iter()
+					.filter(|part| part.name() != "Pallet")
+					.map(|part| part.name())
+					.collect();
+				(pallet_declaration, filtered_names)
+			})
+		})
+		.map(|(decl, filtered_names)| {
+			let name = &decl.name;
+			let index = &decl.index;
+			let storage = expand_pallet_metadata_storage(&filtered_names, runtime, decl);
+			let calls = expand_pallet_metadata_calls(&filtered_names, runtime, decl);
+			let event = expand_pallet_metadata_events(&filtered_names, runtime, scrate, decl);
+			let constants = expand_pallet_metadata_constants(runtime, decl);
+			let errors = expand_pallet_metadata_errors(runtime, decl);
+			let docs = expand_pallet_metadata_docs(runtime, decl);
+			let attr = decl.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+				let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+					.expect("was successfully parsed before; qed");
+				quote! {
+					#acc
+					#attr
+				}
+			});
+
+			quote! {
+				#attr
+				#scrate::__private::metadata_ir::PalletMetadataIR {
+					name: stringify!(#name),
+					index: #index,
+					storage: #storage,
+					calls: #calls,
+					event: #event,
+					constants: #constants,
+					error: #errors,
+					docs: #docs,
+				}
+			}
+		})
+		.collect::<Vec<_>>();
+
+	quote! {
+		impl #runtime {
+			fn metadata_ir() -> #scrate::__private::metadata_ir::MetadataIR {
+				// Each runtime must expose the `runtime_metadata()` to fetch the runtime API metadata.
+				// The function is implemented by calling `impl_runtime_apis!`.
+				//
+				// However, the `construct_runtime!` may be called without calling `impl_runtime_apis!`.
+				// Rely on the `Deref` trait to differentiate between a runtime that implements
+				// APIs (by macro impl_runtime_apis!) and a runtime that is simply created (by macro construct_runtime!).
+				//
+				// Both `InternalConstructRuntime` and `InternalImplRuntimeApis` expose a `runtime_metadata()` function.
+				// `InternalConstructRuntime` is implemented by the `construct_runtime!` for Runtime references (`& Runtime`),
+				// while `InternalImplRuntimeApis` is implemented by the `impl_runtime_apis!` for Runtime (`Runtime`).
+				//
+				// Therefore, the `Deref` trait will resolve the `runtime_metadata` from `impl_runtime_apis!`
+				// when both macros are called; and will resolve an empty `runtime_metadata` when only the `construct_runtime!`
+				// is called.
+				//
+				// `Deref` needs a reference for resolving the function call.
+				let rt = #runtime;
+
+				let ty = #scrate::__private::scale_info::meta_type::<#extrinsic>();
+				let address_ty = #scrate::__private::scale_info::meta_type::<
+						<<#extrinsic as #scrate::sp_runtime::traits::Extrinsic>::SignaturePayload as #scrate::sp_runtime::traits::SignaturePayload>::SignatureAddress
+					>();
+				let call_ty = #scrate::__private::scale_info::meta_type::<
+					<#extrinsic as #scrate::sp_runtime::traits::Extrinsic>::Call
+					>();
+				let signature_ty = #scrate::__private::scale_info::meta_type::<
+						<<#extrinsic as #scrate::sp_runtime::traits::Extrinsic>::SignaturePayload as #scrate::sp_runtime::traits::SignaturePayload>::Signature
+					>();
+				let extra_ty = #scrate::__private::scale_info::meta_type::<
+						<<#extrinsic as #scrate::sp_runtime::traits::Extrinsic>::SignaturePayload as #scrate::sp_runtime::traits::SignaturePayload>::SignatureExtra
+					>();
+
+				#scrate::__private::metadata_ir::MetadataIR {
+					pallets: #scrate::__private::sp_std::vec![ #(#pallets),* ],
+					extrinsic: #scrate::__private::metadata_ir::ExtrinsicMetadataIR {
+						ty,
+						version: <#extrinsic as #scrate::sp_runtime::traits::ExtrinsicMetadata>::VERSION,
+						address_ty,
+						call_ty,
+						signature_ty,
+						extra_ty,
+						signed_extensions: <
+								<
+									#extrinsic as #scrate::sp_runtime::traits::ExtrinsicMetadata
+								>::SignedExtensions as #scrate::sp_runtime::traits::SignedExtension
+							>::metadata()
+								.into_iter()
+								.map(|meta| #scrate::__private::metadata_ir::SignedExtensionMetadataIR {
+									identifier: meta.identifier,
+									ty: meta.ty,
+									additional_signed: meta.additional_signed,
+								})
+								.collect(),
+					},
+					ty: #scrate::__private::scale_info::meta_type::<#runtime>(),
+					apis: (&rt).runtime_metadata(),
+					outer_enums: #scrate::__private::metadata_ir::OuterEnumsIR {
+						call_enum_ty: #scrate::__private::scale_info::meta_type::<
+								<#runtime as #system_path::Config>::RuntimeCall
+							>(),
+						event_enum_ty: #scrate::__private::scale_info::meta_type::<RuntimeEvent>(),
+						error_enum_ty: #scrate::__private::scale_info::meta_type::<RuntimeError>(),
+					}
+				}
+			}
+
+			pub fn metadata() -> #scrate::__private::metadata::RuntimeMetadataPrefixed {
+				// Note: this always returns the V14 version. The runtime API function
+				// must be deprecated.
+				#scrate::__private::metadata_ir::into_v14(#runtime::metadata_ir())
+			}
+
+			pub fn metadata_at_version(version: u32) -> Option<#scrate::__private::OpaqueMetadata> {
+				#scrate::__private::metadata_ir::into_version(#runtime::metadata_ir(), version).map(|prefixed| {
+					#scrate::__private::OpaqueMetadata::new(prefixed.into())
+				})
+			}
+
+			pub fn metadata_versions() -> #scrate::__private::sp_std::vec::Vec<u32> {
+				#scrate::__private::metadata_ir::supported_versions()
+			}
+		}
+	}
+}
+
+fn expand_pallet_metadata_storage(
+	filtered_names: &[&'static str],
+	runtime: &Ident,
+	decl: &Pallet,
+) -> TokenStream {
+	if filtered_names.contains(&"Storage") {
+		let instance = decl.instance.as_ref().into_iter();
+		let path = &decl.path;
+
+		quote! {
+			Some(#path::Pallet::<#runtime #(, #path::#instance)*>::storage_metadata())
+		}
+	} else {
+		quote!(None)
+	}
+}
+
+fn expand_pallet_metadata_calls(
+	filtered_names: &[&'static str],
+	runtime: &Ident,
+	decl: &Pallet,
+) -> TokenStream {
+	if filtered_names.contains(&"Call") {
+		let instance = decl.instance.as_ref().into_iter();
+		let path = &decl.path;
+
+		quote! {
+			Some(#path::Pallet::<#runtime #(, #path::#instance)*>::call_functions())
+		}
+	} else {
+		quote!(None)
+	}
+}
+
+fn expand_pallet_metadata_events(
+	filtered_names: &[&'static str],
+	runtime: &Ident,
+	scrate: &TokenStream,
+	decl: &Pallet,
+) -> TokenStream {
+	if filtered_names.contains(&"Event") {
+		let path = &decl.path;
+		let part_is_generic = !decl
+			.find_part("Event")
+			.expect("Event part exists; qed")
+			.generics
+			.params
+			.is_empty();
+		let pallet_event = match (decl.instance.as_ref(), part_is_generic) {
+			(Some(inst), true) => quote!(#path::Event::<#runtime, #path::#inst>),
+			(Some(inst), false) => quote!(#path::Event::<#path::#inst>),
+			(None, true) => quote!(#path::Event::<#runtime>),
+			(None, false) => quote!(#path::Event),
+		};
+
+		quote! {
+			Some(
+				#scrate::__private::metadata_ir::PalletEventMetadataIR {
+					ty: #scrate::__private::scale_info::meta_type::<#pallet_event>()
+				}
+			)
+		}
+	} else {
+		quote!(None)
+	}
+}
+
+fn expand_pallet_metadata_constants(runtime: &Ident, decl: &Pallet) -> TokenStream {
+	let path = &decl.path;
+	let instance = decl.instance.as_ref().into_iter();
+
+	quote! {
+		#path::Pallet::<#runtime #(, #path::#instance)*>::pallet_constants_metadata()
+	}
+}
+
+fn expand_pallet_metadata_errors(runtime: &Ident, decl: &Pallet) -> TokenStream {
+	let path = &decl.path;
+	let instance = decl.instance.as_ref().into_iter();
+
+	quote! {
+		#path::Pallet::<#runtime #(, #path::#instance)*>::error_metadata()
+	}
+}
+
+fn expand_pallet_metadata_docs(runtime: &Ident, decl: &Pallet) -> TokenStream {
+	let path = &decl.path;
+	let instance = decl.instance.as_ref().into_iter();
+
+	quote! {
+		#path::Pallet::<#runtime #(, #path::#instance)*>::pallet_documentation_metadata()
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/mod.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..830338f9265ffa846aee7de1e01bc7175e908c3a
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/mod.rs
@@ -0,0 +1,40 @@
+// 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
+
+mod call;
+mod config;
+mod freeze_reason;
+mod hold_reason;
+mod inherent;
+mod lock_id;
+mod metadata;
+mod origin;
+mod outer_enums;
+mod slash_reason;
+mod unsigned;
+
+pub use call::expand_outer_dispatch;
+pub use config::expand_outer_config;
+pub use freeze_reason::expand_outer_freeze_reason;
+pub use hold_reason::expand_outer_hold_reason;
+pub use inherent::expand_outer_inherent;
+pub use lock_id::expand_outer_lock_id;
+pub use metadata::expand_runtime_metadata;
+pub use origin::expand_outer_origin;
+pub use outer_enums::{expand_outer_enum, OuterEnumType};
+pub use slash_reason::expand_outer_slash_reason;
+pub use unsigned::expand_outer_validate_unsigned;
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/origin.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/origin.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b421d2aaffabe077450d81e3396976f3067b264a
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/origin.rs
@@ -0,0 +1,455 @@
+// 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::construct_runtime::{Pallet, SYSTEM_PALLET_NAME};
+use proc_macro2::TokenStream;
+use quote::quote;
+use std::str::FromStr;
+use syn::{Generics, Ident};
+
+pub fn expand_outer_origin(
+	runtime: &Ident,
+	system_pallet: &Pallet,
+	pallets: &[Pallet],
+	scrate: &TokenStream,
+) -> syn::Result<TokenStream> {
+	let mut caller_variants = TokenStream::new();
+	let mut pallet_conversions = TokenStream::new();
+	let mut query_origin_part_macros = Vec::new();
+
+	for pallet_decl in pallets.iter().filter(|pallet| pallet.name != SYSTEM_PALLET_NAME) {
+		if let Some(pallet_entry) = pallet_decl.find_part("Origin") {
+			let instance = pallet_decl.instance.as_ref();
+			let index = pallet_decl.index;
+			let generics = &pallet_entry.generics;
+			let name = &pallet_decl.name;
+			let path = &pallet_decl.path;
+
+			if instance.is_some() && generics.params.is_empty() {
+				let msg = format!(
+					"Instantiable pallet with no generic `Origin` cannot \
+					 be constructed: pallet `{}` must have generic `Origin`",
+					name
+				);
+				return Err(syn::Error::new(name.span(), msg))
+			}
+
+			caller_variants.extend(expand_origin_caller_variant(
+				runtime,
+				pallet_decl,
+				index,
+				instance,
+				generics,
+			));
+			pallet_conversions.extend(expand_origin_pallet_conversions(
+				scrate,
+				runtime,
+				pallet_decl,
+				instance,
+				generics,
+			));
+			query_origin_part_macros.push(quote! {
+				#path::__substrate_origin_check::is_origin_part_defined!(#name);
+			});
+		}
+	}
+
+	let system_path = &system_pallet.path;
+
+	let system_index = system_pallet.index;
+
+	let system_path_name = system_path.module_name();
+
+	let doc_string = get_intra_doc_string(
+		"Origin is always created with the base filter configured in",
+		&system_path_name,
+	);
+
+	let doc_string_none_origin =
+		get_intra_doc_string("Create with system none origin and", &system_path_name);
+
+	let doc_string_root_origin =
+		get_intra_doc_string("Create with system root origin and", &system_path_name);
+
+	let doc_string_signed_origin =
+		get_intra_doc_string("Create with system signed origin and", &system_path_name);
+
+	let doc_string_runtime_origin =
+		get_intra_doc_string("Convert to runtime origin, using as filter:", &system_path_name);
+
+	let doc_string_runtime_origin_with_caller = get_intra_doc_string(
+		"Convert to runtime origin with caller being system signed or none and use filter",
+		&system_path_name,
+	);
+
+	Ok(quote! {
+		#( #query_origin_part_macros )*
+
+		/// The runtime origin type representing the origin of a call.
+		///
+		#[doc = #doc_string]
+		#[derive(Clone)]
+		pub struct RuntimeOrigin {
+			caller: OriginCaller,
+			filter: #scrate::__private::sp_std::rc::Rc<Box<dyn Fn(&<#runtime as #system_path::Config>::RuntimeCall) -> bool>>,
+		}
+
+		#[cfg(not(feature = "std"))]
+		impl #scrate::__private::sp_std::fmt::Debug for RuntimeOrigin {
+			fn fmt(
+				&self,
+				fmt: &mut #scrate::__private::sp_std::fmt::Formatter,
+			) -> #scrate::__private::sp_std::result::Result<(), #scrate::__private::sp_std::fmt::Error> {
+				fmt.write_str("<wasm:stripped>")
+			}
+		}
+
+		#[cfg(feature = "std")]
+		impl #scrate::__private::sp_std::fmt::Debug for RuntimeOrigin {
+			fn fmt(
+				&self,
+				fmt: &mut #scrate::__private::sp_std::fmt::Formatter,
+			) -> #scrate::__private::sp_std::result::Result<(), #scrate::__private::sp_std::fmt::Error> {
+				fmt.debug_struct("Origin")
+					.field("caller", &self.caller)
+					.field("filter", &"[function ptr]")
+					.finish()
+			}
+		}
+
+		impl #scrate::traits::OriginTrait for RuntimeOrigin {
+			type Call = <#runtime as #system_path::Config>::RuntimeCall;
+			type PalletsOrigin = OriginCaller;
+			type AccountId = <#runtime as #system_path::Config>::AccountId;
+
+			fn add_filter(&mut self, filter: impl Fn(&Self::Call) -> bool + 'static) {
+				let f = self.filter.clone();
+
+				self.filter = #scrate::__private::sp_std::rc::Rc::new(Box::new(move |call| {
+					f(call) && filter(call)
+				}));
+			}
+
+			fn reset_filter(&mut self) {
+				let filter = <
+					<#runtime as #system_path::Config>::BaseCallFilter
+					as #scrate::traits::Contains<<#runtime as #system_path::Config>::RuntimeCall>
+				>::contains;
+
+				self.filter = #scrate::__private::sp_std::rc::Rc::new(Box::new(filter));
+			}
+
+			fn set_caller_from(&mut self, other: impl Into<Self>) {
+				self.caller = other.into().caller;
+			}
+
+			fn filter_call(&self, call: &Self::Call) -> bool {
+				match self.caller {
+					// Root bypasses all filters
+					OriginCaller::system(#system_path::Origin::<#runtime>::Root) => true,
+					_ => (self.filter)(call),
+				}
+			}
+
+			fn caller(&self) -> &Self::PalletsOrigin {
+				&self.caller
+			}
+
+			fn into_caller(self) -> Self::PalletsOrigin {
+				self.caller
+			}
+
+			fn try_with_caller<R>(
+				mut self,
+				f: impl FnOnce(Self::PalletsOrigin) -> Result<R, Self::PalletsOrigin>,
+			) -> Result<R, Self> {
+				match f(self.caller) {
+					Ok(r) => Ok(r),
+					Err(caller) => { self.caller = caller; Err(self) }
+				}
+			}
+
+			fn none() -> Self {
+				#system_path::RawOrigin::None.into()
+			}
+
+			fn root() -> Self {
+				#system_path::RawOrigin::Root.into()
+			}
+
+			fn signed(by: Self::AccountId) -> Self {
+				#system_path::RawOrigin::Signed(by).into()
+			}
+		}
+
+		#[derive(
+			Clone, PartialEq, Eq, #scrate::__private::RuntimeDebug, #scrate::__private::codec::Encode,
+			#scrate::__private::codec::Decode, #scrate::__private::scale_info::TypeInfo, #scrate::__private::codec::MaxEncodedLen,
+		)]
+		#[allow(non_camel_case_types)]
+		pub enum OriginCaller {
+			#[codec(index = #system_index)]
+			system(#system_path::Origin<#runtime>),
+			#caller_variants
+			#[allow(dead_code)]
+			Void(#scrate::__private::Void)
+		}
+
+		// For backwards compatibility and ease of accessing these functions.
+		#[allow(dead_code)]
+		impl RuntimeOrigin {
+			#[doc = #doc_string_none_origin]
+			pub fn none() -> Self {
+				<RuntimeOrigin as #scrate::traits::OriginTrait>::none()
+			}
+
+			#[doc = #doc_string_root_origin]
+			pub fn root() -> Self {
+				<RuntimeOrigin as #scrate::traits::OriginTrait>::root()
+			}
+
+			#[doc = #doc_string_signed_origin]
+			pub fn signed(by: <#runtime as #system_path::Config>::AccountId) -> Self {
+				<RuntimeOrigin as #scrate::traits::OriginTrait>::signed(by)
+			}
+		}
+
+		impl From<#system_path::Origin<#runtime>> for OriginCaller {
+			fn from(x: #system_path::Origin<#runtime>) -> Self {
+				OriginCaller::system(x)
+			}
+		}
+
+		impl #scrate::traits::CallerTrait<<#runtime as #system_path::Config>::AccountId> for OriginCaller {
+			fn into_system(self) -> Option<#system_path::RawOrigin<<#runtime as #system_path::Config>::AccountId>> {
+				match self {
+					OriginCaller::system(x) => Some(x),
+					_ => None,
+				}
+			}
+			fn as_system_ref(&self) -> Option<&#system_path::RawOrigin<<#runtime as #system_path::Config>::AccountId>> {
+				match &self {
+					OriginCaller::system(o) => Some(o),
+					_ => None,
+				}
+			}
+		}
+
+		impl TryFrom<OriginCaller> for #system_path::Origin<#runtime> {
+			type Error = OriginCaller;
+			fn try_from(x: OriginCaller)
+				-> #scrate::__private::sp_std::result::Result<#system_path::Origin<#runtime>, OriginCaller>
+			{
+				if let OriginCaller::system(l) = x {
+					Ok(l)
+				} else {
+					Err(x)
+				}
+			}
+		}
+
+		impl From<#system_path::Origin<#runtime>> for RuntimeOrigin {
+
+			#[doc = #doc_string_runtime_origin]
+			fn from(x: #system_path::Origin<#runtime>) -> Self {
+				let o: OriginCaller = x.into();
+				o.into()
+			}
+		}
+
+		impl From<OriginCaller> for RuntimeOrigin {
+			fn from(x: OriginCaller) -> Self {
+				let mut o = RuntimeOrigin {
+					caller: x,
+					filter: #scrate::__private::sp_std::rc::Rc::new(Box::new(|_| true)),
+				};
+
+				#scrate::traits::OriginTrait::reset_filter(&mut o);
+
+				o
+			}
+		}
+
+		impl From<RuntimeOrigin> for #scrate::__private::sp_std::result::Result<#system_path::Origin<#runtime>, RuntimeOrigin> {
+			/// NOTE: converting to pallet origin loses the origin filter information.
+			fn from(val: RuntimeOrigin) -> Self {
+				if let OriginCaller::system(l) = val.caller {
+					Ok(l)
+				} else {
+					Err(val)
+				}
+			}
+		}
+		impl From<Option<<#runtime as #system_path::Config>::AccountId>> for RuntimeOrigin {
+			#[doc = #doc_string_runtime_origin_with_caller]
+			fn from(x: Option<<#runtime as #system_path::Config>::AccountId>) -> Self {
+				<#system_path::Origin<#runtime>>::from(x).into()
+			}
+		}
+
+		#pallet_conversions
+	})
+}
+
+fn expand_origin_caller_variant(
+	runtime: &Ident,
+	pallet: &Pallet,
+	index: u8,
+	instance: Option<&Ident>,
+	generics: &Generics,
+) -> TokenStream {
+	let part_is_generic = !generics.params.is_empty();
+	let variant_name = &pallet.name;
+	let path = &pallet.path;
+	let attr = pallet.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+		let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+			.expect("was successfully parsed before; qed");
+		quote! {
+			#acc
+			#attr
+		}
+	});
+
+	match instance {
+		Some(inst) if part_is_generic => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::Origin<#runtime, #path::#inst>),
+		},
+		Some(inst) => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::Origin<#path::#inst>),
+		},
+		None if part_is_generic => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::Origin<#runtime>),
+		},
+		None => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::Origin),
+		},
+	}
+}
+
+fn expand_origin_pallet_conversions(
+	scrate: &TokenStream,
+	runtime: &Ident,
+	pallet: &Pallet,
+	instance: Option<&Ident>,
+	generics: &Generics,
+) -> TokenStream {
+	let path = &pallet.path;
+	let variant_name = &pallet.name;
+
+	let part_is_generic = !generics.params.is_empty();
+	let pallet_origin = match instance {
+		Some(inst) if part_is_generic => quote!(#path::Origin<#runtime, #path::#inst>),
+		Some(inst) => quote!(#path::Origin<#path::#inst>),
+		None if part_is_generic => quote!(#path::Origin<#runtime>),
+		None => quote!(#path::Origin),
+	};
+
+	let doc_string = get_intra_doc_string(" Convert to runtime origin using", &path.module_name());
+	let attr = pallet.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+		let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+			.expect("was successfully parsed before; qed");
+		quote! {
+			#acc
+			#attr
+		}
+	});
+
+	quote! {
+		#attr
+		impl From<#pallet_origin> for OriginCaller {
+			fn from(x: #pallet_origin) -> Self {
+				OriginCaller::#variant_name(x)
+			}
+		}
+
+		#attr
+		impl From<#pallet_origin> for RuntimeOrigin {
+			#[doc = #doc_string]
+			fn from(x: #pallet_origin) -> Self {
+				let x: OriginCaller = x.into();
+				x.into()
+			}
+		}
+
+		#attr
+		impl From<RuntimeOrigin> for #scrate::__private::sp_std::result::Result<#pallet_origin, RuntimeOrigin> {
+			/// NOTE: converting to pallet origin loses the origin filter information.
+			fn from(val: RuntimeOrigin) -> Self {
+				if let OriginCaller::#variant_name(l) = val.caller {
+					Ok(l)
+				} else {
+					Err(val)
+				}
+			}
+		}
+
+		#attr
+		impl TryFrom<OriginCaller> for #pallet_origin {
+			type Error = OriginCaller;
+			fn try_from(
+				x: OriginCaller,
+			) -> #scrate::__private::sp_std::result::Result<#pallet_origin, OriginCaller> {
+				if let OriginCaller::#variant_name(l) = x {
+					Ok(l)
+				} else {
+					Err(x)
+				}
+			}
+		}
+
+		#attr
+		impl<'a> TryFrom<&'a OriginCaller> for &'a #pallet_origin {
+			type Error = ();
+			fn try_from(
+				x: &'a OriginCaller,
+			) -> #scrate::__private::sp_std::result::Result<&'a #pallet_origin, ()> {
+				if let OriginCaller::#variant_name(l) = x {
+					Ok(&l)
+				} else {
+					Err(())
+				}
+			}
+		}
+
+		#attr
+		impl<'a> TryFrom<&'a RuntimeOrigin> for &'a #pallet_origin {
+			type Error = ();
+			fn try_from(
+				x: &'a RuntimeOrigin,
+			) -> #scrate::__private::sp_std::result::Result<&'a #pallet_origin, ()> {
+				if let OriginCaller::#variant_name(l) = &x.caller {
+					Ok(&l)
+				} else {
+					Err(())
+				}
+			}
+		}
+	}
+}
+
+// Get the actual documentation using the doc information and system path name
+fn get_intra_doc_string(doc_info: &str, system_path_name: &String) -> String {
+	format!(" {} [`{}::Config::BaseCallFilter`].", doc_info, system_path_name)
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/outer_enums.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/outer_enums.rs
new file mode 100644
index 0000000000000000000000000000000000000000..df69c19a4b617bbe7194bb5958848fc04d8d546a
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/outer_enums.rs
@@ -0,0 +1,281 @@
+// 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::construct_runtime::Pallet;
+use proc_macro2::{Span, TokenStream};
+use quote::{quote, ToTokens};
+use std::str::FromStr;
+use syn::{Generics, Ident};
+
+/// Represents the types supported for creating an outer enum.
+#[derive(Clone, Copy, PartialEq)]
+pub enum OuterEnumType {
+	/// Collects the Event enums from all pallets.
+	Event,
+	/// Collects the Error enums from all pallets.
+	Error,
+}
+
+impl OuterEnumType {
+	/// The name of the structure this enum represents.
+	fn struct_name(&self) -> &str {
+		match self {
+			OuterEnumType::Event => "RuntimeEvent",
+			OuterEnumType::Error => "RuntimeError",
+		}
+	}
+
+	/// The name of the variant (ie `Event` or `Error`).
+	fn variant_name(&self) -> &str {
+		match self {
+			OuterEnumType::Event => "Event",
+			OuterEnumType::Error => "Error",
+		}
+	}
+}
+
+impl ToTokens for OuterEnumType {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		match self {
+			OuterEnumType::Event => quote!(Event).to_tokens(tokens),
+			OuterEnumType::Error => quote!(Error).to_tokens(tokens),
+		}
+	}
+}
+
+/// Create an outer enum that encapsulates all pallets as variants.
+///
+/// Each variant represents a pallet and contains the corresponding type declared with either:
+/// - #[pallet::event] for the [`OuterEnumType::Event`] variant
+/// - #[pallet::error] for the [`OuterEnumType::Error`] variant
+///
+/// The name of the outer enum is prefixed with Runtime, resulting in names like RuntimeEvent
+/// or RuntimeError.
+///
+/// This structure facilitates the decoding process by leveraging the metadata.
+///
+/// # Example
+///
+/// The code generate looks like the following for [`OuterEnumType::Event`].
+///
+/// ```ignore
+/// enum RuntimeEvent {
+///     #[codec(index = 0)]
+///     System(pallet_system::Event),
+///
+///     #[codec(index = 5)]
+///     Balances(pallet_system::Event),
+/// }
+/// ```
+///
+/// Notice that the pallet index is preserved using the `#[codec(index = ..)]` attribute.
+pub fn expand_outer_enum(
+	runtime: &Ident,
+	pallet_decls: &[Pallet],
+	scrate: &TokenStream,
+	enum_ty: OuterEnumType,
+) -> syn::Result<TokenStream> {
+	// Stores all pallet variants.
+	let mut enum_variants = TokenStream::new();
+	// Generates the enum conversion between the `Runtime` outer enum and the pallet's enum.
+	let mut enum_conversions = TokenStream::new();
+	// Specific for events to query via `is_event_part_defined!`.
+	let mut query_enum_part_macros = Vec::new();
+
+	let enum_name_str = enum_ty.variant_name();
+	let enum_name_ident = Ident::new(enum_ty.struct_name(), Span::call_site());
+
+	for pallet_decl in pallet_decls {
+		let Some(pallet_entry) = pallet_decl.find_part(enum_name_str) else { continue };
+
+		let path = &pallet_decl.path;
+		let pallet_name = &pallet_decl.name;
+		let index = pallet_decl.index;
+		let instance = pallet_decl.instance.as_ref();
+		let generics = &pallet_entry.generics;
+
+		if instance.is_some() && generics.params.is_empty() {
+			let msg = format!(
+				"Instantiable pallet with no generic `{}` cannot \
+					be constructed: pallet `{}` must have generic `{}`",
+				enum_name_str, pallet_name, enum_name_str,
+			);
+			return Err(syn::Error::new(pallet_name.span(), msg))
+		}
+
+		let part_is_generic = !generics.params.is_empty();
+		let pallet_enum = match (instance, part_is_generic) {
+			(Some(inst), true) => quote!(#path::#enum_ty::<#runtime, #path::#inst>),
+			(Some(inst), false) => quote!(#path::#enum_ty::<#path::#inst>),
+			(None, true) => quote!(#path::#enum_ty::<#runtime>),
+			(None, false) => quote!(#path::#enum_ty),
+		};
+
+		enum_variants.extend(expand_enum_variant(
+			runtime,
+			pallet_decl,
+			index,
+			instance,
+			generics,
+			enum_ty,
+		));
+		enum_conversions.extend(expand_enum_conversion(
+			scrate,
+			pallet_decl,
+			&pallet_enum,
+			&enum_name_ident,
+		));
+
+		if enum_ty == OuterEnumType::Event {
+			query_enum_part_macros.push(quote! {
+				#path::__substrate_event_check::is_event_part_defined!(#pallet_name);
+			});
+		}
+	}
+
+	// Derives specific for the event.
+	let event_custom_derives =
+		if enum_ty == OuterEnumType::Event { quote!(Clone, PartialEq, Eq,) } else { quote!() };
+
+	// Implementation specific for errors.
+	let error_custom_impl = generate_error_impl(scrate, enum_ty);
+
+	Ok(quote! {
+		#( #query_enum_part_macros )*
+
+		#[derive(
+			#event_custom_derives
+			#scrate::__private::codec::Encode,
+			#scrate::__private::codec::Decode,
+			#scrate::__private::scale_info::TypeInfo,
+			#scrate::__private::RuntimeDebug,
+		)]
+		#[allow(non_camel_case_types)]
+		pub enum #enum_name_ident {
+			#enum_variants
+		}
+
+		#enum_conversions
+
+		#error_custom_impl
+	})
+}
+
+fn expand_enum_variant(
+	runtime: &Ident,
+	pallet: &Pallet,
+	index: u8,
+	instance: Option<&Ident>,
+	generics: &Generics,
+	enum_ty: OuterEnumType,
+) -> TokenStream {
+	let path = &pallet.path;
+	let variant_name = &pallet.name;
+	let part_is_generic = !generics.params.is_empty();
+	let attr = pallet.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+		let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+			.expect("was successfully parsed before; qed");
+		quote! {
+			#acc
+			#attr
+		}
+	});
+
+	match instance {
+		Some(inst) if part_is_generic => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::#enum_ty<#runtime, #path::#inst>),
+		},
+		Some(inst) => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::#enum_ty<#path::#inst>),
+		},
+		None if part_is_generic => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::#enum_ty<#runtime>),
+		},
+		None => quote! {
+			#attr
+			#[codec(index = #index)]
+			#variant_name(#path::#enum_ty),
+		},
+	}
+}
+
+fn expand_enum_conversion(
+	scrate: &TokenStream,
+	pallet: &Pallet,
+	pallet_enum: &TokenStream,
+	enum_name_ident: &Ident,
+) -> TokenStream {
+	let variant_name = &pallet.name;
+	let attr = pallet.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+		let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+			.expect("was successfully parsed before; qed");
+		quote! {
+			#acc
+			#attr
+		}
+	});
+
+	quote! {
+		#attr
+		impl From<#pallet_enum> for #enum_name_ident {
+			fn from(x: #pallet_enum) -> Self {
+				#enum_name_ident
+				::#variant_name(x)
+			}
+		}
+		#attr
+		impl TryInto<#pallet_enum> for #enum_name_ident {
+			type Error = ();
+
+			fn try_into(self) -> #scrate::__private::sp_std::result::Result<#pallet_enum, Self::Error> {
+				match self {
+					Self::#variant_name(evt) => Ok(evt),
+					_ => Err(()),
+				}
+			}
+		}
+	}
+}
+
+fn generate_error_impl(scrate: &TokenStream, enum_ty: OuterEnumType) -> TokenStream {
+	// Implementation is specific to `Error`s.
+	if enum_ty == OuterEnumType::Event {
+		return quote! {}
+	}
+
+	let enum_name_ident = Ident::new(enum_ty.struct_name(), Span::call_site());
+
+	quote! {
+		impl #enum_name_ident {
+			/// Optionally convert the `DispatchError` into the `RuntimeError`.
+			///
+			/// Returns `Some` if the error matches the `DispatchError::Module` variant, otherwise `None`.
+			pub fn from_dispatch_error(err: #scrate::sp_runtime::DispatchError) -> Option<Self> {
+				let #scrate::sp_runtime::DispatchError::Module(module_error) = err else { return None };
+
+				let bytes = #scrate::__private::codec::Encode::encode(&module_error);
+				#scrate::__private::codec::Decode::decode(&mut &bytes[..]).ok()
+			}
+		}
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/slash_reason.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/slash_reason.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a3283230ad84baa02d159c74b72ec63a38230e8
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/slash_reason.rs
@@ -0,0 +1,68 @@
+// 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::construct_runtime::{parse::PalletPath, Pallet};
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+
+pub fn expand_outer_slash_reason(pallet_decls: &[Pallet], scrate: &TokenStream) -> TokenStream {
+	let mut conversion_fns = Vec::new();
+	let mut slash_reason_variants = Vec::new();
+	for decl in pallet_decls {
+		if let Some(_) = decl.find_part("SlashReason") {
+			let variant_name = &decl.name;
+			let path = &decl.path;
+			let index = decl.index;
+
+			conversion_fns.push(expand_conversion_fn(path, variant_name));
+
+			slash_reason_variants.push(expand_variant(index, path, variant_name));
+		}
+	}
+
+	quote! {
+		/// A reason for slashing funds.
+		#[derive(
+			Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+			#scrate::__private::codec::Encode, #scrate::__private::codec::Decode, #scrate::__private::codec::MaxEncodedLen,
+			#scrate::__private::scale_info::TypeInfo,
+			#scrate::__private::RuntimeDebug,
+		)]
+		pub enum RuntimeSlashReason {
+			#( #slash_reason_variants )*
+		}
+
+		#( #conversion_fns )*
+	}
+}
+
+fn expand_conversion_fn(path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		impl From<#path::SlashReason> for RuntimeSlashReason {
+			fn from(hr: #path::SlashReason) -> Self {
+				RuntimeSlashReason::#variant_name(hr)
+			}
+		}
+	}
+}
+
+fn expand_variant(index: u8, path: &PalletPath, variant_name: &Ident) -> TokenStream {
+	quote! {
+		#[codec(index = #index)]
+		#variant_name(#path::SlashReason),
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/expand/unsigned.rs b/substrate/frame/support/procedural/src/construct_runtime/expand/unsigned.rs
new file mode 100644
index 0000000000000000000000000000000000000000..33aadba0d1f1c522aae13fb647b9fe8a918d8e24
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/expand/unsigned.rs
@@ -0,0 +1,89 @@
+// 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::construct_runtime::Pallet;
+use proc_macro2::TokenStream;
+use quote::quote;
+use std::str::FromStr;
+use syn::Ident;
+
+pub fn expand_outer_validate_unsigned(
+	runtime: &Ident,
+	pallet_decls: &[Pallet],
+	scrate: &TokenStream,
+) -> TokenStream {
+	let mut pallet_names = Vec::new();
+	let mut pallet_attrs = Vec::new();
+	let mut query_validate_unsigned_part_macros = Vec::new();
+
+	for pallet_decl in pallet_decls {
+		if pallet_decl.exists_part("ValidateUnsigned") {
+			let name = &pallet_decl.name;
+			let path = &pallet_decl.path;
+			let attr = pallet_decl.cfg_pattern.iter().fold(TokenStream::new(), |acc, pattern| {
+				let attr = TokenStream::from_str(&format!("#[cfg({})]", pattern.original()))
+					.expect("was successfully parsed before; qed");
+				quote! {
+					#acc
+					#attr
+				}
+			});
+
+			pallet_names.push(name);
+			pallet_attrs.push(attr);
+			query_validate_unsigned_part_macros.push(quote! {
+				#path::__substrate_validate_unsigned_check::is_validate_unsigned_part_defined!(#name);
+			});
+		}
+	}
+
+	quote! {
+		#( #query_validate_unsigned_part_macros )*
+
+		impl #scrate::unsigned::ValidateUnsigned for #runtime {
+			type Call = RuntimeCall;
+
+			fn pre_dispatch(call: &Self::Call) -> Result<(), #scrate::unsigned::TransactionValidityError> {
+				#[allow(unreachable_patterns)]
+				match call {
+					#(
+						#pallet_attrs
+						RuntimeCall::#pallet_names(inner_call) => #pallet_names::pre_dispatch(inner_call),
+					)*
+					// pre-dispatch should not stop inherent extrinsics, validation should prevent
+					// including arbitrary (non-inherent) extrinsics to blocks.
+					_ => Ok(()),
+				}
+			}
+
+			fn validate_unsigned(
+				#[allow(unused_variables)]
+				source: #scrate::unsigned::TransactionSource,
+				call: &Self::Call,
+			) -> #scrate::unsigned::TransactionValidity {
+				#[allow(unreachable_patterns)]
+				match call {
+					#(
+						#pallet_attrs
+						RuntimeCall::#pallet_names(inner_call) => #pallet_names::validate_unsigned(source, inner_call),
+					)*
+					_ => #scrate::unsigned::UnknownTransaction::NoUnsignedValidator.into(),
+				}
+			}
+		}
+	}
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/mod.rs b/substrate/frame/support/procedural/src/construct_runtime/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f42dd837e3a95978db83912d6b8298ec70ae778a
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/mod.rs
@@ -0,0 +1,830 @@
+// 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.
+
+//! Implementation of `construct_runtime`.
+//!
+//! `construct_runtime` implementation is recursive and can generate code which will call itself in
+//! order to get all the pallet parts for each pallet.
+//!
+//! Pallets can define their parts:
+//!  - Implicitely: `System: frame_system`
+//!  - Explicitly: `System: frame_system::{Pallet, Call}`
+//!
+//! The `construct_runtime` transitions from the implicit definition to the explict one.
+//! From the explicit state, Substrate expands the pallets with additional information
+//! that is to be included in the runtime metadata. This expansion makes visible some extra
+//! parts of the pallets, mainly the `Error` if defined. The expanded state looks like
+//! `System: frame_system expanded::{Error} ::{Pallet, Call}` and concatenates the extra expanded
+//! parts with the user-provided parts. For example, the `Pallet`, `Call` and `Error` parts are
+//! collected.
+//!
+//! Pallets must provide the `tt_extra_parts` and `tt_default_parts` macros for these transitions.
+//! These are automatically implemented by the `#[pallet::pallet]` macro.
+//!
+//! This macro also generates the following enums for ease of decoding:
+//!  - `enum RuntimeCall`: This type contains the information needed to decode extrinsics.
+//!  - `enum RuntimeEvent`: This type contains the information needed to decode events.
+//!  - `enum RuntimeError`: While this cannot be used directly to decode `sp_runtime::DispatchError`
+//!    from the chain, it contains the information needed to decode the
+//!    `sp_runtime::DispatchError::Module`.
+//!
+//! # State Transitions
+//!
+//! ```ignore
+//!  +----------+
+//!  | Implicit | -----------+
+//!  +----------+            |
+//!      |                   |
+//!      v                   v
+//!  +----------+     +------------------+
+//!  | Explicit | --> | ExplicitExpanded |
+//!  +----------+     +------------------+
+//! ```
+//!
+//! When all pallet parts are implcit, then the `construct_runtime!` macro expands to its final
+//! state, the `ExplicitExpanded`. Otherwise, all implicit parts are converted to an explicit
+//! expanded part allow the `construct_runtime!` to expand any remaining explicit parts to an
+//! explicit expanded part.
+//!
+//! # Implicit to Explicit
+//!
+//! The `construct_runtime` macro transforms the implicit declaration of each pallet
+//! `System: frame_system` to an explicit one `System: frame_system::{Pallet, Call}` using the
+//! `tt_default_parts` macro.
+//!
+//! The `tt_default_parts` macro exposes a comma separated list of pallet parts. For example, the
+//! `Event` part is exposed only if the pallet implements an event via `#[pallet::event]` macro.
+//! The tokens generated by this macro are ` expanded :: { Pallet, Call }` for our example.
+//!
+//! The `match_and_insert` macro takes in 3 arguments:
+//!  - target: This is the `TokenStream` that contains the `construct_runtime!` macro.
+//!  - pattern: The pattern to match against in the target stream.
+//!  - tokens: The tokens to added after the pattern match.
+//!
+//! The `construct_runtime` macro uses the `tt_call` to get the default pallet parts via
+//! the `tt_default_parts` macro defined by each pallet. The pallet parts are then returned as
+//! input to the `match_and_replace` macro.
+//! The `match_and_replace` then will modify the the `construct_runtime!` to expand the implicit
+//! definition to the explicit one.
+//!
+//! For example,
+//!
+//! ```ignore
+//! construct_runtime!(
+//! 	//...
+//! 	{
+//! 		System: frame_system = 0, // Implicit definition of parts
+//! 		Balances: pallet_balances = 1, // Implicit definition of parts
+//! 	}
+//! );
+//! ```
+//! This call has some implicit pallet parts, thus it will expand to:
+//! ```ignore
+//! frame_support::__private::tt_call! {
+//! 	macro = [{ pallet_balances::tt_default_parts }]
+//! 	~~> frame_support::match_and_insert! {
+//! 		target = [{
+//! 			frame_support::__private::tt_call! {
+//! 				macro = [{ frame_system::tt_default_parts }]
+//! 				~~> frame_support::match_and_insert! {
+//! 					target = [{
+//! 						construct_runtime!(
+//! 							//...
+//! 							{
+//! 								System: frame_system = 0,
+//! 								Balances: pallet_balances = 1,
+//! 							}
+//! 						);
+//! 					}]
+//! 					pattern = [{ System: frame_system }]
+//! 				}
+//! 			}
+//! 		}]
+//! 		pattern = [{ Balances: pallet_balances }]
+//! 	}
+//! }
+//! ```
+//! `tt_default_parts` must be defined. It returns the pallet parts inside some tokens, and
+//! then `tt_call` will pipe the returned pallet parts into the input of `match_and_insert`.
+//! Thus `match_and_insert` will initially receive the following inputs:
+//! ```ignore
+//! frame_support::match_and_insert! {
+//! 	target = [{
+//! 		frame_support::match_and_insert! {
+//! 			target = [{
+//! 				construct_runtime!(
+//! 					//...
+//! 					{
+//! 						System: frame_system = 0,
+//! 						Balances: pallet_balances = 1,
+//! 					}
+//! 				)
+//! 			}]
+//! 			pattern = [{ System: frame_system }]
+//! 			tokens = [{ ::{Pallet, Call} }]
+//! 		}
+//! 	}]
+//! 	pattern = [{ Balances: pallet_balances }]
+//! 	tokens = [{ ::{Pallet, Call} }]
+//! }
+//! ```
+//! After dealing with `pallet_balances`, the inner `match_and_insert` will expand to:
+//! ```ignore
+//! frame_support::match_and_insert! {
+//! 	target = [{
+//! 		construct_runtime!(
+//! 			//...
+//! 			{
+//! 				System: frame_system = 0, // Implicit definition of parts
+//! 				Balances: pallet_balances::{Pallet, Call} = 1, // Explicit definition of parts
+//! 			}
+//! 		)
+//! 	}]
+//! 	pattern = [{ System: frame_system }]
+//! 	tokens = [{ ::{Pallet, Call} }]
+//! }
+//! ```
+//!
+//! Which will then finally expand to the following:
+//! ```ignore
+//! construct_runtime!(
+//! 	//...
+//! 	{
+//! 		System: frame_system::{Pallet, Call},
+//! 		Balances: pallet_balances::{Pallet, Call},
+//! 	}
+//! )
+//! ```
+//!
+//! This call has no implicit pallet parts, thus it will expand to the runtime construction:
+//! ```ignore
+//! pub struct Runtime { ... }
+//! pub struct Call { ... }
+//! impl Call ...
+//! pub enum Origin { ... }
+//! ...
+//! ```
+//!
+//! Visualizing the entire flow of `construct_runtime!`, it would look like the following:
+//!
+//! ```ignore
+//! +--------------------+     +---------------------+     +-------------------+
+//! |                    |     | (defined in pallet) |     |                   |
+//! | construct_runtime! | --> |  tt_default_parts!  | --> | match_and_insert! |
+//! | w/ no pallet parts |     |                     |     |                   |
+//! +--------------------+     +---------------------+     +-------------------+
+//!
+//!     +--------------------+
+//!     |                    |
+//! --> | construct_runtime! |
+//!     |  w/ pallet parts   |
+//!     +--------------------+
+//! ```
+//!
+//! # Explicit to Explicit Expanded
+//!
+//! Users normally do not care about this transition.
+//!
+//! Similarly to the previous transition, the macro expansion transforms `System:
+//! frame_system::{Pallet, Call}` into  `System: frame_system expanded::{Error} ::{Pallet, Call}`.
+//! The `expanded` section adds extra parts that the Substrate would like to expose for each pallet
+//! by default. This is done to expose the approprite types for metadata construction.
+//!
+//! This time, instead of calling `tt_default_parts` we are using the `tt_extra_parts` macro.
+//! This macro returns the ` :: expanded { Error }` list of additional parts we would like to
+//! expose.
+
+mod expand;
+mod parse;
+
+use cfg_expr::Predicate;
+use frame_support_procedural_tools::{
+	generate_crate_access, generate_crate_access_2018, generate_hidden_includes,
+};
+use itertools::Itertools;
+use parse::{ExplicitRuntimeDeclaration, ImplicitRuntimeDeclaration, Pallet, RuntimeDeclaration};
+use proc_macro::TokenStream;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use std::{collections::HashSet, str::FromStr};
+use syn::{spanned::Spanned, Ident, Result};
+
+/// The fixed name of the system pallet.
+const SYSTEM_PALLET_NAME: &str = "System";
+
+/// Implementation of `construct_runtime` macro. Either expand to some code which will call
+/// `construct_runtime` again, or expand to the final runtime definition.
+pub fn construct_runtime(input: TokenStream) -> TokenStream {
+	let input_copy = input.clone();
+	let definition = syn::parse_macro_input!(input as RuntimeDeclaration);
+
+	let res = match definition {
+		RuntimeDeclaration::Implicit(implicit_def) =>
+			check_pallet_number(input_copy.clone().into(), implicit_def.pallets.len()).and_then(
+				|_| construct_runtime_implicit_to_explicit(input_copy.into(), implicit_def),
+			),
+		RuntimeDeclaration::Explicit(explicit_decl) => check_pallet_number(
+			input_copy.clone().into(),
+			explicit_decl.pallets.len(),
+		)
+		.and_then(|_| {
+			construct_runtime_explicit_to_explicit_expanded(input_copy.into(), explicit_decl)
+		}),
+		RuntimeDeclaration::ExplicitExpanded(explicit_decl) =>
+			check_pallet_number(input_copy.into(), explicit_decl.pallets.len())
+				.and_then(|_| construct_runtime_final_expansion(explicit_decl)),
+	};
+
+	let res = res.unwrap_or_else(|e| e.to_compile_error());
+
+	let res = expander::Expander::new("construct_runtime")
+		.dry(std::env::var("FRAME_EXPAND").is_err())
+		.verbose(true)
+		.write_to_out_dir(res)
+		.expect("Does not fail because of IO in OUT_DIR; qed");
+
+	res.into()
+}
+
+/// All pallets that have implicit pallet parts (ie `System: frame_system`) are
+/// expanded with the default parts defined by the pallet's `tt_default_parts` macro.
+///
+/// This function transforms the [`RuntimeDeclaration::Implicit`] into
+/// [`RuntimeDeclaration::Explicit`] that is not yet fully expanded.
+///
+/// For more details, please refer to the root documentation.
+fn construct_runtime_implicit_to_explicit(
+	input: TokenStream2,
+	definition: ImplicitRuntimeDeclaration,
+) -> Result<TokenStream2> {
+	let frame_support = generate_crate_access_2018("frame-support")?;
+	let mut expansion = quote::quote!(
+		#frame_support::construct_runtime! { #input }
+	);
+	for pallet in definition.pallets.iter().filter(|pallet| pallet.pallet_parts.is_none()) {
+		let pallet_path = &pallet.path;
+		let pallet_name = &pallet.name;
+		let pallet_instance = pallet.instance.as_ref().map(|instance| quote::quote!(::<#instance>));
+		expansion = quote::quote!(
+			#frame_support::__private::tt_call! {
+				macro = [{ #pallet_path::tt_default_parts }]
+				frame_support = [{ #frame_support }]
+				~~> #frame_support::match_and_insert! {
+					target = [{ #expansion }]
+					pattern = [{ #pallet_name: #pallet_path #pallet_instance }]
+				}
+			}
+		);
+	}
+
+	Ok(expansion)
+}
+
+/// All pallets that have
+///   (I): explicit pallet parts (ie `System: frame_system::{Pallet, Call}`) and
+///   (II): are not fully expanded (ie do not include the `Error` expansion part)
+/// are fully expanded by including the parts from the pallet's `tt_extra_parts` macro.
+///
+/// This function transforms the [`RuntimeDeclaration::Explicit`] that is not yet fully expanded
+/// into [`RuntimeDeclaration::ExplicitExpanded`] fully expanded.
+///
+/// For more details, please refer to the root documentation.
+fn construct_runtime_explicit_to_explicit_expanded(
+	input: TokenStream2,
+	definition: ExplicitRuntimeDeclaration,
+) -> Result<TokenStream2> {
+	let frame_support = generate_crate_access_2018("frame-support")?;
+	let mut expansion = quote::quote!(
+		#frame_support::construct_runtime! { #input }
+	);
+	for pallet in definition.pallets.iter().filter(|pallet| !pallet.is_expanded) {
+		let pallet_path = &pallet.path;
+		let pallet_name = &pallet.name;
+		let pallet_instance = pallet.instance.as_ref().map(|instance| quote::quote!(::<#instance>));
+		expansion = quote::quote!(
+			#frame_support::__private::tt_call! {
+				macro = [{ #pallet_path::tt_extra_parts }]
+				frame_support = [{ #frame_support }]
+				~~> #frame_support::match_and_insert! {
+					target = [{ #expansion }]
+					pattern = [{ #pallet_name: #pallet_path #pallet_instance }]
+				}
+			}
+		);
+	}
+
+	Ok(expansion)
+}
+
+/// All pallets have explicit definition of parts, this will expand to the runtime declaration.
+fn construct_runtime_final_expansion(
+	definition: ExplicitRuntimeDeclaration,
+) -> Result<TokenStream2> {
+	let ExplicitRuntimeDeclaration { name, pallets, pallets_token, where_section } = definition;
+
+	let system_pallet =
+		pallets.iter().find(|decl| decl.name == SYSTEM_PALLET_NAME).ok_or_else(|| {
+			syn::Error::new(
+				pallets_token.span.join(),
+				"`System` pallet declaration is missing. \
+			 Please add this line: `System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},`",
+			)
+		})?;
+	if !system_pallet.cfg_pattern.is_empty() {
+		return Err(syn::Error::new(
+			system_pallet.name.span(),
+			"`System` pallet declaration is feature gated, please remove any `#[cfg]` attributes",
+		))
+	}
+
+	let features = pallets
+		.iter()
+		.filter_map(|decl| {
+			(!decl.cfg_pattern.is_empty()).then(|| {
+				decl.cfg_pattern.iter().flat_map(|attr| {
+					attr.predicates().filter_map(|pred| match pred {
+						Predicate::Feature(feat) => Some(feat),
+						Predicate::Test => Some("test"),
+						_ => None,
+					})
+				})
+			})
+		})
+		.flatten()
+		.collect::<HashSet<_>>();
+
+	let hidden_crate_name = "construct_runtime";
+	let scrate = generate_crate_access(hidden_crate_name, "frame-support");
+	let scrate_decl = generate_hidden_includes(hidden_crate_name, "frame-support");
+
+	let frame_system = generate_crate_access_2018("frame-system")?;
+	let block = quote!(<#name as #frame_system::Config>::Block);
+	let unchecked_extrinsic = quote!(<#block as #scrate::sp_runtime::traits::Block>::Extrinsic);
+
+	let outer_event =
+		expand::expand_outer_enum(&name, &pallets, &scrate, expand::OuterEnumType::Event)?;
+	let outer_error =
+		expand::expand_outer_enum(&name, &pallets, &scrate, expand::OuterEnumType::Error)?;
+
+	let outer_origin = expand::expand_outer_origin(&name, system_pallet, &pallets, &scrate)?;
+	let all_pallets = decl_all_pallets(&name, pallets.iter(), &features);
+	let pallet_to_index = decl_pallet_runtime_setup(&name, &pallets, &scrate);
+
+	let dispatch = expand::expand_outer_dispatch(&name, system_pallet, &pallets, &scrate);
+	let metadata = expand::expand_runtime_metadata(
+		&name,
+		&pallets,
+		&scrate,
+		&unchecked_extrinsic,
+		&system_pallet.path,
+	);
+	let outer_config = expand::expand_outer_config(&name, &pallets, &scrate);
+	let inherent =
+		expand::expand_outer_inherent(&name, &block, &unchecked_extrinsic, &pallets, &scrate);
+	let validate_unsigned = expand::expand_outer_validate_unsigned(&name, &pallets, &scrate);
+	let freeze_reason = expand::expand_outer_freeze_reason(&pallets, &scrate);
+	let hold_reason = expand::expand_outer_hold_reason(&pallets, &scrate);
+	let lock_id = expand::expand_outer_lock_id(&pallets, &scrate);
+	let slash_reason = expand::expand_outer_slash_reason(&pallets, &scrate);
+	let integrity_test = decl_integrity_test(&scrate);
+	let static_assertions = decl_static_assertions(&name, &pallets, &scrate);
+
+	let warning =
+		where_section.map_or(None, |where_section| {
+			Some(proc_macro_warning::Warning::new_deprecated("WhereSection")
+			.old("use a `where` clause in `construct_runtime`")
+			.new("use `frame_system::Config` to set the `Block` type and delete this clause. 
+				It is planned to be removed in December 2023")
+			.help_links(&["https://github.com/paritytech/substrate/pull/14437"])
+			.span(where_section.span)
+			.build(),
+		)
+		});
+
+	let res = quote!(
+		#warning
+
+		#scrate_decl
+
+		// Prevent UncheckedExtrinsic to print unused warning.
+		const _: () = {
+			#[allow(unused)]
+			type __hidden_use_of_unchecked_extrinsic = #unchecked_extrinsic;
+		};
+
+		#[derive(
+			Clone, Copy, PartialEq, Eq, #scrate::sp_runtime::RuntimeDebug,
+			#scrate::__private::scale_info::TypeInfo
+		)]
+		pub struct #name;
+		impl #scrate::sp_runtime::traits::GetRuntimeBlockType for #name {
+			type RuntimeBlock = #block;
+		}
+
+		// Each runtime must expose the `runtime_metadata()` to fetch the runtime API metadata.
+		// The function is implemented by calling `impl_runtime_apis!`.
+		//
+		// However, the `construct_runtime!` may be called without calling `impl_runtime_apis!`.
+		// Rely on the `Deref` trait to differentiate between a runtime that implements
+		// APIs (by macro impl_runtime_apis!) and a runtime that is simply created (by macro construct_runtime!).
+		//
+		// Both `InternalConstructRuntime` and `InternalImplRuntimeApis` expose a `runtime_metadata()` function.
+		// `InternalConstructRuntime` is implemented by the `construct_runtime!` for Runtime references (`& Runtime`),
+		// while `InternalImplRuntimeApis` is implemented by the `impl_runtime_apis!` for Runtime (`Runtime`).
+		//
+		// Therefore, the `Deref` trait will resolve the `runtime_metadata` from `impl_runtime_apis!`
+		// when both macros are called; and will resolve an empty `runtime_metadata` when only the `construct_runtime!`
+		// is called.
+
+		#[doc(hidden)]
+		trait InternalConstructRuntime {
+			#[inline(always)]
+			fn runtime_metadata(&self) -> #scrate::__private::sp_std::vec::Vec<#scrate::__private::metadata_ir::RuntimeApiMetadataIR> {
+				Default::default()
+			}
+		}
+		#[doc(hidden)]
+		impl InternalConstructRuntime for &#name {}
+
+		#outer_event
+
+		#outer_error
+
+		#outer_origin
+
+		#all_pallets
+
+		#pallet_to_index
+
+		#dispatch
+
+		#metadata
+
+		#outer_config
+
+		#inherent
+
+		#validate_unsigned
+
+		#freeze_reason
+
+		#hold_reason
+
+		#lock_id
+
+		#slash_reason
+
+		#integrity_test
+
+		#static_assertions
+	);
+
+	Ok(res)
+}
+
+fn decl_all_pallets<'a>(
+	runtime: &'a Ident,
+	pallet_declarations: impl Iterator<Item = &'a Pallet>,
+	features: &HashSet<&str>,
+) -> TokenStream2 {
+	let mut types = TokenStream2::new();
+
+	// Every feature set to the pallet names that should be included by this feature set.
+	let mut features_to_names = features
+		.iter()
+		.map(|f| *f)
+		.powerset()
+		.map(|feat| (HashSet::from_iter(feat), Vec::new()))
+		.collect::<Vec<(HashSet<_>, Vec<_>)>>();
+
+	for pallet_declaration in pallet_declarations {
+		let type_name = &pallet_declaration.name;
+		let pallet = &pallet_declaration.path;
+		let mut generics = vec![quote!(#runtime)];
+		generics.extend(pallet_declaration.instance.iter().map(|name| quote!(#pallet::#name)));
+		let mut attrs = Vec::new();
+		for cfg in &pallet_declaration.cfg_pattern {
+			let feat = format!("#[cfg({})]\n", cfg.original());
+			attrs.extend(TokenStream2::from_str(&feat).expect("was parsed successfully; qed"));
+		}
+		let type_decl = quote!(
+			#(#attrs)*
+			pub type #type_name = #pallet::Pallet <#(#generics),*>;
+		);
+		types.extend(type_decl);
+
+		if pallet_declaration.cfg_pattern.is_empty() {
+			for (_, names) in features_to_names.iter_mut() {
+				names.push(&pallet_declaration.name);
+			}
+		} else {
+			for (feature_set, names) in &mut features_to_names {
+				// Rust tidbit: if we have multiple `#[cfg]` feature on the same item, then the
+				// predicates listed in all `#[cfg]` attributes are effectively joined by `and()`,
+				// meaning that all of them must match in order to activate the item
+				let is_feature_active = pallet_declaration.cfg_pattern.iter().all(|expr| {
+					expr.eval(|pred| match pred {
+						Predicate::Feature(f) => feature_set.contains(f),
+						Predicate::Test => feature_set.contains(&"test"),
+						_ => false,
+					})
+				});
+
+				if is_feature_active {
+					names.push(&pallet_declaration.name);
+				}
+			}
+		}
+	}
+
+	// All possible features. This will be used below for the empty feature set.
+	let mut all_features = features_to_names
+		.iter()
+		.flat_map(|f| f.0.iter().cloned())
+		.collect::<HashSet<_>>();
+	let attribute_to_names = features_to_names
+		.into_iter()
+		.map(|(mut features, names)| {
+			// If this is the empty feature set, it needs to be changed to negate all available
+			// features. So, we ensure that there is some type declared when all features are not
+			// enabled.
+			if features.is_empty() {
+				let test_cfg = all_features.remove("test").then_some(quote!(test)).into_iter();
+				let features = all_features.iter();
+				let attr = quote!(#[cfg(all( #(not(#test_cfg)),* #(not(feature = #features)),* ))]);
+
+				(attr, names)
+			} else {
+				let test_cfg = features.remove("test").then_some(quote!(test)).into_iter();
+				let disabled_features = all_features.difference(&features);
+				let features = features.iter();
+				let attr = quote!(#[cfg(all( #(#test_cfg,)* #(feature = #features,)* #(not(feature = #disabled_features)),* ))]);
+
+				(attr, names)
+			}
+		})
+		.collect::<Vec<_>>();
+
+	let all_pallets_without_system = attribute_to_names.iter().map(|(attr, names)| {
+		let names = names.iter().filter(|n| **n != SYSTEM_PALLET_NAME);
+		quote! {
+			#attr
+			/// All pallets included in the runtime as a nested tuple of types.
+			/// Excludes the System pallet.
+			pub type AllPalletsWithoutSystem = ( #(#names,)* );
+		}
+	});
+
+	let all_pallets_with_system = attribute_to_names.iter().map(|(attr, names)| {
+		quote! {
+			#attr
+			/// All pallets included in the runtime as a nested tuple of types.
+			pub type AllPalletsWithSystem = ( #(#names,)* );
+		}
+	});
+
+	let all_pallets_without_system_reversed = attribute_to_names.iter().map(|(attr, names)| {
+		let names = names.iter().filter(|n| **n != SYSTEM_PALLET_NAME).rev();
+		quote! {
+			#attr
+			/// All pallets included in the runtime as a nested tuple of types in reversed order.
+			/// Excludes the System pallet.
+			#[deprecated(note = "Using reverse pallet orders is deprecated. use only \
+			`AllPalletsWithSystem or AllPalletsWithoutSystem`")]
+			pub type AllPalletsWithoutSystemReversed = ( #(#names,)* );
+		}
+	});
+
+	let all_pallets_with_system_reversed = attribute_to_names.iter().map(|(attr, names)| {
+		let names = names.iter().rev();
+		quote! {
+			#attr
+			/// All pallets included in the runtime as a nested tuple of types in reversed order.
+			#[deprecated(note = "Using reverse pallet orders is deprecated. use only \
+			`AllPalletsWithSystem or AllPalletsWithoutSystem`")]
+			pub type AllPalletsWithSystemReversed = ( #(#names,)* );
+		}
+	});
+
+	let all_pallets_reversed_with_system_first = attribute_to_names.iter().map(|(attr, names)| {
+		let system = quote::format_ident!("{}", SYSTEM_PALLET_NAME);
+		let names = std::iter::once(&system)
+			.chain(names.iter().rev().filter(|n| **n != SYSTEM_PALLET_NAME).cloned());
+		quote! {
+			#attr
+			/// All pallets included in the runtime as a nested tuple of types in reversed order.
+			/// With the system pallet first.
+			#[deprecated(note = "Using reverse pallet orders is deprecated. use only \
+			`AllPalletsWithSystem or AllPalletsWithoutSystem`")]
+			pub type AllPalletsReversedWithSystemFirst = ( #(#names,)* );
+		}
+	});
+
+	quote!(
+		#types
+
+		/// All pallets included in the runtime as a nested tuple of types.
+		#[deprecated(note = "The type definition has changed from representing all pallets \
+			excluding system, in reversed order to become the representation of all pallets \
+			including system pallet in regular order. For this reason it is encouraged to use \
+			explicitly one of `AllPalletsWithSystem`, `AllPalletsWithoutSystem`, \
+			`AllPalletsWithSystemReversed`, `AllPalletsWithoutSystemReversed`. \
+			Note that the type `frame_executive::Executive` expects one of `AllPalletsWithSystem` \
+			, `AllPalletsWithSystemReversed`, `AllPalletsReversedWithSystemFirst`. More details in \
+			https://github.com/paritytech/substrate/pull/10043")]
+		pub type AllPallets = AllPalletsWithSystem;
+
+		#( #all_pallets_with_system )*
+
+		#( #all_pallets_without_system )*
+
+		#( #all_pallets_with_system_reversed )*
+
+		#( #all_pallets_without_system_reversed )*
+
+		#( #all_pallets_reversed_with_system_first )*
+	)
+}
+
+fn decl_pallet_runtime_setup(
+	runtime: &Ident,
+	pallet_declarations: &[Pallet],
+	scrate: &TokenStream2,
+) -> TokenStream2 {
+	let names = pallet_declarations.iter().map(|d| &d.name).collect::<Vec<_>>();
+	let name_strings = pallet_declarations.iter().map(|d| d.name.to_string());
+	let module_names = pallet_declarations.iter().map(|d| d.path.module_name());
+	let indices = pallet_declarations.iter().map(|pallet| pallet.index as usize);
+	let pallet_structs = pallet_declarations
+		.iter()
+		.map(|pallet| {
+			let path = &pallet.path;
+			match pallet.instance.as_ref() {
+				Some(inst) => quote!(#path::Pallet<#runtime, #path::#inst>),
+				None => quote!(#path::Pallet<#runtime>),
+			}
+		})
+		.collect::<Vec<_>>();
+	let pallet_attrs = pallet_declarations
+		.iter()
+		.map(|pallet| {
+			pallet.cfg_pattern.iter().fold(TokenStream2::new(), |acc, pattern| {
+				let attr = TokenStream2::from_str(&format!("#[cfg({})]", pattern.original()))
+					.expect("was successfully parsed before; qed");
+				quote! {
+					#acc
+					#attr
+				}
+			})
+		})
+		.collect::<Vec<_>>();
+
+	quote!(
+		/// Provides an implementation of `PalletInfo` to provide information
+		/// about the pallet setup in the runtime.
+		pub struct PalletInfo;
+
+		impl #scrate::traits::PalletInfo for PalletInfo {
+			fn index<P: 'static>() -> Option<usize> {
+				let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+				#(
+					#pallet_attrs
+					if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+						return Some(#indices)
+					}
+				)*
+
+				None
+			}
+
+			fn name<P: 'static>() -> Option<&'static str> {
+				let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+				#(
+					#pallet_attrs
+					if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+						return Some(#name_strings)
+					}
+				)*
+
+				None
+			}
+
+			fn module_name<P: 'static>() -> Option<&'static str> {
+				let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+				#(
+					#pallet_attrs
+					if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+						return Some(#module_names)
+					}
+				)*
+
+				None
+			}
+
+			fn crate_version<P: 'static>() -> Option<#scrate::traits::CrateVersion> {
+				let type_id = #scrate::__private::sp_std::any::TypeId::of::<P>();
+				#(
+					#pallet_attrs
+					if type_id == #scrate::__private::sp_std::any::TypeId::of::<#names>() {
+						return Some(
+							<#pallet_structs as #scrate::traits::PalletInfoAccess>::crate_version()
+						)
+					}
+				)*
+
+				None
+			}
+		}
+	)
+}
+
+fn decl_integrity_test(scrate: &TokenStream2) -> TokenStream2 {
+	quote!(
+		#[cfg(test)]
+		mod __construct_runtime_integrity_test {
+			use super::*;
+
+			#[test]
+			pub fn runtime_integrity_tests() {
+				#scrate::__private::sp_tracing::try_init_simple();
+				<AllPalletsWithSystem as #scrate::traits::IntegrityTest>::integrity_test();
+			}
+		}
+	)
+}
+
+fn decl_static_assertions(
+	runtime: &Ident,
+	pallet_decls: &[Pallet],
+	scrate: &TokenStream2,
+) -> TokenStream2 {
+	let error_encoded_size_check = pallet_decls.iter().map(|decl| {
+		let path = &decl.path;
+		let assert_message = format!(
+			"The maximum encoded size of the error type in the `{}` pallet exceeds \
+			`MAX_MODULE_ERROR_ENCODED_SIZE`",
+			decl.name,
+		);
+
+		quote! {
+			#scrate::__private::tt_call! {
+				macro = [{ #path::tt_error_token }]
+				frame_support = [{ #scrate }]
+				~~> #scrate::assert_error_encoded_size! {
+					path = [{ #path }]
+					runtime = [{ #runtime }]
+					assert_message = [{ #assert_message }]
+				}
+			}
+		}
+	});
+
+	quote! {
+		#(#error_encoded_size_check)*
+	}
+}
+
+fn check_pallet_number(input: TokenStream2, pallet_num: usize) -> Result<()> {
+	let max_pallet_num = {
+		if cfg!(feature = "tuples-96") {
+			96
+		} else if cfg!(feature = "tuples-128") {
+			128
+		} else {
+			64
+		}
+	};
+
+	if pallet_num > max_pallet_num {
+		let no_feature = max_pallet_num == 128;
+		return Err(syn::Error::new(
+			input.span(),
+			format!(
+				"{} To increase this limit, enable the tuples-{} feature of [frame_support]. {}",
+				"The number of pallets exceeds the maximum number of tuple elements.",
+				max_pallet_num + 32,
+				if no_feature {
+					"If the feature does not exist - it needs to be implemented."
+				} else {
+					""
+				},
+			),
+		))
+	}
+
+	Ok(())
+}
diff --git a/substrate/frame/support/procedural/src/construct_runtime/parse.rs b/substrate/frame/support/procedural/src/construct_runtime/parse.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9b08e16469754a98c8cc089176b973c7d1ce1fae
--- /dev/null
+++ b/substrate/frame/support/procedural/src/construct_runtime/parse.rs
@@ -0,0 +1,780 @@
+// 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_support_procedural_tools::syn_ext as ext;
+use proc_macro2::{Span, TokenStream};
+use quote::ToTokens;
+use std::collections::{HashMap, HashSet};
+use syn::{
+	ext::IdentExt,
+	parse::{Parse, ParseStream},
+	punctuated::Punctuated,
+	spanned::Spanned,
+	token, Attribute, Error, Ident, Path, Result, Token,
+};
+
+mod keyword {
+	syn::custom_keyword!(Block);
+	syn::custom_keyword!(NodeBlock);
+	syn::custom_keyword!(UncheckedExtrinsic);
+	syn::custom_keyword!(Pallet);
+	syn::custom_keyword!(Call);
+	syn::custom_keyword!(Storage);
+	syn::custom_keyword!(Event);
+	syn::custom_keyword!(Error);
+	syn::custom_keyword!(Config);
+	syn::custom_keyword!(Origin);
+	syn::custom_keyword!(Inherent);
+	syn::custom_keyword!(ValidateUnsigned);
+	syn::custom_keyword!(FreezeReason);
+	syn::custom_keyword!(HoldReason);
+	syn::custom_keyword!(LockId);
+	syn::custom_keyword!(SlashReason);
+	syn::custom_keyword!(exclude_parts);
+	syn::custom_keyword!(use_parts);
+	syn::custom_keyword!(expanded);
+}
+
+/// Declaration of a runtime.
+///
+/// Pallet declare their part either explicitly or implicitly (using no part declaration)
+/// If all pallet have explicit parts then the runtime declaration is explicit, otherwise it is
+/// implicit.
+#[derive(Debug)]
+pub enum RuntimeDeclaration {
+	Implicit(ImplicitRuntimeDeclaration),
+	Explicit(ExplicitRuntimeDeclaration),
+	ExplicitExpanded(ExplicitRuntimeDeclaration),
+}
+
+/// Declaration of a runtime with some pallet with implicit declaration of parts.
+#[derive(Debug)]
+pub struct ImplicitRuntimeDeclaration {
+	pub name: Ident,
+	pub where_section: Option<WhereSection>,
+	pub pallets: Vec<PalletDeclaration>,
+}
+
+/// Declaration of a runtime with all pallet having explicit declaration of parts.
+#[derive(Debug)]
+pub struct ExplicitRuntimeDeclaration {
+	pub name: Ident,
+	pub where_section: Option<WhereSection>,
+	pub pallets: Vec<Pallet>,
+	pub pallets_token: token::Brace,
+}
+
+impl Parse for RuntimeDeclaration {
+	fn parse(input: ParseStream) -> Result<Self> {
+		input.parse::<Token![pub]>()?;
+
+		// Support either `enum` or `struct`.
+		if input.peek(Token![struct]) {
+			input.parse::<Token![struct]>()?;
+		} else {
+			input.parse::<Token![enum]>()?;
+		}
+
+		let name = input.parse::<syn::Ident>()?;
+		let where_section = if input.peek(token::Where) { Some(input.parse()?) } else { None };
+		let pallets =
+			input.parse::<ext::Braces<ext::Punctuated<PalletDeclaration, Token![,]>>>()?;
+		let pallets_token = pallets.token;
+
+		match convert_pallets(pallets.content.inner.into_iter().collect())? {
+			PalletsConversion::Implicit(pallets) =>
+				Ok(RuntimeDeclaration::Implicit(ImplicitRuntimeDeclaration {
+					name,
+					where_section,
+					pallets,
+				})),
+			PalletsConversion::Explicit(pallets) =>
+				Ok(RuntimeDeclaration::Explicit(ExplicitRuntimeDeclaration {
+					name,
+					where_section,
+					pallets,
+					pallets_token,
+				})),
+			PalletsConversion::ExplicitExpanded(pallets) =>
+				Ok(RuntimeDeclaration::ExplicitExpanded(ExplicitRuntimeDeclaration {
+					name,
+					where_section,
+					pallets,
+					pallets_token,
+				})),
+		}
+	}
+}
+
+#[derive(Debug)]
+pub struct WhereSection {
+	pub span: Span,
+	pub block: syn::TypePath,
+	pub node_block: syn::TypePath,
+	pub unchecked_extrinsic: syn::TypePath,
+}
+
+impl Parse for WhereSection {
+	fn parse(input: ParseStream) -> Result<Self> {
+		input.parse::<token::Where>()?;
+
+		let mut definitions = Vec::new();
+		while !input.peek(token::Brace) {
+			let definition: WhereDefinition = input.parse()?;
+			definitions.push(definition);
+			if !input.peek(Token![,]) {
+				if !input.peek(token::Brace) {
+					return Err(input.error("Expected `,` or `{`"))
+				}
+				break
+			}
+			input.parse::<Token![,]>()?;
+		}
+		let block = remove_kind(input, WhereKind::Block, &mut definitions)?.value;
+		let node_block = remove_kind(input, WhereKind::NodeBlock, &mut definitions)?.value;
+		let unchecked_extrinsic =
+			remove_kind(input, WhereKind::UncheckedExtrinsic, &mut definitions)?.value;
+		if let Some(WhereDefinition { ref kind_span, ref kind, .. }) = definitions.first() {
+			let msg = format!(
+				"`{:?}` was declared above. Please use exactly one declaration for `{:?}`.",
+				kind, kind
+			);
+			return Err(Error::new(*kind_span, msg))
+		}
+		Ok(Self { span: input.span(), block, node_block, unchecked_extrinsic })
+	}
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
+pub enum WhereKind {
+	Block,
+	NodeBlock,
+	UncheckedExtrinsic,
+}
+
+#[derive(Debug)]
+pub struct WhereDefinition {
+	pub kind_span: Span,
+	pub kind: WhereKind,
+	pub value: syn::TypePath,
+}
+
+impl Parse for WhereDefinition {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let lookahead = input.lookahead1();
+		let (kind_span, kind) = if lookahead.peek(keyword::Block) {
+			(input.parse::<keyword::Block>()?.span(), WhereKind::Block)
+		} else if lookahead.peek(keyword::NodeBlock) {
+			(input.parse::<keyword::NodeBlock>()?.span(), WhereKind::NodeBlock)
+		} else if lookahead.peek(keyword::UncheckedExtrinsic) {
+			(input.parse::<keyword::UncheckedExtrinsic>()?.span(), WhereKind::UncheckedExtrinsic)
+		} else {
+			return Err(lookahead.error())
+		};
+
+		Ok(Self {
+			kind_span,
+			kind,
+			value: {
+				let _: Token![=] = input.parse()?;
+				input.parse()?
+			},
+		})
+	}
+}
+
+/// The declaration of a pallet.
+#[derive(Debug, Clone)]
+pub struct PalletDeclaration {
+	/// Is this pallet fully expanded?
+	pub is_expanded: bool,
+	/// The name of the pallet, e.g.`System` in `System: frame_system`.
+	pub name: Ident,
+	/// Optional attributes tagged right above a pallet declaration.
+	pub attrs: Vec<Attribute>,
+	/// Optional fixed index, e.g. `MyPallet ...  = 3,`.
+	pub index: Option<u8>,
+	/// The path of the pallet, e.g. `frame_system` in `System: frame_system`.
+	pub path: PalletPath,
+	/// The instance of the pallet, e.g. `Instance1` in `Council: pallet_collective::<Instance1>`.
+	pub instance: Option<Ident>,
+	/// The declared pallet parts,
+	/// e.g. `Some([Pallet, Call])` for `System: system::{Pallet, Call}`
+	/// or `None` for `System: system`.
+	pub pallet_parts: Option<Vec<PalletPart>>,
+	/// The specified parts, either use_parts or exclude_parts.
+	pub specified_parts: SpecifiedParts,
+}
+
+/// The possible declaration of pallet parts to use.
+#[derive(Debug, Clone)]
+pub enum SpecifiedParts {
+	/// Use all the pallet parts except those specified.
+	Exclude(Vec<PalletPartNoGeneric>),
+	/// Use only the specified pallet parts.
+	Use(Vec<PalletPartNoGeneric>),
+	/// Use the all the pallet parts.
+	All,
+}
+
+impl Parse for PalletDeclaration {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let attrs = input.call(Attribute::parse_outer)?;
+
+		let name = input.parse()?;
+		let _: Token![:] = input.parse()?;
+		let path = input.parse()?;
+
+		// Parse for instance.
+		let instance = if input.peek(Token![::]) && input.peek3(Token![<]) {
+			let _: Token![::] = input.parse()?;
+			let _: Token![<] = input.parse()?;
+			let res = Some(input.parse()?);
+			let _: Token![>] = input.parse()?;
+			res
+		} else if !(input.peek(Token![::]) && input.peek3(token::Brace)) &&
+			!input.peek(keyword::expanded) &&
+			!input.peek(keyword::exclude_parts) &&
+			!input.peek(keyword::use_parts) &&
+			!input.peek(Token![=]) &&
+			!input.peek(Token![,]) &&
+			!input.is_empty()
+		{
+			return Err(input.error(
+				"Unexpected tokens, expected one of `::$ident` `::{`, `exclude_parts`, `use_parts`, `=`, `,`",
+			));
+		} else {
+			None
+		};
+
+		// Check if the pallet is fully expanded.
+		let (is_expanded, extra_parts) = if input.peek(keyword::expanded) {
+			let _: keyword::expanded = input.parse()?;
+			let _: Token![::] = input.parse()?;
+			(true, parse_pallet_parts(input)?)
+		} else {
+			(false, vec![])
+		};
+
+		// Parse for explicit parts
+		let pallet_parts = if input.peek(Token![::]) && input.peek3(token::Brace) {
+			let _: Token![::] = input.parse()?;
+			let mut parts = parse_pallet_parts(input)?;
+			parts.extend(extra_parts.into_iter());
+			Some(parts)
+		} else if !input.peek(keyword::exclude_parts) &&
+			!input.peek(keyword::use_parts) &&
+			!input.peek(Token![=]) &&
+			!input.peek(Token![,]) &&
+			!input.is_empty()
+		{
+			return Err(input.error(
+				"Unexpected tokens, expected one of `::{`, `exclude_parts`, `use_parts`, `=`, `,`",
+			))
+		} else {
+			is_expanded.then_some(extra_parts)
+		};
+
+		// Parse for specified parts
+		let specified_parts = if input.peek(keyword::exclude_parts) {
+			let _: keyword::exclude_parts = input.parse()?;
+			SpecifiedParts::Exclude(parse_pallet_parts_no_generic(input)?)
+		} else if input.peek(keyword::use_parts) {
+			let _: keyword::use_parts = input.parse()?;
+			SpecifiedParts::Use(parse_pallet_parts_no_generic(input)?)
+		} else if !input.peek(Token![=]) && !input.peek(Token![,]) && !input.is_empty() {
+			return Err(input.error("Unexpected tokens, expected one of `exclude_parts`, `=`, `,`"))
+		} else {
+			SpecifiedParts::All
+		};
+
+		// Parse for pallet index
+		let index = if input.peek(Token![=]) {
+			input.parse::<Token![=]>()?;
+			let index = input.parse::<syn::LitInt>()?;
+			let index = index.base10_parse::<u8>()?;
+			Some(index)
+		} else if !input.peek(Token![,]) && !input.is_empty() {
+			return Err(input.error("Unexpected tokens, expected one of `=`, `,`"))
+		} else {
+			None
+		};
+
+		Ok(Self { is_expanded, attrs, name, path, instance, pallet_parts, specified_parts, index })
+	}
+}
+
+/// A struct representing a path to a pallet. `PalletPath` is almost identical to the standard
+/// Rust path with a few restrictions:
+/// - No leading colons allowed
+/// - Path segments can only consist of identifers separated by colons
+#[derive(Debug, Clone)]
+pub struct PalletPath {
+	pub inner: Path,
+}
+
+impl PalletPath {
+	pub fn module_name(&self) -> String {
+		self.inner.segments.iter().fold(String::new(), |mut acc, segment| {
+			if !acc.is_empty() {
+				acc.push_str("::");
+			}
+			acc.push_str(&segment.ident.to_string());
+			acc
+		})
+	}
+}
+
+impl Parse for PalletPath {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let mut res =
+			PalletPath { inner: Path { leading_colon: None, segments: Punctuated::new() } };
+
+		let lookahead = input.lookahead1();
+		if lookahead.peek(Token![crate]) ||
+			lookahead.peek(Token![self]) ||
+			lookahead.peek(Token![super]) ||
+			lookahead.peek(Ident)
+		{
+			let ident = input.call(Ident::parse_any)?;
+			res.inner.segments.push(ident.into());
+		} else {
+			return Err(lookahead.error())
+		}
+
+		while input.peek(Token![::]) && input.peek3(Ident) {
+			input.parse::<Token![::]>()?;
+			let ident = input.parse::<Ident>()?;
+			res.inner.segments.push(ident.into());
+		}
+		Ok(res)
+	}
+}
+
+impl quote::ToTokens for PalletPath {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		self.inner.to_tokens(tokens);
+	}
+}
+
+/// Parse [`PalletPart`]'s from a braces enclosed list that is split by commas, e.g.
+///
+/// `{ Call, Event }`
+fn parse_pallet_parts(input: ParseStream) -> Result<Vec<PalletPart>> {
+	let pallet_parts: ext::Braces<ext::Punctuated<PalletPart, Token![,]>> = input.parse()?;
+
+	let mut resolved = HashSet::new();
+	for part in pallet_parts.content.inner.iter() {
+		if !resolved.insert(part.name()) {
+			let msg = format!(
+				"`{}` was already declared before. Please remove the duplicate declaration",
+				part.name(),
+			);
+			return Err(Error::new(part.keyword.span(), msg))
+		}
+	}
+
+	Ok(pallet_parts.content.inner.into_iter().collect())
+}
+
+#[derive(Debug, Clone)]
+pub enum PalletPartKeyword {
+	Pallet(keyword::Pallet),
+	Call(keyword::Call),
+	Storage(keyword::Storage),
+	Event(keyword::Event),
+	Error(keyword::Error),
+	Config(keyword::Config),
+	Origin(keyword::Origin),
+	Inherent(keyword::Inherent),
+	ValidateUnsigned(keyword::ValidateUnsigned),
+	FreezeReason(keyword::FreezeReason),
+	HoldReason(keyword::HoldReason),
+	LockId(keyword::LockId),
+	SlashReason(keyword::SlashReason),
+}
+
+impl Parse for PalletPartKeyword {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let lookahead = input.lookahead1();
+
+		if lookahead.peek(keyword::Pallet) {
+			Ok(Self::Pallet(input.parse()?))
+		} else if lookahead.peek(keyword::Call) {
+			Ok(Self::Call(input.parse()?))
+		} else if lookahead.peek(keyword::Storage) {
+			Ok(Self::Storage(input.parse()?))
+		} else if lookahead.peek(keyword::Event) {
+			Ok(Self::Event(input.parse()?))
+		} else if lookahead.peek(keyword::Error) {
+			Ok(Self::Error(input.parse()?))
+		} else if lookahead.peek(keyword::Config) {
+			Ok(Self::Config(input.parse()?))
+		} else if lookahead.peek(keyword::Origin) {
+			Ok(Self::Origin(input.parse()?))
+		} else if lookahead.peek(keyword::Inherent) {
+			Ok(Self::Inherent(input.parse()?))
+		} else if lookahead.peek(keyword::ValidateUnsigned) {
+			Ok(Self::ValidateUnsigned(input.parse()?))
+		} else if lookahead.peek(keyword::FreezeReason) {
+			Ok(Self::FreezeReason(input.parse()?))
+		} else if lookahead.peek(keyword::HoldReason) {
+			Ok(Self::HoldReason(input.parse()?))
+		} else if lookahead.peek(keyword::LockId) {
+			Ok(Self::LockId(input.parse()?))
+		} else if lookahead.peek(keyword::SlashReason) {
+			Ok(Self::SlashReason(input.parse()?))
+		} else {
+			Err(lookahead.error())
+		}
+	}
+}
+
+impl PalletPartKeyword {
+	/// Returns the name of `Self`.
+	fn name(&self) -> &'static str {
+		match self {
+			Self::Pallet(_) => "Pallet",
+			Self::Call(_) => "Call",
+			Self::Storage(_) => "Storage",
+			Self::Event(_) => "Event",
+			Self::Error(_) => "Error",
+			Self::Config(_) => "Config",
+			Self::Origin(_) => "Origin",
+			Self::Inherent(_) => "Inherent",
+			Self::ValidateUnsigned(_) => "ValidateUnsigned",
+			Self::FreezeReason(_) => "FreezeReason",
+			Self::HoldReason(_) => "HoldReason",
+			Self::LockId(_) => "LockId",
+			Self::SlashReason(_) => "SlashReason",
+		}
+	}
+
+	/// Returns `true` if this pallet part is allowed to have generic arguments.
+	fn allows_generic(&self) -> bool {
+		Self::all_generic_arg().iter().any(|n| *n == self.name())
+	}
+
+	/// Returns the names of all pallet parts that allow to have a generic argument.
+	fn all_generic_arg() -> &'static [&'static str] {
+		&["Event", "Error", "Origin", "Config"]
+	}
+}
+
+impl ToTokens for PalletPartKeyword {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		match self {
+			Self::Pallet(inner) => inner.to_tokens(tokens),
+			Self::Call(inner) => inner.to_tokens(tokens),
+			Self::Storage(inner) => inner.to_tokens(tokens),
+			Self::Event(inner) => inner.to_tokens(tokens),
+			Self::Error(inner) => inner.to_tokens(tokens),
+			Self::Config(inner) => inner.to_tokens(tokens),
+			Self::Origin(inner) => inner.to_tokens(tokens),
+			Self::Inherent(inner) => inner.to_tokens(tokens),
+			Self::ValidateUnsigned(inner) => inner.to_tokens(tokens),
+			Self::FreezeReason(inner) => inner.to_tokens(tokens),
+			Self::HoldReason(inner) => inner.to_tokens(tokens),
+			Self::LockId(inner) => inner.to_tokens(tokens),
+			Self::SlashReason(inner) => inner.to_tokens(tokens),
+		}
+	}
+}
+
+#[derive(Debug, Clone)]
+pub struct PalletPart {
+	pub keyword: PalletPartKeyword,
+	pub generics: syn::Generics,
+}
+
+impl Parse for PalletPart {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let keyword: PalletPartKeyword = input.parse()?;
+
+		let generics: syn::Generics = input.parse()?;
+		if !generics.params.is_empty() && !keyword.allows_generic() {
+			let valid_generics = PalletPart::format_names(PalletPartKeyword::all_generic_arg());
+			let msg = format!(
+				"`{}` is not allowed to have generics. \
+				 Only the following pallets are allowed to have generics: {}.",
+				keyword.name(),
+				valid_generics,
+			);
+			return Err(syn::Error::new(keyword.span(), msg))
+		}
+
+		Ok(Self { keyword, generics })
+	}
+}
+
+impl PalletPart {
+	pub fn format_names(names: &[&'static str]) -> String {
+		let res: Vec<_> = names.iter().map(|s| format!("`{}`", s)).collect();
+		res.join(", ")
+	}
+
+	/// The name of this pallet part.
+	pub fn name(&self) -> &'static str {
+		self.keyword.name()
+	}
+}
+
+fn remove_kind(
+	input: ParseStream,
+	kind: WhereKind,
+	definitions: &mut Vec<WhereDefinition>,
+) -> Result<WhereDefinition> {
+	if let Some(pos) = definitions.iter().position(|d| d.kind == kind) {
+		Ok(definitions.remove(pos))
+	} else {
+		let msg = format!(
+			"Missing associated type for `{:?}`. Add `{:?}` = ... to where section.",
+			kind, kind
+		);
+		Err(input.error(msg))
+	}
+}
+
+/// The declaration of a part without its generics
+#[derive(Debug, Clone)]
+pub struct PalletPartNoGeneric {
+	keyword: PalletPartKeyword,
+}
+
+impl Parse for PalletPartNoGeneric {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(Self { keyword: input.parse()? })
+	}
+}
+
+/// Parse [`PalletPartNoGeneric`]'s from a braces enclosed list that is split by commas, e.g.
+///
+/// `{ Call, Event }`
+fn parse_pallet_parts_no_generic(input: ParseStream) -> Result<Vec<PalletPartNoGeneric>> {
+	let pallet_parts: ext::Braces<ext::Punctuated<PalletPartNoGeneric, Token![,]>> =
+		input.parse()?;
+
+	let mut resolved = HashSet::new();
+	for part in pallet_parts.content.inner.iter() {
+		if !resolved.insert(part.keyword.name()) {
+			let msg = format!(
+				"`{}` was already declared before. Please remove the duplicate declaration",
+				part.keyword.name(),
+			);
+			return Err(Error::new(part.keyword.span(), msg))
+		}
+	}
+
+	Ok(pallet_parts.content.inner.into_iter().collect())
+}
+
+/// The final definition of a pallet with the resulting fixed index and explicit parts.
+#[derive(Debug, Clone)]
+pub struct Pallet {
+	/// Is this pallet fully expanded?
+	pub is_expanded: bool,
+	/// The name of the pallet, e.g.`System` in `System: frame_system`.
+	pub name: Ident,
+	/// Either automatically infered, or defined (e.g. `MyPallet ...  = 3,`).
+	pub index: u8,
+	/// The path of the pallet, e.g. `frame_system` in `System: frame_system`.
+	pub path: PalletPath,
+	/// The instance of the pallet, e.g. `Instance1` in `Council: pallet_collective::<Instance1>`.
+	pub instance: Option<Ident>,
+	/// The pallet parts to use for the pallet.
+	pub pallet_parts: Vec<PalletPart>,
+	/// Expressions specified inside of a #[cfg] attribute.
+	pub cfg_pattern: Vec<cfg_expr::Expression>,
+}
+
+impl Pallet {
+	/// Get resolved pallet parts
+	pub fn pallet_parts(&self) -> &[PalletPart] {
+		&self.pallet_parts
+	}
+
+	/// Find matching parts
+	pub fn find_part(&self, name: &str) -> Option<&PalletPart> {
+		self.pallet_parts.iter().find(|part| part.name() == name)
+	}
+
+	/// Return whether pallet contains part
+	pub fn exists_part(&self, name: &str) -> bool {
+		self.find_part(name).is_some()
+	}
+}
+
+/// Result of a conversion of a declaration of pallets.
+///
+/// # State Transitions
+///
+/// ```ignore
+/// +----------+    +----------+    +------------------+
+/// | Implicit | -> | Explicit | -> | ExplicitExpanded |
+/// +----------+    +----------+    +------------------+
+/// ```
+enum PalletsConversion {
+	/// Pallets implicitely declare parts.
+	///
+	/// `System: frame_system`.
+	Implicit(Vec<PalletDeclaration>),
+	/// Pallets explicitly declare parts.
+	///
+	/// `System: frame_system::{Pallet, Call}`
+	///
+	/// However, for backwards compatibility with Polkadot/Kusama
+	/// we must propagate some other parts to the pallet by default.
+	Explicit(Vec<Pallet>),
+	/// Pallets explicitly declare parts that are fully expanded.
+	///
+	/// This is the end state that contains extra parts included by
+	/// default by Subtrate.
+	///
+	/// `System: frame_system expanded::{Error} ::{Pallet, Call}`
+	///
+	/// For this example, the `Pallet`, `Call` and `Error` parts are collected.
+	ExplicitExpanded(Vec<Pallet>),
+}
+
+/// Convert from the parsed pallet declaration to their final information.
+///
+/// Check if all pallet have explicit declaration of their parts, if so then assign index to each
+/// pallet using same rules as rust for fieldless enum. I.e. implicit are assigned number
+/// incrementedly from last explicit or 0.
+fn convert_pallets(pallets: Vec<PalletDeclaration>) -> syn::Result<PalletsConversion> {
+	if pallets.iter().any(|pallet| pallet.pallet_parts.is_none()) {
+		return Ok(PalletsConversion::Implicit(pallets))
+	}
+
+	let mut indices = HashMap::new();
+	let mut last_index: Option<u8> = None;
+	let mut names = HashMap::new();
+	let mut is_expanded = true;
+
+	let pallets = pallets
+		.into_iter()
+		.map(|pallet| {
+			let final_index = match pallet.index {
+				Some(i) => i,
+				None => last_index.map_or(Some(0), |i| i.checked_add(1)).ok_or_else(|| {
+					let msg = "Pallet index doesn't fit into u8, index is 256";
+					syn::Error::new(pallet.name.span(), msg)
+				})?,
+			};
+
+			last_index = Some(final_index);
+
+			if let Some(used_pallet) = indices.insert(final_index, pallet.name.clone()) {
+				let msg = format!(
+					"Pallet indices are conflicting: Both pallets {} and {} are at index {}",
+					used_pallet, pallet.name, final_index,
+				);
+				let mut err = syn::Error::new(used_pallet.span(), &msg);
+				err.combine(syn::Error::new(pallet.name.span(), msg));
+				return Err(err)
+			}
+
+			if let Some(used_pallet) = names.insert(pallet.name.clone(), pallet.name.span()) {
+				let msg = "Two pallets with the same name!";
+
+				let mut err = syn::Error::new(used_pallet, &msg);
+				err.combine(syn::Error::new(pallet.name.span(), &msg));
+				return Err(err)
+			}
+
+			let mut pallet_parts = pallet.pallet_parts.expect("Checked above");
+
+			let available_parts =
+				pallet_parts.iter().map(|part| part.keyword.name()).collect::<HashSet<_>>();
+
+			// Check parts are correctly specified
+			match &pallet.specified_parts {
+				SpecifiedParts::Exclude(parts) | SpecifiedParts::Use(parts) =>
+					for part in parts {
+						if !available_parts.contains(part.keyword.name()) {
+							let msg = format!(
+								"Invalid pallet part specified, the pallet `{}` doesn't have the \
+								`{}` part. Available parts are: {}.",
+								pallet.name,
+								part.keyword.name(),
+								pallet_parts.iter().fold(String::new(), |fold, part| {
+									if fold.is_empty() {
+										format!("`{}`", part.keyword.name())
+									} else {
+										format!("{}, `{}`", fold, part.keyword.name())
+									}
+								})
+							);
+							return Err(syn::Error::new(part.keyword.span(), msg))
+						}
+					},
+				SpecifiedParts::All => (),
+			}
+
+			// Set only specified parts.
+			match pallet.specified_parts {
+				SpecifiedParts::Exclude(excluded_parts) => pallet_parts.retain(|part| {
+					!excluded_parts
+						.iter()
+						.any(|excluded_part| excluded_part.keyword.name() == part.keyword.name())
+				}),
+				SpecifiedParts::Use(used_parts) => pallet_parts.retain(|part| {
+					used_parts.iter().any(|use_part| use_part.keyword.name() == part.keyword.name())
+				}),
+				SpecifiedParts::All => (),
+			}
+
+			let cfg_pattern = pallet
+				.attrs
+				.iter()
+				.map(|attr| {
+					if attr.path().segments.first().map_or(false, |s| s.ident != "cfg") {
+						let msg = "Unsupported attribute, only #[cfg] is supported on pallet \
+						declarations in `construct_runtime`";
+						return Err(syn::Error::new(attr.span(), msg))
+					}
+
+					attr.parse_args_with(|input: syn::parse::ParseStream| {
+						// Required, otherwise the parse stream doesn't advance and will result in
+						// an error.
+						let input = input.parse::<proc_macro2::TokenStream>()?;
+						cfg_expr::Expression::parse(&input.to_string())
+							.map_err(|e| syn::Error::new(attr.span(), e.to_string()))
+					})
+				})
+				.collect::<Result<Vec<_>>>()?;
+
+			is_expanded &= pallet.is_expanded;
+
+			Ok(Pallet {
+				is_expanded: pallet.is_expanded,
+				name: pallet.name,
+				index: final_index,
+				path: pallet.path,
+				instance: pallet.instance,
+				cfg_pattern,
+				pallet_parts,
+			})
+		})
+		.collect::<Result<Vec<_>>>()?;
+
+	if is_expanded {
+		Ok(PalletsConversion::ExplicitExpanded(pallets))
+	} else {
+		Ok(PalletsConversion::Explicit(pallets))
+	}
+}
diff --git a/substrate/frame/support/procedural/src/crate_version.rs b/substrate/frame/support/procedural/src/crate_version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3f728abdb0b03ef5c3c2f6aca5746e8bac8a1e66
--- /dev/null
+++ b/substrate/frame/support/procedural/src/crate_version.rs
@@ -0,0 +1,54 @@
+// 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.
+
+//! Implementation of macros related to crate versioning.
+
+use super::get_cargo_env_var;
+use frame_support_procedural_tools::generate_crate_access_2018;
+use proc_macro2::{Span, TokenStream};
+use syn::{Error, Result};
+
+/// Create an error that will be shown by rustc at the call site of the macro.
+fn create_error(message: &str) -> Error {
+	Error::new(Span::call_site(), message)
+}
+
+/// Implementation of the `crate_to_crate_version!` macro.
+pub fn crate_to_crate_version(input: proc_macro::TokenStream) -> Result<TokenStream> {
+	if !input.is_empty() {
+		return Err(create_error("No arguments expected!"))
+	}
+
+	let major_version = get_cargo_env_var::<u16>("CARGO_PKG_VERSION_MAJOR")
+		.map_err(|_| create_error("Major version needs to fit into `u16`"))?;
+
+	let minor_version = get_cargo_env_var::<u8>("CARGO_PKG_VERSION_MINOR")
+		.map_err(|_| create_error("Minor version needs to fit into `u8`"))?;
+
+	let patch_version = get_cargo_env_var::<u8>("CARGO_PKG_VERSION_PATCH")
+		.map_err(|_| create_error("Patch version needs to fit into `u8`"))?;
+
+	let crate_ = generate_crate_access_2018("frame-support")?;
+
+	Ok(quote::quote! {
+		#crate_::traits::CrateVersion {
+			major: #major_version,
+			minor: #minor_version,
+			patch: #patch_version,
+		}
+	})
+}
diff --git a/substrate/frame/support/procedural/src/derive_impl.rs b/substrate/frame/support/procedural/src/derive_impl.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8b5e334f1f5513cafc1fc5e58d1cbcb44d3232a8
--- /dev/null
+++ b/substrate/frame/support/procedural/src/derive_impl.rs
@@ -0,0 +1,229 @@
+// 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.
+
+//! Implementation of the `derive_impl` attribute macro.
+
+use derive_syn_parse::Parse;
+use macro_magic::mm_core::ForeignPath;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{quote, ToTokens};
+use std::collections::HashSet;
+use syn::{
+	parse2, parse_quote, spanned::Spanned, token, Ident, ImplItem, ItemImpl, Path, Result, Token,
+};
+
+mod keyword {
+	syn::custom_keyword!(inject_runtime_type);
+	syn::custom_keyword!(no_aggregated_types);
+}
+
+#[derive(derive_syn_parse::Parse, PartialEq, Eq)]
+pub enum PalletAttrType {
+	#[peek(keyword::inject_runtime_type, name = "inject_runtime_type")]
+	RuntimeType(keyword::inject_runtime_type),
+}
+
+#[derive(derive_syn_parse::Parse)]
+pub struct PalletAttr {
+	_pound: Token![#],
+	#[bracket]
+	_bracket: token::Bracket,
+	#[inside(_bracket)]
+	typ: PalletAttrType,
+}
+
+fn get_first_item_pallet_attr<Attr>(item: &syn::ImplItemType) -> syn::Result<Option<Attr>>
+where
+	Attr: syn::parse::Parse,
+{
+	item.attrs.get(0).map(|a| syn::parse2(a.into_token_stream())).transpose()
+}
+
+#[derive(Parse, Debug)]
+pub struct DeriveImplAttrArgs {
+	pub default_impl_path: Path,
+	_as: Option<Token![as]>,
+	#[parse_if(_as.is_some())]
+	pub disambiguation_path: Option<Path>,
+	_comma: Option<Token![,]>,
+	#[parse_if(_comma.is_some())]
+	pub no_aggregated_types: Option<keyword::no_aggregated_types>,
+}
+
+impl ForeignPath for DeriveImplAttrArgs {
+	fn foreign_path(&self) -> &Path {
+		&self.default_impl_path
+	}
+}
+
+impl ToTokens for DeriveImplAttrArgs {
+	fn to_tokens(&self, tokens: &mut TokenStream2) {
+		tokens.extend(self.default_impl_path.to_token_stream());
+		tokens.extend(self._as.to_token_stream());
+		tokens.extend(self.disambiguation_path.to_token_stream());
+		tokens.extend(self._comma.to_token_stream());
+		tokens.extend(self.no_aggregated_types.to_token_stream());
+	}
+}
+
+/// Gets the [`Ident`] representation of the given [`ImplItem`], if one exists. Otherwise
+/// returns [`None`].
+///
+/// Used by [`combine_impls`] to determine whether we can compare [`ImplItem`]s by [`Ident`]
+/// or not.
+fn impl_item_ident(impl_item: &ImplItem) -> Option<&Ident> {
+	match impl_item {
+		ImplItem::Const(item) => Some(&item.ident),
+		ImplItem::Fn(item) => Some(&item.sig.ident),
+		ImplItem::Type(item) => Some(&item.ident),
+		ImplItem::Macro(item) => item.mac.path.get_ident(),
+		_ => None,
+	}
+}
+
+/// The real meat behind `derive_impl`. Takes in a `local_impl`, which is the impl for which we
+/// want to implement defaults (i.e. the one the attribute macro is attached to), and a
+/// `foreign_impl`, which is the impl containing the defaults we want to use, and returns an
+/// [`ItemImpl`] containing the final generated impl.
+///
+/// This process has the following caveats:
+/// * Colliding items that have an ident are not copied into `local_impl`
+/// * Uncolliding items that have an ident are copied into `local_impl` but are qualified as `type
+///   #ident = <#default_impl_path as #disambiguation_path>::#ident;`
+/// * Items that lack an ident are de-duplicated so only unique items that lack an ident are copied
+///   into `local_impl`. Items that lack an ident and also exist verbatim in `local_impl` are not
+///   copied over.
+fn combine_impls(
+	local_impl: ItemImpl,
+	foreign_impl: ItemImpl,
+	default_impl_path: Path,
+	disambiguation_path: Path,
+	inject_runtime_types: bool,
+) -> ItemImpl {
+	let (existing_local_keys, existing_unsupported_items): (HashSet<ImplItem>, HashSet<ImplItem>) =
+		local_impl
+			.items
+			.iter()
+			.cloned()
+			.partition(|impl_item| impl_item_ident(impl_item).is_some());
+	let existing_local_keys: HashSet<Ident> = existing_local_keys
+		.into_iter()
+		.filter_map(|item| impl_item_ident(&item).cloned())
+		.collect();
+	let mut final_impl = local_impl;
+	let extended_items = foreign_impl.items.into_iter().filter_map(|item| {
+		if let Some(ident) = impl_item_ident(&item) {
+			if existing_local_keys.contains(&ident) {
+				// do not copy colliding items that have an ident
+				return None
+			}
+			if let ImplItem::Type(typ) = item.clone() {
+				let mut typ = typ.clone();
+				if let Ok(Some(PalletAttr { typ: PalletAttrType::RuntimeType(_), .. })) =
+					get_first_item_pallet_attr::<PalletAttr>(&mut typ)
+				{
+					let item: ImplItem = if inject_runtime_types {
+						parse_quote! {
+							type #ident = #ident;
+						}
+					} else {
+						item
+					};
+					return Some(item)
+				}
+				// modify and insert uncolliding type items
+				let modified_item: ImplItem = parse_quote! {
+					type #ident = <#default_impl_path as #disambiguation_path>::#ident;
+				};
+				return Some(modified_item)
+			}
+			// copy uncolliding non-type items that have an ident
+			Some(item)
+		} else {
+			// do not copy colliding items that lack an ident
+			(!existing_unsupported_items.contains(&item))
+				// copy uncolliding items without an ident verbatim
+				.then_some(item)
+		}
+	});
+	final_impl.items.extend(extended_items);
+	final_impl
+}
+
+/// Internal implementation behind [`#[derive_impl(..)]`](`macro@crate::derive_impl`).
+///
+/// `default_impl_path`: the module path of the external `impl` statement whose tokens we are
+///	                     importing via `macro_magic`
+///
+/// `foreign_tokens`: the tokens for the external `impl` statement
+///
+/// `local_tokens`: the tokens for the local `impl` statement this attribute is attached to
+///
+/// `disambiguation_path`: the module path of the external trait we will use to qualify
+///                        defaults imported from the external `impl` statement
+pub fn derive_impl(
+	default_impl_path: TokenStream2,
+	foreign_tokens: TokenStream2,
+	local_tokens: TokenStream2,
+	disambiguation_path: Option<Path>,
+	no_aggregated_types: Option<keyword::no_aggregated_types>,
+) -> Result<TokenStream2> {
+	let local_impl = parse2::<ItemImpl>(local_tokens)?;
+	let foreign_impl = parse2::<ItemImpl>(foreign_tokens)?;
+	let default_impl_path = parse2::<Path>(default_impl_path)?;
+
+	// have disambiguation_path default to the item being impl'd in the foreign impl if we
+	// don't specify an `as [disambiguation_path]` in the macro attr
+	let disambiguation_path = match (disambiguation_path, foreign_impl.clone().trait_) {
+		(Some(disambiguation_path), _) => disambiguation_path,
+		(None, Some((_, foreign_impl_path, _))) => foreign_impl_path,
+		_ =>
+			return Err(syn::Error::new(
+				foreign_impl.span(),
+				"Impl statement must have a defined type being implemented \
+				for a defined type such as `impl A for B`",
+			)),
+	};
+
+	// generate the combined impl
+	let combined_impl = combine_impls(
+		local_impl,
+		foreign_impl,
+		default_impl_path,
+		disambiguation_path,
+		no_aggregated_types.is_none(),
+	);
+
+	Ok(quote!(#combined_impl))
+}
+
+#[test]
+fn test_derive_impl_attr_args_parsing() {
+	parse2::<DeriveImplAttrArgs>(quote!(
+		some::path::TestDefaultConfig as some::path::DefaultConfig
+	))
+	.unwrap();
+	parse2::<DeriveImplAttrArgs>(quote!(
+		frame_system::prelude::testing::TestDefaultConfig as DefaultConfig
+	))
+	.unwrap();
+	parse2::<DeriveImplAttrArgs>(quote!(Something as some::path::DefaultConfig)).unwrap();
+	parse2::<DeriveImplAttrArgs>(quote!(Something as DefaultConfig)).unwrap();
+	parse2::<DeriveImplAttrArgs>(quote!(DefaultConfig)).unwrap();
+	assert!(parse2::<DeriveImplAttrArgs>(quote!()).is_err());
+	assert!(parse2::<DeriveImplAttrArgs>(quote!(Config Config)).is_err());
+}
diff --git a/substrate/frame/support/procedural/src/dummy_part_checker.rs b/substrate/frame/support/procedural/src/dummy_part_checker.rs
new file mode 100644
index 0000000000000000000000000000000000000000..792b17a8f775855eb4f277f76b10bbdd16c44e21
--- /dev/null
+++ b/substrate/frame/support/procedural/src/dummy_part_checker.rs
@@ -0,0 +1,62 @@
+use crate::COUNTER;
+use proc_macro::TokenStream;
+
+pub fn generate_dummy_part_checker(input: TokenStream) -> TokenStream {
+	if !input.is_empty() {
+		return syn::Error::new(proc_macro2::Span::call_site(), "No arguments expected")
+			.to_compile_error()
+			.into()
+	}
+
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+
+	let no_op_macro_ident =
+		syn::Ident::new(&format!("__dummy_part_checker_{}", count), proc_macro2::Span::call_site());
+
+	quote::quote!(
+		#[macro_export]
+		#[doc(hidden)]
+		macro_rules! #no_op_macro_ident {
+			( $( $tt:tt )* ) => {};
+		}
+
+		#[doc(hidden)]
+		pub mod __substrate_genesis_config_check {
+			#[doc(hidden)]
+			pub use #no_op_macro_ident as is_genesis_config_defined;
+			#[doc(hidden)]
+			pub use #no_op_macro_ident as is_std_enabled_for_genesis;
+		}
+
+		#[doc(hidden)]
+		pub mod __substrate_event_check {
+			#[doc(hidden)]
+			pub use #no_op_macro_ident as is_event_part_defined;
+		}
+
+		#[doc(hidden)]
+		pub mod __substrate_inherent_check {
+			#[doc(hidden)]
+			pub use #no_op_macro_ident as is_inherent_part_defined;
+		}
+
+		#[doc(hidden)]
+		pub mod __substrate_validate_unsigned_check {
+			#[doc(hidden)]
+			pub use #no_op_macro_ident as is_validate_unsigned_part_defined;
+		}
+
+		#[doc(hidden)]
+		pub mod __substrate_call_check {
+			#[doc(hidden)]
+			pub use #no_op_macro_ident as is_call_part_defined;
+		}
+
+		#[doc(hidden)]
+		pub mod __substrate_origin_check {
+			#[doc(hidden)]
+			pub use #no_op_macro_ident as is_origin_part_defined;
+		}
+	)
+	.into()
+}
diff --git a/substrate/frame/support/procedural/src/key_prefix.rs b/substrate/frame/support/procedural/src/key_prefix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f793d0e37bde1a72e1cda44b30ca98a3c771a4c
--- /dev/null
+++ b/substrate/frame/support/procedural/src/key_prefix.rs
@@ -0,0 +1,99 @@
+// 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 proc_macro2::{Span, TokenStream};
+use quote::{format_ident, quote, ToTokens};
+use syn::{Ident, Result};
+
+const MAX_IDENTS: usize = 18;
+
+pub fn impl_key_prefix_for_tuples(input: proc_macro::TokenStream) -> Result<TokenStream> {
+	if !input.is_empty() {
+		return Err(syn::Error::new(Span::call_site(), "No arguments expected"))
+	}
+
+	let mut all_trait_impls = TokenStream::new();
+
+	for i in 2..=MAX_IDENTS {
+		let current_tuple = (0..i)
+			.map(|n| Ident::new(&format!("Tuple{}", n), Span::call_site()))
+			.collect::<Vec<_>>();
+
+		for prefix_count in 1..i {
+			let (prefixes, suffixes) = current_tuple.split_at(prefix_count);
+
+			let hashers = current_tuple
+				.iter()
+				.map(|ident| format_ident!("Hasher{}", ident))
+				.collect::<Vec<_>>();
+			let kargs =
+				prefixes.iter().map(|ident| format_ident!("KArg{}", ident)).collect::<Vec<_>>();
+			let partial_keygen = generate_keygen(prefixes);
+			let suffix_keygen = generate_keygen(suffixes);
+			let suffix_tuple = generate_tuple(suffixes);
+
+			let trait_impls = quote! {
+				impl<
+					#(#current_tuple: FullCodec + StaticTypeInfo,)*
+					#(#hashers: StorageHasher,)*
+					#(#kargs: EncodeLike<#prefixes>),*
+				> HasKeyPrefix<( #( #kargs, )* )> for ( #( Key<#hashers, #current_tuple>, )* ) {
+					type Suffix = #suffix_tuple;
+
+					fn partial_key(prefix: ( #( #kargs, )* )) -> Vec<u8> {
+						<#partial_keygen>::final_key(prefix)
+					}
+				}
+
+				impl<
+					#(#current_tuple: FullCodec + StaticTypeInfo,)*
+					#(#hashers: ReversibleStorageHasher,)*
+					#(#kargs: EncodeLike<#prefixes>),*
+				> HasReversibleKeyPrefix<( #( #kargs, )* )> for ( #( Key<#hashers, #current_tuple>, )* ) {
+					fn decode_partial_key(key_material: &[u8]) -> Result<Self::Suffix, codec::Error> {
+						<#suffix_keygen>::decode_final_key(key_material).map(|k| k.0)
+					}
+				}
+			};
+
+			all_trait_impls.extend(trait_impls);
+		}
+	}
+
+	Ok(all_trait_impls)
+}
+
+fn generate_tuple(idents: &[Ident]) -> TokenStream {
+	if idents.len() == 1 {
+		idents[0].to_token_stream()
+	} else {
+		quote!((#(#idents),*))
+	}
+}
+
+fn generate_keygen(idents: &[Ident]) -> TokenStream {
+	if idents.len() == 1 {
+		let key = &idents[0];
+		let hasher = format_ident!("Hasher{}", key);
+
+		quote!(Key<#hasher, #key>)
+	} else {
+		let hashers = idents.iter().map(|ident| format_ident!("Hasher{}", ident));
+
+		quote!((#(Key<#hashers, #idents>),*))
+	}
+}
diff --git a/substrate/frame/support/procedural/src/lib.rs b/substrate/frame/support/procedural/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9957cf1cff85c821b50d132d92762eac4a70b7ac
--- /dev/null
+++ b/substrate/frame/support/procedural/src/lib.rs
@@ -0,0 +1,1690 @@
+// 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.
+
+//! Proc macro of Support code for the runtime.
+
+#![recursion_limit = "512"]
+
+mod benchmark;
+mod construct_runtime;
+mod crate_version;
+mod derive_impl;
+mod dummy_part_checker;
+mod key_prefix;
+mod match_and_insert;
+mod no_bound;
+mod pallet;
+mod pallet_error;
+mod storage_alias;
+mod transactional;
+mod tt_macro;
+
+use frame_support_procedural_tools::generate_crate_access_2018;
+use macro_magic::import_tokens_attr;
+use proc_macro::TokenStream;
+use quote::{quote, ToTokens};
+use std::{cell::RefCell, str::FromStr};
+use syn::{parse_macro_input, Error, ItemImpl, ItemMod, TraitItemType};
+
+pub(crate) const INHERENT_INSTANCE_NAME: &str = "__InherentHiddenInstance";
+
+thread_local! {
+	/// A global counter, can be used to generate a relatively unique identifier.
+	static COUNTER: RefCell<Counter> = RefCell::new(Counter(0));
+}
+
+/// Counter to generate a relatively unique identifier for macros. This is necessary because
+/// declarative macros gets hoisted to the crate root, which shares the namespace with other pallets
+/// containing the very same macros.
+struct Counter(u64);
+
+impl Counter {
+	fn inc(&mut self) -> u64 {
+		let ret = self.0;
+		self.0 += 1;
+		ret
+	}
+}
+
+/// Get the value from the given environment variable set by cargo.
+///
+/// The value is parsed into the requested destination type.
+fn get_cargo_env_var<T: FromStr>(version_env: &str) -> std::result::Result<T, ()> {
+	let version = std::env::var(version_env)
+		.unwrap_or_else(|_| panic!("`{}` is always set by cargo; qed", version_env));
+
+	T::from_str(&version).map_err(drop)
+}
+
+/// Generate the counter_prefix related to the storage.
+/// counter_prefix is used by counted storage map.
+fn counter_prefix(prefix: &str) -> String {
+	format!("CounterFor{}", prefix)
+}
+
+/// Construct a runtime, with the given name and the given pallets.
+///
+/// The parameters here are specific types for `Block`, `NodeBlock`, and `UncheckedExtrinsic`
+/// and the pallets that are used by the runtime.
+/// `Block` is the block type that is used in the runtime and `NodeBlock` is the block type
+/// that is used in the node. For instance they can differ in the extrinsics type.
+///
+/// # Example:
+///
+/// ```ignore
+/// construct_runtime!(
+///     pub enum Runtime where
+///         Block = Block,
+///         NodeBlock = node::Block,
+///         UncheckedExtrinsic = UncheckedExtrinsic
+///     {
+///         System: frame_system::{Pallet, Call, Event<T>, Config<T>} = 0,
+///         Test: path::to::test::{Pallet, Call} = 1,
+///
+///         // Pallets with instances.
+///         Test2_Instance1: test2::<Instance1>::{Pallet, Call, Storage, Event<T, I>, Config<T, I>, Origin<T, I>},
+///         Test2_DefaultInstance: test2::{Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>} = 4,
+///
+///         // Pallets declared with `pallet` attribute macro: no need to define the parts
+///         Test3_Instance1: test3::<Instance1>,
+///         Test3_DefaultInstance: test3,
+///
+///         // with `exclude_parts` keyword some part can be excluded.
+///         Test4_Instance1: test4::<Instance1> exclude_parts { Call, Origin },
+///         Test4_DefaultInstance: test4 exclude_parts { Storage },
+///
+///         // with `use_parts` keyword, a subset of the pallet parts can be specified.
+///         Test4_Instance1: test4::<Instance1> use_parts { Pallet, Call},
+///         Test4_DefaultInstance: test4 use_parts { Pallet },
+///     }
+/// )
+/// ```
+///
+/// Each pallet is declared as such:
+/// * `Identifier`: name given to the pallet that uniquely identifies it.
+///
+/// * `:`: colon separator
+///
+/// * `path::to::pallet`: identifiers separated by colons which declare the path to a pallet
+///   definition.
+///
+/// * `::<InstanceN>` optional: specify the instance of the pallet to use. If not specified it will
+///   use the default instance (or the only instance in case of non-instantiable pallets).
+///
+/// * `::{ Part1, Part2<T>, .. }` optional if pallet declared with `frame_support::pallet`: Comma
+///   separated parts declared with their generic. If a pallet is declared with
+///   `frame_support::pallet` macro then the parts can be automatically derived if not explicitly
+///   provided. We provide support for the following module parts in a pallet:
+///
+///   - `Pallet` - Required for all pallets
+///   - `Call` - If the pallet has callable functions
+///   - `Storage` - If the pallet uses storage
+///   - `Event` or `Event<T>` (if the event is generic) - If the pallet emits events
+///   - `Origin` or `Origin<T>` (if the origin is generic) - If the pallet has instanciable origins
+///   - `Config` or `Config<T>` (if the config is generic) - If the pallet builds the genesis
+///     storage with `GenesisConfig`
+///   - `Inherent` - If the pallet provides/can check inherents.
+///   - `ValidateUnsigned` - If the pallet validates unsigned extrinsics.
+///
+///   It is important to list these parts here to export them correctly in the metadata or to make
+/// the pallet usable in the runtime.
+///
+/// * `exclude_parts { Part1, Part2 }` optional: comma separated parts without generics. I.e. one of
+///   `Pallet`, `Call`, `Storage`, `Event`, `Origin`, `Config`, `Inherent`, `ValidateUnsigned`. It
+///   is incompatible with `use_parts`. This specifies the part to exclude. In order to select
+///   subset of the pallet parts.
+///
+///   For example excluding the part `Call` can be useful if the runtime doesn't want to make the
+///   pallet calls available.
+///
+/// * `use_parts { Part1, Part2 }` optional: comma separated parts without generics. I.e. one of
+///   `Pallet`, `Call`, `Storage`, `Event`, `Origin`, `Config`, `Inherent`, `ValidateUnsigned`. It
+///   is incompatible with `exclude_parts`. This specifies the part to use. In order to select a
+///   subset of the pallet parts.
+///
+///   For example not using the part `Call` can be useful if the runtime doesn't want to make the
+///   pallet calls available.
+///
+/// * `= $n` optional: number to define at which index the pallet variants in `OriginCaller`, `Call`
+///   and `Event` are encoded, and to define the ModuleToIndex value.
+///
+///   if `= $n` is not given, then index is resolved in the same way as fieldless enum in Rust
+///   (i.e. incrementedly from previous index):
+///   ```nocompile
+///   pallet1 .. = 2,
+///   pallet2 .., // Here pallet2 is given index 3
+///   pallet3 .. = 0,
+///   pallet4 .., // Here pallet4 is given index 1
+///   ```
+///
+/// # Note
+///
+/// The population of the genesis storage depends on the order of pallets. So, if one of your
+/// pallets depends on another pallet, the pallet that is depended upon needs to come before
+/// the pallet depending on it.
+///
+/// # Type definitions
+///
+/// * The macro generates a type alias for each pallet to their `Pallet`. E.g. `type System =
+///   frame_system::Pallet<Runtime>`
+#[proc_macro]
+pub fn construct_runtime(input: TokenStream) -> TokenStream {
+	construct_runtime::construct_runtime(input)
+}
+
+/// The pallet struct placeholder `#[pallet::pallet]` is mandatory and allows you to specify
+/// pallet information.
+///
+/// The struct must be defined as follows:
+/// ```ignore
+/// #[pallet::pallet]
+/// pub struct Pallet<T>(_);
+/// ```
+/// I.e. a regular struct definition named `Pallet`, with generic T and no where clause.
+///
+/// ## Macro expansion:
+///
+/// The macro adds this attribute to the struct definition:
+/// ```ignore
+/// #[derive(
+/// 	frame_support::CloneNoBound,
+/// 	frame_support::EqNoBound,
+/// 	frame_support::PartialEqNoBound,
+/// 	frame_support::RuntimeDebugNoBound,
+/// )]
+/// ```
+/// and replaces the type `_` with `PhantomData<T>`. It also implements on the pallet:
+/// * `GetStorageVersion`
+/// * `OnGenesis`: contains some logic to write the pallet version into storage.
+/// * `PalletErrorTypeInfo`: provides the type information for the pallet error, if defined.
+///
+/// It declares `type Module` type alias for `Pallet`, used by `construct_runtime`.
+///
+/// It implements `PalletInfoAccess` on `Pallet` to ease access to pallet information given by
+/// `frame_support::traits::PalletInfo`. (The implementation uses the associated type
+/// `frame_system::Config::PalletInfo`).
+///
+/// It implements `StorageInfoTrait` on `Pallet` which give information about all storages.
+///
+/// If the attribute `generate_store` is set then the macro creates the trait `Store` and
+/// implements it on `Pallet`.
+///
+/// If the attribute `set_storage_max_encoded_len` is set then the macro calls
+/// `StorageInfoTrait` for each storage in the implementation of `StorageInfoTrait` for the
+/// pallet. Otherwise it implements `StorageInfoTrait` for the pallet using the
+/// `PartialStorageInfoTrait` implementation of storages.
+///
+/// ## Dev Mode (`#[pallet(dev_mode)]`)
+///
+/// Specifying the argument `dev_mode` will allow you to enable dev mode for a pallet. The aim
+/// of dev mode is to loosen some of the restrictions and requirements placed on production
+/// pallets for easy tinkering and development. Dev mode pallets should not be used in
+/// production. Enabling dev mode has the following effects:
+///
+/// * Weights no longer need to be specified on every `#[pallet::call]` declaration. By default, dev
+///   mode pallets will assume a weight of zero (`0`) if a weight is not specified. This is
+///   equivalent to specifying `#[weight(0)]` on all calls that do not specify a weight.
+/// * Call indices no longer need to be specified on every `#[pallet::call]` declaration. By
+///   default, dev mode pallets will assume a call index based on the order of the call.
+/// * All storages are marked as unbounded, meaning you do not need to implement `MaxEncodedLen` on
+///   storage types. This is equivalent to specifying `#[pallet::unbounded]` on all storage type
+///   definitions.
+/// * Storage hashers no longer need to be specified and can be replaced by `_`. In dev mode, these
+///   will be replaced by `Blake2_128Concat`. In case of explicit key-binding, `Hasher` can simply
+///   be ignored when in `dev_mode`.
+///
+/// Note that the `dev_mode` argument can only be supplied to the `#[pallet]` or
+/// `#[frame_support::pallet]` attribute macro that encloses your pallet module. This argument
+/// cannot be specified anywhere else, including but not limited to the `#[pallet::pallet]`
+/// attribute macro.
+///
+/// <div class="example-wrap" style="display:inline-block"><pre class="compile_fail"
+/// style="white-space:normal;font:inherit;">
+/// <strong>WARNING</strong>:
+/// You should not deploy or use dev mode pallets in production. Doing so can break your chain
+/// and therefore should never be done. Once you are done tinkering, you should remove the
+/// 'dev_mode' argument from your #[pallet] declaration and fix any compile errors before
+/// attempting to use your pallet in a production scenario.
+/// </pre></div>
+///
+/// See `frame_support::pallet` docs for more info.
+///
+/// ## Runtime Metadata Documentation
+///
+/// The documentation added to this pallet is included in the runtime metadata.
+///
+/// The documentation can be defined in the following ways:
+///
+/// ```ignore
+/// #[pallet::pallet]
+/// /// Documentation for pallet 1
+/// #[doc = "Documentation for pallet 2"]
+/// #[doc = include_str!("../README.md")]
+/// #[pallet_doc("../doc1.md")]
+/// #[pallet_doc("../doc2.md")]
+/// pub mod pallet {}
+/// ```
+///
+/// The runtime metadata for this pallet contains the following
+///  - " Documentation for pallet 1" (captured from `///`)
+///  - "Documentation for pallet 2"  (captured from `#[doc]`)
+///  - content of ../README.md       (captured from `#[doc]` with `include_str!`)
+///  - content of "../doc1.md"       (captured from `pallet_doc`)
+///  - content of "../doc2.md"       (captured from `pallet_doc`)
+///
+/// ### `doc` attribute
+///
+/// The value of the `doc` attribute is included in the runtime metadata, as well as
+/// expanded on the pallet module. The previous example is expanded to:
+///
+/// ```ignore
+/// /// Documentation for pallet 1
+/// /// Documentation for pallet 2
+/// /// Content of README.md
+/// pub mod pallet {}
+/// ```
+///
+/// If you want to specify the file from which the documentation is loaded, you can use the
+/// `include_str` macro. However, if you only want the documentation to be included in the
+/// runtime metadata, use the `pallet_doc` attribute.
+///
+/// ### `pallet_doc` attribute
+///
+/// Unlike the `doc` attribute, the documentation provided to the `pallet_doc` attribute is
+/// not inserted on the module.
+///
+/// The `pallet_doc` attribute can only be provided with one argument,
+/// which is the file path that holds the documentation to be added to the metadata.
+///
+/// This approach is beneficial when you use the `include_str` macro at the beginning of the file
+/// and want that documentation to extend to the runtime metadata, without reiterating the
+/// documentation on the pallet module itself.
+#[proc_macro_attribute]
+pub fn pallet(attr: TokenStream, item: TokenStream) -> TokenStream {
+	pallet::pallet(attr, item)
+}
+
+/// An attribute macro that can be attached to a (non-empty) module declaration. Doing so will
+/// designate that module as a benchmarking module.
+///
+/// See `frame_benchmarking::v2` for more info.
+#[proc_macro_attribute]
+pub fn benchmarks(attr: TokenStream, tokens: TokenStream) -> TokenStream {
+	match benchmark::benchmarks(attr, tokens, false) {
+		Ok(tokens) => tokens,
+		Err(err) => err.to_compile_error().into(),
+	}
+}
+
+/// An attribute macro that can be attached to a (non-empty) module declaration. Doing so will
+/// designate that module as an instance benchmarking module.
+///
+/// See `frame_benchmarking::v2` for more info.
+#[proc_macro_attribute]
+pub fn instance_benchmarks(attr: TokenStream, tokens: TokenStream) -> TokenStream {
+	match benchmark::benchmarks(attr, tokens, true) {
+		Ok(tokens) => tokens,
+		Err(err) => err.to_compile_error().into(),
+	}
+}
+
+/// An attribute macro used to declare a benchmark within a benchmarking module. Must be
+/// attached to a function definition containing an `#[extrinsic_call]` or `#[block]`
+/// attribute.
+///
+/// See `frame_benchmarking::v2` for more info.
+#[proc_macro_attribute]
+pub fn benchmark(_attrs: TokenStream, _tokens: TokenStream) -> TokenStream {
+	quote!(compile_error!(
+		"`#[benchmark]` must be in a module labeled with #[benchmarks] or #[instance_benchmarks]."
+	))
+	.into()
+}
+
+/// An attribute macro used to specify the extrinsic call inside a benchmark function, and also
+/// used as a boundary designating where the benchmark setup code ends, and the benchmark
+/// verification code begins.
+///
+/// See `frame_benchmarking::v2` for more info.
+#[proc_macro_attribute]
+pub fn extrinsic_call(_attrs: TokenStream, _tokens: TokenStream) -> TokenStream {
+	quote!(compile_error!(
+		"`#[extrinsic_call]` must be in a benchmark function definition labeled with `#[benchmark]`."
+	);)
+	.into()
+}
+
+/// An attribute macro used to specify that a block should be the measured portion of the
+/// enclosing benchmark function, This attribute is also used as a boundary designating where
+/// the benchmark setup code ends, and the benchmark verification code begins.
+///
+/// See `frame_benchmarking::v2` for more info.
+#[proc_macro_attribute]
+pub fn block(_attrs: TokenStream, _tokens: TokenStream) -> TokenStream {
+	quote!(compile_error!(
+		"`#[block]` must be in a benchmark function definition labeled with `#[benchmark]`."
+	))
+	.into()
+}
+
+/// Execute the annotated function in a new storage transaction.
+///
+/// The return type of the annotated function must be `Result`. All changes to storage performed
+/// by the annotated function are discarded if it returns `Err`, or committed if `Ok`.
+///
+/// # Example
+///
+/// ```nocompile
+/// #[transactional]
+/// fn value_commits(v: u32) -> result::Result<u32, &'static str> {
+/// 	Value::set(v);
+/// 	Ok(v)
+/// }
+///
+/// #[transactional]
+/// fn value_rollbacks(v: u32) -> result::Result<u32, &'static str> {
+/// 	Value::set(v);
+/// 	Err("nah")
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn transactional(attr: TokenStream, input: TokenStream) -> TokenStream {
+	transactional::transactional(attr, input).unwrap_or_else(|e| e.to_compile_error().into())
+}
+
+#[proc_macro_attribute]
+pub fn require_transactional(attr: TokenStream, input: TokenStream) -> TokenStream {
+	transactional::require_transactional(attr, input)
+		.unwrap_or_else(|e| e.to_compile_error().into())
+}
+
+/// Derive [`Clone`] but do not bound any generic. Docs are at `frame_support::CloneNoBound`.
+#[proc_macro_derive(CloneNoBound)]
+pub fn derive_clone_no_bound(input: TokenStream) -> TokenStream {
+	no_bound::clone::derive_clone_no_bound(input)
+}
+
+/// Derive [`Debug`] but do not bound any generics. Docs are at `frame_support::DebugNoBound`.
+#[proc_macro_derive(DebugNoBound)]
+pub fn derive_debug_no_bound(input: TokenStream) -> TokenStream {
+	no_bound::debug::derive_debug_no_bound(input)
+}
+
+/// Derive [`Debug`], if `std` is enabled it uses `frame_support::DebugNoBound`, if `std` is not
+/// enabled it just returns `"<wasm:stripped>"`.
+/// This behaviour is useful to prevent bloating the runtime WASM blob from unneeded code.
+#[proc_macro_derive(RuntimeDebugNoBound)]
+pub fn derive_runtime_debug_no_bound(input: TokenStream) -> TokenStream {
+	if cfg!(any(feature = "std", feature = "try-runtime")) {
+		no_bound::debug::derive_debug_no_bound(input)
+	} else {
+		let input: syn::DeriveInput = match syn::parse(input) {
+			Ok(input) => input,
+			Err(e) => return e.to_compile_error().into(),
+		};
+
+		let name = &input.ident;
+		let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+		quote::quote!(
+			const _: () = {
+				impl #impl_generics core::fmt::Debug for #name #ty_generics #where_clause {
+					fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+						fmt.write_str("<wasm:stripped>")
+					}
+				}
+			};
+		)
+		.into()
+	}
+}
+
+/// Derive [`PartialEq`] but do not bound any generic. Docs are at
+/// `frame_support::PartialEqNoBound`.
+#[proc_macro_derive(PartialEqNoBound)]
+pub fn derive_partial_eq_no_bound(input: TokenStream) -> TokenStream {
+	no_bound::partial_eq::derive_partial_eq_no_bound(input)
+}
+
+/// derive Eq but do no bound any generic. Docs are at `frame_support::EqNoBound`.
+#[proc_macro_derive(EqNoBound)]
+pub fn derive_eq_no_bound(input: TokenStream) -> TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let name = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	quote::quote_spanned!(name.span() =>
+		const _: () = {
+			impl #impl_generics core::cmp::Eq for #name #ty_generics #where_clause {}
+		};
+	)
+	.into()
+}
+
+/// derive `Default` but do no bound any generic. Docs are at `frame_support::DefaultNoBound`.
+#[proc_macro_derive(DefaultNoBound, attributes(default))]
+pub fn derive_default_no_bound(input: TokenStream) -> TokenStream {
+	no_bound::default::derive_default_no_bound(input)
+}
+
+#[proc_macro]
+pub fn crate_to_crate_version(input: TokenStream) -> TokenStream {
+	crate_version::crate_to_crate_version(input)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+/// The number of module instances supported by the runtime, starting at index 1,
+/// and up to `NUMBER_OF_INSTANCE`.
+pub(crate) const NUMBER_OF_INSTANCE: u8 = 16;
+
+/// This macro is meant to be used by frame-support only.
+/// It implements the trait `HasKeyPrefix` and `HasReversibleKeyPrefix` for tuple of `Key`.
+#[proc_macro]
+pub fn impl_key_prefix_for_tuples(input: TokenStream) -> TokenStream {
+	key_prefix::impl_key_prefix_for_tuples(input)
+		.unwrap_or_else(syn::Error::into_compile_error)
+		.into()
+}
+
+/// Internal macro use by frame_support to generate dummy part checker for old pallet declaration
+#[proc_macro]
+pub fn __generate_dummy_part_checker(input: TokenStream) -> TokenStream {
+	dummy_part_checker::generate_dummy_part_checker(input)
+}
+
+/// Macro that inserts some tokens after the first match of some pattern.
+///
+/// # Example:
+///
+/// ```nocompile
+/// match_and_insert!(
+///     target = [{ Some content with { at some point match pattern } other match pattern are ignored }]
+///     pattern = [{ match pattern }] // the match pattern cannot contain any group: `[]`, `()`, `{}`
+/// 								  // can relax this constraint, but will require modifying the match logic in code
+///     tokens = [{ expansion tokens }] // content inside braces can be anything including groups
+/// );
+/// ```
+///
+/// will generate:
+///
+/// ```nocompile
+///     Some content with { at some point match pattern expansion tokens } other match patterns are
+///     ignored
+/// ```
+#[proc_macro]
+pub fn match_and_insert(input: TokenStream) -> TokenStream {
+	match_and_insert::match_and_insert(input)
+}
+
+#[proc_macro_derive(PalletError, attributes(codec))]
+pub fn derive_pallet_error(input: TokenStream) -> TokenStream {
+	pallet_error::derive_pallet_error(input)
+}
+
+/// Internal macro used by `frame_support` to create tt-call-compliant macros
+#[proc_macro]
+pub fn __create_tt_macro(input: TokenStream) -> TokenStream {
+	tt_macro::create_tt_return_macro(input)
+}
+
+#[proc_macro_attribute]
+pub fn storage_alias(attributes: TokenStream, input: TokenStream) -> TokenStream {
+	storage_alias::storage_alias(attributes.into(), input.into())
+		.unwrap_or_else(|r| r.into_compile_error())
+		.into()
+}
+
+/// This attribute can be used to derive a full implementation of a trait based on a local partial
+/// impl and an external impl containing defaults that can be overriden in the local impl.
+///
+/// For a full end-to-end example, see [below](#use-case-auto-derive-test-pallet-config-traits).
+///
+/// # Usage
+///
+/// The attribute should be attached to an impl block (strictly speaking a `syn::ItemImpl`) for
+/// which we want to inject defaults in the event of missing trait items in the block.
+///
+/// The attribute minimally takes a single `default_impl_path` argument, which should be the module
+/// path to an impl registered via [`#[register_default_impl]`](`macro@register_default_impl`) that
+/// contains the default trait items we want to potentially inject, with the general form:
+///
+/// ```ignore
+/// #[derive_impl(default_impl_path)]
+/// impl SomeTrait for SomeStruct {
+///     ...
+/// }
+/// ```
+///
+/// Optionally, a `disambiguation_path` can be specified as follows by providing `as path::here`
+/// after the `default_impl_path`:
+///
+/// ```ignore
+/// #[derive_impl(default_impl_path as disambiguation_path)]
+/// impl SomeTrait for SomeStruct {
+///     ...
+/// }
+/// ```
+///
+/// The `disambiguation_path`, if specified, should be the path to a trait that will be used to
+/// qualify all default entries that are injected into the local impl. For example if your
+/// `default_impl_path` is `some::path::TestTraitImpl` and your `disambiguation_path` is
+/// `another::path::DefaultTrait`, any items injected into the local impl will be qualified as
+/// `<some::path::TestTraitImpl as another::path::DefaultTrait>::specific_trait_item`.
+///
+/// If you omit the `as disambiguation_path` portion, the `disambiguation_path` will internally
+/// default to `A` from the `impl A for B` part of the default impl. This is useful for scenarios
+/// where all of the relevant types are already in scope via `use` statements.
+///
+/// Conversely, the `default_impl_path` argument is required and cannot be omitted.
+///
+/// Optionally, `no_aggregated_types` can be specified as follows:
+///
+/// ```ignore
+/// #[derive_impl(default_impl_path as disambiguation_path, no_aggregated_types)]
+/// impl SomeTrait for SomeStruct {
+///     ...
+/// }
+/// ```
+///
+/// If specified, this indicates that the aggregated types (as denoted by impl items
+/// attached with [`#[inject_runtime_type]`]) should not be injected with the respective concrete
+/// types. By default, all such types are injected.
+///
+/// You can also make use of `#[pallet::no_default]` on specific items in your default impl that you
+/// want to ensure will not be copied over but that you nonetheless want to use locally in the
+/// context of the foreign impl and the pallet (or context) in which it is defined.
+///
+/// ## Use-Case Example: Auto-Derive Test Pallet Config Traits
+///
+/// The `#[derive_imp(..)]` attribute can be used to derive a test pallet `Config` based on an
+/// existing pallet `Config` that has been marked with
+/// [`#[pallet::config(with_default)]`](`macro@config`) (which under the hood, generates a
+/// `DefaultConfig` trait in the pallet in which the macro was invoked).
+///
+/// In this case, the `#[derive_impl(..)]` attribute should be attached to an `impl` block that
+/// implements a compatible `Config` such as `frame_system::Config` for a test/mock runtime, and
+/// should receive as its first argument the path to a `DefaultConfig` impl that has been registered
+/// via [`#[register_default_impl]`](`macro@register_default_impl`), and as its second argument, the
+/// path to the auto-generated `DefaultConfig` for the existing pallet `Config` we want to base our
+/// test config off of.
+///
+/// The following is what the `basic` example pallet would look like with a default testing config:
+///
+/// ```ignore
+/// #[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::pallet::DefaultConfig)]
+/// impl frame_system::Config for Test {
+///     // These are all defined by system as mandatory.
+///     type BaseCallFilter = frame_support::traits::Everything;
+///     type RuntimeEvent = RuntimeEvent;
+///     type RuntimeCall = RuntimeCall;
+///     type RuntimeOrigin = RuntimeOrigin;
+///     type OnSetCode = ();
+///     type PalletInfo = PalletInfo;
+///     type Block = Block;
+///     // We decide to override this one.
+///     type AccountData = pallet_balances::AccountData<u64>;
+/// }
+/// ```
+///
+/// where `TestDefaultConfig` was defined and registered as follows:
+///
+/// ```ignore
+/// pub struct TestDefaultConfig;
+///
+/// #[register_default_impl(TestDefaultConfig)]
+/// impl DefaultConfig for TestDefaultConfig {
+///     type Version = ();
+///     type BlockWeights = ();
+///     type BlockLength = ();
+///     type DbWeight = ();
+///     type Nonce = u64;
+///     type BlockNumber = u64;
+///     type Hash = sp_core::hash::H256;
+///     type Hashing = sp_runtime::traits::BlakeTwo256;
+///     type AccountId = AccountId;
+///     type Lookup = IdentityLookup<AccountId>;
+///     type BlockHashCount = frame_support::traits::ConstU64<10>;
+///     type AccountData = u32;
+///     type OnNewAccount = ();
+///     type OnKilledAccount = ();
+///     type SystemWeightInfo = ();
+///     type SS58Prefix = ();
+///     type MaxConsumers = frame_support::traits::ConstU32<16>;
+/// }
+/// ```
+///
+/// The above call to `derive_impl` would expand to roughly the following:
+///
+/// ```ignore
+/// impl frame_system::Config for Test {
+///     use frame_system::config_preludes::TestDefaultConfig;
+///     use frame_system::pallet::DefaultConfig;
+///
+///     type BaseCallFilter = frame_support::traits::Everything;
+///     type RuntimeEvent = RuntimeEvent;
+///     type RuntimeCall = RuntimeCall;
+///     type RuntimeOrigin = RuntimeOrigin;
+///     type OnSetCode = ();
+///     type PalletInfo = PalletInfo;
+///     type Block = Block;
+///     type AccountData = pallet_balances::AccountData<u64>;
+///     type Version = <TestDefaultConfig as DefaultConfig>::Version;
+///     type BlockWeights = <TestDefaultConfig as DefaultConfig>::BlockWeights;
+///     type BlockLength = <TestDefaultConfig as DefaultConfig>::BlockLength;
+///     type DbWeight = <TestDefaultConfig as DefaultConfig>::DbWeight;
+///     type Nonce = <TestDefaultConfig as DefaultConfig>::Nonce;
+///     type BlockNumber = <TestDefaultConfig as DefaultConfig>::BlockNumber;
+///     type Hash = <TestDefaultConfig as DefaultConfig>::Hash;
+///     type Hashing = <TestDefaultConfig as DefaultConfig>::Hashing;
+///     type AccountId = <TestDefaultConfig as DefaultConfig>::AccountId;
+///     type Lookup = <TestDefaultConfig as DefaultConfig>::Lookup;
+///     type BlockHashCount = <TestDefaultConfig as DefaultConfig>::BlockHashCount;
+///     type OnNewAccount = <TestDefaultConfig as DefaultConfig>::OnNewAccount;
+///     type OnKilledAccount = <TestDefaultConfig as DefaultConfig>::OnKilledAccount;
+///     type SystemWeightInfo = <TestDefaultConfig as DefaultConfig>::SystemWeightInfo;
+///     type SS58Prefix = <TestDefaultConfig as DefaultConfig>::SS58Prefix;
+///     type MaxConsumers = <TestDefaultConfig as DefaultConfig>::MaxConsumers;
+/// }
+/// ```
+///
+/// You can then use the resulting `Test` config in test scenarios.
+///
+/// Note that items that are _not_ present in our local `DefaultConfig` are automatically copied
+/// from the foreign trait (in this case `TestDefaultConfig`) into the local trait impl (in this
+/// case `Test`), unless the trait item in the local trait impl is marked with
+/// [`#[pallet::no_default]`](`macro@no_default`), in which case it cannot be overridden, and any
+/// attempts to do so will result in a compiler error.
+///
+/// See `frame/examples/default-config/tests.rs` for a runnable end-to-end example pallet that makes
+/// use of `derive_impl` to derive its testing config.
+///
+/// See [here](`macro@config`) for more information and caveats about the auto-generated
+/// `DefaultConfig` trait.
+///
+/// ## Optional Conventions
+///
+/// Note that as an optional convention, we encourage creating a `config_preludes` module inside of
+/// your pallet. This is the convention we follow for `frame_system`'s `TestDefaultConfig` which, as
+/// shown above, is located at `frame_system::config_preludes::TestDefaultConfig`. This is just a
+/// suggested convention -- there is nothing in the code that expects modules with these names to be
+/// in place, so there is no imperative to follow this pattern unless desired.
+///
+/// In `config_preludes`, you can place types named like:
+///
+/// * `TestDefaultConfig`
+/// * `ParachainDefaultConfig`
+/// * `SolochainDefaultConfig`
+///
+/// Signifying in which context they can be used.
+///
+/// # Advanced Usage
+///
+/// ## Expansion
+///
+/// The `#[derive_impl(default_impl_path as disambiguation_path)]` attribute will expand to the
+/// local impl, with any extra items from the foreign impl that aren't present in the local impl
+/// also included. In the case of a colliding trait item, the version of the item that exists in the
+/// local impl will be retained. All imported items are qualified by the `disambiguation_path`, as
+/// discussed above.
+///
+/// ## Handling of Unnamed Trait Items
+///
+/// Items that lack a `syn::Ident` for whatever reason are first checked to see if they exist,
+/// verbatim, in the local/destination trait before they are copied over, so you should not need to
+/// worry about collisions between identical unnamed items.
+#[import_tokens_attr {
+    format!(
+        "{}::macro_magic",
+        match generate_crate_access_2018("frame-support") {
+            Ok(path) => Ok(path),
+            Err(_) => generate_crate_access_2018("frame"),
+        }
+        .expect("Failed to find either `frame-support` or `frame` in `Cargo.toml` dependencies.")
+        .to_token_stream()
+        .to_string()
+    )
+}]
+#[with_custom_parsing(derive_impl::DeriveImplAttrArgs)]
+#[proc_macro_attribute]
+pub fn derive_impl(attrs: TokenStream, input: TokenStream) -> TokenStream {
+	let custom_attrs = parse_macro_input!(__custom_tokens as derive_impl::DeriveImplAttrArgs);
+	derive_impl::derive_impl(
+		__source_path.into(),
+		attrs.into(),
+		input.into(),
+		custom_attrs.disambiguation_path,
+		custom_attrs.no_aggregated_types,
+	)
+	.unwrap_or_else(|r| r.into_compile_error())
+	.into()
+}
+
+/// The optional attribute `#[pallet::no_default]` can be attached to trait items within a
+/// `Config` trait impl that has [`#[pallet::config(with_default)]`](`macro@config`) attached.
+///
+/// Attaching this attribute to a trait item ensures that that trait item will not be used as a
+/// default with the [`#[derive_impl(..)]`](`macro@derive_impl`) attribute macro.
+#[proc_macro_attribute]
+pub fn no_default(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The optional attribute `#[pallet::no_default_bounds]` can be attached to trait items within a
+/// `Config` trait impl that has [`#[pallet::config(with_default)]`](`macro@config`) attached.
+///
+/// Attaching this attribute to a trait item ensures that the generated trait `DefaultConfig`
+/// will not have any bounds for this trait item.
+///
+/// As an example, if you have a trait item `type AccountId: SomeTrait;` in your `Config` trait,
+/// the generated `DefaultConfig` will only have `type AccountId;` with no trait bound.
+#[proc_macro_attribute]
+pub fn no_default_bounds(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// Attach this attribute to an impl statement that you want to use with
+/// [`#[derive_impl(..)]`](`macro@derive_impl`).
+///
+/// You must also provide an identifier/name as the attribute's argument. This is the name you
+/// must provide to [`#[derive_impl(..)]`](`macro@derive_impl`) when you import this impl via
+/// the `default_impl_path` argument. This name should be unique at the crate-level.
+///
+/// ## Example
+///
+/// ```ignore
+/// pub struct ExampleTestDefaultConfig;
+///
+/// #[register_default_impl(ExampleTestDefaultConfig)]
+/// impl DefaultConfig for ExampleTestDefaultConfig {
+/// 	type Version = ();
+/// 	type BlockWeights = ();
+/// 	type BlockLength = ();
+/// 	...
+/// 	type SS58Prefix = ();
+/// 	type MaxConsumers = frame_support::traits::ConstU32<16>;
+/// }
+/// ```
+///
+/// ## Advanced Usage
+///
+/// This macro acts as a thin wrapper around macro_magic's `#[export_tokens]`. See the docs
+/// [here](https://docs.rs/macro_magic/latest/macro_magic/attr.export_tokens.html) for more
+/// info.
+///
+/// There are some caveats when applying a `use` statement to bring a
+/// `#[register_default_impl]` item into scope. If you have a `#[register_default_impl]`
+/// defined in `my_crate::submodule::MyItem`, it is currently not sufficient to do something
+/// like:
+///
+/// ```ignore
+/// use my_crate::submodule::MyItem;
+/// #[derive_impl(MyItem as Whatever)]
+/// ```
+///
+/// This will fail with a mysterious message about `__export_tokens_tt_my_item` not being
+/// defined.
+///
+/// You can, however, do any of the following:
+/// ```ignore
+/// // partial path works
+/// use my_crate::submodule;
+/// #[derive_impl(submodule::MyItem as Whatever)]
+/// ```
+/// ```ignore
+/// // full path works
+/// #[derive_impl(my_crate::submodule::MyItem as Whatever)]
+/// ```
+/// ```ignore
+/// // wild-cards work
+/// use my_crate::submodule::*;
+/// #[derive_impl(MyItem as Whatever)]
+/// ```
+#[proc_macro_attribute]
+pub fn register_default_impl(attrs: TokenStream, tokens: TokenStream) -> TokenStream {
+	// ensure this is a impl statement
+	let item_impl = syn::parse_macro_input!(tokens as ItemImpl);
+
+	// internally wrap macro_magic's `#[export_tokens]` macro
+	match macro_magic::mm_core::export_tokens_internal(attrs, item_impl.to_token_stream(), true) {
+		Ok(tokens) => tokens.into(),
+		Err(err) => err.to_compile_error().into(),
+	}
+}
+
+#[proc_macro_attribute]
+pub fn inject_runtime_type(_: TokenStream, tokens: TokenStream) -> TokenStream {
+	let item = tokens.clone();
+	let item = syn::parse_macro_input!(item as TraitItemType);
+	if item.ident != "RuntimeCall" &&
+		item.ident != "RuntimeEvent" &&
+		item.ident != "RuntimeOrigin" &&
+		item.ident != "PalletInfo"
+	{
+		return syn::Error::new_spanned(
+			item,
+			"`#[inject_runtime_type]` can only be attached to `RuntimeCall`, `RuntimeEvent`, `RuntimeOrigin` or `PalletInfo`",
+		)
+		.to_compile_error()
+		.into();
+	}
+	tokens
+}
+
+/// Used internally to decorate pallet attribute macro stubs when they are erroneously used
+/// outside of a pallet module
+fn pallet_macro_stub() -> TokenStream {
+	quote!(compile_error!(
+		"This attribute can only be used from within a pallet module marked with `#[frame_support::pallet]`"
+	))
+	.into()
+}
+
+/// The mandatory attribute `#[pallet::config]` defines the configurable options for the pallet.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::config]
+/// pub trait Config: frame_system::Config + $optionally_some_other_supertraits
+/// $optional_where_clause
+/// {
+/// ...
+/// }
+/// ```
+///
+/// I.e. a regular trait definition named `Config`, with the supertrait
+/// `frame_system::pallet::Config`, and optionally other supertraits and a where clause.
+/// (Specifying other supertraits here is known as [tight
+/// coupling](https://docs.substrate.io/reference/how-to-guides/pallet-design/use-tight-coupling/))
+///
+/// The associated type `RuntimeEvent` is reserved. If defined, it must have the bounds
+/// `From<Event>` and `IsType<<Self as frame_system::Config>::RuntimeEvent>`.
+///
+/// [`pallet::event`](`macro@event`) must be present if `RuntimeEvent` exists as a config item
+/// in your `#[pallet::config]`.
+///
+/// ## Optional: `with_default`
+///
+/// An optional `with_default` argument may also be specified. Doing so will automatically
+/// generate a `DefaultConfig` trait inside your pallet which is suitable for use with
+/// [`[#[derive_impl(..)]`](`macro@derive_impl`) to derive a default testing config:
+///
+/// ```ignore
+/// #[pallet::config(with_default)]
+/// pub trait Config: frame_system::Config {
+/// 		type RuntimeEvent: Parameter
+/// 			+ Member
+/// 			+ From<Event<Self>>
+/// 			+ Debug
+/// 			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+///
+/// 		#[pallet::no_default]
+/// 		type BaseCallFilter: Contains<Self::RuntimeCall>;
+/// 	// ...
+/// }
+/// ```
+///
+/// As shown above, you may also attach the [`#[pallet::no_default]`](`macro@no_default`)
+/// attribute to specify that a particular trait item _cannot_ be used as a default when a test
+/// `Config` is derived using the [`#[derive_impl(..)]`](`macro@derive_impl`) attribute macro.
+/// This will cause that particular trait item to simply not appear in default testing configs
+/// based on this config (the trait item will not be included in `DefaultConfig`).
+///
+/// ### `DefaultConfig` Caveats
+///
+/// The auto-generated `DefaultConfig` trait:
+/// - is always a _subset_ of your pallet's `Config` trait.
+/// - can only contain items that don't rely on externalities, such as `frame_system::Config`.
+///
+/// Trait items that _do_ rely on externalities should be marked with
+/// [`#[pallet::no_default]`](`macro@no_default`)
+///
+/// Consequently:
+/// - Any items that rely on externalities _must_ be marked with
+///   [`#[pallet::no_default]`](`macro@no_default`) or your trait will fail to compile when used
+///   with [`derive_impl`](`macro@derive_impl`).
+/// - Items marked with [`#[pallet::no_default]`](`macro@no_default`) are entirely excluded from the
+///   `DefaultConfig` trait, and therefore any impl of `DefaultConfig` doesn't need to implement
+///   such items.
+///
+/// For more information, see [`macro@derive_impl`].
+#[proc_macro_attribute]
+pub fn config(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::constant]` attribute can be used to add an associated type trait bounded by `Get`
+/// from [`pallet::config`](`macro@config`) into metadata, e.g.:
+///
+/// ```ignore
+/// #[pallet::config]
+/// pub trait Config: frame_system::Config {
+/// 	#[pallet::constant]
+/// 	type Foo: Get<u32>;
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn constant(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// To bypass the `frame_system::Config` supertrait check, use the attribute
+/// `pallet::disable_frame_system_supertrait_check`, e.g.:
+///
+/// ```ignore
+/// #[pallet::config]
+/// #[pallet::disable_frame_system_supertrait_check]
+/// pub trait Config: pallet_timestamp::Config {}
+/// ```
+///
+/// NOTE: Bypassing the `frame_system::Config` supertrait check is typically desirable when you
+/// want to write an alternative to the `frame_system` pallet.
+#[proc_macro_attribute]
+pub fn disable_frame_system_supertrait_check(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// To generate a `Store` trait associating all storages, annotate your `Pallet` struct with
+/// the attribute `#[pallet::generate_store($vis trait Store)]`, e.g.:
+///
+/// ```ignore
+/// #[pallet::pallet]
+/// #[pallet::generate_store(pub(super) trait Store)]
+/// pub struct Pallet<T>(_);
+/// ```
+/// More precisely, the `Store` trait contains an associated type for each storage. It is
+/// implemented for `Pallet` allowing access to the storage from pallet struct.
+///
+/// Thus when defining a storage named `Foo`, it can later be accessed from `Pallet` using
+/// `<Pallet as Store>::Foo`.
+///
+/// NOTE: this attribute is only valid when applied _directly_ to your `Pallet` struct
+/// definition.
+#[proc_macro_attribute]
+pub fn generate_store(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// Because the `pallet::pallet` macro implements `GetStorageVersion`, the current storage
+/// version needs to be communicated to the macro. This can be done by using the
+/// `pallet::storage_version` attribute:
+///
+/// ```ignore
+/// const STORAGE_VERSION: StorageVersion = StorageVersion::new(5);
+///
+/// #[pallet::pallet]
+/// #[pallet::storage_version(STORAGE_VERSION)]
+/// pub struct Pallet<T>(_);
+/// ```
+///
+/// If not present, the current storage version is set to the default value.
+#[proc_macro_attribute]
+pub fn storage_version(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::hooks]` attribute allows you to specify a `Hooks` implementation for
+/// `Pallet` that specifies pallet-specific logic.
+///
+/// The item the attribute attaches to must be defined as follows:
+/// ```ignore
+/// #[pallet::hooks]
+/// impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> $optional_where_clause {
+///     ...
+/// }
+/// ```
+/// I.e. a regular trait implementation with generic bound: `T: Config`, for the trait
+/// `Hooks<BlockNumberFor<T>>` (they are defined in preludes), for the type `Pallet<T>` and
+/// with an optional where clause.
+///
+/// If no `#[pallet::hooks]` exists, then the following default implementation is
+/// automatically generated:
+/// ```ignore
+/// #[pallet::hooks]
+/// impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+/// ```
+///
+/// ## Macro expansion
+///
+/// The macro implements the traits `OnInitialize`, `OnIdle`, `OnFinalize`, `OnRuntimeUpgrade`,
+/// `OffchainWorker`, and `IntegrityTest` using the provided `Hooks` implementation.
+///
+/// NOTE: `OnRuntimeUpgrade` is implemented with `Hooks::on_runtime_upgrade` and some
+/// additional logic. E.g. logic to write the pallet version into storage.
+///
+/// NOTE: The macro also adds some tracing logic when implementing the above traits. The
+/// following hooks emit traces: `on_initialize`, `on_finalize` and `on_runtime_upgrade`.
+#[proc_macro_attribute]
+pub fn hooks(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// Each dispatchable needs to define a weight with `#[pallet::weight($expr)]` attribute, the
+/// first argument must be `origin: OriginFor<T>`.
+#[proc_macro_attribute]
+pub fn weight(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// Compact encoding for arguments can be achieved via `#[pallet::compact]`. The function must
+/// return a `DispatchResultWithPostInfo` or `DispatchResult`.
+#[proc_macro_attribute]
+pub fn compact(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// Each dispatchable may also be annotated with the `#[pallet::call_index($idx)]` attribute,
+/// which explicitly defines the codec index for the dispatchable function in the `Call` enum.
+///
+/// All call indexes start from 0, until it encounters a dispatchable function with a defined
+/// call index. The dispatchable function that lexically follows the function with a defined
+/// call index will have that call index, but incremented by 1, e.g. if there are 3
+/// dispatchable functions `fn foo`, `fn bar` and `fn qux` in that order, and only `fn bar`
+/// has a call index of 10, then `fn qux` will have an index of 11, instead of 1.
+///
+/// All arguments must implement [`Debug`], [`PartialEq`], [`Eq`], `Decode`, `Encode`, and
+/// [`Clone`]. For ease of use, bound by the trait `frame_support::pallet_prelude::Member`.
+///
+/// If no `#[pallet::call]` exists, then a default implementation corresponding to the
+/// following code is automatically generated:
+///
+/// ```ignore
+/// #[pallet::call]
+/// impl<T: Config> Pallet<T> {}
+/// ```
+///
+/// **WARNING**: modifying dispatchables, changing their order, removing some, etc., must be
+/// done with care. Indeed this will change the outer runtime call type (which is an enum with
+/// one variant per pallet), this outer runtime call can be stored on-chain (e.g. in
+/// `pallet-scheduler`). Thus migration might be needed. To mitigate against some of this, the
+/// `#[pallet::call_index($idx)]` attribute can be used to fix the order of the dispatchable so
+/// that the `Call` enum encoding does not change after modification. As a general rule of
+/// thumb, it is therefore adventageous to always add new calls to the end so you can maintain
+/// the existing order of calls.
+///
+/// ### Macro expansion
+///
+/// The macro creates an enum `Call` with one variant per dispatchable. This enum implements:
+/// [`Clone`], [`Eq`], [`PartialEq`], [`Debug`] (with stripped implementation in `not("std")`),
+/// `Encode`, `Decode`, `GetDispatchInfo`, `GetCallName`, `GetCallIndex` and
+/// `UnfilteredDispatchable`.
+///
+/// The macro implements the `Callable` trait on `Pallet` and a function `call_functions`
+/// which returns the dispatchable metadata.
+#[proc_macro_attribute]
+pub fn call_index(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// Allows you to define some extra constants to be added into constant metadata.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::extra_constants]
+/// impl<T: Config> Pallet<T> where $optional_where_clause {
+/// 	/// $some_doc
+/// 	$vis fn $fn_name() -> $some_return_type {
+/// 		...
+/// 	}
+/// 	...
+/// }
+/// ```
+/// I.e. a regular rust `impl` block with some optional where clause and functions with 0 args,
+/// 0 generics, and some return type.
+///
+/// ## Macro expansion
+///
+/// The macro add some extra constants to pallet constant metadata.
+#[proc_macro_attribute]
+pub fn extra_constants(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::error]` attribute allows you to define an error enum that will be returned
+/// from the dispatchable when an error occurs. The information for this error type is then
+/// stored in metadata.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::error]
+/// pub enum Error<T> {
+/// 	/// $some_optional_doc
+/// 	$SomeFieldLessVariant,
+/// 	/// $some_more_optional_doc
+/// 	$SomeVariantWithOneField(FieldType),
+/// 	...
+/// }
+/// ```
+/// I.e. a regular enum named `Error`, with generic `T` and fieldless or multiple-field
+/// variants.
+///
+/// Any field type in the enum variants must implement `TypeInfo` in order to be properly used
+/// in the metadata, and its encoded size should be as small as possible, preferably 1 byte in
+/// size in order to reduce storage size. The error enum itself has an absolute maximum encoded
+/// size specified by `MAX_MODULE_ERROR_ENCODED_SIZE`.
+///
+/// (1 byte can still be 256 different errors. The more specific the error, the easier it is to
+/// diagnose problems and give a better experience to the user. Don't skimp on having lots of
+/// individual error conditions.)
+///
+/// Field types in enum variants must also implement `PalletError`, otherwise the pallet will
+/// fail to compile. Rust primitive types have already implemented the `PalletError` trait
+/// along with some commonly used stdlib types such as [`Option`] and `PhantomData`, and hence
+/// in most use cases, a manual implementation is not necessary and is discouraged.
+///
+/// The generic `T` must not bound anything and a `where` clause is not allowed. That said,
+/// bounds and/or a where clause should not needed for any use-case.
+///
+/// ## Macro expansion
+///
+/// The macro implements the [`Debug`] trait and functions `as_u8` using variant position, and
+/// `as_str` using variant doc.
+///
+/// The macro also implements `From<Error<T>>` for `&'static str` and `From<Error<T>>` for
+/// `DispatchError`.
+#[proc_macro_attribute]
+pub fn error(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::event]` attribute allows you to define pallet events. Pallet events are
+/// stored under the `system` / `events` key when the block is applied (and then replaced when
+/// the next block writes it's events).
+///
+/// The Event enum must be defined as follows:
+///
+/// ```ignore
+/// #[pallet::event]
+/// #[pallet::generate_deposit($visibility fn deposit_event)] // Optional
+/// pub enum Event<$some_generic> $optional_where_clause {
+/// 	/// Some doc
+/// 	$SomeName($SomeType, $YetanotherType, ...),
+/// 	...
+/// }
+/// ```
+///
+/// I.e. an enum (with named or unnamed fields variant), named `Event`, with generic: none or
+/// `T` or `T: Config`, and optional w here clause.
+///
+/// Each field must implement [`Clone`], [`Eq`], [`PartialEq`], `Encode`, `Decode`, and
+/// [`Debug`] (on std only). For ease of use, bound by the trait `Member`, available in
+/// `frame_support::pallet_prelude`.
+#[proc_macro_attribute]
+pub fn event(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The attribute `#[pallet::generate_deposit($visibility fn deposit_event)]` generates a
+/// helper function on `Pallet` that handles deposit events.
+///
+/// NOTE: For instantiable pallets, the event must be generic over `T` and `I`.
+///
+/// ## Macro expansion
+///
+/// The macro will add on enum `Event` the attributes:
+/// * `#[derive(frame_support::CloneNoBound)]`
+/// * `#[derive(frame_support::EqNoBound)]`
+/// * `#[derive(frame_support::PartialEqNoBound)]`
+/// * `#[derive(frame_support::RuntimeDebugNoBound)]`
+/// * `#[derive(codec::Encode)]`
+/// * `#[derive(codec::Decode)]`
+///
+/// The macro implements `From<Event<..>>` for ().
+///
+/// The macro implements a metadata function on `Event` returning the `EventMetadata`.
+///
+/// If `#[pallet::generate_deposit]` is present then the macro implements `fn deposit_event` on
+/// `Pallet`.
+#[proc_macro_attribute]
+pub fn generate_deposit(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::storage]` attribute lets you define some abstract storage inside of runtime
+/// storage and also set its metadata. This attribute can be used multiple times.
+///
+/// Item should be defined as:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::getter(fn $getter_name)] // optional
+/// $vis type $StorageName<$some_generic> $optional_where_clause
+/// 	= $StorageType<$generic_name = $some_generics, $other_name = $some_other, ...>;
+/// ```
+///
+/// or with unnamed generic:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::getter(fn $getter_name)] // optional
+/// $vis type $StorageName<$some_generic> $optional_where_clause
+/// 	= $StorageType<_, $some_generics, ...>;
+/// ```
+///
+/// I.e. it must be a type alias, with generics: `T` or `T: Config`. The aliased type must be
+/// one of `StorageValue`, `StorageMap` or `StorageDoubleMap`. The generic arguments of the
+/// storage type can be given in two manners: named and unnamed. For named generic arguments,
+/// the name for each argument should match the name defined for it on the storage struct:
+/// * `StorageValue` expects `Value` and optionally `QueryKind` and `OnEmpty`,
+/// * `StorageMap` expects `Hasher`, `Key`, `Value` and optionally `QueryKind` and `OnEmpty`,
+/// * `CountedStorageMap` expects `Hasher`, `Key`, `Value` and optionally `QueryKind` and `OnEmpty`,
+/// * `StorageDoubleMap` expects `Hasher1`, `Key1`, `Hasher2`, `Key2`, `Value` and optionally
+///   `QueryKind` and `OnEmpty`.
+///
+/// For unnamed generic arguments: Their first generic must be `_` as it is replaced by the
+/// macro and other generic must declared as a normal generic type declaration.
+///
+/// The `Prefix` generic written by the macro is generated using
+/// `PalletInfo::name::<Pallet<..>>()` and the name of the storage type. E.g. if runtime names
+/// the pallet "MyExample" then the storage `type Foo<T> = ...` should use the prefix:
+/// `Twox128(b"MyExample") ++ Twox128(b"Foo")`.
+///
+/// For the `CountedStorageMap` variant, the `Prefix` also implements
+/// `CountedStorageMapInstance`. It also associates a `CounterPrefix`, which is implemented the
+/// same as above, but the storage prefix is prepend with `"CounterFor"`. E.g. if runtime names
+/// the pallet "MyExample" then the storage `type Foo<T> = CountedStorageaMap<...>` will store
+/// its counter at the prefix: `Twox128(b"MyExample") ++ Twox128(b"CounterForFoo")`.
+///
+/// E.g:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// pub(super) type MyStorage<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
+/// ```
+///
+/// In this case the final prefix used by the map is `Twox128(b"MyExample") ++
+/// Twox128(b"OtherName")`.
+#[proc_macro_attribute]
+pub fn storage(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The optional attribute `#[pallet::getter(fn $my_getter_fn_name)]` allows you to define a
+/// getter function on `Pallet`.
+///
+/// Also see [`pallet::storage`](`macro@storage`)
+#[proc_macro_attribute]
+pub fn getter(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The optional attribute `#[pallet::storage_prefix = "SomeName"]` allows you to define the
+/// storage prefix to use. This is helpful if you wish to rename the storage field but don't
+/// want to perform a migration.
+///
+/// E.g:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::storage_prefix = "foo"]
+/// #[pallet::getter(fn my_storage)]
+/// pub(super) type MyStorage<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
+/// ```
+///
+/// or
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::getter(fn my_storage)]
+/// pub(super) type MyStorage<T> = StorageMap<_, Blake2_128Concat, u32, u32>;
+/// ```
+#[proc_macro_attribute]
+pub fn storage_prefix(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The optional attribute `#[pallet::unbounded]` declares the storage as unbounded. When
+/// implementating the storage info (when `#[pallet::generate_storage_info]` is specified on
+/// the pallet struct placeholder), the size of the storage will be declared as unbounded. This
+/// can be useful for storage which can never go into PoV (Proof of Validity).
+#[proc_macro_attribute]
+pub fn unbounded(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The optional attribute `#[pallet::whitelist_storage]` will declare the
+/// storage as whitelisted from benchmarking. Doing so will exclude reads of
+/// that value's storage key from counting towards weight calculations during
+/// benchmarking.
+///
+/// This attribute should only be attached to storages that are known to be
+/// read/used in every block. This will result in a more accurate benchmarking weight.
+///
+/// ### Example
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::whitelist_storage]
+/// pub(super) type Number<T: Config> = StorageValue<_, frame_system::pallet_prelude::BlockNumberFor::<T>, ValueQuery>;
+/// ```
+///
+/// NOTE: As with all `pallet::*` attributes, this one _must_ be written as
+/// `#[pallet::whitelist_storage]` and can only be placed inside a `pallet` module in order for
+/// it to work properly.
+#[proc_macro_attribute]
+pub fn whitelist_storage(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::type_value]` attribute lets you define a struct implementing the `Get` trait
+/// to ease the use of storage types. This attribute is meant to be used alongside
+/// [`#[pallet::storage]`](`macro@storage`) to define a storage's default value. This attribute
+/// can be used multiple times.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::type_value]
+/// fn $MyDefaultName<$some_generic>() -> $default_type $optional_where_clause { $expr }
+/// ```
+///
+/// I.e.: a function definition with generics none or `T: Config` and a returned type.
+///
+/// E.g.:
+///
+/// ```ignore
+/// #[pallet::type_value]
+/// fn MyDefault<T: Config>() -> T::Balance { 3.into() }
+/// ```
+///
+/// ## Macro expansion
+///
+/// The macro renames the function to some internal name, generates a struct with the original
+/// name of the function and its generic, and implements `Get<$ReturnType>` by calling the user
+/// defined function.
+#[proc_macro_attribute]
+pub fn type_value(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::genesis_config]` attribute allows you to define the genesis configuration
+/// for the pallet.
+///
+/// Item is defined as either an enum or a struct. It needs to be public and implement the
+/// trait `GenesisBuild` with [`#[pallet::genesis_build]`](`macro@genesis_build`). The type
+/// generics are constrained to be either none, or `T` or `T: Config`.
+///
+/// E.g:
+///
+/// ```ignore
+/// #[pallet::genesis_config]
+/// pub struct GenesisConfig<T: Config> {
+/// 	_myfield: BalanceOf<T>,
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn genesis_config(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::genesis_build]` attribute allows you to define how `genesis_configuration`
+/// is built. This takes as input the `GenesisConfig` type (as `self`) and constructs the pallet's
+/// initial state.
+///
+/// The impl must be defined as:
+///
+/// ```ignore
+/// #[pallet::genesis_build]
+/// impl<T: Config> GenesisBuild<T> for GenesisConfig<$maybe_generics> {
+/// 	fn build(&self) { $expr }
+/// }
+/// ```
+///
+/// I.e. a trait implementation with generic `T: Config`, of trait `GenesisBuild<T>` on
+/// type `GenesisConfig` with generics none or `T`.
+///
+/// E.g.:
+///
+/// ```ignore
+/// #[pallet::genesis_build]
+/// impl<T: Config> GenesisBuild<T> for GenesisConfig {
+/// 	fn build(&self) {}
+/// }
+/// ```
+///
+/// ## Macro expansion
+///
+/// The macro will add the following attribute:
+/// * `#[cfg(feature = "std")]`
+///
+/// The macro will implement `sp_runtime::BuildStorage`.
+#[proc_macro_attribute]
+pub fn genesis_build(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::inherent]` attribute allows the pallet to provide some
+/// [inherent](https://docs.substrate.io/fundamentals/transaction-types/#inherent-transactions).
+/// An inherent is some piece of data that is inserted by a block authoring node at block
+/// creation time and can either be accepted or rejected by validators based on whether the
+/// data falls within an acceptable range.
+///
+/// The most common inherent is the `timestamp` that is inserted into every block. Since there
+/// is no way to validate timestamps, validators simply check that the timestamp reported by
+/// the block authoring node falls within an acceptable range.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::inherent]
+/// impl<T: Config> ProvideInherent for Pallet<T> {
+/// 	// ... regular trait implementation
+/// }
+/// ```
+///
+/// I.e. a trait implementation with bound `T: Config`, of trait `ProvideInherent` for type
+/// `Pallet<T>`, and some optional where clause.
+///
+/// ## Macro expansion
+///
+/// The macro currently makes no use of this information, but it might use this information in
+/// the future to give information directly to `construct_runtime`.
+#[proc_macro_attribute]
+pub fn inherent(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::validate_unsigned]` attribute allows the pallet to validate some unsigned
+/// transaction:
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::validate_unsigned]
+/// impl<T: Config> ValidateUnsigned for Pallet<T> {
+/// 	// ... regular trait implementation
+/// }
+/// ```
+///
+/// I.e. a trait implementation with bound `T: Config`, of trait `ValidateUnsigned` for type
+/// `Pallet<T>`, and some optional where clause.
+///
+/// NOTE: There is also the `sp_runtime::traits::SignedExtension` trait that can be used to add
+/// some specific logic for transaction validation.
+///
+/// ## Macro expansion
+///
+/// The macro currently makes no use of this information, but it might use this information in
+/// the future to give information directly to `construct_runtime`.
+#[proc_macro_attribute]
+pub fn validate_unsigned(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::origin]` attribute allows you to define some origin for the pallet.
+///
+/// Item must be either a type alias, an enum, or a struct. It needs to be public.
+///
+/// E.g.:
+///
+/// ```ignore
+/// #[pallet::origin]
+/// pub struct Origin<T>(PhantomData<(T)>);
+/// ```
+///
+/// **WARNING**: modifying origin changes the outer runtime origin. This outer runtime origin
+/// can be stored on-chain (e.g. in `pallet-scheduler`), thus any change must be done with care
+/// as it might require some migration.
+///
+/// NOTE: for instantiable pallets, the origin must be generic over `T` and `I`.
+#[proc_macro_attribute]
+pub fn origin(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// The `#[pallet::composite_enum]` attribute allows you to define an enum that gets composed as an
+/// aggregate enum by `construct_runtime`. This is similar in principle with `#[pallet::event]` and
+/// `#[pallet::error]`.
+///
+/// The attribute currently only supports enum definitions, and identifiers that are named
+/// `FreezeReason`, `HoldReason`, `LockId` or `SlashReason`. Arbitrary identifiers for the enum are
+/// not supported. The aggregate enum generated by `construct_runtime` will have the name of
+/// `RuntimeFreezeReason`, `RuntimeHoldReason`, `RuntimeLockId` and `RuntimeSlashReason`
+/// respectively.
+///
+/// NOTE: The aggregate enum generated by `construct_runtime` generates a conversion function from
+/// the pallet enum to the aggregate enum, and automatically derives the following traits:
+///
+/// ```ignore
+/// Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, TypeInfo,
+/// RuntimeDebug
+/// ```
+///
+/// For ease of usage, when no `#[derive]` attributes are found for the enum under
+/// `#[pallet::composite_enum]`, the aforementioned traits are automatically derived for it. The
+/// inverse is also true: if there are any `#[derive]` attributes found for the enum, then no traits
+/// will automatically be derived for it.
+#[proc_macro_attribute]
+pub fn composite_enum(_: TokenStream, _: TokenStream) -> TokenStream {
+	pallet_macro_stub()
+}
+
+/// Can be attached to a module. Doing so will declare that module as importable into a pallet
+/// via [`#[import_section]`](`macro@import_section`).
+///
+/// Note that sections are imported by their module name/ident, and should be referred to by
+/// their _full path_ from the perspective of the target pallet. Do not attempt to make use
+/// of `use` statements to bring pallet sections into scope, as this will not work (unless
+/// you do so as part of a wildcard import, in which case it will work).
+///
+/// ## Naming Logistics
+///
+/// Also note that because of how `#[pallet_section]` works, pallet section names must be
+/// globally unique _within the crate in which they are defined_. For more information on
+/// why this must be the case, see macro_magic's
+/// [`#[export_tokens]`](https://docs.rs/macro_magic/latest/macro_magic/attr.export_tokens.html) macro.
+///
+/// Optionally, you may provide an argument to `#[pallet_section]` such as
+/// `#[pallet_section(some_ident)]`, in the event that there is another pallet section in
+/// same crate with the same ident/name. The ident you specify can then be used instead of
+/// the module's ident name when you go to import it via `#[import_section]`.
+#[proc_macro_attribute]
+pub fn pallet_section(attr: TokenStream, tokens: TokenStream) -> TokenStream {
+	let tokens_clone = tokens.clone();
+	// ensure this can only be attached to a module
+	let _mod = parse_macro_input!(tokens_clone as ItemMod);
+
+	// use macro_magic's export_tokens as the internal implementation otherwise
+	match macro_magic::mm_core::export_tokens_internal(attr, tokens, false) {
+		Ok(tokens) => tokens.into(),
+		Err(err) => err.to_compile_error().into(),
+	}
+}
+
+/// An attribute macro that can be attached to a module declaration. Doing so will
+/// Imports the contents of the specified external pallet section that was defined
+/// previously using [`#[pallet_section]`](`macro@pallet_section`).
+///
+/// ## Example
+/// ```ignore
+/// #[import_section(some_section)]
+/// #[pallet]
+/// pub mod pallet {
+///     // ...
+/// }
+/// ```
+/// where `some_section` was defined elsewhere via:
+/// ```ignore
+/// #[pallet_section]
+/// pub mod some_section {
+///     // ...
+/// }
+/// ```
+///
+/// This will result in the contents of `some_section` being _verbatim_ imported into
+/// the pallet above. Note that since the tokens for `some_section` are essentially
+/// copy-pasted into the target pallet, you cannot refer to imports that don't also
+/// exist in the target pallet, but this is easily resolved by including all relevant
+/// `use` statements within your pallet section, so they are imported as well, or by
+/// otherwise ensuring that you have the same imports on the target pallet.
+///
+/// It is perfectly permissible to import multiple pallet sections into the same pallet,
+/// which can be done by having multiple `#[import_section(something)]` attributes
+/// attached to the pallet.
+///
+/// Note that sections are imported by their module name/ident, and should be referred to by
+/// their _full path_ from the perspective of the target pallet.
+#[import_tokens_attr {
+    format!(
+        "{}::macro_magic",
+        match generate_crate_access_2018("frame-support") {
+            Ok(path) => Ok(path),
+            Err(_) => generate_crate_access_2018("frame"),
+        }
+        .expect("Failed to find either `frame-support` or `frame` in `Cargo.toml` dependencies.")
+        .to_token_stream()
+        .to_string()
+    )
+}]
+#[proc_macro_attribute]
+pub fn import_section(attr: TokenStream, tokens: TokenStream) -> TokenStream {
+	let foreign_mod = parse_macro_input!(attr as ItemMod);
+	let mut internal_mod = parse_macro_input!(tokens as ItemMod);
+
+	// check that internal_mod is a pallet module
+	if !internal_mod.attrs.iter().any(|attr| {
+		if let Some(last_seg) = attr.path().segments.last() {
+			last_seg.ident == "pallet"
+		} else {
+			false
+		}
+	}) {
+		return Error::new(
+			internal_mod.ident.span(),
+			"`#[import_section]` can only be applied to a valid pallet module",
+		)
+		.to_compile_error()
+		.into()
+	}
+
+	if let Some(ref mut content) = internal_mod.content {
+		if let Some(foreign_content) = foreign_mod.content {
+			content.1.extend(foreign_content.1);
+		}
+	}
+
+	quote! {
+		#internal_mod
+	}
+	.into()
+}
diff --git a/substrate/frame/support/procedural/src/match_and_insert.rs b/substrate/frame/support/procedural/src/match_and_insert.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa9cc56d769d01ce18620c10654dbadaf5f200cc
--- /dev/null
+++ b/substrate/frame/support/procedural/src/match_and_insert.rs
@@ -0,0 +1,159 @@
+// 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.
+
+//! Implementation of the `match_and_insert` macro.
+
+use proc_macro2::{Group, Span, TokenStream, TokenTree};
+use std::iter::once;
+use syn::spanned::Spanned;
+
+mod keyword {
+	syn::custom_keyword!(target);
+	syn::custom_keyword!(pattern);
+	syn::custom_keyword!(tokens);
+}
+
+pub fn match_and_insert(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let MatchAndInsertDef { pattern, tokens, target } =
+		syn::parse_macro_input!(input as MatchAndInsertDef);
+
+	match expand_in_stream(&pattern, &mut Some(tokens), target) {
+		Ok(stream) => stream.into(),
+		Err(err) => err.to_compile_error().into(),
+	}
+}
+
+struct MatchAndInsertDef {
+	// Token stream to search and insert tokens into.
+	target: TokenStream,
+	// Pattern to match against, this is ensured to have no TokenTree::Group nor TokenTree::Literal
+	// (i.e. contains only Punct or Ident), and not being empty.
+	pattern: Vec<TokenTree>,
+	// Token stream to insert after the match pattern.
+	tokens: TokenStream,
+}
+
+impl syn::parse::Parse for MatchAndInsertDef {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		let mut target;
+		let _ = input.parse::<keyword::target>()?;
+		let _ = input.parse::<syn::Token![=]>()?;
+		let _replace_with_bracket: syn::token::Bracket = syn::bracketed!(target in input);
+		let _replace_with_brace: syn::token::Brace = syn::braced!(target in target);
+		let target = target.parse()?;
+
+		let mut pattern;
+		let _ = input.parse::<keyword::pattern>()?;
+		let _ = input.parse::<syn::Token![=]>()?;
+		let _replace_with_bracket: syn::token::Bracket = syn::bracketed!(pattern in input);
+		let _replace_with_brace: syn::token::Brace = syn::braced!(pattern in pattern);
+		let pattern = pattern.parse::<TokenStream>()?.into_iter().collect::<Vec<TokenTree>>();
+
+		if let Some(t) = pattern.iter().find(|t| matches!(t, TokenTree::Group(_))) {
+			return Err(syn::Error::new(t.span(), "Unexpected group token tree"))
+		}
+		if let Some(t) = pattern.iter().find(|t| matches!(t, TokenTree::Literal(_))) {
+			return Err(syn::Error::new(t.span(), "Unexpected literal token tree"))
+		}
+
+		if pattern.is_empty() {
+			return Err(syn::Error::new(Span::call_site(), "empty match pattern is invalid"))
+		}
+
+		let mut tokens;
+		let _ = input.parse::<keyword::tokens>()?;
+		let _ = input.parse::<syn::Token![=]>()?;
+		let _replace_with_bracket: syn::token::Bracket = syn::bracketed!(tokens in input);
+		let _replace_with_brace: syn::token::Brace = syn::braced!(tokens in tokens);
+		let tokens = tokens.parse()?;
+
+		Ok(Self { tokens, pattern, target })
+	}
+}
+
+// Insert `tokens` after the first matching `pattern`.
+// `tokens` must be some (Option is used for internal simplification).
+// `pattern` must not be empty and should only contain Ident or Punct.
+fn expand_in_stream(
+	pattern: &[TokenTree],
+	tokens: &mut Option<TokenStream>,
+	stream: TokenStream,
+) -> syn::Result<TokenStream> {
+	assert!(
+		tokens.is_some(),
+		"`tokens` must be some, Option is used because `tokens` is used only once"
+	);
+	assert!(
+		!pattern.is_empty(),
+		"`pattern` must not be empty, otherwise there is nothing to match against"
+	);
+
+	let stream_span = stream.span();
+	let mut stream = stream.into_iter();
+	let mut extended = TokenStream::new();
+	let mut match_cursor = 0;
+
+	while let Some(token) = stream.next() {
+		match token {
+			TokenTree::Group(group) => {
+				match_cursor = 0;
+				let group_stream = group.stream();
+				match expand_in_stream(pattern, tokens, group_stream) {
+					Ok(s) => {
+						extended.extend(once(TokenTree::Group(Group::new(group.delimiter(), s))));
+						extended.extend(stream);
+						return Ok(extended)
+					},
+					Err(_) => {
+						extended.extend(once(TokenTree::Group(group)));
+					},
+				}
+			},
+			other => {
+				advance_match_cursor(&other, pattern, &mut match_cursor);
+
+				extended.extend(once(other));
+
+				if match_cursor == pattern.len() {
+					extended
+						.extend(once(tokens.take().expect("tokens is used to replace only once")));
+					extended.extend(stream);
+					return Ok(extended)
+				}
+			},
+		}
+	}
+	// if we reach this point, it means the stream is empty and we haven't found a matching pattern
+	let msg = format!("Cannot find pattern `{:?}` in given token stream", pattern);
+	Err(syn::Error::new(stream_span, msg))
+}
+
+fn advance_match_cursor(other: &TokenTree, pattern: &[TokenTree], match_cursor: &mut usize) {
+	use TokenTree::{Ident, Punct};
+
+	let does_match_other_pattern = match (other, &pattern[*match_cursor]) {
+		(Ident(i1), Ident(i2)) => i1 == i2,
+		(Punct(p1), Punct(p2)) => p1.as_char() == p2.as_char(),
+		_ => false,
+	};
+
+	if does_match_other_pattern {
+		*match_cursor += 1;
+	} else {
+		*match_cursor = 0;
+	}
+}
diff --git a/substrate/frame/support/procedural/src/no_bound/clone.rs b/substrate/frame/support/procedural/src/no_bound/clone.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bbea2feffa96fc52763c97cd812abc66a4c0c495
--- /dev/null
+++ b/substrate/frame/support/procedural/src/no_bound/clone.rs
@@ -0,0 +1,109 @@
+// 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 syn::spanned::Spanned;
+
+/// Derive Clone but do not bound any generic.
+pub fn derive_clone_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let name = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	let impl_ = match input.data {
+		syn::Data::Struct(struct_) => match struct_.fields {
+			syn::Fields::Named(named) => {
+				let fields = named.named.iter().map(|i| &i.ident).map(|i| {
+					quote::quote_spanned!(i.span() =>
+						#i: core::clone::Clone::clone(&self.#i)
+					)
+				});
+
+				quote::quote!( Self { #( #fields, )* } )
+			},
+			syn::Fields::Unnamed(unnamed) => {
+				let fields =
+					unnamed.unnamed.iter().enumerate().map(|(i, _)| syn::Index::from(i)).map(|i| {
+						quote::quote_spanned!(i.span() =>
+							core::clone::Clone::clone(&self.#i)
+						)
+					});
+
+				quote::quote!( Self ( #( #fields, )* ) )
+			},
+			syn::Fields::Unit => {
+				quote::quote!(Self)
+			},
+		},
+		syn::Data::Enum(enum_) => {
+			let variants = enum_.variants.iter().map(|variant| {
+				let ident = &variant.ident;
+				match &variant.fields {
+					syn::Fields::Named(named) => {
+						let captured = named.named.iter().map(|i| &i.ident);
+						let cloned = captured.clone().map(|i| {
+							quote::quote_spanned!(i.span() =>
+								#i: core::clone::Clone::clone(#i)
+							)
+						});
+						quote::quote!(
+							Self::#ident { #( ref #captured, )* } => Self::#ident { #( #cloned, )*}
+						)
+					},
+					syn::Fields::Unnamed(unnamed) => {
+						let captured = unnamed
+							.unnamed
+							.iter()
+							.enumerate()
+							.map(|(i, f)| syn::Ident::new(&format!("_{}", i), f.span()));
+						let cloned = captured.clone().map(|i| {
+							quote::quote_spanned!(i.span() =>
+								core::clone::Clone::clone(#i)
+							)
+						});
+						quote::quote!(
+							Self::#ident ( #( ref #captured, )* ) => Self::#ident ( #( #cloned, )*)
+						)
+					},
+					syn::Fields::Unit => quote::quote!( Self::#ident => Self::#ident ),
+				}
+			});
+
+			quote::quote!(match self {
+				#( #variants, )*
+			})
+		},
+		syn::Data::Union(_) => {
+			let msg = "Union type not supported by `derive(CloneNoBound)`";
+			return syn::Error::new(input.span(), msg).to_compile_error().into()
+		},
+	};
+
+	quote::quote!(
+		const _: () = {
+			impl #impl_generics core::clone::Clone for #name #ty_generics #where_clause {
+				fn clone(&self) -> Self {
+					#impl_
+				}
+			}
+		};
+	)
+	.into()
+}
diff --git a/substrate/frame/support/procedural/src/no_bound/debug.rs b/substrate/frame/support/procedural/src/no_bound/debug.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ae182829a49eb14513acc3b7a6e3763af6a8db6b
--- /dev/null
+++ b/substrate/frame/support/procedural/src/no_bound/debug.rs
@@ -0,0 +1,123 @@
+// 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 syn::spanned::Spanned;
+
+/// Derive Debug but do not bound any generics.
+pub fn derive_debug_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let input_ident = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	let impl_ = match input.data {
+		syn::Data::Struct(struct_) => match struct_.fields {
+			syn::Fields::Named(named) => {
+				let fields =
+					named.named.iter().map(|i| &i.ident).map(
+						|i| quote::quote_spanned!(i.span() => .field(stringify!(#i), &self.#i) ),
+					);
+
+				quote::quote!(
+					fmt.debug_struct(stringify!(#input_ident))
+						#( #fields )*
+						.finish()
+				)
+			},
+			syn::Fields::Unnamed(unnamed) => {
+				let fields = unnamed
+					.unnamed
+					.iter()
+					.enumerate()
+					.map(|(i, _)| syn::Index::from(i))
+					.map(|i| quote::quote_spanned!(i.span() => .field(&self.#i) ));
+
+				quote::quote!(
+					fmt.debug_tuple(stringify!(#input_ident))
+						#( #fields )*
+						.finish()
+				)
+			},
+			syn::Fields::Unit => quote::quote!(fmt.write_str(stringify!(#input_ident))),
+		},
+		syn::Data::Enum(enum_) => {
+			let variants = enum_.variants.iter().map(|variant| {
+				let ident = &variant.ident;
+				let full_variant_str = format!("{}::{}", input_ident, ident);
+				match &variant.fields {
+					syn::Fields::Named(named) => {
+						let captured = named.named.iter().map(|i| &i.ident);
+						let debugged = captured.clone().map(|i| {
+							quote::quote_spanned!(i.span() =>
+								.field(stringify!(#i), &#i)
+							)
+						});
+						quote::quote!(
+							Self::#ident { #( ref #captured, )* } => {
+								fmt.debug_struct(#full_variant_str)
+									#( #debugged )*
+									.finish()
+							}
+						)
+					},
+					syn::Fields::Unnamed(unnamed) => {
+						let captured = unnamed
+							.unnamed
+							.iter()
+							.enumerate()
+							.map(|(i, f)| syn::Ident::new(&format!("_{}", i), f.span()));
+						let debugged = captured
+							.clone()
+							.map(|i| quote::quote_spanned!(i.span() => .field(&#i)));
+						quote::quote!(
+							Self::#ident ( #( ref #captured, )* ) => {
+								fmt.debug_tuple(#full_variant_str)
+									#( #debugged )*
+									.finish()
+							}
+						)
+					},
+					syn::Fields::Unit => quote::quote!(
+						Self::#ident => fmt.write_str(#full_variant_str)
+					),
+				}
+			});
+
+			quote::quote!(match *self {
+				#( #variants, )*
+			})
+		},
+		syn::Data::Union(_) => {
+			let msg = "Union type not supported by `derive(DebugNoBound)`";
+			return syn::Error::new(input.span(), msg).to_compile_error().into()
+		},
+	};
+
+	quote::quote!(
+		const _: () = {
+			impl #impl_generics core::fmt::Debug for #input_ident #ty_generics #where_clause {
+				fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+					#impl_
+				}
+			}
+		};
+	)
+	.into()
+}
diff --git a/substrate/frame/support/procedural/src/no_bound/default.rs b/substrate/frame/support/procedural/src/no_bound/default.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da05f19e0f817d3b1a3c8709bee87dd39f67277d
--- /dev/null
+++ b/substrate/frame/support/procedural/src/no_bound/default.rs
@@ -0,0 +1,163 @@
+// 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 proc_macro2::Span;
+use quote::{quote, quote_spanned};
+use syn::{spanned::Spanned, Data, DeriveInput, Fields};
+
+/// Derive Default but do not bound any generic.
+pub fn derive_default_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input = syn::parse_macro_input!(input as DeriveInput);
+
+	let name = &input.ident;
+
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	let impl_ = match input.data {
+		Data::Struct(struct_) => match struct_.fields {
+			Fields::Named(named) => {
+				let fields = named.named.iter().map(|field| &field.ident).map(|ident| {
+					quote_spanned! {ident.span() =>
+						#ident: core::default::Default::default()
+					}
+				});
+
+				quote!(Self { #( #fields, )* })
+			},
+			Fields::Unnamed(unnamed) => {
+				let fields = unnamed.unnamed.iter().map(|field| {
+					quote_spanned! {field.span()=>
+						core::default::Default::default()
+					}
+				});
+
+				quote!(Self( #( #fields, )* ))
+			},
+			Fields::Unit => {
+				quote!(Self)
+			},
+		},
+		Data::Enum(enum_) => {
+			if enum_.variants.is_empty() {
+				return syn::Error::new_spanned(name, "cannot derive Default for an empty enum")
+					.to_compile_error()
+					.into()
+			}
+
+			// all #[default] attrs with the variant they're on; i.e. a var
+			let default_variants = enum_
+				.variants
+				.into_iter()
+				.filter(|variant| variant.attrs.iter().any(|attr| attr.path().is_ident("default")))
+				.collect::<Vec<_>>();
+
+			match &*default_variants {
+				[] => {
+					return syn::Error::new(
+						name.clone().span(),
+						// writing this as a regular string breaks rustfmt for some reason
+						r#"no default declared, make a variant default by placing `#[default]` above it"#,
+					)
+					.into_compile_error()
+					.into()
+				},
+				// only one variant with the #[default] attribute set
+				[default_variant] => {
+					let variant_attrs = default_variant
+						.attrs
+						.iter()
+						.filter(|a| a.path().is_ident("default"))
+						.collect::<Vec<_>>();
+
+					// check that there is only one #[default] attribute on the variant
+					if let [first_attr, second_attr, additional_attrs @ ..] = &*variant_attrs {
+						let mut err =
+							syn::Error::new(Span::call_site(), "multiple `#[default]` attributes");
+
+						err.combine(syn::Error::new_spanned(first_attr, "`#[default]` used here"));
+
+						err.extend([second_attr].into_iter().chain(additional_attrs).map(
+							|variant| {
+								syn::Error::new_spanned(variant, "`#[default]` used again here")
+							},
+						));
+
+						return err.into_compile_error().into()
+					}
+
+					let variant_ident = &default_variant.ident;
+
+					let fully_qualified_variant_path = quote!(Self::#variant_ident);
+
+					match &default_variant.fields {
+						Fields::Named(named) => {
+							let fields =
+								named.named.iter().map(|field| &field.ident).map(|ident| {
+									quote_spanned! {ident.span()=>
+										#ident: core::default::Default::default()
+									}
+								});
+
+							quote!(#fully_qualified_variant_path { #( #fields, )* })
+						},
+						Fields::Unnamed(unnamed) => {
+							let fields = unnamed.unnamed.iter().map(|field| {
+								quote_spanned! {field.span()=>
+									core::default::Default::default()
+								}
+							});
+
+							quote!(#fully_qualified_variant_path( #( #fields, )* ))
+						},
+						Fields::Unit => fully_qualified_variant_path,
+					}
+				},
+				[first, additional @ ..] => {
+					let mut err = syn::Error::new(Span::call_site(), "multiple declared defaults");
+
+					err.combine(syn::Error::new_spanned(first, "first default"));
+
+					err.extend(
+						additional
+							.into_iter()
+							.map(|variant| syn::Error::new_spanned(variant, "additional default")),
+					);
+
+					return err.into_compile_error().into()
+				},
+			}
+		},
+		Data::Union(union_) =>
+			return syn::Error::new_spanned(
+				union_.union_token,
+				"Union type not supported by `derive(DefaultNoBound)`",
+			)
+			.to_compile_error()
+			.into(),
+	};
+
+	quote!(
+		const _: () = {
+			impl #impl_generics core::default::Default for #name #ty_generics #where_clause {
+				fn default() -> Self {
+					#impl_
+				}
+			}
+		};
+	)
+	.into()
+}
diff --git a/substrate/frame/support/procedural/src/no_bound/mod.rs b/substrate/frame/support/procedural/src/no_bound/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f76b01726150e97f784ecd93dec3b8ba79ba3fd
--- /dev/null
+++ b/substrate/frame/support/procedural/src/no_bound/mod.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.
+
+//! Derive macros to derive traits without bounding generic parameters.
+
+pub mod clone;
+pub mod debug;
+pub mod default;
+pub mod partial_eq;
diff --git a/substrate/frame/support/procedural/src/no_bound/partial_eq.rs b/substrate/frame/support/procedural/src/no_bound/partial_eq.rs
new file mode 100644
index 0000000000000000000000000000000000000000..27f5e98810ec3aa209f9a4030cfd4f2527ba724a
--- /dev/null
+++ b/substrate/frame/support/procedural/src/no_bound/partial_eq.rs
@@ -0,0 +1,139 @@
+// 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 syn::spanned::Spanned;
+
+/// Derive PartialEq but do not bound any generic.
+pub fn derive_partial_eq_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input: syn::DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let name = &input.ident;
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+	let impl_ = match input.data {
+		syn::Data::Struct(struct_) => match struct_.fields {
+			syn::Fields::Named(named) => {
+				let fields = named
+					.named
+					.iter()
+					.map(|i| &i.ident)
+					.map(|i| quote::quote_spanned!(i.span() => self.#i == other.#i ));
+
+				quote::quote!( true #( && #fields )* )
+			},
+			syn::Fields::Unnamed(unnamed) => {
+				let fields = unnamed
+					.unnamed
+					.iter()
+					.enumerate()
+					.map(|(i, _)| syn::Index::from(i))
+					.map(|i| quote::quote_spanned!(i.span() => self.#i == other.#i ));
+
+				quote::quote!( true #( && #fields )* )
+			},
+			syn::Fields::Unit => {
+				quote::quote!(true)
+			},
+		},
+		syn::Data::Enum(enum_) => {
+			let variants =
+				enum_.variants.iter().map(|variant| {
+					let ident = &variant.ident;
+					match &variant.fields {
+						syn::Fields::Named(named) => {
+							let names = named.named.iter().map(|i| &i.ident);
+							let other_names = names.clone().enumerate().map(|(n, ident)| {
+								syn::Ident::new(&format!("_{}", n), ident.span())
+							});
+
+							let capture = names.clone();
+							let other_capture = names
+								.clone()
+								.zip(other_names.clone())
+								.map(|(i, other_i)| quote::quote!(#i: #other_i));
+							let eq = names.zip(other_names).map(
+								|(i, other_i)| quote::quote_spanned!(i.span() => #i == #other_i),
+							);
+							quote::quote!(
+								(
+									Self::#ident { #( #capture, )* },
+									Self::#ident { #( #other_capture, )* },
+								) => true #( && #eq )*
+							)
+						},
+						syn::Fields::Unnamed(unnamed) => {
+							let names = unnamed
+								.unnamed
+								.iter()
+								.enumerate()
+								.map(|(i, f)| syn::Ident::new(&format!("_{}", i), f.span()));
+							let other_names =
+								unnamed.unnamed.iter().enumerate().map(|(i, f)| {
+									syn::Ident::new(&format!("_{}_other", i), f.span())
+								});
+							let eq = names.clone().zip(other_names.clone()).map(
+								|(i, other_i)| quote::quote_spanned!(i.span() => #i == #other_i),
+							);
+							quote::quote!(
+								(
+									Self::#ident ( #( #names, )* ),
+									Self::#ident ( #( #other_names, )* ),
+								) => true #( && #eq )*
+							)
+						},
+						syn::Fields::Unit => quote::quote!( (Self::#ident, Self::#ident) => true ),
+					}
+				});
+
+			let mut different_variants = vec![];
+			for (i, i_variant) in enum_.variants.iter().enumerate() {
+				for (j, j_variant) in enum_.variants.iter().enumerate() {
+					if i != j {
+						let i_ident = &i_variant.ident;
+						let j_ident = &j_variant.ident;
+						different_variants.push(quote::quote!(
+							(Self::#i_ident { .. }, Self::#j_ident { .. }) => false
+						))
+					}
+				}
+			}
+
+			quote::quote!( match (self, other) {
+				#( #variants, )*
+				#( #different_variants, )*
+			})
+		},
+		syn::Data::Union(_) => {
+			let msg = "Union type not supported by `derive(PartialEqNoBound)`";
+			return syn::Error::new(input.span(), msg).to_compile_error().into()
+		},
+	};
+
+	quote::quote!(
+		const _: () = {
+			impl #impl_generics core::cmp::PartialEq for #name #ty_generics #where_clause {
+				fn eq(&self, other: &Self) -> bool {
+					#impl_
+				}
+			}
+		};
+	)
+	.into()
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/call.rs b/substrate/frame/support/procedural/src/pallet/expand/call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6489949ed5c33499038cbbe9c78138e2c109408f
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/call.rs
@@ -0,0 +1,427 @@
+// 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::{
+	pallet::{
+		parse::call::{CallVariantDef, CallWeightDef},
+		Def,
+	},
+	COUNTER,
+};
+use proc_macro2::TokenStream as TokenStream2;
+use quote::{quote, ToTokens};
+use syn::spanned::Spanned;
+
+///
+/// * Generate enum call and implement various trait on it.
+/// * Implement Callable and call_function on `Pallet`
+pub fn expand_call(def: &mut Def) -> proc_macro2::TokenStream {
+	let (span, where_clause, methods, docs) = match def.call.as_ref() {
+		Some(call) => {
+			let span = call.attr_span;
+			let where_clause = call.where_clause.clone();
+			let methods = call.methods.clone();
+			let docs = call.docs.clone();
+
+			(span, where_clause, methods, docs)
+		},
+		None => (def.item.span(), def.config.where_clause.clone(), Vec::new(), Vec::new()),
+	};
+	let frame_support = &def.frame_support;
+	let frame_system = &def.frame_system;
+	let type_impl_gen = &def.type_impl_generics(span);
+	let type_decl_bounded_gen = &def.type_decl_bounded_generics(span);
+	let type_use_gen = &def.type_use_generics(span);
+	let call_ident = syn::Ident::new("Call", span);
+	let pallet_ident = &def.pallet_struct.pallet;
+
+	let fn_name = methods.iter().map(|method| &method.name).collect::<Vec<_>>();
+	let call_index = methods.iter().map(|method| method.call_index).collect::<Vec<_>>();
+	let new_call_variant_fn_name = fn_name
+		.iter()
+		.map(|fn_name| quote::format_ident!("new_call_variant_{}", fn_name))
+		.collect::<Vec<_>>();
+
+	let new_call_variant_doc = fn_name
+		.iter()
+		.map(|fn_name| format!("Create a call with the variant `{}`.", fn_name))
+		.collect::<Vec<_>>();
+
+	let mut call_index_warnings = Vec::new();
+	// Emit a warning for each call that is missing `call_index` when not in dev-mode.
+	for method in &methods {
+		if method.explicit_call_index || def.dev_mode {
+			continue
+		}
+
+		let warning = proc_macro_warning::Warning::new_deprecated("ImplicitCallIndex")
+			.index(call_index_warnings.len())
+			.old("use implicit call indices")
+			.new("ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode")
+			.help_links(&[
+				"https://github.com/paritytech/substrate/pull/12891",
+				"https://github.com/paritytech/substrate/pull/11381"
+			])
+			.span(method.name.span())
+			.build();
+		call_index_warnings.push(warning);
+	}
+
+	let mut fn_weight = Vec::<TokenStream2>::new();
+	let mut weight_warnings = Vec::new();
+	for method in &methods {
+		match &method.weight {
+			CallWeightDef::DevModeDefault => fn_weight.push(syn::parse_quote!(0)),
+			CallWeightDef::Immediate(e @ syn::Expr::Lit(lit)) if !def.dev_mode => {
+				let warning = proc_macro_warning::Warning::new_deprecated("ConstantWeight")
+					.index(weight_warnings.len())
+					.old("use hard-coded constant as call weight")
+					.new("benchmark all calls or put the pallet into `dev` mode")
+					.help_link("https://github.com/paritytech/substrate/pull/13798")
+					.span(lit.span())
+					.build();
+				weight_warnings.push(warning);
+				fn_weight.push(e.into_token_stream());
+			},
+			CallWeightDef::Immediate(e) => fn_weight.push(e.into_token_stream()),
+			CallWeightDef::Inherited => {
+				let pallet_weight = def
+					.call
+					.as_ref()
+					.expect("we have methods; we have calls; qed")
+					.inherited_call_weight
+					.as_ref()
+					.expect("the parser prevents this");
+
+				// Expand `<<T as Config>::WeightInfo>::call_name()`.
+				let t = &pallet_weight.typename;
+				let n = &method.name;
+				fn_weight.push(quote!({ < #t > :: #n ()	}));
+			},
+		}
+	}
+	debug_assert_eq!(fn_weight.len(), methods.len());
+
+	let map_fn_docs = if !def.dev_mode {
+		// Emit the [`Pallet::method`] documentation only for non-dev modes.
+		|method: &CallVariantDef| {
+			let reference = format!("See [`Pallet::{}`].", method.name);
+			quote!(#reference)
+		}
+	} else {
+		// For the dev-mode do not provide a documenation link as it will break the
+		// `cargo doc` if the pallet is private inside a test.
+		|method: &CallVariantDef| {
+			let reference = format!("See `Pallet::{}`.", method.name);
+			quote!(#reference)
+		}
+	};
+
+	let fn_doc = methods.iter().map(map_fn_docs).collect::<Vec<_>>();
+
+	let args_name = methods
+		.iter()
+		.map(|method| method.args.iter().map(|(_, name, _)| name.clone()).collect::<Vec<_>>())
+		.collect::<Vec<_>>();
+
+	let args_name_stripped = methods
+		.iter()
+		.map(|method| {
+			method
+				.args
+				.iter()
+				.map(|(_, name, _)| {
+					syn::Ident::new(name.to_string().trim_start_matches('_'), name.span())
+				})
+				.collect::<Vec<_>>()
+		})
+		.collect::<Vec<_>>();
+
+	let make_args_name_pattern = |ref_tok| {
+		args_name
+			.iter()
+			.zip(args_name_stripped.iter())
+			.map(|(args_name, args_name_stripped)| {
+				args_name
+					.iter()
+					.zip(args_name_stripped)
+					.map(|(args_name, args_name_stripped)| {
+						if args_name == args_name_stripped {
+							quote::quote!( #ref_tok #args_name )
+						} else {
+							quote::quote!( #args_name_stripped: #ref_tok #args_name )
+						}
+					})
+					.collect::<Vec<_>>()
+			})
+			.collect::<Vec<_>>()
+	};
+
+	let args_name_pattern = make_args_name_pattern(None);
+	let args_name_pattern_ref = make_args_name_pattern(Some(quote::quote!(ref)));
+
+	let args_type = methods
+		.iter()
+		.map(|method| method.args.iter().map(|(_, _, type_)| type_.clone()).collect::<Vec<_>>())
+		.collect::<Vec<_>>();
+
+	let args_compact_attr = methods.iter().map(|method| {
+		method
+			.args
+			.iter()
+			.map(|(is_compact, _, type_)| {
+				if *is_compact {
+					quote::quote_spanned!(type_.span() => #[codec(compact)] )
+				} else {
+					quote::quote!()
+				}
+			})
+			.collect::<Vec<_>>()
+	});
+
+	let default_docs =
+		[syn::parse_quote!(r"Contains a variant per dispatchable extrinsic that this pallet has.")];
+	let docs = if docs.is_empty() { &default_docs[..] } else { &docs[..] };
+
+	let maybe_compile_error = if def.call.is_none() {
+		quote::quote! {
+			compile_error!(concat!(
+				"`",
+				stringify!($pallet_name),
+				"` does not have #[pallet::call] defined, perhaps you should remove `Call` from \
+				construct_runtime?",
+			));
+		}
+	} else {
+		proc_macro2::TokenStream::new()
+	};
+
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+	let macro_ident = syn::Ident::new(&format!("__is_call_part_defined_{}", count), span);
+
+	let capture_docs = if cfg!(feature = "no-metadata-docs") { "never" } else { "always" };
+
+	// Wrap all calls inside of storage layers
+	if let Some(syn::Item::Impl(item_impl)) = def
+		.call
+		.as_ref()
+		.map(|c| &mut def.item.content.as_mut().expect("Checked by def parser").1[c.index])
+	{
+		item_impl.items.iter_mut().for_each(|i| {
+			if let syn::ImplItem::Fn(method) = i {
+				let block = &method.block;
+				method.block = syn::parse_quote! {{
+					// We execute all dispatchable in a new storage layer, allowing them
+					// to return an error at any point, and undoing any storage changes.
+					#frame_support::storage::with_storage_layer(|| #block)
+				}};
+			}
+		});
+	}
+
+	// Extracts #[allow] attributes, necessary so that we don't run into compiler warnings
+	let maybe_allow_attrs = methods
+		.iter()
+		.map(|method| {
+			method
+				.attrs
+				.iter()
+				.find(|attr| attr.path().is_ident("allow"))
+				.map_or(proc_macro2::TokenStream::new(), |attr| attr.to_token_stream())
+		})
+		.collect::<Vec<_>>();
+
+	quote::quote_spanned!(span =>
+		mod warnings {
+			#(
+				#call_index_warnings
+			)*
+			#(
+				#weight_warnings
+			)*
+		}
+
+		#[doc(hidden)]
+		pub mod __substrate_call_check {
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #macro_ident {
+				($pallet_name:ident) => {
+					#maybe_compile_error
+				};
+			}
+
+			#[doc(hidden)]
+			pub use #macro_ident as is_call_part_defined;
+		}
+
+		#( #[doc = #docs] )*
+		#[derive(
+			#frame_support::RuntimeDebugNoBound,
+			#frame_support::CloneNoBound,
+			#frame_support::EqNoBound,
+			#frame_support::PartialEqNoBound,
+			#frame_support::__private::codec::Encode,
+			#frame_support::__private::codec::Decode,
+			#frame_support::__private::scale_info::TypeInfo,
+		)]
+		#[codec(encode_bound())]
+		#[codec(decode_bound())]
+		#[scale_info(skip_type_params(#type_use_gen), capture_docs = #capture_docs)]
+		#[allow(non_camel_case_types)]
+		pub enum #call_ident<#type_decl_bounded_gen> #where_clause {
+			#[doc(hidden)]
+			#[codec(skip)]
+			__Ignore(
+				#frame_support::__private::sp_std::marker::PhantomData<(#type_use_gen,)>,
+				#frame_support::Never,
+			),
+			#(
+				#[doc = #fn_doc]
+				#[codec(index = #call_index)]
+				#fn_name {
+					#(
+						#[allow(missing_docs)]
+						#args_compact_attr #args_name_stripped: #args_type
+					),*
+				},
+			)*
+		}
+
+		impl<#type_impl_gen> #call_ident<#type_use_gen> #where_clause {
+			#(
+				#[doc = #new_call_variant_doc]
+				pub fn #new_call_variant_fn_name(
+					#( #args_name_stripped: #args_type ),*
+				) -> Self {
+					Self::#fn_name {
+						#( #args_name_stripped ),*
+					}
+				}
+			)*
+		}
+
+		impl<#type_impl_gen> #frame_support::dispatch::GetDispatchInfo
+			for #call_ident<#type_use_gen>
+			#where_clause
+		{
+			fn get_dispatch_info(&self) -> #frame_support::dispatch::DispatchInfo {
+				match *self {
+					#(
+						Self::#fn_name { #( #args_name_pattern_ref, )* } => {
+							let __pallet_base_weight = #fn_weight;
+
+							let __pallet_weight = <
+								dyn #frame_support::dispatch::WeighData<( #( & #args_type, )* )>
+							>::weigh_data(&__pallet_base_weight, ( #( #args_name, )* ));
+
+							let __pallet_class = <
+								dyn #frame_support::dispatch::ClassifyDispatch<
+									( #( & #args_type, )* )
+								>
+							>::classify_dispatch(&__pallet_base_weight, ( #( #args_name, )* ));
+
+							let __pallet_pays_fee = <
+								dyn #frame_support::dispatch::PaysFee<( #( & #args_type, )* )>
+							>::pays_fee(&__pallet_base_weight, ( #( #args_name, )* ));
+
+							#frame_support::dispatch::DispatchInfo {
+								weight: __pallet_weight,
+								class: __pallet_class,
+								pays_fee: __pallet_pays_fee,
+							}
+						},
+					)*
+					Self::__Ignore(_, _) => unreachable!("__Ignore cannot be used"),
+				}
+			}
+		}
+
+		impl<#type_impl_gen> #frame_support::dispatch::GetCallName for #call_ident<#type_use_gen>
+			#where_clause
+		{
+			fn get_call_name(&self) -> &'static str {
+				match *self {
+					#( Self::#fn_name { .. } => stringify!(#fn_name), )*
+					Self::__Ignore(_, _) => unreachable!("__PhantomItem cannot be used."),
+				}
+			}
+
+			fn get_call_names() -> &'static [&'static str] {
+				&[ #( stringify!(#fn_name), )* ]
+			}
+		}
+
+		impl<#type_impl_gen> #frame_support::dispatch::GetCallIndex for #call_ident<#type_use_gen>
+			#where_clause
+		{
+			fn get_call_index(&self) -> u8 {
+				match *self {
+					#( Self::#fn_name { .. } => #call_index, )*
+					Self::__Ignore(_, _) => unreachable!("__PhantomItem cannot be used."),
+				}
+			}
+
+			fn get_call_indices() -> &'static [u8] {
+				&[ #( #call_index, )* ]
+			}
+		}
+
+		impl<#type_impl_gen> #frame_support::traits::UnfilteredDispatchable
+			for #call_ident<#type_use_gen>
+			#where_clause
+		{
+			type RuntimeOrigin = #frame_system::pallet_prelude::OriginFor<T>;
+			fn dispatch_bypass_filter(
+				self,
+				origin: Self::RuntimeOrigin
+			) -> #frame_support::dispatch::DispatchResultWithPostInfo {
+				#frame_support::dispatch_context::run_in_context(|| {
+					match self {
+						#(
+							Self::#fn_name { #( #args_name_pattern, )* } => {
+								#frame_support::__private::sp_tracing::enter_span!(
+									#frame_support::__private::sp_tracing::trace_span!(stringify!(#fn_name))
+								);
+								#maybe_allow_attrs
+								<#pallet_ident<#type_use_gen>>::#fn_name(origin, #( #args_name, )* )
+									.map(Into::into).map_err(Into::into)
+							},
+						)*
+						Self::__Ignore(_, _) => {
+							let _ = origin; // Use origin for empty Call enum
+							unreachable!("__PhantomItem cannot be used.");
+						},
+					}
+				})
+			}
+		}
+
+		impl<#type_impl_gen> #frame_support::dispatch::Callable<T> for #pallet_ident<#type_use_gen>
+			#where_clause
+		{
+			type RuntimeCall = #call_ident<#type_use_gen>;
+		}
+
+		impl<#type_impl_gen> #pallet_ident<#type_use_gen> #where_clause {
+			#[doc(hidden)]
+			pub fn call_functions() -> #frame_support::__private::metadata_ir::PalletCallMetadataIR {
+				#frame_support::__private::scale_info::meta_type::<#call_ident<#type_use_gen>>().into()
+			}
+		}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/config.rs b/substrate/frame/support/procedural/src/pallet/expand/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5cf4035a8f8b9ddb0f31c3e3b1b8ce36215543ff
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/config.rs
@@ -0,0 +1,97 @@
+// 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::pallet::Def;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse_quote, Item};
+
+///
+/// * Generate default rust doc
+pub fn expand_config(def: &mut Def) -> TokenStream {
+	let config = &def.config;
+	let config_item = {
+		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[config.index];
+		if let Item::Trait(item) = item {
+			item
+		} else {
+			unreachable!("Checked by config parser")
+		}
+	};
+
+	config_item.attrs.insert(
+		0,
+		parse_quote!(
+			#[doc = r"
+Configuration trait of this pallet.
+
+The main purpose of this trait is to act as an interface between this pallet and the runtime in
+which it is embedded in. A type, function, or constant in this trait is essentially left to be
+configured by the runtime that includes this pallet.
+
+Consequently, a runtime that wants to include this pallet must implement this trait."
+			]
+		),
+	);
+
+	// we only emit `DefaultConfig` if there are trait items, so an empty `DefaultConfig` is
+	// impossible consequently.
+	match &config.default_sub_trait {
+		Some(default_sub_trait) if default_sub_trait.items.len() > 0 => {
+			let trait_items = &default_sub_trait
+				.items
+				.iter()
+				.map(|item| {
+					if item.1 {
+						if let syn::TraitItem::Type(item) = item.0.clone() {
+							let mut item = item.clone();
+							item.bounds.clear();
+							syn::TraitItem::Type(item)
+						} else {
+							item.0.clone()
+						}
+					} else {
+						item.0.clone()
+					}
+				})
+				.collect::<Vec<_>>();
+
+			let type_param_bounds = if default_sub_trait.has_system {
+				let system = &def.frame_system;
+				quote::quote!(: #system::DefaultConfig)
+			} else {
+				quote::quote!()
+			};
+
+			quote!(
+				/// Based on [`Config`]. Auto-generated by
+				/// [`#[pallet::config(with_default)]`](`frame_support::pallet_macros::config`).
+				/// Can be used in tandem with
+				/// [`#[register_default_config]`](`frame_support::register_default_config`) and
+				/// [`#[derive_impl]`](`frame_support::derive_impl`) to derive test config traits
+				/// based on existing pallet config traits in a safe and developer-friendly way.
+				///
+				/// See [here](`frame_support::pallet_macros::config`) for more information and caveats about
+				/// the auto-generated `DefaultConfig` trait and how it is generated.
+				pub trait DefaultConfig #type_param_bounds {
+					#(#trait_items)*
+				}
+			)
+		},
+		_ => Default::default(),
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/constants.rs b/substrate/frame/support/procedural/src/pallet/expand/constants.rs
new file mode 100644
index 0000000000000000000000000000000000000000..57fa8b7f3cd9af0e24feffaac17367b7cc817054
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/constants.rs
@@ -0,0 +1,108 @@
+// 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::pallet::Def;
+
+struct ConstDef {
+	/// Name of the associated type.
+	pub ident: syn::Ident,
+	/// The type in Get, e.g. `u32` in `type Foo: Get<u32>;`, but `Self` is replaced by `T`
+	pub type_: syn::Type,
+	/// The doc associated
+	pub doc: Vec<syn::Expr>,
+	/// default_byte implementation
+	pub default_byte_impl: proc_macro2::TokenStream,
+	/// Constant name for Metadata (optional)
+	pub metadata_name: Option<syn::Ident>,
+}
+
+///
+/// * Impl fn module_constant_metadata for 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());
+	let type_use_gen = &def.type_use_generics(proc_macro2::Span::call_site());
+	let pallet_ident = &def.pallet_struct.pallet;
+	let trait_use_gen = &def.trait_use_generics(proc_macro2::Span::call_site());
+
+	let mut where_clauses = vec![&def.config.where_clause];
+	where_clauses.extend(def.extra_constants.iter().map(|d| &d.where_clause));
+	let completed_where_clause = super::merge_where_clauses(&where_clauses);
+
+	let config_consts = def.config.consts_metadata.iter().map(|const_| {
+		let ident = &const_.ident;
+		let const_type = &const_.type_;
+
+		ConstDef {
+			ident: const_.ident.clone(),
+			type_: const_.type_.clone(),
+			doc: const_.doc.clone(),
+			default_byte_impl: quote::quote!(
+				let value = <<T as Config #trait_use_gen>::#ident as
+					#frame_support::traits::Get<#const_type>>::get();
+				#frame_support::__private::codec::Encode::encode(&value)
+			),
+			metadata_name: None,
+		}
+	});
+
+	let extra_consts = def.extra_constants.iter().flat_map(|d| &d.extra_constants).map(|const_| {
+		let ident = &const_.ident;
+
+		ConstDef {
+			ident: const_.ident.clone(),
+			type_: const_.type_.clone(),
+			doc: const_.doc.clone(),
+			default_byte_impl: quote::quote!(
+				let value = <Pallet<#type_use_gen>>::#ident();
+				#frame_support::__private::codec::Encode::encode(&value)
+			),
+			metadata_name: const_.metadata_name.clone(),
+		}
+	});
+
+	let consts = config_consts.chain(extra_consts).map(|const_| {
+		let const_type = &const_.type_;
+		let ident_str = format!("{}", const_.metadata_name.unwrap_or(const_.ident));
+
+		let no_docs = vec![];
+		let doc = if cfg!(feature = "no-metadata-docs") { &no_docs } else { &const_.doc };
+
+		let default_byte_impl = &const_.default_byte_impl;
+
+		quote::quote!({
+			#frame_support::__private::metadata_ir::PalletConstantMetadataIR {
+				name: #ident_str,
+				ty: #frame_support::__private::scale_info::meta_type::<#const_type>(),
+				value: { #default_byte_impl },
+				docs: #frame_support::__private::sp_std::vec![ #( #doc ),* ],
+			}
+		})
+	});
+
+	quote::quote!(
+		impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause{
+
+			#[doc(hidden)]
+			pub fn pallet_constants_metadata()
+				-> #frame_support::__private::sp_std::vec::Vec<#frame_support::__private::metadata_ir::PalletConstantMetadataIR>
+			{
+				#frame_support::__private::sp_std::vec![ #( #consts ),* ]
+			}
+		}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/doc_only.rs b/substrate/frame/support/procedural/src/pallet/expand/doc_only.rs
new file mode 100644
index 0000000000000000000000000000000000000000..50afeb3ca88cfcb0d9ee6400b5fc2de606f01b0e
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/doc_only.rs
@@ -0,0 +1,103 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2023 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 proc_macro2::Span;
+
+use crate::pallet::Def;
+
+pub fn expand_doc_only(def: &mut Def) -> proc_macro2::TokenStream {
+	let dispatchables = if let Some(call_def) = &def.call {
+		let type_impl_generics = def.type_impl_generics(Span::call_site());
+		call_def
+			.methods
+			.iter()
+			.map(|method| {
+				let name = &method.name;
+				let args = &method
+					.args
+					.iter()
+					.map(|(_, arg_name, arg_type)| quote::quote!( #arg_name: #arg_type, ))
+					.collect::<proc_macro2::TokenStream>();
+				let docs = &method.docs;
+
+				let real = format!(" [`Pallet::{}`].", name);
+				quote::quote!(
+					#( #[doc = #docs] )*
+					///
+					/// # Warning: Doc-Only
+					///
+					/// This function is an automatically generated, and is doc-only, uncallable
+					/// stub. See the real version in
+					#[ doc = #real ]
+					pub fn #name<#type_impl_generics>(#args) { unreachable!(); }
+				)
+			})
+			.collect::<proc_macro2::TokenStream>()
+	} else {
+		quote::quote!()
+	};
+
+	let storage_types = def
+		.storages
+		.iter()
+		.map(|storage| {
+			let storage_name = &storage.ident;
+			let storage_type_docs = &storage.docs;
+			let real = format!("[`pallet::{}`].", storage_name);
+			quote::quote!(
+				#( #[doc = #storage_type_docs] )*
+				///
+				/// # Warning: Doc-Only
+				///
+				/// This type is automatically generated, and is doc-only. See the real version in
+				#[ doc = #real ]
+				pub struct #storage_name();
+			)
+		})
+		.collect::<proc_macro2::TokenStream>();
+
+	quote::quote!(
+		/// Auto-generated docs-only module listing all (public and private) defined storage types
+		/// for this pallet.
+		///
+		/// # Warning: Doc-Only
+		///
+		/// Members of this module cannot be used directly and are only provided for documentation
+		/// purposes.
+		///
+		/// To see the actual storage type, find a struct with the same name at the root of the
+		/// pallet, in the list of [*Type Definitions*](../index.html#types).
+		#[cfg(doc)]
+		pub mod storage_types {
+			use super::*;
+			#storage_types
+		}
+
+		/// Auto-generated docs-only module listing all defined dispatchables for this pallet.
+		///
+		/// # Warning: Doc-Only
+		///
+		/// Members of this module cannot be used directly and are only provided for documentation
+		/// purposes. To see the real version of each dispatchable, look for them in [`Pallet`] or
+		/// [`Call`].
+		#[cfg(doc)]
+		pub mod dispatchables {
+			use super::*;
+			#dispatchables
+		}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/documentation.rs b/substrate/frame/support/procedural/src/pallet/expand/documentation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec19f889a9f20a57e5b0096f9873623baa06d59f
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/documentation.rs
@@ -0,0 +1,172 @@
+// 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::pallet::Def;
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::{spanned::Spanned, Attribute, Lit, LitStr};
+
+const DOC: &'static str = "doc";
+const PALLET_DOC: &'static str = "pallet_doc";
+
+/// Get the documentation file path from the `pallet_doc` attribute.
+///
+/// Supported format:
+/// `#[pallet_doc(PATH)]`: The path of the file from which the documentation is loaded
+fn parse_pallet_doc_value(attr: &Attribute) -> syn::Result<DocMetaValue> {
+	let lit: syn::LitStr = attr.parse_args().map_err(|_| {
+		let msg = "The `pallet_doc` received an unsupported argument. Supported format: `pallet_doc(\"PATH\")`";
+		syn::Error::new(attr.span(), msg)
+	})?;
+
+	Ok(DocMetaValue::Path(lit))
+}
+
+/// Get the value from the `doc` comment attribute:
+///
+/// Supported formats:
+/// - `#[doc = "A doc string"]`: Documentation as a string literal
+/// - `#[doc = include_str!(PATH)]`: Documentation obtained from a path
+fn parse_doc_value(attr: &Attribute) -> syn::Result<Option<DocMetaValue>> {
+	if !attr.path().is_ident(DOC) {
+		return Ok(None)
+	}
+
+	let meta = attr.meta.require_name_value()?;
+
+	match &meta.value {
+		syn::Expr::Lit(lit) => Ok(Some(DocMetaValue::Lit(lit.lit.clone()))),
+		syn::Expr::Macro(mac) if mac.mac.path.is_ident("include_str") =>
+			Ok(Some(DocMetaValue::Path(mac.mac.parse_body()?))),
+		_ =>
+			Err(syn::Error::new(attr.span(), "Expected `= \"docs\"` or `= include_str!(\"PATH\")`")),
+	}
+}
+
+/// Supported documentation tokens.
+#[derive(Debug)]
+enum DocMetaValue {
+	/// Documentation with string literals.
+	///
+	/// `#[doc = "Lit"]`
+	Lit(Lit),
+	/// Documentation with `include_str!` macro.
+	///
+	/// The string literal represents the file `PATH`.
+	///
+	/// `#[doc = include_str!(PATH)]`
+	Path(LitStr),
+}
+
+impl ToTokens for DocMetaValue {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		match self {
+			DocMetaValue::Lit(lit) => lit.to_tokens(tokens),
+			DocMetaValue::Path(path_lit) => {
+				let decl = quote::quote!(include_str!(#path_lit));
+				tokens.extend(decl)
+			},
+		}
+	}
+}
+
+/// Extract the documentation from the given pallet definition
+/// to include in the runtime metadata.
+///
+/// Implement a `pallet_documentation_metadata` function to fetch the
+/// documentation that is included in the metadata.
+///
+/// The documentation is placed on the pallet similar to:
+///
+/// ```ignore
+/// #[pallet]
+/// /// Documentation for pallet
+/// #[doc = "Documentation for pallet"]
+/// #[doc = include_str!("../README.md")]
+/// #[pallet_doc("../documentation1.md")]
+/// #[pallet_doc("../documentation2.md")]
+/// pub mod pallet {}
+/// ```
+///
+/// # pallet_doc
+///
+/// The `pallet_doc` attribute can only be provided with one argument,
+/// which is the file path that holds the documentation to be added to the metadata.
+///
+/// Unlike the `doc` attribute, the documentation provided to the `proc_macro` attribute is
+/// not added to the pallet.
+pub fn expand_documentation(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());
+	let type_use_gen = &def.type_use_generics(proc_macro2::Span::call_site());
+	let pallet_ident = &def.pallet_struct.pallet;
+	let where_clauses = &def.config.where_clause;
+
+	// TODO: Use [drain_filter](https://doc.rust-lang.org/std/vec/struct.Vec.html#method.drain_filter) when it is stable.
+
+	// The `pallet_doc` attributes are excluded from the generation of the pallet,
+	// but they are included in the runtime metadata.
+	let mut pallet_docs = Vec::with_capacity(def.item.attrs.len());
+	let mut index = 0;
+	while index < def.item.attrs.len() {
+		let attr = &def.item.attrs[index];
+		if attr.path().get_ident().map_or(false, |i| *i == PALLET_DOC) {
+			pallet_docs.push(def.item.attrs.remove(index));
+			// Do not increment the index, we have just removed the
+			// element from the attributes.
+			continue
+		}
+
+		index += 1;
+	}
+
+	// Capture the `#[doc = include_str!("../README.md")]` and `#[doc = "Documentation"]`.
+	let docs = match def
+		.item
+		.attrs
+		.iter()
+		.filter_map(|v| parse_doc_value(v).transpose())
+		.collect::<syn::Result<Vec<_>>>()
+	{
+		Ok(r) => r,
+		Err(err) => return err.into_compile_error(),
+	};
+
+	// Capture the `#[pallet_doc("../README.md")]`.
+	let pallet_docs = match pallet_docs
+		.into_iter()
+		.map(|attr| parse_pallet_doc_value(&attr))
+		.collect::<syn::Result<Vec<_>>>()
+	{
+		Ok(docs) => docs,
+		Err(err) => return err.into_compile_error(),
+	};
+
+	let docs = docs.iter().chain(pallet_docs.iter());
+
+	quote::quote!(
+		impl<#type_impl_gen> #pallet_ident<#type_use_gen> #where_clauses{
+
+			#[doc(hidden)]
+			pub fn pallet_documentation_metadata()
+				-> #frame_support::__private::sp_std::vec::Vec<&'static str>
+			{
+				#frame_support::__private::sp_std::vec![ #( #docs ),* ]
+			}
+		}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/error.rs b/substrate/frame/support/procedural/src/pallet/expand/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d3aa0b762bc52df2af97079574eb5dbf6616c72a
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/error.rs
@@ -0,0 +1,184 @@
+// 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::{
+	pallet::{parse::error::VariantField, Def},
+	COUNTER,
+};
+use frame_support_procedural_tools::get_doc_literals;
+use syn::spanned::Spanned;
+
+///
+/// * impl various trait on Error
+pub fn expand_error(def: &mut Def) -> proc_macro2::TokenStream {
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+	let error_token_unique_id =
+		syn::Ident::new(&format!("__tt_error_token_{}", count), def.item.span());
+
+	let frame_support = &def.frame_support;
+	let frame_system = &def.frame_system;
+	let config_where_clause = &def.config.where_clause;
+
+	let error = if let Some(error) = &def.error {
+		error
+	} else {
+		return quote::quote! {
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #error_token_unique_id {
+				{
+					$caller:tt
+					frame_support = [{ $($frame_support:ident)::* }]
+				} => {
+					$($frame_support::)*__private::tt_return! {
+						$caller
+					}
+				};
+			}
+
+			pub use #error_token_unique_id as tt_error_token;
+		}
+	};
+
+	let error_ident = &error.error;
+	let type_impl_gen = &def.type_impl_generics(error.attr_span);
+	let type_use_gen = &def.type_use_generics(error.attr_span);
+
+	let phantom_variant: syn::Variant = syn::parse_quote!(
+		#[doc(hidden)]
+		#[codec(skip)]
+		__Ignore(
+			#frame_support::__private::sp_std::marker::PhantomData<(#type_use_gen)>,
+			#frame_support::Never,
+		)
+	);
+
+	let as_str_matches = error.variants.iter().map(|(variant, field_ty, _)| {
+		let variant_str = variant.to_string();
+		match field_ty {
+			Some(VariantField { is_named: true }) => {
+				quote::quote_spanned!(error.attr_span => Self::#variant { .. } => #variant_str,)
+			},
+			Some(VariantField { is_named: false }) => {
+				quote::quote_spanned!(error.attr_span => Self::#variant(..) => #variant_str,)
+			},
+			None => {
+				quote::quote_spanned!(error.attr_span => Self::#variant => #variant_str,)
+			},
+		}
+	});
+
+	let error_item = {
+		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[error.index];
+		if let syn::Item::Enum(item) = item {
+			item
+		} else {
+			unreachable!("Checked by error parser")
+		}
+	};
+
+	error_item.variants.insert(0, phantom_variant);
+
+	let capture_docs = if cfg!(feature = "no-metadata-docs") { "never" } else { "always" };
+
+	// derive TypeInfo for error metadata
+	error_item.attrs.push(syn::parse_quote! {
+		#[derive(
+			#frame_support::__private::codec::Encode,
+			#frame_support::__private::codec::Decode,
+			#frame_support::__private::scale_info::TypeInfo,
+			#frame_support::PalletError,
+		)]
+	});
+	error_item.attrs.push(syn::parse_quote!(
+		#[scale_info(skip_type_params(#type_use_gen), capture_docs = #capture_docs)]
+	));
+
+	if get_doc_literals(&error_item.attrs).is_empty() {
+		error_item.attrs.push(syn::parse_quote!(
+			#[doc = "The `Error` enum of this pallet."]
+		));
+	}
+
+	quote::quote_spanned!(error.attr_span =>
+		impl<#type_impl_gen> #frame_support::__private::sp_std::fmt::Debug for #error_ident<#type_use_gen>
+			#config_where_clause
+		{
+			fn fmt(&self, f: &mut #frame_support::__private::sp_std::fmt::Formatter<'_>)
+				-> #frame_support::__private::sp_std::fmt::Result
+			{
+				f.write_str(self.as_str())
+			}
+		}
+
+		impl<#type_impl_gen> #error_ident<#type_use_gen> #config_where_clause {
+			#[doc(hidden)]
+			pub fn as_str(&self) -> &'static str {
+				match &self {
+					Self::__Ignore(_, _) => unreachable!("`__Ignore` can never be constructed"),
+					#( #as_str_matches )*
+				}
+			}
+		}
+
+		impl<#type_impl_gen> From<#error_ident<#type_use_gen>> for &'static str
+			#config_where_clause
+		{
+			fn from(err: #error_ident<#type_use_gen>) -> &'static str {
+				err.as_str()
+			}
+		}
+
+		impl<#type_impl_gen> From<#error_ident<#type_use_gen>>
+			for #frame_support::sp_runtime::DispatchError
+			#config_where_clause
+		{
+			fn from(err: #error_ident<#type_use_gen>) -> Self {
+				use #frame_support::__private::codec::Encode;
+				let index = <
+					<T as #frame_system::Config>::PalletInfo
+					as #frame_support::traits::PalletInfo
+				>::index::<Pallet<#type_use_gen>>()
+					.expect("Every active module has an index in the runtime; qed") as u8;
+				let mut encoded = err.encode();
+				encoded.resize(#frame_support::MAX_MODULE_ERROR_ENCODED_SIZE, 0);
+
+				#frame_support::sp_runtime::DispatchError::Module(#frame_support::sp_runtime::ModuleError {
+					index,
+					error: TryInto::try_into(encoded).expect("encoded error is resized to be equal to the maximum encoded error size; qed"),
+					message: Some(err.as_str()),
+				})
+			}
+		}
+
+		#[macro_export]
+		#[doc(hidden)]
+		macro_rules! #error_token_unique_id {
+			{
+				$caller:tt
+				frame_support = [{ $($frame_support:ident)::* }]
+			} => {
+				$($frame_support::)*__private::tt_return! {
+					$caller
+					error = [{ #error_ident }]
+				}
+			};
+		}
+
+		pub use #error_token_unique_id as tt_error_token;
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/event.rs b/substrate/frame/support/procedural/src/pallet/expand/event.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fbb699b4d41cceb64384a67ad3c472cf6c32c98b
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/event.rs
@@ -0,0 +1,173 @@
+// 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::{
+	pallet::{parse::event::PalletEventDepositAttr, Def},
+	COUNTER,
+};
+use frame_support_procedural_tools::get_doc_literals;
+use syn::{spanned::Spanned, Ident};
+
+///
+/// * Add __Ignore variant on Event
+/// * Impl various trait on Event including metadata
+/// * if deposit_event is defined, implement deposit_event on module.
+pub fn expand_event(def: &mut Def) -> proc_macro2::TokenStream {
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+
+	let (event, macro_ident) = if let Some(event) = &def.event {
+		let ident = Ident::new(&format!("__is_event_part_defined_{}", count), event.attr_span);
+		(event, ident)
+	} else {
+		let macro_ident =
+			Ident::new(&format!("__is_event_part_defined_{}", count), def.item.span());
+
+		return quote::quote! {
+			#[doc(hidden)]
+			pub mod __substrate_event_check {
+				#[macro_export]
+				#[doc(hidden)]
+				macro_rules! #macro_ident {
+					($pallet_name:ident) => {
+						compile_error!(concat!(
+							"`",
+							stringify!($pallet_name),
+							"` does not have #[pallet::event] defined, perhaps you should \
+							remove `Event` from construct_runtime?",
+						));
+					}
+				}
+
+				#[doc(hidden)]
+				pub use #macro_ident as is_event_part_defined;
+			}
+		}
+	};
+
+	let event_where_clause = &event.where_clause;
+
+	// NOTE: actually event where clause must be a subset of config where clause because of
+	// `type RuntimeEvent: From<Event<Self>>`. But we merge either way for potential better error
+	// message
+	let completed_where_clause =
+		super::merge_where_clauses(&[&event.where_clause, &def.config.where_clause]);
+
+	let event_ident = &event.event;
+	let frame_system = &def.frame_system;
+	let frame_support = &def.frame_support;
+	let event_use_gen = &event.gen_kind.type_use_gen(event.attr_span);
+	let event_impl_gen = &event.gen_kind.type_impl_gen(event.attr_span);
+
+	let event_item = {
+		let item = &mut def.item.content.as_mut().expect("Checked by def parser").1[event.index];
+		if let syn::Item::Enum(item) = item {
+			item
+		} else {
+			unreachable!("Checked by event parser")
+		}
+	};
+
+	// Phantom data is added for generic event.
+	if event.gen_kind.is_generic() {
+		let variant = syn::parse_quote!(
+			#[doc(hidden)]
+			#[codec(skip)]
+			__Ignore(
+				#frame_support::__private::sp_std::marker::PhantomData<(#event_use_gen)>,
+				#frame_support::Never,
+			)
+		);
+
+		// Push ignore variant at the end.
+		event_item.variants.push(variant);
+	}
+
+	if get_doc_literals(&event_item.attrs).is_empty() {
+		event_item
+			.attrs
+			.push(syn::parse_quote!(#[doc = "The `Event` enum of this pallet"]));
+	}
+
+	// derive some traits because system event require Clone, FullCodec, Eq, PartialEq and Debug
+	event_item.attrs.push(syn::parse_quote!(
+		#[derive(
+			#frame_support::CloneNoBound,
+			#frame_support::EqNoBound,
+			#frame_support::PartialEqNoBound,
+			#frame_support::RuntimeDebugNoBound,
+			#frame_support::__private::codec::Encode,
+			#frame_support::__private::codec::Decode,
+			#frame_support::__private::scale_info::TypeInfo,
+		)]
+	));
+
+	let capture_docs = if cfg!(feature = "no-metadata-docs") { "never" } else { "always" };
+
+	// skip requirement for type params to implement `TypeInfo`, and set docs capture
+	event_item.attrs.push(syn::parse_quote!(
+		#[scale_info(skip_type_params(#event_use_gen), capture_docs = #capture_docs)]
+	));
+
+	let deposit_event = if let Some(deposit_event) = &event.deposit_event {
+		let event_use_gen = &event.gen_kind.type_use_gen(event.attr_span);
+		let trait_use_gen = &def.trait_use_generics(event.attr_span);
+		let type_impl_gen = &def.type_impl_generics(event.attr_span);
+		let type_use_gen = &def.type_use_generics(event.attr_span);
+
+		let PalletEventDepositAttr { fn_vis, fn_span, .. } = deposit_event;
+
+		quote::quote_spanned!(*fn_span =>
+			impl<#type_impl_gen> Pallet<#type_use_gen> #completed_where_clause {
+				#fn_vis fn deposit_event(event: Event<#event_use_gen>) {
+					let event = <
+						<T as Config #trait_use_gen>::RuntimeEvent as
+						From<Event<#event_use_gen>>
+					>::from(event);
+
+					let event = <
+						<T as Config #trait_use_gen>::RuntimeEvent as
+						Into<<T as #frame_system::Config>::RuntimeEvent>
+					>::into(event);
+
+					<#frame_system::Pallet<T>>::deposit_event(event)
+				}
+			}
+		)
+	} else {
+		Default::default()
+	};
+
+	quote::quote_spanned!(event.attr_span =>
+		#[doc(hidden)]
+		pub mod __substrate_event_check {
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #macro_ident {
+				($pallet_name:ident) => {};
+			}
+
+			#[doc(hidden)]
+			pub use #macro_ident as is_event_part_defined;
+		}
+
+		#deposit_event
+
+		impl<#event_impl_gen> From<#event_ident<#event_use_gen>> for () #event_where_clause {
+			fn from(_: #event_ident<#event_use_gen>) {}
+		}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/genesis_build.rs b/substrate/frame/support/procedural/src/pallet/expand/genesis_build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..15ddfcf1d49d4e81c26fe96d70589c4fa431fe0c
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/genesis_build.rs
@@ -0,0 +1,49 @@
+// 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::pallet::Def;
+
+///
+/// * implement the trait `sp_runtime::BuildStorage`
+pub fn expand_genesis_build(def: &mut Def) -> proc_macro2::TokenStream {
+	let genesis_config = if let Some(genesis_config) = &def.genesis_config {
+		genesis_config
+	} else {
+		return Default::default()
+	};
+	let genesis_build = def.genesis_build.as_ref().expect("Checked by def parser");
+
+	let frame_support = &def.frame_support;
+	let type_impl_gen = &genesis_config.gen_kind.type_impl_gen(genesis_build.attr_span);
+	let gen_cfg_ident = &genesis_config.genesis_config;
+	let gen_cfg_use_gen = &genesis_config.gen_kind.type_use_gen(genesis_build.attr_span);
+
+	let where_clause = &genesis_build.where_clause;
+
+	quote::quote_spanned!(genesis_build.attr_span =>
+		#[cfg(feature = "std")]
+			impl<#type_impl_gen> #frame_support::sp_runtime::BuildStorage for #gen_cfg_ident<#gen_cfg_use_gen> #where_clause
+			{
+				fn assimilate_storage(&self, storage: &mut sp_runtime::Storage) -> std::result::Result<(), std::string::String> {
+					#frame_support::__private::BasicExternalities::execute_with_storage(storage, || {
+						self.build();
+						Ok(())
+					})
+				}
+			}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/genesis_config.rs b/substrate/frame/support/procedural/src/pallet/expand/genesis_config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b00f9bcd1a662dd592a7191a80469363f1a5acb4
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/genesis_config.rs
@@ -0,0 +1,146 @@
+// 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::{pallet::Def, COUNTER};
+use frame_support_procedural_tools::get_doc_literals;
+use syn::{spanned::Spanned, Ident};
+
+///
+/// * add various derive trait on GenesisConfig struct.
+pub fn expand_genesis_config(def: &mut Def) -> proc_macro2::TokenStream {
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+
+	let (genesis_config, def_macro_ident, std_macro_ident) =
+		if let Some(genesis_config) = &def.genesis_config {
+			let def_macro_ident = Ident::new(
+				&format!("__is_genesis_config_defined_{}", count),
+				genesis_config.genesis_config.span(),
+			);
+
+			let std_macro_ident = Ident::new(
+				&format!("__is_std_macro_defined_for_genesis_{}", count),
+				genesis_config.genesis_config.span(),
+			);
+
+			(genesis_config, def_macro_ident, std_macro_ident)
+		} else {
+			let def_macro_ident =
+				Ident::new(&format!("__is_genesis_config_defined_{}", count), def.item.span());
+
+			let std_macro_ident =
+				Ident::new(&format!("__is_std_enabled_for_genesis_{}", count), def.item.span());
+
+			return quote::quote! {
+				#[doc(hidden)]
+				pub mod __substrate_genesis_config_check {
+					#[macro_export]
+					#[doc(hidden)]
+					macro_rules! #def_macro_ident {
+						($pallet_name:ident) => {
+							compile_error!(concat!(
+								"`",
+								stringify!($pallet_name),
+								"` does not have #[pallet::genesis_config] defined, perhaps you should \
+								remove `Config` from construct_runtime?",
+							));
+						}
+					}
+
+					#[macro_export]
+					#[doc(hidden)]
+					macro_rules! #std_macro_ident {
+						($pallet_name:ident, $pallet_path:expr) => {};
+					}
+
+					#[doc(hidden)]
+					pub use #def_macro_ident as is_genesis_config_defined;
+					#[doc(hidden)]
+					pub use #std_macro_ident as is_std_enabled_for_genesis;
+				}
+			}
+		};
+
+	let frame_support = &def.frame_support;
+
+	let genesis_config_item =
+		&mut def.item.content.as_mut().expect("Checked by def parser").1[genesis_config.index];
+
+	let serde_crate = format!("{}::__private::serde", frame_support);
+
+	match genesis_config_item {
+		syn::Item::Enum(syn::ItemEnum { attrs, .. }) |
+		syn::Item::Struct(syn::ItemStruct { attrs, .. }) |
+		syn::Item::Type(syn::ItemType { attrs, .. }) => {
+			if get_doc_literals(attrs).is_empty() {
+				attrs.push(syn::parse_quote!(
+					#[doc = r"
+					Can be used to configure the
+					[genesis state](https://docs.substrate.io/build/genesis-configuration/)
+					of this pallet.
+					"]
+				));
+			}
+			attrs.push(syn::parse_quote!(
+				#[derive(#frame_support::Serialize, #frame_support::Deserialize)]
+			));
+			attrs.push(syn::parse_quote!( #[serde(rename_all = "camelCase")] ));
+			attrs.push(syn::parse_quote!( #[serde(deny_unknown_fields)] ));
+			attrs.push(syn::parse_quote!( #[serde(bound(serialize = ""))] ));
+			attrs.push(syn::parse_quote!( #[serde(bound(deserialize = ""))] ));
+			attrs.push(syn::parse_quote!( #[serde(crate = #serde_crate)] ));
+		},
+		_ => unreachable!("Checked by genesis_config parser"),
+	}
+
+	quote::quote! {
+		#[doc(hidden)]
+		pub mod __substrate_genesis_config_check {
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #def_macro_ident {
+				($pallet_name:ident) => {};
+			}
+
+			#[cfg(not(feature = "std"))]
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #std_macro_ident {
+				($pallet_name:ident, $pallet_path:expr) => {
+					compile_error!(concat!(
+						"`",
+						stringify!($pallet_name),
+						"` does not have the std feature enabled, this will cause the `",
+						$pallet_path,
+						"::GenesisConfig` type to not implement serde traits."
+					));
+				};
+			}
+
+			#[cfg(feature = "std")]
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #std_macro_ident {
+				($pallet_name:ident, $pallet_path:expr) => {};
+			}
+
+			#[doc(hidden)]
+			pub use #def_macro_ident as is_genesis_config_defined;
+			#[doc(hidden)]
+			pub use #std_macro_ident as is_std_enabled_for_genesis;
+		}
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/hooks.rs b/substrate/frame/support/procedural/src/pallet/expand/hooks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2825756f270f02ba8feb66088811ca21391c5330
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/hooks.rs
@@ -0,0 +1,283 @@
+// 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::pallet::Def;
+
+/// * implement the individual traits using the Hooks trait
+pub fn expand_hooks(def: &mut Def) -> proc_macro2::TokenStream {
+	let (where_clause, span, has_runtime_upgrade) = match def.hooks.as_ref() {
+		Some(hooks) => {
+			let where_clause = hooks.where_clause.clone();
+			let span = hooks.attr_span;
+			let has_runtime_upgrade = hooks.has_runtime_upgrade;
+			(where_clause, span, has_runtime_upgrade)
+		},
+		None => (def.config.where_clause.clone(), def.pallet_struct.attr_span, false),
+	};
+
+	let frame_support = &def.frame_support;
+	let type_impl_gen = &def.type_impl_generics(span);
+	let type_use_gen = &def.type_use_generics(span);
+	let pallet_ident = &def.pallet_struct.pallet;
+	let frame_system = &def.frame_system;
+
+	let log_runtime_upgrade = if has_runtime_upgrade {
+		// a migration is defined here.
+		quote::quote! {
+			#frame_support::__private::log::info!(
+				target: #frame_support::LOG_TARGET,
+				"⚠� {} declares internal migrations (which *might* execute). \
+				 On-chain `{:?}` vs current storage version `{:?}`",
+				pallet_name,
+				<Self as #frame_support::traits::GetStorageVersion>::on_chain_storage_version(),
+				<Self as #frame_support::traits::GetStorageVersion>::current_storage_version(),
+			);
+		}
+	} else {
+		// default.
+		quote::quote! {
+			#frame_support::__private::log::debug!(
+				target: #frame_support::LOG_TARGET,
+				"✅ no migration for {}",
+				pallet_name,
+			);
+		}
+	};
+
+	let log_try_state = quote::quote! {
+		let pallet_name = <
+			<T as #frame_system::Config>::PalletInfo
+			as
+			#frame_support::traits::PalletInfo
+		>::name::<Self>().expect("No name found for the pallet! This usually means that the pallet wasn't added to `construct_runtime!`.");
+		#frame_support::__private::log::debug!(
+			target: #frame_support::LOG_TARGET,
+			"🩺 try-state pallet {:?}",
+			pallet_name,
+		);
+	};
+
+	let hooks_impl = if def.hooks.is_none() {
+		let frame_system = &def.frame_system;
+		quote::quote! {
+			impl<#type_impl_gen>
+				#frame_support::traits::Hooks<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+				for #pallet_ident<#type_use_gen> #where_clause {}
+		}
+	} else {
+		proc_macro2::TokenStream::new()
+	};
+
+	// If a storage version is set, we should ensure that the storage version on chain matches the
+	// current storage version. This assumes that `Executive` is running custom migrations before
+	// the pallets are called.
+	let post_storage_version_check = if def.pallet_struct.storage_version.is_some() {
+		quote::quote! {
+			let on_chain_version = <Self as #frame_support::traits::GetStorageVersion>::on_chain_storage_version();
+			let current_version = <Self as #frame_support::traits::GetStorageVersion>::current_storage_version();
+
+			if on_chain_version != current_version {
+				let pallet_name = <
+					<T as #frame_system::Config>::PalletInfo
+					as
+					#frame_support::traits::PalletInfo
+				>::name::<Self>().unwrap_or("<unknown pallet name>");
+
+				#frame_support::__private::log::error!(
+					target: #frame_support::LOG_TARGET,
+					"{}: On chain storage version {:?} doesn't match current storage version {:?}.",
+					pallet_name,
+					on_chain_version,
+					current_version,
+				);
+
+				return Err("On chain and current storage version do not match. Missing runtime upgrade?".into());
+			}
+		}
+	} else {
+		quote::quote! {
+			let on_chain_version = <Self as #frame_support::traits::GetStorageVersion>::on_chain_storage_version();
+
+			if on_chain_version != #frame_support::traits::StorageVersion::new(0) {
+				let pallet_name = <
+					<T as #frame_system::Config>::PalletInfo
+					as
+					#frame_support::traits::PalletInfo
+				>::name::<Self>().unwrap_or("<unknown pallet name>");
+
+				#frame_support::__private::log::error!(
+					target: #frame_support::LOG_TARGET,
+					"{}: On chain storage version {:?} is set to non zero, \
+					 while the pallet is missing the `#[pallet::storage_version(VERSION)]` attribute.",
+					pallet_name,
+					on_chain_version,
+				);
+
+				return Err("On chain storage version set, while the pallet doesn't \
+							have the `#[pallet::storage_version(VERSION)]` attribute.".into());
+			}
+		}
+	};
+
+	quote::quote_spanned!(span =>
+		#hooks_impl
+
+		impl<#type_impl_gen>
+			#frame_support::traits::OnFinalize<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+			for #pallet_ident<#type_use_gen> #where_clause
+		{
+			fn on_finalize(n: #frame_system::pallet_prelude::BlockNumberFor::<T>) {
+				#frame_support::__private::sp_tracing::enter_span!(
+					#frame_support::__private::sp_tracing::trace_span!("on_finalize")
+				);
+				<
+					Self as #frame_support::traits::Hooks<
+						#frame_system::pallet_prelude::BlockNumberFor::<T>
+					>
+				>::on_finalize(n)
+			}
+		}
+
+		impl<#type_impl_gen>
+			#frame_support::traits::OnIdle<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+			for #pallet_ident<#type_use_gen> #where_clause
+		{
+			fn on_idle(
+				n: #frame_system::pallet_prelude::BlockNumberFor::<T>,
+				remaining_weight: #frame_support::weights::Weight
+			) -> #frame_support::weights::Weight {
+				<
+					Self as #frame_support::traits::Hooks<
+						#frame_system::pallet_prelude::BlockNumberFor::<T>
+					>
+				>::on_idle(n, remaining_weight)
+			}
+		}
+
+		impl<#type_impl_gen>
+			#frame_support::traits::OnInitialize<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+			for #pallet_ident<#type_use_gen> #where_clause
+		{
+			fn on_initialize(
+				n: #frame_system::pallet_prelude::BlockNumberFor::<T>
+			) -> #frame_support::weights::Weight {
+				#frame_support::__private::sp_tracing::enter_span!(
+					#frame_support::__private::sp_tracing::trace_span!("on_initialize")
+				);
+				<
+					Self as #frame_support::traits::Hooks<
+						#frame_system::pallet_prelude::BlockNumberFor::<T>
+					>
+				>::on_initialize(n)
+			}
+		}
+
+		impl<#type_impl_gen>
+			#frame_support::traits::OnRuntimeUpgrade
+			for #pallet_ident<#type_use_gen> #where_clause
+		{
+			fn on_runtime_upgrade() -> #frame_support::weights::Weight {
+				#frame_support::__private::sp_tracing::enter_span!(
+					#frame_support::__private::sp_tracing::trace_span!("on_runtime_update")
+				);
+
+				// log info about the upgrade.
+				let pallet_name = <
+					<T as #frame_system::Config>::PalletInfo
+					as
+					#frame_support::traits::PalletInfo
+				>::name::<Self>().unwrap_or("<unknown pallet name>");
+				#log_runtime_upgrade
+
+				<
+					Self as #frame_support::traits::Hooks<
+						#frame_system::pallet_prelude::BlockNumberFor::<T>
+					>
+				>::on_runtime_upgrade()
+			}
+
+			#[cfg(feature = "try-runtime")]
+			fn pre_upgrade() -> Result<#frame_support::__private::sp_std::vec::Vec<u8>, #frame_support::sp_runtime::TryRuntimeError> {
+				<
+					Self
+					as
+					#frame_support::traits::Hooks<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+				>::pre_upgrade()
+			}
+
+			#[cfg(feature = "try-runtime")]
+			fn post_upgrade(state: #frame_support::__private::sp_std::vec::Vec<u8>) -> Result<(), #frame_support::sp_runtime::TryRuntimeError> {
+				#post_storage_version_check
+
+				<
+					Self
+					as
+					#frame_support::traits::Hooks<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+				>::post_upgrade(state)
+			}
+		}
+
+		impl<#type_impl_gen>
+			#frame_support::traits::OffchainWorker<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+			for #pallet_ident<#type_use_gen> #where_clause
+		{
+			fn offchain_worker(n: #frame_system::pallet_prelude::BlockNumberFor::<T>) {
+				<
+					Self as #frame_support::traits::Hooks<
+						#frame_system::pallet_prelude::BlockNumberFor::<T>
+					>
+				>::offchain_worker(n)
+			}
+		}
+
+		// Integrity tests are only required for when `std` is enabled.
+		#frame_support::std_enabled! {
+			impl<#type_impl_gen>
+				#frame_support::traits::IntegrityTest
+			for #pallet_ident<#type_use_gen> #where_clause
+			{
+				fn integrity_test() {
+					#frame_support::__private::sp_io::TestExternalities::default().execute_with(|| {
+						<
+							Self as #frame_support::traits::Hooks<
+								#frame_system::pallet_prelude::BlockNumberFor::<T>
+							>
+						>::integrity_test()
+					});
+				}
+			}
+		}
+
+		#[cfg(feature = "try-runtime")]
+		impl<#type_impl_gen>
+			#frame_support::traits::TryState<#frame_system::pallet_prelude::BlockNumberFor::<T>>
+			for #pallet_ident<#type_use_gen> #where_clause
+		{
+			fn try_state(
+				n: #frame_system::pallet_prelude::BlockNumberFor::<T>,
+				_s: #frame_support::traits::TryStateSelect
+			) -> Result<(), #frame_support::sp_runtime::TryRuntimeError> {
+				#log_try_state
+				<
+					Self as #frame_support::traits::Hooks<
+						#frame_system::pallet_prelude::BlockNumberFor::<T>
+					>
+				>::try_state(n)
+			}
+		}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/inherent.rs b/substrate/frame/support/procedural/src/pallet/expand/inherent.rs
new file mode 100644
index 0000000000000000000000000000000000000000..182d79f5b0a9e7fe41fa05fbac3c06d9a6d97d7c
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/inherent.rs
@@ -0,0 +1,55 @@
+// 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::{pallet::Def, COUNTER};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{spanned::Spanned, Ident};
+
+pub fn expand_inherents(def: &mut Def) -> TokenStream {
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+	let macro_ident = Ident::new(&format!("__is_inherent_part_defined_{}", count), def.item.span());
+
+	let maybe_compile_error = if def.inherent.is_none() {
+		quote! {
+			compile_error!(concat!(
+				"`",
+				stringify!($pallet_name),
+				"` does not have #[pallet::inherent] defined, perhaps you should \
+				remove `Inherent` from construct_runtime?",
+			));
+		}
+	} else {
+		TokenStream::new()
+	};
+
+	quote! {
+		#[doc(hidden)]
+		pub mod __substrate_inherent_check {
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #macro_ident {
+				($pallet_name:ident) => {
+					#maybe_compile_error
+				}
+			}
+
+			#[doc(hidden)]
+			pub use #macro_ident as is_inherent_part_defined;
+		}
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/instances.rs b/substrate/frame/support/procedural/src/pallet/expand/instances.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b6dfa7e6d9e9cdec39bdb2a84cf598b28c074386
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/instances.rs
@@ -0,0 +1,43 @@
+// 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::{pallet::Def, NUMBER_OF_INSTANCE};
+use proc_macro2::Span;
+
+///
+/// * Provide inherent instance to be used by construct_runtime
+/// * Provide Instance1 ..= Instance16 for instantiable pallet
+pub fn expand_instances(def: &mut Def) -> proc_macro2::TokenStream {
+	let frame_support = &def.frame_support;
+	let inherent_ident = syn::Ident::new(crate::INHERENT_INSTANCE_NAME, Span::call_site());
+	let instances = if def.config.has_instance {
+		(1..=NUMBER_OF_INSTANCE)
+			.map(|i| syn::Ident::new(&format!("Instance{}", i), Span::call_site()))
+			.collect()
+	} else {
+		vec![]
+	};
+
+	quote::quote!(
+		/// Hidden instance generated to be internally used when module is used without
+		/// instance.
+		#[doc(hidden)]
+		pub type #inherent_ident = ();
+
+		#( pub use #frame_support::instances::#instances; )*
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/mod.rs b/substrate/frame/support/procedural/src/pallet/expand/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2b998227c1d841a92a2ded9f3f5b681b83d4ef65
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/mod.rs
@@ -0,0 +1,126 @@
+// 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.
+
+mod call;
+mod config;
+mod constants;
+mod doc_only;
+mod documentation;
+mod error;
+mod event;
+mod genesis_build;
+mod genesis_config;
+mod hooks;
+mod inherent;
+mod instances;
+mod origin;
+mod pallet_struct;
+mod storage;
+mod store_trait;
+mod tt_default_parts;
+mod type_value;
+mod validate_unsigned;
+
+use crate::pallet::Def;
+use quote::ToTokens;
+
+/// Merge where clause together, `where` token span is taken from the first not none one.
+pub fn merge_where_clauses(clauses: &[&Option<syn::WhereClause>]) -> Option<syn::WhereClause> {
+	let mut clauses = clauses.iter().filter_map(|f| f.as_ref());
+	let mut res = clauses.next()?.clone();
+	for other in clauses {
+		res.predicates.extend(other.predicates.iter().cloned())
+	}
+	Some(res)
+}
+
+/// Expand definition, in particular:
+/// * add some bounds and variants to type defined,
+/// * create some new types,
+/// * impl stuff on them.
+pub fn expand(mut def: Def) -> proc_macro2::TokenStream {
+	// Remove the `pallet_doc` attribute first.
+	let metadata_docs = documentation::expand_documentation(&mut def);
+	let constants = constants::expand_constants(&mut def);
+	let pallet_struct = pallet_struct::expand_pallet_struct(&mut def);
+	let config = config::expand_config(&mut def);
+	let call = call::expand_call(&mut def);
+	let error = error::expand_error(&mut def);
+	let event = event::expand_event(&mut def);
+	let storages = storage::expand_storages(&mut def);
+	let inherents = inherent::expand_inherents(&mut def);
+	let instances = instances::expand_instances(&mut def);
+	let store_trait = store_trait::expand_store_trait(&mut def);
+	let hooks = hooks::expand_hooks(&mut def);
+	let genesis_build = genesis_build::expand_genesis_build(&mut def);
+	let genesis_config = genesis_config::expand_genesis_config(&mut def);
+	let type_values = type_value::expand_type_values(&mut def);
+	let origins = origin::expand_origins(&mut def);
+	let validate_unsigned = validate_unsigned::expand_validate_unsigned(&mut def);
+	let tt_default_parts = tt_default_parts::expand_tt_default_parts(&mut def);
+	let doc_only = doc_only::expand_doc_only(&mut def);
+
+	def.item.attrs.insert(
+		0,
+		syn::parse_quote!(
+			#[doc = r"The `pallet` module in each FRAME pallet hosts the most important items needed
+to construct this pallet.
+
+The main components of this pallet are:
+- [`Pallet`], which implements all of the dispatchable extrinsics of the pallet, among
+other public functions.
+	- The subset of the functions that are dispatchable can be identified either in the
+	[`dispatchables`] module or in the [`Call`] enum.
+- [`storage_types`], which contains the list of all types that are representing a
+storage item. Otherwise, all storage items are listed among [*Type Definitions*](#types).
+- [`Config`], which contains the configuration trait of this pallet.
+- [`Event`] and [`Error`], which are listed among the [*Enums*](#enums).
+		"]
+		),
+	);
+
+	let new_items = quote::quote!(
+		#metadata_docs
+		#constants
+		#pallet_struct
+		#config
+		#call
+		#error
+		#event
+		#storages
+		#inherents
+		#instances
+		#store_trait
+		#hooks
+		#genesis_build
+		#genesis_config
+		#type_values
+		#origins
+		#validate_unsigned
+		#tt_default_parts
+		#doc_only
+	);
+
+	def.item
+		.content
+		.as_mut()
+		.expect("This is checked by parsing")
+		.1
+		.push(syn::Item::Verbatim(new_items));
+
+	def.item.into_token_stream()
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/origin.rs b/substrate/frame/support/procedural/src/pallet/expand/origin.rs
new file mode 100644
index 0000000000000000000000000000000000000000..55865b42491a3b4017fe301bbddbbe5d142e64cb
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/origin.rs
@@ -0,0 +1,55 @@
+// 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::{pallet::Def, COUNTER};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{spanned::Spanned, Ident};
+
+pub fn expand_origins(def: &mut Def) -> TokenStream {
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+	let macro_ident = Ident::new(&format!("__is_origin_part_defined_{}", count), def.item.span());
+
+	let maybe_compile_error = if def.origin.is_none() {
+		quote! {
+			compile_error!(concat!(
+				"`",
+				stringify!($pallet_name),
+				"` does not have #[pallet::origin] defined, perhaps you should \
+				remove `Origin` from construct_runtime?",
+			));
+		}
+	} else {
+		TokenStream::new()
+	};
+
+	quote! {
+		#[doc(hidden)]
+		pub mod __substrate_origin_check {
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #macro_ident {
+				($pallet_name:ident) => {
+					#maybe_compile_error
+				}
+			}
+
+			#[doc(hidden)]
+			pub use #macro_ident as is_origin_part_defined;
+		}
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/pallet_struct.rs b/substrate/frame/support/procedural/src/pallet/expand/pallet_struct.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e519e34d1dfd9411d735887b4dbe0ed337772238
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/pallet_struct.rs
@@ -0,0 +1,282 @@
+// 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::pallet::{expand::merge_where_clauses, Def};
+use frame_support_procedural_tools::get_doc_literals;
+
+///
+/// * Add derive trait on Pallet
+/// * Implement GetStorageVersion on Pallet
+/// * Implement OnGenesis on Pallet
+/// * Implement `fn error_metadata` on Pallet
+/// * declare Module type alias for construct_runtime
+/// * replace the first field type of `struct Pallet` with `PhantomData` if it is `_`
+/// * implementation of `PalletInfoAccess` information
+/// * implementation of `StorageInfoTrait` on Pallet
+pub fn expand_pallet_struct(def: &mut Def) -> proc_macro2::TokenStream {
+	let frame_support = &def.frame_support;
+	let frame_system = &def.frame_system;
+	let type_impl_gen = &def.type_impl_generics(def.pallet_struct.attr_span);
+	let type_use_gen = &def.type_use_generics(def.pallet_struct.attr_span);
+	let type_decl_gen = &def.type_decl_generics(def.pallet_struct.attr_span);
+	let pallet_ident = &def.pallet_struct.pallet;
+	let config_where_clause = &def.config.where_clause;
+
+	let mut storages_where_clauses = vec![&def.config.where_clause];
+	storages_where_clauses.extend(def.storages.iter().map(|storage| &storage.where_clause));
+	let storages_where_clauses = merge_where_clauses(&storages_where_clauses);
+
+	let pallet_item = {
+		let pallet_module_items = &mut def.item.content.as_mut().expect("Checked by def").1;
+		let item = &mut pallet_module_items[def.pallet_struct.index];
+		if let syn::Item::Struct(item) = item {
+			item
+		} else {
+			unreachable!("Checked by pallet struct parser")
+		}
+	};
+
+	// If the first field type is `_` then we replace with `PhantomData`
+	if let Some(field) = pallet_item.fields.iter_mut().next() {
+		if field.ty == syn::parse_quote!(_) {
+			field.ty = syn::parse_quote!(
+				#frame_support::__private::sp_std::marker::PhantomData<(#type_use_gen)>
+			);
+		}
+	}
+
+	if get_doc_literals(&pallet_item.attrs).is_empty() {
+		pallet_item.attrs.push(syn::parse_quote!(
+			#[doc = r"
+				The `Pallet` struct, the main type that implements traits and standalone
+				functions within the pallet.
+			"]
+		));
+	}
+
+	pallet_item.attrs.push(syn::parse_quote!(
+		#[derive(
+			#frame_support::CloneNoBound,
+			#frame_support::EqNoBound,
+			#frame_support::PartialEqNoBound,
+			#frame_support::RuntimeDebugNoBound,
+		)]
+	));
+
+	let pallet_error_metadata = if let Some(error_def) = &def.error {
+		let error_ident = &error_def.error;
+		quote::quote_spanned!(def.pallet_struct.attr_span =>
+			impl<#type_impl_gen> #pallet_ident<#type_use_gen> #config_where_clause {
+				#[doc(hidden)]
+				pub fn error_metadata() -> Option<#frame_support::__private::metadata_ir::PalletErrorMetadataIR> {
+					Some(#frame_support::__private::metadata_ir::PalletErrorMetadataIR {
+						ty: #frame_support::__private::scale_info::meta_type::<#error_ident<#type_use_gen>>()
+					})
+				}
+			}
+		)
+	} else {
+		quote::quote_spanned!(def.pallet_struct.attr_span =>
+			impl<#type_impl_gen> #pallet_ident<#type_use_gen> #config_where_clause {
+				#[doc(hidden)]
+				pub fn error_metadata() -> Option<#frame_support::__private::metadata_ir::PalletErrorMetadataIR> {
+					None
+				}
+			}
+		)
+	};
+
+	let storage_info_span =
+		def.pallet_struct.without_storage_info.unwrap_or(def.pallet_struct.attr_span);
+
+	let storage_names = &def.storages.iter().map(|storage| &storage.ident).collect::<Vec<_>>();
+	let storage_cfg_attrs =
+		&def.storages.iter().map(|storage| &storage.cfg_attrs).collect::<Vec<_>>();
+
+	// Depending on the flag `without_storage_info` and the storage attribute `unbounded`, we use
+	// partial or full storage info from storage.
+	let storage_info_traits = &def
+		.storages
+		.iter()
+		.map(|storage| {
+			if storage.unbounded || def.pallet_struct.without_storage_info.is_some() {
+				quote::quote_spanned!(storage_info_span => PartialStorageInfoTrait)
+			} else {
+				quote::quote_spanned!(storage_info_span => StorageInfoTrait)
+			}
+		})
+		.collect::<Vec<_>>();
+
+	let storage_info_methods = &def
+		.storages
+		.iter()
+		.map(|storage| {
+			if storage.unbounded || def.pallet_struct.without_storage_info.is_some() {
+				quote::quote_spanned!(storage_info_span => partial_storage_info)
+			} else {
+				quote::quote_spanned!(storage_info_span => storage_info)
+			}
+		})
+		.collect::<Vec<_>>();
+
+	let storage_info = quote::quote_spanned!(storage_info_span =>
+		impl<#type_impl_gen> #frame_support::traits::StorageInfoTrait
+			for #pallet_ident<#type_use_gen>
+			#storages_where_clauses
+		{
+			fn storage_info()
+				-> #frame_support::__private::sp_std::vec::Vec<#frame_support::traits::StorageInfo>
+			{
+				#[allow(unused_mut)]
+				let mut res = #frame_support::__private::sp_std::vec![];
+
+				#(
+					#(#storage_cfg_attrs)*
+					{
+						let mut storage_info = <
+							#storage_names<#type_use_gen>
+							as #frame_support::traits::#storage_info_traits
+						>::#storage_info_methods();
+						res.append(&mut storage_info);
+					}
+				)*
+
+				res
+			}
+		}
+	);
+
+	let (storage_version, current_storage_version_ty) =
+		if let Some(v) = def.pallet_struct.storage_version.as_ref() {
+			(quote::quote! { #v }, quote::quote! { #frame_support::traits::StorageVersion })
+		} else {
+			(
+				quote::quote! { core::default::Default::default() },
+				quote::quote! { #frame_support::traits::NoStorageVersionSet },
+			)
+		};
+
+	let whitelisted_storage_idents: Vec<syn::Ident> = def
+		.storages
+		.iter()
+		.filter_map(|s| s.whitelisted.then_some(s.ident.clone()))
+		.collect();
+
+	let whitelisted_storage_keys_impl = quote::quote![
+		use #frame_support::traits::{StorageInfoTrait, TrackedStorageKey, WhitelistedStorageKeys};
+		impl<#type_impl_gen> WhitelistedStorageKeys for #pallet_ident<#type_use_gen> #storages_where_clauses {
+			fn whitelisted_storage_keys() -> #frame_support::__private::sp_std::vec::Vec<TrackedStorageKey> {
+				use #frame_support::__private::sp_std::vec;
+				vec![#(
+					TrackedStorageKey::new(#whitelisted_storage_idents::<#type_use_gen>::hashed_key().to_vec())
+				),*]
+			}
+		}
+	];
+
+	quote::quote_spanned!(def.pallet_struct.attr_span =>
+		#pallet_error_metadata
+
+		/// Type alias to `Pallet`, to be used by `construct_runtime`.
+		///
+		/// Generated by `pallet` attribute macro.
+		#[deprecated(note = "use `Pallet` instead")]
+		#[allow(dead_code)]
+		pub type Module<#type_decl_gen> = #pallet_ident<#type_use_gen>;
+
+		// Implement `GetStorageVersion` for `Pallet`
+		impl<#type_impl_gen> #frame_support::traits::GetStorageVersion
+			for #pallet_ident<#type_use_gen>
+			#config_where_clause
+		{
+			type CurrentStorageVersion = #current_storage_version_ty;
+
+			fn current_storage_version() -> Self::CurrentStorageVersion {
+				#storage_version
+			}
+
+			fn on_chain_storage_version() -> #frame_support::traits::StorageVersion {
+				#frame_support::traits::StorageVersion::get::<Self>()
+			}
+		}
+
+		// Implement `OnGenesis` for `Pallet`
+		impl<#type_impl_gen> #frame_support::traits::OnGenesis
+			for #pallet_ident<#type_use_gen>
+			#config_where_clause
+		{
+			fn on_genesis() {
+				let storage_version: #frame_support::traits::StorageVersion = #storage_version;
+				storage_version.put::<Self>();
+			}
+		}
+
+		// Implement `PalletInfoAccess` for `Pallet`
+		impl<#type_impl_gen> #frame_support::traits::PalletInfoAccess
+			for #pallet_ident<#type_use_gen>
+			#config_where_clause
+		{
+			fn index() -> usize {
+				<
+					<T as #frame_system::Config>::PalletInfo as #frame_support::traits::PalletInfo
+				>::index::<Self>()
+					.expect("Pallet is part of the runtime because pallet `Config` trait is \
+						implemented by the runtime")
+			}
+
+			fn name() -> &'static str {
+				<
+					<T as #frame_system::Config>::PalletInfo as #frame_support::traits::PalletInfo
+				>::name::<Self>()
+					.expect("Pallet is part of the runtime because pallet `Config` trait is \
+						implemented by the runtime")
+			}
+
+			fn module_name() -> &'static str {
+				<
+					<T as #frame_system::Config>::PalletInfo as #frame_support::traits::PalletInfo
+				>::module_name::<Self>()
+					.expect("Pallet is part of the runtime because pallet `Config` trait is \
+						implemented by the runtime")
+			}
+
+			fn crate_version() -> #frame_support::traits::CrateVersion {
+				#frame_support::crate_to_crate_version!()
+			}
+		}
+
+		impl<#type_impl_gen> #frame_support::traits::PalletsInfoAccess
+			for #pallet_ident<#type_use_gen>
+			#config_where_clause
+		{
+			fn count() -> usize { 1 }
+			fn infos() -> #frame_support::__private::sp_std::vec::Vec<#frame_support::traits::PalletInfoData> {
+				use #frame_support::traits::PalletInfoAccess;
+				let item = #frame_support::traits::PalletInfoData {
+					index: Self::index(),
+					name: Self::name(),
+					module_name: Self::module_name(),
+					crate_version: Self::crate_version(),
+				};
+				#frame_support::__private::sp_std::vec![item]
+			}
+		}
+
+		#storage_info
+		#whitelisted_storage_keys_impl
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/storage.rs b/substrate/frame/support/procedural/src/pallet/expand/storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1a941f6cb3f5ca135081935c6b6bc21bc24bb289
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/storage.rs
@@ -0,0 +1,815 @@
+// 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::{
+	counter_prefix,
+	pallet::{
+		parse::storage::{Metadata, QueryKind, StorageDef, StorageGenerics},
+		Def,
+	},
+};
+use itertools::Itertools;
+use quote::ToTokens;
+use std::{collections::HashMap, ops::IndexMut};
+use syn::spanned::Spanned;
+
+/// Generate the prefix_ident related to the storage.
+/// prefix_ident is used for the prefix struct to be given to storage as first generic param.
+fn prefix_ident(storage: &StorageDef) -> syn::Ident {
+	let storage_ident = &storage.ident;
+	syn::Ident::new(&format!("_GeneratedPrefixForStorage{}", storage_ident), storage_ident.span())
+}
+
+/// Generate the counter_prefix_ident related to the storage.
+/// counter_prefix_ident is used for the prefix struct to be given to counted storage map.
+fn counter_prefix_ident(storage_ident: &syn::Ident) -> syn::Ident {
+	syn::Ident::new(
+		&format!("_GeneratedCounterPrefixForStorage{}", storage_ident),
+		storage_ident.span(),
+	)
+}
+
+/// Check for duplicated storage prefixes. This step is necessary since users can specify an
+/// alternative storage prefix using the #[pallet::storage_prefix] syntax, and we need to ensure
+/// that the prefix specified by the user is not a duplicate of an existing one.
+fn check_prefix_duplicates(
+	storage_def: &StorageDef,
+	// A hashmap of all already used prefix and their associated error if duplication
+	used_prefixes: &mut HashMap<String, syn::Error>,
+) -> syn::Result<()> {
+	let prefix = storage_def.prefix();
+	let dup_err = syn::Error::new(
+		storage_def.prefix_span(),
+		format!("Duplicate storage prefixes found for `{}`", prefix),
+	);
+
+	if let Some(other_dup_err) = used_prefixes.insert(prefix.clone(), dup_err.clone()) {
+		let mut err = dup_err;
+		err.combine(other_dup_err);
+		return Err(err)
+	}
+
+	if let Metadata::CountedMap { .. } = storage_def.metadata {
+		let counter_prefix = counter_prefix(&prefix);
+		let counter_dup_err = syn::Error::new(
+			storage_def.prefix_span(),
+			format!(
+				"Duplicate storage prefixes found for `{}`, used for counter associated to \
+				counted storage map",
+				counter_prefix,
+			),
+		);
+
+		if let Some(other_dup_err) = used_prefixes.insert(counter_prefix, counter_dup_err.clone()) {
+			let mut err = counter_dup_err;
+			err.combine(other_dup_err);
+			return Err(err)
+		}
+	}
+
+	Ok(())
+}
+
+pub struct ResultOnEmptyStructMetadata {
+	/// The Rust ident that is going to be used as the name of the OnEmpty struct.
+	pub name: syn::Ident,
+	/// The path to the error type being returned by the ResultQuery.
+	pub error_path: syn::Path,
+	/// The visibility of the OnEmpty struct.
+	pub visibility: syn::Visibility,
+	/// The type of the storage item.
+	pub value_ty: syn::Type,
+	/// The name of the pallet error enum variant that is going to be returned.
+	pub variant_name: syn::Ident,
+	/// The span used to report compilation errors about the OnEmpty struct.
+	pub span: proc_macro2::Span,
+}
+
+///
+/// * if generics are unnamed: replace the first generic `_` by the generated prefix structure
+/// * if generics are named: reorder the generic, remove their name, and add the missing ones.
+/// * Add `#[allow(type_alias_bounds)]`
+pub fn process_generics(def: &mut Def) -> syn::Result<Vec<ResultOnEmptyStructMetadata>> {
+	let frame_support = &def.frame_support;
+	let mut on_empty_struct_metadata = Vec::new();
+
+	for storage_def in def.storages.iter_mut() {
+		let item = &mut def.item.content.as_mut().expect("Checked by def").1[storage_def.index];
+
+		let typ_item = match item {
+			syn::Item::Type(t) => t,
+			_ => unreachable!("Checked by def"),
+		};
+
+		typ_item.attrs.push(syn::parse_quote!(#[allow(type_alias_bounds)]));
+
+		let typ_path = match &mut *typ_item.ty {
+			syn::Type::Path(p) => p,
+			_ => unreachable!("Checked by def"),
+		};
+
+		let args = match &mut typ_path.path.segments[0].arguments {
+			syn::PathArguments::AngleBracketed(args) => args,
+			_ => unreachable!("Checked by def"),
+		};
+
+		let prefix_ident = prefix_ident(storage_def);
+		let type_use_gen = if def.config.has_instance {
+			quote::quote_spanned!(storage_def.attr_span => T, I)
+		} else {
+			quote::quote_spanned!(storage_def.attr_span => T)
+		};
+
+		let default_query_kind: syn::Type =
+			syn::parse_quote!(#frame_support::storage::types::OptionQuery);
+		let mut default_on_empty = |value_ty: syn::Type| -> syn::Type {
+			if let Some(QueryKind::ResultQuery(error_path, variant_name)) =
+				storage_def.query_kind.as_ref()
+			{
+				let on_empty_ident =
+					quote::format_ident!("__Frame_Internal_Get{}Result", storage_def.ident);
+				on_empty_struct_metadata.push(ResultOnEmptyStructMetadata {
+					name: on_empty_ident.clone(),
+					visibility: storage_def.vis.clone(),
+					value_ty,
+					error_path: error_path.clone(),
+					variant_name: variant_name.clone(),
+					span: storage_def.attr_span,
+				});
+				return syn::parse_quote!(#on_empty_ident)
+			}
+			syn::parse_quote!(#frame_support::traits::GetDefault)
+		};
+		let default_max_values: syn::Type = syn::parse_quote!(#frame_support::traits::GetDefault);
+
+		let set_result_query_type_parameter = |query_type: &mut syn::Type| -> syn::Result<()> {
+			if let Some(QueryKind::ResultQuery(error_path, _)) = storage_def.query_kind.as_ref() {
+				if let syn::Type::Path(syn::TypePath { path: syn::Path { segments, .. }, .. }) =
+					query_type
+				{
+					if let Some(seg) = segments.last_mut() {
+						if let syn::PathArguments::AngleBracketed(
+							syn::AngleBracketedGenericArguments { args, .. },
+						) = &mut seg.arguments
+						{
+							args.clear();
+							args.push(syn::GenericArgument::Type(syn::parse_quote!(#error_path)));
+						}
+					}
+				} else {
+					let msg = format!(
+						"Invalid pallet::storage, unexpected type for query, expected ResultQuery \
+						with 1 type parameter, found `{}`",
+						query_type.to_token_stream().to_string()
+					);
+					return Err(syn::Error::new(query_type.span(), msg))
+				}
+			}
+			Ok(())
+		};
+
+		if let Some(named_generics) = storage_def.named_generics.clone() {
+			args.args.clear();
+			args.args.push(syn::parse_quote!( #prefix_ident<#type_use_gen> ));
+			match named_generics {
+				StorageGenerics::Value { value, query_kind, on_empty } => {
+					args.args.push(syn::GenericArgument::Type(value.clone()));
+					let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
+					set_result_query_type_parameter(&mut query_kind)?;
+					args.args.push(syn::GenericArgument::Type(query_kind));
+					let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
+					args.args.push(syn::GenericArgument::Type(on_empty));
+				},
+				StorageGenerics::Map { hasher, key, value, query_kind, on_empty, max_values } |
+				StorageGenerics::CountedMap {
+					hasher,
+					key,
+					value,
+					query_kind,
+					on_empty,
+					max_values,
+				} => {
+					args.args.push(syn::GenericArgument::Type(hasher));
+					args.args.push(syn::GenericArgument::Type(key));
+					args.args.push(syn::GenericArgument::Type(value.clone()));
+					let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
+					set_result_query_type_parameter(&mut query_kind)?;
+					args.args.push(syn::GenericArgument::Type(query_kind));
+					let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
+					args.args.push(syn::GenericArgument::Type(on_empty));
+					let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
+					args.args.push(syn::GenericArgument::Type(max_values));
+				},
+				StorageGenerics::DoubleMap {
+					hasher1,
+					key1,
+					hasher2,
+					key2,
+					value,
+					query_kind,
+					on_empty,
+					max_values,
+				} => {
+					args.args.push(syn::GenericArgument::Type(hasher1));
+					args.args.push(syn::GenericArgument::Type(key1));
+					args.args.push(syn::GenericArgument::Type(hasher2));
+					args.args.push(syn::GenericArgument::Type(key2));
+					args.args.push(syn::GenericArgument::Type(value.clone()));
+					let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
+					set_result_query_type_parameter(&mut query_kind)?;
+					args.args.push(syn::GenericArgument::Type(query_kind));
+					let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
+					args.args.push(syn::GenericArgument::Type(on_empty));
+					let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
+					args.args.push(syn::GenericArgument::Type(max_values));
+				},
+				StorageGenerics::NMap { keygen, value, query_kind, on_empty, max_values } |
+				StorageGenerics::CountedNMap {
+					keygen,
+					value,
+					query_kind,
+					on_empty,
+					max_values,
+				} => {
+					args.args.push(syn::GenericArgument::Type(keygen));
+					args.args.push(syn::GenericArgument::Type(value.clone()));
+					let mut query_kind = query_kind.unwrap_or_else(|| default_query_kind.clone());
+					set_result_query_type_parameter(&mut query_kind)?;
+					args.args.push(syn::GenericArgument::Type(query_kind));
+					let on_empty = on_empty.unwrap_or_else(|| default_on_empty(value));
+					args.args.push(syn::GenericArgument::Type(on_empty));
+					let max_values = max_values.unwrap_or_else(|| default_max_values.clone());
+					args.args.push(syn::GenericArgument::Type(max_values));
+				},
+			}
+		} else {
+			args.args[0] = syn::parse_quote!( #prefix_ident<#type_use_gen> );
+
+			let (value_idx, query_idx, on_empty_idx) = match storage_def.metadata {
+				Metadata::Value { .. } => (1, 2, 3),
+				Metadata::NMap { .. } | Metadata::CountedNMap { .. } => (2, 3, 4),
+				Metadata::Map { .. } | Metadata::CountedMap { .. } => (3, 4, 5),
+				Metadata::DoubleMap { .. } => (5, 6, 7),
+			};
+
+			if storage_def.use_default_hasher {
+				let hasher_indices: Vec<usize> = match storage_def.metadata {
+					Metadata::Map { .. } | Metadata::CountedMap { .. } => vec![1],
+					Metadata::DoubleMap { .. } => vec![1, 3],
+					_ => vec![],
+				};
+				for hasher_idx in hasher_indices {
+					args.args[hasher_idx] = syn::GenericArgument::Type(
+						syn::parse_quote!(#frame_support::Blake2_128Concat),
+					);
+				}
+			}
+
+			if query_idx < args.args.len() {
+				if let syn::GenericArgument::Type(query_kind) = args.args.index_mut(query_idx) {
+					set_result_query_type_parameter(query_kind)?;
+				}
+			} else if let Some(QueryKind::ResultQuery(error_path, _)) =
+				storage_def.query_kind.as_ref()
+			{
+				args.args.push(syn::GenericArgument::Type(syn::parse_quote!(#error_path)))
+			}
+
+			// Here, we only need to check if OnEmpty is *not* specified, and if so, then we have to
+			// generate a default OnEmpty struct for it.
+			if on_empty_idx >= args.args.len() &&
+				matches!(storage_def.query_kind.as_ref(), Some(QueryKind::ResultQuery(_, _)))
+			{
+				let value_ty = match args.args[value_idx].clone() {
+					syn::GenericArgument::Type(ty) => ty,
+					_ => unreachable!(),
+				};
+				let on_empty = default_on_empty(value_ty);
+				args.args.push(syn::GenericArgument::Type(on_empty));
+			}
+		}
+	}
+
+	Ok(on_empty_struct_metadata)
+}
+
+fn augment_final_docs(def: &mut Def) {
+	// expand the docs with a new line showing the storage type (value, map, double map, etc), and
+	// the key/value type(s).
+	let mut push_string_literal = |doc_line: &str, storage: &mut StorageDef| {
+		let item = &mut def.item.content.as_mut().expect("Checked by def").1[storage.index];
+		let typ_item = match item {
+			syn::Item::Type(t) => t,
+			_ => unreachable!("Checked by def"),
+		};
+		typ_item.attrs.push(syn::parse_quote!(#[doc = ""]));
+		typ_item.attrs.push(syn::parse_quote!(#[doc = #doc_line]));
+	};
+	def.storages.iter_mut().for_each(|storage| match &storage.metadata {
+		Metadata::Value { value } => {
+			let doc_line = format!(
+				"Storage type is [`StorageValue`] with value type `{}`.",
+				value.to_token_stream()
+			);
+			push_string_literal(&doc_line, storage);
+		},
+		Metadata::Map { key, value } => {
+			let doc_line = format!(
+				"Storage type is [`StorageMap`] with key type `{}` and value type `{}`.",
+				key.to_token_stream(),
+				value.to_token_stream()
+			);
+			push_string_literal(&doc_line, storage);
+		},
+		Metadata::DoubleMap { key1, key2, value } => {
+			let doc_line = format!(
+				"Storage type is [`StorageDoubleMap`] with key1 type {}, key2 type {} and value type {}.",
+				key1.to_token_stream(),
+				key2.to_token_stream(),
+				value.to_token_stream()
+			);
+			push_string_literal(&doc_line, storage);
+		},
+		Metadata::NMap { keys, value, .. } => {
+			let doc_line = format!(
+				"Storage type is [`StorageNMap`] with keys type ({}) and value type {}.",
+				keys.iter()
+					.map(|k| k.to_token_stream().to_string())
+					.collect::<Vec<_>>()
+					.join(", "),
+				value.to_token_stream()
+			);
+			push_string_literal(&doc_line, storage);
+		},
+		Metadata::CountedNMap { keys, value, .. } => {
+			let doc_line = format!(
+				"Storage type is [`CountedStorageNMap`] with keys type ({}) and value type {}.",
+				keys.iter()
+					.map(|k| k.to_token_stream().to_string())
+					.collect::<Vec<_>>()
+					.join(", "),
+				value.to_token_stream()
+			);
+			push_string_literal(&doc_line, storage);
+		},
+		Metadata::CountedMap { key, value } => {
+			let doc_line = format!(
+				"Storage type is [`CountedStorageMap`] with key type {} and value type {}.",
+				key.to_token_stream(),
+				value.to_token_stream()
+			);
+			push_string_literal(&doc_line, storage);
+		},
+	});
+}
+
+///
+/// * generate StoragePrefix structs (e.g. for a storage `MyStorage` a struct with the name
+///   `_GeneratedPrefixForStorage$NameOfStorage` is generated) and implements StorageInstance trait.
+/// * if generics are unnamed: replace the first generic `_` by the generated prefix structure
+/// * if generics are named: reorder the generic, remove their name, and add the missing ones.
+/// * Add `#[allow(type_alias_bounds)]` on storages type alias
+/// * generate metadatas
+pub fn expand_storages(def: &mut Def) -> proc_macro2::TokenStream {
+	let on_empty_struct_metadata = match process_generics(def) {
+		Ok(idents) => idents,
+		Err(e) => return e.into_compile_error(),
+	};
+
+	augment_final_docs(def);
+
+	// Check for duplicate prefixes
+	let mut prefix_set = HashMap::new();
+	let mut errors = def
+		.storages
+		.iter()
+		.filter_map(|storage_def| check_prefix_duplicates(storage_def, &mut prefix_set).err());
+	if let Some(mut final_error) = errors.next() {
+		errors.for_each(|error| final_error.combine(error));
+		return final_error.into_compile_error()
+	}
+
+	let frame_support = &def.frame_support;
+	let frame_system = &def.frame_system;
+	let pallet_ident = &def.pallet_struct.pallet;
+
+	let entries_builder = def.storages.iter().map(|storage| {
+		let no_docs = vec![];
+		let docs = if cfg!(feature = "no-metadata-docs") { &no_docs } else { &storage.docs };
+
+		let ident = &storage.ident;
+		let gen = &def.type_use_generics(storage.attr_span);
+		let full_ident = quote::quote_spanned!(storage.attr_span => #ident<#gen> );
+
+		let cfg_attrs = &storage.cfg_attrs;
+
+		quote::quote_spanned!(storage.attr_span =>
+			#(#cfg_attrs)*
+			{
+				<#full_ident as #frame_support::storage::StorageEntryMetadataBuilder>::build_metadata(
+					#frame_support::__private::sp_std::vec![
+						#( #docs, )*
+					],
+					&mut entries,
+				);
+			}
+		)
+	});
+
+	let getters = def.storages.iter().map(|storage| {
+		if let Some(getter) = &storage.getter {
+			let completed_where_clause =
+				super::merge_where_clauses(&[&storage.where_clause, &def.config.where_clause]);
+
+			let ident = &storage.ident;
+			let gen = &def.type_use_generics(storage.attr_span);
+			let type_impl_gen = &def.type_impl_generics(storage.attr_span);
+			let type_use_gen = &def.type_use_generics(storage.attr_span);
+			let full_ident = quote::quote_spanned!(storage.attr_span => #ident<#gen> );
+
+			let cfg_attrs = &storage.cfg_attrs;
+
+			// If the storage item is public, just link to it rather than copy-pasting the docs.
+			let getter_doc_line = if matches!(storage.vis, syn::Visibility::Public(_)) {
+				format!("An auto-generated getter for [`{}`].", storage.ident)
+			} else {
+				storage.docs.iter().map(|d| d.into_token_stream().to_string()).join("\n")
+			};
+
+			match &storage.metadata {
+				Metadata::Value { value } => {
+					let query = match storage.query_kind.as_ref().expect("Checked by def") {
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
+						QueryKind::ResultQuery(error_path, _) => {
+							quote::quote_spanned!(storage.attr_span =>
+								Result<#value, #error_path>
+							)
+						},
+						QueryKind::ValueQuery => quote::quote!(#value),
+					};
+					quote::quote_spanned!(storage.attr_span =>
+						#(#cfg_attrs)*
+						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
+							#[doc = #getter_doc_line]
+							pub fn #getter() -> #query {
+								<
+									#full_ident as #frame_support::storage::StorageValue<#value>
+								>::get()
+							}
+						}
+					)
+				},
+				Metadata::Map { key, value } => {
+					let query = match storage.query_kind.as_ref().expect("Checked by def") {
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
+						QueryKind::ResultQuery(error_path, _) => {
+							quote::quote_spanned!(storage.attr_span =>
+								Result<#value, #error_path>
+							)
+						},
+						QueryKind::ValueQuery => quote::quote!(#value),
+					};
+					quote::quote_spanned!(storage.attr_span =>
+						#(#cfg_attrs)*
+						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
+							#[doc = #getter_doc_line]
+							pub fn #getter<KArg>(k: KArg) -> #query where
+								KArg: #frame_support::__private::codec::EncodeLike<#key>,
+							{
+								<
+									#full_ident as #frame_support::storage::StorageMap<#key, #value>
+								>::get(k)
+							}
+						}
+					)
+				},
+				Metadata::CountedMap { key, value } => {
+					let query = match storage.query_kind.as_ref().expect("Checked by def") {
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
+						QueryKind::ResultQuery(error_path, _) => {
+							quote::quote_spanned!(storage.attr_span =>
+								Result<#value, #error_path>
+							)
+						},
+						QueryKind::ValueQuery => quote::quote!(#value),
+					};
+					quote::quote_spanned!(storage.attr_span =>
+						#(#cfg_attrs)*
+						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
+							#[doc = #getter_doc_line]
+							pub fn #getter<KArg>(k: KArg) -> #query where
+								KArg: #frame_support::__private::codec::EncodeLike<#key>,
+							{
+								// NOTE: we can't use any trait here because CountedStorageMap
+								// doesn't implement any.
+								<#full_ident>::get(k)
+							}
+						}
+					)
+				},
+				Metadata::DoubleMap { key1, key2, value } => {
+					let query = match storage.query_kind.as_ref().expect("Checked by def") {
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
+						QueryKind::ResultQuery(error_path, _) => {
+							quote::quote_spanned!(storage.attr_span =>
+								Result<#value, #error_path>
+							)
+						},
+						QueryKind::ValueQuery => quote::quote!(#value),
+					};
+					quote::quote_spanned!(storage.attr_span =>
+						#(#cfg_attrs)*
+						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
+							#[doc = #getter_doc_line]
+							pub fn #getter<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> #query where
+								KArg1: #frame_support::__private::codec::EncodeLike<#key1>,
+								KArg2: #frame_support::__private::codec::EncodeLike<#key2>,
+							{
+								<
+									#full_ident as
+									#frame_support::storage::StorageDoubleMap<#key1, #key2, #value>
+								>::get(k1, k2)
+							}
+						}
+					)
+				},
+				Metadata::NMap { keygen, value, .. } => {
+					let query = match storage.query_kind.as_ref().expect("Checked by def") {
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
+						QueryKind::ResultQuery(error_path, _) => {
+							quote::quote_spanned!(storage.attr_span =>
+								Result<#value, #error_path>
+							)
+						},
+						QueryKind::ValueQuery => quote::quote!(#value),
+					};
+					quote::quote_spanned!(storage.attr_span =>
+						#(#cfg_attrs)*
+						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
+							#[doc = #getter_doc_line]
+							pub fn #getter<KArg>(key: KArg) -> #query
+							where
+								KArg: #frame_support::storage::types::EncodeLikeTuple<
+									<#keygen as #frame_support::storage::types::KeyGenerator>::KArg
+								>
+									+ #frame_support::storage::types::TupleToEncodedIter,
+							{
+								<
+									#full_ident as
+									#frame_support::storage::StorageNMap<#keygen, #value>
+								>::get(key)
+							}
+						}
+					)
+				},
+				Metadata::CountedNMap { keygen, value, .. } => {
+					let query = match storage.query_kind.as_ref().expect("Checked by def") {
+						QueryKind::OptionQuery => quote::quote_spanned!(storage.attr_span =>
+							Option<#value>
+						),
+						QueryKind::ResultQuery(error_path, _) => {
+							quote::quote_spanned!(storage.attr_span =>
+								Result<#value, #error_path>
+							)
+						},
+						QueryKind::ValueQuery => quote::quote!(#value),
+					};
+					quote::quote_spanned!(storage.attr_span =>
+						#(#cfg_attrs)*
+						impl<#type_impl_gen> #pallet_ident<#type_use_gen> #completed_where_clause {
+							#[doc = #getter_doc_line]
+							pub fn #getter<KArg>(key: KArg) -> #query
+							where
+								KArg: #frame_support::storage::types::EncodeLikeTuple<
+									<#keygen as #frame_support::storage::types::KeyGenerator>::KArg
+								>
+									+ #frame_support::storage::types::TupleToEncodedIter,
+							{
+								// NOTE: we can't use any trait here because CountedStorageNMap
+								// doesn't implement any.
+								<#full_ident>::get(key)
+							}
+						}
+					)
+				},
+			}
+		} else {
+			Default::default()
+		}
+	});
+
+	let prefix_structs = def.storages.iter().map(|storage_def| {
+		let type_impl_gen = &def.type_impl_generics(storage_def.attr_span);
+		let type_use_gen = &def.type_use_generics(storage_def.attr_span);
+		let prefix_struct_ident = prefix_ident(storage_def);
+		let prefix_struct_vis = &storage_def.vis;
+		let prefix_struct_const = storage_def.prefix();
+		let config_where_clause = &def.config.where_clause;
+
+		let cfg_attrs = &storage_def.cfg_attrs;
+
+		let maybe_counter = match storage_def.metadata {
+			Metadata::CountedMap { .. } => {
+				let counter_prefix_struct_ident = counter_prefix_ident(&storage_def.ident);
+				let counter_prefix_struct_const = counter_prefix(&prefix_struct_const);
+				quote::quote_spanned!(storage_def.attr_span =>
+					#(#cfg_attrs)*
+					#[doc(hidden)]
+					#prefix_struct_vis struct #counter_prefix_struct_ident<#type_use_gen>(
+						core::marker::PhantomData<(#type_use_gen,)>
+					);
+					#(#cfg_attrs)*
+					impl<#type_impl_gen> #frame_support::traits::StorageInstance
+						for #counter_prefix_struct_ident<#type_use_gen>
+						#config_where_clause
+					{
+						fn pallet_prefix() -> &'static str {
+							<
+								<T as #frame_system::Config>::PalletInfo
+								as #frame_support::traits::PalletInfo
+							>::name::<Pallet<#type_use_gen>>()
+								.expect("No name found for the pallet in the runtime! This usually means that the pallet wasn't added to `construct_runtime!`.")
+						}
+						const STORAGE_PREFIX: &'static str = #counter_prefix_struct_const;
+					}
+					#(#cfg_attrs)*
+					impl<#type_impl_gen> #frame_support::storage::types::CountedStorageMapInstance
+						for #prefix_struct_ident<#type_use_gen>
+						#config_where_clause
+					{
+						type CounterPrefix = #counter_prefix_struct_ident<#type_use_gen>;
+					}
+				)
+			},
+			Metadata::CountedNMap { .. } => {
+				let counter_prefix_struct_ident = counter_prefix_ident(&storage_def.ident);
+				let counter_prefix_struct_const = counter_prefix(&prefix_struct_const);
+				quote::quote_spanned!(storage_def.attr_span =>
+					#(#cfg_attrs)*
+					#[doc(hidden)]
+					#prefix_struct_vis struct #counter_prefix_struct_ident<#type_use_gen>(
+						core::marker::PhantomData<(#type_use_gen,)>
+					);
+					#(#cfg_attrs)*
+					impl<#type_impl_gen> #frame_support::traits::StorageInstance
+						for #counter_prefix_struct_ident<#type_use_gen>
+						#config_where_clause
+					{
+						fn pallet_prefix() -> &'static str {
+							<
+								<T as #frame_system::Config>::PalletInfo
+								as #frame_support::traits::PalletInfo
+							>::name::<Pallet<#type_use_gen>>()
+								.expect("No name found for the pallet in the runtime! This usually means that the pallet wasn't added to `construct_runtime!`.")
+						}
+						const STORAGE_PREFIX: &'static str = #counter_prefix_struct_const;
+					}
+					#(#cfg_attrs)*
+					impl<#type_impl_gen> #frame_support::storage::types::CountedStorageNMapInstance
+						for #prefix_struct_ident<#type_use_gen>
+						#config_where_clause
+					{
+						type CounterPrefix = #counter_prefix_struct_ident<#type_use_gen>;
+					}
+				)
+			},
+			_ => proc_macro2::TokenStream::default(),
+		};
+
+		quote::quote_spanned!(storage_def.attr_span =>
+			#maybe_counter
+
+			#(#cfg_attrs)*
+			#[doc(hidden)]
+			#prefix_struct_vis struct #prefix_struct_ident<#type_use_gen>(
+				core::marker::PhantomData<(#type_use_gen,)>
+			);
+			#(#cfg_attrs)*
+			impl<#type_impl_gen> #frame_support::traits::StorageInstance
+				for #prefix_struct_ident<#type_use_gen>
+				#config_where_clause
+			{
+				fn pallet_prefix() -> &'static str {
+					<
+						<T as #frame_system::Config>::PalletInfo
+						as #frame_support::traits::PalletInfo
+					>::name::<Pallet<#type_use_gen>>()
+						.expect("No name found for the pallet in the runtime! This usually means that the pallet wasn't added to `construct_runtime!`.")
+				}
+				const STORAGE_PREFIX: &'static str = #prefix_struct_const;
+			}
+		)
+	});
+
+	let on_empty_structs = on_empty_struct_metadata.into_iter().map(|metadata| {
+		use crate::pallet::parse::GenericKind;
+		use syn::{GenericArgument, Path, PathArguments, PathSegment, Type, TypePath};
+
+		let ResultOnEmptyStructMetadata {
+			name,
+			visibility,
+			value_ty,
+			error_path,
+			variant_name,
+			span,
+		} = metadata;
+
+		let generic_kind = match error_path.segments.last() {
+			Some(PathSegment { arguments: PathArguments::AngleBracketed(args), .. }) => {
+				let (has_config, has_instance) =
+					args.args.iter().fold((false, false), |(has_config, has_instance), arg| {
+						match arg {
+							GenericArgument::Type(Type::Path(TypePath {
+								path: Path { segments, .. },
+								..
+							})) => {
+								let maybe_config =
+									segments.first().map_or(false, |seg| seg.ident == "T");
+								let maybe_instance =
+									segments.first().map_or(false, |seg| seg.ident == "I");
+
+								(has_config || maybe_config, has_instance || maybe_instance)
+							},
+							_ => (has_config, has_instance),
+						}
+					});
+				GenericKind::from_gens(has_config, has_instance).unwrap_or(GenericKind::None)
+			},
+			_ => GenericKind::None,
+		};
+		let type_impl_gen = generic_kind.type_impl_gen(proc_macro2::Span::call_site());
+		let config_where_clause = &def.config.where_clause;
+
+		quote::quote_spanned!(span =>
+			#[doc(hidden)]
+			#[allow(non_camel_case_types)]
+			#visibility struct #name;
+
+			impl<#type_impl_gen> #frame_support::traits::Get<Result<#value_ty, #error_path>>
+				for #name
+				#config_where_clause
+			{
+				fn get() -> Result<#value_ty, #error_path> {
+					Err(<#error_path>::#variant_name)
+				}
+			}
+		)
+	});
+
+	let mut where_clauses = vec![&def.config.where_clause];
+	where_clauses.extend(def.storages.iter().map(|storage| &storage.where_clause));
+	let completed_where_clause = super::merge_where_clauses(&where_clauses);
+	let type_impl_gen = &def.type_impl_generics(proc_macro2::Span::call_site());
+	let type_use_gen = &def.type_use_generics(proc_macro2::Span::call_site());
+
+	quote::quote!(
+		impl<#type_impl_gen> #pallet_ident<#type_use_gen>
+			#completed_where_clause
+		{
+			#[doc(hidden)]
+			pub fn storage_metadata() -> #frame_support::__private::metadata_ir::PalletStorageMetadataIR {
+				#frame_support::__private::metadata_ir::PalletStorageMetadataIR {
+					prefix: <
+						<T as #frame_system::Config>::PalletInfo as
+						#frame_support::traits::PalletInfo
+					>::name::<#pallet_ident<#type_use_gen>>()
+						.expect("No name found for the pallet in the runtime! This usually means that the pallet wasn't added to `construct_runtime!`."),
+					entries: {
+						#[allow(unused_mut)]
+						let mut entries = #frame_support::__private::sp_std::vec![];
+						#( #entries_builder )*
+						entries
+					},
+				}
+			}
+		}
+
+		#( #getters )*
+		#( #prefix_structs )*
+		#( #on_empty_structs )*
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/store_trait.rs b/substrate/frame/support/procedural/src/pallet/expand/store_trait.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6635adc988157361a1478a5ec06589f7988b9676
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/store_trait.rs
@@ -0,0 +1,67 @@
+// 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::pallet::Def;
+use syn::spanned::Spanned;
+
+/// If attribute `#[pallet::generate_store(..)]` is defined then:
+/// * generate Store trait with all storages,
+/// * implement Store trait for Pallet.
+pub fn expand_store_trait(def: &mut Def) -> proc_macro2::TokenStream {
+	let (trait_vis, trait_store, attribute_span) =
+		if let Some(store) = &def.pallet_struct.store { store } else { return Default::default() };
+
+	let type_impl_gen = &def.type_impl_generics(trait_store.span());
+	let type_use_gen = &def.type_use_generics(trait_store.span());
+	let pallet_ident = &def.pallet_struct.pallet;
+
+	let mut where_clauses = vec![&def.config.where_clause];
+	where_clauses.extend(def.storages.iter().map(|storage| &storage.where_clause));
+	let completed_where_clause = super::merge_where_clauses(&where_clauses);
+
+	let storage_names = &def.storages.iter().map(|storage| &storage.ident).collect::<Vec<_>>();
+	let storage_cfg_attrs =
+		&def.storages.iter().map(|storage| &storage.cfg_attrs).collect::<Vec<_>>();
+	let warnig_struct_name = syn::Ident::new("Store", *attribute_span);
+	let warning: syn::ItemStruct = syn::parse_quote!(
+		#[deprecated(note = r"
+		Use of `#[pallet::generate_store(pub(super) trait Store)]` will be removed after July 2023.
+		Check https://github.com/paritytech/substrate/pull/13535 for more details.")]
+		struct #warnig_struct_name;
+	);
+
+	quote::quote_spanned!(trait_store.span() =>
+		const _:() = {
+			#warning
+			const _: Option<#warnig_struct_name> = None;
+		};
+		#trait_vis trait #trait_store {
+			#(
+				#(#storage_cfg_attrs)*
+				type #storage_names;
+			)*
+		}
+		impl<#type_impl_gen> #trait_store for #pallet_ident<#type_use_gen>
+			#completed_where_clause
+		{
+			#(
+				#(#storage_cfg_attrs)*
+				type #storage_names = #storage_names<#type_use_gen>;
+			)*
+		}
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/tt_default_parts.rs b/substrate/frame/support/procedural/src/pallet/expand/tt_default_parts.rs
new file mode 100644
index 0000000000000000000000000000000000000000..86db56c776dfefbdd393ae090e59ed11472456c1
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/tt_default_parts.rs
@@ -0,0 +1,142 @@
+// 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::{
+	pallet::{CompositeKeyword, Def},
+	COUNTER,
+};
+use syn::spanned::Spanned;
+
+/// Generate the `tt_default_parts` macro.
+pub fn expand_tt_default_parts(def: &mut Def) -> proc_macro2::TokenStream {
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+	let default_parts_unique_id =
+		syn::Ident::new(&format!("__tt_default_parts_{}", count), def.item.span());
+	let extra_parts_unique_id =
+		syn::Ident::new(&format!("__tt_extra_parts_{}", count), def.item.span());
+
+	let call_part = def.call.as_ref().map(|_| quote::quote!(Call,));
+
+	let storage_part = (!def.storages.is_empty()).then(|| quote::quote!(Storage,));
+
+	let event_part = def.event.as_ref().map(|event| {
+		let gen = event.gen_kind.is_generic().then(|| quote::quote!( <T> ));
+		quote::quote!( Event #gen , )
+	});
+
+	let error_part = def.error.as_ref().map(|_| quote::quote!(Error<T>,));
+
+	let origin_part = def.origin.as_ref().map(|origin| {
+		let gen = origin.is_generic.then(|| quote::quote!( <T> ));
+		quote::quote!( Origin #gen , )
+	});
+
+	let config_part = def.genesis_config.as_ref().map(|genesis_config| {
+		let gen = genesis_config.gen_kind.is_generic().then(|| quote::quote!( <T> ));
+		quote::quote!( Config #gen , )
+	});
+
+	let inherent_part = def.inherent.as_ref().map(|_| quote::quote!(Inherent,));
+
+	let validate_unsigned_part =
+		def.validate_unsigned.as_ref().map(|_| quote::quote!(ValidateUnsigned,));
+
+	let freeze_reason_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::FreezeReason(_)))
+		.then_some(quote::quote!(FreezeReason,));
+
+	let hold_reason_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::HoldReason(_)))
+		.then_some(quote::quote!(HoldReason,));
+
+	let lock_id_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::LockId(_)))
+		.then_some(quote::quote!(LockId,));
+
+	let slash_reason_part = def
+		.composites
+		.iter()
+		.any(|c| matches!(c.composite_keyword, CompositeKeyword::SlashReason(_)))
+		.then_some(quote::quote!(SlashReason,));
+
+	quote::quote!(
+		// This macro follows the conventions as laid out by the `tt-call` crate. It does not
+		// accept any arguments and simply returns the pallet parts, separated by commas, then
+		// wrapped inside of braces and finally prepended with double colons, to the caller inside
+		// of a key named `tokens`.
+		//
+		// We need to accept a frame_support argument here, because this macro gets expanded on the
+		// crate that called the `construct_runtime!` macro, and said crate may have renamed
+		// frame-support, and so we need to pass in the frame-support path that said crate
+		// recognizes.
+		#[macro_export]
+		#[doc(hidden)]
+		macro_rules! #default_parts_unique_id {
+			{
+				$caller:tt
+				frame_support = [{ $($frame_support:ident)::* }]
+			} => {
+				$($frame_support)*::__private::tt_return! {
+					$caller
+					tokens = [{
+						expanded::{
+							Pallet, #call_part #storage_part #event_part #error_part #origin_part #config_part
+							#inherent_part #validate_unsigned_part #freeze_reason_part
+							#hold_reason_part #lock_id_part #slash_reason_part
+						}
+					}]
+				}
+			};
+		}
+
+		pub use #default_parts_unique_id as tt_default_parts;
+
+
+		// This macro is similar to the `tt_default_parts!`. It expands the pallets thare are declared
+		// explicitly (`System: frame_system::{Pallet, Call}`) with extra parts.
+		//
+		// For example, after expansion an explicit pallet would look like:
+		// `System: expanded::{Error} ::{Pallet, Call}`.
+		//
+		// The `expanded` keyword is a marker of the final state of the `construct_runtime!`.
+		#[macro_export]
+		#[doc(hidden)]
+		macro_rules! #extra_parts_unique_id {
+			{
+				$caller:tt
+				frame_support = [{ $($frame_support:ident)::* }]
+			} => {
+				$($frame_support)*::__private::tt_return! {
+					$caller
+					tokens = [{
+						expanded::{
+							#error_part
+						}
+					}]
+				}
+			};
+		}
+
+		pub use #extra_parts_unique_id as tt_extra_parts;
+	)
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/type_value.rs b/substrate/frame/support/procedural/src/pallet/expand/type_value.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5dc6309c074a6ee296e5defd7d7d8af9cc02a4e9
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/type_value.rs
@@ -0,0 +1,77 @@
+// 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::pallet::Def;
+
+///
+/// * Generate the struct
+/// * implement the `Get<..>` on it
+/// * Rename the name of the function to internal name
+pub fn expand_type_values(def: &mut Def) -> proc_macro2::TokenStream {
+	let mut expand = quote::quote!();
+	let frame_support = &def.frame_support;
+
+	for type_value in &def.type_values {
+		let fn_name_str = &type_value.ident.to_string();
+		let fn_name_snakecase = inflector::cases::snakecase::to_snake_case(fn_name_str);
+		let fn_ident_renamed = syn::Ident::new(
+			&format!("__type_value_for_{}", fn_name_snakecase),
+			type_value.ident.span(),
+		);
+
+		let type_value_item = {
+			let item = &mut def.item.content.as_mut().expect("Checked by def").1[type_value.index];
+			if let syn::Item::Fn(item) = item {
+				item
+			} else {
+				unreachable!("Checked by error parser")
+			}
+		};
+
+		// Rename the type_value function name
+		type_value_item.sig.ident = fn_ident_renamed.clone();
+
+		let vis = &type_value.vis;
+		let ident = &type_value.ident;
+		let type_ = &type_value.type_;
+		let where_clause = &type_value.where_clause;
+
+		let (struct_impl_gen, struct_use_gen) = if type_value.is_generic {
+			(
+				def.type_impl_generics(type_value.attr_span),
+				def.type_use_generics(type_value.attr_span),
+			)
+		} else {
+			(Default::default(), Default::default())
+		};
+
+		let docs = &type_value.docs;
+
+		expand.extend(quote::quote_spanned!(type_value.attr_span =>
+			#( #[doc = #docs] )*
+			#vis struct #ident<#struct_use_gen>(core::marker::PhantomData<((), #struct_use_gen)>);
+			impl<#struct_impl_gen> #frame_support::traits::Get<#type_> for #ident<#struct_use_gen>
+			#where_clause
+			{
+				fn get() -> #type_ {
+					#fn_ident_renamed::<#struct_use_gen>()
+				}
+			}
+		));
+	}
+	expand
+}
diff --git a/substrate/frame/support/procedural/src/pallet/expand/validate_unsigned.rs b/substrate/frame/support/procedural/src/pallet/expand/validate_unsigned.rs
new file mode 100644
index 0000000000000000000000000000000000000000..87699558517127af6201eeffca6ee5be988519ed
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/expand/validate_unsigned.rs
@@ -0,0 +1,56 @@
+// 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::{pallet::Def, COUNTER};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{spanned::Spanned, Ident};
+
+pub fn expand_validate_unsigned(def: &mut Def) -> TokenStream {
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+	let macro_ident =
+		Ident::new(&format!("__is_validate_unsigned_part_defined_{}", count), def.item.span());
+
+	let maybe_compile_error = if def.validate_unsigned.is_none() {
+		quote! {
+			compile_error!(concat!(
+				"`",
+				stringify!($pallet_name),
+				"` does not have #[pallet::validate_unsigned] defined, perhaps you should \
+				remove `ValidateUnsigned` from construct_runtime?",
+			));
+		}
+	} else {
+		TokenStream::new()
+	};
+
+	quote! {
+		#[doc(hidden)]
+		pub mod __substrate_validate_unsigned_check {
+			#[macro_export]
+			#[doc(hidden)]
+			macro_rules! #macro_ident {
+				($pallet_name:ident) => {
+					#maybe_compile_error
+				}
+			}
+
+			#[doc(hidden)]
+			pub use #macro_ident as is_validate_unsigned_part_defined;
+		}
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/mod.rs b/substrate/frame/support/procedural/src/pallet/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3618711051d7fe5649f883a5b95708d47475e5a4
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/mod.rs
@@ -0,0 +1,61 @@
+// 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.
+
+//! Implementation for pallet attribute macro.
+//!
+//! General workflow:
+//! 1 - parse all pallet attributes:
+//!   This step remove all attributes `#[pallet::*]` from the ItemMod and build the `Def` struct
+//!   which holds the ItemMod without `#[pallet::*]` and information given by those attributes
+//! 2 - expand from the parsed information
+//!   This step will modify the ItemMod by adding some derive attributes or phantom data variants
+//!   to user defined types. And also crate new types and implement block.
+
+mod expand;
+mod parse;
+
+pub use parse::{composite::keyword::CompositeKeyword, Def};
+use syn::spanned::Spanned;
+
+mod keyword {
+	syn::custom_keyword!(dev_mode);
+}
+
+pub fn pallet(
+	attr: proc_macro::TokenStream,
+	item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+	let mut dev_mode = false;
+	if !attr.is_empty() {
+		if let Ok(_) = syn::parse::<keyword::dev_mode>(attr.clone()) {
+			dev_mode = true;
+		} else {
+			let msg = "Invalid pallet macro call: unexpected attribute. Macro call must be \
+				bare, such as `#[frame_support::pallet]` or `#[pallet]`, or must specify the \
+				`dev_mode` attribute, such as `#[frame_support::pallet(dev_mode)]` or \
+				#[pallet(dev_mode)].";
+			let span = proc_macro2::TokenStream::from(attr).span();
+			return syn::Error::new(span, msg).to_compile_error().into()
+		}
+	}
+
+	let item = syn::parse_macro_input!(item as syn::ItemMod);
+	match parse::Def::try_from(item, dev_mode) {
+		Ok(def) => expand::expand(def).into(),
+		Err(e) => e.to_compile_error().into(),
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/call.rs b/substrate/frame/support/procedural/src/pallet/parse/call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..90631f264b92aba30a60059f0d992583b6253938
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/call.rs
@@ -0,0 +1,351 @@
+// 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::{helper, InheritedCallWeightAttr};
+use frame_support_procedural_tools::get_doc_literals;
+use quote::ToTokens;
+use std::collections::HashMap;
+use syn::spanned::Spanned;
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(Call);
+	syn::custom_keyword!(OriginFor);
+	syn::custom_keyword!(weight);
+	syn::custom_keyword!(call_index);
+	syn::custom_keyword!(compact);
+	syn::custom_keyword!(T);
+	syn::custom_keyword!(pallet);
+}
+
+/// Definition of dispatchables typically `impl<T: Config> Pallet<T> { ... }`
+pub struct CallDef {
+	/// The where_clause used.
+	pub where_clause: Option<syn::WhereClause>,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The index of call item in pallet module.
+	pub index: usize,
+	/// Information on methods (used for expansion).
+	pub methods: Vec<CallVariantDef>,
+	/// The span of the pallet::call attribute.
+	pub attr_span: proc_macro2::Span,
+	/// Docs, specified on the impl Block.
+	pub docs: Vec<syn::Expr>,
+	/// The optional `weight` attribute on the `pallet::call`.
+	pub inherited_call_weight: Option<InheritedCallWeightAttr>,
+}
+
+/// The weight of a call.
+#[derive(Clone)]
+pub enum CallWeightDef {
+	/// Explicitly set on the call itself with `#[pallet::weight(…)]`. This value is used.
+	Immediate(syn::Expr),
+
+	/// The default value that should be set for dev-mode pallets. Usually zero.
+	DevModeDefault,
+
+	/// Inherits whatever value is configured on the pallet level.
+	///
+	/// The concrete value is not known at this point.
+	Inherited,
+}
+
+/// Definition of dispatchable typically: `#[weight...] fn foo(origin .., param1: ...) -> ..`
+#[derive(Clone)]
+pub struct CallVariantDef {
+	/// Function name.
+	pub name: syn::Ident,
+	/// Information on args: `(is_compact, name, type)`
+	pub args: Vec<(bool, syn::Ident, Box<syn::Type>)>,
+	/// Weight for the call.
+	pub weight: CallWeightDef,
+	/// Call index of the dispatchable.
+	pub call_index: u8,
+	/// Whether an explicit call index was specified.
+	pub explicit_call_index: bool,
+	/// Docs, used for metadata.
+	pub docs: Vec<syn::Expr>,
+	/// Attributes annotated at the top of the dispatchable function.
+	pub attrs: Vec<syn::Attribute>,
+}
+
+/// Attributes for functions in call impl block.
+/// Parse for `#[pallet::weight(expr)]` or `#[pallet::call_index(expr)]
+pub enum FunctionAttr {
+	CallIndex(u8),
+	Weight(syn::Expr),
+}
+
+impl syn::parse::Parse for FunctionAttr {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<keyword::pallet>()?;
+		content.parse::<syn::Token![::]>()?;
+
+		let lookahead = content.lookahead1();
+		if lookahead.peek(keyword::weight) {
+			content.parse::<keyword::weight>()?;
+			let weight_content;
+			syn::parenthesized!(weight_content in content);
+			Ok(FunctionAttr::Weight(weight_content.parse::<syn::Expr>()?))
+		} else if lookahead.peek(keyword::call_index) {
+			content.parse::<keyword::call_index>()?;
+			let call_index_content;
+			syn::parenthesized!(call_index_content in content);
+			let index = call_index_content.parse::<syn::LitInt>()?;
+			if !index.suffix().is_empty() {
+				let msg = "Number literal must not have a suffix";
+				return Err(syn::Error::new(index.span(), msg))
+			}
+			Ok(FunctionAttr::CallIndex(index.base10_parse()?))
+		} else {
+			Err(lookahead.error())
+		}
+	}
+}
+
+/// Attribute for arguments in function in call impl block.
+/// Parse for `#[pallet::compact]|
+pub struct ArgAttrIsCompact;
+
+impl syn::parse::Parse for ArgAttrIsCompact {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<keyword::pallet>()?;
+		content.parse::<syn::Token![::]>()?;
+
+		content.parse::<keyword::compact>()?;
+		Ok(ArgAttrIsCompact)
+	}
+}
+
+/// Check the syntax is `OriginFor<T>`
+pub fn check_dispatchable_first_arg_type(ty: &syn::Type) -> syn::Result<()> {
+	pub struct CheckDispatchableFirstArg;
+	impl syn::parse::Parse for CheckDispatchableFirstArg {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			input.parse::<keyword::OriginFor>()?;
+			input.parse::<syn::Token![<]>()?;
+			input.parse::<keyword::T>()?;
+			input.parse::<syn::Token![>]>()?;
+
+			Ok(Self)
+		}
+	}
+
+	syn::parse2::<CheckDispatchableFirstArg>(ty.to_token_stream()).map_err(|e| {
+		let msg = "Invalid type: expected `OriginFor<T>`";
+		let mut err = syn::Error::new(ty.span(), msg);
+		err.combine(e);
+		err
+	})?;
+
+	Ok(())
+}
+
+impl CallDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+		dev_mode: bool,
+		inherited_call_weight: Option<InheritedCallWeightAttr>,
+	) -> syn::Result<Self> {
+		let item_impl = if let syn::Item::Impl(item) = item {
+			item
+		} else {
+			return Err(syn::Error::new(item.span(), "Invalid pallet::call, expected item impl"))
+		};
+
+		let instances = vec![
+			helper::check_impl_gen(&item_impl.generics, item_impl.impl_token.span())?,
+			helper::check_pallet_struct_usage(&item_impl.self_ty)?,
+		];
+
+		if let Some((_, _, for_)) = item_impl.trait_ {
+			let msg = "Invalid pallet::call, expected no trait ident as in \
+				`impl<..> Pallet<..> { .. }`";
+			return Err(syn::Error::new(for_.span(), msg))
+		}
+
+		let mut methods = vec![];
+		let mut indices = HashMap::new();
+		let mut last_index: Option<u8> = None;
+		for item in &mut item_impl.items {
+			if let syn::ImplItem::Fn(method) = item {
+				if !matches!(method.vis, syn::Visibility::Public(_)) {
+					let msg = "Invalid pallet::call, dispatchable function must be public: \
+						`pub fn`";
+
+					let span = match method.vis {
+						syn::Visibility::Inherited => method.sig.span(),
+						_ => method.vis.span(),
+					};
+
+					return Err(syn::Error::new(span, msg))
+				}
+
+				match method.sig.inputs.first() {
+					None => {
+						let msg = "Invalid pallet::call, must have at least origin arg";
+						return Err(syn::Error::new(method.sig.span(), msg))
+					},
+					Some(syn::FnArg::Receiver(_)) => {
+						let msg = "Invalid pallet::call, first argument must be a typed argument, \
+							e.g. `origin: OriginFor<T>`";
+						return Err(syn::Error::new(method.sig.span(), msg))
+					},
+					Some(syn::FnArg::Typed(arg)) => {
+						check_dispatchable_first_arg_type(&arg.ty)?;
+					},
+				}
+
+				if let syn::ReturnType::Type(_, type_) = &method.sig.output {
+					helper::check_pallet_call_return_type(type_)?;
+				} else {
+					let msg = "Invalid pallet::call, require return type \
+						DispatchResultWithPostInfo";
+					return Err(syn::Error::new(method.sig.span(), msg))
+				}
+
+				let (mut weight_attrs, mut call_idx_attrs): (Vec<FunctionAttr>, Vec<FunctionAttr>) =
+					helper::take_item_pallet_attrs(&mut method.attrs)?.into_iter().partition(
+						|attr| {
+							if let FunctionAttr::Weight(_) = attr {
+								true
+							} else {
+								false
+							}
+						},
+					);
+
+				if weight_attrs.is_empty() && dev_mode {
+					// inject a default O(1) weight when dev mode is enabled and no weight has
+					// been specified on the call
+					let empty_weight: syn::Expr = syn::parse(quote::quote!(0).into())
+						.expect("we are parsing a quoted string; qed");
+					weight_attrs.push(FunctionAttr::Weight(empty_weight));
+				}
+
+				let weight = match weight_attrs.len() {
+					0 if inherited_call_weight.is_some() => CallWeightDef::Inherited,
+					0 if dev_mode => CallWeightDef::DevModeDefault,
+					0 => return Err(syn::Error::new(
+						method.sig.span(),
+						"A pallet::call requires either a concrete `#[pallet::weight($expr)]` or an 
+						inherited weight from the `#[pallet:call(weight($type))]` attribute, but 
+						none were given.",
+					)),
+					1 => match weight_attrs.pop().unwrap() {
+						FunctionAttr::Weight(w) => CallWeightDef::Immediate(w),
+						_ => unreachable!("checked during creation of the let binding"),
+					},
+					_ => {
+						let msg = "Invalid pallet::call, too many weight attributes given";
+						return Err(syn::Error::new(method.sig.span(), msg))
+					},
+				};
+
+				if call_idx_attrs.len() > 1 {
+					let msg = "Invalid pallet::call, too many call_index attributes given";
+					return Err(syn::Error::new(method.sig.span(), msg))
+				}
+				let call_index = call_idx_attrs.pop().map(|attr| match attr {
+					FunctionAttr::CallIndex(idx) => idx,
+					_ => unreachable!("checked during creation of the let binding"),
+				});
+				let explicit_call_index = call_index.is_some();
+
+				let final_index = match call_index {
+					Some(i) => i,
+					None =>
+						last_index.map_or(Some(0), |idx| idx.checked_add(1)).ok_or_else(|| {
+							let msg = "Call index doesn't fit into u8, index is 256";
+							syn::Error::new(method.sig.span(), msg)
+						})?,
+				};
+				last_index = Some(final_index);
+
+				if let Some(used_fn) = indices.insert(final_index, method.sig.ident.clone()) {
+					let msg = format!(
+						"Call indices are conflicting: Both functions {} and {} are at index {}",
+						used_fn, method.sig.ident, final_index,
+					);
+					let mut err = syn::Error::new(used_fn.span(), &msg);
+					err.combine(syn::Error::new(method.sig.ident.span(), msg));
+					return Err(err)
+				}
+
+				let mut args = vec![];
+				for arg in method.sig.inputs.iter_mut().skip(1) {
+					let arg = if let syn::FnArg::Typed(arg) = arg {
+						arg
+					} else {
+						unreachable!("Only first argument can be receiver");
+					};
+
+					let arg_attrs: Vec<ArgAttrIsCompact> =
+						helper::take_item_pallet_attrs(&mut arg.attrs)?;
+
+					if arg_attrs.len() > 1 {
+						let msg = "Invalid pallet::call, argument has too many attributes";
+						return Err(syn::Error::new(arg.span(), msg))
+					}
+
+					let arg_ident = if let syn::Pat::Ident(pat) = &*arg.pat {
+						pat.ident.clone()
+					} else {
+						let msg = "Invalid pallet::call, argument must be ident";
+						return Err(syn::Error::new(arg.pat.span(), msg))
+					};
+
+					args.push((!arg_attrs.is_empty(), arg_ident, arg.ty.clone()));
+				}
+
+				let docs = get_doc_literals(&method.attrs);
+
+				methods.push(CallVariantDef {
+					name: method.sig.ident.clone(),
+					weight,
+					call_index: final_index,
+					explicit_call_index,
+					args,
+					docs,
+					attrs: method.attrs.clone(),
+				});
+			} else {
+				let msg = "Invalid pallet::call, only method accepted";
+				return Err(syn::Error::new(item.span(), msg))
+			}
+		}
+
+		Ok(Self {
+			index,
+			attr_span,
+			instances,
+			methods,
+			where_clause: item_impl.generics.where_clause.clone(),
+			docs: get_doc_literals(&item_impl.attrs),
+			inherited_call_weight,
+		})
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/composite.rs b/substrate/frame/support/procedural/src/pallet/parse/composite.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cb554a116175c1f93aa2b7f5b4da447d6efb7741
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/composite.rs
@@ -0,0 +1,136 @@
+// 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 quote::ToTokens;
+use syn::spanned::Spanned;
+
+pub mod keyword {
+	use super::*;
+
+	syn::custom_keyword!(FreezeReason);
+	syn::custom_keyword!(HoldReason);
+	syn::custom_keyword!(LockId);
+	syn::custom_keyword!(SlashReason);
+	pub enum CompositeKeyword {
+		FreezeReason(FreezeReason),
+		HoldReason(HoldReason),
+		LockId(LockId),
+		SlashReason(SlashReason),
+	}
+
+	impl ToTokens for CompositeKeyword {
+		fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+			use CompositeKeyword::*;
+			match self {
+				FreezeReason(inner) => inner.to_tokens(tokens),
+				HoldReason(inner) => inner.to_tokens(tokens),
+				LockId(inner) => inner.to_tokens(tokens),
+				SlashReason(inner) => inner.to_tokens(tokens),
+			}
+		}
+	}
+
+	impl syn::parse::Parse for CompositeKeyword {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let lookahead = input.lookahead1();
+			if lookahead.peek(FreezeReason) {
+				Ok(Self::FreezeReason(input.parse()?))
+			} else if lookahead.peek(HoldReason) {
+				Ok(Self::HoldReason(input.parse()?))
+			} else if lookahead.peek(LockId) {
+				Ok(Self::LockId(input.parse()?))
+			} else if lookahead.peek(SlashReason) {
+				Ok(Self::SlashReason(input.parse()?))
+			} else {
+				Err(lookahead.error())
+			}
+		}
+	}
+
+	impl std::fmt::Display for CompositeKeyword {
+		fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+			use CompositeKeyword::*;
+			write!(
+				f,
+				"{}",
+				match self {
+					FreezeReason(_) => "FreezeReason",
+					HoldReason(_) => "HoldReason",
+					LockId(_) => "LockId",
+					SlashReason(_) => "SlashReason",
+				}
+			)
+		}
+	}
+}
+
+pub struct CompositeDef {
+	/// The index of the HoldReason item in the pallet module.
+	pub index: usize,
+	/// The composite keyword used (contains span).
+	pub composite_keyword: keyword::CompositeKeyword,
+	/// The span of the pallet::composite_enum attribute.
+	pub attr_span: proc_macro2::Span,
+}
+
+impl CompositeDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		scrate: &proc_macro2::Ident,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Enum(item) = item {
+			item
+		} else {
+			return Err(syn::Error::new(
+				item.span(),
+				"Invalid pallet::composite_enum, expected enum item",
+			))
+		};
+
+		if !matches!(item.vis, syn::Visibility::Public(_)) {
+			let msg = format!("Invalid pallet::composite_enum, `{}` must be public", item.ident);
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		let has_derive_attr = item.attrs.iter().any(|attr| {
+			if let syn::Meta::List(syn::MetaList { path, .. }) = &attr.meta {
+				path.get_ident().map(|ident| ident == "derive").unwrap_or(false)
+			} else {
+				false
+			}
+		});
+
+		if !has_derive_attr {
+			let derive_attr: syn::Attribute = syn::parse_quote! {
+				#[derive(
+					Copy, Clone, Eq, PartialEq, Ord, PartialOrd,
+					#scrate::__private::codec::Encode, #scrate::__private::codec::Decode, #scrate::__private::codec::MaxEncodedLen,
+					#scrate::__private::scale_info::TypeInfo,
+					#scrate::__private::RuntimeDebug,
+				)]
+			};
+			item.attrs.push(derive_attr);
+		}
+
+		let composite_keyword =
+			syn::parse2::<keyword::CompositeKeyword>(item.ident.to_token_stream())?;
+
+		Ok(CompositeDef { index, composite_keyword, attr_span })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/config.rs b/substrate/frame/support/procedural/src/pallet/parse/config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e505f8b04119bd685bb2c3dfd77521f349eb619f
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/config.rs
@@ -0,0 +1,479 @@
+// 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::helper;
+use frame_support_procedural_tools::get_doc_literals;
+use quote::ToTokens;
+use syn::{spanned::Spanned, token, Token};
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(Config);
+	syn::custom_keyword!(From);
+	syn::custom_keyword!(T);
+	syn::custom_keyword!(I);
+	syn::custom_keyword!(config);
+	syn::custom_keyword!(pallet);
+	syn::custom_keyword!(IsType);
+	syn::custom_keyword!(RuntimeEvent);
+	syn::custom_keyword!(Event);
+	syn::custom_keyword!(frame_system);
+	syn::custom_keyword!(disable_frame_system_supertrait_check);
+	syn::custom_keyword!(no_default);
+	syn::custom_keyword!(no_default_bounds);
+	syn::custom_keyword!(constant);
+}
+
+#[derive(Default)]
+pub struct DefaultTrait {
+	/// A bool for each sub-trait item indicates whether the item has
+	/// `#[pallet::no_default_bounds]` attached to it. If true, the item will not have any bounds
+	/// in the generated default sub-trait.
+	pub items: Vec<(syn::TraitItem, bool)>,
+	pub has_system: bool,
+}
+
+/// Input definition for the pallet config.
+pub struct ConfigDef {
+	/// The index of item in pallet module.
+	pub index: usize,
+	/// Whether the trait has instance (i.e. define with `Config<I = ()>`)
+	pub has_instance: bool,
+	/// Const associated type.
+	pub consts_metadata: Vec<ConstMetadataDef>,
+	/// Whether the trait has the associated type `Event`, note that those bounds are
+	/// checked:
+	/// * `IsType<Self as frame_system::Config>::RuntimeEvent`
+	/// * `From<Event>` or `From<Event<T>>` or `From<Event<T, I>>`
+	pub has_event_type: bool,
+	/// The where clause on trait definition but modified so `Self` is `T`.
+	pub where_clause: Option<syn::WhereClause>,
+	/// The span of the pallet::config attribute.
+	pub attr_span: proc_macro2::Span,
+	/// Whether a default sub-trait should be generated.
+	///
+	/// Contains default sub-trait items (instantiated by `#[pallet::config(with_default)]`).
+	/// Vec will be empty if `#[pallet::config(with_default)]` is not specified or if there are
+	/// no trait items.
+	pub default_sub_trait: Option<DefaultTrait>,
+}
+
+/// Input definition for a constant in pallet config.
+pub struct ConstMetadataDef {
+	/// Name of the associated type.
+	pub ident: syn::Ident,
+	/// The type in Get, e.g. `u32` in `type Foo: Get<u32>;`, but `Self` is replaced by `T`
+	pub type_: syn::Type,
+	/// The doc associated
+	pub doc: Vec<syn::Expr>,
+}
+
+impl TryFrom<&syn::TraitItemType> for ConstMetadataDef {
+	type Error = syn::Error;
+
+	fn try_from(trait_ty: &syn::TraitItemType) -> Result<Self, Self::Error> {
+		let err = |span, msg| {
+			syn::Error::new(span, format!("Invalid usage of `#[pallet::constant]`: {}", msg))
+		};
+		let doc = get_doc_literals(&trait_ty.attrs);
+		let ident = trait_ty.ident.clone();
+		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
+				}
+			})
+			.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 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");
+
+		Ok(Self { ident, type_, doc })
+	}
+}
+
+/// Parse for `#[pallet::disable_frame_system_supertrait_check]`
+pub struct DisableFrameSystemSupertraitCheck;
+
+impl syn::parse::Parse for DisableFrameSystemSupertraitCheck {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<syn::Ident>()?;
+		content.parse::<syn::Token![::]>()?;
+
+		content.parse::<keyword::disable_frame_system_supertrait_check>()?;
+		Ok(Self)
+	}
+}
+
+/// Parsing for the `typ` portion of `PalletAttr`
+#[derive(derive_syn_parse::Parse, PartialEq, Eq)]
+pub enum PalletAttrType {
+	#[peek(keyword::no_default, name = "no_default")]
+	NoDefault(keyword::no_default),
+	#[peek(keyword::no_default_bounds, name = "no_default_bounds")]
+	NoBounds(keyword::no_default_bounds),
+	#[peek(keyword::constant, name = "constant")]
+	Constant(keyword::constant),
+}
+
+/// Parsing for `#[pallet::X]`
+#[derive(derive_syn_parse::Parse)]
+pub struct PalletAttr {
+	_pound: Token![#],
+	#[bracket]
+	_bracket: token::Bracket,
+	#[inside(_bracket)]
+	_pallet: keyword::pallet,
+	#[prefix(Token![::] in _bracket)]
+	#[inside(_bracket)]
+	typ: PalletAttrType,
+}
+
+pub struct ConfigBoundParse(syn::Ident);
+
+impl syn::parse::Parse for ConfigBoundParse {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		let ident = input.parse::<syn::Ident>()?;
+		input.parse::<syn::Token![::]>()?;
+		input.parse::<keyword::Config>()?;
+
+		if input.peek(syn::token::Lt) {
+			input.parse::<syn::AngleBracketedGenericArguments>()?;
+		}
+
+		Ok(Self(ident))
+	}
+}
+
+/// Parse for `IsType<<Sef as $ident::Config>::RuntimeEvent>` and retrieve `$ident`
+pub struct IsTypeBoundEventParse(syn::Ident);
+
+impl syn::parse::Parse for IsTypeBoundEventParse {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<keyword::IsType>()?;
+		input.parse::<syn::Token![<]>()?;
+		input.parse::<syn::Token![<]>()?;
+		input.parse::<syn::Token![Self]>()?;
+		input.parse::<syn::Token![as]>()?;
+		let ident = input.parse::<syn::Ident>()?;
+		input.parse::<syn::Token![::]>()?;
+		input.parse::<keyword::Config>()?;
+		input.parse::<syn::Token![>]>()?;
+		input.parse::<syn::Token![::]>()?;
+		input.parse::<keyword::RuntimeEvent>()?;
+		input.parse::<syn::Token![>]>()?;
+
+		Ok(Self(ident))
+	}
+}
+
+/// Parse for `From<Event>` or `From<Event<Self>>` or `From<Event<Self, I>>`
+pub struct FromEventParse {
+	is_generic: bool,
+	has_instance: bool,
+}
+
+impl syn::parse::Parse for FromEventParse {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		let mut is_generic = false;
+		let mut has_instance = false;
+
+		input.parse::<keyword::From>()?;
+		input.parse::<syn::Token![<]>()?;
+		input.parse::<keyword::Event>()?;
+		if input.peek(syn::Token![<]) {
+			is_generic = true;
+			input.parse::<syn::Token![<]>()?;
+			input.parse::<syn::Token![Self]>()?;
+			if input.peek(syn::Token![,]) {
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+				has_instance = true;
+			}
+			input.parse::<syn::Token![>]>()?;
+		}
+		input.parse::<syn::Token![>]>()?;
+
+		Ok(Self { is_generic, has_instance })
+	}
+}
+
+/// Check if trait_item is `type RuntimeEvent`, if so checks its bounds are those expected.
+/// (Event type is reserved type)
+fn check_event_type(
+	frame_system: &syn::Ident,
+	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))
+			}
+			// 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| b.0 == *frame_system)
+			});
+
+			if !has_is_type_bound {
+				let msg = format!(
+					"Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must \
+					bound: `IsType<<Self as {}::Config>::RuntimeEvent>`",
+					frame_system,
+				);
+				return Err(syn::Error::new(type_.span(), msg))
+			}
+
+			let from_event_bound = type_
+				.bounds
+				.iter()
+				.find_map(|s| syn::parse2::<FromEventParse>(s.to_token_stream()).ok());
+
+			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))
+			};
+
+			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)
+	}
+}
+
+/// Replace ident `Self` by `T`
+pub fn replace_self_by_t(input: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+	input
+		.into_iter()
+		.map(|token_tree| match token_tree {
+			proc_macro2::TokenTree::Group(group) =>
+				proc_macro2::Group::new(group.delimiter(), replace_self_by_t(group.stream())).into(),
+			proc_macro2::TokenTree::Ident(ident) if ident == "Self" =>
+				proc_macro2::Ident::new("T", ident.span()).into(),
+			other => other,
+		})
+		.collect()
+}
+
+impl ConfigDef {
+	pub fn try_from(
+		frame_system: &syn::Ident,
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+		enable_default: bool,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Trait(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::config, expected trait definition";
+			return Err(syn::Error::new(item.span(), msg))
+		};
+
+		if !matches!(item.vis, syn::Visibility::Public(_)) {
+			let msg = "Invalid pallet::config, trait must be public";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		syn::parse2::<keyword::Config>(item.ident.to_token_stream())?;
+
+		let where_clause = {
+			let stream = replace_self_by_t(item.generics.where_clause.to_token_stream());
+			syn::parse2::<Option<syn::WhereClause>>(stream).expect(
+				"Internal error: replacing `Self` by `T` should result in valid where
+					clause",
+			)
+		};
+
+		if item.generics.params.len() > 1 {
+			let msg = "Invalid pallet::config, expected no more than one generic";
+			return Err(syn::Error::new(item.generics.params[2].span(), msg))
+		}
+
+		let has_instance = if item.generics.params.first().is_some() {
+			helper::check_config_def_gen(&item.generics, item.ident.span())?;
+			true
+		} else {
+			false
+		};
+
+		let has_frame_system_supertrait = item.supertraits.iter().any(|s| {
+			syn::parse2::<ConfigBoundParse>(s.to_token_stream())
+				.map_or(false, |b| b.0 == *frame_system)
+		});
+
+		let mut has_event_type = false;
+		let mut consts_metadata = vec![];
+		let mut default_sub_trait = if enable_default {
+			Some(DefaultTrait {
+				items: Default::default(),
+				has_system: has_frame_system_supertrait,
+			})
+		} else {
+			None
+		};
+		for trait_item in &mut item.items {
+			let is_event = check_event_type(frame_system, trait_item, has_instance)?;
+			has_event_type = has_event_type || is_event;
+
+			let mut already_no_default = false;
+			let mut already_constant = false;
+			let mut already_no_default_bounds = false;
+
+			while let Ok(Some(pallet_attr)) =
+				helper::take_first_item_pallet_attr::<PalletAttr>(trait_item)
+			{
+				match (pallet_attr.typ, &trait_item) {
+					(PalletAttrType::Constant(_), syn::TraitItem::Type(ref typ)) => {
+						if already_constant {
+							return Err(syn::Error::new(
+								pallet_attr._bracket.span.join(),
+								"Duplicate #[pallet::constant] attribute not allowed.",
+							))
+						}
+						already_constant = true;
+						consts_metadata.push(ConstMetadataDef::try_from(typ)?);
+					},
+					(PalletAttrType::Constant(_), _) =>
+						return Err(syn::Error::new(
+							trait_item.span(),
+							"Invalid #[pallet::constant] in #[pallet::config], expected type item",
+						)),
+					(PalletAttrType::NoDefault(_), _) => {
+						if !enable_default {
+							return Err(syn::Error::new(
+								pallet_attr._bracket.span.join(),
+								"`#[pallet:no_default]` can only be used if `#[pallet::config(with_default)]` \
+								has been specified"
+							))
+						}
+						if already_no_default {
+							return Err(syn::Error::new(
+								pallet_attr._bracket.span.join(),
+								"Duplicate #[pallet::no_default] attribute not allowed.",
+							))
+						}
+
+						already_no_default = true;
+					},
+					(PalletAttrType::NoBounds(_), _) => {
+						if !enable_default {
+							return Err(syn::Error::new(
+								pallet_attr._bracket.span.join(),
+								"`#[pallet:no_default_bounds]` can only be used if `#[pallet::config(with_default)]` \
+								has been specified"
+							))
+						}
+						if already_no_default_bounds {
+							return Err(syn::Error::new(
+								pallet_attr._bracket.span.join(),
+								"Duplicate #[pallet::no_default_bounds] attribute not allowed.",
+							))
+						}
+						already_no_default_bounds = true;
+					},
+				}
+			}
+
+			if !already_no_default && enable_default {
+				default_sub_trait
+					.as_mut()
+					.expect("is 'Some(_)' if 'enable_default'; qed")
+					.items
+					.push((trait_item.clone(), already_no_default_bounds));
+			}
+		}
+
+		let attr: Option<DisableFrameSystemSupertraitCheck> =
+			helper::take_first_item_pallet_attr(&mut item.attrs)?;
+		let disable_system_supertrait_check = attr.is_some();
+
+		if !has_frame_system_supertrait && !disable_system_supertrait_check {
+			let found = if item.supertraits.is_empty() {
+				"none".to_string()
+			} else {
+				let mut found = item
+					.supertraits
+					.iter()
+					.fold(String::new(), |acc, s| format!("{}`{}`, ", acc, quote::quote!(#s)));
+				found.pop();
+				found.pop();
+				found
+			};
+
+			let msg = format!(
+				"Invalid pallet::trait, expected explicit `{}::Config` as supertrait, \
+				found {}. \
+				(try `pub trait Config: frame_system::Config {{ ...` or \
+				`pub trait Config<I: 'static>: frame_system::Config {{ ...`). \
+				To disable this check, use `#[pallet::disable_frame_system_supertrait_check]`",
+				frame_system, found,
+			);
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		Ok(Self {
+			index,
+			has_instance,
+			consts_metadata,
+			has_event_type,
+			where_clause,
+			attr_span,
+			default_sub_trait,
+		})
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/error.rs b/substrate/frame/support/procedural/src/pallet/parse/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f82ce61fc93fc118ec4a7017fb7ccc87275a71b
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/error.rs
@@ -0,0 +1,97 @@
+// 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::helper;
+use frame_support_procedural_tools::get_doc_literals;
+use quote::ToTokens;
+use syn::{spanned::Spanned, Fields};
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(Error);
+}
+
+/// Records information about the error enum variants.
+pub struct VariantField {
+	/// Whether or not the field is named, i.e. whether it is a tuple variant or struct variant.
+	pub is_named: bool,
+}
+
+/// This checks error declaration as a enum declaration with only variants without fields nor
+/// discriminant.
+pub struct ErrorDef {
+	/// The index of error item in pallet module.
+	pub index: usize,
+	/// Variants ident, optional field and doc literals (ordered as declaration order)
+	pub variants: Vec<(syn::Ident, Option<VariantField>, Vec<syn::Expr>)>,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The keyword error used (contains span).
+	pub error: keyword::Error,
+	/// The span of the pallet::error attribute.
+	pub attr_span: proc_macro2::Span,
+}
+
+impl ErrorDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Enum(item) = item {
+			item
+		} else {
+			return Err(syn::Error::new(item.span(), "Invalid pallet::error, expected item enum"))
+		};
+		if !matches!(item.vis, syn::Visibility::Public(_)) {
+			let msg = "Invalid pallet::error, `Error` must be public";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		let instances =
+			vec![helper::check_type_def_gen_no_bounds(&item.generics, item.ident.span())?];
+
+		if item.generics.where_clause.is_some() {
+			let msg = "Invalid pallet::error, where clause is not allowed on pallet error item";
+			return Err(syn::Error::new(item.generics.where_clause.as_ref().unwrap().span(), msg))
+		}
+
+		let error = syn::parse2::<keyword::Error>(item.ident.to_token_stream())?;
+
+		let variants = item
+			.variants
+			.iter()
+			.map(|variant| {
+				let field_ty = match &variant.fields {
+					Fields::Unit => None,
+					Fields::Named(_) => Some(VariantField { is_named: true }),
+					Fields::Unnamed(_) => Some(VariantField { is_named: false }),
+				};
+				if variant.discriminant.is_some() {
+					let msg = "Invalid pallet::error, unexpected discriminant, discriminants \
+						are not supported";
+					let span = variant.discriminant.as_ref().unwrap().0.span();
+					return Err(syn::Error::new(span, msg))
+				}
+
+				Ok((variant.ident.clone(), field_ty, get_doc_literals(&variant.attrs)))
+			})
+			.collect::<Result<_, _>>()?;
+
+		Ok(ErrorDef { attr_span, index, variants, instances, error })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/event.rs b/substrate/frame/support/procedural/src/pallet/parse/event.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0fb8ee4f549777fe6c9d25e99e3e082553c70d7c
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/event.rs
@@ -0,0 +1,141 @@
+// 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::helper;
+use quote::ToTokens;
+use syn::spanned::Spanned;
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(Event);
+	syn::custom_keyword!(pallet);
+	syn::custom_keyword!(generate_deposit);
+	syn::custom_keyword!(deposit_event);
+}
+
+/// Definition for pallet event enum.
+pub struct EventDef {
+	/// The index of event item in pallet module.
+	pub index: usize,
+	/// The keyword Event used (contains span).
+	pub event: keyword::Event,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The kind of generic the type `Event` has.
+	pub gen_kind: super::GenericKind,
+	/// Whether the function `deposit_event` must be generated.
+	pub deposit_event: Option<PalletEventDepositAttr>,
+	/// Where clause used in event definition.
+	pub where_clause: Option<syn::WhereClause>,
+	/// The span of the pallet::event attribute.
+	pub attr_span: proc_macro2::Span,
+}
+
+/// Attribute for a pallet's Event.
+///
+/// Syntax is:
+/// * `#[pallet::generate_deposit($vis fn deposit_event)]`
+pub struct PalletEventDepositAttr {
+	pub fn_vis: syn::Visibility,
+	// Span for the keyword deposit_event
+	pub fn_span: proc_macro2::Span,
+	// Span of the attribute
+	pub span: proc_macro2::Span,
+}
+
+impl syn::parse::Parse for PalletEventDepositAttr {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<keyword::pallet>()?;
+		content.parse::<syn::Token![::]>()?;
+
+		let span = content.parse::<keyword::generate_deposit>()?.span();
+		let generate_content;
+		syn::parenthesized!(generate_content in content);
+		let fn_vis = generate_content.parse::<syn::Visibility>()?;
+		generate_content.parse::<syn::Token![fn]>()?;
+		let fn_span = generate_content.parse::<keyword::deposit_event>()?.span();
+
+		Ok(PalletEventDepositAttr { fn_vis, span, fn_span })
+	}
+}
+
+struct PalletEventAttrInfo {
+	deposit_event: Option<PalletEventDepositAttr>,
+}
+
+impl PalletEventAttrInfo {
+	fn from_attrs(attrs: Vec<PalletEventDepositAttr>) -> syn::Result<Self> {
+		let mut deposit_event = None;
+		for attr in attrs {
+			if deposit_event.is_none() {
+				deposit_event = Some(attr)
+			} else {
+				return Err(syn::Error::new(attr.span, "Duplicate attribute"))
+			}
+		}
+
+		Ok(PalletEventAttrInfo { deposit_event })
+	}
+}
+
+impl EventDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Enum(item) = item {
+			item
+		} else {
+			return Err(syn::Error::new(item.span(), "Invalid pallet::event, expected enum item"))
+		};
+
+		let event_attrs: Vec<PalletEventDepositAttr> =
+			helper::take_item_pallet_attrs(&mut item.attrs)?;
+		let attr_info = PalletEventAttrInfo::from_attrs(event_attrs)?;
+		let deposit_event = attr_info.deposit_event;
+
+		if !matches!(item.vis, syn::Visibility::Public(_)) {
+			let msg = "Invalid pallet::event, `Event` must be public";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		let where_clause = item.generics.where_clause.clone();
+
+		let mut instances = vec![];
+		// NOTE: Event is not allowed to be only generic on I because it is not supported
+		// by construct_runtime.
+		if let Some(u) = helper::check_type_def_optional_gen(&item.generics, item.ident.span())? {
+			instances.push(u);
+		} else {
+			// construct_runtime only allow non generic event for non instantiable pallet.
+			instances.push(helper::InstanceUsage { has_instance: false, span: item.ident.span() })
+		}
+
+		let has_instance = item.generics.type_params().any(|t| t.ident == "I");
+		let has_config = item.generics.type_params().any(|t| t.ident == "T");
+		let gen_kind = super::GenericKind::from_gens(has_config, has_instance)
+			.expect("Checked by `helper::check_type_def_optional_gen` above");
+
+		let event = syn::parse2::<keyword::Event>(item.ident.to_token_stream())?;
+
+		Ok(EventDef { attr_span, index, instances, deposit_event, event, gen_kind, where_clause })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/extra_constants.rs b/substrate/frame/support/procedural/src/pallet/parse/extra_constants.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2ba6c44b7d158e20d09a309f31b93fadf2cf8cf8
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/extra_constants.rs
@@ -0,0 +1,160 @@
+// 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::helper;
+use frame_support_procedural_tools::get_doc_literals;
+use syn::spanned::Spanned;
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(DispatchResultWithPostInfo);
+	syn::custom_keyword!(Call);
+	syn::custom_keyword!(OriginFor);
+	syn::custom_keyword!(weight);
+	syn::custom_keyword!(compact);
+	syn::custom_keyword!(T);
+	syn::custom_keyword!(pallet);
+	syn::custom_keyword!(constant_name);
+}
+
+/// Definition of extra constants typically `impl<T: Config> Pallet<T> { ... }`
+pub struct ExtraConstantsDef {
+	/// The where_clause used.
+	pub where_clause: Option<syn::WhereClause>,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The index of call item in pallet module.
+	pub index: usize,
+	/// The extra constant defined.
+	pub extra_constants: Vec<ExtraConstantDef>,
+}
+
+/// Input definition for an constant in pallet.
+pub struct ExtraConstantDef {
+	/// Name of the function
+	pub ident: syn::Ident,
+	/// The type returned by the function
+	pub type_: syn::Type,
+	/// The doc associated
+	pub doc: Vec<syn::Expr>,
+	/// Optional MetaData Name
+	pub metadata_name: Option<syn::Ident>,
+}
+
+/// Attributes for functions in extra_constants impl block.
+/// Parse for `#[pallet::constant_name(ConstantName)]`
+pub struct ExtraConstAttr {
+	metadata_name: syn::Ident,
+}
+
+impl syn::parse::Parse for ExtraConstAttr {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<keyword::pallet>()?;
+		content.parse::<syn::Token![::]>()?;
+		content.parse::<keyword::constant_name>()?;
+
+		let metadata_name;
+		syn::parenthesized!(metadata_name in content);
+		Ok(ExtraConstAttr { metadata_name: metadata_name.parse::<syn::Ident>()? })
+	}
+}
+
+impl ExtraConstantsDef {
+	pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+		let item = if let syn::Item::Impl(item) = item {
+			item
+		} else {
+			return Err(syn::Error::new(
+				item.span(),
+				"Invalid pallet::extra_constants, expected item impl",
+			))
+		};
+
+		let instances = vec![
+			helper::check_impl_gen(&item.generics, item.impl_token.span())?,
+			helper::check_pallet_struct_usage(&item.self_ty)?,
+		];
+
+		if let Some((_, _, for_)) = item.trait_ {
+			let msg = "Invalid pallet::call, expected no trait ident as in \
+				`impl<..> Pallet<..> { .. }`";
+			return Err(syn::Error::new(for_.span(), msg))
+		}
+
+		let mut extra_constants = vec![];
+		for impl_item in &mut item.items {
+			let method = if let syn::ImplItem::Fn(method) = impl_item {
+				method
+			} else {
+				let msg = "Invalid pallet::call, only method accepted";
+				return Err(syn::Error::new(impl_item.span(), msg))
+			};
+
+			if !method.sig.inputs.is_empty() {
+				let msg = "Invalid pallet::extra_constants, method must have 0 args";
+				return Err(syn::Error::new(method.sig.span(), msg))
+			}
+
+			if !method.sig.generics.params.is_empty() {
+				let msg = "Invalid pallet::extra_constants, method must have 0 generics";
+				return Err(syn::Error::new(method.sig.generics.params[0].span(), msg))
+			}
+
+			if method.sig.generics.where_clause.is_some() {
+				let msg = "Invalid pallet::extra_constants, method must have no where clause";
+				return Err(syn::Error::new(method.sig.generics.where_clause.span(), msg))
+			}
+
+			let type_ = match &method.sig.output {
+				syn::ReturnType::Default => {
+					let msg = "Invalid pallet::extra_constants, method must have a return type";
+					return Err(syn::Error::new(method.span(), msg))
+				},
+				syn::ReturnType::Type(_, type_) => *type_.clone(),
+			};
+
+			// parse metadata_name
+			let mut extra_constant_attrs: Vec<ExtraConstAttr> =
+				helper::take_item_pallet_attrs(method)?;
+
+			if extra_constant_attrs.len() > 1 {
+				let msg =
+					"Invalid attribute in pallet::constant_name, only one attribute is expected";
+				return Err(syn::Error::new(extra_constant_attrs[1].metadata_name.span(), msg))
+			}
+
+			let metadata_name = extra_constant_attrs.pop().map(|attr| attr.metadata_name);
+
+			extra_constants.push(ExtraConstantDef {
+				ident: method.sig.ident.clone(),
+				type_,
+				doc: get_doc_literals(&method.attrs),
+				metadata_name,
+			});
+		}
+
+		Ok(Self {
+			index,
+			instances,
+			where_clause: item.generics.where_clause.clone(),
+			extra_constants,
+		})
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/genesis_build.rs b/substrate/frame/support/procedural/src/pallet/parse/genesis_build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d0e1d9ec998ec00661ef02eee7f4077a11c8084b
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/genesis_build.rs
@@ -0,0 +1,61 @@
+// 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::helper;
+use syn::spanned::Spanned;
+
+/// Definition for pallet genesis build implementation.
+pub struct GenesisBuildDef {
+	/// The index of item in pallet module.
+	pub index: usize,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Option<Vec<helper::InstanceUsage>>,
+	/// The where_clause used.
+	pub where_clause: Option<syn::WhereClause>,
+	/// The span of the pallet::genesis_build attribute.
+	pub attr_span: proc_macro2::Span,
+}
+
+impl GenesisBuildDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Impl(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::genesis_build, expected item impl";
+			return Err(syn::Error::new(item.span(), msg))
+		};
+
+		let item_trait = &item
+			.trait_
+			.as_ref()
+			.ok_or_else(|| {
+				let msg = "Invalid pallet::genesis_build, expected impl<..> GenesisBuild<..> \
+					for GenesisConfig<..>";
+				syn::Error::new(item.span(), msg)
+			})?
+			.1;
+
+		let instances =
+			helper::check_genesis_builder_usage(item_trait)?.map(|instances| vec![instances]);
+
+		Ok(Self { attr_span, index, instances, where_clause: item.generics.where_clause.clone() })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/genesis_config.rs b/substrate/frame/support/procedural/src/pallet/parse/genesis_config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..62da6ba13b3be3d2c8cc41b2e874f1a8c24b86d2
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/genesis_config.rs
@@ -0,0 +1,73 @@
+// 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::helper;
+use syn::spanned::Spanned;
+
+/// Definition for pallet genesis config type.
+///
+/// Either:
+/// * `struct GenesisConfig`
+/// * `enum GenesisConfig`
+pub struct GenesisConfigDef {
+	/// The index of item in pallet module.
+	pub index: usize,
+	/// The kind of generic the type `GenesisConfig` has.
+	pub gen_kind: super::GenericKind,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The ident of genesis_config, can be used for span.
+	pub genesis_config: syn::Ident,
+}
+
+impl GenesisConfigDef {
+	pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+		let item_span = item.span();
+		let (vis, ident, generics) = match &item {
+			syn::Item::Enum(item) => (&item.vis, &item.ident, &item.generics),
+			syn::Item::Struct(item) => (&item.vis, &item.ident, &item.generics),
+			_ => {
+				let msg = "Invalid pallet::genesis_config, expected enum or struct";
+				return Err(syn::Error::new(item.span(), msg))
+			},
+		};
+
+		let mut instances = vec![];
+		// NOTE: GenesisConfig is not allowed to be only generic on I because it is not supported
+		// by construct_runtime.
+		if let Some(u) = helper::check_type_def_optional_gen(generics, ident.span())? {
+			instances.push(u);
+		}
+
+		let has_instance = generics.type_params().any(|t| t.ident == "I");
+		let has_config = generics.type_params().any(|t| t.ident == "T");
+		let gen_kind = super::GenericKind::from_gens(has_config, has_instance)
+			.expect("Checked by `helper::check_type_def_optional_gen` above");
+
+		if !matches!(vis, syn::Visibility::Public(_)) {
+			let msg = "Invalid pallet::genesis_config, GenesisConfig must be public";
+			return Err(syn::Error::new(item_span, msg))
+		}
+
+		if ident != "GenesisConfig" {
+			let msg = "Invalid pallet::genesis_config, ident must `GenesisConfig`";
+			return Err(syn::Error::new(ident.span(), msg))
+		}
+
+		Ok(GenesisConfigDef { index, genesis_config: ident.clone(), instances, gen_kind })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/helper.rs b/substrate/frame/support/procedural/src/pallet/parse/helper.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1e6e83d7eeba7e1b63b18693ee1fce5cce72dc76
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/helper.rs
@@ -0,0 +1,612 @@
+// 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 quote::ToTokens;
+use syn::spanned::Spanned;
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(I);
+	syn::custom_keyword!(compact);
+	syn::custom_keyword!(GenesisBuild);
+	syn::custom_keyword!(BuildGenesisConfig);
+	syn::custom_keyword!(Config);
+	syn::custom_keyword!(T);
+	syn::custom_keyword!(Pallet);
+	syn::custom_keyword!(origin);
+	syn::custom_keyword!(DispatchResult);
+	syn::custom_keyword!(DispatchResultWithPostInfo);
+}
+
+/// A usage of instance, either the trait `Config` has been used with instance or without instance.
+/// Used to check for consistency.
+#[derive(Clone)]
+pub struct InstanceUsage {
+	pub has_instance: bool,
+	pub span: proc_macro2::Span,
+}
+
+/// Trait implemented for syn items to get mutable references on their attributes.
+///
+/// NOTE: verbatim variants are not supported.
+pub trait MutItemAttrs {
+	fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>>;
+}
+
+/// Take the first pallet attribute (e.g. attribute like `#[pallet..]`) and decode it to `Attr`
+pub(crate) fn take_first_item_pallet_attr<Attr>(
+	item: &mut impl MutItemAttrs,
+) -> syn::Result<Option<Attr>>
+where
+	Attr: syn::parse::Parse,
+{
+	let attrs = if let Some(attrs) = item.mut_item_attrs() { attrs } else { return Ok(None) };
+
+	if 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)
+	}
+}
+
+/// Take all the pallet attributes (e.g. attribute like `#[pallet..]`) and decode them to `Attr`
+pub(crate) fn take_item_pallet_attrs<Attr>(item: &mut impl MutItemAttrs) -> syn::Result<Vec<Attr>>
+where
+	Attr: syn::parse::Parse,
+{
+	let mut pallet_attrs = Vec::new();
+
+	while let Some(attr) = take_first_item_pallet_attr(item)? {
+		pallet_attrs.push(attr)
+	}
+
+	Ok(pallet_attrs)
+}
+
+/// Get all the cfg attributes (e.g. attribute like `#[cfg..]`) and decode them to `Attr`
+pub fn get_item_cfg_attrs(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
+	attrs
+		.iter()
+		.filter_map(|attr| {
+			if attr.path().segments.first().map_or(false, |segment| segment.ident == "cfg") {
+				Some(attr.clone())
+			} else {
+				None
+			}
+		})
+		.collect::<Vec<_>>()
+}
+
+impl MutItemAttrs for syn::Item {
+	fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
+		match self {
+			Self::Const(item) => Some(item.attrs.as_mut()),
+			Self::Enum(item) => Some(item.attrs.as_mut()),
+			Self::ExternCrate(item) => Some(item.attrs.as_mut()),
+			Self::Fn(item) => Some(item.attrs.as_mut()),
+			Self::ForeignMod(item) => Some(item.attrs.as_mut()),
+			Self::Impl(item) => Some(item.attrs.as_mut()),
+			Self::Macro(item) => Some(item.attrs.as_mut()),
+			Self::Mod(item) => Some(item.attrs.as_mut()),
+			Self::Static(item) => Some(item.attrs.as_mut()),
+			Self::Struct(item) => Some(item.attrs.as_mut()),
+			Self::Trait(item) => Some(item.attrs.as_mut()),
+			Self::TraitAlias(item) => Some(item.attrs.as_mut()),
+			Self::Type(item) => Some(item.attrs.as_mut()),
+			Self::Union(item) => Some(item.attrs.as_mut()),
+			Self::Use(item) => Some(item.attrs.as_mut()),
+			_ => None,
+		}
+	}
+}
+
+impl MutItemAttrs for syn::TraitItem {
+	fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
+		match self {
+			Self::Const(item) => Some(item.attrs.as_mut()),
+			Self::Fn(item) => Some(item.attrs.as_mut()),
+			Self::Type(item) => Some(item.attrs.as_mut()),
+			Self::Macro(item) => Some(item.attrs.as_mut()),
+			_ => None,
+		}
+	}
+}
+
+impl MutItemAttrs for Vec<syn::Attribute> {
+	fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
+		Some(self)
+	}
+}
+
+impl MutItemAttrs for syn::ItemMod {
+	fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
+		Some(&mut self.attrs)
+	}
+}
+
+impl MutItemAttrs for syn::ImplItemFn {
+	fn mut_item_attrs(&mut self) -> Option<&mut Vec<syn::Attribute>> {
+		Some(&mut self.attrs)
+	}
+}
+
+/// Parse for `()`
+struct Unit;
+impl syn::parse::Parse for Unit {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		let content;
+		syn::parenthesized!(content in input);
+		if !content.is_empty() {
+			let msg = "unexpected tokens, expected nothing inside parenthesis as `()`";
+			return Err(syn::Error::new(content.span(), msg))
+		}
+		Ok(Self)
+	}
+}
+
+/// Parse for `'static`
+struct StaticLifetime;
+impl syn::parse::Parse for StaticLifetime {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		let lifetime = input.parse::<syn::Lifetime>()?;
+		if lifetime.ident != "static" {
+			let msg = "unexpected tokens, expected `static`";
+			return Err(syn::Error::new(lifetime.ident.span(), msg))
+		}
+		Ok(Self)
+	}
+}
+
+/// Check the syntax: `I: 'static = ()`
+///
+/// `span` is used in case generics is empty (empty generics has span == call_site).
+///
+/// return the instance if found.
+pub fn check_config_def_gen(gen: &syn::Generics, span: proc_macro2::Span) -> syn::Result<()> {
+	let expected = "expected `I: 'static = ()`";
+	pub struct CheckTraitDefGenerics;
+	impl syn::parse::Parse for CheckTraitDefGenerics {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			input.parse::<keyword::I>()?;
+			input.parse::<syn::Token![:]>()?;
+			input.parse::<StaticLifetime>()?;
+			input.parse::<syn::Token![=]>()?;
+			input.parse::<Unit>()?;
+
+			Ok(Self)
+		}
+	}
+
+	syn::parse2::<CheckTraitDefGenerics>(gen.params.to_token_stream()).map_err(|e| {
+		let msg = format!("Invalid generics: {}", expected);
+		let mut err = syn::Error::new(span, msg);
+		err.combine(e);
+		err
+	})?;
+
+	Ok(())
+}
+
+/// Check the syntax:
+/// * either `T`
+/// * or `T, I = ()`
+///
+/// `span` is used in case generics is empty (empty generics has span == call_site).
+///
+/// return the instance if found.
+pub fn check_type_def_gen_no_bounds(
+	gen: &syn::Generics,
+	span: proc_macro2::Span,
+) -> syn::Result<InstanceUsage> {
+	let expected = "expected `T` or `T, I = ()`";
+	pub struct Checker(InstanceUsage);
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let mut instance_usage = InstanceUsage { has_instance: false, span: input.span() };
+
+			input.parse::<keyword::T>()?;
+			if input.peek(syn::Token![,]) {
+				instance_usage.has_instance = true;
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![=]>()?;
+				input.parse::<Unit>()?;
+			}
+
+			Ok(Self(instance_usage))
+		}
+	}
+
+	let i = syn::parse2::<Checker>(gen.params.to_token_stream())
+		.map_err(|e| {
+			let msg = format!("Invalid type def generics: {}", expected);
+			let mut err = syn::Error::new(span, msg);
+			err.combine(e);
+			err
+		})?
+		.0;
+
+	Ok(i)
+}
+
+/// Check the syntax:
+/// * either `` (no generics
+/// * or `T`
+/// * or `T: Config`
+/// * or `T, I = ()`
+/// * or `T: Config<I>, I: 'static = ()`
+///
+/// `span` is used in case generics is empty (empty generics has span == call_site).
+///
+/// return some instance usage if there is some generic, or none otherwise.
+pub fn check_type_def_optional_gen(
+	gen: &syn::Generics,
+	span: proc_macro2::Span,
+) -> syn::Result<Option<InstanceUsage>> {
+	let expected = "expected `` or `T` or `T: Config` or `T, I = ()` or \
+		`T: Config<I>, I: 'static = ()`";
+	pub struct Checker(Option<InstanceUsage>);
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			if input.is_empty() {
+				return Ok(Self(None))
+			}
+
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
+
+			input.parse::<keyword::T>()?;
+
+			if input.is_empty() {
+				return Ok(Self(Some(instance_usage)))
+			}
+
+			let lookahead = input.lookahead1();
+			if lookahead.peek(syn::Token![,]) {
+				instance_usage.has_instance = true;
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![=]>()?;
+				input.parse::<Unit>()?;
+
+				Ok(Self(Some(instance_usage)))
+			} else if lookahead.peek(syn::Token![:]) {
+				input.parse::<syn::Token![:]>()?;
+				input.parse::<keyword::Config>()?;
+
+				if input.is_empty() {
+					return Ok(Self(Some(instance_usage)))
+				}
+
+				instance_usage.has_instance = true;
+				input.parse::<syn::Token![<]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![>]>()?;
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![:]>()?;
+				input.parse::<StaticLifetime>()?;
+				input.parse::<syn::Token![=]>()?;
+				input.parse::<Unit>()?;
+
+				Ok(Self(Some(instance_usage)))
+			} else {
+				Err(lookahead.error())
+			}
+		}
+	}
+
+	let i = syn::parse2::<Checker>(gen.params.to_token_stream())
+		.map_err(|e| {
+			let msg = format!("Invalid type def generics: {}", expected);
+			let mut err = syn::Error::new(span, msg);
+			err.combine(e);
+			err
+		})?
+		.0
+		// Span can be call_site if generic is empty. Thus we replace it.
+		.map(|mut i| {
+			i.span = span;
+			i
+		});
+
+	Ok(i)
+}
+
+/// Check the syntax:
+/// * either `Pallet<T>`
+/// * or `Pallet<T, I>`
+///
+/// return the instance if found.
+pub fn check_pallet_struct_usage(type_: &Box<syn::Type>) -> syn::Result<InstanceUsage> {
+	let expected = "expected `Pallet<T>` or `Pallet<T, I>`";
+	pub struct Checker(InstanceUsage);
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
+
+			input.parse::<keyword::Pallet>()?;
+			input.parse::<syn::Token![<]>()?;
+			input.parse::<keyword::T>()?;
+			if input.peek(syn::Token![,]) {
+				instance_usage.has_instance = true;
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+			}
+			input.parse::<syn::Token![>]>()?;
+
+			Ok(Self(instance_usage))
+		}
+	}
+
+	let i = syn::parse2::<Checker>(type_.to_token_stream())
+		.map_err(|e| {
+			let msg = format!("Invalid pallet struct: {}", expected);
+			let mut err = syn::Error::new(type_.span(), msg);
+			err.combine(e);
+			err
+		})?
+		.0;
+
+	Ok(i)
+}
+
+/// Check the generic is:
+/// * either `T: Config`
+/// * or `T: Config<I>, I: 'static`
+///
+/// `span` is used in case generics is empty (empty generics has span == call_site).
+///
+/// return whether it contains instance.
+pub fn check_impl_gen(gen: &syn::Generics, span: proc_macro2::Span) -> syn::Result<InstanceUsage> {
+	let expected = "expected `impl<T: Config>` or `impl<T: Config<I>, I: 'static>`";
+	pub struct Checker(InstanceUsage);
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
+
+			input.parse::<keyword::T>()?;
+			input.parse::<syn::Token![:]>()?;
+			input.parse::<keyword::Config>()?;
+			if input.peek(syn::Token![<]) {
+				instance_usage.has_instance = true;
+				input.parse::<syn::Token![<]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![>]>()?;
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![:]>()?;
+				input.parse::<StaticLifetime>()?;
+			}
+
+			Ok(Self(instance_usage))
+		}
+	}
+
+	let i = syn::parse2::<Checker>(gen.params.to_token_stream())
+		.map_err(|e| {
+			let mut err = syn::Error::new(span, format!("Invalid generics: {}", expected));
+			err.combine(e);
+			err
+		})?
+		.0;
+
+	Ok(i)
+}
+
+/// Check the syntax:
+/// * or `T`
+/// * or `T: Config`
+/// * or `T, I = ()`
+/// * or `T: Config<I>, I: 'static = ()`
+///
+/// `span` is used in case generics is empty (empty generics has span == call_site).
+///
+/// return the instance if found.
+pub fn check_type_def_gen(
+	gen: &syn::Generics,
+	span: proc_macro2::Span,
+) -> syn::Result<InstanceUsage> {
+	let expected = "expected `T` or `T: Config` or `T, I = ()` or \
+		`T: Config<I>, I: 'static = ()`";
+	pub struct Checker(InstanceUsage);
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
+
+			input.parse::<keyword::T>()?;
+
+			if input.is_empty() {
+				return Ok(Self(instance_usage))
+			}
+
+			let lookahead = input.lookahead1();
+			if lookahead.peek(syn::Token![,]) {
+				instance_usage.has_instance = true;
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![=]>()?;
+				input.parse::<Unit>()?;
+
+				Ok(Self(instance_usage))
+			} else if lookahead.peek(syn::Token![:]) {
+				input.parse::<syn::Token![:]>()?;
+				input.parse::<keyword::Config>()?;
+
+				if input.is_empty() {
+					return Ok(Self(instance_usage))
+				}
+
+				instance_usage.has_instance = true;
+				input.parse::<syn::Token![<]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![>]>()?;
+				input.parse::<syn::Token![,]>()?;
+				input.parse::<keyword::I>()?;
+				input.parse::<syn::Token![:]>()?;
+				input.parse::<StaticLifetime>()?;
+				input.parse::<syn::Token![=]>()?;
+				input.parse::<Unit>()?;
+
+				Ok(Self(instance_usage))
+			} else {
+				Err(lookahead.error())
+			}
+		}
+	}
+
+	let mut i = syn::parse2::<Checker>(gen.params.to_token_stream())
+		.map_err(|e| {
+			let msg = format!("Invalid type def generics: {}", expected);
+			let mut err = syn::Error::new(span, msg);
+			err.combine(e);
+			err
+		})?
+		.0;
+
+	// Span can be call_site if generic is empty. Thus we replace it.
+	i.span = span;
+
+	Ok(i)
+}
+
+/// Check the syntax:
+/// * either `GenesisBuild<T>`
+/// * or `GenesisBuild<T, I>`
+/// * or `BuildGenesisConfig`
+///
+/// return the instance if found for `GenesisBuild`
+/// return None for BuildGenesisConfig
+pub fn check_genesis_builder_usage(type_: &syn::Path) -> syn::Result<Option<InstanceUsage>> {
+	let expected = "expected `GenesisBuild<T>` or `GenesisBuild<T, I>`";
+	pub struct Checker(Option<InstanceUsage>);
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
+
+			if input.peek(keyword::GenesisBuild) {
+				input.parse::<keyword::GenesisBuild>()?;
+				input.parse::<syn::Token![<]>()?;
+				input.parse::<keyword::T>()?;
+				if input.peek(syn::Token![,]) {
+					instance_usage.has_instance = true;
+					input.parse::<syn::Token![,]>()?;
+					input.parse::<keyword::I>()?;
+				}
+				input.parse::<syn::Token![>]>()?;
+				return Ok(Self(Some(instance_usage)))
+			} else {
+				input.parse::<keyword::BuildGenesisConfig>()?;
+				return Ok(Self(None))
+			}
+		}
+	}
+
+	let i = syn::parse2::<Checker>(type_.to_token_stream())
+		.map_err(|e| {
+			let msg = format!("Invalid genesis builder: {}", expected);
+			let mut err = syn::Error::new(type_.span(), msg);
+			err.combine(e);
+			err
+		})?
+		.0;
+
+	Ok(i)
+}
+
+/// Check the syntax:
+/// * either `` (no generics)
+/// * or `T: Config`
+/// * or `T: Config<I>, I: 'static`
+///
+/// `span` is used in case generics is empty (empty generics has span == call_site).
+///
+/// return the instance if found.
+pub fn check_type_value_gen(
+	gen: &syn::Generics,
+	span: proc_macro2::Span,
+) -> syn::Result<Option<InstanceUsage>> {
+	let expected = "expected `` or `T: Config` or `T: Config<I>, I: 'static`";
+	pub struct Checker(Option<InstanceUsage>);
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			if input.is_empty() {
+				return Ok(Self(None))
+			}
+
+			input.parse::<keyword::T>()?;
+			input.parse::<syn::Token![:]>()?;
+			input.parse::<keyword::Config>()?;
+
+			let mut instance_usage = InstanceUsage { span: input.span(), has_instance: false };
+
+			if input.is_empty() {
+				return Ok(Self(Some(instance_usage)))
+			}
+
+			instance_usage.has_instance = true;
+			input.parse::<syn::Token![<]>()?;
+			input.parse::<keyword::I>()?;
+			input.parse::<syn::Token![>]>()?;
+			input.parse::<syn::Token![,]>()?;
+			input.parse::<keyword::I>()?;
+			input.parse::<syn::Token![:]>()?;
+			input.parse::<StaticLifetime>()?;
+
+			Ok(Self(Some(instance_usage)))
+		}
+	}
+
+	let i = syn::parse2::<Checker>(gen.params.to_token_stream())
+		.map_err(|e| {
+			let msg = format!("Invalid type def generics: {}", expected);
+			let mut err = syn::Error::new(span, msg);
+			err.combine(e);
+			err
+		})?
+		.0
+		// Span can be call_site if generic is empty. Thus we replace it.
+		.map(|mut i| {
+			i.span = span;
+			i
+		});
+
+	Ok(i)
+}
+
+/// Check the keyword `DispatchResultWithPostInfo` or `DispatchResult`.
+pub fn check_pallet_call_return_type(type_: &syn::Type) -> syn::Result<()> {
+	pub struct Checker;
+	impl syn::parse::Parse for Checker {
+		fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+			let lookahead = input.lookahead1();
+			if lookahead.peek(keyword::DispatchResultWithPostInfo) {
+				input.parse::<keyword::DispatchResultWithPostInfo>()?;
+				Ok(Self)
+			} else if lookahead.peek(keyword::DispatchResult) {
+				input.parse::<keyword::DispatchResult>()?;
+				Ok(Self)
+			} else {
+				Err(lookahead.error())
+			}
+		}
+	}
+
+	syn::parse2::<Checker>(type_.to_token_stream()).map(|_| ())
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/hooks.rs b/substrate/frame/support/procedural/src/pallet/parse/hooks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..37d7d22f4b6bb3c60cb8e9c4b9eaffc221ce3b70
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/hooks.rs
@@ -0,0 +1,86 @@
+// 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::helper;
+use syn::spanned::Spanned;
+
+/// Implementation of the pallet hooks.
+pub struct HooksDef {
+	/// The index of item in pallet.
+	pub index: usize,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The where_clause used.
+	pub where_clause: Option<syn::WhereClause>,
+	/// The span of the pallet::hooks attribute.
+	pub attr_span: proc_macro2::Span,
+	/// Boolean flag, set to true if the `on_runtime_upgrade` method of hooks was implemented.
+	pub has_runtime_upgrade: bool,
+}
+
+impl HooksDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Impl(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::hooks, expected item impl";
+			return Err(syn::Error::new(item.span(), msg))
+		};
+
+		let instances = vec![
+			helper::check_pallet_struct_usage(&item.self_ty)?,
+			helper::check_impl_gen(&item.generics, item.impl_token.span())?,
+		];
+
+		let item_trait = &item
+			.trait_
+			.as_ref()
+			.ok_or_else(|| {
+				let msg = "Invalid pallet::hooks, expected impl<..> Hooks \
+					for Pallet<..>";
+				syn::Error::new(item.span(), msg)
+			})?
+			.1;
+
+		if item_trait.segments.len() != 1 || item_trait.segments[0].ident != "Hooks" {
+			let msg = format!(
+				"Invalid pallet::hooks, expected trait to be `Hooks` found `{}`\
+				, you can import from `frame_support::pallet_prelude`",
+				quote::quote!(#item_trait)
+			);
+
+			return Err(syn::Error::new(item_trait.span(), msg))
+		}
+
+		let has_runtime_upgrade = item.items.iter().any(|i| match i {
+			syn::ImplItem::Fn(method) => method.sig.ident == "on_runtime_upgrade",
+			_ => false,
+		});
+
+		Ok(Self {
+			attr_span,
+			index,
+			instances,
+			has_runtime_upgrade,
+			where_clause: item.generics.where_clause.clone(),
+		})
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/inherent.rs b/substrate/frame/support/procedural/src/pallet/parse/inherent.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d8641691a40e30c5a006fc5fb7555910cfe3db35
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/inherent.rs
@@ -0,0 +1,60 @@
+// 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::helper;
+use syn::spanned::Spanned;
+
+/// The definition of the pallet inherent implementation.
+pub struct InherentDef {
+	/// The index of inherent item in pallet module.
+	pub index: usize,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+}
+
+impl InherentDef {
+	pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+		let item = if let syn::Item::Impl(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::inherent, expected item impl";
+			return Err(syn::Error::new(item.span(), msg))
+		};
+
+		if item.trait_.is_none() {
+			let msg = "Invalid pallet::inherent, expected impl<..> ProvideInherent for Pallet<..>";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		if let Some(last) = item.trait_.as_ref().unwrap().1.segments.last() {
+			if last.ident != "ProvideInherent" {
+				let msg = "Invalid pallet::inherent, expected trait ProvideInherent";
+				return Err(syn::Error::new(last.span(), msg))
+			}
+		} else {
+			let msg = "Invalid pallet::inherent, expected impl<..> ProvideInherent for Pallet<..>";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		let instances = vec![
+			helper::check_pallet_struct_usage(&item.self_ty)?,
+			helper::check_impl_gen(&item.generics, item.impl_token.span())?,
+		];
+
+		Ok(InherentDef { index, instances })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/mod.rs b/substrate/frame/support/procedural/src/pallet/parse/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0f5e5f1136610e40226ba880a1b47512d2ee34a9
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/mod.rs
@@ -0,0 +1,594 @@
+// 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.
+
+//! Parse for pallet macro.
+//!
+//! Parse the module into `Def` struct through `Def::try_from` function.
+
+pub mod call;
+pub mod composite;
+pub mod config;
+pub mod error;
+pub mod event;
+pub mod extra_constants;
+pub mod genesis_build;
+pub mod genesis_config;
+pub mod helper;
+pub mod hooks;
+pub mod inherent;
+pub mod origin;
+pub mod pallet_struct;
+pub mod storage;
+pub mod type_value;
+pub mod validate_unsigned;
+
+use composite::{keyword::CompositeKeyword, CompositeDef};
+use frame_support_procedural_tools::generate_crate_access_2018;
+use syn::spanned::Spanned;
+
+/// Parsed definition of a pallet.
+pub struct Def {
+	/// The module items.
+	/// (their order must not be modified because they are registered in individual definitions).
+	pub item: syn::ItemMod,
+	pub config: config::ConfigDef,
+	pub pallet_struct: pallet_struct::PalletStructDef,
+	pub hooks: Option<hooks::HooksDef>,
+	pub call: Option<call::CallDef>,
+	pub storages: Vec<storage::StorageDef>,
+	pub error: Option<error::ErrorDef>,
+	pub event: Option<event::EventDef>,
+	pub origin: Option<origin::OriginDef>,
+	pub inherent: Option<inherent::InherentDef>,
+	pub genesis_config: Option<genesis_config::GenesisConfigDef>,
+	pub genesis_build: Option<genesis_build::GenesisBuildDef>,
+	pub validate_unsigned: Option<validate_unsigned::ValidateUnsignedDef>,
+	pub extra_constants: Option<extra_constants::ExtraConstantsDef>,
+	pub composites: Vec<composite::CompositeDef>,
+	pub type_values: Vec<type_value::TypeValueDef>,
+	pub frame_system: syn::Ident,
+	pub frame_support: syn::Ident,
+	pub dev_mode: bool,
+}
+
+impl Def {
+	pub fn try_from(mut item: syn::ItemMod, dev_mode: bool) -> syn::Result<Self> {
+		let frame_system = generate_crate_access_2018("frame-system")?;
+		let frame_support = generate_crate_access_2018("frame-support")?;
+
+		let item_span = item.span();
+		let items = &mut item
+			.content
+			.as_mut()
+			.ok_or_else(|| {
+				let msg = "Invalid pallet definition, expected mod to be inlined.";
+				syn::Error::new(item_span, msg)
+			})?
+			.1;
+
+		let mut config = None;
+		let mut pallet_struct = None;
+		let mut hooks = None;
+		let mut call = None;
+		let mut error = None;
+		let mut event = None;
+		let mut origin = None;
+		let mut inherent = None;
+		let mut genesis_config = None;
+		let mut genesis_build = None;
+		let mut validate_unsigned = None;
+		let mut extra_constants = None;
+		let mut storages = vec![];
+		let mut type_values = vec![];
+		let mut composites: Vec<CompositeDef> = vec![];
+
+		for (index, item) in items.iter_mut().enumerate() {
+			let pallet_attr: Option<PalletAttr> = helper::take_first_item_pallet_attr(item)?;
+
+			match pallet_attr {
+				Some(PalletAttr::Config(span, with_default)) if config.is_none() =>
+					config = Some(config::ConfigDef::try_from(
+						&frame_system,
+						span,
+						index,
+						item,
+						with_default,
+					)?),
+				Some(PalletAttr::Pallet(span)) if pallet_struct.is_none() => {
+					let p = pallet_struct::PalletStructDef::try_from(span, index, item)?;
+					pallet_struct = Some(p);
+				},
+				Some(PalletAttr::Hooks(span)) if hooks.is_none() => {
+					let m = hooks::HooksDef::try_from(span, index, item)?;
+					hooks = Some(m);
+				},
+				Some(PalletAttr::RuntimeCall(cw, span)) if call.is_none() =>
+					call = Some(call::CallDef::try_from(span, index, item, dev_mode, cw)?),
+				Some(PalletAttr::Error(span)) if error.is_none() =>
+					error = Some(error::ErrorDef::try_from(span, index, item)?),
+				Some(PalletAttr::RuntimeEvent(span)) if event.is_none() =>
+					event = Some(event::EventDef::try_from(span, index, item)?),
+				Some(PalletAttr::GenesisConfig(_)) if genesis_config.is_none() => {
+					let g = genesis_config::GenesisConfigDef::try_from(index, item)?;
+					genesis_config = Some(g);
+				},
+				Some(PalletAttr::GenesisBuild(span)) if genesis_build.is_none() => {
+					let g = genesis_build::GenesisBuildDef::try_from(span, index, item)?;
+					genesis_build = Some(g);
+				},
+				Some(PalletAttr::RuntimeOrigin(_)) if origin.is_none() =>
+					origin = Some(origin::OriginDef::try_from(index, item)?),
+				Some(PalletAttr::Inherent(_)) if inherent.is_none() =>
+					inherent = Some(inherent::InherentDef::try_from(index, item)?),
+				Some(PalletAttr::Storage(span)) =>
+					storages.push(storage::StorageDef::try_from(span, index, item, dev_mode)?),
+				Some(PalletAttr::ValidateUnsigned(_)) if validate_unsigned.is_none() => {
+					let v = validate_unsigned::ValidateUnsignedDef::try_from(index, item)?;
+					validate_unsigned = Some(v);
+				},
+				Some(PalletAttr::TypeValue(span)) =>
+					type_values.push(type_value::TypeValueDef::try_from(span, index, item)?),
+				Some(PalletAttr::ExtraConstants(_)) =>
+					extra_constants =
+						Some(extra_constants::ExtraConstantsDef::try_from(index, item)?),
+				Some(PalletAttr::Composite(span)) => {
+					let composite =
+						composite::CompositeDef::try_from(span, index, &frame_support, item)?;
+					if composites.iter().any(|def| {
+						match (&def.composite_keyword, &composite.composite_keyword) {
+							(
+								CompositeKeyword::FreezeReason(_),
+								CompositeKeyword::FreezeReason(_),
+							) |
+							(CompositeKeyword::HoldReason(_), CompositeKeyword::HoldReason(_)) |
+							(CompositeKeyword::LockId(_), CompositeKeyword::LockId(_)) |
+							(
+								CompositeKeyword::SlashReason(_),
+								CompositeKeyword::SlashReason(_),
+							) => true,
+							_ => false,
+						}
+					}) {
+						let msg = format!(
+							"Invalid duplicated `{}` definition",
+							composite.composite_keyword
+						);
+						return Err(syn::Error::new(composite.composite_keyword.span(), &msg))
+					}
+					composites.push(composite);
+				},
+				Some(attr) => {
+					let msg = "Invalid duplicated attribute";
+					return Err(syn::Error::new(attr.span(), msg))
+				},
+				None => (),
+			}
+		}
+
+		if genesis_config.is_some() != genesis_build.is_some() {
+			let msg = format!(
+				"`#[pallet::genesis_config]` and `#[pallet::genesis_build]` attributes must be \
+				either both used or both not used, instead genesis_config is {} and genesis_build \
+				is {}",
+				genesis_config.as_ref().map_or("unused", |_| "used"),
+				genesis_build.as_ref().map_or("unused", |_| "used"),
+			);
+			return Err(syn::Error::new(item_span, msg))
+		}
+
+		let def = Def {
+			item,
+			config: config
+				.ok_or_else(|| syn::Error::new(item_span, "Missing `#[pallet::config]`"))?,
+			pallet_struct: pallet_struct
+				.ok_or_else(|| syn::Error::new(item_span, "Missing `#[pallet::pallet]`"))?,
+			hooks,
+			call,
+			extra_constants,
+			genesis_config,
+			genesis_build,
+			validate_unsigned,
+			error,
+			event,
+			origin,
+			inherent,
+			storages,
+			composites,
+			type_values,
+			frame_system,
+			frame_support,
+			dev_mode,
+		};
+
+		def.check_instance_usage()?;
+		def.check_event_usage()?;
+
+		Ok(def)
+	}
+
+	/// Check that usage of trait `Event` is consistent with the definition, i.e. it is declared
+	/// and trait defines type RuntimeEvent, or not declared and no trait associated type.
+	fn check_event_usage(&self) -> syn::Result<()> {
+		match (self.config.has_event_type, self.event.is_some()) {
+			(true, false) => {
+				let msg = "Invalid usage of RuntimeEvent, `Config` contains associated type `RuntimeEvent`, \
+					but enum `Event` is not declared (i.e. no use of `#[pallet::event]`). \
+					Note that type `RuntimeEvent` in trait is reserved to work alongside pallet event.";
+				Err(syn::Error::new(proc_macro2::Span::call_site(), msg))
+			},
+			(false, true) => {
+				let msg = "Invalid usage of RuntimeEvent, `Config` contains no associated type \
+					`RuntimeEvent`, but enum `Event` is declared (in use of `#[pallet::event]`). \
+					An RuntimeEvent associated type must be declare on trait `Config`.";
+				Err(syn::Error::new(proc_macro2::Span::call_site(), msg))
+			},
+			_ => Ok(()),
+		}
+	}
+
+	/// Check that usage of trait `Config` is consistent with the definition, i.e. it is used with
+	/// instance iff it is defined with instance.
+	fn check_instance_usage(&self) -> syn::Result<()> {
+		let mut instances = vec![];
+		instances.extend_from_slice(&self.pallet_struct.instances[..]);
+		instances.extend(&mut self.storages.iter().flat_map(|s| s.instances.clone()));
+		if let Some(call) = &self.call {
+			instances.extend_from_slice(&call.instances[..]);
+		}
+		if let Some(hooks) = &self.hooks {
+			instances.extend_from_slice(&hooks.instances[..]);
+		}
+		if let Some(event) = &self.event {
+			instances.extend_from_slice(&event.instances[..]);
+		}
+		if let Some(error) = &self.error {
+			instances.extend_from_slice(&error.instances[..]);
+		}
+		if let Some(inherent) = &self.inherent {
+			instances.extend_from_slice(&inherent.instances[..]);
+		}
+		if let Some(origin) = &self.origin {
+			instances.extend_from_slice(&origin.instances[..]);
+		}
+		if let Some(genesis_config) = &self.genesis_config {
+			instances.extend_from_slice(&genesis_config.instances[..]);
+		}
+		if let Some(genesis_build) = &self.genesis_build {
+			genesis_build.instances.as_ref().map(|i| instances.extend_from_slice(&i));
+		}
+		if let Some(extra_constants) = &self.extra_constants {
+			instances.extend_from_slice(&extra_constants.instances[..]);
+		}
+
+		let mut errors = instances.into_iter().filter_map(|instances| {
+			if instances.has_instance == self.config.has_instance {
+				return None
+			}
+			let msg = if self.config.has_instance {
+				"Invalid generic declaration, trait is defined with instance but generic use none"
+			} else {
+				"Invalid generic declaration, trait is defined without instance but generic use \
+						some"
+			};
+			Some(syn::Error::new(instances.span, msg))
+		});
+
+		if let Some(mut first_error) = errors.next() {
+			for error in errors {
+				first_error.combine(error)
+			}
+			Err(first_error)
+		} else {
+			Ok(())
+		}
+	}
+
+	/// Depending on if pallet is instantiable:
+	/// * either `T: Config`
+	/// * or `T: Config<I>, I: 'static`
+	pub fn type_impl_generics(&self, span: proc_macro2::Span) -> proc_macro2::TokenStream {
+		if self.config.has_instance {
+			quote::quote_spanned!(span => T: Config<I>, I: 'static)
+		} else {
+			quote::quote_spanned!(span => T: Config)
+		}
+	}
+
+	/// Depending on if pallet is instantiable:
+	/// * either `T: Config`
+	/// * or `T: Config<I>, I: 'static = ()`
+	pub fn type_decl_bounded_generics(&self, span: proc_macro2::Span) -> proc_macro2::TokenStream {
+		if self.config.has_instance {
+			quote::quote_spanned!(span => T: Config<I>, I: 'static = ())
+		} else {
+			quote::quote_spanned!(span => T: Config)
+		}
+	}
+
+	/// Depending on if pallet is instantiable:
+	/// * either `T`
+	/// * or `T, I = ()`
+	pub fn type_decl_generics(&self, span: proc_macro2::Span) -> proc_macro2::TokenStream {
+		if self.config.has_instance {
+			quote::quote_spanned!(span => T, I = ())
+		} else {
+			quote::quote_spanned!(span => T)
+		}
+	}
+
+	/// Depending on if pallet is instantiable:
+	/// * either ``
+	/// * or `<I>`
+	/// to be used when using pallet trait `Config`
+	pub fn trait_use_generics(&self, span: proc_macro2::Span) -> proc_macro2::TokenStream {
+		if self.config.has_instance {
+			quote::quote_spanned!(span => <I>)
+		} else {
+			quote::quote_spanned!(span => )
+		}
+	}
+
+	/// Depending on if pallet is instantiable:
+	/// * either `T`
+	/// * or `T, I`
+	pub fn type_use_generics(&self, span: proc_macro2::Span) -> proc_macro2::TokenStream {
+		if self.config.has_instance {
+			quote::quote_spanned!(span => T, I)
+		} else {
+			quote::quote_spanned!(span => T)
+		}
+	}
+}
+
+/// Some generic kind for type which can be not generic, or generic over config,
+/// or generic over config and instance, but not generic only over instance.
+pub enum GenericKind {
+	None,
+	Config,
+	ConfigAndInstance,
+}
+
+impl GenericKind {
+	/// Return Err if it is only generics over instance but not over config.
+	pub fn from_gens(has_config: bool, has_instance: bool) -> Result<Self, ()> {
+		match (has_config, has_instance) {
+			(false, false) => Ok(GenericKind::None),
+			(true, false) => Ok(GenericKind::Config),
+			(true, true) => Ok(GenericKind::ConfigAndInstance),
+			(false, true) => Err(()),
+		}
+	}
+
+	/// Return the generic to be used when using the type.
+	///
+	/// Depending on its definition it can be: ``, `T` or `T, I`
+	pub fn type_use_gen(&self, span: proc_macro2::Span) -> proc_macro2::TokenStream {
+		match self {
+			GenericKind::None => quote::quote!(),
+			GenericKind::Config => quote::quote_spanned!(span => T),
+			GenericKind::ConfigAndInstance => quote::quote_spanned!(span => T, I),
+		}
+	}
+
+	/// Return the generic to be used in `impl<..>` when implementing on the type.
+	pub fn type_impl_gen(&self, span: proc_macro2::Span) -> proc_macro2::TokenStream {
+		match self {
+			GenericKind::None => quote::quote!(),
+			GenericKind::Config => quote::quote_spanned!(span => T: Config),
+			GenericKind::ConfigAndInstance => {
+				quote::quote_spanned!(span => T: Config<I>, I: 'static)
+			},
+		}
+	}
+
+	/// Return whereas the type has some generic.
+	pub fn is_generic(&self) -> bool {
+		match self {
+			GenericKind::None => false,
+			GenericKind::Config | GenericKind::ConfigAndInstance => true,
+		}
+	}
+}
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(origin);
+	syn::custom_keyword!(call);
+	syn::custom_keyword!(weight);
+	syn::custom_keyword!(event);
+	syn::custom_keyword!(config);
+	syn::custom_keyword!(with_default);
+	syn::custom_keyword!(hooks);
+	syn::custom_keyword!(inherent);
+	syn::custom_keyword!(error);
+	syn::custom_keyword!(storage);
+	syn::custom_keyword!(genesis_build);
+	syn::custom_keyword!(genesis_config);
+	syn::custom_keyword!(validate_unsigned);
+	syn::custom_keyword!(type_value);
+	syn::custom_keyword!(pallet);
+	syn::custom_keyword!(generate_store);
+	syn::custom_keyword!(Store);
+	syn::custom_keyword!(extra_constants);
+	syn::custom_keyword!(composite_enum);
+}
+
+/// Parse attributes for item in pallet module
+/// syntax must be `pallet::` (e.g. `#[pallet::config]`)
+enum PalletAttr {
+	Config(proc_macro2::Span, bool),
+	Pallet(proc_macro2::Span),
+	Hooks(proc_macro2::Span),
+	/// A `#[pallet::call]` with optional attributes to specialize the behaviour.
+	///
+	/// # Attributes
+	///
+	/// Each attribute `attr` can take the form of `#[pallet::call(attr = …)]` or
+	/// `#[pallet::call(attr(…))]`. The possible attributes are:
+	///
+	/// ## `weight`
+	///
+	/// Can be used to reduce the repetitive weight annotation in the trivial case. It accepts one
+	/// argument that is expected to be an implementation of the `WeightInfo` or something that
+	/// behaves syntactically equivalent. This allows to annotate a `WeightInfo` for all the calls.
+	/// Now each call does not need to specify its own `#[pallet::weight]` but can instead use the
+	/// one from the `#[pallet::call]` definition. So instead of having to write it on each call:
+	///
+	/// ```ignore
+	/// #[pallet::call]
+	/// impl<T: Config> Pallet<T> {
+	///     #[pallet::weight(T::WeightInfo::create())]
+	///     pub fn create(
+	/// ```
+	/// you can now omit it on the call itself, if the name of the weigh function matches the call:
+	///
+	/// ```ignore
+	/// #[pallet::call(weight = <T as crate::Config>::WeightInfo)]
+	/// impl<T: Config> Pallet<T> {
+	///     pub fn create(
+	/// ```
+	///
+	/// It is possible to use this syntax together with instantiated pallets by using `Config<I>`
+	/// instead.
+	///
+	/// ### Dev Mode
+	///
+	/// Normally the `dev_mode` sets all weights of calls without a `#[pallet::weight]` annotation
+	/// to zero. Now when there is a `weight` attribute on the `#[pallet::call]`, then that is used
+	/// instead of the zero weight. So to say: it works together with `dev_mode`.
+	RuntimeCall(Option<InheritedCallWeightAttr>, proc_macro2::Span),
+	Error(proc_macro2::Span),
+	RuntimeEvent(proc_macro2::Span),
+	RuntimeOrigin(proc_macro2::Span),
+	Inherent(proc_macro2::Span),
+	Storage(proc_macro2::Span),
+	GenesisConfig(proc_macro2::Span),
+	GenesisBuild(proc_macro2::Span),
+	ValidateUnsigned(proc_macro2::Span),
+	TypeValue(proc_macro2::Span),
+	ExtraConstants(proc_macro2::Span),
+	Composite(proc_macro2::Span),
+}
+
+impl PalletAttr {
+	fn span(&self) -> proc_macro2::Span {
+		match self {
+			Self::Config(span, _) => *span,
+			Self::Pallet(span) => *span,
+			Self::Hooks(span) => *span,
+			Self::RuntimeCall(_, span) => *span,
+			Self::Error(span) => *span,
+			Self::RuntimeEvent(span) => *span,
+			Self::RuntimeOrigin(span) => *span,
+			Self::Inherent(span) => *span,
+			Self::Storage(span) => *span,
+			Self::GenesisConfig(span) => *span,
+			Self::GenesisBuild(span) => *span,
+			Self::ValidateUnsigned(span) => *span,
+			Self::TypeValue(span) => *span,
+			Self::ExtraConstants(span) => *span,
+			Self::Composite(span) => *span,
+		}
+	}
+}
+
+impl syn::parse::Parse for PalletAttr {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<keyword::pallet>()?;
+		content.parse::<syn::Token![::]>()?;
+
+		let lookahead = content.lookahead1();
+		if lookahead.peek(keyword::config) {
+			let span = content.parse::<keyword::config>()?.span();
+			let with_default = content.peek(syn::token::Paren);
+			if with_default {
+				let inside_config;
+				let _paren = syn::parenthesized!(inside_config in content);
+				inside_config.parse::<keyword::with_default>()?;
+			}
+			Ok(PalletAttr::Config(span, with_default))
+		} else if lookahead.peek(keyword::pallet) {
+			Ok(PalletAttr::Pallet(content.parse::<keyword::pallet>()?.span()))
+		} else if lookahead.peek(keyword::hooks) {
+			Ok(PalletAttr::Hooks(content.parse::<keyword::hooks>()?.span()))
+		} else if lookahead.peek(keyword::call) {
+			let span = content.parse::<keyword::call>().expect("peeked").span();
+			let attr = match content.is_empty() {
+				true => None,
+				false => Some(InheritedCallWeightAttr::parse(&content)?),
+			};
+			Ok(PalletAttr::RuntimeCall(attr, span))
+		} else if lookahead.peek(keyword::error) {
+			Ok(PalletAttr::Error(content.parse::<keyword::error>()?.span()))
+		} else if lookahead.peek(keyword::event) {
+			Ok(PalletAttr::RuntimeEvent(content.parse::<keyword::event>()?.span()))
+		} else if lookahead.peek(keyword::origin) {
+			Ok(PalletAttr::RuntimeOrigin(content.parse::<keyword::origin>()?.span()))
+		} else if lookahead.peek(keyword::inherent) {
+			Ok(PalletAttr::Inherent(content.parse::<keyword::inherent>()?.span()))
+		} else if lookahead.peek(keyword::storage) {
+			Ok(PalletAttr::Storage(content.parse::<keyword::storage>()?.span()))
+		} else if lookahead.peek(keyword::genesis_config) {
+			Ok(PalletAttr::GenesisConfig(content.parse::<keyword::genesis_config>()?.span()))
+		} else if lookahead.peek(keyword::genesis_build) {
+			Ok(PalletAttr::GenesisBuild(content.parse::<keyword::genesis_build>()?.span()))
+		} else if lookahead.peek(keyword::validate_unsigned) {
+			Ok(PalletAttr::ValidateUnsigned(content.parse::<keyword::validate_unsigned>()?.span()))
+		} else if lookahead.peek(keyword::type_value) {
+			Ok(PalletAttr::TypeValue(content.parse::<keyword::type_value>()?.span()))
+		} else if lookahead.peek(keyword::extra_constants) {
+			Ok(PalletAttr::ExtraConstants(content.parse::<keyword::extra_constants>()?.span()))
+		} else if lookahead.peek(keyword::composite_enum) {
+			Ok(PalletAttr::Composite(content.parse::<keyword::composite_enum>()?.span()))
+		} else {
+			Err(lookahead.error())
+		}
+	}
+}
+
+/// The optional weight annotation on a `#[pallet::call]` like `#[pallet::call(weight($type))]`.
+#[derive(Clone)]
+pub struct InheritedCallWeightAttr {
+	pub typename: syn::Type,
+	pub span: proc_macro2::Span,
+}
+
+impl syn::parse::Parse for InheritedCallWeightAttr {
+	// Parses `(weight($type))` or `(weight = $type)`.
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		let content;
+		syn::parenthesized!(content in input);
+		content.parse::<keyword::weight>()?;
+		let lookahead = content.lookahead1();
+
+		let buffer = if lookahead.peek(syn::token::Paren) {
+			let inner;
+			syn::parenthesized!(inner in content);
+			inner
+		} else if lookahead.peek(syn::Token![=]) {
+			content.parse::<syn::Token![=]>().expect("peeked");
+			content
+		} else {
+			return Err(lookahead.error())
+		};
+
+		Ok(Self { typename: buffer.parse()?, span: input.span() })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/origin.rs b/substrate/frame/support/procedural/src/pallet/parse/origin.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76e2a8841196b9a7c85f220a4698b0661c3c4e11
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/origin.rs
@@ -0,0 +1,72 @@
+// 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::helper;
+use syn::spanned::Spanned;
+
+/// Definition of the pallet origin type.
+///
+/// Either:
+/// * `type Origin`
+/// * `struct Origin`
+/// * `enum Origin`
+pub struct OriginDef {
+	/// The index of item in pallet module.
+	pub index: usize,
+	pub has_instance: bool,
+	pub is_generic: bool,
+	/// A set of usage of instance, must be check for consistency with trait.
+	pub instances: Vec<helper::InstanceUsage>,
+}
+
+impl OriginDef {
+	pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+		let item_span = item.span();
+		let (vis, ident, generics) = match &item {
+			syn::Item::Enum(item) => (&item.vis, &item.ident, &item.generics),
+			syn::Item::Struct(item) => (&item.vis, &item.ident, &item.generics),
+			syn::Item::Type(item) => (&item.vis, &item.ident, &item.generics),
+			_ => {
+				let msg = "Invalid pallet::origin, expected enum or struct or type";
+				return Err(syn::Error::new(item.span(), msg))
+			},
+		};
+
+		let has_instance = generics.params.len() == 2;
+		let is_generic = !generics.params.is_empty();
+
+		let mut instances = vec![];
+		if let Some(u) = helper::check_type_def_optional_gen(generics, item.span())? {
+			instances.push(u);
+		} else {
+			// construct_runtime only allow generic event for instantiable pallet.
+			instances.push(helper::InstanceUsage { has_instance: false, span: ident.span() })
+		}
+
+		if !matches!(vis, syn::Visibility::Public(_)) {
+			let msg = "Invalid pallet::origin, Origin must be public";
+			return Err(syn::Error::new(item_span, msg))
+		}
+
+		if ident != "Origin" {
+			let msg = "Invalid pallet::origin, ident must `Origin`";
+			return Err(syn::Error::new(ident.span(), msg))
+		}
+
+		Ok(OriginDef { index, has_instance, is_generic, instances })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/pallet_struct.rs b/substrate/frame/support/procedural/src/pallet/parse/pallet_struct.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f4af86aa3e9936a3e77036f062ba8d4bf1a6c601
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/pallet_struct.rs
@@ -0,0 +1,171 @@
+// 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::helper;
+use quote::ToTokens;
+use syn::spanned::Spanned;
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(pallet);
+	syn::custom_keyword!(Pallet);
+	syn::custom_keyword!(generate_store);
+	syn::custom_keyword!(without_storage_info);
+	syn::custom_keyword!(storage_version);
+	syn::custom_keyword!(Store);
+}
+
+/// Definition of the pallet pallet.
+pub struct PalletStructDef {
+	/// The index of item in pallet pallet.
+	pub index: usize,
+	/// A set of usage of instance, must be check for consistency with config trait.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The keyword Pallet used (contains span).
+	pub pallet: keyword::Pallet,
+	/// Whether the trait `Store` must be generated.
+	pub store: Option<(syn::Visibility, keyword::Store, proc_macro2::Span)>,
+	/// The span of the pallet::pallet attribute.
+	pub attr_span: proc_macro2::Span,
+	/// Whether to specify the storages max encoded len when implementing `StorageInfoTrait`.
+	/// Contains the span of the attribute.
+	pub without_storage_info: Option<proc_macro2::Span>,
+	/// The current storage version of the pallet.
+	pub storage_version: Option<syn::Path>,
+}
+
+/// Parse for one variant of:
+/// * `#[pallet::generate_store($vis trait Store)]`
+/// * `#[pallet::without_storage_info]`
+/// * `#[pallet::storage_version(STORAGE_VERSION)]`
+pub enum PalletStructAttr {
+	GenerateStore { span: proc_macro2::Span, vis: syn::Visibility, keyword: keyword::Store },
+	WithoutStorageInfoTrait(proc_macro2::Span),
+	StorageVersion { storage_version: syn::Path, span: proc_macro2::Span },
+}
+
+impl PalletStructAttr {
+	fn span(&self) -> proc_macro2::Span {
+		match self {
+			Self::GenerateStore { span, .. } |
+			Self::WithoutStorageInfoTrait(span) |
+			Self::StorageVersion { span, .. } => *span,
+		}
+	}
+}
+
+impl syn::parse::Parse for PalletStructAttr {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<keyword::pallet>()?;
+		content.parse::<syn::Token![::]>()?;
+
+		let lookahead = content.lookahead1();
+		if lookahead.peek(keyword::generate_store) {
+			content.parse::<keyword::generate_store>()?;
+			let generate_content;
+			syn::parenthesized!(generate_content in content);
+			let vis = generate_content.parse::<syn::Visibility>()?;
+			generate_content.parse::<syn::Token![trait]>()?;
+			let keyword = generate_content.parse::<keyword::Store>()?;
+			let span = content.span();
+			Ok(Self::GenerateStore { vis, keyword, span })
+		} else if lookahead.peek(keyword::without_storage_info) {
+			let span = content.parse::<keyword::without_storage_info>()?.span();
+			Ok(Self::WithoutStorageInfoTrait(span))
+		} else if lookahead.peek(keyword::storage_version) {
+			let span = content.parse::<keyword::storage_version>()?.span();
+
+			let version_content;
+			syn::parenthesized!(version_content in content);
+			let storage_version = version_content.parse::<syn::Path>()?;
+
+			Ok(Self::StorageVersion { storage_version, span })
+		} else {
+			Err(lookahead.error())
+		}
+	}
+}
+
+impl PalletStructDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Struct(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::pallet, expected struct definition";
+			return Err(syn::Error::new(item.span(), msg))
+		};
+
+		let mut store = None;
+		let mut without_storage_info = None;
+		let mut storage_version_found = None;
+
+		let struct_attrs: Vec<PalletStructAttr> = helper::take_item_pallet_attrs(&mut item.attrs)?;
+		for attr in struct_attrs {
+			match attr {
+				PalletStructAttr::GenerateStore { vis, keyword, span } if store.is_none() => {
+					store = Some((vis, keyword, span));
+				},
+				PalletStructAttr::WithoutStorageInfoTrait(span)
+					if without_storage_info.is_none() =>
+				{
+					without_storage_info = Some(span);
+				},
+				PalletStructAttr::StorageVersion { storage_version, .. }
+					if storage_version_found.is_none() =>
+				{
+					storage_version_found = Some(storage_version);
+				},
+				attr => {
+					let msg = "Unexpected duplicated attribute";
+					return Err(syn::Error::new(attr.span(), msg))
+				},
+			}
+		}
+
+		let pallet = syn::parse2::<keyword::Pallet>(item.ident.to_token_stream())?;
+
+		if !matches!(item.vis, syn::Visibility::Public(_)) {
+			let msg = "Invalid pallet::pallet, Pallet must be public";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		if item.generics.where_clause.is_some() {
+			let msg = "Invalid pallet::pallet, where clause not supported on Pallet declaration";
+			return Err(syn::Error::new(item.generics.where_clause.span(), msg))
+		}
+
+		let instances =
+			vec![helper::check_type_def_gen_no_bounds(&item.generics, item.ident.span())?];
+
+		Ok(Self {
+			index,
+			instances,
+			pallet,
+			store,
+			attr_span,
+			without_storage_info,
+			storage_version: storage_version_found,
+		})
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/storage.rs b/substrate/frame/support/procedural/src/pallet/parse/storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3a0ec4747153a512ae642d810624e0487c7699a7
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/storage.rs
@@ -0,0 +1,927 @@
+// 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::helper;
+use frame_support_procedural_tools::get_doc_literals;
+use quote::ToTokens;
+use std::collections::HashMap;
+use syn::spanned::Spanned;
+
+/// List of additional token to be used for parsing.
+mod keyword {
+	syn::custom_keyword!(Error);
+	syn::custom_keyword!(pallet);
+	syn::custom_keyword!(getter);
+	syn::custom_keyword!(storage_prefix);
+	syn::custom_keyword!(unbounded);
+	syn::custom_keyword!(whitelist_storage);
+	syn::custom_keyword!(OptionQuery);
+	syn::custom_keyword!(ResultQuery);
+	syn::custom_keyword!(ValueQuery);
+}
+
+/// Parse for one of the following:
+/// * `#[pallet::getter(fn dummy)]`
+/// * `#[pallet::storage_prefix = "CustomName"]`
+/// * `#[pallet::unbounded]`
+/// * `#[pallet::whitelist_storage]
+pub enum PalletStorageAttr {
+	Getter(syn::Ident, proc_macro2::Span),
+	StorageName(syn::LitStr, proc_macro2::Span),
+	Unbounded(proc_macro2::Span),
+	WhitelistStorage(proc_macro2::Span),
+}
+
+impl PalletStorageAttr {
+	fn attr_span(&self) -> proc_macro2::Span {
+		match self {
+			Self::Getter(_, span) |
+			Self::StorageName(_, span) |
+			Self::Unbounded(span) |
+			Self::WhitelistStorage(span) => *span,
+		}
+	}
+}
+
+impl syn::parse::Parse for PalletStorageAttr {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		input.parse::<syn::Token![#]>()?;
+		let attr_span = input.span();
+		let content;
+		syn::bracketed!(content in input);
+		content.parse::<keyword::pallet>()?;
+		content.parse::<syn::Token![::]>()?;
+
+		let lookahead = content.lookahead1();
+		if lookahead.peek(keyword::getter) {
+			content.parse::<keyword::getter>()?;
+
+			let generate_content;
+			syn::parenthesized!(generate_content in content);
+			generate_content.parse::<syn::Token![fn]>()?;
+			Ok(Self::Getter(generate_content.parse::<syn::Ident>()?, attr_span))
+		} else if lookahead.peek(keyword::storage_prefix) {
+			content.parse::<keyword::storage_prefix>()?;
+			content.parse::<syn::Token![=]>()?;
+
+			let renamed_prefix = content.parse::<syn::LitStr>()?;
+			// Ensure the renamed prefix is a proper Rust identifier
+			syn::parse_str::<syn::Ident>(&renamed_prefix.value()).map_err(|_| {
+				let msg = format!("`{}` is not a valid identifier", renamed_prefix.value());
+				syn::Error::new(renamed_prefix.span(), msg)
+			})?;
+
+			Ok(Self::StorageName(renamed_prefix, attr_span))
+		} else if lookahead.peek(keyword::unbounded) {
+			content.parse::<keyword::unbounded>()?;
+
+			Ok(Self::Unbounded(attr_span))
+		} else if lookahead.peek(keyword::whitelist_storage) {
+			content.parse::<keyword::whitelist_storage>()?;
+			Ok(Self::WhitelistStorage(attr_span))
+		} else {
+			Err(lookahead.error())
+		}
+	}
+}
+
+struct PalletStorageAttrInfo {
+	getter: Option<syn::Ident>,
+	rename_as: Option<syn::LitStr>,
+	unbounded: bool,
+	whitelisted: bool,
+}
+
+impl PalletStorageAttrInfo {
+	fn from_attrs(attrs: Vec<PalletStorageAttr>) -> syn::Result<Self> {
+		let mut getter = None;
+		let mut rename_as = None;
+		let mut unbounded = false;
+		let mut whitelisted = false;
+		for attr in attrs {
+			match attr {
+				PalletStorageAttr::Getter(ident, ..) if getter.is_none() => getter = Some(ident),
+				PalletStorageAttr::StorageName(name, ..) if rename_as.is_none() =>
+					rename_as = Some(name),
+				PalletStorageAttr::Unbounded(..) if !unbounded => unbounded = true,
+				PalletStorageAttr::WhitelistStorage(..) if !whitelisted => whitelisted = true,
+				attr =>
+					return Err(syn::Error::new(
+						attr.attr_span(),
+						"Invalid attribute: Duplicate attribute",
+					)),
+			}
+		}
+
+		Ok(PalletStorageAttrInfo { getter, rename_as, unbounded, whitelisted })
+	}
+}
+
+/// The value and key types used by storages. Needed to expand metadata.
+pub enum Metadata {
+	Value { value: syn::Type },
+	Map { value: syn::Type, key: syn::Type },
+	CountedMap { value: syn::Type, key: syn::Type },
+	DoubleMap { value: syn::Type, key1: syn::Type, key2: syn::Type },
+	NMap { keys: Vec<syn::Type>, keygen: syn::Type, value: syn::Type },
+	CountedNMap { keys: Vec<syn::Type>, keygen: syn::Type, value: syn::Type },
+}
+
+pub enum QueryKind {
+	OptionQuery,
+	ResultQuery(syn::Path, syn::Ident),
+	ValueQuery,
+}
+
+/// Definition of a storage, storage is a storage type like
+/// `type MyStorage = StorageValue<MyStorageP, u32>`
+/// The keys and values types are parsed in order to get metadata
+pub struct StorageDef {
+	/// The index of error item in pallet module.
+	pub index: usize,
+	/// Visibility of the storage type.
+	pub vis: syn::Visibility,
+	/// The type ident, to generate the StoragePrefix for.
+	pub ident: syn::Ident,
+	/// The keys and value metadata of the storage.
+	pub metadata: Metadata,
+	/// The doc associated to the storage.
+	pub docs: Vec<syn::Expr>,
+	/// A set of usage of instance, must be check for consistency with config.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// Optional getter to generate. If some then query_kind is ensured to be some as well.
+	pub getter: Option<syn::Ident>,
+	/// Optional expression that evaluates to a type that can be used as StoragePrefix instead of
+	/// ident.
+	pub rename_as: Option<syn::LitStr>,
+	/// Whereas the querytype of the storage is OptionQuery, ResultQuery or ValueQuery.
+	/// Note that this is best effort as it can't be determined when QueryKind is generic, and
+	/// result can be false if user do some unexpected type alias.
+	pub query_kind: Option<QueryKind>,
+	/// Where clause of type definition.
+	pub where_clause: Option<syn::WhereClause>,
+	/// The span of the pallet::storage attribute.
+	pub attr_span: proc_macro2::Span,
+	/// The `cfg` attributes.
+	pub cfg_attrs: Vec<syn::Attribute>,
+	/// If generics are named (e.g. `StorageValue<Value = u32, ..>`) then this contains all the
+	/// generics of the storage.
+	/// If generics are not named, this is none.
+	pub named_generics: Option<StorageGenerics>,
+	/// If the value stored in this storage is unbounded.
+	pub unbounded: bool,
+	/// Whether or not reads to this storage key will be ignored by benchmarking
+	pub whitelisted: bool,
+	/// Whether or not a default hasher is allowed to replace `_`
+	pub use_default_hasher: bool,
+}
+
+/// The parsed generic from the
+#[derive(Clone)]
+pub enum StorageGenerics {
+	DoubleMap {
+		hasher1: syn::Type,
+		key1: syn::Type,
+		hasher2: syn::Type,
+		key2: syn::Type,
+		value: syn::Type,
+		query_kind: Option<syn::Type>,
+		on_empty: Option<syn::Type>,
+		max_values: Option<syn::Type>,
+	},
+	Map {
+		hasher: syn::Type,
+		key: syn::Type,
+		value: syn::Type,
+		query_kind: Option<syn::Type>,
+		on_empty: Option<syn::Type>,
+		max_values: Option<syn::Type>,
+	},
+	CountedMap {
+		hasher: syn::Type,
+		key: syn::Type,
+		value: syn::Type,
+		query_kind: Option<syn::Type>,
+		on_empty: Option<syn::Type>,
+		max_values: Option<syn::Type>,
+	},
+	Value {
+		value: syn::Type,
+		query_kind: Option<syn::Type>,
+		on_empty: Option<syn::Type>,
+	},
+	NMap {
+		keygen: syn::Type,
+		value: syn::Type,
+		query_kind: Option<syn::Type>,
+		on_empty: Option<syn::Type>,
+		max_values: Option<syn::Type>,
+	},
+	CountedNMap {
+		keygen: syn::Type,
+		value: syn::Type,
+		query_kind: Option<syn::Type>,
+		on_empty: Option<syn::Type>,
+		max_values: Option<syn::Type>,
+	},
+}
+
+impl StorageGenerics {
+	/// Return the metadata from the defined generics
+	fn metadata(&self) -> syn::Result<Metadata> {
+		let res = match self.clone() {
+			Self::DoubleMap { value, key1, key2, .. } => Metadata::DoubleMap { value, key1, key2 },
+			Self::Map { value, key, .. } => Metadata::Map { value, key },
+			Self::CountedMap { value, key, .. } => Metadata::CountedMap { value, key },
+			Self::Value { value, .. } => Metadata::Value { value },
+			Self::NMap { keygen, value, .. } =>
+				Metadata::NMap { keys: collect_keys(&keygen)?, keygen, value },
+			Self::CountedNMap { keygen, value, .. } =>
+				Metadata::CountedNMap { keys: collect_keys(&keygen)?, keygen, value },
+		};
+
+		Ok(res)
+	}
+
+	/// Return the query kind from the defined generics
+	fn query_kind(&self) -> Option<syn::Type> {
+		match &self {
+			Self::DoubleMap { query_kind, .. } |
+			Self::Map { query_kind, .. } |
+			Self::CountedMap { query_kind, .. } |
+			Self::Value { query_kind, .. } |
+			Self::NMap { query_kind, .. } |
+			Self::CountedNMap { query_kind, .. } => query_kind.clone(),
+		}
+	}
+}
+
+enum StorageKind {
+	Value,
+	Map,
+	CountedMap,
+	DoubleMap,
+	NMap,
+	CountedNMap,
+}
+
+/// Check the generics in the `map` contains the generics in `gen` may contains generics in
+/// `optional_gen`, and doesn't contains any other.
+fn check_generics(
+	map: &HashMap<String, syn::AssocType>,
+	mandatory_generics: &[&str],
+	optional_generics: &[&str],
+	storage_type_name: &str,
+	args_span: proc_macro2::Span,
+) -> syn::Result<()> {
+	let mut errors = vec![];
+
+	let expectation = {
+		let mut e = format!(
+			"`{}` expect generics {}and optional generics {}",
+			storage_type_name,
+			mandatory_generics
+				.iter()
+				.map(|name| format!("`{}`, ", name))
+				.collect::<String>(),
+			&optional_generics.iter().map(|name| format!("`{}`, ", name)).collect::<String>(),
+		);
+		e.pop();
+		e.pop();
+		e.push('.');
+		e
+	};
+
+	for (gen_name, gen_binding) in map {
+		if !mandatory_generics.contains(&gen_name.as_str()) &&
+			!optional_generics.contains(&gen_name.as_str())
+		{
+			let msg = format!(
+				"Invalid pallet::storage, Unexpected generic `{}` for `{}`. {}",
+				gen_name, storage_type_name, expectation,
+			);
+			errors.push(syn::Error::new(gen_binding.span(), msg));
+		}
+	}
+
+	for mandatory_generic in mandatory_generics {
+		if !map.contains_key(&mandatory_generic.to_string()) {
+			let msg = format!(
+				"Invalid pallet::storage, cannot find `{}` generic, required for `{}`.",
+				mandatory_generic, storage_type_name
+			);
+			errors.push(syn::Error::new(args_span, msg));
+		}
+	}
+
+	let mut errors = errors.drain(..);
+	if let Some(mut error) = errors.next() {
+		for other_error in errors {
+			error.combine(other_error);
+		}
+		Err(error)
+	} else {
+		Ok(())
+	}
+}
+
+/// Returns `(named generics, metadata, query kind, use_default_hasher)`
+fn process_named_generics(
+	storage: &StorageKind,
+	args_span: proc_macro2::Span,
+	args: &[syn::AssocType],
+	dev_mode: bool,
+) -> syn::Result<(Option<StorageGenerics>, Metadata, Option<syn::Type>, bool)> {
+	let mut parsed = HashMap::<String, syn::AssocType>::new();
+
+	// Ensure no duplicate.
+	for arg in args {
+		if let Some(other) = parsed.get(&arg.ident.to_string()) {
+			let msg = "Invalid pallet::storage, Duplicated named generic";
+			let mut err = syn::Error::new(arg.ident.span(), msg);
+			err.combine(syn::Error::new(other.ident.span(), msg));
+			return Err(err)
+		}
+		parsed.insert(arg.ident.to_string(), arg.clone());
+	}
+
+	let mut map_mandatory_generics = vec!["Key", "Value"];
+	let mut map_optional_generics = vec!["QueryKind", "OnEmpty", "MaxValues"];
+	if dev_mode {
+		map_optional_generics.push("Hasher");
+	} else {
+		map_mandatory_generics.push("Hasher");
+	}
+
+	let generics = match storage {
+		StorageKind::Value => {
+			check_generics(
+				&parsed,
+				&["Value"],
+				&["QueryKind", "OnEmpty"],
+				"StorageValue",
+				args_span,
+			)?;
+
+			StorageGenerics::Value {
+				value: parsed
+					.remove("Value")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
+				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
+			}
+		},
+		StorageKind::Map => {
+			check_generics(
+				&parsed,
+				&map_mandatory_generics,
+				&map_optional_generics,
+				"StorageMap",
+				args_span,
+			)?;
+
+			StorageGenerics::Map {
+				hasher: parsed
+					.remove("Hasher")
+					.map(|binding| binding.ty)
+					.unwrap_or(syn::parse_quote!(Blake2_128Concat)),
+				key: parsed
+					.remove("Key")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				value: parsed
+					.remove("Value")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
+				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
+				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
+			}
+		},
+		StorageKind::CountedMap => {
+			check_generics(
+				&parsed,
+				&map_mandatory_generics,
+				&map_optional_generics,
+				"CountedStorageMap",
+				args_span,
+			)?;
+
+			StorageGenerics::CountedMap {
+				hasher: parsed
+					.remove("Hasher")
+					.map(|binding| binding.ty)
+					.unwrap_or(syn::Type::Verbatim(quote::quote! { Blake2_128Concat })),
+				key: parsed
+					.remove("Key")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				value: parsed
+					.remove("Value")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
+				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
+				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
+			}
+		},
+		StorageKind::DoubleMap => {
+			let mut double_map_mandatory_generics = vec!["Key1", "Key2", "Value"];
+			if dev_mode {
+				map_optional_generics.extend(["Hasher1", "Hasher2"]);
+			} else {
+				double_map_mandatory_generics.extend(["Hasher1", "Hasher2"]);
+			}
+
+			check_generics(
+				&parsed,
+				&double_map_mandatory_generics,
+				&map_optional_generics,
+				"StorageDoubleMap",
+				args_span,
+			)?;
+
+			StorageGenerics::DoubleMap {
+				hasher1: parsed
+					.remove("Hasher1")
+					.map(|binding| binding.ty)
+					.unwrap_or(syn::parse_quote!(Blake2_128Concat)),
+				key1: parsed
+					.remove("Key1")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				hasher2: parsed
+					.remove("Hasher2")
+					.map(|binding| binding.ty)
+					.unwrap_or(syn::parse_quote!(Blake2_128Concat)),
+				key2: parsed
+					.remove("Key2")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				value: parsed
+					.remove("Value")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
+				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
+				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
+			}
+		},
+		StorageKind::NMap => {
+			check_generics(
+				&parsed,
+				&["Key", "Value"],
+				&["QueryKind", "OnEmpty", "MaxValues"],
+				"StorageNMap",
+				args_span,
+			)?;
+
+			StorageGenerics::NMap {
+				keygen: parsed
+					.remove("Key")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				value: parsed
+					.remove("Value")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
+				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
+				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
+			}
+		},
+		StorageKind::CountedNMap => {
+			check_generics(
+				&parsed,
+				&["Key", "Value"],
+				&["QueryKind", "OnEmpty", "MaxValues"],
+				"CountedStorageNMap",
+				args_span,
+			)?;
+
+			StorageGenerics::CountedNMap {
+				keygen: parsed
+					.remove("Key")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				value: parsed
+					.remove("Value")
+					.map(|binding| binding.ty)
+					.expect("checked above as mandatory generic"),
+				query_kind: parsed.remove("QueryKind").map(|binding| binding.ty),
+				on_empty: parsed.remove("OnEmpty").map(|binding| binding.ty),
+				max_values: parsed.remove("MaxValues").map(|binding| binding.ty),
+			}
+		},
+	};
+
+	let metadata = generics.metadata()?;
+	let query_kind = generics.query_kind();
+
+	Ok((Some(generics), metadata, query_kind, false))
+}
+
+/// Returns `(named generics, metadata, query kind, use_default_hasher)`
+fn process_unnamed_generics(
+	storage: &StorageKind,
+	args_span: proc_macro2::Span,
+	args: &[syn::Type],
+	dev_mode: bool,
+) -> syn::Result<(Option<StorageGenerics>, Metadata, Option<syn::Type>, bool)> {
+	let retrieve_arg = |arg_pos| {
+		args.get(arg_pos).cloned().ok_or_else(|| {
+			let msg = format!(
+				"Invalid pallet::storage, unexpected number of generic argument, \
+						expect at least {} args, found {}.",
+				arg_pos + 1,
+				args.len(),
+			);
+			syn::Error::new(args_span, msg)
+		})
+	};
+
+	let prefix_arg = retrieve_arg(0)?;
+	syn::parse2::<syn::Token![_]>(prefix_arg.to_token_stream()).map_err(|e| {
+		let msg = "Invalid pallet::storage, for unnamed generic arguments the type \
+				first generic argument must be `_`, the argument is then replaced by macro.";
+		let mut err = syn::Error::new(prefix_arg.span(), msg);
+		err.combine(e);
+		err
+	})?;
+
+	let use_default_hasher = |arg_pos| {
+		let arg = retrieve_arg(arg_pos)?;
+		if syn::parse2::<syn::Token![_]>(arg.to_token_stream()).is_ok() {
+			if dev_mode {
+				Ok(true)
+			} else {
+				let msg = "`_` can only be used in dev_mode. Please specify an appropriate hasher.";
+				Err(syn::Error::new(arg.span(), msg))
+			}
+		} else {
+			Ok(false)
+		}
+	};
+
+	let res = match storage {
+		StorageKind::Value =>
+			(None, Metadata::Value { value: retrieve_arg(1)? }, retrieve_arg(2).ok(), false),
+		StorageKind::Map => (
+			None,
+			Metadata::Map { key: retrieve_arg(2)?, value: retrieve_arg(3)? },
+			retrieve_arg(4).ok(),
+			use_default_hasher(1)?,
+		),
+		StorageKind::CountedMap => (
+			None,
+			Metadata::CountedMap { key: retrieve_arg(2)?, value: retrieve_arg(3)? },
+			retrieve_arg(4).ok(),
+			use_default_hasher(1)?,
+		),
+		StorageKind::DoubleMap => (
+			None,
+			Metadata::DoubleMap {
+				key1: retrieve_arg(2)?,
+				key2: retrieve_arg(4)?,
+				value: retrieve_arg(5)?,
+			},
+			retrieve_arg(6).ok(),
+			use_default_hasher(1)? && use_default_hasher(3)?,
+		),
+		StorageKind::NMap => {
+			let keygen = retrieve_arg(1)?;
+			let keys = collect_keys(&keygen)?;
+			(
+				None,
+				Metadata::NMap { keys, keygen, value: retrieve_arg(2)? },
+				retrieve_arg(3).ok(),
+				false,
+			)
+		},
+		StorageKind::CountedNMap => {
+			let keygen = retrieve_arg(1)?;
+			let keys = collect_keys(&keygen)?;
+			(
+				None,
+				Metadata::CountedNMap { keys, keygen, value: retrieve_arg(2)? },
+				retrieve_arg(3).ok(),
+				false,
+			)
+		},
+	};
+
+	Ok(res)
+}
+
+/// Returns `(named generics, metadata, query kind, use_default_hasher)`
+fn process_generics(
+	segment: &syn::PathSegment,
+	dev_mode: bool,
+) -> syn::Result<(Option<StorageGenerics>, Metadata, Option<syn::Type>, bool)> {
+	let storage_kind = match &*segment.ident.to_string() {
+		"StorageValue" => StorageKind::Value,
+		"StorageMap" => StorageKind::Map,
+		"CountedStorageMap" => StorageKind::CountedMap,
+		"StorageDoubleMap" => StorageKind::DoubleMap,
+		"StorageNMap" => StorageKind::NMap,
+		"CountedStorageNMap" => StorageKind::CountedNMap,
+		found => {
+			let msg = format!(
+				"Invalid pallet::storage, expected ident: `StorageValue` or \
+				`StorageMap` or `CountedStorageMap` or `StorageDoubleMap` or `StorageNMap` or `CountedStorageNMap` \
+				in order to expand metadata, found `{}`.",
+				found,
+			);
+			return Err(syn::Error::new(segment.ident.span(), msg))
+		},
+	};
+
+	let args_span = segment.arguments.span();
+
+	let args = match &segment.arguments {
+		syn::PathArguments::AngleBracketed(args) if !args.args.is_empty() => args,
+		_ => {
+			let msg = "Invalid pallet::storage, invalid number of generic generic arguments, \
+				expect more that 0 generic arguments.";
+			return Err(syn::Error::new(segment.span(), msg))
+		},
+	};
+
+	if args.args.iter().all(|gen| matches!(gen, syn::GenericArgument::Type(_))) {
+		let args = args
+			.args
+			.iter()
+			.map(|gen| match gen {
+				syn::GenericArgument::Type(gen) => gen.clone(),
+				_ => unreachable!("It is asserted above that all generics are types"),
+			})
+			.collect::<Vec<_>>();
+		process_unnamed_generics(&storage_kind, args_span, &args, dev_mode)
+	} else if args.args.iter().all(|gen| matches!(gen, syn::GenericArgument::AssocType(_))) {
+		let args = args
+			.args
+			.iter()
+			.map(|gen| match gen {
+				syn::GenericArgument::AssocType(gen) => gen.clone(),
+				_ => unreachable!("It is asserted above that all generics are bindings"),
+			})
+			.collect::<Vec<_>>();
+		process_named_generics(&storage_kind, args_span, &args, dev_mode)
+	} else {
+		let msg = "Invalid pallet::storage, invalid generic declaration for storage. Expect only \
+			type generics or binding generics, e.g. `<Name1 = Gen1, Name2 = Gen2, ..>` or \
+			`<Gen1, Gen2, ..>`.";
+		Err(syn::Error::new(segment.span(), msg))
+	}
+}
+
+/// Parse the 2nd type argument to `StorageNMap` and return its keys.
+fn collect_keys(keygen: &syn::Type) -> syn::Result<Vec<syn::Type>> {
+	if let syn::Type::Tuple(tup) = keygen {
+		tup.elems.iter().map(extract_key).collect::<syn::Result<Vec<_>>>()
+	} else {
+		Ok(vec![extract_key(keygen)?])
+	}
+}
+
+/// In `Key<H, K>`, extract K and return it.
+fn extract_key(ty: &syn::Type) -> syn::Result<syn::Type> {
+	let typ = if let syn::Type::Path(typ) = ty {
+		typ
+	} else {
+		let msg = "Invalid pallet::storage, expected type path";
+		return Err(syn::Error::new(ty.span(), msg))
+	};
+
+	let key_struct = typ.path.segments.last().ok_or_else(|| {
+		let msg = "Invalid pallet::storage, expected type path with at least one segment";
+		syn::Error::new(typ.path.span(), msg)
+	})?;
+	if key_struct.ident != "Key" && key_struct.ident != "NMapKey" {
+		let msg = "Invalid pallet::storage, expected Key or NMapKey struct";
+		return Err(syn::Error::new(key_struct.ident.span(), msg))
+	}
+
+	let ty_params = if let syn::PathArguments::AngleBracketed(args) = &key_struct.arguments {
+		args
+	} else {
+		let msg = "Invalid pallet::storage, expected angle bracketed arguments";
+		return Err(syn::Error::new(key_struct.arguments.span(), msg))
+	};
+
+	if ty_params.args.len() != 2 {
+		let msg = format!(
+			"Invalid pallet::storage, unexpected number of generic arguments \
+			for Key struct, expected 2 args, found {}",
+			ty_params.args.len()
+		);
+		return Err(syn::Error::new(ty_params.span(), msg))
+	}
+
+	let key = match &ty_params.args[1] {
+		syn::GenericArgument::Type(key_ty) => key_ty.clone(),
+		_ => {
+			let msg = "Invalid pallet::storage, expected type";
+			return Err(syn::Error::new(ty_params.args[1].span(), msg))
+		},
+	};
+
+	Ok(key)
+}
+
+impl StorageDef {
+	/// Return the storage prefix for this storage item
+	pub fn prefix(&self) -> String {
+		self.rename_as
+			.as_ref()
+			.map(syn::LitStr::value)
+			.unwrap_or_else(|| self.ident.to_string())
+	}
+
+	/// Return either the span of the ident or the span of the literal in the
+	/// #[storage_prefix] attribute
+	pub fn prefix_span(&self) -> proc_macro2::Span {
+		self.rename_as
+			.as_ref()
+			.map(syn::LitStr::span)
+			.unwrap_or_else(|| self.ident.span())
+	}
+
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+		dev_mode: bool,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Type(item) = item {
+			item
+		} else {
+			return Err(syn::Error::new(item.span(), "Invalid pallet::storage, expect item type."))
+		};
+
+		let attrs: Vec<PalletStorageAttr> = helper::take_item_pallet_attrs(&mut item.attrs)?;
+		let PalletStorageAttrInfo { getter, rename_as, mut unbounded, whitelisted } =
+			PalletStorageAttrInfo::from_attrs(attrs)?;
+
+		// set all storages to be unbounded if dev_mode is enabled
+		unbounded |= dev_mode;
+		let cfg_attrs = helper::get_item_cfg_attrs(&item.attrs);
+
+		let instances = vec![helper::check_type_def_gen(&item.generics, item.ident.span())?];
+
+		let where_clause = item.generics.where_clause.clone();
+		let docs = get_doc_literals(&item.attrs);
+
+		let typ = if let syn::Type::Path(typ) = &*item.ty {
+			typ
+		} else {
+			let msg = "Invalid pallet::storage, expected type path";
+			return Err(syn::Error::new(item.ty.span(), msg))
+		};
+
+		if typ.path.segments.len() != 1 {
+			let msg = "Invalid pallet::storage, expected type path with one segment";
+			return Err(syn::Error::new(item.ty.span(), msg))
+		}
+
+		let (named_generics, metadata, query_kind, use_default_hasher) =
+			process_generics(&typ.path.segments[0], dev_mode)?;
+
+		let query_kind = query_kind
+			.map(|query_kind| {
+				use syn::{
+					AngleBracketedGenericArguments, GenericArgument, Path, PathArguments, Type,
+					TypePath,
+				};
+
+				let result_query = match query_kind {
+					Type::Path(path)
+						if path
+							.path
+							.segments
+							.last()
+							.map_or(false, |s| s.ident == "OptionQuery") =>
+						return Ok(Some(QueryKind::OptionQuery)),
+					Type::Path(TypePath { path: Path { segments, .. }, .. })
+						if segments.last().map_or(false, |s| s.ident == "ResultQuery") =>
+						segments
+							.last()
+							.expect("segments is checked to have the last value; qed")
+							.clone(),
+					Type::Path(path)
+						if path.path.segments.last().map_or(false, |s| s.ident == "ValueQuery") =>
+						return Ok(Some(QueryKind::ValueQuery)),
+					_ => return Ok(None),
+				};
+
+				let error_type = match result_query.arguments {
+					PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+						args, ..
+					}) => {
+						if args.len() != 1 {
+							let msg = format!(
+								"Invalid pallet::storage, unexpected number of generic arguments \
+								for ResultQuery, expected 1 type argument, found {}",
+								args.len(),
+							);
+							return Err(syn::Error::new(args.span(), msg))
+						}
+
+						args[0].clone()
+					},
+					args => {
+						let msg = format!(
+							"Invalid pallet::storage, unexpected generic args for ResultQuery, \
+							expected angle-bracketed arguments, found `{}`",
+							args.to_token_stream().to_string()
+						);
+						return Err(syn::Error::new(args.span(), msg))
+					},
+				};
+
+				match error_type {
+					GenericArgument::Type(Type::Path(TypePath {
+						path: Path { segments: err_variant, leading_colon },
+						..
+					})) => {
+						if err_variant.len() < 2 {
+							let msg = format!(
+								"Invalid pallet::storage, unexpected number of path segments for \
+								the generics in ResultQuery, expected a path with at least 2 \
+								segments, found {}",
+								err_variant.len(),
+							);
+							return Err(syn::Error::new(err_variant.span(), msg))
+						}
+						let mut error = err_variant.clone();
+						let err_variant = error
+							.pop()
+							.expect("Checked to have at least 2; qed")
+							.into_value()
+							.ident;
+
+						// Necessary here to eliminate the last double colon
+						let last =
+							error.pop().expect("Checked to have at least 2; qed").into_value();
+						error.push_value(last);
+
+						Ok(Some(QueryKind::ResultQuery(
+							syn::Path { leading_colon, segments: error },
+							err_variant,
+						)))
+					},
+					gen_arg => {
+						let msg = format!(
+							"Invalid pallet::storage, unexpected generic argument kind, expected a \
+							type path to a `PalletError` enum variant, found `{}`",
+							gen_arg.to_token_stream().to_string(),
+						);
+						Err(syn::Error::new(gen_arg.span(), msg))
+					},
+				}
+			})
+			.transpose()?
+			.unwrap_or(Some(QueryKind::OptionQuery));
+
+		if let (None, Some(getter)) = (query_kind.as_ref(), getter.as_ref()) {
+			let msg = "Invalid pallet::storage, cannot generate getter because QueryKind is not \
+				identifiable. QueryKind must be `OptionQuery`, `ResultQuery`, `ValueQuery`, or default \
+				one to be identifiable.";
+			return Err(syn::Error::new(getter.span(), msg))
+		}
+
+		Ok(StorageDef {
+			attr_span,
+			index,
+			vis: item.vis.clone(),
+			ident: item.ident.clone(),
+			instances,
+			metadata,
+			docs,
+			getter,
+			rename_as,
+			query_kind,
+			where_clause,
+			cfg_attrs,
+			named_generics,
+			unbounded,
+			whitelisted,
+			use_default_hasher,
+		})
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/type_value.rs b/substrate/frame/support/procedural/src/pallet/parse/type_value.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d9db30b3a788354ab5a650c9780717dbb649ee0
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/type_value.rs
@@ -0,0 +1,123 @@
+// 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::helper;
+use syn::spanned::Spanned;
+
+/// Definition of type value. Just a function which is expanded to a struct implementing `Get`.
+pub struct TypeValueDef {
+	/// The index of error item in pallet module.
+	pub index: usize,
+	/// Visibility of the struct to generate.
+	pub vis: syn::Visibility,
+	/// Ident of the struct to generate.
+	pub ident: syn::Ident,
+	/// The type return by Get.
+	pub type_: Box<syn::Type>,
+	/// The block returning the value to get
+	pub block: Box<syn::Block>,
+	/// If type value is generic over `T` (or `T` and `I` for instantiable pallet)
+	pub is_generic: bool,
+	/// A set of usage of instance, must be check for consistency with config.
+	pub instances: Vec<helper::InstanceUsage>,
+	/// The where clause of the function.
+	pub where_clause: Option<syn::WhereClause>,
+	/// The span of the pallet::type_value attribute.
+	pub attr_span: proc_macro2::Span,
+	/// Docs on the item.
+	pub docs: Vec<syn::Expr>,
+}
+
+impl TypeValueDef {
+	pub fn try_from(
+		attr_span: proc_macro2::Span,
+		index: usize,
+		item: &mut syn::Item,
+	) -> syn::Result<Self> {
+		let item = if let syn::Item::Fn(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::type_value, expected item fn";
+			return Err(syn::Error::new(item.span(), msg))
+		};
+
+		let mut docs = vec![];
+		for attr in &item.attrs {
+			if let syn::Meta::NameValue(meta) = &attr.meta {
+				if meta.path.get_ident().map_or(false, |ident| ident == "doc") {
+					docs.push(meta.value.clone());
+					continue
+				}
+			}
+
+			let msg = "Invalid pallet::type_value, unexpected attribute, only doc attribute are \
+				allowed";
+			return Err(syn::Error::new(attr.span(), msg))
+		}
+
+		if let Some(span) = item
+			.sig
+			.constness
+			.as_ref()
+			.map(|t| t.span())
+			.or_else(|| item.sig.asyncness.as_ref().map(|t| t.span()))
+			.or_else(|| item.sig.unsafety.as_ref().map(|t| t.span()))
+			.or_else(|| item.sig.abi.as_ref().map(|t| t.span()))
+			.or_else(|| item.sig.variadic.as_ref().map(|t| t.span()))
+		{
+			let msg = "Invalid pallet::type_value, unexpected token";
+			return Err(syn::Error::new(span, msg))
+		}
+
+		if !item.sig.inputs.is_empty() {
+			let msg = "Invalid pallet::type_value, unexpected argument";
+			return Err(syn::Error::new(item.sig.inputs[0].span(), msg))
+		}
+
+		let vis = item.vis.clone();
+		let ident = item.sig.ident.clone();
+		let block = item.block.clone();
+		let type_ = match item.sig.output.clone() {
+			syn::ReturnType::Type(_, type_) => type_,
+			syn::ReturnType::Default => {
+				let msg = "Invalid pallet::type_value, expected return type";
+				return Err(syn::Error::new(item.sig.span(), msg))
+			},
+		};
+
+		let mut instances = vec![];
+		if let Some(usage) = helper::check_type_value_gen(&item.sig.generics, item.sig.span())? {
+			instances.push(usage);
+		}
+
+		let is_generic = item.sig.generics.type_params().count() > 0;
+		let where_clause = item.sig.generics.where_clause.clone();
+
+		Ok(TypeValueDef {
+			attr_span,
+			index,
+			is_generic,
+			vis,
+			ident,
+			block,
+			type_,
+			instances,
+			where_clause,
+			docs,
+		})
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet/parse/validate_unsigned.rs b/substrate/frame/support/procedural/src/pallet/parse/validate_unsigned.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2bf0a1b6c1886632b0abc52661cded9e5e227ed3
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet/parse/validate_unsigned.rs
@@ -0,0 +1,62 @@
+// 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::helper;
+use syn::spanned::Spanned;
+
+/// The definition of the pallet validate unsigned implementation.
+pub struct ValidateUnsignedDef {
+	/// The index of validate unsigned item in pallet module.
+	pub index: usize,
+	/// A set of usage of instance, must be check for consistency with config.
+	pub instances: Vec<helper::InstanceUsage>,
+}
+
+impl ValidateUnsignedDef {
+	pub fn try_from(index: usize, item: &mut syn::Item) -> syn::Result<Self> {
+		let item = if let syn::Item::Impl(item) = item {
+			item
+		} else {
+			let msg = "Invalid pallet::validate_unsigned, expected item impl";
+			return Err(syn::Error::new(item.span(), msg))
+		};
+
+		if item.trait_.is_none() {
+			let msg = "Invalid pallet::validate_unsigned, expected impl<..> ValidateUnsigned for \
+				Pallet<..>";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		if let Some(last) = item.trait_.as_ref().unwrap().1.segments.last() {
+			if last.ident != "ValidateUnsigned" {
+				let msg = "Invalid pallet::validate_unsigned, expected trait ValidateUnsigned";
+				return Err(syn::Error::new(last.span(), msg))
+			}
+		} else {
+			let msg = "Invalid pallet::validate_unsigned, expected impl<..> ValidateUnsigned for \
+				Pallet<..>";
+			return Err(syn::Error::new(item.span(), msg))
+		}
+
+		let instances = vec![
+			helper::check_pallet_struct_usage(&item.self_ty)?,
+			helper::check_impl_gen(&item.generics, item.impl_token.span())?,
+		];
+
+		Ok(ValidateUnsignedDef { index, instances })
+	}
+}
diff --git a/substrate/frame/support/procedural/src/pallet_error.rs b/substrate/frame/support/procedural/src/pallet_error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7fd02240a628a23fdaee5ff84f89570aa1705fb2
--- /dev/null
+++ b/substrate/frame/support/procedural/src/pallet_error.rs
@@ -0,0 +1,178 @@
+// 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_support_procedural_tools::generate_crate_access_2018;
+use quote::ToTokens;
+
+// Derive `PalletError`
+pub fn derive_pallet_error(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let syn::DeriveInput { ident: name, generics, data, .. } = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let frame_support = match generate_crate_access_2018("frame-support") {
+		Ok(c) => c,
+		Err(e) => return e.into_compile_error().into(),
+	};
+	let frame_support = &frame_support;
+	let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+	let max_encoded_size = match data {
+		syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
+			syn::Fields::Named(syn::FieldsNamed { named: fields, .. }) |
+			syn::Fields::Unnamed(syn::FieldsUnnamed { unnamed: fields, .. }) => {
+				let maybe_field_tys = fields
+					.iter()
+					.map(|f| generate_field_types(f, &frame_support))
+					.collect::<syn::Result<Vec<_>>>();
+				let field_tys = match maybe_field_tys {
+					Ok(tys) => tys.into_iter().flatten(),
+					Err(e) => return e.into_compile_error().into(),
+				};
+				quote::quote! {
+					0_usize
+					#(
+						.saturating_add(<
+							#field_tys as #frame_support::traits::PalletError
+						>::MAX_ENCODED_SIZE)
+					)*
+				}
+			},
+			syn::Fields::Unit => quote::quote!(0),
+		},
+		syn::Data::Enum(syn::DataEnum { variants, .. }) => {
+			let field_tys = variants
+				.iter()
+				.map(|variant| generate_variant_field_types(variant, &frame_support))
+				.collect::<Result<Vec<Option<Vec<proc_macro2::TokenStream>>>, syn::Error>>();
+
+			let field_tys = match field_tys {
+				Ok(tys) => tys.into_iter().flatten().collect::<Vec<_>>(),
+				Err(e) => return e.to_compile_error().into(),
+			};
+
+			// We start with `1`, because the discriminant of an enum is stored as u8
+			if field_tys.is_empty() {
+				quote::quote!(1)
+			} else {
+				let variant_sizes = field_tys.into_iter().map(|variant_field_tys| {
+					quote::quote! {
+						1_usize
+						#(.saturating_add(<
+							#variant_field_tys as #frame_support::traits::PalletError
+						>::MAX_ENCODED_SIZE))*
+					}
+				});
+
+				quote::quote! {{
+					let mut size = 1_usize;
+					let mut tmp = 0_usize;
+					#(
+						tmp = #variant_sizes;
+						size = if tmp > size { tmp } else { size };
+						tmp = 0_usize;
+					)*
+					size
+				}}
+			}
+		},
+		syn::Data::Union(syn::DataUnion { union_token, .. }) => {
+			let msg = "Cannot derive `PalletError` for union; please implement it directly";
+			return syn::Error::new(union_token.span, msg).into_compile_error().into()
+		},
+	};
+
+	quote::quote!(
+		const _: () = {
+			impl #impl_generics #frame_support::traits::PalletError
+				for #name #ty_generics #where_clause
+			{
+				const MAX_ENCODED_SIZE: usize = #max_encoded_size;
+			}
+		};
+	)
+	.into()
+}
+
+fn generate_field_types(
+	field: &syn::Field,
+	scrate: &syn::Ident,
+) -> syn::Result<Option<proc_macro2::TokenStream>> {
+	let attrs = &field.attrs;
+
+	for attr in attrs {
+		if attr.path().is_ident("codec") {
+			let mut res = None;
+
+			attr.parse_nested_meta(|meta| {
+				if meta.path.is_ident("skip") {
+					res = Some(None);
+				} else if meta.path.is_ident("compact") {
+					let field_ty = &field.ty;
+					res = Some(Some(quote::quote!(#scrate::__private::codec::Compact<#field_ty>)));
+				} else if meta.path.is_ident("compact") {
+					res = Some(Some(meta.value()?.parse()?));
+				}
+
+				Ok(())
+			})?;
+
+			if let Some(v) = res {
+				return Ok(v)
+			}
+		}
+	}
+
+	Ok(Some(field.ty.to_token_stream()))
+}
+
+fn generate_variant_field_types(
+	variant: &syn::Variant,
+	scrate: &syn::Ident,
+) -> syn::Result<Option<Vec<proc_macro2::TokenStream>>> {
+	let attrs = &variant.attrs;
+
+	for attr in attrs {
+		if attr.path().is_ident("codec") {
+			let mut skip = false;
+
+			// We ignore the error intentionally as this isn't `codec(skip)` when
+			// `parse_nested_meta` fails.
+			let _ = attr.parse_nested_meta(|meta| {
+				skip = meta.path.is_ident("skip");
+				Ok(())
+			});
+
+			if skip {
+				return Ok(None)
+			}
+		}
+	}
+
+	match &variant.fields {
+		syn::Fields::Named(syn::FieldsNamed { named: fields, .. }) |
+		syn::Fields::Unnamed(syn::FieldsUnnamed { unnamed: fields, .. }) => {
+			let field_tys = fields
+				.iter()
+				.map(|field| generate_field_types(field, scrate))
+				.collect::<syn::Result<Vec<_>>>()?;
+			Ok(Some(field_tys.into_iter().flatten().collect()))
+		},
+		syn::Fields::Unit => Ok(None),
+	}
+}
diff --git a/substrate/frame/support/procedural/src/storage_alias.rs b/substrate/frame/support/procedural/src/storage_alias.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a3f21806e18b921e07c8acdf63aa06bd51c5f2ee
--- /dev/null
+++ b/substrate/frame/support/procedural/src/storage_alias.rs
@@ -0,0 +1,667 @@
+// 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.
+
+//! Implementation of the `storage_alias` attribute macro.
+
+use crate::counter_prefix;
+use frame_support_procedural_tools::generate_crate_access_2018;
+use proc_macro2::{Span, TokenStream};
+use quote::{quote, ToTokens};
+use syn::{
+	parenthesized,
+	parse::{Parse, ParseStream},
+	punctuated::Punctuated,
+	spanned::Spanned,
+	token,
+	visit::Visit,
+	Attribute, Error, Ident, Result, Token, Type, TypeParam, Visibility, WhereClause,
+};
+
+/// Extension trait for [`Type`].
+trait TypeExt {
+	fn get_ident(&self) -> Option<&Ident>;
+	fn contains_ident(&self, ident: &Ident) -> bool;
+}
+
+impl TypeExt for Type {
+	fn get_ident(&self) -> Option<&Ident> {
+		match self {
+			Type::Path(p) => match &p.qself {
+				Some(qself) => qself.ty.get_ident(),
+				None => p.path.get_ident(),
+			},
+			_ => None,
+		}
+	}
+
+	fn contains_ident(&self, ident: &Ident) -> bool {
+		struct ContainsIdent<'a> {
+			ident: &'a Ident,
+			found: bool,
+		}
+		impl<'a, 'ast> Visit<'ast> for ContainsIdent<'a> {
+			fn visit_ident(&mut self, i: &'ast Ident) {
+				if i == self.ident {
+					self.found = true;
+				}
+			}
+		}
+
+		let mut visitor = ContainsIdent { ident, found: false };
+		syn::visit::visit_type(&mut visitor, self);
+		visitor.found
+	}
+}
+
+/// Represents generics which only support [`TypeParam`] separated by commas.
+struct SimpleGenerics {
+	lt_token: Token![<],
+	params: Punctuated<TypeParam, token::Comma>,
+	gt_token: Token![>],
+}
+
+impl SimpleGenerics {
+	/// Returns the generics for types declarations etc.
+	fn type_generics(&self) -> impl Iterator<Item = &Ident> {
+		self.params.iter().map(|p| &p.ident)
+	}
+
+	/// Returns the generics for the `impl` block.
+	fn impl_generics(&self) -> impl Iterator<Item = &TypeParam> {
+		self.params.iter()
+	}
+}
+
+impl Parse for SimpleGenerics {
+	fn parse(input: ParseStream<'_>) -> Result<Self> {
+		Ok(Self {
+			lt_token: input.parse()?,
+			params: Punctuated::parse_separated_nonempty(input)?,
+			gt_token: input.parse()?,
+		})
+	}
+}
+
+impl ToTokens for SimpleGenerics {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		self.lt_token.to_tokens(tokens);
+		self.params.to_tokens(tokens);
+		self.gt_token.to_tokens(tokens);
+	}
+}
+
+mod storage_types {
+	syn::custom_keyword!(StorageValue);
+	syn::custom_keyword!(StorageMap);
+	syn::custom_keyword!(CountedStorageMap);
+	syn::custom_keyword!(StorageDoubleMap);
+	syn::custom_keyword!(StorageNMap);
+}
+
+/// The types of prefixes the storage alias macro supports.
+mod prefix_types {
+	// Use the verbatim/unmodified input name as the prefix.
+	syn::custom_keyword!(verbatim);
+	// The input type is a pallet and its pallet name should be used as the prefix.
+	syn::custom_keyword!(pallet_name);
+	// The input type implements `Get<'static str>` and this `str` should be used as the prefix.
+	syn::custom_keyword!(dynamic);
+}
+
+/// The supported storage types
+enum StorageType {
+	Value {
+		_kw: storage_types::StorageValue,
+		_lt_token: Token![<],
+		prefix: Type,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+	Map {
+		_kw: storage_types::StorageMap,
+		_lt_token: Token![<],
+		prefix: Type,
+		_hasher_comma: Token![,],
+		hasher_ty: Type,
+		_key_comma: Token![,],
+		key_ty: Type,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+	CountedMap {
+		_kw: storage_types::CountedStorageMap,
+		_lt_token: Token![<],
+		prefix: Type,
+		_hasher_comma: Token![,],
+		hasher_ty: Type,
+		_key_comma: Token![,],
+		key_ty: Type,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+	DoubleMap {
+		_kw: storage_types::StorageDoubleMap,
+		_lt_token: Token![<],
+		prefix: Type,
+		_hasher1_comma: Token![,],
+		hasher1_ty: Type,
+		_key1_comma: Token![,],
+		key1_ty: Type,
+		_hasher2_comma: Token![,],
+		hasher2_ty: Type,
+		_key2_comma: Token![,],
+		key2_ty: Type,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+	NMap {
+		_kw: storage_types::StorageNMap,
+		_lt_token: Token![<],
+		prefix: Type,
+		_paren_comma: Token![,],
+		_paren_token: token::Paren,
+		key_types: Punctuated<Type, Token![,]>,
+		_value_comma: Token![,],
+		value_ty: Type,
+		query_type: Option<(Token![,], Type)>,
+		_trailing_comma: Option<Token![,]>,
+		_gt_token: Token![>],
+	},
+}
+
+impl StorageType {
+	/// Generate the actual type declaration.
+	fn generate_type_declaration(
+		&self,
+		crate_: &Ident,
+		storage_instance: &StorageInstance,
+		storage_name: &Ident,
+		storage_generics: Option<&SimpleGenerics>,
+		visibility: &Visibility,
+		attributes: &[Attribute],
+	) -> TokenStream {
+		let storage_instance_generics = &storage_instance.generics;
+		let storage_instance = &storage_instance.name;
+		let attributes = attributes.iter();
+		let storage_generics = storage_generics.map(|g| {
+			let generics = g.type_generics();
+
+			quote!( < #( #generics ),* > )
+		});
+
+		match self {
+			Self::Value { value_ty, query_type, .. } => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::StorageValue<
+						#storage_instance #storage_instance_generics,
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+			Self::CountedMap { value_ty, query_type, hasher_ty, key_ty, .. } |
+			Self::Map { value_ty, query_type, hasher_ty, key_ty, .. } => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+				let map_type = Ident::new(
+					match self {
+						Self::Map { .. } => "StorageMap",
+						_ => "CountedStorageMap",
+					},
+					Span::call_site(),
+				);
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::#map_type<
+						#storage_instance #storage_instance_generics,
+						#hasher_ty,
+						#key_ty,
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+			Self::DoubleMap {
+				value_ty,
+				query_type,
+				hasher1_ty,
+				key1_ty,
+				hasher2_ty,
+				key2_ty,
+				..
+			} => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::StorageDoubleMap<
+						#storage_instance #storage_instance_generics,
+						#hasher1_ty,
+						#key1_ty,
+						#hasher2_ty,
+						#key2_ty,
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+			Self::NMap { value_ty, query_type, key_types, .. } => {
+				let query_type = query_type.as_ref().map(|(c, t)| quote!(#c #t));
+				let key_types = key_types.iter();
+
+				quote! {
+					#( #attributes )*
+					#visibility type #storage_name #storage_generics = #crate_::storage::types::StorageNMap<
+						#storage_instance #storage_instance_generics,
+						( #( #key_types ),* ),
+						#value_ty
+						#query_type
+					>;
+				}
+			},
+		}
+	}
+
+	/// The prefix for this storage type.
+	fn prefix(&self) -> &Type {
+		match self {
+			Self::Value { prefix, .. } |
+			Self::Map { prefix, .. } |
+			Self::CountedMap { prefix, .. } |
+			Self::NMap { prefix, .. } |
+			Self::DoubleMap { prefix, .. } => prefix,
+		}
+	}
+}
+
+impl Parse for StorageType {
+	fn parse(input: ParseStream<'_>) -> Result<Self> {
+		let lookahead = input.lookahead1();
+
+		let parse_query_type = |input: ParseStream<'_>| -> Result<Option<(Token![,], Type)>> {
+			if input.peek(Token![,]) && !input.peek2(Token![>]) {
+				Ok(Some((input.parse()?, input.parse()?)))
+			} else {
+				Ok(None)
+			}
+		};
+
+		if lookahead.peek(storage_types::StorageValue) {
+			Ok(Self::Value {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else if lookahead.peek(storage_types::StorageMap) {
+			Ok(Self::Map {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				_hasher_comma: input.parse()?,
+				hasher_ty: input.parse()?,
+				_key_comma: input.parse()?,
+				key_ty: input.parse()?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else if lookahead.peek(storage_types::CountedStorageMap) {
+			Ok(Self::CountedMap {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				_hasher_comma: input.parse()?,
+				hasher_ty: input.parse()?,
+				_key_comma: input.parse()?,
+				key_ty: input.parse()?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else if lookahead.peek(storage_types::StorageDoubleMap) {
+			Ok(Self::DoubleMap {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				_hasher1_comma: input.parse()?,
+				hasher1_ty: input.parse()?,
+				_key1_comma: input.parse()?,
+				key1_ty: input.parse()?,
+				_hasher2_comma: input.parse()?,
+				hasher2_ty: input.parse()?,
+				_key2_comma: input.parse()?,
+				key2_ty: input.parse()?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else if lookahead.peek(storage_types::StorageNMap) {
+			let content;
+			Ok(Self::NMap {
+				_kw: input.parse()?,
+				_lt_token: input.parse()?,
+				prefix: input.parse()?,
+				_paren_comma: input.parse()?,
+				_paren_token: parenthesized!(content in input),
+				key_types: Punctuated::parse_terminated(&content)?,
+				_value_comma: input.parse()?,
+				value_ty: input.parse()?,
+				query_type: parse_query_type(input)?,
+				_trailing_comma: input.peek(Token![,]).then(|| input.parse()).transpose()?,
+				_gt_token: input.parse()?,
+			})
+		} else {
+			Err(lookahead.error())
+		}
+	}
+}
+
+/// The input expected by this macro.
+struct Input {
+	attributes: Vec<Attribute>,
+	visibility: Visibility,
+	_type: Token![type],
+	storage_name: Ident,
+	storage_generics: Option<SimpleGenerics>,
+	where_clause: Option<WhereClause>,
+	_equal: Token![=],
+	storage_type: StorageType,
+	_semicolon: Token![;],
+}
+
+impl Parse for Input {
+	fn parse(input: ParseStream<'_>) -> Result<Self> {
+		let attributes = input.call(Attribute::parse_outer)?;
+		let visibility = input.parse()?;
+		let _type = input.parse()?;
+		let storage_name = input.parse()?;
+
+		let lookahead = input.lookahead1();
+		let storage_generics = if lookahead.peek(Token![<]) {
+			Some(input.parse()?)
+		} else if lookahead.peek(Token![=]) {
+			None
+		} else {
+			return Err(lookahead.error())
+		};
+
+		let lookahead = input.lookahead1();
+		let where_clause = if lookahead.peek(Token![where]) {
+			Some(input.parse()?)
+		} else if lookahead.peek(Token![=]) {
+			None
+		} else {
+			return Err(lookahead.error())
+		};
+
+		let _equal = input.parse()?;
+
+		let storage_type = input.parse()?;
+
+		let _semicolon = input.parse()?;
+
+		Ok(Self {
+			attributes,
+			visibility,
+			_type,
+			storage_name,
+			storage_generics,
+			_equal,
+			storage_type,
+			where_clause,
+			_semicolon,
+		})
+	}
+}
+
+/// Defines which type of prefix the storage alias is using.
+#[derive(Clone, Copy)]
+enum PrefixType {
+	/// An appropriate prefix will be determined automatically.
+	///
+	/// If generics are passed, this is assumed to be a pallet and the pallet name should be used.
+	/// Otherwise use the verbatim passed name as prefix.
+	Compatibility,
+	/// The provided ident/name will be used as the prefix.
+	Verbatim,
+	/// The provided type will be used to determine the prefix. This type must
+	/// implement `PalletInfoAccess` which specifies the proper name. This
+	/// name is then used as the prefix.
+	PalletName,
+	/// Uses the provided type implementing `Get<'static str>` to determine the prefix.
+	Dynamic,
+}
+
+/// Implementation of the `storage_alias` attribute macro.
+pub fn storage_alias(attributes: TokenStream, input: TokenStream) -> Result<TokenStream> {
+	let input = syn::parse2::<Input>(input)?;
+	let crate_ = generate_crate_access_2018("frame-support")?;
+
+	let prefix_type = if attributes.is_empty() {
+		PrefixType::Compatibility
+	} else if syn::parse2::<prefix_types::verbatim>(attributes.clone()).is_ok() {
+		PrefixType::Verbatim
+	} else if syn::parse2::<prefix_types::pallet_name>(attributes.clone()).is_ok() {
+		PrefixType::PalletName
+	} else if syn::parse2::<prefix_types::dynamic>(attributes.clone()).is_ok() {
+		PrefixType::Dynamic
+	} else {
+		return Err(Error::new(attributes.span(), "Unknown attributes"))
+	};
+
+	let storage_instance = generate_storage_instance(
+		&crate_,
+		&input.storage_name,
+		input.storage_generics.as_ref(),
+		input.where_clause.as_ref(),
+		input.storage_type.prefix(),
+		&input.visibility,
+		matches!(input.storage_type, StorageType::CountedMap { .. }),
+		prefix_type,
+	)?;
+
+	let definition = input.storage_type.generate_type_declaration(
+		&crate_,
+		&storage_instance,
+		&input.storage_name,
+		input.storage_generics.as_ref(),
+		&input.visibility,
+		&input.attributes,
+	);
+
+	let storage_instance_code = storage_instance.code;
+
+	Ok(quote! {
+		#storage_instance_code
+
+		#definition
+	})
+}
+
+/// The storage instance to use for the storage alias.
+struct StorageInstance {
+	name: Ident,
+	generics: TokenStream,
+	code: TokenStream,
+}
+
+/// Generate the [`StorageInstance`] for the storage alias.
+fn generate_storage_instance(
+	crate_: &Ident,
+	storage_name: &Ident,
+	storage_generics: Option<&SimpleGenerics>,
+	storage_where_clause: Option<&WhereClause>,
+	prefix: &Type,
+	visibility: &Visibility,
+	is_counted_map: bool,
+	prefix_type: PrefixType,
+) -> Result<StorageInstance> {
+	if let Type::Infer(_) = prefix {
+		return Err(Error::new(prefix.span(), "`_` is not allowed as prefix by `storage_alias`."))
+	}
+
+	let impl_generics_used_by_prefix = storage_generics
+		.as_ref()
+		.map(|g| {
+			g.impl_generics()
+				.filter(|g| prefix.contains_ident(&g.ident))
+				.collect::<Vec<_>>()
+		})
+		.unwrap_or_default();
+
+	let (pallet_prefix, impl_generics, type_generics) = match prefix_type {
+		PrefixType::Compatibility =>
+			if !impl_generics_used_by_prefix.is_empty() {
+				let type_generics = impl_generics_used_by_prefix.iter().map(|g| &g.ident);
+				let impl_generics = impl_generics_used_by_prefix.iter();
+
+				(
+					quote! {
+						< #prefix as #crate_::traits::PalletInfoAccess>::name()
+					},
+					quote!( #( #impl_generics ),* ),
+					quote!( #( #type_generics ),* ),
+				)
+			} else if let Some(prefix) = prefix.get_ident() {
+				let prefix_str = prefix.to_string();
+
+				(quote!(#prefix_str), quote!(), quote!())
+			} else {
+				return Err(Error::new_spanned(
+					prefix,
+					"If there are no generics, the prefix is only allowed to be an identifier.",
+				))
+			},
+		PrefixType::Verbatim => {
+			let prefix_str = match prefix.get_ident() {
+				Some(p) => p.to_string(),
+				None =>
+					return Err(Error::new_spanned(
+						prefix,
+						"Prefix type `verbatim` requires that the prefix is an ident.",
+					)),
+			};
+
+			(quote!(#prefix_str), quote!(), quote!())
+		},
+		PrefixType::PalletName => {
+			let type_generics = impl_generics_used_by_prefix.iter().map(|g| &g.ident);
+			let impl_generics = impl_generics_used_by_prefix.iter();
+
+			(
+				quote! {
+					<#prefix as #crate_::traits::PalletInfoAccess>::name()
+				},
+				quote!( #( #impl_generics ),* ),
+				quote!( #( #type_generics ),* ),
+			)
+		},
+		PrefixType::Dynamic => {
+			let type_generics = impl_generics_used_by_prefix.iter().map(|g| &g.ident);
+			let impl_generics = impl_generics_used_by_prefix.iter();
+
+			(
+				quote! {
+					<#prefix as #crate_::traits::Get<_>>::get()
+				},
+				quote!( #( #impl_generics ),* ),
+				quote!( #( #type_generics ),* ),
+			)
+		},
+	};
+
+	let where_clause = storage_where_clause.map(|w| quote!(#w)).unwrap_or_default();
+
+	let name_str = format!("{}_Storage_Instance", storage_name);
+	let name = Ident::new(&name_str, Span::call_site());
+	let storage_name_str = storage_name.to_string();
+
+	let counter_code = is_counted_map.then(|| {
+		let counter_name = Ident::new(&counter_prefix(&name_str), Span::call_site());
+		let counter_storage_name_str = counter_prefix(&storage_name_str);
+
+		quote! {
+			#visibility struct #counter_name< #impl_generics >(
+				#crate_::__private::sp_std::marker::PhantomData<(#type_generics)>
+			) #where_clause;
+
+			impl<#impl_generics> #crate_::traits::StorageInstance
+				for #counter_name< #type_generics > #where_clause
+			{
+				fn pallet_prefix() -> &'static str {
+					#pallet_prefix
+				}
+
+				const STORAGE_PREFIX: &'static str = #counter_storage_name_str;
+			}
+
+			impl<#impl_generics> #crate_::storage::types::CountedStorageMapInstance
+				for #name< #type_generics > #where_clause
+			{
+				type CounterPrefix = #counter_name < #type_generics >;
+			}
+		}
+	});
+
+	// Implement `StorageInstance` trait.
+	let code = quote! {
+		#[allow(non_camel_case_types)]
+		#visibility struct #name< #impl_generics >(
+			#crate_::__private::sp_std::marker::PhantomData<(#type_generics)>
+		) #where_clause;
+
+		impl<#impl_generics> #crate_::traits::StorageInstance
+			for #name< #type_generics > #where_clause
+		{
+			fn pallet_prefix() -> &'static str {
+				#pallet_prefix
+			}
+
+			const STORAGE_PREFIX: &'static str = #storage_name_str;
+		}
+
+		#counter_code
+	};
+
+	Ok(StorageInstance { name, code, generics: quote!( < #type_generics > ) })
+}
diff --git a/substrate/frame/support/procedural/src/transactional.rs b/substrate/frame/support/procedural/src/transactional.rs
new file mode 100644
index 0000000000000000000000000000000000000000..23117ffa39c4e6bbd826a885fbaecff5df7f606b
--- /dev/null
+++ b/substrate/frame/support/procedural/src/transactional.rs
@@ -0,0 +1,60 @@
+// 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_support_procedural_tools::generate_crate_access_2018;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{ItemFn, Result};
+
+pub fn transactional(_attr: TokenStream, input: TokenStream) -> Result<TokenStream> {
+	let ItemFn { attrs, vis, sig, block } = syn::parse(input)?;
+
+	let crate_ = generate_crate_access_2018("frame-support")?;
+	let output = quote! {
+		#(#attrs)*
+		#vis #sig {
+			use #crate_::storage::{with_transaction, TransactionOutcome};
+			with_transaction(|| {
+				let r = (|| { #block })();
+				if r.is_ok() {
+					TransactionOutcome::Commit(r)
+				} else {
+					TransactionOutcome::Rollback(r)
+				}
+			})
+		}
+	};
+
+	Ok(output.into())
+}
+
+pub fn require_transactional(_attr: TokenStream, input: TokenStream) -> Result<TokenStream> {
+	let ItemFn { attrs, vis, sig, block } = syn::parse(input)?;
+
+	let crate_ = generate_crate_access_2018("frame-support")?;
+	let output = quote! {
+		#(#attrs)*
+		#vis #sig {
+			if !#crate_::storage::transactional::is_transactional() {
+				return Err(#crate_::sp_runtime::TransactionalError::NoLayer.into());
+			}
+			#block
+		}
+	};
+
+	Ok(output.into())
+}
diff --git a/substrate/frame/support/procedural/src/tt_macro.rs b/substrate/frame/support/procedural/src/tt_macro.rs
new file mode 100644
index 0000000000000000000000000000000000000000..01611f5dc4a4d054de423668af2b56a1b5532035
--- /dev/null
+++ b/substrate/frame/support/procedural/src/tt_macro.rs
@@ -0,0 +1,110 @@
+// 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.
+
+//! Implementation of the `create_tt_return_macro` macro
+
+use crate::COUNTER;
+use frame_support_procedural_tools::generate_crate_access_2018;
+use proc_macro2::{Ident, TokenStream};
+use quote::format_ident;
+
+struct CreateTtReturnMacroDef {
+	name: Ident,
+	args: Vec<(Ident, TokenStream)>,
+}
+
+impl syn::parse::Parse for CreateTtReturnMacroDef {
+	fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+		let name = input.parse()?;
+		let _ = input.parse::<syn::Token![,]>()?;
+
+		let mut args = Vec::new();
+		while !input.is_empty() {
+			let mut value;
+			let key: Ident = input.parse()?;
+			let _ = input.parse::<syn::Token![=]>()?;
+			let _: syn::token::Bracket = syn::bracketed!(value in input);
+			let _: syn::token::Brace = syn::braced!(value in value);
+			let value: TokenStream = value.parse()?;
+
+			args.push((key, value))
+		}
+
+		Ok(Self { name, args })
+	}
+}
+
+/// A proc macro that accepts a name and any number of key-value pairs, to be used to create a
+/// declarative macro that follows tt-call conventions and simply calls
+/// [`tt_call::tt_return`], accepting an optional `frame-support` argument and returning
+/// the key-value pairs that were supplied to the proc macro.
+///
+/// # Example
+/// ```ignore
+/// __create_tt_macro! {
+///     my_tt_macro,
+///     foo = [{ bar }]
+/// }
+///
+/// // Creates the following declarative macro:
+///
+/// macro_rules! my_tt_macro {
+///     {
+///         $caller:tt
+///         $(frame_support = [{ $($frame_support:ident)::* }])?
+///     } => {
+///         frame_support::__private::tt_return! {
+///             $caller
+///             foo = [{ bar }]
+///         }
+///     }
+/// }
+/// ```
+pub fn create_tt_return_macro(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let CreateTtReturnMacroDef { name, args } =
+		syn::parse_macro_input!(input as CreateTtReturnMacroDef);
+
+	let frame_support = match generate_crate_access_2018("frame-support") {
+		Ok(i) => i,
+		Err(e) => return e.into_compile_error().into(),
+	};
+	let (keys, values): (Vec<_>, Vec<_>) = args.into_iter().unzip();
+	let count = COUNTER.with(|counter| counter.borrow_mut().inc());
+	let unique_name = format_ident!("{}_{}", name, count);
+
+	let decl_macro = quote::quote! {
+		#[macro_export]
+		#[doc(hidden)]
+		macro_rules! #unique_name {
+			{
+				$caller:tt
+				$(frame_support = [{ $($frame_support:ident)::* }])?
+			} => {
+				#frame_support::__private::tt_return! {
+					$caller
+					#(
+						#keys = [{ #values }]
+					)*
+				}
+			}
+		}
+
+		pub use #unique_name as #name;
+	};
+
+	decl_macro.into()
+}
diff --git a/substrate/frame/support/procedural/tools/Cargo.toml b/substrate/frame/support/procedural/tools/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7caff534fc1f9d3ce6bce028c75b73179ace6669
--- /dev/null
+++ b/substrate/frame/support/procedural/tools/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "frame-support-procedural-tools"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Proc macro helpers for procedural macros"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+proc-macro-crate = "1.1.3"
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full", "visit", "extra-traits"] }
+frame-support-procedural-tools-derive = { version = "3.0.0", path = "./derive" }
diff --git a/substrate/frame/support/procedural/tools/derive/Cargo.toml b/substrate/frame/support/procedural/tools/derive/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..193df53f129170e10df1851422369dc500f32ffb
--- /dev/null
+++ b/substrate/frame/support/procedural/tools/derive/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "frame-support-procedural-tools-derive"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Use to derive parsing for parsing struct."
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0.56"
+quote = { version = "1.0.28", features = ["proc-macro"] }
+syn = { version = "2.0.16", features = ["proc-macro", "full", "extra-traits", "parsing"] }
diff --git a/substrate/frame/support/procedural/tools/derive/src/lib.rs b/substrate/frame/support/procedural/tools/derive/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f7c57c08674fcee985fab90225e980675cd1096e
--- /dev/null
+++ b/substrate/frame/support/procedural/tools/derive/src/lib.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.
+
+// tag::description[]
+//! Use to derive parsing for parsing struct.
+// end::description[]
+
+#![recursion_limit = "128"]
+
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::quote;
+use syn::parse_macro_input;
+
+pub(crate) fn fields_idents(
+	fields: impl Iterator<Item = syn::Field>,
+) -> impl Iterator<Item = proc_macro2::TokenStream> {
+	fields.enumerate().map(|(ix, field)| {
+		field.ident.map(|i| quote! {#i}).unwrap_or_else(|| {
+			let f_ix: syn::Ident = syn::Ident::new(&format!("f_{}", ix), Span::call_site());
+			quote!( #f_ix )
+		})
+	})
+}
+
+pub(crate) fn fields_access(
+	fields: impl Iterator<Item = syn::Field>,
+) -> impl Iterator<Item = proc_macro2::TokenStream> {
+	fields.enumerate().map(|(ix, field)| {
+		field.ident.map(|i| quote!( #i )).unwrap_or_else(|| {
+			let f_ix: syn::Index = syn::Index { index: ix as u32, span: Span::call_site() };
+			quote!( #f_ix )
+		})
+	})
+}
+
+/// self defined parsing struct.
+/// not meant for any struct, just for fast
+/// parse implementation.
+#[proc_macro_derive(Parse)]
+pub fn derive_parse(input: TokenStream) -> TokenStream {
+	let item = parse_macro_input!(input as syn::Item);
+	match item {
+		syn::Item::Struct(input) => derive_parse_struct(input),
+		_ => TokenStream::new(), // ignore
+	}
+}
+
+fn derive_parse_struct(input: syn::ItemStruct) -> TokenStream {
+	let syn::ItemStruct { ident, generics, fields, .. } = input;
+	let field_names = {
+		let name = fields_idents(fields.iter().map(Clone::clone));
+		quote! {
+			#(
+				#name,
+			)*
+		}
+	};
+	let field = fields_idents(fields.iter().map(Clone::clone));
+	let tokens = quote! {
+		impl #generics syn::parse::Parse for #ident #generics {
+			fn parse(input: syn::parse::ParseStream) -> syn::parse::Result<Self> {
+				#(
+					let #field = input.parse()?;
+				)*
+				Ok(Self {
+					#field_names
+				})
+			}
+		}
+	};
+	tokens.into()
+}
+
+/// self defined parsing struct or enum.
+/// not meant for any struct/enum, just for fast
+/// parse implementation.
+/// For enum:
+///   it only output fields (empty field act as a None).
+#[proc_macro_derive(ToTokens)]
+pub fn derive_totokens(input: TokenStream) -> TokenStream {
+	let item = parse_macro_input!(input as syn::Item);
+	match item {
+		syn::Item::Enum(input) => derive_totokens_enum(input),
+		syn::Item::Struct(input) => derive_totokens_struct(input),
+		_ => TokenStream::new(), // ignore
+	}
+}
+
+fn derive_totokens_struct(input: syn::ItemStruct) -> TokenStream {
+	let syn::ItemStruct { ident, generics, fields, .. } = input;
+
+	let fields = fields_access(fields.iter().map(Clone::clone));
+	let tokens = quote! {
+
+		impl #generics quote::ToTokens for #ident #generics {
+			fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+				#(
+					self.#fields.to_tokens(tokens);
+				)*
+			}
+		}
+
+	};
+	tokens.into()
+}
+
+fn derive_totokens_enum(input: syn::ItemEnum) -> TokenStream {
+	let syn::ItemEnum { ident, generics, variants, .. } = input;
+	let variants = variants.iter().map(|v| {
+		let v_ident = v.ident.clone();
+		let fields_build = if v.fields.iter().count() > 0 {
+			let fields_id = fields_idents(v.fields.iter().map(Clone::clone));
+			quote!( (#(#fields_id), *) )
+		} else {
+			quote!()
+		};
+		let field = fields_idents(v.fields.iter().map(Clone::clone));
+		quote! {
+			#ident::#v_ident #fields_build => {
+				#(
+					#field.to_tokens(tokens);
+				)*
+			},
+		}
+	});
+	let tokens = quote! {
+		impl #generics quote::ToTokens for #ident #generics {
+			fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+				match self {
+					#(
+						#variants
+					)*
+				}
+			}
+		}
+	};
+
+	tokens.into()
+}
diff --git a/substrate/frame/support/procedural/tools/src/lib.rs b/substrate/frame/support/procedural/tools/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..541accc8ab96a3520d6bf9edd03434459ca29bd5
--- /dev/null
+++ b/substrate/frame/support/procedural/tools/src/lib.rs
@@ -0,0 +1,119 @@
+// 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.
+
+// tag::description[]
+//! Proc macro helpers for procedural macros
+// end::description[]
+
+// reexport proc macros
+pub use frame_support_procedural_tools_derive::*;
+
+use proc_macro_crate::{crate_name, FoundCrate};
+use quote::quote;
+use syn::parse::Error;
+
+pub mod syn_ext;
+
+// FIXME #1569, remove the following functions, which are copied from sp-api-macros
+use proc_macro2::{Span, TokenStream};
+use syn::Ident;
+
+fn generate_hidden_includes_mod_name(unique_id: &str) -> Ident {
+	Ident::new(&format!("sp_api_hidden_includes_{}", unique_id), Span::call_site())
+}
+
+/// Generates the access to the `frame-support` crate.
+pub fn generate_crate_access(unique_id: &str, def_crate: &str) -> TokenStream {
+	if std::env::var("CARGO_PKG_NAME").unwrap() == def_crate {
+		quote::quote!(frame_support)
+	} else {
+		let mod_name = generate_hidden_includes_mod_name(unique_id);
+		quote::quote!( self::#mod_name::hidden_include )
+	}
+}
+
+/// Generate the crate access for the crate using 2018 syntax.
+///
+/// for `frame-support` output will for example be `frame_support`.
+pub fn generate_crate_access_2018(def_crate: &str) -> Result<syn::Ident, Error> {
+	match crate_name(def_crate) {
+		Ok(FoundCrate::Itself) => {
+			let name = def_crate.to_string().replace("-", "_");
+			Ok(syn::Ident::new(&name, Span::call_site()))
+		},
+		Ok(FoundCrate::Name(name)) => Ok(Ident::new(&name, Span::call_site())),
+		Err(e) => Err(Error::new(Span::call_site(), e)),
+	}
+}
+
+/// Generates the hidden includes that are required to make the macro independent from its scope.
+pub fn generate_hidden_includes(unique_id: &str, def_crate: &str) -> TokenStream {
+	let mod_name = generate_hidden_includes_mod_name(unique_id);
+
+	match crate_name(def_crate) {
+		Ok(FoundCrate::Itself) => quote!(),
+		Ok(FoundCrate::Name(name)) => {
+			let name = Ident::new(&name, Span::call_site());
+			quote::quote!(
+				#[doc(hidden)]
+				mod #mod_name {
+					pub extern crate #name as hidden_include;
+				}
+			)
+		},
+		Err(e) => {
+			let err = Error::new(Span::call_site(), e).to_compile_error();
+			quote!( #err )
+		},
+	}
+}
+
+// fn to remove white spaces around string types
+// (basically whitespaces around tokens)
+pub fn clean_type_string(input: &str) -> String {
+	input
+		.replace(" ::", "::")
+		.replace(":: ", "::")
+		.replace(" ,", ",")
+		.replace(" ;", ";")
+		.replace(" [", "[")
+		.replace("[ ", "[")
+		.replace(" ]", "]")
+		.replace(" (", "(")
+		.replace("( ", "(")
+		.replace(" )", ")")
+		.replace(" <", "<")
+		.replace("< ", "<")
+		.replace(" >", ">")
+}
+
+/// Return all doc attributes literals found.
+pub fn get_doc_literals(attrs: &[syn::Attribute]) -> Vec<syn::Expr> {
+	attrs
+		.iter()
+		.filter_map(|attr| {
+			if let syn::Meta::NameValue(meta) = &attr.meta {
+				meta.path
+					.get_ident()
+					.filter(|ident| *ident == "doc")
+					.map(|_| meta.value.clone())
+			} else {
+				None
+			}
+		})
+		.collect()
+}
diff --git a/substrate/frame/support/procedural/tools/src/syn_ext.rs b/substrate/frame/support/procedural/tools/src/syn_ext.rs
new file mode 100644
index 0000000000000000000000000000000000000000..833cd17dfacb45dda66540c2ace348a9f4f43e90
--- /dev/null
+++ b/substrate/frame/support/procedural/tools/src/syn_ext.rs
@@ -0,0 +1,230 @@
+// 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.
+
+// tag::description[]
+//! Extension to syn types, mainly for parsing
+// end::description[]
+
+use frame_support_procedural_tools_derive::{Parse, ToTokens};
+use proc_macro2::{TokenStream, TokenTree};
+use quote::ToTokens;
+use std::iter::once;
+use syn::{
+	parse::{Parse, ParseStream, Result},
+	visit::{self, Visit},
+	Ident,
+};
+
+/// stop parsing here getting remaining token as content
+/// Warn duplicate stream (part of)
+#[derive(Parse, ToTokens, Debug)]
+pub struct StopParse {
+	pub inner: TokenStream,
+}
+
+// inner macro really dependant on syn naming convention, do not export
+macro_rules! groups_impl {
+	($name:ident, $tok:ident, $deli:ident, $parse:ident) => {
+		#[derive(Debug)]
+		pub struct $name<P> {
+			pub token: syn::token::$tok,
+			pub content: P,
+		}
+
+		impl<P: Parse> Parse for $name<P> {
+			fn parse(input: ParseStream) -> Result<Self> {
+				let content;
+				let token = syn::$parse!(content in input);
+				let content = content.parse()?;
+				Ok($name { token, content })
+			}
+		}
+
+		impl<P: ToTokens> ToTokens for $name<P> {
+			fn to_tokens(&self, tokens: &mut TokenStream) {
+				let mut inner_stream = TokenStream::new();
+				self.content.to_tokens(&mut inner_stream);
+				let token_tree: proc_macro2::TokenTree =
+					proc_macro2::Group::new(proc_macro2::Delimiter::$deli, inner_stream).into();
+				tokens.extend(once(token_tree));
+			}
+		}
+
+		impl<P: Clone> Clone for $name<P> {
+			fn clone(&self) -> Self {
+				Self { token: self.token.clone(), content: self.content.clone() }
+			}
+		}
+	};
+}
+
+groups_impl!(Braces, Brace, Brace, braced);
+groups_impl!(Brackets, Bracket, Bracket, bracketed);
+groups_impl!(Parens, Paren, Parenthesis, parenthesized);
+
+#[derive(Debug)]
+pub struct PunctuatedInner<P, T, V> {
+	pub inner: syn::punctuated::Punctuated<P, T>,
+	pub variant: V,
+}
+
+#[derive(Debug, Clone)]
+pub struct NoTrailing;
+
+#[derive(Debug, Clone)]
+pub struct Trailing;
+
+pub type Punctuated<P, T> = PunctuatedInner<P, T, NoTrailing>;
+
+pub type PunctuatedTrailing<P, T> = PunctuatedInner<P, T, Trailing>;
+
+impl<P: Parse, T: Parse + syn::token::Token> Parse for PunctuatedInner<P, T, Trailing> {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(PunctuatedInner {
+			inner: syn::punctuated::Punctuated::parse_separated_nonempty(input)?,
+			variant: Trailing,
+		})
+	}
+}
+
+impl<P: Parse, T: Parse> Parse for PunctuatedInner<P, T, NoTrailing> {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(PunctuatedInner {
+			inner: syn::punctuated::Punctuated::parse_terminated(input)?,
+			variant: NoTrailing,
+		})
+	}
+}
+
+impl<P: ToTokens, T: ToTokens, V> ToTokens for PunctuatedInner<P, T, V> {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		self.inner.to_tokens(tokens)
+	}
+}
+
+impl<P: Clone, T: Clone, V: Clone> Clone for PunctuatedInner<P, T, V> {
+	fn clone(&self) -> Self {
+		Self { inner: self.inner.clone(), variant: self.variant.clone() }
+	}
+}
+
+/// Note that syn Meta is almost fine for use case (lacks only `ToToken`)
+#[derive(Debug, Clone)]
+pub struct Meta {
+	pub inner: syn::Meta,
+}
+
+impl Parse for Meta {
+	fn parse(input: ParseStream) -> Result<Self> {
+		Ok(Meta { inner: syn::Meta::parse(input)? })
+	}
+}
+
+impl ToTokens for Meta {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		match self.inner {
+			syn::Meta::Path(ref path) => path.to_tokens(tokens),
+			syn::Meta::List(ref l) => l.to_tokens(tokens),
+			syn::Meta::NameValue(ref n) => n.to_tokens(tokens),
+		}
+	}
+}
+
+#[derive(Debug)]
+pub struct OuterAttributes {
+	pub inner: Vec<syn::Attribute>,
+}
+
+impl Parse for OuterAttributes {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let inner = syn::Attribute::parse_outer(input)?;
+		Ok(OuterAttributes { inner })
+	}
+}
+
+impl ToTokens for OuterAttributes {
+	fn to_tokens(&self, tokens: &mut TokenStream) {
+		for att in self.inner.iter() {
+			att.to_tokens(tokens);
+		}
+	}
+}
+
+pub fn extract_type_option(typ: &syn::Type) -> Option<syn::Type> {
+	if let syn::Type::Path(ref path) = typ {
+		let v = path.path.segments.last()?;
+		if v.ident == "Option" {
+			// Option has only one type argument in angle bracket.
+			if let syn::PathArguments::AngleBracketed(a) = &v.arguments {
+				if let syn::GenericArgument::Type(typ) = a.args.last()? {
+					return Some(typ.clone())
+				}
+			}
+		}
+	}
+
+	None
+}
+
+/// Auxiliary structure to check if a given `Ident` is contained in an ast.
+struct ContainsIdent<'a> {
+	ident: &'a Ident,
+	result: bool,
+}
+
+impl<'ast> ContainsIdent<'ast> {
+	fn visit_tokenstream(&mut self, stream: TokenStream) {
+		stream.into_iter().for_each(|tt| match tt {
+			TokenTree::Ident(id) => self.visit_ident(&id),
+			TokenTree::Group(ref group) => self.visit_tokenstream(group.stream()),
+			_ => {},
+		})
+	}
+
+	fn visit_ident(&mut self, ident: &Ident) {
+		if ident == self.ident {
+			self.result = true;
+		}
+	}
+}
+
+impl<'ast> Visit<'ast> for ContainsIdent<'ast> {
+	fn visit_ident(&mut self, input: &'ast Ident) {
+		self.visit_ident(input);
+	}
+
+	fn visit_macro(&mut self, input: &'ast syn::Macro) {
+		self.visit_tokenstream(input.tokens.clone());
+		visit::visit_macro(self, input);
+	}
+}
+
+/// Check if a `Type` contains the given `Ident`.
+pub fn type_contains_ident(typ: &syn::Type, ident: &Ident) -> bool {
+	let mut visit = ContainsIdent { result: false, ident };
+
+	visit::visit_type(&mut visit, typ);
+	visit.result
+}
+
+/// Check if a `Expr` contains the given `Ident`.
+pub fn expr_contains_ident(expr: &syn::Expr, ident: &Ident) -> bool {
+	let mut visit = ContainsIdent { result: false, ident };
+
+	visit::visit_expr(&mut visit, expr);
+	visit.result
+}
diff --git a/substrate/frame/support/src/crypto.rs b/substrate/frame/support/src/crypto.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1957a7bc97cead92496347376d4e5e4e2fc8f03f
--- /dev/null
+++ b/substrate/frame/support/src/crypto.rs
@@ -0,0 +1,21 @@
+// 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.
+
+//! Utilities for dealing with crypto primitives. Sometimes we need to use these from inside WASM
+//! contracts, where crypto calculations have weak performance.
+
+pub mod ecdsa;
diff --git a/substrate/frame/support/src/crypto/ecdsa.rs b/substrate/frame/support/src/crypto/ecdsa.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d50b51049c9022641a1c3203ceccb1e8919736a
--- /dev/null
+++ b/substrate/frame/support/src/crypto/ecdsa.rs
@@ -0,0 +1,65 @@
+// 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.
+
+//! Simple ECDSA secp256k1 API.
+//!
+//! Provides an extension trait for [`sp_core::ecdsa::Public`] to do certain operations.
+
+use sp_core::{crypto::ByteArray, ecdsa::Public};
+
+/// Extension trait for [`Public`] to be used from inside the runtime.
+///
+/// # Note
+///
+/// This is needed because host functions cannot be called from within
+/// `sp_core` due to cyclic dependencies  on `sp_io`.
+pub trait ECDSAExt {
+	/// Returns Ethereum address calculated from this ECDSA public key.
+	fn to_eth_address(&self) -> Result<[u8; 20], ()>;
+}
+
+impl ECDSAExt for Public {
+	fn to_eth_address(&self) -> Result<[u8; 20], ()> {
+		use k256::{elliptic_curve::sec1::ToEncodedPoint, PublicKey};
+
+		PublicKey::from_sec1_bytes(self.as_slice()).map_err(drop).and_then(|pub_key| {
+			// uncompress the key
+			let uncompressed = pub_key.to_encoded_point(false);
+			// convert to ETH address
+			<[u8; 20]>::try_from(
+				sp_io::hashing::keccak_256(&uncompressed.as_bytes()[1..])[12..].as_ref(),
+			)
+			.map_err(drop)
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{ecdsa, Pair};
+
+	#[test]
+	fn to_eth_address_works() {
+		let pair = ecdsa::Pair::from_string("//Alice//password", None).unwrap();
+		let eth_address = pair.public().to_eth_address().unwrap();
+		assert_eq!(
+			array_bytes::bytes2hex("0x", &eth_address),
+			"0xdc1cce4263956850a3c8eb349dc6fc3f7792cb27"
+		);
+	}
+}
diff --git a/substrate/frame/support/src/dispatch.rs b/substrate/frame/support/src/dispatch.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0388a9adb394895b5fbc88c3041bb4893eb11be0
--- /dev/null
+++ b/substrate/frame/support/src/dispatch.rs
@@ -0,0 +1,1095 @@
+// 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.
+
+//! Dispatch system. Contains a macro for defining runtime modules and
+//! generating values representing lazy module function calls.
+
+pub use crate::traits::{
+	CallMetadata, GetCallIndex, GetCallMetadata, GetCallName, GetStorageVersion,
+	UnfilteredDispatchable,
+};
+pub use codec::{
+	Codec, Decode, Encode, EncodeAsRef, EncodeLike, HasCompact, Input, MaxEncodedLen, Output,
+};
+pub use scale_info::TypeInfo;
+pub use sp_runtime::{
+	traits::Dispatchable, transaction_validity::TransactionPriority, DispatchError, RuntimeDebug,
+};
+pub use sp_std::{
+	fmt, marker,
+	prelude::{Clone, Eq, PartialEq, Vec},
+	result,
+};
+pub use sp_weights::Weight;
+
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+use sp_runtime::{
+	generic::{CheckedExtrinsic, UncheckedExtrinsic},
+	traits::SignedExtension,
+};
+
+/// The return type of a `Dispatchable` in frame. When returned explicitly from
+/// a dispatchable function it allows overriding the default `PostDispatchInfo`
+/// returned from a dispatch.
+pub type DispatchResultWithPostInfo = sp_runtime::DispatchResultWithInfo<PostDispatchInfo>;
+
+/// Unaugmented version of `DispatchResultWithPostInfo` that can be returned from
+/// dispatchable functions and is automatically converted to the augmented type. Should be
+/// used whenever the `PostDispatchInfo` does not need to be overwritten. As this should
+/// be the common case it is the implicit return type when none is specified.
+pub type DispatchResult = Result<(), sp_runtime::DispatchError>;
+
+/// The error type contained in a `DispatchResultWithPostInfo`.
+pub type DispatchErrorWithPostInfo = sp_runtime::DispatchErrorWithPostInfo<PostDispatchInfo>;
+
+/// Serializable version of pallet dispatchable.
+pub trait Callable<T> {
+	type RuntimeCall: UnfilteredDispatchable + Codec + Clone + PartialEq + Eq;
+}
+
+// dirty hack to work around serde_derive issue
+// https://github.com/rust-lang/rust/issues/51331
+pub type CallableCallFor<A, R> = <A as Callable<R>>::RuntimeCall;
+
+/// Origin for the System pallet.
+#[derive(PartialEq, Eq, Clone, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub enum RawOrigin<AccountId> {
+	/// The system itself ordained this dispatch to happen: this is the highest privilege level.
+	Root,
+	/// It is signed by some public key and we provide the `AccountId`.
+	Signed(AccountId),
+	/// It is signed by nobody, can be either:
+	/// * included and agreed upon by the validators anyway,
+	/// * or unsigned transaction validated by a pallet.
+	None,
+}
+
+impl<AccountId> From<Option<AccountId>> for RawOrigin<AccountId> {
+	fn from(s: Option<AccountId>) -> RawOrigin<AccountId> {
+		match s {
+			Some(who) => RawOrigin::Signed(who),
+			None => RawOrigin::None,
+		}
+	}
+}
+
+impl<AccountId> RawOrigin<AccountId> {
+	/// Returns `Some` with a reference to the `AccountId` if `self` is `Signed`, `None` otherwise.
+	pub fn as_signed(&self) -> Option<&AccountId> {
+		match &self {
+			Self::Signed(x) => Some(x),
+			_ => None,
+		}
+	}
+
+	/// Returns `true` if `self` is `Root`, `None` otherwise.
+	pub fn is_root(&self) -> bool {
+		matches!(&self, Self::Root)
+	}
+
+	/// Returns `true` if `self` is `None`, `None` otherwise.
+	pub fn is_none(&self) -> bool {
+		matches!(&self, Self::None)
+	}
+}
+
+/// A type that can be used as a parameter in a dispatchable function.
+///
+/// When using `decl_module` all arguments for call functions must implement this trait.
+pub trait Parameter: Codec + EncodeLike + Clone + Eq + fmt::Debug + scale_info::TypeInfo {}
+impl<T> Parameter for T where T: Codec + EncodeLike + Clone + Eq + fmt::Debug + scale_info::TypeInfo {}
+
+/// Means of classifying a dispatchable function.
+pub trait ClassifyDispatch<T> {
+	/// Classify the dispatch function based on input data `target` of type `T`. When implementing
+	/// this for a dispatchable, `T` will be a tuple of all arguments given to the function (except
+	/// origin).
+	fn classify_dispatch(&self, target: T) -> DispatchClass;
+}
+
+/// Indicates if dispatch function should pay fees or not.
+///
+/// If set to `Pays::No`, the block resource limits are applied, yet no fee is deducted.
+pub trait PaysFee<T> {
+	fn pays_fee(&self, _target: T) -> Pays;
+}
+
+/// Explicit enum to denote if a transaction pays fee or not.
+#[derive(Clone, Copy, Eq, PartialEq, RuntimeDebug, Encode, Decode, TypeInfo)]
+pub enum Pays {
+	/// Transactor will pay related fees.
+	Yes,
+	/// Transactor will NOT pay related fees.
+	No,
+}
+
+impl Default for Pays {
+	fn default() -> Self {
+		Self::Yes
+	}
+}
+
+impl From<Pays> for PostDispatchInfo {
+	fn from(pays_fee: Pays) -> Self {
+		Self { actual_weight: None, pays_fee }
+	}
+}
+
+/// A generalized group of dispatch types.
+///
+/// NOTE whenever upgrading the enum make sure to also update
+/// [DispatchClass::all] and [DispatchClass::non_mandatory] helper functions.
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub enum DispatchClass {
+	/// A normal dispatch.
+	Normal,
+	/// An operational dispatch.
+	Operational,
+	/// A mandatory dispatch. These kinds of dispatch are always included regardless of their
+	/// weight, therefore it is critical that they are separately validated to ensure that a
+	/// malicious validator cannot craft a valid but impossibly heavy block. Usually this just
+	/// means ensuring that the extrinsic can only be included once and that it is always very
+	/// light.
+	///
+	/// Do *NOT* use it for extrinsics that can be heavy.
+	///
+	/// The only real use case for this is inherent extrinsics that are required to execute in a
+	/// block for the block to be valid, and it solves the issue in the case that the block
+	/// initialization is sufficiently heavy to mean that those inherents do not fit into the
+	/// block. Essentially, we assume that in these exceptional circumstances, it is better to
+	/// allow an overweight block to be created than to not allow any block at all to be created.
+	Mandatory,
+}
+
+impl Default for DispatchClass {
+	fn default() -> Self {
+		Self::Normal
+	}
+}
+
+impl DispatchClass {
+	/// Returns an array containing all dispatch classes.
+	pub fn all() -> &'static [DispatchClass] {
+		&[DispatchClass::Normal, DispatchClass::Operational, DispatchClass::Mandatory]
+	}
+
+	/// Returns an array of all dispatch classes except `Mandatory`.
+	pub fn non_mandatory() -> &'static [DispatchClass] {
+		&[DispatchClass::Normal, DispatchClass::Operational]
+	}
+}
+
+/// A trait that represents one or many values of given type.
+///
+/// Useful to accept as parameter type to let the caller pass either a single value directly
+/// or an iterator.
+pub trait OneOrMany<T> {
+	/// The iterator type.
+	type Iter: Iterator<Item = T>;
+	/// Convert this item into an iterator.
+	fn into_iter(self) -> Self::Iter;
+}
+
+impl OneOrMany<DispatchClass> for DispatchClass {
+	type Iter = sp_std::iter::Once<DispatchClass>;
+	fn into_iter(self) -> Self::Iter {
+		sp_std::iter::once(self)
+	}
+}
+
+impl<'a> OneOrMany<DispatchClass> for &'a [DispatchClass] {
+	type Iter = sp_std::iter::Cloned<sp_std::slice::Iter<'a, DispatchClass>>;
+	fn into_iter(self) -> Self::Iter {
+		self.iter().cloned()
+	}
+}
+
+/// A bundle of static information collected from the `#[pallet::weight]` attributes.
+#[derive(Clone, Copy, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo)]
+pub struct DispatchInfo {
+	/// Weight of this transaction.
+	pub weight: Weight,
+	/// Class of this transaction.
+	pub class: DispatchClass,
+	/// Does this transaction pay fees.
+	pub pays_fee: Pays,
+}
+
+/// A `Dispatchable` function (aka transaction) that can carry some static information along with
+/// it, using the `#[pallet::weight]` attribute.
+pub trait GetDispatchInfo {
+	/// Return a `DispatchInfo`, containing relevant information of this dispatch.
+	///
+	/// This is done independently of its encoded size.
+	fn get_dispatch_info(&self) -> DispatchInfo;
+}
+
+impl GetDispatchInfo for () {
+	fn get_dispatch_info(&self) -> DispatchInfo {
+		DispatchInfo::default()
+	}
+}
+
+/// Extract the actual weight from a dispatch result if any or fall back to the default weight.
+pub fn extract_actual_weight(result: &DispatchResultWithPostInfo, info: &DispatchInfo) -> Weight {
+	match result {
+		Ok(post_info) => post_info,
+		Err(err) => &err.post_info,
+	}
+	.calc_actual_weight(info)
+}
+
+/// Extract the actual pays_fee from a dispatch result if any or fall back to the default weight.
+pub fn extract_actual_pays_fee(result: &DispatchResultWithPostInfo, info: &DispatchInfo) -> Pays {
+	match result {
+		Ok(post_info) => post_info,
+		Err(err) => &err.post_info,
+	}
+	.pays_fee(info)
+}
+
+/// Weight information that is only available post dispatch.
+/// NOTE: This can only be used to reduce the weight or fee, not increase it.
+#[derive(Clone, Copy, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo)]
+pub struct PostDispatchInfo {
+	/// Actual weight consumed by a call or `None` which stands for the worst case static weight.
+	pub actual_weight: Option<Weight>,
+	/// Whether this transaction should pay fees when all is said and done.
+	pub pays_fee: Pays,
+}
+
+impl PostDispatchInfo {
+	/// Calculate how much (if any) weight was not used by the `Dispatchable`.
+	pub fn calc_unspent(&self, info: &DispatchInfo) -> Weight {
+		info.weight - self.calc_actual_weight(info)
+	}
+
+	/// Calculate how much weight was actually spent by the `Dispatchable`.
+	pub fn calc_actual_weight(&self, info: &DispatchInfo) -> Weight {
+		if let Some(actual_weight) = self.actual_weight {
+			actual_weight.min(info.weight)
+		} else {
+			info.weight
+		}
+	}
+
+	/// Determine if user should actually pay fees at the end of the dispatch.
+	pub fn pays_fee(&self, info: &DispatchInfo) -> Pays {
+		// If they originally were not paying fees, or the post dispatch info
+		// says they should not pay fees, then they don't pay fees.
+		// This is because the pre dispatch information must contain the
+		// worst case for weight and fees paid.
+		if info.pays_fee == Pays::No || self.pays_fee == Pays::No {
+			Pays::No
+		} else {
+			// Otherwise they pay.
+			Pays::Yes
+		}
+	}
+}
+
+impl From<()> for PostDispatchInfo {
+	fn from(_: ()) -> Self {
+		Self { actual_weight: None, pays_fee: Default::default() }
+	}
+}
+
+impl sp_runtime::traits::Printable for PostDispatchInfo {
+	fn print(&self) {
+		"actual_weight=".print();
+		match self.actual_weight {
+			Some(weight) => weight.print(),
+			None => "max-weight".print(),
+		};
+		"pays_fee=".print();
+		match self.pays_fee {
+			Pays::Yes => "Yes".print(),
+			Pays::No => "No".print(),
+		}
+	}
+}
+
+/// Allows easy conversion from `DispatchError` to `DispatchErrorWithPostInfo` for dispatchables
+/// that want to return a custom a posterior weight on error.
+pub trait WithPostDispatchInfo {
+	/// Call this on your modules custom errors type in order to return a custom weight on error.
+	///
+	/// # Example
+	///
+	/// ```ignore
+	/// let who = ensure_signed(origin).map_err(|e| e.with_weight(Weight::from_parts(100, 0)))?;
+	/// ensure!(who == me, Error::<T>::NotMe.with_weight(200_000));
+	/// ```
+	fn with_weight(self, actual_weight: Weight) -> DispatchErrorWithPostInfo;
+}
+
+impl<T> WithPostDispatchInfo for T
+where
+	T: Into<DispatchError>,
+{
+	fn with_weight(self, actual_weight: Weight) -> DispatchErrorWithPostInfo {
+		DispatchErrorWithPostInfo {
+			post_info: PostDispatchInfo {
+				actual_weight: Some(actual_weight),
+				pays_fee: Default::default(),
+			},
+			error: self.into(),
+		}
+	}
+}
+
+/// Implementation for unchecked extrinsic.
+impl<Address, Call, Signature, Extra> GetDispatchInfo
+	for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Call: GetDispatchInfo,
+	Extra: SignedExtension,
+{
+	fn get_dispatch_info(&self) -> DispatchInfo {
+		self.function.get_dispatch_info()
+	}
+}
+
+/// Implementation for checked extrinsic.
+impl<AccountId, Call, Extra> GetDispatchInfo for CheckedExtrinsic<AccountId, Call, Extra>
+where
+	Call: GetDispatchInfo,
+{
+	fn get_dispatch_info(&self) -> DispatchInfo {
+		self.function.get_dispatch_info()
+	}
+}
+
+/// Implementation for test extrinsic.
+#[cfg(feature = "std")]
+impl<Call: Encode + GetDispatchInfo, Extra: Encode> GetDispatchInfo
+	for sp_runtime::testing::TestXt<Call, Extra>
+{
+	fn get_dispatch_info(&self) -> DispatchInfo {
+		// for testing: weight == size.
+		DispatchInfo {
+			weight: Weight::from_parts(self.encode().len() as _, 0),
+			pays_fee: Pays::Yes,
+			class: self.call.get_dispatch_info().class,
+		}
+	}
+}
+
+/// A struct holding value for each `DispatchClass`.
+#[derive(Clone, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub struct PerDispatchClass<T> {
+	/// Value for `Normal` extrinsics.
+	normal: T,
+	/// Value for `Operational` extrinsics.
+	operational: T,
+	/// Value for `Mandatory` extrinsics.
+	mandatory: T,
+}
+
+impl<T> PerDispatchClass<T> {
+	/// Create new `PerDispatchClass` with the same value for every class.
+	pub fn new(val: impl Fn(DispatchClass) -> T) -> Self {
+		Self {
+			normal: val(DispatchClass::Normal),
+			operational: val(DispatchClass::Operational),
+			mandatory: val(DispatchClass::Mandatory),
+		}
+	}
+
+	/// Get a mutable reference to current value of given class.
+	pub fn get_mut(&mut self, class: DispatchClass) -> &mut T {
+		match class {
+			DispatchClass::Operational => &mut self.operational,
+			DispatchClass::Normal => &mut self.normal,
+			DispatchClass::Mandatory => &mut self.mandatory,
+		}
+	}
+
+	/// Get current value for given class.
+	pub fn get(&self, class: DispatchClass) -> &T {
+		match class {
+			DispatchClass::Normal => &self.normal,
+			DispatchClass::Operational => &self.operational,
+			DispatchClass::Mandatory => &self.mandatory,
+		}
+	}
+}
+
+impl<T: Clone> PerDispatchClass<T> {
+	/// Set the value of given class.
+	pub fn set(&mut self, new: T, class: impl OneOrMany<DispatchClass>) {
+		for class in class.into_iter() {
+			*self.get_mut(class) = new.clone();
+		}
+	}
+}
+
+impl PerDispatchClass<Weight> {
+	/// Returns the total weight consumed by all extrinsics in the block.
+	///
+	/// Saturates on overflow.
+	pub fn total(&self) -> Weight {
+		let mut sum = Weight::zero();
+		for class in DispatchClass::all() {
+			sum.saturating_accrue(*self.get(*class));
+		}
+		sum
+	}
+
+	/// Add some weight to the given class. Saturates at the numeric bounds.
+	pub fn add(mut self, weight: Weight, class: DispatchClass) -> Self {
+		self.accrue(weight, class);
+		self
+	}
+
+	/// Increase the weight of the given class. Saturates at the numeric bounds.
+	pub fn accrue(&mut self, weight: Weight, class: DispatchClass) {
+		self.get_mut(class).saturating_accrue(weight);
+	}
+
+	/// Try to increase the weight of the given class. Saturates at the numeric bounds.
+	pub fn checked_accrue(&mut self, weight: Weight, class: DispatchClass) -> Result<(), ()> {
+		self.get_mut(class).checked_accrue(weight).ok_or(())
+	}
+
+	/// Reduce the weight of the given class. Saturates at the numeric bounds.
+	pub fn reduce(&mut self, weight: Weight, class: DispatchClass) {
+		self.get_mut(class).saturating_reduce(weight);
+	}
+}
+
+/// Means of weighing some particular kind of data (`T`).
+pub trait WeighData<T> {
+	/// Weigh the data `T` given by `target`. When implementing this for a dispatchable, `T` will be
+	/// a tuple of all arguments given to the function (except origin).
+	fn weigh_data(&self, target: T) -> Weight;
+}
+
+impl<T> WeighData<T> for Weight {
+	fn weigh_data(&self, _: T) -> Weight {
+		return *self
+	}
+}
+
+impl<T> PaysFee<T> for (Weight, DispatchClass, Pays) {
+	fn pays_fee(&self, _: T) -> Pays {
+		self.2
+	}
+}
+
+impl<T> WeighData<T> for (Weight, DispatchClass) {
+	fn weigh_data(&self, args: T) -> Weight {
+		return self.0.weigh_data(args)
+	}
+}
+
+impl<T> WeighData<T> for (Weight, DispatchClass, Pays) {
+	fn weigh_data(&self, args: T) -> Weight {
+		return self.0.weigh_data(args)
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (Weight, DispatchClass) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		self.1
+	}
+}
+
+impl<T> PaysFee<T> for (Weight, DispatchClass) {
+	fn pays_fee(&self, _: T) -> Pays {
+		Pays::Yes
+	}
+}
+
+impl<T> WeighData<T> for (Weight, Pays) {
+	fn weigh_data(&self, args: T) -> Weight {
+		return self.0.weigh_data(args)
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (Weight, Pays) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		DispatchClass::Normal
+	}
+}
+
+impl<T> PaysFee<T> for (Weight, Pays) {
+	fn pays_fee(&self, _: T) -> Pays {
+		self.1
+	}
+}
+
+impl From<(Option<Weight>, Pays)> for PostDispatchInfo {
+	fn from(post_weight_info: (Option<Weight>, Pays)) -> Self {
+		let (actual_weight, pays_fee) = post_weight_info;
+		Self { actual_weight, pays_fee }
+	}
+}
+
+impl From<Option<Weight>> for PostDispatchInfo {
+	fn from(actual_weight: Option<Weight>) -> Self {
+		Self { actual_weight, pays_fee: Default::default() }
+	}
+}
+
+impl<T> ClassifyDispatch<T> for Weight {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		DispatchClass::Normal
+	}
+}
+
+impl<T> PaysFee<T> for Weight {
+	fn pays_fee(&self, _: T) -> Pays {
+		Pays::Yes
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (Weight, DispatchClass, Pays) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		self.1
+	}
+}
+
+// TODO: Eventually remove these
+
+impl<T> ClassifyDispatch<T> for u64 {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		DispatchClass::Normal
+	}
+}
+
+impl<T> PaysFee<T> for u64 {
+	fn pays_fee(&self, _: T) -> Pays {
+		Pays::Yes
+	}
+}
+
+impl<T> WeighData<T> for u64 {
+	fn weigh_data(&self, _: T) -> Weight {
+		return Weight::from_parts(*self, 0)
+	}
+}
+
+impl<T> WeighData<T> for (u64, DispatchClass, Pays) {
+	fn weigh_data(&self, args: T) -> Weight {
+		return self.0.weigh_data(args)
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (u64, DispatchClass, Pays) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		self.1
+	}
+}
+
+impl<T> PaysFee<T> for (u64, DispatchClass, Pays) {
+	fn pays_fee(&self, _: T) -> Pays {
+		self.2
+	}
+}
+
+impl<T> WeighData<T> for (u64, DispatchClass) {
+	fn weigh_data(&self, args: T) -> Weight {
+		return self.0.weigh_data(args)
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (u64, DispatchClass) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		self.1
+	}
+}
+
+impl<T> PaysFee<T> for (u64, DispatchClass) {
+	fn pays_fee(&self, _: T) -> Pays {
+		Pays::Yes
+	}
+}
+
+impl<T> WeighData<T> for (u64, Pays) {
+	fn weigh_data(&self, args: T) -> Weight {
+		return self.0.weigh_data(args)
+	}
+}
+
+impl<T> ClassifyDispatch<T> for (u64, Pays) {
+	fn classify_dispatch(&self, _: T) -> DispatchClass {
+		DispatchClass::Normal
+	}
+}
+
+impl<T> PaysFee<T> for (u64, Pays) {
+	fn pays_fee(&self, _: T) -> Pays {
+		self.1
+	}
+}
+
+// END TODO
+
+#[cfg(test)]
+// Do not complain about unused `dispatch` and `dispatch_aux`.
+#[allow(dead_code)]
+mod weight_tests {
+	use super::*;
+	use sp_core::parameter_types;
+	use sp_runtime::{generic, traits::BlakeTwo256};
+	use sp_weights::RuntimeDbWeight;
+
+	pub use self::frame_system::{Call, Config, Pallet};
+
+	fn from_actual_ref_time(ref_time: Option<u64>) -> PostDispatchInfo {
+		PostDispatchInfo {
+			actual_weight: ref_time.map(|t| Weight::from_all(t)),
+			pays_fee: Default::default(),
+		}
+	}
+
+	fn from_post_weight_info(ref_time: Option<u64>, pays_fee: Pays) -> PostDispatchInfo {
+		PostDispatchInfo { actual_weight: ref_time.map(|t| Weight::from_all(t)), pays_fee }
+	}
+
+	#[crate::pallet(dev_mode)]
+	pub mod frame_system {
+		use super::{frame_system, frame_system::pallet_prelude::*};
+		pub use crate::dispatch::RawOrigin;
+		use crate::pallet_prelude::*;
+
+		#[pallet::pallet]
+		pub struct Pallet<T>(_);
+
+		#[pallet::config]
+		#[pallet::disable_frame_system_supertrait_check]
+		pub trait Config: 'static {
+			type Block: Parameter + sp_runtime::traits::Block;
+			type AccountId;
+			type Balance;
+			type BaseCallFilter: crate::traits::Contains<Self::RuntimeCall>;
+			type RuntimeOrigin;
+			type RuntimeCall;
+			type PalletInfo: crate::traits::PalletInfo;
+			type DbWeight: Get<crate::weights::RuntimeDbWeight>;
+		}
+
+		#[pallet::error]
+		pub enum Error<T> {
+			/// Required by construct_runtime
+			CallFiltered,
+		}
+
+		#[pallet::origin]
+		pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
+
+		#[pallet::call]
+		impl<T: Config> Pallet<T> {
+			// no arguments, fixed weight
+			#[pallet::weight(1000)]
+			pub fn f00(_origin: OriginFor<T>) -> DispatchResult {
+				unimplemented!();
+			}
+
+			#[pallet::weight((1000, DispatchClass::Mandatory))]
+			pub fn f01(_origin: OriginFor<T>) -> DispatchResult {
+				unimplemented!();
+			}
+
+			#[pallet::weight((1000, Pays::No))]
+			pub fn f02(_origin: OriginFor<T>) -> DispatchResult {
+				unimplemented!();
+			}
+
+			#[pallet::weight((1000, DispatchClass::Operational, Pays::No))]
+			pub fn f03(_origin: OriginFor<T>) -> DispatchResult {
+				unimplemented!();
+			}
+
+			// weight = a x 10 + b
+			#[pallet::weight(((_a * 10 + _eb * 1) as u64, DispatchClass::Normal, Pays::Yes))]
+			pub fn f11(_origin: OriginFor<T>, _a: u32, _eb: u32) -> DispatchResult {
+				unimplemented!();
+			}
+
+			#[pallet::weight((0, DispatchClass::Operational, Pays::Yes))]
+			pub fn f12(_origin: OriginFor<T>, _a: u32, _eb: u32) -> DispatchResult {
+				unimplemented!();
+			}
+
+			#[pallet::weight(T::DbWeight::get().reads(3) + T::DbWeight::get().writes(2) + Weight::from_all(10_000))]
+			pub fn f20(_origin: OriginFor<T>) -> DispatchResult {
+				unimplemented!();
+			}
+
+			#[pallet::weight(T::DbWeight::get().reads_writes(6, 5) + Weight::from_all(40_000))]
+			pub fn f21(_origin: OriginFor<T>) -> DispatchResult {
+				unimplemented!();
+			}
+		}
+
+		pub mod pallet_prelude {
+			pub type OriginFor<T> = <T as super::Config>::RuntimeOrigin;
+
+			pub type HeaderFor<T> =
+				<<T as super::Config>::Block as sp_runtime::traits::HeaderProvider>::HeaderT;
+
+			pub type BlockNumberFor<T> = <HeaderFor<T> as sp_runtime::traits::Header>::Number;
+		}
+	}
+
+	type BlockNumber = u32;
+	type AccountId = u32;
+	type Balance = u32;
+	type Header = generic::Header<BlockNumber, BlakeTwo256>;
+	type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+	type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+	crate::construct_runtime!(
+		pub enum Runtime
+		{
+			System: self::frame_system,
+		}
+	);
+
+	parameter_types! {
+		pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 100,
+			write: 1000,
+		};
+	}
+
+	impl Config for Runtime {
+		type Block = Block;
+		type AccountId = AccountId;
+		type Balance = Balance;
+		type BaseCallFilter = crate::traits::Everything;
+		type RuntimeOrigin = RuntimeOrigin;
+		type RuntimeCall = RuntimeCall;
+		type DbWeight = DbWeight;
+		type PalletInfo = PalletInfo;
+	}
+
+	#[test]
+	fn weights_are_correct() {
+		// #[pallet::weight(1000)]
+		let info = Call::<Runtime>::f00 {}.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(1000, 0));
+		assert_eq!(info.class, DispatchClass::Normal);
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// #[pallet::weight((1000, DispatchClass::Mandatory))]
+		let info = Call::<Runtime>::f01 {}.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(1000, 0));
+		assert_eq!(info.class, DispatchClass::Mandatory);
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// #[pallet::weight((1000, Pays::No))]
+		let info = Call::<Runtime>::f02 {}.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(1000, 0));
+		assert_eq!(info.class, DispatchClass::Normal);
+		assert_eq!(info.pays_fee, Pays::No);
+
+		// #[pallet::weight((1000, DispatchClass::Operational, Pays::No))]
+		let info = Call::<Runtime>::f03 {}.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(1000, 0));
+		assert_eq!(info.class, DispatchClass::Operational);
+		assert_eq!(info.pays_fee, Pays::No);
+
+		// #[pallet::weight(((_a * 10 + _eb * 1) as u64, DispatchClass::Normal, Pays::Yes))]
+		let info = Call::<Runtime>::f11 { a: 13, eb: 20 }.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(150, 0)); // 13*10 + 20
+		assert_eq!(info.class, DispatchClass::Normal);
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// #[pallet::weight((0, DispatchClass::Operational, Pays::Yes))]
+		let info = Call::<Runtime>::f12 { a: 10, eb: 20 }.get_dispatch_info();
+		assert_eq!(info.weight, Weight::zero());
+		assert_eq!(info.class, DispatchClass::Operational);
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// #[pallet::weight(T::DbWeight::get().reads(3) + T::DbWeight::get().writes(2) +
+		// Weight::from_all(10_000))]
+		let info = Call::<Runtime>::f20 {}.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(12300, 10000)); // 100*3 + 1000*2 + 10_1000
+		assert_eq!(info.class, DispatchClass::Normal);
+		assert_eq!(info.pays_fee, Pays::Yes);
+
+		// #[pallet::weight(T::DbWeight::get().reads_writes(6, 5) + Weight::from_all(40_000))]
+		let info = Call::<Runtime>::f21 {}.get_dispatch_info();
+		assert_eq!(info.weight, Weight::from_parts(45600, 40000)); // 100*6 + 1000*5 + 40_1000
+		assert_eq!(info.class, DispatchClass::Normal);
+		assert_eq!(info.pays_fee, Pays::Yes);
+	}
+
+	#[test]
+	fn extract_actual_weight_works() {
+		let pre = DispatchInfo { weight: Weight::from_parts(1000, 0), ..Default::default() };
+		assert_eq!(
+			extract_actual_weight(&Ok(from_actual_ref_time(Some(7))), &pre),
+			Weight::from_parts(7, 0)
+		);
+		assert_eq!(
+			extract_actual_weight(&Ok(from_actual_ref_time(Some(1000))), &pre),
+			Weight::from_parts(1000, 0)
+		);
+		assert_eq!(
+			extract_actual_weight(
+				&Err(DispatchError::BadOrigin.with_weight(Weight::from_parts(9, 0))),
+				&pre
+			),
+			Weight::from_parts(9, 0)
+		);
+	}
+
+	#[test]
+	fn extract_actual_weight_caps_at_pre_weight() {
+		let pre = DispatchInfo { weight: Weight::from_parts(1000, 0), ..Default::default() };
+		assert_eq!(
+			extract_actual_weight(&Ok(from_actual_ref_time(Some(1250))), &pre),
+			Weight::from_parts(1000, 0)
+		);
+		assert_eq!(
+			extract_actual_weight(
+				&Err(DispatchError::BadOrigin.with_weight(Weight::from_parts(1300, 0))),
+				&pre
+			),
+			Weight::from_parts(1000, 0),
+		);
+	}
+
+	#[test]
+	fn extract_actual_pays_fee_works() {
+		let pre = DispatchInfo { weight: Weight::from_parts(1000, 0), ..Default::default() };
+		assert_eq!(extract_actual_pays_fee(&Ok(from_actual_ref_time(Some(7))), &pre), Pays::Yes);
+		assert_eq!(
+			extract_actual_pays_fee(&Ok(from_actual_ref_time(Some(1000)).into()), &pre),
+			Pays::Yes
+		);
+		assert_eq!(
+			extract_actual_pays_fee(&Ok(from_post_weight_info(Some(1000), Pays::Yes)), &pre),
+			Pays::Yes
+		);
+		assert_eq!(
+			extract_actual_pays_fee(&Ok(from_post_weight_info(Some(1000), Pays::No)), &pre),
+			Pays::No
+		);
+		assert_eq!(
+			extract_actual_pays_fee(
+				&Err(DispatchError::BadOrigin.with_weight(Weight::from_parts(9, 0))),
+				&pre
+			),
+			Pays::Yes
+		);
+		assert_eq!(
+			extract_actual_pays_fee(
+				&Err(DispatchErrorWithPostInfo {
+					post_info: PostDispatchInfo { actual_weight: None, pays_fee: Pays::No },
+					error: DispatchError::BadOrigin,
+				}),
+				&pre
+			),
+			Pays::No
+		);
+
+		let pre = DispatchInfo {
+			weight: Weight::from_parts(1000, 0),
+			pays_fee: Pays::No,
+			..Default::default()
+		};
+		assert_eq!(extract_actual_pays_fee(&Ok(from_actual_ref_time(Some(7))), &pre), Pays::No);
+		assert_eq!(extract_actual_pays_fee(&Ok(from_actual_ref_time(Some(1000))), &pre), Pays::No);
+		assert_eq!(
+			extract_actual_pays_fee(&Ok(from_post_weight_info(Some(1000), Pays::Yes)), &pre),
+			Pays::No
+		);
+	}
+}
+
+#[cfg(test)]
+mod per_dispatch_class_tests {
+	use super::*;
+	use sp_runtime::traits::Zero;
+	use DispatchClass::*;
+
+	#[test]
+	fn add_works() {
+		let a = PerDispatchClass {
+			normal: (5, 10).into(),
+			operational: (20, 30).into(),
+			mandatory: Weight::MAX,
+		};
+		assert_eq!(
+			a.clone()
+				.add((20, 5).into(), Normal)
+				.add((10, 10).into(), Operational)
+				.add((u64::MAX, 3).into(), Mandatory),
+			PerDispatchClass {
+				normal: (25, 15).into(),
+				operational: (30, 40).into(),
+				mandatory: Weight::MAX
+			}
+		);
+		let b = a
+			.add(Weight::MAX, Normal)
+			.add(Weight::MAX, Operational)
+			.add(Weight::MAX, Mandatory);
+		assert_eq!(
+			b,
+			PerDispatchClass {
+				normal: Weight::MAX,
+				operational: Weight::MAX,
+				mandatory: Weight::MAX
+			}
+		);
+		assert_eq!(b.total(), Weight::MAX);
+	}
+
+	#[test]
+	fn accrue_works() {
+		let mut a = PerDispatchClass::default();
+
+		a.accrue((10, 15).into(), Normal);
+		assert_eq!(a.normal, (10, 15).into());
+		assert_eq!(a.total(), (10, 15).into());
+
+		a.accrue((20, 25).into(), Operational);
+		assert_eq!(a.operational, (20, 25).into());
+		assert_eq!(a.total(), (30, 40).into());
+
+		a.accrue((30, 35).into(), Mandatory);
+		assert_eq!(a.mandatory, (30, 35).into());
+		assert_eq!(a.total(), (60, 75).into());
+
+		a.accrue((u64::MAX, 10).into(), Operational);
+		assert_eq!(a.operational, (u64::MAX, 35).into());
+		assert_eq!(a.total(), (u64::MAX, 85).into());
+
+		a.accrue((10, u64::MAX).into(), Normal);
+		assert_eq!(a.normal, (20, u64::MAX).into());
+		assert_eq!(a.total(), Weight::MAX);
+	}
+
+	#[test]
+	fn reduce_works() {
+		let mut a = PerDispatchClass {
+			normal: (10, u64::MAX).into(),
+			mandatory: (u64::MAX, 10).into(),
+			operational: (20, 20).into(),
+		};
+
+		a.reduce((5, 100).into(), Normal);
+		assert_eq!(a.normal, (5, u64::MAX - 100).into());
+		assert_eq!(a.total(), (u64::MAX, u64::MAX - 70).into());
+
+		a.reduce((15, 5).into(), Operational);
+		assert_eq!(a.operational, (5, 15).into());
+		assert_eq!(a.total(), (u64::MAX, u64::MAX - 75).into());
+
+		a.reduce((50, 0).into(), Mandatory);
+		assert_eq!(a.mandatory, (u64::MAX - 50, 10).into());
+		assert_eq!(a.total(), (u64::MAX - 40, u64::MAX - 75).into());
+
+		a.reduce((u64::MAX, 100).into(), Operational);
+		assert!(a.operational.is_zero());
+		assert_eq!(a.total(), (u64::MAX - 45, u64::MAX - 90).into());
+
+		a.reduce((5, u64::MAX).into(), Normal);
+		assert!(a.normal.is_zero());
+		assert_eq!(a.total(), (u64::MAX - 50, 10).into());
+	}
+
+	#[test]
+	fn checked_accrue_works() {
+		let mut a = PerDispatchClass::default();
+
+		a.checked_accrue((1, 2).into(), Normal).unwrap();
+		a.checked_accrue((3, 4).into(), Operational).unwrap();
+		a.checked_accrue((5, 6).into(), Mandatory).unwrap();
+		a.checked_accrue((7, 8).into(), Operational).unwrap();
+		a.checked_accrue((9, 0).into(), Normal).unwrap();
+
+		assert_eq!(
+			a,
+			PerDispatchClass {
+				normal: (10, 2).into(),
+				operational: (10, 12).into(),
+				mandatory: (5, 6).into(),
+			}
+		);
+
+		a.checked_accrue((u64::MAX - 10, u64::MAX - 2).into(), Normal).unwrap();
+		a.checked_accrue((0, 0).into(), Normal).unwrap();
+		a.checked_accrue((1, 0).into(), Normal).unwrap_err();
+		a.checked_accrue((0, 1).into(), Normal).unwrap_err();
+
+		assert_eq!(
+			a,
+			PerDispatchClass {
+				normal: Weight::MAX,
+				operational: (10, 12).into(),
+				mandatory: (5, 6).into(),
+			}
+		);
+	}
+
+	#[test]
+	fn checked_accrue_does_not_modify_on_error() {
+		let mut a = PerDispatchClass {
+			normal: 0.into(),
+			operational: Weight::MAX / 2 + 2.into(),
+			mandatory: 10.into(),
+		};
+
+		a.checked_accrue(Weight::MAX / 2, Operational).unwrap_err();
+		a.checked_accrue(Weight::MAX - 9.into(), Mandatory).unwrap_err();
+		a.checked_accrue(Weight::MAX, Normal).unwrap(); // This one works
+
+		assert_eq!(
+			a,
+			PerDispatchClass {
+				normal: Weight::MAX,
+				operational: Weight::MAX / 2 + 2.into(),
+				mandatory: 10.into(),
+			}
+		);
+	}
+
+	#[test]
+	fn total_works() {
+		assert!(PerDispatchClass::default().total().is_zero());
+
+		assert_eq!(
+			PerDispatchClass {
+				normal: 0.into(),
+				operational: (10, 20).into(),
+				mandatory: (20, u64::MAX).into(),
+			}
+			.total(),
+			(30, u64::MAX).into()
+		);
+
+		assert_eq!(
+			PerDispatchClass {
+				normal: (u64::MAX - 10, 10).into(),
+				operational: (3, u64::MAX).into(),
+				mandatory: (4, u64::MAX).into(),
+			}
+			.total(),
+			(u64::MAX - 3, u64::MAX).into()
+		);
+	}
+}
diff --git a/substrate/frame/support/src/dispatch_context.rs b/substrate/frame/support/src/dispatch_context.rs
new file mode 100644
index 0000000000000000000000000000000000000000..31278ea9f81946baf3d57e75c50e79c5ca25d2ea
--- /dev/null
+++ b/substrate/frame/support/src/dispatch_context.rs
@@ -0,0 +1,232 @@
+// 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.
+
+//! Provides functions to interact with the dispatch context.
+//!
+//! A Dispatch context is created by calling [`run_in_context`] and then the given closure will be
+//! executed in this dispatch context. Everyting run in this `closure` will have access to the same
+//! dispatch context. This also applies to nested calls of [`run_in_context`]. The dispatch context
+//! can be used to store and retrieve information locally in this context. The dispatch context can
+//! be accessed by using [`with_context`]. This function will execute the given closure and give it
+//! access to the value stored in the dispatch context.
+//!
+//! # FRAME integration
+//!
+//! The FRAME macros implement [`UnfilteredDispatchable`](crate::traits::UnfilteredDispatchable) for
+//! each pallet `Call` enum. Part of this implementation is the call to [`run_in_context`], so that
+//! each call to
+//! [`UnfilteredDispatchable::dispatch_bypass_filter`](crate::traits::UnfilteredDispatchable::dispatch_bypass_filter)
+//! or [`Dispatchable::dispatch`](crate::dispatch::Dispatchable::dispatch) will run in a dispatch
+//! context.
+//!
+//! # Example
+//!
+//! ```
+//! use frame_support::dispatch_context::{with_context, run_in_context};
+//!
+//! // Not executed in a dispatch context, so it should return `None`.
+//! assert!(with_context::<(), _>(|_| println!("Hello")).is_none());
+//!
+//! // Run it in a dispatch context and `with_context` returns `Some(_)`.
+//! run_in_context(|| {
+//!     assert!(with_context::<(), _>(|_| println!("Hello")).is_some());
+//! });
+//!
+//! #[derive(Default)]
+//! struct CustomContext(i32);
+//!
+//! run_in_context(|| {
+//!     with_context::<CustomContext, _>(|v| {
+//!         // Intitialize the value to the default value.
+//!         assert_eq!(0, v.or_default().0);
+//!         v.or_default().0 = 10;
+//!     });
+//!
+//!     with_context::<CustomContext, _>(|v| {
+//!         // We are still in the same context and can still access the set value.
+//!         assert_eq!(10, v.or_default().0);
+//!     });
+//!
+//!     run_in_context(|| {
+//!         with_context::<CustomContext, _>(|v| {
+//!             // A nested call of `run_in_context` stays in the same dispatch context
+//!             assert_eq!(10, v.or_default().0);
+//!         })
+//!     })
+//! });
+//!
+//! run_in_context(|| {
+//!     with_context::<CustomContext, _>(|v| {
+//!         // We left the other context and created a new one, so we should be back
+//!         // to our default value.
+//!         assert_eq!(0, v.or_default().0);
+//!     });
+//! });
+//! ```
+//!
+//! In your pallet you will only have to use [`with_context`], because as described above
+//! [`run_in_context`] will be handled by FRAME for you.
+
+use sp_std::{
+	any::{Any, TypeId},
+	boxed::Box,
+	collections::btree_map::{BTreeMap, Entry},
+};
+
+environmental::environmental!(DISPATCH_CONTEXT: BTreeMap<TypeId, Box<dyn Any>>);
+
+/// Abstraction over some optional value `T` that is stored in the dispatch context.
+pub struct Value<'a, T> {
+	value: Option<&'a mut T>,
+	new_value: Option<T>,
+}
+
+impl<T> Value<'_, T> {
+	/// Get the value as reference.
+	pub fn get(&self) -> Option<&T> {
+		self.new_value.as_ref().or_else(|| self.value.as_ref().map(|v| *v as &T))
+	}
+
+	/// Get the value as mutable reference.
+	pub fn get_mut(&mut self) -> Option<&mut T> {
+		self.new_value.as_mut().or_else(|| self.value.as_mut().map(|v| *v as &mut T))
+	}
+
+	/// Set to the given value.
+	///
+	/// [`Self::get`] and [`Self::get_mut`] will return `new_value` afterwards.
+	pub fn set(&mut self, new_value: T) {
+		self.value = None;
+		self.new_value = Some(new_value);
+	}
+
+	/// Returns a mutable reference to the value.
+	///
+	/// If the internal value isn't initialized, this will set it to [`Default::default()`] before
+	/// returning the mutable reference.
+	pub fn or_default(&mut self) -> &mut T
+	where
+		T: Default,
+	{
+		if let Some(v) = &mut self.value {
+			return v
+		}
+
+		self.new_value.get_or_insert_with(|| Default::default())
+	}
+
+	/// Clear the internal value.
+	///
+	/// [`Self::get`] and [`Self::get_mut`] will return `None` afterwards.
+	pub fn clear(&mut self) {
+		self.new_value = None;
+		self.value = None;
+	}
+}
+
+/// Runs the given `callback` in the dispatch context and gives access to some user defined value.
+///
+/// Passes the a mutable reference of [`Value`] to the callback. The value will be of type `T` and
+/// is identified using the [`TypeId`] of `T`. This means that `T` should be some unique type to
+/// make the value unique. If no value is set yet [`Value::get()`] and [`Value::get_mut()`] will
+/// return `None`. It is totally valid to have some `T` that is shared between different callers to
+/// have access to the same value.
+///
+/// Returns `None` if the current context is not a dispatch context. To create a context it is
+/// required to call [`run_in_context`] with the closure to execute in this context. So, for example
+/// in tests it could be that there isn't any dispatch context or when calling a dispatchable like a
+/// normal Rust function from some FRAME hook.
+pub fn with_context<T: 'static, R>(callback: impl FnOnce(&mut Value<T>) -> R) -> Option<R> {
+	DISPATCH_CONTEXT::with(|c| match c.entry(TypeId::of::<T>()) {
+		Entry::Occupied(mut o) => {
+			let value = o.get_mut().downcast_mut::<T>();
+
+			if value.is_none() {
+				log::error!(
+					"Failed to downcast value for type {} in dispatch context!",
+					sp_std::any::type_name::<T>(),
+				);
+			}
+
+			let mut value = Value { value, new_value: None };
+			let res = callback(&mut value);
+
+			if value.value.is_none() && value.new_value.is_none() {
+				o.remove();
+			} else if let Some(new_value) = value.new_value {
+				o.insert(Box::new(new_value) as Box<_>);
+			}
+
+			res
+		},
+		Entry::Vacant(v) => {
+			let mut value = Value { value: None, new_value: None };
+
+			let res = callback(&mut value);
+
+			if let Some(new_value) = value.new_value {
+				v.insert(Box::new(new_value) as Box<_>);
+			}
+
+			res
+		},
+	})
+}
+
+/// Run the given closure `run` in a dispatch context.
+///
+/// Nested calls to this function will execute `run` in the same dispatch context as the initial
+/// call to this function. In other words, all nested calls of this function will be done in the
+/// same dispatch context.
+pub fn run_in_context<R>(run: impl FnOnce() -> R) -> R {
+	DISPATCH_CONTEXT::using_once(&mut Default::default(), run)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn dispatch_context_works() {
+		// No context, so we don't execute
+		assert!(with_context::<(), _>(|_| ()).is_none());
+
+		let ret = run_in_context(|| with_context::<(), _>(|_| 1).unwrap());
+		assert_eq!(1, ret);
+
+		#[derive(Default)]
+		struct Context(i32);
+
+		let res = run_in_context(|| {
+			with_context::<Context, _>(|v| {
+				assert_eq!(0, v.or_default().0);
+
+				v.or_default().0 = 100;
+			});
+
+			run_in_context(|| {
+				run_in_context(|| {
+					run_in_context(|| with_context::<Context, _>(|v| v.or_default().0).unwrap())
+				})
+			})
+		});
+
+		// Ensure that the initial value set in the context is also accessible after nesting the
+		// `run_in_context` calls.
+		assert_eq!(100, res);
+	}
+}
diff --git a/substrate/frame/support/src/genesis_builder_helper.rs b/substrate/frame/support/src/genesis_builder_helper.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d4144a4d9fd19090cc35e50d7b216090e3908299
--- /dev/null
+++ b/substrate/frame/support/src/genesis_builder_helper.rs
@@ -0,0 +1,41 @@
+// 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.
+
+//! Helper functions for implementing [`sp_genesis_builder::GenesisBuilder`] for runtimes.
+//!
+//! Provides common logic. For more info refer to [`sp_genesis_builder::GenesisBuilder`].
+
+use frame_support::traits::BuildGenesisConfig;
+use sp_genesis_builder::Result as BuildResult;
+use sp_runtime::format_runtime_string;
+
+/// Get the default `GenesisConfig` as a JSON blob. For more info refer to
+/// [`sp_genesis_builder::GenesisBuilder::create_default_config`]
+pub fn create_default_config<GC: BuildGenesisConfig>() -> sp_std::vec::Vec<u8> {
+	serde_json::to_string(&GC::default())
+		.expect("serialization to json is expected to work. qed.")
+		.into_bytes()
+}
+
+/// Build `GenesisConfig` from a JSON blob not using any defaults and store it in the storage. For
+/// more info refer to [`sp_genesis_builder::GenesisBuilder::build_config`].
+pub fn build_config<GC: BuildGenesisConfig>(json: sp_std::vec::Vec<u8>) -> BuildResult {
+	let gc = serde_json::from_slice::<GC>(&json)
+		.map_err(|e| format_runtime_string!("Invalid JSON blob: {}", e))?;
+	<GC as BuildGenesisConfig>::build(&gc);
+	Ok(())
+}
diff --git a/substrate/frame/support/src/hash.rs b/substrate/frame/support/src/hash.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9c48f4b187ad3666ed5fc44229656c35b84e0a81
--- /dev/null
+++ b/substrate/frame/support/src/hash.rs
@@ -0,0 +1,222 @@
+// 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.
+
+//! Hash utilities.
+
+use codec::{Codec, MaxEncodedLen};
+use sp_io::hashing::{blake2_128, blake2_256, twox_128, twox_256, twox_64};
+use sp_metadata_ir as metadata_ir;
+use sp_std::prelude::Vec;
+
+// This trait must be kept coherent with frame-support-procedural HasherKind usage
+pub trait Hashable: Sized {
+	fn blake2_128(&self) -> [u8; 16];
+	fn blake2_256(&self) -> [u8; 32];
+	fn blake2_128_concat(&self) -> Vec<u8>;
+	fn twox_128(&self) -> [u8; 16];
+	fn twox_256(&self) -> [u8; 32];
+	fn twox_64_concat(&self) -> Vec<u8>;
+	fn identity(&self) -> Vec<u8>;
+}
+
+impl<T: Codec> Hashable for T {
+	fn blake2_128(&self) -> [u8; 16] {
+		self.using_encoded(blake2_128)
+	}
+	fn blake2_256(&self) -> [u8; 32] {
+		self.using_encoded(blake2_256)
+	}
+	fn blake2_128_concat(&self) -> Vec<u8> {
+		self.using_encoded(Blake2_128Concat::hash)
+	}
+	fn twox_128(&self) -> [u8; 16] {
+		self.using_encoded(twox_128)
+	}
+	fn twox_256(&self) -> [u8; 32] {
+		self.using_encoded(twox_256)
+	}
+	fn twox_64_concat(&self) -> Vec<u8> {
+		self.using_encoded(Twox64Concat::hash)
+	}
+	fn identity(&self) -> Vec<u8> {
+		self.encode()
+	}
+}
+
+/// Hasher to use to hash keys to insert to storage.
+pub trait StorageHasher: 'static {
+	const METADATA: metadata_ir::StorageHasherIR;
+	type Output: AsRef<[u8]>;
+	fn hash(x: &[u8]) -> Self::Output;
+
+	/// The max length of the final hash, for the given key type.
+	fn max_len<K: MaxEncodedLen>() -> usize;
+}
+
+/// Hasher to use to hash keys to insert to storage.
+///
+/// Reversible hasher store the encoded key after the hash part.
+pub trait ReversibleStorageHasher: StorageHasher {
+	/// Split the hash part out of the input.
+	///
+	/// I.e. for input `&[hash ++ key ++ some]` returns `&[key ++ some]`
+	fn reverse(x: &[u8]) -> &[u8];
+}
+
+/// Store the key directly.
+pub struct Identity;
+impl StorageHasher for Identity {
+	const METADATA: metadata_ir::StorageHasherIR = metadata_ir::StorageHasherIR::Identity;
+	type Output = Vec<u8>;
+	fn hash(x: &[u8]) -> Vec<u8> {
+		x.to_vec()
+	}
+	fn max_len<K: MaxEncodedLen>() -> usize {
+		K::max_encoded_len()
+	}
+}
+impl ReversibleStorageHasher for Identity {
+	fn reverse(x: &[u8]) -> &[u8] {
+		x
+	}
+}
+
+/// Hash storage keys with `concat(twox64(key), key)`
+pub struct Twox64Concat;
+impl StorageHasher for Twox64Concat {
+	const METADATA: metadata_ir::StorageHasherIR = metadata_ir::StorageHasherIR::Twox64Concat;
+	type Output = Vec<u8>;
+	fn hash(x: &[u8]) -> Vec<u8> {
+		twox_64(x).iter().chain(x.iter()).cloned().collect::<Vec<_>>()
+	}
+	fn max_len<K: MaxEncodedLen>() -> usize {
+		K::max_encoded_len().saturating_add(8)
+	}
+}
+impl ReversibleStorageHasher for Twox64Concat {
+	fn reverse(x: &[u8]) -> &[u8] {
+		if x.len() < 8 {
+			log::error!("Invalid reverse: hash length too short");
+			return &[]
+		}
+		&x[8..]
+	}
+}
+
+/// Hash storage keys with `concat(blake2_128(key), key)`
+pub struct Blake2_128Concat;
+impl StorageHasher for Blake2_128Concat {
+	const METADATA: metadata_ir::StorageHasherIR = metadata_ir::StorageHasherIR::Blake2_128Concat;
+	type Output = Vec<u8>;
+	fn hash(x: &[u8]) -> Vec<u8> {
+		blake2_128(x).iter().chain(x.iter()).cloned().collect::<Vec<_>>()
+	}
+	fn max_len<K: MaxEncodedLen>() -> usize {
+		K::max_encoded_len().saturating_add(16)
+	}
+}
+impl ReversibleStorageHasher for Blake2_128Concat {
+	fn reverse(x: &[u8]) -> &[u8] {
+		if x.len() < 16 {
+			log::error!("Invalid reverse: hash length too short");
+			return &[]
+		}
+		&x[16..]
+	}
+}
+
+/// Hash storage keys with blake2 128
+pub struct Blake2_128;
+impl StorageHasher for Blake2_128 {
+	const METADATA: metadata_ir::StorageHasherIR = metadata_ir::StorageHasherIR::Blake2_128;
+	type Output = [u8; 16];
+	fn hash(x: &[u8]) -> [u8; 16] {
+		blake2_128(x)
+	}
+	fn max_len<K: MaxEncodedLen>() -> usize {
+		16
+	}
+}
+
+/// Hash storage keys with blake2 256
+pub struct Blake2_256;
+impl StorageHasher for Blake2_256 {
+	const METADATA: metadata_ir::StorageHasherIR = metadata_ir::StorageHasherIR::Blake2_256;
+	type Output = [u8; 32];
+	fn hash(x: &[u8]) -> [u8; 32] {
+		blake2_256(x)
+	}
+	fn max_len<K: MaxEncodedLen>() -> usize {
+		32
+	}
+}
+
+/// Hash storage keys with twox 128
+pub struct Twox128;
+impl StorageHasher for Twox128 {
+	const METADATA: metadata_ir::StorageHasherIR = metadata_ir::StorageHasherIR::Twox128;
+	type Output = [u8; 16];
+	fn hash(x: &[u8]) -> [u8; 16] {
+		twox_128(x)
+	}
+	fn max_len<K: MaxEncodedLen>() -> usize {
+		16
+	}
+}
+
+/// Hash storage keys with twox 256
+pub struct Twox256;
+impl StorageHasher for Twox256 {
+	const METADATA: metadata_ir::StorageHasherIR = metadata_ir::StorageHasherIR::Twox256;
+	type Output = [u8; 32];
+	fn hash(x: &[u8]) -> [u8; 32] {
+		twox_256(x)
+	}
+	fn max_len<K: MaxEncodedLen>() -> usize {
+		32
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_twox_64_concat() {
+		let r = Twox64Concat::hash(b"foo");
+		assert_eq!(r.split_at(8), (&twox_128(b"foo")[..8], &b"foo"[..]))
+	}
+
+	#[test]
+	fn test_blake2_128_concat() {
+		let r = Blake2_128Concat::hash(b"foo");
+		assert_eq!(r.split_at(16), (&blake2_128(b"foo")[..], &b"foo"[..]))
+	}
+
+	#[test]
+	fn max_lengths() {
+		use codec::Encode;
+		let encoded_0u32 = &0u32.encode()[..];
+		assert_eq!(Twox64Concat::hash(encoded_0u32).len(), Twox64Concat::max_len::<u32>());
+		assert_eq!(Twox128::hash(encoded_0u32).len(), Twox128::max_len::<u32>());
+		assert_eq!(Twox256::hash(encoded_0u32).len(), Twox256::max_len::<u32>());
+		assert_eq!(Blake2_128::hash(encoded_0u32).len(), Blake2_128::max_len::<u32>());
+		assert_eq!(Blake2_128Concat::hash(encoded_0u32).len(), Blake2_128Concat::max_len::<u32>());
+		assert_eq!(Blake2_256::hash(encoded_0u32).len(), Blake2_256::max_len::<u32>());
+		assert_eq!(Identity::hash(encoded_0u32).len(), Identity::max_len::<u32>());
+	}
+}
diff --git a/substrate/frame/support/src/inherent.rs b/substrate/frame/support/src/inherent.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8889c93809c7a2104f414391209074d98ec654df
--- /dev/null
+++ b/substrate/frame/support/src/inherent.rs
@@ -0,0 +1,96 @@
+// 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.
+
+pub use sp_inherents::{
+	CheckInherentsResult, InherentData, InherentIdentifier, IsFatalError, MakeFatalError,
+};
+
+/// A pallet that provides or verifies an inherent extrinsic will implement this trait.
+///
+/// The pallet may provide an inherent, verify an inherent, or both provide and verify.
+///
+/// Briefly, inherent extrinsics ("inherents") are extrinsics that are added to a block by the block
+/// producer. See [`sp_inherents`] for more documentation on inherents.
+pub trait ProvideInherent {
+	/// The call type of the pallet.
+	type Call;
+	/// The error returned by `check_inherent`.
+	type Error: codec::Encode + IsFatalError;
+	/// The inherent identifier used by this inherent.
+	const INHERENT_IDENTIFIER: self::InherentIdentifier;
+
+	/// Create an inherent out of the given `InherentData`.
+	///
+	/// NOTE: All checks necessary to ensure that the inherent is correct and that can be done in
+	/// the runtime should happen in the returned `Call`.
+	/// E.g. if this provides the timestamp, the call will check that the given timestamp is
+	/// increasing the old timestamp by more than a minimum and it will also check that the
+	/// timestamp hasn't already been set in the current block.
+	fn create_inherent(data: &InherentData) -> Option<Self::Call>;
+
+	/// Determines whether this inherent is required in this block.
+	///
+	/// - `Ok(None)` indicates that this inherent is not required in this block. The default
+	/// implementation returns this.
+	///
+	/// - `Ok(Some(e))` indicates that this inherent is required in this block. `construct_runtime!`
+	/// will call this function in its implementation of `fn check_extrinsics`.
+	/// If the inherent is not present, it will return `e`.
+	///
+	/// - `Err(_)` indicates that this function failed and further operations should be aborted.
+	///
+	/// NOTE: If the inherent is required then the runtime asserts that the block contains at least
+	/// one inherent for which:
+	/// * type is [`Self::Call`],
+	/// * [`Self::is_inherent`] returns true.
+	///
+	/// NOTE: This is currently only checked by block producers, not all full nodes.
+	fn is_inherent_required(_: &InherentData) -> Result<Option<Self::Error>, Self::Error> {
+		Ok(None)
+	}
+
+	/// Check whether the given inherent is valid. Checking the inherent is optional and can be
+	/// omitted by using the default implementation.
+	///
+	/// When checking an inherent, the first parameter represents the inherent that is actually
+	/// included in the block by its author. Whereas the second parameter represents the inherent
+	/// data that the verifying node calculates.
+	///
+	/// This is intended to allow for checks that cannot be done within the runtime such as, e.g.,
+	/// the timestamp.
+	///
+	/// # Warning
+	///
+	/// This check is not guaranteed to be run by all full nodes and cannot be relied upon for
+	/// ensuring that the block is correct.
+	fn check_inherent(_: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
+		Ok(())
+	}
+
+	/// Return whether the call is an inherent call.
+	///
+	/// NOTE: Signed extrinsics are not inherents, but a signed extrinsic with the given call
+	/// variant can be dispatched.
+	///
+	/// # Warning
+	///
+	/// In FRAME, inherents are enforced to be executed before other extrinsics. For this reason,
+	/// pallets with unsigned transactions **must ensure** that no unsigned transaction call
+	/// is an inherent call, when implementing `ValidateUnsigned::validate_unsigned`.
+	/// Otherwise block producers can produce invalid blocks by including them after non inherents.
+	fn is_inherent(call: &Self::Call) -> bool;
+}
diff --git a/substrate/frame/support/src/instances.rs b/substrate/frame/support/src/instances.rs
new file mode 100644
index 0000000000000000000000000000000000000000..396018d5cbd5289db9c7c6e89d861adee4b2df9a
--- /dev/null
+++ b/substrate/frame/support/src/instances.rs
@@ -0,0 +1,113 @@
+// 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.
+
+//! Some instance placeholder to be used in [`frame_support::pallet`] attribute macro.
+//!
+//! [`frame_support::pallet`] attribute macro does only requires the instance generic `I` to be
+//! static (contrary to `decl_*` macro which requires instance generic to implement
+//! [`frame_support::traits::Instance`]).
+//!
+//! Thus support provides some instance types to be used, This allow some instantiable pallet to
+//! depend on specific instance of another:
+//! ```
+//! # mod another_pallet { pub trait Config<I: 'static = ()> {} }
+//! pub trait Config<I: 'static = ()>: another_pallet::Config<I> {}
+//! ```
+//!
+//! NOTE: [`frame_support::pallet`] will reexport them inside the module, in order to make them
+//! accessible to [`frame_support::construct_runtime`].
+
+/// `Instance1` to be used for instantiable palllets defined with the
+/// [`#[pallet]`](`frame_support::pallet`) macro. Instances 2-16 are also available but are hidden
+/// from docs.
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance1;
+
+/// `Instance2` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance2;
+
+/// `Instance3` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance3;
+
+/// `Instance4` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance4;
+
+/// `Instance5` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance5;
+
+/// `Instance6` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance6;
+
+/// `Instance7` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance7;
+
+/// `Instance8` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance8;
+
+/// `Instance9` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance9;
+
+/// `Instance10` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance10;
+
+/// `Instance11` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance11;
+
+/// `Instance12` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance12;
+
+/// `Instance13` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance13;
+
+/// `Instance14` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance14;
+
+/// `Instance15` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance15;
+
+/// `Instance16` to be used for instantiable palllets defined with the `#[pallet]` macro.
+#[doc(hidden)]
+#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
+pub struct Instance16;
diff --git a/substrate/frame/support/src/lib.rs b/substrate/frame/support/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a2a7e5ebc485fd01218d33ede91a9b7aa2d7150d
--- /dev/null
+++ b/substrate/frame/support/src/lib.rs
@@ -0,0 +1,2212 @@
+// 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.
+
+//! Support code for the runtime.
+//!
+//! ## Note on Tuple Traits
+//!
+//! Many of the traits defined in [`traits`] have auto-implementations on tuples as well. Usually,
+//! the tuple is a function of number of pallets in the runtime. By default, the traits are
+//! implemented for tuples of up to 64 items.
+//
+// If you have more pallets in your runtime, or for any other reason need more, enabled `tuples-96`
+// or the `tuples-128` complication flag. Note that these features *will increase* the compilation
+// of this crate.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// Export ourself as `frame_support` to make tests happy.
+extern crate self as frame_support;
+
+/// Private exports that are being used by macros.
+///
+/// The exports are not stable and should not be relied on.
+#[doc(hidden)]
+pub mod __private {
+	pub use codec;
+	pub use frame_metadata as metadata;
+	pub use log;
+	pub use paste;
+	pub use scale_info;
+	pub use serde;
+	pub use sp_core::{OpaqueMetadata, Void};
+	pub use sp_core_hashing_proc_macro;
+	pub use sp_io::{self, storage::root as storage_root};
+	pub use sp_metadata_ir as metadata_ir;
+	#[cfg(feature = "std")]
+	pub use sp_runtime::{bounded_btree_map, bounded_vec};
+	pub use sp_runtime::{RuntimeDebug, StateVersion};
+	#[cfg(feature = "std")]
+	pub use sp_state_machine::BasicExternalities;
+	pub use sp_std;
+	pub use sp_tracing;
+	pub use tt_call::*;
+}
+
+#[macro_use]
+pub mod dispatch;
+pub mod crypto;
+pub mod dispatch_context;
+mod hash;
+pub mod inherent;
+pub mod instances;
+pub mod migrations;
+pub mod storage;
+#[cfg(test)]
+mod tests;
+pub mod traits;
+pub mod weights;
+#[doc(hidden)]
+pub mod unsigned {
+	#[doc(hidden)]
+	pub use crate::sp_runtime::traits::ValidateUnsigned;
+	#[doc(hidden)]
+	pub use crate::sp_runtime::transaction_validity::{
+		TransactionSource, TransactionValidity, TransactionValidityError, UnknownTransaction,
+	};
+}
+
+#[cfg(any(feature = "std", feature = "runtime-benchmarks", feature = "try-runtime", test))]
+pub use self::storage::storage_noop_guard::StorageNoopGuard;
+pub use self::{
+	dispatch::{Callable, Parameter},
+	hash::{
+		Blake2_128, Blake2_128Concat, Blake2_256, Hashable, Identity, ReversibleStorageHasher,
+		StorageHasher, Twox128, Twox256, Twox64Concat,
+	},
+	storage::{
+		bounded_btree_map::BoundedBTreeMap,
+		bounded_btree_set::BoundedBTreeSet,
+		bounded_vec::{BoundedSlice, BoundedVec},
+		migration,
+		weak_bounded_vec::WeakBoundedVec,
+		IterableStorageDoubleMap, IterableStorageMap, IterableStorageNMap, StorageDoubleMap,
+		StorageMap, StorageNMap, StoragePrefixedMap, StorageValue,
+	},
+};
+pub use sp_runtime::{
+	self, print, traits::Printable, ConsensusEngineId, MAX_MODULE_ERROR_ENCODED_SIZE,
+};
+
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::TypeId;
+
+/// A unified log target for support operations.
+pub const LOG_TARGET: &str = "runtime::frame-support";
+
+/// A type that cannot be instantiated.
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)]
+pub enum Never {}
+
+/// A pallet identifier. These are per pallet and should be stored in a registry somewhere.
+#[derive(Clone, Copy, Eq, PartialEq, Encode, Decode, TypeInfo)]
+pub struct PalletId(pub [u8; 8]);
+
+impl TypeId for PalletId {
+	const TYPE_ID: [u8; 4] = *b"modl";
+}
+
+/// Generate a [`#[pallet::storage]`](pallet_macros::storage) alias outside of a pallet.
+///
+/// This storage alias works similarly to the [`#[pallet::storage]`](pallet_macros::storage)
+/// attribute macro. It supports [`StorageValue`](storage::types::StorageValue),
+/// [`StorageMap`](storage::types::StorageMap),
+/// [`StorageDoubleMap`](storage::types::StorageDoubleMap) and
+/// [`StorageNMap`](storage::types::StorageNMap). The main difference to the normal
+/// [`#[pallet::storage]`](pallet_macros::storage) is the flexibility around declaring the
+/// storage prefix to use. The storage prefix determines where to find the value in the
+/// storage. [`#[pallet::storage]`](pallet_macros::storage) uses the name of the pallet as
+/// declared in [`construct_runtime!`].
+///
+/// The flexibility around declaring the storage prefix makes this macro very useful for
+/// writing migrations etc.
+///
+/// # Examples
+///
+/// There are different ways to declare the `prefix` to use. The `prefix` type can either be
+/// declared explicetly by passing it to the macro as an attribute or by letting the macro
+/// guess on what the `prefix` type is. The `prefix` is always passed as the first generic
+/// argument to the type declaration. When using [`#[pallet::storage]`](pallet_macros::storage)
+/// this first generic argument is always `_`. Besides declaring the `prefix`, the rest of the
+/// type declaration works as with [`#[pallet::storage]`](pallet_macros::storage).
+///
+/// 1. Use the `verbatim` prefix type. This prefix type uses the given identifier as the
+/// `prefix`:
+#[doc = docify::embed!("src/tests/storage_alias.rs", verbatim_attribute)]
+///
+/// 2. Use the `pallet_name` prefix type. This prefix type uses the name of the pallet as
+/// configured in    [`construct_runtime!`] as the `prefix`:
+#[doc = docify::embed!("src/tests/storage_alias.rs", pallet_name_attribute)]
+/// It requires that the given prefix type implements
+/// [`PalletInfoAccess`](traits::PalletInfoAccess) (which is always the case for FRAME pallet
+/// structs). In the example above, `Pallet<T>` is the prefix type.
+///
+/// 3. Use the `dynamic` prefix type. This prefix type calls [`Get::get()`](traits::Get::get)
+///    to get the `prefix`:
+#[doc = docify::embed!("src/tests/storage_alias.rs", dynamic_attribute)]
+/// It requires that the given prefix type implements [`Get<'static str>`](traits::Get).
+///
+/// 4. Let the macro "guess" what kind of prefix type to use. This only supports verbatim or
+///    pallet name. The macro uses the presence of generic arguments to the prefix type as an
+///    indication that it should use the pallet name as the `prefix`:
+#[doc = docify::embed!("src/tests/storage_alias.rs", storage_alias_guess)]
+pub use frame_support_procedural::storage_alias;
+
+pub use frame_support_procedural::derive_impl;
+
+/// Create new implementations of the [`Get`](crate::traits::Get) trait.
+///
+/// The so-called parameter type can be created in four different ways:
+///
+/// - Using `const` to create a parameter type that provides a `const` getter. It is required that
+///   the `value` is const.
+///
+/// - Declare the parameter type without `const` to have more freedom when creating the value.
+///
+/// - Using `storage` to create a storage parameter type. This type is special as it tries to load
+///   the value from the storage under a fixed key. If the value could not be found in the storage,
+///   the given default value will be returned. It is required that the value implements
+///   [`Encode`](codec::Encode) and [`Decode`](codec::Decode). The key for looking up the value in
+///   the storage is built using the following formula:
+///
+///   `twox_128(":" ++ NAME ++ ":")` where `NAME` is the name that is passed as type name.
+///
+/// - Using `static` to create a static parameter type. Its value is being provided by a static
+///   variable with the equivalent name in `UPPER_SNAKE_CASE`. An additional `set` function is
+///   provided in this case to alter the static variable. **This is intended for testing ONLY and is
+///   ONLY available when `std` is enabled.**
+///
+/// # Examples
+///
+/// ```
+/// # use frame_support::traits::Get;
+/// # use frame_support::parameter_types;
+/// // This function cannot be used in a const context.
+/// fn non_const_expression() -> u64 { 99 }
+///
+/// const FIXED_VALUE: u64 = 10;
+/// parameter_types! {
+///    pub const Argument: u64 = 42 + FIXED_VALUE;
+///    /// Visibility of the type is optional
+///    OtherArgument: u64 = non_const_expression();
+///    pub storage StorageArgument: u64 = 5;
+///    pub static StaticArgument: u32 = 7;
+/// }
+///
+/// trait Config {
+///    type Parameter: Get<u64>;
+///    type OtherParameter: Get<u64>;
+///    type StorageParameter: Get<u64>;
+///    type StaticParameter: Get<u32>;
+/// }
+///
+/// struct Runtime;
+/// impl Config for Runtime {
+///    type Parameter = Argument;
+///    type OtherParameter = OtherArgument;
+///    type StorageParameter = StorageArgument;
+///    type StaticParameter = StaticArgument;
+/// }
+///
+/// // In testing, `StaticArgument` can be altered later: `StaticArgument::set(8)`.
+/// ```
+///
+/// # Invalid example:
+///
+/// ```compile_fail
+/// # use frame_support::traits::Get;
+/// # use frame_support::parameter_types;
+/// // This function cannot be used in a const context.
+/// fn non_const_expression() -> u64 { 99 }
+///
+/// parameter_types! {
+///    pub const Argument: u64 = non_const_expression();
+/// }
+/// ```
+#[macro_export]
+macro_rules! parameter_types {
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis const $name:ident $(< $($ty_params:ident),* >)?: $type:ty = $value:expr;
+		$( $rest:tt )*
+	) => (
+		$( #[ $attr ] )*
+		$vis struct $name $(
+			< $($ty_params),* >( $($crate::__private::sp_std::marker::PhantomData<$ty_params>),* )
+		)?;
+		$crate::parameter_types!(IMPL_CONST $name , $type , $value $( $(, $ty_params)* )?);
+		$crate::parameter_types!( $( $rest )* );
+	);
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis $name:ident $(< $($ty_params:ident),* >)?: $type:ty = $value:expr;
+		$( $rest:tt )*
+	) => (
+		$( #[ $attr ] )*
+		$vis struct $name $(
+			< $($ty_params),* >( $($crate::__private::sp_std::marker::PhantomData<$ty_params>),* )
+		)?;
+		$crate::parameter_types!(IMPL $name, $type, $value $( $(, $ty_params)* )?);
+		$crate::parameter_types!( $( $rest )* );
+	);
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis storage $name:ident $(< $($ty_params:ident),* >)?: $type:ty = $value:expr;
+		$( $rest:tt )*
+	) => (
+		$( #[ $attr ] )*
+		$vis struct $name $(
+			< $($ty_params),* >( $($crate::__private::sp_std::marker::PhantomData<$ty_params>),* )
+		)?;
+		$crate::parameter_types!(IMPL_STORAGE $name, $type, $value $( $(, $ty_params)* )?);
+		$crate::parameter_types!( $( $rest )* );
+	);
+	() => ();
+	(IMPL_CONST $name:ident, $type:ty, $value:expr $(, $ty_params:ident)*) => {
+		impl< $($ty_params),* > $name< $($ty_params),* > {
+			/// Returns the value of this parameter type.
+			pub const fn get() -> $type {
+				$value
+			}
+		}
+
+		impl<_I: From<$type> $(, $ty_params)*> $crate::traits::Get<_I> for $name< $($ty_params),* > {
+			fn get() -> _I {
+				_I::from(Self::get())
+			}
+		}
+
+		impl< $($ty_params),* > $crate::traits::TypedGet for $name< $($ty_params),* > {
+			type Type = $type;
+			fn get() -> $type {
+				Self::get()
+			}
+		}
+	};
+	(IMPL $name:ident, $type:ty, $value:expr $(, $ty_params:ident)*) => {
+		impl< $($ty_params),* > $name< $($ty_params),* > {
+			/// Returns the value of this parameter type.
+			pub fn get() -> $type {
+				$value
+			}
+		}
+
+		impl<_I: From<$type>, $(, $ty_params)*> $crate::traits::Get<_I> for $name< $($ty_params),* > {
+			fn get() -> _I {
+				_I::from(Self::get())
+			}
+		}
+
+		impl< $($ty_params),* > $crate::traits::TypedGet for $name< $($ty_params),* > {
+			type Type = $type;
+			fn get() -> $type {
+				Self::get()
+			}
+		}
+	};
+	(IMPL_STORAGE $name:ident, $type:ty, $value:expr $(, $ty_params:ident)*) => {
+		#[allow(unused)]
+		impl< $($ty_params),* > $name< $($ty_params),* > {
+			/// Returns the key for this parameter type.
+			pub fn key() -> [u8; 16] {
+				$crate::__private::sp_core_hashing_proc_macro::twox_128!(b":", $name, b":")
+			}
+
+			/// Set the value of this parameter type in the storage.
+			///
+			/// This needs to be executed in an externalities provided environment.
+			pub fn set(value: &$type) {
+				$crate::storage::unhashed::put(&Self::key(), value);
+			}
+
+			/// Returns the value of this parameter type.
+			///
+			/// This needs to be executed in an externalities provided environment.
+			#[allow(unused)]
+			pub fn get() -> $type {
+				$crate::storage::unhashed::get(&Self::key()).unwrap_or_else(|| $value)
+			}
+		}
+
+		impl<_I: From<$type> $(, $ty_params)*> $crate::traits::Get<_I> for $name< $($ty_params),* > {
+			fn get() -> _I {
+				_I::from(Self::get())
+			}
+		}
+
+		impl< $($ty_params),* > $crate::traits::TypedGet for $name< $($ty_params),* > {
+			type Type = $type;
+			fn get() -> $type {
+				Self::get()
+			}
+		}
+	};
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis static $name:ident: $type:ty = $value:expr;
+		$( $rest:tt )*
+	) => (
+		$crate::parameter_types_impl_thread_local!(
+			$( #[ $attr ] )*
+			$vis static $name: $type = $value;
+		);
+		$crate::parameter_types!( $( $rest )* );
+	);
+}
+
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! parameter_types_impl_thread_local {
+	( $( $any:tt )* ) => {
+		compile_error!("static parameter types is only available in std and for testing.");
+	};
+}
+
+#[cfg(feature = "std")]
+#[macro_export]
+macro_rules! parameter_types_impl_thread_local {
+	(
+		$(
+			$( #[ $attr:meta ] )*
+			$vis:vis static $name:ident: $type:ty = $value:expr;
+		)*
+	) => {
+		$crate::parameter_types_impl_thread_local!(
+			IMPL_THREAD_LOCAL $( $vis, $name, $type, $value, )*
+		);
+		$crate::__private::paste::item! {
+			$crate::parameter_types!(
+				$(
+					$( #[ $attr ] )*
+					$vis $name: $type = [<$name:snake:upper>].with(|v| v.borrow().clone());
+				)*
+			);
+			$(
+				impl $name {
+					/// Set the internal value.
+					pub fn set(t: $type) {
+						[<$name:snake:upper>].with(|v| *v.borrow_mut() = t);
+					}
+
+					/// Mutate the internal value in place.
+					#[allow(unused)]
+					pub fn mutate<R, F: FnOnce(&mut $type) -> R>(mutate: F) -> R{
+						let mut current = Self::get();
+						let result = mutate(&mut current);
+						Self::set(current);
+						result
+					}
+
+					/// Get current value and replace with initial value of the parameter type.
+					#[allow(unused)]
+					pub fn take() -> $type {
+						let current = Self::get();
+						Self::set($value);
+						current
+					}
+				}
+			)*
+		}
+	};
+	(IMPL_THREAD_LOCAL $( $vis:vis, $name:ident, $type:ty, $value:expr, )* ) => {
+		$crate::__private::paste::item! {
+			thread_local! {
+				$(
+					pub static [<$name:snake:upper>]: std::cell::RefCell<$type> =
+						std::cell::RefCell::new($value);
+				)*
+			}
+		}
+	};
+}
+
+/// Macro for easily creating a new implementation of both the `Get` and `Contains` traits. Use
+/// exactly as with `parameter_types`, only the type must be `Ord`.
+#[macro_export]
+macro_rules! ord_parameter_types {
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis const $name:ident: $type:ty = $value:expr;
+		$( $rest:tt )*
+	) => (
+		$( #[ $attr ] )*
+		$vis struct $name;
+		$crate::parameter_types!{IMPL $name , $type , $value}
+		$crate::ord_parameter_types!{IMPL $name , $type , $value}
+		$crate::ord_parameter_types!{ $( $rest )* }
+	);
+	() => ();
+	(IMPL $name:ident , $type:ty , $value:expr) => {
+		impl $crate::traits::SortedMembers<$type> for $name {
+			fn contains(t: &$type) -> bool { &$value == t }
+			fn sorted_members() -> $crate::__private::sp_std::prelude::Vec<$type> { vec![$value] }
+			fn count() -> usize { 1 }
+			#[cfg(feature = "runtime-benchmarks")]
+			fn add(_: &$type) {}
+		}
+		impl $crate::traits::Contains<$type> for $name {
+			fn contains(t: &$type) -> bool { &$value == t }
+		}
+	}
+}
+
+/// Print out a formatted message.
+///
+/// # Example
+///
+/// ```
+/// frame_support::runtime_print!("my value is {}", 3);
+/// ```
+#[macro_export]
+macro_rules! runtime_print {
+	($($arg:tt)+) => {
+		{
+			use core::fmt::Write;
+			let mut w = $crate::__private::sp_std::Writer::default();
+			let _ = core::write!(&mut w, $($arg)+);
+			$crate::__private::sp_io::misc::print_utf8(&w.inner())
+		}
+	}
+}
+
+/// Print out the debuggable type.
+pub fn debug(data: &impl sp_std::fmt::Debug) {
+	runtime_print!("{:?}", data);
+}
+
+#[doc(inline)]
+pub use frame_support_procedural::{
+	construct_runtime, match_and_insert, transactional, PalletError, RuntimeDebugNoBound,
+};
+
+#[doc(hidden)]
+pub use frame_support_procedural::{__create_tt_macro, __generate_dummy_part_checker};
+
+/// Derive [`Clone`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::CloneNoBound;
+/// trait Config {
+/// 		type C: Clone;
+/// }
+///
+/// // Foo implements [`Clone`] because `C` bounds [`Clone`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`Clone`].
+/// #[derive(CloneNoBound)]
+/// struct Foo<T: Config> {
+/// 		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::CloneNoBound;
+
+/// Derive [`Eq`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::{EqNoBound, PartialEqNoBound};
+/// trait Config {
+/// 		type C: Eq;
+/// }
+///
+/// // Foo implements [`Eq`] because `C` bounds [`Eq`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`Eq`].
+/// #[derive(PartialEqNoBound, EqNoBound)]
+/// struct Foo<T: Config> {
+/// 		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::EqNoBound;
+
+/// Derive [`PartialEq`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::PartialEqNoBound;
+/// trait Config {
+/// 		type C: PartialEq;
+/// }
+///
+/// // Foo implements [`PartialEq`] because `C` bounds [`PartialEq`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`PartialEq`].
+/// #[derive(PartialEqNoBound)]
+/// struct Foo<T: Config> {
+/// 		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::PartialEqNoBound;
+
+/// Derive [`Debug`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::DebugNoBound;
+/// # use core::fmt::Debug;
+/// trait Config {
+/// 		type C: Debug;
+/// }
+///
+/// // Foo implements [`Debug`] because `C` bounds [`Debug`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`Debug`].
+/// #[derive(DebugNoBound)]
+/// struct Foo<T: Config> {
+/// 		c: T::C,
+/// }
+/// ```
+pub use frame_support_procedural::DebugNoBound;
+
+/// Derive [`Default`] but do not bound any generic.
+///
+/// This is useful for type generic over runtime:
+/// ```
+/// # use frame_support::DefaultNoBound;
+/// # use core::default::Default;
+/// trait Config {
+/// 	type C: Default;
+/// }
+///
+/// // Foo implements [`Default`] because `C` bounds [`Default`].
+/// // Otherwise compilation will fail with an output telling `c` doesn't implement [`Default`].
+/// #[derive(DefaultNoBound)]
+/// struct Foo<T: Config> {
+/// 	c: T::C,
+/// }
+///
+/// // Also works with enums, by specifying the default with #[default]:
+/// #[derive(DefaultNoBound)]
+/// enum Bar<T: Config> {
+/// 	// Bar will implement Default as long as all of the types within Baz also implement default.
+/// 	#[default]
+/// 	Baz(T::C),
+/// 	Quxx,
+/// }
+/// ```
+pub use frame_support_procedural::DefaultNoBound;
+
+/// Assert the annotated function is executed within a storage transaction.
+///
+/// The assertion is enabled for native execution and when `debug_assertions` are enabled.
+///
+/// # Example
+///
+/// ```
+/// # use frame_support::{
+/// # 	require_transactional, transactional, dispatch::DispatchResult
+/// # };
+///
+/// #[require_transactional]
+/// fn update_all(value: u32) -> DispatchResult {
+/// 	// Update multiple storages.
+/// 	// Return `Err` to indicate should revert.
+/// 	Ok(())
+/// }
+///
+/// #[transactional]
+/// fn safe_update(value: u32) -> DispatchResult {
+/// 	// This is safe
+/// 	update_all(value)
+/// }
+///
+/// fn unsafe_update(value: u32) -> DispatchResult {
+/// 	// this may panic if unsafe_update is not called within a storage transaction
+/// 	update_all(value)
+/// }
+/// ```
+pub use frame_support_procedural::require_transactional;
+
+/// Convert the current crate version into a [`CrateVersion`](crate::traits::CrateVersion).
+///
+/// It uses the `CARGO_PKG_VERSION_MAJOR`, `CARGO_PKG_VERSION_MINOR` and
+/// `CARGO_PKG_VERSION_PATCH` environment variables to fetch the crate version.
+/// This means that the [`CrateVersion`](crate::traits::CrateVersion)
+/// object will correspond to the version of the crate the macro is called in!
+///
+/// # Example
+///
+/// ```
+/// # use frame_support::{traits::CrateVersion, crate_to_crate_version};
+/// const Version: CrateVersion = crate_to_crate_version!();
+/// ```
+pub use frame_support_procedural::crate_to_crate_version;
+
+/// Return Err of the expression: `return Err($expression);`.
+///
+/// Used as `fail!(expression)`.
+#[macro_export]
+macro_rules! fail {
+	( $y:expr ) => {{
+		return Err($y.into())
+	}};
+}
+
+/// Evaluate `$x:expr` and if not true return `Err($y:expr)`.
+///
+/// Used as `ensure!(expression_to_ensure, expression_to_return_on_false)`.
+#[macro_export]
+macro_rules! ensure {
+	( $x:expr, $y:expr $(,)? ) => {{
+		if !$x {
+			$crate::fail!($y);
+		}
+	}};
+}
+
+/// Evaluate an expression, assert it returns an expected `Err` value and that
+/// runtime storage has not been mutated (i.e. expression is a no-operation).
+///
+/// Used as `assert_noop(expression_to_assert, expected_error_expression)`.
+#[macro_export]
+macro_rules! assert_noop {
+	(
+		$x:expr,
+		$y:expr $(,)?
+	) => {
+		let h = $crate::__private::storage_root($crate::__private::StateVersion::V1);
+		$crate::assert_err!($x, $y);
+		assert_eq!(
+			h,
+			$crate::__private::storage_root($crate::__private::StateVersion::V1),
+			"storage has been mutated"
+		);
+	};
+}
+
+/// Evaluate any expression and assert that runtime storage has not been mutated
+/// (i.e. expression is a storage no-operation).
+///
+/// Used as `assert_storage_noop(expression_to_assert)`.
+#[macro_export]
+macro_rules! assert_storage_noop {
+	(
+		$x:expr
+	) => {
+		let h = $crate::__private::storage_root($crate::__private::StateVersion::V1);
+		$x;
+		assert_eq!(h, $crate::__private::storage_root($crate::__private::StateVersion::V1));
+	};
+}
+
+/// Assert an expression returns an error specified.
+///
+/// Used as `assert_err!(expression_to_assert, expected_error_expression)`
+#[macro_export]
+macro_rules! assert_err {
+	( $x:expr , $y:expr $(,)? ) => {
+		assert_eq!($x, Err($y.into()));
+	};
+}
+
+/// Assert an expression returns an error specified.
+///
+/// This can be used on `DispatchResultWithPostInfo` when the post info should
+/// be ignored.
+#[macro_export]
+macro_rules! assert_err_ignore_postinfo {
+	( $x:expr , $y:expr $(,)? ) => {
+		$crate::assert_err!($x.map(|_| ()).map_err(|e| e.error), $y);
+	};
+}
+
+/// Assert an expression returns error with the given weight.
+#[macro_export]
+macro_rules! assert_err_with_weight {
+	($call:expr, $err:expr, $weight:expr $(,)? ) => {
+		if let Err(dispatch_err_with_post) = $call {
+			$crate::assert_err!($call.map(|_| ()).map_err(|e| e.error), $err);
+			assert_eq!(dispatch_err_with_post.post_info.actual_weight, $weight);
+		} else {
+			panic!("expected Err(_), got Ok(_).")
+		}
+	};
+}
+
+/// Panic if an expression doesn't evaluate to `Ok`.
+///
+/// Used as `assert_ok!(expression_to_assert, expected_ok_expression)`,
+/// or `assert_ok!(expression_to_assert)` which would assert against `Ok(())`.
+#[macro_export]
+macro_rules! assert_ok {
+	( $x:expr $(,)? ) => {
+		let is = $x;
+		match is {
+			Ok(_) => (),
+			_ => assert!(false, "Expected Ok(_). Got {:#?}", is),
+		}
+	};
+	( $x:expr, $y:expr $(,)? ) => {
+		assert_eq!($x, Ok($y));
+	};
+}
+
+/// Assert that the maximum encoding size does not exceed the value defined in
+/// [`MAX_MODULE_ERROR_ENCODED_SIZE`] during compilation.
+///
+/// This macro is intended to be used in conjunction with `tt_call!`.
+#[macro_export]
+macro_rules! assert_error_encoded_size {
+	{
+		path = [{ $($path:ident)::+ }]
+		runtime = [{ $runtime:ident }]
+		assert_message = [{ $assert_message:literal }]
+		error = [{ $error:ident }]
+	} => {
+		const _: () = assert!(
+			<
+				$($path::)+$error<$runtime> as $crate::traits::PalletError
+			>::MAX_ENCODED_SIZE <= $crate::MAX_MODULE_ERROR_ENCODED_SIZE,
+			$assert_message
+		);
+	};
+	{
+		path = [{ $($path:ident)::+ }]
+		runtime = [{ $runtime:ident }]
+		assert_message = [{ $assert_message:literal }]
+	} => {};
+}
+
+#[doc(hidden)]
+pub use serde::{Deserialize, Serialize};
+
+#[doc(hidden)]
+#[cfg(not(no_std))]
+pub use macro_magic;
+
+/// Private module re-exporting items used by frame support macros.
+#[doc(hidden)]
+pub mod _private {
+	pub use sp_inherents;
+}
+
+/// Prelude to be used for pallet testing, for ease of use.
+#[cfg(feature = "std")]
+pub mod testing_prelude {
+	pub use super::{
+		assert_err, assert_err_ignore_postinfo, assert_err_with_weight, assert_error_encoded_size,
+		assert_noop, assert_ok, assert_storage_noop, parameter_types, traits::Get,
+	};
+	pub use sp_arithmetic::assert_eq_error_rate;
+	pub use sp_runtime::{bounded_btree_map, bounded_vec};
+}
+
+/// Prelude to be used alongside pallet macro, for ease of use.
+pub mod pallet_prelude {
+	pub use crate::{
+		dispatch::{
+			DispatchClass, DispatchError, DispatchResult, DispatchResultWithPostInfo, Parameter,
+			Pays,
+		},
+		ensure,
+		inherent::{InherentData, InherentIdentifier, ProvideInherent},
+		storage,
+		storage::{
+			bounded_vec::BoundedVec,
+			types::{
+				CountedStorageMap, CountedStorageNMap, Key as NMapKey, OptionQuery, ResultQuery,
+				StorageDoubleMap, StorageMap, StorageNMap, StorageValue, ValueQuery,
+			},
+			StorageList,
+		},
+		traits::{
+			BuildGenesisConfig, ConstU32, EnsureOrigin, Get, GetDefault, GetStorageVersion, Hooks,
+			IsType, PalletInfoAccess, StorageInfoTrait, StorageVersion, TypedGet,
+		},
+		Blake2_128, Blake2_128Concat, Blake2_256, CloneNoBound, DebugNoBound, EqNoBound, Identity,
+		PartialEqNoBound, RuntimeDebugNoBound, Twox128, Twox256, Twox64Concat,
+	};
+	pub use codec::{Decode, Encode, MaxEncodedLen};
+	pub use frame_support::pallet_macros::*;
+	/// The optional attribute `#[inject_runtime_type]` can be attached to `RuntimeCall`,
+	/// `RuntimeEvent`, `RuntimeOrigin` or `PalletInfo` in an impl statement that has
+	/// `#[register_default_impl]` attached to indicate that this item is generated by
+	/// `construct_runtime`.
+	///
+	/// Attaching this attribute to such an item ensures that the combined impl generated via
+	/// [`#[derive_impl(..)]`](`macro@super::derive_impl`)  will use the correct type
+	/// auto-generated by `construct_runtime!`.
+	#[doc = docify::embed!("src/tests/inject_runtime_type.rs", derive_impl_works_with_runtime_type_injection)]
+	///
+	/// However, if `no_aggregated_types` is specified while using
+	/// `[`#[derive_impl(..)]`](`macro@super::derive_impl`)`, then these items are attached
+	/// verbatim to the combined impl.
+	#[doc = docify::embed!("src/tests/inject_runtime_type.rs", derive_impl_works_with_no_aggregated_types)]
+	pub use frame_support_procedural::inject_runtime_type;
+	pub use frame_support_procedural::register_default_impl;
+	pub use scale_info::TypeInfo;
+	pub use sp_inherents::MakeFatalError;
+	pub use sp_runtime::{
+		traits::{MaybeSerializeDeserialize, Member, ValidateUnsigned},
+		transaction_validity::{
+			InvalidTransaction, TransactionLongevity, TransactionPriority, TransactionSource,
+			TransactionTag, TransactionValidity, TransactionValidityError, UnknownTransaction,
+			ValidTransaction,
+		},
+		RuntimeDebug, MAX_MODULE_ERROR_ENCODED_SIZE,
+	};
+	pub use sp_std::marker::PhantomData;
+	pub use sp_weights::Weight;
+}
+
+/// The `pallet` attribute macro defines a pallet that can be used with
+/// [`construct_runtime!`]. It must be attached to a module named `pallet` as follows:
+///
+/// ```ignore
+/// #[pallet]
+/// pub mod pallet {
+/// 	...
+/// }
+/// ```
+///
+/// Note that various types can be automatically imported using
+/// [`frame_support::pallet_prelude`] and `frame_system::pallet_prelude`:
+///
+/// ```ignore
+/// #[pallet]
+/// pub mod pallet {
+/// 	use frame_support::pallet_prelude::*;
+/// 	use frame_system::pallet_prelude::*;
+/// 	...
+/// }
+/// ```
+///
+/// # pallet::* Attributes
+///
+/// The `pallet` macro will parse any items within your `pallet` module that are annotated with
+/// `#[pallet::*]` attributes. Some of these attributes are mandatory and some are optional,
+/// and they can attach to different types of items within your pallet depending on the
+/// attribute in question. The full list of `#[pallet::*]` attributes is shown below in the
+/// order in which they are mentioned in this document:
+///
+/// * [`pallet::pallet`](#pallet-struct-placeholder-palletpallet-mandatory)
+/// * [`pallet::config`](#config-trait-palletconfig-mandatory)
+/// * [`pallet::constant`](#palletconstant)
+/// * [`pallet::disable_frame_system_supertrait_check`](#disable_supertrait_check)
+/// * [`pallet::generate_store($vis trait Store)`](#palletgenerate_storevis-trait-store)
+/// * [`pallet::storage_version`](#palletstorage_version)
+/// * [`pallet::hooks`](#hooks-pallethooks-optional)
+/// * [`pallet::call`](#call-palletcall-optional)
+/// * [`pallet::weight($expr)`](#palletweightexpr)
+/// * [`pallet::compact`](#palletcompact-some_arg-some_type)
+/// * [`pallet::call_index($idx)`](#palletcall_indexidx)
+/// * [`pallet::extra_constants`](#extra-constants-palletextra_constants-optional)
+/// * [`pallet::error`](#error-palleterror-optional)
+/// * [`pallet::event`](#event-palletevent-optional)
+/// * [`pallet::generate_deposit($visibility fn
+///   deposit_event)`](#palletgenerate_depositvisibility-fn-deposit_event)
+/// * [`pallet::storage`](#storage-palletstorage-optional)
+/// * [`pallet::getter(fn $my_getter_fn_name)`](#palletgetterfn-my_getter_fn_name-optional)
+/// * [`pallet::storage_prefix = "SomeName"`](#palletstorage_prefix--somename-optional)
+/// * [`pallet::unbounded`](#palletunbounded-optional)
+/// * [`pallet::whitelist_storage`](#palletwhitelist_storage-optional)
+/// * [`cfg(..)`](#cfg-for-storage) (on storage items)
+/// * [`pallet::type_value`](#type-value-pallettype_value-optional)
+/// * [`pallet::genesis_config`](#genesis-config-palletgenesis_config-optional)
+/// * [`pallet::genesis_build`](#genesis-build-palletgenesis_build-optional)
+/// * [`pallet::inherent`](#inherent-palletinherent-optional)
+/// * [`pallet::validate_unsigned`](#validate-unsigned-palletvalidate_unsigned-optional)
+/// * [`pallet::origin`](#origin-palletorigin-optional)
+/// * [`pallet::composite_enum`](#composite-enum-palletcomposite_enum-optional)
+///
+/// Note that at compile-time, the `#[pallet]` macro will analyze and expand all of these
+/// attributes, ultimately removing their AST nodes before they can be parsed as real
+/// attribute macro calls. This means that technically we do not need attribute macro
+/// definitions for any of these attributes, however, for consistency and discoverability
+/// reasons, we still maintain stub attribute macro definitions for all of these attributes in
+/// the [`pallet_macros`] module which is automatically included in all pallets as part of the
+/// pallet prelude. The actual "work" for all of these attribute macros can be found in the
+/// macro expansion for `#[pallet]`.
+///
+/// Also note that in this document, pallet attributes are explained using the syntax of
+/// non-instantiable pallets. For an example of an instantiable pallet, see [this
+/// example](#example-of-an-instantiable-pallet).
+///
+/// # Dev Mode (`#[pallet(dev_mode)]`)
+///
+/// Specifying the argument `dev_mode` on the `#[pallet]` or `#[frame_support::pallet]`
+/// attribute attached to your pallet module will allow you to enable dev mode for a pallet.
+/// The aim of dev mode is to loosen some of the restrictions and requirements placed on
+/// production pallets for easy tinkering and development. Dev mode pallets should not be used
+/// in production. Enabling dev mode has the following effects:
+///
+/// * Weights no longer need to be specified on every `#[pallet::call]` declaration. By
+///   default, dev mode pallets will assume a weight of zero (`0`) if a weight is not
+///   specified. This is equivalent to specifying `#[weight(0)]` on all calls that do not
+///   specify a weight.
+/// * Call indices no longer need to be specified on every `#[pallet::call]` declaration. By
+///   default, dev mode pallets will assume a call index based on the order of the call.
+/// * All storages are marked as unbounded, meaning you do not need to implement
+///   `MaxEncodedLen` on storage types. This is equivalent to specifying `#[pallet::unbounded]`
+///   on all storage type definitions.
+/// * Storage hashers no longer need to be specified and can be replaced by `_`. In dev mode,
+///   these will be replaced by `Blake2_128Concat`. In case of explicit key-binding, `Hasher`
+///   can simply be ignored when in `dev_mode`.
+///
+/// Note that the `dev_mode` argument can only be supplied to the `#[pallet]` or
+/// `#[frame_support::pallet]` attribute macro that encloses your pallet module. This argument
+/// cannot be specified anywhere else, including but not limited to the `#[pallet::pallet]`
+/// attribute macro.
+///
+/// <div class="example-wrap" style="display:inline-block"><pre class="compile_fail"
+/// style="white-space:normal;font:inherit;">
+/// <strong>WARNING</strong>:
+/// You should not deploy or use dev mode pallets in production. Doing so can break your chain
+/// and therefore should never be done. Once you are done tinkering, you should remove the
+/// 'dev_mode' argument from your #[pallet] declaration and fix any compile errors before
+/// attempting to use your pallet in a production scenario.
+/// </pre></div>
+///
+/// # Pallet struct placeholder: `#[pallet::pallet]` (mandatory)
+///
+/// The pallet struct placeholder `#[pallet::pallet]` is mandatory and allows you to specify
+/// pallet information.
+///
+/// The struct must be defined as follows:
+/// ```ignore
+/// #[pallet::pallet]
+/// pub struct Pallet<T>(_);
+/// ```
+/// I.e. a regular struct definition named `Pallet`, with generic T and no where clause.
+///
+/// ## Macro expansion:
+///
+/// The macro adds this attribute to the struct definition:
+/// ```ignore
+/// #[derive(
+/// 	frame_support::CloneNoBound,
+/// 	frame_support::EqNoBound,
+/// 	frame_support::PartialEqNoBound,
+/// 	frame_support::RuntimeDebugNoBound,
+/// )]
+/// ```
+/// and replaces the type `_` with `PhantomData<T>`. It also implements on the pallet:
+/// * [`GetStorageVersion`](`traits::GetStorageVersion`)
+/// * [`OnGenesis`](`traits::OnGenesis`): contains some logic to write the pallet version into
+///   storage.
+/// * `PalletErrorTypeInfo`: provides the type information for the pallet error, if defined.
+///
+/// It declares `type Module` type alias for `Pallet`, used by `construct_runtime`.
+///
+/// It implements [`PalletInfoAccess`](`traits::PalletInfoAccess') on `Pallet` to ease access
+/// to pallet information given by [`frame_support::traits::PalletInfo`]. (The implementation
+/// uses the associated type `frame_system::Config::PalletInfo`).
+///
+/// It implements [`StorageInfoTrait`](`traits::StorageInfoTrait`) on `Pallet` which give
+/// information about all storages.
+///
+/// If the attribute `generate_store` is set then the macro creates the trait `Store` and
+/// implements it on `Pallet`.
+///
+/// If the attribute `set_storage_max_encoded_len` is set then the macro calls
+/// [`StorageInfoTrait`](`traits::StorageInfoTrait`) for each storage in the implementation of
+/// [`StorageInfoTrait`](`traits::StorageInfoTrait`) for the pallet. Otherwise it implements
+/// [`StorageInfoTrait`](`traits::StorageInfoTrait`) for the pallet using the
+/// [`PartialStorageInfoTrait`](`traits::PartialStorageInfoTrait`) implementation of storages.
+///
+/// # Config trait: `#[pallet::config]` (mandatory)
+///
+/// The mandatory attribute `#[pallet::config]` defines the configurable options for the
+/// pallet.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::config]
+/// pub trait Config: frame_system::Config + $optionally_some_other_supertraits
+/// $optional_where_clause
+/// {
+/// ...
+/// }
+/// ```
+///
+/// I.e. a regular trait definition named `Config`, with the supertrait
+/// `frame_system::pallet::Config`, and optionally other supertraits and a where clause.
+/// (Specifying other supertraits here is known as [tight
+/// coupling](https://docs.substrate.io/reference/how-to-guides/pallet-design/use-tight-coupling/))
+///
+/// The associated type `RuntimeEvent` is reserved. If defined, it must have the bounds
+/// `From<Event>` and `IsType<<Self as frame_system::Config>::RuntimeEvent>`.
+///
+/// [`pallet::event`](`frame_support::pallet_macros::event`) must be present if `RuntimeEvent`
+/// exists as a config item in your `#[pallet::config]`.
+///
+/// Also see [`pallet::config`](`frame_support::pallet_macros::config`)
+///
+/// ## `pallet::constant`
+///
+/// The `#[pallet::constant]` attribute can be used to add an associated type trait bounded by
+/// [`Get`](crate::traits::Get) from [`pallet::config`](#palletconfig) into metadata, e.g.:
+///
+/// ```ignore
+/// #[pallet::config]
+/// pub trait Config: frame_system::Config {
+/// 	#[pallet::constant]
+/// 	type Foo: Get<u32>;
+/// }
+/// ```
+///
+/// Also see [`pallet::constant`](`frame_support::pallet_macros::constant`)
+///
+/// ## `pallet::disable_frame_system_supertrait_check`
+/// <a name="disable_supertrait_check"></a>
+///
+/// To bypass the `frame_system::Config` supertrait check, use the attribute
+/// `pallet::disable_frame_system_supertrait_check`, e.g.:
+///
+/// ```ignore
+/// #[pallet::config]
+/// #[pallet::disable_frame_system_supertrait_check]
+/// pub trait Config: pallet_timestamp::Config {}
+/// ```
+///
+/// NOTE: Bypassing the `frame_system::Config` supertrait check is typically desirable when you
+/// want to write an alternative to the `frame_system` pallet.
+///
+/// Also see
+/// [`pallet::disable_frame_system_supertrait_check`](`frame_support::pallet_macros::disable_frame_system_supertrait_check`)
+///
+/// ## Macro expansion:
+///
+/// The macro expands pallet constant metadata with the information given by
+/// `#[pallet::constant]`.
+///
+/// # `pallet::generate_store($vis trait Store)`
+///
+/// To generate a `Store` trait associating all storages, annotate your `Pallet` struct with
+/// the attribute `#[pallet::generate_store($vis trait Store)]`, e.g.:
+///
+/// ```ignore
+/// #[pallet::pallet]
+/// #[pallet::generate_store(pub(super) trait Store)]
+/// pub struct Pallet<T>(_);
+/// ```
+/// More precisely, the `Store` trait contains an associated type for each storage. It is
+/// implemented for `Pallet` allowing access to the storage from pallet struct.
+///
+/// Thus when defining a storage named `Foo`, it can later be accessed from `Pallet` using
+/// `<Pallet as Store>::Foo`.
+///
+/// NOTE: this attribute is only valid when applied _directly_ to your `Pallet` struct
+/// definition.
+///
+/// Also see [`pallet::generate_store`](`frame_support::pallet_macros::generate_store`).
+///
+/// # `pallet::storage_version`
+///
+/// Because the [`pallet::pallet`](#pallet-struct-placeholder-palletpallet-mandatory) macro
+/// implements [`traits::GetStorageVersion`], the current storage version needs to be
+/// communicated to the macro. This can be done by using the `pallet::storage_version`
+/// attribute:
+///
+/// ```ignore
+/// const STORAGE_VERSION: StorageVersion = StorageVersion::new(5);
+///
+/// #[pallet::pallet]
+/// #[pallet::storage_version(STORAGE_VERSION)]
+/// pub struct Pallet<T>(_);
+/// ```
+///
+/// If not present, the current storage version is set to the default value.
+///
+/// Also see [`pallet::storage_version`](`frame_support::pallet_macros::storage_version`)
+///
+/// # Hooks: `#[pallet::hooks]` (optional)
+///
+/// The `pallet::hooks` attribute allows you to specify a `Hooks` implementation for `Pallet`
+/// that specifies pallet-specific logic.
+///
+/// The item the attribute attaches to must be defined as follows:
+/// ```ignore
+/// #[pallet::hooks]
+/// impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> $optional_where_clause {
+///     ...
+/// }
+/// ```
+/// I.e. a regular trait implementation with generic bound: `T: Config`, for the trait
+/// `Hooks<BlockNumberFor<T>>` (they are defined in preludes), for the type `Pallet<T>` and
+/// with an optional where clause.
+///
+/// If no `#[pallet::hooks]` exists, then the following default implementation is
+/// automatically generated:
+/// ```ignore
+/// #[pallet::hooks]
+/// impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+/// ```
+///
+/// Also see [`pallet::hooks`](`frame_support::pallet_macros::hooks`)
+///
+/// # Call: `#[pallet::call]` (optional)
+///
+/// Implementation of pallet dispatchables.
+///
+/// Item must be defined as:
+/// ```ignore
+/// #[pallet::call]
+/// impl<T: Config> Pallet<T> {
+/// 	/// $some_doc
+/// 	#[pallet::weight($ExpressionResultingInWeight)]
+/// 	pub fn $fn_name(
+/// 		origin: OriginFor<T>,
+/// 		$some_arg: $some_type,
+/// 		// or with compact attribute: #[pallet::compact] $some_arg: $some_type,
+/// 		...
+/// 	) -> DispatchResultWithPostInfo { // or `-> DispatchResult`
+/// 		...
+/// 	}
+/// 	...
+/// }
+/// ```
+/// I.e. a regular type implementation, with generic `T: Config`, on type `Pallet<T>`, with
+/// an optional where clause.
+///
+/// ## `#[pallet::weight($expr)]`
+///
+/// Each dispatchable needs to define a weight with `#[pallet::weight($expr)]` attribute, the
+/// first argument must be `origin: OriginFor<T>`.
+///
+/// Also see [`pallet::weight`](`frame_support::pallet_macros::weight`)
+///
+/// ### `#[pallet::compact] $some_arg: $some_type`
+///
+/// Compact encoding for arguments can be achieved via `#[pallet::compact]`. The function must
+/// return a `DispatchResultWithPostInfo` or `DispatchResult`.
+///
+/// Also see [`pallet::compact`](`frame_support::pallet_macros::compact`)
+///
+/// ## `#[pallet::call_index($idx)]`
+///
+/// Each dispatchable may also be annotated with the `#[pallet::call_index($idx)]` attribute,
+/// which explicitly defines the codec index for the dispatchable function in the `Call` enum.
+///
+/// All call indexes start from 0, until it encounters a dispatchable function with a defined
+/// call index. The dispatchable function that lexically follows the function with a defined
+/// call index will have that call index, but incremented by 1, e.g. if there are 3
+/// dispatchable functions `fn foo`, `fn bar` and `fn qux` in that order, and only `fn bar`
+/// has a call index of 10, then `fn qux` will have an index of 11, instead of 1.
+///
+/// **WARNING**: modifying dispatchables, changing their order, removing some, etc., must be
+/// done with care. Indeed this will change the outer runtime call type (which is an enum with
+/// one variant per pallet), this outer runtime call can be stored on-chain (e.g. in
+/// `pallet-scheduler`). Thus migration might be needed. To mitigate against some of this, the
+/// `#[pallet::call_index($idx)]` attribute can be used to fix the order of the dispatchable so
+/// that the `Call` enum encoding does not change after modification. As a general rule of
+/// thumb, it is therefore adventageous to always add new calls to the end so you can maintain
+/// the existing order of calls.
+///
+/// Also see [`pallet::call_index`](`frame_support::pallet_macros::call_index`)
+///
+/// # Extra constants: `#[pallet::extra_constants]` (optional)
+///
+/// Allows you to define some extra constants to be added into constant metadata.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::extra_constants]
+/// impl<T: Config> Pallet<T> where $optional_where_clause {
+/// 	/// $some_doc
+/// 	$vis fn $fn_name() -> $some_return_type {
+/// 		...
+/// 	}
+/// 	...
+/// }
+/// ```
+/// I.e. a regular rust `impl` block with some optional where clause and functions with 0 args,
+/// 0 generics, and some return type.
+///
+/// ## Macro expansion
+///
+/// The macro add some extra constants to pallet constant metadata.
+///
+/// Also see: [`pallet::extra_constants`](`frame_support::pallet_macros::extra_constants`)
+///
+/// # Error: `#[pallet::error]` (optional)
+///
+/// The `#[pallet::error]` attribute allows you to define an error enum that will be returned
+/// from the dispatchable when an error occurs. The information for this error type is then
+/// stored in metadata.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::error]
+/// pub enum Error<T> {
+/// 	/// $some_optional_doc
+/// 	$SomeFieldLessVariant,
+/// 	/// $some_more_optional_doc
+/// 	$SomeVariantWithOneField(FieldType),
+/// 	...
+/// }
+/// ```
+/// I.e. a regular enum named `Error`, with generic `T` and fieldless or multiple-field
+/// variants.
+///
+/// Any field type in the enum variants must implement [`scale_info::TypeInfo`] in order to be
+/// properly used in the metadata, and its encoded size should be as small as possible,
+/// preferably 1 byte in size in order to reduce storage size. The error enum itself has an
+/// absolute maximum encoded size specified by [`MAX_MODULE_ERROR_ENCODED_SIZE`].
+///
+/// (1 byte can still be 256 different errors. The more specific the error, the easier it is to
+/// diagnose problems and give a better experience to the user. Don't skimp on having lots of
+/// individual error conditions.)
+///
+/// Field types in enum variants must also implement [`PalletError`](traits::PalletError),
+/// otherwise the pallet will fail to compile. Rust primitive types have already implemented
+/// the [`PalletError`](traits::PalletError) trait along with some commonly used stdlib types
+/// such as [`Option`] and [`PhantomData`](`frame_support::dispatch::marker::PhantomData`), and
+/// hence in most use cases, a manual implementation is not necessary and is discouraged.
+///
+/// The generic `T` must not bound anything and a `where` clause is not allowed. That said,
+/// bounds and/or a where clause should not needed for any use-case.
+///
+/// Also see: [`pallet::error`](`frame_support::pallet_macros::error`)
+///
+/// # Event: `#[pallet::event]` (optional)
+///
+/// Allows you to define pallet events. Pallet events are stored under the `system` / `events`
+/// key when the block is applied (and then replaced when the next block writes it's events).
+///
+/// The Event enum must be defined as follows:
+///
+/// ```ignore
+/// #[pallet::event]
+/// #[pallet::generate_deposit($visibility fn deposit_event)] // Optional
+/// pub enum Event<$some_generic> $optional_where_clause {
+/// 	/// Some doc
+/// 	$SomeName($SomeType, $YetanotherType, ...),
+/// 	...
+/// }
+/// ```
+///
+/// I.e. an enum (with named or unnamed fields variant), named `Event`, with generic: none or
+/// `T` or `T: Config`, and optional w here clause.
+///
+/// Each field must implement [`Clone`], [`Eq`], [`PartialEq`], [`Encode`], [`Decode`], and
+/// [`Debug`] (on std only). For ease of use, bound by the trait
+/// [`Member`](`frame_support::pallet_prelude::Member`), available in
+/// frame_support::pallet_prelude.
+///
+/// Also see [`pallet::event`](`frame_support::pallet_macros::event`)
+///
+/// ## `#[pallet::generate_deposit($visibility fn deposit_event)]`
+///
+/// The attribute `#[pallet::generate_deposit($visibility fn deposit_event)]` generates a
+/// helper function on `Pallet` that handles deposit events.
+///
+/// NOTE: For instantiable pallets, the event must be generic over `T` and `I`.
+///
+/// Also see [`pallet::generate_deposit`](`frame_support::pallet_macros::generate_deposit`)
+///
+/// # Storage: `#[pallet::storage]` (optional)
+///
+/// The `#[pallet::storage]` attribute lets you define some abstract storage inside of runtime
+/// storage and also set its metadata. This attribute can be used multiple times.
+///
+/// Item should be defined as:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::getter(fn $getter_name)] // optional
+/// $vis type $StorageName<$some_generic> $optional_where_clause
+/// 	= $StorageType<$generic_name = $some_generics, $other_name = $some_other, ...>;
+/// ```
+///
+/// or with unnamed generic:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::getter(fn $getter_name)] // optional
+/// $vis type $StorageName<$some_generic> $optional_where_clause
+/// 	= $StorageType<_, $some_generics, ...>;
+/// ```
+///
+/// I.e. it must be a type alias, with generics: `T` or `T: Config`. The aliased type must be
+/// one of [`StorageValue`](`pallet_prelude::StorageValue`),
+/// [`StorageMap`](`pallet_prelude::StorageMap`) or
+/// [`StorageDoubleMap`](`pallet_prelude::StorageDoubleMap`). The generic arguments of the
+/// storage type can be given in two manners: named and unnamed. For named generic arguments,
+/// the name for each argument should match the name defined for it on the storage struct:
+/// * [`StorageValue`](`pallet_prelude::StorageValue`) expects `Value` and optionally
+///   `QueryKind` and `OnEmpty`,
+/// * [`StorageMap`](`pallet_prelude::StorageMap`) expects `Hasher`, `Key`, `Value` and
+///   optionally `QueryKind` and `OnEmpty`,
+/// * [`CountedStorageMap`](`pallet_prelude::CountedStorageMap`) expects `Hasher`, `Key`,
+///   `Value` and optionally `QueryKind` and `OnEmpty`,
+/// * [`StorageDoubleMap`](`pallet_prelude::StorageDoubleMap`) expects `Hasher1`, `Key1`,
+///   `Hasher2`, `Key2`, `Value` and optionally `QueryKind` and `OnEmpty`.
+///
+/// For unnamed generic arguments: Their first generic must be `_` as it is replaced by the
+/// macro and other generic must declared as a normal generic type declaration.
+///
+/// The `Prefix` generic written by the macro is generated using
+/// `PalletInfo::name::<Pallet<..>>()` and the name of the storage type. E.g. if runtime names
+/// the pallet "MyExample" then the storage `type Foo<T> = ...` should use the prefix:
+/// `Twox128(b"MyExample") ++ Twox128(b"Foo")`.
+///
+/// For the [`CountedStorageMap`](`pallet_prelude::CountedStorageMap`) variant, the `Prefix`
+/// also implements
+/// [`CountedStorageMapInstance`](`frame_support::storage::types::CountedStorageMapInstance`).
+/// It also associates a [`CounterPrefix`](`pallet_prelude::CounterPrefix'), which is
+/// implemented the same as above, but the storage prefix is prepend with `"CounterFor"`. E.g.
+/// if runtime names the pallet "MyExample" then the storage `type Foo<T> =
+/// CountedStorageaMap<...>` will store its counter at the prefix: `Twox128(b"MyExample") ++
+/// Twox128(b"CounterForFoo")`.
+///
+/// E.g:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// pub(super) type MyStorage<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
+/// ```
+///
+/// In this case the final prefix used by the map is `Twox128(b"MyExample") ++
+/// Twox128(b"OtherName")`.
+///
+/// Also see [`pallet::storage`](`frame_support::pallet_macros::storage`)
+///
+/// ## `#[pallet::getter(fn $my_getter_fn_name)]` (optional)
+///
+/// The optional attribute `#[pallet::getter(fn $my_getter_fn_name)]` allows you to define a
+/// getter function on `Pallet`.
+///
+/// Also see [`pallet::getter`](`frame_support::pallet_macros::getter`)
+///
+/// ## `#[pallet::storage_prefix = "SomeName"]` (optional)
+///
+/// The optional attribute `#[pallet::storage_prefix = "SomeName"]` allows you to define the
+/// storage prefix to use, see how `Prefix` generic is implemented above. This is helpful if
+/// you wish to rename the storage field but don't want to perform a migration.
+///
+/// E.g:
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::storage_prefix = "foo"]
+/// #[pallet::getter(fn my_storage)]
+/// pub(super) type MyStorage<T> = StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
+/// ```
+///
+/// or
+///
+/// ```ignore
+/// #[pallet::storage]
+/// #[pallet::getter(fn my_storage)]
+/// pub(super) type MyStorage<T> = StorageMap<_, Blake2_128Concat, u32, u32>;
+/// ```
+///
+/// Also see [`pallet::storage_prefix`](`frame_support::pallet_macros::storage_prefix`)
+///
+/// ## `#[pallet::unbounded]` (optional)
+///
+/// The optional attribute `#[pallet::unbounded]` declares the storage as unbounded. When
+/// implementating the storage info (when `#[pallet::generate_storage_info]` is specified on
+/// the pallet struct placeholder), the size of the storage will be declared as unbounded. This
+/// can be useful for storage which can never go into PoV (Proof of Validity).
+///
+/// Also see [`pallet::unbounded`](`frame_support::pallet_macros::unbounded`)
+///
+/// ## `#[pallet::whitelist_storage]` (optional)
+///
+/// The optional attribute `#[pallet::whitelist_storage]` will declare the storage as
+/// whitelisted from benchmarking.
+///
+/// See
+/// [`pallet::whitelist_storage`](frame_support::pallet_macros::whitelist_storage)
+/// for more info.
+///
+///	## `#[cfg(..)]` (for storage)
+/// The optional attributes `#[cfg(..)]` allow conditional compilation for the storage.
+///
+/// E.g:
+///
+/// ```ignore
+/// #[cfg(feature = "my-feature")]
+/// #[pallet::storage]
+/// pub(super) type MyStorage<T> = StorageValue<Value = u32>;
+/// ```
+///
+/// All the `cfg` attributes are automatically copied to the items generated for the storage,
+/// i.e. the getter, storage prefix, and the metadata element etc.
+///
+/// Any type placed as the `QueryKind` parameter must implement
+/// [`frame_support::storage::types::QueryKindTrait`]. There are 3 implementations of this
+/// trait by default:
+///
+/// 1. [`OptionQuery`](`frame_support::storage::types::OptionQuery`), the default `QueryKind`
+///    used when this type parameter is omitted. Specifying this as the `QueryKind` would cause
+///    storage map APIs that return a `QueryKind` to instead return an [`Option`], returning
+///    `Some` when a value does exist under a specified storage key, and `None` otherwise.
+/// 2. [`ValueQuery`](`frame_support::storage::types::ValueQuery`) causes storage map APIs that
+///    return a `QueryKind` to instead return the value type. In cases where a value does not
+///    exist under a specified storage key, the `OnEmpty` type parameter on `QueryKindTrait` is
+///    used to return an appropriate value.
+/// 3. [`ResultQuery`](`frame_support::storage::types::ResultQuery`) causes storage map APIs
+///    that return a `QueryKind` to instead return a `Result<T, E>`, with `T` being the value
+///    type and `E` being the pallet error type specified by the `#[pallet::error]` attribute.
+///    In cases where a value does not exist under a specified storage key, an `Err` with the
+///    specified pallet error variant is returned.
+///
+/// NOTE: If the `QueryKind` generic parameter is still generic at this stage or is using some
+/// type alias then the generation of the getter might fail. In this case the getter can be
+/// implemented manually.
+///
+/// NOTE: The generic `Hasher` must implement the [`StorageHasher`] trait (or the type is not
+/// usable at all). We use [`StorageHasher::METADATA`] for the metadata of the hasher of the
+/// storage item. Thus generic hasher is supported.
+///
+/// ## Macro expansion
+///
+/// For each storage item the macro generates a struct named
+/// `_GeneratedPrefixForStorage$NameOfStorage`, and implements
+/// [`StorageInstance`](traits::StorageInstance) on it using the pallet and storage name. It
+/// then uses it as the first generic of the aliased type. For
+/// [`CountedStorageMap`](`pallet_prelude::CountedStorageMap`),
+/// [`CountedStorageMapInstance`](`frame_support::storage::types::CountedStorageMapInstance`)
+/// is implemented, and another similar struct is generated.
+///
+/// For a named generic, the macro will reorder the generics, and remove the names.
+///
+/// The macro implements the function `storage_metadata` on the `Pallet` implementing the
+/// metadata for all storage items based on their kind:
+/// * for a storage value, the type of the value is copied into the metadata
+/// * for a storage map, the type of the values and the key's type is copied into the metadata
+/// * for a storage double map, the type of the values, and the types of `key1` and `key2` are
+///   copied into the metadata.
+///
+/// # Type value: `#[pallet::type_value]` (optional)
+///
+/// The `#[pallet::type_value]` attribute lets you define a struct implementing the
+/// [`Get`](crate::traits::Get) trait to ease use of storage types. This attribute is meant to
+/// be used alongside [`#[pallet::storage]`](#storage-palletstorage-optional) to define a
+/// storage's default value. This attribute can be used multiple times.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::type_value]
+/// fn $MyDefaultName<$some_generic>() -> $default_type $optional_where_clause { $expr }
+/// ```
+///
+/// I.e.: a function definition with generics none or `T: Config` and a returned type.
+///
+/// E.g.:
+///
+/// ```ignore
+/// #[pallet::type_value]
+/// fn MyDefault<T: Config>() -> T::Balance { 3.into() }
+/// ```
+///
+/// Also see [`pallet::type_value`](`frame_support::pallet_macros::type_value`)
+///
+/// # Genesis config: `#[pallet::genesis_config]` (optional)
+///
+/// The `#[pallet::genesis_config]` attribute allows you to define the genesis configuration
+/// for the pallet.
+///
+/// Item is defined as either an enum or a struct. It needs to be public and implement the
+/// trait [`BuildGenesisConfig`](`traits::BuildGenesisConfig`) with
+/// [`#[pallet::genesis_build]`](#genesis-build-palletgenesis_build-optional). The type
+/// generics are constrained to be either none, or `T` or `T: Config`.
+///
+/// E.g:
+///
+/// ```ignore
+/// #[pallet::genesis_config]
+/// pub struct GenesisConfig<T: Config> {
+/// 	_myfield: BalanceOf<T>,
+/// }
+/// ```
+///
+/// Also see [`pallet::genesis_config`](`frame_support::pallet_macros::genesis_config`)
+///
+/// # Genesis build: `#[pallet::genesis_build]` (optional)
+///
+/// The `#[pallet::genesis_build]` attribute allows you to define how `genesis_configuration`
+/// is built. This takes as input the `GenesisConfig` type (as `self`) and constructs the
+/// pallet's initial state.
+///
+/// The impl must be defined as:
+///
+/// ```ignore
+/// #[pallet::genesis_build]
+/// impl<T: Config> GenesisBuild<T> for GenesisConfig<$maybe_generics> {
+/// 	fn build(&self) { $expr }
+/// }
+/// ```
+///
+/// I.e. a trait implementation with generic `T: Config`, of trait `GenesisBuild<T>` on
+/// type `GenesisConfig` with generics none or `T`.
+///
+/// E.g.:
+///
+/// ```ignore
+/// #[pallet::genesis_build]
+/// impl<T: Config> GenesisBuild<T> for GenesisConfig {
+/// 	fn build(&self) {}
+/// }
+/// ```
+///
+/// Also see [`pallet::genesis_build`](`frame_support::pallet_macros::genesis_build`)
+///
+/// # Inherent: `#[pallet::inherent]` (optional)
+///
+/// The `#[pallet::inherent]` attribute allows the pallet to provide some
+/// [inherent](https://docs.substrate.io/fundamentals/transaction-types/#inherent-transactions).
+/// An inherent is some piece of data that is inserted by a block authoring node at block
+/// creation time and can either be accepted or rejected by validators based on whether the
+/// data falls within an acceptable range.
+///
+/// The most common inherent is the `timestamp` that is inserted into every block. Since there
+/// is no way to validate timestamps, validators simply check that the timestamp reported by
+/// the block authoring node falls within an acceptable range.
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::inherent]
+/// impl<T: Config> ProvideInherent for Pallet<T> {
+/// 	// ... regular trait implementation
+/// }
+/// ```
+///
+/// I.e. a trait implementation with bound `T: Config`, of trait
+/// [`ProvideInherent`](`pallet_prelude::ProvideInherent`) for type `Pallet<T>`, and some
+/// optional where clause.
+///
+/// Also see [`pallet::inherent`](`frame_support::pallet_macros::inherent`)
+///
+/// # Validate unsigned: `#[pallet::validate_unsigned]` (optional)
+///
+/// The `#[pallet::validate_unsigned]` attribute allows the pallet to validate some unsigned
+/// transaction:
+///
+/// Item must be defined as:
+///
+/// ```ignore
+/// #[pallet::validate_unsigned]
+/// impl<T: Config> ValidateUnsigned for Pallet<T> {
+/// 	// ... regular trait implementation
+/// }
+/// ```
+///
+/// I.e. a trait implementation with bound `T: Config`, of trait
+/// [`ValidateUnsigned`](`pallet_prelude::ValidateUnsigned`) for type `Pallet<T>`, and some
+/// optional where clause.
+///
+/// NOTE: There is also the [`sp_runtime::traits::SignedExtension`] trait that can be used to
+/// add some specific logic for transaction validation.
+///
+/// Also see [`pallet::validate_unsigned`](`frame_support::pallet_macros::validate_unsigned`)
+///
+/// # Origin: `#[pallet::origin]` (optional)
+///
+/// The `#[pallet::origin]` attribute allows you to define some origin for the pallet.
+///
+/// Item must be either a type alias, an enum, or a struct. It needs to be public.
+///
+/// E.g.:
+///
+/// ```ignore
+/// #[pallet::origin]
+/// pub struct Origin<T>(PhantomData<(T)>);
+/// ```
+///
+/// **WARNING**: modifying origin changes the outer runtime origin. This outer runtime origin
+/// can be stored on-chain (e.g. in `pallet-scheduler`), thus any change must be done with care
+/// as it might require some migration.
+///
+/// NOTE: for instantiable pallets, the origin must be generic over `T` and `I`.
+///
+/// Also see [`pallet::origin`](`frame_support::pallet_macros::origin`)
+///
+/// # Composite enum `#[pallet::composite_enum]` (optional)
+///
+/// The `#[pallet::composite_enum]` attribute allows you to define an enum on the pallet which
+/// will then instruct `construct_runtime` to amalgamate all similarly-named enums from other
+/// pallets into an aggregate enum. This is similar in principle with how the aggregate enum is
+/// generated for `#[pallet::event]` or `#[pallet::error]`.
+///
+/// The item tagged with `#[pallet::composite_enum]` MUST be an enum declaration, and can ONLY
+/// be the following identifiers: `FreezeReason`, `HoldReason`, `LockId` or `SlashReason`.
+/// Custom identifiers are not supported.
+///
+/// NOTE: For ease of usage, when no `#[derive]` attributes are detected, the
+/// `#[pallet::composite_enum]` attribute will automatically derive the following traits for
+/// the enum:
+///
+/// ```ignore
+/// Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, TypeInfo,
+/// RuntimeDebug
+/// ```
+///
+/// The inverse is also true: if there are any #[derive] attributes present for the enum, then
+/// the attribute will not automatically derive any of the traits described above.
+///
+/// # General notes on instantiable pallets
+///
+/// An instantiable pallet is one where Config is generic, i.e. `Config<I>`. This allows
+/// runtime to implement multiple instances of the pallet, by using different types for the
+/// generic. This is the sole purpose of the generic `I`, but because
+/// [`PalletInfo`](`traits::PalletInfo`) requires the `Pallet` placeholder to be static, it is
+/// important to bound by `'static` whenever [`PalletInfo`](`traits::PalletInfo`) can be used.
+/// Additionally, in order to make an instantiable pallet usable as a regular pallet without an
+/// instance, it is important to bound by `= ()` on every type.
+///
+/// Thus impl bound looks like `impl<T: Config<I>, I: 'static>`, and types look like
+/// `SomeType<T, I=()>` or `SomeType<T: Config<I>, I: 'static = ()>`.
+///
+/// # Example of a non-instantiable pallet
+///
+/// ```
+/// pub use pallet::*; // reexport in crate namespace for `construct_runtime!`
+///
+/// #[frame_support::pallet]
+/// // NOTE: The name of the pallet is provided by `construct_runtime` and is used as
+/// // the unique identifier for the pallet's storage. It is not defined in the pallet itself.
+/// pub mod pallet {
+/// 	use frame_support::pallet_prelude::*; // Import various types used in the pallet definition
+/// 	use frame_system::pallet_prelude::*; // Import some system helper types.
+///
+/// 	type BalanceOf<T> = <T as Config>::Balance;
+///
+/// 	// Define the generic parameter of the pallet
+/// 	// The macro parses `#[pallet::constant]` attributes and uses them to generate metadata
+/// 	// for the pallet's constants.
+/// 	#[pallet::config]
+/// 	pub trait Config: frame_system::Config {
+/// 		#[pallet::constant] // put the constant in metadata
+/// 		type MyGetParam: Get<u32>;
+/// 		type Balance: Parameter + MaxEncodedLen + From<u8>;
+/// 		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+/// 	}
+///
+/// 	// Define some additional constant to put into the constant metadata.
+/// 	#[pallet::extra_constants]
+/// 	impl<T: Config> Pallet<T> {
+/// 		/// Some description
+/// 		fn exra_constant_name() -> u128 { 4u128 }
+/// 	}
+///
+/// 	// Define the pallet struct placeholder, various pallet function are implemented on it.
+/// 	#[pallet::pallet]
+/// 	#[pallet::generate_store(pub(super) trait Store)]
+/// 	pub struct Pallet<T>(_);
+///
+/// 	// Implement the pallet hooks.
+/// 	#[pallet::hooks]
+/// 	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+/// 		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+/// 			unimplemented!();
+/// 		}
+///
+/// 		// can implement also: on_finalize, on_runtime_upgrade, offchain_worker, ...
+/// 		// see `Hooks` trait
+/// 	}
+///
+/// 	// Declare Call struct and implement dispatchables.
+/// 	//
+/// 	// WARNING: Each parameter used in functions must implement: Clone, Debug, Eq, PartialEq,
+/// 	// Codec.
+/// 	//
+/// 	// The macro parses `#[pallet::compact]` attributes on function arguments and implements
+/// 	// the `Call` encoding/decoding accordingly.
+/// 	#[pallet::call]
+/// 	impl<T: Config> Pallet<T> {
+/// 		/// Doc comment put in metadata
+/// 		#[pallet::weight(0)] // Defines weight for call (function parameters are in scope)
+/// 		pub fn toto(
+/// 			origin: OriginFor<T>,
+/// 			#[pallet::compact] _foo: u32,
+/// 		) -> DispatchResultWithPostInfo {
+/// 			let _ = origin;
+/// 			unimplemented!();
+/// 		}
+/// 	}
+///
+/// 	// Declare the pallet `Error` enum (this is optional).
+/// 	// The macro generates error metadata using the doc comment on each variant.
+/// 	#[pallet::error]
+/// 	pub enum Error<T> {
+/// 		/// doc comment put into metadata
+/// 		InsufficientProposersBalance,
+/// 	}
+///
+/// 	// Declare pallet Event enum (this is optional).
+/// 	//
+/// 	// WARNING: Each type used in variants must implement: Clone, Debug, Eq, PartialEq, Codec.
+/// 	//
+/// 	// The macro generates event metadata, and derive Clone, Debug, Eq, PartialEq and Codec
+/// 	#[pallet::event]
+/// 	// Generate a funciton on Pallet to deposit an event.
+/// 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+/// 	pub enum Event<T: Config> {
+/// 		/// doc comment put in metadata
+/// 		// `<T as frame_system::Config>::AccountId` is not defined in metadata list, the last
+/// 		// Thus the metadata is `<T as frame_system::Config>::AccountId`.
+/// 		Proposed(<T as frame_system::Config>::AccountId),
+/// 		/// doc
+/// 		// here metadata will be `Balance` as define in metadata list
+/// 		Spending(BalanceOf<T>),
+/// 		// here metadata will be `Other` as define in metadata list
+/// 		Something(u32),
+/// 	}
+///
+/// 	// Define a struct which implements `frame_support::traits::Get<T::Balance>` (optional).
+/// 	#[pallet::type_value]
+/// 	pub(super) fn MyDefault<T: Config>() -> T::Balance { 3.into() }
+///
+/// 	// Declare a storage item. Any amount of storage items can be declared (optional).
+/// 	//
+/// 	// Is expected either `StorageValue`, `StorageMap` or `StorageDoubleMap`.
+/// 	// The macro generates the prefix type and replaces the first generic `_`.
+/// 	//
+/// 	// The macro expands the metadata for the storage item with the type used:
+/// 	// * for a storage value the type of the value is copied into the metadata
+/// 	// * for a storage map the type of the values and the type of the key is copied into the metadata
+/// 	// * for a storage double map the types of the values and keys are copied into the
+/// 	//   metadata.
+/// 	//
+/// 	// NOTE: The generic `Hasher` must implement the `StorageHasher` trait (or the type is not
+/// 	// usable at all). We use [`StorageHasher::METADATA`] for the metadata of the hasher of the
+/// 	// storage item. Thus generic hasher is supported.
+/// 	#[pallet::storage]
+/// 	pub(super) type MyStorageValue<T: Config> =
+/// 		StorageValue<Value = T::Balance, QueryKind = ValueQuery, OnEmpty = MyDefault<T>>;
+///
+/// 	// Another storage declaration
+/// 	#[pallet::storage]
+/// 	#[pallet::getter(fn my_storage)]
+/// 	#[pallet::storage_prefix = "SomeOtherName"]
+/// 	pub(super) type MyStorage<T> =
+/// 		StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
+///
+/// 	// Declare the genesis config (optional).
+/// 	//
+/// 	// The macro accepts either a struct or an enum; it checks that generics are consistent.
+/// 	//
+/// 	// Type must implement the `Default` trait.
+/// 	#[pallet::genesis_config]
+/// 	#[derive(frame_support::DefaultNoBound)]
+/// 	pub struct GenesisConfig<T: Config> {
+/// 	    _config: sp_std::marker::PhantomData<T>,
+/// 		_myfield: u32,
+/// 	}
+///
+/// 	// Declare genesis builder. (This is need only if GenesisConfig is declared)
+/// 	#[pallet::genesis_build]
+/// 	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+/// 		fn build(&self) {}
+/// 	}
+///
+/// 	// Declare a pallet origin (this is optional).
+/// 	//
+/// 	// The macro accept type alias or struct or enum, it checks generics are consistent.
+/// 	#[pallet::origin]
+/// 	pub struct Origin<T>(PhantomData<T>);
+///
+/// 	// Declare validate_unsigned implementation (this is optional).
+/// 	#[pallet::validate_unsigned]
+/// 	impl<T: Config> ValidateUnsigned for Pallet<T> {
+/// 		type Call = Call<T>;
+/// 		fn validate_unsigned(
+/// 			source: TransactionSource,
+/// 			call: &Self::Call
+/// 		) -> TransactionValidity {
+/// 			Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
+/// 		}
+/// 	}
+///
+/// 	// Declare inherent provider for pallet (this is optional).
+/// 	#[pallet::inherent]
+/// 	impl<T: Config> ProvideInherent for Pallet<T> {
+/// 		type Call = Call<T>;
+/// 		type Error = InherentError;
+///
+/// 		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+///
+/// 		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+/// 			unimplemented!();
+/// 		}
+///
+/// 		fn is_inherent(_call: &Self::Call) -> bool {
+/// 			unimplemented!();
+/// 		}
+/// 	}
+///
+/// 	// Regular rust code needed for implementing ProvideInherent trait
+///
+/// 	#[derive(codec::Encode, sp_runtime::RuntimeDebug)]
+/// 	#[cfg_attr(feature = "std", derive(codec::Decode))]
+/// 	pub enum InherentError {
+/// 	}
+///
+/// 	impl sp_inherents::IsFatalError for InherentError {
+/// 		fn is_fatal_error(&self) -> bool {
+/// 			unimplemented!();
+/// 		}
+/// 	}
+///
+/// 	pub const INHERENT_IDENTIFIER: sp_inherents::InherentIdentifier = *b"testpall";
+/// }
+/// ```
+///
+/// # Example of an instantiable pallet
+///
+/// ```
+/// pub use pallet::*;
+///
+/// #[frame_support::pallet]
+/// pub mod pallet {
+/// 	use frame_support::pallet_prelude::*;
+/// 	use frame_system::pallet_prelude::*;
+///
+/// 	type BalanceOf<T, I = ()> = <T as Config<I>>::Balance;
+///
+/// 	#[pallet::config]
+/// 	pub trait Config<I: 'static = ()>: frame_system::Config {
+/// 		#[pallet::constant]
+/// 		type MyGetParam: Get<u32>;
+/// 		type Balance: Parameter + MaxEncodedLen + From<u8>;
+/// 		type RuntimeEvent: From<Event<Self, I>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+/// 	}
+///
+/// 	#[pallet::extra_constants]
+/// 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+/// 		/// Some description
+/// 		fn extra_constant_name() -> u128 { 4u128 }
+/// 	}
+///
+/// 	#[pallet::pallet]
+/// 	#[pallet::generate_store(pub(super) trait Store)]
+/// 	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+///
+/// 	#[pallet::hooks]
+/// 	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+/// 	}
+///
+/// 	#[pallet::call]
+/// 	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+/// 		/// Doc comment put in metadata
+/// 		#[pallet::weight(0)]
+/// 		pub fn toto(origin: OriginFor<T>, #[pallet::compact] _foo: u32) -> DispatchResultWithPostInfo {
+/// 			let _ = origin;
+/// 			unimplemented!();
+/// 		}
+/// 	}
+///
+/// 	#[pallet::error]
+/// 	pub enum Error<T, I = ()> {
+/// 		/// doc comment put into metadata
+/// 		InsufficientProposersBalance,
+/// 	}
+///
+/// 	#[pallet::event]
+/// 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+/// 	pub enum Event<T: Config<I>, I: 'static = ()> {
+/// 		/// doc comment put in metadata
+/// 		Proposed(<T as frame_system::Config>::AccountId),
+/// 		/// doc
+/// 		Spending(BalanceOf<T, I>),
+/// 		Something(u32),
+/// 	}
+///
+/// 	#[pallet::type_value]
+/// 	pub(super) fn MyDefault<T: Config<I>, I: 'static>() -> T::Balance { 3.into() }
+///
+/// 	#[pallet::storage]
+/// 	pub(super) type MyStorageValue<T: Config<I>, I: 'static = ()> =
+/// 		StorageValue<Value = T::Balance, QueryKind = ValueQuery, OnEmpty = MyDefault<T, I>>;
+///
+/// 	#[pallet::storage]
+/// 	#[pallet::getter(fn my_storage)]
+/// 	#[pallet::storage_prefix = "SomeOtherName"]
+/// 	pub(super) type MyStorage<T, I = ()> =
+/// 		StorageMap<Hasher = Blake2_128Concat, Key = u32, Value = u32>;
+///
+/// 	#[pallet::genesis_config]
+/// 	#[derive(frame_support::DefaultNoBound)]
+/// 	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+/// 		 _config: sp_std::marker::PhantomData<(T,I)>,
+/// 		_myfield: u32,
+/// 	}
+///
+/// 	#[pallet::genesis_build]
+/// 	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+/// 		fn build(&self) {}
+/// 	}
+///
+/// 	#[pallet::origin]
+/// 	pub struct Origin<T, I = ()>(PhantomData<(T, I)>);
+///
+/// 	#[pallet::validate_unsigned]
+/// 	impl<T: Config<I>, I: 'static> ValidateUnsigned for Pallet<T, I> {
+/// 		type Call = Call<T, I>;
+/// 		fn validate_unsigned(
+/// 			source: TransactionSource,
+/// 			call: &Self::Call
+/// 		) -> TransactionValidity {
+/// 			Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
+/// 		}
+/// 	}
+///
+/// 	#[pallet::inherent]
+/// 	impl<T: Config<I>, I: 'static> ProvideInherent for Pallet<T, I> {
+/// 		type Call = Call<T, I>;
+/// 		type Error = InherentError;
+///
+/// 		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+///
+/// 		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+/// 			unimplemented!();
+/// 		}
+///
+/// 		fn is_inherent(_call: &Self::Call) -> bool {
+/// 			unimplemented!();
+/// 		}
+/// 	}
+///
+/// 	// Regular rust code needed for implementing ProvideInherent trait
+///
+/// 	#[derive(codec::Encode, sp_runtime::RuntimeDebug)]
+/// 	#[cfg_attr(feature = "std", derive(codec::Decode))]
+/// 	pub enum InherentError {
+/// 	}
+///
+/// 	impl sp_inherents::IsFatalError for InherentError {
+/// 		fn is_fatal_error(&self) -> bool {
+/// 			unimplemented!();
+/// 		}
+/// 	}
+///
+/// 	pub const INHERENT_IDENTIFIER: sp_inherents::InherentIdentifier = *b"testpall";
+/// }
+/// ```
+///
+/// # Upgrade guidelines
+///
+/// 1. Export the metadata of the pallet for later checks
+///     - run your node with the pallet active
+///     - query the metadata using the `state_getMetadata` RPC and curl, or use `subsee -p
+///       <PALLET_NAME> > meta.json`
+/// 2. Generate the template upgrade for the pallet provided by `decl_storage` with the
+///    environment variable `PRINT_PALLET_UPGRADE`: `PRINT_PALLET_UPGRADE=1 cargo check -p
+///    my_pallet`. This template can be used as it contains all information for storages,
+///    genesis config and genesis build.
+/// 3. Reorganize the pallet to have the trait `Config`, `decl_*` macros,
+///    [`ValidateUnsigned`](`pallet_prelude::ValidateUnsigned`),
+///    [`ProvideInherent`](`pallet_prelude::ProvideInherent`), and Origin` all together in one
+///    file. Suggested order:
+///     * `Config`,
+///     * `decl_module`,
+///     * `decl_event`,
+///     * `decl_error`,
+///     * `decl_storage`,
+///     * `origin`,
+///     * `validate_unsigned`,
+///     * `provide_inherent`, so far it should compile and all be correct.
+/// 4. start writing the new pallet module
+/// 	```ignore
+/// 	pub use pallet::*;
+///
+/// 	#[frame_support::pallet]
+/// 	pub mod pallet {
+/// 		use frame_support::pallet_prelude::*;
+/// 		use frame_system::pallet_prelude::*;
+/// 		use super::*;
+///
+/// 		#[pallet::pallet]
+/// 		#[pallet::generate_store($visibility_of_trait_store trait Store)]
+/// 		// NOTE: if the visibility of trait store is private but you want to make it available
+/// 		// in super, then use `pub(super)` or `pub(crate)` to make it available in crate.
+/// 		pub struct Pallet<T>(_);
+/// 		// pub struct Pallet<T, I = ()>(PhantomData<T>); // for instantiable pallet
+/// 	}
+/// 	```
+/// 5. **migrate Config**: move trait into the module with
+///     * all const in `decl_module` to [`#[pallet::constant]`](#palletconstant)
+///     * add the bound `IsType<<Self as frame_system::Config>::RuntimeEvent>` to `type
+///       RuntimeEvent`
+/// 7. **migrate decl_module**: write:
+/// 	```ignore
+/// 	#[pallet::hooks]
+/// 	impl<T: Config> Hooks for Pallet<T> {
+/// 	}
+/// 	```
+///     and write inside `on_initialize`, `on_finalize`, `on_runtime_upgrade`,
+///     `offchain_worker`, and `integrity_test`.
+///
+/// 	then write:
+/// 	```ignore
+/// 	#[pallet::call]
+/// 	impl<T: Config> Pallet<T> {
+/// 	}
+/// 	```
+///     and write inside all the calls in `decl_module` with a few changes in the signature:
+///     - origin must now be written completely, e.g. `origin: OriginFor<T>`
+///     - result type must be `DispatchResultWithPostInfo`, you need to write it and also you
+///    might need to put `Ok(().into())` at the end or the function.
+///     - `#[compact]` must now be written
+///       [`#[pallet::compact]`](#palletcompact-some_arg-some_type)
+///     - `#[weight = ..]` must now be written [`#[pallet::weight(..)]`](#palletweightexpr)
+///
+/// 7. **migrate event**: rewrite as a simple enum with the attribute
+///    [`#[pallet::event]`](#event-palletevent-optional), use [`#[pallet::generate_deposit($vis
+///    fn deposit_event)]`](#event-palletevent-optional) to generate `deposit_event`,
+/// 8. **migrate error**: rewrite it with attribute
+///    [`#[pallet::error]`](#error-palleterror-optional).
+/// 9. **migrate storage**: `decl_storage` provide an upgrade template (see 3.). All storages,
+///    genesis config, genesis build and default implementation of genesis config can be taken
+///    from it directly.
+///
+///     Otherwise here is the manual process:
+///
+///     first migrate the genesis logic. write:
+/// 	```ignore
+/// 	#[pallet::genesis_config]
+/// 	struct GenesisConfig {
+/// 		// fields of add_extra_genesis
+/// 	}
+/// 	impl Default for GenesisConfig {
+/// 		// type default or default provided for fields
+/// 	}
+/// 	#[pallet::genesis_build]
+/// 	impl<T: Config> GenesisBuild<T> for GenesisConfig {
+/// 	// for instantiable pallet:
+/// 	// `impl<T: Config, I: 'static> GenesisBuild<T, I> for GenesisConfig {
+/// 		fn build() {
+/// 			// The add_extra_genesis build logic
+/// 		}
+/// 	}
+/// 	```
+///     for each storage, if it contains `config(..)` then add fields, and make it default to
+///     the value in `= ..;` or the type default if none, if it contains no build then also add
+///     the logic to build the value. for each storage if it contains `build(..)` then add the
+///     logic to `genesis_build`.
+///
+///     NOTE: within `decl_storage`: the individual config is executed first, followed by the
+///     build and finally the `add_extra_genesis` build.
+///
+///     Once this is done you can migrate storages individually, a few notes:
+///     - for private storage use `pub(crate) type ` or `pub(super) type` or nothing,
+///     - for storages with `get(fn ..)` use [`#[pallet::getter(fn
+///       ...)]`](#palletgetterfn-my_getter_fn_name-optional)
+///     - for storages with value being `Option<$something>` make generic `Value` being
+///       `$something` and generic `QueryKind` being `OptionQuery` (note: this is default).
+///       Otherwise make `Value` the complete value type and `QueryKind` being `ValueQuery`.
+///     - for storages with default value: `= $expr;` provide some specific `OnEmpty` generic.
+///       To do so use of `#[pallet::type_value]` to generate the wanted struct to put.
+///       example: `MyStorage: u32 = 3u32` would be written:
+///
+/// 	  	```ignore
+/// 		#[pallet::type_value] fn MyStorageOnEmpty() -> u32 { 3u32 }
+/// 		#[pallet::storage]
+/// 		pub(super) type MyStorage<T> = StorageValue<_, u32, ValueQuery, MyStorageOnEmpty>;
+/// 		```
+///
+///       NOTE: `decl_storage` also generates the functions `assimilate_storage` and
+///       `build_storage` directly on `GenesisConfig`, and these are sometimes used in tests.
+///       In order not to break they can be implemented manually, one can implement those
+///       functions by calling the `GenesisBuild` implementation.
+/// 10. **migrate origin**: move the origin to the pallet module to be under a
+///     [`#[pallet::origin]`](#origin-palletorigin-optional) attribute
+/// 11. **migrate validate_unsigned**: move the
+///     [`ValidateUnsigned`](`pallet_prelude::ValidateUnsigned`) implementation to the pallet
+///     module under a
+///     [`#[pallet::validate_unsigned]`](#validate-unsigned-palletvalidate_unsigned-optional)
+///     attribute
+/// 12. **migrate provide_inherent**: move the
+///     [`ProvideInherent`](`pallet_prelude::ProvideInherent`) implementation to the pallet
+///     module under a [`#[pallet::inherent]`](#inherent-palletinherent-optional) attribute
+/// 13. rename the usage of `Module` to `Pallet` inside the crate.
+/// 14. migration is done, now double check the migration with the checking migration
+///     guidelines shown below.
+///
+/// # Checking upgrade guidelines:
+///
+/// * compare metadata. Use [subsee](https://github.com/ascjones/subsee) to fetch the metadata
+///   and do a diff of the resulting json before and after migration. This checks for:
+/// 		* call, names, signature, docs
+///     * event names, docs
+///     * error names, docs
+///     * storage names, hasher, prefixes, default value
+///     * error, error, constant
+/// * manually check that:
+///     * `Origin` was moved inside the macro under
+///       [`#[pallet::origin]`](#origin-palletorigin-optional) if it exists
+///     * [`ValidateUnsigned`](`pallet_prelude::ValidateUnsigned`) was moved inside the macro
+///       under
+/// 	  [`#[pallet::validate_unsigned)]`](#validate-unsigned-palletvalidate_unsigned-optional)
+/// 	  if it exists
+///     * [`ProvideInherent`](`pallet_prelude::ProvideInherent`) was moved inside the macro
+///       under [`#[pallet::inherent)]`](#inherent-palletinherent-optional) if it exists
+///     * `on_initialize` / `on_finalize` / `on_runtime_upgrade` / `offchain_worker` were moved
+///       to the `Hooks` implementation
+///     * storages with `config(..)` were converted to `GenesisConfig` field, and their default
+///       is `= $expr;` if the storage has a default value
+///     * storages with `build($expr)` or `config(..)` were built in `GenesisBuild::build`
+///     * `add_extra_genesis` fields were converted to `GenesisConfig` field with their correct
+///       default if specified
+///     * `add_extra_genesis` build was written into `GenesisBuild::build`
+/// * storage items defined with [`pallet`] use the name of the pallet provided by
+///   [`traits::PalletInfo::name`] as `pallet_prefix` (in `decl_storage`, storage items used
+///   the `pallet_prefix` given as input of `decl_storage` with the syntax `as Example`). Thus
+///   a runtime using the pallet must be careful with this change. To handle this change:
+///     * either ensure that the name of the pallet given to `construct_runtime!` is the same
+///       as the name the pallet was giving to `decl_storage`,
+///     * or do a storage migration from the old prefix used to the new prefix used.
+///
+/// NOTE: The prefixes used by storage items are in metadata. Thus, ensuring the metadata
+/// hasn't changed ensures that the `pallet_prefix`s used by the storage items haven't changed.
+///
+/// # Notes when macro fails to show proper error message spans:
+///
+/// Rustc loses span for some macro input. Some tips to fix it:
+/// * do not use inner attribute:
+/// 	```ignore
+/// 	#[pallet]
+/// 	pub mod pallet {
+/// 		//! This inner attribute will make span fail
+/// 		..
+/// 	}
+/// 	```
+/// * use the newest nightly possible.
+pub use frame_support_procedural::pallet;
+
+/// Contains macro stubs for all of the pallet:: macros
+pub mod pallet_macros {
+	pub use frame_support_procedural::{
+		call_index, compact, composite_enum, config, constant,
+		disable_frame_system_supertrait_check, error, event, extra_constants, generate_deposit,
+		generate_store, genesis_build, genesis_config, getter, hooks, import_section, inherent,
+		no_default, no_default_bounds, origin, pallet_section, storage, storage_prefix,
+		storage_version, type_value, unbounded, validate_unsigned, weight, whitelist_storage,
+	};
+}
+
+#[deprecated(note = "Will be removed after July 2023; Use `sp_runtime::traits` directly instead.")]
+pub mod error {
+	#[doc(hidden)]
+	pub use sp_runtime::traits::{BadOrigin, LookupError};
+}
+
+#[doc(inline)]
+pub use frame_support_procedural::register_default_impl;
+
+// Generate a macro that will enable/disable code based on `std` feature being active.
+sp_core::generate_feature_enabled_macro!(std_enabled, feature = "std", $);
+
+// Helper for implementing GenesisBuilder runtime API
+pub mod genesis_builder_helper;
diff --git a/substrate/frame/support/src/migrations.rs b/substrate/frame/support/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..19eec194a76ad4a2fa4a255d37aaa07882b1c013
--- /dev/null
+++ b/substrate/frame/support/src/migrations.rs
@@ -0,0 +1,351 @@
+// 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::{
+	traits::{GetStorageVersion, NoStorageVersionSet, PalletInfoAccess, StorageVersion},
+	weights::{RuntimeDbWeight, Weight},
+};
+use impl_trait_for_tuples::impl_for_tuples;
+use sp_core::Get;
+use sp_io::{hashing::twox_128, storage::clear_prefix, KillStorageResult};
+use sp_std::marker::PhantomData;
+
+/// EXPERIMENTAL: The API of this feature may change.
+///
+/// Make it easier to write versioned runtime upgrades.
+///
+/// [`VersionedRuntimeUpgrade`] allows developers to write migrations without worrying about
+/// checking and setting storage versions. Instead, the developer wraps their migration in this
+/// struct which takes care of version handling using best practices.
+///
+/// It takes 5 type parameters:
+/// - `From`: The version being upgraded from.
+/// - `To`: The version being upgraded to.
+/// - `Inner`: An implementation of `OnRuntimeUpgrade`.
+/// - `Pallet`: The Pallet being upgraded.
+/// - `Weight`: The runtime's RuntimeDbWeight implementation.
+///
+/// When a [`VersionedRuntimeUpgrade`] `on_runtime_upgrade`, `pre_upgrade`, or `post_upgrade`
+/// method is called, the on-chain version of the pallet is compared to `From`. If they match, the
+/// `Inner` equivalent is called and the pallets on-chain version is set to `To` after the
+/// migration. Otherwise, a warning is logged notifying the developer that the upgrade was a noop
+/// and should probably be removed.
+///
+/// ### Examples
+/// ```ignore
+/// // In file defining migrations
+/// pub struct VersionUncheckedMigrateV5ToV6<T>(sp_std::marker::PhantomData<T>);
+/// impl<T: Config> OnRuntimeUpgrade for VersionUncheckedMigrateV5ToV6<T> {
+/// 	// OnRuntimeUpgrade implementation...
+/// }
+///
+/// pub type VersionCheckedMigrateV5ToV6<T, I> =
+/// 	VersionedRuntimeUpgrade<
+/// 		5,
+/// 		6,
+/// 		VersionUncheckedMigrateV5ToV6<T, I>,
+/// 		crate::pallet::Pallet<T, I>,
+/// 		<T as frame_system::Config>::DbWeight
+/// 	>;
+///
+/// // Migrations tuple to pass to the Executive pallet:
+/// pub type Migrations = (
+/// 	// other migrations...
+/// 	VersionCheckedMigrateV5ToV6<T, ()>,
+/// 	// other migrations...
+/// );
+/// ```
+#[cfg(feature = "experimental")]
+pub struct VersionedRuntimeUpgrade<const FROM: u16, const TO: u16, Inner, Pallet, Weight> {
+	_marker: PhantomData<(Inner, Pallet, Weight)>,
+}
+
+/// A helper enum to wrap the pre_upgrade bytes like an Option before passing them to post_upgrade.
+/// This enum is used rather than an Option to make the API clearer to the developer.
+#[cfg(feature = "experimental")]
+#[derive(codec::Encode, codec::Decode)]
+pub enum VersionedPostUpgradeData {
+	/// The migration ran, inner vec contains pre_upgrade data.
+	MigrationExecuted(sp_std::vec::Vec<u8>),
+	/// This migration is a noop, do not run post_upgrade checks.
+	Noop,
+}
+
+/// Implementation of the `OnRuntimeUpgrade` trait for `VersionedRuntimeUpgrade`.
+///
+/// Its main function is to perform the runtime upgrade in `on_runtime_upgrade` only if the on-chain
+/// version of the pallets storage matches `From`, and after the upgrade set the on-chain storage to
+/// `To`. If the versions do not match, it writes a log notifying the developer that the migration
+/// is a noop.
+#[cfg(feature = "experimental")]
+impl<
+		const FROM: u16,
+		const TO: u16,
+		Inner: crate::traits::OnRuntimeUpgrade,
+		Pallet: GetStorageVersion<CurrentStorageVersion = StorageVersion> + PalletInfoAccess,
+		DbWeight: Get<RuntimeDbWeight>,
+	> crate::traits::OnRuntimeUpgrade for VersionedRuntimeUpgrade<FROM, TO, Inner, Pallet, DbWeight>
+{
+	/// Executes pre_upgrade if the migration will run, and wraps the pre_upgrade bytes in
+	/// [`VersionedPostUpgradeData`] before passing them to post_upgrade, so it knows whether the
+	/// migration ran or not.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<sp_std::vec::Vec<u8>, sp_runtime::TryRuntimeError> {
+		use codec::Encode;
+		let on_chain_version = Pallet::on_chain_storage_version();
+		if on_chain_version == FROM {
+			Ok(VersionedPostUpgradeData::MigrationExecuted(Inner::pre_upgrade()?).encode())
+		} else {
+			Ok(VersionedPostUpgradeData::Noop.encode())
+		}
+	}
+
+	/// Executes the versioned runtime upgrade.
+	///
+	/// First checks if the pallets on-chain storage version matches the version of this upgrade. If
+	/// it matches, it calls `Inner::on_runtime_upgrade`, updates the on-chain version, and returns
+	/// the weight. If it does not match, it writes a log notifying the developer that the migration
+	/// is a noop.
+	fn on_runtime_upgrade() -> Weight {
+		let on_chain_version = Pallet::on_chain_storage_version();
+		if on_chain_version == FROM {
+			log::info!(
+				"Running {} VersionedOnRuntimeUpgrade: version {:?} to {:?}.",
+				Pallet::name(),
+				FROM,
+				TO
+			);
+
+			// Execute the migration
+			let weight = Inner::on_runtime_upgrade();
+
+			// Update the on-chain version
+			StorageVersion::new(TO).put::<Pallet>();
+
+			weight.saturating_add(DbWeight::get().reads_writes(1, 1))
+		} else {
+			log::warn!(
+				"{} VersionedOnRuntimeUpgrade for version {:?} skipped because current on-chain version is {:?}.",
+				Pallet::name(),
+				FROM,
+				on_chain_version
+			);
+			DbWeight::get().reads(1)
+		}
+	}
+
+	/// Executes `Inner::post_upgrade` if the migration just ran.
+	///
+	/// pre_upgrade passes [`VersionedPostUpgradeData::MigrationExecuted`] to post_upgrade if
+	/// the migration ran, and [`VersionedPostUpgradeData::Noop`] otherwise.
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(
+		versioned_post_upgrade_data_bytes: sp_std::vec::Vec<u8>,
+	) -> Result<(), sp_runtime::TryRuntimeError> {
+		use codec::DecodeAll;
+		match <VersionedPostUpgradeData>::decode_all(&mut &versioned_post_upgrade_data_bytes[..])
+			.map_err(|_| "VersionedRuntimeUpgrade post_upgrade failed to decode PreUpgradeData")?
+		{
+			VersionedPostUpgradeData::MigrationExecuted(inner_bytes) =>
+				Inner::post_upgrade(inner_bytes),
+			VersionedPostUpgradeData::Noop => Ok(()),
+		}
+	}
+}
+
+/// Can store the current pallet version in storage.
+pub trait StoreCurrentStorageVersion<T: GetStorageVersion + PalletInfoAccess> {
+	/// Write the current storage version to the storage.
+	fn store_current_storage_version();
+}
+
+impl<T: GetStorageVersion<CurrentStorageVersion = StorageVersion> + PalletInfoAccess>
+	StoreCurrentStorageVersion<T> for StorageVersion
+{
+	fn store_current_storage_version() {
+		let version = <T as GetStorageVersion>::current_storage_version();
+		version.put::<T>();
+	}
+}
+
+impl<T: GetStorageVersion<CurrentStorageVersion = NoStorageVersionSet> + PalletInfoAccess>
+	StoreCurrentStorageVersion<T> for NoStorageVersionSet
+{
+	fn store_current_storage_version() {
+		StorageVersion::default().put::<T>();
+	}
+}
+
+/// Trait used by [`migrate_from_pallet_version_to_storage_version`] to do the actual migration.
+pub trait PalletVersionToStorageVersionHelper {
+	fn migrate(db_weight: &RuntimeDbWeight) -> Weight;
+}
+
+impl<T: GetStorageVersion + PalletInfoAccess> PalletVersionToStorageVersionHelper for T
+where
+	T::CurrentStorageVersion: StoreCurrentStorageVersion<T>,
+{
+	fn migrate(db_weight: &RuntimeDbWeight) -> Weight {
+		const PALLET_VERSION_STORAGE_KEY_POSTFIX: &[u8] = b":__PALLET_VERSION__:";
+
+		fn pallet_version_key(name: &str) -> [u8; 32] {
+			crate::storage::storage_prefix(name.as_bytes(), PALLET_VERSION_STORAGE_KEY_POSTFIX)
+		}
+
+		sp_io::storage::clear(&pallet_version_key(<T as PalletInfoAccess>::name()));
+
+		<T::CurrentStorageVersion as StoreCurrentStorageVersion<T>>::store_current_storage_version(
+		);
+
+		db_weight.writes(2)
+	}
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl PalletVersionToStorageVersionHelper for T {
+	fn migrate(db_weight: &RuntimeDbWeight) -> Weight {
+		let mut weight = Weight::zero();
+
+		for_tuples!( #( weight = weight.saturating_add(T::migrate(db_weight)); )* );
+
+		weight
+	}
+}
+
+/// Migrate from the `PalletVersion` struct to the new
+/// [`StorageVersion`](crate::traits::StorageVersion) struct.
+///
+/// This will remove all `PalletVersion's` from the state and insert the current storage version.
+pub fn migrate_from_pallet_version_to_storage_version<
+	Pallets: PalletVersionToStorageVersionHelper,
+>(
+	db_weight: &RuntimeDbWeight,
+) -> Weight {
+	Pallets::migrate(db_weight)
+}
+
+/// `RemovePallet` is a utility struct used to remove all storage items associated with a specific
+/// pallet.
+///
+/// This struct is generic over two parameters:
+/// - `P` is a type that implements the `Get` trait for a static string, representing the pallet's
+///   name.
+/// - `DbWeight` is a type that implements the `Get` trait for `RuntimeDbWeight`, providing the
+///   weight for database operations.
+///
+/// On runtime upgrade, the `on_runtime_upgrade` function will clear all storage items associated
+/// with the specified pallet, logging the number of keys removed. If the `try-runtime` feature is
+/// enabled, the `pre_upgrade` and `post_upgrade` functions can be used to verify the storage
+/// removal before and after the upgrade.
+///
+/// # Examples:
+/// ```ignore
+/// construct_runtime! {
+/// 	pub enum Runtime
+/// 	{
+/// 		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>} = 0,
+///
+/// 		SomePalletToRemove: pallet_something::{Pallet, Call, Storage, Event<T>} = 1,
+/// 		AnotherPalletToRemove: pallet_something_else::{Pallet, Call, Storage, Event<T>} = 2,
+///
+/// 		YourOtherPallets...
+/// 	}
+/// };
+///
+/// parameter_types! {
+/// 		pub const SomePalletToRemoveStr: &'static str = "SomePalletToRemove";
+/// 		pub const AnotherPalletToRemoveStr: &'static str = "AnotherPalletToRemove";
+/// }
+///
+/// pub type Migrations = (
+/// 	RemovePallet<SomePalletToRemoveStr, RocksDbWeight>,
+/// 	RemovePallet<AnotherPalletToRemoveStr, RocksDbWeight>,
+/// 	AnyOtherMigrations...
+/// );
+///
+/// pub type Executive = frame_executive::Executive<
+/// 	Runtime,
+/// 	Block,
+/// 	frame_system::ChainContext<Runtime>,
+/// 	Runtime,
+/// 	Migrations
+/// >;
+/// ```
+///
+/// WARNING: `RemovePallet` has no guard rails preventing it from bricking the chain if the
+/// operation of removing storage for the given pallet would exceed the block weight limit.
+///
+/// If your pallet has too many keys to be removed in a single block, it is advised to wait for
+/// a multi-block scheduler currently under development which will allow for removal of storage
+/// items (and performing other heavy migrations) over multiple blocks
+/// (see <https://github.com/paritytech/substrate/issues/13690>).
+pub struct RemovePallet<P: Get<&'static str>, DbWeight: Get<RuntimeDbWeight>>(
+	PhantomData<(P, DbWeight)>,
+);
+impl<P: Get<&'static str>, DbWeight: Get<RuntimeDbWeight>> frame_support::traits::OnRuntimeUpgrade
+	for RemovePallet<P, DbWeight>
+{
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		let hashed_prefix = twox_128(P::get().as_bytes());
+		let keys_removed = match clear_prefix(&hashed_prefix, None) {
+			KillStorageResult::AllRemoved(value) => value,
+			KillStorageResult::SomeRemaining(value) => {
+				log::error!(
+					"`clear_prefix` failed to remove all keys for {}. THIS SHOULD NEVER HAPPEN! 🚨",
+					P::get()
+				);
+				value
+			},
+		} as u64;
+
+		log::info!("Removed {} {} keys 🧹", keys_removed, P::get());
+
+		DbWeight::get().reads_writes(keys_removed + 1, keys_removed)
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<sp_std::vec::Vec<u8>, sp_runtime::TryRuntimeError> {
+		use crate::storage::unhashed::contains_prefixed_key;
+
+		let hashed_prefix = twox_128(P::get().as_bytes());
+		match contains_prefixed_key(&hashed_prefix) {
+			true => log::info!("Found {} keys pre-removal 👀", P::get()),
+			false => log::warn!(
+				"Migration RemovePallet<{}> can be removed (no keys found pre-removal).",
+				P::get()
+			),
+		};
+		Ok(sp_std::vec::Vec::new())
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: sp_std::vec::Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		use crate::storage::unhashed::contains_prefixed_key;
+
+		let hashed_prefix = twox_128(P::get().as_bytes());
+		match contains_prefixed_key(&hashed_prefix) {
+			true => {
+				log::error!("{} has keys remaining post-removal �", P::get());
+				return Err("Keys remaining post-removal, this should never happen 🚨".into())
+			},
+			false => log::info!("No {} keys found post-removal 🎉", P::get()),
+		};
+		Ok(())
+	}
+}
diff --git a/substrate/frame/support/src/storage/bounded_btree_map.rs b/substrate/frame/support/src/storage/bounded_btree_map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f2f32d890b87bca062a4e4f3aec31b7fa3b94127
--- /dev/null
+++ b/substrate/frame/support/src/storage/bounded_btree_map.rs
@@ -0,0 +1,83 @@
+// 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.
+
+//! Traits, types and structs to support a bounded BTreeMap.
+
+use crate::storage::StorageDecodeLength;
+pub use sp_runtime::BoundedBTreeMap;
+
+impl<K, V, S> StorageDecodeLength for BoundedBTreeMap<K, V, S> {}
+
+#[cfg(test)]
+pub mod test {
+	use super::*;
+	use crate::Twox128;
+	use frame_support::traits::{ConstU32, Get};
+	use sp_io::TestExternalities;
+	use sp_std::collections::btree_map::BTreeMap;
+
+	#[crate::storage_alias]
+	type Foo = StorageValue<Prefix, BoundedBTreeMap<u32, (), ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooMap = StorageMap<Prefix, Twox128, u32, BoundedBTreeMap<u32, (), ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooDoubleMap =
+		StorageDoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedBTreeMap<u32, (), ConstU32<7>>>;
+
+	fn map_from_keys<K>(keys: &[K]) -> BTreeMap<K, ()>
+	where
+		K: Ord + Copy,
+	{
+		keys.iter().copied().zip(std::iter::repeat(())).collect()
+	}
+
+	fn boundedmap_from_keys<K, S>(keys: &[K]) -> BoundedBTreeMap<K, (), S>
+	where
+		K: Ord + Copy,
+		S: Get<u32>,
+	{
+		map_from_keys(keys).try_into().unwrap()
+	}
+
+	#[test]
+	fn decode_len_works() {
+		TestExternalities::default().execute_with(|| {
+			let bounded = boundedmap_from_keys::<u32, ConstU32<7>>(&[1, 2, 3]);
+			Foo::put(bounded);
+			assert_eq!(Foo::decode_len().unwrap(), 3);
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded = boundedmap_from_keys::<u32, ConstU32<7>>(&[1, 2, 3]);
+			FooMap::insert(1, bounded);
+			assert_eq!(FooMap::decode_len(1).unwrap(), 3);
+			assert!(FooMap::decode_len(0).is_none());
+			assert!(FooMap::decode_len(2).is_none());
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded = boundedmap_from_keys::<u32, ConstU32<7>>(&[1, 2, 3]);
+			FooDoubleMap::insert(1, 1, bounded);
+			assert_eq!(FooDoubleMap::decode_len(1, 1).unwrap(), 3);
+			assert!(FooDoubleMap::decode_len(2, 1).is_none());
+			assert!(FooDoubleMap::decode_len(1, 2).is_none());
+			assert!(FooDoubleMap::decode_len(2, 2).is_none());
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/bounded_btree_set.rs b/substrate/frame/support/src/storage/bounded_btree_set.rs
new file mode 100644
index 0000000000000000000000000000000000000000..52be1bb99f1015dc63ecd0e5d0bfe343f405e1f2
--- /dev/null
+++ b/substrate/frame/support/src/storage/bounded_btree_set.rs
@@ -0,0 +1,83 @@
+// 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.
+
+//! Traits, types and structs to support a bounded `BTreeSet`.
+
+use crate::storage::StorageDecodeLength;
+pub use sp_runtime::BoundedBTreeSet;
+
+impl<T, S> StorageDecodeLength for BoundedBTreeSet<T, S> {}
+
+#[cfg(test)]
+pub mod test {
+	use super::*;
+	use crate::Twox128;
+	use frame_support::traits::{ConstU32, Get};
+	use sp_io::TestExternalities;
+	use sp_std::collections::btree_set::BTreeSet;
+
+	#[crate::storage_alias]
+	type Foo = StorageValue<Prefix, BoundedBTreeSet<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooMap = StorageMap<Prefix, Twox128, u32, BoundedBTreeSet<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooDoubleMap =
+		StorageDoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedBTreeSet<u32, ConstU32<7>>>;
+
+	fn set_from_keys<T>(keys: &[T]) -> BTreeSet<T>
+	where
+		T: Ord + Copy,
+	{
+		keys.iter().copied().collect()
+	}
+
+	fn boundedset_from_keys<T, S>(keys: &[T]) -> BoundedBTreeSet<T, S>
+	where
+		T: Ord + Copy,
+		S: Get<u32>,
+	{
+		set_from_keys(keys).try_into().unwrap()
+	}
+
+	#[test]
+	fn decode_len_works() {
+		TestExternalities::default().execute_with(|| {
+			let bounded = boundedset_from_keys::<u32, ConstU32<7>>(&[1, 2, 3]);
+			Foo::put(bounded);
+			assert_eq!(Foo::decode_len().unwrap(), 3);
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded = boundedset_from_keys::<u32, ConstU32<7>>(&[1, 2, 3]);
+			FooMap::insert(1, bounded);
+			assert_eq!(FooMap::decode_len(1).unwrap(), 3);
+			assert!(FooMap::decode_len(0).is_none());
+			assert!(FooMap::decode_len(2).is_none());
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded = boundedset_from_keys::<u32, ConstU32<7>>(&[1, 2, 3]);
+			FooDoubleMap::insert(1, 1, bounded);
+			assert_eq!(FooDoubleMap::decode_len(1, 1).unwrap(), 3);
+			assert!(FooDoubleMap::decode_len(2, 1).is_none());
+			assert!(FooDoubleMap::decode_len(1, 2).is_none());
+			assert!(FooDoubleMap::decode_len(2, 2).is_none());
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/bounded_vec.rs b/substrate/frame/support/src/storage/bounded_vec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..06c58915a94d173271ea019138e5d927a84e932c
--- /dev/null
+++ b/substrate/frame/support/src/storage/bounded_vec.rs
@@ -0,0 +1,77 @@
+// 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.
+
+//! Traits, types and structs to support putting a bounded vector into storage, as a raw value, map
+//! or a double map.
+
+use crate::{
+	storage::{StorageDecodeLength, StorageTryAppend},
+	traits::Get,
+};
+pub use sp_runtime::{BoundedSlice, BoundedVec};
+
+impl<T, S> StorageDecodeLength for BoundedVec<T, S> {}
+
+impl<T, S: Get<u32>> StorageTryAppend<T> for BoundedVec<T, S> {
+	fn bound() -> usize {
+		S::get() as usize
+	}
+}
+
+#[cfg(test)]
+pub mod test {
+	use super::*;
+	use crate::{traits::ConstU32, Twox128};
+	use sp_io::TestExternalities;
+	use sp_runtime::bounded_vec;
+
+	#[crate::storage_alias]
+	type Foo = StorageValue<Prefix, BoundedVec<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooMap = StorageMap<Prefix, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
+
+	#[crate::storage_alias]
+	type FooDoubleMap =
+		StorageDoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
+
+	#[test]
+	fn decode_len_works() {
+		TestExternalities::default().execute_with(|| {
+			let bounded: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3];
+			Foo::put(bounded);
+			assert_eq!(Foo::decode_len().unwrap(), 3);
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3];
+			FooMap::insert(1, bounded);
+			assert_eq!(FooMap::decode_len(1).unwrap(), 3);
+			assert!(FooMap::decode_len(0).is_none());
+			assert!(FooMap::decode_len(2).is_none());
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded: BoundedVec<u32, ConstU32<7>> = bounded_vec![1, 2, 3];
+			FooDoubleMap::insert(1, 1, bounded);
+			assert_eq!(FooDoubleMap::decode_len(1, 1).unwrap(), 3);
+			assert!(FooDoubleMap::decode_len(2, 1).is_none());
+			assert!(FooDoubleMap::decode_len(1, 2).is_none());
+			assert!(FooDoubleMap::decode_len(2, 2).is_none());
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/child.rs b/substrate/frame/support/src/storage/child.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e54002d18db3ddf09e7ee3dba56ab6948d7192b2
--- /dev/null
+++ b/substrate/frame/support/src/storage/child.rs
@@ -0,0 +1,239 @@
+// 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.
+
+//! Operation on runtime child storages.
+//!
+//! This module is a currently only a variant of unhashed with additional `child_info`.
+// NOTE: could replace unhashed by having only one kind of storage (top trie being the child info
+// of null length parent storage key).
+
+use codec::{Codec, Decode, Encode};
+pub use sp_core::storage::{ChildInfo, ChildType, StateVersion};
+pub use sp_io::{KillStorageResult, MultiRemovalResults};
+use sp_std::prelude::*;
+
+/// Return the value of the item in storage under `key`, or `None` if there is no explicit entry.
+pub fn get<T: Decode + Sized>(child_info: &ChildInfo, key: &[u8]) -> Option<T> {
+	match child_info.child_type() {
+		ChildType::ParentKeyId => {
+			let storage_key = child_info.storage_key();
+			sp_io::default_child_storage::get(storage_key, key).and_then(|v| {
+				Decode::decode(&mut &v[..]).map(Some).unwrap_or_else(|_| {
+					// TODO #3700: error should be handleable.
+					log::error!(
+						target: "runtime::storage",
+						"Corrupted state in child trie at {:?}/{:?}",
+						storage_key,
+						key,
+					);
+					None
+				})
+			})
+		},
+	}
+}
+
+/// Return the value of the item in storage under `key`, or the type's default if there is no
+/// explicit entry.
+pub fn get_or_default<T: Decode + Sized + Default>(child_info: &ChildInfo, key: &[u8]) -> T {
+	get(child_info, key).unwrap_or_default()
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry.
+pub fn get_or<T: Decode + Sized>(child_info: &ChildInfo, key: &[u8], default_value: T) -> T {
+	get(child_info, key).unwrap_or(default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry.
+pub fn get_or_else<T: Decode + Sized, F: FnOnce() -> T>(
+	child_info: &ChildInfo,
+	key: &[u8],
+	default_value: F,
+) -> T {
+	get(child_info, key).unwrap_or_else(default_value)
+}
+
+/// Put `value` in storage under `key`.
+pub fn put<T: Encode>(child_info: &ChildInfo, key: &[u8], value: &T) {
+	match child_info.child_type() {
+		ChildType::ParentKeyId => value.using_encoded(|slice| {
+			sp_io::default_child_storage::set(child_info.storage_key(), key, slice)
+		}),
+	}
+}
+
+/// Remove `key` from storage, returning its value if it had an explicit entry or `None` otherwise.
+pub fn take<T: Decode + Sized>(child_info: &ChildInfo, key: &[u8]) -> Option<T> {
+	let r = get(child_info, key);
+	if r.is_some() {
+		kill(child_info, key);
+	}
+	r
+}
+
+/// Remove `key` from storage, returning its value, or, if there was no explicit entry in storage,
+/// the default for its type.
+pub fn take_or_default<T: Codec + Sized + Default>(child_info: &ChildInfo, key: &[u8]) -> T {
+	take(child_info, key).unwrap_or_default()
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or<T: Codec + Sized>(child_info: &ChildInfo, key: &[u8], default_value: T) -> T {
+	take(child_info, key).unwrap_or(default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or_else<T: Codec + Sized, F: FnOnce() -> T>(
+	child_info: &ChildInfo,
+	key: &[u8],
+	default_value: F,
+) -> T {
+	take(child_info, key).unwrap_or_else(default_value)
+}
+
+/// Check to see if `key` has an explicit entry in storage.
+pub fn exists(child_info: &ChildInfo, key: &[u8]) -> bool {
+	match child_info.child_type() {
+		ChildType::ParentKeyId =>
+			sp_io::default_child_storage::exists(child_info.storage_key(), key),
+	}
+}
+
+/// Remove all `storage_key` key/values
+///
+/// Deletes all keys from the overlay and up to `limit` keys from the backend if
+/// it is set to `Some`. No limit is applied when `limit` is set to `None`.
+///
+/// The limit can be used to partially delete a child trie in case it is too large
+/// to delete in one go (block).
+///
+/// # Note
+///
+/// Please note that keys that are residing in the overlay for that child trie when
+/// issuing this call are all deleted without counting towards the `limit`. Only keys
+/// written during the current block are part of the overlay. Deleting with a `limit`
+/// mostly makes sense with an empty overlay for that child trie.
+///
+/// Calling this function multiple times per block for the same `storage_key` does
+/// not make much sense because it is not cumulative when called inside the same block.
+/// Use this function to distribute the deletion of a single child trie across multiple
+/// blocks.
+#[deprecated = "Use `clear_storage` instead"]
+pub fn kill_storage(child_info: &ChildInfo, limit: Option<u32>) -> KillStorageResult {
+	match child_info.child_type() {
+		ChildType::ParentKeyId =>
+			sp_io::default_child_storage::storage_kill(child_info.storage_key(), limit),
+	}
+}
+
+/// Partially clear the child storage of each key-value pair.
+///
+/// # Limit
+///
+/// A *limit* should always be provided through `maybe_limit`. This is one fewer than the
+/// maximum number of backend iterations which may be done by this operation and as such
+/// represents the maximum number of backend deletions which may happen. A *limit* of zero
+/// implies that no keys will be deleted, though there may be a single iteration done.
+///
+/// The limit can be used to partially delete storage items in case it is too large or costly
+/// to delete all in a single operation.
+///
+/// # Cursor
+///
+/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+/// passed once (in the initial call) for any attempt to clear storage. In general, subsequent calls
+/// operating on the same prefix should pass `Some` and this value should be equal to the
+/// previous call result's `maybe_cursor` field. The only exception to this is when you can
+/// guarantee that the subsequent call is in a new block; in this case the previous call's result
+/// cursor need not be passed in an a `None` may be passed instead. This exception may be useful
+/// then making this call solely from a block-hook such as `on_initialize`.
+///
+/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once the
+/// resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+///
+/// NOTE: After the initial call for any given child storage, it is important that no keys further
+/// keys are inserted. If so, then they may or may not be deleted by subsequent calls.
+///
+/// # Note
+///
+/// Please note that keys which are residing in the overlay for the child are deleted without
+/// counting towards the `limit`.
+pub fn clear_storage(
+	child_info: &ChildInfo,
+	maybe_limit: Option<u32>,
+	_maybe_cursor: Option<&[u8]>,
+) -> MultiRemovalResults {
+	// TODO: Once the network has upgraded to include the new host functions, this code can be
+	// enabled.
+	// sp_io::default_child_storage::storage_kill(prefix, maybe_limit, maybe_cursor)
+	let r = match child_info.child_type() {
+		ChildType::ParentKeyId =>
+			sp_io::default_child_storage::storage_kill(child_info.storage_key(), maybe_limit),
+	};
+	use sp_io::KillStorageResult::*;
+	let (maybe_cursor, backend) = match r {
+		AllRemoved(db) => (None, db),
+		SomeRemaining(db) => (Some(child_info.storage_key().to_vec()), db),
+	};
+	MultiRemovalResults { maybe_cursor, backend, unique: backend, loops: backend }
+}
+
+/// Ensure `key` has no explicit entry in storage.
+pub fn kill(child_info: &ChildInfo, key: &[u8]) {
+	match child_info.child_type() {
+		ChildType::ParentKeyId => {
+			sp_io::default_child_storage::clear(child_info.storage_key(), key);
+		},
+	}
+}
+
+/// Get a Vec of bytes from storage.
+pub fn get_raw(child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
+	match child_info.child_type() {
+		ChildType::ParentKeyId => sp_io::default_child_storage::get(child_info.storage_key(), key),
+	}
+}
+
+/// Put a raw byte slice into storage.
+pub fn put_raw(child_info: &ChildInfo, key: &[u8], value: &[u8]) {
+	match child_info.child_type() {
+		ChildType::ParentKeyId =>
+			sp_io::default_child_storage::set(child_info.storage_key(), key, value),
+	}
+}
+
+/// Calculate current child root value.
+pub fn root(child_info: &ChildInfo, version: StateVersion) -> Vec<u8> {
+	match child_info.child_type() {
+		ChildType::ParentKeyId =>
+			sp_io::default_child_storage::root(child_info.storage_key(), version),
+	}
+}
+
+/// Return the length in bytes of the value without reading it. `None` if it does not exist.
+pub fn len(child_info: &ChildInfo, key: &[u8]) -> Option<u32> {
+	match child_info.child_type() {
+		ChildType::ParentKeyId => {
+			let mut buffer = [0; 0];
+			sp_io::default_child_storage::read(child_info.storage_key(), key, &mut buffer, 0)
+		},
+	}
+}
diff --git a/substrate/frame/support/src/storage/generator/double_map.rs b/substrate/frame/support/src/storage/generator/double_map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..00a3f1bc7c1ce3d4434766e2a32fa5d523db043d
--- /dev/null
+++ b/substrate/frame/support/src/storage/generator/double_map.rs
@@ -0,0 +1,659 @@
+// 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::{
+	hash::{ReversibleStorageHasher, StorageHasher},
+	storage::{self, storage_prefix, unhashed, KeyPrefixIterator, PrefixIterator, StorageAppend},
+	Never,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, FullEncode};
+use sp_std::prelude::*;
+
+/// Generator for `StorageDoubleMap` used by `decl_storage`.
+///
+/// # Mapping of keys to a storage path
+///
+/// The storage key (i.e. the key under which the `Value` will be stored) is created from two parts.
+/// The first part is a hash of a concatenation of the `key1_prefix` and `Key1`. And the second part
+/// is a hash of a `Key2`.
+///
+/// Thus value for (key1, key2) is stored at:
+/// ```nocompile
+/// Twox128(module_prefix) ++ Twox128(storage_prefix) ++ Hasher1(encode(key1)) ++ Hasher2(encode(key2))
+/// ```
+///
+/// # Warning
+///
+/// If the key1s are not trusted (e.g. can be set by a user), a cryptographic `hasher` such as
+/// `blake2_256` must be used for Hasher1. Otherwise, other values in storage can be compromised.
+/// If the key2s are not trusted (e.g. can be set by a user), a cryptographic `hasher` such as
+/// `blake2_256` must be used for Hasher2. Otherwise, other items in storage with the same first
+/// key can be compromised.
+pub trait StorageDoubleMap<K1: FullEncode, K2: FullEncode, V: FullCodec> {
+	/// The type that get/take returns.
+	type Query;
+
+	/// Hasher for the first key.
+	type Hasher1: StorageHasher;
+
+	/// Hasher for the second key.
+	type Hasher2: StorageHasher;
+
+	/// Module prefix. Used for generating final key.
+	fn module_prefix() -> &'static [u8];
+
+	/// Storage prefix. Used for generating final key.
+	fn storage_prefix() -> &'static [u8];
+
+	/// The full prefix; just the hash of `module_prefix` concatenated to the hash of
+	/// `storage_prefix`.
+	fn prefix_hash() -> Vec<u8> {
+		let result = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		result.to_vec()
+	}
+
+	/// Convert an optional value retrieved from storage to the type queried.
+	fn from_optional_value_to_query(v: Option<V>) -> Self::Query;
+
+	/// Convert a query to an optional value into storage.
+	fn from_query_to_optional_value(v: Self::Query) -> Option<V>;
+
+	/// Generate the first part of the key used in top storage.
+	fn storage_double_map_final_key1<KArg1>(k1: KArg1) -> Vec<u8>
+	where
+		KArg1: EncodeLike<K1>,
+	{
+		let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		let key_hashed = k1.using_encoded(Self::Hasher1::hash);
+
+		let mut final_key = Vec::with_capacity(storage_prefix.len() + key_hashed.as_ref().len());
+
+		final_key.extend_from_slice(&storage_prefix);
+		final_key.extend_from_slice(key_hashed.as_ref());
+
+		final_key
+	}
+
+	/// Generate the full key used in top storage.
+	fn storage_double_map_final_key<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Vec<u8>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+	{
+		let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		let key1_hashed = k1.using_encoded(Self::Hasher1::hash);
+		let key2_hashed = k2.using_encoded(Self::Hasher2::hash);
+
+		let mut final_key = Vec::with_capacity(
+			storage_prefix.len() + key1_hashed.as_ref().len() + key2_hashed.as_ref().len(),
+		);
+
+		final_key.extend_from_slice(&storage_prefix);
+		final_key.extend_from_slice(key1_hashed.as_ref());
+		final_key.extend_from_slice(key2_hashed.as_ref());
+
+		final_key
+	}
+}
+
+impl<K1, K2, V, G> storage::StorageDoubleMap<K1, K2, V> for G
+where
+	K1: FullEncode,
+	K2: FullEncode,
+	V: FullCodec,
+	G: StorageDoubleMap<K1, K2, V>,
+{
+	type Query = G::Query;
+
+	fn hashed_key_for<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Vec<u8>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+	{
+		Self::storage_double_map_final_key(k1, k2)
+	}
+
+	fn contains_key<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> bool
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+	{
+		unhashed::exists(&Self::storage_double_map_final_key(k1, k2))
+	}
+
+	fn get<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Self::Query
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+	{
+		G::from_optional_value_to_query(unhashed::get(&Self::storage_double_map_final_key(k1, k2)))
+	}
+
+	fn try_get<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Result<V, ()>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+	{
+		unhashed::get(&Self::storage_double_map_final_key(k1, k2)).ok_or(())
+	}
+
+	fn set<KArg1: EncodeLike<K1>, KArg2: EncodeLike<K2>>(k1: KArg1, k2: KArg2, q: Self::Query) {
+		match G::from_query_to_optional_value(q) {
+			Some(v) => Self::insert(k1, k2, v),
+			None => Self::remove(k1, k2),
+		}
+	}
+
+	fn take<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Self::Query
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+	{
+		let final_key = Self::storage_double_map_final_key(k1, k2);
+
+		let value = unhashed::take(&final_key);
+		G::from_optional_value_to_query(value)
+	}
+
+	fn swap<XKArg1, XKArg2, YKArg1, YKArg2>(x_k1: XKArg1, x_k2: XKArg2, y_k1: YKArg1, y_k2: YKArg2)
+	where
+		XKArg1: EncodeLike<K1>,
+		XKArg2: EncodeLike<K2>,
+		YKArg1: EncodeLike<K1>,
+		YKArg2: EncodeLike<K2>,
+	{
+		let final_x_key = Self::storage_double_map_final_key(x_k1, x_k2);
+		let final_y_key = Self::storage_double_map_final_key(y_k1, y_k2);
+
+		let v1 = unhashed::get_raw(&final_x_key);
+		if let Some(val) = unhashed::get_raw(&final_y_key) {
+			unhashed::put_raw(&final_x_key, &val);
+		} else {
+			unhashed::kill(&final_x_key)
+		}
+		if let Some(val) = v1 {
+			unhashed::put_raw(&final_y_key, &val);
+		} else {
+			unhashed::kill(&final_y_key)
+		}
+	}
+
+	fn insert<KArg1, KArg2, VArg>(k1: KArg1, k2: KArg2, val: VArg)
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		VArg: EncodeLike<V>,
+	{
+		unhashed::put(&Self::storage_double_map_final_key(k1, k2), &val)
+	}
+
+	fn remove<KArg1, KArg2>(k1: KArg1, k2: KArg2)
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+	{
+		unhashed::kill(&Self::storage_double_map_final_key(k1, k2))
+	}
+
+	fn remove_prefix<KArg1>(k1: KArg1, maybe_limit: Option<u32>) -> sp_io::KillStorageResult
+	where
+		KArg1: EncodeLike<K1>,
+	{
+		unhashed::clear_prefix(Self::storage_double_map_final_key1(k1).as_ref(), maybe_limit, None)
+			.into()
+	}
+
+	fn clear_prefix<KArg1>(
+		k1: KArg1,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::MultiRemovalResults
+	where
+		KArg1: EncodeLike<K1>,
+	{
+		unhashed::clear_prefix(
+			Self::storage_double_map_final_key1(k1).as_ref(),
+			Some(limit),
+			maybe_cursor,
+		)
+		.into()
+	}
+
+	fn contains_prefix<KArg1>(k1: KArg1) -> bool
+	where
+		KArg1: EncodeLike<K1>,
+	{
+		unhashed::contains_prefixed_key(Self::storage_double_map_final_key1(k1).as_ref())
+	}
+
+	fn iter_prefix_values<KArg1>(k1: KArg1) -> storage::PrefixIterator<V>
+	where
+		KArg1: ?Sized + EncodeLike<K1>,
+	{
+		let prefix = Self::storage_double_map_final_key1(k1);
+		storage::PrefixIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |_raw_key, mut raw_value| V::decode(&mut raw_value),
+			phantom: Default::default(),
+		}
+	}
+
+	fn mutate<KArg1, KArg2, R, F>(k1: KArg1, k2: KArg2, f: F) -> R
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Self::Query) -> R,
+	{
+		Self::try_mutate(k1, k2, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	fn mutate_exists<KArg1, KArg2, R, F>(k1: KArg1, k2: KArg2, f: F) -> R
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Option<V>) -> R,
+	{
+		Self::try_mutate_exists(k1, k2, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	fn try_mutate<KArg1, KArg2, R, E, F>(k1: KArg1, k2: KArg2, f: F) -> Result<R, E>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Self::Query) -> Result<R, E>,
+	{
+		let final_key = Self::storage_double_map_final_key(k1, k2);
+		let mut val = G::from_optional_value_to_query(unhashed::get(final_key.as_ref()));
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match G::from_query_to_optional_value(val) {
+				Some(ref val) => unhashed::put(final_key.as_ref(), val),
+				None => unhashed::kill(final_key.as_ref()),
+			}
+		}
+		ret
+	}
+
+	fn try_mutate_exists<KArg1, KArg2, R, E, F>(k1: KArg1, k2: KArg2, f: F) -> Result<R, E>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Option<V>) -> Result<R, E>,
+	{
+		let final_key = Self::storage_double_map_final_key(k1, k2);
+		let mut val = unhashed::get(final_key.as_ref());
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match val {
+				Some(ref val) => unhashed::put(final_key.as_ref(), val),
+				None => unhashed::kill(final_key.as_ref()),
+			}
+		}
+		ret
+	}
+
+	fn append<Item, EncodeLikeItem, KArg1, KArg2>(k1: KArg1, k2: KArg2, item: EncodeLikeItem)
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		V: StorageAppend<Item>,
+	{
+		let final_key = Self::storage_double_map_final_key(k1, k2);
+		sp_io::storage::append(&final_key, item.encode());
+	}
+
+	fn migrate_keys<
+		OldHasher1: StorageHasher,
+		OldHasher2: StorageHasher,
+		KeyArg1: EncodeLike<K1>,
+		KeyArg2: EncodeLike<K2>,
+	>(
+		key1: KeyArg1,
+		key2: KeyArg2,
+	) -> Option<V> {
+		let old_key = {
+			let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+
+			let key1_hashed = key1.using_encoded(OldHasher1::hash);
+			let key2_hashed = key2.using_encoded(OldHasher2::hash);
+
+			let mut final_key = Vec::with_capacity(
+				storage_prefix.len() + key1_hashed.as_ref().len() + key2_hashed.as_ref().len(),
+			);
+
+			final_key.extend_from_slice(&storage_prefix);
+			final_key.extend_from_slice(key1_hashed.as_ref());
+			final_key.extend_from_slice(key2_hashed.as_ref());
+
+			final_key
+		};
+		unhashed::take(old_key.as_ref()).map(|value| {
+			unhashed::put(Self::storage_double_map_final_key(key1, key2).as_ref(), &value);
+			value
+		})
+	}
+}
+
+impl<K1: FullCodec, K2: FullCodec, V: FullCodec, G: StorageDoubleMap<K1, K2, V>>
+	storage::IterableStorageDoubleMap<K1, K2, V> for G
+where
+	G::Hasher1: ReversibleStorageHasher,
+	G::Hasher2: ReversibleStorageHasher,
+{
+	type PartialKeyIterator = KeyPrefixIterator<K2>;
+	type PrefixIterator = PrefixIterator<(K2, V)>;
+	type FullKeyIterator = KeyPrefixIterator<(K1, K2)>;
+	type Iterator = PrefixIterator<(K1, K2, V)>;
+
+	fn iter_prefix(k1: impl EncodeLike<K1>) -> Self::PrefixIterator {
+		let prefix = G::storage_double_map_final_key1(k1);
+		Self::PrefixIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |raw_key_without_prefix, mut raw_value| {
+				let mut key_material = G::Hasher2::reverse(raw_key_without_prefix);
+				Ok((K2::decode(&mut key_material)?, V::decode(&mut raw_value)?))
+			},
+			phantom: Default::default(),
+		}
+	}
+
+	fn iter_prefix_from(
+		k1: impl EncodeLike<K1>,
+		starting_raw_key: Vec<u8>,
+	) -> Self::PrefixIterator {
+		let mut iter = Self::iter_prefix(k1);
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	fn iter_key_prefix(k1: impl EncodeLike<K1>) -> Self::PartialKeyIterator {
+		let prefix = G::storage_double_map_final_key1(k1);
+		Self::PartialKeyIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |raw_key_without_prefix| {
+				let mut key_material = G::Hasher2::reverse(raw_key_without_prefix);
+				K2::decode(&mut key_material)
+			},
+		}
+	}
+
+	fn iter_key_prefix_from(
+		k1: impl EncodeLike<K1>,
+		starting_raw_key: Vec<u8>,
+	) -> Self::PartialKeyIterator {
+		let mut iter = Self::iter_key_prefix(k1);
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	fn drain_prefix(k1: impl EncodeLike<K1>) -> Self::PrefixIterator {
+		let mut iterator = Self::iter_prefix(k1);
+		iterator.drain = true;
+		iterator
+	}
+
+	fn iter() -> Self::Iterator {
+		let prefix = G::prefix_hash();
+		Self::Iterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |raw_key_without_prefix, mut raw_value| {
+				let mut k1_k2_material = G::Hasher1::reverse(raw_key_without_prefix);
+				let k1 = K1::decode(&mut k1_k2_material)?;
+				let mut k2_material = G::Hasher2::reverse(k1_k2_material);
+				let k2 = K2::decode(&mut k2_material)?;
+				Ok((k1, k2, V::decode(&mut raw_value)?))
+			},
+			phantom: Default::default(),
+		}
+	}
+
+	fn iter_from(starting_raw_key: Vec<u8>) -> Self::Iterator {
+		let mut iter = Self::iter();
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	fn iter_keys() -> Self::FullKeyIterator {
+		let prefix = G::prefix_hash();
+		Self::FullKeyIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |raw_key_without_prefix| {
+				let mut k1_k2_material = G::Hasher1::reverse(raw_key_without_prefix);
+				let k1 = K1::decode(&mut k1_k2_material)?;
+				let mut k2_material = G::Hasher2::reverse(k1_k2_material);
+				let k2 = K2::decode(&mut k2_material)?;
+				Ok((k1, k2))
+			},
+		}
+	}
+
+	fn iter_keys_from(starting_raw_key: Vec<u8>) -> Self::FullKeyIterator {
+		let mut iter = Self::iter_keys();
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	fn drain() -> Self::Iterator {
+		let mut iterator = Self::iter();
+		iterator.drain = true;
+		iterator
+	}
+
+	fn translate<O: Decode, F: FnMut(K1, K2, O) -> Option<V>>(mut f: F) {
+		let prefix = G::prefix_hash();
+		let mut previous_key = prefix.clone();
+		while let Some(next) =
+			sp_io::storage::next_key(&previous_key).filter(|n| n.starts_with(&prefix))
+		{
+			previous_key = next;
+			let value = match unhashed::get::<O>(&previous_key) {
+				Some(value) => value,
+				None => {
+					log::error!("Invalid translate: fail to decode old value");
+					continue
+				},
+			};
+			let mut key_material = G::Hasher1::reverse(&previous_key[prefix.len()..]);
+			let key1 = match K1::decode(&mut key_material) {
+				Ok(key1) => key1,
+				Err(_) => {
+					log::error!("Invalid translate: fail to decode key1");
+					continue
+				},
+			};
+
+			let mut key2_material = G::Hasher2::reverse(key_material);
+			let key2 = match K2::decode(&mut key2_material) {
+				Ok(key2) => key2,
+				Err(_) => {
+					log::error!("Invalid translate: fail to decode key2");
+					continue
+				},
+			};
+
+			match f(key1, key2, value) {
+				Some(new) => unhashed::put::<V>(&previous_key, &new),
+				None => unhashed::kill(&previous_key),
+			}
+		}
+	}
+}
+
+/// Test iterators for StorageDoubleMap
+#[cfg(test)]
+mod test_iterators {
+	use crate::{
+		hash::StorageHasher,
+		storage::{
+			generator::{tests::*, StorageDoubleMap},
+			unhashed,
+		},
+	};
+	use codec::Encode;
+
+	#[test]
+	fn double_map_iter_from() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			use crate::hash::Identity;
+			#[crate::storage_alias]
+			type MyDoubleMap = StorageDoubleMap<MyModule, Identity, u64, Identity, u64, u64>;
+
+			MyDoubleMap::insert(1, 10, 100);
+			MyDoubleMap::insert(1, 21, 201);
+			MyDoubleMap::insert(1, 31, 301);
+			MyDoubleMap::insert(1, 41, 401);
+			MyDoubleMap::insert(2, 20, 200);
+			MyDoubleMap::insert(3, 30, 300);
+			MyDoubleMap::insert(4, 40, 400);
+			MyDoubleMap::insert(5, 50, 500);
+
+			let starting_raw_key = MyDoubleMap::storage_double_map_final_key(1, 21);
+			let iter = MyDoubleMap::iter_key_prefix_from(1, starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![31, 41]);
+
+			let starting_raw_key = MyDoubleMap::storage_double_map_final_key(1, 31);
+			let iter = MyDoubleMap::iter_prefix_from(1, starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![(41, 401)]);
+
+			let starting_raw_key = MyDoubleMap::storage_double_map_final_key(2, 20);
+			let iter = MyDoubleMap::iter_keys_from(starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![(3, 30), (4, 40), (5, 50)]);
+
+			let starting_raw_key = MyDoubleMap::storage_double_map_final_key(3, 30);
+			let iter = MyDoubleMap::iter_from(starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![(4, 40, 400), (5, 50, 500)]);
+		});
+	}
+
+	#[test]
+	fn double_map_reversible_reversible_iteration() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			type DoubleMap = self::frame_system::DoubleMap<Runtime>;
+
+			// All map iterator
+			let prefix = DoubleMap::prefix_hash();
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+
+			for i in 0..4 {
+				DoubleMap::insert(i as u16, i as u32, i as u64);
+			}
+
+			assert_eq!(
+				DoubleMap::iter().collect::<Vec<_>>(),
+				vec![(3, 3, 3), (0, 0, 0), (2, 2, 2), (1, 1, 1)],
+			);
+
+			assert_eq!(
+				DoubleMap::iter_keys().collect::<Vec<_>>(),
+				vec![(3, 3), (0, 0), (2, 2), (1, 1)],
+			);
+
+			assert_eq!(DoubleMap::iter_values().collect::<Vec<_>>(), vec![3, 0, 2, 1]);
+
+			assert_eq!(
+				DoubleMap::drain().collect::<Vec<_>>(),
+				vec![(3, 3, 3), (0, 0, 0), (2, 2, 2), (1, 1, 1)],
+			);
+
+			assert_eq!(DoubleMap::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(unhashed::get(&key_before_prefix(prefix.clone())), Some(1u64));
+			assert_eq!(unhashed::get(&key_after_prefix(prefix.clone())), Some(1u64));
+
+			// Prefix iterator
+			let k1 = 3 << 8;
+			let prefix = DoubleMap::storage_double_map_final_key1(k1);
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+
+			for i in 0..4 {
+				DoubleMap::insert(k1, i as u32, i as u64);
+			}
+
+			assert_eq!(
+				DoubleMap::iter_prefix(k1).collect::<Vec<_>>(),
+				vec![(1, 1), (2, 2), (0, 0), (3, 3)],
+			);
+
+			assert_eq!(DoubleMap::iter_key_prefix(k1).collect::<Vec<_>>(), vec![1, 2, 0, 3]);
+
+			assert_eq!(DoubleMap::iter_prefix_values(k1).collect::<Vec<_>>(), vec![1, 2, 0, 3]);
+
+			assert_eq!(
+				DoubleMap::drain_prefix(k1).collect::<Vec<_>>(),
+				vec![(1, 1), (2, 2), (0, 0), (3, 3)],
+			);
+
+			assert_eq!(DoubleMap::iter_prefix(k1).collect::<Vec<_>>(), vec![]);
+			assert_eq!(unhashed::get(&key_before_prefix(prefix.clone())), Some(1u64));
+			assert_eq!(unhashed::get(&key_after_prefix(prefix.clone())), Some(1u64));
+
+			// Translate
+			let prefix = DoubleMap::prefix_hash();
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+			for i in 0..4 {
+				DoubleMap::insert(i as u16, i as u32, i as u64);
+			}
+
+			// Wrong key1
+			unhashed::put(&[prefix.clone(), vec![1, 2, 3]].concat(), &3u64.encode());
+
+			// Wrong key2
+			unhashed::put(
+				&[prefix.clone(), crate::Blake2_128Concat::hash(&1u16.encode())].concat(),
+				&3u64.encode(),
+			);
+
+			// Wrong value
+			unhashed::put(
+				&[
+					prefix.clone(),
+					crate::Blake2_128Concat::hash(&1u16.encode()),
+					crate::Twox64Concat::hash(&2u32.encode()),
+				]
+				.concat(),
+				&vec![1],
+			);
+
+			DoubleMap::translate(|_k1, _k2, v: u64| Some(v * 2));
+			assert_eq!(
+				DoubleMap::iter().collect::<Vec<_>>(),
+				vec![(3, 3, 6), (0, 0, 0), (2, 2, 4), (1, 1, 2)],
+			);
+		})
+	}
+}
diff --git a/substrate/frame/support/src/storage/generator/map.rs b/substrate/frame/support/src/storage/generator/map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..90fac4b41c7592c29b7f38a781a39e3be186fd94
--- /dev/null
+++ b/substrate/frame/support/src/storage/generator/map.rs
@@ -0,0 +1,445 @@
+// 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::{
+	hash::{ReversibleStorageHasher, StorageHasher},
+	storage::{self, storage_prefix, unhashed, KeyPrefixIterator, PrefixIterator, StorageAppend},
+	Never,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, FullEncode};
+use sp_std::borrow::Borrow;
+#[cfg(not(feature = "std"))]
+use sp_std::prelude::*;
+
+/// Generator for `StorageMap` used by `decl_storage`.
+///
+/// By default each key value is stored at:
+/// ```nocompile
+/// Twox128(module_prefix) ++ Twox128(storage_prefix) ++ Hasher(encode(key))
+/// ```
+///
+/// # Warning
+///
+/// If the keys are not trusted (e.g. can be set by a user), a cryptographic `hasher` such as
+/// `blake2_256` must be used.  Otherwise, other values in storage can be compromised.
+pub trait StorageMap<K: FullEncode, V: FullCodec> {
+	/// The type that get/take returns.
+	type Query;
+
+	/// Hasher. Used for generating final key.
+	type Hasher: StorageHasher;
+
+	/// Module prefix. Used for generating final key.
+	fn module_prefix() -> &'static [u8];
+
+	/// Storage prefix. Used for generating final key.
+	fn storage_prefix() -> &'static [u8];
+
+	/// The full prefix; just the hash of `module_prefix` concatenated to the hash of
+	/// `storage_prefix`.
+	fn prefix_hash() -> Vec<u8> {
+		let result = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		result.to_vec()
+	}
+
+	/// Convert an optional value retrieved from storage to the type queried.
+	fn from_optional_value_to_query(v: Option<V>) -> Self::Query;
+
+	/// Convert a query to an optional value into storage.
+	fn from_query_to_optional_value(v: Self::Query) -> Option<V>;
+
+	/// Generate the full key used in top storage.
+	fn storage_map_final_key<KeyArg>(key: KeyArg) -> Vec<u8>
+	where
+		KeyArg: EncodeLike<K>,
+	{
+		let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		let key_hashed = key.using_encoded(Self::Hasher::hash);
+
+		let mut final_key = Vec::with_capacity(storage_prefix.len() + key_hashed.as_ref().len());
+
+		final_key.extend_from_slice(&storage_prefix);
+		final_key.extend_from_slice(key_hashed.as_ref());
+
+		final_key
+	}
+}
+
+/// Utility to iterate through items in a storage map.
+pub struct StorageMapIterator<K, V, Hasher> {
+	prefix: Vec<u8>,
+	previous_key: Vec<u8>,
+	drain: bool,
+	_phantom: ::sp_std::marker::PhantomData<(K, V, Hasher)>,
+}
+
+impl<K: Decode + Sized, V: Decode + Sized, Hasher: ReversibleStorageHasher> Iterator
+	for StorageMapIterator<K, V, Hasher>
+{
+	type Item = (K, V);
+
+	fn next(&mut self) -> Option<(K, V)> {
+		loop {
+			let maybe_next = sp_io::storage::next_key(&self.previous_key)
+				.filter(|n| n.starts_with(&self.prefix));
+			break match maybe_next {
+				Some(next) => {
+					self.previous_key = next;
+					match unhashed::get::<V>(&self.previous_key) {
+						Some(value) => {
+							if self.drain {
+								unhashed::kill(&self.previous_key)
+							}
+							let mut key_material =
+								Hasher::reverse(&self.previous_key[self.prefix.len()..]);
+							match K::decode(&mut key_material) {
+								Ok(key) => Some((key, value)),
+								Err(_) => continue,
+							}
+						},
+						None => continue,
+					}
+				},
+				None => None,
+			}
+		}
+	}
+}
+
+impl<K: FullCodec, V: FullCodec, G: StorageMap<K, V>> storage::IterableStorageMap<K, V> for G
+where
+	G::Hasher: ReversibleStorageHasher,
+{
+	type Iterator = PrefixIterator<(K, V)>;
+	type KeyIterator = KeyPrefixIterator<K>;
+
+	/// Enumerate all elements in the map.
+	fn iter() -> Self::Iterator {
+		let prefix = G::prefix_hash();
+		PrefixIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |raw_key_without_prefix, mut raw_value| {
+				let mut key_material = G::Hasher::reverse(raw_key_without_prefix);
+				Ok((K::decode(&mut key_material)?, V::decode(&mut raw_value)?))
+			},
+			phantom: Default::default(),
+		}
+	}
+
+	/// Enumerate all elements in the map after a given key.
+	fn iter_from(starting_raw_key: Vec<u8>) -> Self::Iterator {
+		let mut iter = Self::iter();
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	/// Enumerate all keys in the map.
+	fn iter_keys() -> Self::KeyIterator {
+		let prefix = G::prefix_hash();
+		KeyPrefixIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |raw_key_without_prefix| {
+				let mut key_material = G::Hasher::reverse(raw_key_without_prefix);
+				K::decode(&mut key_material)
+			},
+		}
+	}
+
+	/// Enumerate all keys in the map after a given key.
+	fn iter_keys_from(starting_raw_key: Vec<u8>) -> Self::KeyIterator {
+		let mut iter = Self::iter_keys();
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	/// Enumerate all elements in the map.
+	fn drain() -> Self::Iterator {
+		let mut iterator = Self::iter();
+		iterator.drain = true;
+		iterator
+	}
+
+	fn translate<O: Decode, F: FnMut(K, O) -> Option<V>>(mut f: F) {
+		let mut previous_key = None;
+		loop {
+			previous_key = Self::translate_next(previous_key, &mut f);
+			if previous_key.is_none() {
+				break
+			}
+		}
+	}
+
+	fn translate_next<O: Decode, F: FnMut(K, O) -> Option<V>>(
+		previous_key: Option<Vec<u8>>,
+		mut f: F,
+	) -> Option<Vec<u8>> {
+		let prefix = G::prefix_hash();
+		let previous_key = previous_key.unwrap_or_else(|| prefix.clone());
+
+		let current_key =
+			sp_io::storage::next_key(&previous_key).filter(|n| n.starts_with(&prefix))?;
+
+		let value = match unhashed::get::<O>(&current_key) {
+			Some(value) => value,
+			None => {
+				log::error!("Invalid translate: fail to decode old value");
+				return Some(current_key)
+			},
+		};
+
+		let mut key_material = G::Hasher::reverse(&current_key[prefix.len()..]);
+		let key = match K::decode(&mut key_material) {
+			Ok(key) => key,
+			Err(_) => {
+				log::error!("Invalid translate: fail to decode key");
+				return Some(current_key)
+			},
+		};
+
+		match f(key, value) {
+			Some(new) => unhashed::put::<V>(&current_key, &new),
+			None => unhashed::kill(&current_key),
+		}
+
+		Some(current_key)
+	}
+}
+
+impl<K: FullEncode, V: FullCodec, G: StorageMap<K, V>> storage::StorageMap<K, V> for G {
+	type Query = G::Query;
+
+	fn hashed_key_for<KeyArg: EncodeLike<K>>(key: KeyArg) -> Vec<u8> {
+		Self::storage_map_final_key(key)
+	}
+
+	fn swap<KeyArg1: EncodeLike<K>, KeyArg2: EncodeLike<K>>(key1: KeyArg1, key2: KeyArg2) {
+		let k1 = Self::storage_map_final_key(key1);
+		let k2 = Self::storage_map_final_key(key2);
+
+		let v1 = unhashed::get_raw(k1.as_ref());
+		if let Some(val) = unhashed::get_raw(k2.as_ref()) {
+			unhashed::put_raw(k1.as_ref(), &val);
+		} else {
+			unhashed::kill(k1.as_ref())
+		}
+		if let Some(val) = v1 {
+			unhashed::put_raw(k2.as_ref(), &val);
+		} else {
+			unhashed::kill(k2.as_ref())
+		}
+	}
+
+	fn contains_key<KeyArg: EncodeLike<K>>(key: KeyArg) -> bool {
+		unhashed::exists(Self::storage_map_final_key(key).as_ref())
+	}
+
+	fn get<KeyArg: EncodeLike<K>>(key: KeyArg) -> Self::Query {
+		G::from_optional_value_to_query(unhashed::get(Self::storage_map_final_key(key).as_ref()))
+	}
+
+	fn try_get<KeyArg: EncodeLike<K>>(key: KeyArg) -> Result<V, ()> {
+		unhashed::get(Self::storage_map_final_key(key).as_ref()).ok_or(())
+	}
+
+	fn set<KeyArg: EncodeLike<K>>(key: KeyArg, q: Self::Query) {
+		match G::from_query_to_optional_value(q) {
+			Some(v) => Self::insert(key, v),
+			None => Self::remove(key),
+		}
+	}
+
+	fn insert<KeyArg: EncodeLike<K>, ValArg: EncodeLike<V>>(key: KeyArg, val: ValArg) {
+		unhashed::put(Self::storage_map_final_key(key).as_ref(), &val)
+	}
+
+	fn remove<KeyArg: EncodeLike<K>>(key: KeyArg) {
+		unhashed::kill(Self::storage_map_final_key(key).as_ref())
+	}
+
+	fn mutate<KeyArg: EncodeLike<K>, R, F: FnOnce(&mut Self::Query) -> R>(key: KeyArg, f: F) -> R {
+		Self::try_mutate(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	fn mutate_exists<KeyArg: EncodeLike<K>, R, F: FnOnce(&mut Option<V>) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		Self::try_mutate_exists(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	fn try_mutate<KeyArg: EncodeLike<K>, R, E, F: FnOnce(&mut Self::Query) -> Result<R, E>>(
+		key: KeyArg,
+		f: F,
+	) -> Result<R, E> {
+		let final_key = Self::storage_map_final_key(key);
+		let mut val = G::from_optional_value_to_query(unhashed::get(final_key.as_ref()));
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match G::from_query_to_optional_value(val) {
+				Some(ref val) => unhashed::put(final_key.as_ref(), &val.borrow()),
+				None => unhashed::kill(final_key.as_ref()),
+			}
+		}
+		ret
+	}
+
+	fn try_mutate_exists<KeyArg: EncodeLike<K>, R, E, F: FnOnce(&mut Option<V>) -> Result<R, E>>(
+		key: KeyArg,
+		f: F,
+	) -> Result<R, E> {
+		let final_key = Self::storage_map_final_key(key);
+		let mut val = unhashed::get(final_key.as_ref());
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match val {
+				Some(ref val) => unhashed::put(final_key.as_ref(), &val.borrow()),
+				None => unhashed::kill(final_key.as_ref()),
+			}
+		}
+		ret
+	}
+
+	fn take<KeyArg: EncodeLike<K>>(key: KeyArg) -> Self::Query {
+		let key = Self::storage_map_final_key(key);
+		let value = unhashed::take(key.as_ref());
+		G::from_optional_value_to_query(value)
+	}
+
+	fn append<Item, EncodeLikeItem, EncodeLikeKey>(key: EncodeLikeKey, item: EncodeLikeItem)
+	where
+		EncodeLikeKey: EncodeLike<K>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		V: StorageAppend<Item>,
+	{
+		let key = Self::storage_map_final_key(key);
+		sp_io::storage::append(&key, item.encode());
+	}
+
+	fn migrate_key<OldHasher: StorageHasher, KeyArg: EncodeLike<K>>(key: KeyArg) -> Option<V> {
+		let old_key = {
+			let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+			let key_hashed = key.using_encoded(OldHasher::hash);
+
+			let mut final_key =
+				Vec::with_capacity(storage_prefix.len() + key_hashed.as_ref().len());
+
+			final_key.extend_from_slice(&storage_prefix);
+			final_key.extend_from_slice(key_hashed.as_ref());
+
+			final_key
+		};
+		unhashed::take(old_key.as_ref()).map(|value| {
+			unhashed::put(Self::storage_map_final_key(key).as_ref(), &value);
+			value
+		})
+	}
+}
+
+/// Test iterators for StorageMap
+#[cfg(test)]
+mod test_iterators {
+	use crate::{
+		hash::StorageHasher,
+		storage::{
+			generator::{tests::*, StorageMap},
+			unhashed,
+		},
+	};
+	use codec::Encode;
+
+	#[test]
+	fn map_iter_from() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			use crate::hash::Identity;
+			#[crate::storage_alias]
+			type MyMap = StorageMap<MyModule, Identity, u64, u64>;
+
+			MyMap::insert(1, 10);
+			MyMap::insert(2, 20);
+			MyMap::insert(3, 30);
+			MyMap::insert(4, 40);
+			MyMap::insert(5, 50);
+
+			let starting_raw_key = MyMap::storage_map_final_key(3);
+			let iter = MyMap::iter_from(starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![(4, 40), (5, 50)]);
+
+			let starting_raw_key = MyMap::storage_map_final_key(2);
+			let iter = MyMap::iter_keys_from(starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![3, 4, 5]);
+		});
+	}
+
+	#[test]
+	fn map_reversible_reversible_iteration() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			type Map = self::frame_system::Map<Runtime>;
+
+			// All map iterator
+			let prefix = Map::prefix_hash();
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+
+			for i in 0..4 {
+				Map::insert(i as u16, i as u64);
+			}
+
+			assert_eq!(Map::iter().collect::<Vec<_>>(), vec![(3, 3), (0, 0), (2, 2), (1, 1)]);
+
+			assert_eq!(Map::iter_keys().collect::<Vec<_>>(), vec![3, 0, 2, 1]);
+
+			assert_eq!(Map::iter_values().collect::<Vec<_>>(), vec![3, 0, 2, 1]);
+
+			assert_eq!(Map::drain().collect::<Vec<_>>(), vec![(3, 3), (0, 0), (2, 2), (1, 1)]);
+
+			assert_eq!(Map::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(unhashed::get(&key_before_prefix(prefix.clone())), Some(1u64));
+			assert_eq!(unhashed::get(&key_after_prefix(prefix.clone())), Some(1u64));
+
+			// Translate
+			let prefix = Map::prefix_hash();
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+			for i in 0..4 {
+				Map::insert(i as u16, i as u64);
+			}
+
+			// Wrong key
+			unhashed::put(&[prefix.clone(), vec![1, 2, 3]].concat(), &3u64.encode());
+
+			// Wrong value
+			unhashed::put(
+				&[prefix.clone(), crate::Blake2_128Concat::hash(&6u16.encode())].concat(),
+				&vec![1],
+			);
+
+			Map::translate(|_k1, v: u64| Some(v * 2));
+			assert_eq!(Map::iter().collect::<Vec<_>>(), vec![(3, 6), (0, 0), (2, 4), (1, 2)]);
+		})
+	}
+}
diff --git a/substrate/frame/support/src/storage/generator/mod.rs b/substrate/frame/support/src/storage/generator/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bac9f642e37d6d5c01f7ed6cc1301d30e90bd6b9
--- /dev/null
+++ b/substrate/frame/support/src/storage/generator/mod.rs
@@ -0,0 +1,265 @@
+// 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.
+
+//! Generators are a set of trait on which storage traits are implemented.
+//!
+//! (i.e. implementing the generator for StorageValue on a type will automatically derive the
+//! implementation of StorageValue for this type).
+//!
+//! They are used by `decl_storage`.
+//!
+//! This is internal api and is subject to change.
+
+mod double_map;
+pub(crate) mod map;
+mod nmap;
+mod value;
+
+pub use double_map::StorageDoubleMap;
+pub use map::StorageMap;
+pub use nmap::StorageNMap;
+pub use value::StorageValue;
+
+#[cfg(test)]
+mod tests {
+	use codec::Encode;
+	use sp_io::TestExternalities;
+	use sp_runtime::{generic, traits::BlakeTwo256, BuildStorage};
+
+	use crate::{
+		assert_noop, assert_ok,
+		storage::{generator::StorageValue, unhashed},
+	};
+
+	#[crate::pallet]
+	pub mod frame_system {
+		#[allow(unused)]
+		use super::{frame_system, frame_system::pallet_prelude::*};
+		pub use crate::dispatch::RawOrigin;
+		use crate::pallet_prelude::*;
+
+		#[pallet::pallet]
+		pub struct Pallet<T>(_);
+
+		#[pallet::config]
+		#[pallet::disable_frame_system_supertrait_check]
+		pub trait Config: 'static {
+			type Block: sp_runtime::traits::Block;
+			type AccountId;
+			type BaseCallFilter: crate::traits::Contains<Self::RuntimeCall>;
+			type RuntimeOrigin;
+			type RuntimeCall;
+			type PalletInfo: crate::traits::PalletInfo;
+			type DbWeight: Get<crate::weights::RuntimeDbWeight>;
+		}
+
+		#[pallet::origin]
+		pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
+
+		#[pallet::error]
+		pub enum Error<T> {
+			/// Required by construct_runtime
+			CallFiltered,
+		}
+
+		#[pallet::call]
+		impl<T: Config> Pallet<T> {}
+
+		#[pallet::storage]
+		pub type Value<T> = StorageValue<_, (u64, u64), ValueQuery>;
+
+		#[pallet::storage]
+		pub type Map<T> = StorageMap<_, Blake2_128Concat, u16, u64, ValueQuery>;
+
+		#[pallet::storage]
+		pub type NumberMap<T> = StorageMap<_, Identity, u32, u64, ValueQuery>;
+
+		#[pallet::storage]
+		pub type DoubleMap<T> =
+			StorageDoubleMap<_, Blake2_128Concat, u16, Twox64Concat, u32, u64, ValueQuery>;
+
+		#[pallet::storage]
+		pub type NMap<T> = StorageNMap<
+			_,
+			(storage::Key<Blake2_128Concat, u16>, storage::Key<Twox64Concat, u32>),
+			u64,
+			ValueQuery,
+		>;
+
+		pub mod pallet_prelude {
+			pub type OriginFor<T> = <T as super::Config>::RuntimeOrigin;
+
+			pub type HeaderFor<T> =
+				<<T as super::Config>::Block as sp_runtime::traits::HeaderProvider>::HeaderT;
+
+			pub type BlockNumberFor<T> = <HeaderFor<T> as sp_runtime::traits::Header>::Number;
+		}
+	}
+
+	type BlockNumber = u32;
+	type AccountId = u32;
+	type Header = generic::Header<BlockNumber, BlakeTwo256>;
+	type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+	type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+	crate::construct_runtime!(
+		pub enum Runtime
+		{
+			System: self::frame_system,
+		}
+	);
+
+	impl self::frame_system::Config for Runtime {
+		type AccountId = AccountId;
+		type Block = Block;
+		type BaseCallFilter = crate::traits::Everything;
+		type RuntimeOrigin = RuntimeOrigin;
+		type RuntimeCall = RuntimeCall;
+		type PalletInfo = PalletInfo;
+		type DbWeight = ();
+	}
+
+	pub fn key_before_prefix(mut prefix: Vec<u8>) -> Vec<u8> {
+		let last = prefix.iter_mut().last().unwrap();
+		assert_ne!(*last, 0, "mock function not implemented for this prefix");
+		*last -= 1;
+		prefix
+	}
+
+	pub fn key_after_prefix(mut prefix: Vec<u8>) -> Vec<u8> {
+		let last = prefix.iter_mut().last().unwrap();
+		assert_ne!(*last, 255, "mock function not implemented for this prefix");
+		*last += 1;
+		prefix
+	}
+
+	#[test]
+	fn value_translate_works() {
+		let t = RuntimeGenesisConfig::default().build_storage().unwrap();
+		TestExternalities::new(t).execute_with(|| {
+			type Value = self::frame_system::Value<Runtime>;
+
+			// put the old value `1111u32` in the storage.
+			let key = Value::storage_value_final_key();
+			unhashed::put_raw(&key, &1111u32.encode());
+
+			// translate
+			let translate_fn = |old: Option<u32>| -> Option<(u64, u64)> {
+				old.map(|o| (o.into(), (o * 2).into()))
+			};
+			let res = Value::translate(translate_fn);
+			debug_assert!(res.is_ok());
+
+			// new storage should be `(1111, 1111 * 2)`
+			assert_eq!(Value::get(), (1111, 2222));
+		})
+	}
+
+	#[test]
+	fn map_translate_works() {
+		let t = RuntimeGenesisConfig::default().build_storage().unwrap();
+		TestExternalities::new(t).execute_with(|| {
+			type NumberMap = self::frame_system::NumberMap<Runtime>;
+
+			// start with a map of u32 -> u64.
+			for i in 0u32..100u32 {
+				unhashed::put(&NumberMap::hashed_key_for(&i), &(i as u64));
+			}
+
+			assert_eq!(
+				NumberMap::iter().collect::<Vec<_>>(),
+				(0..100).map(|x| (x as u32, x as u64)).collect::<Vec<_>>(),
+			);
+
+			// do translation.
+			NumberMap::translate(
+				|k: u32, v: u64| if k % 2 == 0 { Some((k as u64) << 32 | v) } else { None },
+			);
+
+			assert_eq!(
+				NumberMap::iter().collect::<Vec<_>>(),
+				(0..50u32)
+					.map(|x| x * 2)
+					.map(|x| (x, (x as u64) << 32 | x as u64))
+					.collect::<Vec<_>>(),
+			);
+		})
+	}
+
+	#[test]
+	fn try_mutate_works() {
+		let t = RuntimeGenesisConfig::default().build_storage().unwrap();
+		TestExternalities::new(t).execute_with(|| {
+			type Value = self::frame_system::Value<Runtime>;
+			type NumberMap = self::frame_system::NumberMap<Runtime>;
+			type DoubleMap = self::frame_system::DoubleMap<Runtime>;
+
+			assert_eq!(Value::get(), (0, 0));
+			assert_eq!(NumberMap::get(0), 0);
+			assert_eq!(DoubleMap::get(0, 0), 0);
+
+			// `assert_noop` ensures that the state does not change
+			assert_noop!(
+				Value::try_mutate(|value| -> Result<(), &'static str> {
+					*value = (2, 2);
+					Err("don't change value")
+				}),
+				"don't change value"
+			);
+
+			assert_noop!(
+				NumberMap::try_mutate(0, |value| -> Result<(), &'static str> {
+					*value = 4;
+					Err("don't change value")
+				}),
+				"don't change value"
+			);
+
+			assert_noop!(
+				DoubleMap::try_mutate(0, 0, |value| -> Result<(), &'static str> {
+					*value = 6;
+					Err("don't change value")
+				}),
+				"don't change value"
+			);
+
+			// Showing this explicitly for clarity
+			assert_eq!(Value::get(), (0, 0));
+			assert_eq!(NumberMap::get(0), 0);
+			assert_eq!(DoubleMap::get(0, 0), 0);
+
+			assert_ok!(Value::try_mutate(|value| -> Result<(), &'static str> {
+				*value = (2, 2);
+				Ok(())
+			}));
+
+			assert_ok!(NumberMap::try_mutate(0, |value| -> Result<(), &'static str> {
+				*value = 4;
+				Ok(())
+			}));
+
+			assert_ok!(DoubleMap::try_mutate(0, 0, |value| -> Result<(), &'static str> {
+				*value = 6;
+				Ok(())
+			}));
+
+			assert_eq!(Value::get(), (2, 2));
+			assert_eq!(NumberMap::get(0), 4);
+			assert_eq!(DoubleMap::get(0, 0), 6);
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/generator/nmap.rs b/substrate/frame/support/src/storage/generator/nmap.rs
new file mode 100755
index 0000000000000000000000000000000000000000..5d3d689aa98a6f378666333677df77197fbc4e04
--- /dev/null
+++ b/substrate/frame/support/src/storage/generator/nmap.rs
@@ -0,0 +1,632 @@
+// 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.
+
+//! Generator for `StorageNMap` used by `decl_storage` and storage types.
+//!
+//! By default each key value is stored at:
+//! ```nocompile
+//! Twox128(pallet_prefix) ++ Twox128(storage_prefix)
+//!     ++ Hasher1(encode(key1)) ++ Hasher2(encode(key2)) ++ ... ++ HasherN(encode(keyN))
+//! ```
+//!
+//! # Warning
+//!
+//! If the keys are not trusted (e.g. can be set by a user), a cryptographic `hasher` such as
+//! `blake2_256` must be used.  Otherwise, other values in storage with the same prefix can
+//! be compromised.
+
+use crate::{
+	storage::{
+		self, storage_prefix,
+		types::{
+			EncodeLikeTuple, HasKeyPrefix, HasReversibleKeyPrefix, KeyGenerator,
+			ReversibleKeyGenerator, TupleToEncodedIter,
+		},
+		unhashed, KeyPrefixIterator, PrefixIterator, StorageAppend,
+	},
+	Never,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec};
+#[cfg(not(feature = "std"))]
+use sp_std::prelude::*;
+
+/// Generator for `StorageNMap` used by `decl_storage` and storage types.
+///
+/// By default each key value is stored at:
+/// ```nocompile
+/// Twox128(pallet_prefix) ++ Twox128(storage_prefix)
+///     ++ Hasher1(encode(key1)) ++ Hasher2(encode(key2)) ++ ... ++ HasherN(encode(keyN))
+/// ```
+///
+/// # Warning
+///
+/// If the keys are not trusted (e.g. can be set by a user), a cryptographic `hasher` such as
+/// `blake2_256` must be used.  Otherwise, other values in storage with the same prefix can
+/// be compromised.
+pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
+	/// The type that get/take returns.
+	type Query;
+
+	/// Module prefix. Used for generating final key.
+	fn module_prefix() -> &'static [u8];
+
+	/// Storage prefix. Used for generating final key.
+	fn storage_prefix() -> &'static [u8];
+
+	/// The full prefix; just the hash of `module_prefix` concatenated to the hash of
+	/// `storage_prefix`.
+	fn prefix_hash() -> Vec<u8> {
+		let result = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		result.to_vec()
+	}
+
+	/// Convert an optional value retrieved from storage to the type queried.
+	fn from_optional_value_to_query(v: Option<V>) -> Self::Query;
+
+	/// Convert a query to an optional value into storage.
+	fn from_query_to_optional_value(v: Self::Query) -> Option<V>;
+
+	/// Generate a partial key used in top storage.
+	fn storage_n_map_partial_key<KP>(key: KP) -> Vec<u8>
+	where
+		K: HasKeyPrefix<KP>,
+	{
+		let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		let key_hashed = <K as HasKeyPrefix<KP>>::partial_key(key);
+
+		let mut final_key = Vec::with_capacity(storage_prefix.len() + key_hashed.len());
+
+		final_key.extend_from_slice(&storage_prefix);
+		final_key.extend_from_slice(key_hashed.as_ref());
+
+		final_key
+	}
+
+	/// Generate the full key used in top storage.
+	fn storage_n_map_final_key<KG, KArg>(key: KArg) -> Vec<u8>
+	where
+		KG: KeyGenerator,
+		KArg: EncodeLikeTuple<KG::KArg> + TupleToEncodedIter,
+	{
+		let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+		let key_hashed = KG::final_key(key);
+
+		let mut final_key = Vec::with_capacity(storage_prefix.len() + key_hashed.len());
+
+		final_key.extend_from_slice(&storage_prefix);
+		final_key.extend_from_slice(key_hashed.as_ref());
+
+		final_key
+	}
+}
+
+impl<K, V, G> storage::StorageNMap<K, V> for G
+where
+	K: KeyGenerator,
+	V: FullCodec,
+	G: StorageNMap<K, V>,
+{
+	type Query = G::Query;
+
+	fn hashed_key_for<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
+		Self::storage_n_map_final_key::<K, _>(key)
+	}
+
+	fn contains_key<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> bool {
+		unhashed::exists(&Self::storage_n_map_final_key::<K, _>(key))
+	}
+
+	fn get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query {
+		G::from_optional_value_to_query(unhashed::get(&Self::storage_n_map_final_key::<K, _>(key)))
+	}
+
+	fn try_get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Result<V, ()> {
+		unhashed::get(&Self::storage_n_map_final_key::<K, _>(key)).ok_or(())
+	}
+
+	fn set<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg, q: Self::Query) {
+		match G::from_query_to_optional_value(q) {
+			Some(v) => Self::insert(key, v),
+			None => Self::remove(key),
+		}
+	}
+
+	fn take<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query {
+		let final_key = Self::storage_n_map_final_key::<K, _>(key);
+
+		let value = unhashed::take(&final_key);
+		G::from_optional_value_to_query(value)
+	}
+
+	fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
+	where
+		KOther: KeyGenerator,
+		KArg1: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		KArg2: EncodeLikeTuple<KOther::KArg> + TupleToEncodedIter,
+	{
+		let final_x_key = Self::storage_n_map_final_key::<K, _>(key1);
+		let final_y_key = Self::storage_n_map_final_key::<KOther, _>(key2);
+
+		let v1 = unhashed::get_raw(&final_x_key);
+		if let Some(val) = unhashed::get_raw(&final_y_key) {
+			unhashed::put_raw(&final_x_key, &val);
+		} else {
+			unhashed::kill(&final_x_key);
+		}
+		if let Some(val) = v1 {
+			unhashed::put_raw(&final_y_key, &val);
+		} else {
+			unhashed::kill(&final_y_key);
+		}
+	}
+
+	fn insert<KArg, VArg>(key: KArg, val: VArg)
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		VArg: EncodeLike<V>,
+	{
+		unhashed::put(&Self::storage_n_map_final_key::<K, _>(key), &val);
+	}
+
+	fn remove<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) {
+		unhashed::kill(&Self::storage_n_map_final_key::<K, _>(key));
+	}
+
+	fn remove_prefix<KP>(partial_key: KP, limit: Option<u32>) -> sp_io::KillStorageResult
+	where
+		K: HasKeyPrefix<KP>,
+	{
+		unhashed::clear_prefix(&Self::storage_n_map_partial_key(partial_key), limit, None).into()
+	}
+
+	fn clear_prefix<KP>(
+		partial_key: KP,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::MultiRemovalResults
+	where
+		K: HasKeyPrefix<KP>,
+	{
+		unhashed::clear_prefix(
+			&Self::storage_n_map_partial_key(partial_key),
+			Some(limit),
+			maybe_cursor,
+		)
+	}
+
+	fn contains_prefix<KP>(partial_key: KP) -> bool
+	where
+		K: HasKeyPrefix<KP>,
+	{
+		unhashed::contains_prefixed_key(&Self::storage_n_map_partial_key(partial_key))
+	}
+
+	fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<V>
+	where
+		K: HasKeyPrefix<KP>,
+	{
+		let prefix = Self::storage_n_map_partial_key(partial_key);
+		PrefixIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |_raw_key, mut raw_value| V::decode(&mut raw_value),
+			phantom: Default::default(),
+		}
+	}
+
+	fn mutate<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Self::Query) -> R,
+	{
+		Self::try_mutate(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	fn try_mutate<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Self::Query) -> Result<R, E>,
+	{
+		let final_key = Self::storage_n_map_final_key::<K, _>(key);
+		let mut val = G::from_optional_value_to_query(unhashed::get(final_key.as_ref()));
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match G::from_query_to_optional_value(val) {
+				Some(ref val) => unhashed::put(final_key.as_ref(), val),
+				None => unhashed::kill(final_key.as_ref()),
+			}
+		}
+		ret
+	}
+
+	fn mutate_exists<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<V>) -> R,
+	{
+		Self::try_mutate_exists(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	fn try_mutate_exists<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<V>) -> Result<R, E>,
+	{
+		let final_key = Self::storage_n_map_final_key::<K, _>(key);
+		let mut val = unhashed::get(final_key.as_ref());
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match val {
+				Some(ref val) => unhashed::put(final_key.as_ref(), val),
+				None => unhashed::kill(final_key.as_ref()),
+			}
+		}
+		ret
+	}
+
+	fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		V: StorageAppend<Item>,
+	{
+		let final_key = Self::storage_n_map_final_key::<K, _>(key);
+		sp_io::storage::append(&final_key, item.encode());
+	}
+
+	fn migrate_keys<KArg>(key: KArg, hash_fns: K::HArg) -> Option<V>
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+	{
+		let old_key = {
+			let storage_prefix = storage_prefix(Self::module_prefix(), Self::storage_prefix());
+			let key_hashed = K::migrate_key(&key, hash_fns);
+
+			let mut final_key = Vec::with_capacity(storage_prefix.len() + key_hashed.len());
+
+			final_key.extend_from_slice(&storage_prefix);
+			final_key.extend_from_slice(key_hashed.as_ref());
+
+			final_key
+		};
+		unhashed::take(old_key.as_ref()).map(|value| {
+			unhashed::put(Self::storage_n_map_final_key::<K, _>(key).as_ref(), &value);
+			value
+		})
+	}
+}
+
+impl<K: ReversibleKeyGenerator, V: FullCodec, G: StorageNMap<K, V>>
+	storage::IterableStorageNMap<K, V> for G
+{
+	type KeyIterator = KeyPrefixIterator<K::Key>;
+	type Iterator = PrefixIterator<(K::Key, V)>;
+
+	fn iter_prefix<KP>(kp: KP) -> PrefixIterator<(<K as HasKeyPrefix<KP>>::Suffix, V)>
+	where
+		K: HasReversibleKeyPrefix<KP>,
+	{
+		let prefix = G::storage_n_map_partial_key(kp);
+		PrefixIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: |raw_key_without_prefix, mut raw_value| {
+				let partial_key = K::decode_partial_key(raw_key_without_prefix)?;
+				Ok((partial_key, V::decode(&mut raw_value)?))
+			},
+			phantom: Default::default(),
+		}
+	}
+
+	fn iter_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> PrefixIterator<(<K as HasKeyPrefix<KP>>::Suffix, V)>
+	where
+		K: HasReversibleKeyPrefix<KP>,
+	{
+		let mut iter = Self::iter_prefix(kp);
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	fn iter_key_prefix<KP>(kp: KP) -> KeyPrefixIterator<<K as HasKeyPrefix<KP>>::Suffix>
+	where
+		K: HasReversibleKeyPrefix<KP>,
+	{
+		let prefix = G::storage_n_map_partial_key(kp);
+		KeyPrefixIterator {
+			prefix: prefix.clone(),
+			previous_key: prefix,
+			drain: false,
+			closure: K::decode_partial_key,
+		}
+	}
+
+	fn iter_key_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> KeyPrefixIterator<<K as HasKeyPrefix<KP>>::Suffix>
+	where
+		K: HasReversibleKeyPrefix<KP>,
+	{
+		let mut iter = Self::iter_key_prefix(kp);
+		iter.set_last_raw_key(starting_raw_key);
+		iter
+	}
+
+	fn drain_prefix<KP>(kp: KP) -> PrefixIterator<(<K as HasKeyPrefix<KP>>::Suffix, V)>
+	where
+		K: HasReversibleKeyPrefix<KP>,
+	{
+		let mut iter = Self::iter_prefix(kp);
+		iter.drain = true;
+		iter
+	}
+
+	fn iter() -> Self::Iterator {
+		Self::iter_from(G::prefix_hash())
+	}
+
+	fn iter_from(starting_raw_key: Vec<u8>) -> Self::Iterator {
+		let prefix = G::prefix_hash();
+		Self::Iterator {
+			prefix,
+			previous_key: starting_raw_key,
+			drain: false,
+			closure: |raw_key_without_prefix, mut raw_value| {
+				let (final_key, _) = K::decode_final_key(raw_key_without_prefix)?;
+				Ok((final_key, V::decode(&mut raw_value)?))
+			},
+			phantom: Default::default(),
+		}
+	}
+
+	fn iter_keys() -> Self::KeyIterator {
+		Self::iter_keys_from(G::prefix_hash())
+	}
+
+	fn iter_keys_from(starting_raw_key: Vec<u8>) -> Self::KeyIterator {
+		let prefix = G::prefix_hash();
+		Self::KeyIterator {
+			prefix,
+			previous_key: starting_raw_key,
+			drain: false,
+			closure: |raw_key_without_prefix| {
+				let (final_key, _) = K::decode_final_key(raw_key_without_prefix)?;
+				Ok(final_key)
+			},
+		}
+	}
+
+	fn drain() -> Self::Iterator {
+		let mut iterator = Self::iter();
+		iterator.drain = true;
+		iterator
+	}
+
+	fn translate<O: Decode, F: FnMut(K::Key, O) -> Option<V>>(mut f: F) {
+		let prefix = G::prefix_hash();
+		let mut previous_key = prefix.clone();
+		while let Some(next) =
+			sp_io::storage::next_key(&previous_key).filter(|n| n.starts_with(&prefix))
+		{
+			previous_key = next;
+			let value = match unhashed::get::<O>(&previous_key) {
+				Some(value) => value,
+				None => {
+					log::error!("Invalid translate: fail to decode old value");
+					continue
+				},
+			};
+
+			let final_key = match K::decode_final_key(&previous_key[prefix.len()..]) {
+				Ok((final_key, _)) => final_key,
+				Err(_) => {
+					log::error!("Invalid translate: fail to decode key");
+					continue
+				},
+			};
+
+			match f(final_key, value) {
+				Some(new) => unhashed::put::<V>(&previous_key, &new),
+				None => unhashed::kill(&previous_key),
+			}
+		}
+	}
+}
+
+/// Test iterators for StorageNMap
+#[cfg(test)]
+mod test_iterators {
+	use crate::{
+		hash::StorageHasher,
+		storage::{
+			generator::{tests::*, StorageNMap},
+			unhashed,
+		},
+	};
+	use codec::Encode;
+
+	#[test]
+	fn n_map_iter_from() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			use crate::{hash::Identity, storage::Key as NMapKey};
+			#[crate::storage_alias]
+			type MyNMap = StorageNMap<
+				MyModule,
+				(NMapKey<Identity, u64>, NMapKey<Identity, u64>, NMapKey<Identity, u64>),
+				u64,
+			>;
+
+			MyNMap::insert((1, 1, 1), 11);
+			MyNMap::insert((1, 1, 2), 21);
+			MyNMap::insert((1, 1, 3), 31);
+			MyNMap::insert((1, 2, 1), 12);
+			MyNMap::insert((1, 2, 2), 22);
+			MyNMap::insert((1, 2, 3), 32);
+			MyNMap::insert((1, 3, 1), 13);
+			MyNMap::insert((1, 3, 2), 23);
+			MyNMap::insert((1, 3, 3), 33);
+			MyNMap::insert((2, 0, 0), 200);
+
+			type Key = (NMapKey<Identity, u64>, NMapKey<Identity, u64>, NMapKey<Identity, u64>);
+
+			let starting_raw_key = MyNMap::storage_n_map_final_key::<Key, _>((1, 2, 2));
+			let iter = MyNMap::iter_key_prefix_from((1,), starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![(2, 3), (3, 1), (3, 2), (3, 3)]);
+
+			let starting_raw_key = MyNMap::storage_n_map_final_key::<Key, _>((1, 3, 1));
+			let iter = MyNMap::iter_prefix_from((1, 3), starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![(2, 23), (3, 33)]);
+
+			let starting_raw_key = MyNMap::storage_n_map_final_key::<Key, _>((1, 3, 2));
+			let iter = MyNMap::iter_keys_from(starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![(1, 3, 3), (2, 0, 0)]);
+
+			let starting_raw_key = MyNMap::storage_n_map_final_key::<Key, _>((1, 3, 3));
+			let iter = MyNMap::iter_from(starting_raw_key);
+			assert_eq!(iter.collect::<Vec<_>>(), vec![((2, 0, 0), 200)]);
+		});
+	}
+
+	#[test]
+	fn n_map_double_map_identical_key() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			use crate::hash::{Blake2_128Concat, Twox64Concat};
+
+			type NMap = self::frame_system::NMap<Runtime>;
+
+			NMap::insert((1, 2), 50);
+			let key_hash = NMap::hashed_key_for((1, 2));
+
+			{
+				#[crate::storage_alias]
+				type NMap = StorageDoubleMap<System, Blake2_128Concat, u16, Twox64Concat, u32, u64>;
+
+				assert_eq!(NMap::get(1, 2), Some(50));
+				assert_eq!(NMap::hashed_key_for(1, 2), key_hash);
+			}
+		});
+	}
+
+	#[test]
+	fn n_map_reversible_reversible_iteration() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			type NMap = self::frame_system::NMap<Runtime>;
+
+			// All map iterator
+			let prefix = NMap::prefix_hash();
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+
+			for i in 0..4 {
+				NMap::insert((i as u16, i as u32), i as u64);
+			}
+
+			assert_eq!(
+				NMap::iter().collect::<Vec<_>>(),
+				vec![((3, 3), 3), ((0, 0), 0), ((2, 2), 2), ((1, 1), 1)],
+			);
+
+			assert_eq!(NMap::iter_keys().collect::<Vec<_>>(), vec![(3, 3), (0, 0), (2, 2), (1, 1)]);
+
+			assert_eq!(NMap::iter_values().collect::<Vec<_>>(), vec![3, 0, 2, 1]);
+
+			assert_eq!(
+				NMap::drain().collect::<Vec<_>>(),
+				vec![((3, 3), 3), ((0, 0), 0), ((2, 2), 2), ((1, 1), 1)],
+			);
+
+			assert_eq!(NMap::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(unhashed::get(&key_before_prefix(prefix.clone())), Some(1u64));
+			assert_eq!(unhashed::get(&key_after_prefix(prefix.clone())), Some(1u64));
+
+			// Prefix iterator
+			let k1 = 3 << 8;
+			let prefix = NMap::storage_n_map_partial_key((k1,));
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+
+			for i in 0..4 {
+				NMap::insert((k1, i as u32), i as u64);
+			}
+
+			assert_eq!(
+				NMap::iter_prefix((k1,)).collect::<Vec<_>>(),
+				vec![(1, 1), (2, 2), (0, 0), (3, 3)],
+			);
+
+			assert_eq!(NMap::iter_key_prefix((k1,)).collect::<Vec<_>>(), vec![1, 2, 0, 3]);
+
+			assert_eq!(NMap::iter_prefix_values((k1,)).collect::<Vec<_>>(), vec![1, 2, 0, 3]);
+
+			assert_eq!(
+				NMap::drain_prefix((k1,)).collect::<Vec<_>>(),
+				vec![(1, 1), (2, 2), (0, 0), (3, 3)],
+			);
+
+			assert_eq!(NMap::iter_prefix((k1,)).collect::<Vec<_>>(), vec![]);
+			assert_eq!(unhashed::get(&key_before_prefix(prefix.clone())), Some(1u64));
+			assert_eq!(unhashed::get(&key_after_prefix(prefix.clone())), Some(1u64));
+
+			// Translate
+			let prefix = NMap::prefix_hash();
+
+			unhashed::put(&key_before_prefix(prefix.clone()), &1u64);
+			unhashed::put(&key_after_prefix(prefix.clone()), &1u64);
+			for i in 0..4 {
+				NMap::insert((i as u16, i as u32), i as u64);
+			}
+
+			// Wrong key1
+			unhashed::put(&[prefix.clone(), vec![1, 2, 3]].concat(), &3u64.encode());
+
+			// Wrong key2
+			unhashed::put(
+				&[prefix.clone(), crate::Blake2_128Concat::hash(&1u16.encode())].concat(),
+				&3u64.encode(),
+			);
+
+			// Wrong value
+			unhashed::put(
+				&[
+					prefix.clone(),
+					crate::Blake2_128Concat::hash(&1u16.encode()),
+					crate::Twox64Concat::hash(&2u32.encode()),
+				]
+				.concat(),
+				&vec![1],
+			);
+
+			NMap::translate(|(_k1, _k2), v: u64| Some(v * 2));
+			assert_eq!(
+				NMap::iter().collect::<Vec<_>>(),
+				vec![((3, 3), 6), ((0, 0), 0), ((2, 2), 4), ((1, 1), 2)],
+			);
+		})
+	}
+}
diff --git a/substrate/frame/support/src/storage/generator/value.rs b/substrate/frame/support/src/storage/generator/value.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4ffe40bac53ca231f10e25cf521f3f4d7df02de3
--- /dev/null
+++ b/substrate/frame/support/src/storage/generator/value.rs
@@ -0,0 +1,163 @@
+// 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::{
+	storage::{self, unhashed, StorageAppend},
+	Never,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec};
+
+/// Generator for `StorageValue` used by `decl_storage`.
+///
+/// By default value is stored at:
+/// ```nocompile
+/// Twox128(module_prefix) ++ Twox128(storage_prefix)
+/// ```
+pub trait StorageValue<T: FullCodec> {
+	/// The type that get/take returns.
+	type Query;
+
+	/// Module prefix. Used for generating final key.
+	fn module_prefix() -> &'static [u8];
+
+	/// Storage prefix. Used for generating final key.
+	fn storage_prefix() -> &'static [u8];
+
+	/// Convert an optional value retrieved from storage to the type queried.
+	fn from_optional_value_to_query(v: Option<T>) -> Self::Query;
+
+	/// Convert a query to an optional value into storage.
+	fn from_query_to_optional_value(v: Self::Query) -> Option<T>;
+
+	/// Generate the full key used in top storage.
+	fn storage_value_final_key() -> [u8; 32] {
+		crate::storage::storage_prefix(Self::module_prefix(), Self::storage_prefix())
+	}
+}
+
+impl<T: FullCodec, G: StorageValue<T>> storage::StorageValue<T> for G {
+	type Query = G::Query;
+
+	fn hashed_key() -> [u8; 32] {
+		Self::storage_value_final_key()
+	}
+
+	fn exists() -> bool {
+		unhashed::exists(&Self::storage_value_final_key())
+	}
+
+	fn get() -> Self::Query {
+		let value = unhashed::get(&Self::storage_value_final_key());
+		G::from_optional_value_to_query(value)
+	}
+
+	fn try_get() -> Result<T, ()> {
+		unhashed::get(&Self::storage_value_final_key()).ok_or(())
+	}
+
+	fn translate<O: Decode, F: FnOnce(Option<O>) -> Option<T>>(f: F) -> Result<Option<T>, ()> {
+		let key = Self::storage_value_final_key();
+
+		// attempt to get the length directly.
+		let maybe_old = unhashed::get_raw(&key)
+			.map(|old_data| O::decode(&mut &old_data[..]).map_err(|_| ()))
+			.transpose()?;
+		let maybe_new = f(maybe_old);
+		if let Some(new) = maybe_new.as_ref() {
+			new.using_encoded(|d| unhashed::put_raw(&key, d));
+		} else {
+			unhashed::kill(&key);
+		}
+		Ok(maybe_new)
+	}
+
+	fn put<Arg: EncodeLike<T>>(val: Arg) {
+		unhashed::put(&Self::storage_value_final_key(), &val)
+	}
+
+	fn set(maybe_val: Self::Query) {
+		if let Some(val) = G::from_query_to_optional_value(maybe_val) {
+			unhashed::put(&Self::storage_value_final_key(), &val)
+		} else {
+			unhashed::kill(&Self::storage_value_final_key())
+		}
+	}
+
+	fn kill() {
+		unhashed::kill(&Self::storage_value_final_key())
+	}
+
+	fn mutate<R, F: FnOnce(&mut G::Query) -> R>(f: F) -> R {
+		Self::try_mutate(|v| Ok::<R, Never>(f(v))).expect("`Never` can not be constructed; qed")
+	}
+
+	fn try_mutate<R, E, F: FnOnce(&mut G::Query) -> Result<R, E>>(f: F) -> Result<R, E> {
+		let mut val = G::get();
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match G::from_query_to_optional_value(val) {
+				Some(ref val) => G::put(val),
+				None => G::kill(),
+			}
+		}
+		ret
+	}
+
+	fn mutate_exists<R, F>(f: F) -> R
+	where
+		F: FnOnce(&mut Option<T>) -> R,
+	{
+		Self::try_mutate_exists(|v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	fn try_mutate_exists<R, E, F>(f: F) -> Result<R, E>
+	where
+		F: FnOnce(&mut Option<T>) -> Result<R, E>,
+	{
+		let mut val = G::from_query_to_optional_value(Self::get());
+
+		let ret = f(&mut val);
+		if ret.is_ok() {
+			match val {
+				Some(ref val) => Self::put(val),
+				None => Self::kill(),
+			}
+		}
+		ret
+	}
+
+	fn take() -> G::Query {
+		let key = Self::storage_value_final_key();
+		let value = unhashed::get(&key);
+		if value.is_some() {
+			unhashed::kill(&key)
+		}
+		G::from_optional_value_to_query(value)
+	}
+
+	fn append<Item, EncodeLikeItem>(item: EncodeLikeItem)
+	where
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		T: StorageAppend<Item>,
+	{
+		let key = Self::storage_value_final_key();
+		sp_io::storage::append(&key, item.encode());
+	}
+}
diff --git a/substrate/frame/support/src/storage/hashed.rs b/substrate/frame/support/src/storage/hashed.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6633adce8ff655aa7d5e3df0b63be77a645812f7
--- /dev/null
+++ b/substrate/frame/support/src/storage/hashed.rs
@@ -0,0 +1,156 @@
+// 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.
+
+//! Operation on runtime storage using hashed keys.
+
+use super::unhashed;
+use codec::{Decode, Encode};
+use sp_std::prelude::*;
+
+/// Return the value of the item in storage under `key`, or `None` if there is no explicit entry.
+pub fn get<T, HashFn, R>(hash: &HashFn, key: &[u8]) -> Option<T>
+where
+	T: Decode + Sized,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::get(hash(key).as_ref())
+}
+
+/// Return the value of the item in storage under `key`, or the type's default if there is no
+/// explicit entry.
+pub fn get_or_default<T, HashFn, R>(hash: &HashFn, key: &[u8]) -> T
+where
+	T: Decode + Sized + Default,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::get_or_default(hash(key).as_ref())
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry.
+pub fn get_or<T, HashFn, R>(hash: &HashFn, key: &[u8], default_value: T) -> T
+where
+	T: Decode + Sized,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::get_or(hash(key).as_ref(), default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry.
+pub fn get_or_else<T, F, HashFn, R>(hash: &HashFn, key: &[u8], default_value: F) -> T
+where
+	T: Decode + Sized,
+	F: FnOnce() -> T,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::get_or_else(hash(key).as_ref(), default_value)
+}
+
+/// Put `value` in storage under `key`.
+pub fn put<T, HashFn, R>(hash: &HashFn, key: &[u8], value: &T)
+where
+	T: Encode,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::put(hash(key).as_ref(), value)
+}
+
+/// Remove `key` from storage, returning its value if it had an explicit entry or `None` otherwise.
+pub fn take<T, HashFn, R>(hash: &HashFn, key: &[u8]) -> Option<T>
+where
+	T: Decode + Sized,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::take(hash(key).as_ref())
+}
+
+/// Remove `key` from storage, returning its value, or, if there was no explicit entry in storage,
+/// the default for its type.
+pub fn take_or_default<T, HashFn, R>(hash: &HashFn, key: &[u8]) -> T
+where
+	T: Decode + Sized + Default,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::take_or_default(hash(key).as_ref())
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or<T, HashFn, R>(hash: &HashFn, key: &[u8], default_value: T) -> T
+where
+	T: Decode + Sized,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::take_or(hash(key).as_ref(), default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or_else<T, F, HashFn, R>(hash: &HashFn, key: &[u8], default_value: F) -> T
+where
+	T: Decode + Sized,
+	F: FnOnce() -> T,
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::take_or_else(hash(key).as_ref(), default_value)
+}
+
+/// Check to see if `key` has an explicit entry in storage.
+pub fn exists<HashFn, R>(hash: &HashFn, key: &[u8]) -> bool
+where
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::exists(hash(key).as_ref())
+}
+
+/// Ensure `key` has no explicit entry in storage.
+pub fn kill<HashFn, R>(hash: &HashFn, key: &[u8])
+where
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::kill(hash(key).as_ref())
+}
+
+/// Get a Vec of bytes from storage.
+pub fn get_raw<HashFn, R>(hash: &HashFn, key: &[u8]) -> Option<Vec<u8>>
+where
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::get_raw(hash(key).as_ref())
+}
+
+/// Put a raw byte slice into storage.
+pub fn put_raw<HashFn, R>(hash: &HashFn, key: &[u8], value: &[u8])
+where
+	HashFn: Fn(&[u8]) -> R,
+	R: AsRef<[u8]>,
+{
+	unhashed::put_raw(hash(key).as_ref(), value)
+}
diff --git a/substrate/frame/support/src/storage/migration.rs b/substrate/frame/support/src/storage/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..568c475bdc69d6adc9f59bc0b059b48987bd04e3
--- /dev/null
+++ b/substrate/frame/support/src/storage/migration.rs
@@ -0,0 +1,517 @@
+// 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.
+
+//! Some utilities for helping access storage with arbitrary key types.
+
+use crate::{
+	hash::ReversibleStorageHasher,
+	storage::{storage_prefix, unhashed},
+	StorageHasher, Twox128,
+};
+use codec::{Decode, Encode};
+use sp_std::prelude::*;
+
+use super::PrefixIterator;
+
+/// Utility to iterate through raw items in storage.
+pub struct StorageIterator<T> {
+	prefix: Vec<u8>,
+	previous_key: Vec<u8>,
+	drain: bool,
+	_phantom: ::sp_std::marker::PhantomData<T>,
+}
+
+impl<T> StorageIterator<T> {
+	/// Construct iterator to iterate over map items in `module` for the map called `item`.
+	#[deprecated(note = "Will be removed after July 2023; Please use the storage_iter or \
+		storage_iter_with_suffix functions instead")]
+	pub fn new(module: &[u8], item: &[u8]) -> Self {
+		#[allow(deprecated)]
+		Self::with_suffix(module, item, &[][..])
+	}
+
+	/// Construct iterator to iterate over map items in `module` for the map called `item`.
+	#[deprecated(note = "Will be removed after July 2023; Please use the storage_iter or \
+		storage_iter_with_suffix functions instead")]
+	pub fn with_suffix(module: &[u8], item: &[u8], suffix: &[u8]) -> Self {
+		let mut prefix = Vec::new();
+		let storage_prefix = storage_prefix(module, item);
+		prefix.extend_from_slice(&storage_prefix);
+		prefix.extend_from_slice(suffix);
+		let previous_key = prefix.clone();
+		Self { prefix, previous_key, drain: false, _phantom: Default::default() }
+	}
+
+	/// Mutate this iterator into a draining iterator; items iterated are removed from storage.
+	pub fn drain(mut self) -> Self {
+		self.drain = true;
+		self
+	}
+}
+
+impl<T: Decode + Sized> Iterator for StorageIterator<T> {
+	type Item = (Vec<u8>, T);
+
+	fn next(&mut self) -> Option<(Vec<u8>, T)> {
+		loop {
+			let maybe_next = sp_io::storage::next_key(&self.previous_key)
+				.filter(|n| n.starts_with(&self.prefix));
+			break match maybe_next {
+				Some(next) => {
+					self.previous_key = next.clone();
+					let maybe_value = frame_support::storage::unhashed::get::<T>(&next);
+					match maybe_value {
+						Some(value) => {
+							if self.drain {
+								frame_support::storage::unhashed::kill(&next);
+							}
+							Some((self.previous_key[self.prefix.len()..].to_vec(), value))
+						},
+						None => continue,
+					}
+				},
+				None => None,
+			}
+		}
+	}
+}
+
+/// Utility to iterate through raw items in storage.
+pub struct StorageKeyIterator<K, T, H: ReversibleStorageHasher> {
+	prefix: Vec<u8>,
+	previous_key: Vec<u8>,
+	drain: bool,
+	_phantom: ::sp_std::marker::PhantomData<(K, T, H)>,
+}
+
+impl<K, T, H: ReversibleStorageHasher> StorageKeyIterator<K, T, H> {
+	/// Construct iterator to iterate over map items in `module` for the map called `item`.
+	#[deprecated(note = "Will be removed after July 2023; Please use the storage_key_iter or \
+		storage_key_iter_with_suffix functions instead")]
+	pub fn new(module: &[u8], item: &[u8]) -> Self {
+		#[allow(deprecated)]
+		Self::with_suffix(module, item, &[][..])
+	}
+
+	/// Construct iterator to iterate over map items in `module` for the map called `item`.
+	#[deprecated(note = "Will be removed after July 2023; Please use the storage_key_iter or \
+		storage_key_iter_with_suffix functions instead")]
+	pub fn with_suffix(module: &[u8], item: &[u8], suffix: &[u8]) -> Self {
+		let mut prefix = Vec::new();
+		let storage_prefix = storage_prefix(module, item);
+		prefix.extend_from_slice(&storage_prefix);
+		prefix.extend_from_slice(suffix);
+		let previous_key = prefix.clone();
+		Self { prefix, previous_key, drain: false, _phantom: Default::default() }
+	}
+
+	/// Mutate this iterator into a draining iterator; items iterated are removed from storage.
+	pub fn drain(mut self) -> Self {
+		self.drain = true;
+		self
+	}
+}
+
+impl<K: Decode + Sized, T: Decode + Sized, H: ReversibleStorageHasher> Iterator
+	for StorageKeyIterator<K, T, H>
+{
+	type Item = (K, T);
+
+	fn next(&mut self) -> Option<(K, T)> {
+		loop {
+			let maybe_next = sp_io::storage::next_key(&self.previous_key)
+				.filter(|n| n.starts_with(&self.prefix));
+			break match maybe_next {
+				Some(next) => {
+					self.previous_key = next.clone();
+					let mut key_material = H::reverse(&next[self.prefix.len()..]);
+					match K::decode(&mut key_material) {
+						Ok(key) => {
+							let maybe_value = frame_support::storage::unhashed::get::<T>(&next);
+							match maybe_value {
+								Some(value) => {
+									if self.drain {
+										frame_support::storage::unhashed::kill(&next);
+									}
+									Some((key, value))
+								},
+								None => continue,
+							}
+						},
+						Err(_) => continue,
+					}
+				},
+				None => None,
+			}
+		}
+	}
+}
+
+/// Construct iterator to iterate over map items in `module` for the map called `item`.
+pub fn storage_iter<T: Decode + Sized>(module: &[u8], item: &[u8]) -> PrefixIterator<(Vec<u8>, T)> {
+	storage_iter_with_suffix(module, item, &[][..])
+}
+
+/// Construct iterator to iterate over map items in `module` for the map called `item`.
+pub fn storage_iter_with_suffix<T: Decode + Sized>(
+	module: &[u8],
+	item: &[u8],
+	suffix: &[u8],
+) -> PrefixIterator<(Vec<u8>, T)> {
+	let mut prefix = Vec::new();
+	let storage_prefix = storage_prefix(module, item);
+	prefix.extend_from_slice(&storage_prefix);
+	prefix.extend_from_slice(suffix);
+	let previous_key = prefix.clone();
+	let closure = |raw_key_without_prefix: &[u8], mut raw_value: &[u8]| {
+		let value = T::decode(&mut raw_value)?;
+		Ok((raw_key_without_prefix.to_vec(), value))
+	};
+
+	PrefixIterator { prefix, previous_key, drain: false, closure, phantom: Default::default() }
+}
+
+/// Construct iterator to iterate over map items in `module` for the map called `item`.
+pub fn storage_key_iter<K: Decode + Sized, T: Decode + Sized, H: ReversibleStorageHasher>(
+	module: &[u8],
+	item: &[u8],
+) -> PrefixIterator<(K, T)> {
+	storage_key_iter_with_suffix::<K, T, H>(module, item, &[][..])
+}
+
+/// Construct iterator to iterate over map items in `module` for the map called `item`.
+pub fn storage_key_iter_with_suffix<
+	K: Decode + Sized,
+	T: Decode + Sized,
+	H: ReversibleStorageHasher,
+>(
+	module: &[u8],
+	item: &[u8],
+	suffix: &[u8],
+) -> PrefixIterator<(K, T)> {
+	let mut prefix = Vec::new();
+	let storage_prefix = storage_prefix(module, item);
+
+	prefix.extend_from_slice(&storage_prefix);
+	prefix.extend_from_slice(suffix);
+	let previous_key = prefix.clone();
+	let closure = |raw_key_without_prefix: &[u8], mut raw_value: &[u8]| {
+		let mut key_material = H::reverse(raw_key_without_prefix);
+		let key = K::decode(&mut key_material)?;
+		let value = T::decode(&mut raw_value)?;
+		Ok((key, value))
+	};
+	PrefixIterator { prefix, previous_key, drain: false, closure, phantom: Default::default() }
+}
+
+/// Get a particular value in storage by the `module`, the map's `item` name and the key `hash`.
+pub fn have_storage_value(module: &[u8], item: &[u8], hash: &[u8]) -> bool {
+	get_storage_value::<()>(module, item, hash).is_some()
+}
+
+/// Get a particular value in storage by the `module`, the map's `item` name and the key `hash`.
+pub fn get_storage_value<T: Decode + Sized>(module: &[u8], item: &[u8], hash: &[u8]) -> Option<T> {
+	let mut key = vec![0u8; 32 + hash.len()];
+	let storage_prefix = storage_prefix(module, item);
+	key[0..32].copy_from_slice(&storage_prefix);
+	key[32..].copy_from_slice(hash);
+	frame_support::storage::unhashed::get::<T>(&key)
+}
+
+/// Take a particular value in storage by the `module`, the map's `item` name and the key `hash`.
+pub fn take_storage_value<T: Decode + Sized>(module: &[u8], item: &[u8], hash: &[u8]) -> Option<T> {
+	let mut key = vec![0u8; 32 + hash.len()];
+	let storage_prefix = storage_prefix(module, item);
+	key[0..32].copy_from_slice(&storage_prefix);
+	key[32..].copy_from_slice(hash);
+	frame_support::storage::unhashed::take::<T>(&key)
+}
+
+/// Put a particular value into storage by the `module`, the map's `item` name and the key `hash`.
+pub fn put_storage_value<T: Encode>(module: &[u8], item: &[u8], hash: &[u8], value: T) {
+	let mut key = vec![0u8; 32 + hash.len()];
+	let storage_prefix = storage_prefix(module, item);
+	key[0..32].copy_from_slice(&storage_prefix);
+	key[32..].copy_from_slice(hash);
+	frame_support::storage::unhashed::put(&key, &value);
+}
+
+/// Remove all items under a storage prefix by the `module`, the map's `item` name and the key
+/// `hash`.
+#[deprecated = "Use `clear_storage_prefix` instead"]
+pub fn remove_storage_prefix(module: &[u8], item: &[u8], hash: &[u8]) {
+	let mut key = vec![0u8; 32 + hash.len()];
+	let storage_prefix = storage_prefix(module, item);
+	key[0..32].copy_from_slice(&storage_prefix);
+	key[32..].copy_from_slice(hash);
+	let _ = frame_support::storage::unhashed::clear_prefix(&key, None, None);
+}
+
+/// Attempt to remove all values under a storage prefix by the `module`, the map's `item` name and
+/// the key `hash`.
+///
+/// All values in the client overlay will be deleted, if `maybe_limit` is `Some` then up to
+/// that number of values are deleted from the client backend by seeking and reading that number of
+/// storage values plus one. If `maybe_limit` is `None` then all values in the client backend are
+/// deleted. This is potentially unsafe since it's an unbounded operation.
+///
+/// ## Cursors
+///
+/// The `maybe_cursor` parameter should be `None` for the first call to initial removal.
+/// If the resultant `maybe_cursor` is `Some`, then another call is required to complete the
+/// removal operation. This value must be passed in as the subsequent call's `maybe_cursor`
+/// parameter. If the resultant `maybe_cursor` is `None`, then the operation is complete and no
+/// items remain in storage provided that no items were added between the first calls and the
+/// final call.
+pub fn clear_storage_prefix(
+	module: &[u8],
+	item: &[u8],
+	hash: &[u8],
+	maybe_limit: Option<u32>,
+	maybe_cursor: Option<&[u8]>,
+) -> sp_io::MultiRemovalResults {
+	let mut key = vec![0u8; 32 + hash.len()];
+	let storage_prefix = storage_prefix(module, item);
+	key[0..32].copy_from_slice(&storage_prefix);
+	key[32..].copy_from_slice(hash);
+	frame_support::storage::unhashed::clear_prefix(&key, maybe_limit, maybe_cursor)
+}
+
+/// Take a particular item in storage by the `module`, the map's `item` name and the key `hash`.
+pub fn take_storage_item<K: Encode + Sized, T: Decode + Sized, H: StorageHasher>(
+	module: &[u8],
+	item: &[u8],
+	key: K,
+) -> Option<T> {
+	take_storage_value(module, item, key.using_encoded(H::hash).as_ref())
+}
+
+/// Move a storage from a pallet prefix to another pallet prefix.
+///
+/// Keys used in pallet storages always start with:
+/// `concat(twox_128(pallet_name), towx_128(storage_name))`.
+///
+/// This function will remove all value for which the key start with
+/// `concat(twox_128(old_pallet_name), towx_128(storage_name))` and insert them at the key with
+/// the start replaced by `concat(twox_128(new_pallet_name), towx_128(storage_name))`.
+///
+/// # Example
+///
+/// If a pallet named "my_example" has 2 storages named "Foo" and "Bar" and the pallet is renamed
+/// "my_new_example_name", a migration can be:
+/// ```
+/// # use frame_support::storage::migration::move_storage_from_pallet;
+/// # sp_io::TestExternalities::new_empty().execute_with(|| {
+/// move_storage_from_pallet(b"Foo", b"my_example", b"my_new_example_name");
+/// move_storage_from_pallet(b"Bar", b"my_example", b"my_new_example_name");
+/// # })
+/// ```
+pub fn move_storage_from_pallet(
+	storage_name: &[u8],
+	old_pallet_name: &[u8],
+	new_pallet_name: &[u8],
+) {
+	let new_prefix = storage_prefix(new_pallet_name, storage_name);
+	let old_prefix = storage_prefix(old_pallet_name, storage_name);
+
+	move_prefix(&old_prefix, &new_prefix);
+
+	if let Some(value) = unhashed::get_raw(&old_prefix) {
+		unhashed::put_raw(&new_prefix, &value);
+		unhashed::kill(&old_prefix);
+	}
+}
+
+/// Move all storages from a pallet prefix to another pallet prefix.
+///
+/// Keys used in pallet storages always start with:
+/// `concat(twox_128(pallet_name), towx_128(storage_name))`.
+///
+/// This function will remove all value for which the key start with `twox_128(old_pallet_name)`
+/// and insert them at the key with the start replaced by `twox_128(new_pallet_name)`.
+///
+/// NOTE: The value at the key `twox_128(old_pallet_name)` is not moved.
+///
+/// # Example
+///
+/// If a pallet named "my_example" has some storages and the pallet is renamed
+/// "my_new_example_name", a migration can be:
+/// ```
+/// # use frame_support::storage::migration::move_pallet;
+/// # sp_io::TestExternalities::new_empty().execute_with(|| {
+/// move_pallet(b"my_example", b"my_new_example_name");
+/// # })
+/// ```
+pub fn move_pallet(old_pallet_name: &[u8], new_pallet_name: &[u8]) {
+	move_prefix(&Twox128::hash(old_pallet_name), &Twox128::hash(new_pallet_name))
+}
+
+/// Move all `(key, value)` after some prefix to the another prefix
+///
+/// This function will remove all value for which the key start with `from_prefix`
+/// and insert them at the key with the start replaced by `to_prefix`.
+///
+/// NOTE: The value at the key `from_prefix` is not moved.
+pub fn move_prefix(from_prefix: &[u8], to_prefix: &[u8]) {
+	if from_prefix == to_prefix {
+		return
+	}
+
+	let iter = PrefixIterator::<_> {
+		prefix: from_prefix.to_vec(),
+		previous_key: from_prefix.to_vec(),
+		drain: true,
+		closure: |key, value| Ok((key.to_vec(), value.to_vec())),
+		phantom: Default::default(),
+	};
+
+	for (key, value) in iter {
+		let full_key = [to_prefix, &key].concat();
+		unhashed::put_raw(&full_key, &value);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{
+		move_pallet, move_prefix, move_storage_from_pallet, storage_iter, storage_key_iter,
+	};
+	use crate::{
+		hash::StorageHasher,
+		pallet_prelude::{StorageMap, StorageValue, Twox128, Twox64Concat},
+	};
+	use sp_io::TestExternalities;
+
+	struct OldPalletStorageValuePrefix;
+	impl frame_support::traits::StorageInstance for OldPalletStorageValuePrefix {
+		const STORAGE_PREFIX: &'static str = "foo_value";
+		fn pallet_prefix() -> &'static str {
+			"my_old_pallet"
+		}
+	}
+	type OldStorageValue = StorageValue<OldPalletStorageValuePrefix, u32>;
+
+	struct OldPalletStorageMapPrefix;
+	impl frame_support::traits::StorageInstance for OldPalletStorageMapPrefix {
+		const STORAGE_PREFIX: &'static str = "foo_map";
+		fn pallet_prefix() -> &'static str {
+			"my_old_pallet"
+		}
+	}
+	type OldStorageMap = StorageMap<OldPalletStorageMapPrefix, Twox64Concat, u32, u32>;
+
+	struct NewPalletStorageValuePrefix;
+	impl frame_support::traits::StorageInstance for NewPalletStorageValuePrefix {
+		const STORAGE_PREFIX: &'static str = "foo_value";
+		fn pallet_prefix() -> &'static str {
+			"my_new_pallet"
+		}
+	}
+	type NewStorageValue = StorageValue<NewPalletStorageValuePrefix, u32>;
+
+	struct NewPalletStorageMapPrefix;
+	impl frame_support::traits::StorageInstance for NewPalletStorageMapPrefix {
+		const STORAGE_PREFIX: &'static str = "foo_map";
+		fn pallet_prefix() -> &'static str {
+			"my_new_pallet"
+		}
+	}
+	type NewStorageMap = StorageMap<NewPalletStorageMapPrefix, Twox64Concat, u32, u32>;
+
+	#[test]
+	fn test_move_prefix() {
+		TestExternalities::new_empty().execute_with(|| {
+			OldStorageValue::put(3);
+			OldStorageMap::insert(1, 2);
+			OldStorageMap::insert(3, 4);
+
+			move_prefix(&Twox128::hash(b"my_old_pallet"), &Twox128::hash(b"my_new_pallet"));
+
+			assert_eq!(OldStorageValue::get(), None);
+			assert_eq!(OldStorageMap::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(NewStorageValue::get(), Some(3));
+			assert_eq!(NewStorageMap::iter().collect::<Vec<_>>(), vec![(1, 2), (3, 4)]);
+		})
+	}
+
+	#[test]
+	fn test_move_storage() {
+		TestExternalities::new_empty().execute_with(|| {
+			OldStorageValue::put(3);
+			OldStorageMap::insert(1, 2);
+			OldStorageMap::insert(3, 4);
+
+			move_storage_from_pallet(b"foo_map", b"my_old_pallet", b"my_new_pallet");
+
+			assert_eq!(OldStorageValue::get(), Some(3));
+			assert_eq!(OldStorageMap::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(NewStorageValue::get(), None);
+			assert_eq!(NewStorageMap::iter().collect::<Vec<_>>(), vec![(1, 2), (3, 4)]);
+
+			move_storage_from_pallet(b"foo_value", b"my_old_pallet", b"my_new_pallet");
+
+			assert_eq!(OldStorageValue::get(), None);
+			assert_eq!(OldStorageMap::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(NewStorageValue::get(), Some(3));
+			assert_eq!(NewStorageMap::iter().collect::<Vec<_>>(), vec![(1, 2), (3, 4)]);
+		})
+	}
+
+	#[test]
+	fn test_move_pallet() {
+		TestExternalities::new_empty().execute_with(|| {
+			OldStorageValue::put(3);
+			OldStorageMap::insert(1, 2);
+			OldStorageMap::insert(3, 4);
+
+			move_pallet(b"my_old_pallet", b"my_new_pallet");
+
+			assert_eq!(OldStorageValue::get(), None);
+			assert_eq!(OldStorageMap::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(NewStorageValue::get(), Some(3));
+			assert_eq!(NewStorageMap::iter().collect::<Vec<_>>(), vec![(1, 2), (3, 4)]);
+		})
+	}
+
+	#[test]
+	fn test_storage_iter() {
+		TestExternalities::new_empty().execute_with(|| {
+			OldStorageValue::put(3);
+			OldStorageMap::insert(1, 2);
+			OldStorageMap::insert(3, 4);
+
+			assert_eq!(
+				storage_key_iter::<i32, i32, Twox64Concat>(b"my_old_pallet", b"foo_map")
+					.collect::<Vec<_>>(),
+				vec![(1, 2), (3, 4)],
+			);
+
+			assert_eq!(
+				storage_iter(b"my_old_pallet", b"foo_map")
+					.drain()
+					.map(|t| t.1)
+					.collect::<Vec<i32>>(),
+				vec![2, 4],
+			);
+			assert_eq!(OldStorageMap::iter().collect::<Vec<_>>(), vec![]);
+
+			// Empty because storage iterator skips over the entry under the first key
+			assert_eq!(storage_iter::<i32>(b"my_old_pallet", b"foo_value").drain().next(), None);
+			assert_eq!(OldStorageValue::get(), Some(3));
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/mod.rs b/substrate/frame/support/src/storage/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d52908fa366c6cc144a4027bcafade19e50fe2dd
--- /dev/null
+++ b/substrate/frame/support/src/storage/mod.rs
@@ -0,0 +1,2024 @@
+// 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.
+
+//! Stuff to do with the runtime's storage.
+
+use crate::{
+	hash::{ReversibleStorageHasher, StorageHasher},
+	storage::types::{
+		EncodeLikeTuple, HasKeyPrefix, HasReversibleKeyPrefix, KeyGenerator,
+		ReversibleKeyGenerator, TupleToEncodedIter,
+	},
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, FullEncode};
+use sp_core::storage::ChildInfo;
+use sp_runtime::generic::{Digest, DigestItem};
+use sp_std::{collections::btree_set::BTreeSet, marker::PhantomData, prelude::*};
+
+pub use self::{
+	stream_iter::StorageStreamIter,
+	transactional::{
+		in_storage_layer, with_storage_layer, with_transaction, with_transaction_unchecked,
+	},
+	types::StorageEntryMetadataBuilder,
+};
+pub use sp_runtime::TransactionOutcome;
+pub use types::Key;
+
+pub mod bounded_btree_map;
+pub mod bounded_btree_set;
+pub mod bounded_vec;
+pub mod child;
+#[doc(hidden)]
+pub mod generator;
+pub mod hashed;
+pub mod migration;
+pub mod storage_noop_guard;
+mod stream_iter;
+pub mod transactional;
+pub mod types;
+pub mod unhashed;
+pub mod weak_bounded_vec;
+
+/// Utility type for converting a storage map into a `Get<u32>` impl which returns the maximum
+/// key size.
+pub struct KeyLenOf<M>(PhantomData<M>);
+
+/// A trait for working with macro-generated storage values under the substrate storage API.
+///
+/// Details on implementation can be found at [`generator::StorageValue`].
+pub trait StorageValue<T: FullCodec> {
+	/// The type that get/take return.
+	type Query;
+
+	/// Get the storage key.
+	fn hashed_key() -> [u8; 32];
+
+	/// Does the value (explicitly) exist in storage?
+	fn exists() -> bool;
+
+	/// Load the value from the provided storage instance.
+	fn get() -> Self::Query;
+
+	/// Try to get the underlying value from the provided storage instance.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	fn try_get() -> Result<T, ()>;
+
+	/// Translate a value from some previous type (`O`) to the current type.
+	///
+	/// `f: F` is the translation function.
+	///
+	/// Returns `Err` if the storage item could not be interpreted as the old type, and Ok, along
+	/// with the new value if it could.
+	///
+	/// NOTE: This operates from and to `Option<_>` types; no effort is made to respect the default
+	/// value of the original type.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade, while
+	/// ensuring **no usage of this storage are made before the call to `on_runtime_upgrade`**.
+	/// (More precisely prior initialized modules doesn't make use of this storage).
+	fn translate<O: Decode, F: FnOnce(Option<O>) -> Option<T>>(f: F) -> Result<Option<T>, ()>;
+
+	/// Store a value under this key into the provided storage instance.
+	fn put<Arg: EncodeLike<T>>(val: Arg);
+
+	/// Store a value under this key into the provided storage instance; this uses the query
+	/// type rather than the underlying value.
+	fn set(val: Self::Query);
+
+	/// Mutate the value
+	fn mutate<R, F: FnOnce(&mut Self::Query) -> R>(f: F) -> R;
+
+	/// Mutate the value under a key if the value already exists. Do nothing and return the default
+	/// value if not.
+	fn mutate_extant<R: Default, F: FnOnce(&mut T) -> R>(f: F) -> R {
+		Self::mutate_exists(|maybe_v| match maybe_v {
+			Some(ref mut value) => f(value),
+			None => R::default(),
+		})
+	}
+
+	/// Mutate the value if closure returns `Ok`
+	fn try_mutate<R, E, F: FnOnce(&mut Self::Query) -> Result<R, E>>(f: F) -> Result<R, E>;
+
+	/// Mutate the value. Deletes the item if mutated to a `None`.
+	fn mutate_exists<R, F: FnOnce(&mut Option<T>) -> R>(f: F) -> R;
+
+	/// Mutate the value if closure returns `Ok`. Deletes the item if mutated to a `None`.
+	fn try_mutate_exists<R, E, F: FnOnce(&mut Option<T>) -> Result<R, E>>(f: F) -> Result<R, E>;
+
+	/// Clear the storage value.
+	fn kill();
+
+	/// Take a value from storage, removing it afterwards.
+	fn take() -> Self::Query;
+
+	/// Append the given item to the value in the storage.
+	///
+	/// `T` is required to implement [`StorageAppend`].
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage item will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	fn append<Item, EncodeLikeItem>(item: EncodeLikeItem)
+	where
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		T: StorageAppend<Item>;
+
+	/// Read the length of the storage value without decoding the entire value.
+	///
+	/// `T` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	fn decode_len() -> Option<usize>
+	where
+		T: StorageDecodeLength,
+	{
+		T::decode_len(&Self::hashed_key())
+	}
+}
+
+/// A non-continuous container type.
+pub trait StorageList<V: FullCodec> {
+	/// Iterator for normal and draining iteration.
+	type Iterator: Iterator<Item = V>;
+
+	/// Append iterator for fast append operations.
+	type Appender: StorageAppender<V>;
+
+	/// List the elements in append order.
+	fn iter() -> Self::Iterator;
+
+	/// Drain the elements in append order.
+	///
+	/// Note that this drains a value as soon as it is being inspected. For example `take_while(|_|
+	/// false)` still drains the first element. This also applies to `peek()`.
+	fn drain() -> Self::Iterator;
+
+	/// A fast append iterator.
+	fn appender() -> Self::Appender;
+
+	/// Append a single element.
+	///
+	/// Should not be called repeatedly; use `append_many` instead.  
+	/// Worst case linear `O(len)` with `len` being the number if elements in the list.
+	fn append_one<EncodeLikeValue>(item: EncodeLikeValue)
+	where
+		EncodeLikeValue: EncodeLike<V>,
+	{
+		Self::append_many(core::iter::once(item));
+	}
+
+	/// Append many elements.
+	///
+	/// Should not be called repeatedly; use `appender` instead.  
+	/// Worst case linear `O(len + items.count())` with `len` beings the number if elements in the
+	/// list.
+	fn append_many<EncodeLikeValue, I>(items: I)
+	where
+		EncodeLikeValue: EncodeLike<V>,
+		I: IntoIterator<Item = EncodeLikeValue>,
+	{
+		let mut ap = Self::appender();
+		ap.append_many(items);
+	}
+}
+
+/// Append iterator to append values to a storage struct.
+///
+/// Can be used in situations where appending does not have constant time complexity.
+pub trait StorageAppender<V: FullCodec> {
+	/// Append a single item in constant time `O(1)`.
+	fn append<EncodeLikeValue>(&mut self, item: EncodeLikeValue)
+	where
+		EncodeLikeValue: EncodeLike<V>;
+
+	/// Append many items in linear time `O(items.count())`.
+	// Note: a default impl is provided since `Self` is already assumed to be optimal for single
+	// append operations.
+	fn append_many<EncodeLikeValue, I>(&mut self, items: I)
+	where
+		EncodeLikeValue: EncodeLike<V>,
+		I: IntoIterator<Item = EncodeLikeValue>,
+	{
+		for item in items.into_iter() {
+			self.append(item);
+		}
+	}
+}
+
+/// A strongly-typed map in storage.
+///
+/// Details on implementation can be found at [`generator::StorageMap`].
+pub trait StorageMap<K: FullEncode, V: FullCodec> {
+	/// The type that get/take return.
+	type Query;
+
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	fn hashed_key_for<KeyArg: EncodeLike<K>>(key: KeyArg) -> Vec<u8>;
+
+	/// Does the value (explicitly) exist in storage?
+	fn contains_key<KeyArg: EncodeLike<K>>(key: KeyArg) -> bool;
+
+	/// Load the value associated with the given key from the map.
+	fn get<KeyArg: EncodeLike<K>>(key: KeyArg) -> Self::Query;
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	fn set<KeyArg: EncodeLike<K>>(key: KeyArg, query: Self::Query);
+
+	/// Try to get the value for the given key from the map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	fn try_get<KeyArg: EncodeLike<K>>(key: KeyArg) -> Result<V, ()>;
+
+	/// Swap the values of two keys.
+	fn swap<KeyArg1: EncodeLike<K>, KeyArg2: EncodeLike<K>>(key1: KeyArg1, key2: KeyArg2);
+
+	/// Store a value to be associated with the given key from the map.
+	fn insert<KeyArg: EncodeLike<K>, ValArg: EncodeLike<V>>(key: KeyArg, val: ValArg);
+
+	/// Remove the value under a key.
+	fn remove<KeyArg: EncodeLike<K>>(key: KeyArg);
+
+	/// Mutate the value under a key.
+	fn mutate<KeyArg: EncodeLike<K>, R, F: FnOnce(&mut Self::Query) -> R>(key: KeyArg, f: F) -> R;
+
+	/// Mutate the item, only if an `Ok` value is returned.
+	fn try_mutate<KeyArg: EncodeLike<K>, R, E, F: FnOnce(&mut Self::Query) -> Result<R, E>>(
+		key: KeyArg,
+		f: F,
+	) -> Result<R, E>;
+
+	/// Mutate the value under a key if the value already exists. Do nothing and return the default
+	/// value if not.
+	fn mutate_extant<KeyArg: EncodeLike<K>, R: Default, F: FnOnce(&mut V) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		Self::mutate_exists(key, |maybe_v| match maybe_v {
+			Some(ref mut value) => f(value),
+			None => R::default(),
+		})
+	}
+
+	/// Mutate the value under a key.
+	///
+	/// Deletes the item if mutated to a `None`.
+	fn mutate_exists<KeyArg: EncodeLike<K>, R, F: FnOnce(&mut Option<V>) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R;
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	fn try_mutate_exists<KeyArg: EncodeLike<K>, R, E, F: FnOnce(&mut Option<V>) -> Result<R, E>>(
+		key: KeyArg,
+		f: F,
+	) -> Result<R, E>;
+
+	/// Take the value under a key.
+	fn take<KeyArg: EncodeLike<K>>(key: KeyArg) -> Self::Query;
+
+	/// Append the given items to the value in the storage.
+	///
+	/// `V` is required to implement `codec::EncodeAppend`.
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	fn append<Item, EncodeLikeItem, EncodeLikeKey>(key: EncodeLikeKey, item: EncodeLikeItem)
+	where
+		EncodeLikeKey: EncodeLike<K>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		V: StorageAppend<Item>;
+
+	/// Read the length of the storage value without decoding the entire value under the
+	/// given `key`.
+	///
+	/// `V` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	fn decode_len<KeyArg: EncodeLike<K>>(key: KeyArg) -> Option<usize>
+	where
+		V: StorageDecodeLength,
+	{
+		V::decode_len(&Self::hashed_key_for(key))
+	}
+
+	/// Migrate an item with the given `key` from a defunct `OldHasher` to the current hasher.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	fn migrate_key<OldHasher: StorageHasher, KeyArg: EncodeLike<K>>(key: KeyArg) -> Option<V>;
+
+	/// Migrate an item with the given `key` from a `blake2_256` hasher to the current hasher.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	fn migrate_key_from_blake<KeyArg: EncodeLike<K>>(key: KeyArg) -> Option<V> {
+		Self::migrate_key::<crate::hash::Blake2_256, KeyArg>(key)
+	}
+}
+
+/// A strongly-typed map in storage whose keys and values can be iterated over.
+pub trait IterableStorageMap<K: FullEncode, V: FullCodec>: StorageMap<K, V> {
+	/// The type that iterates over all `(key, value)`.
+	type Iterator: Iterator<Item = (K, V)>;
+	/// The type that itereates over all `key`s.
+	type KeyIterator: Iterator<Item = K>;
+
+	/// Enumerate all elements in the map in lexicographical order of the encoded key. If you
+	/// alter the map while doing this, you'll get undefined results.
+	fn iter() -> Self::Iterator;
+
+	/// Enumerate all elements in the map after a specified `starting_raw_key` in lexicographical
+	/// order of the encoded key. If you alter the map while doing this, you'll get undefined
+	/// results.
+	fn iter_from(starting_raw_key: Vec<u8>) -> Self::Iterator;
+
+	/// Enumerate all keys in the map in lexicographical order of the encoded key, skipping over
+	/// the elements. If you alter the map while doing this, you'll get undefined results.
+	fn iter_keys() -> Self::KeyIterator;
+
+	/// Enumerate all keys in the map after a specified `starting_raw_key` in lexicographical order
+	/// of the encoded key. If you alter the map while doing this, you'll get undefined results.
+	fn iter_keys_from(starting_raw_key: Vec<u8>) -> Self::KeyIterator;
+
+	/// Remove all elements from the map and iterate through them in lexicographical order of the
+	/// encoded key. If you add elements to the map while doing this, you'll get undefined results.
+	fn drain() -> Self::Iterator;
+
+	/// Translate the values of all elements by a function `f`, in the map in lexicographical order
+	/// of the encoded key.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	fn translate<O: Decode, F: FnMut(K, O) -> Option<V>>(f: F);
+
+	/// Translate the next entry following `previous_key` by a function `f`.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// Returns the next key to iterate from in lexicographical order of the encoded key.
+	fn translate_next<O: Decode, F: FnMut(K, O) -> Option<V>>(
+		previous_key: Option<Vec<u8>>,
+		f: F,
+	) -> Option<Vec<u8>>;
+}
+
+/// A strongly-typed double map in storage whose secondary keys and values can be iterated over.
+pub trait IterableStorageDoubleMap<K1: FullCodec, K2: FullCodec, V: FullCodec>:
+	StorageDoubleMap<K1, K2, V>
+{
+	/// The type that iterates over all `key2`.
+	type PartialKeyIterator: Iterator<Item = K2>;
+
+	/// The type that iterates over all `(key2, value)`.
+	type PrefixIterator: Iterator<Item = (K2, V)>;
+
+	/// The type that iterates over all `(key1, key2)`.
+	type FullKeyIterator: Iterator<Item = (K1, K2)>;
+
+	/// The type that iterates over all `(key1, key2, value)`.
+	type Iterator: Iterator<Item = (K1, K2, V)>;
+
+	/// Enumerate all elements in the map with first key `k1` in lexicographical order of the
+	/// encoded key. If you add or remove values whose first key is `k1` to the map while doing
+	/// this, you'll get undefined results.
+	fn iter_prefix(k1: impl EncodeLike<K1>) -> Self::PrefixIterator;
+
+	/// Enumerate all elements in the map with first key `k1` after a specified `starting_raw_key`
+	/// in lexicographical order of the encoded key. If you add or remove values whose first key is
+	/// `k1` to the map while doing this, you'll get undefined results.
+	fn iter_prefix_from(k1: impl EncodeLike<K1>, starting_raw_key: Vec<u8>)
+		-> Self::PrefixIterator;
+
+	/// Enumerate all second keys `k2` in the map with the same first key `k1` in lexicographical
+	/// order of the encoded key. If you add or remove values whose first key is `k1` to the map
+	/// while doing this, you'll get undefined results.
+	fn iter_key_prefix(k1: impl EncodeLike<K1>) -> Self::PartialKeyIterator;
+
+	/// Enumerate all second keys `k2` in the map with the same first key `k1` after a specified
+	/// `starting_raw_key` in lexicographical order of the encoded key. If you add or remove values
+	/// whose first key is `k1` to the map while doing this, you'll get undefined results.
+	fn iter_key_prefix_from(
+		k1: impl EncodeLike<K1>,
+		starting_raw_key: Vec<u8>,
+	) -> Self::PartialKeyIterator;
+
+	/// Remove all elements from the map with first key `k1` and iterate through them in
+	/// lexicographical order of the encoded key. If you add elements with first key `k1` to the
+	/// map while doing this, you'll get undefined results.
+	fn drain_prefix(k1: impl EncodeLike<K1>) -> Self::PrefixIterator;
+
+	/// Enumerate all elements in the map in lexicographical order of the encoded key. If you add
+	/// or remove values to the map while doing this, you'll get undefined results.
+	fn iter() -> Self::Iterator;
+
+	/// Enumerate all elements in the map after a specified `starting_raw_key` in lexicographical
+	/// order of the encoded key. If you add or remove values to the map while doing this, you'll
+	/// get undefined results.
+	fn iter_from(starting_raw_key: Vec<u8>) -> Self::Iterator;
+
+	/// Enumerate all keys `k1` and `k2` in the map in lexicographical order of the encoded key. If
+	/// you add or remove values to the map while doing this, you'll get undefined results.
+	fn iter_keys() -> Self::FullKeyIterator;
+
+	/// Enumerate all keys `k1` and `k2` in the map after a specified `starting_raw_key` in
+	/// lexicographical order of the encoded key. If you add or remove values to the map while
+	/// doing this, you'll get undefined results.
+	fn iter_keys_from(starting_raw_key: Vec<u8>) -> Self::FullKeyIterator;
+
+	/// Remove all elements from the map and iterate through them in lexicographical order of the
+	/// encoded key. If you add elements to the map while doing this, you'll get undefined results.
+	fn drain() -> Self::Iterator;
+
+	/// Translate the values of all elements by a function `f`, in the map in lexicographical order
+	/// of the encoded key.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	fn translate<O: Decode, F: FnMut(K1, K2, O) -> Option<V>>(f: F);
+}
+
+/// A strongly-typed map with arbitrary number of keys in storage whose keys and values can be
+/// iterated over.
+pub trait IterableStorageNMap<K: ReversibleKeyGenerator, V: FullCodec>: StorageNMap<K, V> {
+	/// The type that iterates over all `(key1, key2, key3, ... keyN)` tuples.
+	type KeyIterator: Iterator<Item = K::Key>;
+
+	/// The type that iterates over all `(key1, key2, key3, ... keyN), value)` tuples.
+	type Iterator: Iterator<Item = (K::Key, V)>;
+
+	/// Enumerate all elements in the map with prefix key `kp` in lexicographical order of the
+	/// encoded key. If you add or remove values whose prefix is `kp` to the map while doing this,
+	/// you'll get undefined results.
+	fn iter_prefix<KP>(kp: KP) -> PrefixIterator<(<K as HasKeyPrefix<KP>>::Suffix, V)>
+	where
+		K: HasReversibleKeyPrefix<KP>;
+
+	/// Enumerate all elements in the map with prefix key `kp` after a specified `starting_raw_key`
+	/// in lexicographical order of the encoded key. If you add or remove values whose prefix is
+	/// `kp` to the map while doing this, you'll get undefined results.
+	fn iter_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> PrefixIterator<(<K as HasKeyPrefix<KP>>::Suffix, V)>
+	where
+		K: HasReversibleKeyPrefix<KP>;
+
+	/// Enumerate all suffix keys in the map with prefix key `kp` in lexicographical order of the
+	/// encoded key. If you add or remove values whose prefix is `kp` to the map while doing this,
+	/// you'll get undefined results.
+	fn iter_key_prefix<KP>(kp: KP) -> KeyPrefixIterator<<K as HasKeyPrefix<KP>>::Suffix>
+	where
+		K: HasReversibleKeyPrefix<KP>;
+
+	/// Enumerate all suffix keys in the map with prefix key `kp` after a specified
+	/// `starting_raw_key` in lexicographical order of the encoded key. If you add or remove values
+	/// whose prefix is `kp` to the map while doing this, you'll get undefined results.
+	fn iter_key_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> KeyPrefixIterator<<K as HasKeyPrefix<KP>>::Suffix>
+	where
+		K: HasReversibleKeyPrefix<KP>;
+
+	/// Remove all elements from the map with prefix key `kp` and iterate through them in
+	/// lexicographical order of the encoded key. If you add elements with prefix key `kp` to the
+	/// map while doing this, you'll get undefined results.
+	fn drain_prefix<KP>(kp: KP) -> PrefixIterator<(<K as HasKeyPrefix<KP>>::Suffix, V)>
+	where
+		K: HasReversibleKeyPrefix<KP>;
+
+	/// Enumerate all elements in the map in lexicographical order of the encoded key. If you add
+	/// or remove values to the map while doing this, you'll get undefined results.
+	fn iter() -> Self::Iterator;
+
+	/// Enumerate all elements in the map after a specified `starting_raw_key` in lexicographical
+	/// order of the encoded key. If you add or remove values to the map while doing this, you'll
+	/// get undefined results.
+	fn iter_from(starting_raw_key: Vec<u8>) -> Self::Iterator;
+
+	/// Enumerate all keys in the map in lexicographical order of the encoded key. If you add or
+	/// remove values to the map while doing this, you'll get undefined results.
+	fn iter_keys() -> Self::KeyIterator;
+
+	/// Enumerate all keys in the map after `starting_raw_key` in lexicographical order of the
+	/// encoded key. If you add or remove values to the map while doing this, you'll get undefined
+	/// results.
+	fn iter_keys_from(starting_raw_key: Vec<u8>) -> Self::KeyIterator;
+
+	/// Remove all elements from the map and iterate through them in lexicographical order of the
+	/// encoded key. If you add elements to the map while doing this, you'll get undefined results.
+	fn drain() -> Self::Iterator;
+
+	/// Translate the values of all elements by a function `f`, in the map in lexicographical order
+	/// of the encoded key.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	fn translate<O: Decode, F: FnMut(K::Key, O) -> Option<V>>(f: F);
+}
+
+/// An implementation of a map with a two keys.
+///
+/// Details on implementation can be found at [`generator::StorageDoubleMap`].
+pub trait StorageDoubleMap<K1: FullEncode, K2: FullEncode, V: FullCodec> {
+	/// The type that get/take returns.
+	type Query;
+
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	fn hashed_key_for<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Vec<u8>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>;
+
+	/// Does the value (explicitly) exist in storage?
+	fn contains_key<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> bool
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>;
+
+	/// Load the value associated with the given key from the double map.
+	fn get<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Self::Query
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>;
+
+	/// Try to get the value for the given key from the double map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	fn try_get<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Result<V, ()>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>;
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	fn set<KArg1: EncodeLike<K1>, KArg2: EncodeLike<K2>>(k1: KArg1, k2: KArg2, query: Self::Query);
+
+	/// Take a value from storage, removing it afterwards.
+	fn take<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Self::Query
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>;
+
+	/// Swap the values of two key-pairs.
+	fn swap<XKArg1, XKArg2, YKArg1, YKArg2>(x_k1: XKArg1, x_k2: XKArg2, y_k1: YKArg1, y_k2: YKArg2)
+	where
+		XKArg1: EncodeLike<K1>,
+		XKArg2: EncodeLike<K2>,
+		YKArg1: EncodeLike<K1>,
+		YKArg2: EncodeLike<K2>;
+
+	/// Store a value to be associated with the given keys from the double map.
+	fn insert<KArg1, KArg2, VArg>(k1: KArg1, k2: KArg2, val: VArg)
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		VArg: EncodeLike<V>;
+
+	/// Remove the value under the given keys.
+	fn remove<KArg1, KArg2>(k1: KArg1, k2: KArg2)
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>;
+
+	/// Remove all values under the first key `k1` in the overlay and up to `limit` in the
+	/// backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear_prefix` instead"]
+	fn remove_prefix<KArg1>(k1: KArg1, limit: Option<u32>) -> sp_io::KillStorageResult
+	where
+		KArg1: ?Sized + EncodeLike<K1>;
+
+	/// Remove all values under the first key `k1` in the overlay and up to `maybe_limit` in the
+	/// backend.
+	///
+	/// All values in the client overlay will be deleted, if `maybe_limit` is `Some` then up to
+	/// that number of values are deleted from the client backend, otherwise all values in the
+	/// client backend are deleted.
+	///
+	/// ## Cursors
+	///
+	/// The `maybe_cursor` parameter should be `None` for the first call to initial removal.
+	/// If the resultant `maybe_cursor` is `Some`, then another call is required to complete the
+	/// removal operation. This value must be passed in as the subsequent call's `maybe_cursor`
+	/// parameter. If the resultant `maybe_cursor` is `None`, then the operation is complete and no
+	/// items remain in storage provided that no items were added between the first calls and the
+	/// final call.
+	fn clear_prefix<KArg1>(
+		k1: KArg1,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::MultiRemovalResults
+	where
+		KArg1: ?Sized + EncodeLike<K1>;
+
+	/// Does any value under the first key `k1` (explicitly) exist in storage?
+	/// Might have unexpected behaviour with empty keys, e.g. `[]`.
+	fn contains_prefix<KArg1>(k1: KArg1) -> bool
+	where
+		KArg1: EncodeLike<K1>;
+
+	/// Iterate over values that share the first key.
+	fn iter_prefix_values<KArg1>(k1: KArg1) -> PrefixIterator<V>
+	where
+		KArg1: ?Sized + EncodeLike<K1>;
+
+	/// Mutate the value under the given keys.
+	fn mutate<KArg1, KArg2, R, F>(k1: KArg1, k2: KArg2, f: F) -> R
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Self::Query) -> R;
+
+	/// Mutate the value under the given keys when the closure returns `Ok`.
+	fn try_mutate<KArg1, KArg2, R, E, F>(k1: KArg1, k2: KArg2, f: F) -> Result<R, E>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Self::Query) -> Result<R, E>;
+
+	/// Mutate the value under the given keys. Deletes the item if mutated to a `None`.
+	fn mutate_exists<KArg1, KArg2, R, F>(k1: KArg1, k2: KArg2, f: F) -> R
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Option<V>) -> R;
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	fn try_mutate_exists<KArg1, KArg2, R, E, F>(k1: KArg1, k2: KArg2, f: F) -> Result<R, E>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		F: FnOnce(&mut Option<V>) -> Result<R, E>;
+
+	/// Append the given item to the value in the storage.
+	///
+	/// `V` is required to implement [`StorageAppend`].
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	fn append<Item, EncodeLikeItem, KArg1, KArg2>(k1: KArg1, k2: KArg2, item: EncodeLikeItem)
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		V: StorageAppend<Item>;
+
+	/// Read the length of the storage value without decoding the entire value under the
+	/// given `key1` and `key2`.
+	///
+	/// `V` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	fn decode_len<KArg1, KArg2>(key1: KArg1, key2: KArg2) -> Option<usize>
+	where
+		KArg1: EncodeLike<K1>,
+		KArg2: EncodeLike<K2>,
+		V: StorageDecodeLength,
+	{
+		V::decode_len(&Self::hashed_key_for(key1, key2))
+	}
+
+	/// Migrate an item with the given `key1` and `key2` from defunct `OldHasher1` and
+	/// `OldHasher2` to the current hashers.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	fn migrate_keys<
+		OldHasher1: StorageHasher,
+		OldHasher2: StorageHasher,
+		KeyArg1: EncodeLike<K1>,
+		KeyArg2: EncodeLike<K2>,
+	>(
+		key1: KeyArg1,
+		key2: KeyArg2,
+	) -> Option<V>;
+}
+
+/// An implementation of a map with an arbitrary number of keys.
+///
+/// Details of implementation can be found at [`generator::StorageNMap`].
+pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
+	/// The type that get/take returns.
+	type Query;
+
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	fn hashed_key_for<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8>;
+
+	/// Does the value (explicitly) exist in storage?
+	fn contains_key<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> bool;
+
+	/// Load the value associated with the given key from the map.
+	fn get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query;
+
+	/// Try to get the value for the given key from the map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	fn try_get<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Result<V, ()>;
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	fn set<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg, query: Self::Query);
+
+	/// Swap the values of two keys.
+	fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
+	where
+		KOther: KeyGenerator,
+		KArg1: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		KArg2: EncodeLikeTuple<KOther::KArg> + TupleToEncodedIter;
+
+	/// Store a value to be associated with the given key from the map.
+	fn insert<KArg, VArg>(key: KArg, val: VArg)
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		VArg: EncodeLike<V>;
+
+	/// Remove the value under a key.
+	fn remove<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg);
+
+	/// Remove all values starting with `partial_key` in the overlay and up to `limit` in the
+	/// backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear_prefix` instead"]
+	fn remove_prefix<KP>(partial_key: KP, limit: Option<u32>) -> sp_io::KillStorageResult
+	where
+		K: HasKeyPrefix<KP>;
+
+	/// Attempt to remove items from the map matching a `partial_key` prefix.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map which match the `partial key`. If so, then the map may not be
+	/// empty when the resultant `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must be provided in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map and `partial_key`. Subsequent
+	/// calls operating on the same map/`partial_key` should always pass `Some`, and this should be
+	/// equal to the previous call result's `maybe_cursor` field.
+	fn clear_prefix<KP>(
+		partial_key: KP,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::MultiRemovalResults
+	where
+		K: HasKeyPrefix<KP>;
+
+	/// Does any value under a `partial_key` prefix (explicitly) exist in storage?
+	/// Might have unexpected behaviour with empty keys, e.g. `[]`.
+	fn contains_prefix<KP>(partial_key: KP) -> bool
+	where
+		K: HasKeyPrefix<KP>;
+
+	/// Iterate over values that share the partial prefix key.
+	fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<V>
+	where
+		K: HasKeyPrefix<KP>;
+
+	/// Mutate the value under a key.
+	fn mutate<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Self::Query) -> R;
+
+	/// Mutate the item, only if an `Ok` value is returned.
+	fn try_mutate<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Self::Query) -> Result<R, E>;
+
+	/// Mutate the value under a key.
+	///
+	/// Deletes the item if mutated to a `None`.
+	fn mutate_exists<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<V>) -> R;
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	fn try_mutate_exists<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<V>) -> Result<R, E>;
+
+	/// Take the value under a key.
+	fn take<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Self::Query;
+
+	/// Append the given items to the value in the storage.
+	///
+	/// `V` is required to implement `codec::EncodeAppend`.
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		V: StorageAppend<Item>;
+
+	/// Read the length of the storage value without decoding the entire value under the
+	/// given `key`.
+	///
+	/// `V` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	fn decode_len<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Option<usize>
+	where
+		V: StorageDecodeLength,
+	{
+		V::decode_len(&Self::hashed_key_for(key))
+	}
+
+	/// Migrate an item with the given `key` from defunct `hash_fns` to the current hashers.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	fn migrate_keys<KArg>(key: KArg, hash_fns: K::HArg) -> Option<V>
+	where
+		KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter;
+}
+
+/// Iterate or drain over a prefix and decode raw_key and raw_value into `T`.
+///
+/// If any decoding fails it skips it and continues to the next key.
+///
+/// If draining, then the hook `OnRemoval::on_removal` is called after each removal.
+pub struct PrefixIterator<T, OnRemoval = ()> {
+	prefix: Vec<u8>,
+	previous_key: Vec<u8>,
+	/// If true then value are removed while iterating
+	drain: bool,
+	/// Function that take `(raw_key_without_prefix, raw_value)` and decode `T`.
+	/// `raw_key_without_prefix` is the raw storage key without the prefix iterated on.
+	closure: fn(&[u8], &[u8]) -> Result<T, codec::Error>,
+	phantom: core::marker::PhantomData<OnRemoval>,
+}
+
+impl<T, OnRemoval1> PrefixIterator<T, OnRemoval1> {
+	/// Converts to the same iterator but with the different 'OnRemoval' type
+	pub fn convert_on_removal<OnRemoval2>(self) -> PrefixIterator<T, OnRemoval2> {
+		PrefixIterator::<T, OnRemoval2> {
+			prefix: self.prefix,
+			previous_key: self.previous_key,
+			drain: self.drain,
+			closure: self.closure,
+			phantom: Default::default(),
+		}
+	}
+}
+
+/// Trait for specialising on removal logic of [`PrefixIterator`].
+pub trait PrefixIteratorOnRemoval {
+	/// This function is called whenever a key/value is removed.
+	fn on_removal(key: &[u8], value: &[u8]);
+}
+
+/// No-op implementation.
+impl PrefixIteratorOnRemoval for () {
+	fn on_removal(_key: &[u8], _value: &[u8]) {}
+}
+
+impl<T, OnRemoval> PrefixIterator<T, OnRemoval> {
+	/// Creates a new `PrefixIterator`, iterating after `previous_key` and filtering out keys that
+	/// are not prefixed with `prefix`.
+	///
+	/// A `decode_fn` function must also be supplied, and it takes in two `&[u8]` parameters,
+	/// returning a `Result` containing the decoded type `T` if successful, and a `codec::Error` on
+	/// failure. The first `&[u8]` argument represents the raw, undecoded key without the prefix of
+	/// the current item, while the second `&[u8]` argument denotes the corresponding raw,
+	/// undecoded value.
+	pub fn new(
+		prefix: Vec<u8>,
+		previous_key: Vec<u8>,
+		decode_fn: fn(&[u8], &[u8]) -> Result<T, codec::Error>,
+	) -> Self {
+		PrefixIterator {
+			prefix,
+			previous_key,
+			drain: false,
+			closure: decode_fn,
+			phantom: Default::default(),
+		}
+	}
+
+	/// Get the last key that has been iterated upon and return it.
+	pub fn last_raw_key(&self) -> &[u8] {
+		&self.previous_key
+	}
+
+	/// Get the prefix that is being iterated upon for this iterator and return it.
+	pub fn prefix(&self) -> &[u8] {
+		&self.prefix
+	}
+
+	/// Set the key that the iterator should start iterating after.
+	pub fn set_last_raw_key(&mut self, previous_key: Vec<u8>) {
+		self.previous_key = previous_key;
+	}
+
+	/// Mutate this iterator into a draining iterator; items iterated are removed from storage.
+	pub fn drain(mut self) -> Self {
+		self.drain = true;
+		self
+	}
+}
+
+impl<T, OnRemoval: PrefixIteratorOnRemoval> Iterator for PrefixIterator<T, OnRemoval> {
+	type Item = T;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		loop {
+			let maybe_next = sp_io::storage::next_key(&self.previous_key)
+				.filter(|n| n.starts_with(&self.prefix));
+			break match maybe_next {
+				Some(next) => {
+					self.previous_key = next;
+					let raw_value = match unhashed::get_raw(&self.previous_key) {
+						Some(raw_value) => raw_value,
+						None => {
+							log::error!(
+								"next_key returned a key with no value at {:?}",
+								self.previous_key,
+							);
+							continue
+						},
+					};
+					if self.drain {
+						unhashed::kill(&self.previous_key);
+						OnRemoval::on_removal(&self.previous_key, &raw_value);
+					}
+					let raw_key_without_prefix = &self.previous_key[self.prefix.len()..];
+					let item = match (self.closure)(raw_key_without_prefix, &raw_value[..]) {
+						Ok(item) => item,
+						Err(e) => {
+							log::error!(
+								"(key, value) failed to decode at {:?}: {:?}",
+								self.previous_key,
+								e,
+							);
+							continue
+						},
+					};
+
+					Some(item)
+				},
+				None => None,
+			}
+		}
+	}
+}
+
+/// Iterate over a prefix and decode raw_key into `T`.
+///
+/// If any decoding fails it skips it and continues to the next key.
+pub struct KeyPrefixIterator<T> {
+	prefix: Vec<u8>,
+	previous_key: Vec<u8>,
+	/// If true then value are removed while iterating
+	drain: bool,
+	/// Function that take `raw_key_without_prefix` and decode `T`.
+	/// `raw_key_without_prefix` is the raw storage key without the prefix iterated on.
+	closure: fn(&[u8]) -> Result<T, codec::Error>,
+}
+
+impl<T> KeyPrefixIterator<T> {
+	/// Creates a new `KeyPrefixIterator`, iterating after `previous_key` and filtering out keys
+	/// that are not prefixed with `prefix`.
+	///
+	/// A `decode_fn` function must also be supplied, and it takes in a `&[u8]` parameter, returning
+	/// a `Result` containing the decoded key type `T` if successful, and a `codec::Error` on
+	/// failure. The `&[u8]` argument represents the raw, undecoded key without the prefix of the
+	/// current item.
+	pub fn new(
+		prefix: Vec<u8>,
+		previous_key: Vec<u8>,
+		decode_fn: fn(&[u8]) -> Result<T, codec::Error>,
+	) -> Self {
+		KeyPrefixIterator { prefix, previous_key, drain: false, closure: decode_fn }
+	}
+
+	/// Get the last key that has been iterated upon and return it.
+	pub fn last_raw_key(&self) -> &[u8] {
+		&self.previous_key
+	}
+
+	/// Get the prefix that is being iterated upon for this iterator and return it.
+	pub fn prefix(&self) -> &[u8] {
+		&self.prefix
+	}
+
+	/// Set the key that the iterator should start iterating after.
+	pub fn set_last_raw_key(&mut self, previous_key: Vec<u8>) {
+		self.previous_key = previous_key;
+	}
+
+	/// Mutate this iterator into a draining iterator; items iterated are removed from storage.
+	pub fn drain(mut self) -> Self {
+		self.drain = true;
+		self
+	}
+}
+
+impl<T> Iterator for KeyPrefixIterator<T> {
+	type Item = T;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		loop {
+			let maybe_next = sp_io::storage::next_key(&self.previous_key)
+				.filter(|n| n.starts_with(&self.prefix));
+
+			if let Some(next) = maybe_next {
+				self.previous_key = next;
+				if self.drain {
+					unhashed::kill(&self.previous_key);
+				}
+				let raw_key_without_prefix = &self.previous_key[self.prefix.len()..];
+
+				match (self.closure)(raw_key_without_prefix) {
+					Ok(item) => return Some(item),
+					Err(e) => {
+						log::error!("key failed to decode at {:?}: {:?}", self.previous_key, e);
+						continue
+					},
+				}
+			}
+
+			return None
+		}
+	}
+}
+
+/// Iterate over a prefix of a child trie and decode raw_key and raw_value into `T`.
+///
+/// If any decoding fails it skips the key and continues to the next one.
+pub struct ChildTriePrefixIterator<T> {
+	/// The prefix iterated on
+	prefix: Vec<u8>,
+	/// child info for child trie
+	child_info: ChildInfo,
+	/// The last key iterated on
+	previous_key: Vec<u8>,
+	/// If true then values are removed while iterating
+	drain: bool,
+	/// Whether or not we should fetch the previous key
+	fetch_previous_key: bool,
+	/// Function that takes `(raw_key_without_prefix, raw_value)` and decode `T`.
+	/// `raw_key_without_prefix` is the raw storage key without the prefix iterated on.
+	closure: fn(&[u8], &[u8]) -> Result<T, codec::Error>,
+}
+
+impl<T> ChildTriePrefixIterator<T> {
+	/// Mutate this iterator into a draining iterator; items iterated are removed from storage.
+	pub fn drain(mut self) -> Self {
+		self.drain = true;
+		self
+	}
+}
+
+impl<T: Decode + Sized> ChildTriePrefixIterator<(Vec<u8>, T)> {
+	/// Construct iterator to iterate over child trie items in `child_info` with the prefix
+	/// `prefix`.
+	///
+	/// NOTE: Iterator with [`Self::drain`] will remove any value who failed to decode
+	pub fn with_prefix(child_info: &ChildInfo, prefix: &[u8]) -> Self {
+		let prefix = prefix.to_vec();
+		let previous_key = prefix.clone();
+		let closure = |raw_key_without_prefix: &[u8], mut raw_value: &[u8]| {
+			let value = T::decode(&mut raw_value)?;
+			Ok((raw_key_without_prefix.to_vec(), value))
+		};
+
+		Self {
+			prefix,
+			child_info: child_info.clone(),
+			previous_key,
+			drain: false,
+			fetch_previous_key: true,
+			closure,
+		}
+	}
+}
+
+impl<K: Decode + Sized, T: Decode + Sized> ChildTriePrefixIterator<(K, T)> {
+	/// Construct iterator to iterate over child trie items in `child_info` with the prefix
+	/// `prefix`.
+	///
+	/// NOTE: Iterator with [`Self::drain`] will remove any key or value who failed to decode
+	pub fn with_prefix_over_key<H: ReversibleStorageHasher>(
+		child_info: &ChildInfo,
+		prefix: &[u8],
+	) -> Self {
+		let prefix = prefix.to_vec();
+		let previous_key = prefix.clone();
+		let closure = |raw_key_without_prefix: &[u8], mut raw_value: &[u8]| {
+			let mut key_material = H::reverse(raw_key_without_prefix);
+			let key = K::decode(&mut key_material)?;
+			let value = T::decode(&mut raw_value)?;
+			Ok((key, value))
+		};
+
+		Self {
+			prefix,
+			child_info: child_info.clone(),
+			previous_key,
+			drain: false,
+			fetch_previous_key: true,
+			closure,
+		}
+	}
+}
+
+impl<T> Iterator for ChildTriePrefixIterator<T> {
+	type Item = T;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		loop {
+			let maybe_next = if self.fetch_previous_key {
+				self.fetch_previous_key = false;
+				Some(self.previous_key.clone())
+			} else {
+				sp_io::default_child_storage::next_key(
+					self.child_info.storage_key(),
+					&self.previous_key,
+				)
+				.filter(|n| n.starts_with(&self.prefix))
+			};
+			break match maybe_next {
+				Some(next) => {
+					self.previous_key = next;
+					let raw_value = match child::get_raw(&self.child_info, &self.previous_key) {
+						Some(raw_value) => raw_value,
+						None => {
+							log::error!(
+								"next_key returned a key with no value at {:?}",
+								self.previous_key,
+							);
+							continue
+						},
+					};
+					if self.drain {
+						child::kill(&self.child_info, &self.previous_key)
+					}
+					let raw_key_without_prefix = &self.previous_key[self.prefix.len()..];
+					let item = match (self.closure)(raw_key_without_prefix, &raw_value[..]) {
+						Ok(item) => item,
+						Err(e) => {
+							log::error!(
+								"(key, value) failed to decode at {:?}: {:?}",
+								self.previous_key,
+								e,
+							);
+							continue
+						},
+					};
+
+					Some(item)
+				},
+				None => None,
+			}
+		}
+	}
+}
+
+/// Trait for storage types that store all its value after a unique prefix.
+pub trait StoragePrefixedContainer {
+	/// Module prefix. Used for generating final key.
+	fn module_prefix() -> &'static [u8];
+
+	/// Storage prefix. Used for generating final key.
+	fn storage_prefix() -> &'static [u8];
+
+	/// Final full prefix that prefixes all keys.
+	fn final_prefix() -> [u8; 32] {
+		crate::storage::storage_prefix(Self::module_prefix(), Self::storage_prefix())
+	}
+}
+
+/// Trait for maps that store all its value after a unique prefix.
+///
+/// By default the final prefix is:
+/// ```nocompile
+/// Twox128(module_prefix) ++ Twox128(storage_prefix)
+/// ```
+pub trait StoragePrefixedMap<Value: FullCodec> {
+	/// Module prefix. Used for generating final key.
+	fn module_prefix() -> &'static [u8]; // TODO move to StoragePrefixedContainer
+
+	/// Storage prefix. Used for generating final key.
+	fn storage_prefix() -> &'static [u8];
+
+	/// Final full prefix that prefixes all keys.
+	fn final_prefix() -> [u8; 32] {
+		crate::storage::storage_prefix(Self::module_prefix(), Self::storage_prefix())
+	}
+
+	/// Remove all values in the overlay and up to `limit` in the backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear` instead"]
+	fn remove_all(limit: Option<u32>) -> sp_io::KillStorageResult {
+		unhashed::clear_prefix(&Self::final_prefix(), limit, None).into()
+	}
+
+	/// Attempt to remove all items from the map.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map. If so, then the map may not be empty when the resultant
+	/// `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must always be provided through in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map. Subsequent calls
+	/// operating on the same map should always pass `Some`, and this should be equal to the
+	/// previous call result's `maybe_cursor` field.
+	fn clear(limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::MultiRemovalResults {
+		unhashed::clear_prefix(&Self::final_prefix(), Some(limit), maybe_cursor)
+	}
+
+	/// Iter over all value of the storage.
+	///
+	/// NOTE: If a value failed to decode because storage is corrupted then it is skipped.
+	fn iter_values() -> PrefixIterator<Value> {
+		let prefix = Self::final_prefix();
+		PrefixIterator {
+			prefix: prefix.to_vec(),
+			previous_key: prefix.to_vec(),
+			drain: false,
+			closure: |_raw_key, mut raw_value| Value::decode(&mut raw_value),
+			phantom: Default::default(),
+		}
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade.
+	fn translate_values<OldValue: Decode, F: FnMut(OldValue) -> Option<Value>>(mut f: F) {
+		let prefix = Self::final_prefix();
+		let mut previous_key = prefix.clone().to_vec();
+		while let Some(next) =
+			sp_io::storage::next_key(&previous_key).filter(|n| n.starts_with(&prefix))
+		{
+			previous_key = next;
+			let maybe_value = unhashed::get::<OldValue>(&previous_key);
+			match maybe_value {
+				Some(value) => match f(value) {
+					Some(new) => unhashed::put::<Value>(&previous_key, &new),
+					None => unhashed::kill(&previous_key),
+				},
+				None => {
+					log::error!("old key failed to decode at {:?}", previous_key);
+					continue
+				},
+			}
+		}
+	}
+}
+
+/// Marker trait that will be implemented for types that support the `storage::append` api.
+///
+/// This trait is sealed.
+pub trait StorageAppend<Item: Encode>: private::Sealed {}
+
+/// Marker trait that will be implemented for types that support to decode their length in an
+/// efficient way. It is expected that the length is at the beginning of the encoded object
+/// and that the length is a `Compact<u32>`.
+///
+/// This trait is sealed.
+pub trait StorageDecodeLength: private::Sealed + codec::DecodeLength {
+	/// Decode the length of the storage value at `key`.
+	///
+	/// This function assumes that the length is at the beginning of the encoded object
+	/// and is a `Compact<u32>`.
+	///
+	/// Returns `None` if the storage value does not exist or the decoding failed.
+	fn decode_len(key: &[u8]) -> Option<usize> {
+		// `Compact<u32>` is 5 bytes in maximum.
+		let mut data = [0u8; 5];
+		let len = sp_io::storage::read(key, &mut data, 0)?;
+		let len = data.len().min(len as usize);
+		<Self as codec::DecodeLength>::len(&data[..len]).ok()
+	}
+}
+
+/// Provides `Sealed` trait to prevent implementing trait `StorageAppend` & `StorageDecodeLength`
+/// & `EncodeLikeTuple` outside of this crate.
+mod private {
+	use super::*;
+	use bounded_vec::BoundedVec;
+	use weak_bounded_vec::WeakBoundedVec;
+
+	pub trait Sealed {}
+
+	impl<T: Encode> Sealed for Vec<T> {}
+	impl Sealed for Digest {}
+	impl<T, S> Sealed for BoundedVec<T, S> {}
+	impl<T, S> Sealed for WeakBoundedVec<T, S> {}
+	impl<K, V, S> Sealed for bounded_btree_map::BoundedBTreeMap<K, V, S> {}
+	impl<T, S> Sealed for bounded_btree_set::BoundedBTreeSet<T, S> {}
+	impl<T: Encode> Sealed for BTreeSet<T> {}
+	impl<'a, T: EncodeLike<U>, U: Encode> Sealed for codec::Ref<'a, T, U> {}
+
+	macro_rules! impl_sealed_for_tuple {
+		($($elem:ident),+) => {
+			paste::paste! {
+				impl<$($elem: Encode,)+> Sealed for ($($elem,)+) {}
+				impl<$($elem: Encode,)+> Sealed for &($($elem,)+) {}
+			}
+		};
+	}
+
+	impl_sealed_for_tuple!(A);
+	impl_sealed_for_tuple!(A, B);
+	impl_sealed_for_tuple!(A, B, C);
+	impl_sealed_for_tuple!(A, B, C, D);
+	impl_sealed_for_tuple!(A, B, C, D, E);
+	impl_sealed_for_tuple!(A, B, C, D, E, F);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J, K);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, O);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, O, P);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, O, P, Q);
+	impl_sealed_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, O, P, Q, R);
+}
+
+impl<T: Encode> StorageAppend<T> for Vec<T> {}
+impl<T: Encode> StorageDecodeLength for Vec<T> {}
+
+impl<T: Encode> StorageAppend<T> for BTreeSet<T> {}
+impl<T: Encode> StorageDecodeLength for BTreeSet<T> {}
+
+/// We abuse the fact that SCALE does not put any marker into the encoding, i.e. we only encode the
+/// internal vec and we can append to this vec. We have a test that ensures that if the `Digest`
+/// format ever changes, we need to remove this here.
+impl StorageAppend<DigestItem> for Digest {}
+
+/// Marker trait that is implemented for types that support the `storage::append` api with a limit
+/// on the number of element.
+///
+/// This trait is sealed.
+pub trait StorageTryAppend<Item>: StorageDecodeLength + private::Sealed {
+	fn bound() -> usize;
+}
+
+/// Storage value that is capable of [`StorageTryAppend`](crate::storage::StorageTryAppend).
+pub trait TryAppendValue<T: StorageTryAppend<I>, I: Encode> {
+	/// Try and append the `item` into the storage item.
+	///
+	/// This might fail if bounds are not respected.
+	fn try_append<LikeI: EncodeLike<I>>(item: LikeI) -> Result<(), ()>;
+}
+
+impl<T, I, StorageValueT> TryAppendValue<T, I> for StorageValueT
+where
+	I: Encode,
+	T: FullCodec + StorageTryAppend<I>,
+	StorageValueT: generator::StorageValue<T>,
+{
+	fn try_append<LikeI: EncodeLike<I>>(item: LikeI) -> Result<(), ()> {
+		let bound = T::bound();
+		let current = Self::decode_len().unwrap_or_default();
+		if current < bound {
+			// NOTE: we cannot reuse the implementation for `Vec<T>` here because we never want to
+			// mark `BoundedVec<T, S>` as `StorageAppend`.
+			let key = Self::storage_value_final_key();
+			sp_io::storage::append(&key, item.encode());
+			Ok(())
+		} else {
+			Err(())
+		}
+	}
+}
+
+/// Storage map that is capable of [`StorageTryAppend`](crate::storage::StorageTryAppend).
+pub trait TryAppendMap<K: Encode, T: StorageTryAppend<I>, I: Encode> {
+	/// Try and append the `item` into the storage map at the given `key`.
+	///
+	/// This might fail if bounds are not respected.
+	fn try_append<LikeK: EncodeLike<K> + Clone, LikeI: EncodeLike<I>>(
+		key: LikeK,
+		item: LikeI,
+	) -> Result<(), ()>;
+}
+
+impl<K, T, I, StorageMapT> TryAppendMap<K, T, I> for StorageMapT
+where
+	K: FullCodec,
+	T: FullCodec + StorageTryAppend<I>,
+	I: Encode,
+	StorageMapT: generator::StorageMap<K, T>,
+{
+	fn try_append<LikeK: EncodeLike<K> + Clone, LikeI: EncodeLike<I>>(
+		key: LikeK,
+		item: LikeI,
+	) -> Result<(), ()> {
+		let bound = T::bound();
+		let current = Self::decode_len(key.clone()).unwrap_or_default();
+		if current < bound {
+			let key = Self::storage_map_final_key(key);
+			sp_io::storage::append(&key, item.encode());
+			Ok(())
+		} else {
+			Err(())
+		}
+	}
+}
+
+/// Storage double map that is capable of [`StorageTryAppend`](crate::storage::StorageTryAppend).
+pub trait TryAppendDoubleMap<K1: Encode, K2: Encode, T: StorageTryAppend<I>, I: Encode> {
+	/// Try and append the `item` into the storage double map at the given `key`.
+	///
+	/// This might fail if bounds are not respected.
+	fn try_append<
+		LikeK1: EncodeLike<K1> + Clone,
+		LikeK2: EncodeLike<K2> + Clone,
+		LikeI: EncodeLike<I>,
+	>(
+		key1: LikeK1,
+		key2: LikeK2,
+		item: LikeI,
+	) -> Result<(), ()>;
+}
+
+impl<K1, K2, T, I, StorageDoubleMapT> TryAppendDoubleMap<K1, K2, T, I> for StorageDoubleMapT
+where
+	K1: FullCodec,
+	K2: FullCodec,
+	T: FullCodec + StorageTryAppend<I>,
+	I: Encode,
+	StorageDoubleMapT: generator::StorageDoubleMap<K1, K2, T>,
+{
+	fn try_append<
+		LikeK1: EncodeLike<K1> + Clone,
+		LikeK2: EncodeLike<K2> + Clone,
+		LikeI: EncodeLike<I>,
+	>(
+		key1: LikeK1,
+		key2: LikeK2,
+		item: LikeI,
+	) -> Result<(), ()> {
+		let bound = T::bound();
+		let current = Self::decode_len(key1.clone(), key2.clone()).unwrap_or_default();
+		if current < bound {
+			let double_map_key = Self::storage_double_map_final_key(key1, key2);
+			sp_io::storage::append(&double_map_key, item.encode());
+			Ok(())
+		} else {
+			Err(())
+		}
+	}
+}
+
+/// Returns the storage prefix for a specific pallet name and storage name.
+///
+/// The storage prefix is `concat(twox_128(pallet_name), twox_128(storage_name))`.
+pub fn storage_prefix(pallet_name: &[u8], storage_name: &[u8]) -> [u8; 32] {
+	let pallet_hash = sp_io::hashing::twox_128(pallet_name);
+	let storage_hash = sp_io::hashing::twox_128(storage_name);
+
+	let mut final_key = [0u8; 32];
+	final_key[..16].copy_from_slice(&pallet_hash);
+	final_key[16..].copy_from_slice(&storage_hash);
+
+	final_key
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{assert_ok, hash::Identity, pallet_prelude::NMapKey, Twox128};
+	use bounded_vec::BoundedVec;
+	use frame_support::traits::ConstU32;
+	use generator::StorageValue as _;
+	use sp_core::hashing::twox_128;
+	use sp_io::TestExternalities;
+	use weak_bounded_vec::WeakBoundedVec;
+
+	#[test]
+	fn prefixed_map_works() {
+		TestExternalities::default().execute_with(|| {
+			struct MyStorage;
+			impl StoragePrefixedMap<u64> for MyStorage {
+				fn module_prefix() -> &'static [u8] {
+					b"MyModule"
+				}
+
+				fn storage_prefix() -> &'static [u8] {
+					b"MyStorage"
+				}
+			}
+
+			let key_before = {
+				let mut k = MyStorage::final_prefix();
+				let last = k.iter_mut().last().unwrap();
+				*last = last.checked_sub(1).unwrap();
+				k
+			};
+			let key_after = {
+				let mut k = MyStorage::final_prefix();
+				let last = k.iter_mut().last().unwrap();
+				*last = last.checked_add(1).unwrap();
+				k
+			};
+
+			unhashed::put(&key_before[..], &32u64);
+			unhashed::put(&key_after[..], &33u64);
+
+			let k = [twox_128(b"MyModule"), twox_128(b"MyStorage")].concat();
+			assert_eq!(MyStorage::final_prefix().to_vec(), k);
+
+			// test iteration
+			assert!(MyStorage::iter_values().collect::<Vec<_>>().is_empty());
+
+			unhashed::put(&[&k[..], &vec![1][..]].concat(), &1u64);
+			unhashed::put(&[&k[..], &vec![1, 1][..]].concat(), &2u64);
+			unhashed::put(&[&k[..], &vec![8][..]].concat(), &3u64);
+			unhashed::put(&[&k[..], &vec![10][..]].concat(), &4u64);
+
+			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![1, 2, 3, 4]);
+
+			// test removal
+			let _ = MyStorage::clear(u32::max_value(), None);
+			assert!(MyStorage::iter_values().collect::<Vec<_>>().is_empty());
+
+			// test migration
+			unhashed::put(&[&k[..], &vec![1][..]].concat(), &1u32);
+			unhashed::put(&[&k[..], &vec![8][..]].concat(), &2u32);
+
+			assert!(MyStorage::iter_values().collect::<Vec<_>>().is_empty());
+			MyStorage::translate_values(|v: u32| Some(v as u64));
+			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![1, 2]);
+			let _ = MyStorage::clear(u32::max_value(), None);
+
+			// test migration 2
+			unhashed::put(&[&k[..], &vec![1][..]].concat(), &1u128);
+			unhashed::put(&[&k[..], &vec![1, 1][..]].concat(), &2u64);
+			unhashed::put(&[&k[..], &vec![8][..]].concat(), &3u128);
+			unhashed::put(&[&k[..], &vec![10][..]].concat(), &4u32);
+
+			// (contains some value that successfully decoded to u64)
+			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![1, 2, 3]);
+			MyStorage::translate_values(|v: u128| Some(v as u64));
+			assert_eq!(MyStorage::iter_values().collect::<Vec<_>>(), vec![1, 2, 3]);
+			let _ = MyStorage::clear(u32::max_value(), None);
+
+			// test that other values are not modified.
+			assert_eq!(unhashed::get(&key_before[..]), Some(32u64));
+			assert_eq!(unhashed::get(&key_after[..]), Some(33u64));
+		});
+	}
+
+	// This test ensures that the Digest encoding does not change without being noticied.
+	#[test]
+	fn digest_storage_append_works_as_expected() {
+		TestExternalities::default().execute_with(|| {
+			struct Storage;
+			impl generator::StorageValue<Digest> for Storage {
+				type Query = Digest;
+
+				fn module_prefix() -> &'static [u8] {
+					b"MyModule"
+				}
+
+				fn storage_prefix() -> &'static [u8] {
+					b"Storage"
+				}
+
+				fn from_optional_value_to_query(v: Option<Digest>) -> Self::Query {
+					v.unwrap()
+				}
+
+				fn from_query_to_optional_value(v: Self::Query) -> Option<Digest> {
+					Some(v)
+				}
+			}
+
+			Storage::append(DigestItem::Other(Vec::new()));
+
+			let value = unhashed::get_raw(&Storage::storage_value_final_key()).unwrap();
+
+			let expected = Digest { logs: vec![DigestItem::Other(Vec::new())] };
+			assert_eq!(Digest::decode(&mut &value[..]).unwrap(), expected);
+		});
+	}
+
+	#[test]
+	fn key_prefix_iterator_works() {
+		TestExternalities::default().execute_with(|| {
+			use crate::{hash::Twox64Concat, storage::generator::StorageMap};
+			struct MyStorageMap;
+			impl StorageMap<u64, u64> for MyStorageMap {
+				type Query = u64;
+				type Hasher = Twox64Concat;
+
+				fn module_prefix() -> &'static [u8] {
+					b"MyModule"
+				}
+
+				fn storage_prefix() -> &'static [u8] {
+					b"MyStorageMap"
+				}
+
+				fn from_optional_value_to_query(v: Option<u64>) -> Self::Query {
+					v.unwrap_or_default()
+				}
+
+				fn from_query_to_optional_value(v: Self::Query) -> Option<u64> {
+					Some(v)
+				}
+			}
+
+			let k = [twox_128(b"MyModule"), twox_128(b"MyStorageMap")].concat();
+			assert_eq!(MyStorageMap::prefix_hash().to_vec(), k);
+
+			// empty to start
+			assert!(MyStorageMap::iter_keys().collect::<Vec<_>>().is_empty());
+
+			MyStorageMap::insert(1, 10);
+			MyStorageMap::insert(2, 20);
+			MyStorageMap::insert(3, 30);
+			MyStorageMap::insert(4, 40);
+
+			// just looking
+			let mut keys = MyStorageMap::iter_keys().collect::<Vec<_>>();
+			keys.sort();
+			assert_eq!(keys, vec![1, 2, 3, 4]);
+
+			// draining the keys and values
+			let mut drained_keys = MyStorageMap::iter_keys().drain().collect::<Vec<_>>();
+			drained_keys.sort();
+			assert_eq!(drained_keys, vec![1, 2, 3, 4]);
+
+			// empty again
+			assert!(MyStorageMap::iter_keys().collect::<Vec<_>>().is_empty());
+		});
+	}
+
+	#[test]
+	fn prefix_iterator_pagination_works() {
+		TestExternalities::default().execute_with(|| {
+			use crate::{hash::Identity, storage::generator::map::StorageMap};
+			#[crate::storage_alias]
+			type MyStorageMap = StorageMap<MyModule, Identity, u64, u64>;
+
+			MyStorageMap::insert(1, 10);
+			MyStorageMap::insert(2, 20);
+			MyStorageMap::insert(3, 30);
+			MyStorageMap::insert(4, 40);
+			MyStorageMap::insert(5, 50);
+			MyStorageMap::insert(6, 60);
+			MyStorageMap::insert(7, 70);
+			MyStorageMap::insert(8, 80);
+			MyStorageMap::insert(9, 90);
+			MyStorageMap::insert(10, 100);
+
+			let op = |(_, v)| v / 10;
+			let mut final_vec = vec![];
+			let mut iter = MyStorageMap::iter();
+
+			let elem = iter.next().unwrap();
+			assert_eq!(elem, (1, 10));
+			final_vec.push(op(elem));
+
+			let elem = iter.next().unwrap();
+			assert_eq!(elem, (2, 20));
+			final_vec.push(op(elem));
+
+			let stored_key = iter.last_raw_key().to_owned();
+			assert_eq!(stored_key, MyStorageMap::storage_map_final_key(2));
+
+			let mut iter = MyStorageMap::iter_from(stored_key.clone());
+
+			final_vec.push(op(iter.next().unwrap()));
+			final_vec.push(op(iter.next().unwrap()));
+			final_vec.push(op(iter.next().unwrap()));
+
+			assert_eq!(final_vec, vec![1, 2, 3, 4, 5]);
+
+			let mut iter = PrefixIterator::<_>::new(
+				iter.prefix().to_vec(),
+				stored_key,
+				|mut raw_key_without_prefix, mut raw_value| {
+					let key = u64::decode(&mut raw_key_without_prefix)?;
+					Ok((key, u64::decode(&mut raw_value)?))
+				},
+			);
+			let previous_key = MyStorageMap::storage_map_final_key(5);
+			iter.set_last_raw_key(previous_key);
+
+			let remaining = iter.map(op).collect::<Vec<_>>();
+			assert_eq!(remaining.len(), 5);
+			assert_eq!(remaining, vec![6, 7, 8, 9, 10]);
+
+			final_vec.extend_from_slice(&remaining);
+
+			assert_eq!(final_vec, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+		});
+	}
+
+	#[test]
+	fn child_trie_prefixed_map_works() {
+		TestExternalities::default().execute_with(|| {
+			let child_info_a = child::ChildInfo::new_default(b"a");
+			child::put(&child_info_a, &[1, 2, 3], &8u16);
+			child::put(&child_info_a, &[2], &8u16);
+			child::put(&child_info_a, &[2, 1, 3], &8u8);
+			child::put(&child_info_a, &[2, 2, 3], &8u16);
+			child::put(&child_info_a, &[3], &8u16);
+
+			assert_eq!(
+				ChildTriePrefixIterator::with_prefix(&child_info_a, &[2])
+					.collect::<Vec<(Vec<u8>, u16)>>(),
+				vec![(vec![], 8), (vec![2, 3], 8),],
+			);
+
+			assert_eq!(
+				ChildTriePrefixIterator::with_prefix(&child_info_a, &[2])
+					.drain()
+					.collect::<Vec<(Vec<u8>, u16)>>(),
+				vec![(vec![], 8), (vec![2, 3], 8),],
+			);
+
+			// The only remaining is the ones outside prefix
+			assert_eq!(
+				ChildTriePrefixIterator::with_prefix(&child_info_a, &[])
+					.collect::<Vec<(Vec<u8>, u8)>>(),
+				vec![(vec![1, 2, 3], 8), (vec![3], 8),],
+			);
+
+			child::put(&child_info_a, &[1, 2, 3], &8u16);
+			child::put(&child_info_a, &[2], &8u16);
+			child::put(&child_info_a, &[2, 1, 3], &8u8);
+			child::put(&child_info_a, &[2, 2, 3], &8u16);
+			child::put(&child_info_a, &[3], &8u16);
+
+			assert_eq!(
+				ChildTriePrefixIterator::with_prefix_over_key::<Identity>(&child_info_a, &[2])
+					.collect::<Vec<(u16, u16)>>(),
+				vec![(u16::decode(&mut &[2, 3][..]).unwrap(), 8),],
+			);
+
+			assert_eq!(
+				ChildTriePrefixIterator::with_prefix_over_key::<Identity>(&child_info_a, &[2])
+					.drain()
+					.collect::<Vec<(u16, u16)>>(),
+				vec![(u16::decode(&mut &[2, 3][..]).unwrap(), 8),],
+			);
+
+			// The only remaining is the ones outside prefix
+			assert_eq!(
+				ChildTriePrefixIterator::with_prefix(&child_info_a, &[])
+					.collect::<Vec<(Vec<u8>, u8)>>(),
+				vec![(vec![1, 2, 3], 8), (vec![3], 8),],
+			);
+		});
+	}
+
+	#[crate::storage_alias]
+	type Foo = StorageValue<Prefix, WeakBoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooMap = StorageMap<Prefix, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooDoubleMap =
+		StorageDoubleMap<Prefix, Twox128, u32, Twox128, u32, BoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooTripleMap = StorageNMap<
+		Prefix,
+		(NMapKey<Twox128, u32>, NMapKey<Twox128, u32>, NMapKey<Twox128, u32>),
+		u64,
+	>;
+
+	#[test]
+	fn contains_prefix_works() {
+		TestExternalities::default().execute_with(|| {
+			// Test double maps
+			assert!(FooDoubleMap::iter_prefix_values(1).next().is_none());
+			assert_eq!(FooDoubleMap::contains_prefix(1), false);
+
+			assert_ok!(FooDoubleMap::try_append(1, 1, 4));
+			assert_ok!(FooDoubleMap::try_append(2, 1, 4));
+			assert!(FooDoubleMap::iter_prefix_values(1).next().is_some());
+			assert!(FooDoubleMap::contains_prefix(1));
+			FooDoubleMap::remove(1, 1);
+			assert_eq!(FooDoubleMap::contains_prefix(1), false);
+
+			// Test N Maps
+			assert!(FooTripleMap::iter_prefix_values((1,)).next().is_none());
+			assert_eq!(FooTripleMap::contains_prefix((1,)), false);
+
+			FooTripleMap::insert((1, 1, 1), 4);
+			FooTripleMap::insert((2, 1, 1), 4);
+			assert!(FooTripleMap::iter_prefix_values((1,)).next().is_some());
+			assert!(FooTripleMap::contains_prefix((1,)));
+			FooTripleMap::remove((1, 1, 1));
+			assert_eq!(FooTripleMap::contains_prefix((1,)), false);
+		});
+	}
+
+	#[test]
+	fn try_append_works() {
+		TestExternalities::default().execute_with(|| {
+			let bounded: WeakBoundedVec<u32, ConstU32<7>> = vec![1, 2, 3].try_into().unwrap();
+			Foo::put(bounded);
+			assert_ok!(Foo::try_append(4));
+			assert_ok!(Foo::try_append(5));
+			assert_ok!(Foo::try_append(6));
+			assert_ok!(Foo::try_append(7));
+			assert_eq!(Foo::decode_len().unwrap(), 7);
+			assert!(Foo::try_append(8).is_err());
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded: BoundedVec<u32, ConstU32<7>> = vec![1, 2, 3].try_into().unwrap();
+			FooMap::insert(1, bounded);
+
+			assert_ok!(FooMap::try_append(1, 4));
+			assert_ok!(FooMap::try_append(1, 5));
+			assert_ok!(FooMap::try_append(1, 6));
+			assert_ok!(FooMap::try_append(1, 7));
+			assert_eq!(FooMap::decode_len(1).unwrap(), 7);
+			assert!(FooMap::try_append(1, 8).is_err());
+
+			// append to a non-existing
+			assert!(FooMap::get(2).is_none());
+			assert_ok!(FooMap::try_append(2, 4));
+			assert_eq!(
+				FooMap::get(2).unwrap(),
+				BoundedVec::<u32, ConstU32<7>>::try_from(vec![4]).unwrap(),
+			);
+			assert_ok!(FooMap::try_append(2, 5));
+			assert_eq!(
+				FooMap::get(2).unwrap(),
+				BoundedVec::<u32, ConstU32<7>>::try_from(vec![4, 5]).unwrap(),
+			);
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded: BoundedVec<u32, ConstU32<7>> = vec![1, 2, 3].try_into().unwrap();
+			FooDoubleMap::insert(1, 1, bounded);
+
+			assert_ok!(FooDoubleMap::try_append(1, 1, 4));
+			assert_ok!(FooDoubleMap::try_append(1, 1, 5));
+			assert_ok!(FooDoubleMap::try_append(1, 1, 6));
+			assert_ok!(FooDoubleMap::try_append(1, 1, 7));
+			assert_eq!(FooDoubleMap::decode_len(1, 1).unwrap(), 7);
+			assert!(FooDoubleMap::try_append(1, 1, 8).is_err());
+
+			// append to a non-existing
+			assert!(FooDoubleMap::get(2, 1).is_none());
+			assert_ok!(FooDoubleMap::try_append(2, 1, 4));
+			assert_eq!(
+				FooDoubleMap::get(2, 1).unwrap(),
+				BoundedVec::<u32, ConstU32<7>>::try_from(vec![4]).unwrap(),
+			);
+			assert_ok!(FooDoubleMap::try_append(2, 1, 5));
+			assert_eq!(
+				FooDoubleMap::get(2, 1).unwrap(),
+				BoundedVec::<u32, ConstU32<7>>::try_from(vec![4, 5]).unwrap(),
+			);
+		});
+	}
+
+	#[crate::storage_alias]
+	type FooSet = StorageValue<Prefix, BTreeSet<u32>>;
+
+	#[test]
+	fn btree_set_append_and_decode_len_works() {
+		TestExternalities::default().execute_with(|| {
+			let btree = BTreeSet::from([1, 2, 3]);
+			FooSet::put(btree);
+
+			FooSet::append(4);
+			FooSet::append(5);
+			FooSet::append(6);
+			FooSet::append(7);
+
+			assert_eq!(FooSet::decode_len().unwrap(), 7);
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/storage_noop_guard.rs b/substrate/frame/support/src/storage/storage_noop_guard.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d00e6e18ecc484e3139ea27e25e3d580871c8c3c
--- /dev/null
+++ b/substrate/frame/support/src/storage/storage_noop_guard.rs
@@ -0,0 +1,114 @@
+// 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.
+
+// Feature gated since it can panic.
+#![cfg(any(feature = "std", feature = "runtime-benchmarks", feature = "try-runtime", test))]
+
+//! Contains the [`crate::StorageNoopGuard`] for conveniently asserting
+//! that no storage mutation has been made by a whole code block.
+
+/// Asserts that no storage changes took place between con- and destruction of [`Self`].
+///
+/// This is easier than wrapping the whole code-block inside a `assert_storage_noop!`.
+///
+/// # Example
+///
+/// ```should_panic
+/// use frame_support::{StorageNoopGuard, storage::unhashed::put};
+///
+/// sp_io::TestExternalities::default().execute_with(|| {
+/// 	let _guard = frame_support::StorageNoopGuard::default();
+/// 	put(b"key", b"value");
+/// 	// Panics since there are storage changes.
+/// });
+/// ```
+#[must_use]
+pub struct StorageNoopGuard(sp_std::vec::Vec<u8>);
+
+impl Default for StorageNoopGuard {
+	fn default() -> Self {
+		Self(sp_io::storage::root(sp_runtime::StateVersion::V1))
+	}
+}
+
+impl Drop for StorageNoopGuard {
+	fn drop(&mut self) {
+		// No need to double panic, eg. inside a test assertion failure.
+		if sp_std::thread::panicking() {
+			return
+		}
+		assert_eq!(
+			sp_io::storage::root(sp_runtime::StateVersion::V1),
+			self.0,
+			"StorageNoopGuard detected wrongful storage changes.",
+		);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_io::TestExternalities;
+
+	#[test]
+	#[should_panic(expected = "StorageNoopGuard detected wrongful storage changes.")]
+	fn storage_noop_guard_panics_on_changed() {
+		TestExternalities::default().execute_with(|| {
+			let _guard = StorageNoopGuard::default();
+			frame_support::storage::unhashed::put(b"key", b"value");
+		});
+	}
+
+	#[test]
+	fn storage_noop_guard_works_on_unchanged() {
+		TestExternalities::default().execute_with(|| {
+			let _guard = StorageNoopGuard::default();
+			frame_support::storage::unhashed::put(b"key", b"value");
+			frame_support::storage::unhashed::kill(b"key");
+		});
+	}
+
+	#[test]
+	#[should_panic(expected = "StorageNoopGuard detected wrongful storage changes.")]
+	fn storage_noop_guard_panics_on_early_drop() {
+		TestExternalities::default().execute_with(|| {
+			let guard = StorageNoopGuard::default();
+			frame_support::storage::unhashed::put(b"key", b"value");
+			sp_std::mem::drop(guard);
+			frame_support::storage::unhashed::kill(b"key");
+		});
+	}
+
+	#[test]
+	fn storage_noop_guard_works_on_changed_forget() {
+		TestExternalities::default().execute_with(|| {
+			let guard = StorageNoopGuard::default();
+			frame_support::storage::unhashed::put(b"key", b"value");
+			sp_std::mem::forget(guard);
+		});
+	}
+
+	#[test]
+	#[should_panic(expected = "Something else")]
+	fn storage_noop_guard_does_not_double_panic() {
+		TestExternalities::default().execute_with(|| {
+			let _guard = StorageNoopGuard::default();
+			frame_support::storage::unhashed::put(b"key", b"value");
+			panic!("Something else");
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/stream_iter.rs b/substrate/frame/support/src/storage/stream_iter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2205601938b880f88bcdbc20680e7d6254badc8b
--- /dev/null
+++ b/substrate/frame/support/src/storage/stream_iter.rs
@@ -0,0 +1,666 @@
+// 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::{BoundedBTreeMap, BoundedBTreeSet, BoundedVec, WeakBoundedVec};
+use codec::Decode;
+use sp_std::vec::Vec;
+
+/// Provides the sealed trait `StreamIter`.
+mod private {
+	use super::*;
+
+	/// Used as marker trait for types that support stream iteration.
+	pub trait StreamIter {
+		/// The actual iterator implementation.
+		type Iterator: sp_std::iter::Iterator;
+
+		/// Create the stream iterator for the value found at `key`.
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator;
+	}
+
+	impl<T: codec::Decode> StreamIter for Vec<T> {
+		type Iterator = ScaleContainerStreamIter<T>;
+
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator {
+			ScaleContainerStreamIter::new(key)
+		}
+	}
+
+	impl<T: codec::Decode> StreamIter for sp_std::collections::btree_set::BTreeSet<T> {
+		type Iterator = ScaleContainerStreamIter<T>;
+
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator {
+			ScaleContainerStreamIter::new(key)
+		}
+	}
+
+	impl<K: codec::Decode, V: codec::Decode> StreamIter
+		for sp_std::collections::btree_map::BTreeMap<K, V>
+	{
+		type Iterator = ScaleContainerStreamIter<(K, V)>;
+
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator {
+			ScaleContainerStreamIter::new(key)
+		}
+	}
+
+	impl<T: codec::Decode, S> StreamIter for BoundedVec<T, S> {
+		type Iterator = ScaleContainerStreamIter<T>;
+
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator {
+			ScaleContainerStreamIter::new(key)
+		}
+	}
+
+	impl<T: codec::Decode, S> StreamIter for WeakBoundedVec<T, S> {
+		type Iterator = ScaleContainerStreamIter<T>;
+
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator {
+			ScaleContainerStreamIter::new(key)
+		}
+	}
+
+	impl<K: codec::Decode, V: codec::Decode, S> StreamIter for BoundedBTreeMap<K, V, S> {
+		type Iterator = ScaleContainerStreamIter<(K, V)>;
+
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator {
+			ScaleContainerStreamIter::new(key)
+		}
+	}
+
+	impl<T: codec::Decode, S> StreamIter for BoundedBTreeSet<T, S> {
+		type Iterator = ScaleContainerStreamIter<T>;
+
+		fn stream_iter(key: Vec<u8>) -> Self::Iterator {
+			ScaleContainerStreamIter::new(key)
+		}
+	}
+}
+
+/// An iterator that streams values directly from storage.
+///
+/// Requires that `T` implements the sealed trait `StreamIter`.
+///
+/// Instead of loading the entire `T` into memory, the iterator only loads a certain number of bytes
+/// into memory to decode the next `T::Item`. The iterator implementation is allowed to have some
+/// internal buffer to reduce the number of storage reads. The iterator should have an almost
+/// constant memory usage over its lifetime. If at some point there is a decoding error, the
+/// iterator will return `None` to signal that the iterator is finished.
+pub trait StorageStreamIter<T: private::StreamIter> {
+	/// Create the streaming iterator.
+	fn stream_iter() -> T::Iterator;
+}
+
+impl<T: private::StreamIter + codec::FullCodec, StorageValue: super::StorageValue<T>>
+	StorageStreamIter<T> for StorageValue
+{
+	fn stream_iter() -> T::Iterator {
+		T::stream_iter(Self::hashed_key().into())
+	}
+}
+
+/// A streaming iterator implementation for SCALE container types.
+///
+/// SCALE container types follow the same type of encoding `Compact<u32>(len) ++ data`.
+/// This type provides an [`Iterator`](sp_std::iter::Iterator) implementation that decodes
+/// one item after another with each call to [`next`](Self::next). The bytes representing
+/// the container are also not read at once into memory and instead being read in chunks. As long
+/// as individual items are smaller than these chunks the memory usage of this iterator should
+/// be constant. On decoding errors [`next`](Self::next) will return `None` to signal that the
+/// iterator is finished.
+pub struct ScaleContainerStreamIter<T> {
+	marker: sp_std::marker::PhantomData<T>,
+	input: StorageInput,
+	length: u32,
+	read: u32,
+}
+
+impl<T> ScaleContainerStreamIter<T> {
+	/// Creates a new instance of the stream iterator.
+	///
+	/// - `key`: Storage key of the container in the state.
+	///
+	/// Same as [`Self::new_try`], but logs a potential error and sets the length to `0`.
+	pub fn new(key: Vec<u8>) -> Self {
+		let mut input = StorageInput::new(key);
+		let length = if input.exists() {
+			match codec::Compact::<u32>::decode(&mut input) {
+				Ok(length) => length.0,
+				Err(e) => {
+					// TODO #3700: error should be handleable.
+					log::error!(
+						target: "runtime::storage",
+						"Corrupted state at `{:?}`: failed to decode element count: {:?}",
+						input.key,
+						e,
+					);
+
+					0
+				},
+			}
+		} else {
+			0
+		};
+
+		Self { marker: sp_std::marker::PhantomData, input, length, read: 0 }
+	}
+
+	/// Creates a new instance of the stream iterator.
+	///
+	/// - `key`: Storage key of the container in the state.
+	///
+	/// Returns an error if the length of the container fails to decode.
+	pub fn new_try(key: Vec<u8>) -> Result<Self, codec::Error> {
+		let mut input = StorageInput::new(key);
+		let length = if input.exists() { codec::Compact::<u32>::decode(&mut input)?.0 } else { 0 };
+
+		Ok(Self { marker: sp_std::marker::PhantomData, input, length, read: 0 })
+	}
+}
+
+impl<T: codec::Decode> sp_std::iter::Iterator for ScaleContainerStreamIter<T> {
+	type Item = T;
+
+	fn next(&mut self) -> Option<T> {
+		if self.read >= self.length {
+			return None
+		}
+
+		match codec::Decode::decode(&mut self.input) {
+			Ok(r) => {
+				self.read += 1;
+				Some(r)
+			},
+			Err(e) => {
+				log::error!(
+					target: "runtime::storage",
+					"Corrupted state at `{:?}`: failed to decode element {} (out of {} in total): {:?}",
+					self.input.key,
+					self.read,
+					self.length,
+					e,
+				);
+
+				self.read = self.length;
+				None
+			},
+		}
+	}
+
+	fn size_hint(&self) -> (usize, Option<usize>) {
+		let left = (self.length - self.read) as usize;
+
+		(left, Some(left))
+	}
+}
+
+/// The size of the internal buffer used by [`StorageInput`].
+///
+/// This internal buffer is used to speed up implementation as reading from the
+/// state for every access is too slow.
+const STORAGE_INPUT_BUFFER_CAPACITY: usize = 2 * 1024;
+
+/// Implementation of [`codec::Input`] using [`sp_io::storage::read`].
+///
+/// Keeps an internal buffer with a size of [`STORAGE_INPUT_BUFFER_CAPACITY`]. All read accesses
+/// are tried to be served by this buffer. If the buffer doesn't hold enough bytes to fullfill the
+/// current read access, the buffer is re-filled from the state. A read request that is bigger than
+/// the internal buffer is directly forwarded to the state to reduce the number of reads from the
+/// state.
+struct StorageInput {
+	key: Vec<u8>,
+	offset: u32,
+	total_length: u32,
+	exists: bool,
+	buffer: Vec<u8>,
+	buffer_pos: usize,
+}
+
+impl StorageInput {
+	/// Create a new instance of the input.
+	///
+	/// - `key`: The storage key of the storage item that this input will read.
+	fn new(key: Vec<u8>) -> Self {
+		let mut buffer = sp_std::vec![0; STORAGE_INPUT_BUFFER_CAPACITY];
+		unsafe {
+			buffer.set_len(buffer.capacity());
+		}
+
+		let (total_length, exists) =
+			if let Some(total_length) = sp_io::storage::read(&key, &mut buffer, 0) {
+				(total_length, true)
+			} else {
+				(0, false)
+			};
+
+		if (total_length as usize) < buffer.len() {
+			unsafe {
+				buffer.set_len(total_length as usize);
+			}
+		}
+
+		Self { total_length, offset: buffer.len() as u32, key, exists, buffer, buffer_pos: 0 }
+	}
+
+	/// Fill the internal buffer from the state.
+	fn fill_buffer(&mut self) -> Result<(), codec::Error> {
+		self.buffer.copy_within(self.buffer_pos.., 0);
+		let present_bytes = self.buffer.len() - self.buffer_pos;
+		self.buffer_pos = 0;
+
+		unsafe {
+			self.buffer.set_len(self.buffer.capacity());
+		}
+
+		if let Some(length_minus_offset) =
+			sp_io::storage::read(&self.key, &mut self.buffer[present_bytes..], self.offset)
+		{
+			let bytes_read =
+				sp_std::cmp::min(length_minus_offset as usize, self.buffer.len() - present_bytes);
+			let buffer_len = present_bytes + bytes_read;
+			unsafe {
+				self.buffer.set_len(buffer_len);
+			}
+
+			self.ensure_total_length_did_not_change(length_minus_offset)?;
+
+			self.offset += bytes_read as u32;
+
+			Ok(())
+		} else {
+			// The value was deleted, let's ensure we don't read anymore.
+			self.stop_reading();
+
+			Err("Value doesn't exist in the state?".into())
+		}
+	}
+
+	/// Returns if the value to read exists in the state.
+	fn exists(&self) -> bool {
+		self.exists
+	}
+
+	/// Reads directly into the given slice `into`.
+	///
+	/// Should be used when `into.len() > self.buffer.capacity()` to reduce the number of reads from
+	/// the state.
+	#[inline(never)]
+	fn read_big_item(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
+		let num_cached = self.buffer.len() - self.buffer_pos;
+
+		let (out_already_read, mut out_remaining) = into.split_at_mut(num_cached);
+		out_already_read.copy_from_slice(&self.buffer[self.buffer_pos..]);
+
+		self.buffer_pos = 0;
+		unsafe {
+			self.buffer.set_len(0);
+		}
+
+		if let Some(length_minus_offset) =
+			sp_io::storage::read(&self.key, &mut out_remaining, self.offset)
+		{
+			if (length_minus_offset as usize) < out_remaining.len() {
+				return Err("Not enough data to fill the buffer".into())
+			}
+
+			self.ensure_total_length_did_not_change(length_minus_offset)?;
+
+			self.offset += out_remaining.len() as u32;
+
+			Ok(())
+		} else {
+			// The value was deleted, let's ensure we don't read anymore.
+			self.stop_reading();
+
+			Err("Value doesn't exist in the state?".into())
+		}
+	}
+
+	/// Ensures that the expected total length of the value did not change.
+	///
+	/// On error ensures that further reading is prohibited.
+	fn ensure_total_length_did_not_change(
+		&mut self,
+		length_minus_offset: u32,
+	) -> Result<(), codec::Error> {
+		if self.total_length == self.offset + length_minus_offset {
+			Ok(())
+		} else {
+			// The value total length changed, let's ensure we don't read anymore.
+			self.stop_reading();
+
+			Err("Storage value changed while it is being read!".into())
+		}
+	}
+
+	/// Ensure that we are stop reading from this value in the state.
+	///
+	/// Should be used when there happened an unrecoverable error while reading.
+	fn stop_reading(&mut self) {
+		self.offset = self.total_length;
+
+		self.buffer_pos = 0;
+		unsafe {
+			self.buffer.set_len(0);
+		}
+	}
+}
+
+impl codec::Input for StorageInput {
+	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
+		Ok(Some(self.total_length.saturating_sub(
+			self.offset.saturating_sub((self.buffer.len() - self.buffer_pos) as u32),
+		) as usize))
+	}
+
+	fn read(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
+		// If there is still data left to be read from the state.
+		if self.offset < self.total_length {
+			if into.len() > self.buffer.capacity() {
+				return self.read_big_item(into)
+			} else if self.buffer_pos + into.len() > self.buffer.len() {
+				self.fill_buffer()?;
+			}
+		}
+
+		// Guard against `fill_buffer` not reading enough data or just not having enough data
+		// anymore.
+		if into.len() + self.buffer_pos > self.buffer.len() {
+			return Err("Not enough data to fill the buffer".into())
+		}
+
+		let end = self.buffer_pos + into.len();
+		into.copy_from_slice(&self.buffer[self.buffer_pos..end]);
+		self.buffer_pos = end;
+
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::{Compact, CompactLen, Encode, Input};
+
+	#[crate::storage_alias]
+	pub type TestVecU32 = StorageValue<Test, Vec<u32>>;
+
+	#[crate::storage_alias]
+	pub type TestVecVecU8 = StorageValue<Test, Vec<Vec<u8>>>;
+
+	#[test]
+	fn remaining_len_works() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			let data: Vec<u32> = vec![1, 2, 3, 4, 5];
+			TestVecU32::put(&data);
+
+			let mut input = StorageInput::new(TestVecU32::hashed_key().into());
+			assert_eq!(
+				5 * std::mem::size_of::<u32>() + Compact::<u32>::compact_len(&5) as usize,
+				input.remaining_len().ok().flatten().unwrap()
+			);
+
+			assert_eq!(5, Compact::<u32>::decode(&mut input).unwrap().0);
+			assert_eq!(
+				5 * std::mem::size_of::<u32>(),
+				input.remaining_len().ok().flatten().unwrap()
+			);
+
+			for i in &data {
+				assert_eq!(*i, u32::decode(&mut input).unwrap());
+				assert_eq!(
+					(5 - *i as usize) * std::mem::size_of::<u32>(),
+					input.remaining_len().ok().flatten().unwrap()
+				);
+			}
+
+			let data: Vec<Vec<u8>> = vec![
+				vec![0; 20],
+				vec![1; STORAGE_INPUT_BUFFER_CAPACITY * 2],
+				vec![2; STORAGE_INPUT_BUFFER_CAPACITY * 2],
+				vec![3; 30],
+				vec![4; 30],
+				vec![5; STORAGE_INPUT_BUFFER_CAPACITY * 2],
+				vec![6; 30],
+			];
+			TestVecVecU8::put(&data);
+
+			let mut input = StorageInput::new(TestVecVecU8::hashed_key().into());
+			let total_data_len = data
+				.iter()
+				.map(|v| v.len() + Compact::<u32>::compact_len(&(v.len() as u32)) as usize)
+				.sum::<usize>();
+			assert_eq!(
+				total_data_len + Compact::<u32>::compact_len(&(data.len() as u32)) as usize,
+				input.remaining_len().ok().flatten().unwrap()
+			);
+
+			assert_eq!(data.len(), Compact::<u32>::decode(&mut input).unwrap().0 as usize);
+			assert_eq!(total_data_len, input.remaining_len().ok().flatten().unwrap());
+
+			let mut remaining_len = total_data_len;
+			for i in data {
+				assert_eq!(i, Vec::<u8>::decode(&mut input).unwrap());
+
+				remaining_len -= i.len() + Compact::<u32>::compact_len(&(i.len() as u32)) as usize;
+
+				assert_eq!(remaining_len, input.remaining_len().ok().flatten().unwrap());
+			}
+		})
+	}
+
+	#[test]
+	fn detects_value_total_length_change() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			let test_data: Vec<Vec<Vec<u8>>> = vec![
+				vec![vec![0; 20], vec![1; STORAGE_INPUT_BUFFER_CAPACITY * 2]],
+				vec![
+					vec![0; STORAGE_INPUT_BUFFER_CAPACITY - 1],
+					vec![1; STORAGE_INPUT_BUFFER_CAPACITY - 1],
+				],
+			];
+
+			for data in test_data {
+				TestVecVecU8::put(&data);
+
+				let mut input = StorageInput::new(TestVecVecU8::hashed_key().into());
+
+				Compact::<u32>::decode(&mut input).unwrap();
+				Vec::<u8>::decode(&mut input).unwrap();
+
+				TestVecVecU8::append(vec![1, 2, 3]);
+
+				assert!(Vec::<u8>::decode(&mut input)
+					.unwrap_err()
+					.to_string()
+					.contains("Storage value changed while it is being read"));
+
+				// Reading a second time should now prevent reading at all.
+				assert!(Vec::<u8>::decode(&mut input)
+					.unwrap_err()
+					.to_string()
+					.contains("Not enough data to fill the buffer"));
+			}
+		})
+	}
+
+	#[test]
+	fn stream_read_test() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			let data: Vec<u32> = vec![1, 2, 3, 4, 5];
+			TestVecU32::put(&data);
+
+			assert_eq!(data, TestVecU32::stream_iter().collect::<Vec<_>>());
+
+			let data: Vec<Vec<u8>> = vec![vec![0; 3000], vec![1; 2500]];
+			TestVecVecU8::put(&data);
+
+			assert_eq!(data, TestVecVecU8::stream_iter().collect::<Vec<_>>());
+		})
+	}
+
+	#[test]
+	fn reading_big_intermediate_value() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			let data: Vec<Vec<u8>> =
+				vec![vec![0; 20], vec![1; STORAGE_INPUT_BUFFER_CAPACITY * 2], vec![2; 30]];
+			TestVecVecU8::put(&data);
+
+			assert_eq!(data, TestVecVecU8::stream_iter().collect::<Vec<_>>());
+
+			let data: Vec<Vec<u8>> = vec![
+				vec![0; 20],
+				vec![1; STORAGE_INPUT_BUFFER_CAPACITY * 2],
+				vec![2; STORAGE_INPUT_BUFFER_CAPACITY * 2],
+				vec![3; 30],
+				vec![4; 30],
+				vec![5; STORAGE_INPUT_BUFFER_CAPACITY * 2],
+				vec![6; 30],
+			];
+			TestVecVecU8::put(&data);
+
+			assert_eq!(data, TestVecVecU8::stream_iter().collect::<Vec<_>>());
+		})
+	}
+
+	#[test]
+	fn reading_more_data_as_in_the_state_is_detected() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			let data: Vec<Vec<u8>> = vec![vec![0; 20], vec![1; STORAGE_INPUT_BUFFER_CAPACITY * 2]];
+			TestVecVecU8::put(&data);
+
+			let mut input = StorageInput::new(TestVecVecU8::hashed_key().into());
+
+			Compact::<u32>::decode(&mut input).unwrap();
+
+			Vec::<u8>::decode(&mut input).unwrap();
+
+			let mut buffer = vec![0; STORAGE_INPUT_BUFFER_CAPACITY * 4];
+			assert!(input
+				.read(&mut buffer)
+				.unwrap_err()
+				.to_string()
+				.contains("Not enough data to fill the buffer"));
+		})
+	}
+
+	#[test]
+	fn reading_invalid_data_from_state() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			let data: Vec<u32> = vec![1, 2, 3, 4, 5];
+
+			let mut data_encoded = data.encode();
+			data_encoded.truncate(data_encoded.len() - 2);
+			sp_io::storage::set(&TestVecU32::hashed_key(), &data_encoded);
+			assert_eq!(
+				data.iter().copied().take(data.len() - 1).collect::<Vec<_>>(),
+				TestVecU32::stream_iter().collect::<Vec<_>>()
+			);
+
+			let data_encoded = data.encode()[2..].to_vec();
+			sp_io::storage::set(&TestVecU32::hashed_key(), &data_encoded);
+			assert!(TestVecU32::stream_iter().collect::<Vec<_>>().is_empty());
+
+			let data: Vec<Vec<u8>> = vec![vec![0; 20], vec![1; STORAGE_INPUT_BUFFER_CAPACITY * 2]];
+			let mut data_encoded = data.encode();
+			data_encoded.truncate(data_encoded.len() - 100);
+			sp_io::storage::set(&TestVecVecU8::hashed_key(), &data_encoded);
+
+			assert_eq!(
+				data.iter().cloned().take(1).collect::<Vec<_>>(),
+				TestVecVecU8::stream_iter().collect::<Vec<_>>()
+			);
+		})
+	}
+
+	#[test]
+	fn reading_with_fill_buffer() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			const BUFFER_SIZE: usize = 300;
+			// Ensure that the capacity isn't dividable by `300`.
+			assert!(STORAGE_INPUT_BUFFER_CAPACITY % BUFFER_SIZE != 0, "Please update buffer size");
+			// Create some items where the last item is partially in the inner buffer so that
+			// we need to fill the buffer to read the entire item.
+			let data: Vec<Vec<u8>> = (0..=(STORAGE_INPUT_BUFFER_CAPACITY / BUFFER_SIZE))
+				.into_iter()
+				.map(|i| vec![i as u8; BUFFER_SIZE])
+				.collect::<Vec<Vec<u8>>>();
+			TestVecVecU8::put(&data);
+
+			assert_eq!(data, TestVecVecU8::stream_iter().collect::<Vec<_>>());
+
+			let mut input = StorageInput::new(TestVecVecU8::hashed_key().into());
+
+			Compact::<u32>::decode(&mut input).unwrap();
+
+			(0..data.len() - 1).into_iter().for_each(|_| {
+				Vec::<u8>::decode(&mut input).unwrap();
+			});
+
+			// Try reading a more data than there should be left.
+			let mut result_buffer = vec![0; BUFFER_SIZE * 2];
+			assert!(input
+				.read(&mut result_buffer)
+				.unwrap_err()
+				.to_string()
+				.contains("Not enough data to fill the buffer"));
+		})
+	}
+
+	#[test]
+	fn detect_value_deleted_in_state() {
+		sp_io::TestExternalities::default().execute_with(|| {
+			let data: Vec<Vec<u8>> = vec![vec![0; 20], vec![1; STORAGE_INPUT_BUFFER_CAPACITY * 2]];
+			TestVecVecU8::put(&data);
+
+			let mut input = StorageInput::new(TestVecVecU8::hashed_key().into());
+			TestVecVecU8::kill();
+
+			Compact::<u32>::decode(&mut input).unwrap();
+			Vec::<u8>::decode(&mut input).unwrap();
+
+			assert!(Vec::<u8>::decode(&mut input)
+				.unwrap_err()
+				.to_string()
+				.contains("Value doesn't exist in the state?"));
+
+			const BUFFER_SIZE: usize = 300;
+			// Ensure that the capacity isn't dividable by `300`.
+			assert!(STORAGE_INPUT_BUFFER_CAPACITY % BUFFER_SIZE != 0, "Please update buffer size");
+			// Create some items where the last item is partially in the inner buffer so that
+			// we need to fill the buffer to read the entire item.
+			let data: Vec<Vec<u8>> = (0..=(STORAGE_INPUT_BUFFER_CAPACITY / BUFFER_SIZE))
+				.into_iter()
+				.map(|i| vec![i as u8; BUFFER_SIZE])
+				.collect::<Vec<Vec<u8>>>();
+			TestVecVecU8::put(&data);
+
+			let mut input = StorageInput::new(TestVecVecU8::hashed_key().into());
+			TestVecVecU8::kill();
+
+			Compact::<u32>::decode(&mut input).unwrap();
+			(0..data.len() - 1).into_iter().for_each(|_| {
+				Vec::<u8>::decode(&mut input).unwrap();
+			});
+
+			assert!(Vec::<u8>::decode(&mut input)
+				.unwrap_err()
+				.to_string()
+				.contains("Value doesn't exist in the state?"));
+		})
+	}
+}
diff --git a/substrate/frame/support/src/storage/transactional.rs b/substrate/frame/support/src/storage/transactional.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d42e1809e91292a8e0ad367af4e203b8b1b17f87
--- /dev/null
+++ b/substrate/frame/support/src/storage/transactional.rs
@@ -0,0 +1,303 @@
+// 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.
+
+//! Provides functionality around the transaction storage.
+//!
+//! Transactional storage provides functionality to run an entire code block
+//! in a storage transaction. This means that either the entire changes to the
+//! storage are committed or everything is thrown away. This simplifies the
+//! writing of functionality that may bail at any point of operation. Otherwise
+//! you would need to first verify all storage accesses and then do the storage
+//! modifications.
+//!
+//! [`with_transaction`] provides a way to run a given closure in a transactional context.
+
+use sp_io::storage::{commit_transaction, rollback_transaction, start_transaction};
+use sp_runtime::{DispatchError, TransactionOutcome, TransactionalError};
+
+/// The type that is being used to store the current number of active layers.
+pub type Layer = u32;
+/// The key that is holds the current number of active layers.
+///
+/// Encodes to `0x3a7472616e73616374696f6e5f6c6576656c3a`.
+pub const TRANSACTION_LEVEL_KEY: &[u8] = b":transaction_level:";
+/// The maximum number of nested layers.
+pub const TRANSACTIONAL_LIMIT: Layer = 255;
+
+/// Returns the current number of nested transactional layers.
+fn get_transaction_level() -> Layer {
+	crate::storage::unhashed::get_or_default::<Layer>(TRANSACTION_LEVEL_KEY)
+}
+
+/// Set the current number of nested transactional layers.
+fn set_transaction_level(level: Layer) {
+	crate::storage::unhashed::put::<Layer>(TRANSACTION_LEVEL_KEY, &level);
+}
+
+/// Kill the transactional layers storage.
+fn kill_transaction_level() {
+	crate::storage::unhashed::kill(TRANSACTION_LEVEL_KEY);
+}
+
+/// Increments the transaction level. Returns an error if levels go past the limit.
+///
+/// Returns a guard that when dropped decrements the transaction level automatically.
+fn inc_transaction_level() -> Result<StorageLayerGuard, ()> {
+	let existing_levels = get_transaction_level();
+	if existing_levels >= TRANSACTIONAL_LIMIT {
+		return Err(())
+	}
+	// Cannot overflow because of check above.
+	set_transaction_level(existing_levels + 1);
+	Ok(StorageLayerGuard)
+}
+
+fn dec_transaction_level() {
+	let existing_levels = get_transaction_level();
+	if existing_levels == 0 {
+		log::warn!(
+				"We are underflowing with calculating transactional levels. Not great, but let's not panic...",
+			);
+	} else if existing_levels == 1 {
+		// Don't leave any trace of this storage item.
+		kill_transaction_level();
+	} else {
+		// Cannot underflow because of checks above.
+		set_transaction_level(existing_levels - 1);
+	}
+}
+
+struct StorageLayerGuard;
+
+impl Drop for StorageLayerGuard {
+	fn drop(&mut self) {
+		dec_transaction_level()
+	}
+}
+
+/// Check if the current call is within a transactional layer.
+pub fn is_transactional() -> bool {
+	get_transaction_level() > 0
+}
+
+/// Execute the supplied function in a new storage transaction.
+///
+/// All changes to storage performed by the supplied function are discarded if the returned
+/// outcome is `TransactionOutcome::Rollback`.
+///
+/// Transactions can be nested up to `TRANSACTIONAL_LIMIT` times; more than that will result in an
+/// error.
+///
+/// Commits happen to the parent transaction.
+pub fn with_transaction<T, E, F>(f: F) -> Result<T, E>
+where
+	E: From<DispatchError>,
+	F: FnOnce() -> TransactionOutcome<Result<T, E>>,
+{
+	// This needs to happen before `start_transaction` below.
+	// Otherwise we may rollback the increase, then decrease as the guard goes out of scope
+	// and then end in some bad state.
+	let _guard = inc_transaction_level().map_err(|()| TransactionalError::LimitReached.into())?;
+
+	start_transaction();
+
+	match f() {
+		TransactionOutcome::Commit(res) => {
+			commit_transaction();
+			res
+		},
+		TransactionOutcome::Rollback(res) => {
+			rollback_transaction();
+			res
+		},
+	}
+}
+
+/// Same as [`with_transaction`] but without a limit check on nested transactional layers.
+///
+/// This is mostly for backwards compatibility before there was a transactional layer limit.
+/// It is recommended to only use [`with_transaction`] to avoid users from generating too many
+/// transactional layers.
+pub fn with_transaction_unchecked<R, F>(f: F) -> R
+where
+	F: FnOnce() -> TransactionOutcome<R>,
+{
+	// This needs to happen before `start_transaction` below.
+	// Otherwise we may rollback the increase, then decrease as the guard goes out of scope
+	// and then end in some bad state.
+	let maybe_guard = inc_transaction_level();
+
+	if maybe_guard.is_err() {
+		log::warn!(
+			"The transactional layer limit has been reached, and new transactional layers are being
+			spawned with `with_transaction_unchecked`. This could be caused by someone trying to
+			attack your chain, and you should investigate usage of `with_transaction_unchecked` and
+			potentially migrate to `with_transaction`, which enforces a transactional limit.",
+		);
+	}
+
+	start_transaction();
+
+	match f() {
+		TransactionOutcome::Commit(res) => {
+			commit_transaction();
+			res
+		},
+		TransactionOutcome::Rollback(res) => {
+			rollback_transaction();
+			res
+		},
+	}
+}
+
+/// Execute the supplied function, adding a new storage layer.
+///
+/// This is the same as `with_transaction`, but assuming that any function returning an `Err` should
+/// rollback, and any function returning `Ok` should commit. This provides a cleaner API to the
+/// developer who wants this behavior.
+pub fn with_storage_layer<T, E, F>(f: F) -> Result<T, E>
+where
+	E: From<DispatchError>,
+	F: FnOnce() -> Result<T, E>,
+{
+	with_transaction(|| {
+		let r = f();
+		if r.is_ok() {
+			TransactionOutcome::Commit(r)
+		} else {
+			TransactionOutcome::Rollback(r)
+		}
+	})
+}
+
+/// Execute the supplied function, ensuring we are at least in one storage layer.
+///
+/// If we are already in a storage layer, we just execute the provided closure.
+/// If we are not, we execute the closure within a [`with_storage_layer`].
+pub fn in_storage_layer<T, E, F>(f: F) -> Result<T, E>
+where
+	E: From<DispatchError>,
+	F: FnOnce() -> Result<T, E>,
+{
+	if is_transactional() {
+		f()
+	} else {
+		with_storage_layer(f)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{assert_noop, assert_ok};
+	use sp_io::TestExternalities;
+	use sp_runtime::DispatchResult;
+
+	#[test]
+	fn is_transactional_should_return_false() {
+		TestExternalities::default().execute_with(|| {
+			assert!(!is_transactional());
+		});
+	}
+
+	#[test]
+	fn is_transactional_should_not_error_in_with_transaction() {
+		TestExternalities::default().execute_with(|| {
+			assert_ok!(with_transaction(|| -> TransactionOutcome<DispatchResult> {
+				assert!(is_transactional());
+				TransactionOutcome::Commit(Ok(()))
+			}));
+
+			assert_noop!(
+				with_transaction(|| -> TransactionOutcome<DispatchResult> {
+					assert!(is_transactional());
+					TransactionOutcome::Rollback(Err("revert".into()))
+				}),
+				"revert"
+			);
+		});
+	}
+
+	fn recursive_transactional(num: u32) -> DispatchResult {
+		if num == 0 {
+			return Ok(())
+		}
+
+		with_transaction(|| -> TransactionOutcome<DispatchResult> {
+			let res = recursive_transactional(num - 1);
+			TransactionOutcome::Commit(res)
+		})
+	}
+
+	#[test]
+	fn transaction_limit_should_work() {
+		TestExternalities::default().execute_with(|| {
+			assert_eq!(get_transaction_level(), 0);
+
+			assert_ok!(with_transaction(|| -> TransactionOutcome<DispatchResult> {
+				assert_eq!(get_transaction_level(), 1);
+				TransactionOutcome::Commit(Ok(()))
+			}));
+
+			assert_ok!(with_transaction(|| -> TransactionOutcome<DispatchResult> {
+				assert_eq!(get_transaction_level(), 1);
+				let res = with_transaction(|| -> TransactionOutcome<DispatchResult> {
+					assert_eq!(get_transaction_level(), 2);
+					TransactionOutcome::Commit(Ok(()))
+				});
+				TransactionOutcome::Commit(res)
+			}));
+
+			assert_ok!(recursive_transactional(255));
+			assert_noop!(
+				recursive_transactional(256),
+				sp_runtime::TransactionalError::LimitReached
+			);
+
+			assert_eq!(get_transaction_level(), 0);
+		});
+	}
+
+	#[test]
+	fn in_storage_layer_works() {
+		TestExternalities::default().execute_with(|| {
+			assert_eq!(get_transaction_level(), 0);
+
+			let res = in_storage_layer(|| -> DispatchResult {
+				assert_eq!(get_transaction_level(), 1);
+				in_storage_layer(|| -> DispatchResult {
+					// We are still in the same layer :)
+					assert_eq!(get_transaction_level(), 1);
+					Ok(())
+				})
+			});
+
+			assert_ok!(res);
+
+			let res = in_storage_layer(|| -> DispatchResult {
+				assert_eq!(get_transaction_level(), 1);
+				in_storage_layer(|| -> DispatchResult {
+					// We are still in the same layer :)
+					assert_eq!(get_transaction_level(), 1);
+					Err("epic fail".into())
+				})
+			});
+
+			assert_noop!(res, "epic fail");
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/types/counted_map.rs b/substrate/frame/support/src/storage/types/counted_map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5b750a74098b8395a4234a7db562b52e254a8f63
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/counted_map.rs
@@ -0,0 +1,1176 @@
+// 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.
+
+//! Storage counted map type.
+
+use crate::{
+	storage::{
+		generator::StorageMap as _,
+		types::{
+			OptionQuery, QueryKindTrait, StorageEntryMetadataBuilder, StorageMap, StorageValue,
+			ValueQuery,
+		},
+		StorageAppend, StorageDecodeLength, StorageTryAppend,
+	},
+	traits::{Get, GetDefault, StorageInfo, StorageInfoTrait, StorageInstance},
+	Never,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen, Ref};
+use sp_io::MultiRemovalResults;
+use sp_metadata_ir::StorageEntryMetadataIR;
+use sp_runtime::traits::Saturating;
+use sp_std::prelude::*;
+
+/// A wrapper around a `StorageMap` and a `StorageValue<Value=u32>` to keep track of how many items
+/// are in a map, without needing to iterate all the values.
+///
+/// This storage item has additional storage read and write overhead when manipulating values
+/// compared to a regular storage map.
+///
+/// For functions where we only add or remove a value, a single storage read is needed to check if
+/// that value already exists. For mutate functions, two storage reads are used to check if the
+/// value existed before and after the mutation.
+///
+/// Whenever the counter needs to be updated, an additional read and write occurs to update that
+/// counter.
+pub struct CountedStorageMap<
+	Prefix,
+	Hasher,
+	Key,
+	Value,
+	QueryKind = OptionQuery,
+	OnEmpty = GetDefault,
+	MaxValues = GetDefault,
+>(core::marker::PhantomData<(Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues)>);
+
+/// The requirement for an instance of [`CountedStorageMap`].
+pub trait CountedStorageMapInstance: StorageInstance {
+	/// The prefix to use for the counter storage value.
+	type CounterPrefix: StorageInstance;
+}
+
+// Private helper trait to access map from counted storage map.
+trait MapWrapper {
+	type Map;
+}
+
+impl<P: CountedStorageMapInstance, H, K, V, Q, O, M> MapWrapper
+	for CountedStorageMap<P, H, K, V, Q, O, M>
+{
+	type Map = StorageMap<P, H, K, V, Q, O, M>;
+}
+
+type CounterFor<P> = StorageValue<<P as CountedStorageMapInstance>::CounterPrefix, u32, ValueQuery>;
+
+/// On removal logic for updating counter while draining upon some prefix with
+/// [`crate::storage::PrefixIterator`].
+pub struct OnRemovalCounterUpdate<Prefix>(core::marker::PhantomData<Prefix>);
+
+impl<Prefix: CountedStorageMapInstance> crate::storage::PrefixIteratorOnRemoval
+	for OnRemovalCounterUpdate<Prefix>
+{
+	fn on_removal(_key: &[u8], _value: &[u8]) {
+		CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+	CountedStorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageMapInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// The key used to store the counter of the map.
+	pub fn counter_storage_final_key() -> [u8; 32] {
+		CounterFor::<Prefix>::hashed_key()
+	}
+
+	/// The prefix used to generate the key of the map.
+	pub fn map_storage_final_prefix() -> Vec<u8> {
+		use crate::storage::generator::StorageMap;
+		<Self as MapWrapper>::Map::prefix_hash()
+	}
+
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	pub fn hashed_key_for<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Vec<u8> {
+		<Self as MapWrapper>::Map::hashed_key_for(key)
+	}
+
+	/// Does the value (explicitly) exist in storage?
+	pub fn contains_key<KeyArg: EncodeLike<Key>>(key: KeyArg) -> bool {
+		<Self as MapWrapper>::Map::contains_key(key)
+	}
+
+	/// Load the value associated with the given key from the map.
+	pub fn get<KeyArg: EncodeLike<Key>>(key: KeyArg) -> QueryKind::Query {
+		<Self as MapWrapper>::Map::get(key)
+	}
+
+	/// Try to get the value for the given key from the map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	pub fn try_get<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Result<Value, ()> {
+		<Self as MapWrapper>::Map::try_get(key)
+	}
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	pub fn set<KeyArg: EncodeLike<Key>>(key: KeyArg, q: QueryKind::Query) {
+		match QueryKind::from_query_to_optional_value(q) {
+			Some(v) => Self::insert(key, v),
+			None => Self::remove(key),
+		}
+	}
+
+	/// Swap the values of two keys.
+	pub fn swap<KeyArg1: EncodeLike<Key>, KeyArg2: EncodeLike<Key>>(key1: KeyArg1, key2: KeyArg2) {
+		<Self as MapWrapper>::Map::swap(key1, key2)
+	}
+
+	/// Store a value to be associated with the given key from the map.
+	pub fn insert<KeyArg: EncodeLike<Key>, ValArg: EncodeLike<Value>>(key: KeyArg, val: ValArg) {
+		if !<Self as MapWrapper>::Map::contains_key(Ref::from(&key)) {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_inc());
+		}
+		<Self as MapWrapper>::Map::insert(key, val)
+	}
+
+	/// Remove the value under a key.
+	pub fn remove<KeyArg: EncodeLike<Key>>(key: KeyArg) {
+		if <Self as MapWrapper>::Map::contains_key(Ref::from(&key)) {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+		}
+		<Self as MapWrapper>::Map::remove(key)
+	}
+
+	/// Mutate the value under a key.
+	pub fn mutate<KeyArg: EncodeLike<Key>, R, F: FnOnce(&mut QueryKind::Query) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		Self::try_mutate(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	/// Mutate the item, only if an `Ok` value is returned.
+	pub fn try_mutate<KeyArg, R, E, F>(key: KeyArg, f: F) -> Result<R, E>
+	where
+		KeyArg: EncodeLike<Key>,
+		F: FnOnce(&mut QueryKind::Query) -> Result<R, E>,
+	{
+		Self::try_mutate_exists(key, |option_value_ref| {
+			let option_value = core::mem::replace(option_value_ref, None);
+			let mut query = <Self as MapWrapper>::Map::from_optional_value_to_query(option_value);
+			let res = f(&mut query);
+			let option_value = <Self as MapWrapper>::Map::from_query_to_optional_value(query);
+			let _ = core::mem::replace(option_value_ref, option_value);
+			res
+		})
+	}
+
+	/// Mutate the value under a key. Deletes the item if mutated to a `None`.
+	pub fn mutate_exists<KeyArg: EncodeLike<Key>, R, F: FnOnce(&mut Option<Value>) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		Self::try_mutate_exists(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	pub fn try_mutate_exists<KeyArg, R, E, F>(key: KeyArg, f: F) -> Result<R, E>
+	where
+		KeyArg: EncodeLike<Key>,
+		F: FnOnce(&mut Option<Value>) -> Result<R, E>,
+	{
+		<Self as MapWrapper>::Map::try_mutate_exists(key, |option_value| {
+			let existed = option_value.is_some();
+			let res = f(option_value);
+			let exist = option_value.is_some();
+
+			if res.is_ok() {
+				if existed && !exist {
+					// Value was deleted
+					CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+				} else if !existed && exist {
+					// Value was added
+					CounterFor::<Prefix>::mutate(|value| value.saturating_inc());
+				}
+			}
+			res
+		})
+	}
+
+	/// Take the value under a key.
+	pub fn take<KeyArg: EncodeLike<Key>>(key: KeyArg) -> QueryKind::Query {
+		let removed_value = <Self as MapWrapper>::Map::mutate_exists(key, |value| value.take());
+		if removed_value.is_some() {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+		}
+		<Self as MapWrapper>::Map::from_optional_value_to_query(removed_value)
+	}
+
+	/// Append the given items to the value in the storage.
+	///
+	/// `Value` is required to implement `codec::EncodeAppend`.
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten and set to
+	/// `[item]`. Any default value set for the storage item will be ignored on overwrite.
+	pub fn append<Item, EncodeLikeItem, EncodeLikeKey>(key: EncodeLikeKey, item: EncodeLikeItem)
+	where
+		EncodeLikeKey: EncodeLike<Key>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageAppend<Item>,
+	{
+		if !<Self as MapWrapper>::Map::contains_key(Ref::from(&key)) {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_inc());
+		}
+		<Self as MapWrapper>::Map::append(key, item)
+	}
+
+	/// Read the length of the storage value without decoding the entire value under the given
+	/// `key`.
+	///
+	/// `Value` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned. Otherwise
+	/// `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	pub fn decode_len<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Option<usize>
+	where
+		Value: StorageDecodeLength,
+	{
+		<Self as MapWrapper>::Map::decode_len(key)
+	}
+
+	/// Migrate an item with the given `key` from a defunct `OldHasher` to the current hasher.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	pub fn migrate_key<OldHasher: crate::hash::StorageHasher, KeyArg: EncodeLike<Key>>(
+		key: KeyArg,
+	) -> Option<Value> {
+		<Self as MapWrapper>::Map::migrate_key::<OldHasher, _>(key)
+	}
+
+	/// Remove all values in the map.
+	#[deprecated = "Use `clear` instead"]
+	pub fn remove_all() {
+		#[allow(deprecated)]
+		<Self as MapWrapper>::Map::remove_all(None);
+		CounterFor::<Prefix>::kill();
+	}
+
+	/// Attempt to remove all items from the map.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map. If so, then the map may not be empty when the resultant
+	/// `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must always be provided through in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map. Subsequent calls
+	/// operating on the same map should always pass `Some`, and this should be equal to the
+	/// previous call result's `maybe_cursor` field.
+	pub fn clear(limit: u32, maybe_cursor: Option<&[u8]>) -> MultiRemovalResults {
+		let result = <Self as MapWrapper>::Map::clear(limit, maybe_cursor);
+		match result.maybe_cursor {
+			None => CounterFor::<Prefix>::kill(),
+			Some(_) => CounterFor::<Prefix>::mutate(|x| x.saturating_reduce(result.unique)),
+		}
+		result
+	}
+
+	/// Iter over all value of the storage.
+	///
+	/// NOTE: If a value failed to decode because storage is corrupted then it is skipped.
+	pub fn iter_values() -> crate::storage::PrefixIterator<Value, OnRemovalCounterUpdate<Prefix>> {
+		<Self as MapWrapper>::Map::iter_values().convert_on_removal()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	///
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade.
+	pub fn translate_values<OldValue: Decode, F: FnMut(OldValue) -> Option<Value>>(mut f: F) {
+		<Self as MapWrapper>::Map::translate_values(|old_value| {
+			let res = f(old_value);
+			if res.is_none() {
+				CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+			}
+			res
+		})
+	}
+
+	/// Try and append the given item to the value in the storage.
+	///
+	/// Is only available if `Value` of the storage implements [`StorageTryAppend`].
+	pub fn try_append<KArg, Item, EncodeLikeItem>(key: KArg, item: EncodeLikeItem) -> Result<(), ()>
+	where
+		KArg: EncodeLike<Key>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageTryAppend<Item>,
+	{
+		let bound = Value::bound();
+		let current = <Self as MapWrapper>::Map::decode_len(Ref::from(&key)).unwrap_or_default();
+		if current < bound {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_inc());
+			let key = <Self as MapWrapper>::Map::hashed_key_for(key);
+			sp_io::storage::append(&key, item.encode());
+			Ok(())
+		} else {
+			Err(())
+		}
+	}
+
+	/// Initialize the counter with the actual number of items in the map.
+	///
+	/// This function iterates through all the items in the map and sets the counter. This operation
+	/// can be very heavy, so use with caution.
+	///
+	/// Returns the number of items in the map which is used to set the counter.
+	pub fn initialize_counter() -> u32 {
+		let count = Self::iter_values().count() as u32;
+		CounterFor::<Prefix>::set(count);
+		count
+	}
+
+	/// Return the count.
+	pub fn count() -> u32 {
+		CounterFor::<Prefix>::get()
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+	CountedStorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageMapInstance,
+	Hasher: crate::hash::StorageHasher + crate::ReversibleStorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Enumerate all elements in the map in no particular order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter() -> crate::storage::PrefixIterator<(Key, Value), OnRemovalCounterUpdate<Prefix>> {
+		<Self as MapWrapper>::Map::iter().convert_on_removal()
+	}
+
+	/// Remove all elements from the map and iterate through them in no particular order.
+	///
+	/// If you add elements to the map while doing this, you'll get undefined results.
+	pub fn drain() -> crate::storage::PrefixIterator<(Key, Value), OnRemovalCounterUpdate<Prefix>> {
+		<Self as MapWrapper>::Map::drain().convert_on_removal()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	///
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	pub fn translate<O: Decode, F: FnMut(Key, O) -> Option<Value>>(mut f: F) {
+		<Self as MapWrapper>::Map::translate(|key, old_value| {
+			let res = f(key, old_value);
+			if res.is_none() {
+				CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+			}
+			res
+		})
+	}
+
+	/// Enumerate all elements in the counted map after a specified `starting_raw_key` in no
+	/// particular order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_from(
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::PrefixIterator<(Key, Value), OnRemovalCounterUpdate<Prefix>> {
+		<Self as MapWrapper>::Map::iter_from(starting_raw_key).convert_on_removal()
+	}
+
+	/// Enumerate all keys in the counted map.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_keys() -> crate::storage::KeyPrefixIterator<Key> {
+		<Self as MapWrapper>::Map::iter_keys()
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues> StorageEntryMetadataBuilder
+	for CountedStorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageMapInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec + scale_info::StaticTypeInfo,
+	Value: FullCodec + scale_info::StaticTypeInfo,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn build_metadata(docs: Vec<&'static str>, entries: &mut Vec<StorageEntryMetadataIR>) {
+		<Self as MapWrapper>::Map::build_metadata(docs, entries);
+		CounterFor::<Prefix>::build_metadata(
+			if cfg!(feature = "no-metadata-docs") {
+				vec![]
+			} else {
+				vec!["Counter for the related counted storage map"]
+			},
+			entries,
+		);
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues> crate::traits::StorageInfoTrait
+	for CountedStorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageMapInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec + MaxEncodedLen,
+	Value: FullCodec + MaxEncodedLen,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn storage_info() -> Vec<StorageInfo> {
+		[<Self as MapWrapper>::Map::storage_info(), CounterFor::<Prefix>::storage_info()].concat()
+	}
+}
+
+/// It doesn't require to implement `MaxEncodedLen` and give no information for `max_size`.
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+	crate::traits::PartialStorageInfoTrait
+	for CountedStorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageMapInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn partial_storage_info() -> Vec<StorageInfo> {
+		[<Self as MapWrapper>::Map::partial_storage_info(), CounterFor::<Prefix>::storage_info()]
+			.concat()
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{
+		hash::*,
+		storage::{bounded_vec::BoundedVec, types::ValueQuery},
+		traits::ConstU32,
+	};
+	use sp_io::{hashing::twox_128, TestExternalities};
+	use sp_metadata_ir::{StorageEntryModifierIR, StorageEntryTypeIR, StorageHasherIR};
+
+	struct Prefix;
+	impl StorageInstance for Prefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "foo";
+	}
+
+	struct CounterPrefix;
+	impl StorageInstance for CounterPrefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "counter_for_foo";
+	}
+	impl CountedStorageMapInstance for Prefix {
+		type CounterPrefix = CounterPrefix;
+	}
+
+	struct ADefault;
+	impl crate::traits::Get<u32> for ADefault {
+		fn get() -> u32 {
+			97
+		}
+	}
+	#[crate::storage_alias]
+	type ExampleCountedMap = CountedStorageMap<Prefix, Twox64Concat, u16, u32>;
+
+	#[test]
+	fn storage_alias_works() {
+		TestExternalities::default().execute_with(|| {
+			assert_eq!(ExampleCountedMap::count(), 0);
+			ExampleCountedMap::insert(3, 10);
+		})
+	}
+
+	#[test]
+	fn test_value_query() {
+		type A = CountedStorageMap<Prefix, Twox64Concat, u16, u32, ValueQuery, ADefault>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"foo"));
+			k.extend(&3u16.twox_64_concat());
+			assert_eq!(A::hashed_key_for(3).to_vec(), k);
+
+			assert_eq!(A::contains_key(3), false);
+			assert_eq!(A::get(3), ADefault::get());
+			assert_eq!(A::try_get(3), Err(()));
+			assert_eq!(A::count(), 0);
+
+			// Insert non-existing.
+			A::insert(3, 10);
+
+			assert_eq!(A::contains_key(3), true);
+			assert_eq!(A::get(3), 10);
+			assert_eq!(A::try_get(3), Ok(10));
+			assert_eq!(A::count(), 1);
+
+			// Swap non-existing with existing.
+			A::swap(4, 3);
+
+			assert_eq!(A::contains_key(3), false);
+			assert_eq!(A::get(3), ADefault::get());
+			assert_eq!(A::try_get(3), Err(()));
+			assert_eq!(A::contains_key(4), true);
+			assert_eq!(A::get(4), 10);
+			assert_eq!(A::try_get(4), Ok(10));
+			assert_eq!(A::count(), 1);
+
+			// Swap existing with non-existing.
+			A::swap(4, 3);
+
+			assert_eq!(A::try_get(3), Ok(10));
+			assert_eq!(A::contains_key(4), false);
+			assert_eq!(A::get(4), ADefault::get());
+			assert_eq!(A::try_get(4), Err(()));
+			assert_eq!(A::count(), 1);
+
+			A::insert(4, 11);
+
+			assert_eq!(A::try_get(3), Ok(10));
+			assert_eq!(A::try_get(4), Ok(11));
+			assert_eq!(A::count(), 2);
+
+			// Swap 2 existing.
+			A::swap(3, 4);
+
+			assert_eq!(A::try_get(3), Ok(11));
+			assert_eq!(A::try_get(4), Ok(10));
+			assert_eq!(A::count(), 2);
+
+			// Insert an existing key, shouldn't increment counted values.
+			A::insert(3, 12);
+
+			assert_eq!(A::try_get(3), Ok(12));
+			assert_eq!(A::count(), 2);
+
+			// Remove non-existing.
+			A::remove(2);
+
+			assert_eq!(A::contains_key(2), false);
+			assert_eq!(A::count(), 2);
+
+			// Remove existing.
+			A::remove(3);
+
+			assert_eq!(A::try_get(3), Err(()));
+			assert_eq!(A::count(), 1);
+
+			// Mutate non-existing to existing.
+			A::mutate(3, |query| {
+				assert_eq!(*query, ADefault::get());
+				*query = 40;
+			});
+
+			assert_eq!(A::try_get(3), Ok(40));
+			assert_eq!(A::count(), 2);
+
+			// Mutate existing to existing.
+			A::mutate(3, |query| {
+				assert_eq!(*query, 40);
+				*query = 40;
+			});
+
+			assert_eq!(A::try_get(3), Ok(40));
+			assert_eq!(A::count(), 2);
+
+			// Try fail mutate non-existing to existing.
+			A::try_mutate(2, |query| {
+				assert_eq!(*query, ADefault::get());
+				*query = 4;
+				Result::<(), ()>::Err(())
+			})
+			.err()
+			.unwrap();
+
+			assert_eq!(A::try_get(2), Err(()));
+			assert_eq!(A::count(), 2);
+
+			// Try succeed mutate non-existing to existing.
+			A::try_mutate(2, |query| {
+				assert_eq!(*query, ADefault::get());
+				*query = 41;
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(A::try_get(2), Ok(41));
+			assert_eq!(A::count(), 3);
+
+			// Try succeed mutate existing to existing.
+			A::try_mutate(2, |query| {
+				assert_eq!(*query, 41);
+				*query = 41;
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(A::try_get(2), Ok(41));
+			assert_eq!(A::count(), 3);
+
+			// Try fail mutate non-existing to existing.
+			A::try_mutate_exists(1, |query| {
+				assert_eq!(*query, None);
+				*query = Some(4);
+				Result::<(), ()>::Err(())
+			})
+			.err()
+			.unwrap();
+
+			assert_eq!(A::try_get(1), Err(()));
+			assert_eq!(A::count(), 3);
+
+			// Try succeed mutate non-existing to existing.
+			A::try_mutate_exists(1, |query| {
+				assert_eq!(*query, None);
+				*query = Some(43);
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(A::try_get(1), Ok(43));
+			assert_eq!(A::count(), 4);
+
+			// Try succeed mutate existing to existing.
+			A::try_mutate_exists(1, |query| {
+				assert_eq!(*query, Some(43));
+				*query = Some(45);
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(A::try_get(1), Ok(45));
+			assert_eq!(A::count(), 4);
+
+			// Try succeed mutate existing to non-existing.
+			A::try_mutate_exists(1, |query| {
+				assert_eq!(*query, Some(45));
+				*query = None;
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(A::try_get(1), Err(()));
+			assert_eq!(A::count(), 3);
+
+			// Take exsisting.
+			assert_eq!(A::take(4), 10);
+
+			assert_eq!(A::try_get(4), Err(()));
+			assert_eq!(A::count(), 2);
+
+			// Take non-exsisting.
+			assert_eq!(A::take(4), ADefault::get());
+
+			assert_eq!(A::try_get(4), Err(()));
+			assert_eq!(A::count(), 2);
+
+			// Remove all.
+			let _ = A::clear(u32::max_value(), None);
+
+			assert_eq!(A::count(), 0);
+			assert_eq!(A::initialize_counter(), 0);
+
+			A::insert(1, 1);
+			A::insert(2, 2);
+
+			// Iter values.
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![2, 1]);
+
+			// Iter drain values.
+			assert_eq!(A::iter_values().drain().collect::<Vec<_>>(), vec![2, 1]);
+			assert_eq!(A::count(), 0);
+
+			A::insert(1, 1);
+			A::insert(2, 2);
+
+			// Test initialize_counter.
+			assert_eq!(A::initialize_counter(), 2);
+
+			// Set non-existing.
+			A::set(30, 100);
+
+			assert_eq!(A::contains_key(30), true);
+			assert_eq!(A::get(30), 100);
+			assert_eq!(A::try_get(30), Ok(100));
+			assert_eq!(A::count(), 3);
+
+			// Set existing.
+			A::set(30, 101);
+
+			assert_eq!(A::contains_key(30), true);
+			assert_eq!(A::get(30), 101);
+			assert_eq!(A::try_get(30), Ok(101));
+			assert_eq!(A::count(), 3);
+		})
+	}
+
+	#[test]
+	fn test_option_query() {
+		type B = CountedStorageMap<Prefix, Twox64Concat, u16, u32>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"foo"));
+			k.extend(&3u16.twox_64_concat());
+			assert_eq!(B::hashed_key_for(3).to_vec(), k);
+
+			assert_eq!(B::contains_key(3), false);
+			assert_eq!(B::get(3), None);
+			assert_eq!(B::try_get(3), Err(()));
+			assert_eq!(B::count(), 0);
+
+			// Insert non-existing.
+			B::insert(3, 10);
+
+			assert_eq!(B::contains_key(3), true);
+			assert_eq!(B::get(3), Some(10));
+			assert_eq!(B::try_get(3), Ok(10));
+			assert_eq!(B::count(), 1);
+
+			// Swap non-existing with existing.
+			B::swap(4, 3);
+
+			assert_eq!(B::contains_key(3), false);
+			assert_eq!(B::get(3), None);
+			assert_eq!(B::try_get(3), Err(()));
+			assert_eq!(B::contains_key(4), true);
+			assert_eq!(B::get(4), Some(10));
+			assert_eq!(B::try_get(4), Ok(10));
+			assert_eq!(B::count(), 1);
+
+			// Swap existing with non-existing.
+			B::swap(4, 3);
+
+			assert_eq!(B::try_get(3), Ok(10));
+			assert_eq!(B::contains_key(4), false);
+			assert_eq!(B::get(4), None);
+			assert_eq!(B::try_get(4), Err(()));
+			assert_eq!(B::count(), 1);
+
+			B::insert(4, 11);
+
+			assert_eq!(B::try_get(3), Ok(10));
+			assert_eq!(B::try_get(4), Ok(11));
+			assert_eq!(B::count(), 2);
+
+			// Swap 2 existing.
+			B::swap(3, 4);
+
+			assert_eq!(B::try_get(3), Ok(11));
+			assert_eq!(B::try_get(4), Ok(10));
+			assert_eq!(B::count(), 2);
+
+			// Insert an existing key, shouldn't increment counted values.
+			B::insert(3, 11);
+
+			assert_eq!(B::count(), 2);
+
+			// Remove non-existing.
+			B::remove(2);
+
+			assert_eq!(B::contains_key(2), false);
+			assert_eq!(B::count(), 2);
+
+			// Remove existing.
+			B::remove(3);
+
+			assert_eq!(B::try_get(3), Err(()));
+			assert_eq!(B::count(), 1);
+
+			// Mutate non-existing to existing.
+			B::mutate(3, |query| {
+				assert_eq!(*query, None);
+				*query = Some(40)
+			});
+
+			assert_eq!(B::try_get(3), Ok(40));
+			assert_eq!(B::count(), 2);
+
+			// Mutate existing to existing.
+			B::mutate(3, |query| {
+				assert_eq!(*query, Some(40));
+				*query = Some(40)
+			});
+
+			assert_eq!(B::try_get(3), Ok(40));
+			assert_eq!(B::count(), 2);
+
+			// Mutate existing to non-existing.
+			B::mutate(3, |query| {
+				assert_eq!(*query, Some(40));
+				*query = None
+			});
+
+			assert_eq!(B::try_get(3), Err(()));
+			assert_eq!(B::count(), 1);
+
+			B::insert(3, 40);
+
+			// Try fail mutate non-existing to existing.
+			B::try_mutate(2, |query| {
+				assert_eq!(*query, None);
+				*query = Some(4);
+				Result::<(), ()>::Err(())
+			})
+			.err()
+			.unwrap();
+
+			assert_eq!(B::try_get(2), Err(()));
+			assert_eq!(B::count(), 2);
+
+			// Try succeed mutate non-existing to existing.
+			B::try_mutate(2, |query| {
+				assert_eq!(*query, None);
+				*query = Some(41);
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(B::try_get(2), Ok(41));
+			assert_eq!(B::count(), 3);
+
+			// Try succeed mutate existing to existing.
+			B::try_mutate(2, |query| {
+				assert_eq!(*query, Some(41));
+				*query = Some(41);
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(B::try_get(2), Ok(41));
+			assert_eq!(B::count(), 3);
+
+			// Try succeed mutate existing to non-existing.
+			B::try_mutate(2, |query| {
+				assert_eq!(*query, Some(41));
+				*query = None;
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(B::try_get(2), Err(()));
+			assert_eq!(B::count(), 2);
+
+			B::insert(2, 41);
+
+			// Try fail mutate non-existing to existing.
+			B::try_mutate_exists(1, |query| {
+				assert_eq!(*query, None);
+				*query = Some(4);
+				Result::<(), ()>::Err(())
+			})
+			.err()
+			.unwrap();
+
+			assert_eq!(B::try_get(1), Err(()));
+			assert_eq!(B::count(), 3);
+
+			// Try succeed mutate non-existing to existing.
+			B::try_mutate_exists(1, |query| {
+				assert_eq!(*query, None);
+				*query = Some(43);
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(B::try_get(1), Ok(43));
+			assert_eq!(B::count(), 4);
+
+			// Try succeed mutate existing to existing.
+			B::try_mutate_exists(1, |query| {
+				assert_eq!(*query, Some(43));
+				*query = Some(43);
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(B::try_get(1), Ok(43));
+			assert_eq!(B::count(), 4);
+
+			// Try succeed mutate existing to non-existing.
+			B::try_mutate_exists(1, |query| {
+				assert_eq!(*query, Some(43));
+				*query = None;
+				Result::<(), ()>::Ok(())
+			})
+			.unwrap();
+
+			assert_eq!(B::try_get(1), Err(()));
+			assert_eq!(B::count(), 3);
+
+			// Take exsisting.
+			assert_eq!(B::take(4), Some(10));
+
+			assert_eq!(B::try_get(4), Err(()));
+			assert_eq!(B::count(), 2);
+
+			// Take non-exsisting.
+			assert_eq!(B::take(4), None);
+
+			assert_eq!(B::try_get(4), Err(()));
+			assert_eq!(B::count(), 2);
+
+			// Remove all.
+			let _ = B::clear(u32::max_value(), None);
+
+			assert_eq!(B::count(), 0);
+			assert_eq!(B::initialize_counter(), 0);
+
+			B::insert(1, 1);
+			B::insert(2, 2);
+
+			// Iter values.
+			assert_eq!(B::iter_values().collect::<Vec<_>>(), vec![2, 1]);
+
+			// Iter drain values.
+			assert_eq!(B::iter_values().drain().collect::<Vec<_>>(), vec![2, 1]);
+			assert_eq!(B::count(), 0);
+
+			B::insert(1, 1);
+			B::insert(2, 2);
+
+			// Test initialize_counter.
+			assert_eq!(B::initialize_counter(), 2);
+
+			// Set non-existing.
+			B::set(30, Some(100));
+
+			assert_eq!(B::contains_key(30), true);
+			assert_eq!(B::get(30), Some(100));
+			assert_eq!(B::try_get(30), Ok(100));
+			assert_eq!(B::count(), 3);
+
+			// Set existing.
+			B::set(30, Some(101));
+
+			assert_eq!(B::contains_key(30), true);
+			assert_eq!(B::get(30), Some(101));
+			assert_eq!(B::try_get(30), Ok(101));
+			assert_eq!(B::count(), 3);
+
+			// Unset existing.
+			B::set(30, None);
+
+			assert_eq!(B::contains_key(30), false);
+			assert_eq!(B::get(30), None);
+			assert_eq!(B::try_get(30), Err(()));
+
+			assert_eq!(B::count(), 2);
+
+			// Unset non-existing.
+			B::set(31, None);
+
+			assert_eq!(B::contains_key(31), false);
+			assert_eq!(B::get(31), None);
+			assert_eq!(B::try_get(31), Err(()));
+
+			assert_eq!(B::count(), 2);
+		})
+	}
+
+	#[test]
+	fn append_decode_len_works() {
+		type B = CountedStorageMap<Prefix, Twox64Concat, u16, Vec<u32>>;
+
+		TestExternalities::default().execute_with(|| {
+			assert_eq!(B::decode_len(0), None);
+			B::append(0, 3);
+			assert_eq!(B::decode_len(0), Some(1));
+			B::append(0, 3);
+			assert_eq!(B::decode_len(0), Some(2));
+			B::append(0, 3);
+			assert_eq!(B::decode_len(0), Some(3));
+		})
+	}
+
+	#[test]
+	fn try_append_decode_len_works() {
+		type B = CountedStorageMap<Prefix, Twox64Concat, u16, BoundedVec<u32, ConstU32<3u32>>>;
+
+		TestExternalities::default().execute_with(|| {
+			assert_eq!(B::decode_len(0), None);
+			B::try_append(0, 3).unwrap();
+			assert_eq!(B::decode_len(0), Some(1));
+			B::try_append(0, 3).unwrap();
+			assert_eq!(B::decode_len(0), Some(2));
+			B::try_append(0, 3).unwrap();
+			assert_eq!(B::decode_len(0), Some(3));
+			B::try_append(0, 3).err().unwrap();
+			assert_eq!(B::decode_len(0), Some(3));
+		})
+	}
+
+	#[test]
+	fn migrate_keys_works() {
+		type A = CountedStorageMap<Prefix, Twox64Concat, u16, u32>;
+		type B = CountedStorageMap<Prefix, Blake2_128Concat, u16, u32>;
+		TestExternalities::default().execute_with(|| {
+			A::insert(1, 1);
+			assert_eq!(B::migrate_key::<Twox64Concat, _>(1), Some(1));
+			assert_eq!(B::get(1), Some(1));
+		})
+	}
+
+	#[test]
+	fn translate_values() {
+		type A = CountedStorageMap<Prefix, Twox64Concat, u16, u32>;
+		TestExternalities::default().execute_with(|| {
+			A::insert(1, 1);
+			A::insert(2, 2);
+			A::translate_values::<u32, _>(|old_value| if old_value == 1 { None } else { Some(1) });
+			assert_eq!(A::count(), 1);
+			assert_eq!(A::get(2), Some(1));
+		})
+	}
+
+	#[test]
+	fn test_iter_drain_translate() {
+		type A = CountedStorageMap<Prefix, Twox64Concat, u16, u32>;
+		TestExternalities::default().execute_with(|| {
+			A::insert(1, 1);
+			A::insert(2, 2);
+
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(2, 2), (1, 1)]);
+
+			assert_eq!(A::count(), 2);
+
+			A::translate::<u32, _>(
+				|key, value| if key == 1 { None } else { Some(key as u32 * value) },
+			);
+
+			assert_eq!(A::count(), 1);
+
+			assert_eq!(A::drain().collect::<Vec<_>>(), vec![(2, 4)]);
+
+			assert_eq!(A::count(), 0);
+		})
+	}
+
+	#[test]
+	fn test_iter_from() {
+		type A = CountedStorageMap<Prefix, Twox64Concat, u16, u32>;
+		TestExternalities::default().execute_with(|| {
+			A::insert(1, 1);
+			A::insert(2, 2);
+			A::insert(3, 3);
+			A::insert(4, 4);
+
+			// no prefix is same as normal iter.
+			assert_eq!(A::iter_from(vec![]).collect::<Vec<_>>(), A::iter().collect::<Vec<_>>());
+
+			let iter_all = A::iter().collect::<Vec<_>>();
+			let (before, after) = iter_all.split_at(2);
+			let last_key = before.last().map(|(k, _)| k).unwrap();
+			assert_eq!(A::iter_from(A::hashed_key_for(last_key)).collect::<Vec<_>>(), after);
+		})
+	}
+
+	#[test]
+	fn test_metadata() {
+		type A = CountedStorageMap<Prefix, Twox64Concat, u16, u32, ValueQuery, ADefault>;
+		let mut entries = vec![];
+		A::build_metadata(vec![], &mut entries);
+		assert_eq!(
+			entries,
+			vec![
+				StorageEntryMetadataIR {
+					name: "foo",
+					modifier: StorageEntryModifierIR::Default,
+					ty: StorageEntryTypeIR::Map {
+						hashers: vec![StorageHasherIR::Twox64Concat],
+						key: scale_info::meta_type::<u16>(),
+						value: scale_info::meta_type::<u32>(),
+					},
+					default: 97u32.encode(),
+					docs: vec![],
+				},
+				StorageEntryMetadataIR {
+					name: "counter_for_foo",
+					modifier: StorageEntryModifierIR::Default,
+					ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+					default: vec![0, 0, 0, 0],
+					docs: if cfg!(feature = "no-metadata-docs") {
+						vec![]
+					} else {
+						vec!["Counter for the related counted storage map"]
+					},
+				},
+			]
+		);
+	}
+}
diff --git a/substrate/frame/support/src/storage/types/counted_nmap.rs b/substrate/frame/support/src/storage/types/counted_nmap.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7dbcb74f000537b0f2a6c067d7594f529763a554
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/counted_nmap.rs
@@ -0,0 +1,1427 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2021-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.
+
+//! Counted storage n-map type.
+
+use crate::{
+	storage::{
+		types::{
+			EncodeLikeTuple, HasKeyPrefix, HasReversibleKeyPrefix, OptionQuery, QueryKindTrait,
+			StorageEntryMetadataBuilder, StorageNMap, StorageValue, TupleToEncodedIter, ValueQuery,
+		},
+		KeyGenerator, PrefixIterator, StorageAppend, StorageDecodeLength,
+	},
+	traits::{Get, GetDefault, StorageInfo, StorageInstance},
+	Never,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen, Ref};
+use sp_metadata_ir::StorageEntryMetadataIR;
+use sp_runtime::traits::Saturating;
+use sp_std::prelude::*;
+
+/// A wrapper around a `StorageNMap` and a `StorageValue<Value=u32>` to keep track of how many items
+/// are in a map, without needing to iterate over all of the values.
+///
+/// This storage item has some additional storage read and write overhead when manipulating values
+/// compared to a regular storage map.
+///
+/// For functions where we only add or remove a value, a single storage read is needed to check if
+/// that value already exists. For mutate functions, two storage reads are used to check if the
+/// value existed before and after the mutation.
+///
+/// Whenever the counter needs to be updated, an additional read and write occurs to update that
+/// counter.
+pub struct CountedStorageNMap<
+	Prefix,
+	Key,
+	Value,
+	QueryKind = OptionQuery,
+	OnEmpty = GetDefault,
+	MaxValues = GetDefault,
+>(core::marker::PhantomData<(Prefix, Key, Value, QueryKind, OnEmpty, MaxValues)>);
+
+/// The requirement for an instance of [`CountedStorageNMap`].
+pub trait CountedStorageNMapInstance: StorageInstance {
+	/// The prefix to use for the counter storage value.
+	type CounterPrefix: StorageInstance;
+}
+
+// Private helper trait to access map from counted storage n-map
+trait MapWrapper {
+	type Map;
+}
+
+impl<P: CountedStorageNMapInstance, K, V, Q, O, M> MapWrapper
+	for CountedStorageNMap<P, K, V, Q, O, M>
+{
+	type Map = StorageNMap<P, K, V, Q, O, M>;
+}
+
+type CounterFor<P> =
+	StorageValue<<P as CountedStorageNMapInstance>::CounterPrefix, u32, ValueQuery>;
+
+/// On removal logic for updating counter while draining upon some prefix with
+/// [`crate::storage::PrefixIterator`].
+pub struct OnRemovalCounterUpdate<Prefix>(core::marker::PhantomData<Prefix>);
+
+impl<Prefix: CountedStorageNMapInstance> crate::storage::PrefixIteratorOnRemoval
+	for OnRemovalCounterUpdate<Prefix>
+{
+	fn on_removal(_key: &[u8], _value: &[u8]) {
+		CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+	CountedStorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageNMapInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// The key used to store the counter of the map.
+	pub fn counter_storage_final_key() -> [u8; 32] {
+		CounterFor::<Prefix>::hashed_key()
+	}
+
+	/// The prefix used to generate the key of the map.
+	pub fn map_storage_final_prefix() -> Vec<u8> {
+		use crate::storage::generator::StorageNMap;
+		<Self as MapWrapper>::Map::prefix_hash()
+	}
+
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	pub fn hashed_key_for<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> Vec<u8> {
+		<Self as MapWrapper>::Map::hashed_key_for(key)
+	}
+
+	/// Does the value (explicitly) exist in storage?
+	pub fn contains_key<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(key: KArg) -> bool {
+		<Self as MapWrapper>::Map::contains_key(key)
+	}
+
+	/// Load the value associated with the given key from the map.
+	pub fn get<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> QueryKind::Query {
+		<Self as MapWrapper>::Map::get(key)
+	}
+
+	/// Try to get the value for the given key from the map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	pub fn try_get<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> Result<Value, ()> {
+		<Self as MapWrapper>::Map::try_get(key)
+	}
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	/// It decrements the counter when the value is removed.
+	pub fn set<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+		query: QueryKind::Query,
+	) {
+		let option = QueryKind::from_query_to_optional_value(query);
+		if option.is_none() {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+		}
+		<Self as MapWrapper>::Map::set(key, QueryKind::from_optional_value_to_query(option))
+	}
+
+	/// Take a value from storage, removing it afterwards.
+	pub fn take<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> QueryKind::Query {
+		let removed_value =
+			<Self as MapWrapper>::Map::mutate_exists(key, |value| core::mem::replace(value, None));
+		if removed_value.is_some() {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+		}
+		QueryKind::from_optional_value_to_query(removed_value)
+	}
+
+	/// Swap the values of two key-pairs.
+	pub fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
+	where
+		KOther: KeyGenerator,
+		KArg1: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		KArg2: EncodeLikeTuple<KOther::KArg> + TupleToEncodedIter,
+	{
+		<Self as MapWrapper>::Map::swap::<KOther, _, _>(key1, key2)
+	}
+
+	/// Store a value to be associated with the given keys from the map.
+	pub fn insert<KArg, VArg>(key: KArg, val: VArg)
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + EncodeLike<Key::KArg> + TupleToEncodedIter,
+		VArg: EncodeLike<Value>,
+	{
+		if !<Self as MapWrapper>::Map::contains_key(Ref::from(&key)) {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_inc());
+		}
+		<Self as MapWrapper>::Map::insert(key, val)
+	}
+
+	/// Remove the value under the given keys.
+	pub fn remove<KArg: EncodeLikeTuple<Key::KArg> + EncodeLike<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) {
+		if <Self as MapWrapper>::Map::contains_key(Ref::from(&key)) {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+		}
+		<Self as MapWrapper>::Map::remove(key)
+	}
+
+	/// Attempt to remove items from the map matching a `partial_key` prefix.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map which match the `partial key`. If so, then the map may not be
+	/// empty when the resultant `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must be provided in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map and `partial_key`. Subsequent
+	/// calls operating on the same map/`partial_key` should always pass `Some`, and this should be
+	/// equal to the previous call result's `maybe_cursor` field.
+	pub fn clear_prefix<KP>(
+		partial_key: KP,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::MultiRemovalResults
+	where
+		Key: HasKeyPrefix<KP>,
+	{
+		let result = <Self as MapWrapper>::Map::clear_prefix(partial_key, limit, maybe_cursor);
+		match result.maybe_cursor {
+			None => CounterFor::<Prefix>::kill(),
+			Some(_) => CounterFor::<Prefix>::mutate(|x| x.saturating_reduce(result.unique)),
+		}
+		result
+	}
+
+	/// Iterate over values that share the first key.
+	pub fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<Value>
+	where
+		Key: HasKeyPrefix<KP>,
+	{
+		<Self as MapWrapper>::Map::iter_prefix_values(partial_key)
+	}
+
+	/// Mutate the value under the given keys.
+	pub fn mutate<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut QueryKind::Query) -> R,
+	{
+		Self::try_mutate(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	/// Mutate the value under the given keys when the closure returns `Ok`.
+	pub fn try_mutate<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut QueryKind::Query) -> Result<R, E>,
+	{
+		Self::try_mutate_exists(key, |option_value_ref| {
+			let option_value = core::mem::replace(option_value_ref, None);
+			let mut query = QueryKind::from_optional_value_to_query(option_value);
+			let res = f(&mut query);
+			let option_value = QueryKind::from_query_to_optional_value(query);
+			let _ = core::mem::replace(option_value_ref, option_value);
+			res
+		})
+	}
+
+	/// Mutate the value under the given keys. Deletes the item if mutated to a `None`.
+	pub fn mutate_exists<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<Value>) -> R,
+	{
+		Self::try_mutate_exists(key, |v| Ok::<R, Never>(f(v)))
+			.expect("`Never` can not be constructed; qed")
+	}
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	pub fn try_mutate_exists<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<Value>) -> Result<R, E>,
+	{
+		<Self as MapWrapper>::Map::try_mutate_exists(key, |option_value| {
+			let existed = option_value.is_some();
+			let res = f(option_value);
+			let exist = option_value.is_some();
+
+			if res.is_ok() {
+				if existed && !exist {
+					// Value was deleted
+					CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+				} else if !existed && exist {
+					// Value was added
+					CounterFor::<Prefix>::mutate(|value| value.saturating_inc());
+				}
+			}
+			res
+		})
+	}
+
+	/// Append the given item to the value in the storage.
+	///
+	/// `Value` is required to implement [`StorageAppend`].
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	pub fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + EncodeLike<Key::KArg> + TupleToEncodedIter,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageAppend<Item>,
+	{
+		if !<Self as MapWrapper>::Map::contains_key(Ref::from(&key)) {
+			CounterFor::<Prefix>::mutate(|value| value.saturating_inc());
+		}
+		<Self as MapWrapper>::Map::append(key, item)
+	}
+
+	/// Read the length of the storage value without decoding the entire value under the
+	/// given `key1` and `key2`.
+	///
+	/// `Value` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	pub fn decode_len<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> Option<usize>
+	where
+		Value: StorageDecodeLength,
+	{
+		<Self as MapWrapper>::Map::decode_len(key)
+	}
+
+	/// Migrate an item with the given `key` from defunct `hash_fns` to the current hashers.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	pub fn migrate_keys<KArg>(key: KArg, hash_fns: Key::HArg) -> Option<Value>
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+	{
+		<Self as MapWrapper>::Map::migrate_keys::<_>(key, hash_fns)
+	}
+
+	/// Attempt to remove all items from the map.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map. If so, then the map may not be empty when the resultant
+	/// `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must always be provided through in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map. Subsequent calls
+	/// operating on the same map should always pass `Some`, and this should be equal to the
+	/// previous call result's `maybe_cursor` field.
+	pub fn clear(limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::MultiRemovalResults {
+		let result = <Self as MapWrapper>::Map::clear(limit, maybe_cursor);
+		match result.maybe_cursor {
+			None => CounterFor::<Prefix>::kill(),
+			Some(_) => CounterFor::<Prefix>::mutate(|x| x.saturating_reduce(result.unique)),
+		}
+		result
+	}
+
+	/// Iter over all value of the storage.
+	///
+	/// NOTE: If a value failed to decode because storage is corrupted then it is skipped.
+	pub fn iter_values() -> crate::storage::PrefixIterator<Value> {
+		<Self as MapWrapper>::Map::iter_values()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade.
+	pub fn translate_values<OldValue: Decode, F: FnMut(OldValue) -> Option<Value>>(mut f: F) {
+		<Self as MapWrapper>::Map::translate_values(|old_value| {
+			let res = f(old_value);
+			if res.is_none() {
+				CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+			}
+			res
+		})
+	}
+
+	/// Initialize the counter with the actual number of items in the map.
+	///
+	/// This function iterates through all the items in the map and sets the counter. This operation
+	/// can be very heavy, so use with caution.
+	///
+	/// Returns the number of items in the map which is used to set the counter.
+	pub fn initialize_counter() -> u32 {
+		let count = Self::iter_values().count() as u32;
+		CounterFor::<Prefix>::set(count);
+		count
+	}
+
+	/// Return the count.
+	pub fn count() -> u32 {
+		CounterFor::<Prefix>::get()
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+	CountedStorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageNMapInstance,
+	Key: super::key::ReversibleKeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Enumerate all elements in the map with prefix key `kp` in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_prefix<KP>(
+		kp: KP,
+	) -> crate::storage::PrefixIterator<(<Key as HasKeyPrefix<KP>>::Suffix, Value)>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as MapWrapper>::Map::iter_prefix(kp)
+	}
+
+	/// Enumerate all elements in the map with prefix key `kp` after a specified `starting_raw_key`
+	/// in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::PrefixIterator<
+		(<Key as HasKeyPrefix<KP>>::Suffix, Value),
+		OnRemovalCounterUpdate<Prefix>,
+	>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as MapWrapper>::Map::iter_prefix_from(kp, starting_raw_key).convert_on_removal()
+	}
+
+	/// Enumerate all suffix keys in the map with prefix key `kp` in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_key_prefix<KP>(
+		kp: KP,
+	) -> crate::storage::KeyPrefixIterator<<Key as HasKeyPrefix<KP>>::Suffix>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as MapWrapper>::Map::iter_key_prefix(kp)
+	}
+
+	/// Enumerate all suffix keys in the map with prefix key `kp` after a specified
+	/// `starting_raw_key` in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_key_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::KeyPrefixIterator<<Key as HasKeyPrefix<KP>>::Suffix>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as MapWrapper>::Map::iter_key_prefix_from(kp, starting_raw_key)
+	}
+
+	/// Remove all elements from the map with prefix key `kp` and iterate through them in no
+	/// particular order.
+	///
+	/// If you add elements with prefix key `k1` to the map while doing this, you'll get undefined
+	/// results.
+	pub fn drain_prefix<KP>(
+		kp: KP,
+	) -> crate::storage::PrefixIterator<
+		(<Key as HasKeyPrefix<KP>>::Suffix, Value),
+		OnRemovalCounterUpdate<Prefix>,
+	>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as MapWrapper>::Map::drain_prefix(kp).convert_on_removal()
+	}
+
+	/// Enumerate all elements in the map in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter(
+	) -> crate::storage::PrefixIterator<(Key::Key, Value), OnRemovalCounterUpdate<Prefix>> {
+		<Self as MapWrapper>::Map::iter().convert_on_removal()
+	}
+
+	/// Enumerate all elements in the map after a specified `starting_key` in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_from(
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::PrefixIterator<(Key::Key, Value), OnRemovalCounterUpdate<Prefix>> {
+		<Self as MapWrapper>::Map::iter_from(starting_raw_key).convert_on_removal()
+	}
+
+	/// Enumerate all keys in the map in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_keys() -> crate::storage::KeyPrefixIterator<Key::Key> {
+		<Self as MapWrapper>::Map::iter_keys()
+	}
+
+	/// Enumerate all keys in the map after a specified `starting_raw_key` in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_keys_from(
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::KeyPrefixIterator<Key::Key> {
+		<Self as MapWrapper>::Map::iter_keys_from(starting_raw_key)
+	}
+
+	/// Remove all elements from the map and iterate through them in no particular order.
+	///
+	/// If you add elements to the map while doing this, you'll get undefined results.
+	pub fn drain(
+	) -> crate::storage::PrefixIterator<(Key::Key, Value), OnRemovalCounterUpdate<Prefix>> {
+		<Self as MapWrapper>::Map::drain().convert_on_removal()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	///
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value can't be decoded because the storage is corrupted, then it is skipped.
+	pub fn translate<O: Decode, F: FnMut(Key::Key, O) -> Option<Value>>(mut f: F) {
+		<Self as MapWrapper>::Map::translate(|key, old_value| {
+			let res = f(key, old_value);
+			if res.is_none() {
+				CounterFor::<Prefix>::mutate(|value| value.saturating_dec());
+			}
+			res
+		})
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues> StorageEntryMetadataBuilder
+	for CountedStorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageNMapInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec + scale_info::StaticTypeInfo,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn build_metadata(docs: Vec<&'static str>, entries: &mut Vec<StorageEntryMetadataIR>) {
+		<Self as MapWrapper>::Map::build_metadata(docs, entries);
+		CounterFor::<Prefix>::build_metadata(
+			vec![&"Counter for the related counted storage map"],
+			entries,
+		);
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues> crate::traits::StorageInfoTrait
+	for CountedStorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageNMapInstance,
+	Key: super::key::KeyGenerator + super::key::KeyGeneratorMaxEncodedLen,
+	Value: FullCodec + MaxEncodedLen,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn storage_info() -> Vec<StorageInfo> {
+		[<Self as MapWrapper>::Map::storage_info(), CounterFor::<Prefix>::storage_info()].concat()
+	}
+}
+
+/// It doesn't require to implement `MaxEncodedLen` and give no information for `max_size`.
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues> crate::traits::PartialStorageInfoTrait
+	for CountedStorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: CountedStorageNMapInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn partial_storage_info() -> Vec<StorageInfo> {
+		[
+			<Self as MapWrapper>::Map::partial_storage_info(),
+			CounterFor::<Prefix>::partial_storage_info(),
+		]
+		.concat()
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{
+		hash::{StorageHasher as _, *},
+		storage::types::{Key as NMapKey, ValueQuery},
+	};
+	use sp_io::{hashing::twox_128, TestExternalities};
+	use sp_metadata_ir::{StorageEntryModifierIR, StorageEntryTypeIR, StorageHasherIR};
+
+	struct Prefix;
+	impl StorageInstance for Prefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "Foo";
+	}
+	impl CountedStorageNMapInstance for Prefix {
+		type CounterPrefix = Prefix;
+	}
+
+	struct ADefault;
+	impl crate::traits::Get<u32> for ADefault {
+		fn get() -> u32 {
+			98
+		}
+	}
+
+	#[test]
+	fn test_1_key() {
+		type A = CountedStorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, u32, OptionQuery>;
+		type AValueQueryWithAnOnEmpty =
+			CountedStorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, u32, ValueQuery, ADefault>;
+		type B = CountedStorageNMap<Prefix, NMapKey<Blake2_256, u16>, u32, ValueQuery>;
+		type C = CountedStorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, u8, ValueQuery>;
+		type WithLen = CountedStorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, Vec<u32>>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"Foo"));
+			k.extend(&3u16.blake2_128_concat());
+			assert_eq!(A::hashed_key_for((&3,)).to_vec(), k);
+
+			assert_eq!(A::contains_key((3,)), false);
+			assert_eq!(A::get((3,)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3,)), 98);
+			assert_eq!(A::count(), 0);
+
+			A::insert((3,), 10);
+			assert_eq!(A::contains_key((3,)), true);
+			assert_eq!(A::get((3,)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3,)), 10);
+			assert_eq!(A::count(), 1);
+
+			A::swap::<NMapKey<Blake2_128Concat, u16>, _, _>((3,), (2,));
+			assert_eq!(A::contains_key((3,)), false);
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((3,)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3,)), 98);
+			assert_eq!(A::get((2,)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((2,)), 10);
+			assert_eq!(A::count(), 1);
+
+			A::remove((2,));
+			assert_eq!(A::contains_key((2,)), false);
+			assert_eq!(A::get((2,)), None);
+			assert_eq!(A::count(), 0);
+
+			AValueQueryWithAnOnEmpty::mutate((2,), |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate((2,), |v| *v = *v * 2);
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(98 * 4));
+			assert_eq!(A::count(), 1);
+
+			A::remove((2,));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2,), |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2,), |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(98 * 4));
+			assert_eq!(A::count(), 1);
+
+			A::remove((2,));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2,), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2,)), false);
+			assert_eq!(A::count(), 0);
+
+			A::remove((2,));
+			AValueQueryWithAnOnEmpty::mutate_exists((2,), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(10));
+			AValueQueryWithAnOnEmpty::mutate_exists((2,), |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(100));
+			assert_eq!(A::count(), 1);
+
+			A::remove((2,));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2,), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(10));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2,), |v| {
+				*v = Some(v.unwrap() * 10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(100));
+			assert_eq!(A::try_get((2,)), Ok(100));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2,), |v| {
+				*v = Some(v.unwrap() * 10);
+				Err(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(100));
+			assert_eq!(A::count(), 1);
+
+			A::insert((2,), 10);
+			assert_eq!(A::take((2,)), Some(10));
+			assert_eq!(A::contains_key((2,)), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take((2,)), 98);
+			assert_eq!(A::contains_key((2,)), false);
+			assert_eq!(A::try_get((2,)), Err(()));
+			assert_eq!(A::count(), 0);
+
+			B::insert((2,), 10);
+			assert_eq!(
+				A::migrate_keys((2,), (Box::new(|key| Blake2_256::hash(key).to_vec()),),),
+				Some(10)
+			);
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(10));
+			assert_eq!(A::count(), 1);
+
+			A::insert((3,), 10);
+			A::insert((4,), 10);
+			assert_eq!(A::count(), 3);
+			let _ = A::clear(u32::max_value(), None);
+			assert!(!A::contains_key((2,)) && !A::contains_key((3,)) && !A::contains_key((4,)));
+			assert_eq!(A::count(), 0);
+
+			A::insert((3,), 10);
+			A::insert((4,), 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+			assert_eq!(A::count(), 2);
+
+			C::insert((3,), 10);
+			C::insert((4,), 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 20), (3, 20)]);
+			assert_eq!(A::count(), 2);
+
+			A::insert((3,), 10);
+			A::insert((4,), 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 10), (3, 10)]);
+			assert_eq!(A::drain().collect::<Vec<_>>(), vec![(4, 10), (3, 10)]);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(A::count(), 0);
+
+			C::insert((3,), 10);
+			C::insert((4,), 10);
+			A::translate::<u8, _>(|k1, v| Some((k1 as u16 * v as u16).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 40), (3, 30)]);
+			assert_eq!(A::count(), 2);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![StorageHasherIR::Blake2_128Concat],
+							key: scale_info::meta_type::<u16>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: if cfg!(feature = "no-metadata-docs") {
+							vec![]
+						} else {
+							vec!["Counter for the related counted storage map"]
+						},
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![StorageHasherIR::Blake2_128Concat],
+							key: scale_info::meta_type::<u16>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 98u32.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: if cfg!(feature = "no-metadata-docs") {
+							vec![]
+						} else {
+							vec!["Counter for the related counted storage map"]
+						},
+					},
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len((3,)), None);
+			WithLen::append((0,), 10);
+			assert_eq!(WithLen::decode_len((0,)), Some(1));
+		});
+	}
+
+	#[test]
+	fn test_2_keys() {
+		type A = CountedStorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			u32,
+			OptionQuery,
+		>;
+		type AValueQueryWithAnOnEmpty = CountedStorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			u32,
+			ValueQuery,
+			ADefault,
+		>;
+		type B = CountedStorageNMap<
+			Prefix,
+			(NMapKey<Blake2_256, u16>, NMapKey<Twox128, u8>),
+			u32,
+			ValueQuery,
+		>;
+		type C = CountedStorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			u8,
+			ValueQuery,
+		>;
+		type WithLen = CountedStorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			Vec<u32>,
+		>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"Foo"));
+			k.extend(&3u16.blake2_128_concat());
+			k.extend(&30u8.twox_64_concat());
+			assert_eq!(A::hashed_key_for((3, 30)).to_vec(), k);
+
+			assert_eq!(A::contains_key((3, 30)), false);
+			assert_eq!(A::get((3, 30)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3, 30)), 98);
+			assert_eq!(A::count(), 0);
+
+			A::insert((3, 30), 10);
+			assert_eq!(A::contains_key((3, 30)), true);
+			assert_eq!(A::get((3, 30)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3, 30)), 10);
+			assert_eq!(A::count(), 1);
+
+			A::swap::<(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>), _, _>(
+				(3, 30),
+				(2, 20),
+			);
+			assert_eq!(A::contains_key((3, 30)), false);
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((3, 30)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3, 30)), 98);
+			assert_eq!(A::get((2, 20)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((2, 20)), 10);
+			assert_eq!(A::count(), 1);
+
+			A::remove((2, 20));
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(A::get((2, 20)), None);
+			assert_eq!(A::count(), 0);
+
+			AValueQueryWithAnOnEmpty::mutate((2, 20), |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate((2, 20), |v| *v = *v * 2);
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(98 * 4));
+			assert_eq!(A::count(), 1);
+
+			A::remove((2, 20));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2, 20), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(A::count(), 0);
+
+			A::remove((2, 20));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2, 20), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(A::count(), 0);
+
+			A::remove((2, 20));
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(10));
+			assert_eq!(A::count(), 1);
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20), |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(100));
+			assert_eq!(A::count(), 1);
+
+			A::remove((2, 20));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(10));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20), |v| {
+				*v = Some(v.unwrap() * 10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(100));
+			assert_eq!(A::try_get((2, 20)), Ok(100));
+			assert_eq!(A::count(), 1);
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20), |v| {
+				*v = Some(v.unwrap() * 10);
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(100));
+			assert_eq!(A::count(), 1);
+
+			A::insert((2, 20), 10);
+			assert_eq!(A::take((2, 20)), Some(10));
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take((2, 20)), 98);
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(A::try_get((2, 20)), Err(()));
+			assert_eq!(A::count(), 0);
+
+			B::insert((2, 20), 10);
+			assert_eq!(
+				A::migrate_keys(
+					(2, 20),
+					(
+						Box::new(|key| Blake2_256::hash(key).to_vec()),
+						Box::new(|key| Twox128::hash(key).to_vec()),
+					),
+				),
+				Some(10)
+			);
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(10));
+			assert_eq!(A::count(), 1);
+
+			A::insert((3, 30), 10);
+			A::insert((4, 40), 10);
+			assert_eq!(A::count(), 3);
+			let _ = A::clear(u32::max_value(), None);
+			// one of the item has been removed
+			assert!(
+				!A::contains_key((2, 20)) && !A::contains_key((3, 30)) && !A::contains_key((4, 40))
+			);
+			assert_eq!(A::count(), 0);
+
+			assert_eq!(A::count(), 0);
+
+			A::insert((3, 30), 10);
+			A::insert((4, 40), 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+			assert_eq!(A::count(), 2);
+
+			C::insert((3, 30), 10);
+			C::insert((4, 40), 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40), 20), ((3, 30), 20)]);
+			assert_eq!(A::count(), 2);
+
+			A::insert((3, 30), 10);
+			A::insert((4, 40), 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40), 10), ((3, 30), 10)]);
+			assert_eq!(A::drain().collect::<Vec<_>>(), vec![((4, 40), 10), ((3, 30), 10)]);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(A::count(), 0);
+
+			C::insert((3, 30), 10);
+			C::insert((4, 40), 10);
+			A::translate::<u8, _>(|(k1, k2), v| Some((k1 * k2 as u16 * v as u16).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40), 1600), ((3, 30), 900)]);
+			assert_eq!(A::count(), 2);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u8)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: if cfg!(feature = "no-metadata-docs") {
+							vec![]
+						} else {
+							vec!["Counter for the related counted storage map"]
+						},
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u8)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 98u32.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: if cfg!(feature = "no-metadata-docs") {
+							vec![]
+						} else {
+							vec!["Counter for the related counted storage map"]
+						},
+					},
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len((3, 30)), None);
+			WithLen::append((0, 100), 10);
+			assert_eq!(WithLen::decode_len((0, 100)), Some(1));
+
+			A::insert((3, 30), 11);
+			A::insert((3, 31), 12);
+			A::insert((4, 40), 13);
+			A::insert((4, 41), 14);
+			assert_eq!(A::iter_prefix_values((3,)).collect::<Vec<_>>(), vec![12, 11]);
+			assert_eq!(A::iter_prefix_values((4,)).collect::<Vec<_>>(), vec![13, 14]);
+			assert_eq!(A::count(), 5);
+		});
+	}
+
+	#[test]
+	fn test_3_keys() {
+		type A = CountedStorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			u32,
+			OptionQuery,
+		>;
+		type AValueQueryWithAnOnEmpty = CountedStorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			u32,
+			ValueQuery,
+			ADefault,
+		>;
+		type B = CountedStorageNMap<
+			Prefix,
+			(NMapKey<Blake2_256, u16>, NMapKey<Blake2_256, u16>, NMapKey<Twox128, u16>),
+			u32,
+			ValueQuery,
+		>;
+		type C = CountedStorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			u8,
+			ValueQuery,
+		>;
+		type WithLen = CountedStorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			Vec<u32>,
+		>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"Foo"));
+			k.extend(&1u16.blake2_128_concat());
+			k.extend(&10u16.blake2_128_concat());
+			k.extend(&100u16.twox_64_concat());
+			assert_eq!(A::hashed_key_for((1, 10, 100)).to_vec(), k);
+
+			assert_eq!(A::contains_key((1, 10, 100)), false);
+			assert_eq!(A::get((1, 10, 100)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((1, 10, 100)), 98);
+			assert_eq!(A::count(), 0);
+
+			A::insert((1, 10, 100), 30);
+			assert_eq!(A::contains_key((1, 10, 100)), true);
+			assert_eq!(A::get((1, 10, 100)), Some(30));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((1, 10, 100)), 30);
+			assert_eq!(A::count(), 1);
+
+			A::swap::<
+				(
+					NMapKey<Blake2_128Concat, u16>,
+					NMapKey<Blake2_128Concat, u16>,
+					NMapKey<Twox64Concat, u16>,
+				),
+				_,
+				_,
+			>((1, 10, 100), (2, 20, 200));
+			assert_eq!(A::contains_key((1, 10, 100)), false);
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((1, 10, 100)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((1, 10, 100)), 98);
+			assert_eq!(A::get((2, 20, 200)), Some(30));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((2, 20, 200)), 30);
+			assert_eq!(A::count(), 1);
+
+			A::remove((2, 20, 200));
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+			assert_eq!(A::get((2, 20, 200)), None);
+			assert_eq!(A::count(), 0);
+
+			AValueQueryWithAnOnEmpty::mutate((2, 20, 200), |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate((2, 20, 200), |v| *v = *v * 2);
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(98 * 4));
+			assert_eq!(A::count(), 1);
+
+			A::remove((2, 20, 200));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2, 20, 200), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+			assert_eq!(A::count(), 0);
+
+			A::remove((2, 20, 200));
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20, 200), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(10));
+			assert_eq!(A::count(), 1);
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20, 200), |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(100));
+			assert_eq!(A::count(), 1);
+
+			A::remove((2, 20, 200));
+			let _: Result<(), ()> =
+				AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20, 200), |v| {
+					assert!(v.is_none());
+					*v = Some(10);
+					Ok(())
+				});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(10));
+			let _: Result<(), ()> =
+				AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20, 200), |v| {
+					*v = Some(v.unwrap() * 10);
+					Ok(())
+				});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(100));
+			assert_eq!(A::try_get((2, 20, 200)), Ok(100));
+			assert_eq!(A::count(), 1);
+			let _: Result<(), ()> =
+				AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20, 200), |v| {
+					*v = Some(v.unwrap() * 10);
+					Err(())
+				});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(100));
+			assert_eq!(A::count(), 1);
+
+			A::insert((2, 20, 200), 10);
+			assert_eq!(A::take((2, 20, 200)), Some(10));
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take((2, 20, 200)), 98);
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+			assert_eq!(A::try_get((2, 20, 200)), Err(()));
+			assert_eq!(A::count(), 0);
+
+			B::insert((2, 20, 200), 10);
+			assert_eq!(
+				A::migrate_keys(
+					(2, 20, 200),
+					(
+						Box::new(|key| Blake2_256::hash(key).to_vec()),
+						Box::new(|key| Blake2_256::hash(key).to_vec()),
+						Box::new(|key| Twox128::hash(key).to_vec()),
+					),
+				),
+				Some(10)
+			);
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(10));
+			assert_eq!(A::count(), 1);
+
+			A::insert((3, 30, 300), 10);
+			A::insert((4, 40, 400), 10);
+			assert_eq!(A::count(), 3);
+			let _ = A::clear(u32::max_value(), None);
+			// one of the item has been removed
+			assert!(
+				!A::contains_key((2, 20, 200)) &&
+					!A::contains_key((3, 30, 300)) &&
+					!A::contains_key((4, 40, 400))
+			);
+			assert_eq!(A::count(), 0);
+
+			A::insert((3, 30, 300), 10);
+			A::insert((4, 40, 400), 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+			assert_eq!(A::count(), 2);
+
+			C::insert((3, 30, 300), 10);
+			C::insert((4, 40, 400), 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40, 400), 20), ((3, 30, 300), 20)]);
+			assert_eq!(A::count(), 2);
+
+			A::insert((3, 30, 300), 10);
+			A::insert((4, 40, 400), 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40, 400), 10), ((3, 30, 300), 10)]);
+			assert_eq!(
+				A::drain().collect::<Vec<_>>(),
+				vec![((4, 40, 400), 10), ((3, 30, 300), 10)]
+			);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+			assert_eq!(A::count(), 0);
+
+			C::insert((3, 30, 300), 10);
+			C::insert((4, 40, 400), 10);
+			A::translate::<u8, _>(|(k1, k2, k3), v| {
+				Some((k1 * k2 as u16 * v as u16 / k3 as u16).into())
+			});
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40, 400), 4), ((3, 30, 300), 3)]);
+			assert_eq!(A::count(), 2);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u16, u16)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: if cfg!(feature = "no-metadata-docs") {
+							vec![]
+						} else {
+							vec!["Counter for the related counted storage map"]
+						},
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u16, u16)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 98u32.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: if cfg!(feature = "no-metadata-docs") {
+							vec![]
+						} else {
+							vec!["Counter for the related counted storage map"]
+						},
+					},
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len((3, 30, 300)), None);
+			WithLen::append((0, 100, 1000), 10);
+			assert_eq!(WithLen::decode_len((0, 100, 1000)), Some(1));
+
+			A::insert((3, 30, 300), 11);
+			A::insert((3, 30, 301), 12);
+			A::insert((4, 40, 400), 13);
+			A::insert((4, 40, 401), 14);
+			assert_eq!(A::iter_prefix_values((3,)).collect::<Vec<_>>(), vec![11, 12]);
+			assert_eq!(A::iter_prefix_values((4,)).collect::<Vec<_>>(), vec![14, 13]);
+			assert_eq!(A::iter_prefix_values((3, 30)).collect::<Vec<_>>(), vec![11, 12]);
+			assert_eq!(A::iter_prefix_values((4, 40)).collect::<Vec<_>>(), vec![14, 13]);
+			assert_eq!(A::count(), 5);
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/types/double_map.rs b/substrate/frame/support/src/storage/types/double_map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e787921841032f3f0cbada6fd0ff0d4ab665dd59
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/double_map.rs
@@ -0,0 +1,970 @@
+// 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.
+
+//! Storage map type. Implements StorageDoubleMap, StorageIterableDoubleMap,
+//! StoragePrefixedDoubleMap traits and their methods directly.
+
+use crate::{
+	storage::{
+		types::{OptionQuery, QueryKindTrait, StorageEntryMetadataBuilder},
+		KeyLenOf, StorageAppend, StorageDecodeLength, StoragePrefixedMap, StorageTryAppend,
+	},
+	traits::{Get, GetDefault, StorageInfo, StorageInstance},
+	StorageHasher, Twox128,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};
+use sp_arithmetic::traits::SaturatedConversion;
+use sp_metadata_ir::{StorageEntryMetadataIR, StorageEntryTypeIR};
+use sp_std::prelude::*;
+
+/// A type that allow to store values for `(key1, key2)` couple. Similar to `StorageMap` but allow
+/// to iterate and remove value associated to first key.
+///
+/// Each value is stored at:
+/// ```nocompile
+/// Twox128(Prefix::pallet_prefix())
+/// 		++ Twox128(Prefix::STORAGE_PREFIX)
+/// 		++ Hasher1(encode(key1))
+/// 		++ Hasher2(encode(key2))
+/// ```
+///
+/// # Warning
+///
+/// If the key1s (or key2s) are not trusted (e.g. can be set by a user), a cryptographic `hasher`
+/// such as `blake2_128_concat` must be used for Hasher1 (resp. Hasher2). Otherwise, other values
+/// in storage can be compromised.
+pub struct StorageDoubleMap<
+	Prefix,
+	Hasher1,
+	Key1,
+	Hasher2,
+	Key2,
+	Value,
+	QueryKind = OptionQuery,
+	OnEmpty = GetDefault,
+	MaxValues = GetDefault,
+>(
+	core::marker::PhantomData<(
+		Prefix,
+		Hasher1,
+		Key1,
+		Hasher2,
+		Key2,
+		Value,
+		QueryKind,
+		OnEmpty,
+		MaxValues,
+	)>,
+);
+
+impl<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues> Get<u32>
+	for KeyLenOf<
+		StorageDoubleMap<
+			Prefix,
+			Hasher1,
+			Key1,
+			Hasher2,
+			Key2,
+			Value,
+			QueryKind,
+			OnEmpty,
+			MaxValues,
+		>,
+	> where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher,
+	Hasher2: crate::hash::StorageHasher,
+	Key1: MaxEncodedLen,
+	Key2: MaxEncodedLen,
+{
+	fn get() -> u32 {
+		// The `max_len` of both key hashes plus the pallet prefix and storage prefix (which both
+		// are hashed with `Twox128`).
+		let z =
+			Hasher1::max_len::<Key1>() + Hasher2::max_len::<Key2>() + Twox128::max_len::<()>() * 2;
+		z as u32
+	}
+}
+
+impl<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+	crate::storage::generator::StorageDoubleMap<Key1, Key2, Value>
+	for StorageDoubleMap<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher,
+	Hasher2: crate::hash::StorageHasher,
+	Key1: FullCodec,
+	Key2: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	type Query = QueryKind::Query;
+	type Hasher1 = Hasher1;
+	type Hasher2 = Hasher2;
+	fn module_prefix() -> &'static [u8] {
+		Prefix::pallet_prefix().as_bytes()
+	}
+	fn storage_prefix() -> &'static [u8] {
+		Prefix::STORAGE_PREFIX.as_bytes()
+	}
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query {
+		QueryKind::from_optional_value_to_query(v)
+	}
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value> {
+		QueryKind::from_query_to_optional_value(v)
+	}
+}
+
+impl<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+	StoragePrefixedMap<Value>
+	for StorageDoubleMap<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher,
+	Hasher2: crate::hash::StorageHasher,
+	Key1: FullCodec,
+	Key2: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn module_prefix() -> &'static [u8] {
+		<Self as crate::storage::generator::StorageDoubleMap<Key1, Key2, Value>>::module_prefix()
+	}
+	fn storage_prefix() -> &'static [u8] {
+		<Self as crate::storage::generator::StorageDoubleMap<Key1, Key2, Value>>::storage_prefix()
+	}
+}
+
+impl<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+	StorageDoubleMap<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher,
+	Hasher2: crate::hash::StorageHasher,
+	Key1: FullCodec,
+	Key2: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	pub fn hashed_key_for<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Vec<u8>
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::hashed_key_for(k1, k2)
+	}
+
+	/// Does the value (explicitly) exist in storage?
+	pub fn contains_key<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> bool
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::contains_key(k1, k2)
+	}
+
+	/// Load the value associated with the given key from the double map.
+	pub fn get<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> QueryKind::Query
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::get(k1, k2)
+	}
+
+	/// Try to get the value for the given key from the double map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	pub fn try_get<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> Result<Value, ()>
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::try_get(k1, k2)
+	}
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	pub fn set<KArg1: EncodeLike<Key1>, KArg2: EncodeLike<Key2>>(
+		k1: KArg1,
+		k2: KArg2,
+		q: QueryKind::Query,
+	) {
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::set(k1, k2, q)
+	}
+
+	/// Take a value from storage, removing it afterwards.
+	pub fn take<KArg1, KArg2>(k1: KArg1, k2: KArg2) -> QueryKind::Query
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::take(k1, k2)
+	}
+
+	/// Swap the values of two key-pairs.
+	pub fn swap<XKArg1, XKArg2, YKArg1, YKArg2>(
+		x_k1: XKArg1,
+		x_k2: XKArg2,
+		y_k1: YKArg1,
+		y_k2: YKArg2,
+	) where
+		XKArg1: EncodeLike<Key1>,
+		XKArg2: EncodeLike<Key2>,
+		YKArg1: EncodeLike<Key1>,
+		YKArg2: EncodeLike<Key2>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::swap(x_k1, x_k2, y_k1, y_k2)
+	}
+
+	/// Store a value to be associated with the given keys from the double map.
+	pub fn insert<KArg1, KArg2, VArg>(k1: KArg1, k2: KArg2, val: VArg)
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+		VArg: EncodeLike<Value>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::insert(k1, k2, val)
+	}
+
+	/// Remove the value under the given keys.
+	pub fn remove<KArg1, KArg2>(k1: KArg1, k2: KArg2)
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::remove(k1, k2)
+	}
+
+	/// Remove all values under `k1` in the overlay and up to `limit` in the
+	/// backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear_prefix` instead"]
+	pub fn remove_prefix<KArg1>(k1: KArg1, limit: Option<u32>) -> sp_io::KillStorageResult
+	where
+		KArg1: ?Sized + EncodeLike<Key1>,
+	{
+		#[allow(deprecated)]
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::remove_prefix(k1, limit)
+	}
+
+	/// Attempt to remove items from the map matching a `first_key` prefix.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map which match the `first_key`. If so, then the map may not be
+	/// empty when the resultant `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must always be provided through in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map and `first_key`. Subsequent
+	/// calls operating on the same map/`first_key` should always pass `Some`, and this should be
+	/// equal to the previous call result's `maybe_cursor` field.
+	pub fn clear_prefix<KArg1>(
+		first_key: KArg1,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::MultiRemovalResults
+	where
+		KArg1: ?Sized + EncodeLike<Key1>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::clear_prefix(
+			first_key,
+			limit,
+			maybe_cursor,
+		)
+	}
+
+	/// Iterate over values that share the first key.
+	pub fn iter_prefix_values<KArg1>(k1: KArg1) -> crate::storage::PrefixIterator<Value>
+	where
+		KArg1: ?Sized + EncodeLike<Key1>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::iter_prefix_values(k1)
+	}
+
+	/// Mutate the value under the given keys.
+	pub fn mutate<KArg1, KArg2, R, F>(k1: KArg1, k2: KArg2, f: F) -> R
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+		F: FnOnce(&mut QueryKind::Query) -> R,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::mutate(k1, k2, f)
+	}
+
+	/// Mutate the value under the given keys when the closure returns `Ok`.
+	pub fn try_mutate<KArg1, KArg2, R, E, F>(k1: KArg1, k2: KArg2, f: F) -> Result<R, E>
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+		F: FnOnce(&mut QueryKind::Query) -> Result<R, E>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::try_mutate(k1, k2, f)
+	}
+
+	/// Mutate the value under the given keys. Deletes the item if mutated to a `None`.
+	pub fn mutate_exists<KArg1, KArg2, R, F>(k1: KArg1, k2: KArg2, f: F) -> R
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+		F: FnOnce(&mut Option<Value>) -> R,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::mutate_exists(k1, k2, f)
+	}
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	pub fn try_mutate_exists<KArg1, KArg2, R, E, F>(k1: KArg1, k2: KArg2, f: F) -> Result<R, E>
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+		F: FnOnce(&mut Option<Value>) -> Result<R, E>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::try_mutate_exists(k1, k2, f)
+	}
+
+	/// Append the given item to the value in the storage.
+	///
+	/// `Value` is required to implement [`StorageAppend`].
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	pub fn append<Item, EncodeLikeItem, KArg1, KArg2>(k1: KArg1, k2: KArg2, item: EncodeLikeItem)
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageAppend<Item>,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::append(k1, k2, item)
+	}
+
+	/// Read the length of the storage value without decoding the entire value under the
+	/// given `key1` and `key2`.
+	///
+	/// `Value` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	pub fn decode_len<KArg1, KArg2>(key1: KArg1, key2: KArg2) -> Option<usize>
+	where
+		KArg1: EncodeLike<Key1>,
+		KArg2: EncodeLike<Key2>,
+		Value: StorageDecodeLength,
+	{
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::decode_len(key1, key2)
+	}
+
+	/// Migrate an item with the given `key1` and `key2` from defunct `OldHasher1` and
+	/// `OldHasher2` to the current hashers.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	pub fn migrate_keys<
+		OldHasher1: crate::StorageHasher,
+		OldHasher2: crate::StorageHasher,
+		KeyArg1: EncodeLike<Key1>,
+		KeyArg2: EncodeLike<Key2>,
+	>(
+		key1: KeyArg1,
+		key2: KeyArg2,
+	) -> Option<Value> {
+		<Self as crate::storage::StorageDoubleMap<Key1, Key2, Value>>::migrate_keys::<
+			OldHasher1,
+			OldHasher2,
+			_,
+			_,
+		>(key1, key2)
+	}
+
+	/// Remove all values in the overlay and up to `limit` in the backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear` instead"]
+	pub fn remove_all(limit: Option<u32>) -> sp_io::KillStorageResult {
+		#[allow(deprecated)]
+		<Self as crate::storage::StoragePrefixedMap<Value>>::remove_all(limit)
+	}
+
+	/// Attempt to remove all items from the map.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map. If so, then the map may not be empty when the resultant
+	/// `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must always be provided through in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen.A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map. Subsequent calls
+	/// operating on the same map should always pass `Some`, and this should be equal to the
+	/// previous call result's `maybe_cursor` field.
+	pub fn clear(limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::MultiRemovalResults {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::clear(limit, maybe_cursor)
+	}
+
+	/// Iter over all value of the storage.
+	///
+	/// NOTE: If a value failed to decode because storage is corrupted then it is skipped.
+	pub fn iter_values() -> crate::storage::PrefixIterator<Value> {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::iter_values()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade.
+	pub fn translate_values<OldValue: Decode, F: FnMut(OldValue) -> Option<Value>>(f: F) {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::translate_values(f)
+	}
+
+	/// Try and append the given item to the value in the storage.
+	///
+	/// Is only available if `Value` of the storage implements [`StorageTryAppend`].
+	pub fn try_append<KArg1, KArg2, Item, EncodeLikeItem>(
+		key1: KArg1,
+		key2: KArg2,
+		item: EncodeLikeItem,
+	) -> Result<(), ()>
+	where
+		KArg1: EncodeLike<Key1> + Clone,
+		KArg2: EncodeLike<Key2> + Clone,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageTryAppend<Item>,
+	{
+		<Self as crate::storage::TryAppendDoubleMap<Key1, Key2, Value, Item>>::try_append(
+			key1, key2, item,
+		)
+	}
+}
+
+impl<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+	StorageDoubleMap<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher + crate::ReversibleStorageHasher,
+	Hasher2: crate::hash::StorageHasher + crate::ReversibleStorageHasher,
+	Key1: FullCodec,
+	Key2: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Enumerate all elements in the map with first key `k1` in no particular order.
+	///
+	/// If you add or remove values whose first key is `k1` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_prefix(k1: impl EncodeLike<Key1>) -> crate::storage::PrefixIterator<(Key2, Value)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter_prefix(k1)
+	}
+
+	/// Enumerate all elements in the map with first key `k1` after a specified `starting_raw_key`
+	/// in no particular order.
+	///
+	/// If you add or remove values whose first key is `k1` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_prefix_from(
+		k1: impl EncodeLike<Key1>,
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::PrefixIterator<(Key2, Value)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter_prefix_from(
+			k1,
+			starting_raw_key,
+		)
+	}
+
+	/// Enumerate all second keys `k2` in the map with the same first key `k1` in no particular
+	/// order.
+	///
+	/// If you add or remove values whose first key is `k1` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_key_prefix(k1: impl EncodeLike<Key1>) -> crate::storage::KeyPrefixIterator<Key2> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter_key_prefix(k1)
+	}
+
+	/// Enumerate all second keys `k2` in the map with the same first key `k1` after a specified
+	/// `starting_raw_key` in no particular order.
+	///
+	/// If you add or remove values whose first key is `k1` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_key_prefix_from(
+		k1: impl EncodeLike<Key1>,
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::KeyPrefixIterator<Key2> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter_key_prefix_from(
+			k1,
+			starting_raw_key,
+		)
+	}
+
+	/// Remove all elements from the map with first key `k1` and iterate through them in no
+	/// particular order.
+	///
+	/// If you add elements with first key `k1` to the map while doing this, you'll get undefined
+	/// results.
+	pub fn drain_prefix(
+		k1: impl EncodeLike<Key1>,
+	) -> crate::storage::PrefixIterator<(Key2, Value)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::drain_prefix(k1)
+	}
+
+	/// Enumerate all elements in the map in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter() -> crate::storage::PrefixIterator<(Key1, Key2, Value)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter()
+	}
+
+	/// Enumerate all elements in the map after a specified `starting_raw_key` in no particular
+	/// order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_from(
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::PrefixIterator<(Key1, Key2, Value)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter_from(
+			starting_raw_key,
+		)
+	}
+
+	/// Enumerate all keys `k1` and `k2` in the map in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_keys() -> crate::storage::KeyPrefixIterator<(Key1, Key2)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter_keys()
+	}
+
+	/// Enumerate all keys `k1` and `k2` in the map after a specified `starting_raw_key` in no
+	/// particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_keys_from(
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::KeyPrefixIterator<(Key1, Key2)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::iter_keys_from(
+			starting_raw_key,
+		)
+	}
+
+	/// Remove all elements from the map and iterate through them in no particular order.
+	///
+	/// If you add elements to the map while doing this, you'll get undefined results.
+	pub fn drain() -> crate::storage::PrefixIterator<(Key1, Key2, Value)> {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::drain()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	///
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	pub fn translate<O: Decode, F: FnMut(Key1, Key2, O) -> Option<Value>>(f: F) {
+		<Self as crate::storage::IterableStorageDoubleMap<Key1, Key2, Value>>::translate(f)
+	}
+}
+
+impl<Prefix, Hasher1, Hasher2, Key1, Key2, Value, QueryKind, OnEmpty, MaxValues>
+	StorageEntryMetadataBuilder
+	for StorageDoubleMap<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher,
+	Hasher2: crate::hash::StorageHasher,
+	Key1: FullCodec + scale_info::StaticTypeInfo,
+	Key2: FullCodec + scale_info::StaticTypeInfo,
+	Value: FullCodec + scale_info::StaticTypeInfo,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn build_metadata(docs: Vec<&'static str>, entries: &mut Vec<StorageEntryMetadataIR>) {
+		let docs = if cfg!(feature = "no-metadata-docs") { vec![] } else { docs };
+
+		let entry = StorageEntryMetadataIR {
+			name: Prefix::STORAGE_PREFIX,
+			modifier: QueryKind::METADATA,
+			ty: StorageEntryTypeIR::Map {
+				hashers: vec![Hasher1::METADATA, Hasher2::METADATA],
+				key: scale_info::meta_type::<(Key1, Key2)>(),
+				value: scale_info::meta_type::<Value>(),
+			},
+			default: OnEmpty::get().encode(),
+			docs,
+		};
+
+		entries.push(entry);
+	}
+}
+
+impl<Prefix, Hasher1, Hasher2, Key1, Key2, Value, QueryKind, OnEmpty, MaxValues>
+	crate::traits::StorageInfoTrait
+	for StorageDoubleMap<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher,
+	Hasher2: crate::hash::StorageHasher,
+	Key1: FullCodec + MaxEncodedLen,
+	Key2: FullCodec + MaxEncodedLen,
+	Value: FullCodec + MaxEncodedLen,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::final_prefix().to_vec(),
+			max_values: MaxValues::get(),
+			max_size: Some(
+				Hasher1::max_len::<Key1>()
+					.saturating_add(Hasher2::max_len::<Key2>())
+					.saturating_add(Value::max_encoded_len())
+					.saturated_into(),
+			),
+		}]
+	}
+}
+
+/// It doesn't require to implement `MaxEncodedLen` and give no information for `max_size`.
+impl<Prefix, Hasher1, Hasher2, Key1, Key2, Value, QueryKind, OnEmpty, MaxValues>
+	crate::traits::PartialStorageInfoTrait
+	for StorageDoubleMap<Prefix, Hasher1, Key1, Hasher2, Key2, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher1: crate::hash::StorageHasher,
+	Hasher2: crate::hash::StorageHasher,
+	Key1: FullCodec,
+	Key2: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn partial_storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::final_prefix().to_vec(),
+			max_values: MaxValues::get(),
+			max_size: None,
+		}]
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{hash::*, storage::types::ValueQuery};
+	use sp_io::{hashing::twox_128, TestExternalities};
+	use sp_metadata_ir::{StorageEntryModifierIR, StorageEntryTypeIR, StorageHasherIR};
+
+	struct Prefix;
+	impl StorageInstance for Prefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "foo";
+	}
+
+	struct ADefault;
+	impl crate::traits::Get<u32> for ADefault {
+		fn get() -> u32 {
+			97
+		}
+	}
+
+	#[test]
+	fn keylenof_works() {
+		// Works with Blake2_128Concat and Twox64Concat.
+		type A = StorageDoubleMap<Prefix, Blake2_128Concat, u64, Twox64Concat, u32, u32>;
+		let size = 16 * 2 // Two Twox128
+			+ 16 + 8 // Blake2_128Concat = hash + key
+			+ 8 + 4; // Twox64Concat = hash + key
+		assert_eq!(KeyLenOf::<A>::get(), size);
+	}
+
+	#[test]
+	fn test() {
+		type A =
+			StorageDoubleMap<Prefix, Blake2_128Concat, u16, Twox64Concat, u8, u32, OptionQuery>;
+		type AValueQueryWithAnOnEmpty = StorageDoubleMap<
+			Prefix,
+			Blake2_128Concat,
+			u16,
+			Twox64Concat,
+			u8,
+			u32,
+			ValueQuery,
+			ADefault,
+		>;
+		type B = StorageDoubleMap<Prefix, Blake2_256, u16, Twox128, u8, u32, ValueQuery>;
+		type C = StorageDoubleMap<Prefix, Blake2_128Concat, u16, Twox64Concat, u8, u8, ValueQuery>;
+		type WithLen = StorageDoubleMap<Prefix, Blake2_128Concat, u16, Twox64Concat, u8, Vec<u32>>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"foo"));
+			k.extend(&3u16.blake2_128_concat());
+			k.extend(&30u8.twox_64_concat());
+			assert_eq!(A::hashed_key_for(3, 30).to_vec(), k);
+
+			assert_eq!(A::contains_key(3, 30), false);
+			assert_eq!(A::get(3, 30), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get(3, 30), 97);
+
+			A::insert(3, 30, 10);
+			assert_eq!(A::contains_key(3, 30), true);
+			assert_eq!(A::get(3, 30), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get(3, 30), 10);
+
+			A::swap(3, 30, 2, 20);
+			assert_eq!(A::contains_key(3, 30), false);
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(3, 30), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get(3, 30), 97);
+			assert_eq!(A::get(2, 20), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get(2, 20), 10);
+
+			A::remove(2, 20);
+			assert_eq!(A::contains_key(2, 20), false);
+			assert_eq!(A::get(2, 20), None);
+
+			AValueQueryWithAnOnEmpty::mutate(2, 20, |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate(2, 20, |v| *v = *v * 2);
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(97 * 4));
+
+			A::remove(2, 20);
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate(2, 20, |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate(2, 20, |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(97 * 4));
+
+			A::remove(2, 20);
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate(2, 20, |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key(2, 20), false);
+
+			A::remove(2, 20);
+			AValueQueryWithAnOnEmpty::mutate_exists(2, 20, |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(10));
+			AValueQueryWithAnOnEmpty::mutate_exists(2, 20, |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(100));
+
+			A::remove(2, 20);
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists(2, 20, |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(10));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists(2, 20, |v| {
+				*v = Some(v.unwrap() * 10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(100));
+			assert_eq!(A::try_get(2, 20), Ok(100));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists(2, 20, |v| {
+				*v = Some(v.unwrap() * 10);
+				Err(())
+			});
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(100));
+
+			A::insert(2, 20, 10);
+			assert_eq!(A::take(2, 20), Some(10));
+			assert_eq!(A::contains_key(2, 20), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take(2, 20), 97);
+			assert_eq!(A::contains_key(2, 20), false);
+			assert_eq!(A::try_get(2, 20), Err(()));
+
+			B::insert(2, 20, 10);
+			assert_eq!(A::migrate_keys::<Blake2_256, Twox128, _, _>(2, 20), Some(10));
+			assert_eq!(A::contains_key(2, 20), true);
+			assert_eq!(A::get(2, 20), Some(10));
+
+			A::insert(3, 30, 10);
+			A::insert(4, 40, 10);
+			let _ = A::clear(u32::max_value(), None);
+			assert_eq!(A::contains_key(3, 30), false);
+			assert_eq!(A::contains_key(4, 40), false);
+
+			A::insert(3, 30, 10);
+			A::insert(4, 40, 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+
+			C::insert(3, 30, 10);
+			C::insert(4, 40, 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 40, 20), (3, 30, 20)]);
+
+			A::insert(3, 30, 10);
+			A::insert(4, 40, 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 40, 10), (3, 30, 10)]);
+			assert_eq!(A::drain().collect::<Vec<_>>(), vec![(4, 40, 10), (3, 30, 10)]);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+
+			C::insert(3, 30, 10);
+			C::insert(4, 40, 10);
+			A::translate::<u8, _>(|k1, k2, v| Some((k1 * k2 as u16 * v as u16).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 40, 1600), (3, 30, 900)]);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u8)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u8)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 97u32.encode(),
+						docs: vec![],
+					}
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len(3, 30), None);
+			WithLen::append(0, 100, 10);
+			assert_eq!(WithLen::decode_len(0, 100), Some(1));
+
+			A::insert(3, 30, 11);
+			A::insert(3, 31, 12);
+			A::insert(4, 40, 13);
+			A::insert(4, 41, 14);
+			assert_eq!(A::iter_prefix_values(3).collect::<Vec<_>>(), vec![12, 11]);
+			assert_eq!(A::iter_prefix(3).collect::<Vec<_>>(), vec![(31, 12), (30, 11)]);
+			assert_eq!(A::iter_prefix_values(4).collect::<Vec<_>>(), vec![13, 14]);
+			assert_eq!(A::iter_prefix(4).collect::<Vec<_>>(), vec![(40, 13), (41, 14)]);
+
+			let _ = A::clear_prefix(3, u32::max_value(), None);
+			assert_eq!(A::iter_prefix(3).collect::<Vec<_>>(), vec![]);
+			assert_eq!(A::iter_prefix(4).collect::<Vec<_>>(), vec![(40, 13), (41, 14)]);
+
+			assert_eq!(A::drain_prefix(4).collect::<Vec<_>>(), vec![(40, 13), (41, 14)]);
+			assert_eq!(A::iter_prefix(4).collect::<Vec<_>>(), vec![]);
+			assert_eq!(A::drain_prefix(4).collect::<Vec<_>>(), vec![]);
+		})
+	}
+}
diff --git a/substrate/frame/support/src/storage/types/key.rs b/substrate/frame/support/src/storage/types/key.rs
new file mode 100755
index 0000000000000000000000000000000000000000..90cf09dd1d341eefc9280c3a086ff6c311248141
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/key.rs
@@ -0,0 +1,282 @@
+// 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.
+
+//! Storage key type.
+
+use crate::hash::{ReversibleStorageHasher, StorageHasher};
+use codec::{Encode, EncodeLike, FullCodec, MaxEncodedLen};
+use paste::paste;
+use scale_info::StaticTypeInfo;
+use sp_std::prelude::*;
+
+/// A type used exclusively by storage maps as their key type.
+///
+/// The final key generated has the following form:
+/// ```nocompile
+/// Hasher1(encode(key1))
+///     ++ Hasher2(encode(key2))
+///     ++ ...
+///     ++ HasherN(encode(keyN))
+/// ```
+pub struct Key<Hasher, KeyType>(core::marker::PhantomData<(Hasher, KeyType)>);
+
+/// A trait that contains the current key as an associated type.
+pub trait KeyGenerator {
+	type Key: EncodeLike<Self::Key> + StaticTypeInfo;
+	type KArg: Encode + EncodeLike<Self::KArg>;
+	type HashFn: FnOnce(&[u8]) -> Vec<u8>;
+	type HArg;
+
+	const HASHER_METADATA: &'static [sp_metadata_ir::StorageHasherIR];
+
+	/// Given a `key` tuple, calculate the final key by encoding each element individually and
+	/// hashing them using the corresponding hasher in the `KeyGenerator`.
+	fn final_key<KArg: EncodeLikeTuple<Self::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8>;
+	/// Given a `key` tuple, migrate the keys from using the old hashers as given by `hash_fns`
+	/// to using the newer hashers as specified by this `KeyGenerator`.
+	fn migrate_key<KArg: EncodeLikeTuple<Self::KArg> + TupleToEncodedIter>(
+		key: &KArg,
+		hash_fns: Self::HArg,
+	) -> Vec<u8>;
+}
+
+/// The maximum length used by the key in storage.
+pub trait KeyGeneratorMaxEncodedLen: KeyGenerator {
+	fn key_max_encoded_len() -> usize;
+}
+
+/// A trait containing methods that are only implemented on the Key struct instead of the entire
+/// tuple.
+pub trait KeyGeneratorInner: KeyGenerator {
+	type Hasher: StorageHasher;
+
+	/// Hash a given `encoded` byte slice using the `KeyGenerator`'s associated `StorageHasher`.
+	fn final_hash(encoded: &[u8]) -> Vec<u8>;
+}
+
+impl<H: StorageHasher, K: FullCodec + StaticTypeInfo> KeyGenerator for Key<H, K> {
+	type Key = K;
+	type KArg = (K,);
+	type HashFn = Box<dyn FnOnce(&[u8]) -> Vec<u8>>;
+	type HArg = (Self::HashFn,);
+
+	const HASHER_METADATA: &'static [sp_metadata_ir::StorageHasherIR] = &[H::METADATA];
+
+	fn final_key<KArg: EncodeLikeTuple<Self::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
+		H::hash(&key.to_encoded_iter().next().expect("should have at least one element!"))
+			.as_ref()
+			.to_vec()
+	}
+
+	fn migrate_key<KArg: EncodeLikeTuple<Self::KArg> + TupleToEncodedIter>(
+		key: &KArg,
+		hash_fns: Self::HArg,
+	) -> Vec<u8> {
+		(hash_fns.0)(&key.to_encoded_iter().next().expect("should have at least one element!"))
+	}
+}
+
+impl<H: StorageHasher, K: FullCodec + MaxEncodedLen + StaticTypeInfo> KeyGeneratorMaxEncodedLen
+	for Key<H, K>
+{
+	fn key_max_encoded_len() -> usize {
+		H::max_len::<K>()
+	}
+}
+
+impl<H: StorageHasher, K: FullCodec + StaticTypeInfo> KeyGeneratorInner for Key<H, K> {
+	type Hasher = H;
+
+	fn final_hash(encoded: &[u8]) -> Vec<u8> {
+		H::hash(encoded).as_ref().to_vec()
+	}
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(1, 18)]
+#[tuple_types_custom_trait_bound(KeyGeneratorInner)]
+impl KeyGenerator for Tuple {
+	for_tuples!( type Key = ( #(Tuple::Key),* ); );
+	for_tuples!( type KArg = ( #(Tuple::Key),* ); );
+	for_tuples!( type HArg = ( #(Tuple::HashFn),* ); );
+	type HashFn = Box<dyn FnOnce(&[u8]) -> Vec<u8>>;
+
+	const HASHER_METADATA: &'static [sp_metadata_ir::StorageHasherIR] =
+		&[for_tuples!( #(Tuple::Hasher::METADATA),* )];
+
+	fn final_key<KArg: EncodeLikeTuple<Self::KArg> + TupleToEncodedIter>(key: KArg) -> Vec<u8> {
+		let mut final_key = Vec::new();
+		let mut iter = key.to_encoded_iter();
+		for_tuples!(
+			#(
+				let next_encoded = iter.next().expect("KArg number should be equal to Key number");
+				final_key.extend_from_slice(&Tuple::final_hash(&next_encoded));
+			)*
+		);
+		final_key
+	}
+
+	fn migrate_key<KArg: EncodeLikeTuple<Self::KArg> + TupleToEncodedIter>(
+		key: &KArg,
+		hash_fns: Self::HArg,
+	) -> Vec<u8> {
+		let mut migrated_key = Vec::new();
+		let mut iter = key.to_encoded_iter();
+		for_tuples!(
+			#(
+				let next_encoded = iter.next().expect("KArg number should be equal to Key number");
+				migrated_key.extend_from_slice(&(hash_fns.Tuple)(&next_encoded));
+			)*
+		);
+		migrated_key
+	}
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(1, 18)]
+#[tuple_types_custom_trait_bound(KeyGeneratorInner + KeyGeneratorMaxEncodedLen)]
+impl KeyGeneratorMaxEncodedLen for Tuple {
+	fn key_max_encoded_len() -> usize {
+		let mut len = 0usize;
+		for_tuples!(
+			#(
+				len = len.saturating_add(Tuple::key_max_encoded_len());
+			)*
+		);
+		len
+	}
+}
+
+/// Marker trait to indicate that each element in the tuple encodes like the corresponding element
+/// in another tuple.
+///
+/// This trait is sealed.
+pub trait EncodeLikeTuple<T>: crate::storage::private::Sealed {}
+
+macro_rules! impl_encode_like_tuples {
+	($($elem:ident),+) => {
+		paste! {
+			impl<$($elem: Encode,)+ $([<$elem $elem>]: Encode + EncodeLike<$elem>,)+>
+				EncodeLikeTuple<($($elem,)+)> for
+				($([<$elem $elem>],)+) {}
+			impl<$($elem: Encode,)+ $([<$elem $elem>]: Encode + EncodeLike<$elem>,)+>
+				EncodeLikeTuple<($($elem,)+)> for
+				&($([<$elem $elem>],)+) {}
+		}
+	};
+}
+
+impl_encode_like_tuples!(A);
+impl_encode_like_tuples!(A, B);
+impl_encode_like_tuples!(A, B, C);
+impl_encode_like_tuples!(A, B, C, D);
+impl_encode_like_tuples!(A, B, C, D, E);
+impl_encode_like_tuples!(A, B, C, D, E, F);
+impl_encode_like_tuples!(A, B, C, D, E, F, G);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J, K);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J, K, L);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, O);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, O, P);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, O, P, Q);
+impl_encode_like_tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, O, P, Q, R);
+
+impl<'a, T: EncodeLike<U> + EncodeLikeTuple<U>, U: Encode> EncodeLikeTuple<U>
+	for codec::Ref<'a, T, U>
+{
+}
+
+/// Trait to indicate that a tuple can be converted into an iterator of a vector of encoded bytes.
+pub trait TupleToEncodedIter {
+	fn to_encoded_iter(&self) -> sp_std::vec::IntoIter<Vec<u8>>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(1, 18)]
+#[tuple_types_custom_trait_bound(Encode)]
+impl TupleToEncodedIter for Tuple {
+	fn to_encoded_iter(&self) -> sp_std::vec::IntoIter<Vec<u8>> {
+		[for_tuples!( #(self.Tuple.encode()),* )].to_vec().into_iter()
+	}
+}
+
+impl<T: TupleToEncodedIter> TupleToEncodedIter for &T {
+	fn to_encoded_iter(&self) -> sp_std::vec::IntoIter<Vec<u8>> {
+		(*self).to_encoded_iter()
+	}
+}
+
+impl<'a, T: EncodeLike<U> + TupleToEncodedIter, U: Encode> TupleToEncodedIter
+	for codec::Ref<'a, T, U>
+{
+	fn to_encoded_iter(&self) -> sp_std::vec::IntoIter<Vec<u8>> {
+		use core::ops::Deref as _;
+		self.deref().to_encoded_iter()
+	}
+}
+
+/// A trait that indicates the hashers for the keys generated are all reversible.
+pub trait ReversibleKeyGenerator: KeyGenerator {
+	type ReversibleHasher;
+	fn decode_final_key(key_material: &[u8]) -> Result<(Self::Key, &[u8]), codec::Error>;
+}
+
+impl<H: ReversibleStorageHasher, K: FullCodec + StaticTypeInfo> ReversibleKeyGenerator
+	for Key<H, K>
+{
+	type ReversibleHasher = H;
+
+	fn decode_final_key(key_material: &[u8]) -> Result<(Self::Key, &[u8]), codec::Error> {
+		let mut current_key_material = Self::ReversibleHasher::reverse(key_material);
+		let key = K::decode(&mut current_key_material)?;
+		Ok((key, current_key_material))
+	}
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(2, 18)]
+#[tuple_types_custom_trait_bound(ReversibleKeyGenerator + KeyGeneratorInner)]
+impl ReversibleKeyGenerator for Tuple {
+	for_tuples!( type ReversibleHasher = ( #(Tuple::ReversibleHasher),* ); );
+
+	fn decode_final_key(key_material: &[u8]) -> Result<(Self::Key, &[u8]), codec::Error> {
+		let mut current_key_material = key_material;
+		Ok((
+			(for_tuples! {
+				#({
+					let (key, material) = Tuple::decode_final_key(current_key_material)?;
+					current_key_material = material;
+					key
+				}),*
+			}),
+			current_key_material,
+		))
+	}
+}
+
+/// Trait indicating whether a KeyGenerator has the prefix P.
+pub trait HasKeyPrefix<P>: KeyGenerator {
+	type Suffix;
+
+	fn partial_key(prefix: P) -> Vec<u8>;
+}
+
+/// Trait indicating whether a ReversibleKeyGenerator has the prefix P.
+pub trait HasReversibleKeyPrefix<P>: ReversibleKeyGenerator + HasKeyPrefix<P> {
+	fn decode_partial_key(key_material: &[u8]) -> Result<Self::Suffix, codec::Error>;
+}
+
+frame_support_procedural::impl_key_prefix_for_tuples!();
diff --git a/substrate/frame/support/src/storage/types/map.rs b/substrate/frame/support/src/storage/types/map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..816b90162f644b88b620b218bef36e6ff952c051
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/map.rs
@@ -0,0 +1,777 @@
+// 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.
+
+//! Storage map type. Implements StorageMap, StorageIterableMap, StoragePrefixedMap traits and their
+//! methods directly.
+
+use crate::{
+	storage::{
+		types::{OptionQuery, QueryKindTrait, StorageEntryMetadataBuilder},
+		KeyLenOf, StorageAppend, StorageDecodeLength, StoragePrefixedMap, StorageTryAppend,
+	},
+	traits::{Get, GetDefault, StorageInfo, StorageInstance},
+	StorageHasher, Twox128,
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};
+use sp_arithmetic::traits::SaturatedConversion;
+use sp_metadata_ir::{StorageEntryMetadataIR, StorageEntryTypeIR};
+use sp_std::prelude::*;
+
+/// A type that allow to store value for given key. Allowing to insert/remove/iterate on values.
+///
+/// Each value is stored at:
+/// ```nocompile
+/// Twox128(Prefix::pallet_prefix())
+/// 		++ Twox128(Prefix::STORAGE_PREFIX)
+/// 		++ Hasher1(encode(key))
+/// ```
+///
+/// # Warning
+///
+/// If the keys are not trusted (e.g. can be set by a user), a cryptographic `hasher` such as
+/// `blake2_128_concat` must be used.  Otherwise, other values in storage can be compromised.
+pub struct StorageMap<
+	Prefix,
+	Hasher,
+	Key,
+	Value,
+	QueryKind = OptionQuery,
+	OnEmpty = GetDefault,
+	MaxValues = GetDefault,
+>(core::marker::PhantomData<(Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues)>);
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues> Get<u32>
+	for KeyLenOf<StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec + MaxEncodedLen,
+{
+	fn get() -> u32 {
+		// The `max_len` of the key hash plus the pallet prefix and storage prefix (which both are
+		// hashed with `Twox128`).
+		let z = Hasher::max_len::<Key>() + Twox128::max_len::<()>() * 2;
+		z as u32
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+	crate::storage::generator::StorageMap<Key, Value>
+	for StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	type Query = QueryKind::Query;
+	type Hasher = Hasher;
+	fn module_prefix() -> &'static [u8] {
+		Prefix::pallet_prefix().as_bytes()
+	}
+	fn storage_prefix() -> &'static [u8] {
+		Prefix::STORAGE_PREFIX.as_bytes()
+	}
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query {
+		QueryKind::from_optional_value_to_query(v)
+	}
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value> {
+		QueryKind::from_query_to_optional_value(v)
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues> StoragePrefixedMap<Value>
+	for StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn module_prefix() -> &'static [u8] {
+		<Self as crate::storage::generator::StorageMap<Key, Value>>::module_prefix()
+	}
+	fn storage_prefix() -> &'static [u8] {
+		<Self as crate::storage::generator::StorageMap<Key, Value>>::storage_prefix()
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+	StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	pub fn hashed_key_for<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Vec<u8> {
+		<Self as crate::storage::StorageMap<Key, Value>>::hashed_key_for(key)
+	}
+
+	/// Does the value (explicitly) exist in storage?
+	pub fn contains_key<KeyArg: EncodeLike<Key>>(key: KeyArg) -> bool {
+		<Self as crate::storage::StorageMap<Key, Value>>::contains_key(key)
+	}
+
+	/// Load the value associated with the given key from the map.
+	pub fn get<KeyArg: EncodeLike<Key>>(key: KeyArg) -> QueryKind::Query {
+		<Self as crate::storage::StorageMap<Key, Value>>::get(key)
+	}
+
+	/// Try to get the value for the given key from the map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	pub fn try_get<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Result<Value, ()> {
+		<Self as crate::storage::StorageMap<Key, Value>>::try_get(key)
+	}
+
+	/// Swap the values of two keys.
+	pub fn swap<KeyArg1: EncodeLike<Key>, KeyArg2: EncodeLike<Key>>(key1: KeyArg1, key2: KeyArg2) {
+		<Self as crate::storage::StorageMap<Key, Value>>::swap(key1, key2)
+	}
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	pub fn set<KeyArg: EncodeLike<Key>>(key: KeyArg, q: QueryKind::Query) {
+		<Self as crate::storage::StorageMap<Key, Value>>::set(key, q)
+	}
+
+	/// Store a value to be associated with the given key from the map.
+	pub fn insert<KeyArg: EncodeLike<Key>, ValArg: EncodeLike<Value>>(key: KeyArg, val: ValArg) {
+		<Self as crate::storage::StorageMap<Key, Value>>::insert(key, val)
+	}
+
+	/// Remove the value under a key.
+	pub fn remove<KeyArg: EncodeLike<Key>>(key: KeyArg) {
+		<Self as crate::storage::StorageMap<Key, Value>>::remove(key)
+	}
+
+	/// Mutate the value under a key.
+	pub fn mutate<KeyArg: EncodeLike<Key>, R, F: FnOnce(&mut QueryKind::Query) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		<Self as crate::storage::StorageMap<Key, Value>>::mutate(key, f)
+	}
+
+	/// Mutate the item, only if an `Ok` value is returned.
+	pub fn try_mutate<KeyArg, R, E, F>(key: KeyArg, f: F) -> Result<R, E>
+	where
+		KeyArg: EncodeLike<Key>,
+		F: FnOnce(&mut QueryKind::Query) -> Result<R, E>,
+	{
+		<Self as crate::storage::StorageMap<Key, Value>>::try_mutate(key, f)
+	}
+
+	/// Mutate the value under a key iff it exists. Do nothing and return the default value if not.
+	pub fn mutate_extant<KeyArg: EncodeLike<Key>, R: Default, F: FnOnce(&mut Value) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		<Self as crate::storage::StorageMap<Key, Value>>::mutate_extant(key, f)
+	}
+
+	/// Mutate the value under a key. Deletes the item if mutated to a `None`.
+	pub fn mutate_exists<KeyArg: EncodeLike<Key>, R, F: FnOnce(&mut Option<Value>) -> R>(
+		key: KeyArg,
+		f: F,
+	) -> R {
+		<Self as crate::storage::StorageMap<Key, Value>>::mutate_exists(key, f)
+	}
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	pub fn try_mutate_exists<KeyArg, R, E, F>(key: KeyArg, f: F) -> Result<R, E>
+	where
+		KeyArg: EncodeLike<Key>,
+		F: FnOnce(&mut Option<Value>) -> Result<R, E>,
+	{
+		<Self as crate::storage::StorageMap<Key, Value>>::try_mutate_exists(key, f)
+	}
+
+	/// Take the value under a key.
+	pub fn take<KeyArg: EncodeLike<Key>>(key: KeyArg) -> QueryKind::Query {
+		<Self as crate::storage::StorageMap<Key, Value>>::take(key)
+	}
+
+	/// Append the given items to the value in the storage.
+	///
+	/// `Value` is required to implement `codec::EncodeAppend`.
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	pub fn append<Item, EncodeLikeItem, EncodeLikeKey>(key: EncodeLikeKey, item: EncodeLikeItem)
+	where
+		EncodeLikeKey: EncodeLike<Key>,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageAppend<Item>,
+	{
+		<Self as crate::storage::StorageMap<Key, Value>>::append(key, item)
+	}
+
+	/// Read the length of the storage value without decoding the entire value under the
+	/// given `key`.
+	///
+	/// `Value` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	pub fn decode_len<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Option<usize>
+	where
+		Value: StorageDecodeLength,
+	{
+		<Self as crate::storage::StorageMap<Key, Value>>::decode_len(key)
+	}
+
+	/// Migrate an item with the given `key` from a defunct `OldHasher` to the current hasher.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	pub fn migrate_key<OldHasher: crate::hash::StorageHasher, KeyArg: EncodeLike<Key>>(
+		key: KeyArg,
+	) -> Option<Value> {
+		<Self as crate::storage::StorageMap<Key, Value>>::migrate_key::<OldHasher, _>(key)
+	}
+
+	/// Remove all values of the storage in the overlay and up to `limit` in the backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear` instead"]
+	pub fn remove_all(limit: Option<u32>) -> sp_io::KillStorageResult {
+		#[allow(deprecated)]
+		<Self as crate::storage::StoragePrefixedMap<Value>>::remove_all(limit)
+	}
+
+	/// Attempt to remove all items from the map.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map. If so, then the map may not be empty when the resultant
+	/// `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must always be provided through in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map. Subsequent calls
+	/// operating on the same map should always pass `Some`, and this should be equal to the
+	/// previous call result's `maybe_cursor` field.
+	pub fn clear(limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::MultiRemovalResults {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::clear(limit, maybe_cursor)
+	}
+
+	/// Iter over all value of the storage.
+	///
+	/// NOTE: If a value failed to decode because storage is corrupted then it is skipped.
+	pub fn iter_values() -> crate::storage::PrefixIterator<Value> {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::iter_values()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	///
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade.
+	pub fn translate_values<OldValue: Decode, F: FnMut(OldValue) -> Option<Value>>(f: F) {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::translate_values(f)
+	}
+
+	/// Try and append the given item to the value in the storage.
+	///
+	/// Is only available if `Value` of the storage implements [`StorageTryAppend`].
+	pub fn try_append<KArg, Item, EncodeLikeItem>(key: KArg, item: EncodeLikeItem) -> Result<(), ()>
+	where
+		KArg: EncodeLike<Key> + Clone,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageTryAppend<Item>,
+	{
+		<Self as crate::storage::TryAppendMap<Key, Value, Item>>::try_append(key, item)
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+	StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher + crate::ReversibleStorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Enumerate all elements in the map in no particular order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter() -> crate::storage::PrefixIterator<(Key, Value)> {
+		<Self as crate::storage::IterableStorageMap<Key, Value>>::iter()
+	}
+
+	/// Enumerate all elements in the map after a specified `starting_raw_key` in no
+	/// particular order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_from(starting_raw_key: Vec<u8>) -> crate::storage::PrefixIterator<(Key, Value)> {
+		<Self as crate::storage::IterableStorageMap<Key, Value>>::iter_from(starting_raw_key)
+	}
+
+	/// Enumerate all elements in the map after a specified `starting_key` in no
+	/// particular order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_from_key(
+		starting_key: impl EncodeLike<Key>,
+	) -> crate::storage::PrefixIterator<(Key, Value)> {
+		Self::iter_from(Self::hashed_key_for(starting_key))
+	}
+
+	/// Enumerate all keys in the map in no particular order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_keys() -> crate::storage::KeyPrefixIterator<Key> {
+		<Self as crate::storage::IterableStorageMap<Key, Value>>::iter_keys()
+	}
+
+	/// Enumerate all keys in the map after a specified `starting_raw_key` in no particular
+	/// order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_keys_from(starting_raw_key: Vec<u8>) -> crate::storage::KeyPrefixIterator<Key> {
+		<Self as crate::storage::IterableStorageMap<Key, Value>>::iter_keys_from(starting_raw_key)
+	}
+
+	/// Enumerate all keys in the map after a specified `starting_key` in no particular
+	/// order.
+	///
+	/// If you alter the map while doing this, you'll get undefined results.
+	pub fn iter_keys_from_key(
+		starting_key: impl EncodeLike<Key>,
+	) -> crate::storage::KeyPrefixIterator<Key> {
+		Self::iter_keys_from(Self::hashed_key_for(starting_key))
+	}
+
+	/// Remove all elements from the map and iterate through them in no particular order.
+	///
+	/// If you add elements to the map while doing this, you'll get undefined results.
+	pub fn drain() -> crate::storage::PrefixIterator<(Key, Value)> {
+		<Self as crate::storage::IterableStorageMap<Key, Value>>::drain()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	///
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	pub fn translate<O: Decode, F: FnMut(Key, O) -> Option<Value>>(f: F) {
+		<Self as crate::storage::IterableStorageMap<Key, Value>>::translate(f)
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues> StorageEntryMetadataBuilder
+	for StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec + scale_info::StaticTypeInfo,
+	Value: FullCodec + scale_info::StaticTypeInfo,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn build_metadata(docs: Vec<&'static str>, entries: &mut Vec<StorageEntryMetadataIR>) {
+		let docs = if cfg!(feature = "no-metadata-docs") { vec![] } else { docs };
+
+		let entry = StorageEntryMetadataIR {
+			name: Prefix::STORAGE_PREFIX,
+			modifier: QueryKind::METADATA,
+			ty: StorageEntryTypeIR::Map {
+				hashers: vec![Hasher::METADATA],
+				key: scale_info::meta_type::<Key>(),
+				value: scale_info::meta_type::<Value>(),
+			},
+			default: OnEmpty::get().encode(),
+			docs,
+		};
+
+		entries.push(entry);
+	}
+}
+
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues> crate::traits::StorageInfoTrait
+	for StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec + MaxEncodedLen,
+	Value: FullCodec + MaxEncodedLen,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::final_prefix().to_vec(),
+			max_values: MaxValues::get(),
+			max_size: Some(
+				Hasher::max_len::<Key>()
+					.saturating_add(Value::max_encoded_len())
+					.saturated_into(),
+			),
+		}]
+	}
+}
+
+/// It doesn't require to implement `MaxEncodedLen` and give no information for `max_size`.
+impl<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+	crate::traits::PartialStorageInfoTrait
+	for StorageMap<Prefix, Hasher, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Hasher: crate::hash::StorageHasher,
+	Key: FullCodec,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn partial_storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::final_prefix().to_vec(),
+			max_values: MaxValues::get(),
+			max_size: None,
+		}]
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{
+		hash::*,
+		storage::{types::ValueQuery, IterableStorageMap},
+	};
+	use sp_io::{hashing::twox_128, TestExternalities};
+	use sp_metadata_ir::{StorageEntryModifierIR, StorageEntryTypeIR, StorageHasherIR};
+
+	struct Prefix;
+	impl StorageInstance for Prefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "foo";
+	}
+
+	struct ADefault;
+	impl crate::traits::Get<u32> for ADefault {
+		fn get() -> u32 {
+			97
+		}
+	}
+
+	#[test]
+	fn keylenof_works() {
+		// Works with Blake2_128Concat.
+		type A = StorageMap<Prefix, Blake2_128Concat, u32, u32>;
+		let size = 16 * 2 // Two Twox128
+			+ 16 + 4; // Blake2_128Concat = hash + key
+		assert_eq!(KeyLenOf::<A>::get(), size);
+
+		// Works with Blake2_256.
+		type B = StorageMap<Prefix, Blake2_256, u32, u32>;
+		let size = 16 * 2 // Two Twox128
+			+ 32; // Blake2_256
+		assert_eq!(KeyLenOf::<B>::get(), size);
+
+		// Works with Twox64Concat.
+		type C = StorageMap<Prefix, Twox64Concat, u32, u32>;
+		let size = 16 * 2 // Two Twox128
+			+ 8 + 4; // Twox64Concat = hash + key
+		assert_eq!(KeyLenOf::<C>::get(), size);
+	}
+
+	#[test]
+	fn test() {
+		type A = StorageMap<Prefix, Blake2_128Concat, u16, u32, OptionQuery>;
+		type AValueQueryWithAnOnEmpty =
+			StorageMap<Prefix, Blake2_128Concat, u16, u32, ValueQuery, ADefault>;
+		type B = StorageMap<Prefix, Blake2_256, u16, u32, ValueQuery>;
+		type C = StorageMap<Prefix, Blake2_128Concat, u16, u8, ValueQuery>;
+		type WithLen = StorageMap<Prefix, Blake2_128Concat, u16, Vec<u32>>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"foo"));
+			k.extend(&3u16.blake2_128_concat());
+			assert_eq!(A::hashed_key_for(3).to_vec(), k);
+
+			assert_eq!(A::contains_key(3), false);
+			assert_eq!(A::get(3), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get(3), 97);
+
+			A::insert(3, 10);
+			assert_eq!(A::contains_key(3), true);
+			assert_eq!(A::get(3), Some(10));
+			assert_eq!(A::try_get(3), Ok(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get(3), 10);
+
+			A::swap(3, 2);
+			assert_eq!(A::contains_key(3), false);
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(3), None);
+			assert_eq!(A::try_get(3), Err(()));
+			assert_eq!(AValueQueryWithAnOnEmpty::get(3), 97);
+			assert_eq!(A::get(2), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get(2), 10);
+
+			A::remove(2);
+			assert_eq!(A::contains_key(2), false);
+			assert_eq!(A::get(2), None);
+
+			AValueQueryWithAnOnEmpty::mutate(2, |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate(2, |v| *v = *v * 2);
+			assert_eq!(AValueQueryWithAnOnEmpty::contains_key(2), true);
+			assert_eq!(AValueQueryWithAnOnEmpty::get(2), 97 * 4);
+
+			A::remove(2);
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate(2, |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate(2, |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(2), Some(97 * 4));
+
+			A::remove(2);
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate(2, |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key(2), false);
+
+			A::remove(2);
+			AValueQueryWithAnOnEmpty::mutate_exists(2, |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(2), Some(10));
+			AValueQueryWithAnOnEmpty::mutate_exists(2, |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(2), Some(100));
+
+			A::remove(2);
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists(2, |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(2), Some(10));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists(2, |v| {
+				*v = Some(v.unwrap() * 10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(2), Some(100));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists(2, |v| {
+				*v = Some(v.unwrap() * 10);
+				Err(())
+			});
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(2), Some(100));
+
+			A::insert(2, 10);
+			assert_eq!(A::take(2), Some(10));
+			assert_eq!(A::contains_key(2), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take(2), 97);
+			assert_eq!(A::contains_key(2), false);
+
+			// Set non-existing.
+			B::set(30, 100);
+
+			assert_eq!(B::contains_key(30), true);
+			assert_eq!(B::get(30), 100);
+			assert_eq!(B::try_get(30), Ok(100));
+
+			// Set existing.
+			B::set(30, 101);
+
+			assert_eq!(B::contains_key(30), true);
+			assert_eq!(B::get(30), 101);
+			assert_eq!(B::try_get(30), Ok(101));
+
+			// Set non-existing.
+			A::set(30, Some(100));
+
+			assert_eq!(A::contains_key(30), true);
+			assert_eq!(A::get(30), Some(100));
+			assert_eq!(A::try_get(30), Ok(100));
+
+			// Set existing.
+			A::set(30, Some(101));
+
+			assert_eq!(A::contains_key(30), true);
+			assert_eq!(A::get(30), Some(101));
+			assert_eq!(A::try_get(30), Ok(101));
+
+			// Unset existing.
+			A::set(30, None);
+
+			assert_eq!(A::contains_key(30), false);
+			assert_eq!(A::get(30), None);
+			assert_eq!(A::try_get(30), Err(()));
+
+			// Unset non-existing.
+			A::set(31, None);
+
+			assert_eq!(A::contains_key(31), false);
+			assert_eq!(A::get(31), None);
+			assert_eq!(A::try_get(31), Err(()));
+
+			B::insert(2, 10);
+			assert_eq!(A::migrate_key::<Blake2_256, _>(2), Some(10));
+			assert_eq!(A::contains_key(2), true);
+			assert_eq!(A::get(2), Some(10));
+
+			A::insert(3, 10);
+			A::insert(4, 10);
+			let _ = A::clear(u32::max_value(), None);
+			assert_eq!(A::contains_key(3), false);
+			assert_eq!(A::contains_key(4), false);
+
+			A::insert(3, 10);
+			A::insert(4, 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+
+			C::insert(3, 10);
+			C::insert(4, 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 20), (3, 20)]);
+
+			A::insert(3, 10);
+			A::insert(4, 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 10), (3, 10)]);
+			assert_eq!(A::drain().collect::<Vec<_>>(), vec![(4, 10), (3, 10)]);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+
+			C::insert(3, 10);
+			C::insert(4, 10);
+			A::translate::<u8, _>(|k, v| Some((k * v as u16).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 40), (3, 30)]);
+
+			let translate_next = |k: u16, v: u8| Some((v as u16 / k).into());
+			let k = A::translate_next::<u8, _>(None, translate_next);
+			let k = A::translate_next::<u8, _>(k, translate_next);
+			assert_eq!(None, A::translate_next::<u8, _>(k, translate_next));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 10), (3, 10)]);
+
+			let _ = A::translate_next::<u8, _>(None, |_, _| None);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(3, 10)]);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![StorageHasherIR::Blake2_128Concat],
+							key: scale_info::meta_type::<u16>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![StorageHasherIR::Blake2_128Concat],
+							key: scale_info::meta_type::<u16>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 97u32.encode(),
+						docs: vec![],
+					}
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len(3), None);
+			WithLen::append(0, 10);
+			assert_eq!(WithLen::decode_len(0), Some(1));
+		})
+	}
+}
diff --git a/substrate/frame/support/src/storage/types/mod.rs b/substrate/frame/support/src/storage/types/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c7f2557099b36a3b740b6038694401b35838d396
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/mod.rs
@@ -0,0 +1,142 @@
+// 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.
+
+//! Storage types to build abstraction on storage, they implements storage traits such as
+//! StorageMap and others.
+
+use codec::FullCodec;
+use sp_metadata_ir::{StorageEntryMetadataIR, StorageEntryModifierIR};
+use sp_std::prelude::*;
+
+mod counted_map;
+mod counted_nmap;
+mod double_map;
+mod key;
+mod map;
+mod nmap;
+mod value;
+
+pub use counted_map::{CountedStorageMap, CountedStorageMapInstance};
+pub use counted_nmap::{CountedStorageNMap, CountedStorageNMapInstance};
+pub use double_map::StorageDoubleMap;
+pub use key::{
+	EncodeLikeTuple, HasKeyPrefix, HasReversibleKeyPrefix, Key, KeyGenerator,
+	KeyGeneratorMaxEncodedLen, ReversibleKeyGenerator, TupleToEncodedIter,
+};
+pub use map::StorageMap;
+pub use nmap::StorageNMap;
+pub use value::StorageValue;
+
+/// Trait implementing how the storage optional value is converted into the queried type.
+///
+/// It is implemented by:
+/// * `OptionQuery` which converts an optional value to an optional value, used when querying
+///   storage returns an optional value.
+/// * `ResultQuery` which converts an optional value to a result value, used when querying storage
+///   returns a result value.
+/// * `ValueQuery` which converts an optional value to a value, used when querying storage returns a
+///   value.
+pub trait QueryKindTrait<Value, OnEmpty> {
+	/// Metadata for the storage kind.
+	const METADATA: StorageEntryModifierIR;
+
+	/// Type returned on query
+	type Query: FullCodec + 'static;
+
+	/// Convert an optional value (i.e. some if trie contains the value or none otherwise) to the
+	/// query.
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query;
+
+	/// Convert a query to an optional value.
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value>;
+}
+
+/// Implement QueryKindTrait with query being `Option<Value>`
+///
+/// NOTE: it doesn't support a generic `OnEmpty`. This means only `None` can be
+/// returned when no value is found. To use another `OnEmpty` implementation, `ValueQuery` can be
+/// used instead.
+pub struct OptionQuery;
+impl<Value> QueryKindTrait<Value, crate::traits::GetDefault> for OptionQuery
+where
+	Value: FullCodec + 'static,
+{
+	const METADATA: StorageEntryModifierIR = StorageEntryModifierIR::Optional;
+
+	type Query = Option<Value>;
+
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query {
+		// NOTE: OnEmpty is fixed to GetDefault, thus it returns `None` on no value.
+		v
+	}
+
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value> {
+		v
+	}
+}
+
+/// Implement QueryKindTrait with query being `Result<Value, PalletError>`
+pub struct ResultQuery<Error>(sp_std::marker::PhantomData<Error>);
+impl<Value, Error, OnEmpty> QueryKindTrait<Value, OnEmpty> for ResultQuery<Error>
+where
+	Value: FullCodec + 'static,
+	Error: FullCodec + 'static,
+	OnEmpty: crate::traits::Get<Result<Value, Error>>,
+{
+	const METADATA: StorageEntryModifierIR = StorageEntryModifierIR::Optional;
+
+	type Query = Result<Value, Error>;
+
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query {
+		match v {
+			Some(v) => Ok(v),
+			None => OnEmpty::get(),
+		}
+	}
+
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value> {
+		v.ok()
+	}
+}
+
+/// Implement QueryKindTrait with query being `Value`
+pub struct ValueQuery;
+impl<Value, OnEmpty> QueryKindTrait<Value, OnEmpty> for ValueQuery
+where
+	Value: FullCodec + 'static,
+	OnEmpty: crate::traits::Get<Value>,
+{
+	const METADATA: StorageEntryModifierIR = StorageEntryModifierIR::Default;
+
+	type Query = Value;
+
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query {
+		v.unwrap_or_else(|| OnEmpty::get())
+	}
+
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value> {
+		Some(v)
+	}
+}
+
+/// Build the metadata of a storage.
+///
+/// Implemented by each of the storage types: value, map, countedmap, doublemap and nmap.
+pub trait StorageEntryMetadataBuilder {
+	/// Build into `entries` the storage metadata entries of a storage given some `docs`.
+	fn build_metadata(doc: Vec<&'static str>, entries: &mut Vec<StorageEntryMetadataIR>);
+}
diff --git a/substrate/frame/support/src/storage/types/nmap.rs b/substrate/frame/support/src/storage/types/nmap.rs
new file mode 100755
index 0000000000000000000000000000000000000000..e9a4b12dd43a16ea6713ea59a821959bbea20e51
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/nmap.rs
@@ -0,0 +1,1283 @@
+// 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.
+
+//! Storage n-map type. Particularly implements `StorageNMap` and `StoragePrefixedMap`
+//! traits and their methods directly.
+
+use crate::{
+	storage::{
+		types::{
+			EncodeLikeTuple, HasKeyPrefix, HasReversibleKeyPrefix, OptionQuery, QueryKindTrait,
+			StorageEntryMetadataBuilder, TupleToEncodedIter,
+		},
+		KeyGenerator, PrefixIterator, StorageAppend, StorageDecodeLength, StoragePrefixedMap,
+	},
+	traits::{Get, GetDefault, StorageInfo, StorageInstance},
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};
+use sp_metadata_ir::{StorageEntryMetadataIR, StorageEntryTypeIR};
+use sp_runtime::SaturatedConversion;
+use sp_std::prelude::*;
+
+/// A type that allow to store values for an arbitrary number of keys in the form of
+/// `(Key<Hasher1, key1>, Key<Hasher2, key2>, ..., Key<HasherN, keyN>)`.
+///
+/// Each value is stored at:
+/// ```nocompile
+/// Twox128(Prefix::pallet_prefix())
+/// 		++ Twox128(Prefix::STORAGE_PREFIX)
+/// 		++ Hasher1(encode(key1))
+/// 		++ Hasher2(encode(key2))
+/// 	++ ...
+/// 	++ HasherN(encode(keyN))
+/// ```
+///
+/// # Warning
+///
+/// If the keys are not trusted (e.g. can be set by a user), a cryptographic `hasher`
+/// such as `blake2_128_concat` must be used for the key hashers. Otherwise, other values
+/// in storage can be compromised.
+pub struct StorageNMap<
+	Prefix,
+	Key,
+	Value,
+	QueryKind = OptionQuery,
+	OnEmpty = GetDefault,
+	MaxValues = GetDefault,
+>(core::marker::PhantomData<(Prefix, Key, Value, QueryKind, OnEmpty, MaxValues)>);
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+	crate::storage::generator::StorageNMap<Key, Value>
+	for StorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	type Query = QueryKind::Query;
+	fn module_prefix() -> &'static [u8] {
+		Prefix::pallet_prefix().as_bytes()
+	}
+	fn storage_prefix() -> &'static [u8] {
+		Prefix::STORAGE_PREFIX.as_bytes()
+	}
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query {
+		QueryKind::from_optional_value_to_query(v)
+	}
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value> {
+		QueryKind::from_query_to_optional_value(v)
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues> crate::storage::StoragePrefixedMap<Value>
+	for StorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn module_prefix() -> &'static [u8] {
+		<Self as crate::storage::generator::StorageNMap<Key, Value>>::module_prefix()
+	}
+	fn storage_prefix() -> &'static [u8] {
+		<Self as crate::storage::generator::StorageNMap<Key, Value>>::storage_prefix()
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+	StorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Get the storage key used to fetch a value corresponding to a specific key.
+	pub fn hashed_key_for<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> Vec<u8> {
+		<Self as crate::storage::StorageNMap<Key, Value>>::hashed_key_for(key)
+	}
+
+	/// Does the value (explicitly) exist in storage?
+	pub fn contains_key<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(key: KArg) -> bool {
+		<Self as crate::storage::StorageNMap<Key, Value>>::contains_key(key)
+	}
+
+	/// Load the value associated with the given key from the map.
+	pub fn get<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> QueryKind::Query {
+		<Self as crate::storage::StorageNMap<Key, Value>>::get(key)
+	}
+
+	/// Try to get the value for the given key from the map.
+	///
+	/// Returns `Ok` if it exists, `Err` if not.
+	pub fn try_get<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> Result<Value, ()> {
+		<Self as crate::storage::StorageNMap<Key, Value>>::try_get(key)
+	}
+
+	/// Store or remove the value to be associated with `key` so that `get` returns the `query`.
+	pub fn set<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+		query: QueryKind::Query,
+	) {
+		<Self as crate::storage::StorageNMap<Key, Value>>::set(key, query)
+	}
+
+	/// Take a value from storage, removing it afterwards.
+	pub fn take<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> QueryKind::Query {
+		<Self as crate::storage::StorageNMap<Key, Value>>::take(key)
+	}
+
+	/// Swap the values of two key-pairs.
+	pub fn swap<KOther, KArg1, KArg2>(key1: KArg1, key2: KArg2)
+	where
+		KOther: KeyGenerator,
+		KArg1: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		KArg2: EncodeLikeTuple<KOther::KArg> + TupleToEncodedIter,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::swap::<KOther, _, _>(key1, key2)
+	}
+
+	/// Store a value to be associated with the given keys from the map.
+	pub fn insert<KArg, VArg>(key: KArg, val: VArg)
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		VArg: EncodeLike<Value>,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::insert(key, val)
+	}
+
+	/// Remove the value under the given keys.
+	pub fn remove<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(key: KArg) {
+		<Self as crate::storage::StorageNMap<Key, Value>>::remove(key)
+	}
+
+	/// Remove all values starting with `partial_key` in the overlay and up to `limit` in the
+	/// backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear_prefix` instead"]
+	pub fn remove_prefix<KP>(partial_key: KP, limit: Option<u32>) -> sp_io::KillStorageResult
+	where
+		Key: HasKeyPrefix<KP>,
+	{
+		#[allow(deprecated)]
+		<Self as crate::storage::StorageNMap<Key, Value>>::remove_prefix(partial_key, limit)
+	}
+
+	/// Attempt to remove items from the map matching a `partial_key` prefix.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map which match the `partial key`. If so, then the map may not be
+	/// empty when the resultant `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must be provided in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map and `partial_key`. Subsequent
+	/// calls operating on the same map/`partial_key` should always pass `Some`, and this should be
+	/// equal to the previous call result's `maybe_cursor` field.
+	pub fn clear_prefix<KP>(
+		partial_key: KP,
+		limit: u32,
+		maybe_cursor: Option<&[u8]>,
+	) -> sp_io::MultiRemovalResults
+	where
+		Key: HasKeyPrefix<KP>,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::clear_prefix(
+			partial_key,
+			limit,
+			maybe_cursor,
+		)
+	}
+
+	/// Iterate over values that share the first key.
+	pub fn iter_prefix_values<KP>(partial_key: KP) -> PrefixIterator<Value>
+	where
+		Key: HasKeyPrefix<KP>,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::iter_prefix_values(partial_key)
+	}
+
+	/// Mutate the value under the given keys.
+	pub fn mutate<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut QueryKind::Query) -> R,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::mutate(key, f)
+	}
+
+	/// Mutate the value under the given keys when the closure returns `Ok`.
+	pub fn try_mutate<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut QueryKind::Query) -> Result<R, E>,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::try_mutate(key, f)
+	}
+
+	/// Mutate the value under the given keys. Deletes the item if mutated to a `None`.
+	pub fn mutate_exists<KArg, R, F>(key: KArg, f: F) -> R
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<Value>) -> R,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::mutate_exists(key, f)
+	}
+
+	/// Mutate the item, only if an `Ok` value is returned. Deletes the item if mutated to a `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	pub fn try_mutate_exists<KArg, R, E, F>(key: KArg, f: F) -> Result<R, E>
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		F: FnOnce(&mut Option<Value>) -> Result<R, E>,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::try_mutate_exists(key, f)
+	}
+
+	/// Append the given item to the value in the storage.
+	///
+	/// `Value` is required to implement [`StorageAppend`].
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	pub fn append<Item, EncodeLikeItem, KArg>(key: KArg, item: EncodeLikeItem)
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageAppend<Item>,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::append(key, item)
+	}
+
+	/// Read the length of the storage value without decoding the entire value under the
+	/// given `key1` and `key2`.
+	///
+	/// `Value` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	pub fn decode_len<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
+		key: KArg,
+	) -> Option<usize>
+	where
+		Value: StorageDecodeLength,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::decode_len(key)
+	}
+
+	/// Migrate an item with the given `key` from defunct `hash_fns` to the current hashers.
+	///
+	/// If the key doesn't exist, then it's a no-op. If it does, then it returns its value.
+	pub fn migrate_keys<KArg>(key: KArg, hash_fns: Key::HArg) -> Option<Value>
+	where
+		KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter,
+	{
+		<Self as crate::storage::StorageNMap<Key, Value>>::migrate_keys::<_>(key, hash_fns)
+	}
+
+	/// Remove all values in the overlay and up to `limit` in the backend.
+	///
+	/// All values in the client overlay will be deleted, if there is some `limit` then up to
+	/// `limit` values are deleted from the client backend, if `limit` is none then all values in
+	/// the client backend are deleted.
+	///
+	/// # Note
+	///
+	/// Calling this multiple times per block with a `limit` set leads always to the same keys being
+	/// removed and the same result being returned. This happens because the keys to delete in the
+	/// overlay are not taken into account when deleting keys in the backend.
+	#[deprecated = "Use `clear` instead"]
+	pub fn remove_all(limit: Option<u32>) -> sp_io::KillStorageResult {
+		#[allow(deprecated)]
+		<Self as crate::storage::StoragePrefixedMap<Value>>::remove_all(limit).into()
+	}
+
+	/// Attempt to remove all items from the map.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given map, it is important that no further items
+	/// are inserted into the map. If so, then the map may not be empty when the resultant
+	/// `maybe_cursor` is `None`.
+	///
+	/// # Limit
+	///
+	/// A `limit` must always be provided through in order to cap the maximum
+	/// amount of deletions done in a single call. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A `limit` of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given storage map. Subsequent calls
+	/// operating on the same map should always pass `Some`, and this should be equal to the
+	/// previous call result's `maybe_cursor` field.
+	pub fn clear(limit: u32, maybe_cursor: Option<&[u8]>) -> sp_io::MultiRemovalResults {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::clear(limit, maybe_cursor)
+	}
+
+	/// Iter over all value of the storage.
+	///
+	/// NOTE: If a value failed to decode because storage is corrupted then it is skipped.
+	pub fn iter_values() -> crate::storage::PrefixIterator<Value> {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::iter_values()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade.
+	pub fn translate_values<OldValue: Decode, F: FnMut(OldValue) -> Option<Value>>(f: F) {
+		<Self as crate::storage::StoragePrefixedMap<Value>>::translate_values(f)
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+	StorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Key: super::key::ReversibleKeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	/// Enumerate all elements in the map with prefix key `kp` in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_prefix<KP>(
+		kp: KP,
+	) -> crate::storage::PrefixIterator<(<Key as HasKeyPrefix<KP>>::Suffix, Value)>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter_prefix(kp)
+	}
+
+	/// Enumerate all elements in the map with prefix key `kp` after a specified `starting_raw_key`
+	/// in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::PrefixIterator<(<Key as HasKeyPrefix<KP>>::Suffix, Value)>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter_prefix_from(
+			kp,
+			starting_raw_key,
+		)
+	}
+
+	/// Enumerate all suffix keys in the map with prefix key `kp` in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_key_prefix<KP>(
+		kp: KP,
+	) -> crate::storage::KeyPrefixIterator<<Key as HasKeyPrefix<KP>>::Suffix>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter_key_prefix(kp)
+	}
+
+	/// Enumerate all suffix keys in the map with prefix key `kp` after a specified
+	/// `starting_raw_key` in no particular order.
+	///
+	/// If you add or remove values whose prefix key is `kp` to the map while doing this, you'll get
+	/// undefined results.
+	pub fn iter_key_prefix_from<KP>(
+		kp: KP,
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::KeyPrefixIterator<<Key as HasKeyPrefix<KP>>::Suffix>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter_key_prefix_from(
+			kp,
+			starting_raw_key,
+		)
+	}
+
+	/// Remove all elements from the map with prefix key `kp` and iterate through them in no
+	/// particular order.
+	///
+	/// If you add elements with prefix key `k1` to the map while doing this, you'll get undefined
+	/// results.
+	pub fn drain_prefix<KP>(
+		kp: KP,
+	) -> crate::storage::PrefixIterator<(<Key as HasKeyPrefix<KP>>::Suffix, Value)>
+	where
+		Key: HasReversibleKeyPrefix<KP>,
+	{
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::drain_prefix(kp)
+	}
+
+	/// Enumerate all elements in the map in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter() -> crate::storage::PrefixIterator<(Key::Key, Value)> {
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter()
+	}
+
+	/// Enumerate all elements in the map after a specified `starting_key` in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_from(
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::PrefixIterator<(Key::Key, Value)> {
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter_from(starting_raw_key)
+	}
+
+	/// Enumerate all keys in the map in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_keys() -> crate::storage::KeyPrefixIterator<Key::Key> {
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter_keys()
+	}
+
+	/// Enumerate all keys in the map after a specified `starting_raw_key` in no particular order.
+	///
+	/// If you add or remove values to the map while doing this, you'll get undefined results.
+	pub fn iter_keys_from(
+		starting_raw_key: Vec<u8>,
+	) -> crate::storage::KeyPrefixIterator<Key::Key> {
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::iter_keys_from(starting_raw_key)
+	}
+
+	/// Remove all elements from the map and iterate through them in no particular order.
+	///
+	/// If you add elements to the map while doing this, you'll get undefined results.
+	pub fn drain() -> crate::storage::PrefixIterator<(Key::Key, Value)> {
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::drain()
+	}
+
+	/// Translate the values of all elements by a function `f`, in the map in no particular order.
+	///
+	/// By returning `None` from `f` for an element, you'll remove it from the map.
+	///
+	/// NOTE: If a value fail to decode because storage is corrupted then it is skipped.
+	pub fn translate<O: Decode, F: FnMut(Key::Key, O) -> Option<Value>>(f: F) {
+		<Self as crate::storage::IterableStorageNMap<Key, Value>>::translate(f)
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues> StorageEntryMetadataBuilder
+	for StorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec + scale_info::StaticTypeInfo,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn build_metadata(docs: Vec<&'static str>, entries: &mut Vec<StorageEntryMetadataIR>) {
+		let docs = if cfg!(feature = "no-metadata-docs") { vec![] } else { docs };
+
+		let entry = StorageEntryMetadataIR {
+			name: Prefix::STORAGE_PREFIX,
+			modifier: QueryKind::METADATA,
+			ty: StorageEntryTypeIR::Map {
+				key: scale_info::meta_type::<Key::Key>(),
+				hashers: Key::HASHER_METADATA.to_vec(),
+				value: scale_info::meta_type::<Value>(),
+			},
+			default: OnEmpty::get().encode(),
+			docs,
+		};
+
+		entries.push(entry);
+	}
+}
+
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues> crate::traits::StorageInfoTrait
+	for StorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Key: super::key::KeyGenerator + super::key::KeyGeneratorMaxEncodedLen,
+	Value: FullCodec + MaxEncodedLen,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::final_prefix().to_vec(),
+			max_values: MaxValues::get(),
+			max_size: Some(
+				Key::key_max_encoded_len()
+					.saturating_add(Value::max_encoded_len())
+					.saturated_into(),
+			),
+		}]
+	}
+}
+
+/// It doesn't require to implement `MaxEncodedLen` and give no information for `max_size`.
+impl<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues> crate::traits::PartialStorageInfoTrait
+	for StorageNMap<Prefix, Key, Value, QueryKind, OnEmpty, MaxValues>
+where
+	Prefix: StorageInstance,
+	Key: super::key::KeyGenerator,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: Get<QueryKind::Query> + 'static,
+	MaxValues: Get<Option<u32>>,
+{
+	fn partial_storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::final_prefix().to_vec(),
+			max_values: MaxValues::get(),
+			max_size: None,
+		}]
+	}
+}
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{
+		hash::{StorageHasher as _, *},
+		storage::types::{Key as NMapKey, ValueQuery},
+	};
+	use sp_io::{hashing::twox_128, TestExternalities};
+	use sp_metadata_ir::{StorageEntryModifierIR, StorageHasherIR};
+
+	struct Prefix;
+	impl StorageInstance for Prefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "Foo";
+	}
+
+	struct ADefault;
+	impl crate::traits::Get<u32> for ADefault {
+		fn get() -> u32 {
+			98
+		}
+	}
+
+	#[test]
+	fn test_1_key() {
+		type A = StorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, u32, OptionQuery>;
+		type AValueQueryWithAnOnEmpty =
+			StorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, u32, ValueQuery, ADefault>;
+		type B = StorageNMap<Prefix, NMapKey<Blake2_256, u16>, u32, ValueQuery>;
+		type C = StorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, u8, ValueQuery>;
+		type WithLen = StorageNMap<Prefix, NMapKey<Blake2_128Concat, u16>, Vec<u32>>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"Foo"));
+			k.extend(&3u16.blake2_128_concat());
+			assert_eq!(A::hashed_key_for((&3,)).to_vec(), k);
+
+			assert_eq!(A::contains_key((3,)), false);
+			assert_eq!(A::get((3,)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3,)), 98);
+
+			A::insert((3,), 10);
+			assert_eq!(A::contains_key((3,)), true);
+			assert_eq!(A::get((3,)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3,)), 10);
+
+			{
+				#[crate::storage_alias]
+				type Foo = StorageNMap<test, (NMapKey<Blake2_128Concat, u16>), u32>;
+
+				assert_eq!(Foo::contains_key((3,)), true);
+				assert_eq!(Foo::get((3,)), Some(10));
+			}
+
+			A::swap::<NMapKey<Blake2_128Concat, u16>, _, _>((3,), (2,));
+			assert_eq!(A::contains_key((3,)), false);
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((3,)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3,)), 98);
+			assert_eq!(A::get((2,)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((2,)), 10);
+
+			A::remove((2,));
+			assert_eq!(A::contains_key((2,)), false);
+			assert_eq!(A::get((2,)), None);
+
+			AValueQueryWithAnOnEmpty::mutate((2,), |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate((2,), |v| *v = *v * 2);
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(98 * 4));
+
+			A::remove((2,));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2,), |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2,), |v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(98 * 4));
+
+			A::remove((2,));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2,), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2,)), false);
+
+			A::remove((2,));
+			AValueQueryWithAnOnEmpty::mutate_exists((2,), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(10));
+			AValueQueryWithAnOnEmpty::mutate_exists((2,), |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(100));
+
+			A::remove((2,));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2,), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(10));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2,), |v| {
+				*v = Some(v.unwrap() * 10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(100));
+			assert_eq!(A::try_get((2,)), Ok(100));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2,), |v| {
+				*v = Some(v.unwrap() * 10);
+				Err(())
+			});
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(100));
+
+			A::insert((2,), 10);
+			assert_eq!(A::take((2,)), Some(10));
+			assert_eq!(A::contains_key((2,)), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take((2,)), 98);
+			assert_eq!(A::contains_key((2,)), false);
+			assert_eq!(A::try_get((2,)), Err(()));
+
+			B::insert((2,), 10);
+			assert_eq!(
+				A::migrate_keys((2,), (Box::new(|key| Blake2_256::hash(key).to_vec()),),),
+				Some(10)
+			);
+			assert_eq!(A::contains_key((2,)), true);
+			assert_eq!(A::get((2,)), Some(10));
+
+			A::insert((3,), 10);
+			A::insert((4,), 10);
+			let _ = A::clear(u32::max_value(), None);
+			assert_eq!(A::contains_key((3,)), false);
+			assert_eq!(A::contains_key((4,)), false);
+
+			A::insert((3,), 10);
+			A::insert((4,), 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+
+			C::insert((3,), 10);
+			C::insert((4,), 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 20), (3, 20)]);
+
+			A::insert((3,), 10);
+			A::insert((4,), 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 10), (3, 10)]);
+			assert_eq!(A::drain().collect::<Vec<_>>(), vec![(4, 10), (3, 10)]);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+
+			C::insert((3,), 10);
+			C::insert((4,), 10);
+			A::translate::<u8, _>(|k1, v| Some((k1 as u16 * v as u16).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![(4, 40), (3, 30)]);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![StorageHasherIR::Blake2_128Concat],
+							key: scale_info::meta_type::<u16>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![StorageHasherIR::Blake2_128Concat],
+							key: scale_info::meta_type::<u16>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 98u32.encode(),
+						docs: vec![],
+					}
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len((3,)), None);
+			WithLen::append((0,), 10);
+			assert_eq!(WithLen::decode_len((0,)), Some(1));
+		});
+	}
+
+	#[test]
+	fn test_2_keys() {
+		type A = StorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			u32,
+			OptionQuery,
+		>;
+		type AValueQueryWithAnOnEmpty = StorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			u32,
+			ValueQuery,
+			ADefault,
+		>;
+		type B =
+			StorageNMap<Prefix, (NMapKey<Blake2_256, u16>, NMapKey<Twox128, u8>), u32, ValueQuery>;
+		type C = StorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			u8,
+			ValueQuery,
+		>;
+		type WithLen = StorageNMap<
+			Prefix,
+			(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>),
+			Vec<u32>,
+		>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"Foo"));
+			k.extend(&3u16.blake2_128_concat());
+			k.extend(&30u8.twox_64_concat());
+			assert_eq!(A::hashed_key_for((3, 30)).to_vec(), k);
+
+			assert_eq!(A::contains_key((3, 30)), false);
+			assert_eq!(A::get((3, 30)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3, 30)), 98);
+
+			A::insert((3, 30), 10);
+			assert_eq!(A::contains_key((3, 30)), true);
+			assert_eq!(A::get((3, 30)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3, 30)), 10);
+
+			A::swap::<(NMapKey<Blake2_128Concat, u16>, NMapKey<Twox64Concat, u8>), _, _>(
+				(3, 30),
+				(2, 20),
+			);
+			assert_eq!(A::contains_key((3, 30)), false);
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((3, 30)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((3, 30)), 98);
+			assert_eq!(A::get((2, 20)), Some(10));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((2, 20)), 10);
+
+			A::remove((2, 20));
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(A::get((2, 20)), None);
+
+			AValueQueryWithAnOnEmpty::mutate((2, 20), |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate((2, 20), |v| *v = *v * 2);
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(98 * 4));
+
+			A::remove((2, 20));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2, 20), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20)), false);
+
+			A::remove((2, 20));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2, 20), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20)), false);
+
+			A::remove((2, 20));
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(10));
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20), |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(100));
+
+			A::remove((2, 20));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(10));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20), |v| {
+				*v = Some(v.unwrap() * 10);
+				Ok(())
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(100));
+			assert_eq!(A::try_get((2, 20)), Ok(100));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20), |v| {
+				*v = Some(v.unwrap() * 10);
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(100));
+
+			A::insert((2, 20), 10);
+			assert_eq!(A::take((2, 20)), Some(10));
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take((2, 20)), 98);
+			assert_eq!(A::contains_key((2, 20)), false);
+			assert_eq!(A::try_get((2, 20)), Err(()));
+
+			B::insert((2, 20), 10);
+			assert_eq!(
+				A::migrate_keys(
+					(2, 20),
+					(
+						Box::new(|key| Blake2_256::hash(key).to_vec()),
+						Box::new(|key| Twox128::hash(key).to_vec()),
+					),
+				),
+				Some(10)
+			);
+			assert_eq!(A::contains_key((2, 20)), true);
+			assert_eq!(A::get((2, 20)), Some(10));
+
+			A::insert((3, 30), 10);
+			A::insert((4, 40), 10);
+			let _ = A::clear(u32::max_value(), None);
+			assert_eq!(A::contains_key((3, 30)), false);
+			assert_eq!(A::contains_key((4, 40)), false);
+
+			A::insert((3, 30), 10);
+			A::insert((4, 40), 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+
+			C::insert((3, 30), 10);
+			C::insert((4, 40), 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40), 20), ((3, 30), 20)]);
+
+			A::insert((3, 30), 10);
+			A::insert((4, 40), 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40), 10), ((3, 30), 10)]);
+			assert_eq!(A::drain().collect::<Vec<_>>(), vec![((4, 40), 10), ((3, 30), 10)]);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+
+			C::insert((3, 30), 10);
+			C::insert((4, 40), 10);
+			A::translate::<u8, _>(|(k1, k2), v| Some((k1 * k2 as u16 * v as u16).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40), 1600), ((3, 30), 900)]);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u8)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u8)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 98u32.encode(),
+						docs: vec![],
+					}
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len((3, 30)), None);
+			WithLen::append((0, 100), 10);
+			assert_eq!(WithLen::decode_len((0, 100)), Some(1));
+
+			A::insert((3, 30), 11);
+			A::insert((3, 31), 12);
+			A::insert((4, 40), 13);
+			A::insert((4, 41), 14);
+			assert_eq!(A::iter_prefix_values((3,)).collect::<Vec<_>>(), vec![12, 11]);
+			assert_eq!(A::iter_prefix_values((4,)).collect::<Vec<_>>(), vec![13, 14]);
+		});
+	}
+
+	#[test]
+	fn test_3_keys() {
+		type A = StorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			u32,
+			OptionQuery,
+		>;
+		type AValueQueryWithAnOnEmpty = StorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			u32,
+			ValueQuery,
+			ADefault,
+		>;
+		type B = StorageNMap<
+			Prefix,
+			(NMapKey<Blake2_256, u16>, NMapKey<Blake2_256, u16>, NMapKey<Twox128, u16>),
+			u32,
+			ValueQuery,
+		>;
+		type C = StorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			u8,
+			ValueQuery,
+		>;
+		type WithLen = StorageNMap<
+			Prefix,
+			(
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Blake2_128Concat, u16>,
+				NMapKey<Twox64Concat, u16>,
+			),
+			Vec<u32>,
+		>;
+
+		TestExternalities::default().execute_with(|| {
+			let mut k: Vec<u8> = vec![];
+			k.extend(&twox_128(b"test"));
+			k.extend(&twox_128(b"Foo"));
+			k.extend(&1u16.blake2_128_concat());
+			k.extend(&10u16.blake2_128_concat());
+			k.extend(&100u16.twox_64_concat());
+			assert_eq!(A::hashed_key_for((1, 10, 100)).to_vec(), k);
+
+			assert_eq!(A::contains_key((1, 10, 100)), false);
+			assert_eq!(A::get((1, 10, 100)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((1, 10, 100)), 98);
+
+			A::insert((1, 10, 100), 30);
+			assert_eq!(A::contains_key((1, 10, 100)), true);
+			assert_eq!(A::get((1, 10, 100)), Some(30));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((1, 10, 100)), 30);
+
+			A::swap::<
+				(
+					NMapKey<Blake2_128Concat, u16>,
+					NMapKey<Blake2_128Concat, u16>,
+					NMapKey<Twox64Concat, u16>,
+				),
+				_,
+				_,
+			>((1, 10, 100), (2, 20, 200));
+			assert_eq!(A::contains_key((1, 10, 100)), false);
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((1, 10, 100)), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get((1, 10, 100)), 98);
+			assert_eq!(A::get((2, 20, 200)), Some(30));
+			assert_eq!(AValueQueryWithAnOnEmpty::get((2, 20, 200)), 30);
+
+			A::remove((2, 20, 200));
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+			assert_eq!(A::get((2, 20, 200)), None);
+
+			AValueQueryWithAnOnEmpty::mutate((2, 20, 200), |v| *v = *v * 2);
+			AValueQueryWithAnOnEmpty::mutate((2, 20, 200), |v| *v = *v * 2);
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(98 * 4));
+
+			A::remove((2, 20, 200));
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate((2, 20, 200), |v| {
+				*v = *v * 2;
+				Err(())
+			});
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+
+			A::remove((2, 20, 200));
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20, 200), |v| {
+				assert!(v.is_none());
+				*v = Some(10);
+			});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(10));
+			AValueQueryWithAnOnEmpty::mutate_exists((2, 20, 200), |v| {
+				*v = Some(v.unwrap() * 10);
+			});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(100));
+
+			A::remove((2, 20, 200));
+			let _: Result<(), ()> =
+				AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20, 200), |v| {
+					assert!(v.is_none());
+					*v = Some(10);
+					Ok(())
+				});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(10));
+			let _: Result<(), ()> =
+				AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20, 200), |v| {
+					*v = Some(v.unwrap() * 10);
+					Ok(())
+				});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(100));
+			assert_eq!(A::try_get((2, 20, 200)), Ok(100));
+			let _: Result<(), ()> =
+				AValueQueryWithAnOnEmpty::try_mutate_exists((2, 20, 200), |v| {
+					*v = Some(v.unwrap() * 10);
+					Err(())
+				});
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(100));
+
+			A::insert((2, 20, 200), 10);
+			assert_eq!(A::take((2, 20, 200)), Some(10));
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+			assert_eq!(AValueQueryWithAnOnEmpty::take((2, 20, 200)), 98);
+			assert_eq!(A::contains_key((2, 20, 200)), false);
+			assert_eq!(A::try_get((2, 20, 200)), Err(()));
+
+			B::insert((2, 20, 200), 10);
+			assert_eq!(
+				A::migrate_keys(
+					(2, 20, 200),
+					(
+						Box::new(|key| Blake2_256::hash(key).to_vec()),
+						Box::new(|key| Blake2_256::hash(key).to_vec()),
+						Box::new(|key| Twox128::hash(key).to_vec()),
+					),
+				),
+				Some(10)
+			);
+			assert_eq!(A::contains_key((2, 20, 200)), true);
+			assert_eq!(A::get((2, 20, 200)), Some(10));
+
+			A::insert((3, 30, 300), 10);
+			A::insert((4, 40, 400), 10);
+			let _ = A::clear(u32::max_value(), None);
+			assert_eq!(A::contains_key((3, 30, 300)), false);
+			assert_eq!(A::contains_key((4, 40, 400)), false);
+
+			A::insert((3, 30, 300), 10);
+			A::insert((4, 40, 400), 10);
+			assert_eq!(A::iter_values().collect::<Vec<_>>(), vec![10, 10]);
+
+			C::insert((3, 30, 300), 10);
+			C::insert((4, 40, 400), 10);
+			A::translate_values::<u8, _>(|v| Some((v * 2).into()));
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40, 400), 20), ((3, 30, 300), 20)]);
+
+			A::insert((3, 30, 300), 10);
+			A::insert((4, 40, 400), 10);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40, 400), 10), ((3, 30, 300), 10)]);
+			assert_eq!(
+				A::drain().collect::<Vec<_>>(),
+				vec![((4, 40, 400), 10), ((3, 30, 300), 10)]
+			);
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![]);
+
+			C::insert((3, 30, 300), 10);
+			C::insert((4, 40, 400), 10);
+			A::translate::<u8, _>(|(k1, k2, k3), v| {
+				Some((k1 * k2 as u16 * v as u16 / k3 as u16).into())
+			});
+			assert_eq!(A::iter().collect::<Vec<_>>(), vec![((4, 40, 400), 4), ((3, 30, 300), 3)]);
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u16, u16)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "Foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Map {
+							hashers: vec![
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Blake2_128Concat,
+								StorageHasherIR::Twox64Concat
+							],
+							key: scale_info::meta_type::<(u16, u16, u16)>(),
+							value: scale_info::meta_type::<u32>(),
+						},
+						default: 98u32.encode(),
+						docs: vec![],
+					}
+				]
+			);
+
+			let _ = WithLen::clear(u32::max_value(), None);
+			assert_eq!(WithLen::decode_len((3, 30, 300)), None);
+			WithLen::append((0, 100, 1000), 10);
+			assert_eq!(WithLen::decode_len((0, 100, 1000)), Some(1));
+
+			A::insert((3, 30, 300), 11);
+			A::insert((3, 30, 301), 12);
+			A::insert((4, 40, 400), 13);
+			A::insert((4, 40, 401), 14);
+			assert_eq!(A::iter_prefix_values((3,)).collect::<Vec<_>>(), vec![11, 12]);
+			assert_eq!(A::iter_prefix_values((4,)).collect::<Vec<_>>(), vec![14, 13]);
+			assert_eq!(A::iter_prefix_values((3, 30)).collect::<Vec<_>>(), vec![11, 12]);
+			assert_eq!(A::iter_prefix_values((4, 40)).collect::<Vec<_>>(), vec![14, 13]);
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/types/value.rs b/substrate/frame/support/src/storage/types/value.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3c7f24715ac94026b3bea3c1aeb5eb7a775b41ed
--- /dev/null
+++ b/substrate/frame/support/src/storage/types/value.rs
@@ -0,0 +1,395 @@
+// 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.
+
+//! Storage value type. Implements StorageValue trait and its method directly.
+
+use crate::{
+	storage::{
+		generator::StorageValue as StorageValueT,
+		types::{OptionQuery, QueryKindTrait, StorageEntryMetadataBuilder},
+		StorageAppend, StorageDecodeLength, StorageTryAppend,
+	},
+	traits::{GetDefault, StorageInfo, StorageInstance},
+};
+use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};
+use sp_arithmetic::traits::SaturatedConversion;
+use sp_metadata_ir::{StorageEntryMetadataIR, StorageEntryTypeIR};
+use sp_std::prelude::*;
+
+/// A type that allow to store a value.
+///
+/// Each value is stored at:
+/// ```nocompile
+/// Twox128(Prefix::pallet_prefix()) ++ Twox128(Prefix::STORAGE_PREFIX)
+/// ```
+pub struct StorageValue<Prefix, Value, QueryKind = OptionQuery, OnEmpty = GetDefault>(
+	core::marker::PhantomData<(Prefix, Value, QueryKind, OnEmpty)>,
+);
+
+impl<Prefix, Value, QueryKind, OnEmpty> crate::storage::generator::StorageValue<Value>
+	for StorageValue<Prefix, Value, QueryKind, OnEmpty>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: crate::traits::Get<QueryKind::Query> + 'static,
+{
+	type Query = QueryKind::Query;
+	fn module_prefix() -> &'static [u8] {
+		Prefix::pallet_prefix().as_bytes()
+	}
+	fn storage_prefix() -> &'static [u8] {
+		Prefix::STORAGE_PREFIX.as_bytes()
+	}
+	fn from_optional_value_to_query(v: Option<Value>) -> Self::Query {
+		QueryKind::from_optional_value_to_query(v)
+	}
+	fn from_query_to_optional_value(v: Self::Query) -> Option<Value> {
+		QueryKind::from_query_to_optional_value(v)
+	}
+}
+
+impl<Prefix, Value, QueryKind, OnEmpty> StorageValue<Prefix, Value, QueryKind, OnEmpty>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: crate::traits::Get<QueryKind::Query> + 'static,
+{
+	/// Get the storage key.
+	pub fn hashed_key() -> [u8; 32] {
+		<Self as crate::storage::StorageValue<Value>>::hashed_key()
+	}
+
+	/// Does the value (explicitly) exist in storage?
+	pub fn exists() -> bool {
+		<Self as crate::storage::StorageValue<Value>>::exists()
+	}
+
+	/// Load the value from the provided storage instance.
+	pub fn get() -> QueryKind::Query {
+		<Self as crate::storage::StorageValue<Value>>::get()
+	}
+
+	/// Try to get the underlying value from the provided storage instance; `Ok` if it exists,
+	/// `Err` if not.
+	pub fn try_get() -> Result<Value, ()> {
+		<Self as crate::storage::StorageValue<Value>>::try_get()
+	}
+
+	/// Translate a value from some previous type (`O`) to the current type.
+	///
+	/// `f: F` is the translation function.
+	///
+	/// Returns `Err` if the storage item could not be interpreted as the old type, and Ok, along
+	/// with the new value if it could.
+	///
+	/// NOTE: This operates from and to `Option<_>` types; no effort is made to respect the default
+	/// value of the original type.
+	///
+	/// # Warning
+	///
+	/// This function must be used with care, before being updated the storage still contains the
+	/// old type, thus other calls (such as `get`) will fail at decoding it.
+	///
+	/// # Usage
+	///
+	/// This would typically be called inside the module implementation of on_runtime_upgrade,
+	/// while ensuring **no usage of this storage are made before the call to
+	/// `on_runtime_upgrade`**. (More precisely prior initialized modules doesn't make use of this
+	/// storage).
+	pub fn translate<O: Decode, F: FnOnce(Option<O>) -> Option<Value>>(
+		f: F,
+	) -> Result<Option<Value>, ()> {
+		<Self as crate::storage::StorageValue<Value>>::translate(f)
+	}
+
+	/// Store a value under this key into the provided storage instance.
+	pub fn put<Arg: EncodeLike<Value>>(val: Arg) {
+		<Self as crate::storage::StorageValue<Value>>::put(val)
+	}
+
+	/// Store a value under this key into the provided storage instance.
+	///
+	/// this uses the query type rather than the underlying value.
+	pub fn set(val: QueryKind::Query) {
+		<Self as crate::storage::StorageValue<Value>>::set(val)
+	}
+
+	/// Mutate the value
+	pub fn mutate<R, F: FnOnce(&mut QueryKind::Query) -> R>(f: F) -> R {
+		<Self as crate::storage::StorageValue<Value>>::mutate(f)
+	}
+
+	/// Mutate the value under a key iff it exists. Do nothing and return the default value if not.
+	pub fn mutate_extant<R: Default, F: FnOnce(&mut Value) -> R>(f: F) -> R {
+		<Self as crate::storage::StorageValue<Value>>::mutate_extant(f)
+	}
+
+	/// Mutate the value if closure returns `Ok`
+	pub fn try_mutate<R, E, F: FnOnce(&mut QueryKind::Query) -> Result<R, E>>(
+		f: F,
+	) -> Result<R, E> {
+		<Self as crate::storage::StorageValue<Value>>::try_mutate(f)
+	}
+
+	/// Mutate the value. Deletes the item if mutated to a `None`.
+	pub fn mutate_exists<R, F: FnOnce(&mut Option<Value>) -> R>(f: F) -> R {
+		<Self as crate::storage::StorageValue<Value>>::mutate_exists(f)
+	}
+
+	/// Mutate the value if closure returns `Ok`. Deletes the item if mutated to a `None`.
+	pub fn try_mutate_exists<R, E, F: FnOnce(&mut Option<Value>) -> Result<R, E>>(
+		f: F,
+	) -> Result<R, E> {
+		<Self as crate::storage::StorageValue<Value>>::try_mutate_exists(f)
+	}
+
+	/// Clear the storage value.
+	pub fn kill() {
+		<Self as crate::storage::StorageValue<Value>>::kill()
+	}
+
+	/// Take a value from storage, removing it afterwards.
+	pub fn take() -> QueryKind::Query {
+		<Self as crate::storage::StorageValue<Value>>::take()
+	}
+
+	/// Append the given item to the value in the storage.
+	///
+	/// `Value` is required to implement [`StorageAppend`].
+	///
+	/// # Warning
+	///
+	/// If the storage item is not encoded properly, the storage item will be overwritten
+	/// and set to `[item]`. Any default value set for the storage item will be ignored
+	/// on overwrite.
+	pub fn append<Item, EncodeLikeItem>(item: EncodeLikeItem)
+	where
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageAppend<Item>,
+	{
+		<Self as crate::storage::StorageValue<Value>>::append(item)
+	}
+
+	/// Read the length of the storage value without decoding the entire value.
+	///
+	/// `Value` is required to implement [`StorageDecodeLength`].
+	///
+	/// If the value does not exists or it fails to decode the length, `None` is returned.
+	/// Otherwise `Some(len)` is returned.
+	///
+	/// # Warning
+	///
+	/// `None` does not mean that `get()` does not return a value. The default value is completly
+	/// ignored by this function.
+	pub fn decode_len() -> Option<usize>
+	where
+		Value: StorageDecodeLength,
+	{
+		<Self as crate::storage::StorageValue<Value>>::decode_len()
+	}
+
+	/// Try and append the given item to the value in the storage.
+	///
+	/// Is only available if `Value` of the storage implements [`StorageTryAppend`].
+	pub fn try_append<Item, EncodeLikeItem>(item: EncodeLikeItem) -> Result<(), ()>
+	where
+		Item: Encode,
+		EncodeLikeItem: EncodeLike<Item>,
+		Value: StorageTryAppend<Item>,
+	{
+		<Self as crate::storage::TryAppendValue<Value, Item>>::try_append(item)
+	}
+}
+
+impl<Prefix, Value, QueryKind, OnEmpty> StorageEntryMetadataBuilder
+	for StorageValue<Prefix, Value, QueryKind, OnEmpty>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec + scale_info::StaticTypeInfo,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: crate::traits::Get<QueryKind::Query> + 'static,
+{
+	fn build_metadata(docs: Vec<&'static str>, entries: &mut Vec<StorageEntryMetadataIR>) {
+		let docs = if cfg!(feature = "no-metadata-docs") { vec![] } else { docs };
+
+		let entry = StorageEntryMetadataIR {
+			name: Prefix::STORAGE_PREFIX,
+			modifier: QueryKind::METADATA,
+			ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<Value>()),
+			default: OnEmpty::get().encode(),
+			docs,
+		};
+
+		entries.push(entry);
+	}
+}
+
+impl<Prefix, Value, QueryKind, OnEmpty> crate::traits::StorageInfoTrait
+	for StorageValue<Prefix, Value, QueryKind, OnEmpty>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec + MaxEncodedLen,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: crate::traits::Get<QueryKind::Query> + 'static,
+{
+	fn storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::hashed_key().to_vec(),
+			max_values: Some(1),
+			max_size: Some(Value::max_encoded_len().saturated_into()),
+		}]
+	}
+}
+
+/// It doesn't require to implement `MaxEncodedLen` and give no information for `max_size`.
+impl<Prefix, Value, QueryKind, OnEmpty> crate::traits::PartialStorageInfoTrait
+	for StorageValue<Prefix, Value, QueryKind, OnEmpty>
+where
+	Prefix: StorageInstance,
+	Value: FullCodec,
+	QueryKind: QueryKindTrait<Value, OnEmpty>,
+	OnEmpty: crate::traits::Get<QueryKind::Query> + 'static,
+{
+	fn partial_storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: Self::module_prefix().to_vec(),
+			storage_name: Self::storage_prefix().to_vec(),
+			prefix: Self::hashed_key().to_vec(),
+			max_values: Some(1),
+			max_size: None,
+		}]
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::storage::types::ValueQuery;
+	use sp_io::{hashing::twox_128, TestExternalities};
+	use sp_metadata_ir::StorageEntryModifierIR;
+
+	struct Prefix;
+	impl StorageInstance for Prefix {
+		fn pallet_prefix() -> &'static str {
+			"test"
+		}
+		const STORAGE_PREFIX: &'static str = "foo";
+	}
+
+	struct ADefault;
+	impl crate::traits::Get<u32> for ADefault {
+		fn get() -> u32 {
+			97
+		}
+	}
+
+	#[test]
+	fn test() {
+		type A = StorageValue<Prefix, u32, OptionQuery>;
+		type AValueQueryWithAnOnEmpty = StorageValue<Prefix, u32, ValueQuery, ADefault>;
+		type B = StorageValue<Prefix, u16, ValueQuery>;
+		type WithLen = StorageValue<Prefix, Vec<u32>>;
+
+		TestExternalities::default().execute_with(|| {
+			assert_eq!(A::hashed_key().to_vec(), [twox_128(b"test"), twox_128(b"foo")].concat());
+			assert_eq!(A::exists(), false);
+			assert_eq!(A::get(), None);
+			assert_eq!(AValueQueryWithAnOnEmpty::get(), 97);
+			assert_eq!(A::try_get(), Err(()));
+
+			A::put(2);
+			assert_eq!(A::exists(), true);
+			assert_eq!(A::get(), Some(2));
+			assert_eq!(AValueQueryWithAnOnEmpty::get(), 2);
+			assert_eq!(A::try_get(), Ok(2));
+			assert_eq!(A::try_get(), Ok(2));
+
+			B::put(4);
+			A::translate::<u16, _>(|v| v.map(Into::into)).unwrap();
+			assert_eq!(A::try_get(), Ok(4));
+
+			A::set(None);
+			assert_eq!(A::try_get(), Err(()));
+
+			A::set(Some(2));
+			assert_eq!(A::try_get(), Ok(2));
+
+			A::mutate(|v| *v = Some(v.unwrap() * 2));
+			assert_eq!(A::try_get(), Ok(4));
+
+			A::set(Some(4));
+			let _: Result<(), ()> = A::try_mutate(|v| {
+				*v = Some(v.unwrap() * 2);
+				Ok(())
+			});
+			assert_eq!(A::try_get(), Ok(8));
+
+			let _: Result<(), ()> = A::try_mutate(|v| {
+				*v = Some(v.unwrap() * 2);
+				Err(())
+			});
+			assert_eq!(A::try_get(), Ok(8));
+
+			A::kill();
+			AValueQueryWithAnOnEmpty::mutate(|v| *v = *v * 2);
+			assert_eq!(AValueQueryWithAnOnEmpty::try_get(), Ok(97 * 2));
+
+			AValueQueryWithAnOnEmpty::kill();
+			let _: Result<(), ()> = AValueQueryWithAnOnEmpty::try_mutate(|v| {
+				*v = *v * 2;
+				Ok(())
+			});
+			assert_eq!(AValueQueryWithAnOnEmpty::try_get(), Ok(97 * 2));
+
+			A::kill();
+			assert_eq!(A::try_get(), Err(()));
+
+			let mut entries = vec![];
+			A::build_metadata(vec![], &mut entries);
+			AValueQueryWithAnOnEmpty::build_metadata(vec![], &mut entries);
+			assert_eq!(
+				entries,
+				vec![
+					StorageEntryMetadataIR {
+						name: "foo",
+						modifier: StorageEntryModifierIR::Optional,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: Option::<u32>::None.encode(),
+						docs: vec![],
+					},
+					StorageEntryMetadataIR {
+						name: "foo",
+						modifier: StorageEntryModifierIR::Default,
+						ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+						default: 97u32.encode(),
+						docs: vec![],
+					}
+				]
+			);
+
+			WithLen::kill();
+			assert_eq!(WithLen::decode_len(), None);
+			WithLen::append(3);
+			assert_eq!(WithLen::decode_len(), Some(1));
+		});
+	}
+}
diff --git a/substrate/frame/support/src/storage/unhashed.rs b/substrate/frame/support/src/storage/unhashed.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aae83034ab71aab13a24f060e369e966d26f93ca
--- /dev/null
+++ b/substrate/frame/support/src/storage/unhashed.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.
+
+//! Operation on unhashed runtime storage.
+
+use codec::{Decode, Encode};
+use sp_std::prelude::*;
+
+/// Return the value of the item in storage under `key`, or `None` if there is no explicit entry.
+pub fn get<T: Decode + Sized>(key: &[u8]) -> Option<T> {
+	sp_io::storage::get(key).and_then(|val| {
+		Decode::decode(&mut &val[..]).map(Some).unwrap_or_else(|e| {
+			// TODO #3700: error should be handleable.
+			log::error!(
+				target: "runtime::storage",
+				"Corrupted state at `{:?}: {:?}`",
+				key,
+				e,
+			);
+			None
+		})
+	})
+}
+
+/// Return the value of the item in storage under `key`, or the type's default if there is no
+/// explicit entry.
+pub fn get_or_default<T: Decode + Sized + Default>(key: &[u8]) -> T {
+	get(key).unwrap_or_default()
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry.
+pub fn get_or<T: Decode + Sized>(key: &[u8], default_value: T) -> T {
+	get(key).unwrap_or(default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry.
+pub fn get_or_else<T: Decode + Sized, F: FnOnce() -> T>(key: &[u8], default_value: F) -> T {
+	get(key).unwrap_or_else(default_value)
+}
+
+/// Put `value` in storage under `key`.
+pub fn put<T: Encode + ?Sized>(key: &[u8], value: &T) {
+	value.using_encoded(|slice| sp_io::storage::set(key, slice));
+}
+
+/// Remove `key` from storage, returning its value if it had an explicit entry or `None` otherwise.
+pub fn take<T: Decode + Sized>(key: &[u8]) -> Option<T> {
+	let r = get(key);
+	if r.is_some() {
+		kill(key);
+	}
+	r
+}
+
+/// Remove `key` from storage, returning its value, or, if there was no explicit entry in storage,
+/// the default for its type.
+pub fn take_or_default<T: Decode + Sized + Default>(key: &[u8]) -> T {
+	take(key).unwrap_or_default()
+}
+
+/// Return the value of the item in storage under `key`, or `default_value` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or<T: Decode + Sized>(key: &[u8], default_value: T) -> T {
+	take(key).unwrap_or(default_value)
+}
+
+/// Return the value of the item in storage under `key`, or `default_value()` if there is no
+/// explicit entry. Ensure there is no explicit entry on return.
+pub fn take_or_else<T: Decode + Sized, F: FnOnce() -> T>(key: &[u8], default_value: F) -> T {
+	take(key).unwrap_or_else(default_value)
+}
+
+/// Check to see if `key` has an explicit entry in storage.
+pub fn exists(key: &[u8]) -> bool {
+	sp_io::storage::exists(key)
+}
+
+/// Ensure `key` has no explicit entry in storage.
+pub fn kill(key: &[u8]) {
+	sp_io::storage::clear(key);
+}
+
+/// Ensure keys with the given `prefix` have no entries in storage.
+#[deprecated = "Use `clear_prefix` instead"]
+pub fn kill_prefix(prefix: &[u8], limit: Option<u32>) -> sp_io::KillStorageResult {
+	// TODO: Once the network has upgraded to include the new host functions, this code can be
+	// enabled.
+	// clear_prefix(prefix, limit).into()
+	sp_io::storage::clear_prefix(prefix, limit)
+}
+
+/// Partially clear the storage of all keys under a common `prefix`.
+///
+/// # Limit
+///
+/// A *limit* should always be provided through `maybe_limit`. This is one fewer than the
+/// maximum number of backend iterations which may be done by this operation and as such
+/// represents the maximum number of backend deletions which may happen. A *limit* of zero
+/// implies that no keys will be deleted, though there may be a single iteration done.
+///
+/// The limit can be used to partially delete storage items in case it is too large or costly
+/// to delete all in a single operation.
+///
+/// # Cursor
+///
+/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+/// passed once (in the initial call) for any attempt to clear storage. In general, subsequent calls
+/// operating on the same prefix should pass `Some` and this value should be equal to the
+/// previous call result's `maybe_cursor` field. The only exception to this is when you can
+/// guarantee that the subsequent call is in a new block; in this case the previous call's result
+/// cursor need not be passed in an a `None` may be passed instead. This exception may be useful
+/// then making this call solely from a block-hook such as `on_initialize`.
+///
+/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once the
+/// resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+///
+/// NOTE: After the initial call for any given child storage, it is important that no keys further
+/// keys are inserted. If so, then they may or may not be deleted by subsequent calls.
+///
+/// # Note
+///
+/// Please note that keys which are residing in the overlay for the child are deleted without
+/// counting towards the `limit`.
+pub fn clear_prefix(
+	prefix: &[u8],
+	maybe_limit: Option<u32>,
+	_maybe_cursor: Option<&[u8]>,
+) -> sp_io::MultiRemovalResults {
+	// TODO: Once the network has upgraded to include the new host functions, this code can be
+	// enabled.
+	// sp_io::storage::clear_prefix(prefix, maybe_limit, maybe_cursor)
+	use sp_io::{KillStorageResult::*, MultiRemovalResults};
+	#[allow(deprecated)]
+	let (maybe_cursor, i) = match kill_prefix(prefix, maybe_limit) {
+		AllRemoved(i) => (None, i),
+		SomeRemaining(i) => (Some(prefix.to_vec()), i),
+	};
+	MultiRemovalResults { maybe_cursor, backend: i, unique: i, loops: i }
+}
+
+/// Returns `true` if the storage contains any key, which starts with a certain prefix,
+/// and is longer than said prefix.
+/// This means that a key which equals the prefix will not be counted.
+pub fn contains_prefixed_key(prefix: &[u8]) -> bool {
+	match sp_io::storage::next_key(prefix) {
+		Some(key) => key.starts_with(prefix),
+		None => false,
+	}
+}
+
+/// Get a Vec of bytes from storage.
+pub fn get_raw(key: &[u8]) -> Option<Vec<u8>> {
+	sp_io::storage::get(key).map(|value| value.to_vec())
+}
+
+/// Put a raw byte slice into storage.
+///
+/// **WARNING**: If you set the storage of the Substrate Wasm (`well_known_keys::CODE`),
+/// you should also call `frame_system::RuntimeUpgraded::put(true)` to trigger the
+/// `on_runtime_upgrade` logic.
+pub fn put_raw(key: &[u8], value: &[u8]) {
+	sp_io::storage::set(key, value)
+}
diff --git a/substrate/frame/support/src/storage/weak_bounded_vec.rs b/substrate/frame/support/src/storage/weak_bounded_vec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..41d27b51a12fd20bbf31056abd664b08be2a5f17
--- /dev/null
+++ b/substrate/frame/support/src/storage/weak_bounded_vec.rs
@@ -0,0 +1,75 @@
+// 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.
+
+//! Traits, types and structs to support putting a bounded vector into storage, as a raw value, map
+//! or a double map.
+
+use crate::{
+	storage::{StorageDecodeLength, StorageTryAppend},
+	traits::Get,
+};
+pub use sp_runtime::WeakBoundedVec;
+
+impl<T, S> StorageDecodeLength for WeakBoundedVec<T, S> {}
+
+impl<T, S: Get<u32>> StorageTryAppend<T> for WeakBoundedVec<T, S> {
+	fn bound() -> usize {
+		S::get() as usize
+	}
+}
+
+#[cfg(test)]
+pub mod test {
+	use super::*;
+	use crate::Twox128;
+	use frame_support::traits::ConstU32;
+	use sp_io::TestExternalities;
+
+	#[crate::storage_alias]
+	type Foo = StorageValue<Prefix, WeakBoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooMap = StorageMap<Prefix, Twox128, u32, WeakBoundedVec<u32, ConstU32<7>>>;
+	#[crate::storage_alias]
+	type FooDoubleMap =
+		StorageDoubleMap<Prefix, Twox128, u32, Twox128, u32, WeakBoundedVec<u32, ConstU32<7>>>;
+
+	#[test]
+	fn decode_len_works() {
+		TestExternalities::default().execute_with(|| {
+			let bounded: WeakBoundedVec<u32, ConstU32<7>> = vec![1, 2, 3].try_into().unwrap();
+			Foo::put(bounded);
+			assert_eq!(Foo::decode_len().unwrap(), 3);
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded: WeakBoundedVec<u32, ConstU32<7>> = vec![1, 2, 3].try_into().unwrap();
+			FooMap::insert(1, bounded);
+			assert_eq!(FooMap::decode_len(1).unwrap(), 3);
+			assert!(FooMap::decode_len(0).is_none());
+			assert!(FooMap::decode_len(2).is_none());
+		});
+
+		TestExternalities::default().execute_with(|| {
+			let bounded: WeakBoundedVec<u32, ConstU32<7>> = vec![1, 2, 3].try_into().unwrap();
+			FooDoubleMap::insert(1, 1, bounded);
+			assert_eq!(FooDoubleMap::decode_len(1, 1).unwrap(), 3);
+			assert!(FooDoubleMap::decode_len(2, 1).is_none());
+			assert!(FooDoubleMap::decode_len(1, 2).is_none());
+			assert!(FooDoubleMap::decode_len(2, 2).is_none());
+		});
+	}
+}
diff --git a/substrate/frame/support/src/tests/inject_runtime_type.rs b/substrate/frame/support/src/tests/inject_runtime_type.rs
new file mode 100644
index 0000000000000000000000000000000000000000..429a743d3b7b2bf16d8d9e7bf60b30c9433ae909
--- /dev/null
+++ b/substrate/frame/support/src/tests/inject_runtime_type.rs
@@ -0,0 +1,47 @@
+// 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::{Config, Runtime};
+use crate::{derive_impl, pallet_prelude::inject_runtime_type};
+use static_assertions::assert_type_eq_all;
+
+#[docify::export]
+#[test]
+fn derive_impl_works_with_runtime_type_injection() {
+	assert_type_eq_all!(<Runtime as Config>::RuntimeOrigin, super::RuntimeOrigin);
+	assert_type_eq_all!(<Runtime as Config>::RuntimeCall, super::RuntimeCall);
+	assert_type_eq_all!(<Runtime as Config>::PalletInfo, super::PalletInfo);
+}
+
+#[docify::export]
+#[test]
+fn derive_impl_works_with_no_aggregated_types() {
+	struct DummyRuntime;
+
+	#[derive_impl(
+        super::frame_system::config_preludes::TestDefaultConfig as super::frame_system::DefaultConfig,
+        no_aggregated_types
+    )]
+	impl Config for DummyRuntime {
+		type Block = super::Block;
+		type AccountId = super::AccountId;
+		type PalletInfo = super::PalletInfo;
+	}
+
+	assert_type_eq_all!(<DummyRuntime as Config>::RuntimeOrigin, ());
+	assert_type_eq_all!(<DummyRuntime as Config>::RuntimeCall, ());
+}
diff --git a/substrate/frame/support/src/tests/mod.rs b/substrate/frame/support/src/tests/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..db458880db6836eaedacd6ad44d269adca290933
--- /dev/null
+++ b/substrate/frame/support/src/tests/mod.rs
@@ -0,0 +1,649 @@
+// 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 sp_io::{MultiRemovalResults, TestExternalities};
+use sp_metadata_ir::{
+	PalletStorageMetadataIR, StorageEntryMetadataIR, StorageEntryModifierIR, StorageEntryTypeIR,
+	StorageHasherIR,
+};
+use sp_runtime::{generic, traits::BlakeTwo256, BuildStorage};
+
+pub use self::frame_system::{pallet_prelude::*, Config, Pallet};
+
+mod inject_runtime_type;
+mod storage_alias;
+
+#[pallet]
+pub mod frame_system {
+	#[allow(unused)]
+	use super::{frame_system, frame_system::pallet_prelude::*};
+	pub use crate::dispatch::RawOrigin;
+	use crate::pallet_prelude::*;
+
+	pub mod config_preludes {
+		use super::{inject_runtime_type, DefaultConfig};
+		pub struct TestDefaultConfig;
+
+		#[crate::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			type AccountId = u64;
+			type BaseCallFilter = frame_support::traits::Everything;
+			#[inject_runtime_type]
+			type RuntimeOrigin = ();
+			#[inject_runtime_type]
+			type RuntimeCall = ();
+			#[inject_runtime_type]
+			type PalletInfo = ();
+			type DbWeight = ();
+		}
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config(with_default)]
+	#[pallet::disable_frame_system_supertrait_check]
+	pub trait Config: 'static {
+		#[pallet::no_default]
+		type Block: Parameter + sp_runtime::traits::Block;
+		type AccountId;
+		#[pallet::no_default_bounds]
+		type BaseCallFilter: crate::traits::Contains<Self::RuntimeCall>;
+		#[pallet::no_default_bounds]
+		type RuntimeOrigin;
+		#[pallet::no_default_bounds]
+		type RuntimeCall;
+		#[pallet::no_default_bounds]
+		type PalletInfo: crate::traits::PalletInfo;
+		type DbWeight: Get<crate::weights::RuntimeDbWeight>;
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Required by construct_runtime
+		CallFiltered,
+	}
+
+	#[pallet::origin]
+	pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	pub type Data<T> = StorageMap<_, Twox64Concat, u32, u64, ValueQuery>;
+
+	#[pallet::storage]
+	pub type OptionLinkedMap<T> = StorageMap<_, Blake2_128Concat, u32, u32, OptionQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn generic_data)]
+	pub type GenericData<T: Config> =
+		StorageMap<_, Identity, BlockNumberFor<T>, BlockNumberFor<T>, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn generic_data2)]
+	pub type GenericData2<T: Config> =
+		StorageMap<_, Blake2_128Concat, BlockNumberFor<T>, BlockNumberFor<T>, OptionQuery>;
+
+	#[pallet::storage]
+	pub type DataDM<T> =
+		StorageDoubleMap<_, Twox64Concat, u32, Blake2_128Concat, u32, u64, ValueQuery>;
+
+	#[pallet::storage]
+	pub type GenericDataDM<T: Config> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		BlockNumberFor<T>,
+		Identity,
+		BlockNumberFor<T>,
+		BlockNumberFor<T>,
+		ValueQuery,
+	>;
+
+	#[pallet::storage]
+	pub type GenericData2DM<T: Config> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		BlockNumberFor<T>,
+		Twox64Concat,
+		BlockNumberFor<T>,
+		BlockNumberFor<T>,
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub type AppendableDM<T: Config> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		u32,
+		Blake2_128Concat,
+		BlockNumberFor<T>,
+		Vec<u32>,
+		ValueQuery,
+	>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub data: Vec<(u32, u64)>,
+		pub test_config: Vec<(u32, u32, u64)>,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			Self {
+				_config: Default::default(),
+				data: vec![(15u32, 42u64)],
+				test_config: vec![(15u32, 16u32, 42u64)],
+			}
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			for (k, v) in &self.data {
+				<Data<T>>::insert(k, v);
+			}
+			for (k1, k2, v) in &self.test_config {
+				<DataDM<T>>::insert(k1, k2, v);
+			}
+		}
+	}
+
+	pub mod pallet_prelude {
+		pub type OriginFor<T> = <T as super::Config>::RuntimeOrigin;
+
+		pub type HeaderFor<T> =
+			<<T as super::Config>::Block as sp_runtime::traits::HeaderProvider>::HeaderT;
+
+		pub type BlockNumberFor<T> = <HeaderFor<T> as sp_runtime::traits::Header>::Number;
+	}
+}
+
+type BlockNumber = u32;
+type AccountId = u32;
+type Header = generic::Header<BlockNumber, BlakeTwo256>;
+type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+crate::construct_runtime!(
+	pub enum Runtime
+	{
+		System: self::frame_system,
+	}
+);
+
+#[crate::derive_impl(self::frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl Config for Runtime {
+	type Block = Block;
+	type AccountId = AccountId;
+}
+
+fn new_test_ext() -> TestExternalities {
+	RuntimeGenesisConfig::default().build_storage().unwrap().into()
+}
+
+trait Sorted {
+	fn sorted(self) -> Self;
+}
+
+impl<T: Ord> Sorted for Vec<T> {
+	fn sorted(mut self) -> Self {
+		self.sort();
+		self
+	}
+}
+
+#[test]
+fn map_issue_3318() {
+	new_test_ext().execute_with(|| {
+		type OptionLinkedMap = self::frame_system::OptionLinkedMap<Runtime>;
+
+		OptionLinkedMap::insert(1, 1);
+		assert_eq!(OptionLinkedMap::get(1), Some(1));
+		OptionLinkedMap::insert(1, 2);
+		assert_eq!(OptionLinkedMap::get(1), Some(2));
+	});
+}
+
+#[test]
+fn map_swap_works() {
+	new_test_ext().execute_with(|| {
+		type OptionLinkedMap = self::frame_system::OptionLinkedMap<Runtime>;
+
+		OptionLinkedMap::insert(0, 0);
+		OptionLinkedMap::insert(1, 1);
+		OptionLinkedMap::insert(2, 2);
+		OptionLinkedMap::insert(3, 3);
+
+		let collect = || OptionLinkedMap::iter().collect::<Vec<_>>().sorted();
+		assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
+
+		// Two existing
+		OptionLinkedMap::swap(1, 2);
+		assert_eq!(collect(), vec![(0, 0), (1, 2), (2, 1), (3, 3)]);
+
+		// Back to normal
+		OptionLinkedMap::swap(2, 1);
+		assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
+
+		// Left existing
+		OptionLinkedMap::swap(2, 5);
+		assert_eq!(collect(), vec![(0, 0), (1, 1), (3, 3), (5, 2)]);
+
+		// Right existing
+		OptionLinkedMap::swap(5, 2);
+		assert_eq!(collect(), vec![(0, 0), (1, 1), (2, 2), (3, 3)]);
+	});
+}
+
+#[test]
+fn double_map_swap_works() {
+	new_test_ext().execute_with(|| {
+		type DataDM = self::frame_system::DataDM<Runtime>;
+
+		DataDM::insert(0, 1, 1);
+		DataDM::insert(1, 0, 2);
+		DataDM::insert(1, 1, 3);
+
+		let get_all = || {
+			vec![
+				DataDM::get(0, 1),
+				DataDM::get(1, 0),
+				DataDM::get(1, 1),
+				DataDM::get(2, 0),
+				DataDM::get(2, 1),
+			]
+		};
+		assert_eq!(get_all(), vec![1, 2, 3, 0, 0]);
+
+		// Two existing
+		DataDM::swap(0, 1, 1, 0);
+		assert_eq!(get_all(), vec![2, 1, 3, 0, 0]);
+
+		// Left existing
+		DataDM::swap(1, 0, 2, 0);
+		assert_eq!(get_all(), vec![2, 0, 3, 1, 0]);
+
+		// Right existing
+		DataDM::swap(2, 1, 1, 1);
+		assert_eq!(get_all(), vec![2, 0, 0, 1, 3]);
+	});
+}
+
+#[test]
+fn map_basic_insert_remove_should_work() {
+	new_test_ext().execute_with(|| {
+		type Map = self::frame_system::Data<Runtime>;
+
+		// initialized during genesis
+		assert_eq!(Map::get(&15u32), 42u64);
+
+		// get / insert / take
+		let key = 17u32;
+		assert_eq!(Map::get(&key), 0u64);
+		Map::insert(key, 4u64);
+		assert_eq!(Map::get(&key), 4u64);
+		assert_eq!(Map::take(&key), 4u64);
+		assert_eq!(Map::get(&key), 0u64);
+
+		// mutate
+		Map::mutate(&key, |val| {
+			*val = 15;
+		});
+		assert_eq!(Map::get(&key), 15u64);
+
+		// remove
+		Map::remove(&key);
+		assert_eq!(Map::get(&key), 0u64);
+	});
+}
+
+#[test]
+fn map_iteration_should_work() {
+	new_test_ext().execute_with(|| {
+		type Map = self::frame_system::Data<Runtime>;
+
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(15, 42)]);
+		// insert / remove
+		let key = 17u32;
+		Map::insert(key, 4u64);
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(15, 42), (key, 4)]);
+		assert_eq!(Map::take(&15), 42u64);
+		assert_eq!(Map::take(&key), 4u64);
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
+
+		// Add couple of more elements
+		Map::insert(key, 42u64);
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key, 42)]);
+		Map::insert(key + 1, 43u64);
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key, 42), (key + 1, 43)]);
+
+		// mutate
+		let key = key + 2;
+		Map::mutate(&key, |val| {
+			*val = 15;
+		});
+		assert_eq!(
+			Map::iter().collect::<Vec<_>>().sorted(),
+			vec![(key - 2, 42), (key - 1, 43), (key, 15)]
+		);
+		Map::mutate(&key, |val| {
+			*val = 17;
+		});
+		assert_eq!(
+			Map::iter().collect::<Vec<_>>().sorted(),
+			vec![(key - 2, 42), (key - 1, 43), (key, 17)]
+		);
+
+		// remove first
+		Map::remove(&key);
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 2, 42), (key - 1, 43)]);
+
+		// remove last from the list
+		Map::remove(&(key - 2));
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![(key - 1, 43)]);
+
+		// remove the last element
+		Map::remove(&(key - 1));
+		assert_eq!(Map::iter().collect::<Vec<_>>().sorted(), vec![]);
+	});
+}
+
+#[test]
+fn double_map_basic_insert_remove_remove_prefix_with_commit_should_work() {
+	let key1 = 17u32;
+	let key2 = 18u32;
+	type DoubleMap = self::frame_system::DataDM<Runtime>;
+	let mut e = new_test_ext();
+	e.execute_with(|| {
+		// initialized during genesis
+		assert_eq!(DoubleMap::get(&15u32, &16u32), 42u64);
+
+		// get / insert / take
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+		DoubleMap::insert(&key1, &key2, &4u64);
+		assert_eq!(DoubleMap::get(&key1, &key2), 4u64);
+		assert_eq!(DoubleMap::take(&key1, &key2), 4u64);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+
+		// mutate
+		DoubleMap::mutate(&key1, &key2, |val| *val = 15);
+		assert_eq!(DoubleMap::get(&key1, &key2), 15u64);
+
+		// remove
+		DoubleMap::remove(&key1, &key2);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+
+		// remove prefix
+		DoubleMap::insert(&key1, &key2, &4u64);
+		DoubleMap::insert(&key1, &(key2 + 1), &4u64);
+		DoubleMap::insert(&(key1 + 1), &key2, &4u64);
+		DoubleMap::insert(&(key1 + 1), &(key2 + 1), &4u64);
+	});
+	e.commit_all().unwrap();
+	e.execute_with(|| {
+		assert!(matches!(
+			DoubleMap::clear_prefix(&key1, u32::max_value(), None),
+			MultiRemovalResults { maybe_cursor: None, backend: 2, unique: 2, loops: 2 }
+		));
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+		assert_eq!(DoubleMap::get(&key1, &(key2 + 1)), 0u64);
+		assert_eq!(DoubleMap::get(&(key1 + 1), &key2), 4u64);
+		assert_eq!(DoubleMap::get(&(key1 + 1), &(key2 + 1)), 4u64);
+	});
+}
+
+#[test]
+fn double_map_basic_insert_remove_remove_prefix_should_work() {
+	new_test_ext().execute_with(|| {
+		let key1 = 17u32;
+		let key2 = 18u32;
+		type DoubleMap = self::frame_system::DataDM<Runtime>;
+
+		// initialized during genesis
+		assert_eq!(DoubleMap::get(&15u32, &16u32), 42u64);
+
+		// get / insert / take
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+		DoubleMap::insert(&key1, &key2, &4u64);
+		assert_eq!(DoubleMap::get(&key1, &key2), 4u64);
+		assert_eq!(DoubleMap::take(&key1, &key2), 4u64);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+
+		// mutate
+		DoubleMap::mutate(&key1, &key2, |val| *val = 15);
+		assert_eq!(DoubleMap::get(&key1, &key2), 15u64);
+
+		// remove
+		DoubleMap::remove(&key1, &key2);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+
+		// remove prefix
+		DoubleMap::insert(&key1, &key2, &4u64);
+		DoubleMap::insert(&key1, &(key2 + 1), &4u64);
+		DoubleMap::insert(&(key1 + 1), &key2, &4u64);
+		DoubleMap::insert(&(key1 + 1), &(key2 + 1), &4u64);
+		// all in overlay
+		assert!(matches!(
+			DoubleMap::clear_prefix(&key1, u32::max_value(), None),
+			MultiRemovalResults { maybe_cursor: None, backend: 0, unique: 0, loops: 0 }
+		));
+		// Note this is the incorrect answer (for now), since we are using v2 of
+		// `clear_prefix`.
+		// When we switch to v3, then this will become:
+		//   MultiRemovalResults:: { maybe_cursor: None, backend: 0, unique: 2, loops: 2 },
+		assert!(matches!(
+			DoubleMap::clear_prefix(&key1, u32::max_value(), None),
+			MultiRemovalResults { maybe_cursor: None, backend: 0, unique: 0, loops: 0 }
+		));
+		assert_eq!(DoubleMap::get(&key1, &key2), 0u64);
+		assert_eq!(DoubleMap::get(&key1, &(key2 + 1)), 0u64);
+		assert_eq!(DoubleMap::get(&(key1 + 1), &key2), 4u64);
+		assert_eq!(DoubleMap::get(&(key1 + 1), &(key2 + 1)), 4u64);
+	});
+}
+
+#[test]
+fn double_map_append_should_work() {
+	new_test_ext().execute_with(|| {
+		type DoubleMap = self::frame_system::AppendableDM<Runtime>;
+
+		let key1 = 17u32;
+		let key2 = 18u32;
+
+		DoubleMap::insert(&key1, &key2, &vec![1]);
+		DoubleMap::append(&key1, &key2, 2);
+		assert_eq!(DoubleMap::get(&key1, &key2), &[1, 2]);
+	});
+}
+
+#[test]
+fn double_map_mutate_exists_should_work() {
+	new_test_ext().execute_with(|| {
+		type DoubleMap = self::frame_system::DataDM<Runtime>;
+
+		let (key1, key2) = (11, 13);
+
+		// mutated
+		DoubleMap::mutate_exists(key1, key2, |v| *v = Some(1));
+		assert_eq!(DoubleMap::get(&key1, key2), 1);
+
+		// removed if mutated to `None`
+		DoubleMap::mutate_exists(key1, key2, |v| *v = None);
+		assert!(!DoubleMap::contains_key(&key1, key2));
+	});
+}
+
+#[test]
+fn double_map_try_mutate_exists_should_work() {
+	new_test_ext().execute_with(|| {
+		type DoubleMap = self::frame_system::DataDM<Runtime>;
+		type TestResult = Result<(), &'static str>;
+
+		let (key1, key2) = (11, 13);
+
+		// mutated if `Ok`
+		assert_ok!(DoubleMap::try_mutate_exists(key1, key2, |v| -> TestResult {
+			*v = Some(1);
+			Ok(())
+		}));
+		assert_eq!(DoubleMap::get(&key1, key2), 1);
+
+		// no-op if `Err`
+		assert_noop!(
+			DoubleMap::try_mutate_exists(key1, key2, |v| -> TestResult {
+				*v = Some(2);
+				Err("nah")
+			}),
+			"nah"
+		);
+
+		// removed if mutated to`None`
+		assert_ok!(DoubleMap::try_mutate_exists(key1, key2, |v| -> TestResult {
+			*v = None;
+			Ok(())
+		}));
+		assert!(!DoubleMap::contains_key(&key1, key2));
+	});
+}
+
+fn expected_metadata() -> PalletStorageMetadataIR {
+	PalletStorageMetadataIR {
+		prefix: "System",
+		entries: vec![
+			StorageEntryMetadataIR {
+				name: "Data",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Twox64Concat],
+					key: scale_info::meta_type::<u32>(),
+					value: scale_info::meta_type::<u64>(),
+				},
+				default: vec![0, 0, 0, 0, 0, 0, 0, 0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "OptionLinkedMap",
+				modifier: StorageEntryModifierIR::Optional,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Blake2_128Concat],
+					key: scale_info::meta_type::<u32>(),
+					value: scale_info::meta_type::<u32>(),
+				},
+				default: vec![0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "GenericData",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Identity],
+					key: scale_info::meta_type::<u32>(),
+					value: scale_info::meta_type::<u32>(),
+				},
+				default: vec![0, 0, 0, 0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "GenericData2",
+				modifier: StorageEntryModifierIR::Optional,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Blake2_128Concat],
+					key: scale_info::meta_type::<u32>(),
+					value: scale_info::meta_type::<u32>(),
+				},
+				default: vec![0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "DataDM",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Twox64Concat, StorageHasherIR::Blake2_128Concat],
+					key: scale_info::meta_type::<(u32, u32)>(),
+					value: scale_info::meta_type::<u64>(),
+				},
+				default: vec![0, 0, 0, 0, 0, 0, 0, 0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "GenericDataDM",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Blake2_128Concat, StorageHasherIR::Identity],
+					key: scale_info::meta_type::<(u32, u32)>(),
+					value: scale_info::meta_type::<u32>(),
+				},
+				default: vec![0, 0, 0, 0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "GenericData2DM",
+				modifier: StorageEntryModifierIR::Optional,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Blake2_128Concat, StorageHasherIR::Twox64Concat],
+					key: scale_info::meta_type::<(u32, u32)>(),
+					value: scale_info::meta_type::<u32>(),
+				},
+				default: vec![0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "AppendableDM",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![
+						StorageHasherIR::Blake2_128Concat,
+						StorageHasherIR::Blake2_128Concat,
+					],
+					key: scale_info::meta_type::<(u32, u32)>(),
+					value: scale_info::meta_type::<Vec<u32>>(),
+				},
+				default: vec![0],
+				docs: vec![],
+			},
+		],
+	}
+}
+
+#[test]
+fn store_metadata() {
+	let metadata = Pallet::<Runtime>::storage_metadata();
+	pretty_assertions::assert_eq!(expected_metadata(), metadata);
+}
+
+parameter_types! {
+	storage StorageParameter: u64 = 10;
+}
+
+#[test]
+fn check_storage_parameter_type_works() {
+	TestExternalities::default().execute_with(|| {
+		assert_eq!(sp_io::hashing::twox_128(b":StorageParameter:"), StorageParameter::key());
+
+		assert_eq!(10, StorageParameter::get());
+
+		StorageParameter::set(&300);
+		assert_eq!(300, StorageParameter::get());
+	})
+}
diff --git a/substrate/frame/support/src/tests/storage_alias.rs b/substrate/frame/support/src/tests/storage_alias.rs
new file mode 100644
index 0000000000000000000000000000000000000000..05ea1b5f712c631bc731f9444621d7f8c20f8b81
--- /dev/null
+++ b/substrate/frame/support/src/tests/storage_alias.rs
@@ -0,0 +1,192 @@
+// 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 sp_core::Get;
+
+use super::{new_test_ext, BlockNumberFor, Config, Pallet, Runtime};
+use crate::{
+	assert_noop, assert_ok, parameter_types, storage::generator::StorageValue, Blake2_128Concat,
+};
+
+#[test]
+fn storage_alias_works() {
+	new_test_ext().execute_with(|| {
+		#[crate::storage_alias]
+		type GenericData2<T> =
+			StorageMap<System, Blake2_128Concat, BlockNumberFor<T>, BlockNumberFor<T>>;
+
+		assert_eq!(Pallet::<Runtime>::generic_data2(5), None);
+		GenericData2::<Runtime>::insert(5, 5);
+		assert_eq!(Pallet::<Runtime>::generic_data2(5), Some(5));
+
+		/// Some random docs that ensure that docs are accepted
+		#[crate::storage_alias]
+		pub type GenericData<T> =
+			StorageMap<Test2, Blake2_128Concat, BlockNumberFor<T>, BlockNumberFor<T>>;
+
+		#[crate::storage_alias]
+		pub type GenericDataPallet<T: Config> =
+			StorageMap<Pallet<T>, Blake2_128Concat, BlockNumberFor<T>, BlockNumberFor<T>>;
+	});
+}
+
+#[test]
+fn storage_value_mutate_exists_should_work() {
+	new_test_ext().execute_with(|| {
+		#[crate::storage_alias]
+		pub type Value = StorageValue<Test, u32>;
+
+		assert!(!Value::exists());
+
+		Value::mutate_exists(|v| *v = Some(1));
+		assert!(Value::exists());
+		assert_eq!(Value::get(), Some(1));
+
+		// removed if mutated to `None`
+		Value::mutate_exists(|v| *v = None);
+		assert!(!Value::exists());
+	});
+}
+
+#[test]
+fn storage_value_try_mutate_exists_should_work() {
+	new_test_ext().execute_with(|| {
+		#[crate::storage_alias]
+		pub type Value = StorageValue<Test, u32>;
+
+		type TestResult = std::result::Result<(), &'static str>;
+
+		assert!(!Value::exists());
+
+		// mutated if `Ok`
+		assert_ok!(Value::try_mutate_exists(|v| -> TestResult {
+			*v = Some(1);
+			Ok(())
+		}));
+		assert!(Value::exists());
+		assert_eq!(Value::get(), Some(1));
+
+		// no-op if `Err`
+		assert_noop!(
+			Value::try_mutate_exists(|v| -> TestResult {
+				*v = Some(2);
+				Err("nah")
+			}),
+			"nah"
+		);
+		assert_eq!(Value::get(), Some(1));
+
+		// removed if mutated to`None`
+		assert_ok!(Value::try_mutate_exists(|v| -> TestResult {
+			*v = None;
+			Ok(())
+		}));
+		assert!(!Value::exists());
+	});
+}
+
+#[docify::export]
+#[test]
+fn verbatim_attribute() {
+	new_test_ext().execute_with(|| {
+		// Declare the alias that will use the verbatim identifier as prefix.
+		#[crate::storage_alias(verbatim)]
+		pub type Value = StorageValue<Test, u32>;
+
+		// Check that it works as expected.
+		Value::put(1);
+		assert_eq!(1, Value::get().unwrap());
+
+		// The prefix is the one we declared above.
+		assert_eq!(&b"Test"[..], Value::module_prefix());
+	});
+}
+
+#[docify::export]
+#[test]
+fn pallet_name_attribute() {
+	new_test_ext().execute_with(|| {
+		// Declare the alias that will use the pallet name as prefix.
+		#[crate::storage_alias(pallet_name)]
+		pub type Value<T: Config> = StorageValue<Pallet<T>, u32>;
+
+		// Check that it works as expected.
+		Value::<Runtime>::put(1);
+		assert_eq!(1, Value::<Runtime>::get().unwrap());
+
+		// The prefix is the pallet name. In this case the pallet name is `System` as declared in
+		// `construct_runtime!`.
+		assert_eq!(&b"System"[..], Value::<Runtime>::module_prefix());
+	});
+}
+
+#[docify::export]
+#[test]
+fn dynamic_attribute() {
+	new_test_ext().execute_with(|| {
+		// First let's declare our prefix.
+		//
+		// It could be any type that, as long as it implements `Get<&'static str>`.
+		parameter_types! {
+			pub Prefix: &'static str = "Hello";
+		}
+
+		// Declare the alias that will use the dynamic `Get` as prefix.
+		#[crate::storage_alias(dynamic)]
+		pub type Value<T: Get<&'static str>> = StorageValue<T, u32>;
+
+		// Check that it works as expected.
+		Value::<Prefix>::put(1);
+		assert_eq!(1, Value::<Prefix>::get().unwrap());
+
+		// The prefix is the one we declared above.
+		assert_eq!(&b"Hello"[..], Value::<Prefix>::module_prefix());
+	});
+}
+
+#[docify::export]
+#[test]
+fn storage_alias_guess() {
+	new_test_ext().execute_with(|| {
+		// The macro will use `Test` as prefix.
+		#[crate::storage_alias]
+		pub type Value = StorageValue<Test, u32>;
+
+		assert_eq!(&b"Test"[..], Value::module_prefix());
+
+		// The macro will use the pallet name as prefix.
+		#[crate::storage_alias]
+		pub type PalletValue<T: Config> = StorageValue<Pallet<T>, u32>;
+
+		assert_eq!(&b"System"[..], PalletValue::<Runtime>::module_prefix());
+	});
+}
+
+#[test]
+fn dynamic_attribute_without_generics_works() {
+	new_test_ext().execute_with(|| {
+		parameter_types! {
+			pub Prefix: &'static str = "Hello";
+		}
+
+		#[crate::storage_alias(dynamic)]
+		pub type Value = StorageValue<Prefix, u32>;
+
+		Value::put(1);
+		assert_eq!(1, Value::get().unwrap())
+	});
+}
diff --git a/substrate/frame/support/src/traits.rs b/substrate/frame/support/src/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f669046f858f44d8013311abdf778b4f7be56d49
--- /dev/null
+++ b/substrate/frame/support/src/traits.rs
@@ -0,0 +1,128 @@
+// 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.
+
+//! Traits and associated utilities for use in the FRAME environment.
+//!
+//! NOTE: If you're looking for `parameter_types`, it has moved in to the top-level module.
+
+pub mod tokens;
+pub use tokens::{
+	currency::{
+		ActiveIssuanceOf, Currency, LockIdentifier, LockableCurrency, NamedReservableCurrency,
+		ReservableCurrency, TotalIssuanceOf, VestingSchedule,
+	},
+	fungible, fungibles,
+	imbalance::{Imbalance, OnUnbalanced, SignedImbalance},
+	nonfungible, nonfungibles, BalanceStatus, ExistenceRequirement, Locker, WithdrawReasons,
+};
+
+mod members;
+#[allow(deprecated)]
+pub use members::{AllowAll, DenyAll, Filter};
+pub use members::{
+	AsContains, ChangeMembers, Contains, ContainsLengthBound, ContainsPair, Everything,
+	EverythingBut, FromContainsPair, InitializeMembers, InsideBoth, IsInVec, Nothing,
+	RankedMembers, SortedMembers, TheseExcept,
+};
+
+mod validation;
+pub use validation::{
+	DisabledValidators, EstimateNextNewSession, EstimateNextSessionRotation, FindAuthor,
+	KeyOwnerProofSystem, Lateness, OneSessionHandler, ValidatorRegistration, ValidatorSet,
+	ValidatorSetWithIdentification, VerifySeal,
+};
+
+mod error;
+pub use error::PalletError;
+
+mod filter;
+pub use filter::{ClearFilterGuard, FilterStack, FilterStackGuard, InstanceFilter};
+
+mod misc;
+pub use misc::{
+	defensive_prelude::{self, *},
+	AccountTouch, Backing, ConstBool, ConstI128, ConstI16, ConstI32, ConstI64, ConstI8, ConstU128,
+	ConstU16, ConstU32, ConstU64, ConstU8, DefensiveMax, DefensiveMin, DefensiveSaturating,
+	DefensiveTruncateFrom, EnsureInherentsAreFirst, EqualPrivilegeOnly, EstimateCallFee,
+	ExecuteBlock, ExtrinsicCall, Get, GetBacking, GetDefault, HandleLifetime, IsSubType, IsType,
+	Len, OffchainWorker, OnKilledAccount, OnNewAccount, PrivilegeCmp, SameOrOther, Time,
+	TryCollect, TryDrop, TypedGet, UnixTime, WrapperKeepOpaque, WrapperOpaque,
+};
+#[allow(deprecated)]
+pub use misc::{PreimageProvider, PreimageRecipient};
+#[doc(hidden)]
+pub use misc::{DEFENSIVE_OP_INTERNAL_ERROR, DEFENSIVE_OP_PUBLIC_ERROR};
+
+mod stored_map;
+pub use stored_map::{StorageMapShim, StoredMap};
+mod randomness;
+pub use randomness::Randomness;
+
+mod metadata;
+pub use metadata::{
+	CallMetadata, CrateVersion, GetCallIndex, GetCallMetadata, GetCallName, GetStorageVersion,
+	NoStorageVersionSet, PalletInfo, PalletInfoAccess, PalletInfoData, PalletsInfoAccess,
+	StorageVersion, STORAGE_VERSION_STORAGE_KEY_POSTFIX,
+};
+
+mod hooks;
+#[allow(deprecated)]
+pub use hooks::GenesisBuild;
+pub use hooks::{
+	BuildGenesisConfig, Hooks, IntegrityTest, OnFinalize, OnGenesis, OnIdle, OnInitialize,
+	OnRuntimeUpgrade, OnTimestampSet,
+};
+
+pub mod schedule;
+mod storage;
+pub use storage::{
+	Incrementable, Instance, PartialStorageInfoTrait, StorageInfo, StorageInfoTrait,
+	StorageInstance, TrackedStorageKey, WhitelistedStorageKeys,
+};
+
+mod dispatch;
+#[allow(deprecated)]
+pub use dispatch::EnsureOneOf;
+pub use dispatch::{
+	AsEnsureOriginWithArg, CallerTrait, EitherOf, EitherOfDiverse, EnsureOrigin,
+	EnsureOriginEqualOrHigherPrivilege, EnsureOriginWithArg, MapSuccess, NeverEnsureOrigin,
+	OriginTrait, TryMapSuccess, TryWithMorphedArg, UnfilteredDispatchable,
+};
+
+mod voting;
+pub use voting::{ClassCountOf, PollStatus, Polling, VoteTally};
+
+mod preimages;
+pub use preimages::{Bounded, BoundedInline, FetchResult, Hash, QueryPreimage, StorePreimage};
+
+mod messages;
+pub use messages::{
+	EnqueueMessage, EnqueueWithOrigin, ExecuteOverweightError, Footprint, HandleMessage,
+	NoopServiceQueues, ProcessMessage, ProcessMessageError, QueuePausedQuery, ServiceQueues,
+	TransformOrigin,
+};
+
+mod safe_mode;
+pub use safe_mode::{SafeMode, SafeModeError, SafeModeNotify};
+
+mod tx_pause;
+pub use tx_pause::{TransactionPause, TransactionPauseError};
+
+#[cfg(feature = "try-runtime")]
+mod try_runtime;
+#[cfg(feature = "try-runtime")]
+pub use try_runtime::{Select as TryStateSelect, TryState, UpgradeCheckSelect};
diff --git a/substrate/frame/support/src/traits/dispatch.rs b/substrate/frame/support/src/traits/dispatch.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d0cedb708cf1d7c24d1d0a6be3ee5596a4c2df10
--- /dev/null
+++ b/substrate/frame/support/src/traits/dispatch.rs
@@ -0,0 +1,623 @@
+// 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.
+
+//! Traits for dealing with dispatching calls and the origin from which they are dispatched.
+
+use crate::dispatch::{DispatchResultWithPostInfo, Parameter, RawOrigin};
+use codec::MaxEncodedLen;
+use sp_runtime::{
+	traits::{BadOrigin, Get, Member, Morph, TryMorph},
+	Either,
+};
+use sp_std::{cmp::Ordering, marker::PhantomData};
+
+use super::misc;
+
+/// Some sort of check on the origin is performed by this object.
+pub trait EnsureOrigin<OuterOrigin> {
+	/// A return type.
+	type Success;
+
+	/// Perform the origin check.
+	fn ensure_origin(o: OuterOrigin) -> Result<Self::Success, BadOrigin> {
+		Self::try_origin(o).map_err(|_| BadOrigin)
+	}
+
+	/// The same as `ensure_origin` except that Root origin will always pass. This can only be
+	/// used if `Success` has a sensible impl of `Default` since that will be used in the result.
+	fn ensure_origin_or_root(o: OuterOrigin) -> Result<Option<Self::Success>, BadOrigin>
+	where
+		OuterOrigin: OriginTrait,
+	{
+		if o.caller().is_root() {
+			return Ok(None)
+		} else {
+			Self::ensure_origin(o).map(Some)
+		}
+	}
+
+	/// Perform the origin check.
+	fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin>;
+
+	/// The same as `try_origin` except that Root origin will always pass. This can only be
+	/// used if `Success` has a sensible impl of `Default` since that will be used in the result.
+	fn try_origin_or_root(o: OuterOrigin) -> Result<Option<Self::Success>, OuterOrigin>
+	where
+		OuterOrigin: OriginTrait,
+	{
+		if o.caller().is_root() {
+			return Ok(None)
+		} else {
+			Self::try_origin(o).map(Some)
+		}
+	}
+
+	/// Attempt to get an outer origin capable of passing `try_origin` check. May return `Err` if it
+	/// is impossible.
+	///
+	/// ** Should be used for benchmarking only!!! **
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<OuterOrigin, ()>;
+}
+
+/// [`EnsureOrigin`] implementation that checks that an origin has equal or higher privilege
+/// compared to the expected `Origin`.
+///
+/// It will take the shortcut of comparing the incoming origin with the expected `Origin` and if
+/// both are the same the origin is accepted.
+///
+/// # Example
+///
+/// ```rust
+/// # use frame_support::traits::{EnsureOriginEqualOrHigherPrivilege, PrivilegeCmp, EnsureOrigin as _};
+/// # use sp_runtime::traits::{parameter_types, Get};
+/// # use sp_std::cmp::Ordering;
+///
+/// #[derive(Eq, PartialEq, Debug)]
+/// pub enum Origin {
+///     Root,
+///     SomethingBelowRoot,
+///     NormalUser,
+/// }
+///
+/// struct OriginPrivilegeCmp;
+///
+/// impl PrivilegeCmp<Origin> for OriginPrivilegeCmp {
+///     fn cmp_privilege(left: &Origin, right: &Origin) -> Option<Ordering> {
+///         match (left, right) {
+///             (Origin::Root, Origin::Root) => Some(Ordering::Equal),
+///             (Origin::Root, _) => Some(Ordering::Greater),
+///             (Origin::SomethingBelowRoot, Origin::SomethingBelowRoot) => Some(Ordering::Equal),
+///             (Origin::SomethingBelowRoot, Origin::Root) => Some(Ordering::Less),
+///             (Origin::SomethingBelowRoot, Origin::NormalUser) => Some(Ordering::Greater),
+///             (Origin::NormalUser, Origin::NormalUser) => Some(Ordering::Equal),
+///             (Origin::NormalUser, _) => Some(Ordering::Less),
+///         }
+///     }
+/// }
+///
+/// parameter_types! {
+///     pub const ExpectedOrigin: Origin = Origin::SomethingBelowRoot;
+/// }
+///
+/// type EnsureOrigin = EnsureOriginEqualOrHigherPrivilege<ExpectedOrigin, OriginPrivilegeCmp>;
+///
+/// // `Root` has an higher privilege as our expected origin.
+/// assert!(EnsureOrigin::ensure_origin(Origin::Root).is_ok());
+/// // `SomethingBelowRoot` is exactly the expected origin.
+/// assert!(EnsureOrigin::ensure_origin(Origin::SomethingBelowRoot).is_ok());
+/// // The `NormalUser` origin is not allowed.
+/// assert!(EnsureOrigin::ensure_origin(Origin::NormalUser).is_err());
+/// ```
+pub struct EnsureOriginEqualOrHigherPrivilege<Origin, PrivilegeCmp>(
+	sp_std::marker::PhantomData<(Origin, PrivilegeCmp)>,
+);
+
+impl<OuterOrigin, Origin, PrivilegeCmp> EnsureOrigin<OuterOrigin>
+	for EnsureOriginEqualOrHigherPrivilege<Origin, PrivilegeCmp>
+where
+	Origin: Get<OuterOrigin>,
+	OuterOrigin: Eq,
+	PrivilegeCmp: misc::PrivilegeCmp<OuterOrigin>,
+{
+	type Success = ();
+
+	fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin> {
+		let expected_origin = Origin::get();
+
+		// If this is the expected origin, it has the same privilege.
+		if o == expected_origin {
+			return Ok(())
+		}
+
+		let cmp = PrivilegeCmp::cmp_privilege(&o, &expected_origin);
+
+		match cmp {
+			Some(Ordering::Equal) | Some(Ordering::Greater) => Ok(()),
+			None | Some(Ordering::Less) => Err(o),
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<OuterOrigin, ()> {
+		Ok(Origin::get())
+	}
+}
+
+/// Some sort of check on the origin is performed by this object.
+pub trait EnsureOriginWithArg<OuterOrigin, Argument> {
+	/// A return type.
+	type Success;
+
+	/// Perform the origin check.
+	fn ensure_origin(o: OuterOrigin, a: &Argument) -> Result<Self::Success, BadOrigin> {
+		Self::try_origin(o, a).map_err(|_| BadOrigin)
+	}
+
+	/// Perform the origin check, returning the origin value if unsuccessful. This allows chaining.
+	fn try_origin(o: OuterOrigin, a: &Argument) -> Result<Self::Success, OuterOrigin>;
+
+	/// Attempt to get an outer origin capable of passing `try_origin` check. May return `Err` if it
+	/// is impossible.
+	///
+	/// ** Should be used for benchmarking only!!! **
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(a: &Argument) -> Result<OuterOrigin, ()>;
+}
+
+/// Simple macro to explicitly implement [EnsureOriginWithArg] to be used on any type which
+/// implements [EnsureOrigin]. This is quick and dirty, so you must use the type parameters `O`
+/// (the origin type), `T` (the argument type) and `AccountId` (if you are using the `O: ..` form).
+///
+/// The argument is ignored, much like in [AsEnsureOriginWithArg].
+#[macro_export]
+macro_rules! impl_ensure_origin_with_arg_ignoring_arg {
+	( impl < { O: .., I: 'static, $( $bound:tt )* }> EnsureOriginWithArg<O, $t_param:ty> for $name:ty {} ) => {
+		impl_ensure_origin_with_arg_ignoring_arg! {
+			impl <{
+				O: Into<Result<RawOrigin<AccountId, I>, O>> + From<RawOrigin<AccountId, I>>,
+				I: 'static,
+				$( $bound )*
+			}> EnsureOriginWithArg<O, $t_param> for $name {}
+		}
+	};
+	( impl < { O: .. , $( $bound:tt )* }> EnsureOriginWithArg<O, $t_param:ty> for $name:ty {} ) => {
+		impl_ensure_origin_with_arg_ignoring_arg! {
+			impl <{
+				O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>,
+				$( $bound )*
+			}> EnsureOriginWithArg<O, $t_param> for $name {}
+		}
+	};
+	( impl < { $( $bound:tt )* } > EnsureOriginWithArg<$o_param:ty, $t_param:ty> for $name:ty {} ) => {
+		impl < $( $bound )* > EnsureOriginWithArg<$o_param, $t_param> for $name {
+			type Success = <Self as EnsureOrigin<$o_param>>::Success;
+			fn try_origin(o: $o_param, _: &$t_param) -> Result<Self::Success, $o_param> {
+				<Self as EnsureOrigin<$o_param>>::try_origin(o)
+			}
+			#[cfg(feature = "runtime-benchmarks")]
+			fn try_successful_origin(_: &$t_param) -> Result<$o_param, ()> {
+				<Self as EnsureOrigin<$o_param>>::try_successful_origin()
+			}
+		}
+	}
+}
+
+/// [`EnsureOrigin`] implementation that always fails.
+pub struct NeverEnsureOrigin<Success>(sp_std::marker::PhantomData<Success>);
+impl<OO, Success> EnsureOrigin<OO> for NeverEnsureOrigin<Success> {
+	type Success = Success;
+	fn try_origin(o: OO) -> Result<Success, OO> {
+		Err(o)
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<OO, ()> {
+		Err(())
+	}
+}
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl<{ OO, Success, A }>
+		EnsureOriginWithArg<OO, A> for NeverEnsureOrigin<Success>
+	{}
+}
+
+pub struct AsEnsureOriginWithArg<EO>(sp_std::marker::PhantomData<EO>);
+impl<OuterOrigin, Argument, EO: EnsureOrigin<OuterOrigin>>
+	EnsureOriginWithArg<OuterOrigin, Argument> for AsEnsureOriginWithArg<EO>
+{
+	/// A return type.
+	type Success = EO::Success;
+
+	/// Perform the origin check.
+	fn ensure_origin(o: OuterOrigin, _: &Argument) -> Result<Self::Success, BadOrigin> {
+		EO::ensure_origin(o)
+	}
+
+	/// Perform the origin check, returning the origin value if unsuccessful. This allows chaining.
+	fn try_origin(o: OuterOrigin, _: &Argument) -> Result<Self::Success, OuterOrigin> {
+		EO::try_origin(o)
+	}
+
+	/// Returns an outer origin capable of passing `try_origin` check.
+	///
+	/// ** Should be used for benchmarking only!!! **
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(_: &Argument) -> Result<OuterOrigin, ()> {
+		EO::try_successful_origin()
+	}
+}
+
+/// A derivative `EnsureOrigin` implementation. It mutates the `Success` result of an `Original`
+/// implementation with a given `Mutator`.
+pub struct MapSuccess<Original, Mutator>(PhantomData<(Original, Mutator)>);
+impl<O, Original: EnsureOrigin<O>, Mutator: Morph<Original::Success>> EnsureOrigin<O>
+	for MapSuccess<Original, Mutator>
+{
+	type Success = Mutator::Outcome;
+	fn try_origin(o: O) -> Result<Mutator::Outcome, O> {
+		Ok(Mutator::morph(Original::try_origin(o)?))
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Original::try_successful_origin()
+	}
+}
+impl<O, Original: EnsureOriginWithArg<O, A>, Mutator: Morph<Original::Success>, A>
+	EnsureOriginWithArg<O, A> for MapSuccess<Original, Mutator>
+{
+	type Success = Mutator::Outcome;
+	fn try_origin(o: O, a: &A) -> Result<Mutator::Outcome, O> {
+		Ok(Mutator::morph(Original::try_origin(o, a)?))
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(a: &A) -> Result<O, ()> {
+		Original::try_successful_origin(a)
+	}
+}
+
+/// A derivative `EnsureOrigin` implementation. It mutates the `Success` result of an `Original`
+/// implementation with a given `Mutator`, allowing the possibility of an error to be returned
+/// from the mutator.
+///
+/// NOTE: This is strictly worse performance than `MapSuccess` since it clones the original origin
+/// value. If possible, use `MapSuccess` instead.
+pub struct TryMapSuccess<Orig, Mutator>(PhantomData<(Orig, Mutator)>);
+impl<O: Clone, Original: EnsureOrigin<O>, Mutator: TryMorph<Original::Success>> EnsureOrigin<O>
+	for TryMapSuccess<Original, Mutator>
+{
+	type Success = Mutator::Outcome;
+	fn try_origin(o: O) -> Result<Mutator::Outcome, O> {
+		let orig = o.clone();
+		Mutator::try_morph(Original::try_origin(o)?).map_err(|()| orig)
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Original::try_successful_origin()
+	}
+}
+impl<O: Clone, Original: EnsureOriginWithArg<O, A>, Mutator: TryMorph<Original::Success>, A>
+	EnsureOriginWithArg<O, A> for TryMapSuccess<Original, Mutator>
+{
+	type Success = Mutator::Outcome;
+	fn try_origin(o: O, a: &A) -> Result<Mutator::Outcome, O> {
+		let orig = o.clone();
+		Mutator::try_morph(Original::try_origin(o, a)?).map_err(|()| orig)
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(a: &A) -> Result<O, ()> {
+		Original::try_successful_origin(a)
+	}
+}
+
+pub struct TryWithMorphedArg<O, A, Morph, Inner, Success>(
+	PhantomData<(O, A, Morph, Inner, Success)>,
+);
+impl<
+		O,
+		A,
+		Morph: for<'a> TryMorph<&'a A>,
+		Inner: for<'a> EnsureOriginWithArg<O, <Morph as TryMorph<&'a A>>::Outcome, Success = Success>,
+		Success,
+	> EnsureOriginWithArg<O, A> for TryWithMorphedArg<O, A, Morph, Inner, Success>
+{
+	type Success = Success;
+	fn try_origin(o: O, a: &A) -> Result<Success, O> {
+		match Morph::try_morph(a) {
+			Ok(x) => Inner::try_origin(o, &x),
+			_ => return Err(o),
+		}
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(a: &A) -> Result<O, ()> {
+		Inner::try_successful_origin(&Morph::try_morph(a).map_err(|_| ())?)
+	}
+}
+
+/// "OR gate" implementation of `EnsureOrigin` allowing for different `Success` types for `L`
+/// and `R`, with them combined using an `Either` type.
+///
+/// Origin check will pass if `L` or `R` origin check passes. `L` is tested first.
+///
+/// Successful origin is derived from the left side.
+pub struct EitherOfDiverse<L, R>(sp_std::marker::PhantomData<(L, R)>);
+impl<OuterOrigin, L: EnsureOrigin<OuterOrigin>, R: EnsureOrigin<OuterOrigin>>
+	EnsureOrigin<OuterOrigin> for EitherOfDiverse<L, R>
+{
+	type Success = Either<L::Success, R::Success>;
+	fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin> {
+		L::try_origin(o)
+			.map_or_else(|o| R::try_origin(o).map(Either::Right), |o| Ok(Either::Left(o)))
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<OuterOrigin, ()> {
+		L::try_successful_origin().or_else(|()| R::try_successful_origin())
+	}
+}
+impl<
+		OuterOrigin,
+		L: EnsureOriginWithArg<OuterOrigin, Argument>,
+		R: EnsureOriginWithArg<OuterOrigin, Argument>,
+		Argument,
+	> EnsureOriginWithArg<OuterOrigin, Argument> for EitherOfDiverse<L, R>
+{
+	type Success = Either<L::Success, R::Success>;
+	fn try_origin(o: OuterOrigin, a: &Argument) -> Result<Self::Success, OuterOrigin> {
+		L::try_origin(o, a)
+			.map_or_else(|o| R::try_origin(o, a).map(Either::Right), |o| Ok(Either::Left(o)))
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(a: &Argument) -> Result<OuterOrigin, ()> {
+		L::try_successful_origin(a).or_else(|()| R::try_successful_origin(a))
+	}
+}
+
+/// "OR gate" implementation of `EnsureOrigin` allowing for different `Success` types for `L`
+/// and `R`, with them combined using an `Either` type.
+///
+/// Origin check will pass if `L` or `R` origin check passes. `L` is tested first.
+///
+/// Successful origin is derived from the left side.
+#[deprecated = "Use `EitherOfDiverse` instead"]
+pub type EnsureOneOf<L, R> = EitherOfDiverse<L, R>;
+
+/// "OR gate" implementation of `EnsureOrigin`, `Success` type for both `L` and `R` must
+/// be equal.
+///
+/// Origin check will pass if `L` or `R` origin check passes. `L` is tested first.
+///
+/// Successful origin is derived from the left side.
+pub struct EitherOf<L, R>(sp_std::marker::PhantomData<(L, R)>);
+impl<
+		OuterOrigin,
+		L: EnsureOrigin<OuterOrigin>,
+		R: EnsureOrigin<OuterOrigin, Success = L::Success>,
+	> EnsureOrigin<OuterOrigin> for EitherOf<L, R>
+{
+	type Success = L::Success;
+	fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin> {
+		L::try_origin(o).or_else(|o| R::try_origin(o))
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<OuterOrigin, ()> {
+		L::try_successful_origin().or_else(|()| R::try_successful_origin())
+	}
+}
+impl<
+		OuterOrigin,
+		L: EnsureOriginWithArg<OuterOrigin, Argument>,
+		R: EnsureOriginWithArg<OuterOrigin, Argument, Success = L::Success>,
+		Argument,
+	> EnsureOriginWithArg<OuterOrigin, Argument> for EitherOf<L, R>
+{
+	type Success = L::Success;
+	fn try_origin(o: OuterOrigin, a: &Argument) -> Result<Self::Success, OuterOrigin> {
+		L::try_origin(o, a).or_else(|o| R::try_origin(o, a))
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin(a: &Argument) -> Result<OuterOrigin, ()> {
+		L::try_successful_origin(a).or_else(|()| R::try_successful_origin(a))
+	}
+}
+
+/// Type that can be dispatched with an origin but without checking the origin filter.
+///
+/// Implemented for pallet dispatchable type by `decl_module` and for runtime dispatchable by
+/// `construct_runtime`.
+pub trait UnfilteredDispatchable {
+	/// The origin type of the runtime, (i.e. `frame_system::Config::RuntimeOrigin`).
+	type RuntimeOrigin;
+
+	/// Dispatch this call but do not check the filter in origin.
+	fn dispatch_bypass_filter(self, origin: Self::RuntimeOrigin) -> DispatchResultWithPostInfo;
+}
+
+/// The trait implemented by the overarching enumeration of the different pallets' origins.
+/// Unlike `OriginTrait` impls, this does not include any kind of dispatch/call filter. Also, this
+/// trait is more flexible in terms of how it can be used: it is a `Parameter` and `Member`, so it
+/// can be used as dispatchable parameters as well as in storage items.
+pub trait CallerTrait<AccountId>: Parameter + Member + From<RawOrigin<AccountId>> {
+	/// Extract the signer from the message if it is a `Signed` origin.
+	fn into_system(self) -> Option<RawOrigin<AccountId>>;
+
+	/// Extract a reference to the system-level `RawOrigin` if it is that.
+	fn as_system_ref(&self) -> Option<&RawOrigin<AccountId>>;
+
+	/// Extract the signer from it if a system `Signed` origin, `None` otherwise.
+	fn as_signed(&self) -> Option<&AccountId> {
+		self.as_system_ref().and_then(RawOrigin::as_signed)
+	}
+
+	/// Returns `true` if `self` is a system `Root` origin, `None` otherwise.
+	fn is_root(&self) -> bool {
+		self.as_system_ref().map_or(false, RawOrigin::is_root)
+	}
+
+	/// Returns `true` if `self` is a system `None` origin, `None` otherwise.
+	fn is_none(&self) -> bool {
+		self.as_system_ref().map_or(false, RawOrigin::is_none)
+	}
+}
+
+/// Methods available on `frame_system::Config::RuntimeOrigin`.
+pub trait OriginTrait: Sized {
+	/// Runtime call type, as in `frame_system::Config::Call`
+	type Call;
+
+	/// The caller origin, overarching type of all pallets origins.
+	type PalletsOrigin: Into<Self> + CallerTrait<Self::AccountId> + MaxEncodedLen;
+
+	/// The AccountId used across the system.
+	type AccountId;
+
+	/// Add a filter to the origin.
+	fn add_filter(&mut self, filter: impl Fn(&Self::Call) -> bool + 'static);
+
+	/// Reset origin filters to default one, i.e `frame_system::Config::BaseCallFilter`.
+	fn reset_filter(&mut self);
+
+	/// Replace the caller with caller from the other origin
+	fn set_caller_from(&mut self, other: impl Into<Self>);
+
+	/// Filter the call if caller is not root, if false is returned then the call must be filtered
+	/// out.
+	///
+	/// For root origin caller, the filters are bypassed and true is returned.
+	fn filter_call(&self, call: &Self::Call) -> bool;
+
+	/// Get a reference to the caller (`CallerTrait` impl).
+	fn caller(&self) -> &Self::PalletsOrigin;
+
+	/// Consume `self` and return the caller.
+	fn into_caller(self) -> Self::PalletsOrigin;
+
+	/// Do something with the caller, consuming self but returning it if the caller was unused.
+	fn try_with_caller<R>(
+		self,
+		f: impl FnOnce(Self::PalletsOrigin) -> Result<R, Self::PalletsOrigin>,
+	) -> Result<R, Self>;
+
+	/// Create with system none origin and `frame_system::Config::BaseCallFilter`.
+	fn none() -> Self;
+
+	/// Create with system root origin and `frame_system::Config::BaseCallFilter`.
+	fn root() -> Self;
+
+	/// Create with system signed origin and `frame_system::Config::BaseCallFilter`.
+	fn signed(by: Self::AccountId) -> Self;
+
+	/// Extract the signer from the message if it is a `Signed` origin.
+	#[deprecated = "Use `into_signer` instead"]
+	fn as_signed(self) -> Option<Self::AccountId> {
+		self.into_signer()
+	}
+
+	/// Extract the signer from the message if it is a `Signed` origin.
+	fn into_signer(self) -> Option<Self::AccountId> {
+		self.into_caller().into_system().and_then(|s| {
+			if let RawOrigin::Signed(who) = s {
+				Some(who)
+			} else {
+				None
+			}
+		})
+	}
+
+	/// Extract a reference to the sytsem origin, if that's what the caller is.
+	fn as_system_ref(&self) -> Option<&RawOrigin<Self::AccountId>> {
+		self.caller().as_system_ref()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::traits::{ConstBool, ConstU8, TypedGet};
+	use std::marker::PhantomData;
+
+	struct EnsureSuccess<V>(PhantomData<V>);
+	struct EnsureFail<T>(PhantomData<T>);
+
+	impl<V: TypedGet> EnsureOrigin<()> for EnsureSuccess<V> {
+		type Success = V::Type;
+		fn try_origin(_: ()) -> Result<Self::Success, ()> {
+			Ok(V::get())
+		}
+		#[cfg(feature = "runtime-benchmarks")]
+		fn try_successful_origin() -> Result<(), ()> {
+			Ok(())
+		}
+	}
+
+	impl<T> EnsureOrigin<()> for EnsureFail<T> {
+		type Success = T;
+		fn try_origin(_: ()) -> Result<Self::Success, ()> {
+			Err(())
+		}
+		#[cfg(feature = "runtime-benchmarks")]
+		fn try_successful_origin() -> Result<(), ()> {
+			Err(())
+		}
+	}
+
+	#[test]
+	fn either_of_diverse_works() {
+		assert_eq!(
+			EitherOfDiverse::<
+				EnsureSuccess<ConstBool<true>>,
+				EnsureSuccess<ConstU8<0>>,
+			>::try_origin(()).unwrap().left(),
+			Some(true)
+		);
+		assert_eq!(
+			EitherOfDiverse::<EnsureSuccess<ConstBool<true>>, EnsureFail<u8>>::try_origin(())
+				.unwrap()
+				.left(),
+			Some(true)
+		);
+		assert_eq!(
+			EitherOfDiverse::<EnsureFail<bool>, EnsureSuccess<ConstU8<0>>>::try_origin(())
+				.unwrap()
+				.right(),
+			Some(0u8)
+		);
+		assert!(EitherOfDiverse::<EnsureFail<bool>, EnsureFail<u8>>::try_origin(()).is_err());
+	}
+
+	#[test]
+	fn either_of_works() {
+		assert_eq!(
+			EitherOf::<
+				EnsureSuccess<ConstBool<true>>,
+				EnsureSuccess<ConstBool<false>>,
+			>::try_origin(()).unwrap(),
+			true
+		);
+		assert_eq!(
+			EitherOf::<EnsureSuccess<ConstBool<true>>, EnsureFail<bool>>::try_origin(()).unwrap(),
+			true
+		);
+		assert_eq!(
+			EitherOf::<EnsureFail<bool>, EnsureSuccess<ConstBool<false>>>::try_origin(()).unwrap(),
+			false
+		);
+		assert!(EitherOf::<EnsureFail<bool>, EnsureFail<bool>>::try_origin(()).is_err());
+	}
+}
diff --git a/substrate/frame/support/src/traits/error.rs b/substrate/frame/support/src/traits/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0f30e266da2dffebef980088e332b312187081ab
--- /dev/null
+++ b/substrate/frame/support/src/traits/error.rs
@@ -0,0 +1,95 @@
+// 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.
+
+//! Traits for describing and constraining pallet error types.
+use codec::{Compact, Decode, Encode};
+use sp_std::marker::PhantomData;
+
+/// Trait indicating that the implementing type is going to be included as a field in a variant of
+/// the `#[pallet::error]` enum type.
+///
+/// ## Notes
+///
+/// The pallet error enum has a maximum encoded size as defined by
+/// [`frame_support::MAX_MODULE_ERROR_ENCODED_SIZE`]. If the pallet error type exceeds this size
+/// limit, a static assertion during compilation will fail. The compilation error will be in the
+/// format of `error[E0080]: evaluation of constant value failed` due to the usage of
+/// const assertions.
+pub trait PalletError: Encode + Decode {
+	/// The maximum encoded size for the implementing type.
+	///
+	/// This will be used to check whether the pallet error type is less than or equal to
+	/// [`frame_support::MAX_MODULE_ERROR_ENCODED_SIZE`], and if it is, a compilation error will be
+	/// thrown.
+	const MAX_ENCODED_SIZE: usize;
+}
+
+macro_rules! impl_for_types {
+	(size: $size:expr, $($typ:ty),+) => {
+		$(
+			impl PalletError for $typ {
+				const MAX_ENCODED_SIZE: usize = $size;
+			}
+		)+
+	};
+}
+
+impl_for_types!(size: 0, (), crate::Never);
+impl_for_types!(size: 1, u8, i8, bool);
+impl_for_types!(size: 2, u16, i16, Compact<u8>);
+impl_for_types!(size: 4, u32, i32, Compact<u16>);
+impl_for_types!(size: 5, Compact<u32>);
+impl_for_types!(size: 8, u64, i64);
+impl_for_types!(size: 9, Compact<u64>);
+// Contains a u64 for secs and u32 for nanos, hence 12 bytes
+impl_for_types!(size: 12, core::time::Duration);
+impl_for_types!(size: 16, u128, i128);
+impl_for_types!(size: 17, Compact<u128>);
+
+impl<T> PalletError for PhantomData<T> {
+	const MAX_ENCODED_SIZE: usize = 0;
+}
+
+impl<T: PalletError> PalletError for core::ops::Range<T> {
+	const MAX_ENCODED_SIZE: usize = T::MAX_ENCODED_SIZE.saturating_mul(2);
+}
+
+impl<T: PalletError, const N: usize> PalletError for [T; N] {
+	const MAX_ENCODED_SIZE: usize = T::MAX_ENCODED_SIZE.saturating_mul(N);
+}
+
+impl<T: PalletError> PalletError for Option<T> {
+	const MAX_ENCODED_SIZE: usize = T::MAX_ENCODED_SIZE.saturating_add(1);
+}
+
+impl<T: PalletError, E: PalletError> PalletError for Result<T, E> {
+	const MAX_ENCODED_SIZE: usize = if T::MAX_ENCODED_SIZE > E::MAX_ENCODED_SIZE {
+		T::MAX_ENCODED_SIZE
+	} else {
+		E::MAX_ENCODED_SIZE
+	}
+	.saturating_add(1);
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(1, 18)]
+impl PalletError for Tuple {
+	const MAX_ENCODED_SIZE: usize = {
+		let mut size = 0_usize;
+		for_tuples!( #(size = size.saturating_add(Tuple::MAX_ENCODED_SIZE);)* );
+		size
+	};
+}
diff --git a/substrate/frame/support/src/traits/filter.rs b/substrate/frame/support/src/traits/filter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..44f9f136cfc2a14c05d0f2a938530d8b2b597515
--- /dev/null
+++ b/substrate/frame/support/src/traits/filter.rs
@@ -0,0 +1,267 @@
+// 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.
+
+//! Traits and associated utilities for dealing with abstract constraint filters.
+
+pub use super::members::Contains;
+use sp_std::marker::PhantomData;
+
+/// Trait to add a constraint onto the filter.
+pub trait FilterStack<T>: Contains<T> {
+	/// The type used to archive the stack.
+	type Stack;
+
+	/// Add a new `constraint` onto the filter.
+	fn push(constraint: impl Fn(&T) -> bool + 'static);
+
+	/// Removes the most recently pushed, and not-yet-popped, constraint from the filter.
+	fn pop();
+
+	/// Clear the filter, returning a value that may be used later to `restore` it.
+	fn take() -> Self::Stack;
+
+	/// Restore the filter from a previous `take` operation.
+	fn restore(taken: Self::Stack);
+}
+
+/// Guard type for pushing a constraint to a `FilterStack` and popping when dropped.
+pub struct FilterStackGuard<F: FilterStack<T>, T>(PhantomData<(F, T)>);
+
+/// Guard type for clearing all pushed constraints from a `FilterStack` and reinstating them when
+/// dropped.
+pub struct ClearFilterGuard<F: FilterStack<T>, T>(Option<F::Stack>, PhantomData<T>);
+
+impl<F: FilterStack<T>, T> FilterStackGuard<F, T> {
+	/// Create a new instance, adding a new `constraint` onto the filter `T`, and popping it when
+	/// this instance is dropped.
+	pub fn new(constraint: impl Fn(&T) -> bool + 'static) -> Self {
+		F::push(constraint);
+		Self(PhantomData)
+	}
+}
+
+impl<F: FilterStack<T>, T> Drop for FilterStackGuard<F, T> {
+	fn drop(&mut self) {
+		F::pop();
+	}
+}
+
+impl<F: FilterStack<T>, T> ClearFilterGuard<F, T> {
+	/// Create a new instance, adding a new `constraint` onto the filter `T`, and popping it when
+	/// this instance is dropped.
+	pub fn new() -> Self {
+		Self(Some(F::take()), PhantomData)
+	}
+}
+
+impl<F: FilterStack<T>, T> Drop for ClearFilterGuard<F, T> {
+	fn drop(&mut self) {
+		if let Some(taken) = self.0.take() {
+			F::restore(taken);
+		}
+	}
+}
+
+/// Simple trait for providing a filter over a reference to some type, given an instance of itself.
+pub trait InstanceFilter<T>: Sized + Send + Sync {
+	/// Determine if a given value should be allowed through the filter (returns `true`) or not.
+	fn filter(&self, _: &T) -> bool;
+
+	/// Determines whether `self` matches at least everything that `_o` does.
+	fn is_superset(&self, _o: &Self) -> bool {
+		false
+	}
+}
+
+impl<T> InstanceFilter<T> for () {
+	fn filter(&self, _: &T) -> bool {
+		true
+	}
+	fn is_superset(&self, _o: &Self) -> bool {
+		true
+	}
+}
+
+#[macro_export]
+macro_rules! impl_filter_stack {
+	($target:ty, $base:ty, $call:ty, $module:ident) => {
+		#[cfg(feature = "std")]
+		mod $module {
+			#[allow(unused_imports)]
+			use super::*;
+			use $crate::__private::sp_std::{boxed::Box, cell::RefCell, mem::{swap, take}, vec::Vec};
+			use $crate::traits::filter::{Contains, FilterStack};
+
+			thread_local! {
+				static FILTER: RefCell<Vec<Box<dyn Fn(&$call) -> bool + 'static>>> = RefCell::new(Vec::new());
+			}
+
+			impl Contains<$call> for $target {
+				fn contains(call: &$call) -> bool {
+					<$base>::contains(call) &&
+						FILTER.with(|filter| filter.borrow().iter().all(|f| f(call)))
+				}
+			}
+
+			impl FilterStack<$call> for $target {
+				type Stack = Vec<Box<dyn Fn(&$call) -> bool + 'static>>;
+				fn push(f: impl Fn(&$call) -> bool + 'static) {
+					FILTER.with(|filter| filter.borrow_mut().push(Box::new(f)));
+				}
+				fn pop() {
+					FILTER.with(|filter| filter.borrow_mut().pop());
+				}
+				fn take() -> Self::Stack {
+					FILTER.with(|filter| take(filter.borrow_mut().as_mut()))
+				}
+				fn restore(mut s: Self::Stack) {
+					FILTER.with(|filter| swap(filter.borrow_mut().as_mut(), &mut s));
+				}
+			}
+		}
+
+		#[cfg(not(feature = "std"))]
+		mod $module {
+			#[allow(unused_imports)]
+			use super::*;
+			use $crate::traits::{swap, take, RefCell, Vec, Box, Contains, FilterStack};
+
+			struct ThisFilter(RefCell<Vec<Box<dyn Fn(&$call) -> bool + 'static>>>);
+			// NOTE: Safe only in wasm (guarded above) because there's only one thread.
+			unsafe impl Send for ThisFilter {}
+			unsafe impl Sync for ThisFilter {}
+
+			static FILTER: ThisFilter = ThisFilter(RefCell::new(Vec::new()));
+
+			impl Contains<$call> for $target {
+				fn contains(call: &$call) -> bool {
+					<$base>::contains(call) && FILTER.0.borrow().iter().all(|f| f(call))
+				}
+			}
+
+			impl FilterStack<$call> for $target {
+				type Stack = Vec<Box<dyn Fn(&$call) -> bool + 'static>>;
+				fn push(f: impl Fn(&$call) -> bool + 'static) {
+					FILTER.0.borrow_mut().push(Box::new(f));
+				}
+				fn pop() {
+					FILTER.0.borrow_mut().pop();
+				}
+				fn take() -> Self::Stack {
+					take(FILTER.0.borrow_mut().as_mut())
+				}
+				fn restore(mut s: Self::Stack) {
+					swap(FILTER.0.borrow_mut().as_mut(), &mut s);
+				}
+			}
+		}
+	}
+}
+
+#[cfg(test)]
+pub mod test_impl_filter_stack {
+	use super::*;
+
+	pub struct IsCallable;
+	pub struct BaseFilter;
+	impl Contains<u32> for BaseFilter {
+		fn contains(x: &u32) -> bool {
+			x % 2 == 0
+		}
+	}
+	impl_filter_stack!(
+		crate::traits::filter::test_impl_filter_stack::IsCallable,
+		crate::traits::filter::test_impl_filter_stack::BaseFilter,
+		u32,
+		is_callable
+	);
+
+	#[test]
+	fn impl_filter_stack_should_work() {
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(IsCallable::contains(&42));
+		assert!(!IsCallable::contains(&43));
+
+		IsCallable::push(|x| *x < 42);
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(!IsCallable::contains(&42));
+
+		IsCallable::push(|x| *x % 3 == 0);
+		assert!(IsCallable::contains(&36));
+		assert!(!IsCallable::contains(&40));
+
+		IsCallable::pop();
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(!IsCallable::contains(&42));
+
+		let saved = IsCallable::take();
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(IsCallable::contains(&42));
+		assert!(!IsCallable::contains(&43));
+
+		IsCallable::restore(saved);
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(!IsCallable::contains(&42));
+
+		IsCallable::pop();
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(IsCallable::contains(&42));
+		assert!(!IsCallable::contains(&43));
+	}
+
+	#[test]
+	fn guards_should_work() {
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(IsCallable::contains(&42));
+		assert!(!IsCallable::contains(&43));
+		{
+			let _guard_1 = FilterStackGuard::<IsCallable, u32>::new(|x| *x < 42);
+			assert!(IsCallable::contains(&36));
+			assert!(IsCallable::contains(&40));
+			assert!(!IsCallable::contains(&42));
+			{
+				let _guard_2 = FilterStackGuard::<IsCallable, u32>::new(|x| *x % 3 == 0);
+				assert!(IsCallable::contains(&36));
+				assert!(!IsCallable::contains(&40));
+			}
+			assert!(IsCallable::contains(&36));
+			assert!(IsCallable::contains(&40));
+			assert!(!IsCallable::contains(&42));
+			{
+				let _guard_2 = ClearFilterGuard::<IsCallable, u32>::new();
+				assert!(IsCallable::contains(&36));
+				assert!(IsCallable::contains(&40));
+				assert!(IsCallable::contains(&42));
+				assert!(!IsCallable::contains(&43));
+			}
+			assert!(IsCallable::contains(&36));
+			assert!(IsCallable::contains(&40));
+			assert!(!IsCallable::contains(&42));
+		}
+		assert!(IsCallable::contains(&36));
+		assert!(IsCallable::contains(&40));
+		assert!(IsCallable::contains(&42));
+		assert!(!IsCallable::contains(&43));
+	}
+}
diff --git a/substrate/frame/support/src/traits/hooks.rs b/substrate/frame/support/src/traits/hooks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6163c048e75d854e601aaad3e50cd89e03b38d90
--- /dev/null
+++ b/substrate/frame/support/src/traits/hooks.rs
@@ -0,0 +1,627 @@
+// 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.
+
+//! Traits relating to pallet hooks.
+//!
+//! See [`Hooks`] as the main entry-point.
+
+#![deny(missing_docs)]
+
+use crate::weights::Weight;
+use impl_trait_for_tuples::impl_for_tuples;
+use sp_runtime::traits::AtLeast32BitUnsigned;
+use sp_std::prelude::*;
+
+#[cfg(feature = "try-runtime")]
+use sp_runtime::TryRuntimeError;
+
+/// See [`Hooks::on_initialize`].
+pub trait OnInitialize<BlockNumber> {
+	/// See [`Hooks::on_initialize`].
+	fn on_initialize(_n: BlockNumber) -> Weight {
+		Weight::zero()
+	}
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl<BlockNumber: Clone> OnInitialize<BlockNumber> for Tuple {
+	fn on_initialize(n: BlockNumber) -> Weight {
+		let mut weight = Weight::zero();
+		for_tuples!( #( weight = weight.saturating_add(Tuple::on_initialize(n.clone())); )* );
+		weight
+	}
+}
+
+/// See [`Hooks::on_finalize`].
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+pub trait OnFinalize<BlockNumber> {
+	/// See [`Hooks::on_finalize`].
+	fn on_finalize(_n: BlockNumber) {}
+}
+
+/// See [`Hooks::on_idle`].
+pub trait OnIdle<BlockNumber> {
+	/// See [`Hooks::on_idle`].
+	fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight {
+		Weight::zero()
+	}
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl<BlockNumber: Copy + AtLeast32BitUnsigned> OnIdle<BlockNumber> for Tuple {
+	fn on_idle(n: BlockNumber, remaining_weight: Weight) -> Weight {
+		let on_idle_functions: &[fn(BlockNumber, Weight) -> Weight] =
+			&[for_tuples!( #( Tuple::on_idle ),* )];
+		let mut weight = Weight::zero();
+		let len = on_idle_functions.len();
+		let start_index = n % (len as u32).into();
+		let start_index = start_index.try_into().ok().expect(
+			"`start_index % len` always fits into `usize`, because `len` can be in maximum `usize::MAX`; qed"
+		);
+		for on_idle_fn in on_idle_functions.iter().cycle().skip(start_index).take(len) {
+			let adjusted_remaining_weight = remaining_weight.saturating_sub(weight);
+			weight = weight.saturating_add(on_idle_fn(n, adjusted_remaining_weight));
+		}
+		weight
+	}
+}
+
+/// A trait that will be called at genesis.
+///
+/// Implementing this trait for a pallet let's you express operations that should
+/// happen at genesis. It will be called in an externalities provided environment and
+/// will see the genesis state after all pallets have written their genesis state.
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+pub trait OnGenesis {
+	/// Something that should happen at genesis.
+	fn on_genesis() {}
+}
+
+/// See [`Hooks::on_runtime_upgrade`].
+pub trait OnRuntimeUpgrade {
+	/// See [`Hooks::on_runtime_upgrade`].
+	fn on_runtime_upgrade() -> Weight {
+		Weight::zero()
+	}
+
+	/// The expected and default behavior of this method is to handle executing `pre_upgrade` ->
+	/// `on_runtime_upgrade` -> `post_upgrade` hooks for a migration.
+	///
+	/// Internally, the default implementation
+	/// - Handles passing data from `pre_upgrade` to `post_upgrade`
+	/// - Ensure storage is not modified in `pre_upgrade` and `post_upgrade` hooks.
+	///
+	/// Combining the `pre_upgrade` -> `on_runtime_upgrade` -> `post_upgrade` logic flow into a
+	/// single method call is helpful for scenarios like testing a tuple of migrations, where the
+	/// tuple contains order-dependent migrations.
+	#[cfg(feature = "try-runtime")]
+	fn try_on_runtime_upgrade(checks: bool) -> Result<Weight, TryRuntimeError> {
+		let maybe_state = if checks {
+			let _guard = frame_support::StorageNoopGuard::default();
+			let state = Self::pre_upgrade()?;
+			Some(state)
+		} else {
+			None
+		};
+
+		let weight = Self::on_runtime_upgrade();
+
+		if let Some(state) = maybe_state {
+			let _guard = frame_support::StorageNoopGuard::default();
+			// we want to panic if any checks fail right here right now.
+			Self::post_upgrade(state)?
+		}
+
+		Ok(weight)
+	}
+
+	/// See [`Hooks::pre_upgrade`].
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		Ok(Vec::new())
+	}
+
+	/// See [`Hooks::post_upgrade`].
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		Ok(())
+	}
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl OnRuntimeUpgrade for Tuple {
+	fn on_runtime_upgrade() -> Weight {
+		let mut weight = Weight::zero();
+		for_tuples!( #( weight = weight.saturating_add(Tuple::on_runtime_upgrade()); )* );
+		weight
+	}
+
+	/// Implements the default behavior of `try_on_runtime_upgrade` for tuples, logging any errors
+	/// that occur.
+	#[cfg(feature = "try-runtime")]
+	fn try_on_runtime_upgrade(checks: bool) -> Result<Weight, TryRuntimeError> {
+		let mut cumulative_weight = Weight::zero();
+
+		let mut errors = Vec::new();
+
+		for_tuples!(#(
+			match Tuple::try_on_runtime_upgrade(checks) {
+				Ok(weight) => { cumulative_weight.saturating_accrue(weight); },
+				Err(err) => { errors.push(err); },
+			}
+		)*);
+
+		if errors.len() == 1 {
+			return Err(errors[0])
+		} else if !errors.is_empty() {
+			log::error!(
+				target: "try-runtime",
+				"Detected multiple errors while executing `try_on_runtime_upgrade`:",
+			);
+
+			errors.iter().for_each(|err| {
+				log::error!(
+					target: "try-runtime",
+					"{:?}",
+					err
+				);
+			});
+
+			return Err("Detected multiple errors while executing `try_on_runtime_upgrade`, check the logs!".into())
+		}
+
+		Ok(cumulative_weight)
+	}
+
+	/// [`OnRuntimeUpgrade::pre_upgrade`] should not be used on a tuple.
+	///
+	/// Instead, implementors should use [`OnRuntimeUpgrade::try_on_runtime_upgrade`] which
+	/// internally calls `pre_upgrade` -> `on_runtime_upgrade` -> `post_upgrade` for each tuple
+	/// member in sequence, enabling testing of order-dependent migrations.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		Err("Usage of `pre_upgrade` with Tuples is not expected. Please use `try_on_runtime_upgrade` instead, which internally calls `pre_upgrade` -> `on_runtime_upgrade` -> `post_upgrade` for each tuple member.".into())
+	}
+
+	/// [`OnRuntimeUpgrade::post_upgrade`] should not be used on a tuple.
+	///
+	/// Instead, implementors should use [`OnRuntimeUpgrade::try_on_runtime_upgrade`] which
+	/// internally calls `pre_upgrade` -> `on_runtime_upgrade` -> `post_upgrade` for each tuple
+	/// member in sequence, enabling testing of order-dependent migrations.
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		Err("Usage of `post_upgrade` with Tuples is not expected. Please use `try_on_runtime_upgrade` instead, which internally calls `pre_upgrade` -> `on_runtime_upgrade` -> `post_upgrade` for each tuple member.".into())
+	}
+}
+
+/// See [`Hooks::integrity_test`].
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+pub trait IntegrityTest {
+	/// See [`Hooks::integrity_test`].
+	fn integrity_test() {}
+}
+
+#[cfg_attr(doc, aquamarine::aquamarine)]
+/// The pallet hooks trait. This is merely an umbrella trait for:
+///
+/// - [`OnInitialize`]
+/// - [`OnFinalize`]
+/// - [`OnRuntimeUpgrade`]
+/// - [`crate::traits::misc::OffchainWorker`]
+/// - [`OnIdle`]
+/// - [`IntegrityTest`]
+///
+/// ## Ordering
+///
+/// For all hooks, except [`OnIdle`] the order of execution is derived from how the pallets are
+/// ordered in [`crate::construct_runtime`].
+///
+/// ## Summary
+///
+/// In short, the following diagram shows the flow of hooks in a pallet
+///
+/// ```mermaid
+/// graph LR
+/// 	Optional --> BeforeExtrinsics
+/// 	BeforeExtrinsics --> Extrinsics
+/// 	Extrinsics --> AfterExtrinsics
+/// 	subgraph Optional
+/// 	OnRuntimeUpgrade
+/// end
+///
+/// subgraph BeforeExtrinsics
+/// 	OnInitialize
+/// end
+///
+/// subgraph Extrinsics
+/// 	direction TB
+/// 	Inherent1
+/// 	Inherent2
+/// 	Extrinsic1
+/// 	Extrinsic2
+///
+/// 	Inherent1 --> Inherent2
+/// 	Inherent2 --> Extrinsic1
+/// 	Extrinsic1 --> Extrinsic2
+/// end
+///
+/// subgraph AfterExtrinsics
+/// 	OnIdle
+/// 	OnFinalize
+///
+/// 	OnIdle --> OnFinalize
+/// end
+/// ```
+///
+/// * `OnRuntimeUpgrade` is only executed before everything else if a code
+/// * `OnRuntimeUpgrade` is mandatorily at the beginning of the block body (extrinsics) being
+///   processed. change is detected.
+/// * Extrinsics start with inherents, and continue with other signed or unsigned extrinsics.
+/// * `OnIdle` optionally comes after extrinsics.
+/// `OnFinalize` mandatorily comes after `OnIdle`.
+///
+/// > `OffchainWorker` is not part of this flow, as it is not really part of the consensus/main
+/// > block import path, and is called optionally, and in other circumstances. See
+/// > [`crate::traits::misc::OffchainWorker`] for more information.
+///
+/// To learn more about the execution of hooks see `frame-executive` as this component is is charge
+/// of dispatching extrinsics and placing the hooks in the correct order.
+pub trait Hooks<BlockNumber> {
+	/// Block initialization hook. This is called at the very beginning of block execution.
+	///
+	/// Must return the non-negotiable weight of both itself and whatever [`Hooks::on_finalize`]
+	/// wishes to consume.
+	///
+	/// ## Warning
+	///
+	/// The weight returned by this is treated as `DispatchClass::Mandatory`, meaning that
+	/// it MUST BE EXECUTED. If this is not the case, consider using [`Hooks::on_idle`] instead.
+	///
+	/// Try to keep any arbitrary execution __deterministic__ and within __minimal__ time
+	/// complexity. For example, do not execute any unbounded iterations.
+	///
+	/// NOTE: This function is called BEFORE ANY extrinsic in a block is applied, including inherent
+	/// extrinsics. Hence for instance, if you runtime includes `pallet-timestamp`, the `timestamp`
+	/// is not yet up to date at this point.
+	fn on_initialize(_n: BlockNumber) -> Weight {
+		Weight::zero()
+	}
+
+	/// Block finalization hook. This is called at the very end of block execution.
+	///
+	/// Note that this has nothing to do with finality in the "consensus" sense.
+	///
+	/// Note that the non-negotiable weight for this has must have already been returned by
+	/// [`Hooks::on_initialize`]. It usage alone is not permitted.
+	///
+	/// Similar to [`Hooks::on_initialize`] it should only be used when execution is absolutely
+	/// necessary. In other cases, consider using [`Hooks::on_idle`] instead.
+	fn on_finalize(_n: BlockNumber) {}
+
+	/// Hook to consume a block's idle time. This will run when the block is being finalized (before
+	/// [`Hooks::on_finalize`]).
+	///
+	/// Given that all dispatchables are already executed and noted (and the weight for
+	/// [`Hooks::on_finalize`], which comes next, is also already accounted for via
+	/// `on_initialize`), this hook consumes anything that is leftover.
+	///
+	/// Each pallet's `on_idle` is chosen to be the first to execute in a round-robin fashion
+	/// indexed by the block number.
+	///
+	/// Return the weight used, the caller will use this to calculate the remaining weight and then
+	/// call the next pallet `on_idle` hook if there is still weight left.
+	///
+	/// Any implementation should always respect `_remaining_weight` and never consume (and
+	/// therefore return) more than this amount.
+	fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight {
+		Weight::zero()
+	}
+
+	/// Hook executed when a code change (aka. a "runtime upgrade") is detected by FRAME.
+	///
+	/// Be aware that this is called before [`Hooks::on_initialize`] of any pallet; therefore, a lot
+	/// of the critical storage items such as `block_number` in system pallet might have not been
+	/// set.
+	///
+	/// Vert similar to [`Hooks::on_initialize`], any code in this block is mandatory and MUST
+	/// execute. Use with care.
+	///
+	/// ## Implementation Note: Versioning
+	///
+	/// 1. An implementation of this should typically follow a pattern where the version of the
+	/// pallet is checked against the onchain version, and a decision is made about what needs to be
+	/// done. This is helpful to prevent accidental repetitive execution of this hook, which can be
+	/// catastrophic.
+	///
+	/// Alternatively, `migrations::VersionedRuntimeUpgrade` can be used to assist with
+	/// this.
+	///
+	/// ## Implementation Note: Runtime Level Migration
+	///
+	/// Additional "upgrade hooks" can be created by pallets by a manual implementation of
+	/// [`Hooks::on_runtime_upgrade`] which can be passed on to `Executive` at the top level
+	/// runtime.
+	fn on_runtime_upgrade() -> Weight {
+		Weight::zero()
+	}
+
+	/// Execute the sanity checks of this pallet, per block.
+	///
+	/// It should focus on certain checks to ensure that the state is sensible. This is never
+	/// executed in a consensus code-path, therefore it can consume as much weight as it needs.
+	///
+	/// This hook should not alter any storage.
+	#[cfg(feature = "try-runtime")]
+	fn try_state(_n: BlockNumber) -> Result<(), TryRuntimeError> {
+		Ok(())
+	}
+
+	/// Execute some pre-checks prior to a runtime upgrade.
+	///
+	/// Return a `Vec<u8>` that can contain arbitrary encoded data (usually some pre-upgrade state),
+	/// which will be passed to `post_upgrade` after upgrading for post-check. An empty vector
+	/// should be returned if there is no such need.
+	///
+	/// This hook is never meant to be executed on-chain but is meant to be used by testing tools.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+		Ok(Vec::new())
+	}
+
+	/// Execute some post-checks after a runtime upgrade.
+	///
+	/// The `state` parameter is the `Vec<u8>` returned by `pre_upgrade` before upgrading, which
+	/// can be used for post-check. NOTE: if `pre_upgrade` is not implemented an empty vector will
+	/// be passed in, in such case `post_upgrade` should ignore it.
+	///
+	/// This hook is never meant to be executed on-chain but is meant to be used by testing tools.
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(_state: Vec<u8>) -> Result<(), TryRuntimeError> {
+		Ok(())
+	}
+
+	/// Implementing this function on a pallet allows you to perform long-running tasks that are
+	/// dispatched as separate threads, and entirely independent of the main wasm runtime.
+	///
+	/// This function can freely read from the state, but any change it makes to the state is
+	/// meaningless. Writes can be pushed back to the chain by submitting extrinsics from the
+	/// offchain worker to the transaction pool. See `pallet-example-offchain-worker` for more
+	/// details on this.
+	///
+	/// Moreover, the code in this function has access to a wider range of host functions in
+	/// [`sp-io`], namely [`sp_io::offchain`]. This includes exotic operations such as HTTP calls
+	/// that are not really possible in the rest of the runtime code.
+	///
+	/// The execution of this hook is entirely optional and is left at the discretion of the
+	/// node-side software and its configuration. In a normal substrate-cli, look for the CLI
+	/// flags related to offchain-workers to learn more.
+	fn offchain_worker(_n: BlockNumber) {}
+
+	/// Check the integrity of this pallet's configuration.
+	///
+	/// Any code located in this hook is placed in an auto-generated test, and generated as a part
+	/// of [`crate::construct_runtime`]'s expansion. Look for a test case with a name along the
+	/// lines of: `__construct_runtime_integrity_test`.
+	///
+	/// This hook is the location where the values/types provided to the `Config` trait
+	/// of the pallet can be tested for correctness. For example, if two `type Foo: Get<u32>` and
+	/// `type Bar: Get<u32>` where `Foo::get()` must always be greater than `Bar::get()`, such
+	/// checks can be asserted upon here.
+	///
+	/// Note that this hook is executed in an externality environment, provided by
+	/// `sp_io::TestExternalities`. This makes it possible to access the storage.
+	fn integrity_test() {}
+}
+
+/// A trait to define the build function of a genesis config for both runtime and pallets.
+///
+/// Replaces deprecated [`GenesisBuild<T,I>`].
+pub trait BuildGenesisConfig: Default + sp_runtime::traits::MaybeSerializeDeserialize {
+	/// The build function puts initial `GenesisConfig` keys/values pairs into the storage.
+	fn build(&self);
+}
+
+/// A trait to define the build function of a genesis config, T and I are placeholder for pallet
+/// trait and pallet instance.
+#[deprecated(
+	note = "GenesisBuild is planned to be removed in December 2023. Use BuildGenesisConfig instead of it."
+)]
+pub trait GenesisBuild<T, I = ()>: Default + sp_runtime::traits::MaybeSerializeDeserialize {
+	/// The build function is called within an externalities allowing storage APIs.
+	/// Thus one can write to storage using regular pallet storages.
+	fn build(&self);
+
+	/// Build the storage using `build` inside default storage.
+	#[cfg(feature = "std")]
+	fn build_storage(&self) -> Result<sp_runtime::Storage, String> {
+		let mut storage = Default::default();
+		self.assimilate_storage(&mut storage)?;
+		Ok(storage)
+	}
+
+	/// Assimilate the storage for this module into pre-existing overlays.
+	#[cfg(feature = "std")]
+	fn assimilate_storage(&self, storage: &mut sp_runtime::Storage) -> Result<(), String> {
+		sp_state_machine::BasicExternalities::execute_with_storage(storage, || {
+			self.build();
+			Ok(())
+		})
+	}
+}
+
+/// A trait which is called when the timestamp is set in the runtime.
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+pub trait OnTimestampSet<Moment> {
+	/// Called when the timestamp is set.
+	fn on_timestamp_set(moment: Moment);
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_io::TestExternalities;
+
+	#[cfg(feature = "try-runtime")]
+	#[test]
+	fn on_runtime_upgrade_pre_post_executed_tuple() {
+		crate::parameter_types! {
+			pub static Pre: Vec<&'static str> = Default::default();
+			pub static Post: Vec<&'static str> = Default::default();
+		}
+
+		macro_rules! impl_test_type {
+			($name:ident) => {
+				struct $name;
+				impl OnRuntimeUpgrade for $name {
+					fn on_runtime_upgrade() -> Weight {
+						Default::default()
+					}
+
+					#[cfg(feature = "try-runtime")]
+					fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError> {
+						Pre::mutate(|s| s.push(stringify!($name)));
+						Ok(Vec::new())
+					}
+
+					#[cfg(feature = "try-runtime")]
+					fn post_upgrade(_: Vec<u8>) -> Result<(), TryRuntimeError> {
+						Post::mutate(|s| s.push(stringify!($name)));
+						Ok(())
+					}
+				}
+			};
+		}
+
+		impl_test_type!(Foo);
+		impl_test_type!(Bar);
+		impl_test_type!(Baz);
+
+		TestExternalities::default().execute_with(|| {
+			// try_on_runtime_upgrade works
+			Foo::try_on_runtime_upgrade(true).unwrap();
+			assert_eq!(Pre::take(), vec!["Foo"]);
+			assert_eq!(Post::take(), vec!["Foo"]);
+
+			<(Foo, Bar, Baz)>::try_on_runtime_upgrade(true).unwrap();
+			assert_eq!(Pre::take(), vec!["Foo", "Bar", "Baz"]);
+			assert_eq!(Post::take(), vec!["Foo", "Bar", "Baz"]);
+
+			<((Foo, Bar), Baz)>::try_on_runtime_upgrade(true).unwrap();
+			assert_eq!(Pre::take(), vec!["Foo", "Bar", "Baz"]);
+			assert_eq!(Post::take(), vec!["Foo", "Bar", "Baz"]);
+
+			<(Foo, (Bar, Baz))>::try_on_runtime_upgrade(true).unwrap();
+			assert_eq!(Pre::take(), vec!["Foo", "Bar", "Baz"]);
+			assert_eq!(Post::take(), vec!["Foo", "Bar", "Baz"]);
+
+			// calling pre_upgrade and post_upgrade directly on tuple of pallets fails
+			assert!(<(Foo, (Bar, Baz))>::pre_upgrade().is_err());
+			assert!(<(Foo, (Bar, Baz))>::post_upgrade(vec![]).is_err());
+		});
+	}
+
+	#[test]
+	fn on_initialize_and_on_runtime_upgrade_weight_merge_works() {
+		struct Test;
+
+		impl OnInitialize<u8> for Test {
+			fn on_initialize(_n: u8) -> Weight {
+				Weight::from_parts(10, 0)
+			}
+		}
+		impl OnRuntimeUpgrade for Test {
+			fn on_runtime_upgrade() -> Weight {
+				Weight::from_parts(20, 0)
+			}
+		}
+
+		TestExternalities::default().execute_with(|| {
+			assert_eq!(<(Test, Test)>::on_initialize(0), Weight::from_parts(20, 0));
+			assert_eq!(<(Test, Test)>::on_runtime_upgrade(), Weight::from_parts(40, 0));
+		});
+	}
+
+	#[test]
+	fn on_idle_round_robin_works() {
+		static mut ON_IDLE_INVOCATION_ORDER: sp_std::vec::Vec<&str> = sp_std::vec::Vec::new();
+
+		struct Test1;
+		struct Test2;
+		struct Test3;
+		type TestTuple = (Test1, Test2, Test3);
+		impl OnIdle<u32> for Test1 {
+			fn on_idle(_n: u32, _weight: Weight) -> Weight {
+				unsafe {
+					ON_IDLE_INVOCATION_ORDER.push("Test1");
+				}
+				Weight::zero()
+			}
+		}
+		impl OnIdle<u32> for Test2 {
+			fn on_idle(_n: u32, _weight: Weight) -> Weight {
+				unsafe {
+					ON_IDLE_INVOCATION_ORDER.push("Test2");
+				}
+				Weight::zero()
+			}
+		}
+		impl OnIdle<u32> for Test3 {
+			fn on_idle(_n: u32, _weight: Weight) -> Weight {
+				unsafe {
+					ON_IDLE_INVOCATION_ORDER.push("Test3");
+				}
+				Weight::zero()
+			}
+		}
+
+		unsafe {
+			TestTuple::on_idle(0, Weight::zero());
+			assert_eq!(ON_IDLE_INVOCATION_ORDER, ["Test1", "Test2", "Test3"].to_vec());
+			ON_IDLE_INVOCATION_ORDER.clear();
+
+			TestTuple::on_idle(1, Weight::zero());
+			assert_eq!(ON_IDLE_INVOCATION_ORDER, ["Test2", "Test3", "Test1"].to_vec());
+			ON_IDLE_INVOCATION_ORDER.clear();
+
+			TestTuple::on_idle(2, Weight::zero());
+			assert_eq!(ON_IDLE_INVOCATION_ORDER, ["Test3", "Test1", "Test2"].to_vec());
+			ON_IDLE_INVOCATION_ORDER.clear();
+
+			TestTuple::on_idle(3, Weight::zero());
+			assert_eq!(ON_IDLE_INVOCATION_ORDER, ["Test1", "Test2", "Test3"].to_vec());
+			ON_IDLE_INVOCATION_ORDER.clear();
+
+			TestTuple::on_idle(4, Weight::zero());
+			assert_eq!(ON_IDLE_INVOCATION_ORDER, ["Test2", "Test3", "Test1"].to_vec());
+			ON_IDLE_INVOCATION_ORDER.clear();
+		}
+	}
+}
diff --git a/substrate/frame/support/src/traits/members.rs b/substrate/frame/support/src/traits/members.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fbba742ebeb4395b4ec17ad6656956929f8fec76
--- /dev/null
+++ b/substrate/frame/support/src/traits/members.rs
@@ -0,0 +1,385 @@
+// 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.
+
+//! Traits for dealing with the idea of membership.
+
+use impl_trait_for_tuples::impl_for_tuples;
+use sp_arithmetic::traits::AtLeast16BitUnsigned;
+use sp_runtime::DispatchResult;
+use sp_std::{marker::PhantomData, prelude::*};
+
+/// A trait for querying whether a type can be said to "contain" a value.
+pub trait Contains<T> {
+	/// Return `true` if this "contains" the given value `t`.
+	fn contains(t: &T) -> bool;
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl<T> Contains<T> for Tuple {
+	fn contains(t: &T) -> bool {
+		for_tuples!( #(
+			if Tuple::contains(t) { return true }
+		)* );
+		false
+	}
+}
+
+/// A trait for querying whether a type can be said to "contain" a pair-value.
+pub trait ContainsPair<A, B> {
+	/// Return `true` if this "contains" the pair-value `(a, b)`.
+	fn contains(a: &A, b: &B) -> bool;
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl<A, B> ContainsPair<A, B> for Tuple {
+	fn contains(a: &A, b: &B) -> bool {
+		for_tuples!( #(
+			if Tuple::contains(a, b) { return true }
+		)* );
+		false
+	}
+}
+
+/// Converter `struct` to use a `ContainsPair` implementation for a `Contains` bound.
+pub struct FromContainsPair<CP>(PhantomData<CP>);
+impl<A, B, CP: ContainsPair<A, B>> Contains<(A, B)> for FromContainsPair<CP> {
+	fn contains((ref a, ref b): &(A, B)) -> bool {
+		CP::contains(a, b)
+	}
+}
+
+/// A [`Contains`] implementation that contains every value.
+pub enum Everything {}
+impl<T> Contains<T> for Everything {
+	fn contains(_: &T) -> bool {
+		true
+	}
+}
+impl<A, B> ContainsPair<A, B> for Everything {
+	fn contains(_: &A, _: &B) -> bool {
+		true
+	}
+}
+
+/// A [`Contains`] implementation that contains no value.
+pub enum Nothing {}
+impl<T> Contains<T> for Nothing {
+	fn contains(_: &T) -> bool {
+		false
+	}
+}
+impl<A, B> ContainsPair<A, B> for Nothing {
+	fn contains(_: &A, _: &B) -> bool {
+		false
+	}
+}
+
+/// A [`Contains`] implementation that contains everything except the values in `Exclude`.
+pub struct EverythingBut<Exclude>(PhantomData<Exclude>);
+impl<T, Exclude: Contains<T>> Contains<T> for EverythingBut<Exclude> {
+	fn contains(t: &T) -> bool {
+		!Exclude::contains(t)
+	}
+}
+impl<A, B, Exclude: ContainsPair<A, B>> ContainsPair<A, B> for EverythingBut<Exclude> {
+	fn contains(a: &A, b: &B) -> bool {
+		!Exclude::contains(a, b)
+	}
+}
+
+/// A [`Contains`] implementation that contains all members of `These` excepting any members in
+/// `Except`.
+pub struct TheseExcept<These, Except>(PhantomData<(These, Except)>);
+impl<T, These: Contains<T>, Except: Contains<T>> Contains<T> for TheseExcept<These, Except> {
+	fn contains(t: &T) -> bool {
+		These::contains(t) && !Except::contains(t)
+	}
+}
+impl<A, B, These: ContainsPair<A, B>, Except: ContainsPair<A, B>> ContainsPair<A, B>
+	for TheseExcept<These, Except>
+{
+	fn contains(a: &A, b: &B) -> bool {
+		These::contains(a, b) && !Except::contains(a, b)
+	}
+}
+
+/// A [`Contains`] implementation which contains all members of `These` which are also members of
+/// `Those`.
+pub struct InsideBoth<These, Those>(PhantomData<(These, Those)>);
+impl<T, These: Contains<T>, Those: Contains<T>> Contains<T> for InsideBoth<These, Those> {
+	fn contains(t: &T) -> bool {
+		These::contains(t) && Those::contains(t)
+	}
+}
+impl<A, B, These: ContainsPair<A, B>, Those: ContainsPair<A, B>> ContainsPair<A, B>
+	for InsideBoth<These, Those>
+{
+	fn contains(a: &A, b: &B) -> bool {
+		These::contains(a, b) && Those::contains(a, b)
+	}
+}
+
+/// Create a type which implements the `Contains` trait for a particular type with syntax similar
+/// to `matches!`.
+#[macro_export]
+macro_rules! match_types {
+	(
+		pub type $n:ident: impl Contains<$t:ty> = {
+			$phead:pat_param $( | $ptail:pat )*
+		};
+		$( $rest:tt )*
+	) => {
+		pub struct $n;
+		impl $crate::traits::Contains<$t> for $n {
+			fn contains(l: &$t) -> bool {
+				matches!(l, $phead $( | $ptail )* )
+			}
+		}
+		$crate::match_types!( $( $rest )* );
+	};
+	(
+		pub type $n:ident: impl ContainsPair<$a:ty, $b:ty> = {
+			$phead:pat_param $( | $ptail:pat )*
+		};
+		$( $rest:tt )*
+	) => {
+		pub struct $n;
+		impl $crate::traits::ContainsPair<$a, $b> for $n {
+			fn contains(a: &$a, b: &$b) -> bool {
+				matches!((a, b), $phead $( | $ptail )* )
+			}
+		}
+		$crate::match_types!( $( $rest )* );
+	};
+	() => {}
+}
+
+/// Create a type which implements the `Contains` trait for a particular type with syntax similar
+/// to `matches!`.
+#[macro_export]
+#[deprecated = "Use `match_types!` instead"]
+macro_rules! match_type {
+	($( $x:tt )*) => { $crate::match_types!( $( $x )* ); }
+}
+
+#[deprecated = "Use `Everything` instead"]
+pub type AllowAll = Everything;
+#[deprecated = "Use `Nothing` instead"]
+pub type DenyAll = Nothing;
+#[deprecated = "Use `Contains` instead"]
+pub trait Filter<T> {
+	fn filter(t: &T) -> bool;
+}
+#[allow(deprecated)]
+impl<T, C: Contains<T>> Filter<T> for C {
+	fn filter(t: &T) -> bool {
+		Self::contains(t)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	match_types! {
+		pub type OneOrTenToTwenty: impl Contains<u8> = { 1 | 10..=20 };
+	}
+
+	#[test]
+	fn match_types_works() {
+		for i in 0..=255 {
+			assert_eq!(OneOrTenToTwenty::contains(&i), i == 1 || i >= 10 && i <= 20);
+		}
+	}
+}
+
+/// A trait for a set which can enumerate its members in order.
+pub trait SortedMembers<T: Ord> {
+	/// Get a vector of all members in the set, ordered.
+	fn sorted_members() -> Vec<T>;
+
+	/// Return `true` if this "contains" the given value `t`.
+	fn contains(t: &T) -> bool {
+		Self::sorted_members().binary_search(t).is_ok()
+	}
+
+	/// Get the number of items in the set.
+	fn count() -> usize {
+		Self::sorted_members().len()
+	}
+
+	/// Add an item that would satisfy `contains`. It does not make sure any other
+	/// state is correctly maintained or generated.
+	///
+	/// **Should be used for benchmarking only!!!**
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add(_t: &T) {
+		unimplemented!()
+	}
+}
+
+/// Adapter struct for turning an `OrderedMembership` impl into a `Contains` impl.
+pub struct AsContains<OM>(PhantomData<(OM,)>);
+impl<T: Ord + Eq, OM: SortedMembers<T>> Contains<T> for AsContains<OM> {
+	fn contains(t: &T) -> bool {
+		OM::contains(t)
+	}
+}
+
+/// Trivial utility for implementing `Contains`/`OrderedMembership` with a `Vec`.
+pub struct IsInVec<T>(PhantomData<T>);
+impl<X: Eq, T: super::Get<Vec<X>>> Contains<X> for IsInVec<T> {
+	fn contains(t: &X) -> bool {
+		T::get().contains(t)
+	}
+}
+impl<X: Ord + PartialOrd, T: super::Get<Vec<X>>> SortedMembers<X> for IsInVec<T> {
+	fn sorted_members() -> Vec<X> {
+		let mut r = T::get();
+		r.sort();
+		r
+	}
+}
+
+/// A trait for querying bound for the length of an implementation of `Contains`
+pub trait ContainsLengthBound {
+	/// Minimum number of elements contained
+	fn min_len() -> usize;
+	/// Maximum number of elements contained
+	fn max_len() -> usize;
+}
+
+/// Ranked membership data structure.
+pub trait RankedMembers {
+	type AccountId;
+	type Rank: AtLeast16BitUnsigned;
+
+	/// The lowest rank possible in this membership organisation.
+	fn min_rank() -> Self::Rank;
+
+	/// Return the rank of the given ID, or `None` if they are not a member.
+	fn rank_of(who: &Self::AccountId) -> Option<Self::Rank>;
+
+	/// Add a member to the group at the `min_rank()`.
+	fn induct(who: &Self::AccountId) -> DispatchResult;
+
+	/// Promote a member to the next higher rank.
+	fn promote(who: &Self::AccountId) -> DispatchResult;
+
+	/// Demote a member to the next lower rank; demoting beyond the `min_rank` removes the
+	/// member entirely.
+	fn demote(who: &Self::AccountId) -> DispatchResult;
+}
+
+/// Trait for type that can handle the initialization of account IDs at genesis.
+pub trait InitializeMembers<AccountId> {
+	/// Initialize the members to the given `members`.
+	fn initialize_members(members: &[AccountId]);
+}
+
+impl<T> InitializeMembers<T> for () {
+	fn initialize_members(_: &[T]) {}
+}
+
+/// Trait for type that can handle incremental changes to a set of account IDs.
+pub trait ChangeMembers<AccountId: Clone + Ord> {
+	/// A number of members `incoming` just joined the set and replaced some `outgoing` ones. The
+	/// new set is given by `new`, and need not be sorted.
+	///
+	/// This resets any previous value of prime.
+	fn change_members(incoming: &[AccountId], outgoing: &[AccountId], mut new: Vec<AccountId>) {
+		new.sort();
+		Self::change_members_sorted(incoming, outgoing, &new[..]);
+	}
+
+	/// A number of members `_incoming` just joined the set and replaced some `_outgoing` ones. The
+	/// new set is thus given by `sorted_new` and **must be sorted**.
+	///
+	/// NOTE: This is the only function that needs to be implemented in `ChangeMembers`.
+	///
+	/// This resets any previous value of prime.
+	fn change_members_sorted(
+		incoming: &[AccountId],
+		outgoing: &[AccountId],
+		sorted_new: &[AccountId],
+	);
+
+	/// Set the new members; they **must already be sorted**. This will compute the diff and use it
+	/// to call `change_members_sorted`.
+	///
+	/// This resets any previous value of prime.
+	fn set_members_sorted(new_members: &[AccountId], old_members: &[AccountId]) {
+		let (incoming, outgoing) = Self::compute_members_diff_sorted(new_members, old_members);
+		Self::change_members_sorted(&incoming[..], &outgoing[..], new_members);
+	}
+
+	/// Compute diff between new and old members; they **must already be sorted**.
+	///
+	/// Returns incoming and outgoing members.
+	fn compute_members_diff_sorted(
+		new_members: &[AccountId],
+		old_members: &[AccountId],
+	) -> (Vec<AccountId>, Vec<AccountId>) {
+		let mut old_iter = old_members.iter();
+		let mut new_iter = new_members.iter();
+		let mut incoming = Vec::new();
+		let mut outgoing = Vec::new();
+		let mut old_i = old_iter.next();
+		let mut new_i = new_iter.next();
+		loop {
+			match (old_i, new_i) {
+				(None, None) => break,
+				(Some(old), Some(new)) if old == new => {
+					old_i = old_iter.next();
+					new_i = new_iter.next();
+				},
+				(Some(old), Some(new)) if old < new => {
+					outgoing.push(old.clone());
+					old_i = old_iter.next();
+				},
+				(Some(old), None) => {
+					outgoing.push(old.clone());
+					old_i = old_iter.next();
+				},
+				(_, Some(new)) => {
+					incoming.push(new.clone());
+					new_i = new_iter.next();
+				},
+			}
+		}
+		(incoming, outgoing)
+	}
+
+	/// Set the prime member.
+	fn set_prime(_prime: Option<AccountId>) {}
+
+	/// Get the current prime.
+	fn get_prime() -> Option<AccountId> {
+		None
+	}
+}
+
+impl<T: Clone + Ord> ChangeMembers<T> for () {
+	fn change_members(_: &[T], _: &[T], _: Vec<T>) {}
+	fn change_members_sorted(_: &[T], _: &[T], _: &[T]) {}
+	fn set_members_sorted(_: &[T], _: &[T]) {}
+	fn set_prime(_: Option<T>) {}
+}
diff --git a/substrate/frame/support/src/traits/messages.rs b/substrate/frame/support/src/traits/messages.rs
new file mode 100644
index 0000000000000000000000000000000000000000..36fa7957dff7c3891053eddc1f33b29da20366de
--- /dev/null
+++ b/substrate/frame/support/src/traits/messages.rs
@@ -0,0 +1,244 @@
+// 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.
+
+//! Traits for managing message queuing and handling.
+
+use codec::{Decode, Encode, FullCodec, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_core::{ConstU32, Get, TypedGet};
+use sp_runtime::{traits::Convert, BoundedSlice, RuntimeDebug};
+use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
+use sp_weights::{Weight, WeightMeter};
+
+/// Errors that can happen when attempting to process a message with
+/// [`ProcessMessage::process_message()`].
+#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, TypeInfo, RuntimeDebug)]
+pub enum ProcessMessageError {
+	/// The message data format is unknown (e.g. unrecognised header)
+	BadFormat,
+	/// The message data is bad (e.g. decoding returns an error).
+	Corrupt,
+	/// The message format is unsupported (e.g. old XCM version).
+	Unsupported,
+	/// Message processing was not attempted because it was not certain that the weight limit
+	/// would be respected. The parameter gives the maximum weight which the message could take
+	/// to process.
+	Overweight(Weight),
+	/// The queue wants to give up its current processing slot.
+	///
+	/// Hints the message processor to cease servicing this queue and proceed to the next
+	/// one. This is seen as a *hint*, not an instruction. Implementations must therefore handle
+	/// the case that a queue is re-serviced within the same block after *yielding*. A queue is
+	/// not required to *yield* again when it is being re-serviced withing the same block.
+	Yield,
+}
+
+/// Can process messages from a specific origin.
+pub trait ProcessMessage {
+	/// The transport from where a message originates.
+	type Origin: FullCodec + MaxEncodedLen + Clone + Eq + PartialEq + TypeInfo + Debug;
+
+	/// Process the given message, using no more than the remaining `meter` weight to do so.
+	///
+	/// Returns whether the message was processed.
+	fn process_message(
+		message: &[u8],
+		origin: Self::Origin,
+		meter: &mut WeightMeter,
+		id: &mut [u8; 32],
+	) -> Result<bool, ProcessMessageError>;
+}
+
+/// Errors that can happen when attempting to execute an overweight message with
+/// [`ServiceQueues::execute_overweight()`].
+#[derive(Eq, PartialEq, RuntimeDebug)]
+pub enum ExecuteOverweightError {
+	/// The referenced message was not found.
+	NotFound,
+	/// The message was already processed.
+	///
+	/// This can be treated as success condition.
+	AlreadyProcessed,
+	/// The available weight was insufficient to execute the message.
+	InsufficientWeight,
+	/// The queue is paused and no message can be executed from it.
+	///
+	/// This can change at any time and may resolve in the future by re-trying.
+	QueuePaused,
+	/// An unspecified error.
+	Other,
+}
+
+/// Can service queues and execute overweight messages.
+pub trait ServiceQueues {
+	/// Addresses a specific overweight message.
+	type OverweightMessageAddress;
+
+	/// Service all message queues in some fair manner.
+	///
+	/// - `weight_limit`: The maximum amount of dynamic weight that this call can use.
+	///
+	/// Returns the dynamic weight used by this call; is never greater than `weight_limit`.
+	fn service_queues(weight_limit: Weight) -> Weight;
+
+	/// Executes a message that could not be executed by [`Self::service_queues()`] because it was
+	/// temporarily overweight.
+	fn execute_overweight(
+		_weight_limit: Weight,
+		_address: Self::OverweightMessageAddress,
+	) -> Result<Weight, ExecuteOverweightError> {
+		Err(ExecuteOverweightError::NotFound)
+	}
+}
+
+/// Services queues by doing nothing.
+pub struct NoopServiceQueues<OverweightAddr>(PhantomData<OverweightAddr>);
+impl<OverweightAddr> ServiceQueues for NoopServiceQueues<OverweightAddr> {
+	type OverweightMessageAddress = OverweightAddr;
+
+	fn service_queues(_: Weight) -> Weight {
+		Weight::zero()
+	}
+}
+
+/// The resource footprint of a queue.
+#[derive(Default, Copy, Clone, Eq, PartialEq, RuntimeDebug)]
+pub struct Footprint {
+	pub count: u64,
+	pub size: u64,
+}
+
+/// Can enqueue messages for multiple origins.
+pub trait EnqueueMessage<Origin: MaxEncodedLen> {
+	/// The maximal length any enqueued message may have.
+	type MaxMessageLen: Get<u32>;
+
+	/// Enqueue a single `message` from a specific `origin`.
+	fn enqueue_message(message: BoundedSlice<u8, Self::MaxMessageLen>, origin: Origin);
+
+	/// Enqueue multiple `messages` from a specific `origin`.
+	fn enqueue_messages<'a>(
+		messages: impl Iterator<Item = BoundedSlice<'a, u8, Self::MaxMessageLen>>,
+		origin: Origin,
+	);
+
+	/// Any remaining unprocessed messages should happen only lazily, not proactively.
+	fn sweep_queue(origin: Origin);
+
+	/// Return the state footprint of the given queue.
+	fn footprint(origin: Origin) -> Footprint;
+}
+
+impl<Origin: MaxEncodedLen> EnqueueMessage<Origin> for () {
+	type MaxMessageLen = ConstU32<0>;
+	fn enqueue_message(_: BoundedSlice<u8, Self::MaxMessageLen>, _: Origin) {}
+	fn enqueue_messages<'a>(
+		_: impl Iterator<Item = BoundedSlice<'a, u8, Self::MaxMessageLen>>,
+		_: Origin,
+	) {
+	}
+	fn sweep_queue(_: Origin) {}
+	fn footprint(_: Origin) -> Footprint {
+		Footprint::default()
+	}
+}
+
+/// Transform the origin of an [`EnqueueMessage`] via `C::convert`.
+pub struct TransformOrigin<E, O, N, C>(PhantomData<(E, O, N, C)>);
+impl<E: EnqueueMessage<O>, O: MaxEncodedLen, N: MaxEncodedLen, C: Convert<N, O>> EnqueueMessage<N>
+	for TransformOrigin<E, O, N, C>
+{
+	type MaxMessageLen = E::MaxMessageLen;
+
+	fn enqueue_message(message: BoundedSlice<u8, Self::MaxMessageLen>, origin: N) {
+		E::enqueue_message(message, C::convert(origin));
+	}
+
+	fn enqueue_messages<'a>(
+		messages: impl Iterator<Item = BoundedSlice<'a, u8, Self::MaxMessageLen>>,
+		origin: N,
+	) {
+		E::enqueue_messages(messages, C::convert(origin));
+	}
+
+	fn sweep_queue(origin: N) {
+		E::sweep_queue(C::convert(origin));
+	}
+
+	fn footprint(origin: N) -> Footprint {
+		E::footprint(C::convert(origin))
+	}
+}
+
+/// Handles incoming messages for a single origin.
+pub trait HandleMessage {
+	/// The maximal length any enqueued message may have.
+	type MaxMessageLen: Get<u32>;
+
+	/// Enqueue a single `message` with an implied origin.
+	fn handle_message(message: BoundedSlice<u8, Self::MaxMessageLen>);
+
+	/// Enqueue multiple `messages` from an implied origin.
+	fn handle_messages<'a>(
+		messages: impl Iterator<Item = BoundedSlice<'a, u8, Self::MaxMessageLen>>,
+	);
+
+	/// Any remaining unprocessed messages should happen only lazily, not proactively.
+	fn sweep_queue();
+
+	/// Return the state footprint of the queue.
+	fn footprint() -> Footprint;
+}
+
+/// Adapter type to transform an [`EnqueueMessage`] with an origin into a [`HandleMessage`] impl.
+pub struct EnqueueWithOrigin<E, O>(PhantomData<(E, O)>);
+impl<E: EnqueueMessage<O::Type>, O: TypedGet> HandleMessage for EnqueueWithOrigin<E, O>
+where
+	O::Type: MaxEncodedLen,
+{
+	type MaxMessageLen = E::MaxMessageLen;
+
+	fn handle_message(message: BoundedSlice<u8, Self::MaxMessageLen>) {
+		E::enqueue_message(message, O::get());
+	}
+
+	fn handle_messages<'a>(
+		messages: impl Iterator<Item = BoundedSlice<'a, u8, Self::MaxMessageLen>>,
+	) {
+		E::enqueue_messages(messages, O::get());
+	}
+
+	fn sweep_queue() {
+		E::sweep_queue(O::get());
+	}
+
+	fn footprint() -> Footprint {
+		E::footprint(O::get())
+	}
+}
+
+/// Provides information on paused queues.
+pub trait QueuePausedQuery<Origin> {
+	/// Whether this queue is paused.
+	fn is_paused(origin: &Origin) -> bool;
+}
+
+impl<Origin> QueuePausedQuery<Origin> for () {
+	fn is_paused(_: &Origin) -> bool {
+		false
+	}
+}
diff --git a/substrate/frame/support/src/traits/metadata.rs b/substrate/frame/support/src/traits/metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..85d8f9a5a74e0ddfa3bf592908d0e2fb8f434e49
--- /dev/null
+++ b/substrate/frame/support/src/traits/metadata.rs
@@ -0,0 +1,328 @@
+// 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.
+
+//! Traits for managing information attached to pallets and their constituents.
+
+use codec::{Decode, Encode};
+use impl_trait_for_tuples::impl_for_tuples;
+use sp_runtime::RuntimeDebug;
+use sp_std::{ops::Add, prelude::*};
+
+/// Provides information about the pallet itself and its setup in the runtime.
+///
+/// An implementor should be able to provide information about each pallet that
+/// is configured in `construct_runtime!`.
+pub trait PalletInfo {
+	/// Convert the given pallet `P` into its index as configured in the runtime.
+	fn index<P: 'static>() -> Option<usize>;
+	/// Convert the given pallet `P` into its name as configured in the runtime.
+	fn name<P: 'static>() -> Option<&'static str>;
+	/// Convert the given pallet `P` into its Rust module name as used in `construct_runtime!`.
+	fn module_name<P: 'static>() -> Option<&'static str>;
+	/// Convert the given pallet `P` into its containing crate version.
+	fn crate_version<P: 'static>() -> Option<CrateVersion>;
+}
+
+/// Information regarding an instance of a pallet.
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug)]
+pub struct PalletInfoData {
+	/// Index of the pallet as configured in the runtime.
+	pub index: usize,
+	/// Name of the pallet as configured in the runtime.
+	pub name: &'static str,
+	/// Name of the Rust module containing the pallet.
+	pub module_name: &'static str,
+	/// Version of the crate containing the pallet.
+	pub crate_version: CrateVersion,
+}
+
+/// Provides information about the pallet itself and its setup in the runtime.
+///
+/// Declare some information and access the information provided by [`PalletInfo`] for a specific
+/// pallet.
+pub trait PalletInfoAccess {
+	/// Index of the pallet as configured in the runtime.
+	fn index() -> usize;
+	/// Name of the pallet as configured in the runtime.
+	fn name() -> &'static str;
+	/// Name of the Rust module containing the pallet.
+	fn module_name() -> &'static str;
+	/// Version of the crate containing the pallet.
+	fn crate_version() -> CrateVersion;
+}
+
+/// Provide information about a bunch of pallets.
+pub trait PalletsInfoAccess {
+	/// The number of pallets' information that this type represents.
+	///
+	/// You probably don't want this function but `infos()` instead.
+	fn count() -> usize {
+		// for backwards compatibility with XCM-3, Mark as deprecated.
+		Self::infos().len()
+	}
+
+	/// All of the pallets' information that this type represents.
+	fn infos() -> Vec<PalletInfoData>;
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl PalletsInfoAccess for Tuple {
+	fn infos() -> Vec<PalletInfoData> {
+		let mut res = vec![];
+		for_tuples!( #( res.extend(Tuple::infos()); )* );
+		res
+	}
+}
+
+/// The function and pallet name of the Call.
+#[derive(Clone, Eq, PartialEq, Default, RuntimeDebug)]
+pub struct CallMetadata {
+	/// Name of the function.
+	pub function_name: &'static str,
+	/// Name of the pallet to which the function belongs.
+	pub pallet_name: &'static str,
+}
+
+/// Gets the function name of the Call.
+pub trait GetCallName {
+	/// Return all function names in the same order as [`GetCallIndex`].
+	fn get_call_names() -> &'static [&'static str];
+	/// Return the function name of the Call.
+	fn get_call_name(&self) -> &'static str;
+}
+
+/// Gets the function index of the Call.
+pub trait GetCallIndex {
+	/// Return all call indices in the same order as [`GetCallName`].
+	fn get_call_indices() -> &'static [u8];
+	/// Return the index of this Call.
+	fn get_call_index(&self) -> u8;
+}
+
+/// Gets the metadata for the Call - function name and pallet name.
+pub trait GetCallMetadata {
+	/// Return all module names.
+	fn get_module_names() -> &'static [&'static str];
+	/// Return all function names for the given `module`.
+	fn get_call_names(module: &str) -> &'static [&'static str];
+	/// Return a [`CallMetadata`], containing function and pallet name of the Call.
+	fn get_call_metadata(&self) -> CallMetadata;
+}
+
+/// The version of a crate.
+#[derive(Debug, Eq, PartialEq, Encode, Decode, Clone, Copy, Default)]
+pub struct CrateVersion {
+	/// The major version of the crate.
+	pub major: u16,
+	/// The minor version of the crate.
+	pub minor: u8,
+	/// The patch version of the crate.
+	pub patch: u8,
+}
+
+impl CrateVersion {
+	pub const fn new(major: u16, minor: u8, patch: u8) -> Self {
+		Self { major, minor, patch }
+	}
+}
+
+impl sp_std::cmp::Ord for CrateVersion {
+	fn cmp(&self, other: &Self) -> sp_std::cmp::Ordering {
+		self.major
+			.cmp(&other.major)
+			.then_with(|| self.minor.cmp(&other.minor).then_with(|| self.patch.cmp(&other.patch)))
+	}
+}
+
+impl sp_std::cmp::PartialOrd for CrateVersion {
+	fn partial_cmp(&self, other: &Self) -> Option<sp_std::cmp::Ordering> {
+		Some(<Self as Ord>::cmp(self, other))
+	}
+}
+
+/// The storage key postfix that is used to store the [`StorageVersion`] per pallet.
+///
+/// The full storage key is built by using:
+/// Twox128([`PalletInfo::name`]) ++ Twox128([`STORAGE_VERSION_STORAGE_KEY_POSTFIX`])
+pub const STORAGE_VERSION_STORAGE_KEY_POSTFIX: &[u8] = b":__STORAGE_VERSION__:";
+
+/// The storage version of a pallet.
+///
+/// Each storage version of a pallet is stored in the state under a fixed key. See
+/// [`STORAGE_VERSION_STORAGE_KEY_POSTFIX`] for how this key is built.
+#[derive(Debug, Eq, PartialEq, Encode, Decode, Ord, Clone, Copy, PartialOrd, Default)]
+pub struct StorageVersion(u16);
+
+impl StorageVersion {
+	/// Creates a new instance of `Self`.
+	pub const fn new(version: u16) -> Self {
+		Self(version)
+	}
+
+	/// Returns the storage key for a storage version.
+	///
+	/// See [`STORAGE_VERSION_STORAGE_KEY_POSTFIX`] on how this key is built.
+	pub fn storage_key<P: PalletInfoAccess>() -> [u8; 32] {
+		let pallet_name = P::name();
+		crate::storage::storage_prefix(pallet_name.as_bytes(), STORAGE_VERSION_STORAGE_KEY_POSTFIX)
+	}
+
+	/// Put this storage version for the given pallet into the storage.
+	///
+	/// It will use the storage key that is associated with the given `Pallet`.
+	///
+	/// # Panics
+	///
+	/// This function will panic iff `Pallet` can not be found by `PalletInfo`.
+	/// In a runtime that is put together using
+	/// [`construct_runtime!`](crate::construct_runtime) this should never happen.
+	///
+	/// It will also panic if this function isn't executed in an externalities
+	/// provided environment.
+	pub fn put<P: PalletInfoAccess>(&self) {
+		let key = Self::storage_key::<P>();
+
+		crate::storage::unhashed::put(&key, self);
+	}
+
+	/// Get the storage version of the given pallet from the storage.
+	///
+	/// It will use the storage key that is associated with the given `Pallet`.
+	///
+	/// # Panics
+	///
+	/// This function will panic iff `Pallet` can not be found by `PalletInfo`.
+	/// In a runtime that is put together using
+	/// [`construct_runtime!`](crate::construct_runtime) this should never happen.
+	///
+	/// It will also panic if this function isn't executed in an externalities
+	/// provided environment.
+	pub fn get<P: PalletInfoAccess>() -> Self {
+		let key = Self::storage_key::<P>();
+
+		crate::storage::unhashed::get_or_default(&key)
+	}
+}
+
+impl PartialEq<u16> for StorageVersion {
+	fn eq(&self, other: &u16) -> bool {
+		self.0 == *other
+	}
+}
+
+impl PartialOrd<u16> for StorageVersion {
+	fn partial_cmp(&self, other: &u16) -> Option<sp_std::cmp::Ordering> {
+		Some(self.0.cmp(other))
+	}
+}
+
+impl Add<u16> for StorageVersion {
+	type Output = StorageVersion;
+
+	fn add(self, rhs: u16) -> Self::Output {
+		Self::new(self.0 + rhs)
+	}
+}
+
+/// Special marker struct if no storage version is set for a pallet.
+///
+/// If you (the reader) end up here, it probably means that you tried to compare
+/// [`GetStorageVersion::on_chain_storage_version`] against
+/// [`GetStorageVersion::current_storage_version`]. This basically means that the
+/// [`storage_version`](crate::pallet_macros::storage_version) is missing in the pallet where the
+/// mentioned functions are being called.
+#[derive(Debug, Default)]
+pub struct NoStorageVersionSet;
+
+/// Provides information about the storage version of a pallet.
+///
+/// It differentiates between current and on-chain storage version. Both should be only out of sync
+/// when a new runtime upgrade was applied and the runtime migrations did not yet executed.
+/// Otherwise it means that the pallet works with an unsupported storage version and unforeseen
+/// stuff can happen.
+///
+/// The current storage version is the version of the pallet as supported at runtime. The active
+/// storage version is the version of the pallet in the storage.
+///
+/// It is required to update the on-chain storage version manually when a migration was applied.
+pub trait GetStorageVersion {
+	/// This will be filled out by the [`pallet`](crate::pallet) macro.
+	///
+	/// If the [`storage_version`](crate::pallet_macros::storage_version) attribute isn't given
+	/// this is set to [`NoStorageVersionSet`] to inform the user that the attribute is missing.
+	/// This should prevent that the user forgets to set a storage version when required. However,
+	/// this will only work when the user actually tries to call [`Self::current_storage_version`]
+	/// to compare it against the [`Self::on_chain_storage_version`]. If the attribute is given,
+	/// this will be set to [`StorageVersion`].
+	type CurrentStorageVersion;
+
+	/// Returns the current storage version as supported by the pallet.
+	fn current_storage_version() -> Self::CurrentStorageVersion;
+	/// Returns the on-chain storage version of the pallet as stored in the storage.
+	fn on_chain_storage_version() -> StorageVersion;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	struct Pallet1;
+	impl PalletInfoAccess for Pallet1 {
+		fn index() -> usize {
+			1
+		}
+		fn name() -> &'static str {
+			"Pallet1"
+		}
+		fn module_name() -> &'static str {
+			"pallet1"
+		}
+		fn crate_version() -> CrateVersion {
+			CrateVersion::new(1, 0, 0)
+		}
+	}
+	struct Pallet2;
+	impl PalletInfoAccess for Pallet2 {
+		fn index() -> usize {
+			2
+		}
+		fn name() -> &'static str {
+			"Pallet2"
+		}
+		fn module_name() -> &'static str {
+			"pallet2"
+		}
+		fn crate_version() -> CrateVersion {
+			CrateVersion::new(1, 0, 0)
+		}
+	}
+
+	#[test]
+	fn check_storage_version_ordering() {
+		let version = StorageVersion::new(1);
+		assert!(version == StorageVersion::new(1));
+		assert!(version < StorageVersion::new(2));
+		assert!(version < StorageVersion::new(3));
+
+		let version = StorageVersion::new(2);
+		assert!(version < StorageVersion::new(3));
+		assert!(version > StorageVersion::new(1));
+		assert!(version < StorageVersion::new(5));
+	}
+}
diff --git a/substrate/frame/support/src/traits/misc.rs b/substrate/frame/support/src/traits/misc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb704de4353c7318ce3ae709c60b0a9dc1fafe76
--- /dev/null
+++ b/substrate/frame/support/src/traits/misc.rs
@@ -0,0 +1,1457 @@
+// 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.
+
+//! Smaller traits used in FRAME which don't need their own file.
+
+use crate::dispatch::{DispatchResult, Parameter};
+use codec::{CompactLen, Decode, DecodeLimit, Encode, EncodeLike, Input, MaxEncodedLen};
+use impl_trait_for_tuples::impl_for_tuples;
+use scale_info::{build::Fields, meta_type, Path, Type, TypeInfo, TypeParameter};
+use sp_arithmetic::traits::{CheckedAdd, CheckedMul, CheckedSub, One, Saturating};
+use sp_core::bounded::bounded_vec::TruncateFrom;
+#[doc(hidden)]
+pub use sp_runtime::traits::{
+	ConstBool, ConstI128, ConstI16, ConstI32, ConstI64, ConstI8, ConstU128, ConstU16, ConstU32,
+	ConstU64, ConstU8, Get, GetDefault, TryCollect, TypedGet,
+};
+use sp_runtime::{traits::Block as BlockT, DispatchError};
+use sp_std::{cmp::Ordering, prelude::*};
+
+#[doc(hidden)]
+pub const DEFENSIVE_OP_PUBLIC_ERROR: &str = "a defensive failure has been triggered; please report the block number at https://github.com/paritytech/substrate/issues";
+#[doc(hidden)]
+pub const DEFENSIVE_OP_INTERNAL_ERROR: &str = "Defensive failure has been triggered!";
+
+/// Generic function to mark an execution path as ONLY defensive.
+///
+/// Similar to mark a match arm or `if/else` branch as `unreachable!`.
+#[macro_export]
+macro_rules! defensive {
+	() => {
+		frame_support::__private::log::error!(
+			target: "runtime",
+			"{}",
+			$crate::traits::DEFENSIVE_OP_PUBLIC_ERROR
+		);
+		debug_assert!(false, "{}", $crate::traits::DEFENSIVE_OP_INTERNAL_ERROR);
+	};
+	($error:expr $(,)?) => {
+		frame_support::__private::log::error!(
+			target: "runtime",
+			"{}: {:?}",
+			$crate::traits::DEFENSIVE_OP_PUBLIC_ERROR,
+			$error
+		);
+		debug_assert!(false, "{}: {:?}", $crate::traits::DEFENSIVE_OP_INTERNAL_ERROR, $error);
+	};
+	($error:expr, $proof:expr $(,)?) => {
+		frame_support::__private::log::error!(
+			target: "runtime",
+			"{}: {:?}: {:?}",
+			$crate::traits::DEFENSIVE_OP_PUBLIC_ERROR,
+			$error,
+			$proof,
+		);
+		debug_assert!(false, "{}: {:?}: {:?}", $crate::traits::DEFENSIVE_OP_INTERNAL_ERROR, $error, $proof);
+	}
+}
+
+/// Trigger a defensive failure if a condition is not met.
+///
+/// Similar to [`assert!`] but will print an error without `debug_assertions` instead of silently
+/// ignoring it. Only accepts one instead of variable formatting arguments.
+///
+/// # Example
+///
+/// ```should_panic
+/// frame_support::defensive_assert!(1 == 0, "Must fail")
+/// ```
+#[macro_export]
+macro_rules! defensive_assert {
+	($cond:expr $(, $proof:expr )? $(,)?) => {
+		if !($cond) {
+			$crate::defensive!(::core::stringify!($cond) $(, $proof )?);
+		}
+	};
+}
+
+/// Prelude module for all defensive traits to be imported at once.
+pub mod defensive_prelude {
+	pub use super::{Defensive, DefensiveOption, DefensiveResult};
+}
+
+/// A trait to handle errors and options when you are really sure that a condition must hold, but
+/// not brave enough to `expect` on it, or a default fallback value makes more sense.
+///
+/// This trait mostly focuses on methods that eventually unwrap the inner value. See
+/// [`DefensiveResult`] and [`DefensiveOption`] for methods that specifically apply to the
+/// respective types.
+///
+/// Each function in this trait will have two side effects, aside from behaving exactly as the name
+/// would suggest:
+///
+/// 1. It panics on `#[debug_assertions]`, so if the infallible code is reached in any of the tests,
+///    you realize.
+/// 2. It will log an error using the runtime logging system. This might help you detect such bugs
+///    in production as well. Note that the log message, as of now, are not super expressive. Your
+///    best shot of fully diagnosing the error would be to infer the block number of which the log
+///    message was emitted, then re-execute that block using `check-block` or `try-runtime`
+///    subcommands in substrate client.
+pub trait Defensive<T> {
+	/// Exactly the same as `unwrap_or`, but it does the defensive warnings explained in the trait
+	/// docs.
+	fn defensive_unwrap_or(self, other: T) -> T;
+
+	/// Exactly the same as `unwrap_or_else`, but it does the defensive warnings explained in the
+	/// trait docs.
+	fn defensive_unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T;
+
+	/// Exactly the same as `unwrap_or_default`, but it does the defensive warnings explained in the
+	/// trait docs.
+	fn defensive_unwrap_or_default(self) -> T
+	where
+		T: Default;
+
+	/// Does not alter the inner value at all, but it will log warnings if the inner value is `None`
+	/// or `Err`.
+	///
+	/// In some ways, this is like  `.defensive_map(|x| x)`.
+	///
+	/// This is useful as:
+	/// ```nocompile
+	/// if let Some(inner) = maybe_value().defensive() {
+	/// 	 	..
+	/// }
+	/// ```
+	fn defensive(self) -> Self;
+
+	/// Same as [`Defensive::defensive`], but it takes a proof as input, and displays it if the
+	/// defensive operation has been triggered.
+	fn defensive_proof(self, proof: &'static str) -> Self;
+}
+
+/// Subset of methods similar to [`Defensive`] that can only work for a `Result`.
+pub trait DefensiveResult<T, E> {
+	/// Defensively map the error into another return type, but you are really sure that this
+	/// conversion should never be needed.
+	fn defensive_map_err<F, O: FnOnce(E) -> F>(self, o: O) -> Result<T, F>;
+
+	/// Defensively map and unpack the value to something else (`U`), or call the default callback
+	/// if `Err`, which should never happen.
+	fn defensive_map_or_else<U, D: FnOnce(E) -> U, F: FnOnce(T) -> U>(self, default: D, f: F) -> U;
+
+	/// Defensively transform this result into an option, discarding the `Err` variant if it
+	/// happens, which should never happen.
+	fn defensive_ok(self) -> Option<T>;
+
+	/// Exactly the same as `map`, but it prints the appropriate warnings if the value being mapped
+	/// is `Err`.
+	fn defensive_map<U, F: FnOnce(T) -> U>(self, f: F) -> Result<U, E>;
+}
+
+/// Subset of methods similar to [`Defensive`] that can only work for a `Option`.
+pub trait DefensiveOption<T> {
+	/// Potentially map and unpack the value to something else (`U`), or call the default callback
+	/// if `None`, which should never happen.
+	fn defensive_map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(self, default: D, f: F) -> U;
+
+	/// Defensively transform this option to a result, mapping `None` to the return value of an
+	/// error closure.
+	fn defensive_ok_or_else<E: sp_std::fmt::Debug, F: FnOnce() -> E>(self, err: F) -> Result<T, E>;
+
+	/// Defensively transform this option to a result, mapping `None` to a default value.
+	fn defensive_ok_or<E: sp_std::fmt::Debug>(self, err: E) -> Result<T, E>;
+
+	/// Exactly the same as `map`, but it prints the appropriate warnings if the value being mapped
+	/// is `None`.
+	fn defensive_map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U>;
+}
+
+impl<T> Defensive<T> for Option<T> {
+	fn defensive_unwrap_or(self, or: T) -> T {
+		match self {
+			Some(inner) => inner,
+			None => {
+				defensive!();
+				or
+			},
+		}
+	}
+
+	fn defensive_unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T {
+		match self {
+			Some(inner) => inner,
+			None => {
+				defensive!();
+				f()
+			},
+		}
+	}
+
+	fn defensive_unwrap_or_default(self) -> T
+	where
+		T: Default,
+	{
+		match self {
+			Some(inner) => inner,
+			None => {
+				defensive!();
+				Default::default()
+			},
+		}
+	}
+
+	fn defensive(self) -> Self {
+		match self {
+			Some(inner) => Some(inner),
+			None => {
+				defensive!();
+				None
+			},
+		}
+	}
+
+	fn defensive_proof(self, proof: &'static str) -> Self {
+		if self.is_none() {
+			defensive!(proof);
+		}
+		self
+	}
+}
+
+impl<T, E: sp_std::fmt::Debug> Defensive<T> for Result<T, E> {
+	fn defensive_unwrap_or(self, or: T) -> T {
+		match self {
+			Ok(inner) => inner,
+			Err(e) => {
+				defensive!(e);
+				or
+			},
+		}
+	}
+
+	fn defensive_unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T {
+		match self {
+			Ok(inner) => inner,
+			Err(e) => {
+				defensive!(e);
+				f()
+			},
+		}
+	}
+
+	fn defensive_unwrap_or_default(self) -> T
+	where
+		T: Default,
+	{
+		match self {
+			Ok(inner) => inner,
+			Err(e) => {
+				defensive!(e);
+				Default::default()
+			},
+		}
+	}
+
+	fn defensive(self) -> Self {
+		match self {
+			Ok(inner) => Ok(inner),
+			Err(e) => {
+				defensive!(e);
+				Err(e)
+			},
+		}
+	}
+
+	fn defensive_proof(self, proof: &'static str) -> Self {
+		match self {
+			Ok(inner) => Ok(inner),
+			Err(e) => {
+				defensive!(e, proof);
+				Err(e)
+			},
+		}
+	}
+}
+
+impl<T, E: sp_std::fmt::Debug> DefensiveResult<T, E> for Result<T, E> {
+	fn defensive_map_err<F, O: FnOnce(E) -> F>(self, o: O) -> Result<T, F> {
+		self.map_err(|e| {
+			defensive!(e);
+			o(e)
+		})
+	}
+
+	fn defensive_map_or_else<U, D: FnOnce(E) -> U, F: FnOnce(T) -> U>(self, default: D, f: F) -> U {
+		self.map_or_else(
+			|e| {
+				defensive!(e);
+				default(e)
+			},
+			f,
+		)
+	}
+
+	fn defensive_ok(self) -> Option<T> {
+		match self {
+			Ok(inner) => Some(inner),
+			Err(e) => {
+				defensive!(e);
+				None
+			},
+		}
+	}
+
+	fn defensive_map<U, F: FnOnce(T) -> U>(self, f: F) -> Result<U, E> {
+		match self {
+			Ok(inner) => Ok(f(inner)),
+			Err(e) => {
+				defensive!(e);
+				Err(e)
+			},
+		}
+	}
+}
+
+impl<T> DefensiveOption<T> for Option<T> {
+	fn defensive_map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(self, default: D, f: F) -> U {
+		self.map_or_else(
+			|| {
+				defensive!();
+				default()
+			},
+			f,
+		)
+	}
+
+	fn defensive_ok_or_else<E: sp_std::fmt::Debug, F: FnOnce() -> E>(self, err: F) -> Result<T, E> {
+		self.ok_or_else(|| {
+			let err_value = err();
+			defensive!(err_value);
+			err_value
+		})
+	}
+
+	fn defensive_ok_or<E: sp_std::fmt::Debug>(self, err: E) -> Result<T, E> {
+		self.ok_or_else(|| {
+			defensive!(err);
+			err
+		})
+	}
+
+	fn defensive_map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> {
+		match self {
+			Some(inner) => Some(f(inner)),
+			None => {
+				defensive!();
+				None
+			},
+		}
+	}
+}
+
+/// A variant of [`Defensive`] with the same rationale, for the arithmetic operations where in
+/// case an infallible operation fails, it saturates.
+pub trait DefensiveSaturating {
+	/// Return `self` plus `other` defensively.
+	fn defensive_saturating_add(self, other: Self) -> Self;
+	/// Return `self` minus `other` defensively.
+	fn defensive_saturating_sub(self, other: Self) -> Self;
+	/// Return the product of `self` and `other` defensively.
+	fn defensive_saturating_mul(self, other: Self) -> Self;
+	/// Increase `self` by `other` defensively.
+	fn defensive_saturating_accrue(&mut self, other: Self);
+	/// Reduce `self` by `other` defensively.
+	fn defensive_saturating_reduce(&mut self, other: Self);
+	/// Increment `self` by one defensively.
+	fn defensive_saturating_inc(&mut self);
+	/// Decrement `self` by one defensively.
+	fn defensive_saturating_dec(&mut self);
+}
+
+// NOTE: A bit unfortunate, since T has to be bound by all the traits needed. Could make it
+// `DefensiveSaturating<T>` to mitigate.
+impl<T: Saturating + CheckedAdd + CheckedMul + CheckedSub + One> DefensiveSaturating for T {
+	fn defensive_saturating_add(self, other: Self) -> Self {
+		self.checked_add(&other).defensive_unwrap_or_else(|| self.saturating_add(other))
+	}
+	fn defensive_saturating_sub(self, other: Self) -> Self {
+		self.checked_sub(&other).defensive_unwrap_or_else(|| self.saturating_sub(other))
+	}
+	fn defensive_saturating_mul(self, other: Self) -> Self {
+		self.checked_mul(&other).defensive_unwrap_or_else(|| self.saturating_mul(other))
+	}
+	fn defensive_saturating_accrue(&mut self, other: Self) {
+		// Use `replace` here since `take` would require `T: Default`.
+		*self = sp_std::mem::replace(self, One::one()).defensive_saturating_add(other);
+	}
+	fn defensive_saturating_reduce(&mut self, other: Self) {
+		// Use `replace` here since `take` would require `T: Default`.
+		*self = sp_std::mem::replace(self, One::one()).defensive_saturating_sub(other);
+	}
+	fn defensive_saturating_inc(&mut self) {
+		self.defensive_saturating_accrue(One::one());
+	}
+	fn defensive_saturating_dec(&mut self) {
+		self.defensive_saturating_reduce(One::one());
+	}
+}
+
+/// Construct an object by defensively truncating an input if the `TryFrom` conversion fails.
+pub trait DefensiveTruncateFrom<T> {
+	/// Use `TryFrom` first and defensively fall back to truncating otherwise.
+	///
+	/// # Example
+	///
+	/// ```
+	/// use frame_support::{BoundedVec, traits::DefensiveTruncateFrom};
+	/// use sp_runtime::traits::ConstU32;
+	///
+	/// let unbound = vec![1, 2];
+	/// let bound = BoundedVec::<u8, ConstU32<2>>::defensive_truncate_from(unbound);
+	///
+	/// assert_eq!(bound, vec![1, 2]);
+	/// ```
+	fn defensive_truncate_from(unbound: T) -> Self;
+}
+
+impl<T, U> DefensiveTruncateFrom<U> for T
+where
+	// NOTE: We use the fact that `BoundedVec` and
+	// `BoundedSlice` use `Self` as error type. We could also
+	// require a `Clone` bound and use `unbound.clone()` in the
+	// error case.
+	T: TruncateFrom<U> + TryFrom<U, Error = U>,
+{
+	fn defensive_truncate_from(unbound: U) -> Self {
+		unbound.try_into().map_or_else(
+			|err| {
+				defensive!("DefensiveTruncateFrom truncating");
+				T::truncate_from(err)
+			},
+			|bound| bound,
+		)
+	}
+}
+
+/// Defensively calculates the minimum of two values.
+///
+/// Can be used in contexts where we assume the receiver value to be (strictly) smaller.
+pub trait DefensiveMin<T> {
+	/// Returns the minimum and defensively checks that `self` is not larger than `other`.
+	///
+	/// # Example
+	///
+	/// ```
+	/// use frame_support::traits::DefensiveMin;
+	/// // min(3, 4) is 3.
+	/// assert_eq!(3, 3_u32.defensive_min(4_u32));
+	/// // min(4, 4) is 4.
+	/// assert_eq!(4, 4_u32.defensive_min(4_u32));
+	/// ```
+	///
+	/// ```#[cfg_attr(debug_assertions, should_panic)]
+	/// use frame_support::traits::DefensiveMin;
+	/// // min(4, 3) panics.
+	/// 4_u32.defensive_min(3_u32);
+	/// ```
+	fn defensive_min(self, other: T) -> Self;
+
+	/// Returns the minimum and defensively checks that `self` is smaller than `other`.
+	///
+	/// # Example
+	///
+	/// ```
+	/// use frame_support::traits::DefensiveMin;
+	/// // min(3, 4) is 3.
+	/// assert_eq!(3, 3_u32.defensive_strict_min(4_u32));
+	/// ```
+	///
+	/// ```#[cfg_attr(debug_assertions, should_panic)]
+	/// use frame_support::traits::DefensiveMin;
+	/// // min(4, 4) panics.
+	/// 4_u32.defensive_strict_min(4_u32);
+	/// ```
+	fn defensive_strict_min(self, other: T) -> Self;
+}
+
+impl<T> DefensiveMin<T> for T
+where
+	T: sp_std::cmp::PartialOrd<T>,
+{
+	fn defensive_min(self, other: T) -> Self {
+		if self <= other {
+			self
+		} else {
+			defensive!("DefensiveMin");
+			other
+		}
+	}
+
+	fn defensive_strict_min(self, other: T) -> Self {
+		if self < other {
+			self
+		} else {
+			defensive!("DefensiveMin strict");
+			other
+		}
+	}
+}
+
+/// Defensively calculates the maximum of two values.
+///
+/// Can be used in contexts where we assume the receiver value to be (strictly) larger.
+pub trait DefensiveMax<T> {
+	/// Returns the maximum and defensively asserts that `other` is not larger than `self`.
+	///
+	/// # Example
+	///
+	/// ```
+	/// use frame_support::traits::DefensiveMax;
+	/// // max(4, 3) is 4.
+	/// assert_eq!(4, 4_u32.defensive_max(3_u32));
+	/// // max(4, 4) is 4.
+	/// assert_eq!(4, 4_u32.defensive_max(4_u32));
+	/// ```
+	///
+	/// ```#[cfg_attr(debug_assertions, should_panic)]
+	/// use frame_support::traits::DefensiveMax;
+	/// // max(4, 5) panics.
+	/// 4_u32.defensive_max(5_u32);
+	/// ```
+	fn defensive_max(self, other: T) -> Self;
+
+	/// Returns the maximum and defensively asserts that `other` is smaller than `self`.
+	///
+	/// # Example
+	///
+	/// ```
+	/// use frame_support::traits::DefensiveMax;
+	/// // y(4, 3) is 4.
+	/// assert_eq!(4, 4_u32.defensive_strict_max(3_u32));
+	/// ```
+	///
+	/// ```#[cfg_attr(debug_assertions, should_panic)]
+	/// use frame_support::traits::DefensiveMax;
+	/// // max(4, 4) panics.
+	/// 4_u32.defensive_strict_max(4_u32);
+	/// ```
+	fn defensive_strict_max(self, other: T) -> Self;
+}
+
+impl<T> DefensiveMax<T> for T
+where
+	T: sp_std::cmp::PartialOrd<T>,
+{
+	fn defensive_max(self, other: T) -> Self {
+		if self >= other {
+			self
+		} else {
+			defensive!("DefensiveMax");
+			other
+		}
+	}
+
+	fn defensive_strict_max(self, other: T) -> Self {
+		if self > other {
+			self
+		} else {
+			defensive!("DefensiveMax strict");
+			other
+		}
+	}
+}
+
+/// Anything that can have a `::len()` method.
+pub trait Len {
+	/// Return the length of data type.
+	fn len(&self) -> usize;
+}
+
+impl<T: IntoIterator + Clone> Len for T
+where
+	<T as IntoIterator>::IntoIter: ExactSizeIterator,
+{
+	fn len(&self) -> usize {
+		self.clone().into_iter().len()
+	}
+}
+
+/// A type for which some values make sense to be able to drop without further consideration.
+pub trait TryDrop: Sized {
+	/// Drop an instance cleanly. Only works if its value represents "no-operation".
+	fn try_drop(self) -> Result<(), Self>;
+}
+
+impl TryDrop for () {
+	fn try_drop(self) -> Result<(), Self> {
+		Ok(())
+	}
+}
+
+/// Return type used when we need to return one of two items, each of the opposite direction or
+/// sign, with one (`Same`) being of the same type as the `self` or primary argument of the function
+/// that returned it.
+pub enum SameOrOther<A, B> {
+	/// No item.
+	None,
+	/// An item of the same type as the `Self` on which the return function was called.
+	Same(A),
+	/// An item of the opposite type to the `Self` on which the return function was called.
+	Other(B),
+}
+
+impl<A, B> TryDrop for SameOrOther<A, B> {
+	fn try_drop(self) -> Result<(), Self> {
+		if let SameOrOther::None = self {
+			Ok(())
+		} else {
+			Err(self)
+		}
+	}
+}
+
+impl<A, B> SameOrOther<A, B> {
+	/// Returns `Ok` with the inner value of `Same` if `self` is that, otherwise returns `Err` with
+	/// `self`.
+	pub fn try_same(self) -> Result<A, Self> {
+		match self {
+			SameOrOther::Same(a) => Ok(a),
+			x => Err(x),
+		}
+	}
+
+	/// Returns `Ok` with the inner value of `Other` if `self` is that, otherwise returns `Err` with
+	/// `self`.
+	pub fn try_other(self) -> Result<B, Self> {
+		match self {
+			SameOrOther::Other(b) => Ok(b),
+			x => Err(x),
+		}
+	}
+
+	/// Returns `Ok` if `self` is `None`, otherwise returns `Err` with `self`.
+	pub fn try_none(self) -> Result<(), Self> {
+		match self {
+			SameOrOther::None => Ok(()),
+			x => Err(x),
+		}
+	}
+
+	pub fn same(self) -> Result<A, B>
+	where
+		A: Default,
+	{
+		match self {
+			SameOrOther::Same(a) => Ok(a),
+			SameOrOther::None => Ok(A::default()),
+			SameOrOther::Other(b) => Err(b),
+		}
+	}
+
+	pub fn other(self) -> Result<B, A>
+	where
+		B: Default,
+	{
+		match self {
+			SameOrOther::Same(a) => Err(a),
+			SameOrOther::None => Ok(B::default()),
+			SameOrOther::Other(b) => Ok(b),
+		}
+	}
+}
+
+/// Handler for when a new account has been created.
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+pub trait OnNewAccount<AccountId> {
+	/// A new account `who` has been registered.
+	fn on_new_account(who: &AccountId);
+}
+
+/// The account with the given id was reaped.
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+pub trait OnKilledAccount<AccountId> {
+	/// The account with the given id was reaped.
+	fn on_killed_account(who: &AccountId);
+}
+
+/// A simple, generic one-parameter event notifier/handler.
+pub trait HandleLifetime<T> {
+	/// An account was created.
+	fn created(_t: &T) -> Result<(), DispatchError> {
+		Ok(())
+	}
+
+	/// An account was killed.
+	fn killed(_t: &T) -> Result<(), DispatchError> {
+		Ok(())
+	}
+}
+
+impl<T> HandleLifetime<T> for () {}
+
+pub trait Time {
+	type Moment: sp_arithmetic::traits::AtLeast32Bit + Parameter + Default + Copy + MaxEncodedLen;
+
+	fn now() -> Self::Moment;
+}
+
+/// Trait to deal with unix time.
+pub trait UnixTime {
+	/// Return duration since `SystemTime::UNIX_EPOCH`.
+	fn now() -> core::time::Duration;
+}
+
+/// Trait to be used when types are exactly same.
+///
+/// This allow to convert back and forth from type, a reference and a mutable reference.
+pub trait IsType<T>: Into<T> + From<T> {
+	/// Cast reference.
+	fn from_ref(t: &T) -> &Self;
+
+	/// Cast reference.
+	fn into_ref(&self) -> &T;
+
+	/// Cast mutable reference.
+	fn from_mut(t: &mut T) -> &mut Self;
+
+	/// Cast mutable reference.
+	fn into_mut(&mut self) -> &mut T;
+}
+
+impl<T> IsType<T> for T {
+	fn from_ref(t: &T) -> &Self {
+		t
+	}
+	fn into_ref(&self) -> &T {
+		self
+	}
+	fn from_mut(t: &mut T) -> &mut Self {
+		t
+	}
+	fn into_mut(&mut self) -> &mut T {
+		self
+	}
+}
+
+/// Something that can be checked to be a of sub type `T`.
+///
+/// This is useful for enums where each variant encapsulates a different sub type, and
+/// you need access to these sub types.
+///
+/// For example, in FRAME, this trait is implemented for the runtime `Call` enum. Pallets use this
+/// to check if a certain call is an instance of the local pallet's `Call` enum.
+///
+/// # Example
+///
+/// ```
+/// # use frame_support::traits::IsSubType;
+///
+/// enum Test {
+///     String(String),
+///     U32(u32),
+/// }
+///
+/// impl IsSubType<String> for Test {
+///     fn is_sub_type(&self) -> Option<&String> {
+///         match self {
+///             Self::String(ref r) => Some(r),
+///             _ => None,
+///         }
+///     }
+/// }
+///
+/// impl IsSubType<u32> for Test {
+///     fn is_sub_type(&self) -> Option<&u32> {
+///         match self {
+///             Self::U32(ref r) => Some(r),
+///             _ => None,
+///         }
+///     }
+/// }
+///
+/// fn main() {
+///     let data = Test::String("test".into());
+///
+///     assert_eq!("test", IsSubType::<String>::is_sub_type(&data).unwrap().as_str());
+/// }
+/// ```
+pub trait IsSubType<T> {
+	/// Returns `Some(_)` if `self` is an instance of sub type `T`.
+	fn is_sub_type(&self) -> Option<&T>;
+}
+
+/// Something that can execute a given block.
+///
+/// Executing a block means that all extrinsics in a given block will be executed and the resulting
+/// header will be checked against the header of the given block.
+pub trait ExecuteBlock<Block: BlockT> {
+	/// Execute the given `block`.
+	///
+	/// This will execute all extrinsics in the block and check that the resulting header is
+	/// correct.
+	///
+	/// # Panic
+	///
+	/// Panics when an extrinsics panics or the resulting header doesn't match the expected header.
+	fn execute_block(block: Block);
+}
+
+/// Something that can compare privileges of two origins.
+pub trait PrivilegeCmp<Origin> {
+	/// Compare the `left` to the `right` origin.
+	///
+	/// The returned ordering should be from the pov of the `left` origin.
+	///
+	/// Should return `None` when it can not compare the given origins.
+	fn cmp_privilege(left: &Origin, right: &Origin) -> Option<Ordering>;
+}
+
+/// Implementation of [`PrivilegeCmp`] that only checks for equal origins.
+///
+/// This means it will either return [`Ordering::Equal`] or `None`.
+pub struct EqualPrivilegeOnly;
+impl<Origin: PartialEq> PrivilegeCmp<Origin> for EqualPrivilegeOnly {
+	fn cmp_privilege(left: &Origin, right: &Origin) -> Option<Ordering> {
+		(left == right).then(|| Ordering::Equal)
+	}
+}
+
+/// Off-chain computation trait.
+///
+/// Implementing this trait on a module allows you to perform long-running tasks
+/// that make (by default) validators generate transactions that feed results
+/// of those long-running computations back on chain.
+///
+/// NOTE: This function runs off-chain, so it can access the block state,
+/// but cannot preform any alterations. More specifically alterations are
+/// not forbidden, but they are not persisted in any way after the worker
+/// has finished.
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+pub trait OffchainWorker<BlockNumber> {
+	/// This function is being called after every block import (when fully synced).
+	///
+	/// Implement this and use any of the `Offchain` `sp_io` set of APIs
+	/// to perform off-chain computations, calls and submit transactions
+	/// with results to trigger any on-chain changes.
+	/// Any state alterations are lost and are not persisted.
+	fn offchain_worker(_n: BlockNumber) {}
+}
+
+/// Some amount of backing from a group. The precise definition of what it means to "back" something
+/// is left flexible.
+pub struct Backing {
+	/// The number of members of the group that back some motion.
+	pub approvals: u32,
+	/// The total count of group members.
+	pub eligible: u32,
+}
+
+/// Retrieve the backing from an object's ref.
+pub trait GetBacking {
+	/// Returns `Some` `Backing` if `self` represents a fractional/groupwise backing of some
+	/// implicit motion. `None` if it does not.
+	fn get_backing(&self) -> Option<Backing>;
+}
+
+/// A trait to ensure the inherent are before non-inherent in a block.
+///
+/// This is typically implemented on runtime, through `construct_runtime!`.
+pub trait EnsureInherentsAreFirst<Block> {
+	/// Ensure the position of inherent is correct, i.e. they are before non-inherents.
+	///
+	/// On error return the index of the inherent with invalid position (counting from 0).
+	fn ensure_inherents_are_first(block: &Block) -> Result<(), u32>;
+}
+
+/// An extrinsic on which we can get access to call.
+pub trait ExtrinsicCall: sp_runtime::traits::Extrinsic {
+	/// Get the call of the extrinsic.
+	fn call(&self) -> &Self::Call;
+}
+
+#[cfg(feature = "std")]
+impl<Call, Extra> ExtrinsicCall for sp_runtime::testing::TestXt<Call, Extra>
+where
+	Call: codec::Codec + Sync + Send + TypeInfo,
+	Extra: TypeInfo,
+{
+	fn call(&self) -> &Self::Call {
+		&self.call
+	}
+}
+
+impl<Address, Call, Signature, Extra> ExtrinsicCall
+	for sp_runtime::generic::UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Address: TypeInfo,
+	Call: TypeInfo,
+	Signature: TypeInfo,
+	Extra: sp_runtime::traits::SignedExtension + TypeInfo,
+{
+	fn call(&self) -> &Self::Call {
+		&self.function
+	}
+}
+
+/// Something that can estimate the fee of a (frame-based) call.
+///
+/// Typically, the same pallet that will charge transaction fees will implement this.
+pub trait EstimateCallFee<Call, Balance> {
+	/// Estimate the fee of this call.
+	///
+	/// The dispatch info and the length is deduced from the call. The post info can optionally be
+	/// provided.
+	fn estimate_call_fee(call: &Call, post_info: crate::dispatch::PostDispatchInfo) -> Balance;
+}
+
+// Useful for building mocks.
+#[cfg(feature = "std")]
+impl<Call, Balance: From<u32>, const T: u32> EstimateCallFee<Call, Balance> for ConstU32<T> {
+	fn estimate_call_fee(_: &Call, _: crate::dispatch::PostDispatchInfo) -> Balance {
+		T.into()
+	}
+}
+
+/// A wrapper for any type `T` which implement encode/decode in a way compatible with `Vec<u8>`.
+///
+/// The encoding is the encoding of `T` prepended with the compact encoding of its size in bytes.
+/// Thus the encoded value can be decoded as a `Vec<u8>`.
+#[derive(Debug, Eq, PartialEq, Default, Clone)]
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+pub struct WrapperOpaque<T>(pub T);
+
+impl<T: Encode> EncodeLike for WrapperOpaque<T> {}
+impl<T: Encode> EncodeLike<WrapperKeepOpaque<T>> for WrapperOpaque<T> {}
+
+impl<T: Encode> Encode for WrapperOpaque<T> {
+	fn size_hint(&self) -> usize {
+		self.0.size_hint().saturating_add(<codec::Compact<u32>>::max_encoded_len())
+	}
+
+	fn encode_to<O: codec::Output + ?Sized>(&self, dest: &mut O) {
+		self.0.encode().encode_to(dest);
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		self.0.encode().encode()
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.encode().using_encoded(f)
+	}
+}
+
+impl<T: Decode> Decode for WrapperOpaque<T> {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		Ok(Self(T::decode_all_with_depth_limit(
+			sp_api::MAX_EXTRINSIC_DEPTH,
+			&mut &<Vec<u8>>::decode(input)?[..],
+		)?))
+	}
+
+	fn skip<I: Input>(input: &mut I) -> Result<(), codec::Error> {
+		<Vec<u8>>::skip(input)
+	}
+}
+
+impl<T> From<T> for WrapperOpaque<T> {
+	fn from(t: T) -> Self {
+		Self(t)
+	}
+}
+
+impl<T: MaxEncodedLen> MaxEncodedLen for WrapperOpaque<T> {
+	fn max_encoded_len() -> usize {
+		let t_max_len = T::max_encoded_len();
+
+		// See scale encoding: https://docs.substrate.io/reference/scale-codec/
+		if t_max_len < 64 {
+			t_max_len + 1
+		} else if t_max_len < 2usize.pow(14) {
+			t_max_len + 2
+		} else if t_max_len < 2usize.pow(30) {
+			t_max_len + 4
+		} else {
+			<codec::Compact<u32>>::max_encoded_len().saturating_add(T::max_encoded_len())
+		}
+	}
+}
+
+impl<T: TypeInfo + 'static> TypeInfo for WrapperOpaque<T> {
+	type Identity = Self;
+	fn type_info() -> Type {
+		Type::builder()
+			.path(Path::new("WrapperOpaque", module_path!()))
+			.type_params(vec![TypeParameter::new("T", Some(meta_type::<T>()))])
+			.composite(
+				Fields::unnamed()
+					.field(|f| f.compact::<u32>())
+					.field(|f| f.ty::<T>().type_name("T")),
+			)
+	}
+}
+
+/// A wrapper for any type `T` which implement encode/decode in a way compatible with `Vec<u8>`.
+///
+/// This type is similar to [`WrapperOpaque`], but it differs in the way it stores the type `T`.
+/// While [`WrapperOpaque`] stores the decoded type, the [`WrapperKeepOpaque`] stores the type only
+/// in its opaque format, aka as a `Vec<u8>`. To access the real type `T` [`Self::try_decode`] needs
+/// to be used.
+#[derive(Debug, Eq, PartialEq, Default, Clone)]
+pub struct WrapperKeepOpaque<T> {
+	data: Vec<u8>,
+	_phantom: sp_std::marker::PhantomData<T>,
+}
+
+impl<T: Decode> WrapperKeepOpaque<T> {
+	/// Try to decode the wrapped type from the inner `data`.
+	///
+	/// Returns `None` if the decoding failed.
+	pub fn try_decode(&self) -> Option<T> {
+		T::decode_all_with_depth_limit(sp_api::MAX_EXTRINSIC_DEPTH, &mut &self.data[..]).ok()
+	}
+
+	/// Returns the length of the encoded `T`.
+	pub fn encoded_len(&self) -> usize {
+		self.data.len()
+	}
+
+	/// Returns the encoded data.
+	pub fn encoded(&self) -> &[u8] {
+		&self.data
+	}
+
+	/// Create from the given encoded `data`.
+	pub fn from_encoded(data: Vec<u8>) -> Self {
+		Self { data, _phantom: sp_std::marker::PhantomData }
+	}
+}
+
+impl<T: Encode> EncodeLike for WrapperKeepOpaque<T> {}
+impl<T: Encode> EncodeLike<WrapperOpaque<T>> for WrapperKeepOpaque<T> {}
+
+impl<T: Encode> Encode for WrapperKeepOpaque<T> {
+	fn size_hint(&self) -> usize {
+		self.data.len() + codec::Compact::<u32>::compact_len(&(self.data.len() as u32))
+	}
+
+	fn encode_to<O: codec::Output + ?Sized>(&self, dest: &mut O) {
+		self.data.encode_to(dest);
+	}
+
+	fn encode(&self) -> Vec<u8> {
+		self.data.encode()
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.data.using_encoded(f)
+	}
+}
+
+impl<T: Decode> Decode for WrapperKeepOpaque<T> {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		Ok(Self { data: Vec::<u8>::decode(input)?, _phantom: sp_std::marker::PhantomData })
+	}
+
+	fn skip<I: Input>(input: &mut I) -> Result<(), codec::Error> {
+		<Vec<u8>>::skip(input)
+	}
+}
+
+impl<T: MaxEncodedLen> MaxEncodedLen for WrapperKeepOpaque<T> {
+	fn max_encoded_len() -> usize {
+		WrapperOpaque::<T>::max_encoded_len()
+	}
+}
+
+impl<T: TypeInfo + 'static> TypeInfo for WrapperKeepOpaque<T> {
+	type Identity = Self;
+	fn type_info() -> Type {
+		Type::builder()
+			.path(Path::new("WrapperKeepOpaque", module_path!()))
+			.type_params(vec![TypeParameter::new("T", Some(meta_type::<T>()))])
+			.composite(
+				Fields::unnamed()
+					.field(|f| f.compact::<u32>())
+					.field(|f| f.ty::<T>().type_name("T")),
+			)
+	}
+}
+
+/// A interface for looking up preimages from their hash on chain.
+pub trait PreimageProvider<Hash> {
+	/// Returns whether a preimage exists for a given hash.
+	///
+	/// A value of `true` implies that `get_preimage` is `Some`.
+	fn have_preimage(hash: &Hash) -> bool;
+
+	/// Returns the preimage for a given hash.
+	fn get_preimage(hash: &Hash) -> Option<Vec<u8>>;
+
+	/// Returns whether a preimage request exists for a given hash.
+	fn preimage_requested(hash: &Hash) -> bool;
+
+	/// Request that someone report a preimage. Providers use this to optimise the economics for
+	/// preimage reporting.
+	fn request_preimage(hash: &Hash);
+
+	/// Cancel a previous preimage request.
+	fn unrequest_preimage(hash: &Hash);
+}
+
+impl<Hash> PreimageProvider<Hash> for () {
+	fn have_preimage(_: &Hash) -> bool {
+		false
+	}
+	fn get_preimage(_: &Hash) -> Option<Vec<u8>> {
+		None
+	}
+	fn preimage_requested(_: &Hash) -> bool {
+		false
+	}
+	fn request_preimage(_: &Hash) {}
+	fn unrequest_preimage(_: &Hash) {}
+}
+
+/// A interface for managing preimages to hashes on chain.
+///
+/// Note that this API does not assume any underlying user is calling, and thus
+/// does not handle any preimage ownership or fees. Other system level logic that
+/// uses this API should implement that on their own side.
+pub trait PreimageRecipient<Hash>: PreimageProvider<Hash> {
+	/// Maximum size of a preimage.
+	type MaxSize: Get<u32>;
+
+	/// Store the bytes of a preimage on chain infallible due to the bounded type.
+	fn note_preimage(bytes: crate::BoundedVec<u8, Self::MaxSize>);
+
+	/// Clear a previously noted preimage. This is infallible and should be treated more like a
+	/// hint - if it was not previously noted or if it is now requested, then this will not do
+	/// anything.
+	fn unnote_preimage(hash: &Hash);
+}
+
+impl<Hash> PreimageRecipient<Hash> for () {
+	type MaxSize = ();
+	fn note_preimage(_: crate::BoundedVec<u8, Self::MaxSize>) {}
+	fn unnote_preimage(_: &Hash) {}
+}
+
+/// Trait for creating an asset account with a deposit taken from a designated depositor specified
+/// by the client.
+pub trait AccountTouch<AssetId, AccountId> {
+	/// The type for currency units of the deposit.
+	type Balance;
+
+	/// The deposit amount of a native currency required for creating an account of the `asset`.
+	fn deposit_required(asset: AssetId) -> Self::Balance;
+
+	/// Create an account for `who` of the `asset` with a deposit taken from the `depositor`.
+	fn touch(asset: AssetId, who: AccountId, depositor: AccountId) -> DispatchResult;
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use sp_core::bounded::{BoundedSlice, BoundedVec};
+	use sp_std::marker::PhantomData;
+
+	#[test]
+	fn defensive_assert_works() {
+		defensive_assert!(true);
+		defensive_assert!(true,);
+		defensive_assert!(true, "must work");
+		defensive_assert!(true, "must work",);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive failure has been triggered!: \"1 == 0\": \"Must fail\"")]
+	fn defensive_assert_panics() {
+		defensive_assert!(1 == 0, "Must fail");
+	}
+
+	#[test]
+	#[cfg(not(debug_assertions))]
+	fn defensive_assert_does_not_panic() {
+		defensive_assert!(1 == 0, "Must fail");
+	}
+
+	#[test]
+	#[cfg(not(debug_assertions))]
+	fn defensive_saturating_accrue_works() {
+		let mut v = 1_u32;
+		v.defensive_saturating_accrue(2);
+		assert_eq!(v, 3);
+		v.defensive_saturating_accrue(u32::MAX);
+		assert_eq!(v, u32::MAX);
+		v.defensive_saturating_accrue(1);
+		assert_eq!(v, u32::MAX);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive")]
+	fn defensive_saturating_accrue_panics() {
+		let mut v = u32::MAX;
+		v.defensive_saturating_accrue(1); // defensive failure
+	}
+
+	#[test]
+	#[cfg(not(debug_assertions))]
+	fn defensive_saturating_reduce_works() {
+		let mut v = u32::MAX;
+		v.defensive_saturating_reduce(3);
+		assert_eq!(v, u32::MAX - 3);
+		v.defensive_saturating_reduce(u32::MAX);
+		assert_eq!(v, 0);
+		v.defensive_saturating_reduce(1);
+		assert_eq!(v, 0);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive")]
+	fn defensive_saturating_reduce_panics() {
+		let mut v = 0_u32;
+		v.defensive_saturating_reduce(1); // defensive failure
+	}
+
+	#[test]
+	#[cfg(not(debug_assertions))]
+	fn defensive_saturating_inc_works() {
+		let mut v = 0_u32;
+		for i in 1..10 {
+			v.defensive_saturating_inc();
+			assert_eq!(v, i);
+		}
+		v += u32::MAX - 10;
+		v.defensive_saturating_inc();
+		assert_eq!(v, u32::MAX);
+		v.defensive_saturating_inc();
+		assert_eq!(v, u32::MAX);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive")]
+	fn defensive_saturating_inc_panics() {
+		let mut v = u32::MAX;
+		v.defensive_saturating_inc(); // defensive failure
+	}
+
+	#[test]
+	#[cfg(not(debug_assertions))]
+	fn defensive_saturating_dec_works() {
+		let mut v = u32::MAX;
+		for i in 1..10 {
+			v.defensive_saturating_dec();
+			assert_eq!(v, u32::MAX - i);
+		}
+		v -= u32::MAX - 10;
+		v.defensive_saturating_dec();
+		assert_eq!(v, 0);
+		v.defensive_saturating_dec();
+		assert_eq!(v, 0);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive")]
+	fn defensive_saturating_dec_panics() {
+		let mut v = 0_u32;
+		v.defensive_saturating_dec(); // defensive failure
+	}
+
+	#[test]
+	#[cfg(not(debug_assertions))]
+	fn defensive_truncating_from_vec_defensive_works() {
+		let unbound = vec![1u32, 2];
+		let bound = BoundedVec::<u32, ConstU32<1>>::defensive_truncate_from(unbound);
+		assert_eq!(bound, vec![1u32]);
+	}
+
+	#[test]
+	#[cfg(not(debug_assertions))]
+	fn defensive_truncating_from_slice_defensive_works() {
+		let unbound = &[1u32, 2];
+		let bound = BoundedSlice::<u32, ConstU32<1>>::defensive_truncate_from(unbound);
+		assert_eq!(bound, &[1u32][..]);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(
+		expected = "Defensive failure has been triggered!: \"DefensiveTruncateFrom truncating\""
+	)]
+	fn defensive_truncating_from_vec_defensive_panics() {
+		let unbound = vec![1u32, 2];
+		let _ = BoundedVec::<u32, ConstU32<1>>::defensive_truncate_from(unbound);
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(
+		expected = "Defensive failure has been triggered!: \"DefensiveTruncateFrom truncating\""
+	)]
+	fn defensive_truncating_from_slice_defensive_panics() {
+		let unbound = &[1u32, 2];
+		let _ = BoundedSlice::<u32, ConstU32<1>>::defensive_truncate_from(unbound);
+	}
+
+	#[test]
+	fn defensive_truncate_from_vec_works() {
+		let unbound = vec![1u32, 2, 3];
+		let bound = BoundedVec::<u32, ConstU32<3>>::defensive_truncate_from(unbound.clone());
+		assert_eq!(bound, unbound);
+	}
+
+	#[test]
+	fn defensive_truncate_from_slice_works() {
+		let unbound = [1u32, 2, 3];
+		let bound = BoundedSlice::<u32, ConstU32<3>>::defensive_truncate_from(&unbound);
+		assert_eq!(bound, &unbound[..]);
+	}
+
+	#[derive(Encode, Decode)]
+	enum NestedType {
+		Nested(Box<Self>),
+		Done,
+	}
+
+	#[test]
+	fn test_opaque_wrapper_decode_limit() {
+		let limit = sp_api::MAX_EXTRINSIC_DEPTH as usize;
+		let mut ok_bytes = vec![0u8; limit];
+		ok_bytes.push(1u8);
+		let mut err_bytes = vec![0u8; limit + 1];
+		err_bytes.push(1u8);
+		assert!(<WrapperOpaque<NestedType>>::decode(&mut &ok_bytes.encode()[..]).is_ok());
+		assert!(<WrapperOpaque<NestedType>>::decode(&mut &err_bytes.encode()[..]).is_err());
+
+		let ok_keep_opaque = WrapperKeepOpaque { data: ok_bytes, _phantom: PhantomData };
+		let err_keep_opaque = WrapperKeepOpaque { data: err_bytes, _phantom: PhantomData };
+
+		assert!(<WrapperKeepOpaque<NestedType>>::try_decode(&ok_keep_opaque).is_some());
+		assert!(<WrapperKeepOpaque<NestedType>>::try_decode(&err_keep_opaque).is_none());
+	}
+
+	#[test]
+	fn test_opaque_wrapper() {
+		let encoded = WrapperOpaque(3u32).encode();
+		assert_eq!(encoded, [codec::Compact(4u32).encode(), 3u32.to_le_bytes().to_vec()].concat());
+		let vec_u8 = <Vec<u8>>::decode(&mut &encoded[..]).unwrap();
+		let decoded_from_vec_u8 = u32::decode(&mut &vec_u8[..]).unwrap();
+		assert_eq!(decoded_from_vec_u8, 3u32);
+		let decoded = <WrapperOpaque<u32>>::decode(&mut &encoded[..]).unwrap();
+		assert_eq!(decoded.0, 3u32);
+
+		assert_eq!(<WrapperOpaque<[u8; 63]>>::max_encoded_len(), 63 + 1);
+		assert_eq!(
+			<WrapperOpaque<[u8; 63]>>::max_encoded_len(),
+			WrapperOpaque([0u8; 63]).encode().len()
+		);
+
+		assert_eq!(<WrapperOpaque<[u8; 64]>>::max_encoded_len(), 64 + 2);
+		assert_eq!(
+			<WrapperOpaque<[u8; 64]>>::max_encoded_len(),
+			WrapperOpaque([0u8; 64]).encode().len()
+		);
+
+		assert_eq!(
+			<WrapperOpaque<[u8; 2usize.pow(14) - 1]>>::max_encoded_len(),
+			2usize.pow(14) - 1 + 2
+		);
+		assert_eq!(<WrapperOpaque<[u8; 2usize.pow(14)]>>::max_encoded_len(), 2usize.pow(14) + 4);
+
+		let data = 4u64;
+		// Ensure that we check that the `Vec<u8>` is consumed completly on decode.
+		assert!(WrapperOpaque::<u32>::decode(&mut &data.encode().encode()[..]).is_err());
+	}
+
+	#[test]
+	fn test_keep_opaque_wrapper() {
+		let data = 3u32.encode().encode();
+
+		let keep_opaque = WrapperKeepOpaque::<u32>::decode(&mut &data[..]).unwrap();
+		keep_opaque.try_decode().unwrap();
+
+		let data = WrapperOpaque(50u32).encode();
+		let decoded = WrapperKeepOpaque::<u32>::decode(&mut &data[..]).unwrap();
+		let data = decoded.encode();
+		WrapperOpaque::<u32>::decode(&mut &data[..]).unwrap();
+	}
+
+	#[test]
+	fn defensive_min_works() {
+		assert_eq!(10, 10_u32.defensive_min(11_u32));
+		assert_eq!(10, 10_u32.defensive_min(10_u32));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive failure has been triggered!: \"DefensiveMin\"")]
+	fn defensive_min_panics() {
+		10_u32.defensive_min(9_u32);
+	}
+
+	#[test]
+	fn defensive_strict_min_works() {
+		assert_eq!(10, 10_u32.defensive_strict_min(11_u32));
+		assert_eq!(9, 9_u32.defensive_strict_min(10_u32));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive failure has been triggered!: \"DefensiveMin strict\"")]
+	fn defensive_strict_min_panics() {
+		9_u32.defensive_strict_min(9_u32);
+	}
+
+	#[test]
+	fn defensive_max_works() {
+		assert_eq!(11, 11_u32.defensive_max(10_u32));
+		assert_eq!(10, 10_u32.defensive_max(10_u32));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive failure has been triggered!: \"DefensiveMax\"")]
+	fn defensive_max_panics() {
+		9_u32.defensive_max(10_u32);
+	}
+
+	#[test]
+	fn defensive_strict_max_works() {
+		assert_eq!(11, 11_u32.defensive_strict_max(10_u32));
+		assert_eq!(10, 10_u32.defensive_strict_max(9_u32));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Defensive failure has been triggered!: \"DefensiveMax strict\"")]
+	fn defensive_strict_max_panics() {
+		9_u32.defensive_strict_max(9_u32);
+	}
+}
diff --git a/substrate/frame/support/src/traits/preimages.rs b/substrate/frame/support/src/traits/preimages.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3e78116202b4f0d0a3d85561a06bb095e56b2815
--- /dev/null
+++ b/substrate/frame/support/src/traits/preimages.rs
@@ -0,0 +1,331 @@
+// 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.
+
+//! Stuff for dealing with 32-byte hashed preimages.
+
+use codec::{Decode, Encode, EncodeLike, MaxEncodedLen};
+use sp_core::{RuntimeDebug, H256};
+use sp_io::hashing::blake2_256;
+use sp_runtime::{traits::ConstU32, DispatchError};
+use sp_std::borrow::Cow;
+
+pub type Hash = H256;
+pub type BoundedInline = crate::BoundedVec<u8, ConstU32<128>>;
+
+/// The maximum we expect a single legacy hash lookup to be.
+const MAX_LEGACY_LEN: u32 = 1_000_000;
+
+#[derive(
+	Encode, Decode, MaxEncodedLen, Clone, Eq, PartialEq, scale_info::TypeInfo, RuntimeDebug,
+)]
+#[codec(mel_bound())]
+pub enum Bounded<T> {
+	/// A Blake2 256 hash with no preimage length. We
+	/// do not support creation of this except for transitioning from legacy state.
+	/// In the future we will make this a pure `Dummy` item storing only the final `dummy` field.
+	Legacy { hash: Hash, dummy: sp_std::marker::PhantomData<T> },
+	/// A an bounded `Call`. Its encoding must be at most 128 bytes.
+	Inline(BoundedInline),
+	/// A Blake2-256 hash of the call together with an upper limit for its size.
+	Lookup { hash: Hash, len: u32 },
+}
+
+impl<T> Bounded<T> {
+	/// Casts the wrapped type into something that encodes alike.
+	///
+	/// # Examples
+	/// ```
+	/// use frame_support::traits::Bounded;
+	///
+	/// // Transmute from `String` to `&str`.
+	/// let x: Bounded<String> = Bounded::Inline(Default::default());
+	/// let _: Bounded<&str> = x.transmute();
+	/// ```
+	pub fn transmute<S: Encode>(self) -> Bounded<S>
+	where
+		T: Encode + EncodeLike<S>,
+	{
+		use Bounded::*;
+		match self {
+			Legacy { hash, .. } => Legacy { hash, dummy: sp_std::marker::PhantomData },
+			Inline(x) => Inline(x),
+			Lookup { hash, len } => Lookup { hash, len },
+		}
+	}
+
+	/// Returns the hash of the preimage.
+	///
+	/// The hash is re-calculated every time if the preimage is inlined.
+	pub fn hash(&self) -> Hash {
+		use Bounded::*;
+		match self {
+			Lookup { hash, .. } | Legacy { hash, .. } => *hash,
+			Inline(x) => blake2_256(x.as_ref()).into(),
+		}
+	}
+
+	/// Returns the hash to lookup the preimage.
+	///
+	/// If this is a `Bounded::Inline`, `None` is returned as no lookup is required.
+	pub fn lookup_hash(&self) -> Option<Hash> {
+		use Bounded::*;
+		match self {
+			Lookup { hash, .. } | Legacy { hash, .. } => Some(*hash),
+			Inline(_) => None,
+		}
+	}
+
+	/// Returns the length of the preimage or `None` if the length is unknown.
+	pub fn len(&self) -> Option<u32> {
+		match self {
+			Self::Legacy { .. } => None,
+			Self::Inline(i) => Some(i.len() as u32),
+			Self::Lookup { len, .. } => Some(*len),
+		}
+	}
+
+	/// Returns whether the image will require a lookup to be peeked.
+	pub fn lookup_needed(&self) -> bool {
+		match self {
+			Self::Inline(..) => false,
+			Self::Legacy { .. } | Self::Lookup { .. } => true,
+		}
+	}
+
+	/// The maximum length of the lookup that is needed to peek `Self`.
+	pub fn lookup_len(&self) -> Option<u32> {
+		match self {
+			Self::Inline(..) => None,
+			Self::Legacy { .. } => Some(MAX_LEGACY_LEN),
+			Self::Lookup { len, .. } => Some(*len),
+		}
+	}
+
+	/// Constructs a `Lookup` bounded item.
+	pub fn unrequested(hash: Hash, len: u32) -> Self {
+		Self::Lookup { hash, len }
+	}
+
+	/// Constructs a `Legacy` bounded item.
+	#[deprecated = "This API is only for transitioning to Scheduler v3 API"]
+	pub fn from_legacy_hash(hash: impl Into<Hash>) -> Self {
+		Self::Legacy { hash: hash.into(), dummy: sp_std::marker::PhantomData }
+	}
+}
+
+pub type FetchResult = Result<Cow<'static, [u8]>, DispatchError>;
+
+/// A interface for looking up preimages from their hash on chain.
+pub trait QueryPreimage {
+	/// Returns whether a preimage exists for a given hash and if so its length.
+	fn len(hash: &Hash) -> Option<u32>;
+
+	/// Returns the preimage for a given hash. If given, `len` must be the size of the preimage.
+	fn fetch(hash: &Hash, len: Option<u32>) -> FetchResult;
+
+	/// Returns whether a preimage request exists for a given hash.
+	fn is_requested(hash: &Hash) -> bool;
+
+	/// Request that someone report a preimage. Providers use this to optimise the economics for
+	/// preimage reporting.
+	fn request(hash: &Hash);
+
+	/// Cancel a previous preimage request.
+	fn unrequest(hash: &Hash);
+
+	/// Request that the data required for decoding the given `bounded` value is made available.
+	fn hold<T>(bounded: &Bounded<T>) {
+		use Bounded::*;
+		match bounded {
+			Inline(..) => {},
+			Legacy { hash, .. } | Lookup { hash, .. } => Self::request(hash),
+		}
+	}
+
+	/// No longer request that the data required for decoding the given `bounded` value is made
+	/// available.
+	fn drop<T>(bounded: &Bounded<T>) {
+		use Bounded::*;
+		match bounded {
+			Inline(..) => {},
+			Legacy { hash, .. } | Lookup { hash, .. } => Self::unrequest(hash),
+		}
+	}
+
+	/// Check to see if all data required for the given `bounded` value is available for its
+	/// decoding.
+	fn have<T>(bounded: &Bounded<T>) -> bool {
+		use Bounded::*;
+		match bounded {
+			Inline(..) => true,
+			Legacy { hash, .. } | Lookup { hash, .. } => Self::len(hash).is_some(),
+		}
+	}
+
+	/// Create a `Bounded` instance based on the `hash` and `len` of the encoded value.
+	///
+	/// It also directly requests the given `hash` using [`Self::request`].
+	///
+	/// This may not be `peek`-able or `realize`-able.
+	fn pick<T>(hash: Hash, len: u32) -> Bounded<T> {
+		Self::request(&hash);
+		Bounded::Lookup { hash, len }
+	}
+
+	/// Convert the given `bounded` instance back into its original instance, also returning the
+	/// exact size of its encoded form if it needed to be looked-up from a stored preimage).
+	///
+	/// NOTE: This does not remove any data needed for realization. If you will no longer use the
+	/// `bounded`, call `realize` instead or call `drop` afterwards.
+	fn peek<T: Decode>(bounded: &Bounded<T>) -> Result<(T, Option<u32>), DispatchError> {
+		use Bounded::*;
+		match bounded {
+			Inline(data) => T::decode(&mut &data[..]).ok().map(|x| (x, None)),
+			Lookup { hash, len } => {
+				let data = Self::fetch(hash, Some(*len))?;
+				T::decode(&mut &data[..]).ok().map(|x| (x, Some(data.len() as u32)))
+			},
+			Legacy { hash, .. } => {
+				let data = Self::fetch(hash, None)?;
+				T::decode(&mut &data[..]).ok().map(|x| (x, Some(data.len() as u32)))
+			},
+		}
+		.ok_or(DispatchError::Corruption)
+	}
+
+	/// Convert the given `bounded` value back into its original instance. If successful,
+	/// `drop` any data backing it. This will not break the realisability of independently
+	/// created instances of `Bounded` which happen to have identical data.
+	fn realize<T: Decode>(bounded: &Bounded<T>) -> Result<(T, Option<u32>), DispatchError> {
+		let r = Self::peek(bounded)?;
+		Self::drop(bounded);
+		Ok(r)
+	}
+}
+
+/// A interface for managing preimages to hashes on chain.
+///
+/// Note that this API does not assume any underlying user is calling, and thus
+/// does not handle any preimage ownership or fees. Other system level logic that
+/// uses this API should implement that on their own side.
+pub trait StorePreimage: QueryPreimage {
+	/// The maximum length of preimage we can store.
+	///
+	/// This is the maximum length of the *encoded* value that can be passed to `bound`.
+	const MAX_LENGTH: usize;
+
+	/// Request and attempt to store the bytes of a preimage on chain.
+	///
+	/// May return `DispatchError::Exhausted` if the preimage is just too big.
+	fn note(bytes: Cow<[u8]>) -> Result<Hash, DispatchError>;
+
+	/// Attempt to clear a previously noted preimage. Exactly the same as `unrequest` but is
+	/// provided for symmetry.
+	fn unnote(hash: &Hash) {
+		Self::unrequest(hash)
+	}
+
+	/// Convert an otherwise unbounded or large value into a type ready for placing in storage.
+	///
+	/// The result is a type whose `MaxEncodedLen` is 131 bytes.
+	///
+	/// NOTE: Once this API is used, you should use either `drop` or `realize`.
+	/// The value is also noted using [`Self::note`].
+	fn bound<T: Encode>(t: T) -> Result<Bounded<T>, DispatchError> {
+		let data = t.encode();
+		let len = data.len() as u32;
+		Ok(match BoundedInline::try_from(data) {
+			Ok(bounded) => Bounded::Inline(bounded),
+			Err(unbounded) => Bounded::Lookup { hash: Self::note(unbounded.into())?, len },
+		})
+	}
+}
+
+impl QueryPreimage for () {
+	fn len(_: &Hash) -> Option<u32> {
+		None
+	}
+	fn fetch(_: &Hash, _: Option<u32>) -> FetchResult {
+		Err(DispatchError::Unavailable)
+	}
+	fn is_requested(_: &Hash) -> bool {
+		false
+	}
+	fn request(_: &Hash) {}
+	fn unrequest(_: &Hash) {}
+}
+
+impl StorePreimage for () {
+	const MAX_LENGTH: usize = 0;
+	fn note(_: Cow<[u8]>) -> Result<Hash, DispatchError> {
+		Err(DispatchError::Exhausted)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::BoundedVec;
+	use sp_runtime::bounded_vec;
+
+	#[test]
+	fn bounded_size_is_correct() {
+		assert_eq!(<Bounded<Vec<u8>> as MaxEncodedLen>::max_encoded_len(), 131);
+	}
+
+	#[test]
+	fn bounded_basic_works() {
+		let data: BoundedVec<u8, _> = bounded_vec![b'a', b'b', b'c'];
+		let len = data.len() as u32;
+		let hash = blake2_256(&data).into();
+
+		// Inline works
+		{
+			let bound: Bounded<Vec<u8>> = Bounded::Inline(data.clone());
+			assert_eq!(bound.hash(), hash);
+			assert_eq!(bound.len(), Some(len));
+			assert!(!bound.lookup_needed());
+			assert_eq!(bound.lookup_len(), None);
+		}
+		// Legacy works
+		{
+			let bound: Bounded<Vec<u8>> = Bounded::Legacy { hash, dummy: Default::default() };
+			assert_eq!(bound.hash(), hash);
+			assert_eq!(bound.len(), None);
+			assert!(bound.lookup_needed());
+			assert_eq!(bound.lookup_len(), Some(1_000_000));
+		}
+		// Lookup works
+		{
+			let bound: Bounded<Vec<u8>> = Bounded::Lookup { hash, len: data.len() as u32 };
+			assert_eq!(bound.hash(), hash);
+			assert_eq!(bound.len(), Some(len));
+			assert!(bound.lookup_needed());
+			assert_eq!(bound.lookup_len(), Some(len));
+		}
+	}
+
+	#[test]
+	fn bounded_transmuting_works() {
+		let data: BoundedVec<u8, _> = bounded_vec![b'a', b'b', b'c'];
+
+		// Transmute a `String` into a `&str`.
+		let x: Bounded<String> = Bounded::Inline(data.clone());
+		let y: Bounded<&str> = x.transmute();
+		assert_eq!(y, Bounded::Inline(data));
+	}
+}
diff --git a/substrate/frame/support/src/traits/randomness.rs b/substrate/frame/support/src/traits/randomness.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3666a486465f9a32e83aff7c495a48963fdcb6b5
--- /dev/null
+++ b/substrate/frame/support/src/traits/randomness.rs
@@ -0,0 +1,54 @@
+// 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.
+
+//! Traits for dealing with on-chain randomness.
+
+/// A trait that is able to provide randomness.
+///
+/// Being a deterministic blockchain, real randomness is difficult to come by, different
+/// implementations of this trait will provide different security guarantees. At best,
+/// this will be randomness which was hard to predict a long time ago, but that has become
+/// easy to predict recently.
+pub trait Randomness<Output, BlockNumber> {
+	/// Get the most recently determined random seed, along with the time in the past
+	/// since when it was determinable by chain observers.
+	///
+	/// `subject` is a context identifier and allows you to get a different result to
+	/// other callers of this function; use it like `random(&b"my context"[..])`.
+	///
+	/// NOTE: The returned seed should only be used to distinguish commitments made before
+	/// the returned block number. If the block number is too early (i.e. commitments were
+	/// made afterwards), then ensure no further commitments may be made and repeatedly
+	/// call this on later blocks until the block number returned is later than the latest
+	/// commitment.
+	fn random(subject: &[u8]) -> (Output, BlockNumber);
+
+	/// Get the basic random seed.
+	///
+	/// In general you won't want to use this, but rather `Self::random` which allows
+	/// you to give a subject for the random result and whose value will be
+	/// independently low-influence random from any other such seeds.
+	///
+	/// NOTE: The returned seed should only be used to distinguish commitments made before
+	/// the returned block number. If the block number is too early (i.e. commitments were
+	/// made afterwards), then ensure no further commitments may be made and repeatedly
+	/// call this on later blocks until the block number returned is later than the latest
+	/// commitment.
+	fn random_seed() -> (Output, BlockNumber) {
+		Self::random(&[][..])
+	}
+}
diff --git a/substrate/frame/support/src/traits/safe_mode.rs b/substrate/frame/support/src/traits/safe_mode.rs
new file mode 100644
index 0000000000000000000000000000000000000000..332e28d6e52a91000875ce788dfc2b7c5e17dfcb
--- /dev/null
+++ b/substrate/frame/support/src/traits/safe_mode.rs
@@ -0,0 +1,76 @@
+// 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.
+
+//! Types to put the runtime into safe mode.
+
+/// Can put the runtime into a safe mode.
+///
+/// When the runtime entered safe mode, transaction processing for most general transactions is
+/// paused.
+pub trait SafeMode {
+	/// Block number type.
+	type BlockNumber;
+
+	/// Whether safe mode is entered.
+	fn is_entered() -> bool {
+		Self::remaining().is_some()
+	}
+
+	/// How many more blocks safe mode will stay entered.
+	///
+	/// If this returns `0`, then safe mode will exit in the next block.
+	fn remaining() -> Option<Self::BlockNumber>;
+
+	/// Enter safe mode for `duration` blocks.
+	///
+	/// Should error when already entered with `AlreadyEntered`.
+	fn enter(duration: Self::BlockNumber) -> Result<(), SafeModeError>;
+
+	/// Extend safe mode for `duration` blocks.
+	///
+	/// Should error when not entered with `AlreadyExited`.
+	fn extend(duration: Self::BlockNumber) -> Result<(), SafeModeError>;
+
+	/// Exit safe mode immediately.
+	///
+	/// This takes effect already in the same block.
+	fn exit() -> Result<(), SafeModeError>;
+}
+
+/// The error type for [`SafeMode`].
+pub enum SafeModeError {
+	/// Safe mode is already entered.
+	AlreadyEntered,
+	/// Safe mode is already exited.
+	AlreadyExited,
+	/// Unknown error.
+	Unknown,
+}
+
+/// A trait to notify when the runtime enters or exits safe mode.
+pub trait SafeModeNotify {
+	/// Called when the runtime enters safe mode.
+	fn entered();
+
+	/// Called when the runtime exits safe mode.
+	fn exited();
+}
+
+impl SafeModeNotify for () {
+	fn entered() {}
+	fn exited() {}
+}
diff --git a/substrate/frame/support/src/traits/schedule.rs b/substrate/frame/support/src/traits/schedule.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74a5951142d522861b568e28023a791a493ac4e6
--- /dev/null
+++ b/substrate/frame/support/src/traits/schedule.rs
@@ -0,0 +1,477 @@
+// 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.
+
+//! Traits and associated utilities for scheduling dispatchables in FRAME.
+
+#[allow(deprecated)]
+use super::PreimageProvider;
+use codec::{Codec, Decode, Encode, EncodeLike, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{traits::Saturating, DispatchError, RuntimeDebug};
+use sp_std::{fmt::Debug, prelude::*, result::Result};
+
+/// Information relating to the period of a scheduled task. First item is the length of the
+/// period and the second is the number of times it should be executed in total before the task
+/// is considered finished and removed.
+pub type Period<BlockNumber> = (BlockNumber, u32);
+
+/// Priority with which a call is scheduled. It's just a linear amount with lowest values meaning
+/// higher priority.
+pub type Priority = u8;
+
+/// The dispatch time of a scheduled task.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum DispatchTime<BlockNumber> {
+	/// At specified block.
+	At(BlockNumber),
+	/// After specified number of blocks.
+	After(BlockNumber),
+}
+
+impl<BlockNumber: Saturating + Copy> DispatchTime<BlockNumber> {
+	pub fn evaluate(&self, since: BlockNumber) -> BlockNumber {
+		match &self {
+			Self::At(m) => *m,
+			Self::After(m) => m.saturating_add(since),
+		}
+	}
+}
+
+/// The highest priority. We invert the value so that normal sorting will place the highest
+/// priority at the beginning of the list.
+pub const HIGHEST_PRIORITY: Priority = 0;
+/// Anything of this value or lower will definitely be scheduled on the block that they ask for,
+/// even if it breaches the `MaximumWeight` limitation.
+pub const HARD_DEADLINE: Priority = 63;
+/// The lowest priority. Most stuff should be around here.
+pub const LOWEST_PRIORITY: Priority = 255;
+
+/// Type representing an encodable value or the hash of the encoding of such a value.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum MaybeHashed<T, Hash> {
+	/// The value itself.
+	Value(T),
+	/// The hash of the encoded value which this value represents.
+	Hash(Hash),
+}
+
+impl<T, H> From<T> for MaybeHashed<T, H> {
+	fn from(t: T) -> Self {
+		MaybeHashed::Value(t)
+	}
+}
+
+/// Error type for `MaybeHashed::lookup`.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum LookupError {
+	/// A call of this hash was not known.
+	Unknown,
+	/// The preimage for this hash was known but could not be decoded into a `Call`.
+	BadFormat,
+}
+
+impl<T: Decode, H> MaybeHashed<T, H> {
+	pub fn as_value(&self) -> Option<&T> {
+		match &self {
+			Self::Value(c) => Some(c),
+			Self::Hash(_) => None,
+		}
+	}
+
+	pub fn as_hash(&self) -> Option<&H> {
+		match &self {
+			Self::Value(_) => None,
+			Self::Hash(h) => Some(h),
+		}
+	}
+
+	pub fn ensure_requested<P: PreimageProvider<H>>(&self) {
+		match &self {
+			Self::Value(_) => (),
+			Self::Hash(hash) => P::request_preimage(hash),
+		}
+	}
+
+	pub fn ensure_unrequested<P: PreimageProvider<H>>(&self) {
+		match &self {
+			Self::Value(_) => (),
+			Self::Hash(hash) => P::unrequest_preimage(hash),
+		}
+	}
+
+	pub fn resolved<P: PreimageProvider<H>>(self) -> (Self, Option<H>) {
+		match self {
+			Self::Value(c) => (Self::Value(c), None),
+			Self::Hash(h) => {
+				let data = match P::get_preimage(&h) {
+					Some(p) => p,
+					None => return (Self::Hash(h), None),
+				};
+				match T::decode(&mut &data[..]) {
+					Ok(c) => (Self::Value(c), Some(h)),
+					Err(_) => (Self::Hash(h), None),
+				}
+			},
+		}
+	}
+}
+
+// TODO: deprecate
+pub mod v1 {
+	use super::*;
+
+	/// A type that can be used as a scheduler.
+	pub trait Anon<BlockNumber, Call, RuntimeOrigin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + Debug + TypeInfo + MaxEncodedLen;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// This is not named.
+		fn schedule(
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: RuntimeOrigin,
+			call: Call,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Cancel a scheduled task. If periodic, then it will cancel all further instances of that,
+		/// also.
+		///
+		/// Will return an error if the `address` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		///
+		/// NOTE2: This will not work to cancel periodic tasks after their initial execution. For
+		/// that, you must name the task explicitly using the `Named` trait.
+		fn cancel(address: Self::Address) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block. For periodic tasks,
+		/// this dispatch is guaranteed to succeed only before the *initial* execution; for
+		/// others, use `reschedule_named`.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn reschedule(
+			address: Self::Address,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, ()>;
+	}
+
+	/// A type that can be used as a scheduler.
+	pub trait Named<BlockNumber, Call, RuntimeOrigin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + sp_std::fmt::Debug + MaxEncodedLen;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// - `id`: The identity of the task. This must be unique and will return an error if not.
+		fn schedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: RuntimeOrigin,
+			call: Call,
+		) -> Result<Self::Address, ()>;
+
+		/// Cancel a scheduled, named task. If periodic, then it will cancel all further instances
+		/// of that, also.
+		///
+		/// Will return an error if the `id` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		fn cancel_named(id: Vec<u8>) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block.
+		fn reschedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `id` is invalid.
+		fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumber, ()>;
+	}
+
+	impl<T, BlockNumber, Call, RuntimeOrigin> Anon<BlockNumber, Call, RuntimeOrigin> for T
+	where
+		T: v2::Anon<BlockNumber, Call, RuntimeOrigin>,
+	{
+		type Address = T::Address;
+
+		fn schedule(
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: RuntimeOrigin,
+			call: Call,
+		) -> Result<Self::Address, DispatchError> {
+			let c = MaybeHashed::<Call, T::Hash>::Value(call);
+			T::schedule(when, maybe_periodic, priority, origin, c)
+		}
+
+		fn cancel(address: Self::Address) -> Result<(), ()> {
+			T::cancel(address)
+		}
+
+		fn reschedule(
+			address: Self::Address,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError> {
+			T::reschedule(address, when)
+		}
+
+		fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, ()> {
+			T::next_dispatch_time(address)
+		}
+	}
+
+	impl<T, BlockNumber, Call, RuntimeOrigin> Named<BlockNumber, Call, RuntimeOrigin> for T
+	where
+		T: v2::Named<BlockNumber, Call, RuntimeOrigin>,
+	{
+		type Address = T::Address;
+
+		fn schedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: RuntimeOrigin,
+			call: Call,
+		) -> Result<Self::Address, ()> {
+			let c = MaybeHashed::<Call, T::Hash>::Value(call);
+			T::schedule_named(id, when, maybe_periodic, priority, origin, c)
+		}
+
+		fn cancel_named(id: Vec<u8>) -> Result<(), ()> {
+			T::cancel_named(id)
+		}
+
+		fn reschedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError> {
+			T::reschedule_named(id, when)
+		}
+
+		fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumber, ()> {
+			T::next_dispatch_time(id)
+		}
+	}
+}
+
+// TODO: deprecate
+pub mod v2 {
+	use super::*;
+
+	/// A type that can be used as a scheduler.
+	pub trait Anon<BlockNumber, Call, RuntimeOrigin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + Debug + TypeInfo + MaxEncodedLen;
+		/// A means of expressing a call by the hash of its encoded data.
+		type Hash;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// This is not named.
+		fn schedule(
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: RuntimeOrigin,
+			call: MaybeHashed<Call, Self::Hash>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Cancel a scheduled task. If periodic, then it will cancel all further instances of that,
+		/// also.
+		///
+		/// Will return an error if the `address` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		///
+		/// NOTE2: This will not work to cancel periodic tasks after their initial execution. For
+		/// that, you must name the task explicitly using the `Named` trait.
+		fn cancel(address: Self::Address) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block. For periodic tasks,
+		/// this dispatch is guaranteed to succeed only before the *initial* execution; for
+		/// others, use `reschedule_named`.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn reschedule(
+			address: Self::Address,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `address` is invalid.
+		fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, ()>;
+	}
+
+	/// A type that can be used as a scheduler.
+	pub trait Named<BlockNumber, Call, RuntimeOrigin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + Clone + Eq + EncodeLike + sp_std::fmt::Debug + MaxEncodedLen;
+		/// A means of expressing a call by the hash of its encoded data.
+		type Hash;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// - `id`: The identity of the task. This must be unique and will return an error if not.
+		fn schedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: RuntimeOrigin,
+			call: MaybeHashed<Call, Self::Hash>,
+		) -> Result<Self::Address, ()>;
+
+		/// Cancel a scheduled, named task. If periodic, then it will cancel all further instances
+		/// of that, also.
+		///
+		/// Will return an error if the `id` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		fn cancel_named(id: Vec<u8>) -> Result<(), ()>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block.
+		fn reschedule_named(
+			id: Vec<u8>,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an error if the `id` is invalid.
+		fn next_dispatch_time(id: Vec<u8>) -> Result<BlockNumber, ()>;
+	}
+}
+
+pub mod v3 {
+	use super::*;
+	use crate::traits::Bounded;
+
+	/// A type that can be used as a scheduler.
+	pub trait Anon<BlockNumber, Call, Origin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + MaxEncodedLen + Clone + Eq + EncodeLike + Debug + TypeInfo;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// This is not named.
+		fn schedule(
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: Bounded<Call>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Cancel a scheduled task. If periodic, then it will cancel all further instances of that,
+		/// also.
+		///
+		/// Will return an `Unavailable` error if the `address` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		///
+		/// NOTE2: This will not work to cancel periodic tasks after their initial execution. For
+		/// that, you must name the task explicitly using the `Named` trait.
+		fn cancel(address: Self::Address) -> Result<(), DispatchError>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block. For periodic tasks,
+		/// this dispatch is guaranteed to succeed only before the *initial* execution; for
+		/// others, use `reschedule_named`.
+		///
+		/// Will return an `Unavailable` error if the `address` is invalid.
+		fn reschedule(
+			address: Self::Address,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an `Unavailable` error if the `address` is invalid.
+		fn next_dispatch_time(address: Self::Address) -> Result<BlockNumber, DispatchError>;
+	}
+
+	pub type TaskName = [u8; 32];
+
+	/// A type that can be used as a scheduler.
+	pub trait Named<BlockNumber, Call, Origin> {
+		/// An address which can be used for removing a scheduled task.
+		type Address: Codec + MaxEncodedLen + Clone + Eq + EncodeLike + sp_std::fmt::Debug;
+
+		/// Schedule a dispatch to happen at the beginning of some block in the future.
+		///
+		/// - `id`: The identity of the task. This must be unique and will return an error if not.
+		///
+		/// NOTE: This will request `call` to be made available.
+		fn schedule_named(
+			id: TaskName,
+			when: DispatchTime<BlockNumber>,
+			maybe_periodic: Option<Period<BlockNumber>>,
+			priority: Priority,
+			origin: Origin,
+			call: Bounded<Call>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Cancel a scheduled, named task. If periodic, then it will cancel all further instances
+		/// of that, also.
+		///
+		/// Will return an `Unavailable` error if the `id` is invalid.
+		///
+		/// NOTE: This guaranteed to work only *before* the point that it is due to be executed.
+		/// If it ends up being delayed beyond the point of execution, then it cannot be cancelled.
+		fn cancel_named(id: TaskName) -> Result<(), DispatchError>;
+
+		/// Reschedule a task. For one-off tasks, this dispatch is guaranteed to succeed
+		/// only if it is executed *before* the currently scheduled block.
+		///
+		/// Will return an `Unavailable` error if the `id` is invalid.
+		fn reschedule_named(
+			id: TaskName,
+			when: DispatchTime<BlockNumber>,
+		) -> Result<Self::Address, DispatchError>;
+
+		/// Return the next dispatch time for a given task.
+		///
+		/// Will return an `Unavailable` error if the `id` is invalid.
+		fn next_dispatch_time(id: TaskName) -> Result<BlockNumber, DispatchError>;
+	}
+}
+
+pub use v1::*;
diff --git a/substrate/frame/support/src/traits/storage.rs b/substrate/frame/support/src/traits/storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..64eddf51b7fabb160dfd9b09c2cd3c98bf7c317b
--- /dev/null
+++ b/substrate/frame/support/src/traits/storage.rs
@@ -0,0 +1,167 @@
+// 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.
+
+//! Traits for encoding data related to pallet's storage items.
+
+use impl_trait_for_tuples::impl_for_tuples;
+pub use sp_core::storage::TrackedStorageKey;
+use sp_runtime::{traits::Saturating, RuntimeDebug};
+use sp_std::{collections::btree_set::BTreeSet, prelude::*};
+
+/// An instance of a pallet in the storage.
+///
+/// It is required that these instances are unique, to support multiple instances per pallet in the
+/// same runtime!
+///
+/// E.g. for module MyModule default instance will have prefix "MyModule" and other instances
+/// "InstanceNMyModule".
+pub trait Instance: 'static {
+	/// Unique module prefix. E.g. "InstanceNMyModule" or "MyModule"
+	const PREFIX: &'static str;
+	/// Unique numerical identifier for an instance.
+	const INDEX: u8;
+}
+
+// Dummy implementation for `()`.
+impl Instance for () {
+	const PREFIX: &'static str = "";
+	const INDEX: u8 = 0;
+}
+
+/// An instance of a storage in a pallet.
+///
+/// Define an instance for an individual storage inside a pallet.
+/// The pallet prefix is used to isolate the storage between pallets, and the storage prefix is
+/// used to isolate storages inside a pallet.
+///
+/// NOTE: These information can be used to define storages in pallet such as a `StorageMap` which
+/// can use keys after `twox_128(pallet_prefix())++twox_128(STORAGE_PREFIX)`
+pub trait StorageInstance {
+	/// Prefix of a pallet to isolate it from other pallets.
+	fn pallet_prefix() -> &'static str;
+
+	/// Prefix given to a storage to isolate from other storages in the pallet.
+	const STORAGE_PREFIX: &'static str;
+}
+
+/// Metadata about storage from the runtime.
+#[derive(
+	codec::Encode, codec::Decode, RuntimeDebug, Eq, PartialEq, Clone, scale_info::TypeInfo,
+)]
+pub struct StorageInfo {
+	/// Encoded string of pallet name.
+	pub pallet_name: Vec<u8>,
+	/// Encoded string of storage name.
+	pub storage_name: Vec<u8>,
+	/// The prefix of the storage. All keys after the prefix are considered part of this storage.
+	pub prefix: Vec<u8>,
+	/// The maximum number of values in the storage, or none if no maximum specified.
+	pub max_values: Option<u32>,
+	/// The maximum size of key/values in the storage, or none if no maximum specified.
+	pub max_size: Option<u32>,
+}
+
+/// A trait to give information about storage.
+///
+/// It can be used to calculate PoV worst case size.
+pub trait StorageInfoTrait {
+	fn storage_info() -> Vec<StorageInfo>;
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl StorageInfoTrait for Tuple {
+	fn storage_info() -> Vec<StorageInfo> {
+		let mut res = vec![];
+		for_tuples!( #( res.extend_from_slice(&Tuple::storage_info()); )* );
+		res
+	}
+}
+
+/// Similar to [`StorageInfoTrait`], a trait to give partial information about storage.
+///
+/// This is useful when a type can give some partial information with its generic parameter doesn't
+/// implement some bounds.
+pub trait PartialStorageInfoTrait {
+	fn partial_storage_info() -> Vec<StorageInfo>;
+}
+
+/// Allows a pallet to specify storage keys to whitelist during benchmarking.
+/// This means those keys will be excluded from the benchmarking performance
+/// calculation.
+pub trait WhitelistedStorageKeys {
+	/// Returns a [`Vec<TrackedStorageKey>`] indicating the storage keys that
+	/// should be whitelisted during benchmarking. This means that those keys
+	/// will be excluded from the benchmarking performance calculation.
+	fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>;
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(feature = "tuples-128", impl_for_tuples(128))]
+impl WhitelistedStorageKeys for Tuple {
+	fn whitelisted_storage_keys() -> Vec<TrackedStorageKey> {
+		// de-duplicate the storage keys
+		let mut combined_keys: BTreeSet<TrackedStorageKey> = BTreeSet::new();
+		for_tuples!( #(
+			for storage_key in Tuple::whitelisted_storage_keys() {
+				combined_keys.insert(storage_key);
+			}
+		 )* );
+		combined_keys.into_iter().collect::<Vec<_>>()
+	}
+}
+
+macro_rules! impl_incrementable {
+	($($type:ty),+) => {
+		$(
+			impl Incrementable for $type {
+				fn increment(&self) -> Option<Self> {
+					let mut val = self.clone();
+					val.saturating_inc();
+					Some(val)
+				}
+
+				fn initial_value() -> Option<Self> {
+					Some(0)
+				}
+			}
+		)+
+	};
+}
+
+/// A trait representing an incrementable type.
+///
+/// The `increment` and `initial_value` functions are fallible.
+/// They should either both return `Some` with a valid value, or `None`.
+pub trait Incrementable
+where
+	Self: Sized,
+{
+	/// Increments the value.
+	///
+	/// Returns `Some` with the incremented value if it is possible, or `None` if it is not.
+	fn increment(&self) -> Option<Self>;
+
+	/// Returns the initial value.
+	///
+	/// Returns `Some` with the initial value if it is available, or `None` if it is not.
+	fn initial_value() -> Option<Self>;
+}
+
+impl_incrementable!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
diff --git a/substrate/frame/support/src/traits/stored_map.rs b/substrate/frame/support/src/traits/stored_map.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cbe70f29323491179d945027bfccaaf5cb880671
--- /dev/null
+++ b/substrate/frame/support/src/traits/stored_map.rs
@@ -0,0 +1,119 @@
+// 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.
+
+//! Traits and associated datatypes for managing abstract stored values.
+
+use crate::storage::StorageMap;
+use codec::FullCodec;
+use sp_runtime::DispatchError;
+
+/// An abstraction of a value stored within storage, but possibly as part of a larger composite
+/// item.
+pub trait StoredMap<K, T: Default> {
+	/// Get the item, or its default if it doesn't yet exist; we make no distinction between the
+	/// two.
+	fn get(k: &K) -> T;
+
+	/// Maybe mutate the item only if an `Ok` value is returned from `f`. Do nothing if an `Err` is
+	/// returned. It is removed or reset to default value if it has been mutated to `None`.
+	/// `f` will always be called with an option representing if the storage item exists (`Some<V>`)
+	/// or if the storage item does not exist (`None`), independent of the `QueryType`.
+	fn try_mutate_exists<R, E: From<DispatchError>>(
+		k: &K,
+		f: impl FnOnce(&mut Option<T>) -> Result<R, E>,
+	) -> Result<R, E>;
+
+	// Everything past here has a default implementation.
+
+	/// Mutate the item.
+	fn mutate<R>(k: &K, f: impl FnOnce(&mut T) -> R) -> Result<R, DispatchError> {
+		Self::mutate_exists(k, |maybe_account| match maybe_account {
+			Some(ref mut account) => f(account),
+			x @ None => {
+				let mut account = Default::default();
+				let r = f(&mut account);
+				*x = Some(account);
+				r
+			},
+		})
+	}
+
+	/// Mutate the item, removing or resetting to default value if it has been mutated to `None`.
+	///
+	/// This is infallible as long as the value does not get destroyed.
+	fn mutate_exists<R>(k: &K, f: impl FnOnce(&mut Option<T>) -> R) -> Result<R, DispatchError> {
+		Self::try_mutate_exists(k, |x| -> Result<R, DispatchError> { Ok(f(x)) })
+	}
+
+	/// Set the item to something new.
+	fn insert(k: &K, t: T) -> Result<(), DispatchError> {
+		Self::mutate(k, |i| *i = t)
+	}
+
+	/// Remove the item or otherwise replace it with its default value; we don't care which.
+	fn remove(k: &K) -> Result<(), DispatchError> {
+		Self::mutate_exists(k, |x| *x = None)
+	}
+}
+
+/// A shim for placing around a storage item in order to use it as a `StoredValue`. Ideally this
+/// wouldn't be needed as `StorageValue`s should blanket implement `StoredValue`s, however this
+/// would break the ability to have custom impls of `StoredValue`. The other workaround is to
+/// implement it directly in the macro.
+///
+/// This form has the advantage that two additional types are provides, `Created` and `Removed`,
+/// which are both generic events that can be tied to handlers to do something in the case of being
+/// about to create an account where one didn't previously exist (at all; not just where it used to
+/// be the default value), or where the account is being removed or reset back to the default value
+/// where previously it did exist (though may have been in a default state). This works well with
+/// system module's `CallOnCreatedAccount` and `CallKillAccount`.
+pub struct StorageMapShim<S, K, T>(sp_std::marker::PhantomData<(S, K, T)>);
+impl<S: StorageMap<K, T, Query = T>, K: FullCodec, T: FullCodec + Default> StoredMap<K, T>
+	for StorageMapShim<S, K, T>
+{
+	fn get(k: &K) -> T {
+		S::get(k)
+	}
+	fn insert(k: &K, t: T) -> Result<(), DispatchError> {
+		S::insert(k, t);
+		Ok(())
+	}
+	fn remove(k: &K) -> Result<(), DispatchError> {
+		if S::contains_key(&k) {
+			S::remove(k);
+		}
+		Ok(())
+	}
+	fn mutate<R>(k: &K, f: impl FnOnce(&mut T) -> R) -> Result<R, DispatchError> {
+		Ok(S::mutate(k, f))
+	}
+	fn mutate_exists<R>(k: &K, f: impl FnOnce(&mut Option<T>) -> R) -> Result<R, DispatchError> {
+		S::try_mutate_exists(k, |maybe_value| {
+			let r = f(maybe_value);
+			Ok(r)
+		})
+	}
+	fn try_mutate_exists<R, E: From<DispatchError>>(
+		k: &K,
+		f: impl FnOnce(&mut Option<T>) -> Result<R, E>,
+	) -> Result<R, E> {
+		S::try_mutate_exists(k, |maybe_value| {
+			let r = f(maybe_value)?;
+			Ok(r)
+		})
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens.rs b/substrate/frame/support/src/traits/tokens.rs
new file mode 100644
index 0000000000000000000000000000000000000000..253b49c6671f80fe0e05792b9095dcb3ab22032d
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens.rs
@@ -0,0 +1,36 @@
+// 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.
+
+//! Traits for working with tokens and their associated datastructures.
+
+pub mod currency;
+pub mod fungible;
+pub mod fungibles;
+pub mod imbalance;
+mod misc;
+pub mod nonfungible;
+pub mod nonfungible_v2;
+pub mod nonfungibles;
+pub mod nonfungibles_v2;
+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, WithdrawConsequence, WithdrawReasons,
+};
+pub use pay::{Pay, PayFromAccount, PaymentStatus};
diff --git a/substrate/frame/support/src/traits/tokens/currency.rs b/substrate/frame/support/src/traits/tokens/currency.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e6a7284a74b7ff50c4b88fa4c5d6737694bffc67
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/currency.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.
+
+//! The Currency trait and associated types.
+
+use super::{
+	imbalance::{Imbalance, SignedImbalance},
+	misc::{Balance, ExistenceRequirement, WithdrawReasons},
+};
+use crate::{
+	dispatch::{DispatchError, DispatchResult},
+	traits::Get,
+};
+use sp_runtime::traits::MaybeSerializeDeserialize;
+
+mod reservable;
+pub use reservable::{NamedReservableCurrency, ReservableCurrency};
+mod lockable;
+pub use lockable::{LockIdentifier, LockableCurrency, VestingSchedule};
+
+/// Abstraction over a fungible assets system.
+pub trait Currency<AccountId> {
+	/// The balance of an account.
+	type Balance: Balance + MaybeSerializeDeserialize;
+
+	/// The opaque token type for an imbalance. This is returned by unbalanced operations
+	/// and must be dealt with. It may be dropped but cannot be cloned.
+	type PositiveImbalance: Imbalance<Self::Balance, Opposite = Self::NegativeImbalance>;
+
+	/// The opaque token type for an imbalance. This is returned by unbalanced operations
+	/// and must be dealt with. It may be dropped but cannot be cloned.
+	type NegativeImbalance: Imbalance<Self::Balance, Opposite = Self::PositiveImbalance>;
+
+	// PUBLIC IMMUTABLES
+
+	/// The combined balance of `who`.
+	fn total_balance(who: &AccountId) -> Self::Balance;
+
+	/// Same result as `slash(who, value)` (but without the side-effects) assuming there are no
+	/// balance changes in the meantime and only the reserved balance is not taken into account.
+	fn can_slash(who: &AccountId, value: Self::Balance) -> bool;
+
+	/// The total amount of issuance in the system.
+	fn total_issuance() -> Self::Balance;
+
+	/// The total amount of issuance in the system excluding those which are controlled by the
+	/// system.
+	fn active_issuance() -> Self::Balance {
+		Self::total_issuance()
+	}
+
+	/// Reduce the active issuance by some amount.
+	fn deactivate(_: Self::Balance) {}
+
+	/// Increase the active issuance by some amount, up to the outstanding amount reduced.
+	fn reactivate(_: Self::Balance) {}
+
+	/// The minimum balance any single account may have. This is equivalent to the `Balances`
+	/// module's `ExistentialDeposit`.
+	fn minimum_balance() -> Self::Balance;
+
+	/// Reduce the total issuance by `amount` and return the according imbalance. The imbalance will
+	/// typically be used to reduce an account by the same amount with e.g. `settle`.
+	///
+	/// This is infallible, but doesn't guarantee that the entire `amount` is burnt, for example
+	/// in the case of underflow.
+	fn burn(amount: Self::Balance) -> Self::PositiveImbalance;
+
+	/// Increase the total issuance by `amount` and return the according imbalance. The imbalance
+	/// will typically be used to increase an account by the same amount with e.g.
+	/// `resolve_into_existing` or `resolve_creating`.
+	///
+	/// This is infallible, but doesn't guarantee that the entire `amount` is issued, for example
+	/// in the case of overflow.
+	fn issue(amount: Self::Balance) -> Self::NegativeImbalance;
+
+	/// Produce a pair of imbalances that cancel each other out exactly.
+	///
+	/// This is just the same as burning and issuing the same amount and has no effect on the
+	/// total issuance.
+	fn pair(amount: Self::Balance) -> (Self::PositiveImbalance, Self::NegativeImbalance) {
+		(Self::burn(amount), Self::issue(amount))
+	}
+
+	/// The 'free' balance of a given account.
+	///
+	/// This is the only balance that matters in terms of most operations on tokens. It alone
+	/// is used to determine the balance when in the contract execution environment. When this
+	/// balance falls below the value of `ExistentialDeposit`, then the 'current account' is
+	/// deleted: specifically `FreeBalance`.
+	///
+	/// `system::AccountNonce` is also deleted if `ReservedBalance` is also zero (it also gets
+	/// collapsed to zero if it ever becomes less than `ExistentialDeposit`.
+	fn free_balance(who: &AccountId) -> Self::Balance;
+
+	/// Returns `Ok` iff the account is able to make a withdrawal of the given amount
+	/// for the given reason. Basically, it's just a dry-run of `withdraw`.
+	///
+	/// `Err(...)` with the reason why not otherwise.
+	fn ensure_can_withdraw(
+		who: &AccountId,
+		_amount: Self::Balance,
+		reasons: WithdrawReasons,
+		new_balance: Self::Balance,
+	) -> DispatchResult;
+
+	// PUBLIC MUTABLES (DANGEROUS)
+
+	/// Transfer some liquid free balance to another staker.
+	///
+	/// This is a very high-level function. It will ensure no imbalance in the system remains.
+	fn transfer(
+		source: &AccountId,
+		dest: &AccountId,
+		value: Self::Balance,
+		existence_requirement: ExistenceRequirement,
+	) -> DispatchResult;
+
+	/// Deducts up to `value` from the combined balance of `who`, preferring to deduct from the
+	/// free balance. This function cannot fail.
+	///
+	/// The resulting imbalance is the first item of the tuple returned.
+	///
+	/// As much funds up to `value` will be deducted as possible. If this is less than `value`,
+	/// then a non-zero second item will be returned.
+	fn slash(who: &AccountId, value: Self::Balance) -> (Self::NegativeImbalance, Self::Balance);
+
+	/// Mints `value` to the free balance of `who`.
+	///
+	/// If `who` doesn't exist, nothing is done and an Err returned.
+	fn deposit_into_existing(
+		who: &AccountId,
+		value: Self::Balance,
+	) -> Result<Self::PositiveImbalance, DispatchError>;
+
+	/// Similar to deposit_creating, only accepts a `NegativeImbalance` and returns nothing on
+	/// success.
+	fn resolve_into_existing(
+		who: &AccountId,
+		value: Self::NegativeImbalance,
+	) -> Result<(), Self::NegativeImbalance> {
+		let v = value.peek();
+		match Self::deposit_into_existing(who, v) {
+			Ok(opposite) => Ok(drop(value.offset(opposite))),
+			_ => Err(value),
+		}
+	}
+
+	/// Adds up to `value` to the free balance of `who`. If `who` doesn't exist, it is created.
+	///
+	/// Infallible.
+	fn deposit_creating(who: &AccountId, value: Self::Balance) -> Self::PositiveImbalance;
+
+	/// Similar to deposit_creating, only accepts a `NegativeImbalance` and returns nothing on
+	/// success.
+	fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance) {
+		let v = value.peek();
+		drop(value.offset(Self::deposit_creating(who, v)));
+	}
+
+	/// Removes some free balance from `who` account for `reason` if possible. If `liveness` is
+	/// `KeepAlive`, then no less than `ExistentialDeposit` must be left remaining.
+	///
+	/// This checks any locks, vesting, and liquidity requirements. If the removal is not possible,
+	/// then it returns `Err`.
+	///
+	/// If the operation is successful, this will return `Ok` with a `NegativeImbalance` whose value
+	/// is `value`.
+	fn withdraw(
+		who: &AccountId,
+		value: Self::Balance,
+		reasons: WithdrawReasons,
+		liveness: ExistenceRequirement,
+	) -> Result<Self::NegativeImbalance, DispatchError>;
+
+	/// Similar to withdraw, only accepts a `PositiveImbalance` and returns nothing on success.
+	fn settle(
+		who: &AccountId,
+		value: Self::PositiveImbalance,
+		reasons: WithdrawReasons,
+		liveness: ExistenceRequirement,
+	) -> Result<(), Self::PositiveImbalance> {
+		let v = value.peek();
+		match Self::withdraw(who, v, reasons, liveness) {
+			Ok(opposite) => Ok(drop(value.offset(opposite))),
+			_ => Err(value),
+		}
+	}
+
+	/// Ensure an account's free balance equals some value; this will create the account
+	/// if needed.
+	///
+	/// Returns a signed imbalance and status to indicate if the account was successfully updated or
+	/// update has led to killing of the account.
+	fn make_free_balance_be(
+		who: &AccountId,
+		balance: Self::Balance,
+	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>;
+}
+
+/// A non-const `Get` implementation parameterised by a `Currency` impl which provides the result
+/// of `total_issuance`.
+pub struct TotalIssuanceOf<C: Currency<A>, A>(sp_std::marker::PhantomData<(C, A)>);
+impl<C: Currency<A>, A> Get<C::Balance> for TotalIssuanceOf<C, A> {
+	fn get() -> C::Balance {
+		C::total_issuance()
+	}
+}
+
+/// A non-const `Get` implementation parameterised by a `Currency` impl which provides the result
+/// of `active_issuance`.
+pub struct ActiveIssuanceOf<C: Currency<A>, A>(sp_std::marker::PhantomData<(C, A)>);
+impl<C: Currency<A>, A> Get<C::Balance> for ActiveIssuanceOf<C, A> {
+	fn get() -> C::Balance {
+		C::active_issuance()
+	}
+}
+
+#[cfg(feature = "std")]
+impl<AccountId> Currency<AccountId> for () {
+	type Balance = u32;
+	type PositiveImbalance = ();
+	type NegativeImbalance = ();
+	fn total_balance(_: &AccountId) -> Self::Balance {
+		0
+	}
+	fn can_slash(_: &AccountId, _: Self::Balance) -> bool {
+		true
+	}
+	fn total_issuance() -> Self::Balance {
+		0
+	}
+	fn minimum_balance() -> Self::Balance {
+		0
+	}
+	fn burn(_: Self::Balance) -> Self::PositiveImbalance {
+		()
+	}
+	fn issue(_: Self::Balance) -> Self::NegativeImbalance {
+		()
+	}
+	fn pair(_: Self::Balance) -> (Self::PositiveImbalance, Self::NegativeImbalance) {
+		((), ())
+	}
+	fn free_balance(_: &AccountId) -> Self::Balance {
+		0
+	}
+	fn ensure_can_withdraw(
+		_: &AccountId,
+		_: Self::Balance,
+		_: WithdrawReasons,
+		_: Self::Balance,
+	) -> DispatchResult {
+		Ok(())
+	}
+	fn transfer(
+		_: &AccountId,
+		_: &AccountId,
+		_: Self::Balance,
+		_: ExistenceRequirement,
+	) -> DispatchResult {
+		Ok(())
+	}
+	fn slash(_: &AccountId, _: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) {
+		((), 0)
+	}
+	fn deposit_into_existing(
+		_: &AccountId,
+		_: Self::Balance,
+	) -> Result<Self::PositiveImbalance, DispatchError> {
+		Ok(())
+	}
+	fn resolve_into_existing(
+		_: &AccountId,
+		_: Self::NegativeImbalance,
+	) -> Result<(), Self::NegativeImbalance> {
+		Ok(())
+	}
+	fn deposit_creating(_: &AccountId, _: Self::Balance) -> Self::PositiveImbalance {
+		()
+	}
+	fn resolve_creating(_: &AccountId, _: Self::NegativeImbalance) {}
+	fn withdraw(
+		_: &AccountId,
+		_: Self::Balance,
+		_: WithdrawReasons,
+		_: ExistenceRequirement,
+	) -> Result<Self::NegativeImbalance, DispatchError> {
+		Ok(())
+	}
+	fn settle(
+		_: &AccountId,
+		_: Self::PositiveImbalance,
+		_: WithdrawReasons,
+		_: ExistenceRequirement,
+	) -> Result<(), Self::PositiveImbalance> {
+		Ok(())
+	}
+	fn make_free_balance_be(
+		_: &AccountId,
+		_: Self::Balance,
+	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
+		SignedImbalance::Positive(())
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/currency/lockable.rs b/substrate/frame/support/src/traits/tokens/currency/lockable.rs
new file mode 100644
index 0000000000000000000000000000000000000000..955814f5aa9de3e8767cc9632e6a23802ed0e94f
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/currency/lockable.rs
@@ -0,0 +1,108 @@
+// 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.
+
+//! The lockable currency trait and some associated types.
+
+use super::{super::misc::WithdrawReasons, Currency};
+use crate::{dispatch::DispatchResult, traits::misc::Get};
+
+/// An identifier for a lock. Used for disambiguating different locks so that
+/// they can be individually replaced or removed.
+pub type LockIdentifier = [u8; 8];
+
+/// A currency whose accounts can have liquidity restrictions.
+pub trait LockableCurrency<AccountId>: Currency<AccountId> {
+	/// The quantity used to denote time; usually just a `BlockNumber`.
+	type Moment;
+
+	/// The maximum number of locks a user should have on their account.
+	type MaxLocks: Get<u32>;
+
+	/// Create a new balance lock on account `who`.
+	///
+	/// If the new lock is valid (i.e. not already expired), it will push the struct to
+	/// the `Locks` vec in storage. Note that you can lock more funds than a user has.
+	///
+	/// If the lock `id` already exists, this will update it.
+	fn set_lock(
+		id: LockIdentifier,
+		who: &AccountId,
+		amount: Self::Balance,
+		reasons: WithdrawReasons,
+	);
+
+	/// Changes a balance lock (selected by `id`) so that it becomes less liquid in all
+	/// parameters or creates a new one if it does not exist.
+	///
+	/// Calling `extend_lock` on an existing lock `id` differs from `set_lock` in that it
+	/// applies the most severe constraints of the two, while `set_lock` replaces the lock
+	/// with the new parameters. As in, `extend_lock` will set:
+	/// - maximum `amount`
+	/// - bitwise mask of all `reasons`
+	fn extend_lock(
+		id: LockIdentifier,
+		who: &AccountId,
+		amount: Self::Balance,
+		reasons: WithdrawReasons,
+	);
+
+	/// Remove an existing lock.
+	fn remove_lock(id: LockIdentifier, who: &AccountId);
+}
+
+/// A vesting schedule over a currency. This allows a particular currency to have vesting limits
+/// applied to it.
+pub trait VestingSchedule<AccountId> {
+	/// The quantity used to denote time; usually just a `BlockNumber`.
+	type Moment;
+
+	/// The currency that this schedule applies to.
+	type Currency: Currency<AccountId>;
+
+	/// Get the amount that is currently being vested and cannot be transferred out of this account.
+	/// Returns `None` if the account has no vesting schedule.
+	fn vesting_balance(who: &AccountId)
+		-> Option<<Self::Currency as Currency<AccountId>>::Balance>;
+
+	/// Adds a vesting schedule to a given account.
+	///
+	/// If the account has `MaxVestingSchedules`, an Error is returned and nothing
+	/// is updated.
+	///
+	/// Is a no-op if the amount to be vested is zero.
+	///
+	/// NOTE: This doesn't alter the free balance of the account.
+	fn add_vesting_schedule(
+		who: &AccountId,
+		locked: <Self::Currency as Currency<AccountId>>::Balance,
+		per_block: <Self::Currency as Currency<AccountId>>::Balance,
+		starting_block: Self::Moment,
+	) -> DispatchResult;
+
+	/// Checks if `add_vesting_schedule` would work against `who`.
+	fn can_add_vesting_schedule(
+		who: &AccountId,
+		locked: <Self::Currency as Currency<AccountId>>::Balance,
+		per_block: <Self::Currency as Currency<AccountId>>::Balance,
+		starting_block: Self::Moment,
+	) -> DispatchResult;
+
+	/// Remove a vesting schedule for a given account.
+	///
+	/// NOTE: This doesn't alter the free balance of the account.
+	fn remove_vesting_schedule(who: &AccountId, schedule_index: u32) -> DispatchResult;
+}
diff --git a/substrate/frame/support/src/traits/tokens/currency/reservable.rs b/substrate/frame/support/src/traits/tokens/currency/reservable.rs
new file mode 100644
index 0000000000000000000000000000000000000000..79129cecdd6969d56ca9cab0e7fa752469a5c4e1
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/currency/reservable.rs
@@ -0,0 +1,378 @@
+// 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.
+
+//! The reservable currency trait.
+
+use scale_info::TypeInfo;
+use sp_core::Get;
+
+use super::{super::misc::BalanceStatus, Currency};
+use crate::{
+	dispatch::{DispatchError, DispatchResult},
+	traits::{ExistenceRequirement, SignedImbalance, WithdrawReasons},
+};
+
+/// A currency where funds can be reserved from the user.
+pub trait ReservableCurrency<AccountId>: Currency<AccountId> {
+	/// Same result as `reserve(who, value)` (but without the side-effects) assuming there
+	/// are no balance changes in the meantime.
+	fn can_reserve(who: &AccountId, value: Self::Balance) -> bool;
+
+	/// Deducts up to `value` from reserved balance of `who`. This function cannot fail.
+	///
+	/// As much funds up to `value` will be deducted as possible. If the reserve balance of `who`
+	/// is less than `value`, then the second item will be equal to the value not able to be
+	/// slashed.
+	fn slash_reserved(
+		who: &AccountId,
+		value: Self::Balance,
+	) -> (Self::NegativeImbalance, Self::Balance);
+
+	/// The amount of the balance of a given account that is externally reserved; this can still get
+	/// slashed, but gets slashed last of all.
+	///
+	/// This balance is a 'reserve' balance that other subsystems use in order to set aside tokens
+	/// that are still 'owned' by the account holder, but which are suspendable.
+	///
+	/// `system::AccountNonce` is also deleted if `FreeBalance` is also zero (it also gets
+	/// collapsed to zero if it ever becomes less than `ExistentialDeposit`.
+	fn reserved_balance(who: &AccountId) -> Self::Balance;
+
+	/// Moves `value` from balance to reserved balance.
+	///
+	/// If the free balance is lower than `value`, then no funds will be moved and an `Err` will
+	/// be returned to notify of this. This is different behavior than `unreserve`.
+	fn reserve(who: &AccountId, value: Self::Balance) -> DispatchResult;
+
+	/// Moves up to `value` from reserved balance to free balance. This function cannot fail.
+	///
+	/// As much funds up to `value` will be moved as possible. If the reserve balance of `who`
+	/// is less than `value`, then the remaining amount will be returned. This is different
+	/// behavior than `reserve`.
+	fn unreserve(who: &AccountId, value: Self::Balance) -> Self::Balance;
+
+	/// Moves up to `value` from reserved balance of account `slashed` to balance of account
+	/// `beneficiary`. `beneficiary` must exist for this to succeed. If it does not, `Err` will be
+	/// returned. Funds will be placed in either the `free` balance or the `reserved` balance,
+	/// depending on the `status`.
+	///
+	/// As much funds up to `value` will be deducted as possible. If this is less than `value`,
+	/// then `Ok(non_zero)` will be returned.
+	fn repatriate_reserved(
+		slashed: &AccountId,
+		beneficiary: &AccountId,
+		value: Self::Balance,
+		status: BalanceStatus,
+	) -> Result<Self::Balance, DispatchError>;
+}
+
+#[cfg(feature = "std")]
+impl<AccountId> ReservableCurrency<AccountId> for () {
+	fn can_reserve(_: &AccountId, _: Self::Balance) -> bool {
+		true
+	}
+	fn slash_reserved(_: &AccountId, _: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) {
+		((), 0)
+	}
+	fn reserved_balance(_: &AccountId) -> Self::Balance {
+		0
+	}
+	fn reserve(_: &AccountId, _: Self::Balance) -> DispatchResult {
+		Ok(())
+	}
+	fn unreserve(_: &AccountId, _: Self::Balance) -> Self::Balance {
+		0
+	}
+	fn repatriate_reserved(
+		_: &AccountId,
+		_: &AccountId,
+		_: Self::Balance,
+		_: BalanceStatus,
+	) -> Result<Self::Balance, DispatchError> {
+		Ok(0)
+	}
+}
+
+pub trait NamedReservableCurrency<AccountId>: ReservableCurrency<AccountId> {
+	/// An identifier for a reserve. Used for disambiguating different reserves so that
+	/// they can be individually replaced or removed.
+	type ReserveIdentifier: codec::Encode + TypeInfo + 'static;
+
+	/// Deducts up to `value` from reserved balance of `who`. This function cannot fail.
+	///
+	/// As much funds up to `value` will be deducted as possible. If the reserve balance of `who`
+	/// is less than `value`, then a non-zero second item will be returned.
+	fn slash_reserved_named(
+		id: &Self::ReserveIdentifier,
+		who: &AccountId,
+		value: Self::Balance,
+	) -> (Self::NegativeImbalance, Self::Balance);
+
+	/// The amount of the balance of a given account that is externally reserved; this can still get
+	/// slashed, but gets slashed last of all.
+	///
+	/// This balance is a 'reserve' balance that other subsystems use in order to set aside tokens
+	/// that are still 'owned' by the account holder, but which are suspendable.
+	///
+	/// When this balance falls below the value of `ExistentialDeposit`, then this 'reserve account'
+	/// is deleted: specifically, `ReservedBalance`.
+	///
+	/// `system::AccountNonce` is also deleted if `FreeBalance` is also zero (it also gets
+	/// collapsed to zero if it ever becomes less than `ExistentialDeposit`.
+	fn reserved_balance_named(id: &Self::ReserveIdentifier, who: &AccountId) -> Self::Balance;
+
+	/// Moves `value` from balance to reserved balance.
+	///
+	/// If the free balance is lower than `value`, then no funds will be moved and an `Err` will
+	/// be returned to notify of this. This is different behavior than `unreserve`.
+	fn reserve_named(
+		id: &Self::ReserveIdentifier,
+		who: &AccountId,
+		value: Self::Balance,
+	) -> DispatchResult;
+
+	/// Moves up to `value` from reserved balance to free balance. This function cannot fail.
+	///
+	/// As much funds up to `value` will be moved as possible. If the reserve balance of `who`
+	/// is less than `value`, then the remaining amount will be returned.
+	///
+	/// # NOTES
+	///
+	/// - This is different from `reserve`.
+	/// - If the remaining reserved balance is less than `ExistentialDeposit`, it will
+	/// invoke `on_reserved_too_low` and could reap the account.
+	fn unreserve_named(
+		id: &Self::ReserveIdentifier,
+		who: &AccountId,
+		value: Self::Balance,
+	) -> Self::Balance;
+
+	/// Moves up to `value` from reserved balance of account `slashed` to balance of account
+	/// `beneficiary`. `beneficiary` must exist for this to succeed. If it does not, `Err` will be
+	/// returned. Funds will be placed in either the `free` balance or the `reserved` balance,
+	/// depending on the `status`.
+	///
+	/// As much funds up to `value` will be deducted as possible. If this is less than `value`,
+	/// then `Ok(non_zero)` will be returned.
+	fn repatriate_reserved_named(
+		id: &Self::ReserveIdentifier,
+		slashed: &AccountId,
+		beneficiary: &AccountId,
+		value: Self::Balance,
+		status: BalanceStatus,
+	) -> Result<Self::Balance, DispatchError>;
+
+	/// Ensure the reserved balance is equal to `value`.
+	///
+	/// This will reserve extra amount of current reserved balance is less than `value`.
+	/// And unreserve if current reserved balance is greater than `value`.
+	fn ensure_reserved_named(
+		id: &Self::ReserveIdentifier,
+		who: &AccountId,
+		value: Self::Balance,
+	) -> DispatchResult {
+		let current = Self::reserved_balance_named(id, who);
+		if current > value {
+			// we always have enough balance to unreserve here
+			Self::unreserve_named(id, who, current - value);
+			Ok(())
+		} else if value > current {
+			// we checked value > current
+			Self::reserve_named(id, who, value - current)
+		} else {
+			// current == value
+			Ok(())
+		}
+	}
+
+	/// Unreserve all the named reserved balances, returning unreserved amount.
+	///
+	/// Is a no-op if the value to be unreserved is zero.
+	fn unreserve_all_named(id: &Self::ReserveIdentifier, who: &AccountId) -> Self::Balance {
+		let value = Self::reserved_balance_named(id, who);
+		Self::unreserve_named(id, who, value);
+		value
+	}
+
+	/// Slash all the reserved balance, returning the negative imbalance created.
+	///
+	/// Is a no-op if the value to be slashed is zero.
+	fn slash_all_reserved_named(
+		id: &Self::ReserveIdentifier,
+		who: &AccountId,
+	) -> Self::NegativeImbalance {
+		let value = Self::reserved_balance_named(id, who);
+		Self::slash_reserved_named(id, who, value).0
+	}
+
+	/// Move all the named reserved balance of one account into the balance of another, according to
+	/// `status`. If `status` is `Reserved`, the balance will be reserved with given `id`.
+	///
+	/// Is a no-op if:
+	/// - the value to be moved is zero; or
+	/// - the `slashed` id equal to `beneficiary` and the `status` is `Reserved`.
+	fn repatriate_all_reserved_named(
+		id: &Self::ReserveIdentifier,
+		slashed: &AccountId,
+		beneficiary: &AccountId,
+		status: BalanceStatus,
+	) -> DispatchResult {
+		let value = Self::reserved_balance_named(id, slashed);
+		Self::repatriate_reserved_named(id, slashed, beneficiary, value, status).map(|_| ())
+	}
+}
+
+/// Adapter to allow a `NamedReservableCurrency` to be passed as regular `ReservableCurrency`
+/// together with an `Id`.
+///
+/// All "anonymous" operations are then implemented as their named counterparts with the given `Id`.
+pub struct WithName<NamedReservable, Id, AccountId>(
+	sp_std::marker::PhantomData<(NamedReservable, Id, AccountId)>,
+);
+impl<
+		NamedReservable: NamedReservableCurrency<AccountId>,
+		Id: Get<NamedReservable::ReserveIdentifier>,
+		AccountId,
+	> Currency<AccountId> for WithName<NamedReservable, Id, AccountId>
+{
+	type Balance = <NamedReservable as Currency<AccountId>>::Balance;
+	type PositiveImbalance = <NamedReservable as Currency<AccountId>>::PositiveImbalance;
+	type NegativeImbalance = <NamedReservable as Currency<AccountId>>::NegativeImbalance;
+
+	fn total_balance(who: &AccountId) -> Self::Balance {
+		NamedReservable::total_balance(who)
+	}
+	fn can_slash(who: &AccountId, value: Self::Balance) -> bool {
+		NamedReservable::can_slash(who, value)
+	}
+	fn total_issuance() -> Self::Balance {
+		NamedReservable::total_issuance()
+	}
+	fn minimum_balance() -> Self::Balance {
+		NamedReservable::minimum_balance()
+	}
+	fn burn(amount: Self::Balance) -> Self::PositiveImbalance {
+		NamedReservable::burn(amount)
+	}
+	fn issue(amount: Self::Balance) -> Self::NegativeImbalance {
+		NamedReservable::issue(amount)
+	}
+	fn pair(amount: Self::Balance) -> (Self::PositiveImbalance, Self::NegativeImbalance) {
+		NamedReservable::pair(amount)
+	}
+	fn free_balance(who: &AccountId) -> Self::Balance {
+		NamedReservable::free_balance(who)
+	}
+	fn ensure_can_withdraw(
+		who: &AccountId,
+		amount: Self::Balance,
+		reasons: WithdrawReasons,
+		new_balance: Self::Balance,
+	) -> DispatchResult {
+		NamedReservable::ensure_can_withdraw(who, amount, reasons, new_balance)
+	}
+
+	fn transfer(
+		source: &AccountId,
+		dest: &AccountId,
+		value: Self::Balance,
+		existence_requirement: ExistenceRequirement,
+	) -> DispatchResult {
+		NamedReservable::transfer(source, dest, value, existence_requirement)
+	}
+	fn slash(who: &AccountId, value: Self::Balance) -> (Self::NegativeImbalance, Self::Balance) {
+		NamedReservable::slash(who, value)
+	}
+	fn deposit_into_existing(
+		who: &AccountId,
+		value: Self::Balance,
+	) -> Result<Self::PositiveImbalance, DispatchError> {
+		NamedReservable::deposit_into_existing(who, value)
+	}
+	fn resolve_into_existing(
+		who: &AccountId,
+		value: Self::NegativeImbalance,
+	) -> Result<(), Self::NegativeImbalance> {
+		NamedReservable::resolve_into_existing(who, value)
+	}
+	fn deposit_creating(who: &AccountId, value: Self::Balance) -> Self::PositiveImbalance {
+		NamedReservable::deposit_creating(who, value)
+	}
+	fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance) {
+		NamedReservable::resolve_creating(who, value)
+	}
+	fn withdraw(
+		who: &AccountId,
+		value: Self::Balance,
+		reasons: WithdrawReasons,
+		liveness: ExistenceRequirement,
+	) -> Result<Self::NegativeImbalance, DispatchError> {
+		NamedReservable::withdraw(who, value, reasons, liveness)
+	}
+	fn settle(
+		who: &AccountId,
+		value: Self::PositiveImbalance,
+		reasons: WithdrawReasons,
+		liveness: ExistenceRequirement,
+	) -> Result<(), Self::PositiveImbalance> {
+		NamedReservable::settle(who, value, reasons, liveness)
+	}
+	fn make_free_balance_be(
+		who: &AccountId,
+		balance: Self::Balance,
+	) -> SignedImbalance<Self::Balance, Self::PositiveImbalance> {
+		NamedReservable::make_free_balance_be(who, balance)
+	}
+}
+impl<
+		NamedReservable: NamedReservableCurrency<AccountId>,
+		Id: Get<NamedReservable::ReserveIdentifier>,
+		AccountId,
+	> ReservableCurrency<AccountId> for WithName<NamedReservable, Id, AccountId>
+{
+	fn can_reserve(who: &AccountId, value: Self::Balance) -> bool {
+		NamedReservable::can_reserve(who, value)
+	}
+
+	fn slash_reserved(
+		who: &AccountId,
+		value: Self::Balance,
+	) -> (Self::NegativeImbalance, Self::Balance) {
+		NamedReservable::slash_reserved_named(&Id::get(), who, value)
+	}
+
+	fn reserved_balance(who: &AccountId) -> Self::Balance {
+		NamedReservable::reserved_balance_named(&Id::get(), who)
+	}
+
+	fn reserve(who: &AccountId, value: Self::Balance) -> DispatchResult {
+		NamedReservable::reserve_named(&Id::get(), who, value)
+	}
+
+	fn unreserve(who: &AccountId, value: Self::Balance) -> Self::Balance {
+		NamedReservable::unreserve_named(&Id::get(), who, value)
+	}
+
+	fn repatriate_reserved(
+		slashed: &AccountId,
+		beneficiary: &AccountId,
+		value: Self::Balance,
+		status: BalanceStatus,
+	) -> Result<Self::Balance, DispatchError> {
+		NamedReservable::repatriate_reserved_named(&Id::get(), slashed, beneficiary, value, status)
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungible/conformance_tests/inspect_mutate.rs b/substrate/frame/support/src/traits/tokens/fungible/conformance_tests/inspect_mutate.rs
new file mode 100644
index 0000000000000000000000000000000000000000..732742cca9b54aaf08b9bf42a1898709e556e693
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/conformance_tests/inspect_mutate.rs
@@ -0,0 +1,975 @@
+// 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::traits::{
+	fungible::{Inspect, Mutate},
+	tokens::{
+		DepositConsequence, Fortitude, Precision, Preservation, Provenance, WithdrawConsequence,
+	},
+};
+use core::fmt::Debug;
+use sp_arithmetic::traits::AtLeast8BitUnsigned;
+use sp_runtime::traits::{Bounded, Zero};
+
+/// Test the `mint_into` function for successful token minting.
+///
+/// This test checks the `mint_into` function in the `Mutate` trait implementation for type `T`.
+/// It ensures that account balances and total issuance values are updated correctly after minting
+/// tokens into two distinct accounts.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn mint_into_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account_0 = AccountId::from(0);
+	let account_1 = AccountId::from(1);
+
+	// Test: Mint an amount into each account
+	let amount_0 = T::minimum_balance();
+	let amount_1 = T::minimum_balance() + 5.into();
+	T::mint_into(&account_0, amount_0).unwrap();
+	T::mint_into(&account_1, amount_1).unwrap();
+
+	// Verify: Account balances are updated correctly
+	assert_eq!(T::total_balance(&account_0), amount_0);
+	assert_eq!(T::total_balance(&account_1), amount_1);
+	assert_eq!(T::balance(&account_0), amount_0);
+	assert_eq!(T::balance(&account_1), amount_1);
+
+	// Verify: Total issuance is updated correctly
+	assert_eq!(T::total_issuance(), initial_total_issuance + amount_0 + amount_1);
+	assert_eq!(T::active_issuance(), initial_active_issuance + amount_0 + amount_1);
+}
+
+/// Test the `mint_into` function for overflow prevention.
+///
+/// This test ensures that minting tokens beyond the maximum balance value for an account
+/// returns an error and does not change the account balance or total issuance values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn mint_into_overflow<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account = AccountId::from(10);
+	let amount = T::Balance::max_value() - 5.into() - initial_total_issuance;
+
+	// Mint just below the maximum balance
+	T::mint_into(&account, amount).unwrap();
+
+	// Verify: Minting beyond the maximum balance value returns an Err
+	T::mint_into(&account, 10.into()).unwrap_err();
+
+	// Verify: The balance did not change
+	assert_eq!(T::total_balance(&account), amount);
+	assert_eq!(T::balance(&account), amount);
+
+	// Verify: The total issuance did not change
+	assert_eq!(T::total_issuance(), initial_total_issuance + amount);
+	assert_eq!(T::active_issuance(), initial_active_issuance + amount);
+}
+
+/// Test the `mint_into` function for handling balances below the minimum value.
+///
+/// This test verifies that minting tokens below the minimum balance for an account
+/// returns an error and has no impact on the account balance or total issuance values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn mint_into_below_minimum<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	// Skip if there is no minimum balance
+	if T::minimum_balance() == T::Balance::zero() {
+		return
+	}
+
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account = AccountId::from(10);
+	let amount = T::minimum_balance() - 1.into();
+
+	// Verify: Minting below the minimum balance returns Err
+	T::mint_into(&account, amount).unwrap_err();
+
+	// Verify: noop
+	assert_eq!(T::total_balance(&account), T::Balance::zero());
+	assert_eq!(T::balance(&account), T::Balance::zero());
+	assert_eq!(T::total_issuance(), initial_total_issuance);
+	assert_eq!(T::active_issuance(), initial_active_issuance);
+}
+
+/// Test the `burn_from` function for successfully burning an exact amount of tokens.
+///
+/// This test checks that the `burn_from` function with `Precision::Exact` correctly
+/// reduces the account balance and total issuance values by the burned amount.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate` for `AccountId`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn burn_from_exact_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+
+	// Setup account
+	let account = AccountId::from(5);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Test: Burn an exact amount from the account
+	let amount_to_burn = T::Balance::from(5);
+	let precision = Precision::Exact;
+	let force = Fortitude::Polite;
+	T::burn_from(&account, amount_to_burn, precision, force).unwrap();
+
+	// Verify: The balance and total issuance should be reduced by the burned amount
+	assert_eq!(T::balance(&account), initial_balance - amount_to_burn);
+	assert_eq!(T::total_balance(&account), initial_balance - amount_to_burn);
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance - amount_to_burn);
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance - amount_to_burn);
+}
+
+/// Test the `burn_from` function for successfully burning tokens with a best-effort approach.
+///
+/// This test verifies that the `burn_from` function with `Precision::BestEffort` correctly
+/// reduces the account balance and total issuance values by the reducible balance when
+/// attempting to burn an amount greater than the reducible balance.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate` for `AccountId`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn burn_from_best_effort_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+
+	// Setup account
+	let account = AccountId::from(5);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Get reducible balance
+	let force = Fortitude::Polite;
+	let reducible_balance = T::reducible_balance(&account, Preservation::Expendable, force);
+
+	// Test: Burn a best effort amount from the account that is greater than the reducible balance
+	let amount_to_burn = reducible_balance + 5.into();
+	let precision = Precision::BestEffort;
+	assert!(amount_to_burn > reducible_balance);
+	assert!(amount_to_burn > T::balance(&account));
+	T::burn_from(&account, amount_to_burn, precision, force).unwrap();
+
+	// Verify: The balance and total issuance should be reduced by the reducible_balance
+	assert_eq!(T::balance(&account), initial_balance - reducible_balance);
+	assert_eq!(T::total_balance(&account), initial_balance - reducible_balance);
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance - reducible_balance);
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance - reducible_balance);
+}
+
+/// Test the `burn_from` function for handling insufficient funds with `Precision::Exact`.
+///
+/// This test verifies that burning an amount greater than the account's balance with
+/// `Precision::Exact` returns an error and does not change the account balance or total issuance
+/// values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn burn_from_exact_insufficient_funds<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	// Set up the initial conditions and parameters for the test
+	let account = AccountId::from(5);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+
+	// Verify: Burn an amount greater than the account's balance with Exact precision returns Err
+	let amount_to_burn = initial_balance + 10.into();
+	let precision = Precision::Exact;
+	let force = Fortitude::Polite;
+	T::burn_from(&account, amount_to_burn, precision, force).unwrap_err();
+
+	// Verify: The balance and total issuance should remain unchanged
+	assert_eq!(T::balance(&account), initial_balance);
+	assert_eq!(T::total_balance(&account), initial_balance);
+	assert_eq!(T::total_issuance(), initial_total_issuance);
+	assert_eq!(T::active_issuance(), initial_active_issuance);
+}
+
+/// Test the `restore` function for successful restoration.
+///
+/// This test verifies that restoring an amount into each account updates their balances and the
+/// total issuance values correctly.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn restore_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let account_0 = AccountId::from(0);
+	let account_1 = AccountId::from(1);
+
+	// Test: Restore an amount into each account
+	let amount_0 = T::minimum_balance();
+	let amount_1 = T::minimum_balance() + 5.into();
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	T::restore(&account_0, amount_0).unwrap();
+	T::restore(&account_1, amount_1).unwrap();
+
+	// Verify: Account balances are updated correctly
+	assert_eq!(T::total_balance(&account_0), amount_0);
+	assert_eq!(T::total_balance(&account_1), amount_1);
+	assert_eq!(T::balance(&account_0), amount_0);
+	assert_eq!(T::balance(&account_1), amount_1);
+
+	// Verify: Total issuance is updated correctly
+	assert_eq!(T::total_issuance(), initial_total_issuance + amount_0 + amount_1);
+	assert_eq!(T::active_issuance(), initial_active_issuance + amount_0 + amount_1);
+}
+
+/// Test the `restore` function for handling balance overflow.
+///
+/// This test verifies that restoring an amount beyond the maximum balance returns an error and
+/// does not change the account balance or total issuance values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn restore_overflow<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account = AccountId::from(10);
+	let amount = T::Balance::max_value() - 5.into() - initial_total_issuance;
+
+	// Restore just below the maximum balance
+	T::restore(&account, amount).unwrap();
+
+	// Verify: Restoring beyond the maximum balance returns an Err
+	T::restore(&account, 10.into()).unwrap_err();
+
+	// Verify: The balance and total issuance did not change
+	assert_eq!(T::total_balance(&account), amount);
+	assert_eq!(T::balance(&account), amount);
+	assert_eq!(T::total_issuance(), initial_total_issuance + amount);
+	assert_eq!(T::active_issuance(), initial_active_issuance + amount);
+}
+
+/// Test the `restore` function for handling restoration below the minimum balance.
+///
+/// This test verifies that restoring an amount below the minimum balance returns an error and
+/// does not change the account balance or total issuance values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn restore_below_minimum<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	// Skip if there is no minimum balance
+	if T::minimum_balance() == T::Balance::zero() {
+		return
+	}
+
+	let account = AccountId::from(10);
+	let amount = T::minimum_balance() - 1.into();
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+
+	// Verify: Restoring below the minimum balance returns Err
+	T::restore(&account, amount).unwrap_err();
+
+	// Verify: noop
+	assert_eq!(T::total_balance(&account), T::Balance::zero());
+	assert_eq!(T::balance(&account), T::Balance::zero());
+	assert_eq!(T::total_issuance(), initial_total_issuance);
+	assert_eq!(T::active_issuance(), initial_active_issuance);
+}
+
+/// Test the `shelve` function for successful shelving.
+///
+/// This test verifies that shelving an amount from an account reduces the account balance and
+/// total issuance values by the shelved amount.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn shelve_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+
+	// Setup account
+	let account = AccountId::from(5);
+	let initial_balance = T::minimum_balance() + 10.into();
+
+	T::restore(&account, initial_balance).unwrap();
+
+	// Test: Shelve an amount from the account
+	let amount_to_shelve = T::Balance::from(5);
+	T::shelve(&account, amount_to_shelve).unwrap();
+
+	// Verify: The balance and total issuance should be reduced by the shelved amount
+	assert_eq!(T::balance(&account), initial_balance - amount_to_shelve);
+	assert_eq!(T::total_balance(&account), initial_balance - amount_to_shelve);
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance - amount_to_shelve);
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance - amount_to_shelve);
+}
+
+/// Test the `shelve` function for handling insufficient funds.
+///
+/// This test verifies that attempting to shelve an amount greater than the account's balance
+/// returns an error and does not change the account balance or total issuance values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn shelve_insufficient_funds<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+
+	// Set up the initial conditions and parameters for the test
+	let account = AccountId::from(5);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::restore(&account, initial_balance).unwrap();
+
+	// Verify: Shelving greater than the balance with Exact precision returns Err
+	let amount_to_shelve = initial_balance + 10.into();
+	T::shelve(&account, amount_to_shelve).unwrap_err();
+
+	// Verify: The balance and total issuance should remain unchanged
+	assert_eq!(T::balance(&account), initial_balance);
+	assert_eq!(T::total_balance(&account), initial_balance);
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance);
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance);
+}
+
+/// Test the `transfer` function for a successful transfer.
+///
+/// This test verifies that transferring an amount between two accounts with
+/// `Preservation::Expendable` updates the account balances and maintains the total issuance and
+/// active issuance values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn transfer_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account_0 = AccountId::from(0);
+	let account_1 = AccountId::from(1);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::set_balance(&account_0, initial_balance);
+	T::set_balance(&account_1, initial_balance);
+
+	// Test: Transfer an amount from account_0 to account_1
+	let transfer_amount = T::Balance::from(3);
+	T::transfer(&account_0, &account_1, transfer_amount, Preservation::Expendable).unwrap();
+
+	// Verify: Account balances are updated correctly
+	assert_eq!(T::total_balance(&account_0), initial_balance - transfer_amount);
+	assert_eq!(T::total_balance(&account_1), initial_balance + transfer_amount);
+	assert_eq!(T::balance(&account_0), initial_balance - transfer_amount);
+	assert_eq!(T::balance(&account_1), initial_balance + transfer_amount);
+
+	// Verify: Total issuance doesn't change
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance * 2.into());
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance * 2.into());
+}
+
+/// Test the `transfer` function with `Preservation::Expendable` for transferring the entire
+/// balance.
+///
+/// This test verifies that transferring the entire balance from one account to another with
+/// `Preservation::Expendable` updates the account balances and maintains the total issuance and
+/// active issuance values.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn transfer_expendable_all<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account_0 = AccountId::from(0);
+	let account_1 = AccountId::from(1);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::set_balance(&account_0, initial_balance);
+	T::set_balance(&account_1, initial_balance);
+
+	// Test: Transfer entire balance from account_0 to account_1
+	let preservation = Preservation::Expendable;
+	let transfer_amount = initial_balance;
+	T::transfer(&account_0, &account_1, transfer_amount, preservation).unwrap();
+
+	// Verify: Account balances are updated correctly
+	assert_eq!(T::total_balance(&account_0), T::Balance::zero());
+	assert_eq!(T::total_balance(&account_1), initial_balance * 2.into());
+	assert_eq!(T::balance(&account_0), T::Balance::zero());
+	assert_eq!(T::balance(&account_1), initial_balance * 2.into());
+
+	// Verify: Total issuance doesn't change
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance * 2.into());
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance * 2.into());
+}
+
+/// Test the transfer function with Preservation::Expendable for transferring amounts that leaves
+/// an account with less than the minimum balance.
+///
+/// This test verifies that when transferring an amount using Preservation::Expendable and an
+/// account will be left with less than the minimum balance, the account balances are updated, dust
+/// is collected properly depending on whether a dust_trap exists, and the total issuance and active
+/// issuance values remain consistent.
+///
+/// # Parameters
+///
+/// - dust_trap: An optional account identifier to which dust will be collected. If None, dust will
+///   be removed from the total and active issuance.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn transfer_expendable_dust<T, AccountId>(dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	if T::minimum_balance() == T::Balance::zero() {
+		return
+	}
+
+	let account_0 = AccountId::from(10);
+	let account_1 = AccountId::from(20);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::set_balance(&account_0, initial_balance);
+	T::set_balance(&account_1, initial_balance);
+
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let initial_dust_trap_balance = match dust_trap.clone() {
+		Some(dust_trap) => T::total_balance(&dust_trap),
+		None => T::Balance::zero(),
+	};
+
+	// Test: Transfer balance
+	let preservation = Preservation::Expendable;
+	let transfer_amount = T::Balance::from(11);
+	T::transfer(&account_0, &account_1, transfer_amount, preservation).unwrap();
+
+	// Verify: Account balances are updated correctly
+	assert_eq!(T::total_balance(&account_0), T::Balance::zero());
+	assert_eq!(T::total_balance(&account_1), initial_balance + transfer_amount);
+	assert_eq!(T::balance(&account_0), T::Balance::zero());
+	assert_eq!(T::balance(&account_1), initial_balance + transfer_amount);
+
+	match dust_trap {
+		Some(dust_trap) => {
+			// Verify: Total issuance and active issuance don't change
+			assert_eq!(T::total_issuance(), initial_total_issuance);
+			assert_eq!(T::active_issuance(), initial_active_issuance);
+			// Verify: Dust is collected into dust trap
+			assert_eq!(
+				T::total_balance(&dust_trap),
+				initial_dust_trap_balance + T::minimum_balance() - 1.into()
+			);
+			assert_eq!(
+				T::balance(&dust_trap),
+				initial_dust_trap_balance + T::minimum_balance() - 1.into()
+			);
+		},
+		None => {
+			// Verify: Total issuance and active issuance are reduced by the dust amount
+			assert_eq!(
+				T::total_issuance(),
+				initial_total_issuance - T::minimum_balance() + 1.into()
+			);
+			assert_eq!(
+				T::active_issuance(),
+				initial_active_issuance - T::minimum_balance() + 1.into()
+			);
+		},
+	}
+}
+
+/// Test the `transfer` function with `Preservation::Protect` and `Preservation::Preserve` for
+/// transferring the entire balance.
+///
+/// This test verifies that attempting to transfer the entire balance with `Preservation::Protect`
+/// or `Preservation::Preserve` returns an error, and the account balances, total issuance, and
+/// active issuance values remain unchanged.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - `T`: Implements `Mutate<AccountId>`.
+/// - `AccountId`: Account identifier implementing `AtLeast8BitUnsigned`.
+/// ```
+pub fn transfer_protect_preserve<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	// This test means nothing if there is no minimum balance
+	if T::minimum_balance() == T::Balance::zero() {
+		return
+	}
+
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account_0 = AccountId::from(0);
+	let account_1 = AccountId::from(1);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::set_balance(&account_0, initial_balance);
+	T::set_balance(&account_1, initial_balance);
+
+	// Verify: Transfer Protect entire balance from account_0 to account_1 should Err
+	let preservation = Preservation::Protect;
+	let transfer_amount = initial_balance;
+	T::transfer(&account_0, &account_1, transfer_amount, preservation).unwrap_err();
+
+	// Verify: Noop
+	assert_eq!(T::total_balance(&account_0), initial_balance);
+	assert_eq!(T::total_balance(&account_1), initial_balance);
+	assert_eq!(T::balance(&account_0), initial_balance);
+	assert_eq!(T::balance(&account_1), initial_balance);
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance * 2.into());
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance * 2.into());
+
+	// Verify: Transfer Preserve entire balance from account_0 to account_1 should Err
+	let preservation = Preservation::Preserve;
+	T::transfer(&account_0, &account_1, transfer_amount, preservation).unwrap_err();
+
+	// Verify: Noop
+	assert_eq!(T::total_balance(&account_0), initial_balance);
+	assert_eq!(T::total_balance(&account_1), initial_balance);
+	assert_eq!(T::balance(&account_0), initial_balance);
+	assert_eq!(T::balance(&account_1), initial_balance);
+	assert_eq!(T::total_issuance(), initial_total_issuance + initial_balance * 2.into());
+	assert_eq!(T::active_issuance(), initial_active_issuance + initial_balance * 2.into());
+}
+
+/// Test the set_balance function for successful minting.
+///
+/// This test verifies that minting a balance using set_balance updates the account balance, total
+/// issuance, and active issuance correctly.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn set_balance_mint_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account = AccountId::from(10);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Test: Increase the account balance with set_balance
+	let increase_amount: T::Balance = 5.into();
+	let new = T::set_balance(&account, initial_balance + increase_amount);
+
+	// Verify: set_balance returned the new balance
+	let expected_new = initial_balance + increase_amount;
+	assert_eq!(new, expected_new);
+
+	// Verify: Balance and issuance is updated correctly
+	assert_eq!(T::total_balance(&account), expected_new);
+	assert_eq!(T::balance(&account), expected_new);
+	assert_eq!(T::total_issuance(), initial_total_issuance + expected_new);
+	assert_eq!(T::active_issuance(), initial_active_issuance + expected_new);
+}
+
+/// Test the set_balance function for successful burning.
+///
+/// This test verifies that burning a balance using set_balance updates the account balance, total
+/// issuance, and active issuance correctly.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn set_balance_burn_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let initial_total_issuance = T::total_issuance();
+	let initial_active_issuance = T::active_issuance();
+	let account = AccountId::from(10);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Test: Increase the account balance with set_balance
+	let burn_amount: T::Balance = 5.into();
+	let new = T::set_balance(&account, initial_balance - burn_amount);
+
+	// Verify: set_balance returned the new balance
+	let expected_new = initial_balance - burn_amount;
+	assert_eq!(new, expected_new);
+
+	// Verify: Balance and issuance is updated correctly
+	assert_eq!(T::total_balance(&account), expected_new);
+	assert_eq!(T::balance(&account), expected_new);
+	assert_eq!(T::total_issuance(), initial_total_issuance + expected_new);
+	assert_eq!(T::active_issuance(), initial_active_issuance + expected_new);
+}
+
+/// Test the can_deposit function for returning a success value.
+///
+/// This test verifies that the can_deposit function returns DepositConsequence::Success when
+/// depositing a reasonable amount.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn can_deposit_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let account = AccountId::from(10);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Test: can_deposit a reasonable amount
+	let ret = T::can_deposit(&account, 5.into(), Provenance::Minted);
+
+	// Verify: Returns success
+	assert_eq!(ret, DepositConsequence::Success);
+}
+
+/// Test the can_deposit function for returning a minimum balance error.
+///
+/// This test verifies that the can_deposit function returns DepositConsequence::BelowMinimum when
+/// depositing below the minimum balance.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn can_deposit_below_minimum<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	// can_deposit always returns Success for amount 0
+	if T::minimum_balance() < 2.into() {
+		return
+	}
+
+	let account = AccountId::from(10);
+
+	// Test: can_deposit below the minimum
+	let ret = T::can_deposit(&account, T::minimum_balance() - 1.into(), Provenance::Minted);
+
+	// Verify: Returns success
+	assert_eq!(ret, DepositConsequence::BelowMinimum);
+}
+
+/// Test the can_deposit function for returning an overflow error.
+///
+/// This test verifies that the can_deposit function returns DepositConsequence::Overflow when
+/// depositing an amount that would cause an overflow.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn can_deposit_overflow<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let account = AccountId::from(10);
+
+	// Test: Try deposit over the max balance
+	let initial_balance = T::Balance::max_value() - 5.into() - T::total_issuance();
+	T::mint_into(&account, initial_balance).unwrap();
+	let ret = T::can_deposit(&account, 10.into(), Provenance::Minted);
+
+	// Verify: Returns success
+	assert_eq!(ret, DepositConsequence::Overflow);
+}
+
+/// Test the can_withdraw function for returning a success value.
+///
+/// This test verifies that the can_withdraw function returns WithdrawConsequence::Success when
+/// withdrawing a reasonable amount.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn can_withdraw_success<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let account = AccountId::from(10);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Test: can_withdraw a reasonable amount
+	let ret = T::can_withdraw(&account, 5.into());
+
+	// Verify: Returns success
+	assert_eq!(ret, WithdrawConsequence::Success);
+}
+
+/// Test the can_withdraw function for withdrawal resulting in a reduced balance of zero.
+///
+/// This test verifies that the can_withdraw function returns WithdrawConsequence::ReducedToZero
+/// when withdrawing an amount that would reduce the account balance below the minimum balance.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn can_withdraw_reduced_to_zero<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	if T::minimum_balance() == T::Balance::zero() {
+		return
+	}
+
+	let account = AccountId::from(10);
+	let initial_balance = T::minimum_balance();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Verify: can_withdraw below the minimum balance returns ReducedToZero
+	let ret = T::can_withdraw(&account, 1.into());
+	assert_eq!(ret, WithdrawConsequence::ReducedToZero(T::minimum_balance() - 1.into()));
+}
+
+/// Test the can_withdraw function for returning a low balance error.
+///
+/// This test verifies that the can_withdraw function returns WithdrawConsequence::BalanceLow when
+/// withdrawing an amount that would result in an account balance below the current balance.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn can_withdraw_balance_low<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	if T::minimum_balance() == T::Balance::zero() {
+		return
+	}
+
+	let account = AccountId::from(10);
+	let other_account = AccountId::from(100);
+	let initial_balance = T::minimum_balance() + 5.into();
+	T::mint_into(&account, initial_balance).unwrap();
+	T::mint_into(&other_account, initial_balance * 2.into()).unwrap();
+
+	// Verify: can_withdraw below the account balance returns BalanceLow
+	let ret = T::can_withdraw(&account, initial_balance + 1.into());
+	assert_eq!(ret, WithdrawConsequence::BalanceLow);
+}
+
+/// Test the reducible_balance function with Preservation::Expendable.
+///
+/// This test verifies that the reducible_balance function returns the full account balance when
+/// using Preservation::Expendable.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn reducible_balance_expendable<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let account = AccountId::from(10);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Verify: reducible_balance returns the full balance
+	let ret = T::reducible_balance(&account, Preservation::Expendable, Fortitude::Polite);
+	assert_eq!(ret, initial_balance);
+}
+
+/// Test the reducible_balance function with Preservation::Protect and Preservation::Preserve.
+///
+/// This test verifies that the reducible_balance function returns the account balance minus the
+/// minimum balance when using either Preservation::Protect or Preservation::Preserve.
+///
+/// # Type Parameters
+///
+/// ```text
+/// - T: Implements Mutate<AccountId>.
+/// - AccountId: Account identifier implementing AtLeast8BitUnsigned.
+/// ```
+pub fn reducible_balance_protect_preserve<T, AccountId>(_dust_trap: Option<AccountId>)
+where
+	T: Mutate<AccountId>,
+	<T as Inspect<AccountId>>::Balance: AtLeast8BitUnsigned + Debug,
+	AccountId: AtLeast8BitUnsigned,
+{
+	let account = AccountId::from(10);
+	let initial_balance = T::minimum_balance() + 10.into();
+	T::mint_into(&account, initial_balance).unwrap();
+
+	// Verify: reducible_balance returns the full balance - min balance
+	let ret = T::reducible_balance(&account, Preservation::Protect, Fortitude::Polite);
+	assert_eq!(ret, initial_balance - T::minimum_balance());
+	let ret = T::reducible_balance(&account, Preservation::Preserve, Fortitude::Polite);
+	assert_eq!(ret, initial_balance - T::minimum_balance());
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungible/conformance_tests/mod.rs b/substrate/frame/support/src/traits/tokens/fungible/conformance_tests/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..88ba56a6fed0200c7b1616f0422f8a42de12610e
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/conformance_tests/mod.rs
@@ -0,0 +1 @@
+pub mod inspect_mutate;
diff --git a/substrate/frame/support/src/traits/tokens/fungible/freeze.rs b/substrate/frame/support/src/traits/tokens/fungible/freeze.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ec3a5fadf555cdc06d76c675a6fe770238cfba7
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/freeze.rs
@@ -0,0 +1,68 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! The traits for putting freezes within a single fungible token class.
+
+use scale_info::TypeInfo;
+use sp_runtime::DispatchResult;
+
+/// Trait for inspecting a fungible asset which can be frozen. Freezing is essentially setting a
+/// minimum balance bellow which the total balance (inclusive of any funds placed on hold) may not
+/// be normally allowed to drop. Generally, freezers will provide an "update" function such that
+/// if the total balance does drop below the limit, then the freezer can update their housekeeping
+/// accordingly.
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	/// An identifier for a freeze.
+	type Id: codec::Encode + TypeInfo + 'static;
+
+	/// Amount of funds held in reserve by `who` for the given `id`.
+	fn balance_frozen(id: &Self::Id, who: &AccountId) -> Self::Balance;
+
+	/// The amount of the balance which can become frozen. Defaults to `total_balance()`.
+	fn balance_freezable(who: &AccountId) -> Self::Balance {
+		Self::total_balance(who)
+	}
+
+	/// Returns `true` if it's possible to introduce a freeze for the given `id` onto the
+	/// account of `who`. This will be true as long as the implementor supports as many
+	/// concurrent freeze locks as there are possible values of `id`.
+	fn can_freeze(id: &Self::Id, who: &AccountId) -> bool;
+}
+
+/// Trait for introducing, altering and removing locks to freeze an account's funds so they never
+/// go below a set minimum.
+pub trait Mutate<AccountId>: Inspect<AccountId> {
+	/// Prevent actions which would reduce the balance of the account of `who` below the given
+	/// `amount` and identify this restriction though the given `id`. Unlike `extend_freeze`, any
+	/// outstanding freeze in place for `who` under the `id` are dropped.
+	///
+	/// If `amount` is zero, it is equivalent to using `thaw`.
+	///
+	/// Note that `amount` can be greater than the total balance, if desired.
+	fn set_freeze(id: &Self::Id, who: &AccountId, amount: Self::Balance) -> DispatchResult;
+
+	/// Prevent the balance of the account of `who` from being reduced below the given `amount` and
+	/// identify this restriction though the given `id`. Unlike `set_freeze`, this does not
+	/// counteract any pre-existing freezes in place for `who` under the `id`. Also unlike
+	/// `set_freeze`, in the case that `amount` is zero, this is no-op and never fails.
+	///
+	/// Note that more funds can be locked than the total balance, if desired.
+	fn extend_freeze(id: &Self::Id, who: &AccountId, amount: Self::Balance) -> DispatchResult;
+
+	/// Remove an existing lock.
+	fn thaw(id: &Self::Id, who: &AccountId) -> DispatchResult;
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungible/hold.rs b/substrate/frame/support/src/traits/tokens/fungible/hold.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa15e9df63a48f886883554687d13150c4c4a78d
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/hold.rs
@@ -0,0 +1,397 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! The traits for putting holds within a single fungible token class.
+
+use crate::{
+	ensure,
+	traits::tokens::{
+		DepositConsequence::Success,
+		Fortitude::{self, Force},
+		Precision::{self, BestEffort, Exact},
+		Preservation::{self, Protect},
+		Provenance::Extant,
+		Restriction::{self, Free, OnHold},
+	},
+};
+use scale_info::TypeInfo;
+use sp_arithmetic::{
+	traits::{CheckedAdd, CheckedSub, Zero},
+	ArithmeticError,
+};
+use sp_runtime::{DispatchError, DispatchResult, Saturating, TokenError};
+
+use super::*;
+
+/// Trait for inspecting a fungible asset whose accounts support partitioning and slashing.
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	/// An identifier for a hold. Used for disambiguating different holds so that
+	/// they can be individually replaced or removed and funds from one hold don't accidentally
+	/// become unreserved or slashed for another.
+	type Reason: codec::Encode + TypeInfo + 'static;
+
+	/// Amount of funds on hold (for all hold reasons) of `who`.
+	fn total_balance_on_hold(who: &AccountId) -> Self::Balance;
+
+	/// Get the maximum amount that the `total_balance_on_hold` of `who` can be reduced successfully
+	/// based on whether we are willing to force the reduction and potentially go below user-level
+	/// restrictions on the minimum amount of the account. Note: This cannot bring the account into
+	/// an inconsistent state with regards any required existential deposit.
+	///
+	/// Never more than `total_balance_on_hold()`.
+	fn reducible_total_balance_on_hold(who: &AccountId, _force: Fortitude) -> Self::Balance {
+		Self::total_balance_on_hold(who)
+	}
+
+	/// Amount of funds on hold (for the given reason) of `who`.
+	fn balance_on_hold(reason: &Self::Reason, who: &AccountId) -> Self::Balance;
+
+	/// Returns `true` if it's possible to place (additional) funds under a hold of a given
+	/// `reason`. This may fail if the account has exhausted a limited number of concurrent
+	/// holds or if it cannot be made to exist (e.g. there is no provider reference).
+	///
+	/// NOTE: This does not take into account changes which could be made to the account of `who`
+	/// (such as removing a provider reference) after this call is made. Any usage of this should
+	/// therefore ensure the account is already in the appropriate state prior to calling it.
+	fn hold_available(_reason: &Self::Reason, _who: &AccountId) -> bool {
+		true
+	}
+
+	/// Check to see if some `amount` of funds of `who` may be placed on hold with the given
+	/// `reason`. Reasons why this may not be true:
+	///
+	/// - The implementor supports only a limited number of concurrent holds on an account which is
+	///   the possible values of `reason`;
+	/// - The total balance of the account is less than `amount`;
+	/// - Removing `amount` from the total balance would kill the account and remove the only
+	///   provider reference.
+	///
+	/// Note: we pass `true` as the third argument to `reducible_balance` since we assume that if
+	/// needed the balance can slashed. If we are using a simple non-forcing reserve-transfer, then
+	/// we really ought to check that we are not reducing the funds below the freeze-limit (if any).
+	///
+	/// NOTE: This does not take into account changes which could be made to the account of `who`
+	/// (such as removing a provider reference) after this call is made. Any usage of this should
+	/// therefore ensure the account is already in the appropriate state prior to calling it.
+	fn ensure_can_hold(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult {
+		ensure!(Self::hold_available(reason, who), TokenError::CannotCreateHold);
+		ensure!(
+			amount <= Self::reducible_balance(who, Protect, Force),
+			TokenError::FundsUnavailable
+		);
+		Ok(())
+	}
+
+	/// Check to see if some `amount` of funds of `who` may be placed on hold for the given
+	/// `reason`. Reasons why this may not be true:
+	///
+	/// - The implementor supports only a limited number of concurrent holds on an account which is
+	///   the possible values of `reason`;
+	/// - The main balance of the account is less than `amount`;
+	/// - Removing `amount` from the main balance would kill the account and remove the only
+	///   provider reference.
+	///
+	/// NOTE: This does not take into account changes which could be made to the account of `who`
+	/// (such as removing a provider reference) after this call is made. Any usage of this should
+	/// therefore ensure the account is already in the appropriate state prior to calling it.
+	fn can_hold(reason: &Self::Reason, who: &AccountId, amount: Self::Balance) -> bool {
+		Self::ensure_can_hold(reason, who, amount).is_ok()
+	}
+}
+
+/// A fungible, holdable token class where the balance on hold can be set arbitrarily.
+///
+/// **WARNING**
+/// Do not use this directly unless you want trouble, since it allows you to alter account balances
+/// without keeping the issuance up to date. It has no safeguards against accidentally creating
+/// token imbalances in your system leading to accidental inflation or deflation. It's really just
+/// for the underlying datatype to implement so the user gets the much safer `Balanced` trait to
+/// use.
+pub trait Unbalanced<AccountId>: Inspect<AccountId> {
+	/// Forcefully set the balance on hold of `who` to `amount`. This is independent of any other
+	/// balances on hold or the main ("free") balance.
+	///
+	/// If this call executes successfully, you can `assert_eq!(Self::balance_on_hold(), amount);`.
+	///
+	/// This function does its best to force the balance change through, but will not break system
+	/// invariants such as any Existential Deposits needed or overflows/underflows.
+	/// If this cannot be done for some reason (e.g. because the account doesn't exist) then an
+	/// `Err` is returned.
+	// Implementation note: This should increment the consumer refs if it moves total on hold from
+	// zero to non-zero and decrement in the opposite direction.
+	//
+	// Since this was not done in the previous logic, this will need either a migration or a
+	// state item which tracks whether the account is on the old logic or new.
+	fn set_balance_on_hold(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult;
+
+	/// Reduce the balance on hold of `who` by `amount`.
+	///
+	/// If `precision` is `Exact` and it cannot be reduced by that amount for
+	/// some reason, return `Err` and don't reduce it at all. If `precision` is `BestEffort`, then
+	/// reduce the balance of `who` by the most that is possible, up to `amount`.
+	///
+	/// In either case, if `Ok` is returned then the inner is the amount by which is was reduced.
+	fn decrease_balance_on_hold(
+		reason: &Self::Reason,
+		who: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance_on_hold(reason, who);
+		if let BestEffort = precision {
+			amount = amount.min(old_balance);
+		}
+		let new_balance = old_balance.checked_sub(&amount).ok_or(TokenError::FundsUnavailable)?;
+		Self::set_balance_on_hold(reason, who, new_balance)?;
+		Ok(amount)
+	}
+
+	/// Increase the balance on hold of `who` by `amount`.
+	///
+	/// If it cannot be increased by that amount for some reason, return `Err` and don't increase
+	/// it at all. If Ok, return the imbalance.
+	fn increase_balance_on_hold(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance_on_hold(reason, who);
+		let new_balance = if let BestEffort = precision {
+			old_balance.saturating_add(amount)
+		} else {
+			old_balance.checked_add(&amount).ok_or(ArithmeticError::Overflow)?
+		};
+		let amount = new_balance.saturating_sub(old_balance);
+		if !amount.is_zero() {
+			Self::set_balance_on_hold(reason, who, new_balance)?;
+		}
+		Ok(amount)
+	}
+}
+
+/// Trait for mutating a fungible asset which can be placed on hold.
+pub trait Mutate<AccountId>:
+	Inspect<AccountId> + super::Unbalanced<AccountId> + Unbalanced<AccountId>
+{
+	/// Hold some funds in an account. If a hold for `reason` is already in place, then this
+	/// will increase it.
+	fn hold(reason: &Self::Reason, who: &AccountId, amount: Self::Balance) -> DispatchResult {
+		// NOTE: This doesn't change the total balance of the account so there's no need to
+		// check liquidity.
+
+		Self::ensure_can_hold(reason, who, amount)?;
+		// Should be infallible now, but we proceed softly anyway.
+		Self::decrease_balance(who, amount, Exact, Protect, Force)?;
+		Self::increase_balance_on_hold(reason, who, amount, BestEffort)?;
+		Self::done_hold(reason, who, amount);
+		Ok(())
+	}
+
+	/// Release up to `amount` held funds in an account.
+	///
+	/// The actual amount released is returned with `Ok`.
+	///
+	/// If `precision` is `BestEffort`, then the amount actually unreserved and returned as the
+	/// inner value of `Ok` may be smaller than the `amount` passed.
+	///
+	/// NOTE! The inner of the `Ok` result variant returns the *actual* amount released. This is the
+	/// opposite of the `ReservableCurrency::unreserve()` result, which gives the amount not able
+	/// to be released!
+	fn release(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		// NOTE: This doesn't change the total balance of the account so there's no need to
+		// check liquidity.
+
+		// We want to make sure we can deposit the amount in advance. If we can't then something is
+		// very wrong.
+		ensure!(Self::can_deposit(who, amount, Extant) == Success, TokenError::CannotCreate);
+		// Get the amount we can actually take from the hold. This might be less than what we want
+		// if we're only doing a best-effort.
+		let amount = Self::decrease_balance_on_hold(reason, who, amount, precision)?;
+		// Increase the main balance by what we took. We always do a best-effort here because we
+		// already checked that we can deposit before.
+		let actual = Self::increase_balance(who, amount, BestEffort)?;
+		Self::done_release(reason, who, actual);
+		Ok(actual)
+	}
+
+	/// Attempt to decrease the balance of `who` which is held for the given `reason` by `amount`.
+	///
+	/// If `precision` is `BestEffort`, then as much as possible is reduced, up to `amount`, and the
+	/// amount of tokens reduced is returned. Otherwise, if the total amount can be reduced, then it
+	/// is and the amount returned, and if not, then nothing changes and `Err` is returned.
+	///
+	/// If `force` is `Force`, then locks/freezes will be ignored. This should only be used when
+	/// conducting slashing or other activity which materially disadvantages the account holder
+	/// since it could provide a means of circumventing freezes.
+	fn burn_held(
+		reason: &Self::Reason,
+		who: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		// We must check total-balance requirements if `!force`.
+		let liquid = Self::reducible_total_balance_on_hold(who, force);
+		if let BestEffort = precision {
+			amount = amount.min(liquid);
+		} else {
+			ensure!(amount <= liquid, TokenError::Frozen);
+		}
+		let amount = Self::decrease_balance_on_hold(reason, who, amount, precision)?;
+		Self::set_total_issuance(Self::total_issuance().saturating_sub(amount));
+		Self::done_burn_held(reason, who, amount);
+		Ok(amount)
+	}
+
+	/// Transfer held funds into a destination account.
+	///
+	/// If `mode` is `OnHold`, then the destination account must already exist and the assets
+	/// transferred will still be on hold in the destination account. If not, then the destination
+	/// account need not already exist, but must be creatable.
+	///
+	/// If `precision` is `BestEffort`, then an amount less than `amount` may be transferred without
+	/// error.
+	///
+	/// If `force` is `Force`, then other fund-locking mechanisms may be disregarded. It should be
+	/// left as `Polite` in most circumstances, but when you want the same power as a `slash`, it
+	/// may be `Force`.
+	///
+	/// The actual amount transferred is returned, or `Err` in the case of error and nothing is
+	/// changed.
+	fn transfer_on_hold(
+		reason: &Self::Reason,
+		source: &AccountId,
+		dest: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+		mode: Restriction,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		// We must check total-balance requirements if `force` is `Fortitude::Polite`.
+		let have = Self::balance_on_hold(reason, source);
+		let liquid = Self::reducible_total_balance_on_hold(source, force);
+		if let BestEffort = precision {
+			amount = amount.min(liquid).min(have);
+		} else {
+			ensure!(amount <= liquid, TokenError::Frozen);
+			ensure!(amount <= have, TokenError::FundsUnavailable);
+		}
+
+		// We want to make sure we can deposit the amount in advance. If we can't then something is
+		// very wrong.
+		ensure!(Self::can_deposit(dest, amount, Extant) == Success, TokenError::CannotCreate);
+		ensure!(mode == Free || Self::hold_available(reason, dest), TokenError::CannotCreateHold);
+
+		let amount = Self::decrease_balance_on_hold(reason, source, amount, precision)?;
+		let actual = if mode == OnHold {
+			Self::increase_balance_on_hold(reason, dest, amount, precision)?
+		} else {
+			Self::increase_balance(dest, amount, precision)?
+		};
+		Self::done_transfer_on_hold(reason, source, dest, actual);
+		Ok(actual)
+	}
+
+	/// Transfer some `amount` of free balance from `source` to become owned by `dest` but on hold
+	/// for `reason`.
+	///
+	/// If `precision` is `BestEffort`, then an amount less than `amount` may be transferred without
+	/// error.
+	///
+	/// `source` must obey the requirements of `keep_alive`.
+	///
+	/// If `force` is `Force`, then other fund-locking mechanisms may be disregarded. It should be
+	/// left as `Polite` in most circumstances, but when you want the same power as a `slash`, it
+	/// may be `Force`.
+	///
+	/// The amount placed on hold is returned or `Err` in the case of error and nothing is changed.
+	///
+	/// WARNING: This may return an error after a partial storage mutation. It should be used only
+	/// inside a transactional storage context and an `Err` result must imply a storage rollback.
+	fn transfer_and_hold(
+		reason: &Self::Reason,
+		source: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		expendability: Preservation,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		ensure!(Self::hold_available(reason, dest), TokenError::CannotCreateHold);
+		ensure!(Self::can_deposit(dest, amount, Extant) == Success, TokenError::CannotCreate);
+		let actual = Self::decrease_balance(source, amount, precision, expendability, force)?;
+		Self::increase_balance_on_hold(reason, dest, actual, precision)?;
+		Self::done_transfer_on_hold(reason, source, dest, actual);
+		Ok(actual)
+	}
+
+	fn done_hold(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_release(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_burn_held(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_transfer_on_hold(
+		_reason: &Self::Reason,
+		_source: &AccountId,
+		_dest: &AccountId,
+		_amount: Self::Balance,
+	) {
+	}
+	fn done_transfer_and_hold(
+		_reason: &Self::Reason,
+		_source: &AccountId,
+		_dest: &AccountId,
+		_transferred: Self::Balance,
+	) {
+	}
+}
+
+/// Trait for slashing a fungible asset which can be place on hold.
+pub trait Balanced<AccountId>: super::Balanced<AccountId> + Unbalanced<AccountId> {
+	/// Reduce the balance of some funds on hold in an account.
+	///
+	/// The resulting imbalance is the first item of the tuple returned.
+	///
+	/// As much funds that are on hold up to `amount` will be deducted as possible. If this is less
+	/// than `amount`, then a non-zero second item will be returned.
+	fn slash(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> (Credit<AccountId, Self>, Self::Balance) {
+		let decrease = Self::decrease_balance_on_hold(reason, who, amount, BestEffort)
+			.unwrap_or(Default::default());
+		let credit =
+			Imbalance::<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>::new(decrease);
+		Self::done_slash(reason, who, decrease);
+		(credit, amount.saturating_sub(decrease))
+	}
+
+	fn done_slash(_reason: &Self::Reason, _who: &AccountId, _amount: Self::Balance) {}
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungible/imbalance.rs b/substrate/frame/support/src/traits/tokens/fungible/imbalance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..de85924a4de7c75ca0c18c262ebfb28ee6605a0f
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/imbalance.rs
@@ -0,0 +1,159 @@
+// 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.
+
+//! The imbalance type and its associates, which handles keeps everything adding up properly with
+//! unbalanced operations.
+
+use super::{super::Imbalance as ImbalanceT, Balanced, *};
+use crate::traits::{
+	misc::{SameOrOther, TryDrop},
+	tokens::Balance,
+};
+use sp_runtime::{traits::Zero, RuntimeDebug};
+use sp_std::marker::PhantomData;
+
+/// Handler for when an imbalance gets dropped. This could handle either a credit (negative) or
+/// debt (positive) imbalance.
+pub trait HandleImbalanceDrop<Balance> {
+	/// Some something with the imbalance's value which is being dropped.
+	fn handle(amount: Balance);
+}
+
+impl<Balance> HandleImbalanceDrop<Balance> for () {
+	fn handle(_: Balance) {}
+}
+
+/// An imbalance in the system, representing a divergence of recorded token supply from the sum of
+/// the balances of all accounts. This is `must_use` in order to ensure it gets handled (placing
+/// into an account, settling from an account or altering the supply).
+///
+/// Importantly, it has a special `Drop` impl, and cannot be created outside of this module.
+#[must_use]
+#[derive(RuntimeDebug, Eq, PartialEq)]
+pub struct Imbalance<
+	B: Balance,
+	OnDrop: HandleImbalanceDrop<B>,
+	OppositeOnDrop: HandleImbalanceDrop<B>,
+> {
+	amount: B,
+	_phantom: PhantomData<(OnDrop, OppositeOnDrop)>,
+}
+
+impl<B: Balance, OnDrop: HandleImbalanceDrop<B>, OppositeOnDrop: HandleImbalanceDrop<B>> Drop
+	for Imbalance<B, OnDrop, OppositeOnDrop>
+{
+	fn drop(&mut self) {
+		if !self.amount.is_zero() {
+			OnDrop::handle(self.amount)
+		}
+	}
+}
+
+impl<B: Balance, OnDrop: HandleImbalanceDrop<B>, OppositeOnDrop: HandleImbalanceDrop<B>> TryDrop
+	for Imbalance<B, OnDrop, OppositeOnDrop>
+{
+	/// Drop an instance cleanly. Only works if its value represents "no-operation".
+	fn try_drop(self) -> Result<(), Self> {
+		self.drop_zero()
+	}
+}
+
+impl<B: Balance, OnDrop: HandleImbalanceDrop<B>, OppositeOnDrop: HandleImbalanceDrop<B>> Default
+	for Imbalance<B, OnDrop, OppositeOnDrop>
+{
+	fn default() -> Self {
+		Self::zero()
+	}
+}
+
+impl<B: Balance, OnDrop: HandleImbalanceDrop<B>, OppositeOnDrop: HandleImbalanceDrop<B>>
+	Imbalance<B, OnDrop, OppositeOnDrop>
+{
+	pub(crate) fn new(amount: B) -> Self {
+		Self { amount, _phantom: PhantomData }
+	}
+}
+
+impl<B: Balance, OnDrop: HandleImbalanceDrop<B>, OppositeOnDrop: HandleImbalanceDrop<B>>
+	ImbalanceT<B> for Imbalance<B, OnDrop, OppositeOnDrop>
+{
+	type Opposite = Imbalance<B, OppositeOnDrop, OnDrop>;
+
+	fn zero() -> Self {
+		Self { amount: Zero::zero(), _phantom: PhantomData }
+	}
+
+	fn drop_zero(self) -> Result<(), Self> {
+		if self.amount.is_zero() {
+			sp_std::mem::forget(self);
+			Ok(())
+		} else {
+			Err(self)
+		}
+	}
+
+	fn split(self, amount: B) -> (Self, Self) {
+		let first = self.amount.min(amount);
+		let second = self.amount - first;
+		sp_std::mem::forget(self);
+		(Imbalance::new(first), Imbalance::new(second))
+	}
+	fn merge(mut self, other: Self) -> Self {
+		self.amount = self.amount.saturating_add(other.amount);
+		sp_std::mem::forget(other);
+		self
+	}
+	fn subsume(&mut self, other: Self) {
+		self.amount = self.amount.saturating_add(other.amount);
+		sp_std::mem::forget(other);
+	}
+	fn offset(
+		self,
+		other: Imbalance<B, OppositeOnDrop, OnDrop>,
+	) -> SameOrOther<Self, Imbalance<B, OppositeOnDrop, OnDrop>> {
+		let (a, b) = (self.amount, other.amount);
+		sp_std::mem::forget((self, other));
+
+		if a == b {
+			SameOrOther::None
+		} else if a > b {
+			SameOrOther::Same(Imbalance::new(a - b))
+		} else {
+			SameOrOther::Other(Imbalance::<B, OppositeOnDrop, OnDrop>::new(b - a))
+		}
+	}
+	fn peek(&self) -> B {
+		self.amount
+	}
+}
+
+/// Imbalance implying that the total_issuance value is less than the sum of all account balances.
+pub type Debt<AccountId, B> = Imbalance<
+	<B as Inspect<AccountId>>::Balance,
+	// This will generally be implemented by increasing the total_issuance value.
+	<B as Balanced<AccountId>>::OnDropDebt,
+	<B as Balanced<AccountId>>::OnDropCredit,
+>;
+
+/// Imbalance implying that the total_issuance value is greater than the sum of all account
+/// balances.
+pub type Credit<AccountId, B> = Imbalance<
+	<B as Inspect<AccountId>>::Balance,
+	// This will generally be implemented by decreasing the total_issuance value.
+	<B as Balanced<AccountId>>::OnDropCredit,
+	<B as Balanced<AccountId>>::OnDropDebt,
+>;
diff --git a/substrate/frame/support/src/traits/tokens/fungible/item_of.rs b/substrate/frame/support/src/traits/tokens/fungible/item_of.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cf2d96ef28791aa1eef17f621045311c2e61a8af
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/item_of.rs
@@ -0,0 +1,451 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! Adapter to use `fungibles::*` implementations as `fungible::*`.
+
+use sp_core::Get;
+use sp_runtime::{DispatchError, DispatchResult};
+
+use super::*;
+use crate::traits::tokens::{
+	fungibles, DepositConsequence, Fortitude, Imbalance as ImbalanceT, Precision, Preservation,
+	Provenance, Restriction, WithdrawConsequence,
+};
+
+/// Convert a `fungibles` trait implementation into a `fungible` trait implementation by identifying
+/// a single item.
+pub struct ItemOf<
+	F: fungibles::Inspect<AccountId>,
+	A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+	AccountId,
+>(sp_std::marker::PhantomData<(F, A, AccountId)>);
+
+impl<
+		F: fungibles::Inspect<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> Inspect<AccountId> for ItemOf<F, A, AccountId>
+{
+	type Balance = <F as fungibles::Inspect<AccountId>>::Balance;
+	fn total_issuance() -> Self::Balance {
+		<F as fungibles::Inspect<AccountId>>::total_issuance(A::get())
+	}
+	fn active_issuance() -> Self::Balance {
+		<F as fungibles::Inspect<AccountId>>::active_issuance(A::get())
+	}
+	fn minimum_balance() -> Self::Balance {
+		<F as fungibles::Inspect<AccountId>>::minimum_balance(A::get())
+	}
+	fn balance(who: &AccountId) -> Self::Balance {
+		<F as fungibles::Inspect<AccountId>>::balance(A::get(), who)
+	}
+	fn total_balance(who: &AccountId) -> Self::Balance {
+		<F as fungibles::Inspect<AccountId>>::total_balance(A::get(), who)
+	}
+	fn reducible_balance(
+		who: &AccountId,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Self::Balance {
+		<F as fungibles::Inspect<AccountId>>::reducible_balance(A::get(), who, preservation, force)
+	}
+	fn can_deposit(
+		who: &AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence {
+		<F as fungibles::Inspect<AccountId>>::can_deposit(A::get(), who, amount, provenance)
+	}
+	fn can_withdraw(who: &AccountId, amount: Self::Balance) -> WithdrawConsequence<Self::Balance> {
+		<F as fungibles::Inspect<AccountId>>::can_withdraw(A::get(), who, amount)
+	}
+}
+
+impl<
+		F: fungibles::InspectHold<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> InspectHold<AccountId> for ItemOf<F, A, AccountId>
+{
+	type Reason = F::Reason;
+
+	fn reducible_total_balance_on_hold(who: &AccountId, force: Fortitude) -> Self::Balance {
+		<F as fungibles::InspectHold<AccountId>>::reducible_total_balance_on_hold(
+			A::get(),
+			who,
+			force,
+		)
+	}
+	fn hold_available(reason: &Self::Reason, who: &AccountId) -> bool {
+		<F as fungibles::InspectHold<AccountId>>::hold_available(A::get(), reason, who)
+	}
+	fn total_balance_on_hold(who: &AccountId) -> Self::Balance {
+		<F as fungibles::InspectHold<AccountId>>::total_balance_on_hold(A::get(), who)
+	}
+	fn balance_on_hold(reason: &Self::Reason, who: &AccountId) -> Self::Balance {
+		<F as fungibles::InspectHold<AccountId>>::balance_on_hold(A::get(), reason, who)
+	}
+	fn can_hold(reason: &Self::Reason, who: &AccountId, amount: Self::Balance) -> bool {
+		<F as fungibles::InspectHold<AccountId>>::can_hold(A::get(), reason, who, amount)
+	}
+}
+
+impl<
+		F: fungibles::InspectFreeze<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> InspectFreeze<AccountId> for ItemOf<F, A, AccountId>
+{
+	type Id = F::Id;
+	fn balance_frozen(id: &Self::Id, who: &AccountId) -> Self::Balance {
+		<F as fungibles::InspectFreeze<AccountId>>::balance_frozen(A::get(), id, who)
+	}
+	fn balance_freezable(who: &AccountId) -> Self::Balance {
+		<F as fungibles::InspectFreeze<AccountId>>::balance_freezable(A::get(), who)
+	}
+	fn can_freeze(id: &Self::Id, who: &AccountId) -> bool {
+		<F as fungibles::InspectFreeze<AccountId>>::can_freeze(A::get(), id, who)
+	}
+}
+
+impl<
+		F: fungibles::Unbalanced<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> Unbalanced<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn handle_dust(dust: regular::Dust<AccountId, Self>)
+	where
+		Self: Sized,
+	{
+		<F as fungibles::Unbalanced<AccountId>>::handle_dust(fungibles::Dust(A::get(), dust.0))
+	}
+	fn write_balance(
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> Result<Option<Self::Balance>, DispatchError> {
+		<F as fungibles::Unbalanced<AccountId>>::write_balance(A::get(), who, amount)
+	}
+	fn set_total_issuance(amount: Self::Balance) -> () {
+		<F as fungibles::Unbalanced<AccountId>>::set_total_issuance(A::get(), amount)
+	}
+	fn decrease_balance(
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::Unbalanced<AccountId>>::decrease_balance(
+			A::get(),
+			who,
+			amount,
+			precision,
+			preservation,
+			force,
+		)
+	}
+	fn increase_balance(
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::Unbalanced<AccountId>>::increase_balance(A::get(), who, amount, precision)
+	}
+}
+
+impl<
+		F: fungibles::UnbalancedHold<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> UnbalancedHold<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn set_balance_on_hold(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult {
+		<F as fungibles::UnbalancedHold<AccountId>>::set_balance_on_hold(
+			A::get(),
+			reason,
+			who,
+			amount,
+		)
+	}
+	fn decrease_balance_on_hold(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::UnbalancedHold<AccountId>>::decrease_balance_on_hold(
+			A::get(),
+			reason,
+			who,
+			amount,
+			precision,
+		)
+	}
+	fn increase_balance_on_hold(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::UnbalancedHold<AccountId>>::increase_balance_on_hold(
+			A::get(),
+			reason,
+			who,
+			amount,
+			precision,
+		)
+	}
+}
+
+impl<
+		F: fungibles::Mutate<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> Mutate<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn mint_into(who: &AccountId, amount: Self::Balance) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::Mutate<AccountId>>::mint_into(A::get(), who, amount)
+	}
+	fn burn_from(
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::Mutate<AccountId>>::burn_from(A::get(), who, amount, precision, force)
+	}
+	fn shelve(who: &AccountId, amount: Self::Balance) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::Mutate<AccountId>>::shelve(A::get(), who, amount)
+	}
+	fn restore(who: &AccountId, amount: Self::Balance) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::Mutate<AccountId>>::restore(A::get(), who, amount)
+	}
+	fn transfer(
+		source: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+		preservation: Preservation,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::Mutate<AccountId>>::transfer(A::get(), source, dest, amount, preservation)
+	}
+
+	fn set_balance(who: &AccountId, amount: Self::Balance) -> Self::Balance {
+		<F as fungibles::Mutate<AccountId>>::set_balance(A::get(), who, amount)
+	}
+}
+
+impl<
+		F: fungibles::MutateHold<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> MutateHold<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn hold(reason: &Self::Reason, who: &AccountId, amount: Self::Balance) -> DispatchResult {
+		<F as fungibles::MutateHold<AccountId>>::hold(A::get(), reason, who, amount)
+	}
+	fn release(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::MutateHold<AccountId>>::release(A::get(), reason, who, amount, precision)
+	}
+	fn burn_held(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::MutateHold<AccountId>>::burn_held(
+			A::get(),
+			reason,
+			who,
+			amount,
+			precision,
+			force,
+		)
+	}
+	fn transfer_on_hold(
+		reason: &Self::Reason,
+		source: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		mode: Restriction,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::MutateHold<AccountId>>::transfer_on_hold(
+			A::get(),
+			reason,
+			source,
+			dest,
+			amount,
+			precision,
+			mode,
+			force,
+		)
+	}
+	fn transfer_and_hold(
+		reason: &Self::Reason,
+		source: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		<F as fungibles::MutateHold<AccountId>>::transfer_and_hold(
+			A::get(),
+			reason,
+			source,
+			dest,
+			amount,
+			precision,
+			preservation,
+			force,
+		)
+	}
+}
+
+impl<
+		F: fungibles::MutateFreeze<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> MutateFreeze<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn set_freeze(id: &Self::Id, who: &AccountId, amount: Self::Balance) -> DispatchResult {
+		<F as fungibles::MutateFreeze<AccountId>>::set_freeze(A::get(), id, who, amount)
+	}
+	fn extend_freeze(id: &Self::Id, who: &AccountId, amount: Self::Balance) -> DispatchResult {
+		<F as fungibles::MutateFreeze<AccountId>>::extend_freeze(A::get(), id, who, amount)
+	}
+	fn thaw(id: &Self::Id, who: &AccountId) -> DispatchResult {
+		<F as fungibles::MutateFreeze<AccountId>>::thaw(A::get(), id, who)
+	}
+}
+
+pub struct ConvertImbalanceDropHandler<AccountId, Balance, AssetIdType, AssetId, Handler>(
+	sp_std::marker::PhantomData<(AccountId, Balance, AssetIdType, AssetId, Handler)>,
+);
+
+impl<
+		AccountId,
+		Balance,
+		AssetIdType,
+		AssetId: Get<AssetIdType>,
+		Handler: crate::traits::tokens::fungibles::HandleImbalanceDrop<AssetIdType, Balance>,
+	> HandleImbalanceDrop<Balance>
+	for ConvertImbalanceDropHandler<AccountId, Balance, AssetIdType, AssetId, Handler>
+{
+	fn handle(amount: Balance) {
+		Handler::handle(AssetId::get(), amount)
+	}
+}
+
+impl<
+		F: fungibles::Inspect<AccountId>
+			+ fungibles::Unbalanced<AccountId>
+			+ fungibles::Balanced<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> Balanced<AccountId> for ItemOf<F, A, AccountId>
+{
+	type OnDropDebt =
+		ConvertImbalanceDropHandler<AccountId, Self::Balance, F::AssetId, A, F::OnDropDebt>;
+	type OnDropCredit =
+		ConvertImbalanceDropHandler<AccountId, Self::Balance, F::AssetId, A, F::OnDropCredit>;
+	fn deposit(
+		who: &AccountId,
+		value: Self::Balance,
+		precision: Precision,
+	) -> Result<Debt<AccountId, Self>, DispatchError> {
+		<F as fungibles::Balanced<AccountId>>::deposit(A::get(), who, value, precision)
+			.map(|debt| Imbalance::new(debt.peek()))
+	}
+	fn issue(amount: Self::Balance) -> Credit<AccountId, Self> {
+		Imbalance::new(<F as fungibles::Balanced<AccountId>>::issue(A::get(), amount).peek())
+	}
+	fn pair(amount: Self::Balance) -> (Debt<AccountId, Self>, Credit<AccountId, Self>) {
+		let (a, b) = <F as fungibles::Balanced<AccountId>>::pair(A::get(), amount);
+		(Imbalance::new(a.peek()), Imbalance::new(b.peek()))
+	}
+	fn rescind(amount: Self::Balance) -> Debt<AccountId, Self> {
+		Imbalance::new(<F as fungibles::Balanced<AccountId>>::rescind(A::get(), amount).peek())
+	}
+	fn resolve(
+		who: &AccountId,
+		credit: Credit<AccountId, Self>,
+	) -> Result<(), Credit<AccountId, Self>> {
+		let credit = fungibles::Imbalance::new(A::get(), credit.peek());
+		<F as fungibles::Balanced<AccountId>>::resolve(who, credit)
+			.map_err(|credit| Imbalance::new(credit.peek()))
+	}
+	fn settle(
+		who: &AccountId,
+		debt: Debt<AccountId, Self>,
+		preservation: Preservation,
+	) -> Result<Credit<AccountId, Self>, Debt<AccountId, Self>> {
+		let debt = fungibles::Imbalance::new(A::get(), debt.peek());
+		<F as fungibles::Balanced<AccountId>>::settle(who, debt, preservation)
+			.map(|credit| Imbalance::new(credit.peek()))
+			.map_err(|debt| Imbalance::new(debt.peek()))
+	}
+	fn withdraw(
+		who: &AccountId,
+		value: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Result<Credit<AccountId, Self>, DispatchError> {
+		<F as fungibles::Balanced<AccountId>>::withdraw(
+			A::get(),
+			who,
+			value,
+			precision,
+			preservation,
+			force,
+		)
+		.map(|credit| Imbalance::new(credit.peek()))
+	}
+}
+
+impl<
+		F: fungibles::BalancedHold<AccountId>,
+		A: Get<<F as fungibles::Inspect<AccountId>>::AssetId>,
+		AccountId,
+	> BalancedHold<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn slash(
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> (Credit<AccountId, Self>, Self::Balance) {
+		let (credit, amount) =
+			<F as fungibles::BalancedHold<AccountId>>::slash(A::get(), reason, who, amount);
+		(Imbalance::new(credit.peek()), amount)
+	}
+}
+
+#[test]
+fn test() {}
diff --git a/substrate/frame/support/src/traits/tokens/fungible/mod.rs b/substrate/frame/support/src/traits/tokens/fungible/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8ab63ad366f08318ebbd996d18d897f4a4e9e200
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/mod.rs
@@ -0,0 +1,57 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! The traits for dealing with a single fungible token class and any associated types.
+//!
+//! ### User-implememted traits
+//! - `Inspect`: Regular balance inspector functions.
+//! - `Unbalanced`: Low-level balance mutating functions. Does not guarantee proper book-keeping and
+//!   so should not be called into directly from application code. Other traits depend on this and
+//!   provide default implementations based on it.
+//! - `UnbalancedHold`: Low-level balance mutating functions for balances placed on hold. Does not
+//!   guarantee proper book-keeping and so should not be called into directly from application code.
+//!   Other traits depend on this and provide default implementations based on it.
+//! - `Mutate`: Regular balance mutator functions. Pre-implemented using `Unbalanced`, though the
+//!   `done_*` functions should likely be reimplemented in case you want to do something following
+//!   the operation such as emit events.
+//! - `InspectHold`: Inspector functions for balances on hold.
+//! - `MutateHold`: Mutator functions for balances on hold. Mostly pre-implemented using
+//!   `UnbalancedHold`.
+//! - `InspectFreeze`: Inspector functions for frozen balance.
+//! - `MutateFreeze`: Mutator functions for frozen balance.
+//! - `Balanced`: One-sided mutator functions for regular balances, which return imbalance objects
+//!   which guarantee eventual book-keeping. May be useful for some sophisticated operations where
+//!   funds must be removed from an account before it is known precisely what should be done with
+//!   them.
+
+pub mod conformance_tests;
+pub mod freeze;
+pub mod hold;
+mod imbalance;
+mod item_of;
+mod regular;
+
+pub use freeze::{Inspect as InspectFreeze, Mutate as MutateFreeze};
+pub use hold::{
+	Balanced as BalancedHold, Inspect as InspectHold, Mutate as MutateHold,
+	Unbalanced as UnbalancedHold,
+};
+pub use imbalance::{Credit, Debt, HandleImbalanceDrop, Imbalance};
+pub use item_of::ItemOf;
+pub use regular::{
+	Balanced, DecreaseIssuance, Dust, IncreaseIssuance, Inspect, Mutate, Unbalanced,
+};
diff --git a/substrate/frame/support/src/traits/tokens/fungible/regular.rs b/substrate/frame/support/src/traits/tokens/fungible/regular.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2838bed540aa261e1c4b5c7a985f4b294e20dd81
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungible/regular.rs
@@ -0,0 +1,507 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! `Inspect` and `Mutate` traits for working with regular balances.
+
+use crate::{
+	dispatch::DispatchError,
+	ensure,
+	traits::{
+		tokens::{
+			misc::{
+				Balance, DepositConsequence,
+				Fortitude::{self, Force, Polite},
+				Precision::{self, BestEffort, Exact},
+				Preservation::{self, Expendable},
+				Provenance::{self, Extant},
+				WithdrawConsequence,
+			},
+			Imbalance as ImbalanceT,
+		},
+		SameOrOther, TryDrop,
+	},
+};
+use sp_arithmetic::traits::{CheckedAdd, CheckedSub, One};
+use sp_runtime::{traits::Saturating, ArithmeticError, TokenError};
+use sp_std::marker::PhantomData;
+
+use super::{Credit, Debt, HandleImbalanceDrop, Imbalance};
+
+/// Trait for providing balance-inspection access to a fungible asset.
+pub trait Inspect<AccountId>: Sized {
+	/// Scalar type for representing balance of an account.
+	type Balance: Balance;
+
+	/// The total amount of issuance in the system.
+	fn total_issuance() -> Self::Balance;
+
+	/// The total amount of issuance in the system excluding those which are controlled by the
+	/// system.
+	fn active_issuance() -> Self::Balance {
+		Self::total_issuance()
+	}
+
+	/// The minimum balance any single account may have.
+	fn minimum_balance() -> Self::Balance;
+
+	/// Get the total amount of funds whose ultimate beneficial ownership can be determined as
+	/// `who`.
+	///
+	/// This may include funds which are wholly inaccessible to `who`, either temporarily or even
+	/// indefinitely.
+	///
+	/// For the amount of the balance which is currently free to be removed from the account without
+	/// error, use `reducible_balance`.
+	///
+	/// For the amount of the balance which may eventually be free to be removed from the account,
+	/// use `balance()`.
+	fn total_balance(who: &AccountId) -> Self::Balance;
+
+	/// Get the balance of `who` which does not include funds which are exclusively allocated to
+	/// subsystems of the chain ("on hold" or "reserved").
+	///
+	/// In general this isn't especially useful outside of tests, and for practical purposes, you'll
+	/// want to use `reducible_balance()`.
+	fn balance(who: &AccountId) -> Self::Balance;
+
+	/// Get the maximum amount that `who` can withdraw/transfer successfully based on whether the
+	/// account should be kept alive (`preservation`) or whether we are willing to force the
+	/// reduction and potentially go below user-level restrictions on the minimum amount of the
+	/// account.
+	///
+	/// Always less than or equal to `balance()`.
+	fn reducible_balance(
+		who: &AccountId,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Self::Balance;
+
+	/// Returns `true` if the balance of `who` may be increased by `amount`.
+	///
+	/// - `who`: The account of which the balance should be increased by `amount`.
+	/// - `amount`: How much should the balance be increased?
+	/// - `provenance`: Will `amount` be minted to deposit it into `account` or is it already in the
+	///   system?
+	fn can_deposit(
+		who: &AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence;
+
+	/// Returns `Success` if the balance of `who` may be decreased by `amount`, otherwise
+	/// the consequence.
+	fn can_withdraw(who: &AccountId, amount: Self::Balance) -> WithdrawConsequence<Self::Balance>;
+}
+
+/// Special dust type which can be type-safely converted into a `Credit`.
+#[must_use]
+pub struct Dust<A, T: Inspect<A>>(pub T::Balance);
+
+impl<A, T: Balanced<A>> Dust<A, T> {
+	/// Convert `Dust` into an instance of `Credit`.
+	pub fn into_credit(self) -> Credit<A, T> {
+		Credit::<A, T>::new(self.0)
+	}
+}
+
+/// A fungible token class where the balance can be set arbitrarily.
+///
+/// **WARNING**
+/// Do not use this directly unless you want trouble, since it allows you to alter account balances
+/// without keeping the issuance up to date. It has no safeguards against accidentally creating
+/// token imbalances in your system leading to accidental inflation or deflation. It's really just
+/// for the underlying datatype to implement so the user gets the much safer `Balanced` trait to
+/// use.
+pub trait Unbalanced<AccountId>: Inspect<AccountId> {
+	/// Create some dust and handle it with `Self::handle_dust`. This is an unbalanced operation
+	/// and it must only be used when an account is modified in a raw fashion, outside of the entire
+	/// fungibles API. The `amount` is capped at `Self::minimum_balance() - 1`.
+	///
+	/// This should not be reimplemented.
+	fn handle_raw_dust(amount: Self::Balance) {
+		Self::handle_dust(Dust(amount.min(Self::minimum_balance().saturating_sub(One::one()))))
+	}
+
+	/// Do something with the dust which has been destroyed from the system. `Dust` can be converted
+	/// into a `Credit` with the `Balanced` trait impl.
+	fn handle_dust(dust: Dust<AccountId, Self>);
+
+	/// Forcefully set the balance of `who` to `amount`.
+	///
+	/// If this call executes successfully, you can `assert_eq!(Self::balance(), amount);`.
+	///
+	/// For implementations which include one or more balances on hold, then these are *not*
+	/// included in the `amount`.
+	///
+	/// This function does its best to force the balance change through, but will not break system
+	/// invariants such as any Existential Deposits needed or overflows/underflows.
+	/// If this cannot be done for some reason (e.g. because the account cannot be created, deleted
+	/// or would overflow) then an `Err` is returned.
+	///
+	/// If `Ok` is returned then its inner, if `Some` is the amount which was discarded as dust due
+	/// to existential deposit requirements. The default implementation of `decrease_balance` and
+	/// `increase_balance` converts this into an `Imbalance` and then passes it into `handle_dust`.
+	fn write_balance(
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> Result<Option<Self::Balance>, DispatchError>;
+
+	/// Set the total issuance to `amount`.
+	fn set_total_issuance(amount: Self::Balance);
+
+	/// Reduce the balance of `who` by `amount`.
+	///
+	/// If `precision` is `Exact` and it cannot be reduced by that amount for
+	/// some reason, return `Err` and don't reduce it at all. If `precision` is `BestEffort`, then
+	/// reduce the balance of `who` by the most that is possible, up to `amount`.
+	///
+	/// In either case, if `Ok` is returned then the inner is the amount by which is was reduced.
+	/// Minimum balance will be respected and thus the returned amount may be up to
+	/// `Self::minimum_balance() - 1` greater than `amount` in the case that the reduction caused
+	/// the account to be deleted.
+	fn decrease_balance(
+		who: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance(who);
+		let free = Self::reducible_balance(who, preservation, force);
+		if let BestEffort = precision {
+			amount = amount.min(free);
+		}
+		let new_balance = old_balance.checked_sub(&amount).ok_or(TokenError::FundsUnavailable)?;
+		if let Some(dust) = Self::write_balance(who, new_balance)? {
+			Self::handle_dust(Dust(dust));
+		}
+		Ok(old_balance.saturating_sub(new_balance))
+	}
+
+	/// Increase the balance of `who` by `amount`.
+	///
+	/// If it cannot be increased by that amount for some reason, return `Err` and don't increase
+	/// it at all. If Ok, return the imbalance.
+	/// Minimum balance will be respected and an error will be returned if
+	/// `amount < Self::minimum_balance()` when the account of `who` is zero.
+	fn increase_balance(
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance(who);
+		let new_balance = if let BestEffort = precision {
+			old_balance.saturating_add(amount)
+		} else {
+			old_balance.checked_add(&amount).ok_or(ArithmeticError::Overflow)?
+		};
+		if new_balance < Self::minimum_balance() {
+			// Attempt to increase from 0 to below minimum -> stays at zero.
+			if let BestEffort = precision {
+				Ok(Default::default())
+			} else {
+				Err(TokenError::BelowMinimum.into())
+			}
+		} else {
+			if new_balance == old_balance {
+				Ok(Default::default())
+			} else {
+				if let Some(dust) = Self::write_balance(who, new_balance)? {
+					Self::handle_dust(Dust(dust));
+				}
+				Ok(new_balance.saturating_sub(old_balance))
+			}
+		}
+	}
+
+	/// Reduce the active issuance by some amount.
+	fn deactivate(_: Self::Balance) {}
+
+	/// Increase the active issuance by some amount, up to the outstanding amount reduced.
+	fn reactivate(_: Self::Balance) {}
+}
+
+/// Trait for providing a basic fungible asset.
+pub trait Mutate<AccountId>: Inspect<AccountId> + Unbalanced<AccountId> {
+	/// Increase the balance of `who` by exactly `amount`, minting new tokens. If that isn't
+	/// possible then an `Err` is returned and nothing is changed.
+	fn mint_into(who: &AccountId, amount: Self::Balance) -> Result<Self::Balance, DispatchError> {
+		Self::total_issuance().checked_add(&amount).ok_or(ArithmeticError::Overflow)?;
+		let actual = Self::increase_balance(who, amount, Exact)?;
+		Self::set_total_issuance(Self::total_issuance().saturating_add(actual));
+		Self::done_mint_into(who, amount);
+		Ok(actual)
+	}
+
+	/// Decrease the balance of `who` by at least `amount`, possibly slightly more in the case of
+	/// minimum-balance requirements, burning the tokens. If that isn't possible then an `Err` is
+	/// returned and nothing is changed. If successful, the amount of tokens reduced is returned.
+	fn burn_from(
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		let actual = Self::reducible_balance(who, Expendable, force).min(amount);
+		ensure!(actual == amount || precision == BestEffort, TokenError::FundsUnavailable);
+		Self::total_issuance().checked_sub(&actual).ok_or(ArithmeticError::Overflow)?;
+		let actual = Self::decrease_balance(who, actual, BestEffort, Expendable, force)?;
+		Self::set_total_issuance(Self::total_issuance().saturating_sub(actual));
+		Self::done_burn_from(who, actual);
+		Ok(actual)
+	}
+
+	/// Attempt to decrease the `asset` balance of `who` by `amount`.
+	///
+	/// Equivalent to `burn_from`, except with an expectation that within the bounds of some
+	/// universal issuance, the total assets `suspend`ed and `resume`d will be equivalent. The
+	/// implementation may be configured such that the total assets suspended may never be less than
+	/// the total assets resumed (which is the invariant for an issuing system), or the reverse
+	/// (which the invariant in a non-issuing system).
+	///
+	/// Because of this expectation, any metadata associated with the asset is expected to survive
+	/// the suspect-resume cycle.
+	fn shelve(who: &AccountId, amount: Self::Balance) -> Result<Self::Balance, DispatchError> {
+		let actual = Self::reducible_balance(who, Expendable, Polite).min(amount);
+		ensure!(actual == amount, TokenError::FundsUnavailable);
+		Self::total_issuance().checked_sub(&actual).ok_or(ArithmeticError::Overflow)?;
+		let actual = Self::decrease_balance(who, actual, BestEffort, Expendable, Polite)?;
+		Self::set_total_issuance(Self::total_issuance().saturating_sub(actual));
+		Self::done_shelve(who, actual);
+		Ok(actual)
+	}
+
+	/// Attempt to increase the `asset` balance of `who` by `amount`.
+	///
+	/// Equivalent to `mint_into`, except with an expectation that within the bounds of some
+	/// universal issuance, the total assets `suspend`ed and `resume`d will be equivalent. The
+	/// implementation may be configured such that the total assets suspended may never be less than
+	/// the total assets resumed (which is the invariant for an issuing system), or the reverse
+	/// (which the invariant in a non-issuing system).
+	///
+	/// Because of this expectation, any metadata associated with the asset is expected to survive
+	/// the suspect-resume cycle.
+	fn restore(who: &AccountId, amount: Self::Balance) -> Result<Self::Balance, DispatchError> {
+		Self::total_issuance().checked_add(&amount).ok_or(ArithmeticError::Overflow)?;
+		let actual = Self::increase_balance(who, amount, Exact)?;
+		Self::set_total_issuance(Self::total_issuance().saturating_add(actual));
+		Self::done_restore(who, amount);
+		Ok(actual)
+	}
+
+	/// Transfer funds from one account into another.
+	fn transfer(
+		source: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+		preservation: Preservation,
+	) -> Result<Self::Balance, DispatchError> {
+		let _extra = Self::can_withdraw(source, amount).into_result(preservation != Expendable)?;
+		Self::can_deposit(dest, amount, Extant).into_result()?;
+		Self::decrease_balance(source, amount, BestEffort, preservation, Polite)?;
+		// This should never fail as we checked `can_deposit` earlier. But we do a best-effort
+		// anyway.
+		let _ = Self::increase_balance(dest, amount, BestEffort);
+		Self::done_transfer(source, dest, amount);
+		Ok(amount)
+	}
+
+	/// Simple infallible function to force an account to have a particular balance, good for use
+	/// in tests and benchmarks but not recommended for production code owing to the lack of
+	/// error reporting.
+	///
+	/// Returns the new balance.
+	fn set_balance(who: &AccountId, amount: Self::Balance) -> Self::Balance {
+		let b = Self::balance(who);
+		if b > amount {
+			Self::burn_from(who, b - amount, BestEffort, Force).map(|d| b.saturating_sub(d))
+		} else {
+			Self::mint_into(who, amount - b).map(|d| b.saturating_add(d))
+		}
+		.unwrap_or(b)
+	}
+
+	fn done_mint_into(_who: &AccountId, _amount: Self::Balance) {}
+	fn done_burn_from(_who: &AccountId, _amount: Self::Balance) {}
+	fn done_shelve(_who: &AccountId, _amount: Self::Balance) {}
+	fn done_restore(_who: &AccountId, _amount: Self::Balance) {}
+	fn done_transfer(_source: &AccountId, _dest: &AccountId, _amount: Self::Balance) {}
+}
+
+/// Simple handler for an imbalance drop which increases the total issuance of the system by the
+/// imbalance amount. Used for leftover debt.
+pub struct IncreaseIssuance<AccountId, U>(PhantomData<(AccountId, U)>);
+impl<AccountId, U: Unbalanced<AccountId>> HandleImbalanceDrop<U::Balance>
+	for IncreaseIssuance<AccountId, U>
+{
+	fn handle(amount: U::Balance) {
+		U::set_total_issuance(U::total_issuance().saturating_add(amount))
+	}
+}
+
+/// Simple handler for an imbalance drop which decreases the total issuance of the system by the
+/// imbalance amount. Used for leftover credit.
+pub struct DecreaseIssuance<AccountId, U>(PhantomData<(AccountId, U)>);
+impl<AccountId, U: Unbalanced<AccountId>> HandleImbalanceDrop<U::Balance>
+	for DecreaseIssuance<AccountId, U>
+{
+	fn handle(amount: U::Balance) {
+		U::set_total_issuance(U::total_issuance().saturating_sub(amount))
+	}
+}
+
+/// A fungible token class where any creation and deletion of tokens is semi-explicit and where the
+/// total supply is maintained automatically.
+///
+/// This is auto-implemented when a token class has `Unbalanced` implemented.
+pub trait Balanced<AccountId>: Inspect<AccountId> + Unbalanced<AccountId> {
+	/// The type for managing what happens when an instance of `Debt` is dropped without being used.
+	type OnDropDebt: HandleImbalanceDrop<Self::Balance>;
+	/// The type for managing what happens when an instance of `Credit` is dropped without being
+	/// used.
+	type OnDropCredit: HandleImbalanceDrop<Self::Balance>;
+
+	/// Reduce the total issuance by `amount` and return the according imbalance. The imbalance will
+	/// typically be used to reduce an account by the same amount with e.g. `settle`.
+	///
+	/// This is infallible, but doesn't guarantee that the entire `amount` is burnt, for example
+	/// in the case of underflow.
+	fn rescind(amount: Self::Balance) -> Debt<AccountId, Self> {
+		let old = Self::total_issuance();
+		let new = old.saturating_sub(amount);
+		Self::set_total_issuance(new);
+		let delta = old - new;
+		Self::done_rescind(delta);
+		Imbalance::<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>::new(delta)
+	}
+
+	/// Increase the total issuance by `amount` and return the according imbalance. The imbalance
+	/// will typically be used to increase an account by the same amount with e.g.
+	/// `resolve_into_existing` or `resolve_creating`.
+	///
+	/// This is infallible, but doesn't guarantee that the entire `amount` is issued, for example
+	/// in the case of overflow.
+	fn issue(amount: Self::Balance) -> Credit<AccountId, Self> {
+		let old = Self::total_issuance();
+		let new = old.saturating_add(amount);
+		Self::set_total_issuance(new);
+		let delta = new - old;
+		Self::done_issue(delta);
+		Imbalance::<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>::new(delta)
+	}
+
+	/// Produce a pair of imbalances that cancel each other out exactly.
+	///
+	/// This is just the same as burning and issuing the same amount and has no effect on the
+	/// total issuance.
+	fn pair(amount: Self::Balance) -> (Debt<AccountId, Self>, Credit<AccountId, Self>) {
+		(Self::rescind(amount), Self::issue(amount))
+	}
+
+	/// Mints `value` into the account of `who`, creating it as needed.
+	///
+	/// If `precision` is `BestEffort` and `value` in full could not be minted (e.g. due to
+	/// overflow), then the maximum is minted, up to `value`. If `precision` is `Exact`, then
+	/// exactly `value` must be minted into the account of `who` or the operation will fail with an
+	/// `Err` and nothing will change.
+	///
+	/// If the operation is successful, this will return `Ok` with a `Debt` of the total value
+	/// added to the account.
+	fn deposit(
+		who: &AccountId,
+		value: Self::Balance,
+		precision: Precision,
+	) -> Result<Debt<AccountId, Self>, DispatchError> {
+		let increase = Self::increase_balance(who, value, precision)?;
+		Self::done_deposit(who, increase);
+		Ok(Imbalance::<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>::new(increase))
+	}
+
+	/// Removes `value` balance from `who` account if possible.
+	///
+	/// If `precision` is `BestEffort` and `value` in full could not be removed (e.g. due to
+	/// underflow), then the maximum is removed, up to `value`. If `precision` is `Exact`, then
+	/// exactly `value` must be removed from the account of `who` or the operation will fail with an
+	/// `Err` and nothing will change.
+	///
+	/// If the removal is needed but not possible, then it returns `Err` and nothing is changed.
+	/// If the account needed to be deleted, then slightly more than `value` may be removed from the
+	/// account owning since up to (but not including) minimum balance may also need to be removed.
+	///
+	/// If the operation is successful, this will return `Ok` with a `Credit` of the total value
+	/// removed from the account.
+	fn withdraw(
+		who: &AccountId,
+		value: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Result<Credit<AccountId, Self>, DispatchError> {
+		let decrease = Self::decrease_balance(who, value, precision, preservation, force)?;
+		Self::done_withdraw(who, decrease);
+		Ok(Imbalance::<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>::new(decrease))
+	}
+
+	/// The balance of `who` is increased in order to counter `credit`. If the whole of `credit`
+	/// cannot be countered, then nothing is changed and the original `credit` is returned in an
+	/// `Err`.
+	///
+	/// Please note: If `credit.peek()` is less than `Self::minimum_balance()`, then `who` must
+	/// already exist for this to succeed.
+	fn resolve(
+		who: &AccountId,
+		credit: Credit<AccountId, Self>,
+	) -> Result<(), Credit<AccountId, Self>> {
+		let v = credit.peek();
+		let debt = match Self::deposit(who, v, Exact) {
+			Err(_) => return Err(credit),
+			Ok(d) => d,
+		};
+		let result = credit.offset(debt).try_drop();
+		debug_assert!(result.is_ok(), "ok deposit return must be equal to credit value; qed");
+		Ok(())
+	}
+
+	/// The balance of `who` is decreased in order to counter `debt`. If the whole of `debt`
+	/// cannot be countered, then nothing is changed and the original `debt` is returned in an
+	/// `Err`.
+	fn settle(
+		who: &AccountId,
+		debt: Debt<AccountId, Self>,
+		preservation: Preservation,
+	) -> Result<Credit<AccountId, Self>, Debt<AccountId, Self>> {
+		let amount = debt.peek();
+		let credit = match Self::withdraw(who, amount, Exact, preservation, Polite) {
+			Err(_) => return Err(debt),
+			Ok(d) => d,
+		};
+
+		match credit.offset(debt) {
+			SameOrOther::None => Ok(Credit::<AccountId, Self>::zero()),
+			SameOrOther::Same(dust) => Ok(dust),
+			SameOrOther::Other(rest) => {
+				debug_assert!(false, "ok withdraw return must be at least debt value; qed");
+				Err(rest)
+			},
+		}
+	}
+
+	fn done_rescind(_amount: Self::Balance) {}
+	fn done_issue(_amount: Self::Balance) {}
+	fn done_deposit(_who: &AccountId, _amount: Self::Balance) {}
+	fn done_withdraw(_who: &AccountId, _amount: Self::Balance) {}
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/approvals.rs b/substrate/frame/support/src/traits/tokens/fungibles/approvals.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7a80279b01981420840811e550c92c106a682bef
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/approvals.rs
@@ -0,0 +1,43 @@
+// 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.
+
+//! Inspect and Mutate traits for Asset approvals
+
+use crate::dispatch::DispatchResult;
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	// Check the amount approved by an owner to be spent by a delegate
+	fn allowance(asset: Self::AssetId, owner: &AccountId, delegate: &AccountId) -> Self::Balance;
+}
+
+pub trait Mutate<AccountId>: Inspect<AccountId> {
+	// Approve a delegate account to spend an amount of tokens owned by an owner
+	fn approve(
+		asset: Self::AssetId,
+		owner: &AccountId,
+		delegate: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult;
+
+	// Transfer from a delegate account an amount approved by the owner of the asset
+	fn transfer_from(
+		asset: Self::AssetId,
+		owner: &AccountId,
+		delegate: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult;
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/enumerable.rs b/substrate/frame/support/src/traits/tokens/fungibles/enumerable.rs
new file mode 100644
index 0000000000000000000000000000000000000000..08bb784a7dbf63fd39c51f0468cfe42cbcb16248
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/enumerable.rs
@@ -0,0 +1,24 @@
+// 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.
+
+/// Interface for enumerating assets in existence or owned by a given account.
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	type AssetsIterator;
+
+	/// Returns an iterator of the collections in existence.
+	fn asset_ids() -> Self::AssetsIterator;
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/freeze.rs b/substrate/frame/support/src/traits/tokens/fungibles/freeze.rs
new file mode 100644
index 0000000000000000000000000000000000000000..08549c2d4b74410737984e4ce5bf9e935a06f8a7
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/freeze.rs
@@ -0,0 +1,78 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! The traits for putting freezes within a single fungible token class.
+
+use scale_info::TypeInfo;
+use sp_runtime::DispatchResult;
+
+/// Trait for inspecting a fungible asset which can be frozen. Freezing is essentially setting a
+/// minimum balance below which the total balance (inclusive of any funds placed on hold) may not
+/// be normally allowed to drop. Generally, freezers will provide an "update" function such that
+/// if the total balance does drop below the limit, then the freezer can update their housekeeping
+/// accordingly.
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	/// An identifier for a freeze.
+	type Id: codec::Encode + TypeInfo + 'static;
+
+	/// Amount of funds held in reserve by `who` for the given `id`.
+	fn balance_frozen(asset: Self::AssetId, id: &Self::Id, who: &AccountId) -> Self::Balance;
+
+	/// The amount of the balance which can become frozen. Defaults to `total_balance()`.
+	fn balance_freezable(asset: Self::AssetId, who: &AccountId) -> Self::Balance {
+		Self::total_balance(asset, who)
+	}
+
+	/// Returns `true` if it's possible to introduce a freeze for the given `id` onto the
+	/// account of `who`. This will be true as long as the implementor supports as many
+	/// concurrent freeze locks as there are possible values of `id`.
+	fn can_freeze(asset: Self::AssetId, id: &Self::Id, who: &AccountId) -> bool;
+}
+
+/// Trait for introducing, altering and removing locks to freeze an account's funds so they never
+/// go below a set minimum.
+pub trait Mutate<AccountId>: Inspect<AccountId> {
+	/// Prevent actions which would reduce the balance of the account of `who` below the given
+	/// `amount` and identify this restriction though the given `id`. Unlike `extend_freeze`, any
+	/// outstanding freeze in place for `who` under the `id` are dropped.
+	///
+	/// If `amount` is zero, it is equivalent to using `thaw`.
+	///
+	/// Note that `amount` can be greater than the total balance, if desired.
+	fn set_freeze(
+		asset: Self::AssetId,
+		id: &Self::Id,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult;
+
+	/// Prevent the balance of the account of `who` from being reduced below the given `amount` and
+	/// identify this restriction though the given `id`. Unlike `set_freeze`, this does not
+	/// counteract any pre-existing freezes in place for `who` under the `id`. Also unlike
+	/// `set_freeze`, in the case that `amount` is zero, this is no-op and never fails.
+	///
+	/// Note that more funds can be locked than the total balance, if desired.
+	fn extend_freeze(
+		asset: Self::AssetId,
+		id: &Self::Id,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult;
+
+	/// Remove an existing lock.
+	fn thaw(asset: Self::AssetId, id: &Self::Id, who: &AccountId) -> DispatchResult;
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/hold.rs b/substrate/frame/support/src/traits/tokens/fungibles/hold.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c751a836d1f4335e406ea584f5f74c85798aef68
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/hold.rs
@@ -0,0 +1,470 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! The traits for putting holds within a single fungible token class.
+
+use crate::{
+	ensure,
+	traits::tokens::{
+		DepositConsequence::Success,
+		Fortitude::{self, Force},
+		Precision::{self, BestEffort, Exact},
+		Preservation::{self, Protect},
+		Provenance::Extant,
+		Restriction::{self, Free, OnHold},
+	},
+};
+use scale_info::TypeInfo;
+use sp_arithmetic::{
+	traits::{CheckedAdd, CheckedSub, Zero},
+	ArithmeticError,
+};
+use sp_runtime::{DispatchError, DispatchResult, Saturating, TokenError};
+
+use super::*;
+
+/// Trait for inspecting a fungible asset whose accounts support partitioning and slashing.
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	/// An identifier for a hold. Used for disambiguating different holds so that
+	/// they can be individually replaced or removed and funds from one hold don't accidentally
+	/// become unreserved or slashed for another.
+	type Reason: codec::Encode + TypeInfo + 'static;
+
+	/// Amount of funds on hold (for all hold reasons) of `who`.
+	fn total_balance_on_hold(asset: Self::AssetId, who: &AccountId) -> Self::Balance;
+
+	/// Get the maximum amount that the `total_balance_on_hold` of `who` can be reduced successfully
+	/// based on whether we are willing to force the reduction and potentially go below user-level
+	/// restrictions on the minimum amount of the account. Note: This cannot bring the account into
+	/// an inconsistent state with regards any required existential deposit.
+	///
+	/// Never more than `total_balance_on_hold()`.
+	fn reducible_total_balance_on_hold(
+		asset: Self::AssetId,
+		who: &AccountId,
+		_force: Fortitude,
+	) -> Self::Balance {
+		Self::total_balance_on_hold(asset, who)
+	}
+
+	/// Amount of funds on hold (for the given reason) of `who`.
+	fn balance_on_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+	) -> Self::Balance;
+
+	/// Returns `true` if it's possible to place (additional) funds under a hold of a given
+	/// `reason`. This may fail if the account has exhausted a limited number of concurrent
+	/// holds or if it cannot be made to exist (e.g. there is no provider reference).
+	///
+	/// NOTE: This does not take into account changes which could be made to the account of `who`
+	/// (such as removing a provider reference) after this call is made. Any usage of this should
+	/// therefore ensure the account is already in the appropriate state prior to calling it.
+	fn hold_available(_asset: Self::AssetId, _reason: &Self::Reason, _who: &AccountId) -> bool {
+		true
+	}
+
+	/// Check to see if some `amount` of funds of `who` may be placed on hold with the given
+	/// `reason`. Reasons why this may not be true:
+	///
+	/// - The implementor supports only a limited number of concurrent holds on an account which is
+	///   the possible values of `reason`;
+	/// - The total balance of the account is less than `amount`;
+	/// - Removing `amount` from the total balance would kill the account and remove the only
+	///   provider reference.
+	///
+	/// Note: we pass `Fortitude::Force` as the last argument to `reducible_balance` since we assume
+	/// that if needed the balance can slashed. If we are using a simple non-forcing
+	/// reserve-transfer, then we really ought to check that we are not reducing the funds below the
+	/// freeze-limit (if any).
+	///
+	/// NOTE: This does not take into account changes which could be made to the account of `who`
+	/// (such as removing a provider reference) after this call is made. Any usage of this should
+	/// therefore ensure the account is already in the appropriate state prior to calling it.
+	fn ensure_can_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult {
+		ensure!(Self::hold_available(asset.clone(), reason, who), TokenError::CannotCreateHold);
+		ensure!(
+			amount <= Self::reducible_balance(asset, who, Protect, Force),
+			TokenError::FundsUnavailable
+		);
+		Ok(())
+	}
+
+	/// Check to see if some `amount` of funds of `who` may be placed on hold for the given
+	/// `reason`. Reasons why this may not be true:
+	///
+	/// - The implementor supports only a limited number of concurrent holds on an account which is
+	///   the possible values of `reason`;
+	/// - The main balance of the account is less than `amount`;
+	/// - Removing `amount` from the main balance would kill the account and remove the only
+	///   provider reference.
+	///
+	/// NOTE: This does not take into account changes which could be made to the account of `who`
+	/// (such as removing a provider reference) after this call is made. Any usage of this should
+	/// therefore ensure the account is already in the appropriate state prior to calling it.
+	fn can_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> bool {
+		Self::ensure_can_hold(asset, reason, who, amount).is_ok()
+	}
+}
+
+/// A fungible, holdable token class where the balance on hold can be set arbitrarily.
+///
+/// **WARNING**
+/// Do not use this directly unless you want trouble, since it allows you to alter account balances
+/// without keeping the issuance up to date. It has no safeguards against accidentally creating
+/// token imbalances in your system leading to accidental inflation or deflation. It's really just
+/// for the underlying datatype to implement so the user gets the much safer `Balanced` trait to
+/// use.
+pub trait Unbalanced<AccountId>: Inspect<AccountId> {
+	/// Forcefully set the balance on hold of `who` to `amount`. This is independent of any other
+	/// balances on hold or the main ("free") balance.
+	///
+	/// If this call executes successfully, you can `assert_eq!(Self::balance_on_hold(), amount);`.
+	///
+	/// This function does its best to force the balance change through, but will not break system
+	/// invariants such as any Existential Deposits needed or overflows/underflows.
+	/// If this cannot be done for some reason (e.g. because the account doesn't exist) then an
+	/// `Err` is returned.
+	// Implementation note: This should increment the consumer refs if it moves total on hold from
+	// zero to non-zero and decrement in the opposite direction.
+	//
+	// Since this was not done in the previous logic, this will need either a migration or a
+	// state item which tracks whether the account is on the old logic or new.
+	fn set_balance_on_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult;
+
+	/// Reduce the balance on hold of `who` by `amount`.
+	///
+	/// If `precision` is `Precision::Exact` and it cannot be reduced by that amount for
+	/// some reason, return `Err` and don't reduce it at all. If `precision` is
+	/// `Precision::BestEffort`, then reduce the balance of `who` by the most that is possible, up
+	/// to `amount`.
+	///
+	/// In either case, if `Ok` is returned then the inner is the amount by which is was reduced.
+	fn decrease_balance_on_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance_on_hold(asset.clone(), reason, who);
+		if let BestEffort = precision {
+			amount = amount.min(old_balance);
+		}
+		let new_balance = old_balance.checked_sub(&amount).ok_or(TokenError::FundsUnavailable)?;
+		Self::set_balance_on_hold(asset, reason, who, new_balance)?;
+		Ok(amount)
+	}
+
+	/// Increase the balance on hold of `who` by `amount`.
+	///
+	/// If it cannot be increased by that amount for some reason, return `Err` and don't increase
+	/// it at all. If Ok, return the imbalance.
+	fn increase_balance_on_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance_on_hold(asset.clone(), reason, who);
+		let new_balance = if let BestEffort = precision {
+			old_balance.saturating_add(amount)
+		} else {
+			old_balance.checked_add(&amount).ok_or(ArithmeticError::Overflow)?
+		};
+		let amount = new_balance.saturating_sub(old_balance);
+		if !amount.is_zero() {
+			Self::set_balance_on_hold(asset, reason, who, new_balance)?;
+		}
+		Ok(amount)
+	}
+}
+
+/// Trait for slashing a fungible asset which can be place on hold.
+pub trait Balanced<AccountId>: super::Balanced<AccountId> + Unbalanced<AccountId> {
+	/// Reduce the balance of some funds on hold in an account.
+	///
+	/// The resulting imbalance is the first item of the tuple returned.
+	///
+	/// As much funds that are on hold up to `amount` will be deducted as possible. If this is less
+	/// than `amount`, then a non-zero second item will be returned.
+	fn slash(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> (Credit<AccountId, Self>, Self::Balance) {
+		let decrease =
+			Self::decrease_balance_on_hold(asset.clone(), reason, who, amount, BestEffort)
+				.unwrap_or(Default::default());
+		let credit =
+			Imbalance::<Self::AssetId, Self::Balance, Self::OnDropCredit, Self::OnDropDebt>::new(
+				asset.clone(),
+				decrease,
+			);
+		Self::done_slash(asset, reason, who, decrease);
+		(credit, amount.saturating_sub(decrease))
+	}
+
+	fn done_slash(
+		_asset: Self::AssetId,
+		_reason: &Self::Reason,
+		_who: &AccountId,
+		_amount: Self::Balance,
+	) {
+	}
+}
+
+/// Trait for mutating a fungible asset which can be placed on hold.
+pub trait Mutate<AccountId>:
+	Inspect<AccountId> + super::Unbalanced<AccountId> + Unbalanced<AccountId>
+{
+	/// Hold some funds in an account. If a hold for `reason` is already in place, then this
+	/// will increase it.
+	fn hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> DispatchResult {
+		// NOTE: This doesn't change the total balance of the account so there's no need to
+		// check liquidity.
+
+		Self::ensure_can_hold(asset.clone(), reason, who, amount)?;
+		// Should be infallible now, but we proceed softly anyway.
+		Self::decrease_balance(asset.clone(), who, amount, Exact, Protect, Force)?;
+		Self::increase_balance_on_hold(asset.clone(), reason, who, amount, BestEffort)?;
+		Self::done_hold(asset, reason, who, amount);
+		Ok(())
+	}
+
+	/// Release up to `amount` held funds in an account.
+	///
+	/// The actual amount released is returned with `Ok`.
+	///
+	/// If `precision` is `BestEffort`, then the amount actually unreserved and returned as the
+	/// inner value of `Ok` may be smaller than the `amount` passed.
+	fn release(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		// NOTE: This doesn't change the total balance of the account so there's no need to
+		// check liquidity.
+
+		// We want to make sure we can deposit the amount in advance. If we can't then something is
+		// very wrong.
+		ensure!(
+			Self::can_deposit(asset.clone(), who, amount, Extant) == Success,
+			TokenError::CannotCreate
+		);
+		// Get the amount we can actually take from the hold. This might be less than what we want
+		// if we're only doing a best-effort.
+		let amount = Self::decrease_balance_on_hold(asset.clone(), reason, who, amount, precision)?;
+		// Increase the main balance by what we took. We always do a best-effort here because we
+		// already checked that we can deposit before.
+		let actual = Self::increase_balance(asset.clone(), who, amount, BestEffort)?;
+		Self::done_release(asset, reason, who, actual);
+		Ok(actual)
+	}
+
+	/// Attempt to decrease the balance of `who` which is held for the given `reason` by `amount`.
+	///
+	/// If `precision` is true, then as much as possible is reduced, up to `amount`, and the
+	/// amount of tokens reduced is returned. Otherwise, if the total amount can be reduced, then it
+	/// is and the amount returned, and if not, then nothing changes and `Err` is returned.
+	///
+	/// If `force` is `Force`, then locks/freezes will be ignored. This should only be used when
+	/// conducting slashing or other activity which materially disadvantages the account holder
+	/// since it could provide a means of circumventing freezes.
+	fn burn_held(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		who: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		// We must check total-balance requirements if `!force`.
+		let liquid = Self::reducible_total_balance_on_hold(asset.clone(), who, force);
+		if let BestEffort = precision {
+			amount = amount.min(liquid);
+		} else {
+			ensure!(amount <= liquid, TokenError::Frozen);
+		}
+		let amount = Self::decrease_balance_on_hold(asset.clone(), reason, who, amount, precision)?;
+		Self::set_total_issuance(
+			asset.clone(),
+			Self::total_issuance(asset.clone()).saturating_sub(amount),
+		);
+		Self::done_burn_held(asset, reason, who, amount);
+		Ok(amount)
+	}
+
+	/// Transfer held funds into a destination account.
+	///
+	/// If `mode` is `OnHold`, then the destination account must already exist and the assets
+	/// transferred will still be on hold in the destination account. If not, then the destination
+	/// account need not already exist, but must be creatable.
+	///
+	/// If `precision` is `BestEffort`, then an amount less than `amount` may be transferred without
+	/// error.
+	///
+	/// If `force` is `Force`, then other fund-locking mechanisms may be disregarded. It should be
+	/// left as `Regular` in most circumstances, but when you want the same power as a `slash`, it
+	/// may be `Force`.
+	///
+	/// The actual amount transferred is returned, or `Err` in the case of error and nothing is
+	/// changed.
+	fn transfer_on_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		source: &AccountId,
+		dest: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+		mode: Restriction,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		// We must check total-balance requirements if `!force`.
+		let have = Self::balance_on_hold(asset.clone(), reason, source);
+		let liquid = Self::reducible_total_balance_on_hold(asset.clone(), source, force);
+		if let BestEffort = precision {
+			amount = amount.min(liquid).min(have);
+		} else {
+			ensure!(amount <= liquid, TokenError::Frozen);
+			ensure!(amount <= have, TokenError::FundsUnavailable);
+		}
+
+		// We want to make sure we can deposit the amount in advance. If we can't then something is
+		// very wrong.
+		ensure!(
+			Self::can_deposit(asset.clone(), dest, amount, Extant) == Success,
+			TokenError::CannotCreate
+		);
+		ensure!(
+			mode == Free || Self::hold_available(asset.clone(), reason, dest),
+			TokenError::CannotCreateHold
+		);
+
+		let amount =
+			Self::decrease_balance_on_hold(asset.clone(), reason, source, amount, precision)?;
+		let actual = if mode == OnHold {
+			Self::increase_balance_on_hold(asset.clone(), reason, dest, amount, precision)?
+		} else {
+			Self::increase_balance(asset.clone(), dest, amount, precision)?
+		};
+		Self::done_transfer_on_hold(asset, reason, source, dest, actual);
+		Ok(actual)
+	}
+
+	/// Transfer some `amount` of free balance from `source` to become owned by `dest` but on hold
+	/// for `reason`.
+	/// for `reason`.
+	///
+	/// If `precision` is `BestEffort`, then an amount less than `amount` may be transferred without
+	/// error.
+	///
+	/// `source` must obey the requirements of `keep_alive`.
+	///
+	/// If `force` is `Force`, then other fund-locking mechanisms may be disregarded. It should be
+	/// left as `Regular` in most circumstances, but when you want the same power as a `slash`, it
+	/// may be `Force`.
+	///
+	/// The amount placed on hold is returned or `Err` in the case of error and nothing is changed.
+	///
+	/// WARNING: This may return an error after a partial storage mutation. It should be used only
+	/// inside a transactional storage context and an `Err` result must imply a storage rollback.
+	fn transfer_and_hold(
+		asset: Self::AssetId,
+		reason: &Self::Reason,
+		source: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		expendability: Preservation,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		ensure!(Self::hold_available(asset.clone(), reason, dest), TokenError::CannotCreateHold);
+		ensure!(
+			Self::can_deposit(asset.clone(), dest, amount, Extant) == Success,
+			TokenError::CannotCreate
+		);
+		let actual =
+			Self::decrease_balance(asset.clone(), source, amount, precision, expendability, force)?;
+		Self::increase_balance_on_hold(asset.clone(), reason, dest, actual, precision)?;
+		Self::done_transfer_on_hold(asset, reason, source, dest, actual);
+		Ok(actual)
+	}
+
+	fn done_hold(
+		_asset: Self::AssetId,
+		_reason: &Self::Reason,
+		_who: &AccountId,
+		_amount: Self::Balance,
+	) {
+	}
+	fn done_release(
+		_asset: Self::AssetId,
+		_reason: &Self::Reason,
+		_who: &AccountId,
+		_amount: Self::Balance,
+	) {
+	}
+	fn done_burn_held(
+		_asset: Self::AssetId,
+		_reason: &Self::Reason,
+		_who: &AccountId,
+		_amount: Self::Balance,
+	) {
+	}
+	fn done_transfer_on_hold(
+		_asset: Self::AssetId,
+		_reason: &Self::Reason,
+		_source: &AccountId,
+		_dest: &AccountId,
+		_amount: Self::Balance,
+	) {
+	}
+	fn done_transfer_and_hold(
+		_asset: Self::AssetId,
+		_reason: &Self::Reason,
+		_source: &AccountId,
+		_dest: &AccountId,
+		_transferred: Self::Balance,
+	) {
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/imbalance.rs b/substrate/frame/support/src/traits/tokens/fungibles/imbalance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1668268ea2dcf232a4aaf3f6a7b4df3b67060542
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/imbalance.rs
@@ -0,0 +1,178 @@
+// 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.
+
+//! The imbalance type and its associates, which handles keeps everything adding up properly with
+//! unbalanced operations.
+
+use super::*;
+use crate::traits::{
+	misc::{SameOrOther, TryDrop},
+	tokens::{AssetId, Balance},
+};
+use sp_runtime::{traits::Zero, RuntimeDebug};
+use sp_std::marker::PhantomData;
+
+/// Handler for when an imbalance gets dropped. This could handle either a credit (negative) or
+/// debt (positive) imbalance.
+pub trait HandleImbalanceDrop<AssetId, Balance> {
+	fn handle(asset: AssetId, amount: Balance);
+}
+
+/// An imbalance in the system, representing a divergence of recorded token supply from the sum of
+/// the balances of all accounts. This is `must_use` in order to ensure it gets handled (placing
+/// into an account, settling from an account or altering the supply).
+///
+/// Importantly, it has a special `Drop` impl, and cannot be created outside of this module.
+#[must_use]
+#[derive(RuntimeDebug, Eq, PartialEq)]
+pub struct Imbalance<
+	A: AssetId,
+	B: Balance,
+	OnDrop: HandleImbalanceDrop<A, B>,
+	OppositeOnDrop: HandleImbalanceDrop<A, B>,
+> {
+	asset: A,
+	amount: B,
+	_phantom: PhantomData<(OnDrop, OppositeOnDrop)>,
+}
+
+impl<
+		A: AssetId,
+		B: Balance,
+		OnDrop: HandleImbalanceDrop<A, B>,
+		OppositeOnDrop: HandleImbalanceDrop<A, B>,
+	> Drop for Imbalance<A, B, OnDrop, OppositeOnDrop>
+{
+	fn drop(&mut self) {
+		if !self.amount.is_zero() {
+			OnDrop::handle(self.asset.clone(), self.amount)
+		}
+	}
+}
+
+impl<
+		A: AssetId,
+		B: Balance,
+		OnDrop: HandleImbalanceDrop<A, B>,
+		OppositeOnDrop: HandleImbalanceDrop<A, B>,
+	> TryDrop for Imbalance<A, B, OnDrop, OppositeOnDrop>
+{
+	/// Drop an instance cleanly. Only works if its value represents "no-operation".
+	fn try_drop(self) -> Result<(), Self> {
+		self.drop_zero()
+	}
+}
+
+impl<
+		A: AssetId,
+		B: Balance,
+		OnDrop: HandleImbalanceDrop<A, B>,
+		OppositeOnDrop: HandleImbalanceDrop<A, B>,
+	> Imbalance<A, B, OnDrop, OppositeOnDrop>
+{
+	pub fn zero(asset: A) -> Self {
+		Self { asset, amount: Zero::zero(), _phantom: PhantomData }
+	}
+
+	pub(crate) fn new(asset: A, amount: B) -> Self {
+		Self { asset, amount, _phantom: PhantomData }
+	}
+
+	pub fn drop_zero(self) -> Result<(), Self> {
+		if self.amount.is_zero() {
+			sp_std::mem::forget(self);
+			Ok(())
+		} else {
+			Err(self)
+		}
+	}
+
+	pub fn split(self, amount: B) -> (Self, Self) {
+		let first = self.amount.min(amount);
+		let second = self.amount - first;
+		let asset = self.asset.clone();
+		sp_std::mem::forget(self);
+		(Imbalance::new(asset.clone(), first), Imbalance::new(asset, second))
+	}
+	pub fn merge(mut self, other: Self) -> Result<Self, (Self, Self)> {
+		if self.asset == other.asset {
+			self.amount = self.amount.saturating_add(other.amount);
+			sp_std::mem::forget(other);
+			Ok(self)
+		} else {
+			Err((self, other))
+		}
+	}
+	pub fn subsume(&mut self, other: Self) -> Result<(), Self> {
+		if self.asset == other.asset {
+			self.amount = self.amount.saturating_add(other.amount);
+			sp_std::mem::forget(other);
+			Ok(())
+		} else {
+			Err(other)
+		}
+	}
+	pub fn offset(
+		self,
+		other: Imbalance<A, B, OppositeOnDrop, OnDrop>,
+	) -> Result<
+		SameOrOther<Self, Imbalance<A, B, OppositeOnDrop, OnDrop>>,
+		(Self, Imbalance<A, B, OppositeOnDrop, OnDrop>),
+	> {
+		if self.asset == other.asset {
+			let (a, b) = (self.amount, other.amount);
+			let asset = self.asset.clone();
+			sp_std::mem::forget((self, other));
+
+			if a == b {
+				Ok(SameOrOther::None)
+			} else if a > b {
+				Ok(SameOrOther::Same(Imbalance::new(asset, a - b)))
+			} else {
+				Ok(SameOrOther::Other(Imbalance::<A, B, OppositeOnDrop, OnDrop>::new(asset, b - a)))
+			}
+		} else {
+			Err((self, other))
+		}
+	}
+	pub fn peek(&self) -> B {
+		self.amount
+	}
+
+	pub fn asset(&self) -> A {
+		self.asset.clone()
+	}
+}
+
+/// Imbalance implying that the total_issuance value is less than the sum of all account balances.
+pub type Debt<AccountId, B> = Imbalance<
+	<B as Inspect<AccountId>>::AssetId,
+	<B as Inspect<AccountId>>::Balance,
+	// This will generally be implemented by increasing the total_issuance value.
+	<B as Balanced<AccountId>>::OnDropDebt,
+	<B as Balanced<AccountId>>::OnDropCredit,
+>;
+
+/// Imbalance implying that the total_issuance value is greater than the sum of all account
+/// balances.
+pub type Credit<AccountId, B> = Imbalance<
+	<B as Inspect<AccountId>>::AssetId,
+	<B as Inspect<AccountId>>::Balance,
+	// This will generally be implemented by decreasing the total_issuance value.
+	<B as Balanced<AccountId>>::OnDropCredit,
+	<B as Balanced<AccountId>>::OnDropDebt,
+>;
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/lifetime.rs b/substrate/frame/support/src/traits/tokens/fungibles/lifetime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9e2c306f6f38acae211004a5b9baa63ed34b6a4d
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/lifetime.rs
@@ -0,0 +1,84 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! Traits for creating and destroying assets.
+
+use sp_runtime::{DispatchError, DispatchResult};
+
+use super::Inspect;
+
+/// Trait for providing the ability to create new fungible assets.
+pub trait Create<AccountId>: Inspect<AccountId> {
+	/// Create a new fungible asset.
+	fn create(
+		id: Self::AssetId,
+		admin: AccountId,
+		is_sufficient: bool,
+		min_balance: Self::Balance,
+	) -> DispatchResult;
+}
+
+/// Trait for providing the ability to destroy existing fungible assets.
+pub trait Destroy<AccountId>: Inspect<AccountId> {
+	/// Start the destruction an existing fungible asset.
+	/// * `id`: The `AssetId` to be destroyed. successfully.
+	/// * `maybe_check_owner`: An optional account id that can be used to authorize the destroy
+	///   command. If not provided, no authorization checks will be performed before destroying
+	///   asset.
+	fn start_destroy(id: Self::AssetId, maybe_check_owner: Option<AccountId>) -> DispatchResult;
+
+	/// Destroy all accounts associated with a given asset.
+	/// `destroy_accounts` should only be called after `start_destroy` has been called, and the
+	/// asset is in a `Destroying` state
+	///
+	/// * `id`: The identifier of the asset to be destroyed. This must identify an existing asset.
+	/// * `max_items`: The maximum number of accounts to be destroyed for a given call of the
+	///   function. This value should be small enough to allow the operation fit into a logical
+	///   block.
+	///
+	///	Response:
+	/// * u32: Total number of approvals which were actually destroyed
+	///
+	/// Due to weight restrictions, this function may need to be called multiple
+	/// times to fully destroy all approvals. It will destroy `max_items` approvals at a
+	/// time.
+	fn destroy_accounts(id: Self::AssetId, max_items: u32) -> Result<u32, DispatchError>;
+	/// Destroy all approvals associated with a given asset up to the `max_items`
+	/// `destroy_approvals` should only be called after `start_destroy` has been called, and the
+	/// asset is in a `Destroying` state
+	///
+	/// * `id`: The identifier of the asset to be destroyed. This must identify an existing asset.
+	/// * `max_items`: The maximum number of accounts to be destroyed for a given call of the
+	///   function. This value should be small enough to allow the operation fit into a logical
+	///   block.
+	///
+	///	Response:
+	/// * u32: Total number of approvals which were actually destroyed
+	///
+	/// Due to weight restrictions, this function may need to be called multiple
+	/// times to fully destroy all approvals. It will destroy `max_items` approvals at a
+	/// time.
+	fn destroy_approvals(id: Self::AssetId, max_items: u32) -> Result<u32, DispatchError>;
+
+	/// Complete destroying asset and unreserve currency.
+	/// `finish_destroy` should only be called after `start_destroy` has been called, and the
+	/// asset is in a `Destroying` state. All accounts or approvals should be destroyed before
+	/// hand.
+	///
+	/// * `id`: The identifier of the asset to be destroyed. This must identify an existing asset.
+	fn finish_destroy(id: Self::AssetId) -> DispatchResult;
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/metadata.rs b/substrate/frame/support/src/traits/tokens/fungibles/metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ab310119e58467da21dc9f68c84ad8dd173e8f43
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/metadata.rs
@@ -0,0 +1,46 @@
+// 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.
+
+//! Inspect and Mutate traits for Asset metadata
+
+use crate::dispatch::DispatchResult;
+use sp_std::vec::Vec;
+
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	// Get name for an AssetId.
+	fn name(asset: Self::AssetId) -> Vec<u8>;
+	// Get symbol for an AssetId.
+	fn symbol(asset: Self::AssetId) -> Vec<u8>;
+	// Get decimals for an AssetId.
+	fn decimals(asset: Self::AssetId) -> u8;
+}
+
+pub trait Mutate<AccountId>: Inspect<AccountId> {
+	// Set name, symbol and decimals for a given assetId.
+	fn set(
+		asset: Self::AssetId,
+		from: &AccountId,
+		name: Vec<u8>,
+		symbol: Vec<u8>,
+		decimals: u8,
+	) -> DispatchResult;
+}
+
+pub trait MetadataDeposit<DepositBalance> {
+	// Returns the required deposit amount for a given metadata.
+	fn calc_metadata_deposit(name: &[u8], symbol: &[u8]) -> DepositBalance;
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/mod.rs b/substrate/frame/support/src/traits/tokens/fungibles/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..697eff39ff7489c964328a23317871f01a137c83
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/mod.rs
@@ -0,0 +1,40 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! The traits for sets of fungible tokens and any associated types.
+
+pub mod approvals;
+mod enumerable;
+pub mod freeze;
+pub mod hold;
+mod imbalance;
+mod lifetime;
+pub mod metadata;
+mod regular;
+pub mod roles;
+
+pub use enumerable::Inspect as InspectEnumerable;
+pub use freeze::{Inspect as InspectFreeze, Mutate as MutateFreeze};
+pub use hold::{
+	Balanced as BalancedHold, Inspect as InspectHold, Mutate as MutateHold,
+	Unbalanced as UnbalancedHold,
+};
+pub use imbalance::{Credit, Debt, HandleImbalanceDrop, Imbalance};
+pub use lifetime::{Create, Destroy};
+pub use regular::{
+	Balanced, DecreaseIssuance, Dust, IncreaseIssuance, Inspect, Mutate, Unbalanced,
+};
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/regular.rs b/substrate/frame/support/src/traits/tokens/fungibles/regular.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b6cea15284d396e3f3432581671f75124eb92b8a
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/regular.rs
@@ -0,0 +1,586 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+//! `Inspect` and `Mutate` traits for working with regular balances.
+
+use sp_std::marker::PhantomData;
+
+use crate::{
+	dispatch::DispatchError,
+	ensure,
+	traits::{
+		tokens::{
+			misc::{
+				Balance, DepositConsequence,
+				Fortitude::{self, Force, Polite},
+				Precision::{self, BestEffort, Exact},
+				Preservation::{self, Expendable},
+				Provenance::{self, Extant},
+				WithdrawConsequence,
+			},
+			AssetId,
+		},
+		SameOrOther, TryDrop,
+	},
+};
+use sp_arithmetic::traits::{CheckedAdd, CheckedSub, One};
+use sp_runtime::{traits::Saturating, ArithmeticError, TokenError};
+
+use super::{Credit, Debt, HandleImbalanceDrop, Imbalance};
+
+/// Trait for providing balance-inspection access to a set of named fungible assets.
+pub trait Inspect<AccountId>: Sized {
+	/// Means of identifying one asset class from another.
+	type AssetId: AssetId;
+
+	/// Scalar type for representing balance of an account.
+	type Balance: Balance;
+
+	/// The total amount of issuance in the system.
+	fn total_issuance(asset: Self::AssetId) -> Self::Balance;
+
+	/// The total amount of issuance in the system excluding those which are controlled by the
+	/// system.
+	fn active_issuance(asset: Self::AssetId) -> Self::Balance {
+		Self::total_issuance(asset)
+	}
+
+	/// The minimum balance any single account may have.
+	fn minimum_balance(asset: Self::AssetId) -> Self::Balance;
+
+	/// Get the total amount of funds whose ultimate beneficial ownership can be determined as
+	/// `who`.
+	///
+	/// This may include funds which are wholly inaccessible to `who`, either temporarily or even
+	/// indefinitely.
+	///
+	/// For the amount of the balance which is currently free to be removed from the account without
+	/// error, use `reducible_balance`.
+	///
+	/// For the amount of the balance which may eventually be free to be removed from the account,
+	/// use `balance()`.
+	fn total_balance(asset: Self::AssetId, who: &AccountId) -> Self::Balance;
+
+	/// Get the balance of `who` which does not include funds which are exclusively allocated to
+	/// subsystems of the chain ("on hold" or "reserved").
+	///
+	/// In general this isn't especially useful outside of tests, and for practical purposes, you'll
+	/// want to use `reducible_balance()`.
+	fn balance(asset: Self::AssetId, who: &AccountId) -> Self::Balance;
+
+	/// Get the maximum amount that `who` can withdraw/transfer successfully based on whether the
+	/// account should be kept alive (`preservation`) or whether we are willing to force the
+	/// transfer and potentially go below user-level restrictions on the minimum amount of the
+	/// account.
+	///
+	/// Always less than `free_balance()`.
+	fn reducible_balance(
+		asset: Self::AssetId,
+		who: &AccountId,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Self::Balance;
+
+	/// Returns `true` if the `asset` balance of `who` may be increased by `amount`.
+	///
+	/// - `asset`: The asset that should be deposited.
+	/// - `who`: The account of which the balance should be increased by `amount`.
+	/// - `amount`: How much should the balance be increased?
+	/// - `mint`: Will `amount` be minted to deposit it into `account`?
+	fn can_deposit(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+		provenance: Provenance,
+	) -> DepositConsequence;
+
+	/// Returns `Failed` if the `asset` balance of `who` may not be decreased by `amount`, otherwise
+	/// the consequence.
+	fn can_withdraw(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> WithdrawConsequence<Self::Balance>;
+
+	/// Returns `true` if an `asset` exists.
+	fn asset_exists(asset: Self::AssetId) -> bool;
+}
+
+/// Special dust type which can be type-safely converted into a `Credit`.
+#[must_use]
+pub struct Dust<A, T: Unbalanced<A>>(pub T::AssetId, pub T::Balance);
+
+impl<A, T: Balanced<A>> Dust<A, T> {
+	/// Convert `Dust` into an instance of `Credit`.
+	pub fn into_credit(self) -> Credit<A, T> {
+		Credit::<A, T>::new(self.0, self.1)
+	}
+}
+
+/// A fungible token class where the balance can be set arbitrarily.
+///
+/// **WARNING**
+/// Do not use this directly unless you want trouble, since it allows you to alter account balances
+/// without keeping the issuance up to date. It has no safeguards against accidentally creating
+/// token imbalances in your system leading to accidental inflation or deflation. It's really just
+/// for the underlying datatype to implement so the user gets the much safer `Balanced` trait to
+/// use.
+pub trait Unbalanced<AccountId>: Inspect<AccountId> {
+	/// Create some dust and handle it with `Self::handle_dust`. This is an unbalanced operation
+	/// and it must only be used when an account is modified in a raw fashion, outside of the entire
+	/// fungibles API. The `amount` is capped at `Self::minimum_balance() - 1`.
+	///
+	/// This should not be reimplemented.
+	fn handle_raw_dust(asset: Self::AssetId, amount: Self::Balance) {
+		Self::handle_dust(Dust(
+			asset.clone(),
+			amount.min(Self::minimum_balance(asset).saturating_sub(One::one())),
+		))
+	}
+
+	/// Do something with the dust which has been destroyed from the system. `Dust` can be converted
+	/// into a `Credit` with the `Balanced` trait impl.
+	fn handle_dust(dust: Dust<AccountId, Self>);
+
+	/// Forcefully set the balance of `who` to `amount`.
+	///
+	/// If this call executes successfully, you can `assert_eq!(Self::balance(), amount);`.
+	///
+	/// For implementations which include one or more balances on hold, then these are *not*
+	/// included in the `amount`.
+	///
+	/// This function does its best to force the balance change through, but will not break system
+	/// invariants such as any Existential Deposits needed or overflows/underflows.
+	/// If this cannot be done for some reason (e.g. because the account cannot be created, deleted
+	/// or would overflow) then an `Err` is returned.
+	fn write_balance(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> Result<Option<Self::Balance>, DispatchError>;
+
+	/// Set the total issuance to `amount`.
+	fn set_total_issuance(asset: Self::AssetId, amount: Self::Balance);
+
+	/// Reduce the balance of `who` by `amount`.
+	///
+	/// If `precision` is `Exact` and it cannot be reduced by that amount for
+	/// some reason, return `Err` and don't reduce it at all. If `precision` is `BestEffort`, then
+	/// reduce the balance of `who` by the most that is possible, up to `amount`.
+	///
+	/// In either case, if `Ok` is returned then the inner is the amount by which is was reduced.
+	/// Minimum balance will be respected and thus the returned amount may be up to
+	/// `Self::minimum_balance() - 1` greater than `amount` in the case that the reduction caused
+	/// the account to be deleted.
+	fn decrease_balance(
+		asset: Self::AssetId,
+		who: &AccountId,
+		mut amount: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance(asset.clone(), who);
+		let free = Self::reducible_balance(asset.clone(), who, preservation, force);
+		if let BestEffort = precision {
+			amount = amount.min(free);
+		}
+		let new_balance = old_balance.checked_sub(&amount).ok_or(TokenError::FundsUnavailable)?;
+		if let Some(dust) = Self::write_balance(asset.clone(), who, new_balance)? {
+			Self::handle_dust(Dust(asset, dust));
+		}
+		Ok(old_balance.saturating_sub(new_balance))
+	}
+
+	/// Increase the balance of `who` by `amount`.
+	///
+	/// If it cannot be increased by that amount for some reason, return `Err` and don't increase
+	/// it at all. If Ok, return the imbalance.
+	/// Minimum balance will be respected and an error will be returned if
+	/// `amount < Self::minimum_balance()` when the account of `who` is zero.
+	fn increase_balance(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+	) -> Result<Self::Balance, DispatchError> {
+		let old_balance = Self::balance(asset.clone(), who);
+		let new_balance = if let BestEffort = precision {
+			old_balance.saturating_add(amount)
+		} else {
+			old_balance.checked_add(&amount).ok_or(ArithmeticError::Overflow)?
+		};
+		if new_balance < Self::minimum_balance(asset.clone()) {
+			// Attempt to increase from 0 to below minimum -> stays at zero.
+			if let BestEffort = precision {
+				Ok(Self::Balance::default())
+			} else {
+				Err(TokenError::BelowMinimum.into())
+			}
+		} else {
+			if new_balance == old_balance {
+				Ok(Self::Balance::default())
+			} else {
+				if let Some(dust) = Self::write_balance(asset.clone(), who, new_balance)? {
+					Self::handle_dust(Dust(asset, dust));
+				}
+				Ok(new_balance.saturating_sub(old_balance))
+			}
+		}
+	}
+
+	/// Reduce the active issuance by some amount.
+	fn deactivate(_asset: Self::AssetId, _: Self::Balance) {}
+
+	/// Increase the active issuance by some amount, up to the outstanding amount reduced.
+	fn reactivate(_asset: Self::AssetId, _: Self::Balance) {}
+}
+
+/// Trait for providing a basic fungible asset.
+pub trait Mutate<AccountId>: Inspect<AccountId> + Unbalanced<AccountId> {
+	/// Increase the balance of `who` by exactly `amount`, minting new tokens. If that isn't
+	/// possible then an `Err` is returned and nothing is changed.
+	fn mint_into(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> Result<Self::Balance, DispatchError> {
+		Self::total_issuance(asset.clone())
+			.checked_add(&amount)
+			.ok_or(ArithmeticError::Overflow)?;
+		let actual = Self::increase_balance(asset.clone(), who, amount, Exact)?;
+		Self::set_total_issuance(
+			asset.clone(),
+			Self::total_issuance(asset.clone()).saturating_add(actual),
+		);
+		Self::done_mint_into(asset, who, amount);
+		Ok(actual)
+	}
+
+	/// Decrease the balance of `who` by at least `amount`, possibly slightly more in the case of
+	/// minimum-balance requirements, burning the tokens. If that isn't possible then an `Err` is
+	/// returned and nothing is changed. If successful, the amount of tokens reduced is returned.
+	fn burn_from(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+		precision: Precision,
+		force: Fortitude,
+	) -> Result<Self::Balance, DispatchError> {
+		let actual = Self::reducible_balance(asset.clone(), who, Expendable, force).min(amount);
+		ensure!(actual == amount || precision == BestEffort, TokenError::FundsUnavailable);
+		Self::total_issuance(asset.clone())
+			.checked_sub(&actual)
+			.ok_or(ArithmeticError::Overflow)?;
+		let actual =
+			Self::decrease_balance(asset.clone(), who, actual, BestEffort, Expendable, force)?;
+		Self::set_total_issuance(
+			asset.clone(),
+			Self::total_issuance(asset.clone()).saturating_sub(actual),
+		);
+		Self::done_burn_from(asset, who, actual);
+		Ok(actual)
+	}
+
+	/// Attempt to decrease the `asset` balance of `who` by `amount`.
+	///
+	/// Equivalent to `burn_from`, except with an expectation that within the bounds of some
+	/// universal issuance, the total assets `suspend`ed and `resume`d will be equivalent. The
+	/// implementation may be configured such that the total assets suspended may never be less than
+	/// the total assets resumed (which is the invariant for an issuing system), or the reverse
+	/// (which the invariant in a non-issuing system).
+	///
+	/// Because of this expectation, any metadata associated with the asset is expected to survive
+	/// the suspect-resume cycle.
+	fn shelve(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> Result<Self::Balance, DispatchError> {
+		let actual = Self::reducible_balance(asset.clone(), who, Expendable, Polite).min(amount);
+		ensure!(actual == amount, TokenError::FundsUnavailable);
+		Self::total_issuance(asset.clone())
+			.checked_sub(&actual)
+			.ok_or(ArithmeticError::Overflow)?;
+		let actual =
+			Self::decrease_balance(asset.clone(), who, actual, BestEffort, Expendable, Polite)?;
+		Self::set_total_issuance(
+			asset.clone(),
+			Self::total_issuance(asset.clone()).saturating_sub(actual),
+		);
+		Self::done_shelve(asset, who, actual);
+		Ok(actual)
+	}
+
+	/// Attempt to increase the `asset` balance of `who` by `amount`.
+	///
+	/// Equivalent to `mint_into`, except with an expectation that within the bounds of some
+	/// universal issuance, the total assets `suspend`ed and `resume`d will be equivalent. The
+	/// implementation may be configured such that the total assets suspended may never be less than
+	/// the total assets resumed (which is the invariant for an issuing system), or the reverse
+	/// (which the invariant in a non-issuing system).
+	///
+	/// Because of this expectation, any metadata associated with the asset is expected to survive
+	/// the suspect-resume cycle.
+	fn restore(
+		asset: Self::AssetId,
+		who: &AccountId,
+		amount: Self::Balance,
+	) -> Result<Self::Balance, DispatchError> {
+		Self::total_issuance(asset.clone())
+			.checked_add(&amount)
+			.ok_or(ArithmeticError::Overflow)?;
+		let actual = Self::increase_balance(asset.clone(), who, amount, Exact)?;
+		Self::set_total_issuance(
+			asset.clone(),
+			Self::total_issuance(asset.clone()).saturating_add(actual),
+		);
+		Self::done_restore(asset, who, amount);
+		Ok(actual)
+	}
+
+	/// Transfer funds from one account into another.
+	fn transfer(
+		asset: Self::AssetId,
+		source: &AccountId,
+		dest: &AccountId,
+		amount: Self::Balance,
+		preservation: Preservation,
+	) -> Result<Self::Balance, DispatchError> {
+		let _extra = Self::can_withdraw(asset.clone(), source, amount)
+			.into_result(preservation != Expendable)?;
+		Self::can_deposit(asset.clone(), dest, amount, Extant).into_result()?;
+		Self::decrease_balance(asset.clone(), source, amount, BestEffort, preservation, Polite)?;
+		// This should never fail as we checked `can_deposit` earlier. But we do a best-effort
+		// anyway.
+		let _ = Self::increase_balance(asset.clone(), dest, amount, BestEffort);
+		Self::done_transfer(asset, source, dest, amount);
+		Ok(amount)
+	}
+
+	/// Simple infallible function to force an account to have a particular balance, good for use
+	/// in tests and benchmarks but not recommended for production code owing to the lack of
+	/// error reporting.
+	///
+	/// Returns the new balance.
+	fn set_balance(asset: Self::AssetId, who: &AccountId, amount: Self::Balance) -> Self::Balance {
+		let b = Self::balance(asset.clone(), who);
+		if b > amount {
+			Self::burn_from(asset, who, b - amount, BestEffort, Force).map(|d| b.saturating_sub(d))
+		} else {
+			Self::mint_into(asset, who, amount - b).map(|d| b.saturating_add(d))
+		}
+		.unwrap_or(b)
+	}
+	fn done_mint_into(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_burn_from(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_shelve(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_restore(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_transfer(
+		_asset: Self::AssetId,
+		_source: &AccountId,
+		_dest: &AccountId,
+		_amount: Self::Balance,
+	) {
+	}
+}
+
+/// Simple handler for an imbalance drop which increases the total issuance of the system by the
+/// imbalance amount. Used for leftover debt.
+pub struct IncreaseIssuance<AccountId, U>(PhantomData<(AccountId, U)>);
+impl<AccountId, U: Unbalanced<AccountId>> HandleImbalanceDrop<U::AssetId, U::Balance>
+	for IncreaseIssuance<AccountId, U>
+{
+	fn handle(asset: U::AssetId, amount: U::Balance) {
+		U::set_total_issuance(asset.clone(), U::total_issuance(asset).saturating_add(amount))
+	}
+}
+
+/// Simple handler for an imbalance drop which decreases the total issuance of the system by the
+/// imbalance amount. Used for leftover credit.
+pub struct DecreaseIssuance<AccountId, U>(PhantomData<(AccountId, U)>);
+impl<AccountId, U: Unbalanced<AccountId>> HandleImbalanceDrop<U::AssetId, U::Balance>
+	for DecreaseIssuance<AccountId, U>
+{
+	fn handle(asset: U::AssetId, amount: U::Balance) {
+		U::set_total_issuance(asset.clone(), U::total_issuance(asset).saturating_sub(amount))
+	}
+}
+
+/// A fungible token class where any creation and deletion of tokens is semi-explicit and where the
+/// total supply is maintained automatically.
+///
+/// This is auto-implemented when a token class has `Unbalanced` implemented.
+pub trait Balanced<AccountId>: Inspect<AccountId> + Unbalanced<AccountId> {
+	/// The type for managing what happens when an instance of `Debt` is dropped without being used.
+	type OnDropDebt: HandleImbalanceDrop<Self::AssetId, Self::Balance>;
+	/// The type for managing what happens when an instance of `Credit` is dropped without being
+	/// used.
+	type OnDropCredit: HandleImbalanceDrop<Self::AssetId, Self::Balance>;
+
+	/// Reduce the total issuance by `amount` and return the according imbalance. The imbalance will
+	/// typically be used to reduce an account by the same amount with e.g. `settle`.
+	///
+	/// This is infallible, but doesn't guarantee that the entire `amount` is burnt, for example
+	/// in the case of underflow.
+	fn rescind(asset: Self::AssetId, amount: Self::Balance) -> Debt<AccountId, Self> {
+		let old = Self::total_issuance(asset.clone());
+		let new = old.saturating_sub(amount);
+		Self::set_total_issuance(asset.clone(), new);
+		let delta = old - new;
+		Self::done_rescind(asset.clone(), delta);
+		Imbalance::<Self::AssetId, Self::Balance, Self::OnDropDebt, Self::OnDropCredit>::new(
+			asset, delta,
+		)
+	}
+
+	/// Increase the total issuance by `amount` and return the according imbalance. The imbalance
+	/// will typically be used to increase an account by the same amount with e.g.
+	/// `resolve_into_existing` or `resolve_creating`.
+	///
+	/// This is infallible, but doesn't guarantee that the entire `amount` is issued, for example
+	/// in the case of overflow.
+	fn issue(asset: Self::AssetId, amount: Self::Balance) -> Credit<AccountId, Self> {
+		let old = Self::total_issuance(asset.clone());
+		let new = old.saturating_add(amount);
+		Self::set_total_issuance(asset.clone(), new);
+		let delta = new - old;
+		Self::done_issue(asset.clone(), delta);
+		Imbalance::<Self::AssetId, Self::Balance, Self::OnDropCredit, Self::OnDropDebt>::new(
+			asset, delta,
+		)
+	}
+
+	/// Produce a pair of imbalances that cancel each other out exactly.
+	///
+	/// This is just the same as burning and issuing the same amount and has no effect on the
+	/// total issuance.
+	fn pair(
+		asset: Self::AssetId,
+		amount: Self::Balance,
+	) -> (Debt<AccountId, Self>, Credit<AccountId, Self>) {
+		(Self::rescind(asset.clone(), amount), Self::issue(asset, amount))
+	}
+
+	/// Mints `value` into the account of `who`, creating it as needed.
+	///
+	/// If `precision` is `BestEffort` and `value` in full could not be minted (e.g. due to
+	/// overflow), then the maximum is minted, up to `value`. If `precision` is `Exact`, then
+	/// exactly `value` must be minted into the account of `who` or the operation will fail with an
+	/// `Err` and nothing will change.
+	///
+	/// If the operation is successful, this will return `Ok` with a `Debt` of the total value
+	/// added to the account.
+	fn deposit(
+		asset: Self::AssetId,
+		who: &AccountId,
+		value: Self::Balance,
+		precision: Precision,
+	) -> Result<Debt<AccountId, Self>, DispatchError> {
+		let increase = Self::increase_balance(asset.clone(), who, value, precision)?;
+		Self::done_deposit(asset.clone(), who, increase);
+		Ok(Imbalance::<Self::AssetId, Self::Balance, Self::OnDropDebt, Self::OnDropCredit>::new(
+			asset, increase,
+		))
+	}
+
+	/// Removes `value` balance from `who` account if possible.
+	///
+	/// If `precision` is `BestEffort` and `value` in full could not be removed (e.g. due to
+	/// underflow), then the maximum is removed, up to `value`. If `precision` is `Exact`, then
+	/// exactly `value` must be removed from the account of `who` or the operation will fail with an
+	/// `Err` and nothing will change.
+	///
+	/// If the removal is needed but not possible, then it returns `Err` and nothing is changed.
+	/// If the account needed to be deleted, then slightly more than `value` may be removed from the
+	/// account owning since up to (but not including) minimum balance may also need to be removed.
+	///
+	/// If the operation is successful, this will return `Ok` with a `Credit` of the total value
+	/// removed from the account.
+	fn withdraw(
+		asset: Self::AssetId,
+		who: &AccountId,
+		value: Self::Balance,
+		precision: Precision,
+		preservation: Preservation,
+		force: Fortitude,
+	) -> Result<Credit<AccountId, Self>, DispatchError> {
+		let decrease =
+			Self::decrease_balance(asset.clone(), who, value, precision, preservation, force)?;
+		Self::done_withdraw(asset.clone(), who, decrease);
+		Ok(Imbalance::<Self::AssetId, Self::Balance, Self::OnDropCredit, Self::OnDropDebt>::new(
+			asset, decrease,
+		))
+	}
+
+	/// The balance of `who` is increased in order to counter `credit`. If the whole of `credit`
+	/// cannot be countered, then nothing is changed and the original `credit` is returned in an
+	/// `Err`.
+	///
+	/// Please note: If `credit.peek()` is less than `Self::minimum_balance()`, then `who` must
+	/// already exist for this to succeed.
+	fn resolve(
+		who: &AccountId,
+		credit: Credit<AccountId, Self>,
+	) -> Result<(), Credit<AccountId, Self>> {
+		let v = credit.peek();
+		let debt = match Self::deposit(credit.asset(), who, v, Exact) {
+			Err(_) => return Err(credit),
+			Ok(d) => d,
+		};
+		if let Ok(result) = credit.offset(debt) {
+			let result = result.try_drop();
+			debug_assert!(result.is_ok(), "ok deposit return must be equal to credit value; qed");
+		} else {
+			debug_assert!(false, "debt.asset is credit.asset; qed");
+		}
+		Ok(())
+	}
+
+	/// The balance of `who` is decreased in order to counter `debt`. If the whole of `debt`
+	/// cannot be countered, then nothing is changed and the original `debt` is returned in an
+	/// `Err`.
+	fn settle(
+		who: &AccountId,
+		debt: Debt<AccountId, Self>,
+		preservation: Preservation,
+	) -> Result<Credit<AccountId, Self>, Debt<AccountId, Self>> {
+		let amount = debt.peek();
+		let asset = debt.asset();
+		let credit = match Self::withdraw(asset.clone(), who, amount, Exact, preservation, Polite) {
+			Err(_) => return Err(debt),
+			Ok(d) => d,
+		};
+		match credit.offset(debt) {
+			Ok(SameOrOther::None) => Ok(Credit::<AccountId, Self>::zero(asset)),
+			Ok(SameOrOther::Same(dust)) => Ok(dust),
+			Ok(SameOrOther::Other(rest)) => {
+				debug_assert!(false, "ok withdraw return must be at least debt value; qed");
+				Err(rest)
+			},
+			Err(_) => {
+				debug_assert!(false, "debt.asset is credit.asset; qed");
+				Ok(Credit::<AccountId, Self>::zero(asset))
+			},
+		}
+	}
+
+	fn done_rescind(_asset: Self::AssetId, _amount: Self::Balance) {}
+	fn done_issue(_asset: Self::AssetId, _amount: Self::Balance) {}
+	fn done_deposit(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
+	fn done_withdraw(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
+}
diff --git a/substrate/frame/support/src/traits/tokens/fungibles/roles.rs b/substrate/frame/support/src/traits/tokens/fungibles/roles.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5cd1228afbce72542aae333759968d5ddee6fac3
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/fungibles/roles.rs
@@ -0,0 +1,29 @@
+// 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.
+
+//! Inspect traits for Asset roles
+
+pub trait Inspect<AccountId>: super::Inspect<AccountId> {
+	// Get owner for an AssetId.
+	fn owner(asset: Self::AssetId) -> Option<AccountId>;
+	// Get issuer for an AssetId.
+	fn issuer(asset: Self::AssetId) -> Option<AccountId>;
+	// Get admin for an AssetId.
+	fn admin(asset: Self::AssetId) -> Option<AccountId>;
+	// Get freezer for an AssetId.
+	fn freezer(asset: Self::AssetId) -> Option<AccountId>;
+}
diff --git a/substrate/frame/support/src/traits/tokens/imbalance.rs b/substrate/frame/support/src/traits/tokens/imbalance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..403321725042c6899c16d90f1ba1652965a336cb
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/imbalance.rs
@@ -0,0 +1,231 @@
+// 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.
+
+//! The imbalance trait type and its associates, which handles keeps everything adding up properly
+//! with unbalanced operations.
+
+use crate::traits::misc::{SameOrOther, TryDrop};
+use sp_runtime::traits::Saturating;
+use sp_std::ops::Div;
+
+mod on_unbalanced;
+mod signed_imbalance;
+mod split_two_ways;
+pub use on_unbalanced::OnUnbalanced;
+pub use signed_imbalance::SignedImbalance;
+pub use split_two_ways::SplitTwoWays;
+
+/// A trait for a not-quite Linear Type that tracks an imbalance.
+///
+/// Functions that alter account balances return an object of this trait to
+/// express how much account balances have been altered in aggregate. If
+/// dropped, the currency system will take some default steps to deal with
+/// the imbalance (`balances` module simply reduces or increases its
+/// total issuance). Your module should generally handle it in some way,
+/// good practice is to do so in a configurable manner using an
+/// `OnUnbalanced` type for each situation in which your module needs to
+/// handle an imbalance.
+///
+/// Imbalances can either be Positive (funds were added somewhere without
+/// being subtracted elsewhere - e.g. a reward) or Negative (funds deducted
+/// somewhere without an equal and opposite addition - e.g. a slash or
+/// system fee payment).
+///
+/// Since they are unsigned, the actual type is always Positive or Negative.
+/// The trait makes no distinction except to define the `Opposite` type.
+///
+/// New instances of zero value can be created (`zero`) and destroyed
+/// (`drop_zero`).
+///
+/// Existing instances can be `split` and merged either consuming `self` with
+/// `merge` or mutating `self` with `subsume`. If the target is an `Option`,
+/// then `maybe_merge` and `maybe_subsume` might work better. Instances can
+/// also be `offset` with an `Opposite` that is less than or equal to in value.
+///
+/// You can always retrieve the raw balance value using `peek`.
+#[must_use]
+pub trait Imbalance<Balance>: Sized + TryDrop + Default {
+	/// The oppositely imbalanced type. They come in pairs.
+	type Opposite: Imbalance<Balance>;
+
+	/// The zero imbalance. Can be destroyed with `drop_zero`.
+	fn zero() -> Self;
+
+	/// Drop an instance cleanly. Only works if its `self.value()` is zero.
+	fn drop_zero(self) -> Result<(), Self>;
+
+	/// Consume `self` and return two independent instances; the first
+	/// is guaranteed to be at most `amount` and the second will be the remainder.
+	fn split(self, amount: Balance) -> (Self, Self);
+
+	/// Consume `self` and return two independent instances; the amounts returned will be in
+	/// approximately the same ratio as `first`:`second`.
+	///
+	/// NOTE: This requires up to `first + second` room for a multiply, and `first + second` should
+	/// fit into a `u32`. Overflow will safely saturate in both cases.
+	fn ration(self, first: u32, second: u32) -> (Self, Self)
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+		let total: u32 = first.saturating_add(second);
+		if total == 0 {
+			return (Self::zero(), Self::zero())
+		}
+		let amount1 = self.peek().saturating_mul(first.into()) / total.into();
+		self.split(amount1)
+	}
+
+	/// Consume self and add its two components, defined by the first component's balance,
+	/// element-wise to two pre-existing Imbalances.
+	///
+	/// A convenient replacement for `split` and `merge`.
+	fn split_merge(self, amount: Balance, others: (Self, Self)) -> (Self, Self) {
+		let (a, b) = self.split(amount);
+		(a.merge(others.0), b.merge(others.1))
+	}
+
+	/// Consume self and add its two components, defined by the ratio `first`:`second`,
+	/// element-wise to two pre-existing Imbalances.
+	///
+	/// A convenient replacement for `split` and `merge`.
+	fn ration_merge(self, first: u32, second: u32, others: (Self, Self)) -> (Self, Self)
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+		let (a, b) = self.ration(first, second);
+		(a.merge(others.0), b.merge(others.1))
+	}
+
+	/// Consume self and add its two components, defined by the first component's balance,
+	/// element-wise into two pre-existing Imbalance refs.
+	///
+	/// A convenient replacement for `split` and `subsume`.
+	fn split_merge_into(self, amount: Balance, others: &mut (Self, Self)) {
+		let (a, b) = self.split(amount);
+		others.0.subsume(a);
+		others.1.subsume(b);
+	}
+
+	/// Consume self and add its two components, defined by the ratio `first`:`second`,
+	/// element-wise to two pre-existing Imbalances.
+	///
+	/// A convenient replacement for `split` and `merge`.
+	fn ration_merge_into(self, first: u32, second: u32, others: &mut (Self, Self))
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+		let (a, b) = self.ration(first, second);
+		others.0.subsume(a);
+		others.1.subsume(b);
+	}
+
+	/// Consume `self` and an `other` to return a new instance that combines
+	/// both.
+	fn merge(self, other: Self) -> Self;
+
+	/// Consume self to mutate `other` so that it combines both. Just like `subsume`, only with
+	/// reversed arguments.
+	fn merge_into(self, other: &mut Self) {
+		other.subsume(self)
+	}
+
+	/// Consume `self` and maybe an `other` to return a new instance that combines
+	/// both.
+	fn maybe_merge(self, other: Option<Self>) -> Self {
+		if let Some(o) = other {
+			self.merge(o)
+		} else {
+			self
+		}
+	}
+
+	/// Consume an `other` to mutate `self` into a new instance that combines
+	/// both.
+	fn subsume(&mut self, other: Self);
+
+	/// Maybe consume an `other` to mutate `self` into a new instance that combines
+	/// both.
+	fn maybe_subsume(&mut self, other: Option<Self>) {
+		if let Some(o) = other {
+			self.subsume(o)
+		}
+	}
+
+	/// Consume self and along with an opposite counterpart to return
+	/// a combined result.
+	///
+	/// Returns `Ok` along with a new instance of `Self` if this instance has a
+	/// greater value than the `other`. Otherwise returns `Err` with an instance of
+	/// the `Opposite`. In both cases the value represents the combination of `self`
+	/// and `other`.
+	fn offset(self, other: Self::Opposite) -> SameOrOther<Self, Self::Opposite>;
+
+	/// The raw value of self.
+	fn peek(&self) -> Balance;
+}
+
+#[cfg(feature = "std")]
+impl<Balance: Default> Imbalance<Balance> for () {
+	type Opposite = ();
+	fn zero() -> Self {
+		()
+	}
+	fn drop_zero(self) -> Result<(), Self> {
+		Ok(())
+	}
+	fn split(self, _: Balance) -> (Self, Self) {
+		((), ())
+	}
+	fn ration(self, _: u32, _: u32) -> (Self, Self)
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+		((), ())
+	}
+	fn split_merge(self, _: Balance, _: (Self, Self)) -> (Self, Self) {
+		((), ())
+	}
+	fn ration_merge(self, _: u32, _: u32, _: (Self, Self)) -> (Self, Self)
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+		((), ())
+	}
+	fn split_merge_into(self, _: Balance, _: &mut (Self, Self)) {}
+	fn ration_merge_into(self, _: u32, _: u32, _: &mut (Self, Self))
+	where
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+	{
+	}
+	fn merge(self, _: Self) -> Self {
+		()
+	}
+	fn merge_into(self, _: &mut Self) {}
+	fn maybe_merge(self, _: Option<Self>) -> Self {
+		()
+	}
+	fn subsume(&mut self, _: Self) {}
+	fn maybe_subsume(&mut self, _: Option<Self>) {
+		()
+	}
+	fn offset(self, _: Self::Opposite) -> SameOrOther<Self, Self::Opposite> {
+		SameOrOther::None
+	}
+	fn peek(&self) -> Balance {
+		Default::default()
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/imbalance/on_unbalanced.rs b/substrate/frame/support/src/traits/tokens/imbalance/on_unbalanced.rs
new file mode 100644
index 0000000000000000000000000000000000000000..27bfe46e181e2255204ce4b377bd6a561e8bbdfc
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/imbalance/on_unbalanced.rs
@@ -0,0 +1,55 @@
+// 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.
+
+//! Trait for handling imbalances.
+
+use crate::traits::misc::TryDrop;
+
+/// Handler for when some currency "account" decreased in balance for
+/// some reason.
+///
+/// The only reason at present for an increase would be for validator rewards, but
+/// there may be other reasons in the future or for other chains.
+///
+/// Reasons for decreases include:
+///
+/// - Someone got slashed.
+/// - Someone paid for a transaction to be included.
+pub trait OnUnbalanced<Imbalance: TryDrop> {
+	/// Handler for some imbalances. The different imbalances might have different origins or
+	/// meanings, dependent on the context. Will default to simply calling on_unbalanced for all
+	/// of them. Infallible.
+	fn on_unbalanceds<B>(amounts: impl Iterator<Item = Imbalance>)
+	where
+		Imbalance: crate::traits::Imbalance<B>,
+	{
+		Self::on_unbalanced(amounts.fold(Imbalance::zero(), |i, x| x.merge(i)))
+	}
+
+	/// Handler for some imbalance. Infallible.
+	fn on_unbalanced(amount: Imbalance) {
+		amount.try_drop().unwrap_or_else(Self::on_nonzero_unbalanced)
+	}
+
+	/// Actually handle a non-zero imbalance. You probably want to implement this rather than
+	/// `on_unbalanced`.
+	fn on_nonzero_unbalanced(amount: Imbalance) {
+		drop(amount);
+	}
+}
+
+impl<Imbalance: TryDrop> OnUnbalanced<Imbalance> for () {}
diff --git a/substrate/frame/support/src/traits/tokens/imbalance/signed_imbalance.rs b/substrate/frame/support/src/traits/tokens/imbalance/signed_imbalance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..03e821b161b694a554effc51c09292ea6df718c2
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/imbalance/signed_imbalance.rs
@@ -0,0 +1,71 @@
+// 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.
+
+//! Convenience type for managing an imbalance whose sign is unknown.
+
+use super::super::imbalance::Imbalance;
+use crate::traits::misc::SameOrOther;
+use codec::FullCodec;
+use sp_runtime::traits::{AtLeast32BitUnsigned, MaybeSerializeDeserialize};
+use sp_std::fmt::Debug;
+
+/// Either a positive or a negative imbalance.
+pub enum SignedImbalance<B, PositiveImbalance: Imbalance<B>> {
+	/// A positive imbalance (funds have been created but none destroyed).
+	Positive(PositiveImbalance),
+	/// A negative imbalance (funds have been destroyed but none created).
+	Negative(PositiveImbalance::Opposite),
+}
+
+impl<
+		P: Imbalance<B, Opposite = N>,
+		N: Imbalance<B, Opposite = P>,
+		B: AtLeast32BitUnsigned + FullCodec + Copy + MaybeSerializeDeserialize + Debug + Default,
+	> SignedImbalance<B, P>
+{
+	/// Create a `Positive` instance of `Self` whose value is zero.
+	pub fn zero() -> Self {
+		SignedImbalance::Positive(P::zero())
+	}
+
+	/// Drop `Self` if and only if it is equal to zero. Return `Err` with `Self` if not.
+	pub fn drop_zero(self) -> Result<(), Self> {
+		match self {
+			SignedImbalance::Positive(x) => x.drop_zero().map_err(SignedImbalance::Positive),
+			SignedImbalance::Negative(x) => x.drop_zero().map_err(SignedImbalance::Negative),
+		}
+	}
+
+	/// Consume `self` and an `other` to return a new instance that combines
+	/// both.
+	pub fn merge(self, other: Self) -> Self {
+		match (self, other) {
+			(SignedImbalance::Positive(one), SignedImbalance::Positive(other)) =>
+				SignedImbalance::Positive(one.merge(other)),
+			(SignedImbalance::Negative(one), SignedImbalance::Negative(other)) =>
+				SignedImbalance::Negative(one.merge(other)),
+			(SignedImbalance::Positive(one), SignedImbalance::Negative(other)) => {
+				match one.offset(other) {
+					SameOrOther::Same(positive) => SignedImbalance::Positive(positive),
+					SameOrOther::Other(negative) => SignedImbalance::Negative(negative),
+					SameOrOther::None => SignedImbalance::Positive(P::zero()),
+				}
+			},
+			(one, other) => other.merge(one),
+		}
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/imbalance/split_two_ways.rs b/substrate/frame/support/src/traits/tokens/imbalance/split_two_ways.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c1afac35fc93c4ab9263a190c0adca44adad3ded
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/imbalance/split_two_ways.rs
@@ -0,0 +1,45 @@
+// 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.
+
+//! Means for splitting an imbalance into two and hanlding them differently.
+
+use super::super::imbalance::{Imbalance, OnUnbalanced};
+use sp_runtime::traits::Saturating;
+use sp_std::{marker::PhantomData, ops::Div};
+
+/// Split an unbalanced amount two ways between a common divisor.
+pub struct SplitTwoWays<Balance, Imbalance, Target1, Target2, const PART1: u32, const PART2: u32>(
+	PhantomData<(Balance, Imbalance, Target1, Target2)>,
+);
+
+impl<
+		Balance: From<u32> + Saturating + Div<Output = Balance>,
+		I: Imbalance<Balance>,
+		Target1: OnUnbalanced<I>,
+		Target2: OnUnbalanced<I>,
+		const PART1: u32,
+		const PART2: u32,
+	> OnUnbalanced<I> for SplitTwoWays<Balance, I, Target1, Target2, PART1, PART2>
+{
+	fn on_nonzero_unbalanced(amount: I) {
+		let total: u32 = PART1 + PART2;
+		let amount1 = amount.peek().saturating_mul(PART1.into()) / total.into();
+		let (imb1, imb2) = amount.split(amount1);
+		Target1::on_unbalanced(imb1);
+		Target2::on_unbalanced(imb2);
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/misc.rs b/substrate/frame/support/src/traits/tokens/misc.rs
new file mode 100644
index 0000000000000000000000000000000000000000..baf3fd5f354646153679d81b6b3349762f62b5c0
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/misc.rs
@@ -0,0 +1,294 @@
+// 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.
+
+//! Miscellaneous types.
+
+use codec::{Decode, Encode, FullCodec, MaxEncodedLen};
+use sp_arithmetic::traits::{AtLeast32BitUnsigned, Zero};
+use sp_core::RuntimeDebug;
+use sp_runtime::{traits::Convert, ArithmeticError, DispatchError, TokenError};
+use sp_std::fmt::Debug;
+
+/// The origin of funds to be used for a deposit operation.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum Provenance {
+	/// The funds will be minted into the system, increasing total issuance (and potentially
+	/// causing an overflow there).
+	Minted,
+	/// The funds already exist in the system, therefore will not affect total issuance.
+	Extant,
+}
+
+/// The mode under which usage of funds may be restricted.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum Restriction {
+	/// Funds are under the normal conditions.
+	Free,
+	/// Funds are on hold.
+	OnHold,
+}
+
+/// The mode by which we describe whether an operation should keep an account alive.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum Preservation {
+	/// We don't care if the account gets killed by this operation.
+	Expendable,
+	/// The account may not be killed, but we don't care if the balance gets dusted.
+	Protect,
+	/// The account may not be killed and our provider reference must remain (in the context of
+	/// tokens, this means that the account may not be dusted).
+	Preserve,
+}
+
+/// The privilege with which a withdraw operation is conducted.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum Fortitude {
+	/// The operation should execute with regular privilege.
+	Polite,
+	/// The operation should be forced to succeed if possible. This is usually employed for system-
+	/// level security-critical events such as slashing.
+	Force,
+}
+
+/// The precision required of an operation generally involving some aspect of quantitative fund
+/// withdrawal or transfer.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum Precision {
+	/// The operation should must either proceed either exactly according to the amounts involved
+	/// or not at all.
+	Exact,
+	/// The operation may be considered successful even if less than the specified amounts are
+	/// available to be used. In this case a best effort will be made.
+	BestEffort,
+}
+
+/// One of a number of consequences of withdrawing a fungible from an account.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum WithdrawConsequence<Balance> {
+	/// Withdraw could not happen since the amount to be withdrawn is less than the total funds in
+	/// the account.
+	BalanceLow,
+	/// The withdraw would mean the account dying when it needs to exist (usually because it is a
+	/// provider and there are consumer references on it).
+	WouldDie,
+	/// The asset is unknown. Usually because an `AssetId` has been presented which doesn't exist
+	/// on the system.
+	UnknownAsset,
+	/// There has been an underflow in the system. This is indicative of a corrupt state and
+	/// likely unrecoverable.
+	Underflow,
+	/// There has been an overflow in the system. This is indicative of a corrupt state and
+	/// likely unrecoverable.
+	Overflow,
+	/// Not enough of the funds in the account are unavailable for withdrawal.
+	Frozen,
+	/// Account balance would reduce to zero, potentially destroying it. The parameter is the
+	/// amount of balance which is destroyed.
+	ReducedToZero(Balance),
+	/// Account continued in existence.
+	Success,
+}
+
+impl<Balance: Zero> WithdrawConsequence<Balance> {
+	/// Convert the type into a `Result` with `DispatchError` as the error or the additional
+	/// `Balance` by which the account will be reduced.
+	pub fn into_result(self, keep_nonzero: bool) -> Result<Balance, DispatchError> {
+		use WithdrawConsequence::*;
+		match self {
+			BalanceLow => Err(TokenError::FundsUnavailable.into()),
+			WouldDie => Err(TokenError::OnlyProvider.into()),
+			UnknownAsset => Err(TokenError::UnknownAsset.into()),
+			Underflow => Err(ArithmeticError::Underflow.into()),
+			Overflow => Err(ArithmeticError::Overflow.into()),
+			Frozen => Err(TokenError::Frozen.into()),
+			ReducedToZero(_) if keep_nonzero => Err(TokenError::NotExpendable.into()),
+			ReducedToZero(result) => Ok(result),
+			Success => Ok(Zero::zero()),
+		}
+	}
+}
+
+/// One of a number of consequences of withdrawing a fungible from an account.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum DepositConsequence {
+	/// Deposit couldn't happen due to the amount being too low. This is usually because the
+	/// account doesn't yet exist and the deposit wouldn't bring it to at least the minimum needed
+	/// for existance.
+	BelowMinimum,
+	/// Deposit cannot happen since the account cannot be created (usually because it's a consumer
+	/// and there exists no provider reference).
+	CannotCreate,
+	/// The asset is unknown. Usually because an `AssetId` has been presented which doesn't exist
+	/// on the system.
+	UnknownAsset,
+	/// An overflow would occur. This is practically unexpected, but could happen in test systems
+	/// with extremely small balance types or balances that approach the max value of the balance
+	/// type.
+	Overflow,
+	/// Account continued in existence.
+	Success,
+	/// Account cannot receive the assets.
+	Blocked,
+}
+
+impl DepositConsequence {
+	/// Convert the type into a `Result` with `TokenError` as the error.
+	pub fn into_result(self) -> Result<(), DispatchError> {
+		use DepositConsequence::*;
+		Err(match self {
+			BelowMinimum => TokenError::BelowMinimum.into(),
+			CannotCreate => TokenError::CannotCreate.into(),
+			UnknownAsset => TokenError::UnknownAsset.into(),
+			Overflow => ArithmeticError::Overflow.into(),
+			Blocked => TokenError::Blocked.into(),
+			Success => return Ok(()),
+		})
+	}
+}
+
+/// Simple boolean for whether an account needs to be kept in existence.
+#[derive(Copy, Clone, RuntimeDebug, Eq, PartialEq)]
+pub enum ExistenceRequirement {
+	/// Operation must not result in the account going out of existence.
+	///
+	/// Note this implies that if the account never existed in the first place, then the operation
+	/// may legitimately leave the account unchanged and still non-existent.
+	KeepAlive,
+	/// Operation may result in account going out of existence.
+	AllowDeath,
+}
+
+/// Status of funds.
+#[derive(
+	PartialEq, Eq, Clone, Copy, Encode, Decode, RuntimeDebug, scale_info::TypeInfo, MaxEncodedLen,
+)]
+pub enum BalanceStatus {
+	/// Funds are free, as corresponding to `free` item in Balances.
+	Free,
+	/// Funds are reserved, as corresponding to `reserved` item in Balances.
+	Reserved,
+}
+
+bitflags::bitflags! {
+	/// Reasons for moving funds out of an account.
+	#[derive(Encode, Decode, MaxEncodedLen)]
+	pub struct WithdrawReasons: u8 {
+		/// In order to pay for (system) transaction costs.
+		const TRANSACTION_PAYMENT = 0b00000001;
+		/// In order to transfer ownership.
+		const TRANSFER = 0b00000010;
+		/// In order to reserve some funds for a later return or repatriation.
+		const RESERVE = 0b00000100;
+		/// In order to pay some other (higher-level) fees.
+		const FEE = 0b00001000;
+		/// In order to tip a validator for transaction inclusion.
+		const TIP = 0b00010000;
+	}
+}
+
+impl WithdrawReasons {
+	/// Choose all variants except for `one`.
+	///
+	/// ```rust
+	/// # use frame_support::traits::WithdrawReasons;
+	/// # fn main() {
+	/// assert_eq!(
+	/// 	WithdrawReasons::FEE | WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE | WithdrawReasons::TIP,
+	/// 	WithdrawReasons::except(WithdrawReasons::TRANSACTION_PAYMENT),
+	/// 	);
+	/// # }
+	/// ```
+	pub fn except(one: WithdrawReasons) -> WithdrawReasons {
+		let mut flags = Self::all();
+		flags.toggle(one);
+		flags
+	}
+}
+
+/// Simple amalgamation trait to collect together properties for an AssetId under one roof.
+pub trait AssetId:
+	FullCodec + Clone + Eq + PartialEq + Debug + scale_info::TypeInfo + MaxEncodedLen
+{
+}
+impl<T: FullCodec + Clone + Eq + PartialEq + Debug + scale_info::TypeInfo + MaxEncodedLen> AssetId
+	for T
+{
+}
+
+/// Simple amalgamation trait to collect together properties for a Balance under one roof.
+pub trait Balance:
+	AtLeast32BitUnsigned + FullCodec + Copy + Default + Debug + scale_info::TypeInfo + MaxEncodedLen
+{
+}
+impl<
+		T: AtLeast32BitUnsigned
+			+ FullCodec
+			+ Copy
+			+ Default
+			+ Debug
+			+ scale_info::TypeInfo
+			+ MaxEncodedLen,
+	> Balance for T
+{
+}
+
+/// Converts a balance value into an asset balance.
+pub trait ConversionToAssetBalance<InBalance, AssetId, AssetBalance> {
+	type Error;
+	fn to_asset_balance(balance: InBalance, asset_id: AssetId)
+		-> Result<AssetBalance, Self::Error>;
+}
+
+/// Converts an asset balance value into balance.
+pub trait ConversionFromAssetBalance<AssetBalance, AssetId, OutBalance> {
+	type Error;
+	fn from_asset_balance(
+		balance: AssetBalance,
+		asset_id: AssetId,
+	) -> Result<OutBalance, Self::Error>;
+}
+
+/// Trait to handle NFT locking mechanism to ensure interactions with the asset can be implemented
+/// downstream to extend logic of Uniques/Nfts current functionality.
+pub trait Locker<CollectionId, ItemId> {
+	/// Check if the asset should be locked and prevent interactions with the asset from executing.
+	fn is_locked(collection: CollectionId, item: ItemId) -> bool;
+}
+
+impl<CollectionId, ItemId> Locker<CollectionId, ItemId> for () {
+	// Default will be false if not implemented downstream.
+	// Note: The logic check in this function must be constant time and consistent for benchmarks
+	// to work.
+	fn is_locked(_collection: CollectionId, _item: ItemId) -> bool {
+		false
+	}
+}
+
+/// Retrieve the salary for a member of a particular rank.
+pub trait GetSalary<Rank, AccountId, Balance> {
+	/// Retrieve the salary for a given rank. The account ID is also supplied in case this changes
+	/// things.
+	fn get_salary(rank: Rank, who: &AccountId) -> Balance;
+}
+
+/// Adapter for a rank-to-salary `Convert` implementation into a `GetSalary` implementation.
+pub struct ConvertRank<C>(sp_std::marker::PhantomData<C>);
+impl<A, R, B, C: Convert<R, B>> GetSalary<R, A, B> for ConvertRank<C> {
+	fn get_salary(rank: R, _: &A) -> B {
+		C::convert(rank)
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/nonfungible.rs b/substrate/frame/support/src/traits/tokens/nonfungible.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e3fc84f1d57b2cf1d47a01a81eb13478a6e8830b
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/nonfungible.rs
@@ -0,0 +1,203 @@
+// 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.
+
+//! Traits for dealing with a single non-fungible collection of items.
+//!
+//! This assumes a single level namespace identified by `Inspect::ItemId`, and could
+//! reasonably be implemented by pallets which wants to expose a single collection of NFT-like
+//! objects.
+//!
+//! For an NFT API which has dual-level namespacing, the traits in `nonfungibles` are better to
+//! use.
+
+use super::nonfungibles;
+use crate::{dispatch::DispatchResult, traits::Get};
+use codec::{Decode, Encode};
+use sp_runtime::TokenError;
+use sp_std::prelude::*;
+
+/// Trait for providing an interface to a read-only NFT-like set of items.
+pub trait Inspect<AccountId> {
+	/// Type for identifying an item.
+	type ItemId;
+
+	/// Returns the owner of `item`, or `None` if the item doesn't exist or has no
+	/// owner.
+	fn owner(item: &Self::ItemId) -> Option<AccountId>;
+
+	/// Returns the attribute value of `item` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn attribute(_item: &Self::ItemId, _key: &[u8]) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the strongly-typed attribute value of `item` corresponding to `key`.
+	///
+	/// By default this just attempts to use `attribute`.
+	fn typed_attribute<K: Encode, V: Decode>(item: &Self::ItemId, key: &K) -> Option<V> {
+		key.using_encoded(|d| Self::attribute(item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns `true` if the `item` may be transferred.
+	///
+	/// Default implementation is that all items are transferable.
+	fn can_transfer(_item: &Self::ItemId) -> bool {
+		true
+	}
+}
+
+/// Interface for enumerating items in existence or owned by a given account over a collection
+/// of NFTs.
+pub trait InspectEnumerable<AccountId>: Inspect<AccountId> {
+	/// The iterator type for [`Self::items`].
+	type ItemsIterator: Iterator<Item = Self::ItemId>;
+	/// The iterator type for [`Self::owned`].
+	type OwnedIterator: Iterator<Item = Self::ItemId>;
+
+	/// Returns an iterator of the items within a `collection` in existence.
+	fn items() -> Self::ItemsIterator;
+
+	/// Returns an iterator of the items of all collections owned by `who`.
+	fn owned(who: &AccountId) -> Self::OwnedIterator;
+}
+
+/// Trait for providing an interface for NFT-like items which may be minted, burned and/or have
+/// attributes set on them.
+pub trait Mutate<AccountId>: Inspect<AccountId> {
+	/// Mint some `item` to be owned by `who`.
+	///
+	/// By default, this is not a supported operation.
+	fn mint_into(_item: &Self::ItemId, _who: &AccountId) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Burn some `item`.
+	///
+	/// By default, this is not a supported operation.
+	fn burn(_item: &Self::ItemId, _maybe_check_owner: Option<&AccountId>) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Set attribute `value` of `item`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn set_attribute(_item: &Self::ItemId, _key: &[u8], _value: &[u8]) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to set the strongly-typed attribute `value` of `item`'s `key`.
+	///
+	/// By default this just attempts to use `set_attribute`.
+	fn set_typed_attribute<K: Encode, V: Encode>(
+		item: &Self::ItemId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| value.using_encoded(|v| Self::set_attribute(item, k, v)))
+	}
+}
+
+/// Trait for providing a non-fungible set of items which can only be transferred.
+pub trait Transfer<AccountId>: Inspect<AccountId> {
+	/// Transfer `item` into `destination` account.
+	fn transfer(item: &Self::ItemId, destination: &AccountId) -> DispatchResult;
+}
+
+/// Convert a `fungibles` trait implementation into a `fungible` trait implementation by identifying
+/// a single item.
+pub struct ItemOf<
+	F: nonfungibles::Inspect<AccountId>,
+	A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+	AccountId,
+>(sp_std::marker::PhantomData<(F, A, AccountId)>);
+
+impl<
+		F: nonfungibles::Inspect<AccountId>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+	> Inspect<AccountId> for ItemOf<F, A, AccountId>
+{
+	type ItemId = <F as nonfungibles::Inspect<AccountId>>::ItemId;
+	fn owner(item: &Self::ItemId) -> Option<AccountId> {
+		<F as nonfungibles::Inspect<AccountId>>::owner(&A::get(), item)
+	}
+	fn attribute(item: &Self::ItemId, key: &[u8]) -> Option<Vec<u8>> {
+		<F as nonfungibles::Inspect<AccountId>>::attribute(&A::get(), item, key)
+	}
+	fn typed_attribute<K: Encode, V: Decode>(item: &Self::ItemId, key: &K) -> Option<V> {
+		<F as nonfungibles::Inspect<AccountId>>::typed_attribute(&A::get(), item, key)
+	}
+	fn can_transfer(item: &Self::ItemId) -> bool {
+		<F as nonfungibles::Inspect<AccountId>>::can_transfer(&A::get(), item)
+	}
+}
+
+impl<
+		F: nonfungibles::InspectEnumerable<AccountId>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+	> InspectEnumerable<AccountId> for ItemOf<F, A, AccountId>
+{
+	type ItemsIterator = <F as nonfungibles::InspectEnumerable<AccountId>>::ItemsIterator;
+	type OwnedIterator =
+		<F as nonfungibles::InspectEnumerable<AccountId>>::OwnedInCollectionIterator;
+
+	fn items() -> Self::ItemsIterator {
+		<F as nonfungibles::InspectEnumerable<AccountId>>::items(&A::get())
+	}
+
+	fn owned(who: &AccountId) -> Self::OwnedIterator {
+		<F as nonfungibles::InspectEnumerable<AccountId>>::owned_in_collection(&A::get(), who)
+	}
+}
+
+impl<
+		F: nonfungibles::Mutate<AccountId>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+	> Mutate<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn mint_into(item: &Self::ItemId, who: &AccountId) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId>>::mint_into(&A::get(), item, who)
+	}
+	fn burn(item: &Self::ItemId, maybe_check_owner: Option<&AccountId>) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId>>::burn(&A::get(), item, maybe_check_owner)
+	}
+	fn set_attribute(item: &Self::ItemId, key: &[u8], value: &[u8]) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId>>::set_attribute(&A::get(), item, key, value)
+	}
+	fn set_typed_attribute<K: Encode, V: Encode>(
+		item: &Self::ItemId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId>>::set_typed_attribute(&A::get(), item, key, value)
+	}
+}
+
+impl<
+		F: nonfungibles::Transfer<AccountId>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+	> Transfer<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn transfer(item: &Self::ItemId, destination: &AccountId) -> DispatchResult {
+		<F as nonfungibles::Transfer<AccountId>>::transfer(&A::get(), item, destination)
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/nonfungible_v2.rs b/substrate/frame/support/src/traits/tokens/nonfungible_v2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c4463e0070f9a1df2183e982043e63cd309180ce
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/nonfungible_v2.rs
@@ -0,0 +1,329 @@
+// 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.
+
+//! Traits for dealing with a single non-fungible item.
+//!
+//! This assumes a single-level namespace identified by `Inspect::ItemId`, and could
+//! reasonably be implemented by pallets that want to expose a single collection of NFT-like
+//! objects.
+//!
+//! For an NFT API that has dual-level namespacing, the traits in `nonfungibles` are better to
+//! use.
+
+use super::nonfungibles_v2 as nonfungibles;
+use crate::{
+	dispatch::{DispatchResult, Parameter},
+	traits::Get,
+};
+use codec::{Decode, Encode};
+use sp_runtime::TokenError;
+use sp_std::prelude::*;
+
+/// Trait for providing an interface to a read-only NFT-like item.
+pub trait Inspect<AccountId> {
+	/// Type for identifying an item.
+	type ItemId: Parameter;
+
+	/// Returns the owner of `item`, or `None` if the item doesn't exist or has no
+	/// owner.
+	fn owner(item: &Self::ItemId) -> Option<AccountId>;
+
+	/// Returns the attribute value of `item` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn attribute(_item: &Self::ItemId, _key: &[u8]) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the custom attribute value of `item` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn custom_attribute(
+		_account: &AccountId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+	) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the system attribute value of `item` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn system_attribute(_item: &Self::ItemId, _key: &[u8]) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the strongly-typed attribute value of `item` corresponding to `key`.
+	///
+	/// By default this just attempts to use `attribute`.
+	fn typed_attribute<K: Encode, V: Decode>(item: &Self::ItemId, key: &K) -> Option<V> {
+		key.using_encoded(|d| Self::attribute(item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns the strongly-typed custom attribute value of `item` corresponding to `key`.
+	///
+	/// By default this just attempts to use `custom_attribute`.
+	fn typed_custom_attribute<K: Encode, V: Decode>(
+		account: &AccountId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> Option<V> {
+		key.using_encoded(|d| Self::custom_attribute(account, item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns the strongly-typed system attribute value of `item` corresponding to `key`.
+	///
+	/// By default this just attempts to use `system_attribute`.
+	fn typed_system_attribute<K: Encode, V: Decode>(item: &Self::ItemId, key: &K) -> Option<V> {
+		key.using_encoded(|d| Self::system_attribute(item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns `true` if the `item` may be transferred.
+	///
+	/// Default implementation is that all items are transferable.
+	fn can_transfer(_item: &Self::ItemId) -> bool {
+		true
+	}
+}
+
+/// Interface for enumerating items in existence or owned by a given account over a collection
+/// of NFTs.
+pub trait InspectEnumerable<AccountId>: Inspect<AccountId> {
+	/// The iterator type for [`Self::items`].
+	type ItemsIterator: Iterator<Item = Self::ItemId>;
+	/// The iterator type for [`Self::owned`].
+	type OwnedIterator: Iterator<Item = Self::ItemId>;
+
+	/// Returns an iterator of the items within a `collection` in existence.
+	fn items() -> Self::ItemsIterator;
+
+	/// Returns an iterator of the items of all collections owned by `who`.
+	fn owned(who: &AccountId) -> Self::OwnedIterator;
+}
+
+/// Trait for providing an interface for NFT-like items which may be minted, burned and/or have
+/// attributes set on them.
+pub trait Mutate<AccountId, ItemConfig>: Inspect<AccountId> {
+	/// Mint some `item` to be owned by `who`.
+	///
+	/// By default, this is not a supported operation.
+	fn mint_into(
+		_item: &Self::ItemId,
+		_who: &AccountId,
+		_config: &ItemConfig,
+		_deposit_collection_owner: bool,
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Burn some `item`.
+	///
+	/// By default, this is not a supported operation.
+	fn burn(_item: &Self::ItemId, _maybe_check_owner: Option<&AccountId>) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Set attribute `value` of `item`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn set_attribute(_item: &Self::ItemId, _key: &[u8], _value: &[u8]) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to set the strongly-typed attribute `value` of `item`'s `key`.
+	///
+	/// By default this just attempts to use `set_attribute`.
+	fn set_typed_attribute<K: Encode, V: Encode>(
+		item: &Self::ItemId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| value.using_encoded(|v| Self::set_attribute(item, k, v)))
+	}
+
+	/// Clear attribute of `item`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn clear_attribute(_item: &Self::ItemId, _key: &[u8]) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to clear the strongly-typed attribute of `item`'s `key`.
+	///
+	/// By default this just attempts to use `clear_attribute`.
+	fn clear_typed_attribute<K: Encode>(item: &Self::ItemId, key: &K) -> DispatchResult {
+		key.using_encoded(|k| Self::clear_attribute(item, k))
+	}
+}
+
+/// Trait for transferring and controlling the transfer of non-fungible sets of items.
+pub trait Transfer<AccountId>: Inspect<AccountId> {
+	/// Transfer `item` into `destination` account.
+	fn transfer(item: &Self::ItemId, destination: &AccountId) -> DispatchResult;
+	/// Disable the `item` of `collection` transfer.
+	///
+	/// By default, this is not a supported operation.
+	fn disable_transfer(item: &Self::ItemId) -> DispatchResult;
+	/// Re-enable the `item` of `collection` transfer.
+	///
+	/// By default, this is not a supported operation.
+	fn enable_transfer(item: &Self::ItemId) -> DispatchResult;
+}
+
+/// Convert a `nonfungibles` trait implementation into a `nonfungible` trait implementation by
+/// identifying a single item.
+pub struct ItemOf<
+	F: nonfungibles::Inspect<AccountId>,
+	A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+	AccountId,
+>(sp_std::marker::PhantomData<(F, A, AccountId)>);
+
+impl<
+		F: nonfungibles::Inspect<AccountId>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+	> Inspect<AccountId> for ItemOf<F, A, AccountId>
+{
+	type ItemId = <F as nonfungibles::Inspect<AccountId>>::ItemId;
+	fn owner(item: &Self::ItemId) -> Option<AccountId> {
+		<F as nonfungibles::Inspect<AccountId>>::owner(&A::get(), item)
+	}
+	fn attribute(item: &Self::ItemId, key: &[u8]) -> Option<Vec<u8>> {
+		<F as nonfungibles::Inspect<AccountId>>::attribute(&A::get(), item, key)
+	}
+	fn custom_attribute(account: &AccountId, item: &Self::ItemId, key: &[u8]) -> Option<Vec<u8>> {
+		<F as nonfungibles::Inspect<AccountId>>::custom_attribute(account, &A::get(), item, key)
+	}
+	fn system_attribute(item: &Self::ItemId, key: &[u8]) -> Option<Vec<u8>> {
+		<F as nonfungibles::Inspect<AccountId>>::system_attribute(&A::get(), item, key)
+	}
+	fn typed_attribute<K: Encode, V: Decode>(item: &Self::ItemId, key: &K) -> Option<V> {
+		<F as nonfungibles::Inspect<AccountId>>::typed_attribute(&A::get(), item, key)
+	}
+	fn typed_custom_attribute<K: Encode, V: Decode>(
+		account: &AccountId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> Option<V> {
+		<F as nonfungibles::Inspect<AccountId>>::typed_custom_attribute(
+			account,
+			&A::get(),
+			item,
+			key,
+		)
+	}
+	fn typed_system_attribute<K: Encode, V: Decode>(item: &Self::ItemId, key: &K) -> Option<V> {
+		<F as nonfungibles::Inspect<AccountId>>::typed_system_attribute(&A::get(), item, key)
+	}
+	fn can_transfer(item: &Self::ItemId) -> bool {
+		<F as nonfungibles::Inspect<AccountId>>::can_transfer(&A::get(), item)
+	}
+}
+
+impl<
+		F: nonfungibles::InspectEnumerable<AccountId>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+	> InspectEnumerable<AccountId> for ItemOf<F, A, AccountId>
+{
+	type ItemsIterator = <F as nonfungibles::InspectEnumerable<AccountId>>::ItemsIterator;
+	type OwnedIterator =
+		<F as nonfungibles::InspectEnumerable<AccountId>>::OwnedInCollectionIterator;
+
+	fn items() -> Self::ItemsIterator {
+		<F as nonfungibles::InspectEnumerable<AccountId>>::items(&A::get())
+	}
+	fn owned(who: &AccountId) -> Self::OwnedIterator {
+		<F as nonfungibles::InspectEnumerable<AccountId>>::owned_in_collection(&A::get(), who)
+	}
+}
+
+impl<
+		F: nonfungibles::Mutate<AccountId, ItemConfig>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+		ItemConfig,
+	> Mutate<AccountId, ItemConfig> for ItemOf<F, A, AccountId>
+{
+	fn mint_into(
+		item: &Self::ItemId,
+		who: &AccountId,
+		config: &ItemConfig,
+		deposit_collection_owner: bool,
+	) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId, ItemConfig>>::mint_into(
+			&A::get(),
+			item,
+			who,
+			config,
+			deposit_collection_owner,
+		)
+	}
+	fn burn(item: &Self::ItemId, maybe_check_owner: Option<&AccountId>) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId, ItemConfig>>::burn(&A::get(), item, maybe_check_owner)
+	}
+	fn set_attribute(item: &Self::ItemId, key: &[u8], value: &[u8]) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId, ItemConfig>>::set_attribute(
+			&A::get(),
+			item,
+			key,
+			value,
+		)
+	}
+	fn set_typed_attribute<K: Encode, V: Encode>(
+		item: &Self::ItemId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId, ItemConfig>>::set_typed_attribute(
+			&A::get(),
+			item,
+			key,
+			value,
+		)
+	}
+	fn clear_attribute(item: &Self::ItemId, key: &[u8]) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId, ItemConfig>>::clear_attribute(&A::get(), item, key)
+	}
+	fn clear_typed_attribute<K: Encode>(item: &Self::ItemId, key: &K) -> DispatchResult {
+		<F as nonfungibles::Mutate<AccountId, ItemConfig>>::clear_typed_attribute(
+			&A::get(),
+			item,
+			key,
+		)
+	}
+}
+
+impl<
+		F: nonfungibles::Transfer<AccountId>,
+		A: Get<<F as nonfungibles::Inspect<AccountId>>::CollectionId>,
+		AccountId,
+	> Transfer<AccountId> for ItemOf<F, A, AccountId>
+{
+	fn transfer(item: &Self::ItemId, destination: &AccountId) -> DispatchResult {
+		<F as nonfungibles::Transfer<AccountId>>::transfer(&A::get(), item, destination)
+	}
+	fn disable_transfer(item: &Self::ItemId) -> DispatchResult {
+		<F as nonfungibles::Transfer<AccountId>>::disable_transfer(&A::get(), item)
+	}
+	fn enable_transfer(item: &Self::ItemId) -> DispatchResult {
+		<F as nonfungibles::Transfer<AccountId>>::enable_transfer(&A::get(), item)
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/nonfungibles.rs b/substrate/frame/support/src/traits/tokens/nonfungibles.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e9538d14f5471aa2877fbfdf6cd2a43442180383
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/nonfungibles.rs
@@ -0,0 +1,250 @@
+// 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.
+
+//! Traits for dealing with multiple collections of non-fungible items.
+//!
+//! This assumes a dual-level namespace identified by `Inspect::ItemId`, and could
+//! reasonably be implemented by pallets which want to expose multiple independent collections of
+//! NFT-like objects.
+//!
+//! For an NFT API which has single-level namespacing, the traits in `nonfungible` are better to
+//! use.
+//!
+//! Implementations of these traits may be converted to implementations of corresponding
+//! `nonfungible` traits by using the `nonfungible::ItemOf` type adapter.
+
+use crate::dispatch::{DispatchError, DispatchResult};
+use codec::{Decode, Encode};
+use sp_runtime::TokenError;
+use sp_std::prelude::*;
+
+/// Trait for providing an interface to many read-only NFT-like sets of items.
+pub trait Inspect<AccountId> {
+	/// Type for identifying an item.
+	type ItemId;
+
+	/// Type for identifying a collection (an identifier for an independent collection of
+	/// items).
+	type CollectionId;
+
+	/// Returns the owner of `item` of `collection`, or `None` if the item doesn't exist
+	/// (or somehow has no owner).
+	fn owner(collection: &Self::CollectionId, item: &Self::ItemId) -> Option<AccountId>;
+
+	/// Returns the owner of the `collection`, if there is one. For many NFTs this may not
+	/// make any sense, so users of this API should not be surprised to find a collection
+	/// results in `None` here.
+	fn collection_owner(_collection: &Self::CollectionId) -> Option<AccountId> {
+		None
+	}
+
+	/// Returns the attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn attribute(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+	) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the strongly-typed attribute value of `item` of `collection` corresponding to
+	/// `key`.
+	///
+	/// By default this just attempts to use `attribute`.
+	fn typed_attribute<K: Encode, V: Decode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> Option<V> {
+		key.using_encoded(|d| Self::attribute(collection, item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns the attribute value of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn collection_attribute(_collection: &Self::CollectionId, _key: &[u8]) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the strongly-typed attribute value of `collection` corresponding to `key`.
+	///
+	/// By default this just attempts to use `collection_attribute`.
+	fn typed_collection_attribute<K: Encode, V: Decode>(
+		collection: &Self::CollectionId,
+		key: &K,
+	) -> Option<V> {
+		key.using_encoded(|d| Self::collection_attribute(collection, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns `true` if the `item` of `collection` may be transferred.
+	///
+	/// Default implementation is that all items are transferable.
+	fn can_transfer(_collection: &Self::CollectionId, _item: &Self::ItemId) -> bool {
+		true
+	}
+}
+
+/// Interface for enumerating items in existence or owned by a given account over many collections
+/// of NFTs.
+pub trait InspectEnumerable<AccountId>: Inspect<AccountId> {
+	/// The iterator type for [`Self::collections`].
+	type CollectionsIterator: Iterator<Item = Self::CollectionId>;
+	/// The iterator type for [`Self::items`].
+	type ItemsIterator: Iterator<Item = Self::ItemId>;
+	/// The iterator type for [`Self::owned`].
+	type OwnedIterator: Iterator<Item = (Self::CollectionId, Self::ItemId)>;
+	/// The iterator type for [`Self::owned_in_collection`].
+	type OwnedInCollectionIterator: Iterator<Item = Self::ItemId>;
+
+	/// Returns an iterator of the collections in existence.
+	fn collections() -> Self::CollectionsIterator;
+
+	/// Returns an iterator of the items of a `collection` in existence.
+	fn items(collection: &Self::CollectionId) -> Self::ItemsIterator;
+
+	/// Returns an iterator of the items of all collections owned by `who`.
+	fn owned(who: &AccountId) -> Self::OwnedIterator;
+
+	/// Returns an iterator of the items of `collection` owned by `who`.
+	fn owned_in_collection(
+		collection: &Self::CollectionId,
+		who: &AccountId,
+	) -> Self::OwnedInCollectionIterator;
+}
+
+/// Trait for providing the ability to create collections of nonfungible items.
+pub trait Create<AccountId>: Inspect<AccountId> {
+	/// Create a `collection` of nonfungible items to be owned by `who` and managed by `admin`.
+	fn create_collection(
+		collection: &Self::CollectionId,
+		who: &AccountId,
+		admin: &AccountId,
+	) -> DispatchResult;
+}
+
+/// Trait for providing the ability to destroy collections of nonfungible items.
+pub trait Destroy<AccountId>: Inspect<AccountId> {
+	/// The witness data needed to destroy an item.
+	type DestroyWitness;
+
+	/// Provide the appropriate witness data needed to destroy an item.
+	fn get_destroy_witness(collection: &Self::CollectionId) -> Option<Self::DestroyWitness>;
+
+	/// Destroy an existing fungible item.
+	/// * `collection`: The `CollectionId` to be destroyed.
+	/// * `witness`: Any witness data that needs to be provided to complete the operation
+	///   successfully.
+	/// * `maybe_check_owner`: An optional account id that can be used to authorize the destroy
+	///   command. If not provided, we will not do any authorization checks before destroying the
+	///   item.
+	///
+	/// If successful, this function will return the actual witness data from the destroyed item.
+	/// This may be different than the witness data provided, and can be used to refund weight.
+	fn destroy(
+		collection: Self::CollectionId,
+		witness: Self::DestroyWitness,
+		maybe_check_owner: Option<AccountId>,
+	) -> Result<Self::DestroyWitness, DispatchError>;
+}
+
+/// Trait for providing an interface for multiple collections of NFT-like items which may be
+/// minted, burned and/or have attributes set on them.
+pub trait Mutate<AccountId>: Inspect<AccountId> {
+	/// Mint some `item` of `collection` to be owned by `who`.
+	///
+	/// By default, this is not a supported operation.
+	fn mint_into(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_who: &AccountId,
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Burn some `item` of `collection`.
+	///
+	/// By default, this is not a supported operation.
+	fn burn(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_maybe_check_owner: Option<&AccountId>,
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Set attribute `value` of `item` of `collection`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn set_attribute(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+		_value: &[u8],
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to set the strongly-typed attribute `value` of `item` of `collection`'s `key`.
+	///
+	/// By default this just attempts to use `set_attribute`.
+	fn set_typed_attribute<K: Encode, V: Encode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| value.using_encoded(|v| Self::set_attribute(collection, item, k, v)))
+	}
+
+	/// Set attribute `value` of `collection`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn set_collection_attribute(
+		_collection: &Self::CollectionId,
+		_key: &[u8],
+		_value: &[u8],
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to set the strongly-typed attribute `value` of `collection`'s `key`.
+	///
+	/// By default this just attempts to use `set_attribute`.
+	fn set_typed_collection_attribute<K: Encode, V: Encode>(
+		collection: &Self::CollectionId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| {
+			value.using_encoded(|v| Self::set_collection_attribute(collection, k, v))
+		})
+	}
+}
+
+/// Trait for providing a non-fungible sets of items which can only be transferred.
+pub trait Transfer<AccountId>: Inspect<AccountId> {
+	/// Transfer `item` of `collection` into `destination` account.
+	fn transfer(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		destination: &AccountId,
+	) -> DispatchResult;
+}
diff --git a/substrate/frame/support/src/traits/tokens/nonfungibles_v2.rs b/substrate/frame/support/src/traits/tokens/nonfungibles_v2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..345cce237b67b1955b14d2090f5a6ce07039f86c
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/nonfungibles_v2.rs
@@ -0,0 +1,372 @@
+// 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.
+
+//! Traits for dealing with multiple collections of non-fungible items.
+//!
+//! This assumes a dual-level namespace identified by `Inspect::ItemId`, and could
+//! reasonably be implemented by pallets which want to expose multiple independent collections of
+//! NFT-like objects.
+//!
+//! For an NFT API which has single-level namespacing, the traits in `nonfungible` are better to
+//! use.
+//!
+//! Implementations of these traits may be converted to implementations of corresponding
+//! `nonfungible` traits by using the `nonfungible::ItemOf` type adapter.
+
+use crate::dispatch::{DispatchError, DispatchResult, Parameter};
+use codec::{Decode, Encode};
+use sp_runtime::TokenError;
+use sp_std::prelude::*;
+
+/// Trait for providing an interface to many read-only NFT-like sets of items.
+pub trait Inspect<AccountId> {
+	/// Type for identifying an item.
+	type ItemId: Parameter;
+
+	/// Type for identifying a collection (an identifier for an independent collection of
+	/// items).
+	type CollectionId: Parameter;
+
+	/// Returns the owner of `item` of `collection`, or `None` if the item doesn't exist
+	/// (or somehow has no owner).
+	fn owner(collection: &Self::CollectionId, item: &Self::ItemId) -> Option<AccountId>;
+
+	/// Returns the owner of the `collection`, if there is one. For many NFTs this may not
+	/// make any sense, so users of this API should not be surprised to find a collection
+	/// results in `None` here.
+	fn collection_owner(_collection: &Self::CollectionId) -> Option<AccountId> {
+		None
+	}
+
+	/// Returns the attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn attribute(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+	) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the custom attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn custom_attribute(
+		_account: &AccountId,
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+	) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the system attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn system_attribute(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+	) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the strongly-typed attribute value of `item` of `collection` corresponding to
+	/// `key`.
+	///
+	/// By default this just attempts to use `attribute`.
+	fn typed_attribute<K: Encode, V: Decode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> Option<V> {
+		key.using_encoded(|d| Self::attribute(collection, item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns the strongly-typed custom attribute value of `item` of `collection` corresponding to
+	/// `key`.
+	///
+	/// By default this just attempts to use `custom_attribute`.
+	fn typed_custom_attribute<K: Encode, V: Decode>(
+		account: &AccountId,
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> Option<V> {
+		key.using_encoded(|d| Self::custom_attribute(account, collection, item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns the strongly-typed system attribute value of `item` of `collection` corresponding to
+	/// `key`.
+	///
+	/// By default this just attempts to use `system_attribute`.
+	fn typed_system_attribute<K: Encode, V: Decode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> Option<V> {
+		key.using_encoded(|d| Self::system_attribute(collection, item, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns the attribute value of `collection` corresponding to `key`.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn collection_attribute(_collection: &Self::CollectionId, _key: &[u8]) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Returns the strongly-typed attribute value of `collection` corresponding to `key`.
+	///
+	/// By default this just attempts to use `collection_attribute`.
+	fn typed_collection_attribute<K: Encode, V: Decode>(
+		collection: &Self::CollectionId,
+		key: &K,
+	) -> Option<V> {
+		key.using_encoded(|d| Self::collection_attribute(collection, d))
+			.and_then(|v| V::decode(&mut &v[..]).ok())
+	}
+
+	/// Returns `true` if the `item` of `collection` may be transferred.
+	///
+	/// Default implementation is that all items are transferable.
+	fn can_transfer(_collection: &Self::CollectionId, _item: &Self::ItemId) -> bool {
+		true
+	}
+}
+
+/// Interface for enumerating items in existence or owned by a given account over many collections
+/// of NFTs.
+pub trait InspectEnumerable<AccountId>: Inspect<AccountId> {
+	/// The iterator type for [`Self::collections`].
+	type CollectionsIterator: Iterator<Item = Self::CollectionId>;
+	/// The iterator type for [`Self::items`].
+	type ItemsIterator: Iterator<Item = Self::ItemId>;
+	/// The iterator type for [`Self::owned`].
+	type OwnedIterator: Iterator<Item = (Self::CollectionId, Self::ItemId)>;
+	/// The iterator type for [`Self::owned_in_collection`].
+	type OwnedInCollectionIterator: Iterator<Item = Self::ItemId>;
+
+	/// Returns an iterator of the collections in existence.
+	fn collections() -> Self::CollectionsIterator;
+
+	/// Returns an iterator of the items of a `collection` in existence.
+	fn items(collection: &Self::CollectionId) -> Self::ItemsIterator;
+
+	/// Returns an iterator of the items of all collections owned by `who`.
+	fn owned(who: &AccountId) -> Self::OwnedIterator;
+
+	/// Returns an iterator of the items of `collection` owned by `who`.
+	fn owned_in_collection(
+		collection: &Self::CollectionId,
+		who: &AccountId,
+	) -> Self::OwnedInCollectionIterator;
+}
+
+/// Trait for providing an interface to check the account's role within the collection.
+pub trait InspectRole<AccountId>: Inspect<AccountId> {
+	/// Returns `true` if `who` is the issuer of the `collection`.
+	fn is_issuer(collection: &Self::CollectionId, who: &AccountId) -> bool;
+	/// Returns `true` if `who` is the admin of the `collection`.
+	fn is_admin(collection: &Self::CollectionId, who: &AccountId) -> bool;
+	/// Returns `true` if `who` is the freezer of the `collection`.
+	fn is_freezer(collection: &Self::CollectionId, who: &AccountId) -> bool;
+}
+
+/// Trait for providing the ability to create collections of nonfungible items.
+pub trait Create<AccountId, CollectionConfig>: Inspect<AccountId> {
+	/// Create a `collection` of nonfungible items to be owned by `who` and managed by `admin`.
+	fn create_collection(
+		who: &AccountId,
+		admin: &AccountId,
+		config: &CollectionConfig,
+	) -> Result<Self::CollectionId, DispatchError>;
+
+	fn create_collection_with_id(
+		collection: Self::CollectionId,
+		who: &AccountId,
+		admin: &AccountId,
+		config: &CollectionConfig,
+	) -> Result<(), DispatchError>;
+}
+
+/// Trait for providing the ability to destroy collections of nonfungible items.
+pub trait Destroy<AccountId>: Inspect<AccountId> {
+	/// The witness data needed to destroy an item.
+	type DestroyWitness: Parameter;
+
+	/// Provide the appropriate witness data needed to destroy an item.
+	fn get_destroy_witness(collection: &Self::CollectionId) -> Option<Self::DestroyWitness>;
+
+	/// Destroy an existing fungible item.
+	/// * `collection`: The `CollectionId` to be destroyed.
+	/// * `witness`: Any witness data that needs to be provided to complete the operation
+	///   successfully.
+	/// * `maybe_check_owner`: An optional `AccountId` that can be used to authorize the destroy
+	///   command. If not provided, we will not do any authorization checks before destroying the
+	///   item.
+	///
+	/// If successful, this function will return the actual witness data from the destroyed item.
+	/// This may be different than the witness data provided, and can be used to refund weight.
+	fn destroy(
+		collection: Self::CollectionId,
+		witness: Self::DestroyWitness,
+		maybe_check_owner: Option<AccountId>,
+	) -> Result<Self::DestroyWitness, DispatchError>;
+}
+
+/// Trait for providing an interface for multiple collections of NFT-like items which may be
+/// minted, burned and/or have attributes set on them.
+pub trait Mutate<AccountId, ItemConfig>: Inspect<AccountId> {
+	/// Mint some `item` of `collection` to be owned by `who`.
+	///
+	/// By default, this is not a supported operation.
+	fn mint_into(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_who: &AccountId,
+		_config: &ItemConfig,
+		_deposit_collection_owner: bool,
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Burn some `item` of `collection`.
+	///
+	/// By default, this is not a supported operation.
+	fn burn(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_maybe_check_owner: Option<&AccountId>,
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Set attribute `value` of `item` of `collection`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn set_attribute(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+		_value: &[u8],
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to set the strongly-typed attribute `value` of `item` of `collection`'s `key`.
+	///
+	/// By default this just attempts to use `set_attribute`.
+	fn set_typed_attribute<K: Encode, V: Encode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| value.using_encoded(|v| Self::set_attribute(collection, item, k, v)))
+	}
+
+	/// Set attribute `value` of `collection`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn set_collection_attribute(
+		_collection: &Self::CollectionId,
+		_key: &[u8],
+		_value: &[u8],
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to set the strongly-typed attribute `value` of `collection`'s `key`.
+	///
+	/// By default this just attempts to use `set_attribute`.
+	fn set_typed_collection_attribute<K: Encode, V: Encode>(
+		collection: &Self::CollectionId,
+		key: &K,
+		value: &V,
+	) -> DispatchResult {
+		key.using_encoded(|k| {
+			value.using_encoded(|v| Self::set_collection_attribute(collection, k, v))
+		})
+	}
+
+	/// Clear attribute of `item` of `collection`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn clear_attribute(
+		_collection: &Self::CollectionId,
+		_item: &Self::ItemId,
+		_key: &[u8],
+	) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to clear the strongly-typed attribute of `item` of `collection`'s `key`.
+	///
+	/// By default this just attempts to use `clear_attribute`.
+	fn clear_typed_attribute<K: Encode>(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &K,
+	) -> DispatchResult {
+		key.using_encoded(|k| Self::clear_attribute(collection, item, k))
+	}
+
+	/// Clear attribute of `collection`'s `key`.
+	///
+	/// By default, this is not a supported operation.
+	fn clear_collection_attribute(_collection: &Self::CollectionId, _key: &[u8]) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Attempt to clear the strongly-typed attribute of `collection`'s `key`.
+	///
+	/// By default this just attempts to use `clear_attribute`.
+	fn clear_typed_collection_attribute<K: Encode>(
+		collection: &Self::CollectionId,
+		key: &K,
+	) -> DispatchResult {
+		key.using_encoded(|k| Self::clear_collection_attribute(collection, k))
+	}
+}
+
+/// Trait for transferring non-fungible sets of items.
+pub trait Transfer<AccountId>: Inspect<AccountId> {
+	/// Transfer `item` of `collection` into `destination` account.
+	fn transfer(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		destination: &AccountId,
+	) -> DispatchResult;
+
+	/// Disable the `item` of `collection` transfer.
+	///
+	/// By default, this is not a supported operation.
+	fn disable_transfer(_collection: &Self::CollectionId, _item: &Self::ItemId) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+
+	/// Re-enable the `item` of `collection` transfer.
+	///
+	/// By default, this is not a supported operation.
+	fn enable_transfer(_collection: &Self::CollectionId, _item: &Self::ItemId) -> DispatchResult {
+		Err(TokenError::Unsupported.into())
+	}
+}
diff --git a/substrate/frame/support/src/traits/tokens/pay.rs b/substrate/frame/support/src/traits/tokens/pay.rs
new file mode 100644
index 0000000000000000000000000000000000000000..78f8e7b8734803ac163a8ed767d4daf4d1a93e10
--- /dev/null
+++ b/substrate/frame/support/src/traits/tokens/pay.rs
@@ -0,0 +1,109 @@
+// 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.
+
+//! The Pay trait and associated types.
+
+use codec::{Decode, Encode, FullCodec, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_core::{RuntimeDebug, TypedGet};
+use sp_runtime::DispatchError;
+use sp_std::fmt::Debug;
+
+use super::{fungible, Balance, Preservation::Expendable};
+
+/// Can be implemented by `PayFromAccount` using a `fungible` impl, but can also be implemented with
+/// XCM/MultiAsset and made generic over assets.
+pub trait Pay {
+	/// The type by which we measure units of the currency in which we make payments.
+	type Balance: Balance;
+	/// The type by which we identify the beneficiaries to whom a payment may be made.
+	type Beneficiary;
+	/// The type for the kinds of asset that are going to be paid.
+	///
+	/// The unit type can be used here to indicate there's only one kind of asset to do payments
+	/// with. When implementing, it should be clear from the context what that asset is.
+	type AssetKind;
+	/// An identifier given to an individual payment.
+	type Id: FullCodec + MaxEncodedLen + TypeInfo + Clone + Eq + PartialEq + Debug + Copy;
+	/// An error which could be returned by the Pay type
+	type Error: Debug;
+	/// Make a payment and return an identifier for later evaluation of success in some off-chain
+	/// mechanism (likely an event, but possibly not on this chain).
+	fn pay(
+		who: &Self::Beneficiary,
+		asset_kind: Self::AssetKind,
+		amount: Self::Balance,
+	) -> Result<Self::Id, Self::Error>;
+	/// Check how a payment has proceeded. `id` must have been previously returned by `pay` for
+	/// the result of this call to be meaningful. Once this returns anything other than
+	/// `InProgress` for some `id` it must return `Unknown` rather than the actual result
+	/// value.
+	fn check_payment(id: Self::Id) -> PaymentStatus;
+	/// Ensure that a call to pay with the given parameters will be successful if done immediately
+	/// after this call. Used in benchmarking code.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_successful(
+		who: &Self::Beneficiary,
+		asset_kind: Self::AssetKind,
+		amount: Self::Balance,
+	);
+	/// Ensure that a call to `check_payment` with the given parameters will return either `Success`
+	/// or `Failure`.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_concluded(id: Self::Id);
+}
+
+/// Status for making a payment via the `Pay::pay` trait function.
+#[derive(Encode, Decode, Eq, PartialEq, Clone, TypeInfo, MaxEncodedLen, RuntimeDebug)]
+pub enum PaymentStatus {
+	/// Payment is in progress. Nothing to report yet.
+	InProgress,
+	/// Payment status is unknowable. It may already have reported the result, or if not then
+	/// it will never be reported successful or failed.
+	Unknown,
+	/// Payment happened successfully.
+	Success,
+	/// Payment failed. It may safely be retried.
+	Failure,
+}
+
+/// Simple implementation of `Pay` which makes a payment from a "pot" - i.e. a single account.
+pub struct PayFromAccount<F, A>(sp_std::marker::PhantomData<(F, A)>);
+impl<A: TypedGet, F: fungible::Mutate<A::Type>> Pay for PayFromAccount<F, A> {
+	type Balance = F::Balance;
+	type Beneficiary = A::Type;
+	type AssetKind = ();
+	type Id = ();
+	type Error = DispatchError;
+	fn pay(
+		who: &Self::Beneficiary,
+		_: Self::AssetKind,
+		amount: Self::Balance,
+	) -> Result<Self::Id, Self::Error> {
+		<F as fungible::Mutate<_>>::transfer(&A::get(), who, amount, Expendable)?;
+		Ok(())
+	}
+	fn check_payment(_: ()) -> PaymentStatus {
+		PaymentStatus::Success
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_successful(_: &Self::Beneficiary, _: Self::AssetKind, amount: Self::Balance) {
+		<F as fungible::Mutate<_>>::mint_into(&A::get(), amount).unwrap();
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn ensure_concluded(_: Self::Id) {}
+}
diff --git a/substrate/frame/support/src/traits/try_runtime.rs b/substrate/frame/support/src/traits/try_runtime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..31aebeeb4d99b2cd5fab1dd833c215a433562213
--- /dev/null
+++ b/substrate/frame/support/src/traits/try_runtime.rs
@@ -0,0 +1,189 @@
+// 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.
+
+//! Try-runtime specific traits and types.
+
+use impl_trait_for_tuples::impl_for_tuples;
+use sp_arithmetic::traits::AtLeast32BitUnsigned;
+use sp_runtime::TryRuntimeError;
+use sp_std::prelude::*;
+
+/// Which state tests to execute.
+#[derive(codec::Encode, codec::Decode, Clone, scale_info::TypeInfo)]
+pub enum Select {
+	/// None of them.
+	None,
+	/// All of them.
+	All,
+	/// Run a fixed number of them in a round robin manner.
+	RoundRobin(u32),
+	/// Run only pallets who's name matches the given list.
+	///
+	/// Pallet names are obtained from [`super::PalletInfoAccess`].
+	Only(Vec<Vec<u8>>),
+}
+
+impl Default for Select {
+	fn default() -> Self {
+		Select::None
+	}
+}
+
+impl sp_std::fmt::Debug for Select {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		match self {
+			Select::RoundRobin(x) => write!(f, "RoundRobin({})", x),
+			Select::Only(x) => write!(
+				f,
+				"Only({:?})",
+				x.iter()
+					.map(|x| sp_std::str::from_utf8(x).unwrap_or("<invalid?>"))
+					.collect::<Vec<_>>(),
+			),
+			Select::All => write!(f, "All"),
+			Select::None => write!(f, "None"),
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl sp_std::str::FromStr for Select {
+	type Err = &'static str;
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		match s {
+			"all" | "All" => Ok(Select::All),
+			"none" | "None" => Ok(Select::None),
+			_ =>
+				if s.starts_with("rr-") {
+					let count = s
+						.split_once('-')
+						.and_then(|(_, count)| count.parse::<u32>().ok())
+						.ok_or("failed to parse count")?;
+					Ok(Select::RoundRobin(count))
+				} else {
+					let pallets = s.split(',').map(|x| x.as_bytes().to_vec()).collect::<Vec<_>>();
+					Ok(Select::Only(pallets))
+				},
+		}
+	}
+}
+
+/// Select which checks should be run when trying a runtime upgrade upgrade.
+#[derive(codec::Encode, codec::Decode, Clone, Debug, Copy, scale_info::TypeInfo)]
+pub enum UpgradeCheckSelect {
+	/// Run no checks.
+	None,
+	/// Run the `try_state`, `pre_upgrade` and `post_upgrade` checks.
+	All,
+	/// Run the `pre_upgrade` and `post_upgrade` checks.
+	PreAndPost,
+	/// Run the `try_state` checks.
+	TryState,
+}
+
+impl UpgradeCheckSelect {
+	/// Whether the pre- and post-upgrade checks are selected.
+	pub fn pre_and_post(&self) -> bool {
+		matches!(self, Self::All | Self::PreAndPost)
+	}
+
+	/// Whether the try-state checks are selected.
+	pub fn try_state(&self) -> bool {
+		matches!(self, Self::All | Self::TryState)
+	}
+}
+
+#[cfg(feature = "std")]
+impl core::str::FromStr for UpgradeCheckSelect {
+	type Err = &'static str;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		match s.to_lowercase().as_str() {
+			"none" => Ok(Self::None),
+			"all" => Ok(Self::All),
+			"pre-and-post" => Ok(Self::PreAndPost),
+			"try-state" => Ok(Self::TryState),
+			_ => Err("Invalid CheckSelector"),
+		}
+	}
+}
+
+/// Execute some checks to ensure the internal state of a pallet is consistent.
+///
+/// Usually, these checks should check all of the invariants that are expected to be held on all of
+/// the storage items of your pallet.
+///
+/// This hook should not alter any storage.
+pub trait TryState<BlockNumber> {
+	/// Execute the state checks.
+	fn try_state(_: BlockNumber, _: Select) -> Result<(), TryRuntimeError>;
+}
+
+#[cfg_attr(all(not(feature = "tuples-96"), not(feature = "tuples-128")), impl_for_tuples(64))]
+#[cfg_attr(all(feature = "tuples-96", not(feature = "tuples-128")), impl_for_tuples(96))]
+#[cfg_attr(all(feature = "tuples-128"), impl_for_tuples(128))]
+impl<BlockNumber: Clone + sp_std::fmt::Debug + AtLeast32BitUnsigned> TryState<BlockNumber>
+	for Tuple
+{
+	for_tuples!( where #( Tuple: crate::traits::PalletInfoAccess )* );
+	fn try_state(n: BlockNumber, targets: Select) -> Result<(), TryRuntimeError> {
+		match targets {
+			Select::None => Ok(()),
+			Select::All => {
+				let mut result = Ok(());
+				for_tuples!( #( result = result.and(Tuple::try_state(n.clone(), targets.clone())); )* );
+				result
+			},
+			Select::RoundRobin(len) => {
+				let functions: &[fn(BlockNumber, Select) -> Result<(), TryRuntimeError>] =
+					&[for_tuples!(#( Tuple::try_state ),*)];
+				let skip = n.clone() % (functions.len() as u32).into();
+				let skip: u32 =
+					skip.try_into().unwrap_or_else(|_| sp_runtime::traits::Bounded::max_value());
+				let mut result = Ok(());
+				for try_state_fn in functions.iter().cycle().skip(skip as usize).take(len as usize)
+				{
+					result = result.and(try_state_fn(n.clone(), targets.clone()));
+				}
+				result
+			},
+			Select::Only(ref pallet_names) => {
+				let try_state_fns: &[(
+					&'static str,
+					fn(BlockNumber, Select) -> Result<(), TryRuntimeError>,
+				)] = &[for_tuples!(
+					#( (<Tuple as crate::traits::PalletInfoAccess>::name(), Tuple::try_state) ),*
+				)];
+				let mut result = Ok(());
+				pallet_names.iter().for_each(|pallet_name| {
+					if let Some((name, try_state_fn)) =
+						try_state_fns.iter().find(|(name, _)| name.as_bytes() == pallet_name)
+					{
+						result = result.and(try_state_fn(n.clone(), targets.clone()));
+					} else {
+						log::warn!(
+							"Pallet {:?} not found",
+							sp_std::str::from_utf8(pallet_name).unwrap_or_default()
+						);
+					}
+				});
+
+				result
+			},
+		}
+	}
+}
diff --git a/substrate/frame/support/src/traits/tx_pause.rs b/substrate/frame/support/src/traits/tx_pause.rs
new file mode 100644
index 0000000000000000000000000000000000000000..64d2f754f523582ca843ce88f7f115059f713579
--- /dev/null
+++ b/substrate/frame/support/src/traits/tx_pause.rs
@@ -0,0 +1,66 @@
+// 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.
+
+//! Types to pause calls in the runtime.
+
+/// Can pause specific transactions from being processed.
+///
+/// Note that paused transactions will not be queued for later execution. Instead they will be
+/// dropped.
+pub trait TransactionPause {
+	/// How to unambiguously identify a call.
+	///
+	/// For example `(pallet_index, call_index)`.
+	type CallIdentifier;
+
+	/// Whether this call is paused.
+	fn is_paused(call: Self::CallIdentifier) -> bool;
+
+	/// Whether this call can be paused.
+	///
+	/// This holds for the current block, but may change in the future.
+	fn can_pause(call: Self::CallIdentifier) -> bool;
+
+	/// Pause this call immediately.
+	///
+	/// This takes effect in the same block and must succeed if `can_pause` returns `true`.
+	fn pause(call: Self::CallIdentifier) -> Result<(), TransactionPauseError>;
+
+	/// Unpause this call immediately.
+	///
+	/// This takes effect in the same block and must succeed if `is_paused` returns `true`. This
+	/// invariant is important to not have un-resumable calls.
+	fn unpause(call: Self::CallIdentifier) -> Result<(), TransactionPauseError>;
+}
+
+/// The error type for [`TransactionPause`].
+pub enum TransactionPauseError {
+	/// The call could not be found in the runtime.
+	///
+	/// This is a permanent error but could change after a runtime upgrade.
+	NotFound,
+	/// Call cannot be paused.
+	///
+	/// This may or may not resolve in a future block.
+	Unpausable,
+	/// Call is already paused.
+	AlreadyPaused,
+	/// Call is already unpaused.
+	AlreadyUnpaused,
+	/// Unknown error.
+	Unknown,
+}
diff --git a/substrate/frame/support/src/traits/validation.rs b/substrate/frame/support/src/traits/validation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..617cdb2d3f4615794af3261e235d322050153f03
--- /dev/null
+++ b/substrate/frame/support/src/traits/validation.rs
@@ -0,0 +1,260 @@
+// 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.
+
+//! Traits for dealing with validation and validators.
+
+use crate::{dispatch::Parameter, weights::Weight};
+use codec::{Codec, Decode, MaxEncodedLen};
+use sp_runtime::{
+	traits::{Convert, Zero},
+	BoundToRuntimeAppPublic, ConsensusEngineId, Permill, RuntimeAppPublic,
+};
+use sp_staking::SessionIndex;
+use sp_std::prelude::*;
+
+/// A trait for online node inspection in a session.
+///
+/// Something that can give information about the current validator set.
+pub trait ValidatorSet<AccountId> {
+	/// Type for representing validator id in a session.
+	type ValidatorId: Parameter + MaxEncodedLen;
+	/// A type for converting `AccountId` to `ValidatorId`.
+	type ValidatorIdOf: Convert<AccountId, Option<Self::ValidatorId>>;
+
+	/// Returns current session index.
+	fn session_index() -> SessionIndex;
+
+	/// Returns the active set of validators.
+	fn validators() -> Vec<Self::ValidatorId>;
+}
+
+/// [`ValidatorSet`] combined with an identification.
+pub trait ValidatorSetWithIdentification<AccountId>: ValidatorSet<AccountId> {
+	/// Full identification of `ValidatorId`.
+	type Identification: Parameter;
+	/// A type for converting `ValidatorId` to `Identification`.
+	type IdentificationOf: Convert<Self::ValidatorId, Option<Self::Identification>>;
+}
+
+/// A trait for finding the author of a block header based on the `PreRuntime` digests contained
+/// within it.
+pub trait FindAuthor<Author> {
+	/// Find the author of a block based on the pre-runtime digests.
+	fn find_author<'a, I>(digests: I) -> Option<Author>
+	where
+		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>;
+}
+
+impl<A> FindAuthor<A> for () {
+	fn find_author<'a, I>(_: I) -> Option<A>
+	where
+		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+	{
+		None
+	}
+}
+
+/// A trait for verifying the seal of a header and returning the author.
+pub trait VerifySeal<Header, Author> {
+	/// Verify a header and return the author, if any.
+	fn verify_seal(header: &Header) -> Result<Option<Author>, &'static str>;
+}
+
+/// A session handler for specific key type.
+pub trait OneSessionHandler<ValidatorId>: BoundToRuntimeAppPublic {
+	/// The key type expected.
+	type Key: Decode + RuntimeAppPublic;
+
+	/// The given validator set will be used for the genesis session.
+	/// It is guaranteed that the given validator set will also be used
+	/// for the second session, therefore the first call to `on_new_session`
+	/// should provide the same validator set.
+	fn on_genesis_session<'a, I: 'a>(validators: I)
+	where
+		I: Iterator<Item = (&'a ValidatorId, Self::Key)>,
+		ValidatorId: 'a;
+
+	/// Session set has changed; act appropriately. Note that this can be called
+	/// before initialization of your module.
+	///
+	/// `changed` is true when at least one of the session keys
+	/// or the underlying economic identities/distribution behind one the
+	/// session keys has changed, false otherwise.
+	///
+	/// The `validators` are the validators of the incoming session, and `queued_validators`
+	/// will follow.
+	fn on_new_session<'a, I: 'a>(changed: bool, validators: I, queued_validators: I)
+	where
+		I: Iterator<Item = (&'a ValidatorId, Self::Key)>,
+		ValidatorId: 'a;
+
+	/// A notification for end of the session.
+	///
+	/// Note it is triggered before any `SessionManager::end_session` handlers,
+	/// so we can still affect the validator set.
+	fn on_before_session_ending() {}
+
+	/// A validator got disabled. Act accordingly until a new session begins.
+	fn on_disabled(_validator_index: u32);
+}
+
+/// Something that can estimate at which block the next session rotation will happen (i.e. a new
+/// session starts).
+///
+/// The accuracy of the estimates is dependent on the specific implementation, but in order to get
+/// the best estimate possible these methods should be called throughout the duration of the session
+/// (rather than calling once and storing the result).
+///
+/// This should be the same logical unit that dictates `ShouldEndSession` to the session module. No
+/// assumptions are made about the scheduling of the sessions.
+pub trait EstimateNextSessionRotation<BlockNumber> {
+	/// Return the average length of a session.
+	///
+	/// This may or may not be accurate.
+	fn average_session_length() -> BlockNumber;
+
+	/// Return an estimate of the current session progress.
+	///
+	/// None should be returned if the estimation fails to come to an answer.
+	fn estimate_current_session_progress(now: BlockNumber) -> (Option<Permill>, Weight);
+
+	/// Return the block number at which the next session rotation is estimated to happen.
+	///
+	/// None should be returned if the estimation fails to come to an answer.
+	fn estimate_next_session_rotation(now: BlockNumber) -> (Option<BlockNumber>, Weight);
+}
+
+impl<BlockNumber: Zero> EstimateNextSessionRotation<BlockNumber> for () {
+	fn average_session_length() -> BlockNumber {
+		Zero::zero()
+	}
+
+	fn estimate_current_session_progress(_: BlockNumber) -> (Option<Permill>, Weight) {
+		(None, Zero::zero())
+	}
+
+	fn estimate_next_session_rotation(_: BlockNumber) -> (Option<BlockNumber>, Weight) {
+		(None, Zero::zero())
+	}
+}
+
+/// Something that can estimate at which block scheduling of the next session will happen (i.e when
+/// we will try to fetch new validators).
+///
+/// This only refers to the point when we fetch the next session details and not when we enact them
+/// (for enactment there's `EstimateNextSessionRotation`). With `pallet-session` this should be
+/// triggered whenever `SessionManager::new_session` is called.
+///
+/// For example, if we are using a staking module this would be the block when the session module
+/// would ask staking what the next validator set will be, as such this must always be implemented
+/// by the session module.
+pub trait EstimateNextNewSession<BlockNumber> {
+	/// Return the average length of a session.
+	///
+	/// This may or may not be accurate.
+	fn average_session_length() -> BlockNumber;
+
+	/// Return the block number at which the next new session is estimated to happen.
+	///
+	/// None should be returned if the estimation fails to come to an answer.
+	fn estimate_next_new_session(_: BlockNumber) -> (Option<BlockNumber>, Weight);
+}
+
+impl<BlockNumber: Zero> EstimateNextNewSession<BlockNumber> for () {
+	fn average_session_length() -> BlockNumber {
+		Zero::zero()
+	}
+
+	fn estimate_next_new_session(_: BlockNumber) -> (Option<BlockNumber>, Weight) {
+		(None, Zero::zero())
+	}
+}
+
+/// Something which can compute and check proofs of
+/// a historical key owner and return full identification data of that
+/// key owner.
+pub trait KeyOwnerProofSystem<Key> {
+	/// The proof of membership itself.
+	type Proof: Codec;
+	/// The full identification of a key owner and the stash account.
+	type IdentificationTuple: Codec;
+
+	/// Prove membership of a key owner in the current block-state.
+	///
+	/// This should typically only be called off-chain, since it may be
+	/// computationally heavy.
+	///
+	/// Returns `Some` iff the key owner referred to by the given `key` is a
+	/// member of the current set.
+	fn prove(key: Key) -> Option<Self::Proof>;
+
+	/// Check a proof of membership on-chain. Return `Some` iff the proof is
+	/// valid and recent enough to check.
+	fn check_proof(key: Key, proof: Self::Proof) -> Option<Self::IdentificationTuple>;
+}
+
+impl<Key> KeyOwnerProofSystem<Key> for () {
+	// The proof and identification tuples is any bottom type to guarantee that the methods of this
+	// implementation can never be called or return anything other than `None`.
+	type Proof = sp_core::Void;
+	type IdentificationTuple = sp_core::Void;
+
+	fn prove(_key: Key) -> Option<Self::Proof> {
+		None
+	}
+
+	fn check_proof(_key: Key, _proof: Self::Proof) -> Option<Self::IdentificationTuple> {
+		None
+	}
+}
+
+/// Trait to be used by block producing consensus engine modules to determine
+/// how late the current block is (e.g. in a slot-based proposal mechanism how
+/// many slots were skipped since the previous block).
+pub trait Lateness<N> {
+	/// Returns a generic measure of how late the current block is compared to
+	/// its parent.
+	fn lateness(&self) -> N;
+}
+
+impl<N: Zero> Lateness<N> for () {
+	fn lateness(&self) -> N {
+		Zero::zero()
+	}
+}
+
+/// Implementors of this trait provide information about whether or not some validator has
+/// been registered with them. The [Session module](../../pallet_session/index.html) is an
+/// implementor.
+pub trait ValidatorRegistration<ValidatorId> {
+	/// Returns true if the provided validator ID has been registered with the implementing runtime
+	/// module
+	fn is_registered(id: &ValidatorId) -> bool;
+}
+
+/// Trait used to check whether a given validator is currently disabled and should not be
+/// participating in consensus (e.g. because they equivocated).
+pub trait DisabledValidators {
+	/// Returns true if the given validator is disabled.
+	fn is_disabled(index: u32) -> bool;
+}
+
+impl DisabledValidators for () {
+	fn is_disabled(_index: u32) -> bool {
+		false
+	}
+}
diff --git a/substrate/frame/support/src/traits/voting.rs b/substrate/frame/support/src/traits/voting.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4201b8d48d157634b5cd7793dee94abd6d9483aa
--- /dev/null
+++ b/substrate/frame/support/src/traits/voting.rs
@@ -0,0 +1,118 @@
+// 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.
+
+//! Traits and associated data structures concerned with voting, and moving between tokens and
+//! votes.
+
+use crate::dispatch::{DispatchError, Parameter};
+use codec::{HasCompact, MaxEncodedLen};
+use sp_arithmetic::Perbill;
+use sp_runtime::traits::Member;
+use sp_std::prelude::*;
+
+pub trait VoteTally<Votes, Class> {
+	fn new(_: Class) -> Self;
+	fn ayes(&self, class: Class) -> Votes;
+	fn support(&self, class: Class) -> Perbill;
+	fn approval(&self, class: Class) -> Perbill;
+	#[cfg(feature = "runtime-benchmarks")]
+	fn unanimity(class: Class) -> Self;
+	#[cfg(feature = "runtime-benchmarks")]
+	fn rejection(class: Class) -> Self;
+	#[cfg(feature = "runtime-benchmarks")]
+	fn from_requirements(support: Perbill, approval: Perbill, class: Class) -> Self;
+	#[cfg(feature = "runtime-benchmarks")]
+	/// A function that should be called before any use of the `runtime-benchmarks` gated functions
+	/// of the `VoteTally` trait.
+	///
+	/// Should be used to set up any needed state in a Pallet which implements `VoteTally` so that
+	/// benchmarks that execute will complete successfully. `class` can be used to set up a
+	/// particular class of voters, and `granularity` is used to determine the weight of one vote
+	/// relative to total unanimity.
+	///
+	/// For example, in the case where there are a number of unique voters, and each voter has equal
+	/// voting weight, a granularity of `Perbill::from_rational(1, 1000)` should create `1_000`
+	/// users.
+	fn setup(class: Class, granularity: Perbill);
+}
+pub enum PollStatus<Tally, Moment, Class> {
+	None,
+	Ongoing(Tally, Class),
+	Completed(Moment, bool),
+}
+
+impl<Tally, Moment, Class> PollStatus<Tally, Moment, Class> {
+	pub fn ensure_ongoing(self) -> Option<(Tally, Class)> {
+		match self {
+			Self::Ongoing(t, c) => Some((t, c)),
+			_ => None,
+		}
+	}
+}
+
+pub struct ClassCountOf<P, T>(sp_std::marker::PhantomData<(P, T)>);
+impl<T, P: Polling<T>> sp_runtime::traits::Get<u32> for ClassCountOf<P, T> {
+	fn get() -> u32 {
+		P::classes().len() as u32
+	}
+}
+
+pub trait Polling<Tally> {
+	type Index: Parameter + Member + Ord + PartialOrd + Copy + HasCompact + MaxEncodedLen;
+	type Votes: Parameter + Member + Ord + PartialOrd + Copy + HasCompact + MaxEncodedLen;
+	type Class: Parameter + Member + Ord + PartialOrd + MaxEncodedLen;
+	type Moment;
+
+	/// Provides a vec of values that `T` may take.
+	fn classes() -> Vec<Self::Class>;
+
+	/// `Some` if the referendum `index` can be voted on, along with the tally and class of
+	/// referendum.
+	///
+	/// Don't use this if you might mutate - use `try_access_poll` instead.
+	fn as_ongoing(index: Self::Index) -> Option<(Tally, Self::Class)>;
+
+	fn access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(PollStatus<&mut Tally, Self::Moment, Self::Class>) -> R,
+	) -> R;
+
+	fn try_access_poll<R>(
+		index: Self::Index,
+		f: impl FnOnce(PollStatus<&mut Tally, Self::Moment, Self::Class>) -> Result<R, DispatchError>,
+	) -> Result<R, DispatchError>;
+
+	/// Create an ongoing majority-carries poll of given class lasting given period for the purpose
+	/// of benchmarking.
+	///
+	/// May return `Err` if it is impossible.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn create_ongoing(class: Self::Class) -> Result<Self::Index, ()>;
+
+	/// End the given ongoing poll and return the result.
+	///
+	/// Returns `Err` if `index` is not an ongoing poll.
+	#[cfg(feature = "runtime-benchmarks")]
+	fn end_ongoing(index: Self::Index, approved: bool) -> Result<(), ()>;
+
+	/// The maximum amount of ongoing polls within any single class. By default it practically
+	/// unlimited (`u32::max_value()`).
+	#[cfg(feature = "runtime-benchmarks")]
+	fn max_ongoing() -> (Self::Class, u32) {
+		(Self::classes().into_iter().next().expect("Always one class"), u32::max_value())
+	}
+}
diff --git a/substrate/frame/support/src/weights.rs b/substrate/frame/support/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7941f2a89a5504d46596907d0484b492b6d1babb
--- /dev/null
+++ b/substrate/frame/support/src/weights.rs
@@ -0,0 +1,39 @@
+// 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.
+
+//! Re-exports `sp-weights` public API, and contains benchmarked weight constants specific to FRAME.
+
+mod block_weights;
+mod extrinsic_weights;
+mod paritydb_weights;
+mod rocksdb_weights;
+
+pub use sp_weights::*;
+
+/// These constants are specific to FRAME, and the current implementation of its various components.
+/// For example: FRAME System, FRAME Executive, our FRAME support libraries, etc...
+pub mod constants {
+	pub use sp_weights::constants::*;
+
+	// Expose the Block and Extrinsic base weights.
+	pub use super::{block_weights::BlockExecutionWeight, extrinsic_weights::ExtrinsicBaseWeight};
+
+	// Expose the DB weights.
+	pub use super::{
+		paritydb_weights::constants::ParityDbWeight, rocksdb_weights::constants::RocksDbWeight,
+	};
+}
diff --git a/substrate/frame/support/src/weights/block_weights.rs b/substrate/frame/support/src/weights/block_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..57a68554755abb007165e751df687d097cd48f17
--- /dev/null
+++ b/substrate/frame/support/src/weights/block_weights.rs
@@ -0,0 +1,82 @@
+// 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 FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16 (Y/M/D)
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//!
+//! SHORT-NAME: `block`, LONG-NAME: `BlockExecution`, RUNTIME: `Development`
+//! WARMUPS: `10`, REPEAT: `100`
+//! WEIGHT-PATH: `./frame/support/src/weights/`
+//! WEIGHT-METRIC: `Average`, WEIGHT-MUL: `1.0`, WEIGHT-ADD: `0`
+
+// Executed Command:
+//   ./target/production/substrate
+//   benchmark
+//   overhead
+//   --chain=dev
+//   --execution=wasm
+//   --wasm-execution=compiled
+//   --weight-path=./frame/support/src/weights/
+//   --header=./HEADER-APACHE2
+//   --warmup=10
+//   --repeat=100
+
+use sp_core::parameter_types;
+use sp_weights::{constants::WEIGHT_REF_TIME_PER_NANOS, Weight};
+
+parameter_types! {
+	/// Time to execute an empty block.
+	/// Calculated by multiplying the *Average* with `1.0` and adding `0`.
+	///
+	/// Stats nanoseconds:
+	///   Min, Max: 376_949, 622_462
+	///   Average:  390_584
+	///   Median:   386_322
+	///   Std-Dev:  24792.0
+	///
+	/// Percentiles nanoseconds:
+	///   99th: 433_299
+	///   95th: 402_688
+	///   75th: 391_645
+	pub const BlockExecutionWeight: Weight =
+		Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(390_584), 0);
+}
+
+#[cfg(test)]
+mod test_weights {
+	use sp_weights::constants;
+
+	/// Checks that the weight exists and is sane.
+	// NOTE: If this test fails but you are sure that the generated values are fine,
+	// you can delete it.
+	#[test]
+	fn sane() {
+		let w = super::BlockExecutionWeight::get();
+
+		// At least 100 µs.
+		assert!(
+			w.ref_time() >= 100u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
+			"Weight should be at least 100 µs."
+		);
+		// At most 50 ms.
+		assert!(
+			w.ref_time() <= 50u64 * constants::WEIGHT_REF_TIME_PER_MILLIS,
+			"Weight should be at most 50 ms."
+		);
+	}
+}
diff --git a/substrate/frame/support/src/weights/extrinsic_weights.rs b/substrate/frame/support/src/weights/extrinsic_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a304f089ff782c34ab9941705503c5e766bb08b0
--- /dev/null
+++ b/substrate/frame/support/src/weights/extrinsic_weights.rs
@@ -0,0 +1,82 @@
+// 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 FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16 (Y/M/D)
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//!
+//! SHORT-NAME: `extrinsic`, LONG-NAME: `ExtrinsicBase`, RUNTIME: `Development`
+//! WARMUPS: `10`, REPEAT: `100`
+//! WEIGHT-PATH: `./frame/support/src/weights/`
+//! WEIGHT-METRIC: `Average`, WEIGHT-MUL: `1.0`, WEIGHT-ADD: `0`
+
+// Executed Command:
+//   ./target/production/substrate
+//   benchmark
+//   overhead
+//   --chain=dev
+//   --execution=wasm
+//   --wasm-execution=compiled
+//   --weight-path=./frame/support/src/weights/
+//   --header=./HEADER-APACHE2
+//   --warmup=10
+//   --repeat=100
+
+use sp_core::parameter_types;
+use sp_weights::{constants::WEIGHT_REF_TIME_PER_NANOS, Weight};
+
+parameter_types! {
+	/// Time to execute a NO-OP extrinsic, for example `System::remark`.
+	/// Calculated by multiplying the *Average* with `1.0` and adding `0`.
+	///
+	/// Stats nanoseconds:
+	///   Min, Max: 123_875, 128_419
+	///   Average:  124_414
+	///   Median:   124_332
+	///   Std-Dev:  497.74
+	///
+	/// Percentiles nanoseconds:
+	///   99th: 125_245
+	///   95th: 124_989
+	///   75th: 124_498
+	pub const ExtrinsicBaseWeight: Weight =
+		Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(124_414), 0);
+}
+
+#[cfg(test)]
+mod test_weights {
+	use sp_weights::constants;
+
+	/// Checks that the weight exists and is sane.
+	// NOTE: If this test fails but you are sure that the generated values are fine,
+	// you can delete it.
+	#[test]
+	fn sane() {
+		let w = super::ExtrinsicBaseWeight::get();
+
+		// At least 10 µs.
+		assert!(
+			w.ref_time() >= 10u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
+			"Weight should be at least 10 µs."
+		);
+		// At most 1 ms.
+		assert!(
+			w.ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+			"Weight should be at most 1 ms."
+		);
+	}
+}
diff --git a/substrate/frame/support/src/weights/paritydb_weights.rs b/substrate/frame/support/src/weights/paritydb_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f69fc0cd93c62b57951447f100ea5358fc5ea2a1
--- /dev/null
+++ b/substrate/frame/support/src/weights/paritydb_weights.rs
@@ -0,0 +1,62 @@
+// 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.
+
+pub mod constants {
+	use frame_support::weights::constants;
+	use sp_core::parameter_types;
+	use sp_weights::RuntimeDbWeight;
+
+	parameter_types! {
+		/// ParityDB can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		pub const ParityDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 8_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+			write: 50_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::ParityDbWeight as W;
+		use sp_weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}
diff --git a/substrate/frame/support/src/weights/rocksdb_weights.rs b/substrate/frame/support/src/weights/rocksdb_weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..25d2ac1cdec0430c892545a3749d282fe174ccdf
--- /dev/null
+++ b/substrate/frame/support/src/weights/rocksdb_weights.rs
@@ -0,0 +1,62 @@
+// 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.
+
+pub mod constants {
+	use frame_support::weights::constants;
+	use sp_core::parameter_types;
+	use sp_weights::RuntimeDbWeight;
+
+	parameter_types! {
+		/// By default, Substrate uses RocksDB, so this will be the weight used throughout
+		/// the runtime.
+		pub const RocksDbWeight: RuntimeDbWeight = RuntimeDbWeight {
+			read: 25_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+			write: 100_000 * constants::WEIGHT_REF_TIME_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::RocksDbWeight as W;
+		use sp_weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn sane() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}
diff --git a/substrate/frame/support/test/Cargo.toml b/substrate/frame/support/test/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ecb171244299a201e8267764501785a9943ffe42
--- /dev/null
+++ b/substrate/frame/support/test/Cargo.toml
@@ -0,0 +1,75 @@
+[package]
+name = "frame-support-test"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+static_assertions = "1.1.0"
+serde = { version = "1.0.163", default-features = false, features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-metadata = { version = "16.0.0", default-features = false, features = ["current"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/api" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../../../primitives/arithmetic" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io", default-features = false }
+sp-state-machine = { version = "0.28.0", optional = true, path = "../../../primitives/state-machine" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../" }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../benchmarking" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+sp-version = { version = "22.0.0", default-features = false, path = "../../../primitives/version" }
+sp-metadata-ir = { version = "0.1.0", default-features = false, path = "../../../primitives/metadata-ir" }
+trybuild = { version = "1.0.74", features = [ "diff" ] }
+pretty_assertions = "1.3.0"
+rustversion = "1.0.6"
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+frame-executive = { version = "4.0.0-dev", default-features = false, path = "../../executive" }
+# The "std" feature for this pallet is never activated on purpose, in order to test construct_runtime error message
+test-pallet = { package = "frame-support-test-pallet", default-features = false, path = "pallet" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-executive/std",
+	"frame-metadata/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-api/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-metadata-ir/std",
+	"sp-runtime/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-version/std",
+	"test-pallet/std",
+]
+experimental = [ "frame-support/experimental" ]
+try-runtime = [
+	"frame-executive/try-runtime",
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
+# WARNING:
+# Only CI runs with this feature enabled. This feature is for testing stuff related to the FRAME macros
+# in conjunction with rust features.
+frame-feature-testing = []
+frame-feature-testing-2 = []
+# Disable ui tests
+disable-ui-tests = []
+no-metadata-docs = [ "frame-support/no-metadata-docs" ]
diff --git a/substrate/frame/support/test/compile_pass/Cargo.toml b/substrate/frame/support/test/compile_pass/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..151f7d8a5be0eef5c4d8ecb743fc92616acd14ec
--- /dev/null
+++ b/substrate/frame/support/test/compile_pass/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "frame-support-test-compile-pass"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+renamed-frame-support = { package = "frame-support", version = "4.0.0-dev", default-features = false, path = "../../" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../../../primitives/core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../../primitives/runtime" }
+sp-version = { version = "22.0.0", default-features = false, path = "../../../../primitives/version" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-system/std",
+	"renamed-frame-support/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-version/std",
+]
diff --git a/substrate/frame/support/test/compile_pass/src/lib.rs b/substrate/frame/support/test/compile_pass/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bf90d73acb320a439963ec25d8379982e1338127
--- /dev/null
+++ b/substrate/frame/support/test/compile_pass/src/lib.rs
@@ -0,0 +1,87 @@
+// 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/>.
+
+//! Test that `construct_runtime!` also works when `frame-support` is renamed in the `Cargo.toml`.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use renamed_frame_support::{
+	construct_runtime, parameter_types,
+	traits::{ConstU16, ConstU32, ConstU64, Everything},
+};
+use sp_core::{sr25519, H256};
+use sp_runtime::{
+	create_runtime_str, generic,
+	traits::{BlakeTwo256, IdentityLookup, Verify},
+};
+use sp_version::RuntimeVersion;
+
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: create_runtime_str!("frame-support-test-compile-pass"),
+	impl_name: create_runtime_str!("substrate-frame-support-test-compile-pass-runtime"),
+	authoring_version: 0,
+	spec_version: 0,
+	impl_version: 0,
+	apis: sp_version::create_apis_vec!([]),
+	transaction_version: 0,
+	state_version: 0,
+};
+
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type BlockNumber = u64;
+
+parameter_types! {
+	pub const Version: RuntimeVersion = VERSION;
+}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type Nonce = u128;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type Block = Block;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type BlockHashCount = ConstU64<2400>;
+	type Version = Version;
+	type AccountData = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type AccountId = AccountId;
+	type RuntimeEvent = RuntimeEvent;
+	type PalletInfo = PalletInfo;
+	type RuntimeCall = RuntimeCall;
+	type DbWeight = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+	type SystemWeightInfo = ();
+	type SS58Prefix = ConstU16<0>;
+}
+
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+construct_runtime!(
+	pub struct Runtime {
+		System: frame_system,
+	}
+);
diff --git a/substrate/frame/support/test/pallet/Cargo.toml b/substrate/frame/support/test/pallet/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..073b7510701522c9ed2c2ab153cc29ebc9a8db13
--- /dev/null
+++ b/substrate/frame/support/test/pallet/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "frame-support-test-pallet"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.0.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, features = ["derive"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../../primitives/runtime" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-runtime/std",
+]
diff --git a/substrate/frame/support/test/pallet/src/lib.rs b/substrate/frame/support/test/pallet/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..49450659285d7a1df529356d834d940f33f4a5c8
--- /dev/null
+++ b/substrate/frame/support/test/pallet/src/lib.rs
@@ -0,0 +1,56 @@
+// 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 basic pallet that can be used to test `construct_runtime!`.
+
+// Ensure docs are propagated properly by the macros.
+#![warn(missing_docs)]
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	/// I'm the documentation
+	#[pallet::storage]
+	pub type Value<T> = StorageValue<_, u32>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		#[serde(skip)]
+		_config: core::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {}
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Something failed
+		Test,
+	}
+}
diff --git a/substrate/frame/support/test/src/lib.rs b/substrate/frame/support/test/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6b38d42d33d0d06b0115ad887825ab31a294a70d
--- /dev/null
+++ b/substrate/frame/support/test/src/lib.rs
@@ -0,0 +1,143 @@
+// 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.
+
+//! Minimal pallet without `frame_system::Config`-super trait.
+
+// Make sure we fail compilation on warnings
+#![warn(missing_docs)]
+#![deny(warnings)]
+
+pub use frame_support::dispatch::RawOrigin;
+use frame_system::pallet_prelude::BlockNumberFor;
+
+pub use self::pallet::*;
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use super::*;
+	use crate::{self as frame_system, pallet_prelude::*};
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// The configuration trait.
+	#[pallet::config]
+	#[pallet::disable_frame_system_supertrait_check]
+	pub trait Config: 'static + Eq + Clone {
+		/// The block number type.
+		type BlockNumber: Parameter + Member + Default + MaybeSerializeDeserialize + MaxEncodedLen;
+		/// The account type.
+		type AccountId: Parameter + Member + MaxEncodedLen;
+		/// The basic call filter to use in Origin.
+		type BaseCallFilter: frame_support::traits::Contains<Self::RuntimeCall>;
+		/// The runtime origin type.
+		type RuntimeOrigin: Into<Result<RawOrigin<Self::AccountId>, Self::RuntimeOrigin>>
+			+ From<RawOrigin<Self::AccountId>>;
+		/// The runtime call type.
+		type RuntimeCall;
+		/// The runtime event type.
+		type RuntimeEvent: Parameter
+			+ Member
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>
+			+ From<Event<Self>>;
+		/// The information about the pallet setup in the runtime.
+		type PalletInfo: frame_support::traits::PalletInfo;
+		/// The db weights.
+		type DbWeight: Get<frame_support::weights::RuntimeDbWeight>;
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// A noop call.
+		pub fn noop(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		/// A empty method.
+		pub fn deposit_event(_event: impl Into<T::RuntimeEvent>) {}
+	}
+
+	/// The origin type.
+	#[pallet::origin]
+	pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
+
+	/// The error type.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Test error documentation
+		TestError,
+		/// Error documentation
+		/// with multiple lines
+		AnotherError,
+		/// Required by construct_runtime
+		CallFiltered,
+	}
+
+	/// The event type.
+	#[pallet::event]
+	pub enum Event<T: Config> {
+		/// The extrinsic is successful
+		ExtrinsicSuccess,
+		/// The extrinsic is failed
+		ExtrinsicFailed,
+		/// The ignored error
+		Ignore(<T as Config>::BlockNumber),
+	}
+}
+
+/// Ensure that the origin `o` represents the root. Returns `Ok` or an `Err` otherwise.
+pub fn ensure_root<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<(), &'static str>
+where
+	OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
+{
+	o.into().map(|_| ()).map_err(|_| "bad origin: expected to be a root origin")
+}
+
+/// Same semantic as [`frame_system`].
+// Note: we cannot use [`frame_system`] here since the pallet does not depend on
+// [`frame_system::Config`].
+pub mod pallet_prelude {
+	pub use crate::ensure_root;
+
+	/// Type alias for the `Origin` associated type of system config.
+	pub type OriginFor<T> = <T as crate::Config>::RuntimeOrigin;
+
+	/// Type alias for the `BlockNumber` associated type of system config.
+	pub type BlockNumberFor<T> = <T as super::Config>::BlockNumber;
+}
+
+/// Provides an implementation of [`frame_support::traits::Randomness`] that should only be used in
+/// tests!
+pub struct TestRandomness<T>(sp_std::marker::PhantomData<T>);
+
+impl<Output: codec::Decode + Default, T>
+	frame_support::traits::Randomness<Output, BlockNumberFor<T>> for TestRandomness<T>
+where
+	T: frame_system::Config,
+{
+	fn random(subject: &[u8]) -> (Output, BlockNumberFor<T>) {
+		use sp_runtime::traits::TrailingZeroInput;
+
+		(
+			Output::decode(&mut TrailingZeroInput::new(subject)).unwrap_or_default(),
+			frame_system::Pallet::<T>::block_number(),
+		)
+	}
+}
diff --git a/substrate/frame/support/test/tests/benchmark_ui.rs b/substrate/frame/support/test/tests/benchmark_ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa5fadd0e27bf591e1a1e5552dcfed0c0b4e316d
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui.rs
@@ -0,0 +1,36 @@
+// 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.
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn benchmark_ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if std::env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("SKIP_WASM_BUILD", "1");
+
+	// Deny all warnings since we emit warnings as part of a Pallet's UI.
+	std::env::set_var("RUSTFLAGS", "--deny warnings");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/benchmark_ui/*.rs");
+	t.pass("tests/benchmark_ui/pass/*.rs");
+}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_param_name.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..657e481a9430a51fdc04a01abfaad3306f4502df
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name.rs
@@ -0,0 +1,18 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench(winton: Linear<1, 2>) {
+		let a = 2 + 2;
+		#[block]
+		{}
+		assert_eq!(a, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_param_name.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4e2d63a6b5030f7a42a922ac95e1ee43d2032d11
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name.stderr
@@ -0,0 +1,5 @@
+error: Benchmark parameter names must consist of a single lowercase letter (a-z) and no other characters.
+  --> tests/benchmark_ui/bad_param_name.rs:10:11
+   |
+10 |     fn bench(winton: Linear<1, 2>) {
+   |              ^^^^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_too_long.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_too_long.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f970126d12e7e6a0e2f984173309fa54a894ca19
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_too_long.rs
@@ -0,0 +1,14 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benchmarks {
+	#[benchmark]
+	fn bench(xx: Linear<1, 2>) {
+		#[block]
+		{}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_too_long.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_too_long.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..32f6bf8e47d09f7e8ce9d79e50f38eaa0498c7e0
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_too_long.stderr
@@ -0,0 +1,5 @@
+error: Benchmark parameter names must consist of a single lowercase letter (a-z) and no other characters.
+ --> tests/benchmark_ui/bad_param_name_too_long.rs:8:11
+  |
+8 |     fn bench(xx: Linear<1, 2>) {
+  |              ^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_upper_case.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_upper_case.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9970f3230167244f9bbba2f705e7243f3a784a9e
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_upper_case.rs
@@ -0,0 +1,14 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	#[benchmark]
+	fn bench(D: Linear<1, 2>) {
+		#[block]
+		{}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_upper_case.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_upper_case.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..48dd41d3262d75642d991e36c032ef2bdea2eb3d
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_param_name_upper_case.stderr
@@ -0,0 +1,5 @@
+error: Benchmark parameter names must consist of a single lowercase letter (a-z) and no other characters.
+ --> tests/benchmark_ui/bad_param_name_upper_case.rs:8:11
+  |
+8 |     fn bench(D: Linear<1, 2>) {
+  |              ^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_params.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5049f2eae2c2edfe92777c5274a9bf551355f268
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_params.rs
@@ -0,0 +1,18 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench(y: Linear<1, 2>, x: u32) {
+		let a = 2 + 2;
+		#[block]
+		{}
+		assert_eq!(a, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_params.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_params.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..068eaedd531b9db0e867e57fa6fe462be5c23843
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_params.stderr
@@ -0,0 +1,5 @@
+error: Invalid benchmark function param. A valid example would be `x: Linear<5, 10>`.
+  --> tests/benchmark_ui/bad_params.rs:10:31
+   |
+10 |     fn bench(y: Linear<1, 2>, x: u32) {
+   |                                  ^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_benchmark_err.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_benchmark_err.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5e332801df8307ee1a9c3c23e21a02edf37a15bf
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_benchmark_err.rs
@@ -0,0 +1,19 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() -> Result<(), BenchmarkException> {
+		let a = 2 + 2;
+		#[block]
+		{}
+		assert_eq!(a, 4);
+		Ok(())
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_benchmark_err.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_benchmark_err.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..ab0bff54a8a0333bd0e80d9aedb16e2c771b3a4f
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_benchmark_err.stderr
@@ -0,0 +1,5 @@
+error: expected `BenchmarkError`
+  --> tests/benchmark_ui/bad_return_non_benchmark_err.rs:10:27
+   |
+10 |     fn bench() -> Result<(), BenchmarkException> {
+   |                              ^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_type_path.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_type_path.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a4b0d007eeecb218daf7cbbceabca52c2afbdf83
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_type_path.rs
@@ -0,0 +1,17 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn bench() -> (String, u32) {
+		#[block]
+		{}
+		(String::from("hey"), 23)
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_type_path.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_type_path.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..69d61b4229155e7092ef072d6fe4e8010de50df6
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_type_path.stderr
@@ -0,0 +1,5 @@
+error: Only `Result<(), BenchmarkError>` or a blank return type is allowed on benchmark function definitions
+  --> tests/benchmark_ui/bad_return_non_type_path.rs:10:16
+   |
+10 |     fn bench() -> (String, u32) {
+   |                   ^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_unit_t.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_unit_t.rs
new file mode 100644
index 0000000000000000000000000000000000000000..15289c298aec1558419a6ba9b41b8f36e9905eb9
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_unit_t.rs
@@ -0,0 +1,15 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benchmarks {
+	#[benchmark]
+	fn bench() -> Result<u32, BenchmarkError> {
+		#[block]
+		{}
+		Ok(10)
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_unit_t.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_unit_t.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4181ea099a14ffdfa4814a1d1b05d7d74a659c82
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_non_unit_t.stderr
@@ -0,0 +1,5 @@
+error: expected `()`
+ --> tests/benchmark_ui/bad_return_non_unit_t.rs:8:23
+  |
+8 |     fn bench() -> Result<u32, BenchmarkError> {
+  |                          ^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_blank_with_question.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_blank_with_question.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a6a2c61127fa2c03d11268db9659ec8a659c4bd0
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_blank_with_question.rs
@@ -0,0 +1,22 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	fn something() -> Result<(), BenchmarkError> {
+		Ok(())
+	}
+
+	#[benchmark]
+	fn bench() {
+		something()?;
+		#[block]
+		{}
+		assert_eq!(2 + 2, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_blank_with_question.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_blank_with_question.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..601bbd20fb73d404350205926c3d5f5f14b0e95e
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_blank_with_question.stderr
@@ -0,0 +1,10 @@
+error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
+  --> tests/benchmark_ui/bad_return_type_blank_with_question.rs:15:14
+   |
+5  | #[benchmarks]
+   | ------------- this function should return `Result` or `Option` to accept `?`
+...
+15 |         something()?;
+   |                    ^ cannot use the `?` operator in a function that returns `()`
+   |
+   = help: the trait `FromResidual<Result<Infallible, frame_benchmarking::BenchmarkError>>` is not implemented for `()`
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_no_last_stmt.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_no_last_stmt.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76f1299005309832dd834327ccdd60b26e6d85a9
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_no_last_stmt.rs
@@ -0,0 +1,16 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() -> Result<(), BenchmarkError> {
+		#[block]
+		{}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_no_last_stmt.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_no_last_stmt.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..ff501a620fe33fad0b67eac73d16396cfc9f6107
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_no_last_stmt.stderr
@@ -0,0 +1,9 @@
+error: Benchmark `#[block]` or `#[extrinsic_call]` item cannot be the last statement of your benchmark function definition if you have defined a return type. You should return something compatible with Result<(), BenchmarkError> (i.e. `Ok(())`) as the last statement or change your signature to a blank return type.
+  --> tests/benchmark_ui/bad_return_type_no_last_stmt.rs:10:43
+   |
+10 |       fn bench() -> Result<(), BenchmarkError> {
+   |  ______________________________________________^
+11 | |         #[block]
+12 | |         {}
+13 | |     }
+   | |_____^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_non_result.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_non_result.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c206ec36a151e24f4a91d62680e6436a01e8c032
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_non_result.rs
@@ -0,0 +1,19 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench(y: Linear<1, 2>) -> String {
+		let a = 2 + 2;
+		#[block]
+		{}
+		assert_eq!(a, 4);
+		String::from("test")
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_non_result.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_non_result.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b830b8eb59c636fe5a517271b9bd4919cc47bd8f
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_non_result.stderr
@@ -0,0 +1,5 @@
+error: expected `Result`
+  --> tests/benchmark_ui/bad_return_type_non_result.rs:10:31
+   |
+10 |     fn bench(y: Linear<1, 2>) -> String {
+   |                                  ^^^^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_option.rs b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_option.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b55885939747113ae1c715779c881148d142ce5
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_option.rs
@@ -0,0 +1,18 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() -> Option<BenchmarkError> {
+		#[block]
+		{}
+		assert_eq!(2 + 2, 4);
+		None
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_option.stderr b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_option.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..050da1676735a55c849650b84ed821f216d50ac3
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/bad_return_type_option.stderr
@@ -0,0 +1,5 @@
+error: expected `Result`
+  --> tests/benchmark_ui/bad_return_type_option.rs:10:16
+   |
+10 |     fn bench() -> Option<BenchmarkError> {
+   |                   ^^^^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/dup_block.rs b/substrate/frame/support/test/tests/benchmark_ui/dup_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2c2ef9db9a45c327d2f0aeedaf1bad42bc2b43a3
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/dup_block.rs
@@ -0,0 +1,20 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() {
+		let a = 2 + 2;
+		#[block]
+		{}
+		#[block]
+		{}
+		assert_eq!(a, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/dup_block.stderr b/substrate/frame/support/test/tests/benchmark_ui/dup_block.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..3d73c3d6609b15fafa543328a5a6e31f2d59fd26
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/dup_block.stderr
@@ -0,0 +1,5 @@
+error: Only one #[extrinsic_call] or #[block] attribute is allowed per benchmark.
+  --> tests/benchmark_ui/dup_block.rs:14:3
+   |
+14 |         #[block]
+   |         ^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/dup_extrinsic_call.rs b/substrate/frame/support/test/tests/benchmark_ui/dup_extrinsic_call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d135d1a04f527841b4dcd8793a15fd602f37c3b
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/dup_extrinsic_call.rs
@@ -0,0 +1,20 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() {
+		let a = 2 + 2;
+		#[extrinsic_call]
+		_(stuff);
+		#[extrinsic_call]
+		_(other_stuff);
+		assert_eq!(a, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/dup_extrinsic_call.stderr b/substrate/frame/support/test/tests/benchmark_ui/dup_extrinsic_call.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..593f7072bfa512f958e8106ec8f6a55fe60c1c5c
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/dup_extrinsic_call.stderr
@@ -0,0 +1,5 @@
+error: Only one #[extrinsic_call] or #[block] attribute is allowed per benchmark.
+  --> tests/benchmark_ui/dup_extrinsic_call.rs:14:3
+   |
+14 |         #[extrinsic_call]
+   |         ^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/empty_function.rs b/substrate/frame/support/test/tests/benchmark_ui/empty_function.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bc04101dd384a04409b7d2ab26a413d05435afd4
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/empty_function.rs
@@ -0,0 +1,13 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/empty_function.stderr b/substrate/frame/support/test/tests/benchmark_ui/empty_function.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..69d75303613d9ae5d88d71414eb626d5d3f6169a
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/empty_function.stderr
@@ -0,0 +1,5 @@
+error: No valid #[extrinsic_call] or #[block] annotation could be found in benchmark function body.
+  --> tests/benchmark_ui/empty_function.rs:10:13
+   |
+10 |     fn bench() {}
+   |                ^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/extra_extra.rs b/substrate/frame/support/test/tests/benchmark_ui/extra_extra.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1aa6c9ecb7526cd8f40b88118266863e9d96c18f
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/extra_extra.rs
@@ -0,0 +1,16 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark(extra, extra)]
+	fn bench() {
+		#[block]
+		{}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/extra_extra.stderr b/substrate/frame/support/test/tests/benchmark_ui/extra_extra.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..bf36b4f08054a7b78b6ebc98805b0eb2907e1c05
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/extra_extra.stderr
@@ -0,0 +1,5 @@
+error: unexpected end of input, `extra` can only be specified once
+ --> tests/benchmark_ui/extra_extra.rs:9:26
+  |
+9 |     #[benchmark(extra, extra)]
+  |                             ^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/extra_skip_meta.rs b/substrate/frame/support/test/tests/benchmark_ui/extra_skip_meta.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3418c7af73748f431278c154c7ca1c6699bd8614
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/extra_skip_meta.rs
@@ -0,0 +1,16 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark(skip_meta, skip_meta)]
+	fn bench() {
+		#[block]
+		{}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/extra_skip_meta.stderr b/substrate/frame/support/test/tests/benchmark_ui/extra_skip_meta.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4d48a8ad77a45a66d52cd05bd6b3046bbd2adac9
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/extra_skip_meta.stderr
@@ -0,0 +1,5 @@
+error: unexpected end of input, `skip_meta` can only be specified once
+ --> tests/benchmark_ui/extra_skip_meta.rs:9:34
+  |
+9 |     #[benchmark(skip_meta, skip_meta)]
+  |                                     ^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/extrinsic_call_out_of_fn.rs b/substrate/frame/support/test/tests/benchmark_ui/extrinsic_call_out_of_fn.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ce360ee7577f5f0503af2e9b87eb293166a7d66b
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/extrinsic_call_out_of_fn.rs
@@ -0,0 +1,6 @@
+use frame_benchmarking::v2::*;
+
+#[extrinsic_call]
+mod stuff {}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/extrinsic_call_out_of_fn.stderr b/substrate/frame/support/test/tests/benchmark_ui/extrinsic_call_out_of_fn.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c5194d7a66502cc980a6832d4bfe1fc407976f77
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/extrinsic_call_out_of_fn.stderr
@@ -0,0 +1,7 @@
+error: `#[extrinsic_call]` must be in a benchmark function definition labeled with `#[benchmark]`.
+ --> tests/benchmark_ui/extrinsic_call_out_of_fn.rs:3:1
+  |
+3 | #[extrinsic_call]
+  | ^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the attribute macro `extrinsic_call` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/benchmark_ui/invalid_origin.rs b/substrate/frame/support/test/tests/benchmark_ui/invalid_origin.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cfb00e88c00c0e07abd0180386b73c2d58bca02a
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/invalid_origin.rs
@@ -0,0 +1,17 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+use frame_support_test::Call;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() {
+		#[extrinsic_call]
+		noop(1);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/invalid_origin.stderr b/substrate/frame/support/test/tests/benchmark_ui/invalid_origin.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..115a8206f58a3683037f74fc0ce591db299327f2
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/invalid_origin.stderr
@@ -0,0 +1,8 @@
+error[E0277]: the trait bound `<T as frame_support_test::Config>::RuntimeOrigin: From<{integer}>` is not satisfied
+ --> tests/benchmark_ui/invalid_origin.rs:6:1
+  |
+6 | #[benchmarks]
+  | ^^^^^^^^^^^^^ the trait `From<{integer}>` is not implemented for `<T as frame_support_test::Config>::RuntimeOrigin`
+  |
+  = note: required for `{integer}` to implement `Into<<T as frame_support_test::Config>::RuntimeOrigin>`
+  = note: this error originates in the attribute macro `benchmarks` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/benchmark_ui/missing_call.rs b/substrate/frame/support/test/tests/benchmark_ui/missing_call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f39e74286b5cbe84e9cfa16ee3526f552730621d
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/missing_call.rs
@@ -0,0 +1,15 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() {
+		assert_eq!(2 + 2, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/missing_call.stderr b/substrate/frame/support/test/tests/benchmark_ui/missing_call.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..908d9704392271d02b136237b53859dae8ab8e78
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/missing_call.stderr
@@ -0,0 +1,8 @@
+error: No valid #[extrinsic_call] or #[block] annotation could be found in benchmark function body.
+  --> tests/benchmark_ui/missing_call.rs:10:13
+   |
+10 |       fn bench() {
+   |  ________________^
+11 | |         assert_eq!(2 + 2, 4);
+12 | |     }
+   | |_____^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/missing_origin.rs b/substrate/frame/support/test/tests/benchmark_ui/missing_origin.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2aaed756b9a46e894ee3f412b141dfa4d102ae17
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/missing_origin.rs
@@ -0,0 +1,16 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() {
+		#[extrinsic_call]
+		thing();
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/missing_origin.stderr b/substrate/frame/support/test/tests/benchmark_ui/missing_origin.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0e72bff4747a3f4deadb96eaa0dfb19a60923749
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/missing_origin.stderr
@@ -0,0 +1,5 @@
+error: Single-item extrinsic calls must specify their origin as the first argument.
+  --> tests/benchmark_ui/missing_origin.rs:12:3
+   |
+12 |         thing();
+   |         ^^^^^
diff --git a/substrate/frame/support/test/tests/benchmark_ui/pass/valid_basic.rs b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_basic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..450ce4f9c50da5eb1eb5457cff8092fe12c76d70
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_basic.rs
@@ -0,0 +1,17 @@
+use frame_benchmarking::v2::*;
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark(skip_meta, extra)]
+	fn bench() {
+		let a = 2 + 2;
+		#[block]
+		{}
+		assert_eq!(a, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/pass/valid_complex_path_benchmark_result.rs b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_complex_path_benchmark_result.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4930aedd6011e6b63848a825ae368935e71b0b6e
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_complex_path_benchmark_result.rs
@@ -0,0 +1,17 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() -> Result<(), frame_benchmarking::v2::BenchmarkError> {
+		#[block]
+		{}
+		Ok(())
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/pass/valid_const_expr.rs b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_const_expr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bead3bf277be269eb74aa6d17220f032cd6e1269
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_const_expr.rs
@@ -0,0 +1,28 @@
+use frame_benchmarking::v2::*;
+use frame_support_test::Config;
+use frame_support::parameter_types;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	const MY_CONST: u32 = 100;
+
+	const fn my_fn() -> u32 {
+		200
+	}
+
+	parameter_types! {
+		const MyConst: u32 = MY_CONST;
+	}
+
+	#[benchmark(skip_meta, extra)]
+	fn bench(a: Linear<{MY_CONST * 2}, {my_fn() + MyConst::get()}>) {
+		let a = 2 + 2;
+		#[block]
+		{}
+		assert_eq!(a, 4);
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/pass/valid_no_last_stmt.rs b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_no_last_stmt.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ce09b437a83bd42eb023a321d9ea1e913011a327
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_no_last_stmt.rs
@@ -0,0 +1,16 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() {
+		#[block]
+		{}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/pass/valid_path_result_benchmark_error.rs b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_path_result_benchmark_error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4930aedd6011e6b63848a825ae368935e71b0b6e
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_path_result_benchmark_error.rs
@@ -0,0 +1,17 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() -> Result<(), frame_benchmarking::v2::BenchmarkError> {
+		#[block]
+		{}
+		Ok(())
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/pass/valid_result.rs b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_result.rs
new file mode 100644
index 0000000000000000000000000000000000000000..33d71ece4a01812e61a7489d7cce72790050fd64
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/pass/valid_result.rs
@@ -0,0 +1,18 @@
+use frame_benchmarking::v2::*;
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark]
+	fn bench() -> Result<(), BenchmarkError> {
+		let a = 2 + 2;
+		#[block]
+		{}
+		assert_eq!(a, 4);
+		Ok(())
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/unrecognized_option.rs b/substrate/frame/support/test/tests/benchmark_ui/unrecognized_option.rs
new file mode 100644
index 0000000000000000000000000000000000000000..18cae4d5d5c8efacc49019710b4a6ec0260f2da6
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/unrecognized_option.rs
@@ -0,0 +1,16 @@
+use frame_benchmarking::v2::*;
+#[allow(unused_imports)]
+use frame_support_test::Config;
+
+#[benchmarks]
+mod benches {
+	use super::*;
+
+	#[benchmark(skip_meta, extra, bad)]
+	fn bench() {
+		#[block]
+		{}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/benchmark_ui/unrecognized_option.stderr b/substrate/frame/support/test/tests/benchmark_ui/unrecognized_option.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5cebe9eab05e905e7b0a958884427ffd9e361bc5
--- /dev/null
+++ b/substrate/frame/support/test/tests/benchmark_ui/unrecognized_option.stderr
@@ -0,0 +1,5 @@
+error: expected `extra` or `skip_meta`
+ --> tests/benchmark_ui/unrecognized_option.rs:9:32
+  |
+9 |     #[benchmark(skip_meta, extra, bad)]
+  |                                   ^^^
diff --git a/substrate/frame/support/test/tests/common/mod.rs b/substrate/frame/support/test/tests/common/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b02ecc1b6e1ddd00bcb6d02a653622fe624988b5
--- /dev/null
+++ b/substrate/frame/support/test/tests/common/mod.rs
@@ -0,0 +1,19 @@
+// 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.
+
+///! Common functionality between tests.
+pub mod outer_enums;
diff --git a/substrate/frame/support/test/tests/common/outer_enums.rs b/substrate/frame/support/test/tests/common/outer_enums.rs
new file mode 100644
index 0000000000000000000000000000000000000000..92dc7ac522079f9c3b06818788386c72b62ab7cd
--- /dev/null
+++ b/substrate/frame/support/test/tests/common/outer_enums.rs
@@ -0,0 +1,146 @@
+// 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.
+
+// Create 3 pallets for testing the outer error enum construction:
+//
+// - `pallet`: declares an error with `#[pallet::error]`
+// - `pallet2`: declares an error with `#[pallet::error]`
+// - `pallet3`: does not declare an error.
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// Something
+		Something(u32),
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		phantom: PhantomData<(T, I)>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			GenesisConfig { phantom: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {}
+	}
+
+	#[pallet::error]
+	#[derive(PartialEq, Eq)]
+	pub enum Error<T, I = ()> {
+		/// doc comment put into metadata
+		InsufficientProposersBalance,
+		NonExistentStorageValue,
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet2 {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// Something
+		Something(u32),
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		phantom: PhantomData<(T, I)>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			GenesisConfig { phantom: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {}
+	}
+
+	#[pallet::error]
+	#[derive(PartialEq, Eq)]
+	pub enum Error<T, I = ()> {
+		/// doc comment put into metadata
+		OtherInsufficientProposersBalance,
+		OtherNonExistentStorageValue,
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet3 {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// Something
+		Something(u32),
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		phantom: PhantomData<(T, I)>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			GenesisConfig { phantom: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {}
+	}
+}
diff --git a/substrate/frame/support/test/tests/construct_runtime.rs b/substrate/frame/support/test/tests/construct_runtime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a14276fa4d2ff5661663b9cc6a919c20f1d09d6d
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime.rs
@@ -0,0 +1,897 @@
+// 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.
+
+//! General tests for construct_runtime macro, test for:
+//! * error declared with decl_error works
+//! * integrity test is generated
+
+#![recursion_limit = "128"]
+
+use codec::MaxEncodedLen;
+use frame_support::{
+	derive_impl, parameter_types, traits::PalletInfo as _, weights::RuntimeDbWeight,
+};
+use frame_system::limits::{BlockLength, BlockWeights};
+use scale_info::TypeInfo;
+use sp_api::RuntimeVersion;
+use sp_core::{sr25519, ConstU64};
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, Verify},
+	DispatchError, ModuleError,
+};
+
+parameter_types! {
+	pub static IntegrityTestExec: u32 = 0;
+}
+
+#[frame_support::pallet(dev_mode)]
+mod module1 {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		pub fn fail(_origin: OriginFor<T>) -> DispatchResult {
+			Err(Error::<T, I>::Something.into())
+		}
+	}
+
+	#[pallet::origin]
+	#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	#[scale_info(skip_type_params(I))]
+	pub struct Origin<T, I = ()>(pub PhantomData<(T, I)>);
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		A(<T as frame_system::Config>::AccountId),
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		Something,
+	}
+}
+
+#[frame_support::pallet(dev_mode)]
+mod module2 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn integrity_test() {
+			IntegrityTestExec::mutate(|i| *i += 1);
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn fail(_origin: OriginFor<T>) -> DispatchResult {
+			Err(Error::<T>::Something.into())
+		}
+	}
+
+	#[pallet::origin]
+	#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub struct Origin;
+
+	#[pallet::event]
+	pub enum Event<T> {
+		A,
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		Something,
+	}
+}
+
+mod nested {
+	use super::*;
+
+	#[frame_support::pallet(dev_mode)]
+	pub mod module3 {
+		use super::*;
+		use frame_support::pallet_prelude::*;
+		use frame_system::pallet_prelude::*;
+
+		#[pallet::pallet]
+		pub struct Pallet<T>(_);
+
+		#[pallet::config]
+		pub trait Config: frame_system::Config {
+			type RuntimeEvent: From<Event<Self>>
+				+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		}
+
+		#[pallet::hooks]
+		impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+			fn integrity_test() {
+				IntegrityTestExec::mutate(|i| *i += 1);
+			}
+		}
+
+		#[pallet::call]
+		impl<T: Config> Pallet<T> {
+			pub fn fail(_origin: OriginFor<T>) -> DispatchResult {
+				Err(Error::<T>::Something.into())
+			}
+		}
+
+		#[pallet::origin]
+		#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+		pub struct Origin;
+
+		#[pallet::event]
+		pub enum Event<T> {
+			A,
+		}
+
+		#[pallet::error]
+		pub enum Error<T> {
+			Something,
+		}
+
+		#[pallet::genesis_config]
+		#[derive(frame_support::DefaultNoBound)]
+		pub struct GenesisConfig<T: Config> {
+			#[serde(skip)]
+			pub _config: sp_std::marker::PhantomData<T>,
+		}
+
+		#[pallet::genesis_build]
+		impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+			fn build(&self) {}
+		}
+	}
+}
+
+#[frame_support::pallet(dev_mode)]
+pub mod module3 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn fail(_origin: OriginFor<T>) -> DispatchResult {
+			Err(Error::<T>::Something.into())
+		}
+		pub fn aux_1(_origin: OriginFor<T>, #[pallet::compact] _data: u32) -> DispatchResult {
+			unreachable!()
+		}
+		pub fn aux_2(
+			_origin: OriginFor<T>,
+			_data: i32,
+			#[pallet::compact] _data2: u32,
+		) -> DispatchResult {
+			unreachable!()
+		}
+		#[pallet::weight(0)]
+		pub fn aux_3(_origin: OriginFor<T>, _data: i32, _data2: String) -> DispatchResult {
+			unreachable!()
+		}
+		#[pallet::weight(3)]
+		pub fn aux_4(_origin: OriginFor<T>) -> DispatchResult {
+			unreachable!()
+		}
+		#[pallet::weight((5, DispatchClass::Operational))]
+		pub fn operational(_origin: OriginFor<T>) -> DispatchResult {
+			unreachable!()
+		}
+	}
+
+	#[pallet::origin]
+	#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub struct Origin<T>(pub PhantomData<T>);
+
+	#[pallet::event]
+	pub enum Event<T> {
+		A,
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		Something,
+	}
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {}
+	}
+}
+
+pub type BlockNumber = u64;
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Event<T>, Origin<T>} = 30,
+		Module1_1: module1::<Instance1>::{Pallet, Call, Storage, Event<T>, Origin<T>},
+		Module2: module2::{Pallet, Call, Storage, Event<T>, Origin},
+		Module1_2: module1::<Instance2>::{Pallet, Call, Storage, Event<T>, Origin<T>},
+		NestedModule3: nested::module3::{Pallet, Call, Config<T>, Storage, Event<T>, Origin},
+		Module3: self::module3::{Pallet, Call, Config<T>, Storage, Event<T>, Origin<T>},
+		Module1_3: module1::<Instance3>::{Pallet, Storage, Event<T> } = 6,
+		Module1_4: module1::<Instance4>::{Pallet, Call, Event<T> } = 3,
+		Module1_5: module1::<Instance5>::{Pallet, Event<T>},
+		Module1_6: module1::<Instance6>::{Pallet, Call, Storage, Event<T>, Origin<T>} = 1,
+		Module1_7: module1::<Instance7>::{Pallet, Call, Storage, Event<T>, Origin<T>},
+		Module1_8: module1::<Instance8>::{Pallet, Call, Storage, Event<T>, Origin<T>} = 12,
+		Module1_9: module1::<Instance9>::{Pallet, Call, Storage, Event<T>, Origin<T>},
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Runtime {
+	type AccountId = AccountId;
+	type Lookup = sp_runtime::traits::IdentityLookup<AccountId>;
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+	type Block = Block;
+	type BlockHashCount = ConstU64<10>;
+}
+
+impl module1::Config<module1::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance2> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance3> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance4> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance5> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance6> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance7> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance8> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module1::Config<module1::Instance9> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module2::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl nested::module3::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module3::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+fn test_pub() -> AccountId {
+	AccountId::from_raw([0; 32])
+}
+
+#[test]
+fn check_modules_error_type() {
+	sp_io::TestExternalities::default().execute_with(|| {
+		assert_eq!(
+			Module1_1::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 31,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module2::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 32,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_2::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 33,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			NestedModule3::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 34,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_3::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 6,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_4::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 3,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_5::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 4,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_6::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 1,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_7::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 2,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_8::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 12,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+		assert_eq!(
+			Module1_9::fail(frame_system::Origin::<Runtime>::Root.into()),
+			Err(DispatchError::Module(ModuleError {
+				index: 13,
+				error: [0; 4],
+				message: Some("Something")
+			})),
+		);
+	})
+}
+
+#[test]
+fn integrity_test_works() {
+	__construct_runtime_integrity_test::runtime_integrity_tests();
+	assert_eq!(IntegrityTestExec::get(), 2);
+}
+
+#[test]
+fn origin_codec() {
+	use codec::Encode;
+
+	let origin = OriginCaller::system(frame_system::RawOrigin::None);
+	assert_eq!(origin.encode()[0], 30);
+
+	let origin = OriginCaller::Module1_1(module1::Origin(Default::default()));
+	assert_eq!(origin.encode()[0], 31);
+
+	let origin = OriginCaller::Module2(module2::Origin);
+	assert_eq!(origin.encode()[0], 32);
+
+	let origin = OriginCaller::Module1_2(module1::Origin(Default::default()));
+	assert_eq!(origin.encode()[0], 33);
+
+	let origin = OriginCaller::NestedModule3(nested::module3::Origin);
+	assert_eq!(origin.encode()[0], 34);
+
+	let origin = OriginCaller::Module3(module3::Origin(Default::default()));
+	assert_eq!(origin.encode()[0], 35);
+
+	let origin = OriginCaller::Module1_6(module1::Origin(Default::default()));
+	assert_eq!(origin.encode()[0], 1);
+
+	let origin = OriginCaller::Module1_7(module1::Origin(Default::default()));
+	assert_eq!(origin.encode()[0], 2);
+
+	let origin = OriginCaller::Module1_8(module1::Origin(Default::default()));
+	assert_eq!(origin.encode()[0], 12);
+
+	let origin = OriginCaller::Module1_9(module1::Origin(Default::default()));
+	assert_eq!(origin.encode()[0], 13);
+}
+
+#[test]
+fn event_codec() {
+	use codec::Encode;
+
+	let event =
+		frame_system::Event::<Runtime>::ExtrinsicSuccess { dispatch_info: Default::default() };
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 30);
+
+	let event = module1::Event::<Runtime, module1::Instance1>::A(test_pub());
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 31);
+
+	let event = module2::Event::A;
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 32);
+
+	let event = module1::Event::<Runtime, module1::Instance2>::A(test_pub());
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 33);
+
+	let event = nested::module3::Event::A;
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 34);
+
+	let event = module3::Event::A;
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 35);
+
+	let event = module1::Event::<Runtime, module1::Instance5>::A(test_pub());
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 4);
+
+	let event = module1::Event::<Runtime, module1::Instance6>::A(test_pub());
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 1);
+
+	let event = module1::Event::<Runtime, module1::Instance7>::A(test_pub());
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 2);
+
+	let event = module1::Event::<Runtime, module1::Instance8>::A(test_pub());
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 12);
+
+	let event = module1::Event::<Runtime, module1::Instance9>::A(test_pub());
+	assert_eq!(RuntimeEvent::from(event).encode()[0], 13);
+}
+
+#[test]
+fn call_codec() {
+	use codec::Encode;
+	assert_eq!(RuntimeCall::System(frame_system::Call::remark { remark: vec![1] }).encode()[0], 30);
+	assert_eq!(RuntimeCall::Module1_1(module1::Call::fail {}).encode()[0], 31);
+	assert_eq!(RuntimeCall::Module2(module2::Call::fail {}).encode()[0], 32);
+	assert_eq!(RuntimeCall::Module1_2(module1::Call::fail {}).encode()[0], 33);
+	assert_eq!(RuntimeCall::NestedModule3(nested::module3::Call::fail {}).encode()[0], 34);
+	assert_eq!(RuntimeCall::Module3(module3::Call::fail {}).encode()[0], 35);
+	assert_eq!(RuntimeCall::Module1_4(module1::Call::fail {}).encode()[0], 3);
+	assert_eq!(RuntimeCall::Module1_6(module1::Call::fail {}).encode()[0], 1);
+	assert_eq!(RuntimeCall::Module1_7(module1::Call::fail {}).encode()[0], 2);
+	assert_eq!(RuntimeCall::Module1_8(module1::Call::fail {}).encode()[0], 12);
+	assert_eq!(RuntimeCall::Module1_9(module1::Call::fail {}).encode()[0], 13);
+}
+
+#[test]
+fn call_compact_attr() {
+	use codec::Encode;
+	let call: module3::Call<Runtime> = module3::Call::aux_1 { data: 1 };
+	let encoded = call.encode();
+	assert_eq!(2, encoded.len());
+	assert_eq!(vec![1, 4], encoded);
+
+	let call: module3::Call<Runtime> = module3::Call::aux_2 { data: 1, data2: 2 };
+	let encoded = call.encode();
+	assert_eq!(6, encoded.len());
+	assert_eq!(vec![2, 1, 0, 0, 0, 8], encoded);
+}
+
+#[test]
+fn call_encode_is_correct_and_decode_works() {
+	use codec::{Decode, Encode};
+	let call: module3::Call<Runtime> = module3::Call::fail {};
+	let encoded = call.encode();
+	assert_eq!(vec![0], encoded);
+	let decoded = module3::Call::<Runtime>::decode(&mut &encoded[..]).unwrap();
+	assert_eq!(decoded, call);
+
+	let call: module3::Call<Runtime> = module3::Call::aux_3 { data: 32, data2: "hello".into() };
+	let encoded = call.encode();
+	assert_eq!(vec![3, 32, 0, 0, 0, 20, 104, 101, 108, 108, 111], encoded);
+	let decoded = module3::Call::<Runtime>::decode(&mut &encoded[..]).unwrap();
+	assert_eq!(decoded, call);
+}
+
+#[test]
+fn call_weight_should_attach_to_call_enum() {
+	use frame_support::{
+		dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays},
+		weights::Weight,
+	};
+	// operational.
+	assert_eq!(
+		module3::Call::<Runtime>::operational {}.get_dispatch_info(),
+		DispatchInfo {
+			weight: Weight::from_parts(5, 0),
+			class: DispatchClass::Operational,
+			pays_fee: Pays::Yes
+		},
+	);
+	// custom basic
+	assert_eq!(
+		module3::Call::<Runtime>::aux_4 {}.get_dispatch_info(),
+		DispatchInfo {
+			weight: Weight::from_parts(3, 0),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes
+		},
+	);
+}
+
+#[test]
+fn call_name() {
+	use frame_support::dispatch::GetCallName;
+	let name = module3::Call::<Runtime>::aux_4 {}.get_call_name();
+	assert_eq!("aux_4", name);
+}
+
+#[test]
+fn call_metadata() {
+	use frame_support::dispatch::{CallMetadata, GetCallMetadata};
+	let call = RuntimeCall::Module3(module3::Call::<Runtime>::aux_4 {});
+	let metadata = call.get_call_metadata();
+	let expected = CallMetadata { function_name: "aux_4".into(), pallet_name: "Module3".into() };
+	assert_eq!(metadata, expected);
+}
+
+#[test]
+fn get_call_names() {
+	use frame_support::dispatch::GetCallName;
+	let call_names = module3::Call::<Runtime>::get_call_names();
+	assert_eq!(["fail", "aux_1", "aux_2", "aux_3", "aux_4", "operational"], call_names);
+}
+
+#[test]
+fn get_module_names() {
+	use frame_support::dispatch::GetCallMetadata;
+	let module_names = RuntimeCall::get_module_names();
+	assert_eq!(
+		[
+			"System",
+			"Module1_1",
+			"Module2",
+			"Module1_2",
+			"NestedModule3",
+			"Module3",
+			"Module1_4",
+			"Module1_6",
+			"Module1_7",
+			"Module1_8",
+			"Module1_9",
+		],
+		module_names
+	);
+}
+
+#[test]
+fn call_subtype_conversion() {
+	use frame_support::{dispatch::CallableCallFor, traits::IsSubType};
+	let call = RuntimeCall::Module3(module3::Call::<Runtime>::fail {});
+	let subcall: Option<&CallableCallFor<Module3, Runtime>> = call.is_sub_type();
+	let subcall_none: Option<&CallableCallFor<Module2, Runtime>> = call.is_sub_type();
+	assert_eq!(Some(&module3::Call::<Runtime>::fail {}), subcall);
+	assert_eq!(None, subcall_none);
+
+	let from = RuntimeCall::from(subcall.unwrap().clone());
+	assert_eq!(from, call);
+}
+
+#[test]
+fn test_metadata() {
+	use frame_metadata::{v14::*, *};
+	use scale_info::meta_type;
+	use sp_core::Encode;
+
+	fn maybe_docs(doc: Vec<&'static str>) -> Vec<&'static str> {
+		if cfg!(feature = "no-metadata-docs") {
+			vec![]
+		} else {
+			doc
+		}
+	}
+
+	let pallets = vec![
+		PalletMetadata {
+			name: "System",
+			storage: None,
+			calls: Some(meta_type::<frame_system::Call<Runtime>>().into()),
+			event: Some(meta_type::<frame_system::Event<Runtime>>().into()),
+			constants: vec![
+				PalletConstantMetadata {
+					name: "BlockWeights",
+					ty: meta_type::<BlockWeights>(),
+					value: BlockWeights::default().encode(),
+					docs: maybe_docs(vec![" Block & extrinsics weights: base values and limits."]),
+				},
+				PalletConstantMetadata {
+					name: "BlockLength",
+					ty: meta_type::<BlockLength>(),
+					value: BlockLength::default().encode(),
+					docs: maybe_docs(vec![" The maximum length of a block (in bytes)."]),
+				},
+				PalletConstantMetadata {
+					name: "BlockHashCount",
+					ty: meta_type::<u64>(),
+					value: 10u64.encode(),
+					docs: maybe_docs(vec![" Maximum number of block number to block hash mappings to keep (oldest pruned first)."]),
+				},
+				PalletConstantMetadata {
+					name: "DbWeight",
+					ty: meta_type::<RuntimeDbWeight>(),
+					value: RuntimeDbWeight::default().encode(),
+					docs: maybe_docs(vec![" The weight of runtime database operations the runtime can invoke.",]),
+				},
+				PalletConstantMetadata {
+					name: "Version",
+					ty: meta_type::<RuntimeVersion>(),
+					value: RuntimeVersion::default().encode(),
+					docs: maybe_docs(vec![ " Get the chain's current version."]),
+				},
+				PalletConstantMetadata {
+					name: "SS58Prefix",
+					ty: meta_type::<u16>(),
+					value: 0u16.encode(),
+					docs: maybe_docs(vec![
+						" The designated SS58 prefix of this chain.",
+						"",
+						" This replaces the \"ss58Format\" property declared in the chain spec. Reason is",
+						" that the runtime should know about the prefix in order to make use of it as",
+						" an identifier of the chain.",
+					]),
+				},
+			],
+			error: Some(meta_type::<frame_system::Error<Runtime>>().into()),
+			index: 30,
+		},
+		PalletMetadata {
+			name: "Module1_1",
+			storage: Some(PalletStorageMetadata { prefix: "Module1_1", entries: vec![] }),
+			calls: Some(meta_type::<module1::Call<Runtime, module1::Instance1>>().into()),
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance1>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime>>().into()),
+			index: 31,
+		},
+		PalletMetadata {
+			name: "Module2",
+			storage: Some(PalletStorageMetadata { prefix: "Module2", entries: vec![] }),
+			calls: Some(meta_type::<module2::Call<Runtime>>().into()),
+			event: Some(meta_type::<module2::Event<Runtime>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module2::Error<Runtime>>().into()),
+			index: 32,
+		},
+		PalletMetadata {
+			name: "Module1_2",
+			storage: Some(PalletStorageMetadata { prefix: "Module1_2", entries: vec![] }),
+			calls: Some(meta_type::<module1::Call<Runtime, module1::Instance2>>().into()),
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance2>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance2>>().into()),
+			index: 33,
+		},
+		PalletMetadata {
+			name: "NestedModule3",
+			storage: Some(PalletStorageMetadata { prefix: "NestedModule3", entries: vec![] }),
+			calls: Some(meta_type::<nested::module3::Call<Runtime>>().into()),
+			event: Some(meta_type::<nested::module3::Event<Runtime>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<nested::module3::Error<Runtime>>().into()),
+			index: 34,
+		},
+		PalletMetadata {
+			name: "Module3",
+			storage: Some(PalletStorageMetadata { prefix: "Module3", entries: vec![] }),
+			calls: Some(meta_type::<module3::Call<Runtime>>().into()),
+			event: Some(meta_type::<module3::Event<Runtime>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module3::Error<Runtime>>().into()),
+			index: 35,
+		},
+		PalletMetadata {
+			name: "Module1_3",
+			storage: Some(PalletStorageMetadata { prefix: "Module1_3", entries: vec![] }),
+			calls: None,
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance3>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance3>>().into()),
+			index: 6,
+		},
+		PalletMetadata {
+			name: "Module1_4",
+			storage: None,
+			calls: Some(meta_type::<module1::Call<Runtime, module1::Instance4>>().into()),
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance4>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance4>>().into()),
+			index: 3,
+		},
+		PalletMetadata {
+			name: "Module1_5",
+			storage: None,
+			calls: None,
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance5>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance5>>().into()),
+			index: 4,
+		},
+		PalletMetadata {
+			name: "Module1_6",
+			storage: Some(PalletStorageMetadata { prefix: "Module1_6", entries: vec![] }),
+			calls: Some(meta_type::<module1::Call<Runtime, module1::Instance6>>().into()),
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance6>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance6>>().into()),
+			index: 1,
+		},
+		PalletMetadata {
+			name: "Module1_7",
+			storage: Some(PalletStorageMetadata { prefix: "Module1_7", entries: vec![] }),
+			calls: Some(meta_type::<module1::Call<Runtime, module1::Instance7>>().into()),
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance7>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance7>>().into()),
+			index: 2,
+		},
+		PalletMetadata {
+			name: "Module1_8",
+			storage: Some(PalletStorageMetadata { prefix: "Module1_8", entries: vec![] }),
+			calls: Some(meta_type::<module1::Call<Runtime, module1::Instance8>>().into()),
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance8>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance8>>().into()),
+			index: 12,
+		},
+		PalletMetadata {
+			name: "Module1_9",
+			storage: Some(PalletStorageMetadata { prefix: "Module1_9", entries: vec![] }),
+			calls: Some(meta_type::<module1::Call<Runtime, module1::Instance9>>().into()),
+			event: Some(meta_type::<module1::Event<Runtime, module1::Instance9>>().into()),
+			constants: vec![],
+			error: Some(meta_type::<module1::Error<Runtime, module1::Instance9>>().into()),
+			index: 13,
+		},
+	];
+
+	let extrinsic = ExtrinsicMetadata {
+		ty: meta_type::<UncheckedExtrinsic>(),
+		version: 4,
+		signed_extensions: vec![SignedExtensionMetadata {
+			identifier: "UnitSignedExtension",
+			ty: meta_type::<()>(),
+			additional_signed: meta_type::<()>(),
+		}],
+	};
+
+	let expected_metadata: RuntimeMetadataPrefixed =
+		RuntimeMetadataLastVersion::new(pallets, extrinsic, meta_type::<Runtime>()).into();
+	let actual_metadata = Runtime::metadata();
+
+	pretty_assertions::assert_eq!(actual_metadata, expected_metadata);
+}
+
+#[test]
+fn pallet_in_runtime_is_correct() {
+	assert_eq!(PalletInfo::index::<System>().unwrap(), 30);
+	assert_eq!(PalletInfo::name::<System>().unwrap(), "System");
+	assert_eq!(PalletInfo::module_name::<System>().unwrap(), "frame_system");
+	assert!(PalletInfo::crate_version::<System>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_1>().unwrap(), 31);
+	assert_eq!(PalletInfo::name::<Module1_1>().unwrap(), "Module1_1");
+	assert_eq!(PalletInfo::module_name::<Module1_1>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_1>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module2>().unwrap(), 32);
+	assert_eq!(PalletInfo::name::<Module2>().unwrap(), "Module2");
+	assert_eq!(PalletInfo::module_name::<Module2>().unwrap(), "module2");
+	assert!(PalletInfo::crate_version::<Module2>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_2>().unwrap(), 33);
+	assert_eq!(PalletInfo::name::<Module1_2>().unwrap(), "Module1_2");
+	assert_eq!(PalletInfo::module_name::<Module1_2>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_2>().is_some());
+
+	assert_eq!(PalletInfo::index::<NestedModule3>().unwrap(), 34);
+	assert_eq!(PalletInfo::name::<NestedModule3>().unwrap(), "NestedModule3");
+	assert_eq!(PalletInfo::module_name::<NestedModule3>().unwrap(), "nested::module3");
+	assert!(PalletInfo::crate_version::<NestedModule3>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module3>().unwrap(), 35);
+	assert_eq!(PalletInfo::name::<Module3>().unwrap(), "Module3");
+	assert_eq!(PalletInfo::module_name::<Module3>().unwrap(), "self::module3");
+	assert!(PalletInfo::crate_version::<Module3>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_3>().unwrap(), 6);
+	assert_eq!(PalletInfo::name::<Module1_3>().unwrap(), "Module1_3");
+	assert_eq!(PalletInfo::module_name::<Module1_3>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_3>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_4>().unwrap(), 3);
+	assert_eq!(PalletInfo::name::<Module1_4>().unwrap(), "Module1_4");
+	assert_eq!(PalletInfo::module_name::<Module1_4>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_4>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_5>().unwrap(), 4);
+	assert_eq!(PalletInfo::name::<Module1_5>().unwrap(), "Module1_5");
+	assert_eq!(PalletInfo::module_name::<Module1_5>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_5>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_6>().unwrap(), 1);
+	assert_eq!(PalletInfo::name::<Module1_6>().unwrap(), "Module1_6");
+	assert_eq!(PalletInfo::module_name::<Module1_6>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_6>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_7>().unwrap(), 2);
+	assert_eq!(PalletInfo::name::<Module1_7>().unwrap(), "Module1_7");
+	assert_eq!(PalletInfo::module_name::<Module1_7>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_7>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_8>().unwrap(), 12);
+	assert_eq!(PalletInfo::name::<Module1_8>().unwrap(), "Module1_8");
+	assert_eq!(PalletInfo::module_name::<Module1_8>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_8>().is_some());
+
+	assert_eq!(PalletInfo::index::<Module1_9>().unwrap(), 13);
+	assert_eq!(PalletInfo::name::<Module1_9>().unwrap(), "Module1_9");
+	assert_eq!(PalletInfo::module_name::<Module1_9>().unwrap(), "module1");
+	assert!(PalletInfo::crate_version::<Module1_9>().is_some());
+}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui.rs b/substrate/frame/support/test/tests/construct_runtime_ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec6758f4b295fd9ced4c70e4f5cc27ce1ddbd3a6
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui.rs
@@ -0,0 +1,32 @@
+// 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.
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if std::env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("SKIP_WASM_BUILD", "1");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/construct_runtime_ui/*.rs");
+}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/abundant_where_param.rs b/substrate/frame/support/test/tests/construct_runtime_ui/abundant_where_param.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ab55c22e9fbf19c10befe81585c322eeede4d0aa
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/abundant_where_param.rs
@@ -0,0 +1,12 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		Block = Block,
+		NodeBlock = Block,
+		Block = Block1,
+		UncheckedExtrinsic = Uxt,
+	{}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/abundant_where_param.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/abundant_where_param.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b622adbfe65b417865827af90ab13397ddad0a85
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/abundant_where_param.stderr
@@ -0,0 +1,5 @@
+error: `Block` was declared above. Please use exactly one declaration for `Block`.
+ --> $DIR/abundant_where_param.rs:7:3
+  |
+7 |         Block = Block1,
+  |         ^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/both_use_and_excluded_parts.rs b/substrate/frame/support/test/tests/construct_runtime_ui/both_use_and_excluded_parts.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4cb249714650e8b7dcee376e0342b13c5d273a39
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/both_use_and_excluded_parts.rs
@@ -0,0 +1,30 @@
+use frame_support::construct_runtime;
+use sp_runtime::{generic, traits::BlakeTwo256};
+use sp_core::sr25519;
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u64;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet exclude_parts { Pallet } use_parts { Pallet },
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/both_use_and_excluded_parts.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/both_use_and_excluded_parts.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1ea62b7d6fd653faee0f8d111b757512047a6df1
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/both_use_and_excluded_parts.stderr
@@ -0,0 +1,22 @@
+error: Unexpected tokens, expected one of `=`, `,`
+  --> tests/construct_runtime_ui/both_use_and_excluded_parts.rs:26:43
+   |
+26 |         Pallet: pallet exclude_parts { Pallet } use_parts { Pallet },
+   |                                                 ^^^^^^^^^
+
+error[E0412]: cannot find type `RuntimeCall` in this scope
+  --> tests/construct_runtime_ui/both_use_and_excluded_parts.rs:18:64
+   |
+18 | pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                                                                ^^^^^^^^^^^ not found in this scope
+   |
+help: you might be missing a type parameter
+   |
+18 | pub type UncheckedExtrinsic<RuntimeCall> = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                            +++++++++++++
+
+error[E0412]: cannot find type `Runtime` in this scope
+  --> tests/construct_runtime_ui/both_use_and_excluded_parts.rs:20:25
+   |
+20 | impl pallet::Config for Runtime {}
+   |                         ^^^^^^^ not found in this scope
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index.rs b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index.rs
new file mode 100644
index 0000000000000000000000000000000000000000..712452d1a3a43c43daa641b78b532d3ce4bfdf30
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index.rs
@@ -0,0 +1,14 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		UncheckedExtrinsic = UncheckedExtrinsic,
+		Block = Block,
+		NodeBlock = Block,
+	{
+		System: system::{},
+		Pallet1: pallet1::{} = 0,
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..2e2028fd1b862bb40c7854ed8b11137f426403b7
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index.stderr
@@ -0,0 +1,11 @@
+error: Pallet indices are conflicting: Both pallets System and Pallet1 are at index 0
+ --> $DIR/conflicting_index.rs:9:3
+  |
+9 |         System: system::{},
+  |         ^^^^^^
+
+error: Pallet indices are conflicting: Both pallets System and Pallet1 are at index 0
+  --> $DIR/conflicting_index.rs:10:3
+   |
+10 |         Pallet1: pallet1::{} = 0,
+   |         ^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index_2.rs b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index_2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6bc6bc5402e9aa0ee7d9f7483d5beb176ddf3245
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index_2.rs
@@ -0,0 +1,16 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		UncheckedExtrinsic = UncheckedExtrinsic,
+		Block = Block,
+		NodeBlock = Block,
+	{
+		System: system::{} = 5,
+		Pallet1: pallet1::{} = 3,
+		Pallet2: pallet2::{},
+		Pallet3: pallet3::{},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index_2.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index_2.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..bfa3706a456a4540d6e20631d43542f1099cd6ca
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_index_2.stderr
@@ -0,0 +1,11 @@
+error: Pallet indices are conflicting: Both pallets System and Pallet3 are at index 5
+ --> $DIR/conflicting_index_2.rs:9:3
+  |
+9 |         System: system::{} = 5,
+  |         ^^^^^^
+
+error: Pallet indices are conflicting: Both pallets System and Pallet3 are at index 5
+  --> $DIR/conflicting_index_2.rs:12:3
+   |
+12 |         Pallet3: pallet3::{},
+   |         ^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_module_name.rs b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_module_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..513fbcfb5135402d7c34e4e0d4391f093eb4d4ef
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_module_name.rs
@@ -0,0 +1,12 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet},
+		Balance: balances::{Pallet},
+		Balance: balances::{Pallet},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_module_name.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_module_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..6fb983f03a9610e66779b2d8e9011797a0b87948
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/conflicting_module_name.stderr
@@ -0,0 +1,11 @@
+error: Two pallets with the same name!
+ --> tests/construct_runtime_ui/conflicting_module_name.rs:7:3
+  |
+7 |         Balance: balances::{Pallet},
+  |         ^^^^^^^
+
+error: Two pallets with the same name!
+ --> tests/construct_runtime_ui/conflicting_module_name.rs:8:3
+  |
+8 |         Balance: balances::{Pallet},
+  |         ^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/deprecated_where_block.rs b/substrate/frame/support/test/tests/construct_runtime_ui/deprecated_where_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c0e325085b5e5b0a32c7a37cc35b81ceae11ef5b
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/deprecated_where_block.rs
@@ -0,0 +1,13 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		Block = Block,
+		NodeBlock = Block,
+		UncheckedExtrinsic = Uxt,
+	{
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/deprecated_where_block.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/deprecated_where_block.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0aee2cbceb9a11ed6d7826e2b1fc1e602399d9be
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/deprecated_where_block.stderr
@@ -0,0 +1,442 @@
+error: use of deprecated constant `WhereSection::_w`:
+               It is deprecated to use a `where` clause in `construct_runtime`.
+               Please instead use `frame_system::Config` to set the `Block` type and delete this clause.
+               It is planned to be removed in December 2023.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/14437>
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | / construct_runtime! {
+4  | |     pub struct Runtime where
+5  | |         Block = Block,
+6  | |         NodeBlock = Block,
+...  |
+10 | |     }
+11 | | }
+   | |_^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+   = note: this error originates in the macro `frame_support::match_and_insert` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+note: required by a bound in `frame_system::Event`
+  --> $WORKSPACE/frame/system/src/lib.rs
+   |
+   |     pub enum Event<T: Config> {
+   |                       ^^^^^^ required by this bound in `Event`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied in `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+note: required because it appears within the type `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `Clone`
+  --> $RUST/core/src/clone.rs
+   |
+   | pub trait Clone: Sized {
+   |                  ^^^^^ required by this bound in `Clone`
+   = note: this error originates in the derive macro `Clone` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied in `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+note: required because it appears within the type `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `EncodeLike`
+  --> $CARGO/parity-scale-codec-3.6.1/src/encode_like.rs
+   |
+   | pub trait EncodeLike<T: Encode = Self>: Sized + Encode {}
+   |                                         ^^^^^ required by this bound in `EncodeLike`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied in `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+note: required because it appears within the type `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `Decode`
+  --> $CARGO/parity-scale-codec-3.6.1/src/codec.rs
+   |
+   | pub trait Decode: Sized {
+   |                   ^^^^^ required by this bound in `Decode`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied in `frame_system::Event<Runtime>`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = note: required because it appears within the type `Event<Runtime>`
+note: required by a bound in `From`
+  --> $RUST/core/src/convert/mod.rs
+   |
+   | pub trait From<T>: Sized {
+   |                ^ required by this bound in `From`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied in `frame_system::Event<Runtime>`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = note: required because it appears within the type `Event<Runtime>`
+note: required by a bound in `TryInto`
+  --> $RUST/core/src/convert/mod.rs
+   |
+   | pub trait TryInto<T>: Sized {
+   |                   ^ required by this bound in `TryInto`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+ --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+  |
+3 | construct_runtime! {
+  | ^ the trait `Config` is not implemented for `Runtime`
+  |
+  = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `RawOrigin<_>: TryFrom<OriginCaller>` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = help: the trait `TryFrom<OriginCaller>` is implemented for `RawOrigin<<Runtime as Config>::AccountId>`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = help: the trait `Callable<T>` is implemented for `Pallet<T>`
+   = note: required for `Pallet<Runtime>` to implement `Callable<Runtime>`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = note: required for `Pallet<Runtime>` to implement `Callable<Runtime>`
+note: required because it appears within the type `RuntimeCall`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `Clone`
+  --> $RUST/core/src/clone.rs
+   |
+   | pub trait Clone: Sized {
+   |                  ^^^^^ required by this bound in `Clone`
+   = note: this error originates in the derive macro `Clone` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = note: required for `Pallet<Runtime>` to implement `Callable<Runtime>`
+note: required because it appears within the type `RuntimeCall`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `EncodeLike`
+  --> $CARGO/parity-scale-codec-3.6.1/src/encode_like.rs
+   |
+   | pub trait EncodeLike<T: Encode = Self>: Sized + Encode {}
+   |                                         ^^^^^ required by this bound in `EncodeLike`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = note: required for `Pallet<Runtime>` to implement `Callable<Runtime>`
+note: required because it appears within the type `RuntimeCall`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `Decode`
+  --> $CARGO/parity-scale-codec-3.6.1/src/codec.rs
+   |
+   | pub trait Decode: Sized {
+   |                   ^^^^^ required by this bound in `Decode`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+ --> tests/construct_runtime_ui/deprecated_where_block.rs:9:3
+  |
+9 |         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+  |         ^^^^^^ the trait `Config` is not implemented for `Runtime`
+  |
+note: required by a bound in `frame_system::GenesisConfig`
+ --> $WORKSPACE/frame/system/src/lib.rs
+  |
+  |     pub struct GenesisConfig<T: Config> {
+  |                                 ^^^^^^ required by this bound in `GenesisConfig`
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied in `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+note: required because it appears within the type `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `Result`
+  --> $RUST/core/src/result.rs
+   |
+   | pub enum Result<T, E> {
+   |                 ^ required by this bound in `Result`
+   = note: this error originates in the derive macro `self::sp_api_hidden_includes_construct_runtime::hidden_include::__private::codec::Decode` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied in `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+note: required because it appears within the type `RuntimeEvent`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `TryInto`
+  --> $RUST/core/src/convert/mod.rs
+   |
+   | pub trait TryInto<T>: Sized {
+   |                       ^^^^^ required by this bound in `TryInto`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `Runtime: Config` is not satisfied
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = note: required for `Pallet<Runtime>` to implement `Callable<Runtime>`
+note: required because it appears within the type `RuntimeCall`
+  --> tests/construct_runtime_ui/deprecated_where_block.rs:3:1
+   |
+3  | // construct_runtime! {
+4  | ||     pub struct Runtime where
+5  | ||         Block = Block,
+6  | ||         NodeBlock = Block,
+...  ||
+10 | ||     }
+11 | || }
+   | ||_- in this macro invocation
+...  |
+note: required by a bound in `Result`
+  --> $RUST/core/src/result.rs
+   |
+   | pub enum Result<T, E> {
+   |                 ^ required by this bound in `Result`
+   = note: this error originates in the derive macro `self::sp_api_hidden_includes_construct_runtime::hidden_include::__private::codec::Decode` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/double_module_parts.rs b/substrate/frame/support/test/tests/construct_runtime_ui/double_module_parts.rs
new file mode 100644
index 0000000000000000000000000000000000000000..68a2523d3bcb2f8accc4c611bec0bb082096c431
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/double_module_parts.rs
@@ -0,0 +1,11 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet},
+		Balance: balances::{Config, Call, Config<T>, Origin<T>},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/double_module_parts.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/double_module_parts.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e3f694781441ff4e4dc55c95cbbcd05f282c5dbf
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/double_module_parts.stderr
@@ -0,0 +1,5 @@
+error: `Config` was already declared before. Please remove the duplicate declaration
+ --> tests/construct_runtime_ui/double_module_parts.rs:7:37
+  |
+7 |         Balance: balances::{Config, Call, Config<T>, Origin<T>},
+  |                                           ^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/duplicate_exclude.rs b/substrate/frame/support/test/tests/construct_runtime_ui/duplicate_exclude.rs
new file mode 100644
index 0000000000000000000000000000000000000000..83e708841aaf2dcaf69180dac7177381c362f791
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/duplicate_exclude.rs
@@ -0,0 +1,13 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		UncheckedExtrinsic = UncheckedExtrinsic,
+		Block = Block,
+		NodeBlock = Block,
+	{
+		System: frame_system exclude_parts { Call, Call },
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/duplicate_exclude.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/duplicate_exclude.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..75de56076528b220c630477ff466dea2258e3765
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/duplicate_exclude.stderr
@@ -0,0 +1,5 @@
+error: `Call` was already declared before. Please remove the duplicate declaration
+ --> $DIR/duplicate_exclude.rs:9:46
+  |
+9 |         System: frame_system exclude_parts { Call, Call },
+  |                                                    ^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/empty_pallet_path.rs b/substrate/frame/support/test/tests/construct_runtime_ui/empty_pallet_path.rs
new file mode 100644
index 0000000000000000000000000000000000000000..23badd76276e21b780067126f74dc1a01c4bcc31
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/empty_pallet_path.rs
@@ -0,0 +1,10 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		system: ,
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/empty_pallet_path.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/empty_pallet_path.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f0c0f17779d6756ce345569d4cbc6be351ddd81c
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/empty_pallet_path.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `crate`, `self`, `super`, identifier
+ --> tests/construct_runtime_ui/empty_pallet_path.rs:6:11
+  |
+6 |         system: ,
+  |                 ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/exclude_missspell.rs b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_missspell.rs
new file mode 100644
index 0000000000000000000000000000000000000000..441e9c75040c530ae856855a24fe99cbb29317a9
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_missspell.rs
@@ -0,0 +1,13 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		UncheckedExtrinsic = UncheckedExtrinsic,
+		Block = Block,
+		NodeBlock = Block,
+	{
+		System: frame_system exclude_part { Call },
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/exclude_missspell.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_missspell.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..82e6aa6c8e3089a745b2581bba6907e7471a53f5
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_missspell.stderr
@@ -0,0 +1,5 @@
+error: Unexpected tokens, expected one of `::$ident` `::{`, `exclude_parts`, `use_parts`, `=`, `,`
+ --> $DIR/exclude_missspell.rs:9:24
+  |
+9 |         System: frame_system exclude_part { Call },
+  |                              ^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/exclude_undefined_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_undefined_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..10cda7b4e7e8a50f3f7ad1ff2eea295620868045
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_undefined_part.rs
@@ -0,0 +1,35 @@
+use frame_support::construct_runtime;
+use sp_runtime::{generic, traits::BlakeTwo256};
+use sp_core::sr25519;
+
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<Value=u8>;
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u64;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet exclude_parts { Call },
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/exclude_undefined_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_undefined_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4b85613838ab5e127a740946c6e37cd6e8a53539
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/exclude_undefined_part.stderr
@@ -0,0 +1,22 @@
+error: Invalid pallet part specified, the pallet `Pallet` doesn't have the `Call` part. Available parts are: `Pallet`, `Storage`.
+  --> tests/construct_runtime_ui/exclude_undefined_part.rs:31:34
+   |
+31 |         Pallet: pallet exclude_parts { Call },
+   |                                        ^^^^
+
+error[E0412]: cannot find type `RuntimeCall` in this scope
+  --> tests/construct_runtime_ui/exclude_undefined_part.rs:23:64
+   |
+23 | pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                                                                ^^^^^^^^^^^ not found in this scope
+   |
+help: you might be missing a type parameter
+   |
+23 | pub type UncheckedExtrinsic<RuntimeCall> = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                            +++++++++++++
+
+error[E0412]: cannot find type `Runtime` in this scope
+  --> tests/construct_runtime_ui/exclude_undefined_part.rs:25:25
+   |
+25 | impl pallet::Config for Runtime {}
+   |                         ^^^^^^^ not found in this scope
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/feature_gated_system_pallet.rs b/substrate/frame/support/test/tests/construct_runtime_ui/feature_gated_system_pallet.rs
new file mode 100644
index 0000000000000000000000000000000000000000..35d49a4d8a23b172244e6ded301df7fc9f786e97
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/feature_gated_system_pallet.rs
@@ -0,0 +1,11 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		#[cfg(test)]
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/feature_gated_system_pallet.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/feature_gated_system_pallet.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..6a6c4b415888935d9a122a84881ae5bb3ebd8b4f
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/feature_gated_system_pallet.stderr
@@ -0,0 +1,5 @@
+error: `System` pallet declaration is feature gated, please remove any `#[cfg]` attributes
+ --> tests/construct_runtime_ui/feature_gated_system_pallet.rs:7:3
+  |
+7 |         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+  |         ^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/generics_in_invalid_module.rs b/substrate/frame/support/test/tests/construct_runtime_ui/generics_in_invalid_module.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ad1f8e0b1d5f6af667974aa67b8088d5754fbb3
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/generics_in_invalid_module.rs
@@ -0,0 +1,11 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet},
+		Balance: balances::<Instance1>::{Call<T>, Origin<T>},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/generics_in_invalid_module.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/generics_in_invalid_module.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..a6adb37d0494999b13e0dbfd66aa48a058f2bce2
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/generics_in_invalid_module.stderr
@@ -0,0 +1,5 @@
+error: `Call` is not allowed to have generics. Only the following pallets are allowed to have generics: `Event`, `Error`, `Origin`, `Config`.
+ --> tests/construct_runtime_ui/generics_in_invalid_module.rs:7:36
+  |
+7 |         Balance: balances::<Instance1>::{Call<T>, Origin<T>},
+  |                                          ^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_meta_literal.rs b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_meta_literal.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bce87c51336eb26d0ecbe05fab6a9d4440bf204b
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_meta_literal.rs
@@ -0,0 +1,12 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet},
+		#[cfg(feature = 1)]
+		Balance: balances::{Config, Call},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_meta_literal.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_meta_literal.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..bfee2910cd2a465ca8bb9c834a705e6cc7d7a3d7
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_meta_literal.stderr
@@ -0,0 +1,6 @@
+error: feature = 1
+                 ^ expected one of `<key>`, `all`, `any`, `not` here
+ --> tests/construct_runtime_ui/invalid_meta_literal.rs:7:3
+  |
+7 |         #[cfg(feature = 1)]
+  |         ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details.rs b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bf6919f5a58ef51e03e09656d8e8c60a1a42f7a4
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details.rs
@@ -0,0 +1,10 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		system: System::(),
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1f9277c3f0a8ee1a639f59d701210ce5051be251
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details.stderr
@@ -0,0 +1,5 @@
+error: Unexpected tokens, expected one of `::$ident` `::{`, `exclude_parts`, `use_parts`, `=`, `,`
+ --> tests/construct_runtime_ui/invalid_module_details.rs:6:17
+  |
+6 |         system: System::(),
+  |                       ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.rs b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51f14e6883e4ac5dd641e143237d9c2d9fe9d2a0
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.rs
@@ -0,0 +1,10 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		system: System::{enum},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..dfcc9b8be42c605fc5c56dac8acb3c50cc295665
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_details_keyword.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `Pallet`, `Call`, `Storage`, `Event`, `Error`, `Config`, `Origin`, `Inherent`, `ValidateUnsigned`, `FreezeReason`, `HoldReason`, `LockId`, `SlashReason`
+ --> tests/construct_runtime_ui/invalid_module_details_keyword.rs:6:20
+  |
+6 |         system: System::{enum},
+  |                          ^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.rs b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.rs
new file mode 100644
index 0000000000000000000000000000000000000000..607741d7823d4fbc390884b2ab2ec7c949e5e3ec
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.rs
@@ -0,0 +1,11 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet},
+		Balance: balances::{Unexpected},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9dd849ff0412eb6a052145ccfcb317bc9a3a0020
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_module_entry.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `Pallet`, `Call`, `Storage`, `Event`, `Error`, `Config`, `Origin`, `Inherent`, `ValidateUnsigned`, `FreezeReason`, `HoldReason`, `LockId`, `SlashReason`
+ --> tests/construct_runtime_ui/invalid_module_entry.rs:7:23
+  |
+7 |         Balance: balances::{Unexpected},
+  |                             ^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_module.rs b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_module.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c132fa01b2297273c86f1b4a58c0702a3c89535c
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_module.rs
@@ -0,0 +1,10 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		system: System ?
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_module.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_module.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..80be1b8dd42fd242524e67d29060566e60b912e4
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_module.stderr
@@ -0,0 +1,5 @@
+error: Unexpected tokens, expected one of `::$ident` `::{`, `exclude_parts`, `use_parts`, `=`, `,`
+ --> tests/construct_runtime_ui/invalid_token_after_module.rs:6:18
+  |
+6 |         system: System ?
+  |                        ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_name.rs b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..42e7759f87f2bce6a552bef4e10eb7811c0b9302
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_name.rs
@@ -0,0 +1,10 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		system ?
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_name.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..8988f8a35b0a4bd1f84fa9b13a25d56ed0d963f7
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_token_after_name.stderr
@@ -0,0 +1,5 @@
+error: expected `:`
+ --> tests/construct_runtime_ui/invalid_token_after_name.rs:6:10
+  |
+6 |         system ?
+  |                ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_where_param.rs b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_where_param.rs
new file mode 100644
index 0000000000000000000000000000000000000000..091f0644494f6e509b21cd0268b41124acaedd25
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_where_param.rs
@@ -0,0 +1,12 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		Block = Block,
+		NodeBlock = Block,
+		TypeX = Block,
+		UncheckedExtrinsic = UncheckedExtrinsic,
+	{}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/invalid_where_param.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_where_param.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9e358b6a21fab0f7022c11f697042299a5357c6f
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/invalid_where_param.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `Block`, `NodeBlock`, `UncheckedExtrinsic`
+ --> $DIR/invalid_where_param.rs:7:3
+  |
+7 |         TypeX = Block,
+  |         ^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_event_generic_on_module_with_instance.rs b/substrate/frame/support/test/tests/construct_runtime_ui/missing_event_generic_on_module_with_instance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bc2039c4e8180ee382e600acdf9c5b9c89ae80a1
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_event_generic_on_module_with_instance.rs
@@ -0,0 +1,11 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system expanded::{}::{Pallet},
+		Balance: balances::<Instance1> expanded::{}::{Event},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_event_generic_on_module_with_instance.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/missing_event_generic_on_module_with_instance.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..30fcba4c710d05d7a496d09047997c397737a149
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_event_generic_on_module_with_instance.stderr
@@ -0,0 +1,5 @@
+error: Instantiable pallet with no generic `Event` cannot be constructed: pallet `Balance` must have generic `Event`
+ --> tests/construct_runtime_ui/missing_event_generic_on_module_with_instance.rs:7:3
+  |
+7 |         Balance: balances::<Instance1> expanded::{}::{Event},
+  |         ^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_module_instance.rs b/substrate/frame/support/test/tests/construct_runtime_ui/missing_module_instance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..afd96a04854f28a30adaa9e034373818040ac4bb
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_module_instance.rs
@@ -0,0 +1,10 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		system: System::<>,
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_module_instance.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/missing_module_instance.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5072f718db12efc3831fd2f4888435282b8c9b0a
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_module_instance.stderr
@@ -0,0 +1,5 @@
+error: expected identifier
+ --> tests/construct_runtime_ui/missing_module_instance.rs:6:20
+  |
+6 |         system: System::<>,
+  |                          ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_origin_generic_on_module_with_instance.rs b/substrate/frame/support/test/tests/construct_runtime_ui/missing_origin_generic_on_module_with_instance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..42db63ae90a3a961530529d31d9a94db25b34538
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_origin_generic_on_module_with_instance.rs
@@ -0,0 +1,11 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system expanded::{}::{Pallet},
+		Balance: balances::<Instance1> expanded::{}::{Origin},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_origin_generic_on_module_with_instance.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/missing_origin_generic_on_module_with_instance.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..6c076d7b49fc04a229112756eb7e4de6b0574332
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_origin_generic_on_module_with_instance.stderr
@@ -0,0 +1,5 @@
+error: Instantiable pallet with no generic `Origin` cannot be constructed: pallet `Balance` must have generic `Origin`
+ --> tests/construct_runtime_ui/missing_origin_generic_on_module_with_instance.rs:7:3
+  |
+7 |         Balance: balances::<Instance1> expanded::{}::{Origin},
+  |         ^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_system_module.rs b/substrate/frame/support/test/tests/construct_runtime_ui/missing_system_module.rs
new file mode 100644
index 0000000000000000000000000000000000000000..685f9059b1be2c77fcb26e507924ca3ffdf667e1
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_system_module.rs
@@ -0,0 +1,9 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_system_module.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/missing_system_module.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c8631f44051ca5a8bdb8cd1bfe683358e2cfb894
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_system_module.stderr
@@ -0,0 +1,6 @@
+error: `System` pallet declaration is missing. Please add this line: `System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},`
+ --> tests/construct_runtime_ui/missing_system_module.rs:5:2
+  |
+5 | /     {
+6 | |     }
+  | |_____^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_where_param.rs b/substrate/frame/support/test/tests/construct_runtime_ui/missing_where_param.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d2225a4afbc9e677c0f46aad7ded3d579f4c38d
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_where_param.rs
@@ -0,0 +1,10 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		Block = Block,
+		NodeBlock = Block,
+	{}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/missing_where_param.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/missing_where_param.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..fb7e38b53dcd6b311ad288454ba48b0214ab1fba
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/missing_where_param.stderr
@@ -0,0 +1,5 @@
+error: Missing associated type for `UncheckedExtrinsic`. Add `UncheckedExtrinsic` = ... to where section.
+ --> tests/construct_runtime_ui/missing_where_param.rs:7:2
+  |
+7 |     {}
+  |     ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/more_than_256_modules.rs b/substrate/frame/support/test/tests/construct_runtime_ui/more_than_256_modules.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7dcbdb9aa4fba17321685b54aa144227496490a4
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/more_than_256_modules.rs
@@ -0,0 +1,14 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		UncheckedExtrinsic = UncheckedExtrinsic,
+		Block = Block,
+		NodeBlock = Block,
+	{
+		System: system::{} = 255,
+		Pallet256: pallet256::{},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/more_than_256_modules.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/more_than_256_modules.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..2e055f5d3726a1657f471fb4d7492537295d38b1
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/more_than_256_modules.stderr
@@ -0,0 +1,5 @@
+error: Pallet index doesn't fit into u8, index is 256
+  --> $DIR/more_than_256_modules.rs:10:3
+   |
+10 |         Pallet256: pallet256::{},
+   |         ^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/no_comma_after_where.rs b/substrate/frame/support/test/tests/construct_runtime_ui/no_comma_after_where.rs
new file mode 100644
index 0000000000000000000000000000000000000000..499f9a5cdcd5424102d5a71faa41a73e4df92d44
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/no_comma_after_where.rs
@@ -0,0 +1,13 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime where
+		UncheckedExtrinsic = UncheckedExtrinsic
+		Block = Block,
+		NodeBlock = Block,
+	{
+		System: system,
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/no_comma_after_where.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/no_comma_after_where.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..caf4a7401b08ecdcd6589fa60627eeedd0aac132
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/no_comma_after_where.stderr
@@ -0,0 +1,5 @@
+error: Expected `,` or `{`
+ --> $DIR/no_comma_after_where.rs:6:3
+  |
+6 |         Block = Block,
+  |         ^^^^^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs b/substrate/frame/support/test/tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d6afbcdc2c65aa0c4a86ba893158784528170f4
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs
@@ -0,0 +1,165 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet1: pallet::{Pallet},
+		Pallet2: pallet::{Pallet},
+		Pallet3: pallet::{Pallet},
+		Pallet4: pallet::{Pallet},
+		Pallet5: pallet::{Pallet},
+		Pallet6: pallet::{Pallet},
+		Pallet7: pallet::{Pallet},
+		Pallet8: pallet::{Pallet},
+		Pallet9: pallet::{Pallet},
+		Pallet10: pallet::{Pallet},
+		Pallet11: pallet::{Pallet},
+		Pallet12: pallet::{Pallet},
+		Pallet13: pallet::{Pallet},
+		Pallet14: pallet::{Pallet},
+		Pallet15: pallet::{Pallet},
+		Pallet16: pallet::{Pallet},
+		Pallet17: pallet::{Pallet},
+		Pallet18: pallet::{Pallet},
+		Pallet19: pallet::{Pallet},
+		Pallet20: pallet::{Pallet},
+		Pallet21: pallet::{Pallet},
+		Pallet22: pallet::{Pallet},
+		Pallet23: pallet::{Pallet},
+		Pallet24: pallet::{Pallet},
+		Pallet25: pallet::{Pallet},
+		Pallet26: pallet::{Pallet},
+		Pallet27: pallet::{Pallet},
+		Pallet28: pallet::{Pallet},
+		Pallet29: pallet::{Pallet},
+		Pallet30: pallet::{Pallet},
+		Pallet31: pallet::{Pallet},
+		Pallet32: pallet::{Pallet},
+		Pallet33: pallet::{Pallet},
+		Pallet34: pallet::{Pallet},
+		Pallet35: pallet::{Pallet},
+		Pallet36: pallet::{Pallet},
+		Pallet37: pallet::{Pallet},
+		Pallet38: pallet::{Pallet},
+		Pallet39: pallet::{Pallet},
+		Pallet40: pallet::{Pallet},
+		Pallet41: pallet::{Pallet},
+		Pallet42: pallet::{Pallet},
+		Pallet43: pallet::{Pallet},
+		Pallet44: pallet::{Pallet},
+		Pallet45: pallet::{Pallet},
+		Pallet46: pallet::{Pallet},
+		Pallet47: pallet::{Pallet},
+		Pallet48: pallet::{Pallet},
+		Pallet49: pallet::{Pallet},
+		Pallet50: pallet::{Pallet},
+		Pallet51: pallet::{Pallet},
+		Pallet52: pallet::{Pallet},
+		Pallet53: pallet::{Pallet},
+		Pallet54: pallet::{Pallet},
+		Pallet55: pallet::{Pallet},
+		Pallet56: pallet::{Pallet},
+		Pallet57: pallet::{Pallet},
+		Pallet58: pallet::{Pallet},
+		Pallet59: pallet::{Pallet},
+		Pallet60: pallet::{Pallet},
+		Pallet61: pallet::{Pallet},
+		Pallet62: pallet::{Pallet},
+		Pallet63: pallet::{Pallet},
+		Pallet64: pallet::{Pallet},
+		Pallet65: pallet::{Pallet},
+		Pallet66: pallet::{Pallet},
+		Pallet67: pallet::{Pallet},
+		Pallet68: pallet::{Pallet},
+		Pallet69: pallet::{Pallet},
+		Pallet70: pallet::{Pallet},
+		Pallet71: pallet::{Pallet},
+		Pallet72: pallet::{Pallet},
+		Pallet73: pallet::{Pallet},
+		Pallet74: pallet::{Pallet},
+		Pallet75: pallet::{Pallet},
+		Pallet76: pallet::{Pallet},
+		Pallet77: pallet::{Pallet},
+		Pallet78: pallet::{Pallet},
+		Pallet79: pallet::{Pallet},
+		Pallet80: pallet::{Pallet},
+		Pallet81: pallet::{Pallet},
+		Pallet82: pallet::{Pallet},
+		Pallet83: pallet::{Pallet},
+		Pallet84: pallet::{Pallet},
+		Pallet85: pallet::{Pallet},
+		Pallet86: pallet::{Pallet},
+		Pallet87: pallet::{Pallet},
+		Pallet88: pallet::{Pallet},
+		Pallet89: pallet::{Pallet},
+		Pallet90: pallet::{Pallet},
+		Pallet91: pallet::{Pallet},
+		Pallet92: pallet::{Pallet},
+		Pallet93: pallet::{Pallet},
+		Pallet94: pallet::{Pallet},
+		Pallet95: pallet::{Pallet},
+		Pallet96: pallet::{Pallet},
+		Pallet97: pallet::{Pallet},
+		Pallet98: pallet::{Pallet},
+		Pallet99: pallet::{Pallet},
+		Pallet100: pallet::{Pallet},
+		Pallet101: pallet::{Pallet},
+		Pallet102: pallet::{Pallet},
+		Pallet103: pallet::{Pallet},
+		Pallet104: pallet::{Pallet},
+		Pallet105: pallet::{Pallet},
+		Pallet106: pallet::{Pallet},
+		Pallet107: pallet::{Pallet},
+		Pallet108: pallet::{Pallet},
+		Pallet109: pallet::{Pallet},
+		Pallet110: pallet::{Pallet},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..75d0ce0546583fb2901dbf5eeba0ee4b40fc19d0
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.stderr
@@ -0,0 +1,63 @@
+error: The number of pallets exceeds the maximum number of tuple elements. To increase this limit, enable the tuples-96 feature of [frame_support].
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:49:2
+   |
+49 |     pub struct Runtime
+   |     ^^^
+
+error[E0412]: cannot find type `RuntimeCall` in this scope
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:18:64
+   |
+18 | pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                                                                ^^^^^^^^^^^ not found in this scope
+   |
+help: you might be missing a type parameter
+   |
+18 | pub type UncheckedExtrinsic<RuntimeCall> = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                            +++++++++++++
+
+error[E0412]: cannot find type `Runtime` in this scope
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:20:25
+   |
+20 | impl pallet::Config for Runtime {}
+   |                         ^^^^^^^ not found in this scope
+
+error[E0412]: cannot find type `Runtime` in this scope
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:22:31
+   |
+22 | impl frame_system::Config for Runtime {
+   |                               ^^^^^^^ not found in this scope
+
+error[E0412]: cannot find type `RuntimeOrigin` in this scope
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:24:23
+   |
+24 |     type RuntimeOrigin = RuntimeOrigin;
+   |                          ^^^^^^^^^^^^^ help: you might have meant to use the associated type: `Self::RuntimeOrigin`
+
+error[E0412]: cannot find type `RuntimeCall` in this scope
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:26:21
+   |
+26 |     type RuntimeCall = RuntimeCall;
+   |                        ^^^^^^^^^^^ help: you might have meant to use the associated type: `Self::RuntimeCall`
+
+error[E0412]: cannot find type `RuntimeEvent` in this scope
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:32:22
+   |
+32 |     type RuntimeEvent = RuntimeEvent;
+   |                         ^^^^^^^^^^^^ help: you might have meant to use the associated type: `Self::RuntimeEvent`
+
+error[E0412]: cannot find type `PalletInfo` in this scope
+  --> tests/construct_runtime_ui/number_of_pallets_exceeds_tuple_size.rs:38:20
+   |
+38 |     type PalletInfo = PalletInfo;
+   |                       ^^^^^^^^^^
+   |
+help: you might have meant to use the associated type
+   |
+38 |     type PalletInfo = Self::PalletInfo;
+   |                       ~~~~~~~~~~~~~~~~
+help: consider importing one of these items
+   |
+1  + use frame_benchmarking::__private::traits::PalletInfo;
+   |
+1  + use frame_support::traits::PalletInfo;
+   |
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/pallet_error_too_large.rs b/substrate/frame/support/test/tests/construct_runtime_ui/pallet_error_too_large.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8b3e26bc5e2e42b9f320239b3998e7275306cdbb
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/pallet_error_too_large.rs
@@ -0,0 +1,81 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::error]
+	pub enum Error<T> {
+		MyError(crate::Nested1),
+	}
+}
+
+#[derive(scale_info::TypeInfo, frame_support::PalletError, codec::Encode, codec::Decode)]
+pub enum Nested1 {
+	Nested2(Nested2),
+}
+
+#[derive(scale_info::TypeInfo, frame_support::PalletError, codec::Encode, codec::Decode)]
+pub enum Nested2 {
+	Nested3(Nested3),
+}
+
+#[derive(scale_info::TypeInfo, frame_support::PalletError, codec::Encode, codec::Decode)]
+pub enum Nested3 {
+	Nested4(Nested4),
+}
+
+#[derive(scale_info::TypeInfo, frame_support::PalletError, codec::Encode, codec::Decode)]
+pub enum Nested4 {
+	Num(u8),
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet::{Pallet},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/pallet_error_too_large.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/pallet_error_too_large.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..47504573515a22f09c8942ef6bd67e1324de3b39
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/pallet_error_too_large.stderr
@@ -0,0 +1,13 @@
+error[E0080]: evaluation of constant value failed
+  --> tests/construct_runtime_ui/pallet_error_too_large.rs:73:1
+   |
+73 | / construct_runtime! {
+74 | |     pub struct Runtime
+75 | |     {
+76 | |         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+77 | |         Pallet: pallet::{Pallet},
+78 | |     }
+79 | | }
+   | |_^ the evaluated program panicked at 'The maximum encoded size of the error type in the `Pallet` pallet exceeds `MAX_MODULE_ERROR_ENCODED_SIZE`', $DIR/tests/construct_runtime_ui/pallet_error_too_large.rs:73:1
+   |
+   = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_call_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_call_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..25cb5e93f652e0ef23632f0b69d71d6d786d855b
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_call_part.rs
@@ -0,0 +1,56 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet::{Pallet, Call},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_call_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_call_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f3f29e4c6955491dfd81694af8916fcf46ec999e
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_call_part.stderr
@@ -0,0 +1,16 @@
+error: `Pallet` does not have #[pallet::call] defined, perhaps you should remove `Call` from construct_runtime?
+  --> tests/construct_runtime_ui/undefined_call_part.rs:5:1
+   |
+5  |   #[frame_support::pallet]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+...
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet::{Pallet, Call},
+53 | |     }
+54 | | }
+   | |_- in this macro invocation
+   |
+   = note: this error originates in the macro `pallet::__substrate_call_check::is_call_part_defined` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_event_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_event_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c44cceef81a123ea31ae8c5a774f65fd18669527
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_event_part.rs
@@ -0,0 +1,56 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet expanded::{}::{Pallet, Event},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_event_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_event_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..81e42cec3b97a171402f3b3cb2295969ce71cd98
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_event_part.stderr
@@ -0,0 +1,36 @@
+error: `Pallet` does not have #[pallet::event] defined, perhaps you should remove `Event` from construct_runtime?
+  --> tests/construct_runtime_ui/undefined_event_part.rs:5:1
+   |
+5  |   #[frame_support::pallet]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+...
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Event},
+53 | |     }
+54 | | }
+   | |_- in this macro invocation
+   |
+   = note: this error originates in the macro `pallet::__substrate_event_check::is_event_part_defined` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0412]: cannot find type `Event` in module `pallet`
+  --> tests/construct_runtime_ui/undefined_event_part.rs:48:1
+   |
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Event},
+53 | |     }
+54 | | }
+   | |_^ not found in `pallet`
+   |
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing one of these items
+   |
+1  + use frame_support_test::Event;
+   |
+1  + use frame_system::Event;
+   |
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_genesis_config_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_genesis_config_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4436202f04fc7db4783e76990060b9df10e0c8cd
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_genesis_config_part.rs
@@ -0,0 +1,56 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet expanded::{}::{Pallet, Config},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_genesis_config_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_genesis_config_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..920785fc962911594d45c2a3c737a1bce7facd9e
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_genesis_config_part.stderr
@@ -0,0 +1,36 @@
+error: `Pallet` does not have #[pallet::genesis_config] defined, perhaps you should remove `Config` from construct_runtime?
+  --> tests/construct_runtime_ui/undefined_genesis_config_part.rs:5:1
+   |
+5  |   #[frame_support::pallet]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+...
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Config},
+53 | |     }
+54 | | }
+   | |_- in this macro invocation
+   |
+   = note: this error originates in the macro `pallet::__substrate_genesis_config_check::is_genesis_config_defined` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0412]: cannot find type `GenesisConfig` in module `pallet`
+  --> tests/construct_runtime_ui/undefined_genesis_config_part.rs:48:1
+   |
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Config},
+53 | |     }
+54 | | }
+   | |_^ not found in `pallet`
+   |
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing one of these items
+   |
+1  + use frame_system::GenesisConfig;
+   |
+1  + use test_pallet::GenesisConfig;
+   |
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_inherent_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_inherent_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8b48c4d0d6af7c1f84f4a5958b2b478c9c150627
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_inherent_part.rs
@@ -0,0 +1,56 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet expanded::{}::{Pallet, Inherent},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_inherent_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_inherent_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..659d43b151006e894f8a468f3548a1bd8ef279fe
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_inherent_part.stderr
@@ -0,0 +1,121 @@
+error: `Pallet` does not have #[pallet::inherent] defined, perhaps you should remove `Inherent` from construct_runtime?
+  --> tests/construct_runtime_ui/undefined_inherent_part.rs:5:1
+   |
+5  |   #[frame_support::pallet]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+...
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Inherent},
+53 | |     }
+54 | | }
+   | |_- in this macro invocation
+   |
+   = note: this error originates in the macro `pallet::__substrate_inherent_check::is_inherent_part_defined` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no function or associated item named `create_inherent` found for struct `pallet::Pallet` in the current scope
+  --> tests/construct_runtime_ui/undefined_inherent_part.rs:48:1
+   |
+11 |       pub struct Pallet<T>(_);
+   |       -------------------- function or associated item `create_inherent` not found for this struct
+...
+48 |   construct_runtime! {
+   |  _^
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Inherent},
+53 | |     }
+54 | | }
+   | |_^ function or associated item not found in `Pallet<Runtime>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following trait defines an item `create_inherent`, perhaps you need to implement it:
+           candidate #1: `ProvideInherent`
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no function or associated item named `is_inherent` found for struct `pallet::Pallet` in the current scope
+  --> tests/construct_runtime_ui/undefined_inherent_part.rs:48:1
+   |
+11 |       pub struct Pallet<T>(_);
+   |       -------------------- function or associated item `is_inherent` not found for this struct
+...
+48 |   construct_runtime! {
+   |  _^
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Inherent},
+53 | |     }
+54 | | }
+   | |_^ function or associated item not found in `Pallet<Runtime>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following trait defines an item `is_inherent`, perhaps you need to implement it:
+           candidate #1: `ProvideInherent`
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no function or associated item named `check_inherent` found for struct `pallet::Pallet` in the current scope
+  --> tests/construct_runtime_ui/undefined_inherent_part.rs:48:1
+   |
+11 |       pub struct Pallet<T>(_);
+   |       -------------------- function or associated item `check_inherent` not found for this struct
+...
+48 |   construct_runtime! {
+   |  _^
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Inherent},
+53 | |     }
+54 | | }
+   | |_^ function or associated item not found in `Pallet<Runtime>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following trait defines an item `check_inherent`, perhaps you need to implement it:
+           candidate #1: `ProvideInherent`
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no associated item named `INHERENT_IDENTIFIER` found for struct `pallet::Pallet` in the current scope
+  --> tests/construct_runtime_ui/undefined_inherent_part.rs:48:1
+   |
+11 |       pub struct Pallet<T>(_);
+   |       -------------------- associated item `INHERENT_IDENTIFIER` not found for this struct
+...
+48 |   construct_runtime! {
+   |  _^
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Inherent},
+53 | |     }
+54 | | }
+   | |_^ associated item not found in `Pallet<Runtime>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following trait defines an item `INHERENT_IDENTIFIER`, perhaps you need to implement it:
+           candidate #1: `ProvideInherent`
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no function or associated item named `is_inherent_required` found for struct `pallet::Pallet` in the current scope
+  --> tests/construct_runtime_ui/undefined_inherent_part.rs:48:1
+   |
+11 |       pub struct Pallet<T>(_);
+   |       -------------------- function or associated item `is_inherent_required` not found for this struct
+...
+48 |   construct_runtime! {
+   |  _^
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Inherent},
+53 | |     }
+54 | | }
+   | |_^ function or associated item not found in `Pallet<Runtime>`
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following trait defines an item `is_inherent_required`, perhaps you need to implement it:
+           candidate #1: `ProvideInherent`
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_origin_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_origin_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..974928785f748620cfc4b8fb642b84aa16a7e789
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_origin_part.rs
@@ -0,0 +1,56 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet expanded::{}::{Pallet, Origin},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_origin_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_origin_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c41dbe79421eae92da3134ae96f4cce1728bbc34
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_origin_part.stderr
@@ -0,0 +1,36 @@
+error: `Pallet` does not have #[pallet::origin] defined, perhaps you should remove `Origin` from construct_runtime?
+  --> tests/construct_runtime_ui/undefined_origin_part.rs:5:1
+   |
+5  |   #[frame_support::pallet]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+...
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Origin},
+53 | |     }
+54 | | }
+   | |_- in this macro invocation
+   |
+   = note: this error originates in the macro `pallet::__substrate_origin_check::is_origin_part_defined` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0412]: cannot find type `Origin` in module `pallet`
+  --> tests/construct_runtime_ui/undefined_origin_part.rs:48:1
+   |
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system expanded::{}::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet expanded::{}::{Pallet, Origin},
+53 | |     }
+54 | | }
+   | |_^ not found in `pallet`
+   |
+   = note: this error originates in the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider importing one of these items
+   |
+1  + use frame_support_test::Origin;
+   |
+1  + use frame_system::Origin;
+   |
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_validate_unsigned_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_validate_unsigned_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..505b249d92d58897a32af2cf3b2b312cc6351dd1
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_validate_unsigned_part.rs
@@ -0,0 +1,56 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet::{Pallet, ValidateUnsigned},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/undefined_validate_unsigned_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_validate_unsigned_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..007b77250736ec7f83159f6c965b18919bada40d
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/undefined_validate_unsigned_part.stderr
@@ -0,0 +1,79 @@
+error: `Pallet` does not have #[pallet::validate_unsigned] defined, perhaps you should remove `ValidateUnsigned` from construct_runtime?
+  --> tests/construct_runtime_ui/undefined_validate_unsigned_part.rs:5:1
+   |
+5  |   #[frame_support::pallet]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+...
+48 | / construct_runtime! {
+49 | |     pub struct Runtime
+50 | |     {
+51 | |         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | |         Pallet: pallet::{Pallet, ValidateUnsigned},
+53 | |     }
+54 | | }
+   | |_- in this macro invocation
+   |
+   = note: this error originates in the macro `pallet::__substrate_validate_unsigned_check::is_validate_unsigned_part_defined` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no variant or associated item named `Pallet` found for enum `RuntimeCall` in the current scope
+  --> tests/construct_runtime_ui/undefined_validate_unsigned_part.rs:52:3
+   |
+48 | // construct_runtime! {
+49 | ||     pub struct Runtime
+50 | ||     {
+51 | ||         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | ||         Pallet: pallet::{Pallet, ValidateUnsigned},
+   | ||        -^^^^^^ variant or associated item not found in `RuntimeCall`
+   | ||________|
+   | |
+...  |
+
+error[E0599]: no function or associated item named `pre_dispatch` found for struct `pallet::Pallet` in the current scope
+  --> tests/construct_runtime_ui/undefined_validate_unsigned_part.rs:48:1
+   |
+11 |        pub struct Pallet<T>(_);
+   |        -------------------- function or associated item `pre_dispatch` not found for this struct
+...
+48 |    construct_runtime! {
+   |  __^
+   | | _|
+   | ||
+49 | ||     pub struct Runtime
+50 | ||     {
+51 | ||         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | ||         Pallet: pallet::{Pallet, ValidateUnsigned},
+53 | ||     }
+54 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following traits define an item `pre_dispatch`, perhaps you need to implement one of them:
+           candidate #1: `SignedExtension`
+           candidate #2: `ValidateUnsigned`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0599]: no function or associated item named `validate_unsigned` found for struct `pallet::Pallet` in the current scope
+  --> tests/construct_runtime_ui/undefined_validate_unsigned_part.rs:48:1
+   |
+11 |        pub struct Pallet<T>(_);
+   |        -------------------- function or associated item `validate_unsigned` not found for this struct
+...
+48 |    construct_runtime! {
+   |  __^
+   | | _|
+   | ||
+49 | ||     pub struct Runtime
+50 | ||     {
+51 | ||         System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+52 | ||         Pallet: pallet::{Pallet, ValidateUnsigned},
+53 | ||     }
+54 | || }
+   | ||_- in this macro invocation
+...  |
+   |
+   = help: items from traits can only be used if the trait is implemented and in scope
+   = note: the following traits define an item `validate_unsigned`, perhaps you need to implement one of them:
+           candidate #1: `SignedExtension`
+           candidate #2: `ValidateUnsigned`
+   = note: this error originates in the macro `frame_support::construct_runtime` which comes from the expansion of the macro `construct_runtime` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_meta_structure.rs b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_meta_structure.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e4e2d3dca021ea74401e9512553ba4ef5ac6003b
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_meta_structure.rs
@@ -0,0 +1,12 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet},
+		#[cfg(feature(test))]
+		Balance: balances::{Config, Call},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_meta_structure.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_meta_structure.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..34637269db617c7edb52091455593f45e0bda079
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_meta_structure.stderr
@@ -0,0 +1,6 @@
+error: feature(test)
+              ^ expected one of `=`, `,`, `)` here
+ --> tests/construct_runtime_ui/unsupported_meta_structure.rs:7:3
+  |
+7 |         #[cfg(feature(test))]
+  |         ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_pallet_attr.rs b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_pallet_attr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..491cc2c90533de4e1b08ed22070307e7d827b93b
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_pallet_attr.rs
@@ -0,0 +1,12 @@
+use frame_support::construct_runtime;
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet},
+		#[attr]
+		Balance: balances::{Config, Call},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_pallet_attr.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_pallet_attr.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..da1b61b1c30782f8f3fbc2e078e49fe44595d5b8
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/unsupported_pallet_attr.stderr
@@ -0,0 +1,5 @@
+error: Unsupported attribute, only #[cfg] is supported on pallet declarations in `construct_runtime`
+ --> tests/construct_runtime_ui/unsupported_pallet_attr.rs:7:3
+  |
+7 |         #[attr]
+  |         ^
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/use_undefined_part.rs b/substrate/frame/support/test/tests/construct_runtime_ui/use_undefined_part.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8563be1008cd93473f978cd043dcbad8f2d89848
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/use_undefined_part.rs
@@ -0,0 +1,35 @@
+use frame_support::construct_runtime;
+use sp_runtime::{generic, traits::BlakeTwo256};
+use sp_core::sr25519;
+
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<Value=u8>;
+}
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u64;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl pallet::Config for Runtime {}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: pallet use_parts { Call },
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/construct_runtime_ui/use_undefined_part.stderr b/substrate/frame/support/test/tests/construct_runtime_ui/use_undefined_part.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4058ccab2c5d7da5a836f9a5c90d89f22f285a88
--- /dev/null
+++ b/substrate/frame/support/test/tests/construct_runtime_ui/use_undefined_part.stderr
@@ -0,0 +1,22 @@
+error: Invalid pallet part specified, the pallet `Pallet` doesn't have the `Call` part. Available parts are: `Pallet`, `Storage`.
+  --> tests/construct_runtime_ui/use_undefined_part.rs:31:30
+   |
+31 |         Pallet: pallet use_parts { Call },
+   |                                    ^^^^
+
+error[E0412]: cannot find type `RuntimeCall` in this scope
+  --> tests/construct_runtime_ui/use_undefined_part.rs:23:64
+   |
+23 | pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                                                                ^^^^^^^^^^^ not found in this scope
+   |
+help: you might be missing a type parameter
+   |
+23 | pub type UncheckedExtrinsic<RuntimeCall> = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+   |                            +++++++++++++
+
+error[E0412]: cannot find type `Runtime` in this scope
+  --> tests/construct_runtime_ui/use_undefined_part.rs:25:25
+   |
+25 | impl pallet::Config for Runtime {}
+   |                         ^^^^^^^ not found in this scope
diff --git a/substrate/frame/support/test/tests/derive_impl_ui.rs b/substrate/frame/support/test/tests/derive_impl_ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee219d0670aaff7986338c26d7e80a9ef0b13395
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui.rs
@@ -0,0 +1,38 @@
+// 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(not(feature = "disable-ui-tests"))]
+#![cfg(test)]
+
+#[rustversion::attr(not(stable), ignore)]
+#[test]
+fn derive_impl_ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if std::env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("SKIP_WASM_BUILD", "1");
+
+	// Deny all warnings since we emit warnings as part of a Pallet's UI.
+	std::env::set_var("RUSTFLAGS", "--deny warnings");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/derive_impl_ui/*.rs");
+	t.pass("tests/derive_impl_ui/pass/*.rs");
+}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/attached_to_non_impl.rs b/substrate/frame/support/test/tests/derive_impl_ui/attached_to_non_impl.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3b27916933865325144e02bfe7d86bfaba63f484
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/attached_to_non_impl.rs
@@ -0,0 +1,41 @@
+use frame_support::*;
+
+pub trait Animal {
+	type Locomotion;
+	type Diet;
+	type SleepingStrategy;
+	type Environment;
+
+	fn animal_name() -> &'static str;
+}
+
+pub type RunsOnFourLegs = (usize, usize, usize, usize);
+pub type RunsOnTwoLegs = (usize, usize);
+pub type Swims = isize;
+pub type Diurnal = bool;
+pub type Nocturnal = Option<bool>;
+pub type Omnivore = char;
+pub type Land = ((), ());
+pub type Sea = ((), (), ());
+pub type Carnivore = (char, char);
+
+pub struct FourLeggedAnimal {}
+
+#[register_default_impl(FourLeggedAnimal)]
+impl Animal for FourLeggedAnimal {
+	type Locomotion = RunsOnFourLegs;
+	type Diet = Omnivore;
+	type SleepingStrategy = Diurnal;
+	type Environment = Land;
+
+	fn animal_name() -> &'static str {
+		"A Four-Legged Animal"
+	}
+}
+
+pub struct AcquaticMammal {}
+
+#[derive_impl(FourLeggedAnimal as Animal)]
+struct Something {}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/attached_to_non_impl.stderr b/substrate/frame/support/test/tests/derive_impl_ui/attached_to_non_impl.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..735fd7a628e77872f62a535915d9b3c2aeb978e5
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/attached_to_non_impl.stderr
@@ -0,0 +1,5 @@
+error: expected `impl`
+  --> tests/derive_impl_ui/attached_to_non_impl.rs:39:1
+   |
+39 | struct Something {}
+   | ^^^^^^
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/bad_default_impl_path.rs b/substrate/frame/support/test/tests/derive_impl_ui/bad_default_impl_path.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2badd1830033bdf877dd19764ba738321c953486
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/bad_default_impl_path.rs
@@ -0,0 +1,48 @@
+use frame_support::*;
+
+pub trait Animal {
+	type Locomotion;
+	type Diet;
+	type SleepingStrategy;
+	type Environment;
+
+	fn animal_name() -> &'static str;
+}
+
+pub type RunsOnFourLegs = (usize, usize, usize, usize);
+pub type RunsOnTwoLegs = (usize, usize);
+pub type Swims = isize;
+pub type Diurnal = bool;
+pub type Nocturnal = Option<bool>;
+pub type Omnivore = char;
+pub type Land = ((), ());
+pub type Sea = ((), (), ());
+pub type Carnivore = (char, char);
+
+pub struct FourLeggedAnimal {}
+
+#[register_default_impl(FourLeggedAnimal)]
+impl Animal for FourLeggedAnimal {
+	type Locomotion = RunsOnFourLegs;
+	type Diet = Omnivore;
+	type SleepingStrategy = Diurnal;
+	type Environment = Land;
+
+	fn animal_name() -> &'static str {
+		"A Four-Legged Animal"
+	}
+}
+
+pub struct AcquaticMammal {}
+
+// Should throw: `error: cannot find macro `__export_tokens_tt_tiger` in this scope`
+//
+// Note that there is really no better way to clean up this error, tt_call suffers from the
+// same downside but this is really the only rough edge when using macro magic.
+#[derive_impl(Tiger as Animal)]
+impl Animal for AcquaticMammal {
+	type Locomotion = (Swims, RunsOnFourLegs);
+	type Environment = (Land, Sea);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/bad_default_impl_path.stderr b/substrate/frame/support/test/tests/derive_impl_ui/bad_default_impl_path.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1cac1662462767fc1139006041ed683eaddcb5ad
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/bad_default_impl_path.stderr
@@ -0,0 +1,7 @@
+error: cannot find macro `__export_tokens_tt_tiger` in this scope
+  --> tests/derive_impl_ui/bad_default_impl_path.rs:42:1
+   |
+42 | #[derive_impl(Tiger as Animal)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `frame_support::macro_magic::forward_tokens` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/bad_disambiguation_path.rs b/substrate/frame/support/test/tests/derive_impl_ui/bad_disambiguation_path.rs
new file mode 100644
index 0000000000000000000000000000000000000000..adc5df23a759a0cdb43495d44261cc9e9c0f2657
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/bad_disambiguation_path.rs
@@ -0,0 +1,44 @@
+use frame_support::*;
+
+pub trait Animal {
+	type Locomotion;
+	type Diet;
+	type SleepingStrategy;
+	type Environment;
+
+	fn animal_name() -> &'static str;
+}
+
+pub type RunsOnFourLegs = (usize, usize, usize, usize);
+pub type RunsOnTwoLegs = (usize, usize);
+pub type Swims = isize;
+pub type Diurnal = bool;
+pub type Nocturnal = Option<bool>;
+pub type Omnivore = char;
+pub type Land = ((), ());
+pub type Sea = ((), (), ());
+pub type Carnivore = (char, char);
+
+pub struct FourLeggedAnimal {}
+
+#[register_default_impl(FourLeggedAnimal)]
+impl Animal for FourLeggedAnimal {
+	type Locomotion = RunsOnFourLegs;
+	type Diet = Omnivore;
+	type SleepingStrategy = Diurnal;
+	type Environment = Land;
+
+	fn animal_name() -> &'static str {
+		"A Four-Legged Animal"
+	}
+}
+
+pub struct AcquaticMammal {}
+
+#[derive_impl(FourLeggedAnimal as Insect)]
+impl Animal for AcquaticMammal {
+	type Locomotion = (Swims, RunsOnFourLegs);
+	type Environment = (Land, Sea);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/bad_disambiguation_path.stderr b/substrate/frame/support/test/tests/derive_impl_ui/bad_disambiguation_path.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..6fd4e431beb52c62c5ea2b98648f625627ab0825
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/bad_disambiguation_path.stderr
@@ -0,0 +1,5 @@
+error[E0405]: cannot find trait `Insect` in this scope
+  --> tests/derive_impl_ui/bad_disambiguation_path.rs:38:35
+   |
+38 | #[derive_impl(FourLeggedAnimal as Insect)]
+   |                                   ^^^^^^ not found in this scope
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_fails_when_type_not_in_scope.rs b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_fails_when_type_not_in_scope.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d8dc8eb1d4720ed542c6a4d95bf74e932848552
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_fails_when_type_not_in_scope.rs
@@ -0,0 +1,23 @@
+use frame_support::{*, pallet_prelude::inject_runtime_type};
+use static_assertions::assert_type_eq_all;
+
+pub trait Config {
+    type RuntimeCall;
+}
+
+struct Pallet;
+
+#[register_default_impl(Pallet)]
+impl Config for Pallet {
+    #[inject_runtime_type]
+    type RuntimeCall = ();
+}
+
+struct SomePallet;
+
+#[derive_impl(Pallet)] // Injects type RuntimeCall = RuntimeCall;
+impl Config for SomePallet {}
+
+assert_type_eq_all!(<SomePallet as Config>::RuntimeCall, u32);
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_fails_when_type_not_in_scope.stderr b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_fails_when_type_not_in_scope.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..683131cceb8dce24e5a7947bc367243e58014ab8
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_fails_when_type_not_in_scope.stderr
@@ -0,0 +1,10 @@
+error[E0412]: cannot find type `RuntimeCall` in this scope
+  --> tests/derive_impl_ui/inject_runtime_type_fails_when_type_not_in_scope.rs:13:10
+   |
+13 |     type RuntimeCall = ();
+   |          ^^^^^^^^^^^ help: you might have meant to use the associated type: `Self::RuntimeCall`
+...
+18 | #[derive_impl(Pallet)] // Injects type RuntimeCall = RuntimeCall;
+   | ---------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `__export_tokens_tt_pallet` which comes from the expansion of the macro `frame_support::macro_magic::forward_tokens` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_invalid.rs b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_invalid.rs
new file mode 100644
index 0000000000000000000000000000000000000000..60ec710d0154c368a222bf358a2382b4dc94665b
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_invalid.rs
@@ -0,0 +1,25 @@
+use frame_support::{*, pallet_prelude::inject_runtime_type};
+use static_assertions::assert_type_eq_all;
+
+pub trait Config {
+    type RuntimeInfo;
+}
+
+type RuntimeInfo = u32;
+
+struct Pallet;
+
+#[register_default_impl(Pallet)]
+impl Config for Pallet {
+    #[inject_runtime_type]
+    type RuntimeInfo = ();
+}
+
+struct SomePallet;
+
+#[derive_impl(Pallet)] // Injects type RuntimeInfo = RuntimeInfo;
+impl Config for SomePallet {}
+
+assert_type_eq_all!(<SomePallet as Config>::RuntimeInfo, u32);
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_invalid.stderr b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_invalid.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c3382510744a7a1912fed107abbcf29922971905
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/inject_runtime_type_invalid.stderr
@@ -0,0 +1,14 @@
+error: `#[inject_runtime_type]` can only be attached to `RuntimeCall`, `RuntimeEvent`, `RuntimeOrigin` or `PalletInfo`
+  --> tests/derive_impl_ui/inject_runtime_type_invalid.rs:15:5
+   |
+15 |     type RuntimeInfo = ();
+   |     ^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0046]: not all trait items implemented, missing: `RuntimeInfo`
+  --> tests/derive_impl_ui/inject_runtime_type_invalid.rs:13:1
+   |
+5  |     type RuntimeInfo;
+   |     ---------------- `RuntimeInfo` from trait
+...
+13 | impl Config for Pallet {
+   | ^^^^^^^^^^^^^^^^^^^^^^ missing `RuntimeInfo` in implementation
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/missing_disambiguation_path.rs b/substrate/frame/support/test/tests/derive_impl_ui/missing_disambiguation_path.rs
new file mode 100644
index 0000000000000000000000000000000000000000..21f1cc32009a5d27a6196e99caff6b2f718af8d4
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/missing_disambiguation_path.rs
@@ -0,0 +1,44 @@
+use frame_support::*;
+
+pub trait Animal {
+	type Locomotion;
+	type Diet;
+	type SleepingStrategy;
+	type Environment;
+
+	fn animal_name() -> &'static str;
+}
+
+pub type RunsOnFourLegs = (usize, usize, usize, usize);
+pub type RunsOnTwoLegs = (usize, usize);
+pub type Swims = isize;
+pub type Diurnal = bool;
+pub type Nocturnal = Option<bool>;
+pub type Omnivore = char;
+pub type Land = ((), ());
+pub type Sea = ((), (), ());
+pub type Carnivore = (char, char);
+
+pub struct FourLeggedAnimal {}
+
+#[register_default_impl(FourLeggedAnimal)]
+impl Animal for FourLeggedAnimal {
+	type Locomotion = RunsOnFourLegs;
+	type Diet = Omnivore;
+	type SleepingStrategy = Diurnal;
+	type Environment = Land;
+
+	fn animal_name() -> &'static str {
+		"A Four-Legged Animal"
+	}
+}
+
+pub struct AcquaticMammal {}
+
+#[derive_impl(FourLeggedAnimal as)]
+impl Animal for AcquaticMammal {
+	type Locomotion = (Swims, RunsOnFourLegs);
+	type Environment = (Land, Sea);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/missing_disambiguation_path.stderr b/substrate/frame/support/test/tests/derive_impl_ui/missing_disambiguation_path.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..85cd94ae08ae7ee72a6a67b0c0cd113abd7b70ff
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/missing_disambiguation_path.stderr
@@ -0,0 +1,7 @@
+error: unexpected end of input, expected identifier
+  --> tests/derive_impl_ui/missing_disambiguation_path.rs:38:1
+   |
+38 | #[derive_impl(FourLeggedAnimal as)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the attribute macro `derive_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/pass/basic_overriding.rs b/substrate/frame/support/test/tests/derive_impl_ui/pass/basic_overriding.rs
new file mode 100644
index 0000000000000000000000000000000000000000..336ddc315f8cb3f7387db6894db1106113698822
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/pass/basic_overriding.rs
@@ -0,0 +1,69 @@
+use frame_support::*;
+use static_assertions::assert_type_eq_all;
+
+pub trait Animal {
+	type Locomotion;
+	type Diet;
+	type SleepingStrategy;
+	type Environment;
+
+	fn animal_name() -> &'static str;
+}
+
+pub type RunsOnFourLegs = (usize, usize, usize, usize);
+pub type RunsOnTwoLegs = (usize, usize);
+pub type Swims = isize;
+pub type Diurnal = bool;
+pub type Nocturnal = Option<bool>;
+pub type Omnivore = char;
+pub type Land = ((), ());
+pub type Sea = ((), (), ());
+pub type Carnivore = (char, char);
+
+pub struct FourLeggedAnimal {}
+
+#[register_default_impl(FourLeggedAnimal)]
+impl Animal for FourLeggedAnimal {
+	type Locomotion = RunsOnFourLegs;
+	type Diet = Omnivore;
+	type SleepingStrategy = Diurnal;
+	type Environment = Land;
+
+	fn animal_name() -> &'static str {
+		"A Four-Legged Animal"
+	}
+}
+
+pub struct AcquaticMammal {}
+
+// without omitting the `as X`
+#[derive_impl(FourLeggedAnimal as Animal)]
+impl Animal for AcquaticMammal {
+	type Locomotion = (Swims, RunsOnFourLegs);
+	type Environment = (Land, Sea);
+}
+
+assert_type_eq_all!(<AcquaticMammal as Animal>::Locomotion, (Swims, RunsOnFourLegs));
+assert_type_eq_all!(<AcquaticMammal as Animal>::Environment, (Land, Sea));
+assert_type_eq_all!(<AcquaticMammal as Animal>::Diet, Omnivore);
+assert_type_eq_all!(<AcquaticMammal as Animal>::SleepingStrategy, Diurnal);
+
+pub struct Lion {}
+
+// test omitting the `as X`
+#[derive_impl(FourLeggedAnimal)]
+impl Animal for Lion {
+	type Diet = Carnivore;
+	type SleepingStrategy = Nocturnal;
+
+	fn animal_name() -> &'static str {
+		"Lion"
+	}
+}
+
+assert_type_eq_all!(<Lion as Animal>::Diet, Carnivore);
+assert_type_eq_all!(<Lion as Animal>::SleepingStrategy, Nocturnal);
+assert_type_eq_all!(<Lion as Animal>::Environment, Land);
+assert_type_eq_all!(<Lion as Animal>::Locomotion, RunsOnFourLegs);
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/pass/macro_magic_working.rs b/substrate/frame/support/test/tests/derive_impl_ui/pass/macro_magic_working.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec09bd15e01731b5c5cf544928e4dea264c8831b
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/pass/macro_magic_working.rs
@@ -0,0 +1,18 @@
+#[frame_support::macro_magic::export_tokens]
+struct MyCoolStruct {
+	field: u32,
+}
+
+// create a test receiver since `proc_support` isn't enabled so we're on our own in terms of
+// what we can call
+macro_rules! receiver {
+	($_tokens_var:ident, $($tokens:tt)*) => {
+		stringify!($($tokens)*)
+	};
+}
+
+fn main() {
+	let _instance: MyCoolStruct = MyCoolStruct { field: 3 };
+	let _str = __export_tokens_tt_my_cool_struct!(tokens, receiver);
+	// this compiling demonstrates that macro_magic is working properly
+}
diff --git a/substrate/frame/support/test/tests/derive_impl_ui/pass/runtime_type_working.rs b/substrate/frame/support/test/tests/derive_impl_ui/pass/runtime_type_working.rs
new file mode 100644
index 0000000000000000000000000000000000000000..04ad008944682cc0705ed04c8b239838e67286c7
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_impl_ui/pass/runtime_type_working.rs
@@ -0,0 +1,25 @@
+use frame_support::{*, pallet_prelude::inject_runtime_type};
+use static_assertions::assert_type_eq_all;
+
+pub trait Config {
+    type RuntimeCall;
+}
+
+type RuntimeCall = u32;
+
+struct Pallet;
+
+#[register_default_impl(Pallet)]
+impl Config for Pallet {
+    #[inject_runtime_type]
+    type RuntimeCall = ();
+}
+
+struct SomePallet;
+
+#[derive_impl(Pallet)] // Injects type RuntimeCall = RuntimeCall;
+impl Config for SomePallet {}
+
+assert_type_eq_all!(<SomePallet as Config>::RuntimeCall, u32);
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound.rs b/substrate/frame/support/test/tests/derive_no_bound.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dc78027f22ebad3acca901792cf4368522d17409
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound.rs
@@ -0,0 +1,253 @@
+// 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 DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound, and
+//! RuntimeDebugNoBound
+
+use frame_support::{
+	CloneNoBound, DebugNoBound, DefaultNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound,
+};
+
+#[derive(RuntimeDebugNoBound)]
+struct Unnamed(u64);
+
+#[test]
+fn runtime_debug_no_bound_display_correctly() {
+	// This test is not executed without std
+	assert_eq!(format!("{:?}", Unnamed(1)), "Unnamed(1)");
+}
+
+trait Config {
+	type C: std::fmt::Debug + Clone + Eq + PartialEq + Default;
+}
+
+struct Runtime;
+struct ImplNone;
+
+impl Config for Runtime {
+	type C = u32;
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound)]
+struct StructNamed<T: Config, U, V> {
+	a: u32,
+	b: u64,
+	c: T::C,
+	phantom: core::marker::PhantomData<(U, V)>,
+}
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn test_struct_named_debug_print() {
+	let a_1 = StructNamed::<Runtime, ImplNone, ImplNone> {
+		a: 1,
+		b: 2,
+		c: 3,
+		phantom: Default::default(),
+	};
+
+	assert_eq!(
+		format!("{:?}", a_1),
+		String::from("StructNamed { a: 1, b: 2, c: 3, phantom: PhantomData<(derive_no_bound::ImplNone, derive_no_bound::ImplNone)> }")
+	);
+}
+
+#[test]
+fn test_struct_named() {
+	let a_1 = StructNamed::<Runtime, ImplNone, ImplNone> {
+		a: 1,
+		b: 2,
+		c: 3,
+		phantom: Default::default(),
+	};
+
+	let a_default: StructNamed<Runtime, ImplNone, ImplNone> = Default::default();
+	assert_eq!(a_default.a, 0);
+	assert_eq!(a_default.b, 0);
+	assert_eq!(a_default.c, 0);
+	assert_eq!(a_default.phantom, Default::default());
+
+	let a_2 = a_1.clone();
+	assert_eq!(a_2.a, 1);
+	assert_eq!(a_2.b, 2);
+	assert_eq!(a_2.c, 3);
+	assert_eq!(a_2, a_1);
+
+	let b = StructNamed::<Runtime, ImplNone, ImplNone> {
+		a: 1,
+		b: 2,
+		c: 4,
+		phantom: Default::default(),
+	};
+
+	assert!(b != a_1);
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound)]
+struct StructUnnamed<T: Config, U, V>(u32, u64, T::C, core::marker::PhantomData<(U, V)>);
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn test_struct_unnamed_debug_print() {
+	let a_1 = StructUnnamed::<Runtime, ImplNone, ImplNone>(1, 2, 3, Default::default());
+	assert_eq!(format!("{:?}", a_1), String::from("StructUnnamed(1, 2, 3, PhantomData<(derive_no_bound::ImplNone, derive_no_bound::ImplNone)>)"));
+}
+
+#[test]
+fn test_struct_unnamed() {
+	let a_1 = StructUnnamed::<Runtime, ImplNone, ImplNone>(1, 2, 3, Default::default());
+
+	let a_default: StructUnnamed<Runtime, ImplNone, ImplNone> = Default::default();
+	assert_eq!(a_default.0, 0);
+	assert_eq!(a_default.1, 0);
+	assert_eq!(a_default.2, 0);
+	assert_eq!(a_default.3, Default::default());
+
+	let a_2 = a_1.clone();
+	assert_eq!(a_2.0, 1);
+	assert_eq!(a_2.1, 2);
+	assert_eq!(a_2.2, 3);
+	assert_eq!(a_2, a_1);
+
+	let b = StructUnnamed::<Runtime, ImplNone, ImplNone>(1, 2, 4, Default::default());
+
+	assert!(b != a_1);
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound)]
+struct StructNoGenerics {
+	field1: u32,
+	field2: u64,
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound)]
+enum EnumNoGenerics {
+	#[default]
+	VariantUnnamed(u32, u64),
+	VariantNamed {
+		a: u32,
+		b: u64,
+	},
+	VariantUnit,
+}
+
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound)]
+enum Enum<T: Config, U, V> {
+	#[default]
+	VariantUnnamed(u32, u64, T::C, core::marker::PhantomData<(U, V)>),
+	VariantNamed {
+		a: u32,
+		b: u64,
+		c: T::C,
+		phantom: core::marker::PhantomData<(U, V)>,
+	},
+	VariantUnit,
+	VariantUnit2,
+}
+
+// enum that will have a named default.
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound)]
+enum Enum2<T: Config> {
+	#[default]
+	VariantNamed {
+		a: u32,
+		b: u64,
+		c: T::C,
+	},
+	VariantUnnamed(u32, u64, T::C),
+	VariantUnit,
+	VariantUnit2,
+}
+
+// enum that will have a unit default.
+#[derive(DebugNoBound, CloneNoBound, EqNoBound, PartialEqNoBound, DefaultNoBound)]
+enum Enum3<T: Config> {
+	#[default]
+	VariantUnit,
+	VariantNamed {
+		a: u32,
+		b: u64,
+		c: T::C,
+	},
+	VariantUnnamed(u32, u64, T::C),
+	VariantUnit2,
+}
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn test_enum_debug_print() {
+	type TestEnum = Enum<Runtime, ImplNone, ImplNone>;
+	let variant_0 = TestEnum::VariantUnnamed(1, 2, 3, Default::default());
+	let variant_1 = TestEnum::VariantNamed { a: 1, b: 2, c: 3, phantom: Default::default() };
+	let variant_2 = TestEnum::VariantUnit;
+	let variant_3 = TestEnum::VariantUnit2;
+
+	assert_eq!(
+		format!("{:?}", variant_0),
+		String::from("Enum::VariantUnnamed(1, 2, 3, PhantomData<(derive_no_bound::ImplNone, derive_no_bound::ImplNone)>)"),
+	);
+	assert_eq!(
+		format!("{:?}", variant_1),
+		String::from("Enum::VariantNamed { a: 1, b: 2, c: 3, phantom: PhantomData<(derive_no_bound::ImplNone, derive_no_bound::ImplNone)> }"),
+	);
+	assert_eq!(format!("{:?}", variant_2), String::from("Enum::VariantUnit"));
+	assert_eq!(format!("{:?}", variant_3), String::from("Enum::VariantUnit2"));
+}
+
+#[test]
+fn test_enum() {
+	type TestEnum = Enum<Runtime, ImplNone, ImplNone>;
+	let variant_0 = TestEnum::VariantUnnamed(1, 2, 3, Default::default());
+	let variant_0_bis = TestEnum::VariantUnnamed(1, 2, 4, Default::default());
+	let variant_1 = TestEnum::VariantNamed { a: 1, b: 2, c: 3, phantom: Default::default() };
+	let variant_1_bis = TestEnum::VariantNamed { a: 1, b: 2, c: 4, phantom: Default::default() };
+	let variant_2 = TestEnum::VariantUnit;
+	let variant_3 = TestEnum::VariantUnit2;
+
+	let default: TestEnum = Default::default();
+	assert_eq!(
+		default,
+		// first variant is default.
+		TestEnum::VariantUnnamed(0, 0, 0, Default::default())
+	);
+
+	assert_eq!(Enum2::<Runtime>::default(), Enum2::<Runtime>::VariantNamed { a: 0, b: 0, c: 0 });
+	assert_eq!(Enum3::<Runtime>::default(), Enum3::<Runtime>::VariantUnit);
+
+	assert!(variant_0 != variant_0_bis);
+	assert!(variant_1 != variant_1_bis);
+	assert!(variant_0 != variant_1);
+	assert!(variant_0 != variant_2);
+	assert!(variant_0 != variant_3);
+	assert!(variant_1 != variant_0);
+	assert!(variant_1 != variant_2);
+	assert!(variant_1 != variant_3);
+	assert!(variant_2 != variant_0);
+	assert!(variant_2 != variant_1);
+	assert!(variant_2 != variant_3);
+	assert!(variant_3 != variant_0);
+	assert!(variant_3 != variant_1);
+	assert!(variant_3 != variant_2);
+
+	assert!(variant_0.clone() == variant_0);
+	assert!(variant_1.clone() == variant_1);
+	assert!(variant_2.clone() == variant_2);
+	assert!(variant_3.clone() == variant_3);
+}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui.rs b/substrate/frame/support/test/tests/derive_no_bound_ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b1c9283c0925a7b661f680811f612e5598f35f29
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui.rs
@@ -0,0 +1,32 @@
+// 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.
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn derive_no_bound_ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if std::env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("SKIP_WASM_BUILD", "1");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/derive_no_bound_ui/*.rs");
+}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/clone.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/clone.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2bc1cc492d171f695fa22334c3d53e1c4f30cae6
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/clone.rs
@@ -0,0 +1,10 @@
+trait Config {
+	type C;
+}
+
+#[derive(frame_support::CloneNoBound)]
+struct Foo<T: Config> {
+	c: T::C,
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/clone.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/clone.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..7744586e56bf4757994f2a92d373b763a3643df1
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/clone.stderr
@@ -0,0 +1,5 @@
+error[E0277]: the trait bound `<T as Config>::C: Clone` is not satisfied
+ --> tests/derive_no_bound_ui/clone.rs:7:2
+  |
+7 |     c: T::C,
+  |     ^ the trait `Clone` is not implemented for `<T as Config>::C`
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/debug.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/debug.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6016c3e6d98b8ca71eadc645382fd997071ec22d
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/debug.rs
@@ -0,0 +1,10 @@
+trait Config {
+	type C;
+}
+
+#[derive(frame_support::DebugNoBound)]
+struct Foo<T: Config> {
+	c: T::C,
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/debug.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/debug.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..acc7f80b376634e46e3301f9f76d061c9b329526
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/debug.stderr
@@ -0,0 +1,8 @@
+error[E0277]: `<T as Config>::C` doesn't implement `std::fmt::Debug`
+ --> tests/derive_no_bound_ui/debug.rs:7:2
+  |
+7 |     c: T::C,
+  |     ^ `<T as Config>::C` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+  |
+  = help: the trait `std::fmt::Debug` is not implemented for `<T as Config>::C`
+  = note: required for the cast from `<T as Config>::C` to the object type `dyn std::fmt::Debug`
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/default.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0780a88e6753daf9719aa98204b9e583f16c1b31
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default.rs
@@ -0,0 +1,10 @@
+trait Config {
+	type C;
+}
+
+#[derive(frame_support::DefaultNoBound)]
+struct Foo<T: Config> {
+	c: T::C,
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/default.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d56dd438f2a7fa2bf100920cab12151d8737fdd6
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default.stderr
@@ -0,0 +1,5 @@
+error[E0277]: the trait bound `<T as Config>::C: std::default::Default` is not satisfied
+ --> tests/derive_no_bound_ui/default.rs:7:2
+  |
+7 |     c: T::C,
+  |     ^ the trait `std::default::Default` is not implemented for `<T as Config>::C`
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_empty_enum.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/default_empty_enum.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51b6137c0075537bc249424ddce61125db8bd495
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_empty_enum.rs
@@ -0,0 +1,4 @@
+#[derive(frame_support::DefaultNoBound)]
+enum Empty {}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_empty_enum.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/default_empty_enum.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9c93b515adce51bc891f86d1fe765f9ca6ba8a5d
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_empty_enum.stderr
@@ -0,0 +1,5 @@
+error: cannot derive Default for an empty enum
+ --> tests/derive_no_bound_ui/default_empty_enum.rs:2:6
+  |
+2 | enum Empty {}
+  |      ^^^^^
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_no_attribute.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/default_no_attribute.rs
new file mode 100644
index 0000000000000000000000000000000000000000..185df01fe2b842341c417ba327e0fd11fb7942e8
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_no_attribute.rs
@@ -0,0 +1,11 @@
+trait Config {
+	type C;
+}
+
+#[derive(frame_support::DefaultNoBound)]
+enum Foo<T: Config> {
+	Bar(T::C),
+	Baz,
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_no_attribute.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/default_no_attribute.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..12e0023671587784b0c00accd57f501fb05d5f02
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_no_attribute.stderr
@@ -0,0 +1,5 @@
+error: no default declared, make a variant default by placing `#[default]` above it
+ --> tests/derive_no_bound_ui/default_no_attribute.rs:6:6
+  |
+6 | enum Foo<T: Config> {
+  |      ^^^
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_too_many_attributes.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/default_too_many_attributes.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3d175da6c056f917ebd33cc3fb7c70b7aaafe22
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_too_many_attributes.rs
@@ -0,0 +1,13 @@
+trait Config {
+	type C;
+}
+
+#[derive(frame_support::DefaultNoBound)]
+enum Foo<T: Config> {
+	#[default]
+	Bar(T::C),
+	#[default]
+	Baz,
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_too_many_attributes.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/default_too_many_attributes.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5430ef142c5c864581167a0db87fb78f68de02ef
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_too_many_attributes.stderr
@@ -0,0 +1,21 @@
+error: multiple declared defaults
+ --> tests/derive_no_bound_ui/default_too_many_attributes.rs:5:10
+  |
+5 | #[derive(frame_support::DefaultNoBound)]
+  |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the derive macro `frame_support::DefaultNoBound` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: first default
+ --> tests/derive_no_bound_ui/default_too_many_attributes.rs:7:2
+  |
+7 | /     #[default]
+8 | |     Bar(T::C),
+  | |_____________^
+
+error: additional default
+  --> tests/derive_no_bound_ui/default_too_many_attributes.rs:9:2
+   |
+9  | /     #[default]
+10 | |     Baz,
+   | |_______^
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_union.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/default_union.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5822cda1aa64df30f604df3a8438d1daacebc36e
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_union.rs
@@ -0,0 +1,7 @@
+#[derive(frame_support::DefaultNoBound)]
+union Foo {
+	field1: u32,
+	field2: (),
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/default_union.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/default_union.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1e01e1baaf8ac1793beb5b178864a5c7c32514bb
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/default_union.stderr
@@ -0,0 +1,5 @@
+error: Union type not supported by `derive(DefaultNoBound)`
+ --> tests/derive_no_bound_ui/default_union.rs:2:1
+  |
+2 | union Foo {
+  | ^^^^^
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/eq.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/eq.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a48452626368c08dd9d0df1265a344caccce86e7
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/eq.rs
@@ -0,0 +1,10 @@
+trait Config {
+	type C;
+}
+
+#[derive(frame_support::EqNoBound)]
+struct Foo<T: Config> {
+	c: T::C,
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/eq.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/eq.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..eb3345eede508649c5bdaa977edf15024cd5627a
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/eq.stderr
@@ -0,0 +1,12 @@
+error[E0277]: can't compare `Foo<T>` with `Foo<T>`
+ --> tests/derive_no_bound_ui/eq.rs:6:8
+  |
+6 | struct Foo<T: Config> {
+  |        ^^^^^^^^^^^^^^ no implementation for `Foo<T> == Foo<T>`
+  |
+  = help: the trait `PartialEq` is not implemented for `Foo<T>`
+note: required by a bound in `std::cmp::Eq`
+ --> $RUST/core/src/cmp.rs
+  |
+  | pub trait Eq: PartialEq<Self> {
+  |               ^^^^^^^^^^^^^^^ required by this bound in `Eq`
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.rs b/substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7bd6b7ef6a2e3c5fec0ee6488356c66a76b5593d
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.rs
@@ -0,0 +1,10 @@
+trait Config {
+	type C;
+}
+
+#[derive(frame_support::PartialEqNoBound)]
+struct Foo<T: Config> {
+	c: T::C,
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.stderr b/substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1c230db376a49e000f848fc0e130580f7b2a7a3e
--- /dev/null
+++ b/substrate/frame/support/test/tests/derive_no_bound_ui/partial_eq.stderr
@@ -0,0 +1,5 @@
+error[E0369]: binary operation `==` cannot be applied to type `<T as Config>::C`
+ --> tests/derive_no_bound_ui/partial_eq.rs:7:2
+  |
+7 |     c: T::C,
+  |     ^
diff --git a/substrate/frame/support/test/tests/final_keys.rs b/substrate/frame/support/test/tests/final_keys.rs
new file mode 100644
index 0000000000000000000000000000000000000000..765afaf1e660429603b906218d5e1beceea27224
--- /dev/null
+++ b/substrate/frame/support/test/tests/final_keys.rs
@@ -0,0 +1,333 @@
+// 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 codec::Encode;
+use frame_support::{derive_impl, storage::unhashed, StoragePrefixedMap};
+use frame_system::pallet_prelude::BlockNumberFor;
+
+use sp_core::{sr25519, ConstU32};
+use sp_io::{
+	hashing::{blake2_128, twox_128, twox_64},
+	TestExternalities,
+};
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, Verify},
+};
+
+#[frame_support::pallet]
+mod no_instance {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	pub type Value<T> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::storage]
+	pub type Map<T> = StorageMap<_, Blake2_128Concat, u32, u32, ValueQuery>;
+	#[pallet::storage]
+	pub type Map2<T> = StorageMap<_, Twox64Concat, u32, u32, ValueQuery>;
+
+	#[pallet::storage]
+	pub type DoubleMap<T> =
+		StorageDoubleMap<_, Blake2_128Concat, u32, Blake2_128Concat, u32, u32, ValueQuery>;
+	#[pallet::storage]
+	pub type DoubleMap2<T> =
+		StorageDoubleMap<_, Twox64Concat, u32, Twox64Concat, u32, u32, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn test_generic_value)]
+	pub type TestGenericValue<T: Config> = StorageValue<_, BlockNumberFor<T>, OptionQuery>;
+	#[pallet::storage]
+	#[pallet::getter(fn foo2)]
+	pub type TestGenericDoubleMap<T: Config> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		u32,
+		Blake2_128Concat,
+		BlockNumberFor<T>,
+		u32,
+		ValueQuery,
+	>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub value: u32,
+		pub test_generic_value: BlockNumberFor<T>,
+		pub test_generic_double_map: Vec<(u32, BlockNumberFor<T>, u32)>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			Self {
+				value: Default::default(),
+				test_generic_value: Default::default(),
+				test_generic_double_map: Default::default(),
+			}
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			<Value<T>>::put(self.value);
+			<TestGenericValue<T>>::put(&self.test_generic_value);
+			for (k1, k2, v) in &self.test_generic_double_map {
+				<TestGenericDoubleMap<T>>::insert(k1, k2, v);
+			}
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod instance {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+
+	#[pallet::storage]
+	pub type Value<T: Config<I>, I: 'static = ()> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::storage]
+	pub type Map<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, u32, u32, ValueQuery>;
+	#[pallet::storage]
+	pub type Map2<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Twox64Concat, u32, u32, ValueQuery>;
+
+	#[pallet::storage]
+	pub type DoubleMap<T: Config<I>, I: 'static = ()> =
+		StorageDoubleMap<_, Blake2_128Concat, u32, Blake2_128Concat, u32, u32, ValueQuery>;
+	#[pallet::storage]
+	pub type DoubleMap2<T: Config<I>, I: 'static = ()> =
+		StorageDoubleMap<_, Twox64Concat, u32, Twox64Concat, u32, u32, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn test_generic_value)]
+	pub type TestGenericValue<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BlockNumberFor<T>, OptionQuery>;
+	#[pallet::storage]
+	#[pallet::getter(fn foo2)]
+	pub type TestGenericDoubleMap<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		u32,
+		Blake2_128Concat,
+		BlockNumberFor<T>,
+		u32,
+		ValueQuery,
+	>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub value: u32,
+		pub test_generic_value: BlockNumberFor<T>,
+		pub test_generic_double_map: Vec<(u32, BlockNumberFor<T>, u32)>,
+		pub phantom: PhantomData<I>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			Self {
+				value: Default::default(),
+				test_generic_value: Default::default(),
+				test_generic_double_map: Default::default(),
+				phantom: Default::default(),
+			}
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			<Value<T, I>>::put(self.value);
+			<TestGenericValue<T, I>>::put(&self.test_generic_value);
+			for (k1, k2, v) in &self.test_generic_double_map {
+				<TestGenericDoubleMap<T, I>>::insert(k1, k2, v);
+			}
+		}
+	}
+}
+
+fn twox_64_concat(d: &[u8]) -> Vec<u8> {
+	let mut v = twox_64(d).to_vec();
+	v.extend_from_slice(d);
+	v
+}
+
+fn blake2_128_concat(d: &[u8]) -> Vec<u8> {
+	let mut v = blake2_128(d).to_vec();
+	v.extend_from_slice(d);
+	v
+}
+
+pub type BlockNumber = u32;
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+frame_support::construct_runtime!(
+	pub enum Runtime
+
+	{
+		System: frame_system,
+		FinalKeysNone: no_instance,
+		FinalKeysSome: instance,
+		Instance2FinalKeysSome: instance::<Instance2>,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl no_instance::Config for Runtime {}
+
+impl instance::Config for Runtime {}
+impl instance::Config<instance::Instance2> for Runtime {}
+
+#[test]
+fn final_keys_no_instance() {
+	TestExternalities::default().execute_with(|| {
+		<no_instance::Value<Runtime>>::put(1);
+		let k = [twox_128(b"FinalKeysNone"), twox_128(b"Value")].concat();
+		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));
+
+		<no_instance::Map<Runtime>>::insert(1, 2);
+		let mut k = [twox_128(b"FinalKeysNone"), twox_128(b"Map")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<no_instance::Map<Runtime>>::final_prefix());
+
+		<no_instance::Map2<Runtime>>::insert(1, 2);
+		let mut k = [twox_128(b"FinalKeysNone"), twox_128(b"Map2")].concat();
+		k.extend(1u32.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<no_instance::Map2<Runtime>>::final_prefix());
+
+		<no_instance::DoubleMap<Runtime>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"FinalKeysNone"), twox_128(b"DoubleMap")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<no_instance::DoubleMap<Runtime>>::final_prefix());
+
+		<no_instance::DoubleMap2<Runtime>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"FinalKeysNone"), twox_128(b"DoubleMap2")].concat();
+		k.extend(1u32.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<no_instance::DoubleMap2<Runtime>>::final_prefix());
+	});
+}
+
+#[test]
+fn final_keys_default_instance() {
+	TestExternalities::default().execute_with(|| {
+		<instance::Value<Runtime>>::put(1);
+		let k = [twox_128(b"FinalKeysSome"), twox_128(b"Value")].concat();
+		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));
+
+		<instance::Map<Runtime>>::insert(1, 2);
+		let mut k = [twox_128(b"FinalKeysSome"), twox_128(b"Map")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<instance::Map<Runtime>>::final_prefix());
+
+		<instance::Map2<Runtime>>::insert(1, 2);
+		let mut k = [twox_128(b"FinalKeysSome"), twox_128(b"Map2")].concat();
+		k.extend(1u32.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<instance::Map2<Runtime>>::final_prefix());
+
+		<instance::DoubleMap<Runtime>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"FinalKeysSome"), twox_128(b"DoubleMap")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<instance::DoubleMap<Runtime>>::final_prefix());
+
+		<instance::DoubleMap2<Runtime>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"FinalKeysSome"), twox_128(b"DoubleMap2")].concat();
+		k.extend(1u32.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<instance::DoubleMap2<Runtime>>::final_prefix());
+	});
+}
+
+#[test]
+fn final_keys_instance_2() {
+	TestExternalities::default().execute_with(|| {
+		<instance::Value<Runtime, instance::Instance2>>::put(1);
+		let k = [twox_128(b"Instance2FinalKeysSome"), twox_128(b"Value")].concat();
+		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));
+
+		<instance::Map<Runtime, instance::Instance2>>::insert(1, 2);
+		let mut k = [twox_128(b"Instance2FinalKeysSome"), twox_128(b"Map")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<instance::Map<Runtime, instance::Instance2>>::final_prefix());
+
+		<instance::Map2<Runtime, instance::Instance2>>::insert(1, 2);
+		let mut k = [twox_128(b"Instance2FinalKeysSome"), twox_128(b"Map2")].concat();
+		k.extend(1u32.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<instance::Map2<Runtime, instance::Instance2>>::final_prefix());
+
+		<instance::DoubleMap<Runtime, instance::Instance2>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Instance2FinalKeysSome"), twox_128(b"DoubleMap")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<instance::DoubleMap<Runtime, instance::Instance2>>::final_prefix());
+
+		<instance::DoubleMap2<Runtime, instance::Instance2>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Instance2FinalKeysSome"), twox_128(b"DoubleMap2")].concat();
+		k.extend(1u32.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<instance::DoubleMap2<Runtime, instance::Instance2>>::final_prefix());
+	});
+}
diff --git a/substrate/frame/support/test/tests/genesisconfig.rs b/substrate/frame/support/test/tests/genesisconfig.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c6781220692a942adfb445f8620c522b40e4e45a
--- /dev/null
+++ b/substrate/frame/support/test/tests/genesisconfig.rs
@@ -0,0 +1,99 @@
+// 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_support::derive_impl;
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_core::{sr25519, ConstU32};
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, Verify},
+};
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub type AppendableDM<T: Config> =
+		StorageDoubleMap<_, Identity, u32, Identity, BlockNumberFor<T>, Vec<u32>>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub t: Vec<(u32, BlockNumberFor<T>, Vec<u32>)>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			Self { t: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			for (k1, k2, v) in &self.t {
+				<AppendableDM<T>>::insert(k1, k2, v);
+			}
+		}
+	}
+}
+
+pub type BlockNumber = u32;
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+
+	{
+		System: frame_system,
+		MyPallet: pallet,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl pallet::Config for Test {}
+
+#[test]
+fn init_genesis_config() {
+	pallet::GenesisConfig::<Test>::default();
+}
diff --git a/substrate/frame/support/test/tests/instance.rs b/substrate/frame/support/test/tests/instance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43a93df9dea498a0245e3c88e195023c872b785c
--- /dev/null
+++ b/substrate/frame/support/test/tests/instance.rs
@@ -0,0 +1,485 @@
+// 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.
+
+#![recursion_limit = "128"]
+
+use frame_support::{
+	derive_impl,
+	inherent::{InherentData, InherentIdentifier, MakeFatalError, ProvideInherent},
+	traits::ConstU32,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_core::sr25519;
+use sp_metadata_ir::{
+	PalletStorageMetadataIR, StorageEntryMetadataIR, StorageEntryModifierIR, StorageEntryTypeIR,
+	StorageHasherIR,
+};
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, Verify},
+	BuildStorage,
+};
+
+pub trait Currency {}
+
+// Test for:
+// * No default instance
+// * Origin, Inherent, Event
+#[frame_support::pallet(dev_mode)]
+mod module1 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		type RuntimeOrigin: From<Origin<Self, I>>;
+		type SomeParameter: Get<u32>;
+		type GenericType: Parameter + Member + MaybeSerializeDeserialize + Default + MaxEncodedLen;
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		#[pallet::weight(0)]
+		pub fn one(origin: OriginFor<T>) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::deposit_event(Event::AnotherVariant(3));
+			Ok(())
+		}
+	}
+
+	#[pallet::storage]
+	#[pallet::getter(fn value)]
+	pub type Value<T: Config<I>, I: 'static = ()> = StorageValue<_, T::GenericType, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn map)]
+	pub type Map<T: Config<I>, I: 'static = ()> = StorageMap<_, Identity, u32, u64, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub value: <T as Config<I>>::GenericType,
+		pub test: BlockNumberFor<T>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			Self { value: Default::default(), test: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I>
+	where
+		BlockNumberFor<T>: std::fmt::Display,
+	{
+		fn build(&self) {
+			<Value<T, I>>::put(self.value.clone());
+			println!("{}", self.test);
+		}
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Test
+		Test,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		_Phantom(PhantomData<T>),
+		AnotherVariant(u32),
+	}
+
+	#[pallet::origin]
+	#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	#[scale_info(skip_type_params(I))]
+	pub enum Origin<T, I = ()> {
+		Members(u32),
+		_Phantom(PhantomData<(T, I)>),
+	}
+
+	pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"12345678";
+
+	#[pallet::inherent]
+	impl<T: Config<I>, I: 'static> ProvideInherent for Pallet<T, I>
+	where
+		BlockNumberFor<T>: From<u32>,
+	{
+		type Call = Call<T, I>;
+		type Error = MakeFatalError<()>;
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			unimplemented!();
+		}
+
+		fn check_inherent(_: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
+			unimplemented!();
+		}
+
+		fn is_inherent(_call: &Self::Call) -> bool {
+			unimplemented!();
+		}
+	}
+}
+
+// Test for:
+// * default instance
+// * use of no_genesis_config_phantom_data
+#[frame_support::pallet]
+mod module2 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type Amount: Parameter + MaybeSerializeDeserialize + Default + MaxEncodedLen;
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		type RuntimeOrigin: From<Origin<Self, I>>;
+	}
+
+	impl<T: Config<I>, I: 'static> Currency for Pallet<T, I> {}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+
+	#[pallet::storage]
+	pub type Value<T: Config<I>, I: 'static = ()> = StorageValue<_, T::Amount, ValueQuery>;
+
+	#[pallet::storage]
+	pub type Map<T: Config<I>, I: 'static = ()> = StorageMap<_, Identity, u64, u64, ValueQuery>;
+
+	#[pallet::storage]
+	pub type DoubleMap<T: Config<I>, I: 'static = ()> =
+		StorageDoubleMap<_, Identity, u64, Identity, u64, u64, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		pub value: T::Amount,
+		pub map: Vec<(u64, u64)>,
+		pub double_map: Vec<(u64, u64, u64)>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			Self {
+				value: Default::default(),
+				map: Default::default(),
+				double_map: Default::default(),
+			}
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I>
+	where
+		BlockNumberFor<T>: std::fmt::Display,
+	{
+		fn build(&self) {
+			<Value<T, I>>::put(self.value.clone());
+			for (k, v) in &self.map {
+				<Map<T, I>>::insert(k, v);
+			}
+			for (k1, k2, v) in &self.double_map {
+				<DoubleMap<T, I>>::insert(k1, k2, v);
+			}
+		}
+	}
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		Variant(T::Amount),
+	}
+
+	#[pallet::origin]
+	#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	#[scale_info(skip_type_params(I))]
+	pub enum Origin<T, I = ()> {
+		Members(u32),
+		_Phantom(PhantomData<(T, I)>),
+	}
+
+	pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"12345678";
+
+	#[pallet::inherent]
+	impl<T: Config<I>, I: 'static> ProvideInherent for Pallet<T, I> {
+		type Call = Call<T, I>;
+		type Error = MakeFatalError<()>;
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			unimplemented!();
+		}
+
+		fn check_inherent(_call: &Self::Call, _data: &InherentData) -> Result<(), Self::Error> {
+			unimplemented!();
+		}
+
+		fn is_inherent(_call: &Self::Call) -> bool {
+			unimplemented!();
+		}
+	}
+}
+
+// Test for:
+// * Depends on multiple instances of a module with instances
+#[frame_support::pallet]
+mod module3 {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>:
+		frame_system::Config + module2::Config<I> + module2::Config<module2::Instance1>
+	{
+		type Currency: Currency;
+		type Currency2: Currency;
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+}
+
+pub type BlockNumber = u32;
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+frame_support::construct_runtime!(
+	pub enum Runtime
+	{
+		System: frame_system::{Pallet, Call, Event<T>},
+		Module1_1: module1::<Instance1>::{
+			Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>, Inherent
+		},
+		Module1_2: module1::<Instance2>::{
+			Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>, Inherent
+		},
+		Module2: module2::{Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>, Inherent},
+		Module2_1: module2::<Instance1>::{
+			Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>, Inherent
+		},
+		Module2_2: module2::<Instance2>::{
+			Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>, Inherent
+		},
+		Module2_3: module2::<Instance3>::{
+			Pallet, Call, Storage, Event<T>, Config<T>, Origin<T>, Inherent
+		},
+		Module3: module3::{Pallet, Call},
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl module1::Config<module1::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type SomeParameter = ConstU32<100>;
+	type GenericType = u32;
+}
+impl module1::Config<module1::Instance2> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+	type SomeParameter = ConstU32<100>;
+	type GenericType = u32;
+}
+impl module2::Config for Runtime {
+	type Amount = u16;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module2::Config<module2::Instance1> for Runtime {
+	type Amount = u32;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module2::Config<module2::Instance2> for Runtime {
+	type Amount = u32;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module2::Config<module2::Instance3> for Runtime {
+	type Amount = u64;
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeOrigin = RuntimeOrigin;
+}
+impl module3::Config for Runtime {
+	type Currency = Module2_2;
+	type Currency2 = Module2_3;
+}
+
+fn new_test_ext() -> sp_io::TestExternalities {
+	RuntimeGenesisConfig {
+		module_1_1: module1::GenesisConfig { value: 3, test: 2 },
+		module_1_2: module1::GenesisConfig { value: 4, test: 5 },
+		module_2: module2::GenesisConfig {
+			value: 4,
+			map: vec![(0, 0)],
+			double_map: vec![(0, 0, 0)],
+		},
+		module_2_1: module2::GenesisConfig {
+			value: 4,
+			map: vec![(0, 0)],
+			double_map: vec![(0, 0, 0)],
+		},
+		module_2_2: Default::default(),
+		module_2_3: Default::default(),
+	}
+	.build_storage()
+	.unwrap()
+	.into()
+}
+
+#[test]
+fn storage_instance_independence() {
+	let mut storage = sp_core::storage::Storage {
+		top: std::collections::BTreeMap::new(),
+		children_default: std::collections::HashMap::new(),
+	};
+	sp_state_machine::BasicExternalities::execute_with_storage(&mut storage, || {
+		module2::Value::<Runtime>::put(0);
+		module2::Value::<Runtime, module2::Instance1>::put(0);
+		module2::Value::<Runtime, module2::Instance2>::put(0);
+		module2::Value::<Runtime, module2::Instance3>::put(0);
+		module2::Map::<Runtime>::insert(0, 0);
+		module2::Map::<Runtime, module2::Instance1>::insert(0, 0);
+		module2::Map::<Runtime, module2::Instance2>::insert(0, 0);
+		module2::Map::<Runtime, module2::Instance3>::insert(0, 0);
+		module2::DoubleMap::<Runtime>::insert(&0, &0, &0);
+		module2::DoubleMap::<Runtime, module2::Instance1>::insert(&0, &0, &0);
+		module2::DoubleMap::<Runtime, module2::Instance2>::insert(&0, &0, &0);
+		module2::DoubleMap::<Runtime, module2::Instance3>::insert(&0, &0, &0);
+	});
+	// 12 storage values.
+	assert_eq!(storage.top.len(), 12);
+}
+
+#[test]
+fn storage_with_instance_basic_operation() {
+	new_test_ext().execute_with(|| {
+		type Value = module2::Value<Runtime, module2::Instance1>;
+		type Map = module2::Map<Runtime, module2::Instance1>;
+		type DoubleMap = module2::DoubleMap<Runtime, module2::Instance1>;
+
+		assert_eq!(Value::exists(), true);
+		assert_eq!(Value::get(), 4);
+		Value::put(1);
+		assert_eq!(Value::get(), 1);
+		assert_eq!(Value::take(), 1);
+		assert_eq!(Value::get(), 0);
+		Value::mutate(|a| *a = 2);
+		assert_eq!(Value::get(), 2);
+		Value::kill();
+		assert_eq!(Value::exists(), false);
+		assert_eq!(Value::get(), 0);
+
+		let key = 1;
+		assert_eq!(Map::contains_key(0), true);
+		assert_eq!(Map::contains_key(key), false);
+		Map::insert(key, 1);
+		assert_eq!(Map::get(key), 1);
+		assert_eq!(Map::take(key), 1);
+		assert_eq!(Map::get(key), 0);
+		Map::mutate(key, |a| *a = 2);
+		assert_eq!(Map::get(key), 2);
+		Map::remove(key);
+		assert_eq!(Map::contains_key(key), false);
+		assert_eq!(Map::get(key), 0);
+
+		let key1 = 1;
+		let key2 = 1;
+		assert_eq!(DoubleMap::contains_key(&0, &0), true);
+		assert_eq!(DoubleMap::contains_key(&key1, &key2), false);
+		DoubleMap::insert(&key1, &key2, &1);
+		assert_eq!(DoubleMap::get(&key1, &key2), 1);
+		assert_eq!(DoubleMap::take(&key1, &key2), 1);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0);
+		DoubleMap::mutate(&key1, &key2, |a| *a = 2);
+		assert_eq!(DoubleMap::get(&key1, &key2), 2);
+		DoubleMap::remove(&key1, &key2);
+		assert_eq!(DoubleMap::get(&key1, &key2), 0);
+	});
+}
+
+fn expected_metadata() -> PalletStorageMetadataIR {
+	PalletStorageMetadataIR {
+		prefix: "Module2_2",
+		entries: vec![
+			StorageEntryMetadataIR {
+				name: "Value",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Plain(scale_info::meta_type::<u32>()),
+				default: vec![0, 0, 0, 0],
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "Map",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Identity],
+					key: scale_info::meta_type::<u64>(),
+					value: scale_info::meta_type::<u64>(),
+				},
+				default: [0u8; 8].to_vec(),
+				docs: vec![],
+			},
+			StorageEntryMetadataIR {
+				name: "DoubleMap",
+				modifier: StorageEntryModifierIR::Default,
+				ty: StorageEntryTypeIR::Map {
+					hashers: vec![StorageHasherIR::Identity, StorageHasherIR::Identity],
+					key: scale_info::meta_type::<(u64, u64)>(),
+					value: scale_info::meta_type::<u64>(),
+				},
+				default: [0u8; 8].to_vec(),
+				docs: vec![],
+			},
+		],
+	}
+}
+
+#[test]
+fn test_instance_storage_metadata() {
+	let metadata = Module2_2::storage_metadata();
+	pretty_assertions::assert_eq!(expected_metadata(), metadata);
+}
diff --git a/substrate/frame/support/test/tests/issue2219.rs b/substrate/frame/support/test/tests/issue2219.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4016707b51a8def242cc16a23f58e9955a9c6679
--- /dev/null
+++ b/substrate/frame/support/test/tests/issue2219.rs
@@ -0,0 +1,197 @@
+// 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_support::derive_impl;
+use frame_system::pallet_prelude::BlockNumberFor;
+use sp_core::{sr25519, ConstU64};
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, Verify},
+};
+
+#[frame_support::pallet]
+mod module {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+
+	pub type Request<T> = (<T as frame_system::Config>::AccountId, Role, BlockNumberFor<T>);
+	pub type Requests<T> = Vec<Request<T>>;
+
+	#[derive(Copy, Clone, Eq, PartialEq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub enum Role {
+		Storage,
+	}
+
+	#[derive(Copy, Clone, Eq, PartialEq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub struct RoleParameters<T: Config> {
+		// minimum actors to maintain - if role is unstaking
+		// and remaining actors would be less that this value - prevent or punish for unstaking
+		pub min_actors: u32,
+
+		// the maximum number of spots available to fill for a role
+		pub max_actors: u32,
+
+		// payouts are made at this block interval
+		pub reward_period: BlockNumberFor<T>,
+
+		// minimum amount of time before being able to unstake
+		pub bonding_period: BlockNumberFor<T>,
+
+		// how long tokens remain locked for after unstaking
+		pub unbonding_period: BlockNumberFor<T>,
+
+		// minimum period required to be in service. unbonding before this time is highly penalized
+		pub min_service_period: BlockNumberFor<T>,
+
+		// "startup" time allowed for roles that need to sync their infrastructure
+		// with other providers before they are considered in service and punishable for
+		// not delivering required level of service.
+		pub startup_grace_period: BlockNumberFor<T>,
+	}
+
+	impl<T: Config> Default for RoleParameters<T> {
+		fn default() -> Self {
+			Self {
+				max_actors: 10,
+				reward_period: BlockNumberFor::<T>::default(),
+				unbonding_period: BlockNumberFor::<T>::default(),
+
+				// not currently used
+				min_actors: 5,
+				bonding_period: BlockNumberFor::<T>::default(),
+				min_service_period: BlockNumberFor::<T>::default(),
+				startup_grace_period: BlockNumberFor::<T>::default(),
+			}
+		}
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config + TypeInfo {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	/// requirements to enter and maintain status in roles
+	#[pallet::storage]
+	#[pallet::getter(fn parameters)]
+	pub type Parameters<T: Config> =
+		StorageMap<_, Blake2_128Concat, Role, RoleParameters<T>, OptionQuery>;
+
+	/// the roles members can enter into
+	#[pallet::storage]
+	#[pallet::getter(fn available_roles)]
+	#[pallet::unbounded]
+	pub type AvailableRoles<T: Config> = StorageValue<_, Vec<Role>, ValueQuery>;
+
+	/// Actors list
+	#[pallet::storage]
+	#[pallet::getter(fn actor_account_ids)]
+	#[pallet::unbounded]
+	pub type ActorAccountIds<T: Config> = StorageValue<_, Vec<T::AccountId>>;
+
+	/// actor accounts associated with a role
+	#[pallet::storage]
+	#[pallet::getter(fn account_ids_by_role)]
+	#[pallet::unbounded]
+	pub type AccountIdsByRole<T: Config> = StorageMap<_, Blake2_128Concat, Role, Vec<T::AccountId>>;
+
+	/// tokens locked until given block number
+	#[pallet::storage]
+	#[pallet::getter(fn bondage)]
+	pub type Bondage<T: Config> = StorageMap<_, Blake2_128Concat, T::AccountId, BlockNumberFor<T>>;
+
+	/// First step before enter a role is registering intent with a new account/key.
+	/// This is done by sending a role_entry_request() from the new account.
+	/// The member must then send a stake() transaction to approve the request and enter the desired
+	/// role. The account making the request will be bonded and must have
+	/// sufficient balance to cover the minimum stake for the role.
+	/// Bonding only occurs after successful entry into a role.
+	#[pallet::storage]
+	#[pallet::getter(fn role_entry_requests)]
+	#[pallet::unbounded]
+	pub type RoleEntryRequests<T: Config> = StorageValue<_, Requests<T>>;
+
+	/// Entry request expires after this number of blocks
+	#[pallet::storage]
+	#[pallet::getter(fn request_life_time)]
+	pub type RequestLifeTime<T: Config> = StorageValue<_, u64, ValueQuery, ConstU64<0>>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub enable_storage_role: bool,
+		pub request_life_time: u64,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			if self.enable_storage_role {
+				<Parameters<T>>::insert(Role::Storage, <RoleParameters<T>>::default());
+				<AvailableRoles<T>>::put(vec![Role::Storage]);
+			}
+			<RequestLifeTime<T>>::put(self.request_life_time);
+		}
+	}
+}
+
+pub type BlockNumber = u64;
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl module::Config for Runtime {}
+
+frame_support::construct_runtime!(
+	pub struct Runtime {
+		System: frame_system,
+		Module: module,
+	}
+);
+
+#[test]
+fn create_genesis_config() {
+	let config = RuntimeGenesisConfig {
+		system: Default::default(),
+		module: module::GenesisConfig {
+			request_life_time: 0,
+			enable_storage_role: true,
+			..Default::default()
+		},
+	};
+	assert_eq!(config.module.request_life_time, 0);
+	assert!(config.module.enable_storage_role);
+}
diff --git a/substrate/frame/support/test/tests/origin.rs b/substrate/frame/support/test/tests/origin.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5682bb500c7e366ba6f6da1cd6e0b70569c4a6a7
--- /dev/null
+++ b/substrate/frame/support/test/tests/origin.rs
@@ -0,0 +1,236 @@
+// 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.
+
+//! RuntimeOrigin tests for construct_runtime macro
+
+#![recursion_limit = "128"]
+
+use frame_support::{
+	derive_impl,
+	traits::{Contains, OriginTrait},
+};
+use sp_core::ConstU32;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+mod nested {
+	#[frame_support::pallet(dev_mode)]
+	pub mod module {
+		use frame_support::pallet_prelude::*;
+		use frame_system::pallet_prelude::*;
+
+		#[pallet::pallet]
+		pub struct Pallet<T>(_);
+
+		#[pallet::config]
+		pub trait Config: frame_system::Config {
+			type RuntimeEvent: From<Event<Self>>
+				+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		}
+
+		#[pallet::call]
+		impl<T: Config> Pallet<T> {
+			pub fn fail(_origin: OriginFor<T>) -> DispatchResult {
+				Err(Error::<T>::Something.into())
+			}
+		}
+
+		#[pallet::origin]
+		#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+		pub struct Origin;
+
+		#[pallet::event]
+		pub enum Event<T> {
+			A,
+		}
+
+		#[pallet::error]
+		pub enum Error<T> {
+			Something,
+		}
+
+		#[pallet::genesis_config]
+		#[derive(frame_support::DefaultNoBound)]
+		pub struct GenesisConfig<T: Config> {
+			#[serde(skip)]
+			pub _config: sp_std::marker::PhantomData<T>,
+		}
+
+		#[pallet::genesis_build]
+		impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+			fn build(&self) {}
+		}
+	}
+}
+
+#[frame_support::pallet(dev_mode)]
+pub mod module {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn fail(_origin: OriginFor<T>) -> DispatchResult {
+			Err(Error::<T>::Something.into())
+		}
+		pub fn aux_1(_origin: OriginFor<T>, #[pallet::compact] _data: u32) -> DispatchResult {
+			unreachable!()
+		}
+		pub fn aux_2(
+			_origin: OriginFor<T>,
+			_data: i32,
+			#[pallet::compact] _data2: u32,
+		) -> DispatchResult {
+			unreachable!()
+		}
+		#[pallet::weight(0)]
+		pub fn aux_3(_origin: OriginFor<T>, _data: i32, _data2: String) -> DispatchResult {
+			unreachable!()
+		}
+		#[pallet::weight(3)]
+		pub fn aux_4(_origin: OriginFor<T>) -> DispatchResult {
+			unreachable!()
+		}
+		#[pallet::weight((5, DispatchClass::Operational))]
+		pub fn operational(_origin: OriginFor<T>) -> DispatchResult {
+			unreachable!()
+		}
+	}
+
+	#[pallet::origin]
+	#[derive(Clone, PartialEq, Eq, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub struct Origin<T>(pub PhantomData<T>);
+
+	#[pallet::event]
+	pub enum Event<T> {
+		A,
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		Something,
+	}
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {}
+	}
+}
+
+pub struct BaseCallFilter;
+impl Contains<RuntimeCall> for BaseCallFilter {
+	fn contains(c: &RuntimeCall) -> bool {
+		match c {
+			RuntimeCall::NestedModule(_) => true,
+			_ => false,
+		}
+	}
+}
+
+pub type BlockNumber = u32;
+pub type AccountId = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+frame_support::construct_runtime!(
+	pub enum RuntimeOriginTest
+	{
+		System: frame_system,
+		NestedModule: nested::module,
+		Module: module,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl nested::module::Config for RuntimeOriginTest {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl module::Config for RuntimeOriginTest {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+#[test]
+fn origin_default_filter() {
+	let accepted_call = nested::module::Call::fail {}.into();
+	let rejected_call = module::Call::fail {}.into();
+
+	assert_eq!(RuntimeOrigin::root().filter_call(&accepted_call), true);
+	assert_eq!(RuntimeOrigin::root().filter_call(&rejected_call), true);
+	assert_eq!(RuntimeOrigin::none().filter_call(&accepted_call), true);
+	assert_eq!(RuntimeOrigin::none().filter_call(&rejected_call), false);
+	assert_eq!(RuntimeOrigin::signed(0).filter_call(&accepted_call), true);
+	assert_eq!(RuntimeOrigin::signed(0).filter_call(&rejected_call), false);
+	assert_eq!(RuntimeOrigin::from(Some(0)).filter_call(&accepted_call), true);
+	assert_eq!(RuntimeOrigin::from(Some(0)).filter_call(&rejected_call), false);
+	assert_eq!(RuntimeOrigin::from(None).filter_call(&accepted_call), true);
+	assert_eq!(RuntimeOrigin::from(None).filter_call(&rejected_call), false);
+	assert_eq!(RuntimeOrigin::from(nested::module::Origin).filter_call(&accepted_call), true);
+	assert_eq!(RuntimeOrigin::from(nested::module::Origin).filter_call(&rejected_call), false);
+
+	let mut origin = RuntimeOrigin::from(Some(0));
+	origin.add_filter(|c| matches!(c, RuntimeCall::Module(_)));
+	assert_eq!(origin.filter_call(&accepted_call), false);
+	assert_eq!(origin.filter_call(&rejected_call), false);
+
+	// Now test for root origin and filters:
+	let mut origin = RuntimeOrigin::from(Some(0));
+	origin.set_caller_from(RuntimeOrigin::root());
+	assert!(matches!(origin.caller, OriginCaller::system(frame_support_test::RawOrigin::Root)));
+
+	// Root origin bypass all filter.
+	assert_eq!(origin.filter_call(&accepted_call), true);
+	assert_eq!(origin.filter_call(&rejected_call), true);
+
+	origin.set_caller_from(RuntimeOrigin::from(Some(0)));
+
+	// Back to another signed origin, the filtered are now effective again
+	assert_eq!(origin.filter_call(&accepted_call), true);
+	assert_eq!(origin.filter_call(&rejected_call), false);
+
+	origin.set_caller_from(RuntimeOrigin::root());
+	origin.reset_filter();
+
+	// Root origin bypass all filter, even when they are reset.
+	assert_eq!(origin.filter_call(&accepted_call), true);
+	assert_eq!(origin.filter_call(&rejected_call), true);
+}
diff --git a/substrate/frame/support/test/tests/pallet.rs b/substrate/frame/support/test/tests/pallet.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8c85cd56959533f0e35cdebc35d7b48b03a6b225
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet.rs
@@ -0,0 +1,2444 @@
+// 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_support::{
+	assert_ok,
+	dispatch::{
+		DispatchClass, DispatchInfo, Dispatchable, GetDispatchInfo, Parameter, Pays,
+		UnfilteredDispatchable,
+	},
+	dispatch_context::with_context,
+	pallet_prelude::{StorageInfoTrait, ValueQuery},
+	parameter_types,
+	storage::unhashed,
+	traits::{
+		ConstU32, GetCallIndex, GetCallName, GetStorageVersion, OnFinalize, OnGenesis,
+		OnInitialize, OnRuntimeUpgrade, PalletError, PalletInfoAccess, StorageVersion,
+	},
+	weights::{RuntimeDbWeight, Weight},
+};
+use scale_info::{meta_type, TypeInfo};
+use sp_io::{
+	hashing::{blake2_128, twox_128, twox_64},
+	TestExternalities,
+};
+use sp_runtime::{
+	traits::{Extrinsic as ExtrinsicT, SignaturePayload as SignaturePayloadT},
+	DispatchError, ModuleError,
+};
+
+parameter_types! {
+	/// Used to control if the storage version should be updated.
+	storage UpdateStorageVersion: bool = false;
+}
+
+/// Latest stable metadata version used for testing.
+const LATEST_METADATA_VERSION: u32 = 15;
+
+pub struct SomeType1;
+impl From<SomeType1> for u64 {
+	fn from(_t: SomeType1) -> Self {
+		0u64
+	}
+}
+
+pub struct SomeType2;
+impl From<SomeType2> for u64 {
+	fn from(_t: SomeType2) -> Self {
+		100u64
+	}
+}
+
+pub struct SomeType3;
+impl From<SomeType3> for u64 {
+	fn from(_t: SomeType3) -> Self {
+		0u64
+	}
+}
+
+pub struct SomeType4;
+impl From<SomeType4> for u64 {
+	fn from(_t: SomeType4) -> Self {
+		0u64
+	}
+}
+
+pub struct SomeType5;
+impl From<SomeType5> for u64 {
+	fn from(_t: SomeType5) -> Self {
+		0u64
+	}
+}
+
+pub struct SomeType6;
+impl From<SomeType6> for u64 {
+	fn from(_t: SomeType6) -> Self {
+		0u64
+	}
+}
+
+pub struct SomeType7;
+impl From<SomeType7> for u64 {
+	fn from(_t: SomeType7) -> Self {
+		0u64
+	}
+}
+
+pub trait SomeAssociation1 {
+	type _1: Parameter + codec::MaxEncodedLen + TypeInfo;
+}
+impl SomeAssociation1 for u64 {
+	type _1 = u64;
+}
+
+pub trait SomeAssociation2 {
+	type _2: Parameter + codec::MaxEncodedLen + TypeInfo;
+}
+impl SomeAssociation2 for u64 {
+	type _2 = u64;
+}
+
+#[frame_support::pallet]
+/// Pallet documentation
+// Comments should not be included in the pallet documentation
+#[pallet_doc("../../README.md")]
+#[doc = include_str!("../../README.md")]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+	use sp_runtime::DispatchResult;
+
+	type BalanceOf<T> = <T as Config>::Balance;
+
+	pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(10);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
+	{
+		/// Some comment
+		/// Some comment
+		#[pallet::constant]
+		type MyGetParam: Get<u32>;
+
+		/// Some comment
+		/// Some comment
+		#[pallet::constant]
+		type MyGetParam2: Get<u32>;
+
+		#[pallet::constant]
+		type MyGetParam3: Get<<Self::AccountId as SomeAssociation1>::_1>;
+
+		type Balance: Parameter + Default + TypeInfo;
+
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::extra_constants]
+	impl<T: Config> Pallet<T>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType2>,
+	{
+		/// Some doc
+		/// Some doc
+		fn some_extra() -> T::AccountId {
+			SomeType2.into()
+		}
+
+		/// Some doc
+		fn some_extra_extra() -> T::AccountId {
+			SomeType1.into()
+		}
+
+		/// Some doc
+		#[pallet::constant_name(SomeExtraRename)]
+		fn some_extra_rename() -> T::AccountId {
+			SomeType1.into()
+		}
+	}
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T>
+	where
+		T::AccountId: From<SomeType2> + From<SomeType1> + SomeAssociation1,
+	{
+		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType2); // Test for where clause
+			Self::deposit_event(Event::Something(10));
+			Weight::from_parts(10, 0)
+		}
+		fn on_finalize(_: BlockNumberFor<T>) {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType2); // Test for where clause
+			Self::deposit_event(Event::Something(20));
+		}
+		fn on_runtime_upgrade() -> Weight {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType2); // Test for where clause
+			Self::deposit_event(Event::Something(30));
+			Weight::from_parts(30, 0)
+		}
+		fn integrity_test() {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType2); // Test for where clause
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T>
+	where
+		T::AccountId: From<SomeType1> + From<SomeType3> + SomeAssociation1,
+	{
+		/// Doc comment put in metadata
+		#[pallet::call_index(0)]
+		#[pallet::weight(Weight::from_parts(*_foo as u64, 0))]
+		pub fn foo(
+			origin: OriginFor<T>,
+			#[pallet::compact] _foo: u32,
+			_bar: u32,
+		) -> DispatchResultWithPostInfo {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType3); // Test for where clause
+			let _ = origin;
+			Self::deposit_event(Event::Something(3));
+			Ok(().into())
+		}
+
+		/// Doc comment put in metadata
+		#[pallet::call_index(1)]
+		#[pallet::weight({1})]
+		pub fn foo_storage_layer(
+			_origin: OriginFor<T>,
+			#[pallet::compact] foo: u32,
+		) -> DispatchResultWithPostInfo {
+			Self::deposit_event(Event::Something(0));
+			if foo == 0 {
+				Err(Error::<T>::InsufficientProposersBalance)?;
+			}
+
+			Ok(().into())
+		}
+
+		#[pallet::call_index(4)]
+		#[pallet::weight({1})]
+		pub fn foo_index_out_of_order(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+
+		// Test for DispatchResult return type
+		#[pallet::call_index(2)]
+		#[pallet::weight({1})]
+		pub fn foo_no_post_info(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+
+		#[pallet::call_index(3)]
+		#[pallet::weight({1})]
+		pub fn check_for_dispatch_context(_origin: OriginFor<T>) -> DispatchResult {
+			with_context::<(), _>(|_| ()).ok_or_else(|| DispatchError::Unavailable)
+		}
+	}
+
+	#[pallet::error]
+	#[derive(PartialEq, Eq)]
+	pub enum Error<T> {
+		/// doc comment put into metadata
+		InsufficientProposersBalance,
+		NonExistentStorageValue,
+		Code(u8),
+		#[codec(skip)]
+		Skipped(u128),
+		CompactU8(#[codec(compact)] u8),
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(fn deposit_event)]
+	pub enum Event<T: Config>
+	where
+		T::AccountId: SomeAssociation1 + From<SomeType1>,
+	{
+		/// doc comment put in metadata
+		Proposed(<T as frame_system::Config>::AccountId),
+		/// doc
+		Spending(BalanceOf<T>),
+		Something(u32),
+		SomethingElse(<T::AccountId as SomeAssociation1>::_1),
+	}
+
+	#[pallet::storage]
+	pub type ValueWhereClause<T: Config>
+	where
+		T::AccountId: SomeAssociation2,
+	= StorageValue<_, <T::AccountId as SomeAssociation2>::_2>;
+
+	#[pallet::storage]
+	pub type Value<T> = StorageValue<Value = u32>;
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "Value2"]
+	pub type RenamedValue<T> = StorageValue<Value = u64>;
+
+	/// Test some doc
+	#[pallet::type_value]
+	pub fn MyDefault<T: Config>() -> u16
+	where
+		T::AccountId: From<SomeType7> + From<SomeType1> + SomeAssociation1,
+	{
+		let _ = T::AccountId::from(SomeType7); // Test where clause works
+		4u16
+	}
+
+	#[pallet::storage]
+	pub type Map<T: Config>
+	where
+		T::AccountId: From<SomeType7>,
+	= StorageMap<_, Blake2_128Concat, u8, u16, ValueQuery, MyDefault<T>>;
+
+	#[pallet::storage]
+	pub type Map2<T> =
+		StorageMap<Hasher = Twox64Concat, Key = u16, Value = u32, MaxValues = ConstU32<3>>;
+
+	#[pallet::storage]
+	pub type Map3<T> =
+		StorageMap<_, Blake2_128Concat, u32, u64, ResultQuery<Error<T>::NonExistentStorageValue>>;
+
+	#[pallet::storage]
+	pub type DoubleMap<T> = StorageDoubleMap<_, Blake2_128Concat, u8, Twox64Concat, u16, u32>;
+
+	#[pallet::storage]
+	pub type DoubleMap2<T> = StorageDoubleMap<
+		Hasher1 = Twox64Concat,
+		Key1 = u16,
+		Hasher2 = Blake2_128Concat,
+		Key2 = u32,
+		Value = u64,
+		MaxValues = ConstU32<5>,
+	>;
+
+	#[pallet::storage]
+	pub type DoubleMap3<T> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		u32,
+		Twox64Concat,
+		u64,
+		u128,
+		ResultQuery<Error<T>::NonExistentStorageValue>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn nmap)]
+	pub type NMap<T> = StorageNMap<_, storage::Key<Blake2_128Concat, u8>, u32>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn nmap2)]
+	pub type NMap2<T> = StorageNMap<
+		Key = (NMapKey<Twox64Concat, u16>, NMapKey<Blake2_128Concat, u32>),
+		Value = u64,
+		MaxValues = ConstU32<11>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn nmap3)]
+	pub type NMap3<T> = StorageNMap<
+		_,
+		(NMapKey<Blake2_128Concat, u8>, NMapKey<Twox64Concat, u16>),
+		u128,
+		ResultQuery<Error<T>::NonExistentStorageValue>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn counted_nmap)]
+	pub type CountedNMap<T> = CountedStorageNMap<_, storage::Key<Blake2_128Concat, u8>, u32>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn counted_nmap2)]
+	pub type CountedNMap2<T> = CountedStorageNMap<
+		Key = (NMapKey<Twox64Concat, u16>, NMapKey<Blake2_128Concat, u32>),
+		Value = u64,
+		MaxValues = ConstU32<11>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn counted_nmap3)]
+	pub type CountedNMap3<T> = CountedStorageNMap<
+		_,
+		(NMapKey<Blake2_128Concat, u8>, NMapKey<Twox64Concat, u16>),
+		u128,
+		ResultQuery<Error<T>::NonExistentStorageValue>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn conditional_value)]
+	#[cfg(feature = "frame-feature-testing")]
+	pub type ConditionalValue<T> = StorageValue<_, u32>;
+
+	#[cfg(feature = "frame-feature-testing")]
+	#[pallet::storage]
+	#[pallet::getter(fn conditional_map)]
+	pub type ConditionalMap<T> =
+		StorageMap<_, Twox64Concat, u16, u32, OptionQuery, GetDefault, ConstU32<12>>;
+
+	#[cfg(feature = "frame-feature-testing")]
+	#[pallet::storage]
+	#[pallet::getter(fn conditional_double_map)]
+	pub type ConditionalDoubleMap<T> =
+		StorageDoubleMap<_, Blake2_128Concat, u8, Twox64Concat, u16, u32>;
+
+	#[cfg(feature = "frame-feature-testing")]
+	#[pallet::storage]
+	#[pallet::getter(fn conditional_nmap)]
+	pub type ConditionalNMap<T> =
+		StorageNMap<_, (storage::Key<Blake2_128Concat, u8>, storage::Key<Twox64Concat, u16>), u32>;
+
+	#[cfg(feature = "frame-feature-testing")]
+	#[pallet::storage]
+	#[pallet::getter(fn conditional_counted_nmap)]
+	pub type ConditionalCountedNMap<T> = CountedStorageNMap<
+		_,
+		(storage::Key<Blake2_128Concat, u8>, storage::Key<Twox64Concat, u16>),
+		u32,
+	>;
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "RenamedCountedMap"]
+	#[pallet::getter(fn counted_storage_map)]
+	pub type SomeCountedStorageMap<T> =
+		CountedStorageMap<Hasher = Twox64Concat, Key = u8, Value = u32>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub type Unbounded<T> = StorageValue<Value = Vec<u8>>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType4>,
+	{
+		#[serde(skip)]
+		_config: sp_std::marker::PhantomData<T>,
+		_myfield: u32,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType4>,
+	{
+		fn build(&self) {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType4); // Test for where clause
+		}
+	}
+
+	#[pallet::origin]
+	#[derive(
+		EqNoBound,
+		RuntimeDebugNoBound,
+		CloneNoBound,
+		PartialEqNoBound,
+		Encode,
+		Decode,
+		TypeInfo,
+		MaxEncodedLen,
+	)]
+	pub struct Origin<T>(PhantomData<T>);
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType5> + From<SomeType3>,
+	{
+		type Call = Call<T>;
+		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType5); // Test for where clause
+			if matches!(call, Call::foo_storage_layer { .. }) {
+				return Ok(ValidTransaction::default())
+			}
+			Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
+		}
+	}
+
+	#[pallet::inherent]
+	impl<T: Config> ProvideInherent for Pallet<T>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1 + From<SomeType6> + From<SomeType3>,
+	{
+		type Call = Call<T>;
+		type Error = InherentError;
+
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			let _ = T::AccountId::from(SomeType1); // Test for where clause
+			let _ = T::AccountId::from(SomeType6); // Test for where clause
+			Some(Call::foo_no_post_info {})
+		}
+
+		fn is_inherent(call: &Self::Call) -> bool {
+			matches!(call, Call::foo_no_post_info {} | Call::foo { .. })
+		}
+
+		fn check_inherent(call: &Self::Call, _: &InherentData) -> Result<(), Self::Error> {
+			match call {
+				Call::foo_no_post_info {} => Ok(()),
+				Call::foo { foo: 0, bar: 0 } => Err(InherentError::Fatal),
+				Call::foo { .. } => Ok(()),
+				_ => unreachable!("other calls are not inherents"),
+			}
+		}
+
+		fn is_inherent_required(d: &InherentData) -> Result<Option<Self::Error>, Self::Error> {
+			match d.get_data::<bool>(b"required") {
+				Ok(Some(true)) => Ok(Some(InherentError::Fatal)),
+				Ok(Some(false)) | Ok(None) => Ok(None),
+				Err(_) => unreachable!("should not happen in tests"),
+			}
+		}
+	}
+
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		Staking,
+	}
+
+	#[derive(codec::Encode, sp_runtime::RuntimeDebug)]
+	#[cfg_attr(feature = "std", derive(codec::Decode))]
+	pub enum InherentError {
+		Fatal,
+	}
+
+	impl frame_support::inherent::IsFatalError for InherentError {
+		fn is_fatal_error(&self) -> bool {
+			matches!(self, InherentError::Fatal)
+		}
+	}
+
+	pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"testpall";
+}
+
+// Test that a pallet with non generic event and generic genesis_config is correctly handled
+// and that a pallet with the attribute without_storage_info is correctly handled.
+#[frame_support::pallet]
+pub mod pallet2 {
+	use super::{SomeAssociation1, SomeType1, UpdateStorageVersion};
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	pub(crate) const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
+	{
+		type RuntimeEvent: From<Event> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1,
+	{
+		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
+			Self::deposit_event(Event::Something(11));
+			Weight::zero()
+		}
+		fn on_finalize(_: BlockNumberFor<T>) {
+			Self::deposit_event(Event::Something(21));
+		}
+		fn on_runtime_upgrade() -> Weight {
+			Self::deposit_event(Event::Something(31));
+
+			if UpdateStorageVersion::get() {
+				Self::current_storage_version().put::<Self>();
+			}
+
+			Weight::zero()
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> where T::AccountId: From<SomeType1> + SomeAssociation1 {}
+
+	#[pallet::storage]
+	pub type SomeValue<T: Config> = StorageValue<_, Vec<u32>>;
+
+	#[pallet::storage]
+	pub type SomeCountedStorageMap<T> =
+		CountedStorageMap<Hasher = Twox64Concat, Key = u8, Value = u32>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(fn deposit_event)]
+	pub enum Event {
+		/// Something
+		Something(u32),
+	}
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1,
+	{
+		phantom: PhantomData<T>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1,
+	{
+		fn default() -> Self {
+			GenesisConfig { phantom: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T>
+	where
+		T::AccountId: From<SomeType1> + SomeAssociation1,
+	{
+		fn build(&self) {}
+	}
+
+	#[pallet::composite_enum]
+	pub enum HoldReason {
+		Governance,
+	}
+
+	#[pallet::composite_enum]
+	pub enum SlashReason {
+		Equivocation,
+	}
+}
+
+/// Test that the supertrait check works when we pass some parameter to the `frame_system::Config`.
+#[frame_support::pallet]
+pub mod pallet3 {
+	#[pallet::config]
+	pub trait Config:
+		frame_system::Config<RuntimeOrigin = <Self as Config>::RuntimeOrigin>
+	{
+		type RuntimeOrigin;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+#[frame_support::pallet]
+pub mod pallet4 {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+/// Test that the supertrait check works when we pass some parameter to the `frame_system::Config`.
+#[frame_support::pallet]
+pub mod pallet5 {
+	#[pallet::config]
+	pub trait Config:
+		frame_system::Config<RuntimeOrigin = <Self as Config>::RuntimeOrigin>
+	{
+		type RuntimeOrigin;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+frame_support::parameter_types!(
+	pub const MyGetParam3: u32 = 12;
+);
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+impl pallet::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type MyGetParam = ConstU32<10>;
+	type MyGetParam2 = ConstU32<11>;
+	type MyGetParam3 = MyGetParam3;
+	type Balance = u64;
+}
+
+impl pallet2::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+impl pallet4::Config for Runtime {}
+
+#[cfg(feature = "frame-feature-testing")]
+impl pallet3::Config for Runtime {
+	type RuntimeOrigin = RuntimeOrigin;
+}
+
+#[cfg(feature = "frame-feature-testing-2")]
+impl pallet5::Config for Runtime {
+	type RuntimeOrigin = RuntimeOrigin;
+}
+
+pub type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic =
+	sp_runtime::testing::TestXt<RuntimeCall, frame_system::CheckNonZeroSender<Runtime>>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		// Exclude part `Storage` in order not to check its metadata in tests.
+		System: frame_system exclude_parts { Pallet, Storage },
+		Example: pallet,
+		Example2: pallet2 exclude_parts { Call },
+		#[cfg(feature = "frame-feature-testing")]
+		Example3: pallet3,
+		Example4: pallet4 use_parts { Call },
+
+		#[cfg(feature = "frame-feature-testing-2")]
+		Example5: pallet5,
+	}
+);
+
+// Test that the part `RuntimeCall` is excluded from Example2 and included in Example4.
+fn _ensure_call_is_correctly_excluded_and_included(call: RuntimeCall) {
+	match call {
+		RuntimeCall::System(_) | RuntimeCall::Example(_) | RuntimeCall::Example4(_) => (),
+	}
+}
+
+#[test]
+fn transactional_works() {
+	TestExternalities::default().execute_with(|| {
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+
+		pallet::Call::<Runtime>::foo_storage_layer { foo: 0 }
+			.dispatch_bypass_filter(None.into())
+			.err()
+			.unwrap();
+		assert!(frame_system::Pallet::<Runtime>::events().is_empty());
+
+		pallet::Call::<Runtime>::foo_storage_layer { foo: 1 }
+			.dispatch_bypass_filter(None.into())
+			.unwrap();
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()
+				.iter()
+				.map(|e| &e.event)
+				.collect::<Vec<_>>(),
+			vec![&RuntimeEvent::Example(pallet::Event::Something(0))],
+		);
+	})
+}
+
+#[test]
+fn call_expand() {
+	let call_foo = pallet::Call::<Runtime>::foo { foo: 3, bar: 0 };
+	assert_eq!(
+		call_foo.get_dispatch_info(),
+		DispatchInfo {
+			weight: frame_support::weights::Weight::from_parts(3, 0),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes
+		}
+	);
+	assert_eq!(call_foo.get_call_name(), "foo");
+	assert_eq!(
+		pallet::Call::<Runtime>::get_call_names(),
+		&[
+			"foo",
+			"foo_storage_layer",
+			"foo_index_out_of_order",
+			"foo_no_post_info",
+			"check_for_dispatch_context"
+		],
+	);
+
+	assert_eq!(call_foo.get_call_index(), 0u8);
+	assert_eq!(pallet::Call::<Runtime>::get_call_indices(), &[0u8, 1u8, 4u8, 2u8, 3u8])
+}
+
+#[test]
+fn call_expand_index() {
+	let call_foo = pallet::Call::<Runtime>::foo_index_out_of_order {};
+
+	assert_eq!(call_foo.get_call_index(), 4u8);
+	assert_eq!(pallet::Call::<Runtime>::get_call_indices(), &[0u8, 1u8, 4u8, 2u8, 3u8])
+}
+
+#[test]
+fn error_expand() {
+	assert_eq!(
+		format!("{:?}", pallet::Error::<Runtime>::InsufficientProposersBalance),
+		String::from("InsufficientProposersBalance"),
+	);
+	assert_eq!(
+		<&'static str>::from(pallet::Error::<Runtime>::InsufficientProposersBalance),
+		"InsufficientProposersBalance",
+	);
+	assert_eq!(
+		DispatchError::from(pallet::Error::<Runtime>::InsufficientProposersBalance),
+		DispatchError::Module(ModuleError {
+			index: 1,
+			error: [0, 0, 0, 0],
+			message: Some("InsufficientProposersBalance")
+		}),
+	);
+	assert_eq!(<pallet::Error::<Runtime> as PalletError>::MAX_ENCODED_SIZE, 3);
+}
+
+#[test]
+fn instance_expand() {
+	// Assert same type.
+	let _: pallet::__InherentHiddenInstance = ();
+}
+
+#[test]
+fn inherent_expand() {
+	use frame_support::{inherent::InherentData, traits::EnsureInherentsAreFirst};
+	use sp_core::Hasher;
+	use sp_runtime::{
+		traits::{BlakeTwo256, Block as _, Header},
+		Digest,
+	};
+
+	let inherents = InherentData::new().create_extrinsics();
+
+	let expected = vec![UncheckedExtrinsic {
+		call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
+		signature: None,
+	}];
+	assert_eq!(expected, inherents);
+
+	let block = Block::new(
+		Header::new(
+			1,
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			Digest::default(),
+		),
+		vec![
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
+				signature: None,
+			},
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 0 }),
+				signature: None,
+			},
+		],
+	);
+
+	assert!(InherentData::new().check_extrinsics(&block).ok());
+
+	let block = Block::new(
+		Header::new(
+			1,
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			Digest::default(),
+		),
+		vec![
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
+				signature: None,
+			},
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo { foo: 0, bar: 0 }),
+				signature: None,
+			},
+		],
+	);
+
+	assert!(InherentData::new().check_extrinsics(&block).fatal_error());
+
+	let block = Block::new(
+		Header::new(
+			1,
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			Digest::default(),
+		),
+		vec![UncheckedExtrinsic {
+			call: RuntimeCall::Example(pallet::Call::foo_storage_layer { foo: 0 }),
+			signature: None,
+		}],
+	);
+
+	let mut inherent = InherentData::new();
+	inherent.put_data(*b"required", &true).unwrap();
+	assert!(inherent.check_extrinsics(&block).fatal_error());
+
+	let block = Block::new(
+		Header::new(
+			1,
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			Digest::default(),
+		),
+		vec![UncheckedExtrinsic {
+			call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
+			signature: Some((1, Default::default())),
+		}],
+	);
+
+	let mut inherent = InherentData::new();
+	inherent.put_data(*b"required", &true).unwrap();
+	assert!(inherent.check_extrinsics(&block).fatal_error());
+
+	let block = Block::new(
+		Header::new(
+			1,
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			Digest::default(),
+		),
+		vec![
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 1 }),
+				signature: None,
+			},
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo_storage_layer { foo: 0 }),
+				signature: None,
+			},
+		],
+	);
+
+	assert!(Runtime::ensure_inherents_are_first(&block).is_ok());
+
+	let block = Block::new(
+		Header::new(
+			1,
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			Digest::default(),
+		),
+		vec![
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 1 }),
+				signature: None,
+			},
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo_storage_layer { foo: 0 }),
+				signature: None,
+			},
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
+				signature: None,
+			},
+		],
+	);
+
+	assert_eq!(Runtime::ensure_inherents_are_first(&block).err().unwrap(), 2);
+
+	let block = Block::new(
+		Header::new(
+			1,
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			BlakeTwo256::hash(b"test"),
+			Digest::default(),
+		),
+		vec![
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 1 }),
+				signature: None,
+			},
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 0 }),
+				signature: Some((1, Default::default())),
+			},
+			UncheckedExtrinsic {
+				call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
+				signature: None,
+			},
+		],
+	);
+
+	assert_eq!(Runtime::ensure_inherents_are_first(&block).err().unwrap(), 2);
+}
+
+#[test]
+fn validate_unsigned_expand() {
+	use frame_support::pallet_prelude::{
+		InvalidTransaction, TransactionSource, TransactionValidityError, ValidTransaction,
+		ValidateUnsigned,
+	};
+	let call = pallet::Call::<Runtime>::foo_no_post_info {};
+
+	let validity = pallet::Pallet::validate_unsigned(TransactionSource::Local, &call).unwrap_err();
+	assert_eq!(validity, TransactionValidityError::Invalid(InvalidTransaction::Call));
+
+	let call = pallet::Call::<Runtime>::foo_storage_layer { foo: 0 };
+
+	let validity = pallet::Pallet::validate_unsigned(TransactionSource::External, &call).unwrap();
+	assert_eq!(validity, ValidTransaction::default());
+}
+
+#[test]
+fn composite_expand() {
+	use codec::Encode;
+
+	let hold_reason: RuntimeHoldReason = pallet::HoldReason::Staking.into();
+	let hold_reason2: RuntimeHoldReason = pallet2::HoldReason::Governance.into();
+	let slash_reason: RuntimeSlashReason = pallet2::SlashReason::Equivocation.into();
+
+	assert_eq!(hold_reason, RuntimeHoldReason::Example(pallet::HoldReason::Staking));
+	assert_eq!(hold_reason2, RuntimeHoldReason::Example2(pallet2::HoldReason::Governance));
+	assert_eq!(slash_reason, RuntimeSlashReason::Example2(pallet2::SlashReason::Equivocation));
+
+	assert_eq!(hold_reason.encode(), [1, 0]);
+	assert_eq!(hold_reason2.encode(), [2, 0]);
+	assert_eq!(slash_reason.encode(), [2, 0]);
+}
+
+#[test]
+fn pallet_expand_deposit_event() {
+	TestExternalities::default().execute_with(|| {
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+		pallet::Call::<Runtime>::foo { foo: 3, bar: 0 }
+			.dispatch_bypass_filter(None.into())
+			.unwrap();
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[0].event,
+			RuntimeEvent::Example(pallet::Event::Something(3)),
+		);
+	})
+}
+
+#[test]
+fn pallet_new_call_variant() {
+	pallet::Call::<Runtime>::new_call_variant_foo(3, 4);
+}
+
+#[test]
+fn storage_expand() {
+	use frame_support::{pallet_prelude::*, storage::StoragePrefixedMap};
+
+	fn twox_64_concat(d: &[u8]) -> Vec<u8> {
+		let mut v = twox_64(d).to_vec();
+		v.extend_from_slice(d);
+		v
+	}
+
+	fn blake2_128_concat(d: &[u8]) -> Vec<u8> {
+		let mut v = blake2_128(d).to_vec();
+		v.extend_from_slice(d);
+		v
+	}
+
+	TestExternalities::default().execute_with(|| {
+		pallet::Value::<Runtime>::put(1);
+		let k = [twox_128(b"Example"), twox_128(b"Value")].concat();
+		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));
+
+		pallet::RenamedValue::<Runtime>::put(2);
+		let k = [twox_128(b"Example"), twox_128(b"Value2")].concat();
+		assert_eq!(unhashed::get::<u64>(&k), Some(2));
+
+		pallet::Map::<Runtime>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"Map")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u16>(&k), Some(2u16));
+		assert_eq!(&k[..32], &<pallet::Map<Runtime>>::final_prefix());
+
+		pallet::Map2::<Runtime>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"Map2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<pallet::Map2<Runtime>>::final_prefix());
+
+		pallet::Map3::<Runtime>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"Map3")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(2u64));
+		assert_eq!(&k[..32], &<pallet::Map3<Runtime>>::final_prefix());
+		assert_eq!(
+			pallet::Map3::<Runtime>::get(2),
+			Err(pallet::Error::<Runtime>::NonExistentStorageValue),
+		);
+
+		pallet::DoubleMap::<Runtime>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		k.extend(2u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<pallet::DoubleMap<Runtime>>::final_prefix());
+
+		pallet::DoubleMap2::<Runtime>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
+		assert_eq!(&k[..32], &<pallet::DoubleMap2<Runtime>>::final_prefix());
+
+		pallet::DoubleMap3::<Runtime>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap3")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		k.extend(2u64.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
+		assert_eq!(&k[..32], &<pallet::DoubleMap3<Runtime>>::final_prefix());
+		assert_eq!(
+			pallet::DoubleMap3::<Runtime>::get(2, 3),
+			Err(pallet::Error::<Runtime>::NonExistentStorageValue),
+		);
+
+		pallet::NMap::<Runtime>::insert((&1,), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"NMap")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<pallet::NMap<Runtime>>::final_prefix());
+
+		pallet::NMap2::<Runtime>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"NMap2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
+		assert_eq!(&k[..32], &<pallet::NMap2<Runtime>>::final_prefix());
+		assert_eq!(pallet::Pallet::<Runtime>::nmap2((1, 2)), Some(3u64));
+
+		pallet::NMap3::<Runtime>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"NMap3")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		k.extend(2u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
+		assert_eq!(&k[..32], &<pallet::NMap3<Runtime>>::final_prefix());
+		assert_eq!(pallet::Pallet::<Runtime>::nmap3((1, 2)), Ok(3u128));
+		assert_eq!(
+			pallet::NMap3::<Runtime>::get((2, 3)),
+			Err(pallet::Error::<Runtime>::NonExistentStorageValue),
+		);
+
+		pallet::CountedNMap::<Runtime>::insert((&1,), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"CountedNMap")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(pallet::CountedNMap::<Runtime>::count(), 1);
+		assert_eq!(
+			unhashed::get::<u32>(
+				&[twox_128(b"Example"), twox_128(b"CounterForCountedNMap")].concat()
+			),
+			Some(1u32)
+		);
+
+		pallet::CountedNMap2::<Runtime>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"CountedNMap2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
+		assert_eq!(pallet::CountedNMap2::<Runtime>::count(), 1);
+		assert_eq!(
+			unhashed::get::<u32>(
+				&[twox_128(b"Example"), twox_128(b"CounterForCountedNMap2")].concat()
+			),
+			Some(1u32)
+		);
+		assert_eq!(pallet::Pallet::<Runtime>::counted_nmap2((1, 2)), Some(3u64));
+
+		pallet::CountedNMap3::<Runtime>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"CountedNMap3")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		k.extend(2u16.using_encoded(twox_64_concat));
+		assert_eq!(pallet::CountedNMap3::<Runtime>::count(), 1);
+		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
+		assert_eq!(pallet::Pallet::<Runtime>::counted_nmap3((1, 2)), Ok(3u128));
+		assert_eq!(
+			pallet::CountedNMap3::<Runtime>::get((2, 3)),
+			Err(pallet::Error::<Runtime>::NonExistentStorageValue),
+		);
+		assert_eq!(
+			unhashed::get::<u32>(
+				&[twox_128(b"Example"), twox_128(b"CounterForCountedNMap3")].concat()
+			),
+			Some(1u32)
+		);
+
+		#[cfg(feature = "frame-feature-testing")]
+		{
+			pallet::ConditionalValue::<Runtime>::put(1);
+			pallet::ConditionalMap::<Runtime>::insert(1, 2);
+			pallet::ConditionalDoubleMap::<Runtime>::insert(1, 2, 3);
+			pallet::ConditionalNMap::<Runtime>::insert((1, 2), 3);
+		}
+
+		pallet::SomeCountedStorageMap::<Runtime>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"RenamedCountedMap")].concat();
+		k.extend(1u8.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		let k = [twox_128(b"Example"), twox_128(b"CounterForRenamedCountedMap")].concat();
+		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));
+
+		pallet::Unbounded::<Runtime>::put(vec![1, 2]);
+		let k = [twox_128(b"Example"), twox_128(b"Unbounded")].concat();
+		assert_eq!(unhashed::get::<Vec<u8>>(&k), Some(vec![1, 2]));
+	})
+}
+
+#[test]
+fn pallet_hooks_expand() {
+	TestExternalities::default().execute_with(|| {
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+
+		assert_eq!(AllPalletsWithoutSystem::on_initialize(1), Weight::from_parts(10, 0));
+		AllPalletsWithoutSystem::on_finalize(1);
+
+		assert_eq!(AllPalletsWithoutSystem::on_runtime_upgrade(), Weight::from_parts(30, 0));
+
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[0].event,
+			RuntimeEvent::Example(pallet::Event::Something(10)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[1].event,
+			RuntimeEvent::Example2(pallet2::Event::Something(11)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[2].event,
+			RuntimeEvent::Example(pallet::Event::Something(20)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[3].event,
+			RuntimeEvent::Example2(pallet2::Event::Something(21)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[4].event,
+			RuntimeEvent::Example(pallet::Event::Something(30)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[5].event,
+			RuntimeEvent::Example2(pallet2::Event::Something(31)),
+		);
+	})
+}
+
+#[test]
+fn all_pallets_type_reversed_order_is_correct() {
+	TestExternalities::default().execute_with(|| {
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+
+		#[allow(deprecated)]
+		{
+			assert_eq!(
+				AllPalletsWithoutSystemReversed::on_initialize(1),
+				Weight::from_parts(10, 0)
+			);
+			AllPalletsWithoutSystemReversed::on_finalize(1);
+
+			assert_eq!(
+				AllPalletsWithoutSystemReversed::on_runtime_upgrade(),
+				Weight::from_parts(30, 0)
+			);
+		}
+
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[0].event,
+			RuntimeEvent::Example2(pallet2::Event::Something(11)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[1].event,
+			RuntimeEvent::Example(pallet::Event::Something(10)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[2].event,
+			RuntimeEvent::Example2(pallet2::Event::Something(21)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[3].event,
+			RuntimeEvent::Example(pallet::Event::Something(20)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[4].event,
+			RuntimeEvent::Example2(pallet2::Event::Something(31)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[5].event,
+			RuntimeEvent::Example(pallet::Event::Something(30)),
+		);
+	})
+}
+
+#[test]
+fn pallet_on_genesis() {
+	TestExternalities::default().execute_with(|| {
+		assert_eq!(pallet::Pallet::<Runtime>::on_chain_storage_version(), StorageVersion::new(0));
+		pallet::Pallet::<Runtime>::on_genesis();
+		assert_eq!(
+			pallet::Pallet::<Runtime>::current_storage_version(),
+			pallet::Pallet::<Runtime>::on_chain_storage_version(),
+		);
+	})
+}
+
+#[test]
+fn migrate_from_pallet_version_to_storage_version() {
+	const PALLET_VERSION_STORAGE_KEY_POSTFIX: &[u8] = b":__PALLET_VERSION__:";
+
+	fn pallet_version_key(name: &str) -> [u8; 32] {
+		frame_support::storage::storage_prefix(name.as_bytes(), PALLET_VERSION_STORAGE_KEY_POSTFIX)
+	}
+
+	TestExternalities::default().execute_with(|| {
+		// Insert some fake pallet versions
+		sp_io::storage::set(&pallet_version_key(Example::name()), &[1, 2, 3]);
+		sp_io::storage::set(&pallet_version_key(Example2::name()), &[1, 2, 3]);
+		sp_io::storage::set(&pallet_version_key(System::name()), &[1, 2, 3]);
+
+		// Check that everyone currently is at version 0
+		assert_eq!(Example::on_chain_storage_version(), StorageVersion::new(0));
+		assert_eq!(Example2::on_chain_storage_version(), StorageVersion::new(0));
+		assert_eq!(System::on_chain_storage_version(), StorageVersion::new(0));
+
+		let db_weight = RuntimeDbWeight { read: 0, write: 5 };
+		let weight = frame_support::migrations::migrate_from_pallet_version_to_storage_version::<
+			AllPalletsWithSystem,
+		>(&db_weight);
+
+		let mut pallet_num = 4;
+		if cfg!(feature = "frame-feature-testing") {
+			pallet_num += 1;
+		};
+		if cfg!(feature = "frame-feature-testing-2") {
+			pallet_num += 1;
+		};
+
+		// `pallet_num` pallets, 2 writes and every write costs 5 weight.
+		assert_eq!(Weight::from_parts(pallet_num * 2 * 5, 0), weight);
+
+		// All pallet versions should be removed
+		assert!(sp_io::storage::get(&pallet_version_key(Example::name())).is_none());
+		assert!(sp_io::storage::get(&pallet_version_key(Example2::name())).is_none());
+		assert!(sp_io::storage::get(&pallet_version_key(System::name())).is_none());
+
+		assert_eq!(Example::on_chain_storage_version(), pallet::STORAGE_VERSION);
+		assert_eq!(Example2::on_chain_storage_version(), pallet2::STORAGE_VERSION);
+		assert_eq!(System::on_chain_storage_version(), StorageVersion::new(0));
+	});
+}
+
+#[test]
+fn metadata() {
+	use codec::Decode;
+	use frame_metadata::{v15::*, *};
+
+	fn maybe_docs(doc: Vec<&'static str>) -> Vec<&'static str> {
+		if cfg!(feature = "no-metadata-docs") {
+			vec![]
+		} else {
+			doc
+		}
+	}
+
+	let readme = "Support code for the runtime.\n\nLicense: Apache-2.0";
+	let expected_pallet_doc = vec![" Pallet documentation", readme, readme];
+
+	let pallets = vec![
+		PalletMetadata {
+			index: 1,
+			name: "Example",
+			storage: Some(PalletStorageMetadata {
+				prefix: "Example",
+				entries: vec![
+					StorageEntryMetadata {
+						name: "ValueWhereClause",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Plain(meta_type::<u64>()),
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "Value",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "Value2",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Plain(meta_type::<u64>()),
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "Map",
+						modifier: StorageEntryModifier::Default,
+						ty: StorageEntryType::Map {
+							key: meta_type::<u8>(),
+							value: meta_type::<u16>(),
+							hashers: vec![StorageHasher::Blake2_128Concat],
+						},
+						default: vec![4, 0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "Map2",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<u16>(),
+							value: meta_type::<u32>(),
+							hashers: vec![StorageHasher::Twox64Concat],
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "Map3",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<u32>(),
+							value: meta_type::<u64>(),
+							hashers: vec![StorageHasher::Blake2_128Concat],
+						},
+						default: vec![1, 1],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "DoubleMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							value: meta_type::<u32>(),
+							hashers: vec![
+								StorageHasher::Blake2_128Concat,
+								StorageHasher::Twox64Concat,
+							],
+							key: meta_type::<(u8, u16)>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "DoubleMap2",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							value: meta_type::<u64>(),
+							key: meta_type::<(u16, u32)>(),
+							hashers: vec![
+								StorageHasher::Twox64Concat,
+								StorageHasher::Blake2_128Concat,
+							],
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "DoubleMap3",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							value: meta_type::<u128>(),
+							key: meta_type::<(u32, u64)>(),
+							hashers: vec![
+								StorageHasher::Blake2_128Concat,
+								StorageHasher::Twox64Concat,
+							],
+						},
+						default: vec![1, 1],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "NMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<u8>(),
+							hashers: vec![StorageHasher::Blake2_128Concat],
+							value: meta_type::<u32>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "NMap2",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<(u16, u32)>(),
+							hashers: vec![
+								StorageHasher::Twox64Concat,
+								StorageHasher::Blake2_128Concat,
+							],
+							value: meta_type::<u64>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "NMap3",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<(u8, u16)>(),
+							hashers: vec![
+								StorageHasher::Blake2_128Concat,
+								StorageHasher::Twox64Concat,
+							],
+							value: meta_type::<u128>(),
+						},
+						default: vec![1, 1],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "CountedNMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<u8>(),
+							hashers: vec![StorageHasher::Blake2_128Concat],
+							value: meta_type::<u32>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "CounterForCountedNMap",
+						modifier: StorageEntryModifier::Default,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
+					},
+					StorageEntryMetadata {
+						name: "CountedNMap2",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<(u16, u32)>(),
+							hashers: vec![
+								StorageHasher::Twox64Concat,
+								StorageHasher::Blake2_128Concat,
+							],
+							value: meta_type::<u64>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "CounterForCountedNMap2",
+						modifier: StorageEntryModifier::Default,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
+					},
+					StorageEntryMetadata {
+						name: "CountedNMap3",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<(u8, u16)>(),
+							hashers: vec![
+								StorageHasher::Blake2_128Concat,
+								StorageHasher::Twox64Concat,
+							],
+							value: meta_type::<u128>(),
+						},
+						default: vec![1, 1],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "CounterForCountedNMap3",
+						modifier: StorageEntryModifier::Default,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
+					},
+					#[cfg(feature = "frame-feature-testing")]
+					StorageEntryMetadata {
+						name: "ConditionalValue",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0],
+						docs: vec![],
+					},
+					#[cfg(feature = "frame-feature-testing")]
+					StorageEntryMetadata {
+						name: "ConditionalMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<u16>(),
+							value: meta_type::<u32>(),
+							hashers: vec![StorageHasher::Twox64Concat],
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					#[cfg(feature = "frame-feature-testing")]
+					StorageEntryMetadata {
+						name: "ConditionalDoubleMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							value: meta_type::<u32>(),
+							key: meta_type::<(u8, u16)>(),
+							hashers: vec![
+								StorageHasher::Blake2_128Concat,
+								StorageHasher::Twox64Concat,
+							],
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					#[cfg(feature = "frame-feature-testing")]
+					StorageEntryMetadata {
+						name: "ConditionalNMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<(u8, u16)>(),
+							hashers: vec![
+								StorageHasher::Blake2_128Concat,
+								StorageHasher::Twox64Concat,
+							],
+							value: meta_type::<u32>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					#[cfg(feature = "frame-feature-testing")]
+					StorageEntryMetadata {
+						name: "ConditionalCountedNMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							key: meta_type::<(u8, u16)>(),
+							hashers: vec![
+								StorageHasher::Blake2_128Concat,
+								StorageHasher::Twox64Concat,
+							],
+							value: meta_type::<u32>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					#[cfg(feature = "frame-feature-testing")]
+					StorageEntryMetadata {
+						name: "CounterForConditionalCountedNMap",
+						modifier: StorageEntryModifier::Default,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
+					},
+					StorageEntryMetadata {
+						name: "RenamedCountedMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							hashers: vec![StorageHasher::Twox64Concat],
+							key: meta_type::<u8>(),
+							value: meta_type::<u32>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "CounterForRenamedCountedMap",
+						modifier: StorageEntryModifier::Default,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
+					},
+					StorageEntryMetadata {
+						name: "Unbounded",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Plain(meta_type::<Vec<u8>>()),
+						default: vec![0],
+						docs: vec![],
+					},
+				],
+			}),
+			calls: Some(meta_type::<pallet::Call<Runtime>>().into()),
+			event: Some(meta_type::<pallet::Event<Runtime>>().into()),
+			constants: vec![
+				PalletConstantMetadata {
+					name: "MyGetParam",
+					ty: meta_type::<u32>(),
+					value: vec![10, 0, 0, 0],
+					docs: maybe_docs(vec![" Some comment", " Some comment"]),
+				},
+				PalletConstantMetadata {
+					name: "MyGetParam2",
+					ty: meta_type::<u32>(),
+					value: vec![11, 0, 0, 0],
+					docs: maybe_docs(vec![" Some comment", " Some comment"]),
+				},
+				PalletConstantMetadata {
+					name: "MyGetParam3",
+					ty: meta_type::<u64>(),
+					value: vec![12, 0, 0, 0, 0, 0, 0, 0],
+					docs: vec![],
+				},
+				PalletConstantMetadata {
+					name: "some_extra",
+					ty: meta_type::<u64>(),
+					value: vec![100, 0, 0, 0, 0, 0, 0, 0],
+					docs: maybe_docs(vec![" Some doc", " Some doc"]),
+				},
+				PalletConstantMetadata {
+					name: "some_extra_extra",
+					ty: meta_type::<u64>(),
+					value: vec![0, 0, 0, 0, 0, 0, 0, 0],
+					docs: maybe_docs(vec![" Some doc"]),
+				},
+				PalletConstantMetadata {
+					name: "SomeExtraRename",
+					ty: meta_type::<u64>(),
+					value: vec![0, 0, 0, 0, 0, 0, 0, 0],
+					docs: maybe_docs(vec![" Some doc"]),
+				},
+			],
+			error: Some(PalletErrorMetadata { ty: meta_type::<pallet::Error<Runtime>>() }),
+			docs: expected_pallet_doc,
+		},
+		PalletMetadata {
+			index: 2,
+			name: "Example2",
+			storage: Some(PalletStorageMetadata {
+				prefix: "Example2",
+				entries: vec![
+					StorageEntryMetadata {
+						name: "SomeValue",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Plain(meta_type::<Vec<u32>>()),
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "SomeCountedStorageMap",
+						modifier: StorageEntryModifier::Optional,
+						ty: StorageEntryType::Map {
+							hashers: vec![StorageHasher::Twox64Concat],
+							key: meta_type::<u8>(),
+							value: meta_type::<u32>(),
+						},
+						default: vec![0],
+						docs: vec![],
+					},
+					StorageEntryMetadata {
+						name: "CounterForSomeCountedStorageMap",
+						modifier: StorageEntryModifier::Default,
+						ty: StorageEntryType::Plain(meta_type::<u32>()),
+						default: vec![0, 0, 0, 0],
+						docs: maybe_docs(vec!["Counter for the related counted storage map"]),
+					},
+				],
+			}),
+			calls: None,
+			event: Some(PalletEventMetadata { ty: meta_type::<pallet2::Event>() }),
+			constants: vec![],
+			error: None,
+			docs: vec![],
+		},
+		#[cfg(feature = "frame-feature-testing")]
+		PalletMetadata {
+			index: 3,
+			name: "Example3",
+			storage: None,
+			calls: None,
+			event: None,
+			constants: vec![],
+			error: None,
+			docs: vec![" Test that the supertrait check works when we pass some parameter to the `frame_system::Config`."],
+		},
+		#[cfg(feature = "frame-feature-testing-2")]
+		PalletMetadata {
+			index: 5,
+			name: "Example5",
+			storage: None,
+			calls: None,
+			event: None,
+			constants: vec![],
+			error: None,
+			docs: vec![" Test that the supertrait check works when we pass some parameter to the `frame_system::Config`."],
+		},
+	];
+
+	let empty_doc = pallets[0].event.as_ref().unwrap().ty.type_info().docs.is_empty() &&
+		pallets[0].error.as_ref().unwrap().ty.type_info().docs.is_empty() &&
+		pallets[0].calls.as_ref().unwrap().ty.type_info().docs.is_empty();
+
+	if cfg!(feature = "no-metadata-docs") {
+		assert!(empty_doc)
+	} else {
+		assert!(!empty_doc)
+	}
+
+	let extrinsic = ExtrinsicMetadata {
+		version: 4,
+		signed_extensions: vec![SignedExtensionMetadata {
+			identifier: "UnitSignedExtension",
+			ty: meta_type::<()>(),
+			additional_signed: meta_type::<()>(),
+		}],
+		address_ty: meta_type::<<<UncheckedExtrinsic as ExtrinsicT>::SignaturePayload as SignaturePayloadT>::SignatureAddress>(),
+		call_ty: meta_type::<<UncheckedExtrinsic as ExtrinsicT>::Call>(),
+		signature_ty: meta_type::<
+			<<UncheckedExtrinsic as ExtrinsicT>::SignaturePayload as SignaturePayloadT>::Signature
+		>(),
+		extra_ty: meta_type::<<<UncheckedExtrinsic as ExtrinsicT>::SignaturePayload as SignaturePayloadT>::SignatureExtra>(),
+	};
+
+	let outer_enums = OuterEnums {
+		call_enum_ty: meta_type::<RuntimeCall>(),
+		event_enum_ty: meta_type::<RuntimeEvent>(),
+		error_enum_ty: meta_type::<RuntimeError>(),
+	};
+
+	let expected_metadata: RuntimeMetadataPrefixed = RuntimeMetadataLastVersion::new(
+		pallets,
+		extrinsic,
+		meta_type::<Runtime>(),
+		vec![],
+		outer_enums,
+		CustomMetadata { map: Default::default() },
+	)
+	.into();
+	let expected_metadata = match expected_metadata.1 {
+		RuntimeMetadata::V15(metadata) => metadata,
+		_ => panic!("metadata has been bumped, test needs to be updated"),
+	};
+
+	let bytes = &Runtime::metadata_at_version(LATEST_METADATA_VERSION)
+		.expect("Metadata must be present; qed");
+
+	let actual_metadata: RuntimeMetadataPrefixed =
+		Decode::decode(&mut &bytes[..]).expect("Metadata encoded properly; qed");
+
+	let actual_metadata = match actual_metadata.1 {
+		RuntimeMetadata::V15(metadata) => metadata,
+		_ => panic!("metadata has been bumped, test needs to be updated"),
+	};
+
+	pretty_assertions::assert_eq!(actual_metadata.pallets, expected_metadata.pallets);
+}
+
+#[test]
+fn metadata_at_version() {
+	use frame_metadata::*;
+	use sp_core::Decode;
+
+	// Metadata always returns the V14.3
+	let metadata = Runtime::metadata();
+	let at_metadata = match Runtime::metadata_at_version(14) {
+		Some(opaque) => {
+			let bytes = &*opaque;
+			let metadata: RuntimeMetadataPrefixed = Decode::decode(&mut &bytes[..]).unwrap();
+			metadata
+		},
+		_ => panic!("metadata has been bumped, test needs to be updated"),
+	};
+
+	assert_eq!(metadata, at_metadata);
+}
+
+#[test]
+fn metadata_versions() {
+	assert_eq!(vec![14, LATEST_METADATA_VERSION], Runtime::metadata_versions());
+}
+
+#[test]
+fn metadata_ir_pallet_runtime_docs() {
+	let ir = Runtime::metadata_ir();
+	let pallet = ir
+		.pallets
+		.iter()
+		.find(|pallet| pallet.name == "Example")
+		.expect("Pallet should be present");
+
+	let readme = "Support code for the runtime.\n\nLicense: Apache-2.0";
+	let expected = vec![" Pallet documentation", readme, readme];
+	assert_eq!(pallet.docs, expected);
+}
+
+#[test]
+fn extrinsic_metadata_ir_types() {
+	let ir = Runtime::metadata_ir().extrinsic;
+
+	assert_eq!(meta_type::<<<UncheckedExtrinsic as ExtrinsicT>::SignaturePayload as SignaturePayloadT>::SignatureAddress>(), ir.address_ty);
+	assert_eq!(meta_type::<u64>(), ir.address_ty);
+
+	assert_eq!(meta_type::<<UncheckedExtrinsic as ExtrinsicT>::Call>(), ir.call_ty);
+	assert_eq!(meta_type::<RuntimeCall>(), ir.call_ty);
+
+	assert_eq!(
+		meta_type::<
+			<<UncheckedExtrinsic as ExtrinsicT>::SignaturePayload as SignaturePayloadT>::Signature,
+		>(),
+		ir.signature_ty
+	);
+	assert_eq!(meta_type::<()>(), ir.signature_ty);
+
+	assert_eq!(meta_type::<<<UncheckedExtrinsic as ExtrinsicT>::SignaturePayload as SignaturePayloadT>::SignatureExtra>(), ir.extra_ty);
+	assert_eq!(meta_type::<frame_system::CheckNonZeroSender<Runtime>>(), ir.extra_ty);
+}
+
+#[test]
+fn test_pallet_runtime_docs() {
+	let docs = crate::pallet::Pallet::<Runtime>::pallet_documentation_metadata();
+	let readme = "Support code for the runtime.\n\nLicense: Apache-2.0";
+	let expected = vec![" Pallet documentation", readme, readme];
+	assert_eq!(docs, expected);
+}
+
+#[test]
+fn test_pallet_info_access() {
+	assert_eq!(<System as frame_support::traits::PalletInfoAccess>::name(), "System");
+	assert_eq!(<Example as frame_support::traits::PalletInfoAccess>::name(), "Example");
+	assert_eq!(<Example2 as frame_support::traits::PalletInfoAccess>::name(), "Example2");
+	assert_eq!(<System as frame_support::traits::PalletInfoAccess>::index(), 0);
+	assert_eq!(<Example as frame_support::traits::PalletInfoAccess>::index(), 1);
+	assert_eq!(<Example2 as frame_support::traits::PalletInfoAccess>::index(), 2);
+}
+
+#[test]
+fn test_storage_info() {
+	use frame_support::{
+		storage::storage_prefix as prefix,
+		traits::{StorageInfo, StorageInfoTrait},
+	};
+
+	// Storage max size is calculated by adding up all the hasher size, the key type size and the
+	// value type size
+	assert_eq!(
+		Example::storage_info(),
+		vec![
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"ValueWhereClause".to_vec(),
+				prefix: prefix(b"Example", b"ValueWhereClause").to_vec(),
+				max_values: Some(1),
+				max_size: Some(8),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"Value".to_vec(),
+				prefix: prefix(b"Example", b"Value").to_vec(),
+				max_values: Some(1),
+				max_size: Some(4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"Value2".to_vec(),
+				prefix: prefix(b"Example", b"Value2").to_vec(),
+				max_values: Some(1),
+				max_size: Some(8),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"Map".to_vec(),
+				prefix: prefix(b"Example", b"Map").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 1 + 2),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"Map2".to_vec(),
+				prefix: prefix(b"Example", b"Map2").to_vec(),
+				max_values: Some(3),
+				max_size: Some(8 + 2 + 4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"Map3".to_vec(),
+				prefix: prefix(b"Example", b"Map3").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 4 + 8),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"DoubleMap".to_vec(),
+				prefix: prefix(b"Example", b"DoubleMap").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 1 + 8 + 2 + 4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"DoubleMap2".to_vec(),
+				prefix: prefix(b"Example", b"DoubleMap2").to_vec(),
+				max_values: Some(5),
+				max_size: Some(8 + 2 + 16 + 4 + 8),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"DoubleMap3".to_vec(),
+				prefix: prefix(b"Example", b"DoubleMap3").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 4 + 8 + 8 + 16),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"NMap".to_vec(),
+				prefix: prefix(b"Example", b"NMap").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 1 + 4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"NMap2".to_vec(),
+				prefix: prefix(b"Example", b"NMap2").to_vec(),
+				max_values: Some(11),
+				max_size: Some(8 + 2 + 16 + 4 + 8),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"NMap3".to_vec(),
+				prefix: prefix(b"Example", b"NMap3").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 1 + 8 + 2 + 16),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"CountedNMap".to_vec(),
+				prefix: prefix(b"Example", b"CountedNMap").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 1 + 4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"CounterForCountedNMap".to_vec(),
+				prefix: prefix(b"Example", b"CounterForCountedNMap").to_vec(),
+				max_values: Some(1),
+				max_size: Some(4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"CountedNMap2".to_vec(),
+				prefix: prefix(b"Example", b"CountedNMap2").to_vec(),
+				max_values: Some(11),
+				max_size: Some(8 + 2 + 16 + 4 + 8),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"CounterForCountedNMap2".to_vec(),
+				prefix: prefix(b"Example", b"CounterForCountedNMap2").to_vec(),
+				max_values: Some(1),
+				max_size: Some(4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"CountedNMap3".to_vec(),
+				prefix: prefix(b"Example", b"CountedNMap3").to_vec(),
+				max_values: None,
+				max_size: Some(16 + 1 + 8 + 2 + 16),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"CounterForCountedNMap3".to_vec(),
+				prefix: prefix(b"Example", b"CounterForCountedNMap3").to_vec(),
+				max_values: Some(1),
+				max_size: Some(4),
+			},
+			#[cfg(feature = "frame-feature-testing")]
+			{
+				StorageInfo {
+					pallet_name: b"Example".to_vec(),
+					storage_name: b"ConditionalValue".to_vec(),
+					prefix: prefix(b"Example", b"ConditionalValue").to_vec(),
+					max_values: Some(1),
+					max_size: Some(4),
+				}
+			},
+			#[cfg(feature = "frame-feature-testing")]
+			{
+				StorageInfo {
+					pallet_name: b"Example".to_vec(),
+					storage_name: b"ConditionalMap".to_vec(),
+					prefix: prefix(b"Example", b"ConditionalMap").to_vec(),
+					max_values: Some(12),
+					max_size: Some(8 + 2 + 4),
+				}
+			},
+			#[cfg(feature = "frame-feature-testing")]
+			{
+				StorageInfo {
+					pallet_name: b"Example".to_vec(),
+					storage_name: b"ConditionalDoubleMap".to_vec(),
+					prefix: prefix(b"Example", b"ConditionalDoubleMap").to_vec(),
+					max_values: None,
+					max_size: Some(16 + 1 + 8 + 2 + 4),
+				}
+			},
+			#[cfg(feature = "frame-feature-testing")]
+			{
+				StorageInfo {
+					pallet_name: b"Example".to_vec(),
+					storage_name: b"ConditionalNMap".to_vec(),
+					prefix: prefix(b"Example", b"ConditionalNMap").to_vec(),
+					max_values: None,
+					max_size: Some(16 + 1 + 8 + 2 + 4),
+				}
+			},
+			#[cfg(feature = "frame-feature-testing")]
+			{
+				StorageInfo {
+					pallet_name: b"Example".to_vec(),
+					storage_name: b"ConditionalCountedNMap".to_vec(),
+					prefix: prefix(b"Example", b"ConditionalCountedNMap").to_vec(),
+					max_values: None,
+					max_size: Some(16 + 1 + 8 + 2 + 4),
+				}
+			},
+			#[cfg(feature = "frame-feature-testing")]
+			{
+				StorageInfo {
+					pallet_name: b"Example".to_vec(),
+					storage_name: b"CounterForConditionalCountedNMap".to_vec(),
+					prefix: prefix(b"Example", b"CounterForConditionalCountedNMap").to_vec(),
+					max_values: Some(1),
+					max_size: Some(4),
+				}
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"RenamedCountedMap".to_vec(),
+				prefix: prefix(b"Example", b"RenamedCountedMap").to_vec(),
+				max_values: None,
+				max_size: Some(8 + 1 + 4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"CounterForRenamedCountedMap".to_vec(),
+				prefix: prefix(b"Example", b"CounterForRenamedCountedMap").to_vec(),
+				max_values: Some(1),
+				max_size: Some(4),
+			},
+			StorageInfo {
+				pallet_name: b"Example".to_vec(),
+				storage_name: b"Unbounded".to_vec(),
+				prefix: prefix(b"Example", b"Unbounded").to_vec(),
+				max_values: Some(1),
+				max_size: None,
+			},
+		],
+	);
+
+	assert_eq!(
+		Example2::storage_info(),
+		vec![
+			StorageInfo {
+				pallet_name: b"Example2".to_vec(),
+				storage_name: b"SomeValue".to_vec(),
+				prefix: prefix(b"Example2", b"SomeValue").to_vec(),
+				max_values: Some(1),
+				max_size: None,
+			},
+			StorageInfo {
+				pallet_name: b"Example2".to_vec(),
+				storage_name: b"SomeCountedStorageMap".to_vec(),
+				prefix: prefix(b"Example2", b"SomeCountedStorageMap").to_vec(),
+				max_values: None,
+				max_size: None,
+			},
+			StorageInfo {
+				pallet_name: b"Example2".to_vec(),
+				storage_name: b"CounterForSomeCountedStorageMap".to_vec(),
+				prefix: prefix(b"Example2", b"CounterForSomeCountedStorageMap").to_vec(),
+				max_values: Some(1),
+				max_size: Some(4),
+			},
+		],
+	);
+}
+
+#[test]
+fn assert_type_all_pallets_reversed_with_system_first_is_correct() {
+	// Just ensure the 2 types are same.
+	#[allow(deprecated)]
+	fn _a(_t: AllPalletsReversedWithSystemFirst) {}
+	#[cfg(all(not(feature = "frame-feature-testing"), not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (System, Example4, Example2, Example)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (System, Example4, Example3, Example2, Example)) {
+		_a(t)
+	}
+
+	#[cfg(all(not(feature = "frame-feature-testing"), feature = "frame-feature-testing-2"))]
+	fn _b(t: (System, Example5, Example4, Example2, Example)) {
+		_a(t)
+	}
+
+	#[cfg(all(feature = "frame-feature-testing", feature = "frame-feature-testing-2"))]
+	fn _b(t: (System, Example5, Example4, Example3, Example2, Example)) {
+		_a(t)
+	}
+}
+
+#[test]
+fn assert_type_all_pallets_with_system_is_correct() {
+	// Just ensure the 2 types are same.
+	fn _a(_t: AllPalletsWithSystem) {}
+	#[cfg(all(not(feature = "frame-feature-testing"), not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (System, Example, Example2, Example4)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (System, Example, Example2, Example3, Example4)) {
+		_a(t)
+	}
+	#[cfg(all(not(feature = "frame-feature-testing"), feature = "frame-feature-testing-2"))]
+	fn _b(t: (System, Example, Example2, Example4, Example5)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", feature = "frame-feature-testing-2"))]
+	fn _b(t: (System, Example, Example2, Example3, Example4, Example5)) {
+		_a(t)
+	}
+}
+
+#[test]
+fn assert_type_all_pallets_without_system_is_correct() {
+	// Just ensure the 2 types are same.
+	fn _a(_t: AllPalletsWithoutSystem) {}
+	#[cfg(all(not(feature = "frame-feature-testing"), not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (Example, Example2, Example4)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (Example, Example2, Example3, Example4)) {
+		_a(t)
+	}
+	#[cfg(all(not(feature = "frame-feature-testing"), feature = "frame-feature-testing-2"))]
+	fn _b(t: (Example, Example2, Example4, Example5)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", feature = "frame-feature-testing-2"))]
+	fn _b(t: (Example, Example2, Example3, Example4, Example5)) {
+		_a(t)
+	}
+}
+
+#[test]
+fn assert_type_all_pallets_with_system_reversed_is_correct() {
+	// Just ensure the 2 types are same.
+	#[allow(deprecated)]
+	fn _a(_t: AllPalletsWithSystemReversed) {}
+	#[cfg(all(not(feature = "frame-feature-testing"), not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (Example4, Example2, Example, System)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (Example4, Example3, Example2, Example, System)) {
+		_a(t)
+	}
+	#[cfg(all(not(feature = "frame-feature-testing"), feature = "frame-feature-testing-2"))]
+	fn _b(t: (Example5, Example4, Example2, Example, System)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", feature = "frame-feature-testing-2"))]
+	fn _b(t: (Example5, Example4, Example3, Example2, Example, System)) {
+		_a(t)
+	}
+}
+
+#[test]
+fn assert_type_all_pallets_without_system_reversed_is_correct() {
+	// Just ensure the 2 types are same.
+	#[allow(deprecated)]
+	fn _a(_t: AllPalletsWithoutSystemReversed) {}
+	#[cfg(all(not(feature = "frame-feature-testing"), not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (Example4, Example2, Example)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", not(feature = "frame-feature-testing-2")))]
+	fn _b(t: (Example4, Example3, Example2, Example)) {
+		_a(t)
+	}
+	#[cfg(all(not(feature = "frame-feature-testing"), feature = "frame-feature-testing-2"))]
+	fn _b(t: (Example5, Example4, Example2, Example)) {
+		_a(t)
+	}
+	#[cfg(all(feature = "frame-feature-testing", feature = "frame-feature-testing-2"))]
+	fn _b(t: (Example5, Example4, Example3, Example2, Example)) {
+		_a(t)
+	}
+}
+
+#[test]
+fn test_storage_alias() {
+	use frame_support::Twox64Concat;
+
+	#[frame_support::storage_alias]
+	type Value<T: pallet::Config>
+	where
+		<T as frame_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
+	= StorageValue<pallet::Pallet<T>, u32, ValueQuery>;
+
+	#[frame_support::storage_alias]
+	type SomeCountedStorageMap<T: pallet2::Config>
+	where
+		<T as frame_system::Config>::AccountId: From<SomeType1> + SomeAssociation1,
+	= CountedStorageMap<pallet2::Pallet<T>, Twox64Concat, u8, u32>;
+
+	TestExternalities::default().execute_with(|| {
+		pallet::Value::<Runtime>::put(10);
+		assert_eq!(10, Value::<Runtime>::get());
+
+		pallet2::SomeCountedStorageMap::<Runtime>::insert(10, 100);
+		assert_eq!(Some(100), SomeCountedStorageMap::<Runtime>::get(10));
+		assert_eq!(1, SomeCountedStorageMap::<Runtime>::count());
+		assert_eq!(
+			SomeCountedStorageMap::<Runtime>::storage_info(),
+			pallet2::SomeCountedStorageMap::<Runtime>::storage_info()
+		);
+	})
+}
+
+#[cfg(feature = "try-runtime")]
+#[test]
+fn post_runtime_upgrade_detects_storage_version_issues() {
+	use frame_support::traits::UpgradeCheckSelect;
+
+	struct CustomUpgrade;
+
+	impl OnRuntimeUpgrade for CustomUpgrade {
+		fn on_runtime_upgrade() -> Weight {
+			Example2::current_storage_version().put::<Example2>();
+
+			Default::default()
+		}
+	}
+
+	struct CustomUpgradePallet4;
+
+	impl OnRuntimeUpgrade for CustomUpgradePallet4 {
+		fn on_runtime_upgrade() -> Weight {
+			StorageVersion::new(100).put::<Example4>();
+
+			Default::default()
+		}
+	}
+
+	type Executive = frame_executive::Executive<
+		Runtime,
+		Block,
+		frame_system::ChainContext<Runtime>,
+		Runtime,
+		AllPalletsWithSystem,
+	>;
+
+	type ExecutiveWithUpgrade = frame_executive::Executive<
+		Runtime,
+		Block,
+		frame_system::ChainContext<Runtime>,
+		Runtime,
+		AllPalletsWithSystem,
+		CustomUpgrade,
+	>;
+
+	type ExecutiveWithUpgradePallet4 = frame_executive::Executive<
+		Runtime,
+		Block,
+		frame_system::ChainContext<Runtime>,
+		Runtime,
+		AllPalletsWithSystem,
+		CustomUpgradePallet4,
+	>;
+
+	TestExternalities::default().execute_with(|| {
+		// Call `on_genesis` to put the storage version of `Example` into the storage.
+		Example::on_genesis();
+		// The version isn't changed, we should detect it.
+		assert!(
+			Executive::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost).unwrap_err() ==
+				"On chain and current storage version do not match. Missing runtime upgrade?"
+					.into()
+		);
+	});
+
+	TestExternalities::default().execute_with(|| {
+		// Call `on_genesis` to put the storage version of `Example` into the storage.
+		Example::on_genesis();
+		// We set the new storage version in the pallet and that should be detected.
+		UpdateStorageVersion::set(&true);
+		Executive::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost).unwrap();
+	});
+
+	TestExternalities::default().execute_with(|| {
+		// Call `on_genesis` to put the storage version of `Example` into the storage.
+		Example::on_genesis();
+		// We set the new storage version in the custom upgrade and that should be detected.
+		ExecutiveWithUpgrade::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost).unwrap();
+	});
+
+	TestExternalities::default().execute_with(|| {
+		// Call `on_genesis` to put the storage version of `Example` into the storage.
+		Example::on_genesis();
+		// We need to set the correct storage version for `Example2`
+		UpdateStorageVersion::set(&true);
+
+		// `CustomUpgradePallet4` will set a storage version for `Example4` while this doesn't has
+		// any storage version "enabled".
+		assert!(
+			ExecutiveWithUpgradePallet4::try_runtime_upgrade(UpgradeCheckSelect::PreAndPost)
+				.unwrap_err() == "On chain storage version set, while the pallet \
+				doesn't have the `#[pallet::storage_version(VERSION)]` attribute."
+				.into()
+		);
+	});
+}
+
+#[test]
+fn test_dispatch_context() {
+	TestExternalities::default().execute_with(|| {
+		// By default there is no context
+		assert!(with_context::<(), _>(|_| ()).is_none());
+
+		// When not using `dispatch`, there should be no dispatch context
+		assert_eq!(
+			DispatchError::Unavailable,
+			Example::check_for_dispatch_context(RuntimeOrigin::root()).unwrap_err(),
+		);
+
+		// When using `dispatch`, there should be a dispatch context
+		assert_ok!(RuntimeCall::from(pallet::Call::<Runtime>::check_for_dispatch_context {})
+			.dispatch(RuntimeOrigin::root()));
+	});
+}
diff --git a/substrate/frame/support/test/tests/pallet_instance.rs b/substrate/frame/support/test/tests/pallet_instance.rs
new file mode 100644
index 0000000000000000000000000000000000000000..be675a562cec5d40c7cf468c5a6b04b08202b998
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_instance.rs
@@ -0,0 +1,991 @@
+// 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_support::{
+	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, Pays, UnfilteredDispatchable},
+	pallet_prelude::ValueQuery,
+	parameter_types,
+	storage::unhashed,
+	traits::{ConstU32, GetCallName, OnFinalize, OnGenesis, OnInitialize, OnRuntimeUpgrade},
+	weights::Weight,
+};
+use sp_io::{
+	hashing::{blake2_128, twox_128, twox_64},
+	TestExternalities,
+};
+use sp_runtime::{DispatchError, ModuleError};
+use sp_std::any::TypeId;
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	type BalanceOf<T, I> = <T as Config<I>>::Balance;
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		#[pallet::constant]
+		type MyGetParam: Get<u32>;
+		type Balance: Parameter + Default + scale_info::StaticTypeInfo;
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		fn on_initialize(_: BlockNumberFor<T>) -> Weight {
+			if TypeId::of::<I>() == TypeId::of::<()>() {
+				Self::deposit_event(Event::Something(10));
+				Weight::from_parts(10, 0)
+			} else {
+				Self::deposit_event(Event::Something(11));
+				Weight::from_parts(11, 0)
+			}
+		}
+		fn on_finalize(_: BlockNumberFor<T>) {
+			if TypeId::of::<I>() == TypeId::of::<()>() {
+				Self::deposit_event(Event::Something(20));
+			} else {
+				Self::deposit_event(Event::Something(21));
+			}
+		}
+		fn on_runtime_upgrade() -> Weight {
+			if TypeId::of::<I>() == TypeId::of::<()>() {
+				Self::deposit_event(Event::Something(30));
+				Weight::from_parts(30, 0)
+			} else {
+				Self::deposit_event(Event::Something(31));
+				Weight::from_parts(31, 0)
+			}
+		}
+		fn integrity_test() {}
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Doc comment put in metadata
+		#[pallet::call_index(0)]
+		#[pallet::weight(Weight::from_parts(*_foo as u64, 0))]
+		pub fn foo(
+			origin: OriginFor<T>,
+			#[pallet::compact] _foo: u32,
+		) -> DispatchResultWithPostInfo {
+			let _ = origin;
+			Self::deposit_event(Event::Something(3));
+			Ok(().into())
+		}
+
+		/// Doc comment put in metadata
+		#[pallet::call_index(1)]
+		#[pallet::weight(1)]
+		pub fn foo_storage_layer(
+			origin: OriginFor<T>,
+			#[pallet::compact] _foo: u32,
+		) -> DispatchResultWithPostInfo {
+			let _ = origin;
+			Ok(().into())
+		}
+	}
+
+	#[pallet::error]
+	#[derive(PartialEq, Eq)]
+	pub enum Error<T, I = ()> {
+		/// doc comment put into metadata
+		InsufficientProposersBalance,
+		NonExistentStorageValue,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// doc comment put in metadata
+		Proposed(<T as frame_system::Config>::AccountId),
+		/// doc
+		Spending(BalanceOf<T, I>),
+		Something(u32),
+	}
+
+	#[pallet::storage]
+	pub type Value<T, I = ()> = StorageValue<_, u32>;
+
+	#[pallet::storage]
+	pub type Map<T, I = ()> = StorageMap<_, Blake2_128Concat, u8, u16>;
+
+	#[pallet::storage]
+	pub type Map2<T, I = ()> = StorageMap<_, Twox64Concat, u16, u32>;
+
+	parameter_types! {
+		pub const Map3Default<T, I>: Result<u64, Error<T, I>> = Ok(1337);
+	}
+
+	#[pallet::storage]
+	pub type Map3<T, I = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		u32,
+		u64,
+		ResultQuery<Error<T, I>::NonExistentStorageValue>,
+		Map3Default<T, I>,
+	>;
+
+	#[pallet::storage]
+	pub type DoubleMap<T, I = ()> =
+		StorageDoubleMap<_, Blake2_128Concat, u8, Twox64Concat, u16, u32>;
+
+	#[pallet::storage]
+	pub type DoubleMap2<T, I = ()> =
+		StorageDoubleMap<_, Twox64Concat, u16, Blake2_128Concat, u32, u64>;
+
+	#[pallet::storage]
+	pub type DoubleMap3<T, I = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		u32,
+		Twox64Concat,
+		u64,
+		u128,
+		ResultQuery<Error<T, I>::NonExistentStorageValue>,
+	>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn nmap)]
+	pub type NMap<T, I = ()> = StorageNMap<_, storage::Key<Blake2_128Concat, u8>, u32>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn nmap2)]
+	pub type NMap2<T, I = ()> =
+		StorageNMap<_, (storage::Key<Twox64Concat, u16>, storage::Key<Blake2_128Concat, u32>), u64>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn nmap3)]
+	pub type NMap3<T, I = ()> = StorageNMap<
+		_,
+		(NMapKey<Blake2_128Concat, u8>, NMapKey<Twox64Concat, u16>),
+		u128,
+		ResultQuery<Error<T, I>::NonExistentStorageValue>,
+	>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		#[serde(skip)]
+		_config: sp_std::marker::PhantomData<(T, I)>,
+		_myfield: u32,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {}
+	}
+
+	#[pallet::origin]
+	#[derive(
+		EqNoBound,
+		RuntimeDebugNoBound,
+		CloneNoBound,
+		PartialEqNoBound,
+		Encode,
+		Decode,
+		scale_info::TypeInfo,
+		MaxEncodedLen,
+	)]
+	#[scale_info(skip_type_params(T, I))]
+	pub struct Origin<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::validate_unsigned]
+	impl<T: Config<I>, I: 'static> ValidateUnsigned for Pallet<T, I> {
+		type Call = Call<T, I>;
+		fn validate_unsigned(
+			_source: TransactionSource,
+			_call: &Self::Call,
+		) -> TransactionValidity {
+			Err(TransactionValidityError::Invalid(InvalidTransaction::Call))
+		}
+	}
+
+	#[pallet::inherent]
+	impl<T: Config<I>, I: 'static> ProvideInherent for Pallet<T, I> {
+		type Call = Call<T, I>;
+		type Error = InherentError;
+
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(_data: &InherentData) -> Option<Self::Call> {
+			unimplemented!();
+		}
+
+		fn is_inherent(_call: &Self::Call) -> bool {
+			unimplemented!();
+		}
+	}
+
+	#[derive(codec::Encode, sp_runtime::RuntimeDebug)]
+	#[cfg_attr(feature = "std", derive(codec::Decode))]
+	pub enum InherentError {}
+
+	impl frame_support::inherent::IsFatalError for InherentError {
+		fn is_fatal_error(&self) -> bool {
+			unimplemented!();
+		}
+	}
+
+	pub const INHERENT_IDENTIFIER: frame_support::inherent::InherentIdentifier = *b"testpall";
+}
+
+// Test that a instantiable pallet with a generic genesis_config is correctly handled
+#[frame_support::pallet]
+pub mod pallet2 {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::event]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// Something
+		Something(u32),
+	}
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		phantom: PhantomData<(T, I)>,
+	}
+
+	impl<T: Config<I>, I: 'static> Default for GenesisConfig<T, I> {
+		fn default() -> Self {
+			GenesisConfig { phantom: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {}
+	}
+}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+impl pallet::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type MyGetParam = ConstU32<10>;
+	type Balance = u64;
+}
+impl pallet::Config<pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type MyGetParam = ConstU32<10>;
+	type Balance = u64;
+}
+impl pallet2::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl pallet2::Config<pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+pub type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		// Exclude part `Storage` in order not to check its metadata in tests.
+		System: frame_system exclude_parts { Storage },
+		Example: pallet,
+		Instance1Example: pallet::<Instance1>,
+		Example2: pallet2,
+		Instance1Example2: pallet2::<Instance1>,
+	}
+);
+
+#[test]
+fn call_expand() {
+	let call_foo = pallet::Call::<Runtime>::foo { foo: 3 };
+	assert_eq!(
+		call_foo.get_dispatch_info(),
+		DispatchInfo {
+			weight: Weight::from_parts(3, 0),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes
+		}
+	);
+	assert_eq!(call_foo.get_call_name(), "foo");
+	assert_eq!(pallet::Call::<Runtime>::get_call_names(), &["foo", "foo_storage_layer"]);
+
+	let call_foo = pallet::Call::<Runtime, pallet::Instance1>::foo { foo: 3 };
+	assert_eq!(
+		call_foo.get_dispatch_info(),
+		DispatchInfo {
+			weight: Weight::from_parts(3, 0),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes
+		}
+	);
+	assert_eq!(call_foo.get_call_name(), "foo");
+	assert_eq!(
+		pallet::Call::<Runtime, pallet::Instance1>::get_call_names(),
+		&["foo", "foo_storage_layer"],
+	);
+}
+
+#[test]
+fn error_expand() {
+	assert_eq!(
+		format!("{:?}", pallet::Error::<Runtime>::InsufficientProposersBalance),
+		String::from("InsufficientProposersBalance"),
+	);
+	assert_eq!(
+		<&'static str>::from(pallet::Error::<Runtime>::InsufficientProposersBalance),
+		"InsufficientProposersBalance",
+	);
+	assert_eq!(
+		DispatchError::from(pallet::Error::<Runtime>::InsufficientProposersBalance),
+		DispatchError::Module(ModuleError {
+			index: 1,
+			error: [0; 4],
+			message: Some("InsufficientProposersBalance")
+		}),
+	);
+
+	assert_eq!(
+		format!("{:?}", pallet::Error::<Runtime, pallet::Instance1>::InsufficientProposersBalance),
+		String::from("InsufficientProposersBalance"),
+	);
+	assert_eq!(
+		<&'static str>::from(
+			pallet::Error::<Runtime, pallet::Instance1>::InsufficientProposersBalance
+		),
+		"InsufficientProposersBalance",
+	);
+	assert_eq!(
+		DispatchError::from(
+			pallet::Error::<Runtime, pallet::Instance1>::InsufficientProposersBalance
+		),
+		DispatchError::Module(ModuleError {
+			index: 2,
+			error: [0; 4],
+			message: Some("InsufficientProposersBalance")
+		}),
+	);
+}
+
+#[test]
+fn module_error_outer_enum_expand() {
+	// assert that all variants of the Example pallet are included into the
+	// RuntimeError definition.
+	match RuntimeError::Example(pallet::Error::InsufficientProposersBalance) {
+		RuntimeError::Example(example) => match example {
+			pallet::Error::InsufficientProposersBalance => (),
+			pallet::Error::NonExistentStorageValue => (),
+			// Extra pattern added by `construct_runtime`.
+			pallet::Error::__Ignore(_, _) => (),
+		},
+		_ => (),
+	};
+}
+
+#[test]
+fn module_error_from_dispatch_error() {
+	let dispatch_err = DispatchError::Module(ModuleError {
+		index: 1,
+		error: [0; 4],
+		message: Some("InsufficientProposersBalance"),
+	});
+	let err = RuntimeError::from_dispatch_error(dispatch_err).unwrap();
+
+	match err {
+		RuntimeError::Example(pallet::Error::InsufficientProposersBalance) => (),
+		_ => panic!("Module error constructed incorrectly"),
+	};
+
+	// Only `ModuleError` is converted.
+	assert!(RuntimeError::from_dispatch_error(DispatchError::BadOrigin).is_none());
+}
+
+#[test]
+fn instance_expand() {
+	// assert same type
+	let _: pallet::__InherentHiddenInstance = ();
+}
+
+#[test]
+fn pallet_expand_deposit_event() {
+	TestExternalities::default().execute_with(|| {
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+		pallet::Call::<Runtime>::foo { foo: 3 }
+			.dispatch_bypass_filter(None.into())
+			.unwrap();
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[0].event,
+			RuntimeEvent::Example(pallet::Event::Something(3)),
+		);
+	});
+
+	TestExternalities::default().execute_with(|| {
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+		pallet::Call::<Runtime, pallet::Instance1>::foo { foo: 3 }
+			.dispatch_bypass_filter(None.into())
+			.unwrap();
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[0].event,
+			RuntimeEvent::Instance1Example(pallet::Event::Something(3)),
+		);
+	});
+}
+
+#[test]
+fn storage_expand() {
+	use frame_support::{pallet_prelude::*, storage::StoragePrefixedMap};
+
+	fn twox_64_concat(d: &[u8]) -> Vec<u8> {
+		let mut v = twox_64(d).to_vec();
+		v.extend_from_slice(d);
+		v
+	}
+
+	fn blake2_128_concat(d: &[u8]) -> Vec<u8> {
+		let mut v = blake2_128(d).to_vec();
+		v.extend_from_slice(d);
+		v
+	}
+
+	TestExternalities::default().execute_with(|| {
+		<pallet::Value<Runtime>>::put(1);
+		let k = [twox_128(b"Example"), twox_128(b"Value")].concat();
+		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));
+
+		<pallet::Map<Runtime>>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"Map")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u16>(&k), Some(2u16));
+		assert_eq!(&k[..32], &<pallet::Map<Runtime>>::final_prefix());
+
+		<pallet::Map2<Runtime>>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"Map2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<pallet::Map2<Runtime>>::final_prefix());
+
+		<pallet::Map3<Runtime>>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"Map3")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(2u64));
+		assert_eq!(&k[..32], &<pallet::Map3<Runtime>>::final_prefix());
+		assert_eq!(<pallet::Map3<Runtime>>::get(2), Ok(1337));
+
+		<pallet::DoubleMap<Runtime>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		k.extend(2u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<pallet::DoubleMap<Runtime>>::final_prefix());
+
+		<pallet::DoubleMap2<Runtime>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
+		assert_eq!(&k[..32], &<pallet::DoubleMap2<Runtime>>::final_prefix());
+
+		<pallet::DoubleMap3<Runtime>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"DoubleMap3")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		k.extend(2u64.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
+		assert_eq!(&k[..32], &<pallet::DoubleMap3<Runtime>>::final_prefix());
+		assert_eq!(
+			<pallet::DoubleMap3<Runtime>>::get(2, 3),
+			Err(pallet::Error::<Runtime>::NonExistentStorageValue),
+		);
+
+		<pallet::NMap<Runtime>>::insert((&1,), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"NMap")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<pallet::NMap<Runtime>>::final_prefix());
+
+		<pallet::NMap2<Runtime>>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"NMap2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
+		assert_eq!(&k[..32], &<pallet::NMap2<Runtime>>::final_prefix());
+
+		<pallet::NMap3<Runtime>>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Example"), twox_128(b"NMap3")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		k.extend(2u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
+		assert_eq!(&k[..32], &<pallet::NMap3<Runtime>>::final_prefix());
+		assert_eq!(
+			<pallet::NMap3<Runtime>>::get((2, 3)),
+			Err(pallet::Error::<Runtime>::NonExistentStorageValue),
+		);
+	});
+
+	TestExternalities::default().execute_with(|| {
+		<pallet::Value<Runtime, pallet::Instance1>>::put(1);
+		let k = [twox_128(b"Instance1Example"), twox_128(b"Value")].concat();
+		assert_eq!(unhashed::get::<u32>(&k), Some(1u32));
+
+		<pallet::Map<Runtime, pallet::Instance1>>::insert(1, 2);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"Map")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u16>(&k), Some(2u16));
+		assert_eq!(&k[..32], &<pallet::Map<Runtime, pallet::Instance1>>::final_prefix());
+
+		<pallet::Map2<Runtime, pallet::Instance1>>::insert(1, 2);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"Map2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(2u32));
+		assert_eq!(&k[..32], &<pallet::Map2<Runtime, pallet::Instance1>>::final_prefix());
+
+		<pallet::Map3<Runtime, pallet::Instance1>>::insert(1, 2);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"Map3")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(2u64));
+		assert_eq!(&k[..32], &<pallet::Map3<Runtime, pallet::Instance1>>::final_prefix());
+		assert_eq!(<pallet::Map3<Runtime, pallet::Instance1>>::get(2), Ok(1337));
+
+		<pallet::DoubleMap<Runtime, pallet::Instance1>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"DoubleMap")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		k.extend(2u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<pallet::DoubleMap<Runtime, pallet::Instance1>>::final_prefix());
+
+		<pallet::DoubleMap2<Runtime, pallet::Instance1>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"DoubleMap2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
+		assert_eq!(&k[..32], &<pallet::DoubleMap2<Runtime, pallet::Instance1>>::final_prefix());
+
+		<pallet::DoubleMap3<Runtime, pallet::Instance1>>::insert(&1, &2, &3);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"DoubleMap3")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		k.extend(2u64.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
+		assert_eq!(&k[..32], &<pallet::DoubleMap3<Runtime, pallet::Instance1>>::final_prefix());
+		assert_eq!(
+			<pallet::DoubleMap3<Runtime, pallet::Instance1>>::get(2, 3),
+			Err(pallet::Error::<Runtime, pallet::Instance1>::NonExistentStorageValue),
+		);
+
+		<pallet::NMap<Runtime, pallet::Instance1>>::insert((&1,), &3);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"NMap")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u32>(&k), Some(3u32));
+		assert_eq!(&k[..32], &<pallet::NMap<Runtime, pallet::Instance1>>::final_prefix());
+
+		<pallet::NMap2<Runtime, pallet::Instance1>>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"NMap2")].concat();
+		k.extend(1u16.using_encoded(twox_64_concat));
+		k.extend(2u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(3u64));
+		assert_eq!(&k[..32], &<pallet::NMap2<Runtime, pallet::Instance1>>::final_prefix());
+
+		<pallet::NMap3<Runtime, pallet::Instance1>>::insert((&1, &2), &3);
+		let mut k = [twox_128(b"Instance1Example"), twox_128(b"NMap3")].concat();
+		k.extend(1u8.using_encoded(blake2_128_concat));
+		k.extend(2u16.using_encoded(twox_64_concat));
+		assert_eq!(unhashed::get::<u128>(&k), Some(3u128));
+		assert_eq!(&k[..32], &<pallet::NMap3<Runtime, pallet::Instance1>>::final_prefix());
+		assert_eq!(
+			<pallet::NMap3<Runtime, pallet::Instance1>>::get((2, 3)),
+			Err(pallet::Error::<Runtime, pallet::Instance1>::NonExistentStorageValue),
+		);
+	});
+}
+
+#[test]
+fn pallet_metadata_expands() {
+	use frame_support::traits::PalletsInfoAccess;
+	let mut infos = AllPalletsWithSystem::infos();
+	infos.sort_by_key(|x| x.index);
+
+	assert_eq!(infos[0].index, 0);
+	assert_eq!(infos[0].name, "System");
+	assert_eq!(infos[0].module_name, "frame_system");
+
+	assert_eq!(infos[1].index, 1);
+	assert_eq!(infos[1].name, "Example");
+	assert_eq!(infos[1].module_name, "pallet");
+
+	assert_eq!(infos[2].index, 2);
+	assert_eq!(infos[2].name, "Instance1Example");
+	assert_eq!(infos[2].module_name, "pallet");
+
+	assert_eq!(infos[3].index, 3);
+	assert_eq!(infos[3].name, "Example2");
+	assert_eq!(infos[3].module_name, "pallet2");
+
+	assert_eq!(infos[4].index, 4);
+	assert_eq!(infos[4].name, "Instance1Example2");
+	assert_eq!(infos[4].module_name, "pallet2");
+}
+
+#[test]
+fn pallet_hooks_expand() {
+	TestExternalities::default().execute_with(|| {
+		frame_system::Pallet::<Runtime>::set_block_number(1);
+
+		assert_eq!(AllPalletsWithoutSystem::on_initialize(1), Weight::from_parts(21, 0));
+		AllPalletsWithoutSystem::on_finalize(1);
+
+		assert_eq!(AllPalletsWithoutSystem::on_runtime_upgrade(), Weight::from_parts(61, 0));
+
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[0].event,
+			RuntimeEvent::Example(pallet::Event::Something(10)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[1].event,
+			RuntimeEvent::Instance1Example(pallet::Event::Something(11)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[2].event,
+			RuntimeEvent::Example(pallet::Event::Something(20)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[3].event,
+			RuntimeEvent::Instance1Example(pallet::Event::Something(21)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[4].event,
+			RuntimeEvent::Example(pallet::Event::Something(30)),
+		);
+		assert_eq!(
+			frame_system::Pallet::<Runtime>::events()[5].event,
+			RuntimeEvent::Instance1Example(pallet::Event::Something(31)),
+		);
+	})
+}
+
+#[test]
+fn pallet_on_genesis() {
+	TestExternalities::default().execute_with(|| {
+		pallet::Pallet::<Runtime>::on_genesis();
+
+		pallet::Pallet::<Runtime, pallet::Instance1>::on_genesis();
+	})
+}
+
+#[test]
+fn metadata() {
+	use frame_metadata::{v14::*, *};
+
+	let system_pallet_metadata = PalletMetadata {
+		index: 0,
+		name: "System",
+		storage: None, // The storage metadatas have been excluded.
+		calls: Some(scale_info::meta_type::<frame_system::Call<Runtime>>().into()),
+		event: Some(PalletEventMetadata {
+			ty: scale_info::meta_type::<frame_system::Event<Runtime>>(),
+		}),
+		constants: vec![
+			PalletConstantMetadata {
+				name: "BlockWeights",
+				ty: scale_info::meta_type::<frame_system::limits::BlockWeights>(),
+				value: vec![],
+				docs: vec![],
+			},
+			PalletConstantMetadata {
+				name: "BlockLength",
+				ty: scale_info::meta_type::<frame_system::limits::BlockLength>(),
+				value: vec![],
+				docs: vec![],
+			},
+			PalletConstantMetadata {
+				name: "BlockHashCount",
+				ty: scale_info::meta_type::<u32>(),
+				value: vec![],
+				docs: vec![],
+			},
+			PalletConstantMetadata {
+				name: "DbWeight",
+				ty: scale_info::meta_type::<frame_support::weights::RuntimeDbWeight>(),
+				value: vec![],
+				docs: vec![],
+			},
+			PalletConstantMetadata {
+				name: "Version",
+				ty: scale_info::meta_type::<sp_version::RuntimeVersion>(),
+				value: vec![],
+				docs: vec![],
+			},
+			PalletConstantMetadata {
+				name: "SS58Prefix",
+				ty: scale_info::meta_type::<u16>(),
+				value: vec![],
+				docs: vec![],
+			},
+		],
+		error: Some(PalletErrorMetadata {
+			ty: scale_info::meta_type::<frame_system::Error<Runtime>>(),
+		}),
+	};
+
+	let example_pallet_metadata = PalletMetadata {
+		index: 1,
+		name: "Example",
+		storage: Some(PalletStorageMetadata {
+			prefix: "Example",
+			entries: vec![
+				StorageEntryMetadata {
+					name: "Value",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Plain(scale_info::meta_type::<u32>()),
+					default: vec![0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "Map",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						key: scale_info::meta_type::<u8>(),
+						value: scale_info::meta_type::<u16>(),
+						hashers: vec![StorageHasher::Blake2_128Concat],
+					},
+					default: vec![0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "Map2",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						key: scale_info::meta_type::<u16>(),
+						value: scale_info::meta_type::<u32>(),
+						hashers: vec![StorageHasher::Twox64Concat],
+					},
+					default: vec![0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "Map3",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						key: scale_info::meta_type::<u32>(),
+						value: scale_info::meta_type::<u64>(),
+						hashers: vec![StorageHasher::Blake2_128Concat],
+					},
+					default: vec![0, 57, 5, 0, 0, 0, 0, 0, 0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "DoubleMap",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						value: scale_info::meta_type::<u32>(),
+						key: scale_info::meta_type::<(u8, u16)>(),
+						hashers: vec![StorageHasher::Blake2_128Concat, StorageHasher::Twox64Concat],
+					},
+					default: vec![0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "DoubleMap2",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						value: scale_info::meta_type::<u64>(),
+						key: scale_info::meta_type::<(u16, u32)>(),
+						hashers: vec![StorageHasher::Twox64Concat, StorageHasher::Blake2_128Concat],
+					},
+					default: vec![0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "DoubleMap3",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						value: scale_info::meta_type::<u128>(),
+						key: scale_info::meta_type::<(u32, u64)>(),
+						hashers: vec![StorageHasher::Blake2_128Concat, StorageHasher::Twox64Concat],
+					},
+					default: vec![1, 1],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "NMap",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						key: scale_info::meta_type::<u8>(),
+						hashers: vec![StorageHasher::Blake2_128Concat],
+						value: scale_info::meta_type::<u32>(),
+					},
+					default: vec![0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "NMap2",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						key: scale_info::meta_type::<(u16, u32)>(),
+						hashers: vec![StorageHasher::Twox64Concat, StorageHasher::Blake2_128Concat],
+						value: scale_info::meta_type::<u64>(),
+					},
+					default: vec![0],
+					docs: vec![],
+				},
+				StorageEntryMetadata {
+					name: "NMap3",
+					modifier: StorageEntryModifier::Optional,
+					ty: StorageEntryType::Map {
+						key: scale_info::meta_type::<(u8, u16)>(),
+						hashers: vec![StorageHasher::Blake2_128Concat, StorageHasher::Twox64Concat],
+						value: scale_info::meta_type::<u128>(),
+					},
+					default: vec![1, 1],
+					docs: vec![],
+				},
+			],
+		}),
+		calls: Some(scale_info::meta_type::<pallet::Call<Runtime>>().into()),
+		event: Some(PalletEventMetadata { ty: scale_info::meta_type::<pallet::Event<Runtime>>() }),
+		constants: vec![PalletConstantMetadata {
+			name: "MyGetParam",
+			ty: scale_info::meta_type::<u32>(),
+			value: vec![10, 0, 0, 0],
+			docs: vec![],
+		}],
+		error: Some(PalletErrorMetadata { ty: scale_info::meta_type::<pallet::Error<Runtime>>() }),
+	};
+
+	let mut example_pallet_instance1_metadata = example_pallet_metadata.clone();
+	example_pallet_instance1_metadata.name = "Instance1Example";
+	example_pallet_instance1_metadata.index = 2;
+	match example_pallet_instance1_metadata.calls {
+		Some(ref mut calls_meta) => {
+			calls_meta.ty = scale_info::meta_type::<pallet::Call<Runtime, pallet::Instance1>>();
+		},
+		_ => unreachable!(),
+	}
+	match example_pallet_instance1_metadata.event {
+		Some(ref mut event_meta) => {
+			event_meta.ty = scale_info::meta_type::<pallet::Event<Runtime, pallet::Instance1>>();
+		},
+		_ => unreachable!(),
+	}
+	match example_pallet_instance1_metadata.error {
+		Some(ref mut error_meta) => {
+			error_meta.ty = scale_info::meta_type::<pallet::Error<Runtime, pallet::Instance1>>();
+		},
+		_ => unreachable!(),
+	}
+	match example_pallet_instance1_metadata.storage {
+		Some(ref mut storage_meta) => {
+			storage_meta.prefix = "Instance1Example";
+		},
+		_ => unreachable!(),
+	}
+
+	let pallets =
+		vec![system_pallet_metadata, example_pallet_metadata, example_pallet_instance1_metadata];
+
+	let extrinsic = ExtrinsicMetadata {
+		ty: scale_info::meta_type::<UncheckedExtrinsic>(),
+		version: 4,
+		signed_extensions: vec![SignedExtensionMetadata {
+			identifier: "UnitSignedExtension",
+			ty: scale_info::meta_type::<()>(),
+			additional_signed: scale_info::meta_type::<()>(),
+		}],
+	};
+
+	let expected_metadata: RuntimeMetadataPrefixed =
+		RuntimeMetadataLastVersion::new(pallets, extrinsic, scale_info::meta_type::<Runtime>())
+			.into();
+	let expected_metadata = match expected_metadata.1 {
+		RuntimeMetadata::V14(metadata) => metadata,
+		_ => panic!("metadata has been bumped, test needs to be updated"),
+	};
+
+	let actual_metadata = match Runtime::metadata().1 {
+		RuntimeMetadata::V14(metadata) => metadata,
+		_ => panic!("metadata has been bumped, test needs to be updated"),
+	};
+
+	pretty_assertions::assert_eq!(actual_metadata.pallets[1], expected_metadata.pallets[1]);
+	pretty_assertions::assert_eq!(actual_metadata.pallets[2], expected_metadata.pallets[2]);
+}
+
+#[test]
+fn test_pallet_info_access() {
+	assert_eq!(<System as frame_support::traits::PalletInfoAccess>::name(), "System");
+	assert_eq!(<Example as frame_support::traits::PalletInfoAccess>::name(), "Example");
+	assert_eq!(
+		<Instance1Example as frame_support::traits::PalletInfoAccess>::name(),
+		"Instance1Example"
+	);
+	assert_eq!(<Example2 as frame_support::traits::PalletInfoAccess>::name(), "Example2");
+	assert_eq!(
+		<Instance1Example2 as frame_support::traits::PalletInfoAccess>::name(),
+		"Instance1Example2"
+	);
+
+	assert_eq!(<System as frame_support::traits::PalletInfoAccess>::index(), 0);
+	assert_eq!(<Example as frame_support::traits::PalletInfoAccess>::index(), 1);
+	assert_eq!(<Instance1Example as frame_support::traits::PalletInfoAccess>::index(), 2);
+	assert_eq!(<Example2 as frame_support::traits::PalletInfoAccess>::index(), 3);
+	assert_eq!(<Instance1Example2 as frame_support::traits::PalletInfoAccess>::index(), 4);
+}
+
+#[test]
+fn test_storage_alias() {
+	#[frame_support::storage_alias]
+	type Value<T: pallet::Config<I>, I: 'static> =
+		StorageValue<pallet::Pallet<T, I>, u32, ValueQuery>;
+
+	TestExternalities::default().execute_with(|| {
+		pallet::Value::<Runtime, pallet::Instance1>::put(10);
+		assert_eq!(10, Value::<Runtime, pallet::Instance1>::get());
+	})
+}
diff --git a/substrate/frame/support/test/tests/pallet_outer_enums_explicit.rs b/substrate/frame/support/test/tests/pallet_outer_enums_explicit.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a8250f8b15325cf2b2a149f2c8b0414d6308395a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_outer_enums_explicit.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.
+
+use frame_support::{derive_impl, traits::ConstU32};
+
+mod common;
+
+use common::outer_enums::{pallet, pallet2};
+
+pub type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl common::outer_enums::pallet::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet::Config<common::outer_enums::pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet2::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet2::Config<common::outer_enums::pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet3::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet3::Config<common::outer_enums::pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		// Exclude part `Storage` in order not to check its metadata in tests.
+		System: frame_system::{Pallet, Config<T>, Call, Event<T> },
+
+		// This pallet exposes the Error type explicitly.
+		Example: common::outer_enums::pallet::{Pallet, Config<T>, Event<T>, Error<T>},
+		Instance1Example: common::outer_enums::pallet::<Instance1>::{ Pallet, Config<T>, Event<T> },
+
+		// This pallet does not mention the Error type, but it must be propagated (similarly to the polkadot/kusama).
+		Example2: common::outer_enums::pallet2::{Pallet, Config<T>, Event<T> },
+		Instance1Example2: common::outer_enums::pallet2::<Instance1>::{Pallet, Config<T>, Event<T>},
+
+		// This pallet does not declare any errors.
+		Example3: common::outer_enums::pallet3::{Pallet, Config<T>, Event<T>},
+		Instance1Example3: common::outer_enums::pallet3::<Instance1>::{Pallet, Config<T>, Event<T>},
+	}
+);
+
+#[test]
+fn module_error_outer_enum_expand_explicit() {
+	// The Runtime has *all* parts explicitly defined.
+
+	// Check that all error types are propagated
+	match RuntimeError::Example(pallet::Error::InsufficientProposersBalance) {
+		// Error passed implicitely to the pallet system.
+		RuntimeError::System(system) => match system {
+			frame_system::Error::InvalidSpecName => (),
+			frame_system::Error::SpecVersionNeedsToIncrease => (),
+			frame_system::Error::FailedToExtractRuntimeVersion => (),
+			frame_system::Error::NonDefaultComposite => (),
+			frame_system::Error::NonZeroRefCount => (),
+			frame_system::Error::CallFiltered => (),
+			frame_system::Error::__Ignore(_, _) => (),
+		},
+
+		// Error declared explicitly.
+		RuntimeError::Example(example) => match example {
+			pallet::Error::InsufficientProposersBalance => (),
+			pallet::Error::NonExistentStorageValue => (),
+			pallet::Error::__Ignore(_, _) => (),
+		},
+		// Error declared explicitly.
+		RuntimeError::Instance1Example(example) => match example {
+			pallet::Error::InsufficientProposersBalance => (),
+			pallet::Error::NonExistentStorageValue => (),
+			pallet::Error::__Ignore(_, _) => (),
+		},
+
+		// Error must propagate even if not defined explicitly as pallet part.
+		RuntimeError::Example2(example) => match example {
+			pallet2::Error::OtherInsufficientProposersBalance => (),
+			pallet2::Error::OtherNonExistentStorageValue => (),
+			pallet2::Error::__Ignore(_, _) => (),
+		},
+		// Error must propagate even if not defined explicitly as pallet part.
+		RuntimeError::Instance1Example2(example) => match example {
+			pallet2::Error::OtherInsufficientProposersBalance => (),
+			pallet2::Error::OtherNonExistentStorageValue => (),
+			pallet2::Error::__Ignore(_, _) => (),
+		},
+	};
+}
diff --git a/substrate/frame/support/test/tests/pallet_outer_enums_implicit.rs b/substrate/frame/support/test/tests/pallet_outer_enums_implicit.rs
new file mode 100644
index 0000000000000000000000000000000000000000..191f095f5d78d4c1a1276326451b1afed674989a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_outer_enums_implicit.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.
+
+use frame_support::{derive_impl, traits::ConstU32};
+
+mod common;
+
+use common::outer_enums::{pallet, pallet2};
+
+pub type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl common::outer_enums::pallet::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet::Config<common::outer_enums::pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet2::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet2::Config<common::outer_enums::pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet3::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+impl common::outer_enums::pallet3::Config<common::outer_enums::pallet::Instance1> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		// Exclude part `Storage` in order not to check its metadata in tests.
+		System: frame_system exclude_parts { Storage },
+
+		// Pallet exposes `Error` implicitely.
+		Example: common::outer_enums::pallet,
+		Instance1Example: common::outer_enums::pallet::<Instance1>,
+
+		// Pallet exposes `Error` implicitely.
+		Example2: common::outer_enums::pallet2,
+		Instance1Example2: common::outer_enums::pallet2::<Instance1>,
+
+		// Pallet does not implement error.
+		Example3: common::outer_enums::pallet3,
+		Instance1Example3: common::outer_enums::pallet3::<Instance1>,
+	}
+);
+
+#[test]
+fn module_error_outer_enum_expand_implicit() {
+	// The Runtime has *all* parts implicitly defined.
+
+	// Check that all error types are propagated
+	match RuntimeError::Example(pallet::Error::InsufficientProposersBalance) {
+		// Error passed implicitely to the pallet system.
+		RuntimeError::System(system) => match system {
+			frame_system::Error::InvalidSpecName => (),
+			frame_system::Error::SpecVersionNeedsToIncrease => (),
+			frame_system::Error::FailedToExtractRuntimeVersion => (),
+			frame_system::Error::NonDefaultComposite => (),
+			frame_system::Error::NonZeroRefCount => (),
+			frame_system::Error::CallFiltered => (),
+			frame_system::Error::__Ignore(_, _) => (),
+		},
+
+		// Error declared explicitly.
+		RuntimeError::Example(example) => match example {
+			pallet::Error::InsufficientProposersBalance => (),
+			pallet::Error::NonExistentStorageValue => (),
+			pallet::Error::__Ignore(_, _) => (),
+		},
+		// Error declared explicitly.
+		RuntimeError::Instance1Example(example) => match example {
+			pallet::Error::InsufficientProposersBalance => (),
+			pallet::Error::NonExistentStorageValue => (),
+			pallet::Error::__Ignore(_, _) => (),
+		},
+
+		// Error must propagate even if not defined explicitly as pallet part.
+		RuntimeError::Example2(example) => match example {
+			pallet2::Error::OtherInsufficientProposersBalance => (),
+			pallet2::Error::OtherNonExistentStorageValue => (),
+			pallet2::Error::__Ignore(_, _) => (),
+		},
+		// Error must propagate even if not defined explicitly as pallet part.
+		RuntimeError::Instance1Example2(example) => match example {
+			pallet2::Error::OtherInsufficientProposersBalance => (),
+			pallet2::Error::OtherNonExistentStorageValue => (),
+			pallet2::Error::__Ignore(_, _) => (),
+		},
+	};
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui.rs b/substrate/frame/support/test/tests/pallet_ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..466957c9faa636c2a2d7f2b2bb1f5b58f208d1a2
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui.rs
@@ -0,0 +1,36 @@
+// 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.
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn pallet_ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if std::env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("SKIP_WASM_BUILD", "1");
+
+	// Deny all warnings since we emit warnings as part of a Pallet's UI.
+	std::env::set_var("RUSTFLAGS", "--deny warnings");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/pallet_ui/*.rs");
+	t.pass("tests/pallet_ui/pass/*.rs");
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/attr_non_empty.rs b/substrate/frame/support/test/tests/pallet_ui/attr_non_empty.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5173d983bbd8e37a6df18ba4b0b7953b6a3c9e94
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/attr_non_empty.rs
@@ -0,0 +1,6 @@
+#[frame_support::pallet [foo]]
+mod foo {
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/attr_non_empty.stderr b/substrate/frame/support/test/tests/pallet_ui/attr_non_empty.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9eac5de35db802320915c3b76a0367c03d1040f7
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/attr_non_empty.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet macro call: unexpected attribute. Macro call must be bare, such as `#[frame_support::pallet]` or `#[pallet]`, or must specify the `dev_mode` attribute, such as `#[frame_support::pallet(dev_mode)]` or #[pallet(dev_mode)].
+ --> tests/pallet_ui/attr_non_empty.rs:1:26
+  |
+1 | #[frame_support::pallet [foo]]
+  |                          ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.rs b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4f18f7281817afca45d6846339185821c4013705
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.rs
@@ -0,0 +1,28 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, DispatchResultWithPostInfo};
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar: codec::Codec + scale_info::TypeInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		#[pallet::call_index(0)]
+		pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+			Ok(().into())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.stderr b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d10bf1359019adb1197c9bbb2c4cbd48f66fb817
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound.stderr
@@ -0,0 +1,34 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_argument_invalid_bound.rs:19:20
+   |
+19 |         #[pallet::weight(0)]
+   |                          ^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error[E0277]: `<T as pallet::Config>::Bar` doesn't implement `std::fmt::Debug`
+  --> tests/pallet_ui/call_argument_invalid_bound.rs:21:36
+   |
+21 |         pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^ `<T as pallet::Config>::Bar` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+   |
+   = help: the trait `std::fmt::Debug` is not implemented for `<T as pallet::Config>::Bar`
+   = note: required for `&<T as pallet::Config>::Bar` to implement `std::fmt::Debug`
+   = note: required for the cast from `&<T as pallet::Config>::Bar` to the object type `dyn std::fmt::Debug`
+
+error[E0277]: the trait bound `<T as pallet::Config>::Bar: Clone` is not satisfied
+  --> tests/pallet_ui/call_argument_invalid_bound.rs:21:36
+   |
+21 |         pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^ the trait `Clone` is not implemented for `<T as pallet::Config>::Bar`
+
+error[E0369]: binary operation `==` cannot be applied to type `&<T as pallet::Config>::Bar`
+  --> tests/pallet_ui/call_argument_invalid_bound.rs:21:36
+   |
+21 |         pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.rs b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..20568908e72b22a1486ac968c32b7bd37ab561db
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.rs
@@ -0,0 +1,28 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, DispatchResultWithPostInfo};
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar: scale_info::TypeInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		#[pallet::call_index(0)]
+		pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+			Ok(().into())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.stderr b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..7173cdcd47361651ca3fa4b5ae887ab9b1c94a92
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_2.stderr
@@ -0,0 +1,53 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_argument_invalid_bound_2.rs:19:20
+   |
+19 |         #[pallet::weight(0)]
+   |                          ^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error[E0277]: `<T as pallet::Config>::Bar` doesn't implement `std::fmt::Debug`
+  --> tests/pallet_ui/call_argument_invalid_bound_2.rs:21:36
+   |
+21 |         pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^ `<T as pallet::Config>::Bar` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+   |
+   = help: the trait `std::fmt::Debug` is not implemented for `<T as pallet::Config>::Bar`
+   = note: required for `&<T as pallet::Config>::Bar` to implement `std::fmt::Debug`
+   = note: required for the cast from `&<T as pallet::Config>::Bar` to the object type `dyn std::fmt::Debug`
+
+error[E0277]: the trait bound `<T as pallet::Config>::Bar: Clone` is not satisfied
+  --> tests/pallet_ui/call_argument_invalid_bound_2.rs:21:36
+   |
+21 |         pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^ the trait `Clone` is not implemented for `<T as pallet::Config>::Bar`
+
+error[E0369]: binary operation `==` cannot be applied to type `&<T as pallet::Config>::Bar`
+  --> tests/pallet_ui/call_argument_invalid_bound_2.rs:21:36
+   |
+21 |         pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^
+
+error[E0277]: the trait bound `<T as pallet::Config>::Bar: WrapperTypeEncode` is not satisfied
+  --> tests/pallet_ui/call_argument_invalid_bound_2.rs:21:36
+   |
+1  | #[frame_support::pallet]
+   | ------------------------ required by a bound introduced by this call
+...
+21 |         pub fn foo(origin: OriginFor<T>, _bar: T::Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^ the trait `WrapperTypeEncode` is not implemented for `<T as pallet::Config>::Bar`
+   |
+   = note: required for `<T as pallet::Config>::Bar` to implement `Encode`
+
+error[E0277]: the trait bound `<T as pallet::Config>::Bar: WrapperTypeDecode` is not satisfied
+  --> tests/pallet_ui/call_argument_invalid_bound_2.rs:17:12
+   |
+17 |     #[pallet::call]
+   |               ^^^^ the trait `WrapperTypeDecode` is not implemented for `<T as pallet::Config>::Bar`
+   |
+   = note: required for `<T as pallet::Config>::Bar` to implement `Decode`
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.rs b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.rs
new file mode 100644
index 0000000000000000000000000000000000000000..64b6642b0a8787111de9454ff91c0afaedb1c131
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.rs
@@ -0,0 +1,29 @@
+#[frame_support::pallet]
+mod pallet {
+	use codec::{Decode, Encode};
+	use frame_support::pallet_prelude::{DispatchResultWithPostInfo, Hooks};
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[derive(Encode, Decode, scale_info::TypeInfo, PartialEq, Clone)]
+	struct Bar;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		#[pallet::call_index(0)]
+		pub fn foo(origin: OriginFor<T>, _bar: Bar) -> DispatchResultWithPostInfo {
+			Ok(().into())
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.stderr b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4cbed3709626c0fda8178e637ee02eb9fa0872c4
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_argument_invalid_bound_3.stderr
@@ -0,0 +1,28 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_argument_invalid_bound_3.rs:21:20
+   |
+21 |         #[pallet::weight(0)]
+   |                          ^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error[E0277]: `Bar` doesn't implement `std::fmt::Debug`
+  --> tests/pallet_ui/call_argument_invalid_bound_3.rs:23:36
+   |
+23 |         pub fn foo(origin: OriginFor<T>, _bar: Bar) -> DispatchResultWithPostInfo {
+   |                                          ^^^^ `Bar` cannot be formatted using `{:?}`
+   |
+   = help: the trait `std::fmt::Debug` is not implemented for `Bar`
+   = note: add `#[derive(Debug)]` to `Bar` or manually `impl std::fmt::Debug for Bar`
+   = note: required for `&Bar` to implement `std::fmt::Debug`
+   = note: required for the cast from `&Bar` to the object type `dyn std::fmt::Debug`
+help: consider annotating `Bar` with `#[derive(Debug)]`
+   |
+17 +     #[derive(Debug)]
+18 |     struct Bar;
+   |
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_conflicting_indices.rs b/substrate/frame/support/test/tests/pallet_ui/call_conflicting_indices.rs
new file mode 100644
index 0000000000000000000000000000000000000000..395766c7cd331febcc15ed9a6ea04a0cbaad3693
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_conflicting_indices.rs
@@ -0,0 +1,24 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		#[pallet::call_index(10)]
+		pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+
+		#[pallet::weight(0)]
+		#[pallet::call_index(10)]
+		pub fn bar(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_conflicting_indices.stderr b/substrate/frame/support/test/tests/pallet_ui/call_conflicting_indices.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5d0c90609c2a189486fb46043fe79f201ff28a00
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_conflicting_indices.stderr
@@ -0,0 +1,11 @@
+error: Call indices are conflicting: Both functions foo and bar are at index 10
+  --> tests/pallet_ui/call_conflicting_indices.rs:15:10
+   |
+15 |         pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+   |                ^^^
+
+error: Call indices are conflicting: Both functions foo and bar are at index 10
+  --> tests/pallet_ui/call_conflicting_indices.rs:19:10
+   |
+19 |         pub fn bar(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+   |                ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_index_has_suffix.rs b/substrate/frame/support/test/tests/pallet_ui/call_index_has_suffix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..abe4dc199bf515e08187c192ee95f7afb42e6430
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_index_has_suffix.rs
@@ -0,0 +1,20 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+        #[pallet::call_index(0something)]
+		pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_index_has_suffix.stderr b/substrate/frame/support/test/tests/pallet_ui/call_index_has_suffix.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..2f4cead6cf70c960af51dcd72be7da239522196a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_index_has_suffix.stderr
@@ -0,0 +1,5 @@
+error: Number literal must not have a suffix
+  --> tests/pallet_ui/call_index_has_suffix.rs:14:30
+   |
+14 |         #[pallet::call_index(0something)]
+   |                              ^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_attr.rs b/substrate/frame/support/test/tests/pallet_ui/call_invalid_attr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..118d3c92f360d65d8f2c79171b3d04047ac23ba2
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_attr.rs
@@ -0,0 +1,20 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weird_attr]
+		pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_attr.stderr b/substrate/frame/support/test/tests/pallet_ui/call_invalid_attr.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..3f680203a262f73e6803316622c5a104a312b6df
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_attr.stderr
@@ -0,0 +1,5 @@
+error: expected `weight` or `call_index`
+  --> tests/pallet_ui/call_invalid_attr.rs:14:13
+   |
+14 |         #[pallet::weird_attr]
+   |                   ^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_const.rs b/substrate/frame/support/test/tests/pallet_ui/call_invalid_const.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1a28bc32e65c6eee61fe071561bd9ca9f180c3b5
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_const.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		const Foo: u8 = 3u8;
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_const.stderr b/substrate/frame/support/test/tests/pallet_ui/call_invalid_const.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0acb3e864a51209be716cb573af0cad9e1fceacb
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_const.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::call, only method accepted
+  --> $DIR/call_invalid_const.rs:17:3
+   |
+17 |         const Foo: u8 = 3u8;
+   |         ^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_index.rs b/substrate/frame/support/test/tests/pallet_ui/call_invalid_index.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0b40691ca43a37905c8ed660d70f91f133a7feec
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_index.rs
@@ -0,0 +1,21 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		#[pallet::call_index(256)]
+		pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_index.stderr b/substrate/frame/support/test/tests/pallet_ui/call_invalid_index.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1e07a4974bf695eff67167adae5e22307719078a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_index.stderr
@@ -0,0 +1,5 @@
+error: number too large to fit in target type
+  --> tests/pallet_ui/call_invalid_index.rs:15:24
+   |
+15 |         #[pallet::call_index(256)]
+   |                              ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_origin_type.rs b/substrate/frame/support/test/tests/pallet_ui/call_invalid_origin_type.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2502506fa6aa4a72a44376784f44c1c1fe1fada2
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_origin_type.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn foo(origin: u8) {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_origin_type.stderr b/substrate/frame/support/test/tests/pallet_ui/call_invalid_origin_type.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f17cd9016a6e4b200b2a6fc767e451d5667676f1
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_origin_type.stderr
@@ -0,0 +1,11 @@
+error: Invalid type: expected `OriginFor<T>`
+  --> $DIR/call_invalid_origin_type.rs:17:22
+   |
+17 |         pub fn foo(origin: u8) {}
+   |                            ^^
+
+error: expected `OriginFor`
+  --> $DIR/call_invalid_origin_type.rs:17:22
+   |
+17 |         pub fn foo(origin: u8) {}
+   |                            ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_return.rs b/substrate/frame/support/test/tests/pallet_ui/call_invalid_return.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ccdff5d07374d936f426731ab8dc546aa854765
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_return.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn foo(origin: OriginFor<T>) -> ::DispatchResult { todo!() }
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_return.stderr b/substrate/frame/support/test/tests/pallet_ui/call_invalid_return.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..8803bbba01326b6b33c19eb1fab9fad561ff559b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_return.stderr
@@ -0,0 +1,5 @@
+error: expected `DispatchResultWithPostInfo` or `DispatchResult`
+  --> tests/pallet_ui/call_invalid_return.rs:17:39
+   |
+17 |         pub fn foo(origin: OriginFor<T>) -> ::DispatchResult { todo!() }
+   |                                             ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis.rs b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe1c5aee453d4474104dcd6a83ff24453c6a9bf6
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis.rs
@@ -0,0 +1,27 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, DispatchResultWithPostInfo};
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar: codec::Codec;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			Ok(().into())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis.stderr b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..321828a1ae28ef1645b4fdc2553cc01e900b83b0
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::call, dispatchable function must be public: `pub fn`
+  --> $DIR/call_invalid_vis.rs:20:3
+   |
+20 |         fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+   |         ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis_2.rs b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis_2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fb25e9876dc8d89c799933fa583c7f8860be4d16
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis_2.rs
@@ -0,0 +1,27 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, DispatchResultWithPostInfo};
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar: codec::Codec;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		pub(crate) fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+			Ok(().into())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis_2.stderr b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis_2.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..7d3113474af73db528c63ef3801d7438fe5f07c1
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_invalid_vis_2.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::call, dispatchable function must be public: `pub fn`
+  --> $DIR/call_invalid_vis_2.rs:20:3
+   |
+20 |         pub(crate) fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
+   |         ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_missing_index.rs b/substrate/frame/support/test/tests/pallet_ui/call_missing_index.rs
new file mode 100644
index 0000000000000000000000000000000000000000..98c49f493e50d33dc6ff8d96af6da80761070491
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_missing_index.rs
@@ -0,0 +1,27 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResult;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+
+		#[pallet::weight(0)]
+		pub fn bar(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_missing_index.stderr b/substrate/frame/support/test/tests/pallet_ui/call_missing_index.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..82dbe1d24c28e78aa62d3166418ed92aaf823b89
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_missing_index.stderr
@@ -0,0 +1,47 @@
+error: use of deprecated constant `pallet::warnings::ImplicitCallIndex_0::_w`:
+               It is deprecated to use implicit call indices.
+               Please instead ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/12891>
+                   <https://github.com/paritytech/substrate/pull/11381>
+  --> tests/pallet_ui/call_missing_index.rs:15:10
+   |
+15 |         pub fn foo(_: OriginFor<T>) -> DispatchResult {
+   |                ^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error: use of deprecated constant `pallet::warnings::ImplicitCallIndex_1::_w`:
+               It is deprecated to use implicit call indices.
+               Please instead ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/12891>
+                   <https://github.com/paritytech/substrate/pull/11381>
+  --> tests/pallet_ui/call_missing_index.rs:20:10
+   |
+20 |         pub fn bar(_: OriginFor<T>) -> DispatchResult {
+   |                ^^^
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_missing_index.rs:14:20
+   |
+14 |         #[pallet::weight(0)]
+   |                          ^
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_1::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_missing_index.rs:19:20
+   |
+19 |         #[pallet::weight(0)]
+   |                          ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_missing_weight.rs b/substrate/frame/support/test/tests/pallet_ui/call_missing_weight.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4cdb85502b57fbe9fd0fedb8794218ab059cda7b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_missing_weight.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, DispatchResultWithPostInfo};
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_missing_weight.stderr b/substrate/frame/support/test/tests/pallet_ui/call_missing_weight.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0a6cf16571f95cc92956f6682130e22b61e4e01c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_missing_weight.stderr
@@ -0,0 +1,7 @@
+error: A pallet::call requires either a concrete `#[pallet::weight($expr)]` or an
+                               inherited weight from the `#[pallet:call(weight($type))]` attribute, but
+                               none were given.
+  --> tests/pallet_ui/call_missing_weight.rs:17:7
+   |
+17 |         pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+   |             ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_multiple_call_index.rs b/substrate/frame/support/test/tests/pallet_ui/call_multiple_call_index.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5753ecd076c807875c500268877967fa144fca6f
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_multiple_call_index.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		#[pallet::call_index(1)]
+		#[pallet::call_index(2)]
+		pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_multiple_call_index.stderr b/substrate/frame/support/test/tests/pallet_ui/call_multiple_call_index.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..ba22b012745c19d82542d339007c4680dfd3cdc3
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_multiple_call_index.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::call, too many call_index attributes given
+  --> tests/pallet_ui/call_multiple_call_index.rs:17:7
+   |
+17 |         pub fn foo(origin: OriginFor<T>) -> DispatchResultWithPostInfo {}
+   |             ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_no_origin.rs b/substrate/frame/support/test/tests/pallet_ui/call_no_origin.rs
new file mode 100644
index 0000000000000000000000000000000000000000..231c75f43f4ad8b4fccce287273b02a4098369d9
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_no_origin.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn foo() {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_no_origin.stderr b/substrate/frame/support/test/tests/pallet_ui/call_no_origin.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..97574ea1b644c0fe017d25eddd8a96f230492b27
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_no_origin.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::call, must have at least origin arg
+  --> $DIR/call_no_origin.rs:17:7
+   |
+17 |         pub fn foo() {}
+   |             ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_no_return.rs b/substrate/frame/support/test/tests/pallet_ui/call_no_return.rs
new file mode 100644
index 0000000000000000000000000000000000000000..68a883c52c0722204b8c7da046a7b9e2a0a3a2d4
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_no_return.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::{BlockNumberFor, OriginFor};
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn foo(origin: OriginFor<T>) {}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_no_return.stderr b/substrate/frame/support/test/tests/pallet_ui/call_no_return.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..18ebbaff76d9d6044cffe0accabe5d637379d4c8
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_no_return.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::call, require return type DispatchResultWithPostInfo
+  --> $DIR/call_no_return.rs:17:7
+   |
+17 |         pub fn foo(origin: OriginFor<T>) {}
+   |             ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c122877e8a0757d0244e0ed71f5899032469379a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.rs
@@ -0,0 +1,21 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResult;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+        #[pallet::weight(10_000something)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult { Ok(()) }
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0651f003b9e23f7dccb7d7959ef64b4056f8ca7c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_argument_has_suffix.stderr
@@ -0,0 +1,20 @@
+error: invalid suffix `something` for number literal
+  --> tests/pallet_ui/call_weight_argument_has_suffix.rs:15:26
+   |
+15 |         #[pallet::weight(10_000something)]
+   |                          ^^^^^^^^^^^^^^^ invalid suffix `something`
+   |
+   = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_argument_has_suffix.rs:15:26
+   |
+15 |         #[pallet::weight(10_000something)]
+   |                          ^^^^^^^^^^^^^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2e5dc2a649e709f148adfce1ff2d0c3212176cc7
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning.rs
@@ -0,0 +1,21 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResult;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+        #[pallet::weight(123_u64)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult { Ok(()) }
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b04c3ec395ce67ab5d6616d8f9acc0756fd65faa
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning.stderr
@@ -0,0 +1,12 @@
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_const_warning.rs:15:26
+   |
+15 |         #[pallet::weight(123_u64)]
+   |                          ^^^^^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.rs
new file mode 100644
index 0000000000000000000000000000000000000000..798911dba33d9d466f80ea55131e17131580e2e0
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.rs
@@ -0,0 +1,25 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::DispatchResult;
+	use frame_system::pallet_prelude::OriginFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+        #[pallet::weight(123)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult { Ok(()) }
+
+		#[pallet::call_index(1)]
+        #[pallet::weight(123_custom_prefix)]
+		pub fn bar(_: OriginFor<T>) -> DispatchResult { Ok(()) }
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c656790207504df0144187a7d00daa23dc6d867e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_const_warning_twice.stderr
@@ -0,0 +1,31 @@
+error: invalid suffix `custom_prefix` for number literal
+  --> tests/pallet_ui/call_weight_const_warning_twice.rs:19:26
+   |
+19 |         #[pallet::weight(123_custom_prefix)]
+   |                          ^^^^^^^^^^^^^^^^^ invalid suffix `custom_prefix`
+   |
+   = help: the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_const_warning_twice.rs:15:26
+   |
+15 |         #[pallet::weight(123)]
+   |                          ^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_1::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/call_weight_const_warning_twice.rs:19:26
+   |
+19 |         #[pallet::weight(123_custom_prefix)]
+   |                          ^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ff235e986099f4f91c3e7a029686c8bdf6fda125
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid.rs
@@ -0,0 +1,50 @@
+use frame_support::pallet_prelude::*;
+
+pub trait WeightInfo {
+	fn foo() -> Weight;
+}
+
+#[frame_support::pallet]
+mod pallet {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(invalid)]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call = invalid]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..7eed646e7b1909ecbddaab8f84bcfe899504e048
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid.stderr
@@ -0,0 +1,11 @@
+error: expected `weight`
+  --> tests/pallet_ui/call_weight_inherited_invalid.rs:19:17
+   |
+19 |     #[pallet::call(invalid)]
+   |                    ^^^^^^^
+
+error: expected parentheses
+  --> tests/pallet_ui/call_weight_inherited_invalid.rs:40:17
+   |
+40 |     #[pallet::call = invalid]
+   |                    ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid2.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76ccf5db220194ff9c27ea38ea1a287162c9b950
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid2.rs
@@ -0,0 +1,53 @@
+// Weight is an ident instead of a type.
+
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+pub trait WeightInfo {
+	fn foo() -> Weight;
+}
+
+#[frame_support::pallet]
+mod parentheses {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight(prefix))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight = prefix)]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid2.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid2.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..29f3b6bfd2b0dd942b04f662b45c9a282ffb9616
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid2.stderr
@@ -0,0 +1,11 @@
+error[E0412]: cannot find type `prefix` in this scope
+  --> tests/pallet_ui/call_weight_inherited_invalid2.rs:22:24
+   |
+22 |     #[pallet::call(weight(prefix))]
+   |                           ^^^^^^ not found in this scope
+
+error[E0412]: cannot find type `prefix` in this scope
+  --> tests/pallet_ui/call_weight_inherited_invalid2.rs:43:26
+   |
+43 |     #[pallet::call(weight = prefix)]
+   |                             ^^^^^^ not found in this scope
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid3.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid3.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b31bc0ae234b27dbfa60fa254d78c353760f7345
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid3.rs
@@ -0,0 +1,53 @@
+// Call weight is an LitInt instead of a type.
+
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+pub trait WeightInfo {
+	fn foo() -> Weight;
+}
+
+#[frame_support::pallet]
+mod parentheses {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight(123))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight = 123)]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid3.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid3.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..fab7acb90deafde9a61d7192efae3bcdfeeac597
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid3.stderr
@@ -0,0 +1,19 @@
+error: expected one of: `for`, parentheses, `fn`, `unsafe`, `extern`, identifier, `::`, `<`, `dyn`, square brackets, `*`, `&`, `!`, `impl`, `_`, lifetime
+  --> tests/pallet_ui/call_weight_inherited_invalid3.rs:22:24
+   |
+22 |     #[pallet::call(weight(123))]
+   |                           ^^^
+
+error: expected one of: `for`, parentheses, `fn`, `unsafe`, `extern`, identifier, `::`, `<`, `dyn`, square brackets, `*`, `&`, `!`, `impl`, `_`, lifetime
+  --> tests/pallet_ui/call_weight_inherited_invalid3.rs:43:26
+   |
+43 |     #[pallet::call(weight = 123)]
+   |                             ^^^
+
+error: unused import: `frame_system::pallet_prelude::*`
+ --> tests/pallet_ui/call_weight_inherited_invalid3.rs:4:5
+  |
+4 | use frame_system::pallet_prelude::*;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: `-D unused-imports` implied by `-D warnings`
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid4.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..39c0929d603ad1f362243c4ededcb6af00bc31ca
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid4.rs
@@ -0,0 +1,52 @@
+// Function does not exist in the trait.
+
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+pub trait WeightInfo {
+}
+
+#[frame_support::pallet]
+mod parentheses {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight(<T as Config>::WeightInfo))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight = <T as Config>::WeightInfo)]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid4.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid4.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..fbde5c691c5a08c50a9a5a83b34e1107fc9a2f54
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid4.stderr
@@ -0,0 +1,11 @@
+error[E0599]: no function or associated item named `foo` found for associated type `<T as parentheses::Config>::WeightInfo` in the current scope
+  --> tests/pallet_ui/call_weight_inherited_invalid4.rs:24:10
+   |
+24 |         pub fn foo(_: OriginFor<T>) -> DispatchResult {
+   |                ^^^ function or associated item not found in `<T as Config>::WeightInfo`
+
+error[E0599]: no function or associated item named `foo` found for associated type `<T as assign::Config>::WeightInfo` in the current scope
+  --> tests/pallet_ui/call_weight_inherited_invalid4.rs:45:10
+   |
+45 |         pub fn foo(_: OriginFor<T>) -> DispatchResult {
+   |                ^^^ function or associated item not found in `<T as Config>::WeightInfo`
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid5.rs b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid5.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a5b2f5c7f6aa6ad32b5ab872cdcbe3004983f848
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid5.rs
@@ -0,0 +1,44 @@
+// Stray tokens after good input.
+
+#[frame_support::pallet]
+mod parentheses {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight(<T as Config>::WeightInfo straycat))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+	
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight = <T as Config>::WeightInfo straycat)]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid5.stderr b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid5.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c0e9ef2d9e9d82dc4d7889fc8d27a85ee4c9cddd
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/call_weight_inherited_invalid5.stderr
@@ -0,0 +1,11 @@
+error: unexpected token
+  --> tests/pallet_ui/call_weight_inherited_invalid5.rs:14:50
+   |
+14 |     #[pallet::call(weight(<T as Config>::WeightInfo straycat))]
+   |                                                     ^^^^^^^^
+
+error: unexpected token
+  --> tests/pallet_ui/call_weight_inherited_invalid5.rs:34:52
+   |
+34 |     #[pallet::call(weight = <T as Config>::WeightInfo straycat)]
+   |                                                       ^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/compare_unset_storage_version.rs b/substrate/frame/support/test/tests/pallet_ui/compare_unset_storage_version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e417c619fc45f3c623668bb15766c5ba49d0e3df
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/compare_unset_storage_version.rs
@@ -0,0 +1,27 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_runtime_upgrade() -> Weight {
+			if Self::current_storage_version() != Self::on_chain_storage_version() {
+
+			}
+
+			Default::default()
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/compare_unset_storage_version.stderr b/substrate/frame/support/test/tests/pallet_ui/compare_unset_storage_version.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e75aa5226153886f2e8b7c91f05b430fa9c8c5ff
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/compare_unset_storage_version.stderr
@@ -0,0 +1,7 @@
+error[E0369]: binary operation `!=` cannot be applied to type `NoStorageVersionSet`
+  --> tests/pallet_ui/compare_unset_storage_version.rs:15:39
+   |
+15 |             if Self::current_storage_version() != Self::on_chain_storage_version() {
+   |                ------------------------------- ^^ -------------------------------- StorageVersion
+   |                |
+   |                NoStorageVersionSet
diff --git a/substrate/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.rs b/substrate/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74692ee94efd24d7662ad9020493dd1ded50b913
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.rs
@@ -0,0 +1,13 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+	pub enum HoldReasons {}
+}
+
+fn main() {}
\ No newline at end of file
diff --git a/substrate/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.stderr b/substrate/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..902e8923759b2226d296272b81c559eaccfa41c6
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/composite_enum_unsupported_identifier.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `FreezeReason`, `HoldReason`, `LockId`, `SlashReason`
+  --> tests/pallet_ui/composite_enum_unsupported_identifier.rs:10:11
+   |
+10 |     pub enum HoldReasons {}
+   |              ^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/default_config_with_no_default_in_system.rs b/substrate/frame/support/test/tests/pallet_ui/default_config_with_no_default_in_system.rs
new file mode 100644
index 0000000000000000000000000000000000000000..026b74c914a136cb73466d5b5926307ce1d3c8d0
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/default_config_with_no_default_in_system.rs
@@ -0,0 +1,15 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config(with_default)]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		type MyGetParam2: Get<Self::Block>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/default_config_with_no_default_in_system.stderr b/substrate/frame/support/test/tests/pallet_ui/default_config_with_no_default_in_system.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..17d818113567439a60ed7db1167c6ff9c954d5f9
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/default_config_with_no_default_in_system.stderr
@@ -0,0 +1,5 @@
+error[E0220]: associated type `Block` not found for `Self`
+ --> tests/pallet_ui/default_config_with_no_default_in_system.rs:8:31
+  |
+8 |         type MyGetParam2: Get<Self::Block>;
+  |                                     ^^^^^ there is a similarly named associated type `Block` in the trait `frame_system::Config`
diff --git a/substrate/frame/support/test/tests/pallet_ui/deprecated_store_attr.rs b/substrate/frame/support/test/tests/pallet_ui/deprecated_store_attr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0799a3fce8d58bc5beeb1ba8020204d239eccb2a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/deprecated_store_attr.rs
@@ -0,0 +1,11 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(trait Store)]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/deprecated_store_attr.stderr b/substrate/frame/support/test/tests/pallet_ui/deprecated_store_attr.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5d2734b4db601f4e1bf3035536e766ba33f283ef
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/deprecated_store_attr.stderr
@@ -0,0 +1,9 @@
+error: use of deprecated struct `pallet::_::Store`:
+               Use of `#[pallet::generate_store(pub(super) trait Store)]` will be removed after July 2023.
+               Check https://github.com/paritytech/substrate/pull/13535 for more details.
+ --> tests/pallet_ui/deprecated_store_attr.rs:7:3
+  |
+7 |     #[pallet::generate_store(trait Store)]
+  |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: `-D deprecated` implied by `-D warnings`
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg.rs b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a413eea9b4aac70f299bac1c853dd43900abdb9
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg.rs
@@ -0,0 +1,31 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	// The struct on which we build all of our Pallet logic.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	// Your Pallet's configuration trait, representing custom external types and interfaces.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::storage]
+	type MyStorage<T: Config> = StorageValue<_, Vec<u8>>;
+
+	// Your Pallet's callable functions.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+
+	// Your Pallet's internal functions.
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg.stderr b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1e2011b2a30cfce1d33689c9206d7cbdffb6fe40
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg.stderr
@@ -0,0 +1,7 @@
+error: A pallet::call requires either a concrete `#[pallet::weight($expr)]` or an
+                               inherited weight from the `#[pallet:call(weight($type))]` attribute, but
+                               none were given.
+  --> tests/pallet_ui/dev_mode_without_arg.rs:22:7
+   |
+22 |         pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+   |             ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_call_index.rs b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_call_index.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1920b6799de25f9f5e8a9fb7cb19d8ae1a38738c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_call_index.rs
@@ -0,0 +1,31 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::OriginFor;
+
+	// The struct on which we build all of our Pallet logic.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	// Your Pallet's configuration trait, representing custom external types and interfaces.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	// Your Pallet's callable functions.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+
+	// Your Pallet's internal functions.
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_call_index.stderr b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_call_index.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b75edff1ab5f3b1e633e7472445f19d678b70f8e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_call_index.stderr
@@ -0,0 +1,24 @@
+error: use of deprecated constant `pallet::warnings::ImplicitCallIndex_0::_w`:
+               It is deprecated to use implicit call indices.
+               Please instead ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/12891>
+                   <https://github.com/paritytech/substrate/pull/11381>
+  --> tests/pallet_ui/dev_mode_without_arg_call_index.rs:22:10
+   |
+22 |         pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+   |                ^^^^^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/dev_mode_without_arg_call_index.rs:21:20
+   |
+21 |         #[pallet::weight(0)]
+   |                          ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_default_hasher.rs b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_default_hasher.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fb1139479566affb94bb2ddf6d326f20cf269238
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_default_hasher.rs
@@ -0,0 +1,33 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	// The struct on which we build all of our Pallet logic.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	// Your Pallet's configuration trait, representing custom external types and interfaces.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::storage]
+	type MyStorage<T: Config> = StorageValue<_, Vec<u8>>;
+
+	#[pallet::storage]
+	type MyStorageMap<T: Config> = StorageMap<_, _, u32, u64>;
+
+	#[pallet::storage]
+	type MyStorageDoubleMap<T: Config> = StorageDoubleMap<_, _, u32, _, u64, u64>;
+
+	#[pallet::storage]
+	type MyCountedStorageMap<T: Config> = CountedStorageMap<_, _, u32, u64>;
+
+	// Your Pallet's internal functions.
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_default_hasher.stderr b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_default_hasher.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e0dbc8c953b4e9054371eddfb4871f6b77daa240
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_default_hasher.stderr
@@ -0,0 +1,11 @@
+error: `_` can only be used in dev_mode. Please specify an appropriate hasher.
+  --> tests/pallet_ui/dev_mode_without_arg_default_hasher.rs:21:47
+   |
+21 |     type MyStorageMap<T: Config> = StorageMap<_, _, u32, u64>;
+   |                                                  ^
+
+error[E0432]: unresolved import `pallet`
+ --> tests/pallet_ui/dev_mode_without_arg_default_hasher.rs:3:9
+  |
+3 | pub use pallet::*;
+  |         ^^^^^^ help: a similar path exists: `test_pallet::pallet`
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f6efcc3fc3d7240a48857c3b046bfe582dc56571
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs
@@ -0,0 +1,34 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	// The struct on which we build all of our Pallet logic.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	// Your Pallet's configuration trait, representing custom external types and interfaces.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::storage]
+	type MyStorage<T: Config> = StorageValue<_, Vec<u8>>;
+
+	// Your Pallet's callable functions.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+
+	// Your Pallet's internal functions.
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.stderr b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..cf502ac5be475e31f3ea1184138d0af5b93da678
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/dev_mode_without_arg_max_encoded_len.stderr
@@ -0,0 +1,42 @@
+error: use of deprecated constant `pallet::warnings::ImplicitCallIndex_0::_w`:
+               It is deprecated to use implicit call indices.
+               Please instead ensure that all calls have a `pallet::call_index` attribute or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/12891>
+                   <https://github.com/paritytech/substrate/pull/11381>
+  --> tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs:25:10
+   |
+25 |         pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+   |                ^^^^^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error: use of deprecated constant `pallet::warnings::ConstantWeight_0::_w`:
+               It is deprecated to use hard-coded constant as call weight.
+               Please instead benchmark all calls or put the pallet into `dev` mode.
+
+               For more info see:
+                   <https://github.com/paritytech/substrate/pull/13798>
+  --> tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs:24:20
+   |
+24 |         #[pallet::weight(0)]
+   |                          ^
+
+error[E0277]: the trait bound `Vec<u8>: MaxEncodedLen` is not satisfied
+  --> tests/pallet_ui/dev_mode_without_arg_max_encoded_len.rs:11:12
+   |
+11 |     #[pallet::pallet]
+   |               ^^^^^^ the trait `MaxEncodedLen` is not implemented for `Vec<u8>`
+   |
+   = help: the following other types implement trait `MaxEncodedLen`:
+             ()
+             (TupleElement0, TupleElement1)
+             (TupleElement0, TupleElement1, TupleElement2)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6, TupleElement7)
+           and $N others
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageMyStorage<T>, Vec<u8>>` to implement `StorageInfoTrait`
diff --git a/substrate/frame/support/test/tests/pallet_ui/duplicate_call_attr.rs b/substrate/frame/support/test/tests/pallet_ui/duplicate_call_attr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6d781a19e6742cdc814353f9467afa257177ad83
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/duplicate_call_attr.rs
@@ -0,0 +1,27 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+	use frame_support::pallet_prelude::StorageValue;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<_, u8>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/duplicate_call_attr.stderr b/substrate/frame/support/test/tests/pallet_ui/duplicate_call_attr.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..2b03f410243511a37764220493f7281dfae2ccb3
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/duplicate_call_attr.stderr
@@ -0,0 +1,5 @@
+error: Invalid duplicated attribute
+  --> $DIR/duplicate_call_attr.rs:22:12
+   |
+22 |     #[pallet::call]
+   |               ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/duplicate_storage_prefix.rs b/substrate/frame/support/test/tests/pallet_ui/duplicate_storage_prefix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..543c15bd06905fc40f427410413b5b5e815846ee
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/duplicate_storage_prefix.rs
@@ -0,0 +1,26 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<_, u8>;
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "Foo"]
+	type NotFoo<T> = StorageValue<_, u16>;
+
+	#[pallet::storage]
+	type CounterForBar<T> = StorageValue<_, u16>;
+
+	#[pallet::storage]
+	type Bar<T> = CountedStorageMap<_, Twox64Concat, u16, u16>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/duplicate_storage_prefix.stderr b/substrate/frame/support/test/tests/pallet_ui/duplicate_storage_prefix.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..75297dc5a7f79f36a7d897fdb2743c47023dec4b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/duplicate_storage_prefix.stderr
@@ -0,0 +1,47 @@
+error: Duplicate storage prefixes found for `Foo`
+  --> $DIR/duplicate_storage_prefix.rs:15:29
+   |
+15 |     #[pallet::storage_prefix = "Foo"]
+   |                                ^^^^^
+
+error: Duplicate storage prefixes found for `Foo`
+  --> $DIR/duplicate_storage_prefix.rs:12:7
+   |
+12 |     type Foo<T> = StorageValue<_, u8>;
+   |          ^^^
+
+error: Duplicate storage prefixes found for `CounterForBar`, used for counter associated to counted storage map
+  --> $DIR/duplicate_storage_prefix.rs:22:7
+   |
+22 |     type Bar<T> = CountedStorageMap<_, Twox64Concat, u16, u16>;
+   |          ^^^
+
+error: Duplicate storage prefixes found for `CounterForBar`
+  --> $DIR/duplicate_storage_prefix.rs:19:7
+   |
+19 |     type CounterForBar<T> = StorageValue<_, u16>;
+   |          ^^^^^^^^^^^^^
+
+error[E0412]: cannot find type `_GeneratedPrefixForStorageFoo` in this scope
+  --> $DIR/duplicate_storage_prefix.rs:12:7
+   |
+12 |     type Foo<T> = StorageValue<_, u8>;
+   |          ^^^ not found in this scope
+
+error[E0412]: cannot find type `_GeneratedPrefixForStorageNotFoo` in this scope
+  --> $DIR/duplicate_storage_prefix.rs:16:7
+   |
+16 |     type NotFoo<T> = StorageValue<_, u16>;
+   |          ^^^^^^ not found in this scope
+
+error[E0412]: cannot find type `_GeneratedPrefixForStorageCounterForBar` in this scope
+  --> $DIR/duplicate_storage_prefix.rs:19:7
+   |
+19 |     type CounterForBar<T> = StorageValue<_, u16>;
+   |          ^^^^^^^^^^^^^ not found in this scope
+
+error[E0412]: cannot find type `_GeneratedPrefixForStorageBar` in this scope
+  --> $DIR/duplicate_storage_prefix.rs:22:7
+   |
+22 |     type Bar<T> = CountedStorageMap<_, Twox64Concat, u16, u16>;
+   |          ^^^ not found in this scope
diff --git a/substrate/frame/support/test/tests/pallet_ui/duplicate_store_attr.rs b/substrate/frame/support/test/tests/pallet_ui/duplicate_store_attr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ab318034aca054564964cfcd3356719bbe8142f0
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/duplicate_store_attr.rs
@@ -0,0 +1,25 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+	use frame_support::pallet_prelude::StorageValue;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(trait Store)]
+	#[pallet::generate_store(trait Store)]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<_, u8>;
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/duplicate_store_attr.stderr b/substrate/frame/support/test/tests/pallet_ui/duplicate_store_attr.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1c13ee17eb75105701f330e0dd4c8ce0685abfe7
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/duplicate_store_attr.stderr
@@ -0,0 +1,5 @@
+error: Unexpected duplicated attribute
+  --> tests/pallet_ui/duplicate_store_attr.rs:12:3
+   |
+12 |     #[pallet::generate_store(trait Store)]
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_does_not_derive_pallet_error.rs b/substrate/frame/support/test/tests/pallet_ui/error_does_not_derive_pallet_error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..254d65866774fee7efba978b2479d7f1bc9b4621
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_does_not_derive_pallet_error.rs
@@ -0,0 +1,19 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::error]
+	pub enum Error<T> {
+		CustomError(crate::MyError),
+	}
+}
+
+#[derive(scale_info::TypeInfo, codec::Encode, codec::Decode)]
+enum MyError {}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_does_not_derive_pallet_error.stderr b/substrate/frame/support/test/tests/pallet_ui/error_does_not_derive_pallet_error.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..7edb55a62d401a3c43dd3d589482ae9f1c94122d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_does_not_derive_pallet_error.stderr
@@ -0,0 +1,17 @@
+error[E0277]: the trait bound `MyError: PalletError` is not satisfied
+ --> tests/pallet_ui/error_does_not_derive_pallet_error.rs:1:1
+  |
+1 | #[frame_support::pallet]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `PalletError` is not implemented for `MyError`
+  |
+  = help: the following other types implement trait `PalletError`:
+            ()
+            (TupleElement0, TupleElement1)
+            (TupleElement0, TupleElement1, TupleElement2)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6, TupleElement7)
+          and 36 others
+  = note: this error originates in the derive macro `frame_support::PalletError` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_where_clause.rs b/substrate/frame/support/test/tests/pallet_ui/error_where_clause.rs
new file mode 100644
index 0000000000000000000000000000000000000000..29d7435bc4bc850b8642c2912f79b1997d42c81c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_where_clause.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::error]
+	pub enum Error<T> where u32: From<u8> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_where_clause.stderr b/substrate/frame/support/test/tests/pallet_ui/error_where_clause.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..8e9d0e60692d8af48d8b9fbc8c7403428c4e7ca5
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_where_clause.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::error, where clause is not allowed on pallet error item
+  --> $DIR/error_where_clause.rs:19:20
+   |
+19 |     pub enum Error<T> where u32: From<u8> {}
+   |                       ^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_wrong_item.rs b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..50e66dc8c0dce0bb0da8137f2652855540820f9f
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::error]
+	pub struct Foo;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_wrong_item.stderr b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..8c0496782fb168e7392aac73ae49b0ef3c5a2e66
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::error, expected item enum
+  --> $DIR/error_wrong_item.rs:19:2
+   |
+19 |     pub struct Foo;
+   |     ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_wrong_item_name.rs b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..14107fafb06eaf6591218c33c367b701d99e468a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item_name.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::error]
+	pub enum Foo<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/error_wrong_item_name.stderr b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d7e54ad8a75163097bd9253456544788ef2525a3
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/error_wrong_item_name.stderr
@@ -0,0 +1,5 @@
+error: expected `Error`
+  --> $DIR/error_wrong_item_name.rs:19:11
+   |
+19 |     pub enum Foo<T> {}
+   |              ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_field_not_member.rs b/substrate/frame/support/test/tests/pallet_ui/event_field_not_member.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2b45a971788fb9b6b5ed11e5b184527b59729f93
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_field_not_member.rs
@@ -0,0 +1,28 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, IsType};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar;
+		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent> + From<Event<Self>>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::event]
+	pub enum Event<T: Config> {
+		B { b: T::Bar },
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_field_not_member.stderr b/substrate/frame/support/test/tests/pallet_ui/event_field_not_member.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1161f4a190231eb17eb23db90e9d76e09b0f867c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_field_not_member.stderr
@@ -0,0 +1,21 @@
+error[E0277]: the trait bound `<T as pallet::Config>::Bar: Clone` is not satisfied
+  --> tests/pallet_ui/event_field_not_member.rs:23:7
+   |
+23 |         B { b: T::Bar },
+   |             ^ the trait `Clone` is not implemented for `<T as pallet::Config>::Bar`
+
+error[E0369]: binary operation `==` cannot be applied to type `&<T as pallet::Config>::Bar`
+  --> tests/pallet_ui/event_field_not_member.rs:23:7
+   |
+23 |         B { b: T::Bar },
+   |             ^
+
+error[E0277]: `<T as pallet::Config>::Bar` doesn't implement `std::fmt::Debug`
+  --> tests/pallet_ui/event_field_not_member.rs:23:7
+   |
+23 |         B { b: T::Bar },
+   |             ^ `<T as pallet::Config>::Bar` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`
+   |
+   = help: the trait `std::fmt::Debug` is not implemented for `<T as pallet::Config>::Bar`
+   = note: required for `&<T as pallet::Config>::Bar` to implement `std::fmt::Debug`
+   = note: required for the cast from `&<T as pallet::Config>::Bar` to the object type `dyn std::fmt::Debug`
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_not_in_trait.rs b/substrate/frame/support/test/tests/pallet_ui/event_not_in_trait.rs
new file mode 100644
index 0000000000000000000000000000000000000000..94151ba4c3d9d7efbc901eec9d7a5f84c058ee81
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_not_in_trait.rs
@@ -0,0 +1,27 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::event]
+	pub enum Event<T: Config> {
+		B { b: T::Bar },
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_not_in_trait.stderr b/substrate/frame/support/test/tests/pallet_ui/event_not_in_trait.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..2eda72eb5f72f86851af25ee2c26251a93e4ec77
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_not_in_trait.stderr
@@ -0,0 +1,7 @@
+error: Invalid usage of RuntimeEvent, `Config` contains no associated type `RuntimeEvent`, but enum `Event` is declared (in use of `#[pallet::event]`). An RuntimeEvent associated type must be declare on trait `Config`.
+ --> $DIR/event_not_in_trait.rs:1:1
+  |
+1 | #[frame_support::pallet]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the attribute macro `frame_support::pallet` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound.rs b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a02cc9b9de883e2204b22a413969e217c4a00d49
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound.rs
@@ -0,0 +1,28 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar;
+		type RuntimeEvent;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::event]
+	pub enum Event<T: Config> {
+		B { b: T::Bar },
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound.stderr b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d54149d719a3bfc8cfa335992faaf2bae6bef8c1
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound.stderr
@@ -0,0 +1,5 @@
+error: Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must bound: `IsType<<Self as frame_system::Config>::RuntimeEvent>`
+ --> $DIR/event_type_invalid_bound.rs:9:3
+  |
+9 |         type RuntimeEvent;
+  |         ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound_2.rs b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound_2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..99df89d67278ce786c094a48404aed3c5a52b2dd
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound_2.rs
@@ -0,0 +1,28 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, IsType};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type Bar;
+		type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::event]
+	pub enum Event<T: Config> {
+		B { b: T::Bar },
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound_2.stderr b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound_2.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..ea8b2ff000cebf66408e06de26d48126dfc804a1
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_type_invalid_bound_2.stderr
@@ -0,0 +1,5 @@
+error: Invalid `type RuntimeEvent`, associated type `RuntimeEvent` is reserved and must bound: `From<Event>` or `From<Event<Self>>` or `From<Event<Self, I>>`
+ --> $DIR/event_type_invalid_bound_2.rs:9:3
+  |
+9 |         type RuntimeEvent: IsType<<Self as frame_system::Config>::RuntimeEvent>;
+  |         ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_wrong_item.rs b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d6690557c39d85445f8f93d2f2b0cf7094015c84
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::event]
+	pub struct Foo;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_wrong_item.stderr b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0ef150dfd62e1a3a7ba40b44d3829c99cf09eb0f
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::event, expected enum item
+  --> $DIR/event_wrong_item.rs:19:2
+   |
+19 |     pub struct Foo;
+   |     ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_wrong_item_name.rs b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d828965c5173c548c9bee3b0e6d36225241c7135
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item_name.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::event]
+	pub enum Foo {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/event_wrong_item_name.stderr b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..14e8615c5619950efd4807a9fa589ba110cb978a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/event_wrong_item_name.stderr
@@ -0,0 +1,5 @@
+error: expected `Event`
+  --> $DIR/event_wrong_item_name.rs:19:11
+   |
+19 |     pub enum Foo {}
+   |              ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_default_not_satisfied.rs b/substrate/frame/support/test/tests/pallet_ui/genesis_default_not_satisfied.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a4a0eb832c9c0a8de91a76682dbbb54dcd1e4e1e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_default_not_satisfied.rs
@@ -0,0 +1,26 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{BuildGenesisConfig, Hooks};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig;
+
+	#[pallet::genesis_build]
+	impl BuildGenesisConfig for GenesisConfig {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_default_not_satisfied.stderr b/substrate/frame/support/test/tests/pallet_ui/genesis_default_not_satisfied.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..7245333c9842e56a77791827cf7ef2e3b70b97b8
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_default_not_satisfied.stderr
@@ -0,0 +1,16 @@
+error[E0277]: the trait bound `pallet::GenesisConfig: std::default::Default` is not satisfied
+  --> tests/pallet_ui/genesis_default_not_satisfied.rs:22:30
+   |
+22 |     impl BuildGenesisConfig for GenesisConfig {}
+   |                                 ^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `pallet::GenesisConfig`
+   |
+note: required by a bound in `BuildGenesisConfig`
+  --> $WORKSPACE/frame/support/src/traits/hooks.rs
+   |
+   | pub trait BuildGenesisConfig: Default + sp_runtime::traits::MaybeSerializeDeserialize {
+   |                               ^^^^^^^ required by this bound in `BuildGenesisConfig`
+help: consider annotating `pallet::GenesisConfig` with `#[derive(Default)]`
+    |
+19  +     #[derive(Default)]
+20  |     pub struct GenesisConfig;
+    |
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_inconsistent_build_config.rs b/substrate/frame/support/test/tests/pallet_ui/genesis_inconsistent_build_config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9ae851005acb3b7cf24846a6c4d455d90f30064e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_inconsistent_build_config.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::genesis_build]
+	impl<T: Config> GenesisBuild<T> for GenesisConfig {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_inconsistent_build_config.stderr b/substrate/frame/support/test/tests/pallet_ui/genesis_inconsistent_build_config.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9afc1037a48ae3c27f4221ac46c4da0952dcbded
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_inconsistent_build_config.stderr
@@ -0,0 +1,5 @@
+error: `#[pallet::genesis_config]` and `#[pallet::genesis_build]` attributes must be either both used or both not used, instead genesis_config is unused and genesis_build is used
+ --> $DIR/genesis_inconsistent_build_config.rs:2:1
+  |
+2 | mod pallet {
+  | ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_invalid_generic.rs b/substrate/frame/support/test/tests/pallet_ui/genesis_invalid_generic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f1eae16f496009a1df92a252b793982972a96d9d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_invalid_generic.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::genesis_build]
+	impl GenesisBuild for GenesisConfig {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_invalid_generic.stderr b/substrate/frame/support/test/tests/pallet_ui/genesis_invalid_generic.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f57b4a61c80c5bb7ddcd8a0f6e25d028d0c2fc18
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_invalid_generic.stderr
@@ -0,0 +1,13 @@
+error: Invalid genesis builder: expected `GenesisBuild<T>` or `GenesisBuild<T, I>`
+  --> $DIR/genesis_invalid_generic.rs:19:7
+   |
+19 |     impl GenesisBuild for GenesisConfig {}
+   |          ^^^^^^^^^^^^
+
+error: expected `<`
+ --> $DIR/genesis_invalid_generic.rs:1:1
+  |
+1 | #[frame_support::pallet]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the attribute macro `frame_support::pallet` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_wrong_name.rs b/substrate/frame/support/test/tests/pallet_ui/genesis_wrong_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5e8b297ba4ccfbd8653181506fbaaf374a6dba55
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_wrong_name.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::genesis_build]
+	impl Foo {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/genesis_wrong_name.stderr b/substrate/frame/support/test/tests/pallet_ui/genesis_wrong_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..dd2e65588f56b62f22322547f3e161a9e97ac8b6
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/genesis_wrong_name.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::genesis_build, expected impl<..> GenesisBuild<..> for GenesisConfig<..>
+  --> $DIR/genesis_wrong_name.rs:19:2
+   |
+19 |     impl Foo {}
+   |     ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/hold_reason_non_enum.rs b/substrate/frame/support/test/tests/pallet_ui/hold_reason_non_enum.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8008c465e61ad0f80192f4c920a2024e28cbb066
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/hold_reason_non_enum.rs
@@ -0,0 +1,14 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+	pub struct HoldReason;
+}
+
+fn main() {
+}
\ No newline at end of file
diff --git a/substrate/frame/support/test/tests/pallet_ui/hold_reason_non_enum.stderr b/substrate/frame/support/test/tests/pallet_ui/hold_reason_non_enum.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..7d86b8d4f1bd52bf283fcd889f6acc5998d65f2e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/hold_reason_non_enum.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::composite_enum, expected enum item
+  --> tests/pallet_ui/hold_reason_non_enum.rs:10:2
+   |
+10 |     pub struct HoldReason;
+   |     ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/hold_reason_not_pub.rs b/substrate/frame/support/test/tests/pallet_ui/hold_reason_not_pub.rs
new file mode 100644
index 0000000000000000000000000000000000000000..626dad74113194f86520f93bcfff1c18d83638e7
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/hold_reason_not_pub.rs
@@ -0,0 +1,14 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+    enum HoldReason {}
+}
+
+fn main() {
+}
\ No newline at end of file
diff --git a/substrate/frame/support/test/tests/pallet_ui/hold_reason_not_pub.stderr b/substrate/frame/support/test/tests/pallet_ui/hold_reason_not_pub.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e8b0c14e967dd1f4b31564dae27e1f5d1c2b4dbc
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/hold_reason_not_pub.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::composite_enum, `HoldReason` must be public
+  --> tests/pallet_ui/hold_reason_not_pub.rs:10:5
+   |
+10 |     enum HoldReason {}
+   |     ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/hooks_invalid_item.rs b/substrate/frame/support/test/tests/pallet_ui/hooks_invalid_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c66b3e6cecc1f45ca75d99afa770e1baaec2e8d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/hooks_invalid_item.rs
@@ -0,0 +1,19 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/hooks_invalid_item.stderr b/substrate/frame/support/test/tests/pallet_ui/hooks_invalid_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9c30179bc11ef2565635002624cf42420a25e548
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/hooks_invalid_item.stderr
@@ -0,0 +1,15 @@
+error[E0107]: missing generics for trait `Hooks`
+  --> tests/pallet_ui/hooks_invalid_item.rs:12:18
+   |
+12 |     impl<T: Config> Hooks for Pallet<T> {}
+   |                     ^^^^^ expected 1 generic argument
+   |
+note: trait defined here, with 1 generic parameter: `BlockNumber`
+  --> $WORKSPACE/frame/support/src/traits/hooks.rs
+   |
+   | pub trait Hooks<BlockNumber> {
+   |           ^^^^^ -----------
+help: add missing generic argument
+    |
+12  |     impl<T: Config> Hooks<BlockNumber> for Pallet<T> {}
+    |                          +++++++++++++
diff --git a/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_1.rs b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_1.rs
new file mode 100644
index 0000000000000000000000000000000000000000..00b57a01235c37a851bb7889afb519d9bb2cbefb
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_1.rs
@@ -0,0 +1,20 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_1.stderr b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_1.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..06c7941a0bcb99ddc7512abce6ebf697b0d1f825
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_1.stderr
@@ -0,0 +1,29 @@
+error: Invalid generic declaration, trait is defined with instance but generic use none
+  --> $DIR/inconsistent_instance_1.rs:10:20
+   |
+10 |     pub struct Pallet<T>(core::marker::PhantomData<T>);
+   |                       ^
+
+error: Invalid generic declaration, trait is defined with instance but generic use none
+  --> $DIR/inconsistent_instance_1.rs:16:7
+   |
+16 |     impl<T: Config> Pallet<T> {}
+   |          ^
+
+error: Invalid generic declaration, trait is defined with instance but generic use none
+  --> $DIR/inconsistent_instance_1.rs:16:18
+   |
+16 |     impl<T: Config> Pallet<T> {}
+   |                     ^^^^^^
+
+error: Invalid generic declaration, trait is defined with instance but generic use none
+  --> $DIR/inconsistent_instance_1.rs:13:47
+   |
+13 |     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+   |                                                  ^^^^^^
+
+error: Invalid generic declaration, trait is defined with instance but generic use none
+  --> $DIR/inconsistent_instance_1.rs:13:7
+   |
+13 |     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+   |          ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_2.rs b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e7b51cb5ebef51975792de25686f01711ab55ac8
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_2.rs
@@ -0,0 +1,20 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(core::marker::PhantomData<(T, I)>);
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_2.stderr b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_2.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9d61f2976b75a273e0dc11c7c0824e830e354aa9
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inconsistent_instance_2.stderr
@@ -0,0 +1,29 @@
+error: Invalid generic declaration, trait is defined without instance but generic use some
+  --> $DIR/inconsistent_instance_2.rs:10:20
+   |
+10 |     pub struct Pallet<T, I = ()>(core::marker::PhantomData<(T, I)>);
+   |                       ^
+
+error: Invalid generic declaration, trait is defined without instance but generic use some
+  --> $DIR/inconsistent_instance_2.rs:16:7
+   |
+16 |     impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+   |          ^
+
+error: Invalid generic declaration, trait is defined without instance but generic use some
+  --> $DIR/inconsistent_instance_2.rs:16:33
+   |
+16 |     impl<T: Config<I>, I: 'static> Pallet<T, I> {}
+   |                                    ^^^^^^
+
+error: Invalid generic declaration, trait is defined without instance but generic use some
+  --> $DIR/inconsistent_instance_2.rs:13:62
+   |
+13 |     impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {}
+   |                                                                 ^^^^^^
+
+error: Invalid generic declaration, trait is defined without instance but generic use some
+  --> $DIR/inconsistent_instance_2.rs:13:7
+   |
+13 |     impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {}
+   |          ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/inherent_check_inner_span.rs b/substrate/frame/support/test/tests/pallet_ui/inherent_check_inner_span.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9704a7e1a442e19771437906b6ef2a2fbf619bb0
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inherent_check_inner_span.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, ProvideInherent};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::inherent]
+	impl<T: Config> ProvideInherent for Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/inherent_check_inner_span.stderr b/substrate/frame/support/test/tests/pallet_ui/inherent_check_inner_span.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..bc34c55241a7649d898be6266e6058f49cc7943a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inherent_check_inner_span.stderr
@@ -0,0 +1,11 @@
+error[E0046]: not all trait items implemented, missing: `Call`, `Error`, `INHERENT_IDENTIFIER`, `create_inherent`, `is_inherent`
+  --> $DIR/inherent_check_inner_span.rs:19:2
+   |
+19 |     impl<T: Config> ProvideInherent for Pallet<T> {}
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `Call`, `Error`, `INHERENT_IDENTIFIER`, `create_inherent`, `is_inherent` in implementation
+   |
+   = help: implement the missing item: `type Call = Type;`
+   = help: implement the missing item: `type Error = Type;`
+   = help: implement the missing item: `const INHERENT_IDENTIFIER: [u8; 8] = value;`
+   = help: implement the missing item: `fn create_inherent(_: &InherentData) -> std::option::Option<<Self as ProvideInherent>::Call> { todo!() }`
+   = help: implement the missing item: `fn is_inherent(_: &<Self as ProvideInherent>::Call) -> bool { todo!() }`
diff --git a/substrate/frame/support/test/tests/pallet_ui/inherent_invalid_item.rs b/substrate/frame/support/test/tests/pallet_ui/inherent_invalid_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..97eda447213074c3012658194f701d869ec351bd
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inherent_invalid_item.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::inherent]
+	impl Foo {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/inherent_invalid_item.stderr b/substrate/frame/support/test/tests/pallet_ui/inherent_invalid_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b62b1234bdeb01b2c4d6de8b74ddca24544be24d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/inherent_invalid_item.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::inherent, expected impl<..> ProvideInherent for Pallet<..>
+  --> $DIR/inherent_invalid_item.rs:19:2
+   |
+19 |     impl Foo {}
+   |     ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/lock_id_duplicate.rs b/substrate/frame/support/test/tests/pallet_ui/lock_id_duplicate.rs
new file mode 100644
index 0000000000000000000000000000000000000000..70418efc41421a793c79b1a784829159153a70fd
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/lock_id_duplicate.rs
@@ -0,0 +1,17 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::composite_enum]
+    pub enum LockId {}
+
+	#[pallet::composite_enum]
+    pub enum LockId {}
+}
+
+fn main() {
+}
\ No newline at end of file
diff --git a/substrate/frame/support/test/tests/pallet_ui/lock_id_duplicate.stderr b/substrate/frame/support/test/tests/pallet_ui/lock_id_duplicate.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1b7097d0a1095fa9abebe3876d6802f55a9a6804
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/lock_id_duplicate.stderr
@@ -0,0 +1,5 @@
+error: Invalid duplicated `LockId` definition
+  --> tests/pallet_ui/lock_id_duplicate.rs:13:14
+   |
+13 |     pub enum LockId {}
+   |              ^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/mod_not_inlined.rs b/substrate/frame/support/test/tests/pallet_ui/mod_not_inlined.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c74c7f5ef2a2b65b98225eace8b5454207fa142b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/mod_not_inlined.rs
@@ -0,0 +1,5 @@
+#[frame_support::pallet]
+mod foo;
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/mod_not_inlined.stderr b/substrate/frame/support/test/tests/pallet_ui/mod_not_inlined.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9ad93939d8c00f1a956fcd21283d2125a529105e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/mod_not_inlined.stderr
@@ -0,0 +1,13 @@
+error[E0658]: non-inline modules in proc macro input are unstable
+ --> $DIR/mod_not_inlined.rs:2:1
+  |
+2 | mod foo;
+  | ^^^^^^^^
+  |
+  = note: see issue #54727 <https://github.com/rust-lang/rust/issues/54727> for more information
+
+error: Invalid pallet definition, expected mod to be inlined.
+ --> $DIR/mod_not_inlined.rs:2:1
+  |
+2 | mod foo;
+  | ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/no_default_bounds_but_missing_with_default.rs b/substrate/frame/support/test/tests/pallet_ui/no_default_bounds_but_missing_with_default.rs
new file mode 100644
index 0000000000000000000000000000000000000000..123d79141749876ef0bb66b4685ead35b5ad9237
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/no_default_bounds_but_missing_with_default.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		#[pallet::no_default_bounds]
+		type MyGetParam2: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/no_default_bounds_but_missing_with_default.stderr b/substrate/frame/support/test/tests/pallet_ui/no_default_bounds_but_missing_with_default.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..cbed14bca2cd4a86737608bde1cd9504ff647e9a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/no_default_bounds_but_missing_with_default.stderr
@@ -0,0 +1,5 @@
+error: `#[pallet:no_default_bounds]` can only be used if `#[pallet::config(with_default)]` has been specified
+ --> tests/pallet_ui/no_default_bounds_but_missing_with_default.rs:9:4
+  |
+9 |         #[pallet::no_default_bounds]
+  |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/no_default_but_missing_with_default.rs b/substrate/frame/support/test/tests/pallet_ui/no_default_but_missing_with_default.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5ffa13c22243dacd19c7b04f0bebce11364d2d53
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/no_default_but_missing_with_default.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		#[pallet::no_default]
+		type MyGetParam2: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/no_default_but_missing_with_default.stderr b/substrate/frame/support/test/tests/pallet_ui/no_default_but_missing_with_default.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..aebde115eb80e14551da03546ea91506ec20e60d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/no_default_but_missing_with_default.stderr
@@ -0,0 +1,5 @@
+error: `#[pallet:no_default]` can only be used if `#[pallet::config(with_default)]` has been specified
+ --> tests/pallet_ui/no_default_but_missing_with_default.rs:9:4
+  |
+9 |         #[pallet::no_default]
+  |          ^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.rs b/substrate/frame/support/test/tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7d8be8ec0017456bd0c9a75c455e50314907ec30
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.rs
@@ -0,0 +1,33 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	// The struct on which we build all of our Pallet logic.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	// Your Pallet's configuration trait, representing custom external types and interfaces.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::storage]
+	type MyStorage<T: Config> = StorageValue<_, Vec<u8>>;
+
+	#[pallet::storage]
+	type MyStorageMap<T: Config> = StorageMap<Key = u32, Value = u64>;
+
+	#[pallet::storage]
+	type MyStorageDoubleMap<T: Config> = StorageDoubleMap<Key1 = u32, Key2 = u64, Value = u64>;
+
+	#[pallet::storage]
+	type MyCountedStorageMap<T: Config> = CountedStorageMap<Key = u32, Value = u64>;
+
+	// Your Pallet's internal functions.
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.stderr b/substrate/frame/support/test/tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..68751470a3e2fcb7f5b817bdf5e87e54f9d9b229
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.stderr
@@ -0,0 +1,11 @@
+error: Invalid pallet::storage, cannot find `Hasher` generic, required for `StorageMap`.
+  --> tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.rs:21:43
+   |
+21 |     type MyStorageMap<T: Config> = StorageMap<Key = u32, Value = u64>;
+   |                                              ^
+
+error[E0432]: unresolved import `pallet`
+ --> tests/pallet_ui/non_dev_mode_storage_map_explicit_key_default_hasher.rs:3:9
+  |
+3 | pub use pallet::*;
+  |         ^^^^^^ help: a similar path exists: `test_pallet::pallet`
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_arg_non_path.rs b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_arg_non_path.rs
new file mode 100644
index 0000000000000000000000000000000000000000..32df5d61836530c86c72440410fc992d203f56cb
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_arg_non_path.rs
@@ -0,0 +1,16 @@
+#[frame_support::pallet]
+// Must receive a string literal pointing to a path
+#[pallet_doc(X)]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::Nonce: From<u128>,
+	{
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_arg_non_path.stderr b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_arg_non_path.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9a1249dd36f37aaf2becc67c07c8826ac60bd29e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_arg_non_path.stderr
@@ -0,0 +1,5 @@
+error: The `pallet_doc` received an unsupported argument. Supported format: `pallet_doc("PATH")`
+ --> tests/pallet_ui/pallet_doc_arg_non_path.rs:3:1
+  |
+3 | #[pallet_doc(X)]
+  | ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_empty.rs b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_empty.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6ff01e9fb44b83922f3f07e1cc212ae45d47dfd9
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_empty.rs
@@ -0,0 +1,16 @@
+#[frame_support::pallet]
+// Expected one argument for the doc path.
+#[pallet_doc]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::Nonce: From<u128>,
+	{
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_empty.stderr b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_empty.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..a220cbe9e99902790bf2974af2cd1fc3047e2834
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_empty.stderr
@@ -0,0 +1,5 @@
+error: The `pallet_doc` received an unsupported argument. Supported format: `pallet_doc("PATH")`
+ --> tests/pallet_ui/pallet_doc_empty.rs:3:1
+  |
+3 | #[pallet_doc]
+  | ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_invalid_arg.rs b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_invalid_arg.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c7d3b556a08e2a229e4638f4ea0f1293076cd7ce
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_invalid_arg.rs
@@ -0,0 +1,16 @@
+#[frame_support::pallet]
+// Argument expected as list, not named value.
+#[pallet_doc = "invalid"]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::Nonce: From<u128>,
+	{
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_invalid_arg.stderr b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_invalid_arg.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..bee7c708507d229c7866ba1d2d04216e6c44ff67
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_invalid_arg.stderr
@@ -0,0 +1,5 @@
+error: The `pallet_doc` received an unsupported argument. Supported format: `pallet_doc("PATH")`
+ --> tests/pallet_ui/pallet_doc_invalid_arg.rs:3:1
+  |
+3 | #[pallet_doc = "invalid"]
+  | ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_multiple_args.rs b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_multiple_args.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a799879fe4442fadda19bddf008102b32679ba5c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_multiple_args.rs
@@ -0,0 +1,16 @@
+#[frame_support::pallet]
+// Supports only one argument.
+#[pallet_doc("A", "B")]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::Nonce: From<u128>,
+	{
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_doc_multiple_args.stderr b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_multiple_args.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e769555438e13bd0d5fabf3f7edf369054fb0862
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_doc_multiple_args.stderr
@@ -0,0 +1,5 @@
+error: The `pallet_doc` received an unsupported argument. Supported format: `pallet_doc("PATH")`
+ --> tests/pallet_ui/pallet_doc_multiple_args.rs:3:1
+  |
+3 | #[pallet_doc("A", "B")]
+  | ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_invalid_arg.rs b/substrate/frame/support/test/tests/pallet_ui/pallet_invalid_arg.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1fc42f6511cfaf27fbf9d51f01fb3d8c9a7851e6
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_invalid_arg.rs
@@ -0,0 +1,4 @@
+#[frame_support::pallet(foo)]
+pub mod pallet {}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_invalid_arg.stderr b/substrate/frame/support/test/tests/pallet_ui/pallet_invalid_arg.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..234dc07f2ece33c9423f282a9f8e2bf44e8a98e6
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_invalid_arg.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet macro call: unexpected attribute. Macro call must be bare, such as `#[frame_support::pallet]` or `#[pallet]`, or must specify the `dev_mode` attribute, such as `#[frame_support::pallet(dev_mode)]` or #[pallet(dev_mode)].
+ --> tests/pallet_ui/pallet_invalid_arg.rs:1:25
+  |
+1 | #[frame_support::pallet(foo)]
+  |                         ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_struct_invalid_attr.rs b/substrate/frame/support/test/tests/pallet_ui/pallet_struct_invalid_attr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ac52e75a5f48900e49e62b7d9f6e3175fcb0426b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_struct_invalid_attr.rs
@@ -0,0 +1,15 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	#[pallet::generate_storage_info] // invalid
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pallet_struct_invalid_attr.stderr b/substrate/frame/support/test/tests/pallet_ui/pallet_struct_invalid_attr.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..301a73c000f079211da38d5a9ac7bdc0ace40c00
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pallet_struct_invalid_attr.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `generate_store`, `without_storage_info`, `storage_version`
+ --> tests/pallet_ui/pallet_struct_invalid_attr.rs:7:12
+  |
+7 |     #[pallet::generate_storage_info] // invalid
+  |               ^^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/default_config.rs b/substrate/frame/support/test/tests/pallet_ui/pass/default_config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9f90ae67d5779a55464bf1169201b9b23f6e9546
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/default_config.rs
@@ -0,0 +1,15 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config(with_default)]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		type MyGetParam2: Get<Self::AccountId>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+}
+
+fn main() {}
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
new file mode 100644
index 0000000000000000000000000000000000000000..ed779da80a1881d024fd34b87f50ec272b4ad298
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/dev_mode_valid.rs
@@ -0,0 +1,117 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::traits::ConstU32;
+
+pub use pallet::*;
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	// The struct on which we build all of our Pallet logic.
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	// Your Pallet's configuration trait, representing custom external types and interfaces.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	// The MEL requirement for bounded pallets is skipped by `dev_mode`.
+	#[pallet::storage]
+	type MyStorage<T: Config> = StorageValue<_, Vec<u8>>;
+
+	// The Hasher requirement skipped by `dev_mode`.
+	#[pallet::storage]
+	pub type MyStorageMap<T: Config> = StorageMap<_, _, u32, u64>;
+
+	#[pallet::storage]
+	type MyStorageDoubleMap<T: Config> = StorageDoubleMap<_, _, u32, _, u64, u64>;
+
+	#[pallet::storage]
+	type MyCountedStorageMap<T: Config> = CountedStorageMap<_, _, u32, u64>;
+
+	#[pallet::storage]
+	pub type MyStorageMap2<T: Config> = StorageMap<Key = u32, Value = u64>;
+
+	#[pallet::storage]
+	type MyStorageDoubleMap2<T: Config> = StorageDoubleMap<Key1 = u32, Key2 = u64, Value = u64>;
+
+	#[pallet::storage]
+	type MyCountedStorageMap2<T: Config> = CountedStorageMap<Key = u32, Value = u64>;
+
+	// Your Pallet's callable functions.
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		// No need to define a `weight` attribute here because of `dev_mode`.
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+
+	// Your Pallet's internal functions.
+	impl<T: Config> Pallet<T> {}
+}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+pub type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		// Exclude part `Storage` in order not to check its metadata in tests.
+		System: frame_system exclude_parts { Pallet, Storage },
+		Example: pallet,
+	}
+);
+
+impl pallet::Config for Runtime {}
+
+fn main() {
+	use frame_support::pallet_prelude::*;
+	use sp_io::{
+		hashing::{blake2_128, twox_128},
+		TestExternalities,
+	};
+	use storage::unhashed;
+
+	fn blake2_128_concat(d: &[u8]) -> Vec<u8> {
+		let mut v = blake2_128(d).to_vec();
+		v.extend_from_slice(d);
+		v
+	}
+
+	TestExternalities::default().execute_with(|| {
+		pallet::MyStorageMap::<Runtime>::insert(1, 2);
+		let mut k = [twox_128(b"Example"), twox_128(b"MyStorageMap")].concat();
+		k.extend(1u32.using_encoded(blake2_128_concat));
+		assert_eq!(unhashed::get::<u64>(&k), Some(2u64));
+	});
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/error_nested_types.rs b/substrate/frame/support/test/tests/pallet_ui/pass/error_nested_types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1b6f584af23b9c9c84f425735e53a60fa94b3f57
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/error_nested_types.rs
@@ -0,0 +1,41 @@
+use codec::{Decode, Encode};
+use frame_support::PalletError;
+
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::error]
+	pub enum Error<T> {
+		CustomError(crate::MyError),
+	}
+}
+
+#[derive(Encode, Decode, PalletError, scale_info::TypeInfo)]
+pub enum MyError {
+    Foo,
+    Bar,
+    Baz(NestedError),
+    Struct(MyStruct),
+    Wrapper(Wrapper),
+}
+
+#[derive(Encode, Decode, PalletError, scale_info::TypeInfo)]
+pub enum NestedError {
+    Quux
+}
+
+#[derive(Encode, Decode, PalletError, scale_info::TypeInfo)]
+pub struct MyStruct {
+    field: u8,
+}
+
+#[derive(Encode, Decode, PalletError, scale_info::TypeInfo)]
+pub struct Wrapper(bool);
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight.rs b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight.rs
new file mode 100644
index 0000000000000000000000000000000000000000..355a1c978df06d2783e0ce78cf2da37957122495
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight.rs
@@ -0,0 +1,51 @@
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+pub trait WeightInfo {
+	fn foo() -> Weight;
+}
+
+#[frame_support::pallet]
+mod parentheses {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight(<T as Config>::WeightInfo))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: crate::WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight = <T as Config>::WeightInfo)]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight2.rs b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ae70c295d8db24da7768a4c8295b74181c8ff460
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight2.rs
@@ -0,0 +1,57 @@
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+pub trait WeightInfo {
+	fn foo() -> Weight;
+}
+
+impl WeightInfo for () {
+	fn foo() -> Weight {
+		Weight::zero()
+	}
+}
+
+#[frame_support::pallet]
+mod parentheses {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	// Crazy man just uses `()`, but it still works ;)
+	#[pallet::call(weight(()))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	// Crazy man just uses `()`, but it still works ;)
+	#[pallet::call(weight = ())]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight3.rs b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight3.rs
new file mode 100644
index 0000000000000000000000000000000000000000..567fd2e5fa032f51734b4931c467faedafd26b7b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight3.rs
@@ -0,0 +1,54 @@
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+// If, for whatever reason, you dont to not use a `WeightInfo` trait - it will still work.
+struct Impl;
+
+impl Impl {
+	fn foo() -> Weight {
+		Weight::zero()
+	}
+}
+
+#[frame_support::pallet]
+mod parentheses {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight(crate::Impl))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+#[frame_support::pallet]
+mod assign {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight = crate::Impl)]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight_dev_mode.rs b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight_dev_mode.rs
new file mode 100644
index 0000000000000000000000000000000000000000..04ce49ee71e99fa72623c5e2052a243e37f86d2a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight_dev_mode.rs
@@ -0,0 +1,30 @@
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+
+pub trait WeightInfo {
+	fn foo() -> Weight;
+}
+
+#[frame_support::pallet(dev_mode)]
+mod pallet {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call(weight(<T as Config>::WeightInfo))]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		pub fn foo(_: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/no_std_genesis_config.rs b/substrate/frame/support/test/tests/pallet_ui/pass/no_std_genesis_config.rs
new file mode 100644
index 0000000000000000000000000000000000000000..87659a0bab5136ceff1c812f62991e8fa35abd65
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/no_std_genesis_config.rs
@@ -0,0 +1,47 @@
+use frame_support::construct_runtime;
+use sp_core::sr25519;
+use sp_runtime::{generic, traits::BlakeTwo256};
+
+pub type Signature = sr25519::Signature;
+pub type BlockNumber = u32;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+
+impl test_pallet::Config for Runtime {}
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+	type Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = frame_support::traits::ConstU32<250>;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+}
+
+construct_runtime! {
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Pallet: test_pallet::{Pallet, Config<T>},
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/trait_constant_valid_bounds.rs b/substrate/frame/support/test/tests/pallet_ui/pass/trait_constant_valid_bounds.rs
new file mode 100644
index 0000000000000000000000000000000000000000..71eb4f2992b39debd98ff43f0e59f28e2fd40295
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/trait_constant_valid_bounds.rs
@@ -0,0 +1,29 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		type U: Get<u32>;
+
+		#[pallet::constant]
+		type V: Get<u32> + From<u16>;
+
+		#[pallet::constant]
+		type W: From<u16> + Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/pass/where_clause_missing_hooks.rs b/substrate/frame/support/test/tests/pallet_ui/pass/where_clause_missing_hooks.rs
new file mode 100644
index 0000000000000000000000000000000000000000..15fff372a1dd13ffac6e3c4bf72c2354a7e0e898
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/pass/where_clause_missing_hooks.rs
@@ -0,0 +1,26 @@
+#[frame_support::pallet]
+mod pallet {
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where
+		<Self as frame_system::Config>::Nonce: From<u128>,
+	{
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> where <T as frame_system::Config>::Nonce: From<u128> {}
+
+	impl<T: Config> Pallet<T>
+	where
+		<T as frame_system::Config>::Nonce: From<u128>,
+	{
+		fn foo(x: u128) {
+			let _index = <T as frame_system::Config>::Nonce::from(x);
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe4682c401fa047d98fe63495eb60e406533bea4
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs
@@ -0,0 +1,26 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, StorageValue};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	struct Bar;
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<Value = Bar>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..bc6d98b8da84d056bfaa09cb23cf5d6827d33f4f
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.stderr
@@ -0,0 +1,130 @@
+error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs:10:12
+   |
+10 |     #[pallet::without_storage_info]
+   |               ^^^^^^^^^^^^^^^^^^^^ the trait `WrapperTypeDecode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeDecode`:
+             Arc<T>
+             Box<T>
+             Rc<T>
+             frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
+   = note: required for `Bar` to implement `Decode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `PartialStorageInfoTrait`
+
+error[E0277]: the trait bound `Bar: EncodeLike` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs:10:12
+   |
+10 |     #[pallet::without_storage_info]
+   |               ^^^^^^^^^^^^^^^^^^^^ the trait `EncodeLike` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `EncodeLike<T>`:
+             <&&T as EncodeLike<T>>
+             <&T as EncodeLike<T>>
+             <&T as EncodeLike>
+             <&[(K, V)] as EncodeLike<BTreeMap<LikeK, LikeV>>>
+             <&[(T,)] as EncodeLike<BTreeSet<LikeT>>>
+             <&[(T,)] as EncodeLike<BinaryHeap<LikeT>>>
+             <&[(T,)] as EncodeLike<LinkedList<LikeT>>>
+             <&[T] as EncodeLike<Vec<U>>>
+           and $N others
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `PartialStorageInfoTrait`
+
+error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs:10:12
+   |
+10 |     #[pallet::without_storage_info]
+   |               ^^^^^^^^^^^^^^^^^^^^ the trait `WrapperTypeEncode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeEncode`:
+             &T
+             &mut T
+             Arc<T>
+             Box<T>
+             Cow<'a, T>
+             Rc<T>
+             Vec<T>
+             bytes::bytes::Bytes
+           and $N others
+   = note: required for `Bar` to implement `Encode`
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `PartialStorageInfoTrait`
+
+error[E0277]: the trait bound `Bar: TypeInfo` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `TypeInfo` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `TypeInfo`:
+             &T
+             &mut T
+             ()
+             (A, B)
+             (A, B, C)
+             (A, B, C, D)
+             (A, B, C, D, E)
+             (A, B, C, D, E, F)
+           and $N others
+   = note: required for `Bar` to implement `StaticTypeInfo`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
+
+error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `WrapperTypeDecode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeDecode`:
+             Arc<T>
+             Box<T>
+             Rc<T>
+             frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
+   = note: required for `Bar` to implement `Decode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
+
+error[E0277]: the trait bound `Bar: EncodeLike` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `EncodeLike` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `EncodeLike<T>`:
+             <&&T as EncodeLike<T>>
+             <&T as EncodeLike<T>>
+             <&T as EncodeLike>
+             <&[(K, V)] as EncodeLike<BTreeMap<LikeK, LikeV>>>
+             <&[(T,)] as EncodeLike<BTreeSet<LikeT>>>
+             <&[(T,)] as EncodeLike<BinaryHeap<LikeT>>>
+             <&[(T,)] as EncodeLike<LinkedList<LikeT>>>
+             <&[T] as EncodeLike<Vec<U>>>
+           and $N others
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
+
+error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `WrapperTypeEncode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeEncode`:
+             &T
+             &mut T
+             Arc<T>
+             Box<T>
+             Cow<'a, T>
+             Rc<T>
+             Vec<T>
+             bytes::bytes::Bytes
+           and $N others
+   = note: required for `Bar` to implement `Encode`
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs
new file mode 100644
index 0000000000000000000000000000000000000000..82512a89fb15aa7556e38622e5a79fcce84e2314
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs
@@ -0,0 +1,26 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, StorageValue};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	struct Bar;
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<_, Bar>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1c010d662d07aa34b81fca9cd54eeeaef6f953b3
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.stderr
@@ -0,0 +1,130 @@
+error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs:10:12
+   |
+10 |     #[pallet::without_storage_info]
+   |               ^^^^^^^^^^^^^^^^^^^^ the trait `WrapperTypeDecode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeDecode`:
+             Arc<T>
+             Box<T>
+             Rc<T>
+             frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
+   = note: required for `Bar` to implement `Decode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `PartialStorageInfoTrait`
+
+error[E0277]: the trait bound `Bar: EncodeLike` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs:10:12
+   |
+10 |     #[pallet::without_storage_info]
+   |               ^^^^^^^^^^^^^^^^^^^^ the trait `EncodeLike` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `EncodeLike<T>`:
+             <&&T as EncodeLike<T>>
+             <&T as EncodeLike<T>>
+             <&T as EncodeLike>
+             <&[(K, V)] as EncodeLike<BTreeMap<LikeK, LikeV>>>
+             <&[(T,)] as EncodeLike<BTreeSet<LikeT>>>
+             <&[(T,)] as EncodeLike<BinaryHeap<LikeT>>>
+             <&[(T,)] as EncodeLike<LinkedList<LikeT>>>
+             <&[T] as EncodeLike<Vec<U>>>
+           and $N others
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `PartialStorageInfoTrait`
+
+error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs:10:12
+   |
+10 |     #[pallet::without_storage_info]
+   |               ^^^^^^^^^^^^^^^^^^^^ the trait `WrapperTypeEncode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeEncode`:
+             &T
+             &mut T
+             Arc<T>
+             Box<T>
+             Cow<'a, T>
+             Rc<T>
+             Vec<T>
+             bytes::bytes::Bytes
+           and $N others
+   = note: required for `Bar` to implement `Encode`
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `PartialStorageInfoTrait`
+
+error[E0277]: the trait bound `Bar: TypeInfo` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `TypeInfo` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `TypeInfo`:
+             &T
+             &mut T
+             ()
+             (A, B)
+             (A, B, C)
+             (A, B, C, D)
+             (A, B, C, D, E)
+             (A, B, C, D, E, F)
+           and $N others
+   = note: required for `Bar` to implement `StaticTypeInfo`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
+
+error[E0277]: the trait bound `Bar: WrapperTypeDecode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `WrapperTypeDecode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeDecode`:
+             Arc<T>
+             Box<T>
+             Rc<T>
+             frame_support::sp_runtime::sp_application_crypto::sp_core::Bytes
+   = note: required for `Bar` to implement `Decode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
+
+error[E0277]: the trait bound `Bar: EncodeLike` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `EncodeLike` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `EncodeLike<T>`:
+             <&&T as EncodeLike<T>>
+             <&T as EncodeLike<T>>
+             <&T as EncodeLike>
+             <&[(K, V)] as EncodeLike<BTreeMap<LikeK, LikeV>>>
+             <&[(T,)] as EncodeLike<BTreeSet<LikeT>>>
+             <&[(T,)] as EncodeLike<BinaryHeap<LikeT>>>
+             <&[(T,)] as EncodeLike<LinkedList<LikeT>>>
+             <&[T] as EncodeLike<Vec<U>>>
+           and $N others
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
+
+error[E0277]: the trait bound `Bar: WrapperTypeEncode` is not satisfied
+  --> tests/pallet_ui/storage_ensure_span_are_ok_on_wrong_gen_unnamed.rs:21:12
+   |
+21 |     #[pallet::storage]
+   |               ^^^^^^^ the trait `WrapperTypeEncode` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `WrapperTypeEncode`:
+             &T
+             &mut T
+             Arc<T>
+             Box<T>
+             Cow<'a, T>
+             Rc<T>
+             Vec<T>
+             bytes::bytes::Bytes
+           and $N others
+   = note: required for `Bar` to implement `Encode`
+   = note: required for `Bar` to implement `FullEncode`
+   = note: required for `Bar` to implement `FullCodec`
+   = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageEntryMetadataBuilder`
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_incomplete_item.rs b/substrate/frame/support/test/tests/pallet_ui/storage_incomplete_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e451df8c78a02f97bbd047d87a99889c0f3533e6
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_incomplete_item.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_incomplete_item.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_incomplete_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..57f3ab78a5382e07b824bd89774ab0e1ec12c3cf
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_incomplete_item.stderr
@@ -0,0 +1,13 @@
+error: free type alias without body
+  --> $DIR/storage_incomplete_item.rs:19:2
+   |
+19 |     type Foo;
+   |     ^^^^^^^^-
+   |             |
+   |             help: provide a definition for the type: `= <type>;`
+
+error[E0433]: failed to resolve: use of undeclared crate or module `pallet`
+  --> $DIR/storage_incomplete_item.rs:18:4
+   |
+18 |     #[pallet::storage]
+   |       ^^^^^^ use of undeclared crate or module `pallet`
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied.rs b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4d43e3a17a9ec80e5a1771f5ff2538e62a2d1f33
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied.rs
@@ -0,0 +1,26 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, StorageValue};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[derive(codec::Encode, codec::Decode, scale_info::TypeInfo)]
+	struct Bar;
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<_, Bar>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c17f9eaa03251bd7109fb32e640462823f65d4ee
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied.stderr
@@ -0,0 +1,17 @@
+error[E0277]: the trait bound `Bar: MaxEncodedLen` is not satisfied
+ --> tests/pallet_ui/storage_info_unsatisfied.rs:9:12
+  |
+9 |     #[pallet::pallet]
+  |               ^^^^^^ the trait `MaxEncodedLen` is not implemented for `Bar`
+  |
+  = help: the following other types implement trait `MaxEncodedLen`:
+            ()
+            (TupleElement0, TupleElement1)
+            (TupleElement0, TupleElement1, TupleElement2)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6)
+            (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6, TupleElement7)
+          and $N others
+  = note: required for `frame_support::pallet_prelude::StorageValue<_GeneratedPrefixForStorageFoo<T>, Bar>` to implement `StorageInfoTrait`
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied_nmap.rs b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied_nmap.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dd10bc0723fe129b80dad1eb4bbbc7d394ffa3b6
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied_nmap.rs
@@ -0,0 +1,28 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::{
+		pallet_prelude::{Hooks, Twox64Concat},
+		storage::types::{StorageNMap, Key},
+	};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[derive(codec::Encode, codec::Decode, scale_info::TypeInfo)]
+	struct Bar;
+
+	#[pallet::storage]
+	type Foo<T> = StorageNMap<_, Key<Twox64Concat, Bar>, u32>;
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied_nmap.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied_nmap.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c34c796fe59c18bcfdc12b3d6283fbb1cf4ed08f
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_info_unsatisfied_nmap.stderr
@@ -0,0 +1,18 @@
+error[E0277]: the trait bound `Bar: MaxEncodedLen` is not satisfied
+  --> tests/pallet_ui/storage_info_unsatisfied_nmap.rs:12:12
+   |
+12 |     #[pallet::pallet]
+   |               ^^^^^^ the trait `MaxEncodedLen` is not implemented for `Bar`
+   |
+   = help: the following other types implement trait `MaxEncodedLen`:
+             ()
+             (TupleElement0, TupleElement1)
+             (TupleElement0, TupleElement1, TupleElement2)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6)
+             (TupleElement0, TupleElement1, TupleElement2, TupleElement3, TupleElement4, TupleElement5, TupleElement6, TupleElement7)
+           and $N others
+   = note: required for `Key<frame_support::Twox64Concat, Bar>` to implement `KeyGeneratorMaxEncodedLen`
+   = note: required for `frame_support::pallet_prelude::StorageNMap<_GeneratedPrefixForStorageFoo<T>, Key<frame_support::Twox64Concat, Bar>, u32>` to implement `StorageInfoTrait`
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_invalid_attribute.rs b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_attribute.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c6a88c083135d538b0550547f72cc4dec2c1a078
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_attribute.rs
@@ -0,0 +1,21 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	#[pallet::generate_store(pub trait Store)]
+	type Foo<T> = StorageValue<u8, u8>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_invalid_attribute.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_attribute.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..80c6526bbf88897282e4d2deb576f09fe56b238d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_attribute.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `getter`, `storage_prefix`, `unbounded`, `whitelist_storage`
+  --> $DIR/storage_invalid_attribute.rs:16:12
+   |
+16 |     #[pallet::generate_store(pub trait Store)]
+   |               ^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_invalid_first_generic.rs b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_first_generic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c8df93c9b323d350582e122e30c49b6c7164645b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_first_generic.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<u8, u8>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_invalid_first_generic.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_first_generic.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b37f7e57f3552c5745fba93fe780d21b5de14b84
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_first_generic.stderr
@@ -0,0 +1,11 @@
+error: Invalid pallet::storage, for unnamed generic arguments the type first generic argument must be `_`, the argument is then replaced by macro.
+  --> $DIR/storage_invalid_first_generic.rs:19:29
+   |
+19 |     type Foo<T> = StorageValue<u8, u8>;
+   |                                ^^
+
+error: expected `_`
+  --> $DIR/storage_invalid_first_generic.rs:19:29
+   |
+19 |     type Foo<T> = StorageValue<u8, u8>;
+   |                                ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_invalid_rename_value.rs b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_rename_value.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3a08e05e2ac7b42c362a63b0f6e1dac79ad013d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_rename_value.rs
@@ -0,0 +1,18 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "pub"]
+	type Foo<T> = StorageValue<_, u8>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_invalid_rename_value.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_rename_value.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..513970f98a4f7d38d3885afd1b72c5b3391e5ac2
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_invalid_rename_value.stderr
@@ -0,0 +1,5 @@
+error: `pub` is not a valid identifier
+  --> $DIR/storage_invalid_rename_value.rs:13:29
+   |
+13 |     #[pallet::storage_prefix = "pub"]
+   |                                ^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_multiple_getters.rs b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_getters.rs
new file mode 100644
index 0000000000000000000000000000000000000000..309b9b24136fadae4fdda89b5283de5a198c21c4
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_getters.rs
@@ -0,0 +1,25 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	#[pallet::getter(fn get_foo)]
+	#[pallet::getter(fn foo_error)]
+	type Foo<T> = StorageValue<_, u8>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_multiple_getters.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_getters.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..40f57f16e0df5a8de14ab4efb68d38574a9cc1d3
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_getters.stderr
@@ -0,0 +1,5 @@
+error: Invalid attribute: Duplicate attribute
+  --> $DIR/storage_multiple_getters.rs:20:3
+   |
+20 |     #[pallet::getter(fn foo_error)]
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_multiple_renames.rs b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_renames.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f3caef80a7ee28a34ca318455c6deb7a389a9616
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_renames.rs
@@ -0,0 +1,25 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "Bar"]
+	#[pallet::storage_prefix = "Baz"]
+	type Foo<T> = StorageValue<_, u8>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_multiple_renames.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_renames.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..52cb7e85adf21c10591ceec5b9df997571ff358b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_multiple_renames.stderr
@@ -0,0 +1,5 @@
+error: Invalid attribute: Duplicate attribute
+  --> $DIR/storage_multiple_renames.rs:20:3
+   |
+20 |     #[pallet::storage_prefix = "Baz"]
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_not_storage_type.rs b/substrate/frame/support/test/tests/pallet_ui/storage_not_storage_type.rs
new file mode 100644
index 0000000000000000000000000000000000000000..03eee6fc8ec7d3990b35c7697c38fabb9293b88e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_not_storage_type.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = u8;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_not_storage_type.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_not_storage_type.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..3358f00151d50dcc65a305b42753765d19187a90
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_not_storage_type.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::storage, expected ident: `StorageValue` or `StorageMap` or `CountedStorageMap` or `StorageDoubleMap` or `StorageNMap` or `CountedStorageNMap` in order to expand metadata, found `u8`.
+  --> $DIR/storage_not_storage_type.rs:19:16
+   |
+19 |     type Foo<T> = u8;
+   |                   ^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_missing_generics.rs b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_missing_generics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a051cc087db5888c98e73902c894212b2306eebf
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_missing_generics.rs
@@ -0,0 +1,21 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::error]
+	pub enum Error<T> {
+		NonExistentValue,
+	}
+
+	#[pallet::storage]
+	type Foo<T: Config> = StorageValue<_, u8, ResultQuery<Error::NonExistentValue>>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_missing_generics.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_missing_generics.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9e63fd03db52b2e18afa17e78a5a5293bb5c6094
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_missing_generics.stderr
@@ -0,0 +1,15 @@
+error[E0107]: missing generics for enum `pallet::Error`
+  --> tests/pallet_ui/storage_result_query_missing_generics.rs:17:56
+   |
+17 |     type Foo<T: Config> = StorageValue<_, u8, ResultQuery<Error::NonExistentValue>>;
+   |                                                           ^^^^^ expected 1 generic argument
+   |
+note: enum defined here, with 1 generic parameter: `T`
+  --> tests/pallet_ui/storage_result_query_missing_generics.rs:12:11
+   |
+12 |     pub enum Error<T> {
+   |              ^^^^^ -
+help: add missing generic argument
+   |
+17 |     type Foo<T: Config> = StorageValue<_, u8, ResultQuery<Error<T>::NonExistentValue>>;
+   |                                                                +++
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_multiple_type_args.rs b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_multiple_type_args.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9e0da4b62128d85ea122723365e50098afcc3dc7
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_multiple_type_args.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::error]
+	pub enum Error<T> {
+		NonExistentValue,
+		SomeOtherError,
+	}
+
+	#[pallet::storage]
+	type Foo<T: Config> = StorageValue<_, u8, ResultQuery<Error<T>::NonExistentValue, SomeOtherError>>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_multiple_type_args.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_multiple_type_args.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4be2a36eb89e17981a3a431a8d3dbe5c8457f8ff
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_multiple_type_args.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::storage, unexpected number of generic arguments for ResultQuery, expected 1 type argument, found 2
+  --> tests/pallet_ui/storage_result_query_multiple_type_args.rs:19:56
+   |
+19 |     type Foo<T: Config> = StorageValue<_, u8, ResultQuery<Error<T>::NonExistentValue, SomeOtherError>>;
+   |                                                           ^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_no_defined_pallet_error.rs b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_no_defined_pallet_error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..102a2261f83338a4e9a748b515f5f4c48ea657b4
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_no_defined_pallet_error.rs
@@ -0,0 +1,16 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::storage]
+	type Foo<T: Config> = StorageValue<_, u8, ResultQuery<NonExistentValue>>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_no_defined_pallet_error.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_no_defined_pallet_error.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..77a7972a5b5cf7e5ad0a9cf7e2cacd0ac6deb225
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_no_defined_pallet_error.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::storage, unexpected number of path segments for the generics in ResultQuery, expected a path with at least 2 segments, found 1
+  --> tests/pallet_ui/storage_result_query_no_defined_pallet_error.rs:12:56
+   |
+12 |     type Foo<T: Config> = StorageValue<_, u8, ResultQuery<NonExistentValue>>;
+   |                                                           ^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_parenthesized_generics.rs b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_parenthesized_generics.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f30dc3b6a3cc76070bac729ed3d500ba2eef9ca4
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_parenthesized_generics.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::error]
+	pub enum Error<T> {
+		NonExistentValue,
+	}
+
+	#[pallet::storage]
+	type Foo<T: Config> = StorageValue<_, u8, ResultQuery(NonExistentValue)>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_parenthesized_generics.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_parenthesized_generics.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..89ddd1599ac971d805777953db879951608a05f9
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_parenthesized_generics.stderr
@@ -0,0 +1,5 @@
+error: expected `,`
+  --> tests/pallet_ui/storage_result_query_parenthesized_generics.rs:18:55
+   |
+18 |     type Foo<T: Config> = StorageValue<_, u8, ResultQuery(NonExistentValue)>;
+   |                                                          ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_wrong_generic_kind.rs b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_wrong_generic_kind.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a5065398b397063bd405c341af820294bba76694
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_wrong_generic_kind.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::error]
+	pub enum Error<T> {
+		NonExistentValue,
+	}
+
+	#[pallet::storage]
+	type Foo<T: Config> = StorageValue<_, u8, ResultQuery<'static>>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_result_query_wrong_generic_kind.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_wrong_generic_kind.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9f333ae28e6aa327532f4a4a562625e545a2300d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_result_query_wrong_generic_kind.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::storage, unexpected generic argument kind, expected a type path to a `PalletError` enum variant, found `'static`
+  --> tests/pallet_ui/storage_result_query_wrong_generic_kind.rs:18:56
+   |
+18 |     type Foo<T: Config> = StorageValue<_, u8, ResultQuery<'static>>;
+   |                                                           ^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_duplicate_named_generic.rs b/substrate/frame/support/test/tests/pallet_ui/storage_value_duplicate_named_generic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f076b1ecbfc6b020d9ec1254938375487f8c59c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_duplicate_named_generic.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, StorageValue};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<Value = u32, Value = u32>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_duplicate_named_generic.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_value_duplicate_named_generic.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..3def9061fec8a1a1bc011eaf602e717804347599
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_duplicate_named_generic.stderr
@@ -0,0 +1,11 @@
+error: Invalid pallet::storage, Duplicated named generic
+  --> $DIR/storage_value_duplicate_named_generic.rs:19:42
+   |
+19 |     type Foo<T> = StorageValue<Value = u32, Value = u32>;
+   |                                             ^^^^^
+
+error: Invalid pallet::storage, Duplicated named generic
+  --> $DIR/storage_value_duplicate_named_generic.rs:19:29
+   |
+19 |     type Foo<T> = StorageValue<Value = u32, Value = u32>;
+   |                                ^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_generic_named_and_unnamed.rs b/substrate/frame/support/test/tests/pallet_ui/storage_value_generic_named_and_unnamed.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fd0ea4794bc43421da38acbbfb966f5e81fbf55d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_generic_named_and_unnamed.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, StorageValue, OptionQuery};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<u32, QueryKind = OptionQuery>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_generic_named_and_unnamed.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_value_generic_named_and_unnamed.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..61c01943cc3f5e1a6fcc004bdfba74ce676705f3
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_generic_named_and_unnamed.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::storage, invalid generic declaration for storage. Expect only type generics or binding generics, e.g. `<Name1 = Gen1, Name2 = Gen2, ..>` or `<Gen1, Gen2, ..>`.
+  --> $DIR/storage_value_generic_named_and_unnamed.rs:19:16
+   |
+19 |     type Foo<T> = StorageValue<u32, QueryKind = OptionQuery>;
+   |                   ^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_no_generic.rs b/substrate/frame/support/test/tests/pallet_ui/storage_value_no_generic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e62bdafaa2643535e436ae26114645c8507e46c3
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_no_generic.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_no_generic.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_value_no_generic.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f7449c5ffda7d9d84a4f3f4c4d1165ed94d34178
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_no_generic.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::storage, invalid number of generic generic arguments, expect more that 0 generic arguments.
+  --> $DIR/storage_value_no_generic.rs:19:16
+   |
+19 |     type Foo<T> = StorageValue;
+   |                   ^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_unexpected_named_generic.rs b/substrate/frame/support/test/tests/pallet_ui/storage_value_unexpected_named_generic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a3e54448e42addc61dae9a1895c3a86dc13e528a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_unexpected_named_generic.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, StorageValue};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<P = u32>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_value_unexpected_named_generic.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_value_unexpected_named_generic.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f03b71ff5eb6e82434385b4069720382a7b7926e
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_value_unexpected_named_generic.stderr
@@ -0,0 +1,11 @@
+error: Invalid pallet::storage, Unexpected generic `P` for `StorageValue`. `StorageValue` expect generics `Value`, and optional generics `QueryKind`, `OnEmpty`.
+  --> $DIR/storage_value_unexpected_named_generic.rs:19:29
+   |
+19 |     type Foo<T> = StorageValue<P = u32>;
+   |                                ^
+
+error: Invalid pallet::storage, cannot find `Value` generic, required for `StorageValue`.
+  --> $DIR/storage_value_unexpected_named_generic.rs:19:28
+   |
+19 |     type Foo<T> = StorageValue<P = u32>;
+   |                               ^
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_wrong_item.rs b/substrate/frame/support/test/tests/pallet_ui/storage_wrong_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..56c4b86f2b35a9fde7b16f37776ebef7ee59bfea
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_wrong_item.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	impl Foo {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/storage_wrong_item.stderr b/substrate/frame/support/test/tests/pallet_ui/storage_wrong_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d875d8acec66f6b6b91d1f987d5b462883173a98
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/storage_wrong_item.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::storage, expect item type.
+  --> $DIR/storage_wrong_item.rs:19:2
+   |
+19 |     impl Foo {}
+   |     ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/store_trait_leak_private.rs b/substrate/frame/support/test/tests/pallet_ui/store_trait_leak_private.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3ebd1cb9fa608e1526440c6cb6fd6800eb4ccbb1
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/store_trait_leak_private.rs
@@ -0,0 +1,25 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+	use frame_support::pallet_prelude::StorageValue;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub trait Store)]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::storage]
+	type Foo<T> = StorageValue<_, u8>;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/store_trait_leak_private.stderr b/substrate/frame/support/test/tests/pallet_ui/store_trait_leak_private.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..a8836bc0482311a2d37eb3872cd724fff951b780
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/store_trait_leak_private.stderr
@@ -0,0 +1,18 @@
+error: use of deprecated struct `pallet::_::Store`:
+               Use of `#[pallet::generate_store(pub(super) trait Store)]` will be removed after July 2023.
+               Check https://github.com/paritytech/substrate/pull/13535 for more details.
+  --> tests/pallet_ui/store_trait_leak_private.rs:11:3
+   |
+11 |     #[pallet::generate_store(pub trait Store)]
+   |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D deprecated` implied by `-D warnings`
+
+error[E0446]: private type `_GeneratedPrefixForStorageFoo<T>` in public interface
+  --> tests/pallet_ui/store_trait_leak_private.rs:11:37
+   |
+11 |     #[pallet::generate_store(pub trait Store)]
+   |                                        ^^^^^ can't leak private type
+...
+20 |     #[pallet::storage]
+   |               ------- `_GeneratedPrefixForStorageFoo<T>` declared as private
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound.rs b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ce599d5a31e71b09e711c59f9fb8c41accee9da5
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		type U;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound.stderr b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..057ec6ffb2c75211a1e34f271815159480b2bc54
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound.stderr
@@ -0,0 +1,5 @@
+error: Invalid usage of `#[pallet::constant]`: `Get<T>` trait bound not found
+ --> $DIR/trait_constant_invalid_bound.rs:9:3
+  |
+9 |         type U;
+  |         ^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound_lifetime.rs b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound_lifetime.rs
new file mode 100644
index 0000000000000000000000000000000000000000..47303f2b20a023efbeece7e3f3c37d52723b531a
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound_lifetime.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		type U: Get<'static>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound_lifetime.stderr b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound_lifetime.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..8d830fed8f392b267a27a74aa2ff5b0a54a1abff
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_constant_invalid_bound_lifetime.stderr
@@ -0,0 +1,5 @@
+error: Invalid usage of `#[pallet::constant]`: Expected a type argument
+ --> $DIR/trait_constant_invalid_bound_lifetime.rs:9:15
+  |
+9 |         type U: Get<'static>;
+  |                     ^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_invalid_item.rs b/substrate/frame/support/test/tests/pallet_ui/trait_invalid_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8537659dcd037e1a488b3f08abce2a35f0cd2a80
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_invalid_item.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		const U: u8 = 3;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_invalid_item.stderr b/substrate/frame/support/test/tests/pallet_ui/trait_invalid_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e3409a819114a96f52d52732a1bf93f178fa6ada
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_invalid_item.stderr
@@ -0,0 +1,5 @@
+error: Invalid #[pallet::constant] in #[pallet::config], expected type item
+ --> tests/pallet_ui/trait_invalid_item.rs:9:3
+  |
+9 |         const U: u8 = 3;
+  |         ^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_constant_attr.rs b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_constant_attr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8f3d9f3f3e2f956f47632ceda79b627c32d3701c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_constant_attr.rs
@@ -0,0 +1,23 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		#[pallet::constant]
+		type MyGetParam2: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_constant_attr.stderr b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_constant_attr.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..3679b67f07b53bc9ccf999b8c737569cfc9bbfa1
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_constant_attr.stderr
@@ -0,0 +1,5 @@
+error: Duplicate #[pallet::constant] attribute not allowed.
+ --> tests/pallet_ui/trait_item_duplicate_constant_attr.rs:9:4
+  |
+9 |         #[pallet::constant]
+  |          ^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_no_default.rs b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_no_default.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d2040ec74dc4edc3e123672f67ff01216990cfde
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_no_default.rs
@@ -0,0 +1,24 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config(with_default)]
+	pub trait Config: frame_system::Config {
+		#[pallet::constant]
+		#[pallet::no_default]
+		#[pallet::no_default]
+		type MyGetParam2: Get<u32>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_no_default.stderr b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_no_default.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..77a29c394d62dd1a5ca1cd7cabd8f10f7b5926ad
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_item_duplicate_no_default.stderr
@@ -0,0 +1,5 @@
+error: Duplicate #[pallet::no_default] attribute not allowed.
+  --> tests/pallet_ui/trait_item_duplicate_no_default.rs:10:4
+   |
+10 |         #[pallet::no_default]
+   |          ^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_no_supertrait.rs b/substrate/frame/support/test/tests/pallet_ui/trait_no_supertrait.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0fc987f7bbdd7d45e57b5f79d876f02cab73da1c
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_no_supertrait.rs
@@ -0,0 +1,21 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config {
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(core::marker::PhantomData<T>);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/trait_no_supertrait.stderr b/substrate/frame/support/test/tests/pallet_ui/trait_no_supertrait.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..c38f43d28eb3377725bf0fb1cb15da3d74c47b1f
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/trait_no_supertrait.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::trait, expected explicit `frame_system::Config` as supertrait, found none. (try `pub trait Config: frame_system::Config { ...` or `pub trait Config<I: 'static>: frame_system::Config { ...`). To disable this check, use `#[pallet::disable_frame_system_supertrait_check]`
+ --> $DIR/trait_no_supertrait.rs:7:2
+  |
+7 |     pub trait Config {
+  |     ^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_error_in_block.rs b/substrate/frame/support/test/tests/pallet_ui/type_value_error_in_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a13e1c7c5c2d28cad863c3b31dac236b0bdaf636
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_error_in_block.rs
@@ -0,0 +1,25 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::type_value] fn Foo() -> u32 {
+		// Just wrong code to see span
+		u32::new()
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_error_in_block.stderr b/substrate/frame/support/test/tests/pallet_ui/type_value_error_in_block.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f46b89a067b061613d07ee37747b8213613ccc77
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_error_in_block.stderr
@@ -0,0 +1,5 @@
+error[E0599]: no function or associated item named `new` found for type `u32` in the current scope
+  --> $DIR/type_value_error_in_block.rs:20:8
+   |
+20 |         u32::new()
+   |              ^^^ function or associated item not found in `u32`
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_forgotten_where_clause.rs b/substrate/frame/support/test/tests/pallet_ui/type_value_forgotten_where_clause.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b04d8b894676d0964ed06fd966e94d89cd8650a5
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_forgotten_where_clause.rs
@@ -0,0 +1,28 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::Hooks;
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config
+	where <Self as frame_system::Config>::AccountId: From<u32>
+	{}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T>
+	where <T as frame_system::Config>::AccountId: From<u32>
+	{}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T>
+	where <T as frame_system::Config>::AccountId: From<u32>
+	{}
+
+	#[pallet::type_value] fn Foo<T: Config>() -> u32 { 3u32 }
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_forgotten_where_clause.stderr b/substrate/frame/support/test/tests/pallet_ui/type_value_forgotten_where_clause.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d955960c315b021063903e74411cfd03a6a7ade2
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_forgotten_where_clause.stderr
@@ -0,0 +1,53 @@
+error[E0277]: the trait bound `<T as frame_system::Config>::AccountId: From<u32>` is not satisfied
+  --> tests/pallet_ui/type_value_forgotten_where_clause.rs:24:34
+   |
+24 |     #[pallet::type_value] fn Foo<T: Config>() -> u32 { 3u32 }
+   |                                     ^^^^^^ the trait `From<u32>` is not implemented for `<T as frame_system::Config>::AccountId`
+   |
+note: required by a bound in `pallet::Config`
+  --> tests/pallet_ui/type_value_forgotten_where_clause.rs:8:51
+   |
+7  |     pub trait Config: frame_system::Config
+   |               ------ required by a bound in this trait
+8  |     where <Self as frame_system::Config>::AccountId: From<u32>
+   |                                                      ^^^^^^^^^ required by this bound in `Config`
+help: consider further restricting the associated type
+   |
+24 |     #[pallet::type_value] fn Foo<T: Config>() -> u32 where <T as frame_system::Config>::AccountId: From<u32> { 3u32 }
+   |                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+error[E0277]: the trait bound `<T as frame_system::Config>::AccountId: From<u32>` is not satisfied
+  --> tests/pallet_ui/type_value_forgotten_where_clause.rs:24:12
+   |
+24 |     #[pallet::type_value] fn Foo<T: Config>() -> u32 { 3u32 }
+   |               ^^^^^^^^^^ the trait `From<u32>` is not implemented for `<T as frame_system::Config>::AccountId`
+   |
+note: required by a bound in `pallet::Config`
+  --> tests/pallet_ui/type_value_forgotten_where_clause.rs:8:51
+   |
+7  |     pub trait Config: frame_system::Config
+   |               ------ required by a bound in this trait
+8  |     where <Self as frame_system::Config>::AccountId: From<u32>
+   |                                                      ^^^^^^^^^ required by this bound in `Config`
+help: consider further restricting the associated type
+   |
+24 |     #[pallet::type_value where <T as frame_system::Config>::AccountId: From<u32>] fn Foo<T: Config>() -> u32 { 3u32 }
+   |                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+error[E0277]: the trait bound `<T as frame_system::Config>::AccountId: From<u32>` is not satisfied
+  --> tests/pallet_ui/type_value_forgotten_where_clause.rs:24:12
+   |
+24 |     #[pallet::type_value] fn Foo<T: Config>() -> u32 { 3u32 }
+   |               ^^^^^^^^^^ the trait `From<u32>` is not implemented for `<T as frame_system::Config>::AccountId`
+   |
+note: required by a bound in `pallet::Config`
+  --> tests/pallet_ui/type_value_forgotten_where_clause.rs:8:51
+   |
+7  |     pub trait Config: frame_system::Config
+   |               ------ required by a bound in this trait
+8  |     where <Self as frame_system::Config>::AccountId: From<u32>
+   |                                                      ^^^^^^^^^ required by this bound in `Config`
+help: consider further restricting the associated type
+   |
+24 |     #[pallet::type_value] fn Foo<T: Config>() -> u32 where <T as frame_system::Config>::AccountId: From<u32> { 3u32 }
+   |                                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_invalid_item.rs b/substrate/frame/support/test/tests/pallet_ui/type_value_invalid_item.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1b6c975b09ed1d35e10cdccb22d02a61065a4781
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_invalid_item.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, PhantomData};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::type_value] struct Foo;
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_invalid_item.stderr b/substrate/frame/support/test/tests/pallet_ui/type_value_invalid_item.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5ae618df8837c2a7c4bc734bf5b8b9bb27c5794d
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_invalid_item.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::type_value, expected item fn
+  --> $DIR/type_value_invalid_item.rs:18:24
+   |
+18 |     #[pallet::type_value] struct Foo;
+   |                           ^^^^^^
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_no_return.rs b/substrate/frame/support/test/tests/pallet_ui/type_value_no_return.rs
new file mode 100644
index 0000000000000000000000000000000000000000..82eb3b17d0393b8c7bd3bbd729dd28d01f66858f
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_no_return.rs
@@ -0,0 +1,22 @@
+#[frame_support::pallet]
+mod pallet {
+	use frame_support::pallet_prelude::{Hooks, PhantomData};
+	use frame_system::pallet_prelude::BlockNumberFor;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {}
+
+	#[pallet::type_value] fn Foo() {}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/pallet_ui/type_value_no_return.stderr b/substrate/frame/support/test/tests/pallet_ui/type_value_no_return.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..65ac0243f9f64eadf1c1f585321d608be15f194b
--- /dev/null
+++ b/substrate/frame/support/test/tests/pallet_ui/type_value_no_return.stderr
@@ -0,0 +1,5 @@
+error: Invalid pallet::type_value, expected return type
+  --> $DIR/type_value_no_return.rs:18:24
+   |
+18 |     #[pallet::type_value] fn Foo() {}
+   |                           ^^
diff --git a/substrate/frame/support/test/tests/runtime_metadata.rs b/substrate/frame/support/test/tests/runtime_metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a545735f2b1e8bb8496ef12360fdd1c289ef0f2b
--- /dev/null
+++ b/substrate/frame/support/test/tests/runtime_metadata.rs
@@ -0,0 +1,215 @@
+// 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_support::traits::ConstU32;
+use scale_info::{form::MetaForm, meta_type};
+use sp_metadata_ir::{
+	RuntimeApiMetadataIR, RuntimeApiMethodMetadataIR, RuntimeApiMethodParamMetadataIR,
+};
+use sp_runtime::traits::Block as BlockT;
+
+pub type BlockNumber = u64;
+pub type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+
+impl frame_system::Config for Runtime {
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type BaseCallFilter = frame_support::traits::Everything;
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type RuntimeCall = RuntimeCall;
+	type Hash = sp_runtime::testing::H256;
+	type Hashing = sp_runtime::traits::BlakeTwo256;
+	type AccountId = u64;
+	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 = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+frame_support::construct_runtime!(
+	pub enum Runtime
+	{
+		System: frame_system,
+	}
+);
+
+sp_api::decl_runtime_apis! {
+	/// ApiWithCustomVersion trait documentation
+	///
+	/// Documentation on multiline.
+	pub trait Api {
+		fn test(data: u64);
+		/// something_with_block.
+		fn something_with_block(block: Block) -> Block;
+		fn function_with_two_args(data: u64, block: Block);
+		fn same_name();
+		fn wild_card(_: u32);
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	impl self::Api<Block> for Runtime {
+		fn test(_data: u64) {
+			unimplemented!()
+		}
+
+		fn something_with_block(_: Block) -> Block {
+			unimplemented!()
+		}
+
+		fn function_with_two_args(_: u64, _: Block) {
+			unimplemented!()
+		}
+
+		fn same_name() {}
+
+		fn wild_card(_: u32) {}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+#[test]
+fn runtime_metadata() {
+	fn maybe_docs(doc: Vec<&'static str>) -> Vec<&'static str> {
+		if cfg!(feature = "no-metadata-docs") {
+			vec![]
+		} else {
+			doc
+		}
+	}
+
+	let expected_runtime_metadata = vec![
+		RuntimeApiMetadataIR {
+			name: "Api",
+			methods: vec![
+				RuntimeApiMethodMetadataIR {
+					name: "test",
+					inputs: vec![RuntimeApiMethodParamMetadataIR::<MetaForm> {
+						name: "data",
+						ty: meta_type::<u64>(),
+					}],
+					output: meta_type::<()>(),
+					docs: vec![],
+				},
+				RuntimeApiMethodMetadataIR {
+					name: "something_with_block",
+					inputs: vec![RuntimeApiMethodParamMetadataIR::<MetaForm> {
+						name: "block",
+						ty: meta_type::<Block>(),
+					}],
+					output: meta_type::<Block>(),
+					docs: maybe_docs(vec![" something_with_block."]),
+				},
+				RuntimeApiMethodMetadataIR {
+					name: "function_with_two_args",
+					inputs: vec![
+						RuntimeApiMethodParamMetadataIR::<MetaForm> {
+							name: "data",
+							ty: meta_type::<u64>(),
+						},
+						RuntimeApiMethodParamMetadataIR::<MetaForm> {
+							name: "block",
+							ty: meta_type::<Block>(),
+						},
+					],
+					output: meta_type::<()>(),
+					docs: vec![],
+				},
+				RuntimeApiMethodMetadataIR {
+					name: "same_name",
+					inputs: vec![],
+					output: meta_type::<()>(),
+					docs: vec![],
+				},
+				RuntimeApiMethodMetadataIR {
+					name: "wild_card",
+					inputs: vec![RuntimeApiMethodParamMetadataIR::<MetaForm> {
+						name: "_",
+						ty: meta_type::<u32>(),
+					}],
+					output: meta_type::<()>(),
+					docs: vec![],
+				},
+			],
+			docs: maybe_docs(vec![
+				" ApiWithCustomVersion trait documentation",
+				"",
+				" Documentation on multiline.",
+			]),
+		},
+		RuntimeApiMetadataIR {
+			name: "Core",
+			methods: vec![
+				RuntimeApiMethodMetadataIR {
+					name: "version",
+					inputs: vec![],
+					output: meta_type::<sp_version::RuntimeVersion>(),
+					docs: maybe_docs(vec![" Returns the version of the runtime."]),
+				},
+				RuntimeApiMethodMetadataIR {
+					name: "execute_block",
+					inputs: vec![RuntimeApiMethodParamMetadataIR::<MetaForm> {
+						name: "block",
+						ty: meta_type::<Block>(),
+					}],
+					output: meta_type::<()>(),
+					docs: maybe_docs(vec![" Execute the given block."]),
+				},
+				RuntimeApiMethodMetadataIR {
+					name: "initialize_block",
+					inputs: vec![RuntimeApiMethodParamMetadataIR::<MetaForm> {
+						name: "header",
+						ty: meta_type::<&<Block as BlockT>::Header>(),
+					}],
+					output: meta_type::<()>(),
+					docs: maybe_docs(vec![" Initialize a block with the given header."]),
+				},
+			],
+			docs: maybe_docs(vec![
+				" The `Core` runtime api that every Substrate runtime needs to implement.",
+			]),
+		},
+	];
+
+	let rt = Runtime;
+	let runtime_metadata = (&rt).runtime_metadata();
+	pretty_assertions::assert_eq!(runtime_metadata, expected_runtime_metadata);
+}
diff --git a/substrate/frame/support/test/tests/split_ui.rs b/substrate/frame/support/test/tests/split_ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..14f99b8ecdab1f88778d379e657c3bf7f1f66a70
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui.rs
@@ -0,0 +1,36 @@
+// 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.
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn split_ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if std::env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("SKIP_WASM_BUILD", "1");
+
+	// Deny all warnings since we emit warnings as part of a Pallet's UI.
+	std::env::set_var("RUSTFLAGS", "--deny warnings");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/split_ui/*.rs");
+	t.pass("tests/split_ui/pass/*.rs");
+}
diff --git a/substrate/frame/support/test/tests/split_ui/import_without_pallet.rs b/substrate/frame/support/test/tests/split_ui/import_without_pallet.rs
new file mode 100644
index 0000000000000000000000000000000000000000..874a92e4610986e807370865ab9f4d60f3f4d32f
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/import_without_pallet.rs
@@ -0,0 +1,17 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::pallet_macros::*;
+
+#[pallet_section]
+mod storages {
+	#[pallet::storage]
+	pub type MyStorageMap<T: Config> = StorageMap<_, _, u32, u64>;
+}
+
+#[import_section(storages)]
+pub mod pallet {
+	
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/split_ui/import_without_pallet.stderr b/substrate/frame/support/test/tests/split_ui/import_without_pallet.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0d7b5414b10162623db997d5921971066e5ddab0
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/import_without_pallet.stderr
@@ -0,0 +1,5 @@
+error: `#[import_section]` can only be applied to a valid pallet module
+  --> tests/split_ui/import_without_pallet.rs:12:9
+   |
+12 | pub mod pallet {
+   |         ^^^^^^
diff --git a/substrate/frame/support/test/tests/split_ui/no_section_found.rs b/substrate/frame/support/test/tests/split_ui/no_section_found.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe12c6dc51b7295c5e6aceea784e9c21852b3b05
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/no_section_found.rs
@@ -0,0 +1,29 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::pallet_macros::*;
+
+pub use pallet::*;
+
+#[import_section(storages_dev)]
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			MyStorageMap::<T>::insert(1, 2);
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/split_ui/no_section_found.stderr b/substrate/frame/support/test/tests/split_ui/no_section_found.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e0a9322b188e33372331a2293584744b6898b09f
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/no_section_found.stderr
@@ -0,0 +1,13 @@
+error[E0432]: unresolved import `pallet`
+ --> tests/split_ui/no_section_found.rs:5:9
+  |
+5 | pub use pallet::*;
+  |         ^^^^^^ help: a similar path exists: `test_pallet::pallet`
+
+error: cannot find macro `__export_tokens_tt_storages_dev` in this scope
+ --> tests/split_ui/no_section_found.rs:7:1
+  |
+7 | #[import_section(storages_dev)]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: this error originates in the macro `frame_support::macro_magic::forward_tokens` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/frame/support/test/tests/split_ui/pass/split_valid.rs b/substrate/frame/support/test/tests/split_ui/pass/split_valid.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8b5839ecd28a00c67fa7f8c84186ecdd43e5c413
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/pass/split_valid.rs
@@ -0,0 +1,40 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::pallet_macros::*;
+
+pub use pallet::*;
+
+#[pallet_section]
+mod events {
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		SomethingDone,
+	}
+}
+
+#[import_section(events)]
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			Self::deposit_event(Event::SomethingDone);
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/split_ui/pass/split_valid_disambiguation.rs b/substrate/frame/support/test/tests/split_ui/pass/split_valid_disambiguation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8d8d50422e9ce46ac101bfaf517a149b1f619e83
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/pass/split_valid_disambiguation.rs
@@ -0,0 +1,61 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::pallet_macros::*;
+
+pub use pallet::*;
+
+mod first {
+	use super::*;
+
+	#[pallet_section]
+	mod section {
+		#[pallet::event]
+		#[pallet::generate_deposit(pub(super) fn deposit_event)]
+		pub enum Event<T: Config> {
+			SomethingDone,
+		}
+	}
+}
+
+mod second {
+	use super::*;
+	
+	#[pallet_section(section2)]
+	mod section {
+		#[pallet::error]
+		pub enum Error<T> {
+			NoneValue,
+		}
+	}
+}
+
+#[import_section(first::section)]
+#[import_section(second::section2)]
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			Self::deposit_event(Event::SomethingDone);
+			Ok(())
+		}
+
+		pub fn my_call_2(_origin: OriginFor<T>) -> DispatchResult {
+			return Err(Error::<T>::NoneValue.into())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/split_ui/section_not_imported.rs b/substrate/frame/support/test/tests/split_ui/section_not_imported.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bcabf66256771696f17ac00bc81457b7ad3713a6
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/section_not_imported.rs
@@ -0,0 +1,34 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::pallet_macros::*;
+
+pub use pallet::*;
+
+#[pallet_section]
+mod storages {
+	#[pallet::storage]
+	pub type MyStorageMap<T: Config> = StorageMap<_, _, u32, u64>;
+}
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		pub fn my_call(_origin: OriginFor<T>) -> DispatchResult {
+			MyStorageMap::<T>::insert(1, 2);
+			Ok(())
+		}
+	}
+}
+
+fn main() {
+}
diff --git a/substrate/frame/support/test/tests/split_ui/section_not_imported.stderr b/substrate/frame/support/test/tests/split_ui/section_not_imported.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..41ac2a5f58d253b0b6a51d8706e3e64a531cfb79
--- /dev/null
+++ b/substrate/frame/support/test/tests/split_ui/section_not_imported.stderr
@@ -0,0 +1,8 @@
+error[E0433]: failed to resolve: use of undeclared type `MyStorageMap`
+  --> tests/split_ui/section_not_imported.rs:27:4
+   |
+27 |             MyStorageMap::<T>::insert(1, 2);
+   |             ^^^^^^^^^^^^
+   |             |
+   |             use of undeclared type `MyStorageMap`
+   |             help: a struct with a similar name exists: `StorageMap`
diff --git a/substrate/frame/support/test/tests/storage_alias_ui.rs b/substrate/frame/support/test/tests/storage_alias_ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b82acd8f3be43aca96aec941b263fbf715212d54
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_alias_ui.rs
@@ -0,0 +1,32 @@
+// 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.
+
+#[rustversion::attr(not(stable), ignore)]
+#[cfg(not(feature = "disable-ui-tests"))]
+#[test]
+fn storage_alias_ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if std::env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	std::env::set_var("SKIP_WASM_BUILD", "1");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/storage_alias_ui/*.rs");
+}
diff --git a/substrate/frame/support/test/tests/storage_alias_ui/checks_for_valid_storage_type.rs b/substrate/frame/support/test/tests/storage_alias_ui/checks_for_valid_storage_type.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4ed9d5adfec77f1ea9bb7de1c143a767a3a420bf
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_alias_ui/checks_for_valid_storage_type.rs
@@ -0,0 +1,4 @@
+#[frame_support::storage_alias]
+type Ident = StorageValue<hello::World, u32>;
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/storage_alias_ui/checks_for_valid_storage_type.stderr b/substrate/frame/support/test/tests/storage_alias_ui/checks_for_valid_storage_type.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..726efed400715c1d9b4378a52c08056ad989df05
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_alias_ui/checks_for_valid_storage_type.stderr
@@ -0,0 +1,5 @@
+error: If there are no generics, the prefix is only allowed to be an identifier.
+ --> tests/storage_alias_ui/checks_for_valid_storage_type.rs:2:27
+  |
+2 | type Ident = StorageValue<hello::World, u32>;
+  |                           ^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/storage_alias_ui/forbid_underscore_as_prefix.rs b/substrate/frame/support/test/tests/storage_alias_ui/forbid_underscore_as_prefix.rs
new file mode 100644
index 0000000000000000000000000000000000000000..59d8004bbe620eed27573dcb3147534f85d988e5
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_alias_ui/forbid_underscore_as_prefix.rs
@@ -0,0 +1,4 @@
+#[frame_support::storage_alias]
+type Ident = CustomStorage<Hello, u32>;
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/storage_alias_ui/forbid_underscore_as_prefix.stderr b/substrate/frame/support/test/tests/storage_alias_ui/forbid_underscore_as_prefix.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..3b5e3e9c23cca0353c0f497f6e3eb33ebaa919b4
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_alias_ui/forbid_underscore_as_prefix.stderr
@@ -0,0 +1,5 @@
+error: expected one of: `StorageValue`, `StorageMap`, `CountedStorageMap`, `StorageDoubleMap`, `StorageNMap`
+ --> tests/storage_alias_ui/forbid_underscore_as_prefix.rs:2:14
+  |
+2 | type Ident = CustomStorage<Hello, u32>;
+  |              ^^^^^^^^^^^^^
diff --git a/substrate/frame/support/test/tests/storage_alias_ui/prefix_must_be_an_ident.rs b/substrate/frame/support/test/tests/storage_alias_ui/prefix_must_be_an_ident.rs
new file mode 100644
index 0000000000000000000000000000000000000000..79328268dc925d7f6812474fb59ec53580bef1d6
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_alias_ui/prefix_must_be_an_ident.rs
@@ -0,0 +1,4 @@
+#[frame_support::storage_alias]
+type NoUnderscore = StorageValue<_, u32>;
+
+fn main() {}
diff --git a/substrate/frame/support/test/tests/storage_alias_ui/prefix_must_be_an_ident.stderr b/substrate/frame/support/test/tests/storage_alias_ui/prefix_must_be_an_ident.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..abb7bf2518f4f3cb6c158a1d0077f053c25f4141
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_alias_ui/prefix_must_be_an_ident.stderr
@@ -0,0 +1,5 @@
+error: `_` is not allowed as prefix by `storage_alias`.
+ --> tests/storage_alias_ui/prefix_must_be_an_ident.rs:2:34
+  |
+2 | type NoUnderscore = StorageValue<_, u32>;
+  |                                  ^
diff --git a/substrate/frame/support/test/tests/storage_layers.rs b/substrate/frame/support/test/tests/storage_layers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b825c85f9564c12924222af10baa1d6e5e1e7e35
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_layers.rs
@@ -0,0 +1,240 @@
+// 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_support::{
+	assert_noop, assert_ok, dispatch::DispatchResult, ensure, pallet_prelude::ConstU32,
+	storage::with_storage_layer,
+};
+use pallet::*;
+use sp_io::TestExternalities;
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::storage]
+	pub type Value<T> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::storage]
+	pub type Map<T> = StorageMap<_, Blake2_128Concat, u32, u32, ValueQuery>;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		Revert,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight(1)]
+		pub fn set_value(_origin: OriginFor<T>, value: u32) -> DispatchResult {
+			Value::<T>::put(value);
+			ensure!(value != 1, Error::<T>::Revert);
+			Ok(())
+		}
+	}
+}
+
+pub type BlockNumber = u32;
+pub type Nonce = u64;
+pub type AccountId = u64;
+pub type Header = sp_runtime::generic::Header<BlockNumber, sp_runtime::traits::BlakeTwo256>;
+pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<u32, RuntimeCall, (), ()>;
+pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
+
+impl frame_system::Config for Runtime {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Nonce = Nonce;
+	type Hash = sp_runtime::testing::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 = ConstU32<250>;
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = ();
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl Config for Runtime {}
+
+frame_support::construct_runtime!(
+	pub struct Runtime {
+		System: frame_system,
+		MyPallet: pallet,
+	}
+);
+
+#[test]
+fn storage_layer_basic_commit() {
+	TestExternalities::default().execute_with(|| {
+		assert_eq!(Value::<Runtime>::get(), 0);
+		assert!(!Map::<Runtime>::contains_key(0));
+
+		assert_ok!(with_storage_layer(|| -> DispatchResult {
+			Value::<Runtime>::set(99);
+			Map::<Runtime>::insert(0, 99);
+			assert_eq!(Value::<Runtime>::get(), 99);
+			assert_eq!(Map::<Runtime>::get(0), 99);
+			Ok(())
+		}));
+
+		assert_eq!(Value::<Runtime>::get(), 99);
+		assert_eq!(Map::<Runtime>::get(0), 99);
+	});
+}
+
+#[test]
+fn storage_layer_basic_rollback() {
+	TestExternalities::default().execute_with(|| {
+		assert_eq!(Value::<Runtime>::get(), 0);
+		assert_eq!(Map::<Runtime>::get(0), 0);
+
+		assert_noop!(
+			with_storage_layer(|| -> DispatchResult {
+				Value::<Runtime>::set(99);
+				Map::<Runtime>::insert(0, 99);
+				assert_eq!(Value::<Runtime>::get(), 99);
+				assert_eq!(Map::<Runtime>::get(0), 99);
+				Err("revert".into())
+			}),
+			"revert"
+		);
+
+		assert_eq!(Value::<Runtime>::get(), 0);
+		assert_eq!(Map::<Runtime>::get(0), 0);
+	});
+}
+
+#[test]
+fn storage_layer_rollback_then_commit() {
+	TestExternalities::default().execute_with(|| {
+		Value::<Runtime>::set(1);
+		Map::<Runtime>::insert(1, 1);
+
+		assert_ok!(with_storage_layer(|| -> DispatchResult {
+			Value::<Runtime>::set(2);
+			Map::<Runtime>::insert(1, 2);
+			Map::<Runtime>::insert(2, 2);
+
+			assert_noop!(
+				with_storage_layer(|| -> DispatchResult {
+					Value::<Runtime>::set(3);
+					Map::<Runtime>::insert(1, 3);
+					Map::<Runtime>::insert(2, 3);
+					Map::<Runtime>::insert(3, 3);
+
+					assert_eq!(Value::<Runtime>::get(), 3);
+					assert_eq!(Map::<Runtime>::get(1), 3);
+					assert_eq!(Map::<Runtime>::get(2), 3);
+					assert_eq!(Map::<Runtime>::get(3), 3);
+
+					Err("revert".into())
+				}),
+				"revert"
+			);
+
+			assert_eq!(Value::<Runtime>::get(), 2);
+			assert_eq!(Map::<Runtime>::get(1), 2);
+			assert_eq!(Map::<Runtime>::get(2), 2);
+			assert_eq!(Map::<Runtime>::get(3), 0);
+
+			Ok(())
+		}));
+
+		assert_eq!(Value::<Runtime>::get(), 2);
+		assert_eq!(Map::<Runtime>::get(1), 2);
+		assert_eq!(Map::<Runtime>::get(2), 2);
+		assert_eq!(Map::<Runtime>::get(3), 0);
+	});
+}
+
+#[test]
+fn storage_layer_commit_then_rollback() {
+	TestExternalities::default().execute_with(|| {
+		Value::<Runtime>::set(1);
+		Map::<Runtime>::insert(1, 1);
+
+		assert_noop!(
+			with_storage_layer(|| -> DispatchResult {
+				Value::<Runtime>::set(2);
+				Map::<Runtime>::insert(1, 2);
+				Map::<Runtime>::insert(2, 2);
+
+				assert_ok!(with_storage_layer(|| -> DispatchResult {
+					Value::<Runtime>::set(3);
+					Map::<Runtime>::insert(1, 3);
+					Map::<Runtime>::insert(2, 3);
+					Map::<Runtime>::insert(3, 3);
+
+					assert_eq!(Value::<Runtime>::get(), 3);
+					assert_eq!(Map::<Runtime>::get(1), 3);
+					assert_eq!(Map::<Runtime>::get(2), 3);
+					assert_eq!(Map::<Runtime>::get(3), 3);
+
+					Ok(())
+				}));
+
+				assert_eq!(Value::<Runtime>::get(), 3);
+				assert_eq!(Map::<Runtime>::get(1), 3);
+				assert_eq!(Map::<Runtime>::get(2), 3);
+				assert_eq!(Map::<Runtime>::get(3), 3);
+
+				Err("revert".into())
+			}),
+			"revert"
+		);
+
+		assert_eq!(Value::<Runtime>::get(), 1);
+		assert_eq!(Map::<Runtime>::get(1), 1);
+		assert_eq!(Map::<Runtime>::get(2), 0);
+		assert_eq!(Map::<Runtime>::get(3), 0);
+	});
+}
+
+#[test]
+fn storage_layer_in_pallet_call() {
+	TestExternalities::default().execute_with(|| {
+		use sp_runtime::traits::Dispatchable;
+		let call1 = RuntimeCall::MyPallet(pallet::Call::set_value { value: 2 });
+		assert_ok!(call1.dispatch(RuntimeOrigin::signed(0)));
+		assert_eq!(Value::<Runtime>::get(), 2);
+
+		let call2 = RuntimeCall::MyPallet(pallet::Call::set_value { value: 1 });
+		assert_noop!(call2.dispatch(RuntimeOrigin::signed(0)), Error::<Runtime>::Revert);
+	});
+}
diff --git a/substrate/frame/support/test/tests/storage_transaction.rs b/substrate/frame/support/test/tests/storage_transaction.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c47743308609850ae480f3194773a76c36bbba58
--- /dev/null
+++ b/substrate/frame/support/test/tests/storage_transaction.rs
@@ -0,0 +1,282 @@
+// 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.
+
+// Disable warnings for #\[transactional\] being deprecated.
+#![allow(deprecated)]
+
+use frame_support::{
+	assert_noop, assert_ok, assert_storage_noop, derive_impl,
+	dispatch::DispatchResult,
+	storage::{with_transaction, TransactionOutcome::*},
+	transactional,
+};
+use sp_core::{sr25519, ConstU32};
+use sp_io::TestExternalities;
+use sp_runtime::{
+	generic,
+	traits::{BlakeTwo256, Verify},
+	TransactionOutcome,
+};
+
+pub use self::pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub (super) trait Store)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::weight(0)]
+		#[transactional]
+		pub fn value_commits(_origin: OriginFor<T>, v: u32) -> DispatchResult {
+			<Value<T>>::set(v);
+			Ok(())
+		}
+
+		#[pallet::weight(0)]
+		#[transactional]
+		pub fn value_rollbacks(_origin: OriginFor<T>, v: u32) -> DispatchResult {
+			<Value<T>>::set(v);
+			Err(DispatchError::Other("nah"))
+		}
+	}
+
+	#[pallet::storage]
+	pub type Value<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub type Map<T: Config> = StorageMap<_, Twox64Concat, String, u32, ValueQuery>;
+}
+
+pub type BlockNumber = u32;
+pub type Signature = sr25519::Signature;
+pub type AccountId = <Signature as Verify>::Signer;
+pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
+pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<u32, RuntimeCall, Signature, ()>;
+pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+
+frame_support::construct_runtime!(
+	pub enum Runtime
+
+	{
+		System: frame_system,
+		MyPallet: pallet,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+impl Config for Runtime {}
+
+#[test]
+fn storage_transaction_basic_commit() {
+	TestExternalities::default().execute_with(|| {
+		type Value = pallet::Value<Runtime>;
+		type Map = pallet::Map<Runtime>;
+
+		assert_eq!(Value::get(), 0);
+		assert!(!Map::contains_key("val0"));
+
+		assert_ok!(with_transaction(|| -> TransactionOutcome<DispatchResult> {
+			Value::set(99);
+			Map::insert("val0", 99);
+			assert_eq!(Value::get(), 99);
+			assert_eq!(Map::get("val0"), 99);
+			Commit(Ok(()))
+		}));
+
+		assert_eq!(Value::get(), 99);
+		assert_eq!(Map::get("val0"), 99);
+	});
+}
+
+#[test]
+fn storage_transaction_basic_rollback() {
+	TestExternalities::default().execute_with(|| {
+		type Value = pallet::Value<Runtime>;
+		type Map = pallet::Map<Runtime>;
+
+		assert_eq!(Value::get(), 0);
+		assert_eq!(Map::get("val0"), 0);
+
+		assert_noop!(
+			with_transaction(|| -> TransactionOutcome<DispatchResult> {
+				Value::set(99);
+				Map::insert("val0", 99);
+				assert_eq!(Value::get(), 99);
+				assert_eq!(Map::get("val0"), 99);
+				Rollback(Err("revert".into()))
+			}),
+			"revert"
+		);
+
+		assert_storage_noop!(assert_ok!(with_transaction(
+			|| -> TransactionOutcome<DispatchResult> {
+				Value::set(99);
+				Map::insert("val0", 99);
+				assert_eq!(Value::get(), 99);
+				assert_eq!(Map::get("val0"), 99);
+				Rollback(Ok(()))
+			}
+		)));
+
+		assert_eq!(Value::get(), 0);
+		assert_eq!(Map::get("val0"), 0);
+	});
+}
+
+#[test]
+fn storage_transaction_rollback_then_commit() {
+	TestExternalities::default().execute_with(|| {
+		type Value = pallet::Value<Runtime>;
+		type Map = pallet::Map<Runtime>;
+
+		Value::set(1);
+		Map::insert("val1", 1);
+
+		assert_ok!(with_transaction(|| -> TransactionOutcome<DispatchResult> {
+			Value::set(2);
+			Map::insert("val1", 2);
+			Map::insert("val2", 2);
+
+			assert_noop!(
+				with_transaction(|| -> TransactionOutcome<DispatchResult> {
+					Value::set(3);
+					Map::insert("val1", 3);
+					Map::insert("val2", 3);
+					Map::insert("val3", 3);
+
+					assert_eq!(Value::get(), 3);
+					assert_eq!(Map::get("val1"), 3);
+					assert_eq!(Map::get("val2"), 3);
+					assert_eq!(Map::get("val3"), 3);
+
+					Rollback(Err("revert".into()))
+				}),
+				"revert"
+			);
+
+			assert_eq!(Value::get(), 2);
+			assert_eq!(Map::get("val1"), 2);
+			assert_eq!(Map::get("val2"), 2);
+			assert_eq!(Map::get("val3"), 0);
+
+			Commit(Ok(()))
+		}));
+
+		assert_eq!(Value::get(), 2);
+		assert_eq!(Map::get("val1"), 2);
+		assert_eq!(Map::get("val2"), 2);
+		assert_eq!(Map::get("val3"), 0);
+	});
+}
+
+#[test]
+fn storage_transaction_commit_then_rollback() {
+	TestExternalities::default().execute_with(|| {
+		type Value = pallet::Value<Runtime>;
+		type Map = pallet::Map<Runtime>;
+
+		Value::set(1);
+		Map::insert("val1", 1);
+
+		assert_noop!(
+			with_transaction(|| -> TransactionOutcome<DispatchResult> {
+				Value::set(2);
+				Map::insert("val1", 2);
+				Map::insert("val2", 2);
+
+				assert_ok!(with_transaction(|| -> TransactionOutcome<DispatchResult> {
+					Value::set(3);
+					Map::insert("val1", 3);
+					Map::insert("val2", 3);
+					Map::insert("val3", 3);
+
+					assert_eq!(Value::get(), 3);
+					assert_eq!(Map::get("val1"), 3);
+					assert_eq!(Map::get("val2"), 3);
+					assert_eq!(Map::get("val3"), 3);
+
+					Commit(Ok(()))
+				}));
+
+				assert_eq!(Value::get(), 3);
+				assert_eq!(Map::get("val1"), 3);
+				assert_eq!(Map::get("val2"), 3);
+				assert_eq!(Map::get("val3"), 3);
+
+				Rollback(Err("revert".into()))
+			}),
+			"revert"
+		);
+
+		assert_eq!(Value::get(), 1);
+		assert_eq!(Map::get("val1"), 1);
+		assert_eq!(Map::get("val2"), 0);
+		assert_eq!(Map::get("val3"), 0);
+	});
+}
+
+#[test]
+fn transactional_annotation() {
+	type Value = pallet::Value<Runtime>;
+
+	fn set_value(v: u32) -> DispatchResult {
+		Value::set(v);
+		Ok(())
+	}
+
+	#[transactional]
+	fn value_commits(v: u32) -> Result<u32, &'static str> {
+		set_value(v)?;
+		Ok(v)
+	}
+
+	#[transactional]
+	fn value_rollbacks(v: u32) -> Result<u32, &'static str> {
+		set_value(v)?;
+		Err("nah")?;
+		Ok(v)
+	}
+
+	TestExternalities::default().execute_with(|| {
+		assert_ok!(value_commits(2), 2);
+		assert_eq!(Value::get(), 2);
+
+		assert_noop!(value_rollbacks(3), "nah");
+	});
+}
diff --git a/substrate/frame/support/test/tests/versioned_runtime_upgrade.rs b/substrate/frame/support/test/tests/versioned_runtime_upgrade.rs
new file mode 100644
index 0000000000000000000000000000000000000000..93d87df8ca185ae50041f24c8906f8696836c421
--- /dev/null
+++ b/substrate/frame/support/test/tests/versioned_runtime_upgrade.rs
@@ -0,0 +1,230 @@
+// 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 VersionedRuntimeUpgrade
+
+#![cfg(all(feature = "experimental", feature = "try-runtime"))]
+
+use frame_support::{
+	construct_runtime, derive_impl,
+	migrations::VersionedRuntimeUpgrade,
+	parameter_types,
+	traits::{GetStorageVersion, OnRuntimeUpgrade, StorageVersion},
+	weights::constants::RocksDbWeight,
+};
+use frame_system::Config;
+use sp_core::ConstU64;
+use sp_runtime::BuildStorage;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+#[frame_support::pallet]
+mod dummy_pallet {
+	use frame_support::pallet_prelude::*;
+
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::storage]
+	pub type SomeStorage<T: Config> = StorageValue<_, u32, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		#[serde(skip)]
+		_config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {}
+	}
+}
+
+impl dummy_pallet::Config for Test {}
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>} = 0,
+		DummyPallet: dummy_pallet::{Pallet, Config<T>, Storage} = 1,
+	}
+);
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+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;
+	type PalletInfo = PalletInfo;
+	type OnSetCode = ();
+}
+
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	let storage = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let mut ext: sp_io::TestExternalities = sp_io::TestExternalities::from(storage);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+/// A dummy migration for testing the `VersionedRuntimeUpgrade` trait.
+/// Sets SomeStorage to S.
+struct SomeUnversionedMigration<T: Config, const S: u32>(sp_std::marker::PhantomData<T>);
+
+parameter_types! {
+	const UpgradeReads: u64 = 4;
+	const UpgradeWrites: u64 = 2;
+	const PreUpgradeReturnBytes: [u8; 4] = [0, 1, 2, 3];
+	static PreUpgradeCalled: bool = false;
+	static PostUpgradeCalled: bool = false;
+	static PostUpgradeCalledWith: Vec<u8> = Vec::new();
+}
+
+/// Implement `OnRuntimeUpgrade` for `SomeUnversionedMigration`.
+/// It sets SomeStorage to S, and returns a weight derived from UpgradeReads and UpgradeWrites.
+impl<T: dummy_pallet::Config, const S: u32> OnRuntimeUpgrade for SomeUnversionedMigration<T, S> {
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		PreUpgradeCalled::set(true);
+		Ok(PreUpgradeReturnBytes::get().to_vec())
+	}
+
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		dummy_pallet::SomeStorage::<T>::put(S);
+		RocksDbWeight::get().reads_writes(UpgradeReads::get(), UpgradeWrites::get())
+	}
+
+	fn post_upgrade(state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		PostUpgradeCalled::set(true);
+		PostUpgradeCalledWith::set(state);
+		Ok(())
+	}
+}
+
+type VersionedMigrationV0ToV1 =
+	VersionedRuntimeUpgrade<0, 1, SomeUnversionedMigration<Test, 1>, DummyPallet, RocksDbWeight>;
+
+type VersionedMigrationV1ToV2 =
+	VersionedRuntimeUpgrade<1, 2, SomeUnversionedMigration<Test, 2>, DummyPallet, RocksDbWeight>;
+
+type VersionedMigrationV2ToV4 =
+	VersionedRuntimeUpgrade<2, 4, SomeUnversionedMigration<Test, 4>, DummyPallet, RocksDbWeight>;
+
+#[test]
+fn successful_upgrade_path() {
+	new_test_ext().execute_with(|| {
+		// on-chain storage version and value in storage start at zero
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(0));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 0);
+
+		// Execute the migration from version 0 to 1 and verify it was successful
+		VersionedMigrationV0ToV1::on_runtime_upgrade();
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(1));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 1);
+
+		// Execute the migration from version 1 to 2 and verify it was successful
+		VersionedMigrationV1ToV2::on_runtime_upgrade();
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(2));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 2);
+
+		// Execute the migration from version 2 to 4 and verify it was successful
+		VersionedMigrationV2ToV4::on_runtime_upgrade();
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(4));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 4);
+	});
+}
+
+#[test]
+fn future_version_upgrade_is_ignored() {
+	new_test_ext().execute_with(|| {
+		// Executing V1 to V2 on V0 should be a noop
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(0));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 0);
+		VersionedMigrationV1ToV2::on_runtime_upgrade();
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(0));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 0);
+	});
+}
+
+#[test]
+fn past_version_upgrade_is_ignored() {
+	new_test_ext().execute_with(|| {
+		// Upgrade to V2
+		VersionedMigrationV0ToV1::on_runtime_upgrade();
+		VersionedMigrationV1ToV2::on_runtime_upgrade();
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(2));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 2);
+
+		// Now, V0 to V1 and V1 to V2 should both be noops
+		dummy_pallet::SomeStorage::<Test>::put(1000);
+		VersionedMigrationV0ToV1::on_runtime_upgrade();
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(2));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 1000);
+		VersionedMigrationV1ToV2::on_runtime_upgrade();
+		assert_eq!(DummyPallet::on_chain_storage_version(), StorageVersion::new(2));
+		assert_eq!(dummy_pallet::SomeStorage::<Test>::get(), 1000);
+	});
+}
+
+#[test]
+fn weights_are_returned_correctly() {
+	new_test_ext().execute_with(|| {
+		// Successful upgrade requires 1 additional read and write
+		let weight = VersionedMigrationV0ToV1::on_runtime_upgrade();
+		assert_eq!(
+			weight,
+			RocksDbWeight::get().reads_writes(UpgradeReads::get() + 1, UpgradeWrites::get() + 1)
+		);
+
+		// Noop upgrade requires only 1 read
+		let weight = VersionedMigrationV0ToV1::on_runtime_upgrade();
+		assert_eq!(weight, RocksDbWeight::get().reads(1));
+	});
+}
+
+#[test]
+fn pre_and_post_checks_behave_correctly() {
+	new_test_ext().execute_with(|| {
+		// Check initial state
+		assert_eq!(PreUpgradeCalled::get(), false);
+		assert_eq!(PostUpgradeCalled::get(), false);
+		assert_eq!(PostUpgradeCalledWith::get(), Vec::<u8>::new());
+
+		// Check pre/post hooks are called correctly when upgrade occurs.
+		VersionedMigrationV0ToV1::try_on_runtime_upgrade(true).unwrap();
+		assert_eq!(PreUpgradeCalled::get(), true);
+		assert_eq!(PostUpgradeCalled::get(), true);
+		assert_eq!(PostUpgradeCalledWith::get(), PreUpgradeReturnBytes::get().to_vec());
+
+		// Reset hook tracking state.
+		PreUpgradeCalled::set(false);
+		PostUpgradeCalled::set(false);
+
+		// Check pre/post hooks are not called when an upgrade is skipped.
+		VersionedMigrationV0ToV1::try_on_runtime_upgrade(true).unwrap();
+		assert_eq!(PreUpgradeCalled::get(), false);
+		assert_eq!(PostUpgradeCalled::get(), false);
+	})
+}
diff --git a/substrate/frame/system/Cargo.toml b/substrate/frame/system/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6530862832c3f9ef3f02fe53614bd5c41e2827db
--- /dev/null
+++ b/substrate/frame/system/Cargo.toml
@@ -0,0 +1,58 @@
+[package]
+name = "frame-system"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME system module"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+cfg-if = "1.0"
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive", "serde"] }
+serde = { version = "1.0.163", default-features = false, features = ["derive", "alloc"] }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core", features = ["serde"] }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-version = { version = "22.0.0", default-features = false, path = "../../primitives/version", features = ["serde"] }
+sp-weights = { version = "20.0.0", default-features = false, path = "../../primitives/weights", features = ["serde"] }
+
+[dev-dependencies]
+criterion = "0.4.0"
+sp-externalities = { version = "0.19.0", path = "../../primitives/externalities" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"log/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-version/std",
+	"sp-weights/std",
+]
+runtime-benchmarks = [
+	"frame-support/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [ "frame-support/try-runtime", "sp-runtime/try-runtime" ]
+
+[[bench]]
+name = "bench"
+harness = false
diff --git a/substrate/frame/system/README.md b/substrate/frame/system/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..30b2ea73720cf1fa7af62f5cd82c32fda3f0e3ac
--- /dev/null
+++ b/substrate/frame/system/README.md
@@ -0,0 +1,82 @@
+# System Module
+
+The System module provides low-level access to core types and cross-cutting utilities.
+It acts as the base layer for other pallets to interact with the Substrate framework components.
+
+- [`system::Config`](https://docs.rs/frame-system/latest/frame_system/pallet/trait.Config.html)
+
+## Overview
+
+The System module defines the core data types used in a Substrate runtime.
+It also provides several utility functions (see [`Pallet`](https://docs.rs/frame-system/latest/frame_system/pallet/struct.Pallet.html)) for other FRAME pallets.
+
+In addition, it manages the storage items for extrinsics data, indexes, event records, and digest items,
+among other things that support the execution of the current block.
+
+It also handles low-level tasks like depositing logs, basic set up and take down of
+temporary storage entries, and access to previous block hashes.
+
+## Interface
+
+### Dispatchable Functions
+
+The System module does not implement any dispatchable functions.
+
+### Public Functions
+
+See the [`Pallet`](https://docs.rs/frame-system/latest/frame_system/pallet/struct.Pallet.html) struct for details of publicly available functions.
+
+### Signed Extensions
+
+The System module defines the following extensions:
+
+  - [`CheckWeight`]: Checks the weight and length of the block and ensure that it does not
+    exceed the limits.
+  - [`CheckNonce`]: Checks the nonce of the transaction. Contains a single payload of type
+    `T::Nonce`.
+  - [`CheckEra`]: Checks the era of the transaction. Contains a single payload of type `Era`.
+  - [`CheckGenesis`]: Checks the provided genesis hash of the transaction. Must be a part of the
+    signed payload of the transaction.
+  - [`CheckSpecVersion`]: Checks that the runtime version is the same as the one used to sign the
+    transaction.
+  - [`CheckTxVersion`]: Checks that the transaction version is the same as the one used to sign the
+    transaction.
+
+Lookup the runtime aggregator file (e.g. `node/runtime`) to see the full list of signed
+extensions included in a chain.
+
+## Usage
+
+### Prerequisites
+
+Import the System module and derive your module's configuration trait from the system trait.
+
+### Example - Get extrinsic count and parent hash for the current block
+
+```rust
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config {}
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::weight(0)]
+        pub fn system_module_example(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+            let _extrinsic_count = <system::Pallet<T>>::extrinsic_count();
+            let _parent_hash = <system::Pallet<T>>::parent_hash();
+            Ok(())
+        }
+    }
+}
+```
+
+License: Apache-2.0
diff --git a/substrate/frame/system/benches/bench.rs b/substrate/frame/system/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da8bb10fd4e42a17c995a12b39370c9004777c20
--- /dev/null
+++ b/substrate/frame/system/benches/bench.rs
@@ -0,0 +1,116 @@
+// 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 criterion::{black_box, criterion_group, criterion_main, Criterion};
+use frame_support::traits::{ConstU32, ConstU64};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill,
+};
+#[frame_support::pallet]
+mod module {
+	use frame_support::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		type RuntimeEvent: From<Event> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event {
+		Complex(Vec<u8>, u32, u16, u128),
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Module: module::{Pallet, Event},
+	}
+);
+
+frame_support::parameter_types! {
+	pub BlockLength: frame_system::limits::BlockLength =
+		frame_system::limits::BlockLength::max_with_normal_ratio(
+			4 * 1024 * 1024, Perbill::from_percent(75),
+		);
+}
+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 {
+	type RuntimeEvent = RuntimeEvent;
+}
+
+fn new_test_ext() -> sp_io::TestExternalities {
+	frame_system::GenesisConfig::<Runtime>::default()
+		.build_storage()
+		.unwrap()
+		.into()
+}
+
+fn deposit_events(n: usize) {
+	let mut t = new_test_ext();
+	t.execute_with(|| {
+		for _ in 0..n {
+			module::Pallet::<Runtime>::deposit_event(module::Event::Complex(
+				vec![1, 2, 3],
+				2,
+				3,
+				899,
+			));
+		}
+	});
+}
+
+fn sr_system_benchmark(c: &mut Criterion) {
+	c.bench_function("deposit 100 events", |b| b.iter(|| deposit_events(black_box(100))));
+}
+
+criterion_group!(benches, sr_system_benchmark);
+criterion_main!(benches);
diff --git a/substrate/frame/system/benchmarking/Cargo.toml b/substrate/frame/system/benchmarking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..098edbaa8bcd01bfa4662421e6a30b92c2a3f27b
--- /dev/null
+++ b/substrate/frame/system/benchmarking/Cargo.toml
@@ -0,0 +1,51 @@
+[package]
+name = "frame-system-benchmarking"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME System benchmarking"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+[dev-dependencies]
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+sp-externalities = { version = "0.19.0", path = "../../../primitives/externalities" }
+sp-version = { version = "22.0.0", path = "../../../primitives/version" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-version/std",
+]
+
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
diff --git a/substrate/frame/system/benchmarking/README.md b/substrate/frame/system/benchmarking/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9718db58b37e9ae1c81b5b627fe27e51129cf418
--- /dev/null
+++ b/substrate/frame/system/benchmarking/README.md
@@ -0,0 +1 @@
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/system/benchmarking/res/README.md b/substrate/frame/system/benchmarking/res/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..43bb2b5c283ef895211ed06d8e17fdcb651ab02f
--- /dev/null
+++ b/substrate/frame/system/benchmarking/res/README.md
@@ -0,0 +1,5 @@
+These runtimes are used for benchmarking the `set_code` intrinsic.
+
+**Don't use them in production environments!**
+
+To update the just copy the new runtime from `target/release/wbuild/kitchensink-runtime/kitchensink_runtime.compact.compressed.wasm` to here.
diff --git a/substrate/frame/system/benchmarking/res/kitchensink_runtime.compact.compressed.wasm b/substrate/frame/system/benchmarking/res/kitchensink_runtime.compact.compressed.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..a0d2a4bb04b9132da91d825d844e7d67f5a55408
Binary files /dev/null and b/substrate/frame/system/benchmarking/res/kitchensink_runtime.compact.compressed.wasm differ
diff --git a/substrate/frame/system/benchmarking/src/lib.rs b/substrate/frame/system/benchmarking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d85b631af01850265bbf25404715ed86be90370d
--- /dev/null
+++ b/substrate/frame/system/benchmarking/src/lib.rs
@@ -0,0 +1,169 @@
+// 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.
+
+// Benchmarks for Utility Pallet
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg(feature = "runtime-benchmarks")]
+
+use codec::Encode;
+use frame_benchmarking::{
+	v1::{benchmarks, whitelisted_caller},
+	BenchmarkError,
+};
+use frame_support::{dispatch::DispatchClass, storage, traits::Get};
+use frame_system::{Call, Pallet as System, RawOrigin};
+use sp_core::storage::well_known_keys;
+use sp_runtime::traits::Hash;
+use sp_std::{prelude::*, vec};
+
+mod mock;
+
+pub struct Pallet<T: Config>(System<T>);
+pub trait Config: frame_system::Config {
+	/// Adds ability to the Runtime to test against their sample code.
+	///
+	/// Default is `../res/kitchensink_runtime.compact.compressed.wasm`.
+	fn prepare_set_code_data() -> Vec<u8> {
+		include_bytes!("../res/kitchensink_runtime.compact.compressed.wasm").to_vec()
+	}
+
+	/// Adds ability to the Runtime to prepare/initialize before running benchmark `set_code`.
+	fn setup_set_code_requirements(_code: &Vec<u8>) -> Result<(), BenchmarkError> {
+		Ok(())
+	}
+
+	/// Adds ability to the Runtime to do custom validation after benchmark.
+	///
+	/// Default is checking for `CodeUpdated` event .
+	fn verify_set_code() {
+		System::<Self>::assert_last_event(frame_system::Event::<Self>::CodeUpdated.into());
+	}
+}
+
+benchmarks! {
+	remark {
+		let b in 0 .. *T::BlockLength::get().max.get(DispatchClass::Normal) as u32;
+		let remark_message = vec![1; b as usize];
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), remark_message)
+
+	remark_with_event {
+		let b in 0 .. *T::BlockLength::get().max.get(DispatchClass::Normal) as u32;
+		let remark_message = vec![1; b as usize];
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), remark_message)
+
+	set_heap_pages {
+	}: _(RawOrigin::Root, Default::default())
+
+	set_code {
+		let runtime_blob = T::prepare_set_code_data();
+		T::setup_set_code_requirements(&runtime_blob)?;
+	}: _(RawOrigin::Root, runtime_blob)
+	verify {
+		T::verify_set_code()
+	}
+
+	#[extra]
+	set_code_without_checks {
+		// Assume Wasm ~4MB
+		let code = vec![1; 4_000_000 as usize];
+		T::setup_set_code_requirements(&code)?;
+	}: _(RawOrigin::Root, code)
+	verify {
+		let current_code = storage::unhashed::get_raw(well_known_keys::CODE).ok_or("Code not stored.")?;
+		assert_eq!(current_code.len(), 4_000_000 as usize);
+	}
+
+	#[skip_meta]
+	set_storage {
+		let i in 0 .. 1000;
+
+		// Set up i items to add
+		let mut items = Vec::new();
+		for j in 0 .. i {
+			let hash = (i, j).using_encoded(T::Hashing::hash).as_ref().to_vec();
+			items.push((hash.clone(), hash.clone()));
+		}
+
+		let items_to_verify = items.clone();
+	}: _(RawOrigin::Root, items)
+	verify {
+		// Verify that they're actually in the storage.
+		for (item, _) in items_to_verify {
+			let value = storage::unhashed::get_raw(&item).ok_or("No value stored")?;
+			assert_eq!(value, *item);
+		}
+	}
+
+	#[skip_meta]
+	kill_storage {
+		let i in 0 .. 1000;
+
+		// Add i items to storage
+		let mut items = Vec::with_capacity(i as usize);
+		for j in 0 .. i {
+			let hash = (i, j).using_encoded(T::Hashing::hash).as_ref().to_vec();
+			storage::unhashed::put_raw(&hash, &hash);
+			items.push(hash);
+		}
+
+		// Verify that they're actually in the storage.
+		for item in &items {
+			let value = storage::unhashed::get_raw(item).ok_or("No value stored")?;
+			assert_eq!(value, *item);
+		}
+
+		let items_to_verify = items.clone();
+	}: _(RawOrigin::Root, items)
+	verify {
+		// Verify that they're not in the storage anymore.
+		for item in items_to_verify {
+			assert!(storage::unhashed::get_raw(&item).is_none());
+		}
+	}
+
+	#[skip_meta]
+	kill_prefix {
+		let p in 0 .. 1000;
+
+		let prefix = p.using_encoded(T::Hashing::hash).as_ref().to_vec();
+		let mut items = Vec::with_capacity(p as usize);
+		// add p items that share a prefix
+		for i in 0 .. p {
+			let hash = (p, i).using_encoded(T::Hashing::hash).as_ref().to_vec();
+			let key = [&prefix[..], &hash[..]].concat();
+			storage::unhashed::put_raw(&key, &key);
+			items.push(key);
+		}
+
+		// Verify that they're actually in the storage.
+		for item in &items {
+			let value = storage::unhashed::get_raw(item).ok_or("No value stored")?;
+			assert_eq!(value, *item);
+		}
+	}: _(RawOrigin::Root, prefix, p)
+	verify {
+		// Verify that they're not in the storage anymore.
+		for item in items {
+			assert!(storage::unhashed::get_raw(&item).is_none());
+		}
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/system/benchmarking/src/mock.rs b/substrate/frame/system/benchmarking/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e6b1221da35613a242f3b0388ba8f26d7f3b537
--- /dev/null
+++ b/substrate/frame/system/benchmarking/src/mock.rs
@@ -0,0 +1,90 @@
+// 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.
+
+//! Mock file for system benchmarking.
+
+#![cfg(test)]
+
+use codec::Encode;
+use sp_runtime::{traits::IdentityLookup, BuildStorage};
+
+type AccountId = u64;
+type Nonce = u32;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+	}
+);
+
+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 {}
+
+struct MockedReadRuntimeVersion(Vec<u8>);
+
+impl sp_core::traits::ReadRuntimeVersion for MockedReadRuntimeVersion {
+	fn read_runtime_version(
+		&self,
+		_wasm_code: &[u8],
+		_ext: &mut dyn sp_externalities::Externalities,
+	) -> Result<Vec<u8>, String> {
+		Ok(self.0.clone())
+	}
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let version = sp_version::RuntimeVersion {
+		spec_name: "spec_name".into(),
+		spec_version: 123,
+		impl_version: 456,
+		..Default::default()
+	};
+	let read_runtime_version = MockedReadRuntimeVersion(version.encode());
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.register_extension(sp_core::traits::ReadRuntimeVersionExt::new(read_runtime_version));
+	ext
+}
diff --git a/substrate/frame/system/rpc/runtime-api/Cargo.toml b/substrate/frame/system/rpc/runtime-api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ec8348123cbb8a47ed84efbcfe7ac12ee5696e69
--- /dev/null
+++ b/substrate/frame/system/rpc/runtime-api/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "frame-system-rpc-runtime-api"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Runtime API definition required by System RPC extensions."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../../primitives/api" }
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "sp-api/std" ]
diff --git a/substrate/frame/system/rpc/runtime-api/README.md b/substrate/frame/system/rpc/runtime-api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ab46c22a8be3345b13dc4674f3234cb8f511851b
--- /dev/null
+++ b/substrate/frame/system/rpc/runtime-api/README.md
@@ -0,0 +1,7 @@
+Runtime API definition required by System RPC extensions.
+
+This API should be imported and implemented by the runtime,
+of a node that wants to use the custom RPC extension
+adding System access methods.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/frame/system/rpc/runtime-api/src/lib.rs b/substrate/frame/system/rpc/runtime-api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f59988d818f07d716b153839c072513a2a6ad746
--- /dev/null
+++ b/substrate/frame/system/rpc/runtime-api/src/lib.rs
@@ -0,0 +1,35 @@
+// 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.
+
+//! Runtime API definition required by System RPC extensions.
+//!
+//! This API should be imported and implemented by the runtime,
+//! of a node that wants to use the custom RPC extension
+//! adding System access methods.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+sp_api::decl_runtime_apis! {
+	/// The API to query account nonce.
+	pub trait AccountNonceApi<AccountId, Nonce> where
+		AccountId: codec::Codec,
+		Nonce: codec::Codec,
+	{
+		/// Get current account nonce of given `AccountId`.
+		fn account_nonce(account: AccountId) -> Nonce;
+	}
+}
diff --git a/substrate/frame/system/src/extensions/check_genesis.rs b/substrate/frame/system/src/extensions/check_genesis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76a711a823e7d7a4b1092d9220b846584b21603f
--- /dev/null
+++ b/substrate/frame/system/src/extensions/check_genesis.rs
@@ -0,0 +1,75 @@
+// 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::{pallet_prelude::BlockNumberFor, Config, Pallet};
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, SignedExtension, Zero},
+	transaction_validity::TransactionValidityError,
+};
+
+/// Genesis hash check to provide replay protection between different networks.
+///
+/// # Transaction Validity
+///
+/// Note that while a transaction with invalid `genesis_hash` will fail to be decoded,
+/// the extension does not affect any other fields of `TransactionValidity` directly.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckGenesis<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckGenesis<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckGenesis")
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> CheckGenesis<T> {
+	/// Creates new `SignedExtension` to check genesis hash.
+	pub fn new() -> Self {
+		Self(sp_std::marker::PhantomData)
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckGenesis<T> {
+	type AccountId = T::AccountId;
+	type Call = <T as Config>::RuntimeCall;
+	type AdditionalSigned = T::Hash;
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckGenesis";
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(<Pallet<T>>::block_hash(BlockNumberFor::<T>::zero()))
+	}
+
+	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/system/src/extensions/check_mortality.rs b/substrate/frame/system/src/extensions/check_mortality.rs
new file mode 100644
index 0000000000000000000000000000000000000000..148dfd4aad471b8a51aa3106581531b17090c20a
--- /dev/null
+++ b/substrate/frame/system/src/extensions/check_mortality.rs
@@ -0,0 +1,148 @@
+// 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::{pallet_prelude::BlockNumberFor, BlockHash, Config, Pallet};
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	generic::Era,
+	traits::{DispatchInfoOf, SaturatedConversion, SignedExtension},
+	transaction_validity::{
+		InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+	},
+};
+
+/// Check for transaction mortality.
+///
+/// # Transaction Validity
+///
+/// The extension affects `longevity` of the transaction according to the [`Era`] definition.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckMortality<T: Config + Send + Sync>(pub Era, sp_std::marker::PhantomData<T>);
+
+impl<T: Config + Send + Sync> CheckMortality<T> {
+	/// utility constructor. Used only in client/factory code.
+	pub fn from(era: Era) -> Self {
+		Self(era, sp_std::marker::PhantomData)
+	}
+}
+
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckMortality<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckMortality({:?})", self.0)
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckMortality<T> {
+	type AccountId = T::AccountId;
+	type Call = T::RuntimeCall;
+	type AdditionalSigned = T::Hash;
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckMortality";
+
+	fn validate(
+		&self,
+		_who: &Self::AccountId,
+		_call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		let current_u64 = <Pallet<T>>::block_number().saturated_into::<u64>();
+		let valid_till = self.0.death(current_u64);
+		Ok(ValidTransaction {
+			longevity: valid_till.saturating_sub(current_u64),
+			..Default::default()
+		})
+	}
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		let current_u64 = <Pallet<T>>::block_number().saturated_into::<u64>();
+		let n = self.0.birth(current_u64).saturated_into::<BlockNumberFor<T>>();
+		if !<BlockHash<T>>::contains_key(n) {
+			Err(InvalidTransaction::AncientBirthBlock.into())
+		} else {
+			Ok(<Pallet<T>>::block_hash(n))
+		}
+	}
+
+	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(|_| ())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, System, Test, CALL};
+	use frame_support::{
+		dispatch::{DispatchClass, DispatchInfo, Pays},
+		weights::Weight,
+	};
+	use sp_core::H256;
+
+	#[test]
+	fn signed_ext_check_era_should_work() {
+		new_test_ext().execute_with(|| {
+			// future
+			assert_eq!(
+				CheckMortality::<Test>::from(Era::mortal(4, 2))
+					.additional_signed()
+					.err()
+					.unwrap(),
+				InvalidTransaction::AncientBirthBlock.into(),
+			);
+
+			// correct
+			System::set_block_number(13);
+			<BlockHash<Test>>::insert(12, H256::repeat_byte(1));
+			assert!(CheckMortality::<Test>::from(Era::mortal(4, 12)).additional_signed().is_ok());
+		})
+	}
+
+	#[test]
+	fn signed_ext_check_era_should_change_longevity() {
+		new_test_ext().execute_with(|| {
+			let normal = DispatchInfo {
+				weight: Weight::from_parts(100, 0),
+				class: DispatchClass::Normal,
+				pays_fee: Pays::Yes,
+			};
+			let len = 0_usize;
+			let ext = (
+				crate::CheckWeight::<Test>::new(),
+				CheckMortality::<Test>::from(Era::mortal(16, 256)),
+			);
+			System::set_block_number(17);
+			<BlockHash<Test>>::insert(16, H256::repeat_byte(1));
+
+			assert_eq!(ext.validate(&1, CALL, &normal, len).unwrap().longevity, 15);
+		})
+	}
+}
diff --git a/substrate/frame/system/src/extensions/check_non_zero_sender.rs b/substrate/frame/system/src/extensions/check_non_zero_sender.rs
new file mode 100644
index 0000000000000000000000000000000000000000..92eed60fc66b53dec19a86c1fac20f1af8ff4d7b
--- /dev/null
+++ b/substrate/frame/system/src/extensions/check_non_zero_sender.rs
@@ -0,0 +1,110 @@
+// 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::Config;
+use codec::{Decode, Encode};
+use frame_support::{dispatch::DispatchInfo, DefaultNoBound};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, Dispatchable, SignedExtension},
+	transaction_validity::{
+		InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+	},
+};
+use sp_std::{marker::PhantomData, prelude::*};
+
+/// Check to ensure that the sender is not the zero address.
+#[derive(Encode, Decode, DefaultNoBound, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckNonZeroSender<T>(PhantomData<T>);
+
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckNonZeroSender<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckNonZeroSender")
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> CheckNonZeroSender<T> {
+	/// Create new `SignedExtension` to check runtime version.
+	pub fn new() -> Self {
+		Self(sp_std::marker::PhantomData)
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckNonZeroSender<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+{
+	type AccountId = T::AccountId;
+	type Call = T::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckNonZeroSender";
+
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	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(|_| ())
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		_call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		if who.using_encoded(|d| d.iter().all(|x| *x == 0)) {
+			return Err(TransactionValidityError::Invalid(InvalidTransaction::BadSigner))
+		}
+		Ok(ValidTransaction::default())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, Test, CALL};
+	use frame_support::{assert_noop, assert_ok};
+
+	#[test]
+	fn zero_account_ban_works() {
+		new_test_ext().execute_with(|| {
+			let info = DispatchInfo::default();
+			let len = 0_usize;
+			assert_noop!(
+				CheckNonZeroSender::<Test>::new().validate(&0, CALL, &info, len),
+				InvalidTransaction::BadSigner
+			);
+			assert_ok!(CheckNonZeroSender::<Test>::new().validate(&1, CALL, &info, len));
+		})
+	}
+}
diff --git a/substrate/frame/system/src/extensions/check_nonce.rs b/substrate/frame/system/src/extensions/check_nonce.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2939fd6534c09c7e5b59816b821d781966273e81
--- /dev/null
+++ b/substrate/frame/system/src/extensions/check_nonce.rs
@@ -0,0 +1,167 @@
+// 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::Config;
+use codec::{Decode, Encode};
+use frame_support::dispatch::DispatchInfo;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, Dispatchable, One, SignedExtension},
+	transaction_validity::{
+		InvalidTransaction, TransactionLongevity, TransactionValidity, TransactionValidityError,
+		ValidTransaction,
+	},
+};
+use sp_std::vec;
+
+/// Nonce check and increment to give replay protection for transactions.
+///
+/// # Transaction Validity
+///
+/// This extension affects `requires` and `provides` tags of validity, but DOES NOT
+/// set the `priority` field. Make sure that AT LEAST one of the signed extension sets
+/// some kind of priority upon validating transactions.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckNonce<T: Config>(#[codec(compact)] pub T::Nonce);
+
+impl<T: Config> CheckNonce<T> {
+	/// utility constructor. Used only in client/factory code.
+	pub fn from(nonce: T::Nonce) -> Self {
+		Self(nonce)
+	}
+}
+
+impl<T: Config> sp_std::fmt::Debug for CheckNonce<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckNonce({})", self.0)
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config> SignedExtension for CheckNonce<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+{
+	type AccountId = T::AccountId;
+	type Call = T::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckNonce";
+
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		_call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> Result<(), TransactionValidityError> {
+		let mut account = crate::Account::<T>::get(who);
+		if self.0 != account.nonce {
+			return Err(if self.0 < account.nonce {
+				InvalidTransaction::Stale
+			} else {
+				InvalidTransaction::Future
+			}
+			.into())
+		}
+		account.nonce += T::Nonce::one();
+		crate::Account::<T>::insert(who, account);
+		Ok(())
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		_call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		// check index
+		let account = crate::Account::<T>::get(who);
+		if self.0 < account.nonce {
+			return InvalidTransaction::Stale.into()
+		}
+
+		let provides = vec![Encode::encode(&(who, self.0))];
+		let requires = if account.nonce < self.0 {
+			vec![Encode::encode(&(who, self.0 - One::one()))]
+		} else {
+			vec![]
+		};
+
+		Ok(ValidTransaction {
+			priority: 0,
+			requires,
+			provides,
+			longevity: TransactionLongevity::max_value(),
+			propagate: true,
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{new_test_ext, Test, CALL};
+	use frame_support::{assert_noop, assert_ok};
+
+	#[test]
+	fn signed_ext_check_nonce_works() {
+		new_test_ext().execute_with(|| {
+			crate::Account::<Test>::insert(
+				1,
+				crate::AccountInfo {
+					nonce: 1,
+					consumers: 0,
+					providers: 0,
+					sufficients: 0,
+					data: 0,
+				},
+			);
+			let info = DispatchInfo::default();
+			let len = 0_usize;
+			// stale
+			assert_noop!(
+				CheckNonce::<Test>(0).validate(&1, CALL, &info, len),
+				InvalidTransaction::Stale
+			);
+			assert_noop!(
+				CheckNonce::<Test>(0).pre_dispatch(&1, CALL, &info, len),
+				InvalidTransaction::Stale
+			);
+			// correct
+			assert_ok!(CheckNonce::<Test>(1).validate(&1, CALL, &info, len));
+			assert_ok!(CheckNonce::<Test>(1).pre_dispatch(&1, CALL, &info, len));
+			// future
+			assert_ok!(CheckNonce::<Test>(5).validate(&1, CALL, &info, len));
+			assert_noop!(
+				CheckNonce::<Test>(5).pre_dispatch(&1, CALL, &info, len),
+				InvalidTransaction::Future
+			);
+		})
+	}
+}
diff --git a/substrate/frame/system/src/extensions/check_spec_version.rs b/substrate/frame/system/src/extensions/check_spec_version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..24d5ef9cafb17b0dd8c1ac02fc127f7068cf6cca
--- /dev/null
+++ b/substrate/frame/system/src/extensions/check_spec_version.rs
@@ -0,0 +1,75 @@
+// 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::{Config, Pallet};
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, SignedExtension},
+	transaction_validity::TransactionValidityError,
+};
+
+/// Ensure the runtime version registered in the transaction is the same as at present.
+///
+/// # Transaction Validity
+///
+/// The transaction with incorrect `spec_version` are considered invalid. The validity
+/// is not affected in any other way.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckSpecVersion<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckSpecVersion<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckSpecVersion")
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> CheckSpecVersion<T> {
+	/// Create new `SignedExtension` to check runtime version.
+	pub fn new() -> Self {
+		Self(sp_std::marker::PhantomData)
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckSpecVersion<T> {
+	type AccountId = T::AccountId;
+	type Call = <T as Config>::RuntimeCall;
+	type AdditionalSigned = u32;
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckSpecVersion";
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(<Pallet<T>>::runtime_version().spec_version)
+	}
+
+	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/system/src/extensions/check_tx_version.rs b/substrate/frame/system/src/extensions/check_tx_version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3f9d6a1903fe1d08d05266a46625aeacba3c273c
--- /dev/null
+++ b/substrate/frame/system/src/extensions/check_tx_version.rs
@@ -0,0 +1,74 @@
+// 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::{Config, Pallet};
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, SignedExtension},
+	transaction_validity::TransactionValidityError,
+};
+
+/// Ensure the transaction version registered in the transaction is the same as at present.
+///
+/// # Transaction Validity
+///
+/// The transaction with incorrect `transaction_version` are considered invalid. The validity
+/// is not affected in any other way.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckTxVersion<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckTxVersion<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckTxVersion")
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> CheckTxVersion<T> {
+	/// Create new `SignedExtension` to check transaction version.
+	pub fn new() -> Self {
+		Self(sp_std::marker::PhantomData)
+	}
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckTxVersion<T> {
+	type AccountId = T::AccountId;
+	type Call = <T as Config>::RuntimeCall;
+	type AdditionalSigned = u32;
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckTxVersion";
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(<Pallet<T>>::runtime_version().transaction_version)
+	}
+	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/system/src/extensions/check_weight.rs b/substrate/frame/system/src/extensions/check_weight.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1030c8daf7b0464aff46a1020e83b3b7c9831b16
--- /dev/null
+++ b/substrate/frame/system/src/extensions/check_weight.rs
@@ -0,0 +1,714 @@
+// 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::{limits::BlockWeights, Config, Pallet};
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{DispatchInfo, PostDispatchInfo},
+	traits::Get,
+};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension},
+	transaction_validity::{InvalidTransaction, TransactionValidity, TransactionValidityError},
+	DispatchResult,
+};
+use sp_weights::Weight;
+
+/// Block resource (weight) limit check.
+///
+/// # Transaction Validity
+///
+/// This extension does not influence any fields of `TransactionValidity` in case the
+/// transaction is valid.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, Default, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct CheckWeight<T: Config + Send + Sync>(sp_std::marker::PhantomData<T>);
+
+impl<T: Config + Send + Sync> CheckWeight<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+{
+	/// Checks if the current extrinsic does not exceed the maximum weight a single extrinsic
+	/// with given `DispatchClass` can have.
+	fn check_extrinsic_weight(
+		info: &DispatchInfoOf<T::RuntimeCall>,
+	) -> Result<(), TransactionValidityError> {
+		let max = T::BlockWeights::get().get(info.class).max_extrinsic;
+		match max {
+			Some(max) if info.weight.any_gt(max) =>
+				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`.
+	fn check_block_weight(
+		info: &DispatchInfoOf<T::RuntimeCall>,
+	) -> Result<crate::ConsumedWeight, TransactionValidityError> {
+		let maximum_weight = T::BlockWeights::get();
+		let all_weight = Pallet::<T>::block_weight();
+		calculate_consumed_weight::<T::RuntimeCall>(maximum_weight, all_weight, info)
+	}
+
+	/// Checks if the current extrinsic can fit into the block with respect to block length limits.
+	///
+	/// Upon successes, it returns the new block length as a `Result`.
+	fn check_block_length(
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		len: usize,
+	) -> Result<u32, TransactionValidityError> {
+		let length_limit = T::BlockLength::get();
+		let current_len = Pallet::<T>::all_extrinsics_len();
+		let added_len = len as u32;
+		let next_len = current_len.saturating_add(added_len);
+		if next_len > *length_limit.max.get(info.class) {
+			Err(InvalidTransaction::ExhaustsResources.into())
+		} else {
+			Ok(next_len)
+		}
+	}
+
+	/// Creates new `SignedExtension` to check weight of the extrinsic.
+	pub fn new() -> Self {
+		Self(Default::default())
+	}
+
+	/// Do the pre-dispatch checks. This can be applied to both signed and unsigned.
+	///
+	/// It checks and notes the new weight and length.
+	pub fn do_pre_dispatch(
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		len: usize,
+	) -> Result<(), TransactionValidityError> {
+		let next_len = Self::check_block_length(info, len)?;
+		let next_weight = Self::check_block_weight(info)?;
+		Self::check_extrinsic_weight(info)?;
+
+		crate::AllExtrinsicsLen::<T>::put(next_len);
+		crate::BlockWeight::<T>::put(next_weight);
+		Ok(())
+	}
+
+	/// Do the validate checks. This can be applied to both signed and unsigned.
+	///
+	/// It only checks that the block weight and length limit will not exceed.
+	pub fn do_validate(info: &DispatchInfoOf<T::RuntimeCall>, len: usize) -> TransactionValidity {
+		// ignore the next length. If they return `Ok`, then it is below the limit.
+		let _ = Self::check_block_length(info, len)?;
+		// during validation we skip block limit check. Since the `validate_transaction`
+		// call runs on an empty block anyway, by this we prevent `on_initialize` weight
+		// consumption from causing false negatives.
+		Self::check_extrinsic_weight(info)?;
+
+		Ok(Default::default())
+	}
+}
+
+pub fn calculate_consumed_weight<Call>(
+	maximum_weight: BlockWeights,
+	mut all_weight: crate::ConsumedWeight,
+	info: &DispatchInfoOf<Call>,
+) -> 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);
+	let limit_per_class = maximum_weight.get(info.class);
+
+	// add the weight. If class is unlimited, use saturating add instead of checked one.
+	if limit_per_class.max_total.is_none() && limit_per_class.reserved.is_none() {
+		all_weight.accrue(extrinsic_weight, info.class)
+	} else {
+		all_weight
+			.checked_accrue(extrinsic_weight, info.class)
+			.map_err(|_| InvalidTransaction::ExhaustsResources)?;
+	}
+
+	let per_class = *all_weight.get(info.class);
+
+	// Check if we don't exceed per-class allowance
+	match limit_per_class.max_total {
+		Some(max) if per_class.any_gt(max) =>
+			return Err(InvalidTransaction::ExhaustsResources.into()),
+		// There is no `max_total` limit (`None`),
+		// or we are below the limit.
+		_ => {},
+	}
+
+	// In cases total block weight is exceeded, we need to fall back
+	// to `reserved` pool if there is any.
+	if all_weight.total().any_gt(maximum_weight.max_block) {
+		match limit_per_class.reserved {
+			// We are over the limit in reserved pool.
+			Some(reserved) if per_class.any_gt(reserved) =>
+				return Err(InvalidTransaction::ExhaustsResources.into()),
+			// There is either no limit in reserved pool (`None`),
+			// or we are below the limit.
+			_ => {},
+		}
+	}
+
+	Ok(all_weight)
+}
+
+impl<T: Config + Send + Sync> SignedExtension for CheckWeight<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+{
+	type AccountId = T::AccountId;
+	type Call = T::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckWeight";
+
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	fn pre_dispatch(
+		self,
+		_who: &Self::AccountId,
+		_call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<(), TransactionValidityError> {
+		Self::do_pre_dispatch(info, len)
+	}
+
+	fn validate(
+		&self,
+		_who: &Self::AccountId,
+		_call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		Self::do_validate(info, len)
+	}
+
+	fn pre_dispatch_unsigned(
+		_call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<(), TransactionValidityError> {
+		Self::do_pre_dispatch(info, len)
+	}
+
+	fn validate_unsigned(
+		_call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		Self::do_validate(info, len)
+	}
+
+	fn post_dispatch(
+		_pre: Option<Self::Pre>,
+		info: &DispatchInfoOf<Self::Call>,
+		post_info: &PostDispatchInfoOf<Self::Call>,
+		_len: usize,
+		_result: &DispatchResult,
+	) -> Result<(), TransactionValidityError> {
+		let unspent = post_info.calc_unspent(info);
+		if unspent.any_gt(Weight::zero()) {
+			crate::BlockWeight::<T>::mutate(|current_weight| {
+				current_weight.reduce(unspent, info.class);
+			})
+		}
+
+		Ok(())
+	}
+}
+
+impl<T: Config + Send + Sync> sp_std::fmt::Debug for CheckWeight<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "CheckWeight")
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		mock::{new_test_ext, System, Test, CALL},
+		AllExtrinsicsLen, BlockWeight, DispatchClass,
+	};
+	use frame_support::{assert_err, assert_ok, dispatch::Pays, weights::Weight};
+	use sp_std::marker::PhantomData;
+
+	fn block_weights() -> crate::limits::BlockWeights {
+		<Test as crate::Config>::BlockWeights::get()
+	}
+
+	fn normal_weight_limit() -> Weight {
+		block_weights()
+			.get(DispatchClass::Normal)
+			.max_total
+			.unwrap_or_else(|| block_weights().max_block)
+	}
+
+	fn block_weight_limit() -> Weight {
+		block_weights().max_block
+	}
+
+	fn normal_length_limit() -> u32 {
+		*<Test as Config>::BlockLength::get().max.get(DispatchClass::Normal)
+	}
+
+	#[test]
+	fn mandatory_extrinsic_doesnt_care_about_limits() {
+		fn check(call: impl FnOnce(&DispatchInfo, usize)) {
+			new_test_ext().execute_with(|| {
+				let max = DispatchInfo {
+					weight: Weight::MAX,
+					class: DispatchClass::Mandatory,
+					..Default::default()
+				};
+				let len = 0_usize;
+
+				call(&max, len);
+			});
+		}
+
+		check(|max, len| {
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(max, len));
+			assert_eq!(System::block_weight().total(), Weight::MAX);
+			assert!(System::block_weight().total().ref_time() > block_weight_limit().ref_time());
+		});
+		check(|max, len| {
+			assert_ok!(CheckWeight::<Test>::do_validate(max, len));
+		});
+	}
+
+	#[test]
+	fn normal_extrinsic_limited_by_maximum_extrinsic_weight() {
+		new_test_ext().execute_with(|| {
+			let max = DispatchInfo {
+				weight: block_weights().get(DispatchClass::Normal).max_extrinsic.unwrap() +
+					Weight::from_parts(1, 0),
+				class: DispatchClass::Normal,
+				..Default::default()
+			};
+			let len = 0_usize;
+			assert_err!(
+				CheckWeight::<Test>::do_validate(&max, len),
+				InvalidTransaction::ExhaustsResources
+			);
+		});
+	}
+
+	#[test]
+	fn operational_extrinsic_limited_by_operational_space_limit() {
+		new_test_ext().execute_with(|| {
+			let weights = block_weights();
+			let operational_limit = weights
+				.get(DispatchClass::Operational)
+				.max_total
+				.unwrap_or_else(|| weights.max_block);
+			let base_weight = weights.get(DispatchClass::Operational).base_extrinsic;
+
+			let weight = operational_limit - base_weight;
+			let okay =
+				DispatchInfo { weight, class: DispatchClass::Operational, ..Default::default() };
+			let max = DispatchInfo {
+				weight: weight + Weight::from_parts(1, 0),
+				class: DispatchClass::Operational,
+				..Default::default()
+			};
+			let len = 0_usize;
+
+			assert_eq!(CheckWeight::<Test>::do_validate(&okay, len), Ok(Default::default()));
+			assert_err!(
+				CheckWeight::<Test>::do_validate(&max, len),
+				InvalidTransaction::ExhaustsResources
+			);
+		});
+	}
+
+	#[test]
+	fn register_extra_weight_unchecked_doesnt_care_about_limits() {
+		new_test_ext().execute_with(|| {
+			System::register_extra_weight_unchecked(Weight::MAX, DispatchClass::Normal);
+			assert_eq!(System::block_weight().total(), Weight::MAX);
+			assert!(System::block_weight().total().ref_time() > block_weight_limit().ref_time());
+		});
+	}
+
+	#[test]
+	fn full_block_with_normal_and_operational() {
+		new_test_ext().execute_with(|| {
+			// Max block is 1024
+			// Max normal is 768 (75%)
+			// 10 is taken for block execution weight
+			// So normal extrinsic can be 758 weight (-5 for base extrinsic weight)
+			// And Operational can be 246 to produce a full block (-10 for base)
+			let max_normal =
+				DispatchInfo { weight: Weight::from_parts(753, 0), ..Default::default() };
+			let rest_operational = DispatchInfo {
+				weight: Weight::from_parts(246, 0),
+				class: DispatchClass::Operational,
+				..Default::default()
+			};
+
+			let len = 0_usize;
+
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&max_normal, len));
+			assert_eq!(System::block_weight().total(), Weight::from_parts(768, 0));
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&rest_operational, len));
+			assert_eq!(block_weight_limit(), Weight::from_parts(1024, u64::MAX));
+			assert_eq!(System::block_weight().total(), block_weight_limit().set_proof_size(0));
+			// Checking single extrinsic should not take current block weight into account.
+			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&rest_operational), Ok(()));
+		});
+	}
+
+	#[test]
+	fn dispatch_order_does_not_effect_weight_logic() {
+		new_test_ext().execute_with(|| {
+			// We switch the order of `full_block_with_normal_and_operational`
+			let max_normal =
+				DispatchInfo { weight: Weight::from_parts(753, 0), ..Default::default() };
+			let rest_operational = DispatchInfo {
+				weight: Weight::from_parts(246, 0),
+				class: DispatchClass::Operational,
+				..Default::default()
+			};
+
+			let len = 0_usize;
+
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&rest_operational, len));
+			// Extra 20 here from block execution + base extrinsic weight
+			assert_eq!(System::block_weight().total(), Weight::from_parts(266, 0));
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&max_normal, len));
+			assert_eq!(block_weight_limit(), Weight::from_parts(1024, u64::MAX));
+			assert_eq!(System::block_weight().total(), block_weight_limit().set_proof_size(0));
+		});
+	}
+
+	#[test]
+	fn operational_works_on_full_block() {
+		new_test_ext().execute_with(|| {
+			// An on_initialize takes up the whole block! (Every time!)
+			System::register_extra_weight_unchecked(Weight::MAX, DispatchClass::Mandatory);
+			let dispatch_normal = DispatchInfo {
+				weight: Weight::from_parts(251, 0),
+				class: DispatchClass::Normal,
+				..Default::default()
+			};
+			let dispatch_operational = DispatchInfo {
+				weight: Weight::from_parts(246, 0),
+				class: DispatchClass::Operational,
+				..Default::default()
+			};
+			let len = 0_usize;
+
+			assert_err!(
+				CheckWeight::<Test>::do_pre_dispatch(&dispatch_normal, len),
+				InvalidTransaction::ExhaustsResources
+			);
+			// Thank goodness we can still do an operational transaction to possibly save the
+			// blockchain.
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&dispatch_operational, len));
+			// Not too much though
+			assert_err!(
+				CheckWeight::<Test>::do_pre_dispatch(&dispatch_operational, len),
+				InvalidTransaction::ExhaustsResources
+			);
+			// Even with full block, validity of single transaction should be correct.
+			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&dispatch_operational), Ok(()));
+		});
+	}
+
+	#[test]
+	fn signed_ext_check_weight_works_operational_tx() {
+		new_test_ext().execute_with(|| {
+			let normal = DispatchInfo { weight: Weight::from_parts(100, 0), ..Default::default() };
+			let op = DispatchInfo {
+				weight: Weight::from_parts(100, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			let len = 0_usize;
+			let normal_limit = normal_weight_limit();
+
+			// given almost full block
+			BlockWeight::<Test>::mutate(|current_weight| {
+				current_weight.set(normal_limit, DispatchClass::Normal)
+			});
+			// will not fit.
+			assert_err!(
+				CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &normal, len),
+				InvalidTransaction::ExhaustsResources
+			);
+			// will fit.
+			assert_ok!(CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &op, len));
+
+			// likewise for length limit.
+			let len = 100_usize;
+			AllExtrinsicsLen::<Test>::put(normal_length_limit());
+			assert_err!(
+				CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &normal, len),
+				InvalidTransaction::ExhaustsResources
+			);
+			assert_ok!(CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &op, len));
+		})
+	}
+
+	#[test]
+	fn signed_ext_check_weight_block_size_works() {
+		new_test_ext().execute_with(|| {
+			let normal = DispatchInfo::default();
+			let normal_limit = normal_weight_limit().ref_time() as usize;
+			let reset_check_weight = |tx, s, f| {
+				AllExtrinsicsLen::<Test>::put(0);
+				let r = CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, tx, s);
+				if f {
+					assert!(r.is_err())
+				} else {
+					assert!(r.is_ok())
+				}
+			};
+
+			reset_check_weight(&normal, normal_limit - 1, false);
+			reset_check_weight(&normal, normal_limit, false);
+			reset_check_weight(&normal, normal_limit + 1, true);
+
+			// Operational ones don't have this limit.
+			let op = DispatchInfo {
+				weight: Weight::zero(),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			reset_check_weight(&op, normal_limit, false);
+			reset_check_weight(&op, normal_limit + 100, false);
+			reset_check_weight(&op, 1024, false);
+			reset_check_weight(&op, 1025, true);
+		})
+	}
+
+	#[test]
+	fn signed_ext_check_weight_works_normal_tx() {
+		new_test_ext().execute_with(|| {
+			let normal_limit = normal_weight_limit();
+			let small = DispatchInfo { weight: Weight::from_parts(100, 0), ..Default::default() };
+			let base_extrinsic = block_weights().get(DispatchClass::Normal).base_extrinsic;
+			let medium =
+				DispatchInfo { weight: normal_limit - base_extrinsic, ..Default::default() };
+			let big = DispatchInfo {
+				weight: normal_limit - base_extrinsic + Weight::from_parts(1, 0),
+				..Default::default()
+			};
+			let len = 0_usize;
+
+			let reset_check_weight = |i, f, s| {
+				BlockWeight::<Test>::mutate(|current_weight| {
+					current_weight.set(s, DispatchClass::Normal)
+				});
+				let r = CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, i, len);
+				if f {
+					assert!(r.is_err())
+				} else {
+					assert!(r.is_ok())
+				}
+			};
+
+			reset_check_weight(&small, false, Weight::zero());
+			reset_check_weight(&medium, false, Weight::zero());
+			reset_check_weight(&big, true, Weight::from_parts(1, 0));
+		})
+	}
+
+	#[test]
+	fn signed_ext_check_weight_refund_works() {
+		new_test_ext().execute_with(|| {
+			// This is half of the max block weight
+			let info = DispatchInfo { weight: Weight::from_parts(512, 0), ..Default::default() };
+			let post_info = PostDispatchInfo {
+				actual_weight: Some(Weight::from_parts(128, 0)),
+				pays_fee: Default::default(),
+			};
+			let len = 0_usize;
+			let base_extrinsic = block_weights().get(DispatchClass::Normal).base_extrinsic;
+
+			// We allow 75% for normal transaction, so we put 25% - extrinsic base weight
+			BlockWeight::<Test>::mutate(|current_weight| {
+				current_weight.set(Weight::zero(), DispatchClass::Mandatory);
+				current_weight
+					.set(Weight::from_parts(256, 0) - base_extrinsic, DispatchClass::Normal);
+			});
+
+			let pre = CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &info, len).unwrap();
+			assert_eq!(
+				BlockWeight::<Test>::get().total(),
+				info.weight + Weight::from_parts(256, 0)
+			);
+
+			assert_ok!(CheckWeight::<Test>::post_dispatch(
+				Some(pre),
+				&info,
+				&post_info,
+				len,
+				&Ok(())
+			));
+			assert_eq!(
+				BlockWeight::<Test>::get().total(),
+				post_info.actual_weight.unwrap() + Weight::from_parts(256, 0)
+			);
+		})
+	}
+
+	#[test]
+	fn signed_ext_check_weight_actual_weight_higher_than_max_is_capped() {
+		new_test_ext().execute_with(|| {
+			let info = DispatchInfo { weight: Weight::from_parts(512, 0), ..Default::default() };
+			let post_info = PostDispatchInfo {
+				actual_weight: Some(Weight::from_parts(700, 0)),
+				pays_fee: Default::default(),
+			};
+			let len = 0_usize;
+
+			BlockWeight::<Test>::mutate(|current_weight| {
+				current_weight.set(Weight::zero(), DispatchClass::Mandatory);
+				current_weight.set(Weight::from_parts(128, 0), DispatchClass::Normal);
+			});
+
+			let pre = CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &info, len).unwrap();
+			assert_eq!(
+				BlockWeight::<Test>::get().total(),
+				info.weight +
+					Weight::from_parts(128, 0) +
+					block_weights().get(DispatchClass::Normal).base_extrinsic,
+			);
+
+			assert_ok!(CheckWeight::<Test>::post_dispatch(
+				Some(pre),
+				&info,
+				&post_info,
+				len,
+				&Ok(())
+			));
+			assert_eq!(
+				BlockWeight::<Test>::get().total(),
+				info.weight +
+					Weight::from_parts(128, 0) +
+					block_weights().get(DispatchClass::Normal).base_extrinsic,
+			);
+		})
+	}
+
+	#[test]
+	fn zero_weight_extrinsic_still_has_base_weight() {
+		new_test_ext().execute_with(|| {
+			let weights = block_weights();
+			let free = DispatchInfo { weight: Weight::zero(), ..Default::default() };
+			let len = 0_usize;
+
+			// Initial weight from `weights.base_block`
+			assert_eq!(System::block_weight().total(), weights.base_block);
+			assert_ok!(CheckWeight::<Test>(PhantomData).pre_dispatch(&1, CALL, &free, len));
+			assert_eq!(
+				System::block_weight().total(),
+				weights.get(DispatchClass::Normal).base_extrinsic + weights.base_block
+			);
+		})
+	}
+
+	#[test]
+	fn normal_and_mandatory_tracked_separately() {
+		new_test_ext().execute_with(|| {
+			// Max block is 1024
+			// Max normal is 768 (75%)
+			// Max mandatory is unlimited
+			let max_normal =
+				DispatchInfo { weight: Weight::from_parts(753, 0), ..Default::default() };
+			let mandatory = DispatchInfo {
+				weight: Weight::from_parts(1019, 0),
+				class: DispatchClass::Mandatory,
+				..Default::default()
+			};
+
+			let len = 0_usize;
+
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&max_normal, len));
+			assert_eq!(System::block_weight().total(), Weight::from_parts(768, 0));
+			assert_ok!(CheckWeight::<Test>::do_pre_dispatch(&mandatory, len));
+			assert_eq!(block_weight_limit(), Weight::from_parts(1024, u64::MAX));
+			assert_eq!(System::block_weight().total(), Weight::from_parts(1024 + 768, 0));
+			assert_eq!(CheckWeight::<Test>::check_extrinsic_weight(&mandatory), Ok(()));
+		});
+	}
+
+	#[test]
+	fn no_max_total_should_still_be_limited_by_max_block() {
+		// given
+		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, u64::MAX));
+			})
+			.for_class(DispatchClass::Mandatory, |w| {
+				w.base_extrinsic = Weight::zero();
+				w.reserved = Some(Weight::from_parts(5, u64::MAX));
+				w.max_total = None;
+			})
+			.build_or_panic();
+		let all_weight = crate::ConsumedWeight::new(|class| match class {
+			DispatchClass::Normal => Weight::from_parts(10, 0),
+			DispatchClass::Operational => Weight::from_parts(10, 0),
+			DispatchClass::Mandatory => Weight::zero(),
+		});
+		assert_eq!(maximum_weight.max_block, all_weight.total().set_proof_size(u64::MAX));
+
+		// fits into reserved
+		let mandatory1 = DispatchInfo {
+			weight: Weight::from_parts(5, 0),
+			class: DispatchClass::Mandatory,
+			..Default::default()
+		};
+		// does not fit into reserved and the block is full.
+		let mandatory2 = DispatchInfo {
+			weight: Weight::from_parts(6, 0),
+			class: DispatchClass::Mandatory,
+			..Default::default()
+		};
+
+		// when
+		assert_ok!(calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+			maximum_weight.clone(),
+			all_weight.clone(),
+			&mandatory1
+		));
+		assert_err!(
+			calculate_consumed_weight::<<Test as Config>::RuntimeCall>(
+				maximum_weight,
+				all_weight,
+				&mandatory2
+			),
+			InvalidTransaction::ExhaustsResources
+		);
+	}
+}
diff --git a/substrate/frame/system/src/extensions/mod.rs b/substrate/frame/system/src/extensions/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a88c9fbf96ebdac86d9c45a8e5b07020c3325bb0
--- /dev/null
+++ b/substrate/frame/system/src/extensions/mod.rs
@@ -0,0 +1,24 @@
+// 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.
+
+pub mod check_genesis;
+pub mod check_mortality;
+pub mod check_non_zero_sender;
+pub mod check_nonce;
+pub mod check_spec_version;
+pub mod check_tx_version;
+pub mod check_weight;
diff --git a/substrate/frame/system/src/lib.rs b/substrate/frame/system/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..84b6dc031457db67ebd9eba43b83571fb70220bf
--- /dev/null
+++ b/substrate/frame/system/src/lib.rs
@@ -0,0 +1,1819 @@
+// 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.
+
+//! # System Pallet
+//!
+//! The System pallet provides low-level access to core types and cross-cutting utilities.
+//! It acts as the base layer for other pallets to interact with the Substrate framework components.
+//!
+//! - [`Config`]
+//!
+//! ## Overview
+//!
+//! The System pallet defines the core data types used in a Substrate runtime.
+//! It also provides several utility functions (see [`Pallet`]) for other FRAME pallets.
+//!
+//! In addition, it manages the storage items for extrinsics data, indexes, event records, and
+//! digest items, among other things that support the execution of the current block.
+//!
+//! It also handles low-level tasks like depositing logs, basic set up and take down of
+//! temporary storage entries, and access to previous block hashes.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! The System pallet does not implement any dispatchable functions.
+//!
+//! ### Public Functions
+//!
+//! See the [`Pallet`] struct for details of publicly available functions.
+//!
+//! ### Signed Extensions
+//!
+//! The System pallet defines the following extensions:
+//!
+//!   - [`CheckWeight`]: Checks the weight and length of the block and ensure that it does not
+//!     exceed the limits.
+//!   - [`CheckNonce`]: Checks the nonce of the transaction. Contains a single payload of type
+//!     `T::Nonce`.
+//!   - [`CheckEra`]: Checks the era of the transaction. Contains a single payload of type `Era`.
+//!   - [`CheckGenesis`]: Checks the provided genesis hash of the transaction. Must be a part of the
+//!     signed payload of the transaction.
+//!   - [`CheckSpecVersion`]: Checks that the runtime version is the same as the one used to sign
+//!     the transaction.
+//!   - [`CheckTxVersion`]: Checks that the transaction version is the same as the one used to sign
+//!     the transaction.
+//!
+//! Lookup the runtime aggregator file (e.g. `node/runtime`) to see the full list of signed
+//! extensions included in a chain.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use pallet_prelude::{BlockNumberFor, HeaderFor};
+#[cfg(feature = "std")]
+use serde::Serialize;
+use sp_io::hashing::blake2_256;
+#[cfg(feature = "runtime-benchmarks")]
+use sp_runtime::traits::TrailingZeroInput;
+use sp_runtime::{
+	generic,
+	traits::{
+		self, AtLeast32Bit, BadOrigin, BlockNumberProvider, Bounded, CheckEqual, Dispatchable,
+		Hash, Header, Lookup, LookupError, MaybeDisplay, MaybeSerializeDeserialize, Member, One,
+		Saturating, SimpleBitOps, StaticLookup, Zero,
+	},
+	DispatchError, RuntimeDebug,
+};
+#[cfg(any(feature = "std", test))]
+use sp_std::map;
+use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
+use sp_version::RuntimeVersion;
+
+use codec::{Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};
+#[cfg(feature = "std")]
+use frame_support::traits::BuildGenesisConfig;
+use frame_support::{
+	dispatch::{
+		extract_actual_pays_fee, extract_actual_weight, DispatchClass, DispatchInfo,
+		DispatchResult, DispatchResultWithPostInfo, PerDispatchClass,
+	},
+	impl_ensure_origin_with_arg_ignoring_arg,
+	storage::{self, StorageStreamIter},
+	traits::{
+		ConstU32, Contains, EnsureOrigin, EnsureOriginWithArg, Get, HandleLifetime,
+		OnKilledAccount, OnNewAccount, OriginTrait, PalletInfo, SortedMembers, StoredMap, TypedGet,
+	},
+	Parameter,
+};
+use scale_info::TypeInfo;
+use sp_core::storage::well_known_keys;
+use sp_weights::{RuntimeDbWeight, Weight};
+
+#[cfg(any(feature = "std", test))]
+use sp_io::TestExternalities;
+
+pub mod limits;
+#[cfg(test)]
+pub(crate) mod mock;
+pub mod offchain;
+
+mod extensions;
+#[cfg(feature = "std")]
+pub mod mocking;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+pub mod migrations;
+
+pub use extensions::{
+	check_genesis::CheckGenesis, check_mortality::CheckMortality,
+	check_non_zero_sender::CheckNonZeroSender, check_nonce::CheckNonce,
+	check_spec_version::CheckSpecVersion, check_tx_version::CheckTxVersion,
+	check_weight::CheckWeight,
+};
+// Backward compatible re-export.
+pub use extensions::check_mortality::CheckMortality as CheckEra;
+pub use frame_support::dispatch::RawOrigin;
+pub use weights::WeightInfo;
+
+const LOG_TARGET: &str = "runtime::system";
+
+/// Compute the trie root of a list of extrinsics.
+///
+/// The merkle proof is using the same trie as runtime state with
+/// `state_version` 0.
+pub fn extrinsics_root<H: Hash, E: codec::Encode>(extrinsics: &[E]) -> H::Output {
+	extrinsics_data_root::<H>(extrinsics.iter().map(codec::Encode::encode).collect())
+}
+
+/// Compute the trie root of a list of extrinsics.
+///
+/// The merkle proof is using the same trie as runtime state with
+/// `state_version` 0.
+pub fn extrinsics_data_root<H: Hash>(xts: Vec<Vec<u8>>) -> H::Output {
+	H::ordered_trie_root(xts, sp_core::storage::StateVersion::V0)
+}
+
+/// An object to track the currently used extrinsic weight in a block.
+pub type ConsumedWeight = PerDispatchClass<Weight>;
+
+pub use pallet::*;
+
+/// Do something when we should be setting the code.
+pub trait SetCode<T: Config> {
+	/// Set the code to the given blob.
+	fn set_code(code: Vec<u8>) -> DispatchResult;
+}
+
+impl<T: Config> SetCode<T> for () {
+	fn set_code(code: Vec<u8>) -> DispatchResult {
+		<Pallet<T>>::update_code_in_storage(&code)?;
+		Ok(())
+	}
+}
+
+/// Numeric limits over the ability to add a consumer ref using `inc_consumers`.
+pub trait ConsumerLimits {
+	/// The number of consumers over which `inc_consumers` will cease to work.
+	fn max_consumers() -> RefCount;
+	/// The maximum number of additional consumers expected to be over be added at once using
+	/// `inc_consumers_without_limit`.
+	///
+	/// Note: This is not enforced and it's up to the chain's author to ensure this reflects the
+	/// actual situation.
+	fn max_overflow() -> RefCount;
+}
+
+impl<const Z: u32> ConsumerLimits for ConstU32<Z> {
+	fn max_consumers() -> RefCount {
+		Z
+	}
+	fn max_overflow() -> RefCount {
+		Z
+	}
+}
+
+impl<MaxNormal: Get<u32>, MaxOverflow: Get<u32>> ConsumerLimits for (MaxNormal, MaxOverflow) {
+	fn max_consumers() -> RefCount {
+		MaxNormal::get()
+	}
+	fn max_overflow() -> RefCount {
+		MaxOverflow::get()
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use crate::{self as frame_system, pallet_prelude::*, *};
+	use frame_support::pallet_prelude::*;
+
+	/// Default implementations of [`DefaultConfig`], which can be used to implement [`Config`].
+	pub mod config_preludes {
+		use super::{inject_runtime_type, DefaultConfig};
+
+		/// Provides a viable default config that can be used with
+		/// [`derive_impl`](`frame_support::derive_impl`) to derive a testing pallet config
+		/// based on this one.
+		///
+		/// See `Test` in the `default-config` example pallet's `test.rs` for an example of
+		/// a downstream user of this particular `TestDefaultConfig`
+		pub struct TestDefaultConfig;
+
+		#[frame_support::register_default_impl(TestDefaultConfig)]
+		impl DefaultConfig for TestDefaultConfig {
+			type Nonce = u32;
+			type Hash = sp_core::hash::H256;
+			type Hashing = sp_runtime::traits::BlakeTwo256;
+			type AccountId = u64;
+			type Lookup = sp_runtime::traits::IdentityLookup<u64>;
+			type MaxConsumers = frame_support::traits::ConstU32<16>;
+			type AccountData = ();
+			type OnNewAccount = ();
+			type OnKilledAccount = ();
+			type SystemWeightInfo = ();
+			type SS58Prefix = ();
+			type Version = ();
+			type BlockWeights = ();
+			type BlockLength = ();
+			type DbWeight = ();
+			#[inject_runtime_type]
+			type RuntimeEvent = ();
+			#[inject_runtime_type]
+			type RuntimeOrigin = ();
+			#[inject_runtime_type]
+			type RuntimeCall = ();
+			#[inject_runtime_type]
+			type PalletInfo = ();
+			type BaseCallFilter = frame_support::traits::Everything;
+			type BlockHashCount = frame_support::traits::ConstU64<10>;
+			type OnSetCode = ();
+		}
+	}
+
+	/// System configuration trait. Implemented by runtime.
+	#[pallet::config(with_default)]
+	#[pallet::disable_frame_system_supertrait_check]
+	pub trait Config: 'static + Eq + Clone {
+		/// The aggregated event type of the runtime.
+		#[pallet::no_default_bounds]
+		type RuntimeEvent: Parameter
+			+ Member
+			+ From<Event<Self>>
+			+ Debug
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The basic call filter to use in Origin. All origins are built with this filter as base,
+		/// except Root.
+		///
+		/// This works as a filter for each incoming call. The call needs to pass this filter in
+		/// order to dispatch. Otherwise it will be rejected with `CallFiltered`. This can be
+		/// bypassed via `dispatch_bypass_filter` which should only be accessible by root. The
+		/// filter can be composed of sub-filters by nesting for example
+		/// [`frame_support::traits::InsideBoth`], [`frame_support::traits::TheseExcept`] or
+		/// [`frame_support::traits::EverythingBut`] et al. The default would be
+		/// [`frame_support::traits::Everything`].
+		#[pallet::no_default_bounds]
+		type BaseCallFilter: Contains<Self::RuntimeCall>;
+
+		/// Block & extrinsics weights: base values and limits.
+		#[pallet::constant]
+		type BlockWeights: Get<limits::BlockWeights>;
+
+		/// The maximum length of a block (in bytes).
+		#[pallet::constant]
+		type BlockLength: Get<limits::BlockLength>;
+
+		/// The `RuntimeOrigin` type used by dispatchable calls.
+		#[pallet::no_default_bounds]
+		type RuntimeOrigin: Into<Result<RawOrigin<Self::AccountId>, Self::RuntimeOrigin>>
+			+ From<RawOrigin<Self::AccountId>>
+			+ Clone
+			+ OriginTrait<Call = Self::RuntimeCall, AccountId = Self::AccountId>;
+
+		/// The aggregated `RuntimeCall` type.
+		#[pallet::no_default_bounds]
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ Debug
+			+ From<Call<Self>>;
+
+		/// This stores the number of previous transactions associated with a sender account.
+		type Nonce: Parameter
+			+ Member
+			+ MaybeSerializeDeserialize
+			+ Debug
+			+ Default
+			+ MaybeDisplay
+			+ AtLeast32Bit
+			+ Copy
+			+ MaxEncodedLen;
+
+		/// The output of the `Hashing` function.
+		type Hash: Parameter
+			+ Member
+			+ MaybeSerializeDeserialize
+			+ Debug
+			+ MaybeDisplay
+			+ SimpleBitOps
+			+ Ord
+			+ Default
+			+ Copy
+			+ CheckEqual
+			+ sp_std::hash::Hash
+			+ AsRef<[u8]>
+			+ AsMut<[u8]>
+			+ MaxEncodedLen;
+
+		/// The hashing system (algorithm) being used in the runtime (e.g. Blake2).
+		type Hashing: Hash<Output = Self::Hash> + TypeInfo;
+
+		/// The user account identifier type for the runtime.
+		type AccountId: Parameter
+			+ Member
+			+ MaybeSerializeDeserialize
+			+ Debug
+			+ MaybeDisplay
+			+ Ord
+			+ MaxEncodedLen;
+
+		/// Converting trait to take a source type and convert to `AccountId`.
+		///
+		/// Used to define the type and conversion mechanism for referencing accounts in
+		/// transactions. It's perfectly reasonable for this to be an identity conversion (with the
+		/// source type being `AccountId`), but other pallets (e.g. Indices pallet) may provide more
+		/// functional/efficient alternatives.
+		type Lookup: StaticLookup<Target = Self::AccountId>;
+
+		/// The Block type used by the runtime. This is used by `construct_runtime` to retrieve the
+		/// extrinsics or other block specific data as needed.
+		#[pallet::no_default]
+		type Block: Parameter + Member + traits::Block<Hash = Self::Hash>;
+
+		/// Maximum number of block number to block hash mappings to keep (oldest pruned first).
+		#[pallet::constant]
+		#[pallet::no_default_bounds]
+		type BlockHashCount: Get<BlockNumberFor<Self>>;
+
+		/// The weight of runtime database operations the runtime can invoke.
+		#[pallet::constant]
+		type DbWeight: Get<RuntimeDbWeight>;
+
+		/// Get the chain's current version.
+		#[pallet::constant]
+		type Version: Get<RuntimeVersion>;
+
+		/// Provides information about the pallet setup in the runtime.
+		///
+		/// Expects the `PalletInfo` type that is being generated by `construct_runtime!` in the
+		/// runtime.
+		///
+		/// For tests it is okay to use `()` as type, however it will provide "useless" data.
+		#[pallet::no_default_bounds]
+		type PalletInfo: PalletInfo;
+
+		/// Data to be associated with an account (other than nonce/transaction counter, which this
+		/// pallet does regardless).
+		type AccountData: Member + FullCodec + Clone + Default + TypeInfo + MaxEncodedLen;
+
+		/// Handler for when a new account has just been created.
+		type OnNewAccount: OnNewAccount<Self::AccountId>;
+
+		/// A function that is invoked when an account has been determined to be dead.
+		///
+		/// All resources should be cleaned up associated with the given account.
+		type OnKilledAccount: OnKilledAccount<Self::AccountId>;
+
+		type SystemWeightInfo: WeightInfo;
+
+		/// The designated SS58 prefix of this chain.
+		///
+		/// This replaces the "ss58Format" property declared in the chain spec. Reason is
+		/// that the runtime should know about the prefix in order to make use of it as
+		/// an identifier of the chain.
+		#[pallet::constant]
+		type SS58Prefix: Get<u16>;
+
+		/// What to do if the runtime wants to change the code to something new.
+		///
+		/// The default (`()`) implementation is responsible for setting the correct storage
+		/// entry and emitting corresponding event and log item. (see
+		/// [`Pallet::update_code_in_storage`]).
+		/// It's unlikely that this needs to be customized, unless you are writing a parachain using
+		/// `Cumulus`, where the actual code change is deferred.
+		#[pallet::no_default_bounds]
+		type OnSetCode: SetCode<Self>;
+
+		/// The maximum number of consumers allowed on a single account.
+		type MaxConsumers: ConsumerLimits;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		#[cfg(feature = "std")]
+		fn integrity_test() {
+			T::BlockWeights::get().validate().expect("The weights are invalid.");
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Make some on-chain remark.
+		///
+		/// Can be executed by every `origin`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::SystemWeightInfo::remark(_remark.len() as u32))]
+		pub fn remark(_origin: OriginFor<T>, _remark: Vec<u8>) -> DispatchResultWithPostInfo {
+			Ok(().into())
+		}
+
+		/// Set the number of pages in the WebAssembly environment's heap.
+		#[pallet::call_index(1)]
+		#[pallet::weight((T::SystemWeightInfo::set_heap_pages(), DispatchClass::Operational))]
+		pub fn set_heap_pages(origin: OriginFor<T>, pages: u64) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			storage::unhashed::put_raw(well_known_keys::HEAP_PAGES, &pages.encode());
+			Self::deposit_log(generic::DigestItem::RuntimeEnvironmentUpdated);
+			Ok(().into())
+		}
+
+		/// Set the new runtime code.
+		#[pallet::call_index(2)]
+		#[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]
+		pub fn set_code(origin: OriginFor<T>, code: Vec<u8>) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			Self::can_set_code(&code)?;
+			T::OnSetCode::set_code(code)?;
+			// consume the rest of the block to prevent further transactions
+			Ok(Some(T::BlockWeights::get().max_block).into())
+		}
+
+		/// Set the new runtime code without doing any checks of the given `code`.
+		#[pallet::call_index(3)]
+		#[pallet::weight((T::SystemWeightInfo::set_code(), DispatchClass::Operational))]
+		pub fn set_code_without_checks(
+			origin: OriginFor<T>,
+			code: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			T::OnSetCode::set_code(code)?;
+			Ok(Some(T::BlockWeights::get().max_block).into())
+		}
+
+		/// Set some items of storage.
+		#[pallet::call_index(4)]
+		#[pallet::weight((
+			T::SystemWeightInfo::set_storage(items.len() as u32),
+			DispatchClass::Operational,
+		))]
+		pub fn set_storage(
+			origin: OriginFor<T>,
+			items: Vec<KeyValue>,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			for i in &items {
+				storage::unhashed::put_raw(&i.0, &i.1);
+			}
+			Ok(().into())
+		}
+
+		/// Kill some items from storage.
+		#[pallet::call_index(5)]
+		#[pallet::weight((
+			T::SystemWeightInfo::kill_storage(keys.len() as u32),
+			DispatchClass::Operational,
+		))]
+		pub fn kill_storage(origin: OriginFor<T>, keys: Vec<Key>) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			for key in &keys {
+				storage::unhashed::kill(key);
+			}
+			Ok(().into())
+		}
+
+		/// Kill all storage items with a key that starts with the given prefix.
+		///
+		/// **NOTE:** We rely on the Root origin to provide us the number of subkeys under
+		/// the prefix we are removing to accurately calculate the weight of this function.
+		#[pallet::call_index(6)]
+		#[pallet::weight((
+			T::SystemWeightInfo::kill_prefix(_subkeys.saturating_add(1)),
+			DispatchClass::Operational,
+		))]
+		pub fn kill_prefix(
+			origin: OriginFor<T>,
+			prefix: Key,
+			_subkeys: u32,
+		) -> DispatchResultWithPostInfo {
+			ensure_root(origin)?;
+			let _ = storage::unhashed::clear_prefix(&prefix, None, None);
+			Ok(().into())
+		}
+
+		/// Make some on-chain remark and emit event.
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::SystemWeightInfo::remark_with_event(remark.len() as u32))]
+		pub fn remark_with_event(
+			origin: OriginFor<T>,
+			remark: Vec<u8>,
+		) -> DispatchResultWithPostInfo {
+			let who = ensure_signed(origin)?;
+			let hash = T::Hashing::hash(&remark[..]);
+			Self::deposit_event(Event::Remarked { sender: who, hash });
+			Ok(().into())
+		}
+	}
+
+	/// Event for the System pallet.
+	#[pallet::event]
+	pub enum Event<T: Config> {
+		/// An extrinsic completed successfully.
+		ExtrinsicSuccess { dispatch_info: DispatchInfo },
+		/// An extrinsic failed.
+		ExtrinsicFailed { dispatch_error: DispatchError, dispatch_info: DispatchInfo },
+		/// `:code` was updated.
+		CodeUpdated,
+		/// A new account was created.
+		NewAccount { account: T::AccountId },
+		/// An account was reaped.
+		KilledAccount { account: T::AccountId },
+		/// On on-chain remark happened.
+		Remarked { sender: T::AccountId, hash: T::Hash },
+	}
+
+	/// Error for the System pallet
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The name of specification does not match between the current runtime
+		/// and the new runtime.
+		InvalidSpecName,
+		/// The specification version is not allowed to decrease between the current runtime
+		/// and the new runtime.
+		SpecVersionNeedsToIncrease,
+		/// Failed to extract the runtime version from the new runtime.
+		///
+		/// Either calling `Core_version` or decoding `RuntimeVersion` failed.
+		FailedToExtractRuntimeVersion,
+		/// Suicide called when the account has non-default composite data.
+		NonDefaultComposite,
+		/// There is a non-zero reference count preventing the account from being purged.
+		NonZeroRefCount,
+		/// The origin filter prevent the call to be dispatched.
+		CallFiltered,
+	}
+
+	/// Exposed trait-generic origin type.
+	#[pallet::origin]
+	pub type Origin<T> = RawOrigin<<T as Config>::AccountId>;
+
+	/// The full account information for a particular account ID.
+	#[pallet::storage]
+	#[pallet::getter(fn account)]
+	pub type Account<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		AccountInfo<T::Nonce, T::AccountData>,
+		ValueQuery,
+	>;
+
+	/// Total extrinsics count for the current block.
+	#[pallet::storage]
+	pub(super) type ExtrinsicCount<T: Config> = StorageValue<_, u32>;
+
+	/// The current weight for the block.
+	#[pallet::storage]
+	#[pallet::whitelist_storage]
+	#[pallet::getter(fn block_weight)]
+	pub(super) type BlockWeight<T: Config> = StorageValue<_, ConsumedWeight, ValueQuery>;
+
+	/// Total length (in bytes) for all extrinsics put together, for the current block.
+	#[pallet::storage]
+	pub(super) type AllExtrinsicsLen<T: Config> = StorageValue<_, u32>;
+
+	/// Map of block numbers to block hashes.
+	#[pallet::storage]
+	#[pallet::getter(fn block_hash)]
+	pub type BlockHash<T: Config> =
+		StorageMap<_, Twox64Concat, BlockNumberFor<T>, T::Hash, ValueQuery>;
+
+	/// Extrinsics data for the current block (maps an extrinsic's index to its data).
+	#[pallet::storage]
+	#[pallet::getter(fn extrinsic_data)]
+	#[pallet::unbounded]
+	pub(super) type ExtrinsicData<T: Config> =
+		StorageMap<_, Twox64Concat, u32, Vec<u8>, ValueQuery>;
+
+	/// The current block number being processed. Set by `execute_block`.
+	#[pallet::storage]
+	#[pallet::whitelist_storage]
+	#[pallet::getter(fn block_number)]
+	pub(super) type Number<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;
+
+	/// Hash of the previous block.
+	#[pallet::storage]
+	#[pallet::getter(fn parent_hash)]
+	pub(super) type ParentHash<T: Config> = StorageValue<_, T::Hash, ValueQuery>;
+
+	/// Digest of the current block, also part of the block header.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	#[pallet::getter(fn digest)]
+	pub(super) type Digest<T: Config> = StorageValue<_, generic::Digest, ValueQuery>;
+
+	/// Events deposited for the current block.
+	///
+	/// NOTE: The item is unbound and should therefore never be read on chain.
+	/// It could otherwise inflate the PoV size of a block.
+	///
+	/// Events have a large in-memory size. Box the events to not go out-of-memory
+	/// just in case someone still reads them from within the runtime.
+	#[pallet::storage]
+	#[pallet::whitelist_storage]
+	#[pallet::unbounded]
+	pub(super) type Events<T: Config> =
+		StorageValue<_, Vec<Box<EventRecord<T::RuntimeEvent, T::Hash>>>, ValueQuery>;
+
+	/// The number of events in the `Events<T>` list.
+	#[pallet::storage]
+	#[pallet::whitelist_storage]
+	#[pallet::getter(fn event_count)]
+	pub(super) type EventCount<T: Config> = StorageValue<_, EventIndex, ValueQuery>;
+
+	/// Mapping between a topic (represented by T::Hash) and a vector of indexes
+	/// of events in the `<Events<T>>` list.
+	///
+	/// All topic vectors have deterministic storage locations depending on the topic. This
+	/// allows light-clients to leverage the changes trie storage tracking mechanism and
+	/// in case of changes fetch the list of events of interest.
+	///
+	/// The value has the type `(BlockNumberFor<T>, EventIndex)` because if we used only just
+	/// the `EventIndex` then in case if the topic has the same contents on the next block
+	/// no notification will be triggered thus the event might be lost.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	#[pallet::getter(fn event_topics)]
+	pub(super) type EventTopics<T: Config> =
+		StorageMap<_, Blake2_128Concat, T::Hash, Vec<(BlockNumberFor<T>, EventIndex)>, ValueQuery>;
+
+	/// Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
+	#[pallet::storage]
+	#[pallet::unbounded]
+	pub type LastRuntimeUpgrade<T: Config> = StorageValue<_, LastRuntimeUpgradeInfo>;
+
+	/// True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
+	#[pallet::storage]
+	pub(super) type UpgradedToU32RefCount<T: Config> = StorageValue<_, bool, ValueQuery>;
+
+	/// True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
+	/// (default) if not.
+	#[pallet::storage]
+	pub(super) type UpgradedToTripleRefCount<T: Config> = StorageValue<_, bool, ValueQuery>;
+
+	/// The execution phase of the block.
+	#[pallet::storage]
+	#[pallet::whitelist_storage]
+	pub(super) type ExecutionPhase<T: Config> = StorageValue<_, Phase>;
+
+	#[derive(frame_support::DefaultNoBound)]
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		#[serde(with = "sp_core::bytes")]
+		pub code: Vec<u8>,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			<BlockHash<T>>::insert::<_, T::Hash>(BlockNumberFor::<T>::zero(), hash69());
+			<ParentHash<T>>::put::<T::Hash>(hash69());
+			<LastRuntimeUpgrade<T>>::put(LastRuntimeUpgradeInfo::from(T::Version::get()));
+			<UpgradedToU32RefCount<T>>::put(true);
+			<UpgradedToTripleRefCount<T>>::put(true);
+
+			sp_io::storage::set(well_known_keys::CODE, &self.code);
+			sp_io::storage::set(well_known_keys::EXTRINSIC_INDEX, &0u32.encode());
+		}
+	}
+}
+
+pub type Key = Vec<u8>;
+pub type KeyValue = (Vec<u8>, Vec<u8>);
+
+/// A phase of a block's execution.
+#[derive(Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(feature = "std", derive(Serialize, PartialEq, Eq, Clone))]
+pub enum Phase {
+	/// Applying an extrinsic.
+	ApplyExtrinsic(u32),
+	/// Finalizing the block.
+	Finalization,
+	/// Initializing the block.
+	Initialization,
+}
+
+impl Default for Phase {
+	fn default() -> Self {
+		Self::Initialization
+	}
+}
+
+/// Record of an event happening.
+#[derive(Encode, Decode, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Serialize, PartialEq, Eq, Clone))]
+pub struct EventRecord<E: Parameter + Member, T> {
+	/// The phase of the block it happened in.
+	pub phase: Phase,
+	/// The event itself.
+	pub event: E,
+	/// The list of the topics this event has.
+	pub topics: Vec<T>,
+}
+
+// Create a Hash with 69 for each byte,
+// only used to build genesis config.
+fn hash69<T: AsMut<[u8]> + Default>() -> T {
+	let mut h = T::default();
+	h.as_mut().iter_mut().for_each(|byte| *byte = 69);
+	h
+}
+
+/// This type alias represents an index of an event.
+///
+/// We use `u32` here because this index is used as index for `Events<T>`
+/// which can't contain more than `u32::MAX` items.
+type EventIndex = u32;
+
+/// Type used to encode the number of references an account has.
+pub type RefCount = u32;
+
+/// Information of an account.
+#[derive(Clone, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub struct AccountInfo<Nonce, AccountData> {
+	/// The number of transactions this account has sent.
+	pub nonce: Nonce,
+	/// The number of other modules that currently depend on this account's existence. The account
+	/// cannot be reaped until this is zero.
+	pub consumers: RefCount,
+	/// The number of other modules that allow this account to exist. The account may not be reaped
+	/// until this and `sufficients` are both zero.
+	pub providers: RefCount,
+	/// The number of modules that allow this account to exist for their own purposes only. The
+	/// account may not be reaped until this and `providers` are both zero.
+	pub sufficients: RefCount,
+	/// The additional data that belongs to this account. Used to store the balance(s) in a lot of
+	/// chains.
+	pub data: AccountData,
+}
+
+/// Stores the `spec_version` and `spec_name` of when the last runtime upgrade
+/// happened.
+#[derive(sp_runtime::RuntimeDebug, Encode, Decode, TypeInfo)]
+#[cfg_attr(feature = "std", derive(PartialEq))]
+pub struct LastRuntimeUpgradeInfo {
+	pub spec_version: codec::Compact<u32>,
+	pub spec_name: sp_runtime::RuntimeString,
+}
+
+impl LastRuntimeUpgradeInfo {
+	/// Returns if the runtime was upgraded in comparison of `self` and `current`.
+	///
+	/// Checks if either the `spec_version` increased or the `spec_name` changed.
+	pub fn was_upgraded(&self, current: &sp_version::RuntimeVersion) -> bool {
+		current.spec_version > self.spec_version.0 || current.spec_name != self.spec_name
+	}
+}
+
+impl From<sp_version::RuntimeVersion> for LastRuntimeUpgradeInfo {
+	fn from(version: sp_version::RuntimeVersion) -> Self {
+		Self { spec_version: version.spec_version.into(), spec_name: version.spec_name }
+	}
+}
+
+/// Ensure the origin is Root.
+pub struct EnsureRoot<AccountId>(sp_std::marker::PhantomData<AccountId>);
+impl<O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>, AccountId>
+	EnsureOrigin<O> for EnsureRoot<AccountId>
+{
+	type Success = ();
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Root => Ok(()),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Ok(O::from(RawOrigin::Root))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., AccountId: Decode, T } >
+		EnsureOriginWithArg<O, T> for EnsureRoot<AccountId>
+	{}
+}
+
+/// Ensure the origin is Root and return the provided `Success` value.
+pub struct EnsureRootWithSuccess<AccountId, Success>(
+	sp_std::marker::PhantomData<(AccountId, Success)>,
+);
+impl<
+		O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>,
+		AccountId,
+		Success: TypedGet,
+	> EnsureOrigin<O> for EnsureRootWithSuccess<AccountId, Success>
+{
+	type Success = Success::Type;
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Root => Ok(Success::get()),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Ok(O::from(RawOrigin::Root))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., AccountId: Decode, Success: TypedGet, T } >
+		EnsureOriginWithArg<O, T> for EnsureRootWithSuccess<AccountId, Success>
+	{}
+}
+
+/// Ensure the origin is provided `Ensure` origin and return the provided `Success` value.
+pub struct EnsureWithSuccess<Ensure, AccountId, Success>(
+	sp_std::marker::PhantomData<(Ensure, AccountId, Success)>,
+);
+
+impl<
+		O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>,
+		Ensure: EnsureOrigin<O>,
+		AccountId,
+		Success: TypedGet,
+	> EnsureOrigin<O> for EnsureWithSuccess<Ensure, AccountId, Success>
+{
+	type Success = Success::Type;
+
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		Ensure::try_origin(o).map(|_| Success::get())
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Ensure::try_successful_origin()
+	}
+}
+
+/// Ensure the origin is any `Signed` origin.
+pub struct EnsureSigned<AccountId>(sp_std::marker::PhantomData<AccountId>);
+impl<O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>, AccountId: Decode>
+	EnsureOrigin<O> for EnsureSigned<AccountId>
+{
+	type Success = AccountId;
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Signed(who) => Ok(who),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		let zero_account_id =
+			AccountId::decode(&mut TrailingZeroInput::zeroes()).map_err(|_| ())?;
+		Ok(O::from(RawOrigin::Signed(zero_account_id)))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., AccountId: Decode, T } >
+		EnsureOriginWithArg<O, T> for EnsureSigned<AccountId>
+	{}
+}
+
+/// Ensure the origin is `Signed` origin from the given `AccountId`.
+pub struct EnsureSignedBy<Who, AccountId>(sp_std::marker::PhantomData<(Who, AccountId)>);
+impl<
+		O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>,
+		Who: SortedMembers<AccountId>,
+		AccountId: PartialEq + Clone + Ord + Decode,
+	> EnsureOrigin<O> for EnsureSignedBy<Who, AccountId>
+{
+	type Success = AccountId;
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::Signed(ref who) if Who::contains(who) => Ok(who.clone()),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		let first_member = match Who::sorted_members().first() {
+			Some(account) => account.clone(),
+			None => AccountId::decode(&mut TrailingZeroInput::zeroes()).map_err(|_| ())?,
+		};
+		Ok(O::from(RawOrigin::Signed(first_member)))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., Who: SortedMembers<AccountId>, AccountId: PartialEq + Clone + Ord + Decode, T } >
+		EnsureOriginWithArg<O, T> for EnsureSignedBy<Who, AccountId>
+	{}
+}
+
+/// Ensure the origin is `None`. i.e. unsigned transaction.
+pub struct EnsureNone<AccountId>(sp_std::marker::PhantomData<AccountId>);
+impl<O: Into<Result<RawOrigin<AccountId>, O>> + From<RawOrigin<AccountId>>, AccountId>
+	EnsureOrigin<O> for EnsureNone<AccountId>
+{
+	type Success = ();
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		o.into().and_then(|o| match o {
+			RawOrigin::None => Ok(()),
+			r => Err(O::from(r)),
+		})
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Ok(O::from(RawOrigin::None))
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O: .., AccountId, T } >
+		EnsureOriginWithArg<O, T> for EnsureNone<AccountId>
+	{}
+}
+
+/// Always fail.
+pub struct EnsureNever<Success>(sp_std::marker::PhantomData<Success>);
+impl<O, Success> EnsureOrigin<O> for EnsureNever<Success> {
+	type Success = Success;
+	fn try_origin(o: O) -> Result<Self::Success, O> {
+		Err(o)
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<O, ()> {
+		Err(())
+	}
+}
+
+impl_ensure_origin_with_arg_ignoring_arg! {
+	impl< { O, Success, T } >
+		EnsureOriginWithArg<O, T> for EnsureNever<Success>
+	{}
+}
+
+/// Ensure that the origin `o` represents a signed extrinsic (i.e. transaction).
+/// Returns `Ok` with the account that signed the extrinsic or an `Err` otherwise.
+pub fn ensure_signed<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<AccountId, BadOrigin>
+where
+	OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
+{
+	match o.into() {
+		Ok(RawOrigin::Signed(t)) => Ok(t),
+		_ => Err(BadOrigin),
+	}
+}
+
+/// Ensure that the origin `o` represents either a signed extrinsic (i.e. transaction) or the root.
+/// Returns `Ok` with the account that signed the extrinsic, `None` if it was root,  or an `Err`
+/// otherwise.
+pub fn ensure_signed_or_root<OuterOrigin, AccountId>(
+	o: OuterOrigin,
+) -> Result<Option<AccountId>, BadOrigin>
+where
+	OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
+{
+	match o.into() {
+		Ok(RawOrigin::Root) => Ok(None),
+		Ok(RawOrigin::Signed(t)) => Ok(Some(t)),
+		_ => Err(BadOrigin),
+	}
+}
+
+/// Ensure that the origin `o` represents the root. Returns `Ok` or an `Err` otherwise.
+pub fn ensure_root<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<(), BadOrigin>
+where
+	OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
+{
+	match o.into() {
+		Ok(RawOrigin::Root) => Ok(()),
+		_ => Err(BadOrigin),
+	}
+}
+
+/// Ensure that the origin `o` represents an unsigned extrinsic. Returns `Ok` or an `Err` otherwise.
+pub fn ensure_none<OuterOrigin, AccountId>(o: OuterOrigin) -> Result<(), BadOrigin>
+where
+	OuterOrigin: Into<Result<RawOrigin<AccountId>, OuterOrigin>>,
+{
+	match o.into() {
+		Ok(RawOrigin::None) => Ok(()),
+		_ => Err(BadOrigin),
+	}
+}
+
+/// Reference status; can be either referenced or unreferenced.
+#[derive(RuntimeDebug)]
+pub enum RefStatus {
+	Referenced,
+	Unreferenced,
+}
+
+/// Some resultant status relevant to incrementing a provider/self-sufficient reference.
+#[derive(Eq, PartialEq, RuntimeDebug)]
+pub enum IncRefStatus {
+	/// Account was created.
+	Created,
+	/// Account already existed.
+	Existed,
+}
+
+/// Some resultant status relevant to decrementing a provider/self-sufficient reference.
+#[derive(Eq, PartialEq, RuntimeDebug)]
+pub enum DecRefStatus {
+	/// Account was destroyed.
+	Reaped,
+	/// Account still exists.
+	Exists,
+}
+
+impl<T: Config> Pallet<T> {
+	pub fn account_exists(who: &T::AccountId) -> bool {
+		Account::<T>::contains_key(who)
+	}
+
+	/// Write code to the storage and emit related events and digest items.
+	///
+	/// Note this function almost never should be used directly. It is exposed
+	/// for `OnSetCode` implementations that defer actual code being written to
+	/// the storage (for instance in case of parachains).
+	pub fn update_code_in_storage(code: &[u8]) -> DispatchResult {
+		storage::unhashed::put_raw(well_known_keys::CODE, code);
+		Self::deposit_log(generic::DigestItem::RuntimeEnvironmentUpdated);
+		Self::deposit_event(Event::CodeUpdated);
+		Ok(())
+	}
+
+	/// Increment the reference counter on an account.
+	#[deprecated = "Use `inc_consumers` instead"]
+	pub fn inc_ref(who: &T::AccountId) {
+		let _ = Self::inc_consumers(who);
+	}
+
+	/// Decrement the reference counter on an account. This *MUST* only be done once for every time
+	/// you called `inc_consumers` on `who`.
+	#[deprecated = "Use `dec_consumers` instead"]
+	pub fn dec_ref(who: &T::AccountId) {
+		let _ = Self::dec_consumers(who);
+	}
+
+	/// The number of outstanding references for the account `who`.
+	#[deprecated = "Use `consumers` instead"]
+	pub fn refs(who: &T::AccountId) -> RefCount {
+		Self::consumers(who)
+	}
+
+	/// True if the account has no outstanding references.
+	#[deprecated = "Use `!is_provider_required` instead"]
+	pub fn allow_death(who: &T::AccountId) -> bool {
+		!Self::is_provider_required(who)
+	}
+
+	/// Increment the provider reference counter on an account.
+	pub fn inc_providers(who: &T::AccountId) -> IncRefStatus {
+		Account::<T>::mutate(who, |a| {
+			if a.providers == 0 && a.sufficients == 0 {
+				// Account is being created.
+				a.providers = 1;
+				Self::on_created_account(who.clone(), a);
+				IncRefStatus::Created
+			} else {
+				a.providers = a.providers.saturating_add(1);
+				IncRefStatus::Existed
+			}
+		})
+	}
+
+	/// Decrement the provider reference counter on an account.
+	///
+	/// This *MUST* only be done once for every time you called `inc_providers` on `who`.
+	pub fn dec_providers(who: &T::AccountId) -> Result<DecRefStatus, DispatchError> {
+		Account::<T>::try_mutate_exists(who, |maybe_account| {
+			if let Some(mut account) = maybe_account.take() {
+				if account.providers == 0 {
+					// Logic error - cannot decrement beyond zero.
+					log::error!(
+						target: LOG_TARGET,
+						"Logic error: Unexpected underflow in reducing provider",
+					);
+					account.providers = 1;
+				}
+				match (account.providers, account.consumers, account.sufficients) {
+					(1, 0, 0) => {
+						// No providers left (and no consumers) and no sufficients. Account dead.
+
+						Pallet::<T>::on_killed_account(who.clone());
+						Ok(DecRefStatus::Reaped)
+					},
+					(1, c, _) if c > 0 => {
+						// Cannot remove last provider if there are consumers.
+						Err(DispatchError::ConsumerRemaining)
+					},
+					(x, _, _) => {
+						// Account will continue to exist as there is either > 1 provider or
+						// > 0 sufficients.
+						account.providers = x - 1;
+						*maybe_account = Some(account);
+						Ok(DecRefStatus::Exists)
+					},
+				}
+			} else {
+				log::error!(
+					target: LOG_TARGET,
+					"Logic error: Account already dead when reducing provider",
+				);
+				Ok(DecRefStatus::Reaped)
+			}
+		})
+	}
+
+	/// Increment the self-sufficient reference counter on an account.
+	pub fn inc_sufficients(who: &T::AccountId) -> IncRefStatus {
+		Account::<T>::mutate(who, |a| {
+			if a.providers + a.sufficients == 0 {
+				// Account is being created.
+				a.sufficients = 1;
+				Self::on_created_account(who.clone(), a);
+				IncRefStatus::Created
+			} else {
+				a.sufficients = a.sufficients.saturating_add(1);
+				IncRefStatus::Existed
+			}
+		})
+	}
+
+	/// Decrement the sufficients reference counter on an account.
+	///
+	/// This *MUST* only be done once for every time you called `inc_sufficients` on `who`.
+	pub fn dec_sufficients(who: &T::AccountId) -> DecRefStatus {
+		Account::<T>::mutate_exists(who, |maybe_account| {
+			if let Some(mut account) = maybe_account.take() {
+				if account.sufficients == 0 {
+					// Logic error - cannot decrement beyond zero.
+					log::error!(
+						target: LOG_TARGET,
+						"Logic error: Unexpected underflow in reducing sufficients",
+					);
+				}
+				match (account.sufficients, account.providers) {
+					(0, 0) | (1, 0) => {
+						Pallet::<T>::on_killed_account(who.clone());
+						DecRefStatus::Reaped
+					},
+					(x, _) => {
+						account.sufficients = x - 1;
+						*maybe_account = Some(account);
+						DecRefStatus::Exists
+					},
+				}
+			} else {
+				log::error!(
+					target: LOG_TARGET,
+					"Logic error: Account already dead when reducing provider",
+				);
+				DecRefStatus::Reaped
+			}
+		})
+	}
+
+	/// The number of outstanding provider references for the account `who`.
+	pub fn providers(who: &T::AccountId) -> RefCount {
+		Account::<T>::get(who).providers
+	}
+
+	/// The number of outstanding sufficient references for the account `who`.
+	pub fn sufficients(who: &T::AccountId) -> RefCount {
+		Account::<T>::get(who).sufficients
+	}
+
+	/// The number of outstanding provider and sufficient references for the account `who`.
+	pub fn reference_count(who: &T::AccountId) -> RefCount {
+		let a = Account::<T>::get(who);
+		a.providers + a.sufficients
+	}
+
+	/// Increment the reference counter on an account.
+	///
+	/// The account `who`'s `providers` must be non-zero and the current number of consumers must
+	/// be less than `MaxConsumers::max_consumers()` or this will return an error.
+	pub fn inc_consumers(who: &T::AccountId) -> Result<(), DispatchError> {
+		Account::<T>::try_mutate(who, |a| {
+			if a.providers > 0 {
+				if a.consumers < T::MaxConsumers::max_consumers() {
+					a.consumers = a.consumers.saturating_add(1);
+					Ok(())
+				} else {
+					Err(DispatchError::TooManyConsumers)
+				}
+			} else {
+				Err(DispatchError::NoProviders)
+			}
+		})
+	}
+
+	/// Increment the reference counter on an account, ignoring the `MaxConsumers` limits.
+	///
+	/// The account `who`'s `providers` must be non-zero or this will return an error.
+	pub fn inc_consumers_without_limit(who: &T::AccountId) -> Result<(), DispatchError> {
+		Account::<T>::try_mutate(who, |a| {
+			if a.providers > 0 {
+				a.consumers = a.consumers.saturating_add(1);
+				Ok(())
+			} else {
+				Err(DispatchError::NoProviders)
+			}
+		})
+	}
+
+	/// Decrement the reference counter on an account. This *MUST* only be done once for every time
+	/// you called `inc_consumers` on `who`.
+	pub fn dec_consumers(who: &T::AccountId) {
+		Account::<T>::mutate(who, |a| {
+			if a.consumers > 0 {
+				a.consumers -= 1;
+			} else {
+				log::error!(
+					target: LOG_TARGET,
+					"Logic error: Unexpected underflow in reducing consumer",
+				);
+			}
+		})
+	}
+
+	/// The number of outstanding references for the account `who`.
+	pub fn consumers(who: &T::AccountId) -> RefCount {
+		Account::<T>::get(who).consumers
+	}
+
+	/// True if the account has some outstanding consumer references.
+	pub fn is_provider_required(who: &T::AccountId) -> bool {
+		Account::<T>::get(who).consumers != 0
+	}
+
+	/// True if the account has no outstanding consumer references or more than one provider.
+	pub fn can_dec_provider(who: &T::AccountId) -> bool {
+		let a = Account::<T>::get(who);
+		a.consumers == 0 || a.providers > 1
+	}
+
+	/// True if the account has at least one provider reference and adding `amount` consumer
+	/// references would not take it above the the maximum.
+	pub fn can_accrue_consumers(who: &T::AccountId, amount: u32) -> bool {
+		let a = Account::<T>::get(who);
+		match a.consumers.checked_add(amount) {
+			Some(c) => a.providers > 0 && c <= T::MaxConsumers::max_consumers(),
+			None => false,
+		}
+	}
+
+	/// True if the account has at least one provider reference and fewer consumer references than
+	/// the maximum.
+	pub fn can_inc_consumer(who: &T::AccountId) -> bool {
+		Self::can_accrue_consumers(who, 1)
+	}
+
+	/// Deposits an event into this block's event record.
+	///
+	/// NOTE: Events not registered at the genesis block and quietly omitted.
+	pub fn deposit_event(event: impl Into<T::RuntimeEvent>) {
+		Self::deposit_event_indexed(&[], event.into());
+	}
+
+	/// Deposits an event into this block's event record adding this event
+	/// to the corresponding topic indexes.
+	///
+	/// This will update storage entries that correspond to the specified topics.
+	/// It is expected that light-clients could subscribe to this topics.
+	///
+	/// NOTE: Events not registered at the genesis block and quietly omitted.
+	pub fn deposit_event_indexed(topics: &[T::Hash], event: T::RuntimeEvent) {
+		let block_number = Self::block_number();
+		// Don't populate events on genesis.
+		if block_number.is_zero() {
+			return
+		}
+
+		let phase = ExecutionPhase::<T>::get().unwrap_or_default();
+		let event = EventRecord { phase, event, topics: topics.to_vec() };
+
+		// Index of the event to be added.
+		let event_idx = {
+			let old_event_count = EventCount::<T>::get();
+			let new_event_count = match old_event_count.checked_add(1) {
+				// We've reached the maximum number of events at this block, just
+				// don't do anything and leave the event_count unaltered.
+				None => return,
+				Some(nc) => nc,
+			};
+			EventCount::<T>::put(new_event_count);
+			old_event_count
+		};
+
+		Events::<T>::append(event);
+
+		for topic in topics {
+			<EventTopics<T>>::append(topic, &(block_number, event_idx));
+		}
+	}
+
+	/// Gets the index of extrinsic that is currently executing.
+	pub fn extrinsic_index() -> Option<u32> {
+		storage::unhashed::get(well_known_keys::EXTRINSIC_INDEX)
+	}
+
+	/// Gets extrinsics count.
+	pub fn extrinsic_count() -> u32 {
+		ExtrinsicCount::<T>::get().unwrap_or_default()
+	}
+
+	pub fn all_extrinsics_len() -> u32 {
+		AllExtrinsicsLen::<T>::get().unwrap_or_default()
+	}
+
+	/// Inform the system pallet of some additional weight that should be accounted for, in the
+	/// current block.
+	///
+	/// NOTE: use with extra care; this function is made public only be used for certain pallets
+	/// that need it. A runtime that does not have dynamic calls should never need this and should
+	/// stick to static weights. A typical use case for this is inner calls or smart contract calls.
+	/// Furthermore, it only makes sense to use this when it is presumably  _cheap_ to provide the
+	/// argument `weight`; In other words, if this function is to be used to account for some
+	/// unknown, user provided call's weight, it would only make sense to use it if you are sure you
+	/// can rapidly compute the weight of the inner call.
+	///
+	/// Even more dangerous is to note that this function does NOT take any action, if the new sum
+	/// of block weight is more than the block weight limit. This is what the _unchecked_.
+	///
+	/// Another potential use-case could be for the `on_initialize` and `on_finalize` hooks.
+	pub fn register_extra_weight_unchecked(weight: Weight, class: DispatchClass) {
+		BlockWeight::<T>::mutate(|current_weight| {
+			current_weight.accrue(weight, class);
+		});
+	}
+
+	/// Start the execution of a particular block.
+	pub fn initialize(number: &BlockNumberFor<T>, parent_hash: &T::Hash, digest: &generic::Digest) {
+		// populate environment
+		ExecutionPhase::<T>::put(Phase::Initialization);
+		storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &0u32);
+		let entropy = (b"frame_system::initialize", parent_hash).using_encoded(blake2_256);
+		storage::unhashed::put_raw(well_known_keys::INTRABLOCK_ENTROPY, &entropy[..]);
+		<Number<T>>::put(number);
+		<Digest<T>>::put(digest);
+		<ParentHash<T>>::put(parent_hash);
+		<BlockHash<T>>::insert(*number - One::one(), parent_hash);
+
+		// Remove previous block data from storage
+		BlockWeight::<T>::kill();
+	}
+
+	/// Remove temporary "environment" entries in storage, compute the storage root and return the
+	/// resulting header for this block.
+	pub fn finalize() -> HeaderFor<T> {
+		log::debug!(
+			target: LOG_TARGET,
+			"[{:?}] {} extrinsics, length: {} (normal {}%, op: {}%, mandatory {}%) / normal weight:\
+			 {} ({}%) op weight {} ({}%) / mandatory weight {} ({}%)",
+			Self::block_number(),
+			Self::extrinsic_index().unwrap_or_default(),
+			Self::all_extrinsics_len(),
+			sp_runtime::Percent::from_rational(
+				Self::all_extrinsics_len(),
+				*T::BlockLength::get().max.get(DispatchClass::Normal)
+			).deconstruct(),
+			sp_runtime::Percent::from_rational(
+				Self::all_extrinsics_len(),
+				*T::BlockLength::get().max.get(DispatchClass::Operational)
+			).deconstruct(),
+			sp_runtime::Percent::from_rational(
+				Self::all_extrinsics_len(),
+				*T::BlockLength::get().max.get(DispatchClass::Mandatory)
+			).deconstruct(),
+			Self::block_weight().get(DispatchClass::Normal),
+			sp_runtime::Percent::from_rational(
+				Self::block_weight().get(DispatchClass::Normal).ref_time(),
+				T::BlockWeights::get().get(DispatchClass::Normal).max_total.unwrap_or(Bounded::max_value()).ref_time()
+			).deconstruct(),
+			Self::block_weight().get(DispatchClass::Operational),
+			sp_runtime::Percent::from_rational(
+				Self::block_weight().get(DispatchClass::Operational).ref_time(),
+				T::BlockWeights::get().get(DispatchClass::Operational).max_total.unwrap_or(Bounded::max_value()).ref_time()
+			).deconstruct(),
+			Self::block_weight().get(DispatchClass::Mandatory),
+			sp_runtime::Percent::from_rational(
+				Self::block_weight().get(DispatchClass::Mandatory).ref_time(),
+				T::BlockWeights::get().get(DispatchClass::Mandatory).max_total.unwrap_or(Bounded::max_value()).ref_time()
+			).deconstruct(),
+		);
+		ExecutionPhase::<T>::kill();
+		AllExtrinsicsLen::<T>::kill();
+		storage::unhashed::kill(well_known_keys::INTRABLOCK_ENTROPY);
+
+		// The following fields
+		//
+		// - <Events<T>>
+		// - <EventCount<T>>
+		// - <EventTopics<T>>
+		// - <Number<T>>
+		// - <ParentHash<T>>
+		// - <Digest<T>>
+		//
+		// stay to be inspected by the client and will be cleared by `Self::initialize`.
+		let number = <Number<T>>::get();
+		let parent_hash = <ParentHash<T>>::get();
+		let digest = <Digest<T>>::get();
+
+		let extrinsics = (0..ExtrinsicCount::<T>::take().unwrap_or_default())
+			.map(ExtrinsicData::<T>::take)
+			.collect();
+		let extrinsics_root = extrinsics_data_root::<T::Hashing>(extrinsics);
+
+		// move block hash pruning window by one block
+		let block_hash_count = T::BlockHashCount::get();
+		let to_remove = number.saturating_sub(block_hash_count).saturating_sub(One::one());
+
+		// keep genesis hash
+		if !to_remove.is_zero() {
+			<BlockHash<T>>::remove(to_remove);
+		}
+
+		let version = T::Version::get().state_version();
+		let storage_root = T::Hash::decode(&mut &sp_io::storage::root(version)[..])
+			.expect("Node is configured to use the same hash; qed");
+
+		HeaderFor::<T>::new(number, extrinsics_root, storage_root, parent_hash, digest)
+	}
+
+	/// Deposits a log and ensures it matches the block's log data.
+	pub fn deposit_log(item: generic::DigestItem) {
+		<Digest<T>>::append(item);
+	}
+
+	/// Get the basic externalities for this pallet, useful for tests.
+	#[cfg(any(feature = "std", test))]
+	pub fn externalities() -> TestExternalities {
+		TestExternalities::new(sp_core::storage::Storage {
+			top: map![
+				<BlockHash<T>>::hashed_key_for(BlockNumberFor::<T>::zero()) => [69u8; 32].encode(),
+				<Number<T>>::hashed_key().to_vec() => BlockNumberFor::<T>::one().encode(),
+				<ParentHash<T>>::hashed_key().to_vec() => [69u8; 32].encode()
+			],
+			children_default: map![],
+		})
+	}
+
+	/// Get the current events deposited by the runtime.
+	///
+	/// NOTE: This should only be used in tests. Reading events from the runtime can have a large
+	/// impact on the PoV size of a block. Users should use alternative and well bounded storage
+	/// items for any behavior like this.
+	///
+	/// NOTE: Events not registered at the genesis block and quietly omitted.
+	#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
+	pub fn events() -> Vec<EventRecord<T::RuntimeEvent, T::Hash>> {
+		debug_assert!(
+			!Self::block_number().is_zero(),
+			"events not registered at the genesis block"
+		);
+		// Dereferencing the events here is fine since we are not in the
+		// memory-restricted runtime.
+		Self::read_events_no_consensus().map(|e| *e).collect()
+	}
+
+	/// Get a single event at specified index.
+	///
+	/// Should only be called if you know what you are doing and outside of the runtime block
+	/// execution else it can have a large impact on the PoV size of a block.
+	pub fn event_no_consensus(index: usize) -> Option<T::RuntimeEvent> {
+		Self::read_events_no_consensus().nth(index).map(|e| e.event.clone())
+	}
+
+	/// Get the current events deposited by the runtime.
+	///
+	/// Should only be called if you know what you are doing and outside of the runtime block
+	/// execution else it can have a large impact on the PoV size of a block.
+	pub fn read_events_no_consensus(
+	) -> impl sp_std::iter::Iterator<Item = Box<EventRecord<T::RuntimeEvent, T::Hash>>> {
+		Events::<T>::stream_iter()
+	}
+
+	/// Set the block number to something in particular. Can be used as an alternative to
+	/// `initialize` for tests that don't need to bother with the other environment entries.
+	#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
+	pub fn set_block_number(n: BlockNumberFor<T>) {
+		<Number<T>>::put(n);
+	}
+
+	/// Sets the index of extrinsic that is currently executing.
+	#[cfg(any(feature = "std", test))]
+	pub fn set_extrinsic_index(extrinsic_index: u32) {
+		storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &extrinsic_index)
+	}
+
+	/// Set the parent hash number to something in particular. Can be used as an alternative to
+	/// `initialize` for tests that don't need to bother with the other environment entries.
+	#[cfg(any(feature = "std", test))]
+	pub fn set_parent_hash(n: T::Hash) {
+		<ParentHash<T>>::put(n);
+	}
+
+	/// Set the current block weight. This should only be used in some integration tests.
+	#[cfg(any(feature = "std", test))]
+	pub fn set_block_consumed_resources(weight: Weight, len: usize) {
+		BlockWeight::<T>::mutate(|current_weight| {
+			current_weight.set(weight, DispatchClass::Normal)
+		});
+		AllExtrinsicsLen::<T>::put(len as u32);
+	}
+
+	/// Reset events.
+	///
+	/// This needs to be used in prior calling [`initialize`](Self::initialize) for each new block
+	/// to clear events from previous block.
+	pub fn reset_events() {
+		<Events<T>>::kill();
+		EventCount::<T>::kill();
+		let _ = <EventTopics<T>>::clear(u32::max_value(), None);
+	}
+
+	/// Assert the given `event` exists.
+	///
+	/// NOTE: Events not registered at the genesis block and quietly omitted.
+	#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
+	pub fn assert_has_event(event: T::RuntimeEvent) {
+		let events = Self::events();
+		assert!(
+			events.iter().any(|record| record.event == event),
+			"expected event {event:?} not found in events {events:?}",
+		);
+	}
+
+	/// Assert the last event equal to the given `event`.
+	///
+	/// NOTE: Events not registered at the genesis block and quietly omitted.
+	#[cfg(any(feature = "std", feature = "runtime-benchmarks", test))]
+	pub fn assert_last_event(event: T::RuntimeEvent) {
+		let last_event = Self::events().last().expect("events expected").event.clone();
+		assert_eq!(
+			last_event, event,
+			"expected event {event:?} is not equal to the last event {last_event:?}",
+		);
+	}
+
+	/// Return the chain's current runtime version.
+	pub fn runtime_version() -> RuntimeVersion {
+		T::Version::get()
+	}
+
+	/// Retrieve the account transaction counter from storage.
+	pub fn account_nonce(who: impl EncodeLike<T::AccountId>) -> T::Nonce {
+		Account::<T>::get(who).nonce
+	}
+
+	/// Increment a particular account's nonce by 1.
+	pub fn inc_account_nonce(who: impl EncodeLike<T::AccountId>) {
+		Account::<T>::mutate(who, |a| a.nonce += T::Nonce::one());
+	}
+
+	/// Note what the extrinsic data of the current extrinsic index is.
+	///
+	/// This is required to be called before applying an extrinsic. The data will used
+	/// in [`Self::finalize`] to calculate the correct extrinsics root.
+	pub fn note_extrinsic(encoded_xt: Vec<u8>) {
+		ExtrinsicData::<T>::insert(Self::extrinsic_index().unwrap_or_default(), encoded_xt);
+	}
+
+	/// To be called immediately after an extrinsic has been applied.
+	///
+	/// Emits an `ExtrinsicSuccess` or `ExtrinsicFailed` event depending on the outcome.
+	/// The emitted event contains the post-dispatch corrected weight including
+	/// the base-weight for its dispatch class.
+	pub fn note_applied_extrinsic(r: &DispatchResultWithPostInfo, mut info: DispatchInfo) {
+		info.weight = extract_actual_weight(r, &info)
+			.saturating_add(T::BlockWeights::get().get(info.class).base_extrinsic);
+		info.pays_fee = extract_actual_pays_fee(r, &info);
+
+		Self::deposit_event(match r {
+			Ok(_) => Event::ExtrinsicSuccess { dispatch_info: info },
+			Err(err) => {
+				log::trace!(
+					target: LOG_TARGET,
+					"Extrinsic failed at block({:?}): {:?}",
+					Self::block_number(),
+					err,
+				);
+				Event::ExtrinsicFailed { dispatch_error: err.error, dispatch_info: info }
+			},
+		});
+
+		let next_extrinsic_index = Self::extrinsic_index().unwrap_or_default() + 1u32;
+
+		storage::unhashed::put(well_known_keys::EXTRINSIC_INDEX, &next_extrinsic_index);
+		ExecutionPhase::<T>::put(Phase::ApplyExtrinsic(next_extrinsic_index));
+	}
+
+	/// To be called immediately after `note_applied_extrinsic` of the last extrinsic of the block
+	/// has been called.
+	pub fn note_finished_extrinsics() {
+		let extrinsic_index: u32 =
+			storage::unhashed::take(well_known_keys::EXTRINSIC_INDEX).unwrap_or_default();
+		ExtrinsicCount::<T>::put(extrinsic_index);
+		ExecutionPhase::<T>::put(Phase::Finalization);
+	}
+
+	/// To be called immediately after finishing the initialization of the block
+	/// (e.g., called `on_initialize` for all pallets).
+	pub fn note_finished_initialize() {
+		ExecutionPhase::<T>::put(Phase::ApplyExtrinsic(0))
+	}
+
+	/// An account is being created.
+	pub fn on_created_account(who: T::AccountId, _a: &mut AccountInfo<T::Nonce, T::AccountData>) {
+		T::OnNewAccount::on_new_account(&who);
+		Self::deposit_event(Event::NewAccount { account: who });
+	}
+
+	/// Do anything that needs to be done after an account has been killed.
+	fn on_killed_account(who: T::AccountId) {
+		T::OnKilledAccount::on_killed_account(&who);
+		Self::deposit_event(Event::KilledAccount { account: who });
+	}
+
+	/// Determine whether or not it is possible to update the code.
+	///
+	/// Checks the given code if it is a valid runtime wasm blob by instantianting
+	/// it and extracting the runtime version of it. It checks that the runtime version
+	/// of the old and new runtime has the same spec name and that the spec version is increasing.
+	pub fn can_set_code(code: &[u8]) -> Result<(), sp_runtime::DispatchError> {
+		let current_version = T::Version::get();
+		let new_version = sp_io::misc::runtime_version(code)
+			.and_then(|v| RuntimeVersion::decode(&mut &v[..]).ok())
+			.ok_or(Error::<T>::FailedToExtractRuntimeVersion)?;
+
+		cfg_if::cfg_if! {
+			if #[cfg(all(feature = "runtime-benchmarks", not(test)))] {
+					// Let's ensure the compiler doesn't optimize our fetching of the runtime version away.
+					core::hint::black_box((new_version, current_version));
+					Ok(())
+			} else {
+				if new_version.spec_name != current_version.spec_name {
+					return Err(Error::<T>::InvalidSpecName.into())
+				}
+
+				if new_version.spec_version <= current_version.spec_version {
+					return Err(Error::<T>::SpecVersionNeedsToIncrease.into())
+				}
+
+				Ok(())
+			}
+		}
+	}
+}
+
+/// Returns a 32 byte datum which is guaranteed to be universally unique. `entropy` is provided
+/// as a facility to reduce the potential for precalculating results.
+pub fn unique(entropy: impl Encode) -> [u8; 32] {
+	let mut last = [0u8; 32];
+	sp_io::storage::read(well_known_keys::INTRABLOCK_ENTROPY, &mut last[..], 0);
+	let next = (b"frame_system::unique", entropy, last).using_encoded(blake2_256);
+	sp_io::storage::set(well_known_keys::INTRABLOCK_ENTROPY, &next);
+	next
+}
+
+/// Event handler which registers a provider when created.
+pub struct Provider<T>(PhantomData<T>);
+impl<T: Config> HandleLifetime<T::AccountId> for Provider<T> {
+	fn created(t: &T::AccountId) -> Result<(), DispatchError> {
+		Pallet::<T>::inc_providers(t);
+		Ok(())
+	}
+	fn killed(t: &T::AccountId) -> Result<(), DispatchError> {
+		Pallet::<T>::dec_providers(t).map(|_| ())
+	}
+}
+
+/// Event handler which registers a self-sufficient when created.
+pub struct SelfSufficient<T>(PhantomData<T>);
+impl<T: Config> HandleLifetime<T::AccountId> for SelfSufficient<T> {
+	fn created(t: &T::AccountId) -> Result<(), DispatchError> {
+		Pallet::<T>::inc_sufficients(t);
+		Ok(())
+	}
+	fn killed(t: &T::AccountId) -> Result<(), DispatchError> {
+		Pallet::<T>::dec_sufficients(t);
+		Ok(())
+	}
+}
+
+/// Event handler which registers a consumer when created.
+pub struct Consumer<T>(PhantomData<T>);
+impl<T: Config> HandleLifetime<T::AccountId> for Consumer<T> {
+	fn created(t: &T::AccountId) -> Result<(), DispatchError> {
+		Pallet::<T>::inc_consumers(t)
+	}
+	fn killed(t: &T::AccountId) -> Result<(), DispatchError> {
+		Pallet::<T>::dec_consumers(t);
+		Ok(())
+	}
+}
+
+impl<T: Config> BlockNumberProvider for Pallet<T> {
+	type BlockNumber = BlockNumberFor<T>;
+
+	fn current_block_number() -> Self::BlockNumber {
+		Pallet::<T>::block_number()
+	}
+}
+
+/// Implement StoredMap for a simple single-item, provide-when-not-default system. This works fine
+/// for storing a single item which allows the account to continue existing as long as it's not
+/// empty/default.
+///
+/// Anything more complex will need more sophisticated logic.
+impl<T: Config> StoredMap<T::AccountId, T::AccountData> for Pallet<T> {
+	fn get(k: &T::AccountId) -> T::AccountData {
+		Account::<T>::get(k).data
+	}
+
+	fn try_mutate_exists<R, E: From<DispatchError>>(
+		k: &T::AccountId,
+		f: impl FnOnce(&mut Option<T::AccountData>) -> Result<R, E>,
+	) -> Result<R, E> {
+		let account = Account::<T>::get(k);
+		let is_default = account.data == T::AccountData::default();
+		let mut some_data = if is_default { None } else { Some(account.data) };
+		let result = f(&mut some_data)?;
+		if Self::providers(k) > 0 || Self::sufficients(k) > 0 {
+			Account::<T>::mutate(k, |a| a.data = some_data.unwrap_or_default());
+		} else {
+			Account::<T>::remove(k)
+		}
+		Ok(result)
+	}
+}
+
+/// Split an `option` into two constituent options, as defined by a `splitter` function.
+pub fn split_inner<T, R, S>(
+	option: Option<T>,
+	splitter: impl FnOnce(T) -> (R, S),
+) -> (Option<R>, Option<S>) {
+	match option {
+		Some(inner) => {
+			let (r, s) = splitter(inner);
+			(Some(r), Some(s))
+		},
+		None => (None, None),
+	}
+}
+
+pub struct ChainContext<T>(PhantomData<T>);
+impl<T> Default for ChainContext<T> {
+	fn default() -> Self {
+		ChainContext(PhantomData)
+	}
+}
+
+impl<T: Config> Lookup for ChainContext<T> {
+	type Source = <T::Lookup as StaticLookup>::Source;
+	type Target = <T::Lookup as StaticLookup>::Target;
+
+	fn lookup(&self, s: Self::Source) -> Result<Self::Target, LookupError> {
+		<T::Lookup as StaticLookup>::lookup(s)
+	}
+}
+
+/// Prelude to be used alongside pallet macro, for ease of use.
+pub mod pallet_prelude {
+	pub use crate::{ensure_none, ensure_root, ensure_signed, ensure_signed_or_root};
+
+	/// Type alias for the `Origin` associated type of system config.
+	pub type OriginFor<T> = <T as crate::Config>::RuntimeOrigin;
+
+	/// Type alias for the `Header`.
+	pub type HeaderFor<T> =
+		<<T as crate::Config>::Block as sp_runtime::traits::HeaderProvider>::HeaderT;
+
+	/// Type alias for the `BlockNumber` associated type of system config.
+	pub type BlockNumberFor<T> = <HeaderFor<T> as sp_runtime::traits::Header>::Number;
+}
diff --git a/substrate/frame/system/src/limits.rs b/substrate/frame/system/src/limits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5fd7a5af87571ff3a77442c1588a6f1fa5bee686
--- /dev/null
+++ b/substrate/frame/system/src/limits.rs
@@ -0,0 +1,450 @@
+// 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.
+
+//! Block resource limits configuration structures.
+//!
+//! FRAME defines two resources that are limited within a block:
+//! - Weight (execution cost/time)
+//! - Length (block size)
+//!
+//! `frame_system` tracks consumption of each of these resources separately for each
+//! `DispatchClass`. This module contains configuration object for both resources,
+//! which should be passed to `frame_system` configuration when runtime is being set up.
+
+use frame_support::{
+	dispatch::{DispatchClass, OneOrMany, PerDispatchClass},
+	weights::{constants, Weight},
+};
+use scale_info::TypeInfo;
+use sp_runtime::{traits::Bounded, Perbill, RuntimeDebug};
+
+/// Block length limit configuration.
+#[derive(RuntimeDebug, Clone, codec::Encode, codec::Decode, TypeInfo)]
+pub struct BlockLength {
+	/// Maximal total length in bytes for each extrinsic class.
+	///
+	/// In the worst case, the total block length is going to be:
+	/// `MAX(max)`
+	pub max: PerDispatchClass<u32>,
+}
+
+impl Default for BlockLength {
+	fn default() -> Self {
+		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, DEFAULT_NORMAL_RATIO)
+	}
+}
+
+impl BlockLength {
+	/// Create new `BlockLength` with `max` for every class.
+	pub fn max(max: u32) -> Self {
+		Self { max: PerDispatchClass::new(|_| max) }
+	}
+
+	/// Create new `BlockLength` with `max` for `Operational` & `Mandatory`
+	/// and `normal * max` for `Normal`.
+	pub fn max_with_normal_ratio(max: u32, normal: Perbill) -> Self {
+		Self {
+			max: PerDispatchClass::new(|class| {
+				if class == DispatchClass::Normal {
+					normal * max
+				} else {
+					max
+				}
+			}),
+		}
+	}
+}
+
+#[derive(Default, RuntimeDebug)]
+pub struct ValidationErrors {
+	pub has_errors: bool,
+	#[cfg(feature = "std")]
+	pub errors: Vec<String>,
+}
+
+macro_rules! error_assert {
+	($cond : expr, $err : expr, $format : expr $(, $params: expr )*$(,)*) => {
+		if !$cond {
+			$err.has_errors = true;
+			#[cfg(feature = "std")]
+			{ $err.errors.push(format!($format $(, &$params )*)); }
+		}
+	}
+}
+
+/// A result of validating `BlockWeights` correctness.
+pub type ValidationResult = Result<BlockWeights, ValidationErrors>;
+
+/// A ratio of `Normal` dispatch class within block, used as default value for
+/// `BlockWeight` and `BlockLength`. The `Default` impls are provided mostly for convenience
+/// to use in tests.
+const DEFAULT_NORMAL_RATIO: Perbill = Perbill::from_percent(75);
+
+/// `DispatchClass`-specific weight configuration.
+#[derive(RuntimeDebug, Clone, codec::Encode, codec::Decode, TypeInfo)]
+pub struct WeightsPerClass {
+	/// Base weight of single extrinsic of given class.
+	pub base_extrinsic: Weight,
+	/// Maximal weight of single extrinsic. Should NOT include `base_extrinsic` cost.
+	///
+	/// `None` indicates that this class of extrinsics doesn't have a limit.
+	pub max_extrinsic: Option<Weight>,
+	/// Block maximal total weight for all extrinsics of given class.
+	///
+	/// `None` indicates that weight sum of this class of extrinsics is not
+	/// restricted. Use this value carefully, since it might produce heavily oversized
+	/// blocks.
+	///
+	/// In the worst case, the total weight consumed by the class is going to be:
+	/// `MAX(max_total) + MAX(reserved)`.
+	pub max_total: Option<Weight>,
+	/// Block reserved allowance for all extrinsics of a particular class.
+	///
+	/// Setting to `None` indicates that extrinsics of that class are allowed
+	/// to go over total block weight (but at most `max_total` for that class).
+	/// Setting to `Some(x)` guarantees that at least `x` weight of particular class
+	/// is processed in every block.
+	pub reserved: Option<Weight>,
+}
+
+/// Block weight limits & base values configuration.
+///
+/// This object is responsible for defining weight limits and base weight values tracked
+/// during extrinsic execution.
+///
+/// Each block starts with `base_block` weight being consumed right away. Next up the
+/// `on_initialize` pallet callbacks are invoked and their cost is added before any extrinsic
+/// is executed. This cost is tracked as `Mandatory` dispatch class.
+///
+/// ```text,ignore
+/// |   | `max_block`    |   |
+/// |   |                |   |
+/// |   |                |   |
+/// |   |                |   |
+/// |   |                |  #| `on_initialize`
+/// |  #| `base_block`   |  #|
+/// |NOM|                |NOM|
+///  ||\_ Mandatory
+///  |\__ Operational
+///  \___ Normal
+/// ```
+///
+/// The remaining capacity can be used to dispatch extrinsics. Note that each dispatch class
+/// is being tracked separately, but the sum can't exceed `max_block` (except for `reserved`).
+/// Below you can see a picture representing full block with 3 extrinsics (two `Operational` and
+/// one `Normal`). Each class has it's own limit `max_total`, but also the sum cannot exceed
+/// `max_block` value.
+///
+/// ```text,ignore
+///                          -- `Mandatory` limit (unlimited)
+/// | # |                 |   |
+/// | # | `Ext3`          | - - `Operational` limit
+/// |#  | `Ext2`          |-  - `Normal` limit
+/// | # | `Ext1`          | # |
+/// |  #| `on_initialize` | ##|
+/// |  #| `base_block`    |###|
+/// |NOM|                 |NOM|
+/// ```
+///
+/// It should be obvious now that it's possible for one class to reach it's limit (say `Normal`),
+/// while the block has still capacity to process more transactions (`max_block` not reached,
+/// `Operational` transactions can still go in). Setting `max_total` to `None` disables the
+/// per-class limit. This is generally highly recommended for `Mandatory` dispatch class, while it
+/// can be dangerous for `Normal` class and should only be done with extra care and consideration.
+///
+/// Often it's desirable for some class of transactions to be added to the block despite it being
+/// full. For instance one might want to prevent high-priority `Normal` transactions from pushing
+/// out lower-priority `Operational` transactions. In such cases you might add a `reserved` capacity
+/// for given class.
+///
+/// ```test,ignore
+///              _
+///   #           \
+///   #   `Ext8`   - `reserved`
+///   #          _/
+/// | # | `Ext7                 | - - `Operational` limit
+/// |#  | `Ext6`                |   |
+/// |#  | `Ext5`                |-# - `Normal` limit
+/// |#  | `Ext4`                |## |
+/// |  #| `on_initialize`       |###|
+/// |  #| `base_block`          |###|
+/// |NOM|                       |NOM|
+/// ```
+///
+/// In the above example, `Ext4-6` fill up the block almost up to `max_block`. `Ext7` would not fit
+/// if there wasn't the extra `reserved` space for `Operational` transactions. Note that `max_total`
+/// limit applies to `reserved` space as well (i.e. the sum of weights of `Ext7` & `Ext8` mustn't
+/// exceed it). Setting `reserved` to `None` allows the extrinsics to always get into the block up
+/// to their `max_total` limit. If `max_total` is set to `None` as well, all extrinsics witch
+/// dispatchables of given class will always end up in the block (recommended for `Mandatory`
+/// dispatch class).
+///
+/// As a consequence of `reserved` space, total consumed block weight might exceed `max_block`
+/// value, so this parameter should rather be thought of as "target block weight" than a hard limit.
+#[derive(RuntimeDebug, Clone, codec::Encode, codec::Decode, TypeInfo)]
+pub struct BlockWeights {
+	/// Base weight of block execution.
+	pub base_block: Weight,
+	/// Maximal total weight consumed by all kinds of extrinsics (without `reserved` space).
+	pub max_block: Weight,
+	/// Weight limits for extrinsics of given dispatch class.
+	pub per_class: PerDispatchClass<WeightsPerClass>,
+}
+
+impl Default for BlockWeights {
+	fn default() -> Self {
+		Self::with_sensible_defaults(
+			Weight::from_parts(constants::WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
+			DEFAULT_NORMAL_RATIO,
+		)
+	}
+}
+
+impl BlockWeights {
+	/// Get per-class weight settings.
+	pub fn get(&self, class: DispatchClass) -> &WeightsPerClass {
+		self.per_class.get(class)
+	}
+
+	/// Verifies correctness of this `BlockWeights` object.
+	pub fn validate(self) -> ValidationResult {
+		fn or_max(w: Option<Weight>) -> Weight {
+			w.unwrap_or_else(Weight::max_value)
+		}
+		let mut error = ValidationErrors::default();
+
+		for class in DispatchClass::all() {
+			let weights = self.per_class.get(*class);
+			let max_for_class = or_max(weights.max_total);
+			let base_for_class = weights.base_extrinsic;
+			let reserved = or_max(weights.reserved);
+			// Make sure that if total is set it's greater than base_block &&
+			// base_for_class
+			error_assert!(
+				(max_for_class.all_gt(self.base_block) && max_for_class.all_gt(base_for_class))
+				|| max_for_class == Weight::zero(),
+				&mut error,
+				"[{:?}] {:?} (total) has to be greater than {:?} (base block) & {:?} (base extrinsic)",
+				class, max_for_class, self.base_block, base_for_class,
+			);
+			// Max extrinsic can't be greater than max_for_class.
+			error_assert!(
+				weights
+					.max_extrinsic
+					.unwrap_or(Weight::zero())
+					.all_lte(max_for_class.saturating_sub(base_for_class)),
+				&mut error,
+				"[{:?}] {:?} (max_extrinsic) can't be greater than {:?} (max for class)",
+				class,
+				weights.max_extrinsic,
+				max_for_class.saturating_sub(base_for_class),
+			);
+			// Max extrinsic should not be 0
+			error_assert!(
+				weights.max_extrinsic.unwrap_or_else(Weight::max_value).all_gt(Weight::zero()),
+				&mut error,
+				"[{:?}] {:?} (max_extrinsic) must not be 0. Check base cost and average initialization cost.",
+				class, weights.max_extrinsic,
+			);
+			// Make sure that if reserved is set it's greater than base_for_class.
+			error_assert!(
+				reserved.all_gt(base_for_class) || reserved == Weight::zero(),
+				&mut error,
+				"[{:?}] {:?} (reserved) has to be greater than {:?} (base extrinsic) if set",
+				class,
+				reserved,
+				base_for_class,
+			);
+			// Make sure max block is greater than max_total if it's set.
+			error_assert!(
+				self.max_block.all_gte(weights.max_total.unwrap_or(Weight::zero())),
+				&mut error,
+				"[{:?}] {:?} (max block) has to be greater than {:?} (max for class)",
+				class,
+				self.max_block,
+				weights.max_total,
+			);
+			// Make sure we can fit at least one extrinsic.
+			error_assert!(
+				self.max_block.all_gt(base_for_class + self.base_block),
+				&mut error,
+				"[{:?}] {:?} (max block) must fit at least one extrinsic {:?} (base weight)",
+				class,
+				self.max_block,
+				base_for_class + self.base_block,
+			);
+		}
+
+		if error.has_errors {
+			Err(error)
+		} else {
+			Ok(self)
+		}
+	}
+
+	/// Create new weights definition, with both `Normal` and `Operational`
+	/// classes limited to given weight.
+	///
+	/// Note there is no reservation for `Operational` class, so this constructor
+	/// is not suitable for production deployments.
+	pub fn simple_max(block_weight: Weight) -> Self {
+		Self::builder()
+			.base_block(Weight::zero())
+			.for_class(DispatchClass::all(), |weights| {
+				weights.base_extrinsic = Weight::zero();
+			})
+			.for_class(DispatchClass::non_mandatory(), |weights| {
+				weights.max_total = block_weight.into();
+			})
+			.build()
+			.expect("We only specify max_total and leave base values as defaults; qed")
+	}
+
+	/// Create a sensible default weights system given only expected maximal block weight and the
+	/// ratio that `Normal` extrinsics should occupy.
+	///
+	/// Assumptions:
+	///  - Average block initialization is assumed to be `10%`.
+	///  - `Operational` transactions have reserved allowance (`1.0 - normal_ratio`)
+	pub fn with_sensible_defaults(expected_block_weight: Weight, normal_ratio: Perbill) -> Self {
+		let normal_weight = normal_ratio * expected_block_weight;
+		Self::builder()
+			.for_class(DispatchClass::Normal, |weights| {
+				weights.max_total = normal_weight.into();
+			})
+			.for_class(DispatchClass::Operational, |weights| {
+				weights.max_total = expected_block_weight.into();
+				weights.reserved = (expected_block_weight - normal_weight).into();
+			})
+			.avg_block_initialization(Perbill::from_percent(10))
+			.build()
+			.expect("Sensible defaults are tested to be valid; qed")
+	}
+
+	/// Start constructing new `BlockWeights` object.
+	///
+	/// By default all kinds except of `Mandatory` extrinsics are disallowed.
+	pub fn builder() -> BlockWeightsBuilder {
+		BlockWeightsBuilder {
+			weights: BlockWeights {
+				base_block: constants::BlockExecutionWeight::get(),
+				max_block: Weight::zero(),
+				per_class: PerDispatchClass::new(|class| {
+					let initial =
+						if class == DispatchClass::Mandatory { None } else { Some(Weight::zero()) };
+					WeightsPerClass {
+						base_extrinsic: constants::ExtrinsicBaseWeight::get(),
+						max_extrinsic: None,
+						max_total: initial,
+						reserved: initial,
+					}
+				}),
+			},
+			init_cost: None,
+		}
+	}
+}
+
+/// An opinionated builder for `Weights` object.
+pub struct BlockWeightsBuilder {
+	weights: BlockWeights,
+	init_cost: Option<Perbill>,
+}
+
+impl BlockWeightsBuilder {
+	/// Set base block weight.
+	pub fn base_block(mut self, base_block: Weight) -> Self {
+		self.weights.base_block = base_block;
+		self
+	}
+
+	/// Average block initialization weight cost.
+	///
+	/// This value is used to derive maximal allowed extrinsic weight for each
+	/// class, based on the allowance.
+	///
+	/// This is to make sure that extrinsics don't stay forever in the pool,
+	/// because they could seamingly fit the block (since they are below `max_block`),
+	/// but the cost of calling `on_initialize` always prevents them from being included.
+	pub fn avg_block_initialization(mut self, init_cost: Perbill) -> Self {
+		self.init_cost = Some(init_cost);
+		self
+	}
+
+	/// Set parameters for particular class.
+	///
+	/// Note: `None` values of `max_extrinsic` will be overwritten in `build` in case
+	/// `avg_block_initialization` rate is set to a non-zero value.
+	pub fn for_class(
+		mut self,
+		class: impl OneOrMany<DispatchClass>,
+		action: impl Fn(&mut WeightsPerClass),
+	) -> Self {
+		for class in class.into_iter() {
+			action(self.weights.per_class.get_mut(class));
+		}
+		self
+	}
+
+	/// Construct the `BlockWeights` object.
+	pub fn build(self) -> ValidationResult {
+		// compute max extrinsic size
+		let Self { mut weights, init_cost } = self;
+
+		// compute max block size.
+		for class in DispatchClass::all() {
+			weights.max_block = match weights.per_class.get(*class).max_total {
+				Some(max) => max.max(weights.max_block),
+				_ => weights.max_block,
+			};
+		}
+		// compute max size of single extrinsic
+		if let Some(init_weight) = init_cost.map(|rate| rate * weights.max_block) {
+			for class in DispatchClass::all() {
+				let per_class = weights.per_class.get_mut(*class);
+				if per_class.max_extrinsic.is_none() && init_cost.is_some() {
+					per_class.max_extrinsic = per_class
+						.max_total
+						.map(|x| x.saturating_sub(init_weight))
+						.map(|x| x.saturating_sub(per_class.base_extrinsic));
+				}
+			}
+		}
+
+		// Validate the result
+		weights.validate()
+	}
+
+	/// Construct the `BlockWeights` object or panic if it's invalid.
+	///
+	/// This is a convenience method to be called whenever you construct a runtime.
+	pub fn build_or_panic(self) -> BlockWeights {
+		self.build().expect(
+			"Builder finished with `build_or_panic`; The panic is expected if runtime weights are not correct"
+		)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn default_weights_are_valid() {
+		BlockWeights::default().validate().unwrap();
+	}
+}
diff --git a/substrate/frame/system/src/migrations/mod.rs b/substrate/frame/system/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..945bbc53955257266f9023c790f9a7a87d2f8a55
--- /dev/null
+++ b/substrate/frame/system/src/migrations/mod.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.
+
+//! Migrate the reference counting state.
+
+use super::LOG_TARGET;
+use crate::{Config, Pallet};
+use codec::{Decode, Encode, FullCodec};
+use frame_support::{
+	pallet_prelude::ValueQuery, traits::PalletInfoAccess, weights::Weight, Blake2_128Concat,
+};
+use sp_runtime::RuntimeDebug;
+use sp_std::prelude::*;
+
+/// Type used to encode the number of references an account has.
+type RefCount = u32;
+
+/// Information of an account.
+#[derive(Clone, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode)]
+struct AccountInfo<Nonce, AccountData> {
+	nonce: Nonce,
+	consumers: RefCount,
+	providers: RefCount,
+	sufficients: RefCount,
+	data: AccountData,
+}
+
+/// Trait to implement to give information about types used for migration
+pub trait V2ToV3 {
+	/// The system pallet.
+	type Pallet: 'static + PalletInfoAccess;
+
+	/// System config account id
+	type AccountId: 'static + FullCodec;
+
+	/// System config nonce
+	type Nonce: 'static + FullCodec + Copy;
+
+	/// System config account data
+	type AccountData: 'static + FullCodec;
+}
+
+#[frame_support::storage_alias]
+type UpgradedToU32RefCount<T: Config> = StorageValue<Pallet<T>, bool, ValueQuery>;
+
+#[frame_support::storage_alias]
+type UpgradedToTripleRefCount<T: Config> = StorageValue<Pallet<T>, bool, ValueQuery>;
+
+#[frame_support::storage_alias]
+type Account<V, T: Config> = StorageMap<
+	Pallet<T>,
+	Blake2_128Concat,
+	<V as V2ToV3>::AccountId,
+	AccountInfo<<V as V2ToV3>::Nonce, <V as V2ToV3>::AccountData>,
+>;
+
+/// Migrate from unique `u8` reference counting to triple `u32` reference counting.
+pub fn migrate_from_single_u8_to_triple_ref_count<V: V2ToV3, T: Config>() -> Weight {
+	let mut translated: usize = 0;
+	<Account<V, T>>::translate::<(V::Nonce, u8, V::AccountData), _>(|_key, (nonce, rc, data)| {
+		translated += 1;
+		Some(AccountInfo { nonce, consumers: rc as RefCount, providers: 1, sufficients: 0, data })
+	});
+	log::info!(
+		target: LOG_TARGET,
+		"Applied migration from single u8 to triple reference counting to {:?} elements.",
+		translated
+	);
+	<UpgradedToU32RefCount<T>>::put(true);
+	<UpgradedToTripleRefCount<T>>::put(true);
+	Weight::MAX
+}
+
+/// Migrate from unique `u32` reference counting to triple `u32` reference counting.
+pub fn migrate_from_single_to_triple_ref_count<V: V2ToV3, T: Config>() -> Weight {
+	let mut translated: usize = 0;
+	<Account<V, T>>::translate::<(V::Nonce, RefCount, V::AccountData), _>(
+		|_key, (nonce, consumers, data)| {
+			translated += 1;
+			Some(AccountInfo { nonce, consumers, providers: 1, sufficients: 0, data })
+		},
+	);
+	log::info!(
+		target: LOG_TARGET,
+		"Applied migration from single to triple reference counting to {:?} elements.",
+		translated
+	);
+	<UpgradedToTripleRefCount<T>>::put(true);
+	Weight::MAX
+}
+
+/// Migrate from dual `u32` reference counting to triple `u32` reference counting.
+pub fn migrate_from_dual_to_triple_ref_count<V: V2ToV3, T: Config>() -> Weight {
+	let mut translated: usize = 0;
+	<Account<V, T>>::translate::<(V::Nonce, RefCount, RefCount, V::AccountData), _>(
+		|_key, (nonce, consumers, providers, data)| {
+			translated += 1;
+			Some(AccountInfo { nonce, consumers, providers, sufficients: 0, data })
+		},
+	);
+	log::info!(
+		target: LOG_TARGET,
+		"Applied migration from dual to triple reference counting to {:?} elements.",
+		translated
+	);
+	<UpgradedToTripleRefCount<T>>::put(true);
+	Weight::MAX
+}
diff --git a/substrate/frame/system/src/mock.rs b/substrate/frame/system/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c016ea9e1cd14969e5dac8d626687ee4a0553acf
--- /dev/null
+++ b/substrate/frame/system/src/mock.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::{self as frame_system, *};
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill,
+};
+
+type Block = mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+	}
+);
+
+const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
+const MAX_BLOCK_WEIGHT: Weight = Weight::from_parts(1024, u64::MAX);
+
+parameter_types! {
+	pub Version: RuntimeVersion = RuntimeVersion {
+		spec_name: sp_version::create_runtime_str!("test"),
+		impl_name: sp_version::create_runtime_str!("system-test"),
+		authoring_version: 1,
+		spec_version: 1,
+		impl_version: 1,
+		apis: sp_version::create_apis_vec!([]),
+		transaction_version: 1,
+		state_version: 1,
+	};
+	pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight {
+		read: 10,
+		write: 100,
+	};
+	pub RuntimeBlockWeights: limits::BlockWeights = limits::BlockWeights::builder()
+		.base_block(Weight::from_parts(10, 0))
+		.for_class(DispatchClass::all(), |weights| {
+			weights.base_extrinsic = Weight::from_parts(5, 0);
+		})
+		.for_class(DispatchClass::Normal, |weights| {
+			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAX_BLOCK_WEIGHT);
+		})
+		.for_class(DispatchClass::Operational, |weights| {
+			weights.base_extrinsic = Weight::from_parts(10, 0);
+			weights.max_total = Some(MAX_BLOCK_WEIGHT);
+			weights.reserved = Some(
+				MAX_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAX_BLOCK_WEIGHT
+			);
+		})
+		.avg_block_initialization(Perbill::from_percent(0))
+		.build_or_panic();
+	pub RuntimeBlockLength: limits::BlockLength =
+		limits::BlockLength::max_with_normal_ratio(1024, NORMAL_DISPATCH_RATIO);
+}
+
+parameter_types! {
+	pub static Killed: Vec<u64> = vec![];
+}
+
+pub struct RecordKilled;
+impl OnKilledAccount<u64> for RecordKilled {
+	fn on_killed_account(who: &u64) {
+		Killed::mutate(|r| r.push(*who))
+	}
+}
+
+impl Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = RuntimeBlockWeights;
+	type BlockLength = RuntimeBlockLength;
+	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<10>;
+	type DbWeight = DbWeight;
+	type Version = Version;
+	type PalletInfo = PalletInfo;
+	type AccountData = u32;
+	type OnNewAccount = ();
+	type OnKilledAccount = RecordKilled;
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+pub type SysEvent = frame_system::Event<Test>;
+
+/// A simple call, which one doesn't matter.
+pub const CALL: &<Test as Config>::RuntimeCall =
+	&RuntimeCall::System(frame_system::Call::set_heap_pages { pages: 0u64 });
+
+/// Create new externalities for `System` module tests.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut ext: sp_io::TestExternalities =
+		RuntimeGenesisConfig::default().build_storage().unwrap().into();
+	// Add to each test the initial weight of a block
+	ext.execute_with(|| {
+		System::register_extra_weight_unchecked(
+			<Test as crate::Config>::BlockWeights::get().base_block,
+			DispatchClass::Mandatory,
+		)
+	});
+	ext
+}
diff --git a/substrate/frame/system/src/mocking.rs b/substrate/frame/system/src/mocking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..833309e05ecc97d2c8e2bb9645664e7551fe5d72
--- /dev/null
+++ b/substrate/frame/system/src/mocking.rs
@@ -0,0 +1,47 @@
+// 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.
+
+//! Provide types to help defining a mock environment when testing pallets.
+
+use sp_runtime::generic;
+
+/// An unchecked extrinsic type to be used in tests.
+pub type MockUncheckedExtrinsic<T, Signature = (), Extra = ()> = generic::UncheckedExtrinsic<
+	<T as crate::Config>::AccountId,
+	<T as crate::Config>::RuntimeCall,
+	Signature,
+	Extra,
+>;
+
+/// An implementation of `sp_runtime::traits::Block` to be used in tests.
+pub type MockBlock<T> = generic::Block<
+	generic::Header<u64, sp_runtime::traits::BlakeTwo256>,
+	MockUncheckedExtrinsic<T>,
+>;
+
+/// An implementation of `sp_runtime::traits::Block` to be used in tests with u32 BlockNumber type.
+pub type MockBlockU32<T> = generic::Block<
+	generic::Header<u32, sp_runtime::traits::BlakeTwo256>,
+	MockUncheckedExtrinsic<T>,
+>;
+
+/// An implementation of `sp_runtime::traits::Block` to be used in tests with u128 BlockNumber
+/// type.
+pub type MockBlockU128<T> = generic::Block<
+	generic::Header<u128, sp_runtime::traits::BlakeTwo256>,
+	MockUncheckedExtrinsic<T>,
+>;
diff --git a/substrate/frame/system/src/offchain.rs b/substrate/frame/system/src/offchain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dd4ac6782a55e1d6330386444423c1d6e662d5be
--- /dev/null
+++ b/substrate/frame/system/src/offchain.rs
@@ -0,0 +1,795 @@
+// 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.
+
+//! Module helpers for off-chain calls.
+//!
+//! ## Overview
+//!
+//! This module provides transaction related helpers to:
+//! - Submit a raw unsigned transaction
+//! - Submit an unsigned transaction with a signed payload
+//! - Submit a signed transction.
+//!
+//! ## Usage
+//!
+//! Please refer to [`example-offchain-worker`](../../pallet_example_offchain_worker/index.html) for
+//! a concrete example usage of this crate.
+//!
+//! ### Submit a raw unsigned transaction
+//!
+//! To submit a raw unsigned transaction, [`SubmitTransaction`](./struct.SubmitTransaction.html)
+//! can be used.
+//!
+//! ### Signing transactions
+//!
+//! To be able to use signing, the following trait should be implemented:
+//!
+//! - [`AppCrypto`](./trait.AppCrypto.html): where an application-specific key is defined and can be
+//!   used by this module's helpers for signing.
+//! - [`CreateSignedTransaction`](./trait.CreateSignedTransaction.html): where the manner in which
+//!   the transaction is constructed is defined.
+//!
+//! #### Submit an unsigned transaction with a signed payload
+//!
+//! Initially, a payload instance that implements the `SignedPayload` trait should be defined.
+//! See [`PricePayload`](../../pallet_example_offchain_worker/struct.PricePayload.html)
+//!
+//! The payload type that is defined defined can then be signed and submitted onchain.
+//!
+//! #### Submit a signed transaction
+//!
+//! [`Signer`](./struct.Signer.html) can be used to sign/verify payloads
+
+#![warn(missing_docs)]
+
+use codec::Encode;
+use sp_runtime::{
+	app_crypto::RuntimeAppPublic,
+	traits::{Extrinsic as ExtrinsicT, IdentifyAccount, One},
+	RuntimeDebug,
+};
+use sp_std::{collections::btree_set::BTreeSet, prelude::*};
+
+/// Marker struct used to flag using all supported keys to sign a payload.
+pub struct ForAll {}
+/// Marker struct used to flag using any of the supported keys to sign a payload.
+pub struct ForAny {}
+
+/// Provides the ability to directly submit signed and unsigned
+/// transaction onchain.
+///
+/// For submitting unsigned transactions, `submit_unsigned_transaction`
+/// utility function can be used. However, this struct is used by `Signer`
+/// to submit a signed transactions providing the signature along with the call.
+pub struct SubmitTransaction<T: SendTransactionTypes<OverarchingCall>, OverarchingCall> {
+	_phantom: sp_std::marker::PhantomData<(T, OverarchingCall)>,
+}
+
+impl<T, LocalCall> SubmitTransaction<T, LocalCall>
+where
+	T: SendTransactionTypes<LocalCall>,
+{
+	/// Submit transaction onchain by providing the call and an optional signature
+	pub fn submit_transaction(
+		call: <T as SendTransactionTypes<LocalCall>>::OverarchingCall,
+		signature: Option<<T::Extrinsic as ExtrinsicT>::SignaturePayload>,
+	) -> Result<(), ()> {
+		let xt = T::Extrinsic::new(call, signature).ok_or(())?;
+		sp_io::offchain::submit_transaction(xt.encode())
+	}
+
+	/// A convenience method to submit an unsigned transaction onchain.
+	pub fn submit_unsigned_transaction(
+		call: <T as SendTransactionTypes<LocalCall>>::OverarchingCall,
+	) -> Result<(), ()> {
+		SubmitTransaction::<T, LocalCall>::submit_transaction(call, None)
+	}
+}
+
+/// Provides an implementation for signing transaction payloads.
+///
+/// Keys used for signing are defined when instantiating the signer object.
+/// Signing can be done using:
+///
+/// - All supported keys in the keystore
+/// - Any of the supported keys in the keystore
+/// - An intersection of in-keystore keys and the list of provided keys
+///
+/// The signer is then able to:
+/// - Submit a unsigned transaction with a signed payload
+/// - Submit a signed transaction
+#[derive(RuntimeDebug)]
+pub struct Signer<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>, X = ForAny> {
+	accounts: Option<Vec<T::Public>>,
+	_phantom: sp_std::marker::PhantomData<(X, C)>,
+}
+
+impl<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>, X> Default for Signer<T, C, X> {
+	fn default() -> Self {
+		Self { accounts: Default::default(), _phantom: Default::default() }
+	}
+}
+
+impl<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>, X> Signer<T, C, X> {
+	/// Use all available keys for signing.
+	pub fn all_accounts() -> Signer<T, C, ForAll> {
+		Default::default()
+	}
+
+	/// Use any of the available keys for signing.
+	pub fn any_account() -> Signer<T, C, ForAny> {
+		Default::default()
+	}
+
+	/// Use provided `accounts` for signing.
+	///
+	/// Note that not all keys will be necessarily used. The provided
+	/// vector of accounts will be intersected with the supported keys
+	/// in the keystore and the resulting list will be used for signing.
+	pub fn with_filter(mut self, accounts: Vec<T::Public>) -> Self {
+		self.accounts = Some(accounts);
+		self
+	}
+
+	/// Check if there are any keys that could be used for signing.
+	pub fn can_sign(&self) -> bool {
+		self.accounts_from_keys().count() > 0
+	}
+
+	/// Return a vector of the intersection between
+	/// all available accounts and the provided accounts
+	/// in `with_filter`. If no accounts are provided,
+	/// use all accounts by default.
+	fn accounts_from_keys<'a>(&'a self) -> Box<dyn Iterator<Item = Account<T>> + 'a> {
+		let keystore_accounts = self.keystore_accounts();
+		match self.accounts {
+			None => Box::new(keystore_accounts),
+			Some(ref keys) => {
+				let keystore_lookup: BTreeSet<<T as SigningTypes>::Public> =
+					keystore_accounts.map(|account| account.public).collect();
+
+				Box::new(
+					keys.iter()
+						.enumerate()
+						.map(|(index, key)| {
+							let account_id = key.clone().into_account();
+							Account::new(index, account_id, key.clone())
+						})
+						.filter(move |account| keystore_lookup.contains(&account.public)),
+				)
+			},
+		}
+	}
+
+	fn keystore_accounts(&self) -> impl Iterator<Item = Account<T>> {
+		C::RuntimeAppPublic::all().into_iter().enumerate().map(|(index, key)| {
+			let generic_public = C::GenericPublic::from(key);
+			let public: T::Public = generic_public.into();
+			let account_id = public.clone().into_account();
+			Account::new(index, account_id, public)
+		})
+	}
+}
+
+impl<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>> Signer<T, C, ForAll> {
+	fn for_all<F, R>(&self, f: F) -> Vec<(Account<T>, R)>
+	where
+		F: Fn(&Account<T>) -> Option<R>,
+	{
+		let accounts = self.accounts_from_keys();
+		accounts
+			.into_iter()
+			.filter_map(|account| f(&account).map(|res| (account, res)))
+			.collect()
+	}
+}
+
+impl<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>> Signer<T, C, ForAny> {
+	fn for_any<F, R>(&self, f: F) -> Option<(Account<T>, R)>
+	where
+		F: Fn(&Account<T>) -> Option<R>,
+	{
+		let accounts = self.accounts_from_keys();
+		for account in accounts.into_iter() {
+			let res = f(&account);
+			if let Some(res) = res {
+				return Some((account, res))
+			}
+		}
+		None
+	}
+}
+
+impl<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>> SignMessage<T>
+	for Signer<T, C, ForAll>
+{
+	type SignatureData = Vec<(Account<T>, T::Signature)>;
+
+	fn sign_message(&self, message: &[u8]) -> Self::SignatureData {
+		self.for_all(|account| C::sign(message, account.public.clone()))
+	}
+
+	fn sign<TPayload, F>(&self, f: F) -> Self::SignatureData
+	where
+		F: Fn(&Account<T>) -> TPayload,
+		TPayload: SignedPayload<T>,
+	{
+		self.for_all(|account| f(account).sign::<C>())
+	}
+}
+
+impl<T: SigningTypes, C: AppCrypto<T::Public, T::Signature>> SignMessage<T>
+	for Signer<T, C, ForAny>
+{
+	type SignatureData = Option<(Account<T>, T::Signature)>;
+
+	fn sign_message(&self, message: &[u8]) -> Self::SignatureData {
+		self.for_any(|account| C::sign(message, account.public.clone()))
+	}
+
+	fn sign<TPayload, F>(&self, f: F) -> Self::SignatureData
+	where
+		F: Fn(&Account<T>) -> TPayload,
+		TPayload: SignedPayload<T>,
+	{
+		self.for_any(|account| f(account).sign::<C>())
+	}
+}
+
+impl<
+		T: CreateSignedTransaction<LocalCall> + SigningTypes,
+		C: AppCrypto<T::Public, T::Signature>,
+		LocalCall,
+	> SendSignedTransaction<T, C, LocalCall> for Signer<T, C, ForAny>
+{
+	type Result = Option<(Account<T>, Result<(), ()>)>;
+
+	fn send_signed_transaction(&self, f: impl Fn(&Account<T>) -> LocalCall) -> Self::Result {
+		self.for_any(|account| {
+			let call = f(account);
+			self.send_single_signed_transaction(account, call)
+		})
+	}
+}
+
+impl<
+		T: SigningTypes + CreateSignedTransaction<LocalCall>,
+		C: AppCrypto<T::Public, T::Signature>,
+		LocalCall,
+	> SendSignedTransaction<T, C, LocalCall> for Signer<T, C, ForAll>
+{
+	type Result = Vec<(Account<T>, Result<(), ()>)>;
+
+	fn send_signed_transaction(&self, f: impl Fn(&Account<T>) -> LocalCall) -> Self::Result {
+		self.for_all(|account| {
+			let call = f(account);
+			self.send_single_signed_transaction(account, call)
+		})
+	}
+}
+
+impl<
+		T: SigningTypes + SendTransactionTypes<LocalCall>,
+		C: AppCrypto<T::Public, T::Signature>,
+		LocalCall,
+	> SendUnsignedTransaction<T, LocalCall> for Signer<T, C, ForAny>
+{
+	type Result = Option<(Account<T>, Result<(), ()>)>;
+
+	fn send_unsigned_transaction<TPayload, F>(
+		&self,
+		f: F,
+		f2: impl Fn(TPayload, T::Signature) -> LocalCall,
+	) -> Self::Result
+	where
+		F: Fn(&Account<T>) -> TPayload,
+		TPayload: SignedPayload<T>,
+	{
+		self.for_any(|account| {
+			let payload = f(account);
+			let signature = payload.sign::<C>()?;
+			let call = f2(payload, signature);
+			self.submit_unsigned_transaction(call)
+		})
+	}
+}
+
+impl<
+		T: SigningTypes + SendTransactionTypes<LocalCall>,
+		C: AppCrypto<T::Public, T::Signature>,
+		LocalCall,
+	> SendUnsignedTransaction<T, LocalCall> for Signer<T, C, ForAll>
+{
+	type Result = Vec<(Account<T>, Result<(), ()>)>;
+
+	fn send_unsigned_transaction<TPayload, F>(
+		&self,
+		f: F,
+		f2: impl Fn(TPayload, T::Signature) -> LocalCall,
+	) -> Self::Result
+	where
+		F: Fn(&Account<T>) -> TPayload,
+		TPayload: SignedPayload<T>,
+	{
+		self.for_all(|account| {
+			let payload = f(account);
+			let signature = payload.sign::<C>()?;
+			let call = f2(payload, signature);
+			self.submit_unsigned_transaction(call)
+		})
+	}
+}
+
+/// Details of an account for which a private key is contained in the keystore.
+#[derive(RuntimeDebug, PartialEq)]
+pub struct Account<T: SigningTypes> {
+	/// Index on the provided list of accounts or list of all accounts.
+	pub index: usize,
+	/// Runtime-specific `AccountId`.
+	pub id: T::AccountId,
+	/// A runtime-specific `Public` key for that key pair.
+	pub public: T::Public,
+}
+
+impl<T: SigningTypes> Account<T> {
+	/// Create a new Account instance
+	pub fn new(index: usize, id: T::AccountId, public: T::Public) -> Self {
+		Self { index, id, public }
+	}
+}
+
+impl<T: SigningTypes> Clone for Account<T>
+where
+	T::AccountId: Clone,
+	T::Public: Clone,
+{
+	fn clone(&self) -> Self {
+		Self { index: self.index, id: self.id.clone(), public: self.public.clone() }
+	}
+}
+
+/// A type binding runtime-level `Public/Signature` pair with crypto wrapped by `RuntimeAppPublic`.
+///
+/// Implementations of this trait should specify the app-specific public/signature types.
+/// This is merely a wrapper around an existing `RuntimeAppPublic` type, but with
+/// extra non-application-specific crypto type that is being wrapped (e.g. `sr25519`, `ed25519`).
+/// This is needed to later on convert into runtime-specific `Public` key, which might support
+/// multiple different crypto.
+/// The point of this trait is to be able to easily convert between `RuntimeAppPublic`, the wrapped
+/// (generic = non application-specific) crypto types and the `Public` type required by the runtime.
+///
+/// Example (pseudo-)implementation:
+/// ```ignore
+/// // im-online specific crypto
+/// type RuntimeAppPublic = ImOnline(sr25519::Public);
+///
+/// // wrapped "raw" crypto
+/// type GenericPublic = sr25519::Public;
+/// type GenericSignature = sr25519::Signature;
+///
+/// // runtime-specific public key
+/// type Public = MultiSigner: From<sr25519::Public>;
+/// type Signature = MulitSignature: From<sr25519::Signature>;
+/// ```
+// TODO [#5662] Potentially use `IsWrappedBy` types, or find some other way to make it easy to
+// obtain unwrapped crypto (and wrap it back).
+pub trait AppCrypto<Public, Signature> {
+	/// A application-specific crypto.
+	type RuntimeAppPublic: RuntimeAppPublic;
+
+	/// A raw crypto public key wrapped by `RuntimeAppPublic`.
+	type GenericPublic: From<Self::RuntimeAppPublic>
+		+ Into<Self::RuntimeAppPublic>
+		+ TryFrom<Public>
+		+ Into<Public>;
+
+	/// A matching raw crypto `Signature` type.
+	type GenericSignature: From<<Self::RuntimeAppPublic as RuntimeAppPublic>::Signature>
+		+ Into<<Self::RuntimeAppPublic as RuntimeAppPublic>::Signature>
+		+ TryFrom<Signature>
+		+ Into<Signature>;
+
+	/// Sign payload with the private key to maps to the provided public key.
+	fn sign(payload: &[u8], public: Public) -> Option<Signature> {
+		let p: Self::GenericPublic = public.try_into().ok()?;
+		let x = Into::<Self::RuntimeAppPublic>::into(p);
+		x.sign(&payload)
+			.map(|x| {
+				let sig: Self::GenericSignature = x.into();
+				sig
+			})
+			.map(Into::into)
+	}
+
+	/// Verify signature against the provided public key.
+	fn verify(payload: &[u8], public: Public, signature: Signature) -> bool {
+		let p: Self::GenericPublic = match public.try_into() {
+			Ok(a) => a,
+			_ => return false,
+		};
+		let x = Into::<Self::RuntimeAppPublic>::into(p);
+		let signature: Self::GenericSignature = match signature.try_into() {
+			Ok(a) => a,
+			_ => return false,
+		};
+		let signature =
+			Into::<<Self::RuntimeAppPublic as RuntimeAppPublic>::Signature>::into(signature);
+
+		x.verify(&payload, &signature)
+	}
+}
+
+/// A wrapper around the types which are used for signing.
+///
+/// This trait adds extra bounds to `Public` and `Signature` types of the runtime
+/// that are necessary to use these types for signing.
+// TODO [#5663] Could this be just `T::Signature as traits::Verify>::Signer`?
+// Seems that this may cause issues with bounds resolution.
+pub trait SigningTypes: crate::Config {
+	/// A public key that is capable of identifying `AccountId`s.
+	///
+	/// Usually that's either a raw crypto public key (e.g. `sr25519::Public`) or
+	/// an aggregate type for multiple crypto public keys, like `MulitSigner`.
+	type Public: Clone
+		+ PartialEq
+		+ IdentifyAccount<AccountId = Self::AccountId>
+		+ core::fmt::Debug
+		+ codec::Codec
+		+ Ord
+		+ scale_info::TypeInfo;
+
+	/// A matching `Signature` type.
+	type Signature: Clone + PartialEq + core::fmt::Debug + codec::Codec + scale_info::TypeInfo;
+}
+
+/// A definition of types required to submit transactions from within the runtime.
+pub trait SendTransactionTypes<LocalCall> {
+	/// The extrinsic type expected by the runtime.
+	type Extrinsic: ExtrinsicT<Call = Self::OverarchingCall> + codec::Encode;
+	/// The runtime's call type.
+	///
+	/// This has additional bound to be able to be created from pallet-local `Call` types.
+	type OverarchingCall: From<LocalCall> + codec::Encode;
+}
+
+/// Create signed transaction.
+///
+/// This trait is meant to be implemented by the runtime and is responsible for constructing
+/// a payload to be signed and contained within the extrinsic.
+/// This will most likely include creation of `SignedExtra` (a set of `SignedExtensions`).
+/// Note that the result can be altered by inspecting the `Call` (for instance adjusting
+/// fees, or mortality depending on the `pallet` being called).
+pub trait CreateSignedTransaction<LocalCall>:
+	SendTransactionTypes<LocalCall> + SigningTypes
+{
+	/// Attempt to create signed extrinsic data that encodes call from given account.
+	///
+	/// Runtime implementation is free to construct the payload to sign and the signature
+	/// in any way it wants.
+	/// Returns `None` if signed extrinsic could not be created (either because signing failed
+	/// or because of any other runtime-specific reason).
+	fn create_transaction<C: AppCrypto<Self::Public, Self::Signature>>(
+		call: Self::OverarchingCall,
+		public: Self::Public,
+		account: Self::AccountId,
+		nonce: Self::Nonce,
+	) -> Option<(Self::OverarchingCall, <Self::Extrinsic as ExtrinsicT>::SignaturePayload)>;
+}
+
+/// A message signer.
+pub trait SignMessage<T: SigningTypes> {
+	/// A signature data.
+	///
+	/// May contain account used for signing and the `Signature` itself.
+	type SignatureData;
+
+	/// Sign a message.
+	///
+	/// Implementation of this method should return
+	/// a result containing the signature.
+	fn sign_message(&self, message: &[u8]) -> Self::SignatureData;
+
+	/// Construct and sign given payload.
+	///
+	/// This method expects `f` to return a `SignedPayload`
+	/// object which is then used for signing.
+	fn sign<TPayload, F>(&self, f: F) -> Self::SignatureData
+	where
+		F: Fn(&Account<T>) -> TPayload,
+		TPayload: SignedPayload<T>;
+}
+
+/// Submit a signed transaction to the transaction pool.
+pub trait SendSignedTransaction<
+	T: SigningTypes + CreateSignedTransaction<LocalCall>,
+	C: AppCrypto<T::Public, T::Signature>,
+	LocalCall,
+>
+{
+	/// A submission result.
+	///
+	/// This should contain an indication of success and the account that was used for signing.
+	type Result;
+
+	/// Submit a signed transaction to the local pool.
+	///
+	/// Given `f` closure will be called for every requested account and expects a `Call` object
+	/// to be returned.
+	/// The call is then wrapped into a transaction (see `#CreateSignedTransaction`), signed and
+	/// submitted to the pool.
+	fn send_signed_transaction(&self, f: impl Fn(&Account<T>) -> LocalCall) -> Self::Result;
+
+	/// Wraps the call into transaction, signs using given account and submits to the pool.
+	fn send_single_signed_transaction(
+		&self,
+		account: &Account<T>,
+		call: LocalCall,
+	) -> Option<Result<(), ()>> {
+		let mut account_data = crate::Account::<T>::get(&account.id);
+		log::debug!(
+			target: "runtime::offchain",
+			"Creating signed transaction from account: {:?} (nonce: {:?})",
+			account.id,
+			account_data.nonce,
+		);
+		let (call, signature) = T::create_transaction::<C>(
+			call.into(),
+			account.public.clone(),
+			account.id.clone(),
+			account_data.nonce,
+		)?;
+		let res = SubmitTransaction::<T, LocalCall>::submit_transaction(call, Some(signature));
+
+		if res.is_ok() {
+			// increment the nonce. This is fine, since the code should always
+			// be running in off-chain context, so we NEVER persists data.
+			account_data.nonce += One::one();
+			crate::Account::<T>::insert(&account.id, account_data);
+		}
+
+		Some(res)
+	}
+}
+
+/// Submit an unsigned transaction onchain with a signed payload
+pub trait SendUnsignedTransaction<T: SigningTypes + SendTransactionTypes<LocalCall>, LocalCall> {
+	/// A submission result.
+	///
+	/// Should contain the submission result and the account(s) that signed the payload.
+	type Result;
+
+	/// Send an unsigned transaction with a signed payload.
+	///
+	/// This method takes `f` and `f2` where:
+	/// - `f` is called for every account and is expected to return a `SignedPayload` object.
+	/// - `f2` is then called with the `SignedPayload` returned by `f` and the signature and is
+	/// expected to return a `Call` object to be embedded into transaction.
+	fn send_unsigned_transaction<TPayload, F>(
+		&self,
+		f: F,
+		f2: impl Fn(TPayload, T::Signature) -> LocalCall,
+	) -> Self::Result
+	where
+		F: Fn(&Account<T>) -> TPayload,
+		TPayload: SignedPayload<T>;
+
+	/// Submits an unsigned call to the transaction pool.
+	fn submit_unsigned_transaction(&self, call: LocalCall) -> Option<Result<(), ()>> {
+		Some(SubmitTransaction::<T, LocalCall>::submit_unsigned_transaction(call.into()))
+	}
+}
+
+/// Utility trait to be implemented on payloads that can be signed.
+pub trait SignedPayload<T: SigningTypes>: Encode {
+	/// Return a public key that is expected to have a matching key in the keystore,
+	/// which should be used to sign the payload.
+	fn public(&self) -> T::Public;
+
+	/// Sign the payload using the implementor's provided public key.
+	///
+	/// Returns `Some(signature)` if public key is supported.
+	fn sign<C: AppCrypto<T::Public, T::Signature>>(&self) -> Option<T::Signature> {
+		self.using_encoded(|payload| C::sign(payload, self.public()))
+	}
+
+	/// Verify signature against payload.
+	///
+	/// Returns a bool indicating whether the signature is valid or not.
+	fn verify<C: AppCrypto<T::Public, T::Signature>>(&self, signature: T::Signature) -> bool {
+		self.using_encoded(|payload| C::verify(payload, self.public(), signature))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::mock::{RuntimeCall, Test as TestRuntime, CALL};
+	use codec::Decode;
+	use sp_core::offchain::{testing, TransactionPoolExt};
+	use sp_runtime::testing::{TestSignature, TestXt, UintAuthorityId};
+
+	impl SigningTypes for TestRuntime {
+		type Public = UintAuthorityId;
+		type Signature = TestSignature;
+	}
+
+	type Extrinsic = TestXt<RuntimeCall, ()>;
+
+	impl SendTransactionTypes<RuntimeCall> for TestRuntime {
+		type Extrinsic = Extrinsic;
+		type OverarchingCall = RuntimeCall;
+	}
+
+	#[derive(codec::Encode, codec::Decode)]
+	struct SimplePayload {
+		pub public: UintAuthorityId,
+		pub data: Vec<u8>,
+	}
+
+	impl SignedPayload<TestRuntime> for SimplePayload {
+		fn public(&self) -> UintAuthorityId {
+			self.public.clone()
+		}
+	}
+
+	struct DummyAppCrypto;
+	// Bind together the `SigningTypes` with app-crypto and the wrapper types.
+	// here the implementation is pretty dummy, because we use the same type for
+	// both application-specific crypto and the runtime crypto, but in real-life
+	// runtimes it's going to use different types everywhere.
+	impl AppCrypto<UintAuthorityId, TestSignature> for DummyAppCrypto {
+		type RuntimeAppPublic = UintAuthorityId;
+		type GenericPublic = UintAuthorityId;
+		type GenericSignature = TestSignature;
+	}
+
+	fn assert_account(next: Option<(Account<TestRuntime>, Result<(), ()>)>, index: usize, id: u64) {
+		assert_eq!(next, Some((Account { index, id, public: id.into() }, Ok(()))));
+	}
+
+	#[test]
+	fn should_send_unsigned_with_signed_payload_with_all_accounts() {
+		let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+
+		let mut t = sp_io::TestExternalities::default();
+		t.register_extension(TransactionPoolExt::new(pool));
+
+		// given
+		UintAuthorityId::set_all_keys(vec![0xf0, 0xf1, 0xf2]);
+
+		t.execute_with(|| {
+			// when
+			let result = Signer::<TestRuntime, DummyAppCrypto>::all_accounts()
+				.send_unsigned_transaction(
+					|account| SimplePayload { data: vec![1, 2, 3], public: account.public.clone() },
+					|_payload, _signature| CALL.clone(),
+				);
+
+			// then
+			let mut res = result.into_iter();
+			assert_account(res.next(), 0, 0xf0);
+			assert_account(res.next(), 1, 0xf1);
+			assert_account(res.next(), 2, 0xf2);
+			assert_eq!(res.next(), None);
+
+			// check the transaction pool content:
+			let tx1 = pool_state.write().transactions.pop().unwrap();
+			let _tx2 = pool_state.write().transactions.pop().unwrap();
+			let _tx3 = pool_state.write().transactions.pop().unwrap();
+			assert!(pool_state.read().transactions.is_empty());
+			let tx1 = Extrinsic::decode(&mut &*tx1).unwrap();
+			assert_eq!(tx1.signature, None);
+		});
+	}
+
+	#[test]
+	fn should_send_unsigned_with_signed_payload_with_any_account() {
+		let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+
+		let mut t = sp_io::TestExternalities::default();
+		t.register_extension(TransactionPoolExt::new(pool));
+
+		// given
+		UintAuthorityId::set_all_keys(vec![0xf0, 0xf1, 0xf2]);
+
+		t.execute_with(|| {
+			// when
+			let result = Signer::<TestRuntime, DummyAppCrypto>::any_account()
+				.send_unsigned_transaction(
+					|account| SimplePayload { data: vec![1, 2, 3], public: account.public.clone() },
+					|_payload, _signature| CALL.clone(),
+				);
+
+			// then
+			let mut res = result.into_iter();
+			assert_account(res.next(), 0, 0xf0);
+			assert_eq!(res.next(), None);
+
+			// check the transaction pool content:
+			let tx1 = pool_state.write().transactions.pop().unwrap();
+			assert!(pool_state.read().transactions.is_empty());
+			let tx1 = Extrinsic::decode(&mut &*tx1).unwrap();
+			assert_eq!(tx1.signature, None);
+		});
+	}
+
+	#[test]
+	fn should_send_unsigned_with_signed_payload_with_all_account_and_filter() {
+		let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+
+		let mut t = sp_io::TestExternalities::default();
+		t.register_extension(TransactionPoolExt::new(pool));
+
+		// given
+		UintAuthorityId::set_all_keys(vec![0xf0, 0xf1, 0xf2]);
+
+		t.execute_with(|| {
+			// when
+			let result = Signer::<TestRuntime, DummyAppCrypto>::all_accounts()
+				.with_filter(vec![0xf2.into(), 0xf1.into()])
+				.send_unsigned_transaction(
+					|account| SimplePayload { data: vec![1, 2, 3], public: account.public.clone() },
+					|_payload, _signature| CALL.clone(),
+				);
+
+			// then
+			let mut res = result.into_iter();
+			assert_account(res.next(), 0, 0xf2);
+			assert_account(res.next(), 1, 0xf1);
+			assert_eq!(res.next(), None);
+
+			// check the transaction pool content:
+			let tx1 = pool_state.write().transactions.pop().unwrap();
+			let _tx2 = pool_state.write().transactions.pop().unwrap();
+			assert!(pool_state.read().transactions.is_empty());
+			let tx1 = Extrinsic::decode(&mut &*tx1).unwrap();
+			assert_eq!(tx1.signature, None);
+		});
+	}
+
+	#[test]
+	fn should_send_unsigned_with_signed_payload_with_any_account_and_filter() {
+		let (pool, pool_state) = testing::TestTransactionPoolExt::new();
+
+		let mut t = sp_io::TestExternalities::default();
+		t.register_extension(TransactionPoolExt::new(pool));
+
+		// given
+		UintAuthorityId::set_all_keys(vec![0xf0, 0xf1, 0xf2]);
+
+		t.execute_with(|| {
+			// when
+			let result = Signer::<TestRuntime, DummyAppCrypto>::any_account()
+				.with_filter(vec![0xf2.into(), 0xf1.into()])
+				.send_unsigned_transaction(
+					|account| SimplePayload { data: vec![1, 2, 3], public: account.public.clone() },
+					|_payload, _signature| CALL.clone(),
+				);
+
+			// then
+			let mut res = result.into_iter();
+			assert_account(res.next(), 0, 0xf2);
+			assert_eq!(res.next(), None);
+
+			// check the transaction pool content:
+			let tx1 = pool_state.write().transactions.pop().unwrap();
+			assert!(pool_state.read().transactions.is_empty());
+			let tx1 = Extrinsic::decode(&mut &*tx1).unwrap();
+			assert_eq!(tx1.signature, None);
+		});
+	}
+}
diff --git a/substrate/frame/system/src/tests.rs b/substrate/frame/system/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..165df688b1c2c2915bfdb932a9e1d0448d31b680
--- /dev/null
+++ b/substrate/frame/system/src/tests.rs
@@ -0,0 +1,775 @@
+// 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 frame_support::{
+	assert_noop, assert_ok,
+	dispatch::{Pays, PostDispatchInfo, WithPostDispatchInfo},
+	traits::WhitelistedStorageKeys,
+};
+use std::collections::BTreeSet;
+
+use mock::{RuntimeOrigin, *};
+use sp_core::{hexdisplay::HexDisplay, H256};
+use sp_runtime::{
+	traits::{BlakeTwo256, Header},
+	DispatchError, DispatchErrorWithPostInfo,
+};
+
+#[test]
+fn check_whitelist() {
+	let whitelist: BTreeSet<String> = AllPalletsWithSystem::whitelisted_storage_keys()
+		.iter()
+		.map(|s| HexDisplay::from(&s.key).to_string())
+		.collect();
+
+	// Block Number
+	assert!(whitelist.contains("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac"));
+	// Execution Phase
+	assert!(whitelist.contains("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a"));
+	// Event Count
+	assert!(whitelist.contains("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850"));
+	// System Events
+	assert!(whitelist.contains("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7"));
+	// System BlockWeight
+	assert!(whitelist.contains("26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96"));
+}
+
+#[test]
+fn origin_works() {
+	let o = RuntimeOrigin::from(RawOrigin::<u64>::Signed(1u64));
+	let x: Result<RawOrigin<u64>, RuntimeOrigin> = o.into();
+	assert_eq!(x.unwrap(), RawOrigin::<u64>::Signed(1u64));
+}
+
+#[test]
+fn unique_datum_works() {
+	new_test_ext().execute_with(|| {
+		System::initialize(&1, &[0u8; 32].into(), &Default::default());
+		assert!(sp_io::storage::exists(well_known_keys::INTRABLOCK_ENTROPY));
+
+		let h1 = unique(b"");
+		assert_eq!(
+			32,
+			sp_io::storage::read(well_known_keys::INTRABLOCK_ENTROPY, &mut [], 0).unwrap()
+		);
+		let h2 = unique(b"");
+		assert_eq!(
+			32,
+			sp_io::storage::read(well_known_keys::INTRABLOCK_ENTROPY, &mut [], 0).unwrap()
+		);
+		assert_ne!(h1, h2);
+
+		let h3 = unique(b"Hello");
+		assert_eq!(
+			32,
+			sp_io::storage::read(well_known_keys::INTRABLOCK_ENTROPY, &mut [], 0).unwrap()
+		);
+		assert_ne!(h2, h3);
+
+		let h4 = unique(b"Hello");
+		assert_eq!(
+			32,
+			sp_io::storage::read(well_known_keys::INTRABLOCK_ENTROPY, &mut [], 0).unwrap()
+		);
+		assert_ne!(h3, h4);
+
+		System::finalize();
+		assert!(!sp_io::storage::exists(well_known_keys::INTRABLOCK_ENTROPY));
+	});
+}
+
+#[test]
+fn stored_map_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Created);
+		assert_ok!(System::insert(&0, 42));
+		assert!(!System::is_provider_required(&0));
+
+		assert_eq!(
+			Account::<Test>::get(0),
+			AccountInfo { nonce: 0, providers: 1, consumers: 0, sufficients: 0, data: 42 }
+		);
+
+		assert_ok!(System::inc_consumers(&0));
+		assert!(System::is_provider_required(&0));
+
+		assert_ok!(System::insert(&0, 69));
+		assert!(System::is_provider_required(&0));
+
+		System::dec_consumers(&0);
+		assert!(!System::is_provider_required(&0));
+
+		assert!(Killed::get().is_empty());
+		assert_ok!(System::remove(&0));
+		assert_ok!(System::dec_providers(&0));
+		assert_eq!(Killed::get(), vec![0u64]);
+	});
+}
+
+#[test]
+fn provider_ref_handover_to_self_sufficient_ref_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Created);
+		System::inc_account_nonce(&0);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// a second reference coming and going doesn't change anything.
+		assert_eq!(System::inc_sufficients(&0), IncRefStatus::Existed);
+		assert_eq!(System::dec_sufficients(&0), DecRefStatus::Exists);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// a provider reference coming and going doesn't change anything.
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Existed);
+		assert_eq!(System::dec_providers(&0).unwrap(), DecRefStatus::Exists);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// decreasing the providers with a self-sufficient present should not delete the account
+		assert_eq!(System::inc_sufficients(&0), IncRefStatus::Existed);
+		assert_eq!(System::dec_providers(&0).unwrap(), DecRefStatus::Exists);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// decreasing the sufficients should delete the account
+		assert_eq!(System::dec_sufficients(&0), DecRefStatus::Reaped);
+		assert_eq!(System::account_nonce(&0), 0);
+	});
+}
+
+#[test]
+fn self_sufficient_ref_handover_to_provider_ref_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(System::inc_sufficients(&0), IncRefStatus::Created);
+		System::inc_account_nonce(&0);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// a second reference coming and going doesn't change anything.
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Existed);
+		assert_eq!(System::dec_providers(&0).unwrap(), DecRefStatus::Exists);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// a sufficient reference coming and going doesn't change anything.
+		assert_eq!(System::inc_sufficients(&0), IncRefStatus::Existed);
+		assert_eq!(System::dec_sufficients(&0), DecRefStatus::Exists);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// decreasing the sufficients with a provider present should not delete the account
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Existed);
+		assert_eq!(System::dec_sufficients(&0), DecRefStatus::Exists);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		// decreasing the providers should delete the account
+		assert_eq!(System::dec_providers(&0).unwrap(), DecRefStatus::Reaped);
+		assert_eq!(System::account_nonce(&0), 0);
+	});
+}
+
+#[test]
+fn sufficient_cannot_support_consumer() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(System::inc_sufficients(&0), IncRefStatus::Created);
+		System::inc_account_nonce(&0);
+		assert_eq!(System::account_nonce(&0), 1);
+		assert_noop!(System::inc_consumers(&0), DispatchError::NoProviders);
+
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Existed);
+		assert_ok!(System::inc_consumers(&0));
+		assert_noop!(System::dec_providers(&0), DispatchError::ConsumerRemaining);
+	});
+}
+
+#[test]
+fn provider_required_to_support_consumer() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(System::inc_consumers(&0), DispatchError::NoProviders);
+
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Created);
+		System::inc_account_nonce(&0);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		assert_eq!(System::inc_providers(&0), IncRefStatus::Existed);
+		assert_eq!(System::dec_providers(&0).unwrap(), DecRefStatus::Exists);
+		assert_eq!(System::account_nonce(&0), 1);
+
+		assert_ok!(System::inc_consumers(&0));
+		assert_noop!(System::dec_providers(&0), DispatchError::ConsumerRemaining);
+
+		System::dec_consumers(&0);
+		assert_eq!(System::dec_providers(&0).unwrap(), DecRefStatus::Reaped);
+		assert_eq!(System::account_nonce(&0), 0);
+	});
+}
+
+#[test]
+fn deposit_event_should_work() {
+	new_test_ext().execute_with(|| {
+		System::reset_events();
+		System::initialize(&1, &[0u8; 32].into(), &Default::default());
+		System::note_finished_extrinsics();
+		System::deposit_event(SysEvent::CodeUpdated);
+		System::finalize();
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Finalization,
+				event: SysEvent::CodeUpdated.into(),
+				topics: vec![],
+			}]
+		);
+
+		let normal_base = <Test as crate::Config>::BlockWeights::get()
+			.get(DispatchClass::Normal)
+			.base_extrinsic;
+
+		System::reset_events();
+		System::initialize(&2, &[0u8; 32].into(), &Default::default());
+		System::deposit_event(SysEvent::NewAccount { account: 32 });
+		System::note_finished_initialize();
+		System::deposit_event(SysEvent::KilledAccount { account: 42 });
+		System::note_applied_extrinsic(&Ok(().into()), Default::default());
+		System::note_applied_extrinsic(&Err(DispatchError::BadOrigin.into()), Default::default());
+		System::note_finished_extrinsics();
+		System::deposit_event(SysEvent::NewAccount { account: 3 });
+		System::finalize();
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Initialization,
+					event: SysEvent::NewAccount { account: 32 }.into(),
+					topics: vec![],
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(0),
+					event: SysEvent::KilledAccount { account: 42 }.into(),
+					topics: vec![]
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(0),
+					event: SysEvent::ExtrinsicSuccess {
+						dispatch_info: DispatchInfo { weight: normal_base, ..Default::default() }
+					}
+					.into(),
+					topics: vec![]
+				},
+				EventRecord {
+					phase: Phase::ApplyExtrinsic(1),
+					event: SysEvent::ExtrinsicFailed {
+						dispatch_error: DispatchError::BadOrigin.into(),
+						dispatch_info: DispatchInfo { weight: normal_base, ..Default::default() }
+					}
+					.into(),
+					topics: vec![]
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: SysEvent::NewAccount { account: 3 }.into(),
+					topics: vec![]
+				},
+			]
+		);
+	});
+}
+
+#[test]
+fn deposit_event_uses_actual_weight_and_pays_fee() {
+	new_test_ext().execute_with(|| {
+		System::reset_events();
+		System::initialize(&1, &[0u8; 32].into(), &Default::default());
+		System::note_finished_initialize();
+
+		let normal_base = <Test as crate::Config>::BlockWeights::get()
+			.get(DispatchClass::Normal)
+			.base_extrinsic;
+		let pre_info = DispatchInfo { weight: Weight::from_parts(1000, 0), ..Default::default() };
+		System::note_applied_extrinsic(&Ok(from_actual_ref_time(Some(300))), pre_info);
+		System::note_applied_extrinsic(&Ok(from_actual_ref_time(Some(1000))), pre_info);
+		System::note_applied_extrinsic(
+			// values over the pre info should be capped at pre dispatch value
+			&Ok(from_actual_ref_time(Some(1200))),
+			pre_info,
+		);
+		System::note_applied_extrinsic(
+			&Ok(from_post_weight_info(Some(2_500_000), Pays::Yes)),
+			pre_info,
+		);
+		System::note_applied_extrinsic(&Ok(Pays::No.into()), pre_info);
+		System::note_applied_extrinsic(
+			&Ok(from_post_weight_info(Some(2_500_000), Pays::No)),
+			pre_info,
+		);
+		System::note_applied_extrinsic(&Ok(from_post_weight_info(Some(500), Pays::No)), pre_info);
+		System::note_applied_extrinsic(
+			&Err(DispatchError::BadOrigin.with_weight(Weight::from_parts(999, 0))),
+			pre_info,
+		);
+
+		System::note_applied_extrinsic(
+			&Err(DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo { actual_weight: None, pays_fee: Pays::Yes },
+				error: DispatchError::BadOrigin,
+			}),
+			pre_info,
+		);
+		System::note_applied_extrinsic(
+			&Err(DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					actual_weight: Some(Weight::from_parts(800, 0)),
+					pays_fee: Pays::Yes,
+				},
+				error: DispatchError::BadOrigin,
+			}),
+			pre_info,
+		);
+		System::note_applied_extrinsic(
+			&Err(DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					actual_weight: Some(Weight::from_parts(800, 0)),
+					pays_fee: Pays::No,
+				},
+				error: DispatchError::BadOrigin,
+			}),
+			pre_info,
+		);
+		// Also works for operational.
+		let operational_base = <Test as crate::Config>::BlockWeights::get()
+			.get(DispatchClass::Operational)
+			.base_extrinsic;
+		assert!(normal_base != operational_base, "Test pre-condition violated");
+		let pre_info = DispatchInfo {
+			weight: Weight::from_parts(1000, 0),
+			class: DispatchClass::Operational,
+			..Default::default()
+		};
+		System::note_applied_extrinsic(&Ok(from_actual_ref_time(Some(300))), pre_info);
+
+		let got = System::events();
+		let want = vec![
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(0),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(300, 0).saturating_add(normal_base),
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(1),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(1000, 0).saturating_add(normal_base),
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(2),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(1000, 0).saturating_add(normal_base),
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(3),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(1000, 0).saturating_add(normal_base),
+						pays_fee: Pays::Yes,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(4),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(1000, 0).saturating_add(normal_base),
+						pays_fee: Pays::No,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(5),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(1000, 0).saturating_add(normal_base),
+						pays_fee: Pays::No,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(6),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(500, 0).saturating_add(normal_base),
+						pays_fee: Pays::No,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(7),
+				event: SysEvent::ExtrinsicFailed {
+					dispatch_error: DispatchError::BadOrigin.into(),
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(999, 0).saturating_add(normal_base),
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(8),
+				event: SysEvent::ExtrinsicFailed {
+					dispatch_error: DispatchError::BadOrigin.into(),
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(1000, 0).saturating_add(normal_base),
+						pays_fee: Pays::Yes,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(9),
+				event: SysEvent::ExtrinsicFailed {
+					dispatch_error: DispatchError::BadOrigin.into(),
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(800, 0).saturating_add(normal_base),
+						pays_fee: Pays::Yes,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(10),
+				event: SysEvent::ExtrinsicFailed {
+					dispatch_error: DispatchError::BadOrigin.into(),
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(800, 0).saturating_add(normal_base),
+						pays_fee: Pays::No,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+			EventRecord {
+				phase: Phase::ApplyExtrinsic(11),
+				event: SysEvent::ExtrinsicSuccess {
+					dispatch_info: DispatchInfo {
+						weight: Weight::from_parts(300, 0).saturating_add(operational_base),
+						class: DispatchClass::Operational,
+						..Default::default()
+					},
+				}
+				.into(),
+				topics: vec![],
+			},
+		];
+		for (i, event) in want.into_iter().enumerate() {
+			assert_eq!(got[i], event, "Event mismatch at index {}", i);
+		}
+	});
+}
+
+#[test]
+fn deposit_event_topics() {
+	new_test_ext().execute_with(|| {
+		const BLOCK_NUMBER: u64 = 1;
+
+		System::reset_events();
+		System::initialize(&BLOCK_NUMBER, &[0u8; 32].into(), &Default::default());
+		System::note_finished_extrinsics();
+
+		let topics = vec![H256::repeat_byte(1), H256::repeat_byte(2), H256::repeat_byte(3)];
+
+		// We deposit a few events with different sets of topics.
+		System::deposit_event_indexed(&topics[0..3], SysEvent::NewAccount { account: 1 }.into());
+		System::deposit_event_indexed(&topics[0..1], SysEvent::NewAccount { account: 2 }.into());
+		System::deposit_event_indexed(&topics[1..2], SysEvent::NewAccount { account: 3 }.into());
+
+		System::finalize();
+
+		// Check that topics are reflected in the event record.
+		assert_eq!(
+			System::events(),
+			vec![
+				EventRecord {
+					phase: Phase::Finalization,
+					event: SysEvent::NewAccount { account: 1 }.into(),
+					topics: topics[0..3].to_vec(),
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: SysEvent::NewAccount { account: 2 }.into(),
+					topics: topics[0..1].to_vec(),
+				},
+				EventRecord {
+					phase: Phase::Finalization,
+					event: SysEvent::NewAccount { account: 3 }.into(),
+					topics: topics[1..2].to_vec(),
+				}
+			]
+		);
+
+		// Check that the topic-events mapping reflects the deposited topics.
+		// Note that these are indexes of the events.
+		assert_eq!(System::event_topics(&topics[0]), vec![(BLOCK_NUMBER, 0), (BLOCK_NUMBER, 1)]);
+		assert_eq!(System::event_topics(&topics[1]), vec![(BLOCK_NUMBER, 0), (BLOCK_NUMBER, 2)]);
+		assert_eq!(System::event_topics(&topics[2]), vec![(BLOCK_NUMBER, 0)]);
+	});
+}
+
+#[test]
+fn event_util_functions_should_work() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		System::deposit_event(SysEvent::CodeUpdated);
+
+		System::assert_has_event(SysEvent::CodeUpdated.into());
+		System::assert_last_event(SysEvent::CodeUpdated.into());
+	});
+}
+
+#[test]
+fn prunes_block_hash_mappings() {
+	new_test_ext().execute_with(|| {
+		// simulate import of 15 blocks
+		for n in 1..=15 {
+			System::reset_events();
+			System::initialize(&n, &[n as u8 - 1; 32].into(), &Default::default());
+
+			System::finalize();
+		}
+
+		// first 5 block hashes are pruned
+		for n in 0..5 {
+			assert_eq!(System::block_hash(n), H256::zero());
+		}
+
+		// the remaining 10 are kept
+		for n in 5..15 {
+			assert_eq!(System::block_hash(n), [n as u8; 32].into());
+		}
+	})
+}
+
+#[test]
+fn set_code_checks_works() {
+	struct ReadRuntimeVersion(Vec<u8>);
+
+	impl sp_core::traits::ReadRuntimeVersion for ReadRuntimeVersion {
+		fn read_runtime_version(
+			&self,
+			_wasm_code: &[u8],
+			_ext: &mut dyn sp_externalities::Externalities,
+		) -> Result<Vec<u8>, String> {
+			Ok(self.0.clone())
+		}
+	}
+
+	let test_data = vec![
+		("test", 1, 2, Err(Error::<Test>::SpecVersionNeedsToIncrease)),
+		("test", 1, 1, Err(Error::<Test>::SpecVersionNeedsToIncrease)),
+		("test2", 1, 1, Err(Error::<Test>::InvalidSpecName)),
+		(
+			"test",
+			2,
+			1,
+			Ok(Some(<mock::Test as pallet::Config>::BlockWeights::get().max_block).into()),
+		),
+		("test", 0, 1, Err(Error::<Test>::SpecVersionNeedsToIncrease)),
+		("test", 1, 0, Err(Error::<Test>::SpecVersionNeedsToIncrease)),
+	];
+
+	for (spec_name, spec_version, impl_version, expected) in test_data.into_iter() {
+		let version = RuntimeVersion {
+			spec_name: spec_name.into(),
+			spec_version,
+			impl_version,
+			..Default::default()
+		};
+		let read_runtime_version = ReadRuntimeVersion(version.encode());
+
+		let mut ext = new_test_ext();
+		ext.register_extension(sp_core::traits::ReadRuntimeVersionExt::new(read_runtime_version));
+		ext.execute_with(|| {
+			let res = System::set_code(RawOrigin::Root.into(), vec![1, 2, 3, 4]);
+
+			assert_runtime_updated_digest(if res.is_ok() { 1 } else { 0 });
+			assert_eq!(expected.map_err(DispatchErrorWithPostInfo::from), res);
+		});
+	}
+}
+
+fn assert_runtime_updated_digest(num: usize) {
+	assert_eq!(
+		System::digest()
+			.logs
+			.into_iter()
+			.filter(|item| *item == generic::DigestItem::RuntimeEnvironmentUpdated)
+			.count(),
+		num,
+		"Incorrect number of Runtime Updated digest items",
+	);
+}
+
+#[test]
+fn set_code_with_real_wasm_blob() {
+	let executor = substrate_test_runtime_client::new_native_or_wasm_executor();
+	let mut ext = new_test_ext();
+	ext.register_extension(sp_core::traits::ReadRuntimeVersionExt::new(executor));
+	ext.execute_with(|| {
+		System::set_block_number(1);
+		System::set_code(
+			RawOrigin::Root.into(),
+			substrate_test_runtime_client::runtime::wasm_binary_unwrap().to_vec(),
+		)
+		.unwrap();
+
+		assert_eq!(
+			System::events(),
+			vec![EventRecord {
+				phase: Phase::Initialization,
+				event: SysEvent::CodeUpdated.into(),
+				topics: vec![],
+			}],
+		);
+	});
+}
+
+#[test]
+fn runtime_upgraded_with_set_storage() {
+	let executor = substrate_test_runtime_client::new_native_or_wasm_executor();
+	let mut ext = new_test_ext();
+	ext.register_extension(sp_core::traits::ReadRuntimeVersionExt::new(executor));
+	ext.execute_with(|| {
+		System::set_storage(
+			RawOrigin::Root.into(),
+			vec![(
+				well_known_keys::CODE.to_vec(),
+				substrate_test_runtime_client::runtime::wasm_binary_unwrap().to_vec(),
+			)],
+		)
+		.unwrap();
+	});
+}
+
+#[test]
+fn events_not_emitted_during_genesis() {
+	new_test_ext().execute_with(|| {
+		// Block Number is zero at genesis
+		assert!(System::block_number().is_zero());
+		let mut account_data = AccountInfo::default();
+		System::on_created_account(Default::default(), &mut account_data);
+		// No events registered at the genesis block
+		assert!(!System::read_events_no_consensus().any(|_| true));
+		// Events will be emitted starting on block 1
+		System::set_block_number(1);
+		System::on_created_account(Default::default(), &mut account_data);
+		assert!(System::events().len() == 1);
+	});
+}
+
+#[test]
+fn extrinsics_root_is_calculated_correctly() {
+	new_test_ext().execute_with(|| {
+		System::reset_events();
+		System::initialize(&1, &[0u8; 32].into(), &Default::default());
+		System::note_finished_initialize();
+		System::note_extrinsic(vec![1]);
+		System::note_applied_extrinsic(&Ok(().into()), Default::default());
+		System::note_extrinsic(vec![2]);
+		System::note_applied_extrinsic(&Err(DispatchError::BadOrigin.into()), Default::default());
+		System::note_finished_extrinsics();
+		let header = System::finalize();
+
+		let ext_root = extrinsics_data_root::<BlakeTwo256>(vec![vec![1], vec![2]]);
+		assert_eq!(ext_root, *header.extrinsics_root());
+	});
+}
+
+#[test]
+fn runtime_updated_digest_emitted_when_heap_pages_changed() {
+	new_test_ext().execute_with(|| {
+		System::reset_events();
+		System::initialize(&1, &[0u8; 32].into(), &Default::default());
+		System::set_heap_pages(RawOrigin::Root.into(), 5).unwrap();
+		assert_runtime_updated_digest(1);
+	});
+}
+
+#[test]
+fn ensure_signed_stuff_works() {
+	struct Members;
+	impl SortedMembers<u64> for Members {
+		fn sorted_members() -> Vec<u64> {
+			(0..10).collect()
+		}
+	}
+
+	let signed_origin = RuntimeOrigin::signed(0u64);
+	assert_ok!(<EnsureSigned<_> as EnsureOrigin<_>>::try_origin(signed_origin.clone()));
+	assert_ok!(<EnsureSignedBy<Members, _> as EnsureOrigin<_>>::try_origin(signed_origin));
+
+	#[cfg(feature = "runtime-benchmarks")]
+	{
+		let successful_origin: RuntimeOrigin =
+			<EnsureSigned<_> as EnsureOrigin<_>>::try_successful_origin()
+				.expect("EnsureSigned has no successful origin required for the test");
+		assert_ok!(<EnsureSigned<_> as EnsureOrigin<_>>::try_origin(successful_origin));
+
+		let successful_origin: RuntimeOrigin =
+			<EnsureSignedBy<Members, _> as EnsureOrigin<_>>::try_successful_origin()
+				.expect("EnsureSignedBy has no successful origin required for the test");
+		assert_ok!(<EnsureSignedBy<Members, _> as EnsureOrigin<_>>::try_origin(successful_origin));
+	}
+}
+
+pub fn from_actual_ref_time(ref_time: Option<u64>) -> PostDispatchInfo {
+	PostDispatchInfo {
+		actual_weight: ref_time.map(|t| Weight::from_all(t)),
+		pays_fee: Default::default(),
+	}
+}
+
+pub fn from_post_weight_info(ref_time: Option<u64>, pays_fee: Pays) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: ref_time.map(|t| Weight::from_all(t)), pays_fee }
+}
diff --git a/substrate/frame/system/src/weights.rs b/substrate/frame/system/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b79db3654b9f7172eab2a520151e0ab470dc7527
--- /dev/null
+++ b/substrate/frame/system/src/weights.rs
@@ -0,0 +1,243 @@
+// 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.
+
+//! Autogenerated weights for frame_system
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-22, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-s7kdgajz-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// target/production/substrate
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=frame-system
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/system/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for frame_system.
+pub trait WeightInfo {
+	fn remark(b: u32, ) -> Weight;
+	fn remark_with_event(b: u32, ) -> Weight;
+	fn set_heap_pages() -> Weight;
+	fn set_code() -> Weight;
+	fn set_storage(i: u32, ) -> Weight;
+	fn kill_storage(i: u32, ) -> Weight;
+	fn kill_prefix(p: u32, ) -> Weight;
+}
+
+/// Weights for frame_system using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: crate::Config> WeightInfo for SubstrateWeight<T> {
+	/// The range of component `b` is `[0, 3932160]`.
+	fn remark(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_004_000 picoseconds.
+		Weight::from_parts(2_119_000, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(390, 0).saturating_mul(b.into()))
+	}
+	/// The range of component `b` is `[0, 3932160]`.
+	fn remark_with_event(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_032_000 picoseconds.
+		Weight::from_parts(8_097_000, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_455, 0).saturating_mul(b.into()))
+	}
+	/// Storage: System Digest (r:1 w:1)
+	/// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: unknown `0x3a686561707061676573` (r:0 w:1)
+	/// Proof Skipped: unknown `0x3a686561707061676573` (r:0 w:1)
+	fn set_heap_pages() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 4_446_000 picoseconds.
+		Weight::from_parts(4_782_000, 1485)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: System Digest (r:1 w:1)
+	/// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: unknown `0x3a636f6465` (r:0 w:1)
+	/// Proof Skipped: unknown `0x3a636f6465` (r:0 w:1)
+	fn set_code() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 84_000_503_000 picoseconds.
+		Weight::from_parts(87_586_619_000, 1485)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Skipped Metadata (r:0 w:0)
+	/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn set_storage(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_086_000 picoseconds.
+		Weight::from_parts(2_175_000, 0)
+			// Standard Error: 1_056
+			.saturating_add(Weight::from_parts(841_511, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
+	}
+	/// Storage: Skipped Metadata (r:0 w:0)
+	/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn kill_storage(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_000_000 picoseconds.
+		Weight::from_parts(2_255_000, 0)
+			// Standard Error: 1_425
+			.saturating_add(Weight::from_parts(662_473, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
+	}
+	/// Storage: Skipped Metadata (r:0 w:0)
+	/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `p` is `[0, 1000]`.
+	fn kill_prefix(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `115 + p * (69 ±0)`
+		//  Estimated: `128 + p * (70 ±0)`
+		// Minimum execution time: 4_189_000 picoseconds.
+		Weight::from_parts(4_270_000, 128)
+			// Standard Error: 2_296
+			.saturating_add(Weight::from_parts(1_389_650, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into())))
+			.saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// The range of component `b` is `[0, 3932160]`.
+	fn remark(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_004_000 picoseconds.
+		Weight::from_parts(2_119_000, 0)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(390, 0).saturating_mul(b.into()))
+	}
+	/// The range of component `b` is `[0, 3932160]`.
+	fn remark_with_event(b: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 8_032_000 picoseconds.
+		Weight::from_parts(8_097_000, 0)
+			// Standard Error: 2
+			.saturating_add(Weight::from_parts(1_455, 0).saturating_mul(b.into()))
+	}
+	/// Storage: System Digest (r:1 w:1)
+	/// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: unknown `0x3a686561707061676573` (r:0 w:1)
+	/// Proof Skipped: unknown `0x3a686561707061676573` (r:0 w:1)
+	fn set_heap_pages() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 4_446_000 picoseconds.
+		Weight::from_parts(4_782_000, 1485)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: System Digest (r:1 w:1)
+	/// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: unknown `0x3a636f6465` (r:0 w:1)
+	/// Proof Skipped: unknown `0x3a636f6465` (r:0 w:1)
+	fn set_code() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `1485`
+		// Minimum execution time: 84_000_503_000 picoseconds.
+		Weight::from_parts(87_586_619_000, 1485)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Skipped Metadata (r:0 w:0)
+	/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn set_storage(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_086_000 picoseconds.
+		Weight::from_parts(2_175_000, 0)
+			// Standard Error: 1_056
+			.saturating_add(Weight::from_parts(841_511, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
+	}
+	/// Storage: Skipped Metadata (r:0 w:0)
+	/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `i` is `[0, 1000]`.
+	fn kill_storage(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 2_000_000 picoseconds.
+		Weight::from_parts(2_255_000, 0)
+			// Standard Error: 1_425
+			.saturating_add(Weight::from_parts(662_473, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
+	}
+	/// Storage: Skipped Metadata (r:0 w:0)
+	/// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `p` is `[0, 1000]`.
+	fn kill_prefix(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `115 + p * (69 ±0)`
+		//  Estimated: `128 + p * (70 ±0)`
+		// Minimum execution time: 4_189_000 picoseconds.
+		Weight::from_parts(4_270_000, 128)
+			// Standard Error: 2_296
+			.saturating_add(Weight::from_parts(1_389_650, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(p.into())))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(p.into())))
+			.saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into()))
+	}
+}
diff --git a/substrate/frame/timestamp/Cargo.toml b/substrate/frame/timestamp/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..76896ae9411b48b76b9c9bde5ddbbd56608bf3d6
--- /dev/null
+++ b/substrate/frame/timestamp/Cargo.toml
@@ -0,0 +1,62 @@
+[package]
+name = "pallet-timestamp"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME Timestamp Module"
+documentation = "https://docs.rs/pallet-timestamp"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../primitives/inherents" }
+sp-io = { version = "23.0.0", default-features = false, optional = true, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-storage = { version = "13.0.0", default-features = false, path = "../../primitives/storage" }
+sp-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../primitives/timestamp" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-io?/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-storage/std",
+	"sp-timestamp/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sp-io",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/timestamp/README.md b/substrate/frame/timestamp/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1546377ee67432bd2b2b42556aba096fc224185e
--- /dev/null
+++ b/substrate/frame/timestamp/README.md
@@ -0,0 +1,83 @@
+# Timestamp Module
+
+The Timestamp module provides functionality to get and set the on-chain time.
+
+- [`timestamp::Config`](https://docs.rs/pallet-timestamp/latest/pallet_timestamp/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-timestamp/latest/pallet_timestamp/pallet/enum.Call.html)
+- [`Pallet`](https://docs.rs/pallet-timestamp/latest/pallet_timestamp/pallet/struct.Pallet.html)
+
+## Overview
+
+The Timestamp module allows the validators to set and validate a timestamp with each block.
+
+It uses inherents for timestamp data, which is provided by the block author and validated/verified
+by other validators. The timestamp can be set only once per block and must be set each block.
+There could be a constraint on how much time must pass before setting the new timestamp.
+
+**NOTE:** The Timestamp module is the recommended way to query the on-chain time instead of using
+an approach based on block numbers. The block number based time measurement can cause issues
+because of cumulative calculation errors and hence should be avoided.
+
+## Interface
+
+### Dispatchable Functions
+
+* `set` - Sets the current time.
+
+### Public functions
+
+* `get` - Gets the current time for the current block. If this function is called prior to
+setting the timestamp, it will return the timestamp of the previous block.
+
+### Config Getters
+
+* `MinimumPeriod` - Gets the minimum (and advised) period between blocks for the chain.
+
+## Usage
+
+The following example shows how to use the Timestamp module in your custom module to query the current timestamp.
+
+### Prerequisites
+
+Import the Timestamp module into your custom module and derive the module configuration
+trait from the timestamp trait.
+
+### Get current timestamp
+
+```rust
+use pallet_timestamp::{self as timestamp};
+
+#[frame_support::pallet]
+pub mod pallet {
+    use super::*;
+    use frame_support::pallet_prelude::*;
+    use frame_system::pallet_prelude::*;
+
+    #[pallet::pallet]
+    pub struct Pallet<T>(_);
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config + timestamp::Config {}
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::weight(0)]
+        pub fn get_time(origin: OriginFor<T>) -> DispatchResult {
+            let _sender = ensure_signed(origin)?;
+            let _now = <timestamp::Pallet<T>>::get();
+            Ok(())
+        }
+    }
+}
+```
+
+### Example from the FRAME
+
+The [Session module](https://github.com/paritytech/substrate/blob/master/frame/session/src/lib.rs) uses
+the Timestamp module for session management.
+
+## Related Modules
+
+* [Session](https://docs.rs/pallet-session/latest/pallet_session/)
+
+License: Apache-2.0
diff --git a/substrate/frame/timestamp/src/benchmarking.rs b/substrate/frame/timestamp/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..82dfdfa8b312065aededecd7e81404c19403fe24
--- /dev/null
+++ b/substrate/frame/timestamp/src/benchmarking.rs
@@ -0,0 +1,61 @@
+// 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.
+
+//! Timestamp pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::benchmarks;
+use frame_support::{ensure, traits::OnFinalize};
+use frame_system::RawOrigin;
+use sp_storage::TrackedStorageKey;
+
+use crate::Pallet as Timestamp;
+
+const MAX_TIME: u32 = 100;
+
+benchmarks! {
+	set {
+		let t = MAX_TIME;
+		// Ignore write to `DidUpdate` since it transient.
+		let did_update_key = crate::DidUpdate::<T>::hashed_key().to_vec();
+		frame_benchmarking::benchmarking::add_to_whitelist(TrackedStorageKey {
+			key: did_update_key,
+			reads: 0,
+			writes: 1,
+			whitelisted: false,
+		});
+	}: _(RawOrigin::None, t.into())
+	verify {
+		ensure!(Timestamp::<T>::now() == t.into(), "Time was not set.");
+	}
+
+	on_finalize {
+		let t = MAX_TIME;
+		Timestamp::<T>::set(RawOrigin::None.into(), t.into())?;
+		ensure!(DidUpdate::<T>::exists(), "Time was not set.");
+		// Ignore read/write to `DidUpdate` since it is transient.
+		let did_update_key = crate::DidUpdate::<T>::hashed_key().to_vec();
+		frame_benchmarking::benchmarking::add_to_whitelist(did_update_key.into());
+	}: { Timestamp::<T>::on_finalize(t.into()); }
+	verify {
+		ensure!(!DidUpdate::<T>::exists(), "Time was not removed.");
+	}
+
+	impl_benchmark_test_suite!(Timestamp, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/timestamp/src/lib.rs b/substrate/frame/timestamp/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4eb95941d782881778c493ea28f88492438c8be4
--- /dev/null
+++ b/substrate/frame/timestamp/src/lib.rs
@@ -0,0 +1,314 @@
+// 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.
+
+//! # Timestamp Pallet
+//!
+//! The Timestamp pallet provides functionality to get and set the on-chain time.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//! - [`Pallet`]
+//!
+//! ## Overview
+//!
+//! The Timestamp pallet allows the validators to set and validate a timestamp with each block.
+//!
+//! It uses inherents for timestamp data, which is provided by the block author and
+//! validated/verified by other validators. The timestamp can be set only once per block and must be
+//! set each block. There could be a constraint on how much time must pass before setting the new
+//! timestamp.
+//!
+//! **NOTE:** The Timestamp pallet is the recommended way to query the on-chain time instead of
+//! using an approach based on block numbers. The block number based time measurement can cause
+//! issues because of cumulative calculation errors and hence should be avoided.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! * `set` - Sets the current time.
+//!
+//! ### Public functions
+//!
+//! * `get` - Gets the current time for the current block. If this function is called prior to
+//! setting the timestamp, it will return the timestamp of the previous block.
+//!
+//! ### Config Getters
+//!
+//! * `MinimumPeriod` - Gets the minimum (and advised) period between blocks for the chain.
+//!
+//! ## Usage
+//!
+//! The following example shows how to use the Timestamp pallet in your custom pallet to query the
+//! current timestamp.
+//!
+//! ### Prerequisites
+//!
+//! Import the Timestamp pallet into your custom pallet and derive the pallet configuration
+//! trait from the timestamp trait.
+//!
+//! ### Get current timestamp
+//!
+//! ```
+//! use pallet_timestamp::{self as timestamp};
+//!
+//! #[frame_support::pallet]
+//! pub mod pallet {
+//! 	use super::*;
+//! 	use frame_support::pallet_prelude::*;
+//! 	use frame_system::pallet_prelude::*;
+//!
+//! 	#[pallet::pallet]
+//! 	pub struct Pallet<T>(_);
+//!
+//! 	#[pallet::config]
+//! 	pub trait Config: frame_system::Config + timestamp::Config {}
+//!
+//! 	#[pallet::call]
+//! 	impl<T: Config> Pallet<T> {
+//! 		#[pallet::weight(0)]
+//! 		pub fn get_time(origin: OriginFor<T>) -> DispatchResult {
+//! 			let _sender = ensure_signed(origin)?;
+//! 			let _now = <timestamp::Pallet<T>>::get();
+//! 			Ok(())
+//! 		}
+//! 	}
+//! }
+//! # fn main() {}
+//! ```
+//!
+//! ### Example from the FRAME
+//!
+//! The [Session pallet](https://github.com/paritytech/substrate/blob/master/frame/session/src/lib.rs) uses
+//! the Timestamp pallet for session management.
+//!
+//! ## Related Pallets
+//!
+//! * [Session](../pallet_session/index.html)
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use frame_support::traits::{OnTimestampSet, Time, UnixTime};
+use sp_runtime::traits::{AtLeast32Bit, SaturatedConversion, Scale, Zero};
+use sp_std::{cmp, result};
+use sp_timestamp::{InherentError, InherentType, INHERENT_IDENTIFIER};
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The pallet configuration trait
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// Type used for expressing timestamp.
+		type Moment: Parameter
+			+ Default
+			+ AtLeast32Bit
+			+ Scale<BlockNumberFor<Self>, Output = Self::Moment>
+			+ Copy
+			+ MaxEncodedLen
+			+ scale_info::StaticTypeInfo;
+
+		/// Something which can be notified when the timestamp is set. Set this to `()` if not
+		/// needed.
+		type OnTimestampSet: OnTimestampSet<Self::Moment>;
+
+		/// The minimum period between blocks. Beware that this is different to the *expected*
+		/// period that the block production apparatus provides. Your chosen consensus system will
+		/// generally work with this to determine a sensible block time. e.g. For Aura, it will be
+		/// double this period on default settings.
+		#[pallet::constant]
+		type MinimumPeriod: Get<Self::Moment>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Current time for the current block.
+	#[pallet::storage]
+	#[pallet::getter(fn now)]
+	pub type Now<T: Config> = StorageValue<_, T::Moment, ValueQuery>;
+
+	/// Did the timestamp get updated in this block?
+	#[pallet::storage]
+	pub(super) type DidUpdate<T: Config> = StorageValue<_, bool, ValueQuery>;
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		/// dummy `on_initialize` to return the weight used in `on_finalize`.
+		fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+			// weight of `on_finalize`
+			T::WeightInfo::on_finalize()
+		}
+
+		/// ## Complexity
+		/// - `O(1)`
+		fn on_finalize(_n: BlockNumberFor<T>) {
+			assert!(DidUpdate::<T>::take(), "Timestamp must be updated once in the block");
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Set the current time.
+		///
+		/// This call should be invoked exactly once per block. It will panic at the finalization
+		/// phase, if this call hasn't been invoked by that time.
+		///
+		/// The timestamp should be greater than the previous one by the amount specified by
+		/// `MinimumPeriod`.
+		///
+		/// The dispatch origin for this call must be `Inherent`.
+		///
+		/// ## Complexity
+		/// - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
+		/// - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in
+		///   `on_finalize`)
+		/// - 1 event handler `on_timestamp_set`. Must be `O(1)`.
+		#[pallet::call_index(0)]
+		#[pallet::weight((
+			T::WeightInfo::set(),
+			DispatchClass::Mandatory
+		))]
+		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();
+			assert!(
+				prev.is_zero() || now >= prev + T::MinimumPeriod::get(),
+				"Timestamp must increment by at least <MinimumPeriod> between sequential blocks"
+			);
+			Now::<T>::put(now);
+			DidUpdate::<T>::put(true);
+
+			<T::OnTimestampSet as OnTimestampSet<_>>::on_timestamp_set(now);
+
+			Ok(())
+		}
+	}
+
+	#[pallet::inherent]
+	impl<T: Config> ProvideInherent for Pallet<T> {
+		type Call = Call<T>;
+		type Error = InherentError;
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(data: &InherentData) -> Option<Self::Call> {
+			let inherent_data = data
+				.get_data::<InherentType>(&INHERENT_IDENTIFIER)
+				.expect("Timestamp inherent data not correctly encoded")
+				.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());
+			Some(Call::set { now: next_time })
+		}
+
+		fn check_inherent(
+			call: &Self::Call,
+			data: &InherentData,
+		) -> result::Result<(), Self::Error> {
+			const MAX_TIMESTAMP_DRIFT_MILLIS: sp_timestamp::Timestamp =
+				sp_timestamp::Timestamp::new(30 * 1000);
+
+			let t: u64 = match call {
+				Call::set { ref now } => (*now).saturated_into::<u64>(),
+				_ => return Ok(()),
+			};
+
+			let data = data
+				.get_data::<InherentType>(&INHERENT_IDENTIFIER)
+				.expect("Timestamp inherent data not correctly encoded")
+				.expect("Timestamp inherent data must be provided");
+
+			let minimum = (Self::now() + T::MinimumPeriod::get()).saturated_into::<u64>();
+			if t > *(data + MAX_TIMESTAMP_DRIFT_MILLIS) {
+				Err(InherentError::TooFarInFuture)
+			} else if t < minimum {
+				Err(InherentError::TooEarly)
+			} else {
+				Ok(())
+			}
+		}
+
+		fn is_inherent(call: &Self::Call) -> bool {
+			matches!(call, Call::set { .. })
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Get the current time for the current block.
+	///
+	/// 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()
+	}
+
+	/// Set the timestamp to something in particular. Only used for tests.
+	#[cfg(any(feature = "runtime-benchmarks", feature = "std"))]
+	pub fn set_timestamp(now: T::Moment) {
+		Now::<T>::put(now);
+		DidUpdate::<T>::put(true);
+		<T::OnTimestampSet as OnTimestampSet<_>>::on_timestamp_set(now);
+	}
+}
+
+impl<T: Config> Time for Pallet<T> {
+	type Moment = T::Moment;
+
+	/// Before the first set of now with inherent the value returned is zero.
+	fn now() -> Self::Moment {
+		Self::now()
+	}
+}
+
+/// Before the timestamp inherent is applied, it returns the time of previous block.
+///
+/// On genesis the time returned is not valid.
+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();
+		sp_std::if_std! {
+			if now == T::Moment::zero() {
+				log::error!(
+					target: "runtime::timestamp",
+					"`pallet_timestamp::UnixTime::now` is called at genesis, invalid value returned: 0",
+				);
+			}
+		}
+		core::time::Duration::from_millis(now.saturated_into::<u64>())
+	}
+}
diff --git a/substrate/frame/timestamp/src/mock.rs b/substrate/frame/timestamp/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..418d257b3f0050d33a9690a068b5669ce055c1e9
--- /dev/null
+++ b/substrate/frame/timestamp/src/mock.rs
@@ -0,0 +1,101 @@
+// 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 Utilities.
+
+use super::*;
+use crate as pallet_timestamp;
+
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_io::TestExternalities;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+type Moment = u64;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
+	}
+);
+
+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 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! {
+	pub static CapturedMoment: Option<Moment> = None;
+}
+
+pub struct MockOnTimestampSet;
+impl OnTimestampSet<Moment> for MockOnTimestampSet {
+	fn on_timestamp_set(moment: Moment) {
+		CapturedMoment::mutate(|x| *x = Some(moment));
+	}
+}
+
+impl Config for Test {
+	type Moment = Moment;
+	type OnTimestampSet = MockOnTimestampSet;
+	type MinimumPeriod = ConstU64<5>;
+	type WeightInfo = ();
+}
+
+pub(crate) fn clear_captured_moment() {
+	CapturedMoment::mutate(|x| *x = None);
+}
+
+pub(crate) fn get_captured_moment() -> Option<Moment> {
+	CapturedMoment::get()
+}
+
+pub(crate) fn new_test_ext() -> TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	clear_captured_moment();
+	TestExternalities::new(t)
+}
diff --git a/substrate/frame/timestamp/src/tests.rs b/substrate/frame/timestamp/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..317631eeb704843140db261925d7ed109c614211
--- /dev/null
+++ b/substrate/frame/timestamp/src/tests.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.
+
+//! Tests for the Timestamp module.
+
+use crate::mock::*;
+use frame_support::assert_ok;
+
+#[test]
+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!(Some(69), get_captured_moment());
+	});
+}
+
+#[test]
+#[should_panic(expected = "Timestamp must be updated only once in the block")]
+fn double_timestamp_should_fail() {
+	new_test_ext().execute_with(|| {
+		Timestamp::set_timestamp(42);
+		assert_ok!(Timestamp::set(RuntimeOrigin::none(), 69));
+	});
+}
+
+#[test]
+#[should_panic(
+	expected = "Timestamp must increment by at least <MinimumPeriod> between sequential blocks"
+)]
+fn block_period_minimum_enforced() {
+	new_test_ext().execute_with(|| {
+		crate::Now::<Test>::put(44);
+		let _ = Timestamp::set(RuntimeOrigin::none(), 46);
+	});
+}
diff --git a/substrate/frame/timestamp/src/weights.rs b/substrate/frame/timestamp/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..46c544734869442c17d2be8b354bed916e197b83
--- /dev/null
+++ b/substrate/frame/timestamp/src/weights.rs
@@ -0,0 +1,106 @@
+// 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.
+
+//! Autogenerated weights for pallet_timestamp
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_timestamp
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/timestamp/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_timestamp.
+pub trait WeightInfo {
+	fn set() -> Weight;
+	fn on_finalize() -> Weight;
+}
+
+/// Weights for pallet_timestamp using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Timestamp Now (r:1 w:1)
+	/// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Babe CurrentSlot (r:1 w:0)
+	/// Proof: Babe CurrentSlot (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn set() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312`
+		//  Estimated: `1493`
+		// Minimum execution time: 9_857_000 picoseconds.
+		Weight::from_parts(10_492_000, 1493)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	fn on_finalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161`
+		//  Estimated: `0`
+		// Minimum execution time: 4_175_000 picoseconds.
+		Weight::from_parts(4_334_000, 0)
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Timestamp Now (r:1 w:1)
+	/// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	/// Storage: Babe CurrentSlot (r:1 w:0)
+	/// Proof: Babe CurrentSlot (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen)
+	fn set() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `312`
+		//  Estimated: `1493`
+		// Minimum execution time: 9_857_000 picoseconds.
+		Weight::from_parts(10_492_000, 1493)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	fn on_finalize() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161`
+		//  Estimated: `0`
+		// Minimum execution time: 4_175_000 picoseconds.
+		Weight::from_parts(4_334_000, 0)
+	}
+}
diff --git a/substrate/frame/tips/Cargo.toml b/substrate/frame/tips/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..61ecc681ec596832753c374d1a00179e9bed29bd
--- /dev/null
+++ b/substrate/frame/tips/Cargo.toml
@@ -0,0 +1,65 @@
+[package]
+name = "pallet-tips"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to manage tips"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive"], optional = true }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-treasury = { version = "4.0.0-dev", default-features = false, path = "../treasury" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-storage = { version = "13.0.0", path = "../../primitives/storage" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"pallet-treasury/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-storage/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-treasury/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-treasury/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/tips/README.md b/substrate/frame/tips/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d885ce770f79533c9b203f73bcf25458b644852b
--- /dev/null
+++ b/substrate/frame/tips/README.md
@@ -0,0 +1,33 @@
+# Tipping Pallet ( pallet-tips )
+
+**Note :: This pallet is tightly coupled to pallet-treasury**
+
+A subsystem to allow for an agile "tipping" process, whereby a reward may be given without first
+having a pre-determined stakeholder group come to consensus on how much should be paid.
+
+A group of `Tippers` is determined through the config `Config`. After half of these have declared
+some amount that they believe a particular reported reason deserves, then a countdown period is
+entered where any remaining members can declare their tip amounts also. After the close of the
+countdown period, the median of all declared tips is paid to the reported beneficiary, along with
+any finders fee, in case of a public (and bonded) original report.
+
+### Terminology
+
+- **Tipping:** The process of gathering declarations of amounts to tip and taking the median amount
+  to be transferred from the treasury to a beneficiary account.
+- **Tip Reason:** The reason for a tip; generally a URL which embodies or explains why a particular
+  individual (identified by an account ID) is worthy of a recognition by the treasury.
+- **Finder:** The original public reporter of some reason for tipping.
+- **Finders Fee:** Some proportion of the tip amount that is paid to the reporter of  the tip,
+  rather than the main beneficiary.
+
+## Interface
+
+### Dispatchable Functions
+
+- `report_awesome` - Report something worthy of a tip and register for a finders fee.
+- `retract_tip` - Retract a previous (finders fee registered) report.
+- `tip_new` - Report an item worthy of a tip and declare a specific amount to tip.
+- `tip` - Declare or redeclare an amount to tip for a particular reason.
+- `close_tip` - Close and pay out a tip.
+- `slash_tip` - Remove and slash an already-open tip.
\ No newline at end of file
diff --git a/substrate/frame/tips/src/benchmarking.rs b/substrate/frame/tips/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4a991b11b93319aa6daccade78fb2b8d535d58eb
--- /dev/null
+++ b/substrate/frame/tips/src/benchmarking.rs
@@ -0,0 +1,206 @@
+// 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.
+
+//! Treasury tips benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelisted_caller, BenchmarkError,
+};
+use frame_support::ensure;
+use frame_system::RawOrigin;
+use sp_runtime::traits::Saturating;
+
+use super::*;
+use crate::Pallet as TipsMod;
+
+const SEED: u32 = 0;
+
+// Create the pre-requisite information needed to create a `report_awesome`.
+fn setup_awesome<T: Config<I>, I: 'static>(length: u32) -> (T::AccountId, Vec<u8>, T::AccountId) {
+	let caller = whitelisted_caller();
+	let value = T::TipReportDepositBase::get() +
+		T::DataDepositPerByte::get() * length.into() +
+		T::Currency::minimum_balance();
+	let _ = T::Currency::make_free_balance_be(&caller, value);
+	let reason = vec![0; length as usize];
+	let awesome_person = account("awesome", 0, SEED);
+	(caller, reason, awesome_person)
+}
+
+// Create the pre-requisite information needed to call `tip_new`.
+fn setup_tip<T: Config<I>, I: 'static>(
+	r: u32,
+	t: u32,
+) -> Result<(T::AccountId, Vec<u8>, T::AccountId, BalanceOf<T, I>), &'static str> {
+	let tippers_count = T::Tippers::count();
+
+	for i in 0..t {
+		let member = account("member", i, SEED);
+		T::Tippers::add(&member);
+		ensure!(T::Tippers::contains(&member), "failed to add tipper");
+	}
+
+	ensure!(T::Tippers::count() == tippers_count + t as usize, "problem creating tippers");
+	let caller = account("member", t - 1, SEED);
+	let reason = vec![0; r as usize];
+	let beneficiary = account("beneficiary", t, SEED);
+	let value = T::Currency::minimum_balance().saturating_mul(100u32.into());
+	Ok((caller, reason, beneficiary, value))
+}
+
+// Create `t` new tips for the tip proposal with `hash`.
+// This function automatically makes the tip able to close.
+fn create_tips<T: Config<I>, I: 'static>(
+	t: u32,
+	hash: T::Hash,
+	value: BalanceOf<T, I>,
+) -> Result<(), &'static str> {
+	for i in 0..t {
+		let caller = account("member", i, SEED);
+		ensure!(T::Tippers::contains(&caller), "caller is not a tipper");
+		TipsMod::<T, I>::tip(RawOrigin::Signed(caller).into(), hash, value)?;
+	}
+	Tips::<T, I>::mutate(hash, |maybe_tip| {
+		if let Some(open_tip) = maybe_tip {
+			open_tip.closes = Some(frame_system::pallet_prelude::BlockNumberFor::<T>::zero());
+		}
+	});
+	Ok(())
+}
+
+fn setup_pot_account<T: Config<I>, I: 'static>() {
+	let pot_account = TipsMod::<T, I>::account_id();
+	let value = T::Currency::minimum_balance().saturating_mul(1_000_000_000u32.into());
+	let _ = T::Currency::make_free_balance_be(&pot_account, value);
+}
+
+benchmarks_instance_pallet! {
+	report_awesome {
+		let r in 0 .. T::MaximumReasonLength::get();
+		let (caller, reason, awesome_person) = setup_awesome::<T, I>(r);
+		let awesome_person_lookup = T::Lookup::unlookup(awesome_person);
+		// 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());
+	}: _(RawOrigin::Signed(caller), reason, awesome_person_lookup)
+
+	retract_tip {
+		let r = T::MaximumReasonLength::get();
+		let (caller, reason, awesome_person) = setup_awesome::<T, I>(r);
+		let awesome_person_lookup = T::Lookup::unlookup(awesome_person.clone());
+		TipsMod::<T, I>::report_awesome(
+			RawOrigin::Signed(caller.clone()).into(),
+			reason.clone(),
+			awesome_person_lookup
+		)?;
+		let reason_hash = T::Hashing::hash(&reason[..]);
+		let hash = T::Hashing::hash_of(&(&reason_hash, &awesome_person));
+		// 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());
+	}: _(RawOrigin::Signed(caller), hash)
+
+	tip_new {
+		let r in 0 .. T::MaximumReasonLength::get();
+		let t in 1 .. T::Tippers::max_len() as u32;
+
+		let (caller, reason, beneficiary, value) = setup_tip::<T, I>(r, t)?;
+		let beneficiary_lookup = T::Lookup::unlookup(beneficiary);
+		// 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());
+	}: _(RawOrigin::Signed(caller), reason, beneficiary_lookup, value)
+
+	tip {
+		let t in 1 .. T::Tippers::max_len() as u32;
+		let (member, reason, beneficiary, value) = setup_tip::<T, I>(0, t)?;
+		let beneficiary_lookup = T::Lookup::unlookup(beneficiary.clone());
+		let value = T::Currency::minimum_balance().saturating_mul(100u32.into());
+		TipsMod::<T, I>::tip_new(
+			RawOrigin::Signed(member).into(),
+			reason.clone(),
+			beneficiary_lookup,
+			value
+		)?;
+		let reason_hash = T::Hashing::hash(&reason[..]);
+		let hash = T::Hashing::hash_of(&(&reason_hash, &beneficiary));
+		ensure!(Tips::<T, I>::contains_key(hash), "tip does not exist");
+		create_tips::<T, I>(t - 1, hash, value)?;
+		let caller = account("member", t - 1, 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());
+	}: _(RawOrigin::Signed(caller), hash, value)
+
+	close_tip {
+		let t in 1 .. T::Tippers::max_len() as u32;
+
+		// Make sure pot is funded
+		setup_pot_account::<T, I>();
+
+		// Set up a new tip proposal
+		let (member, reason, beneficiary, value) = setup_tip::<T, I>(0, t)?;
+		let beneficiary_lookup = T::Lookup::unlookup(beneficiary.clone());
+		let value = T::Currency::minimum_balance().saturating_mul(100u32.into());
+		TipsMod::<T, I>::tip_new(
+			RawOrigin::Signed(member).into(),
+			reason.clone(),
+			beneficiary_lookup,
+			value
+		)?;
+
+		// Create a bunch of tips
+		let reason_hash = T::Hashing::hash(&reason[..]);
+		let hash = T::Hashing::hash_of(&(&reason_hash, &beneficiary));
+		ensure!(Tips::<T, I>::contains_key(hash), "tip does not exist");
+
+		create_tips::<T, I>(t, hash, value)?;
+
+		let caller = account("caller", 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());
+	}: _(RawOrigin::Signed(caller), hash)
+
+	slash_tip {
+		let t in 1 .. T::Tippers::max_len() as u32;
+
+		// Make sure pot is funded
+		setup_pot_account::<T, I>();
+
+		// Set up a new tip proposal
+		let (member, reason, beneficiary, value) = setup_tip::<T, I>(0, t)?;
+		let beneficiary_lookup = T::Lookup::unlookup(beneficiary.clone());
+		let value = T::Currency::minimum_balance().saturating_mul(100u32.into());
+		TipsMod::<T, I>::tip_new(
+			RawOrigin::Signed(member).into(),
+			reason.clone(),
+			beneficiary_lookup,
+			value
+		)?;
+
+		let reason_hash = T::Hashing::hash(&reason[..]);
+		let hash = T::Hashing::hash_of(&(&reason_hash, &beneficiary));
+		ensure!(Tips::<T, I>::contains_key(hash), "tip does not exist");
+		let reject_origin =
+			T::RejectOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: _<T::RuntimeOrigin>(reject_origin, hash)
+
+	impl_benchmark_test_suite!(TipsMod, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/tips/src/lib.rs b/substrate/frame/tips/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6e8f72e0540e63bd88560fc13b778d34be740e2e
--- /dev/null
+++ b/substrate/frame/tips/src/lib.rs
@@ -0,0 +1,602 @@
+// 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.
+
+//! # Tipping Pallet ( pallet-tips )
+//!
+//! > NOTE: This pallet is tightly coupled with pallet-treasury.
+//!
+//! A subsystem to allow for an agile "tipping" process, whereby a reward may be given without first
+//! having a pre-determined stakeholder group come to consensus on how much should be paid.
+//!
+//! A group of `Tippers` is determined through the config `Config`. After half of these have
+//! declared some amount that they believe a particular reported reason deserves, then a countdown
+//! period is entered where any remaining members can declare their tip amounts also. After the
+//! close of the countdown period, the median of all declared tips is paid to the reported
+//! beneficiary, along with any finders fee, in case of a public (and bonded) original report.
+//!
+//!
+//! ### Terminology
+//!
+//! Tipping protocol:
+//! - **Tipping:** The process of gathering declarations of amounts to tip and taking the median
+//!   amount to be transferred from the treasury to a beneficiary account.
+//! - **Tip Reason:** The reason for a tip; generally a URL which embodies or explains why a
+//!   particular individual (identified by an account ID) is worthy of a recognition by the
+//!   treasury.
+//! - **Finder:** The original public reporter of some reason for tipping.
+//! - **Finders Fee:** Some proportion of the tip amount that is paid to the reporter of the tip,
+//!   rather than the main beneficiary.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! Tipping protocol:
+//! - `report_awesome` - Report something worthy of a tip and register for a finders fee.
+//! - `retract_tip` - Retract a previous (finders fee registered) report.
+//! - `tip_new` - Report an item worthy of a tip and declare a specific amount to tip.
+//! - `tip` - Declare or redeclare an amount to tip for a particular reason.
+//! - `close_tip` - Close and pay out a tip.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod tests;
+
+pub mod migrations;
+pub mod weights;
+
+use sp_runtime::{
+	traits::{AccountIdConversion, BadOrigin, Hash, StaticLookup, TrailingZeroInput, Zero},
+	Percent, RuntimeDebug,
+};
+use sp_std::prelude::*;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	traits::{
+		ContainsLengthBound, Currency, EnsureOrigin, ExistenceRequirement::KeepAlive, Get,
+		OnUnbalanced, ReservableCurrency, SortedMembers,
+	},
+	Parameter,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+const LOG_TARGET: &str = "runtime::tips";
+
+pub type BalanceOf<T, I = ()> = pallet_treasury::BalanceOf<T, I>;
+pub type NegativeImbalanceOf<T, I = ()> = pallet_treasury::NegativeImbalanceOf<T, I>;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// An open tipping "motion". Retains all details of a tip including information on the finder
+/// and the members who have voted.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, scale_info::TypeInfo)]
+pub struct OpenTip<
+	AccountId: Parameter,
+	Balance: Parameter,
+	BlockNumber: Parameter,
+	Hash: Parameter,
+> {
+	/// The hash of the reason for the tip. The reason should be a human-readable UTF-8 encoded
+	/// string. A URL would be sensible.
+	reason: Hash,
+	/// The account to be tipped.
+	who: AccountId,
+	/// The account who began this tip.
+	finder: AccountId,
+	/// The amount held on deposit for this tip.
+	deposit: Balance,
+	/// The block number at which this tip will close if `Some`. If `None`, then no closing is
+	/// scheduled.
+	closes: Option<BlockNumber>,
+	/// The members who have voted for this tip. Sorted by AccountId.
+	tips: Vec<(AccountId, Balance)>,
+	/// Whether this tip should result in the finder taking a fee.
+	finders_fee: bool,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	/// The current storage version.
+	const STORAGE_VERSION: StorageVersion = StorageVersion::new(4);
+
+	#[pallet::pallet]
+	#[pallet::storage_version(STORAGE_VERSION)]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config + pallet_treasury::Config<I> {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Maximum acceptable reason length.
+		///
+		/// Benchmarks depend on this value, be sure to update weights file when changing this value
+		#[pallet::constant]
+		type MaximumReasonLength: Get<u32>;
+
+		/// The amount held on deposit per byte within the tip report reason or bounty description.
+		#[pallet::constant]
+		type DataDepositPerByte: Get<BalanceOf<Self, I>>;
+
+		/// The period for which a tip remains open after is has achieved threshold tippers.
+		#[pallet::constant]
+		type TipCountdown: Get<BlockNumberFor<Self>>;
+
+		/// The percent of the final tip which goes to the original reporter of the tip.
+		#[pallet::constant]
+		type TipFindersFee: Get<Percent>;
+
+		/// The amount held on deposit for placing a tip report.
+		#[pallet::constant]
+		type TipReportDepositBase: Get<BalanceOf<Self, I>>;
+
+		/// Origin from which tippers must come.
+		///
+		/// `ContainsLengthBound::max_len` must be cost free (i.e. no storage read or heavy
+		/// operation). Benchmarks depend on the value of `ContainsLengthBound::max_len` be sure to
+		/// update weights file when altering this method.
+		type Tippers: SortedMembers<Self::AccountId> + ContainsLengthBound;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// TipsMap that are not yet completed. Keyed by the hash of `(reason, who)` from the value.
+	/// This has the insecure enumerable hash function since the key itself is already
+	/// guaranteed to be a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn tips)]
+	pub type Tips<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Twox64Concat,
+		T::Hash,
+		OpenTip<T::AccountId, BalanceOf<T, I>, BlockNumberFor<T>, T::Hash>,
+		OptionQuery,
+	>;
+
+	/// Simple preimage lookup from the reason's hash to the original data. Again, has an
+	/// insecure enumerable hash since the key is guaranteed to be the result of a secure hash.
+	#[pallet::storage]
+	#[pallet::getter(fn reasons)]
+	pub type Reasons<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Identity, T::Hash, Vec<u8>, OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A new tip suggestion has been opened.
+		NewTip { tip_hash: T::Hash },
+		/// A tip suggestion has reached threshold and is closing.
+		TipClosing { tip_hash: T::Hash },
+		/// A tip suggestion has been closed.
+		TipClosed { tip_hash: T::Hash, who: T::AccountId, payout: BalanceOf<T, I> },
+		/// A tip suggestion has been retracted.
+		TipRetracted { tip_hash: T::Hash },
+		/// A tip suggestion has been slashed.
+		TipSlashed { tip_hash: T::Hash, finder: T::AccountId, deposit: BalanceOf<T, I> },
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// The reason given is just too big.
+		ReasonTooBig,
+		/// The tip was already found/started.
+		AlreadyKnown,
+		/// The tip hash is unknown.
+		UnknownTip,
+		/// The account attempting to retract the tip is not the finder of the tip.
+		NotFinder,
+		/// The tip cannot be claimed/closed because there are not enough tippers yet.
+		StillOpen,
+		/// The tip cannot be claimed/closed because it's still in the countdown period.
+		Premature,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Report something `reason` that deserves a tip and claim any eventual the finder's fee.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// Payment: `TipReportDepositBase` will be reserved from the origin account, as well as
+		/// `DataDepositPerByte` for each byte in `reason`.
+		///
+		/// - `reason`: The reason for, or the thing that deserves, the tip; generally this will be
+		///   a UTF-8-encoded URL.
+		/// - `who`: The account which should be credited for the tip.
+		///
+		/// Emits `NewTip` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R)` where `R` length of `reason`.
+		///   - encoding and hashing of 'reason'
+		#[pallet::call_index(0)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::report_awesome(reason.len() as u32))]
+		pub fn report_awesome(
+			origin: OriginFor<T>,
+			reason: Vec<u8>,
+			who: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let finder = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
+
+			ensure!(
+				reason.len() <= T::MaximumReasonLength::get() as usize,
+				Error::<T, I>::ReasonTooBig
+			);
+
+			let reason_hash = T::Hashing::hash(&reason[..]);
+			ensure!(!Reasons::<T, I>::contains_key(&reason_hash), Error::<T, I>::AlreadyKnown);
+			let hash = T::Hashing::hash_of(&(&reason_hash, &who));
+			ensure!(!Tips::<T, I>::contains_key(&hash), Error::<T, I>::AlreadyKnown);
+
+			let deposit = T::TipReportDepositBase::get() +
+				T::DataDepositPerByte::get() * (reason.len() as u32).into();
+			T::Currency::reserve(&finder, deposit)?;
+
+			Reasons::<T, I>::insert(&reason_hash, &reason);
+			let tip = OpenTip {
+				reason: reason_hash,
+				who,
+				finder,
+				deposit,
+				closes: None,
+				tips: vec![],
+				finders_fee: true,
+			};
+			Tips::<T, I>::insert(&hash, tip);
+			Self::deposit_event(Event::NewTip { tip_hash: hash });
+			Ok(())
+		}
+
+		/// Retract a prior tip-report from `report_awesome`, and cancel the process of tipping.
+		///
+		/// If successful, the original deposit will be unreserved.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the tip identified by `hash`
+		/// must have been reported by the signing account through `report_awesome` (and not
+		/// through `tip_new`).
+		///
+		/// - `hash`: The identity of the open tip for which a tip value is declared. This is formed
+		///   as the hash of the tuple of the original tip `reason` and the beneficiary account ID.
+		///
+		/// Emits `TipRetracted` if successful.
+		///
+		/// ## Complexity
+		/// - `O(1)`
+		///   - Depends on the length of `T::Hash` which is fixed.
+		#[pallet::call_index(1)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::retract_tip())]
+		pub fn retract_tip(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let tip = Tips::<T, I>::get(&hash).ok_or(Error::<T, I>::UnknownTip)?;
+			ensure!(tip.finder == who, Error::<T, I>::NotFinder);
+
+			Reasons::<T, I>::remove(&tip.reason);
+			Tips::<T, I>::remove(&hash);
+			if !tip.deposit.is_zero() {
+				let err_amount = T::Currency::unreserve(&who, tip.deposit);
+				debug_assert!(err_amount.is_zero());
+			}
+			Self::deposit_event(Event::TipRetracted { tip_hash: hash });
+			Ok(())
+		}
+
+		/// Give a tip for something new; no finder's fee will be taken.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the signing account must be a
+		/// member of the `Tippers` set.
+		///
+		/// - `reason`: The reason for, or the thing that deserves, the tip; generally this will be
+		///   a UTF-8-encoded URL.
+		/// - `who`: The account which should be credited for the tip.
+		/// - `tip_value`: The amount of tip that the sender would like to give. The median tip
+		///   value of active tippers will be given to the `who`.
+		///
+		/// Emits `NewTip` if successful.
+		///
+		/// ## Complexity
+		/// - `O(R + T)` where `R` length of `reason`, `T` is the number of tippers.
+		///   - `O(T)`: decoding `Tipper` vec of length `T`. `T` is charged as upper bound given by
+		///     `ContainsLengthBound`. The actual cost depends on the implementation of
+		///     `T::Tippers`.
+		///   - `O(R)`: hashing and encoding of reason of length `R`
+		#[pallet::call_index(2)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::tip_new(reason.len() as u32, T::Tippers::max_len() as u32))]
+		pub fn tip_new(
+			origin: OriginFor<T>,
+			reason: Vec<u8>,
+			who: AccountIdLookupOf<T>,
+			#[pallet::compact] tip_value: BalanceOf<T, I>,
+		) -> DispatchResult {
+			let tipper = ensure_signed(origin)?;
+			let who = T::Lookup::lookup(who)?;
+			ensure!(T::Tippers::contains(&tipper), BadOrigin);
+			let reason_hash = T::Hashing::hash(&reason[..]);
+			ensure!(!Reasons::<T, I>::contains_key(&reason_hash), Error::<T, I>::AlreadyKnown);
+			let hash = T::Hashing::hash_of(&(&reason_hash, &who));
+
+			Reasons::<T, I>::insert(&reason_hash, &reason);
+			Self::deposit_event(Event::NewTip { tip_hash: hash });
+			let tips = vec![(tipper.clone(), tip_value)];
+			let tip = OpenTip {
+				reason: reason_hash,
+				who,
+				finder: tipper,
+				deposit: Zero::zero(),
+				closes: None,
+				tips,
+				finders_fee: false,
+			};
+			Tips::<T, I>::insert(&hash, tip);
+			Ok(())
+		}
+
+		/// Declare a tip value for an already-open tip.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the signing account must be a
+		/// member of the `Tippers` set.
+		///
+		/// - `hash`: The identity of the open tip for which a tip value is declared. This is formed
+		///   as the hash of the tuple of the hash of the original tip `reason` and the beneficiary
+		///   account ID.
+		/// - `tip_value`: The amount of tip that the sender would like to give. The median tip
+		///   value of active tippers will be given to the `who`.
+		///
+		/// Emits `TipClosing` if the threshold of tippers has been reached and the countdown period
+		/// has started.
+		///
+		/// ## Complexity
+		/// - `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length `T`, insert
+		///   tip and check closing, `T` is charged as upper bound given by `ContainsLengthBound`.
+		///   The actual cost depends on the implementation of `T::Tippers`.
+		///
+		///   Actually weight could be lower as it depends on how many tips are in `OpenTip` but it
+		///   is weighted as if almost full i.e of length `T-1`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::tip(T::Tippers::max_len() as u32))]
+		pub fn tip(
+			origin: OriginFor<T>,
+			hash: T::Hash,
+			#[pallet::compact] tip_value: BalanceOf<T, I>,
+		) -> DispatchResult {
+			let tipper = ensure_signed(origin)?;
+			ensure!(T::Tippers::contains(&tipper), BadOrigin);
+
+			let mut tip = Tips::<T, I>::get(hash).ok_or(Error::<T, I>::UnknownTip)?;
+			if Self::insert_tip_and_check_closing(&mut tip, tipper, tip_value) {
+				Self::deposit_event(Event::TipClosing { tip_hash: hash });
+			}
+			Tips::<T, I>::insert(&hash, tip);
+			Ok(())
+		}
+
+		/// Close and payout a tip.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// The tip identified by `hash` must have finished its countdown period.
+		///
+		/// - `hash`: The identity of the open tip for which a tip value is declared. This is formed
+		///   as the hash of the tuple of the original tip `reason` and the beneficiary account ID.
+		///
+		/// ## Complexity
+		/// - : `O(T)` where `T` is the number of tippers. decoding `Tipper` vec of length `T`. `T`
+		///   is charged as upper bound given by `ContainsLengthBound`. The actual cost depends on
+		///   the implementation of `T::Tippers`.
+		#[pallet::call_index(4)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::close_tip(T::Tippers::max_len() as u32))]
+		pub fn close_tip(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
+			ensure_signed(origin)?;
+
+			let tip = Tips::<T, I>::get(hash).ok_or(Error::<T, I>::UnknownTip)?;
+			let n = tip.closes.as_ref().ok_or(Error::<T, I>::StillOpen)?;
+			ensure!(frame_system::Pallet::<T>::block_number() >= *n, Error::<T, I>::Premature);
+			// closed.
+			Reasons::<T, I>::remove(&tip.reason);
+			Tips::<T, I>::remove(hash);
+			Self::payout_tip(hash, tip);
+			Ok(())
+		}
+
+		/// Remove and slash an already-open tip.
+		///
+		/// May only be called from `T::RejectOrigin`.
+		///
+		/// As a result, the finder is slashed and the deposits are lost.
+		///
+		/// Emits `TipSlashed` if successful.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(5)]
+		#[pallet::weight(<T as Config<I>>::WeightInfo::slash_tip(T::Tippers::max_len() as u32))]
+		pub fn slash_tip(origin: OriginFor<T>, hash: T::Hash) -> DispatchResult {
+			T::RejectOrigin::ensure_origin(origin)?;
+
+			let tip = Tips::<T, I>::take(hash).ok_or(Error::<T, I>::UnknownTip)?;
+
+			if !tip.deposit.is_zero() {
+				let imbalance = T::Currency::slash_reserved(&tip.finder, tip.deposit).0;
+				T::OnSlash::on_unbalanced(imbalance);
+			}
+			Reasons::<T, I>::remove(&tip.reason);
+			Self::deposit_event(Event::TipSlashed {
+				tip_hash: hash,
+				finder: tip.finder,
+				deposit: tip.deposit,
+			});
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	// Add public immutables and private mutables.
+
+	/// The account ID of the treasury pot.
+	///
+	/// This actually does computation. If you need to keep using it, then make sure you cache the
+	/// value and only call this once.
+	pub fn account_id() -> T::AccountId {
+		T::PalletId::get().into_account_truncating()
+	}
+
+	/// Given a mutable reference to an `OpenTip`, insert the tip into it and check whether it
+	/// closes, if so, then deposit the relevant event and set closing accordingly.
+	///
+	/// `O(T)` and one storage access.
+	fn insert_tip_and_check_closing(
+		tip: &mut OpenTip<T::AccountId, BalanceOf<T, I>, BlockNumberFor<T>, T::Hash>,
+		tipper: T::AccountId,
+		tip_value: BalanceOf<T, I>,
+	) -> bool {
+		match tip.tips.binary_search_by_key(&&tipper, |x| &x.0) {
+			Ok(pos) => tip.tips[pos] = (tipper, tip_value),
+			Err(pos) => tip.tips.insert(pos, (tipper, tip_value)),
+		}
+		Self::retain_active_tips(&mut tip.tips);
+		let threshold = (T::Tippers::count() + 1) / 2;
+		if tip.tips.len() >= threshold && tip.closes.is_none() {
+			tip.closes = Some(frame_system::Pallet::<T>::block_number() + T::TipCountdown::get());
+			true
+		} else {
+			false
+		}
+	}
+
+	/// Remove any non-members of `Tippers` from a `tips` vector. `O(T)`.
+	fn retain_active_tips(tips: &mut Vec<(T::AccountId, BalanceOf<T, I>)>) {
+		let members = T::Tippers::sorted_members();
+		let mut members_iter = members.iter();
+		let mut member = members_iter.next();
+		tips.retain(|(ref a, _)| loop {
+			match member {
+				None => break false,
+				Some(m) if m > a => break false,
+				Some(m) => {
+					member = members_iter.next();
+					if m < a {
+						continue
+					} else {
+						break true
+					}
+				},
+			}
+		});
+	}
+
+	/// Execute the payout of a tip.
+	///
+	/// Up to three balance operations.
+	/// Plus `O(T)` (`T` is Tippers length).
+	fn payout_tip(
+		hash: T::Hash,
+		tip: OpenTip<T::AccountId, BalanceOf<T, I>, BlockNumberFor<T>, T::Hash>,
+	) {
+		let mut tips = tip.tips;
+		Self::retain_active_tips(&mut tips);
+		tips.sort_by_key(|i| i.1);
+
+		let treasury = Self::account_id();
+		let max_payout = pallet_treasury::Pallet::<T, I>::pot();
+
+		let mut payout = tips[tips.len() / 2].1.min(max_payout);
+		if !tip.deposit.is_zero() {
+			let err_amount = T::Currency::unreserve(&tip.finder, tip.deposit);
+			debug_assert!(err_amount.is_zero());
+		}
+
+		if tip.finders_fee && tip.finder != tip.who {
+			// pay out the finder's fee.
+			let finders_fee = T::TipFindersFee::get() * payout;
+			payout -= finders_fee;
+			// this should go through given we checked it's at most the free balance, but still
+			// we only make a best-effort.
+			let res = T::Currency::transfer(&treasury, &tip.finder, finders_fee, KeepAlive);
+			debug_assert!(res.is_ok());
+		}
+
+		// same as above: best-effort only.
+		let res = T::Currency::transfer(&treasury, &tip.who, payout, KeepAlive);
+		debug_assert!(res.is_ok());
+		Self::deposit_event(Event::TipClosed { tip_hash: hash, who: tip.who, payout });
+	}
+
+	pub fn migrate_retract_tip_for_tip_new(module: &[u8], item: &[u8]) {
+		/// An open tipping "motion". Retains all details of a tip including information on the
+		/// finder and the members who have voted.
+		#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug)]
+		pub struct OldOpenTip<
+			AccountId: Parameter,
+			Balance: Parameter,
+			BlockNumber: Parameter,
+			Hash: Parameter,
+		> {
+			/// The hash of the reason for the tip. The reason should be a human-readable UTF-8
+			/// encoded string. A URL would be sensible.
+			reason: Hash,
+			/// The account to be tipped.
+			who: AccountId,
+			/// The account who began this tip and the amount held on deposit.
+			finder: Option<(AccountId, Balance)>,
+			/// The block number at which this tip will close if `Some`. If `None`, then no closing
+			/// is scheduled.
+			closes: Option<BlockNumber>,
+			/// The members who have voted for this tip. Sorted by AccountId.
+			tips: Vec<(AccountId, Balance)>,
+		}
+
+		use frame_support::{migration::storage_key_iter, Twox64Concat};
+
+		let zero_account = T::AccountId::decode(&mut TrailingZeroInput::new(&[][..]))
+			.expect("infinite input; qed");
+
+		for (hash, old_tip) in storage_key_iter::<
+			T::Hash,
+			OldOpenTip<T::AccountId, BalanceOf<T, I>, BlockNumberFor<T>, T::Hash>,
+			Twox64Concat,
+		>(module, item)
+		.drain()
+		{
+			let (finder, deposit, finders_fee) = match old_tip.finder {
+				Some((finder, deposit)) => (finder, deposit, true),
+				None => (zero_account.clone(), Zero::zero(), false),
+			};
+			let new_tip = OpenTip {
+				reason: old_tip.reason,
+				who: old_tip.who,
+				finder,
+				deposit,
+				closes: old_tip.closes,
+				tips: old_tip.tips,
+				finders_fee,
+			};
+			Tips::<T, I>::insert(hash, new_tip)
+		}
+	}
+}
diff --git a/substrate/frame/tips/src/migrations/mod.rs b/substrate/frame/tips/src/migrations/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9cdd01c17fbf6009e306caff31079ca0eb7a6ea1
--- /dev/null
+++ b/substrate/frame/tips/src/migrations/mod.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.
+
+/// Version 4.
+///
+/// For backward compatability reasons, pallet-tips uses `Treasury` for storage module prefix
+/// before calling this migration. After calling this migration, it will get replaced with
+/// own storage identifier.
+pub mod v4;
+
+/// A migration that unreserves all funds held in the context of this pallet.
+pub mod unreserve_deposits;
diff --git a/substrate/frame/tips/src/migrations/unreserve_deposits.rs b/substrate/frame/tips/src/migrations/unreserve_deposits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..16cb1a80e812bd43dbcf60c353210a650a4d59d0
--- /dev/null
+++ b/substrate/frame/tips/src/migrations/unreserve_deposits.rs
@@ -0,0 +1,324 @@
+// 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 migration that unreserves all deposit and unlocks all stake held in the context of this
+//! pallet.
+
+use core::iter::Sum;
+use frame_support::{
+	pallet_prelude::OptionQuery,
+	storage_alias,
+	traits::{Currency, LockableCurrency, OnRuntimeUpgrade, ReservableCurrency},
+	weights::RuntimeDbWeight,
+	Parameter, Twox64Concat,
+};
+use sp_runtime::{traits::Zero, Saturating};
+use sp_std::collections::btree_map::BTreeMap;
+
+#[cfg(feature = "try-runtime")]
+const LOG_TARGET: &str = "runtime::tips::migrations::unreserve_deposits";
+
+type BalanceOf<T, I> =
+	<<T as UnlockConfig<I>>::Currency as Currency<<T as UnlockConfig<I>>::AccountId>>::Balance;
+
+/// The configuration for [`UnreserveDeposits`].
+pub trait UnlockConfig<I>: 'static {
+	/// The hash used in the runtime.
+	type Hash: Parameter;
+	/// The account ID used in the runtime.
+	type AccountId: Parameter + Ord;
+	/// The currency type used in the runtime.
+	///
+	/// Should match the currency type previously used for the pallet, if applicable.
+	type Currency: LockableCurrency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
+	/// Base deposit to report a tip.
+	///
+	/// Should match the currency type previously used for the pallet, if applicable.
+	type TipReportDepositBase: sp_core::Get<BalanceOf<Self, I>>;
+	/// Deposit per byte to report a tip.
+	///
+	/// Should match the currency type previously used for the pallet, if applicable.
+	type DataDepositPerByte: sp_core::Get<BalanceOf<Self, I>>;
+	/// The name of the pallet as previously configured in
+	/// [`construct_runtime!`](frame_support::construct_runtime).
+	type PalletName: sp_core::Get<&'static str>;
+	/// The DB weight as configured in the runtime to calculate the correct weight.
+	type DbWeight: sp_core::Get<RuntimeDbWeight>;
+	/// The block number as configured in the runtime.
+	type BlockNumber: Parameter + Zero + Copy + Ord;
+}
+
+/// An open tipping "motion". Retains all details of a tip including information on the finder
+/// and the members who have voted.
+#[storage_alias(dynamic)]
+type Tips<T: UnlockConfig<I>, I: 'static> = StorageMap<
+	<T as UnlockConfig<I>>::PalletName,
+	Twox64Concat,
+	<T as UnlockConfig<I>>::Hash,
+	crate::OpenTip<
+		<T as UnlockConfig<I>>::AccountId,
+		BalanceOf<T, I>,
+		<T as UnlockConfig<I>>::BlockNumber,
+		<T as UnlockConfig<I>>::Hash,
+	>,
+	OptionQuery,
+>;
+
+/// A migration that unreserves all tip deposits.
+///
+/// Useful to prevent funds from being locked up when the pallet is deprecated.
+///
+/// The pallet should be made inoperable before or immediately after this migration is run.
+///
+/// (See also the `RemovePallet` migration in `frame/support/src/migrations.rs`)
+pub struct UnreserveDeposits<T: UnlockConfig<I>, I: 'static>(sp_std::marker::PhantomData<(T, I)>);
+
+impl<T: UnlockConfig<I>, I: 'static> UnreserveDeposits<T, I> {
+	/// Calculates and returns the total amount reserved by each account by this pallet from open
+	/// tips.
+	///
+	/// # Returns
+	///
+	/// * `BTreeMap<T::AccountId, T::Balance>`: Map of account IDs to their respective total
+	///   reserved balance by this pallet
+	/// * `frame_support::weights::Weight`: The weight of this operation.
+	fn get_deposits() -> (BTreeMap<T::AccountId, BalanceOf<T, I>>, frame_support::weights::Weight) {
+		use sp_core::Get;
+
+		let mut tips_len = 0;
+		let account_deposits: BTreeMap<T::AccountId, BalanceOf<T, I>> = Tips::<T, I>::iter()
+			.map(|(_hash, open_tip)| open_tip)
+			.fold(BTreeMap::new(), |mut acc, tip| {
+				// Count the total number of tips
+				tips_len.saturating_inc();
+
+				// Add the balance to the account's existing deposit in the accumulator
+				acc.entry(tip.finder).or_insert(Zero::zero()).saturating_accrue(tip.deposit);
+				acc
+			});
+
+		(account_deposits, T::DbWeight::get().reads(tips_len))
+	}
+}
+
+impl<T: UnlockConfig<I>, I: 'static> OnRuntimeUpgrade for UnreserveDeposits<T, I>
+where
+	BalanceOf<T, I>: Sum,
+{
+	/// Gets the actual reserved amount for each account before the migration, performs integrity
+	/// checks and prints some summary information.
+	///
+	/// Steps:
+	/// 1. Gets the deposited balances for each account stored in this pallet.
+	/// 2. Collects actual pre-migration reserved balances for each account.
+	/// 3. Checks the integrity of the deposited balances.
+	/// 4. Prints summary statistics about the state to be migrated.
+	/// 5. Returns the pre-migration actual reserved balance for each account that will
+	/// be part of the migration.
+	///
+	/// Fails with a `TryRuntimeError` if somehow the amount reserved by this pallet is greater than
+	/// the actual total reserved amount for any accounts.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<sp_std::vec::Vec<u8>, sp_runtime::TryRuntimeError> {
+		use codec::Encode;
+		use frame_support::ensure;
+
+		// Get the Tips pallet view of balances it has reserved
+		let (account_deposits, _) = Self::get_deposits();
+
+		// Get the actual amounts reserved for accounts with open tips
+		let account_reserved_before: BTreeMap<T::AccountId, BalanceOf<T, I>> = account_deposits
+			.keys()
+			.map(|account| (account.clone(), T::Currency::reserved_balance(&account)))
+			.collect();
+
+		// The deposit amount must be less than or equal to the reserved amount.
+		// If it is higher, there is either a bug with the pallet or a bug in the calculation of the
+		// deposit amount.
+		ensure!(
+			account_deposits.iter().all(|(account, deposit)| *deposit <=
+				*account_reserved_before.get(account).unwrap_or(&Zero::zero())),
+			"Deposit amount is greater than reserved amount"
+		);
+
+		// Print some summary stats
+		let total_deposits_to_unreserve =
+			account_deposits.clone().into_values().sum::<BalanceOf<T, I>>();
+		log::info!(target: LOG_TARGET, "Total accounts: {}", account_deposits.keys().count());
+		log::info!(target: LOG_TARGET, "Total amount to unreserve: {:?}", total_deposits_to_unreserve);
+
+		// Return the actual amount reserved before the upgrade to verify integrity of the upgrade
+		// in the post_upgrade hook.
+		Ok(account_reserved_before.encode())
+	}
+
+	/// Executes the migration, unreserving funds that are locked in Tip deposits.
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		use frame_support::traits::Get;
+
+		// Get staked and deposited balances as reported by this pallet.
+		let (account_deposits, initial_reads) = Self::get_deposits();
+
+		// Deposited funds need to be unreserved.
+		for (account, unreserve_amount) in account_deposits.iter() {
+			if unreserve_amount.is_zero() {
+				continue
+			}
+			T::Currency::unreserve(&account, *unreserve_amount);
+		}
+
+		T::DbWeight::get()
+			.reads_writes(account_deposits.len() as u64, account_deposits.len() as u64)
+			.saturating_add(initial_reads)
+	}
+
+	/// Verifies that the account reserved balances were reduced by the actual expected amounts.
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(
+		account_reserved_before_bytes: sp_std::vec::Vec<u8>,
+	) -> Result<(), sp_runtime::TryRuntimeError> {
+		use codec::Decode;
+
+		let account_reserved_before = BTreeMap::<T::AccountId, BalanceOf<T, I>>::decode(
+			&mut &account_reserved_before_bytes[..],
+		)
+		.map_err(|_| "Failed to decode account_reserved_before_bytes")?;
+
+		// Get deposited balances as reported by this pallet.
+		let (account_deposits, _) = Self::get_deposits();
+
+		// Check that the reserved balance is reduced by the expected deposited amount.
+		for (account, actual_reserved_before) in account_reserved_before {
+			let actual_reserved_after = T::Currency::reserved_balance(&account);
+			let expected_amount_deducted = *account_deposits
+				.get(&account)
+				.expect("account deposit must exist to be in account_reserved_before, qed");
+			let expected_reserved_after =
+				actual_reserved_before.saturating_sub(expected_amount_deducted);
+
+			if actual_reserved_after != expected_reserved_after {
+				log::error!(
+					target: LOG_TARGET,
+					"Reserved balance for {:?} is incorrect. actual before: {:?}, actual after, {:?}, expected deducted: {:?}",
+					account,
+					actual_reserved_before,
+					actual_reserved_after,
+					expected_amount_deducted
+				);
+				return Err("Reserved balance is incorrect".into())
+			}
+		}
+
+		Ok(())
+	}
+}
+
+#[cfg(all(feature = "try-runtime", test))]
+mod test {
+	use super::*;
+	use crate::{
+		migrations::unreserve_deposits::UnreserveDeposits,
+		tests::{new_test_ext, Balances, RuntimeOrigin, Test, Tips},
+	};
+	use frame_support::{assert_ok, parameter_types, traits::TypedGet};
+	use frame_system::pallet_prelude::BlockNumberFor;
+	use sp_core::ConstU64;
+
+	parameter_types! {
+		const PalletName: &'static str = "Tips";
+	}
+
+	struct UnlockConfigImpl;
+	impl super::UnlockConfig<()> for UnlockConfigImpl {
+		type Currency = Balances;
+		type TipReportDepositBase = ConstU64<1>;
+		type DataDepositPerByte = ConstU64<1>;
+		type Hash = sp_core::H256;
+		type AccountId = u128;
+		type BlockNumber = BlockNumberFor<Test>;
+		type DbWeight = ();
+		type PalletName = PalletName;
+	}
+
+	#[test]
+	fn unreserve_all_funds_works() {
+		let tipper_0 = 0;
+		let tipper_1 = 1;
+		let tipper_0_initial_reserved = 0;
+		let tipper_1_initial_reserved = 5;
+		let recipient = 100;
+		let tip_0_reason = b"what_is_really_not_awesome".to_vec();
+		let tip_1_reason = b"pineapple_on_pizza".to_vec();
+		new_test_ext().execute_with(|| {
+			// Set up
+			assert_ok!(<Test as pallet_treasury::Config>::Currency::reserve(
+				&tipper_0,
+				tipper_0_initial_reserved
+			));
+			assert_ok!(<Test as pallet_treasury::Config>::Currency::reserve(
+				&tipper_1,
+				tipper_1_initial_reserved
+			));
+
+			// Make some tips
+			assert_ok!(Tips::report_awesome(
+				RuntimeOrigin::signed(tipper_0),
+				tip_0_reason.clone(),
+				recipient
+			));
+			assert_ok!(Tips::report_awesome(
+				RuntimeOrigin::signed(tipper_1),
+				tip_1_reason.clone(),
+				recipient
+			));
+
+			// Verify the expected amount is reserved
+			assert_eq!(
+				<Test as pallet_treasury::Config>::Currency::reserved_balance(&tipper_0),
+				tipper_0_initial_reserved +
+					<Test as crate::Config>::TipReportDepositBase::get() +
+					<Test as crate::Config>::DataDepositPerByte::get() *
+						tip_0_reason.len() as u64
+			);
+			assert_eq!(
+				<Test as pallet_treasury::Config>::Currency::reserved_balance(&tipper_1),
+				tipper_1_initial_reserved +
+					<Test as crate::Config>::TipReportDepositBase::get() +
+					<Test as crate::Config>::DataDepositPerByte::get() *
+						tip_1_reason.len() as u64
+			);
+
+			// Execute the migration
+			let bytes = match UnreserveDeposits::<UnlockConfigImpl, ()>::pre_upgrade() {
+				Ok(bytes) => bytes,
+				Err(e) => panic!("pre_upgrade failed: {:?}", e),
+			};
+			UnreserveDeposits::<UnlockConfigImpl, ()>::on_runtime_upgrade();
+			assert_ok!(UnreserveDeposits::<UnlockConfigImpl, ()>::post_upgrade(bytes));
+
+			// Check the deposits were were unreserved
+			assert_eq!(
+				<Test as pallet_treasury::Config>::Currency::reserved_balance(&tipper_0),
+				tipper_0_initial_reserved
+			);
+			assert_eq!(
+				<Test as pallet_treasury::Config>::Currency::reserved_balance(&tipper_1),
+				tipper_1_initial_reserved
+			);
+		});
+	}
+}
diff --git a/substrate/frame/tips/src/migrations/v4.rs b/substrate/frame/tips/src/migrations/v4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..35569633d1bb85e831180775124fc52223337ad1
--- /dev/null
+++ b/substrate/frame/tips/src/migrations/v4.rs
@@ -0,0 +1,196 @@
+// 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 sp_io::hashing::twox_128;
+use sp_std::str;
+
+use super::super::LOG_TARGET;
+use frame_support::{
+	storage::StoragePrefixedMap,
+	traits::{
+		Get, GetStorageVersion, PalletInfoAccess, StorageVersion,
+		STORAGE_VERSION_STORAGE_KEY_POSTFIX,
+	},
+	weights::Weight,
+};
+
+use crate as pallet_tips;
+
+/// Migrate the entire storage of this pallet to a new prefix.
+///
+/// This new prefix must be the same as the one set in construct_runtime.
+/// For safety, use `PalletInfo` to get it, as:
+/// `<Runtime as frame_system::Config>::PalletInfo::name::<TipsPallet>`.
+///
+/// The migration will look into the storage version in order not to trigger a migration on an up
+/// to date storage. Thus the on chain storage version must be less than 4 in order to trigger the
+/// migration.
+pub fn migrate<T: pallet_tips::Config, P: GetStorageVersion + PalletInfoAccess, N: AsRef<str>>(
+	old_pallet_name: N,
+) -> Weight {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+
+	if new_pallet_name == old_pallet_name {
+		log::info!(
+			target: LOG_TARGET,
+			"New pallet name is equal to the old prefix. No migration needs to be done.",
+		);
+		return Weight::zero()
+	}
+
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration to v4 for tips with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 4 {
+		let storage_prefix = pallet_tips::Tips::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, old_pallet_name, new_pallet_name);
+
+		let storage_prefix = pallet_tips::Reasons::<T>::storage_prefix();
+		frame_support::storage::migration::move_storage_from_pallet(
+			storage_prefix,
+			old_pallet_name.as_bytes(),
+			new_pallet_name.as_bytes(),
+		);
+		log_migration("migration", storage_prefix, old_pallet_name, new_pallet_name);
+
+		StorageVersion::new(4).put::<P>();
+		<T as frame_system::Config>::BlockWeights::get().max_block
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to v4 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		Weight::zero()
+	}
+}
+
+/// Some checks prior to migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::pre_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn pre_migrate<
+	T: pallet_tips::Config,
+	P: GetStorageVersion + PalletInfoAccess,
+	N: AsRef<str>,
+>(
+	old_pallet_name: N,
+) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+
+	let storage_prefix_tips = pallet_tips::Tips::<T>::storage_prefix();
+	let storage_prefix_reasons = pallet_tips::Reasons::<T>::storage_prefix();
+
+	log_migration("pre-migration", storage_prefix_tips, old_pallet_name, new_pallet_name);
+	log_migration("pre-migration", storage_prefix_reasons, old_pallet_name, new_pallet_name);
+
+	if new_pallet_name == old_pallet_name {
+		return
+	}
+
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let storage_version_key = twox_128(STORAGE_VERSION_STORAGE_KEY_POSTFIX);
+
+	let mut new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|key| Ok(key.to_vec()),
+	);
+
+	// Ensure nothing except the storage_version_key is stored in the new prefix.
+	assert!(new_pallet_prefix_iter.all(|key| key == storage_version_key));
+
+	assert!(<P as GetStorageVersion>::on_chain_storage_version() < 4);
+}
+
+/// Some checks for after migration. This can be linked to
+/// [`frame_support::traits::OnRuntimeUpgrade::post_upgrade`] for further testing.
+///
+/// Panics if anything goes wrong.
+pub fn post_migrate<
+	T: pallet_tips::Config,
+	P: GetStorageVersion + PalletInfoAccess,
+	N: AsRef<str>,
+>(
+	old_pallet_name: N,
+) {
+	let old_pallet_name = old_pallet_name.as_ref();
+	let new_pallet_name = <P as PalletInfoAccess>::name();
+
+	let storage_prefix_tips = pallet_tips::Tips::<T>::storage_prefix();
+	let storage_prefix_reasons = pallet_tips::Reasons::<T>::storage_prefix();
+
+	log_migration("post-migration", storage_prefix_tips, old_pallet_name, new_pallet_name);
+	log_migration("post-migration", storage_prefix_reasons, old_pallet_name, new_pallet_name);
+
+	if new_pallet_name == old_pallet_name {
+		return
+	}
+
+	// Assert that no `Tips` and `Reasons` storages remains at the old prefix.
+	let old_pallet_prefix = twox_128(old_pallet_name.as_bytes());
+	let old_tips_key = [&old_pallet_prefix, &twox_128(storage_prefix_tips)[..]].concat();
+	let old_tips_key_iter = frame_support::storage::KeyPrefixIterator::new(
+		old_tips_key.to_vec(),
+		old_tips_key.to_vec(),
+		|_| Ok(()),
+	);
+	assert_eq!(old_tips_key_iter.count(), 0);
+
+	let old_reasons_key = [&old_pallet_prefix, &twox_128(storage_prefix_reasons)[..]].concat();
+	let old_reasons_key_iter = frame_support::storage::KeyPrefixIterator::new(
+		old_reasons_key.to_vec(),
+		old_reasons_key.to_vec(),
+		|_| Ok(()),
+	);
+	assert_eq!(old_reasons_key_iter.count(), 0);
+
+	// Assert that the `Tips` and `Reasons` storages (if they exist) have been moved to the new
+	// prefix.
+	// NOTE: storage_version_key is already in the new prefix.
+	let new_pallet_prefix = twox_128(new_pallet_name.as_bytes());
+	let new_pallet_prefix_iter = frame_support::storage::KeyPrefixIterator::new(
+		new_pallet_prefix.to_vec(),
+		new_pallet_prefix.to_vec(),
+		|_| Ok(()),
+	);
+	assert!(new_pallet_prefix_iter.count() >= 1);
+
+	assert_eq!(<P as GetStorageVersion>::on_chain_storage_version(), 4);
+}
+
+fn log_migration(stage: &str, storage_prefix: &[u8], old_pallet_name: &str, new_pallet_name: &str) {
+	log::info!(
+		target: LOG_TARGET,
+		"{} prefix of storage '{}': '{}' ==> '{}'",
+		stage,
+		str::from_utf8(storage_prefix).unwrap_or("<Invalid UTF8>"),
+		old_pallet_name,
+		new_pallet_name,
+	);
+}
diff --git a/substrate/frame/tips/src/tests.rs b/substrate/frame/tips/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a700892d42703f3560d1b6cabc1e1e7641cb1ddc
--- /dev/null
+++ b/substrate/frame/tips/src/tests.rs
@@ -0,0 +1,615 @@
+// 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.
+
+//! Treasury pallet tests.
+
+#![cfg(test)]
+
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BadOrigin, BlakeTwo256, IdentityLookup},
+	BuildStorage, Perbill, Permill,
+};
+use sp_storage::Storage;
+
+use frame_support::{
+	assert_noop, assert_ok, parameter_types,
+	storage::StoragePrefixedMap,
+	traits::{ConstU32, ConstU64, SortedMembers, StorageVersion},
+	PalletId,
+};
+
+use super::*;
+use crate::{self as pallet_tips, Event as TipEvent};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Treasury: pallet_treasury::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Treasury1: pallet_treasury::<Instance1>::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Tips: pallet_tips::{Pallet, Call, Storage, Event<T>},
+		Tips1: pallet_tips::<Instance1>::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub const AvailableBlockRatio: Perbill = Perbill::one();
+}
+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 RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = u128; // u64 is not enough to hold bytes used to generate bounty account
+	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>;
+}
+
+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 MaxHolds = ();
+}
+parameter_types! {
+	static TenToFourteenTestValue: Vec<u128> = vec![10,11,12,13,14];
+}
+pub struct TenToFourteen;
+impl SortedMembers<u128> for TenToFourteen {
+	fn sorted_members() -> Vec<u128> {
+		TenToFourteenTestValue::get().clone()
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add(new: &u128) {
+		TenToFourteenTestValue::mutate(|members| {
+			members.push(*new);
+			members.sort();
+		})
+	}
+}
+impl ContainsLengthBound for TenToFourteen {
+	fn max_len() -> usize {
+		TenToFourteenTestValue::get().len()
+	}
+	fn min_len() -> usize {
+		0
+	}
+}
+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");
+}
+impl pallet_treasury::Config for Test {
+	type PalletId = TreasuryPalletId;
+	type Currency = pallet_balances::Pallet<Test>;
+	type ApproveOrigin = frame_system::EnsureRoot<u128>;
+	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.
+	type WeightInfo = ();
+	type SpendFunds = ();
+	type MaxApprovals = ConstU32<100>;
+	type SpendOrigin = frame_support::traits::NeverEnsureOrigin<u64>;
+}
+
+impl pallet_treasury::Config<Instance1> for Test {
+	type PalletId = TreasuryPalletId2;
+	type Currency = pallet_balances::Pallet<Test>;
+	type ApproveOrigin = frame_system::EnsureRoot<u128>;
+	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.
+	type WeightInfo = ();
+	type SpendFunds = ();
+	type MaxApprovals = ConstU32<100>;
+	type SpendOrigin = frame_support::traits::NeverEnsureOrigin<u64>;
+}
+
+parameter_types! {
+	pub const TipFindersFee: Percent = Percent::from_percent(20);
+}
+impl Config for Test {
+	type MaximumReasonLength = ConstU32<16384>;
+	type Tippers = TenToFourteen;
+	type TipCountdown = ConstU64<1>;
+	type TipFindersFee = TipFindersFee;
+	type TipReportDepositBase = ConstU64<1>;
+	type DataDepositPerByte = ConstU64<1>;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+}
+
+impl Config<Instance1> for Test {
+	type MaximumReasonLength = ConstU32<16384>;
+	type Tippers = TenToFourteen;
+	type TipCountdown = ConstU64<1>;
+	type TipFindersFee = TipFindersFee;
+	type TipReportDepositBase = ConstU64<1>;
+	type DataDepositPerByte = ConstU64<1>;
+	type RuntimeEvent = RuntimeEvent;
+	type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut ext: sp_io::TestExternalities = RuntimeGenesisConfig {
+		system: frame_system::GenesisConfig::default(),
+		balances: pallet_balances::GenesisConfig { balances: vec![(0, 100), (1, 98), (2, 1)] },
+		treasury: Default::default(),
+		treasury_1: Default::default(),
+	}
+	.build_storage()
+	.unwrap()
+	.into();
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+fn last_event() -> TipEvent<Test> {
+	System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let RuntimeEvent::Tips(inner) = e { Some(inner) } else { None })
+		.last()
+		.unwrap()
+}
+
+#[test]
+fn genesis_config_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Treasury::pot(), 0);
+		assert_eq!(Treasury::proposal_count(), 0);
+	});
+}
+
+fn tip_hash() -> H256 {
+	BlakeTwo256::hash_of(&(BlakeTwo256::hash(b"awesome.dot"), 3u128))
+}
+
+#[test]
+fn tip_new_cannot_be_used_twice() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Tips::tip_new(RuntimeOrigin::signed(10), b"awesome.dot".to_vec(), 3, 10));
+		assert_noop!(
+			Tips::tip_new(RuntimeOrigin::signed(11), b"awesome.dot".to_vec(), 3, 10),
+			Error::<Test>::AlreadyKnown
+		);
+	});
+}
+
+#[test]
+fn report_awesome_and_tip_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Tips::report_awesome(RuntimeOrigin::signed(0), b"awesome.dot".to_vec(), 3));
+		assert_eq!(Balances::reserved_balance(0), 12);
+		assert_eq!(Balances::free_balance(0), 88);
+
+		// other reports don't count.
+		assert_noop!(
+			Tips::report_awesome(RuntimeOrigin::signed(1), b"awesome.dot".to_vec(), 3),
+			Error::<Test>::AlreadyKnown
+		);
+
+		let h = tip_hash();
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(10), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 10));
+		assert_noop!(Tips::tip(RuntimeOrigin::signed(9), h, 10), BadOrigin);
+		System::set_block_number(2);
+		assert_ok!(Tips::close_tip(RuntimeOrigin::signed(100), h.into()));
+		assert_eq!(Balances::reserved_balance(0), 0);
+		assert_eq!(Balances::free_balance(0), 102);
+		assert_eq!(Balances::free_balance(3), 8);
+	});
+}
+
+#[test]
+fn report_awesome_from_beneficiary_and_tip_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Tips::report_awesome(RuntimeOrigin::signed(0), b"awesome.dot".to_vec(), 0));
+		assert_eq!(Balances::reserved_balance(0), 12);
+		assert_eq!(Balances::free_balance(0), 88);
+		let h = BlakeTwo256::hash_of(&(BlakeTwo256::hash(b"awesome.dot"), 0u128));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(10), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 10));
+		System::set_block_number(2);
+		assert_ok!(Tips::close_tip(RuntimeOrigin::signed(100), h.into()));
+		assert_eq!(Balances::reserved_balance(0), 0);
+		assert_eq!(Balances::free_balance(0), 110);
+	});
+}
+
+#[test]
+fn close_tip_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+
+		assert_ok!(Tips::tip_new(RuntimeOrigin::signed(10), b"awesome.dot".to_vec(), 3, 10));
+
+		let h = tip_hash();
+
+		assert_eq!(last_event(), TipEvent::NewTip { tip_hash: h });
+
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 10));
+
+		assert_noop!(Tips::close_tip(RuntimeOrigin::signed(0), h.into()), Error::<Test>::StillOpen);
+
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 10));
+
+		assert_eq!(last_event(), TipEvent::TipClosing { tip_hash: h });
+
+		assert_noop!(Tips::close_tip(RuntimeOrigin::signed(0), h.into()), Error::<Test>::Premature);
+
+		System::set_block_number(2);
+		assert_noop!(Tips::close_tip(RuntimeOrigin::none(), h.into()), BadOrigin);
+		assert_ok!(Tips::close_tip(RuntimeOrigin::signed(0), h.into()));
+		assert_eq!(Balances::free_balance(3), 10);
+
+		assert_eq!(last_event(), TipEvent::TipClosed { tip_hash: h, who: 3, payout: 10 });
+
+		assert_noop!(
+			Tips::close_tip(RuntimeOrigin::signed(100), h.into()),
+			Error::<Test>::UnknownTip
+		);
+	});
+}
+
+#[test]
+fn slash_tip_works() {
+	new_test_ext().execute_with(|| {
+		System::set_block_number(1);
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+
+		assert_eq!(Balances::reserved_balance(0), 0);
+		assert_eq!(Balances::free_balance(0), 100);
+
+		assert_ok!(Tips::report_awesome(RuntimeOrigin::signed(0), b"awesome.dot".to_vec(), 3));
+
+		assert_eq!(Balances::reserved_balance(0), 12);
+		assert_eq!(Balances::free_balance(0), 88);
+
+		let h = tip_hash();
+		assert_eq!(last_event(), TipEvent::NewTip { tip_hash: h });
+
+		// can't remove from any origin
+		assert_noop!(Tips::slash_tip(RuntimeOrigin::signed(0), h), BadOrigin);
+
+		// can remove from root.
+		assert_ok!(Tips::slash_tip(RuntimeOrigin::root(), h));
+		assert_eq!(last_event(), TipEvent::TipSlashed { tip_hash: h, finder: 0, deposit: 12 });
+
+		// tipper slashed
+		assert_eq!(Balances::reserved_balance(0), 0);
+		assert_eq!(Balances::free_balance(0), 88);
+	});
+}
+
+#[test]
+fn retract_tip_works() {
+	new_test_ext().execute_with(|| {
+		// with report awesome
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Tips::report_awesome(RuntimeOrigin::signed(0), b"awesome.dot".to_vec(), 3));
+		let h = tip_hash();
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(10), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 10));
+		assert_noop!(Tips::retract_tip(RuntimeOrigin::signed(10), h), Error::<Test>::NotFinder);
+		assert_ok!(Tips::retract_tip(RuntimeOrigin::signed(0), h));
+		System::set_block_number(2);
+		assert_noop!(
+			Tips::close_tip(RuntimeOrigin::signed(0), h.into()),
+			Error::<Test>::UnknownTip
+		);
+
+		// with tip new
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Tips::tip_new(RuntimeOrigin::signed(10), b"awesome.dot".to_vec(), 3, 10));
+		let h = tip_hash();
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 10));
+		assert_noop!(Tips::retract_tip(RuntimeOrigin::signed(0), h), Error::<Test>::NotFinder);
+		assert_ok!(Tips::retract_tip(RuntimeOrigin::signed(10), h));
+		System::set_block_number(2);
+		assert_noop!(
+			Tips::close_tip(RuntimeOrigin::signed(10), h.into()),
+			Error::<Test>::UnknownTip
+		);
+	});
+}
+
+#[test]
+fn tip_median_calculation_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Tips::tip_new(RuntimeOrigin::signed(10), b"awesome.dot".to_vec(), 3, 0));
+		let h = tip_hash();
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 10));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 1000000));
+		System::set_block_number(2);
+		assert_ok!(Tips::close_tip(RuntimeOrigin::signed(0), h.into()));
+		assert_eq!(Balances::free_balance(3), 10);
+	});
+}
+
+#[test]
+fn tip_changing_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Tips::tip_new(RuntimeOrigin::signed(10), b"awesome.dot".to_vec(), 3, 10000));
+		let h = tip_hash();
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 10000));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 10000));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(13), h, 0));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(14), h, 0));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(12), h, 1000));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(11), h, 100));
+		assert_ok!(Tips::tip(RuntimeOrigin::signed(10), h, 10));
+		System::set_block_number(2);
+		assert_ok!(Tips::close_tip(RuntimeOrigin::signed(0), h.into()));
+		assert_eq!(Balances::free_balance(3), 10);
+	});
+}
+
+#[test]
+fn test_last_reward_migration() {
+	let mut s = Storage::default();
+
+	#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug)]
+	pub struct OldOpenTip<
+		AccountId: Parameter,
+		Balance: Parameter,
+		BlockNumber: Parameter,
+		Hash: Parameter,
+	> {
+		/// The hash of the reason for the tip. The reason should be a human-readable UTF-8 encoded
+		/// string. A URL would be sensible.
+		reason: Hash,
+		/// The account to be tipped.
+		who: AccountId,
+		/// The account who began this tip and the amount held on deposit.
+		finder: Option<(AccountId, Balance)>,
+		/// The block number at which this tip will close if `Some`. If `None`, then no closing is
+		/// scheduled.
+		closes: Option<BlockNumber>,
+		/// The members who have voted for this tip. Sorted by AccountId.
+		tips: Vec<(AccountId, Balance)>,
+	}
+
+	let reason1 = BlakeTwo256::hash(b"reason1");
+	let hash1 = BlakeTwo256::hash_of(&(reason1, 10u64));
+
+	let old_tip_finder = OldOpenTip::<u128, u64, u64, H256> {
+		reason: reason1,
+		who: 10,
+		finder: Some((20, 30)),
+		closes: Some(13),
+		tips: vec![(40, 50), (60, 70)],
+	};
+
+	let reason2 = BlakeTwo256::hash(b"reason2");
+	let hash2 = BlakeTwo256::hash_of(&(reason2, 20u64));
+
+	let old_tip_no_finder = OldOpenTip::<u128, u64, u64, H256> {
+		reason: reason2,
+		who: 20,
+		finder: None,
+		closes: Some(13),
+		tips: vec![(40, 50), (60, 70)],
+	};
+
+	let data = vec![
+		(pallet_tips::Tips::<Test>::hashed_key_for(hash1), old_tip_finder.encode().to_vec()),
+		(pallet_tips::Tips::<Test>::hashed_key_for(hash2), old_tip_no_finder.encode().to_vec()),
+	];
+
+	s.top = data.into_iter().collect();
+
+	sp_io::TestExternalities::new(s).execute_with(|| {
+		let module = pallet_tips::Tips::<Test>::module_prefix();
+		let item = pallet_tips::Tips::<Test>::storage_prefix();
+		Tips::migrate_retract_tip_for_tip_new(module, item);
+
+		// Test w/ finder
+		assert_eq!(
+			pallet_tips::Tips::<Test>::get(hash1),
+			Some(OpenTip {
+				reason: reason1,
+				who: 10,
+				finder: 20,
+				deposit: 30,
+				closes: Some(13),
+				tips: vec![(40, 50), (60, 70)],
+				finders_fee: true,
+			})
+		);
+
+		// Test w/o finder
+		assert_eq!(
+			pallet_tips::Tips::<Test>::get(hash2),
+			Some(OpenTip {
+				reason: reason2,
+				who: 20,
+				finder: Default::default(),
+				deposit: 0,
+				closes: Some(13),
+				tips: vec![(40, 50), (60, 70)],
+				finders_fee: false,
+			})
+		);
+	});
+}
+
+#[test]
+fn test_migration_v4() {
+	let reason1 = BlakeTwo256::hash(b"reason1");
+	let hash1 = BlakeTwo256::hash_of(&(reason1, 10u64));
+
+	let tip = OpenTip::<u128, u64, u64, H256> {
+		reason: reason1,
+		who: 10,
+		finder: 20,
+		deposit: 30,
+		closes: Some(13),
+		tips: vec![(40, 50), (60, 70)],
+		finders_fee: true,
+	};
+
+	let data = vec![
+		(pallet_tips::Reasons::<Test>::hashed_key_for(hash1), reason1.encode().to_vec()),
+		(pallet_tips::Tips::<Test>::hashed_key_for(hash1), tip.encode().to_vec()),
+	];
+
+	let mut s = Storage::default();
+	s.top = data.into_iter().collect();
+
+	sp_io::TestExternalities::new(s).execute_with(|| {
+		use frame_support::traits::PalletInfoAccess;
+
+		let old_pallet = "Treasury";
+		let new_pallet = <Tips as PalletInfoAccess>::name();
+		frame_support::storage::migration::move_pallet(
+			new_pallet.as_bytes(),
+			old_pallet.as_bytes(),
+		);
+		StorageVersion::new(0).put::<Tips>();
+
+		crate::migrations::v4::pre_migrate::<Test, Tips, _>(old_pallet);
+		crate::migrations::v4::migrate::<Test, Tips, _>(old_pallet);
+		crate::migrations::v4::post_migrate::<Test, Tips, _>(old_pallet);
+	});
+
+	sp_io::TestExternalities::new(Storage::default()).execute_with(|| {
+		use frame_support::traits::PalletInfoAccess;
+
+		let old_pallet = "Treasury";
+		let new_pallet = <Tips as PalletInfoAccess>::name();
+		frame_support::storage::migration::move_pallet(
+			new_pallet.as_bytes(),
+			old_pallet.as_bytes(),
+		);
+		StorageVersion::new(0).put::<Tips>();
+
+		crate::migrations::v4::pre_migrate::<Test, Tips, _>(old_pallet);
+		crate::migrations::v4::migrate::<Test, Tips, _>(old_pallet);
+		crate::migrations::v4::post_migrate::<Test, Tips, _>(old_pallet);
+	});
+}
+
+#[test]
+fn genesis_funding_works() {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let initial_funding = 100;
+	pallet_balances::GenesisConfig::<Test> {
+		// Total issuance will be 200 with treasury account initialized with 100.
+		balances: vec![(0, 100), (Treasury::account_id(), initial_funding)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	pallet_treasury::GenesisConfig::<Test>::default()
+		.assimilate_storage(&mut t)
+		.unwrap();
+	let mut t: sp_io::TestExternalities = t.into();
+
+	t.execute_with(|| {
+		assert_eq!(Balances::free_balance(Treasury::account_id()), initial_funding);
+		assert_eq!(Treasury::pot(), initial_funding - Balances::minimum_balance());
+	});
+}
+
+#[test]
+fn report_awesome_and_tip_works_second_instance() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		Balances::make_free_balance_be(&Treasury1::account_id(), 201);
+		assert_eq!(Balances::free_balance(&Treasury::account_id()), 101);
+		assert_eq!(Balances::free_balance(&Treasury1::account_id()), 201);
+
+		assert_ok!(Tips1::report_awesome(RuntimeOrigin::signed(0), b"awesome.dot".to_vec(), 3));
+		// duplicate report in tips1 reports don't count.
+		assert_noop!(
+			Tips1::report_awesome(RuntimeOrigin::signed(1), b"awesome.dot".to_vec(), 3),
+			Error::<Test, Instance1>::AlreadyKnown
+		);
+		// but tips is separate
+		assert_ok!(Tips::report_awesome(RuntimeOrigin::signed(0), b"awesome.dot".to_vec(), 3));
+
+		let h = tip_hash();
+		assert_ok!(Tips1::tip(RuntimeOrigin::signed(10), h, 10));
+		assert_ok!(Tips1::tip(RuntimeOrigin::signed(11), h, 10));
+		assert_ok!(Tips1::tip(RuntimeOrigin::signed(12), h, 10));
+		assert_noop!(Tips1::tip(RuntimeOrigin::signed(9), h, 10), BadOrigin);
+
+		System::set_block_number(2);
+
+		assert_ok!(Tips1::close_tip(RuntimeOrigin::signed(100), h.into()));
+		// Treasury 1 unchanged
+		assert_eq!(Balances::free_balance(&Treasury::account_id()), 101);
+		// Treasury 2 gave the funds
+		assert_eq!(Balances::free_balance(&Treasury1::account_id()), 191);
+	});
+}
diff --git a/substrate/frame/tips/src/weights.rs b/substrate/frame/tips/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec6228667159ddbdbfecd12ccb5ff6250390829a
--- /dev/null
+++ b/substrate/frame/tips/src/weights.rs
@@ -0,0 +1,280 @@
+// 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.
+
+//! Autogenerated weights for pallet_tips
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_tips
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/tips/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_tips.
+pub trait WeightInfo {
+	fn report_awesome(r: u32, ) -> Weight;
+	fn retract_tip() -> Weight;
+	fn tip_new(r: u32, t: u32, ) -> Weight;
+	fn tip(t: u32, ) -> Weight;
+	fn close_tip(t: u32, ) -> Weight;
+	fn slash_tip(t: u32, ) -> Weight;
+}
+
+/// Weights for pallet_tips using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Tips Reasons (r:1 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `r` is `[0, 300]`.
+	fn report_awesome(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4`
+		//  Estimated: `3469`
+		// Minimum execution time: 29_576_000 picoseconds.
+		Weight::from_parts(30_722_650, 3469)
+			// Standard Error: 192
+			.saturating_add(Weight::from_parts(2_601, 0).saturating_mul(r.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Reasons (r:0 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	fn retract_tip() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `221`
+		//  Estimated: `3686`
+		// Minimum execution time: 28_522_000 picoseconds.
+		Weight::from_parts(29_323_000, 3686)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Tips Reasons (r:1 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Tips (r:0 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `r` is `[0, 300]`.
+	/// The range of component `t` is `[1, 13]`.
+	fn tip_new(r: u32, t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `526 + t * (64 ±0)`
+		//  Estimated: `3991 + t * (64 ±0)`
+		// Minimum execution time: 19_650_000 picoseconds.
+		Weight::from_parts(19_837_982, 3991)
+			// Standard Error: 151
+			.saturating_add(Weight::from_parts(1_746, 0).saturating_mul(r.into()))
+			// Standard Error: 3_588
+			.saturating_add(Weight::from_parts(102_359, 0).saturating_mul(t.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(t.into()))
+	}
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `t` is `[1, 13]`.
+	fn tip(t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `747 + t * (112 ±0)`
+		//  Estimated: `4212 + t * (112 ±0)`
+		// Minimum execution time: 15_641_000 picoseconds.
+		Weight::from_parts(15_745_460, 4212)
+			// Standard Error: 5_106
+			.saturating_add(Weight::from_parts(229_475, 0).saturating_mul(t.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 112).saturating_mul(t.into()))
+	}
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Tips Reasons (r:0 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `t` is `[1, 13]`.
+	fn close_tip(t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `786 + t * (112 ±0)`
+		//  Estimated: `4242 + t * (112 ±0)`
+		// Minimum execution time: 62_059_000 picoseconds.
+		Weight::from_parts(64_604_554, 4242)
+			// Standard Error: 11_818
+			.saturating_add(Weight::from_parts(116_297, 0).saturating_mul(t.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 112).saturating_mul(t.into()))
+	}
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Reasons (r:0 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `t` is `[1, 13]`.
+	fn slash_tip(t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `269`
+		//  Estimated: `3734`
+		// Minimum execution time: 14_133_000 picoseconds.
+		Weight::from_parts(14_957_547, 3734)
+			// Standard Error: 2_765
+			.saturating_add(Weight::from_parts(22_138, 0).saturating_mul(t.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Tips Reasons (r:1 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `r` is `[0, 300]`.
+	fn report_awesome(r: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `4`
+		//  Estimated: `3469`
+		// Minimum execution time: 29_576_000 picoseconds.
+		Weight::from_parts(30_722_650, 3469)
+			// Standard Error: 192
+			.saturating_add(Weight::from_parts(2_601, 0).saturating_mul(r.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Reasons (r:0 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	fn retract_tip() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `221`
+		//  Estimated: `3686`
+		// Minimum execution time: 28_522_000 picoseconds.
+		Weight::from_parts(29_323_000, 3686)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Tips Reasons (r:1 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Tips (r:0 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `r` is `[0, 300]`.
+	/// The range of component `t` is `[1, 13]`.
+	fn tip_new(r: u32, t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `526 + t * (64 ±0)`
+		//  Estimated: `3991 + t * (64 ±0)`
+		// Minimum execution time: 19_650_000 picoseconds.
+		Weight::from_parts(19_837_982, 3991)
+			// Standard Error: 151
+			.saturating_add(Weight::from_parts(1_746, 0).saturating_mul(r.into()))
+			// Standard Error: 3_588
+			.saturating_add(Weight::from_parts(102_359, 0).saturating_mul(t.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+			.saturating_add(Weight::from_parts(0, 64).saturating_mul(t.into()))
+	}
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `t` is `[1, 13]`.
+	fn tip(t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `747 + t * (112 ±0)`
+		//  Estimated: `4212 + t * (112 ±0)`
+		// Minimum execution time: 15_641_000 picoseconds.
+		Weight::from_parts(15_745_460, 4212)
+			// Standard Error: 5_106
+			.saturating_add(Weight::from_parts(229_475, 0).saturating_mul(t.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(Weight::from_parts(0, 112).saturating_mul(t.into()))
+	}
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Elections Members (r:1 w:0)
+	/// Proof Skipped: Elections Members (max_values: Some(1), max_size: None, mode: Measured)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Tips Reasons (r:0 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `t` is `[1, 13]`.
+	fn close_tip(t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `786 + t * (112 ±0)`
+		//  Estimated: `4242 + t * (112 ±0)`
+		// Minimum execution time: 62_059_000 picoseconds.
+		Weight::from_parts(64_604_554, 4242)
+			// Standard Error: 11_818
+			.saturating_add(Weight::from_parts(116_297, 0).saturating_mul(t.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 112).saturating_mul(t.into()))
+	}
+	/// Storage: Tips Tips (r:1 w:1)
+	/// Proof Skipped: Tips Tips (max_values: None, max_size: None, mode: Measured)
+	/// Storage: Tips Reasons (r:0 w:1)
+	/// Proof Skipped: Tips Reasons (max_values: None, max_size: None, mode: Measured)
+	/// The range of component `t` is `[1, 13]`.
+	fn slash_tip(t: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `269`
+		//  Estimated: `3734`
+		// Minimum execution time: 14_133_000 picoseconds.
+		Weight::from_parts(14_957_547, 3734)
+			// Standard Error: 2_765
+			.saturating_add(Weight::from_parts(22_138, 0).saturating_mul(t.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/frame/transaction-payment/Cargo.toml b/substrate/frame/transaction-payment/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8d4c0e55f798a7a610cbc4132c109663f2d8af4b
--- /dev/null
+++ b/substrate/frame/transaction-payment/Cargo.toml
@@ -0,0 +1,51 @@
+[package]
+name = "pallet-transaction-payment"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to manage transaction payments"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+serde_json = "1.0.85"
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/transaction-payment/README.md b/substrate/frame/transaction-payment/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..bf114246e60fa67bf008ac8e7a2b29a3f2e07d81
--- /dev/null
+++ b/substrate/frame/transaction-payment/README.md
@@ -0,0 +1,16 @@
+# Transaction Payment Pallet
+
+This pallet provides the basic logic needed to pay the absolute minimum amount needed for a
+transaction to be included. This includes:
+  - _weight fee_: A fee proportional to amount of weight a transaction consumes.
+  - _length fee_: A fee proportional to the encoded length of the transaction.
+  - _tip_: An optional tip. Tip increases the priority of the transaction, giving it a higher
+    chance to be included by the transaction queue.
+
+Additionally, this pallet allows one to configure:
+  - The mapping between one unit of weight to one unit of fee via [`Config::WeightToFee`].
+  - A means of updating the fee for the next block, via defining a multiplier, based on the
+    final state of the chain at the end of the previous block. This can be configured via
+    [`Config::FeeMultiplierUpdate`]
+
+License: Apache-2.0
diff --git a/substrate/frame/transaction-payment/asset-conversion-tx-payment/Cargo.toml b/substrate/frame/transaction-payment/asset-conversion-tx-payment/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..51ff136d8ae14c24d74b960b15b53e520b04f30a
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-conversion-tx-payment/Cargo.toml
@@ -0,0 +1,58 @@
+[package]
+name = "pallet-asset-conversion-tx-payment"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Pallet to manage transaction payments in assets by converting them to native assets."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+# Substrate dependencies
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+pallet-asset-conversion = { version = "4.0.0-dev", default-features = false, path = "../../asset-conversion" }
+pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, path = ".." }
+codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-storage = { version = "13.0.0", default-features = false, path = "../../../primitives/storage" }
+pallet-assets = { version = "4.0.0-dev", path = "../../assets" }
+pallet-balances = { version = "4.0.0-dev", path = "../../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-asset-conversion/std",
+	"pallet-assets/std",
+	"pallet-balances/std",
+	"pallet-transaction-payment/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-storage/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-asset-conversion/try-runtime",
+	"pallet-assets/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-transaction-payment/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/transaction-payment/asset-conversion-tx-payment/README.md b/substrate/frame/transaction-payment/asset-conversion-tx-payment/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..eccba773673e690a6d415a4c61d267ba75a1c12e
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-conversion-tx-payment/README.md
@@ -0,0 +1,21 @@
+# pallet-asset-conversion-tx-payment
+
+## Asset Conversion Transaction Payment Pallet
+
+This pallet allows runtimes that include it to pay for transactions in assets other than the
+native token of the chain.
+
+### Overview
+It does this by extending transactions to include an optional `AssetId` that specifies the asset
+to be used for payment (defaulting to the native token on `None`). It expects an
+[`OnChargeAssetTransaction`] implementation analogously to [`pallet-transaction-payment`]. The
+included [`AssetConversionAdapter`] (implementing [`OnChargeAssetTransaction`]) determines the fee
+amount by converting the fee calculated by [`pallet-transaction-payment`] into the desired
+asset.
+
+### Integration
+This pallet wraps FRAME's transaction payment pallet and functions as a replacement. This means
+you should include both pallets in your `construct_runtime` macro, but only include this
+pallet's [`SignedExtension`] ([`ChargeAssetTxPayment`]).
+
+License: Apache-2.0
diff --git a/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/lib.rs b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c2d9ed56c7aa38867cbd988eb1fe1a486233d420
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/lib.rs
@@ -0,0 +1,349 @@
+// 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.
+
+//! # Asset Conversion Transaction Payment Pallet
+//!
+//! This pallet allows runtimes that include it to pay for transactions in assets other than the
+//! chain's native asset.
+//!
+//! ## Overview
+//!
+//! This pallet provides a `SignedExtension` with an optional `AssetId` that specifies the asset
+//! to be used for payment (defaulting to the native token on `None`). It expects an
+//! [`OnChargeAssetTransaction`] implementation analogous to [`pallet-transaction-payment`]. The
+//! included [`AssetConversionAdapter`] (implementing [`OnChargeAssetTransaction`]) determines the
+//! fee amount by converting the fee calculated by [`pallet-transaction-payment`] in the native
+//! asset into the amount required of the specified asset.
+//!
+//! ## Pallet API
+//!
+//! This pallet does not have any dispatchable calls or storage. It wraps FRAME's Transaction
+//! Payment pallet and functions as a replacement. This means you should include both pallets in
+//! your `construct_runtime` macro, but only include this pallet's [`SignedExtension`]
+//! ([`ChargeAssetTxPayment`]).
+//!
+//! ## Terminology
+//!
+//! - Native Asset or Native Currency: The asset that a chain considers native, as in its default
+//!   for transaction fee payment, deposits, inflation, etc.
+//! - Other assets: Other assets that may exist on chain, for example under the Assets pallet.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_std::prelude::*;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{DispatchInfo, DispatchResult, PostDispatchInfo},
+	traits::{
+		tokens::fungibles::{Balanced, Inspect},
+		IsType,
+	},
+	DefaultNoBound,
+};
+use pallet_transaction_payment::OnChargeTransaction;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension, Zero},
+	transaction_validity::{
+		InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+	},
+};
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+mod payment;
+use frame_support::traits::tokens::AssetId;
+use pallet_asset_conversion::MultiAssetIdConverter;
+pub use payment::*;
+
+/// Type aliases used for interaction with `OnChargeTransaction`.
+pub(crate) type OnChargeTransactionOf<T> =
+	<T as pallet_transaction_payment::Config>::OnChargeTransaction;
+/// Balance type alias for balances of the chain's native asset.
+pub(crate) type BalanceOf<T> = <OnChargeTransactionOf<T> as OnChargeTransaction<T>>::Balance;
+/// Liquidity info type alias.
+pub(crate) type LiquidityInfoOf<T> =
+	<OnChargeTransactionOf<T> as OnChargeTransaction<T>>::LiquidityInfo;
+
+/// Balance type alias for balances of assets that implement the `fungibles` trait.
+pub(crate) type AssetBalanceOf<T> =
+	<<T as Config>::Fungibles as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
+/// Type alias for Asset IDs.
+pub(crate) type AssetIdOf<T> =
+	<<T as Config>::Fungibles as Inspect<<T as frame_system::Config>::AccountId>>::AssetId;
+
+/// Type alias for the interaction of balances with `OnChargeAssetTransaction`.
+pub(crate) type ChargeAssetBalanceOf<T> =
+	<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::Balance;
+/// Type alias for Asset IDs in their interaction with `OnChargeAssetTransaction`.
+pub(crate) type ChargeAssetIdOf<T> =
+	<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::AssetId;
+/// Liquidity info type alias for interaction with `OnChargeAssetTransaction`.
+pub(crate) type ChargeAssetLiquidityOf<T> =
+	<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::LiquidityInfo;
+
+/// Used to pass the initial payment info from pre- to post-dispatch.
+#[derive(Encode, Decode, DefaultNoBound, TypeInfo)]
+pub enum InitialPayment<T: Config> {
+	/// No initial fee was paid.
+	#[default]
+	Nothing,
+	/// The initial fee was paid in the native currency.
+	Native(LiquidityInfoOf<T>),
+	/// The initial fee was paid in an asset.
+	Asset((LiquidityInfoOf<T>, BalanceOf<T>, AssetBalanceOf<T>)),
+}
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config:
+		frame_system::Config + pallet_transaction_payment::Config + pallet_asset_conversion::Config
+	{
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// The fungibles instance used to pay for transactions in assets.
+		type Fungibles: Balanced<Self::AccountId>;
+		/// The actual transaction charging logic that charges the fees.
+		type OnChargeAssetTransaction: OnChargeAssetTransaction<Self>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+		/// has been paid by `who` in an asset `asset_id`.
+		AssetTxFeePaid {
+			who: T::AccountId,
+			actual_fee: AssetBalanceOf<T>,
+			tip: BalanceOf<T>,
+			asset_id: ChargeAssetIdOf<T>,
+		},
+		/// A swap of the refund in native currency back to asset failed.
+		AssetRefundFailed { native_amount_kept: BalanceOf<T> },
+	}
+}
+
+/// Require payment for transaction inclusion and optionally include a tip to gain additional
+/// priority in the queue. Allows paying via both `Currency` as well as `fungibles::Balanced`.
+///
+/// Wraps the transaction logic in [`pallet_transaction_payment`] and extends it with assets.
+/// An asset ID of `None` falls back to the underlying transaction payment logic via the native
+/// currency.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct ChargeAssetTxPayment<T: Config> {
+	#[codec(compact)]
+	tip: BalanceOf<T>,
+	asset_id: Option<ChargeAssetIdOf<T>>,
+}
+
+impl<T: Config> ChargeAssetTxPayment<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	AssetBalanceOf<T>: Send + Sync,
+	BalanceOf<T>: Send + Sync + Into<ChargeAssetBalanceOf<T>> + From<ChargeAssetLiquidityOf<T>>,
+	ChargeAssetIdOf<T>: Send + Sync,
+{
+	/// Utility constructor. Used only in client/factory code.
+	pub fn from(tip: BalanceOf<T>, asset_id: Option<ChargeAssetIdOf<T>>) -> Self {
+		Self { tip, asset_id }
+	}
+
+	/// Fee withdrawal logic that dispatches to either `OnChargeAssetTransaction` or
+	/// `OnChargeTransaction`.
+	fn withdraw_fee(
+		&self,
+		who: &T::AccountId,
+		call: &T::RuntimeCall,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		len: usize,
+	) -> Result<(BalanceOf<T>, InitialPayment<T>), TransactionValidityError> {
+		let fee = pallet_transaction_payment::Pallet::<T>::compute_fee(len as u32, info, self.tip);
+		debug_assert!(self.tip <= fee, "tip should be included in the computed fee");
+		if fee.is_zero() {
+			Ok((fee, InitialPayment::Nothing))
+		} else if let Some(asset_id) = &self.asset_id {
+			T::OnChargeAssetTransaction::withdraw_fee(
+				who,
+				call,
+				info,
+				asset_id.clone(),
+				fee.into(),
+				self.tip.into(),
+			)
+			.map(|(used_for_fee, received_exchanged, asset_consumed)| {
+				(
+					fee,
+					InitialPayment::Asset((
+						used_for_fee.into(),
+						received_exchanged.into(),
+						asset_consumed.into(),
+					)),
+				)
+			})
+		} else {
+			<OnChargeTransactionOf<T> as OnChargeTransaction<T>>::withdraw_fee(
+				who, call, info, fee, self.tip,
+			)
+			.map(|i| (fee, InitialPayment::Native(i)))
+			.map_err(|_| -> TransactionValidityError { InvalidTransaction::Payment.into() })
+		}
+	}
+}
+
+impl<T: Config> sp_std::fmt::Debug for ChargeAssetTxPayment<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "ChargeAssetTxPayment<{:?}, {:?}>", self.tip, self.asset_id.encode())
+	}
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config> SignedExtension for ChargeAssetTxPayment<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	AssetBalanceOf<T>: Send + Sync,
+	BalanceOf<T>: Send
+		+ Sync
+		+ From<u64>
+		+ Into<ChargeAssetBalanceOf<T>>
+		+ Into<ChargeAssetLiquidityOf<T>>
+		+ From<ChargeAssetLiquidityOf<T>>,
+	ChargeAssetIdOf<T>: Send + Sync,
+{
+	const IDENTIFIER: &'static str = "ChargeAssetTxPayment";
+	type AccountId = T::AccountId;
+	type Call = T::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = (
+		// tip
+		BalanceOf<T>,
+		// who paid the fee
+		Self::AccountId,
+		// imbalance resulting from withdrawing the fee
+		InitialPayment<T>,
+		// asset_id for the transaction payment
+		Option<ChargeAssetIdOf<T>>,
+	);
+
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		use pallet_transaction_payment::ChargeTransactionPayment;
+		let (fee, _) = self.withdraw_fee(who, call, info, len)?;
+		let priority = ChargeTransactionPayment::<T>::get_priority(info, len, self.tip, fee);
+		Ok(ValidTransaction { priority, ..Default::default() })
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		let (_fee, initial_payment) = self.withdraw_fee(who, call, info, len)?;
+		Ok((self.tip, who.clone(), initial_payment, self.asset_id))
+	}
+
+	fn post_dispatch(
+		pre: Option<Self::Pre>,
+		info: &DispatchInfoOf<Self::Call>,
+		post_info: &PostDispatchInfoOf<Self::Call>,
+		len: usize,
+		result: &DispatchResult,
+	) -> Result<(), TransactionValidityError> {
+		if let Some((tip, who, initial_payment, asset_id)) = pre {
+			match initial_payment {
+				InitialPayment::Native(already_withdrawn) => {
+					debug_assert!(
+						asset_id.is_none(),
+						"For that payment type the `asset_id` should be None"
+					);
+					pallet_transaction_payment::ChargeTransactionPayment::<T>::post_dispatch(
+						Some((tip, who, already_withdrawn)),
+						info,
+						post_info,
+						len,
+						result,
+					)?;
+				},
+				InitialPayment::Asset(already_withdrawn) => {
+					debug_assert!(
+						asset_id.is_some(),
+						"For that payment type the `asset_id` should be set"
+					);
+					let actual_fee = pallet_transaction_payment::Pallet::<T>::compute_actual_fee(
+						len as u32, info, post_info, tip,
+					);
+
+					if let Some(asset_id) = asset_id {
+						let (used_for_fee, received_exchanged, asset_consumed) = already_withdrawn;
+						let converted_fee = T::OnChargeAssetTransaction::correct_and_deposit_fee(
+							&who,
+							info,
+							post_info,
+							actual_fee.into(),
+							tip.into(),
+							used_for_fee.into(),
+							received_exchanged.into(),
+							asset_id.clone(),
+							asset_consumed.into(),
+						)?;
+
+						Pallet::<T>::deposit_event(Event::<T>::AssetTxFeePaid {
+							who,
+							actual_fee: converted_fee,
+							tip,
+							asset_id,
+						});
+					}
+				},
+				InitialPayment::Nothing => {
+					// `actual_fee` should be zero here for any signed extrinsic. It would be
+					// non-zero here in case of unsigned extrinsics as they don't pay fees but
+					// `compute_actual_fee` is not aware of them. In both cases it's fine to just
+					// move ahead without adjusting the fee, though, so we do nothing.
+					debug_assert!(tip.is_zero(), "tip should be zero if initial fee was zero.");
+				},
+			}
+		}
+
+		Ok(())
+	}
+}
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
new file mode 100644
index 0000000000000000000000000000000000000000..bfbe8b4178cee217c65de1f86f980754a12402f0
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/mock.rs
@@ -0,0 +1,268 @@
+// 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 crate as pallet_asset_conversion_tx_payment;
+
+use codec;
+use frame_support::{
+	dispatch::DispatchClass,
+	instances::Instance2,
+	ord_parameter_types,
+	pallet_prelude::*,
+	parameter_types,
+	traits::{AsEnsureOriginWithArg, ConstU32, ConstU64, ConstU8, Imbalance, OnUnbalanced},
+	weights::{Weight, WeightToFee as WeightToFeeT},
+	PalletId,
+};
+use frame_system as system;
+use frame_system::{EnsureRoot, EnsureSignedBy};
+use pallet_asset_conversion::{NativeOrAssetId, NativeOrAssetIdConverter};
+use pallet_transaction_payment::CurrencyAdapter;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{AccountIdConversion, BlakeTwo256, IdentityLookup, SaturatedConversion},
+	Permill,
+};
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+type Balance = u64;
+type AccountId = u64;
+
+frame_support::construct_runtime!(
+	pub enum Runtime
+	{
+		System: system,
+		Balances: pallet_balances,
+		TransactionPayment: pallet_transaction_payment,
+		Assets: pallet_assets,
+		PoolAssets: pallet_assets::<Instance2>,
+		AssetConversion: pallet_asset_conversion,
+		AssetTxPayment: pallet_asset_conversion_tx_payment,
+	}
+);
+
+parameter_types! {
+	pub(crate) static ExtrinsicBaseWeight: Weight = Weight::zero();
+}
+
+pub struct BlockWeights;
+impl Get<frame_system::limits::BlockWeights> for BlockWeights {
+	fn get() -> frame_system::limits::BlockWeights {
+		frame_system::limits::BlockWeights::builder()
+			.base_block(Weight::zero())
+			.for_class(DispatchClass::all(), |weights| {
+				weights.base_extrinsic = ExtrinsicBaseWeight::get().into();
+			})
+			.for_class(DispatchClass::non_mandatory(), |weights| {
+				weights.max_total = Weight::from_parts(1024, u64::MAX).into();
+			})
+			.build_or_panic()
+	}
+}
+
+parameter_types! {
+	pub static WeightToFee: u64 = 1;
+	pub static TransactionByteFee: u64 = 1;
+}
+
+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;
+}
+
+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 MaxHolds = ();
+}
+
+impl WeightToFeeT for WeightToFee {
+	type Balance = u64;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time())
+			.saturating_mul(WEIGHT_TO_FEE.with(|v| *v.borrow()))
+	}
+}
+
+impl WeightToFeeT for TransactionByteFee {
+	type Balance = u64;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time())
+			.saturating_mul(TRANSACTION_BYTE_FEE.with(|v| *v.borrow()))
+	}
+}
+
+parameter_types! {
+	pub(crate) static TipUnbalancedAmount: u64 = 0;
+	pub(crate) static FeeUnbalancedAmount: u64 = 0;
+}
+
+pub struct DealWithFees;
+impl OnUnbalanced<pallet_balances::NegativeImbalance<Runtime>> for DealWithFees {
+	fn on_unbalanceds<B>(
+		mut fees_then_tips: impl Iterator<Item = pallet_balances::NegativeImbalance<Runtime>>,
+	) {
+		if let Some(fees) = fees_then_tips.next() {
+			FeeUnbalancedAmount::mutate(|a| *a += fees.peek());
+			if let Some(tips) = fees_then_tips.next() {
+				TipUnbalancedAmount::mutate(|a| *a += tips.peek());
+			}
+		}
+	}
+}
+
+impl pallet_transaction_payment::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type OnChargeTransaction = CurrencyAdapter<Balances, DealWithFees>;
+	type WeightToFee = WeightToFee;
+	type LengthToFee = TransactionByteFee;
+	type FeeMultiplierUpdate = ();
+	type OperationalFeeMultiplier = ConstU8<5>;
+}
+
+type AssetId = u32;
+
+impl pallet_assets::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = Balance;
+	type AssetId = AssetId;
+	type AssetIdParameter = codec::Compact<AssetId>;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<AccountId>>;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type AssetDeposit = ConstU64<2>;
+	type AssetAccountDeposit = ConstU64<2>;
+	type MetadataDepositBase = ConstU64<0>;
+	type MetadataDepositPerByte = ConstU64<0>;
+	type ApprovalDeposit = ConstU64<0>;
+	type StringLimit = ConstU32<20>;
+	type Freezer = ();
+	type Extra = ();
+	type CallbackHandle = ();
+	type WeightInfo = ();
+	type RemoveItemsLimit = ConstU32<1000>;
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+impl pallet_assets::Config<Instance2> for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u64;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSignedBy<AssetConversionOrigin, u64>>;
+	type ForceOrigin = frame_system::EnsureRoot<u64>;
+	type AssetDeposit = ConstU64<0>;
+	type AssetAccountDeposit = ConstU64<0>;
+	type MetadataDepositBase = ConstU64<0>;
+	type MetadataDepositPerByte = ConstU64<0>;
+	type ApprovalDeposit = ConstU64<0>;
+	type StringLimit = ConstU32<50>;
+	type Freezer = ();
+	type Extra = ();
+	type WeightInfo = ();
+	type CallbackHandle = ();
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+parameter_types! {
+	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
+	pub storage AllowMultiAssetPools: bool = false;
+	// should be non-zero if AllowMultiAssetPools is true, otherwise can be zero
+	pub storage LiquidityWithdrawalFee: Permill = Permill::from_percent(0);
+	pub const MaxSwapPathLength: u32 = 4;
+}
+
+ord_parameter_types! {
+	pub const AssetConversionOrigin: u64 = AccountIdConversion::<u64>::into_account_truncating(&AssetConversionPalletId::get());
+}
+
+impl pallet_asset_conversion::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type AssetBalance = <Self as pallet_balances::Config>::Balance;
+	type AssetId = u32;
+	type PoolAssetId = u32;
+	type Assets = Assets;
+	type PoolAssets = PoolAssets;
+	type PalletId = AssetConversionPalletId;
+	type WeightInfo = ();
+	type LPFee = ConstU32<3>; // means 0.3%
+	type PoolSetupFee = ConstU64<100>; // should be more or equal to the existential deposit
+	type PoolSetupFeeReceiver = AssetConversionOrigin;
+	type LiquidityWithdrawalFee = LiquidityWithdrawalFee;
+	type AllowMultiAssetPools = AllowMultiAssetPools;
+	type MaxSwapPathLength = MaxSwapPathLength;
+	type MintMinLiquidity = ConstU64<100>; // 100 is good enough when the main currency has 12 decimals.
+
+	type Balance = u64;
+	type HigherPrecisionBalance = u128;
+
+	type MultiAssetId = NativeOrAssetId<u32>;
+	type MultiAssetIdConverter = NativeOrAssetIdConverter<u32>;
+
+	pallet_asset_conversion::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+impl Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Fungibles = Assets;
+	type OnChargeAssetTransaction = AssetConversionAdapter<Balances, AssetConversion>;
+}
diff --git a/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/payment.rs b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/payment.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d090211d035218b3bdea39fc31a58d9f7b68744
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/payment.rs
@@ -0,0 +1,202 @@
+// 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.
+
+///! Traits and default implementation for paying transaction fees in assets.
+use super::*;
+use crate::Config;
+
+use frame_support::{
+	ensure,
+	traits::{fungible::Inspect, tokens::Balance},
+	unsigned::TransactionValidityError,
+};
+use pallet_asset_conversion::Swap;
+use sp_runtime::{
+	traits::{DispatchInfoOf, PostDispatchInfoOf, Zero},
+	transaction_validity::InvalidTransaction,
+	Saturating,
+};
+use sp_std::marker::PhantomData;
+
+/// Handle withdrawing, refunding and depositing of transaction fees.
+pub trait OnChargeAssetTransaction<T: Config> {
+	/// The underlying integer type in which fees are calculated.
+	type Balance: Balance;
+	/// The type used to identify the assets used for transaction payment.
+	type AssetId: AssetId;
+	/// The type used to store the intermediate values between pre- and post-dispatch.
+	type LiquidityInfo;
+
+	/// Secure the payment of the transaction fees before the transaction is executed.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	fn withdraw_fee(
+		who: &T::AccountId,
+		call: &T::RuntimeCall,
+		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		asset_id: Self::AssetId,
+		fee: Self::Balance,
+		tip: Self::Balance,
+	) -> Result<
+		(LiquidityInfoOf<T>, Self::LiquidityInfo, AssetBalanceOf<T>),
+		TransactionValidityError,
+	>;
+
+	/// Refund any overpaid fees and deposit the corrected amount.
+	/// The actual fee gets calculated once the transaction is executed.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	///
+	/// Returns the fee and tip in the asset used for payment as (fee, tip).
+	fn correct_and_deposit_fee(
+		who: &T::AccountId,
+		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		corrected_fee: Self::Balance,
+		tip: Self::Balance,
+		fee_paid: LiquidityInfoOf<T>,
+		received_exchanged: Self::LiquidityInfo,
+		asset_id: Self::AssetId,
+		initial_asset_consumed: AssetBalanceOf<T>,
+	) -> Result<AssetBalanceOf<T>, TransactionValidityError>;
+}
+
+/// Implements the asset transaction for a balance to asset converter (implementing [`Swap`]).
+///
+/// The converter is given the complete fee in terms of the asset used for the transaction.
+pub struct AssetConversionAdapter<C, CON>(PhantomData<(C, CON)>);
+
+/// Default implementation for a runtime instantiating this pallet, an asset to native swapper.
+impl<T, C, CON> OnChargeAssetTransaction<T> for AssetConversionAdapter<C, CON>
+where
+	T: Config,
+	C: Inspect<<T as frame_system::Config>::AccountId>,
+	CON: Swap<T::AccountId, T::HigherPrecisionBalance, T::MultiAssetId>,
+	T::HigherPrecisionBalance: From<BalanceOf<T>> + TryInto<AssetBalanceOf<T>>,
+	T::MultiAssetId: From<AssetIdOf<T>>,
+	BalanceOf<T>: IsType<<C as Inspect<<T as frame_system::Config>::AccountId>>::Balance>,
+{
+	type Balance = BalanceOf<T>;
+	type AssetId = AssetIdOf<T>;
+	type LiquidityInfo = BalanceOf<T>;
+
+	/// Swap & withdraw the predicted fee from the transaction origin.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	///
+	/// Returns the total amount in native currency received by exchanging the `asset_id` and the
+	/// amount in native currency used to pay the fee.
+	fn withdraw_fee(
+		who: &T::AccountId,
+		call: &T::RuntimeCall,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		asset_id: Self::AssetId,
+		fee: BalanceOf<T>,
+		tip: BalanceOf<T>,
+	) -> Result<
+		(LiquidityInfoOf<T>, Self::LiquidityInfo, AssetBalanceOf<T>),
+		TransactionValidityError,
+	> {
+		// convert the asset into native currency
+		let ed = C::minimum_balance();
+		let native_asset_required =
+			if C::balance(&who) >= ed.saturating_add(fee.into()) { fee } else { fee + ed.into() };
+
+		let asset_consumed = CON::swap_tokens_for_exact_tokens(
+			who.clone(),
+			vec![asset_id.into(), T::MultiAssetIdConverter::get_native()],
+			T::HigherPrecisionBalance::from(native_asset_required),
+			None,
+			who.clone(),
+			true,
+		)
+		.map_err(|_| TransactionValidityError::from(InvalidTransaction::Payment))?;
+
+		let asset_consumed = asset_consumed
+			.try_into()
+			.map_err(|_| TransactionValidityError::from(InvalidTransaction::Payment))?;
+
+		ensure!(asset_consumed > Zero::zero(), InvalidTransaction::Payment);
+
+		// charge the fee in native currency
+		<T::OnChargeTransaction>::withdraw_fee(who, call, info, fee, tip)
+			.map(|r| (r, native_asset_required, asset_consumed))
+	}
+
+	/// Correct the fee and swap the refund back to asset.
+	///
+	/// Note: The `corrected_fee` already includes the `tip`.
+	/// Note: Is the ED wasn't needed, the `received_exchanged` will be equal to `fee_paid`, or
+	/// `fee_paid + ed` otherwise.
+	fn correct_and_deposit_fee(
+		who: &T::AccountId,
+		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		corrected_fee: BalanceOf<T>,
+		tip: BalanceOf<T>,
+		fee_paid: LiquidityInfoOf<T>,
+		received_exchanged: Self::LiquidityInfo,
+		asset_id: Self::AssetId,
+		initial_asset_consumed: AssetBalanceOf<T>,
+	) -> Result<AssetBalanceOf<T>, TransactionValidityError> {
+		// Refund the native asset to the account that paid the fees (`who`).
+		// The `who` account will receive the "fee_paid - corrected_fee" refund.
+		<T::OnChargeTransaction>::correct_and_deposit_fee(
+			who,
+			dispatch_info,
+			post_info,
+			corrected_fee,
+			tip,
+			fee_paid,
+		)?;
+
+		// calculate the refund in native asset, to swap back to the desired `asset_id`
+		let swap_back = received_exchanged.saturating_sub(corrected_fee);
+		let mut asset_refund = Zero::zero();
+		if !swap_back.is_zero() {
+			// If this fails, the account might have dropped below the existential balance or there
+			// is not enough liquidity left in the pool. In that case we don't throw an error and
+			// the account will keep the native currency.
+			match CON::swap_exact_tokens_for_tokens(
+				who.clone(), // we already deposited the native to `who`
+				vec![
+					T::MultiAssetIdConverter::get_native(), // we provide the native
+					asset_id.into(),                        // we want asset_id back
+				],
+				T::HigherPrecisionBalance::from(swap_back), /* amount of the native asset to
+				                                             * convert to `asset_id` */
+				None,        // no minimum amount back
+				who.clone(), // we will refund to `who`
+				false,       // no need to keep alive
+			)
+			.ok()
+			{
+				Some(acquired) => {
+					asset_refund = acquired
+						.try_into()
+						.map_err(|_| TransactionValidityError::from(InvalidTransaction::Payment))?;
+				},
+				None => {
+					Pallet::<T>::deposit_event(Event::<T>::AssetRefundFailed {
+						native_amount_kept: swap_back,
+					});
+				},
+			}
+		}
+
+		let actual_paid = initial_asset_consumed.saturating_sub(asset_refund);
+		Ok(actual_paid)
+	}
+}
diff --git a/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/tests.rs b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9e9b74a0ddb2e598863565bc2c8906825b7f5acb
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-conversion-tx-payment/src/tests.rs
@@ -0,0 +1,708 @@
+// 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::{
+	assert_ok,
+	dispatch::{DispatchInfo, PostDispatchInfo},
+	pallet_prelude::*,
+	traits::{fungible::Inspect, fungibles::Mutate},
+	weights::Weight,
+};
+use frame_system as system;
+use mock::{ExtrinsicBaseWeight, *};
+use pallet_asset_conversion::NativeOrAssetId;
+use pallet_balances::Call as BalancesCall;
+use sp_runtime::{traits::StaticLookup, BuildStorage};
+
+const CALL: &<Runtime as frame_system::Config>::RuntimeCall =
+	&RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
+
+pub struct ExtBuilder {
+	balance_factor: u64,
+	base_weight: Weight,
+	byte_fee: u64,
+	weight_to_fee: u64,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			balance_factor: 1,
+			base_weight: Weight::from_parts(0, 0),
+			byte_fee: 1,
+			weight_to_fee: 1,
+		}
+	}
+}
+
+impl ExtBuilder {
+	pub fn base_weight(mut self, base_weight: Weight) -> Self {
+		self.base_weight = base_weight;
+		self
+	}
+	pub fn balance_factor(mut self, factor: u64) -> Self {
+		self.balance_factor = factor;
+		self
+	}
+	fn set_constants(&self) {
+		ExtrinsicBaseWeight::mutate(|v| *v = self.base_weight);
+		TRANSACTION_BYTE_FEE.with(|v| *v.borrow_mut() = self.byte_fee);
+		WEIGHT_TO_FEE.with(|v| *v.borrow_mut() = self.weight_to_fee);
+	}
+	pub fn build(self) -> sp_io::TestExternalities {
+		self.set_constants();
+		let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Runtime> {
+			balances: if self.balance_factor > 0 {
+				vec![
+					(1, 10 * self.balance_factor),
+					(2, 20 * self.balance_factor),
+					(3, 30 * self.balance_factor),
+					(4, 40 * self.balance_factor),
+					(5, 50 * self.balance_factor),
+					(6, 60 * self.balance_factor),
+				]
+			} else {
+				vec![]
+			},
+		}
+		.assimilate_storage(&mut t)
+		.unwrap();
+		t.into()
+	}
+}
+
+/// create a transaction info struct from weight. Handy to avoid building the whole struct.
+pub fn info_from_weight(w: Weight) -> DispatchInfo {
+	// pays_fee: Pays::Yes -- class: DispatchClass::Normal
+	DispatchInfo { weight: w, ..Default::default() }
+}
+
+fn post_info_from_weight(w: Weight) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: Some(w), pays_fee: Default::default() }
+}
+
+fn info_from_pays(p: Pays) -> DispatchInfo {
+	DispatchInfo { pays_fee: p, ..Default::default() }
+}
+
+fn post_info_from_pays(p: Pays) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: p }
+}
+
+fn default_post_info() -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: Default::default() }
+}
+
+fn setup_lp(asset_id: u32, balance_factor: u64) {
+	let lp_provider = 5;
+	assert_ok!(Balances::force_set_balance(
+		RuntimeOrigin::root(),
+		lp_provider,
+		10_000 * balance_factor
+	));
+	let lp_provider_account = <Runtime as system::Config>::Lookup::unlookup(lp_provider);
+	assert_ok!(Assets::mint_into(asset_id.into(), &lp_provider_account, 10_000 * balance_factor));
+
+	let token_1 = NativeOrAssetId::Native;
+	let token_2 = NativeOrAssetId::Asset(asset_id);
+	assert_ok!(AssetConversion::create_pool(RuntimeOrigin::signed(lp_provider), token_1, token_2));
+
+	assert_ok!(AssetConversion::add_liquidity(
+		RuntimeOrigin::signed(lp_provider),
+		token_1,
+		token_2,
+		1_000 * balance_factor,  // 1 desired
+		10_000 * balance_factor, // 2 desired
+		1,                       // 1 min
+		1,                       // 2 min
+		lp_provider_account,
+	));
+}
+
+const WEIGHT_5: Weight = Weight::from_parts(5, 0);
+const WEIGHT_50: Weight = Weight::from_parts(50, 0);
+const WEIGHT_100: Weight = Weight::from_parts(100, 0);
+
+#[test]
+fn transaction_payment_in_native_possible() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			let len = 10;
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, None)
+				.pre_dispatch(&1, CALL, &info_from_weight(WEIGHT_5), len)
+				.unwrap();
+			let initial_balance = 10 * balance_factor;
+			assert_eq!(Balances::free_balance(1), initial_balance - 5 - 5 - 10);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(WEIGHT_5),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(1), initial_balance - 5 - 5 - 10);
+
+			let pre = ChargeAssetTxPayment::<Runtime>::from(5 /* tipped */, None)
+				.pre_dispatch(&2, CALL, &info_from_weight(WEIGHT_100), len)
+				.unwrap();
+			let initial_balance_for_2 = 20 * balance_factor;
+
+			assert_eq!(Balances::free_balance(2), initial_balance_for_2 - 5 - 10 - 100 - 5);
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(WEIGHT_100),
+				&post_info_from_weight(WEIGHT_50),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(2), initial_balance_for_2 - 5 - 10 - 50 - 5);
+		});
+}
+
+#[test]
+fn transaction_payment_in_asset_possible() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 1;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 1000;
+
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let len = 10;
+			let tx_weight = 5;
+
+			setup_lp(asset_id, balance_factor);
+
+			let fee_in_native = base_weight + tx_weight + len as u64;
+			let input_quote = AssetConversion::quote_price_tokens_for_exact_tokens(
+				NativeOrAssetId::Asset(asset_id),
+				NativeOrAssetId::Native,
+				fee_in_native,
+				true,
+			);
+			assert_eq!(input_quote, Some(201));
+
+			let fee_in_asset = input_quote.unwrap();
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
+				.unwrap();
+			// assert that native balance is not used
+			assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
+
+			// check that fee was charged in the given asset
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(WEIGHT_5), // estimated tx weight
+				&default_post_info(),        // weight actually used == estimated
+				len,
+				&Ok(())
+			));
+
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
+			assert_eq!(TipUnbalancedAmount::get(), 0);
+			assert_eq!(FeeUnbalancedAmount::get(), fee_in_native);
+		});
+}
+
+#[test]
+fn transaction_payment_in_asset_fails_if_no_pool_for_that_asset() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 1;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 1000;
+
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let len = 10;
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id)).pre_dispatch(
+				&caller,
+				CALL,
+				&info_from_weight(WEIGHT_5),
+				len,
+			);
+
+			// As there is no pool in the dex set up for this asset, conversion should fail.
+			assert!(pre.is_err());
+		});
+}
+
+#[test]
+fn transaction_payment_without_fee() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			let caller = 1;
+
+			// create the asset
+			let asset_id = 1;
+			let balance = 1000;
+			let min_balance = 2;
+
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance,
+			));
+
+			setup_lp(asset_id, balance_factor);
+
+			// mint into the caller account
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let weight = 5;
+			let len = 10;
+			let fee_in_native = base_weight + weight + len as u64;
+			let input_quote = AssetConversion::quote_price_tokens_for_exact_tokens(
+				NativeOrAssetId::Asset(asset_id),
+				NativeOrAssetId::Native,
+				fee_in_native,
+				true,
+			);
+			assert_eq!(input_quote, Some(201));
+
+			let fee_in_asset = input_quote.unwrap();
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
+				.unwrap();
+
+			// assert that native balance is not used
+			assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
+			// check that fee was charged in the given asset
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
+
+			let refund = AssetConversion::quote_price_exact_tokens_for_tokens(
+				NativeOrAssetId::Native,
+				NativeOrAssetId::Asset(asset_id),
+				fee_in_native,
+				true,
+			)
+			.unwrap();
+			assert_eq!(refund, 199);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(WEIGHT_5),
+				&post_info_from_pays(Pays::No),
+				len,
+				&Ok(())
+			));
+
+			// caller should get refunded
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset + refund);
+			assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
+		});
+}
+
+#[test]
+fn asset_transaction_payment_with_tip_and_refund() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance,
+			));
+
+			setup_lp(asset_id, balance_factor);
+
+			// mint into the caller account
+			let caller = 2;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 10000;
+
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let weight = 100;
+			let tip = 5;
+			let len = 10;
+			let fee_in_native = base_weight + weight + len as u64 + tip;
+			let input_quote = AssetConversion::quote_price_tokens_for_exact_tokens(
+				NativeOrAssetId::Asset(asset_id),
+				NativeOrAssetId::Native,
+				fee_in_native,
+				true,
+			);
+			assert_eq!(input_quote, Some(1206));
+
+			let fee_in_asset = input_quote.unwrap();
+			let pre = ChargeAssetTxPayment::<Runtime>::from(tip, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_100), len)
+				.unwrap();
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
+
+			let final_weight = 50;
+			let expected_fee = fee_in_native - final_weight - tip;
+			let expected_token_refund = AssetConversion::quote_price_exact_tokens_for_tokens(
+				NativeOrAssetId::Native,
+				NativeOrAssetId::Asset(asset_id),
+				fee_in_native - expected_fee - tip,
+				true,
+			)
+			.unwrap();
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(WEIGHT_100),
+				&post_info_from_weight(WEIGHT_50),
+				len,
+				&Ok(())
+			));
+
+			assert_eq!(TipUnbalancedAmount::get(), tip);
+			assert_eq!(FeeUnbalancedAmount::get(), expected_fee);
+
+			// caller should get refunded
+			assert_eq!(
+				Assets::balance(asset_id, caller),
+				balance - fee_in_asset + expected_token_refund
+			);
+			assert_eq!(Balances::free_balance(caller), 20 * balance_factor);
+		});
+}
+
+#[test]
+fn payment_from_account_with_only_assets() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance,
+			));
+
+			setup_lp(asset_id, balance_factor);
+
+			// mint into the caller account
+			let caller = 333;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 1000;
+
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			// assert that native balance is not necessary
+			assert_eq!(Balances::free_balance(caller), 0);
+			let weight = 5;
+			let len = 10;
+
+			let fee_in_native = base_weight + weight + len as u64;
+			let ed = Balances::minimum_balance();
+			let fee_in_asset = AssetConversion::quote_price_tokens_for_exact_tokens(
+				NativeOrAssetId::Asset(asset_id),
+				NativeOrAssetId::Native,
+				fee_in_native + ed,
+				true,
+			)
+			.unwrap();
+			assert_eq!(fee_in_asset, 301);
+
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(WEIGHT_5), len)
+				.unwrap();
+			assert_eq!(Balances::free_balance(caller), ed);
+			// check that fee was charged in the given asset
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
+
+			let refund = AssetConversion::quote_price_exact_tokens_for_tokens(
+				NativeOrAssetId::Native,
+				NativeOrAssetId::Asset(asset_id),
+				ed,
+				true,
+			)
+			.unwrap();
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(WEIGHT_5),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset + refund);
+			assert_eq!(Balances::free_balance(caller), 0);
+
+			assert_eq!(TipUnbalancedAmount::get(), 0);
+			assert_eq!(FeeUnbalancedAmount::get(), fee_in_native);
+		});
+}
+
+#[test]
+fn converted_fee_is_never_zero_if_input_fee_is_not() {
+	let base_weight = 1;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 1;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			setup_lp(asset_id, balance_factor);
+
+			// mint into the caller account
+			let caller = 2;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 1000;
+
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let weight = 1;
+			let len = 1;
+
+			// there will be no conversion when the fee is zero
+			{
+				let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+					.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
+					.unwrap();
+				// `Pays::No` implies there are no fees
+				assert_eq!(Assets::balance(asset_id, caller), balance);
+
+				assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+					Some(pre),
+					&info_from_pays(Pays::No),
+					&post_info_from_pays(Pays::No),
+					len,
+					&Ok(())
+				));
+				assert_eq!(Assets::balance(asset_id, caller), balance);
+			}
+
+			// validate even a small fee gets converted to asset.
+			let fee_in_native = base_weight + weight + len as u64;
+			let fee_in_asset = AssetConversion::quote_price_tokens_for_exact_tokens(
+				NativeOrAssetId::Asset(asset_id),
+				NativeOrAssetId::Native,
+				fee_in_native,
+				true,
+			)
+			.unwrap();
+
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.unwrap();
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_in_asset);
+		});
+}
+
+#[test]
+fn post_dispatch_fee_is_zero_if_pre_dispatch_fee_is_zero() {
+	let base_weight = 1;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 100;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 333;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 1000;
+
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let weight = 1;
+			let len = 1;
+			let fee = base_weight + weight + len as u64;
+
+			// calculated fee is greater than 0
+			assert!(fee > 0);
+
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
+				.unwrap();
+			// `Pays::No` implies no pre-dispatch fees
+
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let (_tip, _who, initial_payment, _asset_id) = &pre;
+			let not_paying = match initial_payment {
+				&InitialPayment::Nothing => true,
+				_ => false,
+			};
+			assert!(not_paying, "initial payment should be Nothing if we pass Pays::No");
+
+			// `Pays::Yes` on post-dispatch does not mean we pay (we never charge more than the
+			// initial fee)
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_pays(Pays::No),
+				&post_info_from_pays(Pays::Yes),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+		});
+}
+
+#[test]
+fn post_dispatch_fee_is_zero_if_unsigned_pre_dispatch_fee_is_zero() {
+	let base_weight = 1;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 100;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 333;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 1000;
+
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			let weight = 1;
+			let len = 1;
+			ChargeAssetTxPayment::<Runtime>::pre_dispatch_unsigned(
+				CALL,
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				len,
+			)
+			.unwrap();
+
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			// `Pays::Yes` on post-dispatch does not mean we pay (we never charge more than the
+			// initial fee)
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				None,
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&post_info_from_pays(Pays::Yes),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+		});
+}
diff --git a/substrate/frame/transaction-payment/asset-tx-payment/Cargo.toml b/substrate/frame/transaction-payment/asset-tx-payment/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..42dd65beddb5c48a58c9bdd928c2931388c2c3d2
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-tx-payment/Cargo.toml
@@ -0,0 +1,76 @@
+[package]
+name = "pallet-asset-tx-payment"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "pallet to manage transaction payments in assets"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+# Substrate dependencies
+sp-core = { version = "21.0.0", default-features = false, path = "../../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../../primitives/std" }
+
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
+pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, path = ".." }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../../benchmarking", optional = true }
+
+# Other dependencies
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+
+[dev-dependencies]
+serde_json = "1.0.85"
+
+sp-storage = { version = "13.0.0", default-features = false, path = "../../../primitives/storage" }
+
+pallet-assets = { version = "4.0.0-dev", path = "../../assets" }
+pallet-authorship = { version = "4.0.0-dev", path = "../../authorship" }
+pallet-balances = { version = "4.0.0-dev", path = "../../balances" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-assets/std",
+	"pallet-authorship/std",
+	"pallet-balances/std",
+	"pallet-transaction-payment/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-storage/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-authorship/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-transaction-payment/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/transaction-payment/asset-tx-payment/README.md b/substrate/frame/transaction-payment/asset-tx-payment/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fc860347d85fa37fc98890b5d4b2f56722040a8e
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-tx-payment/README.md
@@ -0,0 +1,21 @@
+# pallet-asset-tx-payment
+
+## Asset Transaction Payment Pallet
+
+This pallet allows runtimes that include it to pay for transactions in assets other than the
+native token of the chain.
+
+### Overview
+It does this by extending transactions to include an optional `AssetId` that specifies the asset
+to be used for payment (defaulting to the native token on `None`). It expects an
+[`OnChargeAssetTransaction`] implementation analogously to [`pallet-transaction-payment`]. The
+included [`FungiblesAdapter`] (implementing [`OnChargeAssetTransaction`]) determines the fee
+amount by converting the fee calculated by [`pallet-transaction-payment`] into the desired
+asset.
+
+### Integration
+This pallet wraps FRAME's transaction payment pallet and functions as a replacement. This means
+you should include both pallets in your `construct_runtime` macro, but only include this
+pallet's [`SignedExtension`] ([`ChargeAssetTxPayment`]).
+
+License: Apache-2.0
diff --git a/substrate/frame/transaction-payment/asset-tx-payment/src/lib.rs b/substrate/frame/transaction-payment/asset-tx-payment/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..753fae747a37ec914abb439fc3829c4caca9a448
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-tx-payment/src/lib.rs
@@ -0,0 +1,314 @@
+// 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.
+
+//! # Asset Transaction Payment Pallet
+//!
+//! This pallet allows runtimes that include it to pay for transactions in assets other than the
+//! main token of the chain.
+//!
+//! ## Overview
+
+//! It does this by extending transactions to include an optional `AssetId` that specifies the asset
+//! to be used for payment (defaulting to the native token on `None`). It expects an
+//! [`OnChargeAssetTransaction`] implementation analogously to [`pallet-transaction-payment`]. The
+//! included [`FungiblesAdapter`] (implementing [`OnChargeAssetTransaction`]) determines the fee
+//! amount by converting the fee calculated by [`pallet-transaction-payment`] into the desired
+//! asset.
+//!
+//! ## Integration
+
+//! This pallet wraps FRAME's transaction payment pallet and functions as a replacement. This means
+//! you should include both pallets in your `construct_runtime` macro, but only include this
+//! pallet's [`SignedExtension`] ([`ChargeAssetTxPayment`]).
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_std::prelude::*;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{DispatchInfo, DispatchResult, PostDispatchInfo},
+	traits::{
+		tokens::{
+			fungibles::{Balanced, Credit, Inspect},
+			WithdrawConsequence,
+		},
+		IsType,
+	},
+	DefaultNoBound,
+};
+use pallet_transaction_payment::OnChargeTransaction;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, Dispatchable, PostDispatchInfoOf, SignedExtension, Zero},
+	transaction_validity::{
+		InvalidTransaction, TransactionValidity, TransactionValidityError, ValidTransaction,
+	},
+};
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+mod payment;
+pub use payment::*;
+
+/// Type aliases used for interaction with `OnChargeTransaction`.
+pub(crate) type OnChargeTransactionOf<T> =
+	<T as pallet_transaction_payment::Config>::OnChargeTransaction;
+/// Balance type alias.
+pub(crate) type BalanceOf<T> = <OnChargeTransactionOf<T> as OnChargeTransaction<T>>::Balance;
+/// Liquidity info type alias.
+pub(crate) type LiquidityInfoOf<T> =
+	<OnChargeTransactionOf<T> as OnChargeTransaction<T>>::LiquidityInfo;
+
+/// Type alias used for interaction with fungibles (assets).
+/// Balance type alias.
+pub(crate) type AssetBalanceOf<T> =
+	<<T as Config>::Fungibles as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
+/// Asset id type alias.
+pub(crate) type AssetIdOf<T> =
+	<<T as Config>::Fungibles as Inspect<<T as frame_system::Config>::AccountId>>::AssetId;
+
+// Type aliases used for interaction with `OnChargeAssetTransaction`.
+/// Balance type alias.
+pub(crate) type ChargeAssetBalanceOf<T> =
+	<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::Balance;
+/// Asset id type alias.
+pub(crate) type ChargeAssetIdOf<T> =
+	<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::AssetId;
+/// Liquidity info type alias.
+pub(crate) type ChargeAssetLiquidityOf<T> =
+	<<T as Config>::OnChargeAssetTransaction as OnChargeAssetTransaction<T>>::LiquidityInfo;
+
+/// Used to pass the initial payment info from pre- to post-dispatch.
+#[derive(Encode, Decode, DefaultNoBound, TypeInfo)]
+pub enum InitialPayment<T: Config> {
+	/// No initial fee was paid.
+	#[default]
+	Nothing,
+	/// The initial fee was paid in the native currency.
+	Native(LiquidityInfoOf<T>),
+	/// The initial fee was paid in an asset.
+	Asset(Credit<T::AccountId, T::Fungibles>),
+}
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config + pallet_transaction_payment::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// The fungibles instance used to pay for transactions in assets.
+		type Fungibles: Balanced<Self::AccountId>;
+		/// The actual transaction charging logic that charges the fees.
+		type OnChargeAssetTransaction: OnChargeAssetTransaction<Self>;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+		/// has been paid by `who` in an asset `asset_id`.
+		AssetTxFeePaid {
+			who: T::AccountId,
+			actual_fee: AssetBalanceOf<T>,
+			tip: AssetBalanceOf<T>,
+			asset_id: Option<ChargeAssetIdOf<T>>,
+		},
+	}
+}
+
+/// Require the transactor pay for themselves and maybe include a tip to gain additional priority
+/// in the queue. Allows paying via both `Currency` as well as `fungibles::Balanced`.
+///
+/// Wraps the transaction logic in [`pallet_transaction_payment`] and extends it with assets.
+/// An asset id of `None` falls back to the underlying transaction payment via the native currency.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct ChargeAssetTxPayment<T: Config> {
+	#[codec(compact)]
+	tip: BalanceOf<T>,
+	asset_id: Option<ChargeAssetIdOf<T>>,
+}
+
+impl<T: Config> ChargeAssetTxPayment<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	AssetBalanceOf<T>: Send + Sync,
+	BalanceOf<T>: Send + Sync + IsType<ChargeAssetBalanceOf<T>>,
+	ChargeAssetIdOf<T>: Send + Sync,
+	Credit<T::AccountId, T::Fungibles>: IsType<ChargeAssetLiquidityOf<T>>,
+{
+	/// Utility constructor. Used only in client/factory code.
+	pub fn from(tip: BalanceOf<T>, asset_id: Option<ChargeAssetIdOf<T>>) -> Self {
+		Self { tip, asset_id }
+	}
+
+	/// Fee withdrawal logic that dispatches to either `OnChargeAssetTransaction` or
+	/// `OnChargeTransaction`.
+	fn withdraw_fee(
+		&self,
+		who: &T::AccountId,
+		call: &T::RuntimeCall,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		len: usize,
+	) -> Result<(BalanceOf<T>, InitialPayment<T>), TransactionValidityError> {
+		let fee = pallet_transaction_payment::Pallet::<T>::compute_fee(len as u32, info, self.tip);
+		debug_assert!(self.tip <= fee, "tip should be included in the computed fee");
+		if fee.is_zero() {
+			Ok((fee, InitialPayment::Nothing))
+		} else if let Some(asset_id) = self.asset_id {
+			T::OnChargeAssetTransaction::withdraw_fee(
+				who,
+				call,
+				info,
+				asset_id,
+				fee.into(),
+				self.tip.into(),
+			)
+			.map(|i| (fee, InitialPayment::Asset(i.into())))
+		} else {
+			<OnChargeTransactionOf<T> as OnChargeTransaction<T>>::withdraw_fee(
+				who, call, info, fee, self.tip,
+			)
+			.map(|i| (fee, InitialPayment::Native(i)))
+			.map_err(|_| -> TransactionValidityError { InvalidTransaction::Payment.into() })
+		}
+	}
+}
+
+impl<T: Config> sp_std::fmt::Debug for ChargeAssetTxPayment<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "ChargeAssetTxPayment<{:?}, {:?}>", self.tip, self.asset_id.encode())
+	}
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config> SignedExtension for ChargeAssetTxPayment<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	AssetBalanceOf<T>: Send + Sync,
+	BalanceOf<T>: Send + Sync + From<u64> + IsType<ChargeAssetBalanceOf<T>>,
+	ChargeAssetIdOf<T>: Send + Sync,
+	Credit<T::AccountId, T::Fungibles>: IsType<ChargeAssetLiquidityOf<T>>,
+{
+	const IDENTIFIER: &'static str = "ChargeAssetTxPayment";
+	type AccountId = T::AccountId;
+	type Call = T::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = (
+		// tip
+		BalanceOf<T>,
+		// who paid the fee
+		Self::AccountId,
+		// imbalance resulting from withdrawing the fee
+		InitialPayment<T>,
+		// asset_id for the transaction payment
+		Option<ChargeAssetIdOf<T>>,
+	);
+
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		use pallet_transaction_payment::ChargeTransactionPayment;
+		let (fee, _) = self.withdraw_fee(who, call, info, len)?;
+		let priority = ChargeTransactionPayment::<T>::get_priority(info, len, self.tip, fee);
+		Ok(ValidTransaction { priority, ..Default::default() })
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		let (_fee, initial_payment) = self.withdraw_fee(who, call, info, len)?;
+		Ok((self.tip, who.clone(), initial_payment, self.asset_id))
+	}
+
+	fn post_dispatch(
+		pre: Option<Self::Pre>,
+		info: &DispatchInfoOf<Self::Call>,
+		post_info: &PostDispatchInfoOf<Self::Call>,
+		len: usize,
+		result: &DispatchResult,
+	) -> Result<(), TransactionValidityError> {
+		if let Some((tip, who, initial_payment, asset_id)) = pre {
+			match initial_payment {
+				InitialPayment::Native(already_withdrawn) => {
+					pallet_transaction_payment::ChargeTransactionPayment::<T>::post_dispatch(
+						Some((tip, who, already_withdrawn)),
+						info,
+						post_info,
+						len,
+						result,
+					)?;
+				},
+				InitialPayment::Asset(already_withdrawn) => {
+					let actual_fee = pallet_transaction_payment::Pallet::<T>::compute_actual_fee(
+						len as u32, info, post_info, tip,
+					);
+
+					let (converted_fee, converted_tip) =
+						T::OnChargeAssetTransaction::correct_and_deposit_fee(
+							&who,
+							info,
+							post_info,
+							actual_fee.into(),
+							tip.into(),
+							already_withdrawn.into(),
+						)?;
+					Pallet::<T>::deposit_event(Event::<T>::AssetTxFeePaid {
+						who,
+						actual_fee: converted_fee,
+						tip: converted_tip,
+						asset_id,
+					});
+				},
+				InitialPayment::Nothing => {
+					// `actual_fee` should be zero here for any signed extrinsic. It would be
+					// non-zero here in case of unsigned extrinsics as they don't pay fees but
+					// `compute_actual_fee` is not aware of them. In both cases it's fine to just
+					// move ahead without adjusting the fee, though, so we do nothing.
+					debug_assert!(tip.is_zero(), "tip should be zero if initial fee was zero.");
+				},
+			}
+		}
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs b/substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b8d7b523ca2589555b7a4aeb65eb544b54a52a98
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-tx-payment/src/mock.rs
@@ -0,0 +1,206 @@
+// 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 crate as pallet_asset_tx_payment;
+
+use codec;
+use frame_support::{
+	dispatch::DispatchClass,
+	pallet_prelude::*,
+	parameter_types,
+	traits::{AsEnsureOriginWithArg, ConstU32, ConstU64, ConstU8, FindAuthor},
+	weights::{Weight, WeightToFee as WeightToFeeT},
+	ConsensusEngineId,
+};
+use frame_system as system;
+use frame_system::EnsureRoot;
+use pallet_transaction_payment::CurrencyAdapter;
+use sp_core::H256;
+use sp_runtime::traits::{BlakeTwo256, ConvertInto, IdentityLookup, SaturatedConversion};
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+type Balance = u64;
+type AccountId = u64;
+
+frame_support::construct_runtime!(
+	pub struct Runtime {
+		System: system,
+		Balances: pallet_balances,
+		TransactionPayment: pallet_transaction_payment,
+		Assets: pallet_assets,
+		Authorship: pallet_authorship,
+		AssetTxPayment: pallet_asset_tx_payment,
+	}
+);
+
+parameter_types! {
+	pub(crate) static ExtrinsicBaseWeight: Weight = Weight::zero();
+}
+
+pub struct BlockWeights;
+impl Get<frame_system::limits::BlockWeights> for BlockWeights {
+	fn get() -> frame_system::limits::BlockWeights {
+		frame_system::limits::BlockWeights::builder()
+			.base_block(Weight::zero())
+			.for_class(DispatchClass::all(), |weights| {
+				weights.base_extrinsic = ExtrinsicBaseWeight::get().into();
+			})
+			.for_class(DispatchClass::non_mandatory(), |weights| {
+				weights.max_total = Weight::from_parts(1024, u64::MAX).into();
+			})
+			.build_or_panic()
+	}
+}
+
+parameter_types! {
+	pub static WeightToFee: u64 = 1;
+	pub static TransactionByteFee: u64 = 1;
+}
+
+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;
+}
+
+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 MaxHolds = ();
+}
+
+impl WeightToFeeT for WeightToFee {
+	type Balance = u64;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time())
+			.saturating_mul(WEIGHT_TO_FEE.with(|v| *v.borrow()))
+	}
+}
+
+impl WeightToFeeT for TransactionByteFee {
+	type Balance = u64;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time())
+			.saturating_mul(TRANSACTION_BYTE_FEE.with(|v| *v.borrow()))
+	}
+}
+
+impl pallet_transaction_payment::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
+	type WeightToFee = WeightToFee;
+	type LengthToFee = TransactionByteFee;
+	type FeeMultiplierUpdate = ();
+	type OperationalFeeMultiplier = ConstU8<5>;
+}
+
+type AssetId = u32;
+
+impl pallet_assets::Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = Balance;
+	type AssetId = AssetId;
+	type AssetIdParameter = codec::Compact<AssetId>;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<AccountId>>;
+	type ForceOrigin = EnsureRoot<AccountId>;
+	type AssetDeposit = ConstU64<2>;
+	type AssetAccountDeposit = ConstU64<2>;
+	type MetadataDepositBase = ConstU64<0>;
+	type MetadataDepositPerByte = ConstU64<0>;
+	type ApprovalDeposit = ConstU64<0>;
+	type StringLimit = ConstU32<20>;
+	type Freezer = ();
+	type Extra = ();
+	type CallbackHandle = ();
+	type WeightInfo = ();
+	type RemoveItemsLimit = ConstU32<1000>;
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+pub struct HardcodedAuthor;
+pub(crate) const BLOCK_AUTHOR: AccountId = 1234;
+impl FindAuthor<AccountId> for HardcodedAuthor {
+	fn find_author<'a, I>(_: I) -> Option<AccountId>
+	where
+		I: 'a + IntoIterator<Item = (ConsensusEngineId, &'a [u8])>,
+	{
+		Some(BLOCK_AUTHOR)
+	}
+}
+
+impl pallet_authorship::Config for Runtime {
+	type FindAuthor = HardcodedAuthor;
+	type EventHandler = ();
+}
+
+pub struct CreditToBlockAuthor;
+impl HandleCredit<AccountId, Assets> for CreditToBlockAuthor {
+	fn handle_credit(credit: Credit<AccountId, Assets>) {
+		if let Some(author) = pallet_authorship::Pallet::<Runtime>::author() {
+			// What to do in case paying the author fails (e.g. because `fee < min_balance`)
+			// default: drop the result which will trigger the `OnDrop` of the imbalance.
+			let _ = <Assets as Balanced<AccountId>>::resolve(&author, credit);
+		}
+	}
+}
+
+impl Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type Fungibles = Assets;
+	type OnChargeAssetTransaction = FungiblesAdapter<
+		pallet_assets::BalanceToAssetBalance<Balances, Runtime, ConvertInto>,
+		CreditToBlockAuthor,
+	>;
+}
diff --git a/substrate/frame/transaction-payment/asset-tx-payment/src/payment.rs b/substrate/frame/transaction-payment/asset-tx-payment/src/payment.rs
new file mode 100644
index 0000000000000000000000000000000000000000..717114ab6bd03c786266d1b54fe25fa171c47d19
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-tx-payment/src/payment.rs
@@ -0,0 +1,174 @@
+// 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.
+
+///! Traits and default implementation for paying transaction fees in assets.
+use super::*;
+use crate::Config;
+
+use codec::FullCodec;
+use frame_support::{
+	traits::{
+		fungibles::{Balanced, Credit, Inspect},
+		tokens::{
+			Balance, ConversionToAssetBalance, Fortitude::Polite, Precision::Exact,
+			Preservation::Protect,
+		},
+	},
+	unsigned::TransactionValidityError,
+};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{DispatchInfoOf, MaybeSerializeDeserialize, One, PostDispatchInfoOf},
+	transaction_validity::InvalidTransaction,
+};
+use sp_std::{fmt::Debug, marker::PhantomData};
+
+/// Handle withdrawing, refunding and depositing of transaction fees.
+pub trait OnChargeAssetTransaction<T: Config> {
+	/// The underlying integer type in which fees are calculated.
+	type Balance: Balance;
+	/// The type used to identify the assets used for transaction payment.
+	type AssetId: FullCodec + Copy + MaybeSerializeDeserialize + Debug + Default + Eq + TypeInfo;
+	/// The type used to store the intermediate values between pre- and post-dispatch.
+	type LiquidityInfo;
+
+	/// Before the transaction is executed the payment of the transaction fees needs to be secured.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	fn withdraw_fee(
+		who: &T::AccountId,
+		call: &T::RuntimeCall,
+		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		asset_id: Self::AssetId,
+		fee: Self::Balance,
+		tip: Self::Balance,
+	) -> Result<Self::LiquidityInfo, TransactionValidityError>;
+
+	/// After the transaction was executed the actual fee can be calculated.
+	/// This function should refund any overpaid fees and optionally deposit
+	/// the corrected amount.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	///
+	/// Returns the fee and tip in the asset used for payment as (fee, tip).
+	fn correct_and_deposit_fee(
+		who: &T::AccountId,
+		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		corrected_fee: Self::Balance,
+		tip: Self::Balance,
+		already_withdrawn: Self::LiquidityInfo,
+	) -> Result<(AssetBalanceOf<T>, AssetBalanceOf<T>), TransactionValidityError>;
+}
+
+/// Allows specifying what to do with the withdrawn asset fees.
+pub trait HandleCredit<AccountId, B: Balanced<AccountId>> {
+	/// Implement to determine what to do with the withdrawn asset fees.
+	/// Default for `CreditOf` from the assets pallet is to burn and
+	/// decrease total issuance.
+	fn handle_credit(credit: Credit<AccountId, B>);
+}
+
+/// Default implementation that just drops the credit according to the `OnDrop` in the underlying
+/// imbalance type.
+impl<A, B: Balanced<A>> HandleCredit<A, B> for () {
+	fn handle_credit(_credit: Credit<A, B>) {}
+}
+
+/// Implements the asset transaction for a balance to asset converter (implementing
+/// [`ConversionToAssetBalance`]) and a credit handler (implementing [`HandleCredit`]).
+///
+/// The credit handler is given the complete fee in terms of the asset used for the transaction.
+pub struct FungiblesAdapter<CON, HC>(PhantomData<(CON, HC)>);
+
+/// Default implementation for a runtime instantiating this pallet, a balance to asset converter and
+/// a credit handler.
+impl<T, CON, HC> OnChargeAssetTransaction<T> for FungiblesAdapter<CON, HC>
+where
+	T: Config,
+	CON: ConversionToAssetBalance<BalanceOf<T>, AssetIdOf<T>, AssetBalanceOf<T>>,
+	HC: HandleCredit<T::AccountId, T::Fungibles>,
+	AssetIdOf<T>: FullCodec + Copy + MaybeSerializeDeserialize + Debug + Default + Eq + TypeInfo,
+{
+	type Balance = BalanceOf<T>;
+	type AssetId = AssetIdOf<T>;
+	type LiquidityInfo = Credit<T::AccountId, T::Fungibles>;
+
+	/// Withdraw the predicted fee from the transaction origin.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	fn withdraw_fee(
+		who: &T::AccountId,
+		_call: &T::RuntimeCall,
+		_info: &DispatchInfoOf<T::RuntimeCall>,
+		asset_id: Self::AssetId,
+		fee: Self::Balance,
+		_tip: Self::Balance,
+	) -> Result<Self::LiquidityInfo, TransactionValidityError> {
+		// We don't know the precision of the underlying asset. Because the converted fee could be
+		// less than one (e.g. 0.5) but gets rounded down by integer division we introduce a minimum
+		// fee.
+		let min_converted_fee = if fee.is_zero() { Zero::zero() } else { One::one() };
+		let converted_fee = CON::to_asset_balance(fee, asset_id)
+			.map_err(|_| TransactionValidityError::from(InvalidTransaction::Payment))?
+			.max(min_converted_fee);
+		let can_withdraw =
+			<T::Fungibles as Inspect<T::AccountId>>::can_withdraw(asset_id, who, converted_fee);
+		if can_withdraw != WithdrawConsequence::Success {
+			return Err(InvalidTransaction::Payment.into())
+		}
+		<T::Fungibles as Balanced<T::AccountId>>::withdraw(
+			asset_id,
+			who,
+			converted_fee,
+			Exact,
+			Protect,
+			Polite,
+		)
+		.map_err(|_| TransactionValidityError::from(InvalidTransaction::Payment))
+	}
+
+	/// Hand the fee and the tip over to the `[HandleCredit]` implementation.
+	/// Since the predicted fee might have been too high, parts of the fee may be refunded.
+	///
+	/// Note: The `corrected_fee` already includes the `tip`.
+	///
+	/// Returns the fee and tip in the asset used for payment as (fee, tip).
+	fn correct_and_deposit_fee(
+		who: &T::AccountId,
+		_dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		_post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		corrected_fee: Self::Balance,
+		tip: Self::Balance,
+		paid: Self::LiquidityInfo,
+	) -> Result<(AssetBalanceOf<T>, AssetBalanceOf<T>), TransactionValidityError> {
+		let min_converted_fee = if corrected_fee.is_zero() { Zero::zero() } else { One::one() };
+		// Convert the corrected fee and tip into the asset used for payment.
+		let converted_fee = CON::to_asset_balance(corrected_fee, paid.asset())
+			.map_err(|_| -> TransactionValidityError { InvalidTransaction::Payment.into() })?
+			.max(min_converted_fee);
+		let converted_tip = CON::to_asset_balance(tip, paid.asset())
+			.map_err(|_| -> TransactionValidityError { InvalidTransaction::Payment.into() })?;
+
+		// Calculate how much refund we should return.
+		let (final_fee, refund) = paid.split(converted_fee);
+		// Refund to the account that paid the fees. If this fails, the account might have dropped
+		// below the existential balance. In that case we don't refund anything.
+		let _ = <T::Fungibles as Balanced<T::AccountId>>::resolve(who, refund);
+		// Handle the final fee, e.g. by transferring to the block author or burning.
+		HC::handle_credit(final_fee);
+		Ok((converted_fee, converted_tip))
+	}
+}
diff --git a/substrate/frame/transaction-payment/asset-tx-payment/src/tests.rs b/substrate/frame/transaction-payment/asset-tx-payment/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8df98ceda9971565788576ee839792f6d58da2b0
--- /dev/null
+++ b/substrate/frame/transaction-payment/asset-tx-payment/src/tests.rs
@@ -0,0 +1,563 @@
+// 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::{
+	assert_ok,
+	dispatch::{DispatchInfo, PostDispatchInfo},
+	pallet_prelude::*,
+	traits::fungibles::Mutate,
+	weights::Weight,
+};
+use frame_system as system;
+use mock::{ExtrinsicBaseWeight, *};
+use pallet_balances::Call as BalancesCall;
+use sp_runtime::{traits::StaticLookup, BuildStorage};
+
+const CALL: &<Runtime as frame_system::Config>::RuntimeCall =
+	&RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
+
+pub struct ExtBuilder {
+	balance_factor: u64,
+	base_weight: Weight,
+	byte_fee: u64,
+	weight_to_fee: u64,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			balance_factor: 1,
+			base_weight: Weight::from_parts(0, 0),
+			byte_fee: 1,
+			weight_to_fee: 1,
+		}
+	}
+}
+
+impl ExtBuilder {
+	pub fn base_weight(mut self, base_weight: Weight) -> Self {
+		self.base_weight = base_weight;
+		self
+	}
+	pub fn balance_factor(mut self, factor: u64) -> Self {
+		self.balance_factor = factor;
+		self
+	}
+	fn set_constants(&self) {
+		ExtrinsicBaseWeight::mutate(|v| *v = self.base_weight);
+		TRANSACTION_BYTE_FEE.with(|v| *v.borrow_mut() = self.byte_fee);
+		WEIGHT_TO_FEE.with(|v| *v.borrow_mut() = self.weight_to_fee);
+	}
+	pub fn build(self) -> sp_io::TestExternalities {
+		self.set_constants();
+		let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Runtime> {
+			balances: if self.balance_factor > 0 {
+				vec![
+					(1, 10 * self.balance_factor),
+					(2, 20 * self.balance_factor),
+					(3, 30 * self.balance_factor),
+					(4, 40 * self.balance_factor),
+					(5, 50 * self.balance_factor),
+					(6, 60 * self.balance_factor),
+				]
+			} else {
+				vec![]
+			},
+		}
+		.assimilate_storage(&mut t)
+		.unwrap();
+		t.into()
+	}
+}
+
+/// create a transaction info struct from weight. Handy to avoid building the whole struct.
+pub fn info_from_weight(w: Weight) -> DispatchInfo {
+	// pays_fee: Pays::Yes -- class: DispatchClass::Normal
+	DispatchInfo { weight: w, ..Default::default() }
+}
+
+fn post_info_from_weight(w: Weight) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: Some(w), pays_fee: Default::default() }
+}
+
+fn info_from_pays(p: Pays) -> DispatchInfo {
+	DispatchInfo { pays_fee: p, ..Default::default() }
+}
+
+fn post_info_from_pays(p: Pays) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: p }
+}
+
+fn default_post_info() -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: Default::default() }
+}
+
+#[test]
+fn transaction_payment_in_native_possible() {
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			let len = 10;
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, None)
+				.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(5, 0)), len)
+				.unwrap();
+			let initial_balance = 10 * balance_factor;
+			assert_eq!(Balances::free_balance(1), initial_balance - 5 - 5 - 10);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(5, 0)),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(1), initial_balance - 5 - 5 - 10);
+
+			let pre = ChargeAssetTxPayment::<Runtime>::from(5 /* tipped */, None)
+				.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
+				.unwrap();
+			let initial_balance_for_2 = 20 * balance_factor;
+			assert_eq!(Balances::free_balance(2), initial_balance_for_2 - 5 - 10 - 100 - 5);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(100, 0)),
+				&post_info_from_weight(Weight::from_parts(50, 0)),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(2), initial_balance_for_2 - 5 - 10 - 50 - 5);
+		});
+}
+
+#[test]
+fn transaction_payment_in_asset_possible() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 1;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 100;
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			let weight = 5;
+			let len = 10;
+			// we convert the from weight to fee based on the ratio between asset min balance and
+			// existential deposit
+			let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.unwrap();
+			// assert that native balance is not used
+			assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
+			// check that fee was charged in the given asset
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee);
+			assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), 0);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee);
+			// check that the block author gets rewarded
+			assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), fee);
+		});
+}
+
+#[test]
+fn transaction_payment_without_fee() {
+	let base_weight = 5;
+	let balance_factor = 100;
+	ExtBuilder::default()
+		.balance_factor(balance_factor)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 1;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 100;
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			let weight = 5;
+			let len = 10;
+			// we convert the from weight to fee based on the ratio between asset min balance and
+			// existential deposit
+			let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.unwrap();
+			// assert that native balance is not used
+			assert_eq!(Balances::free_balance(caller), 10 * balance_factor);
+			// check that fee was charged in the given asset
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee);
+			assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), 0);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&post_info_from_pays(Pays::No),
+				len,
+				&Ok(())
+			));
+			// caller should be refunded
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			// check that the block author did not get rewarded
+			assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), 0);
+		});
+}
+
+#[test]
+fn asset_transaction_payment_with_tip_and_refund() {
+	let base_weight = 5;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 2;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 1000;
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			let weight = 100;
+			let tip = 5;
+			let len = 10;
+			// we convert the from weight to fee based on the ratio between asset min balance and
+			// existential deposit
+			let fee_with_tip =
+				(base_weight + weight + len as u64 + tip) * min_balance / ExistentialDeposit::get();
+			let pre = ChargeAssetTxPayment::<Runtime>::from(tip, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.unwrap();
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee_with_tip);
+
+			let final_weight = 50;
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&post_info_from_weight(Weight::from_parts(final_weight, 0)),
+				len,
+				&Ok(())
+			));
+			let final_fee =
+				fee_with_tip - (weight - final_weight) * min_balance / ExistentialDeposit::get();
+			assert_eq!(Assets::balance(asset_id, caller), balance - (final_fee));
+			assert_eq!(Assets::balance(asset_id, BLOCK_AUTHOR), final_fee);
+		});
+}
+
+#[test]
+fn payment_from_account_with_only_assets() {
+	let base_weight = 5;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 333;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 100;
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			// assert that native balance is not necessary
+			assert_eq!(Balances::free_balance(caller), 0);
+			let weight = 5;
+			let len = 10;
+			// we convert the from weight to fee based on the ratio between asset min balance and
+			// existential deposit
+			let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.unwrap();
+			assert_eq!(Balances::free_balance(caller), 0);
+			// check that fee was charged in the given asset
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance - fee);
+			assert_eq!(Balances::free_balance(caller), 0);
+		});
+}
+
+#[test]
+fn payment_only_with_existing_sufficient_asset() {
+	let base_weight = 5;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			let asset_id = 1;
+			let caller = 1;
+			let weight = 5;
+			let len = 10;
+			// pre_dispatch fails for non-existent asset
+			assert!(ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.is_err());
+
+			// create the non-sufficient asset
+			let min_balance = 2;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,    /* owner */
+				false, /* is_sufficient */
+				min_balance
+			));
+			// pre_dispatch fails for non-sufficient asset
+			assert!(ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.is_err());
+		});
+}
+
+#[test]
+fn converted_fee_is_never_zero_if_input_fee_is_not() {
+	let base_weight = 1;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 1;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 333;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 100;
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			let weight = 1;
+			let len = 1;
+			// we convert the from weight to fee based on the ratio between asset min balance and
+			// existential deposit
+			let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
+			// naive fee calculation would round down to zero
+			assert_eq!(fee, 0);
+			{
+				let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+					.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
+					.unwrap();
+				// `Pays::No` still implies no fees
+				assert_eq!(Assets::balance(asset_id, caller), balance);
+
+				assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+					Some(pre),
+					&info_from_pays(Pays::No),
+					&post_info_from_pays(Pays::No),
+					len,
+					&Ok(())
+				));
+				assert_eq!(Assets::balance(asset_id, caller), balance);
+			}
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_weight(Weight::from_parts(weight, 0)), len)
+				.unwrap();
+			// check that at least one coin was charged in the given asset
+			assert_eq!(Assets::balance(asset_id, caller), balance - 1);
+
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance - 1);
+		});
+}
+
+#[test]
+fn post_dispatch_fee_is_zero_if_pre_dispatch_fee_is_zero() {
+	let base_weight = 1;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 100;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 333;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 100;
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			let weight = 1;
+			let len = 1;
+			// we convert the from weight to fee based on the ratio between asset min balance and
+			// existential deposit
+			let fee = (base_weight + weight + len as u64) * min_balance / ExistentialDeposit::get();
+			// calculated fee is greater than 0
+			assert!(fee > 0);
+			let pre = ChargeAssetTxPayment::<Runtime>::from(0, Some(asset_id))
+				.pre_dispatch(&caller, CALL, &info_from_pays(Pays::No), len)
+				.unwrap();
+			// `Pays::No` implies no pre-dispatch fees
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			let (_tip, _who, initial_payment, _asset_id) = &pre;
+			let not_paying = match initial_payment {
+				&InitialPayment::Nothing => true,
+				_ => false,
+			};
+			assert!(not_paying, "initial payment should be Nothing if we pass Pays::No");
+
+			// `Pays::Yes` on post-dispatch does not mean we pay (we never charge more than the
+			// initial fee)
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_pays(Pays::No),
+				&post_info_from_pays(Pays::Yes),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+		});
+}
+
+#[test]
+fn post_dispatch_fee_is_zero_if_unsigned_pre_dispatch_fee_is_zero() {
+	let base_weight = 1;
+	ExtBuilder::default()
+		.balance_factor(100)
+		.base_weight(Weight::from_parts(base_weight, 0))
+		.build()
+		.execute_with(|| {
+			// create the asset
+			let asset_id = 1;
+			let min_balance = 100;
+			assert_ok!(Assets::force_create(
+				RuntimeOrigin::root(),
+				asset_id.into(),
+				42,   /* owner */
+				true, /* is_sufficient */
+				min_balance
+			));
+
+			// mint into the caller account
+			let caller = 333;
+			let beneficiary = <Runtime as system::Config>::Lookup::unlookup(caller);
+			let balance = 100;
+			assert_ok!(Assets::mint_into(asset_id.into(), &beneficiary, balance));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+			let weight = 1;
+			let len = 1;
+			ChargeAssetTxPayment::<Runtime>::pre_dispatch_unsigned(
+				CALL,
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				len,
+			)
+			.unwrap();
+
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+
+			// `Pays::Yes` on post-dispatch does not mean we pay (we never charge more than the
+			// initial fee)
+			assert_ok!(ChargeAssetTxPayment::<Runtime>::post_dispatch(
+				None,
+				&info_from_weight(Weight::from_parts(weight, 0)),
+				&post_info_from_pays(Pays::Yes),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Assets::balance(asset_id, caller), balance);
+		});
+}
diff --git a/substrate/frame/transaction-payment/rpc/Cargo.toml b/substrate/frame/transaction-payment/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..28eb562e97d0ce2fe69a72e1e5924952ed6be055
--- /dev/null
+++ b/substrate/frame/transaction-payment/rpc/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "pallet-transaction-payment-rpc"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "RPC interface for the transaction payment pallet."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+pallet-transaction-payment-rpc-runtime-api = { version = "4.0.0-dev", path = "./runtime-api" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-rpc = { version = "6.0.0", path = "../../../primitives/rpc" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-weights = { version = "20.0.0", path = "../../../primitives/weights" }
diff --git a/substrate/frame/transaction-payment/rpc/README.md b/substrate/frame/transaction-payment/rpc/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..bf2ada1ff0ab3b6074e2fe3fc9a7ae2e9d5fb52e
--- /dev/null
+++ b/substrate/frame/transaction-payment/rpc/README.md
@@ -0,0 +1,3 @@
+RPC interface for the transaction payment pallet.
+
+License: Apache-2.0
diff --git a/substrate/frame/transaction-payment/rpc/runtime-api/Cargo.toml b/substrate/frame/transaction-payment/rpc/runtime-api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..27b8417b1f3b455230dddcb53cfe8d69a939f03b
--- /dev/null
+++ b/substrate/frame/transaction-payment/rpc/runtime-api/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "pallet-transaction-payment-rpc-runtime-api"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "RPC runtime API for transaction payment FRAME pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, path = "../../../transaction-payment" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../../../primitives/api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../../../primitives/runtime" }
+sp-weights = { version = "20.0.0", default-features = false, path = "../../../../primitives/weights" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"pallet-transaction-payment/std",
+	"sp-api/std",
+	"sp-runtime/std",
+	"sp-weights/std",
+]
diff --git a/substrate/frame/transaction-payment/rpc/runtime-api/README.md b/substrate/frame/transaction-payment/rpc/runtime-api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0d81abdb1eeb30518dd4416262848c925801f170
--- /dev/null
+++ b/substrate/frame/transaction-payment/rpc/runtime-api/README.md
@@ -0,0 +1,3 @@
+Runtime API definition for transaction payment pallet.
+
+License: Apache-2.0
diff --git a/substrate/frame/transaction-payment/rpc/runtime-api/src/lib.rs b/substrate/frame/transaction-payment/rpc/runtime-api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d9c3338250e72c6b71a45c630898905370b2543
--- /dev/null
+++ b/substrate/frame/transaction-payment/rpc/runtime-api/src/lib.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! Runtime API definition for transaction payment pallet.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::Codec;
+use sp_runtime::traits::MaybeDisplay;
+
+pub use pallet_transaction_payment::{FeeDetails, InclusionFee, RuntimeDispatchInfo};
+
+sp_api::decl_runtime_apis! {
+	#[api_version(4)]
+	pub trait TransactionPaymentApi<Balance> where
+		Balance: Codec + MaybeDisplay,
+	{
+		fn query_info(uxt: Block::Extrinsic, len: u32) -> RuntimeDispatchInfo<Balance>;
+		fn query_fee_details(uxt: Block::Extrinsic, len: u32) -> FeeDetails<Balance>;
+		fn query_weight_to_fee(weight: sp_weights::Weight) -> Balance;
+		fn query_length_to_fee(length: u32) -> Balance;
+	}
+
+	#[api_version(3)]
+	pub trait TransactionPaymentCallApi<Balance, Call>
+	where
+		Balance: Codec + MaybeDisplay,
+		Call: Codec,
+	{
+		/// Query information of a dispatch class, weight, and fee of a given encoded `Call`.
+		fn query_call_info(call: Call, len: u32) -> RuntimeDispatchInfo<Balance>;
+
+		/// Query fee details of a given encoded `Call`.
+		fn query_call_fee_details(call: Call, len: u32) -> FeeDetails<Balance>;
+
+		/// Query the output of the current `WeightToFee` given some input.
+		fn query_weight_to_fee(weight: sp_weights::Weight) -> Balance;
+
+		/// Query the output of the current `LengthToFee` given some input.
+		fn query_length_to_fee(length: u32) -> Balance;
+	}
+}
diff --git a/substrate/frame/transaction-payment/rpc/src/lib.rs b/substrate/frame/transaction-payment/rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7f8ed4b80267578f81d6043e64ffa64596f7f904
--- /dev/null
+++ b/substrate/frame/transaction-payment/rpc/src/lib.rs
@@ -0,0 +1,177 @@
+// 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.
+
+//! RPC interface for the transaction payment pallet.
+
+use std::{convert::TryInto, sync::Arc};
+
+use codec::{Codec, Decode};
+use jsonrpsee::{
+	core::{Error as JsonRpseeError, RpcResult},
+	proc_macros::rpc,
+	types::error::{CallError, ErrorCode, ErrorObject},
+};
+use pallet_transaction_payment_rpc_runtime_api::{FeeDetails, InclusionFee, RuntimeDispatchInfo};
+use sp_api::ProvideRuntimeApi;
+use sp_blockchain::HeaderBackend;
+use sp_core::Bytes;
+use sp_rpc::number::NumberOrHex;
+use sp_runtime::traits::{Block as BlockT, MaybeDisplay};
+
+pub use pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi as TransactionPaymentRuntimeApi;
+
+#[rpc(client, server)]
+pub trait TransactionPaymentApi<BlockHash, ResponseType> {
+	#[method(name = "payment_queryInfo")]
+	fn query_info(&self, encoded_xt: Bytes, at: Option<BlockHash>) -> RpcResult<ResponseType>;
+
+	#[method(name = "payment_queryFeeDetails")]
+	fn query_fee_details(
+		&self,
+		encoded_xt: Bytes,
+		at: Option<BlockHash>,
+	) -> RpcResult<FeeDetails<NumberOrHex>>;
+}
+
+/// Provides RPC methods to query a dispatchable's class, weight and fee.
+pub struct TransactionPayment<C, P> {
+	/// Shared reference to the client.
+	client: Arc<C>,
+	_marker: std::marker::PhantomData<P>,
+}
+
+impl<C, P> TransactionPayment<C, P> {
+	/// Creates a new instance of the TransactionPayment Rpc helper.
+	pub fn new(client: Arc<C>) -> Self {
+		Self { client, _marker: Default::default() }
+	}
+}
+
+/// Error type of this RPC api.
+pub enum Error {
+	/// The transaction was not decodable.
+	DecodeError,
+	/// The call to runtime failed.
+	RuntimeError,
+}
+
+impl From<Error> for i32 {
+	fn from(e: Error) -> i32 {
+		match e {
+			Error::RuntimeError => 1,
+			Error::DecodeError => 2,
+		}
+	}
+}
+
+impl<C, Block, Balance>
+	TransactionPaymentApiServer<
+		<Block as BlockT>::Hash,
+		RuntimeDispatchInfo<Balance, sp_weights::Weight>,
+	> for TransactionPayment<C, Block>
+where
+	Block: BlockT,
+	C: ProvideRuntimeApi<Block> + HeaderBackend<Block> + Send + Sync + 'static,
+	C::Api: TransactionPaymentRuntimeApi<Block, Balance>,
+	Balance: Codec + MaybeDisplay + Copy + TryInto<NumberOrHex> + Send + Sync + 'static,
+{
+	fn query_info(
+		&self,
+		encoded_xt: Bytes,
+		at: Option<Block::Hash>,
+	) -> RpcResult<RuntimeDispatchInfo<Balance, sp_weights::Weight>> {
+		let api = self.client.runtime_api();
+		let at_hash = at.unwrap_or_else(|| self.client.info().best_hash);
+
+		let encoded_len = encoded_xt.len() as u32;
+
+		let uxt: Block::Extrinsic = Decode::decode(&mut &*encoded_xt).map_err(|e| {
+			CallError::Custom(ErrorObject::owned(
+				Error::DecodeError.into(),
+				"Unable to query dispatch info.",
+				Some(format!("{:?}", e)),
+			))
+		})?;
+
+		fn map_err(error: impl ToString, desc: &'static str) -> CallError {
+			CallError::Custom(ErrorObject::owned(
+				Error::RuntimeError.into(),
+				desc,
+				Some(error.to_string()),
+			))
+		}
+
+		let res = api
+			.query_info(at_hash, uxt, encoded_len)
+			.map_err(|e| map_err(e, "Unable to query dispatch info."))?;
+
+		Ok(RuntimeDispatchInfo {
+			weight: res.weight,
+			class: res.class,
+			partial_fee: res.partial_fee,
+		})
+	}
+
+	fn query_fee_details(
+		&self,
+		encoded_xt: Bytes,
+		at: Option<Block::Hash>,
+	) -> RpcResult<FeeDetails<NumberOrHex>> {
+		let api = self.client.runtime_api();
+		let at_hash = at.unwrap_or_else(|| self.client.info().best_hash);
+
+		let encoded_len = encoded_xt.len() as u32;
+
+		let uxt: Block::Extrinsic = Decode::decode(&mut &*encoded_xt).map_err(|e| {
+			CallError::Custom(ErrorObject::owned(
+				Error::DecodeError.into(),
+				"Unable to query fee details.",
+				Some(format!("{:?}", e)),
+			))
+		})?;
+		let fee_details = api.query_fee_details(at_hash, uxt, encoded_len).map_err(|e| {
+			CallError::Custom(ErrorObject::owned(
+				Error::RuntimeError.into(),
+				"Unable to query fee details.",
+				Some(e.to_string()),
+			))
+		})?;
+
+		let try_into_rpc_balance = |value: Balance| {
+			value.try_into().map_err(|_| {
+				JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+					ErrorCode::InvalidParams.code(),
+					format!("{} doesn't fit in NumberOrHex representation", value),
+					None::<()>,
+				)))
+			})
+		};
+
+		Ok(FeeDetails {
+			inclusion_fee: if let Some(inclusion_fee) = fee_details.inclusion_fee {
+				Some(InclusionFee {
+					base_fee: try_into_rpc_balance(inclusion_fee.base_fee)?,
+					len_fee: try_into_rpc_balance(inclusion_fee.len_fee)?,
+					adjusted_weight_fee: try_into_rpc_balance(inclusion_fee.adjusted_weight_fee)?,
+				})
+			} else {
+				None
+			},
+			tip: Default::default(),
+		})
+	}
+}
diff --git a/substrate/frame/transaction-payment/src/lib.rs b/substrate/frame/transaction-payment/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8160d72ad8942b776bea069a3ef864217ce9a8b2
--- /dev/null
+++ b/substrate/frame/transaction-payment/src/lib.rs
@@ -0,0 +1,872 @@
+// 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.
+
+//! # Transaction Payment Pallet
+//!
+//! This pallet provides the basic logic needed to pay the absolute minimum amount needed for a
+//! transaction to be included. This includes:
+//!   - _base fee_: This is the minimum amount a user pays for a transaction. It is declared
+//! 	as a base _weight_ in the runtime and converted to a fee using `WeightToFee`.
+//!   - _weight fee_: A fee proportional to amount of weight a transaction consumes.
+//!   - _length fee_: A fee proportional to the encoded length of the transaction.
+//!   - _tip_: An optional tip. Tip increases the priority of the transaction, giving it a higher
+//!     chance to be included by the transaction queue.
+//!
+//! The base fee and adjusted weight and length fees constitute the _inclusion fee_, which is
+//! the minimum fee for a transaction to be included in a block.
+//!
+//! The formula of final fee:
+//!   ```ignore
+//!   inclusion_fee = base_fee + length_fee + [targeted_fee_adjustment * weight_fee];
+//!   final_fee = inclusion_fee + tip;
+//!   ```
+//!
+//!   - `targeted_fee_adjustment`: This is a multiplier that can tune the final fee based on
+//! 	the congestion of the network.
+//!
+//! Additionally, this pallet allows one to configure:
+//!   - The mapping between one unit of weight to one unit of fee via [`Config::WeightToFee`].
+//!   - A means of updating the fee for the next block, via defining a multiplier, based on the
+//!     final state of the chain at the end of the previous block. This can be configured via
+//!     [`Config::FeeMultiplierUpdate`]
+//!   - How the fees are paid via [`Config::OnChargeTransaction`].
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+
+use frame_support::{
+	dispatch::{
+		DispatchClass, DispatchInfo, DispatchResult, GetDispatchInfo, Pays, PostDispatchInfo,
+	},
+	traits::{Defensive, EstimateCallFee, Get},
+	weights::{Weight, WeightToFee},
+};
+pub use pallet::*;
+pub use payment::*;
+use sp_runtime::{
+	traits::{
+		Convert, DispatchInfoOf, Dispatchable, One, PostDispatchInfoOf, SaturatedConversion,
+		Saturating, SignedExtension, Zero,
+	},
+	transaction_validity::{
+		TransactionPriority, TransactionValidity, TransactionValidityError, ValidTransaction,
+	},
+	FixedPointNumber, FixedU128, Perbill, Perquintill, RuntimeDebug,
+};
+use sp_std::prelude::*;
+pub use types::{FeeDetails, InclusionFee, RuntimeDispatchInfo};
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+mod payment;
+mod types;
+
+/// Fee multiplier.
+pub type Multiplier = FixedU128;
+
+type BalanceOf<T> = <<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::Balance;
+
+/// A struct to update the weight multiplier per block. It implements `Convert<Multiplier,
+/// Multiplier>`, meaning that it can convert the previous multiplier to the next one. This should
+/// be called on `on_finalize` of a block, prior to potentially cleaning the weight data from the
+/// system pallet.
+///
+/// given:
+/// 	s = previous block weight
+/// 	s'= ideal block weight
+/// 	m = maximum block weight
+/// 		diff = (s - s')/m
+/// 		v = 0.00001
+/// 		t1 = (v * diff)
+/// 		t2 = (v * diff)^2 / 2
+/// 	then:
+/// 	next_multiplier = prev_multiplier * (1 + t1 + t2)
+///
+/// Where `(s', v)` must be given as the `Get` implementation of the `T` generic type. Moreover, `M`
+/// must provide the minimum allowed value for the multiplier. Note that a runtime should ensure
+/// with tests that the combination of this `M` and `V` is not such that the multiplier can drop to
+/// zero and never recover.
+///
+/// Note that `s'` is interpreted as a portion in the _normal transaction_ capacity of the block.
+/// For example, given `s' == 0.25` and `AvailableBlockRatio = 0.75`, then the target fullness is
+/// _0.25 of the normal capacity_ and _0.1875 of the entire block_.
+///
+/// Since block weight is multi-dimension, we use the scarcer resource, referred as limiting
+/// dimension, for calculation of fees. We determine the limiting dimension by comparing the
+/// dimensions using the ratio of `dimension_value / max_dimension_value` and selecting the largest
+/// ratio. For instance, if a block is 30% full based on `ref_time` and 25% full based on
+/// `proof_size`, we identify `ref_time` as the limiting dimension, indicating that the block is 30%
+/// full.
+///
+/// This implementation implies the bound:
+/// - `v ≤ p / k * (s − s')`
+/// - or, solving for `p`: `p >= v * k * (s - s')`
+///
+/// where `p` is the amount of change over `k` blocks.
+///
+/// Hence:
+/// - in a fully congested chain: `p >= v * k * (1 - s')`.
+/// - in an empty chain: `p >= v * k * (-s')`.
+///
+/// For example, when all blocks are full and there are 28800 blocks per day (default in
+/// `substrate-node`) and v == 0.00001, s' == 0.1875, we'd have:
+///
+/// p >= 0.00001 * 28800 * 0.8125
+/// p >= 0.234
+///
+/// Meaning that fees can change by around ~23% per day, given extreme congestion.
+///
+/// More info can be found at:
+/// <https://research.web3.foundation/en/latest/polkadot/overview/2-token-economics.html>
+pub struct TargetedFeeAdjustment<T, S, V, M, X>(sp_std::marker::PhantomData<(T, S, V, M, X)>);
+
+/// Something that can convert the current multiplier to the next one.
+pub trait MultiplierUpdate: Convert<Multiplier, Multiplier> {
+	/// Minimum multiplier. Any outcome of the `convert` function should be at least this.
+	fn min() -> Multiplier;
+	/// Maximum multiplier. Any outcome of the `convert` function should be less or equal this.
+	fn max() -> Multiplier;
+	/// Target block saturation level
+	fn target() -> Perquintill;
+	/// Variability factor
+	fn variability() -> Multiplier;
+}
+
+impl MultiplierUpdate for () {
+	fn min() -> Multiplier {
+		Default::default()
+	}
+	fn max() -> Multiplier {
+		<Multiplier as sp_runtime::traits::Bounded>::max_value()
+	}
+	fn target() -> Perquintill {
+		Default::default()
+	}
+	fn variability() -> Multiplier {
+		Default::default()
+	}
+}
+
+impl<T, S, V, M, X> MultiplierUpdate for TargetedFeeAdjustment<T, S, V, M, X>
+where
+	T: frame_system::Config,
+	S: Get<Perquintill>,
+	V: Get<Multiplier>,
+	M: Get<Multiplier>,
+	X: Get<Multiplier>,
+{
+	fn min() -> Multiplier {
+		M::get()
+	}
+	fn max() -> Multiplier {
+		X::get()
+	}
+	fn target() -> Perquintill {
+		S::get()
+	}
+	fn variability() -> Multiplier {
+		V::get()
+	}
+}
+
+impl<T, S, V, M, X> Convert<Multiplier, Multiplier> for TargetedFeeAdjustment<T, S, V, M, X>
+where
+	T: frame_system::Config,
+	S: Get<Perquintill>,
+	V: Get<Multiplier>,
+	M: Get<Multiplier>,
+	X: Get<Multiplier>,
+{
+	fn convert(previous: Multiplier) -> Multiplier {
+		// Defensive only. The multiplier in storage should always be at most positive. Nonetheless
+		// we recover here in case of errors, because any value below this would be stale and can
+		// never change.
+		let min_multiplier = M::get();
+		let max_multiplier = X::get();
+		let previous = previous.max(min_multiplier);
+
+		let weights = T::BlockWeights::get();
+		// the computed ratio is only among the normal class.
+		let normal_max_weight =
+			weights.get(DispatchClass::Normal).max_total.unwrap_or(weights.max_block);
+		let current_block_weight = <frame_system::Pallet<T>>::block_weight();
+		let normal_block_weight =
+			current_block_weight.get(DispatchClass::Normal).min(normal_max_weight);
+
+		// Normalize dimensions so they can be compared. Ensure (defensive) max weight is non-zero.
+		let normalized_ref_time = Perbill::from_rational(
+			normal_block_weight.ref_time(),
+			normal_max_weight.ref_time().max(1),
+		);
+		let normalized_proof_size = Perbill::from_rational(
+			normal_block_weight.proof_size(),
+			normal_max_weight.proof_size().max(1),
+		);
+
+		// Pick the limiting dimension. If the proof size is the limiting dimension, then the
+		// multiplier is adjusted by the proof size. Otherwise, it is adjusted by the ref time.
+		let (normal_limiting_dimension, max_limiting_dimension) =
+			if normalized_ref_time < normalized_proof_size {
+				(normal_block_weight.proof_size(), normal_max_weight.proof_size())
+			} else {
+				(normal_block_weight.ref_time(), normal_max_weight.ref_time())
+			};
+
+		let target_block_fullness = S::get();
+		let adjustment_variable = V::get();
+
+		let target_weight = (target_block_fullness * max_limiting_dimension) as u128;
+		let block_weight = normal_limiting_dimension as u128;
+
+		// determines if the first_term is positive
+		let positive = block_weight >= target_weight;
+		let diff_abs = block_weight.max(target_weight) - block_weight.min(target_weight);
+
+		// defensive only, a test case assures that the maximum weight diff can fit in Multiplier
+		// without any saturation.
+		let diff = Multiplier::saturating_from_rational(diff_abs, max_limiting_dimension.max(1));
+		let diff_squared = diff.saturating_mul(diff);
+
+		let v_squared_2 = adjustment_variable.saturating_mul(adjustment_variable) /
+			Multiplier::saturating_from_integer(2);
+
+		let first_term = adjustment_variable.saturating_mul(diff);
+		let second_term = v_squared_2.saturating_mul(diff_squared);
+
+		if positive {
+			let excess = first_term.saturating_add(second_term).saturating_mul(previous);
+			previous.saturating_add(excess).clamp(min_multiplier, max_multiplier)
+		} else {
+			// Defensive-only: first_term > second_term. Safe subtraction.
+			let negative = first_term.saturating_sub(second_term).saturating_mul(previous);
+			previous.saturating_sub(negative).clamp(min_multiplier, max_multiplier)
+		}
+	}
+}
+
+/// A struct to make the fee multiplier a constant
+pub struct ConstFeeMultiplier<M: Get<Multiplier>>(sp_std::marker::PhantomData<M>);
+
+impl<M: Get<Multiplier>> MultiplierUpdate for ConstFeeMultiplier<M> {
+	fn min() -> Multiplier {
+		M::get()
+	}
+	fn max() -> Multiplier {
+		M::get()
+	}
+	fn target() -> Perquintill {
+		Default::default()
+	}
+	fn variability() -> Multiplier {
+		Default::default()
+	}
+}
+
+impl<M> Convert<Multiplier, Multiplier> for ConstFeeMultiplier<M>
+where
+	M: Get<Multiplier>,
+{
+	fn convert(_previous: Multiplier) -> Multiplier {
+		Self::min()
+	}
+}
+
+/// Storage releases of the pallet.
+#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+enum Releases {
+	/// Original version of the pallet.
+	V1Ancient,
+	/// One that bumps the usage to FixedU128 from FixedI128.
+	V2,
+}
+
+impl Default for Releases {
+	fn default() -> Self {
+		Releases::V1Ancient
+	}
+}
+
+/// Default value for NextFeeMultiplier. This is used in genesis and is also used in
+/// NextFeeMultiplierOnEmpty() to provide a value when none exists in storage.
+const MULTIPLIER_DEFAULT_VALUE: Multiplier = Multiplier::from_u32(1);
+
+#[frame_support::pallet]
+pub mod pallet {
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	use super::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Handler for withdrawing, refunding and depositing the transaction fee.
+		/// Transaction fees are withdrawn before the transaction is executed.
+		/// After the transaction was executed the transaction weight can be
+		/// adjusted, depending on the used resources by the transaction. If the
+		/// transaction weight is lower than expected, parts of the transaction fee
+		/// might be refunded. In the end the fees can be deposited.
+		type OnChargeTransaction: OnChargeTransaction<Self>;
+
+		/// A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their
+		/// `priority`
+		///
+		/// This value is multipled by the `final_fee` to obtain a "virtual tip" that is later
+		/// added to a tip component in regular `priority` calculations.
+		/// It means that a `Normal` transaction can front-run a similarly-sized `Operational`
+		/// extrinsic (with no tip), by including a tip value greater than the virtual tip.
+		///
+		/// ```rust,ignore
+		/// // For `Normal`
+		/// let priority = priority_calc(tip);
+		///
+		/// // For `Operational`
+		/// let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;
+		/// let priority = priority_calc(tip + virtual_tip);
+		/// ```
+		///
+		/// Note that since we use `final_fee` the multiplier applies also to the regular `tip`
+		/// sent with the transaction. So, not only does the transaction get a priority bump based
+		/// on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`
+		/// transactions.
+		#[pallet::constant]
+		type OperationalFeeMultiplier: Get<u8>;
+
+		/// Convert a weight value into a deductible fee based on the currency type.
+		type WeightToFee: WeightToFee<Balance = BalanceOf<Self>>;
+
+		/// Convert a length value into a deductible fee based on the currency type.
+		type LengthToFee: WeightToFee<Balance = BalanceOf<Self>>;
+
+		/// Update the multiplier of the next block, based on the previous block's weight.
+		type FeeMultiplierUpdate: MultiplierUpdate;
+	}
+
+	#[pallet::type_value]
+	pub fn NextFeeMultiplierOnEmpty() -> Multiplier {
+		MULTIPLIER_DEFAULT_VALUE
+	}
+
+	#[pallet::storage]
+	#[pallet::getter(fn next_fee_multiplier)]
+	pub type NextFeeMultiplier<T: Config> =
+		StorageValue<_, Multiplier, ValueQuery, NextFeeMultiplierOnEmpty>;
+
+	#[pallet::storage]
+	pub(super) type StorageVersion<T: Config> = StorageValue<_, Releases, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub multiplier: Multiplier,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			Self { multiplier: MULTIPLIER_DEFAULT_VALUE, _config: Default::default() }
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			StorageVersion::<T>::put(Releases::V2);
+			NextFeeMultiplier::<T>::put(self.multiplier);
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
+		/// has been paid by `who`.
+		TransactionFeePaid { who: T::AccountId, actual_fee: BalanceOf<T>, tip: BalanceOf<T> },
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_finalize(_: frame_system::pallet_prelude::BlockNumberFor<T>) {
+			<NextFeeMultiplier<T>>::mutate(|fm| {
+				*fm = T::FeeMultiplierUpdate::convert(*fm);
+			});
+		}
+
+		#[cfg(feature = "std")]
+		fn integrity_test() {
+			// given weight == u64, we build multipliers from `diff` of two weight values, which can
+			// at most be maximum block weight. Make sure that this can fit in a multiplier without
+			// loss.
+			assert!(
+				<Multiplier as sp_runtime::traits::Bounded>::max_value() >=
+					Multiplier::checked_from_integer::<u128>(
+						T::BlockWeights::get().max_block.ref_time().try_into().unwrap()
+					)
+					.unwrap(),
+			);
+
+			let target = T::FeeMultiplierUpdate::target() *
+				T::BlockWeights::get().get(DispatchClass::Normal).max_total.expect(
+					"Setting `max_total` for `Normal` dispatch class is not compatible with \
+					`transaction-payment` pallet.",
+				);
+			// add 1 percent;
+			let addition = target / 100;
+			if addition == Weight::zero() {
+				// this is most likely because in a test setup we set everything to ()
+				// or to `ConstFeeMultiplier`.
+				return
+			}
+
+			// This is the minimum value of the multiplier. Make sure that if we collapse to this
+			// value, we can recover with a reasonable amount of traffic. For this test we assert
+			// that if we collapse to minimum, the trend will be positive with a weight value which
+			// is 1% more than the target.
+			let min_value = T::FeeMultiplierUpdate::min();
+			let target = target + addition;
+
+			<frame_system::Pallet<T>>::set_block_consumed_resources(target, 0);
+			let next = T::FeeMultiplierUpdate::convert(min_value);
+			assert!(
+				next > min_value,
+				"The minimum bound of the multiplier is too low. When \
+				block saturation is more than target by 1% and multiplier is minimal then \
+				the multiplier doesn't increase."
+			);
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Query the data that we know about the fee of a given `call`.
+	///
+	/// This pallet is not and cannot be aware of the internals of a signed extension, for example
+	/// a tip. It only interprets the extrinsic as some encoded value and accounts for its weight
+	/// and length, the runtime's extrinsic base weight, and the current fee multiplier.
+	///
+	/// All dispatchables must be annotated with weight and will have some fee info. This function
+	/// always returns.
+	pub fn query_info<Extrinsic: sp_runtime::traits::Extrinsic + GetDispatchInfo>(
+		unchecked_extrinsic: Extrinsic,
+		len: u32,
+	) -> RuntimeDispatchInfo<BalanceOf<T>>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+	{
+		// NOTE: we can actually make it understand `ChargeTransactionPayment`, but would be some
+		// hassle for sure. We have to make it aware of the index of `ChargeTransactionPayment` in
+		// `Extra`. Alternatively, we could actually execute the tx's per-dispatch and record the
+		// balance of the sender before and after the pipeline.. but this is way too much hassle for
+		// a very very little potential gain in the future.
+		let dispatch_info = <Extrinsic as GetDispatchInfo>::get_dispatch_info(&unchecked_extrinsic);
+
+		let partial_fee = if unchecked_extrinsic.is_signed().unwrap_or(false) {
+			Self::compute_fee(len, &dispatch_info, 0u32.into())
+		} else {
+			// Unsigned extrinsics have no partial fee.
+			0u32.into()
+		};
+
+		let DispatchInfo { weight, class, .. } = dispatch_info;
+
+		RuntimeDispatchInfo { weight, class, partial_fee }
+	}
+
+	/// Query the detailed fee of a given `call`.
+	pub fn query_fee_details<Extrinsic: sp_runtime::traits::Extrinsic + GetDispatchInfo>(
+		unchecked_extrinsic: Extrinsic,
+		len: u32,
+	) -> FeeDetails<BalanceOf<T>>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+	{
+		let dispatch_info = <Extrinsic as GetDispatchInfo>::get_dispatch_info(&unchecked_extrinsic);
+
+		let tip = 0u32.into();
+
+		if unchecked_extrinsic.is_signed().unwrap_or(false) {
+			Self::compute_fee_details(len, &dispatch_info, tip)
+		} else {
+			// Unsigned extrinsics have no inclusion fee.
+			FeeDetails { inclusion_fee: None, tip }
+		}
+	}
+
+	/// Query information of a dispatch class, weight, and fee of a given encoded `Call`.
+	pub fn query_call_info(call: T::RuntimeCall, len: u32) -> RuntimeDispatchInfo<BalanceOf<T>>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo> + GetDispatchInfo,
+	{
+		let dispatch_info = <T::RuntimeCall as GetDispatchInfo>::get_dispatch_info(&call);
+		let DispatchInfo { weight, class, .. } = dispatch_info;
+
+		RuntimeDispatchInfo {
+			weight,
+			class,
+			partial_fee: Self::compute_fee(len, &dispatch_info, 0u32.into()),
+		}
+	}
+
+	/// Query fee details of a given encoded `Call`.
+	pub fn query_call_fee_details(call: T::RuntimeCall, len: u32) -> FeeDetails<BalanceOf<T>>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo> + GetDispatchInfo,
+	{
+		let dispatch_info = <T::RuntimeCall as GetDispatchInfo>::get_dispatch_info(&call);
+		let tip = 0u32.into();
+
+		Self::compute_fee_details(len, &dispatch_info, tip)
+	}
+
+	/// Compute the final fee value for a particular transaction.
+	pub fn compute_fee(
+		len: u32,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		tip: BalanceOf<T>,
+	) -> BalanceOf<T>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+	{
+		Self::compute_fee_details(len, info, tip).final_fee()
+	}
+
+	/// Compute the fee details for a particular transaction.
+	pub fn compute_fee_details(
+		len: u32,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		tip: BalanceOf<T>,
+	) -> FeeDetails<BalanceOf<T>>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo>,
+	{
+		Self::compute_fee_raw(len, info.weight, tip, info.pays_fee, info.class)
+	}
+
+	/// Compute the actual post dispatch fee for a particular transaction.
+	///
+	/// Identical to `compute_fee` with the only difference that the post dispatch corrected
+	/// weight is used for the weight fee calculation.
+	pub fn compute_actual_fee(
+		len: u32,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		tip: BalanceOf<T>,
+	) -> BalanceOf<T>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	{
+		Self::compute_actual_fee_details(len, info, post_info, tip).final_fee()
+	}
+
+	/// Compute the actual post dispatch fee details for a particular transaction.
+	pub fn compute_actual_fee_details(
+		len: u32,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		tip: BalanceOf<T>,
+	) -> FeeDetails<BalanceOf<T>>
+	where
+		T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	{
+		Self::compute_fee_raw(
+			len,
+			post_info.calc_actual_weight(info),
+			tip,
+			post_info.pays_fee(info),
+			info.class,
+		)
+	}
+
+	fn compute_fee_raw(
+		len: u32,
+		weight: Weight,
+		tip: BalanceOf<T>,
+		pays_fee: Pays,
+		class: DispatchClass,
+	) -> FeeDetails<BalanceOf<T>> {
+		if pays_fee == Pays::Yes {
+			// the adjustable part of the fee.
+			let unadjusted_weight_fee = Self::weight_to_fee(weight);
+			let multiplier = Self::next_fee_multiplier();
+			// final adjusted weight fee.
+			let adjusted_weight_fee = multiplier.saturating_mul_int(unadjusted_weight_fee);
+
+			// length fee. this is adjusted via `LengthToFee`.
+			let len_fee = Self::length_to_fee(len);
+
+			let base_fee = Self::weight_to_fee(T::BlockWeights::get().get(class).base_extrinsic);
+			FeeDetails {
+				inclusion_fee: Some(InclusionFee { base_fee, len_fee, adjusted_weight_fee }),
+				tip,
+			}
+		} else {
+			FeeDetails { inclusion_fee: None, tip }
+		}
+	}
+
+	/// Compute the length portion of a fee by invoking the configured `LengthToFee` impl.
+	pub fn length_to_fee(length: u32) -> BalanceOf<T> {
+		T::LengthToFee::weight_to_fee(&Weight::from_parts(length as u64, 0))
+	}
+
+	/// Compute the unadjusted portion of the weight fee by invoking the configured `WeightToFee`
+	/// impl. Note that the input `weight` is capped by the maximum block weight before computation.
+	pub fn weight_to_fee(weight: Weight) -> BalanceOf<T> {
+		// cap the weight to the maximum defined in runtime, otherwise it will be the
+		// `Bounded` maximum of its data type, which is not desired.
+		let capped_weight = weight.min(T::BlockWeights::get().max_block);
+		T::WeightToFee::weight_to_fee(&capped_weight)
+	}
+}
+
+impl<T> Convert<Weight, BalanceOf<T>> for Pallet<T>
+where
+	T: Config,
+{
+	/// Compute the fee for the specified weight.
+	///
+	/// This fee is already adjusted by the per block fee adjustment factor and is therefore the
+	/// share that the weight contributes to the overall fee of a transaction. It is mainly
+	/// for informational purposes and not used in the actual fee calculation.
+	fn convert(weight: Weight) -> BalanceOf<T> {
+		<NextFeeMultiplier<T>>::get().saturating_mul_int(Self::weight_to_fee(weight))
+	}
+}
+
+/// Require the transactor pay for themselves and maybe include a tip to gain additional priority
+/// in the queue.
+///
+/// # Transaction Validity
+///
+/// This extension sets the `priority` field of `TransactionValidity` depending on the amount
+/// of tip being paid per weight unit.
+///
+/// Operational transactions will receive an additional priority bump, so that they are normally
+/// considered before regular transactions.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct ChargeTransactionPayment<T: Config>(#[codec(compact)] BalanceOf<T>);
+
+impl<T: Config> ChargeTransactionPayment<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+	BalanceOf<T>: Send + Sync,
+{
+	/// utility constructor. Used only in client/factory code.
+	pub fn from(fee: BalanceOf<T>) -> Self {
+		Self(fee)
+	}
+
+	/// Returns the tip as being chosen by the transaction sender.
+	pub fn tip(&self) -> BalanceOf<T> {
+		self.0
+	}
+
+	fn withdraw_fee(
+		&self,
+		who: &T::AccountId,
+		call: &T::RuntimeCall,
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		len: usize,
+	) -> Result<
+		(
+			BalanceOf<T>,
+			<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::LiquidityInfo,
+		),
+		TransactionValidityError,
+	> {
+		let tip = self.0;
+		let fee = Pallet::<T>::compute_fee(len as u32, info, tip);
+
+		<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::withdraw_fee(
+			who, call, info, fee, tip,
+		)
+		.map(|i| (fee, i))
+	}
+
+	/// Get an appropriate priority for a transaction with the given `DispatchInfo`, encoded length
+	/// and user-included tip.
+	///
+	/// The priority is based on the amount of `tip` the user is willing to pay per unit of either
+	/// `weight` or `length`, depending which one is more limiting. For `Operational` extrinsics
+	/// we add a "virtual tip" to the calculations.
+	///
+	/// The formula should simply be `tip / bounded_{weight|length}`, but since we are using
+	/// integer division, we have no guarantees it's going to give results in any reasonable
+	/// range (might simply end up being zero). Hence we use a scaling factor:
+	/// `tip * (max_block_{weight|length} / bounded_{weight|length})`, since given current
+	/// state of-the-art blockchains, number of per-block transactions is expected to be in a
+	/// range reasonable enough to not saturate the `Balance` type while multiplying by the tip.
+	pub fn get_priority(
+		info: &DispatchInfoOf<T::RuntimeCall>,
+		len: usize,
+		tip: BalanceOf<T>,
+		final_fee: BalanceOf<T>,
+	) -> TransactionPriority {
+		// Calculate how many such extrinsics we could fit into an empty block and take the
+		// limiting factor.
+		let max_block_weight = T::BlockWeights::get().max_block;
+		let max_block_length = *T::BlockLength::get().max.get(info.class) as u64;
+
+		// bounded_weight is used as a divisor later so we keep it non-zero.
+		let bounded_weight = info.weight.max(Weight::from_parts(1, 1)).min(max_block_weight);
+		let bounded_length = (len as u64).clamp(1, max_block_length);
+
+		// returns the scarce resource, i.e. the one that is limiting the number of transactions.
+		let max_tx_per_block_weight = max_block_weight
+			.checked_div_per_component(&bounded_weight)
+			.defensive_proof("bounded_weight is non-zero; qed")
+			.unwrap_or(1);
+		let max_tx_per_block_length = max_block_length / bounded_length;
+		// Given our current knowledge this value is going to be in a reasonable range - i.e.
+		// less than 10^9 (2^30), so multiplying by the `tip` value is unlikely to overflow the
+		// balance type. We still use saturating ops obviously, but the point is to end up with some
+		// `priority` distribution instead of having all transactions saturate the priority.
+		let max_tx_per_block = max_tx_per_block_length
+			.min(max_tx_per_block_weight)
+			.saturated_into::<BalanceOf<T>>();
+		let max_reward = |val: BalanceOf<T>| val.saturating_mul(max_tx_per_block);
+
+		// To distribute no-tip transactions a little bit, we increase the tip value by one.
+		// This means that given two transactions without a tip, smaller one will be preferred.
+		let tip = tip.saturating_add(One::one());
+		let scaled_tip = max_reward(tip);
+
+		match info.class {
+			DispatchClass::Normal => {
+				// For normal class we simply take the `tip_per_weight`.
+				scaled_tip
+			},
+			DispatchClass::Mandatory => {
+				// Mandatory extrinsics should be prohibited (e.g. by the [`CheckWeight`]
+				// extensions), but just to be safe let's return the same priority as `Normal` here.
+				scaled_tip
+			},
+			DispatchClass::Operational => {
+				// A "virtual tip" value added to an `Operational` extrinsic.
+				// This value should be kept high enough to allow `Operational` extrinsics
+				// to get in even during congestion period, but at the same time low
+				// enough to prevent a possible spam attack by sending invalid operational
+				// extrinsics which push away regular transactions from the pool.
+				let fee_multiplier = T::OperationalFeeMultiplier::get().saturated_into();
+				let virtual_tip = final_fee.saturating_mul(fee_multiplier);
+				let scaled_virtual_tip = max_reward(virtual_tip);
+
+				scaled_tip.saturating_add(scaled_virtual_tip)
+			},
+		}
+		.saturated_into::<TransactionPriority>()
+	}
+}
+
+impl<T: Config> sp_std::fmt::Debug for ChargeTransactionPayment<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "ChargeTransactionPayment<{:?}>", self.0)
+	}
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T: Config> SignedExtension for ChargeTransactionPayment<T>
+where
+	BalanceOf<T>: Send + Sync + From<u64>,
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+{
+	const IDENTIFIER: &'static str = "ChargeTransactionPayment";
+	type AccountId = T::AccountId;
+	type Call = T::RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = (
+		// tip
+		BalanceOf<T>,
+		// who paid the fee - this is an option to allow for a Default impl.
+		Self::AccountId,
+		// imbalance resulting from withdrawing the fee
+		<<T as Config>::OnChargeTransaction as OnChargeTransaction<T>>::LiquidityInfo,
+	);
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		let (final_fee, _) = self.withdraw_fee(who, call, info, len)?;
+		let tip = self.0;
+		Ok(ValidTransaction {
+			priority: Self::get_priority(info, len, tip, final_fee),
+			..Default::default()
+		})
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		let (_fee, imbalance) = self.withdraw_fee(who, call, info, len)?;
+		Ok((self.0, who.clone(), imbalance))
+	}
+
+	fn post_dispatch(
+		maybe_pre: Option<Self::Pre>,
+		info: &DispatchInfoOf<Self::Call>,
+		post_info: &PostDispatchInfoOf<Self::Call>,
+		len: usize,
+		_result: &DispatchResult,
+	) -> Result<(), TransactionValidityError> {
+		if let Some((tip, who, imbalance)) = maybe_pre {
+			let actual_fee = Pallet::<T>::compute_actual_fee(len as u32, info, post_info, tip);
+			T::OnChargeTransaction::correct_and_deposit_fee(
+				&who, info, post_info, actual_fee, tip, imbalance,
+			)?;
+			Pallet::<T>::deposit_event(Event::<T>::TransactionFeePaid { who, actual_fee, tip });
+		}
+		Ok(())
+	}
+}
+
+impl<T: Config, AnyCall: GetDispatchInfo + Encode> EstimateCallFee<AnyCall, BalanceOf<T>>
+	for Pallet<T>
+where
+	T::RuntimeCall: Dispatchable<Info = DispatchInfo, PostInfo = PostDispatchInfo>,
+{
+	fn estimate_call_fee(call: &AnyCall, post_info: PostDispatchInfo) -> BalanceOf<T> {
+		let len = call.encoded_size() as u32;
+		let info = call.get_dispatch_info();
+		Self::compute_actual_fee(len, &info, &post_info, Zero::zero())
+	}
+}
diff --git a/substrate/frame/transaction-payment/src/mock.rs b/substrate/frame/transaction-payment/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..97253be463058ce94bf103ef0e03c5243ea29eec
--- /dev/null
+++ b/substrate/frame/transaction-payment/src/mock.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 crate as pallet_transaction_payment;
+
+use sp_core::H256;
+use sp_runtime::traits::{BlakeTwo256, IdentityLookup};
+
+use frame_support::{
+	dispatch::DispatchClass,
+	parameter_types,
+	traits::{ConstU32, ConstU64, Imbalance, OnUnbalanced},
+	weights::{Weight, WeightToFee as WeightToFeeT},
+};
+use frame_system as system;
+use pallet_balances::Call as BalancesCall;
+
+type Block = frame_system::mocking::MockBlock<Runtime>;
+
+frame_support::construct_runtime!(
+	pub struct Runtime
+	{
+		System: system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		TransactionPayment: pallet_transaction_payment::{Pallet, Storage, Event<T>},
+	}
+);
+
+pub(crate) const CALL: &<Runtime as frame_system::Config>::RuntimeCall =
+	&RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
+
+parameter_types! {
+	pub(crate) static ExtrinsicBaseWeight: Weight = Weight::zero();
+}
+
+pub struct BlockWeights;
+impl Get<frame_system::limits::BlockWeights> for BlockWeights {
+	fn get() -> frame_system::limits::BlockWeights {
+		frame_system::limits::BlockWeights::builder()
+			.base_block(Weight::zero())
+			.for_class(DispatchClass::all(), |weights| {
+				weights.base_extrinsic = ExtrinsicBaseWeight::get().into();
+			})
+			.for_class(DispatchClass::non_mandatory(), |weights| {
+				weights.max_total = Weight::from_parts(1024, u64::MAX).into();
+			})
+			.build_or_panic()
+	}
+}
+
+parameter_types! {
+	pub static WeightToFee: u64 = 1;
+	pub static TransactionByteFee: u64 = 1;
+	pub static OperationalFeeMultiplier: u8 = 5;
+}
+
+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>;
+}
+
+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 MaxHolds = ();
+}
+
+impl WeightToFeeT for WeightToFee {
+	type Balance = u64;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time())
+			.saturating_mul(WEIGHT_TO_FEE.with(|v| *v.borrow()))
+	}
+}
+
+impl WeightToFeeT for TransactionByteFee {
+	type Balance = u64;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time())
+			.saturating_mul(TRANSACTION_BYTE_FEE.with(|v| *v.borrow()))
+	}
+}
+
+parameter_types! {
+	pub(crate) static TipUnbalancedAmount: u64 = 0;
+	pub(crate) static FeeUnbalancedAmount: u64 = 0;
+}
+
+pub struct DealWithFees;
+impl OnUnbalanced<pallet_balances::NegativeImbalance<Runtime>> for DealWithFees {
+	fn on_unbalanceds<B>(
+		mut fees_then_tips: impl Iterator<Item = pallet_balances::NegativeImbalance<Runtime>>,
+	) {
+		if let Some(fees) = fees_then_tips.next() {
+			FeeUnbalancedAmount::mutate(|a| *a += fees.peek());
+			if let Some(tips) = fees_then_tips.next() {
+				TipUnbalancedAmount::mutate(|a| *a += tips.peek());
+			}
+		}
+	}
+}
+
+impl Config for Runtime {
+	type RuntimeEvent = RuntimeEvent;
+	type OnChargeTransaction = CurrencyAdapter<Balances, DealWithFees>;
+	type OperationalFeeMultiplier = OperationalFeeMultiplier;
+	type WeightToFee = WeightToFee;
+	type LengthToFee = TransactionByteFee;
+	type FeeMultiplierUpdate = ();
+}
diff --git a/substrate/frame/transaction-payment/src/payment.rs b/substrate/frame/transaction-payment/src/payment.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bc871deafdc8bc2a56987c58c123ca8014deb671
--- /dev/null
+++ b/substrate/frame/transaction-payment/src/payment.rs
@@ -0,0 +1,139 @@
+/// ! Traits and default implementation for paying transaction fees.
+use crate::Config;
+
+use sp_runtime::{
+	traits::{DispatchInfoOf, PostDispatchInfoOf, Saturating, Zero},
+	transaction_validity::InvalidTransaction,
+};
+use sp_std::marker::PhantomData;
+
+use frame_support::{
+	traits::{Currency, ExistenceRequirement, Imbalance, OnUnbalanced, WithdrawReasons},
+	unsigned::TransactionValidityError,
+};
+
+type NegativeImbalanceOf<C, T> =
+	<C as Currency<<T as frame_system::Config>::AccountId>>::NegativeImbalance;
+
+/// Handle withdrawing, refunding and depositing of transaction fees.
+pub trait OnChargeTransaction<T: Config> {
+	/// The underlying integer type in which fees are calculated.
+	type Balance: frame_support::traits::tokens::Balance;
+
+	type LiquidityInfo: Default;
+
+	/// Before the transaction is executed the payment of the transaction fees
+	/// need to be secured.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	fn withdraw_fee(
+		who: &T::AccountId,
+		call: &T::RuntimeCall,
+		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		fee: Self::Balance,
+		tip: Self::Balance,
+	) -> Result<Self::LiquidityInfo, TransactionValidityError>;
+
+	/// After the transaction was executed the actual fee can be calculated.
+	/// This function should refund any overpaid fees and optionally deposit
+	/// the corrected amount.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	fn correct_and_deposit_fee(
+		who: &T::AccountId,
+		dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		corrected_fee: Self::Balance,
+		tip: Self::Balance,
+		already_withdrawn: Self::LiquidityInfo,
+	) -> Result<(), TransactionValidityError>;
+}
+
+/// Implements the transaction payment for a pallet implementing the `Currency`
+/// trait (eg. the pallet_balances) using an unbalance handler (implementing
+/// `OnUnbalanced`).
+///
+/// The unbalance handler is given 2 unbalanceds in [`OnUnbalanced::on_unbalanceds`]: fee and
+/// then tip.
+pub struct CurrencyAdapter<C, OU>(PhantomData<(C, OU)>);
+
+/// Default implementation for a Currency and an OnUnbalanced handler.
+///
+/// The unbalance handler is given 2 unbalanceds in [`OnUnbalanced::on_unbalanceds`]: fee and
+/// then tip.
+impl<T, C, OU> OnChargeTransaction<T> for CurrencyAdapter<C, OU>
+where
+	T: Config,
+	C: Currency<<T as frame_system::Config>::AccountId>,
+	C::PositiveImbalance: Imbalance<
+		<C as Currency<<T as frame_system::Config>::AccountId>>::Balance,
+		Opposite = C::NegativeImbalance,
+	>,
+	C::NegativeImbalance: Imbalance<
+		<C as Currency<<T as frame_system::Config>::AccountId>>::Balance,
+		Opposite = C::PositiveImbalance,
+	>,
+	OU: OnUnbalanced<NegativeImbalanceOf<C, T>>,
+{
+	type LiquidityInfo = Option<NegativeImbalanceOf<C, T>>;
+	type Balance = <C as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+	/// Withdraw the predicted fee from the transaction origin.
+	///
+	/// Note: The `fee` already includes the `tip`.
+	fn withdraw_fee(
+		who: &T::AccountId,
+		_call: &T::RuntimeCall,
+		_info: &DispatchInfoOf<T::RuntimeCall>,
+		fee: Self::Balance,
+		tip: Self::Balance,
+	) -> Result<Self::LiquidityInfo, TransactionValidityError> {
+		if fee.is_zero() {
+			return Ok(None)
+		}
+
+		let withdraw_reason = if tip.is_zero() {
+			WithdrawReasons::TRANSACTION_PAYMENT
+		} else {
+			WithdrawReasons::TRANSACTION_PAYMENT | WithdrawReasons::TIP
+		};
+
+		match C::withdraw(who, fee, withdraw_reason, ExistenceRequirement::KeepAlive) {
+			Ok(imbalance) => Ok(Some(imbalance)),
+			Err(_) => Err(InvalidTransaction::Payment.into()),
+		}
+	}
+
+	/// Hand the fee and the tip over to the `[OnUnbalanced]` implementation.
+	/// Since the predicted fee might have been too high, parts of the fee may
+	/// be refunded.
+	///
+	/// Note: The `corrected_fee` already includes the `tip`.
+	fn correct_and_deposit_fee(
+		who: &T::AccountId,
+		_dispatch_info: &DispatchInfoOf<T::RuntimeCall>,
+		_post_info: &PostDispatchInfoOf<T::RuntimeCall>,
+		corrected_fee: Self::Balance,
+		tip: Self::Balance,
+		already_withdrawn: Self::LiquidityInfo,
+	) -> Result<(), TransactionValidityError> {
+		if let Some(paid) = already_withdrawn {
+			// Calculate how much refund we should return
+			let refund_amount = paid.peek().saturating_sub(corrected_fee);
+			// refund to the the account that paid the fees. If this fails, the
+			// account might have dropped below the existential balance. In
+			// that case we don't refund anything.
+			let refund_imbalance = C::deposit_into_existing(who, refund_amount)
+				.unwrap_or_else(|_| C::PositiveImbalance::zero());
+			// merge the imbalance caused by paying the fees and refunding parts of it again.
+			let adjusted_paid = paid
+				.offset(refund_imbalance)
+				.same()
+				.map_err(|_| TransactionValidityError::Invalid(InvalidTransaction::Payment))?;
+			// Call someone else to handle the imbalance (fee and tip separately)
+			let (tip, fee) = adjusted_paid.split(tip);
+			OU::on_unbalanceds(Some(fee).into_iter().chain(Some(tip)));
+		}
+		Ok(())
+	}
+}
diff --git a/substrate/frame/transaction-payment/src/tests.rs b/substrate/frame/transaction-payment/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d3a1721ccb9909b2f2a705d9bb9ddc9ebc7cb5ee
--- /dev/null
+++ b/substrate/frame/transaction-payment/src/tests.rs
@@ -0,0 +1,843 @@
+// 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 crate as pallet_transaction_payment;
+
+use codec::Encode;
+
+use sp_runtime::{
+	testing::TestXt, traits::One, transaction_validity::InvalidTransaction, BuildStorage,
+};
+
+use frame_support::{
+	assert_noop, assert_ok,
+	dispatch::{DispatchClass, DispatchInfo, GetDispatchInfo, PostDispatchInfo},
+	traits::Currency,
+	weights::Weight,
+};
+use frame_system as system;
+use mock::*;
+use pallet_balances::Call as BalancesCall;
+
+pub struct ExtBuilder {
+	balance_factor: u64,
+	base_weight: Weight,
+	byte_fee: u64,
+	weight_to_fee: u64,
+	initial_multiplier: Option<Multiplier>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self {
+			balance_factor: 1,
+			base_weight: Weight::zero(),
+			byte_fee: 1,
+			weight_to_fee: 1,
+			initial_multiplier: None,
+		}
+	}
+}
+
+impl ExtBuilder {
+	pub fn base_weight(mut self, base_weight: Weight) -> Self {
+		self.base_weight = base_weight;
+		self
+	}
+	pub fn byte_fee(mut self, byte_fee: u64) -> Self {
+		self.byte_fee = byte_fee;
+		self
+	}
+	pub fn weight_fee(mut self, weight_to_fee: u64) -> Self {
+		self.weight_to_fee = weight_to_fee;
+		self
+	}
+	pub fn balance_factor(mut self, factor: u64) -> Self {
+		self.balance_factor = factor;
+		self
+	}
+	pub fn with_initial_multiplier(mut self, multiplier: Multiplier) -> Self {
+		self.initial_multiplier = Some(multiplier);
+		self
+	}
+	fn set_constants(&self) {
+		ExtrinsicBaseWeight::mutate(|v| *v = self.base_weight);
+		TRANSACTION_BYTE_FEE.with(|v| *v.borrow_mut() = self.byte_fee);
+		WEIGHT_TO_FEE.with(|v| *v.borrow_mut() = self.weight_to_fee);
+	}
+	pub fn build(self) -> sp_io::TestExternalities {
+		self.set_constants();
+		let mut t = frame_system::GenesisConfig::<Runtime>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Runtime> {
+			balances: if self.balance_factor > 0 {
+				vec![
+					(1, 10 * self.balance_factor),
+					(2, 20 * self.balance_factor),
+					(3, 30 * self.balance_factor),
+					(4, 40 * self.balance_factor),
+					(5, 50 * self.balance_factor),
+					(6, 60 * self.balance_factor),
+				]
+			} else {
+				vec![]
+			},
+		}
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+		if let Some(multiplier) = self.initial_multiplier {
+			pallet::GenesisConfig::<Runtime> { multiplier, ..Default::default() }
+				.assimilate_storage(&mut t)
+				.unwrap();
+		}
+
+		t.into()
+	}
+}
+
+/// create a transaction info struct from weight. Handy to avoid building the whole struct.
+pub fn info_from_weight(w: Weight) -> DispatchInfo {
+	// pays_fee: Pays::Yes -- class: DispatchClass::Normal
+	DispatchInfo { weight: w, ..Default::default() }
+}
+
+fn post_info_from_weight(w: Weight) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: Some(w), pays_fee: Default::default() }
+}
+
+fn post_info_from_pays(p: Pays) -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: p }
+}
+
+fn default_post_info() -> PostDispatchInfo {
+	PostDispatchInfo { actual_weight: None, pays_fee: Default::default() }
+}
+
+#[test]
+fn signed_extension_transaction_payment_work() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			let len = 10;
+			let pre = ChargeTransactionPayment::<Runtime>::from(0)
+				.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(5, 0)), len)
+				.unwrap();
+			assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10);
+
+			assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(5, 0)),
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(1), 100 - 5 - 5 - 10);
+			assert_eq!(FeeUnbalancedAmount::get(), 5 + 5 + 10);
+			assert_eq!(TipUnbalancedAmount::get(), 0);
+
+			FeeUnbalancedAmount::mutate(|a| *a = 0);
+
+			let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
+				.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
+				.unwrap();
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
+
+			assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(100, 0)),
+				&post_info_from_weight(Weight::from_parts(50, 0)),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 50 - 5);
+			assert_eq!(FeeUnbalancedAmount::get(), 5 + 10 + 50);
+			assert_eq!(TipUnbalancedAmount::get(), 5);
+		});
+}
+
+#[test]
+fn signed_extension_transaction_payment_multiplied_refund_works() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			let len = 10;
+			<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(3, 2));
+
+			let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
+				.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
+				.unwrap();
+			// 5 base fee, 10 byte fee, 3/2 * 100 weight fee, 5 tip
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 150 - 5);
+
+			assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(100, 0)),
+				&post_info_from_weight(Weight::from_parts(50, 0)),
+				len,
+				&Ok(())
+			));
+			// 75 (3/2 of the returned 50 units of weight) is refunded
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 75 - 5);
+		});
+}
+
+#[test]
+fn signed_extension_transaction_payment_is_bounded() {
+	ExtBuilder::default().balance_factor(1000).byte_fee(0).build().execute_with(|| {
+		// maximum weight possible
+		assert_ok!(ChargeTransactionPayment::<Runtime>::from(0).pre_dispatch(
+			&1,
+			CALL,
+			&info_from_weight(Weight::MAX),
+			10
+		));
+		// fee will be proportional to what is the actual maximum weight in the runtime.
+		assert_eq!(
+			Balances::free_balance(&1),
+			(10000 - <Runtime as frame_system::Config>::BlockWeights::get().max_block.ref_time())
+				as u64
+		);
+	});
+}
+
+#[test]
+fn signed_extension_allows_free_transactions() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// 1 ain't have a penny.
+			assert_eq!(Balances::free_balance(1), 0);
+
+			let len = 100;
+
+			// This is a completely free (and thus wholly insecure/DoS-ridden) transaction.
+			let operational_transaction = DispatchInfo {
+				weight: Weight::from_parts(0, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::No,
+			};
+			assert_ok!(ChargeTransactionPayment::<Runtime>::from(0).validate(
+				&1,
+				CALL,
+				&operational_transaction,
+				len
+			));
+
+			// like a InsecureFreeNormal
+			let free_transaction = DispatchInfo {
+				weight: Weight::from_parts(0, 0),
+				class: DispatchClass::Normal,
+				pays_fee: Pays::Yes,
+			};
+			assert_noop!(
+				ChargeTransactionPayment::<Runtime>::from(0).validate(
+					&1,
+					CALL,
+					&free_transaction,
+					len
+				),
+				TransactionValidityError::Invalid(InvalidTransaction::Payment),
+			);
+		});
+}
+
+#[test]
+fn signed_ext_length_fee_is_also_updated_per_congestion() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(5, 0))
+		.balance_factor(10)
+		.build()
+		.execute_with(|| {
+			// all fees should be x1.5
+			<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(3, 2));
+			let len = 10;
+
+			assert_ok!(ChargeTransactionPayment::<Runtime>::from(10) // tipped
+				.pre_dispatch(&1, CALL, &info_from_weight(Weight::from_parts(3, 0)), len));
+			assert_eq!(
+				Balances::free_balance(1),
+				100 // original
+            - 10 // tip
+            - 5 // base
+            - 10 // len
+            - (3 * 3 / 2) // adjusted weight
+			);
+		})
+}
+
+#[test]
+fn query_info_and_fee_details_works() {
+	let call = RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
+	let origin = 111111;
+	let extra = ();
+	let xt = TestXt::new(call.clone(), Some((origin, extra)));
+	let info = xt.get_dispatch_info();
+	let ext = xt.encode();
+	let len = ext.len() as u32;
+
+	let unsigned_xt = TestXt::<_, ()>::new(call, None);
+	let unsigned_xt_info = unsigned_xt.get_dispatch_info();
+
+	ExtBuilder::default()
+        .base_weight(Weight::from_parts(5, 0))
+        .weight_fee(2)
+        .build()
+        .execute_with(|| {
+            // all fees should be x1.5
+            <NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(3, 2));
+
+            assert_eq!(
+                TransactionPayment::query_info(xt.clone(), len),
+                RuntimeDispatchInfo {
+                    weight: info.weight,
+                    class: info.class,
+                    partial_fee: 5 * 2 /* base * weight_fee */
+                    + len as u64  /* len * 1 */
+                    + info.weight.min(BlockWeights::get().max_block).ref_time() as u64 * 2 * 3 / 2 /* weight */
+                },
+            );
+
+            assert_eq!(
+                TransactionPayment::query_info(unsigned_xt.clone(), len),
+                RuntimeDispatchInfo {
+                    weight: unsigned_xt_info.weight,
+                    class: unsigned_xt_info.class,
+                    partial_fee: 0,
+                },
+            );
+
+            assert_eq!(
+                TransactionPayment::query_fee_details(xt, len),
+                FeeDetails {
+                    inclusion_fee: Some(InclusionFee {
+                        base_fee: 5 * 2,
+                        len_fee: len as u64,
+                        adjusted_weight_fee: info
+                            .weight
+                            .min(BlockWeights::get().max_block)
+                            .ref_time() as u64 * 2 * 3 / 2
+                    }),
+                    tip: 0,
+                },
+            );
+
+            assert_eq!(
+                TransactionPayment::query_fee_details(unsigned_xt, len),
+                FeeDetails { inclusion_fee: None, tip: 0 },
+            );
+        });
+}
+
+#[test]
+fn query_call_info_and_fee_details_works() {
+	let call = RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest: 2, value: 69 });
+	let info = call.get_dispatch_info();
+	let encoded_call = call.encode();
+	let len = encoded_call.len() as u32;
+
+	ExtBuilder::default()
+        .base_weight(Weight::from_parts(5, 0))
+        .weight_fee(2)
+        .build()
+        .execute_with(|| {
+            // all fees should be x1.5
+            <NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(3, 2));
+
+            assert_eq!(
+                TransactionPayment::query_call_info(call.clone(), len),
+                RuntimeDispatchInfo {
+                    weight: info.weight,
+                    class: info.class,
+                    partial_fee: 5 * 2 /* base * weight_fee */
+                    + len as u64  /* len * 1 */
+                    + info.weight.min(BlockWeights::get().max_block).ref_time() as u64 * 2 * 3 / 2 /* weight */
+                },
+            );
+
+            assert_eq!(
+                TransactionPayment::query_call_fee_details(call, len),
+                FeeDetails {
+                    inclusion_fee: Some(InclusionFee {
+                        base_fee: 5 * 2,     /* base * weight_fee */
+                        len_fee: len as u64, /* len * 1 */
+                        adjusted_weight_fee: info
+                            .weight
+                            .min(BlockWeights::get().max_block)
+                            .ref_time() as u64 * 2 * 3 / 2  /* weight * weight_fee * multipler */
+                    }),
+                    tip: 0,
+                },
+            );
+        });
+}
+
+#[test]
+fn compute_fee_works_without_multiplier() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Next fee multiplier is zero
+			assert_eq!(<NextFeeMultiplier<Runtime>>::get(), Multiplier::one());
+
+			// Tip only, no fees works
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(0, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::No,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 10), 10);
+			// No tip, only base fee works
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(0, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 100);
+			// Tip + base fee works
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 69), 169);
+			// Len (byte fee) + base fee works
+			assert_eq!(Pallet::<Runtime>::compute_fee(42, &dispatch_info, 0), 520);
+			// Weight fee + base fee works
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(1000, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 1100);
+		});
+}
+
+#[test]
+fn compute_fee_works_with_multiplier() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Add a next fee multiplier. Fees will be x3/2.
+			<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(3, 2));
+			// Base fee is unaffected by multiplier
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(0, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 100);
+
+			// Everything works together :)
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(123, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			// 123 weight, 456 length, 100 base
+			assert_eq!(
+				Pallet::<Runtime>::compute_fee(456, &dispatch_info, 789),
+				100 + (3 * 123 / 2) + 4560 + 789,
+			);
+		});
+}
+
+#[test]
+fn compute_fee_works_with_negative_multiplier() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Add a next fee multiplier. All fees will be x1/2.
+			<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(1, 2));
+
+			// Base fee is unaffected by multiplier.
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(0, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(Pallet::<Runtime>::compute_fee(0, &dispatch_info, 0), 100);
+
+			// Everything works together.
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(123, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			// 123 weight, 456 length, 100 base
+			assert_eq!(
+				Pallet::<Runtime>::compute_fee(456, &dispatch_info, 789),
+				100 + (123 / 2) + 4560 + 789,
+			);
+		});
+}
+
+#[test]
+fn compute_fee_does_not_overflow() {
+	ExtBuilder::default()
+		.base_weight(Weight::from_parts(100, 0))
+		.byte_fee(10)
+		.balance_factor(0)
+		.build()
+		.execute_with(|| {
+			// Overflow is handled
+			let dispatch_info = DispatchInfo {
+				weight: Weight::MAX,
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			assert_eq!(
+				Pallet::<Runtime>::compute_fee(u32::MAX, &dispatch_info, u64::MAX),
+				u64::MAX
+			);
+		});
+}
+
+#[test]
+fn refund_does_not_recreate_account() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			// So events are emitted
+			System::set_block_number(10);
+			let len = 10;
+			let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
+				.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
+				.unwrap();
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
+
+			// kill the account between pre and post dispatch
+			assert_ok!(Balances::transfer_allow_death(
+				Some(2).into(),
+				3,
+				Balances::free_balance(2)
+			));
+			assert_eq!(Balances::free_balance(2), 0);
+
+			assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(100, 0)),
+				&post_info_from_weight(Weight::from_parts(50, 0)),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(2), 0);
+			// Transfer Event
+			System::assert_has_event(RuntimeEvent::Balances(pallet_balances::Event::Transfer {
+				from: 2,
+				to: 3,
+				amount: 80,
+			}));
+			// Killed Event
+			System::assert_has_event(RuntimeEvent::System(system::Event::KilledAccount {
+				account: 2,
+			}));
+		});
+}
+
+#[test]
+fn actual_weight_higher_than_max_refunds_nothing() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			let len = 10;
+			let pre = ChargeTransactionPayment::<Runtime>::from(5 /* tipped */)
+				.pre_dispatch(&2, CALL, &info_from_weight(Weight::from_parts(100, 0)), len)
+				.unwrap();
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
+
+			assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info_from_weight(Weight::from_parts(100, 0)),
+				&post_info_from_weight(Weight::from_parts(101, 0)),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::free_balance(2), 200 - 5 - 10 - 100 - 5);
+		});
+}
+
+#[test]
+fn zero_transfer_on_free_transaction() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(5, 0))
+		.build()
+		.execute_with(|| {
+			// So events are emitted
+			System::set_block_number(10);
+			let len = 10;
+			let dispatch_info = DispatchInfo {
+				weight: Weight::from_parts(100, 0),
+				pays_fee: Pays::No,
+				class: DispatchClass::Normal,
+			};
+			let user = 69;
+			let pre = ChargeTransactionPayment::<Runtime>::from(0)
+				.pre_dispatch(&user, CALL, &dispatch_info, len)
+				.unwrap();
+			assert_eq!(Balances::total_balance(&user), 0);
+			assert_ok!(ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&dispatch_info,
+				&default_post_info(),
+				len,
+				&Ok(())
+			));
+			assert_eq!(Balances::total_balance(&user), 0);
+			// TransactionFeePaid Event
+			System::assert_has_event(RuntimeEvent::TransactionPayment(
+				pallet_transaction_payment::Event::TransactionFeePaid {
+					who: user,
+					actual_fee: 0,
+					tip: 0,
+				},
+			));
+		});
+}
+
+#[test]
+fn refund_consistent_with_actual_weight() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(7, 0))
+		.build()
+		.execute_with(|| {
+			let info = info_from_weight(Weight::from_parts(100, 0));
+			let post_info = post_info_from_weight(Weight::from_parts(33, 0));
+			let prev_balance = Balances::free_balance(2);
+			let len = 10;
+			let tip = 5;
+
+			<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(5, 4));
+
+			let pre = ChargeTransactionPayment::<Runtime>::from(tip)
+				.pre_dispatch(&2, CALL, &info, len)
+				.unwrap();
+
+			ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info,
+				&post_info,
+				len,
+				&Ok(()),
+			)
+			.unwrap();
+
+			let refund_based_fee = prev_balance - Balances::free_balance(2);
+			let actual_fee =
+				Pallet::<Runtime>::compute_actual_fee(len as u32, &info, &post_info, tip);
+
+			// 33 weight, 10 length, 7 base, 5 tip
+			assert_eq!(actual_fee, 7 + 10 + (33 * 5 / 4) + 5);
+			assert_eq!(refund_based_fee, actual_fee);
+		});
+}
+
+#[test]
+fn should_alter_operational_priority() {
+	let tip = 5;
+	let len = 10;
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let normal = DispatchInfo {
+			weight: Weight::from_parts(100, 0),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes,
+		};
+		let priority = ChargeTransactionPayment::<Runtime>(tip)
+			.validate(&2, CALL, &normal, len)
+			.unwrap()
+			.priority;
+
+		assert_eq!(priority, 60);
+
+		let priority = ChargeTransactionPayment::<Runtime>(2 * tip)
+			.validate(&2, CALL, &normal, len)
+			.unwrap()
+			.priority;
+
+		assert_eq!(priority, 110);
+	});
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let op = DispatchInfo {
+			weight: Weight::from_parts(100, 0),
+			class: DispatchClass::Operational,
+			pays_fee: Pays::Yes,
+		};
+		let priority = ChargeTransactionPayment::<Runtime>(tip)
+			.validate(&2, CALL, &op, len)
+			.unwrap()
+			.priority;
+		assert_eq!(priority, 5810);
+
+		let priority = ChargeTransactionPayment::<Runtime>(2 * tip)
+			.validate(&2, CALL, &op, len)
+			.unwrap()
+			.priority;
+		assert_eq!(priority, 6110);
+	});
+}
+
+#[test]
+fn no_tip_has_some_priority() {
+	let tip = 0;
+	let len = 10;
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let normal = DispatchInfo {
+			weight: Weight::from_parts(100, 0),
+			class: DispatchClass::Normal,
+			pays_fee: Pays::Yes,
+		};
+		let priority = ChargeTransactionPayment::<Runtime>(tip)
+			.validate(&2, CALL, &normal, len)
+			.unwrap()
+			.priority;
+
+		assert_eq!(priority, 10);
+	});
+
+	ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+		let op = DispatchInfo {
+			weight: Weight::from_parts(100, 0),
+			class: DispatchClass::Operational,
+			pays_fee: Pays::Yes,
+		};
+		let priority = ChargeTransactionPayment::<Runtime>(tip)
+			.validate(&2, CALL, &op, len)
+			.unwrap()
+			.priority;
+		assert_eq!(priority, 5510);
+	});
+}
+
+#[test]
+fn higher_tip_have_higher_priority() {
+	let get_priorities = |tip: u64| {
+		let mut priority1 = 0;
+		let mut priority2 = 0;
+		let len = 10;
+		ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+			let normal = DispatchInfo {
+				weight: Weight::from_parts(100, 0),
+				class: DispatchClass::Normal,
+				pays_fee: Pays::Yes,
+			};
+			priority1 = ChargeTransactionPayment::<Runtime>(tip)
+				.validate(&2, CALL, &normal, len)
+				.unwrap()
+				.priority;
+		});
+
+		ExtBuilder::default().balance_factor(100).build().execute_with(|| {
+			let op = DispatchInfo {
+				weight: Weight::from_parts(100, 0),
+				class: DispatchClass::Operational,
+				pays_fee: Pays::Yes,
+			};
+			priority2 = ChargeTransactionPayment::<Runtime>(tip)
+				.validate(&2, CALL, &op, len)
+				.unwrap()
+				.priority;
+		});
+
+		(priority1, priority2)
+	};
+
+	let mut prev_priorities = get_priorities(0);
+
+	for tip in 1..3 {
+		let priorities = get_priorities(tip);
+		assert!(prev_priorities.0 < priorities.0);
+		assert!(prev_priorities.1 < priorities.1);
+		prev_priorities = priorities;
+	}
+}
+
+#[test]
+fn post_info_can_change_pays_fee() {
+	ExtBuilder::default()
+		.balance_factor(10)
+		.base_weight(Weight::from_parts(7, 0))
+		.build()
+		.execute_with(|| {
+			let info = info_from_weight(Weight::from_parts(100, 0));
+			let post_info = post_info_from_pays(Pays::No);
+			let prev_balance = Balances::free_balance(2);
+			let len = 10;
+			let tip = 5;
+
+			<NextFeeMultiplier<Runtime>>::put(Multiplier::saturating_from_rational(5, 4));
+
+			let pre = ChargeTransactionPayment::<Runtime>::from(tip)
+				.pre_dispatch(&2, CALL, &info, len)
+				.unwrap();
+
+			ChargeTransactionPayment::<Runtime>::post_dispatch(
+				Some(pre),
+				&info,
+				&post_info,
+				len,
+				&Ok(()),
+			)
+			.unwrap();
+
+			let refund_based_fee = prev_balance - Balances::free_balance(2);
+			let actual_fee =
+				Pallet::<Runtime>::compute_actual_fee(len as u32, &info, &post_info, tip);
+
+			// Only 5 tip is paid
+			assert_eq!(actual_fee, 5);
+			assert_eq!(refund_based_fee, actual_fee);
+		});
+}
+
+#[test]
+fn genesis_config_works() {
+	ExtBuilder::default()
+		.with_initial_multiplier(Multiplier::from_u32(100))
+		.build()
+		.execute_with(|| {
+			assert_eq!(
+				<NextFeeMultiplier<Runtime>>::get(),
+				Multiplier::saturating_from_integer(100)
+			);
+		});
+}
+
+#[test]
+fn genesis_default_works() {
+	ExtBuilder::default().build().execute_with(|| {
+		assert_eq!(<NextFeeMultiplier<Runtime>>::get(), Multiplier::saturating_from_integer(1));
+	});
+}
diff --git a/substrate/frame/transaction-payment/src/types.rs b/substrate/frame/transaction-payment/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cbe85309b856a9415cd731164d9333ef54aa0922
--- /dev/null
+++ b/substrate/frame/transaction-payment/src/types.rs
@@ -0,0 +1,178 @@
+// 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.
+
+//! Types for transaction-payment RPC.
+
+use codec::{Decode, Encode};
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+
+use scale_info::TypeInfo;
+
+use sp_runtime::traits::{AtLeast32BitUnsigned, Zero};
+use sp_std::prelude::*;
+
+use frame_support::dispatch::DispatchClass;
+
+/// The base fee and adjusted weight and length fees constitute the _inclusion fee_.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+pub struct InclusionFee<Balance> {
+	/// This is the minimum amount a user pays for a transaction. It is declared
+	/// as a base _weight_ in the runtime and converted to a fee using `WeightToFee`.
+	pub base_fee: Balance,
+	/// The length fee, the amount paid for the encoded length (in bytes) of the transaction.
+	pub len_fee: Balance,
+	///
+	/// - `targeted_fee_adjustment`: This is a multiplier that can tune the final fee based on the
+	///   congestion of the network.
+	/// - `weight_fee`: This amount is computed based on the weight of the transaction. Weight
+	/// accounts for the execution time of a transaction.
+	///
+	/// adjusted_weight_fee = targeted_fee_adjustment * weight_fee
+	pub adjusted_weight_fee: Balance,
+}
+
+impl<Balance: AtLeast32BitUnsigned + Copy> InclusionFee<Balance> {
+	/// Returns the total of inclusion fee.
+	///
+	/// ```ignore
+	/// inclusion_fee = base_fee + len_fee + adjusted_weight_fee
+	/// ```
+	pub fn inclusion_fee(&self) -> Balance {
+		self.base_fee
+			.saturating_add(self.len_fee)
+			.saturating_add(self.adjusted_weight_fee)
+	}
+}
+
+/// The `FeeDetails` is composed of:
+///   - (Optional) `inclusion_fee`: Only the `Pays::Yes` transaction can have the inclusion fee.
+///   - `tip`: If included in the transaction, the tip will be added on top. Only signed
+///     transactions can have a tip.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+pub struct FeeDetails<Balance> {
+	/// The minimum fee for a transaction to be included in a block.
+	pub inclusion_fee: Option<InclusionFee<Balance>>,
+	// Do not serialize and deserialize `tip` as we actually can not pass any tip to the RPC.
+	#[cfg_attr(feature = "std", serde(skip))]
+	pub tip: Balance,
+}
+
+impl<Balance: AtLeast32BitUnsigned + Copy> FeeDetails<Balance> {
+	/// Returns the final fee.
+	///
+	/// ```ignore
+	/// final_fee = inclusion_fee + tip;
+	/// ```
+	pub fn final_fee(&self) -> Balance {
+		self.inclusion_fee
+			.as_ref()
+			.map(|i| i.inclusion_fee())
+			.unwrap_or_else(|| Zero::zero())
+			.saturating_add(self.tip)
+	}
+}
+
+/// Information related to a dispatchable's class, weight, and fee that can be queried from the
+/// runtime.
+#[derive(Eq, PartialEq, Encode, Decode, Default, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))]
+#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))]
+#[cfg_attr(
+	feature = "std",
+	serde(bound(serialize = "Balance: std::fmt::Display, Weight: Serialize"))
+)]
+#[cfg_attr(
+	feature = "std",
+	serde(bound(deserialize = "Balance: std::str::FromStr, Weight: Deserialize<'de>"))
+)]
+pub struct RuntimeDispatchInfo<Balance, Weight = frame_support::weights::Weight> {
+	/// Weight of this dispatch.
+	pub weight: Weight,
+	/// Class of this dispatch.
+	pub class: DispatchClass,
+	/// The inclusion fee of this dispatch.
+	///
+	/// This does not include a tip or anything else that
+	/// depends on the signature (i.e. depends on a `SignedExtension`).
+	#[cfg_attr(feature = "std", serde(with = "serde_balance"))]
+	pub partial_fee: Balance,
+}
+
+#[cfg(feature = "std")]
+mod serde_balance {
+	use serde::{Deserialize, Deserializer, Serializer};
+
+	pub fn serialize<S: Serializer, T: std::fmt::Display>(
+		t: &T,
+		serializer: S,
+	) -> Result<S::Ok, S::Error> {
+		serializer.serialize_str(&t.to_string())
+	}
+
+	pub fn deserialize<'de, D: Deserializer<'de>, T: std::str::FromStr>(
+		deserializer: D,
+	) -> Result<T, D::Error> {
+		let s = String::deserialize(deserializer)?;
+		s.parse::<T>().map_err(|_| serde::de::Error::custom("Parse from string failed"))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use frame_support::weights::Weight;
+
+	#[test]
+	fn should_serialize_and_deserialize_properly_with_string() {
+		let info = RuntimeDispatchInfo {
+			weight: Weight::from_parts(5, 0),
+			class: DispatchClass::Normal,
+			partial_fee: 1_000_000_u64,
+		};
+
+		let json_str =
+			r#"{"weight":{"ref_time":5,"proof_size":0},"class":"normal","partialFee":"1000000"}"#;
+
+		assert_eq!(serde_json::to_string(&info).unwrap(), json_str);
+		assert_eq!(serde_json::from_str::<RuntimeDispatchInfo<u64>>(json_str).unwrap(), info);
+
+		// should not panic
+		serde_json::to_value(&info).unwrap();
+	}
+
+	#[test]
+	fn should_serialize_and_deserialize_properly_large_value() {
+		let info = RuntimeDispatchInfo {
+			weight: Weight::from_parts(5, 0),
+			class: DispatchClass::Normal,
+			partial_fee: u128::max_value(),
+		};
+
+		let json_str = r#"{"weight":{"ref_time":5,"proof_size":0},"class":"normal","partialFee":"340282366920938463463374607431768211455"}"#;
+
+		assert_eq!(serde_json::to_string(&info).unwrap(), json_str);
+		assert_eq!(serde_json::from_str::<RuntimeDispatchInfo<u128>>(json_str).unwrap(), info);
+
+		// should not panic
+		serde_json::to_value(&info).unwrap();
+	}
+}
diff --git a/substrate/frame/transaction-storage/Cargo.toml b/substrate/frame/transaction-storage/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6456e3002866cfcd8654e49d31c613822740fa79
--- /dev/null
+++ b/substrate/frame/transaction-storage/Cargo.toml
@@ -0,0 +1,66 @@
+[package]
+name = "pallet-transaction-storage"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Storage chain pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = { version = "6.1", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", optional = true }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../balances" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../primitives/inherents" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-transaction-storage-proof = { version = "4.0.0-dev", default-features = false, path = "../../primitives/transaction-storage-proof" }
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-transaction-storage-proof = { version = "4.0.0-dev", default-features = true, path = "../../primitives/transaction-storage-proof" }
+
+[features]
+default = [ "std" ]
+runtime-benchmarks = [
+	"array-bytes",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-transaction-storage-proof/std",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/transaction-storage/README.md b/substrate/frame/transaction-storage/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ed3ba279c2a590c4a4f10e669b9fbb74d6947ef
--- /dev/null
+++ b/substrate/frame/transaction-storage/README.md
@@ -0,0 +1,82 @@
+# Transaction Storage Pallet
+
+Indexes transactions and manages storage proofs.
+
+Allows storing arbitrary data on the chain. Data is automatically removed after `StoragePeriod` blocks, unless the storage is renewed.
+Validators must submit proof of storing a random chunk of data for block `N - StoragePeriod` when producing block `N`.
+
+# Running a chain
+
+The following describes how to set up a new storage chain.
+
+Start with generating a chain spec.
+
+```bash
+cargo run --release -- build-spec --chain=local > sc_init.json
+```
+
+Edit the json chain spec file to customise the chain. The storage chain genesis params are configured in the `transactionStorage` section.
+Note that `storagePeriod` is specified in blocks and changing it also requires code changes at the moment.
+
+Build a raw spec from the init spec.
+
+```bash
+cargo run --release build-spec --chain=sc_init.json --raw > sc.json
+```
+
+Run a few validator nodes.
+
+```bash
+cargo run --release -- --chain=sc.json -d /tmp/alice --storage-chain --keep-blocks=100800 --ipfs-server --validator --alice
+cargo run --release -- --chain=sc.json -d /tmp/bob --storage-chain --keep-blocks=100800 --ipfs-server --validator --bob
+```
+
+`--storage-chain` enables transaction indexing.
+`--keep-blocks=100800` enables block pruning. The value here should be greater or equal than the storage period.
+`--ipfs-server` enables serving stored content over IPFS.
+
+Once the network is started, any other joining nodes need to sync with `--sync=fast`. Regular sync will fail because block pruning removes old blocks. The chain does not keep full block history.
+
+```bash
+cargo run --release -- --chain=sc.json -d /tmp/charlie --storage-chain --keep-blocks=100800 --ipfs-server --validator --charlie --sync=fast
+```
+
+# Making transactions
+
+To store data use the `transactionStorage.store` extrinsic. And IPFS CID can be generated from the Blake2-256 hash of the data.
+
+```js
+const util_crypto = require('@polkadot/util-crypto');
+const keyring_api = require('@polkadot/keyring');
+const polkadot_api = require('@polkadot/api');
+const fs = require('fs');
+const multihash = require('multihashes');
+const CID = require('cids')
+
+const wsProvider = new polkadot_api.WsProvider();
+const api = await polkadot_api.ApiPromise.create({ provider: wsProvider });
+
+const keyring = new keyring_api.Keyring({ type: "sr25519" });
+const alice = keyring.addFromUri("//Alice");
+
+const file = fs.readFileSync('cute_kitten.jpeg');
+const hash = util_crypto.blake2AsU8a(file)
+const encoded_hash = multihash.encode(hash, 'blake2b-256');
+
+const cid = new CID(1, 'blake2b-256', encoded_hash)
+console.log(cid.toString());
+
+const txHash = await api.tx.transactionStorage.store('0x' + file.toString('hex')).signAndSend(alice);
+```
+Data can be queried over IPFS
+
+```bash
+ipfs swarm connect <substrate peer address>
+ipfs block get /ipfs/<CID> > kitten.jpeg
+```
+
+To renew data and prevent it from being disposed after the storage period, use `transactionStorage.renew(block, index)`
+where `block` is the block number of the previous store or renew transction, and index is the index of that transaction in the block.
+
+
+License: Apache-2.0
diff --git a/substrate/frame/transaction-storage/src/benchmarking.rs b/substrate/frame/transaction-storage/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fdbaeb1f951818a7f34cd98c077f1880dd8bdf5f
--- /dev/null
+++ b/substrate/frame/transaction-storage/src/benchmarking.rs
@@ -0,0 +1,171 @@
+// 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.
+
+//! Benchmarks for transaction-storage Pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{benchmarks, whitelisted_caller};
+use frame_support::traits::{Currency, Get, OnFinalize, OnInitialize};
+use frame_system::{pallet_prelude::BlockNumberFor, EventRecord, Pallet as System, RawOrigin};
+use sp_runtime::traits::{Bounded, One, Zero};
+use sp_std::*;
+use sp_transaction_storage_proof::TransactionStorageProof;
+
+use crate::Pallet as TransactionStorage;
+
+// Proof generated from max size storage:
+// ```
+// let mut transactions = Vec::new();
+// let tx_size = DEFAULT_MAX_TRANSACTION_SIZE;
+// for _ in 0..DEFAULT_MAX_BLOCK_TRANSACTIONS {
+//   transactions.push(vec![0; tx_size]);
+// }
+// let hash = vec![0; 32];
+// build_proof(hash.as_slice(), transactions).unwrap().encode()
+// ```
+// while hardforcing target chunk key in `build_proof` to [22, 21, 1, 0].
+const PROOF: &str = "\
+	0104000000000000000000000000000000000000000000000000000000000000000000000000\
+	0000000000000000000000000000000000000000000000000000000000000000000000000000\
+	0000000000000000000000000000000000000000000000000000000000000000000000000000\
+	0000000000000000000000000000000000000000000000000000000000000000000000000000\
+	0000000000000000000000000000000000000000000000000000000000000000000000000000\
+	0000000000000000000000000000000000000000000000000000000000000000000000000000\
+	00000000000000000000000000000000000000000000000000000000000014cd0780ffff8030\
+	2eb0a6d2f63b834d15f1e729d1c1004657e3048cf206d697eeb153f61a30ba0080302eb0a6d2\
+	f63b834d15f1e729d1c1004657e3048cf206d697eeb153f61a30ba80302eb0a6d2f63b834d15\
+	f1e729d1c1004657e3048cf206d697eeb153f61a30ba80302eb0a6d2f63b834d15f1e729d1c1\
+	004657e3048cf206d697eeb153f61a30ba80302eb0a6d2f63b834d15f1e729d1c1004657e304\
+	8cf206d697eeb153f61a30ba80302eb0a6d2f63b834d15f1e729d1c1004657e3048cf206d697\
+	eeb153f61a30ba80302eb0a6d2f63b834d15f1e729d1c1004657e3048cf206d697eeb153f61a\
+	30ba80302eb0a6d2f63b834d15f1e729d1c1004657e3048cf206d697eeb153f61a30ba80302e\
+	b0a6d2f63b834d15f1e729d1c1004657e3048cf206d697eeb153f61a30ba80302eb0a6d2f63b\
+	834d15f1e729d1c1004657e3048cf206d697eeb153f61a30ba80302eb0a6d2f63b834d15f1e7\
+	29d1c1004657e3048cf206d697eeb153f61a30ba80302eb0a6d2f63b834d15f1e729d1c10046\
+	57e3048cf206d697eeb153f61a30ba80302eb0a6d2f63b834d15f1e729d1c1004657e3048cf2\
+	06d697eeb153f61a30ba80302eb0a6d2f63b834d15f1e729d1c1004657e3048cf206d697eeb1\
+	53f61a30ba80302eb0a6d2f63b834d15f1e729d1c1004657e3048cf206d697eeb153f61a30ba\
+	bd058077778010fd81bc1359802f0b871aeb95e4410a8ec92b93af10ea767a2027cf4734e8de\
+	808da338e6b722f7bf2051901bd5bccee5e71d5cf6b1faff338ad7120b0256c28380221ce17f\
+	19117affa96e077905fe48a99723a065969c638593b7d9ab57b538438010fd81bc1359802f0b\
+	871aeb95e4410a8ec92b93af10ea767a2027cf4734e8de808da338e6b722f7bf2051901bd5bc\
+	cee5e71d5cf6b1faff338ad7120b0256c283008010fd81bc1359802f0b871aeb95e4410a8ec9\
+	2b93af10ea767a2027cf4734e8de808da338e6b722f7bf2051901bd5bccee5e71d5cf6b1faff\
+	338ad7120b0256c28380221ce17f19117affa96e077905fe48a99723a065969c638593b7d9ab\
+	57b538438010fd81bc1359802f0b871aeb95e4410a8ec92b93af10ea767a2027cf4734e8de80\
+	8da338e6b722f7bf2051901bd5bccee5e71d5cf6b1faff338ad7120b0256c28380221ce17f19\
+	117affa96e077905fe48a99723a065969c638593b7d9ab57b53843cd0780ffff804509f59593\
+	fd47b1a97189127ba65a5649cfb0346637f9836e155eaf891a939c00804509f59593fd47b1a9\
+	7189127ba65a5649cfb0346637f9836e155eaf891a939c804509f59593fd47b1a97189127ba6\
+	5a5649cfb0346637f9836e155eaf891a939c804509f59593fd47b1a97189127ba65a5649cfb0\
+	346637f9836e155eaf891a939c804509f59593fd47b1a97189127ba65a5649cfb0346637f983\
+	6e155eaf891a939c804509f59593fd47b1a97189127ba65a5649cfb0346637f9836e155eaf89\
+	1a939c804509f59593fd47b1a97189127ba65a5649cfb0346637f9836e155eaf891a939c8045\
+	09f59593fd47b1a97189127ba65a5649cfb0346637f9836e155eaf891a939c804509f59593fd\
+	47b1a97189127ba65a5649cfb0346637f9836e155eaf891a939c804509f59593fd47b1a97189\
+	127ba65a5649cfb0346637f9836e155eaf891a939c804509f59593fd47b1a97189127ba65a56\
+	49cfb0346637f9836e155eaf891a939c804509f59593fd47b1a97189127ba65a5649cfb03466\
+	37f9836e155eaf891a939c804509f59593fd47b1a97189127ba65a5649cfb0346637f9836e15\
+	5eaf891a939c804509f59593fd47b1a97189127ba65a5649cfb0346637f9836e155eaf891a93\
+	9c804509f59593fd47b1a97189127ba65a5649cfb0346637f9836e155eaf891a939ccd0780ff\
+	ff8078916e776c64ccea05e958559f015c082d9d06feafa3610fc44a5b2ef543cb818078916e\
+	776c64ccea05e958559f015c082d9d06feafa3610fc44a5b2ef543cb818078916e776c64ccea\
+	05e958559f015c082d9d06feafa3610fc44a5b2ef543cb818078916e776c64ccea05e958559f\
+	015c082d9d06feafa3610fc44a5b2ef543cb818078916e776c64ccea05e958559f015c082d9d\
+	06feafa3610fc44a5b2ef543cb81008078916e776c64ccea05e958559f015c082d9d06feafa3\
+	610fc44a5b2ef543cb818078916e776c64ccea05e958559f015c082d9d06feafa3610fc44a5b\
+	2ef543cb818078916e776c64ccea05e958559f015c082d9d06feafa3610fc44a5b2ef543cb81\
+	8078916e776c64ccea05e958559f015c082d9d06feafa3610fc44a5b2ef543cb818078916e77\
+	6c64ccea05e958559f015c082d9d06feafa3610fc44a5b2ef543cb818078916e776c64ccea05\
+	e958559f015c082d9d06feafa3610fc44a5b2ef543cb818078916e776c64ccea05e958559f01\
+	5c082d9d06feafa3610fc44a5b2ef543cb818078916e776c64ccea05e958559f015c082d9d06\
+	feafa3610fc44a5b2ef543cb818078916e776c64ccea05e958559f015c082d9d06feafa3610f\
+	c44a5b2ef543cb818078916e776c64ccea05e958559f015c082d9d06feafa3610fc44a5b2ef5\
+	43cb811044010000\
+";
+fn proof() -> Vec<u8> {
+	array_bytes::hex2bytes_unchecked(PROOF)
+}
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = System::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	let EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+pub fn run_to_block<T: Config>(n: frame_system::pallet_prelude::BlockNumberFor<T>) {
+	while frame_system::Pallet::<T>::block_number() < n {
+		crate::Pallet::<T>::on_finalize(frame_system::Pallet::<T>::block_number());
+		frame_system::Pallet::<T>::on_finalize(frame_system::Pallet::<T>::block_number());
+		frame_system::Pallet::<T>::set_block_number(
+			frame_system::Pallet::<T>::block_number() + One::one(),
+		);
+		frame_system::Pallet::<T>::on_initialize(frame_system::Pallet::<T>::block_number());
+		crate::Pallet::<T>::on_initialize(frame_system::Pallet::<T>::block_number());
+	}
+}
+
+benchmarks! {
+	store {
+		let l in 1 .. T::MaxTransactionSize::get();
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+	}: _(RawOrigin::Signed(caller.clone()), vec![0u8; l as usize])
+	verify {
+		assert!(!BlockTransactions::<T>::get().is_empty());
+		assert_last_event::<T>(Event::Stored { index: 0 }.into());
+	}
+
+	renew {
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		TransactionStorage::<T>::store(
+			RawOrigin::Signed(caller.clone()).into(),
+			vec![0u8; T::MaxTransactionSize::get() as usize],
+		)?;
+		run_to_block::<T>(1u32.into());
+	}: _(RawOrigin::Signed(caller.clone()), BlockNumberFor::<T>::zero(), 0)
+	verify {
+		assert_last_event::<T>(Event::Renewed { index: 0 }.into());
+	}
+
+	check_proof_max {
+		run_to_block::<T>(1u32.into());
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+		for _ in 0 .. T::MaxBlockTransactions::get() {
+			TransactionStorage::<T>::store(
+				RawOrigin::Signed(caller.clone()).into(),
+				vec![0u8; T::MaxTransactionSize::get() as usize],
+			)?;
+		}
+		run_to_block::<T>(StoragePeriod::<T>::get() + BlockNumberFor::<T>::one());
+		let encoded_proof = proof();
+		let proof = TransactionStorageProof::decode(&mut &*encoded_proof).unwrap();
+	}: check_proof(RawOrigin::None, proof)
+	verify {
+		assert_last_event::<T>(Event::ProofChecked.into());
+	}
+
+	impl_benchmark_test_suite!(TransactionStorage, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/transaction-storage/src/lib.rs b/substrate/frame/transaction-storage/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e784d20a0cfd76d607b8327e348dcc25f4b63734
--- /dev/null
+++ b/substrate/frame/transaction-storage/src/lib.rs
@@ -0,0 +1,441 @@
+// 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.
+
+//! Transaction storage pallet. Indexes transactions and manages storage proofs.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+pub mod weights;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{Dispatchable, GetDispatchInfo},
+	traits::{Currency, OnUnbalanced, ReservableCurrency},
+};
+use sp_runtime::traits::{BlakeTwo256, Hash, One, Saturating, Zero};
+use sp_std::{prelude::*, result};
+use sp_transaction_storage_proof::{
+	encode_index, random_chunk, InherentError, TransactionStorageProof, CHUNK_SIZE,
+	INHERENT_IDENTIFIER,
+};
+
+/// A type alias for the balance type from this pallet's point of view.
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type NegativeImbalanceOf<T> = <<T as Config>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+
+// Re-export pallet items so that they can be accessed from the crate namespace.
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+/// Maximum bytes that can be stored in one transaction.
+// Setting higher limit also requires raising the allocator limit.
+pub const DEFAULT_MAX_TRANSACTION_SIZE: u32 = 8 * 1024 * 1024;
+pub const DEFAULT_MAX_BLOCK_TRANSACTIONS: u32 = 512;
+
+/// State data for a stored transaction.
+#[derive(
+	Encode,
+	Decode,
+	Clone,
+	sp_runtime::RuntimeDebug,
+	PartialEq,
+	Eq,
+	scale_info::TypeInfo,
+	MaxEncodedLen,
+)]
+pub struct TransactionInfo {
+	/// Chunk trie root.
+	chunk_root: <BlakeTwo256 as Hash>::Output,
+	/// Plain hash of indexed data.
+	content_hash: <BlakeTwo256 as Hash>::Output,
+	/// Size of indexed data in bytes.
+	size: u32,
+	/// Total number of chunks added in the block with this transaction. This
+	/// is used find transaction info by block chunk index using binary search.
+	block_chunks: u32,
+}
+
+fn num_chunks(bytes: u32) -> u32 {
+	((bytes as u64 + CHUNK_SIZE as u64 - 1) / CHUNK_SIZE as u64) as u32
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+		/// A dispatchable call.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ GetDispatchInfo
+			+ From<frame_system::Call<Self>>;
+		/// The currency trait.
+		type Currency: ReservableCurrency<Self::AccountId>;
+		/// Handler for the unbalanced decrease when fees are burned.
+		type FeeDestination: OnUnbalanced<NegativeImbalanceOf<Self>>;
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+		/// Maximum number of indexed transactions in the block.
+		type MaxBlockTransactions: Get<u32>;
+		/// Maximum data set in a single transaction in bytes.
+		type MaxTransactionSize: Get<u32>;
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Insufficient account balance.
+		InsufficientFunds,
+		/// Invalid configuration.
+		NotConfigured,
+		/// Renewed extrinsic is not found.
+		RenewedNotFound,
+		/// Attempting to store empty transaction
+		EmptyTransaction,
+		/// Proof was not expected in this block.
+		UnexpectedProof,
+		/// Proof failed verification.
+		InvalidProof,
+		/// Missing storage proof.
+		MissingProof,
+		/// Unable to verify proof becasue state data is missing.
+		MissingStateData,
+		/// Double proof check in the block.
+		DoubleCheck,
+		/// Storage proof was not checked in the block.
+		ProofNotChecked,
+		/// Transaction is too large.
+		TransactionTooLarge,
+		/// Too many transactions in the block.
+		TooManyTransactions,
+		/// Attempted to call `store` outside of block execution.
+		BadContext,
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn on_initialize(n: BlockNumberFor<T>) -> Weight {
+			// Drop obsolete roots. The proof for `obsolete` will be checked later
+			// in this block, so we drop `obsolete` - 1.
+			let period = <StoragePeriod<T>>::get();
+			let obsolete = n.saturating_sub(period.saturating_add(One::one()));
+			if obsolete > Zero::zero() {
+				<Transactions<T>>::remove(obsolete);
+				<ChunkCount<T>>::remove(obsolete);
+			}
+			// 2 writes in `on_initialize` and 2 writes + 2 reads in `on_finalize`
+			T::DbWeight::get().reads_writes(2, 4)
+		}
+
+		fn on_finalize(n: BlockNumberFor<T>) {
+			assert!(
+				<ProofChecked<T>>::take() || {
+					// Proof is not required for early or empty blocks.
+					let number = <frame_system::Pallet<T>>::block_number();
+					let period = <StoragePeriod<T>>::get();
+					let target_number = number.saturating_sub(period);
+					target_number.is_zero() || <ChunkCount<T>>::get(target_number) == 0
+				},
+				"Storage proof must be checked once in the block"
+			);
+			// Insert new transactions
+			let transactions = <BlockTransactions<T>>::take();
+			let total_chunks = transactions.last().map_or(0, |t| t.block_chunks);
+			if total_chunks != 0 {
+				<ChunkCount<T>>::insert(n, total_chunks);
+				<Transactions<T>>::insert(n, transactions);
+			}
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Index and store data off chain. Minimum data size is 1 bytes, maximum is
+		/// `MaxTransactionSize`. Data will be removed after `STORAGE_PERIOD` blocks, unless `renew`
+		/// is called.
+		/// ## Complexity
+		/// - O(n*log(n)) of data size, as all data is pushed to an in-memory trie.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::store(data.len() as u32))]
+		pub fn store(origin: OriginFor<T>, data: Vec<u8>) -> DispatchResult {
+			ensure!(data.len() > 0, Error::<T>::EmptyTransaction);
+			ensure!(
+				data.len() <= T::MaxTransactionSize::get() as usize,
+				Error::<T>::TransactionTooLarge
+			);
+			let sender = ensure_signed(origin)?;
+			Self::apply_fee(sender, data.len() as u32)?;
+
+			// Chunk data and compute storage root
+			let chunk_count = num_chunks(data.len() as u32);
+			let chunks = data.chunks(CHUNK_SIZE).map(|c| c.to_vec()).collect();
+			let root = sp_io::trie::blake2_256_ordered_root(chunks, sp_runtime::StateVersion::V1);
+
+			let content_hash = sp_io::hashing::blake2_256(&data);
+			let extrinsic_index =
+				<frame_system::Pallet<T>>::extrinsic_index().ok_or(Error::<T>::BadContext)?;
+			sp_io::transaction_index::index(extrinsic_index, data.len() as u32, content_hash);
+
+			let mut index = 0;
+			<BlockTransactions<T>>::mutate(|transactions| {
+				if transactions.len() + 1 > T::MaxBlockTransactions::get() as usize {
+					return Err(Error::<T>::TooManyTransactions)
+				}
+				let total_chunks = transactions.last().map_or(0, |t| t.block_chunks) + chunk_count;
+				index = transactions.len() as u32;
+				transactions
+					.try_push(TransactionInfo {
+						chunk_root: root,
+						size: data.len() as u32,
+						content_hash: content_hash.into(),
+						block_chunks: total_chunks,
+					})
+					.map_err(|_| Error::<T>::TooManyTransactions)?;
+				Ok(())
+			})?;
+			Self::deposit_event(Event::Stored { index });
+			Ok(())
+		}
+
+		/// Renew previously stored data. Parameters are the block number that contains
+		/// previous `store` or `renew` call and transaction index within that block.
+		/// Transaction index is emitted in the `Stored` or `Renewed` event.
+		/// Applies same fees as `store`.
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::renew())]
+		pub fn renew(
+			origin: OriginFor<T>,
+			block: BlockNumberFor<T>,
+			index: u32,
+		) -> DispatchResultWithPostInfo {
+			let sender = ensure_signed(origin)?;
+			let transactions = <Transactions<T>>::get(block).ok_or(Error::<T>::RenewedNotFound)?;
+			let info = transactions.get(index as usize).ok_or(Error::<T>::RenewedNotFound)?;
+			let extrinsic_index =
+				<frame_system::Pallet<T>>::extrinsic_index().ok_or(Error::<T>::BadContext)?;
+
+			Self::apply_fee(sender, info.size)?;
+
+			sp_io::transaction_index::renew(extrinsic_index, info.content_hash.into());
+
+			let mut index = 0;
+			<BlockTransactions<T>>::mutate(|transactions| {
+				if transactions.len() + 1 > T::MaxBlockTransactions::get() as usize {
+					return Err(Error::<T>::TooManyTransactions)
+				}
+				let chunks = num_chunks(info.size);
+				let total_chunks = transactions.last().map_or(0, |t| t.block_chunks) + chunks;
+				index = transactions.len() as u32;
+				transactions
+					.try_push(TransactionInfo {
+						chunk_root: info.chunk_root,
+						size: info.size,
+						content_hash: info.content_hash,
+						block_chunks: total_chunks,
+					})
+					.map_err(|_| Error::<T>::TooManyTransactions)
+			})?;
+			Self::deposit_event(Event::Renewed { index });
+			Ok(().into())
+		}
+
+		/// Check storage proof for block number `block_number() - StoragePeriod`.
+		/// If such block does not exist the proof is expected to be `None`.
+		/// ## Complexity
+		/// - Linear w.r.t the number of indexed transactions in the proved block for random
+		///   probing.
+		/// There's a DB read for each transaction.
+		#[pallet::call_index(2)]
+		#[pallet::weight((T::WeightInfo::check_proof_max(), DispatchClass::Mandatory))]
+		pub fn check_proof(
+			origin: OriginFor<T>,
+			proof: TransactionStorageProof,
+		) -> DispatchResultWithPostInfo {
+			ensure_none(origin)?;
+			ensure!(!ProofChecked::<T>::get(), Error::<T>::DoubleCheck);
+			let number = <frame_system::Pallet<T>>::block_number();
+			let period = <StoragePeriod<T>>::get();
+			let target_number = number.saturating_sub(period);
+			ensure!(!target_number.is_zero(), Error::<T>::UnexpectedProof);
+			let total_chunks = <ChunkCount<T>>::get(target_number);
+			ensure!(total_chunks != 0, Error::<T>::UnexpectedProof);
+			let parent_hash = <frame_system::Pallet<T>>::parent_hash();
+			let selected_chunk_index = random_chunk(parent_hash.as_ref(), total_chunks);
+			let (info, chunk_index) = match <Transactions<T>>::get(target_number) {
+				Some(infos) => {
+					let index = match infos
+						.binary_search_by_key(&selected_chunk_index, |info| info.block_chunks)
+					{
+						Ok(index) => index,
+						Err(index) => index,
+					};
+					let info = infos.get(index).ok_or(Error::<T>::MissingStateData)?.clone();
+					let chunks = num_chunks(info.size);
+					let prev_chunks = info.block_chunks - chunks;
+					(info, selected_chunk_index - prev_chunks)
+				},
+				None => return Err(Error::<T>::MissingStateData.into()),
+			};
+			ensure!(
+				sp_io::trie::blake2_256_verify_proof(
+					info.chunk_root,
+					&proof.proof,
+					&encode_index(chunk_index),
+					&proof.chunk,
+					sp_runtime::StateVersion::V1,
+				),
+				Error::<T>::InvalidProof
+			);
+			ProofChecked::<T>::put(true);
+			Self::deposit_event(Event::ProofChecked);
+			Ok(().into())
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// Stored data under specified index.
+		Stored { index: u32 },
+		/// Renewed data under specified index.
+		Renewed { index: u32 },
+		/// Storage proof was successfully checked.
+		ProofChecked,
+	}
+
+	/// Collection of transaction metadata by block number.
+	#[pallet::storage]
+	#[pallet::getter(fn transaction_roots)]
+	pub(super) type Transactions<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		BlockNumberFor<T>,
+		BoundedVec<TransactionInfo, T::MaxBlockTransactions>,
+		OptionQuery,
+	>;
+
+	/// Count indexed chunks for each block.
+	#[pallet::storage]
+	pub(super) type ChunkCount<T: Config> =
+		StorageMap<_, Blake2_128Concat, BlockNumberFor<T>, u32, ValueQuery>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn byte_fee)]
+	/// Storage fee per byte.
+	pub(super) type ByteFee<T: Config> = StorageValue<_, BalanceOf<T>>;
+
+	#[pallet::storage]
+	#[pallet::getter(fn entry_fee)]
+	/// Storage fee per transaction.
+	pub(super) type EntryFee<T: Config> = StorageValue<_, BalanceOf<T>>;
+
+	/// Storage period for data in blocks. Should match `sp_storage_proof::DEFAULT_STORAGE_PERIOD`
+	/// for block authoring.
+	#[pallet::storage]
+	pub(super) type StoragePeriod<T: Config> = StorageValue<_, BlockNumberFor<T>, ValueQuery>;
+
+	// Intermediates
+	#[pallet::storage]
+	pub(super) type BlockTransactions<T: Config> =
+		StorageValue<_, BoundedVec<TransactionInfo, T::MaxBlockTransactions>, ValueQuery>;
+
+	/// Was the proof checked in this block?
+	#[pallet::storage]
+	pub(super) type ProofChecked<T: Config> = StorageValue<_, bool, ValueQuery>;
+
+	#[pallet::genesis_config]
+	pub struct GenesisConfig<T: Config> {
+		pub byte_fee: BalanceOf<T>,
+		pub entry_fee: BalanceOf<T>,
+		pub storage_period: BlockNumberFor<T>,
+	}
+
+	impl<T: Config> Default for GenesisConfig<T> {
+		fn default() -> Self {
+			Self {
+				byte_fee: 10u32.into(),
+				entry_fee: 1000u32.into(),
+				storage_period: sp_transaction_storage_proof::DEFAULT_STORAGE_PERIOD.into(),
+			}
+		}
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			<ByteFee<T>>::put(&self.byte_fee);
+			<EntryFee<T>>::put(&self.entry_fee);
+			<StoragePeriod<T>>::put(&self.storage_period);
+		}
+	}
+
+	#[pallet::inherent]
+	impl<T: Config> ProvideInherent for Pallet<T> {
+		type Call = Call<T>;
+		type Error = InherentError;
+		const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER;
+
+		fn create_inherent(data: &InherentData) -> Option<Self::Call> {
+			let proof = data
+				.get_data::<TransactionStorageProof>(&Self::INHERENT_IDENTIFIER)
+				.unwrap_or(None);
+			proof.map(|proof| Call::check_proof { proof })
+		}
+
+		fn check_inherent(
+			_call: &Self::Call,
+			_data: &InherentData,
+		) -> result::Result<(), Self::Error> {
+			Ok(())
+		}
+
+		fn is_inherent(call: &Self::Call) -> bool {
+			matches!(call, Call::check_proof { .. })
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		fn apply_fee(sender: T::AccountId, size: u32) -> DispatchResult {
+			let byte_fee = ByteFee::<T>::get().ok_or(Error::<T>::NotConfigured)?;
+			let entry_fee = EntryFee::<T>::get().ok_or(Error::<T>::NotConfigured)?;
+			let fee = byte_fee.saturating_mul(size.into()).saturating_add(entry_fee);
+			ensure!(T::Currency::can_slash(&sender, fee), Error::<T>::InsufficientFunds);
+			let (credit, _) = T::Currency::slash(&sender, fee);
+			T::FeeDestination::on_unbalanced(credit);
+			Ok(())
+		}
+	}
+}
diff --git a/substrate/frame/transaction-storage/src/mock.rs b/substrate/frame/transaction-storage/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..243e26b559053d54a84b8f29010ccd39de1e6781
--- /dev/null
+++ b/substrate/frame/transaction-storage/src/mock.rs
@@ -0,0 +1,125 @@
+// 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.
+
+//! Test environment for transaction-storage pallet.
+
+use crate::{
+	self as pallet_transaction_storage, TransactionStorageProof, DEFAULT_MAX_BLOCK_TRANSACTIONS,
+	DEFAULT_MAX_TRANSACTION_SIZE,
+};
+use frame_support::traits::{ConstU16, ConstU32, ConstU64, OnFinalize, OnInitialize};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+pub type Block = frame_system::mocking::MockBlock<Test>;
+
+// 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>},
+		Balances: pallet_balances::{Pallet, Call, Config<T>, Storage, Event<T>},
+		TransactionStorage: pallet_transaction_storage::{
+			Pallet, Call, Storage, Config<T>, Inherent, Event<T>
+		},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	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 Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u64>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ConstU16<42>;
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+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 = ();
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+
+impl pallet_transaction_storage::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type FeeDestination = ();
+	type WeightInfo = ();
+	type MaxBlockTransactions = ConstU32<{ DEFAULT_MAX_BLOCK_TRANSACTIONS }>;
+	type MaxTransactionSize = ConstU32<{ DEFAULT_MAX_TRANSACTION_SIZE }>;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig {
+		system: Default::default(),
+		balances: pallet_balances::GenesisConfig::<Test> {
+			balances: vec![(1, 1000000000), (2, 100), (3, 100), (4, 100)],
+		},
+		transaction_storage: pallet_transaction_storage::GenesisConfig::<Test> {
+			storage_period: 10,
+			byte_fee: 2,
+			entry_fee: 200,
+		},
+	}
+	.build_storage()
+	.unwrap();
+	t.into()
+}
+
+pub fn run_to_block(n: u64, f: impl Fn() -> Option<TransactionStorageProof>) {
+	while System::block_number() < n {
+		if let Some(proof) = f() {
+			TransactionStorage::check_proof(RuntimeOrigin::none(), proof).unwrap();
+		}
+		TransactionStorage::on_finalize(System::block_number());
+		System::on_finalize(System::block_number());
+		System::set_block_number(System::block_number() + 1);
+		System::on_initialize(System::block_number());
+		TransactionStorage::on_initialize(System::block_number());
+	}
+}
diff --git a/substrate/frame/transaction-storage/src/tests.rs b/substrate/frame/transaction-storage/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43dfed81f88bb94bae0e936466523f556464f0cb
--- /dev/null
+++ b/substrate/frame/transaction-storage/src/tests.rs
@@ -0,0 +1,148 @@
+// 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 transction-storage pallet.
+
+use super::{Pallet as TransactionStorage, *};
+use crate::mock::*;
+use frame_support::{assert_noop, assert_ok};
+use frame_system::RawOrigin;
+use sp_transaction_storage_proof::registration::build_proof;
+
+const MAX_DATA_SIZE: u32 = DEFAULT_MAX_TRANSACTION_SIZE;
+
+#[test]
+fn discards_data() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1, || None);
+		let caller = 1;
+		assert_ok!(TransactionStorage::<Test>::store(
+			RawOrigin::Signed(caller).into(),
+			vec![0u8; 2000 as usize]
+		));
+		assert_ok!(TransactionStorage::<Test>::store(
+			RawOrigin::Signed(caller).into(),
+			vec![0u8; 2000 as usize]
+		));
+		let proof_provider = || {
+			let block_num = <frame_system::Pallet<Test>>::block_number();
+			if block_num == 11 {
+				let parent_hash = <frame_system::Pallet<Test>>::parent_hash();
+				Some(
+					build_proof(parent_hash.as_ref(), vec![vec![0u8; 2000], vec![0u8; 2000]])
+						.unwrap(),
+				)
+			} else {
+				None
+			}
+		};
+		run_to_block(11, proof_provider);
+		assert!(Transactions::<Test>::get(1).is_some());
+		let transctions = Transactions::<Test>::get(1).unwrap();
+		assert_eq!(transctions.len(), 2);
+		assert_eq!(ChunkCount::<Test>::get(1), 16);
+		run_to_block(12, proof_provider);
+		assert!(Transactions::<Test>::get(1).is_none());
+		assert_eq!(ChunkCount::<Test>::get(1), 0);
+	});
+}
+
+#[test]
+fn burns_fee() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1, || None);
+		let caller = 1;
+		assert_noop!(
+			TransactionStorage::<Test>::store(
+				RawOrigin::Signed(5).into(),
+				vec![0u8; 2000 as usize]
+			),
+			Error::<Test>::InsufficientFunds,
+		);
+		assert_ok!(TransactionStorage::<Test>::store(
+			RawOrigin::Signed(caller).into(),
+			vec![0u8; 2000 as usize]
+		));
+		assert_eq!(Balances::free_balance(1), 1_000_000_000 - 2000 * 2 - 200);
+	});
+}
+
+#[test]
+fn checks_proof() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1, || None);
+		let caller = 1;
+		assert_ok!(TransactionStorage::<Test>::store(
+			RawOrigin::Signed(caller).into(),
+			vec![0u8; MAX_DATA_SIZE as usize]
+		));
+		run_to_block(10, || None);
+		let parent_hash = <frame_system::Pallet<Test>>::parent_hash();
+		let proof =
+			build_proof(parent_hash.as_ref(), vec![vec![0u8; MAX_DATA_SIZE as usize]]).unwrap();
+		assert_noop!(
+			TransactionStorage::<Test>::check_proof(RuntimeOrigin::none(), proof,),
+			Error::<Test>::UnexpectedProof,
+		);
+		run_to_block(11, || None);
+		let parent_hash = <frame_system::Pallet<Test>>::parent_hash();
+
+		let invalid_proof = build_proof(parent_hash.as_ref(), vec![vec![0u8; 1000]]).unwrap();
+		assert_noop!(
+			TransactionStorage::<Test>::check_proof(RuntimeOrigin::none(), invalid_proof,),
+			Error::<Test>::InvalidProof,
+		);
+
+		let proof =
+			build_proof(parent_hash.as_ref(), vec![vec![0u8; MAX_DATA_SIZE as usize]]).unwrap();
+		assert_ok!(TransactionStorage::<Test>::check_proof(RuntimeOrigin::none(), proof));
+	});
+}
+
+#[test]
+fn renews_data() {
+	new_test_ext().execute_with(|| {
+		run_to_block(1, || None);
+		let caller = 1;
+		assert_ok!(TransactionStorage::<Test>::store(
+			RawOrigin::Signed(caller).into(),
+			vec![0u8; 2000]
+		));
+		let info = BlockTransactions::<Test>::get().last().unwrap().clone();
+		run_to_block(6, || None);
+		assert_ok!(TransactionStorage::<Test>::renew(
+			RawOrigin::Signed(caller).into(),
+			1, // block
+			0, // transaction
+		));
+		assert_eq!(Balances::free_balance(1), 1_000_000_000 - 4000 * 2 - 200 * 2);
+		let proof_provider = || {
+			let block_num = <frame_system::Pallet<Test>>::block_number();
+			if block_num == 11 || block_num == 16 {
+				let parent_hash = <frame_system::Pallet<Test>>::parent_hash();
+				Some(build_proof(parent_hash.as_ref(), vec![vec![0u8; 2000]]).unwrap())
+			} else {
+				None
+			}
+		};
+		run_to_block(16, proof_provider);
+		assert!(Transactions::<Test>::get(1).is_none());
+		assert_eq!(Transactions::<Test>::get(6).unwrap().get(0), Some(info).as_ref());
+		run_to_block(17, proof_provider);
+		assert!(Transactions::<Test>::get(6).is_none());
+	});
+}
diff --git a/substrate/frame/transaction-storage/src/weights.rs b/substrate/frame/transaction-storage/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..519317177c492f4e1179b9ee12f17da7d442b0e4
--- /dev/null
+++ b/substrate/frame/transaction-storage/src/weights.rs
@@ -0,0 +1,175 @@
+// 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.
+
+//! Autogenerated weights for pallet_transaction_storage
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_transaction_storage
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/transaction-storage/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_transaction_storage.
+pub trait WeightInfo {
+	fn store(l: u32, ) -> Weight;
+	fn renew() -> Weight;
+	fn check_proof_max() -> Weight;
+}
+
+/// Weights for pallet_transaction_storage using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: TransactionStorage ByteFee (r:1 w:0)
+	/// Proof: TransactionStorage ByteFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage EntryFee (r:1 w:0)
+	/// Proof: TransactionStorage EntryFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage BlockTransactions (r:1 w:1)
+	/// Proof: TransactionStorage BlockTransactions (max_values: Some(1), max_size: Some(36866), added: 37361, mode: MaxEncodedLen)
+	/// The range of component `l` is `[1, 8388608]`.
+	fn store(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `176`
+		//  Estimated: `38351`
+		// Minimum execution time: 34_844_000 picoseconds.
+		Weight::from_parts(35_489_000, 38351)
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(6_912, 0).saturating_mul(l.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: TransactionStorage Transactions (r:1 w:0)
+	/// Proof: TransactionStorage Transactions (max_values: None, max_size: Some(36886), added: 39361, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage ByteFee (r:1 w:0)
+	/// Proof: TransactionStorage ByteFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage EntryFee (r:1 w:0)
+	/// Proof: TransactionStorage EntryFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage BlockTransactions (r:1 w:1)
+	/// Proof: TransactionStorage BlockTransactions (max_values: Some(1), max_size: Some(36866), added: 37361, mode: MaxEncodedLen)
+	fn renew() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `326`
+		//  Estimated: `40351`
+		// Minimum execution time: 48_244_000 picoseconds.
+		Weight::from_parts(50_939_000, 40351)
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: TransactionStorage ProofChecked (r:1 w:1)
+	/// Proof: TransactionStorage ProofChecked (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage StoragePeriod (r:1 w:0)
+	/// Proof: TransactionStorage StoragePeriod (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage ChunkCount (r:1 w:0)
+	/// Proof: TransactionStorage ChunkCount (max_values: None, max_size: Some(24), added: 2499, mode: MaxEncodedLen)
+	/// Storage: System ParentHash (r:1 w:0)
+	/// Proof: System ParentHash (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage Transactions (r:1 w:0)
+	/// Proof: TransactionStorage Transactions (max_values: None, max_size: Some(36886), added: 39361, mode: MaxEncodedLen)
+	fn check_proof_max() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `37145`
+		//  Estimated: `40351`
+		// Minimum execution time: 80_913_000 picoseconds.
+		Weight::from_parts(84_812_000, 40351)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: TransactionStorage ByteFee (r:1 w:0)
+	/// Proof: TransactionStorage ByteFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage EntryFee (r:1 w:0)
+	/// Proof: TransactionStorage EntryFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage BlockTransactions (r:1 w:1)
+	/// Proof: TransactionStorage BlockTransactions (max_values: Some(1), max_size: Some(36866), added: 37361, mode: MaxEncodedLen)
+	/// The range of component `l` is `[1, 8388608]`.
+	fn store(l: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `176`
+		//  Estimated: `38351`
+		// Minimum execution time: 34_844_000 picoseconds.
+		Weight::from_parts(35_489_000, 38351)
+			// Standard Error: 11
+			.saturating_add(Weight::from_parts(6_912, 0).saturating_mul(l.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: TransactionStorage Transactions (r:1 w:0)
+	/// Proof: TransactionStorage Transactions (max_values: None, max_size: Some(36886), added: 39361, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage ByteFee (r:1 w:0)
+	/// Proof: TransactionStorage ByteFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage EntryFee (r:1 w:0)
+	/// Proof: TransactionStorage EntryFee (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage BlockTransactions (r:1 w:1)
+	/// Proof: TransactionStorage BlockTransactions (max_values: Some(1), max_size: Some(36866), added: 37361, mode: MaxEncodedLen)
+	fn renew() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `326`
+		//  Estimated: `40351`
+		// Minimum execution time: 48_244_000 picoseconds.
+		Weight::from_parts(50_939_000, 40351)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: TransactionStorage ProofChecked (r:1 w:1)
+	/// Proof: TransactionStorage ProofChecked (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage StoragePeriod (r:1 w:0)
+	/// Proof: TransactionStorage StoragePeriod (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage ChunkCount (r:1 w:0)
+	/// Proof: TransactionStorage ChunkCount (max_values: None, max_size: Some(24), added: 2499, mode: MaxEncodedLen)
+	/// Storage: System ParentHash (r:1 w:0)
+	/// Proof: System ParentHash (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen)
+	/// Storage: TransactionStorage Transactions (r:1 w:0)
+	/// Proof: TransactionStorage Transactions (max_values: None, max_size: Some(36886), added: 39361, mode: MaxEncodedLen)
+	fn check_proof_max() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `37145`
+		//  Estimated: `40351`
+		// Minimum execution time: 80_913_000 picoseconds.
+		Weight::from_parts(84_812_000, 40351)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/treasury/Cargo.toml b/substrate/frame/treasury/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f49f3ccf756cefd884523fd8b4625392460589ec
--- /dev/null
+++ b/substrate/frame/treasury/Cargo.toml
@@ -0,0 +1,65 @@
+[package]
+name = "pallet-treasury"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet to manage treasury"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+	"max-encoded-len",
+] }
+impl-trait-for-tuples = "0.2.2"
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive"], optional = true }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../balances" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+pallet-utility = { version = "4.0.0-dev", path = "../utility" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-utility/std",
+	"scale-info/std",
+	"serde",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-utility/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-utility/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/treasury/README.md b/substrate/frame/treasury/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4945d79d1429694a1c8db79e8508561f515163da
--- /dev/null
+++ b/substrate/frame/treasury/README.md
@@ -0,0 +1,31 @@
+# Treasury Pallet
+
+The Treasury pallet provides a "pot" of funds that can be managed by stakeholders in the system and
+a structure for making spending proposals from this pot.
+
+## Overview
+
+The Treasury Pallet itself provides the pot to store funds, and a means for stakeholders to propose,
+approve, and deny expenditures. The chain will need to provide a method (e.g.inflation, fees) for
+collecting funds.
+
+By way of example, the Council could vote to fund the Treasury with a portion of the block reward
+and use the funds to pay developers.
+
+### Terminology
+
+- **Proposal:** A suggestion to allocate funds from the pot to a beneficiary.
+- **Beneficiary:** An account who will receive the funds from a proposal if the proposal is
+  approved.
+- **Deposit:** Funds that a proposer must lock when making a proposal. The deposit will be returned
+  or slashed if the proposal is approved or rejected respectively.
+- **Pot:** Unspent funds accumulated by the treasury pallet.
+
+## Interface
+
+### 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.
diff --git a/substrate/frame/treasury/src/benchmarking.rs b/substrate/frame/treasury/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b8a53e06f2092bd4742d8ca1f7f7ab4a2bab5891
--- /dev/null
+++ b/substrate/frame/treasury/src/benchmarking.rs
@@ -0,0 +1,148 @@
+// 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.
+
+//! Treasury pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::{Pallet as Treasury, *};
+
+use frame_benchmarking::v1::{account, benchmarks_instance_pallet, BenchmarkError};
+use frame_support::{
+	dispatch::UnfilteredDispatchable,
+	ensure,
+	traits::{EnsureOrigin, OnInitialize},
+};
+use frame_system::RawOrigin;
+
+const SEED: u32 = 0;
+
+// Create the pre-requisite information needed to create a treasury `propose_spend`.
+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 _ = T::Currency::make_free_balance_be(&caller, value);
+	let beneficiary = account("beneficiary", u, SEED);
+	let beneficiary_lookup = T::Lookup::unlookup(beneficiary);
+	(caller, value, beneficiary_lookup)
+}
+
+// Create proposals that are approved for use in `on_initialize`.
+fn create_approved_proposals<T: Config<I>, I: 'static>(n: u32) -> Result<(), &'static str> {
+	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;
+		#[allow(deprecated)]
+		Treasury::<T, I>::approve_proposal(RawOrigin::Root.into(), proposal_id)?;
+	}
+	ensure!(<Approvals<T, I>>::get().len() == n as usize, "Not all approved");
+	Ok(())
+}
+
+fn setup_pot_account<T: Config<I>, I: 'static>() {
+	let pot_account = Treasury::<T, I>::account_id();
+	let value = T::Currency::minimum_balance().saturating_mul(1_000_000_000u32.into());
+	let _ = T::Currency::make_free_balance_be(&pot_account, value);
+}
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+benchmarks_instance_pallet! {
+	// This benchmark is short-circuited if `SpendOrigin` cannot provide
+	// a successful origin, in which case `spend` is un-callable and can use weight=0.
+	spend {
+		let (_, value, beneficiary_lookup) = setup_proposal::<T, _>(SEED);
+		let origin = T::SpendOrigin::try_successful_origin();
+		let beneficiary = T::Lookup::lookup(beneficiary_lookup.clone()).unwrap();
+		let call = Call::<T, I>::spend { amount: value, beneficiary: beneficiary_lookup };
+	}: {
+		if let Ok(origin) = origin.clone() {
+			call.dispatch_bypass_filter(origin)?;
+		}
+	}
+	verify {
+		if origin.is_ok() {
+			assert_last_event::<T, I>(Event::SpendApproved { proposal_index: 0, amount: value, beneficiary }.into())
+		}
+	}
+
+	propose_spend {
+		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());
+	}: _(RawOrigin::Signed(caller), value, beneficiary_lookup)
+
+	reject_proposal {
+		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)?;
+	}: _<T::RuntimeOrigin>(reject_origin, proposal_id)
+
+	approve_proposal {
+		let p in 0 .. T::MaxApprovals::get() - 1;
+		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;
+		let approve_origin =
+			T::ApproveOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: _<T::RuntimeOrigin>(approve_origin, proposal_id)
+
+	remove_approval {
+		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;
+		#[allow(deprecated)]
+		Treasury::<T, I>::approve_proposal(RawOrigin::Root.into(), proposal_id)?;
+		let reject_origin =
+			T::RejectOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+	}: _<T::RuntimeOrigin>(reject_origin, proposal_id)
+
+	on_initialize_proposals {
+		let p in 0 .. T::MaxApprovals::get();
+		setup_pot_account::<T, _>();
+		create_approved_proposals::<T, _>(p)?;
+	}: {
+		Treasury::<T, _>::on_initialize(frame_system::pallet_prelude::BlockNumberFor::<T>::zero());
+	}
+
+	impl_benchmark_test_suite!(Treasury, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/treasury/src/lib.rs b/substrate/frame/treasury/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..730fae2a4e92c9b673541d25e5fca6c759ad2c91
--- /dev/null
+++ b/substrate/frame/treasury/src/lib.rs
@@ -0,0 +1,628 @@
+// 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.
+
+//! # Treasury Pallet
+//!
+//! The Treasury pallet provides a "pot" of funds that can be managed by stakeholders in the system
+//! and a structure for making spending proposals from this pot.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! The Treasury Pallet itself provides the pot to store funds, and a means for stakeholders to
+//! propose, approve, and deny expenditures. The chain will need to provide a method (e.g.
+//! inflation, fees) for collecting funds.
+//!
+//! By way of example, the Council could vote to fund the Treasury with a portion of the block
+//! reward and use the funds to pay developers.
+//!
+//!
+//! ### Terminology
+//!
+//! - **Proposal:** A suggestion to allocate funds from the pot to a beneficiary.
+//! - **Beneficiary:** An account who will receive the funds from a proposal iff the proposal is
+//!   approved.
+//! - **Deposit:** Funds that a proposer must lock when making a proposal. The deposit will be
+//!   returned or slashed if the proposal is approved or rejected respectively.
+//! - **Pot:** Unspent funds accumulated by the treasury pallet.
+//!
+//! ## Interface
+//!
+//! ### 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.
+//! - `remove_approval` - Remove an approval, the deposit will no longer be returned.
+//!
+//! ## GenesisConfig
+//!
+//! The Treasury pallet depends on the [`GenesisConfig`].
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+
+use sp_runtime::{
+	traits::{AccountIdConversion, CheckedAdd, Saturating, StaticLookup, Zero},
+	Permill, RuntimeDebug,
+};
+use sp_std::{collections::btree_map::BTreeMap, prelude::*};
+
+use frame_support::{
+	print,
+	traits::{
+		Currency, ExistenceRequirement::KeepAlive, Get, Imbalance, OnUnbalanced,
+		ReservableCurrency, WithdrawReasons,
+	},
+	weights::Weight,
+	PalletId,
+};
+
+pub use pallet::*;
+pub use weights::WeightInfo;
+
+pub type BalanceOf<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+pub type PositiveImbalanceOf<T, I = ()> = <<T as Config<I>>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::PositiveImbalance;
+pub type NegativeImbalanceOf<T, I = ()> = <<T as Config<I>>::Currency as Currency<
+	<T as frame_system::Config>::AccountId,
+>>::NegativeImbalance;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+/// A trait to allow the Treasury Pallet to spend it's funds for other purposes.
+/// There is an expectation that the implementer of this trait will correctly manage
+/// the mutable variables passed to it:
+/// * `budget_remaining`: How much available funds that can be spent by the treasury. As funds are
+///   spent, you must correctly deduct from this value.
+/// * `imbalance`: Any imbalances that you create should be subsumed in here to maximize efficiency
+///   of updating the total issuance. (i.e. `deposit_creating`)
+/// * `total_weight`: Track any weight that your `spend_fund` implementation uses by updating this
+///   value.
+/// * `missed_any`: If there were items that you want to spend on, but there were not enough funds,
+///   mark this value as `true`. This will prevent the treasury from burning the excess funds.
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+pub trait SpendFunds<T: Config<I>, I: 'static = ()> {
+	fn spend_funds(
+		budget_remaining: &mut BalanceOf<T, I>,
+		imbalance: &mut PositiveImbalanceOf<T, I>,
+		total_weight: &mut Weight,
+		missed_any: &mut bool,
+	);
+}
+
+/// An index of a proposal. Just a `u32`.
+pub type ProposalIndex = u32;
+
+/// A spending proposal.
+#[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))]
+#[derive(Encode, Decode, Clone, PartialEq, Eq, MaxEncodedLen, RuntimeDebug, TypeInfo)]
+pub struct Proposal<AccountId, Balance> {
+	/// The account proposing it.
+	proposer: AccountId,
+	/// The (total) amount that should be paid if the proposal is accepted.
+	value: Balance,
+	/// The account to whom the payment should be made if the proposal is accepted.
+	beneficiary: AccountId,
+	/// The amount held on deposit (reserved) for making this proposal.
+	bond: Balance,
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::{dispatch_context::with_context, pallet_prelude::*};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(PhantomData<(T, I)>);
+
+	#[pallet::config]
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The staking balance.
+		type Currency: Currency<Self::AccountId> + ReservableCurrency<Self::AccountId>;
+
+		/// Origin from which approvals must come.
+		type ApproveOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Origin from which rejections must come.
+		type RejectOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// 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>>;
+
+		/// Percentage of spare funds (if any) that are burnt per spend period.
+		#[pallet::constant]
+		type Burn: Get<Permill>;
+
+		/// The treasury's pallet id, used for deriving its sovereign account ID.
+		#[pallet::constant]
+		type PalletId: Get<PalletId>;
+
+		/// Handler for the unbalanced decrease when treasury funds are burned.
+		type BurnDestination: OnUnbalanced<NegativeImbalanceOf<Self, I>>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Runtime hooks to external pallet using treasury to compute spend funds.
+		type SpendFunds: SpendFunds<Self, I>;
+
+		/// The maximum number of approvals that can wait in the spending queue.
+		///
+		/// NOTE: This parameter is also used within the Bounties Pallet extension if enabled.
+		#[pallet::constant]
+		type MaxApprovals: Get<u32>;
+
+		/// The origin required for approving spends from the treasury outside of the proposal
+		/// process. The `Success` value is the maximum amount that this origin is allowed to
+		/// spend at a time.
+		type SpendOrigin: EnsureOrigin<Self::RuntimeOrigin, Success = BalanceOf<Self, I>>;
+	}
+
+	/// Number of proposals that have been made.
+	#[pallet::storage]
+	#[pallet::getter(fn proposal_count)]
+	pub(crate) type ProposalCount<T, I = ()> = StorageValue<_, ProposalIndex, ValueQuery>;
+
+	/// Proposals that have been made.
+	#[pallet::storage]
+	#[pallet::getter(fn proposals)]
+	pub type Proposals<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Twox64Concat,
+		ProposalIndex,
+		Proposal<T::AccountId, BalanceOf<T, I>>,
+		OptionQuery,
+	>;
+
+	/// The amount which has been reported as inactive to Currency.
+	#[pallet::storage]
+	pub type Deactivated<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BalanceOf<T, I>, ValueQuery>;
+
+	/// Proposal indices that have been approved but not yet awarded.
+	#[pallet::storage]
+	#[pallet::getter(fn approvals)]
+	pub type Approvals<T: Config<I>, I: 'static = ()> =
+		StorageValue<_, BoundedVec<ProposalIndex, T::MaxApprovals>, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config<I>, I: 'static = ()> {
+		#[serde(skip)]
+		_config: sp_std::marker::PhantomData<(T, I)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config<I>, I: 'static> BuildGenesisConfig for GenesisConfig<T, I> {
+		fn build(&self) {
+			// Create Treasury account
+			let account_id = <Pallet<T, I>>::account_id();
+			let min = T::Currency::minimum_balance();
+			if T::Currency::free_balance(&account_id) < min {
+				let _ = T::Currency::make_free_balance_be(&account_id, min);
+			}
+		}
+	}
+
+	#[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.
+		Rollover { rollover_balance: BalanceOf<T, I> },
+		/// Some funds have been deposited.
+		Deposit { value: BalanceOf<T, I> },
+		/// A new spend proposal has been approved.
+		SpendApproved {
+			proposal_index: ProposalIndex,
+			amount: BalanceOf<T, I>,
+			beneficiary: T::AccountId,
+		},
+		/// The inactive funds of the pallet have been updated.
+		UpdatedInactive { reactivated: BalanceOf<T, I>, deactivated: BalanceOf<T, I> },
+	}
+
+	/// Error for the treasury pallet.
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// Proposer's balance is too low.
+		InsufficientProposersBalance,
+		/// No proposal or bounty at that index.
+		InvalidIndex,
+		/// Too many approvals in the queue.
+		TooManyApprovals,
+		/// The spend origin is valid but the amount it is allowed to spend is lower than the
+		/// amount to be spent.
+		InsufficientPermission,
+		/// Proposal has not been approved.
+		ProposalNotApproved,
+	}
+
+	#[pallet::hooks]
+	impl<T: Config<I>, I: 'static> Hooks<BlockNumberFor<T>> for Pallet<T, I> {
+		/// ## Complexity
+		/// - `O(A)` where `A` is the number of approvals
+		fn on_initialize(n: frame_system::pallet_prelude::BlockNumberFor<T>) -> Weight {
+			let pot = Self::pot();
+			let deactivated = Deactivated::<T, I>::get();
+			if pot != deactivated {
+				T::Currency::reactivate(deactivated);
+				T::Currency::deactivate(pot);
+				Deactivated::<T, I>::put(&pot);
+				Self::deposit_event(Event::<T, I>::UpdatedInactive {
+					reactivated: deactivated,
+					deactivated: pot,
+				});
+			}
+
+			// Check to see if we should spend some funds!
+			if (n % T::SpendPeriod::get()).is_zero() {
+				Self::spend_funds()
+			} else {
+				Weight::zero()
+			}
+		}
+	}
+
+	#[derive(Default)]
+	struct SpendContext<Balance> {
+		spend_in_context: BTreeMap<Balance, Balance>,
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Put forward a suggestion for spending. 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)
+		#[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. The original deposit will be slashed.
+		///
+		/// May only be called from `T::RejectOrigin`.
+		///
+		/// ## Complexity
+		/// - O(1)
+		#[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. At a later time, the proposal will be allocated to the beneficiary
+		/// and the original deposit will be returned.
+		///
+		/// May only be called from `T::ApproveOrigin`.
+		///
+		/// ## Complexity
+		///  - O(1).
+		#[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.
+		///
+		/// - `origin`: Must be `SpendOrigin` with the `Success` value being at least `amount`.
+		/// - `amount`: The amount to be transferred from the treasury to the `beneficiary`.
+		/// - `beneficiary`: The destination account for the transfer.
+		///
+		/// NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the
+		/// beneficiary.
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::spend())]
+		pub fn spend(
+			origin: OriginFor<T>,
+			#[pallet::compact] amount: BalanceOf<T, I>,
+			beneficiary: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let max_amount = T::SpendOrigin::ensure_origin(origin)?;
+			ensure!(amount <= max_amount, Error::<T, I>::InsufficientPermission);
+
+			with_context::<SpendContext<BalanceOf<T, I>>, _>(|v| {
+				let context = v.or_default();
+
+				// We group based on `max_amount`, to dinstinguish between different kind of
+				// origins. (assumes that all origins have different `max_amount`)
+				//
+				// Worst case is that we reject some "valid" request.
+				let spend = context.spend_in_context.entry(max_amount).or_default();
+
+				// Ensure that we don't overflow nor use more than `max_amount`
+				if spend.checked_add(&amount).map(|s| s > max_amount).unwrap_or(true) {
+					Err(Error::<T, I>::InsufficientPermission)
+				} else {
+					*spend = spend.saturating_add(amount);
+
+					Ok(())
+				}
+			})
+			.unwrap_or(Ok(()))?;
+
+			let beneficiary = T::Lookup::lookup(beneficiary)?;
+			let proposal_index = Self::proposal_count();
+			Approvals::<T, I>::try_append(proposal_index)
+				.map_err(|_| Error::<T, I>::TooManyApprovals)?;
+			let proposal = Proposal {
+				proposer: beneficiary.clone(),
+				value: amount,
+				beneficiary: beneficiary.clone(),
+				bond: Default::default(),
+			};
+			Proposals::<T, I>::insert(proposal_index, proposal);
+			ProposalCount::<T, I>::put(proposal_index + 1);
+
+			Self::deposit_event(Event::SpendApproved { proposal_index, amount, beneficiary });
+			Ok(())
+		}
+
+		/// Force a previously approved proposal to be removed from the approval queue.
+		/// The original deposit will no longer be returned.
+		///
+		/// May only be called from `T::RejectOrigin`.
+		/// - `proposal_id`: The index of a proposal
+		///
+		/// ## Complexity
+		/// - O(A) where `A` is the number of approvals
+		///
+		/// Errors:
+		/// - `ProposalNotApproved`: The `proposal_id` supplied was not found in the approval queue,
+		/// i.e., the proposal has not been approved. This could also mean the proposal does not
+		/// exist altogether, thus there is no way it would have been approved in the first place.
+		#[pallet::call_index(4)]
+		#[pallet::weight((T::WeightInfo::remove_approval(), DispatchClass::Operational))]
+		pub fn remove_approval(
+			origin: OriginFor<T>,
+			#[pallet::compact] proposal_id: ProposalIndex,
+		) -> DispatchResult {
+			T::RejectOrigin::ensure_origin(origin)?;
+
+			Approvals::<T, I>::try_mutate(|v| -> DispatchResult {
+				if let Some(index) = v.iter().position(|x| x == &proposal_id) {
+					v.remove(index);
+					Ok(())
+				} else {
+					Err(Error::<T, I>::ProposalNotApproved.into())
+				}
+			})?;
+
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	// Add public immutables and private mutables.
+
+	/// The account ID of the treasury pot.
+	///
+	/// This actually does computation. If you need to keep using it, then make sure you cache the
+	/// value and only call this once.
+	pub fn account_id() -> T::AccountId {
+		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();
+
+		let mut budget_remaining = Self::pot();
+		Self::deposit_event(Event::Spending { budget_remaining });
+		let account_id = Self::account_id();
+
+		let mut missed_any = false;
+		let mut imbalance = <PositiveImbalanceOf<T, I>>::zero();
+		let proposals_len = Approvals::<T, I>::mutate(|v| {
+			let proposals_approvals_len = v.len() as u32;
+			v.retain(|&index| {
+				// Should always be true, but shouldn't panic if false or we're screwed.
+				if let Some(p) = Self::proposals(index) {
+					if p.value <= budget_remaining {
+						budget_remaining -= p.value;
+						<Proposals<T, I>>::remove(index);
+
+						// return their deposit.
+						let err_amount = T::Currency::unreserve(&p.proposer, p.bond);
+						debug_assert!(err_amount.is_zero());
+
+						// provide the allocation.
+						imbalance.subsume(T::Currency::deposit_creating(&p.beneficiary, p.value));
+
+						Self::deposit_event(Event::Awarded {
+							proposal_index: index,
+							award: p.value,
+							account: p.beneficiary,
+						});
+						false
+					} else {
+						missed_any = true;
+						true
+					}
+				} else {
+					false
+				}
+			});
+			proposals_approvals_len
+		});
+
+		total_weight += T::WeightInfo::on_initialize_proposals(proposals_len);
+
+		// Call Runtime hooks to external pallet using treasury to compute spend funds.
+		T::SpendFunds::spend_funds(
+			&mut budget_remaining,
+			&mut imbalance,
+			&mut total_weight,
+			&mut missed_any,
+		);
+
+		if !missed_any {
+			// burn some proportion of the remaining budget if we run a surplus.
+			let burn = (T::Burn::get() * budget_remaining).min(budget_remaining);
+			budget_remaining -= burn;
+
+			let (debit, credit) = T::Currency::pair(burn);
+			imbalance.subsume(debit);
+			T::BurnDestination::on_unbalanced(credit);
+			Self::deposit_event(Event::Burnt { burnt_funds: burn })
+		}
+
+		// Must never be an error, but better to be safe.
+		// proof: budget_remaining is account free balance minus ED;
+		// Thus we can't spend more than account free balance minus ED;
+		// Thus account is kept alive; qed;
+		if let Err(problem) =
+			T::Currency::settle(&account_id, imbalance, WithdrawReasons::TRANSFER, KeepAlive)
+		{
+			print("Inconsistent state - couldn't settle imbalance for funds spent by treasury");
+			// Nothing else to do here.
+			drop(problem);
+		}
+
+		Self::deposit_event(Event::Rollover { rollover_balance: budget_remaining });
+
+		total_weight
+	}
+
+	/// Return the amount of money in the pot.
+	// The existential deposit is not part of the pot so treasury account never gets deleted.
+	pub fn pot() -> BalanceOf<T, I> {
+		T::Currency::free_balance(&Self::account_id())
+			// Must never be less than 0 but better be safe.
+			.saturating_sub(T::Currency::minimum_balance())
+	}
+}
+
+impl<T: Config<I>, I: 'static> OnUnbalanced<NegativeImbalanceOf<T, I>> for Pallet<T, I> {
+	fn on_nonzero_unbalanced(amount: NegativeImbalanceOf<T, I>) {
+		let numeric_amount = amount.peek();
+
+		// Must resolve into existing but better to be safe.
+		let _ = T::Currency::resolve_creating(&Self::account_id(), amount);
+
+		Self::deposit_event(Event::Deposit { value: numeric_amount });
+	}
+}
diff --git a/substrate/frame/treasury/src/tests.rs b/substrate/frame/treasury/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ba45d5f6ff16fb6cd40043d29e96050136ae955e
--- /dev/null
+++ b/substrate/frame/treasury/src/tests.rs
@@ -0,0 +1,604 @@
+// 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.
+
+//! Treasury pallet tests.
+
+#![cfg(test)]
+
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BadOrigin, BlakeTwo256, Dispatchable, IdentityLookup},
+	BuildStorage,
+};
+
+use frame_support::{
+	assert_err_ignore_postinfo, assert_noop, assert_ok, parameter_types,
+	traits::{ConstU32, ConstU64, OnInitialize},
+	PalletId,
+};
+
+use super::*;
+use crate as treasury;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+type UtilityCall = pallet_utility::Call<Test>;
+type TreasuryCall = crate::Call<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Treasury: treasury::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Utility: pallet_utility,
+	}
+);
+
+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 RuntimeCall = RuntimeCall;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = u128; // u64 is not enough to hold bytes used to generate bounty account
+	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>;
+}
+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 MaxHolds = ();
+}
+
+impl pallet_utility::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+}
+
+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 struct TestSpendOrigin;
+impl frame_support::traits::EnsureOrigin<RuntimeOrigin> for TestSpendOrigin {
+	type Success = u64;
+	fn try_origin(o: RuntimeOrigin) -> Result<Self::Success, RuntimeOrigin> {
+		Result::<frame_system::RawOrigin<_>, RuntimeOrigin>::from(o).and_then(|o| match o {
+			frame_system::RawOrigin::Root => Ok(u64::max_value()),
+			frame_system::RawOrigin::Signed(10) => Ok(5),
+			frame_system::RawOrigin::Signed(11) => Ok(10),
+			frame_system::RawOrigin::Signed(12) => Ok(20),
+			frame_system::RawOrigin::Signed(13) => Ok(50),
+			r => Err(RuntimeOrigin::from(r)),
+		})
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	fn try_successful_origin() -> Result<RuntimeOrigin, ()> {
+		Ok(RuntimeOrigin::root())
+	}
+}
+
+impl Config for Test {
+	type PalletId = TreasuryPalletId;
+	type Currency = pallet_balances::Pallet<Test>;
+	type ApproveOrigin = frame_system::EnsureRoot<u128>;
+	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.
+	type WeightInfo = ();
+	type SpendFunds = ();
+	type MaxApprovals = ConstU32<100>;
+	type SpendOrigin = TestSpendOrigin;
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		// Total issuance will be 200 with treasury account initialized at ED.
+		balances: vec![(0, 100), (1, 98), (2, 1)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	crate::GenesisConfig::<Test>::default().assimilate_storage(&mut t).unwrap();
+	t.into()
+}
+
+#[test]
+fn genesis_config_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Treasury::pot(), 0);
+		assert_eq!(Treasury::proposal_count(), 0);
+	});
+}
+
+#[test]
+fn spend_origin_permissioning_works() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Treasury::spend(RuntimeOrigin::signed(1), 1, 1), BadOrigin);
+		assert_noop!(
+			Treasury::spend(RuntimeOrigin::signed(10), 6, 1),
+			Error::<Test>::InsufficientPermission
+		);
+		assert_noop!(
+			Treasury::spend(RuntimeOrigin::signed(11), 11, 1),
+			Error::<Test>::InsufficientPermission
+		);
+		assert_noop!(
+			Treasury::spend(RuntimeOrigin::signed(12), 21, 1),
+			Error::<Test>::InsufficientPermission
+		);
+		assert_noop!(
+			Treasury::spend(RuntimeOrigin::signed(13), 51, 1),
+			Error::<Test>::InsufficientPermission
+		);
+	});
+}
+
+#[test]
+fn spend_origin_works() {
+	new_test_ext().execute_with(|| {
+		// Check that accumulate works when we have Some value in Dummy already.
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_ok!(Treasury::spend(RuntimeOrigin::signed(10), 5, 6));
+		assert_ok!(Treasury::spend(RuntimeOrigin::signed(10), 5, 6));
+		assert_ok!(Treasury::spend(RuntimeOrigin::signed(10), 5, 6));
+		assert_ok!(Treasury::spend(RuntimeOrigin::signed(10), 5, 6));
+		assert_ok!(Treasury::spend(RuntimeOrigin::signed(11), 10, 6));
+		assert_ok!(Treasury::spend(RuntimeOrigin::signed(12), 20, 6));
+		assert_ok!(Treasury::spend(RuntimeOrigin::signed(13), 50, 6));
+
+		<Treasury as OnInitialize<u64>>::on_initialize(1);
+		assert_eq!(Balances::free_balance(6), 0);
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		assert_eq!(Balances::free_balance(6), 100);
+		assert_eq!(Treasury::pot(), 0);
+	});
+}
+
+#[test]
+fn minting_works() {
+	new_test_ext().execute_with(|| {
+		// Check that accumulate works when we have Some value in Dummy already.
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Treasury::pot(), 100);
+	});
+}
+
+#[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)
+			},
+			Error::<Test, _>::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)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(1);
+		assert_eq!(Balances::free_balance(3), 0);
+		assert_eq!(Treasury::pot(), 100);
+	});
+}
+
+#[test]
+fn unused_pot_should_diminish() {
+	new_test_ext().execute_with(|| {
+		let init_total_issuance = Balances::total_issuance();
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		assert_eq!(Balances::total_issuance(), init_total_issuance + 100);
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		assert_eq!(Treasury::pot(), 50);
+		assert_eq!(Balances::total_issuance(), init_total_issuance + 50);
+	});
+}
+
+#[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)
+			},
+			Error::<Test, _>::InvalidIndex
+		);
+	});
+}
+
+#[test]
+fn reject_non_existent_spend_proposal_fails() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			{
+				#[allow(deprecated)]
+				Treasury::reject_proposal(RuntimeOrigin::root(), 0)
+			},
+			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)
+			},
+			Error::<Test, _>::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)
+			},
+			Error::<Test, _>::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)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		assert_eq!(Balances::free_balance(3), 100);
+		assert_eq!(Treasury::pot(), 0);
+	});
+}
+
+#[test]
+fn pot_underflow_should_not_diminish() {
+	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), 150, 3)
+		});
+		assert_ok!({
+			#[allow(deprecated)]
+			Treasury::approve_proposal(RuntimeOrigin::root(), 0)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(2);
+		assert_eq!(Treasury::pot(), 100); // Pot hasn't changed
+
+		let _ = Balances::deposit_into_existing(&Treasury::account_id(), 100).unwrap();
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+		assert_eq!(Balances::free_balance(3), 150); // Fund has been spent
+		assert_eq!(Treasury::pot(), 25); // Pot has finally changed
+	});
+}
+
+// Treasury account doesn't get deleted if amount approved to spend is all its free balance.
+// i.e. pot should not include existential deposit needed for account survival.
+#[test]
+fn treasury_account_doesnt_get_deleted() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), 101);
+		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)
+		});
+
+		<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)
+		});
+
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+		assert_eq!(Treasury::pot(), 0); // Pot is emptied
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 1); // but the account is still there
+	});
+}
+
+// In case treasury account is not existing then it works fine.
+// This is useful for chain that will just update runtime.
+#[test]
+fn inexistent_account_works() {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> { balances: vec![(0, 100), (1, 99), (2, 1)] }
+		.assimilate_storage(&mut t)
+		.unwrap();
+	// Treasury genesis config is not build thus treasury account does not exist
+	let mut t: sp_io::TestExternalities = t.into();
+
+	t.execute_with(|| {
+		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)
+		});
+		<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
+
+		Balances::make_free_balance_be(&Treasury::account_id(), 100);
+		assert_eq!(Treasury::pot(), 99); // Pot now contains funds
+		assert_eq!(Balances::free_balance(Treasury::account_id()), 100); // Account does exist
+
+		<Treasury as OnInitialize<u64>>::on_initialize(4);
+
+		assert_eq!(Treasury::pot(), 0); // Pot has changed
+		assert_eq!(Balances::free_balance(3), 99); // Balance of `3` has changed
+	});
+}
+
+#[test]
+fn genesis_funding_works() {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	let initial_funding = 100;
+	pallet_balances::GenesisConfig::<Test> {
+		// Total issuance will be 200 with treasury account initialized with 100.
+		balances: vec![(0, 100), (Treasury::account_id(), initial_funding)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+	crate::GenesisConfig::<Test>::default().assimilate_storage(&mut t).unwrap();
+	let mut t: sp_io::TestExternalities = t.into();
+
+	t.execute_with(|| {
+		assert_eq!(Balances::free_balance(Treasury::account_id()), initial_funding);
+		assert_eq!(Treasury::pot(), initial_funding - Balances::minimum_balance());
+	});
+}
+
+#[test]
+fn max_approvals_limited() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&Treasury::account_id(), u64::MAX);
+		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)
+			});
+		}
+
+		// 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)
+			},
+			Error::<Test, _>::TooManyApprovals
+		);
+	});
+}
+
+#[test]
+fn remove_already_removed_approval_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::approve_proposal(RuntimeOrigin::root(), 0)
+		});
+		assert_eq!(Treasury::approvals(), vec![0]);
+		assert_ok!(Treasury::remove_approval(RuntimeOrigin::root(), 0));
+		assert_eq!(Treasury::approvals(), vec![]);
+
+		assert_noop!(
+			Treasury::remove_approval(RuntimeOrigin::root(), 0),
+			Error::<Test, _>::ProposalNotApproved
+		);
+	});
+}
+
+#[test]
+fn spending_in_batch_respects_max_total() {
+	new_test_ext().execute_with(|| {
+		// Respect the `max_total` for the given origin.
+		assert_ok!(RuntimeCall::from(UtilityCall::batch_all {
+			calls: vec![
+				RuntimeCall::from(TreasuryCall::spend { amount: 2, beneficiary: 100 }),
+				RuntimeCall::from(TreasuryCall::spend { amount: 2, beneficiary: 101 })
+			]
+		})
+		.dispatch(RuntimeOrigin::signed(10)));
+
+		assert_err_ignore_postinfo!(
+			RuntimeCall::from(UtilityCall::batch_all {
+				calls: vec![
+					RuntimeCall::from(TreasuryCall::spend { amount: 2, beneficiary: 100 }),
+					RuntimeCall::from(TreasuryCall::spend { amount: 4, beneficiary: 101 })
+				]
+			})
+			.dispatch(RuntimeOrigin::signed(10)),
+			Error::<Test, _>::InsufficientPermission
+		);
+	})
+}
diff --git a/substrate/frame/treasury/src/weights.rs b/substrate/frame/treasury/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8f1418f76d969056c83be8673671494992e27fef
--- /dev/null
+++ b/substrate/frame/treasury/src/weights.rs
@@ -0,0 +1,256 @@
+// 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.
+
+//! Autogenerated weights for pallet_treasury
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_treasury
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/treasury/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_treasury.
+pub trait WeightInfo {
+	fn spend() -> 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;
+}
+
+/// Weights for pallet_treasury using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Treasury ProposalCount (r:1 w:1)
+	/// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Treasury Approvals (r:1 w:1)
+	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// Storage: Treasury Proposals (r:0 w:1)
+	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
+	fn spend() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `1887`
+		// Minimum execution time: 15_057_000 picoseconds.
+		Weight::from_parts(15_803_000, 1887)
+			.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: 28_923_000 picoseconds.
+		Weight::from_parts(29_495_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: 30_539_000 picoseconds.
+		Weight::from_parts(30_986_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: 9_320_000 picoseconds.
+		Weight::from_parts(12_606_599, 3573)
+			// Standard Error: 1_302
+			.saturating_add(Weight::from_parts(71_054, 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)
+	fn remove_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161`
+		//  Estimated: `1887`
+		// Minimum execution time: 7_231_000 picoseconds.
+		Weight::from_parts(7_459_000, 1887)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: Treasury Deactivated (r:1 w:1)
+	/// Proof: Treasury Deactivated (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Treasury Approvals (r:1 w:1)
+	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// Storage: Treasury Proposals (r:100 w:100)
+	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
+	/// Storage: System Account (r:200 w:200)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyApprovals (r:1 w:1)
+	/// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// The range of component `p` is `[0, 100]`.
+	fn on_initialize_proposals(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `421 + p * (251 ±0)`
+		//  Estimated: `1887 + p * (5206 ±0)`
+		// Minimum execution time: 44_769_000 picoseconds.
+		Weight::from_parts(57_915_572, 1887)
+			// Standard Error: 59_484
+			.saturating_add(Weight::from_parts(42_343_732, 0).saturating_mul(p.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(p.into())))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(p.into())))
+			.saturating_add(Weight::from_parts(0, 5206).saturating_mul(p.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Treasury ProposalCount (r:1 w:1)
+	/// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: Treasury Approvals (r:1 w:1)
+	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// Storage: Treasury Proposals (r:0 w:1)
+	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
+	fn spend() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `76`
+		//  Estimated: `1887`
+		// Minimum execution time: 15_057_000 picoseconds.
+		Weight::from_parts(15_803_000, 1887)
+			.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: 28_923_000 picoseconds.
+		Weight::from_parts(29_495_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: 30_539_000 picoseconds.
+		Weight::from_parts(30_986_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: 9_320_000 picoseconds.
+		Weight::from_parts(12_606_599, 3573)
+			// Standard Error: 1_302
+			.saturating_add(Weight::from_parts(71_054, 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)
+	fn remove_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `161`
+		//  Estimated: `1887`
+		// Minimum execution time: 7_231_000 picoseconds.
+		Weight::from_parts(7_459_000, 1887)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: Treasury Deactivated (r:1 w:1)
+	/// Proof: Treasury Deactivated (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen)
+	/// Storage: Treasury Approvals (r:1 w:1)
+	/// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// Storage: Treasury Proposals (r:100 w:100)
+	/// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen)
+	/// Storage: System Account (r:200 w:200)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Bounties BountyApprovals (r:1 w:1)
+	/// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen)
+	/// The range of component `p` is `[0, 100]`.
+	fn on_initialize_proposals(p: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `421 + p * (251 ±0)`
+		//  Estimated: `1887 + p * (5206 ±0)`
+		// Minimum execution time: 44_769_000 picoseconds.
+		Weight::from_parts(57_915_572, 1887)
+			// Standard Error: 59_484
+			.saturating_add(Weight::from_parts(42_343_732, 0).saturating_mul(p.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().reads((3_u64).saturating_mul(p.into())))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(RocksDbWeight::get().writes((3_u64).saturating_mul(p.into())))
+			.saturating_add(Weight::from_parts(0, 5206).saturating_mul(p.into()))
+	}
+}
diff --git a/substrate/frame/try-runtime/Cargo.toml b/substrate/frame/try-runtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..afd97632b3242ce5ddae65caa139bd5b92ff007a
--- /dev/null
+++ b/substrate/frame/try-runtime/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "frame-try-runtime"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for democracy"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"]}
+frame-support = { version = "4.0.0-dev", default-features = false,  path = "../support" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-support/std",
+	"sp-api/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+try-runtime = [ "frame-support/try-runtime", "sp-runtime/try-runtime" ]
diff --git a/substrate/frame/try-runtime/src/lib.rs b/substrate/frame/try-runtime/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43292efe210428980321e247807e1fc5da2d3c86
--- /dev/null
+++ b/substrate/frame/try-runtime/src/lib.rs
@@ -0,0 +1,53 @@
+// 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.
+
+//! Supporting types for try-runtime, testing and dry-running commands.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg(feature = "try-runtime")]
+
+pub use frame_support::traits::{TryStateSelect, UpgradeCheckSelect};
+use frame_support::weights::Weight;
+
+sp_api::decl_runtime_apis! {
+	/// Runtime api for testing the execution of a runtime upgrade.
+	pub trait TryRuntime {
+		/// dry-run runtime upgrades, returning the total weight consumed.
+		///
+		/// This should do EXACTLY the same operations as the runtime would have done in the case of
+		/// a runtime upgrade (e.g. pallet ordering must be the same)
+		///
+		/// Returns the consumed weight of the migration in case of a successful one, combined with
+		/// the total allowed block weight of the runtime.
+		///
+		/// If `checks` is `true`, `pre_migrate` and `post_migrate` of each migration and
+		/// `try_state` of all pallets will be executed. Else, no. If checks are executed, the PoV
+		/// tracking is likely inaccurate.
+		fn on_runtime_upgrade(checks: UpgradeCheckSelect) -> (Weight, Weight);
+
+		/// Execute the given block, but optionally disable state-root and signature checks.
+		///
+		/// Optionally, a number of `try_state` hooks can also be executed after the block
+		/// execution.
+		fn execute_block(
+			block: Block,
+			state_root_check: bool,
+			signature_check: bool,
+			try_state: TryStateSelect,
+		) -> Weight;
+	}
+}
diff --git a/substrate/frame/tx-pause/Cargo.toml b/substrate/frame/tx-pause/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..24ac55909ca910317499e43a077cea67dc7c7912
--- /dev/null
+++ b/substrate/frame/tx-pause/Cargo.toml
@@ -0,0 +1,66 @@
+[package]
+name = "pallet-tx-pause"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME transaction pause pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+scale-info = { version = "2.0.1", default-features = false, features = ["derive"] }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances", default-features = false, optional = true }
+pallet-utility = { version = "4.0.0-dev", path = "../utility", default-features = false, optional = true  }
+pallet-proxy = { version = "4.0.0-dev", path = "../proxy", default-features = false, optional = true  }
+
+[dev-dependencies]
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-utility = { version = "4.0.0-dev", path = "../utility" }
+pallet-proxy = { version = "4.0.0-dev", path = "../proxy" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances?/std",
+	"pallet-proxy?/std",
+	"pallet-utility?/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-proxy/runtime-benchmarks",
+	"pallet-utility/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances?/try-runtime",
+	"pallet-proxy?/try-runtime",
+	"pallet-utility?/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/tx-pause/src/benchmarking.rs b/substrate/frame/tx-pause/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..81595ef9f7280f42e8b50989d3f1109280da7c5d
--- /dev/null
+++ b/substrate/frame/tx-pause/src/benchmarking.rs
@@ -0,0 +1,59 @@
+// 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.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::{Pallet as TxPause, *};
+use frame_benchmarking::v2::*;
+
+#[benchmarks]
+mod benchmarks {
+	use super::*;
+
+	#[benchmark]
+	fn pause() {
+		let origin = T::PauseOrigin::try_successful_origin()
+			.expect("Tx-pause pallet is not usable without pause origin");
+		let full_name = name::<T>();
+
+		#[extrinsic_call]
+		_(origin as T::RuntimeOrigin, full_name.clone());
+
+		assert!(PausedCalls::<T>::get(full_name).is_some());
+	}
+
+	#[benchmark]
+	fn unpause() {
+		let unpause_origin = T::UnpauseOrigin::try_successful_origin()
+			.expect("Tx-pause pallet is not usable without pause origin");
+		let full_name = name::<T>();
+		TxPause::<T>::do_pause(full_name.clone()).unwrap();
+
+		#[extrinsic_call]
+		_(unpause_origin as T::RuntimeOrigin, full_name.clone());
+
+		assert!(PausedCalls::<T>::get(full_name).is_none());
+	}
+
+	impl_benchmark_test_suite!(TxPause, crate::mock::new_test_ext(), crate::mock::Test);
+}
+
+/// Longest possible name.
+fn name<T: Config>() -> RuntimeCallNameOf<T> {
+	let max_len = T::MaxNameLen::get() as usize;
+	(vec![1; max_len].try_into().unwrap(), vec![1; max_len].try_into().unwrap())
+}
diff --git a/substrate/frame/tx-pause/src/lib.rs b/substrate/frame/tx-pause/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..36147d32a2f0e477a7bdf8b6e9df5a138ed81164
--- /dev/null
+++ b/substrate/frame/tx-pause/src/lib.rs
@@ -0,0 +1,277 @@
+// 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.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![deny(rustdoc::broken_intra_doc_links)]
+
+mod benchmarking;
+pub mod mock;
+mod tests;
+pub mod weights;
+
+use frame_support::{
+	dispatch::GetDispatchInfo,
+	pallet_prelude::*,
+	traits::{CallMetadata, Contains, GetCallMetadata, IsSubType, IsType},
+	DefaultNoBound,
+};
+use frame_system::pallet_prelude::*;
+use sp_runtime::{traits::Dispatchable, DispatchResult};
+use sp_std::{convert::TryInto, prelude::*};
+
+pub use pallet::*;
+pub use weights::*;
+
+/// The stringy name of a pallet from [`GetCallMetadata`] for [`Config::RuntimeCall`] variants.
+pub type PalletNameOf<T> = BoundedVec<u8, <T as Config>::MaxNameLen>;
+
+/// The stringy name of a call (within a pallet) from [`GetCallMetadata`] for
+/// [`Config::RuntimeCall`] variants.
+pub type PalletCallNameOf<T> = BoundedVec<u8, <T as Config>::MaxNameLen>;
+
+/// A fully specified pallet ([`PalletNameOf`]) and optional call ([`PalletCallNameOf`])
+/// to partially or fully specify an item a variant of a  [`Config::RuntimeCall`].
+pub type RuntimeCallNameOf<T> = (PalletNameOf<T>, PalletCallNameOf<T>);
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(PhantomData<T>);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The overarching call type.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ GetDispatchInfo
+			+ GetCallMetadata
+			+ From<frame_system::Call<Self>>
+			+ IsSubType<Call<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+
+		/// The only origin that can pause calls.
+		type PauseOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The only origin that can un-pause calls.
+		type UnpauseOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Contains all calls that cannot be paused.
+		///
+		/// The `TxMode` pallet cannot pause its own calls, and does not need to be explicitly
+		/// added here.
+		type WhitelistedCalls: Contains<RuntimeCallNameOf<Self>>;
+
+		/// Maximum length for pallet name and call name SCALE encoded string names.
+		///
+		/// TOO LONG NAMES WILL BE TREATED AS PAUSED.
+		#[pallet::constant]
+		type MaxNameLen: Get<u32>;
+
+		// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	/// The set of calls that are explicitly paused.
+	#[pallet::storage]
+	pub type PausedCalls<T: Config> =
+		StorageMap<_, Blake2_128Concat, RuntimeCallNameOf<T>, (), OptionQuery>;
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The call is paused.
+		IsPaused,
+
+		/// The call is unpaused.
+		IsUnpaused,
+
+		/// The call is whitelisted and cannot be paused.
+		Unpausable,
+
+		// The pallet or call does not exist in the runtime.
+		NotFound,
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// This pallet, or a specific call is now paused.
+		CallPaused { full_name: RuntimeCallNameOf<T> },
+		/// This pallet, or a specific call is now unpaused.
+		CallUnpaused { full_name: RuntimeCallNameOf<T> },
+	}
+
+	/// Configure the initial state of this pallet in the genesis block.
+	#[pallet::genesis_config]
+	#[derive(DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		/// Initially paused calls.
+		pub paused: Vec<RuntimeCallNameOf<T>>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			for call in &self.paused {
+				Pallet::<T>::ensure_can_pause(&call).expect("Genesis data is known good; qed");
+				PausedCalls::<T>::insert(&call, ());
+			}
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Pause a call.
+		///
+		/// Can only be called by [`Config::PauseOrigin`].
+		/// Emits an [`Event::CallPaused`] event on success.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::pause())]
+		pub fn pause(origin: OriginFor<T>, full_name: RuntimeCallNameOf<T>) -> DispatchResult {
+			T::PauseOrigin::ensure_origin(origin)?;
+
+			Self::do_pause(full_name).map_err(Into::into)
+		}
+
+		/// Un-pause a call.
+		///
+		/// Can only be called by [`Config::UnpauseOrigin`].
+		/// Emits an [`Event::CallUnpaused`] event on success.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::unpause())]
+		pub fn unpause(origin: OriginFor<T>, ident: RuntimeCallNameOf<T>) -> DispatchResult {
+			T::UnpauseOrigin::ensure_origin(origin)?;
+
+			Self::do_unpause(ident).map_err(Into::into)
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	pub(crate) fn do_pause(ident: RuntimeCallNameOf<T>) -> Result<(), Error<T>> {
+		Self::ensure_can_pause(&ident)?;
+		PausedCalls::<T>::insert(&ident, ());
+		Self::deposit_event(Event::CallPaused { full_name: ident });
+
+		Ok(())
+	}
+
+	pub(crate) fn do_unpause(ident: RuntimeCallNameOf<T>) -> Result<(), Error<T>> {
+		Self::ensure_can_unpause(&ident)?;
+		PausedCalls::<T>::remove(&ident);
+		Self::deposit_event(Event::CallUnpaused { full_name: ident });
+
+		Ok(())
+	}
+
+	/// Return whether this call is paused.
+	pub fn is_paused(full_name: &RuntimeCallNameOf<T>) -> bool {
+		if T::WhitelistedCalls::contains(full_name) {
+			return false
+		}
+
+		<PausedCalls<T>>::contains_key(full_name)
+	}
+
+	/// Same as [`Self::is_paused`] but for inputs unbound by max-encoded-len.
+	pub fn is_paused_unbound(pallet: Vec<u8>, call: Vec<u8>) -> bool {
+		let pallet = PalletNameOf::<T>::try_from(pallet);
+		let call = PalletCallNameOf::<T>::try_from(call);
+
+		match (pallet, call) {
+			(Ok(pallet), Ok(call)) => Self::is_paused(&(pallet, call)),
+			_ => true,
+		}
+	}
+
+	/// Ensure that this call can be paused.
+	pub fn ensure_can_pause(full_name: &RuntimeCallNameOf<T>) -> Result<(), Error<T>> {
+		// SAFETY: The `TxPause` pallet can never pause itself.
+		if full_name.0.as_ref() == <Self as PalletInfoAccess>::name().as_bytes().to_vec() {
+			return Err(Error::<T>::Unpausable)
+		}
+
+		if T::WhitelistedCalls::contains(&full_name) {
+			return Err(Error::<T>::Unpausable)
+		}
+		if Self::is_paused(&full_name) {
+			return Err(Error::<T>::IsPaused)
+		}
+		Ok(())
+	}
+
+	/// Ensure that this call can be un-paused.
+	pub fn ensure_can_unpause(full_name: &RuntimeCallNameOf<T>) -> Result<(), Error<T>> {
+		if Self::is_paused(&full_name) {
+			// SAFETY: Everything that is paused, can be un-paused.
+			Ok(())
+		} else {
+			Err(Error::IsUnpaused)
+		}
+	}
+}
+
+impl<T: pallet::Config> Contains<<T as frame_system::Config>::RuntimeCall> for Pallet<T>
+where
+	<T as frame_system::Config>::RuntimeCall: GetCallMetadata,
+{
+	/// Return whether the call is allowed to be dispatched.
+	fn contains(call: &<T as frame_system::Config>::RuntimeCall) -> bool {
+		let CallMetadata { pallet_name, function_name } = call.get_call_metadata();
+		!Pallet::<T>::is_paused_unbound(pallet_name.into(), function_name.into())
+	}
+}
+
+impl<T: Config> frame_support::traits::TransactionPause for Pallet<T> {
+	type CallIdentifier = RuntimeCallNameOf<T>;
+
+	fn is_paused(full_name: Self::CallIdentifier) -> bool {
+		Self::is_paused(&full_name)
+	}
+
+	fn can_pause(full_name: Self::CallIdentifier) -> bool {
+		Self::ensure_can_pause(&full_name).is_ok()
+	}
+
+	fn pause(
+		full_name: Self::CallIdentifier,
+	) -> Result<(), frame_support::traits::TransactionPauseError> {
+		Self::do_pause(full_name).map_err(Into::into)
+	}
+
+	fn unpause(
+		full_name: Self::CallIdentifier,
+	) -> Result<(), frame_support::traits::TransactionPauseError> {
+		Self::do_unpause(full_name).map_err(Into::into)
+	}
+}
+
+impl<T: Config> From<Error<T>> for frame_support::traits::TransactionPauseError {
+	fn from(err: Error<T>) -> Self {
+		match err {
+			Error::<T>::NotFound => Self::NotFound,
+			Error::<T>::Unpausable => Self::Unpausable,
+			Error::<T>::IsPaused => Self::AlreadyPaused,
+			Error::<T>::IsUnpaused => Self::AlreadyUnpaused,
+			_ => Self::Unknown,
+		}
+	}
+}
diff --git a/substrate/frame/tx-pause/src/mock.rs b/substrate/frame/tx-pause/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..70c888f3c38da2706c31c8ae775501bb1826c974
--- /dev/null
+++ b/substrate/frame/tx-pause/src/mock.rs
@@ -0,0 +1,226 @@
+// 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.
+
+//! Tests and test utilities for transaction pause pallet.
+
+#![cfg(test)]
+
+use super::*;
+use crate as pallet_tx_pause;
+
+use frame_support::{
+	parameter_types,
+	traits::{ConstU64, Everything, InsideBoth, InstanceFilter},
+};
+use frame_system::EnsureSignedBy;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+parameter_types! {
+	pub const BlockHashCount: u64 = 250;
+}
+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;
+}
+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 MaxHolds = ConstU32<0>;
+	type MaxFreezes = ConstU32<0>;
+}
+
+impl pallet_utility::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+}
+
+/// Mocked proxies to check that tx-pause also works with the proxy pallet.
+#[derive(
+	Copy,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	Encode,
+	Decode,
+	RuntimeDebug,
+	MaxEncodedLen,
+	scale_info::TypeInfo,
+)]
+pub enum ProxyType {
+	Any,
+	JustTransfer,
+	JustUtility,
+}
+
+impl Default for ProxyType {
+	fn default() -> Self {
+		Self::Any
+	}
+}
+
+impl InstanceFilter<RuntimeCall> for ProxyType {
+	fn filter(&self, c: &RuntimeCall) -> bool {
+		match self {
+			ProxyType::Any => true,
+			ProxyType::JustTransfer => {
+				matches!(c, RuntimeCall::Balances(pallet_balances::Call::transfer { .. }))
+			},
+			ProxyType::JustUtility => matches!(c, RuntimeCall::Utility { .. }),
+		}
+	}
+	fn is_superset(&self, o: &Self) -> bool {
+		self == &ProxyType::Any || self == o
+	}
+}
+
+impl pallet_proxy::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type Currency = Balances;
+	type ProxyType = ProxyType;
+	type ProxyDepositBase = ConstU64<1>;
+	type ProxyDepositFactor = ConstU64<1>;
+	type MaxProxies = ConstU32<4>;
+	type WeightInfo = ();
+	type CallHasher = BlakeTwo256;
+	type MaxPending = ConstU32<2>;
+	type AnnouncementDepositBase = ConstU64<1>;
+	type AnnouncementDepositFactor = ConstU64<1>;
+}
+
+parameter_types! {
+	pub const MaxNameLen: u32 = 50;
+}
+
+frame_support::ord_parameter_types! {
+	pub const PauseOrigin: u64 = 1;
+	pub const UnpauseOrigin: u64 = 2;
+}
+
+/// Calls that are never allowed to be paused.
+pub struct WhitelistedCalls;
+impl Contains<RuntimeCallNameOf<Test>> for WhitelistedCalls {
+	fn contains(full_name: &RuntimeCallNameOf<Test>) -> bool {
+		match (full_name.0.as_slice(), full_name.1.as_slice()) {
+			(b"Balances", b"transfer_keep_alive") => true,
+			_ => false,
+		}
+	}
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PauseOrigin = EnsureSignedBy<PauseOrigin, Self::AccountId>;
+	type UnpauseOrigin = EnsureSignedBy<UnpauseOrigin, Self::AccountId>;
+	type WhitelistedCalls = WhitelistedCalls;
+	type MaxNameLen = MaxNameLen;
+	type WeightInfo = ();
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Utility: pallet_utility,
+		Proxy: pallet_proxy,
+		TxPause: pallet_tx_pause,
+	}
+);
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	pallet_balances::GenesisConfig::<Test> {
+		// The 0 account is NOT a special origin. The rest may be:
+		balances: vec![(0, 1234), (1, 5678), (2, 5678), (3, 5678), (4, 5678)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	pallet_tx_pause::GenesisConfig::<Test> { paused: vec![] }
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| {
+		System::set_block_number(1);
+	});
+	ext
+}
+
+pub fn next_block() {
+	TxPause::on_finalize(System::block_number());
+	Balances::on_finalize(System::block_number());
+	System::on_finalize(System::block_number());
+	System::set_block_number(System::block_number() + 1);
+	System::on_initialize(System::block_number());
+	Balances::on_initialize(System::block_number());
+	TxPause::on_initialize(System::block_number());
+}
+
+pub fn run_to(n: u64) {
+	while System::block_number() < n {
+		next_block();
+	}
+}
diff --git a/substrate/frame/tx-pause/src/tests.rs b/substrate/frame/tx-pause/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ca259315726b0bed7b99c526ab1a7703d05637d6
--- /dev/null
+++ b/substrate/frame/tx-pause/src/tests.rs
@@ -0,0 +1,222 @@
+// 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.
+
+#![cfg(test)]
+
+use super::*;
+use crate::mock::{RuntimeCall, *};
+
+use frame_support::{assert_err, assert_noop, assert_ok, dispatch::Dispatchable};
+
+// GENERAL SUCCESS/POSITIVE TESTS ---------------------
+
+#[test]
+fn can_pause_specific_call() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(call_transfer(1, 1).dispatch(RuntimeOrigin::signed(0)));
+
+		assert_ok!(TxPause::pause(
+			RuntimeOrigin::signed(mock::PauseOrigin::get()),
+			full_name::<Test>(b"Balances", b"transfer")
+		));
+
+		assert_err!(
+			call_transfer(2, 1).dispatch(RuntimeOrigin::signed(2)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+		assert_ok!(call_transfer_keep_alive(3, 1).dispatch(RuntimeOrigin::signed(3)));
+	});
+}
+
+#[test]
+fn can_pause_all_calls_in_pallet_except_on_whitelist() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(call_transfer(1, 1).dispatch(RuntimeOrigin::signed(0)));
+
+		let batch_call =
+			RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![call_transfer(1, 1)] });
+		assert_ok!(batch_call.clone().dispatch(RuntimeOrigin::signed(0)));
+
+		assert_ok!(TxPause::pause(
+			RuntimeOrigin::signed(mock::PauseOrigin::get()),
+			full_name::<Test>(b"Utility", b"batch")
+		),);
+
+		assert_err!(
+			batch_call.clone().dispatch(RuntimeOrigin::signed(0)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+	});
+}
+
+#[test]
+fn can_unpause_specific_call() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(TxPause::pause(
+			RuntimeOrigin::signed(mock::PauseOrigin::get()),
+			full_name::<Test>(b"Balances", b"transfer"),
+		));
+		assert_err!(
+			call_transfer(2, 1).dispatch(RuntimeOrigin::signed(2)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+
+		assert_ok!(TxPause::unpause(
+			RuntimeOrigin::signed(mock::UnpauseOrigin::get()),
+			full_name::<Test>(b"Balances", b"transfer"),
+		));
+		assert_ok!(call_transfer(4, 1).dispatch(RuntimeOrigin::signed(0)));
+	});
+}
+
+#[test]
+fn can_filter_balance_in_batch_when_paused() {
+	new_test_ext().execute_with(|| {
+		let batch_call =
+			RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![call_transfer(1, 1)] });
+
+		assert_ok!(TxPause::pause(
+			RuntimeOrigin::signed(mock::PauseOrigin::get()),
+			full_name::<Test>(b"Balances", b"transfer"),
+		));
+
+		assert_ok!(batch_call.clone().dispatch(RuntimeOrigin::signed(0)));
+		System::assert_last_event(
+			pallet_utility::Event::BatchInterrupted {
+				index: 0,
+				error: frame_system::Error::<Test>::CallFiltered.into(),
+			}
+			.into(),
+		);
+	});
+}
+
+#[test]
+fn can_filter_balance_in_proxy_when_paused() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(TxPause::pause(
+			RuntimeOrigin::signed(mock::PauseOrigin::get()),
+			full_name::<Test>(b"Balances", b"transfer"),
+		));
+
+		assert_ok!(Proxy::add_proxy(RuntimeOrigin::signed(1), 2, ProxyType::JustTransfer, 0));
+
+		assert_ok!(Proxy::proxy(RuntimeOrigin::signed(2), 1, None, Box::new(call_transfer(1, 1))));
+		System::assert_last_event(
+			pallet_proxy::Event::ProxyExecuted {
+				result: DispatchError::from(frame_system::Error::<Test>::CallFiltered).into(),
+			}
+			.into(),
+		);
+	});
+}
+
+// GENERAL FAIL/NEGATIVE TESTS ---------------------
+
+#[test]
+fn fails_to_pause_self() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			TxPause::pause(
+				RuntimeOrigin::signed(mock::PauseOrigin::get()),
+				full_name::<Test>(b"TxPause", b"pause"),
+			),
+			Error::<Test>::Unpausable
+		);
+	});
+}
+
+#[test]
+fn fails_to_pause_unpausable_call_when_other_call_is_paused() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(call_transfer(1, 1).dispatch(RuntimeOrigin::signed(0)));
+
+		let batch_call =
+			RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![call_transfer(1, 1)] });
+		assert_ok!(batch_call.clone().dispatch(RuntimeOrigin::signed(0)));
+
+		assert_ok!(TxPause::pause(
+			RuntimeOrigin::signed(mock::PauseOrigin::get()),
+			full_name::<Test>(b"Balances", b"transfer"),
+		));
+
+		assert_ok!(call_transfer_keep_alive(3, 1).dispatch(RuntimeOrigin::signed(3)));
+		assert_err!(
+			call_transfer(2, 1).dispatch(RuntimeOrigin::signed(0)),
+			frame_system::Error::<Test>::CallFiltered
+		);
+	});
+}
+
+#[test]
+fn fails_to_pause_unpausable_call() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			TxPause::pause(
+				RuntimeOrigin::signed(mock::PauseOrigin::get()),
+				full_name::<Test>(b"Balances", b"transfer_keep_alive"),
+			),
+			Error::<Test>::Unpausable
+		);
+	});
+}
+
+#[test]
+fn fails_to_pause_already_paused_pallet() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(TxPause::pause(
+			RuntimeOrigin::signed(mock::PauseOrigin::get()),
+			full_name::<Test>(b"Balances", b"transfer"),
+		));
+
+		assert_noop!(
+			TxPause::pause(
+				RuntimeOrigin::signed(mock::PauseOrigin::get()),
+				full_name::<Test>(b"Balances", b"transfer"),
+			),
+			Error::<Test>::IsPaused
+		);
+	});
+}
+
+#[test]
+fn fails_to_unpause_not_paused_pallet() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(
+			TxPause::unpause(
+				RuntimeOrigin::signed(mock::UnpauseOrigin::get()),
+				full_name::<Test>(b"Balances", b"transfer_keep_alive"),
+			),
+			Error::<Test>::IsUnpaused
+		);
+	});
+}
+
+pub fn call_transfer(dest: u64, value: u64) -> RuntimeCall {
+	RuntimeCall::Balances(pallet_balances::Call::transfer { dest, value })
+}
+
+pub fn call_transfer_keep_alive(dest: u64, value: u64) -> RuntimeCall {
+	RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive { dest, value })
+}
+
+pub fn full_name<T: Config>(pallet_name: &[u8], call_name: &[u8]) -> RuntimeCallNameOf<T> {
+	<RuntimeCallNameOf<T>>::from((
+		pallet_name.to_vec().try_into().unwrap(),
+		call_name.to_vec().try_into().unwrap(),
+	))
+}
diff --git a/substrate/frame/tx-pause/src/weights.rs b/substrate/frame/tx-pause/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b733e64b159dc40872e27dd540ed40820e5cc78d
--- /dev/null
+++ b/substrate/frame/tx-pause/src/weights.rs
@@ -0,0 +1,107 @@
+// 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.
+
+//! Autogenerated weights for `pallet_tx_pause`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-08-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-aahe6cbd-project-145-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
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_tx_pause
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/tx-pause/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pallet_tx_pause`.
+pub trait WeightInfo {
+	fn pause() -> Weight;
+	fn unpause() -> Weight;
+}
+
+/// Weights for `pallet_tx_pause` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `TxPause::PausedCalls` (r:1 w:1)
+	/// Proof: `TxPause::PausedCalls` (`max_values`: None, `max_size`: Some(532), added: 3007, mode: `MaxEncodedLen`)
+	fn pause() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3`
+		//  Estimated: `3997`
+		// Minimum execution time: 15_096_000 picoseconds.
+		Weight::from_parts(15_437_000, 3997)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `TxPause::PausedCalls` (r:1 w:1)
+	/// Proof: `TxPause::PausedCalls` (`max_values`: None, `max_size`: Some(532), added: 3007, mode: `MaxEncodedLen`)
+	fn unpause() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `565`
+		//  Estimated: `3997`
+		// Minimum execution time: 21_546_000 picoseconds.
+		Weight::from_parts(22_178_000, 3997)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `TxPause::PausedCalls` (r:1 w:1)
+	/// Proof: `TxPause::PausedCalls` (`max_values`: None, `max_size`: Some(532), added: 3007, mode: `MaxEncodedLen`)
+	fn pause() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `3`
+		//  Estimated: `3997`
+		// Minimum execution time: 15_096_000 picoseconds.
+		Weight::from_parts(15_437_000, 3997)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `TxPause::PausedCalls` (r:1 w:1)
+	/// Proof: `TxPause::PausedCalls` (`max_values`: None, `max_size`: Some(532), added: 3007, mode: `MaxEncodedLen`)
+	fn unpause() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `565`
+		//  Estimated: `3997`
+		// Minimum execution time: 21_546_000 picoseconds.
+		Weight::from_parts(22_178_000, 3997)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+}
diff --git a/substrate/frame/uniques/Cargo.toml b/substrate/frame/uniques/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..28ebc1ff50fe5b46890c7b307c726772ca6497ad
--- /dev/null
+++ b/substrate/frame/uniques/Cargo.toml
@@ -0,0 +1,58 @@
+[package]
+name = "pallet-uniques"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME NFT asset management pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+sp-std = { version = "8.0.0", path = "../../primitives/std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/uniques/README.md b/substrate/frame/uniques/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6cdbcf79f1c95442cd9ec602ffb482f61ba0945f
--- /dev/null
+++ b/substrate/frame/uniques/README.md
@@ -0,0 +1,82 @@
+# Uniques Module
+
+A simple, secure module for dealing with non-fungible assets.
+
+## Overview
+
+The Uniques module provides functionality for non-fungible tokens' management, including:
+
+* Collection Creation
+* Item Minting
+* Item Transfers
+* Item Trading methods
+* Attributes Management
+* Item Burning
+
+To use it in your runtime, you need to implement [`uniques::Config`](https://paritytech.github.io/substrate/master/pallet_uniques/pallet/trait.Config.html).
+
+The supported dispatchable functions are documented in the [`uniques::Call`](https://paritytech.github.io/substrate/master/pallet_uniques/pallet/enum.Call.html) enum.
+
+### Terminology
+
+* **Collection creation:** The creation of a new collection.
+* **Item minting:** The action of creating a new item within a collection.
+* **Item transfer:** The action of sending an item from one account to another.
+* **Item burning:** The destruction of an item.
+* **Non-fungible token (NFT):** An item for which each unit has unique characteristics. There is exactly
+  one instance of such an item in existence and there is exactly one owning account.
+
+### Goals
+
+The Uniques pallet in Substrate is designed to make the following possible:
+
+* Allow accounts to permissionlessly create NFT collections.
+* Allow a named (permissioned) account to mint and burn unique items within a collection.
+* Move items between accounts permissionlessly.
+* Allow a named (permissioned) account to freeze and unfreeze unique items within a
+  collection or the entire collection.
+* Allow the owner of an item to delegate the ability to transfer the item to some
+  named third-party.
+
+## Interface
+
+### Permissionless dispatchables
+* `create`: Create a new collection by placing a deposit.
+* `transfer`: Transfer an item to a new owner.
+* `redeposit`: Update the deposit amount of an item, potentially freeing funds.
+* `approve_transfer`: Name a delegate who may authorise a transfer.
+* `cancel_approval`: Revert the effects of a previous `approve_transfer`.
+
+### Permissioned dispatchables
+* `destroy`: Destroy a collection.
+* `mint`: Mint a new item within a collection.
+* `burn`: Burn an item within a collection.
+* `freeze`: Prevent an individual item from being transferred.
+* `thaw`: Revert the effects of a previous `freeze`.
+* `freeze_collection`: Prevent all items within a collection from being transferred.
+* `thaw_collection`: Revert the effects of a previous `freeze_collection`.
+* `transfer_ownership`: Alter the owner of a collection, moving all associated deposits.
+* `set_team`: Alter the permissioned accounts of a collection.
+
+### Metadata (permissioned) dispatchables
+* `set_attribute`: Set an attribute of an item or collection.
+* `clear_attribute`: Remove an attribute of an item or collection.
+* `set_metadata`: Set general metadata of an item.
+* `clear_metadata`: Remove general metadata of an item.
+* `set_collection_metadata`: Set general metadata of a collection.
+* `clear_collection_metadata`: Remove general metadata of a collection.
+
+### Force (i.e. governance) dispatchables
+* `force_create`: Create a new collection.
+* `force_asset_status`: Alter the underlying characteristics of a collection.
+
+Please refer to the [`Call`](https://paritytech.github.io/substrate/master/pallet_uniques/pallet/enum.Call.html) enum
+and its associated variants for documentation on each function.
+
+## Related Modules
+
+* [`System`](https://docs.rs/frame-system/latest/frame_system/)
+* [`Support`](https://docs.rs/frame-support/latest/frame_support/)
+* [`Assets`](https://docs.rs/pallet-assets/latest/pallet_assets/)
+
+License: Apache-2.0
diff --git a/substrate/frame/uniques/src/benchmarking.rs b/substrate/frame/uniques/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e63f69281e5d431c80f21ab609ebf6d65eeeec9
--- /dev/null
+++ b/substrate/frame/uniques/src/benchmarking.rs
@@ -0,0 +1,449 @@
+// 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.
+
+//! Uniques pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{
+	account, benchmarks_instance_pallet, whitelist_account, whitelisted_caller, BenchmarkError,
+};
+use frame_support::{
+	dispatch::UnfilteredDispatchable,
+	traits::{EnsureOrigin, Get},
+	BoundedVec,
+};
+use frame_system::RawOrigin as SystemOrigin;
+use sp_runtime::traits::Bounded;
+use sp_std::prelude::*;
+
+use crate::Pallet as Uniques;
+
+const SEED: u32 = 0;
+
+fn create_collection<T: Config<I>, I: 'static>(
+) -> (T::CollectionId, T::AccountId, AccountIdLookupOf<T>) {
+	let caller: T::AccountId = whitelisted_caller();
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let collection = T::Helper::collection(0);
+	T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+	assert!(Uniques::<T, I>::force_create(
+		SystemOrigin::Root.into(),
+		collection.clone(),
+		caller_lookup.clone(),
+		false,
+	)
+	.is_ok());
+	(collection, caller, caller_lookup)
+}
+
+fn add_collection_metadata<T: Config<I>, I: 'static>() -> (T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	assert!(Uniques::<T, I>::set_collection_metadata(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
+		false,
+	)
+	.is_ok());
+	(caller, caller_lookup)
+}
+
+fn mint_item<T: Config<I>, I: 'static>(
+	index: u16,
+) -> (T::ItemId, T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().admin;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let item = T::Helper::item(index);
+	assert!(Uniques::<T, I>::mint(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		item,
+		caller_lookup.clone(),
+	)
+	.is_ok());
+	(item, caller, caller_lookup)
+}
+
+fn add_item_metadata<T: Config<I>, I: 'static>(
+	item: T::ItemId,
+) -> (T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	assert!(Uniques::<T, I>::set_metadata(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		item,
+		vec![0; T::StringLimit::get() as usize].try_into().unwrap(),
+		false,
+	)
+	.is_ok());
+	(caller, caller_lookup)
+}
+
+fn add_item_attribute<T: Config<I>, I: 'static>(
+	item: T::ItemId,
+) -> (BoundedVec<u8, T::KeyLimit>, T::AccountId, AccountIdLookupOf<T>) {
+	let caller = Collection::<T, I>::get(T::Helper::collection(0)).unwrap().owner;
+	if caller != whitelisted_caller() {
+		whitelist_account!(caller);
+	}
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	let key: BoundedVec<_, _> = vec![0; T::KeyLimit::get() as usize].try_into().unwrap();
+	assert!(Uniques::<T, I>::set_attribute(
+		SystemOrigin::Signed(caller.clone()).into(),
+		T::Helper::collection(0),
+		Some(item),
+		key.clone(),
+		vec![0; T::ValueLimit::get() as usize].try_into().unwrap(),
+	)
+	.is_ok());
+	(key, caller, caller_lookup)
+}
+
+fn assert_last_event<T: Config<I>, I: 'static>(generic_event: <T as Config<I>>::RuntimeEvent) {
+	let events = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+benchmarks_instance_pallet! {
+	create {
+		let collection = T::Helper::collection(0);
+		let origin = T::CreateOrigin::try_successful_origin(&collection)
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let caller = T::CreateOrigin::ensure_origin(origin.clone(), &collection).unwrap();
+		whitelist_account!(caller);
+		let admin = T::Lookup::unlookup(caller.clone());
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+		let call = Call::<T, I>::create { collection, admin };
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::Created { collection: T::Helper::collection(0), creator: caller.clone(), owner: caller }.into());
+	}
+
+	force_create {
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+	}: _(SystemOrigin::Root, T::Helper::collection(0), caller_lookup, true)
+	verify {
+		assert_last_event::<T, I>(Event::ForceCreated { collection: T::Helper::collection(0), owner: caller }.into());
+	}
+
+	destroy {
+		let n in 0 .. 1_000;
+		let m in 0 .. 1_000;
+		let a in 0 .. 1_000;
+
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		add_collection_metadata::<T, I>();
+		for i in 0..n {
+			mint_item::<T, I>(i as u16);
+		}
+		for i in 0..m {
+			add_item_metadata::<T, I>(T::Helper::item(i as u16));
+		}
+		for i in 0..a {
+			add_item_attribute::<T, I>(T::Helper::item(i as u16));
+		}
+		let witness = Collection::<T, I>::get(collection.clone()).unwrap().destroy_witness();
+	}: _(SystemOrigin::Signed(caller), collection.clone(), witness)
+	verify {
+		assert_last_event::<T, I>(Event::Destroyed { collection: collection.clone() }.into());
+	}
+
+	mint {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let item = T::Helper::item(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), item, caller_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::Issued { collection: collection.clone(), item, owner: caller }.into());
+	}
+
+	burn {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), item, Some(caller_lookup))
+	verify {
+		assert_last_event::<T, I>(Event::Burned { collection: collection.clone(), item, owner: caller }.into());
+	}
+
+	transfer {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), item, target_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::Transferred { collection: collection.clone(), item, from: caller, to: target }.into());
+	}
+
+	redeposit {
+		let i in 0 .. 5_000;
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let items = (0..i).map(|x| mint_item::<T, I>(x as u16).0).collect::<Vec<_>>();
+		Uniques::<T, I>::force_item_status(
+			SystemOrigin::Root.into(),
+			collection.clone(),
+			caller_lookup.clone(),
+			caller_lookup.clone(),
+			caller_lookup.clone(),
+			caller_lookup,
+			true,
+			false,
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), items.clone())
+	verify {
+		assert_last_event::<T, I>(Event::Redeposited { collection: collection.clone(), successful_items: items }.into());
+	}
+
+	freeze {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller.clone()), T::Helper::collection(0), T::Helper::item(0))
+	verify {
+		assert_last_event::<T, I>(Event::Frozen { collection: T::Helper::collection(0), item: T::Helper::item(0) }.into());
+	}
+
+	thaw {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		Uniques::<T, I>::freeze(
+			SystemOrigin::Signed(caller.clone()).into(),
+			collection.clone(),
+			item,
+		)?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), item)
+	verify {
+		assert_last_event::<T, I>(Event::Thawed { collection: collection.clone(), item }.into());
+	}
+
+	freeze_collection {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone())
+	verify {
+		assert_last_event::<T, I>(Event::CollectionFrozen { collection: collection.clone() }.into());
+	}
+
+	thaw_collection {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		Uniques::<T, I>::freeze_collection(origin, collection.clone())?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone())
+	verify {
+		assert_last_event::<T, I>(Event::CollectionThawed { collection: collection.clone() }.into());
+	}
+
+	transfer_ownership {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
+		let origin = SystemOrigin::Signed(target.clone()).into();
+		Uniques::<T, I>::set_accept_ownership(origin, Some(collection.clone()))?;
+	}: _(SystemOrigin::Signed(caller), collection.clone(), target_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::OwnerChanged { collection: collection.clone(), new_owner: target }.into());
+	}
+
+	set_team {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let target0 = T::Lookup::unlookup(account("target", 0, SEED));
+		let target1 = T::Lookup::unlookup(account("target", 1, SEED));
+		let target2 = T::Lookup::unlookup(account("target", 2, SEED));
+	}: _(SystemOrigin::Signed(caller), collection.clone(), target0, target1, target2)
+	verify {
+		assert_last_event::<T, I>(Event::TeamChanged{
+			collection: collection.clone(),
+			issuer: account("target", 0, SEED),
+			admin: account("target", 1, SEED),
+			freezer: account("target", 2, SEED),
+		}.into());
+	}
+
+	force_item_status {
+		let (collection, caller, caller_lookup) = create_collection::<T, I>();
+		let origin =
+			T::ForceOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call = Call::<T, I>::force_item_status {
+			collection: collection.clone(),
+			owner: caller_lookup.clone(),
+			issuer: caller_lookup.clone(),
+			admin: caller_lookup.clone(),
+			freezer: caller_lookup,
+			free_holding: true,
+			is_frozen: false,
+		};
+	}: { call.dispatch_bypass_filter(origin)? }
+	verify {
+		assert_last_event::<T, I>(Event::ItemStatusChanged { collection: collection.clone() }.into());
+	}
+
+	set_attribute {
+		let key: BoundedVec<_, _> = vec![0u8; T::KeyLimit::get() as usize].try_into().unwrap();
+		let value: BoundedVec<_, _> = vec![0u8; T::ValueLimit::get() as usize].try_into().unwrap();
+
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection.clone(), Some(item), key.clone(), value.clone())
+	verify {
+		assert_last_event::<T, I>(Event::AttributeSet { collection: collection.clone(), maybe_item: Some(item), key, value }.into());
+	}
+
+	clear_attribute {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+		let (key, ..) = add_item_attribute::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection.clone(), Some(item), key.clone())
+	verify {
+		assert_last_event::<T, I>(Event::AttributeCleared { collection: collection.clone(), maybe_item: Some(item), key }.into());
+	}
+
+	set_metadata {
+		let data: BoundedVec<_, _> = vec![0u8; T::StringLimit::get() as usize].try_into().unwrap();
+
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+	}: _(SystemOrigin::Signed(caller), collection.clone(), item, data.clone(), false)
+	verify {
+		assert_last_event::<T, I>(Event::MetadataSet { collection: collection.clone(), item, data, is_frozen: false }.into());
+	}
+
+	clear_metadata {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		add_item_metadata::<T, I>(item);
+	}: _(SystemOrigin::Signed(caller), collection.clone(), item)
+	verify {
+		assert_last_event::<T, I>(Event::MetadataCleared { collection: collection.clone(), item }.into());
+	}
+
+	set_collection_metadata {
+		let data: BoundedVec<_, _> = vec![0u8; T::StringLimit::get() as usize].try_into().unwrap();
+
+		let (collection, caller, _) = create_collection::<T, I>();
+	}: _(SystemOrigin::Signed(caller), collection.clone(), data.clone(), false)
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMetadataSet { collection: collection.clone(), data, is_frozen: false }.into());
+	}
+
+	clear_collection_metadata {
+		let (collection, caller, _) = create_collection::<T, I>();
+		add_collection_metadata::<T, I>();
+	}: _(SystemOrigin::Signed(caller), collection.clone())
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMetadataCleared { collection: collection.clone() }.into());
+	}
+
+	approve_transfer {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), item, delegate_lookup)
+	verify {
+		assert_last_event::<T, I>(Event::ApprovedTransfer { collection: collection.clone(), item, owner: caller, delegate }.into());
+	}
+
+	cancel_approval {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let origin = SystemOrigin::Signed(caller.clone()).into();
+		Uniques::<T, I>::approve_transfer(origin, collection.clone(), item, delegate_lookup.clone())?;
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), item, Some(delegate_lookup))
+	verify {
+		assert_last_event::<T, I>(Event::ApprovalCancelled { collection: collection.clone(), item, owner: caller, delegate }.into());
+	}
+
+	set_accept_ownership {
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, DepositBalanceOf::<T, I>::max_value());
+		let collection = T::Helper::collection(0);
+	}: _(SystemOrigin::Signed(caller.clone()), Some(collection.clone()))
+	verify {
+		assert_last_event::<T, I>(Event::OwnershipAcceptanceChanged {
+			who: caller,
+			maybe_collection: Some(collection),
+		}.into());
+	}
+
+	set_collection_max_supply {
+		let (collection, caller, _) = create_collection::<T, I>();
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), u32::MAX)
+	verify {
+		assert_last_event::<T, I>(Event::CollectionMaxSupplySet {
+			collection: collection.clone(),
+			max_supply: u32::MAX,
+		}.into());
+	}
+
+	set_price {
+		let (collection, caller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let delegate: T::AccountId = account("delegate", 0, SEED);
+		let delegate_lookup = T::Lookup::unlookup(delegate.clone());
+		let price = ItemPrice::<T, I>::from(100u32);
+	}: _(SystemOrigin::Signed(caller.clone()), collection.clone(), item, Some(price), Some(delegate_lookup))
+	verify {
+		assert_last_event::<T, I>(Event::ItemPriceSet {
+			collection: collection.clone(),
+			item,
+			price,
+			whitelisted_buyer: Some(delegate),
+		}.into());
+	}
+
+	buy_item {
+		let (collection, seller, _) = create_collection::<T, I>();
+		let (item, ..) = mint_item::<T, I>(0);
+		let buyer: T::AccountId = account("buyer", 0, SEED);
+		let buyer_lookup = T::Lookup::unlookup(buyer.clone());
+		let price = ItemPrice::<T, I>::from(0u32);
+		let origin = SystemOrigin::Signed(seller.clone()).into();
+		Uniques::<T, I>::set_price(origin, collection.clone(), item, Some(price.clone()), Some(buyer_lookup))?;
+		T::Currency::make_free_balance_be(&buyer, DepositBalanceOf::<T, I>::max_value());
+	}: _(SystemOrigin::Signed(buyer.clone()), collection.clone(), item, price.clone())
+	verify {
+		assert_last_event::<T, I>(Event::ItemBought {
+			collection: collection.clone(),
+			item,
+			price,
+			seller,
+			buyer,
+		}.into());
+	}
+
+	impl_benchmark_test_suite!(Uniques, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/uniques/src/functions.rs b/substrate/frame/uniques/src/functions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1977c23f67e5ecc258140782f09dc2d3bc875a59
--- /dev/null
+++ b/substrate/frame/uniques/src/functions.rs
@@ -0,0 +1,350 @@
+// 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.
+
+//! Various pieces of common functionality.
+
+use super::*;
+use frame_support::{
+	ensure,
+	traits::{ExistenceRequirement, Get},
+};
+use sp_runtime::{DispatchError, DispatchResult};
+
+impl<T: Config<I>, I: 'static> Pallet<T, I> {
+	/// Perform a transfer of an item from one account to another within a collection.
+	///
+	/// # Errors
+	/// This function returns a dispatch error in the following cases:
+	/// - The collection or item does not exist
+	///   ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - The collection is frozen, and no transfers are allowed ([`Frozen`](crate::Error::Frozen)).
+	/// - The item is locked, and transfers are not permitted ([`Locked`](crate::Error::Locked)).
+	/// - The `with_details` closure returns an error.
+	pub fn do_transfer(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		dest: T::AccountId,
+		with_details: impl FnOnce(
+			&CollectionDetailsFor<T, I>,
+			&mut ItemDetailsFor<T, I>,
+		) -> DispatchResult,
+	) -> DispatchResult {
+		let collection_details =
+			Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+		ensure!(!collection_details.is_frozen, Error::<T, I>::Frozen);
+		ensure!(!T::Locker::is_locked(collection.clone(), item), Error::<T, I>::Locked);
+
+		let mut details =
+			Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownCollection)?;
+		ensure!(!details.is_frozen, Error::<T, I>::Frozen);
+		with_details(&collection_details, &mut details)?;
+
+		Account::<T, I>::remove((&details.owner, &collection, &item));
+		Account::<T, I>::insert((&dest, &collection, &item), ());
+		let origin = details.owner;
+		details.owner = dest;
+
+		// The approved account has to be reset to `None`, because otherwise pre-approve attack
+		// would be possible, where the owner can approve their second account before making the
+		// transaction and then claiming the item back.
+		details.approved = None;
+
+		Item::<T, I>::insert(&collection, &item, &details);
+		ItemPriceOf::<T, I>::remove(&collection, &item);
+
+		Self::deposit_event(Event::Transferred {
+			collection,
+			item,
+			from: origin,
+			to: details.owner,
+		});
+		Ok(())
+	}
+
+	/// Create a new collection with the provided details.
+	///
+	/// # Errors
+	/// This function returns a dispatch error in the following cases:
+	/// - If the collection ID is already in use ([`InUse`](crate::Error::InUse)).
+	/// - If reserving the deposit fails (e.g., insufficient funds).
+	pub fn do_create_collection(
+		collection: T::CollectionId,
+		owner: T::AccountId,
+		admin: T::AccountId,
+		deposit: DepositBalanceOf<T, I>,
+		free_holding: bool,
+		event: Event<T, I>,
+	) -> DispatchResult {
+		ensure!(!Collection::<T, I>::contains_key(collection.clone()), Error::<T, I>::InUse);
+
+		T::Currency::reserve(&owner, deposit)?;
+
+		Collection::<T, I>::insert(
+			collection.clone(),
+			CollectionDetails {
+				owner: owner.clone(),
+				issuer: admin.clone(),
+				admin: admin.clone(),
+				freezer: admin,
+				total_deposit: deposit,
+				free_holding,
+				items: 0,
+				item_metadatas: 0,
+				attributes: 0,
+				is_frozen: false,
+			},
+		);
+
+		CollectionAccount::<T, I>::insert(&owner, &collection, ());
+		Self::deposit_event(event);
+		Ok(())
+	}
+
+	/// Destroy a collection along with its associated items and metadata.
+	///
+	/// # Errors
+	/// This function returns a dispatch error in the following cases:
+	/// - The collection does not exist ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - The provided witness does not match the actual counts
+	///   ([`BadWitness`](crate::Error::BadWitness)).
+	/// - The caller is not the owner of the collection
+	///   ([`NoPermission`](crate::Error::NoPermission)).
+	pub fn do_destroy_collection(
+		collection: T::CollectionId,
+		witness: DestroyWitness,
+		maybe_check_owner: Option<T::AccountId>,
+	) -> Result<DestroyWitness, DispatchError> {
+		Collection::<T, I>::try_mutate_exists(collection.clone(), |maybe_details| {
+			let collection_details =
+				maybe_details.take().ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = maybe_check_owner {
+				ensure!(collection_details.owner == check_owner, Error::<T, I>::NoPermission);
+			}
+			ensure!(collection_details.items == witness.items, Error::<T, I>::BadWitness);
+			ensure!(
+				collection_details.item_metadatas == witness.item_metadatas,
+				Error::<T, I>::BadWitness
+			);
+			ensure!(collection_details.attributes == witness.attributes, Error::<T, I>::BadWitness);
+
+			for (item, details) in Item::<T, I>::drain_prefix(&collection) {
+				Account::<T, I>::remove((&details.owner, &collection, &item));
+			}
+			#[allow(deprecated)]
+			ItemMetadataOf::<T, I>::remove_prefix(&collection, None);
+			#[allow(deprecated)]
+			ItemPriceOf::<T, I>::remove_prefix(&collection, None);
+			CollectionMetadataOf::<T, I>::remove(&collection);
+			#[allow(deprecated)]
+			Attribute::<T, I>::remove_prefix((&collection,), None);
+			CollectionAccount::<T, I>::remove(&collection_details.owner, &collection);
+			T::Currency::unreserve(&collection_details.owner, collection_details.total_deposit);
+			CollectionMaxSupply::<T, I>::remove(&collection);
+
+			Self::deposit_event(Event::Destroyed { collection });
+
+			Ok(DestroyWitness {
+				items: collection_details.items,
+				item_metadatas: collection_details.item_metadatas,
+				attributes: collection_details.attributes,
+			})
+		})
+	}
+
+	/// Mint (create) a new item within a collection and assign ownership to an account.
+	///
+	/// # Errors
+	/// This function returns a dispatch error in the following cases:
+	/// - The item already exists in the collection
+	///   ([`AlreadyExists`](crate::Error::AlreadyExists)).
+	/// - The collection does not exist ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - The provided closure `with_details` returns an error.
+	/// - The collection has reached its maximum supply
+	///   ([`MaxSupplyReached`](crate::Error::MaxSupplyReached)).
+	/// - An arithmetic overflow occurs when incrementing the number of items in the collection.
+	/// - The currency reserve operation for the item deposit fails for any reason.
+	pub fn do_mint(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		owner: T::AccountId,
+		with_details: impl FnOnce(&CollectionDetailsFor<T, I>) -> DispatchResult,
+	) -> DispatchResult {
+		ensure!(
+			!Item::<T, I>::contains_key(collection.clone(), item),
+			Error::<T, I>::AlreadyExists
+		);
+
+		Collection::<T, I>::try_mutate(
+			&collection,
+			|maybe_collection_details| -> DispatchResult {
+				let collection_details =
+					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+
+				with_details(collection_details)?;
+
+				if let Ok(max_supply) = CollectionMaxSupply::<T, I>::try_get(&collection) {
+					ensure!(collection_details.items < max_supply, Error::<T, I>::MaxSupplyReached);
+				}
+
+				let items =
+					collection_details.items.checked_add(1).ok_or(ArithmeticError::Overflow)?;
+				collection_details.items = items;
+
+				let deposit = match collection_details.free_holding {
+					true => Zero::zero(),
+					false => T::ItemDeposit::get(),
+				};
+				T::Currency::reserve(&collection_details.owner, deposit)?;
+				collection_details.total_deposit += deposit;
+
+				let owner = owner.clone();
+				Account::<T, I>::insert((&owner, &collection, &item), ());
+				let details = ItemDetails { owner, approved: None, is_frozen: false, deposit };
+				Item::<T, I>::insert(&collection, &item, details);
+				Ok(())
+			},
+		)?;
+
+		Self::deposit_event(Event::Issued { collection, item, owner });
+		Ok(())
+	}
+
+	/// Burn (destroy) an item from a collection.
+	///
+	/// # Errors
+	/// This function returns a `Dispatch` error in the following cases:
+	/// - The item is locked and burns are not permitted ([`Locked`](crate::Error::Locked)).
+	/// - The collection or item does not exist
+	///   ([`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - The `with_details` closure returns an error.
+	pub fn do_burn(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		with_details: impl FnOnce(&CollectionDetailsFor<T, I>, &ItemDetailsFor<T, I>) -> DispatchResult,
+	) -> DispatchResult {
+		ensure!(!T::Locker::is_locked(collection.clone(), item), Error::<T, I>::Locked);
+		let owner = Collection::<T, I>::try_mutate(
+			&collection,
+			|maybe_collection_details| -> Result<T::AccountId, DispatchError> {
+				let collection_details =
+					maybe_collection_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+				let details = Item::<T, I>::get(&collection, &item)
+					.ok_or(Error::<T, I>::UnknownCollection)?;
+				with_details(collection_details, &details)?;
+
+				// Return the deposit.
+				T::Currency::unreserve(&collection_details.owner, details.deposit);
+				collection_details.total_deposit.saturating_reduce(details.deposit);
+				collection_details.items.saturating_dec();
+				Ok(details.owner)
+			},
+		)?;
+
+		Item::<T, I>::remove(&collection, &item);
+		Account::<T, I>::remove((&owner, &collection, &item));
+		ItemPriceOf::<T, I>::remove(&collection, &item);
+
+		Self::deposit_event(Event::Burned { collection, item, owner });
+		Ok(())
+	}
+
+	/// Set or remove the price for an item in a collection.
+	///
+	/// # Errors
+	/// This function returns a dispatch error in the following cases:
+	/// - The item or collection does not exist ([`UnknownItem`](crate::Error::UnknownItem) or
+	///   [`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - The sender is not the owner of the item ([`NoPermission`](crate::Error::NoPermission)).
+	pub fn do_set_price(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		sender: T::AccountId,
+		price: Option<ItemPrice<T, I>>,
+		whitelisted_buyer: Option<T::AccountId>,
+	) -> DispatchResult {
+		let details = Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(details.owner == sender, Error::<T, I>::NoPermission);
+
+		if let Some(ref price) = price {
+			ItemPriceOf::<T, I>::insert(&collection, &item, (price, whitelisted_buyer.clone()));
+			Self::deposit_event(Event::ItemPriceSet {
+				collection,
+				item,
+				price: *price,
+				whitelisted_buyer,
+			});
+		} else {
+			ItemPriceOf::<T, I>::remove(&collection, &item);
+			Self::deposit_event(Event::ItemPriceRemoved { collection, item });
+		}
+
+		Ok(())
+	}
+
+	/// Buy an item from a collection.
+	///
+	/// # Errors
+	/// This function returns a dispatch error in the following cases:
+	/// - The item or collection does not exist ([`UnknownItem`](crate::Error::UnknownItem) or
+	///   [`UnknownCollection`](crate::Error::UnknownCollection)).
+	/// - The buyer is the current owner of the item ([`NoPermission`](crate::Error::NoPermission)).
+	/// - The item is not for sale ([`NotForSale`](crate::Error::NotForSale)).
+	/// - The bid price is lower than the item's sale price
+	///   ([`BidTooLow`](crate::Error::BidTooLow)).
+	/// - The item is set to be sold only to a specific buyer, and the provided buyer is not the
+	///   whitelisted buyer ([`NoPermission`](crate::Error::NoPermission)).
+	/// - The currency transfer between the buyer and the owner fails for any reason.
+	pub fn do_buy_item(
+		collection: T::CollectionId,
+		item: T::ItemId,
+		buyer: T::AccountId,
+		bid_price: ItemPrice<T, I>,
+	) -> DispatchResult {
+		let details = Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownItem)?;
+		ensure!(details.owner != buyer, Error::<T, I>::NoPermission);
+
+		let price_info =
+			ItemPriceOf::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::NotForSale)?;
+
+		ensure!(bid_price >= price_info.0, Error::<T, I>::BidTooLow);
+
+		if let Some(only_buyer) = price_info.1 {
+			ensure!(only_buyer == buyer, Error::<T, I>::NoPermission);
+		}
+
+		T::Currency::transfer(
+			&buyer,
+			&details.owner,
+			price_info.0,
+			ExistenceRequirement::KeepAlive,
+		)?;
+
+		let old_owner = details.owner.clone();
+
+		Self::do_transfer(collection.clone(), item, buyer.clone(), |_, _| Ok(()))?;
+
+		Self::deposit_event(Event::ItemBought {
+			collection,
+			item,
+			price: price_info.0,
+			seller: old_owner,
+			buyer,
+		});
+
+		Ok(())
+	}
+}
diff --git a/substrate/frame/uniques/src/impl_nonfungibles.rs b/substrate/frame/uniques/src/impl_nonfungibles.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0ae055a98d8c8bd551106cf4ef3c47503e41a83c
--- /dev/null
+++ b/substrate/frame/uniques/src/impl_nonfungibles.rs
@@ -0,0 +1,199 @@
+// 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.
+
+//! Implementations for `nonfungibles` traits.
+
+use super::*;
+use frame_support::{
+	storage::KeyPrefixIterator,
+	traits::{tokens::nonfungibles::*, Get},
+	BoundedSlice,
+};
+use sp_runtime::{DispatchError, DispatchResult};
+use sp_std::prelude::*;
+
+impl<T: Config<I>, I: 'static> Inspect<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	type ItemId = T::ItemId;
+	type CollectionId = T::CollectionId;
+
+	fn owner(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+	) -> Option<<T as SystemConfig>::AccountId> {
+		Item::<T, I>::get(collection, item).map(|a| a.owner)
+	}
+
+	fn collection_owner(collection: &Self::CollectionId) -> Option<<T as SystemConfig>::AccountId> {
+		Collection::<T, I>::get(collection).map(|a| a.owner)
+	}
+
+	/// Returns the attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// When `key` is empty, we return the item metadata value.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn attribute(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		key: &[u8],
+	) -> Option<Vec<u8>> {
+		if key.is_empty() {
+			// We make the empty key map to the item metadata value.
+			ItemMetadataOf::<T, I>::get(collection, item).map(|m| m.data.into())
+		} else {
+			let key = BoundedSlice::<_, _>::try_from(key).ok()?;
+			Attribute::<T, I>::get((collection, Some(item), key)).map(|a| a.0.into())
+		}
+	}
+
+	/// Returns the attribute value of `item` of `collection` corresponding to `key`.
+	///
+	/// When `key` is empty, we return the item metadata value.
+	///
+	/// By default this is `None`; no attributes are defined.
+	fn collection_attribute(collection: &Self::CollectionId, key: &[u8]) -> Option<Vec<u8>> {
+		if key.is_empty() {
+			// We make the empty key map to the item metadata value.
+			CollectionMetadataOf::<T, I>::get(collection).map(|m| m.data.into())
+		} else {
+			let key = BoundedSlice::<_, _>::try_from(key).ok()?;
+			Attribute::<T, I>::get((collection, Option::<T::ItemId>::None, key)).map(|a| a.0.into())
+		}
+	}
+
+	/// Returns `true` if the `item` of `collection` may be transferred.
+	///
+	/// Default implementation is that all items are transferable.
+	fn can_transfer(collection: &Self::CollectionId, item: &Self::ItemId) -> bool {
+		match (Collection::<T, I>::get(collection), Item::<T, I>::get(collection, item)) {
+			(Some(cd), Some(id)) if !cd.is_frozen && !id.is_frozen => true,
+			_ => false,
+		}
+	}
+}
+
+impl<T: Config<I>, I: 'static> Create<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	/// Create a `collection` of nonfungible items to be owned by `who` and managed by `admin`.
+	fn create_collection(
+		collection: &Self::CollectionId,
+		who: &T::AccountId,
+		admin: &T::AccountId,
+	) -> DispatchResult {
+		Self::do_create_collection(
+			collection.clone(),
+			who.clone(),
+			admin.clone(),
+			T::CollectionDeposit::get(),
+			false,
+			Event::Created {
+				collection: collection.clone(),
+				creator: who.clone(),
+				owner: admin.clone(),
+			},
+		)
+	}
+}
+
+impl<T: Config<I>, I: 'static> Destroy<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	type DestroyWitness = DestroyWitness;
+
+	fn get_destroy_witness(collection: &Self::CollectionId) -> Option<DestroyWitness> {
+		Collection::<T, I>::get(collection).map(|a| a.destroy_witness())
+	}
+
+	fn destroy(
+		collection: Self::CollectionId,
+		witness: Self::DestroyWitness,
+		maybe_check_owner: Option<T::AccountId>,
+	) -> Result<Self::DestroyWitness, DispatchError> {
+		Self::do_destroy_collection(collection, witness, maybe_check_owner)
+	}
+}
+
+impl<T: Config<I>, I: 'static> Mutate<<T as SystemConfig>::AccountId> for Pallet<T, I> {
+	fn mint_into(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		who: &T::AccountId,
+	) -> DispatchResult {
+		Self::do_mint(collection.clone(), *item, who.clone(), |_| Ok(()))
+	}
+
+	fn burn(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		maybe_check_owner: Option<&T::AccountId>,
+	) -> DispatchResult {
+		Self::do_burn(collection.clone(), *item, |_, d| {
+			if let Some(check_owner) = maybe_check_owner {
+				if &d.owner != check_owner {
+					return Err(Error::<T, I>::NoPermission.into())
+				}
+			}
+			Ok(())
+		})
+	}
+}
+
+impl<T: Config<I>, I: 'static> Transfer<T::AccountId> for Pallet<T, I> {
+	fn transfer(
+		collection: &Self::CollectionId,
+		item: &Self::ItemId,
+		destination: &T::AccountId,
+	) -> DispatchResult {
+		Self::do_transfer(collection.clone(), *item, destination.clone(), |_, _| Ok(()))
+	}
+}
+
+impl<T: Config<I>, I: 'static> InspectEnumerable<T::AccountId> for Pallet<T, I> {
+	type CollectionsIterator = KeyPrefixIterator<<T as Config<I>>::CollectionId>;
+	type ItemsIterator = KeyPrefixIterator<<T as Config<I>>::ItemId>;
+	type OwnedIterator =
+		KeyPrefixIterator<(<T as Config<I>>::CollectionId, <T as Config<I>>::ItemId)>;
+	type OwnedInCollectionIterator = KeyPrefixIterator<<T as Config<I>>::ItemId>;
+
+	/// Returns an iterator of the collections in existence.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn collections() -> Self::CollectionsIterator {
+		CollectionMetadataOf::<T, I>::iter_keys()
+	}
+
+	/// Returns an iterator of the items of a `collection` in existence.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn items(collection: &Self::CollectionId) -> Self::ItemsIterator {
+		ItemMetadataOf::<T, I>::iter_key_prefix(collection)
+	}
+
+	/// Returns an iterator of the items of all collections owned by `who`.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn owned(who: &T::AccountId) -> Self::OwnedIterator {
+		Account::<T, I>::iter_key_prefix((who,))
+	}
+
+	/// Returns an iterator of the items of `collection` owned by `who`.
+	///
+	/// NOTE: iterating this list invokes a storage read per item.
+	fn owned_in_collection(
+		collection: &Self::CollectionId,
+		who: &T::AccountId,
+	) -> Self::OwnedInCollectionIterator {
+		Account::<T, I>::iter_key_prefix((who, collection))
+	}
+}
diff --git a/substrate/frame/uniques/src/lib.rs b/substrate/frame/uniques/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1b75d0b078ba5e04e16e6ad9c5ad0f962324ec5c
--- /dev/null
+++ b/substrate/frame/uniques/src/lib.rs
@@ -0,0 +1,1535 @@
+// 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.
+
+//! # Unique (Items) Module
+//!
+//! A simple, secure module for dealing with non-fungible items.
+//!
+//! ## Related Modules
+//!
+//! * [`System`](../frame_system/index.html)
+//! * [`Support`](../frame_support/index.html)
+
+#![recursion_limit = "256"]
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+pub mod mock;
+#[cfg(test)]
+mod tests;
+
+mod functions;
+mod impl_nonfungibles;
+mod types;
+
+pub mod migration;
+pub mod weights;
+
+use codec::{Decode, Encode};
+use frame_support::traits::{
+	tokens::Locker, BalanceStatus::Reserved, Currency, EnsureOriginWithArg, ReservableCurrency,
+};
+use frame_system::Config as SystemConfig;
+use sp_runtime::{
+	traits::{Saturating, StaticLookup, Zero},
+	ArithmeticError, RuntimeDebug,
+};
+use sp_std::prelude::*;
+
+pub use pallet::*;
+pub use types::*;
+pub use weights::WeightInfo;
+
+/// The log target for this pallet.
+const LOG_TARGET: &str = "runtime::uniques";
+
+/// A type alias for the account ID type used in the dispatchable functions of this pallet.
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T, I = ()>(_);
+
+	#[cfg(feature = "runtime-benchmarks")]
+	pub trait BenchmarkHelper<CollectionId, ItemId> {
+		fn collection(i: u16) -> CollectionId;
+		fn item(i: u16) -> ItemId;
+	}
+	#[cfg(feature = "runtime-benchmarks")]
+	impl<CollectionId: From<u16>, ItemId: From<u16>> BenchmarkHelper<CollectionId, ItemId> for () {
+		fn collection(i: u16) -> CollectionId {
+			i.into()
+		}
+		fn item(i: u16) -> ItemId {
+			i.into()
+		}
+	}
+
+	#[pallet::config]
+	/// The module configuration trait.
+	pub trait Config<I: 'static = ()>: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self, I>>
+			+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// Identifier for the collection of item.
+		type CollectionId: Member + Parameter + MaxEncodedLen;
+
+		/// The type used to identify a unique item within a collection.
+		type ItemId: Member + Parameter + MaxEncodedLen + Copy;
+
+		/// The currency mechanism, used for paying for reserves.
+		type Currency: ReservableCurrency<Self::AccountId>;
+
+		/// The origin which may forcibly create or destroy an item or otherwise alter privileged
+		/// attributes.
+		type ForceOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Standard collection creation is only allowed if the origin attempting it and the
+		/// collection are in this set.
+		type CreateOrigin: EnsureOriginWithArg<
+			Self::RuntimeOrigin,
+			Self::CollectionId,
+			Success = Self::AccountId,
+		>;
+
+		/// Locker trait to enable Locking mechanism downstream.
+		type Locker: Locker<Self::CollectionId, Self::ItemId>;
+
+		/// The basic amount of funds that must be reserved for collection.
+		#[pallet::constant]
+		type CollectionDeposit: Get<DepositBalanceOf<Self, I>>;
+
+		/// The basic amount of funds that must be reserved for an item.
+		#[pallet::constant]
+		type ItemDeposit: Get<DepositBalanceOf<Self, I>>;
+
+		/// The basic amount of funds that must be reserved when adding metadata to your item.
+		#[pallet::constant]
+		type MetadataDepositBase: Get<DepositBalanceOf<Self, I>>;
+
+		/// The basic amount of funds that must be reserved when adding an attribute to an item.
+		#[pallet::constant]
+		type AttributeDepositBase: Get<DepositBalanceOf<Self, I>>;
+
+		/// The additional funds that must be reserved for the number of bytes store in metadata,
+		/// either "normal" metadata or attribute metadata.
+		#[pallet::constant]
+		type DepositPerByte: Get<DepositBalanceOf<Self, I>>;
+
+		/// The maximum length of data stored on-chain.
+		#[pallet::constant]
+		type StringLimit: Get<u32>;
+
+		/// The maximum length of an attribute key.
+		#[pallet::constant]
+		type KeyLimit: Get<u32>;
+
+		/// The maximum length of an attribute value.
+		#[pallet::constant]
+		type ValueLimit: Get<u32>;
+
+		#[cfg(feature = "runtime-benchmarks")]
+		/// A set of helper functions for benchmarking.
+		type Helper: BenchmarkHelper<Self::CollectionId, Self::ItemId>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "Class"]
+	/// Details of a collection.
+	pub(super) type Collection<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		CollectionDetails<T::AccountId, DepositBalanceOf<T, I>>,
+	>;
+
+	#[pallet::storage]
+	/// The collection, if any, of which an account is willing to take ownership.
+	pub(super) type OwnershipAcceptance<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, T::AccountId, T::CollectionId>;
+
+	#[pallet::storage]
+	/// The items held by any given account; set out this way so that items owned by a single
+	/// account can be enumerated.
+	pub(super) type Account<T: Config<I>, I: 'static = ()> = StorageNMap<
+		_,
+		(
+			NMapKey<Blake2_128Concat, T::AccountId>, // owner
+			NMapKey<Blake2_128Concat, T::CollectionId>,
+			NMapKey<Blake2_128Concat, T::ItemId>,
+		),
+		(),
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "ClassAccount"]
+	/// The collections owned by any given account; set out this way so that collections owned by
+	/// a single account can be enumerated.
+	pub(super) type CollectionAccount<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		Blake2_128Concat,
+		T::CollectionId,
+		(),
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "Asset"]
+	/// The items in existence and their ownership details.
+	pub(super) type Item<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		ItemDetails<T::AccountId, DepositBalanceOf<T, I>>,
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "ClassMetadataOf"]
+	/// Metadata of a collection.
+	pub(super) type CollectionMetadataOf<T: Config<I>, I: 'static = ()> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		CollectionMetadata<DepositBalanceOf<T, I>, T::StringLimit>,
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	#[pallet::storage_prefix = "InstanceMetadataOf"]
+	/// Metadata of an item.
+	pub(super) type ItemMetadataOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		ItemMetadata<DepositBalanceOf<T, I>, T::StringLimit>,
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	/// Attributes of a collection.
+	pub(super) type Attribute<T: Config<I>, I: 'static = ()> = StorageNMap<
+		_,
+		(
+			NMapKey<Blake2_128Concat, T::CollectionId>,
+			NMapKey<Blake2_128Concat, Option<T::ItemId>>,
+			NMapKey<Blake2_128Concat, BoundedVec<u8, T::KeyLimit>>,
+		),
+		(BoundedVec<u8, T::ValueLimit>, DepositBalanceOf<T, I>),
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	/// Price of an asset instance.
+	pub(super) type ItemPriceOf<T: Config<I>, I: 'static = ()> = StorageDoubleMap<
+		_,
+		Blake2_128Concat,
+		T::CollectionId,
+		Blake2_128Concat,
+		T::ItemId,
+		(ItemPrice<T, I>, Option<T::AccountId>),
+		OptionQuery,
+	>;
+
+	#[pallet::storage]
+	/// Keeps track of the number of items a collection might have.
+	pub(super) type CollectionMaxSupply<T: Config<I>, I: 'static = ()> =
+		StorageMap<_, Blake2_128Concat, T::CollectionId, u32, OptionQuery>;
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config<I>, I: 'static = ()> {
+		/// A `collection` was created.
+		Created { collection: T::CollectionId, creator: T::AccountId, owner: T::AccountId },
+		/// A `collection` was force-created.
+		ForceCreated { collection: T::CollectionId, owner: T::AccountId },
+		/// A `collection` was destroyed.
+		Destroyed { collection: T::CollectionId },
+		/// An `item` was issued.
+		Issued { collection: T::CollectionId, item: T::ItemId, owner: T::AccountId },
+		/// An `item` was transferred.
+		Transferred {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			from: T::AccountId,
+			to: T::AccountId,
+		},
+		/// An `item` was destroyed.
+		Burned { collection: T::CollectionId, item: T::ItemId, owner: T::AccountId },
+		/// Some `item` was frozen.
+		Frozen { collection: T::CollectionId, item: T::ItemId },
+		/// Some `item` was thawed.
+		Thawed { collection: T::CollectionId, item: T::ItemId },
+		/// Some `collection` was frozen.
+		CollectionFrozen { collection: T::CollectionId },
+		/// Some `collection` was thawed.
+		CollectionThawed { collection: T::CollectionId },
+		/// The owner changed.
+		OwnerChanged { collection: T::CollectionId, new_owner: T::AccountId },
+		/// The management team changed.
+		TeamChanged {
+			collection: T::CollectionId,
+			issuer: T::AccountId,
+			admin: T::AccountId,
+			freezer: T::AccountId,
+		},
+		/// An `item` of a `collection` has been approved by the `owner` for transfer by
+		/// a `delegate`.
+		ApprovedTransfer {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			owner: T::AccountId,
+			delegate: T::AccountId,
+		},
+		/// An approval for a `delegate` account to transfer the `item` of an item
+		/// `collection` was cancelled by its `owner`.
+		ApprovalCancelled {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			owner: T::AccountId,
+			delegate: T::AccountId,
+		},
+		/// A `collection` has had its attributes changed by the `Force` origin.
+		ItemStatusChanged { collection: T::CollectionId },
+		/// New metadata has been set for a `collection`.
+		CollectionMetadataSet {
+			collection: T::CollectionId,
+			data: BoundedVec<u8, T::StringLimit>,
+			is_frozen: bool,
+		},
+		/// Metadata has been cleared for a `collection`.
+		CollectionMetadataCleared { collection: T::CollectionId },
+		/// New metadata has been set for an item.
+		MetadataSet {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			data: BoundedVec<u8, T::StringLimit>,
+			is_frozen: bool,
+		},
+		/// Metadata has been cleared for an item.
+		MetadataCleared { collection: T::CollectionId, item: T::ItemId },
+		/// Metadata has been cleared for an item.
+		Redeposited { collection: T::CollectionId, successful_items: Vec<T::ItemId> },
+		/// New attribute metadata has been set for a `collection` or `item`.
+		AttributeSet {
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+			value: BoundedVec<u8, T::ValueLimit>,
+		},
+		/// Attribute metadata has been cleared for a `collection` or `item`.
+		AttributeCleared {
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+		},
+		/// Ownership acceptance has changed for an account.
+		OwnershipAcceptanceChanged { who: T::AccountId, maybe_collection: Option<T::CollectionId> },
+		/// Max supply has been set for a collection.
+		CollectionMaxSupplySet { collection: T::CollectionId, max_supply: u32 },
+		/// The price was set for the instance.
+		ItemPriceSet {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			price: ItemPrice<T, I>,
+			whitelisted_buyer: Option<T::AccountId>,
+		},
+		/// The price for the instance was removed.
+		ItemPriceRemoved { collection: T::CollectionId, item: T::ItemId },
+		/// An item was bought.
+		ItemBought {
+			collection: T::CollectionId,
+			item: T::ItemId,
+			price: ItemPrice<T, I>,
+			seller: T::AccountId,
+			buyer: T::AccountId,
+		},
+	}
+
+	#[pallet::error]
+	pub enum Error<T, I = ()> {
+		/// The signing account has no permission to do the operation.
+		NoPermission,
+		/// The given item ID is unknown.
+		UnknownCollection,
+		/// The item ID has already been used for an item.
+		AlreadyExists,
+		/// The owner turned out to be different to what was expected.
+		WrongOwner,
+		/// Invalid witness data given.
+		BadWitness,
+		/// The item ID is already taken.
+		InUse,
+		/// The item or collection is frozen.
+		Frozen,
+		/// The delegate turned out to be different to what was expected.
+		WrongDelegate,
+		/// There is no delegate approved.
+		NoDelegate,
+		/// No approval exists that would allow the transfer.
+		Unapproved,
+		/// The named owner has not signed ownership of the collection is acceptable.
+		Unaccepted,
+		/// The item is locked.
+		Locked,
+		/// All items have been minted.
+		MaxSupplyReached,
+		/// The max supply has already been set.
+		MaxSupplyAlreadySet,
+		/// The provided max supply is less to the amount of items a collection already has.
+		MaxSupplyTooSmall,
+		/// The given item ID is unknown.
+		UnknownItem,
+		/// Item is not for sale.
+		NotForSale,
+		/// The provided bid is too low.
+		BidTooLow,
+	}
+
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Get the owner of the item, if the item exists.
+		pub fn owner(collection: T::CollectionId, item: T::ItemId) -> Option<T::AccountId> {
+			Item::<T, I>::get(collection, item).map(|i| i.owner)
+		}
+
+		/// Get the owner of the item, if the item exists.
+		pub fn collection_owner(collection: T::CollectionId) -> Option<T::AccountId> {
+			Collection::<T, I>::get(collection).map(|i| i.owner)
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config<I>, I: 'static> Pallet<T, I> {
+		/// Issue a new collection of non-fungible items from a public origin.
+		///
+		/// This new collection has no items initially and its owner is the origin.
+		///
+		/// The origin must conform to the configured `CreateOrigin` and have sufficient funds free.
+		///
+		/// `ItemDeposit` funds of sender are reserved.
+		///
+		/// Parameters:
+		/// - `collection`: The identifier of the new collection. This must not be currently in use.
+		/// - `admin`: The admin of this collection. The admin is the initial address of each
+		/// member of the collection's admin team.
+		///
+		/// Emits `Created` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::create())]
+		pub fn create(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			admin: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let owner = T::CreateOrigin::ensure_origin(origin, &collection)?;
+			let admin = T::Lookup::lookup(admin)?;
+
+			Self::do_create_collection(
+				collection.clone(),
+				owner.clone(),
+				admin.clone(),
+				T::CollectionDeposit::get(),
+				false,
+				Event::Created { collection, creator: owner, owner: admin },
+			)
+		}
+
+		/// Issue a new collection of non-fungible items from a privileged origin.
+		///
+		/// This new collection has no items initially.
+		///
+		/// The origin must conform to `ForceOrigin`.
+		///
+		/// Unlike `create`, no funds are reserved.
+		///
+		/// - `collection`: The identifier of the new item. This must not be currently in use.
+		/// - `owner`: The owner of this collection of items. The owner has full superuser
+		///   permissions
+		/// over this item, but may later change and configure the permissions using
+		/// `transfer_ownership` and `set_team`.
+		///
+		/// Emits `ForceCreated` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::force_create())]
+		pub fn force_create(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			owner: AccountIdLookupOf<T>,
+			free_holding: bool,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+
+			Self::do_create_collection(
+				collection.clone(),
+				owner.clone(),
+				owner.clone(),
+				Zero::zero(),
+				free_holding,
+				Event::ForceCreated { collection, owner },
+			)
+		}
+
+		/// Destroy a collection of fungible items.
+		///
+		/// The origin must conform to `ForceOrigin` or must be `Signed` and the sender must be the
+		/// owner of the `collection`.
+		///
+		/// - `collection`: The identifier of the collection to be destroyed.
+		/// - `witness`: Information on the items minted in the collection. This must be
+		/// correct.
+		///
+		/// Emits `Destroyed` event when successful.
+		///
+		/// Weight: `O(n + m)` where:
+		/// - `n = witness.items`
+		/// - `m = witness.item_metadatas`
+		/// - `a = witness.attributes`
+		#[pallet::call_index(2)]
+		#[pallet::weight(T::WeightInfo::destroy(
+			witness.items,
+ 			witness.item_metadatas,
+			witness.attributes,
+ 		))]
+		pub fn destroy(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			witness: DestroyWitness,
+		) -> DispatchResultWithPostInfo {
+			let maybe_check_owner = match T::ForceOrigin::try_origin(origin) {
+				Ok(_) => None,
+				Err(origin) => Some(ensure_signed(origin)?),
+			};
+			let details = Self::do_destroy_collection(collection, witness, maybe_check_owner)?;
+
+			Ok(Some(T::WeightInfo::destroy(
+				details.items,
+				details.item_metadatas,
+				details.attributes,
+			))
+			.into())
+		}
+
+		/// Mint an item of a particular collection.
+		///
+		/// The origin must be Signed and the sender must be the Issuer of the `collection`.
+		///
+		/// - `collection`: The collection of the item to be minted.
+		/// - `item`: The item value of the item to be minted.
+		/// - `beneficiary`: The initial owner of the minted item.
+		///
+		/// Emits `Issued` event when successful.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(3)]
+		#[pallet::weight(T::WeightInfo::mint())]
+		pub fn mint(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			owner: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+
+			Self::do_mint(collection, item, owner, |collection_details| {
+				ensure!(collection_details.issuer == origin, Error::<T, I>::NoPermission);
+				Ok(())
+			})
+		}
+
+		/// Destroy a single item.
+		///
+		/// Origin must be Signed and the signing account must be either:
+		/// - the Admin of the `collection`;
+		/// - the Owner of the `item`;
+		///
+		/// - `collection`: The collection of the item to be burned.
+		/// - `item`: The item of the item to be burned.
+		/// - `check_owner`: If `Some` then the operation will fail with `WrongOwner` unless the
+		///   item is owned by this value.
+		///
+		/// Emits `Burned` with the actual amount burned.
+		///
+		/// Weight: `O(1)`
+		/// Modes: `check_owner.is_some()`.
+		#[pallet::call_index(4)]
+		#[pallet::weight(T::WeightInfo::burn())]
+		pub fn burn(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			check_owner: Option<AccountIdLookupOf<T>>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let check_owner = check_owner.map(T::Lookup::lookup).transpose()?;
+
+			Self::do_burn(collection, item, |collection_details, details| {
+				let is_permitted = collection_details.admin == origin || details.owner == origin;
+				ensure!(is_permitted, Error::<T, I>::NoPermission);
+				ensure!(
+					check_owner.map_or(true, |o| o == details.owner),
+					Error::<T, I>::WrongOwner
+				);
+				Ok(())
+			})
+		}
+
+		/// Move an item from the sender account to another.
+		///
+		/// This resets the approved account of the item.
+		///
+		/// Origin must be Signed and the signing account must be either:
+		/// - the Admin of the `collection`;
+		/// - the Owner of the `item`;
+		/// - the approved delegate for the `item` (in this case, the approval is reset).
+		///
+		/// Arguments:
+		/// - `collection`: The collection of the item to be transferred.
+		/// - `item`: The item of the item to be transferred.
+		/// - `dest`: The account to receive ownership of the item.
+		///
+		/// Emits `Transferred`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(5)]
+		#[pallet::weight(T::WeightInfo::transfer())]
+		pub fn transfer(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			dest: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let dest = T::Lookup::lookup(dest)?;
+
+			Self::do_transfer(collection, item, dest, |collection_details, details| {
+				if details.owner != origin && collection_details.admin != origin {
+					let approved = details.approved.take().map_or(false, |i| i == origin);
+					ensure!(approved, Error::<T, I>::NoPermission);
+				}
+				Ok(())
+			})
+		}
+
+		/// Reevaluate the deposits on some items.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the `collection`.
+		///
+		/// - `collection`: The collection to be frozen.
+		/// - `items`: The items of the collection whose deposits will be reevaluated.
+		///
+		/// NOTE: This exists as a best-effort function. Any items which are unknown or
+		/// in the case that the owner account does not have reservable funds to pay for a
+		/// deposit increase are ignored. Generally the owner isn't going to call this on items
+		/// whose existing deposit is less than the refreshed deposit as it would only cost them,
+		/// so it's of little consequence.
+		///
+		/// It will still return an error in the case that the collection is unknown of the signer
+		/// is not permitted to call it.
+		///
+		/// Weight: `O(items.len())`
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::redeposit(items.len() as u32))]
+		pub fn redeposit(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			items: Vec<T::ItemId>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+
+			let mut collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			ensure!(collection_details.owner == origin, Error::<T, I>::NoPermission);
+			let deposit = match collection_details.free_holding {
+				true => Zero::zero(),
+				false => T::ItemDeposit::get(),
+			};
+
+			let mut successful = Vec::with_capacity(items.len());
+			for item in items.into_iter() {
+				let mut details = match Item::<T, I>::get(&collection, &item) {
+					Some(x) => x,
+					None => continue,
+				};
+				let old = details.deposit;
+				if old > deposit {
+					T::Currency::unreserve(&collection_details.owner, old - deposit);
+				} else if deposit > old {
+					if T::Currency::reserve(&collection_details.owner, deposit - old).is_err() {
+						// NOTE: No alterations made to collection_details in this iteration so far,
+						// so this is OK to do.
+						continue
+					}
+				} else {
+					continue
+				}
+				collection_details.total_deposit.saturating_accrue(deposit);
+				collection_details.total_deposit.saturating_reduce(old);
+				details.deposit = deposit;
+				Item::<T, I>::insert(&collection, &item, &details);
+				successful.push(item);
+			}
+			Collection::<T, I>::insert(&collection, &collection_details);
+
+			Self::deposit_event(Event::<T, I>::Redeposited {
+				collection,
+				successful_items: successful,
+			});
+
+			Ok(())
+		}
+
+		/// Disallow further unprivileged transfer of an item.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the `collection`.
+		///
+		/// - `collection`: The collection of the item to be frozen.
+		/// - `item`: The item of the item to be frozen.
+		///
+		/// Emits `Frozen`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(7)]
+		#[pallet::weight(T::WeightInfo::freeze())]
+		pub fn freeze(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+
+			let mut details =
+				Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownCollection)?;
+			let collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			ensure!(collection_details.freezer == origin, Error::<T, I>::NoPermission);
+
+			details.is_frozen = true;
+			Item::<T, I>::insert(&collection, &item, &details);
+
+			Self::deposit_event(Event::<T, I>::Frozen { collection, item });
+			Ok(())
+		}
+
+		/// Re-allow unprivileged transfer of an item.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the `collection`.
+		///
+		/// - `collection`: The collection of the item to be thawed.
+		/// - `item`: The item of the item to be thawed.
+		///
+		/// Emits `Thawed`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::thaw())]
+		pub fn thaw(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+
+			let mut details =
+				Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownCollection)?;
+			let collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			ensure!(collection_details.admin == origin, Error::<T, I>::NoPermission);
+
+			details.is_frozen = false;
+			Item::<T, I>::insert(&collection, &item, &details);
+
+			Self::deposit_event(Event::<T, I>::Thawed { collection, item });
+			Ok(())
+		}
+
+		/// Disallow further unprivileged transfers for a whole collection.
+		///
+		/// Origin must be Signed and the sender should be the Freezer of the `collection`.
+		///
+		/// - `collection`: The collection to be frozen.
+		///
+		/// Emits `CollectionFrozen`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(9)]
+		#[pallet::weight(T::WeightInfo::freeze_collection())]
+		pub fn freeze_collection(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+
+			Collection::<T, I>::try_mutate(collection.clone(), |maybe_details| {
+				let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+				ensure!(origin == details.freezer, Error::<T, I>::NoPermission);
+
+				details.is_frozen = true;
+
+				Self::deposit_event(Event::<T, I>::CollectionFrozen { collection });
+				Ok(())
+			})
+		}
+
+		/// Re-allow unprivileged transfers for a whole collection.
+		///
+		/// Origin must be Signed and the sender should be the Admin of the `collection`.
+		///
+		/// - `collection`: The collection to be thawed.
+		///
+		/// Emits `CollectionThawed`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::thaw_collection())]
+		pub fn thaw_collection(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+
+			Collection::<T, I>::try_mutate(collection.clone(), |maybe_details| {
+				let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+				ensure!(origin == details.admin, Error::<T, I>::NoPermission);
+
+				details.is_frozen = false;
+
+				Self::deposit_event(Event::<T, I>::CollectionThawed { collection });
+				Ok(())
+			})
+		}
+
+		/// Change the Owner of a collection.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the `collection`.
+		///
+		/// - `collection`: The collection whose owner should be changed.
+		/// - `owner`: The new Owner of this collection. They must have called
+		///   `set_accept_ownership` with `collection` in order for this operation to succeed.
+		///
+		/// Emits `OwnerChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::transfer_ownership())]
+		pub fn transfer_ownership(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			owner: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let owner = T::Lookup::lookup(owner)?;
+
+			let acceptable_collection = OwnershipAcceptance::<T, I>::get(&owner);
+			ensure!(acceptable_collection.as_ref() == Some(&collection), Error::<T, I>::Unaccepted);
+
+			Collection::<T, I>::try_mutate(collection.clone(), |maybe_details| {
+				let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+				ensure!(origin == details.owner, Error::<T, I>::NoPermission);
+				if details.owner == owner {
+					return Ok(())
+				}
+
+				// Move the deposit to the new owner.
+				T::Currency::repatriate_reserved(
+					&details.owner,
+					&owner,
+					details.total_deposit,
+					Reserved,
+				)?;
+				CollectionAccount::<T, I>::remove(&details.owner, &collection);
+				CollectionAccount::<T, I>::insert(&owner, &collection, ());
+				details.owner = owner.clone();
+				OwnershipAcceptance::<T, I>::remove(&owner);
+
+				Self::deposit_event(Event::OwnerChanged { collection, new_owner: owner });
+				Ok(())
+			})
+		}
+
+		/// Change the Issuer, Admin and Freezer of a collection.
+		///
+		/// Origin must be Signed and the sender should be the Owner of the `collection`.
+		///
+		/// - `collection`: The collection whose team should be changed.
+		/// - `issuer`: The new Issuer of this collection.
+		/// - `admin`: The new Admin of this collection.
+		/// - `freezer`: The new Freezer of this collection.
+		///
+		/// Emits `TeamChanged`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(12)]
+		#[pallet::weight(T::WeightInfo::set_team())]
+		pub fn set_team(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			issuer: AccountIdLookupOf<T>,
+			admin: AccountIdLookupOf<T>,
+			freezer: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let issuer = T::Lookup::lookup(issuer)?;
+			let admin = T::Lookup::lookup(admin)?;
+			let freezer = T::Lookup::lookup(freezer)?;
+
+			Collection::<T, I>::try_mutate(collection.clone(), |maybe_details| {
+				let details = maybe_details.as_mut().ok_or(Error::<T, I>::UnknownCollection)?;
+				ensure!(origin == details.owner, Error::<T, I>::NoPermission);
+
+				details.issuer = issuer.clone();
+				details.admin = admin.clone();
+				details.freezer = freezer.clone();
+
+				Self::deposit_event(Event::TeamChanged { collection, issuer, admin, freezer });
+				Ok(())
+			})
+		}
+
+		/// Approve an item to be transferred by a delegated third-party account.
+		///
+		/// The origin must conform to `ForceOrigin` or must be `Signed` and the sender must be
+		/// either the owner of the `item` or the admin of the collection.
+		///
+		/// - `collection`: The collection of the item to be approved for delegated transfer.
+		/// - `item`: The item of the item to be approved for delegated transfer.
+		/// - `delegate`: The account to delegate permission to transfer the item.
+		///
+		/// Important NOTE: The `approved` account gets reset after each transfer.
+		///
+		/// Emits `ApprovedTransfer` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(13)]
+		#[pallet::weight(T::WeightInfo::approve_transfer())]
+		pub fn approve_transfer(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			delegate: AccountIdLookupOf<T>,
+		) -> DispatchResult {
+			let maybe_check: Option<T::AccountId> = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+
+			let delegate = T::Lookup::lookup(delegate)?;
+
+			let collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			let mut details =
+				Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownCollection)?;
+
+			if let Some(check) = maybe_check {
+				let permitted = check == collection_details.admin || check == details.owner;
+				ensure!(permitted, Error::<T, I>::NoPermission);
+			}
+
+			details.approved = Some(delegate);
+			Item::<T, I>::insert(&collection, &item, &details);
+
+			let delegate = details.approved.expect("set as Some above; qed");
+			Self::deposit_event(Event::ApprovedTransfer {
+				collection,
+				item,
+				owner: details.owner,
+				delegate,
+			});
+
+			Ok(())
+		}
+
+		/// Cancel the prior approval for the transfer of an item by a delegate.
+		///
+		/// Origin must be either:
+		/// - the `Force` origin;
+		/// - `Signed` with the signer being the Admin of the `collection`;
+		/// - `Signed` with the signer being the Owner of the `item`;
+		///
+		/// Arguments:
+		/// - `collection`: The collection of the item of whose approval will be cancelled.
+		/// - `item`: The item of the item of whose approval will be cancelled.
+		/// - `maybe_check_delegate`: If `Some` will ensure that the given account is the one to
+		///   which permission of transfer is delegated.
+		///
+		/// Emits `ApprovalCancelled` on success.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(14)]
+		#[pallet::weight(T::WeightInfo::cancel_approval())]
+		pub fn cancel_approval(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			maybe_check_delegate: Option<AccountIdLookupOf<T>>,
+		) -> DispatchResult {
+			let maybe_check: Option<T::AccountId> = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some).map_err(DispatchError::from))?;
+
+			let collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			let mut details =
+				Item::<T, I>::get(&collection, &item).ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check) = maybe_check {
+				let permitted = check == collection_details.admin || check == details.owner;
+				ensure!(permitted, Error::<T, I>::NoPermission);
+			}
+			let maybe_check_delegate = maybe_check_delegate.map(T::Lookup::lookup).transpose()?;
+			let old = details.approved.take().ok_or(Error::<T, I>::NoDelegate)?;
+			if let Some(check_delegate) = maybe_check_delegate {
+				ensure!(check_delegate == old, Error::<T, I>::WrongDelegate);
+			}
+
+			Item::<T, I>::insert(&collection, &item, &details);
+			Self::deposit_event(Event::ApprovalCancelled {
+				collection,
+				item,
+				owner: details.owner,
+				delegate: old,
+			});
+
+			Ok(())
+		}
+
+		/// Alter the attributes of a given item.
+		///
+		/// Origin must be `ForceOrigin`.
+		///
+		/// - `collection`: The identifier of the item.
+		/// - `owner`: The new Owner of this item.
+		/// - `issuer`: The new Issuer of this item.
+		/// - `admin`: The new Admin of this item.
+		/// - `freezer`: The new Freezer of this item.
+		/// - `free_holding`: Whether a deposit is taken for holding an item of this collection.
+		/// - `is_frozen`: Whether this collection is frozen except for permissioned/admin
+		/// instructions.
+		///
+		/// Emits `ItemStatusChanged` with the identity of the item.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(15)]
+		#[pallet::weight(T::WeightInfo::force_item_status())]
+		pub fn force_item_status(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			owner: AccountIdLookupOf<T>,
+			issuer: AccountIdLookupOf<T>,
+			admin: AccountIdLookupOf<T>,
+			freezer: AccountIdLookupOf<T>,
+			free_holding: bool,
+			is_frozen: bool,
+		) -> DispatchResult {
+			T::ForceOrigin::ensure_origin(origin)?;
+
+			Collection::<T, I>::try_mutate(collection.clone(), |maybe_item| {
+				let mut item = maybe_item.take().ok_or(Error::<T, I>::UnknownCollection)?;
+				let old_owner = item.owner;
+				let new_owner = T::Lookup::lookup(owner)?;
+				item.owner = new_owner.clone();
+				item.issuer = T::Lookup::lookup(issuer)?;
+				item.admin = T::Lookup::lookup(admin)?;
+				item.freezer = T::Lookup::lookup(freezer)?;
+				item.free_holding = free_holding;
+				item.is_frozen = is_frozen;
+				*maybe_item = Some(item);
+				CollectionAccount::<T, I>::remove(&old_owner, &collection);
+				CollectionAccount::<T, I>::insert(&new_owner, &collection, ());
+
+				Self::deposit_event(Event::ItemStatusChanged { collection });
+				Ok(())
+			})
+		}
+
+		/// Set an attribute for a collection or item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
+		/// `collection`.
+		///
+		/// If the origin is Signed, then funds of signer are reserved according to the formula:
+		/// `MetadataDepositBase + DepositPerByte * (key.len + value.len)` taking into
+		/// account any already reserved funds.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to set.
+		/// - `maybe_item`: The identifier of the item whose metadata to set.
+		/// - `key`: The key of the attribute.
+		/// - `value`: The value to which to set the attribute.
+		///
+		/// Emits `AttributeSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(16)]
+		#[pallet::weight(T::WeightInfo::set_attribute())]
+		pub fn set_attribute(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+			value: BoundedVec<u8, T::ValueLimit>,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some))?;
+
+			let mut collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = &maybe_check_owner {
+				ensure!(check_owner == &collection_details.owner, Error::<T, I>::NoPermission);
+			}
+			let maybe_is_frozen = match maybe_item {
+				None => CollectionMetadataOf::<T, I>::get(collection.clone()).map(|v| v.is_frozen),
+				Some(item) =>
+					ItemMetadataOf::<T, I>::get(collection.clone(), item).map(|v| v.is_frozen),
+			};
+			ensure!(!maybe_is_frozen.unwrap_or(false), Error::<T, I>::Frozen);
+
+			let attribute = Attribute::<T, I>::get((collection.clone(), maybe_item, &key));
+			if attribute.is_none() {
+				collection_details.attributes.saturating_inc();
+			}
+			let old_deposit = attribute.map_or(Zero::zero(), |m| m.1);
+			collection_details.total_deposit.saturating_reduce(old_deposit);
+			let mut deposit = Zero::zero();
+			if !collection_details.free_holding && maybe_check_owner.is_some() {
+				deposit = T::DepositPerByte::get()
+					.saturating_mul(((key.len() + value.len()) as u32).into())
+					.saturating_add(T::AttributeDepositBase::get());
+			}
+			collection_details.total_deposit.saturating_accrue(deposit);
+			if deposit > old_deposit {
+				T::Currency::reserve(&collection_details.owner, deposit - old_deposit)?;
+			} else if deposit < old_deposit {
+				T::Currency::unreserve(&collection_details.owner, old_deposit - deposit);
+			}
+
+			Attribute::<T, I>::insert((&collection, maybe_item, &key), (&value, deposit));
+			Collection::<T, I>::insert(collection.clone(), &collection_details);
+			Self::deposit_event(Event::AttributeSet { collection, maybe_item, key, value });
+			Ok(())
+		}
+
+		/// Clear an attribute for a collection or item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
+		/// `collection`.
+		///
+		/// Any deposit is freed for the collection's owner.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to clear.
+		/// - `maybe_item`: The identifier of the item whose metadata to clear.
+		/// - `key`: The key of the attribute.
+		///
+		/// Emits `AttributeCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(17)]
+		#[pallet::weight(T::WeightInfo::clear_attribute())]
+		pub fn clear_attribute(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			maybe_item: Option<T::ItemId>,
+			key: BoundedVec<u8, T::KeyLimit>,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some))?;
+
+			let mut collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = &maybe_check_owner {
+				ensure!(check_owner == &collection_details.owner, Error::<T, I>::NoPermission);
+			}
+			let maybe_is_frozen = match maybe_item {
+				None => CollectionMetadataOf::<T, I>::get(collection.clone()).map(|v| v.is_frozen),
+				Some(item) =>
+					ItemMetadataOf::<T, I>::get(collection.clone(), item).map(|v| v.is_frozen),
+			};
+			ensure!(!maybe_is_frozen.unwrap_or(false), Error::<T, I>::Frozen);
+
+			if let Some((_, deposit)) =
+				Attribute::<T, I>::take((collection.clone(), maybe_item, &key))
+			{
+				collection_details.attributes.saturating_dec();
+				collection_details.total_deposit.saturating_reduce(deposit);
+				T::Currency::unreserve(&collection_details.owner, deposit);
+				Collection::<T, I>::insert(collection.clone(), &collection_details);
+				Self::deposit_event(Event::AttributeCleared { collection, maybe_item, key });
+			}
+			Ok(())
+		}
+
+		/// Set the metadata for an item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
+		/// `collection`.
+		///
+		/// If the origin is Signed, then funds of signer are reserved according to the formula:
+		/// `MetadataDepositBase + DepositPerByte * data.len` taking into
+		/// account any already reserved funds.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to set.
+		/// - `item`: The identifier of the item whose metadata to set.
+		/// - `data`: The general information of this item. Limited in length by `StringLimit`.
+		/// - `is_frozen`: Whether the metadata should be frozen against further changes.
+		///
+		/// Emits `MetadataSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(18)]
+		#[pallet::weight(T::WeightInfo::set_metadata())]
+		pub fn set_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			data: BoundedVec<u8, T::StringLimit>,
+			is_frozen: bool,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some))?;
+
+			let mut collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+
+			if let Some(check_owner) = &maybe_check_owner {
+				ensure!(check_owner == &collection_details.owner, Error::<T, I>::NoPermission);
+			}
+
+			ItemMetadataOf::<T, I>::try_mutate_exists(collection.clone(), item, |metadata| {
+				let was_frozen = metadata.as_ref().map_or(false, |m| m.is_frozen);
+				ensure!(maybe_check_owner.is_none() || !was_frozen, Error::<T, I>::Frozen);
+
+				if metadata.is_none() {
+					collection_details.item_metadatas.saturating_inc();
+				}
+				let old_deposit = metadata.take().map_or(Zero::zero(), |m| m.deposit);
+				collection_details.total_deposit.saturating_reduce(old_deposit);
+				let mut deposit = Zero::zero();
+				if !collection_details.free_holding && maybe_check_owner.is_some() {
+					deposit = T::DepositPerByte::get()
+						.saturating_mul(((data.len()) as u32).into())
+						.saturating_add(T::MetadataDepositBase::get());
+				}
+				if deposit > old_deposit {
+					T::Currency::reserve(&collection_details.owner, deposit - old_deposit)?;
+				} else if deposit < old_deposit {
+					T::Currency::unreserve(&collection_details.owner, old_deposit - deposit);
+				}
+				collection_details.total_deposit.saturating_accrue(deposit);
+
+				*metadata = Some(ItemMetadata { deposit, data: data.clone(), is_frozen });
+
+				Collection::<T, I>::insert(&collection, &collection_details);
+				Self::deposit_event(Event::MetadataSet { collection, item, data, is_frozen });
+				Ok(())
+			})
+		}
+
+		/// Clear the metadata for an item.
+		///
+		/// Origin must be either `ForceOrigin` or Signed and the sender should be the Owner of the
+		/// `item`.
+		///
+		/// Any deposit is freed for the collection's owner.
+		///
+		/// - `collection`: The identifier of the collection whose item's metadata to clear.
+		/// - `item`: The identifier of the item whose metadata to clear.
+		///
+		/// Emits `MetadataCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(19)]
+		#[pallet::weight(T::WeightInfo::clear_metadata())]
+		pub fn clear_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some))?;
+
+			let mut collection_details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = &maybe_check_owner {
+				ensure!(check_owner == &collection_details.owner, Error::<T, I>::NoPermission);
+			}
+
+			ItemMetadataOf::<T, I>::try_mutate_exists(collection.clone(), item, |metadata| {
+				let was_frozen = metadata.as_ref().map_or(false, |m| m.is_frozen);
+				ensure!(maybe_check_owner.is_none() || !was_frozen, Error::<T, I>::Frozen);
+
+				if metadata.is_some() {
+					collection_details.item_metadatas.saturating_dec();
+				}
+				let deposit = metadata.take().ok_or(Error::<T, I>::UnknownCollection)?.deposit;
+				T::Currency::unreserve(&collection_details.owner, deposit);
+				collection_details.total_deposit.saturating_reduce(deposit);
+
+				Collection::<T, I>::insert(&collection, &collection_details);
+				Self::deposit_event(Event::MetadataCleared { collection, item });
+				Ok(())
+			})
+		}
+
+		/// Set the metadata for a collection.
+		///
+		/// Origin must be either `ForceOrigin` or `Signed` and the sender should be the Owner of
+		/// the `collection`.
+		///
+		/// If the origin is `Signed`, then funds of signer are reserved according to the formula:
+		/// `MetadataDepositBase + DepositPerByte * data.len` taking into
+		/// account any already reserved funds.
+		///
+		/// - `collection`: The identifier of the item whose metadata to update.
+		/// - `data`: The general information of this item. Limited in length by `StringLimit`.
+		/// - `is_frozen`: Whether the metadata should be frozen against further changes.
+		///
+		/// Emits `CollectionMetadataSet`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(20)]
+		#[pallet::weight(T::WeightInfo::set_collection_metadata())]
+		pub fn set_collection_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			data: BoundedVec<u8, T::StringLimit>,
+			is_frozen: bool,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some))?;
+
+			let mut details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = &maybe_check_owner {
+				ensure!(check_owner == &details.owner, Error::<T, I>::NoPermission);
+			}
+
+			CollectionMetadataOf::<T, I>::try_mutate_exists(collection.clone(), |metadata| {
+				let was_frozen = metadata.as_ref().map_or(false, |m| m.is_frozen);
+				ensure!(maybe_check_owner.is_none() || !was_frozen, Error::<T, I>::Frozen);
+
+				let old_deposit = metadata.take().map_or(Zero::zero(), |m| m.deposit);
+				details.total_deposit.saturating_reduce(old_deposit);
+				let mut deposit = Zero::zero();
+				if maybe_check_owner.is_some() && !details.free_holding {
+					deposit = T::DepositPerByte::get()
+						.saturating_mul(((data.len()) as u32).into())
+						.saturating_add(T::MetadataDepositBase::get());
+				}
+				if deposit > old_deposit {
+					T::Currency::reserve(&details.owner, deposit - old_deposit)?;
+				} else if deposit < old_deposit {
+					T::Currency::unreserve(&details.owner, old_deposit - deposit);
+				}
+				details.total_deposit.saturating_accrue(deposit);
+
+				Collection::<T, I>::insert(&collection, details);
+
+				*metadata = Some(CollectionMetadata { deposit, data: data.clone(), is_frozen });
+
+				Self::deposit_event(Event::CollectionMetadataSet { collection, data, is_frozen });
+				Ok(())
+			})
+		}
+
+		/// Clear the metadata for a collection.
+		///
+		/// Origin must be either `ForceOrigin` or `Signed` and the sender should be the Owner of
+		/// the `collection`.
+		///
+		/// Any deposit is freed for the collection's owner.
+		///
+		/// - `collection`: The identifier of the collection whose metadata to clear.
+		///
+		/// Emits `CollectionMetadataCleared`.
+		///
+		/// Weight: `O(1)`
+		#[pallet::call_index(21)]
+		#[pallet::weight(T::WeightInfo::clear_collection_metadata())]
+		pub fn clear_collection_metadata(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some))?;
+
+			let details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = &maybe_check_owner {
+				ensure!(check_owner == &details.owner, Error::<T, I>::NoPermission);
+			}
+
+			CollectionMetadataOf::<T, I>::try_mutate_exists(collection.clone(), |metadata| {
+				let was_frozen = metadata.as_ref().map_or(false, |m| m.is_frozen);
+				ensure!(maybe_check_owner.is_none() || !was_frozen, Error::<T, I>::Frozen);
+
+				let deposit = metadata.take().ok_or(Error::<T, I>::UnknownCollection)?.deposit;
+				T::Currency::unreserve(&details.owner, deposit);
+				Self::deposit_event(Event::CollectionMetadataCleared { collection });
+				Ok(())
+			})
+		}
+
+		/// Set (or reset) the acceptance of ownership for a particular account.
+		///
+		/// Origin must be `Signed` and if `maybe_collection` is `Some`, then the signer must have a
+		/// provider reference.
+		///
+		/// - `maybe_collection`: The identifier of the collection whose ownership the signer is
+		///   willing to accept, or if `None`, an indication that the signer is willing to accept no
+		///   ownership transferal.
+		///
+		/// Emits `OwnershipAcceptanceChanged`.
+		#[pallet::call_index(22)]
+		#[pallet::weight(T::WeightInfo::set_accept_ownership())]
+		pub fn set_accept_ownership(
+			origin: OriginFor<T>,
+			maybe_collection: Option<T::CollectionId>,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			let old = OwnershipAcceptance::<T, I>::get(&who);
+			match (old.is_some(), maybe_collection.is_some()) {
+				(false, true) => {
+					frame_system::Pallet::<T>::inc_consumers(&who)?;
+				},
+				(true, false) => {
+					frame_system::Pallet::<T>::dec_consumers(&who);
+				},
+				_ => {},
+			}
+			if let Some(collection) = maybe_collection.as_ref() {
+				OwnershipAcceptance::<T, I>::insert(&who, collection);
+			} else {
+				OwnershipAcceptance::<T, I>::remove(&who);
+			}
+			Self::deposit_event(Event::OwnershipAcceptanceChanged { who, maybe_collection });
+			Ok(())
+		}
+
+		/// Set the maximum amount of items a collection could have.
+		///
+		/// Origin must be either `ForceOrigin` or `Signed` and the sender should be the Owner of
+		/// the `collection`.
+		///
+		/// Note: This function can only succeed once per collection.
+		///
+		/// - `collection`: The identifier of the collection to change.
+		/// - `max_supply`: The maximum amount of items a collection could have.
+		///
+		/// Emits `CollectionMaxSupplySet` event when successful.
+		#[pallet::call_index(23)]
+		#[pallet::weight(T::WeightInfo::set_collection_max_supply())]
+		pub fn set_collection_max_supply(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			max_supply: u32,
+		) -> DispatchResult {
+			let maybe_check_owner = T::ForceOrigin::try_origin(origin)
+				.map(|_| None)
+				.or_else(|origin| ensure_signed(origin).map(Some))?;
+
+			ensure!(
+				!CollectionMaxSupply::<T, I>::contains_key(&collection),
+				Error::<T, I>::MaxSupplyAlreadySet
+			);
+
+			let details =
+				Collection::<T, I>::get(&collection).ok_or(Error::<T, I>::UnknownCollection)?;
+			if let Some(check_owner) = &maybe_check_owner {
+				ensure!(check_owner == &details.owner, Error::<T, I>::NoPermission);
+			}
+
+			ensure!(details.items <= max_supply, Error::<T, I>::MaxSupplyTooSmall);
+
+			CollectionMaxSupply::<T, I>::insert(&collection, max_supply);
+			Self::deposit_event(Event::CollectionMaxSupplySet { collection, max_supply });
+			Ok(())
+		}
+
+		/// Set (or reset) the price for an item.
+		///
+		/// Origin must be Signed and must be the owner of the asset `item`.
+		///
+		/// - `collection`: The collection of the item.
+		/// - `item`: The item to set the price for.
+		/// - `price`: The price for the item. Pass `None`, to reset the price.
+		/// - `buyer`: Restricts the buy operation to a specific account.
+		///
+		/// Emits `ItemPriceSet` on success if the price is not `None`.
+		/// Emits `ItemPriceRemoved` on success if the price is `None`.
+		#[pallet::call_index(24)]
+		#[pallet::weight(T::WeightInfo::set_price())]
+		pub fn set_price(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			price: Option<ItemPrice<T, I>>,
+			whitelisted_buyer: Option<AccountIdLookupOf<T>>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			let whitelisted_buyer = whitelisted_buyer.map(T::Lookup::lookup).transpose()?;
+			Self::do_set_price(collection, item, origin, price, whitelisted_buyer)
+		}
+
+		/// Allows to buy an item if it's up for sale.
+		///
+		/// Origin must be Signed and must not be the owner of the `item`.
+		///
+		/// - `collection`: The collection of the item.
+		/// - `item`: The item the sender wants to buy.
+		/// - `bid_price`: The price the sender is willing to pay.
+		///
+		/// Emits `ItemBought` on success.
+		#[pallet::call_index(25)]
+		#[pallet::weight(T::WeightInfo::buy_item())]
+		pub fn buy_item(
+			origin: OriginFor<T>,
+			collection: T::CollectionId,
+			item: T::ItemId,
+			bid_price: ItemPrice<T, I>,
+		) -> DispatchResult {
+			let origin = ensure_signed(origin)?;
+			Self::do_buy_item(collection, item, origin, bid_price)
+		}
+	}
+}
diff --git a/substrate/frame/uniques/src/migration.rs b/substrate/frame/uniques/src/migration.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c92b753b4ac2ab29a0c0fdaeab10ba69e37eb7d
--- /dev/null
+++ b/substrate/frame/uniques/src/migration.rs
@@ -0,0 +1,54 @@
+// 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.
+
+//! Various pieces of common functionality.
+use super::*;
+use frame_support::traits::{Get, GetStorageVersion, PalletInfoAccess, StorageVersion};
+
+/// Migrate the pallet storage to v1.
+pub fn migrate_to_v1<T: Config<I>, I: 'static, P: GetStorageVersion + PalletInfoAccess>(
+) -> frame_support::weights::Weight {
+	let on_chain_storage_version = <P as GetStorageVersion>::on_chain_storage_version();
+	log::info!(
+		target: LOG_TARGET,
+		"Running migration storage v1 for uniques with storage version {:?}",
+		on_chain_storage_version,
+	);
+
+	if on_chain_storage_version < 1 {
+		let mut count = 0;
+		for (collection, detail) in Collection::<T, I>::iter() {
+			CollectionAccount::<T, I>::insert(&detail.owner, &collection, ());
+			count += 1;
+		}
+		StorageVersion::new(1).put::<P>();
+		log::info!(
+			target: LOG_TARGET,
+			"Running migration storage v1 for uniques with storage version {:?} was complete",
+			on_chain_storage_version,
+		);
+		// calculate and return migration weights
+		T::DbWeight::get().reads_writes(count as u64 + 1, count as u64 + 1)
+	} else {
+		log::warn!(
+			target: LOG_TARGET,
+			"Attempted to apply migration to v1 but failed because storage version is {:?}",
+			on_chain_storage_version,
+		);
+		T::DbWeight::get().reads(1)
+	}
+}
diff --git a/substrate/frame/uniques/src/mock.rs b/substrate/frame/uniques/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5c44a7ed7a5390cb54f4793c935c5a31862f8859
--- /dev/null
+++ b/substrate/frame/uniques/src/mock.rs
@@ -0,0 +1,113 @@
+// 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.
+
+//! Test environment for Uniques pallet.
+
+use super::*;
+use crate as pallet_uniques;
+
+use frame_support::{
+	construct_runtime,
+	traits::{AsEnsureOriginWithArg, ConstU32, ConstU64},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Uniques: pallet_uniques::{Pallet, Call, Storage, Event<T>},
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	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 Block = Block;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	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 = ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type CollectionId = u32;
+	type ItemId = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<frame_system::EnsureSigned<u64>>;
+	type ForceOrigin = frame_system::EnsureRoot<u64>;
+	type Locker = ();
+	type CollectionDeposit = ConstU64<2>;
+	type ItemDeposit = ConstU64<1>;
+	type MetadataDepositBase = ConstU64<1>;
+	type AttributeDepositBase = ConstU64<1>;
+	type DepositPerByte = ConstU64<1>;
+	type StringLimit = ConstU32<50>;
+	type KeyLimit = ConstU32<50>;
+	type ValueLimit = ConstU32<50>;
+	type WeightInfo = ();
+	#[cfg(feature = "runtime-benchmarks")]
+	type Helper = ();
+}
+
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
diff --git a/substrate/frame/uniques/src/tests.rs b/substrate/frame/uniques/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..993552c3a2aaa5b78e734ad4c53e41652d6a0ef2
--- /dev/null
+++ b/substrate/frame/uniques/src/tests.rs
@@ -0,0 +1,1060 @@
+// 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 Uniques pallet.
+
+use crate::{mock::*, Event, *};
+use frame_support::{assert_noop, assert_ok, dispatch::Dispatchable, traits::Currency};
+use pallet_balances::Error as BalancesError;
+use sp_std::prelude::*;
+
+fn items() -> Vec<(u64, u32, u32)> {
+	let mut r: Vec<_> = Account::<Test>::iter().map(|x| x.0).collect();
+	r.sort();
+	let mut s: Vec<_> = Item::<Test>::iter().map(|x| (x.2.owner, x.0, x.1)).collect();
+	s.sort();
+	assert_eq!(r, s);
+	for collection in Item::<Test>::iter()
+		.map(|x| x.0)
+		.scan(None, |s, item| {
+			if s.map_or(false, |last| last == item) {
+				*s = Some(item);
+				Some(None)
+			} else {
+				Some(Some(item))
+			}
+		})
+		.flatten()
+	{
+		let details = Collection::<Test>::get(collection).unwrap();
+		let items = Item::<Test>::iter_prefix(collection).count() as u32;
+		assert_eq!(details.items, items);
+	}
+	r
+}
+
+fn collections() -> Vec<(u64, u32)> {
+	let mut r: Vec<_> = CollectionAccount::<Test>::iter().map(|x| (x.0, x.1)).collect();
+	r.sort();
+	let mut s: Vec<_> = Collection::<Test>::iter().map(|x| (x.1.owner, x.0)).collect();
+	s.sort();
+	assert_eq!(r, s);
+	r
+}
+
+macro_rules! bvec {
+	($( $x:tt )*) => {
+		vec![$( $x )*].try_into().unwrap()
+	}
+}
+
+fn attributes(collection: u32) -> Vec<(Option<u32>, Vec<u8>, Vec<u8>)> {
+	let mut s: Vec<_> = Attribute::<Test>::iter_prefix((collection,))
+		.map(|(k, v)| (k.0, k.1.into(), v.0.into()))
+		.collect();
+	s.sort();
+	s
+}
+
+fn events() -> Vec<Event<Test>> {
+	let result = System::events()
+		.into_iter()
+		.map(|r| r.event)
+		.filter_map(|e| if let mock::RuntimeEvent::Uniques(inner) = e { Some(inner) } else { None })
+		.collect::<Vec<_>>();
+
+	System::reset_events();
+
+	result
+}
+
+#[test]
+fn basic_setup_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(items(), vec![]);
+	});
+}
+
+#[test]
+fn basic_minting_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_eq!(collections(), vec![(1, 0)]);
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+		assert_eq!(items(), vec![(1, 0, 42)]);
+
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 1, 2, true));
+		assert_eq!(collections(), vec![(1, 0), (2, 1)]);
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(2), 1, 69, 1));
+		assert_eq!(items(), vec![(1, 0, 42), (1, 1, 69)]);
+	});
+}
+
+#[test]
+fn lifecycle_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Uniques::create(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(Balances::reserved_balance(&1), 2);
+		assert_eq!(collections(), vec![(1, 0)]);
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			bvec![0, 0],
+			false
+		));
+		assert_eq!(Balances::reserved_balance(&1), 5);
+		assert!(CollectionMetadataOf::<Test>::contains_key(0));
+
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 10));
+		assert_eq!(Balances::reserved_balance(&1), 6);
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 69, 20));
+		assert_eq!(Balances::reserved_balance(&1), 7);
+		assert_eq!(items(), vec![(10, 0, 42), (20, 0, 69)]);
+		assert_eq!(Collection::<Test>::get(0).unwrap().items, 2);
+		assert_eq!(Collection::<Test>::get(0).unwrap().item_metadatas, 0);
+
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![42, 42], false));
+		assert_eq!(Balances::reserved_balance(&1), 10);
+		assert!(ItemMetadataOf::<Test>::contains_key(0, 42));
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 69, bvec![69, 69], false));
+		assert_eq!(Balances::reserved_balance(&1), 13);
+		assert!(ItemMetadataOf::<Test>::contains_key(0, 69));
+
+		let w = Collection::<Test>::get(0).unwrap().destroy_witness();
+		assert_eq!(w.items, 2);
+		assert_eq!(w.item_metadatas, 2);
+		assert_ok!(Uniques::destroy(RuntimeOrigin::signed(1), 0, w));
+		assert_eq!(Balances::reserved_balance(&1), 0);
+
+		assert!(!Collection::<Test>::contains_key(0));
+		assert!(!Item::<Test>::contains_key(0, 42));
+		assert!(!Item::<Test>::contains_key(0, 69));
+		assert!(!CollectionMetadataOf::<Test>::contains_key(0));
+		assert!(!ItemMetadataOf::<Test>::contains_key(0, 42));
+		assert!(!ItemMetadataOf::<Test>::contains_key(0, 69));
+		assert_eq!(collections(), vec![]);
+		assert_eq!(items(), vec![]);
+	});
+}
+
+#[test]
+fn destroy_with_bad_witness_should_not_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Uniques::create(RuntimeOrigin::signed(1), 0, 1));
+
+		let w = Collection::<Test>::get(0).unwrap().destroy_witness();
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+		assert_noop!(Uniques::destroy(RuntimeOrigin::signed(1), 0, w), Error::<Test>::BadWitness);
+	});
+}
+
+#[test]
+fn mint_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+		assert_eq!(Uniques::owner(0, 42).unwrap(), 1);
+		assert_eq!(collections(), vec![(1, 0)]);
+		assert_eq!(items(), vec![(1, 0, 42)]);
+	});
+}
+
+#[test]
+fn transfer_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 2));
+
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(2), 0, 42, 3));
+		assert_eq!(items(), vec![(3, 0, 42)]);
+		assert_noop!(
+			Uniques::transfer(RuntimeOrigin::signed(2), 0, 42, 4),
+			Error::<Test>::NoPermission
+		);
+
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(3), 0, 42, 2));
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(2), 0, 42, 4));
+	});
+}
+
+#[test]
+fn freezing_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+		assert_ok!(Uniques::freeze(RuntimeOrigin::signed(1), 0, 42));
+		assert_noop!(Uniques::transfer(RuntimeOrigin::signed(1), 0, 42, 2), Error::<Test>::Frozen);
+
+		assert_ok!(Uniques::thaw(RuntimeOrigin::signed(1), 0, 42));
+		assert_ok!(Uniques::freeze_collection(RuntimeOrigin::signed(1), 0));
+		assert_noop!(Uniques::transfer(RuntimeOrigin::signed(1), 0, 42, 2), Error::<Test>::Frozen);
+
+		assert_ok!(Uniques::thaw_collection(RuntimeOrigin::signed(1), 0));
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(1), 0, 42, 2));
+	});
+}
+
+#[test]
+fn origin_guards_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+
+		Balances::make_free_balance_be(&2, 100);
+		assert_ok!(Uniques::set_accept_ownership(RuntimeOrigin::signed(2), Some(0)));
+		assert_noop!(
+			Uniques::transfer_ownership(RuntimeOrigin::signed(2), 0, 2),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Uniques::set_team(RuntimeOrigin::signed(2), 0, 2, 2, 2),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(Uniques::freeze(RuntimeOrigin::signed(2), 0, 42), Error::<Test>::NoPermission);
+		assert_noop!(Uniques::thaw(RuntimeOrigin::signed(2), 0, 42), Error::<Test>::NoPermission);
+		assert_noop!(
+			Uniques::mint(RuntimeOrigin::signed(2), 0, 69, 2),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Uniques::burn(RuntimeOrigin::signed(2), 0, 42, None),
+			Error::<Test>::NoPermission
+		);
+		let w = Collection::<Test>::get(0).unwrap().destroy_witness();
+		assert_noop!(Uniques::destroy(RuntimeOrigin::signed(2), 0, w), Error::<Test>::NoPermission);
+	});
+}
+
+#[test]
+fn transfer_owner_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		Balances::make_free_balance_be(&2, 100);
+		Balances::make_free_balance_be(&3, 100);
+		assert_ok!(Uniques::create(RuntimeOrigin::signed(1), 0, 1));
+		assert_eq!(collections(), vec![(1, 0)]);
+		assert_noop!(
+			Uniques::transfer_ownership(RuntimeOrigin::signed(1), 0, 2),
+			Error::<Test>::Unaccepted
+		);
+		assert_ok!(Uniques::set_accept_ownership(RuntimeOrigin::signed(2), Some(0)));
+		assert_ok!(Uniques::transfer_ownership(RuntimeOrigin::signed(1), 0, 2));
+
+		assert_eq!(collections(), vec![(2, 0)]);
+		assert_eq!(Balances::total_balance(&1), 98);
+		assert_eq!(Balances::total_balance(&2), 102);
+		assert_eq!(Balances::reserved_balance(&1), 0);
+		assert_eq!(Balances::reserved_balance(&2), 2);
+
+		assert_ok!(Uniques::set_accept_ownership(RuntimeOrigin::signed(1), Some(0)));
+		assert_noop!(
+			Uniques::transfer_ownership(RuntimeOrigin::signed(1), 0, 1),
+			Error::<Test>::NoPermission
+		);
+
+		// Mint and set metadata now and make sure that deposit gets transferred back.
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(2),
+			0,
+			bvec![0u8; 20],
+			false
+		));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(2), 0, 42, bvec![0u8; 20], false));
+		assert_ok!(Uniques::set_accept_ownership(RuntimeOrigin::signed(3), Some(0)));
+		assert_ok!(Uniques::transfer_ownership(RuntimeOrigin::signed(2), 0, 3));
+		assert_eq!(collections(), vec![(3, 0)]);
+		assert_eq!(Balances::total_balance(&2), 57);
+		assert_eq!(Balances::total_balance(&3), 145);
+		assert_eq!(Balances::reserved_balance(&2), 0);
+		assert_eq!(Balances::reserved_balance(&3), 45);
+
+		// 2's acceptence from before is reset when it became owner, so it cannot be transfered
+		// without a fresh acceptance.
+		assert_noop!(
+			Uniques::transfer_ownership(RuntimeOrigin::signed(3), 0, 2),
+			Error::<Test>::Unaccepted
+		);
+	});
+}
+
+#[test]
+fn set_team_should_work() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::set_team(RuntimeOrigin::signed(1), 0, 2, 3, 4));
+
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(2), 0, 42, 2));
+		assert_ok!(Uniques::freeze(RuntimeOrigin::signed(4), 0, 42));
+		assert_ok!(Uniques::thaw(RuntimeOrigin::signed(3), 0, 42));
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(3), 0, 42, 3));
+		assert_ok!(Uniques::burn(RuntimeOrigin::signed(3), 0, 42, None));
+	});
+}
+
+#[test]
+fn set_collection_metadata_should_work() {
+	new_test_ext().execute_with(|| {
+		// Cannot add metadata to unknown item
+		assert_noop!(
+			Uniques::set_collection_metadata(RuntimeOrigin::signed(1), 0, bvec![0u8; 20], false),
+			Error::<Test>::UnknownCollection,
+		);
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, false));
+		// Cannot add metadata to unowned item
+		assert_noop!(
+			Uniques::set_collection_metadata(RuntimeOrigin::signed(2), 0, bvec![0u8; 20], false),
+			Error::<Test>::NoPermission,
+		);
+
+		// Successfully add metadata and take deposit
+		Balances::make_free_balance_be(&1, 30);
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			bvec![0u8; 20],
+			false
+		));
+		assert_eq!(Balances::free_balance(&1), 9);
+		assert!(CollectionMetadataOf::<Test>::contains_key(0));
+
+		// Force origin works, too.
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::root(),
+			0,
+			bvec![0u8; 18],
+			false
+		));
+
+		// Update deposit
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			bvec![0u8; 15],
+			false
+		));
+		assert_eq!(Balances::free_balance(&1), 14);
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			bvec![0u8; 25],
+			false
+		));
+		assert_eq!(Balances::free_balance(&1), 4);
+
+		// Cannot over-reserve
+		assert_noop!(
+			Uniques::set_collection_metadata(RuntimeOrigin::signed(1), 0, bvec![0u8; 40], false),
+			BalancesError::<Test, _>::InsufficientBalance,
+		);
+
+		// Can't set or clear metadata once frozen
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			bvec![0u8; 15],
+			true
+		));
+		assert_noop!(
+			Uniques::set_collection_metadata(RuntimeOrigin::signed(1), 0, bvec![0u8; 15], false),
+			Error::<Test, _>::Frozen,
+		);
+		assert_noop!(
+			Uniques::clear_collection_metadata(RuntimeOrigin::signed(1), 0),
+			Error::<Test>::Frozen
+		);
+
+		// Clear Metadata
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::root(),
+			0,
+			bvec![0u8; 15],
+			false
+		));
+		assert_noop!(
+			Uniques::clear_collection_metadata(RuntimeOrigin::signed(2), 0),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Uniques::clear_collection_metadata(RuntimeOrigin::signed(1), 1),
+			Error::<Test>::UnknownCollection
+		);
+		assert_ok!(Uniques::clear_collection_metadata(RuntimeOrigin::signed(1), 0));
+		assert!(!CollectionMetadataOf::<Test>::contains_key(0));
+	});
+}
+
+#[test]
+fn set_item_metadata_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 30);
+
+		// Cannot add metadata to unknown item
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, false));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+		// Cannot add metadata to unowned item
+		assert_noop!(
+			Uniques::set_metadata(RuntimeOrigin::signed(2), 0, 42, bvec![0u8; 20], false),
+			Error::<Test>::NoPermission,
+		);
+
+		// Successfully add metadata and take deposit
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0u8; 20], false));
+		assert_eq!(Balances::free_balance(&1), 8);
+		assert!(ItemMetadataOf::<Test>::contains_key(0, 42));
+
+		// Force origin works, too.
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::root(), 0, 42, bvec![0u8; 18], false));
+
+		// Update deposit
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0u8; 15], false));
+		assert_eq!(Balances::free_balance(&1), 13);
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0u8; 25], false));
+		assert_eq!(Balances::free_balance(&1), 3);
+
+		// Cannot over-reserve
+		assert_noop!(
+			Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0u8; 40], false),
+			BalancesError::<Test, _>::InsufficientBalance,
+		);
+
+		// Can't set or clear metadata once frozen
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0u8; 15], true));
+		assert_noop!(
+			Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0u8; 15], false),
+			Error::<Test, _>::Frozen,
+		);
+		assert_noop!(
+			Uniques::clear_metadata(RuntimeOrigin::signed(1), 0, 42),
+			Error::<Test>::Frozen
+		);
+
+		// Clear Metadata
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::root(), 0, 42, bvec![0u8; 15], false));
+		assert_noop!(
+			Uniques::clear_metadata(RuntimeOrigin::signed(2), 0, 42),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Uniques::clear_metadata(RuntimeOrigin::signed(1), 1, 42),
+			Error::<Test>::UnknownCollection
+		);
+		assert_ok!(Uniques::clear_metadata(RuntimeOrigin::signed(1), 0, 42));
+		assert!(!ItemMetadataOf::<Test>::contains_key(0, 42));
+	});
+}
+
+#[test]
+fn set_attribute_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, false));
+
+		assert_ok!(Uniques::set_attribute(RuntimeOrigin::signed(1), 0, None, bvec![0], bvec![0]));
+		assert_ok!(Uniques::set_attribute(
+			RuntimeOrigin::signed(1),
+			0,
+			Some(0),
+			bvec![0],
+			bvec![0]
+		));
+		assert_ok!(Uniques::set_attribute(
+			RuntimeOrigin::signed(1),
+			0,
+			Some(0),
+			bvec![1],
+			bvec![0]
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, bvec![0], bvec![0]),
+				(Some(0), bvec![0], bvec![0]),
+				(Some(0), bvec![1], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(1), 9);
+
+		assert_ok!(Uniques::set_attribute(
+			RuntimeOrigin::signed(1),
+			0,
+			None,
+			bvec![0],
+			bvec![0; 10]
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, bvec![0], bvec![0; 10]),
+				(Some(0), bvec![0], bvec![0]),
+				(Some(0), bvec![1], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(1), 18);
+
+		assert_ok!(Uniques::clear_attribute(RuntimeOrigin::signed(1), 0, Some(0), bvec![1]));
+		assert_eq!(
+			attributes(0),
+			vec![(None, bvec![0], bvec![0; 10]), (Some(0), bvec![0], bvec![0]),]
+		);
+		assert_eq!(Balances::reserved_balance(1), 15);
+
+		let w = Collection::<Test>::get(0).unwrap().destroy_witness();
+		assert_ok!(Uniques::destroy(RuntimeOrigin::signed(1), 0, w));
+		assert_eq!(attributes(0), vec![]);
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn set_attribute_should_respect_freeze() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, false));
+
+		assert_ok!(Uniques::set_attribute(RuntimeOrigin::signed(1), 0, None, bvec![0], bvec![0]));
+		assert_ok!(Uniques::set_attribute(
+			RuntimeOrigin::signed(1),
+			0,
+			Some(0),
+			bvec![0],
+			bvec![0]
+		));
+		assert_ok!(Uniques::set_attribute(
+			RuntimeOrigin::signed(1),
+			0,
+			Some(1),
+			bvec![0],
+			bvec![0]
+		));
+		assert_eq!(
+			attributes(0),
+			vec![
+				(None, bvec![0], bvec![0]),
+				(Some(0), bvec![0], bvec![0]),
+				(Some(1), bvec![0], bvec![0]),
+			]
+		);
+		assert_eq!(Balances::reserved_balance(1), 9);
+
+		assert_ok!(Uniques::set_collection_metadata(RuntimeOrigin::signed(1), 0, bvec![], true));
+		let e = Error::<Test>::Frozen;
+		assert_noop!(
+			Uniques::set_attribute(RuntimeOrigin::signed(1), 0, None, bvec![0], bvec![0]),
+			e
+		);
+		assert_ok!(Uniques::set_attribute(
+			RuntimeOrigin::signed(1),
+			0,
+			Some(0),
+			bvec![0],
+			bvec![1]
+		));
+
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 0, bvec![], true));
+		let e = Error::<Test>::Frozen;
+		assert_noop!(
+			Uniques::set_attribute(RuntimeOrigin::signed(1), 0, Some(0), bvec![0], bvec![1]),
+			e
+		);
+		assert_ok!(Uniques::set_attribute(
+			RuntimeOrigin::signed(1),
+			0,
+			Some(1),
+			bvec![0],
+			bvec![1]
+		));
+	});
+}
+
+#[test]
+fn force_item_status_should_work() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, false));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 1));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 69, 2));
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			bvec![0; 20],
+			false
+		));
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0; 20], false));
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 69, bvec![0; 20], false));
+		assert_eq!(Balances::reserved_balance(1), 65);
+
+		// force item status to be free holding
+		assert_ok!(Uniques::force_item_status(RuntimeOrigin::root(), 0, 1, 1, 1, 1, true, false));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 142, 1));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 169, 2));
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 142, bvec![0; 20], false));
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 169, bvec![0; 20], false));
+		assert_eq!(Balances::reserved_balance(1), 65);
+
+		assert_ok!(Uniques::redeposit(RuntimeOrigin::signed(1), 0, bvec![0, 42, 50, 69, 100]));
+		assert_eq!(Balances::reserved_balance(1), 63);
+
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 42, bvec![0; 20], false));
+		assert_eq!(Balances::reserved_balance(1), 42);
+
+		assert_ok!(Uniques::set_metadata(RuntimeOrigin::signed(1), 0, 69, bvec![0; 20], false));
+		assert_eq!(Balances::reserved_balance(1), 21);
+
+		assert_ok!(Uniques::set_collection_metadata(
+			RuntimeOrigin::signed(1),
+			0,
+			bvec![0; 20],
+			false
+		));
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn burn_works() {
+	new_test_ext().execute_with(|| {
+		Balances::make_free_balance_be(&1, 100);
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, false));
+		assert_ok!(Uniques::set_team(RuntimeOrigin::signed(1), 0, 2, 3, 4));
+
+		assert_noop!(
+			Uniques::burn(RuntimeOrigin::signed(5), 0, 42, Some(5)),
+			Error::<Test>::UnknownCollection
+		);
+
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(2), 0, 42, 5));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(2), 0, 69, 5));
+		assert_eq!(Balances::reserved_balance(1), 2);
+
+		assert_noop!(
+			Uniques::burn(RuntimeOrigin::signed(0), 0, 42, None),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Uniques::burn(RuntimeOrigin::signed(5), 0, 42, Some(6)),
+			Error::<Test>::WrongOwner
+		);
+
+		assert_ok!(Uniques::burn(RuntimeOrigin::signed(5), 0, 42, Some(5)));
+		assert_ok!(Uniques::burn(RuntimeOrigin::signed(3), 0, 69, Some(5)));
+		assert_eq!(Balances::reserved_balance(1), 0);
+	});
+}
+
+#[test]
+fn approval_lifecycle_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 2));
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(2), 0, 42, 3));
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(3), 0, 42, 4));
+		assert_noop!(
+			Uniques::transfer(RuntimeOrigin::signed(3), 0, 42, 3),
+			Error::<Test>::NoPermission
+		);
+		assert!(Item::<Test>::get(0, 42).unwrap().approved.is_none());
+
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(4), 0, 42, 2));
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(2), 0, 42, 2));
+	});
+}
+
+#[test]
+fn approved_account_gets_reset_after_transfer() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 2));
+
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(2), 0, 42, 3));
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(2), 0, 42, 5));
+
+		// this shouldn't work because we have just transfered the item to another account.
+		assert_noop!(
+			Uniques::transfer(RuntimeOrigin::signed(3), 0, 42, 4),
+			Error::<Test>::NoPermission
+		);
+		// The new owner can transfer fine:
+		assert_ok!(Uniques::transfer(RuntimeOrigin::signed(5), 0, 42, 6));
+	});
+}
+
+#[test]
+fn approved_account_gets_reset_after_buy_item() {
+	new_test_ext().execute_with(|| {
+		let item = 1;
+		let price = 15;
+
+		Balances::make_free_balance_be(&2, 100);
+
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, item, 1));
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(1), 0, item, 5));
+
+		assert_ok!(Uniques::set_price(RuntimeOrigin::signed(1), 0, item, Some(price), None));
+
+		assert_ok!(Uniques::buy_item(RuntimeOrigin::signed(2), 0, item, price));
+
+		// this shouldn't work because the item has been bough and the approved account should be
+		// reset.
+		assert_noop!(
+			Uniques::transfer(RuntimeOrigin::signed(5), 0, item, 4),
+			Error::<Test>::NoPermission
+		);
+	});
+}
+
+#[test]
+fn cancel_approval_works() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 2));
+
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(2), 0, 42, 3));
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(2), 1, 42, None),
+			Error::<Test>::UnknownCollection
+		);
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(2), 0, 43, None),
+			Error::<Test>::UnknownCollection
+		);
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(3), 0, 42, None),
+			Error::<Test>::NoPermission
+		);
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(2), 0, 42, Some(4)),
+			Error::<Test>::WrongDelegate
+		);
+
+		assert_ok!(Uniques::cancel_approval(RuntimeOrigin::signed(2), 0, 42, Some(3)));
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(2), 0, 42, None),
+			Error::<Test>::NoDelegate
+		);
+	});
+}
+
+#[test]
+fn cancel_approval_works_with_admin() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 2));
+
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(2), 0, 42, 3));
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(1), 1, 42, None),
+			Error::<Test>::UnknownCollection
+		);
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(1), 0, 43, None),
+			Error::<Test>::UnknownCollection
+		);
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(1), 0, 42, Some(4)),
+			Error::<Test>::WrongDelegate
+		);
+
+		assert_ok!(Uniques::cancel_approval(RuntimeOrigin::signed(1), 0, 42, Some(3)));
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::signed(1), 0, 42, None),
+			Error::<Test>::NoDelegate
+		);
+	});
+}
+
+#[test]
+fn cancel_approval_works_with_force() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), 0, 1, true));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(1), 0, 42, 2));
+
+		assert_ok!(Uniques::approve_transfer(RuntimeOrigin::signed(2), 0, 42, 3));
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::root(), 1, 42, None),
+			Error::<Test>::UnknownCollection
+		);
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::root(), 0, 43, None),
+			Error::<Test>::UnknownCollection
+		);
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::root(), 0, 42, Some(4)),
+			Error::<Test>::WrongDelegate
+		);
+
+		assert_ok!(Uniques::cancel_approval(RuntimeOrigin::root(), 0, 42, Some(3)));
+		assert_noop!(
+			Uniques::cancel_approval(RuntimeOrigin::root(), 0, 42, None),
+			Error::<Test>::NoDelegate
+		);
+	});
+}
+
+#[test]
+fn max_supply_should_work() {
+	new_test_ext().execute_with(|| {
+		let collection_id = 0;
+		let user_id = 1;
+		let max_supply = 2;
+
+		// validate set_collection_max_supply
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), collection_id, user_id, true));
+		assert!(!CollectionMaxSupply::<Test>::contains_key(collection_id));
+
+		assert_ok!(Uniques::set_collection_max_supply(
+			RuntimeOrigin::signed(user_id),
+			collection_id,
+			max_supply
+		));
+		assert_eq!(CollectionMaxSupply::<Test>::get(collection_id).unwrap(), max_supply);
+
+		assert!(events().contains(&Event::<Test>::CollectionMaxSupplySet {
+			collection: collection_id,
+			max_supply,
+		}));
+
+		assert_noop!(
+			Uniques::set_collection_max_supply(
+				RuntimeOrigin::signed(user_id),
+				collection_id,
+				max_supply + 1
+			),
+			Error::<Test>::MaxSupplyAlreadySet
+		);
+
+		// validate we can't mint more to max supply
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(user_id), collection_id, 0, user_id));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(user_id), collection_id, 1, user_id));
+		assert_noop!(
+			Uniques::mint(RuntimeOrigin::signed(user_id), collection_id, 2, user_id),
+			Error::<Test>::MaxSupplyReached
+		);
+
+		// validate we remove the CollectionMaxSupply record when we destroy the collection
+		assert_ok!(Uniques::destroy(
+			RuntimeOrigin::signed(user_id),
+			collection_id,
+			Collection::<Test>::get(collection_id).unwrap().destroy_witness()
+		));
+		assert!(!CollectionMaxSupply::<Test>::contains_key(collection_id));
+	});
+}
+
+#[test]
+fn set_price_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_id = 1;
+		let collection_id = 0;
+		let item_1 = 1;
+		let item_2 = 2;
+
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), collection_id, user_id, true));
+
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(user_id), collection_id, item_1, user_id));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(user_id), collection_id, item_2, user_id));
+
+		assert_ok!(Uniques::set_price(
+			RuntimeOrigin::signed(user_id),
+			collection_id,
+			item_1,
+			Some(1),
+			None,
+		));
+
+		assert_ok!(Uniques::set_price(
+			RuntimeOrigin::signed(user_id),
+			collection_id,
+			item_2,
+			Some(2),
+			Some(3)
+		));
+
+		let item = ItemPriceOf::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(item.0, 1);
+		assert_eq!(item.1, None);
+
+		let item = ItemPriceOf::<Test>::get(collection_id, item_2).unwrap();
+		assert_eq!(item.0, 2);
+		assert_eq!(item.1, Some(3));
+
+		assert!(events().contains(&Event::<Test>::ItemPriceSet {
+			collection: collection_id,
+			item: item_1,
+			price: 1,
+			whitelisted_buyer: None,
+		}));
+
+		// validate we can unset the price
+		assert_ok!(Uniques::set_price(
+			RuntimeOrigin::signed(user_id),
+			collection_id,
+			item_2,
+			None,
+			None
+		));
+		assert!(events().contains(&Event::<Test>::ItemPriceRemoved {
+			collection: collection_id,
+			item: item_2
+		}));
+		assert!(!ItemPriceOf::<Test>::contains_key(collection_id, item_2));
+	});
+}
+
+#[test]
+fn buy_item_should_work() {
+	new_test_ext().execute_with(|| {
+		let user_1 = 1;
+		let user_2 = 2;
+		let user_3 = 3;
+		let collection_id = 0;
+		let item_1 = 1;
+		let item_2 = 2;
+		let item_3 = 3;
+		let price_1 = 20;
+		let price_2 = 30;
+		let initial_balance = 100;
+
+		Balances::make_free_balance_be(&user_1, initial_balance);
+		Balances::make_free_balance_be(&user_2, initial_balance);
+		Balances::make_free_balance_be(&user_3, initial_balance);
+
+		assert_ok!(Uniques::force_create(RuntimeOrigin::root(), collection_id, user_1, true));
+
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(user_1), collection_id, item_1, user_1));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(user_1), collection_id, item_2, user_1));
+		assert_ok!(Uniques::mint(RuntimeOrigin::signed(user_1), collection_id, item_3, user_1));
+
+		assert_ok!(Uniques::set_price(
+			RuntimeOrigin::signed(user_1),
+			collection_id,
+			item_1,
+			Some(price_1),
+			None,
+		));
+
+		assert_ok!(Uniques::set_price(
+			RuntimeOrigin::signed(user_1),
+			collection_id,
+			item_2,
+			Some(price_2),
+			Some(user_3),
+		));
+
+		// can't buy for less
+		assert_noop!(
+			Uniques::buy_item(RuntimeOrigin::signed(user_2), collection_id, item_1, 1),
+			Error::<Test>::BidTooLow
+		);
+
+		// pass the higher price to validate it will still deduct correctly
+		assert_ok!(Uniques::buy_item(
+			RuntimeOrigin::signed(user_2),
+			collection_id,
+			item_1,
+			price_1 + 1,
+		));
+
+		// validate the new owner & balances
+		let item = Item::<Test>::get(collection_id, item_1).unwrap();
+		assert_eq!(item.owner, user_2);
+		assert_eq!(Balances::total_balance(&user_1), initial_balance + price_1);
+		assert_eq!(Balances::total_balance(&user_2), initial_balance - price_1);
+
+		// can't buy from yourself
+		assert_noop!(
+			Uniques::buy_item(RuntimeOrigin::signed(user_1), collection_id, item_2, price_2),
+			Error::<Test>::NoPermission
+		);
+
+		// can't buy when the item is listed for a specific buyer
+		assert_noop!(
+			Uniques::buy_item(RuntimeOrigin::signed(user_2), collection_id, item_2, price_2),
+			Error::<Test>::NoPermission
+		);
+
+		// can buy when I'm a whitelisted buyer
+		assert_ok!(Uniques::buy_item(
+			RuntimeOrigin::signed(user_3),
+			collection_id,
+			item_2,
+			price_2,
+		));
+
+		assert!(events().contains(&Event::<Test>::ItemBought {
+			collection: collection_id,
+			item: item_2,
+			price: price_2,
+			seller: user_1,
+			buyer: user_3,
+		}));
+
+		// ensure we reset the buyer field
+		assert!(!ItemPriceOf::<Test>::contains_key(collection_id, item_2));
+
+		// can't buy when item is not for sale
+		assert_noop!(
+			Uniques::buy_item(RuntimeOrigin::signed(user_2), collection_id, item_3, price_2),
+			Error::<Test>::NotForSale
+		);
+
+		// ensure we can't buy an item when the collection or an item is frozen
+		{
+			assert_ok!(Uniques::set_price(
+				RuntimeOrigin::signed(user_1),
+				collection_id,
+				item_3,
+				Some(price_1),
+				None,
+			));
+
+			// freeze collection
+			assert_ok!(Uniques::freeze_collection(RuntimeOrigin::signed(user_1), collection_id));
+
+			let buy_item_call = mock::RuntimeCall::Uniques(crate::Call::<Test>::buy_item {
+				collection: collection_id,
+				item: item_3,
+				bid_price: price_1,
+			});
+			assert_noop!(
+				buy_item_call.dispatch(RuntimeOrigin::signed(user_2)),
+				Error::<Test>::Frozen
+			);
+
+			assert_ok!(Uniques::thaw_collection(RuntimeOrigin::signed(user_1), collection_id));
+
+			// freeze item
+			assert_ok!(Uniques::freeze(RuntimeOrigin::signed(user_1), collection_id, item_3));
+
+			let buy_item_call = mock::RuntimeCall::Uniques(crate::Call::<Test>::buy_item {
+				collection: collection_id,
+				item: item_3,
+				bid_price: price_1,
+			});
+			assert_noop!(
+				buy_item_call.dispatch(RuntimeOrigin::signed(user_2)),
+				Error::<Test>::Frozen
+			);
+		}
+	});
+}
diff --git a/substrate/frame/uniques/src/types.rs b/substrate/frame/uniques/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a2e804f245f77ea4ca120af2318ebdfd7f6d89ef
--- /dev/null
+++ b/substrate/frame/uniques/src/types.rs
@@ -0,0 +1,133 @@
+// 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.
+
+//! Various basic types for use in the Uniques pallet.
+
+use super::*;
+use frame_support::{
+	pallet_prelude::{BoundedVec, MaxEncodedLen},
+	traits::Get,
+};
+use scale_info::TypeInfo;
+
+/// A type alias for handling balance deposits.
+pub(super) type DepositBalanceOf<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance;
+/// A type alias representing the details of a collection.
+pub(super) type CollectionDetailsFor<T, I> =
+	CollectionDetails<<T as SystemConfig>::AccountId, DepositBalanceOf<T, I>>;
+/// A type alias for the details of a single item.
+pub(super) type ItemDetailsFor<T, I> =
+	ItemDetails<<T as SystemConfig>::AccountId, DepositBalanceOf<T, I>>;
+/// A type alias to represent the price of an item.
+pub(super) type ItemPrice<T, I = ()> =
+	<<T as Config<I>>::Currency as Currency<<T as SystemConfig>::AccountId>>::Balance;
+
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct CollectionDetails<AccountId, DepositBalance> {
+	/// Can change `owner`, `issuer`, `freezer` and `admin` accounts.
+	pub(super) owner: AccountId,
+	/// Can mint tokens.
+	pub(super) issuer: AccountId,
+	/// Can thaw tokens, force transfers and burn tokens from any account.
+	pub(super) admin: AccountId,
+	/// Can freeze tokens.
+	pub(super) freezer: AccountId,
+	/// The total balance deposited for the all storage associated with this collection.
+	/// Used by `destroy`.
+	pub(super) total_deposit: DepositBalance,
+	/// If `true`, then no deposit is needed to hold items of this collection.
+	pub(super) free_holding: bool,
+	/// The total number of outstanding items of this collection.
+	pub(super) items: u32,
+	/// The total number of outstanding item metadata of this collection.
+	pub(super) item_metadatas: u32,
+	/// The total number of attributes for this collection.
+	pub(super) attributes: u32,
+	/// Whether the collection is frozen for non-admin transfers.
+	pub(super) is_frozen: bool,
+}
+
+/// Witness data for the destroy transactions.
+#[derive(Copy, Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub struct DestroyWitness {
+	/// The total number of outstanding items of this collection.
+	#[codec(compact)]
+	pub items: u32,
+	/// The total number of items in this collection that have outstanding item metadata.
+	#[codec(compact)]
+	pub item_metadatas: u32,
+	#[codec(compact)]
+	/// The total number of attributes for this collection.
+	pub attributes: u32,
+}
+
+impl<AccountId, DepositBalance> CollectionDetails<AccountId, DepositBalance> {
+	pub fn destroy_witness(&self) -> DestroyWitness {
+		DestroyWitness {
+			items: self.items,
+			item_metadatas: self.item_metadatas,
+			attributes: self.attributes,
+		}
+	}
+}
+
+/// Information concerning the ownership of a single unique item.
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, TypeInfo, MaxEncodedLen)]
+pub struct ItemDetails<AccountId, DepositBalance> {
+	/// The owner of this item.
+	pub(super) owner: AccountId,
+	/// The approved transferrer of this item, if one is set.
+	pub(super) approved: Option<AccountId>,
+	/// Whether the item can be transferred or not.
+	pub(super) is_frozen: bool,
+	/// The amount held in the pallet's default account for this item. Free-hold items will have
+	/// this as zero.
+	pub(super) deposit: DepositBalance,
+}
+
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(StringLimit))]
+#[codec(mel_bound(DepositBalance: MaxEncodedLen))]
+pub struct CollectionMetadata<DepositBalance, StringLimit: Get<u32>> {
+	/// The balance deposited for this metadata.
+	///
+	/// This pays for the data stored in this struct.
+	pub(super) deposit: DepositBalance,
+	/// General information concerning this collection. Limited in length by `StringLimit`. This
+	/// will generally be either a JSON dump or the hash of some JSON which can be found on a
+	/// hash-addressable global publication system such as IPFS.
+	pub(super) data: BoundedVec<u8, StringLimit>,
+	/// Whether the collection's metadata may be changed by a non Force origin.
+	pub(super) is_frozen: bool,
+}
+
+#[derive(Clone, Encode, Decode, Eq, PartialEq, RuntimeDebug, Default, TypeInfo, MaxEncodedLen)]
+#[scale_info(skip_type_params(StringLimit))]
+#[codec(mel_bound(DepositBalance: MaxEncodedLen))]
+pub struct ItemMetadata<DepositBalance, StringLimit: Get<u32>> {
+	/// The balance deposited for this metadata.
+	///
+	/// This pays for the data stored in this struct.
+	pub(super) deposit: DepositBalance,
+	/// General information concerning this item. Limited in length by `StringLimit`. This will
+	/// generally be either a JSON dump or the hash of some JSON which can be found on a
+	/// hash-addressable global publication system such as IPFS.
+	pub(super) data: BoundedVec<u8, StringLimit>,
+	/// Whether the item metadata may be changed by a non Force origin.
+	pub(super) is_frozen: bool,
+}
diff --git a/substrate/frame/uniques/src/weights.rs b/substrate/frame/uniques/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb80ee550a1db2d97aaed001f5041e49fdbca864
--- /dev/null
+++ b/substrate/frame/uniques/src/weights.rs
@@ -0,0 +1,863 @@
+// 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.
+
+//! Autogenerated weights for `pallet_uniques`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-07-19, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-gghbxkbs-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: ``, WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
+
+// Executed Command:
+// target/production/substrate
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_uniques
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/uniques/src/weights.rs
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for `pallet_uniques`.
+pub trait WeightInfo {
+	fn create() -> Weight;
+	fn force_create() -> Weight;
+	fn destroy(n: u32, m: u32, a: u32, ) -> Weight;
+	fn mint() -> Weight;
+	fn burn() -> Weight;
+	fn transfer() -> Weight;
+	fn redeposit(i: u32, ) -> Weight;
+	fn freeze() -> Weight;
+	fn thaw() -> Weight;
+	fn freeze_collection() -> Weight;
+	fn thaw_collection() -> Weight;
+	fn transfer_ownership() -> Weight;
+	fn set_team() -> Weight;
+	fn force_item_status() -> Weight;
+	fn set_attribute() -> Weight;
+	fn clear_attribute() -> Weight;
+	fn set_metadata() -> Weight;
+	fn clear_metadata() -> Weight;
+	fn set_collection_metadata() -> Weight;
+	fn clear_collection_metadata() -> Weight;
+	fn approve_transfer() -> Weight;
+	fn cancel_approval() -> Weight;
+	fn set_accept_ownership() -> Weight;
+	fn set_collection_max_supply() -> Weight;
+	fn set_price() -> Weight;
+	fn buy_item() -> Weight;
+}
+
+/// Weights for `pallet_uniques` using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `249`
+		//  Estimated: `3643`
+		// Minimum execution time: 31_393_000 picoseconds.
+		Weight::from_parts(32_933_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn force_create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `3643`
+		// Minimum execution time: 14_827_000 picoseconds.
+		Weight::from_parts(15_273_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1001 w:1000)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1000 w:1000)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Attribute` (r:1000 w:1000)
+	/// Proof: `Uniques::Attribute` (`max_values`: None, `max_size`: Some(364), added: 2839, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassMetadataOf` (r:0 w:1)
+	/// Proof: `Uniques::ClassMetadataOf` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:1000)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::CollectionMaxSupply` (r:0 w:1)
+	/// Proof: `Uniques::CollectionMaxSupply` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1000]`.
+	/// The range of component `m` is `[0, 1000]`.
+	/// The range of component `a` is `[0, 1000]`.
+	fn destroy(n: u32, m: u32, a: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418 + a * (107 ±0) + m * (56 ±0) + n * (76 ±0)`
+		//  Estimated: `3643 + a * (2839 ±0) + m * (2583 ±0) + n * (2597 ±0)`
+		// Minimum execution time: 3_281_673_000 picoseconds.
+		Weight::from_parts(3_443_387_000, 3643)
+			// Standard Error: 41_937
+			.saturating_add(Weight::from_parts(7_914_842, 0).saturating_mul(n.into()))
+			// Standard Error: 41_937
+			.saturating_add(Weight::from_parts(519_960, 0).saturating_mul(m.into()))
+			// Standard Error: 41_937
+			.saturating_add(Weight::from_parts(462_690, 0).saturating_mul(a.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().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(a.into())))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+			.saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(m.into())))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(a.into())))
+			.saturating_add(Weight::from_parts(0, 2839).saturating_mul(a.into()))
+			.saturating_add(Weight::from_parts(0, 2583).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 2597).saturating_mul(n.into()))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::CollectionMaxSupply` (r:1 w:0)
+	/// Proof: `Uniques::CollectionMaxSupply` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:1)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 38_122_000 picoseconds.
+		Weight::from_parts(38_924_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:1)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	fn burn() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 38_835_000 picoseconds.
+		Weight::from_parts(39_754_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:2)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 27_032_000 picoseconds.
+		Weight::from_parts(27_793_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:5000 w:5000)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// The range of component `i` is `[0, 5000]`.
+	fn redeposit(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `805 + i * (76 ±0)`
+		//  Estimated: `3643 + i * (2597 ±0)`
+		// Minimum execution time: 14_737_000 picoseconds.
+		Weight::from_parts(15_070_000, 3643)
+			// Standard Error: 22_500
+			.saturating_add(Weight::from_parts(18_855_468, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(i.into())))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+			.saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into())))
+			.saturating_add(Weight::from_parts(0, 2597).saturating_mul(i.into()))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn freeze() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 18_664_000 picoseconds.
+		Weight::from_parts(19_455_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn thaw() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 18_247_000 picoseconds.
+		Weight::from_parts(18_763_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn freeze_collection() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 13_219_000 picoseconds.
+		Weight::from_parts(13_923_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn thaw_collection() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 13_376_000 picoseconds.
+		Weight::from_parts(13_904_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::OwnershipAcceptance` (r:1 w:1)
+	/// Proof: `Uniques::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:2)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn transfer_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `423`
+		//  Estimated: `3643`
+		// Minimum execution time: 22_353_000 picoseconds.
+		Weight::from_parts(23_222_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn set_team() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 14_072_000 picoseconds.
+		Weight::from_parts(14_619_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn force_item_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 17_081_000 picoseconds.
+		Weight::from_parts(17_698_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:0)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Attribute` (r:1 w:1)
+	/// Proof: `Uniques::Attribute` (`max_values`: None, `max_size`: Some(364), added: 2839, mode: `MaxEncodedLen`)
+	fn set_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `547`
+		//  Estimated: `3829`
+		// Minimum execution time: 41_501_000 picoseconds.
+		Weight::from_parts(43_101_000, 3829)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:0)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Attribute` (r:1 w:1)
+	/// Proof: `Uniques::Attribute` (`max_values`: None, `max_size`: Some(364), added: 2839, mode: `MaxEncodedLen`)
+	fn clear_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `936`
+		//  Estimated: `3829`
+		// Minimum execution time: 39_722_000 picoseconds.
+		Weight::from_parts(40_390_000, 3829)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	fn set_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `415`
+		//  Estimated: `3643`
+		// Minimum execution time: 30_726_000 picoseconds.
+		Weight::from_parts(31_557_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `547`
+		//  Estimated: `3643`
+		// Minimum execution time: 31_303_000 picoseconds.
+		Weight::from_parts(32_389_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::ClassMetadataOf` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn set_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 32_155_000 picoseconds.
+		Weight::from_parts(32_885_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::ClassMetadataOf` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn clear_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `461`
+		//  Estimated: `3643`
+		// Minimum execution time: 30_044_000 picoseconds.
+		Weight::from_parts(31_405_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 18_904_000 picoseconds.
+		Weight::from_parts(19_687_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `528`
+		//  Estimated: `3643`
+		// Minimum execution time: 19_144_000 picoseconds.
+		Weight::from_parts(19_706_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::OwnershipAcceptance` (r:1 w:1)
+	/// Proof: `Uniques::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn set_accept_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `3517`
+		// Minimum execution time: 15_339_000 picoseconds.
+		Weight::from_parts(15_918_000, 3517)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::CollectionMaxSupply` (r:1 w:1)
+	/// Proof: `Uniques::CollectionMaxSupply` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn set_collection_max_supply() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 15_387_000 picoseconds.
+		Weight::from_parts(15_726_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:0)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	fn set_price() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `326`
+		//  Estimated: `3587`
+		// Minimum execution time: 15_873_000 picoseconds.
+		Weight::from_parts(16_860_000, 3587)
+			.saturating_add(T::DbWeight::get().reads(1_u64))
+			.saturating_add(T::DbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:1 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:2)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn buy_item() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `607`
+		//  Estimated: `3643`
+		// Minimum execution time: 37_245_000 picoseconds.
+		Weight::from_parts(38_383_000, 3643)
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+}
+
+// For backwards compatibility and tests.
+impl WeightInfo for () {
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `249`
+		//  Estimated: `3643`
+		// Minimum execution time: 31_393_000 picoseconds.
+		Weight::from_parts(32_933_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn force_create() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `3643`
+		// Minimum execution time: 14_827_000 picoseconds.
+		Weight::from_parts(15_273_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1001 w:1000)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1000 w:1000)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Attribute` (r:1000 w:1000)
+	/// Proof: `Uniques::Attribute` (`max_values`: None, `max_size`: Some(364), added: 2839, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassMetadataOf` (r:0 w:1)
+	/// Proof: `Uniques::ClassMetadataOf` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:1000)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::CollectionMaxSupply` (r:0 w:1)
+	/// Proof: `Uniques::CollectionMaxSupply` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`)
+	/// The range of component `n` is `[0, 1000]`.
+	/// The range of component `m` is `[0, 1000]`.
+	/// The range of component `a` is `[0, 1000]`.
+	fn destroy(n: u32, m: u32, a: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `418 + a * (107 ±0) + m * (56 ±0) + n * (76 ±0)`
+		//  Estimated: `3643 + a * (2839 ±0) + m * (2583 ±0) + n * (2597 ±0)`
+		// Minimum execution time: 3_281_673_000 picoseconds.
+		Weight::from_parts(3_443_387_000, 3643)
+			// Standard Error: 41_937
+			.saturating_add(Weight::from_parts(7_914_842, 0).saturating_mul(n.into()))
+			// Standard Error: 41_937
+			.saturating_add(Weight::from_parts(519_960, 0).saturating_mul(m.into()))
+			// Standard Error: 41_937
+			.saturating_add(Weight::from_parts(462_690, 0).saturating_mul(a.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(m.into())))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(a.into())))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+			.saturating_add(RocksDbWeight::get().writes((2_u64).saturating_mul(n.into())))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(m.into())))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(a.into())))
+			.saturating_add(Weight::from_parts(0, 2839).saturating_mul(a.into()))
+			.saturating_add(Weight::from_parts(0, 2583).saturating_mul(m.into()))
+			.saturating_add(Weight::from_parts(0, 2597).saturating_mul(n.into()))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::CollectionMaxSupply` (r:1 w:0)
+	/// Proof: `Uniques::CollectionMaxSupply` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:1)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn mint() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 38_122_000 picoseconds.
+		Weight::from_parts(38_924_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:1)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	fn burn() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 38_835_000 picoseconds.
+		Weight::from_parts(39_754_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:2)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	fn transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 27_032_000 picoseconds.
+		Weight::from_parts(27_793_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:5000 w:5000)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// The range of component `i` is `[0, 5000]`.
+	fn redeposit(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `805 + i * (76 ±0)`
+		//  Estimated: `3643 + i * (2597 ±0)`
+		// Minimum execution time: 14_737_000 picoseconds.
+		Weight::from_parts(15_070_000, 3643)
+			// Standard Error: 22_500
+			.saturating_add(Weight::from_parts(18_855_468, 0).saturating_mul(i.into()))
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(i.into())))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+			.saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(i.into())))
+			.saturating_add(Weight::from_parts(0, 2597).saturating_mul(i.into()))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn freeze() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 18_664_000 picoseconds.
+		Weight::from_parts(19_455_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn thaw() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 18_247_000 picoseconds.
+		Weight::from_parts(18_763_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn freeze_collection() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 13_219_000 picoseconds.
+		Weight::from_parts(13_923_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn thaw_collection() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 13_376_000 picoseconds.
+		Weight::from_parts(13_904_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::OwnershipAcceptance` (r:1 w:1)
+	/// Proof: `Uniques::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:2)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn transfer_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `423`
+		//  Estimated: `3643`
+		// Minimum execution time: 22_353_000 picoseconds.
+		Weight::from_parts(23_222_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn set_team() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 14_072_000 picoseconds.
+		Weight::from_parts(14_619_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassAccount` (r:0 w:1)
+	/// Proof: `Uniques::ClassAccount` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`)
+	fn force_item_status() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 17_081_000 picoseconds.
+		Weight::from_parts(17_698_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:0)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Attribute` (r:1 w:1)
+	/// Proof: `Uniques::Attribute` (`max_values`: None, `max_size`: Some(364), added: 2839, mode: `MaxEncodedLen`)
+	fn set_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `547`
+		//  Estimated: `3829`
+		// Minimum execution time: 41_501_000 picoseconds.
+		Weight::from_parts(43_101_000, 3829)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:0)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Attribute` (r:1 w:1)
+	/// Proof: `Uniques::Attribute` (`max_values`: None, `max_size`: Some(364), added: 2839, mode: `MaxEncodedLen`)
+	fn clear_attribute() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `936`
+		//  Estimated: `3829`
+		// Minimum execution time: 39_722_000 picoseconds.
+		Weight::from_parts(40_390_000, 3829)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	fn set_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `415`
+		//  Estimated: `3643`
+		// Minimum execution time: 30_726_000 picoseconds.
+		Weight::from_parts(31_557_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::InstanceMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::InstanceMetadataOf` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`)
+	fn clear_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `547`
+		//  Estimated: `3643`
+		// Minimum execution time: 31_303_000 picoseconds.
+		Weight::from_parts(32_389_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:1)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::ClassMetadataOf` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn set_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 32_155_000 picoseconds.
+		Weight::from_parts(32_885_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ClassMetadataOf` (r:1 w:1)
+	/// Proof: `Uniques::ClassMetadataOf` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn clear_collection_metadata() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `461`
+		//  Estimated: `3643`
+		// Minimum execution time: 30_044_000 picoseconds.
+		Weight::from_parts(31_405_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	fn approve_transfer() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `495`
+		//  Estimated: `3643`
+		// Minimum execution time: 18_904_000 picoseconds.
+		Weight::from_parts(19_687_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	fn cancel_approval() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `528`
+		//  Estimated: `3643`
+		// Minimum execution time: 19_144_000 picoseconds.
+		Weight::from_parts(19_706_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::OwnershipAcceptance` (r:1 w:1)
+	/// Proof: `Uniques::OwnershipAcceptance` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`)
+	fn set_accept_ownership() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `109`
+		//  Estimated: `3517`
+		// Minimum execution time: 15_339_000 picoseconds.
+		Weight::from_parts(15_918_000, 3517)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::CollectionMaxSupply` (r:1 w:1)
+	/// Proof: `Uniques::CollectionMaxSupply` (`max_values`: None, `max_size`: Some(24), added: 2499, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	fn set_collection_max_supply() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `349`
+		//  Estimated: `3643`
+		// Minimum execution time: 15_387_000 picoseconds.
+		Weight::from_parts(15_726_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:0)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:0 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	fn set_price() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `326`
+		//  Estimated: `3587`
+		// Minimum execution time: 15_873_000 picoseconds.
+		Weight::from_parts(16_860_000, 3587)
+			.saturating_add(RocksDbWeight::get().reads(1_u64))
+			.saturating_add(RocksDbWeight::get().writes(1_u64))
+	}
+	/// Storage: `Uniques::Asset` (r:1 w:1)
+	/// Proof: `Uniques::Asset` (`max_values`: None, `max_size`: Some(122), added: 2597, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::ItemPriceOf` (r:1 w:1)
+	/// Proof: `Uniques::ItemPriceOf` (`max_values`: None, `max_size`: Some(89), added: 2564, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Class` (r:1 w:0)
+	/// Proof: `Uniques::Class` (`max_values`: None, `max_size`: Some(178), added: 2653, mode: `MaxEncodedLen`)
+	/// Storage: `Uniques::Account` (r:0 w:2)
+	/// Proof: `Uniques::Account` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`)
+	fn buy_item() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `607`
+		//  Estimated: `3643`
+		// Minimum execution time: 37_245_000 picoseconds.
+		Weight::from_parts(38_383_000, 3643)
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+}
diff --git a/substrate/frame/utility/Cargo.toml b/substrate/frame/utility/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..76eafeb2db57b25f207085ef27a239df92c6de6d
--- /dev/null
+++ b/substrate/frame/utility/Cargo.toml
@@ -0,0 +1,67 @@
+[package]
+name = "pallet-utility"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME utilities pallet"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-root-testing = { version = "1.0.0-dev", path = "../root-testing" }
+pallet-collective = { version = "4.0.0-dev", path = "../collective" }
+pallet-timestamp = { version = "4.0.0-dev", path = "../timestamp" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-collective/std",
+	"pallet-root-testing/std",
+	"pallet-timestamp/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-collective/runtime-benchmarks",
+	"pallet-timestamp/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-collective/try-runtime",
+	"pallet-root-testing/try-runtime",
+	"pallet-timestamp/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/utility/README.md b/substrate/frame/utility/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..db19b0cf8cf9ed28b23f043b44be3da4e6a1dbc1
--- /dev/null
+++ b/substrate/frame/utility/README.md
@@ -0,0 +1,38 @@
+# Utility Module
+A stateless module with helpers for dispatch management which does no re-authentication.
+
+- [`utility::Config`](https://docs.rs/pallet-utility/latest/pallet_utility/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-utility/latest/pallet_utility/pallet/enum.Call.html)
+
+## Overview
+
+This module contains two basic pieces of functionality:
+- Batch dispatch: A stateless operation, allowing any origin to execute multiple calls in a
+  single dispatch. This can be useful to amalgamate proposals, combining `set_code` with
+  corresponding `set_storage`s, for efficient multiple payouts with just a single signature
+  verify, or in combination with one of the other two dispatch functionality.
+- Pseudonymal dispatch: A stateless operation, allowing a signed origin to execute a call from
+  an alternative signed origin. Each account has 2 * 2**16 possible "pseudonyms" (alternative
+  account IDs) and these can be stacked. This can be useful as a key management tool, where you
+  need multiple distinct accounts (e.g. as controllers for many staking accounts), but where
+  it's perfectly fine to have each of them controlled by the same underlying keypair.
+  Derivative accounts are, for the purposes of proxy filtering considered exactly the same as
+  the oigin and are thus hampered with the origin's filters.
+
+Since proxy filters are respected in all dispatches of this module, it should never need to be
+filtered by any proxy.
+
+## Interface
+
+### Dispatchable Functions
+
+#### For batch dispatch
+* `batch` - Dispatch multiple calls from the sender's origin.
+
+#### For pseudonymal dispatch
+* `as_derivative` - Dispatch a call from a derivative signed origin.
+
+[`Call`]: ./enum.Call.html
+[`Config`]: ./trait.Config.html
+
+License: Apache-2.0
diff --git a/substrate/frame/utility/src/benchmarking.rs b/substrate/frame/utility/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..78911fd310e857222d5ff46b661838cda79597d9
--- /dev/null
+++ b/substrate/frame/utility/src/benchmarking.rs
@@ -0,0 +1,90 @@
+// 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.
+
+// Benchmarks for Utility Pallet
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller};
+use frame_system::RawOrigin;
+
+const SEED: u32 = 0;
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	frame_system::Pallet::<T>::assert_last_event(generic_event.into());
+}
+
+benchmarks! {
+	where_clause { where <T::RuntimeOrigin as frame_support::traits::OriginTrait>::PalletsOrigin: Clone }
+	batch {
+		let c in 0 .. 1000;
+		let mut calls: Vec<<T as Config>::RuntimeCall> = Vec::new();
+		for i in 0 .. c {
+			let call = frame_system::Call::remark { remark: vec![] }.into();
+			calls.push(call);
+		}
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), calls)
+	verify {
+		assert_last_event::<T>(Event::BatchCompleted.into())
+	}
+
+	as_derivative {
+		let caller = account("caller", SEED, SEED);
+		let call = Box::new(frame_system::Call::remark { remark: vec![] }.into());
+		// 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());
+	}: _(RawOrigin::Signed(caller), SEED as u16, call)
+
+	batch_all {
+		let c in 0 .. 1000;
+		let mut calls: Vec<<T as Config>::RuntimeCall> = Vec::new();
+		for i in 0 .. c {
+			let call = frame_system::Call::remark { remark: vec![] }.into();
+			calls.push(call);
+		}
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), calls)
+	verify {
+		assert_last_event::<T>(Event::BatchCompleted.into())
+	}
+
+	dispatch_as {
+		let caller = account("caller", SEED, SEED);
+		let call = Box::new(frame_system::Call::remark { remark: vec![] }.into());
+		let origin: T::RuntimeOrigin = RawOrigin::Signed(caller).into();
+		let pallets_origin: <T::RuntimeOrigin as frame_support::traits::OriginTrait>::PalletsOrigin = origin.caller().clone();
+		let pallets_origin = Into::<T::PalletsOrigin>::into(pallets_origin);
+	}: _(RawOrigin::Root, Box::new(pallets_origin), call)
+
+	force_batch {
+		let c in 0 .. 1000;
+		let mut calls: Vec<<T as Config>::RuntimeCall> = Vec::new();
+		for i in 0 .. c {
+			let call = frame_system::Call::remark { remark: vec![] }.into();
+			calls.push(call);
+		}
+		let caller = whitelisted_caller();
+	}: _(RawOrigin::Signed(caller), calls)
+	verify {
+		assert_last_event::<T>(Event::BatchCompleted.into())
+	}
+
+	impl_benchmark_test_suite!(Pallet, crate::tests::new_test_ext(), crate::tests::Test);
+}
diff --git a/substrate/frame/utility/src/lib.rs b/substrate/frame/utility/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..af212a31eb9713a651ac9d40c44c582ffc3c1a8e
--- /dev/null
+++ b/substrate/frame/utility/src/lib.rs
@@ -0,0 +1,510 @@
+// 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.
+
+//! # Utility Pallet
+//! A stateless pallet with helpers for dispatch management which does no re-authentication.
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! This pallet contains two basic pieces of functionality:
+//! - Batch dispatch: A stateless operation, allowing any origin to execute multiple calls in a
+//!   single dispatch. This can be useful to amalgamate proposals, combining `set_code` with
+//!   corresponding `set_storage`s, for efficient multiple payouts with just a single signature
+//!   verify, or in combination with one of the other two dispatch functionality.
+//! - Pseudonymal dispatch: A stateless operation, allowing a signed origin to execute a call from
+//!   an alternative signed origin. Each account has 2 * 2**16 possible "pseudonyms" (alternative
+//!   account IDs) and these can be stacked. This can be useful as a key management tool, where you
+//!   need multiple distinct accounts (e.g. as controllers for many staking accounts), but where
+//!   it's perfectly fine to have each of them controlled by the same underlying keypair. Derivative
+//!   accounts are, for the purposes of proxy filtering considered exactly the same as the origin
+//!   and are thus hampered with the origin's filters.
+//!
+//! Since proxy filters are respected in all dispatches of this pallet, it should never need to be
+//! filtered by any proxy.
+//!
+//! ## Interface
+//!
+//! ### Dispatchable Functions
+//!
+//! #### For batch dispatch
+//! * `batch` - Dispatch multiple calls from the sender's origin.
+//!
+//! #### For pseudonymal dispatch
+//! * `as_derivative` - Dispatch a call from a derivative signed origin.
+
+// Ensure we're `no_std` when compiling for Wasm.
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+mod tests;
+pub mod weights;
+
+use codec::{Decode, Encode};
+use frame_support::{
+	dispatch::{extract_actual_weight, GetDispatchInfo, PostDispatchInfo},
+	traits::{IsSubType, OriginTrait, UnfilteredDispatchable},
+};
+use sp_core::TypeId;
+use sp_io::hashing::blake2_256;
+use sp_runtime::traits::{BadOrigin, Dispatchable, TrailingZeroInput};
+use sp_std::prelude::*;
+pub use weights::WeightInfo;
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	/// Configuration trait.
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The overarching call type.
+		type RuntimeCall: Parameter
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ GetDispatchInfo
+			+ From<frame_system::Call<Self>>
+			+ UnfilteredDispatchable<RuntimeOrigin = Self::RuntimeOrigin>
+			+ IsSubType<Call<Self>>
+			+ IsType<<Self as frame_system::Config>::RuntimeCall>;
+
+		/// The caller origin, overarching type of all pallets origins.
+		type PalletsOrigin: Parameter +
+			Into<<Self as frame_system::Config>::RuntimeOrigin> +
+			IsType<<<Self as frame_system::Config>::RuntimeOrigin as frame_support::traits::OriginTrait>::PalletsOrigin>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event {
+		/// Batch of dispatches did not complete fully. Index of first failing dispatch given, as
+		/// well as the error.
+		BatchInterrupted { index: u32, error: DispatchError },
+		/// Batch of dispatches completed fully with no error.
+		BatchCompleted,
+		/// Batch of dispatches completed but has errors.
+		BatchCompletedWithErrors,
+		/// A single item within a Batch of dispatches has completed with no error.
+		ItemCompleted,
+		/// A single item within a Batch of dispatches has completed with error.
+		ItemFailed { error: DispatchError },
+		/// A call was dispatched.
+		DispatchedAs { result: DispatchResult },
+	}
+
+	// Align the call size to 1KB. As we are currently compiling the runtime for native/wasm
+	// the `size_of` of the `Call` can be different. To ensure that this don't leads to
+	// mismatches between native/wasm or to different metadata for the same runtime, we
+	// algin the call size. The value is chosen big enough to hopefully never reach it.
+	const CALL_ALIGN: u32 = 1024;
+
+	#[pallet::extra_constants]
+	impl<T: Config> Pallet<T> {
+		/// The limit on the number of batched calls.
+		fn batched_calls_limit() -> u32 {
+			let allocator_limit = sp_core::MAX_POSSIBLE_ALLOCATION;
+			let call_size = ((sp_std::mem::size_of::<<T as Config>::RuntimeCall>() as u32 +
+				CALL_ALIGN - 1) / CALL_ALIGN) *
+				CALL_ALIGN;
+			// The margin to take into account vec doubling capacity.
+			let margin_factor = 3;
+
+			allocator_limit / margin_factor / call_size
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn integrity_test() {
+			// If you hit this error, you need to try to `Box` big dispatchable parameters.
+			assert!(
+				sp_std::mem::size_of::<<T as Config>::RuntimeCall>() as u32 <= CALL_ALIGN,
+				"Call enum size should be smaller than {} bytes.",
+				CALL_ALIGN,
+			);
+		}
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// Too many calls batched.
+		TooManyCalls,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Send a batch of dispatch calls.
+		///
+		/// May be called from any origin except `None`.
+		///
+		/// - `calls`: The calls to be dispatched from the same origin. The number of call must not
+		///   exceed the constant: `batched_calls_limit` (available in constant metadata).
+		///
+		/// If origin is root then the calls are dispatched without checking origin filter. (This
+		/// includes bypassing `frame_system::Config::BaseCallFilter`).
+		///
+		/// ## Complexity
+		/// - O(C) where C is the number of calls to be batched.
+		///
+		/// This will return `Ok` in all circumstances. To determine the success of the batch, an
+		/// event is deposited. If a call failed and the batch was interrupted, then the
+		/// `BatchInterrupted` event is deposited, along with the number of successful calls made
+		/// and the error of the failed call. If all were successful, then the `BatchCompleted`
+		/// event is deposited.
+		#[pallet::call_index(0)]
+		#[pallet::weight({
+			let dispatch_infos = calls.iter().map(|call| call.get_dispatch_info()).collect::<Vec<_>>();
+			let dispatch_weight = dispatch_infos.iter()
+				.map(|di| di.weight)
+				.fold(Weight::zero(), |total: Weight, weight: Weight| total.saturating_add(weight))
+				.saturating_add(T::WeightInfo::batch(calls.len() as u32));
+			let dispatch_class = {
+				let all_operational = dispatch_infos.iter()
+					.map(|di| di.class)
+					.all(|class| class == DispatchClass::Operational);
+				if all_operational {
+					DispatchClass::Operational
+				} else {
+					DispatchClass::Normal
+				}
+			};
+			(dispatch_weight, dispatch_class)
+		})]
+		pub fn batch(
+			origin: OriginFor<T>,
+			calls: Vec<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			// Do not allow the `None` origin.
+			if ensure_none(origin.clone()).is_ok() {
+				return Err(BadOrigin.into())
+			}
+
+			let is_root = ensure_root(origin.clone()).is_ok();
+			let calls_len = calls.len();
+			ensure!(calls_len <= Self::batched_calls_limit() as usize, Error::<T>::TooManyCalls);
+
+			// Track the actual weight of each of the batch calls.
+			let mut weight = Weight::zero();
+			for (index, call) in calls.into_iter().enumerate() {
+				let info = call.get_dispatch_info();
+				// If origin is root, don't apply any dispatch filters; root can call anything.
+				let result = if is_root {
+					call.dispatch_bypass_filter(origin.clone())
+				} else {
+					call.dispatch(origin.clone())
+				};
+				// Add the weight of this call.
+				weight = weight.saturating_add(extract_actual_weight(&result, &info));
+				if let Err(e) = result {
+					Self::deposit_event(Event::BatchInterrupted {
+						index: index as u32,
+						error: e.error,
+					});
+					// Take the weight of this function itself into account.
+					let base_weight = T::WeightInfo::batch(index.saturating_add(1) as u32);
+					// Return the actual used weight + base_weight of this call.
+					return Ok(Some(base_weight + weight).into())
+				}
+				Self::deposit_event(Event::ItemCompleted);
+			}
+			Self::deposit_event(Event::BatchCompleted);
+			let base_weight = T::WeightInfo::batch(calls_len as u32);
+			Ok(Some(base_weight + weight).into())
+		}
+
+		/// Send a call through an indexed pseudonym of the sender.
+		///
+		/// Filter from origin are passed along. The call will be dispatched with an origin which
+		/// use the same filter as the origin of this call.
+		///
+		/// NOTE: If you need to ensure that any account-based filtering is not honored (i.e.
+		/// because you expect `proxy` to have been used prior in the call stack and you do not want
+		/// the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`
+		/// in the Multisig pallet instead.
+		///
+		/// NOTE: Prior to version *12, this was called `as_limited_sub`.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		#[pallet::call_index(1)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::as_derivative()
+					// AccountData for inner call origin accountdata.
+					.saturating_add(T::DbWeight::get().reads_writes(1, 1))
+					.saturating_add(dispatch_info.weight),
+				dispatch_info.class,
+			)
+		})]
+		pub fn as_derivative(
+			origin: OriginFor<T>,
+			index: u16,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			let mut origin = origin;
+			let who = ensure_signed(origin.clone())?;
+			let pseudonym = Self::derivative_account_id(who, index);
+			origin.set_caller_from(frame_system::RawOrigin::Signed(pseudonym));
+			let info = call.get_dispatch_info();
+			let result = call.dispatch(origin);
+			// Always take into account the base weight of this call.
+			let mut weight = T::WeightInfo::as_derivative()
+				.saturating_add(T::DbWeight::get().reads_writes(1, 1));
+			// Add the real weight of the dispatch.
+			weight = weight.saturating_add(extract_actual_weight(&result, &info));
+			result
+				.map_err(|mut err| {
+					err.post_info = Some(weight).into();
+					err
+				})
+				.map(|_| Some(weight).into())
+		}
+
+		/// Send a batch of dispatch calls and atomically execute them.
+		/// The whole transaction will rollback and fail if any of the calls failed.
+		///
+		/// May be called from any origin except `None`.
+		///
+		/// - `calls`: The calls to be dispatched from the same origin. The number of call must not
+		///   exceed the constant: `batched_calls_limit` (available in constant metadata).
+		///
+		/// If origin is root then the calls are dispatched without checking origin filter. (This
+		/// includes bypassing `frame_system::Config::BaseCallFilter`).
+		///
+		/// ## Complexity
+		/// - O(C) where C is the number of calls to be batched.
+		#[pallet::call_index(2)]
+		#[pallet::weight({
+			let dispatch_infos = calls.iter().map(|call| call.get_dispatch_info()).collect::<Vec<_>>();
+			let dispatch_weight = dispatch_infos.iter()
+				.map(|di| di.weight)
+				.fold(Weight::zero(), |total: Weight, weight: Weight| total.saturating_add(weight))
+				.saturating_add(T::WeightInfo::batch_all(calls.len() as u32));
+			let dispatch_class = {
+				let all_operational = dispatch_infos.iter()
+					.map(|di| di.class)
+					.all(|class| class == DispatchClass::Operational);
+				if all_operational {
+					DispatchClass::Operational
+				} else {
+					DispatchClass::Normal
+				}
+			};
+			(dispatch_weight, dispatch_class)
+		})]
+		pub fn batch_all(
+			origin: OriginFor<T>,
+			calls: Vec<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			// Do not allow the `None` origin.
+			if ensure_none(origin.clone()).is_ok() {
+				return Err(BadOrigin.into())
+			}
+
+			let is_root = ensure_root(origin.clone()).is_ok();
+			let calls_len = calls.len();
+			ensure!(calls_len <= Self::batched_calls_limit() as usize, Error::<T>::TooManyCalls);
+
+			// Track the actual weight of each of the batch calls.
+			let mut weight = Weight::zero();
+			for (index, call) in calls.into_iter().enumerate() {
+				let info = call.get_dispatch_info();
+				// If origin is root, bypass any dispatch filter; root can call anything.
+				let result = if is_root {
+					call.dispatch_bypass_filter(origin.clone())
+				} else {
+					let mut filtered_origin = origin.clone();
+					// Don't allow users to nest `batch_all` calls.
+					filtered_origin.add_filter(
+						move |c: &<T as frame_system::Config>::RuntimeCall| {
+							let c = <T as Config>::RuntimeCall::from_ref(c);
+							!matches!(c.is_sub_type(), Some(Call::batch_all { .. }))
+						},
+					);
+					call.dispatch(filtered_origin)
+				};
+				// Add the weight of this call.
+				weight = weight.saturating_add(extract_actual_weight(&result, &info));
+				result.map_err(|mut err| {
+					// Take the weight of this function itself into account.
+					let base_weight = T::WeightInfo::batch_all(index.saturating_add(1) as u32);
+					// Return the actual used weight + base_weight of this call.
+					err.post_info = Some(base_weight + weight).into();
+					err
+				})?;
+				Self::deposit_event(Event::ItemCompleted);
+			}
+			Self::deposit_event(Event::BatchCompleted);
+			let base_weight = T::WeightInfo::batch_all(calls_len as u32);
+			Ok(Some(base_weight.saturating_add(weight)).into())
+		}
+
+		/// Dispatches a function call with a provided origin.
+		///
+		/// The dispatch origin for this call must be _Root_.
+		///
+		/// ## Complexity
+		/// - O(1).
+		#[pallet::call_index(3)]
+		#[pallet::weight({
+			let dispatch_info = call.get_dispatch_info();
+			(
+				T::WeightInfo::dispatch_as()
+					.saturating_add(dispatch_info.weight),
+				dispatch_info.class,
+			)
+		})]
+		pub fn dispatch_as(
+			origin: OriginFor<T>,
+			as_origin: Box<T::PalletsOrigin>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			let res = call.dispatch_bypass_filter((*as_origin).into());
+
+			Self::deposit_event(Event::DispatchedAs {
+				result: res.map(|_| ()).map_err(|e| e.error),
+			});
+			Ok(())
+		}
+
+		/// Send a batch of dispatch calls.
+		/// Unlike `batch`, it allows errors and won't interrupt.
+		///
+		/// May be called from any origin except `None`.
+		///
+		/// - `calls`: The calls to be dispatched from the same origin. The number of call must not
+		///   exceed the constant: `batched_calls_limit` (available in constant metadata).
+		///
+		/// If origin is root then the calls are dispatch without checking origin filter. (This
+		/// includes bypassing `frame_system::Config::BaseCallFilter`).
+		///
+		/// ## Complexity
+		/// - O(C) where C is the number of calls to be batched.
+		#[pallet::call_index(4)]
+		#[pallet::weight({
+			let dispatch_infos = calls.iter().map(|call| call.get_dispatch_info()).collect::<Vec<_>>();
+			let dispatch_weight = dispatch_infos.iter()
+				.map(|di| di.weight)
+				.fold(Weight::zero(), |total: Weight, weight: Weight| total.saturating_add(weight))
+				.saturating_add(T::WeightInfo::force_batch(calls.len() as u32));
+			let dispatch_class = {
+				let all_operational = dispatch_infos.iter()
+					.map(|di| di.class)
+					.all(|class| class == DispatchClass::Operational);
+				if all_operational {
+					DispatchClass::Operational
+				} else {
+					DispatchClass::Normal
+				}
+			};
+			(dispatch_weight, dispatch_class)
+		})]
+		pub fn force_batch(
+			origin: OriginFor<T>,
+			calls: Vec<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			// Do not allow the `None` origin.
+			if ensure_none(origin.clone()).is_ok() {
+				return Err(BadOrigin.into())
+			}
+
+			let is_root = ensure_root(origin.clone()).is_ok();
+			let calls_len = calls.len();
+			ensure!(calls_len <= Self::batched_calls_limit() as usize, Error::<T>::TooManyCalls);
+
+			// Track the actual weight of each of the batch calls.
+			let mut weight = Weight::zero();
+			// Track failed dispatch occur.
+			let mut has_error: bool = false;
+			for call in calls.into_iter() {
+				let info = call.get_dispatch_info();
+				// If origin is root, don't apply any dispatch filters; root can call anything.
+				let result = if is_root {
+					call.dispatch_bypass_filter(origin.clone())
+				} else {
+					call.dispatch(origin.clone())
+				};
+				// Add the weight of this call.
+				weight = weight.saturating_add(extract_actual_weight(&result, &info));
+				if let Err(e) = result {
+					has_error = true;
+					Self::deposit_event(Event::ItemFailed { error: e.error });
+				} else {
+					Self::deposit_event(Event::ItemCompleted);
+				}
+			}
+			if has_error {
+				Self::deposit_event(Event::BatchCompletedWithErrors);
+			} else {
+				Self::deposit_event(Event::BatchCompleted);
+			}
+			let base_weight = T::WeightInfo::batch(calls_len as u32);
+			Ok(Some(base_weight.saturating_add(weight)).into())
+		}
+
+		/// Dispatch a function call with a specified weight.
+		///
+		/// This function does not check the weight of the call, and instead allows the
+		/// Root origin to specify the weight of the call.
+		///
+		/// The dispatch origin for this call must be _Root_.
+		#[pallet::call_index(5)]
+		#[pallet::weight((*_weight, call.get_dispatch_info().class))]
+		pub fn with_weight(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+			_weight: Weight,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			let res = call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into());
+			res.map(|_| ()).map_err(|e| e.error)
+		}
+	}
+}
+
+/// A pallet identifier. These are per pallet and should be stored in a registry somewhere.
+#[derive(Clone, Copy, Eq, PartialEq, Encode, Decode)]
+struct IndexedUtilityPalletId(u16);
+
+impl TypeId for IndexedUtilityPalletId {
+	const TYPE_ID: [u8; 4] = *b"suba";
+}
+
+impl<T: Config> Pallet<T> {
+	/// Derive a derivative account ID from the owner account and the sub-account index.
+	pub fn derivative_account_id(who: T::AccountId, index: u16) -> T::AccountId {
+		let entropy = (b"modlpy/utilisuba", who, index).using_encoded(blake2_256);
+		Decode::decode(&mut TrailingZeroInput::new(entropy.as_ref()))
+			.expect("infinite length input; no invalid inputs for type; qed")
+	}
+}
diff --git a/substrate/frame/utility/src/tests.rs b/substrate/frame/utility/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c2fd3a851c3197476a4da10c5c6e24386d9decdf
--- /dev/null
+++ b/substrate/frame/utility/src/tests.rs
@@ -0,0 +1,939 @@
+// 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 Utility Pallet
+
+#![cfg(test)]
+
+use super::*;
+
+use crate as utility;
+use frame_support::{
+	assert_err_ignore_postinfo, assert_noop, assert_ok,
+	dispatch::{DispatchError, DispatchErrorWithPostInfo, Dispatchable, Pays},
+	error::BadOrigin,
+	parameter_types, storage,
+	traits::{ConstU32, ConstU64, Contains},
+	weights::Weight,
+};
+use pallet_collective::{EnsureProportionAtLeast, Instance1};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, Hash, IdentityLookup},
+	BuildStorage, TokenError,
+};
+
+type BlockNumber = u64;
+
+// example module to test behaviors.
+#[frame_support::pallet(dev_mode)]
+pub mod example {
+	use frame_support::{dispatch::WithPostDispatchInfo, pallet_prelude::*};
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight(*_weight)]
+		pub fn noop(_origin: OriginFor<T>, _weight: Weight) -> DispatchResult {
+			Ok(())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight(*_start_weight)]
+		pub fn foobar(
+			origin: OriginFor<T>,
+			err: bool,
+			_start_weight: Weight,
+			end_weight: Option<Weight>,
+		) -> DispatchResultWithPostInfo {
+			let _ = ensure_signed(origin)?;
+			if err {
+				let error: DispatchError = "The cake is a lie.".into();
+				if let Some(weight) = end_weight {
+					Err(error.with_weight(weight))
+				} else {
+					Err(error)?
+				}
+			} else {
+				Ok(end_weight.into())
+			}
+		}
+
+		#[pallet::call_index(2)]
+		#[pallet::weight(0)]
+		pub fn big_variant(_origin: OriginFor<T>, _arg: [u8; 400]) -> DispatchResult {
+			Ok(())
+		}
+	}
+}
+
+mod mock_democracy {
+	pub use pallet::*;
+	#[frame_support::pallet(dev_mode)]
+	pub mod pallet {
+		use frame_support::pallet_prelude::*;
+		use frame_system::pallet_prelude::*;
+
+		#[pallet::pallet]
+		pub struct Pallet<T>(_);
+
+		#[pallet::config]
+		pub trait Config: frame_system::Config + Sized {
+			type RuntimeEvent: From<Event<Self>>
+				+ IsType<<Self as frame_system::Config>::RuntimeEvent>;
+			type ExternalMajorityOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+		}
+
+		#[pallet::call]
+		impl<T: Config> Pallet<T> {
+			#[pallet::call_index(3)]
+			#[pallet::weight(0)]
+			pub fn external_propose_majority(origin: OriginFor<T>) -> DispatchResult {
+				T::ExternalMajorityOrigin::ensure_origin(origin)?;
+				Self::deposit_event(Event::<T>::ExternalProposed);
+				Ok(())
+			}
+		}
+
+		#[pallet::event]
+		#[pallet::generate_deposit(pub(super) fn deposit_event)]
+		pub enum Event<T: Config> {
+			ExternalProposed,
+		}
+	}
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Timestamp: pallet_timestamp::{Call, Inherent},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		RootTesting: pallet_root_testing::{Pallet, Call, Storage},
+		Council: pallet_collective::<Instance1>,
+		Utility: utility::{Pallet, Call, Event},
+		Example: example::{Pallet, Call},
+		Democracy: mock_democracy::{Pallet, Call, Event<T>},
+	}
+);
+
+parameter_types! {
+	pub BlockWeights: frame_system::limits::BlockWeights =
+		frame_system::limits::BlockWeights::simple_max(Weight::MAX);
+}
+impl frame_system::Config for Test {
+	type BaseCallFilter = TestBaseCallFilter;
+	type BlockWeights = BlockWeights;
+	type BlockLength = ();
+	type DbWeight = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	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 = frame_system::weights::SubstrateWeight<Test>;
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+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 MaxHolds = ();
+}
+
+impl pallet_root_testing::Config for Test {}
+
+impl pallet_timestamp::Config for Test {
+	type Moment = u64;
+	type OnTimestampSet = ();
+	type MinimumPeriod = ConstU64<3>;
+	type WeightInfo = ();
+}
+
+const MOTION_DURATION_IN_BLOCKS: BlockNumber = 3;
+parameter_types! {
+	pub const MultisigDepositBase: u64 = 1;
+	pub const MultisigDepositFactor: u64 = 1;
+	pub const MaxSignatories: u32 = 3;
+	pub const MotionDuration: BlockNumber = MOTION_DURATION_IN_BLOCKS;
+	pub const MaxProposals: u32 = 100;
+	pub const MaxMembers: u32 = 100;
+	pub MaxProposalWeight: Weight = sp_runtime::Perbill::from_percent(50) * BlockWeights::get().max_block;
+}
+
+type CouncilCollective = pallet_collective::Instance1;
+impl pallet_collective::Config<CouncilCollective> for Test {
+	type RuntimeOrigin = RuntimeOrigin;
+	type Proposal = RuntimeCall;
+	type RuntimeEvent = RuntimeEvent;
+	type MotionDuration = MotionDuration;
+	type MaxProposals = MaxProposals;
+	type MaxMembers = MaxMembers;
+	type DefaultVote = pallet_collective::PrimeDefaultVote;
+	type WeightInfo = ();
+	type SetMembersOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type MaxProposalWeight = MaxProposalWeight;
+}
+
+impl example::Config for Test {}
+
+pub struct TestBaseCallFilter;
+impl Contains<RuntimeCall> for TestBaseCallFilter {
+	fn contains(c: &RuntimeCall) -> bool {
+		match *c {
+			// Transfer works. Use `transfer_keep_alive` for a call that doesn't pass the filter.
+			RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death { .. }) => true,
+			RuntimeCall::Utility(_) => true,
+			// For benchmarking, this acts as a noop call
+			RuntimeCall::System(frame_system::Call::remark { .. }) => true,
+			// For tests
+			RuntimeCall::Example(_) => true,
+			// For council origin tests.
+			RuntimeCall::Democracy(_) => true,
+			_ => false,
+		}
+	}
+}
+impl mock_democracy::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type ExternalMajorityOrigin = EnsureProportionAtLeast<u64, Instance1, 3, 4>;
+}
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type PalletsOrigin = OriginCaller;
+	type WeightInfo = ();
+}
+
+type ExampleCall = example::Call<Test>;
+type UtilityCall = crate::Call<Test>;
+
+use frame_system::Call as SystemCall;
+use pallet_balances::Call as BalancesCall;
+use pallet_root_testing::Call as RootTestingCall;
+use pallet_timestamp::Call as TimestampCall;
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10), (2, 10), (3, 10), (4, 10), (5, 2)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	pallet_collective::GenesisConfig::<Test, Instance1> {
+		members: vec![1, 2, 3],
+		phantom: Default::default(),
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
+
+fn call_transfer(dest: u64, value: u64) -> RuntimeCall {
+	RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest, value })
+}
+
+fn call_foobar(err: bool, start_weight: Weight, end_weight: Option<Weight>) -> RuntimeCall {
+	RuntimeCall::Example(ExampleCall::foobar { err, start_weight, end_weight })
+}
+
+#[test]
+fn as_derivative_works() {
+	new_test_ext().execute_with(|| {
+		let sub_1_0 = Utility::derivative_account_id(1, 0);
+		assert_ok!(Balances::transfer_allow_death(RuntimeOrigin::signed(1), sub_1_0, 5));
+		assert_err_ignore_postinfo!(
+			Utility::as_derivative(RuntimeOrigin::signed(1), 1, Box::new(call_transfer(6, 3)),),
+			TokenError::FundsUnavailable,
+		);
+		assert_ok!(Utility::as_derivative(
+			RuntimeOrigin::signed(1),
+			0,
+			Box::new(call_transfer(2, 3)),
+		));
+		assert_eq!(Balances::free_balance(sub_1_0), 2);
+		assert_eq!(Balances::free_balance(2), 13);
+	});
+}
+
+#[test]
+fn as_derivative_handles_weight_refund() {
+	new_test_ext().execute_with(|| {
+		let start_weight = Weight::from_parts(100, 0);
+		let end_weight = Weight::from_parts(75, 0);
+		let diff = start_weight - end_weight;
+
+		// Full weight when ok
+		let inner_call = call_foobar(false, start_weight, None);
+		let call = RuntimeCall::Utility(UtilityCall::as_derivative {
+			index: 0,
+			call: Box::new(inner_call),
+		});
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		assert_eq!(extract_actual_weight(&result, &info), info.weight);
+
+		// Refund weight when ok
+		let inner_call = call_foobar(false, start_weight, Some(end_weight));
+		let call = RuntimeCall::Utility(UtilityCall::as_derivative {
+			index: 0,
+			call: Box::new(inner_call),
+		});
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		// Diff is refunded
+		assert_eq!(extract_actual_weight(&result, &info), info.weight - diff);
+
+		// Full weight when err
+		let inner_call = call_foobar(true, start_weight, None);
+		let call = RuntimeCall::Utility(UtilityCall::as_derivative {
+			index: 0,
+			call: Box::new(inner_call),
+		});
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_noop!(
+			result,
+			DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					// No weight is refunded
+					actual_weight: Some(info.weight),
+					pays_fee: Pays::Yes,
+				},
+				error: DispatchError::Other("The cake is a lie."),
+			}
+		);
+
+		// Refund weight when err
+		let inner_call = call_foobar(true, start_weight, Some(end_weight));
+		let call = RuntimeCall::Utility(UtilityCall::as_derivative {
+			index: 0,
+			call: Box::new(inner_call),
+		});
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_noop!(
+			result,
+			DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					// Diff is refunded
+					actual_weight: Some(info.weight - diff),
+					pays_fee: Pays::Yes,
+				},
+				error: DispatchError::Other("The cake is a lie."),
+			}
+		);
+	});
+}
+
+#[test]
+fn as_derivative_filters() {
+	new_test_ext().execute_with(|| {
+		assert_err_ignore_postinfo!(
+			Utility::as_derivative(
+				RuntimeOrigin::signed(1),
+				1,
+				Box::new(RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive {
+					dest: 2,
+					value: 1
+				})),
+			),
+			DispatchError::from(frame_system::Error::<Test>::CallFiltered),
+		);
+	});
+}
+
+#[test]
+fn batch_with_root_works() {
+	new_test_ext().execute_with(|| {
+		let k = b"a".to_vec();
+		let call = RuntimeCall::System(frame_system::Call::set_storage {
+			items: vec![(k.clone(), k.clone())],
+		});
+		assert!(!TestBaseCallFilter::contains(&call));
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::batch(
+			RuntimeOrigin::root(),
+			vec![
+				RuntimeCall::Balances(BalancesCall::force_transfer {
+					source: 1,
+					dest: 2,
+					value: 5
+				}),
+				RuntimeCall::Balances(BalancesCall::force_transfer {
+					source: 1,
+					dest: 2,
+					value: 5
+				}),
+				call, // Check filters are correctly bypassed
+			]
+		));
+		assert_eq!(Balances::free_balance(1), 0);
+		assert_eq!(Balances::free_balance(2), 20);
+		assert_eq!(storage::unhashed::get_raw(&k), Some(k));
+	});
+}
+
+#[test]
+fn batch_with_signed_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::batch(
+			RuntimeOrigin::signed(1),
+			vec![call_transfer(2, 5), call_transfer(2, 5)]
+		),);
+		assert_eq!(Balances::free_balance(1), 0);
+		assert_eq!(Balances::free_balance(2), 20);
+	});
+}
+
+#[test]
+fn batch_with_signed_filters() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Utility::batch(
+			RuntimeOrigin::signed(1),
+			vec![RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive {
+				dest: 2,
+				value: 1
+			})]
+		),);
+		System::assert_last_event(
+			utility::Event::BatchInterrupted {
+				index: 0,
+				error: frame_system::Error::<Test>::CallFiltered.into(),
+			}
+			.into(),
+		);
+	});
+}
+
+#[test]
+fn batch_early_exit_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::batch(
+			RuntimeOrigin::signed(1),
+			vec![call_transfer(2, 5), call_transfer(2, 10), call_transfer(2, 5),]
+		),);
+		assert_eq!(Balances::free_balance(1), 5);
+		assert_eq!(Balances::free_balance(2), 15);
+	});
+}
+
+#[test]
+fn batch_weight_calculation_doesnt_overflow() {
+	use sp_runtime::Perbill;
+	new_test_ext().execute_with(|| {
+		let big_call = RuntimeCall::RootTesting(RootTestingCall::fill_block {
+			ratio: Perbill::from_percent(50),
+		});
+		assert_eq!(big_call.get_dispatch_info().weight, Weight::MAX / 2);
+
+		// 3 * 50% saturates to 100%
+		let batch_call = RuntimeCall::Utility(crate::Call::batch {
+			calls: vec![big_call.clone(), big_call.clone(), big_call.clone()],
+		});
+
+		assert_eq!(batch_call.get_dispatch_info().weight, Weight::MAX);
+	});
+}
+
+#[test]
+fn batch_handles_weight_refund() {
+	new_test_ext().execute_with(|| {
+		let start_weight = Weight::from_parts(100, 0);
+		let end_weight = Weight::from_parts(75, 0);
+		let diff = start_weight - end_weight;
+		let batch_len = 4;
+
+		// Full weight when ok
+		let inner_call = call_foobar(false, start_weight, None);
+		let batch_calls = vec![inner_call; batch_len as usize];
+		let call = RuntimeCall::Utility(UtilityCall::batch { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		assert_eq!(extract_actual_weight(&result, &info), info.weight);
+
+		// Refund weight when ok
+		let inner_call = call_foobar(false, start_weight, Some(end_weight));
+		let batch_calls = vec![inner_call; batch_len as usize];
+		let call = RuntimeCall::Utility(UtilityCall::batch { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		// Diff is refunded
+		assert_eq!(extract_actual_weight(&result, &info), info.weight - diff * batch_len);
+
+		// Full weight when err
+		let good_call = call_foobar(false, start_weight, None);
+		let bad_call = call_foobar(true, start_weight, None);
+		let batch_calls = vec![good_call, bad_call];
+		let call = RuntimeCall::Utility(UtilityCall::batch { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		System::assert_last_event(
+			utility::Event::BatchInterrupted { index: 1, error: DispatchError::Other("") }.into(),
+		);
+		// No weight is refunded
+		assert_eq!(extract_actual_weight(&result, &info), info.weight);
+
+		// Refund weight when err
+		let good_call = call_foobar(false, start_weight, Some(end_weight));
+		let bad_call = call_foobar(true, start_weight, Some(end_weight));
+		let batch_calls = vec![good_call, bad_call];
+		let batch_len = batch_calls.len() as u64;
+		let call = RuntimeCall::Utility(UtilityCall::batch { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		System::assert_last_event(
+			utility::Event::BatchInterrupted { index: 1, error: DispatchError::Other("") }.into(),
+		);
+		assert_eq!(extract_actual_weight(&result, &info), info.weight - diff * batch_len);
+
+		// Partial batch completion
+		let good_call = call_foobar(false, start_weight, Some(end_weight));
+		let bad_call = call_foobar(true, start_weight, Some(end_weight));
+		let batch_calls = vec![good_call, bad_call.clone(), bad_call];
+		let call = RuntimeCall::Utility(UtilityCall::batch { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		System::assert_last_event(
+			utility::Event::BatchInterrupted { index: 1, error: DispatchError::Other("") }.into(),
+		);
+		assert_eq!(
+			extract_actual_weight(&result, &info),
+			// Real weight is 2 calls at end_weight
+			<Test as Config>::WeightInfo::batch(2) + end_weight * 2,
+		);
+	});
+}
+
+#[test]
+fn batch_all_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::batch_all(
+			RuntimeOrigin::signed(1),
+			vec![call_transfer(2, 5), call_transfer(2, 5)]
+		),);
+		assert_eq!(Balances::free_balance(1), 0);
+		assert_eq!(Balances::free_balance(2), 20);
+	});
+}
+
+#[test]
+fn batch_all_revert() {
+	new_test_ext().execute_with(|| {
+		let call = call_transfer(2, 5);
+		let info = call.get_dispatch_info();
+
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		let batch_all_calls = RuntimeCall::Utility(crate::Call::<Test>::batch_all {
+			calls: vec![call_transfer(2, 5), call_transfer(2, 10), call_transfer(2, 5)],
+		});
+		assert_noop!(
+			batch_all_calls.dispatch(RuntimeOrigin::signed(1)),
+			DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					actual_weight: Some(
+						<Test as Config>::WeightInfo::batch_all(2) + info.weight * 2
+					),
+					pays_fee: Pays::Yes
+				},
+				error: TokenError::FundsUnavailable.into(),
+			}
+		);
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+	});
+}
+
+#[test]
+fn batch_all_handles_weight_refund() {
+	new_test_ext().execute_with(|| {
+		let start_weight = Weight::from_parts(100, 0);
+		let end_weight = Weight::from_parts(75, 0);
+		let diff = start_weight - end_weight;
+		let batch_len = 4;
+
+		// Full weight when ok
+		let inner_call = call_foobar(false, start_weight, None);
+		let batch_calls = vec![inner_call; batch_len as usize];
+		let call = RuntimeCall::Utility(UtilityCall::batch_all { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		assert_eq!(extract_actual_weight(&result, &info), info.weight);
+
+		// Refund weight when ok
+		let inner_call = call_foobar(false, start_weight, Some(end_weight));
+		let batch_calls = vec![inner_call; batch_len as usize];
+		let call = RuntimeCall::Utility(UtilityCall::batch_all { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_ok!(result);
+		// Diff is refunded
+		assert_eq!(extract_actual_weight(&result, &info), info.weight - diff * batch_len);
+
+		// Full weight when err
+		let good_call = call_foobar(false, start_weight, None);
+		let bad_call = call_foobar(true, start_weight, None);
+		let batch_calls = vec![good_call, bad_call];
+		let call = RuntimeCall::Utility(UtilityCall::batch_all { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_err_ignore_postinfo!(result, "The cake is a lie.");
+		// No weight is refunded
+		assert_eq!(extract_actual_weight(&result, &info), info.weight);
+
+		// Refund weight when err
+		let good_call = call_foobar(false, start_weight, Some(end_weight));
+		let bad_call = call_foobar(true, start_weight, Some(end_weight));
+		let batch_calls = vec![good_call, bad_call];
+		let batch_len = batch_calls.len() as u64;
+		let call = RuntimeCall::Utility(UtilityCall::batch_all { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_err_ignore_postinfo!(result, "The cake is a lie.");
+		assert_eq!(extract_actual_weight(&result, &info), info.weight - diff * batch_len);
+
+		// Partial batch completion
+		let good_call = call_foobar(false, start_weight, Some(end_weight));
+		let bad_call = call_foobar(true, start_weight, Some(end_weight));
+		let batch_calls = vec![good_call, bad_call.clone(), bad_call];
+		let call = RuntimeCall::Utility(UtilityCall::batch_all { calls: batch_calls });
+		let info = call.get_dispatch_info();
+		let result = call.dispatch(RuntimeOrigin::signed(1));
+		assert_err_ignore_postinfo!(result, "The cake is a lie.");
+		assert_eq!(
+			extract_actual_weight(&result, &info),
+			// Real weight is 2 calls at end_weight
+			<Test as Config>::WeightInfo::batch_all(2) + end_weight * 2,
+		);
+	});
+}
+
+#[test]
+fn batch_all_does_not_nest() {
+	new_test_ext().execute_with(|| {
+		let batch_all = RuntimeCall::Utility(UtilityCall::batch_all {
+			calls: vec![call_transfer(2, 1), call_transfer(2, 1), call_transfer(2, 1)],
+		});
+
+		let info = batch_all.get_dispatch_info();
+
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		// A nested batch_all call will not pass the filter, and fail with `BadOrigin`.
+		assert_noop!(
+			Utility::batch_all(RuntimeOrigin::signed(1), vec![batch_all.clone()]),
+			DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					actual_weight: Some(<Test as Config>::WeightInfo::batch_all(1) + info.weight),
+					pays_fee: Pays::Yes
+				},
+				error: frame_system::Error::<Test>::CallFiltered.into(),
+			}
+		);
+
+		// And for those who want to get a little fancy, we check that the filter persists across
+		// other kinds of dispatch wrapping functions... in this case
+		// `batch_all(batch(batch_all(..)))`
+		let batch_nested = RuntimeCall::Utility(UtilityCall::batch { calls: vec![batch_all] });
+		// Batch will end with `Ok`, but does not actually execute as we can see from the event
+		// and balances.
+		assert_ok!(Utility::batch_all(RuntimeOrigin::signed(1), vec![batch_nested]));
+		System::assert_has_event(
+			utility::Event::BatchInterrupted {
+				index: 0,
+				error: frame_system::Error::<Test>::CallFiltered.into(),
+			}
+			.into(),
+		);
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+	});
+}
+
+#[test]
+fn batch_limit() {
+	new_test_ext().execute_with(|| {
+		let calls = vec![RuntimeCall::System(SystemCall::remark { remark: vec![] }); 40_000];
+		assert_noop!(
+			Utility::batch(RuntimeOrigin::signed(1), calls.clone()),
+			Error::<Test>::TooManyCalls
+		);
+		assert_noop!(
+			Utility::batch_all(RuntimeOrigin::signed(1), calls),
+			Error::<Test>::TooManyCalls
+		);
+	});
+}
+
+#[test]
+fn force_batch_works() {
+	new_test_ext().execute_with(|| {
+		assert_eq!(Balances::free_balance(1), 10);
+		assert_eq!(Balances::free_balance(2), 10);
+		assert_ok!(Utility::force_batch(
+			RuntimeOrigin::signed(1),
+			vec![
+				call_transfer(2, 5),
+				call_foobar(true, Weight::from_parts(75, 0), None),
+				call_transfer(2, 10),
+				call_transfer(2, 5),
+			]
+		));
+		System::assert_last_event(utility::Event::BatchCompletedWithErrors.into());
+		System::assert_has_event(
+			utility::Event::ItemFailed { error: DispatchError::Other("") }.into(),
+		);
+		assert_eq!(Balances::free_balance(1), 0);
+		assert_eq!(Balances::free_balance(2), 20);
+
+		assert_ok!(Utility::force_batch(
+			RuntimeOrigin::signed(2),
+			vec![call_transfer(1, 5), call_transfer(1, 5),]
+		));
+		System::assert_last_event(utility::Event::BatchCompleted.into());
+
+		assert_ok!(Utility::force_batch(RuntimeOrigin::signed(1), vec![call_transfer(2, 50),]),);
+		System::assert_last_event(utility::Event::BatchCompletedWithErrors.into());
+	});
+}
+
+#[test]
+fn none_origin_does_not_work() {
+	new_test_ext().execute_with(|| {
+		assert_noop!(Utility::force_batch(RuntimeOrigin::none(), vec![]), BadOrigin);
+		assert_noop!(Utility::batch(RuntimeOrigin::none(), vec![]), BadOrigin);
+		assert_noop!(Utility::batch_all(RuntimeOrigin::none(), vec![]), BadOrigin);
+	})
+}
+
+#[test]
+fn batch_doesnt_work_with_inherents() {
+	new_test_ext().execute_with(|| {
+		// fails because inherents expect the origin to be none.
+		assert_ok!(Utility::batch(
+			RuntimeOrigin::signed(1),
+			vec![RuntimeCall::Timestamp(TimestampCall::set { now: 42 }),]
+		));
+		System::assert_last_event(
+			utility::Event::BatchInterrupted {
+				index: 0,
+				error: frame_system::Error::<Test>::CallFiltered.into(),
+			}
+			.into(),
+		);
+	})
+}
+
+#[test]
+fn force_batch_doesnt_work_with_inherents() {
+	new_test_ext().execute_with(|| {
+		// fails because inherents expect the origin to be none.
+		assert_ok!(Utility::force_batch(
+			RuntimeOrigin::root(),
+			vec![RuntimeCall::Timestamp(TimestampCall::set { now: 42 }),]
+		));
+		System::assert_last_event(utility::Event::BatchCompletedWithErrors.into());
+	})
+}
+
+#[test]
+fn batch_all_doesnt_work_with_inherents() {
+	new_test_ext().execute_with(|| {
+		let batch_all = RuntimeCall::Utility(UtilityCall::batch_all {
+			calls: vec![RuntimeCall::Timestamp(TimestampCall::set { now: 42 })],
+		});
+		let info = batch_all.get_dispatch_info();
+
+		// fails because inherents expect the origin to be none.
+		assert_noop!(
+			batch_all.dispatch(RuntimeOrigin::signed(1)),
+			DispatchErrorWithPostInfo {
+				post_info: PostDispatchInfo {
+					actual_weight: Some(info.weight),
+					pays_fee: Pays::Yes
+				},
+				error: frame_system::Error::<Test>::CallFiltered.into(),
+			}
+		);
+	})
+}
+
+#[test]
+fn batch_works_with_council_origin() {
+	new_test_ext().execute_with(|| {
+		let proposal = RuntimeCall::Utility(UtilityCall::batch {
+			calls: vec![RuntimeCall::Democracy(mock_democracy::Call::external_propose_majority {})],
+		});
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+
+		assert_ok!(Council::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+
+		assert_ok!(Council::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Council::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_ok!(Council::vote(RuntimeOrigin::signed(3), hash, 0, true));
+
+		System::set_block_number(4);
+		assert_ok!(Council::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		System::assert_last_event(RuntimeEvent::Council(pallet_collective::Event::Executed {
+			proposal_hash: hash,
+			result: Ok(()),
+		}));
+	})
+}
+
+#[test]
+fn force_batch_works_with_council_origin() {
+	new_test_ext().execute_with(|| {
+		let proposal = RuntimeCall::Utility(UtilityCall::force_batch {
+			calls: vec![RuntimeCall::Democracy(mock_democracy::Call::external_propose_majority {})],
+		});
+		let proposal_len: u32 = proposal.using_encoded(|p| p.len() as u32);
+		let proposal_weight = proposal.get_dispatch_info().weight;
+		let hash = BlakeTwo256::hash_of(&proposal);
+
+		assert_ok!(Council::propose(
+			RuntimeOrigin::signed(1),
+			3,
+			Box::new(proposal.clone()),
+			proposal_len
+		));
+
+		assert_ok!(Council::vote(RuntimeOrigin::signed(1), hash, 0, true));
+		assert_ok!(Council::vote(RuntimeOrigin::signed(2), hash, 0, true));
+		assert_ok!(Council::vote(RuntimeOrigin::signed(3), hash, 0, true));
+
+		System::set_block_number(4);
+		assert_ok!(Council::close(
+			RuntimeOrigin::signed(4),
+			hash,
+			0,
+			proposal_weight,
+			proposal_len
+		));
+
+		System::assert_last_event(RuntimeEvent::Council(pallet_collective::Event::Executed {
+			proposal_hash: hash,
+			result: Ok(()),
+		}));
+	})
+}
+
+#[test]
+fn batch_all_works_with_council_origin() {
+	new_test_ext().execute_with(|| {
+		assert_ok!(Utility::batch_all(
+			RuntimeOrigin::from(pallet_collective::RawOrigin::Members(3, 3)),
+			vec![RuntimeCall::Democracy(mock_democracy::Call::external_propose_majority {})]
+		));
+	})
+}
+
+#[test]
+fn with_weight_works() {
+	new_test_ext().execute_with(|| {
+		use frame_system::WeightInfo;
+		let upgrade_code_call =
+			Box::new(RuntimeCall::System(frame_system::Call::set_code_without_checks {
+				code: vec![],
+			}));
+		// Weight before is max.
+		assert_eq!(
+			upgrade_code_call.get_dispatch_info().weight,
+			<Test as frame_system::Config>::SystemWeightInfo::set_code()
+		);
+		assert_eq!(
+			upgrade_code_call.get_dispatch_info().class,
+			frame_support::dispatch::DispatchClass::Operational
+		);
+
+		let with_weight_call = Call::<Test>::with_weight {
+			call: upgrade_code_call,
+			weight: Weight::from_parts(123, 456),
+		};
+		// Weight after is set by Root.
+		assert_eq!(with_weight_call.get_dispatch_info().weight, Weight::from_parts(123, 456));
+		assert_eq!(
+			with_weight_call.get_dispatch_info().class,
+			frame_support::dispatch::DispatchClass::Operational
+		);
+	})
+}
diff --git a/substrate/frame/utility/src/weights.rs b/substrate/frame/utility/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1a3ea6c1f7fc85df4e90a6e8552fc211a51f5405
--- /dev/null
+++ b/substrate/frame/utility/src/weights.rs
@@ -0,0 +1,157 @@
+// 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.
+
+//! Autogenerated weights for pallet_utility
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_utility
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/utility/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_utility.
+pub trait WeightInfo {
+	fn batch(c: u32, ) -> Weight;
+	fn as_derivative() -> Weight;
+	fn batch_all(c: u32, ) -> Weight;
+	fn dispatch_as() -> Weight;
+	fn force_batch(c: u32, ) -> Weight;
+}
+
+/// Weights for pallet_utility using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// The range of component `c` is `[0, 1000]`.
+	fn batch(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_763_000 picoseconds.
+		Weight::from_parts(16_943_157, 0)
+			// Standard Error: 1_904
+			.saturating_add(Weight::from_parts(4_653_855, 0).saturating_mul(c.into()))
+	}
+	fn as_derivative() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_149_000 picoseconds.
+		Weight::from_parts(5_268_000, 0)
+	}
+	/// The range of component `c` is `[0, 1000]`.
+	fn batch_all(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_976_000 picoseconds.
+		Weight::from_parts(16_448_433, 0)
+			// Standard Error: 1_834
+			.saturating_add(Weight::from_parts(4_796_983, 0).saturating_mul(c.into()))
+	}
+	fn dispatch_as() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_102_000 picoseconds.
+		Weight::from_parts(9_353_000, 0)
+	}
+	/// The range of component `c` is `[0, 1000]`.
+	fn force_batch(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_840_000 picoseconds.
+		Weight::from_parts(17_748_474, 0)
+			// Standard Error: 2_059
+			.saturating_add(Weight::from_parts(4_630_079, 0).saturating_mul(c.into()))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// The range of component `c` is `[0, 1000]`.
+	fn batch(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_763_000 picoseconds.
+		Weight::from_parts(16_943_157, 0)
+			// Standard Error: 1_904
+			.saturating_add(Weight::from_parts(4_653_855, 0).saturating_mul(c.into()))
+	}
+	fn as_derivative() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 5_149_000 picoseconds.
+		Weight::from_parts(5_268_000, 0)
+	}
+	/// The range of component `c` is `[0, 1000]`.
+	fn batch_all(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_976_000 picoseconds.
+		Weight::from_parts(16_448_433, 0)
+			// Standard Error: 1_834
+			.saturating_add(Weight::from_parts(4_796_983, 0).saturating_mul(c.into()))
+	}
+	fn dispatch_as() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 9_102_000 picoseconds.
+		Weight::from_parts(9_353_000, 0)
+	}
+	/// The range of component `c` is `[0, 1000]`.
+	fn force_batch(c: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `0`
+		//  Estimated: `0`
+		// Minimum execution time: 6_840_000 picoseconds.
+		Weight::from_parts(17_748_474, 0)
+			// Standard Error: 2_059
+			.saturating_add(Weight::from_parts(4_630_079, 0).saturating_mul(c.into()))
+	}
+}
diff --git a/substrate/frame/vesting/Cargo.toml b/substrate/frame/vesting/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e6826903c9dfb63e991db060f2f73f6e165e3fea
--- /dev/null
+++ b/substrate/frame/vesting/Cargo.toml
@@ -0,0 +1,59 @@
+[package]
+name = "pallet-vesting"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for manage vesting"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/vesting/README.md b/substrate/frame/vesting/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1f3744d63592ae74d3844d4762c8da19cf7fe904
--- /dev/null
+++ b/substrate/frame/vesting/README.md
@@ -0,0 +1,32 @@
+# Vesting Module
+
+- [`Config`](https://docs.rs/pallet-vesting/latest/pallet_vesting/pallet/trait.Config.html)
+- [`Call`](https://docs.rs/pallet-vesting/latest/pallet_vesting/pallet/enum.Call.html)
+
+## Overview
+
+A simple module providing a means of placing a linear curve on an account's locked balance. This
+module ensures that there is a lock in place preventing the balance to drop below the *unvested*
+amount for reason other than the ones specified in `UnvestedFundsAllowedWithdrawReasons`
+configuration value.
+
+As the amount vested increases over time, the amount unvested reduces. However, locks remain in
+place and explicit action is needed on behalf of the user to ensure that the amount locked is
+equivalent to the amount remaining to be vested. This is done through a dispatchable function,
+either `vest` (in typical case where the sender is calling on their own behalf) or `vest_other`
+in case the sender is calling on another account's behalf.
+
+## Interface
+
+This module implements the `VestingSchedule` trait.
+
+### Dispatchable Functions
+
+- `vest` - Update the lock, reducing it in line with the amount "vested" so far.
+- `vest_other` - Update the lock of another account, reducing it in line with the amount
+  "vested" so far.
+
+[`Call`]: ./enum.Call.html
+[`Config`]: ./trait.Config.html
+
+License: Apache-2.0
diff --git a/substrate/frame/vesting/src/benchmarking.rs b/substrate/frame/vesting/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4af48f5d368dbfc75643fa1192e4e51b23f33c18
--- /dev/null
+++ b/substrate/frame/vesting/src/benchmarking.rs
@@ -0,0 +1,391 @@
+// 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.
+
+//! Vesting pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use frame_benchmarking::v1::{account, benchmarks, whitelisted_caller};
+use frame_support::assert_ok;
+use frame_system::{pallet_prelude::BlockNumberFor, Pallet as System, RawOrigin};
+use sp_runtime::traits::{Bounded, CheckedDiv, CheckedMul};
+
+use super::*;
+use crate::Pallet as Vesting;
+
+const SEED: u32 = 0;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+fn add_locks<T: Config>(who: &T::AccountId, n: u8) {
+	for id in 0..n {
+		let lock_id = [id; 8];
+		let locked = 256u32;
+		let reasons = WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE;
+		T::Currency::set_lock(lock_id, who, locked.into(), reasons);
+	}
+}
+
+fn add_vesting_schedules<T: Config>(
+	target: AccountIdLookupOf<T>,
+	n: u32,
+) -> Result<BalanceOf<T>, &'static str> {
+	let min_transfer = T::MinVestedTransfer::get();
+	let locked = min_transfer.checked_mul(&20u32.into()).unwrap();
+	// Schedule has a duration of 20.
+	let per_block = min_transfer;
+	let starting_block = 1u32;
+
+	let source: T::AccountId = account("source", 0, SEED);
+	let source_lookup = T::Lookup::unlookup(source.clone());
+	T::Currency::make_free_balance_be(&source, BalanceOf::<T>::max_value());
+
+	System::<T>::set_block_number(BlockNumberFor::<T>::zero());
+
+	let mut total_locked: BalanceOf<T> = Zero::zero();
+	for _ in 0..n {
+		total_locked += locked;
+
+		let schedule = VestingInfo::new(locked, per_block, starting_block.into());
+		assert_ok!(Vesting::<T>::do_vested_transfer(
+			source_lookup.clone(),
+			target.clone(),
+			schedule
+		));
+
+		// Top up to guarantee we can always transfer another schedule.
+		T::Currency::make_free_balance_be(&source, BalanceOf::<T>::max_value());
+	}
+
+	Ok(total_locked)
+}
+
+benchmarks! {
+	vest_locked {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 1 .. T::MAX_VESTING_SCHEDULES;
+
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		T::Currency::make_free_balance_be(&caller, T::Currency::minimum_balance());
+
+		add_locks::<T>(&caller, l as u8);
+		let expected_balance = add_vesting_schedules::<T>(caller_lookup, s)?;
+
+		// At block zero, everything is vested.
+		assert_eq!(System::<T>::block_number(), BlockNumberFor::<T>::zero());
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			Some(expected_balance),
+			"Vesting schedule not added",
+		);
+	}: vest(RawOrigin::Signed(caller.clone()))
+	verify {
+		// Nothing happened since everything is still vested.
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			Some(expected_balance),
+			"Vesting schedule was removed",
+		);
+	}
+
+	vest_unlocked {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 1 .. T::MAX_VESTING_SCHEDULES;
+
+		let caller: T::AccountId = whitelisted_caller();
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		T::Currency::make_free_balance_be(&caller, T::Currency::minimum_balance());
+
+		add_locks::<T>(&caller, l as u8);
+		add_vesting_schedules::<T>(caller_lookup, s)?;
+
+		// At block 21, everything is unlocked.
+		System::<T>::set_block_number(21u32.into());
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			Some(BalanceOf::<T>::zero()),
+			"Vesting schedule still active",
+		);
+	}: vest(RawOrigin::Signed(caller.clone()))
+	verify {
+		// Vesting schedule is removed!
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			None,
+			"Vesting schedule was not removed",
+		);
+	}
+
+	vest_other_locked {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 1 .. T::MAX_VESTING_SCHEDULES;
+
+		let other: T::AccountId = account("other", 0, SEED);
+		let other_lookup = T::Lookup::unlookup(other.clone());
+
+		T::Currency::make_free_balance_be(&other, T::Currency::minimum_balance());
+		add_locks::<T>(&other, l as u8);
+		let expected_balance = add_vesting_schedules::<T>(other_lookup.clone(), s)?;
+
+		// At block zero, everything is vested.
+		assert_eq!(System::<T>::block_number(), BlockNumberFor::<T>::zero());
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&other),
+			Some(expected_balance),
+			"Vesting schedule not added",
+		);
+
+		let caller: T::AccountId = whitelisted_caller();
+	}: vest_other(RawOrigin::Signed(caller.clone()), other_lookup)
+	verify {
+		// Nothing happened since everything is still vested.
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&other),
+			Some(expected_balance),
+			"Vesting schedule was removed",
+		);
+	}
+
+	vest_other_unlocked {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 1 .. T::MAX_VESTING_SCHEDULES;
+
+		let other: T::AccountId = account("other", 0, SEED);
+		let other_lookup = T::Lookup::unlookup(other.clone());
+
+		T::Currency::make_free_balance_be(&other, T::Currency::minimum_balance());
+		add_locks::<T>(&other, l as u8);
+		add_vesting_schedules::<T>(other_lookup.clone(), s)?;
+		// At block 21 everything is unlocked.
+		System::<T>::set_block_number(21u32.into());
+
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&other),
+			Some(BalanceOf::<T>::zero()),
+			"Vesting schedule still active",
+		);
+
+		let caller: T::AccountId = whitelisted_caller();
+	}: vest_other(RawOrigin::Signed(caller.clone()), other_lookup)
+	verify {
+		// Vesting schedule is removed.
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&other),
+			None,
+			"Vesting schedule was not removed",
+		);
+	}
+
+	vested_transfer {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 0 .. T::MAX_VESTING_SCHEDULES - 1;
+
+		let caller: T::AccountId = whitelisted_caller();
+		T::Currency::make_free_balance_be(&caller, BalanceOf::<T>::max_value());
+
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		// Give target existing locks
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
+		add_locks::<T>(&target, l as u8);
+		// Add one vesting schedules.
+		let orig_balance = T::Currency::free_balance(&target);
+		let mut expected_balance = add_vesting_schedules::<T>(target_lookup.clone(), s)?;
+
+		let transfer_amount = T::MinVestedTransfer::get();
+		let per_block = transfer_amount.checked_div(&20u32.into()).unwrap();
+		expected_balance += transfer_amount;
+
+		let vesting_schedule = VestingInfo::new(
+			transfer_amount,
+			per_block,
+			1u32.into(),
+		);
+	}: _(RawOrigin::Signed(caller), target_lookup, vesting_schedule)
+	verify {
+		assert_eq!(
+			orig_balance + expected_balance,
+			T::Currency::free_balance(&target),
+			"Transfer didn't happen",
+		);
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&target),
+			Some(expected_balance),
+			"Lock not correctly updated",
+		);
+	}
+
+	force_vested_transfer {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 0 .. T::MAX_VESTING_SCHEDULES - 1;
+
+		let source: T::AccountId = account("source", 0, SEED);
+		let source_lookup = T::Lookup::unlookup(source.clone());
+		T::Currency::make_free_balance_be(&source, BalanceOf::<T>::max_value());
+
+		let target: T::AccountId = account("target", 0, SEED);
+		let target_lookup = T::Lookup::unlookup(target.clone());
+		// Give target existing locks
+		T::Currency::make_free_balance_be(&target, T::Currency::minimum_balance());
+		add_locks::<T>(&target, l as u8);
+		// Add one less than max vesting schedules
+		let orig_balance = T::Currency::free_balance(&target);
+		let mut expected_balance = add_vesting_schedules::<T>(target_lookup.clone(), s)?;
+
+		let transfer_amount = T::MinVestedTransfer::get();
+		let per_block = transfer_amount.checked_div(&20u32.into()).unwrap();
+		expected_balance += transfer_amount;
+
+		let vesting_schedule = VestingInfo::new(
+			transfer_amount,
+			per_block,
+			1u32.into(),
+		);
+	}: _(RawOrigin::Root, source_lookup, target_lookup, vesting_schedule)
+	verify {
+		assert_eq!(
+			orig_balance + expected_balance,
+			T::Currency::free_balance(&target),
+			"Transfer didn't happen",
+		);
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&target),
+			Some(expected_balance),
+				"Lock not correctly updated",
+			);
+		}
+
+	not_unlocking_merge_schedules {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 2 .. T::MAX_VESTING_SCHEDULES;
+
+		let caller: T::AccountId = account("caller", 0, SEED);
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		// Give target existing locks.
+		T::Currency::make_free_balance_be(&caller, T::Currency::minimum_balance());
+		add_locks::<T>(&caller, l as u8);
+		// Add max vesting schedules.
+		let expected_balance = add_vesting_schedules::<T>(caller_lookup, s)?;
+
+		// Schedules are not vesting at block 0.
+		assert_eq!(System::<T>::block_number(), BlockNumberFor::<T>::zero());
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			Some(expected_balance),
+			"Vesting balance should equal sum locked of all schedules",
+		);
+		assert_eq!(
+			Vesting::<T>::vesting(&caller).unwrap().len(),
+			s as usize,
+			"There should be exactly max vesting schedules"
+		);
+	}: merge_schedules(RawOrigin::Signed(caller.clone()), 0, s - 1)
+	verify {
+		let expected_schedule = VestingInfo::new(
+			T::MinVestedTransfer::get() * 20u32.into() * 2u32.into(),
+			T::MinVestedTransfer::get() * 2u32.into(),
+			1u32.into(),
+		);
+		let expected_index = (s - 2) as usize;
+		assert_eq!(
+			Vesting::<T>::vesting(&caller).unwrap()[expected_index],
+			expected_schedule
+		);
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			Some(expected_balance),
+			"Vesting balance should equal total locked of all schedules",
+		);
+		assert_eq!(
+			Vesting::<T>::vesting(&caller).unwrap().len(),
+			(s - 1) as usize,
+			"Schedule count should reduce by 1"
+		);
+	}
+
+	unlocking_merge_schedules {
+		let l in 0 .. MaxLocksOf::<T>::get() - 1;
+		let s in 2 .. T::MAX_VESTING_SCHEDULES;
+
+		// Destination used just for currency transfers in asserts.
+		let test_dest: T::AccountId = account("test_dest", 0, SEED);
+
+		let caller: T::AccountId = account("caller", 0, SEED);
+		let caller_lookup = T::Lookup::unlookup(caller.clone());
+		// Give target other locks.
+		T::Currency::make_free_balance_be(&caller, T::Currency::minimum_balance());
+		add_locks::<T>(&caller, l as u8);
+		// Add max vesting schedules.
+		let total_transferred = add_vesting_schedules::<T>(caller_lookup, s)?;
+
+		// Go to about half way through all the schedules duration. (They all start at 1, and have a duration of 20 or 21).
+		System::<T>::set_block_number(11u32.into());
+		// We expect half the original locked balance (+ any remainder that vests on the last block).
+		let expected_balance = total_transferred / 2u32.into();
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			Some(expected_balance),
+			"Vesting balance should reflect that we are half way through all schedules duration",
+		);
+		assert_eq!(
+			Vesting::<T>::vesting(&caller).unwrap().len(),
+			s as usize,
+			"There should be exactly max vesting schedules"
+		);
+		// The balance is not actually transferable because it has not been unlocked.
+		assert!(T::Currency::transfer(&caller, &test_dest, expected_balance, ExistenceRequirement::AllowDeath).is_err());
+	}: merge_schedules(RawOrigin::Signed(caller.clone()), 0, s - 1)
+	verify {
+		let expected_schedule = VestingInfo::new(
+			T::MinVestedTransfer::get() * 2u32.into() * 10u32.into(),
+			T::MinVestedTransfer::get() * 2u32.into(),
+			11u32.into(),
+		);
+		let expected_index = (s - 2) as usize;
+		assert_eq!(
+			Vesting::<T>::vesting(&caller).unwrap()[expected_index],
+			expected_schedule,
+			"New schedule is properly created and placed"
+		);
+		assert_eq!(
+			Vesting::<T>::vesting(&caller).unwrap()[expected_index],
+			expected_schedule
+		);
+		assert_eq!(
+			Vesting::<T>::vesting_balance(&caller),
+			Some(expected_balance),
+			"Vesting balance should equal half total locked of all schedules",
+		);
+		assert_eq!(
+			Vesting::<T>::vesting(&caller).unwrap().len(),
+			(s - 1) as usize,
+			"Schedule count should reduce by 1"
+		);
+		// Since merge unlocks all schedules we can now transfer the balance.
+		assert_ok!(
+			T::Currency::transfer(&caller, &test_dest, expected_balance, ExistenceRequirement::AllowDeath)
+		);
+	}
+
+	impl_benchmark_test_suite!(
+		Vesting,
+		crate::mock::ExtBuilder::default().existential_deposit(256).build(),
+		crate::mock::Test,
+	);
+}
diff --git a/substrate/frame/vesting/src/lib.rs b/substrate/frame/vesting/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb829121e979717db9af0b96d60adda2f7efbafa
--- /dev/null
+++ b/substrate/frame/vesting/src/lib.rs
@@ -0,0 +1,743 @@
+// 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.
+
+//! # Vesting Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! A simple pallet providing a means of placing a linear curve on an account's locked balance. This
+//! pallet ensures that there is a lock in place preventing the balance to drop below the *unvested*
+//! amount for any reason other than the ones specified in `UnvestedFundsAllowedWithdrawReasons`
+//! configuration value.
+//!
+//! As the amount vested increases over time, the amount unvested reduces. However, locks remain in
+//! place and explicit action is needed on behalf of the user to ensure that the amount locked is
+//! equivalent to the amount remaining to be vested. This is done through a dispatchable function,
+//! either `vest` (in typical case where the sender is calling on their own behalf) or `vest_other`
+//! in case the sender is calling on another account's behalf.
+//!
+//! ## Interface
+//!
+//! This pallet implements the `VestingSchedule` trait.
+//!
+//! ### Dispatchable Functions
+//!
+//! - `vest` - Update the lock, reducing it in line with the amount "vested" so far.
+//! - `vest_other` - Update the lock of another account, reducing it in line with the amount
+//!   "vested" so far.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+mod benchmarking;
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+mod vesting_info;
+
+pub mod migrations;
+pub mod weights;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::{
+	dispatch::{DispatchError, DispatchResult},
+	ensure,
+	storage::bounded_vec::BoundedVec,
+	traits::{
+		Currency, ExistenceRequirement, Get, LockIdentifier, LockableCurrency, VestingSchedule,
+		WithdrawReasons,
+	},
+	weights::Weight,
+};
+use frame_system::pallet_prelude::BlockNumberFor;
+use scale_info::TypeInfo;
+use sp_runtime::{
+	traits::{
+		AtLeast32BitUnsigned, Bounded, Convert, MaybeSerializeDeserialize, One, Saturating,
+		StaticLookup, Zero,
+	},
+	RuntimeDebug,
+};
+use sp_std::{fmt::Debug, marker::PhantomData, prelude::*};
+
+pub use pallet::*;
+pub use vesting_info::*;
+pub use weights::WeightInfo;
+
+type BalanceOf<T> =
+	<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+type MaxLocksOf<T> =
+	<<T as Config>::Currency as LockableCurrency<<T as frame_system::Config>::AccountId>>::MaxLocks;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+
+const VESTING_ID: LockIdentifier = *b"vesting ";
+
+// A value placed in storage that represents the current version of the Vesting storage.
+// This value is used by `on_runtime_upgrade` to determine whether we run storage migration logic.
+#[derive(Encode, Decode, Clone, Copy, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+enum Releases {
+	V0,
+	V1,
+}
+
+impl Default for Releases {
+	fn default() -> Self {
+		Releases::V0
+	}
+}
+
+/// Actions to take against a user's `Vesting` storage entry.
+#[derive(Clone, Copy)]
+enum VestingAction {
+	/// Do not actively remove any schedules.
+	Passive,
+	/// Remove the schedule specified by the index.
+	Remove { index: usize },
+	/// Remove the two schedules, specified by index, so they can be merged.
+	Merge { index1: usize, index2: usize },
+}
+
+impl VestingAction {
+	/// Whether or not the filter says the schedule index should be removed.
+	fn should_remove(&self, index: usize) -> bool {
+		match self {
+			Self::Passive => false,
+			Self::Remove { index: index1 } => *index1 == index,
+			Self::Merge { index1, index2 } => *index1 == index || *index2 == index,
+		}
+	}
+
+	/// Pick the schedules that this action dictates should continue vesting undisturbed.
+	fn pick_schedules<T: Config>(
+		&self,
+		schedules: Vec<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>>,
+	) -> impl Iterator<Item = VestingInfo<BalanceOf<T>, BlockNumberFor<T>>> + '_ {
+		schedules.into_iter().enumerate().filter_map(move |(index, schedule)| {
+			if self.should_remove(index) {
+				None
+			} else {
+				Some(schedule)
+			}
+		})
+	}
+}
+
+// Wrapper for `T::MAX_VESTING_SCHEDULES` to satisfy `trait Get`.
+pub struct MaxVestingSchedulesGet<T>(PhantomData<T>);
+impl<T: Config> Get<u32> for MaxVestingSchedulesGet<T> {
+	fn get() -> u32 {
+		T::MAX_VESTING_SCHEDULES
+	}
+}
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The currency trait.
+		type Currency: LockableCurrency<Self::AccountId>;
+
+		/// Convert the block number into a balance.
+		type BlockNumberToBalance: Convert<BlockNumberFor<Self>, BalanceOf<Self>>;
+
+		/// The minimum amount transferred to call `vested_transfer`.
+		#[pallet::constant]
+		type MinVestedTransfer: Get<BalanceOf<Self>>;
+
+		/// Weight information for extrinsics in this pallet.
+		type WeightInfo: WeightInfo;
+
+		/// Reasons that determine under which conditions the balance may drop below
+		/// the unvested amount.
+		type UnvestedFundsAllowedWithdrawReasons: Get<WithdrawReasons>;
+
+		/// Maximum number of vesting schedules an account may have at a given moment.
+		const MAX_VESTING_SCHEDULES: u32;
+	}
+
+	#[pallet::extra_constants]
+	impl<T: Config> Pallet<T> {
+		#[pallet::constant_name(MaxVestingSchedules)]
+		fn max_vesting_schedules() -> u32 {
+			T::MAX_VESTING_SCHEDULES
+		}
+	}
+
+	#[pallet::hooks]
+	impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+		fn integrity_test() {
+			assert!(T::MAX_VESTING_SCHEDULES > 0, "`MaxVestingSchedules` must ge greater than 0");
+		}
+	}
+
+	/// Information regarding the vesting of a given account.
+	#[pallet::storage]
+	#[pallet::getter(fn vesting)]
+	pub type Vesting<T: Config> = StorageMap<
+		_,
+		Blake2_128Concat,
+		T::AccountId,
+		BoundedVec<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>, MaxVestingSchedulesGet<T>>,
+	>;
+
+	/// Storage version of the pallet.
+	///
+	/// New networks start with latest version, as determined by the genesis build.
+	#[pallet::storage]
+	pub(crate) type StorageVersion<T: Config> = StorageValue<_, Releases, ValueQuery>;
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub vesting: Vec<(T::AccountId, BlockNumberFor<T>, BlockNumberFor<T>, BalanceOf<T>)>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			use sp_runtime::traits::Saturating;
+
+			// Genesis uses the latest storage version.
+			StorageVersion::<T>::put(Releases::V1);
+
+			// Generate initial vesting configuration
+			// * who - Account which we are generating vesting configuration for
+			// * begin - Block when the account will start to vest
+			// * length - Number of blocks from `begin` until fully vested
+			// * liquid - Number of units which can be spent before vesting begins
+			for &(ref who, begin, length, liquid) in self.vesting.iter() {
+				let balance = T::Currency::free_balance(who);
+				assert!(!balance.is_zero(), "Currencies must be init'd before vesting");
+				// Total genesis `balance` minus `liquid` equals funds locked for vesting
+				let locked = balance.saturating_sub(liquid);
+				let length_as_balance = T::BlockNumberToBalance::convert(length);
+				let per_block = locked / length_as_balance.max(sp_runtime::traits::One::one());
+				let vesting_info = VestingInfo::new(locked, per_block, begin);
+				if !vesting_info.is_valid() {
+					panic!("Invalid VestingInfo params at genesis")
+				};
+
+				Vesting::<T>::try_append(who, vesting_info)
+					.expect("Too many vesting schedules at genesis.");
+
+				let reasons =
+					WithdrawReasons::except(T::UnvestedFundsAllowedWithdrawReasons::get());
+
+				T::Currency::set_lock(VESTING_ID, who, locked, reasons);
+			}
+		}
+	}
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		/// The amount vested has been updated. This could indicate a change in funds available.
+		/// The balance given is the amount which is left unvested (and thus locked).
+		VestingUpdated { account: T::AccountId, unvested: BalanceOf<T> },
+		/// An \[account\] has become fully vested.
+		VestingCompleted { account: T::AccountId },
+	}
+
+	/// Error for the vesting pallet.
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The account given is not vesting.
+		NotVesting,
+		/// The account already has `MaxVestingSchedules` count of schedules and thus
+		/// cannot add another one. Consider merging existing schedules in order to add another.
+		AtMaxVestingSchedules,
+		/// Amount being transferred is too low to create a vesting schedule.
+		AmountLow,
+		/// An index was out of bounds of the vesting schedules.
+		ScheduleIndexOutOfBounds,
+		/// Failed to create a new schedule because some parameter was invalid.
+		InvalidScheduleParams,
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Unlock any vested funds of the sender account.
+		///
+		/// The dispatch origin for this call must be _Signed_ and the sender must have funds still
+		/// locked under this pallet.
+		///
+		/// Emits either `VestingCompleted` or `VestingUpdated`.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::vest_locked(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES)
+			.max(T::WeightInfo::vest_unlocked(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES))
+		)]
+		pub fn vest(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			Self::do_vest(who)
+		}
+
+		/// Unlock any vested funds of a `target` account.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `target`: The account whose vested funds should be unlocked. Must have funds still
+		/// locked under this pallet.
+		///
+		/// Emits either `VestingCompleted` or `VestingUpdated`.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::vest_other_locked(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES)
+			.max(T::WeightInfo::vest_other_unlocked(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES))
+		)]
+		pub fn vest_other(origin: OriginFor<T>, target: AccountIdLookupOf<T>) -> DispatchResult {
+			ensure_signed(origin)?;
+			let who = T::Lookup::lookup(target)?;
+			Self::do_vest(who)
+		}
+
+		/// Create a vested transfer.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `target`: The account receiving the vested funds.
+		/// - `schedule`: The vesting schedule attached to the transfer.
+		///
+		/// Emits `VestingCreated`.
+		///
+		/// NOTE: This will unlock all schedules through the current block.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(2)]
+		#[pallet::weight(
+			T::WeightInfo::vested_transfer(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES)
+		)]
+		pub fn vested_transfer(
+			origin: OriginFor<T>,
+			target: AccountIdLookupOf<T>,
+			schedule: VestingInfo<BalanceOf<T>, BlockNumberFor<T>>,
+		) -> DispatchResult {
+			let transactor = ensure_signed(origin)?;
+			let transactor = <T::Lookup as StaticLookup>::unlookup(transactor);
+			Self::do_vested_transfer(transactor, target, schedule)
+		}
+
+		/// Force a vested transfer.
+		///
+		/// The dispatch origin for this call must be _Root_.
+		///
+		/// - `source`: The account whose funds should be transferred.
+		/// - `target`: The account that should be transferred the vested funds.
+		/// - `schedule`: The vesting schedule attached to the transfer.
+		///
+		/// Emits `VestingCreated`.
+		///
+		/// NOTE: This will unlock all schedules through the current block.
+		///
+		/// ## Complexity
+		/// - `O(1)`.
+		#[pallet::call_index(3)]
+		#[pallet::weight(
+			T::WeightInfo::force_vested_transfer(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES)
+		)]
+		pub fn force_vested_transfer(
+			origin: OriginFor<T>,
+			source: AccountIdLookupOf<T>,
+			target: AccountIdLookupOf<T>,
+			schedule: VestingInfo<BalanceOf<T>, BlockNumberFor<T>>,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+			Self::do_vested_transfer(source, target, schedule)
+		}
+
+		/// Merge two vesting schedules together, creating a new vesting schedule that unlocks over
+		/// the highest possible start and end blocks. If both schedules have already started the
+		/// current block will be used as the schedule start; with the caveat that if one schedule
+		/// is finished by the current block, the other will be treated as the new merged schedule,
+		/// unmodified.
+		///
+		/// NOTE: If `schedule1_index == schedule2_index` this is a no-op.
+		/// NOTE: This will unlock all schedules through the current block prior to merging.
+		/// NOTE: If both schedules have ended by the current block, no new schedule will be created
+		/// and both will be removed.
+		///
+		/// Merged schedule attributes:
+		/// - `starting_block`: `MAX(schedule1.starting_block, scheduled2.starting_block,
+		///   current_block)`.
+		/// - `ending_block`: `MAX(schedule1.ending_block, schedule2.ending_block)`.
+		/// - `locked`: `schedule1.locked_at(current_block) + schedule2.locked_at(current_block)`.
+		///
+		/// The dispatch origin for this call must be _Signed_.
+		///
+		/// - `schedule1_index`: index of the first schedule to merge.
+		/// - `schedule2_index`: index of the second schedule to merge.
+		#[pallet::call_index(4)]
+		#[pallet::weight(
+			T::WeightInfo::not_unlocking_merge_schedules(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES)
+			.max(T::WeightInfo::unlocking_merge_schedules(MaxLocksOf::<T>::get(), T::MAX_VESTING_SCHEDULES))
+		)]
+		pub fn merge_schedules(
+			origin: OriginFor<T>,
+			schedule1_index: u32,
+			schedule2_index: u32,
+		) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+			if schedule1_index == schedule2_index {
+				return Ok(())
+			};
+			let schedule1_index = schedule1_index as usize;
+			let schedule2_index = schedule2_index as usize;
+
+			let schedules = Self::vesting(&who).ok_or(Error::<T>::NotVesting)?;
+			let merge_action =
+				VestingAction::Merge { index1: schedule1_index, index2: schedule2_index };
+
+			let (schedules, locked_now) = Self::exec_action(schedules.to_vec(), merge_action)?;
+
+			Self::write_vesting(&who, schedules)?;
+			Self::write_lock(&who, locked_now);
+
+			Ok(())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	// Create a new `VestingInfo`, based off of two other `VestingInfo`s.
+	// NOTE: We assume both schedules have had funds unlocked up through the current block.
+	fn merge_vesting_info(
+		now: BlockNumberFor<T>,
+		schedule1: VestingInfo<BalanceOf<T>, BlockNumberFor<T>>,
+		schedule2: VestingInfo<BalanceOf<T>, BlockNumberFor<T>>,
+	) -> Option<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>> {
+		let schedule1_ending_block = schedule1.ending_block_as_balance::<T::BlockNumberToBalance>();
+		let schedule2_ending_block = schedule2.ending_block_as_balance::<T::BlockNumberToBalance>();
+		let now_as_balance = T::BlockNumberToBalance::convert(now);
+
+		// Check if one or both schedules have ended.
+		match (schedule1_ending_block <= now_as_balance, schedule2_ending_block <= now_as_balance) {
+			// If both schedules have ended, we don't merge and exit early.
+			(true, true) => return None,
+			// If one schedule has ended, we treat the one that has not ended as the new
+			// merged schedule.
+			(true, false) => return Some(schedule2),
+			(false, true) => return Some(schedule1),
+			// If neither schedule has ended don't exit early.
+			_ => {},
+		}
+
+		let locked = schedule1
+			.locked_at::<T::BlockNumberToBalance>(now)
+			.saturating_add(schedule2.locked_at::<T::BlockNumberToBalance>(now));
+		// This shouldn't happen because we know at least one ending block is greater than now,
+		// thus at least a schedule a some locked balance.
+		debug_assert!(
+			!locked.is_zero(),
+			"merge_vesting_info validation checks failed to catch a locked of 0"
+		);
+
+		let ending_block = schedule1_ending_block.max(schedule2_ending_block);
+		let starting_block = now.max(schedule1.starting_block()).max(schedule2.starting_block());
+
+		let per_block = {
+			let duration = ending_block
+				.saturating_sub(T::BlockNumberToBalance::convert(starting_block))
+				.max(One::one());
+			(locked / duration).max(One::one())
+		};
+
+		let schedule = VestingInfo::new(locked, per_block, starting_block);
+		debug_assert!(schedule.is_valid(), "merge_vesting_info schedule validation check failed");
+
+		Some(schedule)
+	}
+
+	// Execute a vested transfer from `source` to `target` with the given `schedule`.
+	fn do_vested_transfer(
+		source: AccountIdLookupOf<T>,
+		target: AccountIdLookupOf<T>,
+		schedule: VestingInfo<BalanceOf<T>, BlockNumberFor<T>>,
+	) -> DispatchResult {
+		// Validate user inputs.
+		ensure!(schedule.locked() >= T::MinVestedTransfer::get(), Error::<T>::AmountLow);
+		if !schedule.is_valid() {
+			return Err(Error::<T>::InvalidScheduleParams.into())
+		};
+		let target = T::Lookup::lookup(target)?;
+		let source = T::Lookup::lookup(source)?;
+
+		// Check we can add to this account prior to any storage writes.
+		Self::can_add_vesting_schedule(
+			&target,
+			schedule.locked(),
+			schedule.per_block(),
+			schedule.starting_block(),
+		)?;
+
+		T::Currency::transfer(
+			&source,
+			&target,
+			schedule.locked(),
+			ExistenceRequirement::AllowDeath,
+		)?;
+
+		// We can't let this fail because the currency transfer has already happened.
+		let res = Self::add_vesting_schedule(
+			&target,
+			schedule.locked(),
+			schedule.per_block(),
+			schedule.starting_block(),
+		);
+		debug_assert!(res.is_ok(), "Failed to add a schedule when we had to succeed.");
+
+		Ok(())
+	}
+
+	/// Iterate through the schedules to track the current locked amount and
+	/// filter out completed and specified schedules.
+	///
+	/// Returns a tuple that consists of:
+	/// - Vec of vesting schedules, where completed schedules and those specified
+	/// 	by filter are removed. (Note the vec is not checked for respecting
+	/// 	bounded length.)
+	/// - The amount locked at the current block number based on the given schedules.
+	///
+	/// NOTE: the amount locked does not include any schedules that are filtered out via `action`.
+	fn report_schedule_updates(
+		schedules: Vec<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>>,
+		action: VestingAction,
+	) -> (Vec<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>>, BalanceOf<T>) {
+		let now = <frame_system::Pallet<T>>::block_number();
+
+		let mut total_locked_now: BalanceOf<T> = Zero::zero();
+		let filtered_schedules = action
+			.pick_schedules::<T>(schedules)
+			.filter(|schedule| {
+				let locked_now = schedule.locked_at::<T::BlockNumberToBalance>(now);
+				let keep = !locked_now.is_zero();
+				if keep {
+					total_locked_now = total_locked_now.saturating_add(locked_now);
+				}
+				keep
+			})
+			.collect::<Vec<_>>();
+
+		(filtered_schedules, total_locked_now)
+	}
+
+	/// Write an accounts updated vesting lock to storage.
+	fn write_lock(who: &T::AccountId, total_locked_now: BalanceOf<T>) {
+		if total_locked_now.is_zero() {
+			T::Currency::remove_lock(VESTING_ID, who);
+			Self::deposit_event(Event::<T>::VestingCompleted { account: who.clone() });
+		} else {
+			let reasons = WithdrawReasons::except(T::UnvestedFundsAllowedWithdrawReasons::get());
+			T::Currency::set_lock(VESTING_ID, who, total_locked_now, reasons);
+			Self::deposit_event(Event::<T>::VestingUpdated {
+				account: who.clone(),
+				unvested: total_locked_now,
+			});
+		};
+	}
+
+	/// Write an accounts updated vesting schedules to storage.
+	fn write_vesting(
+		who: &T::AccountId,
+		schedules: Vec<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>>,
+	) -> Result<(), DispatchError> {
+		let schedules: BoundedVec<
+			VestingInfo<BalanceOf<T>, BlockNumberFor<T>>,
+			MaxVestingSchedulesGet<T>,
+		> = schedules.try_into().map_err(|_| Error::<T>::AtMaxVestingSchedules)?;
+
+		if schedules.len() == 0 {
+			Vesting::<T>::remove(&who);
+		} else {
+			Vesting::<T>::insert(who, schedules)
+		}
+
+		Ok(())
+	}
+
+	/// Unlock any vested funds of `who`.
+	fn do_vest(who: T::AccountId) -> DispatchResult {
+		let schedules = Self::vesting(&who).ok_or(Error::<T>::NotVesting)?;
+
+		let (schedules, locked_now) =
+			Self::exec_action(schedules.to_vec(), VestingAction::Passive)?;
+
+		Self::write_vesting(&who, schedules)?;
+		Self::write_lock(&who, locked_now);
+
+		Ok(())
+	}
+
+	/// Execute a `VestingAction` against the given `schedules`. Returns the updated schedules
+	/// and locked amount.
+	fn exec_action(
+		schedules: Vec<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>>,
+		action: VestingAction,
+	) -> Result<(Vec<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>>, BalanceOf<T>), DispatchError> {
+		let (schedules, locked_now) = match action {
+			VestingAction::Merge { index1: idx1, index2: idx2 } => {
+				// The schedule index is based off of the schedule ordering prior to filtering out
+				// any schedules that may be ending at this block.
+				let schedule1 = *schedules.get(idx1).ok_or(Error::<T>::ScheduleIndexOutOfBounds)?;
+				let schedule2 = *schedules.get(idx2).ok_or(Error::<T>::ScheduleIndexOutOfBounds)?;
+
+				// The length of `schedules` decreases by 2 here since we filter out 2 schedules.
+				// Thus we know below that we can push the new merged schedule without error
+				// (assuming initial state was valid).
+				let (mut schedules, mut locked_now) =
+					Self::report_schedule_updates(schedules.to_vec(), action);
+
+				let now = <frame_system::Pallet<T>>::block_number();
+				if let Some(new_schedule) = Self::merge_vesting_info(now, schedule1, schedule2) {
+					// Merging created a new schedule so we:
+					// 1) need to add it to the accounts vesting schedule collection,
+					schedules.push(new_schedule);
+					// (we use `locked_at` in case this is a schedule that started in the past)
+					let new_schedule_locked =
+						new_schedule.locked_at::<T::BlockNumberToBalance>(now);
+					// and 2) update the locked amount to reflect the schedule we just added.
+					locked_now = locked_now.saturating_add(new_schedule_locked);
+				} // In the None case there was no new schedule to account for.
+
+				(schedules, locked_now)
+			},
+			_ => Self::report_schedule_updates(schedules.to_vec(), action),
+		};
+
+		debug_assert!(
+			locked_now > Zero::zero() && schedules.len() > 0 ||
+				locked_now == Zero::zero() && schedules.len() == 0
+		);
+
+		Ok((schedules, locked_now))
+	}
+}
+
+impl<T: Config> VestingSchedule<T::AccountId> for Pallet<T>
+where
+	BalanceOf<T>: MaybeSerializeDeserialize + Debug,
+{
+	type Currency = T::Currency;
+	type Moment = BlockNumberFor<T>;
+
+	/// Get the amount that is currently being vested and cannot be transferred out of this account.
+	fn vesting_balance(who: &T::AccountId) -> Option<BalanceOf<T>> {
+		if let Some(v) = Self::vesting(who) {
+			let now = <frame_system::Pallet<T>>::block_number();
+			let total_locked_now = v.iter().fold(Zero::zero(), |total, schedule| {
+				schedule.locked_at::<T::BlockNumberToBalance>(now).saturating_add(total)
+			});
+			Some(T::Currency::free_balance(who).min(total_locked_now))
+		} else {
+			None
+		}
+	}
+
+	/// Adds a vesting schedule to a given account.
+	///
+	/// If the account has `MaxVestingSchedules`, an Error is returned and nothing
+	/// is updated.
+	///
+	/// On success, a linearly reducing amount of funds will be locked. In order to realise any
+	/// reduction of the lock over time as it diminishes, the account owner must use `vest` or
+	/// `vest_other`.
+	///
+	/// Is a no-op if the amount to be vested is zero.
+	///
+	/// NOTE: This doesn't alter the free balance of the account.
+	fn add_vesting_schedule(
+		who: &T::AccountId,
+		locked: BalanceOf<T>,
+		per_block: BalanceOf<T>,
+		starting_block: BlockNumberFor<T>,
+	) -> DispatchResult {
+		if locked.is_zero() {
+			return Ok(())
+		}
+
+		let vesting_schedule = VestingInfo::new(locked, per_block, starting_block);
+		// Check for `per_block` or `locked` of 0.
+		if !vesting_schedule.is_valid() {
+			return Err(Error::<T>::InvalidScheduleParams.into())
+		};
+
+		let mut schedules = Self::vesting(who).unwrap_or_default();
+
+		// NOTE: we must push the new schedule so that `exec_action`
+		// will give the correct new locked amount.
+		ensure!(schedules.try_push(vesting_schedule).is_ok(), Error::<T>::AtMaxVestingSchedules);
+
+		let (schedules, locked_now) =
+			Self::exec_action(schedules.to_vec(), VestingAction::Passive)?;
+
+		Self::write_vesting(who, schedules)?;
+		Self::write_lock(who, locked_now);
+
+		Ok(())
+	}
+
+	// Ensure we can call `add_vesting_schedule` without error. This should always
+	// be called prior to `add_vesting_schedule`.
+	fn can_add_vesting_schedule(
+		who: &T::AccountId,
+		locked: BalanceOf<T>,
+		per_block: BalanceOf<T>,
+		starting_block: BlockNumberFor<T>,
+	) -> DispatchResult {
+		// Check for `per_block` or `locked` of 0.
+		if !VestingInfo::new(locked, per_block, starting_block).is_valid() {
+			return Err(Error::<T>::InvalidScheduleParams.into())
+		}
+
+		ensure!(
+			(Vesting::<T>::decode_len(who).unwrap_or_default() as u32) < T::MAX_VESTING_SCHEDULES,
+			Error::<T>::AtMaxVestingSchedules
+		);
+
+		Ok(())
+	}
+
+	/// Remove a vesting schedule for a given account.
+	fn remove_vesting_schedule(who: &T::AccountId, schedule_index: u32) -> DispatchResult {
+		let schedules = Self::vesting(who).ok_or(Error::<T>::NotVesting)?;
+		let remove_action = VestingAction::Remove { index: schedule_index as usize };
+
+		let (schedules, locked_now) = Self::exec_action(schedules.to_vec(), remove_action)?;
+
+		Self::write_vesting(who, schedules)?;
+		Self::write_lock(who, locked_now);
+		Ok(())
+	}
+}
diff --git a/substrate/frame/vesting/src/migrations.rs b/substrate/frame/vesting/src/migrations.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cac3c90b403ab4b1e037e140c0598aa83d69816e
--- /dev/null
+++ b/substrate/frame/vesting/src/migrations.rs
@@ -0,0 +1,95 @@
+// 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.
+
+//! Storage migrations for the vesting pallet.
+
+use super::*;
+
+// Migration from single schedule to multiple schedules.
+pub mod v1 {
+	use super::*;
+
+	#[cfg(feature = "try-runtime")]
+	pub fn pre_migrate<T: Config>() -> Result<(), &'static str> {
+		assert!(StorageVersion::<T>::get() == Releases::V0, "Storage version too high.");
+
+		log::debug!(
+			target: "runtime::vesting",
+			"migration: Vesting storage version v1 PRE migration checks succesful!"
+		);
+
+		Ok(())
+	}
+
+	/// Migrate from single schedule to multi schedule storage.
+	/// WARNING: This migration will delete schedules if `MaxVestingSchedules < 1`.
+	pub fn migrate<T: Config>() -> Weight {
+		let mut reads_writes = 0;
+
+		Vesting::<T>::translate::<VestingInfo<BalanceOf<T>, BlockNumberFor<T>>, _>(
+			|_key, vesting_info| {
+				reads_writes += 1;
+				let v: Option<
+					BoundedVec<
+						VestingInfo<BalanceOf<T>, BlockNumberFor<T>>,
+						MaxVestingSchedulesGet<T>,
+					>,
+				> = vec![vesting_info].try_into().ok();
+
+				if v.is_none() {
+					log::warn!(
+						target: "runtime::vesting",
+						"migration: Failed to move a vesting schedule into a BoundedVec"
+					);
+				}
+
+				v
+			},
+		);
+
+		T::DbWeight::get().reads_writes(reads_writes, reads_writes)
+	}
+
+	#[cfg(feature = "try-runtime")]
+	pub fn post_migrate<T: Config>() -> Result<(), &'static str> {
+		assert_eq!(StorageVersion::<T>::get(), Releases::V1);
+
+		for (_key, schedules) in Vesting::<T>::iter() {
+			assert!(
+				schedules.len() >= 1,
+				"A bounded vec with incorrect count of items was created."
+			);
+
+			for s in schedules {
+				// It is ok if this does not pass, but ideally pre-existing schedules would pass
+				// this validation logic so we can be more confident about edge cases.
+				if !s.is_valid() {
+					log::warn!(
+						target: "runtime::vesting",
+						"migration: A schedule does not pass new validation logic.",
+					)
+				}
+			}
+		}
+
+		log::debug!(
+			target: "runtime::vesting",
+			"migration: Vesting storage version v1 POST migration checks successful!"
+		);
+		Ok(())
+	}
+}
diff --git a/substrate/frame/vesting/src/mock.rs b/substrate/frame/vesting/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe1779475a69ae850fc4335309f6fadb4cbe5d7e
--- /dev/null
+++ b/substrate/frame/vesting/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.
+
+use frame_support::{
+	parameter_types,
+	traits::{ConstU32, ConstU64, WithdrawReasons},
+};
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, Identity, IdentityLookup},
+	BuildStorage,
+};
+
+use super::*;
+use crate as pallet_vesting;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+frame_support::construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+		Balances: pallet_balances::{Pallet, Call, Storage, Config<T>, Event<T>},
+		Vesting: pallet_vesting::{Pallet, Call, Storage, Event<T>, Config<T>},
+	}
+);
+
+impl frame_system::Config for Test {
+	type AccountData = pallet_balances::AccountData<u64>;
+	type AccountId = u64;
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockHashCount = ConstU64<250>;
+	type BlockLength = ();
+	type BlockWeights = ();
+	type RuntimeCall = RuntimeCall;
+	type DbWeight = ();
+	type RuntimeEvent = RuntimeEvent;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type Block = Block;
+	type Nonce = u64;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type OnKilledAccount = ();
+	type OnNewAccount = ();
+	type OnSetCode = ();
+	type MaxConsumers = frame_support::traits::ConstU32<16>;
+	type RuntimeOrigin = RuntimeOrigin;
+	type PalletInfo = PalletInfo;
+	type SS58Prefix = ();
+	type SystemWeightInfo = ();
+	type Version = ();
+}
+
+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 MaxHolds = ();
+}
+parameter_types! {
+	pub const MinVestedTransfer: u64 = 256 * 2;
+	pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons =
+		WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE);
+	pub static ExistentialDeposit: u64 = 1;
+}
+impl Config for Test {
+	type BlockNumberToBalance = Identity;
+	type Currency = Balances;
+	type RuntimeEvent = RuntimeEvent;
+	const MAX_VESTING_SCHEDULES: u32 = 3;
+	type MinVestedTransfer = MinVestedTransfer;
+	type WeightInfo = ();
+	type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons;
+}
+
+pub struct ExtBuilder {
+	existential_deposit: u64,
+	vesting_genesis_config: Option<Vec<(u64, u64, u64, u64)>>,
+}
+
+impl Default for ExtBuilder {
+	fn default() -> Self {
+		Self { existential_deposit: 1, vesting_genesis_config: None }
+	}
+}
+
+impl ExtBuilder {
+	pub fn existential_deposit(mut self, existential_deposit: u64) -> Self {
+		self.existential_deposit = existential_deposit;
+		self
+	}
+
+	pub fn vesting_genesis_config(mut self, config: Vec<(u64, u64, u64, u64)>) -> Self {
+		self.vesting_genesis_config = Some(config);
+		self
+	}
+
+	pub fn build(self) -> sp_io::TestExternalities {
+		EXISTENTIAL_DEPOSIT.with(|v| *v.borrow_mut() = self.existential_deposit);
+		let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+		pallet_balances::GenesisConfig::<Test> {
+			balances: vec![
+				(1, 10 * self.existential_deposit),
+				(2, 20 * self.existential_deposit),
+				(3, 30 * self.existential_deposit),
+				(4, 40 * self.existential_deposit),
+				(12, 10 * self.existential_deposit),
+				(13, 9999 * self.existential_deposit),
+			],
+		}
+		.assimilate_storage(&mut t)
+		.unwrap();
+
+		let vesting = if let Some(vesting_config) = self.vesting_genesis_config {
+			vesting_config
+		} else {
+			vec![
+				(1, 0, 10, 5 * self.existential_deposit),
+				(2, 10, 20, 0),
+				(12, 10, 20, 5 * self.existential_deposit),
+			]
+		};
+
+		pallet_vesting::GenesisConfig::<Test> { vesting }
+			.assimilate_storage(&mut t)
+			.unwrap();
+		let mut ext = sp_io::TestExternalities::new(t);
+		ext.execute_with(|| System::set_block_number(1));
+		ext
+	}
+}
diff --git a/substrate/frame/vesting/src/tests.rs b/substrate/frame/vesting/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..46afe895f6fcc0de0d25401c22a9ecd07f3f1b57
--- /dev/null
+++ b/substrate/frame/vesting/src/tests.rs
@@ -0,0 +1,1156 @@
+// 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_support::{assert_noop, assert_ok, assert_storage_noop, dispatch::EncodeLike};
+use frame_system::RawOrigin;
+use sp_runtime::{
+	traits::{BadOrigin, Identity},
+	TokenError,
+};
+
+use super::{Vesting as VestingStorage, *};
+use crate::mock::{Balances, ExtBuilder, System, Test, Vesting};
+
+/// A default existential deposit.
+const ED: u64 = 256;
+
+/// Calls vest, and asserts that there is no entry for `account`
+/// in the `Vesting` storage item.
+fn vest_and_assert_no_vesting<T>(account: u64)
+where
+	u64: EncodeLike<<T as frame_system::Config>::AccountId>,
+	T: pallet::Config,
+{
+	// Its ok for this to fail because the user may already have no schedules.
+	let _result = Vesting::vest(Some(account).into());
+	assert!(!<VestingStorage<T>>::contains_key(account));
+}
+
+#[test]
+fn check_vesting_status() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let user1_free_balance = Balances::free_balance(&1);
+		let user2_free_balance = Balances::free_balance(&2);
+		let user12_free_balance = Balances::free_balance(&12);
+		assert_eq!(user1_free_balance, ED * 10); // Account 1 has free balance
+		assert_eq!(user2_free_balance, ED * 20); // Account 2 has free balance
+		assert_eq!(user12_free_balance, ED * 10); // Account 12 has free balance
+		let user1_vesting_schedule = VestingInfo::new(
+			ED * 5,
+			128, // Vesting over 10 blocks
+			0,
+		);
+		let user2_vesting_schedule = VestingInfo::new(
+			ED * 20,
+			ED, // Vesting over 20 blocks
+			10,
+		);
+		let user12_vesting_schedule = VestingInfo::new(
+			ED * 5,
+			64, // Vesting over 20 blocks
+			10,
+		);
+		assert_eq!(Vesting::vesting(&1).unwrap(), vec![user1_vesting_schedule]); // Account 1 has a vesting schedule
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![user2_vesting_schedule]); // Account 2 has a vesting schedule
+		assert_eq!(Vesting::vesting(&12).unwrap(), vec![user12_vesting_schedule]); // Account 12 has a vesting schedule
+
+		// Account 1 has only 128 units vested from their illiquid ED * 5 units at block 1
+		assert_eq!(Vesting::vesting_balance(&1), Some(128 * 9));
+		// Account 2 has their full balance locked
+		assert_eq!(Vesting::vesting_balance(&2), Some(user2_free_balance));
+		// Account 12 has only their illiquid funds locked
+		assert_eq!(Vesting::vesting_balance(&12), Some(user12_free_balance - ED * 5));
+
+		System::set_block_number(10);
+		assert_eq!(System::block_number(), 10);
+
+		// Account 1 has fully vested by block 10
+		assert_eq!(Vesting::vesting_balance(&1), Some(0));
+		// Account 2 has started vesting by block 10
+		assert_eq!(Vesting::vesting_balance(&2), Some(user2_free_balance));
+		// Account 12 has started vesting by block 10
+		assert_eq!(Vesting::vesting_balance(&12), Some(user12_free_balance - ED * 5));
+
+		System::set_block_number(30);
+		assert_eq!(System::block_number(), 30);
+
+		assert_eq!(Vesting::vesting_balance(&1), Some(0)); // Account 1 is still fully vested, and not negative
+		assert_eq!(Vesting::vesting_balance(&2), Some(0)); // Account 2 has fully vested by block 30
+		assert_eq!(Vesting::vesting_balance(&12), Some(0)); // Account 2 has fully vested by block 30
+
+		// Once we unlock the funds, they are removed from storage.
+		vest_and_assert_no_vesting::<Test>(1);
+		vest_and_assert_no_vesting::<Test>(2);
+		vest_and_assert_no_vesting::<Test>(12);
+	});
+}
+
+#[test]
+fn check_vesting_status_for_multi_schedule_account() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		assert_eq!(System::block_number(), 1);
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // Vesting over 20 blocks
+			10,
+		);
+		// Account 2 already has a vesting schedule.
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+
+		// Account 2's free balance is from sched0.
+		let free_balance = Balances::free_balance(&2);
+		assert_eq!(free_balance, ED * (20));
+		assert_eq!(Vesting::vesting_balance(&2), Some(free_balance));
+
+		// Add a 2nd schedule that is already unlocking by block #1.
+		let sched1 = VestingInfo::new(
+			ED * 10,
+			ED, // Vesting over 10 blocks
+			0,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 2, sched1));
+		// Free balance is equal to the two existing schedules total amount.
+		let free_balance = Balances::free_balance(&2);
+		assert_eq!(free_balance, ED * (10 + 20));
+		// The most recently added schedule exists.
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched1]);
+		// sched1 has free funds at block #1, but nothing else.
+		assert_eq!(Vesting::vesting_balance(&2), Some(free_balance - sched1.per_block()));
+
+		// Add a 3rd schedule.
+		let sched2 = VestingInfo::new(
+			ED * 30,
+			ED, // Vesting over 30 blocks
+			5,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 2, sched2));
+
+		System::set_block_number(9);
+		// Free balance is equal to the 3 existing schedules total amount.
+		let free_balance = Balances::free_balance(&2);
+		assert_eq!(free_balance, ED * (10 + 20 + 30));
+		// sched1 and sched2 are freeing funds at block #9.
+		assert_eq!(
+			Vesting::vesting_balance(&2),
+			Some(free_balance - sched1.per_block() * 9 - sched2.per_block() * 4)
+		);
+
+		System::set_block_number(20);
+		// At block #20 sched1 is fully unlocked while sched2 and sched0 are partially unlocked.
+		assert_eq!(
+			Vesting::vesting_balance(&2),
+			Some(
+				free_balance - sched1.locked() - sched2.per_block() * 15 - sched0.per_block() * 10
+			)
+		);
+
+		System::set_block_number(30);
+		// At block #30 sched0 and sched1 are fully unlocked while sched2 is partially unlocked.
+		assert_eq!(
+			Vesting::vesting_balance(&2),
+			Some(free_balance - sched1.locked() - sched2.per_block() * 25 - sched0.locked())
+		);
+
+		// At block #35 sched2 fully unlocks and thus all schedules funds are unlocked.
+		System::set_block_number(35);
+		assert_eq!(Vesting::vesting_balance(&2), Some(0));
+		// Since we have not called any extrinsics that would unlock funds the schedules
+		// are still in storage,
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched1, sched2]);
+		// but once we unlock the funds, they are removed from storage.
+		vest_and_assert_no_vesting::<Test>(2);
+	});
+}
+
+#[test]
+fn unvested_balance_should_not_transfer() {
+	ExtBuilder::default().existential_deposit(10).build().execute_with(|| {
+		let user1_free_balance = Balances::free_balance(&1);
+		assert_eq!(user1_free_balance, 100); // Account 1 has free balance
+									 // Account 1 has only 5 units vested at block 1 (plus 50 unvested)
+		assert_eq!(Vesting::vesting_balance(&1), Some(45));
+		// Account 1 cannot send more than vested amount...
+		assert_noop!(Balances::transfer_allow_death(Some(1).into(), 2, 56), TokenError::Frozen);
+	});
+}
+
+#[test]
+fn vested_balance_should_transfer() {
+	ExtBuilder::default().existential_deposit(10).build().execute_with(|| {
+		let user1_free_balance = Balances::free_balance(&1);
+		assert_eq!(user1_free_balance, 100); // Account 1 has free balance
+									 // Account 1 has only 5 units vested at block 1 (plus 50 unvested)
+		assert_eq!(Vesting::vesting_balance(&1), Some(45));
+		assert_ok!(Vesting::vest(Some(1).into()));
+		assert_ok!(Balances::transfer_allow_death(Some(1).into(), 2, 55));
+	});
+}
+
+#[test]
+fn vested_balance_should_transfer_with_multi_sched() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let sched0 = VestingInfo::new(5 * ED, 128, 0);
+		assert_ok!(Vesting::vested_transfer(Some(13).into(), 1, sched0));
+		// Total 10*ED locked for all the schedules.
+		assert_eq!(Vesting::vesting(&1).unwrap(), vec![sched0, sched0]);
+
+		let user1_free_balance = Balances::free_balance(&1);
+		assert_eq!(user1_free_balance, 3840); // Account 1 has free balance
+
+		// Account 1 has only 256 units unlocking at block 1 (plus 1280 already fee).
+		assert_eq!(Vesting::vesting_balance(&1), Some(2304));
+		assert_ok!(Vesting::vest(Some(1).into()));
+		assert_ok!(Balances::transfer_allow_death(Some(1).into(), 2, 1536));
+	});
+}
+
+#[test]
+fn non_vested_cannot_vest() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		assert!(!<VestingStorage<Test>>::contains_key(4));
+		assert_noop!(Vesting::vest(Some(4).into()), Error::<Test>::NotVesting);
+	});
+}
+
+#[test]
+fn vested_balance_should_transfer_using_vest_other() {
+	ExtBuilder::default().existential_deposit(10).build().execute_with(|| {
+		let user1_free_balance = Balances::free_balance(&1);
+		assert_eq!(user1_free_balance, 100); // Account 1 has free balance
+									 // Account 1 has only 5 units vested at block 1 (plus 50 unvested)
+		assert_eq!(Vesting::vesting_balance(&1), Some(45));
+		assert_ok!(Vesting::vest_other(Some(2).into(), 1));
+		assert_ok!(Balances::transfer_allow_death(Some(1).into(), 2, 55));
+	});
+}
+
+#[test]
+fn vested_balance_should_transfer_using_vest_other_with_multi_sched() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let sched0 = VestingInfo::new(5 * ED, 128, 0);
+		assert_ok!(Vesting::vested_transfer(Some(13).into(), 1, sched0));
+		// Total of 10*ED of locked for all the schedules.
+		assert_eq!(Vesting::vesting(&1).unwrap(), vec![sched0, sched0]);
+
+		let user1_free_balance = Balances::free_balance(&1);
+		assert_eq!(user1_free_balance, 3840); // Account 1 has free balance
+
+		// Account 1 has only 256 units unlocking at block 1 (plus 1280 already free).
+		assert_eq!(Vesting::vesting_balance(&1), Some(2304));
+		assert_ok!(Vesting::vest_other(Some(2).into(), 1));
+		assert_ok!(Balances::transfer_allow_death(Some(1).into(), 2, 1536));
+	});
+}
+
+#[test]
+fn non_vested_cannot_vest_other() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		assert!(!<VestingStorage<Test>>::contains_key(4));
+		assert_noop!(Vesting::vest_other(Some(3).into(), 4), Error::<Test>::NotVesting);
+	});
+}
+
+#[test]
+fn extra_balance_should_transfer() {
+	ExtBuilder::default().existential_deposit(10).build().execute_with(|| {
+		assert_ok!(Balances::transfer_allow_death(Some(3).into(), 1, 100));
+		assert_ok!(Balances::transfer_allow_death(Some(3).into(), 2, 100));
+
+		let user1_free_balance = Balances::free_balance(&1);
+		assert_eq!(user1_free_balance, 200); // Account 1 has 100 more free balance than normal
+
+		let user2_free_balance = Balances::free_balance(&2);
+		assert_eq!(user2_free_balance, 300); // Account 2 has 100 more free balance than normal
+
+		// Account 1 has only 5 units vested at block 1 (plus 150 unvested)
+		assert_eq!(Vesting::vesting_balance(&1), Some(45));
+		assert_ok!(Vesting::vest(Some(1).into()));
+		assert_ok!(Balances::transfer_allow_death(Some(1).into(), 3, 155)); // Account 1 can send extra units gained
+
+		// Account 2 has no units vested at block 1, but gained 100
+		assert_eq!(Vesting::vesting_balance(&2), Some(200));
+		assert_ok!(Vesting::vest(Some(2).into()));
+		assert_ok!(Balances::transfer_allow_death(Some(2).into(), 3, 100)); // Account 2 can send extra
+		                                                            // units gained
+	});
+}
+
+#[test]
+fn liquid_funds_should_transfer_with_delayed_vesting() {
+	ExtBuilder::default().existential_deposit(256).build().execute_with(|| {
+		let user12_free_balance = Balances::free_balance(&12);
+
+		assert_eq!(user12_free_balance, 2560); // Account 12 has free balance
+									   // Account 12 has liquid funds
+		assert_eq!(Vesting::vesting_balance(&12), Some(user12_free_balance - 256 * 5));
+
+		// Account 12 has delayed vesting
+		let user12_vesting_schedule = VestingInfo::new(
+			256 * 5,
+			64, // Vesting over 20 blocks
+			10,
+		);
+		assert_eq!(Vesting::vesting(&12).unwrap(), vec![user12_vesting_schedule]);
+
+		// Account 12 can still send liquid funds
+		assert_ok!(Balances::transfer_allow_death(Some(12).into(), 3, 256 * 5));
+	});
+}
+
+#[test]
+fn vested_transfer_works() {
+	ExtBuilder::default().existential_deposit(256).build().execute_with(|| {
+		let user3_free_balance = Balances::free_balance(&3);
+		let user4_free_balance = Balances::free_balance(&4);
+		assert_eq!(user3_free_balance, 256 * 30);
+		assert_eq!(user4_free_balance, 256 * 40);
+		// Account 4 should not have any vesting yet.
+		assert_eq!(Vesting::vesting(&4), None);
+		// Make the schedule for the new transfer.
+		let new_vesting_schedule = VestingInfo::new(
+			256 * 5,
+			64, // Vesting over 20 blocks
+			10,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(3).into(), 4, new_vesting_schedule));
+		// Now account 4 should have vesting.
+		assert_eq!(Vesting::vesting(&4).unwrap(), vec![new_vesting_schedule]);
+		// Ensure the transfer happened correctly.
+		let user3_free_balance_updated = Balances::free_balance(&3);
+		assert_eq!(user3_free_balance_updated, 256 * 25);
+		let user4_free_balance_updated = Balances::free_balance(&4);
+		assert_eq!(user4_free_balance_updated, 256 * 45);
+		// Account 4 has 5 * 256 locked.
+		assert_eq!(Vesting::vesting_balance(&4), Some(256 * 5));
+
+		System::set_block_number(20);
+		assert_eq!(System::block_number(), 20);
+
+		// Account 4 has 5 * 64 units vested by block 20.
+		assert_eq!(Vesting::vesting_balance(&4), Some(10 * 64));
+
+		System::set_block_number(30);
+		assert_eq!(System::block_number(), 30);
+
+		// Account 4 has fully vested,
+		assert_eq!(Vesting::vesting_balance(&4), Some(0));
+		// and after unlocking its schedules are removed from storage.
+		vest_and_assert_no_vesting::<Test>(4);
+	});
+}
+
+#[test]
+fn vested_transfer_correctly_fails() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let user2_free_balance = Balances::free_balance(&2);
+		let user4_free_balance = Balances::free_balance(&4);
+		assert_eq!(user2_free_balance, ED * 20);
+		assert_eq!(user4_free_balance, ED * 40);
+
+		// Account 2 should already have a vesting schedule.
+		let user2_vesting_schedule = VestingInfo::new(
+			ED * 20,
+			ED, // Vesting over 20 blocks
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![user2_vesting_schedule]);
+
+		// Fails due to too low transfer amount.
+		let new_vesting_schedule_too_low =
+			VestingInfo::new(<Test as Config>::MinVestedTransfer::get() - 1, 64, 10);
+		assert_noop!(
+			Vesting::vested_transfer(Some(3).into(), 4, new_vesting_schedule_too_low),
+			Error::<Test>::AmountLow,
+		);
+
+		// `per_block` is 0, which would result in a schedule with infinite duration.
+		let schedule_per_block_0 =
+			VestingInfo::new(<Test as Config>::MinVestedTransfer::get(), 0, 10);
+		assert_noop!(
+			Vesting::vested_transfer(Some(13).into(), 4, schedule_per_block_0),
+			Error::<Test>::InvalidScheduleParams,
+		);
+
+		// `locked` is 0.
+		let schedule_locked_0 = VestingInfo::new(0, 1, 10);
+		assert_noop!(
+			Vesting::vested_transfer(Some(3).into(), 4, schedule_locked_0),
+			Error::<Test>::AmountLow,
+		);
+
+		// Free balance has not changed.
+		assert_eq!(user2_free_balance, Balances::free_balance(&2));
+		assert_eq!(user4_free_balance, Balances::free_balance(&4));
+		// Account 4 has no schedules.
+		vest_and_assert_no_vesting::<Test>(4);
+	});
+}
+
+#[test]
+fn vested_transfer_allows_max_schedules() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let mut user_4_free_balance = Balances::free_balance(&4);
+		let max_schedules = <Test as Config>::MAX_VESTING_SCHEDULES;
+		let sched = VestingInfo::new(
+			<Test as Config>::MinVestedTransfer::get(),
+			1, // Vest over 2 * 256 blocks.
+			10,
+		);
+
+		// Add max amount schedules to user 4.
+		for _ in 0..max_schedules {
+			assert_ok!(Vesting::vested_transfer(Some(13).into(), 4, sched));
+		}
+
+		// The schedules count towards vesting balance
+		let transferred_amount = <Test as Config>::MinVestedTransfer::get() * max_schedules as u64;
+		assert_eq!(Vesting::vesting_balance(&4), Some(transferred_amount));
+		// and free balance.
+		user_4_free_balance += transferred_amount;
+		assert_eq!(Balances::free_balance(&4), user_4_free_balance);
+
+		// Cannot insert a 4th vesting schedule when `MaxVestingSchedules` === 3,
+		assert_noop!(
+			Vesting::vested_transfer(Some(3).into(), 4, sched),
+			Error::<Test>::AtMaxVestingSchedules,
+		);
+		// so the free balance does not change.
+		assert_eq!(Balances::free_balance(&4), user_4_free_balance);
+
+		// Account 4 has fully vested when all the schedules end,
+		System::set_block_number(
+			<Test as Config>::MinVestedTransfer::get() + sched.starting_block(),
+		);
+		assert_eq!(Vesting::vesting_balance(&4), Some(0));
+		// and after unlocking its schedules are removed from storage.
+		vest_and_assert_no_vesting::<Test>(4);
+	});
+}
+
+#[test]
+fn force_vested_transfer_works() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let user3_free_balance = Balances::free_balance(&3);
+		let user4_free_balance = Balances::free_balance(&4);
+		assert_eq!(user3_free_balance, ED * 30);
+		assert_eq!(user4_free_balance, ED * 40);
+		// Account 4 should not have any vesting yet.
+		assert_eq!(Vesting::vesting(&4), None);
+		// Make the schedule for the new transfer.
+		let new_vesting_schedule = VestingInfo::new(
+			ED * 5,
+			64, // Vesting over 20 blocks
+			10,
+		);
+
+		assert_noop!(
+			Vesting::force_vested_transfer(Some(4).into(), 3, 4, new_vesting_schedule),
+			BadOrigin
+		);
+		assert_ok!(Vesting::force_vested_transfer(
+			RawOrigin::Root.into(),
+			3,
+			4,
+			new_vesting_schedule
+		));
+		// Now account 4 should have vesting.
+		assert_eq!(Vesting::vesting(&4).unwrap()[0], new_vesting_schedule);
+		assert_eq!(Vesting::vesting(&4).unwrap().len(), 1);
+		// Ensure the transfer happened correctly.
+		let user3_free_balance_updated = Balances::free_balance(&3);
+		assert_eq!(user3_free_balance_updated, ED * 25);
+		let user4_free_balance_updated = Balances::free_balance(&4);
+		assert_eq!(user4_free_balance_updated, ED * 45);
+		// Account 4 has 5 * ED locked.
+		assert_eq!(Vesting::vesting_balance(&4), Some(ED * 5));
+
+		System::set_block_number(20);
+		assert_eq!(System::block_number(), 20);
+
+		// Account 4 has 5 * 64 units vested by block 20.
+		assert_eq!(Vesting::vesting_balance(&4), Some(10 * 64));
+
+		System::set_block_number(30);
+		assert_eq!(System::block_number(), 30);
+
+		// Account 4 has fully vested,
+		assert_eq!(Vesting::vesting_balance(&4), Some(0));
+		// and after unlocking its schedules are removed from storage.
+		vest_and_assert_no_vesting::<Test>(4);
+	});
+}
+
+#[test]
+fn force_vested_transfer_correctly_fails() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let user2_free_balance = Balances::free_balance(&2);
+		let user4_free_balance = Balances::free_balance(&4);
+		assert_eq!(user2_free_balance, ED * 20);
+		assert_eq!(user4_free_balance, ED * 40);
+		// Account 2 should already have a vesting schedule.
+		let user2_vesting_schedule = VestingInfo::new(
+			ED * 20,
+			ED, // Vesting over 20 blocks
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![user2_vesting_schedule]);
+
+		// Too low transfer amount.
+		let new_vesting_schedule_too_low =
+			VestingInfo::new(<Test as Config>::MinVestedTransfer::get() - 1, 64, 10);
+		assert_noop!(
+			Vesting::force_vested_transfer(
+				RawOrigin::Root.into(),
+				3,
+				4,
+				new_vesting_schedule_too_low
+			),
+			Error::<Test>::AmountLow,
+		);
+
+		// `per_block` is 0.
+		let schedule_per_block_0 =
+			VestingInfo::new(<Test as Config>::MinVestedTransfer::get(), 0, 10);
+		assert_noop!(
+			Vesting::force_vested_transfer(RawOrigin::Root.into(), 13, 4, schedule_per_block_0),
+			Error::<Test>::InvalidScheduleParams,
+		);
+
+		// `locked` is 0.
+		let schedule_locked_0 = VestingInfo::new(0, 1, 10);
+		assert_noop!(
+			Vesting::force_vested_transfer(RawOrigin::Root.into(), 3, 4, schedule_locked_0),
+			Error::<Test>::AmountLow,
+		);
+
+		// Verify no currency transfer happened.
+		assert_eq!(user2_free_balance, Balances::free_balance(&2));
+		assert_eq!(user4_free_balance, Balances::free_balance(&4));
+		// Account 4 has no schedules.
+		vest_and_assert_no_vesting::<Test>(4);
+	});
+}
+
+#[test]
+fn force_vested_transfer_allows_max_schedules() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let mut user_4_free_balance = Balances::free_balance(&4);
+		let max_schedules = <Test as Config>::MAX_VESTING_SCHEDULES;
+		let sched = VestingInfo::new(
+			<Test as Config>::MinVestedTransfer::get(),
+			1, // Vest over 2 * 256 blocks.
+			10,
+		);
+
+		// Add max amount schedules to user 4.
+		for _ in 0..max_schedules {
+			assert_ok!(Vesting::force_vested_transfer(RawOrigin::Root.into(), 13, 4, sched));
+		}
+
+		// The schedules count towards vesting balance.
+		let transferred_amount = <Test as Config>::MinVestedTransfer::get() * max_schedules as u64;
+		assert_eq!(Vesting::vesting_balance(&4), Some(transferred_amount));
+		// and free balance.
+		user_4_free_balance += transferred_amount;
+		assert_eq!(Balances::free_balance(&4), user_4_free_balance);
+
+		// Cannot insert a 4th vesting schedule when `MaxVestingSchedules` === 3
+		assert_noop!(
+			Vesting::force_vested_transfer(RawOrigin::Root.into(), 3, 4, sched),
+			Error::<Test>::AtMaxVestingSchedules,
+		);
+		// so the free balance does not change.
+		assert_eq!(Balances::free_balance(&4), user_4_free_balance);
+
+		// Account 4 has fully vested when all the schedules end,
+		System::set_block_number(<Test as Config>::MinVestedTransfer::get() + 10);
+		assert_eq!(Vesting::vesting_balance(&4), Some(0));
+		// and after unlocking its schedules are removed from storage.
+		vest_and_assert_no_vesting::<Test>(4);
+	});
+}
+
+#[test]
+fn merge_schedules_that_have_not_started() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		// Account 2 should already have a vesting schedule.
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // Vest over 20 blocks.
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+		assert_eq!(Balances::usable_balance(&2), 0);
+
+		// Add a schedule that is identical to the one that already exists.
+		assert_ok!(Vesting::vested_transfer(Some(3).into(), 2, sched0));
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched0]);
+		assert_eq!(Balances::usable_balance(&2), 0);
+		assert_ok!(Vesting::merge_schedules(Some(2).into(), 0, 1));
+
+		// Since we merged identical schedules, the new schedule finishes at the same
+		// time as the original, just with double the amount.
+		let sched1 = VestingInfo::new(
+			sched0.locked() * 2,
+			sched0.per_block() * 2,
+			10, // Starts at the block the schedules are merged/
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched1]);
+
+		assert_eq!(Balances::usable_balance(&2), 0);
+	});
+}
+
+#[test]
+fn merge_ongoing_schedules() {
+	// Merging two schedules that have started will vest both before merging.
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		// Account 2 should already have a vesting schedule.
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // Vest over 20 blocks.
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+
+		let sched1 = VestingInfo::new(
+			ED * 10,
+			ED,                          // Vest over 10 blocks.
+			sched0.starting_block() + 5, // Start at block 15.
+		);
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 2, sched1));
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched1]);
+
+		// Got to half way through the second schedule where both schedules are actively vesting.
+		let cur_block = 20;
+		System::set_block_number(cur_block);
+
+		// Account 2 has no usable balances prior to the merge because they have not unlocked
+		// with `vest` yet.
+		assert_eq!(Balances::usable_balance(&2), 0);
+
+		assert_ok!(Vesting::merge_schedules(Some(2).into(), 0, 1));
+
+		// Merging schedules un-vests all pre-existing schedules prior to merging, which is
+		// reflected in account 2's updated usable balance.
+		let sched0_vested_now = sched0.per_block() * (cur_block - sched0.starting_block());
+		let sched1_vested_now = sched1.per_block() * (cur_block - sched1.starting_block());
+		assert_eq!(Balances::usable_balance(&2), sched0_vested_now + sched1_vested_now);
+
+		// The locked amount is the sum of what both schedules have locked at the current block.
+		let sched2_locked = sched1
+			.locked_at::<Identity>(cur_block)
+			.saturating_add(sched0.locked_at::<Identity>(cur_block));
+		// End block of the new schedule is the greater of either merged schedule.
+		let sched2_end = sched1
+			.ending_block_as_balance::<Identity>()
+			.max(sched0.ending_block_as_balance::<Identity>());
+		let sched2_duration = sched2_end - cur_block;
+		// Based off the new schedules total locked and its duration, we can calculate the
+		// amount to unlock per block.
+		let sched2_per_block = sched2_locked / sched2_duration;
+
+		let sched2 = VestingInfo::new(sched2_locked, sched2_per_block, cur_block);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched2]);
+
+		// And just to double check, we assert the new merged schedule we be cleaned up as expected.
+		System::set_block_number(30);
+		vest_and_assert_no_vesting::<Test>(2);
+	});
+}
+
+#[test]
+fn merging_shifts_other_schedules_index() {
+	// Schedules being merged are filtered out, schedules to the right of any merged
+	// schedule shift left and the merged schedule is always last.
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let sched0 = VestingInfo::new(
+			ED * 10,
+			ED, // Vesting over 10 blocks.
+			10,
+		);
+		let sched1 = VestingInfo::new(
+			ED * 11,
+			ED, // Vesting over 11 blocks.
+			11,
+		);
+		let sched2 = VestingInfo::new(
+			ED * 12,
+			ED, // Vesting over 12 blocks.
+			12,
+		);
+
+		// Account 3 starts out with no schedules,
+		assert_eq!(Vesting::vesting(&3), None);
+		// and some usable balance.
+		let usable_balance = Balances::usable_balance(&3);
+		assert_eq!(usable_balance, 30 * ED);
+
+		let cur_block = 1;
+		assert_eq!(System::block_number(), cur_block);
+
+		// Transfer the above 3 schedules to account 3.
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 3, sched0));
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 3, sched1));
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 3, sched2));
+
+		// With no schedules vested or merged they are in the order they are created
+		assert_eq!(Vesting::vesting(&3).unwrap(), vec![sched0, sched1, sched2]);
+		// and the usable balance has not changed.
+		assert_eq!(usable_balance, Balances::usable_balance(&3));
+
+		assert_ok!(Vesting::merge_schedules(Some(3).into(), 0, 2));
+
+		// Create the merged schedule of sched0 & sched2.
+		// The merged schedule will have the max possible starting block,
+		let sched3_start = sched1.starting_block().max(sched2.starting_block());
+		// `locked` equal to the sum of the two schedules locked through the current block,
+		let sched3_locked =
+			sched2.locked_at::<Identity>(cur_block) + sched0.locked_at::<Identity>(cur_block);
+		// and will end at the max possible block.
+		let sched3_end = sched2
+			.ending_block_as_balance::<Identity>()
+			.max(sched0.ending_block_as_balance::<Identity>());
+		let sched3_duration = sched3_end - sched3_start;
+		let sched3_per_block = sched3_locked / sched3_duration;
+		let sched3 = VestingInfo::new(sched3_locked, sched3_per_block, sched3_start);
+
+		// The not touched schedule moves left and the new merged schedule is appended.
+		assert_eq!(Vesting::vesting(&3).unwrap(), vec![sched1, sched3]);
+		// The usable balance hasn't changed since none of the schedules have started.
+		assert_eq!(Balances::usable_balance(&3), usable_balance);
+	});
+}
+
+#[test]
+fn merge_ongoing_and_yet_to_be_started_schedules() {
+	// Merge an ongoing schedule that has had `vest` called and a schedule that has not already
+	// started.
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		// Account 2 should already have a vesting schedule.
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // Vesting over 20 blocks
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+
+		// Fast forward to half way through the life of sched1.
+		let mut cur_block =
+			(sched0.starting_block() + sched0.ending_block_as_balance::<Identity>()) / 2;
+		assert_eq!(cur_block, 20);
+		System::set_block_number(cur_block);
+
+		// Prior to vesting there is no usable balance.
+		let mut usable_balance = 0;
+		assert_eq!(Balances::usable_balance(&2), usable_balance);
+		// Vest the current schedules (which is just sched0 now).
+		Vesting::vest(Some(2).into()).unwrap();
+
+		// After vesting the usable balance increases by the unlocked amount.
+		let sched0_vested_now = sched0.locked() - sched0.locked_at::<Identity>(cur_block);
+		usable_balance += sched0_vested_now;
+		assert_eq!(Balances::usable_balance(&2), usable_balance);
+
+		// Go forward a block.
+		cur_block += 1;
+		System::set_block_number(cur_block);
+
+		// And add a schedule that starts after this block, but before sched0 finishes.
+		let sched1 = VestingInfo::new(
+			ED * 10,
+			1, // Vesting over 256 * 10 (2560) blocks
+			cur_block + 1,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 2, sched1));
+
+		// Merge the schedules before sched1 starts.
+		assert_ok!(Vesting::merge_schedules(Some(2).into(), 0, 1));
+		// After merging, the usable balance only changes by the amount sched0 vested since we
+		// last called `vest` (which is just 1 block). The usable balance is not affected by
+		// sched1 because it has not started yet.
+		usable_balance += sched0.per_block();
+		assert_eq!(Balances::usable_balance(&2), usable_balance);
+
+		// The resulting schedule will have the later starting block of the two,
+		let sched2_start = sched1.starting_block();
+		// `locked` equal to the sum of the two schedules locked through the current block,
+		let sched2_locked =
+			sched0.locked_at::<Identity>(cur_block) + sched1.locked_at::<Identity>(cur_block);
+		// and will end at the max possible block.
+		let sched2_end = sched0
+			.ending_block_as_balance::<Identity>()
+			.max(sched1.ending_block_as_balance::<Identity>());
+		let sched2_duration = sched2_end - sched2_start;
+		let sched2_per_block = sched2_locked / sched2_duration;
+
+		let sched2 = VestingInfo::new(sched2_locked, sched2_per_block, sched2_start);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched2]);
+	});
+}
+
+#[test]
+fn merge_finished_and_ongoing_schedules() {
+	// If a schedule finishes by the current block we treat the ongoing schedule,
+	// without any alterations, as the merged one.
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		// Account 2 should already have a vesting schedule.
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // Vesting over 20 blocks.
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+
+		let sched1 = VestingInfo::new(
+			ED * 40,
+			ED, // Vesting over 40 blocks.
+			10,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(4).into(), 2, sched1));
+
+		// Transfer a 3rd schedule, so we can demonstrate how schedule indices change.
+		// (We are not merging this schedule.)
+		let sched2 = VestingInfo::new(
+			ED * 30,
+			ED, // Vesting over 30 blocks.
+			10,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(3).into(), 2, sched2));
+
+		// The schedules are in expected order prior to merging.
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched1, sched2]);
+
+		// Fast forward to sched0's end block.
+		let cur_block = sched0.ending_block_as_balance::<Identity>();
+		System::set_block_number(cur_block);
+		assert_eq!(System::block_number(), 30);
+
+		// Prior to `merge_schedules` and with no vest/vest_other called the user has no usable
+		// balance.
+		assert_eq!(Balances::usable_balance(&2), 0);
+		assert_ok!(Vesting::merge_schedules(Some(2).into(), 0, 1));
+
+		// sched2 is now the first, since sched0 & sched1 get filtered out while "merging".
+		// sched1 gets treated like the new merged schedule by getting pushed onto back
+		// of the vesting schedules vec. Note: sched0 finished at the current block.
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched2, sched1]);
+
+		// sched0 has finished, so its funds are fully unlocked.
+		let sched0_unlocked_now = sched0.locked();
+		// The remaining schedules are ongoing, so their funds are partially unlocked.
+		let sched1_unlocked_now = sched1.locked() - sched1.locked_at::<Identity>(cur_block);
+		let sched2_unlocked_now = sched2.locked() - sched2.locked_at::<Identity>(cur_block);
+
+		// Since merging also vests all the schedules, the users usable balance after merging
+		// includes all pre-existing schedules unlocked through the current block, including
+		// schedules not merged.
+		assert_eq!(
+			Balances::usable_balance(&2),
+			sched0_unlocked_now + sched1_unlocked_now + sched2_unlocked_now
+		);
+	});
+}
+
+#[test]
+fn merge_finishing_schedules_does_not_create_a_new_one() {
+	// If both schedules finish by the current block we don't create new one
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		// Account 2 should already have a vesting schedule.
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // 20 block duration.
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+
+		// Create sched1 and transfer it to account 2.
+		let sched1 = VestingInfo::new(
+			ED * 30,
+			ED, // 30 block duration.
+			10,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(3).into(), 2, sched1));
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched1]);
+
+		let all_scheds_end = sched0
+			.ending_block_as_balance::<Identity>()
+			.max(sched1.ending_block_as_balance::<Identity>());
+
+		assert_eq!(all_scheds_end, 40);
+		System::set_block_number(all_scheds_end);
+
+		// Prior to merge_schedules and with no vest/vest_other called the user has no usable
+		// balance.
+		assert_eq!(Balances::usable_balance(&2), 0);
+
+		// Merge schedule 0 and 1.
+		assert_ok!(Vesting::merge_schedules(Some(2).into(), 0, 1));
+		// The user no longer has any more vesting schedules because they both ended at the
+		// block they where merged,
+		assert!(!<VestingStorage<Test>>::contains_key(&2));
+		// and their usable balance has increased by the total amount locked in the merged
+		// schedules.
+		assert_eq!(Balances::usable_balance(&2), sched0.locked() + sched1.locked());
+	});
+}
+
+#[test]
+fn merge_finished_and_yet_to_be_started_schedules() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		// Account 2 should already have a vesting schedule.
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // 20 block duration.
+			10, // Ends at block 30
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+
+		let sched1 = VestingInfo::new(
+			ED * 30,
+			ED * 2, // 30 block duration.
+			35,
+		);
+		assert_ok!(Vesting::vested_transfer(Some(13).into(), 2, sched1));
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched1]);
+
+		let sched2 = VestingInfo::new(
+			ED * 40,
+			ED, // 40 block duration.
+			30,
+		);
+		// Add a 3rd schedule to demonstrate how sched1 shifts.
+		assert_ok!(Vesting::vested_transfer(Some(13).into(), 2, sched2));
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched1, sched2]);
+
+		System::set_block_number(30);
+
+		// At block 30, sched0 has finished unlocking while sched1 and sched2 are still fully
+		// locked,
+		assert_eq!(Vesting::vesting_balance(&2), Some(sched1.locked() + sched2.locked()));
+		// but since we have not vested usable balance is still 0.
+		assert_eq!(Balances::usable_balance(&2), 0);
+
+		// Merge schedule 0 and 1.
+		assert_ok!(Vesting::merge_schedules(Some(2).into(), 0, 1));
+
+		// sched0 is removed since it finished, and sched1 is removed and then pushed on the back
+		// because it is treated as the merged schedule
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched2, sched1]);
+
+		// The usable balance is updated because merging fully unlocked sched0.
+		assert_eq!(Balances::usable_balance(&2), sched0.locked());
+	});
+}
+
+#[test]
+fn merge_schedules_throws_proper_errors() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		// Account 2 should already have a vesting schedule.
+		let sched0 = VestingInfo::new(
+			ED * 20,
+			ED, // 20 block duration.
+			10,
+		);
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0]);
+
+		// Account 2 only has 1 vesting schedule.
+		assert_noop!(
+			Vesting::merge_schedules(Some(2).into(), 0, 1),
+			Error::<Test>::ScheduleIndexOutOfBounds
+		);
+
+		// Account 4 has 0 vesting schedules.
+		assert_eq!(Vesting::vesting(&4), None);
+		assert_noop!(Vesting::merge_schedules(Some(4).into(), 0, 1), Error::<Test>::NotVesting);
+
+		// There are enough schedules to merge but an index is non-existent.
+		Vesting::vested_transfer(Some(3).into(), 2, sched0).unwrap();
+		assert_eq!(Vesting::vesting(&2).unwrap(), vec![sched0, sched0]);
+		assert_noop!(
+			Vesting::merge_schedules(Some(2).into(), 0, 2),
+			Error::<Test>::ScheduleIndexOutOfBounds
+		);
+
+		// It is a storage noop with no errors if the indexes are the same.
+		assert_storage_noop!(Vesting::merge_schedules(Some(2).into(), 0, 0).unwrap());
+	});
+}
+
+#[test]
+fn generates_multiple_schedules_from_genesis_config() {
+	let vesting_config = vec![
+		// 5 * existential deposit locked.
+		(1, 0, 10, 5 * ED),
+		// 1 * existential deposit locked.
+		(2, 10, 20, 19 * ED),
+		// 2 * existential deposit locked.
+		(2, 10, 20, 18 * ED),
+		// 1 * existential deposit locked.
+		(12, 10, 20, 9 * ED),
+		// 2 * existential deposit locked.
+		(12, 10, 20, 8 * ED),
+		// 3 * existential deposit locked.
+		(12, 10, 20, 7 * ED),
+	];
+	ExtBuilder::default()
+		.existential_deposit(ED)
+		.vesting_genesis_config(vesting_config)
+		.build()
+		.execute_with(|| {
+			let user1_sched1 = VestingInfo::new(5 * ED, 128, 0u64);
+			assert_eq!(Vesting::vesting(&1).unwrap(), vec![user1_sched1]);
+
+			let user2_sched1 = VestingInfo::new(1 * ED, 12, 10u64);
+			let user2_sched2 = VestingInfo::new(2 * ED, 25, 10u64);
+			assert_eq!(Vesting::vesting(&2).unwrap(), vec![user2_sched1, user2_sched2]);
+
+			let user12_sched1 = VestingInfo::new(1 * ED, 12, 10u64);
+			let user12_sched2 = VestingInfo::new(2 * ED, 25, 10u64);
+			let user12_sched3 = VestingInfo::new(3 * ED, 38, 10u64);
+			assert_eq!(
+				Vesting::vesting(&12).unwrap(),
+				vec![user12_sched1, user12_sched2, user12_sched3]
+			);
+		});
+}
+
+#[test]
+#[should_panic]
+fn multiple_schedules_from_genesis_config_errors() {
+	// MaxVestingSchedules is 3, but this config has 4 for account 12 so we panic when building
+	// from genesis.
+	let vesting_config =
+		vec![(12, 10, 20, ED), (12, 10, 20, ED), (12, 10, 20, ED), (12, 10, 20, ED)];
+	ExtBuilder::default()
+		.existential_deposit(ED)
+		.vesting_genesis_config(vesting_config)
+		.build();
+}
+
+#[test]
+fn build_genesis_has_storage_version_v1() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		assert_eq!(StorageVersion::<Test>::get(), Releases::V1);
+	});
+}
+
+#[test]
+fn merge_vesting_handles_per_block_0() {
+	ExtBuilder::default().existential_deposit(ED).build().execute_with(|| {
+		let sched0 = VestingInfo::new(
+			ED, 0, // Vesting over 256 blocks.
+			1,
+		);
+		assert_eq!(sched0.ending_block_as_balance::<Identity>(), 257);
+		let sched1 = VestingInfo::new(
+			ED * 2,
+			0, // Vesting over 512 blocks.
+			10,
+		);
+		assert_eq!(sched1.ending_block_as_balance::<Identity>(), 512u64 + 10);
+
+		let merged = VestingInfo::new(764, 1, 10);
+		assert_eq!(Vesting::merge_vesting_info(5, sched0, sched1), Some(merged));
+	});
+}
+
+#[test]
+fn vesting_info_validate_works() {
+	let min_transfer = <Test as Config>::MinVestedTransfer::get();
+	// Does not check for min transfer.
+	assert_eq!(VestingInfo::new(min_transfer - 1, 1u64, 10u64).is_valid(), true);
+
+	// `locked` cannot be 0.
+	assert_eq!(VestingInfo::new(0, 1u64, 10u64).is_valid(), false);
+
+	// `per_block` cannot be 0.
+	assert_eq!(VestingInfo::new(min_transfer + 1, 0u64, 10u64).is_valid(), false);
+
+	// With valid inputs it does not error.
+	assert_eq!(VestingInfo::new(min_transfer, 1u64, 10u64).is_valid(), true);
+}
+
+#[test]
+fn vesting_info_ending_block_as_balance_works() {
+	// Treats `per_block` 0 as 1.
+	let per_block_0 = VestingInfo::new(256u32, 0u32, 10u32);
+	assert_eq!(per_block_0.ending_block_as_balance::<Identity>(), 256 + 10);
+
+	// `per_block >= locked` always results in a schedule ending the block after it starts
+	let per_block_gt_locked = VestingInfo::new(256u32, 256 * 2u32, 10u32);
+	assert_eq!(
+		per_block_gt_locked.ending_block_as_balance::<Identity>(),
+		1 + per_block_gt_locked.starting_block()
+	);
+	let per_block_eq_locked = VestingInfo::new(256u32, 256u32, 10u32);
+	assert_eq!(
+		per_block_gt_locked.ending_block_as_balance::<Identity>(),
+		per_block_eq_locked.ending_block_as_balance::<Identity>()
+	);
+
+	// Correctly calcs end if `locked % per_block != 0`. (We need a block to unlock the remainder).
+	let imperfect_per_block = VestingInfo::new(256u32, 250u32, 10u32);
+	assert_eq!(
+		imperfect_per_block.ending_block_as_balance::<Identity>(),
+		imperfect_per_block.starting_block() + 2u32,
+	);
+	assert_eq!(
+		imperfect_per_block
+			.locked_at::<Identity>(imperfect_per_block.ending_block_as_balance::<Identity>()),
+		0
+	);
+}
+
+#[test]
+fn per_block_works() {
+	let per_block_0 = VestingInfo::new(256u32, 0u32, 10u32);
+	assert_eq!(per_block_0.per_block(), 1u32);
+	assert_eq!(per_block_0.raw_per_block(), 0u32);
+
+	let per_block_1 = VestingInfo::new(256u32, 1u32, 10u32);
+	assert_eq!(per_block_1.per_block(), 1u32);
+	assert_eq!(per_block_1.raw_per_block(), 1u32);
+}
+
+// When an accounts free balance + schedule.locked is less than ED, the vested transfer will fail.
+#[test]
+fn vested_transfer_less_than_existential_deposit_fails() {
+	ExtBuilder::default().existential_deposit(4 * ED).build().execute_with(|| {
+		// MinVestedTransfer is less the ED.
+		assert!(
+			<Test as Config>::Currency::minimum_balance() >
+				<Test as Config>::MinVestedTransfer::get()
+		);
+
+		let sched =
+			VestingInfo::new(<Test as Config>::MinVestedTransfer::get() as u64, 1u64, 10u64);
+		// The new account balance with the schedule's locked amount would be less than ED.
+		assert!(
+			Balances::free_balance(&99) + sched.locked() <
+				<Test as Config>::Currency::minimum_balance()
+		);
+
+		// vested_transfer fails.
+		assert_noop!(Vesting::vested_transfer(Some(3).into(), 99, sched), TokenError::BelowMinimum,);
+		// force_vested_transfer fails.
+		assert_noop!(
+			Vesting::force_vested_transfer(RawOrigin::Root.into(), 3, 99, sched),
+			TokenError::BelowMinimum,
+		);
+	});
+}
diff --git a/substrate/frame/vesting/src/vesting_info.rs b/substrate/frame/vesting/src/vesting_info.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5d5ae31fc324743eeb71ed0d898d91885d3cf73c
--- /dev/null
+++ b/substrate/frame/vesting/src/vesting_info.rs
@@ -0,0 +1,114 @@
+// 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.
+
+//! Module to enforce private fields on `VestingInfo`.
+
+use super::*;
+
+/// Struct to encode the vesting schedule of an individual account.
+#[derive(Encode, Decode, Copy, Clone, PartialEq, Eq, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+pub struct VestingInfo<Balance, BlockNumber> {
+	/// Locked amount at genesis.
+	locked: Balance,
+	/// Amount that gets unlocked every block after `starting_block`.
+	per_block: Balance,
+	/// Starting block for unlocking(vesting).
+	starting_block: BlockNumber,
+}
+
+impl<Balance, BlockNumber> VestingInfo<Balance, BlockNumber>
+where
+	Balance: AtLeast32BitUnsigned + Copy,
+	BlockNumber: AtLeast32BitUnsigned + Copy + Bounded,
+{
+	/// Instantiate a new `VestingInfo`.
+	pub fn new(
+		locked: Balance,
+		per_block: Balance,
+		starting_block: BlockNumber,
+	) -> VestingInfo<Balance, BlockNumber> {
+		VestingInfo { locked, per_block, starting_block }
+	}
+
+	/// Validate parameters for `VestingInfo`. Note that this does not check
+	/// against `MinVestedTransfer`.
+	pub fn is_valid(&self) -> bool {
+		!self.locked.is_zero() && !self.raw_per_block().is_zero()
+	}
+
+	/// Locked amount at schedule creation.
+	pub fn locked(&self) -> Balance {
+		self.locked
+	}
+
+	/// Amount that gets unlocked every block after `starting_block`. Corrects for `per_block` of 0.
+	/// We don't let `per_block` be less than 1, or else the vesting will never end.
+	/// This should be used whenever accessing `per_block` unless explicitly checking for 0 values.
+	pub fn per_block(&self) -> Balance {
+		self.per_block.max(One::one())
+	}
+
+	/// Get the unmodified `per_block`. Generally should not be used, but is useful for
+	/// validating `per_block`.
+	pub(crate) fn raw_per_block(&self) -> Balance {
+		self.per_block
+	}
+
+	/// Starting block for unlocking(vesting).
+	pub fn starting_block(&self) -> BlockNumber {
+		self.starting_block
+	}
+
+	/// Amount locked at block `n`.
+	pub fn locked_at<BlockNumberToBalance: Convert<BlockNumber, Balance>>(
+		&self,
+		n: BlockNumber,
+	) -> Balance {
+		// Number of blocks that count toward vesting;
+		// saturating to 0 when n < starting_block.
+		let vested_block_count = n.saturating_sub(self.starting_block);
+		let vested_block_count = BlockNumberToBalance::convert(vested_block_count);
+		// Return amount that is still locked in vesting.
+		vested_block_count
+			.checked_mul(&self.per_block()) // `per_block` accessor guarantees at least 1.
+			.map(|to_unlock| self.locked.saturating_sub(to_unlock))
+			.unwrap_or(Zero::zero())
+	}
+
+	/// Block number at which the schedule ends (as type `Balance`).
+	pub fn ending_block_as_balance<BlockNumberToBalance: Convert<BlockNumber, Balance>>(
+		&self,
+	) -> Balance {
+		let starting_block = BlockNumberToBalance::convert(self.starting_block);
+		let duration = if self.per_block() >= self.locked {
+			// If `per_block` is bigger than `locked`, the schedule will end
+			// the block after starting.
+			One::one()
+		} else {
+			self.locked / self.per_block() +
+				if (self.locked % self.per_block()).is_zero() {
+					Zero::zero()
+				} else {
+					// `per_block` does not perfectly divide `locked`, so we need an extra block to
+					// unlock some amount less than `per_block`.
+					One::one()
+				}
+		};
+
+		starting_block.saturating_add(duration)
+	}
+}
diff --git a/substrate/frame/vesting/src/weights.rs b/substrate/frame/vesting/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..17bde888577795667767c8cd8c2dc544d238a578
--- /dev/null
+++ b/substrate/frame/vesting/src/weights.rs
@@ -0,0 +1,432 @@
+// 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.
+
+//! Autogenerated weights for pallet_vesting
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_vesting
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/vesting/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_vesting.
+pub trait WeightInfo {
+	fn vest_locked(l: u32, s: u32, ) -> Weight;
+	fn vest_unlocked(l: u32, s: u32, ) -> Weight;
+	fn vest_other_locked(l: u32, s: u32, ) -> Weight;
+	fn vest_other_unlocked(l: u32, s: u32, ) -> Weight;
+	fn vested_transfer(l: u32, s: u32, ) -> Weight;
+	fn force_vested_transfer(l: u32, s: u32, ) -> Weight;
+	fn not_unlocking_merge_schedules(l: u32, s: u32, ) -> Weight;
+	fn unlocking_merge_schedules(l: u32, s: u32, ) -> Weight;
+}
+
+/// Weights for pallet_vesting using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_locked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 35_336_000 picoseconds.
+		Weight::from_parts(34_290_169, 4764)
+			// Standard Error: 1_381
+			.saturating_add(Weight::from_parts(76_354, 0).saturating_mul(l.into()))
+			// Standard Error: 2_457
+			.saturating_add(Weight::from_parts(81_362, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_unlocked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 38_540_000 picoseconds.
+		Weight::from_parts(38_893_820, 4764)
+			// Standard Error: 1_710
+			.saturating_add(Weight::from_parts(62_106, 0).saturating_mul(l.into()))
+			// Standard Error: 3_043
+			.saturating_add(Weight::from_parts(41_966, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_other_locked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `484 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 37_529_000 picoseconds.
+		Weight::from_parts(36_781_151, 4764)
+			// Standard Error: 1_490
+			.saturating_add(Weight::from_parts(76_322, 0).saturating_mul(l.into()))
+			// Standard Error: 2_652
+			.saturating_add(Weight::from_parts(76_914, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_other_unlocked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `484 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 41_217_000 picoseconds.
+		Weight::from_parts(40_942_515, 4764)
+			// Standard Error: 2_098
+			.saturating_add(Weight::from_parts(65_213, 0).saturating_mul(l.into()))
+			// Standard Error: 3_733
+			.saturating_add(Weight::from_parts(63_326, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[0, 27]`.
+	fn vested_transfer(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `555 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 76_396_000 picoseconds.
+		Weight::from_parts(77_085_336, 4764)
+			// Standard Error: 2_795
+			.saturating_add(Weight::from_parts(88_995, 0).saturating_mul(l.into()))
+			// Standard Error: 4_974
+			.saturating_add(Weight::from_parts(135_384, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[0, 27]`.
+	fn force_vested_transfer(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `658 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `6196`
+		// Minimum execution time: 77_312_000 picoseconds.
+		Weight::from_parts(79_600_900, 6196)
+			// Standard Error: 3_232
+			.saturating_add(Weight::from_parts(78_018, 0).saturating_mul(l.into()))
+			// Standard Error: 5_750
+			.saturating_add(Weight::from_parts(100_848, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[2, 28]`.
+	fn not_unlocking_merge_schedules(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `482 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 38_769_000 picoseconds.
+		Weight::from_parts(37_752_437, 4764)
+			// Standard Error: 1_415
+			.saturating_add(Weight::from_parts(78_398, 0).saturating_mul(l.into()))
+			// Standard Error: 2_614
+			.saturating_add(Weight::from_parts(78_922, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[2, 28]`.
+	fn unlocking_merge_schedules(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `482 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 43_021_000 picoseconds.
+		Weight::from_parts(42_182_858, 4764)
+			// Standard Error: 1_747
+			.saturating_add(Weight::from_parts(83_938, 0).saturating_mul(l.into()))
+			// Standard Error: 3_227
+			.saturating_add(Weight::from_parts(84_652, 0).saturating_mul(s.into()))
+			.saturating_add(T::DbWeight::get().reads(4_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_locked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 35_336_000 picoseconds.
+		Weight::from_parts(34_290_169, 4764)
+			// Standard Error: 1_381
+			.saturating_add(Weight::from_parts(76_354, 0).saturating_mul(l.into()))
+			// Standard Error: 2_457
+			.saturating_add(Weight::from_parts(81_362, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_unlocked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `381 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 38_540_000 picoseconds.
+		Weight::from_parts(38_893_820, 4764)
+			// Standard Error: 1_710
+			.saturating_add(Weight::from_parts(62_106, 0).saturating_mul(l.into()))
+			// Standard Error: 3_043
+			.saturating_add(Weight::from_parts(41_966, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_other_locked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `484 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 37_529_000 picoseconds.
+		Weight::from_parts(36_781_151, 4764)
+			// Standard Error: 1_490
+			.saturating_add(Weight::from_parts(76_322, 0).saturating_mul(l.into()))
+			// Standard Error: 2_652
+			.saturating_add(Weight::from_parts(76_914, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[1, 28]`.
+	fn vest_other_unlocked(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `484 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 41_217_000 picoseconds.
+		Weight::from_parts(40_942_515, 4764)
+			// Standard Error: 2_098
+			.saturating_add(Weight::from_parts(65_213, 0).saturating_mul(l.into()))
+			// Standard Error: 3_733
+			.saturating_add(Weight::from_parts(63_326, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[0, 27]`.
+	fn vested_transfer(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `555 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 76_396_000 picoseconds.
+		Weight::from_parts(77_085_336, 4764)
+			// Standard Error: 2_795
+			.saturating_add(Weight::from_parts(88_995, 0).saturating_mul(l.into()))
+			// Standard Error: 4_974
+			.saturating_add(Weight::from_parts(135_384, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, mode: MaxEncodedLen)
+	/// Storage: System Account (r:2 w:2)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[0, 27]`.
+	fn force_vested_transfer(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `658 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `6196`
+		// Minimum execution time: 77_312_000 picoseconds.
+		Weight::from_parts(79_600_900, 6196)
+			// Standard Error: 3_232
+			.saturating_add(Weight::from_parts(78_018, 0).saturating_mul(l.into()))
+			// Standard Error: 5_750
+			.saturating_add(Weight::from_parts(100_848, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[2, 28]`.
+	fn not_unlocking_merge_schedules(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `482 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 38_769_000 picoseconds.
+		Weight::from_parts(37_752_437, 4764)
+			// Standard Error: 1_415
+			.saturating_add(Weight::from_parts(78_398, 0).saturating_mul(l.into()))
+			// Standard Error: 2_614
+			.saturating_add(Weight::from_parts(78_922, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+	/// Storage: Vesting Vesting (r:1 w:1)
+	/// Proof: Vesting Vesting (max_values: None, max_size: Some(1057), added: 3532, 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(49), added: 2524, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// The range of component `l` is `[0, 49]`.
+	/// The range of component `s` is `[2, 28]`.
+	fn unlocking_merge_schedules(l: u32, s: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `482 + l * (25 ±0) + s * (36 ±0)`
+		//  Estimated: `4764`
+		// Minimum execution time: 43_021_000 picoseconds.
+		Weight::from_parts(42_182_858, 4764)
+			// Standard Error: 1_747
+			.saturating_add(Weight::from_parts(83_938, 0).saturating_mul(l.into()))
+			// Standard Error: 3_227
+			.saturating_add(Weight::from_parts(84_652, 0).saturating_mul(s.into()))
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
+}
diff --git a/substrate/frame/whitelist/Cargo.toml b/substrate/frame/whitelist/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f82900340f3860acb861deb123dc9a204ca077a5
--- /dev/null
+++ b/substrate/frame/whitelist/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "pallet-whitelist"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME pallet for whitelisting call, and dispatch from specific origin"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, path = "../benchmarking" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+
+[dev-dependencies]
+pallet-balances = { version = "4.0.0-dev", path = "../balances" }
+pallet-preimage = { version = "4.0.0-dev", path = "../preimage" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-io = { version = "23.0.0", path = "../../primitives/io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"frame-benchmarking?/std",
+	"frame-support/std",
+	"frame-system/std",
+	"pallet-balances/std",
+	"pallet-preimage/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"pallet-preimage/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+try-runtime = [
+	"frame-support/try-runtime",
+	"frame-system/try-runtime",
+	"pallet-balances/try-runtime",
+	"pallet-preimage/try-runtime",
+	"sp-runtime/try-runtime",
+]
diff --git a/substrate/frame/whitelist/src/benchmarking.rs b/substrate/frame/whitelist/src/benchmarking.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1982f5eb8738e2928946ba62d066bc46a710a854
--- /dev/null
+++ b/substrate/frame/whitelist/src/benchmarking.rs
@@ -0,0 +1,126 @@
+// 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.
+
+//! Whitelist pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::v1::{benchmarks, BenchmarkError};
+use frame_support::{ensure, traits::EnsureOrigin};
+
+#[cfg(test)]
+use crate::Pallet as Whitelist;
+
+benchmarks! {
+	whitelist_call {
+		let origin =
+			T::WhitelistOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call_hash = Default::default();
+	}: _<T::RuntimeOrigin>(origin, call_hash)
+	verify {
+		ensure!(
+			WhitelistedCall::<T>::contains_key(call_hash),
+			"call not whitelisted"
+		);
+		ensure!(
+			T::Preimages::is_requested(&call_hash),
+			"preimage not requested"
+		);
+	}
+
+	remove_whitelisted_call {
+		let origin =
+			T::WhitelistOrigin::try_successful_origin().map_err(|_| BenchmarkError::Weightless)?;
+		let call_hash = Default::default();
+		Pallet::<T>::whitelist_call(origin.clone(), call_hash)
+			.expect("whitelisting call must be successful");
+	}: _<T::RuntimeOrigin>(origin, call_hash)
+	verify {
+		ensure!(
+			!WhitelistedCall::<T>::contains_key(call_hash),
+			"whitelist not removed"
+		);
+		ensure!(
+			!T::Preimages::is_requested(&call_hash),
+			"preimage still requested"
+		);
+	}
+
+	// We benchmark with the maximum possible size for a call.
+	// If the resulting weight is too big, maybe it worth having a weight which depends
+	// on the size of the call, with a new witness in parameter.
+	#[pov_mode = MaxEncodedLen {
+		// Use measured PoV size for the Preimages since we pass in a length witness.
+		Preimage::PreimageFor: Measured
+	}]
+	dispatch_whitelisted_call {
+		// NOTE: we remove `10` because we need some bytes to encode the variants and vec length
+		let n in 1 .. T::Preimages::MAX_LENGTH as u32 - 10;
+
+		let origin = T::DispatchWhitelistedOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let remark = sp_std::vec![1u8; n as usize];
+		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark }.into();
+		let call_weight = call.get_dispatch_info().weight;
+		let encoded_call = call.encode();
+		let call_encoded_len = encoded_call.len() as u32;
+		let call_hash = call.blake2_256().into();
+
+		Pallet::<T>::whitelist_call(origin.clone(), call_hash)
+			.expect("whitelisting call must be successful");
+
+		T::Preimages::note(encoded_call.into()).unwrap();
+
+	}: _<T::RuntimeOrigin>(origin, call_hash, call_encoded_len, call_weight)
+	verify {
+		ensure!(
+			!WhitelistedCall::<T>::contains_key(call_hash),
+			"whitelist not removed"
+		);
+		ensure!(
+			!T::Preimages::is_requested(&call_hash),
+			"preimage still requested"
+		);
+	}
+
+	dispatch_whitelisted_call_with_preimage {
+		let n in 1 .. 10_000;
+
+		let origin = T::DispatchWhitelistedOrigin::try_successful_origin()
+			.map_err(|_| BenchmarkError::Weightless)?;
+		let remark = sp_std::vec![1u8; n as usize];
+
+		let call: <T as Config>::RuntimeCall = frame_system::Call::remark { remark }.into();
+		let call_hash = call.blake2_256().into();
+
+		Pallet::<T>::whitelist_call(origin.clone(), call_hash)
+			.expect("whitelisting call must be successful");
+	}: _<T::RuntimeOrigin>(origin, Box::new(call))
+	verify {
+		ensure!(
+			!WhitelistedCall::<T>::contains_key(call_hash),
+			"whitelist not removed"
+		);
+		ensure!(
+			!T::Preimages::is_requested(&call_hash),
+			"preimage still requested"
+		);
+	}
+
+	impl_benchmark_test_suite!(Whitelist, crate::mock::new_test_ext(), crate::mock::Test);
+}
diff --git a/substrate/frame/whitelist/src/lib.rs b/substrate/frame/whitelist/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..decf010b06757ff7ed03f101100d038078b5e67a
--- /dev/null
+++ b/substrate/frame/whitelist/src/lib.rs
@@ -0,0 +1,249 @@
+// 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.
+
+//! # Whitelist Pallet
+//!
+//! - [`Config`]
+//! - [`Call`]
+//!
+//! ## Overview
+//!
+//! Allow some configurable origin: [`Config::WhitelistOrigin`] to whitelist some hash of a call,
+//! and allow another configurable origin: [`Config::DispatchWhitelistedOrigin`] to dispatch them
+//! with the root origin.
+//!
+//! In the meantime the call corresponding to the hash must have been submitted to the pre-image
+//! handler [`pallet::Config::Preimages`].
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+pub mod weights;
+pub use weights::WeightInfo;
+
+use codec::{DecodeLimit, Encode, FullCodec};
+use frame_support::{
+	dispatch::{GetDispatchInfo, PostDispatchInfo},
+	ensure,
+	traits::{Hash as PreimageHash, QueryPreimage, StorePreimage},
+	weights::Weight,
+	Hashable,
+};
+use scale_info::TypeInfo;
+use sp_runtime::traits::Dispatchable;
+use sp_std::prelude::*;
+
+pub use pallet::*;
+
+#[frame_support::pallet]
+pub mod pallet {
+	use super::*;
+	use frame_support::pallet_prelude::*;
+	use frame_system::pallet_prelude::*;
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {
+		/// The overarching event type.
+		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+		/// The overarching call type.
+		type RuntimeCall: IsType<<Self as frame_system::Config>::RuntimeCall>
+			+ Dispatchable<RuntimeOrigin = Self::RuntimeOrigin, PostInfo = PostDispatchInfo>
+			+ GetDispatchInfo
+			+ FullCodec
+			+ TypeInfo
+			+ From<frame_system::Call<Self>>
+			+ Parameter;
+
+		/// Required origin for whitelisting a call.
+		type WhitelistOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// Required origin for dispatching whitelisted call with root origin.
+		type DispatchWhitelistedOrigin: EnsureOrigin<Self::RuntimeOrigin>;
+
+		/// The handler of pre-images.
+		type Preimages: QueryPreimage + StorePreimage;
+
+		/// The weight information for this pallet.
+		type WeightInfo: WeightInfo;
+	}
+
+	#[pallet::pallet]
+	pub struct Pallet<T>(_);
+
+	#[pallet::event]
+	#[pallet::generate_deposit(pub(super) fn deposit_event)]
+	pub enum Event<T: Config> {
+		CallWhitelisted { call_hash: PreimageHash },
+		WhitelistedCallRemoved { call_hash: PreimageHash },
+		WhitelistedCallDispatched { call_hash: PreimageHash, result: DispatchResultWithPostInfo },
+	}
+
+	#[pallet::error]
+	pub enum Error<T> {
+		/// The preimage of the call hash could not be loaded.
+		UnavailablePreImage,
+		/// The call could not be decoded.
+		UndecodableCall,
+		/// The weight of the decoded call was higher than the witness.
+		InvalidCallWeightWitness,
+		/// The call was not whitelisted.
+		CallIsNotWhitelisted,
+		/// The call was already whitelisted; No-Op.
+		CallAlreadyWhitelisted,
+	}
+
+	#[pallet::storage]
+	pub type WhitelistedCall<T: Config> =
+		StorageMap<_, Twox64Concat, PreimageHash, (), OptionQuery>;
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		#[pallet::call_index(0)]
+		#[pallet::weight(T::WeightInfo::whitelist_call())]
+		pub fn whitelist_call(origin: OriginFor<T>, call_hash: PreimageHash) -> DispatchResult {
+			T::WhitelistOrigin::ensure_origin(origin)?;
+
+			ensure!(
+				!WhitelistedCall::<T>::contains_key(call_hash),
+				Error::<T>::CallAlreadyWhitelisted,
+			);
+
+			WhitelistedCall::<T>::insert(call_hash, ());
+			T::Preimages::request(&call_hash);
+
+			Self::deposit_event(Event::<T>::CallWhitelisted { call_hash });
+
+			Ok(())
+		}
+
+		#[pallet::call_index(1)]
+		#[pallet::weight(T::WeightInfo::remove_whitelisted_call())]
+		pub fn remove_whitelisted_call(
+			origin: OriginFor<T>,
+			call_hash: PreimageHash,
+		) -> DispatchResult {
+			T::WhitelistOrigin::ensure_origin(origin)?;
+
+			WhitelistedCall::<T>::take(call_hash).ok_or(Error::<T>::CallIsNotWhitelisted)?;
+
+			T::Preimages::unrequest(&call_hash);
+
+			Self::deposit_event(Event::<T>::WhitelistedCallRemoved { call_hash });
+
+			Ok(())
+		}
+
+		#[pallet::call_index(2)]
+		#[pallet::weight(
+			T::WeightInfo::dispatch_whitelisted_call(*call_encoded_len)
+				.saturating_add(*call_weight_witness)
+		)]
+		pub fn dispatch_whitelisted_call(
+			origin: OriginFor<T>,
+			call_hash: PreimageHash,
+			call_encoded_len: u32,
+			call_weight_witness: Weight,
+		) -> DispatchResultWithPostInfo {
+			T::DispatchWhitelistedOrigin::ensure_origin(origin)?;
+
+			ensure!(
+				WhitelistedCall::<T>::contains_key(call_hash),
+				Error::<T>::CallIsNotWhitelisted,
+			);
+
+			let call = T::Preimages::fetch(&call_hash, Some(call_encoded_len))
+				.map_err(|_| Error::<T>::UnavailablePreImage)?;
+
+			let call = <T as Config>::RuntimeCall::decode_all_with_depth_limit(
+				sp_api::MAX_EXTRINSIC_DEPTH,
+				&mut &call[..],
+			)
+			.map_err(|_| Error::<T>::UndecodableCall)?;
+
+			ensure!(
+				call.get_dispatch_info().weight.all_lte(call_weight_witness),
+				Error::<T>::InvalidCallWeightWitness
+			);
+
+			let actual_weight = Self::clean_and_dispatch(call_hash, call).map(|w| {
+				w.saturating_add(T::WeightInfo::dispatch_whitelisted_call(call_encoded_len))
+			});
+
+			Ok(actual_weight.into())
+		}
+
+		#[pallet::call_index(3)]
+		#[pallet::weight({
+			let call_weight = call.get_dispatch_info().weight;
+			let call_len = call.encoded_size() as u32;
+
+			T::WeightInfo::dispatch_whitelisted_call_with_preimage(call_len)
+				.saturating_add(call_weight)
+		})]
+		pub fn dispatch_whitelisted_call_with_preimage(
+			origin: OriginFor<T>,
+			call: Box<<T as Config>::RuntimeCall>,
+		) -> DispatchResultWithPostInfo {
+			T::DispatchWhitelistedOrigin::ensure_origin(origin)?;
+
+			let call_hash = call.blake2_256().into();
+
+			ensure!(
+				WhitelistedCall::<T>::contains_key(call_hash),
+				Error::<T>::CallIsNotWhitelisted,
+			);
+
+			let call_len = call.encoded_size() as u32;
+			let actual_weight = Self::clean_and_dispatch(call_hash, *call).map(|w| {
+				w.saturating_add(T::WeightInfo::dispatch_whitelisted_call_with_preimage(call_len))
+			});
+
+			Ok(actual_weight.into())
+		}
+	}
+}
+
+impl<T: Config> Pallet<T> {
+	/// Clean whitelisting/preimage and dispatch call.
+	///
+	/// Return the call actual weight of the dispatched call if there is some.
+	fn clean_and_dispatch(
+		call_hash: PreimageHash,
+		call: <T as Config>::RuntimeCall,
+	) -> Option<Weight> {
+		WhitelistedCall::<T>::remove(call_hash);
+
+		T::Preimages::unrequest(&call_hash);
+
+		let result = call.dispatch(frame_system::Origin::<T>::Root.into());
+
+		let call_actual_weight = match result {
+			Ok(call_post_info) => call_post_info.actual_weight,
+			Err(call_err) => call_err.post_info.actual_weight,
+		};
+
+		Self::deposit_event(Event::<T>::WhitelistedCallDispatched { call_hash, result });
+
+		call_actual_weight
+	}
+}
diff --git a/substrate/frame/whitelist/src/mock.rs b/substrate/frame/whitelist/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d91f43b33af91bd8fe605bbfae6e7f4f0c09fb63
--- /dev/null
+++ b/substrate/frame/whitelist/src/mock.rs
@@ -0,0 +1,112 @@
+// 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.
+
+// Mock for Whitelist Pallet
+
+#![cfg(test)]
+
+use crate as pallet_whitelist;
+
+use frame_support::{
+	construct_runtime,
+	traits::{ConstU32, ConstU64, Nothing},
+};
+use frame_system::EnsureRoot;
+use sp_core::H256;
+use sp_runtime::{
+	traits::{BlakeTwo256, IdentityLookup},
+	BuildStorage,
+};
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Whitelist: pallet_whitelist,
+		Preimage: pallet_preimage,
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = Nothing;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type DbWeight = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type Nonce = u64;
+	type Hash = H256;
+	type RuntimeCall = RuntimeCall;
+	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>;
+}
+
+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 MaxHolds = ();
+}
+
+impl pallet_preimage::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type ManagerOrigin = EnsureRoot<Self::AccountId>;
+	type BaseDeposit = ConstU64<1>;
+	type ByteDeposit = ConstU64<1>;
+	type WeightInfo = ();
+}
+
+impl pallet_whitelist::Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type RuntimeCall = RuntimeCall;
+	type WhitelistOrigin = EnsureRoot<Self::AccountId>;
+	type DispatchWhitelistedOrigin = EnsureRoot<Self::AccountId>;
+	type Preimages = Preimage;
+	type WeightInfo = ();
+}
+
+pub fn new_test_ext() -> sp_io::TestExternalities {
+	let t = RuntimeGenesisConfig::default().build_storage().unwrap();
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}
diff --git a/substrate/frame/whitelist/src/tests.rs b/substrate/frame/whitelist/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3a60adbcfbedc04dd79edacfb2cb16a70427975b
--- /dev/null
+++ b/substrate/frame/whitelist/src/tests.rs
@@ -0,0 +1,225 @@
+// 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 Whitelist Pallet
+
+use crate::mock::*;
+use codec::Encode;
+use frame_support::{
+	assert_noop, assert_ok,
+	dispatch::GetDispatchInfo,
+	traits::{QueryPreimage, StorePreimage},
+	weights::Weight,
+};
+use sp_runtime::{traits::Hash, DispatchError};
+
+#[test]
+fn test_whitelist_call_and_remove() {
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::System(frame_system::Call::remark { remark: vec![] });
+		let encoded_call = call.encode();
+		let call_hash = <Test as frame_system::Config>::Hashing::hash(&encoded_call[..]);
+
+		assert_noop!(
+			Whitelist::remove_whitelisted_call(RuntimeOrigin::root(), call_hash),
+			crate::Error::<Test>::CallIsNotWhitelisted,
+		);
+
+		assert_noop!(
+			Whitelist::whitelist_call(RuntimeOrigin::signed(1), call_hash),
+			DispatchError::BadOrigin,
+		);
+
+		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
+
+		assert!(Preimage::is_requested(&call_hash));
+
+		assert_noop!(
+			Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash),
+			crate::Error::<Test>::CallAlreadyWhitelisted,
+		);
+
+		assert_noop!(
+			Whitelist::remove_whitelisted_call(RuntimeOrigin::signed(1), call_hash),
+			DispatchError::BadOrigin,
+		);
+
+		assert_ok!(Whitelist::remove_whitelisted_call(RuntimeOrigin::root(), call_hash));
+
+		assert!(!Preimage::is_requested(&call_hash));
+
+		assert_noop!(
+			Whitelist::remove_whitelisted_call(RuntimeOrigin::root(), call_hash),
+			crate::Error::<Test>::CallIsNotWhitelisted,
+		);
+	});
+}
+
+#[test]
+fn test_whitelist_call_and_execute() {
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::System(frame_system::Call::remark_with_event { remark: vec![1] });
+		let call_weight = call.get_dispatch_info().weight;
+		let encoded_call = call.encode();
+		let call_encoded_len = encoded_call.len() as u32;
+		let call_hash = <Test as frame_system::Config>::Hashing::hash(&encoded_call[..]);
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
+			crate::Error::<Test>::CallIsNotWhitelisted,
+		);
+
+		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::signed(1),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
+			DispatchError::BadOrigin,
+		);
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
+			crate::Error::<Test>::UnavailablePreImage,
+		);
+
+		assert_ok!(Preimage::note(encoded_call.into()));
+
+		assert!(Preimage::is_requested(&call_hash));
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight - Weight::from_parts(1, 0)
+			),
+			crate::Error::<Test>::InvalidCallWeightWitness,
+		);
+
+		assert_ok!(Whitelist::dispatch_whitelisted_call(
+			RuntimeOrigin::root(),
+			call_hash,
+			call_encoded_len,
+			call_weight
+		));
+
+		assert!(!Preimage::is_requested(&call_hash));
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
+			crate::Error::<Test>::CallIsNotWhitelisted,
+		);
+	});
+}
+
+#[test]
+fn test_whitelist_call_and_execute_failing_call() {
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::Whitelist(crate::Call::dispatch_whitelisted_call {
+			call_hash: Default::default(),
+			call_encoded_len: Default::default(),
+			call_weight_witness: Weight::zero(),
+		});
+		let call_weight = call.get_dispatch_info().weight;
+		let encoded_call = call.encode();
+		let call_encoded_len = encoded_call.len() as u32;
+		let call_hash = <Test as frame_system::Config>::Hashing::hash(&encoded_call[..]);
+
+		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
+		assert_ok!(Preimage::note(encoded_call.into()));
+		assert!(Preimage::is_requested(&call_hash));
+		assert_ok!(Whitelist::dispatch_whitelisted_call(
+			RuntimeOrigin::root(),
+			call_hash,
+			call_encoded_len,
+			call_weight
+		));
+		assert!(!Preimage::is_requested(&call_hash));
+	});
+}
+
+#[test]
+fn test_whitelist_call_and_execute_without_note_preimage() {
+	new_test_ext().execute_with(|| {
+		let call = Box::new(RuntimeCall::System(frame_system::Call::remark_with_event {
+			remark: vec![1],
+		}));
+		let call_hash = <Test as frame_system::Config>::Hashing::hash_of(&call);
+
+		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
+		assert!(Preimage::is_requested(&call_hash));
+
+		assert_ok!(Whitelist::dispatch_whitelisted_call_with_preimage(
+			RuntimeOrigin::root(),
+			call.clone()
+		));
+
+		assert!(!Preimage::is_requested(&call_hash));
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call_with_preimage(RuntimeOrigin::root(), call),
+			crate::Error::<Test>::CallIsNotWhitelisted,
+		);
+	});
+}
+
+#[test]
+fn test_whitelist_call_and_execute_decode_consumes_all() {
+	new_test_ext().execute_with(|| {
+		let call = RuntimeCall::System(frame_system::Call::remark_with_event { remark: vec![1] });
+		let call_weight = call.get_dispatch_info().weight;
+		let mut call = call.encode();
+		// Appending something does not make the encoded call invalid.
+		// This tests that the decode function consumes all data.
+		call.extend(call.clone());
+		let call_encoded_len = call.len() as u32;
+
+		let call_hash = <Test as frame_system::Config>::Hashing::hash(&call[..]);
+
+		assert_ok!(Preimage::note(call.into()));
+		assert_ok!(Whitelist::whitelist_call(RuntimeOrigin::root(), call_hash));
+
+		assert_noop!(
+			Whitelist::dispatch_whitelisted_call(
+				RuntimeOrigin::root(),
+				call_hash,
+				call_encoded_len,
+				call_weight
+			),
+			crate::Error::<Test>::UndecodableCall,
+		);
+	});
+}
diff --git a/substrate/frame/whitelist/src/weights.rs b/substrate/frame/whitelist/src/weights.rs
new file mode 100644
index 0000000000000000000000000000000000000000..de42c5a5841cf8c2d3aea1227dafd35ec461b234
--- /dev/null
+++ b/substrate/frame/whitelist/src/weights.rs
@@ -0,0 +1,190 @@
+// 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.
+
+//! Autogenerated weights for pallet_whitelist
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-06-16, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// ./target/production/substrate
+// benchmark
+// pallet
+// --chain=dev
+// --steps=50
+// --repeat=20
+// --pallet=pallet_whitelist
+// --no-storage-info
+// --no-median-slopes
+// --no-min-squares
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --output=./frame/whitelist/src/weights.rs
+// --header=./HEADER-APACHE2
+// --template=./.maintain/frame-weight-template.hbs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
+use core::marker::PhantomData;
+
+/// Weight functions needed for pallet_whitelist.
+pub trait WeightInfo {
+	fn whitelist_call() -> Weight;
+	fn remove_whitelisted_call() -> Weight;
+	fn dispatch_whitelisted_call(n: u32, ) -> Weight;
+	fn dispatch_whitelisted_call_with_preimage(n: u32, ) -> Weight;
+}
+
+/// Weights for pallet_whitelist using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn whitelist_call() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `217`
+		//  Estimated: `3556`
+		// Minimum execution time: 19_914_000 picoseconds.
+		Weight::from_parts(20_892_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn remove_whitelisted_call() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `346`
+		//  Estimated: `3556`
+		// Minimum execution time: 18_142_000 picoseconds.
+		Weight::from_parts(18_529_000, 3556)
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:1 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: Measured)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 4194294]`.
+	fn dispatch_whitelisted_call(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `422 + n * (1 ±0)`
+		//  Estimated: `3886 + n * (1 ±0)`
+		// Minimum execution time: 30_671_000 picoseconds.
+		Weight::from_parts(31_197_000, 3886)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_163, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(3_u64))
+			.saturating_add(T::DbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
+	}
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 10000]`.
+	fn dispatch_whitelisted_call_with_preimage(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `346`
+		//  Estimated: `3556`
+		// Minimum execution time: 22_099_000 picoseconds.
+		Weight::from_parts(23_145_477, 3556)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(1_422, 0).saturating_mul(n.into()))
+			.saturating_add(T::DbWeight::get().reads(2_u64))
+			.saturating_add(T::DbWeight::get().writes(2_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn whitelist_call() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `217`
+		//  Estimated: `3556`
+		// Minimum execution time: 19_914_000 picoseconds.
+		Weight::from_parts(20_892_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	fn remove_whitelisted_call() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `346`
+		//  Estimated: `3556`
+		// Minimum execution time: 18_142_000 picoseconds.
+		Weight::from_parts(18_529_000, 3556)
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage PreimageFor (r:1 w:1)
+	/// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: Measured)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 4194294]`.
+	fn dispatch_whitelisted_call(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `422 + n * (1 ±0)`
+		//  Estimated: `3886 + n * (1 ±0)`
+		// Minimum execution time: 30_671_000 picoseconds.
+		Weight::from_parts(31_197_000, 3886)
+			// Standard Error: 0
+			.saturating_add(Weight::from_parts(1_163, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(3_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+			.saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into()))
+	}
+	/// Storage: Whitelist WhitelistedCall (r:1 w:1)
+	/// Proof: Whitelist WhitelistedCall (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen)
+	/// Storage: Preimage StatusFor (r:1 w:1)
+	/// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen)
+	/// The range of component `n` is `[1, 10000]`.
+	fn dispatch_whitelisted_call_with_preimage(n: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `346`
+		//  Estimated: `3556`
+		// Minimum execution time: 22_099_000 picoseconds.
+		Weight::from_parts(23_145_477, 3556)
+			// Standard Error: 5
+			.saturating_add(Weight::from_parts(1_422, 0).saturating_mul(n.into()))
+			.saturating_add(RocksDbWeight::get().reads(2_u64))
+			.saturating_add(RocksDbWeight::get().writes(2_u64))
+	}
+}
diff --git a/substrate/primitives/api/Cargo.toml b/substrate/primitives/api/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..544afe6980fa326134d25062ef6bfa494f372432
--- /dev/null
+++ b/substrate/primitives/api/Cargo.toml
@@ -0,0 +1,64 @@
+[package]
+name = "sp-api"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate runtime api primitives"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+sp-api-proc-macro = { version = "4.0.0-dev", path = "proc-macro" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-externalities = { version = "0.19.0", default-features = false, optional = true, path = "../externalities" }
+sp-version = { version = "22.0.0", default-features = false, path = "../version" }
+sp-state-machine = { version = "0.28.0", default-features = false, optional = true, path = "../state-machine" }
+sp-trie = { version = "22.0.0", default-features = false, optional = true, path = "../trie" }
+hash-db = { version = "0.16.0", optional = true }
+thiserror = { version = "1.0.30", optional = true }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+sp-metadata-ir = { version = "0.1.0", default-features = false, optional = true, path = "../metadata-ir" }
+log = { version = "0.4.17", default-features = false }
+
+[dev-dependencies]
+sp-test-primitives = { version = "2.0.0", path = "../test-primitives" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"hash-db",
+	"log/std",
+	"scale-info/std",
+	"sp-api-proc-macro/std",
+	"sp-core/std",
+	"sp-externalities",
+	"sp-externalities?/std",
+	"sp-metadata-ir?/std",
+	"sp-runtime/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-test-primitives/std",
+	"sp-trie/std",
+	"sp-version/std",
+	"thiserror",
+]
+# Special feature to disable logging completely.
+#
+# By default `sp-api` initializes the `RuntimeLogger` for each runtime api function. However,
+# logging functionality increases the code size. It is recommended to enable this feature when
+# building a runtime for registering it on chain.
+#
+# This sets the max logging level to `off` for `log`.
+disable-logging = [ "log/max_level_off" ]
+# Do not report the documentation in the metadata.
+no-metadata-docs = [ "sp-api-proc-macro/no-metadata-docs" ]
+frame-metadata = [ "sp-api-proc-macro/frame-metadata", "sp-metadata-ir" ]
diff --git a/substrate/primitives/api/README.md b/substrate/primitives/api/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1cf9437373c77f878b85d8271c87fdf77bf452ec
--- /dev/null
+++ b/substrate/primitives/api/README.md
@@ -0,0 +1,17 @@
+Substrate runtime api
+
+The Substrate runtime api is the crucial interface between the node and the runtime.
+Every call that goes into the runtime is done with a runtime api. The runtime apis are not fixed.
+Every Substrate user can define its own apis with
+[`decl_runtime_apis`](https://docs.rs/sp-api/latest/sp_api/macro.decl_runtime_apis.html) and implement them in
+the runtime with [`impl_runtime_apis`](https://docs.rs/sp-api/latest/sp_api/macro.impl_runtime_apis.html).
+
+Every Substrate runtime needs to implement the [`Core`] runtime api. This api provides the basic
+functionality that every runtime needs to export.
+
+Besides the macros and the [`Core`] runtime api, this crates provides the [`Metadata`] runtime
+api, the [`ApiExt`] trait, the [`CallApiAt`] trait and the [`ConstructRuntimeApi`] trait.
+
+On a meta level this implies, the client calls the generated API from the client perspective.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/api/proc-macro/Cargo.toml b/substrate/primitives/api/proc-macro/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..862cf00fdd67cc3a580c52e21c978b0ab95bc28c
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "sp-api-proc-macro"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Macros for declaring and implementing runtime apis."
+documentation = "https://docs.rs/sp-api-proc-macro"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full", "fold", "extra-traits", "visit"] }
+proc-macro2 = "1.0.56"
+blake2 = { version = "0.10.4", default-features = false }
+proc-macro-crate = "1.1.3"
+expander = "2.0.0"
+Inflector = "0.11.4"
+
+[dev-dependencies]
+assert_matches = "1.3.0"
+
+[features]
+# Required for the doc tests
+default = [ "std" ]
+std = []
+no-metadata-docs = []
+frame-metadata = []
diff --git a/substrate/primitives/api/proc-macro/src/common.rs b/substrate/primitives/api/proc-macro/src/common.rs
new file mode 100644
index 0000000000000000000000000000000000000000..725ad166fbe733996c93d0999ceda51610607f97
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/src/common.rs
@@ -0,0 +1,38 @@
+// 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.
+
+/// The ident used for the block generic parameter.
+pub const BLOCK_GENERIC_IDENT: &str = "Block";
+
+/// The `core_trait` attribute.
+pub const CORE_TRAIT_ATTRIBUTE: &str = "core_trait";
+/// The `api_version` attribute.
+///
+/// Is used to set the current version of the trait.
+pub const API_VERSION_ATTRIBUTE: &str = "api_version";
+/// The `changed_in` attribute.
+///
+/// Is used when the function signature changed between different versions of a trait.
+/// This attribute should be placed on the old signature of the function.
+pub const CHANGED_IN_ATTRIBUTE: &str = "changed_in";
+/// The `renamed` attribute.
+///
+/// Is used when a trait method was renamed.
+pub const RENAMED_ATTRIBUTE: &str = "renamed";
+/// All attributes that we support in the declaration of a runtime api trait.
+pub const SUPPORTED_ATTRIBUTE_NAMES: &[&str] =
+	&[CORE_TRAIT_ATTRIBUTE, API_VERSION_ATTRIBUTE, CHANGED_IN_ATTRIBUTE, RENAMED_ATTRIBUTE];
diff --git a/substrate/primitives/api/proc-macro/src/decl_runtime_apis.rs b/substrate/primitives/api/proc-macro/src/decl_runtime_apis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..370735819f94c1a4a3660dec6ae006f537f1cda5
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/src/decl_runtime_apis.rs
@@ -0,0 +1,738 @@
+// 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::{
+	common::{
+		API_VERSION_ATTRIBUTE, BLOCK_GENERIC_IDENT, CHANGED_IN_ATTRIBUTE, CORE_TRAIT_ATTRIBUTE,
+		RENAMED_ATTRIBUTE, SUPPORTED_ATTRIBUTE_NAMES,
+	},
+	utils::{
+		extract_parameter_names_types_and_borrows, fold_fn_decl_for_client_side,
+		generate_crate_access, generate_runtime_mod_name_for_trait, parse_runtime_api_version,
+		prefix_function_with_trait, replace_wild_card_parameter_names, return_type_extract_type,
+		versioned_trait_name, AllowSelfRefInParameters,
+	},
+};
+
+use proc_macro2::{Span, TokenStream};
+
+use quote::quote;
+
+use syn::{
+	fold::{self, Fold},
+	parse::{Error, Parse, ParseStream, Result},
+	parse_macro_input, parse_quote,
+	spanned::Spanned,
+	token::Comma,
+	visit::{self, Visit},
+	Attribute, FnArg, GenericParam, Generics, Ident, ItemTrait, LitInt, LitStr, TraitBound,
+	TraitItem, TraitItemFn,
+};
+
+use std::collections::{BTreeMap, HashMap};
+
+/// The structure used for parsing the runtime api declarations.
+struct RuntimeApiDecls {
+	decls: Vec<ItemTrait>,
+}
+
+impl Parse for RuntimeApiDecls {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let mut decls = Vec::new();
+
+		while !input.is_empty() {
+			decls.push(ItemTrait::parse(input)?);
+		}
+
+		Ok(Self { decls })
+	}
+}
+
+/// Extend the given generics with `Block: BlockT` as first generic parameter.
+fn extend_generics_with_block(generics: &mut Generics) {
+	let c = generate_crate_access();
+
+	generics.lt_token = Some(Default::default());
+	generics.params.insert(0, parse_quote!( Block: #c::BlockT ));
+	generics.gt_token = Some(Default::default());
+}
+
+/// Remove all attributes from the vector that are supported by us in the declaration of a runtime
+/// api trait. The returned hashmap contains all found attribute names as keys and the rest of the
+/// attribute body as `TokenStream`.
+fn remove_supported_attributes(attrs: &mut Vec<Attribute>) -> HashMap<&'static str, Attribute> {
+	let mut result = HashMap::new();
+	attrs.retain(|v| match SUPPORTED_ATTRIBUTE_NAMES.iter().find(|a| v.path().is_ident(a)) {
+		Some(attribute) => {
+			result.insert(*attribute, v.clone());
+			false
+		},
+		None => true,
+	});
+
+	result
+}
+
+/// Versioned API traits are used to catch missing methods when implementing a specific version of a
+/// versioned API. They contain all non-versioned methods (aka stable methods) from the main trait
+/// and all versioned methods for the specific version. This means that there is one trait for each
+/// version mentioned in the trait definition. For example:
+/// ```ignore
+/// // The trait version implicitly is 1
+/// decl_runtime_apis!(
+/// 	trait SomeApi {
+/// 		fn method1(); 	// this is a 'stable method'
+///
+/// 		#[api_version(2)]
+/// 		fn method2();
+///
+/// 		#[api_version(2)]
+/// 		fn method3();
+///
+/// 		#[api_version(3)]
+/// 		fn method4();
+/// 	}
+/// );
+/// ```
+/// This trait has got three different versions. The function below will generate the following
+/// code:
+/// ```
+/// trait SomeApiV1 {
+/// 	// in V1 only the stable methods are required. The rest has got default implementations.
+/// 	fn method1();
+/// }
+///
+/// trait SomeApiV2 {
+/// 	// V2 contains all methods from V1 and V2. V3 not required so they are skipped.
+/// 	fn method1();
+/// 	fn method2();
+/// 	fn method3();
+/// }
+///
+/// trait SomeApiV3 {
+/// 	// And V3 contains all methods from the trait.
+/// 	fn method1();
+/// 	fn method2();
+/// 	fn method3();
+/// 	fn method4();
+/// }
+/// ```
+fn generate_versioned_api_traits(
+	api: ItemTrait,
+	methods: BTreeMap<u64, Vec<TraitItemFn>>,
+) -> Vec<ItemTrait> {
+	let mut result = Vec::<ItemTrait>::new();
+	for (version, _) in &methods {
+		let mut versioned_trait = api.clone();
+		versioned_trait.ident = versioned_trait_name(&versioned_trait.ident, *version);
+		versioned_trait.items = Vec::new();
+		// Add the methods from the current version and all previous one. Versions are sorted so
+		// it's safe to stop early.
+		for (_, m) in methods.iter().take_while(|(v, _)| v <= &version) {
+			versioned_trait.items.extend(m.iter().cloned().map(|m| TraitItem::Fn(m)));
+		}
+
+		result.push(versioned_trait);
+	}
+
+	result
+}
+
+/// Try to parse the given `Attribute` as `renamed` attribute.
+fn parse_renamed_attribute(renamed: &Attribute) -> Result<(String, u32)> {
+	let err = || {
+		Error::new(
+			renamed.span(),
+			&format!(
+				"Unexpected `{RENAMED_ATTRIBUTE}` attribute. \
+				 The supported format is `{RENAMED_ATTRIBUTE}(\"old_name\", version_it_was_renamed)`",
+			),
+		)
+	};
+
+	renamed
+		.parse_args_with(|input: ParseStream| {
+			let old_name: LitStr = input.parse()?;
+			let _comma: Comma = input.parse()?;
+			let version: LitInt = input.parse()?;
+
+			if !input.is_empty() {
+				return Err(input.error("No more arguments expected"))
+			}
+
+			Ok((old_name.value(), version.base10_parse()?))
+		})
+		.map_err(|_| err())
+}
+
+/// Generate the declaration of the trait for the runtime.
+fn generate_runtime_decls(decls: &[ItemTrait]) -> Result<TokenStream> {
+	let mut result = Vec::new();
+
+	for decl in decls {
+		let mut decl = decl.clone();
+		let decl_span = decl.span();
+		extend_generics_with_block(&mut decl.generics);
+		let mod_name = generate_runtime_mod_name_for_trait(&decl.ident);
+		let found_attributes = remove_supported_attributes(&mut decl.attrs);
+		let api_version =
+			get_api_version(&found_attributes).map(|v| generate_runtime_api_version(v as u32))?;
+		let id = generate_runtime_api_id(&decl.ident.to_string());
+
+		#[cfg(feature = "frame-metadata")]
+		let metadata = crate::runtime_metadata::generate_decl_runtime_metadata(&decl);
+		#[cfg(not(feature = "frame-metadata"))]
+		let metadata = quote!();
+
+		let trait_api_version = get_api_version(&found_attributes)?;
+
+		let mut methods_by_version: BTreeMap<u64, Vec<TraitItemFn>> = BTreeMap::new();
+
+		// Process the items in the declaration. The filter_map function below does a lot of stuff
+		// because the method attributes are stripped at this point
+		decl.items.iter_mut().for_each(|i| match i {
+			TraitItem::Fn(ref mut method) => {
+				let method_attrs = remove_supported_attributes(&mut method.attrs);
+				let mut method_version = trait_api_version;
+				// validate the api version for the method (if any) and generate default
+				// implementation for versioned methods
+				if let Some(version_attribute) = method_attrs.get(API_VERSION_ATTRIBUTE) {
+					method_version = match parse_runtime_api_version(version_attribute) {
+						Ok(method_api_ver) if method_api_ver < trait_api_version => {
+							let method_ver = method_api_ver.to_string();
+							let trait_ver = trait_api_version.to_string();
+							let mut err1 = Error::new(
+								version_attribute.span(),
+								format!(
+										"Method version `{}` is older than (or equal to) trait version `{}`.\
+										 Methods can't define versions older than the trait version.",
+										method_ver,
+										trait_ver,
+									),
+							);
+
+							let err2 = match found_attributes.get(&API_VERSION_ATTRIBUTE) {
+								Some(attr) => Error::new(attr.span(), "Trait version is set here."),
+								None => Error::new(
+									decl_span,
+									"Trait version is not set so it is implicitly equal to 1.",
+								),
+							};
+							err1.combine(err2);
+							result.push(err1.to_compile_error());
+
+							trait_api_version
+						},
+						Ok(method_api_ver) => method_api_ver,
+						Err(e) => {
+							result.push(e.to_compile_error());
+							trait_api_version
+						},
+					};
+				}
+
+				// Any method with the `changed_in` attribute isn't required for the runtime
+				// anymore.
+				if !method_attrs.contains_key(CHANGED_IN_ATTRIBUTE) {
+					// Make sure we replace all the wild card parameter names.
+					replace_wild_card_parameter_names(&mut method.sig);
+
+					// partition methods by api version
+					methods_by_version.entry(method_version).or_default().push(method.clone());
+				}
+			},
+			_ => (),
+		});
+
+		let versioned_api_traits = generate_versioned_api_traits(decl.clone(), methods_by_version);
+
+		let main_api_ident = decl.ident.clone();
+		let versioned_ident = &versioned_api_traits
+			.first()
+			.expect("There should always be at least one version.")
+			.ident;
+
+		result.push(quote!(
+			#[doc(hidden)]
+			#[allow(dead_code)]
+			#[allow(deprecated)]
+			pub mod #mod_name {
+				pub use super::*;
+
+				#( #versioned_api_traits )*
+
+				pub use #versioned_ident as #main_api_ident;
+
+				#metadata
+
+				pub #api_version
+
+				pub #id
+			}
+		));
+	}
+
+	Ok(quote!( #( #result )* ))
+}
+
+/// Modify the given runtime api declaration to be usable on the client side.
+struct ToClientSideDecl<'a> {
+	block_hash: &'a TokenStream,
+	crate_: &'a TokenStream,
+	found_attributes: &'a mut HashMap<&'static str, Attribute>,
+	/// Any error that we found while converting this declaration.
+	errors: &'a mut Vec<TokenStream>,
+	trait_: &'a Ident,
+}
+
+impl<'a> ToClientSideDecl<'a> {
+	/// Process the given [`ItemTrait`].
+	fn process(mut self, decl: ItemTrait) -> ItemTrait {
+		let mut decl = self.fold_item_trait(decl);
+
+		let block_hash = self.block_hash;
+		let crate_ = self.crate_;
+
+		// Add the special method that will be implemented by the `impl_runtime_apis!` macro
+		// to enable functions to call into the runtime.
+		decl.items.push(parse_quote! {
+			/// !!INTERNAL USE ONLY!!
+			#[doc(hidden)]
+			fn __runtime_api_internal_call_api_at(
+				&self,
+				at: #block_hash,
+				params: std::vec::Vec<u8>,
+				fn_name: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
+			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError>;
+		});
+
+		decl
+	}
+}
+
+impl<'a> ToClientSideDecl<'a> {
+	fn fold_item_trait_items(
+		&mut self,
+		items: Vec<TraitItem>,
+		trait_generics_num: usize,
+	) -> Vec<TraitItem> {
+		let mut result = Vec::new();
+
+		items.into_iter().for_each(|i| match i {
+			TraitItem::Fn(method) => {
+				let fn_decl = self.create_method_decl(method, trait_generics_num);
+				result.push(fn_decl.into());
+			},
+			r => result.push(r),
+		});
+
+		result
+	}
+
+	/// Takes the method declared by the user and creates the declaration we require for the runtime
+	/// api client side. This method will call by default the `method_runtime_api_impl` for doing
+	/// the actual call into the runtime.
+	fn create_method_decl(
+		&mut self,
+		mut method: TraitItemFn,
+		trait_generics_num: usize,
+	) -> TraitItemFn {
+		let params = match extract_parameter_names_types_and_borrows(
+			&method.sig,
+			AllowSelfRefInParameters::No,
+		) {
+			Ok(res) => res.into_iter().map(|v| v.0).collect::<Vec<_>>(),
+			Err(e) => {
+				self.errors.push(e.to_compile_error());
+				Vec::new()
+			},
+		};
+		let ret_type = return_type_extract_type(&method.sig.output);
+
+		fold_fn_decl_for_client_side(&mut method.sig, self.block_hash, self.crate_);
+
+		let crate_ = self.crate_;
+
+		let found_attributes = remove_supported_attributes(&mut method.attrs);
+
+		// Parse the renamed attributes.
+		let mut renames = Vec::new();
+		for (_, a) in found_attributes.iter().filter(|a| a.0 == &RENAMED_ATTRIBUTE) {
+			match parse_renamed_attribute(a) {
+				Ok((old_name, version)) => {
+					renames.push((version, prefix_function_with_trait(&self.trait_, &old_name)));
+				},
+				Err(e) => self.errors.push(e.to_compile_error()),
+			}
+		}
+
+		renames.sort_by(|l, r| r.cmp(l));
+		let (versions, old_names) = renames.into_iter().fold(
+			(Vec::new(), Vec::new()),
+			|(mut versions, mut old_names), (version, old_name)| {
+				versions.push(version);
+				old_names.push(old_name);
+				(versions, old_names)
+			},
+		);
+
+		// Generate the function name before we may rename it below to
+		// `function_name_before_version_{}`.
+		let function_name = prefix_function_with_trait(&self.trait_, &method.sig.ident);
+
+		// If the method has a `changed_in` attribute, we need to alter the method name to
+		// `method_before_version_VERSION`.
+		match get_changed_in(&found_attributes) {
+			Ok(Some(version)) => {
+				// Make sure that the `changed_in` version is at least the current `api_version`.
+				if get_api_version(self.found_attributes).ok() < Some(version) {
+					self.errors.push(
+						Error::new(
+							method.span(),
+							"`changed_in` version can not be greater than the `api_version`",
+						)
+						.to_compile_error(),
+					);
+				}
+
+				let ident = Ident::new(
+					&format!("{}_before_version_{}", method.sig.ident, version),
+					method.sig.ident.span(),
+				);
+				method.sig.ident = ident;
+				method.attrs.push(parse_quote!( #[deprecated] ));
+			},
+			Ok(None) => {},
+			Err(e) => {
+				self.errors.push(e.to_compile_error());
+			},
+		};
+
+		// The module where the runtime relevant stuff is declared.
+		let trait_name = &self.trait_;
+		let runtime_mod = generate_runtime_mod_name_for_trait(trait_name);
+		let underscores = (0..trait_generics_num).map(|_| quote!(_));
+
+		// Generate the default implementation that calls the `method_runtime_api_impl` method.
+		method.default = Some(parse_quote! {
+			{
+				let __runtime_api_impl_params_encoded__ =
+					#crate_::Encode::encode(&( #( &#params ),* ));
+
+				<Self as #trait_name<#( #underscores ),*>>::__runtime_api_internal_call_api_at(
+					self,
+					__runtime_api_at_param__,
+					__runtime_api_impl_params_encoded__,
+					&|_version| {
+						#(
+							// Check if we need to call the function by an old name.
+							if _version.apis.iter().any(|(s, v)| {
+								s == &#runtime_mod::ID && *v < #versions
+							}) {
+								return #old_names
+							}
+						)*
+
+						#function_name
+					}
+				)
+				.and_then(|r|
+					std::result::Result::map_err(
+						<#ret_type as #crate_::Decode>::decode(&mut &r[..]),
+						|err| #crate_::ApiError::FailedToDecodeReturnValue {
+							function: #function_name,
+							error: err,
+						}
+					)
+				)
+			}
+		});
+
+		method
+	}
+}
+
+impl<'a> Fold for ToClientSideDecl<'a> {
+	fn fold_item_trait(&mut self, mut input: ItemTrait) -> ItemTrait {
+		extend_generics_with_block(&mut input.generics);
+
+		*self.found_attributes = remove_supported_attributes(&mut input.attrs);
+		// Check if this is the `Core` runtime api trait.
+		let is_core_trait = self.found_attributes.contains_key(CORE_TRAIT_ATTRIBUTE);
+		let block_ident = Ident::new(BLOCK_GENERIC_IDENT, Span::call_site());
+
+		if is_core_trait {
+			// Add all the supertraits we want to have for `Core`.
+			input.supertraits = parse_quote!('static + Send);
+		} else {
+			// Add the `Core` runtime api as super trait.
+			let crate_ = &self.crate_;
+			input.supertraits.push(parse_quote!( #crate_::Core<#block_ident> ));
+		}
+
+		input.items = self.fold_item_trait_items(input.items, input.generics.params.len());
+
+		fold::fold_item_trait(self, input)
+	}
+}
+
+/// Generates the identifier as const variable for the given `trait_name`
+/// by hashing the `trait_name`.
+fn generate_runtime_api_id(trait_name: &str) -> TokenStream {
+	use blake2::digest::{consts::U8, Digest};
+
+	let mut res = [0; 8];
+	res.copy_from_slice(blake2::Blake2b::<U8>::digest(trait_name).as_slice());
+
+	quote!( const ID: [u8; 8] = [ #( #res ),* ]; )
+}
+
+/// Generates the const variable that holds the runtime api version.
+fn generate_runtime_api_version(version: u32) -> TokenStream {
+	quote!( const VERSION: u32 = #version; )
+}
+
+/// Generates the implementation of `RuntimeApiInfo` for the given trait.
+fn generate_runtime_info_impl(trait_: &ItemTrait, version: u64) -> TokenStream {
+	let trait_name = &trait_.ident;
+	let crate_ = generate_crate_access();
+	let id = generate_runtime_api_id(&trait_name.to_string());
+	let version = generate_runtime_api_version(version as u32);
+
+	let impl_generics = trait_.generics.type_params().map(|t| {
+		let ident = &t.ident;
+		let colon_token = &t.colon_token;
+		let bounds = &t.bounds;
+
+		quote! { #ident #colon_token #bounds }
+	});
+
+	let ty_generics = trait_.generics.type_params().map(|t| {
+		let ident = &t.ident;
+		quote! { #ident }
+	});
+
+	quote!(
+		#crate_::std_enabled! {
+			impl < #( #impl_generics, )* > #crate_::RuntimeApiInfo
+				for dyn #trait_name < #( #ty_generics, )* >
+			{
+				#id
+				#version
+			}
+		}
+	)
+}
+
+/// Get changed in version from the user given attribute or `Ok(None)`, if no attribute was given.
+fn get_changed_in(found_attributes: &HashMap<&'static str, Attribute>) -> Result<Option<u64>> {
+	found_attributes
+		.get(&CHANGED_IN_ATTRIBUTE)
+		.map(|v| parse_runtime_api_version(v).map(Some))
+		.unwrap_or(Ok(None))
+}
+
+/// Get the api version from the user given attribute or `Ok(1)`, if no attribute was given.
+fn get_api_version(found_attributes: &HashMap<&'static str, Attribute>) -> Result<u64> {
+	found_attributes
+		.get(&API_VERSION_ATTRIBUTE)
+		.map(parse_runtime_api_version)
+		.unwrap_or(Ok(1))
+}
+
+/// Generate the declaration of the trait for the client side.
+fn generate_client_side_decls(decls: &[ItemTrait]) -> Result<TokenStream> {
+	let mut result = Vec::new();
+
+	for decl in decls {
+		let decl = decl.clone();
+
+		let crate_ = generate_crate_access();
+		let block_hash = quote!( <Block as #crate_::BlockT>::Hash );
+		let mut found_attributes = HashMap::new();
+		let mut errors = Vec::new();
+		let trait_ = decl.ident.clone();
+
+		let decl = ToClientSideDecl {
+			crate_: &crate_,
+			block_hash: &block_hash,
+			found_attributes: &mut found_attributes,
+			errors: &mut errors,
+			trait_: &trait_,
+		}
+		.process(decl);
+
+		let api_version = get_api_version(&found_attributes);
+
+		let runtime_info = api_version.map(|v| generate_runtime_info_impl(&decl, v))?;
+
+		result.push(quote!(
+			#crate_::std_enabled! { #decl }
+			#runtime_info
+			#( #errors )*
+		));
+	}
+
+	Ok(quote!( #( #result )* ))
+}
+
+/// Checks that a trait declaration is in the format we expect.
+struct CheckTraitDecl {
+	errors: Vec<Error>,
+}
+
+impl CheckTraitDecl {
+	/// Check the given trait.
+	///
+	/// All errors will be collected in `self.errors`.
+	fn check(&mut self, trait_: &ItemTrait) {
+		self.check_method_declarations(trait_.items.iter().filter_map(|i| match i {
+			TraitItem::Fn(method) => Some(method),
+			_ => None,
+		}));
+
+		visit::visit_item_trait(self, trait_);
+	}
+
+	/// Check that the given method declarations are correct.
+	///
+	/// Any error is stored in `self.errors`.
+	fn check_method_declarations<'a>(&mut self, methods: impl Iterator<Item = &'a TraitItemFn>) {
+		let mut method_to_signature_changed = HashMap::<Ident, Vec<Option<u64>>>::new();
+
+		methods.into_iter().for_each(|method| {
+			let attributes = remove_supported_attributes(&mut method.attrs.clone());
+
+			let changed_in = match get_changed_in(&attributes) {
+				Ok(r) => r,
+				Err(e) => {
+					self.errors.push(e);
+					return
+				},
+			};
+
+			method_to_signature_changed
+				.entry(method.sig.ident.clone())
+				.or_default()
+				.push(changed_in);
+
+			if method.default.is_some() {
+				self.errors.push(Error::new(
+					method.default.span(),
+					"A runtime API function cannot have a default implementation!",
+				));
+			}
+		});
+
+		method_to_signature_changed.into_iter().for_each(|(f, changed)| {
+			// If `changed_in` is `None`, it means it is the current "default" method that calls
+			// into the latest implementation.
+			if changed.iter().filter(|c| c.is_none()).count() == 0 {
+				self.errors.push(Error::new(
+					f.span(),
+					"There is no 'default' method with this name (without `changed_in` attribute).\n\
+					 The 'default' method is used to call into the latest implementation.",
+				));
+			}
+		});
+	}
+}
+
+impl<'ast> Visit<'ast> for CheckTraitDecl {
+	fn visit_fn_arg(&mut self, input: &'ast FnArg) {
+		if let FnArg::Receiver(_) = input {
+			self.errors.push(Error::new(input.span(), "`self` as argument not supported."))
+		}
+
+		visit::visit_fn_arg(self, input);
+	}
+
+	fn visit_generic_param(&mut self, input: &'ast GenericParam) {
+		match input {
+			GenericParam::Type(ty) if ty.ident == BLOCK_GENERIC_IDENT =>
+				self.errors.push(Error::new(
+					input.span(),
+					"`Block: BlockT` generic parameter will be added automatically by the \
+						`decl_runtime_apis!` macro!",
+				)),
+			_ => {},
+		}
+
+		visit::visit_generic_param(self, input);
+	}
+
+	fn visit_trait_bound(&mut self, input: &'ast TraitBound) {
+		if let Some(last_ident) = input.path.segments.last().map(|v| &v.ident) {
+			if last_ident == "BlockT" || last_ident == BLOCK_GENERIC_IDENT {
+				self.errors.push(Error::new(
+					input.span(),
+					"`Block: BlockT` generic parameter will be added automatically by the \
+						`decl_runtime_apis!` macro! If you try to use a different trait than the \
+						substrate `Block` trait, please rename it locally.",
+				))
+			}
+		}
+
+		visit::visit_trait_bound(self, input)
+	}
+}
+
+/// Check that the trait declarations are in the format we expect.
+fn check_trait_decls(decls: &[ItemTrait]) -> Result<()> {
+	let mut checker = CheckTraitDecl { errors: Vec::new() };
+	decls.iter().for_each(|decl| checker.check(decl));
+
+	if let Some(err) = checker.errors.pop() {
+		Err(checker.errors.into_iter().fold(err, |mut err, other| {
+			err.combine(other);
+			err
+		}))
+	} else {
+		Ok(())
+	}
+}
+
+/// The implementation of the `decl_runtime_apis!` macro.
+pub fn decl_runtime_apis_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	// Parse all trait declarations
+	let RuntimeApiDecls { decls: api_decls } = parse_macro_input!(input as RuntimeApiDecls);
+
+	decl_runtime_apis_impl_inner(&api_decls)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+fn decl_runtime_apis_impl_inner(api_decls: &[ItemTrait]) -> Result<TokenStream> {
+	check_trait_decls(api_decls)?;
+
+	let runtime_decls = generate_runtime_decls(api_decls)?;
+	let client_side_decls = generate_client_side_decls(api_decls)?;
+
+	let decl = quote! {
+		#runtime_decls
+
+		#client_side_decls
+	};
+
+	let decl = expander::Expander::new("decl_runtime_apis")
+		.dry(std::env::var("SP_API_EXPAND").is_err())
+		.verbose(true)
+		.write_to_out_dir(decl)
+		.expect("Does not fail because of IO in OUT_DIR; qed");
+
+	Ok(decl)
+}
diff --git a/substrate/primitives/api/proc-macro/src/impl_runtime_apis.rs b/substrate/primitives/api/proc-macro/src/impl_runtime_apis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74cfa0980623b0dd14c029c520093bd775f4da4d
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/src/impl_runtime_apis.rs
@@ -0,0 +1,957 @@
+// 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::{
+	common::API_VERSION_ATTRIBUTE,
+	utils::{
+		extract_all_signature_types, extract_block_type_from_trait_path, extract_impl_trait,
+		extract_parameter_names_types_and_borrows, generate_crate_access,
+		generate_runtime_mod_name_for_trait, parse_runtime_api_version, prefix_function_with_trait,
+		versioned_trait_name, AllowSelfRefInParameters, RequireQualifiedTraitPath,
+	},
+};
+
+use proc_macro2::{Span, TokenStream};
+
+use quote::quote;
+
+use syn::{
+	fold::{self, Fold},
+	parenthesized,
+	parse::{Error, Parse, ParseStream, Result},
+	parse_macro_input, parse_quote,
+	spanned::Spanned,
+	Attribute, Ident, ImplItem, ItemImpl, LitInt, LitStr, Path, Signature, Type, TypePath,
+};
+
+use std::collections::HashSet;
+
+/// The structure used for parsing the runtime api implementations.
+struct RuntimeApiImpls {
+	impls: Vec<ItemImpl>,
+}
+
+impl Parse for RuntimeApiImpls {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let mut impls = Vec::new();
+
+		while !input.is_empty() {
+			impls.push(ItemImpl::parse(input)?);
+		}
+
+		if impls.is_empty() {
+			Err(Error::new(Span::call_site(), "No api implementation given!"))
+		} else {
+			Ok(Self { impls })
+		}
+	}
+}
+
+/// Generates the call to the implementation of the requested function.
+/// The generated code includes decoding of the input arguments and encoding of the output.
+fn generate_impl_call(
+	signature: &Signature,
+	runtime: &Type,
+	input: &Ident,
+	impl_trait: &Path,
+	api_version: &ApiVersion,
+) -> Result<TokenStream> {
+	let params =
+		extract_parameter_names_types_and_borrows(signature, AllowSelfRefInParameters::No)?;
+
+	let c = generate_crate_access();
+	let fn_name = &signature.ident;
+	let fn_name_str = fn_name.to_string();
+	let pnames = params.iter().map(|v| &v.0);
+	let pnames2 = params.iter().map(|v| &v.0);
+	let ptypes = params.iter().map(|v| &v.1);
+	let pborrow = params.iter().map(|v| &v.2);
+
+	let decode_params = if params.is_empty() {
+		quote!(
+			if !#input.is_empty() {
+				panic!(
+					"Bad input data provided to {}: expected no parameters, but input buffer is not empty.",
+					#fn_name_str
+				);
+			}
+		)
+	} else {
+		let let_binding = if params.len() == 1 {
+			quote! {
+				let #( #pnames )* : #( #ptypes )*
+			}
+		} else {
+			quote! {
+				let ( #( #pnames ),* ) : ( #( #ptypes ),* )
+			}
+		};
+
+		quote!(
+			#let_binding =
+				match #c::DecodeLimit::decode_all_with_depth_limit(
+					#c::MAX_EXTRINSIC_DEPTH,
+					&mut #input,
+				) {
+					Ok(res) => res,
+					Err(e) => panic!("Bad input data provided to {}: {}", #fn_name_str, e),
+				};
+		)
+	};
+
+	let fn_calls = if let Some(feature_gated) = &api_version.feature_gated {
+		let pnames = pnames2;
+		let pnames2 = pnames.clone();
+		let pborrow2 = pborrow.clone();
+
+		let feature_name = &feature_gated.0;
+		let impl_trait_fg = extend_with_api_version(impl_trait.clone(), Some(feature_gated.1));
+		let impl_trait = extend_with_api_version(impl_trait.clone(), api_version.custom);
+
+		quote!(
+			#[cfg(feature = #feature_name)]
+			#[allow(deprecated)]
+			let r = <#runtime as #impl_trait_fg>::#fn_name(#( #pborrow #pnames ),*);
+
+			#[cfg(not(feature = #feature_name))]
+			#[allow(deprecated)]
+			let r = <#runtime as #impl_trait>::#fn_name(#( #pborrow2 #pnames2 ),*);
+
+			r
+		)
+	} else {
+		let pnames = pnames2;
+		let impl_trait = extend_with_api_version(impl_trait.clone(), api_version.custom);
+
+		quote!(
+			#[allow(deprecated)]
+			<#runtime as #impl_trait>::#fn_name(#( #pborrow #pnames ),*)
+		)
+	};
+
+	Ok(quote!(
+		#decode_params
+
+		#fn_calls
+	))
+}
+
+/// Generate all the implementation calls for the given functions.
+fn generate_impl_calls(
+	impls: &[ItemImpl],
+	input: &Ident,
+) -> Result<Vec<(Ident, Ident, TokenStream, Vec<Attribute>)>> {
+	let mut impl_calls = Vec::new();
+
+	for impl_ in impls {
+		let trait_api_ver = extract_api_version(&impl_.attrs, impl_.span())?;
+		let impl_trait_path = extract_impl_trait(impl_, RequireQualifiedTraitPath::Yes)?;
+		let impl_trait = extend_with_runtime_decl_path(impl_trait_path.clone());
+		let impl_trait_ident = &impl_trait_path
+			.segments
+			.last()
+			.ok_or_else(|| Error::new(impl_trait_path.span(), "Empty trait path not possible!"))?
+			.ident;
+
+		for item in &impl_.items {
+			if let ImplItem::Fn(method) = item {
+				let impl_call = generate_impl_call(
+					&method.sig,
+					&impl_.self_ty,
+					input,
+					&impl_trait,
+					&trait_api_ver,
+				)?;
+				let mut attrs = filter_cfg_attrs(&impl_.attrs);
+
+				// Add any `#[cfg(feature = X)]` attributes of the method to result
+				attrs.extend(filter_cfg_attrs(&method.attrs));
+
+				impl_calls.push((
+					impl_trait_ident.clone(),
+					method.sig.ident.clone(),
+					impl_call,
+					attrs,
+				));
+			}
+		}
+	}
+
+	Ok(impl_calls)
+}
+
+/// Generate the dispatch function that is used in native to call into the runtime.
+fn generate_dispatch_function(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let data = Ident::new("_sp_api_input_data_", Span::call_site());
+	let c = generate_crate_access();
+	let impl_calls =
+		generate_impl_calls(impls, &data)?
+			.into_iter()
+			.map(|(trait_, fn_name, impl_, attrs)| {
+				let name = prefix_function_with_trait(&trait_, &fn_name);
+				quote!(
+					#( #attrs )*
+					#name => Some(#c::Encode::encode(&{ #impl_ })),
+				)
+			});
+
+	Ok(quote!(
+		#c::std_enabled! {
+			pub fn dispatch(method: &str, mut #data: &[u8]) -> Option<Vec<u8>> {
+				match method {
+					#( #impl_calls )*
+					_ => None,
+				}
+			}
+		}
+	))
+}
+
+/// Generate the interface functions that are used to call into the runtime in wasm.
+fn generate_wasm_interface(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let input = Ident::new("input", Span::call_site());
+	let c = generate_crate_access();
+
+	let impl_calls =
+		generate_impl_calls(impls, &input)?
+			.into_iter()
+			.map(|(trait_, fn_name, impl_, attrs)| {
+				let fn_name =
+					Ident::new(&prefix_function_with_trait(&trait_, &fn_name), Span::call_site());
+
+				quote!(
+					#c::std_disabled! {
+						#( #attrs )*
+						#[no_mangle]
+						pub unsafe fn #fn_name(input_data: *mut u8, input_len: usize) -> u64 {
+							let mut #input = if input_len == 0 {
+								&[0u8; 0]
+							} else {
+								unsafe {
+									#c::slice::from_raw_parts(input_data, input_len)
+								}
+							};
+
+							#c::init_runtime_logger();
+
+							let output = (move || { #impl_ })();
+							#c::to_substrate_wasm_fn_return_value(&output)
+						}
+					}
+				)
+			});
+
+	Ok(quote!( #( #impl_calls )* ))
+}
+
+fn generate_runtime_api_base_structures() -> Result<TokenStream> {
+	let crate_ = generate_crate_access();
+
+	Ok(quote!(
+		pub struct RuntimeApi {}
+		#crate_::std_enabled! {
+			/// Implements all runtime apis for the client side.
+			pub struct RuntimeApiImpl<Block: #crate_::BlockT, C: #crate_::CallApiAt<Block> + 'static> {
+				call: &'static C,
+				transaction_depth: std::cell::RefCell<u16>,
+				changes: std::cell::RefCell<#crate_::OverlayedChanges<#crate_::HashingFor<Block>>>,
+				recorder: std::option::Option<#crate_::ProofRecorder<Block>>,
+				call_context: #crate_::CallContext,
+				extensions: std::cell::RefCell<#crate_::Extensions>,
+				extensions_generated_for: std::cell::RefCell<std::option::Option<Block::Hash>>,
+			}
+
+			impl<Block: #crate_::BlockT, C: #crate_::CallApiAt<Block>> #crate_::ApiExt<Block> for
+				RuntimeApiImpl<Block, C>
+			{
+				fn execute_in_transaction<F: FnOnce(&Self) -> #crate_::TransactionOutcome<R>, R>(
+					&self,
+					call: F,
+				) -> R where Self: Sized {
+					self.start_transaction();
+
+					*std::cell::RefCell::borrow_mut(&self.transaction_depth) += 1;
+					let res = call(self);
+					std::cell::RefCell::borrow_mut(&self.transaction_depth)
+						.checked_sub(1)
+						.expect("Transactions are opened and closed together; qed");
+
+					self.commit_or_rollback_transaction(
+						std::matches!(res, #crate_::TransactionOutcome::Commit(_))
+					);
+
+					res.into_inner()
+				}
+
+				fn has_api<A: #crate_::RuntimeApiInfo + ?Sized>(
+					&self,
+					at: <Block as #crate_::BlockT>::Hash,
+				) -> std::result::Result<bool, #crate_::ApiError> where Self: Sized {
+					#crate_::CallApiAt::<Block>::runtime_version_at(self.call, at)
+					.map(|v| #crate_::RuntimeVersion::has_api_with(&v, &A::ID, |v| v == A::VERSION))
+				}
+
+				fn has_api_with<A: #crate_::RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>(
+					&self,
+					at: <Block as #crate_::BlockT>::Hash,
+					pred: P,
+				) -> std::result::Result<bool, #crate_::ApiError> where Self: Sized {
+					#crate_::CallApiAt::<Block>::runtime_version_at(self.call, at)
+					.map(|v| #crate_::RuntimeVersion::has_api_with(&v, &A::ID, pred))
+				}
+
+				fn api_version<A: #crate_::RuntimeApiInfo + ?Sized>(
+					&self,
+					at: <Block as #crate_::BlockT>::Hash,
+				) -> std::result::Result<Option<u32>, #crate_::ApiError> where Self: Sized {
+					#crate_::CallApiAt::<Block>::runtime_version_at(self.call, at)
+					.map(|v| #crate_::RuntimeVersion::api_version(&v, &A::ID))
+				}
+
+				fn record_proof(&mut self) {
+					self.recorder = std::option::Option::Some(std::default::Default::default());
+				}
+
+				fn proof_recorder(&self) -> std::option::Option<#crate_::ProofRecorder<Block>> {
+					std::clone::Clone::clone(&self.recorder)
+				}
+
+				fn extract_proof(
+					&mut self,
+				) -> std::option::Option<#crate_::StorageProof> {
+					let recorder = std::option::Option::take(&mut self.recorder);
+					std::option::Option::map(recorder, |recorder| {
+						#crate_::ProofRecorder::<Block>::drain_storage_proof(recorder)
+					})
+				}
+
+				fn into_storage_changes<B: #crate_::StateBackend<#crate_::HashingFor<Block>>>(
+					&self,
+					backend: &B,
+					parent_hash: Block::Hash,
+				) -> core::result::Result<
+					#crate_::StorageChanges<Block>,
+				String
+					> where Self: Sized {
+						let state_version = #crate_::CallApiAt::<Block>::runtime_version_at(self.call, std::clone::Clone::clone(&parent_hash))
+							.map(|v| #crate_::RuntimeVersion::state_version(&v))
+							.map_err(|e| format!("Failed to get state version: {}", e))?;
+
+						#crate_::OverlayedChanges::drain_storage_changes(
+							&mut std::cell::RefCell::borrow_mut(&self.changes),
+							backend,
+							state_version,
+						)
+					}
+
+				fn set_call_context(&mut self, call_context: #crate_::CallContext) {
+					self.call_context = call_context;
+				}
+
+				fn register_extension<E: #crate_::Extension>(&mut self, extension: E) {
+					std::cell::RefCell::borrow_mut(&self.extensions).register(extension);
+				}
+			}
+
+			impl<Block: #crate_::BlockT, C> #crate_::ConstructRuntimeApi<Block, C>
+				for RuntimeApi
+			where
+				C: #crate_::CallApiAt<Block> + 'static,
+			{
+				type RuntimeApi = RuntimeApiImpl<Block, C>;
+
+				fn construct_runtime_api<'a>(
+					call: &'a C,
+				) -> #crate_::ApiRef<'a, Self::RuntimeApi> {
+					RuntimeApiImpl {
+						call: unsafe { std::mem::transmute(call) },
+						transaction_depth: 0.into(),
+						changes: std::default::Default::default(),
+						recorder: std::default::Default::default(),
+						call_context: #crate_::CallContext::Offchain,
+						extensions: std::default::Default::default(),
+						extensions_generated_for: std::default::Default::default(),
+					}.into()
+				}
+			}
+
+			impl<Block: #crate_::BlockT, C: #crate_::CallApiAt<Block>> RuntimeApiImpl<Block, C> {
+				fn commit_or_rollback_transaction(&self, commit: bool) {
+					let proof = "\
+					We only close a transaction when we opened one ourself.
+					Other parts of the runtime that make use of transactions (state-machine)
+					also balance their transactions. The runtime cannot close client initiated
+					transactions; qed";
+
+					let res = if commit {
+						let res = if let Some(recorder) = &self.recorder {
+							#crate_::ProofRecorder::<Block>::commit_transaction(&recorder)
+						} else {
+							Ok(())
+						};
+
+						let res2 = #crate_::OverlayedChanges::commit_transaction(
+							&mut std::cell::RefCell::borrow_mut(&self.changes)
+						);
+
+						// Will panic on an `Err` below, however we should call commit
+						// on the recorder and the changes together.
+						std::result::Result::and(res, std::result::Result::map_err(res2, drop))
+					} else {
+						let res = if let Some(recorder) = &self.recorder {
+							#crate_::ProofRecorder::<Block>::rollback_transaction(&recorder)
+						} else {
+							Ok(())
+						};
+
+						let res2 = #crate_::OverlayedChanges::rollback_transaction(
+							&mut std::cell::RefCell::borrow_mut(&self.changes)
+						);
+
+						// Will panic on an `Err` below, however we should call commit
+						// on the recorder and the changes together.
+						std::result::Result::and(res, std::result::Result::map_err(res2, drop))
+					};
+
+					std::result::Result::expect(res, proof);
+				}
+
+				fn start_transaction(&self) {
+					#crate_::OverlayedChanges::start_transaction(
+						&mut std::cell::RefCell::borrow_mut(&self.changes)
+					);
+					if let Some(recorder) = &self.recorder {
+						#crate_::ProofRecorder::<Block>::start_transaction(&recorder);
+					}
+				}
+			}
+		}
+	))
+}
+
+/// Extend the given trait path with module that contains the declaration of the trait for the
+/// runtime.
+fn extend_with_runtime_decl_path(mut trait_: Path) -> Path {
+	let runtime = {
+		let trait_name = &trait_
+			.segments
+			.last()
+			.as_ref()
+			.expect("Trait path should always contain at least one item; qed")
+			.ident;
+
+		generate_runtime_mod_name_for_trait(trait_name)
+	};
+
+	let pos = trait_.segments.len() - 1;
+	trait_.segments.insert(pos, runtime.into());
+	trait_
+}
+
+fn extend_with_api_version(mut trait_: Path, version: Option<u64>) -> Path {
+	let version = if let Some(v) = version {
+		v
+	} else {
+		// nothing to do
+		return trait_
+	};
+
+	let trait_name = &mut trait_
+		.segments
+		.last_mut()
+		.expect("Trait path should always contain at least one item; qed")
+		.ident;
+	*trait_name = versioned_trait_name(trait_name, version);
+
+	trait_
+}
+
+/// Adds a feature guard to `attributes`.
+///
+/// Depending on `enable`, the feature guard either enables ('feature = "something"`) or disables
+/// (`not(feature = "something")`).
+fn add_feature_guard(attrs: &mut Vec<Attribute>, feature_name: &str, enable: bool) {
+	let attr = match enable {
+		true => parse_quote!(#[cfg(feature = #feature_name)]),
+		false => parse_quote!(#[cfg(not(feature = #feature_name))]),
+	};
+	attrs.push(attr);
+}
+
+/// Generates the implementations of the apis for the runtime.
+fn generate_api_impl_for_runtime(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let mut impls_prepared = Vec::new();
+
+	// We put `runtime` before each trait to get the trait that is intended for the runtime and
+	// we put the `RuntimeBlock` as first argument for the trait generics.
+	for impl_ in impls.iter() {
+		let trait_api_ver = extract_api_version(&impl_.attrs, impl_.span())?;
+
+		let mut impl_ = impl_.clone();
+		impl_.attrs = filter_cfg_attrs(&impl_.attrs);
+
+		let trait_ = extract_impl_trait(&impl_, RequireQualifiedTraitPath::Yes)?.clone();
+		let trait_ = extend_with_runtime_decl_path(trait_);
+		// If the trait api contains feature gated version - there are staging methods in it. Handle
+		// them explicitly here by adding staging implementation with `#cfg(feature = ...)` and
+		// stable implementation with `#[cfg(not(feature = ...))]`.
+		if let Some(feature_gated) = trait_api_ver.feature_gated {
+			let mut feature_gated_impl = impl_.clone();
+			add_feature_guard(&mut feature_gated_impl.attrs, &feature_gated.0, true);
+			feature_gated_impl.trait_.as_mut().unwrap().1 =
+				extend_with_api_version(trait_.clone(), Some(feature_gated.1));
+
+			impls_prepared.push(feature_gated_impl);
+
+			// Finally add `#[cfg(not(feature = ...))]` for the stable implementation (which is
+			// generated outside this if).
+			add_feature_guard(&mut impl_.attrs, &feature_gated.0, false);
+		}
+
+		// Generate stable trait implementation.
+		let trait_ = extend_with_api_version(trait_, trait_api_ver.custom);
+		impl_.trait_.as_mut().unwrap().1 = trait_;
+		impls_prepared.push(impl_);
+	}
+
+	Ok(quote!( #( #impls_prepared )* ))
+}
+
+/// Auxiliary data structure that is used to convert `impl Api for Runtime` to
+/// `impl Api for RuntimeApi`.
+/// This requires us to replace the runtime `Block` with the node `Block`,
+/// `impl Api for Runtime` with `impl Api for RuntimeApi` and replace the method implementations
+/// with code that calls into the runtime.
+struct ApiRuntimeImplToApiRuntimeApiImpl<'a> {
+	runtime_block: &'a TypePath,
+}
+
+impl<'a> ApiRuntimeImplToApiRuntimeApiImpl<'a> {
+	/// Process the given item implementation.
+	fn process(mut self, input: ItemImpl) -> ItemImpl {
+		let mut input = self.fold_item_impl(input);
+
+		let crate_ = generate_crate_access();
+
+		// Delete all functions, because all of them are default implemented by
+		// `decl_runtime_apis!`. We only need to implement the `__runtime_api_internal_call_api_at`
+		// function.
+		input.items.clear();
+		input.items.push(parse_quote! {
+			fn __runtime_api_internal_call_api_at(
+				&self,
+				at: <__SrApiBlock__ as #crate_::BlockT>::Hash,
+				params: std::vec::Vec<u8>,
+				fn_name: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
+			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError> {
+				// If we are not already in a transaction, we should create a new transaction
+				// and then commit/roll it back at the end!
+				let transaction_depth = *std::cell::RefCell::borrow(&self.transaction_depth);
+
+				if transaction_depth == 0 {
+					self.start_transaction();
+				}
+
+				let res = (|| {
+					let version = #crate_::CallApiAt::<__SrApiBlock__>::runtime_version_at(
+						self.call,
+						at,
+					)?;
+
+					match &mut *std::cell::RefCell::borrow_mut(&self.extensions_generated_for) {
+						Some(generated_for) => {
+							if *generated_for != at {
+								return std::result::Result::Err(
+									#crate_::ApiError::UsingSameInstanceForDifferentBlocks
+								)
+							}
+						},
+						generated_for @ None => {
+							#crate_::CallApiAt::<__SrApiBlock__>::initialize_extensions(
+								self.call,
+								at,
+								&mut std::cell::RefCell::borrow_mut(&self.extensions),
+							)?;
+
+							*generated_for = Some(at);
+						}
+					}
+
+					let params = #crate_::CallApiAtParams {
+						at,
+						function: (*fn_name)(version),
+						arguments: params,
+						overlayed_changes: &self.changes,
+						call_context: self.call_context,
+						recorder: &self.recorder,
+						extensions: &self.extensions,
+					};
+
+					#crate_::CallApiAt::<__SrApiBlock__>::call_api_at(
+						self.call,
+						params,
+					)
+				})();
+
+				if transaction_depth == 0 {
+					self.commit_or_rollback_transaction(std::result::Result::is_ok(&res));
+				}
+
+				res
+			}
+		});
+
+		input
+	}
+}
+
+impl<'a> Fold for ApiRuntimeImplToApiRuntimeApiImpl<'a> {
+	fn fold_type_path(&mut self, input: TypePath) -> TypePath {
+		let new_ty_path =
+			if input == *self.runtime_block { parse_quote!(__SrApiBlock__) } else { input };
+
+		fold::fold_type_path(self, new_ty_path)
+	}
+
+	fn fold_item_impl(&mut self, mut input: ItemImpl) -> ItemImpl {
+		// All this `UnwindSafe` magic below here is required for this rust bug:
+		// https://github.com/rust-lang/rust/issues/24159
+		// Before we directly had the final block type and rust could determine that it is unwind
+		// safe, but now we just have a generic parameter `Block`.
+
+		let crate_ = generate_crate_access();
+
+		// Implement the trait for the `RuntimeApiImpl`
+		input.self_ty =
+			Box::new(parse_quote!( RuntimeApiImpl<__SrApiBlock__, RuntimeApiImplCall> ));
+
+		input.generics.params.push(parse_quote!(
+			__SrApiBlock__: #crate_::BlockT + std::panic::UnwindSafe +
+				std::panic::RefUnwindSafe
+		));
+		input
+			.generics
+			.params
+			.push(parse_quote!( RuntimeApiImplCall: #crate_::CallApiAt<__SrApiBlock__> + 'static ));
+
+		let where_clause = input.generics.make_where_clause();
+
+		where_clause.predicates.push(parse_quote! {
+			RuntimeApiImplCall::StateBackend:
+				#crate_::StateBackend<#crate_::HashingFor<__SrApiBlock__>>
+		});
+
+		where_clause.predicates.push(parse_quote! { &'static RuntimeApiImplCall: Send });
+
+		// Require that all types used in the function signatures are unwind safe.
+		extract_all_signature_types(&input.items).iter().for_each(|i| {
+			where_clause.predicates.push(parse_quote! {
+				#i: std::panic::UnwindSafe + std::panic::RefUnwindSafe
+			});
+		});
+
+		where_clause.predicates.push(parse_quote! {
+			__SrApiBlock__::Header: std::panic::UnwindSafe + std::panic::RefUnwindSafe
+		});
+
+		input.attrs = filter_cfg_attrs(&input.attrs);
+
+		fold::fold_item_impl(self, input)
+	}
+}
+
+/// Generate the implementations of the runtime apis for the `RuntimeApi` type.
+fn generate_api_impl_for_runtime_api(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let mut result = Vec::with_capacity(impls.len());
+
+	for impl_ in impls {
+		let impl_trait_path = extract_impl_trait(impl_, RequireQualifiedTraitPath::Yes)?;
+		let runtime_block = extract_block_type_from_trait_path(impl_trait_path)?;
+		let mut runtime_mod_path = extend_with_runtime_decl_path(impl_trait_path.clone());
+		// remove the trait to get just the module path
+		runtime_mod_path.segments.pop();
+
+		let processed_impl =
+			ApiRuntimeImplToApiRuntimeApiImpl { runtime_block }.process(impl_.clone());
+
+		result.push(processed_impl);
+	}
+
+	let crate_ = generate_crate_access();
+
+	Ok(quote!( #crate_::std_enabled! { #( #result )* } ))
+}
+
+fn populate_runtime_api_versions(
+	result: &mut Vec<TokenStream>,
+	sections: &mut Vec<TokenStream>,
+	attrs: Vec<Attribute>,
+	id: Path,
+	version: TokenStream,
+	crate_access: &TokenStream,
+) {
+	result.push(quote!(
+			#( #attrs )*
+			(#id, #version)
+	));
+
+	sections.push(quote!(
+		#crate_access::std_disabled! {
+			#( #attrs )*
+			const _: () = {
+				// All sections with the same name are going to be merged by concatenation.
+				#[link_section = "runtime_apis"]
+				static SECTION_CONTENTS: [u8; 12] = #crate_access::serialize_runtime_api_info(#id, #version);
+			};
+		}
+	));
+}
+
+/// Generates `RUNTIME_API_VERSIONS` that holds all version information about the implemented
+/// runtime apis.
+fn generate_runtime_api_versions(impls: &[ItemImpl]) -> Result<TokenStream> {
+	let mut result = Vec::<TokenStream>::with_capacity(impls.len());
+	let mut sections = Vec::<TokenStream>::with_capacity(impls.len());
+	let mut processed_traits = HashSet::new();
+
+	let c = generate_crate_access();
+
+	for impl_ in impls {
+		let versions = extract_api_version(&impl_.attrs, impl_.span())?;
+		let api_ver = versions.custom.map(|a| a as u32);
+
+		let mut path = extend_with_runtime_decl_path(
+			extract_impl_trait(impl_, RequireQualifiedTraitPath::Yes)?.clone(),
+		);
+		// Remove the trait
+		let trait_ = path
+			.segments
+			.pop()
+			.expect("extract_impl_trait already checks that this is valid; qed")
+			.into_value()
+			.ident;
+
+		let span = trait_.span();
+		if !processed_traits.insert(trait_) {
+			return Err(Error::new(
+				span,
+				"Two traits with the same name detected! \
+					The trait name is used to generate its ID. \
+					Please rename one trait at the declaration!",
+			))
+		}
+
+		let id: Path = parse_quote!( #path ID );
+		let mut attrs = filter_cfg_attrs(&impl_.attrs);
+
+		// Handle API versioning
+		// If feature gated version is set - handle it first
+		if let Some(feature_gated) = versions.feature_gated {
+			let feature_gated_version = feature_gated.1 as u32;
+			// the attributes for the feature gated staging api
+			let mut feature_gated_attrs = attrs.clone();
+			add_feature_guard(&mut feature_gated_attrs, &feature_gated.0, true);
+			populate_runtime_api_versions(
+				&mut result,
+				&mut sections,
+				feature_gated_attrs,
+				id.clone(),
+				quote!( #feature_gated_version ),
+				&c,
+			);
+
+			// Add `#[cfg(not(feature ...))]` to the initial attributes. If the staging feature flag
+			// is not set we want to set the stable api version
+			add_feature_guard(&mut attrs, &feature_gated.0, false);
+		}
+
+		// Now add the stable api version to the versions list. If the api has got staging functions
+		// there might be a `#[cfg(not(feature ...))]` attribute attached to the stable version.
+		let base_api_version = quote!( #path VERSION );
+		let api_ver = api_ver.map(|a| quote!( #a )).unwrap_or_else(|| base_api_version);
+		populate_runtime_api_versions(&mut result, &mut sections, attrs, id, api_ver, &c);
+	}
+
+	Ok(quote!(
+		const RUNTIME_API_VERSIONS: #c::ApisVec = #c::create_apis_vec!([ #( #result ),* ]);
+
+		#( #sections )*
+	))
+}
+
+/// The implementation of the `impl_runtime_apis!` macro.
+pub fn impl_runtime_apis_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	// Parse all impl blocks
+	let RuntimeApiImpls { impls: api_impls } = parse_macro_input!(input as RuntimeApiImpls);
+
+	impl_runtime_apis_impl_inner(&api_impls)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+fn impl_runtime_apis_impl_inner(api_impls: &[ItemImpl]) -> Result<TokenStream> {
+	let dispatch_impl = generate_dispatch_function(api_impls)?;
+	let api_impls_for_runtime = generate_api_impl_for_runtime(api_impls)?;
+	let base_runtime_api = generate_runtime_api_base_structures()?;
+	let runtime_api_versions = generate_runtime_api_versions(api_impls)?;
+	let wasm_interface = generate_wasm_interface(api_impls)?;
+	let api_impls_for_runtime_api = generate_api_impl_for_runtime_api(api_impls)?;
+
+	#[cfg(feature = "frame-metadata")]
+	let runtime_metadata = crate::runtime_metadata::generate_impl_runtime_metadata(api_impls)?;
+	#[cfg(not(feature = "frame-metadata"))]
+	let runtime_metadata = quote!();
+
+	let impl_ = quote!(
+		#base_runtime_api
+
+		#api_impls_for_runtime
+
+		#api_impls_for_runtime_api
+
+		#runtime_api_versions
+
+		#runtime_metadata
+
+		pub mod api {
+			use super::*;
+
+			#dispatch_impl
+
+			#wasm_interface
+		}
+	);
+
+	let impl_ = expander::Expander::new("impl_runtime_apis")
+		.dry(std::env::var("SP_API_EXPAND").is_err())
+		.verbose(true)
+		.write_to_out_dir(impl_)
+		.expect("Does not fail because of IO in OUT_DIR; qed");
+
+	Ok(impl_)
+}
+
+// Filters all attributes except the cfg ones.
+fn filter_cfg_attrs(attrs: &[Attribute]) -> Vec<Attribute> {
+	attrs.iter().filter(|a| a.path().is_ident("cfg")).cloned().collect()
+}
+
+/// Parse feature flagged api_version.
+/// E.g. `#[cfg_attr(feature = "enable-staging-api", api_version(99))]`
+fn extract_cfg_api_version(attrs: &Vec<Attribute>, span: Span) -> Result<Option<(String, u64)>> {
+	let cfg_attrs = attrs.iter().filter(|a| a.path().is_ident("cfg_attr")).collect::<Vec<_>>();
+
+	let mut cfg_api_version_attr = Vec::new();
+	for cfg_attr in cfg_attrs {
+		let mut feature_name = None;
+		let mut api_version = None;
+		cfg_attr.parse_nested_meta(|m| {
+			if m.path.is_ident("feature") {
+				let a = m.value()?;
+				let b: LitStr = a.parse()?;
+				feature_name = Some(b.value());
+			} else if m.path.is_ident(API_VERSION_ATTRIBUTE) {
+				let content;
+				parenthesized!(content in m.input);
+				let ver: LitInt = content.parse()?;
+				api_version = Some(ver.base10_parse::<u64>()?);
+			}
+			Ok(())
+		})?;
+
+		// If there is a cfg attribute containing api_version - save if for processing
+		if let (Some(feature_name), Some(api_version)) = (feature_name, api_version) {
+			cfg_api_version_attr.push((feature_name, api_version, cfg_attr.span()));
+		}
+	}
+
+	if cfg_api_version_attr.len() > 1 {
+		let mut err = Error::new(span, format!("Found multiple feature gated api versions (cfg attribute with nested `{}` attribute). This is not supported.", API_VERSION_ATTRIBUTE));
+		for (_, _, attr_span) in cfg_api_version_attr {
+			err.combine(Error::new(attr_span, format!("`{}` found here", API_VERSION_ATTRIBUTE)));
+		}
+
+		return Err(err)
+	}
+
+	Ok(cfg_api_version_attr
+		.into_iter()
+		.next()
+		.map(|(feature, name, _)| (feature, name)))
+}
+
+/// Represents an API version.
+struct ApiVersion {
+	/// Corresponds to `#[api_version(X)]` attribute.
+	pub custom: Option<u64>,
+	/// Corresponds to `#[cfg_attr(feature = "enable-staging-api", api_version(99))]`
+	/// attribute. `String` is the feature name, `u64` the staging api version.
+	pub feature_gated: Option<(String, u64)>,
+}
+
+// Extracts the value of `API_VERSION_ATTRIBUTE` and handles errors.
+// Returns:
+// - Err if the version is malformed
+// - `ApiVersion` on success. If a version is set or not is determined by the fields of `ApiVersion`
+fn extract_api_version(attrs: &Vec<Attribute>, span: Span) -> Result<ApiVersion> {
+	// First fetch all `API_VERSION_ATTRIBUTE` values (should be only one)
+	let api_ver = attrs
+		.iter()
+		.filter(|a| a.path().is_ident(API_VERSION_ATTRIBUTE))
+		.collect::<Vec<_>>();
+
+	if api_ver.len() > 1 {
+		return Err(Error::new(
+			span,
+			format!(
+				"Found multiple #[{}] attributes for an API implementation. \
+				Each runtime API can have only one version.",
+				API_VERSION_ATTRIBUTE
+			),
+		))
+	}
+
+	// Parse the runtime version if there exists one.
+	Ok(ApiVersion {
+		custom: api_ver.first().map(|v| parse_runtime_api_version(v)).transpose()?,
+		feature_gated: extract_cfg_api_version(attrs, span)?,
+	})
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn filter_non_cfg_attributes() {
+		let cfg_std: Attribute = parse_quote!(#[cfg(feature = "std")]);
+		let cfg_benchmarks: Attribute = parse_quote!(#[cfg(feature = "runtime-benchmarks")]);
+
+		let attrs = vec![
+			cfg_std.clone(),
+			parse_quote!(#[derive(Debug)]),
+			parse_quote!(#[test]),
+			cfg_benchmarks.clone(),
+			parse_quote!(#[allow(non_camel_case_types)]),
+		];
+
+		let filtered = filter_cfg_attrs(&attrs);
+		assert_eq!(filtered.len(), 2);
+		assert_eq!(cfg_std, filtered[0]);
+		assert_eq!(cfg_benchmarks, filtered[1]);
+	}
+}
diff --git a/substrate/primitives/api/proc-macro/src/lib.rs b/substrate/primitives/api/proc-macro/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..06e148880e975f88e07836a4a5ca52fd5e5527b1
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/src/lib.rs
@@ -0,0 +1,45 @@
+// 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.
+
+//! Macros for declaring and implementing runtime apis.
+
+#![recursion_limit = "512"]
+
+use proc_macro::TokenStream;
+
+mod common;
+mod decl_runtime_apis;
+mod impl_runtime_apis;
+mod mock_impl_runtime_apis;
+#[cfg(feature = "frame-metadata")]
+mod runtime_metadata;
+mod utils;
+
+#[proc_macro]
+pub fn impl_runtime_apis(input: TokenStream) -> TokenStream {
+	impl_runtime_apis::impl_runtime_apis_impl(input)
+}
+
+#[proc_macro]
+pub fn mock_impl_runtime_apis(input: TokenStream) -> TokenStream {
+	mock_impl_runtime_apis::mock_impl_runtime_apis_impl(input)
+}
+
+#[proc_macro]
+pub fn decl_runtime_apis(input: TokenStream) -> TokenStream {
+	decl_runtime_apis::decl_runtime_apis_impl(input)
+}
diff --git a/substrate/primitives/api/proc-macro/src/mock_impl_runtime_apis.rs b/substrate/primitives/api/proc-macro/src/mock_impl_runtime_apis.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c1339ff6621b389e32c2f9ca2a7f19079c2d269e
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/src/mock_impl_runtime_apis.rs
@@ -0,0 +1,443 @@
+// 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::utils::{
+	extract_block_type_from_trait_path, extract_impl_trait,
+	extract_parameter_names_types_and_borrows, generate_crate_access, return_type_extract_type,
+	AllowSelfRefInParameters, RequireQualifiedTraitPath,
+};
+
+use proc_macro2::{Span, TokenStream};
+
+use quote::{quote, quote_spanned};
+
+use syn::{
+	fold::{self, Fold},
+	parse::{Error, Parse, ParseStream, Result},
+	parse_macro_input, parse_quote,
+	spanned::Spanned,
+	Attribute, ItemImpl, Pat, Type, TypePath,
+};
+
+/// The `advanced` attribute.
+///
+/// If this attribute is given to a function, the function gets access to the `Hash` as first
+/// parameter and needs to return a `Result` with the appropriate error type.
+const ADVANCED_ATTRIBUTE: &str = "advanced";
+
+/// The structure used for parsing the runtime api implementations.
+struct RuntimeApiImpls {
+	impls: Vec<ItemImpl>,
+}
+
+impl Parse for RuntimeApiImpls {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let mut impls = Vec::new();
+
+		while !input.is_empty() {
+			impls.push(ItemImpl::parse(input)?);
+		}
+
+		if impls.is_empty() {
+			Err(Error::new(Span::call_site(), "No api implementation given!"))
+		} else {
+			Ok(Self { impls })
+		}
+	}
+}
+
+/// Implement the `ApiExt` trait and the `Core` runtime api.
+fn implement_common_api_traits(block_type: TypePath, self_ty: Type) -> Result<TokenStream> {
+	let crate_ = generate_crate_access();
+
+	Ok(quote!(
+		impl #crate_::ApiExt<#block_type> for #self_ty {
+			fn execute_in_transaction<F: FnOnce(&Self) -> #crate_::TransactionOutcome<R>, R>(
+				&self,
+				call: F,
+			) -> R where Self: Sized {
+				call(self).into_inner()
+			}
+
+			fn has_api<A: #crate_::RuntimeApiInfo + ?Sized>(
+				&self,
+				_: <Block as #crate_::BlockT>::Hash,
+			) -> std::result::Result<bool, #crate_::ApiError> where Self: Sized {
+				Ok(true)
+			}
+
+			fn has_api_with<A: #crate_::RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>(
+				&self,
+				_: <Block as #crate_::BlockT>::Hash,
+				pred: P,
+			) -> std::result::Result<bool, #crate_::ApiError> where Self: Sized {
+				Ok(pred(A::VERSION))
+			}
+
+			fn api_version<A: #crate_::RuntimeApiInfo + ?Sized>(
+				&self,
+				_: <Block as #crate_::BlockT>::Hash,
+			) -> std::result::Result<Option<u32>, #crate_::ApiError> where Self: Sized {
+				Ok(Some(A::VERSION))
+			}
+
+			fn record_proof(&mut self) {
+				unimplemented!("`record_proof` not implemented for runtime api mocks")
+			}
+
+			fn extract_proof(
+				&mut self,
+			) -> Option<#crate_::StorageProof> {
+				unimplemented!("`extract_proof` not implemented for runtime api mocks")
+			}
+
+			fn proof_recorder(&self) -> Option<#crate_::ProofRecorder<#block_type>> {
+				unimplemented!("`proof_recorder` not implemented for runtime api mocks")
+			}
+
+			fn into_storage_changes<B: #crate_::StateBackend<#crate_::HashingFor<#block_type>>>(
+				&self,
+				_: &B,
+				_: <#block_type as #crate_::BlockT>::Hash,
+			) -> std::result::Result<
+				#crate_::StorageChanges<#block_type>,
+				String
+			> where Self: Sized {
+				unimplemented!("`into_storage_changes` not implemented for runtime api mocks")
+			}
+
+			fn set_call_context(&mut self, _: #crate_::CallContext) {
+				unimplemented!("`set_call_context` not implemented for runtime api mocks")
+			}
+
+			fn register_extension<E: #crate_::Extension>(&mut self, _: E) {
+				unimplemented!("`register_extension` not implemented for runtime api mocks")
+			}
+		}
+
+		impl #crate_::Core<#block_type> for #self_ty {
+			fn __runtime_api_internal_call_api_at(
+				&self,
+				_: <#block_type as #crate_::BlockT>::Hash,
+				_: std::vec::Vec<u8>,
+				_: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
+			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError> {
+				unimplemented!("`__runtime_api_internal_call_api_at` not implemented for runtime api mocks")
+			}
+
+			fn version(
+				&self,
+				_: <#block_type as #crate_::BlockT>::Hash,
+			) -> std::result::Result<#crate_::RuntimeVersion, #crate_::ApiError> {
+				unimplemented!("`Core::version` not implemented for runtime api mocks")
+			}
+
+			fn execute_block(
+				&self,
+				_: <#block_type as #crate_::BlockT>::Hash,
+				_: #block_type,
+			) -> std::result::Result<(), #crate_::ApiError> {
+				unimplemented!("`Core::execute_block` not implemented for runtime api mocks")
+			}
+
+			fn initialize_block(
+				&self,
+				_: <#block_type as #crate_::BlockT>::Hash,
+				_: &<#block_type as #crate_::BlockT>::Header,
+			) -> std::result::Result<(), #crate_::ApiError> {
+				unimplemented!("`Core::initialize_block` not implemented for runtime api mocks")
+			}
+		}
+	))
+}
+
+/// Returns if the advanced attribute is present in the given `attributes`.
+///
+/// If the attribute was found, it will be automatically removed from the vec.
+fn has_advanced_attribute(attributes: &mut Vec<Attribute>) -> bool {
+	let mut found = false;
+	attributes.retain(|attr| {
+		if attr.path().is_ident(ADVANCED_ATTRIBUTE) {
+			found = true;
+			false
+		} else {
+			true
+		}
+	});
+
+	found
+}
+
+/// Get the name and type of the `at` parameter that is passed to a runtime api function.
+///
+/// If `is_advanced` is `false`, the name is `_`.
+fn get_at_param_name(
+	is_advanced: bool,
+	param_names: &mut Vec<Pat>,
+	param_types_and_borrows: &mut Vec<(TokenStream, bool)>,
+	function_span: Span,
+	default_hash_type: &TokenStream,
+) -> Result<(TokenStream, TokenStream)> {
+	if is_advanced {
+		if param_names.is_empty() {
+			return Err(Error::new(
+				function_span,
+				format!(
+					"If using the `{}` attribute, it is required that the function \
+					 takes at least one argument, the `Hash`.",
+					ADVANCED_ATTRIBUTE,
+				),
+			))
+		}
+
+		// `param_names` and `param_types` have the same length, so if `param_names` is not empty
+		// `param_types` can not be empty as well.
+		let ptype_and_borrows = param_types_and_borrows.remove(0);
+		let span = ptype_and_borrows.1.span();
+		if ptype_and_borrows.1 {
+			return Err(Error::new(span, "`Hash` needs to be taken by value and not by reference!"))
+		}
+
+		let name = param_names.remove(0);
+		Ok((quote!( #name ), ptype_and_borrows.0))
+	} else {
+		Ok((quote!(_), default_hash_type.clone()))
+	}
+}
+
+/// Auxiliary structure to fold a runtime api trait implementation into the expected format.
+///
+/// This renames the methods, changes the method parameters and extracts the error type.
+struct FoldRuntimeApiImpl<'a> {
+	/// The block type that is being used.
+	block_type: &'a TypePath,
+}
+
+impl<'a> FoldRuntimeApiImpl<'a> {
+	/// Process the given [`syn::ItemImpl`].
+	fn process(mut self, impl_item: syn::ItemImpl) -> syn::ItemImpl {
+		let mut impl_item = self.fold_item_impl(impl_item);
+
+		let crate_ = generate_crate_access();
+
+		let block_type = self.block_type;
+
+		impl_item.items.push(parse_quote! {
+			fn __runtime_api_internal_call_api_at(
+				&self,
+				_: <#block_type as #crate_::BlockT>::Hash,
+				_: std::vec::Vec<u8>,
+				_: &dyn Fn(#crate_::RuntimeVersion) -> &'static str,
+			) -> std::result::Result<std::vec::Vec<u8>, #crate_::ApiError> {
+				unimplemented!(
+					"`__runtime_api_internal_call_api_at` not implemented for runtime api mocks. \
+					 Calling deprecated methods is not supported by mocked runtime api."
+				)
+			}
+		});
+
+		impl_item
+	}
+}
+
+impl<'a> Fold for FoldRuntimeApiImpl<'a> {
+	fn fold_impl_item_fn(&mut self, mut input: syn::ImplItemFn) -> syn::ImplItemFn {
+		let block = {
+			let crate_ = generate_crate_access();
+			let is_advanced = has_advanced_attribute(&mut input.attrs);
+			let mut errors = Vec::new();
+
+			let (mut param_names, mut param_types_and_borrows) =
+				match extract_parameter_names_types_and_borrows(
+					&input.sig,
+					AllowSelfRefInParameters::YesButIgnore,
+				) {
+					Ok(res) => (
+						res.iter().map(|v| v.0.clone()).collect::<Vec<_>>(),
+						res.iter()
+							.map(|v| {
+								let ty = &v.1;
+								let borrow = &v.2;
+								(quote_spanned!(ty.span() => #borrow #ty ), v.2.is_some())
+							})
+							.collect::<Vec<_>>(),
+					),
+					Err(e) => {
+						errors.push(e.to_compile_error());
+
+						(Default::default(), Default::default())
+					},
+				};
+
+			let block_type = &self.block_type;
+			let hash_type = quote!( <#block_type as #crate_::BlockT>::Hash );
+
+			let (at_param_name, hash_type) = match get_at_param_name(
+				is_advanced,
+				&mut param_names,
+				&mut param_types_and_borrows,
+				input.span(),
+				&hash_type,
+			) {
+				Ok(res) => res,
+				Err(e) => {
+					errors.push(e.to_compile_error());
+					(quote!(_), hash_type)
+				},
+			};
+
+			let param_types = param_types_and_borrows.iter().map(|v| &v.0);
+			// Rewrite the input parameters.
+			input.sig.inputs = parse_quote! {
+				&self,
+				#at_param_name: #hash_type,
+				#( #param_names: #param_types ),*
+			};
+
+			// When using advanced, the user needs to declare the correct return type on its own,
+			// otherwise do it for the user.
+			if !is_advanced {
+				let ret_type = return_type_extract_type(&input.sig.output);
+
+				// Generate the correct return type.
+				input.sig.output = parse_quote!(
+					-> std::result::Result<#ret_type, #crate_::ApiError>
+				);
+			}
+
+			let orig_block = input.block.clone();
+
+			let construct_return_value = if is_advanced {
+				quote!( (move || #orig_block)() )
+			} else {
+				quote! {
+					let __fn_implementation__ = move || #orig_block;
+
+					Ok(__fn_implementation__())
+				}
+			};
+
+			// Generate the new method implementation that calls into the runtime.
+			parse_quote!(
+				{
+					// Get the error to the user (if we have one).
+					#( #errors )*
+
+					#construct_return_value
+				}
+			)
+		};
+
+		let mut input = fold::fold_impl_item_fn(self, input);
+		// We need to set the block, after we modified the rest of the ast, otherwise we would
+		// modify our generated block as well.
+		input.block = block;
+		input
+	}
+}
+
+/// Result of [`generate_runtime_api_impls`].
+struct GeneratedRuntimeApiImpls {
+	/// All the runtime api implementations.
+	impls: TokenStream,
+	/// The block type that is being used by the runtime apis.
+	block_type: TypePath,
+	/// The type the traits are implemented for.
+	self_ty: Type,
+}
+
+/// Generate the runtime api implementations from the given trait implementations.
+///
+/// This folds the method names, changes the method parameters, method return type,
+/// extracts the error type, self type and the block type.
+fn generate_runtime_api_impls(impls: &[ItemImpl]) -> Result<GeneratedRuntimeApiImpls> {
+	let mut result = Vec::with_capacity(impls.len());
+	let mut global_block_type: Option<TypePath> = None;
+	let mut self_ty: Option<Box<Type>> = None;
+
+	for impl_ in impls {
+		let impl_trait_path = extract_impl_trait(impl_, RequireQualifiedTraitPath::No)?;
+		let block_type = extract_block_type_from_trait_path(impl_trait_path)?;
+
+		self_ty = match self_ty.take() {
+			Some(self_ty) =>
+				if self_ty == impl_.self_ty {
+					Some(self_ty)
+				} else {
+					let mut error = Error::new(
+						impl_.self_ty.span(),
+						"Self type should not change between runtime apis",
+					);
+
+					error.combine(Error::new(self_ty.span(), "First self type found here"));
+
+					return Err(error)
+				},
+			None => Some(impl_.self_ty.clone()),
+		};
+
+		global_block_type = match global_block_type.take() {
+			Some(global_block_type) =>
+				if global_block_type == *block_type {
+					Some(global_block_type)
+				} else {
+					let mut error = Error::new(
+						block_type.span(),
+						"Block type should be the same between all runtime apis.",
+					);
+
+					error.combine(Error::new(
+						global_block_type.span(),
+						"First block type found here",
+					));
+
+					return Err(error)
+				},
+			None => Some(block_type.clone()),
+		};
+
+		result.push(FoldRuntimeApiImpl { block_type }.process(impl_.clone()));
+	}
+
+	Ok(GeneratedRuntimeApiImpls {
+		impls: quote!( #( #result )* ),
+		block_type: global_block_type.expect("There is a least one runtime api; qed"),
+		self_ty: *self_ty.expect("There is at least one runtime api; qed"),
+	})
+}
+
+/// The implementation of the `mock_impl_runtime_apis!` macro.
+pub fn mock_impl_runtime_apis_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	// Parse all impl blocks
+	let RuntimeApiImpls { impls: api_impls } = parse_macro_input!(input as RuntimeApiImpls);
+
+	mock_impl_runtime_apis_impl_inner(&api_impls)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+fn mock_impl_runtime_apis_impl_inner(api_impls: &[ItemImpl]) -> Result<TokenStream> {
+	let GeneratedRuntimeApiImpls { impls, block_type, self_ty } =
+		generate_runtime_api_impls(api_impls)?;
+	let api_traits = implement_common_api_traits(block_type, self_ty)?;
+
+	Ok(quote!(
+		#impls
+
+		#api_traits
+	))
+}
diff --git a/substrate/primitives/api/proc-macro/src/runtime_metadata.rs b/substrate/primitives/api/proc-macro/src/runtime_metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..41849401291e633924e6f530ffc5bc3474ba6283
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/src/runtime_metadata.rs
@@ -0,0 +1,268 @@
+// 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 proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::{parse_quote, ItemImpl, ItemTrait, Result};
+
+use crate::{
+	common::CHANGED_IN_ATTRIBUTE,
+	utils::{
+		extract_impl_trait, filter_cfg_attributes, generate_crate_access,
+		generate_runtime_mod_name_for_trait, get_doc_literals, RequireQualifiedTraitPath,
+	},
+};
+
+/// Get the type parameter argument without lifetime or mutability
+/// of a runtime metadata function.
+///
+/// In the following example, both the `AccountId` and `Nonce` generic
+/// type parameters must implement `scale_info::TypeInfo` because they
+/// are added into the metadata using `scale_info::meta_type`.
+///
+/// ```ignore
+/// trait ExampleAccountNonceApi<AccountId, Nonce> {
+///   fn account_nonce<'a>(account: &'a AccountId) -> Nonce;
+/// }
+/// ```
+///
+/// Instead of returning `&'a AccountId` for the first parameter, this function
+/// returns `AccountId` to place bounds around it.
+fn get_type_param(ty: &syn::Type) -> syn::Type {
+	// Remove the lifetime and mutability of the type T to
+	// place bounds around it.
+	let ty_elem = match &ty {
+		syn::Type::Reference(reference) => &reference.elem,
+		syn::Type::Ptr(ptr) => &ptr.elem,
+		syn::Type::Slice(slice) => &slice.elem,
+		syn::Type::Array(arr) => &arr.elem,
+		_ => ty,
+	};
+
+	ty_elem.clone()
+}
+
+/// Extract the documentation from the provided attributes.
+///
+/// It takes into account the `no-metadata-docs` feature.
+fn collect_docs(attrs: &[syn::Attribute], crate_: &TokenStream2) -> TokenStream2 {
+	if cfg!(feature = "no-metadata-docs") {
+		quote!(#crate_::vec![])
+	} else {
+		let docs = get_doc_literals(&attrs);
+		quote!(#crate_::vec![ #( #docs, )* ])
+	}
+}
+
+/// Generate the runtime metadata of the provided trait.
+///
+/// The metadata is exposed as a generic function on the hidden module
+/// of the trait generated by the `decl_runtime_apis`.
+pub fn generate_decl_runtime_metadata(decl: &ItemTrait) -> TokenStream2 {
+	let crate_ = generate_crate_access();
+	let mut methods = Vec::new();
+
+	// Ensure that any function parameter that relies on the `BlockT` bounds
+	// also has `TypeInfo + 'static` bounds (required by `scale_info::meta_type`).
+	//
+	// For example, if a runtime API defines a method that has an input:
+	// `fn func(input: <Block as BlockT>::Header)`
+	// then the runtime metadata will imply `<Block as BlockT>::Header: TypeInfo + 'static`.
+	//
+	// This restricts the bounds at the metadata level, without needing to modify the `BlockT`
+	// itself, since the concrete implementations are already satisfying `TypeInfo`.
+	let mut where_clause = Vec::new();
+	for item in &decl.items {
+		// Collect metadata for methods only.
+		let syn::TraitItem::Fn(method) = item else { continue };
+
+		// Collect metadata only for the latest methods.
+		let is_changed_in =
+			method.attrs.iter().any(|attr| attr.path().is_ident(CHANGED_IN_ATTRIBUTE));
+		if is_changed_in {
+			continue
+		}
+
+		let mut inputs = Vec::new();
+		let signature = &method.sig;
+		for input in &signature.inputs {
+			// Exclude `self` from metadata collection.
+			let syn::FnArg::Typed(typed) = input else { continue };
+
+			let pat = &typed.pat;
+			let name = quote!(#pat).to_string();
+			let ty = &typed.ty;
+
+			where_clause.push(get_type_param(ty));
+
+			inputs.push(quote!(
+				#crate_::metadata_ir::RuntimeApiMethodParamMetadataIR {
+					name: #name,
+					ty: #crate_::scale_info::meta_type::<#ty>(),
+				}
+			));
+		}
+
+		let output = match &signature.output {
+			syn::ReturnType::Default => quote!(#crate_::scale_info::meta_type::<()>()),
+			syn::ReturnType::Type(_, ty) => {
+				where_clause.push(get_type_param(ty));
+				quote!(#crate_::scale_info::meta_type::<#ty>())
+			},
+		};
+
+		// String method name including quotes for constructing `v15::RuntimeApiMethodMetadata`.
+		let method_name = signature.ident.to_string();
+		let docs = collect_docs(&method.attrs, &crate_);
+
+		// Include the method metadata only if its `cfg` features are enabled.
+		let attrs = filter_cfg_attributes(&method.attrs);
+		methods.push(quote!(
+			#( #attrs )*
+			#crate_::metadata_ir::RuntimeApiMethodMetadataIR {
+				name: #method_name,
+				inputs: #crate_::vec![ #( #inputs, )* ],
+				output: #output,
+				docs: #docs,
+			}
+		));
+	}
+
+	let trait_name_ident = &decl.ident;
+	let trait_name = trait_name_ident.to_string();
+	let docs = collect_docs(&decl.attrs, &crate_);
+	let attrs = filter_cfg_attributes(&decl.attrs);
+	// The trait generics where already extended with `Block: BlockT`.
+	let mut generics = decl.generics.clone();
+	for generic_param in generics.params.iter_mut() {
+		let syn::GenericParam::Type(ty) = generic_param else { continue };
+
+		// Default type parameters are not allowed in functions.
+		ty.eq_token = None;
+		ty.default = None;
+	}
+
+	where_clause
+		.into_iter()
+		.map(|ty| parse_quote!(#ty: #crate_::scale_info::TypeInfo + 'static))
+		.for_each(|w| generics.make_where_clause().predicates.push(w));
+
+	let (impl_generics, _, where_clause) = generics.split_for_impl();
+
+	quote!(
+		#( #attrs )*
+		#[inline(always)]
+		pub fn runtime_metadata #impl_generics () -> #crate_::metadata_ir::RuntimeApiMetadataIR
+		#where_clause
+		{
+			#crate_::metadata_ir::RuntimeApiMetadataIR {
+				name: #trait_name,
+				methods: #crate_::vec![ #( #methods, )* ],
+				docs: #docs,
+			}
+		}
+	)
+}
+
+/// Implement the `runtime_metadata` function on the runtime that
+/// generates the metadata for the given traits.
+///
+/// The metadata of each trait is extracted from the generic function
+/// exposed by `generate_decl_runtime_metadata`.
+pub fn generate_impl_runtime_metadata(impls: &[ItemImpl]) -> Result<TokenStream2> {
+	if impls.is_empty() {
+		return Ok(quote!())
+	}
+
+	let crate_ = generate_crate_access();
+
+	// Get the name of the runtime for which the traits are implemented.
+	let runtime_name = &impls
+		.get(0)
+		.expect("Traits should contain at least one implementation; qed")
+		.self_ty;
+
+	let mut metadata = Vec::new();
+
+	for impl_ in impls {
+		let mut trait_ = extract_impl_trait(&impl_, RequireQualifiedTraitPath::Yes)?.clone();
+
+		// Implementation traits are always references with a path `impl client::Core<generics> ...`
+		// The trait name is the last segment of this path.
+		let trait_name_ident = &trait_
+			.segments
+			.last()
+			.as_ref()
+			.expect("Trait path should always contain at least one item; qed")
+			.ident;
+
+		// Extract the generics from the trait to pass to the `runtime_metadata`
+		// function on the hidden module.
+		let generics = trait_
+			.segments
+			.iter()
+			.find_map(|segment| {
+				if let syn::PathArguments::AngleBracketed(generics) = &segment.arguments {
+					Some(generics.clone())
+				} else {
+					None
+				}
+			})
+			.expect("Trait path should always contain at least one generic parameter; qed");
+
+		let mod_name = generate_runtime_mod_name_for_trait(&trait_name_ident);
+		// Get absolute path to the `runtime_decl_for_` module by replacing the last segment.
+		if let Some(segment) = trait_.segments.last_mut() {
+			*segment = parse_quote!(#mod_name);
+		}
+
+		let attrs = filter_cfg_attributes(&impl_.attrs);
+		metadata.push(quote!(
+			#( #attrs )*
+			#trait_::runtime_metadata::#generics()
+		));
+	}
+
+	// Each runtime must expose the `runtime_metadata()` to fetch the runtime API metadata.
+	// The function is implemented by calling `impl_runtime_apis!`.
+	//
+	// However, the `construct_runtime!` may be called without calling `impl_runtime_apis!`.
+	// Rely on the `Deref` trait to differentiate between a runtime that implements
+	// APIs (by macro impl_runtime_apis!) and a runtime that is simply created (by macro
+	// construct_runtime!).
+	//
+	// Both `InternalConstructRuntime` and `InternalImplRuntimeApis` expose a `runtime_metadata()`
+	// function. `InternalConstructRuntime` is implemented by the `construct_runtime!` for Runtime
+	// references (`& Runtime`), while `InternalImplRuntimeApis` is implemented by the
+	// `impl_runtime_apis!` for Runtime (`Runtime`).
+	//
+	// Therefore, the `Deref` trait will resolve the `runtime_metadata` from `impl_runtime_apis!`
+	// when both macros are called; and will resolve an empty `runtime_metadata` when only the
+	// `construct_runtime!` is called.
+
+	Ok(quote!(
+		#[doc(hidden)]
+		trait InternalImplRuntimeApis {
+			#[inline(always)]
+			fn runtime_metadata(&self) -> #crate_::vec::Vec<#crate_::metadata_ir::RuntimeApiMetadataIR> {
+				#crate_::vec![ #( #metadata, )* ]
+			}
+		}
+		#[doc(hidden)]
+		impl InternalImplRuntimeApis for #runtime_name {}
+	))
+}
diff --git a/substrate/primitives/api/proc-macro/src/utils.rs b/substrate/primitives/api/proc-macro/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c9389154bbf40ff780f97e5d096dcaee7f1c1ce2
--- /dev/null
+++ b/substrate/primitives/api/proc-macro/src/utils.rs
@@ -0,0 +1,330 @@
+// 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 proc_macro2::{Span, TokenStream};
+
+use syn::{
+	parse_quote, spanned::Spanned, token::And, Attribute, Error, FnArg, GenericArgument, Ident,
+	ImplItem, ItemImpl, Pat, Path, PathArguments, Result, ReturnType, Signature, Type, TypePath,
+};
+
+use quote::{format_ident, quote};
+
+use proc_macro_crate::{crate_name, FoundCrate};
+
+use crate::common::API_VERSION_ATTRIBUTE;
+
+use inflector::Inflector;
+
+/// Generates the access to the `sc_client` crate.
+pub fn generate_crate_access() -> TokenStream {
+	match crate_name("sp-api") {
+		Ok(FoundCrate::Itself) => quote!(sp_api),
+		Ok(FoundCrate::Name(renamed_name)) => {
+			let renamed_name = Ident::new(&renamed_name, Span::call_site());
+			quote!(#renamed_name)
+		},
+		Err(e) => {
+			let err = Error::new(Span::call_site(), e).to_compile_error();
+			quote!( #err )
+		},
+	}
+}
+
+/// Generates the name of the module that contains the trait declaration for the runtime.
+pub fn generate_runtime_mod_name_for_trait(trait_: &Ident) -> Ident {
+	Ident::new(
+		&format!("runtime_decl_for_{}", trait_.to_string().to_snake_case()),
+		Span::call_site(),
+	)
+}
+
+/// Get the type of a `syn::ReturnType`.
+pub fn return_type_extract_type(rt: &ReturnType) -> Type {
+	match rt {
+		ReturnType::Default => parse_quote!(()),
+		ReturnType::Type(_, ref ty) => *ty.clone(),
+	}
+}
+
+/// Replace the `_` (wild card) parameter names in the given signature with unique identifiers.
+pub fn replace_wild_card_parameter_names(input: &mut Signature) {
+	let mut generated_pattern_counter = 0;
+	input.inputs.iter_mut().for_each(|arg| {
+		if let FnArg::Typed(arg) = arg {
+			arg.pat = Box::new(generate_unique_pattern(
+				(*arg.pat).clone(),
+				&mut generated_pattern_counter,
+			));
+		}
+	});
+}
+
+/// Fold the given `Signature` to make it usable on the client side.
+pub fn fold_fn_decl_for_client_side(
+	input: &mut Signature,
+	block_hash: &TokenStream,
+	crate_: &TokenStream,
+) {
+	replace_wild_card_parameter_names(input);
+
+	// Add `&self, at:& Block::Hash` as parameters to each function at the beginning.
+	input.inputs.insert(0, parse_quote!( __runtime_api_at_param__: #block_hash ));
+	input.inputs.insert(0, parse_quote!(&self));
+
+	// Wrap the output in a `Result`
+	input.output = {
+		let ty = return_type_extract_type(&input.output);
+		parse_quote!( -> std::result::Result<#ty, #crate_::ApiError> )
+	};
+}
+
+/// Generate an unique pattern based on the given counter, if the given pattern is a `_`.
+pub fn generate_unique_pattern(pat: Pat, counter: &mut u32) -> Pat {
+	match pat {
+		Pat::Wild(_) => {
+			let generated_name =
+				Ident::new(&format!("__runtime_api_generated_name_{}__", counter), pat.span());
+			*counter += 1;
+
+			parse_quote!( #generated_name )
+		},
+		_ => pat,
+	}
+}
+
+/// Allow `&self` in parameters of a method.
+pub enum AllowSelfRefInParameters {
+	/// Allows `&self` in parameters, but doesn't return it as part of the parameters.
+	YesButIgnore,
+	No,
+}
+
+/// Extracts the name, the type and `&` or ``(if it is a reference or not)
+/// for each parameter in the given function signature.
+pub fn extract_parameter_names_types_and_borrows(
+	sig: &Signature,
+	allow_self: AllowSelfRefInParameters,
+) -> Result<Vec<(Pat, Type, Option<And>)>> {
+	let mut result = Vec::new();
+	let mut generated_pattern_counter = 0;
+	for input in sig.inputs.iter() {
+		match input {
+			FnArg::Typed(arg) => {
+				let (ty, borrow) = match &*arg.ty {
+					Type::Reference(t) => ((*t.elem).clone(), Some(t.and_token)),
+					t => (t.clone(), None),
+				};
+
+				let name =
+					generate_unique_pattern((*arg.pat).clone(), &mut generated_pattern_counter);
+				result.push((name, ty, borrow));
+			},
+			FnArg::Receiver(_) if matches!(allow_self, AllowSelfRefInParameters::No) =>
+				return Err(Error::new(input.span(), "`self` parameter not supported!")),
+			FnArg::Receiver(recv) =>
+				if recv.mutability.is_some() || recv.reference.is_none() {
+					return Err(Error::new(recv.span(), "Only `&self` is supported!"))
+				},
+		}
+	}
+
+	Ok(result)
+}
+
+/// Prefix the given function with the trait name.
+pub fn prefix_function_with_trait<F: ToString>(trait_: &Ident, function: &F) -> String {
+	format!("{}_{}", trait_, function.to_string())
+}
+
+/// Extract all types that appear in signatures in the given `ImplItem`'s.
+///
+/// If a type is a reference, the inner type is extracted (without the reference).
+pub fn extract_all_signature_types(items: &[ImplItem]) -> Vec<Type> {
+	items
+		.iter()
+		.filter_map(|i| match i {
+			ImplItem::Fn(method) => Some(&method.sig),
+			_ => None,
+		})
+		.flat_map(|sig| {
+			let ret_ty = match &sig.output {
+				ReturnType::Default => None,
+				ReturnType::Type(_, ty) => Some((**ty).clone()),
+			};
+
+			sig.inputs
+				.iter()
+				.filter_map(|i| match i {
+					FnArg::Typed(arg) => Some(&arg.ty),
+					_ => None,
+				})
+				.map(|ty| match &**ty {
+					Type::Reference(t) => (*t.elem).clone(),
+					_ => (**ty).clone(),
+				})
+				.chain(ret_ty)
+		})
+		.collect()
+}
+
+/// Extracts the block type from a trait path.
+///
+/// It is expected that the block type is the first type in the generic arguments.
+pub fn extract_block_type_from_trait_path(trait_: &Path) -> Result<&TypePath> {
+	let span = trait_.span();
+	let generics = trait_
+		.segments
+		.last()
+		.ok_or_else(|| Error::new(span, "Empty path not supported"))?;
+
+	match &generics.arguments {
+		PathArguments::AngleBracketed(ref args) => args
+			.args
+			.first()
+			.and_then(|v| match v {
+				GenericArgument::Type(Type::Path(ref block)) => Some(block),
+				_ => None,
+			})
+			.ok_or_else(|| Error::new(args.span(), "Missing `Block` generic parameter.")),
+		PathArguments::None => {
+			let span = trait_.segments.last().as_ref().unwrap().span();
+			Err(Error::new(span, "Missing `Block` generic parameter."))
+		},
+		PathArguments::Parenthesized(_) =>
+			Err(Error::new(generics.arguments.span(), "Unexpected parentheses in path!")),
+	}
+}
+
+/// Should a qualified trait path be required?
+///
+/// e.g. `path::Trait` is qualified and `Trait` is not.
+pub enum RequireQualifiedTraitPath {
+	Yes,
+	No,
+}
+
+/// Extract the trait that is implemented by the given `ItemImpl`.
+pub fn extract_impl_trait(impl_: &ItemImpl, require: RequireQualifiedTraitPath) -> Result<&Path> {
+	impl_
+		.trait_
+		.as_ref()
+		.map(|v| &v.1)
+		.ok_or_else(|| Error::new(impl_.span(), "Only implementation of traits are supported!"))
+		.and_then(|p| {
+			if p.segments.len() > 1 || matches!(require, RequireQualifiedTraitPath::No) {
+				Ok(p)
+			} else {
+				Err(Error::new(
+					p.span(),
+					"The implemented trait has to be referenced with a path, \
+					e.g. `impl client::Core for Runtime`.",
+				))
+			}
+		})
+}
+
+/// Parse the given attribute as `API_VERSION_ATTRIBUTE`.
+pub fn parse_runtime_api_version(version: &Attribute) -> Result<u64> {
+	let version = version.parse_args::<syn::LitInt>().map_err(|_| {
+		Error::new(
+			version.span(),
+			&format!(
+				"Unexpected `{api_version}` attribute. The supported format is `{api_version}(1)`",
+				api_version = API_VERSION_ATTRIBUTE
+			),
+		)
+	})?;
+
+	version.base10_parse()
+}
+
+/// Each versioned trait is named 'ApiNameVN' where N is the specific version. E.g. ParachainHostV2
+pub fn versioned_trait_name(trait_ident: &Ident, version: u64) -> Ident {
+	format_ident!("{}V{}", trait_ident, version)
+}
+
+/// Extract the documentation from the provided attributes.
+#[cfg(feature = "frame-metadata")]
+pub fn get_doc_literals(attrs: &[syn::Attribute]) -> Vec<syn::Lit> {
+	use quote::ToTokens;
+
+	attrs
+		.iter()
+		.filter_map(|attr| {
+			let syn::Meta::NameValue(meta) = &attr.meta else { return None };
+			let Ok(lit) = syn::parse2::<syn::Lit>(meta.value.to_token_stream()) else {
+				unreachable!("non-lit doc attribute values do not exist");
+			};
+			meta.path.get_ident().filter(|ident| *ident == "doc").map(|_| lit)
+		})
+		.collect()
+}
+
+/// Filters all attributes except the cfg ones.
+#[cfg(feature = "frame-metadata")]
+pub fn filter_cfg_attributes(attrs: &[syn::Attribute]) -> Vec<syn::Attribute> {
+	attrs.iter().filter(|a| a.path().is_ident("cfg")).cloned().collect()
+}
+
+#[cfg(test)]
+mod tests {
+	use assert_matches::assert_matches;
+
+	use super::*;
+
+	#[test]
+	fn check_get_doc_literals() {
+		const FIRST: &'static str = "hello";
+		const SECOND: &'static str = "WORLD";
+
+		let doc: Attribute = parse_quote!(#[doc = #FIRST]);
+		let doc_world: Attribute = parse_quote!(#[doc = #SECOND]);
+
+		let attrs = vec![
+			doc.clone(),
+			parse_quote!(#[derive(Debug)]),
+			parse_quote!(#[test]),
+			parse_quote!(#[allow(non_camel_case_types)]),
+			doc_world.clone(),
+		];
+
+		let docs = get_doc_literals(&attrs);
+		assert_eq!(docs.len(), 2);
+		assert_matches!(&docs[0], syn::Lit::Str(val) if val.value() == FIRST);
+		assert_matches!(&docs[1], syn::Lit::Str(val) if val.value() == SECOND);
+	}
+
+	#[test]
+	fn check_filter_cfg_attributes() {
+		let cfg_std: Attribute = parse_quote!(#[cfg(feature = "std")]);
+		let cfg_benchmarks: Attribute = parse_quote!(#[cfg(feature = "runtime-benchmarks")]);
+
+		let attrs = vec![
+			cfg_std.clone(),
+			parse_quote!(#[derive(Debug)]),
+			parse_quote!(#[test]),
+			cfg_benchmarks.clone(),
+			parse_quote!(#[allow(non_camel_case_types)]),
+		];
+
+		let filtered = filter_cfg_attributes(&attrs);
+		assert_eq!(filtered.len(), 2);
+		assert_eq!(cfg_std, filtered[0]);
+		assert_eq!(cfg_benchmarks, filtered[1]);
+	}
+}
diff --git a/substrate/primitives/api/src/lib.rs b/substrate/primitives/api/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3f80acf09ae59a436e79ccb988990a5131ed651
--- /dev/null
+++ b/substrate/primitives/api/src/lib.rs
@@ -0,0 +1,793 @@
+// 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.
+
+//! Substrate runtime api
+//!
+//! The Substrate runtime api is the interface between the node and the runtime. There isn't a fixed
+//! set of runtime apis, instead it is up to the user to declare and implement these runtime apis.
+//! The declaration of a runtime api is normally done outside of a runtime, while the implementation
+//! of it has to be done in the runtime. We provide the [`decl_runtime_apis!`] macro for declaring
+//! a runtime api and the [`impl_runtime_apis!`] for implementing them. The macro docs provide more
+//! information on how to use them and what kind of attributes we support.
+//!
+//! It is required that each runtime implements at least the [`Core`] runtime api. This runtime api
+//! provides all the core functions that Substrate expects from a runtime.
+//!
+//! # Versioning
+//!
+//! Runtime apis support versioning. Each runtime api itself has a version attached. It is also
+//! supported to change function signatures or names in a non-breaking way. For more information on
+//! versioning check the [`decl_runtime_apis!`] macro.
+//!
+//! All runtime apis and their versions are returned as part of the [`RuntimeVersion`]. This can be
+//! used to check which runtime api version is currently provided by the on-chain runtime.
+//!
+//! # Testing
+//!
+//! For testing we provide the [`mock_impl_runtime_apis!`] macro that lets you implement a runtime
+//! api for a mocked object to use it in tests.
+//!
+//! # Logging
+//!
+//! Substrate supports logging from the runtime in native and in wasm. For that purpose it provides
+//! the [`RuntimeLogger`](sp_runtime::runtime_logger::RuntimeLogger). This runtime logger is
+//! automatically enabled for each call into the runtime through the runtime api. As logging
+//! introduces extra code that isn't actually required for the logic of your runtime and also
+//! increases the final wasm blob size, it is recommended to disable the logging for on-chain
+//! wasm blobs. This can be done by enabling the `disable-logging` feature of this crate. Be aware
+//! that this feature instructs `log` and `tracing` to disable logging at compile time by setting
+//! the `max_level_off` feature for these crates. So, you should not enable this feature for a
+//! native build as otherwise the node will not output any log messages.
+//!
+//! # How does it work?
+//!
+//! Each runtime api is declared as a trait with functions. When compiled to WASM, each implemented
+//! runtime api function is exported as a function with the following naming scheme
+//! `${TRAIT_NAME}_${FUNCTION_NAME}`. Such a function has the following signature
+//! `(ptr: *u8, length: u32) -> u64`. It takes a pointer to an `u8` array and its length as an
+//! argument. This `u8` array is expected to be the SCALE encoded parameters of the function as
+//! defined in the trait. The return value is an `u64` that represents `length << 32 | pointer` of
+//! an `u8` array. This return value `u8` array contains the SCALE encoded return value as defined
+//! by the trait function. The macros take care to encode the parameters and to decode the return
+//! value.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+// Make doc tests happy
+extern crate self as sp_api;
+
+#[doc(hidden)]
+pub use codec::{self, Decode, DecodeLimit, Encode};
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub use hash_db::Hasher;
+#[doc(hidden)]
+pub use scale_info;
+#[doc(hidden)]
+pub use sp_core::offchain;
+#[doc(hidden)]
+#[cfg(not(feature = "std"))]
+pub use sp_core::to_substrate_wasm_fn_return_value;
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub use sp_core::traits::CallContext;
+use sp_core::OpaqueMetadata;
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub use sp_externalities::{Extension, Extensions};
+#[doc(hidden)]
+#[cfg(feature = "frame-metadata")]
+pub use sp_metadata_ir::{self as metadata_ir, frame_metadata as metadata};
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub use sp_runtime::StateVersion;
+#[doc(hidden)]
+pub use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Hash as HashT, HashingFor, Header as HeaderT, NumberFor},
+	transaction_validity::TransactionValidity,
+	RuntimeString, TransactionOutcome,
+};
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub use sp_state_machine::{
+	backend::AsTrieBackend, Backend as StateBackend, InMemoryBackend, OverlayedChanges,
+	StorageProof, TrieBackend, TrieBackendBuilder,
+};
+#[doc(hidden)]
+pub use sp_std::{mem, slice, vec};
+#[doc(hidden)]
+pub use sp_version::{create_apis_vec, ApiId, ApisVec, RuntimeVersion};
+#[cfg(feature = "std")]
+use std::cell::RefCell;
+
+/// Maximum nesting level for extrinsics.
+pub const MAX_EXTRINSIC_DEPTH: u32 = 256;
+
+/// Declares given traits as runtime apis.
+///
+/// The macro will create two declarations, one for using on the client side and one for using
+/// on the runtime side. The declaration for the runtime side is hidden in its own module.
+/// The client side declaration gets two extra parameters per function,
+/// `&self` and `at: Block::Hash`. The runtime side declaration will match the given trait
+/// declaration. Besides one exception, the macro adds an extra generic parameter `Block:
+/// BlockT` to the client side and the runtime side. This generic parameter is usable by the
+/// user.
+///
+/// For implementing these macros you should use the
+/// [`impl_runtime_apis!`] macro.
+///
+/// # Example
+///
+/// ```rust
+/// sp_api::decl_runtime_apis! {
+///     /// Declare the api trait.
+///     pub trait Balance {
+///         /// Get the balance.
+///         fn get_balance() -> u64;
+///         /// Set the balance.
+///         fn set_balance(val: u64);
+///     }
+///
+///     /// You can declare multiple api traits in one macro call.
+///     /// In one module you can call the macro at maximum one time.
+///     pub trait BlockBuilder {
+///         /// The macro adds an explicit `Block: BlockT` generic parameter for you.
+///         /// You can use this generic parameter as you would defined it manually.
+///         fn build_block() -> Block;
+///     }
+/// }
+///
+/// # fn main() {}
+/// ```
+///
+/// # Runtime api trait versioning
+///
+/// To support versioning of the traits, the macro supports the attribute `#[api_version(1)]`.
+/// The attribute supports any `u32` as version. By default, each trait is at version `1`, if
+/// no version is provided. We also support changing the signature of a method. This signature
+/// change is highlighted with the `#[changed_in(2)]` attribute above a method. A method that
+/// is tagged with this attribute is callable by the name `METHOD_before_version_VERSION`. This
+/// method will only support calling into wasm, trying to call into native will fail (change
+/// the spec version!). Such a method also does not need to be implemented in the runtime. It
+/// is required that there exist the "default" of the method without the `#[changed_in(_)]`
+/// attribute, this method will be used to call the current default implementation.
+///
+/// ```rust
+/// sp_api::decl_runtime_apis! {
+///     /// Declare the api trait.
+///     #[api_version(2)]
+///     pub trait Balance {
+///         /// Get the balance.
+///         fn get_balance() -> u64;
+///         /// Set balance.
+///         fn set_balance(val: u64);
+///         /// Set balance, old version.
+///         ///
+///         /// Is callable by `set_balance_before_version_2`.
+///         #[changed_in(2)]
+///         fn set_balance(val: u16);
+///         /// In version 2, we added this new function.
+///         fn increase_balance(val: u64);
+///     }
+/// }
+///
+/// # fn main() {}
+/// ```
+///
+/// To check if a given runtime implements a runtime api trait, the `RuntimeVersion` has the
+/// function `has_api<A>()`. Also the `ApiExt` provides a function `has_api<A>(at: Hash)`
+/// to check if the runtime at the given block id implements the requested runtime api trait.
+///
+/// # Declaring multiple api versions
+///
+/// Optionally multiple versions of the same api can be declared. This is useful for
+/// development purposes. For example you want to have a testing version of the api which is
+/// available only on a testnet. You can define one stable and one development version. This
+/// can be done like this:
+/// ```rust
+/// sp_api::decl_runtime_apis! {
+///     /// Declare the api trait.
+/// 	#[api_version(2)]
+///     pub trait Balance {
+///         /// Get the balance.
+///         fn get_balance() -> u64;
+///         /// Set the balance.
+///         fn set_balance(val: u64);
+///         /// Transfer the balance to another user id
+///         #[api_version(3)]
+///         fn transfer_balance(uid: u64);
+///     }
+/// }
+///
+/// # fn main() {}
+/// ```
+/// The example above defines two api versions - 2 and 3. Version 2 contains `get_balance` and
+/// `set_balance`. Version 3 additionally contains `transfer_balance`, which is not available
+/// in version 2. Version 2 in this case is considered the default/base version of the api.
+/// More than two versions can be defined this way. For example:
+/// ```rust
+/// sp_api::decl_runtime_apis! {
+///     /// Declare the api trait.
+///     #[api_version(2)]
+///     pub trait Balance {
+///         /// Get the balance.
+///         fn get_balance() -> u64;
+///         /// Set the balance.
+///         fn set_balance(val: u64);
+///         /// Transfer the balance to another user id
+///         #[api_version(3)]
+///         fn transfer_balance(uid: u64);
+///         /// Clears the balance
+///         #[api_version(4)]
+///         fn clear_balance();
+///     }
+/// }
+///
+/// # fn main() {}
+/// ```
+/// Note that the latest version (4 in our example above) always contains all methods from all
+/// the versions before.
+pub use sp_api_proc_macro::decl_runtime_apis;
+
+/// Tags given trait implementations as runtime apis.
+///
+/// All traits given to this macro, need to be declared with the
+/// [`decl_runtime_apis!`](macro.decl_runtime_apis.html) macro. The implementation of the trait
+/// should follow the declaration given to the
+/// [`decl_runtime_apis!`](macro.decl_runtime_apis.html) macro, besides the `Block` type that
+/// is required as first generic parameter for each runtime api trait. When implementing a
+/// runtime api trait, it is required that the trait is referenced by a path, e.g. `impl
+/// my_trait::MyTrait for Runtime`. The macro will use this path to access the declaration of
+/// the trait for the runtime side.
+///
+/// The macro also generates the api implementations for the client side and provides it
+/// through the `RuntimeApi` type. The `RuntimeApi` is hidden behind a `feature` called `std`.
+///
+/// To expose version information about all implemented api traits, the constant
+/// `RUNTIME_API_VERSIONS` is generated. This constant should be used to instantiate the `apis`
+/// field of `RuntimeVersion`.
+///
+/// # Example
+///
+/// ```rust
+/// use sp_version::create_runtime_str;
+/// #
+/// # use sp_runtime::traits::Block as BlockT;
+/// # use sp_test_primitives::Block;
+/// #
+/// # /// The declaration of the `Runtime` type is done by the `construct_runtime!` macro
+/// # /// in a real runtime.
+/// # pub struct Runtime {}
+/// #
+/// # sp_api::decl_runtime_apis! {
+/// #     /// Declare the api trait.
+/// #     pub trait Balance {
+/// #         /// Get the balance.
+/// #         fn get_balance() -> u64;
+/// #         /// Set the balance.
+/// #         fn set_balance(val: u64);
+/// #     }
+/// #     pub trait BlockBuilder {
+/// #        fn build_block() -> Block;
+/// #     }
+/// # }
+///
+/// /// All runtime api implementations need to be done in one call of the macro!
+/// sp_api::impl_runtime_apis! {
+/// #   impl sp_api::Core<Block> for Runtime {
+/// #       fn version() -> sp_version::RuntimeVersion {
+/// #           unimplemented!()
+/// #       }
+/// #       fn execute_block(_block: Block) {}
+/// #       fn initialize_block(_header: &<Block as BlockT>::Header) {}
+/// #   }
+///
+///     impl self::Balance<Block> for Runtime {
+///         fn get_balance() -> u64 {
+///             1
+///         }
+///         fn set_balance(_bal: u64) {
+///             // Store the balance
+///         }
+///     }
+///
+///     impl self::BlockBuilder<Block> for Runtime {
+///         fn build_block() -> Block {
+///              unimplemented!("Please implement me!")
+///         }
+///     }
+/// }
+///
+/// /// Runtime version. This needs to be declared for each runtime.
+/// pub const VERSION: sp_version::RuntimeVersion = sp_version::RuntimeVersion {
+///     spec_name: create_runtime_str!("node"),
+///     impl_name: create_runtime_str!("test-node"),
+///     authoring_version: 1,
+///     spec_version: 1,
+///     impl_version: 0,
+///     // Here we are exposing the runtime api versions.
+///     apis: RUNTIME_API_VERSIONS,
+///     transaction_version: 1,
+///     state_version: 1,
+/// };
+///
+/// # fn main() {}
+/// ```
+///
+/// # Implementing specific api version
+///
+/// If `decl_runtime_apis!` declares multiple versions for an api `impl_runtime_apis!`
+/// should specify which version it implements by adding `api_version` attribute to the
+/// `impl` block. If omitted - the base/default version is implemented. Here is an example:
+/// ```ignore
+/// sp_api::impl_runtime_apis! {
+///     #[api_version(3)]
+///     impl self::Balance<Block> for Runtime {
+///          // implementation
+///     }
+/// }
+/// ```
+/// In this case `Balance` api version 3 is being implemented for `Runtime`. The `impl` block
+/// must contain all methods declared in version 3 and below.
+///
+/// # Conditional version implementation
+///
+/// `impl_runtime_apis!` supports `cfg_attr` attribute for conditional compilation. For example
+/// let's say you want to implement a staging version of the runtime api and put it behind a
+/// feature flag. You can do it this way:
+/// ```ignore
+/// pub struct Runtime {}
+/// sp_api::decl_runtime_apis! {
+///     pub trait ApiWithStagingMethod {
+///         fn stable_one(data: u64);
+///
+///         #[api_version(99)]
+///         fn staging_one();
+///     }
+/// }
+///
+/// sp_api::impl_runtime_apis! {
+///     #[cfg_attr(feature = "enable-staging-api", api_version(99))]
+///     impl self::ApiWithStagingMethod<Block> for Runtime {
+///         fn stable_one(_: u64) {}
+///
+///         #[cfg(feature = "enable-staging-api")]
+///         fn staging_one() {}
+///     }
+/// }
+/// ```
+///
+/// [`decl_runtime_apis!`] declares two version of the api - 1 (the default one, which is
+/// considered stable in our example) and 99 (which is considered staging). In
+/// `impl_runtime_apis!` a `cfg_attr` attribute is attached to the `ApiWithStagingMethod`
+/// implementation. If the code is compiled with  `enable-staging-api` feature a version 99 of
+/// the runtime api will be built which will include `staging_one`. Note that `staging_one`
+/// implementation is feature gated by `#[cfg(feature = ... )]` attribute.
+///
+/// If the code is compiled without `enable-staging-api` version 1 (the default one) will be
+/// built which doesn't include `staging_one`.
+///
+/// `cfg_attr` can also be used together with `api_version`. For the next snippet will build
+/// version 99 if `enable-staging-api` is enabled and version 2 otherwise because both
+/// `cfg_attr` and `api_version` are attached to the impl block:
+/// ```ignore
+/// #[cfg_attr(feature = "enable-staging-api", api_version(99))]
+/// #[api_version(2)]
+/// impl self::ApiWithStagingAndVersionedMethods<Block> for Runtime {
+///  // impl skipped
+/// }
+/// ```
+pub use sp_api_proc_macro::impl_runtime_apis;
+
+/// Mocks given trait implementations as runtime apis.
+///
+/// Accepts similar syntax as [`impl_runtime_apis!`] and generates
+/// simplified mock implementations of the given runtime apis. The difference in syntax is that
+/// the trait does not need to be referenced by a qualified path, methods accept the `&self`
+/// parameter and the error type can be specified as associated type. If no error type is
+/// specified [`String`] is used as error type.
+///
+/// Besides implementing the given traits, the [`Core`](sp_api::Core) and
+/// [`ApiExt`](sp_api::ApiExt) are implemented automatically.
+///
+/// # Example
+///
+/// ```rust
+/// # use sp_runtime::traits::Block as BlockT;
+/// # use sp_test_primitives::Block;
+/// #
+/// # sp_api::decl_runtime_apis! {
+/// #     /// Declare the api trait.
+/// #     pub trait Balance {
+/// #         /// Get the balance.
+/// #         fn get_balance() -> u64;
+/// #         /// Set the balance.
+/// #         fn set_balance(val: u64);
+/// #     }
+/// #     pub trait BlockBuilder {
+/// #        fn build_block() -> Block;
+/// #     }
+/// # }
+/// struct MockApi {
+///     balance: u64,
+/// }
+///
+/// /// All runtime api mock implementations need to be done in one call of the macro!
+/// sp_api::mock_impl_runtime_apis! {
+///     impl Balance<Block> for MockApi {
+///         /// Here we take the `&self` to access the instance.
+///         fn get_balance(&self) -> u64 {
+///             self.balance
+///         }
+///         fn set_balance(_bal: u64) {
+///             // Store the balance
+///         }
+///     }
+///
+///     impl BlockBuilder<Block> for MockApi {
+///         fn build_block() -> Block {
+///              unimplemented!("Not Required in tests")
+///         }
+///     }
+/// }
+///
+/// # fn main() {}
+/// ```
+///
+/// # `advanced` attribute
+///
+/// This attribute can be placed above individual function in the mock implementation to
+/// request more control over the function declaration. From the client side each runtime api
+/// function is called with the `at` parameter that is a [`Hash`](sp_runtime::traits::Hash).
+/// When using the `advanced` attribute, the macro expects that the first parameter of the
+/// function is this `at` parameter. Besides that the macro also doesn't do the automatic
+/// return value rewrite, which means that full return value must be specified. The full return
+/// value is constructed like [`Result`]`<<ReturnValue>, Error>` while `ReturnValue` being the
+/// return value that is specified in the trait declaration.
+///
+/// ## Example
+/// ```rust
+/// # use sp_runtime::traits::Block as BlockT;
+/// # use sp_test_primitives::Block;
+/// # use codec;
+/// #
+/// # sp_api::decl_runtime_apis! {
+/// #     /// Declare the api trait.
+/// #     pub trait Balance {
+/// #         /// Get the balance.
+/// #         fn get_balance() -> u64;
+/// #         /// Set the balance.
+/// #         fn set_balance(val: u64);
+/// #     }
+/// # }
+/// struct MockApi {
+///     balance: u64,
+/// }
+///
+/// sp_api::mock_impl_runtime_apis! {
+///     impl Balance<Block> for MockApi {
+///         #[advanced]
+///         fn get_balance(&self, at: <Block as BlockT>::Hash) -> Result<u64, sp_api::ApiError> {
+///             println!("Being called at: {}", at);
+///
+///             Ok(self.balance.into())
+///         }
+///         #[advanced]
+///         fn set_balance(at: <Block as BlockT>::Hash, val: u64) -> Result<(), sp_api::ApiError> {
+///             println!("Being called at: {}", at);
+///
+///             Ok(().into())
+///         }
+///     }
+/// }
+///
+/// # fn main() {}
+/// ```
+pub use sp_api_proc_macro::mock_impl_runtime_apis;
+
+/// A type that records all accessed trie nodes and generates a proof out of it.
+#[cfg(feature = "std")]
+pub type ProofRecorder<B> = sp_trie::recorder::Recorder<HashingFor<B>>;
+
+#[cfg(feature = "std")]
+pub type StorageChanges<Block> = sp_state_machine::StorageChanges<HashingFor<Block>>;
+
+/// Something that can be constructed to a runtime api.
+#[cfg(feature = "std")]
+pub trait ConstructRuntimeApi<Block: BlockT, C: CallApiAt<Block>> {
+	/// The actual runtime api that will be constructed.
+	type RuntimeApi: ApiExt<Block>;
+
+	/// Construct an instance of the runtime api.
+	fn construct_runtime_api(call: &C) -> ApiRef<Self::RuntimeApi>;
+}
+
+/// Init the [`RuntimeLogger`](sp_runtime::runtime_logger::RuntimeLogger).
+pub fn init_runtime_logger() {
+	#[cfg(not(feature = "disable-logging"))]
+	sp_runtime::runtime_logger::RuntimeLogger::init();
+}
+
+/// An error describing which API call failed.
+#[cfg(feature = "std")]
+#[derive(Debug, thiserror::Error)]
+pub enum ApiError {
+	#[error("Failed to decode return value of {function}")]
+	FailedToDecodeReturnValue {
+		function: &'static str,
+		#[source]
+		error: codec::Error,
+	},
+	#[error("Failed to convert return value from runtime to node of {function}")]
+	FailedToConvertReturnValue {
+		function: &'static str,
+		#[source]
+		error: codec::Error,
+	},
+	#[error("Failed to convert parameter `{parameter}` from node to runtime of {function}")]
+	FailedToConvertParameter {
+		function: &'static str,
+		parameter: &'static str,
+		#[source]
+		error: codec::Error,
+	},
+	#[error("The given `StateBackend` isn't a `TrieBackend`.")]
+	StateBackendIsNotTrie,
+	#[error(transparent)]
+	Application(#[from] Box<dyn std::error::Error + Send + Sync>),
+	#[error("Api called for an unknown Block: {0}")]
+	UnknownBlock(String),
+	#[error("Using the same api instance to call into multiple independent blocks.")]
+	UsingSameInstanceForDifferentBlocks,
+}
+
+/// Extends the runtime api implementation with some common functionality.
+#[cfg(feature = "std")]
+pub trait ApiExt<Block: BlockT> {
+	/// Execute the given closure inside a new transaction.
+	///
+	/// Depending on the outcome of the closure, the transaction is committed or rolled-back.
+	///
+	/// The internal result of the closure is returned afterwards.
+	fn execute_in_transaction<F: FnOnce(&Self) -> TransactionOutcome<R>, R>(&self, call: F) -> R
+	where
+		Self: Sized;
+
+	/// Checks if the given api is implemented and versions match.
+	fn has_api<A: RuntimeApiInfo + ?Sized>(&self, at_hash: Block::Hash) -> Result<bool, ApiError>
+	where
+		Self: Sized;
+
+	/// Check if the given api is implemented and the version passes a predicate.
+	fn has_api_with<A: RuntimeApiInfo + ?Sized, P: Fn(u32) -> bool>(
+		&self,
+		at_hash: Block::Hash,
+		pred: P,
+	) -> Result<bool, ApiError>
+	where
+		Self: Sized;
+
+	/// Returns the version of the given api.
+	fn api_version<A: RuntimeApiInfo + ?Sized>(
+		&self,
+		at_hash: Block::Hash,
+	) -> Result<Option<u32>, ApiError>
+	where
+		Self: Sized;
+
+	/// Start recording all accessed trie nodes for generating proofs.
+	fn record_proof(&mut self);
+
+	/// Extract the recorded proof.
+	///
+	/// This stops the proof recording.
+	///
+	/// If `record_proof` was not called before, this will return `None`.
+	fn extract_proof(&mut self) -> Option<StorageProof>;
+
+	/// Returns the current active proof recorder.
+	fn proof_recorder(&self) -> Option<ProofRecorder<Block>>;
+
+	/// Convert the api object into the storage changes that were done while executing runtime
+	/// api functions.
+	///
+	/// After executing this function, all collected changes are reset.
+	fn into_storage_changes<B: StateBackend<HashingFor<Block>>>(
+		&self,
+		backend: &B,
+		parent_hash: Block::Hash,
+	) -> Result<StorageChanges<Block>, String>
+	where
+		Self: Sized;
+
+	/// Set the [`CallContext`] to be used by the runtime api calls done by this instance.
+	fn set_call_context(&mut self, call_context: CallContext);
+
+	/// Register an [`Extension`] that will be accessible while executing a runtime api call.
+	fn register_extension<E: Extension>(&mut self, extension: E);
+}
+
+/// Parameters for [`CallApiAt::call_api_at`].
+#[cfg(feature = "std")]
+pub struct CallApiAtParams<'a, Block: BlockT> {
+	/// The block id that determines the state that should be setup when calling the function.
+	pub at: Block::Hash,
+	/// The name of the function that should be called.
+	pub function: &'static str,
+	/// The encoded arguments of the function.
+	pub arguments: Vec<u8>,
+	/// The overlayed changes that are on top of the state.
+	pub overlayed_changes: &'a RefCell<OverlayedChanges<HashingFor<Block>>>,
+	/// The call context of this call.
+	pub call_context: CallContext,
+	/// The optional proof recorder for recording storage accesses.
+	pub recorder: &'a Option<ProofRecorder<Block>>,
+	/// The extensions that should be used for this call.
+	pub extensions: &'a RefCell<Extensions>,
+}
+
+/// Something that can call into the an api at a given block.
+#[cfg(feature = "std")]
+pub trait CallApiAt<Block: BlockT> {
+	/// The state backend that is used to store the block states.
+	type StateBackend: StateBackend<HashingFor<Block>> + AsTrieBackend<HashingFor<Block>>;
+
+	/// Calls the given api function with the given encoded arguments at the given block and returns
+	/// the encoded result.
+	fn call_api_at(&self, params: CallApiAtParams<Block>) -> Result<Vec<u8>, ApiError>;
+
+	/// Returns the runtime version at the given block.
+	fn runtime_version_at(&self, at_hash: Block::Hash) -> Result<RuntimeVersion, ApiError>;
+
+	/// Get the state `at` the given block.
+	fn state_at(&self, at: Block::Hash) -> Result<Self::StateBackend, ApiError>;
+
+	/// Initialize the `extensions` for the given block `at` by using the global extensions factory.
+	fn initialize_extensions(
+		&self,
+		at: Block::Hash,
+		extensions: &mut Extensions,
+	) -> Result<(), ApiError>;
+}
+
+/// Auxiliary wrapper that holds an api instance and binds it to the given lifetime.
+#[cfg(feature = "std")]
+pub struct ApiRef<'a, T>(T, std::marker::PhantomData<&'a ()>);
+
+#[cfg(feature = "std")]
+impl<'a, T> From<T> for ApiRef<'a, T> {
+	fn from(api: T) -> Self {
+		ApiRef(api, Default::default())
+	}
+}
+
+#[cfg(feature = "std")]
+impl<'a, T> std::ops::Deref for ApiRef<'a, T> {
+	type Target = T;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+#[cfg(feature = "std")]
+impl<'a, T> std::ops::DerefMut for ApiRef<'a, T> {
+	fn deref_mut(&mut self) -> &mut T {
+		&mut self.0
+	}
+}
+
+/// Something that provides a runtime api.
+#[cfg(feature = "std")]
+pub trait ProvideRuntimeApi<Block: BlockT> {
+	/// The concrete type that provides the api.
+	type Api: ApiExt<Block>;
+
+	/// Returns the runtime api.
+	/// The returned instance will keep track of modifications to the storage. Any successful
+	/// call to an api function, will `commit` its changes to an internal buffer. Otherwise,
+	/// the modifications will be `discarded`. The modifications will not be applied to the
+	/// storage, even on a `commit`.
+	fn runtime_api(&self) -> ApiRef<Self::Api>;
+}
+
+/// Something that provides information about a runtime api.
+#[cfg(feature = "std")]
+pub trait RuntimeApiInfo {
+	/// The identifier of the runtime api.
+	const ID: [u8; 8];
+	/// The version of the runtime api.
+	const VERSION: u32;
+}
+
+/// The number of bytes required to encode a [`RuntimeApiInfo`].
+///
+/// 8 bytes for `ID` and 4 bytes for a version.
+pub const RUNTIME_API_INFO_SIZE: usize = 12;
+
+/// Crude and simple way to serialize the `RuntimeApiInfo` into a bunch of bytes.
+pub const fn serialize_runtime_api_info(id: [u8; 8], version: u32) -> [u8; RUNTIME_API_INFO_SIZE] {
+	let version = version.to_le_bytes();
+
+	let mut r = [0; RUNTIME_API_INFO_SIZE];
+	r[0] = id[0];
+	r[1] = id[1];
+	r[2] = id[2];
+	r[3] = id[3];
+	r[4] = id[4];
+	r[5] = id[5];
+	r[6] = id[6];
+	r[7] = id[7];
+
+	r[8] = version[0];
+	r[9] = version[1];
+	r[10] = version[2];
+	r[11] = version[3];
+	r
+}
+
+/// Deserialize the runtime API info serialized by [`serialize_runtime_api_info`].
+pub fn deserialize_runtime_api_info(bytes: [u8; RUNTIME_API_INFO_SIZE]) -> ([u8; 8], u32) {
+	let id: [u8; 8] = bytes[0..8]
+		.try_into()
+		.expect("the source slice size is equal to the dest array length; qed");
+
+	let version = u32::from_le_bytes(
+		bytes[8..12]
+			.try_into()
+			.expect("the source slice size is equal to the array length; qed"),
+	);
+
+	(id, version)
+}
+
+decl_runtime_apis! {
+	/// The `Core` runtime api that every Substrate runtime needs to implement.
+	#[core_trait]
+	#[api_version(4)]
+	pub trait Core {
+		/// Returns the version of the runtime.
+		fn version() -> RuntimeVersion;
+		/// Execute the given block.
+		fn execute_block(block: Block);
+		/// Initialize a block with the given header.
+		#[renamed("initialise_block", 2)]
+		fn initialize_block(header: &<Block as BlockT>::Header);
+	}
+
+	/// The `Metadata` api trait that returns metadata for the runtime.
+	#[api_version(2)]
+	pub trait Metadata {
+		/// Returns the metadata of a runtime.
+		fn metadata() -> OpaqueMetadata;
+
+		/// Returns the metadata at a given version.
+		///
+		/// If the given `version` isn't supported, this will return `None`.
+		/// Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime.
+		fn metadata_at_version(version: u32) -> Option<OpaqueMetadata>;
+
+		/// Returns the supported metadata versions.
+		///
+		/// This can be used to call `metadata_at_version`.
+		fn metadata_versions() -> sp_std::vec::Vec<u32>;
+	}
+}
+
+sp_core::generate_feature_enabled_macro!(std_enabled, feature = "std", $);
+sp_core::generate_feature_enabled_macro!(std_disabled, not(feature = "std"), $);
diff --git a/substrate/primitives/api/test/Cargo.toml b/substrate/primitives/api/test/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..48eb067e4e474c2780fe344a48283e9859f6f065
--- /dev/null
+++ b/substrate/primitives/api/test/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "sp-api-test"
+version = "2.0.1"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-api = { version = "4.0.0-dev", path = "../" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
+sp-version = { version = "22.0.0", path = "../../version" }
+sp-tracing = { version = "10.0.0", path = "../../tracing" }
+sp-runtime = { version = "24.0.0", path = "../../runtime" }
+sp-consensus = { version = "0.10.0-dev", path = "../../consensus/common" }
+sc-block-builder = { version = "0.10.0-dev", path = "../../../client/block-builder" }
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+sp-state-machine = { version = "0.28.0", path = "../../state-machine" }
+trybuild = "1.0.74"
+rustversion = "1.0.6"
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+[dev-dependencies]
+criterion = "0.4.0"
+futures = "0.3.21"
+log = "0.4.17"
+sp-core = { version = "21.0.0", path = "../../core" }
+static_assertions = "1.1.0"
+
+[[bench]]
+name = "bench"
+harness = false
+
+[features]
+"enable-staging-api" = []
diff --git a/substrate/primitives/api/test/benches/bench.rs b/substrate/primitives/api/test/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..45bea08af6deded5d85fcbb32dcf873359fb0e34
--- /dev/null
+++ b/substrate/primitives/api/test/benches/bench.rs
@@ -0,0 +1,71 @@
+// 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 criterion::{criterion_group, criterion_main, Criterion};
+use sp_api::ProvideRuntimeApi;
+use substrate_test_runtime_client::{
+	runtime::TestAPI, DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+fn sp_api_benchmark(c: &mut Criterion) {
+	c.bench_function("add one with same runtime api", |b| {
+		let client = substrate_test_runtime_client::new();
+		let runtime_api = client.runtime_api();
+		let best_hash = client.chain_info().best_hash;
+
+		b.iter(|| runtime_api.benchmark_add_one(best_hash, &1))
+	});
+
+	c.bench_function("add one with recreating runtime api", |b| {
+		let client = substrate_test_runtime_client::new();
+		let best_hash = client.chain_info().best_hash;
+
+		b.iter(|| client.runtime_api().benchmark_add_one(best_hash, &1))
+	});
+
+	c.bench_function("vector add one with same runtime api", |b| {
+		let client = substrate_test_runtime_client::new();
+		let runtime_api = client.runtime_api();
+		let best_hash = client.chain_info().best_hash;
+		let data = vec![0; 1000];
+
+		b.iter_with_large_drop(|| runtime_api.benchmark_vector_add_one(best_hash, &data))
+	});
+
+	c.bench_function("vector add one with recreating runtime api", |b| {
+		let client = substrate_test_runtime_client::new();
+		let best_hash = client.chain_info().best_hash;
+		let data = vec![0; 1000];
+
+		b.iter_with_large_drop(|| client.runtime_api().benchmark_vector_add_one(best_hash, &data))
+	});
+
+	c.bench_function("calling function by function pointer in wasm", |b| {
+		let client = TestClientBuilder::new().build();
+		let best_hash = client.chain_info().best_hash;
+		b.iter(|| client.runtime_api().benchmark_indirect_call(best_hash).unwrap())
+	});
+
+	c.bench_function("calling function", |b| {
+		let client = TestClientBuilder::new().build();
+		let best_hash = client.chain_info().best_hash;
+		b.iter(|| client.runtime_api().benchmark_direct_call(best_hash).unwrap())
+	});
+}
+
+criterion_group!(benches, sp_api_benchmark);
+criterion_main!(benches);
diff --git a/substrate/primitives/api/test/tests/decl_and_impl.rs b/substrate/primitives/api/test/tests/decl_and_impl.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6e895680e41c4c120c67e3313d31a5ac16840918
--- /dev/null
+++ b/substrate/primitives/api/test/tests/decl_and_impl.rs
@@ -0,0 +1,308 @@
+// 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 sp_api::{
+	decl_runtime_apis, impl_runtime_apis, mock_impl_runtime_apis, ApiError, ApiExt, RuntimeApiInfo,
+};
+use sp_runtime::traits::Block as BlockT;
+
+use substrate_test_runtime_client::runtime::{Block, Hash};
+
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+pub struct Runtime {}
+
+decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+		fn something_with_block(block: Block) -> Block;
+		fn function_with_two_args(data: u64, block: Block);
+		fn same_name();
+		fn wild_card(_: u32);
+	}
+
+	#[api_version(2)]
+	pub trait ApiWithCustomVersion {
+		fn same_name();
+		#[changed_in(2)]
+		fn same_name() -> String;
+	}
+
+	#[api_version(2)]
+	pub trait ApiWithMultipleVersions {
+		fn stable_one(data: u64);
+		#[api_version(3)]
+		fn new_one();
+		#[api_version(4)]
+		fn glory_one();
+	}
+
+	pub trait ApiWithStagingMethod {
+		fn stable_one(data: u64);
+		#[api_version(99)]
+		fn staging_one();
+	}
+
+	pub trait ApiWithStagingAndVersionedMethods {
+		fn stable_one(data: u64);
+		#[api_version(2)]
+		fn new_one();
+		#[api_version(99)]
+		fn staging_one();
+	}
+
+	#[api_version(2)]
+	pub trait ApiWithStagingAndChangedBase {
+		fn stable_one(data: u64);
+		fn new_one();
+		#[api_version(99)]
+		fn staging_one();
+	}
+
+}
+
+impl_runtime_apis! {
+	impl self::Api<Block> for Runtime {
+		fn test(_: u64) {
+			unimplemented!()
+		}
+
+		fn something_with_block(_: Block) -> Block {
+			unimplemented!()
+		}
+
+		fn function_with_two_args(_: u64, _: Block) {
+			unimplemented!()
+		}
+
+		fn same_name() {}
+
+		fn wild_card(_: u32) {}
+	}
+
+	impl self::ApiWithCustomVersion<Block> for Runtime {
+		fn same_name() {}
+	}
+
+	#[api_version(3)]
+	impl self::ApiWithMultipleVersions<Block> for Runtime {
+		fn stable_one(_: u64) {}
+
+		fn new_one() {}
+	}
+
+	#[cfg_attr(feature = "enable-staging-api", api_version(99))]
+	impl self::ApiWithStagingMethod<Block> for Runtime {
+		fn stable_one(_: u64) {}
+
+		#[cfg(feature = "enable-staging-api")]
+		fn staging_one() { }
+	}
+
+	#[cfg_attr(feature = "enable-staging-api", api_version(99))]
+	#[api_version(2)]
+	impl self::ApiWithStagingAndVersionedMethods<Block> for Runtime {
+		fn stable_one(_: u64) {}
+		fn new_one() {}
+
+		#[cfg(feature = "enable-staging-api")]
+		fn staging_one() {}
+	}
+
+	#[cfg_attr(feature = "enable-staging-api", api_version(99))]
+	impl self::ApiWithStagingAndChangedBase<Block> for Runtime {
+		fn stable_one(_: u64) {}
+		fn new_one() {}
+
+		#[cfg(feature = "enable-staging-api")]
+		fn staging_one() {}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+struct MockApi {
+	block: Option<Block>,
+}
+
+mock_impl_runtime_apis! {
+	impl Api<Block> for MockApi {
+		fn test(_: u64) {
+			unimplemented!()
+		}
+
+		fn something_with_block(&self, _: Block) -> Block {
+			self.block.clone().unwrap()
+		}
+
+		fn function_with_two_args(_: u64, _: Block) {
+			unimplemented!()
+		}
+
+		#[advanced]
+		fn same_name(_: <Block as BlockT>::Hash) -> Result<(), ApiError> {
+			Ok(().into())
+		}
+
+		#[advanced]
+		fn wild_card(at: <Block as BlockT>::Hash, _: u32) -> Result<(), ApiError> {
+			if Hash::repeat_byte(0x0f) == at {
+				// yeah
+				Ok(().into())
+			} else {
+				Err((Box::from("Test error") as Box<dyn std::error::Error + Send + Sync>).into())
+			}
+		}
+	}
+
+	impl ApiWithCustomVersion<Block> for MockApi {
+		fn same_name() {}
+	}
+}
+
+type TestClient = substrate_test_runtime_client::client::Client<
+	substrate_test_runtime_client::Backend,
+	substrate_test_runtime_client::ExecutorDispatch,
+	Block,
+	RuntimeApi,
+>;
+
+#[test]
+fn test_client_side_function_signature() {
+	let _test: fn(
+		&RuntimeApiImpl<Block, TestClient>,
+		<Block as BlockT>::Hash,
+		u64,
+	) -> Result<(), ApiError> = RuntimeApiImpl::<Block, TestClient>::test;
+	let _something_with_block: fn(
+		&RuntimeApiImpl<Block, TestClient>,
+		<Block as BlockT>::Hash,
+		Block,
+	) -> Result<Block, ApiError> = RuntimeApiImpl::<Block, TestClient>::something_with_block;
+
+	#[allow(deprecated)]
+	let _same_name_before_version_2: fn(
+		&RuntimeApiImpl<Block, TestClient>,
+		<Block as BlockT>::Hash,
+	) -> Result<String, ApiError> = RuntimeApiImpl::<Block, TestClient>::same_name_before_version_2;
+}
+
+#[test]
+fn check_runtime_api_info() {
+	assert_eq!(&<dyn Api::<Block>>::ID, &runtime_decl_for_api::ID);
+	assert_eq!(<dyn Api::<Block>>::VERSION, runtime_decl_for_api::VERSION);
+	assert_eq!(<dyn Api::<Block>>::VERSION, 1);
+
+	assert_eq!(
+		<dyn ApiWithCustomVersion::<Block>>::VERSION,
+		runtime_decl_for_api_with_custom_version::VERSION,
+	);
+	assert_eq!(
+		&<dyn ApiWithCustomVersion::<Block>>::ID,
+		&runtime_decl_for_api_with_custom_version::ID,
+	);
+	assert_eq!(<dyn ApiWithCustomVersion::<Block>>::VERSION, 2);
+
+	// The stable version of the API
+	assert_eq!(<dyn ApiWithMultipleVersions::<Block>>::VERSION, 2);
+
+	assert_eq!(<dyn ApiWithStagingMethod::<Block>>::VERSION, 1);
+	assert_eq!(<dyn ApiWithStagingAndVersionedMethods::<Block>>::VERSION, 1);
+	assert_eq!(<dyn ApiWithStagingAndChangedBase::<Block>>::VERSION, 2);
+}
+
+fn check_runtime_api_versions_contains<T: RuntimeApiInfo + ?Sized>() {
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, T::VERSION)));
+}
+
+fn check_staging_runtime_api_versions<T: RuntimeApiInfo + ?Sized>(_staging_ver: u32) {
+	// Staging APIs should contain staging version if the feature is set...
+	#[cfg(feature = "enable-staging-api")]
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, _staging_ver)));
+	//... otherwise the base version should be set
+	#[cfg(not(feature = "enable-staging-api"))]
+	check_runtime_api_versions_contains::<dyn ApiWithStagingMethod<Block>>();
+}
+
+#[allow(unused_assignments)]
+fn check_staging_multiver_runtime_api_versions<T: RuntimeApiInfo + ?Sized>(
+	_staging_ver: u32,
+	_stable_ver: u32,
+) {
+	// Staging APIs should contain staging version if the feature is set...
+	#[cfg(feature = "enable-staging-api")]
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, _staging_ver)));
+	//... otherwise the base version should be set
+	#[cfg(not(feature = "enable-staging-api"))]
+	assert!(RUNTIME_API_VERSIONS.iter().any(|v| v == &(T::ID, _stable_ver)));
+}
+
+#[test]
+fn check_runtime_api_versions() {
+	check_runtime_api_versions_contains::<dyn Api<Block>>();
+	check_runtime_api_versions_contains::<dyn ApiWithCustomVersion<Block>>();
+	assert!(RUNTIME_API_VERSIONS
+		.iter()
+		.any(|v| v == &(<dyn ApiWithMultipleVersions<Block>>::ID, 3)));
+
+	check_staging_runtime_api_versions::<dyn ApiWithStagingMethod<Block>>(99);
+	check_staging_multiver_runtime_api_versions::<dyn ApiWithStagingAndVersionedMethods<Block>>(
+		99, 2,
+	);
+	check_staging_runtime_api_versions::<dyn ApiWithStagingAndChangedBase<Block>>(99);
+
+	check_runtime_api_versions_contains::<dyn sp_api::Core<Block>>();
+}
+
+#[test]
+fn mock_runtime_api_has_api() {
+	let mock = MockApi { block: None };
+
+	assert!(mock.has_api::<dyn ApiWithCustomVersion<Block>>(Hash::default()).unwrap());
+	assert!(mock.has_api::<dyn Api<Block>>(Hash::default()).unwrap());
+}
+
+#[test]
+#[should_panic(expected = "Calling deprecated methods is not supported by mocked runtime api.")]
+fn mock_runtime_api_panics_on_calling_old_version() {
+	let mock = MockApi { block: None };
+
+	#[allow(deprecated)]
+	let _ = mock.same_name_before_version_2(Hash::default());
+}
+
+#[test]
+fn mock_runtime_api_works_with_advanced() {
+	let mock = MockApi { block: None };
+
+	Api::<Block>::same_name(&mock, Hash::default()).unwrap();
+	mock.wild_card(Hash::repeat_byte(0x0f), 1).unwrap();
+	assert_eq!(
+		"Test error".to_string(),
+		mock.wild_card(Hash::repeat_byte(0x01), 1).unwrap_err().to_string(),
+	);
+}
diff --git a/substrate/primitives/api/test/tests/runtime_calls.rs b/substrate/primitives/api/test/tests/runtime_calls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..353be73dcccdadec537b189e3aadc9d7b913c37b
--- /dev/null
+++ b/substrate/primitives/api/test/tests/runtime_calls.rs
@@ -0,0 +1,220 @@
+// 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 std::panic::UnwindSafe;
+
+use sp_api::{ApiExt, Core, ProvideRuntimeApi};
+use sp_runtime::{
+	traits::{HashingFor, Header as HeaderT},
+	TransactionOutcome,
+};
+use sp_state_machine::{create_proof_check_backend, execution_proof_check_on_trie_backend};
+
+use substrate_test_runtime_client::{
+	prelude::*,
+	runtime::{Block, Header, TestAPI, Transfer},
+	DefaultTestClientBuilderExt, TestClient, TestClientBuilder,
+};
+
+use codec::Encode;
+use sc_block_builder::BlockBuilderProvider;
+use sp_consensus::SelectChain;
+use substrate_test_runtime_client::sc_executor::WasmExecutor;
+
+#[test]
+fn calling_runtime_function() {
+	let client = TestClientBuilder::new().build();
+	let runtime_api = client.runtime_api();
+	let best_hash = client.chain_info().best_hash;
+
+	assert_eq!(runtime_api.benchmark_add_one(best_hash, &1).unwrap(), 2);
+}
+
+#[test]
+fn calling_native_runtime_signature_changed_function() {
+	let client = TestClientBuilder::new().build();
+	let runtime_api = client.runtime_api();
+	let best_hash = client.chain_info().best_hash;
+
+	assert_eq!(runtime_api.function_signature_changed(best_hash).unwrap(), 1);
+}
+
+#[test]
+fn use_trie_function() {
+	let client = TestClientBuilder::new().build();
+	let runtime_api = client.runtime_api();
+	let best_hash = client.chain_info().best_hash;
+	assert_eq!(runtime_api.use_trie(best_hash).unwrap(), 2);
+}
+
+#[test]
+fn initialize_block_works() {
+	let client = TestClientBuilder::new().build();
+	let runtime_api = client.runtime_api();
+	let best_hash = client.chain_info().best_hash;
+	runtime_api
+		.initialize_block(
+			best_hash,
+			&Header::new(
+				1,
+				Default::default(),
+				Default::default(),
+				Default::default(),
+				Default::default(),
+			),
+		)
+		.unwrap();
+	assert_eq!(runtime_api.get_block_number(best_hash).unwrap(), 1);
+}
+
+#[test]
+fn record_proof_works() {
+	let (client, longest_chain) = TestClientBuilder::new().build_with_longest_chain();
+
+	let storage_root =
+		*futures::executor::block_on(longest_chain.best_chain()).unwrap().state_root();
+
+	let runtime_code = sp_core::traits::RuntimeCode {
+		code_fetcher: &sp_core::traits::WrappedRuntimeCode(
+			client.code_at(client.chain_info().best_hash).unwrap().into(),
+		),
+		hash: vec![1],
+		heap_pages: None,
+	};
+
+	let transaction = Transfer {
+		amount: 1000,
+		nonce: 0,
+		from: AccountKeyring::Alice.into(),
+		to: AccountKeyring::Bob.into(),
+	}
+	.into_unchecked_extrinsic();
+
+	// Build the block and record proof
+	let mut builder = client
+		.new_block_at(client.chain_info().best_hash, Default::default(), true)
+		.expect("Creates block builder");
+	builder.push(transaction.clone()).unwrap();
+	let (block, _, proof) = builder.build().expect("Bake block").into_inner();
+
+	let backend = create_proof_check_backend::<HashingFor<Block>>(
+		storage_root,
+		proof.expect("Proof was generated"),
+	)
+	.expect("Creates proof backend.");
+
+	// Use the proof backend to execute `execute_block`.
+	let mut overlay = Default::default();
+	let executor = NativeElseWasmExecutor::<LocalExecutorDispatch>::new_with_wasm_executor(
+		WasmExecutor::builder().build(),
+	);
+	execution_proof_check_on_trie_backend(
+		&backend,
+		&mut overlay,
+		&executor,
+		"Core_execute_block",
+		&block.encode(),
+		&runtime_code,
+	)
+	.expect("Executes block while using the proof backend");
+}
+
+#[test]
+fn call_runtime_api_with_multiple_arguments() {
+	let client = TestClientBuilder::new().build();
+
+	let data = vec![1, 2, 4, 5, 6, 7, 8, 8, 10, 12];
+	let best_hash = client.chain_info().best_hash;
+	client
+		.runtime_api()
+		.test_multiple_arguments(best_hash, data.clone(), data.clone(), data.len() as u32)
+		.unwrap();
+}
+
+#[test]
+fn disable_logging_works() {
+	if std::env::var("RUN_TEST").is_ok() {
+		sp_tracing::try_init_simple();
+
+		let mut builder = TestClientBuilder::new();
+		builder.genesis_init_mut().set_wasm_code(
+			substrate_test_runtime_client::runtime::wasm_binary_logging_disabled_unwrap().to_vec(),
+		);
+
+		let client = builder.build();
+		let runtime_api = client.runtime_api();
+		runtime_api
+			.do_trace_log(client.chain_info().genesis_hash)
+			.expect("Logging should not fail");
+		log::error!("Logging from native works");
+	} else {
+		let executable = std::env::current_exe().unwrap();
+		let output = std::process::Command::new(executable)
+			.env("RUN_TEST", "1")
+			.env("RUST_LOG", "info")
+			.args(&["--nocapture", "disable_logging_works"])
+			.output()
+			.unwrap();
+
+		let output = dbg!(String::from_utf8(output.stderr).unwrap());
+		assert!(!output.contains("Hey I'm runtime"));
+		assert!(output.contains("Logging from native works"));
+	}
+}
+
+// Certain logic like the transaction handling is not unwind safe.
+//
+// Ensure that the type is not unwind safe!
+static_assertions::assert_not_impl_any!(<TestClient as ProvideRuntimeApi<_>>::Api: UnwindSafe);
+
+#[test]
+fn ensure_transactional_works() {
+	const KEY: &[u8] = b"test";
+
+	let client = TestClientBuilder::new().build();
+	let best_hash = client.chain_info().best_hash;
+
+	let runtime_api = client.runtime_api();
+	runtime_api.execute_in_transaction(|api| {
+		api.write_key_value(best_hash, KEY.to_vec(), vec![1, 2, 3], false).unwrap();
+
+		api.execute_in_transaction(|api| {
+			api.write_key_value(best_hash, KEY.to_vec(), vec![1, 2, 3, 4], false).unwrap();
+
+			TransactionOutcome::Commit(())
+		});
+
+		TransactionOutcome::Commit(())
+	});
+
+	let changes = runtime_api
+		.into_storage_changes(&client.state_at(best_hash).unwrap(), best_hash)
+		.unwrap();
+	assert_eq!(changes.main_storage_changes[0].1, Some(vec![1, 2, 3, 4]));
+
+	let runtime_api = client.runtime_api();
+	runtime_api.execute_in_transaction(|api| {
+		assert!(api.write_key_value(best_hash, KEY.to_vec(), vec![1, 2, 3], true).is_err());
+
+		TransactionOutcome::Commit(())
+	});
+
+	let changes = runtime_api
+		.into_storage_changes(&client.state_at(best_hash).unwrap(), best_hash)
+		.unwrap();
+	assert_eq!(changes.main_storage_changes[0].1, Some(vec![1, 2, 3]));
+}
diff --git a/substrate/primitives/api/test/tests/trybuild.rs b/substrate/primitives/api/test/tests/trybuild.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b0a334eb7a224174dd56d2b70fdd86a5493c2d36
--- /dev/null
+++ b/substrate/primitives/api/test/tests/trybuild.rs
@@ -0,0 +1,34 @@
+// 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 std::env;
+
+#[rustversion::attr(not(stable), ignore)]
+#[test]
+fn ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	env::set_var("SKIP_WASM_BUILD", "1");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/ui/*.rs");
+	t.pass("tests/ui/positive_cases/*.rs");
+}
diff --git a/substrate/primitives/api/test/tests/ui/adding_self_parameter.rs b/substrate/primitives/api/test/tests/ui/adding_self_parameter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..117fa261886b9f0a740081d5d5b913a26a3d4fd2
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/adding_self_parameter.rs
@@ -0,0 +1,7 @@
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(&self);
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/adding_self_parameter.stderr b/substrate/primitives/api/test/tests/ui/adding_self_parameter.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..894713d35eef8b1e3cb79ba2c5893bb5560ac031
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/adding_self_parameter.stderr
@@ -0,0 +1,5 @@
+error: `self` as argument not supported.
+ --> $DIR/adding_self_parameter.rs:3:11
+  |
+3 |         fn test(&self);
+  |                 ^
diff --git a/substrate/primitives/api/test/tests/ui/changed_in_no_default_method.rs b/substrate/primitives/api/test/tests/ui/changed_in_no_default_method.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a0bb4e2830ca7e370ccca88fc963f8575196d960
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/changed_in_no_default_method.rs
@@ -0,0 +1,13 @@
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	#[api_version(2)]
+	pub trait Api {
+		#[changed_in(2)]
+		fn test(data: u64);
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/changed_in_no_default_method.stderr b/substrate/primitives/api/test/tests/ui/changed_in_no_default_method.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..2140703a5d2c218948ee135a567bd64eb509394d
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/changed_in_no_default_method.stderr
@@ -0,0 +1,6 @@
+error: There is no 'default' method with this name (without `changed_in` attribute).
+       The 'default' method is used to call into the latest implementation.
+ --> tests/ui/changed_in_no_default_method.rs:9:6
+  |
+9 |         fn test(data: u64);
+  |            ^^^^
diff --git a/substrate/primitives/api/test/tests/ui/changed_in_unknown_version.rs b/substrate/primitives/api/test/tests/ui/changed_in_unknown_version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..164b91d19422cdcdd31726664a596ea74ae547b9
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/changed_in_unknown_version.rs
@@ -0,0 +1,13 @@
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		#[changed_in(2)]
+		fn test(data: u64);
+		fn test(data: u64);
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/changed_in_unknown_version.stderr b/substrate/primitives/api/test/tests/ui/changed_in_unknown_version.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..d4a03bab552e90294ddd23fa3d972735872482c6
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/changed_in_unknown_version.stderr
@@ -0,0 +1,5 @@
+error: `changed_in` version can not be greater than the `api_version`
+ --> tests/ui/changed_in_unknown_version.rs:8:3
+  |
+8 |         fn test(data: u64);
+  |         ^^
diff --git a/substrate/primitives/api/test/tests/ui/declaring_old_block.rs b/substrate/primitives/api/test/tests/ui/declaring_old_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fb741590282249c692af3b9233f59a95fa3b0b5b
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/declaring_old_block.rs
@@ -0,0 +1,7 @@
+sp_api::decl_runtime_apis! {
+	pub trait Api<Block: BlockT> {
+		fn test();
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/declaring_old_block.stderr b/substrate/primitives/api/test/tests/ui/declaring_old_block.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..50dd37582c603d5d355472e2003b1813d18ecb67
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/declaring_old_block.stderr
@@ -0,0 +1,11 @@
+error: `Block: BlockT` generic parameter will be added automatically by the `decl_runtime_apis!` macro! If you try to use a different trait than the substrate `Block` trait, please rename it locally.
+ --> $DIR/declaring_old_block.rs:2:23
+  |
+2 |     pub trait Api<Block: BlockT> {
+  |                          ^^^^^^
+
+error: `Block: BlockT` generic parameter will be added automatically by the `decl_runtime_apis!` macro!
+ --> $DIR/declaring_old_block.rs:2:16
+  |
+2 |     pub trait Api<Block: BlockT> {
+  |                   ^^^^^
diff --git a/substrate/primitives/api/test/tests/ui/declaring_own_block_with_different_name.rs b/substrate/primitives/api/test/tests/ui/declaring_own_block_with_different_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e3c7ae8a39ab748557c5d160f35e24dfcd0a353d
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/declaring_own_block_with_different_name.rs
@@ -0,0 +1,7 @@
+sp_api::decl_runtime_apis! {
+	pub trait Api<B: BlockT> {
+		fn test();
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/declaring_own_block_with_different_name.stderr b/substrate/primitives/api/test/tests/ui/declaring_own_block_with_different_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..778de3c9d15f7ff9caf94b858182af78ff260bd1
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/declaring_own_block_with_different_name.stderr
@@ -0,0 +1,5 @@
+error: `Block: BlockT` generic parameter will be added automatically by the `decl_runtime_apis!` macro! If you try to use a different trait than the substrate `Block` trait, please rename it locally.
+ --> $DIR/declaring_own_block_with_different_name.rs:2:19
+  |
+2 |     pub trait Api<B: BlockT> {
+  |                      ^^^^^^
diff --git a/substrate/primitives/api/test/tests/ui/empty_impl_runtime_apis_call.rs b/substrate/primitives/api/test/tests/ui/empty_impl_runtime_apis_call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..68d84d97fa8e25f8bf1611ae4e8598702af87b17
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/empty_impl_runtime_apis_call.rs
@@ -0,0 +1,13 @@
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+sp_api::impl_runtime_apis! {}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/empty_impl_runtime_apis_call.stderr b/substrate/primitives/api/test/tests/ui/empty_impl_runtime_apis_call.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..96ec09a1855446e080b36b5d4d2908b6ed5e9cc5
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/empty_impl_runtime_apis_call.stderr
@@ -0,0 +1,7 @@
+error: No api implementation given!
+  --> tests/ui/empty_impl_runtime_apis_call.rs:11:1
+   |
+11 | sp_api::impl_runtime_apis! {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: this error originates in the macro `sp_api::impl_runtime_apis` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/primitives/api/test/tests/ui/impl_incorrect_method_signature.rs b/substrate/primitives/api/test/tests/ui/impl_incorrect_method_signature.rs
new file mode 100644
index 0000000000000000000000000000000000000000..32501be7855c6b7c6aaff54710a8bd38d7c38581
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/impl_incorrect_method_signature.rs
@@ -0,0 +1,32 @@
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime_client::runtime::Block;
+
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	impl self::Api<Block> for Runtime {
+		fn test(data: String) {}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_api::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/impl_incorrect_method_signature.stderr b/substrate/primitives/api/test/tests/ui/impl_incorrect_method_signature.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..2324be85be4f82acdbb55e17e6b1d21a95739b73
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/impl_incorrect_method_signature.stderr
@@ -0,0 +1,35 @@
+error[E0053]: method `test` has an incompatible type for trait
+  --> tests/ui/impl_incorrect_method_signature.rs:16:17
+   |
+16 |         fn test(data: String) {}
+   |                       ^^^^^^
+   |                       |
+   |                       expected `u64`, found `std::string::String`
+   |                       help: change the parameter type to match the trait: `u64`
+   |
+note: type in trait
+  --> tests/ui/impl_incorrect_method_signature.rs:10:17
+   |
+10 |         fn test(data: u64);
+   |                       ^^^
+   = note: expected signature `fn(u64)`
+              found signature `fn(std::string::String)`
+
+error[E0308]: mismatched types
+  --> tests/ui/impl_incorrect_method_signature.rs:16:11
+   |
+14 | / sp_api::impl_runtime_apis! {
+15 | |     impl self::Api<Block> for Runtime {
+16 | |         fn test(data: String) {}
+   | |                 ^^^^ expected `u64`, found `String`
+17 | |     }
+...  |
+29 | |     }
+30 | | }
+   | |_- arguments to this function are incorrect
+   |
+note: associated function defined here
+  --> tests/ui/impl_incorrect_method_signature.rs:10:6
+   |
+10 |         fn test(data: u64);
+   |            ^^^^
diff --git a/substrate/primitives/api/test/tests/ui/impl_missing_version.rs b/substrate/primitives/api/test/tests/ui/impl_missing_version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8fd40a400922f8240cf09d46a8566be9f17390ed
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/impl_missing_version.rs
@@ -0,0 +1,37 @@
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime_client::runtime::Block;
+
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	#[api_version(2)]
+	pub trait Api {
+		fn test1();
+		fn test2();
+		#[api_version(3)]
+		fn test3();
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	#[api_version(4)]
+	impl self::Api<Block> for Runtime {
+		fn test1() {}
+		fn test2() {}
+		fn test3() {}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/impl_missing_version.stderr b/substrate/primitives/api/test/tests/ui/impl_missing_version.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..770543aa8875d7876772d6f1998a895f821d5c40
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/impl_missing_version.stderr
@@ -0,0 +1,8 @@
+error[E0405]: cannot find trait `ApiV4` in module `self::runtime_decl_for_api`
+  --> tests/ui/impl_missing_version.rs:18:13
+   |
+8  |     pub trait Api {
+   |     ------------- similarly named trait `ApiV2` defined here
+...
+18 |     impl self::Api<Block> for Runtime {
+   |                ^^^ help: a trait with a similar name exists: `ApiV2`
diff --git a/substrate/primitives/api/test/tests/ui/impl_two_traits_with_same_name.rs b/substrate/primitives/api/test/tests/ui/impl_two_traits_with_same_name.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cb8f2f493d74114135b3830d8adf4ac6dc823720
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/impl_two_traits_with_same_name.rs
@@ -0,0 +1,29 @@
+/// The declaration of the `Runtime` type  is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+mod second {
+	sp_api::decl_runtime_apis! {
+		pub trait Api {
+			fn test2(data: u64);
+		}
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	impl self::Api<Block> for Runtime {
+		fn test(data: u64) {}
+	}
+
+	impl second::Api<Block> for Runtime {
+		fn test2(data: u64) {}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/impl_two_traits_with_same_name.stderr b/substrate/primitives/api/test/tests/ui/impl_two_traits_with_same_name.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..a41f59f36b1f0fa3a70c26caf19519600a5812d6
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/impl_two_traits_with_same_name.stderr
@@ -0,0 +1,5 @@
+error: Two traits with the same name detected! The trait name is used to generate its ID. Please rename one trait at the declaration!
+  --> tests/ui/impl_two_traits_with_same_name.rs:24:15
+   |
+24 |     impl second::Api<Block> for Runtime {
+   |                  ^^^
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_1.rs b/substrate/primitives/api/test/tests/ui/invalid_api_version_1.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e038dd0aa6585b03c30e39a9383dd58fecef0dac
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_1.rs
@@ -0,0 +1,8 @@
+sp_api::decl_runtime_apis! {
+	#[api_version]
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_1.stderr b/substrate/primitives/api/test/tests/ui/invalid_api_version_1.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..53ffce959bb6697b861af157bbd7f78d5b2b572a
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_1.stderr
@@ -0,0 +1,5 @@
+error: Unexpected `api_version` attribute. The supported format is `api_version(1)`
+ --> tests/ui/invalid_api_version_1.rs:2:2
+  |
+2 |     #[api_version]
+  |     ^
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_2.rs b/substrate/primitives/api/test/tests/ui/invalid_api_version_2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bb8ed8ed11fea503c931f433c784a182987c320b
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_2.rs
@@ -0,0 +1,8 @@
+sp_api::decl_runtime_apis! {
+	#[api_version("1")]
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_2.stderr b/substrate/primitives/api/test/tests/ui/invalid_api_version_2.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0c5274d4680ff3dbcd83abf7619aea9d9a73357a
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_2.stderr
@@ -0,0 +1,5 @@
+error: Unexpected `api_version` attribute. The supported format is `api_version(1)`
+ --> tests/ui/invalid_api_version_2.rs:2:2
+  |
+2 |     #[api_version("1")]
+  |     ^
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_3.rs b/substrate/primitives/api/test/tests/ui/invalid_api_version_3.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d010866e23731dc737e6cdd810b45b0bba3b5d34
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_3.rs
@@ -0,0 +1,8 @@
+sp_api::decl_runtime_apis! {
+	#[api_version()]
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_3.stderr b/substrate/primitives/api/test/tests/ui/invalid_api_version_3.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4a34a7aa9b47ac666535f9b2828ab9daab3fd865
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_3.stderr
@@ -0,0 +1,5 @@
+error: Unexpected `api_version` attribute. The supported format is `api_version(1)`
+ --> tests/ui/invalid_api_version_3.rs:2:2
+  |
+2 |     #[api_version()]
+  |     ^
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_4.rs b/substrate/primitives/api/test/tests/ui/invalid_api_version_4.rs
new file mode 100644
index 0000000000000000000000000000000000000000..37b5b6ffa25d112532095b0085322e95d2501cd0
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_4.rs
@@ -0,0 +1,8 @@
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		#[api_version("1")]
+		fn test(data: u64);
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/invalid_api_version_4.stderr b/substrate/primitives/api/test/tests/ui/invalid_api_version_4.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..57541a97f6c91b0a87a3e7d6176d73cdf8014752
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/invalid_api_version_4.stderr
@@ -0,0 +1,5 @@
+error: Unexpected `api_version` attribute. The supported format is `api_version(1)`
+ --> tests/ui/invalid_api_version_4.rs:3:3
+  |
+3 |         #[api_version("1")]
+  |         ^
diff --git a/substrate/primitives/api/test/tests/ui/method_ver_lower_than_trait_ver.rs b/substrate/primitives/api/test/tests/ui/method_ver_lower_than_trait_ver.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b4f43cd401bba927323a1d6403f728b301ba6dc8
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/method_ver_lower_than_trait_ver.rs
@@ -0,0 +1,9 @@
+sp_api::decl_runtime_apis! {
+	#[api_version(2)]
+	pub trait Api {
+		#[api_version(1)]
+		fn test(data: u64);
+	}
+}
+
+fn main() {}
\ No newline at end of file
diff --git a/substrate/primitives/api/test/tests/ui/method_ver_lower_than_trait_ver.stderr b/substrate/primitives/api/test/tests/ui/method_ver_lower_than_trait_ver.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..ec4b594023a05963b7ddc7119a807bfbc883b8c8
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/method_ver_lower_than_trait_ver.stderr
@@ -0,0 +1,11 @@
+error: Method version `1` is older than (or equal to) trait version `2`.Methods can't define versions older than the trait version.
+ --> tests/ui/method_ver_lower_than_trait_ver.rs:4:3
+  |
+4 |         #[api_version(1)]
+  |         ^
+
+error: Trait version is set here.
+ --> tests/ui/method_ver_lower_than_trait_ver.rs:2:2
+  |
+2 |     #[api_version(2)]
+  |     ^
diff --git a/substrate/primitives/api/test/tests/ui/missing_block_generic_parameter.rs b/substrate/primitives/api/test/tests/ui/missing_block_generic_parameter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b69505bfeb098f5b04fb8c663f7d29a36e96a42e
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_block_generic_parameter.rs
@@ -0,0 +1,19 @@
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	impl self::Api for Runtime {
+		fn test(data: u64) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/missing_block_generic_parameter.stderr b/substrate/primitives/api/test/tests/ui/missing_block_generic_parameter.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5dc2b993bb1a7345bd8621f81d075fedea998dff
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_block_generic_parameter.stderr
@@ -0,0 +1,5 @@
+error: Missing `Block` generic parameter.
+  --> tests/ui/missing_block_generic_parameter.rs:12:13
+   |
+12 |     impl self::Api for Runtime {
+   |                ^^^
diff --git a/substrate/primitives/api/test/tests/ui/missing_path_for_trait.rs b/substrate/primitives/api/test/tests/ui/missing_path_for_trait.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e47bca1c3f6ce940a205ba79cf5599a806aaad0d
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_path_for_trait.rs
@@ -0,0 +1,19 @@
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	impl Api<Block> for Runtime {
+		fn test(data: u64) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/missing_path_for_trait.stderr b/substrate/primitives/api/test/tests/ui/missing_path_for_trait.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..cca993501979e914f81b8eafdaca6b3d176f6454
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_path_for_trait.stderr
@@ -0,0 +1,5 @@
+error: The implemented trait has to be referenced with a path, e.g. `impl client::Core for Runtime`.
+  --> tests/ui/missing_path_for_trait.rs:12:7
+   |
+12 |     impl Api<Block> for Runtime {
+   |          ^^^
diff --git a/substrate/primitives/api/test/tests/ui/missing_versioned_method.rs b/substrate/primitives/api/test/tests/ui/missing_versioned_method.rs
new file mode 100644
index 0000000000000000000000000000000000000000..919cef055fe62682ed3d80172e556fbb60ed5cc8
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_versioned_method.rs
@@ -0,0 +1,36 @@
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime_client::runtime::Block;
+
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	#[api_version(2)]
+	pub trait Api {
+		fn test1();
+		fn test2();
+		#[api_version(3)]
+		fn test3();
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	#[api_version(3)]
+	impl self::Api<Block> for Runtime {
+		fn test1() {}
+		fn test2() {}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/missing_versioned_method.stderr b/substrate/primitives/api/test/tests/ui/missing_versioned_method.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..b88d903212df1ed29e2a600d6abbca1a1b568dd2
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_versioned_method.stderr
@@ -0,0 +1,8 @@
+error[E0046]: not all trait items implemented, missing: `test3`
+  --> tests/ui/missing_versioned_method.rs:18:2
+   |
+12 |         fn test3();
+   |         ----------- `test3` from trait
+...
+18 |     impl self::Api<Block> for Runtime {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `test3` in implementation
diff --git a/substrate/primitives/api/test/tests/ui/missing_versioned_method_multiple_vers.rs b/substrate/primitives/api/test/tests/ui/missing_versioned_method_multiple_vers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..036bba417f57d00e4a83a311351e58b3a7d3a914
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_versioned_method_multiple_vers.rs
@@ -0,0 +1,39 @@
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime_client::runtime::Block;
+
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	#[api_version(2)]
+	pub trait Api {
+		fn test1();
+		fn test2();
+		#[api_version(3)]
+		fn test3();
+		#[api_version(4)]
+		fn test4();
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	#[api_version(4)]
+	impl self::Api<Block> for Runtime {
+		fn test1() {}
+		fn test2() {}
+		fn test4() {}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/missing_versioned_method_multiple_vers.stderr b/substrate/primitives/api/test/tests/ui/missing_versioned_method_multiple_vers.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..4afa6856a58146694bf94efb3f9ca61d1dc6bb40
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/missing_versioned_method_multiple_vers.stderr
@@ -0,0 +1,8 @@
+error[E0046]: not all trait items implemented, missing: `test3`
+  --> tests/ui/missing_versioned_method_multiple_vers.rs:20:2
+   |
+12 |         fn test3();
+   |         ----------- `test3` from trait
+...
+20 |     impl self::Api<Block> for Runtime {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `test3` in implementation
diff --git a/substrate/primitives/api/test/tests/ui/mock_advanced_hash_by_reference.rs b/substrate/primitives/api/test/tests/ui/mock_advanced_hash_by_reference.rs
new file mode 100644
index 0000000000000000000000000000000000000000..45e6adb2fcf948b64027c9e2241f2f519a240647
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_advanced_hash_by_reference.rs
@@ -0,0 +1,21 @@
+use substrate_test_runtime_client::runtime::Block;
+use sp_api::ApiError;
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test();
+	}
+}
+
+struct MockApi;
+
+sp_api::mock_impl_runtime_apis! {
+	impl Api<Block> for MockApi {
+		#[advanced]
+		fn test(&self, _: &Hash) -> Result<(), ApiError> {
+			Ok(().into())
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/mock_advanced_hash_by_reference.stderr b/substrate/primitives/api/test/tests/ui/mock_advanced_hash_by_reference.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..234331c9749bb333929fa536de73c8260da022aa
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_advanced_hash_by_reference.stderr
@@ -0,0 +1,13 @@
+error: `Hash` needs to be taken by value and not by reference!
+  --> tests/ui/mock_advanced_hash_by_reference.rs:12:1
+   |
+12 | / sp_api::mock_impl_runtime_apis! {
+13 | |     impl Api<Block> for MockApi {
+14 | |         #[advanced]
+15 | |         fn test(&self, _: &Hash) -> Result<(), ApiError> {
+...  |
+18 | |     }
+19 | | }
+   | |_^
+   |
+   = note: this error originates in the macro `sp_api::mock_impl_runtime_apis` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/primitives/api/test/tests/ui/mock_advanced_missing_hash.rs b/substrate/primitives/api/test/tests/ui/mock_advanced_missing_hash.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76bf5f1aa745967c7d3703e0f56121799a34353b
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_advanced_missing_hash.rs
@@ -0,0 +1,21 @@
+use substrate_test_runtime_client::runtime::Block;
+use sp_api::ApiError;
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test();
+	}
+}
+
+struct MockApi;
+
+sp_api::mock_impl_runtime_apis! {
+	impl Api<Block> for MockApi {
+		#[advanced]
+		fn test(&self) -> Result<(), ApiError> {
+			Ok(().into())
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/mock_advanced_missing_hash.stderr b/substrate/primitives/api/test/tests/ui/mock_advanced_missing_hash.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..48a94a00beae7cdc789eb445a054288d0b6bd9e2
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_advanced_missing_hash.stderr
@@ -0,0 +1,5 @@
+error: If using the `advanced` attribute, it is required that the function takes at least one argument, the `Hash`.
+  --> tests/ui/mock_advanced_missing_hash.rs:15:3
+   |
+15 |         fn test(&self) -> Result<(), ApiError> {
+   |         ^^
diff --git a/substrate/primitives/api/test/tests/ui/mock_only_one_block_type.rs b/substrate/primitives/api/test/tests/ui/mock_only_one_block_type.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f49cafd23a00122bd53976c0656e0779f3d3fb5d
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_only_one_block_type.rs
@@ -0,0 +1,25 @@
+struct Block2;
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+
+	pub trait Api2 {
+		fn test(data: u64);
+	}
+}
+
+struct MockApi;
+
+sp_api::mock_impl_runtime_apis! {
+	impl Api<Block> for MockApi {
+		fn test(data: u64) {}
+	}
+
+	impl Api2<Block2> for MockApi {
+		fn test(data: u64) {}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/mock_only_one_block_type.stderr b/substrate/primitives/api/test/tests/ui/mock_only_one_block_type.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1831d0485b473a3d33ca1bafce6c2fa67f6b78a2
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_only_one_block_type.stderr
@@ -0,0 +1,11 @@
+error: Block type should be the same between all runtime apis.
+  --> $DIR/mock_only_one_block_type.rs:20:12
+   |
+20 |     impl Api2<Block2> for MockApi {
+   |               ^^^^^^
+
+error: First block type found here
+  --> $DIR/mock_only_one_block_type.rs:16:11
+   |
+16 |     impl Api<Block> for MockApi {
+   |              ^^^^^
diff --git a/substrate/primitives/api/test/tests/ui/mock_only_one_self_type.rs b/substrate/primitives/api/test/tests/ui/mock_only_one_self_type.rs
new file mode 100644
index 0000000000000000000000000000000000000000..617031b4d5f1a1f37c974ed8d826f43e49003233
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_only_one_self_type.rs
@@ -0,0 +1,24 @@
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+
+	pub trait Api2 {
+		fn test(data: u64);
+	}
+}
+
+struct MockApi;
+struct MockApi2;
+
+sp_api::mock_impl_runtime_apis! {
+	impl Api<Block> for MockApi {
+		fn test(data: u64) {}
+	}
+
+	impl Api2<Block> for MockApi2 {
+		fn test(data: u64) {}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/mock_only_one_self_type.stderr b/substrate/primitives/api/test/tests/ui/mock_only_one_self_type.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..5f1e29b281c8504d39a355028882099b40298810
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_only_one_self_type.stderr
@@ -0,0 +1,11 @@
+error: Self type should not change between runtime apis
+  --> $DIR/mock_only_one_self_type.rs:19:23
+   |
+19 |     impl Api2<Block> for MockApi2 {
+   |                          ^^^^^^^^
+
+error: First self type found here
+  --> $DIR/mock_only_one_self_type.rs:15:22
+   |
+15 |     impl Api<Block> for MockApi {
+   |                         ^^^^^^^
diff --git a/substrate/primitives/api/test/tests/ui/mock_only_self_reference.rs b/substrate/primitives/api/test/tests/ui/mock_only_self_reference.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8a733f5779ce938edcd1301b535938288b66737b
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_only_self_reference.rs
@@ -0,0 +1,20 @@
+use substrate_test_runtime_client::runtime::Block;
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+		fn test2(data: u64);
+	}
+}
+
+struct MockApi;
+
+sp_api::mock_impl_runtime_apis! {
+	impl Api<Block> for MockApi {
+		fn test(self, data: u64) {}
+
+		fn test2(&mut self, data: u64) {}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/mock_only_self_reference.stderr b/substrate/primitives/api/test/tests/ui/mock_only_self_reference.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..f088e8f2de59db08dc37554c6935c7eef54c651c
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/mock_only_self_reference.stderr
@@ -0,0 +1,50 @@
+error: Only `&self` is supported!
+  --> tests/ui/mock_only_self_reference.rs:14:11
+   |
+14 |         fn test(self, data: u64) {}
+   |                 ^^^^
+
+error: Only `&self` is supported!
+  --> tests/ui/mock_only_self_reference.rs:16:12
+   |
+16 |         fn test2(&mut self, data: u64) {}
+   |                  ^
+
+error[E0050]: method `test` has 2 parameters but the declaration in trait `Api::test` has 3
+  --> tests/ui/mock_only_self_reference.rs:12:1
+   |
+3  | / sp_api::decl_runtime_apis! {
+4  | |     pub trait Api {
+5  | |         fn test(data: u64);
+   | |_________________________- trait requires 3 parameters
+...
+12 | / sp_api::mock_impl_runtime_apis! {
+13 | |     impl Api<Block> for MockApi {
+14 | |         fn test(self, data: u64) {}
+15 | |
+16 | |         fn test2(&mut self, data: u64) {}
+17 | |     }
+18 | | }
+   | |_^ expected 3 parameters, found 2
+   |
+   = note: this error originates in the macro `sp_api::mock_impl_runtime_apis` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0050]: method `test2` has 2 parameters but the declaration in trait `Api::test2` has 3
+  --> tests/ui/mock_only_self_reference.rs:12:1
+   |
+3  | / sp_api::decl_runtime_apis! {
+4  | |     pub trait Api {
+5  | |         fn test(data: u64);
+6  | |         fn test2(data: u64);
+   | |__________________________- trait requires 3 parameters
+...
+12 | / sp_api::mock_impl_runtime_apis! {
+13 | |     impl Api<Block> for MockApi {
+14 | |         fn test(self, data: u64) {}
+15 | |
+16 | |         fn test2(&mut self, data: u64) {}
+17 | |     }
+18 | | }
+   | |_^ expected 3 parameters, found 2
+   |
+   = note: this error originates in the macro `sp_api::mock_impl_runtime_apis` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/primitives/api/test/tests/ui/no_default_implementation.rs b/substrate/primitives/api/test/tests/ui/no_default_implementation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6af93d6b865399c85b4d0756cb4357a4b71e21b2
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/no_default_implementation.rs
@@ -0,0 +1,9 @@
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test() {
+			println!("Hey, I'm a default implementation!");
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/no_default_implementation.stderr b/substrate/primitives/api/test/tests/ui/no_default_implementation.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0ccece1441916245bd43517842cd0335395cbdf6
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/no_default_implementation.stderr
@@ -0,0 +1,8 @@
+error: A runtime API function cannot have a default implementation!
+ --> $DIR/no_default_implementation.rs:3:13
+  |
+3 |           fn test() {
+  |  ___________________^
+4 | |             println!("Hey, I'm a default implementation!");
+5 | |         }
+  | |_________^
diff --git a/substrate/primitives/api/test/tests/ui/positive_cases/custom_where_bound.rs b/substrate/primitives/api/test/tests/ui/positive_cases/custom_where_bound.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b572a3bc30d5dd5ff3714cf29a1e08d8a84df247
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/positive_cases/custom_where_bound.rs
@@ -0,0 +1,43 @@
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime_client::runtime::Block;
+
+struct Runtime {}
+
+pub trait CustomTrait: Encode + Decode + TypeInfo {}
+
+#[derive(Encode, Decode, TypeInfo)]
+pub struct SomeImpl;
+impl CustomTrait for SomeImpl {}
+
+#[derive(Encode, Decode, TypeInfo)]
+pub struct SomeOtherType<C: CustomTrait>(C);
+
+sp_api::decl_runtime_apis! {
+	pub trait Api<A> where A: CustomTrait {
+		fn test() -> A;
+		fn test2() -> SomeOtherType<A>;
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	impl self::Api<Block, SomeImpl> for Runtime {
+		fn test() -> SomeImpl { SomeImpl }
+		fn test2() -> SomeOtherType<SomeImpl> { SomeOtherType(SomeImpl) }
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/positive_cases/default_impls.rs b/substrate/primitives/api/test/tests/ui/positive_cases/default_impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..58192feb9ecac3c2b02c7a23c7ec2afada860781
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/positive_cases/default_impls.rs
@@ -0,0 +1,38 @@
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime_client::runtime::Block;
+
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	#[api_version(2)]
+	pub trait Api {
+		fn test1();
+		fn test2();
+		#[api_version(3)]
+		fn test3();
+		#[api_version(4)]
+		fn test4();
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	#[api_version(2)]
+	impl self::Api<Block> for Runtime {
+		fn test1() {}
+		fn test2() {}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_version::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/type_reference_in_impl_runtime_apis_call.rs b/substrate/primitives/api/test/tests/ui/type_reference_in_impl_runtime_apis_call.rs
new file mode 100644
index 0000000000000000000000000000000000000000..14a8fa4d4e0b1bb8eb715c86a4b165874915dca3
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/type_reference_in_impl_runtime_apis_call.rs
@@ -0,0 +1,34 @@
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime_client::runtime::Block;
+
+/// The declaration of the `Runtime` type is done by the `construct_runtime!` macro in a real
+/// runtime.
+struct Runtime {}
+
+sp_api::decl_runtime_apis! {
+	pub trait Api {
+		fn test(data: u64);
+	}
+}
+
+sp_api::impl_runtime_apis! {
+	impl self::Api<Block> for Runtime {
+		fn test(data: &u64) {
+			unimplemented!()
+		}
+	}
+
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> sp_api::RuntimeVersion {
+			unimplemented!()
+		}
+		fn execute_block(_: Block) {
+			unimplemented!()
+		}
+		fn initialize_block(_: &<Block as BlockT>::Header) {
+			unimplemented!()
+		}
+	}
+}
+
+fn main() {}
diff --git a/substrate/primitives/api/test/tests/ui/type_reference_in_impl_runtime_apis_call.stderr b/substrate/primitives/api/test/tests/ui/type_reference_in_impl_runtime_apis_call.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e9d550f3a3bcf841c15bba9c0422db2fcfc06e05
--- /dev/null
+++ b/substrate/primitives/api/test/tests/ui/type_reference_in_impl_runtime_apis_call.stderr
@@ -0,0 +1,39 @@
+error[E0053]: method `test` has an incompatible type for trait
+  --> tests/ui/type_reference_in_impl_runtime_apis_call.rs:16:17
+   |
+16 |         fn test(data: &u64) {
+   |                       ^^^^
+   |                       |
+   |                       expected `u64`, found `&u64`
+   |                       help: change the parameter type to match the trait: `u64`
+   |
+note: type in trait
+  --> tests/ui/type_reference_in_impl_runtime_apis_call.rs:10:17
+   |
+10 |         fn test(data: u64);
+   |                       ^^^
+   = note: expected signature `fn(u64)`
+              found signature `fn(&u64)`
+
+error[E0308]: mismatched types
+  --> tests/ui/type_reference_in_impl_runtime_apis_call.rs:16:11
+   |
+14 | / sp_api::impl_runtime_apis! {
+15 | |     impl self::Api<Block> for Runtime {
+16 | |         fn test(data: &u64) {
+   | |                 ^^^^^^^ expected `u64`, found `&u64`
+17 | |             unimplemented!()
+...  |
+31 | |     }
+32 | | }
+   | |_- arguments to this function are incorrect
+   |
+note: associated function defined here
+  --> tests/ui/type_reference_in_impl_runtime_apis_call.rs:10:6
+   |
+10 |         fn test(data: u64);
+   |            ^^^^
+help: consider removing the borrow
+   |
+16 |         fn test(data: &u64) {
+   |
diff --git a/substrate/primitives/application-crypto/Cargo.toml b/substrate/primitives/application-crypto/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e4daebd51c197964a8e7400f32b5e487c795ae46
--- /dev/null
+++ b/substrate/primitives/application-crypto/Cargo.toml
@@ -0,0 +1,62 @@
+[package]
+name = "sp-application-crypto"
+version = "23.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+description = "Provides facilities for generating application specific crypto wrapper types."
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sp-application-crypto"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+
+[dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, optional = true, features = ["derive", "alloc"]  }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-io = { version = "23.0.0", default-features = false, path = "../io" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"full_crypto",
+	"scale-info/std",
+	"serde/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-std/std",
+]
+
+# Serde support without relying on std features.
+serde = [ "dep:serde", "scale-info/serde", "sp-core/serde" ]
+
+# This feature enables all crypto primitives for `no_std` builds like microcontrollers
+# or Intel SGX.
+# For the regular wasm runtime builds this should not be used.
+full_crypto = [
+	"sp-core/full_crypto",
+	"sp-io/disable_oom",
+	# Don't add `panic_handler` and `alloc_error_handler` since they are expected to be provided
+	# by the user anyway.
+	"sp-io/disable_panic_handler",
+]
+
+# This feature adds BLS crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bls-experimental = [ "sp-core/bls-experimental", "sp-io/bls-experimental" ]
+
+# This feature adds Bandersnatch crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bandersnatch-experimental = [
+	"sp-core/bandersnatch-experimental",
+	"sp-io/bandersnatch-experimental",
+]
diff --git a/substrate/primitives/application-crypto/README.md b/substrate/primitives/application-crypto/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c86e33552f60605d5ca8e9db7e48621f24060f2f
--- /dev/null
+++ b/substrate/primitives/application-crypto/README.md
@@ -0,0 +1,3 @@
+Traits and macros for constructing application specific strongly typed crypto wrappers.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/application-crypto/src/bandersnatch.rs b/substrate/primitives/application-crypto/src/bandersnatch.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fc7383815d7021a6abe93da2bbbeb723d91f4d2e
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/bandersnatch.rs
@@ -0,0 +1,57 @@
+// 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.
+
+//! Bandersnatch VRF application crypto types.
+
+use crate::{KeyTypeId, RuntimePublic};
+pub use sp_core::bandersnatch::*;
+use sp_std::vec::Vec;
+
+mod app {
+	crate::app_crypto!(super, sp_core::testing::BANDERSNATCH);
+}
+
+#[cfg(feature = "full_crypto")]
+pub use app::Pair as AppPair;
+pub use app::{Public as AppPublic, Signature as AppSignature};
+
+impl RuntimePublic for Public {
+	type Signature = Signature;
+
+	/// Dummy implementation. Returns an empty vector.
+	fn all(_key_type: KeyTypeId) -> Vec<Self> {
+		Vec::new()
+	}
+
+	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self {
+		sp_io::crypto::bandersnatch_generate(key_type, seed)
+	}
+
+	/// Dummy implementation. Returns `None`.
+	fn sign<M: AsRef<[u8]>>(&self, _key_type: KeyTypeId, _msg: &M) -> Option<Self::Signature> {
+		None
+	}
+
+	/// Dummy implementation. Returns `false`.
+	fn verify<M: AsRef<[u8]>>(&self, _msg: &M, _signature: &Self::Signature) -> bool {
+		false
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		sp_core::crypto::ByteArray::to_raw_vec(self)
+	}
+}
diff --git a/substrate/primitives/application-crypto/src/bls377.rs b/substrate/primitives/application-crypto/src/bls377.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee17060564fa8bec54888c1123b7c86af13863d3
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/bls377.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! BLS12-377 crypto applications.
+use crate::{KeyTypeId, RuntimePublic};
+
+pub use sp_core::bls::bls377::*;
+
+mod app {
+	crate::app_crypto!(super, sp_core::testing::BLS377);
+}
+
+#[cfg(feature = "full_crypto")]
+pub use app::Pair as AppPair;
+pub use app::{Public as AppPublic, Signature as AppSignature};
+
+impl RuntimePublic for Public {
+	type Signature = Signature;
+
+	/// Dummy implementation. Returns an empty vector.
+	fn all(_key_type: KeyTypeId) -> Vec<Self> {
+		Vec::new()
+	}
+
+	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self {
+		sp_io::crypto::bls377_generate(key_type, seed)
+	}
+
+	/// Dummy implementation. Returns `None`.
+	fn sign<M: AsRef<[u8]>>(&self, _key_type: KeyTypeId, _msg: &M) -> Option<Self::Signature> {
+		None
+	}
+
+	/// Dummy implementation. Returns `false`.
+	fn verify<M: AsRef<[u8]>>(&self, _msg: &M, _signature: &Self::Signature) -> bool {
+		false
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		sp_core::crypto::ByteArray::to_raw_vec(self)
+	}
+}
diff --git a/substrate/primitives/application-crypto/src/bls381.rs b/substrate/primitives/application-crypto/src/bls381.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d990f2e14c8e689aa5320e14ee027e83726986f0
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/bls381.rs
@@ -0,0 +1,28 @@
+// 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.
+
+//! BLS12-381 crypto applications.
+
+pub use sp_core::bls::bls381::*;
+
+mod app {
+	crate::app_crypto!(super, sp_core::testing::BLS381);
+}
+
+#[cfg(feature = "full_crypto")]
+pub use app::Pair as AppPair;
+pub use app::{Public as AppPublic, Signature as AppSignature};
diff --git a/substrate/primitives/application-crypto/src/ecdsa.rs b/substrate/primitives/application-crypto/src/ecdsa.rs
new file mode 100644
index 0000000000000000000000000000000000000000..27ffe12579f5591cf71a0f22cd5bb2702ce83afb
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/ecdsa.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! Ecdsa crypto types.
+
+use crate::{KeyTypeId, RuntimePublic};
+
+use sp_std::vec::Vec;
+
+pub use sp_core::ecdsa::*;
+
+mod app {
+	crate::app_crypto!(super, sp_core::testing::ECDSA);
+}
+
+#[cfg(feature = "full_crypto")]
+pub use app::Pair as AppPair;
+pub use app::{Public as AppPublic, Signature as AppSignature};
+
+impl RuntimePublic for Public {
+	type Signature = Signature;
+
+	fn all(key_type: KeyTypeId) -> crate::Vec<Self> {
+		sp_io::crypto::ecdsa_public_keys(key_type)
+	}
+
+	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self {
+		sp_io::crypto::ecdsa_generate(key_type, seed)
+	}
+
+	fn sign<M: AsRef<[u8]>>(&self, key_type: KeyTypeId, msg: &M) -> Option<Self::Signature> {
+		sp_io::crypto::ecdsa_sign(key_type, self, msg.as_ref())
+	}
+
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool {
+		sp_io::crypto::ecdsa_verify(signature, msg.as_ref(), self)
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		sp_core::crypto::ByteArray::to_raw_vec(self)
+	}
+}
diff --git a/substrate/primitives/application-crypto/src/ed25519.rs b/substrate/primitives/application-crypto/src/ed25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bc05018370edb16c41ed1dddef2dafd7d785cc32
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/ed25519.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! Ed25519 crypto types.
+
+use crate::{KeyTypeId, RuntimePublic};
+
+use sp_std::vec::Vec;
+
+pub use sp_core::ed25519::*;
+
+mod app {
+	crate::app_crypto!(super, sp_core::testing::ED25519);
+}
+
+#[cfg(feature = "full_crypto")]
+pub use app::Pair as AppPair;
+pub use app::{Public as AppPublic, Signature as AppSignature};
+
+impl RuntimePublic for Public {
+	type Signature = Signature;
+
+	fn all(key_type: KeyTypeId) -> crate::Vec<Self> {
+		sp_io::crypto::ed25519_public_keys(key_type)
+	}
+
+	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self {
+		sp_io::crypto::ed25519_generate(key_type, seed)
+	}
+
+	fn sign<M: AsRef<[u8]>>(&self, key_type: KeyTypeId, msg: &M) -> Option<Self::Signature> {
+		sp_io::crypto::ed25519_sign(key_type, self, msg.as_ref())
+	}
+
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool {
+		sp_io::crypto::ed25519_verify(signature, msg.as_ref(), self)
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		sp_core::crypto::ByteArray::to_raw_vec(self)
+	}
+}
diff --git a/substrate/primitives/application-crypto/src/lib.rs b/substrate/primitives/application-crypto/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5384220bc9ca3f1ccf59144311b7ad999a91defa
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/lib.rs
@@ -0,0 +1,584 @@
+// 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.
+
+//! Traits and macros for constructing application specific strongly typed crypto wrappers.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub use sp_core::crypto::{key_types, CryptoTypeId, KeyTypeId};
+#[doc(hidden)]
+#[cfg(feature = "full_crypto")]
+pub use sp_core::crypto::{DeriveError, Pair, SecretStringError};
+#[cfg(any(feature = "full_crypto", feature = "serde"))]
+pub use sp_core::crypto::{DeriveJunction, Ss58Codec};
+#[doc(hidden)]
+pub use sp_core::{
+	self,
+	crypto::{ByteArray, CryptoType, Derive, IsWrappedBy, Public, UncheckedFrom, Wraps},
+	RuntimeDebug,
+};
+
+#[doc(hidden)]
+pub use codec;
+#[doc(hidden)]
+pub use scale_info;
+#[doc(hidden)]
+#[cfg(feature = "serde")]
+pub use serde;
+#[doc(hidden)]
+pub use sp_std::{ops::Deref, vec::Vec};
+
+#[cfg(feature = "bandersnatch-experimental")]
+pub mod bandersnatch;
+#[cfg(feature = "bls-experimental")]
+pub mod bls377;
+#[cfg(feature = "bls-experimental")]
+pub mod bls381;
+pub mod ecdsa;
+pub mod ed25519;
+pub mod sr25519;
+mod traits;
+
+pub use traits::*;
+
+/// Declares `Public`, `Pair` and `Signature` types which are functionally equivalent
+/// to the corresponding types defined by `$module` but are new application-specific
+/// types whose identifier is `$key_type`.
+///
+/// ```rust
+/// # use sp_application_crypto::{app_crypto, ed25519, KeyTypeId};
+/// // Declare a new set of crypto types using ed25519 logic that identifies as `KeyTypeId`
+/// // of value `b"fuba"`.
+/// app_crypto!(ed25519, KeyTypeId(*b"fuba"));
+/// ```
+#[cfg(feature = "full_crypto")]
+#[macro_export]
+macro_rules! app_crypto {
+	($module:ident, $key_type:expr) => {
+		$crate::app_crypto_public_full_crypto!($module::Public, $key_type, $module::CRYPTO_ID);
+		$crate::app_crypto_public_common!(
+			$module::Public,
+			$module::Signature,
+			$key_type,
+			$module::CRYPTO_ID
+		);
+		$crate::app_crypto_signature_full_crypto!(
+			$module::Signature,
+			$key_type,
+			$module::CRYPTO_ID
+		);
+		$crate::app_crypto_signature_common!($module::Signature, $key_type);
+		$crate::app_crypto_pair!($module::Pair, $key_type, $module::CRYPTO_ID);
+	};
+}
+
+/// Declares `Public`, `Pair` and `Signature` types which are functionally equivalent
+/// to the corresponding types defined by `$module` but that are new application-specific
+/// types whose identifier is `$key_type`.
+///
+/// ```rust
+/// # use sp_application_crypto::{app_crypto, ed25519, KeyTypeId};
+/// // Declare a new set of crypto types using ed25519 logic that identifies as `KeyTypeId`
+/// // of value `b"fuba"`.
+/// app_crypto!(ed25519, KeyTypeId(*b"fuba"));
+/// ```
+#[cfg(not(feature = "full_crypto"))]
+#[macro_export]
+macro_rules! app_crypto {
+	($module:ident, $key_type:expr) => {
+		$crate::app_crypto_public_not_full_crypto!($module::Public, $key_type, $module::CRYPTO_ID);
+		$crate::app_crypto_public_common!(
+			$module::Public,
+			$module::Signature,
+			$key_type,
+			$module::CRYPTO_ID
+		);
+		$crate::app_crypto_signature_not_full_crypto!(
+			$module::Signature,
+			$key_type,
+			$module::CRYPTO_ID
+		);
+		$crate::app_crypto_signature_common!($module::Signature, $key_type);
+	};
+}
+
+/// Declares `Pair` type which is functionally equivalent to `$pair`, but is
+/// new application-specific type whose identifier is `$key_type`.
+#[macro_export]
+macro_rules! app_crypto_pair {
+	($pair:ty, $key_type:expr, $crypto_type:expr) => {
+		$crate::wrap! {
+			/// A generic `AppPublic` wrapper type over $pair crypto; this has no specific App.
+			#[derive(Clone)]
+			pub struct Pair($pair);
+		}
+
+		impl $crate::CryptoType for Pair {
+			type Pair = Pair;
+		}
+
+		impl $crate::Pair for Pair {
+			type Public = Public;
+			type Seed = <$pair as $crate::Pair>::Seed;
+			type Signature = Signature;
+
+			$crate::app_crypto_pair_functions_if_std!($pair);
+
+			fn derive<Iter: Iterator<Item = $crate::DeriveJunction>>(
+				&self,
+				path: Iter,
+				seed: Option<Self::Seed>,
+			) -> Result<(Self, Option<Self::Seed>), $crate::DeriveError> {
+				self.0.derive(path, seed).map(|x| (Self(x.0), x.1))
+			}
+			fn from_seed(seed: &Self::Seed) -> Self {
+				Self(<$pair>::from_seed(seed))
+			}
+			fn from_seed_slice(seed: &[u8]) -> Result<Self, $crate::SecretStringError> {
+				<$pair>::from_seed_slice(seed).map(Self)
+			}
+			fn sign(&self, msg: &[u8]) -> Self::Signature {
+				Signature(self.0.sign(msg))
+			}
+			fn verify<M: AsRef<[u8]>>(
+				sig: &Self::Signature,
+				message: M,
+				pubkey: &Self::Public,
+			) -> bool {
+				<$pair>::verify(&sig.0, message, pubkey.as_ref())
+			}
+			fn public(&self) -> Self::Public {
+				Public(self.0.public())
+			}
+			fn to_raw_vec(&self) -> $crate::Vec<u8> {
+				self.0.to_raw_vec()
+			}
+		}
+
+		impl $crate::AppCrypto for Pair {
+			type Public = Public;
+			type Pair = Pair;
+			type Signature = Signature;
+			const ID: $crate::KeyTypeId = $key_type;
+			const CRYPTO_ID: $crate::CryptoTypeId = $crypto_type;
+		}
+
+		impl $crate::AppPair for Pair {
+			type Generic = $pair;
+		}
+
+		impl Pair {
+			/// Convert into wrapped generic key pair type.
+			pub fn into_inner(self) -> $pair {
+				self.0
+			}
+		}
+	};
+}
+
+/// Implements functions for the `Pair` trait when `feature = "std"` is enabled.
+#[doc(hidden)]
+#[cfg(feature = "std")]
+#[macro_export]
+macro_rules! app_crypto_pair_functions_if_std {
+	($pair:ty) => {
+		fn generate_with_phrase(password: Option<&str>) -> (Self, String, Self::Seed) {
+			let r = <$pair>::generate_with_phrase(password);
+			(Self(r.0), r.1, r.2)
+		}
+
+		fn from_phrase(
+			phrase: &str,
+			password: Option<&str>,
+		) -> Result<(Self, Self::Seed), $crate::SecretStringError> {
+			<$pair>::from_phrase(phrase, password).map(|r| (Self(r.0), r.1))
+		}
+	};
+}
+
+#[doc(hidden)]
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! app_crypto_pair_functions_if_std {
+	($pair:ty) => {};
+}
+
+/// Declares `Public` type which is functionally equivalent to `$public` but is
+/// new application-specific type whose identifier is `$key_type`.
+/// For full functionality, `app_crypto_public_common!` must be called too.
+/// Can only be used with `full_crypto` feature.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_public_full_crypto {
+	($public:ty, $key_type:expr, $crypto_type:expr) => {
+		$crate::wrap! {
+			/// A generic `AppPublic` wrapper type over $public crypto; this has no specific App.
+			#[derive(
+				Clone, Eq, Hash, PartialEq, PartialOrd, Ord,
+				$crate::codec::Encode,
+				$crate::codec::Decode,
+				$crate::RuntimeDebug,
+				$crate::codec::MaxEncodedLen,
+				$crate::scale_info::TypeInfo,
+			)]
+			#[codec(crate = $crate::codec)]
+			pub struct Public($public);
+		}
+
+		impl $crate::CryptoType for Public {
+			type Pair = Pair;
+		}
+
+		impl $crate::AppCrypto for Public {
+			type Public = Public;
+			type Pair = Pair;
+			type Signature = Signature;
+			const ID: $crate::KeyTypeId = $key_type;
+			const CRYPTO_ID: $crate::CryptoTypeId = $crypto_type;
+		}
+	};
+}
+
+/// Declares `Public` type which is functionally equivalent to `$public` but is
+/// new application-specific type whose identifier is `$key_type`.
+/// For full functionality, `app_crypto_public_common!` must be called too.
+/// Can only be used without `full_crypto` feature.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_public_not_full_crypto {
+	($public:ty, $key_type:expr, $crypto_type:expr) => {
+		$crate::wrap! {
+			/// A generic `AppPublic` wrapper type over $public crypto; this has no specific App.
+			#[derive(
+				Clone, Eq, PartialEq, Ord, PartialOrd,
+				$crate::codec::Encode,
+				$crate::codec::Decode,
+				$crate::RuntimeDebug,
+				$crate::codec::MaxEncodedLen,
+				$crate::scale_info::TypeInfo,
+			)]
+			pub struct Public($public);
+		}
+
+		impl $crate::CryptoType for Public {}
+
+		impl $crate::AppCrypto for Public {
+			type Public = Public;
+			type Signature = Signature;
+			const ID: $crate::KeyTypeId = $key_type;
+			const CRYPTO_ID: $crate::CryptoTypeId = $crypto_type;
+		}
+	};
+}
+
+/// Declares `Public` type which is functionally equivalent to `$public` but is
+/// new application-specific type whose identifier is `$key_type`.
+/// For full functionality, `app_crypto_public_(not)_full_crypto!` must be called too.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_public_common {
+	($public:ty, $sig:ty, $key_type:expr, $crypto_type:expr) => {
+		$crate::app_crypto_public_common_if_serde!();
+
+		impl AsRef<[u8]> for Public {
+			fn as_ref(&self) -> &[u8] {
+				self.0.as_ref()
+			}
+		}
+
+		impl AsMut<[u8]> for Public {
+			fn as_mut(&mut self) -> &mut [u8] {
+				self.0.as_mut()
+			}
+		}
+
+		impl $crate::ByteArray for Public {
+			const LEN: usize = <$public>::LEN;
+		}
+
+		impl $crate::Public for Public {}
+
+		impl $crate::AppPublic for Public {
+			type Generic = $public;
+		}
+
+		impl<'a> TryFrom<&'a [u8]> for Public {
+			type Error = ();
+
+			fn try_from(data: &'a [u8]) -> Result<Self, Self::Error> {
+				<$public>::try_from(data).map(Into::into)
+			}
+		}
+
+		impl Public {
+			/// Convert into wrapped generic public key type.
+			pub fn into_inner(self) -> $public {
+				self.0
+			}
+		}
+	};
+}
+
+#[doc(hidden)]
+pub mod module_format_string_prelude {
+	#[cfg(all(not(feature = "std"), feature = "serde"))]
+	pub use sp_std::alloc::{format, string::String};
+	#[cfg(feature = "std")]
+	pub use std::{format, string::String};
+}
+
+/// Implements traits for the public key type if `feature = "serde"` is enabled.
+#[cfg(feature = "serde")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_public_common_if_serde {
+	() => {
+		impl $crate::Derive for Public {
+			fn derive<Iter: Iterator<Item = $crate::DeriveJunction>>(
+				&self,
+				path: Iter,
+			) -> Option<Self> {
+				self.0.derive(path).map(Self)
+			}
+		}
+
+		impl core::fmt::Display for Public {
+			fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+				use $crate::Ss58Codec;
+				write!(f, "{}", self.0.to_ss58check())
+			}
+		}
+
+		impl $crate::serde::Serialize for Public {
+			fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
+			where
+				S: $crate::serde::Serializer,
+			{
+				use $crate::Ss58Codec;
+				serializer.serialize_str(&self.to_ss58check())
+			}
+		}
+
+		impl<'de> $crate::serde::Deserialize<'de> for Public {
+			fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
+			where
+				D: $crate::serde::Deserializer<'de>,
+			{
+				use $crate::{module_format_string_prelude::*, Ss58Codec};
+
+				Public::from_ss58check(&String::deserialize(deserializer)?)
+					.map_err(|e| $crate::serde::de::Error::custom(format!("{:?}", e)))
+			}
+		}
+	};
+}
+
+#[cfg(not(feature = "serde"))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_public_common_if_serde {
+	() => {
+		impl $crate::Derive for Public {}
+	};
+}
+
+/// Declares Signature type which is functionally equivalent to `$sig`, but is new
+/// Application-specific type whose identifier is `$key_type`.
+/// For full functionality, app_crypto_public_common! must be called too.
+/// Can only be used with `full_crypto` feature
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_signature_full_crypto {
+	($sig:ty, $key_type:expr, $crypto_type:expr) => {
+		$crate::wrap! {
+			/// A generic `AppPublic` wrapper type over $public crypto; this has no specific App.
+			#[derive(Clone, Eq, PartialEq,
+				$crate::codec::Encode,
+				$crate::codec::Decode,
+				$crate::RuntimeDebug,
+				$crate::scale_info::TypeInfo,
+			)]
+			#[derive(Hash)]
+			pub struct Signature($sig);
+		}
+
+		impl $crate::CryptoType for Signature {
+			type Pair = Pair;
+		}
+
+		impl $crate::AppCrypto for Signature {
+			type Public = Public;
+			type Pair = Pair;
+			type Signature = Signature;
+			const ID: $crate::KeyTypeId = $key_type;
+			const CRYPTO_ID: $crate::CryptoTypeId = $crypto_type;
+		}
+	};
+}
+
+/// Declares `Signature` type which is functionally equivalent to `$sig`, but is new
+/// application-specific type whose identifier is `$key_type`.
+/// For full functionality, `app_crypto_signature_common` must be called too.
+/// Can only be used without `full_crypto` feature.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_signature_not_full_crypto {
+	($sig:ty, $key_type:expr, $crypto_type:expr) => {
+		$crate::wrap! {
+			/// A generic `AppPublic` wrapper type over $public crypto; this has no specific App.
+			#[derive(Clone, Eq, PartialEq,
+				$crate::codec::Encode,
+				$crate::codec::Decode,
+				$crate::RuntimeDebug,
+				$crate::scale_info::TypeInfo,
+			)]
+			pub struct Signature($sig);
+		}
+
+		impl $crate::CryptoType for Signature {}
+
+		impl $crate::AppCrypto for Signature {
+			type Public = Public;
+			type Signature = Signature;
+			const ID: $crate::KeyTypeId = $key_type;
+			const CRYPTO_ID: $crate::CryptoTypeId = $crypto_type;
+		}
+	};
+}
+
+/// Declares `Signature` type which is functionally equivalent to `$sig`, but is new
+/// application-specific type whose identifier is `$key_type`.
+/// For full functionality, app_crypto_signature_(not)_full_crypto! must be called too.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! app_crypto_signature_common {
+	($sig:ty, $key_type:expr) => {
+		impl $crate::Deref for Signature {
+			type Target = [u8];
+
+			fn deref(&self) -> &Self::Target {
+				self.0.as_ref()
+			}
+		}
+
+		impl AsRef<[u8]> for Signature {
+			fn as_ref(&self) -> &[u8] {
+				self.0.as_ref()
+			}
+		}
+
+		impl $crate::AppSignature for Signature {
+			type Generic = $sig;
+		}
+
+		impl<'a> TryFrom<&'a [u8]> for Signature {
+			type Error = ();
+
+			fn try_from(data: &'a [u8]) -> Result<Self, Self::Error> {
+				<$sig>::try_from(data).map(Into::into)
+			}
+		}
+
+		impl TryFrom<$crate::Vec<u8>> for Signature {
+			type Error = ();
+
+			fn try_from(data: $crate::Vec<u8>) -> Result<Self, Self::Error> {
+				Self::try_from(&data[..])
+			}
+		}
+
+		impl Signature {
+			/// Convert into wrapped generic signature type.
+			pub fn into_inner(self) -> $sig {
+				self.0
+			}
+		}
+	};
+}
+
+/// Implement bidirectional `From` and on-way `AsRef`/`AsMut` for two types, `$inner` and `$outer`.
+///
+/// ```rust
+/// sp_application_crypto::wrap! {
+///     pub struct Wrapper(u32);
+/// }
+/// ```
+#[macro_export]
+macro_rules! wrap {
+	($( #[ $attr:meta ] )* struct $outer:ident($inner:ty);) => {
+		$( #[ $attr ] )*
+		struct $outer( $inner );
+		$crate::wrap!($inner, $outer);
+	};
+	($( #[ $attr:meta ] )* pub struct $outer:ident($inner:ty);) => {
+		$( #[ $attr ] )*
+		pub struct $outer( $inner );
+		$crate::wrap!($inner, $outer);
+	};
+	($inner:ty, $outer:ty) => {
+		impl $crate::Wraps for $outer {
+			type Inner = $inner;
+		}
+		impl From<$inner> for $outer {
+			fn from(inner: $inner) -> Self {
+				Self(inner)
+			}
+		}
+		impl From<$outer> for $inner {
+			fn from(outer: $outer) -> Self {
+				outer.0
+			}
+		}
+		impl AsRef<$inner> for $outer {
+			fn as_ref(&self) -> &$inner {
+				&self.0
+			}
+		}
+		impl AsMut<$inner> for $outer {
+			fn as_mut(&mut self) -> &mut $inner {
+				&mut self.0
+			}
+		}
+	}
+}
+
+/// Generate the given code if the pair type is available.
+///
+/// The pair type is available when `feature = "std"` || `feature = "full_crypto"`.
+///
+/// # Example
+///
+/// ```
+/// sp_application_crypto::with_pair! {
+///     pub type Pair = ();
+/// }
+/// ```
+#[macro_export]
+#[cfg(any(feature = "std", feature = "full_crypto"))]
+macro_rules! with_pair {
+	( $( $def:tt )* ) => {
+		$( $def )*
+	}
+}
+
+#[doc(hidden)]
+#[macro_export]
+#[cfg(all(not(feature = "std"), not(feature = "full_crypto")))]
+macro_rules! with_pair {
+	( $( $def:tt )* ) => {};
+}
diff --git a/substrate/primitives/application-crypto/src/sr25519.rs b/substrate/primitives/application-crypto/src/sr25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c91bfa7bb5ffe221a618769f2cb3de3e054d042
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/sr25519.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! Sr25519 crypto types.
+
+use crate::{KeyTypeId, RuntimePublic};
+
+use sp_std::vec::Vec;
+
+pub use sp_core::sr25519::*;
+
+mod app {
+	crate::app_crypto!(super, sp_core::testing::SR25519);
+}
+
+#[cfg(feature = "full_crypto")]
+pub use app::Pair as AppPair;
+pub use app::{Public as AppPublic, Signature as AppSignature};
+
+impl RuntimePublic for Public {
+	type Signature = Signature;
+
+	fn all(key_type: KeyTypeId) -> crate::Vec<Self> {
+		sp_io::crypto::sr25519_public_keys(key_type)
+	}
+
+	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self {
+		sp_io::crypto::sr25519_generate(key_type, seed)
+	}
+
+	fn sign<M: AsRef<[u8]>>(&self, key_type: KeyTypeId, msg: &M) -> Option<Self::Signature> {
+		sp_io::crypto::sr25519_sign(key_type, self, msg.as_ref())
+	}
+
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool {
+		sp_io::crypto::sr25519_verify(signature, msg.as_ref(), self)
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		sp_core::crypto::ByteArray::to_raw_vec(self)
+	}
+}
diff --git a/substrate/primitives/application-crypto/src/traits.rs b/substrate/primitives/application-crypto/src/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e9b1080f63d9ce96ced35989cfba56887f03feb9
--- /dev/null
+++ b/substrate/primitives/application-crypto/src/traits.rs
@@ -0,0 +1,197 @@
+// 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 codec::Codec;
+use scale_info::TypeInfo;
+
+#[cfg(feature = "full_crypto")]
+use sp_core::crypto::Pair;
+use sp_core::crypto::{CryptoType, CryptoTypeId, IsWrappedBy, KeyTypeId, Public};
+use sp_std::{fmt::Debug, vec::Vec};
+
+/// Application-specific cryptographic object.
+///
+/// Combines all the core types and constants that are defined by a particular
+/// cryptographic scheme when it is used in a specific application domain.
+///
+/// Typically, the implementers of this trait are its associated types themselves.
+/// This provides a convenient way to access generic information about the scheme
+/// given any of the associated types.
+pub trait AppCrypto: 'static + Sized + CryptoType {
+	/// Identifier for application-specific key type.
+	const ID: KeyTypeId;
+
+	/// Identifier of the crypto type of this application-specific key type.
+	const CRYPTO_ID: CryptoTypeId;
+
+	/// The corresponding public key type in this application scheme.
+	type Public: AppPublic;
+
+	/// The corresponding signature type in this application scheme.
+	type Signature: AppSignature;
+
+	/// The corresponding key pair type in this application scheme.
+	#[cfg(feature = "full_crypto")]
+	type Pair: AppPair;
+}
+
+/// Type which implements Hash in std, not when no-std (std variant).
+#[cfg(any(feature = "std", feature = "full_crypto"))]
+pub trait MaybeHash: sp_std::hash::Hash {}
+#[cfg(any(feature = "std", feature = "full_crypto"))]
+impl<T: sp_std::hash::Hash> MaybeHash for T {}
+
+/// Type which implements Hash in std, not when no-std (no-std variant).
+#[cfg(all(not(feature = "std"), not(feature = "full_crypto")))]
+pub trait MaybeHash {}
+#[cfg(all(not(feature = "std"), not(feature = "full_crypto")))]
+impl<T> MaybeHash for T {}
+
+/// Application-specific key pair.
+#[cfg(feature = "full_crypto")]
+pub trait AppPair:
+	AppCrypto + Pair<Public = <Self as AppCrypto>::Public, Signature = <Self as AppCrypto>::Signature>
+{
+	/// The wrapped type which is just a plain instance of `Pair`.
+	type Generic: IsWrappedBy<Self>
+		+ Pair<Public = <<Self as AppCrypto>::Public as AppPublic>::Generic>
+		+ Pair<Signature = <<Self as AppCrypto>::Signature as AppSignature>::Generic>;
+}
+
+/// Application-specific public key.
+pub trait AppPublic: AppCrypto + Public + Debug + MaybeHash + Codec {
+	/// The wrapped type which is just a plain instance of `Public`.
+	type Generic: IsWrappedBy<Self> + Public + Debug + MaybeHash + Codec;
+}
+
+/// Application-specific signature.
+pub trait AppSignature: AppCrypto + Eq + PartialEq + Debug + Clone {
+	/// The wrapped type which is just a plain instance of `Signature`.
+	type Generic: IsWrappedBy<Self> + Eq + PartialEq + Debug;
+}
+
+/// Runtime interface for a public key.
+pub trait RuntimePublic: Sized {
+	/// The signature that will be generated when signing with the corresponding private key.
+	type Signature: Debug + Eq + PartialEq + Clone;
+
+	/// Returns all public keys for the given key type in the keystore.
+	fn all(key_type: KeyTypeId) -> crate::Vec<Self>;
+
+	/// Generate a public/private pair for the given key type with an optional `seed` and
+	/// store it in the keystore.
+	///
+	/// The `seed` needs to be valid utf8.
+	///
+	/// Returns the generated public key.
+	fn generate_pair(key_type: KeyTypeId, seed: Option<Vec<u8>>) -> Self;
+
+	/// Sign the given message with the corresponding private key of this public key.
+	///
+	/// The private key will be requested from the keystore using the given key type.
+	///
+	/// Returns the signature or `None` if the private key could not be found or some other error
+	/// occurred.
+	fn sign<M: AsRef<[u8]>>(&self, key_type: KeyTypeId, msg: &M) -> Option<Self::Signature>;
+
+	/// Verify that the given signature matches the given message using this public key.
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool;
+
+	/// Returns `Self` as raw vec.
+	fn to_raw_vec(&self) -> Vec<u8>;
+}
+
+/// Runtime interface for an application's public key.
+pub trait RuntimeAppPublic: Sized {
+	/// An identifier for this application-specific key type.
+	const ID: KeyTypeId;
+
+	/// The signature that will be generated when signing with the corresponding private key.
+	type Signature: Debug + Eq + PartialEq + Clone + TypeInfo + Codec;
+
+	/// Returns all public keys for this application in the keystore.
+	fn all() -> crate::Vec<Self>;
+
+	/// Generate a public/private pair with an optional `seed` and store it in the keystore.
+	///
+	/// The `seed` needs to be valid utf8.
+	///
+	/// Returns the generated public key.
+	fn generate_pair(seed: Option<Vec<u8>>) -> Self;
+
+	/// Sign the given message with the corresponding private key of this public key.
+	///
+	/// The private key will be requested from the keystore.
+	///
+	/// Returns the signature or `None` if the private key could not be found or some other error
+	/// occurred.
+	fn sign<M: AsRef<[u8]>>(&self, msg: &M) -> Option<Self::Signature>;
+
+	/// Verify that the given signature matches the given message using this public key.
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool;
+
+	/// Returns `Self` as raw vec.
+	fn to_raw_vec(&self) -> Vec<u8>;
+}
+
+impl<T> RuntimeAppPublic for T
+where
+	T: AppPublic + AsRef<<T as AppPublic>::Generic>,
+	<T as AppPublic>::Generic: RuntimePublic,
+	<T as AppCrypto>::Signature: TypeInfo
+		+ Codec
+		+ From<<<T as AppPublic>::Generic as RuntimePublic>::Signature>
+		+ AsRef<<<T as AppPublic>::Generic as RuntimePublic>::Signature>,
+{
+	const ID: KeyTypeId = <T as AppCrypto>::ID;
+
+	type Signature = <T as AppCrypto>::Signature;
+
+	fn all() -> crate::Vec<Self> {
+		<<T as AppPublic>::Generic as RuntimePublic>::all(Self::ID)
+			.into_iter()
+			.map(|p| p.into())
+			.collect()
+	}
+
+	fn generate_pair(seed: Option<Vec<u8>>) -> Self {
+		<<T as AppPublic>::Generic as RuntimePublic>::generate_pair(Self::ID, seed).into()
+	}
+
+	fn sign<M: AsRef<[u8]>>(&self, msg: &M) -> Option<Self::Signature> {
+		<<T as AppPublic>::Generic as RuntimePublic>::sign(self.as_ref(), Self::ID, msg)
+			.map(|s| s.into())
+	}
+
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool {
+		<<T as AppPublic>::Generic as RuntimePublic>::verify(self.as_ref(), msg, signature.as_ref())
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		<<T as AppPublic>::Generic as RuntimePublic>::to_raw_vec(self.as_ref())
+	}
+}
+
+/// Something that is bound to a fixed [`RuntimeAppPublic`].
+pub trait BoundToRuntimeAppPublic {
+	/// The [`RuntimeAppPublic`] this type is bound to.
+	type Public: RuntimeAppPublic;
+}
+
+impl<T: RuntimeAppPublic> BoundToRuntimeAppPublic for T {
+	type Public = Self;
+}
diff --git a/substrate/primitives/application-crypto/test/Cargo.toml b/substrate/primitives/application-crypto/test/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d4b2ccca909b510a5c920593ab71248861afc6b7
--- /dev/null
+++ b/substrate/primitives/application-crypto/test/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "sp-application-crypto-test"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+description = "Integration tests for application-crypto"
+license = "Apache-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-api = { version = "4.0.0-dev", path = "../../api" }
+sp-application-crypto = { version = "23.0.0", path = "../" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../core" }
+sp-keystore = { version = "0.27.0", default-features = false, path = "../../keystore" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../test-utils/runtime/client" }
diff --git a/substrate/primitives/application-crypto/test/src/ecdsa.rs b/substrate/primitives/application-crypto/test/src/ecdsa.rs
new file mode 100644
index 0000000000000000000000000000000000000000..396683a91ac02301513d5db82a4e5cb7ea7846a3
--- /dev/null
+++ b/substrate/primitives/application-crypto/test/src/ecdsa.rs
@@ -0,0 +1,46 @@
+// 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.
+
+//! Integration tests for ecdsa
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::ecdsa::AppPair;
+use sp_core::{
+	crypto::{ByteArray, Pair},
+	testing::ECDSA,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::TestAPI, DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn ecdsa_works_in_runtime() {
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (signature, public) = runtime_api
+		.test_ecdsa_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `ecdsa` crypto.");
+
+	let supported_keys = keystore.keys(ECDSA).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+	assert!(AppPair::verify(&signature, "ecdsa", &public));
+}
diff --git a/substrate/primitives/application-crypto/test/src/ed25519.rs b/substrate/primitives/application-crypto/test/src/ed25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f0ceccdcebfcd0638360f18375caf1cfd2310ad6
--- /dev/null
+++ b/substrate/primitives/application-crypto/test/src/ed25519.rs
@@ -0,0 +1,47 @@
+// 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.
+
+//! Integration tests for ed25519
+
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::ed25519::AppPair;
+use sp_core::{
+	crypto::{ByteArray, Pair},
+	testing::ED25519,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::TestAPI, DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn ed25519_works_in_runtime() {
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (signature, public) = runtime_api
+		.test_ed25519_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `ed25519` crypto.");
+
+	let supported_keys = keystore.keys(ED25519).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+	assert!(AppPair::verify(&signature, "ed25519", &public));
+}
diff --git a/substrate/primitives/application-crypto/test/src/lib.rs b/substrate/primitives/application-crypto/test/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..90856ee1e596fee0c4dc3f8636ed050d684dcdd9
--- /dev/null
+++ b/substrate/primitives/application-crypto/test/src/lib.rs
@@ -0,0 +1,25 @@
+// 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.
+
+//! Integration tests for application crypto
+
+#[cfg(test)]
+mod ecdsa;
+#[cfg(test)]
+mod ed25519;
+#[cfg(test)]
+mod sr25519;
diff --git a/substrate/primitives/application-crypto/test/src/sr25519.rs b/substrate/primitives/application-crypto/test/src/sr25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3c62270395f0406d3afcc16837af3ba7fa5532c2
--- /dev/null
+++ b/substrate/primitives/application-crypto/test/src/sr25519.rs
@@ -0,0 +1,47 @@
+// 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.
+
+//! Integration tests for sr25519
+
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_application_crypto::sr25519::AppPair;
+use sp_core::{
+	crypto::{ByteArray, Pair},
+	testing::SR25519,
+};
+use sp_keystore::{testing::MemoryKeystore, Keystore, KeystoreExt};
+use std::sync::Arc;
+use substrate_test_runtime_client::{
+	runtime::TestAPI, DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+};
+
+#[test]
+fn sr25519_works_in_runtime() {
+	let keystore = Arc::new(MemoryKeystore::new());
+	let test_client = TestClientBuilder::new().build();
+
+	let mut runtime_api = test_client.runtime_api();
+	runtime_api.register_extension(KeystoreExt::new(keystore.clone()));
+
+	let (signature, public) = runtime_api
+		.test_sr25519_crypto(test_client.chain_info().genesis_hash)
+		.expect("Tests `sr25519` crypto.");
+
+	let supported_keys = keystore.keys(SR25519).unwrap();
+	assert!(supported_keys.contains(&public.to_raw_vec()));
+	assert!(AppPair::verify(&signature, "sr25519", &public));
+}
diff --git a/substrate/primitives/arithmetic/Cargo.toml b/substrate/primitives/arithmetic/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d7b9b2bf74791df9c1492c65ff270fd9feb89cdf
--- /dev/null
+++ b/substrate/primitives/arithmetic/Cargo.toml
@@ -0,0 +1,49 @@
+[package]
+name = "sp-arithmetic"
+version = "16.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Minimal fixed point arithmetic primitives and types for runtime."
+documentation = "https://docs.rs/sp-arithmetic"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [
+	"derive",
+	"max-encoded-len",
+] }
+integer-sqrt = "0.1.2"
+num-traits = { version = "0.2.8", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, features = ["derive", "alloc"], optional = true }
+static_assertions = "1.1.0"
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[dev-dependencies]
+criterion = "0.4.0"
+primitive-types = "0.12.0"
+sp-core = { version = "21.0.0", features = ["full_crypto"], path = "../core" }
+rand = "0.8.5"
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"num-traits/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-core/std",
+	"sp-std/std",
+]
+# Serde support without relying on std features.
+serde = [ "dep:serde", "scale-info/serde" ]
+
+[[bench]]
+name = "bench"
+harness = false
diff --git a/substrate/primitives/arithmetic/README.md b/substrate/primitives/arithmetic/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e6e52c2a82696ba42e756458fff5839d2d88c09f
--- /dev/null
+++ b/substrate/primitives/arithmetic/README.md
@@ -0,0 +1,3 @@
+Minimal fixed point arithmetic primitives and types for runtime.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/arithmetic/benches/bench.rs b/substrate/primitives/arithmetic/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6a8abca14e526bf0a0731d6fc42d19ccd357a921
--- /dev/null
+++ b/substrate/primitives/arithmetic/benches/bench.rs
@@ -0,0 +1,81 @@
+// 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 criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use rand::Rng;
+use sp_arithmetic::biguint::{BigUint, Single};
+
+fn random_big_uint(size: usize) -> BigUint {
+	let mut rng = rand::thread_rng();
+	let digits: Vec<_> = (0..size).map(|_| rng.gen_range(0..Single::MAX)).collect();
+	BigUint::from_limbs(&digits)
+}
+
+fn bench_op<F: Fn(&BigUint, &BigUint)>(c: &mut Criterion, name: &str, op: F) {
+	let mut group = c.benchmark_group(name);
+
+	for size in [2, 4, 6, 8, 10].iter() {
+		group.throughput(Throughput::Elements(*size));
+		group.bench_with_input(BenchmarkId::from_parameter(size), size, |bencher, &size| {
+			let a = random_big_uint(size as usize);
+			let b = random_big_uint(size as usize);
+
+			bencher.iter(|| op(&a, &b));
+		});
+	}
+}
+
+fn bench_addition(c: &mut Criterion) {
+	bench_op(c, "addition", |a, b| {
+		let _ = a.clone().add(b);
+	});
+}
+
+fn bench_subtraction(c: &mut Criterion) {
+	bench_op(c, "subtraction", |a, b| {
+		let _ = a.clone().sub(b);
+	});
+}
+
+fn bench_multiplication(c: &mut Criterion) {
+	bench_op(c, "multiplication", |a, b| {
+		let _ = a.clone().mul(b);
+	});
+}
+
+fn bench_division(c: &mut Criterion) {
+	let mut group = c.benchmark_group("division");
+
+	for size in [4, 6, 8, 10].iter() {
+		group.throughput(Throughput::Elements(*size));
+		group.bench_with_input(BenchmarkId::from_parameter(size), size, |bencher, &size| {
+			let a = random_big_uint(size as usize);
+			let b = random_big_uint(rand::thread_rng().gen_range(2..size as usize));
+
+			bencher.iter(|| {
+				let _ = a.clone().div(&b, true);
+			});
+		});
+	}
+}
+
+criterion_group! {
+	name = benches;
+	config = Criterion::default();
+	targets = bench_addition, bench_subtraction, bench_multiplication, bench_division
+}
+criterion_main!(benches);
diff --git a/substrate/primitives/arithmetic/fuzzer/Cargo.toml b/substrate/primitives/arithmetic/fuzzer/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..976798831797d91fa800b7f1f1c3e0b42c90c1cb
--- /dev/null
+++ b/substrate/primitives/arithmetic/fuzzer/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "sp-arithmetic-fuzzer"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Fuzzer for fixed point arithmetic primitives."
+documentation = "https://docs.rs/sp-arithmetic-fuzzer"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+arbitrary = "1.3.0"
+fraction = "0.13.1"
+honggfuzz = "0.5.49"
+num-bigint = "0.4.3"
+sp-arithmetic = { version = "16.0.0", path = ".." }
+
+[[bin]]
+name = "biguint"
+path = "src/biguint.rs"
+
+[[bin]]
+name = "normalize"
+path = "src/normalize.rs"
+
+[[bin]]
+name = "per_thing_from_rational"
+path = "src/per_thing_from_rational.rs"
+
+[[bin]]
+name = "per_thing_mult_fraction"
+path = "src/per_thing_mult_fraction.rs"
+
+[[bin]]
+name = "multiply_by_rational_with_rounding"
+path = "src/multiply_by_rational_with_rounding.rs"
+
+[[bin]]
+name = "fixed_point"
+path = "src/fixed_point.rs"
diff --git a/substrate/primitives/arithmetic/fuzzer/src/biguint.rs b/substrate/primitives/arithmetic/fuzzer/src/biguint.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f9f54c81000123a36f0da42c9a1079c76675855
--- /dev/null
+++ b/substrate/primitives/arithmetic/fuzzer/src/biguint.rs
@@ -0,0 +1,211 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run biguint`. `honggfuzz` CLI options can
+//! be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug biguint hfuzz_workspace/biguint/*.fuzz`.
+//!
+//! # More information
+//! More information about `honggfuzz` can be found
+//! [here](https://docs.rs/honggfuzz/).
+
+use honggfuzz::fuzz;
+use sp_arithmetic::biguint::{BigUint, Single};
+
+fn main() {
+	loop {
+		fuzz!(|data: (Vec<Single>, Vec<Single>, bool)| {
+			let (mut digits_u, mut digits_v, return_remainder) = data;
+
+			let mut u = BigUint::from_limbs(&digits_u);
+			let mut v = BigUint::from_limbs(&digits_v);
+
+			u.lstrip();
+			v.lstrip();
+
+			let ue = u128::try_from(u.clone());
+			let ve = u128::try_from(v.clone());
+
+			digits_u.reverse();
+			digits_v.reverse();
+
+			let num_u = num_bigint::BigUint::new(digits_u);
+			let num_v = num_bigint::BigUint::new(digits_v);
+
+			if check_digit_lengths(&u, &v, 4) {
+				assert_eq!(u.cmp(&v), ue.cmp(&ve));
+				assert_eq!(u.eq(&v), ue.eq(&ve));
+			}
+
+			if check_digit_lengths(&u, &v, 3) {
+				let expected = ue.unwrap() + ve.unwrap();
+				let t = u.clone().add(&v);
+				assert_eq!(
+					u128::try_from(t.clone()).unwrap(),
+					expected,
+					"{:?} + {:?} ===> {:?} != {:?}",
+					u,
+					v,
+					t,
+					expected,
+				);
+			}
+
+			if check_digit_lengths(&u, &v, 4) {
+				let expected = ue.unwrap().checked_sub(ve.unwrap());
+				let t = u.clone().sub(&v);
+				if expected.is_none() {
+					assert!(t.is_err())
+				} else {
+					let t = t.unwrap();
+					let expected = expected.unwrap();
+					assert_eq!(
+						u128::try_from(t.clone()).unwrap(),
+						expected,
+						"{:?} - {:?} ===> {:?} != {:?}",
+						u,
+						v,
+						t,
+						expected,
+					);
+				}
+			}
+
+			if check_digit_lengths(&u, &v, 2) {
+				let expected = ue.unwrap() * ve.unwrap();
+				let t = u.clone().mul(&v);
+				assert_eq!(
+					u128::try_from(t.clone()).unwrap(),
+					expected,
+					"{:?} * {:?} ===> {:?} != {:?}",
+					u,
+					v,
+					t,
+					expected,
+				);
+			}
+
+			if check_digit_lengths(&u, &v, 4) {
+				let (ue, ve) = (ue.unwrap(), ve.unwrap());
+				if ve == 0 {
+					return
+				}
+				let (q, r) = (ue / ve, ue % ve);
+				if let Some((qq, rr)) = u.clone().div(&v, true) {
+					assert_eq!(
+						u128::try_from(qq.clone()).unwrap(),
+						q,
+						"{:?} / {:?} ===> {:?} != {:?}",
+						u,
+						v,
+						qq,
+						q,
+					);
+					assert_eq!(
+						u128::try_from(rr.clone()).unwrap(),
+						r,
+						"{:?} % {:?} ===> {:?} != {:?}",
+						u,
+						v,
+						rr,
+						r,
+					);
+				} else if v.len() == 1 {
+					let qq = u.clone().div_unit(ve as Single);
+					assert_eq!(
+						u128::try_from(qq.clone()).unwrap(),
+						q,
+						"[single] {:?} / {:?} ===> {:?} != {:?}",
+						u,
+						v,
+						qq,
+						q,
+					);
+				} else if v.msb() != 0 && u.msb() != 0 && u.len() > v.len() {
+					panic!("div returned none for an unexpected reason");
+				}
+			}
+
+			// Test against num_bigint
+
+			// Equality
+
+			assert_eq!(u.cmp(&v), num_u.cmp(&num_v));
+
+			// Addition
+
+			let w = u.clone().add(&v);
+			let num_w = num_u.clone() + &num_v;
+
+			assert_biguints_eq(&w, &num_w);
+
+			// Subtraction
+
+			if let Ok(w) = u.clone().sub(&v) {
+				let num_w = num_u.clone() - &num_v;
+
+				assert_biguints_eq(&w, &num_w);
+			}
+
+			// Multiplication
+
+			let w = u.clone().mul(&v);
+			let num_w = num_u.clone() * &num_v;
+
+			assert_biguints_eq(&w, &num_w);
+
+			// Division
+
+			if v.len() == 1 && v.get(0) != 0 {
+				let w = u.div_unit(v.get(0));
+				let num_w = num_u / &num_v;
+				assert_biguints_eq(&w, &num_w);
+			} else if u.len() > v.len() && v.len() > 1 {
+				let num_remainder = num_u.clone() % num_v.clone();
+
+				let (w, remainder) = u.div(&v, return_remainder).unwrap();
+				let num_w = num_u / &num_v;
+
+				assert_biguints_eq(&w, &num_w);
+
+				if return_remainder {
+					assert_biguints_eq(&remainder, &num_remainder);
+				}
+			}
+		});
+	}
+}
+
+fn check_digit_lengths(u: &BigUint, v: &BigUint, max_limbs: usize) -> bool {
+	1 <= u.len() && u.len() <= max_limbs && 1 <= v.len() && v.len() <= max_limbs
+}
+
+fn assert_biguints_eq(a: &BigUint, b: &num_bigint::BigUint) {
+	let mut a = a.clone();
+	a.lstrip();
+
+	// `num_bigint::BigUint` doesn't expose it's internals, so we need to convert into that to
+	// compare.
+	let limbs = (0..a.len()).map(|i| a.get(i)).collect();
+	let num_a = num_bigint::BigUint::new(limbs);
+
+	assert!(&num_a == b, "\narithmetic: {:?}\nnum-bigint: {:?}", a, b);
+}
diff --git a/substrate/primitives/arithmetic/fuzzer/src/fixed_point.rs b/substrate/primitives/arithmetic/fuzzer/src/fixed_point.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e76dd1503e39fddb5dbfde601d5a86d28c5b1b88
--- /dev/null
+++ b/substrate/primitives/arithmetic/fuzzer/src/fixed_point.rs
@@ -0,0 +1,84 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run fixed_point`. `honggfuzz` CLI options can
+//! be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug fixed_point hfuzz_workspace/fixed_point/*.fuzz`.
+//!
+//! # More information
+//! More information about `honggfuzz` can be found
+//! [here](https://docs.rs/honggfuzz/).
+
+use honggfuzz::fuzz;
+use sp_arithmetic::{traits::Saturating, FixedI64, FixedPointNumber};
+
+fn main() {
+	loop {
+		fuzz!(|data: (i32, i32)| {
+			let x: i128 = data.0.into();
+			let y: i128 = data.1.into();
+
+			// Check `from_rational` and division are consistent.
+			if y != 0 {
+				let f1 =
+					FixedI64::saturating_from_integer(x) / FixedI64::saturating_from_integer(y);
+				let f2 = FixedI64::saturating_from_rational(x, y);
+				assert_eq!(f1.into_inner(), f2.into_inner());
+			}
+
+			// Check `saturating_mul`.
+			let a = FixedI64::saturating_from_rational(2, 5);
+			let b = a.saturating_mul(FixedI64::saturating_from_integer(x));
+			let n = b.into_inner() as i128;
+			let m = 2i128 * x * FixedI64::accuracy() as i128 / 5i128;
+			assert_eq!(n, m);
+
+			// Check `saturating_mul` and division are inverse.
+			if x != 0 {
+				assert_eq!(a, b / FixedI64::saturating_from_integer(x));
+			}
+
+			// Check `reciprocal`.
+			let r = a.reciprocal().unwrap().reciprocal().unwrap();
+			assert_eq!(a, r);
+
+			// Check addition.
+			let a = FixedI64::saturating_from_integer(x);
+			let b = FixedI64::saturating_from_integer(y);
+			let c = FixedI64::saturating_from_integer(x.saturating_add(y));
+			assert_eq!(a.saturating_add(b), c);
+
+			// Check substraction.
+			let a = FixedI64::saturating_from_integer(x);
+			let b = FixedI64::saturating_from_integer(y);
+			let c = FixedI64::saturating_from_integer(x.saturating_sub(y));
+			assert_eq!(a.saturating_sub(b), c);
+
+			// Check `saturating_mul_acc_int`.
+			let a = FixedI64::saturating_from_rational(2, 5);
+			let b = a.saturating_mul_acc_int(x);
+			let xx = FixedI64::saturating_from_integer(x);
+			let d = a.saturating_mul(xx).saturating_add(xx).into_inner() as i128 /
+				FixedI64::accuracy() as i128;
+			assert_eq!(b, d);
+		});
+	}
+}
diff --git a/substrate/primitives/arithmetic/fuzzer/src/multiply_by_rational_with_rounding.rs b/substrate/primitives/arithmetic/fuzzer/src/multiply_by_rational_with_rounding.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5f3f675c971f21503944a5474bd053faf7dd4873
--- /dev/null
+++ b/substrate/primitives/arithmetic/fuzzer/src/multiply_by_rational_with_rounding.rs
@@ -0,0 +1,105 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run multiply_by_rational_with_rounding`.
+//! `honggfuzz` CLI options can be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4
+//! threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug multiply_by_rational_with_rounding
+//! hfuzz_workspace/multiply_by_rational_with_rounding/*.fuzz`.
+//!
+//! # More information
+//! More information about `honggfuzz` can be found
+//! [here](https://docs.rs/honggfuzz/).
+
+use fraction::prelude::BigFraction as Fraction;
+use honggfuzz::fuzz;
+use sp_arithmetic::{MultiplyRational, Rounding, Rounding::*};
+
+/// Tries to demonstrate that `multiply_by_rational_with_rounding` is incorrect.
+fn main() {
+	loop {
+		fuzz!(|data: (u128, u128, u128, ArbitraryRounding)| {
+			let (f, n, d, r) = (data.0, data.1, data.2, data.3 .0);
+
+			check::<u8>(f as u8, n as u8, d as u8, r);
+			check::<u16>(f as u16, n as u16, d as u16, r);
+			check::<u32>(f as u32, n as u32, d as u32, r);
+			check::<u64>(f as u64, n as u64, d as u64, r);
+			check::<u128>(f, n, d, r);
+		})
+	}
+}
+
+fn check<N>(f: N, n: N, d: N, r: Rounding)
+where
+	N: MultiplyRational + Into<u128> + Copy + core::fmt::Debug,
+{
+	let Some(got) = f.multiply_rational(n, d, r) else { return };
+
+	let (ae, be, ce) =
+		(Fraction::from(f.into()), Fraction::from(n.into()), Fraction::from(d.into()));
+	let want = round(ae * be / ce, r);
+
+	assert_eq!(
+		Fraction::from(got.into()),
+		want,
+		"{:?} * {:?} / {:?} = {:?} != {:?}",
+		f,
+		n,
+		d,
+		got,
+		want
+	);
+}
+
+/// Round a `Fraction` according to the given mode.
+fn round(f: Fraction, r: Rounding) -> Fraction {
+	match r {
+		Up => f.ceil(),
+		NearestPrefUp =>
+			if f.fract() < Fraction::from(0.5) {
+				f.floor()
+			} else {
+				f.ceil()
+			},
+		Down => f.floor(),
+		NearestPrefDown =>
+			if f.fract() > Fraction::from(0.5) {
+				f.ceil()
+			} else {
+				f.floor()
+			},
+	}
+}
+
+/// An [`arbitrary::Arbitrary`] [`Rounding`] mode.
+struct ArbitraryRounding(Rounding);
+impl arbitrary::Arbitrary<'_> for ArbitraryRounding {
+	fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
+		Ok(Self(match u.int_in_range(0..=3).unwrap() {
+			0 => Up,
+			1 => NearestPrefUp,
+			2 => Down,
+			3 => NearestPrefDown,
+			_ => unreachable!(),
+		}))
+	}
+}
diff --git a/substrate/primitives/arithmetic/fuzzer/src/normalize.rs b/substrate/primitives/arithmetic/fuzzer/src/normalize.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7211819017a873da33df00b154cae838f137b72b
--- /dev/null
+++ b/substrate/primitives/arithmetic/fuzzer/src/normalize.rs
@@ -0,0 +1,58 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run normalize`. `honggfuzz` CLI options can
+//! be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug normalize hfuzz_workspace/normalize/*.fuzz`.
+
+use honggfuzz::fuzz;
+use sp_arithmetic::Normalizable;
+
+type Ty = u64;
+
+fn main() {
+	let sum_limit = Ty::max_value() as u128;
+	let len_limit: usize = Ty::max_value().try_into().unwrap();
+
+	loop {
+		fuzz!(|data: (Vec<Ty>, Ty)| {
+			let (data, norm) = data;
+			if data.is_empty() {
+				return
+			}
+			let pre_sum: u128 = data.iter().map(|x| *x as u128).sum();
+
+			let normalized = data.normalize(norm);
+			// error cases.
+			if pre_sum > sum_limit || data.len() > len_limit {
+				assert!(normalized.is_err())
+			} else if let Ok(normalized) = normalized {
+				// if sum goes beyond u128, panic.
+				let sum: u128 = normalized.iter().map(|x| *x as u128).sum();
+
+				// if this function returns Ok(), then it will ALWAYS be accurate.
+				assert_eq!(sum, norm as u128, "sums don't match {:?}, {}", normalized, norm);
+			} else {
+				panic!("Should have returned Ok for input = {:?}, target = {:?}", data, norm);
+			}
+		})
+	}
+}
diff --git a/substrate/primitives/arithmetic/fuzzer/src/per_thing_from_rational.rs b/substrate/primitives/arithmetic/fuzzer/src/per_thing_from_rational.rs
new file mode 100644
index 0000000000000000000000000000000000000000..93af4df9e8e55d9190a0926467b5e72e7f423fbf
--- /dev/null
+++ b/substrate/primitives/arithmetic/fuzzer/src/per_thing_from_rational.rs
@@ -0,0 +1,105 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run per_thing_from_rational`. `honggfuzz` CLI
+//! options can be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug per_thing_from_rational hfuzz_workspace/per_thing_from_rational/*.fuzz`.
+
+use fraction::prelude::BigFraction as Fraction;
+use honggfuzz::fuzz;
+use sp_arithmetic::{
+	traits::SaturatedConversion, PerThing, Perbill, Percent, Perquintill, Rounding::*, *,
+};
+
+/// Tries to demonstrate that `from_rational` is incorrect for any rounding modes.
+///
+/// NOTE: This `Fraction` library is really slow. Using f128/f256 does not work for the large
+/// numbers. But an optimization could be done do use either floats or Fraction depending on the
+/// size of the inputs.
+fn main() {
+	loop {
+		fuzz!(|data: (u128, u128, ArbitraryRounding)| {
+			let (n, d, r) = (data.0.min(data.1), data.0.max(data.1).max(1), data.2);
+
+			check::<PerU16>(n, d, r.0);
+			check::<Percent>(n, d, r.0);
+			check::<Permill>(n, d, r.0);
+			check::<Perbill>(n, d, r.0);
+			check::<Perquintill>(n, d, r.0);
+		})
+	}
+}
+
+/// Assert that the parts of `from_rational` are correct for the given rounding mode.
+fn check<Per: PerThing>(a: u128, b: u128, r: Rounding)
+where
+	Per::Inner: Into<u128>,
+{
+	let approx_ratio = Per::from_rational_with_rounding(a, b, r).unwrap();
+	let approx_parts = Fraction::from(approx_ratio.deconstruct().saturated_into::<u128>());
+
+	let perfect_ratio = if a == 0 && b == 0 {
+		Fraction::from(1)
+	} else {
+		Fraction::from(a) / Fraction::from(b.max(1))
+	};
+	let perfect_parts = round(perfect_ratio * Fraction::from(Per::ACCURACY.into()), r);
+
+	assert_eq!(
+		approx_parts, perfect_parts,
+		"approx_parts: {}, perfect_parts: {}, a: {}, b: {}",
+		approx_parts, perfect_parts, a, b
+	);
+}
+
+/// Round a `Fraction` according to the given mode.
+fn round(f: Fraction, r: Rounding) -> Fraction {
+	match r {
+		Up => f.ceil(),
+		NearestPrefUp =>
+			if f.fract() < Fraction::from(0.5) {
+				f.floor()
+			} else {
+				f.ceil()
+			},
+		Down => f.floor(),
+		NearestPrefDown =>
+			if f.fract() > Fraction::from(0.5) {
+				f.ceil()
+			} else {
+				f.floor()
+			},
+	}
+}
+
+/// An [`arbitrary::Arbitrary`] [`Rounding`] mode.
+struct ArbitraryRounding(Rounding);
+impl arbitrary::Arbitrary<'_> for ArbitraryRounding {
+	fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
+		Ok(Self(match u.int_in_range(0..=3).unwrap() {
+			0 => Up,
+			1 => NearestPrefUp,
+			2 => Down,
+			3 => NearestPrefDown,
+			_ => unreachable!(),
+		}))
+	}
+}
diff --git a/substrate/primitives/arithmetic/fuzzer/src/per_thing_mult_fraction.rs b/substrate/primitives/arithmetic/fuzzer/src/per_thing_mult_fraction.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9cfe28a7800b0dd995009ccf780be43302c2ebb6
--- /dev/null
+++ b/substrate/primitives/arithmetic/fuzzer/src/per_thing_mult_fraction.rs
@@ -0,0 +1,69 @@
+// 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.
+
+//! # Running
+//! Running this fuzzer can be done with `cargo hfuzz run per_thing_mult_fraction`. `honggfuzz` CLI
+//! options can be used by setting `HFUZZ_RUN_ARGS`, such as `-n 4` to use 4 threads.
+//!
+//! # Debugging a panic
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug per_thing_mult_fraction hfuzz_workspace/per_thing_mult_fraction/*.fuzz`.
+
+use honggfuzz::fuzz;
+use sp_arithmetic::{PerThing, Perbill, Percent, Perquintill, *};
+
+/// Tries to disprove `(n / d) * d <= n` for any `PerThing`s.
+fn main() {
+	loop {
+		fuzz!(|data: (u128, u128)| {
+			let (n, d) = (data.0.min(data.1), data.0.max(data.1).max(1));
+
+			check_mul::<PerU16>(n, d);
+			check_mul::<Percent>(n, d);
+			check_mul::<Perbill>(n, d);
+			check_mul::<Perquintill>(n, d);
+
+			check_reciprocal_mul::<PerU16>(n, d);
+			check_reciprocal_mul::<Percent>(n, d);
+			check_reciprocal_mul::<Perbill>(n, d);
+			check_reciprocal_mul::<Perquintill>(n, d);
+		})
+	}
+}
+
+/// Checks that `(n / d) * d <= n`.
+fn check_mul<P: PerThing>(n: u128, d: u128)
+where
+	P: PerThing + core::ops::Mul<u128, Output = u128>,
+{
+	let q = P::from_rational_with_rounding(n, d, Rounding::Down).unwrap();
+	assert!(q * d <= n, "{:?} * {:?} <= {:?}", q, d, n);
+}
+
+/// Checks that `n / (n / d) >= d`.
+fn check_reciprocal_mul<P: PerThing>(n: u128, d: u128)
+where
+	P: PerThing + core::ops::Mul<u128, Output = u128>,
+{
+	let q = P::from_rational_with_rounding(n, d, Rounding::Down).unwrap();
+	if q.is_zero() {
+		return
+	}
+
+	let r = q.saturating_reciprocal_mul_floor(n);
+	assert!(r >= d, "{} / ({} / {}) != {} but {}", n, n, d, d, r);
+}
diff --git a/substrate/primitives/arithmetic/src/biguint.rs b/substrate/primitives/arithmetic/src/biguint.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d92b08c8eca96121ab1e9c6d54f9fca318815861
--- /dev/null
+++ b/substrate/primitives/arithmetic/src/biguint.rs
@@ -0,0 +1,753 @@
+// 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.
+
+//! Infinite precision unsigned integer for substrate runtime.
+
+use codec::{Decode, Encode};
+use num_traits::{One, Zero};
+use sp_std::{cell::RefCell, cmp::Ordering, ops, prelude::*, vec};
+
+// A sensible value for this would be half of the dword size of the host machine. Since the
+// runtime is compiled to 32bit webassembly, using 32 and 64 for single and double respectively
+// should yield the most performance.
+
+/// Representation of a single limb.
+pub type Single = u32;
+/// Representation of two limbs.
+pub type Double = u64;
+/// Difference in the number of bits of [`Single`] and [`Double`].
+const SHIFT: usize = 32;
+/// short form of _Base_. Analogous to the value 10 in base-10 decimal numbers.
+const B: Double = Single::max_value() as Double + 1;
+
+static_assertions::const_assert!(
+	sp_std::mem::size_of::<Double>() - sp_std::mem::size_of::<Single>() == SHIFT / 8
+);
+
+/// Splits a [`Double`] limb number into a tuple of two [`Single`] limb numbers.
+pub fn split(a: Double) -> (Single, Single) {
+	let al = a as Single;
+	let ah = (a >> SHIFT) as Single;
+	(ah, al)
+}
+
+/// Assumed as a given primitive.
+///
+/// Multiplication of two singles, which at most yields 1 double.
+pub fn mul_single(a: Single, b: Single) -> Double {
+	let a: Double = a.into();
+	let b: Double = b.into();
+	a * b
+}
+
+/// Assumed as a given primitive.
+///
+/// Addition of two singles, which at most takes a single limb of result and a carry,
+/// returned as a tuple respectively.
+pub fn add_single(a: Single, b: Single) -> (Single, Single) {
+	let a: Double = a.into();
+	let b: Double = b.into();
+	let q = a + b;
+	let (carry, r) = split(q);
+	(r, carry)
+}
+
+/// Assumed as a given primitive.
+///
+/// Division of double by a single limb. Always returns a double limb of quotient and a single
+/// limb of remainder.
+fn div_single(a: Double, b: Single) -> (Double, Single) {
+	let b: Double = b.into();
+	let q = a / b;
+	let r = a % b;
+	// both conversions are trivially safe.
+	(q, r as Single)
+}
+
+/// Simple wrapper around an infinitely large integer, represented as limbs of [`Single`].
+#[derive(Encode, Decode, Clone, Default)]
+pub struct BigUint {
+	/// digits (limbs) of this number (sorted as msb -> lsb).
+	pub(crate) digits: Vec<Single>,
+}
+
+impl BigUint {
+	/// Create a new instance with `size` limbs. This prevents any number with zero limbs to be
+	/// created.
+	///
+	/// The behavior of the type is undefined with zero limbs.
+	pub fn with_capacity(size: usize) -> Self {
+		Self { digits: vec![0; size.max(1)] }
+	}
+
+	/// Raw constructor from custom limbs. If `limbs` is empty, `Zero::zero()` implementation is
+	/// used.
+	pub fn from_limbs(limbs: &[Single]) -> Self {
+		if !limbs.is_empty() {
+			Self { digits: limbs.to_vec() }
+		} else {
+			Zero::zero()
+		}
+	}
+
+	/// Number of limbs.
+	pub fn len(&self) -> usize {
+		self.digits.len()
+	}
+
+	/// A naive getter for limb at `index`. Note that the order is lsb -> msb.
+	///
+	/// #### Panics
+	///
+	/// This panics if index is out of range.
+	pub fn get(&self, index: usize) -> Single {
+		self.digits[self.len() - 1 - index]
+	}
+
+	/// A naive getter for limb at `index`. Note that the order is lsb -> msb.
+	pub fn checked_get(&self, index: usize) -> Option<Single> {
+		let i = self.len().checked_sub(1)?;
+		let j = i.checked_sub(index)?;
+		self.digits.get(j).cloned()
+	}
+
+	/// A naive setter for limb at `index`. Note that the order is lsb -> msb.
+	///
+	/// #### Panics
+	///
+	/// This panics if index is out of range.
+	pub fn set(&mut self, index: usize, value: Single) {
+		let len = self.digits.len();
+		self.digits[len - 1 - index] = value;
+	}
+
+	/// returns the least significant limb of the number.
+	///
+	/// #### Panics
+	///
+	/// While the constructor of the type prevents this, this can panic if `self` has no digits.
+	pub fn lsb(&self) -> Single {
+		self.digits[self.len() - 1]
+	}
+
+	/// returns the most significant limb of the number.
+	///
+	/// #### Panics
+	///
+	/// While the constructor of the type prevents this, this can panic if `self` has no digits.
+	pub fn msb(&self) -> Single {
+		self.digits[0]
+	}
+
+	/// Strips zeros from the left side (the most significant limbs) of `self`, if any.
+	pub fn lstrip(&mut self) {
+		// by definition, a big-int number should never have leading zero limbs. This function
+		// has the ability to cause this. There is nothing to do if the number already has 1
+		// limb only. call it a day and return.
+		if self.len().is_zero() {
+			return
+		}
+		let index = self.digits.iter().position(|&elem| elem != 0).unwrap_or(self.len() - 1);
+
+		if index > 0 {
+			self.digits = self.digits[index..].to_vec()
+		}
+	}
+
+	/// Zero-pad `self` from left to reach `size` limbs. Will not make any difference if `self`
+	/// is already bigger than `size` limbs.
+	pub fn lpad(&mut self, size: usize) {
+		let n = self.len();
+		if n >= size {
+			return
+		}
+		let pad = size - n;
+		let mut new_digits = (0..pad).map(|_| 0).collect::<Vec<Single>>();
+		new_digits.extend(self.digits.iter());
+		self.digits = new_digits;
+	}
+
+	/// Adds `self` with `other`. self and other do not have to have any particular size. Given
+	/// that the `n = max{size(self), size(other)}`, it will produce a number with `n + 1`
+	/// limbs.
+	///
+	/// This function does not strip the output and returns the original allocated `n + 1`
+	/// limbs. The caller may strip the output if desired.
+	///
+	/// Taken from "The Art of Computer Programming" by D.E. Knuth, vol 2, chapter 4.
+	pub fn add(self, other: &Self) -> Self {
+		let n = self.len().max(other.len());
+		let mut k: Double = 0;
+		let mut w = Self::with_capacity(n + 1);
+
+		for j in 0..n {
+			let u = Double::from(self.checked_get(j).unwrap_or(0));
+			let v = Double::from(other.checked_get(j).unwrap_or(0));
+			let s = u + v + k;
+			// proof: any number % B will fit into `Single`.
+			w.set(j, (s % B) as Single);
+			k = s / B;
+		}
+		// k is always 0 or 1.
+		w.set(n, k as Single);
+		w
+	}
+
+	/// Subtracts `other` from `self`. self and other do not have to have any particular size.
+	/// Given that the `n = max{size(self), size(other)}`, it will produce a number of size `n`.
+	///
+	/// If `other` is bigger than `self`, `Err(B - borrow)` is returned.
+	///
+	/// Taken from "The Art of Computer Programming" by D.E. Knuth, vol 2, chapter 4.
+	pub fn sub(self, other: &Self) -> Result<Self, Self> {
+		let n = self.len().max(other.len());
+		let mut k = 0;
+		let mut w = Self::with_capacity(n);
+		for j in 0..n {
+			let s = {
+				let u = Double::from(self.checked_get(j).unwrap_or(0));
+				let v = Double::from(other.checked_get(j).unwrap_or(0));
+
+				if let Some(v2) = u.checked_sub(v).and_then(|v1| v1.checked_sub(k)) {
+					// no borrow is needed. u - v - k can be computed as-is
+					let t = v2;
+					k = 0;
+
+					t
+				} else {
+					// borrow is needed. Add a `B` to u, before subtracting.
+					// PROOF: addition: `u + B < 2*B`, thus can fit in double.
+					// PROOF: subtraction: if `u - v - k < 0`, then `u + B - v - k < B`.
+					// NOTE: the order of operations is critical to ensure underflow won't happen.
+					let t = u + B - v - k;
+					k = 1;
+
+					t
+				}
+			};
+			w.set(j, s as Single);
+		}
+
+		if k.is_zero() {
+			Ok(w)
+		} else {
+			Err(w)
+		}
+	}
+
+	/// Multiplies n-limb number `self` with m-limb number `other`.
+	///
+	/// The resulting number will always have `n + m` limbs.
+	///
+	/// This function does not strip the output and returns the original allocated `n + m`
+	/// limbs. The caller may strip the output if desired.
+	///
+	/// Taken from "The Art of Computer Programming" by D.E. Knuth, vol 2, chapter 4.
+	pub fn mul(self, other: &Self) -> Self {
+		let n = self.len();
+		let m = other.len();
+		let mut w = Self::with_capacity(m + n);
+
+		for j in 0..n {
+			if self.get(j) == 0 {
+				// Note: `with_capacity` allocates with 0. Explicitly set j + m to zero if
+				// otherwise.
+				continue
+			}
+
+			let mut k = 0;
+			for i in 0..m {
+				// PROOF: (B−1) × (B−1) + (B−1) + (B−1) = B^2 −1 < B^2. addition is safe.
+				let t = mul_single(self.get(j), other.get(i)) +
+					Double::from(w.get(i + j)) +
+					Double::from(k);
+				w.set(i + j, (t % B) as Single);
+				// PROOF: (B^2 - 1) / B < B. conversion is safe.
+				k = (t / B) as Single;
+			}
+			w.set(j + m, k);
+		}
+		w
+	}
+
+	/// Divides `self` by a single limb `other`. This can be used in cases where the original
+	/// division cannot work due to the divisor (`other`) being just one limb.
+	///
+	/// Invariant: `other` cannot be zero.
+	pub fn div_unit(self, mut other: Single) -> Self {
+		other = other.max(1);
+		let n = self.len();
+		let mut out = Self::with_capacity(n);
+		let mut r: Single = 0;
+		// PROOF: (B-1) * B + (B-1) still fits in double
+		let with_r = |x: Single, r: Single| Double::from(r) * B + Double::from(x);
+		for d in (0..n).rev() {
+			let (q, rr) = div_single(with_r(self.get(d), r), other);
+			out.set(d, q as Single);
+			r = rr;
+		}
+		out
+	}
+
+	/// Divides an `n + m` limb self by a `n` limb `other`. The result is a `m + 1` limb
+	/// quotient and a `n` limb remainder, if enabled by passing `true` in `rem` argument, both
+	/// in the form of an option's `Ok`.
+	///
+	/// - requires `other` to be stripped and have no leading zeros.
+	/// - requires `self` to be stripped and have no leading zeros.
+	/// - requires `other` to have at least two limbs.
+	/// - requires `self` to have a greater length compared to `other`.
+	///
+	/// All arguments are examined without being stripped for the above conditions. If any of
+	/// the above fails, `None` is returned.`
+	///
+	/// Taken from "The Art of Computer Programming" by D.E. Knuth, vol 2, chapter 4.
+	pub fn div(self, other: &Self, rem: bool) -> Option<(Self, Self)> {
+		if other.len() <= 1 || other.msb() == 0 || self.msb() == 0 || self.len() <= other.len() {
+			return None
+		}
+		let n = other.len();
+		let m = self.len() - n;
+
+		let mut q = Self::with_capacity(m + 1);
+		let mut r = Self::with_capacity(n);
+
+		// PROOF: 0 <= normalizer_bits < SHIFT 0 <= normalizer < B. all conversions are
+		// safe.
+		let normalizer_bits = other.msb().leading_zeros() as Single;
+		let normalizer = 2_u32.pow(normalizer_bits as u32) as Single;
+
+		// step D1.
+		let mut self_norm = self.mul(&Self::from(normalizer));
+		let mut other_norm = other.clone().mul(&Self::from(normalizer));
+
+		// defensive only; the mul implementation should always create this.
+		self_norm.lpad(n + m + 1);
+		other_norm.lstrip();
+
+		// step D2.
+		for j in (0..=m).rev() {
+			// step D3.0 Find an estimate of q[j], named qhat.
+			let (qhat, rhat) = {
+				// PROOF: this always fits into `Double`. In the context of Single = u8, and
+				// Double = u16, think of 255 * 256 + 255 which is just u16::MAX.
+				let dividend =
+					Double::from(self_norm.get(j + n)) * B + Double::from(self_norm.get(j + n - 1));
+				let divisor = other_norm.get(n - 1);
+				div_single(dividend, divisor)
+			};
+
+			// D3.1 test qhat
+			// replace qhat and rhat with RefCells. This helps share state with the closure
+			let qhat = RefCell::new(qhat);
+			let rhat = RefCell::new(Double::from(rhat));
+
+			let test = || {
+				// decrease qhat if it is bigger than the base (B)
+				let qhat_local = *qhat.borrow();
+				let rhat_local = *rhat.borrow();
+				let predicate_1 = qhat_local >= B;
+				let predicate_2 = {
+					let lhs = qhat_local * Double::from(other_norm.get(n - 2));
+					let rhs = B * rhat_local + Double::from(self_norm.get(j + n - 2));
+					lhs > rhs
+				};
+				if predicate_1 || predicate_2 {
+					*qhat.borrow_mut() -= 1;
+					*rhat.borrow_mut() += Double::from(other_norm.get(n - 1));
+					true
+				} else {
+					false
+				}
+			};
+
+			test();
+			while (*rhat.borrow() as Double) < B {
+				if !test() {
+					break
+				}
+			}
+
+			let qhat = qhat.into_inner();
+			// we don't need rhat anymore. just let it go out of scope when it does.
+
+			// step D4
+			let lhs = Self { digits: (j..=j + n).rev().map(|d| self_norm.get(d)).collect() };
+			let rhs = other_norm.clone().mul(&Self::from(qhat));
+
+			let maybe_sub = lhs.sub(&rhs);
+			let mut negative = false;
+			let sub = match maybe_sub {
+				Ok(t) => t,
+				Err(t) => {
+					negative = true;
+					t
+				},
+			};
+			(j..=j + n).for_each(|d| {
+				self_norm.set(d, sub.get(d - j));
+			});
+
+			// step D5
+			// PROOF: the `test()` specifically decreases qhat until it is below `B`. conversion
+			// is safe.
+			q.set(j, qhat as Single);
+
+			// step D6: add back if negative happened.
+			if negative {
+				q.set(j, q.get(j) - 1);
+				let u = Self { digits: (j..=j + n).rev().map(|d| self_norm.get(d)).collect() };
+				let r = other_norm.clone().add(&u);
+				(j..=j + n).rev().for_each(|d| {
+					self_norm.set(d, r.get(d - j));
+				})
+			}
+		}
+
+		// if requested, calculate remainder.
+		if rem {
+			// undo the normalization.
+			if normalizer_bits > 0 {
+				let s = SHIFT as u32;
+				let nb = normalizer_bits;
+				for d in 0..n - 1 {
+					let v = self_norm.get(d) >> nb | self_norm.get(d + 1).overflowing_shl(s - nb).0;
+					r.set(d, v);
+				}
+				r.set(n - 1, self_norm.get(n - 1) >> normalizer_bits);
+			} else {
+				r = self_norm;
+			}
+		}
+
+		Some((q, r))
+	}
+}
+
+impl sp_std::fmt::Debug for BigUint {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		write!(
+			f,
+			"BigUint {{ {:?} ({:?})}}",
+			self.digits,
+			u128::try_from(self.clone()).unwrap_or(0),
+		)
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl PartialEq for BigUint {
+	fn eq(&self, other: &Self) -> bool {
+		self.cmp(other) == Ordering::Equal
+	}
+}
+
+impl Eq for BigUint {}
+
+impl Ord for BigUint {
+	fn cmp(&self, other: &Self) -> Ordering {
+		let lhs_first = self.digits.iter().position(|&e| e != 0);
+		let rhs_first = other.digits.iter().position(|&e| e != 0);
+
+		match (lhs_first, rhs_first) {
+			// edge cases that should not happen. This basically means that one or both were
+			// zero.
+			(None, None) => Ordering::Equal,
+			(Some(_), None) => Ordering::Greater,
+			(None, Some(_)) => Ordering::Less,
+			(Some(lhs_idx), Some(rhs_idx)) => {
+				let lhs = &self.digits[lhs_idx..];
+				let rhs = &other.digits[rhs_idx..];
+				let len_cmp = lhs.len().cmp(&rhs.len());
+				match len_cmp {
+					Ordering::Equal => lhs.cmp(rhs),
+					_ => len_cmp,
+				}
+			},
+		}
+	}
+}
+
+impl PartialOrd for BigUint {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl ops::Add for BigUint {
+	type Output = Self;
+	fn add(self, rhs: Self) -> Self::Output {
+		self.add(&rhs)
+	}
+}
+
+impl ops::Sub for BigUint {
+	type Output = Self;
+	fn sub(self, rhs: Self) -> Self::Output {
+		self.sub(&rhs).unwrap_or_else(|e| e)
+	}
+}
+
+impl ops::Mul for BigUint {
+	type Output = Self;
+	fn mul(self, rhs: Self) -> Self::Output {
+		self.mul(&rhs)
+	}
+}
+
+impl Zero for BigUint {
+	fn zero() -> Self {
+		Self { digits: vec![Zero::zero()] }
+	}
+
+	fn is_zero(&self) -> bool {
+		self.digits.iter().all(|d| d.is_zero())
+	}
+}
+
+impl One for BigUint {
+	fn one() -> Self {
+		Self { digits: vec![Single::one()] }
+	}
+}
+
+macro_rules! impl_try_from_number_for {
+	($([$type:ty, $len:expr]),+) => {
+		$(
+			impl TryFrom<BigUint> for $type {
+				type Error = &'static str;
+				fn try_from(mut value: BigUint) -> Result<$type, Self::Error> {
+					value.lstrip();
+					let error_message = concat!("cannot fit a number into ", stringify!($type));
+					if value.len() * SHIFT > $len {
+						Err(error_message)
+					} else {
+						let mut acc: $type = Zero::zero();
+						for (i, d) in value.digits.iter().rev().cloned().enumerate() {
+							let d: $type = d.into();
+							acc += d << (SHIFT * i);
+						}
+						Ok(acc)
+					}
+				}
+			}
+		)*
+	};
+}
+// can only be implemented for sizes bigger than two limb.
+impl_try_from_number_for!([u128, 128], [u64, 64]);
+
+macro_rules! impl_from_for_smaller_than_word {
+	($($type:ty),+) => {
+		$(impl From<$type> for BigUint {
+			fn from(a: $type) -> Self {
+				Self { digits: vec! [a.into()] }
+			}
+		})*
+	}
+}
+impl_from_for_smaller_than_word!(u8, u16, u32);
+
+impl From<u64> for BigUint {
+	fn from(a: Double) -> Self {
+		let (ah, al) = split(a);
+		Self { digits: vec![ah, al] }
+	}
+}
+
+impl From<u128> for BigUint {
+	fn from(a: u128) -> Self {
+		crate::helpers_128bit::to_big_uint(a)
+	}
+}
+
+#[cfg(test)]
+pub mod tests {
+	use super::*;
+
+	fn with_limbs(n: usize) -> BigUint {
+		BigUint { digits: vec![1; n] }
+	}
+
+	#[test]
+	fn split_works() {
+		let a = SHIFT / 2;
+		let b = SHIFT * 3 / 2;
+		let num: Double = 1 << a | 1 << b;
+		assert_eq!(num, 0x_0001_0000_0001_0000);
+		assert_eq!(split(num), (1 << a, 1 << a));
+
+		let a = SHIFT / 2 + 4;
+		let b = SHIFT / 2 - 4;
+		let num: Double = 1 << (SHIFT + a) | 1 << b;
+		assert_eq!(num, 0x_0010_0000_0000_1000);
+		assert_eq!(split(num), (1 << a, 1 << b));
+	}
+
+	#[test]
+	fn strip_works() {
+		let mut a = BigUint::from_limbs(&[0, 1, 0]);
+		a.lstrip();
+		assert_eq!(a.digits, vec![1, 0]);
+
+		let mut a = BigUint::from_limbs(&[0, 0, 1]);
+		a.lstrip();
+		assert_eq!(a.digits, vec![1]);
+
+		let mut a = BigUint::from_limbs(&[0, 0]);
+		a.lstrip();
+		assert_eq!(a.digits, vec![0]);
+
+		let mut a = BigUint::from_limbs(&[0, 0, 0]);
+		a.lstrip();
+		assert_eq!(a.digits, vec![0]);
+	}
+
+	#[test]
+	fn lpad_works() {
+		let mut a = BigUint::from_limbs(&[0, 1, 0]);
+		a.lpad(2);
+		assert_eq!(a.digits, vec![0, 1, 0]);
+
+		let mut a = BigUint::from_limbs(&[0, 1, 0]);
+		a.lpad(3);
+		assert_eq!(a.digits, vec![0, 1, 0]);
+
+		let mut a = BigUint::from_limbs(&[0, 1, 0]);
+		a.lpad(4);
+		assert_eq!(a.digits, vec![0, 0, 1, 0]);
+	}
+
+	#[test]
+	fn equality_works() {
+		assert_eq!(BigUint { digits: vec![1, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, true);
+		assert_eq!(BigUint { digits: vec![3, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, false);
+		assert_eq!(BigUint { digits: vec![0, 1, 2, 3] } == BigUint { digits: vec![1, 2, 3] }, true);
+	}
+
+	#[test]
+	fn ordering_works() {
+		assert!(BigUint { digits: vec![0] } < BigUint { digits: vec![1] });
+		assert!(BigUint { digits: vec![0] } == BigUint { digits: vec![0] });
+		assert!(BigUint { digits: vec![] } == BigUint { digits: vec![0] });
+		assert!(BigUint { digits: vec![] } == BigUint { digits: vec![] });
+		assert!(BigUint { digits: vec![] } < BigUint { digits: vec![1] });
+
+		assert!(BigUint { digits: vec![1, 2, 3] } == BigUint { digits: vec![1, 2, 3] });
+		assert!(BigUint { digits: vec![0, 1, 2, 3] } == BigUint { digits: vec![1, 2, 3] });
+
+		assert!(BigUint { digits: vec![1, 2, 4] } > BigUint { digits: vec![1, 2, 3] });
+		assert!(BigUint { digits: vec![0, 1, 2, 4] } > BigUint { digits: vec![1, 2, 3] });
+		assert!(BigUint { digits: vec![1, 2, 1, 0] } > BigUint { digits: vec![1, 2, 3] });
+
+		assert!(BigUint { digits: vec![0, 1, 2, 1] } < BigUint { digits: vec![1, 2, 3] });
+	}
+
+	#[test]
+	fn can_try_build_numbers_from_types() {
+		assert_eq!(u64::try_from(with_limbs(1)).unwrap(), 1);
+		assert_eq!(u64::try_from(with_limbs(2)).unwrap(), u32::MAX as u64 + 2);
+		assert_eq!(u64::try_from(with_limbs(3)).unwrap_err(), "cannot fit a number into u64");
+		assert_eq!(u128::try_from(with_limbs(3)).unwrap(), u32::MAX as u128 + u64::MAX as u128 + 3);
+	}
+
+	#[test]
+	fn zero_works() {
+		assert_eq!(BigUint::zero(), BigUint { digits: vec![0] });
+		assert_eq!(BigUint { digits: vec![0, 1, 0] }.is_zero(), false);
+		assert_eq!(BigUint { digits: vec![0, 0, 0] }.is_zero(), true);
+
+		let a = BigUint::zero();
+		let b = BigUint::zero();
+		let c = a * b;
+		assert_eq!(c.digits, vec![0, 0]);
+	}
+
+	#[test]
+	fn sub_negative_works() {
+		assert_eq!(
+			BigUint::from(10 as Single).sub(&BigUint::from(5 as Single)).unwrap(),
+			BigUint::from(5 as Single)
+		);
+		assert_eq!(
+			BigUint::from(10 as Single).sub(&BigUint::from(10 as Single)).unwrap(),
+			BigUint::from(0 as Single)
+		);
+		assert_eq!(
+			BigUint::from(10 as Single).sub(&BigUint::from(13 as Single)).unwrap_err(),
+			BigUint::from((B - 3) as Single),
+		);
+	}
+
+	#[test]
+	fn mul_always_appends_one_digit() {
+		let a = BigUint::from(10 as Single);
+		let b = BigUint::from(4 as Single);
+		assert_eq!(a.len(), 1);
+		assert_eq!(b.len(), 1);
+
+		let n = a.mul(&b);
+
+		assert_eq!(n.len(), 2);
+		assert_eq!(n.digits, vec![0, 40]);
+	}
+
+	#[test]
+	fn div_conditions_work() {
+		let a = BigUint { digits: vec![2] };
+		let b = BigUint { digits: vec![1, 2] };
+		let c = BigUint { digits: vec![1, 1, 2] };
+		let d = BigUint { digits: vec![0, 2] };
+		let e = BigUint { digits: vec![0, 1, 1, 2] };
+		let f = BigUint { digits: vec![7, 8] };
+
+		assert!(a.clone().div(&b, true).is_none());
+		assert!(c.clone().div(&a, true).is_none());
+		assert!(c.clone().div(&d, true).is_none());
+		assert!(e.clone().div(&a, true).is_none());
+
+		assert!(f.clone().div(&b, true).is_none());
+		assert!(c.clone().div(&b, true).is_some());
+	}
+
+	#[test]
+	fn div_unit_works() {
+		let a = BigUint { digits: vec![100] };
+		let b = BigUint { digits: vec![1, 100] };
+		let c = BigUint { digits: vec![14, 28, 100] };
+
+		assert_eq!(a.clone().div_unit(1), a);
+		assert_eq!(a.clone().div_unit(0), a);
+		assert_eq!(a.clone().div_unit(2), BigUint::from(50 as Single));
+		assert_eq!(a.clone().div_unit(7), BigUint::from(14 as Single));
+
+		assert_eq!(b.clone().div_unit(1), b);
+		assert_eq!(b.clone().div_unit(0), b);
+		assert_eq!(b.clone().div_unit(2), BigUint::from(((B + 100) / 2) as Single));
+		assert_eq!(b.clone().div_unit(7), BigUint::from(((B + 100) / 7) as Single));
+
+		assert_eq!(c.clone().div_unit(1), c);
+		assert_eq!(c.clone().div_unit(0), c);
+		assert_eq!(c.clone().div_unit(2), BigUint { digits: vec![7, 14, 50] });
+		assert_eq!(c.clone().div_unit(7), BigUint { digits: vec![2, 4, 14] });
+	}
+}
diff --git a/substrate/primitives/arithmetic/src/fixed_point.rs b/substrate/primitives/arithmetic/src/fixed_point.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ce14d2957b5e216325a2af02fbb1d68af2b756bb
--- /dev/null
+++ b/substrate/primitives/arithmetic/src/fixed_point.rs
@@ -0,0 +1,2216 @@
+// 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.
+
+//! Decimal Fixed Point implementations for Substrate runtime.
+
+use crate::{
+	helpers_128bit::{multiply_by_rational_with_rounding, sqrt},
+	traits::{
+		Bounded, CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedSub, One,
+		SaturatedConversion, Saturating, UniqueSaturatedInto, Zero,
+	},
+	PerThing, Perbill, Rounding, SignedRounding,
+};
+use codec::{CompactAs, Decode, Encode};
+use sp_std::{
+	fmt::Debug,
+	ops::{self, Add, Div, Mul, Sub},
+	prelude::*,
+};
+
+#[cfg(feature = "serde")]
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::alloc::string::{String, ToString};
+
+/// Integer types that can be used to interact with `FixedPointNumber` implementations.
+pub trait FixedPointOperand:
+	Copy
+	+ Clone
+	+ Bounded
+	+ Zero
+	+ Saturating
+	+ PartialOrd<Self>
+	+ UniqueSaturatedInto<u128>
+	+ TryFrom<u128>
+	+ CheckedNeg
+{
+}
+
+impl<T> FixedPointOperand for T where
+	T: Copy
+		+ Clone
+		+ Bounded
+		+ Zero
+		+ Saturating
+		+ PartialOrd<Self>
+		+ UniqueSaturatedInto<u128>
+		+ TryFrom<u128>
+		+ CheckedNeg
+{
+}
+
+/// Something that implements a decimal fixed point number.
+///
+/// The precision is given by `Self::DIV`, i.e. `1 / DIV` can be represented.
+///
+/// Each type can store numbers from `Self::Inner::min_value() / Self::DIV`
+/// to `Self::Inner::max_value() / Self::DIV`.
+/// This is also referred to as the _accuracy_ of the type in the documentation.
+pub trait FixedPointNumber:
+	Sized
+	+ Copy
+	+ Default
+	+ Debug
+	+ Saturating
+	+ Bounded
+	+ Eq
+	+ PartialEq
+	+ Ord
+	+ PartialOrd
+	+ CheckedSub
+	+ CheckedAdd
+	+ CheckedMul
+	+ CheckedDiv
+	+ Add
+	+ Sub
+	+ Div
+	+ Mul
+	+ Zero
+	+ One
+{
+	/// The underlying data type used for this fixed point number.
+	type Inner: Debug + One + CheckedMul + CheckedDiv + FixedPointOperand;
+
+	/// Precision of this fixed point implementation. It should be a power of `10`.
+	const DIV: Self::Inner;
+
+	/// Indicates if this fixed point implementation is signed or not.
+	const SIGNED: bool;
+
+	/// Precision of this fixed point implementation.
+	fn accuracy() -> Self::Inner {
+		Self::DIV
+	}
+
+	/// Builds this type from an integer number.
+	fn from_inner(int: Self::Inner) -> Self;
+
+	/// Consumes `self` and returns the inner raw value.
+	fn into_inner(self) -> Self::Inner;
+
+	/// Creates self from an integer number `int`.
+	///
+	/// Returns `Self::max` or `Self::min` if `int` exceeds accuracy.
+	fn saturating_from_integer<N: FixedPointOperand>(int: N) -> Self {
+		let mut n: I129 = int.into();
+		n.value = n.value.saturating_mul(Self::DIV.saturated_into());
+		Self::from_inner(from_i129(n).unwrap_or_else(|| to_bound(int, 0)))
+	}
+
+	/// Creates `self` from an integer number `int`.
+	///
+	/// Returns `None` if `int` exceeds accuracy.
+	fn checked_from_integer<N: Into<Self::Inner>>(int: N) -> Option<Self> {
+		let int: Self::Inner = int.into();
+		int.checked_mul(&Self::DIV).map(Self::from_inner)
+	}
+
+	/// Creates `self` from a rational number. Equal to `n / d`.
+	///
+	/// Panics if `d = 0`. Returns `Self::max` or `Self::min` if `n / d` exceeds accuracy.
+	fn saturating_from_rational<N: FixedPointOperand, D: FixedPointOperand>(n: N, d: D) -> Self {
+		if d == D::zero() {
+			panic!("attempt to divide by zero")
+		}
+		Self::checked_from_rational(n, d).unwrap_or_else(|| to_bound(n, d))
+	}
+
+	/// Creates `self` from a rational number. Equal to `n / d`.
+	///
+	/// Returns `None` if `d == 0` or `n / d` exceeds accuracy.
+	fn checked_from_rational<N: FixedPointOperand, D: FixedPointOperand>(
+		n: N,
+		d: D,
+	) -> Option<Self> {
+		if d == D::zero() {
+			return None
+		}
+
+		let n: I129 = n.into();
+		let d: I129 = d.into();
+		let negative = n.negative != d.negative;
+
+		multiply_by_rational_with_rounding(
+			n.value,
+			Self::DIV.unique_saturated_into(),
+			d.value,
+			Rounding::from_signed(SignedRounding::Minor, negative),
+		)
+		.and_then(|value| from_i129(I129 { value, negative }))
+		.map(Self::from_inner)
+	}
+
+	/// Checked multiplication for integer type `N`. Equal to `self * n`.
+	///
+	/// Returns `None` if the result does not fit in `N`.
+	fn checked_mul_int<N: FixedPointOperand>(self, n: N) -> Option<N> {
+		let lhs: I129 = self.into_inner().into();
+		let rhs: I129 = n.into();
+		let negative = lhs.negative != rhs.negative;
+
+		multiply_by_rational_with_rounding(
+			lhs.value,
+			rhs.value,
+			Self::DIV.unique_saturated_into(),
+			Rounding::from_signed(SignedRounding::Minor, negative),
+		)
+		.and_then(|value| from_i129(I129 { value, negative }))
+	}
+
+	/// Saturating multiplication for integer type `N`. Equal to `self * n`.
+	///
+	/// Returns `N::min` or `N::max` if the result does not fit in `N`.
+	fn saturating_mul_int<N: FixedPointOperand>(self, n: N) -> N {
+		self.checked_mul_int(n).unwrap_or_else(|| to_bound(self.into_inner(), n))
+	}
+
+	/// Checked division for integer type `N`. Equal to `self / d`.
+	///
+	/// Returns `None` if the result does not fit in `N` or `d == 0`.
+	fn checked_div_int<N: FixedPointOperand>(self, d: N) -> Option<N> {
+		let lhs: I129 = self.into_inner().into();
+		let rhs: I129 = d.into();
+		let negative = lhs.negative != rhs.negative;
+
+		lhs.value
+			.checked_div(rhs.value)
+			.and_then(|n| n.checked_div(Self::DIV.unique_saturated_into()))
+			.and_then(|value| from_i129(I129 { value, negative }))
+	}
+
+	/// Saturating division for integer type `N`. Equal to `self / d`.
+	///
+	/// Panics if `d == 0`. Returns `N::min` or `N::max` if the result does not fit in `N`.
+	fn saturating_div_int<N: FixedPointOperand>(self, d: N) -> N {
+		if d == N::zero() {
+			panic!("attempt to divide by zero")
+		}
+		self.checked_div_int(d).unwrap_or_else(|| to_bound(self.into_inner(), d))
+	}
+
+	/// Saturating multiplication for integer type `N`, adding the result back.
+	/// Equal to `self * n + n`.
+	///
+	/// Returns `N::min` or `N::max` if the multiplication or final result does not fit in `N`.
+	fn saturating_mul_acc_int<N: FixedPointOperand>(self, n: N) -> N {
+		if self.is_negative() && n > N::zero() {
+			n.saturating_sub(Self::zero().saturating_sub(self).saturating_mul_int(n))
+		} else {
+			self.saturating_mul_int(n).saturating_add(n)
+		}
+	}
+
+	/// Saturating absolute value.
+	///
+	/// Returns `Self::max` if `self == Self::min`.
+	fn saturating_abs(self) -> Self {
+		let inner = self.into_inner();
+		if inner >= Self::Inner::zero() {
+			self
+		} else {
+			Self::from_inner(inner.checked_neg().unwrap_or_else(Self::Inner::max_value))
+		}
+	}
+
+	/// Takes the reciprocal (inverse). Equal to `1 / self`.
+	///
+	/// Returns `None` if `self = 0`.
+	fn reciprocal(self) -> Option<Self> {
+		Self::one().checked_div(&self)
+	}
+
+	/// Checks if the number is one.
+	fn is_one(&self) -> bool {
+		self.into_inner() == Self::Inner::one()
+	}
+
+	/// Returns `true` if `self` is positive and `false` if the number is zero or negative.
+	fn is_positive(self) -> bool {
+		self.into_inner() > Self::Inner::zero()
+	}
+
+	/// Returns `true` if `self` is negative and `false` if the number is zero or positive.
+	fn is_negative(self) -> bool {
+		self.into_inner() < Self::Inner::zero()
+	}
+
+	/// Returns the integer part.
+	fn trunc(self) -> Self {
+		self.into_inner()
+			.checked_div(&Self::DIV)
+			.expect("panics only if DIV is zero, DIV is not zero; qed")
+			.checked_mul(&Self::DIV)
+			.map(Self::from_inner)
+			.expect("can not overflow since fixed number is >= integer part")
+	}
+
+	/// Returns the fractional part.
+	///
+	/// Note: the returned fraction will be non-negative for negative numbers,
+	/// except in the case where the integer part is zero.
+	fn frac(self) -> Self {
+		let integer = self.trunc();
+		let fractional = self.saturating_sub(integer);
+		if integer == Self::zero() {
+			fractional
+		} else {
+			fractional.saturating_abs()
+		}
+	}
+
+	/// Returns the smallest integer greater than or equal to a number.
+	///
+	/// Saturates to `Self::max` (truncated) if the result does not fit.
+	fn ceil(self) -> Self {
+		if self.is_negative() {
+			self.trunc()
+		} else if self.frac() == Self::zero() {
+			self
+		} else {
+			self.saturating_add(Self::one()).trunc()
+		}
+	}
+
+	/// Returns the largest integer less than or equal to a number.
+	///
+	/// Saturates to `Self::min` (truncated) if the result does not fit.
+	fn floor(self) -> Self {
+		if self.is_negative() {
+			self.saturating_sub(Self::one()).trunc()
+		} else {
+			self.trunc()
+		}
+	}
+
+	/// Returns the number rounded to the nearest integer. Rounds half-way cases away from 0.0.
+	///
+	/// Saturates to `Self::min` or `Self::max` (truncated) if the result does not fit.
+	fn round(self) -> Self {
+		let n = self.frac().saturating_mul(Self::saturating_from_integer(10));
+		if n < Self::saturating_from_integer(5) {
+			self.trunc()
+		} else if self.is_positive() {
+			self.saturating_add(Self::one()).trunc()
+		} else {
+			self.saturating_sub(Self::one()).trunc()
+		}
+	}
+}
+
+/// Data type used as intermediate storage in some computations to avoid overflow.
+struct I129 {
+	value: u128,
+	negative: bool,
+}
+
+impl<N: FixedPointOperand> From<N> for I129 {
+	fn from(n: N) -> I129 {
+		if n < N::zero() {
+			let value: u128 = n
+				.checked_neg()
+				.map(|n| n.unique_saturated_into())
+				.unwrap_or_else(|| N::max_value().unique_saturated_into().saturating_add(1));
+			I129 { value, negative: true }
+		} else {
+			I129 { value: n.unique_saturated_into(), negative: false }
+		}
+	}
+}
+
+/// Transforms an `I129` to `N` if it is possible.
+fn from_i129<N: FixedPointOperand>(n: I129) -> Option<N> {
+	let max_plus_one: u128 = N::max_value().unique_saturated_into().saturating_add(1);
+	if n.negative && N::min_value() < N::zero() && n.value == max_plus_one {
+		Some(N::min_value())
+	} else {
+		let unsigned_inner: N = n.value.try_into().ok()?;
+		let inner = if n.negative { unsigned_inner.checked_neg()? } else { unsigned_inner };
+		Some(inner)
+	}
+}
+
+/// Returns `R::max` if the sign of `n * m` is positive, `R::min` otherwise.
+fn to_bound<N: FixedPointOperand, D: FixedPointOperand, R: Bounded>(n: N, m: D) -> R {
+	if (n < N::zero()) != (m < D::zero()) {
+		R::min_value()
+	} else {
+		R::max_value()
+	}
+}
+
+macro_rules! implement_fixed {
+	(
+		$name:ident,
+		$test_mod:ident,
+		$inner_type:ty,
+		$signed:tt,
+		$div:tt,
+		$title:expr $(,)?
+	) => {
+		/// A fixed point number representation in the range.
+		#[doc = $title]
+		#[derive(
+			Encode,
+			Decode,
+			CompactAs,
+			Default,
+			Copy,
+			Clone,
+			codec::MaxEncodedLen,
+			PartialEq,
+			Eq,
+			PartialOrd,
+			Ord,
+			scale_info::TypeInfo,
+		)]
+		pub struct $name($inner_type);
+
+		impl From<$inner_type> for $name {
+			fn from(int: $inner_type) -> Self {
+				$name::saturating_from_integer(int)
+			}
+		}
+
+		impl<N: FixedPointOperand, D: FixedPointOperand> From<(N, D)> for $name {
+			fn from(r: (N, D)) -> Self {
+				$name::saturating_from_rational(r.0, r.1)
+			}
+		}
+
+		impl FixedPointNumber for $name {
+			type Inner = $inner_type;
+
+			const DIV: Self::Inner = $div;
+			const SIGNED: bool = $signed;
+
+			fn from_inner(inner: Self::Inner) -> Self {
+				Self(inner)
+			}
+
+			fn into_inner(self) -> Self::Inner {
+				self.0
+			}
+		}
+
+		impl $name {
+			/// Create a new instance from the given `inner` value.
+			///
+			/// `const` version of `FixedPointNumber::from_inner`.
+			pub const fn from_inner(inner: $inner_type) -> Self {
+				Self(inner)
+			}
+
+			/// Return the instance's inner value.
+			///
+			/// `const` version of `FixedPointNumber::into_inner`.
+			pub const fn into_inner(self) -> $inner_type {
+				self.0
+			}
+
+			/// Creates self from a `u32`.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn from_u32(n: u32) -> Self {
+				Self::from_inner((n as $inner_type) * $div)
+			}
+
+			/// Convert from a `float` value.
+			#[cfg(any(feature = "std", test))]
+			pub fn from_float(x: f64) -> Self {
+				Self((x * (<Self as FixedPointNumber>::DIV as f64)) as $inner_type)
+			}
+
+			/// Convert from a `Perbill` value.
+			pub const fn from_perbill(n: Perbill) -> Self {
+				Self::from_rational(n.deconstruct() as u128, 1_000_000_000)
+			}
+
+			/// Convert into a `Perbill` value. Will saturate if above one or below zero.
+			pub const fn into_perbill(self) -> Perbill {
+				if self.0 <= 0 {
+					Perbill::zero()
+				} else if self.0 >= $div {
+					Perbill::one()
+				} else {
+					match multiply_by_rational_with_rounding(
+						self.0 as u128,
+						1_000_000_000,
+						Self::DIV as u128,
+						Rounding::NearestPrefDown,
+					) {
+						Some(value) => {
+							if value > (u32::max_value() as u128) {
+								panic!(
+									"prior logic ensures 0<self.0<DIV; \
+									multiply ensures 0<self.0<1000000000; \
+									qed"
+								);
+							}
+							Perbill::from_parts(value as u32)
+						},
+						None => Perbill::zero(),
+					}
+				}
+			}
+
+			/// Convert into a `float` value.
+			#[cfg(any(feature = "std", test))]
+			pub fn to_float(self) -> f64 {
+				self.0 as f64 / <Self as FixedPointNumber>::DIV as f64
+			}
+
+			/// Attempt to convert into a `PerThing`. This will succeed iff `self` is at least zero
+			/// and at most one. If it is out of bounds, it will result in an error returning the
+			/// clamped value.
+			pub fn try_into_perthing<P: PerThing>(self) -> Result<P, P> {
+				if self < Self::zero() {
+					Err(P::zero())
+				} else if self > Self::one() {
+					Err(P::one())
+				} else {
+					Ok(P::from_rational(self.0 as u128, $div))
+				}
+			}
+
+			/// Attempt to convert into a `PerThing`. This will always succeed resulting in a
+			/// clamped value if `self` is less than zero or greater than one.
+			pub fn into_clamped_perthing<P: PerThing>(self) -> P {
+				if self < Self::zero() {
+					P::zero()
+				} else if self > Self::one() {
+					P::one()
+				} else {
+					P::from_rational(self.0 as u128, $div)
+				}
+			}
+
+			/// Negate the value.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn neg(self) -> Self {
+				Self(0 - self.0)
+			}
+
+			/// Take the square root of a positive value.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn sqrt(self) -> Self {
+				match self.try_sqrt() {
+					Some(v) => v,
+					None => panic!("sqrt overflow or negative input"),
+				}
+			}
+
+			/// Compute the square root, rounding as desired. If it overflows or is negative, then
+			/// `None` is returned.
+			pub const fn try_sqrt(self) -> Option<Self> {
+				if self.0 == 0 {
+					return Some(Self(0))
+				}
+				if self.0 < 1 {
+					return None
+				}
+				let v = self.0 as u128;
+
+				// Want x' = sqrt(x) where x = n/D and x' = n'/D (D is fixed)
+				// Our prefered way is:
+				//   sqrt(n/D) = sqrt(nD / D^2) = sqrt(nD)/sqrt(D^2) = sqrt(nD)/D
+				//   ergo n' = sqrt(nD)
+				// but this requires nD to fit into our type.
+				// if nD doesn't fit then we can fall back on:
+				//   sqrt(nD) = sqrt(n)*sqrt(D)
+				// computing them individually and taking the product at the end. we will lose some
+				// precision though.
+				let maybe_vd = u128::checked_mul(v, $div);
+				let r = if let Some(vd) = maybe_vd { sqrt(vd) } else { sqrt(v) * sqrt($div) };
+				Some(Self(r as $inner_type))
+			}
+
+			/// Add a value and return the result.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn add(self, rhs: Self) -> Self {
+				Self(self.0 + rhs.0)
+			}
+
+			/// Subtract a value and return the result.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn sub(self, rhs: Self) -> Self {
+				Self(self.0 - rhs.0)
+			}
+
+			/// Multiply by a value and return the result.
+			///
+			/// Result will be rounded to the nearest representable value, rounding down if it is
+			/// equidistant between two neighbours.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn mul(self, rhs: Self) -> Self {
+				match $name::const_checked_mul(self, rhs) {
+					Some(v) => v,
+					None => panic!("attempt to multiply with overflow"),
+				}
+			}
+
+			/// Divide by a value and return the result.
+			///
+			/// Result will be rounded to the nearest representable value, rounding down if it is
+			/// equidistant between two neighbours.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn div(self, rhs: Self) -> Self {
+				match $name::const_checked_div(self, rhs) {
+					Some(v) => v,
+					None => panic!("attempt to divide with overflow or NaN"),
+				}
+			}
+
+			/// Convert into an `I129` format value.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			const fn into_i129(self) -> I129 {
+				#[allow(unused_comparisons)]
+				if self.0 < 0 {
+					let value = match self.0.checked_neg() {
+						Some(n) => n as u128,
+						None => u128::saturating_add(<$inner_type>::max_value() as u128, 1),
+					};
+					I129 { value, negative: true }
+				} else {
+					I129 { value: self.0 as u128, negative: false }
+				}
+			}
+
+			/// Convert from an `I129` format value.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			const fn from_i129(n: I129) -> Option<Self> {
+				let max_plus_one = u128::saturating_add(<$inner_type>::max_value() as u128, 1);
+				#[allow(unused_comparisons)]
+				let inner = if n.negative && <$inner_type>::min_value() < 0 && n.value == max_plus_one {
+					<$inner_type>::min_value()
+				} else {
+					let unsigned_inner = n.value as $inner_type;
+					if unsigned_inner as u128 != n.value || (unsigned_inner > 0) != (n.value > 0) {
+						return None
+					};
+					if n.negative {
+						match unsigned_inner.checked_neg() {
+							Some(v) => v,
+							None => return None,
+						}
+					} else {
+						unsigned_inner
+					}
+				};
+				Some(Self(inner))
+			}
+
+			/// Calculate an approximation of a rational.
+			///
+			/// Result will be rounded to the nearest representable value, rounding down if it is
+			/// equidistant between two neighbours.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn from_rational(a: u128, b: u128) -> Self {
+				Self::from_rational_with_rounding(a, b, Rounding::NearestPrefDown)
+			}
+
+			/// Calculate an approximation of a rational with custom rounding.
+			///
+			/// WARNING: This is a `const` function designed for convenient use at build time and
+			/// will panic on overflow. Ensure that any inputs are sensible.
+			pub const fn from_rational_with_rounding(a: u128, b: u128, rounding: Rounding) -> Self {
+				if b == 0 {
+					panic!("attempt to divide by zero in from_rational")
+				}
+				match multiply_by_rational_with_rounding(Self::DIV as u128, a, b, rounding) {
+					Some(value) => match Self::from_i129(I129 { value, negative: false }) {
+						Some(x) => x,
+						None => panic!("overflow in from_rational"),
+					},
+					None => panic!("overflow in from_rational"),
+				}
+			}
+
+			/// Multiply by another value, returning `None` in the case of an error.
+			///
+			/// Result will be rounded to the nearest representable value, rounding down if it is
+			/// equidistant between two neighbours.
+			pub const fn const_checked_mul(self, other: Self) -> Option<Self> {
+				self.const_checked_mul_with_rounding(other, SignedRounding::NearestPrefLow)
+			}
+
+			/// Multiply by another value with custom rounding, returning `None` in the case of an
+			/// error.
+			///
+			/// Result will be rounded to the nearest representable value, rounding down if it is
+			/// equidistant between two neighbours.
+			pub const fn const_checked_mul_with_rounding(
+				self,
+				other: Self,
+				rounding: SignedRounding,
+			) -> Option<Self> {
+				let lhs = self.into_i129();
+				let rhs = other.into_i129();
+				let negative = lhs.negative != rhs.negative;
+
+				match multiply_by_rational_with_rounding(
+					lhs.value,
+					rhs.value,
+					Self::DIV as u128,
+					Rounding::from_signed(rounding, negative),
+				) {
+					Some(value) => Self::from_i129(I129 { value, negative }),
+					None => None,
+				}
+			}
+
+			/// Divide by another value, returning `None` in the case of an error.
+			///
+			/// Result will be rounded to the nearest representable value, rounding down if it is
+			/// equidistant between two neighbours.
+			pub const fn const_checked_div(self, other: Self) -> Option<Self> {
+				self.checked_rounding_div(other, SignedRounding::NearestPrefLow)
+			}
+
+			/// Divide by another value with custom rounding, returning `None` in the case of an
+			/// error.
+			///
+			/// Result will be rounded to the nearest representable value, rounding down if it is
+			/// equidistant between two neighbours.
+			pub const fn checked_rounding_div(
+				self,
+				other: Self,
+				rounding: SignedRounding,
+			) -> Option<Self> {
+				if other.0 == 0 {
+					return None
+				}
+
+				let lhs = self.into_i129();
+				let rhs = other.into_i129();
+				let negative = lhs.negative != rhs.negative;
+
+				match multiply_by_rational_with_rounding(
+					lhs.value,
+					Self::DIV as u128,
+					rhs.value,
+					Rounding::from_signed(rounding, negative),
+				) {
+					Some(value) => Self::from_i129(I129 { value, negative }),
+					None => None,
+				}
+			}
+		}
+
+		impl Saturating for $name {
+			fn saturating_add(self, rhs: Self) -> Self {
+				Self(self.0.saturating_add(rhs.0))
+			}
+
+			fn saturating_sub(self, rhs: Self) -> Self {
+				Self(self.0.saturating_sub(rhs.0))
+			}
+
+			fn saturating_mul(self, rhs: Self) -> Self {
+				self.checked_mul(&rhs).unwrap_or_else(|| to_bound(self.0, rhs.0))
+			}
+
+			fn saturating_pow(self, exp: usize) -> Self {
+				if exp == 0 {
+					return Self::saturating_from_integer(1)
+				}
+
+				let exp = exp as u32;
+				let msb_pos = 32 - exp.leading_zeros();
+
+				let mut result = Self::saturating_from_integer(1);
+				let mut pow_val = self;
+				for i in 0..msb_pos {
+					if ((1 << i) & exp) > 0 {
+						result = result.saturating_mul(pow_val);
+					}
+					pow_val = pow_val.saturating_mul(pow_val);
+				}
+				result
+			}
+		}
+
+		impl ops::Neg for $name {
+			type Output = Self;
+
+			fn neg(self) -> Self::Output {
+				Self(<Self as FixedPointNumber>::Inner::zero() - self.0)
+			}
+		}
+
+		impl ops::Add for $name {
+			type Output = Self;
+
+			fn add(self, rhs: Self) -> Self::Output {
+				Self(self.0 + rhs.0)
+			}
+		}
+
+		impl ops::Sub for $name {
+			type Output = Self;
+
+			fn sub(self, rhs: Self) -> Self::Output {
+				Self(self.0 - rhs.0)
+			}
+		}
+
+		impl ops::Mul for $name {
+			type Output = Self;
+
+			fn mul(self, rhs: Self) -> Self::Output {
+				self.checked_mul(&rhs)
+					.unwrap_or_else(|| panic!("attempt to multiply with overflow"))
+			}
+		}
+
+		impl ops::Div for $name {
+			type Output = Self;
+
+			fn div(self, rhs: Self) -> Self::Output {
+				if rhs.0 == 0 {
+					panic!("attempt to divide by zero")
+				}
+				self.checked_div(&rhs)
+					.unwrap_or_else(|| panic!("attempt to divide with overflow"))
+			}
+		}
+
+		impl CheckedSub for $name {
+			fn checked_sub(&self, rhs: &Self) -> Option<Self> {
+				self.0.checked_sub(rhs.0).map(Self)
+			}
+		}
+
+		impl CheckedAdd for $name {
+			fn checked_add(&self, rhs: &Self) -> Option<Self> {
+				self.0.checked_add(rhs.0).map(Self)
+			}
+		}
+
+		impl CheckedDiv for $name {
+			fn checked_div(&self, other: &Self) -> Option<Self> {
+				if other.0 == 0 {
+					return None
+				}
+
+				let lhs: I129 = self.0.into();
+				let rhs: I129 = other.0.into();
+				let negative = lhs.negative != rhs.negative;
+
+				// Note that this uses the old (well-tested) code with sign-ignorant rounding. This
+				// is equivalent to the `SignedRounding::NearestPrefMinor`. This means it is
+				// expected to give exactly the same result as `const_checked_div` when the result
+				// is positive and a result up to one epsilon greater when it is negative.
+				multiply_by_rational_with_rounding(
+					lhs.value,
+					Self::DIV as u128,
+					rhs.value,
+					Rounding::from_signed(SignedRounding::Minor, negative),
+				)
+				.and_then(|value| from_i129(I129 { value, negative }))
+				.map(Self)
+			}
+		}
+
+		impl CheckedMul for $name {
+			fn checked_mul(&self, other: &Self) -> Option<Self> {
+				let lhs: I129 = self.0.into();
+				let rhs: I129 = other.0.into();
+				let negative = lhs.negative != rhs.negative;
+
+				multiply_by_rational_with_rounding(
+					lhs.value,
+					rhs.value,
+					Self::DIV as u128,
+					Rounding::from_signed(SignedRounding::Minor, negative),
+				)
+				.and_then(|value| from_i129(I129 { value, negative }))
+				.map(Self)
+			}
+		}
+
+		impl Bounded for $name {
+			fn min_value() -> Self {
+				Self(<Self as FixedPointNumber>::Inner::min_value())
+			}
+
+			fn max_value() -> Self {
+				Self(<Self as FixedPointNumber>::Inner::max_value())
+			}
+		}
+
+		impl Zero for $name {
+			fn zero() -> Self {
+				Self::from_inner(<Self as FixedPointNumber>::Inner::zero())
+			}
+
+			fn is_zero(&self) -> bool {
+				self.into_inner() == <Self as FixedPointNumber>::Inner::zero()
+			}
+		}
+
+		impl One for $name {
+			fn one() -> Self {
+				Self::from_inner(Self::DIV)
+			}
+		}
+
+		impl sp_std::fmt::Debug for $name {
+			#[cfg(feature = "std")]
+			fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+				let integral = {
+					let int = self.0 / Self::accuracy();
+					let signum_for_zero = if int == 0 && self.is_negative() { "-" } else { "" };
+					format!("{}{}", signum_for_zero, int)
+				};
+				let precision = (Self::accuracy() as f64).log10() as usize;
+				let fractional = format!(
+					"{:0>weight$}",
+					((self.0 % Self::accuracy()) as i128).abs(),
+					weight = precision
+				);
+				write!(f, "{}({}.{})", stringify!($name), integral, fractional)
+			}
+
+			#[cfg(not(feature = "std"))]
+			fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+				Ok(())
+			}
+		}
+
+		impl<P: PerThing> From<P> for $name
+		where
+			P::Inner: FixedPointOperand,
+		{
+			fn from(p: P) -> Self {
+				let accuracy = P::ACCURACY;
+				let value = p.deconstruct();
+				$name::saturating_from_rational(value, accuracy)
+			}
+		}
+
+		impl sp_std::fmt::Display for $name {
+			fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+				write!(f, "{}", self.0)
+			}
+		}
+
+		impl sp_std::str::FromStr for $name {
+			type Err = &'static str;
+
+			fn from_str(s: &str) -> Result<Self, Self::Err> {
+				let inner: <Self as FixedPointNumber>::Inner =
+					s.parse().map_err(|_| "invalid string input for fixed point number")?;
+				Ok(Self::from_inner(inner))
+			}
+		}
+
+		// Manual impl `Serialize` as serde_json does not support i128.
+		// TODO: remove impl if issue https://github.com/serde-rs/json/issues/548 fixed.
+		#[cfg(feature = "serde")]
+		impl Serialize for $name {
+			fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+			where
+				S: Serializer,
+			{
+				serializer.serialize_str(&self.to_string())
+			}
+		}
+
+		// Manual impl `Deserialize` as serde_json does not support i128.
+		// TODO: remove impl if issue https://github.com/serde-rs/json/issues/548 fixed.
+		#[cfg(feature = "serde")]
+		impl<'de> Deserialize<'de> for $name {
+			fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+			where
+				D: Deserializer<'de>,
+			{
+				use sp_std::str::FromStr;
+				let s = String::deserialize(deserializer)?;
+				$name::from_str(&s).map_err(de::Error::custom)
+			}
+		}
+
+		#[cfg(test)]
+		mod $test_mod {
+			use super::*;
+			use crate::{Perbill, Percent, Permill, Perquintill};
+
+			fn max() -> $name {
+				$name::max_value()
+			}
+
+			fn min() -> $name {
+				$name::min_value()
+			}
+
+			fn precision() -> usize {
+				($name::accuracy() as f64).log10() as usize
+			}
+
+			#[test]
+			fn macro_preconditions() {
+				assert!($name::DIV > 0);
+			}
+
+			#[test]
+			fn has_max_encoded_len() {
+				struct AsMaxEncodedLen<T: codec::MaxEncodedLen> {
+					_data: T,
+				}
+
+				let _ = AsMaxEncodedLen { _data: $name::min_value() };
+			}
+
+			#[test]
+			fn from_i129_works() {
+				let a = I129 { value: 1, negative: true };
+
+				// Can't convert negative number to unsigned.
+				assert_eq!(from_i129::<u128>(a), None);
+
+				let a = I129 { value: u128::MAX - 1, negative: false };
+
+				// Max - 1 value fits.
+				assert_eq!(from_i129::<u128>(a), Some(u128::MAX - 1));
+
+				let a = I129 { value: u128::MAX, negative: false };
+
+				// Max value fits.
+				assert_eq!(from_i129::<u128>(a), Some(u128::MAX));
+
+				let a = I129 { value: i128::MAX as u128 + 1, negative: true };
+
+				// Min value fits.
+				assert_eq!(from_i129::<i128>(a), Some(i128::MIN));
+
+				let a = I129 { value: i128::MAX as u128 + 1, negative: false };
+
+				// Max + 1 does not fit.
+				assert_eq!(from_i129::<i128>(a), None);
+
+				let a = I129 { value: i128::MAX as u128, negative: false };
+
+				// Max value fits.
+				assert_eq!(from_i129::<i128>(a), Some(i128::MAX));
+			}
+
+			#[test]
+			fn to_bound_works() {
+				let a = 1i32;
+				let b = 1i32;
+
+				// Pos + Pos => Max.
+				assert_eq!(to_bound::<_, _, i32>(a, b), i32::MAX);
+
+				let a = -1i32;
+				let b = -1i32;
+
+				// Neg + Neg => Max.
+				assert_eq!(to_bound::<_, _, i32>(a, b), i32::MAX);
+
+				let a = 1i32;
+				let b = -1i32;
+
+				// Pos + Neg => Min.
+				assert_eq!(to_bound::<_, _, i32>(a, b), i32::MIN);
+
+				let a = -1i32;
+				let b = 1i32;
+
+				// Neg + Pos => Min.
+				assert_eq!(to_bound::<_, _, i32>(a, b), i32::MIN);
+
+				let a = 1i32;
+				let b = -1i32;
+
+				// Pos + Neg => Min (unsigned).
+				assert_eq!(to_bound::<_, _, u32>(a, b), 0);
+			}
+
+			#[test]
+			fn op_neg_works() {
+				let a = $name::zero();
+				let b = -a;
+
+				// Zero.
+				assert_eq!(a, b);
+
+				if $name::SIGNED {
+					let a = $name::saturating_from_integer(5);
+					let b = -a;
+
+					// Positive.
+					assert_eq!($name::saturating_from_integer(-5), b);
+
+					let a = $name::saturating_from_integer(-5);
+					let b = -a;
+
+					// Negative
+					assert_eq!($name::saturating_from_integer(5), b);
+
+					let a = $name::max_value();
+					let b = -a;
+
+					// Max.
+					assert_eq!($name::min_value() + $name::from_inner(1), b);
+
+					let a = $name::min_value() + $name::from_inner(1);
+					let b = -a;
+
+					// Min.
+					assert_eq!($name::max_value(), b);
+				}
+			}
+
+			#[test]
+			fn op_checked_add_overflow_works() {
+				let a = $name::max_value();
+				let b = 1.into();
+				assert!(a.checked_add(&b).is_none());
+			}
+
+			#[test]
+			fn op_add_works() {
+				let a = $name::saturating_from_rational(5, 2);
+				let b = $name::saturating_from_rational(1, 2);
+
+				// Positive case: 6/2 = 3.
+				assert_eq!($name::saturating_from_integer(3), a + b);
+
+				if $name::SIGNED {
+					// Negative case: 4/2 = 2.
+					let b = $name::saturating_from_rational(1, -2);
+					assert_eq!($name::saturating_from_integer(2), a + b);
+				}
+			}
+
+			#[test]
+			fn op_checked_sub_underflow_works() {
+				let a = $name::min_value();
+				let b = 1.into();
+				assert!(a.checked_sub(&b).is_none());
+			}
+
+			#[test]
+			fn op_sub_works() {
+				let a = $name::saturating_from_rational(5, 2);
+				let b = $name::saturating_from_rational(1, 2);
+
+				assert_eq!($name::saturating_from_integer(2), a - b);
+				assert_eq!($name::saturating_from_integer(-2), b.saturating_sub(a));
+			}
+
+			#[test]
+			fn op_checked_mul_overflow_works() {
+				let a = $name::max_value();
+				let b = 2.into();
+				assert!(a.checked_mul(&b).is_none());
+			}
+
+			#[test]
+			fn op_mul_works() {
+				let a = $name::saturating_from_integer(42);
+				let b = $name::saturating_from_integer(2);
+				assert_eq!($name::saturating_from_integer(84), a * b);
+
+				let a = $name::saturating_from_integer(42);
+				let b = $name::saturating_from_integer(-2);
+				assert_eq!($name::saturating_from_integer(-84), a * b);
+			}
+
+			#[test]
+			#[should_panic(expected = "attempt to divide by zero")]
+			fn op_div_panics_on_zero_divisor() {
+				let a = $name::saturating_from_integer(1);
+				let b = 0.into();
+				let _c = a / b;
+			}
+
+			#[test]
+			fn op_checked_div_overflow_works() {
+				if $name::SIGNED {
+					let a = $name::min_value();
+					let b = $name::zero().saturating_sub($name::one());
+					assert!(a.checked_div(&b).is_none());
+				}
+			}
+
+			#[test]
+			fn op_sqrt_works() {
+				for i in 1..1_000i64 {
+					let x = $name::saturating_from_rational(i, 1_000i64);
+					assert_eq!((x * x).try_sqrt(), Some(x));
+					let x = $name::saturating_from_rational(i, 1i64);
+					assert_eq!((x * x).try_sqrt(), Some(x));
+				}
+			}
+
+			#[test]
+			fn op_div_works() {
+				let a = $name::saturating_from_integer(42);
+				let b = $name::saturating_from_integer(2);
+				assert_eq!($name::saturating_from_integer(21), a / b);
+
+				if $name::SIGNED {
+					let a = $name::saturating_from_integer(42);
+					let b = $name::saturating_from_integer(-2);
+					assert_eq!($name::saturating_from_integer(-21), a / b);
+				}
+			}
+
+			#[test]
+			fn saturating_from_integer_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+				let accuracy = $name::accuracy();
+
+				// Cases where integer fits.
+				let a = $name::saturating_from_integer(42);
+				assert_eq!(a.into_inner(), 42 * accuracy);
+
+				let a = $name::saturating_from_integer(-42);
+				assert_eq!(a.into_inner(), 0.saturating_sub(42 * accuracy));
+
+				// Max/min integers that fit.
+				let a = $name::saturating_from_integer(inner_max / accuracy);
+				assert_eq!(a.into_inner(), (inner_max / accuracy) * accuracy);
+
+				let a = $name::saturating_from_integer(inner_min / accuracy);
+				assert_eq!(a.into_inner(), (inner_min / accuracy) * accuracy);
+
+				// Cases where integer doesn't fit, so it saturates.
+				let a = $name::saturating_from_integer(inner_max / accuracy + 1);
+				assert_eq!(a.into_inner(), inner_max);
+
+				let a = $name::saturating_from_integer((inner_min / accuracy).saturating_sub(1));
+				assert_eq!(a.into_inner(), inner_min);
+			}
+
+			#[test]
+			fn checked_from_integer_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+				let accuracy = $name::accuracy();
+
+				// Case where integer fits.
+				let a = $name::checked_from_integer::<$inner_type>(42)
+					.expect("42 * accuracy <= inner_max; qed");
+				assert_eq!(a.into_inner(), 42 * accuracy);
+
+				// Max integer that fit.
+				let a = $name::checked_from_integer::<$inner_type>(inner_max / accuracy)
+					.expect("(inner_max / accuracy) * accuracy <= inner_max; qed");
+				assert_eq!(a.into_inner(), (inner_max / accuracy) * accuracy);
+
+				// Case where integer doesn't fit, so it returns `None`.
+				let a = $name::checked_from_integer::<$inner_type>(inner_max / accuracy + 1);
+				assert_eq!(a, None);
+
+				if $name::SIGNED {
+					// Case where integer fits.
+					let a = $name::checked_from_integer::<$inner_type>(0.saturating_sub(42))
+						.expect("-42 * accuracy >= inner_min; qed");
+					assert_eq!(a.into_inner(), 0 - 42 * accuracy);
+
+					// Min integer that fit.
+					let a = $name::checked_from_integer::<$inner_type>(inner_min / accuracy)
+						.expect("(inner_min / accuracy) * accuracy <= inner_min; qed");
+					assert_eq!(a.into_inner(), (inner_min / accuracy) * accuracy);
+
+					// Case where integer doesn't fit, so it returns `None`.
+					let a = $name::checked_from_integer::<$inner_type>(inner_min / accuracy - 1);
+					assert_eq!(a, None);
+				}
+			}
+
+			#[test]
+			fn from_inner_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+
+				assert_eq!(max(), $name::from_inner(inner_max));
+				assert_eq!(min(), $name::from_inner(inner_min));
+			}
+
+			#[test]
+			#[should_panic(expected = "attempt to divide by zero")]
+			fn saturating_from_rational_panics_on_zero_divisor() {
+				let _ = $name::saturating_from_rational(1, 0);
+			}
+
+			#[test]
+			fn saturating_from_rational_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+				let accuracy = $name::accuracy();
+
+				let a = $name::saturating_from_rational(5, 2);
+
+				// Positive case: 2.5
+				assert_eq!(a.into_inner(), 25 * accuracy / 10);
+
+				// Max - 1.
+				let a = $name::saturating_from_rational(inner_max - 1, accuracy);
+				assert_eq!(a.into_inner(), inner_max - 1);
+
+				// Min + 1.
+				let a = $name::saturating_from_rational(inner_min + 1, accuracy);
+				assert_eq!(a.into_inner(), inner_min + 1);
+
+				// Max.
+				let a = $name::saturating_from_rational(inner_max, accuracy);
+				assert_eq!(a.into_inner(), inner_max);
+
+				// Min.
+				let a = $name::saturating_from_rational(inner_min, accuracy);
+				assert_eq!(a.into_inner(), inner_min);
+
+				// Zero.
+				let a = $name::saturating_from_rational(0, 1);
+				assert_eq!(a.into_inner(), 0);
+
+				if $name::SIGNED {
+					// Negative case: -2.5
+					let a = $name::saturating_from_rational(-5, 2);
+					assert_eq!(a.into_inner(), 0 - 25 * accuracy / 10);
+
+					// Other negative case: -2.5
+					let a = $name::saturating_from_rational(5, -2);
+					assert_eq!(a.into_inner(), 0 - 25 * accuracy / 10);
+
+					// Other positive case: 2.5
+					let a = $name::saturating_from_rational(-5, -2);
+					assert_eq!(a.into_inner(), 25 * accuracy / 10);
+
+					// Max + 1, saturates.
+					let a = $name::saturating_from_rational(inner_max as u128 + 1, accuracy);
+					assert_eq!(a.into_inner(), inner_max);
+
+					// Min - 1, saturates.
+					let a = $name::saturating_from_rational(inner_max as u128 + 2, 0 - accuracy);
+					assert_eq!(a.into_inner(), inner_min);
+
+					let a = $name::saturating_from_rational(inner_max, 0 - accuracy);
+					assert_eq!(a.into_inner(), 0 - inner_max);
+
+					let a = $name::saturating_from_rational(inner_min, 0 - accuracy);
+					assert_eq!(a.into_inner(), inner_max);
+
+					let a = $name::saturating_from_rational(inner_min + 1, 0 - accuracy);
+					assert_eq!(a.into_inner(), inner_max);
+
+					let a = $name::saturating_from_rational(inner_min, 0 - 1);
+					assert_eq!(a.into_inner(), inner_max);
+
+					let a = $name::saturating_from_rational(inner_max, 0 - 1);
+					assert_eq!(a.into_inner(), inner_min);
+
+					let a = $name::saturating_from_rational(inner_max, 0 - inner_max);
+					assert_eq!(a.into_inner(), 0 - accuracy);
+
+					let a = $name::saturating_from_rational(0 - inner_max, inner_max);
+					assert_eq!(a.into_inner(), 0 - accuracy);
+
+					let a = $name::saturating_from_rational(inner_max, 0 - 3 * accuracy);
+					assert_eq!(a.into_inner(), 0 - inner_max / 3);
+
+					let a = $name::saturating_from_rational(inner_min, 0 - accuracy / 3);
+					assert_eq!(a.into_inner(), inner_max);
+
+					let a = $name::saturating_from_rational(1, 0 - accuracy);
+					assert_eq!(a.into_inner(), 0.saturating_sub(1));
+
+					let a = $name::saturating_from_rational(inner_min, inner_min);
+					assert_eq!(a.into_inner(), accuracy);
+
+					// Out of accuracy.
+					let a = $name::saturating_from_rational(1, 0 - accuracy - 1);
+					assert_eq!(a.into_inner(), 0);
+				}
+
+				let a = $name::saturating_from_rational(inner_max - 1, accuracy);
+				assert_eq!(a.into_inner(), inner_max - 1);
+
+				let a = $name::saturating_from_rational(inner_min + 1, accuracy);
+				assert_eq!(a.into_inner(), inner_min + 1);
+
+				let a = $name::saturating_from_rational(inner_max, 1);
+				assert_eq!(a.into_inner(), inner_max);
+
+				let a = $name::saturating_from_rational(inner_min, 1);
+				assert_eq!(a.into_inner(), inner_min);
+
+				let a = $name::saturating_from_rational(inner_max, inner_max);
+				assert_eq!(a.into_inner(), accuracy);
+
+				let a = $name::saturating_from_rational(inner_max, 3 * accuracy);
+				assert_eq!(a.into_inner(), inner_max / 3);
+
+				let a = $name::saturating_from_rational(inner_min, 2 * accuracy);
+				assert_eq!(a.into_inner(), inner_min / 2);
+
+				let a = $name::saturating_from_rational(inner_min, accuracy / 3);
+				assert_eq!(a.into_inner(), inner_min);
+
+				let a = $name::saturating_from_rational(1, accuracy);
+				assert_eq!(a.into_inner(), 1);
+
+				// Out of accuracy.
+				let a = $name::saturating_from_rational(1, accuracy + 1);
+				assert_eq!(a.into_inner(), 0);
+			}
+
+			#[test]
+			fn checked_from_rational_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+				let accuracy = $name::accuracy();
+
+				// Divide by zero => None.
+				let a = $name::checked_from_rational(1, 0);
+				assert_eq!(a, None);
+
+				// Max - 1.
+				let a = $name::checked_from_rational(inner_max - 1, accuracy).unwrap();
+				assert_eq!(a.into_inner(), inner_max - 1);
+
+				// Min + 1.
+				let a = $name::checked_from_rational(inner_min + 1, accuracy).unwrap();
+				assert_eq!(a.into_inner(), inner_min + 1);
+
+				// Max.
+				let a = $name::checked_from_rational(inner_max, accuracy).unwrap();
+				assert_eq!(a.into_inner(), inner_max);
+
+				// Min.
+				let a = $name::checked_from_rational(inner_min, accuracy).unwrap();
+				assert_eq!(a.into_inner(), inner_min);
+
+				// Max + 1 => Overflow => None.
+				let a = $name::checked_from_rational(inner_min, 0.saturating_sub(accuracy));
+				assert_eq!(a, None);
+
+				if $name::SIGNED {
+					// Min - 1 => Underflow => None.
+					let a = $name::checked_from_rational(
+						inner_max as u128 + 2,
+						0.saturating_sub(accuracy),
+					);
+					assert_eq!(a, None);
+
+					let a = $name::checked_from_rational(inner_max, 0 - 3 * accuracy).unwrap();
+					assert_eq!(a.into_inner(), 0 - inner_max / 3);
+
+					let a = $name::checked_from_rational(inner_min, 0 - accuracy / 3);
+					assert_eq!(a, None);
+
+					let a = $name::checked_from_rational(1, 0 - accuracy).unwrap();
+					assert_eq!(a.into_inner(), 0.saturating_sub(1));
+
+					let a = $name::checked_from_rational(1, 0 - accuracy - 1).unwrap();
+					assert_eq!(a.into_inner(), 0);
+
+					let a = $name::checked_from_rational(inner_min, accuracy / 3);
+					assert_eq!(a, None);
+				}
+
+				let a = $name::checked_from_rational(inner_max, 3 * accuracy).unwrap();
+				assert_eq!(a.into_inner(), inner_max / 3);
+
+				let a = $name::checked_from_rational(inner_min, 2 * accuracy).unwrap();
+				assert_eq!(a.into_inner(), inner_min / 2);
+
+				let a = $name::checked_from_rational(1, accuracy).unwrap();
+				assert_eq!(a.into_inner(), 1);
+
+				let a = $name::checked_from_rational(1, accuracy + 1).unwrap();
+				assert_eq!(a.into_inner(), 0);
+			}
+
+			#[test]
+			fn from_rational_works() {
+				let inner_max: u128 = <$name as FixedPointNumber>::Inner::max_value() as u128;
+				let inner_min: u128 = 0;
+				let accuracy: u128 = $name::accuracy() as u128;
+
+				// Max - 1.
+				let a = $name::from_rational(inner_max - 1, accuracy);
+				assert_eq!(a.into_inner() as u128, inner_max - 1);
+
+				// Min + 1.
+				let a = $name::from_rational(inner_min + 1, accuracy);
+				assert_eq!(a.into_inner() as u128, inner_min + 1);
+
+				// Max.
+				let a = $name::from_rational(inner_max, accuracy);
+				assert_eq!(a.into_inner() as u128, inner_max);
+
+				// Min.
+				let a = $name::from_rational(inner_min, accuracy);
+				assert_eq!(a.into_inner() as u128, inner_min);
+
+				let a = $name::from_rational(inner_max, 3 * accuracy);
+				assert_eq!(a.into_inner() as u128, inner_max / 3);
+
+				let a = $name::from_rational(1, accuracy);
+				assert_eq!(a.into_inner() as u128, 1);
+
+				let a = $name::from_rational(1, accuracy + 1);
+				assert_eq!(a.into_inner() as u128, 1);
+
+				let a = $name::from_rational_with_rounding(1, accuracy + 1, Rounding::Down);
+				assert_eq!(a.into_inner() as u128, 0);
+			}
+
+			#[test]
+			fn checked_mul_int_works() {
+				let a = $name::saturating_from_integer(2);
+				// Max - 1.
+				assert_eq!(a.checked_mul_int((i128::MAX - 1) / 2), Some(i128::MAX - 1));
+				// Max.
+				assert_eq!(a.checked_mul_int(i128::MAX / 2), Some(i128::MAX - 1));
+				// Max + 1 => None.
+				assert_eq!(a.checked_mul_int(i128::MAX / 2 + 1), None);
+
+				if $name::SIGNED {
+					// Min - 1.
+					assert_eq!(a.checked_mul_int((i128::MIN + 1) / 2), Some(i128::MIN + 2));
+					// Min.
+					assert_eq!(a.checked_mul_int(i128::MIN / 2), Some(i128::MIN));
+					// Min + 1 => None.
+					assert_eq!(a.checked_mul_int(i128::MIN / 2 - 1), None);
+
+					let b = $name::saturating_from_rational(1, -2);
+					assert_eq!(b.checked_mul_int(42i128), Some(-21));
+					assert_eq!(b.checked_mul_int(u128::MAX), None);
+					assert_eq!(b.checked_mul_int(i128::MAX), Some(i128::MAX / -2));
+					assert_eq!(b.checked_mul_int(i128::MIN), Some(i128::MIN / -2));
+				}
+
+				let a = $name::saturating_from_rational(1, 2);
+				assert_eq!(a.checked_mul_int(42i128), Some(21));
+				assert_eq!(a.checked_mul_int(i128::MAX), Some(i128::MAX / 2));
+				assert_eq!(a.checked_mul_int(i128::MIN), Some(i128::MIN / 2));
+
+				let c = $name::saturating_from_integer(255);
+				assert_eq!(c.checked_mul_int(2i8), None);
+				assert_eq!(c.checked_mul_int(2i128), Some(510));
+				assert_eq!(c.checked_mul_int(i128::MAX), None);
+				assert_eq!(c.checked_mul_int(i128::MIN), None);
+			}
+
+			#[test]
+			fn saturating_mul_int_works() {
+				let a = $name::saturating_from_integer(2);
+				// Max - 1.
+				assert_eq!(a.saturating_mul_int((i128::MAX - 1) / 2), i128::MAX - 1);
+				// Max.
+				assert_eq!(a.saturating_mul_int(i128::MAX / 2), i128::MAX - 1);
+				// Max + 1 => saturates to max.
+				assert_eq!(a.saturating_mul_int(i128::MAX / 2 + 1), i128::MAX);
+
+				// Min - 1.
+				assert_eq!(a.saturating_mul_int((i128::MIN + 1) / 2), i128::MIN + 2);
+				// Min.
+				assert_eq!(a.saturating_mul_int(i128::MIN / 2), i128::MIN);
+				// Min + 1 => saturates to min.
+				assert_eq!(a.saturating_mul_int(i128::MIN / 2 - 1), i128::MIN);
+
+				if $name::SIGNED {
+					let b = $name::saturating_from_rational(1, -2);
+					assert_eq!(b.saturating_mul_int(42i32), -21);
+					assert_eq!(b.saturating_mul_int(i128::MAX), i128::MAX / -2);
+					assert_eq!(b.saturating_mul_int(i128::MIN), i128::MIN / -2);
+					assert_eq!(b.saturating_mul_int(u128::MAX), u128::MIN);
+				}
+
+				let a = $name::saturating_from_rational(1, 2);
+				assert_eq!(a.saturating_mul_int(42i32), 21);
+				assert_eq!(a.saturating_mul_int(i128::MAX), i128::MAX / 2);
+				assert_eq!(a.saturating_mul_int(i128::MIN), i128::MIN / 2);
+
+				let c = $name::saturating_from_integer(255);
+				assert_eq!(c.saturating_mul_int(2i8), i8::MAX);
+				assert_eq!(c.saturating_mul_int(-2i8), i8::MIN);
+				assert_eq!(c.saturating_mul_int(i128::MAX), i128::MAX);
+				assert_eq!(c.saturating_mul_int(i128::MIN), i128::MIN);
+			}
+
+			#[test]
+			fn checked_mul_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+
+				let a = $name::saturating_from_integer(2);
+
+				// Max - 1.
+				let b = $name::from_inner(inner_max - 1);
+				assert_eq!(a.checked_mul(&(b / 2.into())), Some(b));
+
+				// Max.
+				let c = $name::from_inner(inner_max);
+				assert_eq!(a.checked_mul(&(c / 2.into())), Some(b));
+
+				// Max + 1 => None.
+				let e = $name::from_inner(1);
+				assert_eq!(a.checked_mul(&(c / 2.into() + e)), None);
+
+				if $name::SIGNED {
+					// Min + 1.
+					let b = $name::from_inner(inner_min + 1) / 2.into();
+					let c = $name::from_inner(inner_min + 2);
+					assert_eq!(a.checked_mul(&b), Some(c));
+
+					// Min.
+					let b = $name::from_inner(inner_min) / 2.into();
+					let c = $name::from_inner(inner_min);
+					assert_eq!(a.checked_mul(&b), Some(c));
+
+					// Min - 1 => None.
+					let b = $name::from_inner(inner_min) / 2.into() - $name::from_inner(1);
+					assert_eq!(a.checked_mul(&b), None);
+
+					let c = $name::saturating_from_integer(255);
+					let b = $name::saturating_from_rational(1, -2);
+
+					assert_eq!(b.checked_mul(&42.into()), Some(0.saturating_sub(21).into()));
+					assert_eq!(
+						b.checked_mul(&$name::max_value()),
+						$name::max_value().checked_div(&0.saturating_sub(2).into())
+					);
+					assert_eq!(
+						b.checked_mul(&$name::min_value()),
+						$name::min_value().checked_div(&0.saturating_sub(2).into())
+					);
+					assert_eq!(c.checked_mul(&$name::min_value()), None);
+				}
+
+				let a = $name::saturating_from_rational(1, 2);
+				let c = $name::saturating_from_integer(255);
+
+				assert_eq!(a.checked_mul(&42.into()), Some(21.into()));
+				assert_eq!(c.checked_mul(&2.into()), Some(510.into()));
+				assert_eq!(c.checked_mul(&$name::max_value()), None);
+				assert_eq!(
+					a.checked_mul(&$name::max_value()),
+					$name::max_value().checked_div(&2.into())
+				);
+				assert_eq!(
+					a.checked_mul(&$name::min_value()),
+					$name::min_value().checked_div(&2.into())
+				);
+			}
+
+			#[test]
+			fn const_checked_mul_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+
+				let a = $name::saturating_from_integer(2u32);
+
+				// Max - 1.
+				let b = $name::from_inner(inner_max - 1);
+				assert_eq!(a.const_checked_mul((b / 2.into())), Some(b));
+
+				// Max.
+				let c = $name::from_inner(inner_max);
+				assert_eq!(a.const_checked_mul((c / 2.into())), Some(b));
+
+				// Max + 1 => None.
+				let e = $name::from_inner(1);
+				assert_eq!(a.const_checked_mul((c / 2.into() + e)), None);
+
+				if $name::SIGNED {
+					// Min + 1.
+					let b = $name::from_inner(inner_min + 1) / 2.into();
+					let c = $name::from_inner(inner_min + 2);
+					assert_eq!(a.const_checked_mul(b), Some(c));
+
+					// Min.
+					let b = $name::from_inner(inner_min) / 2.into();
+					let c = $name::from_inner(inner_min);
+					assert_eq!(a.const_checked_mul(b), Some(c));
+
+					// Min - 1 => None.
+					let b = $name::from_inner(inner_min) / 2.into() - $name::from_inner(1);
+					assert_eq!(a.const_checked_mul(b), None);
+
+					let b = $name::saturating_from_rational(1i32, -2i32);
+					let c = $name::saturating_from_integer(-21i32);
+					let d = $name::saturating_from_integer(42);
+
+					assert_eq!(b.const_checked_mul(d), Some(c));
+
+					let minus_two = $name::saturating_from_integer(-2i32);
+					assert_eq!(
+						b.const_checked_mul($name::max_value()),
+						$name::max_value().const_checked_div(minus_two)
+					);
+					assert_eq!(
+						b.const_checked_mul($name::min_value()),
+						$name::min_value().const_checked_div(minus_two)
+					);
+
+					let c = $name::saturating_from_integer(255u32);
+					assert_eq!(c.const_checked_mul($name::min_value()), None);
+				}
+
+				let a = $name::saturating_from_rational(1i32, 2i32);
+				let c = $name::saturating_from_integer(255i32);
+
+				assert_eq!(a.const_checked_mul(42.into()), Some(21.into()));
+				assert_eq!(c.const_checked_mul(2.into()), Some(510.into()));
+				assert_eq!(c.const_checked_mul($name::max_value()), None);
+				assert_eq!(
+					a.const_checked_mul($name::max_value()),
+					$name::max_value().checked_div(&2.into())
+				);
+				assert_eq!(
+					a.const_checked_mul($name::min_value()),
+					$name::min_value().const_checked_div($name::saturating_from_integer(2))
+				);
+			}
+
+			#[test]
+			fn checked_div_int_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+				let accuracy = $name::accuracy();
+
+				let a = $name::from_inner(inner_max);
+				let b = $name::from_inner(inner_min);
+				let c = $name::zero();
+				let d = $name::one();
+				let e = $name::saturating_from_integer(6);
+				let f = $name::saturating_from_integer(5);
+
+				assert_eq!(e.checked_div_int(2.into()), Some(3));
+				assert_eq!(f.checked_div_int(2.into()), Some(2));
+
+				assert_eq!(a.checked_div_int(i128::MAX), Some(0));
+				assert_eq!(a.checked_div_int(2), Some(inner_max / (2 * accuracy)));
+				assert_eq!(a.checked_div_int(inner_max / accuracy), Some(1));
+				assert_eq!(a.checked_div_int(1i8), None);
+
+				if b < c {
+					// Not executed by unsigned inners.
+					assert_eq!(
+						a.checked_div_int(0.saturating_sub(2)),
+						Some(0.saturating_sub(inner_max / (2 * accuracy)))
+					);
+					assert_eq!(
+						a.checked_div_int(0.saturating_sub(inner_max / accuracy)),
+						Some(0.saturating_sub(1))
+					);
+					assert_eq!(b.checked_div_int(i128::MIN), Some(0));
+					assert_eq!(b.checked_div_int(inner_min / accuracy), Some(1));
+					assert_eq!(b.checked_div_int(1i8), None);
+					assert_eq!(
+						b.checked_div_int(0.saturating_sub(2)),
+						Some(0.saturating_sub(inner_min / (2 * accuracy)))
+					);
+					assert_eq!(
+						b.checked_div_int(0.saturating_sub(inner_min / accuracy)),
+						Some(0.saturating_sub(1))
+					);
+					assert_eq!(c.checked_div_int(i128::MIN), Some(0));
+					assert_eq!(d.checked_div_int(i32::MIN), Some(0));
+				}
+
+				assert_eq!(b.checked_div_int(2), Some(inner_min / (2 * accuracy)));
+
+				assert_eq!(c.checked_div_int(1), Some(0));
+				assert_eq!(c.checked_div_int(i128::MAX), Some(0));
+				assert_eq!(c.checked_div_int(1i8), Some(0));
+
+				assert_eq!(d.checked_div_int(1), Some(1));
+				assert_eq!(d.checked_div_int(i32::MAX), Some(0));
+				assert_eq!(d.checked_div_int(1i8), Some(1));
+
+				assert_eq!(a.checked_div_int(0), None);
+				assert_eq!(b.checked_div_int(0), None);
+				assert_eq!(c.checked_div_int(0), None);
+				assert_eq!(d.checked_div_int(0), None);
+			}
+
+			#[test]
+			#[should_panic(expected = "attempt to divide by zero")]
+			fn saturating_div_int_panics_when_divisor_is_zero() {
+				let _ = $name::one().saturating_div_int(0);
+			}
+
+			#[test]
+			fn saturating_div_int_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+				let accuracy = $name::accuracy();
+
+				let a = $name::saturating_from_integer(5);
+				assert_eq!(a.saturating_div_int(2), 2);
+
+				let a = $name::min_value();
+				assert_eq!(a.saturating_div_int(1i128), (inner_min / accuracy) as i128);
+
+				if $name::SIGNED {
+					let a = $name::saturating_from_integer(5);
+					assert_eq!(a.saturating_div_int(-2), -2);
+
+					let a = $name::min_value();
+					assert_eq!(a.saturating_div_int(-1i128), (inner_max / accuracy) as i128);
+				}
+			}
+
+			#[test]
+			fn saturating_abs_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+
+				assert_eq!($name::from_inner(inner_max).saturating_abs(), $name::max_value());
+				assert_eq!($name::zero().saturating_abs(), 0.into());
+
+				if $name::SIGNED {
+					assert_eq!($name::from_inner(inner_min).saturating_abs(), $name::max_value());
+					assert_eq!(
+						$name::saturating_from_rational(-1, 2).saturating_abs(),
+						(1, 2).into()
+					);
+				}
+			}
+
+			#[test]
+			fn saturating_mul_acc_int_works() {
+				assert_eq!($name::zero().saturating_mul_acc_int(42i8), 42i8);
+				assert_eq!($name::one().saturating_mul_acc_int(42i8), 2 * 42i8);
+
+				assert_eq!($name::one().saturating_mul_acc_int(i128::MAX), i128::MAX);
+				assert_eq!($name::one().saturating_mul_acc_int(i128::MIN), i128::MIN);
+
+				assert_eq!($name::one().saturating_mul_acc_int(u128::MAX / 2), u128::MAX - 1);
+				assert_eq!($name::one().saturating_mul_acc_int(u128::MIN), u128::MIN);
+
+				if $name::SIGNED {
+					let a = $name::saturating_from_rational(-1, 2);
+					assert_eq!(a.saturating_mul_acc_int(42i8), 21i8);
+					assert_eq!(a.saturating_mul_acc_int(42u8), 21u8);
+					assert_eq!(a.saturating_mul_acc_int(u128::MAX - 1), u128::MAX / 2);
+				}
+			}
+
+			#[test]
+			fn saturating_pow_should_work() {
+				assert_eq!(
+					$name::saturating_from_integer(2).saturating_pow(0),
+					$name::saturating_from_integer(1)
+				);
+				assert_eq!(
+					$name::saturating_from_integer(2).saturating_pow(1),
+					$name::saturating_from_integer(2)
+				);
+				assert_eq!(
+					$name::saturating_from_integer(2).saturating_pow(2),
+					$name::saturating_from_integer(4)
+				);
+				assert_eq!(
+					$name::saturating_from_integer(2).saturating_pow(3),
+					$name::saturating_from_integer(8)
+				);
+				assert_eq!(
+					$name::saturating_from_integer(2).saturating_pow(50),
+					$name::saturating_from_integer(1125899906842624i64)
+				);
+
+				assert_eq!($name::saturating_from_integer(1).saturating_pow(1000), (1).into());
+				assert_eq!(
+					$name::saturating_from_integer(1).saturating_pow(usize::MAX),
+					(1).into()
+				);
+
+				if $name::SIGNED {
+					// Saturating.
+					assert_eq!(
+						$name::saturating_from_integer(2).saturating_pow(68),
+						$name::max_value()
+					);
+
+					assert_eq!($name::saturating_from_integer(-1).saturating_pow(1000), (1).into());
+					assert_eq!(
+						$name::saturating_from_integer(-1).saturating_pow(1001),
+						0.saturating_sub(1).into()
+					);
+					assert_eq!(
+						$name::saturating_from_integer(-1).saturating_pow(usize::MAX),
+						0.saturating_sub(1).into()
+					);
+					assert_eq!(
+						$name::saturating_from_integer(-1).saturating_pow(usize::MAX - 1),
+						(1).into()
+					);
+				}
+
+				assert_eq!(
+					$name::saturating_from_integer(114209).saturating_pow(5),
+					$name::max_value()
+				);
+
+				assert_eq!(
+					$name::saturating_from_integer(1).saturating_pow(usize::MAX),
+					(1).into()
+				);
+				assert_eq!(
+					$name::saturating_from_integer(0).saturating_pow(usize::MAX),
+					(0).into()
+				);
+				assert_eq!(
+					$name::saturating_from_integer(2).saturating_pow(usize::MAX),
+					$name::max_value()
+				);
+			}
+
+			#[test]
+			fn checked_div_works() {
+				let inner_max = <$name as FixedPointNumber>::Inner::max_value();
+				let inner_min = <$name as FixedPointNumber>::Inner::min_value();
+
+				let a = $name::from_inner(inner_max);
+				let b = $name::from_inner(inner_min);
+				let c = $name::zero();
+				let d = $name::one();
+				let e = $name::saturating_from_integer(6);
+				let f = $name::saturating_from_integer(5);
+
+				assert_eq!(e.checked_div(&2.into()), Some(3.into()));
+				assert_eq!(f.checked_div(&2.into()), Some((5, 2).into()));
+
+				assert_eq!(a.checked_div(&inner_max.into()), Some(1.into()));
+				assert_eq!(a.checked_div(&2.into()), Some($name::from_inner(inner_max / 2)));
+				assert_eq!(a.checked_div(&$name::max_value()), Some(1.into()));
+				assert_eq!(a.checked_div(&d), Some(a));
+
+				if b < c {
+					// Not executed by unsigned inners.
+					assert_eq!(
+						a.checked_div(&0.saturating_sub(2).into()),
+						Some($name::from_inner(0.saturating_sub(inner_max / 2)))
+					);
+					assert_eq!(
+						a.checked_div(&-$name::max_value()),
+						Some(0.saturating_sub(1).into())
+					);
+					assert_eq!(
+						b.checked_div(&0.saturating_sub(2).into()),
+						Some($name::from_inner(0.saturating_sub(inner_min / 2)))
+					);
+					assert_eq!(c.checked_div(&$name::max_value()), Some(0.into()));
+					assert_eq!(b.checked_div(&b), Some($name::one()));
+				}
+
+				assert_eq!(b.checked_div(&2.into()), Some($name::from_inner(inner_min / 2)));
+				assert_eq!(b.checked_div(&a), Some(0.saturating_sub(1).into()));
+				assert_eq!(c.checked_div(&1.into()), Some(0.into()));
+				assert_eq!(d.checked_div(&1.into()), Some(1.into()));
+
+				assert_eq!(a.checked_div(&$name::one()), Some(a));
+				assert_eq!(b.checked_div(&$name::one()), Some(b));
+				assert_eq!(c.checked_div(&$name::one()), Some(c));
+				assert_eq!(d.checked_div(&$name::one()), Some(d));
+
+				assert_eq!(a.checked_div(&$name::zero()), None);
+				assert_eq!(b.checked_div(&$name::zero()), None);
+				assert_eq!(c.checked_div(&$name::zero()), None);
+				assert_eq!(d.checked_div(&$name::zero()), None);
+			}
+
+			#[test]
+			fn is_positive_negative_works() {
+				let one = $name::one();
+				assert!(one.is_positive());
+				assert!(!one.is_negative());
+
+				let zero = $name::zero();
+				assert!(!zero.is_positive());
+				assert!(!zero.is_negative());
+
+				if $signed {
+					let minus_one = $name::saturating_from_integer(-1);
+					assert!(minus_one.is_negative());
+					assert!(!minus_one.is_positive());
+				}
+			}
+
+			#[test]
+			fn trunc_works() {
+				let n = $name::saturating_from_rational(5, 2).trunc();
+				assert_eq!(n, $name::saturating_from_integer(2));
+
+				if $name::SIGNED {
+					let n = $name::saturating_from_rational(-5, 2).trunc();
+					assert_eq!(n, $name::saturating_from_integer(-2));
+				}
+			}
+
+			#[test]
+			fn frac_works() {
+				let n = $name::saturating_from_rational(5, 2);
+				let i = n.trunc();
+				let f = n.frac();
+
+				assert_eq!(n, i + f);
+
+				let n = $name::saturating_from_rational(5, 2).frac().saturating_mul(10.into());
+				assert_eq!(n, 5.into());
+
+				let n = $name::saturating_from_rational(1, 2).frac().saturating_mul(10.into());
+				assert_eq!(n, 5.into());
+
+				if $name::SIGNED {
+					let n = $name::saturating_from_rational(-5, 2);
+					let i = n.trunc();
+					let f = n.frac();
+					assert_eq!(n, i - f);
+
+					// The sign is attached to the integer part unless it is zero.
+					let n = $name::saturating_from_rational(-5, 2).frac().saturating_mul(10.into());
+					assert_eq!(n, 5.into());
+
+					let n = $name::saturating_from_rational(-1, 2).frac().saturating_mul(10.into());
+					assert_eq!(n, 0.saturating_sub(5).into());
+				}
+			}
+
+			#[test]
+			fn ceil_works() {
+				let n = $name::saturating_from_rational(5, 2);
+				assert_eq!(n.ceil(), 3.into());
+
+				let n = $name::saturating_from_rational(-5, 2);
+				assert_eq!(n.ceil(), 0.saturating_sub(2).into());
+
+				// On the limits:
+				let n = $name::max_value();
+				assert_eq!(n.ceil(), n.trunc());
+
+				let n = $name::min_value();
+				assert_eq!(n.ceil(), n.trunc());
+			}
+
+			#[test]
+			fn floor_works() {
+				let n = $name::saturating_from_rational(5, 2);
+				assert_eq!(n.floor(), 2.into());
+
+				let n = $name::saturating_from_rational(-5, 2);
+				assert_eq!(n.floor(), 0.saturating_sub(3).into());
+
+				// On the limits:
+				let n = $name::max_value();
+				assert_eq!(n.floor(), n.trunc());
+
+				let n = $name::min_value();
+				assert_eq!(n.floor(), n.trunc());
+			}
+
+			#[test]
+			fn round_works() {
+				let n = $name::zero();
+				assert_eq!(n.round(), n);
+
+				let n = $name::one();
+				assert_eq!(n.round(), n);
+
+				let n = $name::saturating_from_rational(5, 2);
+				assert_eq!(n.round(), 3.into());
+
+				let n = $name::saturating_from_rational(-5, 2);
+				assert_eq!(n.round(), 0.saturating_sub(3).into());
+
+				// Saturating:
+				let n = $name::max_value();
+				assert_eq!(n.round(), n.trunc());
+
+				let n = $name::min_value();
+				assert_eq!(n.round(), n.trunc());
+
+				// On the limit:
+
+				// floor(max - 1) + 0.33..
+				let n = $name::max_value()
+					.saturating_sub(1.into())
+					.trunc()
+					.saturating_add((1, 3).into());
+
+				assert_eq!(n.round(), ($name::max_value() - 1.into()).trunc());
+
+				// floor(max - 1) + 0.5
+				let n = $name::max_value()
+					.saturating_sub(1.into())
+					.trunc()
+					.saturating_add((1, 2).into());
+
+				assert_eq!(n.round(), $name::max_value().trunc());
+
+				if $name::SIGNED {
+					// floor(min + 1) - 0.33..
+					let n = $name::min_value()
+						.saturating_add(1.into())
+						.trunc()
+						.saturating_sub((1, 3).into());
+
+					assert_eq!(n.round(), ($name::min_value() + 1.into()).trunc());
+
+					// floor(min + 1) - 0.5
+					let n = $name::min_value()
+						.saturating_add(1.into())
+						.trunc()
+						.saturating_sub((1, 2).into());
+
+					assert_eq!(n.round(), $name::min_value().trunc());
+				}
+			}
+
+			#[test]
+			fn perthing_into_works() {
+				let ten_percent_percent: $name = Percent::from_percent(10).into();
+				assert_eq!(ten_percent_percent.into_inner(), $name::accuracy() / 10);
+
+				let ten_percent_permill: $name = Permill::from_percent(10).into();
+				assert_eq!(ten_percent_permill.into_inner(), $name::accuracy() / 10);
+
+				let ten_percent_perbill: $name = Perbill::from_percent(10).into();
+				assert_eq!(ten_percent_perbill.into_inner(), $name::accuracy() / 10);
+
+				let ten_percent_perquintill: $name = Perquintill::from_percent(10).into();
+				assert_eq!(ten_percent_perquintill.into_inner(), $name::accuracy() / 10);
+			}
+
+			#[test]
+			fn fmt_should_work() {
+				let zero = $name::zero();
+				assert_eq!(
+					format!("{:?}", zero),
+					format!("{}(0.{:0>weight$})", stringify!($name), 0, weight = precision())
+				);
+
+				let one = $name::one();
+				assert_eq!(
+					format!("{:?}", one),
+					format!("{}(1.{:0>weight$})", stringify!($name), 0, weight = precision())
+				);
+
+				let frac = $name::saturating_from_rational(1, 2);
+				assert_eq!(
+					format!("{:?}", frac),
+					format!("{}(0.{:0<weight$})", stringify!($name), 5, weight = precision())
+				);
+
+				let frac = $name::saturating_from_rational(5, 2);
+				assert_eq!(
+					format!("{:?}", frac),
+					format!("{}(2.{:0<weight$})", stringify!($name), 5, weight = precision())
+				);
+
+				let frac = $name::saturating_from_rational(314, 100);
+				assert_eq!(
+					format!("{:?}", frac),
+					format!("{}(3.{:0<weight$})", stringify!($name), 14, weight = precision())
+				);
+
+				if $name::SIGNED {
+					let neg = -$name::one();
+					assert_eq!(
+						format!("{:?}", neg),
+						format!("{}(-1.{:0>weight$})", stringify!($name), 0, weight = precision())
+					);
+
+					let frac = $name::saturating_from_rational(-314, 100);
+					assert_eq!(
+						format!("{:?}", frac),
+						format!("{}(-3.{:0<weight$})", stringify!($name), 14, weight = precision())
+					);
+				}
+			}
+		}
+	};
+}
+
+implement_fixed!(
+	FixedI64,
+	test_fixed_i64,
+	i64,
+	true,
+	1_000_000_000,
+	"_Fixed Point 64 bits signed, range = [-9223372036.854775808, 9223372036.854775807]_",
+);
+
+implement_fixed!(
+	FixedU64,
+	test_fixed_u64,
+	u64,
+	false,
+	1_000_000_000,
+	"_Fixed Point 64 bits unsigned, range = [0.000000000, 18446744073.709551615]_",
+);
+
+implement_fixed!(
+	FixedI128,
+	test_fixed_i128,
+	i128,
+	true,
+	1_000_000_000_000_000_000,
+	"_Fixed Point 128 bits signed, range = \
+		[-170141183460469231731.687303715884105728, 170141183460469231731.687303715884105727]_",
+);
+
+implement_fixed!(
+	FixedU128,
+	test_fixed_u128,
+	u128,
+	false,
+	1_000_000_000_000_000_000,
+	"_Fixed Point 128 bits unsigned, range = \
+		[0.000000000000000000, 340282366920938463463.374607431768211455]_",
+);
diff --git a/substrate/primitives/arithmetic/src/helpers_128bit.rs b/substrate/primitives/arithmetic/src/helpers_128bit.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9b9c74ba55774984f3891968861317208b4bb5d2
--- /dev/null
+++ b/substrate/primitives/arithmetic/src/helpers_128bit.rs
@@ -0,0 +1,308 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// Some code is based upon Derek Dreery's IntegerSquareRoot impl, used under license.
+// 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.
+
+//! Some helper functions to work with 128bit numbers. Note that the functionality provided here is
+//! only sensible to use with 128bit numbers because for smaller sizes, you can always rely on
+//! assumptions of a bigger type (u128) being available, or simply create a per-thing and use the
+//! multiplication implementation provided there.
+
+use crate::{biguint, Rounding};
+use sp_std::cmp::{max, min};
+
+/// Helper gcd function used in Rational128 implementation.
+pub fn gcd(a: u128, b: u128) -> u128 {
+	match ((a, b), (a & 1, b & 1)) {
+		((x, y), _) if x == y => y,
+		((0, x), _) | ((x, 0), _) => x,
+		((x, y), (0, 1)) | ((y, x), (1, 0)) => gcd(x >> 1, y),
+		((x, y), (0, 0)) => gcd(x >> 1, y >> 1) << 1,
+		((x, y), (1, 1)) => {
+			let (x, y) = (min(x, y), max(x, y));
+			gcd((y - x) >> 1, x)
+		},
+		_ => unreachable!(),
+	}
+}
+
+/// split a u128 into two u64 limbs
+pub fn split(a: u128) -> (u64, u64) {
+	let al = a as u64;
+	let ah = (a >> 64) as u64;
+	(ah, al)
+}
+
+/// Convert a u128 to a u32 based biguint.
+pub fn to_big_uint(x: u128) -> biguint::BigUint {
+	let (xh, xl) = split(x);
+	let (xhh, xhl) = biguint::split(xh);
+	let (xlh, xll) = biguint::split(xl);
+	let mut n = biguint::BigUint::from_limbs(&[xhh, xhl, xlh, xll]);
+	n.lstrip();
+	n
+}
+
+mod double128 {
+	// Inspired by: https://medium.com/wicketh/mathemagic-512-bit-division-in-solidity-afa55870a65
+
+	/// Returns the least significant 64 bits of a
+	const fn low_64(a: u128) -> u128 {
+		a & ((1 << 64) - 1)
+	}
+
+	/// Returns the most significant 64 bits of a
+	const fn high_64(a: u128) -> u128 {
+		a >> 64
+	}
+
+	/// Returns 2^128 - a (two's complement)
+	const fn neg128(a: u128) -> u128 {
+		(!a).wrapping_add(1)
+	}
+
+	/// Returns 2^128 / a
+	const fn div128(a: u128) -> u128 {
+		(neg128(a) / a).wrapping_add(1)
+	}
+
+	/// Returns 2^128 % a
+	const fn mod128(a: u128) -> u128 {
+		neg128(a) % a
+	}
+
+	#[derive(Copy, Clone, Eq, PartialEq)]
+	pub struct Double128 {
+		high: u128,
+		low: u128,
+	}
+
+	impl Double128 {
+		pub const fn try_into_u128(self) -> Result<u128, ()> {
+			match self.high {
+				0 => Ok(self.low),
+				_ => Err(()),
+			}
+		}
+
+		pub const fn zero() -> Self {
+			Self { high: 0, low: 0 }
+		}
+
+		/// Return a `Double128` value representing the `scaled_value << 64`.
+		///
+		/// This means the lower half of the `high` component will be equal to the upper 64-bits of
+		/// `scaled_value` (in the lower positions) and the upper half of the `low` component will
+		/// be equal to the lower 64-bits of `scaled_value`.
+		pub const fn left_shift_64(scaled_value: u128) -> Self {
+			Self { high: scaled_value >> 64, low: scaled_value << 64 }
+		}
+
+		/// Construct a value from the upper 128 bits only, with the lower being zeroed.
+		pub const fn from_low(low: u128) -> Self {
+			Self { high: 0, low }
+		}
+
+		/// Returns the same value ignoring anything in the high 128-bits.
+		pub const fn low_part(self) -> Self {
+			Self { high: 0, ..self }
+		}
+
+		/// Returns a*b (in 256 bits)
+		pub const fn product_of(a: u128, b: u128) -> Self {
+			// Split a and b into hi and lo 64-bit parts
+			let (a_low, a_high) = (low_64(a), high_64(a));
+			let (b_low, b_high) = (low_64(b), high_64(b));
+			// a = (a_low + a_high << 64); b = (b_low + b_high << 64);
+			// ergo a*b = (a_low + a_high << 64)(b_low + b_high << 64)
+			//          = a_low * b_low
+			//          + a_low * b_high << 64
+			//          + a_high << 64 * b_low
+			//          + a_high << 64 * b_high << 64
+			// assuming:
+			//        f = a_low * b_low
+			//        o = a_low * b_high
+			//        i = a_high * b_low
+			//        l = a_high * b_high
+			// then:
+			//      a*b = (o+i) << 64 + f + l << 128
+			let (f, o, i, l) = (a_low * b_low, a_low * b_high, a_high * b_low, a_high * b_high);
+			let fl = Self { high: l, low: f };
+			let i = Self::left_shift_64(i);
+			let o = Self::left_shift_64(o);
+			fl.add(i).add(o)
+		}
+
+		pub const fn add(self, b: Self) -> Self {
+			let (low, overflow) = self.low.overflowing_add(b.low);
+			let carry = overflow as u128; // 1 if true, 0 if false.
+			let high = self.high.wrapping_add(b.high).wrapping_add(carry as u128);
+			Double128 { high, low }
+		}
+
+		pub const fn div(mut self, rhs: u128) -> (Self, u128) {
+			if rhs == 1 {
+				return (self, 0)
+			}
+
+			// (self === a; rhs === b)
+			// Calculate a / b
+			// = (a_high << 128 + a_low) / b
+			//   let (q, r) = (div128(b), mod128(b));
+			// = (a_low * (q * b + r)) + a_high) / b
+			// = (a_low * q * b + a_low * r + a_high)/b
+			// = (a_low * r + a_high) / b + a_low * q
+			let (q, r) = (div128(rhs), mod128(rhs));
+
+			// x = current result
+			// a = next number
+			let mut x = Self::zero();
+			while self.high != 0 {
+				// x += a.low * q
+				x = x.add(Self::product_of(self.high, q));
+				// a = a.low * r + a.high
+				self = Self::product_of(self.high, r).add(self.low_part());
+			}
+
+			(x.add(Self::from_low(self.low / rhs)), self.low % rhs)
+		}
+	}
+}
+
+/// Returns `a * b / c` (wrapping to 128 bits) or `None` in the case of
+/// overflow.
+pub const fn multiply_by_rational_with_rounding(
+	a: u128,
+	b: u128,
+	c: u128,
+	r: Rounding,
+) -> Option<u128> {
+	use double128::Double128;
+	if c == 0 {
+		return None
+	}
+	let (result, remainder) = Double128::product_of(a, b).div(c);
+	let mut result: u128 = match result.try_into_u128() {
+		Ok(v) => v,
+		Err(_) => return None,
+	};
+	if match r {
+		Rounding::Up => remainder > 0,
+		// cannot be `(c + 1) / 2` since `c` might be `max_value` and overflow.
+		Rounding::NearestPrefUp => remainder >= c / 2 + c % 2,
+		Rounding::NearestPrefDown => remainder > c / 2,
+		Rounding::Down => false,
+	} {
+		result = match result.checked_add(1) {
+			Some(v) => v,
+			None => return None,
+		};
+	}
+	Some(result)
+}
+
+pub const fn sqrt(mut n: u128) -> u128 {
+	// Modified from https://github.com/derekdreery/integer-sqrt-rs (Apache/MIT).
+	if n == 0 {
+		return 0
+	}
+
+	// Compute bit, the largest power of 4 <= n
+	let max_shift: u32 = 0u128.leading_zeros() - 1;
+	let shift: u32 = (max_shift - n.leading_zeros()) & !1;
+	let mut bit = 1u128 << shift;
+
+	// Algorithm based on the implementation in:
+	// https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Binary_numeral_system_(base_2)
+	// Note that result/bit are logically unsigned (even if T is signed).
+	let mut result = 0u128;
+	while bit != 0 {
+		if n >= result + bit {
+			n -= result + bit;
+			result = (result >> 1) + bit;
+		} else {
+			result = result >> 1;
+		}
+		bit = bit >> 2;
+	}
+	result
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::{Decode, Encode};
+	use multiply_by_rational_with_rounding as mulrat;
+	use Rounding::*;
+
+	const MAX: u128 = u128::max_value();
+
+	#[test]
+	fn rational_multiply_basic_rounding_works() {
+		assert_eq!(mulrat(1, 1, 1, Up), Some(1));
+		assert_eq!(mulrat(3, 1, 3, Up), Some(1));
+		assert_eq!(mulrat(1, 1, 3, Up), Some(1));
+		assert_eq!(mulrat(1, 2, 3, Down), Some(0));
+		assert_eq!(mulrat(1, 1, 3, NearestPrefDown), Some(0));
+		assert_eq!(mulrat(1, 1, 2, NearestPrefDown), Some(0));
+		assert_eq!(mulrat(1, 2, 3, NearestPrefDown), Some(1));
+		assert_eq!(mulrat(1, 1, 3, NearestPrefUp), Some(0));
+		assert_eq!(mulrat(1, 1, 2, NearestPrefUp), Some(1));
+		assert_eq!(mulrat(1, 2, 3, NearestPrefUp), Some(1));
+	}
+
+	#[test]
+	fn rational_multiply_big_number_works() {
+		assert_eq!(mulrat(MAX, MAX - 1, MAX, Down), Some(MAX - 1));
+		assert_eq!(mulrat(MAX, 1, MAX, Down), Some(1));
+		assert_eq!(mulrat(MAX, MAX - 1, MAX, Up), Some(MAX - 1));
+		assert_eq!(mulrat(MAX, 1, MAX, Up), Some(1));
+		assert_eq!(mulrat(1, MAX - 1, MAX, Down), Some(0));
+		assert_eq!(mulrat(1, 1, MAX, Up), Some(1));
+		assert_eq!(mulrat(1, MAX / 2, MAX, NearestPrefDown), Some(0));
+		assert_eq!(mulrat(1, MAX / 2 + 1, MAX, NearestPrefDown), Some(1));
+		assert_eq!(mulrat(1, MAX / 2, MAX, NearestPrefUp), Some(0));
+		assert_eq!(mulrat(1, MAX / 2 + 1, MAX, NearestPrefUp), Some(1));
+	}
+
+	#[test]
+	fn sqrt_works() {
+		for i in 0..100_000u32 {
+			let a = sqrt(random_u128(i));
+			assert_eq!(sqrt(a * a), a);
+		}
+	}
+
+	fn random_u128(seed: u32) -> u128 {
+		u128::decode(&mut &seed.using_encoded(sp_core::hashing::twox_128)[..]).unwrap_or(0)
+	}
+
+	#[test]
+	fn op_checked_rounded_div_works() {
+		for i in 0..100_000u32 {
+			let a = random_u128(i);
+			let b = random_u128(i + (1 << 30));
+			let c = random_u128(i + (1 << 31));
+			let x = mulrat(a, b, c, NearestPrefDown);
+			let y = multiply_by_rational_with_rounding(a, b, c, Rounding::NearestPrefDown);
+			assert_eq!(x.is_some(), y.is_some());
+			let x = x.unwrap_or(0);
+			let y = y.unwrap_or(0);
+			let d = x.max(y) - x.min(y);
+			assert_eq!(d, 0);
+		}
+	}
+}
diff --git a/substrate/primitives/arithmetic/src/lib.rs b/substrate/primitives/arithmetic/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..900f0b75c3bf4f4e45524db7b3f0991828f03a09
--- /dev/null
+++ b/substrate/primitives/arithmetic/src/lib.rs
@@ -0,0 +1,490 @@
+// 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.
+
+//! Minimal fixed point arithmetic primitives and types for runtime.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// Copied from `sp-runtime` and documented there.
+#[macro_export]
+macro_rules! assert_eq_error_rate {
+	($x:expr, $y:expr, $error:expr $(,)?) => {
+		assert!(
+			($x) >= (($y) - ($error)) && ($x) <= (($y) + ($error)),
+			"{:?} != {:?} (with error rate {:?})",
+			$x,
+			$y,
+			$error,
+		);
+	};
+}
+
+pub mod biguint;
+pub mod fixed_point;
+pub mod helpers_128bit;
+pub mod per_things;
+pub mod rational;
+pub mod traits;
+
+pub use fixed_point::{
+	FixedI128, FixedI64, FixedPointNumber, FixedPointOperand, FixedU128, FixedU64,
+};
+pub use per_things::{
+	InnerOf, MultiplyArg, PerThing, PerU16, Perbill, Percent, Permill, Perquintill, RationalArg,
+	ReciprocalArg, Rounding, SignedRounding, UpperOf,
+};
+pub use rational::{MultiplyRational, Rational128, RationalInfinite};
+
+use sp_std::{cmp::Ordering, fmt::Debug, prelude::*};
+use traits::{BaseArithmetic, One, SaturatedConversion, Unsigned, Zero};
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// Arithmetic errors.
+#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ArithmeticError {
+	/// Underflow.
+	Underflow,
+	/// Overflow.
+	Overflow,
+	/// Division by zero.
+	DivisionByZero,
+}
+
+impl From<ArithmeticError> for &'static str {
+	fn from(e: ArithmeticError) -> &'static str {
+		match e {
+			ArithmeticError::Underflow => "An underflow would occur",
+			ArithmeticError::Overflow => "An overflow would occur",
+			ArithmeticError::DivisionByZero => "Division by zero",
+		}
+	}
+}
+
+/// Trait for comparing two numbers with an threshold.
+///
+/// Returns:
+/// - `Ordering::Greater` if `self` is greater than `other + threshold`.
+/// - `Ordering::Less` if `self` is less than `other - threshold`.
+/// - `Ordering::Equal` otherwise.
+pub trait ThresholdOrd<T> {
+	/// Compare if `self` is `threshold` greater or less than `other`.
+	fn tcmp(&self, other: &T, threshold: T) -> Ordering;
+}
+
+impl<T> ThresholdOrd<T> for T
+where
+	T: Ord + PartialOrd + Copy + Clone + traits::Zero + traits::Saturating,
+{
+	fn tcmp(&self, other: &T, threshold: T) -> Ordering {
+		// early exit.
+		if threshold.is_zero() {
+			return self.cmp(other)
+		}
+
+		let upper_bound = other.saturating_add(threshold);
+		let lower_bound = other.saturating_sub(threshold);
+
+		if upper_bound <= lower_bound {
+			// defensive only. Can never happen.
+			self.cmp(other)
+		} else {
+			// upper_bound is guaranteed now to be bigger than lower.
+			match (self.cmp(&lower_bound), self.cmp(&upper_bound)) {
+				(Ordering::Greater, Ordering::Greater) => Ordering::Greater,
+				(Ordering::Less, Ordering::Less) => Ordering::Less,
+				_ => Ordering::Equal,
+			}
+		}
+	}
+}
+
+/// A collection-like object that is made of values of type `T` and can normalize its individual
+/// values around a centric point.
+///
+/// Note that the order of items in the collection may affect the result.
+pub trait Normalizable<T> {
+	/// Normalize self around `targeted_sum`.
+	///
+	/// Only returns `Ok` if the new sum of results is guaranteed to be equal to `targeted_sum`.
+	/// Else, returns an error explaining why it failed to do so.
+	fn normalize(&self, targeted_sum: T) -> Result<Vec<T>, &'static str>;
+}
+
+macro_rules! impl_normalize_for_numeric {
+	($($numeric:ty),*) => {
+		$(
+			impl Normalizable<$numeric> for Vec<$numeric> {
+				fn normalize(&self, targeted_sum: $numeric) -> Result<Vec<$numeric>, &'static str> {
+					normalize(self.as_ref(), targeted_sum)
+				}
+			}
+		)*
+	};
+}
+
+impl_normalize_for_numeric!(u8, u16, u32, u64, u128);
+
+impl<P: PerThing> Normalizable<P> for Vec<P> {
+	fn normalize(&self, targeted_sum: P) -> Result<Vec<P>, &'static str> {
+		let uppers = self.iter().map(|p| <UpperOf<P>>::from(p.deconstruct())).collect::<Vec<_>>();
+
+		let normalized =
+			normalize(uppers.as_ref(), <UpperOf<P>>::from(targeted_sum.deconstruct()))?;
+
+		Ok(normalized
+			.into_iter()
+			.map(|i: UpperOf<P>| P::from_parts(i.saturated_into::<P::Inner>()))
+			.collect())
+	}
+}
+
+/// Normalize `input` so that the sum of all elements reaches `targeted_sum`.
+///
+/// This implementation is currently in a balanced position between being performant and accurate.
+///
+/// 1. We prefer storing original indices, and sorting the `input` only once. This will save the
+///    cost of sorting per round at the cost of a little bit of memory.
+/// 2. The granularity of increment/decrements is determined by the number of elements in `input`
+///    and their sum difference with `targeted_sum`, namely `diff = diff(sum(input), target_sum)`.
+///    This value is then distributed into `per_round = diff / input.len()` and `leftover = diff %
+///    round`. First, per_round is applied to all elements of input, and then we move to leftover,
+///    in which case we add/subtract 1 by 1 until `leftover` is depleted.
+///
+/// When the sum is less than the target, the above approach always holds. In this case, then each
+/// individual element is also less than target. Thus, by adding `per_round` to each item, neither
+/// of them can overflow the numeric bound of `T`. In fact, neither of the can go beyond
+/// `target_sum`*.
+///
+/// If sum is more than target, there is small twist. The subtraction of `per_round`
+/// form each element might go below zero. In this case, we saturate and add the error to the
+/// `leftover` value. This ensures that the result will always stay accurate, yet it might cause the
+/// execution to become increasingly slow, since leftovers are applied one by one.
+///
+/// All in all, the complicated case above is rare to happen in most use cases within this repo ,
+/// hence we opt for it due to its simplicity.
+///
+/// This function will return an error is if length of `input` cannot fit in `T`, or if `sum(input)`
+/// cannot fit inside `T`.
+///
+/// * This proof is used in the implementation as well.
+pub fn normalize<T>(input: &[T], targeted_sum: T) -> Result<Vec<T>, &'static str>
+where
+	T: Clone + Copy + Ord + BaseArithmetic + Unsigned + Debug,
+{
+	// compute sum and return error if failed.
+	let mut sum = T::zero();
+	for t in input.iter() {
+		sum = sum.checked_add(t).ok_or("sum of input cannot fit in `T`")?;
+	}
+
+	// convert count and return error if failed.
+	let count = input.len();
+	let count_t: T = count.try_into().map_err(|_| "length of `inputs` cannot fit in `T`")?;
+
+	// Nothing to do here.
+	if count.is_zero() {
+		return Ok(Vec::<T>::new())
+	}
+
+	let diff = targeted_sum.max(sum) - targeted_sum.min(sum);
+	if diff.is_zero() {
+		return Ok(input.to_vec())
+	}
+
+	let needs_bump = targeted_sum > sum;
+	let per_round = diff / count_t;
+	let mut leftover = diff % count_t;
+
+	// sort output once based on diff. This will require more data transfer and saving original
+	// index, but we sort only twice instead: once now and once at the very end.
+	let mut output_with_idx = input.iter().cloned().enumerate().collect::<Vec<(usize, T)>>();
+	output_with_idx.sort_by_key(|x| x.1);
+
+	if needs_bump {
+		// must increase the values a bit. Bump from the min element. Index of minimum is now zero
+		// because we did a sort. If at any point the min goes greater or equal the `max_threshold`,
+		// we move to the next minimum.
+		let mut min_index = 0;
+		// at this threshold we move to next index.
+		let threshold = targeted_sum / count_t;
+
+		if !per_round.is_zero() {
+			for _ in 0..count {
+				output_with_idx[min_index].1 = output_with_idx[min_index]
+					.1
+					.checked_add(&per_round)
+					.expect("Proof provided in the module doc; qed.");
+				if output_with_idx[min_index].1 >= threshold {
+					min_index += 1;
+					min_index %= count;
+				}
+			}
+		}
+
+		// continue with the previous min_index
+		while !leftover.is_zero() {
+			output_with_idx[min_index].1 = output_with_idx[min_index]
+				.1
+				.checked_add(&T::one())
+				.expect("Proof provided in the module doc; qed.");
+			if output_with_idx[min_index].1 >= threshold {
+				min_index += 1;
+				min_index %= count;
+			}
+			leftover -= One::one()
+		}
+	} else {
+		// must decrease the stakes a bit. decrement from the max element. index of maximum is now
+		// last. if at any point the max goes less or equal the `min_threshold`, we move to the next
+		// maximum.
+		let mut max_index = count - 1;
+		// at this threshold we move to next index.
+		let threshold = output_with_idx
+			.first()
+			.expect("length of input is greater than zero; it must have a first; qed")
+			.1;
+
+		if !per_round.is_zero() {
+			for _ in 0..count {
+				output_with_idx[max_index].1 =
+					output_with_idx[max_index].1.checked_sub(&per_round).unwrap_or_else(|| {
+						let remainder = per_round - output_with_idx[max_index].1;
+						leftover += remainder;
+						output_with_idx[max_index].1.saturating_sub(per_round)
+					});
+				if output_with_idx[max_index].1 <= threshold {
+					max_index = max_index.checked_sub(1).unwrap_or(count - 1);
+				}
+			}
+		}
+
+		// continue with the previous max_index
+		while !leftover.is_zero() {
+			if let Some(next) = output_with_idx[max_index].1.checked_sub(&One::one()) {
+				output_with_idx[max_index].1 = next;
+				if output_with_idx[max_index].1 <= threshold {
+					max_index = max_index.checked_sub(1).unwrap_or(count - 1);
+				}
+				leftover -= One::one()
+			} else {
+				max_index = max_index.checked_sub(1).unwrap_or(count - 1);
+			}
+		}
+	}
+
+	debug_assert_eq!(
+		output_with_idx.iter().fold(T::zero(), |acc, (_, x)| acc + *x),
+		targeted_sum,
+		"sum({:?}) != {:?}",
+		output_with_idx,
+		targeted_sum,
+	);
+
+	// sort again based on the original index.
+	output_with_idx.sort_by_key(|x| x.0);
+	Ok(output_with_idx.into_iter().map(|(_, t)| t).collect())
+}
+
+#[cfg(test)]
+mod normalize_tests {
+	use super::*;
+
+	#[test]
+	fn work_for_all_types() {
+		macro_rules! test_for {
+			($type:ty) => {
+				assert_eq!(
+					normalize(vec![8 as $type, 9, 7, 10].as_ref(), 40).unwrap(),
+					vec![10, 10, 10, 10],
+				);
+			};
+		}
+		// it should work for all types as long as the length of vector can be converted to T.
+		test_for!(u128);
+		test_for!(u64);
+		test_for!(u32);
+		test_for!(u16);
+		test_for!(u8);
+	}
+
+	#[test]
+	fn fails_on_if_input_sum_large() {
+		assert!(normalize(vec![1u8; 255].as_ref(), 10).is_ok());
+		assert_eq!(normalize(vec![1u8; 256].as_ref(), 10), Err("sum of input cannot fit in `T`"));
+	}
+
+	#[test]
+	fn does_not_fail_on_subtraction_overflow() {
+		assert_eq!(normalize(vec![1u8, 100, 100].as_ref(), 10).unwrap(), vec![1, 9, 0]);
+		assert_eq!(normalize(vec![1u8, 8, 9].as_ref(), 1).unwrap(), vec![0, 1, 0]);
+	}
+
+	#[test]
+	fn works_for_vec() {
+		assert_eq!(vec![8u32, 9, 7, 10].normalize(40).unwrap(), vec![10u32, 10, 10, 10]);
+	}
+
+	#[test]
+	fn works_for_per_thing() {
+		assert_eq!(
+			vec![Perbill::from_percent(33), Perbill::from_percent(33), Perbill::from_percent(33)]
+				.normalize(Perbill::one())
+				.unwrap(),
+			vec![
+				Perbill::from_parts(333333334),
+				Perbill::from_parts(333333333),
+				Perbill::from_parts(333333333),
+			]
+		);
+
+		assert_eq!(
+			vec![Perbill::from_percent(20), Perbill::from_percent(15), Perbill::from_percent(30)]
+				.normalize(Perbill::one())
+				.unwrap(),
+			vec![
+				Perbill::from_parts(316666668),
+				Perbill::from_parts(383333332),
+				Perbill::from_parts(300000000),
+			]
+		);
+	}
+
+	#[test]
+	fn can_work_for_peru16() {
+		// Peru16 is a rather special case; since inner type is exactly the same as capacity, we
+		// could have a situation where the sum cannot be calculated in the inner type. Calculating
+		// using the upper type of the per_thing should assure this to be okay.
+		assert_eq!(
+			vec![PerU16::from_percent(40), PerU16::from_percent(40), PerU16::from_percent(40),]
+				.normalize(PerU16::one())
+				.unwrap(),
+			vec![
+				PerU16::from_parts(21845), // 33%
+				PerU16::from_parts(21845), // 33%
+				PerU16::from_parts(21845), // 33%
+			]
+		);
+	}
+
+	#[test]
+	fn normalize_works_all_le() {
+		assert_eq!(normalize(vec![8u32, 9, 7, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
+
+		assert_eq!(normalize(vec![7u32, 7, 7, 7].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
+
+		assert_eq!(normalize(vec![7u32, 7, 7, 10].as_ref(), 40).unwrap(), vec![11, 11, 8, 10]);
+
+		assert_eq!(normalize(vec![7u32, 8, 7, 10].as_ref(), 40).unwrap(), vec![11, 8, 11, 10]);
+
+		assert_eq!(normalize(vec![7u32, 7, 8, 10].as_ref(), 40).unwrap(), vec![11, 11, 8, 10]);
+	}
+
+	#[test]
+	fn normalize_works_some_ge() {
+		assert_eq!(normalize(vec![8u32, 11, 9, 10].as_ref(), 40).unwrap(), vec![10, 11, 9, 10]);
+	}
+
+	#[test]
+	fn always_inc_min() {
+		assert_eq!(normalize(vec![10u32, 7, 10, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
+		assert_eq!(normalize(vec![10u32, 10, 7, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
+		assert_eq!(normalize(vec![10u32, 10, 10, 7].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
+	}
+
+	#[test]
+	fn normalize_works_all_ge() {
+		assert_eq!(normalize(vec![12u32, 11, 13, 10].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
+
+		assert_eq!(normalize(vec![13u32, 13, 13, 13].as_ref(), 40).unwrap(), vec![10, 10, 10, 10]);
+
+		assert_eq!(normalize(vec![13u32, 13, 13, 10].as_ref(), 40).unwrap(), vec![12, 9, 9, 10]);
+
+		assert_eq!(normalize(vec![13u32, 12, 13, 10].as_ref(), 40).unwrap(), vec![9, 12, 9, 10]);
+
+		assert_eq!(normalize(vec![13u32, 13, 12, 10].as_ref(), 40).unwrap(), vec![9, 9, 12, 10]);
+	}
+}
+
+#[cfg(test)]
+mod threshold_compare_tests {
+	use super::*;
+	use crate::traits::Saturating;
+	use sp_std::cmp::Ordering;
+
+	#[test]
+	fn epsilon_ord_works() {
+		let b = 115u32;
+		let e = Perbill::from_percent(10).mul_ceil(b);
+
+		// [115 - 11,5 (103,5), 115 + 11,5 (126,5)] is all equal
+		assert_eq!(103u32.tcmp(&b, e), Ordering::Equal);
+		assert_eq!(104u32.tcmp(&b, e), Ordering::Equal);
+		assert_eq!(115u32.tcmp(&b, e), Ordering::Equal);
+		assert_eq!(120u32.tcmp(&b, e), Ordering::Equal);
+		assert_eq!(126u32.tcmp(&b, e), Ordering::Equal);
+		assert_eq!(127u32.tcmp(&b, e), Ordering::Equal);
+
+		assert_eq!(128u32.tcmp(&b, e), Ordering::Greater);
+		assert_eq!(102u32.tcmp(&b, e), Ordering::Less);
+	}
+
+	#[test]
+	fn epsilon_ord_works_with_small_epc() {
+		let b = 115u32;
+		// way less than 1 percent. threshold will be zero. Result should be same as normal ord.
+		let e = Perbill::from_parts(100) * b;
+
+		// [115 - 11,5 (103,5), 115 + 11,5 (126,5)] is all equal
+		assert_eq!(103u32.tcmp(&b, e), 103u32.cmp(&b));
+		assert_eq!(104u32.tcmp(&b, e), 104u32.cmp(&b));
+		assert_eq!(115u32.tcmp(&b, e), 115u32.cmp(&b));
+		assert_eq!(120u32.tcmp(&b, e), 120u32.cmp(&b));
+		assert_eq!(126u32.tcmp(&b, e), 126u32.cmp(&b));
+		assert_eq!(127u32.tcmp(&b, e), 127u32.cmp(&b));
+
+		assert_eq!(128u32.tcmp(&b, e), 128u32.cmp(&b));
+		assert_eq!(102u32.tcmp(&b, e), 102u32.cmp(&b));
+	}
+
+	#[test]
+	fn peru16_rational_does_not_overflow() {
+		// A historical example that will panic only for per_thing type that are created with
+		// maximum capacity of their type, e.g. PerU16.
+		let _ = PerU16::from_rational(17424870u32, 17424870);
+	}
+
+	#[test]
+	fn saturating_mul_works() {
+		assert_eq!(Saturating::saturating_mul(2, i32::MIN), i32::MIN);
+		assert_eq!(Saturating::saturating_mul(2, i32::MAX), i32::MAX);
+	}
+
+	#[test]
+	fn saturating_pow_works() {
+		assert_eq!(Saturating::saturating_pow(i32::MIN, 0), 1);
+		assert_eq!(Saturating::saturating_pow(i32::MAX, 0), 1);
+		assert_eq!(Saturating::saturating_pow(i32::MIN, 3), i32::MIN);
+		assert_eq!(Saturating::saturating_pow(i32::MIN, 2), i32::MAX);
+		assert_eq!(Saturating::saturating_pow(i32::MAX, 2), i32::MAX);
+	}
+}
diff --git a/substrate/primitives/arithmetic/src/per_things.rs b/substrate/primitives/arithmetic/src/per_things.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe88b72e24c22158d1d35db50aebf68dec8ff191
--- /dev/null
+++ b/substrate/primitives/arithmetic/src/per_things.rs
@@ -0,0 +1,1872 @@
+// 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(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use crate::traits::{
+	BaseArithmetic, Bounded, CheckedAdd, CheckedMul, CheckedSub, One, SaturatedConversion,
+	Saturating, UniqueSaturatedInto, Unsigned, Zero,
+};
+use codec::{CompactAs, Encode};
+use num_traits::{Pow, SaturatingAdd, SaturatingSub};
+use sp_std::{
+	fmt, ops,
+	ops::{Add, Sub},
+	prelude::*,
+};
+
+/// Get the inner type of a `PerThing`.
+pub type InnerOf<P> = <P as PerThing>::Inner;
+
+/// Get the upper type of a `PerThing`.
+pub type UpperOf<P> = <P as PerThing>::Upper;
+
+pub trait RationalArg:
+	Clone
+	+ Ord
+	+ ops::Div<Self, Output = Self>
+	+ ops::Rem<Self, Output = Self>
+	+ ops::Add<Self, Output = Self>
+	+ ops::AddAssign<Self>
+	+ Unsigned
+	+ Zero
+	+ One
+	+ crate::MultiplyRational
+{
+}
+
+impl<
+		T: Clone
+			+ Ord
+			+ ops::Div<Self, Output = Self>
+			+ ops::Rem<Self, Output = Self>
+			+ ops::Add<Self, Output = Self>
+			+ ops::AddAssign<Self>
+			+ Unsigned
+			+ Zero
+			+ One
+			+ crate::MultiplyRational,
+	> RationalArg for T
+{
+}
+
+pub trait MultiplyArg:
+	Clone
+	+ ops::Rem<Self, Output = Self>
+	+ ops::Div<Self, Output = Self>
+	+ ops::Mul<Self, Output = Self>
+	+ ops::Add<Self, Output = Self>
+	+ Unsigned
+{
+}
+
+impl<
+		T: Clone
+			+ ops::Rem<Self, Output = Self>
+			+ ops::Div<Self, Output = Self>
+			+ ops::Mul<Self, Output = Self>
+			+ ops::Add<Self, Output = Self>
+			+ Unsigned,
+	> MultiplyArg for T
+{
+}
+
+pub trait ReciprocalArg: MultiplyArg + Saturating {}
+impl<T: MultiplyArg + Saturating> ReciprocalArg for T {}
+
+/// Something that implements a fixed point ration with an arbitrary granularity `X`, as _parts per
+/// `X`_.
+pub trait PerThing:
+	Sized
+	+ Saturating
+	+ Copy
+	+ Default
+	+ Eq
+	+ PartialEq
+	+ Ord
+	+ PartialOrd
+	+ Bounded
+	+ fmt::Debug
+	+ ops::Div<Output = Self>
+	+ ops::Mul<Output = Self>
+	+ Pow<usize, Output = Self>
+{
+	/// The data type used to build this per-thingy.
+	type Inner: BaseArithmetic + Unsigned + Copy + Into<u128> + fmt::Debug + crate::MultiplyRational;
+
+	/// A data type larger than `Self::Inner`, used to avoid overflow in some computations.
+	/// It must be able to compute `ACCURACY^2`.
+	type Upper: BaseArithmetic
+		+ Copy
+		+ From<Self::Inner>
+		+ TryInto<Self::Inner>
+		+ UniqueSaturatedInto<Self::Inner>
+		+ Unsigned
+		+ fmt::Debug
+		+ crate::MultiplyRational;
+
+	/// The accuracy of this type.
+	const ACCURACY: Self::Inner;
+
+	/// Equivalent to `Self::from_parts(0)`.
+	fn zero() -> Self {
+		Self::from_parts(Self::Inner::zero())
+	}
+
+	/// Return `true` if this is nothing.
+	fn is_zero(&self) -> bool {
+		self.deconstruct() == Self::Inner::zero()
+	}
+
+	/// Equivalent to `Self::from_parts(Self::ACCURACY)`.
+	fn one() -> Self {
+		Self::from_parts(Self::ACCURACY)
+	}
+
+	/// Return `true` if this is one.
+	fn is_one(&self) -> bool {
+		self.deconstruct() == Self::ACCURACY
+	}
+
+	/// Return the next lower value to `self` or `self` if it is already zero.
+	fn less_epsilon(self) -> Self {
+		if self.is_zero() {
+			return self
+		}
+		Self::from_parts(self.deconstruct() - One::one())
+	}
+
+	/// Return the next lower value to `self` or an error with the same value if `self` is already
+	/// zero.
+	fn try_less_epsilon(self) -> Result<Self, Self> {
+		if self.is_zero() {
+			return Err(self)
+		}
+		Ok(Self::from_parts(self.deconstruct() - One::one()))
+	}
+
+	/// Return the next higher value to `self` or `self` if it is already one.
+	fn plus_epsilon(self) -> Self {
+		if self.is_one() {
+			return self
+		}
+		Self::from_parts(self.deconstruct() + One::one())
+	}
+
+	/// Return the next higher value to `self` or an error with the same value if `self` is already
+	/// one.
+	fn try_plus_epsilon(self) -> Result<Self, Self> {
+		if self.is_one() {
+			return Err(self)
+		}
+		Ok(Self::from_parts(self.deconstruct() + One::one()))
+	}
+
+	/// Build this type from a percent. Equivalent to `Self::from_parts(x * Self::ACCURACY / 100)`
+	/// but more accurate and can cope with potential type overflows.
+	fn from_percent(x: Self::Inner) -> Self {
+		let a: Self::Inner = x.min(100.into());
+		let b: Self::Inner = 100.into();
+		Self::from_rational::<Self::Inner>(a, b)
+	}
+
+	/// Return the product of multiplication of this value by itself.
+	fn square(self) -> Self {
+		let p = Self::Upper::from(self.deconstruct());
+		let q = Self::Upper::from(Self::ACCURACY);
+		Self::from_rational::<Self::Upper>(p * p, q * q)
+	}
+
+	/// Return the part left when `self` is saturating-subtracted from `Self::one()`.
+	fn left_from_one(self) -> Self {
+		Self::one().saturating_sub(self)
+	}
+
+	/// Multiplication that always rounds down to a whole number. The standard `Mul` rounds to the
+	/// nearest whole number.
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing};
+	/// # fn main () {
+	/// // round to nearest
+	/// assert_eq!(Percent::from_percent(34) * 10u64, 3);
+	/// assert_eq!(Percent::from_percent(36) * 10u64, 4);
+	///
+	/// // round down
+	/// assert_eq!(Percent::from_percent(34).mul_floor(10u64), 3);
+	/// assert_eq!(Percent::from_percent(36).mul_floor(10u64), 3);
+	/// # }
+	/// ```
+	fn mul_floor<N>(self, b: N) -> N
+	where
+		N: MultiplyArg + UniqueSaturatedInto<Self::Inner>,
+		Self::Inner: Into<N>,
+	{
+		overflow_prune_mul::<N, Self>(b, self.deconstruct(), Rounding::Down)
+	}
+
+	/// Multiplication that always rounds the result up to a whole number. The standard `Mul`
+	/// rounds to the nearest whole number.
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing};
+	/// # fn main () {
+	/// // round to nearest
+	/// assert_eq!(Percent::from_percent(34) * 10u64, 3);
+	/// assert_eq!(Percent::from_percent(36) * 10u64, 4);
+	///
+	/// // round up
+	/// assert_eq!(Percent::from_percent(34).mul_ceil(10u64), 4);
+	/// assert_eq!(Percent::from_percent(36).mul_ceil(10u64), 4);
+	/// # }
+	/// ```
+	fn mul_ceil<N>(self, b: N) -> N
+	where
+		N: MultiplyArg + UniqueSaturatedInto<Self::Inner>,
+		Self::Inner: Into<N>,
+	{
+		overflow_prune_mul::<N, Self>(b, self.deconstruct(), Rounding::Up)
+	}
+
+	/// Saturating multiplication by the reciprocal of `self`.	The result is rounded to the
+	/// nearest whole number and saturates at the numeric bounds instead of overflowing.
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing};
+	/// # fn main () {
+	/// assert_eq!(Percent::from_percent(50).saturating_reciprocal_mul(10u64), 20);
+	/// # }
+	/// ```
+	fn saturating_reciprocal_mul<N>(self, b: N) -> N
+	where
+		N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
+		Self::Inner: Into<N>,
+	{
+		saturating_reciprocal_mul::<N, Self>(b, self.deconstruct(), Rounding::NearestPrefUp)
+	}
+
+	/// Saturating multiplication by the reciprocal of `self`.	The result is rounded down to the
+	/// nearest whole number and saturates at the numeric bounds instead of overflowing.
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing};
+	/// # fn main () {
+	/// // round to nearest
+	/// assert_eq!(Percent::from_percent(60).saturating_reciprocal_mul(10u64), 17);
+	/// // round down
+	/// assert_eq!(Percent::from_percent(60).saturating_reciprocal_mul_floor(10u64), 16);
+	/// # }
+	/// ```
+	fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N
+	where
+		N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
+		Self::Inner: Into<N>,
+	{
+		saturating_reciprocal_mul::<N, Self>(b, self.deconstruct(), Rounding::Down)
+	}
+
+	/// Saturating multiplication by the reciprocal of `self`.	The result is rounded up to the
+	/// nearest whole number and saturates at the numeric bounds instead of overflowing.
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing};
+	/// # fn main () {
+	/// // round to nearest
+	/// assert_eq!(Percent::from_percent(61).saturating_reciprocal_mul(10u64), 16);
+	/// // round up
+	/// assert_eq!(Percent::from_percent(61).saturating_reciprocal_mul_ceil(10u64), 17);
+	/// # }
+	/// ```
+	fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N
+	where
+		N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
+		Self::Inner: Into<N>,
+	{
+		saturating_reciprocal_mul::<N, Self>(b, self.deconstruct(), Rounding::Up)
+	}
+
+	/// Consume self and return the number of parts per thing.
+	fn deconstruct(self) -> Self::Inner;
+
+	/// Build this type from a number of parts per thing.
+	fn from_parts(parts: Self::Inner) -> Self;
+
+	/// Converts a fraction into `Self`.
+	#[cfg(feature = "std")]
+	fn from_float(x: f64) -> Self;
+
+	/// Same as `Self::from_float`.
+	#[deprecated = "Use from_float instead"]
+	#[cfg(feature = "std")]
+	fn from_fraction(x: f64) -> Self {
+		Self::from_float(x)
+	}
+
+	/// Approximate the fraction `p/q` into a per-thing fraction. This will never overflow.
+	///
+	/// The computation of this approximation is performed in the generic type `N`. Given
+	/// `M` as the data type that can hold the maximum value of this per-thing (e.g. u32 for
+	/// perbill), this can only work if `N == M` or `N: From<M> + TryInto<M>`.
+	///
+	/// Note that this always rounds _down_, i.e.
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing};
+	/// # fn main () {
+	/// // 989/1000 is technically closer to 99%.
+	/// assert_eq!(
+	/// 	Percent::from_rational(989u64, 1000),
+	/// 	Percent::from_parts(98),
+	/// );
+	/// # }
+	/// ```
+	fn from_rational<N>(p: N, q: N) -> Self
+	where
+		N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
+		Self::Inner: Into<N>,
+	{
+		Self::from_rational_with_rounding(p, q, Rounding::Down).unwrap_or_else(|_| Self::one())
+	}
+
+	/// Approximate the fraction `p/q` into a per-thing fraction.
+	///
+	/// The computation of this approximation is performed in the generic type `N`. Given
+	/// `M` as the data type that can hold the maximum value of this per-thing (e.g. `u32` for
+	/// `Perbill`), this can only work if `N == M` or `N: From<M> + TryInto<M>`.
+	///
+	/// In the case of an overflow (or divide by zero), an `Err` is returned.
+	///
+	/// Rounding is determined by the parameter `rounding`, i.e.
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing, Rounding::*};
+	/// # fn main () {
+	/// // 989/100 is technically closer to 99%.
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(989u64, 1000, Down).unwrap(),
+	/// 	Percent::from_parts(98),
+	/// );
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(984u64, 1000, NearestPrefUp).unwrap(),
+	/// 	Percent::from_parts(98),
+	/// );
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(985u64, 1000, NearestPrefDown).unwrap(),
+	/// 	Percent::from_parts(98),
+	/// );
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(985u64, 1000, NearestPrefUp).unwrap(),
+	/// 	Percent::from_parts(99),
+	/// );
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(986u64, 1000, NearestPrefDown).unwrap(),
+	/// 	Percent::from_parts(99),
+	/// );
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(981u64, 1000, Up).unwrap(),
+	/// 	Percent::from_parts(99),
+	/// );
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(1001u64, 1000, Up),
+	/// 	Err(()),
+	/// );
+	/// # }
+	/// ```
+	///
+	/// ```rust
+	/// # use sp_arithmetic::{Percent, PerThing, Rounding::*};
+	/// # fn main () {
+	/// assert_eq!(
+	/// 	Percent::from_rational_with_rounding(981u64, 1000, Up).unwrap(),
+	/// 	Percent::from_parts(99),
+	/// );
+	/// # }
+	/// ```
+	fn from_rational_with_rounding<N>(p: N, q: N, rounding: Rounding) -> Result<Self, ()>
+	where
+		N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
+		Self::Inner: Into<N>;
+
+	/// Same as `Self::from_rational`.
+	#[deprecated = "Use from_rational instead"]
+	fn from_rational_approximation<N>(p: N, q: N) -> Self
+	where
+		N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
+		Self::Inner: Into<N>,
+	{
+		Self::from_rational(p, q)
+	}
+}
+
+/// The rounding method to use for unsigned quantities.
+#[derive(Copy, Clone, sp_std::fmt::Debug)]
+pub enum Rounding {
+	// Towards infinity.
+	Up,
+	// Towards zero.
+	Down,
+	// Nearest integer, rounding as `Up` when equidistant.
+	NearestPrefUp,
+	// Nearest integer, rounding as `Down` when equidistant.
+	NearestPrefDown,
+}
+
+/// The rounding method to use.
+#[derive(Copy, Clone, sp_std::fmt::Debug)]
+pub enum SignedRounding {
+	// Towards positive infinity.
+	High,
+	// Towards negative infinity.
+	Low,
+	// Nearest integer, rounding as `High` when exactly equidistant.
+	NearestPrefHigh,
+	// Nearest integer, rounding as `Low` when exactly equidistant.
+	NearestPrefLow,
+	// Away from zero (up when positive, down when negative). When positive, equivalent to `High`.
+	Major,
+	// Towards zero (down when positive, up when negative). When positive, equivalent to `Low`.
+	Minor,
+	// Nearest integer, rounding as `Major` when exactly equidistant.
+	NearestPrefMajor,
+	// Nearest integer, rounding as `Minor` when exactly equidistant.
+	NearestPrefMinor,
+}
+
+impl Rounding {
+	/// Returns the value for `Rounding` which would give the same result ignorant of the sign.
+	pub const fn from_signed(rounding: SignedRounding, negative: bool) -> Self {
+		use Rounding::*;
+		use SignedRounding::*;
+		match (rounding, negative) {
+			(Low, true) | (Major, _) | (High, false) => Up,
+			(High, true) | (Minor, _) | (Low, false) => Down,
+			(NearestPrefMajor, _) | (NearestPrefHigh, false) | (NearestPrefLow, true) =>
+				NearestPrefUp,
+			(NearestPrefMinor, _) | (NearestPrefLow, false) | (NearestPrefHigh, true) =>
+				NearestPrefDown,
+		}
+	}
+}
+
+/// Saturating reciprocal multiplication. Compute `x / self`, saturating at the numeric
+/// bounds instead of overflowing.
+fn saturating_reciprocal_mul<N, P>(x: N, part: P::Inner, rounding: Rounding) -> N
+where
+	N: Clone
+		+ UniqueSaturatedInto<P::Inner>
+		+ ops::Div<N, Output = N>
+		+ ops::Mul<N, Output = N>
+		+ ops::Add<N, Output = N>
+		+ ops::Rem<N, Output = N>
+		+ Saturating
+		+ Unsigned,
+	P: PerThing,
+	P::Inner: Into<N>,
+{
+	let maximum: N = P::ACCURACY.into();
+	let c = rational_mul_correction::<N, P>(x.clone(), P::ACCURACY, part, rounding);
+	(x / part.into()).saturating_mul(maximum).saturating_add(c)
+}
+
+/// Overflow-prune multiplication. Accurately multiply a value by `self` without overflowing.
+fn overflow_prune_mul<N, P>(x: N, part: P::Inner, rounding: Rounding) -> N
+where
+	N: MultiplyArg + UniqueSaturatedInto<P::Inner>,
+	P: PerThing,
+	P::Inner: Into<N>,
+{
+	let maximum: N = P::ACCURACY.into();
+	let part_n: N = part.into();
+	let c = rational_mul_correction::<N, P>(x.clone(), part, P::ACCURACY, rounding);
+	(x / maximum) * part_n + c
+}
+
+/// Compute the error due to integer division in the expression `x / denom * numer`.
+///
+/// Take the remainder of `x / denom` and multiply by  `numer / denom`. The result can be added
+/// to `x / denom * numer` for an accurate result.
+fn rational_mul_correction<N, P>(x: N, numer: P::Inner, denom: P::Inner, rounding: Rounding) -> N
+where
+	N: MultiplyArg + UniqueSaturatedInto<P::Inner>,
+	P: PerThing,
+	P::Inner: Into<N>,
+{
+	let numer_upper = P::Upper::from(numer);
+	let denom_n: N = denom.into();
+	let denom_upper = P::Upper::from(denom);
+	let rem = x.rem(denom_n);
+	// `rem` is less than `denom`, which fits in `P::Inner`.
+	let rem_inner = rem.saturated_into::<P::Inner>();
+	// `P::Upper` always fits `P::Inner::max_value().pow(2)`, thus it fits `rem * numer`.
+	let rem_mul_upper = P::Upper::from(rem_inner) * numer_upper;
+	// `rem` is less than `denom`, so `rem * numer / denom` is less than `numer`, which fits in
+	// `P::Inner`.
+	let mut rem_mul_div_inner = (rem_mul_upper / denom_upper).saturated_into::<P::Inner>();
+	match rounding {
+		// Already rounded down
+		Rounding::Down => {},
+		// Round up if the fractional part of the result is non-zero.
+		Rounding::Up => {
+			if rem_mul_upper % denom_upper > 0.into() {
+				// `rem * numer / denom` is less than `numer`, so this will not overflow.
+				rem_mul_div_inner += 1.into();
+			}
+		},
+		Rounding::NearestPrefDown => {
+			if rem_mul_upper % denom_upper > denom_upper / 2.into() {
+				// `rem * numer / denom` is less than `numer`, so this will not overflow.
+				rem_mul_div_inner += 1.into();
+			}
+		},
+		Rounding::NearestPrefUp => {
+			if rem_mul_upper % denom_upper >= denom_upper / 2.into() + denom_upper % 2.into() {
+				// `rem * numer / denom` is less than `numer`, so this will not overflow.
+				rem_mul_div_inner += 1.into();
+			}
+		},
+	}
+	rem_mul_div_inner.into()
+}
+
+macro_rules! implement_per_thing {
+	(
+		$name:ident,
+		$test_mod:ident,
+		[$($test_units:tt),+],
+		$max:tt,
+		$type:ty,
+		$upper_type:ty,
+		$title:expr $(,)?
+	) => {
+		/// A fixed point representation of a number in the range [0, 1].
+		///
+		#[doc = $title]
+		#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+		#[derive(Encode, Copy, Clone, PartialEq, Eq, codec::MaxEncodedLen, PartialOrd, Ord, scale_info::TypeInfo)]
+		pub struct $name($type);
+
+		/// Implementation makes any compact encoding of `PerThing::Inner` valid,
+		/// when decoding it will saturate up to `PerThing::ACCURACY`.
+		impl CompactAs for $name {
+			type As = $type;
+			fn encode_as(&self) -> &Self::As {
+				&self.0
+			}
+			fn decode_from(x: Self::As) -> Result<Self, codec::Error> {
+				// Saturates if `x` is more than `$max` internally.
+				Ok(Self::from_parts(x))
+			}
+		}
+
+		impl From<codec::Compact<$name>> for $name {
+			fn from(x: codec::Compact<$name>) -> $name {
+				x.0
+			}
+		}
+
+		#[cfg(feature = "std")]
+		impl sp_std::fmt::Debug for $name {
+			fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+				if $max == <$type>::max_value() {
+					// Not a power of ten: show as N/D and approx %
+					let pc = (self.0 as f64) / (self.0 as f64) * 100f64;
+					write!(fmt, "{:.2}% ({}/{})", pc, self.0, $max)
+				} else {
+					// A power of ten: calculate exact percent
+					let divisor = $max / 100;
+					let units = self.0 / divisor;
+					let rest = self.0 % divisor;
+					write!(fmt, "{}", units)?;
+					if rest > 0 {
+						write!(fmt, ".")?;
+						let mut m = $max / 100;
+						while rest % m > 0 {
+							m /= 10;
+							write!(fmt, "{:01}", rest / m % 10)?;
+						}
+					}
+					write!(fmt, "%")
+				}
+			}
+		}
+
+		#[cfg(not(feature = "std"))]
+		impl sp_std::fmt::Debug for $name {
+			fn fmt(&self, fmt: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+				if $max == <$type>::max_value() {
+					// Not a power of ten: show as N/D and approx %
+					write!(fmt, "{}/{}", self.0, $max)
+				} else {
+					// A power of ten: calculate exact percent
+					let units = self.0 / ($max / 100);
+					let rest = self.0 % ($max / 100);
+					write!(fmt, "{}", units)?;
+					if rest > 0 {
+						write!(fmt, ".")?;
+						let mut m = $max / 100;
+						while rest % m > 0 {
+							m /= 10;
+							write!(fmt, "{:01}", rest / m % 10)?;
+						}
+					}
+					write!(fmt, "%")
+				}
+			}
+		}
+
+		impl PerThing for $name {
+			type Inner = $type;
+			type Upper = $upper_type;
+
+			const ACCURACY: Self::Inner = $max;
+
+			/// Consume self and return the number of parts per thing.
+			fn deconstruct(self) -> Self::Inner { self.0 }
+
+			/// Build this type from a number of parts per thing.
+			fn from_parts(parts: Self::Inner) -> Self { Self(parts.min($max)) }
+
+			/// NOTE: saturate to 0 or 1 if x is beyond `[0, 1]`
+			#[cfg(feature = "std")]
+			fn from_float(x: f64) -> Self {
+				Self::from_parts((x.max(0.).min(1.) * $max as f64) as Self::Inner)
+			}
+
+			fn from_rational_with_rounding<N>(p: N, q: N, r: Rounding) -> Result<Self, ()>
+			where
+				N: Clone
+					+ Ord
+					+ TryInto<Self::Inner>
+					+ TryInto<Self::Upper>
+					+ ops::Div<N, Output = N>
+					+ ops::Rem<N, Output = N>
+					+ ops::Add<N, Output = N>
+					+ ops::AddAssign<N>
+					+ Unsigned
+					+ Zero
+					+ One
+					+ $crate::MultiplyRational,
+				Self::Inner: Into<N>
+			{
+				// q cannot be zero.
+				if q.is_zero() { return Err(()) }
+				// p should not be bigger than q.
+				if p > q { return Err(()) }
+
+				let max: N = $max.into();
+				max.multiply_rational(p, q, r).ok_or(())?.try_into().map(|x| $name(x)).map_err(|_| ())
+			}
+		}
+
+		impl $name {
+			/// From an explicitly defined number of parts per maximum of the type.
+			///
+			// needed only for peru16. Since peru16 is the only type in which $max ==
+			// $type::max_value(), rustc is being a smart-a** here by warning that the comparison
+			// is not needed.
+			#[allow(unused_comparisons)]
+			pub const fn from_parts(parts: $type) -> Self {
+				Self([parts, $max][(parts > $max) as usize])
+			}
+
+			/// Converts a percent into `Self`. Equal to `x / 100`.
+			///
+			/// This can be created at compile time.
+			pub const fn from_percent(x: $type) -> Self {
+				Self(([x, 100][(x > 100) as usize] as $upper_type * $max as $upper_type / 100) as $type)
+			}
+
+			/// See [`PerThing::one`]
+			pub const fn one() -> Self {
+				Self::from_parts($max)
+			}
+
+			/// See [`PerThing::is_one`].
+			pub fn is_one(&self) -> bool {
+				PerThing::is_one(self)
+			}
+
+			/// See [`PerThing::zero`].
+			pub const fn zero() -> Self {
+				Self::from_parts(0)
+			}
+
+			/// See [`PerThing::is_zero`].
+			pub fn is_zero(&self) -> bool {
+				PerThing::is_zero(self)
+			}
+
+			/// See [`PerThing::deconstruct`].
+			pub const fn deconstruct(self) -> $type {
+				self.0
+			}
+
+			/// See [`PerThing::square`].
+			pub fn square(self) -> Self {
+				PerThing::square(self)
+			}
+
+			/// See [`PerThing::from_float`].
+			#[cfg(feature = "std")]
+			pub fn from_float(x: f64) -> Self {
+				<Self as PerThing>::from_float(x)
+			}
+
+			/// See [`PerThing::from_rational`].
+			#[deprecated = "Use `PerThing::from_rational` instead"]
+			pub fn from_rational_approximation<N>(p: N, q: N) -> Self
+			where
+				N: RationalArg+ TryInto<$type> + TryInto<$upper_type>,
+				$type: Into<N>
+			{
+				<Self as PerThing>::from_rational(p, q)
+			}
+
+			/// See [`PerThing::from_rational`].
+			pub fn from_rational<N>(p: N, q: N) -> Self
+			where
+				N: RationalArg+ TryInto<$type> + TryInto<$upper_type>,
+				$type: Into<N>
+			{
+				<Self as PerThing>::from_rational(p, q)
+			}
+
+			/// Integer multiplication with another value, saturating at 1.
+			pub fn int_mul(self, b: $type) -> Self {
+				PerThing::from_parts(self.0.saturating_mul(b))
+			}
+
+			/// Integer division with another value, rounding down.
+			pub fn int_div(self, b: Self) -> $type {
+				self.0 / b.0
+			}
+
+			/// See [`PerThing::mul_floor`].
+			pub fn mul_floor<N>(self, b: N) -> N
+				where
+					N: MultiplyArg + UniqueSaturatedInto<$type>,
+					$type: Into<N>,
+
+			{
+				PerThing::mul_floor(self, b)
+			}
+
+			/// See [`PerThing::mul_ceil`].
+			pub fn mul_ceil<N>(self, b: N) -> N
+				where
+					N: MultiplyArg + UniqueSaturatedInto<$type>,
+					$type: Into<N>,
+			{
+				PerThing::mul_ceil(self, b)
+			}
+
+			/// See [`PerThing::saturating_reciprocal_mul`].
+			pub fn saturating_reciprocal_mul<N>(self, b: N) -> N
+				where
+					N: ReciprocalArg + UniqueSaturatedInto<$type>,
+					$type: Into<N>,
+			{
+				PerThing::saturating_reciprocal_mul(self, b)
+			}
+
+			/// See [`PerThing::saturating_reciprocal_mul_floor`].
+			pub fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N
+				where
+					N: ReciprocalArg + UniqueSaturatedInto<$type>,
+					$type: Into<N>,
+			{
+				PerThing::saturating_reciprocal_mul_floor(self, b)
+			}
+
+			/// See [`PerThing::saturating_reciprocal_mul_ceil`].
+			pub fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N
+				where
+					N: ReciprocalArg + UniqueSaturatedInto<$type>,
+					$type: Into<N>,
+			{
+				PerThing::saturating_reciprocal_mul_ceil(self, b)
+			}
+
+			/// Saturating division. Compute `self / rhs`, saturating at one if `rhs < self`.
+			///
+			/// The `rounding` method must be specified. e.g.:
+			///
+			/// ```rust
+			/// # use sp_arithmetic::{Percent, PerThing, Rounding::*};
+			/// # fn main () {
+			/// let pc = |x| Percent::from_percent(x);
+			/// assert_eq!(
+			/// 	pc(2).saturating_div(pc(3), Down),
+			/// 	pc(66),
+			/// );
+			/// assert_eq!(
+			/// 	pc(1).saturating_div(pc(3), NearestPrefUp),
+			/// 	pc(33),
+			/// );
+			/// assert_eq!(
+			/// 	pc(2).saturating_div(pc(3), NearestPrefDown),
+			/// 	pc(67),
+			/// );
+			/// assert_eq!(
+			/// 	pc(1).saturating_div(pc(3), Up),
+			/// 	pc(34),
+			/// );
+			/// # }
+			/// ```
+			pub fn saturating_div(self, rhs: Self, r: Rounding) -> Self {
+				let p = self.0;
+				let q = rhs.0;
+				Self::from_rational_with_rounding(p, q, r).unwrap_or_else(|_| Self::one())
+			}
+		}
+
+		impl Saturating for $name {
+			/// Saturating addition. Compute `self + rhs`, saturating at the numeric bounds instead of
+			/// overflowing. This operation is lossless if it does not saturate.
+			fn saturating_add(self, rhs: Self) -> Self {
+				// defensive-only: since `$max * 2 < $type::max_value()`, this can never overflow.
+				Self::from_parts(self.0.saturating_add(rhs.0))
+			}
+
+			/// Saturating subtraction. Compute `self - rhs`, saturating at the numeric bounds instead of
+			/// overflowing. This operation is lossless if it does not saturate.
+			fn saturating_sub(self, rhs: Self) -> Self {
+				Self::from_parts(self.0.saturating_sub(rhs.0))
+			}
+
+			/// Saturating multiply. Compute `self * rhs`, saturating at the numeric bounds instead of
+			/// overflowing. This operation is lossy.
+			fn saturating_mul(self, rhs: Self) -> Self {
+				self * rhs
+			}
+
+			/// Saturating exponentiation. Computes `self.pow(exp)`, saturating at the numeric
+			/// bounds instead of overflowing. This operation is lossy.
+			fn saturating_pow(self, exp: usize) -> Self {
+				self.pow(exp)
+			}
+		}
+
+		impl codec::Decode for $name {
+			fn decode<I: codec::Input>(input: &mut I) -> Result<Self, codec::Error> {
+				let inner = <$type as codec::Decode>::decode(input)?;
+
+				if inner <= <Self as PerThing>::ACCURACY {
+					Ok(Self(inner))
+				} else {
+					Err("Value is greater than allowed maximum!".into())
+				}
+			}
+		}
+
+		impl Bounded for $name {
+			fn min_value() -> Self {
+				<Self as PerThing>::zero()
+			}
+
+			fn max_value() -> Self {
+				<Self as PerThing>::one()
+			}
+		}
+
+		impl ops::Mul for $name {
+			type Output = Self;
+
+			fn mul(self, rhs: Self) -> Self::Output {
+				let a = self.0 as $upper_type;
+				let b = rhs.0 as $upper_type;
+				let m = <$upper_type>::from($max);
+				let parts = a * b / m;
+				// This will always fit into $type.
+				Self::from_parts(parts as $type)
+			}
+		}
+
+		impl Pow<usize> for $name {
+			type Output = Self;
+
+			fn pow(mut self, exp: usize) -> Self::Output {
+				if exp == 0 || self.is_one() {
+					return Self::one()
+				}
+
+				let mut result = self;
+				let mut exp = exp - 1;
+				while exp > 0 && !result.is_zero() {
+					if exp % 2 != 0 {
+						result = result * self;
+						exp -= 1;
+					}
+					self = self.square();
+					exp /= 2;
+				}
+				result
+			}
+		}
+
+		impl ops::Div for $name {
+			type Output = Self;
+
+			fn div(self, rhs: Self) -> Self::Output {
+				let p = self.0;
+				let q = rhs.0;
+				Self::from_rational(p, q)
+			}
+		}
+
+		impl Default for $name {
+			fn default() -> Self {
+				<Self as PerThing>::zero()
+			}
+		}
+
+		/// Non-overflow multiplication.
+		///
+		/// This is tailored to be used with a balance type.
+		impl<N> ops::Mul<N> for $name
+		where
+			N: Clone + UniqueSaturatedInto<$type> + ops::Rem<N, Output=N>
+				+ ops::Div<N, Output=N> + ops::Mul<N, Output=N> + ops::Add<N, Output=N> + Unsigned,
+			$type: Into<N>,
+		{
+			type Output = N;
+			fn mul(self, b: N) -> Self::Output {
+				overflow_prune_mul::<N, Self>(b, self.deconstruct(), Rounding::NearestPrefDown)
+			}
+		}
+
+		impl<N> ops::Div<N> for $name where $type: TryFrom<N> {
+			type Output = Self;
+			fn div(self, b: N) -> Self::Output {
+				<$type>::try_from(b).map_or(Self::zero(), |d| Self::from_parts(self.0 / d))
+			}
+		}
+
+		impl Add<Self> for $name {
+			type Output = $name;
+
+			// For PerU16, $max == u16::MAX, so we need this `allow`.
+			#[allow(unused_comparisons)]
+			#[inline]
+			fn add(self, rhs: Self) -> Self::Output {
+				let inner = self.deconstruct().add(rhs.deconstruct());
+				debug_assert!(inner <= $max);
+				$name::from_parts(inner)
+			}
+		}
+
+		impl CheckedAdd for $name {
+			// For PerU16, $max == u16::MAX, so we need this `allow`.
+			#[allow(unused_comparisons)]
+			#[inline]
+			fn checked_add(&self, rhs: &Self) -> Option<Self> {
+				self.deconstruct()
+					.checked_add(rhs.deconstruct())
+					.map(|inner| if inner > $max { None } else { Some($name::from_parts(inner)) })
+					.flatten()
+			}
+		}
+
+		impl Sub<Self> for $name {
+			type Output = $name;
+
+			#[inline]
+			fn sub(self, rhs: Self) -> Self::Output {
+				$name::from_parts(self.deconstruct().sub(rhs.deconstruct()))
+			}
+		}
+
+		impl CheckedSub for $name {
+			#[inline]
+			fn checked_sub(&self, v: &Self) -> Option<Self> {
+				self.deconstruct().checked_sub(v.deconstruct()).map($name::from_parts)
+			}
+		}
+
+		impl SaturatingAdd for $name {
+			#[inline]
+			fn saturating_add(&self, v: &Self) -> Self {
+				$name::from_parts(self.deconstruct().saturating_add(v.deconstruct()))
+			}
+		}
+
+		impl SaturatingSub for $name {
+			#[inline]
+			fn saturating_sub(&self, v: &Self) -> Self {
+				$name::from_parts(self.deconstruct().saturating_sub(v.deconstruct()))
+			}
+		}
+
+		/// # Note
+		/// CheckedMul will never fail for PerThings.
+		impl CheckedMul for $name {
+			#[inline]
+			fn checked_mul(&self, rhs: &Self) -> Option<Self> {
+				Some(*self * *rhs)
+			}
+		}
+
+		impl $crate::traits::Zero for $name {
+			fn zero() -> Self {
+				Self::zero()
+			}
+
+			fn is_zero(&self) -> bool {
+				self == &Self::zero()
+			}
+		}
+
+		impl $crate::traits::One for $name {
+			fn one() -> Self {
+				Self::one()
+			}
+		}
+
+		#[cfg(test)]
+		mod $test_mod {
+			use codec::{Encode, Decode};
+			use super::{$name, Saturating, PerThing};
+			use crate::traits::Zero;
+
+			#[test]
+			fn macro_expanded_correctly() {
+				// needed for the `from_percent` to work. UPDATE: this is no longer needed; yet note
+				// that tests that use percentage or fractions such as $name::from_float(0.2) to
+				// create values will most likely be inaccurate when used with per_things that are
+				// not multiples of 100.
+				// assert!($max >= 100);
+				// assert!($max % 100 == 0);
+
+				// needed for `from_rational`
+				assert!(2 * ($max as $upper_type) < <$upper_type>::max_value());
+				assert!(<$upper_type>::from($max) < <$upper_type>::max_value());
+
+				// for something like percent they can be the same.
+				assert!((<$type>::max_value() as $upper_type) <= <$upper_type>::max_value());
+				assert!(<$upper_type>::from($max).checked_mul($max.into()).is_some());
+
+				// make sure saturating_pow won't overflow the upper type
+				assert!(<$upper_type>::from($max) * <$upper_type>::from($max) < <$upper_type>::max_value());
+			}
+
+			#[derive(Encode, Decode, PartialEq, Eq, Debug)]
+			struct WithCompact<T: codec::HasCompact> {
+				data: T,
+			}
+
+			#[test]
+			fn has_compact() {
+				let data = WithCompact { data: $name(1) };
+				let encoded = data.encode();
+				assert_eq!(data, WithCompact::<$name>::decode(&mut &encoded[..]).unwrap());
+			}
+
+			#[test]
+			fn compact_encoding() {
+				let tests = [
+					// assume all per_things have the size u8 at least.
+					(0 as $type, 1usize),
+					(1 as $type, 1usize),
+					(63, 1),
+					(64, 2),
+					(65, 2),
+					// (<$type>::max_value(), <$type>::max_value().encode().len() + 1)
+				];
+				for &(n, l) in &tests {
+					let compact: codec::Compact<$name> = $name(n).into();
+					let encoded = compact.encode();
+					assert_eq!(encoded.len(), l);
+					let decoded = <codec::Compact<$name>>::decode(&mut & encoded[..])
+						.unwrap();
+					let per_thingy: $name = decoded.into();
+					assert_eq!(per_thingy, $name(n));
+				}
+			}
+
+			#[test]
+			fn from_parts_cannot_overflow() {
+				assert_eq!(<$name>::from_parts($max.saturating_add(1)), <$name>::one());
+			}
+
+			#[test]
+			fn has_max_encoded_len() {
+				struct AsMaxEncodedLen<T: codec::MaxEncodedLen> {
+					_data: T,
+				}
+
+				let _ = AsMaxEncodedLen { _data: $name(1) };
+			}
+
+			#[test]
+			fn fail_on_invalid_encoded_value() {
+				let value = <$upper_type>::from($max) * 2;
+				let casted = value as $type;
+				let encoded = casted.encode();
+
+				// For types where `$max == $type::maximum()` we can not
+				if <$upper_type>::from(casted) == value {
+					assert_eq!(
+						$name::decode(&mut &encoded[..]),
+						Err("Value is greater than allowed maximum!".into()),
+					);
+				}
+			}
+
+			#[test]
+			fn per_thing_api_works() {
+				// some really basic stuff
+				assert_eq!($name::zero(), $name::from_parts(Zero::zero()));
+				assert_eq!($name::one(), $name::from_parts($max));
+				assert_eq!($name::ACCURACY, $max);
+
+				assert_eq!($name::from_percent(0), $name::from_parts(Zero::zero()));
+				assert_eq!($name::from_percent(10), $name::from_parts($max / 10));
+				assert_eq!($name::from_percent(50), $name::from_parts($max / 2));
+				assert_eq!($name::from_percent(100), $name::from_parts($max));
+				assert_eq!($name::from_percent(200), $name::from_parts($max));
+
+				assert_eq!($name::from_float(0.0), $name::from_parts(Zero::zero()));
+				assert_eq!($name::from_float(0.1), $name::from_parts($max / 10));
+				assert_eq!($name::from_float(1.0), $name::from_parts($max));
+				assert_eq!($name::from_float(2.0), $name::from_parts($max));
+				assert_eq!($name::from_float(-1.0), $name::from_parts(Zero::zero()));
+			}
+
+			#[test]
+			fn percent_trait_impl_works() {
+				assert_eq!(<$name as PerThing>::from_percent(0), $name::from_parts(Zero::zero()));
+				assert_eq!(<$name as PerThing>::from_percent(10), $name::from_parts($max / 10));
+				assert_eq!(<$name as PerThing>::from_percent(50), $name::from_parts($max / 2));
+				assert_eq!(<$name as PerThing>::from_percent(100), $name::from_parts($max));
+				assert_eq!(<$name as PerThing>::from_percent(200), $name::from_parts($max));
+			}
+
+			macro_rules! u256ify {
+				($val:expr) => {
+					Into::<U256>::into($val)
+				};
+			}
+
+			macro_rules! per_thing_mul_test {
+				($num_type:tt) => {
+					// multiplication from all sort of from_percent
+					assert_eq!(
+						$name::from_float(1.0) * $num_type::max_value(),
+						$num_type::max_value()
+					);
+					if $max % 100 == 0 {
+						assert_eq_error_rate!(
+							$name::from_percent(99) * $num_type::max_value(),
+							((Into::<U256>::into($num_type::max_value()) * 99u32) / 100u32).as_u128() as $num_type,
+							1,
+						);
+						assert_eq!(
+							$name::from_float(0.5) * $num_type::max_value(),
+							$num_type::max_value() / 2,
+						);
+						assert_eq_error_rate!(
+							$name::from_percent(1) * $num_type::max_value(),
+							$num_type::max_value() / 100,
+							1,
+						);
+					} else {
+						assert_eq!(
+							$name::from_float(0.99) * <$num_type>::max_value(),
+							(
+								(
+									u256ify!($name::from_float(0.99).0) *
+									u256ify!(<$num_type>::max_value()) /
+									u256ify!($max)
+								).as_u128()
+							) as $num_type,
+						);
+						assert_eq!(
+							$name::from_float(0.50) * <$num_type>::max_value(),
+							(
+								(
+									u256ify!($name::from_float(0.50).0) *
+									u256ify!(<$num_type>::max_value()) /
+									u256ify!($max)
+								).as_u128()
+							) as $num_type,
+						);
+						assert_eq!(
+							$name::from_float(0.01) * <$num_type>::max_value(),
+							(
+								(
+									u256ify!($name::from_float(0.01).0) *
+									u256ify!(<$num_type>::max_value()) /
+									u256ify!($max)
+								).as_u128()
+							) as $num_type,
+						);
+					}
+
+					assert_eq!($name::from_float(0.0) * $num_type::max_value(), 0);
+
+					// // multiplication with bounds
+					assert_eq!($name::one() * $num_type::max_value(), $num_type::max_value());
+					assert_eq!($name::zero() * $num_type::max_value(), 0);
+				}
+			}
+
+			#[test]
+			fn per_thing_mul_works() {
+				use primitive_types::U256;
+
+				// accuracy test
+				assert_eq!(
+					$name::from_rational(1 as $type, 3) * 30 as $type,
+					10,
+				);
+
+				$(per_thing_mul_test!($test_units);)*
+			}
+
+			#[test]
+			fn per_thing_mul_rounds_to_nearest_number() {
+				assert_eq!($name::from_percent(33) * 10u64, 3);
+				assert_eq!($name::from_percent(34) * 10u64, 3);
+				assert_eq!($name::from_percent(35) * 10u64, 3);
+				assert_eq!($name::from_percent(36) * 10u64, 4);
+			}
+
+			#[test]
+			fn per_thing_multiplication_with_large_number() {
+				use primitive_types::U256;
+				let max_minus_one = $max - 1;
+				assert_eq_error_rate!(
+					$name::from_parts(max_minus_one) * std::u128::MAX,
+					((Into::<U256>::into(std::u128::MAX) * max_minus_one) / $max).as_u128(),
+					1,
+				);
+			}
+
+			macro_rules! per_thing_from_rationale_approx_test {
+				($num_type:tt) => {
+					// within accuracy boundary
+					assert_eq!(
+						$name::from_rational(1 as $num_type, 0),
+						$name::one(),
+					);
+					assert_eq!(
+						$name::from_rational(1 as $num_type, 1),
+						$name::one(),
+					);
+					assert_eq_error_rate!(
+						$name::from_rational(1 as $num_type, 3).0,
+						$name::from_parts($max / 3).0,
+						2
+					);
+					assert_eq!(
+						$name::from_rational(1 as $num_type, 10),
+						$name::from_float(0.10),
+					);
+					assert_eq!(
+						$name::from_rational(1 as $num_type, 4),
+						$name::from_float(0.25),
+					);
+					assert_eq!(
+						$name::from_rational(1 as $num_type, 4),
+						$name::from_rational(2 as $num_type, 8),
+					);
+					// no accurate anymore but won't overflow.
+					assert_eq_error_rate!(
+						$name::from_rational(
+							$num_type::max_value() - 1,
+							$num_type::max_value()
+						).0 as $upper_type,
+						$name::one().0 as $upper_type,
+						2,
+					);
+					assert_eq_error_rate!(
+						$name::from_rational(
+							$num_type::max_value() / 3,
+							$num_type::max_value()
+						).0 as $upper_type,
+						$name::from_parts($max / 3).0 as $upper_type,
+						2,
+					);
+					assert_eq!(
+						$name::from_rational(1, $num_type::max_value()),
+						$name::zero(),
+					);
+				};
+			}
+
+			#[test]
+			fn per_thing_from_rationale_approx_works() {
+				// This is just to make sure something like Percent which _might_ get built from a
+				// u8 does not overflow in the context of this test.
+				let max_value = <$upper_type>::from($max);
+
+				// almost at the edge
+				assert_eq!(
+					$name::from_rational(max_value - 1, max_value + 1),
+					$name::from_parts($max - 2),
+				);
+				assert_eq!(
+					$name::from_rational(1, $max - 1),
+					$name::from_parts(1),
+				);
+				assert_eq!(
+					$name::from_rational(1, $max),
+					$name::from_parts(1),
+				);
+				assert_eq!(
+					$name::from_rational(2, 2 * max_value - 1),
+					$name::from_parts(1),
+				);
+				assert_eq!(
+					$name::from_rational(1, max_value + 1),
+					$name::zero(),
+				);
+				assert_eq!(
+					$name::from_rational(3 * max_value / 2, 3 * max_value),
+					$name::from_float(0.5),
+				);
+
+				$(per_thing_from_rationale_approx_test!($test_units);)*
+			}
+
+			#[test]
+			fn per_things_mul_operates_in_output_type() {
+				// assert_eq!($name::from_float(0.5) * 100u32, 50u32);
+				assert_eq!($name::from_float(0.5) * 100u64, 50u64);
+				assert_eq!($name::from_float(0.5) * 100u128, 50u128);
+			}
+
+			#[test]
+			fn per_thing_saturating_op_works() {
+				assert_eq_error_rate!(
+					$name::from_float(0.5).saturating_add($name::from_float(0.4)).0 as $upper_type,
+					$name::from_float(0.9).0 as $upper_type,
+					2,
+				);
+				assert_eq_error_rate!(
+					$name::from_float(0.5).saturating_add($name::from_float(0.5)).0 as $upper_type,
+					$name::one().0 as $upper_type,
+					2,
+				);
+				assert_eq!(
+					$name::from_float(0.6).saturating_add($name::from_float(0.5)),
+					$name::one(),
+				);
+
+				assert_eq_error_rate!(
+					$name::from_float(0.6).saturating_sub($name::from_float(0.5)).0 as $upper_type,
+					$name::from_float(0.1).0 as $upper_type,
+					2,
+				);
+				assert_eq!(
+					$name::from_float(0.6).saturating_sub($name::from_float(0.6)),
+					$name::from_float(0.0),
+				);
+				assert_eq!(
+					$name::from_float(0.6).saturating_sub($name::from_float(0.7)),
+					$name::from_float(0.0),
+				);
+
+				assert_eq_error_rate!(
+					$name::from_float(0.5).saturating_mul($name::from_float(0.5)).0 as $upper_type,
+					$name::from_float(0.25).0 as $upper_type,
+					2,
+				);
+				assert_eq_error_rate!(
+					$name::from_float(0.2).saturating_mul($name::from_float(0.2)).0 as $upper_type,
+					$name::from_float(0.04).0 as $upper_type,
+					2,
+				);
+				assert_eq_error_rate!(
+					$name::from_float(0.1).saturating_mul($name::from_float(0.1)).0 as $upper_type,
+					$name::from_float(0.01).0 as $upper_type,
+					1,
+				);
+			}
+
+			#[test]
+			fn per_thing_square_works() {
+				assert_eq!($name::from_float(1.0).square(), $name::from_float(1.0));
+				assert_eq!($name::from_float(0.5).square(), $name::from_float(0.25));
+				assert_eq!($name::from_float(0.1).square(), $name::from_float(0.01));
+				assert_eq!(
+					$name::from_float(0.02).square(),
+					$name::from_parts((4 * <$upper_type>::from($max) / 100 / 100) as $type)
+				);
+			}
+
+			#[test]
+			fn per_things_div_works() {
+				// normal
+				assert_eq_error_rate!(
+					($name::from_float(0.1) / $name::from_float(0.20)).0 as $upper_type,
+					$name::from_float(0.50).0 as $upper_type,
+					2,
+				);
+				assert_eq_error_rate!(
+					($name::from_float(0.1) / $name::from_float(0.10)).0 as $upper_type,
+					$name::from_float(1.0).0 as $upper_type,
+					2,
+				);
+				assert_eq_error_rate!(
+					($name::from_float(0.1) / $name::from_float(0.0)).0 as $upper_type,
+					$name::from_float(1.0).0 as $upper_type,
+					2,
+				);
+
+				// will not overflow
+				assert_eq_error_rate!(
+					($name::from_float(0.10) / $name::from_float(0.05)).0 as $upper_type,
+					$name::from_float(1.0).0 as $upper_type,
+					2,
+				);
+				assert_eq_error_rate!(
+					($name::from_float(1.0) / $name::from_float(0.5)).0 as $upper_type,
+					$name::from_float(1.0).0 as $upper_type,
+					2,
+				);
+			}
+
+			#[test]
+			fn saturating_pow_works() {
+				// x^0 == 1
+				assert_eq!(
+					$name::from_parts($max / 2).saturating_pow(0),
+					$name::from_parts($max),
+				);
+
+				// x^1 == x
+				assert_eq!(
+					$name::from_parts($max / 2).saturating_pow(1),
+					$name::from_parts($max / 2),
+				);
+
+				// x^2
+				assert_eq!(
+					$name::from_parts($max / 2).saturating_pow(2),
+					$name::from_parts($max / 2).square(),
+				);
+
+				// x^2 .. x^16
+				for n in 1..=16 {
+					assert_eq!(
+						$name::from_parts($max / 2).saturating_pow(n),
+						$name::from_parts(($max as u128 / 2u128.pow(n as u32)) as $type),
+					);
+				}
+
+				// 0^n == 0
+				assert_eq!(
+					$name::from_parts(0).saturating_pow(3),
+					$name::from_parts(0),
+				);
+
+				// 1^n == 1
+				assert_eq!(
+					$name::from_parts($max).saturating_pow(3),
+					$name::from_parts($max),
+				);
+
+				// (x < 1)^inf == 0 (where 2.pow(31) ~ inf)
+				assert_eq!(
+					$name::from_parts($max / 2).saturating_pow(2usize.pow(31)),
+					$name::from_parts(0),
+				);
+			}
+
+			#[test]
+			fn saturating_reciprocal_mul_works() {
+				// divide by 1
+				assert_eq!(
+					$name::from_parts($max).saturating_reciprocal_mul(<$type>::from(10u8)),
+					10,
+				);
+				// divide by 1/2
+				assert_eq!(
+					$name::from_parts($max / 2).saturating_reciprocal_mul(<$type>::from(10u8)),
+					20,
+				);
+				// saturate
+				assert_eq!(
+					$name::from_parts(1).saturating_reciprocal_mul($max),
+					<$type>::max_value(),
+				);
+				// round to nearest
+				assert_eq!(
+					$name::from_percent(60).saturating_reciprocal_mul(<$type>::from(10u8)),
+					17,
+				);
+				// round down
+				assert_eq!(
+					$name::from_percent(60).saturating_reciprocal_mul_floor(<$type>::from(10u8)),
+					16,
+				);
+				// round to nearest
+				assert_eq!(
+					$name::from_percent(61).saturating_reciprocal_mul(<$type>::from(10u8)),
+					16,
+				);
+				// round up
+				assert_eq!(
+					$name::from_percent(61).saturating_reciprocal_mul_ceil(<$type>::from(10u8)),
+					17,
+				);
+			}
+
+			#[test]
+			fn saturating_truncating_mul_works() {
+				assert_eq!(
+					$name::from_percent(49).mul_floor(10 as $type),
+					4,
+				);
+				let a: $upper_type = $name::from_percent(50).mul_floor(($max as $upper_type).pow(2));
+				let b: $upper_type = ($max as $upper_type).pow(2) / 2;
+				if $max % 2 == 0 {
+					assert_eq!(a, b);
+				} else {
+					// difference should be less that 1%, IE less than the error in `from_percent`
+					assert!(b - a < ($max as $upper_type).pow(2) / 100 as $upper_type);
+				}
+			}
+
+			#[test]
+			fn rational_mul_correction_works() {
+				assert_eq!(
+					super::rational_mul_correction::<$type, $name>(
+						<$type>::max_value(),
+						<$type>::max_value(),
+						<$type>::max_value(),
+						super::Rounding::NearestPrefDown,
+					),
+					0,
+				);
+				assert_eq!(
+					super::rational_mul_correction::<$type, $name>(
+						<$type>::max_value() - 1,
+						<$type>::max_value(),
+						<$type>::max_value(),
+						super::Rounding::NearestPrefDown,
+					),
+					<$type>::max_value() - 1,
+				);
+				assert_eq!(
+					super::rational_mul_correction::<$upper_type, $name>(
+						((<$type>::max_value() - 1) as $upper_type).pow(2),
+						<$type>::max_value(),
+						<$type>::max_value(),
+						super::Rounding::NearestPrefDown,
+					),
+					1,
+				);
+				// ((max^2 - 1) % max) * max / max == max - 1
+				assert_eq!(
+					super::rational_mul_correction::<$upper_type, $name>(
+						(<$type>::max_value() as $upper_type).pow(2) - 1,
+						<$type>::max_value(),
+						<$type>::max_value(),
+						super::Rounding::NearestPrefDown,
+					),
+					<$upper_type>::from((<$type>::max_value() - 1)),
+				);
+				// (max % 2) * max / 2 == max / 2
+				assert_eq!(
+					super::rational_mul_correction::<$upper_type, $name>(
+						(<$type>::max_value() as $upper_type).pow(2),
+						<$type>::max_value(),
+						2 as $type,
+						super::Rounding::NearestPrefDown,
+					),
+					<$type>::max_value() as $upper_type / 2,
+				);
+				// ((max^2 - 1) % max) * 2 / max == 2 (rounded up)
+				assert_eq!(
+					super::rational_mul_correction::<$upper_type, $name>(
+						(<$type>::max_value() as $upper_type).pow(2) - 1,
+						2 as $type,
+						<$type>::max_value(),
+						super::Rounding::NearestPrefDown,
+					),
+					2,
+				);
+				// ((max^2 - 1) % max) * 2 / max == 1 (rounded down)
+				assert_eq!(
+					super::rational_mul_correction::<$upper_type, $name>(
+						(<$type>::max_value() as $upper_type).pow(2) - 1,
+						2 as $type,
+						<$type>::max_value(),
+						super::Rounding::Down,
+					),
+					1,
+				);
+			}
+
+			#[test]
+			#[allow(unused)]
+			fn const_fns_work() {
+				const C1: $name = $name::from_percent(50);
+				const C2: $name = $name::one();
+				const C3: $name = $name::zero();
+				const C4: $name = $name::from_parts(1);
+
+				// deconstruct is also const, hence it can be called in const rhs.
+				const C5: bool = C1.deconstruct() == 0;
+			}
+
+			#[test]
+			fn compact_decoding_saturate_when_beyond_accuracy() {
+				use num_traits::Bounded;
+				use codec::Compact;
+
+				let p = Compact::<$name>::decode(&mut &Compact(<$type>::max_value()).encode()[..])
+					.unwrap();
+				assert_eq!((p.0).0, $max);
+				assert_eq!($name::from(p), $name::max_value());
+			}
+
+			#[allow(unused_imports)]
+			use super::*;
+
+			#[test]
+			fn test_add_basic() {
+				assert_eq!($name::from_parts(1) + $name::from_parts(1), $name::from_parts(2));
+				assert_eq!($name::from_parts(10) + $name::from_parts(10), $name::from_parts(20));
+			}
+
+			#[test]
+			fn test_basic_checked_add() {
+				assert_eq!(
+					$name::from_parts(1).checked_add(&$name::from_parts(1)),
+					Some($name::from_parts(2))
+				);
+				assert_eq!(
+					$name::from_parts(10).checked_add(&$name::from_parts(10)),
+					Some($name::from_parts(20))
+				);
+				assert_eq!(
+					$name::from_parts(<$type>::MAX).checked_add(&$name::from_parts(<$type>::MAX)),
+					None
+				);
+				assert_eq!(
+					$name::from_parts($max).checked_add(&$name::from_parts(1)),
+					None
+				);
+			}
+
+			#[test]
+			fn test_basic_saturating_add() {
+				assert_eq!(
+					$name::from_parts(1).saturating_add($name::from_parts(1)),
+					$name::from_parts(2)
+				);
+				assert_eq!(
+					$name::from_parts(10).saturating_add($name::from_parts(10)),
+					$name::from_parts(20)
+				);
+				assert_eq!(
+					$name::from_parts(<$type>::MAX).saturating_add($name::from_parts(<$type>::MAX)),
+					$name::from_parts(<$type>::MAX)
+				);
+			}
+
+			#[test]
+			fn test_basic_sub() {
+				assert_eq!($name::from_parts(2) - $name::from_parts(1), $name::from_parts(1));
+				assert_eq!($name::from_parts(20) - $name::from_parts(10), $name::from_parts(10));
+			}
+
+			#[test]
+			fn test_basic_checked_sub() {
+				assert_eq!(
+					$name::from_parts(2).checked_sub(&$name::from_parts(1)),
+					Some($name::from_parts(1))
+				);
+				assert_eq!(
+					$name::from_parts(20).checked_sub(&$name::from_parts(10)),
+					Some($name::from_parts(10))
+				);
+				assert_eq!($name::from_parts(0).checked_sub(&$name::from_parts(1)), None);
+			}
+
+			#[test]
+			fn test_basic_saturating_sub() {
+				assert_eq!(
+					$name::from_parts(2).saturating_sub($name::from_parts(1)),
+					$name::from_parts(1)
+				);
+				assert_eq!(
+					$name::from_parts(20).saturating_sub($name::from_parts(10)),
+					$name::from_parts(10)
+				);
+				assert_eq!(
+					$name::from_parts(0).saturating_sub($name::from_parts(1)),
+					$name::from_parts(0)
+				);
+			}
+
+			#[test]
+			fn test_basic_checked_mul() {
+				assert_eq!(
+					$name::from_parts($max).checked_mul(&$name::from_parts($max)),
+					Some($name::from_percent(100))
+				);
+				assert_eq!(
+					$name::from_percent(100).checked_mul(&$name::from_percent(100)),
+					Some($name::from_percent(100))
+				);
+				assert_eq!(
+					$name::from_percent(50).checked_mul(&$name::from_percent(26)),
+					Some($name::from_percent(13))
+				);
+				assert_eq!(
+					$name::from_percent(0).checked_mul(&$name::from_percent(0)),
+					Some($name::from_percent(0))
+				);
+			}
+		}
+	};
+}
+
+macro_rules! implement_per_thing_with_perthousand {
+	(
+		$name:ident,
+		$test_mod:ident,
+		$pt_test_mod:ident,
+		[$($test_units:tt),+],
+		$max:tt,
+		$type:ty,
+		$upper_type:ty,
+		$title:expr $(,)?
+	) => {
+		implement_per_thing! {
+			$name, $test_mod, [ $( $test_units ),+ ], $max, $type, $upper_type, $title,
+		}
+		impl $name {
+			/// Converts a percent into `Self`. Equal to `x / 1000`.
+			///
+			/// This can be created at compile time.
+			pub const fn from_perthousand(x: $type) -> Self {
+				Self(([x, 1000][(x > 1000) as usize] as $upper_type * $max as $upper_type / 1000) as $type)
+			}
+		}
+		#[cfg(test)]
+		mod $pt_test_mod {
+			use super::$name;
+			use crate::traits::Zero;
+
+			#[test]
+			fn from_perthousand_works() {
+				// some really basic stuff
+				assert_eq!($name::from_perthousand(00), $name::from_parts(Zero::zero()));
+				assert_eq!($name::from_perthousand(100), $name::from_parts($max / 10));
+				assert_eq!($name::from_perthousand(1000), $name::from_parts($max));
+				assert_eq!($name::from_perthousand(2000), $name::from_parts($max));
+			}
+
+			#[test]
+			#[allow(unused)]
+			fn const_fns_work() {
+				const C1: $name = $name::from_perthousand(500);
+			}
+		}
+	}
+}
+
+#[test]
+fn from_rational_with_rounding_works_in_extreme_case() {
+	use Rounding::*;
+	for &r in [Down, NearestPrefDown, NearestPrefUp, Up].iter() {
+		Percent::from_rational_with_rounding(1, u64::max_value(), r).unwrap();
+		Percent::from_rational_with_rounding(1, u32::max_value(), r).unwrap();
+		Percent::from_rational_with_rounding(1, u16::max_value(), r).unwrap();
+		Percent::from_rational_with_rounding(u64::max_value() - 1, u64::max_value(), r).unwrap();
+		Percent::from_rational_with_rounding(u32::max_value() - 1, u32::max_value(), r).unwrap();
+		Percent::from_rational_with_rounding(u16::max_value() - 1, u16::max_value(), r).unwrap();
+		PerU16::from_rational_with_rounding(1, u64::max_value(), r).unwrap();
+		PerU16::from_rational_with_rounding(1, u32::max_value(), r).unwrap();
+		PerU16::from_rational_with_rounding(1, u16::max_value(), r).unwrap();
+		PerU16::from_rational_with_rounding(u64::max_value() - 1, u64::max_value(), r).unwrap();
+		PerU16::from_rational_with_rounding(u32::max_value() - 1, u32::max_value(), r).unwrap();
+		PerU16::from_rational_with_rounding(u16::max_value() - 1, u16::max_value(), r).unwrap();
+		Permill::from_rational_with_rounding(1, u64::max_value(), r).unwrap();
+		Permill::from_rational_with_rounding(1, u32::max_value(), r).unwrap();
+		Permill::from_rational_with_rounding(u64::max_value() - 1, u64::max_value(), r).unwrap();
+		Permill::from_rational_with_rounding(u32::max_value() - 1, u32::max_value(), r).unwrap();
+		Perbill::from_rational_with_rounding(1, u64::max_value(), r).unwrap();
+		Perbill::from_rational_with_rounding(1, u32::max_value(), r).unwrap();
+		Perbill::from_rational_with_rounding(u64::max_value() - 1, u64::max_value(), r).unwrap();
+		Perbill::from_rational_with_rounding(u32::max_value() - 1, u32::max_value(), r).unwrap();
+	}
+}
+
+#[test]
+fn from_rational_with_rounding_breakage() {
+	let n = 372633774963620730670986667244911905u128;
+	let d = 512593663333074177468745541591173060u128;
+	let q = Perquintill::from_rational_with_rounding(n, d, Rounding::Down).unwrap();
+	assert!(q * d <= n);
+}
+
+#[test]
+fn from_rational_with_rounding_breakage_2() {
+	let n = 36893488147419103230u128;
+	let d = 36893488147419103630u128;
+	let q = Perquintill::from_rational_with_rounding(n, d, Rounding::Up).unwrap();
+	assert!(q * d >= n);
+}
+
+implement_per_thing!(Percent, test_per_cent, [u32, u64, u128], 100u8, u8, u16, "_Percent_",);
+implement_per_thing_with_perthousand!(
+	PerU16,
+	test_peru16,
+	test_peru16_extra,
+	[u32, u64, u128],
+	65535_u16,
+	u16,
+	u32,
+	"_Parts per 65535_",
+);
+implement_per_thing_with_perthousand!(
+	Permill,
+	test_permill,
+	test_permill_extra,
+	[u32, u64, u128],
+	1_000_000u32,
+	u32,
+	u64,
+	"_Parts per Million_",
+);
+implement_per_thing_with_perthousand!(
+	Perbill,
+	test_perbill,
+	test_perbill_extra,
+	[u32, u64, u128],
+	1_000_000_000u32,
+	u32,
+	u64,
+	"_Parts per Billion_",
+);
+implement_per_thing_with_perthousand!(
+	Perquintill,
+	test_perquintill,
+	test_perquintill_extra,
+	[u64, u128],
+	1_000_000_000_000_000_000u64,
+	u64,
+	u128,
+	"_Parts per Quintillion_",
+);
diff --git a/substrate/primitives/arithmetic/src/rational.rs b/substrate/primitives/arithmetic/src/rational.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ebd89c615a38b3efc717fbb7051fe12ccfb22ea1
--- /dev/null
+++ b/substrate/primitives/arithmetic/src/rational.rs
@@ -0,0 +1,583 @@
+// 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::{biguint::BigUint, helpers_128bit, Rounding};
+use num_traits::{Bounded, One, Zero};
+use sp_std::{cmp::Ordering, prelude::*};
+
+/// A wrapper for any rational number with infinitely large numerator and denominator.
+///
+/// This type exists to facilitate `cmp` operation
+/// on values like `a/b < c/d` where `a, b, c, d` are all `BigUint`.
+#[derive(Clone, Default, Eq)]
+pub struct RationalInfinite(BigUint, BigUint);
+
+impl RationalInfinite {
+	/// Return the numerator reference.
+	pub fn n(&self) -> &BigUint {
+		&self.0
+	}
+
+	/// Return the denominator reference.
+	pub fn d(&self) -> &BigUint {
+		&self.1
+	}
+
+	/// Build from a raw `n/d`.
+	pub fn from(n: BigUint, d: BigUint) -> Self {
+		Self(n, d.max(BigUint::one()))
+	}
+
+	/// Zero.
+	pub fn zero() -> Self {
+		Self(BigUint::zero(), BigUint::one())
+	}
+
+	/// One.
+	pub fn one() -> Self {
+		Self(BigUint::one(), BigUint::one())
+	}
+}
+
+impl PartialOrd for RationalInfinite {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl Ord for RationalInfinite {
+	fn cmp(&self, other: &Self) -> Ordering {
+		// handle some edge cases.
+		if self.d() == other.d() {
+			self.n().cmp(other.n())
+		} else if self.d().is_zero() {
+			Ordering::Greater
+		} else if other.d().is_zero() {
+			Ordering::Less
+		} else {
+			// (a/b) cmp (c/d) => (a*d) cmp (c*b)
+			self.n().clone().mul(other.d()).cmp(&other.n().clone().mul(self.d()))
+		}
+	}
+}
+
+impl PartialEq for RationalInfinite {
+	fn eq(&self, other: &Self) -> bool {
+		self.cmp(other) == Ordering::Equal
+	}
+}
+
+impl From<Rational128> for RationalInfinite {
+	fn from(t: Rational128) -> Self {
+		Self(t.0.into(), t.1.into())
+	}
+}
+
+/// A wrapper for any rational number with a 128 bit numerator and denominator.
+#[derive(Clone, Copy, Default, Eq)]
+pub struct Rational128(u128, u128);
+
+#[cfg(feature = "std")]
+impl sp_std::fmt::Debug for Rational128 {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		write!(f, "Rational128({} / {} ≈ {:.8})", self.0, self.1, self.0 as f64 / self.1 as f64)
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl sp_std::fmt::Debug for Rational128 {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		write!(f, "Rational128({} / {})", self.0, self.1)
+	}
+}
+
+impl Rational128 {
+	/// Zero.
+	pub fn zero() -> Self {
+		Self(0, 1)
+	}
+
+	/// One
+	pub fn one() -> Self {
+		Self(1, 1)
+	}
+
+	/// If it is zero or not
+	pub fn is_zero(&self) -> bool {
+		self.0.is_zero()
+	}
+
+	/// Build from a raw `n/d`.
+	pub fn from(n: u128, d: u128) -> Self {
+		Self(n, d.max(1))
+	}
+
+	/// Build from a raw `n/d`. This could lead to / 0 if not properly handled.
+	pub fn from_unchecked(n: u128, d: u128) -> Self {
+		Self(n, d)
+	}
+
+	/// Return the numerator.
+	pub fn n(&self) -> u128 {
+		self.0
+	}
+
+	/// Return the denominator.
+	pub fn d(&self) -> u128 {
+		self.1
+	}
+
+	/// Convert `self` to a similar rational number where denominator is the given `den`.
+	//
+	/// This only returns if the result is accurate. `None` is returned if the result cannot be
+	/// accurately calculated.
+	pub fn to_den(self, den: u128) -> Option<Self> {
+		if den == self.1 {
+			Some(self)
+		} else {
+			helpers_128bit::multiply_by_rational_with_rounding(
+				self.0,
+				den,
+				self.1,
+				Rounding::NearestPrefDown,
+			)
+			.map(|n| Self(n, den))
+		}
+	}
+
+	/// Get the least common divisor of `self` and `other`.
+	///
+	/// This only returns if the result is accurate. `None` is returned if the result cannot be
+	/// accurately calculated.
+	pub fn lcm(&self, other: &Self) -> Option<u128> {
+		// this should be tested better: two large numbers that are almost the same.
+		if self.1 == other.1 {
+			return Some(self.1)
+		}
+		let g = helpers_128bit::gcd(self.1, other.1);
+		helpers_128bit::multiply_by_rational_with_rounding(
+			self.1,
+			other.1,
+			g,
+			Rounding::NearestPrefDown,
+		)
+	}
+
+	/// A saturating add that assumes `self` and `other` have the same denominator.
+	pub fn lazy_saturating_add(self, other: Self) -> Self {
+		if other.is_zero() {
+			self
+		} else {
+			Self(self.0.saturating_add(other.0), self.1)
+		}
+	}
+
+	/// A saturating subtraction that assumes `self` and `other` have the same denominator.
+	pub fn lazy_saturating_sub(self, other: Self) -> Self {
+		if other.is_zero() {
+			self
+		} else {
+			Self(self.0.saturating_sub(other.0), self.1)
+		}
+	}
+
+	/// Addition. Simply tries to unify the denominators and add the numerators.
+	///
+	/// Overflow might happen during any of the steps. Error is returned in such cases.
+	pub fn checked_add(self, other: Self) -> Result<Self, &'static str> {
+		let lcm = self.lcm(&other).ok_or(0).map_err(|_| "failed to scale to denominator")?;
+		let self_scaled =
+			self.to_den(lcm).ok_or(0).map_err(|_| "failed to scale to denominator")?;
+		let other_scaled =
+			other.to_den(lcm).ok_or(0).map_err(|_| "failed to scale to denominator")?;
+		let n = self_scaled
+			.0
+			.checked_add(other_scaled.0)
+			.ok_or("overflow while adding numerators")?;
+		Ok(Self(n, self_scaled.1))
+	}
+
+	/// Subtraction. Simply tries to unify the denominators and subtract the numerators.
+	///
+	/// Overflow might happen during any of the steps. None is returned in such cases.
+	pub fn checked_sub(self, other: Self) -> Result<Self, &'static str> {
+		let lcm = self.lcm(&other).ok_or(0).map_err(|_| "failed to scale to denominator")?;
+		let self_scaled =
+			self.to_den(lcm).ok_or(0).map_err(|_| "failed to scale to denominator")?;
+		let other_scaled =
+			other.to_den(lcm).ok_or(0).map_err(|_| "failed to scale to denominator")?;
+
+		let n = self_scaled
+			.0
+			.checked_sub(other_scaled.0)
+			.ok_or("overflow while subtracting numerators")?;
+		Ok(Self(n, self_scaled.1))
+	}
+}
+
+impl Bounded for Rational128 {
+	fn min_value() -> Self {
+		Self(0, 1)
+	}
+
+	fn max_value() -> Self {
+		Self(Bounded::max_value(), 1)
+	}
+}
+
+impl<T: Into<u128>> From<T> for Rational128 {
+	fn from(t: T) -> Self {
+		Self::from(t.into(), 1)
+	}
+}
+
+impl PartialOrd for Rational128 {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl Ord for Rational128 {
+	fn cmp(&self, other: &Self) -> Ordering {
+		// handle some edge cases.
+		if self.1 == other.1 {
+			self.0.cmp(&other.0)
+		} else if self.1.is_zero() {
+			Ordering::Greater
+		} else if other.1.is_zero() {
+			Ordering::Less
+		} else {
+			// Don't even compute gcd.
+			let self_n = helpers_128bit::to_big_uint(self.0) * helpers_128bit::to_big_uint(other.1);
+			let other_n =
+				helpers_128bit::to_big_uint(other.0) * helpers_128bit::to_big_uint(self.1);
+			self_n.cmp(&other_n)
+		}
+	}
+}
+
+impl PartialEq for Rational128 {
+	fn eq(&self, other: &Self) -> bool {
+		// handle some edge cases.
+		if self.1 == other.1 {
+			self.0.eq(&other.0)
+		} else {
+			let self_n = helpers_128bit::to_big_uint(self.0) * helpers_128bit::to_big_uint(other.1);
+			let other_n =
+				helpers_128bit::to_big_uint(other.0) * helpers_128bit::to_big_uint(self.1);
+			self_n.eq(&other_n)
+		}
+	}
+}
+
+pub trait MultiplyRational: Sized {
+	fn multiply_rational(self, n: Self, d: Self, r: Rounding) -> Option<Self>;
+}
+
+macro_rules! impl_rrm {
+	($ulow:ty, $uhi:ty) => {
+		impl MultiplyRational for $ulow {
+			fn multiply_rational(self, n: Self, d: Self, r: Rounding) -> Option<Self> {
+				if d.is_zero() {
+					return None
+				}
+
+				let sn = (self as $uhi) * (n as $uhi);
+				let mut result = sn / (d as $uhi);
+				let remainder = (sn % (d as $uhi)) as $ulow;
+				if match r {
+					Rounding::Up => remainder > 0,
+					// cannot be `(d + 1) / 2` since `d` might be `max_value` and overflow.
+					Rounding::NearestPrefUp => remainder >= d / 2 + d % 2,
+					Rounding::NearestPrefDown => remainder > d / 2,
+					Rounding::Down => false,
+				} {
+					result = match result.checked_add(1) {
+						Some(v) => v,
+						None => return None,
+					};
+				}
+				if result > (<$ulow>::max_value() as $uhi) {
+					None
+				} else {
+					Some(result as $ulow)
+				}
+			}
+		}
+	};
+}
+
+impl_rrm!(u8, u16);
+impl_rrm!(u16, u32);
+impl_rrm!(u32, u64);
+impl_rrm!(u64, u128);
+
+impl MultiplyRational for u128 {
+	fn multiply_rational(self, n: Self, d: Self, r: Rounding) -> Option<Self> {
+		crate::helpers_128bit::multiply_by_rational_with_rounding(self, n, d, r)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{helpers_128bit::*, *};
+	use static_assertions::const_assert;
+
+	const MAX128: u128 = u128::MAX;
+	const MAX64: u128 = u64::MAX as u128;
+	const MAX64_2: u128 = 2 * u64::MAX as u128;
+
+	fn r(p: u128, q: u128) -> Rational128 {
+		Rational128(p, q)
+	}
+
+	fn mul_div(a: u128, b: u128, c: u128) -> u128 {
+		use primitive_types::U256;
+		if a.is_zero() {
+			return Zero::zero()
+		}
+		let c = c.max(1);
+
+		// e for extended
+		let ae: U256 = a.into();
+		let be: U256 = b.into();
+		let ce: U256 = c.into();
+
+		let r = ae * be / ce;
+		if r > u128::max_value().into() {
+			a
+		} else {
+			r.as_u128()
+		}
+	}
+
+	#[test]
+	fn truth_value_function_works() {
+		assert_eq!(mul_div(2u128.pow(100), 8, 4), 2u128.pow(101));
+		assert_eq!(mul_div(2u128.pow(100), 4, 8), 2u128.pow(99));
+
+		// and it returns a if result cannot fit
+		assert_eq!(mul_div(MAX128 - 10, 2, 1), MAX128 - 10);
+	}
+
+	#[test]
+	fn to_denom_works() {
+		// simple up and down
+		assert_eq!(r(1, 5).to_den(10), Some(r(2, 10)));
+		assert_eq!(r(4, 10).to_den(5), Some(r(2, 5)));
+
+		// up and down with large numbers
+		assert_eq!(r(MAX128 - 10, MAX128).to_den(10), Some(r(10, 10)));
+		assert_eq!(r(MAX128 / 2, MAX128).to_den(10), Some(r(5, 10)));
+
+		// large to perbill. This is very well needed for npos-elections.
+		assert_eq!(r(MAX128 / 2, MAX128).to_den(1000_000_000), Some(r(500_000_000, 1000_000_000)));
+
+		// large to large
+		assert_eq!(r(MAX128 / 2, MAX128).to_den(MAX128 / 2), Some(r(MAX128 / 4, MAX128 / 2)));
+	}
+
+	#[test]
+	fn gdc_works() {
+		assert_eq!(gcd(10, 5), 5);
+		assert_eq!(gcd(7, 22), 1);
+	}
+
+	#[test]
+	fn lcm_works() {
+		// simple stuff
+		assert_eq!(r(3, 10).lcm(&r(4, 15)).unwrap(), 30);
+		assert_eq!(r(5, 30).lcm(&r(1, 7)).unwrap(), 210);
+		assert_eq!(r(5, 30).lcm(&r(1, 10)).unwrap(), 30);
+
+		// large numbers
+		assert_eq!(r(1_000_000_000, MAX128).lcm(&r(7_000_000_000, MAX128 - 1)), None,);
+		assert_eq!(
+			r(1_000_000_000, MAX64).lcm(&r(7_000_000_000, MAX64 - 1)),
+			Some(340282366920938463408034375210639556610),
+		);
+		const_assert!(340282366920938463408034375210639556610 < MAX128);
+		const_assert!(340282366920938463408034375210639556610 == MAX64 * (MAX64 - 1));
+	}
+
+	#[test]
+	fn add_works() {
+		// works
+		assert_eq!(r(3, 10).checked_add(r(1, 10)).unwrap(), r(2, 5));
+		assert_eq!(r(3, 10).checked_add(r(3, 7)).unwrap(), r(51, 70));
+
+		// errors
+		assert_eq!(
+			r(1, MAX128).checked_add(r(1, MAX128 - 1)),
+			Err("failed to scale to denominator"),
+		);
+		assert_eq!(
+			r(7, MAX128).checked_add(r(MAX128, MAX128)),
+			Err("overflow while adding numerators"),
+		);
+		assert_eq!(
+			r(MAX128, MAX128).checked_add(r(MAX128, MAX128)),
+			Err("overflow while adding numerators"),
+		);
+	}
+
+	#[test]
+	fn sub_works() {
+		// works
+		assert_eq!(r(3, 10).checked_sub(r(1, 10)).unwrap(), r(1, 5));
+		assert_eq!(r(6, 10).checked_sub(r(3, 7)).unwrap(), r(12, 70));
+
+		// errors
+		assert_eq!(
+			r(2, MAX128).checked_sub(r(1, MAX128 - 1)),
+			Err("failed to scale to denominator"),
+		);
+		assert_eq!(
+			r(7, MAX128).checked_sub(r(MAX128, MAX128)),
+			Err("overflow while subtracting numerators"),
+		);
+		assert_eq!(r(1, 10).checked_sub(r(2, 10)), Err("overflow while subtracting numerators"));
+	}
+
+	#[test]
+	fn ordering_and_eq_works() {
+		assert!(r(1, 2) > r(1, 3));
+		assert!(r(1, 2) > r(2, 6));
+
+		assert!(r(1, 2) < r(6, 6));
+		assert!(r(2, 1) > r(2, 6));
+
+		assert!(r(5, 10) == r(1, 2));
+		assert!(r(1, 2) == r(1, 2));
+
+		assert!(r(1, 1490000000000200000) > r(1, 1490000000000200001));
+	}
+
+	#[test]
+	fn multiply_by_rational_with_rounding_works() {
+		assert_eq!(multiply_by_rational_with_rounding(7, 2, 3, Rounding::Down).unwrap(), 7 * 2 / 3);
+		assert_eq!(
+			multiply_by_rational_with_rounding(7, 20, 30, Rounding::Down).unwrap(),
+			7 * 2 / 3
+		);
+		assert_eq!(
+			multiply_by_rational_with_rounding(20, 7, 30, Rounding::Down).unwrap(),
+			7 * 2 / 3
+		);
+
+		assert_eq!(
+			// MAX128 % 3 == 0
+			multiply_by_rational_with_rounding(MAX128, 2, 3, Rounding::Down).unwrap(),
+			MAX128 / 3 * 2,
+		);
+		assert_eq!(
+			// MAX128 % 7 == 3
+			multiply_by_rational_with_rounding(MAX128, 5, 7, Rounding::Down).unwrap(),
+			(MAX128 / 7 * 5) + (3 * 5 / 7),
+		);
+		assert_eq!(
+			// MAX128 % 7 == 3
+			multiply_by_rational_with_rounding(MAX128, 11, 13, Rounding::Down).unwrap(),
+			(MAX128 / 13 * 11) + (8 * 11 / 13),
+		);
+		assert_eq!(
+			// MAX128 % 1000 == 455
+			multiply_by_rational_with_rounding(MAX128, 555, 1000, Rounding::Down).unwrap(),
+			(MAX128 / 1000 * 555) + (455 * 555 / 1000),
+		);
+
+		assert_eq!(
+			multiply_by_rational_with_rounding(2 * MAX64 - 1, MAX64, MAX64, Rounding::Down)
+				.unwrap(),
+			2 * MAX64 - 1
+		);
+		assert_eq!(
+			multiply_by_rational_with_rounding(2 * MAX64 - 1, MAX64 - 1, MAX64, Rounding::Down)
+				.unwrap(),
+			2 * MAX64 - 3
+		);
+
+		assert_eq!(
+			multiply_by_rational_with_rounding(MAX64 + 100, MAX64_2, MAX64_2 / 2, Rounding::Down)
+				.unwrap(),
+			(MAX64 + 100) * 2,
+		);
+		assert_eq!(
+			multiply_by_rational_with_rounding(
+				MAX64 + 100,
+				MAX64_2 / 100,
+				MAX64_2 / 200,
+				Rounding::Down
+			)
+			.unwrap(),
+			(MAX64 + 100) * 2,
+		);
+
+		assert_eq!(
+			multiply_by_rational_with_rounding(
+				2u128.pow(66) - 1,
+				2u128.pow(65) - 1,
+				2u128.pow(65),
+				Rounding::Down
+			)
+			.unwrap(),
+			73786976294838206461,
+		);
+		assert_eq!(
+			multiply_by_rational_with_rounding(1_000_000_000, MAX128 / 8, MAX128 / 2, Rounding::Up)
+				.unwrap(),
+			250000000
+		);
+
+		assert_eq!(
+			multiply_by_rational_with_rounding(
+				29459999999999999988000u128,
+				1000000000000000000u128,
+				10000000000000000000u128,
+				Rounding::Down
+			)
+			.unwrap(),
+			2945999999999999998800u128
+		);
+	}
+
+	#[test]
+	fn multiply_by_rational_with_rounding_a_b_are_interchangeable() {
+		assert_eq!(
+			multiply_by_rational_with_rounding(10, MAX128, MAX128 / 2, Rounding::NearestPrefDown),
+			Some(20)
+		);
+		assert_eq!(
+			multiply_by_rational_with_rounding(MAX128, 10, MAX128 / 2, Rounding::NearestPrefDown),
+			Some(20)
+		);
+	}
+
+	#[test]
+	#[ignore]
+	fn multiply_by_rational_with_rounding_fuzzed_equation() {
+		assert_eq!(
+			multiply_by_rational_with_rounding(
+				154742576605164960401588224,
+				9223376310179529214,
+				549756068598,
+				Rounding::NearestPrefDown
+			),
+			Some(2596149632101417846585204209223679)
+		);
+	}
+}
diff --git a/substrate/primitives/arithmetic/src/traits.rs b/substrate/primitives/arithmetic/src/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6fcc8248539ca1649a11014615ad5ab48da53119
--- /dev/null
+++ b/substrate/primitives/arithmetic/src/traits.rs
@@ -0,0 +1,1113 @@
+// 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.
+
+//! Primitive traits for the runtime arithmetic.
+
+use codec::HasCompact;
+pub use ensure::{
+	ensure_pow, Ensure, EnsureAdd, EnsureAddAssign, EnsureDiv, EnsureDivAssign,
+	EnsureFixedPointNumber, EnsureFrom, EnsureInto, EnsureMul, EnsureMulAssign, EnsureOp,
+	EnsureOpAssign, EnsureSub, EnsureSubAssign,
+};
+pub use integer_sqrt::IntegerSquareRoot;
+pub use num_traits::{
+	checked_pow, Bounded, CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedRem, CheckedShl,
+	CheckedShr, CheckedSub, One, Signed, Unsigned, Zero,
+};
+use sp_std::ops::{
+	Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, RemAssign, Shl, Shr, Sub, SubAssign,
+};
+
+use crate::MultiplyRational;
+
+/// A meta trait for arithmetic type operations, regardless of any limitation on size.
+pub trait BaseArithmetic:
+	From<u8>
+	+ Zero
+	+ One
+	+ IntegerSquareRoot
+	+ Add<Self, Output = Self>
+	+ AddAssign<Self>
+	+ Sub<Self, Output = Self>
+	+ SubAssign<Self>
+	+ Mul<Self, Output = Self>
+	+ MulAssign<Self>
+	+ Div<Self, Output = Self>
+	+ DivAssign<Self>
+	+ Rem<Self, Output = Self>
+	+ RemAssign<Self>
+	+ Shl<u32, Output = Self>
+	+ Shr<u32, Output = Self>
+	+ CheckedShl
+	+ CheckedShr
+	+ CheckedAdd
+	+ CheckedSub
+	+ CheckedMul
+	+ CheckedDiv
+	+ CheckedRem
+	+ CheckedNeg
+	+ Ensure
+	+ Saturating
+	+ PartialOrd<Self>
+	+ Ord
+	+ Bounded
+	+ HasCompact
+	+ Sized
+	+ Clone
+	+ TryFrom<u8>
+	+ TryInto<u8>
+	+ TryFrom<u16>
+	+ TryInto<u16>
+	+ TryFrom<u32>
+	+ TryInto<u32>
+	+ TryFrom<u64>
+	+ TryInto<u64>
+	+ TryFrom<u128>
+	+ TryInto<u128>
+	+ TryFrom<usize>
+	+ TryInto<usize>
+	+ UniqueSaturatedFrom<u8>
+	+ UniqueSaturatedInto<u8>
+	+ UniqueSaturatedFrom<u16>
+	+ UniqueSaturatedInto<u16>
+	+ UniqueSaturatedFrom<u32>
+	+ UniqueSaturatedInto<u32>
+	+ UniqueSaturatedFrom<u64>
+	+ UniqueSaturatedInto<u64>
+	+ UniqueSaturatedFrom<u128>
+	+ UniqueSaturatedInto<u128>
+{
+}
+
+impl<
+		T: From<u8>
+			+ Zero
+			+ One
+			+ IntegerSquareRoot
+			+ Add<Self, Output = Self>
+			+ AddAssign<Self>
+			+ Sub<Self, Output = Self>
+			+ SubAssign<Self>
+			+ Mul<Self, Output = Self>
+			+ MulAssign<Self>
+			+ Div<Self, Output = Self>
+			+ DivAssign<Self>
+			+ Rem<Self, Output = Self>
+			+ RemAssign<Self>
+			+ Shl<u32, Output = Self>
+			+ Shr<u32, Output = Self>
+			+ CheckedShl
+			+ CheckedShr
+			+ CheckedAdd
+			+ CheckedSub
+			+ CheckedMul
+			+ CheckedDiv
+			+ CheckedRem
+			+ CheckedNeg
+			+ Ensure
+			+ Saturating
+			+ PartialOrd<Self>
+			+ Ord
+			+ Bounded
+			+ HasCompact
+			+ Sized
+			+ Clone
+			+ TryFrom<u8>
+			+ TryInto<u8>
+			+ TryFrom<u16>
+			+ TryInto<u16>
+			+ TryFrom<u32>
+			+ TryInto<u32>
+			+ TryFrom<u64>
+			+ TryInto<u64>
+			+ TryFrom<u128>
+			+ TryInto<u128>
+			+ TryFrom<usize>
+			+ TryInto<usize>
+			+ UniqueSaturatedFrom<u8>
+			+ UniqueSaturatedInto<u8>
+			+ UniqueSaturatedFrom<u16>
+			+ UniqueSaturatedInto<u16>
+			+ UniqueSaturatedFrom<u32>
+			+ UniqueSaturatedInto<u32>
+			+ UniqueSaturatedFrom<u64>
+			+ UniqueSaturatedInto<u64>
+			+ UniqueSaturatedFrom<u128>
+			+ UniqueSaturatedInto<u128>,
+	> BaseArithmetic for T
+{
+}
+
+/// A meta trait for arithmetic.
+///
+/// Arithmetic types do all the usual stuff you'd expect numbers to do. They are guaranteed to
+/// be able to represent at least `u8` values without loss, hence the trait implies `From<u8>`
+/// and smaller integers. All other conversions are fallible.
+pub trait AtLeast8Bit: BaseArithmetic + From<u8> {}
+
+impl<T: BaseArithmetic + From<u8>> AtLeast8Bit for T {}
+
+/// A meta trait for arithmetic.  Same as [`AtLeast8Bit `], but also bounded to be unsigned.
+pub trait AtLeast8BitUnsigned: AtLeast8Bit + Unsigned {}
+
+impl<T: AtLeast8Bit + Unsigned> AtLeast8BitUnsigned for T {}
+
+/// A meta trait for arithmetic.
+///
+/// Arithmetic types do all the usual stuff you'd expect numbers to do. They are guaranteed to
+/// be able to represent at least `u16` values without loss, hence the trait implies `From<u16>`
+/// and smaller integers. All other conversions are fallible.
+pub trait AtLeast16Bit: BaseArithmetic + From<u16> {}
+
+impl<T: BaseArithmetic + From<u16>> AtLeast16Bit for T {}
+
+/// A meta trait for arithmetic.  Same as [`AtLeast16Bit `], but also bounded to be unsigned.
+pub trait AtLeast16BitUnsigned: AtLeast16Bit + Unsigned {}
+
+impl<T: AtLeast16Bit + Unsigned> AtLeast16BitUnsigned for T {}
+
+/// A meta trait for arithmetic.
+///
+/// Arithmetic types do all the usual stuff you'd expect numbers to do. They are guaranteed to
+/// be able to represent at least `u32` values without loss, hence the trait implies `From<u32>`
+/// and smaller integers. All other conversions are fallible.
+pub trait AtLeast32Bit: BaseArithmetic + From<u16> + From<u32> {}
+
+impl<T: BaseArithmetic + From<u16> + From<u32>> AtLeast32Bit for T {}
+
+/// A meta trait for arithmetic.  Same as [`AtLeast32Bit `], but also bounded to be unsigned.
+pub trait AtLeast32BitUnsigned: AtLeast32Bit + Unsigned + MultiplyRational {}
+
+impl<T: AtLeast32Bit + Unsigned + MultiplyRational> AtLeast32BitUnsigned for T {}
+
+/// Just like `From` except that if the source value is too big to fit into the destination type
+/// then it'll saturate the destination.
+pub trait UniqueSaturatedFrom<T: Sized>: Sized {
+	/// Convert from a value of `T` into an equivalent instance of `Self`.
+	fn unique_saturated_from(t: T) -> Self;
+}
+
+/// Just like `Into` except that if the source value is too big to fit into the destination type
+/// then it'll saturate the destination.
+pub trait UniqueSaturatedInto<T: Sized>: Sized {
+	/// Consume self to return an equivalent value of `T`.
+	fn unique_saturated_into(self) -> T;
+}
+
+impl<T: Sized, S: TryFrom<T> + Bounded + Sized> UniqueSaturatedFrom<T> for S {
+	fn unique_saturated_from(t: T) -> Self {
+		S::try_from(t).unwrap_or_else(|_| Bounded::max_value())
+	}
+}
+
+impl<T: Bounded + Sized, S: TryInto<T> + Sized> UniqueSaturatedInto<T> for S {
+	fn unique_saturated_into(self) -> T {
+		self.try_into().unwrap_or_else(|_| Bounded::max_value())
+	}
+}
+
+/// Saturating arithmetic operations, returning maximum or minimum values instead of overflowing.
+pub trait Saturating {
+	/// Saturating addition. Compute `self + rhs`, saturating at the numeric bounds instead of
+	/// overflowing.
+	fn saturating_add(self, rhs: Self) -> Self;
+
+	/// Saturating subtraction. Compute `self - rhs`, saturating at the numeric bounds instead of
+	/// overflowing.
+	fn saturating_sub(self, rhs: Self) -> Self;
+
+	/// Saturating multiply. Compute `self * rhs`, saturating at the numeric bounds instead of
+	/// overflowing.
+	fn saturating_mul(self, rhs: Self) -> Self;
+
+	/// Saturating exponentiation. Compute `self.pow(exp)`, saturating at the numeric bounds
+	/// instead of overflowing.
+	fn saturating_pow(self, exp: usize) -> Self;
+
+	/// Decrement self by one, saturating at zero.
+	fn saturating_less_one(mut self) -> Self
+	where
+		Self: One,
+	{
+		self.saturating_dec();
+		self
+	}
+
+	/// Increment self by one, saturating at the numeric bounds instead of overflowing.
+	fn saturating_plus_one(mut self) -> Self
+	where
+		Self: One,
+	{
+		self.saturating_inc();
+		self
+	}
+
+	/// Increment self by one, saturating.
+	fn saturating_inc(&mut self)
+	where
+		Self: One,
+	{
+		let mut o = Self::one();
+		sp_std::mem::swap(&mut o, self);
+		*self = o.saturating_add(One::one());
+	}
+
+	/// Decrement self by one, saturating at zero.
+	fn saturating_dec(&mut self)
+	where
+		Self: One,
+	{
+		let mut o = Self::one();
+		sp_std::mem::swap(&mut o, self);
+		*self = o.saturating_sub(One::one());
+	}
+
+	/// Increment self by some `amount`, saturating.
+	fn saturating_accrue(&mut self, amount: Self)
+	where
+		Self: One,
+	{
+		let mut o = Self::one();
+		sp_std::mem::swap(&mut o, self);
+		*self = o.saturating_add(amount);
+	}
+
+	/// Decrement self by some `amount`, saturating at zero.
+	fn saturating_reduce(&mut self, amount: Self)
+	where
+		Self: One,
+	{
+		let mut o = Self::one();
+		sp_std::mem::swap(&mut o, self);
+		*self = o.saturating_sub(amount);
+	}
+}
+
+impl<T: Clone + Zero + One + PartialOrd + CheckedMul + Bounded + num_traits::Saturating> Saturating
+	for T
+{
+	fn saturating_add(self, o: Self) -> Self {
+		<Self as num_traits::Saturating>::saturating_add(self, o)
+	}
+
+	fn saturating_sub(self, o: Self) -> Self {
+		<Self as num_traits::Saturating>::saturating_sub(self, o)
+	}
+
+	fn saturating_mul(self, o: Self) -> Self {
+		self.checked_mul(&o).unwrap_or_else(|| {
+			if (self < T::zero()) != (o < T::zero()) {
+				Bounded::min_value()
+			} else {
+				Bounded::max_value()
+			}
+		})
+	}
+
+	fn saturating_pow(self, exp: usize) -> Self {
+		let neg = self < T::zero() && exp % 2 != 0;
+		checked_pow(self, exp).unwrap_or_else(|| {
+			if neg {
+				Bounded::min_value()
+			} else {
+				Bounded::max_value()
+			}
+		})
+	}
+}
+
+/// Convenience type to work around the highly unergonomic syntax needed
+/// to invoke the functions of overloaded generic traits, in this case
+/// `SaturatedFrom` and `SaturatedInto`.
+pub trait SaturatedConversion {
+	/// Convert from a value of `T` into an equivalent instance of `Self`.
+	///
+	/// This just uses `UniqueSaturatedFrom` internally but with this
+	/// variant you can provide the destination type using turbofish syntax
+	/// in case Rust happens not to assume the correct type.
+	fn saturated_from<T>(t: T) -> Self
+	where
+		Self: UniqueSaturatedFrom<T>,
+	{
+		<Self as UniqueSaturatedFrom<T>>::unique_saturated_from(t)
+	}
+
+	/// Consume self to return an equivalent value of `T`.
+	///
+	/// This just uses `UniqueSaturatedInto` internally but with this
+	/// variant you can provide the destination type using turbofish syntax
+	/// in case Rust happens not to assume the correct type.
+	fn saturated_into<T>(self) -> T
+	where
+		Self: UniqueSaturatedInto<T>,
+	{
+		<Self as UniqueSaturatedInto<T>>::unique_saturated_into(self)
+	}
+}
+impl<T: Sized> SaturatedConversion for T {}
+
+/// Arithmetic operations with safe error handling.
+///
+/// This module provide a readable way to do safe arithmetics, turning this:
+///
+/// ```
+/// # use sp_arithmetic::{traits::EnsureSub, ArithmeticError};
+/// # fn foo() -> Result<(), ArithmeticError> {
+/// # let mut my_value: i32 = 1;
+/// # let other_value: i32 = 1;
+/// my_value = my_value.checked_sub(other_value).ok_or(ArithmeticError::Overflow)?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// into this:
+///
+/// ```
+/// # use sp_arithmetic::{traits::EnsureSubAssign, ArithmeticError};
+/// # fn foo() -> Result<(), ArithmeticError> {
+/// # let mut my_value: i32 = 1;
+/// # let other_value: i32 = 1;
+/// my_value.ensure_sub_assign(other_value)?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// choosing the correct [`ArithmeticError`](crate::ArithmeticError) it should return in case of
+/// fail.
+///
+/// The *EnsureOps* family functions follows the same behavior as *CheckedOps* but
+/// returning an [`ArithmeticError`](crate::ArithmeticError) instead of `None`.
+mod ensure {
+	use super::{checked_pow, CheckedAdd, CheckedDiv, CheckedMul, CheckedSub, One, Zero};
+	use crate::{ArithmeticError, FixedPointNumber, FixedPointOperand};
+
+	/// Performs addition that returns [`ArithmeticError`] instead of wrapping around on overflow.
+	pub trait EnsureAdd: EnsureAddAssign {
+		/// Adds two numbers, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// Similar to [`CheckedAdd::checked_add()`] but returning an [`ArithmeticError`] error.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureAdd;
+		///
+		/// let a: i32 = 10;
+		/// let b: i32 = 20;
+		///
+		/// assert_eq!(a.ensure_add(b), Ok(30));
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureAdd, ArithmeticError};
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     u32::MAX.ensure_add(1)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     i32::MIN.ensure_add(-1)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_add(mut self, v: Self) -> Result<Self, ArithmeticError> {
+			self.ensure_add_assign(v)?;
+			Ok(self)
+		}
+	}
+
+	/// Performs subtraction that returns [`ArithmeticError`] instead of wrapping around on
+	/// underflow.
+	pub trait EnsureSub: EnsureSubAssign {
+		/// Subtracts two numbers, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// Similar to [`CheckedSub::checked_sub()`] but returning an [`ArithmeticError`] error.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureSub;
+		///
+		/// let a: i32 = 10;
+		/// let b: i32 = 20;
+		///
+		/// assert_eq!(a.ensure_sub(b), Ok(-10));
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureSub, ArithmeticError};
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     0u32.ensure_sub(1)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     i32::MAX.ensure_sub(-1)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// ```
+		fn ensure_sub(mut self, v: Self) -> Result<Self, ArithmeticError> {
+			self.ensure_sub_assign(v)?;
+			Ok(self)
+		}
+	}
+
+	/// Performs multiplication that returns [`ArithmeticError`] instead of wrapping around on
+	/// overflow.
+	pub trait EnsureMul: EnsureMulAssign {
+		/// Multiplies two numbers, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// Similar to [`CheckedMul::checked_mul()`] but returning an [`ArithmeticError`] error.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureMul;
+		///
+		/// let a: i32 = 10;
+		/// let b: i32 = 20;
+		///
+		/// assert_eq!(a.ensure_mul(b), Ok(200));
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureMul, ArithmeticError};
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     u32::MAX.ensure_mul(2)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     i32::MAX.ensure_mul(-2)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_mul(mut self, v: Self) -> Result<Self, ArithmeticError> {
+			self.ensure_mul_assign(v)?;
+			Ok(self)
+		}
+	}
+
+	/// Performs division that returns [`ArithmeticError`] instead of wrapping around on overflow.
+	pub trait EnsureDiv: EnsureDivAssign {
+		/// Divides two numbers, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// Similar to [`CheckedDiv::checked_div()`] but returning an [`ArithmeticError`] error.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureDiv;
+		///
+		/// let a: i32 = 20;
+		/// let b: i32 = 10;
+		///
+		/// assert_eq!(a.ensure_div(b), Ok(2));
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureDiv, ArithmeticError};
+		///
+		/// fn extrinsic_zero() -> Result<(), ArithmeticError> {
+		///     1.ensure_div(0)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     i64::MIN.ensure_div(-1)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(extrinsic_zero(), Err(ArithmeticError::DivisionByZero));
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// ```
+		fn ensure_div(mut self, v: Self) -> Result<Self, ArithmeticError> {
+			self.ensure_div_assign(v)?;
+			Ok(self)
+		}
+	}
+
+	/// Raises a value to the power of exp, returning `ArithmeticError` if an overflow occurred.
+	///
+	/// Check [`checked_pow`] for more info about border cases.
+	///
+	/// ```
+	/// use sp_arithmetic::{traits::ensure_pow, ArithmeticError};
+	///
+	/// fn overflow() -> Result<(), ArithmeticError> {
+	///     ensure_pow(2u64, 64)?;
+	///     Ok(())
+	/// }
+	///
+	/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+	/// ```
+	pub fn ensure_pow<T: One + CheckedMul + Clone>(
+		base: T,
+		exp: usize,
+	) -> Result<T, ArithmeticError> {
+		checked_pow(base, exp).ok_or(ArithmeticError::Overflow)
+	}
+
+	impl<T: EnsureAddAssign> EnsureAdd for T {}
+	impl<T: EnsureSubAssign> EnsureSub for T {}
+	impl<T: EnsureMulAssign> EnsureMul for T {}
+	impl<T: EnsureDivAssign> EnsureDiv for T {}
+
+	/// Meta trait that supports all immutable arithmetic `Ensure*` operations
+	pub trait EnsureOp: EnsureAdd + EnsureSub + EnsureMul + EnsureDiv {}
+	impl<T: EnsureAdd + EnsureSub + EnsureMul + EnsureDiv> EnsureOp for T {}
+
+	/// Performs self addition that returns [`ArithmeticError`] instead of wrapping around on
+	/// overflow.
+	pub trait EnsureAddAssign: CheckedAdd + PartialOrd + Zero {
+		/// Adds two numbers overwriting the left hand one, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureAddAssign;
+		///
+		/// let mut a: i32 = 10;
+		/// let b: i32 = 20;
+		///
+		/// a.ensure_add_assign(b).unwrap();
+		/// assert_eq!(a, 30);
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureAddAssign, ArithmeticError};
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     let mut max = u32::MAX;
+		///     max.ensure_add_assign(1)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     let mut max = i32::MIN;
+		///     max.ensure_add_assign(-1)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_add_assign(&mut self, v: Self) -> Result<(), ArithmeticError> {
+			*self = self.checked_add(&v).ok_or_else(|| error::equivalent(&v))?;
+			Ok(())
+		}
+	}
+
+	/// Performs self subtraction that returns [`ArithmeticError`] instead of wrapping around on
+	/// underflow.
+	pub trait EnsureSubAssign: CheckedSub + PartialOrd + Zero {
+		/// Subtracts two numbers overwriting the left hand one, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureSubAssign;
+		///
+		/// let mut a: i32 = 10;
+		/// let b: i32 = 20;
+		///
+		/// a.ensure_sub_assign(b).unwrap();
+		/// assert_eq!(a, -10);
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureSubAssign, ArithmeticError};
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     let mut zero: u32 = 0;
+		///     zero.ensure_sub_assign(1)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     let mut zero = i32::MAX;
+		///     zero.ensure_sub_assign(-1)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// ```
+		fn ensure_sub_assign(&mut self, v: Self) -> Result<(), ArithmeticError> {
+			*self = self.checked_sub(&v).ok_or_else(|| error::inverse(&v))?;
+			Ok(())
+		}
+	}
+
+	/// Performs self multiplication that returns [`ArithmeticError`] instead of wrapping around on
+	/// overflow.
+	pub trait EnsureMulAssign: CheckedMul + PartialOrd + Zero {
+		/// Multiplies two numbers overwriting the left hand one, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureMulAssign;
+		///
+		/// let mut a: i32 = 10;
+		/// let b: i32 = 20;
+		///
+		/// a.ensure_mul_assign(b).unwrap();
+		/// assert_eq!(a, 200);
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureMulAssign, ArithmeticError};
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     let mut max = u32::MAX;
+		///     max.ensure_mul_assign(2)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     let mut max = i32::MAX;
+		///     max.ensure_mul_assign(-2)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_mul_assign(&mut self, v: Self) -> Result<(), ArithmeticError> {
+			*self = self.checked_mul(&v).ok_or_else(|| error::multiplication(self, &v))?;
+			Ok(())
+		}
+	}
+
+	/// Performs self division that returns [`ArithmeticError`] instead of wrapping around on
+	/// overflow.
+	pub trait EnsureDivAssign: CheckedDiv + PartialOrd + Zero {
+		/// Divides two numbers overwriting the left hand one, checking for overflow.
+		///
+		/// If it fails, [`ArithmeticError`] is returned.
+		///
+		/// # Examples
+		///
+		/// ```
+		/// use sp_arithmetic::traits::EnsureDivAssign;
+		///
+		/// let mut a: i32 = 20;
+		/// let b: i32 = 10;
+		///
+		/// a.ensure_div_assign(b).unwrap();
+		/// assert_eq!(a, 2);
+		/// ```
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureDivAssign, ArithmeticError, FixedI64};
+		///
+		/// fn extrinsic_zero() -> Result<(), ArithmeticError> {
+		///     let mut one = 1;
+		///     one.ensure_div_assign(0)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     let mut min = FixedI64::from(i64::MIN);
+		///     min.ensure_div_assign(FixedI64::from(-1))?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(extrinsic_zero(), Err(ArithmeticError::DivisionByZero));
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// ```
+		fn ensure_div_assign(&mut self, v: Self) -> Result<(), ArithmeticError> {
+			*self = self.checked_div(&v).ok_or_else(|| error::division(self, &v))?;
+			Ok(())
+		}
+	}
+
+	impl<T: CheckedAdd + PartialOrd + Zero> EnsureAddAssign for T {}
+	impl<T: CheckedSub + PartialOrd + Zero> EnsureSubAssign for T {}
+	impl<T: CheckedMul + PartialOrd + Zero> EnsureMulAssign for T {}
+	impl<T: CheckedDiv + PartialOrd + Zero> EnsureDivAssign for T {}
+
+	/// Meta trait that supports all assigned arithmetic `Ensure*` operations
+	pub trait EnsureOpAssign:
+		EnsureAddAssign + EnsureSubAssign + EnsureMulAssign + EnsureDivAssign
+	{
+	}
+	impl<T: EnsureAddAssign + EnsureSubAssign + EnsureMulAssign + EnsureDivAssign> EnsureOpAssign
+		for T
+	{
+	}
+
+	pub trait Ensure: EnsureOp + EnsureOpAssign {}
+	impl<T: EnsureOp + EnsureOpAssign> Ensure for T {}
+
+	/// Extends [`FixedPointNumber`] with the Ensure family functions.
+	pub trait EnsureFixedPointNumber: FixedPointNumber {
+		/// Creates `self` from a rational number. Equal to `n / d`.
+		///
+		/// Returns [`ArithmeticError`] if `d == 0` or `n / d` exceeds accuracy.
+		///
+		/// Similar to [`FixedPointNumber::checked_from_rational()`] but returning an
+		/// [`ArithmeticError`] error.
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureFixedPointNumber, ArithmeticError, FixedI64};
+		///
+		/// fn extrinsic_zero() -> Result<(), ArithmeticError> {
+		///     FixedI64::ensure_from_rational(1, 0)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     FixedI64::ensure_from_rational(i64::MAX, -1)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(extrinsic_zero(), Err(ArithmeticError::DivisionByZero));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_from_rational<N: FixedPointOperand, D: FixedPointOperand>(
+			n: N,
+			d: D,
+		) -> Result<Self, ArithmeticError> {
+			<Self as FixedPointNumber>::checked_from_rational(n, d)
+				.ok_or_else(|| error::division(&n, &d))
+		}
+
+		/// Ensure multiplication for integer type `N`. Equal to `self * n`.
+		///
+		/// Returns [`ArithmeticError`] if the result does not fit in `N`.
+		///
+		/// Similar to [`FixedPointNumber::checked_mul_int()`] but returning an [`ArithmeticError`]
+		/// error.
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureFixedPointNumber, ArithmeticError, FixedI64};
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     FixedI64::from(i64::MAX).ensure_mul_int(2)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     FixedI64::from(i64::MAX).ensure_mul_int(-2)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_mul_int<N: FixedPointOperand>(self, n: N) -> Result<N, ArithmeticError> {
+			self.checked_mul_int(n).ok_or_else(|| error::multiplication(&self, &n))
+		}
+
+		/// Ensure division for integer type `N`. Equal to `self / d`.
+		///
+		/// Returns [`ArithmeticError`] if the result does not fit in `N` or `d == 0`.
+		///
+		/// Similar to [`FixedPointNumber::checked_div_int()`] but returning an [`ArithmeticError`]
+		/// error.
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureFixedPointNumber, ArithmeticError, FixedI64};
+		///
+		/// fn extrinsic_zero() -> Result<(), ArithmeticError> {
+		///     FixedI64::from(1).ensure_div_int(0)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     FixedI64::from(i64::MIN).ensure_div_int(-1)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(extrinsic_zero(), Err(ArithmeticError::DivisionByZero));
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// ```
+		fn ensure_div_int<D: FixedPointOperand>(self, d: D) -> Result<D, ArithmeticError> {
+			self.checked_div_int(d).ok_or_else(|| error::division(&self, &d))
+		}
+	}
+
+	impl<T: FixedPointNumber> EnsureFixedPointNumber for T {}
+
+	/// Similar to [`TryFrom`] but returning an [`ArithmeticError`] error.
+	pub trait EnsureFrom<T: PartialOrd + Zero>: TryFrom<T> + PartialOrd + Zero {
+		/// Performs the conversion returning an [`ArithmeticError`] if fails.
+		///
+		/// Similar to [`TryFrom::try_from()`] but returning an [`ArithmeticError`] error.
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureFrom, ArithmeticError};
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     let byte: u8 = u8::ensure_from(256u16)?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     let byte: i8 = i8::ensure_from(-129i16)?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_from(other: T) -> Result<Self, ArithmeticError> {
+			let err = error::equivalent(&other);
+			Self::try_from(other).map_err(|_| err)
+		}
+	}
+
+	/// Similar to [`TryInto`] but returning an [`ArithmeticError`] error.
+	pub trait EnsureInto<T: PartialOrd + Zero>: TryInto<T> + PartialOrd + Zero {
+		/// Performs the conversion returning an [`ArithmeticError`] if fails.
+		///
+		/// Similar to [`TryInto::try_into()`] but returning an [`ArithmeticError`] error
+		///
+		/// ```
+		/// use sp_arithmetic::{traits::EnsureInto, ArithmeticError};
+		///
+		/// fn overflow() -> Result<(), ArithmeticError> {
+		///     let byte: u8 = 256u16.ensure_into()?;
+		///     Ok(())
+		/// }
+		///
+		/// fn underflow() -> Result<(), ArithmeticError> {
+		///     let byte: i8 = (-129i16).ensure_into()?;
+		///     Ok(())
+		/// }
+		///
+		/// assert_eq!(overflow(), Err(ArithmeticError::Overflow));
+		/// assert_eq!(underflow(), Err(ArithmeticError::Underflow));
+		/// ```
+		fn ensure_into(self) -> Result<T, ArithmeticError> {
+			let err = error::equivalent(&self);
+			self.try_into().map_err(|_| err)
+		}
+	}
+
+	impl<T: TryFrom<S> + PartialOrd + Zero, S: PartialOrd + Zero> EnsureFrom<S> for T {}
+	impl<T: TryInto<S> + PartialOrd + Zero, S: PartialOrd + Zero> EnsureInto<S> for T {}
+
+	mod error {
+		use super::{ArithmeticError, Zero};
+
+		#[derive(PartialEq)]
+		enum Signum {
+			Negative,
+			Positive,
+		}
+
+		impl<T: PartialOrd + Zero> From<&T> for Signum {
+			fn from(value: &T) -> Self {
+				if value < &Zero::zero() {
+					Signum::Negative
+				} else {
+					Signum::Positive
+				}
+			}
+		}
+
+		impl sp_std::ops::Mul for Signum {
+			type Output = Self;
+
+			fn mul(self, rhs: Self) -> Self {
+				if self != rhs {
+					Signum::Negative
+				} else {
+					Signum::Positive
+				}
+			}
+		}
+
+		pub fn equivalent<R: PartialOrd + Zero>(r: &R) -> ArithmeticError {
+			match Signum::from(r) {
+				Signum::Negative => ArithmeticError::Underflow,
+				Signum::Positive => ArithmeticError::Overflow,
+			}
+		}
+
+		pub fn inverse<R: PartialOrd + Zero>(r: &R) -> ArithmeticError {
+			match Signum::from(r) {
+				Signum::Negative => ArithmeticError::Overflow,
+				Signum::Positive => ArithmeticError::Underflow,
+			}
+		}
+
+		pub fn multiplication<L: PartialOrd + Zero, R: PartialOrd + Zero>(
+			l: &L,
+			r: &R,
+		) -> ArithmeticError {
+			match Signum::from(l) * Signum::from(r) {
+				Signum::Negative => ArithmeticError::Underflow,
+				Signum::Positive => ArithmeticError::Overflow,
+			}
+		}
+
+		pub fn division<N: PartialOrd + Zero, D: PartialOrd + Zero>(
+			n: &N,
+			d: &D,
+		) -> ArithmeticError {
+			if d.is_zero() {
+				ArithmeticError::DivisionByZero
+			} else {
+				multiplication(n, d)
+			}
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::ArithmeticError;
+	use rand::{seq::SliceRandom, thread_rng, Rng};
+
+	#[test]
+	fn ensure_add_works() {
+		test_ensure(values(), &EnsureAdd::ensure_add, &CheckedAdd::checked_add);
+	}
+
+	#[test]
+	fn ensure_sub_works() {
+		test_ensure(values(), &EnsureSub::ensure_sub, &CheckedSub::checked_sub);
+	}
+
+	#[test]
+	fn ensure_mul_works() {
+		test_ensure(values(), &EnsureMul::ensure_mul, &CheckedMul::checked_mul);
+	}
+
+	#[test]
+	fn ensure_div_works() {
+		test_ensure(values(), &EnsureDiv::ensure_div, &CheckedDiv::checked_div);
+	}
+
+	#[test]
+	fn ensure_pow_works() {
+		test_ensure(
+			values().into_iter().map(|(base, exp)| (base, exp as usize)).collect(),
+			ensure_pow,
+			|&a, &b| checked_pow(a, b),
+		);
+	}
+
+	#[test]
+	fn ensure_add_assign_works() {
+		test_ensure_assign(values(), &EnsureAddAssign::ensure_add_assign, &EnsureAdd::ensure_add);
+	}
+
+	#[test]
+	fn ensure_sub_assign_works() {
+		test_ensure_assign(values(), &EnsureSubAssign::ensure_sub_assign, &EnsureSub::ensure_sub);
+	}
+
+	#[test]
+	fn ensure_mul_assign_works() {
+		test_ensure_assign(values(), &EnsureMulAssign::ensure_mul_assign, &&EnsureMul::ensure_mul);
+	}
+
+	#[test]
+	fn ensure_div_assign_works() {
+		test_ensure_assign(values(), &EnsureDivAssign::ensure_div_assign, &EnsureDiv::ensure_div);
+	}
+
+	/// Test that the ensured function returns the expected un-ensured value.
+	fn test_ensure<V, W, E, P>(pairs: Vec<(V, W)>, ensured: E, unensured: P)
+	where
+		V: Ensure + core::fmt::Debug + Copy,
+		W: Ensure + core::fmt::Debug + Copy,
+		E: Fn(V, W) -> Result<V, ArithmeticError>,
+		P: Fn(&V, &W) -> Option<V>,
+	{
+		for (a, b) in pairs.into_iter() {
+			match ensured(a, b) {
+				Ok(c) => {
+					assert_eq!(unensured(&a, &b), Some(c))
+				},
+				Err(_) => {
+					assert!(unensured(&a, &b).is_none());
+				},
+			}
+		}
+	}
+
+	/// Test that the ensured function modifies `self` to the expected un-ensured value.
+	fn test_ensure_assign<V, W, E, P>(pairs: Vec<(V, W)>, ensured: E, unensured: P)
+	where
+		V: Ensure + std::panic::RefUnwindSafe + std::panic::UnwindSafe + core::fmt::Debug + Copy,
+		W: Ensure + std::panic::RefUnwindSafe + std::panic::UnwindSafe + core::fmt::Debug + Copy,
+		E: Fn(&mut V, W) -> Result<(), ArithmeticError>,
+		P: Fn(V, W) -> Result<V, ArithmeticError> + std::panic::RefUnwindSafe,
+	{
+		for (mut a, b) in pairs.into_iter() {
+			let old_a = a;
+
+			match ensured(&mut a, b) {
+				Ok(()) => {
+					assert_eq!(unensured(old_a, b), Ok(a));
+				},
+				Err(err) => {
+					assert_eq!(a, old_a, "A stays unmodified in the error case");
+					assert_eq!(unensured(old_a, b), Err(err));
+				},
+			}
+		}
+	}
+
+	/// Generates some good values for testing integer arithmetic.
+	fn values() -> Vec<(i32, i32)> {
+		let mut rng = thread_rng();
+		let mut one_dimension = || {
+			let mut ret = vec![0i32; 1007];
+			// Some hard-coded interesting values.
+			ret[..7].copy_from_slice(&[-1, 0, 1, i32::MIN, i32::MAX, i32::MAX - 1, i32::MIN + 1]);
+			// … and some random ones.
+			rng.fill(&mut ret[7..]);
+			ret.shuffle(&mut rng);
+			ret
+		};
+		one_dimension().into_iter().zip(one_dimension().into_iter()).collect()
+	}
+}
diff --git a/substrate/primitives/authority-discovery/Cargo.toml b/substrate/primitives/authority-discovery/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8e47208238a3924797c4c3a2d6a34797542bb3f8
--- /dev/null
+++ b/substrate/primitives/authority-discovery/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "sp-authority-discovery"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Authority discovery primitives"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../application-crypto" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+serde = [
+	"scale-info/serde",
+	"sp-application-crypto/serde",
+	"sp-runtime/serde",
+]
diff --git a/substrate/primitives/authority-discovery/README.md b/substrate/primitives/authority-discovery/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..65c2e22dde004483fdcff27d9a4b4392753bff3a
--- /dev/null
+++ b/substrate/primitives/authority-discovery/README.md
@@ -0,0 +1,3 @@
+Runtime Api to help discover authorities.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/authority-discovery/src/lib.rs b/substrate/primitives/authority-discovery/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3b25e39d4045e872d2892aa7e992d4140950479e
--- /dev/null
+++ b/substrate/primitives/authority-discovery/src/lib.rs
@@ -0,0 +1,49 @@
+// 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.
+
+//! Runtime Api to help discover authorities.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_std::vec::Vec;
+
+mod app {
+	use sp_application_crypto::{app_crypto, key_types::AUTHORITY_DISCOVERY, sr25519};
+	app_crypto!(sr25519, AUTHORITY_DISCOVERY);
+}
+
+sp_application_crypto::with_pair! {
+	/// An authority discovery authority keypair.
+	pub type AuthorityPair = app::Pair;
+}
+
+/// An authority discovery authority identifier.
+pub type AuthorityId = app::Public;
+
+/// An authority discovery authority signature.
+pub type AuthoritySignature = app::Signature;
+
+sp_api::decl_runtime_apis! {
+	/// The authority discovery api.
+	///
+	/// This api is used by the `client/authority-discovery` module to retrieve identifiers
+	/// of the current and next authority set.
+	pub trait AuthorityDiscoveryApi {
+		/// Retrieve authority identifiers of the current and next authority set.
+		fn authorities() -> Vec<AuthorityId>;
+	}
+}
diff --git a/substrate/primitives/block-builder/Cargo.toml b/substrate/primitives/block-builder/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1b62747770a6e78ad5454071f86e5779d0262fdf
--- /dev/null
+++ b/substrate/primitives/block-builder/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "sp-block-builder"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "The block builder runtime api."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../inherents" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [ "sp-api/std", "sp-inherents/std", "sp-runtime/std", "sp-std/std" ]
diff --git a/substrate/primitives/block-builder/README.md b/substrate/primitives/block-builder/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..433197d3be9e4104606809bab2834e16e8bcf065
--- /dev/null
+++ b/substrate/primitives/block-builder/README.md
@@ -0,0 +1,3 @@
+The block builder runtime api.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/block-builder/src/lib.rs b/substrate/primitives/block-builder/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..29e04857f463ee04c8f39b6c885437992e0d911c
--- /dev/null
+++ b/substrate/primitives/block-builder/src/lib.rs
@@ -0,0 +1,52 @@
+// 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.
+
+//! The block builder runtime api.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_inherents::{CheckInherentsResult, InherentData};
+use sp_runtime::{traits::Block as BlockT, ApplyExtrinsicResult};
+
+sp_api::decl_runtime_apis! {
+	/// The `BlockBuilder` api trait that provides the required functionality for building a block.
+	#[api_version(6)]
+	pub trait BlockBuilder {
+		/// Apply the given extrinsic.
+		///
+		/// Returns an inclusion outcome which specifies if this extrinsic is included in
+		/// this block or not.
+		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult;
+
+		#[changed_in(6)]
+		fn apply_extrinsic(
+			extrinsic: <Block as BlockT>::Extrinsic,
+		) -> sp_runtime::legacy::byte_sized_error::ApplyExtrinsicResult;
+
+		/// Finish the current block.
+		#[renamed("finalise_block", 3)]
+		fn finalize_block() -> <Block as BlockT>::Header;
+
+		/// Generate inherent extrinsics. The inherent data will vary from chain to chain.
+		fn inherent_extrinsics(
+			inherent: InherentData,
+		) -> sp_std::vec::Vec<<Block as BlockT>::Extrinsic>;
+
+		/// Check that the inherents are valid. The inherent data will vary from chain to chain.
+		fn check_inherents(block: Block, data: InherentData) -> CheckInherentsResult;
+	}
+}
diff --git a/substrate/primitives/blockchain/Cargo.toml b/substrate/primitives/blockchain/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6320fab9390b9649df5ddb162a79ce0d01e32143
--- /dev/null
+++ b/substrate/primitives/blockchain/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "sp-blockchain"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate blockchain traits and primitives."
+documentation = "https://docs.rs/sp-blockchain"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+futures = "0.3.21"
+log = "0.4.17"
+parking_lot = "0.12.1"
+schnellru = "0.2.1"
+thiserror = "1.0.30"
+sp-api = { version = "4.0.0-dev", path = "../api" }
+sp-consensus = { version = "0.10.0-dev", path = "../consensus/common" }
+sp-database = { version = "4.0.0-dev", path = "../database" }
+sp-runtime = { version = "24.0.0", path = "../runtime" }
+sp-state-machine = { version = "0.28.0", path = "../state-machine" }
diff --git a/substrate/primitives/blockchain/README.md b/substrate/primitives/blockchain/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8298bfd7ae60a5d9a6be9c24ae4c7831e72f2bd0
--- /dev/null
+++ b/substrate/primitives/blockchain/README.md
@@ -0,0 +1,3 @@
+Substrate blockchain traits and primitives.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/blockchain/src/backend.rs b/substrate/primitives/blockchain/src/backend.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8208f9128e714511c2a3604d7d754e4d87d62530
--- /dev/null
+++ b/substrate/primitives/blockchain/src/backend.rs
@@ -0,0 +1,288 @@
+// 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.
+
+//! Substrate blockchain trait
+
+use log::warn;
+use parking_lot::RwLock;
+use sp_runtime::{
+	generic::BlockId,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor, Saturating},
+	Justifications,
+};
+use std::collections::btree_set::BTreeSet;
+
+use crate::header_metadata::HeaderMetadata;
+
+use crate::error::{Error, Result};
+
+/// Blockchain database header backend. Does not perform any validation.
+pub trait HeaderBackend<Block: BlockT>: Send + Sync {
+	/// Get block header. Returns `None` if block is not found.
+	fn header(&self, hash: Block::Hash) -> Result<Option<Block::Header>>;
+	/// Get blockchain info.
+	fn info(&self) -> Info<Block>;
+	/// Get block status.
+	fn status(&self, hash: Block::Hash) -> Result<BlockStatus>;
+	/// Get block number by hash. Returns `None` if the header is not in the chain.
+	fn number(
+		&self,
+		hash: Block::Hash,
+	) -> Result<Option<<<Block as BlockT>::Header as HeaderT>::Number>>;
+	/// Get block hash by number. Returns `None` if the header is not in the chain.
+	fn hash(&self, number: NumberFor<Block>) -> Result<Option<Block::Hash>>;
+
+	/// Convert an arbitrary block ID into a block hash.
+	fn block_hash_from_id(&self, id: &BlockId<Block>) -> Result<Option<Block::Hash>> {
+		match *id {
+			BlockId::Hash(h) => Ok(Some(h)),
+			BlockId::Number(n) => self.hash(n),
+		}
+	}
+
+	/// Convert an arbitrary block ID into a block hash.
+	fn block_number_from_id(&self, id: &BlockId<Block>) -> Result<Option<NumberFor<Block>>> {
+		match *id {
+			BlockId::Hash(h) => self.number(h),
+			BlockId::Number(n) => Ok(Some(n)),
+		}
+	}
+
+	/// Get block header. Returns `UnknownBlock` error if block is not found.
+	fn expect_header(&self, hash: Block::Hash) -> Result<Block::Header> {
+		self.header(hash)?
+			.ok_or_else(|| Error::UnknownBlock(format!("Expect header: {}", hash)))
+	}
+
+	/// Convert an arbitrary block ID into a block number. Returns `UnknownBlock` error if block is
+	/// not found.
+	fn expect_block_number_from_id(&self, id: &BlockId<Block>) -> Result<NumberFor<Block>> {
+		self.block_number_from_id(id).and_then(|n| {
+			n.ok_or_else(|| Error::UnknownBlock(format!("Expect block number from id: {}", id)))
+		})
+	}
+
+	/// Convert an arbitrary block ID into a block hash. Returns `UnknownBlock` error if block is
+	/// not found.
+	fn expect_block_hash_from_id(&self, id: &BlockId<Block>) -> Result<Block::Hash> {
+		self.block_hash_from_id(id).and_then(|h| {
+			h.ok_or_else(|| Error::UnknownBlock(format!("Expect block hash from id: {}", id)))
+		})
+	}
+}
+
+/// Handles stale forks.
+pub trait ForkBackend<Block: BlockT>:
+	HeaderMetadata<Block> + HeaderBackend<Block> + Send + Sync
+{
+	/// Best effort to get all the header hashes that are part of the provided forks
+	/// starting only from the fork heads.
+	///
+	/// The function tries to reconstruct the route from the fork head to the canonical chain.
+	/// If any of the hashes on the route can't be found in the db, the function won't be able
+	/// to reconstruct the route anymore. In this case it will give up expanding the current fork,
+	/// move on to the next ones and at the end it will return an error that also contains
+	/// the partially expanded forks.
+	fn expand_forks(
+		&self,
+		fork_heads: &[Block::Hash],
+	) -> std::result::Result<BTreeSet<Block::Hash>, (BTreeSet<Block::Hash>, Error)> {
+		let mut missing_blocks = vec![];
+		let mut expanded_forks = BTreeSet::new();
+		for fork_head in fork_heads {
+			let mut route_head = *fork_head;
+			// Insert stale blocks hashes until canonical chain is reached.
+			// If we reach a block that is already part of the `expanded_forks` we can stop
+			// processing the fork.
+			while expanded_forks.insert(route_head) {
+				match self.header_metadata(route_head) {
+					Ok(meta) => {
+						// If the parent is part of the canonical chain or there doesn't exist a
+						// block hash for the parent number (bug?!), we can abort adding blocks.
+						let parent_number = meta.number.saturating_sub(1u32.into());
+						match self.hash(parent_number) {
+							Ok(Some(parent_hash)) =>
+								if parent_hash == meta.parent {
+									break
+								},
+							Ok(None) | Err(_) => {
+								missing_blocks.push(BlockId::<Block>::Number(parent_number));
+								break
+							},
+						}
+
+						route_head = meta.parent;
+					},
+					Err(_e) => {
+						missing_blocks.push(BlockId::<Block>::Hash(route_head));
+						break
+					},
+				}
+			}
+		}
+
+		if !missing_blocks.is_empty() {
+			return Err((
+				expanded_forks,
+				Error::UnknownBlocks(format!(
+					"Missing stale headers {:?} while expanding forks {:?}.",
+					fork_heads, missing_blocks
+				)),
+			))
+		}
+
+		Ok(expanded_forks)
+	}
+}
+
+impl<Block, T> ForkBackend<Block> for T
+where
+	Block: BlockT,
+	T: HeaderMetadata<Block> + HeaderBackend<Block> + Send + Sync,
+{
+}
+
+/// Blockchain database backend. Does not perform any validation.
+pub trait Backend<Block: BlockT>:
+	HeaderBackend<Block> + HeaderMetadata<Block, Error = Error>
+{
+	/// Get block body. Returns `None` if block is not found.
+	fn body(&self, hash: Block::Hash) -> Result<Option<Vec<<Block as BlockT>::Extrinsic>>>;
+	/// Get block justifications. Returns `None` if no justification exists.
+	fn justifications(&self, hash: Block::Hash) -> Result<Option<Justifications>>;
+	/// Get last finalized block hash.
+	fn last_finalized(&self) -> Result<Block::Hash>;
+
+	/// Returns hashes of all blocks that are leaves of the block tree.
+	/// in other words, that have no children, are chain heads.
+	/// Results must be ordered best (longest, highest) chain first.
+	fn leaves(&self) -> Result<Vec<Block::Hash>>;
+
+	/// Returns displaced leaves after the given block would be finalized.
+	///
+	/// The returned leaves do not contain the leaves from the same height as `block_number`.
+	fn displaced_leaves_after_finalizing(
+		&self,
+		block_number: NumberFor<Block>,
+	) -> Result<Vec<Block::Hash>>;
+
+	/// Return hashes of all blocks that are children of the block with `parent_hash`.
+	fn children(&self, parent_hash: Block::Hash) -> Result<Vec<Block::Hash>>;
+
+	/// Get the most recent block hash of the longest chain that contains
+	/// a block with the given `base_hash`.
+	///
+	/// The search space is always limited to blocks which are in the finalized
+	/// chain or descendents of it.
+	///
+	/// Returns `Ok(None)` if `base_hash` is not found in search space.
+	// TODO: document time complexity of this, see [#1444](https://github.com/paritytech/substrate/issues/1444)
+	fn longest_containing(
+		&self,
+		base_hash: Block::Hash,
+		import_lock: &RwLock<()>,
+	) -> Result<Option<Block::Hash>> {
+		let Some(base_header) = self.header(base_hash)? else { return Ok(None) };
+
+		let leaves = {
+			// ensure no blocks are imported during this code block.
+			// an import could trigger a reorg which could change the canonical chain.
+			// we depend on the canonical chain staying the same during this code block.
+			let _import_guard = import_lock.read();
+			let info = self.info();
+			if info.finalized_number > *base_header.number() {
+				// `base_header` is on a dead fork.
+				return Ok(None)
+			}
+			self.leaves()?
+		};
+
+		// for each chain. longest chain first. shortest last
+		for leaf_hash in leaves {
+			let mut current_hash = leaf_hash;
+			// go backwards through the chain (via parent links)
+			loop {
+				if current_hash == base_hash {
+					return Ok(Some(leaf_hash))
+				}
+
+				let current_header = self
+					.header(current_hash)?
+					.ok_or_else(|| Error::MissingHeader(current_hash.to_string()))?;
+
+				// stop search in this chain once we go below the target's block number
+				if current_header.number() < base_header.number() {
+					break
+				}
+
+				current_hash = *current_header.parent_hash();
+			}
+		}
+
+		// header may be on a dead fork -- the only leaves that are considered are
+		// those which can still be finalized.
+		//
+		// FIXME #1558 only issue this warning when not on a dead fork
+		warn!(
+			"Block {:?} exists in chain but not found when following all leaves backwards",
+			base_hash,
+		);
+
+		Ok(None)
+	}
+
+	/// Get single indexed transaction by content hash. Note that this will only fetch transactions
+	/// that are indexed by the runtime with `storage_index_transaction`.
+	fn indexed_transaction(&self, hash: Block::Hash) -> Result<Option<Vec<u8>>>;
+
+	/// Check if indexed transaction exists.
+	fn has_indexed_transaction(&self, hash: Block::Hash) -> Result<bool> {
+		Ok(self.indexed_transaction(hash)?.is_some())
+	}
+
+	fn block_indexed_body(&self, hash: Block::Hash) -> Result<Option<Vec<Vec<u8>>>>;
+}
+
+/// Blockchain info
+#[derive(Debug, Eq, PartialEq)]
+pub struct Info<Block: BlockT> {
+	/// Best block hash.
+	pub best_hash: Block::Hash,
+	/// Best block number.
+	pub best_number: <<Block as BlockT>::Header as HeaderT>::Number,
+	/// Genesis block hash.
+	pub genesis_hash: Block::Hash,
+	/// The head of the finalized chain.
+	pub finalized_hash: Block::Hash,
+	/// Last finalized block number.
+	pub finalized_number: <<Block as BlockT>::Header as HeaderT>::Number,
+	/// Last finalized state.
+	pub finalized_state: Option<(Block::Hash, <<Block as BlockT>::Header as HeaderT>::Number)>,
+	/// Number of concurrent leave forks.
+	pub number_leaves: usize,
+	/// Missing blocks after warp sync. (start, end).
+	pub block_gap: Option<(NumberFor<Block>, NumberFor<Block>)>,
+}
+
+/// Block status.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BlockStatus {
+	/// Already in the blockchain.
+	InChain,
+	/// Not in the queue or the blockchain.
+	Unknown,
+}
diff --git a/substrate/primitives/blockchain/src/error.rs b/substrate/primitives/blockchain/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..74a2ed3fba50d1b349370a831a92af5d8e78950f
--- /dev/null
+++ b/substrate/primitives/blockchain/src/error.rs
@@ -0,0 +1,224 @@
+// 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.
+
+//! Substrate client possible errors.
+
+use codec::Error as CodecError;
+use sp_api::ApiError;
+use sp_consensus;
+use sp_runtime::transaction_validity::TransactionValidityError;
+use sp_state_machine;
+use std::{self, result};
+
+/// Client Result type alias
+pub type Result<T> = result::Result<T, Error>;
+
+/// Error when the runtime failed to apply an extrinsic.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum ApplyExtrinsicFailed {
+	/// The transaction cannot be included into the current block.
+	///
+	/// This doesn't necessary mean that the transaction itself is invalid, but it might be just
+	/// unappliable onto the current block.
+	#[error("Extrinsic is not valid: {0:?}")]
+	Validity(#[from] TransactionValidityError),
+
+	#[error("Application specific error")]
+	Application(#[source] Box<dyn 'static + std::error::Error + Send + Sync>),
+}
+
+/// Substrate Client error
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+#[non_exhaustive]
+pub enum Error {
+	#[error("Cancelled oneshot channel {0}")]
+	OneShotCancelled(#[from] futures::channel::oneshot::Canceled),
+
+	#[error(transparent)]
+	Consensus(#[from] sp_consensus::Error),
+
+	#[error("Backend error: {0}")]
+	Backend(String),
+
+	#[error("UnknownBlock: {0}")]
+	UnknownBlock(String),
+
+	#[error("UnknownBlocks: {0}")]
+	UnknownBlocks(String),
+
+	#[error(transparent)]
+	ApplyExtrinsicFailed(#[from] ApplyExtrinsicFailed),
+
+	#[error("Child type is invalid")]
+	InvalidChildType,
+
+	#[error("RemoteBodyRequest: invalid extrinsics root expected: {expected} but got {received}")]
+	ExtrinsicRootInvalid { received: String, expected: String },
+
+	// `inner` cannot be made member, since it lacks `std::error::Error` trait bounds.
+	#[error("Execution failed: {0}")]
+	Execution(Box<dyn sp_state_machine::Error>),
+
+	#[error("Blockchain")]
+	Blockchain(#[source] Box<Error>),
+
+	/// A error used by various storage subsystems.
+	///
+	/// Eventually this will be replaced.
+	#[error("{0}")]
+	StorageChanges(sp_state_machine::DefaultError),
+
+	#[error("Invalid child storage key")]
+	InvalidChildStorageKey,
+
+	#[error("Current state of blockchain has invalid authorities set")]
+	InvalidAuthoritiesSet,
+
+	#[error("Failed to get runtime version: {0}")]
+	VersionInvalid(String),
+
+	#[error("Provided state is invalid")]
+	InvalidState,
+
+	#[error("error decoding justification for header")]
+	JustificationDecode,
+
+	#[error("bad justification for header: {0}")]
+	BadJustification(String),
+
+	#[error("This method is not currently available when running in light client mode")]
+	NotAvailableOnLightClient,
+
+	#[error("Remote node has responded with invalid header proof")]
+	InvalidCHTProof,
+
+	#[error("Remote data fetch has been cancelled")]
+	RemoteFetchCancelled,
+
+	#[error("Remote data fetch has been failed")]
+	RemoteFetchFailed,
+
+	#[error("Error decoding call result of {0}")]
+	CallResultDecode(&'static str, #[source] CodecError),
+
+	#[error("Error at calling runtime api: {0}")]
+	RuntimeApiError(#[from] ApiError),
+
+	#[error("Runtime :code missing in storage")]
+	RuntimeCodeMissing,
+
+	#[error("Changes tries are not supported by the runtime")]
+	ChangesTriesNotSupported,
+
+	#[error("Error reading changes tries configuration")]
+	ErrorReadingChangesTriesConfig,
+
+	#[error("Failed to check changes proof: {0}")]
+	ChangesTrieAccessFailed(String),
+
+	#[error("Did not finalize blocks in sequential order.")]
+	NonSequentialFinalization(String),
+
+	#[error("Potential long-range attack: block not in finalized chain.")]
+	NotInFinalizedChain,
+
+	#[error("Failed to get hash of block for building CHT")]
+	MissingHashRequiredForCHT,
+
+	#[error("Calculated state root does not match.")]
+	InvalidStateRoot,
+
+	#[error("Incomplete block import pipeline.")]
+	IncompletePipeline,
+
+	#[error("Transaction pool not ready for block production.")]
+	TransactionPoolNotReady,
+
+	#[error("Database error: {0}")]
+	DatabaseError(#[from] sp_database::error::DatabaseError),
+
+	#[error("Failed to get header for hash {0}")]
+	MissingHeader(String),
+
+	#[error("State Database error: {0}")]
+	StateDatabase(String),
+
+	#[error("Statement store error: {0}")]
+	StatementStore(String),
+
+	#[error("Failed to set the chain head to a block that's too old.")]
+	SetHeadTooOld,
+
+	#[error(transparent)]
+	Application(#[from] Box<dyn std::error::Error + Send + Sync + 'static>),
+
+	// Should be removed/improved once
+	// the storage `fn`s returns typed errors.
+	#[error("Runtime code error: {0}")]
+	RuntimeCode(&'static str),
+
+	// Should be removed/improved once
+	// the storage `fn`s returns typed errors.
+	#[error("Storage error: {0}")]
+	Storage(String),
+}
+
+impl From<Box<dyn sp_state_machine::Error + Send + Sync + 'static>> for Error {
+	fn from(e: Box<dyn sp_state_machine::Error + Send + Sync + 'static>) -> Self {
+		Self::from_state(e)
+	}
+}
+
+impl From<Box<dyn sp_state_machine::Error>> for Error {
+	fn from(e: Box<dyn sp_state_machine::Error>) -> Self {
+		Self::from_state(e)
+	}
+}
+
+impl From<Error> for ApiError {
+	fn from(err: Error) -> ApiError {
+		match err {
+			Error::UnknownBlock(msg) => ApiError::UnknownBlock(msg),
+			Error::RuntimeApiError(err) => err,
+			e => ApiError::Application(Box::new(e)),
+		}
+	}
+}
+
+impl Error {
+	/// Chain a blockchain error.
+	pub fn from_blockchain(e: Box<Error>) -> Self {
+		Error::Blockchain(e)
+	}
+
+	/// Chain a state error.
+	pub fn from_state(e: Box<dyn sp_state_machine::Error>) -> Self {
+		Error::Execution(e)
+	}
+
+	/// Construct from a state db error.
+	// Can not be done directly, since that would make cargo run out of stack if
+	// `sc-state-db` is lib is added as dependency.
+	pub fn from_state_db<E>(e: E) -> Self
+	where
+		E: std::fmt::Debug,
+	{
+		Error::StateDatabase(format!("{:?}", e))
+	}
+}
diff --git a/substrate/primitives/blockchain/src/header_metadata.rs b/substrate/primitives/blockchain/src/header_metadata.rs
new file mode 100644
index 0000000000000000000000000000000000000000..08b3c9ab3dfbda6acc7a0ad6b575c518dc97ecc3
--- /dev/null
+++ b/substrate/primitives/blockchain/src/header_metadata.rs
@@ -0,0 +1,300 @@
+// 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.
+
+//! Implements tree backend, cached header metadata and algorithms
+//! to compute routes efficiently over the tree of headers.
+
+use parking_lot::RwLock;
+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;
+
+/// Get lowest common ancestor between two blocks in the tree.
+///
+/// This implementation is efficient because our trees have very few and
+/// small branches, and because of our current query pattern:
+/// lca(best, final), lca(best + 1, final), lca(best + 2, final), etc.
+/// The first call is O(h) but the others are O(1).
+pub fn lowest_common_ancestor<Block: BlockT, T: HeaderMetadata<Block> + ?Sized>(
+	backend: &T,
+	id_one: Block::Hash,
+	id_two: Block::Hash,
+) -> Result<HashAndNumber<Block>, T::Error> {
+	let mut header_one = backend.header_metadata(id_one)?;
+	if header_one.parent == id_two {
+		return Ok(HashAndNumber { hash: id_two, number: header_one.number - One::one() })
+	}
+
+	let mut header_two = backend.header_metadata(id_two)?;
+	if header_two.parent == id_one {
+		return Ok(HashAndNumber { hash: id_one, number: header_one.number })
+	}
+
+	let mut orig_header_one = header_one.clone();
+	let mut orig_header_two = header_two.clone();
+
+	// We move through ancestor links as much as possible, since ancestor >= parent.
+
+	while header_one.number > header_two.number {
+		let ancestor_one = backend.header_metadata(header_one.ancestor)?;
+
+		if ancestor_one.number >= header_two.number {
+			header_one = ancestor_one;
+		} else {
+			break
+		}
+	}
+
+	while header_one.number < header_two.number {
+		let ancestor_two = backend.header_metadata(header_two.ancestor)?;
+
+		if ancestor_two.number >= header_one.number {
+			header_two = ancestor_two;
+		} else {
+			break
+		}
+	}
+
+	// Then we move the remaining path using parent links.
+
+	while header_one.hash != header_two.hash {
+		if header_one.number > header_two.number {
+			header_one = backend.header_metadata(header_one.parent)?;
+		} else {
+			header_two = backend.header_metadata(header_two.parent)?;
+		}
+	}
+
+	// Update cached ancestor links.
+
+	if orig_header_one.number > header_one.number {
+		orig_header_one.ancestor = header_one.hash;
+		backend.insert_header_metadata(orig_header_one.hash, orig_header_one);
+	}
+
+	if orig_header_two.number > header_one.number {
+		orig_header_two.ancestor = header_one.hash;
+		backend.insert_header_metadata(orig_header_two.hash, orig_header_two);
+	}
+
+	Ok(HashAndNumber { hash: header_one.hash, number: header_one.number })
+}
+
+/// Compute a tree-route between two blocks. See tree-route docs for more details.
+pub fn tree_route<Block: BlockT, T: HeaderMetadata<Block>>(
+	backend: &T,
+	from: Block::Hash,
+	to: Block::Hash,
+) -> Result<TreeRoute<Block>, T::Error> {
+	let mut from = backend.header_metadata(from)?;
+	let mut to = backend.header_metadata(to)?;
+
+	let mut from_branch = Vec::new();
+	let mut to_branch = Vec::new();
+
+	while to.number > from.number {
+		to_branch.push(HashAndNumber { number: to.number, hash: to.hash });
+
+		to = backend.header_metadata(to.parent)?;
+	}
+
+	while from.number > to.number {
+		from_branch.push(HashAndNumber { number: from.number, hash: from.hash });
+		from = backend.header_metadata(from.parent)?;
+	}
+
+	// numbers are equal now. walk backwards until the block is the same
+
+	while to.hash != from.hash {
+		to_branch.push(HashAndNumber { number: to.number, hash: to.hash });
+		to = backend.header_metadata(to.parent)?;
+
+		from_branch.push(HashAndNumber { number: from.number, hash: from.hash });
+		from = backend.header_metadata(from.parent)?;
+	}
+
+	// add the pivot block. and append the reversed to-branch
+	// (note that it's reverse order originals)
+	let pivot = from_branch.len();
+	from_branch.push(HashAndNumber { number: to.number, hash: to.hash });
+	from_branch.extend(to_branch.into_iter().rev());
+
+	Ok(TreeRoute { route: from_branch, pivot })
+}
+
+/// Hash and number of a block.
+#[derive(Debug, Clone)]
+pub struct HashAndNumber<Block: BlockT> {
+	/// The number of the block.
+	pub number: NumberFor<Block>,
+	/// The hash of the block.
+	pub hash: Block::Hash,
+}
+
+/// A tree-route from one block to another in the chain.
+///
+/// All blocks prior to the pivot in the deque is the reverse-order unique ancestry
+/// of the first block, the block at the pivot index is the common ancestor,
+/// and all blocks after the pivot is the ancestry of the second block, in
+/// order.
+///
+/// The ancestry sets will include the given blocks, and thus the tree-route is
+/// never empty.
+///
+/// ```text
+/// Tree route from R1 to E2. Retracted is [R1, R2, R3], Common is C, enacted [E1, E2]
+///   <- R3 <- R2 <- R1
+///  /
+/// C
+///  \-> E1 -> E2
+/// ```
+///
+/// ```text
+/// Tree route from C to E2. Retracted empty. Common is C, enacted [E1, E2]
+/// C -> E1 -> E2
+/// ```
+#[derive(Debug, Clone)]
+pub struct TreeRoute<Block: BlockT> {
+	route: Vec<HashAndNumber<Block>>,
+	pivot: usize,
+}
+
+impl<Block: BlockT> TreeRoute<Block> {
+	/// Creates a new `TreeRoute`.
+	///
+	/// To preserve the structure safety invariats it is required that `pivot < route.len()`.
+	pub fn new(route: Vec<HashAndNumber<Block>>, pivot: usize) -> Result<Self, String> {
+		if pivot < route.len() {
+			Ok(TreeRoute { route, pivot })
+		} else {
+			Err(format!(
+				"TreeRoute pivot ({}) should be less than route length ({})",
+				pivot,
+				route.len()
+			))
+		}
+	}
+
+	/// Get a slice of all retracted blocks in reverse order (towards common ancestor).
+	pub fn retracted(&self) -> &[HashAndNumber<Block>] {
+		&self.route[..self.pivot]
+	}
+
+	/// Convert into all retracted blocks in reverse order (towards common ancestor).
+	pub fn into_retracted(mut self) -> Vec<HashAndNumber<Block>> {
+		self.route.truncate(self.pivot);
+		self.route
+	}
+
+	/// Get the common ancestor block. This might be one of the two blocks of the
+	/// route.
+	pub fn common_block(&self) -> &HashAndNumber<Block> {
+		self.route.get(self.pivot).expect(
+			"tree-routes are computed between blocks; \
+			which are included in the route; \
+			thus it is never empty; qed",
+		)
+	}
+
+	/// Get a slice of enacted blocks (descendents of the common ancestor)
+	pub fn enacted(&self) -> &[HashAndNumber<Block>] {
+		&self.route[self.pivot + 1..]
+	}
+
+	/// Returns the last block.
+	pub fn last(&self) -> Option<&HashAndNumber<Block>> {
+		self.route.last()
+	}
+}
+
+/// Handles header metadata: hash, number, parent hash, etc.
+pub trait HeaderMetadata<Block: BlockT> {
+	/// Error used in case the header metadata is not found.
+	type Error: std::error::Error;
+
+	fn header_metadata(
+		&self,
+		hash: Block::Hash,
+	) -> Result<CachedHeaderMetadata<Block>, Self::Error>;
+	fn insert_header_metadata(
+		&self,
+		hash: Block::Hash,
+		header_metadata: CachedHeaderMetadata<Block>,
+	);
+	fn remove_header_metadata(&self, hash: Block::Hash);
+}
+
+/// Caches header metadata in an in-memory LRU cache.
+pub struct HeaderMetadataCache<Block: BlockT> {
+	cache: RwLock<LruMap<Block::Hash, CachedHeaderMetadata<Block>>>,
+}
+
+impl<Block: BlockT> HeaderMetadataCache<Block> {
+	/// Creates a new LRU header metadata cache with `capacity`.
+	pub fn new(capacity: u32) -> Self {
+		HeaderMetadataCache { cache: RwLock::new(LruMap::new(ByLength::new(capacity))) }
+	}
+}
+
+impl<Block: BlockT> Default for HeaderMetadataCache<Block> {
+	fn default() -> Self {
+		HeaderMetadataCache { cache: RwLock::new(LruMap::new(ByLength::new(LRU_CACHE_SIZE))) }
+	}
+}
+
+impl<Block: BlockT> HeaderMetadataCache<Block> {
+	pub fn header_metadata(&self, hash: Block::Hash) -> Option<CachedHeaderMetadata<Block>> {
+		self.cache.write().get(&hash).cloned()
+	}
+
+	pub fn insert_header_metadata(&self, hash: Block::Hash, metadata: CachedHeaderMetadata<Block>) {
+		self.cache.write().insert(hash, metadata);
+	}
+
+	pub fn remove_header_metadata(&self, hash: Block::Hash) {
+		self.cache.write().remove(&hash);
+	}
+}
+
+/// Cached header metadata. Used to efficiently traverse the tree.
+#[derive(Debug, Clone)]
+pub struct CachedHeaderMetadata<Block: BlockT> {
+	/// Hash of the header.
+	pub hash: Block::Hash,
+	/// Block number.
+	pub number: NumberFor<Block>,
+	/// Hash of parent header.
+	pub parent: Block::Hash,
+	/// Block state root.
+	pub state_root: Block::Hash,
+	/// Hash of an ancestor header. Used to jump through the tree.
+	ancestor: Block::Hash,
+}
+
+impl<Block: BlockT> From<&Block::Header> for CachedHeaderMetadata<Block> {
+	fn from(header: &Block::Header) -> Self {
+		CachedHeaderMetadata {
+			hash: header.hash(),
+			number: *header.number(),
+			parent: *header.parent_hash(),
+			state_root: *header.state_root(),
+			ancestor: *header.parent_hash(),
+		}
+	}
+}
diff --git a/substrate/primitives/blockchain/src/lib.rs b/substrate/primitives/blockchain/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eabbbcf50d9f208c19d76ef81c8736e314e61a71
--- /dev/null
+++ b/substrate/primitives/blockchain/src/lib.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.
+
+//! Substrate blockchain traits and primitives.
+
+mod backend;
+mod error;
+mod header_metadata;
+
+pub use backend::*;
+pub use error::*;
+pub use header_metadata::*;
diff --git a/substrate/primitives/consensus/aura/Cargo.toml b/substrate/primitives/consensus/aura/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f841a65a7d6cfa2abe993828c758c74bbc1b40b9
--- /dev/null
+++ b/substrate/primitives/consensus/aura/Cargo.toml
@@ -0,0 +1,48 @@
+[package]
+name = "sp-consensus-aura"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Primitives for Aura consensus"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = { version = "0.1.57", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../api" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../application-crypto" }
+sp-consensus-slots = { version = "0.10.0-dev", default-features = false, path = "../slots" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../inherents" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../std" }
+sp-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../timestamp" }
+
+[features]
+default = [ "std" ]
+std = [
+	"async-trait",
+	"codec/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-consensus-slots/std",
+	"sp-inherents/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-timestamp/std",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"scale-info/serde",
+	"sp-application-crypto/serde",
+	"sp-consensus-slots/serde",
+	"sp-runtime/serde",
+]
diff --git a/substrate/primitives/consensus/aura/README.md b/substrate/primitives/consensus/aura/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f360ae67eb28a9145ad4c83980f6dff9a9d22f1
--- /dev/null
+++ b/substrate/primitives/consensus/aura/README.md
@@ -0,0 +1,3 @@
+Primitives for Aura.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/consensus/aura/src/digests.rs b/substrate/primitives/consensus/aura/src/digests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..13484da2a2955095e8558561e91724104cf141ac
--- /dev/null
+++ b/substrate/primitives/consensus/aura/src/digests.rs
@@ -0,0 +1,63 @@
+// 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/>.
+
+//! Aura (Authority-Round) digests
+//!
+//! This implements the digests for AuRa, to allow the private
+//! `CompatibleDigestItem` trait to appear in public interfaces.
+
+use crate::AURA_ENGINE_ID;
+use codec::{Codec, Encode};
+use sp_consensus_slots::Slot;
+use sp_runtime::generic::DigestItem;
+
+/// A digest item which is usable with aura consensus.
+pub trait CompatibleDigestItem<Signature>: Sized {
+	/// Construct a digest item which contains a signature on the hash.
+	fn aura_seal(signature: Signature) -> Self;
+
+	/// If this item is an Aura seal, return the signature.
+	fn as_aura_seal(&self) -> Option<Signature>;
+
+	/// Construct a digest item which contains the slot number
+	fn aura_pre_digest(slot: Slot) -> Self;
+
+	/// If this item is an AuRa pre-digest, return the slot number
+	fn as_aura_pre_digest(&self) -> Option<Slot>;
+}
+
+impl<Signature> CompatibleDigestItem<Signature> for DigestItem
+where
+	Signature: Codec,
+{
+	fn aura_seal(signature: Signature) -> Self {
+		DigestItem::Seal(AURA_ENGINE_ID, signature.encode())
+	}
+
+	fn as_aura_seal(&self) -> Option<Signature> {
+		self.seal_try_to(&AURA_ENGINE_ID)
+	}
+
+	fn aura_pre_digest(slot: Slot) -> Self {
+		DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())
+	}
+
+	fn as_aura_pre_digest(&self) -> Option<Slot> {
+		self.pre_runtime_try_to(&AURA_ENGINE_ID)
+	}
+}
diff --git a/substrate/primitives/consensus/aura/src/inherents.rs b/substrate/primitives/consensus/aura/src/inherents.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ef25feb0ad62ef71a96c9bd17a6dc3ac8385cb8
--- /dev/null
+++ b/substrate/primitives/consensus/aura/src/inherents.rs
@@ -0,0 +1,95 @@
+// 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.
+
+/// Contains the inherents for the AURA module
+use sp_inherents::{Error, InherentData, InherentIdentifier};
+
+/// The Aura inherent identifier.
+pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"auraslot";
+
+/// The type of the Aura inherent.
+pub type InherentType = sp_consensus_slots::Slot;
+
+/// Auxiliary trait to extract Aura inherent data.
+pub trait AuraInherentData {
+	/// Get aura inherent data.
+	fn aura_inherent_data(&self) -> Result<Option<InherentType>, Error>;
+	/// Replace aura inherent data.
+	fn aura_replace_inherent_data(&mut self, new: InherentType);
+}
+
+impl AuraInherentData for InherentData {
+	fn aura_inherent_data(&self) -> Result<Option<InherentType>, Error> {
+		self.get_data(&INHERENT_IDENTIFIER)
+	}
+
+	fn aura_replace_inherent_data(&mut self, new: InherentType) {
+		self.replace_data(INHERENT_IDENTIFIER, &new);
+	}
+}
+
+/// Provides the slot duration inherent data for `Aura`.
+// TODO: Remove in the future. https://github.com/paritytech/substrate/issues/8029
+#[cfg(feature = "std")]
+pub struct InherentDataProvider {
+	slot: InherentType,
+}
+
+#[cfg(feature = "std")]
+impl InherentDataProvider {
+	/// Create a new instance with the given slot.
+	pub fn new(slot: InherentType) -> Self {
+		Self { slot }
+	}
+
+	/// Creates the inherent data provider by calculating the slot from the given
+	/// `timestamp` and `duration`.
+	pub fn from_timestamp_and_slot_duration(
+		timestamp: sp_timestamp::Timestamp,
+		slot_duration: sp_consensus_slots::SlotDuration,
+	) -> Self {
+		let slot = InherentType::from_timestamp(timestamp, slot_duration);
+
+		Self { slot }
+	}
+}
+
+#[cfg(feature = "std")]
+impl sp_std::ops::Deref for InherentDataProvider {
+	type Target = InherentType;
+
+	fn deref(&self) -> &Self::Target {
+		&self.slot
+	}
+}
+
+#[cfg(feature = "std")]
+#[async_trait::async_trait]
+impl sp_inherents::InherentDataProvider for InherentDataProvider {
+	async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error> {
+		inherent_data.put_data(INHERENT_IDENTIFIER, &self.slot)
+	}
+
+	async fn try_handle_error(
+		&self,
+		_: &InherentIdentifier,
+		_: &[u8],
+	) -> Option<Result<(), Error>> {
+		// There is no error anymore
+		None
+	}
+}
diff --git a/substrate/primitives/consensus/aura/src/lib.rs b/substrate/primitives/consensus/aura/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..78409e84e93a377c90c4318e185cd5d4d8324781
--- /dev/null
+++ b/substrate/primitives/consensus/aura/src/lib.rs
@@ -0,0 +1,95 @@
+// 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.
+
+//! Primitives for Aura.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Codec, Decode, Encode};
+use sp_runtime::ConsensusEngineId;
+use sp_std::vec::Vec;
+
+pub mod digests;
+pub mod inherents;
+
+pub mod sr25519 {
+	mod app_sr25519 {
+		use sp_application_crypto::{app_crypto, key_types::AURA, sr25519};
+		app_crypto!(sr25519, AURA);
+	}
+
+	sp_application_crypto::with_pair! {
+		/// An Aura authority keypair using S/R 25519 as its crypto.
+		pub type AuthorityPair = app_sr25519::Pair;
+	}
+
+	/// An Aura authority signature using S/R 25519 as its crypto.
+	pub type AuthoritySignature = app_sr25519::Signature;
+
+	/// An Aura authority identifier using S/R 25519 as its crypto.
+	pub type AuthorityId = app_sr25519::Public;
+}
+
+pub mod ed25519 {
+	mod app_ed25519 {
+		use sp_application_crypto::{app_crypto, ed25519, key_types::AURA};
+		app_crypto!(ed25519, AURA);
+	}
+
+	sp_application_crypto::with_pair! {
+		/// An Aura authority keypair using Ed25519 as its crypto.
+		pub type AuthorityPair = app_ed25519::Pair;
+	}
+
+	/// An Aura authority signature using Ed25519 as its crypto.
+	pub type AuthoritySignature = app_ed25519::Signature;
+
+	/// An Aura authority identifier using Ed25519 as its crypto.
+	pub type AuthorityId = app_ed25519::Public;
+}
+
+pub use sp_consensus_slots::{Slot, SlotDuration};
+
+/// The `ConsensusEngineId` of AuRa.
+pub const AURA_ENGINE_ID: ConsensusEngineId = [b'a', b'u', b'r', b'a'];
+
+/// The index of an authority.
+pub type AuthorityIndex = u32;
+
+/// An consensus log item for Aura.
+#[derive(Decode, Encode)]
+pub enum ConsensusLog<AuthorityId: Codec> {
+	/// The authorities have changed.
+	#[codec(index = 1)]
+	AuthoritiesChange(Vec<AuthorityId>),
+	/// Disable the authority with given index.
+	#[codec(index = 2)]
+	OnDisabled(AuthorityIndex),
+}
+
+sp_api::decl_runtime_apis! {
+	/// API necessary for block authorship with aura.
+	pub trait AuraApi<AuthorityId: Codec> {
+		/// Returns the slot duration for Aura.
+		///
+		/// Currently, only the value provided by this type at genesis will be used.
+		fn slot_duration() -> SlotDuration;
+
+		/// Return the current set of authorities.
+		fn authorities() -> Vec<AuthorityId>;
+	}
+}
diff --git a/substrate/primitives/consensus/babe/Cargo.toml b/substrate/primitives/consensus/babe/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ca502c2c6ddb3e27f856e89387bca5ece72babc0
--- /dev/null
+++ b/substrate/primitives/consensus/babe/Cargo.toml
@@ -0,0 +1,54 @@
+[package]
+name = "sp-consensus-babe"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Primitives for BABE consensus"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = { version = "0.1.57", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, features = ["derive", "alloc"], optional = true }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../api" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../application-crypto" }
+sp-consensus-slots = { version = "0.10.0-dev", default-features = false, path = "../slots" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../core" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../inherents" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../std" }
+sp-timestamp = { version = "4.0.0-dev", optional = true, path = "../../timestamp" }
+
+[features]
+default = [ "std" ]
+std = [
+	"async-trait",
+	"codec/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-consensus-slots/std",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-timestamp/std",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"dep:serde",
+	"scale-info/serde",
+	"sp-application-crypto/serde",
+	"sp-consensus-slots/serde",
+	"sp-core/serde",
+	"sp-runtime/serde",
+]
diff --git a/substrate/primitives/consensus/babe/README.md b/substrate/primitives/consensus/babe/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..54bae05fd6db72a167bc8fd687e2d6a91a8a47ba
--- /dev/null
+++ b/substrate/primitives/consensus/babe/README.md
@@ -0,0 +1,3 @@
+Primitives for BABE.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/consensus/babe/src/digests.rs b/substrate/primitives/consensus/babe/src/digests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..afc967e3af391dd165e6be88ffdb42918b57b130
--- /dev/null
+++ b/substrate/primitives/consensus/babe/src/digests.rs
@@ -0,0 +1,215 @@
+// 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.
+
+//! Private implementation details of BABE digests.
+
+use super::{
+	AllowedSlots, AuthorityId, AuthorityIndex, AuthoritySignature, BabeAuthorityWeight,
+	BabeEpochConfiguration, Randomness, Slot, BABE_ENGINE_ID,
+};
+
+use sp_core::sr25519::vrf::VrfSignature;
+use sp_runtime::{DigestItem, RuntimeDebug};
+use sp_std::vec::Vec;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+
+/// Raw BABE primary slot assignment pre-digest.
+#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub struct PrimaryPreDigest {
+	/// Authority index
+	pub authority_index: super::AuthorityIndex,
+	/// Slot
+	pub slot: Slot,
+	/// VRF signature
+	pub vrf_signature: VrfSignature,
+}
+
+/// BABE secondary slot assignment pre-digest.
+#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub struct SecondaryPlainPreDigest {
+	/// Authority index
+	///
+	/// This is not strictly-speaking necessary, since the secondary slots
+	/// are assigned based on slot number and epoch randomness. But including
+	/// it makes things easier for higher-level users of the chain data to
+	/// be aware of the author of a secondary-slot block.
+	pub authority_index: super::AuthorityIndex,
+	/// Slot
+	pub slot: Slot,
+}
+
+/// BABE secondary deterministic slot assignment with VRF outputs.
+#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub struct SecondaryVRFPreDigest {
+	/// Authority index
+	pub authority_index: super::AuthorityIndex,
+	/// Slot
+	pub slot: Slot,
+	/// VRF signature
+	pub vrf_signature: VrfSignature,
+}
+
+/// A BABE pre-runtime digest. This contains all data required to validate a
+/// block and for the BABE runtime module. Slots can be assigned to a primary
+/// (VRF based) and to a secondary (slot number based).
+#[derive(Clone, RuntimeDebug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+pub enum PreDigest {
+	/// A primary VRF-based slot assignment.
+	#[codec(index = 1)]
+	Primary(PrimaryPreDigest),
+	/// A secondary deterministic slot assignment.
+	#[codec(index = 2)]
+	SecondaryPlain(SecondaryPlainPreDigest),
+	/// A secondary deterministic slot assignment with VRF outputs.
+	#[codec(index = 3)]
+	SecondaryVRF(SecondaryVRFPreDigest),
+}
+
+impl PreDigest {
+	/// Returns the slot number of the pre digest.
+	pub fn authority_index(&self) -> AuthorityIndex {
+		match self {
+			PreDigest::Primary(primary) => primary.authority_index,
+			PreDigest::SecondaryPlain(secondary) => secondary.authority_index,
+			PreDigest::SecondaryVRF(secondary) => secondary.authority_index,
+		}
+	}
+
+	/// Returns the slot of the pre digest.
+	pub fn slot(&self) -> Slot {
+		match self {
+			PreDigest::Primary(primary) => primary.slot,
+			PreDigest::SecondaryPlain(secondary) => secondary.slot,
+			PreDigest::SecondaryVRF(secondary) => secondary.slot,
+		}
+	}
+
+	/// Returns true if this pre-digest is for a primary slot assignment.
+	pub fn is_primary(&self) -> bool {
+		matches!(self, PreDigest::Primary(..))
+	}
+
+	/// Returns the weight _added_ by this digest, not the cumulative weight
+	/// of the chain.
+	pub fn added_weight(&self) -> crate::BabeBlockWeight {
+		match self {
+			PreDigest::Primary(_) => 1,
+			PreDigest::SecondaryPlain(_) | PreDigest::SecondaryVRF(_) => 0,
+		}
+	}
+
+	/// Returns the VRF output and proof, if they exist.
+	pub fn vrf_signature(&self) -> Option<&VrfSignature> {
+		match self {
+			PreDigest::Primary(primary) => Some(&primary.vrf_signature),
+			PreDigest::SecondaryVRF(secondary) => Some(&secondary.vrf_signature),
+			PreDigest::SecondaryPlain(_) => None,
+		}
+	}
+}
+
+/// Information about the next epoch. This is broadcast in the first block
+/// of the epoch.
+#[derive(Decode, Encode, PartialEq, Eq, Clone, RuntimeDebug)]
+pub struct NextEpochDescriptor {
+	/// The authorities.
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+
+	/// The value of randomness to use for the slot-assignment.
+	pub randomness: Randomness,
+}
+
+/// Information about the next epoch config, if changed. This is broadcast in the first
+/// block of the epoch, and applies using the same rules as `NextEpochDescriptor`.
+#[derive(
+	Decode, Encode, PartialEq, Eq, Clone, RuntimeDebug, MaxEncodedLen, scale_info::TypeInfo,
+)]
+pub enum NextConfigDescriptor {
+	/// Version 1.
+	#[codec(index = 1)]
+	V1 {
+		/// Value of `c` in `BabeEpochConfiguration`.
+		c: (u64, u64),
+		/// Value of `allowed_slots` in `BabeEpochConfiguration`.
+		allowed_slots: AllowedSlots,
+	},
+}
+
+impl From<NextConfigDescriptor> for BabeEpochConfiguration {
+	fn from(desc: NextConfigDescriptor) -> Self {
+		match desc {
+			NextConfigDescriptor::V1 { c, allowed_slots } => Self { c, allowed_slots },
+		}
+	}
+}
+
+/// A digest item which is usable with BABE consensus.
+pub trait CompatibleDigestItem: Sized {
+	/// Construct a digest item which contains a BABE pre-digest.
+	fn babe_pre_digest(seal: PreDigest) -> Self;
+
+	/// If this item is an BABE pre-digest, return it.
+	fn as_babe_pre_digest(&self) -> Option<PreDigest>;
+
+	/// Construct a digest item which contains a BABE seal.
+	fn babe_seal(signature: AuthoritySignature) -> Self;
+
+	/// If this item is a BABE signature, return the signature.
+	fn as_babe_seal(&self) -> Option<AuthoritySignature>;
+
+	/// If this item is a BABE epoch descriptor, return it.
+	fn as_next_epoch_descriptor(&self) -> Option<NextEpochDescriptor>;
+
+	/// If this item is a BABE config descriptor, return it.
+	fn as_next_config_descriptor(&self) -> Option<NextConfigDescriptor>;
+}
+
+impl CompatibleDigestItem for DigestItem {
+	fn babe_pre_digest(digest: PreDigest) -> Self {
+		DigestItem::PreRuntime(BABE_ENGINE_ID, digest.encode())
+	}
+
+	fn as_babe_pre_digest(&self) -> Option<PreDigest> {
+		self.pre_runtime_try_to(&BABE_ENGINE_ID)
+	}
+
+	fn babe_seal(signature: AuthoritySignature) -> Self {
+		DigestItem::Seal(BABE_ENGINE_ID, signature.encode())
+	}
+
+	fn as_babe_seal(&self) -> Option<AuthoritySignature> {
+		self.seal_try_to(&BABE_ENGINE_ID)
+	}
+
+	fn as_next_epoch_descriptor(&self) -> Option<NextEpochDescriptor> {
+		self.consensus_try_to(&BABE_ENGINE_ID)
+			.and_then(|x: super::ConsensusLog| match x {
+				super::ConsensusLog::NextEpochData(n) => Some(n),
+				_ => None,
+			})
+	}
+
+	fn as_next_config_descriptor(&self) -> Option<NextConfigDescriptor> {
+		self.consensus_try_to(&BABE_ENGINE_ID)
+			.and_then(|x: super::ConsensusLog| match x {
+				super::ConsensusLog::NextConfigData(n) => Some(n),
+				_ => None,
+			})
+	}
+}
diff --git a/substrate/primitives/consensus/babe/src/inherents.rs b/substrate/primitives/consensus/babe/src/inherents.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b01bd1c9221f2043a799f93450280ac7b280401b
--- /dev/null
+++ b/substrate/primitives/consensus/babe/src/inherents.rs
@@ -0,0 +1,101 @@
+// 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.
+
+//! Inherents for BABE
+
+use sp_inherents::{Error, InherentData, InherentIdentifier};
+use sp_std::result::Result;
+
+/// The BABE inherent identifier.
+pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"babeslot";
+
+/// The type of the BABE inherent.
+pub type InherentType = sp_consensus_slots::Slot;
+/// Auxiliary trait to extract BABE inherent data.
+pub trait BabeInherentData {
+	/// Get BABE inherent data.
+	fn babe_inherent_data(&self) -> Result<Option<InherentType>, Error>;
+	/// Replace BABE inherent data.
+	fn babe_replace_inherent_data(&mut self, new: InherentType);
+}
+
+impl BabeInherentData for InherentData {
+	fn babe_inherent_data(&self) -> Result<Option<InherentType>, Error> {
+		self.get_data(&INHERENT_IDENTIFIER)
+	}
+
+	fn babe_replace_inherent_data(&mut self, new: InherentType) {
+		self.replace_data(INHERENT_IDENTIFIER, &new);
+	}
+}
+
+/// Provides the slot duration inherent data for BABE.
+// TODO: Remove in the future. https://github.com/paritytech/substrate/issues/8029
+#[cfg(feature = "std")]
+pub struct InherentDataProvider {
+	slot: InherentType,
+}
+
+#[cfg(feature = "std")]
+impl InherentDataProvider {
+	/// Create new inherent data provider from the given `slot`.
+	pub fn new(slot: InherentType) -> Self {
+		Self { slot }
+	}
+
+	/// Creates the inherent data provider by calculating the slot from the given
+	/// `timestamp` and `duration`.
+	pub fn from_timestamp_and_slot_duration(
+		timestamp: sp_timestamp::Timestamp,
+		slot_duration: sp_consensus_slots::SlotDuration,
+	) -> Self {
+		let slot = InherentType::from_timestamp(timestamp, slot_duration);
+
+		Self { slot }
+	}
+
+	/// Returns the `slot` of this inherent data provider.
+	pub fn slot(&self) -> InherentType {
+		self.slot
+	}
+}
+
+#[cfg(feature = "std")]
+impl sp_std::ops::Deref for InherentDataProvider {
+	type Target = InherentType;
+
+	fn deref(&self) -> &Self::Target {
+		&self.slot
+	}
+}
+
+#[cfg(feature = "std")]
+#[async_trait::async_trait]
+impl sp_inherents::InherentDataProvider for InherentDataProvider {
+	async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error> {
+		inherent_data.put_data(INHERENT_IDENTIFIER, &self.slot)
+	}
+
+	async fn try_handle_error(
+		&self,
+		_: &InherentIdentifier,
+		_: &[u8],
+	) -> Option<Result<(), Error>> {
+		// There is no error anymore
+		None
+	}
+}
diff --git a/substrate/primitives/consensus/babe/src/lib.rs b/substrate/primitives/consensus/babe/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c083bfd9a313e078e4f82de0a9bb00fc025bb93d
--- /dev/null
+++ b/substrate/primitives/consensus/babe/src/lib.rs
@@ -0,0 +1,427 @@
+// 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.
+
+//! Primitives for BABE.
+#![deny(warnings)]
+#![forbid(unsafe_code, missing_docs, unused_variables, unused_imports)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod digests;
+pub mod inherents;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use sp_runtime::{traits::Header, ConsensusEngineId, RuntimeDebug};
+use sp_std::vec::Vec;
+
+use crate::digests::{NextConfigDescriptor, NextEpochDescriptor};
+
+pub use sp_core::sr25519::vrf::{
+	VrfInput, VrfOutput, VrfProof, VrfSignData, VrfSignature, VrfTranscript,
+};
+
+/// Key type for BABE module.
+pub const KEY_TYPE: sp_core::crypto::KeyTypeId = sp_application_crypto::key_types::BABE;
+
+mod app {
+	use sp_application_crypto::{app_crypto, key_types::BABE, sr25519};
+	app_crypto!(sr25519, BABE);
+}
+
+/// VRF context used for per-slot randomness generation.
+pub const RANDOMNESS_VRF_CONTEXT: &[u8] = b"BabeVRFInOutContext";
+
+/// VRF output length for per-slot randomness.
+pub const RANDOMNESS_LENGTH: usize = 32;
+
+/// Randomness type required by BABE operations.
+pub type Randomness = [u8; RANDOMNESS_LENGTH];
+
+/// A Babe authority keypair. Necessarily equivalent to the schnorrkel public key used in
+/// the main Babe module. If that ever changes, then this must, too.
+#[cfg(feature = "std")]
+pub type AuthorityPair = app::Pair;
+
+/// A Babe authority signature.
+pub type AuthoritySignature = app::Signature;
+
+/// A Babe authority identifier. Necessarily equivalent to the schnorrkel public key used in
+/// the main Babe module. If that ever changes, then this must, too.
+pub type AuthorityId = app::Public;
+
+/// The `ConsensusEngineId` of BABE.
+pub const BABE_ENGINE_ID: ConsensusEngineId = *b"BABE";
+
+/// The length of the public key
+pub const PUBLIC_KEY_LENGTH: usize = 32;
+
+/// How many blocks to wait before running the median algorithm for relative time
+/// This will not vary from chain to chain as it is not dependent on slot duration
+/// or epoch length.
+pub const MEDIAN_ALGORITHM_CARDINALITY: usize = 1200; // arbitrary suggestion by w3f-research.
+
+/// The index of an authority.
+pub type AuthorityIndex = u32;
+
+pub use sp_consensus_slots::{Slot, SlotDuration};
+
+/// An equivocation proof for multiple block authorships on the same slot (i.e. double vote).
+pub type EquivocationProof<H> = sp_consensus_slots::EquivocationProof<H, AuthorityId>;
+
+/// The weight of an authority.
+// NOTE: we use a unique name for the weight to avoid conflicts with other
+//       `Weight` types, since the metadata isn't able to disambiguate.
+pub type BabeAuthorityWeight = u64;
+
+/// The cumulative weight of a BABE block, i.e. sum of block weights starting
+/// at this block until the genesis block.
+///
+/// Primary blocks have a weight of 1 whereas secondary blocks have a weight
+/// of 0 (regardless of whether they are plain or vrf secondary blocks).
+pub type BabeBlockWeight = u32;
+
+/// Make VRF input suitable for BABE's randomness generation.
+pub fn make_vrf_transcript(randomness: &Randomness, slot: Slot, epoch: u64) -> VrfInput {
+	VrfInput::new(
+		&BABE_ENGINE_ID,
+		&[
+			(b"slot number", &slot.to_le_bytes()),
+			(b"current epoch", &epoch.to_le_bytes()),
+			(b"chain randomness", randomness),
+		],
+	)
+}
+
+/// Make VRF signing data suitable for BABE's protocol.
+pub fn make_vrf_sign_data(randomness: &Randomness, slot: Slot, epoch: u64) -> VrfSignData {
+	make_vrf_transcript(randomness, slot, epoch).into()
+}
+
+/// An consensus log item for BABE.
+#[derive(Decode, Encode, Clone, PartialEq, Eq)]
+pub enum ConsensusLog {
+	/// The epoch has changed. This provides information about the _next_
+	/// epoch - information about the _current_ epoch (i.e. the one we've just
+	/// entered) should already be available earlier in the chain.
+	#[codec(index = 1)]
+	NextEpochData(NextEpochDescriptor),
+	/// Disable the authority with given index.
+	#[codec(index = 2)]
+	OnDisabled(AuthorityIndex),
+	/// The epoch has changed, and the epoch after the current one will
+	/// enact different epoch configurations.
+	#[codec(index = 3)]
+	NextConfigData(NextConfigDescriptor),
+}
+
+/// Configuration data used by the BABE consensus engine.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug)]
+pub struct BabeConfigurationV1 {
+	/// The slot duration in milliseconds for BABE. Currently, only
+	/// the value provided by this type at genesis will be used.
+	///
+	/// Dynamic slot duration may be supported in the future.
+	pub slot_duration: u64,
+
+	/// The duration of epochs in slots.
+	pub epoch_length: u64,
+
+	/// A constant value that is used in the threshold calculation formula.
+	/// Expressed as a rational where the first member of the tuple is the
+	/// numerator and the second is the denominator. The rational should
+	/// represent a value between 0 and 1.
+	/// In the threshold formula calculation, `1 - c` represents the probability
+	/// of a slot being empty.
+	pub c: (u64, u64),
+
+	/// The authorities for the genesis epoch.
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+
+	/// The randomness for the genesis epoch.
+	pub randomness: Randomness,
+
+	/// Whether this chain should run with secondary slots, which are assigned
+	/// in round-robin manner.
+	pub secondary_slots: bool,
+}
+
+impl From<BabeConfigurationV1> for BabeConfiguration {
+	fn from(v1: BabeConfigurationV1) -> Self {
+		Self {
+			slot_duration: v1.slot_duration,
+			epoch_length: v1.epoch_length,
+			c: v1.c,
+			authorities: v1.authorities,
+			randomness: v1.randomness,
+			allowed_slots: if v1.secondary_slots {
+				AllowedSlots::PrimaryAndSecondaryPlainSlots
+			} else {
+				AllowedSlots::PrimarySlots
+			},
+		}
+	}
+}
+
+/// Configuration data used by the BABE consensus engine.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct BabeConfiguration {
+	/// The slot duration in milliseconds for BABE. Currently, only
+	/// the value provided by this type at genesis will be used.
+	///
+	/// Dynamic slot duration may be supported in the future.
+	pub slot_duration: u64,
+
+	/// The duration of epochs in slots.
+	pub epoch_length: u64,
+
+	/// A constant value that is used in the threshold calculation formula.
+	/// Expressed as a rational where the first member of the tuple is the
+	/// numerator and the second is the denominator. The rational should
+	/// represent a value between 0 and 1.
+	/// In the threshold formula calculation, `1 - c` represents the probability
+	/// of a slot being empty.
+	pub c: (u64, u64),
+
+	/// The authorities
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+
+	/// The randomness
+	pub randomness: Randomness,
+
+	/// Type of allowed slots.
+	pub allowed_slots: AllowedSlots,
+}
+
+impl BabeConfiguration {
+	/// Convenience method to get the slot duration as a `SlotDuration` value.
+	pub fn slot_duration(&self) -> SlotDuration {
+		SlotDuration::from_millis(self.slot_duration)
+	}
+}
+
+/// Types of allowed slots.
+#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum AllowedSlots {
+	/// Only allow primary slots.
+	PrimarySlots,
+	/// Allow primary and secondary plain slots.
+	PrimaryAndSecondaryPlainSlots,
+	/// Allow primary and secondary VRF slots.
+	PrimaryAndSecondaryVRFSlots,
+}
+
+impl AllowedSlots {
+	/// Whether plain secondary slots are allowed.
+	pub fn is_secondary_plain_slots_allowed(&self) -> bool {
+		*self == Self::PrimaryAndSecondaryPlainSlots
+	}
+
+	/// Whether VRF secondary slots are allowed.
+	pub fn is_secondary_vrf_slots_allowed(&self) -> bool {
+		*self == Self::PrimaryAndSecondaryVRFSlots
+	}
+}
+
+/// Configuration data used by the BABE consensus engine that may change with epochs.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct BabeEpochConfiguration {
+	/// A constant value that is used in the threshold calculation formula.
+	/// Expressed as a rational where the first member of the tuple is the
+	/// numerator and the second is the denominator. The rational should
+	/// represent a value between 0 and 1.
+	/// In the threshold formula calculation, `1 - c` represents the probability
+	/// of a slot being empty.
+	pub c: (u64, u64),
+
+	/// Whether this chain should run with secondary slots, which are assigned
+	/// in round-robin manner.
+	pub allowed_slots: AllowedSlots,
+}
+
+/// Verifies the equivocation proof by making sure that: both headers have
+/// different hashes, are targetting the same slot, and have valid signatures by
+/// the same authority.
+pub fn check_equivocation_proof<H>(proof: EquivocationProof<H>) -> bool
+where
+	H: Header,
+{
+	use digests::*;
+	use sp_application_crypto::RuntimeAppPublic;
+
+	let find_pre_digest =
+		|header: &H| header.digest().logs().iter().find_map(|log| log.as_babe_pre_digest());
+
+	let verify_seal_signature = |mut header: H, offender: &AuthorityId| {
+		let seal = header.digest_mut().pop()?.as_babe_seal()?;
+		let pre_hash = header.hash();
+
+		if !offender.verify(&pre_hash.as_ref(), &seal) {
+			return None
+		}
+
+		Some(())
+	};
+
+	let verify_proof = || {
+		// we must have different headers for the equivocation to be valid
+		if proof.first_header.hash() == proof.second_header.hash() {
+			return None
+		}
+
+		let first_pre_digest = find_pre_digest(&proof.first_header)?;
+		let second_pre_digest = find_pre_digest(&proof.second_header)?;
+
+		// both headers must be targetting the same slot and it must
+		// be the same as the one in the proof.
+		if proof.slot != first_pre_digest.slot() ||
+			first_pre_digest.slot() != second_pre_digest.slot()
+		{
+			return None
+		}
+
+		// both headers must have been authored by the same authority
+		if first_pre_digest.authority_index() != second_pre_digest.authority_index() {
+			return None
+		}
+
+		// we finally verify that the expected authority has signed both headers and
+		// that the signature is valid.
+		verify_seal_signature(proof.first_header, &proof.offender)?;
+		verify_seal_signature(proof.second_header, &proof.offender)?;
+
+		Some(())
+	};
+
+	// NOTE: we isolate the verification code into an helper function that
+	// returns `Option<()>` so that we can use `?` to deal with any intermediate
+	// errors and discard the proof as invalid.
+	verify_proof().is_some()
+}
+
+/// An opaque type used to represent the key ownership proof at the runtime API
+/// boundary. The inner value is an encoded representation of the actual key
+/// ownership proof which will be parameterized when defining the runtime. At
+/// 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> {
+		Decode::decode(&mut &self.0[..]).ok()
+	}
+}
+
+/// BABE epoch information
+#[derive(Decode, Encode, PartialEq, Eq, Clone, Debug, TypeInfo)]
+pub struct Epoch {
+	/// The epoch index.
+	pub epoch_index: u64,
+	/// The starting slot of the epoch.
+	pub start_slot: Slot,
+	/// The duration of this epoch.
+	pub duration: u64,
+	/// The authorities and their weights.
+	pub authorities: Vec<(AuthorityId, BabeAuthorityWeight)>,
+	/// Randomness for this epoch.
+	pub randomness: Randomness,
+	/// Configuration of the epoch.
+	pub config: BabeEpochConfiguration,
+}
+
+/// Returns the epoch index the given slot belongs to.
+pub fn epoch_index(slot: Slot, genesis_slot: Slot, epoch_duration: u64) -> u64 {
+	*slot.saturating_sub(genesis_slot) / epoch_duration
+}
+
+/// Returns the first slot at the given epoch index.
+pub fn epoch_start_slot(epoch_index: u64, genesis_slot: Slot, epoch_duration: u64) -> Slot {
+	// (epoch_index * epoch_duration) + genesis_slot
+
+	const PROOF: &str = "slot number is u64; it should relate in some way to wall clock time; \
+						 if u64 is not enough we should crash for safety; qed.";
+
+	epoch_index
+		.checked_mul(epoch_duration)
+		.and_then(|slot| slot.checked_add(*genesis_slot))
+		.expect(PROOF)
+		.into()
+}
+
+sp_api::decl_runtime_apis! {
+	/// API necessary for block authorship with BABE.
+	#[api_version(2)]
+	pub trait BabeApi {
+		/// Return the configuration for BABE.
+		fn configuration() -> BabeConfiguration;
+
+		/// Return the configuration for BABE. Version 1.
+		#[changed_in(2)]
+		fn configuration() -> BabeConfigurationV1;
+
+		/// Returns the slot that started the current epoch.
+		fn current_epoch_start() -> Slot;
+
+		/// Returns information regarding the current epoch.
+		fn current_epoch() -> Epoch;
+
+		/// Returns information regarding the next epoch (which was already
+		/// previously announced).
+		fn next_epoch() -> Epoch;
+
+		/// Generates a proof of key ownership for the given authority in the
+		/// current epoch. An example usage of this module is coupled with the
+		/// session historical module to prove that a given authority key is
+		/// tied to a given staking identity during a specific session. Proofs
+		/// of key ownership are necessary for submitting equivocation reports.
+		/// NOTE: even though the API takes a `slot` as parameter the current
+		/// implementations ignores this parameter and instead relies on this
+		/// method being called at the correct block height, i.e. any point at
+		/// which the epoch for the given slot is live on-chain. Future
+		/// implementations will instead use indexed data through an offchain
+		/// worker, not requiring older states to be available.
+		fn generate_key_ownership_proof(
+			slot: Slot,
+			authority_id: AuthorityId,
+		) -> Option<OpaqueKeyOwnershipProof>;
+
+		/// Submits an unsigned extrinsic to report an equivocation. The caller
+		/// must provide the equivocation proof and a key ownership proof
+		/// (should be obtained using `generate_key_ownership_proof`). The
+		/// extrinsic will be unsigned and should only be accepted for local
+		/// authorship (not to be broadcast to the network). This method returns
+		/// `None` when creation of the extrinsic fails, e.g. if equivocation
+		/// reporting is disabled for the given runtime (i.e. this method is
+		/// hardcoded to return `None`). Only useful in an offchain context.
+		fn submit_report_equivocation_unsigned_extrinsic(
+			equivocation_proof: EquivocationProof<Block::Header>,
+			key_owner_proof: OpaqueKeyOwnershipProof,
+		) -> Option<()>;
+	}
+}
diff --git a/substrate/primitives/consensus/beefy/Cargo.toml b/substrate/primitives/consensus/beefy/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bbc69cef7466d150b78ca2dfd07a240d2d81eca2
--- /dev/null
+++ b/substrate/primitives/consensus/beefy/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "sp-consensus-beefy"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate"
+description = "Primitives for BEEFY protocol."
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false,  optional = true, features =  ["derive", "alloc"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../api" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../application-crypto" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../io" }
+sp-mmr-primitives = { version = "4.0.0-dev", default-features = false, path = "../../merkle-mountain-range" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../std" }
+strum = { version = "0.24.1", features = ["derive"], default-features = false }
+lazy_static = "1.4.0"
+
+[dev-dependencies]
+array-bytes = "6.1"
+w3f-bls = { version = "0.1.3", features = ["std"]} 
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-mmr-primitives/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"dep:serde",
+	"scale-info/serde",
+	"sp-application-crypto/serde",
+	"sp-core/serde",
+	"sp-runtime/serde",
+]
+
+# This feature adds BLS crypto primitives. It should not be used in production since
+# the BLS implementation and interface may still be subject to significant change.
+bls-experimental = [
+	"sp-application-crypto/bls-experimental",
+	"sp-core/bls-experimental",
+]
diff --git a/substrate/primitives/consensus/beefy/src/commitment.rs b/substrate/primitives/consensus/beefy/src/commitment.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5b6ef9ae5ab36e94b045b1e6176e8b712cc20ceb
--- /dev/null
+++ b/substrate/primitives/consensus/beefy/src/commitment.rs
@@ -0,0 +1,503 @@
+// 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 codec::{Decode, Encode, Error, Input};
+use scale_info::TypeInfo;
+use sp_std::{cmp, prelude::*};
+
+use crate::{Payload, ValidatorSetId};
+
+/// A commitment signed by GRANDPA validators as part of BEEFY protocol.
+///
+/// The commitment contains a [payload](Commitment::payload) extracted from the finalized block at
+/// height [block_number](Commitment::block_number).
+/// GRANDPA validators collect signatures on commitments and a stream of such signed commitments
+/// (see [SignedCommitment]) forms the BEEFY protocol.
+#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, TypeInfo)]
+pub struct Commitment<TBlockNumber> {
+	///  A collection of payloads to be signed, see [`Payload`] for details.
+	///
+	/// One of the payloads should be some form of cumulative representation of the chain (think
+	/// MMR root hash). Additionally one of the payloads should also contain some details that
+	/// allow the light client to verify next validator set. The protocol does not enforce any
+	/// particular format of this data, nor how often it should be present in commitments, however
+	/// the light client has to be provided with full validator set whenever it performs the
+	/// transition (i.e. importing first block with
+	/// [validator_set_id](Commitment::validator_set_id) incremented).
+	pub payload: Payload,
+
+	/// Finalized block number this commitment is for.
+	///
+	/// GRANDPA validators agree on a block they create a commitment for and start collecting
+	/// signatures. This process is called a round.
+	/// There might be multiple rounds in progress (depending on the block choice rule), however
+	/// since the payload is supposed to be cumulative, it is not required to import all
+	/// commitments.
+	/// BEEFY light client is expected to import at least one commitment per epoch,
+	/// but is free to import as many as it requires.
+	pub block_number: TBlockNumber,
+
+	/// BEEFY validator set supposed to sign this commitment.
+	///
+	/// Validator set is changing once per epoch. The Light Client must be provided by details
+	/// about the validator set whenever it's importing first commitment with a new
+	/// `validator_set_id`. Validator set data MUST be verifiable, for instance using
+	/// [payload](Commitment::payload) information.
+	pub validator_set_id: ValidatorSetId,
+}
+
+impl<TBlockNumber> cmp::PartialOrd for Commitment<TBlockNumber>
+where
+	TBlockNumber: cmp::Ord,
+{
+	fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+impl<TBlockNumber> cmp::Ord for Commitment<TBlockNumber>
+where
+	TBlockNumber: cmp::Ord,
+{
+	fn cmp(&self, other: &Self) -> cmp::Ordering {
+		self.validator_set_id
+			.cmp(&other.validator_set_id)
+			.then_with(|| self.block_number.cmp(&other.block_number))
+			.then_with(|| self.payload.cmp(&other.payload))
+	}
+}
+
+/// A commitment with matching GRANDPA validators' signatures.
+///
+/// Note that SCALE-encoding of the structure is optimized for size efficiency over the wire,
+/// please take a look at custom [`Encode`] and [`Decode`] implementations and
+/// `CompactSignedCommitment` struct.
+#[derive(Clone, Debug, PartialEq, Eq, TypeInfo)]
+pub struct SignedCommitment<TBlockNumber, TSignature> {
+	/// The commitment signatures are collected for.
+	pub commitment: Commitment<TBlockNumber>,
+	/// GRANDPA validators' signatures for the commitment.
+	///
+	/// The length of this `Vec` must match number of validators in the current set (see
+	/// [Commitment::validator_set_id]).
+	pub signatures: Vec<Option<TSignature>>,
+}
+
+impl<TBlockNumber, TSignature> SignedCommitment<TBlockNumber, TSignature> {
+	/// Return the number of collected signatures.
+	pub fn no_of_signatures(&self) -> usize {
+		self.signatures.iter().filter(|x| x.is_some()).count()
+	}
+}
+
+/// Type to be used to denote placement of signatures
+type BitField = Vec<u8>;
+/// Compress 8 bit values into a single u8 Byte
+const CONTAINER_BIT_SIZE: usize = 8;
+
+/// Compressed representation of [`SignedCommitment`], used for encoding efficiency.
+#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode)]
+struct CompactSignedCommitment<TBlockNumber, TSignature> {
+	/// The commitment, unchanged compared to regular [`SignedCommitment`].
+	commitment: Commitment<TBlockNumber>,
+	/// A bitfield representing presence of a signature coming from a validator at some index.
+	///
+	/// The bit at index `0` is set to `1` in case we have a signature coming from a validator at
+	/// index `0` in in the original validator set. In case the [`SignedCommitment`] does not
+	/// contain that signature the `bit` will be set to `0`. Bits are packed into `Vec<u8>`
+	signatures_from: BitField,
+	/// Number of validators in the Validator Set and hence number of significant bits in the
+	/// [`signatures_from`] collection.
+	///
+	/// Note this might be smaller than the size of `signatures_compact` in case some signatures
+	/// are missing.
+	validator_set_len: u32,
+	/// A `Vec` containing all `Signature`s present in the original [`SignedCommitment`].
+	///
+	/// Note that in order to associate a `Signature` from this `Vec` with a validator, one needs
+	/// to look at the `signatures_from` bitfield, since some validators might have not produced a
+	/// signature.
+	signatures_compact: Vec<TSignature>,
+}
+
+impl<'a, TBlockNumber: Clone, TSignature> CompactSignedCommitment<TBlockNumber, &'a TSignature> {
+	/// Packs a `SignedCommitment` into the compressed `CompactSignedCommitment` format for
+	/// efficient network transport.
+	fn pack(signed_commitment: &'a SignedCommitment<TBlockNumber, TSignature>) -> Self {
+		let SignedCommitment { commitment, signatures } = signed_commitment;
+		let validator_set_len = signatures.len() as u32;
+
+		let signatures_compact: Vec<&'a TSignature> =
+			signatures.iter().filter_map(|x| x.as_ref()).collect();
+		let bits = {
+			let mut bits: Vec<u8> =
+				signatures.iter().map(|x| if x.is_some() { 1 } else { 0 }).collect();
+			// Resize with excess bits for placement purposes
+			let excess_bits_len =
+				CONTAINER_BIT_SIZE - (validator_set_len as usize % CONTAINER_BIT_SIZE);
+			bits.resize(bits.len() + excess_bits_len, 0);
+			bits
+		};
+
+		let mut signatures_from: BitField = vec![];
+		let chunks = bits.chunks(CONTAINER_BIT_SIZE);
+		for chunk in chunks {
+			let mut iter = chunk.iter().copied();
+			let mut v = iter.next().unwrap() as u8;
+
+			for bit in iter {
+				v <<= 1;
+				v |= bit as u8;
+			}
+
+			signatures_from.push(v);
+		}
+
+		Self {
+			commitment: commitment.clone(),
+			signatures_from,
+			validator_set_len,
+			signatures_compact,
+		}
+	}
+
+	/// Unpacks a `CompactSignedCommitment` into the uncompressed `SignedCommitment` form.
+	fn unpack(
+		temporary_signatures: CompactSignedCommitment<TBlockNumber, TSignature>,
+	) -> SignedCommitment<TBlockNumber, TSignature> {
+		let CompactSignedCommitment {
+			commitment,
+			signatures_from,
+			validator_set_len,
+			signatures_compact,
+		} = temporary_signatures;
+		let mut bits: Vec<u8> = vec![];
+
+		for block in signatures_from {
+			for bit in 0..CONTAINER_BIT_SIZE {
+				bits.push((block >> (CONTAINER_BIT_SIZE - bit - 1)) & 1);
+			}
+		}
+
+		bits.truncate(validator_set_len as usize);
+
+		let mut next_signature = signatures_compact.into_iter();
+		let signatures: Vec<Option<TSignature>> = bits
+			.iter()
+			.map(|&x| if x == 1 { next_signature.next() } else { None })
+			.collect();
+
+		SignedCommitment { commitment, signatures }
+	}
+}
+
+impl<TBlockNumber, TSignature> Encode for SignedCommitment<TBlockNumber, TSignature>
+where
+	TBlockNumber: Encode + Clone,
+	TSignature: Encode,
+{
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		let temp = CompactSignedCommitment::pack(self);
+		temp.using_encoded(f)
+	}
+}
+
+impl<TBlockNumber, TSignature> Decode for SignedCommitment<TBlockNumber, TSignature>
+where
+	TBlockNumber: Decode + Clone,
+	TSignature: Decode,
+{
+	fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
+		let temp = CompactSignedCommitment::decode(input)?;
+		Ok(CompactSignedCommitment::unpack(temp))
+	}
+}
+
+/// A [SignedCommitment] with a version number.
+///
+/// This variant will be appended to the block justifications for the block
+/// for which the signed commitment has been generated.
+///
+/// Note that this enum is subject to change in the future with introduction
+/// of additional cryptographic primitives to BEEFY.
+#[derive(Clone, Debug, PartialEq, codec::Encode, codec::Decode)]
+pub enum VersionedFinalityProof<N, S> {
+	#[codec(index = 1)]
+	/// Current active version
+	V1(SignedCommitment<N, S>),
+}
+
+impl<N, S> From<SignedCommitment<N, S>> for VersionedFinalityProof<N, S> {
+	fn from(commitment: SignedCommitment<N, S>) -> Self {
+		VersionedFinalityProof::V1(commitment)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+
+	use super::*;
+	use crate::{ecdsa_crypto::Signature as EcdsaSignature, known_payloads};
+	use codec::Decode;
+	use sp_core::{keccak_256, Pair};
+
+	#[cfg(feature = "bls-experimental")]
+	use crate::bls_crypto::Signature as BlsSignature;
+
+	type TestCommitment = Commitment<u128>;
+
+	const LARGE_RAW_COMMITMENT: &[u8] = include_bytes!("../test-res/large-raw-commitment");
+
+	// Types for bls-less commitment
+	type TestEcdsaSignedCommitment = SignedCommitment<u128, EcdsaSignature>;
+	type TestVersionedFinalityProof = VersionedFinalityProof<u128, EcdsaSignature>;
+
+	// Types for commitment supporting aggregatable bls signature
+	#[cfg(feature = "bls-experimental")]
+	#[derive(Clone, Debug, PartialEq, codec::Encode, codec::Decode)]
+	struct BlsAggregatableSignature(BlsSignature);
+
+	#[cfg(feature = "bls-experimental")]
+	#[derive(Clone, Debug, PartialEq, codec::Encode, codec::Decode)]
+	struct EcdsaBlsSignaturePair(EcdsaSignature, BlsSignature);
+
+	#[cfg(feature = "bls-experimental")]
+	type TestBlsSignedCommitment = SignedCommitment<u128, EcdsaBlsSignaturePair>;
+
+	// Generates mock aggregatable ecdsa signature for generating test commitment
+	// BLS signatures
+	fn mock_ecdsa_signatures() -> (EcdsaSignature, EcdsaSignature) {
+		let alice = sp_core::ecdsa::Pair::from_string("//Alice", None).unwrap();
+
+		let msg = keccak_256(b"This is the first message");
+		let sig1 = alice.sign_prehashed(&msg);
+
+		let msg = keccak_256(b"This is the second message");
+		let sig2 = alice.sign_prehashed(&msg);
+
+		(sig1.into(), sig2.into())
+	}
+
+	// Generates mock aggregatable bls signature for generating test commitment
+	// BLS signatures
+	#[cfg(feature = "bls-experimental")]
+	fn mock_bls_signatures() -> (BlsSignature, BlsSignature) {
+		let alice = sp_core::bls::Pair::from_string("//Alice", None).unwrap();
+
+		let msg = b"This is the first message";
+		let sig1 = alice.sign(msg);
+
+		let msg = b"This is the second message";
+		let sig2 = alice.sign(msg);
+
+		(sig1.into(), sig2.into())
+	}
+
+	#[test]
+	fn commitment_encode_decode() {
+		// given
+		let payload =
+			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		// when
+		let encoded = codec::Encode::encode(&commitment);
+		let decoded = TestCommitment::decode(&mut &*encoded);
+
+		// then
+		assert_eq!(decoded, Ok(commitment));
+		assert_eq!(
+			encoded,
+			array_bytes::hex2bytes_unchecked(
+				"046d68343048656c6c6f20576f726c6421050000000000000000000000000000000000000000000000"
+			)
+		);
+	}
+
+	#[test]
+	fn signed_commitment_encode_decode_ecdsa() {
+		// given
+		let payload =
+			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		let ecdsa_sigs = mock_ecdsa_signatures();
+
+		let ecdsa_signed = SignedCommitment {
+			commitment: commitment.clone(),
+			signatures: vec![None, None, Some(ecdsa_sigs.0.clone()), Some(ecdsa_sigs.1.clone())],
+		};
+
+		// when
+		let encoded = codec::Encode::encode(&ecdsa_signed);
+		let decoded = TestEcdsaSignedCommitment::decode(&mut &*encoded);
+
+		// then
+		assert_eq!(decoded, Ok(ecdsa_signed));
+		assert_eq!(
+			encoded,
+			array_bytes::hex2bytes_unchecked(
+				"\
+				046d68343048656c6c6f20576f726c64210500000000000000000000000000000000000000000000000\
+				4300400000008558455ad81279df0795cc985580e4fb75d72d948d1107b2ac80a09abed4da8480c746c\
+				c321f2319a5e99a830e314d10dd3cd68ce3dc0c33c86e99bcb7816f9ba012d6e1f8105c337a86cdd9aa\
+				acdc496577f3db8c55ef9e6fd48f2c5c05a2274707491635d8ba3df64f324575b7b2a34487bca2324b6\
+				a0046395a71681be3d0c2a00\
+			"
+			)
+		);
+	}
+
+	#[test]
+	#[cfg(feature = "bls-experimental")]
+	fn signed_commitment_encode_decode_ecdsa_n_bls() {
+		// given
+		let payload =
+			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		let ecdsa_sigs = mock_ecdsa_signatures();
+
+		//including bls signature
+		let bls_signed_msgs = mock_bls_signatures();
+
+		let ecdsa_and_bls_signed = SignedCommitment {
+			commitment,
+			signatures: vec![
+				None,
+				None,
+				Some(EcdsaBlsSignaturePair(ecdsa_sigs.0, bls_signed_msgs.0)),
+				Some(EcdsaBlsSignaturePair(ecdsa_sigs.1, bls_signed_msgs.1)),
+			],
+		};
+
+		//when
+		let encoded = codec::Encode::encode(&ecdsa_and_bls_signed);
+		let decoded = TestBlsSignedCommitment::decode(&mut &*encoded);
+
+		// then
+		assert_eq!(decoded, Ok(ecdsa_and_bls_signed));
+		assert_eq!(
+			encoded,
+			array_bytes::hex2bytes_unchecked(
+				"046d68343048656c6c6f20576f726c642105000000000000000000000000000000000000000000000004300400000008558455ad81279df0795cc985580e4fb75d72d948d1107b2ac80a09abed4da8480c746cc321f2319a5e99a830e314d10dd3cd68ce3dc0c33c86e99bcb7816f9ba01667603fc041cf9d7147d22bf54b15e5778893d6986b71a929747befd3b4d233fbe668bc480e8865116b94db46ca25a01e03c71955f2582604e415da68f2c3c406b9d5f4ad416230ec5453f05ac16a50d8d0923dfb0413cc956ae3fa6334465bd1f2cacec8e9cd606438390fe2a29dc052d6e1f8105c337a86cdd9aaacdc496577f3db8c55ef9e6fd48f2c5c05a2274707491635d8ba3df64f324575b7b2a34487bca2324b6a0046395a71681be3d0c2a00df61d3b2be0963eb6caa243cc505d327aec73e1bb7ffe9a14b1354b0c406792ac6d6f47c06987c15dec9993f43eefa001d866fe0850d986702c414840f0d9ec0fdc04832ef91ae37c8d49e2f573ca50cb37f152801d489a19395cb04e5fc8f2ab6954b58a3bcc40ef9b6409d2ff7ef07"
+			)
+		);
+	}
+
+	#[test]
+	fn signed_commitment_count_signatures() {
+		// given
+		let payload =
+			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		let sigs = mock_ecdsa_signatures();
+
+		let mut signed = SignedCommitment {
+			commitment,
+			signatures: vec![None, None, Some(sigs.0), Some(sigs.1)],
+		};
+		assert_eq!(signed.no_of_signatures(), 2);
+
+		// when
+		signed.signatures[2] = None;
+
+		// then
+		assert_eq!(signed.no_of_signatures(), 1);
+	}
+
+	#[test]
+	fn commitment_ordering() {
+		fn commitment(
+			block_number: u128,
+			validator_set_id: crate::ValidatorSetId,
+		) -> TestCommitment {
+			let payload =
+				Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+			Commitment { payload, block_number, validator_set_id }
+		}
+
+		// given
+		let a = commitment(1, 0);
+		let b = commitment(2, 1);
+		let c = commitment(10, 0);
+		let d = commitment(10, 1);
+
+		// then
+		assert!(a < b);
+		assert!(a < c);
+		assert!(c < b);
+		assert!(c < d);
+		assert!(b < d);
+	}
+
+	#[test]
+	fn versioned_commitment_encode_decode() {
+		let payload =
+			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		let sigs = mock_ecdsa_signatures();
+
+		let signed = SignedCommitment {
+			commitment,
+			signatures: vec![None, None, Some(sigs.0), Some(sigs.1)],
+		};
+
+		let versioned = TestVersionedFinalityProof::V1(signed.clone());
+
+		let encoded = codec::Encode::encode(&versioned);
+
+		assert_eq!(1, encoded[0]);
+		assert_eq!(encoded[1..], codec::Encode::encode(&signed));
+
+		let decoded = TestVersionedFinalityProof::decode(&mut &*encoded);
+
+		assert_eq!(decoded, Ok(versioned));
+	}
+
+	#[test]
+	fn large_signed_commitment_encode_decode() {
+		// given
+		let payload =
+			Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode());
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		let sigs = mock_ecdsa_signatures();
+
+		let signatures: Vec<Option<_>> = (0..1024)
+			.into_iter()
+			.map(|x| if x < 340 { None } else { Some(sigs.0.clone()) })
+			.collect();
+		let signed = SignedCommitment { commitment, signatures };
+
+		// when
+		let encoded = codec::Encode::encode(&signed);
+		let decoded = TestEcdsaSignedCommitment::decode(&mut &*encoded);
+
+		// then
+		assert_eq!(decoded, Ok(signed));
+		assert_eq!(encoded, LARGE_RAW_COMMITMENT);
+	}
+}
diff --git a/substrate/primitives/consensus/beefy/src/lib.rs b/substrate/primitives/consensus/beefy/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c69e26bf574d877f2c5a2261709ade2cdcfaef46
--- /dev/null
+++ b/substrate/primitives/consensus/beefy/src/lib.rs
@@ -0,0 +1,461 @@
+// 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)]
+#![warn(missing_docs)]
+
+//! Primitives for BEEFY protocol.
+//!
+//! The crate contains shared data types used by BEEFY protocol and documentation (in a form of
+//! code) for building a BEEFY light client.
+//!
+//! BEEFY is a gadget that runs alongside another finality gadget (for instance GRANDPA).
+//! For simplicity (and the initially intended use case) the documentation says GRANDPA in places
+//! where a more abstract "Finality Gadget" term could be used, but there is no reason why BEEFY
+//! wouldn't run with some other finality scheme.
+//! BEEFY validator set is supposed to be tracking the Finality Gadget validator set, but note that
+//! it will use a different set of keys. For Polkadot use case we plan to use `secp256k1` for BEEFY,
+//! while GRANDPA uses `ed25519`.
+
+mod commitment;
+pub mod mmr;
+mod payload;
+#[cfg(feature = "std")]
+mod test_utils;
+pub mod witness;
+
+pub use commitment::{Commitment, SignedCommitment, VersionedFinalityProof};
+pub use payload::{known_payloads, BeefyPayloadId, Payload, PayloadProvider};
+#[cfg(feature = "std")]
+pub use test_utils::*;
+
+use codec::{Codec, Decode, Encode};
+use scale_info::TypeInfo;
+use sp_application_crypto::RuntimeAppPublic;
+use sp_core::H256;
+use sp_runtime::traits::{Hash, Keccak256, NumberFor};
+use sp_std::prelude::*;
+
+/// Key type for BEEFY module.
+pub const KEY_TYPE: sp_core::crypto::KeyTypeId = sp_application_crypto::key_types::BEEFY;
+
+/// Trait representing BEEFY authority id, including custom signature verification.
+///
+/// Accepts custom hashing fn for the message and custom convertor fn for the signer.
+pub trait BeefyAuthorityId<MsgHash: Hash>: RuntimeAppPublic {
+	/// Verify a signature.
+	///
+	/// Return `true` if signature over `msg` is valid for this id.
+	fn verify(&self, signature: &<Self as RuntimeAppPublic>::Signature, msg: &[u8]) -> bool;
+}
+
+/// BEEFY cryptographic types for ECDSA crypto
+///
+/// This module basically introduces four crypto types:
+/// - `ecdsa_crypto::Pair`
+/// - `ecdsa_crypto::Public`
+/// - `ecdsa_crypto::Signature`
+/// - `ecdsa_crypto::AuthorityId`
+///
+/// Your code should use the above types as concrete types for all crypto related
+/// functionality.
+pub mod ecdsa_crypto {
+	use super::{BeefyAuthorityId, Hash, RuntimeAppPublic, KEY_TYPE as BEEFY_KEY_TYPE};
+	use sp_application_crypto::{app_crypto, ecdsa};
+	use sp_core::crypto::Wraps;
+	app_crypto!(ecdsa, BEEFY_KEY_TYPE);
+
+	/// Identity of a BEEFY authority using ECDSA as its crypto.
+	pub type AuthorityId = Public;
+
+	/// Signature for a BEEFY authority using ECDSA as its crypto.
+	pub type AuthoritySignature = Signature;
+
+	impl<MsgHash: Hash> BeefyAuthorityId<MsgHash> for AuthorityId
+	where
+		<MsgHash as Hash>::Output: Into<[u8; 32]>,
+	{
+		fn verify(&self, signature: &<Self as RuntimeAppPublic>::Signature, msg: &[u8]) -> bool {
+			let msg_hash = <MsgHash as Hash>::hash(msg).into();
+			match sp_io::crypto::secp256k1_ecdsa_recover_compressed(
+				signature.as_inner_ref().as_ref(),
+				&msg_hash,
+			) {
+				Ok(raw_pubkey) => raw_pubkey.as_ref() == AsRef::<[u8]>::as_ref(self),
+				_ => false,
+			}
+		}
+	}
+}
+
+/// BEEFY cryptographic types for BLS crypto
+///
+/// This module basically introduces four crypto types:
+/// - `bls_crypto::Pair`
+/// - `bls_crypto::Public`
+/// - `bls_crypto::Signature`
+/// - `bls_crypto::AuthorityId`
+///
+/// Your code should use the above types as concrete types for all crypto related
+/// functionality.
+
+#[cfg(feature = "bls-experimental")]
+pub mod bls_crypto {
+	use super::{BeefyAuthorityId, Hash, RuntimeAppPublic, KEY_TYPE as BEEFY_KEY_TYPE};
+	use sp_application_crypto::{app_crypto, bls377};
+	use sp_core::{bls377::Pair as BlsPair, crypto::Wraps, Pair as _};
+	app_crypto!(bls377, BEEFY_KEY_TYPE);
+
+	/// Identity of a BEEFY authority using BLS as its crypto.
+	pub type AuthorityId = Public;
+
+	/// Signature for a BEEFY authority using BLS as its crypto.
+	pub type AuthoritySignature = Signature;
+
+	impl<MsgHash: Hash> BeefyAuthorityId<MsgHash> for AuthorityId
+	where
+		<MsgHash as Hash>::Output: Into<[u8; 32]>,
+	{
+		fn verify(&self, signature: &<Self as RuntimeAppPublic>::Signature, msg: &[u8]) -> bool {
+			// `w3f-bls` library uses IETF hashing standard and as such does not exposes
+			// a choice of hash to field function.
+			// We are directly calling into the library to avoid introducing new host call.
+			// and because BeefyAuthorityId::verify is being called in the runtime so we don't have
+
+			BlsPair::verify(signature.as_inner_ref(), msg, self.as_inner_ref())
+		}
+	}
+}
+/// The `ConsensusEngineId` of BEEFY.
+pub const BEEFY_ENGINE_ID: sp_runtime::ConsensusEngineId = *b"BEEF";
+
+/// Authority set id starts with zero at BEEFY pallet genesis.
+pub const GENESIS_AUTHORITY_SET_ID: u64 = 0;
+
+/// A typedef for validator set id.
+pub type ValidatorSetId = u64;
+
+/// A set of BEEFY authorities, a.k.a. validators.
+#[derive(Decode, Encode, Debug, PartialEq, Clone, TypeInfo)]
+pub struct ValidatorSet<AuthorityId> {
+	/// Public keys of the validator set elements
+	validators: Vec<AuthorityId>,
+	/// Identifier of the validator set
+	id: ValidatorSetId,
+}
+
+impl<AuthorityId> ValidatorSet<AuthorityId> {
+	/// Return a validator set with the given validators and set id.
+	pub fn new<I>(validators: I, id: ValidatorSetId) -> Option<Self>
+	where
+		I: IntoIterator<Item = AuthorityId>,
+	{
+		let validators: Vec<AuthorityId> = validators.into_iter().collect();
+		if validators.is_empty() {
+			// No validators; the set would be empty.
+			None
+		} else {
+			Some(Self { validators, id })
+		}
+	}
+
+	/// Return a reference to the vec of validators.
+	pub fn validators(&self) -> &[AuthorityId] {
+		&self.validators
+	}
+
+	/// Return the validator set id.
+	pub fn id(&self) -> ValidatorSetId {
+		self.id
+	}
+
+	/// Return the number of validators in the set.
+	pub fn len(&self) -> usize {
+		self.validators.len()
+	}
+}
+
+/// The index of an authority.
+pub type AuthorityIndex = u32;
+
+/// The Hashing used within MMR.
+pub type MmrHashing = Keccak256;
+/// The type used to represent an MMR root hash.
+pub type MmrRootHash = H256;
+
+/// A consensus log item for BEEFY.
+#[derive(Decode, Encode, TypeInfo)]
+pub enum ConsensusLog<AuthorityId: Codec> {
+	/// The authorities have changed.
+	#[codec(index = 1)]
+	AuthoritiesChange(ValidatorSet<AuthorityId>),
+	/// Disable the authority with given index.
+	#[codec(index = 2)]
+	OnDisabled(AuthorityIndex),
+	/// MMR root hash.
+	#[codec(index = 3)]
+	MmrRoot(MmrRootHash),
+}
+
+/// BEEFY vote message.
+///
+/// A vote message is a direct vote created by a BEEFY node on every voting round
+/// and is gossiped to its peers.
+#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo)]
+pub struct VoteMessage<Number, Id, Signature> {
+	/// Commit to information extracted from a finalized block
+	pub commitment: Commitment<Number>,
+	/// Node authority id
+	pub id: Id,
+	/// Node signature
+	pub signature: Signature,
+}
+
+/// Proof of voter misbehavior on a given set id. Misbehavior/equivocation in
+/// BEEFY happens when a voter votes on the same round/block for different payloads.
+/// Proving is achieved by collecting the signed commitments of conflicting votes.
+#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo)]
+pub struct EquivocationProof<Number, Id, Signature> {
+	/// The first vote in the equivocation.
+	pub first: VoteMessage<Number, Id, Signature>,
+	/// The second vote in the equivocation.
+	pub second: VoteMessage<Number, Id, Signature>,
+}
+
+impl<Number, Id, Signature> EquivocationProof<Number, Id, Signature> {
+	/// Returns the authority id of the equivocator.
+	pub fn offender_id(&self) -> &Id {
+		&self.first.id
+	}
+	/// Returns the round number at which the equivocation occurred.
+	pub fn round_number(&self) -> &Number {
+		&self.first.commitment.block_number
+	}
+	/// Returns the set id at which the equivocation occurred.
+	pub fn set_id(&self) -> ValidatorSetId {
+		self.first.commitment.validator_set_id
+	}
+}
+
+/// Check a commitment signature by encoding the commitment and
+/// verifying the provided signature using the expected authority id.
+pub fn check_commitment_signature<Number, Id, MsgHash>(
+	commitment: &Commitment<Number>,
+	authority_id: &Id,
+	signature: &<Id as RuntimeAppPublic>::Signature,
+) -> bool
+where
+	Id: BeefyAuthorityId<MsgHash>,
+	Number: Clone + Encode + PartialEq,
+	MsgHash: Hash,
+{
+	let encoded_commitment = commitment.encode();
+	BeefyAuthorityId::<MsgHash>::verify(authority_id, signature, &encoded_commitment)
+}
+
+/// Verifies the equivocation proof by making sure that both votes target
+/// different blocks and that its signatures are valid.
+pub fn check_equivocation_proof<Number, Id, MsgHash>(
+	report: &EquivocationProof<Number, Id, <Id as RuntimeAppPublic>::Signature>,
+) -> bool
+where
+	Id: BeefyAuthorityId<MsgHash> + PartialEq,
+	Number: Clone + Encode + PartialEq,
+	MsgHash: Hash,
+{
+	let first = &report.first;
+	let second = &report.second;
+
+	// if votes
+	//   come from different authorities,
+	//   are for different rounds,
+	//   have different validator set ids,
+	//   or both votes have the same commitment,
+	//     --> the equivocation is invalid.
+	if first.id != second.id ||
+		first.commitment.block_number != second.commitment.block_number ||
+		first.commitment.validator_set_id != second.commitment.validator_set_id ||
+		first.commitment.payload == second.commitment.payload
+	{
+		return false
+	}
+
+	// check signatures on both votes are valid
+	let valid_first = check_commitment_signature(&first.commitment, &first.id, &first.signature);
+	let valid_second =
+		check_commitment_signature(&second.commitment, &second.id, &second.signature);
+
+	return valid_first && valid_second
+}
+
+/// New BEEFY validator set notification hook.
+pub trait OnNewValidatorSet<AuthorityId> {
+	/// Function called by the pallet when BEEFY validator set changes.
+	fn on_new_validator_set(
+		validator_set: &ValidatorSet<AuthorityId>,
+		next_validator_set: &ValidatorSet<AuthorityId>,
+	);
+}
+
+/// No-op implementation of [OnNewValidatorSet].
+impl<AuthorityId> OnNewValidatorSet<AuthorityId> for () {
+	fn on_new_validator_set(_: &ValidatorSet<AuthorityId>, _: &ValidatorSet<AuthorityId>) {}
+}
+
+/// An opaque type used to represent the key ownership proof at the runtime API
+/// boundary. The inner value is an encoded representation of the actual key
+/// ownership proof which will be parameterized when defining the runtime. At
+/// 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()
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// API necessary for BEEFY voters.
+	#[api_version(3)]
+	pub trait BeefyApi<AuthorityId> where
+		AuthorityId : Codec + RuntimeAppPublic,
+	{
+		/// Return the block number where BEEFY consensus is enabled/started
+		fn beefy_genesis() -> Option<NumberFor<Block>>;
+
+		/// Return the current active BEEFY validator set
+		fn validator_set() -> Option<ValidatorSet<AuthorityId>>;
+
+		/// Submits an unsigned extrinsic to report an equivocation. The caller
+		/// must provide the equivocation proof and a key ownership proof
+		/// (should be obtained using `generate_key_ownership_proof`). The
+		/// extrinsic will be unsigned and should only be accepted for local
+		/// authorship (not to be broadcast to the network). This method returns
+		/// `None` when creation of the extrinsic fails, e.g. if equivocation
+		/// reporting is disabled for the given runtime (i.e. this method is
+		/// hardcoded to return `None`). Only useful in an offchain context.
+		fn submit_report_equivocation_unsigned_extrinsic(
+			equivocation_proof:
+				EquivocationProof<NumberFor<Block>, AuthorityId, <AuthorityId as RuntimeAppPublic>::Signature>,
+			key_owner_proof: OpaqueKeyOwnershipProof,
+		) -> Option<()>;
+
+		/// Generates a proof of key ownership for the given authority in the
+		/// given set. An example usage of this module is coupled with the
+		/// session historical module to prove that a given authority key is
+		/// tied to a given staking identity during a specific session. Proofs
+		/// of key ownership are necessary for submitting equivocation reports.
+		/// NOTE: even though the API takes a `set_id` as parameter the current
+		/// implementations ignores this parameter and instead relies on this
+		/// method being called at the correct block height, i.e. any point at
+		/// which the given set id is live on-chain. Future implementations will
+		/// instead use indexed data through an offchain worker, not requiring
+		/// older states to be available.
+		fn generate_key_ownership_proof(
+			set_id: ValidatorSetId,
+			authority_id: AuthorityId,
+		) -> Option<OpaqueKeyOwnershipProof>;
+	}
+
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_application_crypto::ecdsa::{self, Public};
+	use sp_core::{blake2_256, crypto::Wraps, keccak_256, Pair};
+	use sp_runtime::traits::{BlakeTwo256, Keccak256};
+
+	#[test]
+	fn validator_set() {
+		// Empty set not allowed.
+		assert_eq!(ValidatorSet::<Public>::new(vec![], 0), None);
+
+		let alice = ecdsa::Pair::from_string("//Alice", None).unwrap();
+		let set_id = 0;
+		let validators = ValidatorSet::<Public>::new(vec![alice.public()], set_id).unwrap();
+
+		assert_eq!(validators.id(), set_id);
+		assert_eq!(validators.validators(), &vec![alice.public()]);
+	}
+
+	#[test]
+	fn ecdsa_beefy_verify_works() {
+		let msg = &b"test-message"[..];
+		let (pair, _) = ecdsa_crypto::Pair::generate();
+
+		let keccak_256_signature: ecdsa_crypto::Signature =
+			pair.as_inner_ref().sign_prehashed(&keccak_256(msg)).into();
+
+		let blake2_256_signature: ecdsa_crypto::Signature =
+			pair.as_inner_ref().sign_prehashed(&blake2_256(msg)).into();
+
+		// Verification works if same hashing function is used when signing and verifying.
+		assert!(BeefyAuthorityId::<Keccak256>::verify(&pair.public(), &keccak_256_signature, msg));
+		assert!(BeefyAuthorityId::<BlakeTwo256>::verify(
+			&pair.public(),
+			&blake2_256_signature,
+			msg
+		));
+		// Verification fails if distinct hashing functions are used when signing and verifying.
+		assert!(!BeefyAuthorityId::<Keccak256>::verify(&pair.public(), &blake2_256_signature, msg));
+		assert!(!BeefyAuthorityId::<BlakeTwo256>::verify(
+			&pair.public(),
+			&keccak_256_signature,
+			msg
+		));
+
+		// Other public key doesn't work
+		let (other_pair, _) = ecdsa_crypto::Pair::generate();
+		assert!(!BeefyAuthorityId::<Keccak256>::verify(
+			&other_pair.public(),
+			&keccak_256_signature,
+			msg,
+		));
+		assert!(!BeefyAuthorityId::<BlakeTwo256>::verify(
+			&other_pair.public(),
+			&blake2_256_signature,
+			msg,
+		));
+	}
+
+	#[test]
+	#[cfg(feature = "bls-experimental")]
+	fn bls_beefy_verify_works() {
+		let msg = &b"test-message"[..];
+		let (pair, _) = bls_crypto::Pair::generate();
+
+		let signature: bls_crypto::Signature = pair.as_inner_ref().sign(&msg).into();
+
+		// Verification works if same hashing function is used when signing and verifying.
+		assert!(BeefyAuthorityId::<Keccak256>::verify(&pair.public(), &signature, msg));
+
+		// Other public key doesn't work
+		let (other_pair, _) = bls_crypto::Pair::generate();
+		assert!(!BeefyAuthorityId::<Keccak256>::verify(&other_pair.public(), &signature, msg,));
+	}
+}
diff --git a/substrate/primitives/consensus/beefy/src/mmr.rs b/substrate/primitives/consensus/beefy/src/mmr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..660506b8763f177591408c526d4c7f8c341ad13c
--- /dev/null
+++ b/substrate/primitives/consensus/beefy/src/mmr.rs
@@ -0,0 +1,258 @@
+// 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.
+
+//! BEEFY + MMR utilties.
+//!
+//! While BEEFY can be used completely independently as an additional consensus gadget,
+//! it is designed around a main use case of bridging standalone networks together.
+//! For that use case it's common to use some aggregated data structure (like MMR) to be
+//! used in conjunction with BEEFY, to be able to efficiently prove any past blockchain data.
+//!
+//! This module contains primitives used by Polkadot implementation of the BEEFY+MMR bridge,
+//! but we imagine they will be useful for other chains that either want to bridge with Polkadot
+//! or are completely standalone, but heavily inspired by Polkadot.
+
+use crate::{ecdsa_crypto::AuthorityId, ConsensusLog, MmrRootHash, Vec, BEEFY_ENGINE_ID};
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime::{
+	generic::OpaqueDigestItemId,
+	traits::{Block, Header},
+};
+
+/// A provider for extra data that gets added to the Mmr leaf
+pub trait BeefyDataProvider<ExtraData> {
+	/// Return a vector of bytes, ideally should be a merkle root hash
+	fn extra_data() -> ExtraData;
+}
+
+/// A default implementation for runtimes.
+impl BeefyDataProvider<Vec<u8>> for () {
+	fn extra_data() -> Vec<u8> {
+		Vec::new()
+	}
+}
+
+/// A standard leaf that gets added every block to the MMR constructed by Substrate's `pallet_mmr`.
+#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode, TypeInfo)]
+pub struct MmrLeaf<BlockNumber, Hash, MerkleRoot, ExtraData> {
+	/// Version of the leaf format.
+	///
+	/// Can be used to enable future format migrations and compatibility.
+	/// See [`MmrLeafVersion`] documentation for details.
+	pub version: MmrLeafVersion,
+	/// Current block parent number and hash.
+	pub parent_number_and_hash: (BlockNumber, Hash),
+	/// A merkle root of the next BEEFY authority set.
+	pub beefy_next_authority_set: BeefyNextAuthoritySet<MerkleRoot>,
+	/// Arbitrary extra leaf data to be used by downstream pallets to include custom data in the
+	/// [`MmrLeaf`]
+	pub leaf_extra: ExtraData,
+}
+
+/// An MMR leaf versioning scheme.
+///
+/// Version is a single byte that constist of two components:
+/// - `major` - 3 bits
+/// - `minor` - 5 bits
+///
+/// Any change in encoding that adds new items to the structure is considered non-breaking, hence
+/// only requires an update of `minor` version. Any backward incompatible change (i.e. decoding to a
+/// previous leaf format fails) should be indicated with `major` version bump.
+///
+/// Given that adding new struct elements in SCALE is backward compatible (i.e. old format can be
+/// still decoded, the new fields will simply be ignored). We expect the major version to be bumped
+/// very rarely (hopefuly never).
+#[derive(Debug, Default, PartialEq, Eq, Clone, Encode, Decode, TypeInfo)]
+pub struct MmrLeafVersion(u8);
+impl MmrLeafVersion {
+	/// Create new version object from `major` and `minor` components.
+	///
+	/// Panics if any of the component occupies more than 4 bits.
+	pub fn new(major: u8, minor: u8) -> Self {
+		if major > 0b111 || minor > 0b11111 {
+			panic!("Version components are too big.");
+		}
+		let version = (major << 5) + minor;
+		Self(version)
+	}
+
+	/// Split the version into `major` and `minor` sub-components.
+	pub fn split(&self) -> (u8, u8) {
+		let major = self.0 >> 5;
+		let minor = self.0 & 0b11111;
+		(major, minor)
+	}
+}
+
+/// Details of a BEEFY authority set.
+#[derive(Debug, Default, PartialEq, Eq, Clone, Encode, Decode, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct BeefyAuthoritySet<AuthoritySetCommitment> {
+	/// Id of the set.
+	///
+	/// Id is required to correlate BEEFY signed commitments with the validator set.
+	/// Light Client can easily verify that the commitment witness it is getting is
+	/// produced by the latest validator set.
+	pub id: crate::ValidatorSetId,
+	/// Number of validators in the set.
+	///
+	/// Some BEEFY Light Clients may use an interactive protocol to verify only a subset
+	/// of signatures. We put set length here, so that these clients can verify the minimal
+	/// number of required signatures.
+	pub len: u32,
+
+	/// Commitment(s) to BEEFY AuthorityIds.
+	///
+	/// This is used by Light Clients to confirm that the commitments are signed by the correct
+	/// validator set. Light Clients using interactive protocol, might verify only subset of
+	/// signatures, hence don't require the full list here (will receive inclusion proofs).
+	///
+	/// This could be Merkle Root Hash built from BEEFY ECDSA public keys and/or
+	/// polynomial commitment to the polynomial interpolating BLS public keys
+	/// which is used by APK proof based light clients to verify the validity
+	/// of aggregated BLS keys using APK proofs.
+	/// Multiple commitments can be tupled together.
+	pub keyset_commitment: AuthoritySetCommitment,
+}
+
+/// Details of the next BEEFY authority set.
+pub type BeefyNextAuthoritySet<MerkleRoot> = BeefyAuthoritySet<MerkleRoot>;
+
+/// Extract the MMR root hash from a digest in the given header, if it exists.
+pub fn find_mmr_root_digest<B: Block>(header: &B::Header) -> Option<MmrRootHash> {
+	let id = OpaqueDigestItemId::Consensus(&BEEFY_ENGINE_ID);
+
+	let filter = |log: ConsensusLog<AuthorityId>| match log {
+		ConsensusLog::MmrRoot(root) => Some(root),
+		_ => None,
+	};
+	header.digest().convert_first(|l| l.try_to(id).and_then(filter))
+}
+
+#[cfg(feature = "std")]
+pub use mmr_root_provider::MmrRootProvider;
+#[cfg(feature = "std")]
+mod mmr_root_provider {
+	use super::*;
+	use crate::{known_payloads, payload::PayloadProvider, Payload};
+	use sp_api::{NumberFor, ProvideRuntimeApi};
+	use sp_mmr_primitives::MmrApi;
+	use sp_std::{marker::PhantomData, sync::Arc};
+
+	/// A [`crate::Payload`] provider where payload is Merkle Mountain Range root hash.
+	///
+	/// Encoded payload contains a [`crate::MmrRootHash`] type (i.e. 32-bytes hash).
+	pub struct MmrRootProvider<B, R> {
+		runtime: Arc<R>,
+		_phantom: PhantomData<B>,
+	}
+
+	impl<B, R> Clone for MmrRootProvider<B, R> {
+		fn clone(&self) -> Self {
+			Self { runtime: self.runtime.clone(), _phantom: PhantomData }
+		}
+	}
+
+	impl<B, R> MmrRootProvider<B, R>
+	where
+		B: Block,
+		R: ProvideRuntimeApi<B>,
+		R::Api: MmrApi<B, MmrRootHash, NumberFor<B>>,
+	{
+		/// Create new BEEFY Payload provider with MMR Root as payload.
+		pub fn new(runtime: Arc<R>) -> Self {
+			Self { runtime, _phantom: PhantomData }
+		}
+
+		/// Simple wrapper that gets MMR root from header digests or from client state.
+		fn mmr_root_from_digest_or_runtime(&self, header: &B::Header) -> Option<MmrRootHash> {
+			find_mmr_root_digest::<B>(header).or_else(|| {
+				self.runtime.runtime_api().mmr_root(header.hash()).ok().and_then(|r| r.ok())
+			})
+		}
+	}
+
+	impl<B: Block, R> PayloadProvider<B> for MmrRootProvider<B, R>
+	where
+		B: Block,
+		R: ProvideRuntimeApi<B>,
+		R::Api: MmrApi<B, MmrRootHash, NumberFor<B>>,
+	{
+		fn payload(&self, header: &B::Header) -> Option<Payload> {
+			self.mmr_root_from_digest_or_runtime(header).map(|mmr_root| {
+				Payload::from_single_entry(known_payloads::MMR_ROOT_ID, mmr_root.encode())
+			})
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::H256;
+	use sp_runtime::{traits::BlakeTwo256, Digest, DigestItem, OpaqueExtrinsic};
+
+	#[test]
+	fn should_construct_version_correctly() {
+		let tests = vec![(0, 0, 0b00000000), (7, 2, 0b11100010), (7, 31, 0b11111111)];
+
+		for (major, minor, version) in tests {
+			let v = MmrLeafVersion::new(major, minor);
+			assert_eq!(v.encode(), vec![version], "Encoding does not match.");
+			assert_eq!(v.split(), (major, minor));
+		}
+	}
+
+	#[test]
+	#[should_panic]
+	fn should_panic_if_major_too_large() {
+		MmrLeafVersion::new(8, 0);
+	}
+
+	#[test]
+	#[should_panic]
+	fn should_panic_if_minor_too_large() {
+		MmrLeafVersion::new(0, 32);
+	}
+
+	#[test]
+	fn extract_mmr_root_digest() {
+		type Header = sp_runtime::generic::Header<u64, BlakeTwo256>;
+		type Block = sp_runtime::generic::Block<Header, OpaqueExtrinsic>;
+		let mut header = Header::new(
+			1u64,
+			Default::default(),
+			Default::default(),
+			Default::default(),
+			Digest::default(),
+		);
+
+		// verify empty digest shows nothing
+		assert!(find_mmr_root_digest::<Block>(&header).is_none());
+
+		let mmr_root_hash = H256::random();
+		header.digest_mut().push(DigestItem::Consensus(
+			BEEFY_ENGINE_ID,
+			ConsensusLog::<AuthorityId>::MmrRoot(mmr_root_hash).encode(),
+		));
+
+		// verify validator set is correctly extracted from digest
+		let extracted = find_mmr_root_digest::<Block>(&header);
+		assert_eq!(extracted, Some(mmr_root_hash));
+	}
+}
diff --git a/substrate/primitives/consensus/beefy/src/payload.rs b/substrate/primitives/consensus/beefy/src/payload.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d520de445c95aed210c61e67f7e09be8b676442b
--- /dev/null
+++ b/substrate/primitives/consensus/beefy/src/payload.rs
@@ -0,0 +1,105 @@
+// 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 codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::traits::Block;
+use sp_std::prelude::*;
+
+/// Id of different payloads in the [`crate::Commitment`] data.
+pub type BeefyPayloadId = [u8; 2];
+
+/// Registry of all known [`BeefyPayloadId`].
+pub mod known_payloads {
+	use crate::BeefyPayloadId;
+
+	/// A [`Payload`](super::Payload) identifier for Merkle Mountain Range root hash.
+	///
+	/// Encoded value should contain a [`crate::MmrRootHash`] type (i.e. 32-bytes hash).
+	pub const MMR_ROOT_ID: BeefyPayloadId = *b"mh";
+}
+
+/// A BEEFY payload type allowing for future extensibility of adding additional kinds of payloads.
+///
+/// The idea is to store a vector of SCALE-encoded values with an extra identifier.
+/// Identifiers MUST be sorted by the [`BeefyPayloadId`] to allow efficient lookup of expected
+/// value. Duplicated identifiers are disallowed. It's okay for different implementations to only
+/// support a subset of possible values.
+#[derive(Decode, Encode, Debug, PartialEq, Eq, Clone, Ord, PartialOrd, Hash, TypeInfo)]
+pub struct Payload(Vec<(BeefyPayloadId, Vec<u8>)>);
+
+impl Payload {
+	/// Construct a new payload given an initial vallue
+	pub fn from_single_entry(id: BeefyPayloadId, value: Vec<u8>) -> Self {
+		Self(vec![(id, value)])
+	}
+
+	/// Returns a raw payload under given `id`.
+	///
+	/// If the [`BeefyPayloadId`] is not found in the payload `None` is returned.
+	pub fn get_raw(&self, id: &BeefyPayloadId) -> Option<&Vec<u8>> {
+		let index = self.0.binary_search_by(|probe| probe.0.cmp(id)).ok()?;
+		Some(&self.0[index].1)
+	}
+
+	/// Returns a decoded payload value under given `id`.
+	///
+	/// In case the value is not there or it cannot be decoded does not match `None` is returned.
+	pub fn get_decoded<T: Decode>(&self, id: &BeefyPayloadId) -> Option<T> {
+		self.get_raw(id).and_then(|raw| T::decode(&mut &raw[..]).ok())
+	}
+
+	/// Push a `Vec<u8>` with a given id into the payload vec.
+	/// This method will internally sort the payload vec after every push.
+	///
+	/// Returns self to allow for daisy chaining.
+	pub fn push_raw(mut self, id: BeefyPayloadId, value: Vec<u8>) -> Self {
+		self.0.push((id, value));
+		self.0.sort_by_key(|(id, _)| *id);
+		self
+	}
+}
+
+/// Trait for custom BEEFY payload providers.
+pub trait PayloadProvider<B: Block> {
+	/// Provide BEEFY payload if available for `header`.
+	fn payload(&self, header: &B::Header) -> Option<Payload>;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn payload_methods_work_as_expected() {
+		let id1: BeefyPayloadId = *b"hw";
+		let msg1: String = "1. Hello World!".to_string();
+		let id2: BeefyPayloadId = *b"yb";
+		let msg2: String = "2. Yellow Board!".to_string();
+		let id3: BeefyPayloadId = *b"cs";
+		let msg3: String = "3. Cello Cord!".to_string();
+
+		let payload = Payload::from_single_entry(id1, msg1.encode())
+			.push_raw(id2, msg2.encode())
+			.push_raw(id3, msg3.encode());
+
+		assert_eq!(payload.get_decoded(&id1), Some(msg1));
+		assert_eq!(payload.get_decoded(&id2), Some(msg2));
+		assert_eq!(payload.get_raw(&id3), Some(&msg3.encode()));
+		assert_eq!(payload.get_raw(&known_payloads::MMR_ROOT_ID), None);
+	}
+}
diff --git a/substrate/primitives/consensus/beefy/src/test_utils.rs b/substrate/primitives/consensus/beefy/src/test_utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b83f657af38e3e77c5d861d8f9e545ae54cf1e60
--- /dev/null
+++ b/substrate/primitives/consensus/beefy/src/test_utils.rs
@@ -0,0 +1,110 @@
+// 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(feature = "std")]
+
+use crate::{ecdsa_crypto, Commitment, EquivocationProof, Payload, ValidatorSetId, VoteMessage};
+use codec::Encode;
+use sp_core::{ecdsa, keccak_256, Pair};
+use std::collections::HashMap;
+use strum::IntoEnumIterator;
+
+/// Set of test accounts using [`crate::ecdsa_crypto`] types.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumIter)]
+pub enum Keyring {
+	Alice,
+	Bob,
+	Charlie,
+	Dave,
+	Eve,
+	Ferdie,
+	One,
+	Two,
+}
+
+impl Keyring {
+	/// Sign `msg`.
+	pub fn sign(self, msg: &[u8]) -> ecdsa_crypto::Signature {
+		// todo: use custom signature hashing type
+		let msg = keccak_256(msg);
+		ecdsa::Pair::from(self).sign_prehashed(&msg).into()
+	}
+
+	/// Return key pair.
+	pub fn pair(self) -> ecdsa_crypto::Pair {
+		ecdsa::Pair::from_string(self.to_seed().as_str(), None).unwrap().into()
+	}
+
+	/// Return public key.
+	pub fn public(self) -> ecdsa_crypto::Public {
+		self.pair().public()
+	}
+
+	/// Return seed string.
+	pub fn to_seed(self) -> String {
+		format!("//{}", self)
+	}
+
+	/// Get Keyring from public key.
+	pub fn from_public(who: &ecdsa_crypto::Public) -> Option<Keyring> {
+		Self::iter().find(|&k| &ecdsa_crypto::Public::from(k) == who)
+	}
+}
+
+lazy_static::lazy_static! {
+	static ref PRIVATE_KEYS: HashMap<Keyring, ecdsa_crypto::Pair> =
+		Keyring::iter().map(|i| (i, i.pair())).collect();
+	static ref PUBLIC_KEYS: HashMap<Keyring, ecdsa_crypto::Public> =
+		PRIVATE_KEYS.iter().map(|(&name, pair)| (name, pair.public())).collect();
+}
+
+impl From<Keyring> for ecdsa_crypto::Pair {
+	fn from(k: Keyring) -> Self {
+		k.pair()
+	}
+}
+
+impl From<Keyring> for ecdsa::Pair {
+	fn from(k: Keyring) -> Self {
+		k.pair().into()
+	}
+}
+
+impl From<Keyring> for ecdsa_crypto::Public {
+	fn from(k: Keyring) -> Self {
+		(*PUBLIC_KEYS).get(&k).cloned().unwrap()
+	}
+}
+
+/// Create a new `EquivocationProof` based on given arguments.
+pub fn generate_equivocation_proof(
+	vote1: (u64, Payload, ValidatorSetId, &Keyring),
+	vote2: (u64, Payload, ValidatorSetId, &Keyring),
+) -> EquivocationProof<u64, ecdsa_crypto::Public, ecdsa_crypto::Signature> {
+	let signed_vote = |block_number: u64,
+	                   payload: Payload,
+	                   validator_set_id: ValidatorSetId,
+	                   keyring: &Keyring| {
+		let commitment = Commitment { validator_set_id, block_number, payload };
+		let signature = keyring.sign(&commitment.encode());
+		VoteMessage { commitment, id: keyring.public(), signature }
+	};
+	let first = signed_vote(vote1.0, vote1.1, vote1.2, vote1.3);
+	let second = signed_vote(vote2.0, vote2.1, vote2.2, vote2.3);
+	EquivocationProof { first, second }
+}
diff --git a/substrate/primitives/consensus/beefy/src/witness.rs b/substrate/primitives/consensus/beefy/src/witness.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3f2c2bcbe282937ad5f0406d36c9358e9221f013
--- /dev/null
+++ b/substrate/primitives/consensus/beefy/src/witness.rs
@@ -0,0 +1,254 @@
+// 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.
+
+//! Primitives for light, 2-phase interactive verification protocol.
+//!
+//! Instead of submitting full list of signatures, it's possible to submit first a witness
+//! form of [SignedCommitment].
+//! This can later be verified by the client requesting only some (out of all) signatures for
+//! verification. This allows lowering the data and computation cost of verifying the
+//! signed commitment.
+
+use sp_std::prelude::*;
+
+use crate::commitment::{Commitment, SignedCommitment};
+
+/// A light form of [SignedCommitment].
+///
+/// This is a light ("witness") form of the signed commitment. Instead of containing full list of
+/// signatures, which might be heavy and expensive to verify, it only contains a bit vector of
+/// validators which signed the original [SignedCommitment] and a merkle root of all signatures.
+///
+/// This can be used by light clients for 2-phase interactive verification (for instance for
+/// Ethereum Mainnet), in a commit-reveal like scheme, where first we submit only the signed
+/// commitment witness and later on, the client picks only some signatures to verify at random.
+#[derive(Debug, PartialEq, Eq, codec::Encode, codec::Decode)]
+pub struct SignedCommitmentWitness<TBlockNumber, TSignatureAccumulator> {
+	/// The full content of the commitment.
+	pub commitment: Commitment<TBlockNumber>,
+
+	/// The bit vector of validators who signed the commitment.
+	pub signed_by: Vec<bool>, // TODO [ToDr] Consider replacing with bitvec crate
+
+	/// Either a merkle root of signatures in the original signed commitment or a single aggregated
+	/// BLS signature aggregating all original signatures.
+	pub signature_accumulator: TSignatureAccumulator,
+}
+
+impl<TBlockNumber, TSignatureAccumulator>
+	SignedCommitmentWitness<TBlockNumber, TSignatureAccumulator>
+{
+	/// Convert [SignedCommitment] into [SignedCommitmentWitness].
+	///
+	/// This takes a [SignedCommitment], which contains full signatures
+	/// and converts it into a witness form, which does not contain full signatures,
+	/// only a bit vector indicating which validators have signed the original [SignedCommitment]
+	/// and a merkle root of all signatures.
+	///
+	/// Returns the full list of signatures along with the witness.
+	pub fn from_signed<TSignatureAggregator, TSignature>(
+		signed: SignedCommitment<TBlockNumber, TSignature>,
+		aggregator: TSignatureAggregator,
+	) -> (Self, Vec<Option<TSignature>>)
+	where
+		TSignatureAggregator: FnOnce(&[Option<TSignature>]) -> TSignatureAccumulator,
+	{
+		let SignedCommitment { commitment, signatures } = signed;
+		let signed_by = signatures.iter().map(|s| s.is_some()).collect();
+		let signature_accumulator = aggregator(&signatures);
+
+		(Self { commitment, signed_by, signature_accumulator }, signatures)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use sp_core::{keccak_256, Pair};
+
+	use super::*;
+	use codec::Decode;
+
+	use crate::{ecdsa_crypto::Signature as EcdsaSignature, known_payloads, Payload};
+
+	#[cfg(feature = "bls-experimental")]
+	use crate::bls_crypto::Signature as BlsSignature;
+
+	#[cfg(feature = "bls-experimental")]
+	use w3f_bls::{
+		single_pop_aggregator::SignatureAggregatorAssumingPoP, Message, SerializableToBytes,
+		Signed, TinyBLS377,
+	};
+
+	type TestCommitment = Commitment<u128>;
+
+	// Types for ecdsa signed commitment.
+	type TestEcdsaSignedCommitment = SignedCommitment<u128, EcdsaSignature>;
+	type TestEcdsaSignedCommitmentWitness =
+		SignedCommitmentWitness<u128, Vec<Option<EcdsaSignature>>>;
+
+	#[cfg(feature = "bls-experimental")]
+	#[derive(Clone, Debug, PartialEq, codec::Encode, codec::Decode)]
+	struct EcdsaBlsSignaturePair(EcdsaSignature, BlsSignature);
+
+	// types for commitment containing  bls signature along side ecdsa signature
+	#[cfg(feature = "bls-experimental")]
+	type TestBlsSignedCommitment = SignedCommitment<u128, EcdsaBlsSignaturePair>;
+	#[cfg(feature = "bls-experimental")]
+	type TestBlsSignedCommitmentWitness = SignedCommitmentWitness<u128, Vec<u8>>;
+
+	// The mock signatures are equivalent to the ones produced by the BEEFY keystore
+	fn mock_ecdsa_signatures() -> (EcdsaSignature, EcdsaSignature) {
+		let alice = sp_core::ecdsa::Pair::from_string("//Alice", None).unwrap();
+
+		let msg = keccak_256(b"This is the first message");
+		let sig1 = alice.sign_prehashed(&msg);
+
+		let msg = keccak_256(b"This is the second message");
+		let sig2 = alice.sign_prehashed(&msg);
+
+		(sig1.into(), sig2.into())
+	}
+
+	// Generates mock aggregatable bls signature for generating test commitment
+	// BLS signatures
+	#[cfg(feature = "bls-experimental")]
+	fn mock_bls_signatures() -> (BlsSignature, BlsSignature) {
+		let alice = sp_core::bls::Pair::from_string("//Alice", None).unwrap();
+
+		let msg = b"This is the first message";
+		let sig1 = alice.sign(msg);
+
+		let msg = b"This is the second message";
+		let sig2 = alice.sign(msg);
+
+		(sig1.into(), sig2.into())
+	}
+
+	fn ecdsa_signed_commitment() -> TestEcdsaSignedCommitment {
+		let payload = Payload::from_single_entry(
+			known_payloads::MMR_ROOT_ID,
+			"Hello World!".as_bytes().to_vec(),
+		);
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		let sigs = mock_ecdsa_signatures();
+
+		SignedCommitment { commitment, signatures: vec![None, None, Some(sigs.0), Some(sigs.1)] }
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn ecdsa_and_bls_signed_commitment() -> TestBlsSignedCommitment {
+		let payload = Payload::from_single_entry(
+			known_payloads::MMR_ROOT_ID,
+			"Hello World!".as_bytes().to_vec(),
+		);
+		let commitment: TestCommitment =
+			Commitment { payload, block_number: 5, validator_set_id: 0 };
+
+		let ecdsa_sigs = mock_ecdsa_signatures();
+		let bls_sigs = mock_bls_signatures();
+
+		SignedCommitment {
+			commitment,
+			signatures: vec![
+				None,
+				None,
+				Some(EcdsaBlsSignaturePair(ecdsa_sigs.0, bls_sigs.0)),
+				Some(EcdsaBlsSignaturePair(ecdsa_sigs.1, bls_sigs.1)),
+			],
+		}
+	}
+
+	#[test]
+	fn should_convert_signed_commitment_to_witness() {
+		// given
+		let signed = ecdsa_signed_commitment();
+
+		// when
+		let (witness, signatures) =
+			TestEcdsaSignedCommitmentWitness::from_signed(signed, |sigs| sigs.to_vec());
+
+		// then
+		assert_eq!(witness.signature_accumulator, signatures);
+	}
+
+	#[test]
+	#[cfg(feature = "bls-experimental")]
+	fn should_convert_dually_signed_commitment_to_witness() {
+		// given
+		let signed = ecdsa_and_bls_signed_commitment();
+
+		// when
+		let (witness, _signatures) =
+			// from signed take a function as the aggregator 
+			TestBlsSignedCommitmentWitness::from_signed::<_, _>(signed, |sigs| {
+				// we are going to aggregate the signatures here
+				let mut aggregatedsigs: SignatureAggregatorAssumingPoP<TinyBLS377> =
+					SignatureAggregatorAssumingPoP::new(Message::new(b"", b"mock payload"));
+
+				for sig in sigs {
+					match sig {
+						Some(sig) => {
+							let serialized_sig : Vec<u8> = (*sig.1).to_vec();
+							aggregatedsigs.add_signature(
+								&w3f_bls::Signature::<TinyBLS377>::from_bytes(
+									serialized_sig.as_slice()
+								).unwrap()
+							);
+						},
+						None => (),
+					}
+				}
+				(&aggregatedsigs).signature().to_bytes()
+			});
+
+		// We can't use BlsSignature::try_from because it expected 112Bytes (CP (64) + BLS 48)
+		// single signature while we are having a BLS aggregated signature corresponding to no CP.
+		w3f_bls::Signature::<TinyBLS377>::from_bytes(witness.signature_accumulator.as_slice())
+			.unwrap();
+	}
+
+	#[test]
+	fn should_encode_and_decode_witness() {
+		// Given
+		let signed = ecdsa_signed_commitment();
+		let (witness, _) = TestEcdsaSignedCommitmentWitness::from_signed::<_, _>(
+			signed,
+			|sigs: &[std::option::Option<EcdsaSignature>]| sigs.to_vec(),
+		);
+
+		// When
+		let encoded = codec::Encode::encode(&witness);
+		let decoded = TestEcdsaSignedCommitmentWitness::decode(&mut &*encoded);
+
+		// Then
+		assert_eq!(decoded, Ok(witness));
+		assert_eq!(
+			encoded,
+			array_bytes::hex2bytes_unchecked(
+				"\
+				046d683048656c6c6f20576f726c642105000000000000000000000000000000000000000000000010\
+				0000010110000001558455ad81279df0795cc985580e4fb75d72d948d1107b2ac80a09abed4da8480c\
+				746cc321f2319a5e99a830e314d10dd3cd68ce3dc0c33c86e99bcb7816f9ba01012d6e1f8105c337a8\
+				6cdd9aaacdc496577f3db8c55ef9e6fd48f2c5c05a2274707491635d8ba3df64f324575b7b2a34487b\
+				ca2324b6a0046395a71681be3d0c2a00\
+			"
+			)
+		);
+	}
+}
diff --git a/substrate/primitives/consensus/beefy/test-res/large-raw-commitment b/substrate/primitives/consensus/beefy/test-res/large-raw-commitment
new file mode 100644
index 0000000000000000000000000000000000000000..d5dbbe402a88e734367395e5af0305f5a47a0872
Binary files /dev/null and b/substrate/primitives/consensus/beefy/test-res/large-raw-commitment differ
diff --git a/substrate/primitives/consensus/common/Cargo.toml b/substrate/primitives/consensus/common/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1f52fb1d44f78a28016e23bec32e17ca9683702c
--- /dev/null
+++ b/substrate/primitives/consensus/common/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "sp-consensus"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Common utilities for building and using consensus engines in substrate."
+documentation = "https://docs.rs/sp-consensus/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = "0.1.57"
+futures = { version = "0.3.21", features = ["thread-pool"] }
+log = "0.4.17"
+thiserror = "1.0.30"
+sp-core = { version = "21.0.0", path = "../../core" }
+sp-inherents = { version = "4.0.0-dev", path = "../../inherents" }
+sp-runtime = { version = "24.0.0", path = "../../runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../state-machine" }
+
+[dev-dependencies]
+futures = "0.3.21"
+sp-test-primitives = { version = "2.0.0", path = "../../test-primitives" }
+
+[features]
+default = []
diff --git a/substrate/primitives/consensus/common/README.md b/substrate/primitives/consensus/common/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..963bb0fbdba4af4de706c5303003f8036016291d
--- /dev/null
+++ b/substrate/primitives/consensus/common/README.md
@@ -0,0 +1,7 @@
+Common utilities for building and using consensus engines in substrate.
+
+Much of this crate is _unstable_ and thus the API is likely to undergo
+change. Implementors of traits should not rely on the interfaces to remain
+the same.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/consensus/common/src/block_validation.rs b/substrate/primitives/consensus/common/src/block_validation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..91e5330bbb06aad3a50af60b141a10d74ca86bc1
--- /dev/null
+++ b/substrate/primitives/consensus/common/src/block_validation.rs
@@ -0,0 +1,98 @@
+// 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.
+
+//! Block announcement validation.
+
+use crate::BlockStatus;
+use futures::FutureExt as _;
+use sp_runtime::traits::Block;
+use std::{error::Error, future::Future, pin::Pin, sync::Arc};
+
+/// A type which provides access to chain information.
+pub trait Chain<B: Block> {
+	/// Retrieve the status of the block denoted by the given [`Block::Hash`].
+	fn block_status(&self, hash: B::Hash) -> Result<BlockStatus, Box<dyn Error + Send>>;
+}
+
+impl<T: Chain<B>, B: Block> Chain<B> for Arc<T> {
+	fn block_status(&self, hash: B::Hash) -> Result<BlockStatus, Box<dyn Error + Send>> {
+		(&**self).block_status(hash)
+	}
+}
+
+/// Result of `BlockAnnounceValidator::validate`.
+#[derive(Debug, PartialEq, Eq)]
+pub enum Validation {
+	/// Valid block announcement.
+	Success {
+		/// Is this the new best block of the node?
+		is_new_best: bool,
+	},
+	/// Invalid block announcement.
+	Failure {
+		/// Should we disconnect from this peer?
+		///
+		/// This should be used if the peer for example send junk to spam us.
+		disconnect: bool,
+	},
+}
+
+/// Type which checks incoming block announcements.
+pub trait BlockAnnounceValidator<B: Block> {
+	/// Validate the announced header and its associated data.
+	///
+	/// # Note
+	///
+	/// Returning [`Validation::Failure`] will lead to a decrease of the
+	/// peers reputation as it sent us invalid data.
+	///
+	/// The returned future should only resolve to an error if there was an internal error
+	/// validating the block announcement. If the block announcement itself is invalid, this should
+	/// *always* return [`Validation::Failure`].
+	fn validate(
+		&mut self,
+		header: &B::Header,
+		data: &[u8],
+	) -> Pin<Box<dyn Future<Output = Result<Validation, Box<dyn Error + Send>>> + Send>>;
+}
+
+/// Default implementation of `BlockAnnounceValidator`.
+#[derive(Debug)]
+pub struct DefaultBlockAnnounceValidator;
+
+impl<B: Block> BlockAnnounceValidator<B> for DefaultBlockAnnounceValidator {
+	fn validate(
+		&mut self,
+		_: &B::Header,
+		data: &[u8],
+	) -> Pin<Box<dyn Future<Output = Result<Validation, Box<dyn Error + Send>>> + Send>> {
+		let is_empty = data.is_empty();
+
+		async move {
+			if !is_empty {
+				log::debug!(
+					target: "sync",
+					"Received unknown data alongside the block announcement.",
+				);
+				Ok(Validation::Failure { disconnect: true })
+			} else {
+				Ok(Validation::Success { is_new_best: false })
+			}
+		}
+		.boxed()
+	}
+}
diff --git a/substrate/primitives/consensus/common/src/error.rs b/substrate/primitives/consensus/common/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fb8d0447fe3d65fb66f058eb61da68755461d8e6
--- /dev/null
+++ b/substrate/primitives/consensus/common/src/error.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! Error types for consensus modules.
+
+/// Result type alias.
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// The error type for consensus-related operations.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Missing state at block with given descriptor.
+	#[error("State unavailable at block {0}")]
+	StateUnavailable(String),
+	/// Intermediate missing.
+	#[error("Missing intermediate")]
+	NoIntermediate,
+	/// Intermediate is of wrong type.
+	#[error("Invalid intermediate")]
+	InvalidIntermediate,
+	/// Error checking signature.
+	#[error("Message signature {0:?} by {1:?} is invalid")]
+	InvalidSignature(Vec<u8>, Vec<u8>),
+	/// Invalid authorities set received from the runtime.
+	#[error("Current state of blockchain has invalid authorities set")]
+	InvalidAuthoritiesSet,
+	/// Justification requirements not met.
+	#[error("Invalid justification")]
+	InvalidJustification,
+	/// Error from the client while importing.
+	#[error("Import failed: {0}")]
+	ClientImport(String),
+	/// Error from the client while fetching some data from the chain.
+	#[error("Chain lookup failed: {0}")]
+	ChainLookup(String),
+	/// Signing failed.
+	#[error("Failed to sign: {0}")]
+	CannotSign(String),
+	/// Some other error.
+	#[error(transparent)]
+	Other(#[from] Box<dyn std::error::Error + Sync + Send + 'static>),
+}
diff --git a/substrate/primitives/consensus/common/src/lib.rs b/substrate/primitives/consensus/common/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6505d005deb8df42c04252be85afd7e7b55924b9
--- /dev/null
+++ b/substrate/primitives/consensus/common/src/lib.rs
@@ -0,0 +1,254 @@
+// 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.
+
+//! Common utilities for building and using consensus engines in substrate.
+//!
+//! Much of this crate is _unstable_ and thus the API is likely to undergo
+//! change. Implementors of traits should not rely on the interfaces to remain
+//! the same.
+
+use std::{sync::Arc, time::Duration};
+
+use futures::prelude::*;
+use sp_runtime::{
+	traits::{Block as BlockT, HashingFor},
+	Digest,
+};
+use sp_state_machine::StorageProof;
+
+pub mod block_validation;
+pub mod error;
+mod select_chain;
+
+pub use self::error::Error;
+pub use select_chain::SelectChain;
+pub use sp_inherents::InherentData;
+pub use sp_state_machine::Backend as StateBackend;
+
+/// Block status.
+#[derive(Debug, PartialEq, Eq)]
+pub enum BlockStatus {
+	/// Added to the import queue.
+	Queued,
+	/// Already in the blockchain and the state is available.
+	InChainWithState,
+	/// In the blockchain, but the state is not available.
+	InChainPruned,
+	/// Block or parent is known to be bad.
+	KnownBad,
+	/// Not in the queue or the blockchain.
+	Unknown,
+}
+
+/// Block data origin.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum BlockOrigin {
+	/// Genesis block built into the client.
+	Genesis,
+	/// Block is part of the initial sync with the network.
+	NetworkInitialSync,
+	/// Block was broadcasted on the network.
+	NetworkBroadcast,
+	/// Block that was received from the network and validated in the consensus process.
+	ConsensusBroadcast,
+	/// Block that was collated by this node.
+	Own,
+	/// Block was imported from a file.
+	File,
+}
+
+/// Environment for a Consensus instance.
+///
+/// Creates proposer instance.
+pub trait Environment<B: BlockT> {
+	/// The proposer type this creates.
+	type Proposer: Proposer<B> + Send + 'static;
+	/// A future that resolves to the proposer.
+	type CreateProposer: Future<Output = Result<Self::Proposer, Self::Error>>
+		+ Send
+		+ Unpin
+		+ 'static;
+	/// Error which can occur upon creation.
+	type Error: From<Error> + std::error::Error + 'static;
+
+	/// Initialize the proposal logic on top of a specific header. Provide
+	/// the authorities at that header.
+	fn init(&mut self, parent_header: &B::Header) -> Self::CreateProposer;
+}
+
+/// A proposal that is created by a [`Proposer`].
+pub struct Proposal<Block: BlockT, Proof> {
+	/// The block that was build.
+	pub block: Block,
+	/// Proof that was recorded while building the block.
+	pub proof: Proof,
+	/// The storage changes while building this block.
+	pub storage_changes: sp_state_machine::StorageChanges<HashingFor<Block>>,
+}
+
+/// Error that is returned when [`ProofRecording`] requested to record a proof,
+/// but no proof was recorded.
+#[derive(Debug, thiserror::Error)]
+#[error("Proof should be recorded, but no proof was provided.")]
+pub struct NoProofRecorded;
+
+/// A trait to express the state of proof recording on type system level.
+///
+/// This is used by [`Proposer`] to signal if proof recording is enabled. This can be used by
+/// downstream users of the [`Proposer`] trait to enforce that proof recording is activated when
+/// required. The only two implementations of this trait are [`DisableProofRecording`] and
+/// [`EnableProofRecording`].
+///
+/// This trait is sealed and can not be implemented outside of this crate!
+pub trait ProofRecording: Send + Sync + private::Sealed + 'static {
+	/// The proof type that will be used internally.
+	type Proof: Send + Sync + 'static;
+	/// Is proof recording enabled?
+	const ENABLED: bool;
+	/// Convert the given `storage_proof` into [`Self::Proof`].
+	///
+	/// Internally Substrate uses `Option<StorageProof>` to express the both states of proof
+	/// recording (for now) and as [`Self::Proof`] is some different type, we need to provide a
+	/// function to convert this value.
+	///
+	/// If the proof recording was requested, but `None` is given, this will return
+	/// `Err(NoProofRecorded)`.
+	fn into_proof(storage_proof: Option<StorageProof>) -> Result<Self::Proof, NoProofRecorded>;
+}
+
+/// Express that proof recording is disabled.
+///
+/// For more information see [`ProofRecording`].
+pub struct DisableProofRecording;
+
+impl ProofRecording for DisableProofRecording {
+	type Proof = ();
+	const ENABLED: bool = false;
+
+	fn into_proof(_: Option<StorageProof>) -> Result<Self::Proof, NoProofRecorded> {
+		Ok(())
+	}
+}
+
+/// Express that proof recording is enabled.
+///
+/// For more information see [`ProofRecording`].
+pub struct EnableProofRecording;
+
+impl ProofRecording for EnableProofRecording {
+	type Proof = sp_state_machine::StorageProof;
+	const ENABLED: bool = true;
+
+	fn into_proof(proof: Option<StorageProof>) -> Result<Self::Proof, NoProofRecorded> {
+		proof.ok_or(NoProofRecorded)
+	}
+}
+
+/// Provides `Sealed` trait to prevent implementing trait [`ProofRecording`] outside of this crate.
+mod private {
+	/// Special trait that prevents the implementation of [`super::ProofRecording`] outside of this
+	/// crate.
+	pub trait Sealed {}
+
+	impl Sealed for super::DisableProofRecording {}
+	impl Sealed for super::EnableProofRecording {}
+}
+
+/// Logic for a proposer.
+///
+/// This will encapsulate creation and evaluation of proposals at a specific
+/// block.
+///
+/// Proposers are generic over bits of "consensus data" which are engine-specific.
+pub trait Proposer<B: BlockT> {
+	/// Error type which can occur when proposing or evaluating.
+	type Error: From<Error> + std::error::Error + 'static;
+	/// Future that resolves to a committed proposal with an optional proof.
+	type Proposal: Future<Output = Result<Proposal<B, Self::Proof>, Self::Error>>
+		+ Send
+		+ Unpin
+		+ 'static;
+	/// The supported proof recording by the implementator of this trait. See [`ProofRecording`]
+	/// for more information.
+	type ProofRecording: self::ProofRecording<Proof = Self::Proof> + Send + Sync + 'static;
+	/// The proof type used by [`Self::ProofRecording`].
+	type Proof: Send + Sync + 'static;
+
+	/// Create a proposal.
+	///
+	/// Gets the `inherent_data` and `inherent_digests` as input for the proposal. Additionally
+	/// a maximum duration for building this proposal is given. If building the proposal takes
+	/// longer than this maximum, the proposal will be very likely discarded.
+	///
+	/// If `block_size_limit` is given, the proposer should push transactions until the block size
+	/// limit is hit. Depending on the `finalize_block` implementation of the runtime, it probably
+	/// incorporates other operations (that are happening after the block limit is hit). So,
+	/// when the block size estimation also includes a proof that is recorded alongside the block
+	/// production, the proof can still grow. This means that the `block_size_limit` should not be
+	/// the hard limit of what is actually allowed.
+	///
+	/// # Return
+	///
+	/// Returns a future that resolves to a [`Proposal`] or to [`Error`].
+	fn propose(
+		self,
+		inherent_data: InherentData,
+		inherent_digests: Digest,
+		max_duration: Duration,
+		block_size_limit: Option<usize>,
+	) -> Self::Proposal;
+}
+
+/// An oracle for when major synchronization work is being undertaken.
+///
+/// Generally, consensus authoring work isn't undertaken while well behind
+/// the head of the chain.
+pub trait SyncOracle {
+	/// Whether the synchronization service is undergoing major sync.
+	/// Returns true if so.
+	fn is_major_syncing(&self) -> bool;
+	/// Whether the synchronization service is offline.
+	/// Returns true if so.
+	fn is_offline(&self) -> bool;
+}
+
+/// A synchronization oracle for when there is no network.
+#[derive(Clone, Copy, Debug)]
+pub struct NoNetwork;
+
+impl SyncOracle for NoNetwork {
+	fn is_major_syncing(&self) -> bool {
+		false
+	}
+	fn is_offline(&self) -> bool {
+		false
+	}
+}
+
+impl<T> SyncOracle for Arc<T>
+where
+	T: ?Sized,
+	T: SyncOracle,
+{
+	fn is_major_syncing(&self) -> bool {
+		T::is_major_syncing(self)
+	}
+
+	fn is_offline(&self) -> bool {
+		T::is_offline(self)
+	}
+}
diff --git a/substrate/primitives/consensus/common/src/select_chain.rs b/substrate/primitives/consensus/common/src/select_chain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d387cc1ade097b7d652ee2f6b5a9ca7de28cea1b
--- /dev/null
+++ b/substrate/primitives/consensus/common/src/select_chain.rs
@@ -0,0 +1,56 @@
+// 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::error::Error;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+/// The SelectChain trait defines the strategy upon which the head is chosen
+/// if multiple forks are present for an opaque definition of "best" in the
+/// specific chain build.
+///
+/// The Strategy can be customized for the two use cases of authoring new blocks
+/// upon the best chain or which fork to finalize. Unless implemented differently
+/// by default finalization methods fall back to use authoring, so as a minimum
+/// `_authoring`-functions must be implemented.
+///
+/// Any particular user must make explicit, however, whether they intend to finalize
+/// or author through the using the right function call, as these might differ in
+/// some implementations.
+///
+/// Non-deterministically finalizing chains may only use the `_authoring` functions.
+#[async_trait::async_trait]
+pub trait SelectChain<Block: BlockT>: Sync + Send + Clone {
+	/// Get all leaves of the chain, i.e. block hashes that have no children currently.
+	/// Leaves that can never be finalized will not be returned.
+	async fn leaves(&self) -> Result<Vec<<Block as BlockT>::Hash>, Error>;
+
+	/// Among those `leaves` deterministically pick one chain as the generally
+	/// best chain to author new blocks upon and probably (but not necessarily)
+	/// finalize.
+	async fn best_chain(&self) -> Result<<Block as BlockT>::Header, Error>;
+
+	/// Get the best descendent of `base_hash` that we should attempt to
+	/// finalize next, if any. It is valid to return the given `base_hash`
+	/// itself if no better descendent exists.
+	async fn finality_target(
+		&self,
+		base_hash: <Block as BlockT>::Hash,
+		_maybe_max_number: Option<NumberFor<Block>>,
+	) -> Result<<Block as BlockT>::Hash, Error> {
+		Ok(base_hash)
+	}
+}
diff --git a/substrate/primitives/consensus/grandpa/Cargo.toml b/substrate/primitives/consensus/grandpa/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1bbbbe61bb5416b0971d4be8fc5c086d0f398bfc
--- /dev/null
+++ b/substrate/primitives/consensus/grandpa/Cargo.toml
@@ -0,0 +1,52 @@
+[package]
+name = "sp-consensus-grandpa"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Primitives for GRANDPA integration, suitable for WASM compilation."
+documentation = "https://docs.rs/sp-consensus-grandpa"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+grandpa = { package = "finality-grandpa", version = "0.16.2", default-features = false, features = ["derive-codec"] }
+log = { version = "0.4.17", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", features = ["derive", "alloc"], default-features = false, optional = true }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../api" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../application-crypto" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../core" }
+sp-keystore = { version = "0.27.0", default-features = false, optional = true, path = "../../keystore" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"grandpa/std",
+	"log/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-keystore/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"dep:serde",
+	"scale-info/serde",
+	"sp-application-crypto/serde",
+	"sp-core/serde",
+	"sp-runtime/serde",
+]
diff --git a/substrate/primitives/consensus/grandpa/README.md b/substrate/primitives/consensus/grandpa/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..77a7abca2eef3fa2da9b8c2580c1c0ae7f1d184b
--- /dev/null
+++ b/substrate/primitives/consensus/grandpa/README.md
@@ -0,0 +1,3 @@
+Primitives for GRANDPA integration, suitable for WASM compilation.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/consensus/grandpa/src/lib.rs b/substrate/primitives/consensus/grandpa/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..baeaee4738e484d23059f4a27dc99093b60412fe
--- /dev/null
+++ b/substrate/primitives/consensus/grandpa/src/lib.rs
@@ -0,0 +1,596 @@
+// 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.
+
+//! Primitives for GRANDPA integration, suitable for WASM compilation.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+#[cfg(feature = "serde")]
+use serde::Serialize;
+
+use codec::{Codec, Decode, Encode, Input};
+use scale_info::TypeInfo;
+#[cfg(feature = "std")]
+use sp_keystore::KeystorePtr;
+use sp_runtime::{
+	traits::{Header as HeaderT, NumberFor},
+	ConsensusEngineId, RuntimeDebug,
+};
+use sp_std::{borrow::Cow, vec::Vec};
+
+/// The log target to be used by client code.
+pub const CLIENT_LOG_TARGET: &str = "grandpa";
+/// The log target to be used by runtime code.
+pub const RUNTIME_LOG_TARGET: &str = "runtime::grandpa";
+
+/// Key type for GRANDPA module.
+pub const KEY_TYPE: sp_core::crypto::KeyTypeId = sp_application_crypto::key_types::GRANDPA;
+
+mod app {
+	use sp_application_crypto::{app_crypto, ed25519, key_types::GRANDPA};
+	app_crypto!(ed25519, GRANDPA);
+}
+
+sp_application_crypto::with_pair! {
+	/// The grandpa crypto scheme defined via the keypair type.
+	pub type AuthorityPair = app::Pair;
+}
+
+/// Identity of a Grandpa authority.
+pub type AuthorityId = app::Public;
+
+/// Signature for a Grandpa authority.
+pub type AuthoritySignature = app::Signature;
+
+/// The `ConsensusEngineId` of GRANDPA.
+pub const GRANDPA_ENGINE_ID: ConsensusEngineId = *b"FRNK";
+
+/// The storage key for the current set of weighted Grandpa authorities.
+/// The value stored is an encoded VersionedAuthorityList.
+pub const GRANDPA_AUTHORITIES_KEY: &[u8] = b":grandpa_authorities";
+
+/// The weight of an authority.
+pub type AuthorityWeight = u64;
+
+/// The index of an authority.
+pub type AuthorityIndex = u64;
+
+/// The monotonic identifier of a GRANDPA set of authorities.
+pub type SetId = u64;
+
+/// The round indicator.
+pub type RoundNumber = u64;
+
+/// A list of Grandpa authorities with associated weights.
+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>;
+
+/// A signed message.
+pub type SignedMessage<Header> = grandpa::SignedMessage<
+	<Header as HeaderT>::Hash,
+	<Header as HeaderT>::Number,
+	AuthoritySignature,
+	AuthorityId,
+>;
+
+/// A primary propose message for this chain's block type.
+pub type PrimaryPropose<Header> =
+	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>;
+/// A precommit message for this chain's block type.
+pub type Precommit<Header> =
+	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<
+	<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<
+	<Header as HeaderT>::Hash,
+	<Header as HeaderT>::Number,
+	AuthoritySignature,
+	AuthorityId,
+>;
+
+/// A compact commit message for this chain's block type.
+pub type CompactCommit<Header> = grandpa::CompactCommit<
+	<Header as HeaderT>::Hash,
+	<Header as HeaderT>::Number,
+	AuthoritySignature,
+	AuthorityId,
+>;
+
+/// A GRANDPA justification for block finality, it includes a commit message and
+/// an ancestry proof including all headers routing all precommit target blocks
+/// to the commit target block. Due to the current voting strategy the precommit
+/// targets should be the same as the commit target, since honest voters don't
+/// vote past authority set change blocks.
+///
+/// This is meant to be stored in the db and passed around the network to other
+/// nodes, and are used by syncing nodes to prove authority set handoffs.
+#[derive(Clone, Encode, Decode, PartialEq, Eq, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Debug))]
+pub struct GrandpaJustification<Header: HeaderT> {
+	pub round: u64,
+	pub commit: Commit<Header>,
+	pub votes_ancestries: Vec<Header>,
+}
+
+/// A scheduled change of authority set.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize))]
+pub struct ScheduledChange<N> {
+	/// The new authorities after the change, along with their respective weights.
+	pub next_authorities: AuthorityList,
+	/// The number of blocks to delay.
+	pub delay: N,
+}
+
+/// An consensus log item for GRANDPA.
+#[derive(Decode, Encode, PartialEq, Eq, Clone, RuntimeDebug)]
+#[cfg_attr(feature = "serde", derive(Serialize))]
+pub enum ConsensusLog<N: Codec> {
+	/// Schedule an authority set change.
+	///
+	/// The earliest digest of this type in a single block will be respected,
+	/// provided that there is no `ForcedChange` digest. If there is, then the
+	/// `ForcedChange` will take precedence.
+	///
+	/// No change should be scheduled if one is already and the delay has not
+	/// passed completely.
+	///
+	/// This should be a pure function: i.e. as long as the runtime can interpret
+	/// the digest type it should return the same result regardless of the current
+	/// state.
+	#[codec(index = 1)]
+	ScheduledChange(ScheduledChange<N>),
+	/// Force an authority set change.
+	///
+	/// Forced changes are applied after a delay of _imported_ blocks,
+	/// while pending changes are applied after a delay of _finalized_ blocks.
+	///
+	/// The earliest digest of this type in a single block will be respected,
+	/// with others ignored.
+	///
+	/// No change should be scheduled if one is already and the delay has not
+	/// passed completely.
+	///
+	/// This should be a pure function: i.e. as long as the runtime can interpret
+	/// the digest type it should return the same result regardless of the current
+	/// state.
+	#[codec(index = 2)]
+	ForcedChange(N, ScheduledChange<N>),
+	/// Note that the authority with given index is disabled until the next change.
+	#[codec(index = 3)]
+	OnDisabled(AuthorityIndex),
+	/// A signal to pause the current authority set after the given delay.
+	/// After finalizing the block at _delay_ the authorities should stop voting.
+	#[codec(index = 4)]
+	Pause(N),
+	/// A signal to resume the current authority set after the given delay.
+	/// After authoring the block at _delay_ the authorities should resume voting.
+	#[codec(index = 5)]
+	Resume(N),
+}
+
+impl<N: Codec> ConsensusLog<N> {
+	/// Try to cast the log entry as a contained signal.
+	pub fn try_into_change(self) -> Option<ScheduledChange<N>> {
+		match self {
+			ConsensusLog::ScheduledChange(change) => Some(change),
+			_ => None,
+		}
+	}
+
+	/// Try to cast the log entry as a contained forced signal.
+	pub fn try_into_forced_change(self) -> Option<(N, ScheduledChange<N>)> {
+		match self {
+			ConsensusLog::ForcedChange(median, change) => Some((median, change)),
+			_ => None,
+		}
+	}
+
+	/// Try to cast the log entry as a contained pause signal.
+	pub fn try_into_pause(self) -> Option<N> {
+		match self {
+			ConsensusLog::Pause(delay) => Some(delay),
+			_ => None,
+		}
+	}
+
+	/// Try to cast the log entry as a contained resume signal.
+	pub fn try_into_resume(self) -> Option<N> {
+		match self {
+			ConsensusLog::Resume(delay) => Some(delay),
+			_ => None,
+		}
+	}
+}
+
+/// Proof of voter misbehavior on a given set id. Misbehavior/equivocation in
+/// GRANDPA happens when a voter votes on the same round (either at prevote or
+/// precommit stage) for different blocks. Proving is achieved by collecting the
+/// signed messages of conflicting votes.
+#[derive(Clone, Debug, Decode, Encode, PartialEq, Eq, TypeInfo)]
+pub struct EquivocationProof<H, N> {
+	set_id: SetId,
+	equivocation: Equivocation<H, N>,
+}
+
+impl<H, N> EquivocationProof<H, N> {
+	/// Create a new `EquivocationProof` for the given set id and using the
+	/// given equivocation as proof.
+	pub fn new(set_id: SetId, equivocation: Equivocation<H, N>) -> Self {
+		EquivocationProof { set_id, equivocation }
+	}
+
+	/// Returns the set id at which the equivocation occurred.
+	pub fn set_id(&self) -> SetId {
+		self.set_id
+	}
+
+	/// Returns the round number at which the equivocation occurred.
+	pub fn round(&self) -> RoundNumber {
+		match self.equivocation {
+			Equivocation::Prevote(ref equivocation) => equivocation.round_number,
+			Equivocation::Precommit(ref equivocation) => equivocation.round_number,
+		}
+	}
+
+	/// Returns the authority id of the equivocator.
+	pub fn offender(&self) -> &AuthorityId {
+		self.equivocation.offender()
+	}
+}
+
+/// Wrapper object for GRANDPA equivocation proofs, useful for unifying prevote
+/// and precommit equivocations under a common type.
+#[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>),
+	/// Proof of equivocation at precommit stage.
+	Precommit(grandpa::Equivocation<AuthorityId, grandpa::Precommit<H, N>, AuthoritySignature>),
+}
+
+impl<H, N> From<grandpa::Equivocation<AuthorityId, grandpa::Prevote<H, N>, AuthoritySignature>>
+	for Equivocation<H, N>
+{
+	fn from(
+		equivocation: grandpa::Equivocation<
+			AuthorityId,
+			grandpa::Prevote<H, N>,
+			AuthoritySignature,
+		>,
+	) -> Self {
+		Equivocation::Prevote(equivocation)
+	}
+}
+
+impl<H, N> From<grandpa::Equivocation<AuthorityId, grandpa::Precommit<H, N>, AuthoritySignature>>
+	for Equivocation<H, N>
+{
+	fn from(
+		equivocation: grandpa::Equivocation<
+			AuthorityId,
+			grandpa::Precommit<H, N>,
+			AuthoritySignature,
+		>,
+	) -> Self {
+		Equivocation::Precommit(equivocation)
+	}
+}
+
+impl<H, N> Equivocation<H, N> {
+	/// Returns the authority id of the equivocator.
+	pub fn offender(&self) -> &AuthorityId {
+		match self {
+			Equivocation::Prevote(ref equivocation) => &equivocation.identity,
+			Equivocation::Precommit(ref equivocation) => &equivocation.identity,
+		}
+	}
+
+	/// Returns the round number when the equivocation happened.
+	pub fn round_number(&self) -> RoundNumber {
+		match self {
+			Equivocation::Prevote(ref equivocation) => equivocation.round_number,
+			Equivocation::Precommit(ref equivocation) => equivocation.round_number,
+		}
+	}
+}
+
+/// Verifies the equivocation proof by making sure that both votes target
+/// different blocks and that its signatures are valid.
+pub fn check_equivocation_proof<H, N>(report: EquivocationProof<H, N>) -> bool
+where
+	H: Clone + Encode + PartialEq,
+	N: Clone + Encode + PartialEq,
+{
+	// NOTE: the bare `Prevote` and `Precommit` types don't share any trait,
+	// this is implemented as a macro to avoid duplication.
+	macro_rules! check {
+		( $equivocation:expr, $message:expr ) => {
+			// if both votes have the same target the equivocation is invalid.
+			if $equivocation.first.0.target_hash == $equivocation.second.0.target_hash &&
+				$equivocation.first.0.target_number == $equivocation.second.0.target_number
+			{
+				return false
+			}
+
+			// check signatures on both votes are valid
+			let valid_first = check_message_signature(
+				&$message($equivocation.first.0),
+				&$equivocation.identity,
+				&$equivocation.first.1,
+				$equivocation.round_number,
+				report.set_id,
+			);
+
+			let valid_second = check_message_signature(
+				&$message($equivocation.second.0),
+				&$equivocation.identity,
+				&$equivocation.second.1,
+				$equivocation.round_number,
+				report.set_id,
+			);
+
+			return valid_first && valid_second
+		};
+	}
+
+	match report.equivocation {
+		Equivocation::Prevote(equivocation) => {
+			check!(equivocation, grandpa::Message::Prevote);
+		},
+		Equivocation::Precommit(equivocation) => {
+			check!(equivocation, grandpa::Message::Precommit);
+		},
+	}
+}
+
+/// Encode round message localized to a given round and set id.
+pub fn localized_payload<E: Encode>(round: RoundNumber, set_id: SetId, message: &E) -> Vec<u8> {
+	let mut buf = Vec::new();
+	localized_payload_with_buffer(round, set_id, message, &mut buf);
+	buf
+}
+
+/// Encode round message localized to a given round and set id using the given
+/// buffer. The given buffer will be cleared and the resulting encoded payload
+/// will always be written to the start of the buffer.
+pub fn localized_payload_with_buffer<E: Encode>(
+	round: RoundNumber,
+	set_id: SetId,
+	message: &E,
+	buf: &mut Vec<u8>,
+) {
+	buf.clear();
+	(message, round, set_id).encode_to(buf)
+}
+
+/// 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>,
+	id: &AuthorityId,
+	signature: &AuthoritySignature,
+	round: RoundNumber,
+	set_id: SetId,
+) -> bool
+where
+	H: Encode,
+	N: Encode,
+{
+	check_message_signature_with_buffer(message, id, signature, round, set_id, &mut Vec::new())
+}
+
+/// Check a message signature by encoding the message as a localized payload and
+/// verifying the provided signature using the expected authority id.
+/// 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>,
+	id: &AuthorityId,
+	signature: &AuthoritySignature,
+	round: RoundNumber,
+	set_id: SetId,
+	buf: &mut Vec<u8>,
+) -> bool
+where
+	H: Encode,
+	N: Encode,
+{
+	use sp_application_crypto::RuntimeAppPublic;
+
+	localized_payload_with_buffer(round, set_id, message, buf);
+
+	let valid = id.verify(&buf, signature);
+
+	if !valid {
+		let log_target = if cfg!(feature = "std") { CLIENT_LOG_TARGET } else { RUNTIME_LOG_TARGET };
+
+		log::debug!(target: log_target, "Bad signature on message from {:?}", id);
+	}
+
+	valid
+}
+
+/// Localizes the message to the given set and round and signs the payload.
+#[cfg(feature = "std")]
+pub fn sign_message<H, N>(
+	keystore: KeystorePtr,
+	message: grandpa::Message<H, N>,
+	public: AuthorityId,
+	round: RoundNumber,
+	set_id: SetId,
+) -> Option<grandpa::SignedMessage<H, N, AuthoritySignature, AuthorityId>>
+where
+	H: Encode,
+	N: Encode,
+{
+	use sp_application_crypto::AppCrypto;
+
+	let encoded = localized_payload(round, set_id, &message);
+	let signature = keystore
+		.ed25519_sign(AuthorityId::ID, public.as_ref(), &encoded[..])
+		.ok()
+		.flatten()?
+		.try_into()
+		.ok()?;
+
+	Some(grandpa::SignedMessage { message, signature, id: public })
+}
+
+/// WASM function call to check for pending changes.
+pub const PENDING_CHANGE_CALL: &str = "grandpa_pending_change";
+/// WASM function call to get current GRANDPA authorities.
+pub const AUTHORITIES_CALL: &str = "grandpa_authorities";
+
+/// The current version of the stored AuthorityList type. The encoding version MUST be updated any
+/// time the AuthorityList type changes.
+const AUTHORITIES_VERSION: u8 = 1;
+
+/// An AuthorityList that is encoded with a version specifier. The encoding version is updated any
+/// time the AuthorityList type changes. This ensures that encodings of different versions of an
+/// AuthorityList are differentiable. Attempting to decode an authority list with an unknown
+/// version will fail.
+#[derive(Default)]
+pub struct VersionedAuthorityList<'a>(Cow<'a, AuthorityList>);
+
+impl<'a> From<AuthorityList> for VersionedAuthorityList<'a> {
+	fn from(authorities: AuthorityList) -> Self {
+		VersionedAuthorityList(Cow::Owned(authorities))
+	}
+}
+
+impl<'a> From<&'a AuthorityList> for VersionedAuthorityList<'a> {
+	fn from(authorities: &'a AuthorityList) -> Self {
+		VersionedAuthorityList(Cow::Borrowed(authorities))
+	}
+}
+
+impl<'a> Into<AuthorityList> for VersionedAuthorityList<'a> {
+	fn into(self) -> AuthorityList {
+		self.0.into_owned()
+	}
+}
+
+impl<'a> Encode for VersionedAuthorityList<'a> {
+	fn size_hint(&self) -> usize {
+		(AUTHORITIES_VERSION, self.0.as_ref()).size_hint()
+	}
+
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		(AUTHORITIES_VERSION, self.0.as_ref()).using_encoded(f)
+	}
+}
+
+impl<'a> Decode for VersionedAuthorityList<'a> {
+	fn decode<I: Input>(value: &mut I) -> Result<Self, codec::Error> {
+		let (version, authorities): (u8, AuthorityList) = Decode::decode(value)?;
+		if version != AUTHORITIES_VERSION {
+			return Err("unknown Grandpa authorities version".into())
+		}
+		Ok(authorities.into())
+	}
+}
+
+/// An opaque type used to represent the key ownership proof at the runtime API
+/// boundary. The inner value is an encoded representation of the actual key
+/// ownership proof which will be parameterized when defining the runtime. At
+/// 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()
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// APIs for integrating the GRANDPA finality gadget into runtimes.
+	/// This should be implemented on the runtime side.
+	///
+	/// This is primarily used for negotiating authority-set changes for the
+	/// gadget. GRANDPA uses a signaling model of changing authority sets:
+	/// changes should be signaled with a delay of N blocks, and then automatically
+	/// applied in the runtime after those N blocks have passed.
+	///
+	/// The consensus protocol will coordinate the handoff externally.
+	#[api_version(3)]
+	pub trait GrandpaApi {
+		/// Get the current GRANDPA authorities and weights. This should not change except
+		/// for when changes are scheduled and the corresponding delay has passed.
+		///
+		/// When called at block B, it will return the set of authorities that should be
+		/// used to finalize descendants of this block (B+1, B+2, ...). The block B itself
+		/// is finalized by the authorities from block B-1.
+		fn grandpa_authorities() -> AuthorityList;
+
+		/// Submits an unsigned extrinsic to report an equivocation. The caller
+		/// must provide the equivocation proof and a key ownership proof
+		/// (should be obtained using `generate_key_ownership_proof`). The
+		/// extrinsic will be unsigned and should only be accepted for local
+		/// authorship (not to be broadcast to the network). This method returns
+		/// `None` when creation of the extrinsic fails, e.g. if equivocation
+		/// reporting is disabled for the given runtime (i.e. this method is
+		/// hardcoded to return `None`). Only useful in an offchain context.
+		fn submit_report_equivocation_unsigned_extrinsic(
+			equivocation_proof: EquivocationProof<Block::Hash, NumberFor<Block>>,
+			key_owner_proof: OpaqueKeyOwnershipProof,
+		) -> Option<()>;
+
+		/// Generates a proof of key ownership for the given authority in the
+		/// given set. An example usage of this module is coupled with the
+		/// session historical module to prove that a given authority key is
+		/// tied to a given staking identity during a specific session. Proofs
+		/// of key ownership are necessary for submitting equivocation reports.
+		/// NOTE: even though the API takes a `set_id` as parameter the current
+		/// implementations ignore this parameter and instead rely on this
+		/// method being called at the correct block height, i.e. any point at
+		/// which the given set id is live on-chain. Future implementations will
+		/// instead use indexed data through an offchain worker, not requiring
+		/// older states to be available.
+		fn generate_key_ownership_proof(
+			set_id: SetId,
+			authority_id: AuthorityId,
+		) -> Option<OpaqueKeyOwnershipProof>;
+
+		/// Get current GRANDPA authority set id.
+		fn current_set_id() -> SetId;
+	}
+}
diff --git a/substrate/primitives/consensus/pow/Cargo.toml b/substrate/primitives/consensus/pow/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..491486fe0c3965a1aeb93cf170e1cd38f9720c69
--- /dev/null
+++ b/substrate/primitives/consensus/pow/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "sp-consensus-pow"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Primitives for Aura consensus"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../api" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"sp-api/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
diff --git a/substrate/primitives/consensus/pow/README.md b/substrate/primitives/consensus/pow/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..881864377649804e610fddecce9e9a3eb8624856
--- /dev/null
+++ b/substrate/primitives/consensus/pow/README.md
@@ -0,0 +1,3 @@
+Primitives for Substrate Proof-of-Work (PoW) consensus.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/consensus/pow/src/lib.rs b/substrate/primitives/consensus/pow/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f37aae1c5c012900b4220e2cdf9e1ab5edd188b0
--- /dev/null
+++ b/substrate/primitives/consensus/pow/src/lib.rs
@@ -0,0 +1,65 @@
+// 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.
+
+//! Primitives for Substrate Proof-of-Work (PoW) consensus.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::Decode;
+use sp_runtime::ConsensusEngineId;
+use sp_std::vec::Vec;
+
+/// The `ConsensusEngineId` of PoW.
+pub const POW_ENGINE_ID: ConsensusEngineId = [b'p', b'o', b'w', b'_'];
+
+/// Type of seal.
+pub type Seal = Vec<u8>;
+
+/// Define methods that total difficulty should implement.
+pub trait TotalDifficulty {
+	fn increment(&mut self, other: Self);
+}
+
+impl TotalDifficulty for sp_core::U256 {
+	fn increment(&mut self, other: Self) {
+		let ret = self.saturating_add(other);
+		*self = ret;
+	}
+}
+
+impl TotalDifficulty for u128 {
+	fn increment(&mut self, other: Self) {
+		let ret = self.saturating_add(other);
+		*self = ret;
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// API necessary for timestamp-based difficulty adjustment algorithms.
+	pub trait TimestampApi<Moment: Decode> {
+		/// Return the timestamp in the current block.
+		fn timestamp() -> Moment;
+	}
+
+	/// API for those chains that put their difficulty adjustment algorithm directly
+	/// onto runtime. Note that while putting difficulty adjustment algorithm to
+	/// runtime is safe, putting the PoW algorithm on runtime is not.
+	pub trait DifficultyApi<Difficulty: Decode> {
+		/// Return the target difficulty of the next block.
+		fn difficulty() -> Difficulty;
+	}
+}
diff --git a/substrate/primitives/consensus/slots/Cargo.toml b/substrate/primitives/consensus/slots/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ffc347a78697e3c7fb172c19811c27458d30d27e
--- /dev/null
+++ b/substrate/primitives/consensus/slots/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "sp-consensus-slots"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Primitives for slots-based consensus"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+scale-info = { version = "2.0.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0", default-features = false, features = ["derive", "alloc"], optional = true }
+sp-std = { version = "8.0.0", default-features = false, path = "../../std" }
+sp-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../timestamp" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-std/std",
+	"sp-timestamp/std",
+]
+
+# Serde support without relying on std features.
+serde = [ "dep:serde", "scale-info/serde" ]
diff --git a/substrate/primitives/consensus/slots/README.md b/substrate/primitives/consensus/slots/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f451c32888a47843c1f679a17d8db06d23811272
--- /dev/null
+++ b/substrate/primitives/consensus/slots/README.md
@@ -0,0 +1,3 @@
+Primitives for slots-based consensus engines.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/consensus/slots/src/lib.rs b/substrate/primitives/consensus/slots/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..30bb42e2c7589094147f6ba2732e8c587c106302
--- /dev/null
+++ b/substrate/primitives/consensus/slots/src/lib.rs
@@ -0,0 +1,143 @@
+// 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.
+
+//! Primitives for slots-based consensus engines.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_timestamp::Timestamp;
+
+/// Unit type wrapper that represents a slot.
+#[derive(Debug, Encode, MaxEncodedLen, Decode, Eq, Clone, Copy, Default, Ord, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Slot(u64);
+
+impl core::ops::Deref for Slot {
+	type Target = u64;
+
+	fn deref(&self) -> &u64 {
+		&self.0
+	}
+}
+
+impl core::ops::Add for Slot {
+	type Output = Self;
+
+	fn add(self, other: Self) -> Self {
+		Self(self.0 + other.0)
+	}
+}
+
+impl core::ops::Add<u64> for Slot {
+	type Output = Self;
+
+	fn add(self, other: u64) -> Self {
+		Self(self.0 + other)
+	}
+}
+
+impl<T: Into<u64> + Copy> core::cmp::PartialEq<T> for Slot {
+	fn eq(&self, eq: &T) -> bool {
+		self.0 == (*eq).into()
+	}
+}
+
+impl<T: Into<u64> + Copy> core::cmp::PartialOrd<T> for Slot {
+	fn partial_cmp(&self, other: &T) -> Option<core::cmp::Ordering> {
+		self.0.partial_cmp(&(*other).into())
+	}
+}
+
+impl Slot {
+	/// Create a new slot by calculating it from the given timestamp and slot duration.
+	pub const fn from_timestamp(timestamp: Timestamp, slot_duration: SlotDuration) -> Self {
+		Slot(timestamp.as_millis() / slot_duration.as_millis())
+	}
+
+	/// Saturating addition.
+	pub fn saturating_add<T: Into<u64>>(self, rhs: T) -> Self {
+		Self(self.0.saturating_add(rhs.into()))
+	}
+
+	/// Saturating subtraction.
+	pub fn saturating_sub<T: Into<u64>>(self, rhs: T) -> Self {
+		Self(self.0.saturating_sub(rhs.into()))
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for Slot {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.0)
+	}
+}
+
+impl From<u64> for Slot {
+	fn from(slot: u64) -> Slot {
+		Slot(slot)
+	}
+}
+
+impl From<Slot> for u64 {
+	fn from(slot: Slot) -> u64 {
+		slot.0
+	}
+}
+
+/// A slot duration defined in milliseconds.
+#[derive(Clone, Copy, Debug, Encode, Decode, Hash, PartialOrd, Ord, PartialEq, Eq, TypeInfo)]
+pub struct SlotDuration(u64);
+
+impl SlotDuration {
+	/// Initialize from the given milliseconds.
+	pub const fn from_millis(millis: u64) -> Self {
+		Self(millis)
+	}
+}
+
+impl SlotDuration {
+	/// Returns `self` as a `u64` representing the duration in milliseconds.
+	pub const fn as_millis(&self) -> u64 {
+		self.0
+	}
+}
+
+#[cfg(feature = "std")]
+impl SlotDuration {
+	/// Returns `self` as [`sp_std::time::Duration`].
+	pub const fn as_duration(&self) -> sp_std::time::Duration {
+		sp_std::time::Duration::from_millis(self.0)
+	}
+}
+
+/// Represents an equivocation proof. An equivocation happens when a validator
+/// produces more than one block on the same slot. The proof of equivocation
+/// are the given distinct headers that were signed by the validator and which
+/// include the slot number.
+#[derive(Clone, Debug, Decode, Encode, PartialEq, TypeInfo, Eq)]
+pub struct EquivocationProof<Header, Id> {
+	/// Returns the authority id of the equivocator.
+	pub offender: Id,
+	/// The slot at which the equivocation happened.
+	pub slot: Slot,
+	/// The first header involved in the equivocation.
+	pub first_header: Header,
+	/// The second header involved in the equivocation.
+	pub second_header: Header,
+}
diff --git a/substrate/primitives/core/Cargo.toml b/substrate/primitives/core/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..85952b355464d87dd52cc1997a088569f8230a92
--- /dev/null
+++ b/substrate/primitives/core/Cargo.toml
@@ -0,0 +1,160 @@
+[package]
+name = "sp-core"
+version = "21.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Shareable Substrate types."
+documentation = "https://docs.rs/sp-core"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+arrayvec = { version = "0.7.2", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive","max-encoded-len"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+serde = { version = "1.0.163", optional = true,  default-features = false, features = ["derive", "alloc"] }
+bounded-collections = { version = "0.1.8", default-features = false }
+primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "scale-info"] }
+impl-serde = { version = "0.4.0", default-features = false, optional = true }
+hash-db = { version = "0.16.0", default-features = false }
+hash256-std-hasher = { version = "0.15.2", default-features = false }
+bs58 = { version = "0.4.0", default-features = false, optional = true }
+rand = { version = "0.8.5", features = ["small_rng"],  optional = true }
+substrate-bip39 = { version = "0.4.4", optional = true }
+tiny-bip39 = { version = "1.0.0", optional = true }
+regex = { version = "1.6.0", optional = true }
+zeroize = { version = "1.4.3", default-features = false }
+secrecy = { version = "0.8.0", default-features = false }
+lazy_static = { version = "1.4.0", default-features = false, optional = true }
+parking_lot = { version = "0.12.1", optional = true }
+ss58-registry = { version = "1.34.0", default-features = false }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-debug-derive = { version = "8.0.0", default-features = false, path = "../debug-derive" }
+sp-storage = { version = "13.0.0", default-features = false, path = "../storage" }
+sp-externalities = { version = "0.19.0", optional = true, path = "../externalities" }
+futures = { version = "0.3.21", optional = true }
+dyn-clonable = { version = "0.9.0", optional = true }
+thiserror = { version = "1.0.30", optional = true }
+tracing = { version = "0.1.29", optional = true }
+bitflags = "1.3"
+paste = "1.0.7"
+
+# full crypto
+array-bytes = { version = "6.1", optional = true }
+ed25519-zebra = { version = "3.1.0", default-features = false, optional = true }
+blake2 = { version = "0.10.4", default-features = false, optional = true }
+libsecp256k1 = { version = "0.7", default-features = false, features = ["static-context"], optional = true }
+schnorrkel = { version = "0.9.1", features = ["preaudit_deprecated", "u64_backend"], default-features = false }
+merlin = { version = "2.0", default-features = false }
+secp256k1 = { version = "0.24.0", default-features = false, features = ["recovery", "alloc"], optional = true }
+sp-core-hashing = { version = "9.0.0", path = "./hashing", default-features = false, optional = true }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../runtime-interface" }
+
+# bls crypto
+w3f-bls = { version = "0.1.3", default-features = false, optional = true}
+# bandersnatch crypto
+bandersnatch_vrfs = { git = "https://github.com/w3f/ring-vrf", rev = "c86ebd4", default-features = false, optional = true }
+
+[dev-dependencies]
+criterion = "0.4.0"
+serde_json = "1.0"
+sp-core-hashing-proc-macro = { version = "9.0.0", path = "./hashing/proc-macro" }
+
+[[bench]]
+name = "bench"
+harness = false
+
+[lib]
+bench = false
+
+[features]
+default = [ "std" ]
+std = [
+	"array-bytes",
+	"arrayvec/std",
+	"bandersnatch_vrfs/getrandom",
+	"blake2/std",
+	"bounded-collections/std",
+	"bs58/std",
+	"codec/std",
+	"dyn-clonable",
+	"ed25519-zebra/std",
+	"full_crypto",
+	"futures",
+	"futures/thread-pool",
+	"hash-db/std",
+	"hash256-std-hasher/std",
+	"impl-serde/std",
+	"lazy_static",
+	"libsecp256k1/std",
+	"log/std",
+	"merlin/std",
+	"parking_lot",
+	"primitive-types/byteorder",
+	"primitive-types/rustc-hex",
+	"primitive-types/serde",
+	"primitive-types/std",
+	"rand",
+	"regex",
+	"scale-info/std",
+	"schnorrkel/std",
+	"secp256k1/global-context",
+	"secp256k1/std",
+	"secrecy/alloc",
+	"serde/std",
+	"sp-core-hashing/std",
+	"sp-debug-derive/std",
+	"sp-externalities/std",
+	"sp-runtime-interface/std",
+	"sp-std/std",
+	"sp-storage/std",
+	"ss58-registry/std",
+	"substrate-bip39",
+	"thiserror",
+	"tiny-bip39",
+	"tracing",
+	"zeroize/alloc",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"array-bytes",
+	"blake2",
+	"bounded-collections/serde",
+	"bs58/alloc",
+	"dep:serde",
+	"impl-serde",
+	"primitive-types/serde_no_std",
+	"scale-info/serde",
+	"secrecy/alloc",
+	"sp-core-hashing",
+	"sp-storage/serde",
+]
+
+# This feature enables all crypto primitives for `no_std` builds like microcontrollers
+# or Intel SGX.
+# For the regular wasm runtime builds this should not be used.
+full_crypto = [
+	"array-bytes",
+	"blake2",
+	"ed25519-zebra",
+	"libsecp256k1",
+	"secp256k1",
+	"sp-core-hashing",
+	"sp-runtime-interface/disable_target_static_assertions",
+]
+
+# This feature adds BLS crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bls-experimental = [ "w3f-bls" ]
+
+# This feature adds Bandersnatch crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bandersnatch-experimental = [ "bandersnatch_vrfs" ]
diff --git a/substrate/primitives/core/benches/bench.rs b/substrate/primitives/core/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e91c1758c3cbb070ea455f6d1bd4b0baeb4a85aa
--- /dev/null
+++ b/substrate/primitives/core/benches/bench.rs
@@ -0,0 +1,156 @@
+// Copyright Parity Technologies (UK) Ltd.
+//
+// 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 criterion::{black_box, criterion_group, criterion_main, Bencher, BenchmarkId, Criterion};
+use sp_core::{
+	crypto::Pair as _,
+	hashing::{blake2_128, twox_128},
+};
+
+const MAX_KEY_SIZE: u32 = 32;
+
+fn get_key(key_size: u32) -> Vec<u8> {
+	use rand::{Rng, SeedableRng};
+
+	let rnd: [u8; 32] = rand::rngs::StdRng::seed_from_u64(12).gen();
+	let mut rnd = rnd.iter().cycle();
+
+	(0..key_size).map(|_| *rnd.next().unwrap()).collect()
+}
+
+fn bench_blake2_128(b: &mut Bencher, key: &Vec<u8>) {
+	b.iter(|| {
+		let _a = blake2_128(black_box(key));
+	});
+}
+
+fn bench_twox_128(b: &mut Bencher, key: &Vec<u8>) {
+	b.iter(|| {
+		let _a = twox_128(black_box(key));
+	});
+}
+
+fn bench_hash_128_fix_size(c: &mut Criterion) {
+	let mut group = c.benchmark_group("fix size hashing");
+
+	let key = get_key(MAX_KEY_SIZE);
+
+	group.bench_with_input("blake2_128", &key, bench_blake2_128);
+	group.bench_with_input("twox_128", &key, bench_twox_128);
+
+	group.finish();
+}
+
+fn bench_hash_128_dyn_size(c: &mut Criterion) {
+	let mut group = c.benchmark_group("dyn size hashing");
+
+	for i in (2..MAX_KEY_SIZE).step_by(4) {
+		let key = get_key(i);
+
+		group.bench_with_input(
+			BenchmarkId::new("blake2_128", format!("{}", i)),
+			&key,
+			bench_blake2_128,
+		);
+		group.bench_with_input(
+			BenchmarkId::new("twox_128", format!("{}", i)),
+			&key,
+			bench_twox_128,
+		);
+	}
+
+	group.finish();
+}
+
+fn bench_ed25519(c: &mut Criterion) {
+	let mut group = c.benchmark_group("ed25519");
+
+	for &msg_size in &[32, 1024, 1024 * 1024] {
+		let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
+		let key = sp_core::ed25519::Pair::generate().0;
+		group.bench_function(BenchmarkId::new("signing", format!("{}", msg_size)), |b| {
+			b.iter(|| key.sign(&msg))
+		});
+	}
+
+	for &msg_size in &[32, 1024, 1024 * 1024] {
+		let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
+		let key = sp_core::ed25519::Pair::generate().0;
+		let sig = key.sign(&msg);
+		let public = key.public();
+		group.bench_function(BenchmarkId::new("verifying", format!("{}", msg_size)), |b| {
+			b.iter(|| sp_core::ed25519::Pair::verify(&sig, &msg, &public))
+		});
+	}
+
+	group.finish();
+}
+
+fn bench_sr25519(c: &mut Criterion) {
+	let mut group = c.benchmark_group("sr25519");
+
+	for &msg_size in &[32, 1024, 1024 * 1024] {
+		let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
+		let key = sp_core::sr25519::Pair::generate().0;
+		group.bench_function(BenchmarkId::new("signing", format!("{}", msg_size)), |b| {
+			b.iter(|| key.sign(&msg))
+		});
+	}
+
+	for &msg_size in &[32, 1024, 1024 * 1024] {
+		let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
+		let key = sp_core::sr25519::Pair::generate().0;
+		let sig = key.sign(&msg);
+		let public = key.public();
+		group.bench_function(BenchmarkId::new("verifying", format!("{}", msg_size)), |b| {
+			b.iter(|| sp_core::sr25519::Pair::verify(&sig, &msg, &public))
+		});
+	}
+
+	group.finish();
+}
+
+fn bench_ecdsa(c: &mut Criterion) {
+	let mut group = c.benchmark_group("ecdsa");
+
+	for &msg_size in &[32, 1024, 1024 * 1024] {
+		let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
+		let key = sp_core::ecdsa::Pair::generate().0;
+		group.bench_function(BenchmarkId::new("signing", format!("{}", msg_size)), |b| {
+			b.iter(|| key.sign(&msg))
+		});
+	}
+
+	for &msg_size in &[32, 1024, 1024 * 1024] {
+		let msg = (0..msg_size).map(|_| rand::random::<u8>()).collect::<Vec<_>>();
+		let key = sp_core::ecdsa::Pair::generate().0;
+		let sig = key.sign(&msg);
+		let public = key.public();
+		group.bench_function(BenchmarkId::new("verifying", format!("{}", msg_size)), |b| {
+			b.iter(|| sp_core::ecdsa::Pair::verify(&sig, &msg, &public))
+		});
+	}
+
+	group.finish();
+}
+
+criterion_group!(
+	benches,
+	bench_hash_128_fix_size,
+	bench_hash_128_dyn_size,
+	bench_ed25519,
+	bench_sr25519,
+	bench_ecdsa,
+);
+criterion_main!(benches);
diff --git a/substrate/primitives/core/hashing/Cargo.toml b/substrate/primitives/core/hashing/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a4ddb6363f774d643b124ec6846c4761c6c1792d
--- /dev/null
+++ b/substrate/primitives/core/hashing/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "sp-core-hashing"
+version = "9.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Primitive core crate hashing implementation."
+documentation = "https://docs.rs/sp-core-hashing"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+blake2b_simd = { version = "1.0.1", default-features = false }
+byteorder = { version = "1.3.2", default-features = false }
+digest = { version = "0.10.3", default-features = false }
+sha2 = { version = "0.10.7", default-features = false }
+sha3 = { version = "0.10.0", default-features = false }
+twox-hash = { version = "1.6.3", default-features = false, features = ["digest_0_10"] }
+
+[features]
+default = [ "std" ]
+std = [
+	"blake2b_simd/std",
+	"byteorder/std",
+	"digest/std",
+	"sha2/std",
+	"sha3/std",
+	"twox-hash/std",
+]
diff --git a/substrate/primitives/core/hashing/proc-macro/Cargo.toml b/substrate/primitives/core/hashing/proc-macro/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..35bb78249d110f806f78588b30426e8ae69b0273
--- /dev/null
+++ b/substrate/primitives/core/hashing/proc-macro/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "sp-core-hashing-proc-macro"
+version = "9.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "This crate provides procedural macros for calculating static hash."
+documentation = "https://docs.rs/sp-core-hashing-proc-macro"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full", "parsing"] }
+sp-core-hashing = { version = "9.0.0", default-features = false, path = "../" }
diff --git a/substrate/primitives/core/hashing/proc-macro/src/impls.rs b/substrate/primitives/core/hashing/proc-macro/src/impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..714852ae3594ab273aba8bd5c272b3eb4d5c087d
--- /dev/null
+++ b/substrate/primitives/core/hashing/proc-macro/src/impls.rs
@@ -0,0 +1,124 @@
+// 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 quote::quote;
+use syn::parse::{Parse, ParseStream};
+
+use proc_macro::TokenStream;
+
+pub(super) struct InputBytes(pub Vec<u8>);
+
+pub(super) struct MultipleInputBytes(pub Vec<Vec<u8>>);
+
+impl MultipleInputBytes {
+	pub(super) fn concatenated(mut self) -> Vec<u8> {
+		if self.0.is_empty() {
+			Vec::new()
+		} else {
+			let mut result = core::mem::take(&mut self.0[0]);
+			for other in self.0[1..].iter_mut() {
+				result.append(other);
+			}
+			result
+		}
+	}
+}
+
+impl Parse for InputBytes {
+	fn parse(input: ParseStream) -> syn::Result<Self> {
+		match syn::ExprArray::parse(input) {
+			Ok(array) => {
+				let mut bytes = Vec::<u8>::new();
+				for expr in array.elems.iter() {
+					match expr {
+						syn::Expr::Lit(lit) => match &lit.lit {
+							syn::Lit::Int(b) => bytes.push(b.base10_parse()?),
+							syn::Lit::Byte(b) => bytes.push(b.value()),
+							_ =>
+								return Err(syn::Error::new(
+									input.span(),
+									"Expected array of u8 elements.".to_string(),
+								)),
+						},
+						_ =>
+							return Err(syn::Error::new(
+								input.span(),
+								"Expected array of u8 elements.".to_string(),
+							)),
+					}
+				}
+				return Ok(InputBytes(bytes))
+			},
+			Err(_e) => (),
+		}
+		// use rust names as a vec of their utf8 bytecode.
+		match syn::Ident::parse(input) {
+			Ok(ident) => return Ok(InputBytes(ident.to_string().as_bytes().to_vec())),
+			Err(_e) => (),
+		}
+		Ok(InputBytes(syn::LitByteStr::parse(input)?.value()))
+	}
+}
+
+impl Parse for MultipleInputBytes {
+	fn parse(input: ParseStream) -> syn::Result<Self> {
+		let elts =
+			syn::punctuated::Punctuated::<InputBytes, syn::token::Comma>::parse_terminated(input)?;
+		Ok(MultipleInputBytes(elts.into_iter().map(|elt| elt.0).collect()))
+	}
+}
+
+pub(super) fn twox_64(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::twox_64(bytes.as_slice()))
+}
+
+pub(super) fn twox_128(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::twox_128(bytes.as_slice()))
+}
+
+pub(super) fn blake2b_512(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::blake2_512(bytes.as_slice()))
+}
+
+pub(super) fn blake2b_256(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::blake2_256(bytes.as_slice()))
+}
+
+pub(super) fn blake2b_64(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::blake2_64(bytes.as_slice()))
+}
+
+pub(super) fn keccak_256(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::keccak_256(bytes.as_slice()))
+}
+
+pub(super) fn keccak_512(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::keccak_512(bytes.as_slice()))
+}
+
+pub(super) fn sha2_256(bytes: Vec<u8>) -> TokenStream {
+	bytes_to_array(sp_core_hashing::sha2_256(bytes.as_slice()))
+}
+
+fn bytes_to_array(bytes: impl IntoIterator<Item = u8>) -> TokenStream {
+	let bytes = bytes.into_iter();
+
+	quote!(
+		[ #( #bytes ),* ]
+	)
+	.into()
+}
diff --git a/substrate/primitives/core/hashing/proc-macro/src/lib.rs b/substrate/primitives/core/hashing/proc-macro/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..69668cadb4e26276377064d1921b3ec86ef76329
--- /dev/null
+++ b/substrate/primitives/core/hashing/proc-macro/src/lib.rs
@@ -0,0 +1,129 @@
+// 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.
+
+//! Macros to calculate constant hash bytes result.
+//!
+//! Macros from this crate does apply a specific hash function on input.
+//! Input can be literal byte array as `b"content"` or array of bytes
+//! as `[1, 2, 3]`.
+//! Rust identifier can also be use, in this case we use their utf8 string
+//! byte representation, for instance if the ident is `MyStruct`, then
+//! `b"MyStruct"` will be hashed.
+//! If multiple arguments comma separated are passed, they are concatenated
+//! then hashed.
+//!
+//! Examples:
+//!
+//! ```rust
+//! assert_eq!(
+//! 	sp_core_hashing_proc_macro::blake2b_256!(b"test"),
+//! 	sp_core_hashing::blake2_256(b"test"),
+//! );
+//! assert_eq!(
+//! 	sp_core_hashing_proc_macro::blake2b_256!([1u8]),
+//! 	sp_core_hashing::blake2_256(&[1u8]),
+//! );
+//! assert_eq!(
+//! 	sp_core_hashing_proc_macro::blake2b_256!([1, 2, 3]),
+//! 	sp_core_hashing::blake2_256(&[1, 2, 3]),
+//! );
+//! assert_eq!(
+//! 	sp_core_hashing_proc_macro::blake2b_256!(identifier),
+//! 	sp_core_hashing::blake2_256(b"identifier"),
+//! );
+//! assert_eq!(
+//! 	sp_core_hashing_proc_macro::blake2b_256!(identifier, b"/string"),
+//! 	sp_core_hashing::blake2_256(b"identifier/string"),
+//! );
+//! ```
+
+mod impls;
+
+use impls::MultipleInputBytes;
+use proc_macro::TokenStream;
+
+/// Process a Blake2 64-bit hash of bytes parameter outputs a `[u8; 8]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn blake2b_64(input: TokenStream) -> TokenStream {
+	impls::blake2b_64(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a Blake2 256-bit hash of bytes parameter, outputs a `[u8; 32]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn blake2b_256(input: TokenStream) -> TokenStream {
+	impls::blake2b_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a Blake2 512-bit hash of bytes parameter, outputs a `[u8; 64]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn blake2b_512(input: TokenStream) -> TokenStream {
+	impls::blake2b_512(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a XX 64-bit hash on its bytes parameter, outputs a `[u8; 8]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn twox_64(input: TokenStream) -> TokenStream {
+	impls::twox_64(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a XX 128-bit hash on its bytes parameter, outputs a `[u8; 16]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn twox_128(input: TokenStream) -> TokenStream {
+	impls::twox_128(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a keccak 256-bit hash on its bytes parameter, outputs a `[u8; 32]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn keccak_256(input: TokenStream) -> TokenStream {
+	impls::keccak_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a keccak 512-bit hash on its bytes parameter, outputs a `[u8; 64]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn keccak_512(input: TokenStream) -> TokenStream {
+	impls::keccak_512(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
+
+/// Apply a sha2 256-bit hash on its bytes parameter, outputs a `[u8; 32]`.
+/// Multiple inputs are concatenated before hashing.
+/// Input can be identifier (name of identifier as bytes is used), byte string or
+/// array of bytes.
+#[proc_macro]
+pub fn sha2_256(input: TokenStream) -> TokenStream {
+	impls::sha2_256(syn::parse_macro_input!(input as MultipleInputBytes).concatenated())
+}
diff --git a/substrate/primitives/core/hashing/src/lib.rs b/substrate/primitives/core/hashing/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..33d777f85b014b5bdf997ea1f8e689467970b87d
--- /dev/null
+++ b/substrate/primitives/core/hashing/src/lib.rs
@@ -0,0 +1,123 @@
+// 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.
+
+//! Hashing Functions.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use core::hash::Hasher;
+
+use byteorder::{ByteOrder, LittleEndian};
+use digest::Digest;
+
+#[inline(always)]
+fn blake2<const N: usize>(data: &[u8]) -> [u8; N] {
+	blake2b_simd::Params::new()
+		.hash_length(N)
+		.hash(data)
+		.as_bytes()
+		.try_into()
+		.expect("slice is always the necessary length")
+}
+
+/// Do a Blake2 512-bit hash and place result in `dest`.
+pub fn blake2_512_into(data: &[u8], dest: &mut [u8; 64]) {
+	*dest = blake2(data);
+}
+
+/// Do a Blake2 512-bit hash and return result.
+pub fn blake2_512(data: &[u8]) -> [u8; 64] {
+	blake2(data)
+}
+
+/// Do a Blake2 256-bit hash and return result.
+pub fn blake2_256(data: &[u8]) -> [u8; 32] {
+	blake2(data)
+}
+
+/// Do a Blake2 128-bit hash and return result.
+pub fn blake2_128(data: &[u8]) -> [u8; 16] {
+	blake2(data)
+}
+
+/// Do a Blake2 64-bit hash and return result.
+pub fn blake2_64(data: &[u8]) -> [u8; 8] {
+	blake2(data)
+}
+
+/// Do a XX 64-bit hash and place result in `dest`.
+pub fn twox_64_into(data: &[u8], dest: &mut [u8; 8]) {
+	let r0 = twox_hash::XxHash::with_seed(0).chain_update(data).finish();
+	LittleEndian::write_u64(&mut dest[0..8], r0);
+}
+
+/// Do a XX 64-bit hash and return result.
+pub fn twox_64(data: &[u8]) -> [u8; 8] {
+	let mut r: [u8; 8] = [0; 8];
+	twox_64_into(data, &mut r);
+	r
+}
+
+/// Do a XX 128-bit hash and place result in `dest`.
+pub fn twox_128_into(data: &[u8], dest: &mut [u8; 16]) {
+	let r0 = twox_hash::XxHash::with_seed(0).chain_update(data).finish();
+	let r1 = twox_hash::XxHash::with_seed(1).chain_update(data).finish();
+	LittleEndian::write_u64(&mut dest[0..8], r0);
+	LittleEndian::write_u64(&mut dest[8..16], r1);
+}
+
+/// Do a XX 128-bit hash and return result.
+pub fn twox_128(data: &[u8]) -> [u8; 16] {
+	let mut r: [u8; 16] = [0; 16];
+	twox_128_into(data, &mut r);
+	r
+}
+
+/// Do a XX 256-bit hash and place result in `dest`.
+pub fn twox_256_into(data: &[u8], dest: &mut [u8; 32]) {
+	let r0 = twox_hash::XxHash::with_seed(0).chain_update(data).finish();
+	let r1 = twox_hash::XxHash::with_seed(1).chain_update(data).finish();
+	let r2 = twox_hash::XxHash::with_seed(2).chain_update(data).finish();
+	let r3 = twox_hash::XxHash::with_seed(3).chain_update(data).finish();
+	LittleEndian::write_u64(&mut dest[0..8], r0);
+	LittleEndian::write_u64(&mut dest[8..16], r1);
+	LittleEndian::write_u64(&mut dest[16..24], r2);
+	LittleEndian::write_u64(&mut dest[24..32], r3);
+}
+
+/// Do a XX 256-bit hash and return result.
+pub fn twox_256(data: &[u8]) -> [u8; 32] {
+	let mut r: [u8; 32] = [0; 32];
+	twox_256_into(data, &mut r);
+	r
+}
+
+/// Do a keccak 256-bit hash and return result.
+pub fn keccak_256(data: &[u8]) -> [u8; 32] {
+	sha3::Keccak256::digest(data).into()
+}
+
+/// Do a keccak 512-bit hash and return result.
+pub fn keccak_512(data: &[u8]) -> [u8; 64] {
+	sha3::Keccak512::digest(data).into()
+}
+
+/// Do a sha2 256-bit hash and return result.
+pub fn sha2_256(data: &[u8]) -> [u8; 32] {
+	sha2::Sha256::digest(data).into()
+}
diff --git a/substrate/primitives/core/src/bandersnatch.rs b/substrate/primitives/core/src/bandersnatch.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3ba7f41058e96eda10c13cf847c9137a5dcba38
--- /dev/null
+++ b/substrate/primitives/core/src/bandersnatch.rs
@@ -0,0 +1,1042 @@
+// 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.
+
+//! VRFs backed by [Bandersnatch](https://neuromancer.sk/std/bls/Bandersnatch),
+//! an elliptic curve built over BLS12-381 scalar field.
+//!
+//! The primitive can operate both as a traditional VRF or as an anonymized ring VRF.
+
+#[cfg(feature = "std")]
+use crate::crypto::Ss58Codec;
+use crate::crypto::{
+	ByteArray, CryptoType, CryptoTypeId, Derive, Public as TraitPublic, UncheckedFrom, VrfPublic,
+};
+#[cfg(feature = "full_crypto")]
+use crate::crypto::{DeriveError, DeriveJunction, Pair as TraitPair, SecretStringError, VrfSecret};
+
+use bandersnatch_vrfs::CanonicalSerialize;
+#[cfg(feature = "full_crypto")]
+use bandersnatch_vrfs::SecretKey;
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+
+use sp_runtime_interface::pass_by::PassByInner;
+use sp_std::{boxed::Box, vec::Vec};
+
+/// Identifier used to match public keys against bandersnatch-vrf keys.
+pub const CRYPTO_ID: CryptoTypeId = CryptoTypeId(*b"band");
+
+/// Context used to produce a plain signature without any VRF input/output.
+#[cfg(feature = "full_crypto")]
+pub const SIGNING_CTX: &[u8] = b"SigningContext";
+
+// Max ring domain size.
+const RING_DOMAIN_SIZE: usize = 1024;
+
+#[cfg(feature = "full_crypto")]
+const SEED_SERIALIZED_LEN: usize = 32;
+
+// Short-Weierstrass form serialized sizes.
+const PUBLIC_SERIALIZED_LEN: usize = 33;
+const SIGNATURE_SERIALIZED_LEN: usize = 65;
+const PREOUT_SERIALIZED_LEN: usize = 33;
+const PEDERSEN_SIGNATURE_SERIALIZED_LEN: usize = 163;
+const RING_PROOF_SERIALIZED_LEN: usize = 592;
+
+// Max size of serialized ring-vrf context params.
+//
+// This size is dependent on the ring domain size and the actual value
+// is equal to the SCALE encoded size of the `KZG` backend.
+//
+// Some values:
+//  ring_size → ~serialized_size
+//   512        →  74 KB
+//  1024        → 147 KB
+//  2048        → 295 KB
+// NOTE: This is quite big but looks like there is an upcoming fix
+// in the backend.
+const RING_CONTEXT_SERIALIZED_LEN: usize = 147752;
+
+/// Bandersnatch public key.
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(
+	Clone,
+	Copy,
+	PartialEq,
+	Eq,
+	PartialOrd,
+	Ord,
+	Encode,
+	Decode,
+	PassByInner,
+	MaxEncodedLen,
+	TypeInfo,
+)]
+pub struct Public(pub [u8; PUBLIC_SERIALIZED_LEN]);
+
+impl UncheckedFrom<[u8; PUBLIC_SERIALIZED_LEN]> for Public {
+	fn unchecked_from(raw: [u8; PUBLIC_SERIALIZED_LEN]) -> Self {
+		Public(raw)
+	}
+}
+
+impl AsRef<[u8; PUBLIC_SERIALIZED_LEN]> for Public {
+	fn as_ref(&self) -> &[u8; PUBLIC_SERIALIZED_LEN] {
+		&self.0
+	}
+}
+
+impl AsRef<[u8]> for Public {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Public {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl TryFrom<&[u8]> for Public {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() != PUBLIC_SERIALIZED_LEN {
+			return Err(())
+		}
+		let mut r = [0u8; PUBLIC_SERIALIZED_LEN];
+		r.copy_from_slice(data);
+		Ok(Self::unchecked_from(r))
+	}
+}
+
+impl ByteArray for Public {
+	const LEN: usize = PUBLIC_SERIALIZED_LEN;
+}
+
+impl TraitPublic for Public {}
+
+impl CryptoType for Public {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+impl Derive for Public {}
+
+impl sp_std::fmt::Debug for Public {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		let s = self.to_ss58check();
+		write!(f, "{} ({}...)", crate::hexdisplay::HexDisplay::from(&self.as_ref()), &s[0..8])
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+/// Bandersnatch signature.
+///
+/// The signature is created via the [`VrfSecret::vrf_sign`] using [`SIGNING_CTX`] as `label`.
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, PassByInner, MaxEncodedLen, TypeInfo)]
+pub struct Signature([u8; SIGNATURE_SERIALIZED_LEN]);
+
+impl UncheckedFrom<[u8; SIGNATURE_SERIALIZED_LEN]> for Signature {
+	fn unchecked_from(raw: [u8; SIGNATURE_SERIALIZED_LEN]) -> Self {
+		Signature(raw)
+	}
+}
+
+impl AsRef<[u8]> for Signature {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Signature {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl TryFrom<&[u8]> for Signature {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() != SIGNATURE_SERIALIZED_LEN {
+			return Err(())
+		}
+		let mut r = [0u8; SIGNATURE_SERIALIZED_LEN];
+		r.copy_from_slice(data);
+		Ok(Self::unchecked_from(r))
+	}
+}
+
+impl ByteArray for Signature {
+	const LEN: usize = SIGNATURE_SERIALIZED_LEN;
+}
+
+impl CryptoType for Signature {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+impl sp_std::fmt::Debug for Signature {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "{}", crate::hexdisplay::HexDisplay::from(&self.0))
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+/// The raw secret seed, which can be used to reconstruct the secret [`Pair`].
+#[cfg(feature = "full_crypto")]
+type Seed = [u8; SEED_SERIALIZED_LEN];
+
+/// Bandersnatch secret key.
+#[cfg(feature = "full_crypto")]
+#[derive(Clone)]
+pub struct Pair {
+	secret: SecretKey,
+	seed: Seed,
+}
+
+#[cfg(feature = "full_crypto")]
+impl Pair {
+	/// Get the key seed.
+	pub fn seed(&self) -> Seed {
+		self.seed
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl TraitPair for Pair {
+	type Seed = Seed;
+	type Public = Public;
+	type Signature = Signature;
+
+	/// Make a new key pair from secret seed material.
+	///
+	/// The slice must be 64 bytes long or it will return an error.
+	fn from_seed_slice(seed_slice: &[u8]) -> Result<Pair, SecretStringError> {
+		if seed_slice.len() != SEED_SERIALIZED_LEN {
+			return Err(SecretStringError::InvalidSeedLength)
+		}
+		let mut seed = [0; SEED_SERIALIZED_LEN];
+		seed.copy_from_slice(seed_slice);
+		let secret = SecretKey::from_seed(&seed);
+		Ok(Pair { secret, seed })
+	}
+
+	/// Derive a child key from a series of given (hard) junctions.
+	///
+	/// Soft junctions are not supported.
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(
+		&self,
+		path: Iter,
+		_seed: Option<Seed>,
+	) -> Result<(Pair, Option<Seed>), DeriveError> {
+		let derive_hard = |seed, cc| -> Seed {
+			("bandersnatch-vrf-HDKD", seed, cc).using_encoded(sp_core_hashing::blake2_256)
+		};
+
+		let mut seed = self.seed();
+		for p in path {
+			if let DeriveJunction::Hard(cc) = p {
+				seed = derive_hard(seed, cc);
+			} else {
+				return Err(DeriveError::SoftKeyInPath)
+			}
+		}
+		Ok((Self::from_seed(&seed), Some(seed)))
+	}
+
+	/// Get the public key.
+	fn public(&self) -> Public {
+		let public = self.secret.to_public();
+		let mut raw = [0; PUBLIC_SERIALIZED_LEN];
+		public
+			.serialize_compressed(raw.as_mut_slice())
+			.expect("key buffer length is good; qed");
+		Public::unchecked_from(raw)
+	}
+
+	/// Sign raw data.
+	fn sign(&self, data: &[u8]) -> Signature {
+		let data = vrf::VrfSignData::new_unchecked(SIGNING_CTX, &[data], None);
+		self.vrf_sign(&data).signature
+	}
+
+	/// Verify a signature on a message.
+	///
+	/// Returns `true` if the signature is good.
+	fn verify<M: AsRef<[u8]>>(signature: &Signature, data: M, public: &Public) -> bool {
+		let data = vrf::VrfSignData::new_unchecked(SIGNING_CTX, &[data.as_ref()], None);
+		let signature =
+			vrf::VrfSignature { signature: *signature, vrf_outputs: vrf::VrfIosVec::default() };
+		public.vrf_verify(&data, &signature)
+	}
+
+	/// Return a vector filled with seed raw data.
+	fn to_raw_vec(&self) -> Vec<u8> {
+		self.seed().to_vec()
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl CryptoType for Pair {
+	type Pair = Pair;
+}
+
+/// Bandersnatch VRF types and operations.
+pub mod vrf {
+	use super::*;
+	use crate::{bounded::BoundedVec, crypto::VrfCrypto, ConstU32};
+	use bandersnatch_vrfs::{
+		CanonicalDeserialize, CanonicalSerialize, IntoVrfInput, Message, PublicKey,
+		ThinVrfSignature, Transcript,
+	};
+
+	/// Max number of inputs/outputs which can be handled by the VRF signing procedures.
+	/// The number is quite arbitrary and fullfils the current usage of the primitive.
+	/// If required it can be extended in the future.
+	pub const MAX_VRF_IOS: u32 = 3;
+
+	/// Bounded vector used for VRF inputs and outputs.
+	///
+	/// Can contain at most [`MAX_VRF_IOS`] elements.
+	pub type VrfIosVec<T> = BoundedVec<T, ConstU32<MAX_VRF_IOS>>;
+
+	/// VRF input to construct a [`VrfOutput`] instance and embeddable within [`VrfSignData`].
+	#[derive(Clone, Debug)]
+	pub struct VrfInput(pub(super) bandersnatch_vrfs::VrfInput);
+
+	impl VrfInput {
+		/// Construct a new VRF input.
+		pub fn new(domain: impl AsRef<[u8]>, data: impl AsRef<[u8]>) -> Self {
+			let msg = Message { domain: domain.as_ref(), message: data.as_ref() };
+			VrfInput(msg.into_vrf_input())
+		}
+	}
+
+	/// VRF (pre)output derived from [`VrfInput`] using a [`VrfSecret`].
+	///
+	/// This is used to produce an arbitrary number of verifiable *random* bytes.
+	#[derive(Clone, Debug, PartialEq, Eq)]
+	pub struct VrfOutput(pub(super) bandersnatch_vrfs::VrfPreOut);
+
+	impl Encode for VrfOutput {
+		fn encode(&self) -> Vec<u8> {
+			let mut bytes = [0; PREOUT_SERIALIZED_LEN];
+			self.0
+				.serialize_compressed(bytes.as_mut_slice())
+				.expect("preout serialization can't fail");
+			bytes.encode()
+		}
+	}
+
+	impl Decode for VrfOutput {
+		fn decode<R: codec::Input>(i: &mut R) -> Result<Self, codec::Error> {
+			let buf = <[u8; PREOUT_SERIALIZED_LEN]>::decode(i)?;
+			let preout = bandersnatch_vrfs::VrfPreOut::deserialize_compressed(buf.as_slice())
+				.map_err(|_| "vrf-preout decode error: bad preout")?;
+			Ok(VrfOutput(preout))
+		}
+	}
+
+	impl MaxEncodedLen for VrfOutput {
+		fn max_encoded_len() -> usize {
+			<[u8; PREOUT_SERIALIZED_LEN]>::max_encoded_len()
+		}
+	}
+
+	impl TypeInfo for VrfOutput {
+		type Identity = [u8; PREOUT_SERIALIZED_LEN];
+
+		fn type_info() -> scale_info::Type {
+			Self::Identity::type_info()
+		}
+	}
+
+	/// A *Fiat-Shamir* transcript and a sequence of [`VrfInput`]s ready to be signed.
+	///
+	/// The `transcript` will be used as messages for the *Fiat-Shamir*
+	/// transform part of the scheme. This data keeps the signature secure
+	/// but doesn't contribute to the actual VRF output. If unsure just give
+	/// it a unique label depending on the actual usage of the signing data.
+	///
+	/// The `vrf_inputs` is a sequence of [`VrfInput`]s to be signed and which
+	/// are used to construct the [`VrfOutput`]s in the signature.
+	#[derive(Clone)]
+	pub struct VrfSignData {
+		/// VRF inputs to be signed.
+		pub vrf_inputs: VrfIosVec<VrfInput>,
+		/// Associated Fiat-Shamir transcript.
+		pub transcript: Transcript,
+	}
+
+	impl VrfSignData {
+		/// Construct a new data to be signed.
+		///
+		/// The `transcript_data` is used to construct the *Fiat-Shamir* `Transcript`.
+		/// Fails if the `vrf_inputs` yields more elements than [`MAX_VRF_IOS`]
+		///
+		/// Refer to the [`VrfSignData`] for more details about the usage of
+		/// `transcript_data` and `vrf_inputs`
+		pub fn new(
+			label: &'static [u8],
+			transcript_data: impl IntoIterator<Item = impl AsRef<[u8]>>,
+			vrf_inputs: impl IntoIterator<Item = VrfInput>,
+		) -> Result<Self, ()> {
+			let vrf_inputs: Vec<VrfInput> = vrf_inputs.into_iter().collect();
+			if vrf_inputs.len() > MAX_VRF_IOS as usize {
+				return Err(())
+			}
+			Ok(Self::new_unchecked(label, transcript_data, vrf_inputs))
+		}
+
+		/// Construct a new data to be signed.
+		///
+		/// The `transcript_data` is used to construct the *Fiat-Shamir* `Transcript`.
+		/// At most the first [`MAX_VRF_IOS`] elements of `vrf_inputs` are used.
+		///
+		/// Refer to the [`VrfSignData`] for more details about the usage of
+		/// `transcript_data` and `vrf_inputs`
+		pub fn new_unchecked(
+			label: &'static [u8],
+			transcript_data: impl IntoIterator<Item = impl AsRef<[u8]>>,
+			vrf_inputs: impl IntoIterator<Item = VrfInput>,
+		) -> Self {
+			let vrf_inputs: Vec<VrfInput> = vrf_inputs.into_iter().collect();
+			let vrf_inputs = VrfIosVec::truncate_from(vrf_inputs);
+			let mut transcript = Transcript::new_labeled(label);
+			transcript_data
+				.into_iter()
+				.for_each(|data| transcript.append_slice(data.as_ref()));
+			VrfSignData { transcript, vrf_inputs }
+		}
+
+		/// Append a raw message to the transcript.
+		pub fn push_transcript_data(&mut self, data: &[u8]) {
+			self.transcript.append_slice(data);
+		}
+
+		/// Append a [`VrfInput`] to the vrf inputs to be signed.
+		///
+		/// On failure, gives back the [`VrfInput`] parameter.
+		pub fn push_vrf_input(&mut self, vrf_input: VrfInput) -> Result<(), VrfInput> {
+			self.vrf_inputs.try_push(vrf_input)
+		}
+
+		/// Create challenge from the transcript contained within the signing data.
+		pub fn challenge<const N: usize>(&self) -> [u8; N] {
+			let mut output = [0; N];
+			let mut transcript = self.transcript.clone();
+			let mut reader = transcript.challenge(b"Prehashed for bandersnatch");
+			reader.read_bytes(&mut output);
+			output
+		}
+	}
+
+	/// VRF signature.
+	#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub struct VrfSignature {
+		/// VRF (pre)outputs.
+		pub vrf_outputs: VrfIosVec<VrfOutput>,
+		/// VRF signature.
+		pub signature: Signature,
+	}
+
+	#[cfg(feature = "full_crypto")]
+	impl VrfCrypto for Pair {
+		type VrfInput = VrfInput;
+		type VrfOutput = VrfOutput;
+		type VrfSignData = VrfSignData;
+		type VrfSignature = VrfSignature;
+	}
+
+	#[cfg(feature = "full_crypto")]
+	impl VrfSecret for Pair {
+		fn vrf_sign(&self, data: &Self::VrfSignData) -> Self::VrfSignature {
+			const _: () = assert!(MAX_VRF_IOS == 3, "`MAX_VRF_IOS` expected to be 3");
+			// Workaround to overcome backend signature generic over the number of IOs.
+			match data.vrf_inputs.len() {
+				0 => self.vrf_sign_gen::<0>(data),
+				1 => self.vrf_sign_gen::<1>(data),
+				2 => self.vrf_sign_gen::<2>(data),
+				3 => self.vrf_sign_gen::<3>(data),
+				_ => unreachable!(),
+			}
+		}
+
+		fn vrf_output(&self, input: &Self::VrfInput) -> Self::VrfOutput {
+			let output = self.secret.0.vrf_preout(&input.0);
+			VrfOutput(output)
+		}
+	}
+
+	impl VrfCrypto for Public {
+		type VrfInput = VrfInput;
+		type VrfOutput = VrfOutput;
+		type VrfSignData = VrfSignData;
+		type VrfSignature = VrfSignature;
+	}
+
+	impl VrfPublic for Public {
+		fn vrf_verify(&self, data: &Self::VrfSignData, signature: &Self::VrfSignature) -> bool {
+			const _: () = assert!(MAX_VRF_IOS == 3, "`MAX_VRF_IOS` expected to be 3");
+			let preouts_len = signature.vrf_outputs.len();
+			if preouts_len != data.vrf_inputs.len() {
+				return false
+			}
+			// Workaround to overcome backend signature generic over the number of IOs.
+			match preouts_len {
+				0 => self.vrf_verify_gen::<0>(data, signature),
+				1 => self.vrf_verify_gen::<1>(data, signature),
+				2 => self.vrf_verify_gen::<2>(data, signature),
+				3 => self.vrf_verify_gen::<3>(data, signature),
+				_ => unreachable!(),
+			}
+		}
+	}
+
+	#[cfg(feature = "full_crypto")]
+	impl Pair {
+		fn vrf_sign_gen<const N: usize>(&self, data: &VrfSignData) -> VrfSignature {
+			let ios: Vec<_> = data
+				.vrf_inputs
+				.iter()
+				.map(|i| self.secret.clone().0.vrf_inout(i.0.clone()))
+				.collect();
+
+			let signature: ThinVrfSignature<N> =
+				self.secret.sign_thin_vrf(data.transcript.clone(), ios.as_slice());
+
+			let mut sign_bytes = [0; SIGNATURE_SERIALIZED_LEN];
+			signature
+				.signature
+				.serialize_compressed(sign_bytes.as_mut_slice())
+				.expect("serialization can't fail");
+
+			let outputs: Vec<_> = signature.preoutputs.into_iter().map(VrfOutput).collect();
+			let outputs = VrfIosVec::truncate_from(outputs);
+			VrfSignature { signature: Signature(sign_bytes), vrf_outputs: outputs }
+		}
+
+		/// Generate an arbitrary number of bytes from the given `context` and VRF `input`.
+		pub fn make_bytes<const N: usize>(
+			&self,
+			context: &'static [u8],
+			input: &VrfInput,
+		) -> [u8; N] {
+			let transcript = Transcript::new_labeled(context);
+			let inout = self.secret.clone().0.vrf_inout(input.0.clone());
+			inout.vrf_output_bytes(transcript)
+		}
+	}
+
+	impl Public {
+		fn vrf_verify_gen<const N: usize>(
+			&self,
+			data: &VrfSignData,
+			signature: &VrfSignature,
+		) -> bool {
+			let Ok(public) = PublicKey::deserialize_compressed(self.as_slice()) else {
+				return false
+			};
+
+			let Ok(preouts) = signature
+				.vrf_outputs
+				.iter()
+				.map(|o| o.0.clone())
+				.collect::<arrayvec::ArrayVec<bandersnatch_vrfs::VrfPreOut, N>>()
+				.into_inner()
+			else {
+				return false
+			};
+
+			// Deserialize only the proof, the rest has already been deserialized
+			// This is another hack used because backend signature type is generic over
+			// the number of ios.
+			let Ok(signature) =
+				ThinVrfSignature::<0>::deserialize_compressed(signature.signature.as_ref())
+					.map(|s| s.signature)
+			else {
+				return false
+			};
+			let signature = ThinVrfSignature { signature, preoutputs: preouts };
+
+			let inputs = data.vrf_inputs.iter().map(|i| i.0.clone());
+
+			signature.verify_thin_vrf(data.transcript.clone(), inputs, &public).is_ok()
+		}
+	}
+
+	impl VrfOutput {
+		/// Generate an arbitrary number of bytes from the given `context` and VRF `input`.
+		pub fn make_bytes<const N: usize>(
+			&self,
+			context: &'static [u8],
+			input: &VrfInput,
+		) -> [u8; N] {
+			let transcript = Transcript::new_labeled(context);
+			let inout =
+				bandersnatch_vrfs::VrfInOut { input: input.0.clone(), preoutput: self.0.clone() };
+			inout.vrf_output_bytes(transcript)
+		}
+	}
+}
+
+/// Bandersnatch Ring-VRF types and operations.
+pub mod ring_vrf {
+	use super::{vrf::*, *};
+	pub use bandersnatch_vrfs::ring::{RingProof, RingProver, RingVerifier, KZG};
+	use bandersnatch_vrfs::{CanonicalDeserialize, PedersenVrfSignature, PublicKey};
+
+	/// Context used to produce ring signatures.
+	#[derive(Clone)]
+	pub struct RingContext(KZG);
+
+	impl RingContext {
+		/// Build an dummy instance used for testing purposes.
+		pub fn new_testing() -> Self {
+			Self(KZG::testing_kzg_setup([0; 32], RING_DOMAIN_SIZE as u32))
+		}
+
+		/// Get the keyset max size.
+		pub fn max_keyset_size(&self) -> usize {
+			self.0.max_keyset_size()
+		}
+
+		/// Get ring prover for the key at index `public_idx` in the `public_keys` set.
+		pub fn prover(&self, public_keys: &[Public], public_idx: usize) -> Option<RingProver> {
+			let mut pks = Vec::with_capacity(public_keys.len());
+			for public_key in public_keys {
+				let pk = PublicKey::deserialize_compressed(public_key.as_slice()).ok()?;
+				pks.push(pk.0 .0.into());
+			}
+
+			let prover_key = self.0.prover_key(pks);
+			let ring_prover = self.0.init_ring_prover(prover_key, public_idx);
+			Some(ring_prover)
+		}
+
+		/// Get ring verifier for the `public_keys` set.
+		pub fn verifier(&self, public_keys: &[Public]) -> Option<RingVerifier> {
+			let mut pks = Vec::with_capacity(public_keys.len());
+			for public_key in public_keys {
+				let pk = PublicKey::deserialize_compressed(public_key.as_slice()).ok()?;
+				pks.push(pk.0 .0.into());
+			}
+
+			let verifier_key = self.0.verifier_key(pks);
+			let ring_verifier = self.0.init_ring_verifier(verifier_key);
+			Some(ring_verifier)
+		}
+	}
+
+	impl Encode for RingContext {
+		fn encode(&self) -> Vec<u8> {
+			let mut buf = Box::new([0; RING_CONTEXT_SERIALIZED_LEN]);
+			self.0
+				.serialize_compressed(buf.as_mut_slice())
+				.expect("preout serialization can't fail");
+			buf.encode()
+		}
+	}
+
+	impl Decode for RingContext {
+		fn decode<R: codec::Input>(i: &mut R) -> Result<Self, codec::Error> {
+			let buf = <Box<[u8; RING_CONTEXT_SERIALIZED_LEN]>>::decode(i)?;
+			let kzg =
+				KZG::deserialize_compressed(buf.as_slice()).map_err(|_| "KZG decode error")?;
+			Ok(RingContext(kzg))
+		}
+	}
+
+	impl MaxEncodedLen for RingContext {
+		fn max_encoded_len() -> usize {
+			<[u8; RING_CONTEXT_SERIALIZED_LEN]>::max_encoded_len()
+		}
+	}
+
+	impl TypeInfo for RingContext {
+		type Identity = [u8; RING_CONTEXT_SERIALIZED_LEN];
+
+		fn type_info() -> scale_info::Type {
+			Self::Identity::type_info()
+		}
+	}
+
+	/// Ring VRF signature.
+	#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub struct RingVrfSignature {
+		/// VRF (pre)outputs.
+		pub outputs: VrfIosVec<VrfOutput>,
+		/// Pedersen VRF signature.
+		signature: [u8; PEDERSEN_SIGNATURE_SERIALIZED_LEN],
+		/// Ring proof.
+		ring_proof: [u8; RING_PROOF_SERIALIZED_LEN],
+	}
+
+	#[cfg(feature = "full_crypto")]
+	impl Pair {
+		/// Produce a ring-vrf signature.
+		///
+		/// The ring signature is verifiable if the public key corresponding to the
+		/// signing [`Pair`] is part of the ring from which the [`RingProver`] has
+		/// been constructed. If not, the produced signature is just useless.
+		pub fn ring_vrf_sign(&self, data: &VrfSignData, prover: &RingProver) -> RingVrfSignature {
+			const _: () = assert!(MAX_VRF_IOS == 3, "`MAX_VRF_IOS` expected to be 3");
+			// Workaround to overcome backend signature generic over the number of IOs.
+			match data.vrf_inputs.len() {
+				0 => self.ring_vrf_sign_gen::<0>(data, prover),
+				1 => self.ring_vrf_sign_gen::<1>(data, prover),
+				2 => self.ring_vrf_sign_gen::<2>(data, prover),
+				3 => self.ring_vrf_sign_gen::<3>(data, prover),
+				_ => unreachable!(),
+			}
+		}
+
+		fn ring_vrf_sign_gen<const N: usize>(
+			&self,
+			data: &VrfSignData,
+			prover: &RingProver,
+		) -> RingVrfSignature {
+			let ios: Vec<_> = data
+				.vrf_inputs
+				.iter()
+				.map(|i| self.secret.clone().0.vrf_inout(i.0.clone()))
+				.collect();
+
+			let ring_signature: bandersnatch_vrfs::RingVrfSignature<N> =
+				self.secret.sign_ring_vrf(data.transcript.clone(), ios.as_slice(), prover);
+
+			let outputs: Vec<_> = ring_signature.preoutputs.into_iter().map(VrfOutput).collect();
+			let outputs = VrfIosVec::truncate_from(outputs);
+
+			let mut signature = [0; PEDERSEN_SIGNATURE_SERIALIZED_LEN];
+			ring_signature
+				.signature
+				.serialize_compressed(signature.as_mut_slice())
+				.expect("ped-signature serialization can't fail");
+
+			let mut ring_proof = [0; RING_PROOF_SERIALIZED_LEN];
+			ring_signature
+				.ring_proof
+				.serialize_compressed(ring_proof.as_mut_slice())
+				.expect("ring-proof serialization can't fail");
+
+			RingVrfSignature { outputs, signature, ring_proof }
+		}
+	}
+
+	impl RingVrfSignature {
+		/// Verify a ring-vrf signature.
+		///
+		/// The signature is verifiable if it has been produced by a member of the ring
+		/// from which the [`RingVerifier`] has been constructed.
+		pub fn verify(&self, data: &VrfSignData, verifier: &RingVerifier) -> bool {
+			const _: () = assert!(MAX_VRF_IOS == 3, "`MAX_VRF_IOS` expected to be 3");
+			let preouts_len = self.outputs.len();
+			if preouts_len != data.vrf_inputs.len() {
+				return false
+			}
+			// Workaround to overcome backend signature generic over the number of IOs.
+			match preouts_len {
+				0 => self.verify_gen::<0>(data, verifier),
+				1 => self.verify_gen::<1>(data, verifier),
+				2 => self.verify_gen::<2>(data, verifier),
+				3 => self.verify_gen::<3>(data, verifier),
+				_ => unreachable!(),
+			}
+		}
+
+		fn verify_gen<const N: usize>(&self, data: &VrfSignData, verifier: &RingVerifier) -> bool {
+			let Ok(preoutputs) = self
+				.outputs
+				.iter()
+				.map(|o| o.0.clone())
+				.collect::<arrayvec::ArrayVec<bandersnatch_vrfs::VrfPreOut, N>>()
+				.into_inner()
+			else {
+				return false
+			};
+
+			let Ok(signature) =
+				PedersenVrfSignature::deserialize_compressed(self.signature.as_slice())
+			else {
+				return false
+			};
+
+			let Ok(ring_proof) = RingProof::deserialize_compressed(self.ring_proof.as_slice())
+			else {
+				return false
+			};
+
+			let ring_signature =
+				bandersnatch_vrfs::RingVrfSignature { signature, preoutputs, ring_proof };
+
+			let inputs = data.vrf_inputs.iter().map(|i| i.0.clone());
+
+			ring_signature
+				.verify_ring_vrf(data.transcript.clone(), inputs, verifier)
+				.is_ok()
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{ring_vrf::*, vrf::*, *};
+	use crate::crypto::{VrfPublic, VrfSecret, DEV_PHRASE};
+	const DEV_SEED: &[u8; SEED_SERIALIZED_LEN] = &[0xcb; SEED_SERIALIZED_LEN];
+
+	#[allow(unused)]
+	fn b2h(bytes: &[u8]) -> String {
+		array_bytes::bytes2hex("", bytes)
+	}
+
+	fn h2b(hex: &str) -> Vec<u8> {
+		array_bytes::hex2bytes_unchecked(hex)
+	}
+
+	#[test]
+	fn assumptions_sanity_check() {
+		// Backend
+		let ring_ctx = RingContext::new_testing();
+		let pair = SecretKey::from_seed(DEV_SEED);
+		let public = pair.to_public();
+
+		assert_eq!(public.0.size_of_serialized(), PUBLIC_SERIALIZED_LEN);
+		assert_eq!(ring_ctx.max_keyset_size(), RING_DOMAIN_SIZE - 257);
+
+		// Wrapper
+		let inputs: Vec<_> = (0..MAX_VRF_IOS - 1).map(|_| VrfInput::new(b"", &[])).collect();
+		let mut sign_data = VrfSignData::new(b"", &[b""], inputs).unwrap();
+		let res = sign_data.push_vrf_input(VrfInput::new(b"", b""));
+		assert!(res.is_ok());
+		let res = sign_data.push_vrf_input(VrfInput::new(b"", b""));
+		assert!(res.is_err());
+		let inputs: Vec<_> = (0..MAX_VRF_IOS + 1).map(|_| VrfInput::new(b"", b"")).collect();
+		let res = VrfSignData::new(b"mydata", &[b"tdata"], inputs);
+		assert!(res.is_err());
+	}
+
+	#[test]
+	fn derive_works() {
+		let pair = Pair::from_string(&format!("{}//Alice//Hard", DEV_PHRASE), None).unwrap();
+		let known = h2b("2b340c18b94dc1916979cb83daf3ed4ac106742ddc06afc42cf26be3b18a523f80");
+		assert_eq!(pair.public().as_ref(), known);
+
+		// Soft derivation not supported
+		let res = Pair::from_string(&format!("{}//Alice/Soft", DEV_PHRASE), None);
+		assert!(res.is_err());
+	}
+
+	#[test]
+	fn sign_verify() {
+		let pair = Pair::from_seed(DEV_SEED);
+		let public = pair.public();
+		let msg = b"hello";
+
+		let signature = pair.sign(msg);
+		assert!(Pair::verify(&signature, msg, &public));
+	}
+
+	#[test]
+	fn vrf_sign_verify() {
+		let pair = Pair::from_seed(DEV_SEED);
+		let public = pair.public();
+
+		let i1 = VrfInput::new(b"dom1", b"foo");
+		let i2 = VrfInput::new(b"dom2", b"bar");
+		let i3 = VrfInput::new(b"dom3", b"baz");
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"tdata"], [i1, i2, i3]);
+
+		let signature = pair.vrf_sign(&data);
+
+		assert!(public.vrf_verify(&data, &signature));
+	}
+
+	#[test]
+	fn vrf_sign_verify_bad_inputs() {
+		let pair = Pair::from_seed(DEV_SEED);
+		let public = pair.public();
+
+		let i1 = VrfInput::new(b"dom1", b"foo");
+		let i2 = VrfInput::new(b"dom2", b"bar");
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"aaaa"], [i1.clone(), i2.clone()]);
+		let signature = pair.vrf_sign(&data);
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"bbb"], [i1, i2.clone()]);
+		assert!(!public.vrf_verify(&data, &signature));
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"aaa"], [i2]);
+		assert!(!public.vrf_verify(&data, &signature));
+	}
+
+	#[test]
+	fn vrf_make_bytes_matches() {
+		let pair = Pair::from_seed(DEV_SEED);
+
+		let i1 = VrfInput::new(b"dom1", b"foo");
+		let i2 = VrfInput::new(b"dom2", b"bar");
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"tdata"], [i1.clone(), i2.clone()]);
+		let signature = pair.vrf_sign(&data);
+
+		let o10 = pair.make_bytes::<32>(b"ctx1", &i1);
+		let o11 = signature.vrf_outputs[0].make_bytes::<32>(b"ctx1", &i1);
+		assert_eq!(o10, o11);
+
+		let o20 = pair.make_bytes::<48>(b"ctx2", &i2);
+		let o21 = signature.vrf_outputs[1].make_bytes::<48>(b"ctx2", &i2);
+		assert_eq!(o20, o21);
+	}
+
+	#[test]
+	fn encode_decode_vrf_signature() {
+		// Transcript data is hashed together and signed.
+		// It doesn't contribute to serialized length.
+		let pair = Pair::from_seed(DEV_SEED);
+
+		let i1 = VrfInput::new(b"dom1", b"foo");
+		let i2 = VrfInput::new(b"dom2", b"bar");
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"tdata"], [i1.clone(), i2.clone()]);
+		let expected = pair.vrf_sign(&data);
+
+		let bytes = expected.encode();
+
+		let expected_len =
+			data.vrf_inputs.len() * PREOUT_SERIALIZED_LEN + SIGNATURE_SERIALIZED_LEN + 1;
+		assert_eq!(bytes.len(), expected_len);
+
+		let decoded = VrfSignature::decode(&mut bytes.as_slice()).unwrap();
+		assert_eq!(expected, decoded);
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"tdata"], []);
+		let expected = pair.vrf_sign(&data);
+
+		let bytes = expected.encode();
+
+		let decoded = VrfSignature::decode(&mut bytes.as_slice()).unwrap();
+		assert_eq!(expected, decoded);
+	}
+
+	#[test]
+	fn ring_vrf_sign_verify() {
+		let ring_ctx = RingContext::new_testing();
+
+		let mut pks: Vec<_> = (0..16).map(|i| Pair::from_seed(&[i as u8; 32]).public()).collect();
+		assert!(pks.len() <= ring_ctx.max_keyset_size());
+
+		let pair = Pair::from_seed(DEV_SEED);
+
+		// Just pick one index to patch with the actual public key
+		let prover_idx = 3;
+		pks[prover_idx] = pair.public();
+
+		let i1 = VrfInput::new(b"dom1", b"foo");
+		let i2 = VrfInput::new(b"dom2", b"bar");
+		let i3 = VrfInput::new(b"dom3", b"baz");
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"tdata"], [i1, i2, i3]);
+
+		let prover = ring_ctx.prover(&pks, prover_idx).unwrap();
+		let signature = pair.ring_vrf_sign(&data, &prover);
+
+		let verifier = ring_ctx.verifier(&pks).unwrap();
+		assert!(signature.verify(&data, &verifier));
+	}
+
+	#[test]
+	fn ring_vrf_sign_verify_with_out_of_ring_key() {
+		let ring_ctx = RingContext::new_testing();
+
+		let pks: Vec<_> = (0..16).map(|i| Pair::from_seed(&[i as u8; 32]).public()).collect();
+		let pair = Pair::from_seed(DEV_SEED);
+
+		// Just pick one index to patch with the actual public key
+		let i1 = VrfInput::new(b"dom1", b"foo");
+		let data = VrfSignData::new_unchecked(b"mydata", Some(b"tdata"), Some(i1));
+
+		// pair.public != pks[0]
+		let prover = ring_ctx.prover(&pks, 0).unwrap();
+		let signature = pair.ring_vrf_sign(&data, &prover);
+
+		let verifier = ring_ctx.verifier(&pks).unwrap();
+		assert!(!signature.verify(&data, &verifier));
+	}
+
+	#[test]
+	fn encode_decode_ring_vrf_signature() {
+		let ring_ctx = RingContext::new_testing();
+
+		let mut pks: Vec<_> = (0..16).map(|i| Pair::from_seed(&[i as u8; 32]).public()).collect();
+		assert!(pks.len() <= ring_ctx.max_keyset_size());
+
+		let pair = Pair::from_seed(DEV_SEED);
+
+		// Just pick one...
+		let prover_idx = 3;
+		pks[prover_idx] = pair.public();
+
+		let i1 = VrfInput::new(b"dom1", b"foo");
+		let i2 = VrfInput::new(b"dom2", b"bar");
+		let i3 = VrfInput::new(b"dom3", b"baz");
+
+		let data = VrfSignData::new_unchecked(b"mydata", &[b"tdata"], [i1, i2, i3]);
+
+		let prover = ring_ctx.prover(&pks, prover_idx).unwrap();
+		let expected = pair.ring_vrf_sign(&data, &prover);
+
+		let bytes = expected.encode();
+
+		let expected_len = data.vrf_inputs.len() * PREOUT_SERIALIZED_LEN +
+			PEDERSEN_SIGNATURE_SERIALIZED_LEN +
+			RING_PROOF_SERIALIZED_LEN +
+			1;
+		assert_eq!(bytes.len(), expected_len);
+
+		let decoded = RingVrfSignature::decode(&mut bytes.as_slice()).unwrap();
+		assert_eq!(expected, decoded);
+	}
+
+	#[test]
+	fn encode_decode_ring_vrf_context() {
+		let ctx1 = RingContext::new_testing();
+		let enc1 = ctx1.encode();
+
+		assert_eq!(enc1.len(), RingContext::max_encoded_len());
+
+		let ctx2 = RingContext::decode(&mut enc1.as_slice()).unwrap();
+		let enc2 = ctx2.encode();
+
+		assert_eq!(enc1, enc2);
+	}
+}
diff --git a/substrate/primitives/core/src/bls.rs b/substrate/primitives/core/src/bls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..951aa1828ea5136700ca8ee91ee1693e4b6b1e0a
--- /dev/null
+++ b/substrate/primitives/core/src/bls.rs
@@ -0,0 +1,682 @@
+// 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.
+
+//! Simple BLS (Boneh–Lynn–Shacham) Signature API.
+
+#[cfg(feature = "std")]
+use crate::crypto::Ss58Codec;
+use crate::crypto::{ByteArray, CryptoType, Derive, Public as TraitPublic, UncheckedFrom};
+#[cfg(feature = "full_crypto")]
+use crate::crypto::{DeriveError, DeriveJunction, Pair as TraitPair, SecretStringError};
+
+#[cfg(feature = "full_crypto")]
+use sp_std::vec::Vec;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+#[cfg(feature = "std")]
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use w3f_bls::{DoublePublicKey, DoubleSignature, EngineBLS, SerializableToBytes, TinyBLS381};
+#[cfg(feature = "full_crypto")]
+use w3f_bls::{DoublePublicKeyScheme, Keypair, Message, SecretKey};
+
+use sp_runtime_interface::pass_by::{self, PassBy, PassByInner};
+use sp_std::{convert::TryFrom, marker::PhantomData, ops::Deref};
+
+/// BLS-377 specialized types
+pub mod bls377 {
+	use crate::crypto::CryptoTypeId;
+	use w3f_bls::TinyBLS377;
+
+	/// An identifier used to match public keys against BLS12-377 keys
+	pub const CRYPTO_ID: CryptoTypeId = CryptoTypeId(*b"bls7");
+
+	/// BLS12-377 key pair.
+	#[cfg(feature = "full_crypto")]
+	pub type Pair = super::Pair<TinyBLS377>;
+	/// BLS12-377 public key.
+	pub type Public = super::Public<TinyBLS377>;
+	/// BLS12-377 signature.
+	pub type Signature = super::Signature<TinyBLS377>;
+
+	impl super::HardJunctionId for TinyBLS377 {
+		const ID: &'static str = "BLS12377HDKD";
+	}
+}
+
+/// BLS-381 specialized types
+pub mod bls381 {
+	use crate::crypto::CryptoTypeId;
+	use w3f_bls::TinyBLS381;
+
+	/// An identifier used to match public keys against BLS12-381 keys
+	pub const CRYPTO_ID: CryptoTypeId = CryptoTypeId(*b"bls8");
+
+	/// BLS12-381 key pair.
+	#[cfg(feature = "full_crypto")]
+	pub type Pair = super::Pair<TinyBLS381>;
+	/// BLS12-381 public key.
+	pub type Public = super::Public<TinyBLS381>;
+	/// BLS12-381 signature.
+	pub type Signature = super::Signature<TinyBLS381>;
+
+	impl super::HardJunctionId for TinyBLS381 {
+		const ID: &'static str = "BLS12381HDKD";
+	}
+}
+
+trait BlsBound: EngineBLS + HardJunctionId + Send + Sync + 'static {}
+
+impl<T: EngineBLS + HardJunctionId + Send + Sync + 'static> BlsBound for T {}
+
+// Secret key serialized size
+#[cfg(feature = "full_crypto")]
+const SECRET_KEY_SERIALIZED_SIZE: usize =
+	<SecretKey<TinyBLS381> as SerializableToBytes>::SERIALIZED_BYTES_SIZE;
+
+// Public key serialized size
+const PUBLIC_KEY_SERIALIZED_SIZE: usize =
+	<DoublePublicKey<TinyBLS381> as SerializableToBytes>::SERIALIZED_BYTES_SIZE;
+
+// Signature serialized size
+const SIGNATURE_SERIALIZED_SIZE: usize =
+	<DoubleSignature<TinyBLS381> as SerializableToBytes>::SERIALIZED_BYTES_SIZE;
+
+/// A secret seed.
+///
+/// It's not called a "secret key" because ring doesn't expose the secret keys
+/// of the key pair (yeah, dumb); as such we're forced to remember the seed manually if we
+/// will need it later (such as for HDKD).
+#[cfg(feature = "full_crypto")]
+type Seed = [u8; SECRET_KEY_SERIALIZED_SIZE];
+
+/// A public key.
+#[derive(Copy, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct Public<T> {
+	inner: [u8; PUBLIC_KEY_SERIALIZED_SIZE],
+	_phantom: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for Public<T> {
+	fn clone(&self) -> Self {
+		Self { inner: self.inner, _phantom: PhantomData }
+	}
+}
+
+impl<T> PartialEq for Public<T> {
+	fn eq(&self, other: &Self) -> bool {
+		self.inner == other.inner
+	}
+}
+
+impl<T> Eq for Public<T> {}
+
+impl<T> PartialOrd for Public<T> {
+	fn partial_cmp(&self, other: &Self) -> Option<sp_std::cmp::Ordering> {
+		self.inner.partial_cmp(&other.inner)
+	}
+}
+
+impl<T> Ord for Public<T> {
+	fn cmp(&self, other: &Self) -> sp_std::cmp::Ordering {
+		self.inner.cmp(&other.inner)
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl<T> sp_std::hash::Hash for Public<T> {
+	fn hash<H: sp_std::hash::Hasher>(&self, state: &mut H) {
+		self.inner.hash(state)
+	}
+}
+
+impl<T> ByteArray for Public<T> {
+	const LEN: usize = PUBLIC_KEY_SERIALIZED_SIZE;
+}
+
+impl<T> PassByInner for Public<T> {
+	type Inner = [u8; PUBLIC_KEY_SERIALIZED_SIZE];
+
+	fn into_inner(self) -> Self::Inner {
+		self.inner
+	}
+
+	fn inner(&self) -> &Self::Inner {
+		&self.inner
+	}
+
+	fn from_inner(inner: Self::Inner) -> Self {
+		Self { inner, _phantom: PhantomData }
+	}
+}
+
+impl<T> PassBy for Public<T> {
+	type PassBy = pass_by::Inner<Self, [u8; PUBLIC_KEY_SERIALIZED_SIZE]>;
+}
+
+impl<T> AsRef<[u8; PUBLIC_KEY_SERIALIZED_SIZE]> for Public<T> {
+	fn as_ref(&self) -> &[u8; PUBLIC_KEY_SERIALIZED_SIZE] {
+		&self.inner
+	}
+}
+
+impl<T> AsRef<[u8]> for Public<T> {
+	fn as_ref(&self) -> &[u8] {
+		&self.inner[..]
+	}
+}
+
+impl<T> AsMut<[u8]> for Public<T> {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.inner[..]
+	}
+}
+
+impl<T> Deref for Public<T> {
+	type Target = [u8];
+
+	fn deref(&self) -> &Self::Target {
+		&self.inner
+	}
+}
+
+impl<T> TryFrom<&[u8]> for Public<T> {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() != PUBLIC_KEY_SERIALIZED_SIZE {
+			return Err(())
+		}
+		let mut r = [0u8; PUBLIC_KEY_SERIALIZED_SIZE];
+		r.copy_from_slice(data);
+		Ok(Self::unchecked_from(r))
+	}
+}
+
+impl<T> From<Public<T>> for [u8; PUBLIC_KEY_SERIALIZED_SIZE] {
+	fn from(x: Public<T>) -> Self {
+		x.inner
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl<T: BlsBound> From<Pair<T>> for Public<T> {
+	fn from(x: Pair<T>) -> Self {
+		x.public()
+	}
+}
+
+impl<T> UncheckedFrom<[u8; PUBLIC_KEY_SERIALIZED_SIZE]> for Public<T> {
+	fn unchecked_from(data: [u8; PUBLIC_KEY_SERIALIZED_SIZE]) -> Self {
+		Public { inner: data, _phantom: PhantomData }
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: BlsBound> std::str::FromStr for Public<T> {
+	type Err = crate::crypto::PublicError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		Self::from_ss58check(s)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: BlsBound> std::fmt::Display for Public<T> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}", self.to_ss58check())
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: BlsBound> sp_std::fmt::Debug for Public<T> {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		let s = self.to_ss58check();
+		write!(f, "{} ({}...)", crate::hexdisplay::HexDisplay::from(&self.inner), &s[0..8])
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T> sp_std::fmt::Debug for Public<T> {
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: BlsBound> Serialize for Public<T> {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&self.to_ss58check())
+	}
+}
+
+#[cfg(feature = "std")]
+impl<'de, T: BlsBound> Deserialize<'de> for Public<T> {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		Public::from_ss58check(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+impl<T: BlsBound> TraitPublic for Public<T> {}
+
+impl<T> Derive for Public<T> {}
+
+impl<T: BlsBound> CryptoType for Public<T> {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair<T>;
+}
+
+/// A generic BLS signature.
+#[derive(Copy, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+pub struct Signature<T> {
+	inner: [u8; SIGNATURE_SERIALIZED_SIZE],
+	_phantom: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for Signature<T> {
+	fn clone(&self) -> Self {
+		Self { inner: self.inner, _phantom: PhantomData }
+	}
+}
+
+impl<T> PartialEq for Signature<T> {
+	fn eq(&self, other: &Self) -> bool {
+		self.inner == other.inner
+	}
+}
+
+impl<T> Eq for Signature<T> {}
+
+#[cfg(feature = "full_crypto")]
+impl<T> sp_std::hash::Hash for Signature<T> {
+	fn hash<H: sp_std::hash::Hasher>(&self, state: &mut H) {
+		self.inner.hash(state)
+	}
+}
+
+impl<T> TryFrom<&[u8]> for Signature<T> {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() != SIGNATURE_SERIALIZED_SIZE {
+			return Err(())
+		}
+		let mut inner = [0u8; SIGNATURE_SERIALIZED_SIZE];
+		inner.copy_from_slice(data);
+		Ok(Signature::unchecked_from(inner))
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T> Serialize for Signature<T> {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&array_bytes::bytes2hex("", self))
+	}
+}
+
+#[cfg(feature = "std")]
+impl<'de, T> Deserialize<'de> for Signature<T> {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let signature_hex = array_bytes::hex2bytes(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))?;
+		Signature::try_from(signature_hex.as_ref())
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+impl<T> From<Signature<T>> for [u8; SIGNATURE_SERIALIZED_SIZE] {
+	fn from(signature: Signature<T>) -> [u8; SIGNATURE_SERIALIZED_SIZE] {
+		signature.inner
+	}
+}
+
+impl<T> AsRef<[u8; SIGNATURE_SERIALIZED_SIZE]> for Signature<T> {
+	fn as_ref(&self) -> &[u8; SIGNATURE_SERIALIZED_SIZE] {
+		&self.inner
+	}
+}
+
+impl<T> AsRef<[u8]> for Signature<T> {
+	fn as_ref(&self) -> &[u8] {
+		&self.inner[..]
+	}
+}
+
+impl<T> AsMut<[u8]> for Signature<T> {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.inner[..]
+	}
+}
+
+impl<T> sp_std::fmt::Debug for Signature<T> {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "{}", crate::hexdisplay::HexDisplay::from(&self.inner))
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl<T> UncheckedFrom<[u8; SIGNATURE_SERIALIZED_SIZE]> for Signature<T> {
+	fn unchecked_from(data: [u8; SIGNATURE_SERIALIZED_SIZE]) -> Self {
+		Signature { inner: data, _phantom: PhantomData }
+	}
+}
+
+impl<T: BlsBound> CryptoType for Signature<T> {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair<T>;
+}
+
+/// A key pair.
+#[cfg(feature = "full_crypto")]
+pub struct Pair<T: EngineBLS>(Keypair<T>);
+
+#[cfg(feature = "full_crypto")]
+impl<T: EngineBLS> Clone for Pair<T> {
+	fn clone(&self) -> Self {
+		Pair(self.0.clone())
+	}
+}
+
+trait HardJunctionId {
+	const ID: &'static str;
+}
+
+/// Derive a single hard junction.
+#[cfg(feature = "full_crypto")]
+fn derive_hard_junction<T: HardJunctionId>(secret_seed: &Seed, cc: &[u8; 32]) -> Seed {
+	(T::ID, secret_seed, cc).using_encoded(sp_core_hashing::blake2_256)
+}
+
+#[cfg(feature = "full_crypto")]
+impl<T: EngineBLS> Pair<T> {}
+
+#[cfg(feature = "full_crypto")]
+impl<T: BlsBound> TraitPair for Pair<T> {
+	type Seed = Seed;
+	type Public = Public<T>;
+	type Signature = Signature<T>;
+
+	fn from_seed_slice(seed_slice: &[u8]) -> Result<Self, SecretStringError> {
+		if seed_slice.len() != SECRET_KEY_SERIALIZED_SIZE {
+			return Err(SecretStringError::InvalidSeedLength)
+		}
+		let secret = w3f_bls::SecretKey::from_seed(seed_slice);
+		let public = secret.into_public();
+		Ok(Pair(w3f_bls::Keypair { secret, public }))
+	}
+
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(
+		&self,
+		path: Iter,
+		_seed: Option<Seed>,
+	) -> Result<(Self, Option<Seed>), DeriveError> {
+		let mut acc: [u8; SECRET_KEY_SERIALIZED_SIZE] =
+			self.0.secret.to_bytes().try_into().expect(
+				"Secret key serializer returns a vector of SECRET_KEY_SERIALIZED_SIZE size",
+			);
+		for j in path {
+			match j {
+				DeriveJunction::Soft(_cc) => return Err(DeriveError::SoftKeyInPath),
+				DeriveJunction::Hard(cc) => acc = derive_hard_junction::<T>(&acc, &cc),
+			}
+		}
+		Ok((Self::from_seed(&acc), Some(acc)))
+	}
+
+	fn public(&self) -> Self::Public {
+		let mut raw = [0u8; PUBLIC_KEY_SERIALIZED_SIZE];
+		let pk = DoublePublicKeyScheme::into_double_public_key(&self.0).to_bytes();
+		raw.copy_from_slice(pk.as_slice());
+		Self::Public::unchecked_from(raw)
+	}
+
+	fn sign(&self, message: &[u8]) -> Self::Signature {
+		let mut mutable_self = self.clone();
+		let r: [u8; SIGNATURE_SERIALIZED_SIZE] =
+			DoublePublicKeyScheme::sign(&mut mutable_self.0, &Message::new(b"", message))
+				.to_bytes()
+				.try_into()
+				.expect("Signature serializer returns vectors of SIGNATURE_SERIALIZED_SIZE size");
+		Self::Signature::unchecked_from(r)
+	}
+
+	fn verify<M: AsRef<[u8]>>(sig: &Self::Signature, message: M, pubkey: &Self::Public) -> bool {
+		let pubkey_array: [u8; PUBLIC_KEY_SERIALIZED_SIZE] =
+			match <[u8; PUBLIC_KEY_SERIALIZED_SIZE]>::try_from(pubkey.as_ref()) {
+				Ok(pk) => pk,
+				Err(_) => return false,
+			};
+		let public_key = match w3f_bls::double::DoublePublicKey::<T>::from_bytes(&pubkey_array) {
+			Ok(pk) => pk,
+			Err(_) => return false,
+		};
+
+		let sig_array = match sig.inner[..].try_into() {
+			Ok(s) => s,
+			Err(_) => return false,
+		};
+		let sig = match w3f_bls::double::DoubleSignature::from_bytes(sig_array) {
+			Ok(s) => s,
+			Err(_) => return false,
+		};
+
+		sig.verify(&Message::new(b"", message.as_ref()), &public_key)
+	}
+
+	/// Get the seed for this key.
+	fn to_raw_vec(&self) -> Vec<u8> {
+		self.0
+			.secret
+			.to_bytes()
+			.try_into()
+			.expect("Secret key serializer returns a vector of SECRET_KEY_SERIALIZED_SIZE size")
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl<T: BlsBound> CryptoType for Pair<T> {
+	type Pair = Pair<T>;
+}
+
+// Test set exercising the BLS12-377 implementation
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::crypto::DEV_PHRASE;
+	use bls377::{Pair, Signature};
+
+	#[test]
+	fn default_phrase_should_be_used() {
+		assert_eq!(
+			Pair::from_string("//Alice///password", None).unwrap().public(),
+			Pair::from_string(&format!("{}//Alice", DEV_PHRASE), Some("password"))
+				.unwrap()
+				.public(),
+		);
+	}
+
+	// Only passes if the seed = (seed mod ScalarField)
+	#[test]
+	fn seed_and_derive_should_work() {
+		let seed = array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f00",
+		);
+		let pair = Pair::from_seed(&seed);
+		// we are using hash to field so this is not going to work
+		// assert_eq!(pair.seed(), seed);
+		let path = vec![DeriveJunction::Hard([0u8; 32])];
+		let derived = pair.derive(path.into_iter(), None).ok().unwrap().0;
+		assert_eq!(
+			derived.to_raw_vec(),
+			array_bytes::hex2array_unchecked::<_, 32>(
+				"a4f2269333b3e87c577aa00c4a2cd650b3b30b2e8c286a47c251279ff3a26e0d"
+			)
+		);
+	}
+
+	#[test]
+	fn test_vector_should_work() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::unchecked_from(array_bytes::hex2array_unchecked(
+				"7a84ca8ce4c37c93c95ecee6a3c0c9a7b9c225093cf2f12dc4f69cbfb847ef9424a18f5755d5a742247d386ff2aabb806bcf160eff31293ea9616976628f77266c8a8cc1d8753be04197bd6cdd8c5c87a148f782c4c1568d599b48833fd539001e580cff64bbc71850605433fcd051f3afc3b74819786f815ffb5272030a8d03e5df61e6183f8fd8ea85f26defa83400"
+			))
+		);
+		let message = b"";
+		let signature =
+	array_bytes::hex2array_unchecked("d1e3013161991e142d8751017d4996209c2ff8a9ee160f373733eda3b4b785ba6edce9f45f87104bbe07aa6aa6eb2780aa705efb2c13d3b317d6409d159d23bdc7cdd5c2a832d1551cf49d811d49c901495e527dbd532e3a462335ce2686009104aba7bc11c5b22be78f3198d2727a0b"
+	);
+		let signature = Signature::unchecked_from(signature);
+		assert!(pair.sign(&message[..]) == signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn test_vector_by_string_should_work() {
+		let pair = Pair::from_string(
+			"0x9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+			None,
+		)
+		.unwrap();
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::unchecked_from(array_bytes::hex2array_unchecked(
+				"6dc6be608fab3c6bd894a606be86db346cc170db85c733853a371f3db54ae1b12052c0888d472760c81b537572a26f00db865e5963aef8634f9917571c51b538b564b2a9ceda938c8b930969ee3b832448e08e33a79e9ddd28af419a3ce45300f5dbc768b067781f44f3fe05a19e6b07b1c4196151ec3f8ea37e4f89a8963030d2101e931276bb9ebe1f20102239d780"
+			))
+		);
+		let message = b"";
+		let signature =
+	array_bytes::hex2array_unchecked("bbb395bbdee1a35930912034f5fde3b36df2835a0536c865501b0675776a1d5931a3bea2e66eff73b2546c6af2061a8019223e4ebbbed661b2538e0f5823f2c708eb89c406beca8fcb53a5c13dbc7c0c42e4cf2be2942bba96ea29297915a06bd2b1b979c0e2ac8fd4ec684a6b5d110c"
+	);
+		let expected_signature = Signature::unchecked_from(signature);
+		println!("signature is {:?}", pair.sign(&message[..]));
+		let signature = pair.sign(&message[..]);
+		assert!(signature == expected_signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+	#[test]
+	fn generated_pair_should_work() {
+		let (pair, _) = Pair::generate();
+		let public = pair.public();
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		assert!(Pair::verify(&signature, &message[..], &public));
+		assert!(!Pair::verify(&signature, b"Something else", &public));
+	}
+
+	#[test]
+	fn seeded_pair_should_work() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::unchecked_from(
+				array_bytes::hex2array_unchecked(
+				"754d2f2bbfa67df54d7e0e951979a18a1e0f45948857752cc2bac6bbb0b1d05e8e48bcc453920bf0c4bbd5993212480112a1fb433f04d74af0a8b700d93dc957ab3207f8d071e948f5aca1a7632c00bdf6d06be05b43e2e6216dccc8a5d55a0071cb2313cfd60b7e9114619cd17c06843b352f0b607a99122f6651df8f02e1ad3697bd208e62af047ddd7b942ba80080")
+			)
+		);
+		let message =
+	array_bytes::hex2bytes_unchecked("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000"
+	);
+		let signature = pair.sign(&message[..]);
+		println!("Correct signature: {:?}", signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+		assert!(!Pair::verify(&signature, "Other message", &public));
+	}
+
+	#[test]
+	fn generate_with_phrase_recovery_possible() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(None);
+		let (pair2, _) = Pair::from_phrase(&phrase, None).unwrap();
+
+		assert_eq!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn generate_with_password_phrase_recovery_possible() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(Some("password"));
+		let (pair2, _) = Pair::from_phrase(&phrase, Some("password")).unwrap();
+
+		assert_eq!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn password_does_something() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(Some("password"));
+		let (pair2, _) = Pair::from_phrase(&phrase, None).unwrap();
+
+		assert_ne!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn ss58check_roundtrip_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let s = public.to_ss58check();
+		println!("Correct: {}", s);
+		let cmp = Public::from_ss58check(&s).unwrap();
+		assert_eq!(cmp, public);
+	}
+
+	#[test]
+	fn signature_serialization_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		let serialized_signature = serde_json::to_string(&signature).unwrap();
+		// Signature is 112 bytes, hexify * 2, so 224  chars + 2 quote chars
+		assert_eq!(serialized_signature.len(), 226);
+		let signature = serde_json::from_str(&serialized_signature).unwrap();
+		assert!(Pair::verify(&signature, &message[..], &pair.public()));
+	}
+
+	#[test]
+	fn signature_serialization_doesnt_panic() {
+		fn deserialize_signature(text: &str) -> Result<Signature, serde_json::error::Error> {
+			serde_json::from_str(text)
+		}
+		assert!(deserialize_signature("Not valid json.").is_err());
+		assert!(deserialize_signature("\"Not an actual signature.\"").is_err());
+		// Poorly-sized
+		assert!(deserialize_signature("\"abc123\"").is_err());
+	}
+}
diff --git a/substrate/primitives/core/src/crypto.rs b/substrate/primitives/core/src/crypto.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6afe4b752a690b7b625787ca295f14e210201388
--- /dev/null
+++ b/substrate/primitives/core/src/crypto.rs
@@ -0,0 +1,1500 @@
+// 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.
+
+//! Cryptographic utilities.
+
+use crate::{ed25519, sr25519};
+#[cfg(feature = "std")]
+use bip39::{Language, Mnemonic, MnemonicType};
+use codec::{Decode, Encode, MaxEncodedLen};
+#[cfg(feature = "std")]
+use rand::{rngs::OsRng, RngCore};
+#[cfg(feature = "std")]
+use regex::Regex;
+use scale_info::TypeInfo;
+#[cfg(feature = "std")]
+pub use secrecy::{ExposeSecret, SecretString};
+use sp_runtime_interface::pass_by::PassByInner;
+#[doc(hidden)]
+pub use sp_std::ops::Deref;
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::{
+	alloc::{format, string::String},
+	vec,
+};
+use sp_std::{hash::Hash, str, vec::Vec};
+pub use ss58_registry::{from_known_address_format, Ss58AddressFormat, Ss58AddressFormatRegistry};
+/// Trait to zeroize a memory buffer.
+pub use zeroize::Zeroize;
+
+/// The root phrase for our publicly known keys.
+pub const DEV_PHRASE: &str =
+	"bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+
+/// The address of the associated root phrase for our publicly known keys.
+pub const DEV_ADDRESS: &str = "5DfhGyQdFobKM8NsWvEeAKk5EQQgYe9AydgJ7rMB6E1EqRzV";
+
+/// The length of the junction identifier. Note that this is also referred to as the
+/// `CHAIN_CODE_LENGTH` in the context of Schnorrkel.
+pub const JUNCTION_ID_LEN: usize = 32;
+
+/// Similar to `From`, except that the onus is on the part of the caller to ensure
+/// that data passed in makes sense. Basically, you're not guaranteed to get anything
+/// sensible out.
+pub trait UncheckedFrom<T> {
+	/// Convert from an instance of `T` to Self. This is not guaranteed to be
+	/// whatever counts as a valid instance of `T` and it's up to the caller to
+	/// ensure that it makes sense.
+	fn unchecked_from(t: T) -> Self;
+}
+
+/// The counterpart to `UncheckedFrom`.
+pub trait UncheckedInto<T> {
+	/// The counterpart to `unchecked_from`.
+	fn unchecked_into(self) -> T;
+}
+
+impl<S, T: UncheckedFrom<S>> UncheckedInto<T> for S {
+	fn unchecked_into(self) -> T {
+		T::unchecked_from(self)
+	}
+}
+
+/// An error with the interpretation of a secret.
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg(feature = "full_crypto")]
+pub enum SecretStringError {
+	/// The overall format was invalid (e.g. the seed phrase contained symbols).
+	#[cfg_attr(feature = "std", error("Invalid format"))]
+	InvalidFormat,
+	/// The seed phrase provided is not a valid BIP39 phrase.
+	#[cfg_attr(feature = "std", error("Invalid phrase"))]
+	InvalidPhrase,
+	/// The supplied password was invalid.
+	#[cfg_attr(feature = "std", error("Invalid password"))]
+	InvalidPassword,
+	/// The seed is invalid (bad content).
+	#[cfg_attr(feature = "std", error("Invalid seed"))]
+	InvalidSeed,
+	/// The seed has an invalid length.
+	#[cfg_attr(feature = "std", error("Invalid seed length"))]
+	InvalidSeedLength,
+	/// The derivation path was invalid (e.g. contains soft junctions when they are not supported).
+	#[cfg_attr(feature = "std", error("Invalid path"))]
+	InvalidPath,
+}
+
+/// An error when deriving a key.
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg(feature = "full_crypto")]
+pub enum DeriveError {
+	/// A soft key was found in the path (and is unsupported).
+	#[cfg_attr(feature = "std", error("Soft key in path"))]
+	SoftKeyInPath,
+}
+
+/// A since derivation junction description. It is the single parameter used when creating
+/// a new secret key from an existing secret key and, in the case of `SoftRaw` and `SoftIndex`
+/// a new public key from an existing public key.
+#[derive(Copy, Clone, Eq, PartialEq, Hash, Debug, Encode, Decode)]
+#[cfg(any(feature = "full_crypto", feature = "serde"))]
+pub enum DeriveJunction {
+	/// Soft (vanilla) derivation. Public keys have a correspondent derivation.
+	Soft([u8; JUNCTION_ID_LEN]),
+	/// Hard ("hardened") derivation. Public keys do not have a correspondent derivation.
+	Hard([u8; JUNCTION_ID_LEN]),
+}
+
+#[cfg(any(feature = "full_crypto", feature = "serde"))]
+impl DeriveJunction {
+	/// Consume self to return a soft derive junction with the same chain code.
+	pub fn soften(self) -> Self {
+		DeriveJunction::Soft(self.unwrap_inner())
+	}
+
+	/// Consume self to return a hard derive junction with the same chain code.
+	pub fn harden(self) -> Self {
+		DeriveJunction::Hard(self.unwrap_inner())
+	}
+
+	/// Create a new soft (vanilla) DeriveJunction from a given, encodable, value.
+	///
+	/// If you need a hard junction, use `hard()`.
+	pub fn soft<T: Encode>(index: T) -> Self {
+		let mut cc: [u8; JUNCTION_ID_LEN] = Default::default();
+		index.using_encoded(|data| {
+			if data.len() > JUNCTION_ID_LEN {
+				cc.copy_from_slice(&sp_core_hashing::blake2_256(data));
+			} else {
+				cc[0..data.len()].copy_from_slice(data);
+			}
+		});
+		DeriveJunction::Soft(cc)
+	}
+
+	/// Create a new hard (hardened) DeriveJunction from a given, encodable, value.
+	///
+	/// If you need a soft junction, use `soft()`.
+	pub fn hard<T: Encode>(index: T) -> Self {
+		Self::soft(index).harden()
+	}
+
+	/// Consume self to return the chain code.
+	pub fn unwrap_inner(self) -> [u8; JUNCTION_ID_LEN] {
+		match self {
+			DeriveJunction::Hard(c) | DeriveJunction::Soft(c) => c,
+		}
+	}
+
+	/// Get a reference to the inner junction id.
+	pub fn inner(&self) -> &[u8; JUNCTION_ID_LEN] {
+		match self {
+			DeriveJunction::Hard(ref c) | DeriveJunction::Soft(ref c) => c,
+		}
+	}
+
+	/// Return `true` if the junction is soft.
+	pub fn is_soft(&self) -> bool {
+		matches!(*self, DeriveJunction::Soft(_))
+	}
+
+	/// Return `true` if the junction is hard.
+	pub fn is_hard(&self) -> bool {
+		matches!(*self, DeriveJunction::Hard(_))
+	}
+}
+
+#[cfg(any(feature = "full_crypto", feature = "serde"))]
+impl<T: AsRef<str>> From<T> for DeriveJunction {
+	fn from(j: T) -> DeriveJunction {
+		let j = j.as_ref();
+		let (code, hard) =
+			if let Some(stripped) = j.strip_prefix('/') { (stripped, true) } else { (j, false) };
+
+		let res = if let Ok(n) = str::parse::<u64>(code) {
+			// number
+			DeriveJunction::soft(n)
+		} else {
+			// something else
+			DeriveJunction::soft(code)
+		};
+
+		if hard {
+			res.harden()
+		} else {
+			res
+		}
+	}
+}
+
+/// An error type for SS58 decoding.
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+#[cfg_attr(not(feature = "std"), derive(Debug))]
+#[derive(Clone, Copy, Eq, PartialEq)]
+#[allow(missing_docs)]
+#[cfg(any(feature = "full_crypto", feature = "serde"))]
+pub enum PublicError {
+	#[cfg_attr(feature = "std", error("Base 58 requirement is violated"))]
+	BadBase58,
+	#[cfg_attr(feature = "std", error("Length is bad"))]
+	BadLength,
+	#[cfg_attr(
+		feature = "std",
+		error(
+			"Unknown SS58 address format `{}`. ` \
+		`To support this address format, you need to call `set_default_ss58_version` at node start up.",
+			_0
+		)
+	)]
+	UnknownSs58AddressFormat(Ss58AddressFormat),
+	#[cfg_attr(feature = "std", error("Invalid checksum"))]
+	InvalidChecksum,
+	#[cfg_attr(feature = "std", error("Invalid SS58 prefix byte."))]
+	InvalidPrefix,
+	#[cfg_attr(feature = "std", error("Invalid SS58 format."))]
+	InvalidFormat,
+	#[cfg_attr(feature = "std", error("Invalid derivation path."))]
+	InvalidPath,
+	#[cfg_attr(feature = "std", error("Disallowed SS58 Address Format for this datatype."))]
+	FormatNotAllowed,
+}
+
+#[cfg(feature = "std")]
+impl sp_std::fmt::Debug for PublicError {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		// Just use the `Display` implementation
+		write!(f, "{}", self)
+	}
+}
+
+/// Key that can be encoded to/from SS58.
+///
+/// See <https://docs.substrate.io/v3/advanced/ss58/>
+/// for information on the codec.
+pub trait Ss58Codec: Sized + AsMut<[u8]> + AsRef<[u8]> + ByteArray {
+	/// A format filterer, can be used to ensure that `from_ss58check` family only decode for
+	/// allowed identifiers. By default just refuses the two reserved identifiers.
+	fn format_is_allowed(f: Ss58AddressFormat) -> bool {
+		!f.is_reserved()
+	}
+
+	/// Some if the string is a properly encoded SS58Check address.
+	#[cfg(feature = "serde")]
+	fn from_ss58check(s: &str) -> Result<Self, PublicError> {
+		Self::from_ss58check_with_version(s).and_then(|(r, v)| match v {
+			v if !v.is_custom() => Ok(r),
+			v if v == default_ss58_version() => Ok(r),
+			v => Err(PublicError::UnknownSs58AddressFormat(v)),
+		})
+	}
+
+	/// Some if the string is a properly encoded SS58Check address.
+	#[cfg(feature = "serde")]
+	fn from_ss58check_with_version(s: &str) -> Result<(Self, Ss58AddressFormat), PublicError> {
+		const CHECKSUM_LEN: usize = 2;
+		let body_len = Self::LEN;
+
+		let data = bs58::decode(s).into_vec().map_err(|_| PublicError::BadBase58)?;
+		if data.len() < 2 {
+			return Err(PublicError::BadLength)
+		}
+		let (prefix_len, ident) = match data[0] {
+			0..=63 => (1, data[0] as u16),
+			64..=127 => {
+				// weird bit manipulation owing to the combination of LE encoding and missing two
+				// bits from the left.
+				// d[0] d[1] are: 01aaaaaa bbcccccc
+				// they make the LE-encoded 16-bit value: aaaaaabb 00cccccc
+				// so the lower byte is formed of aaaaaabb and the higher byte is 00cccccc
+				let lower = (data[0] << 2) | (data[1] >> 6);
+				let upper = data[1] & 0b00111111;
+				(2, (lower as u16) | ((upper as u16) << 8))
+			},
+			_ => return Err(PublicError::InvalidPrefix),
+		};
+		if data.len() != prefix_len + body_len + CHECKSUM_LEN {
+			return Err(PublicError::BadLength)
+		}
+		let format = ident.into();
+		if !Self::format_is_allowed(format) {
+			return Err(PublicError::FormatNotAllowed)
+		}
+
+		let hash = ss58hash(&data[0..body_len + prefix_len]);
+		let checksum = &hash[0..CHECKSUM_LEN];
+		if data[body_len + prefix_len..body_len + prefix_len + CHECKSUM_LEN] != *checksum {
+			// Invalid checksum.
+			return Err(PublicError::InvalidChecksum)
+		}
+
+		let result = Self::from_slice(&data[prefix_len..body_len + prefix_len])
+			.map_err(|()| PublicError::BadLength)?;
+		Ok((result, format))
+	}
+
+	/// Some if the string is a properly encoded SS58Check address, optionally with
+	/// a derivation path following.
+	#[cfg(feature = "std")]
+	fn from_string(s: &str) -> Result<Self, PublicError> {
+		Self::from_string_with_version(s).and_then(|(r, v)| match v {
+			v if !v.is_custom() => Ok(r),
+			v if v == default_ss58_version() => Ok(r),
+			v => Err(PublicError::UnknownSs58AddressFormat(v)),
+		})
+	}
+
+	/// Return the ss58-check string for this key.
+	#[cfg(feature = "serde")]
+	fn to_ss58check_with_version(&self, version: Ss58AddressFormat) -> String {
+		// We mask out the upper two bits of the ident - SS58 Prefix currently only supports 14-bits
+		let ident: u16 = u16::from(version) & 0b0011_1111_1111_1111;
+		let mut v = match ident {
+			0..=63 => vec![ident as u8],
+			64..=16_383 => {
+				// upper six bits of the lower byte(!)
+				let first = ((ident & 0b0000_0000_1111_1100) as u8) >> 2;
+				// lower two bits of the lower byte in the high pos,
+				// lower bits of the upper byte in the low pos
+				let second = ((ident >> 8) as u8) | ((ident & 0b0000_0000_0000_0011) as u8) << 6;
+				vec![first | 0b01000000, second]
+			},
+			_ => unreachable!("masked out the upper two bits; qed"),
+		};
+		v.extend(self.as_ref());
+		let r = ss58hash(&v);
+		v.extend(&r[0..2]);
+		bs58::encode(v).into_string()
+	}
+
+	/// Return the ss58-check string for this key.
+	#[cfg(feature = "serde")]
+	fn to_ss58check(&self) -> String {
+		self.to_ss58check_with_version(default_ss58_version())
+	}
+
+	/// Some if the string is a properly encoded SS58Check address, optionally with
+	/// a derivation path following.
+	#[cfg(feature = "std")]
+	fn from_string_with_version(s: &str) -> Result<(Self, Ss58AddressFormat), PublicError> {
+		Self::from_ss58check_with_version(s)
+	}
+}
+
+/// Derivable key trait.
+pub trait Derive: Sized {
+	/// Derive a child key from a series of given junctions.
+	///
+	/// Will be `None` for public keys if there are any hard junctions in there.
+	#[cfg(feature = "serde")]
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(&self, _path: Iter) -> Option<Self> {
+		None
+	}
+}
+
+#[cfg(feature = "serde")]
+const PREFIX: &[u8] = b"SS58PRE";
+
+#[cfg(feature = "serde")]
+fn ss58hash(data: &[u8]) -> Vec<u8> {
+	use blake2::{Blake2b512, Digest};
+
+	let mut ctx = Blake2b512::new();
+	ctx.update(PREFIX);
+	ctx.update(data);
+	ctx.finalize().to_vec()
+}
+
+/// Default prefix number
+#[cfg(feature = "serde")]
+static DEFAULT_VERSION: core::sync::atomic::AtomicU16 = core::sync::atomic::AtomicU16::new(
+	from_known_address_format(Ss58AddressFormatRegistry::SubstrateAccount),
+);
+
+/// Returns default SS58 format used by the current active process.
+#[cfg(feature = "serde")]
+pub fn default_ss58_version() -> Ss58AddressFormat {
+	DEFAULT_VERSION.load(core::sync::atomic::Ordering::Relaxed).into()
+}
+
+/// Returns either the input address format or the default.
+#[cfg(feature = "serde")]
+pub fn unwrap_or_default_ss58_version(network: Option<Ss58AddressFormat>) -> Ss58AddressFormat {
+	network.unwrap_or_else(default_ss58_version)
+}
+
+/// Set the default SS58 "version".
+///
+/// This SS58 version/format will be used when encoding/decoding SS58 addresses.
+///
+/// If you want to support a custom SS58 prefix (that isn't yet registered in the `ss58-registry`),
+/// you are required to call this function with your desired prefix [`Ss58AddressFormat::custom`].
+/// This will enable the node to decode ss58 addresses with this prefix.
+///
+/// This SS58 version/format is also only used by the node and not by the runtime.
+#[cfg(feature = "serde")]
+pub fn set_default_ss58_version(new_default: Ss58AddressFormat) {
+	DEFAULT_VERSION.store(new_default.into(), core::sync::atomic::Ordering::Relaxed);
+}
+
+#[cfg(feature = "std")]
+lazy_static::lazy_static! {
+	static ref SS58_REGEX: Regex = Regex::new(r"^(?P<ss58>[\w\d ]+)?(?P<path>(//?[^/]+)*)$")
+		.expect("constructed from known-good static value; qed");
+	static ref SECRET_PHRASE_REGEX: Regex = Regex::new(r"^(?P<phrase>[\d\w ]+)?(?P<path>(//?[^/]+)*)(///(?P<password>.*))?$")
+		.expect("constructed from known-good static value; qed");
+	static ref JUNCTION_REGEX: Regex = Regex::new(r"/(/?[^/]+)")
+		.expect("constructed from known-good static value; qed");
+}
+
+#[cfg(feature = "std")]
+impl<T: Sized + AsMut<[u8]> + AsRef<[u8]> + Public + Derive> Ss58Codec for T {
+	fn from_string(s: &str) -> Result<Self, PublicError> {
+		let cap = SS58_REGEX.captures(s).ok_or(PublicError::InvalidFormat)?;
+		let s = cap.name("ss58").map(|r| r.as_str()).unwrap_or(DEV_ADDRESS);
+		let addr = if let Some(stripped) = s.strip_prefix("0x") {
+			let d = array_bytes::hex2bytes(stripped).map_err(|_| PublicError::InvalidFormat)?;
+			Self::from_slice(&d).map_err(|()| PublicError::BadLength)?
+		} else {
+			Self::from_ss58check(s)?
+		};
+		if cap["path"].is_empty() {
+			Ok(addr)
+		} else {
+			let path =
+				JUNCTION_REGEX.captures_iter(&cap["path"]).map(|f| DeriveJunction::from(&f[1]));
+			addr.derive(path).ok_or(PublicError::InvalidPath)
+		}
+	}
+
+	fn from_string_with_version(s: &str) -> Result<(Self, Ss58AddressFormat), PublicError> {
+		let cap = SS58_REGEX.captures(s).ok_or(PublicError::InvalidFormat)?;
+		let (addr, v) = Self::from_ss58check_with_version(
+			cap.name("ss58").map(|r| r.as_str()).unwrap_or(DEV_ADDRESS),
+		)?;
+		if cap["path"].is_empty() {
+			Ok((addr, v))
+		} else {
+			let path =
+				JUNCTION_REGEX.captures_iter(&cap["path"]).map(|f| DeriveJunction::from(&f[1]));
+			addr.derive(path).ok_or(PublicError::InvalidPath).map(|a| (a, v))
+		}
+	}
+}
+
+// Use the default implementations of the trait in serde feature.
+// The std implementation is not available because of std only crate Regex.
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+impl<T: Sized + AsMut<[u8]> + AsRef<[u8]> + Public + Derive> Ss58Codec for T {}
+
+/// Trait used for types that are really just a fixed-length array.
+pub trait ByteArray: AsRef<[u8]> + AsMut<[u8]> + for<'a> TryFrom<&'a [u8], Error = ()> {
+	/// The "length" of the values of this type, which is always the same.
+	const LEN: usize;
+
+	/// A new instance from the given slice that should be `Self::LEN` bytes long.
+	fn from_slice(data: &[u8]) -> Result<Self, ()> {
+		Self::try_from(data)
+	}
+
+	/// Return a `Vec<u8>` filled with raw data.
+	fn to_raw_vec(&self) -> Vec<u8> {
+		self.as_slice().to_vec()
+	}
+
+	/// Return a slice filled with raw data.
+	fn as_slice(&self) -> &[u8] {
+		self.as_ref()
+	}
+}
+
+/// Trait suitable for typical cryptographic key public type.
+pub trait Public: CryptoType + ByteArray + Derive + PartialEq + Eq + Clone + Send + Sync {}
+
+/// An opaque 32-byte cryptographic identifier.
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Hash))]
+pub struct AccountId32([u8; 32]);
+
+impl AccountId32 {
+	/// Create a new instance from its raw inner byte value.
+	///
+	/// Equivalent to this types `From<[u8; 32]>` implementation. For the lack of const
+	/// support in traits we have this constructor.
+	pub const fn new(inner: [u8; 32]) -> Self {
+		Self(inner)
+	}
+}
+
+impl UncheckedFrom<crate::hash::H256> for AccountId32 {
+	fn unchecked_from(h: crate::hash::H256) -> Self {
+		AccountId32(h.into())
+	}
+}
+
+impl ByteArray for AccountId32 {
+	const LEN: usize = 32;
+}
+
+#[cfg(feature = "serde")]
+impl Ss58Codec for AccountId32 {}
+
+impl AsRef<[u8]> for AccountId32 {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for AccountId32 {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl AsRef<[u8; 32]> for AccountId32 {
+	fn as_ref(&self) -> &[u8; 32] {
+		&self.0
+	}
+}
+
+impl AsMut<[u8; 32]> for AccountId32 {
+	fn as_mut(&mut self) -> &mut [u8; 32] {
+		&mut self.0
+	}
+}
+
+impl From<[u8; 32]> for AccountId32 {
+	fn from(x: [u8; 32]) -> Self {
+		Self::new(x)
+	}
+}
+
+impl<'a> TryFrom<&'a [u8]> for AccountId32 {
+	type Error = ();
+	fn try_from(x: &'a [u8]) -> Result<AccountId32, ()> {
+		if x.len() == 32 {
+			let mut data = [0; 32];
+			data.copy_from_slice(x);
+			Ok(AccountId32(data))
+		} else {
+			Err(())
+		}
+	}
+}
+
+impl From<AccountId32> for [u8; 32] {
+	fn from(x: AccountId32) -> [u8; 32] {
+		x.0
+	}
+}
+
+impl From<sr25519::Public> for AccountId32 {
+	fn from(k: sr25519::Public) -> Self {
+		k.0.into()
+	}
+}
+
+impl From<ed25519::Public> for AccountId32 {
+	fn from(k: ed25519::Public) -> Self {
+		k.0.into()
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for AccountId32 {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}", self.to_ss58check())
+	}
+}
+
+impl sp_std::fmt::Debug for AccountId32 {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		let s = self.to_ss58check();
+		write!(f, "{} ({}...)", crate::hexdisplay::HexDisplay::from(&self.0), &s[0..8])
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for AccountId32 {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: serde::Serializer,
+	{
+		serializer.serialize_str(&self.to_ss58check())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for AccountId32 {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'de>,
+	{
+		Ss58Codec::from_ss58check(&String::deserialize(deserializer)?)
+			.map_err(|e| serde::de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+#[cfg(feature = "std")]
+impl sp_std::str::FromStr for AccountId32 {
+	type Err = &'static str;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let hex_or_ss58_without_prefix = s.trim_start_matches("0x");
+		if hex_or_ss58_without_prefix.len() == 64 {
+			array_bytes::hex_n_into(hex_or_ss58_without_prefix).map_err(|_| "invalid hex address.")
+		} else {
+			Self::from_ss58check(s).map_err(|_| "invalid ss58 address.")
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+pub use self::dummy::*;
+
+#[cfg(feature = "std")]
+mod dummy {
+	use super::*;
+
+	/// Dummy cryptography. Doesn't do anything.
+	#[derive(Clone, Hash, Default, Eq, PartialEq)]
+	pub struct Dummy;
+
+	impl AsRef<[u8]> for Dummy {
+		fn as_ref(&self) -> &[u8] {
+			&b""[..]
+		}
+	}
+
+	impl AsMut<[u8]> for Dummy {
+		fn as_mut(&mut self) -> &mut [u8] {
+			unsafe {
+				#[allow(mutable_transmutes)]
+				sp_std::mem::transmute::<_, &'static mut [u8]>(&b""[..])
+			}
+		}
+	}
+
+	impl<'a> TryFrom<&'a [u8]> for Dummy {
+		type Error = ();
+
+		fn try_from(_: &'a [u8]) -> Result<Self, ()> {
+			Ok(Self)
+		}
+	}
+
+	impl CryptoType for Dummy {
+		type Pair = Dummy;
+	}
+
+	impl Derive for Dummy {}
+
+	impl ByteArray for Dummy {
+		const LEN: usize = 0;
+		fn from_slice(_: &[u8]) -> Result<Self, ()> {
+			Ok(Self)
+		}
+		#[cfg(feature = "std")]
+		fn to_raw_vec(&self) -> Vec<u8> {
+			vec![]
+		}
+		fn as_slice(&self) -> &[u8] {
+			b""
+		}
+	}
+	impl Public for Dummy {}
+
+	impl Pair for Dummy {
+		type Public = Dummy;
+		type Seed = Dummy;
+		type Signature = Dummy;
+
+		#[cfg(feature = "std")]
+		fn generate_with_phrase(_: Option<&str>) -> (Self, String, Self::Seed) {
+			Default::default()
+		}
+
+		#[cfg(feature = "std")]
+		fn from_phrase(_: &str, _: Option<&str>) -> Result<(Self, Self::Seed), SecretStringError> {
+			Ok(Default::default())
+		}
+
+		fn derive<Iter: Iterator<Item = DeriveJunction>>(
+			&self,
+			_: Iter,
+			_: Option<Dummy>,
+		) -> Result<(Self, Option<Dummy>), DeriveError> {
+			Ok((Self, None))
+		}
+
+		fn from_seed_slice(_: &[u8]) -> Result<Self, SecretStringError> {
+			Ok(Self)
+		}
+
+		fn sign(&self, _: &[u8]) -> Self::Signature {
+			Self
+		}
+
+		fn verify<M: AsRef<[u8]>>(_: &Self::Signature, _: M, _: &Self::Public) -> bool {
+			true
+		}
+
+		fn public(&self) -> Self::Public {
+			Self
+		}
+
+		fn to_raw_vec(&self) -> Vec<u8> {
+			vec![]
+		}
+	}
+}
+
+/// A secret uri (`SURI`) that can be used to generate a key pair.
+///
+/// The `SURI` can be parsed from a string. The string is interpreted in the following way:
+///
+/// - If `string` is a possibly `0x` prefixed 64-digit hex string, then it will be interpreted
+/// directly as a `MiniSecretKey` (aka "seed" in `subkey`).
+/// - If `string` is a valid BIP-39 key phrase of 12, 15, 18, 21 or 24 words, then the key will
+/// be derived from it. In this case:
+///   - the phrase may be followed by one or more items delimited by `/` characters.
+///   - the path may be followed by `///`, in which case everything after the `///` is treated
+/// as a password.
+/// - If `string` begins with a `/` character it is prefixed with the Substrate public `DEV_PHRASE`
+///   and interpreted as above.
+///
+/// In this case they are interpreted as HDKD junctions; purely numeric items are interpreted as
+/// integers, non-numeric items as strings. Junctions prefixed with `/` are interpreted as soft
+/// junctions, and with `//` as hard junctions.
+///
+/// There is no correspondence mapping between `SURI` strings and the keys they represent.
+/// Two different non-identical strings can actually lead to the same secret being derived.
+/// Notably, integer junction indices may be legally prefixed with arbitrary number of zeros.
+/// Similarly an empty password (ending the `SURI` with `///`) is perfectly valid and will
+/// generally be equivalent to no password at all.
+///
+/// # Example
+///
+/// Parse [`DEV_PHRASE`] secret uri with junction:
+///
+/// ```
+/// # use sp_core::crypto::{SecretUri, DeriveJunction, DEV_PHRASE, ExposeSecret};
+/// # use std::str::FromStr;
+/// let suri = SecretUri::from_str("//Alice").expect("Parse SURI");
+///
+/// assert_eq!(vec![DeriveJunction::from("Alice").harden()], suri.junctions);
+/// assert_eq!(DEV_PHRASE, suri.phrase.expose_secret());
+/// assert!(suri.password.is_none());
+/// ```
+///
+/// Parse [`DEV_PHRASE`] secret ui with junction and password:
+///
+/// ```
+/// # use sp_core::crypto::{SecretUri, DeriveJunction, DEV_PHRASE, ExposeSecret};
+/// # use std::str::FromStr;
+/// let suri = SecretUri::from_str("//Alice///SECRET_PASSWORD").expect("Parse SURI");
+///
+/// assert_eq!(vec![DeriveJunction::from("Alice").harden()], suri.junctions);
+/// assert_eq!(DEV_PHRASE, suri.phrase.expose_secret());
+/// assert_eq!("SECRET_PASSWORD", suri.password.unwrap().expose_secret());
+/// ```
+///
+/// Parse [`DEV_PHRASE`] secret ui with hex phrase and junction:
+///
+/// ```
+/// # use sp_core::crypto::{SecretUri, DeriveJunction, DEV_PHRASE, ExposeSecret};
+/// # use std::str::FromStr;
+/// let suri = SecretUri::from_str("0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a//Alice").expect("Parse SURI");
+///
+/// assert_eq!(vec![DeriveJunction::from("Alice").harden()], suri.junctions);
+/// assert_eq!("0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a", suri.phrase.expose_secret());
+/// assert!(suri.password.is_none());
+/// ```
+#[cfg(feature = "std")]
+pub struct SecretUri {
+	/// The phrase to derive the private key.
+	///
+	/// This can either be a 64-bit hex string or a BIP-39 key phrase.
+	pub phrase: SecretString,
+	/// Optional password as given as part of the uri.
+	pub password: Option<SecretString>,
+	/// The junctions as part of the uri.
+	pub junctions: Vec<DeriveJunction>,
+}
+
+#[cfg(feature = "std")]
+impl sp_std::str::FromStr for SecretUri {
+	type Err = SecretStringError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		let cap = SECRET_PHRASE_REGEX.captures(s).ok_or(SecretStringError::InvalidFormat)?;
+
+		let junctions = JUNCTION_REGEX
+			.captures_iter(&cap["path"])
+			.map(|f| DeriveJunction::from(&f[1]))
+			.collect::<Vec<_>>();
+
+		let phrase = cap.name("phrase").map(|r| r.as_str()).unwrap_or(DEV_PHRASE);
+		let password = cap.name("password");
+
+		Ok(Self {
+			phrase: SecretString::from_str(phrase).expect("Returns infallible error; qed"),
+			password: password.map(|v| {
+				SecretString::from_str(v.as_str()).expect("Returns infallible error; qed")
+			}),
+			junctions,
+		})
+	}
+}
+
+/// Trait suitable for typical cryptographic PKI key pair type.
+///
+/// For now it just specifies how to create a key from a phrase and derivation path.
+#[cfg(feature = "full_crypto")]
+pub trait Pair: CryptoType + Sized {
+	/// The type which is used to encode a public key.
+	type Public: Public + Hash;
+
+	/// The type used to (minimally) encode the data required to securely create
+	/// a new key pair.
+	type Seed: Default + AsRef<[u8]> + AsMut<[u8]> + Clone;
+
+	/// The type used to represent a signature. Can be created from a key pair and a message
+	/// and verified with the message and a public key.
+	type Signature: AsRef<[u8]>;
+
+	/// Generate new secure (random) key pair.
+	///
+	/// This is only for ephemeral keys really, since you won't have access to the secret key
+	/// for storage. If you want a persistent key pair, use `generate_with_phrase` instead.
+	#[cfg(feature = "std")]
+	fn generate() -> (Self, Self::Seed) {
+		let mut seed = Self::Seed::default();
+		OsRng.fill_bytes(seed.as_mut());
+		(Self::from_seed(&seed), seed)
+	}
+
+	/// Generate new secure (random) key pair and provide the recovery phrase.
+	///
+	/// You can recover the same key later with `from_phrase`.
+	///
+	/// This is generally slower than `generate()`, so prefer that unless you need to persist
+	/// the key from the current session.
+	#[cfg(feature = "std")]
+	fn generate_with_phrase(password: Option<&str>) -> (Self, String, Self::Seed) {
+		let mnemonic = Mnemonic::new(MnemonicType::Words12, Language::English);
+		let phrase = mnemonic.phrase();
+		let (pair, seed) = Self::from_phrase(phrase, password)
+			.expect("All phrases generated by Mnemonic are valid; qed");
+		(pair, phrase.to_owned(), seed)
+	}
+
+	/// Returns the KeyPair from the English BIP39 seed `phrase`, or an error if it's invalid.
+	#[cfg(feature = "std")]
+	fn from_phrase(
+		phrase: &str,
+		password: Option<&str>,
+	) -> Result<(Self, Self::Seed), SecretStringError> {
+		let mnemonic = Mnemonic::from_phrase(phrase, Language::English)
+			.map_err(|_| SecretStringError::InvalidPhrase)?;
+		let big_seed =
+			substrate_bip39::seed_from_entropy(mnemonic.entropy(), password.unwrap_or(""))
+				.map_err(|_| SecretStringError::InvalidSeed)?;
+		let mut seed = Self::Seed::default();
+		let seed_slice = seed.as_mut();
+		let seed_len = seed_slice.len();
+		debug_assert!(seed_len <= big_seed.len());
+		seed_slice[..seed_len].copy_from_slice(&big_seed[..seed_len]);
+		Self::from_seed_slice(seed_slice).map(|x| (x, seed))
+	}
+
+	/// Derive a child key from a series of given junctions.
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(
+		&self,
+		path: Iter,
+		seed: Option<Self::Seed>,
+	) -> Result<(Self, Option<Self::Seed>), DeriveError>;
+
+	/// Generate new key pair from the provided `seed`.
+	///
+	/// @WARNING: THIS WILL ONLY BE SECURE IF THE `seed` IS SECURE. If it can be guessed
+	/// by an attacker then they can also derive your key.
+	fn from_seed(seed: &Self::Seed) -> Self {
+		Self::from_seed_slice(seed.as_ref()).expect("seed has valid length; qed")
+	}
+
+	/// Make a new key pair from secret seed material. The slice must be the correct size or
+	/// an error will be returned.
+	///
+	/// @WARNING: THIS WILL ONLY BE SECURE IF THE `seed` IS SECURE. If it can be guessed
+	/// by an attacker then they can also derive your key.
+	fn from_seed_slice(seed: &[u8]) -> Result<Self, SecretStringError>;
+
+	/// Sign a message.
+	fn sign(&self, message: &[u8]) -> Self::Signature;
+
+	/// Verify a signature on a message. Returns true if the signature is good.
+	fn verify<M: AsRef<[u8]>>(sig: &Self::Signature, message: M, pubkey: &Self::Public) -> bool;
+
+	/// Get the public key.
+	fn public(&self) -> Self::Public;
+
+	/// Interprets the string `s` in order to generate a key Pair. Returns both the pair and an
+	/// optional seed, in the case that the pair can be expressed as a direct derivation from a seed
+	/// (some cases, such as Sr25519 derivations with path components, cannot).
+	///
+	/// This takes a helper function to do the key generation from a phrase, password and
+	/// junction iterator.
+	///
+	/// - If `s` is a possibly `0x` prefixed 64-digit hex string, then it will be interpreted
+	/// directly as a `MiniSecretKey` (aka "seed" in `subkey`).
+	/// - If `s` is a valid BIP-39 key phrase of 12, 15, 18, 21 or 24 words, then the key will
+	/// be derived from it. In this case:
+	///   - the phrase may be followed by one or more items delimited by `/` characters.
+	///   - the path may be followed by `///`, in which case everything after the `///` is treated
+	/// as a password.
+	/// - If `s` begins with a `/` character it is prefixed with the Substrate public `DEV_PHRASE`
+	///   and
+	/// interpreted as above.
+	///
+	/// In this case they are interpreted as HDKD junctions; purely numeric items are interpreted as
+	/// integers, non-numeric items as strings. Junctions prefixed with `/` are interpreted as soft
+	/// junctions, and with `//` as hard junctions.
+	///
+	/// There is no correspondence mapping between SURI strings and the keys they represent.
+	/// Two different non-identical strings can actually lead to the same secret being derived.
+	/// Notably, integer junction indices may be legally prefixed with arbitrary number of zeros.
+	/// Similarly an empty password (ending the SURI with `///`) is perfectly valid and will
+	/// generally be equivalent to no password at all.
+	#[cfg(feature = "std")]
+	fn from_string_with_seed(
+		s: &str,
+		password_override: Option<&str>,
+	) -> Result<(Self, Option<Self::Seed>), SecretStringError> {
+		use sp_std::str::FromStr;
+		let SecretUri { junctions, phrase, password } = SecretUri::from_str(s)?;
+		let password =
+			password_override.or_else(|| password.as_ref().map(|p| p.expose_secret().as_str()));
+
+		let (root, seed) = if let Some(stripped) = phrase.expose_secret().strip_prefix("0x") {
+			array_bytes::hex2bytes(stripped)
+				.ok()
+				.and_then(|seed_vec| {
+					let mut seed = Self::Seed::default();
+					if seed.as_ref().len() == seed_vec.len() {
+						seed.as_mut().copy_from_slice(&seed_vec);
+						Some((Self::from_seed(&seed), seed))
+					} else {
+						None
+					}
+				})
+				.ok_or(SecretStringError::InvalidSeed)?
+		} else {
+			Self::from_phrase(phrase.expose_secret().as_str(), password)
+				.map_err(|_| SecretStringError::InvalidPhrase)?
+		};
+		root.derive(junctions.into_iter(), Some(seed))
+			.map_err(|_| SecretStringError::InvalidPath)
+	}
+
+	/// Interprets the string `s` in order to generate a key pair.
+	///
+	/// See [`from_string_with_seed`](Pair::from_string_with_seed) for more extensive documentation.
+	#[cfg(feature = "std")]
+	fn from_string(s: &str, password_override: Option<&str>) -> Result<Self, SecretStringError> {
+		Self::from_string_with_seed(s, password_override).map(|x| x.0)
+	}
+
+	/// Return a vec filled with raw data.
+	fn to_raw_vec(&self) -> Vec<u8>;
+}
+
+/// One type is wrapped by another.
+pub trait IsWrappedBy<Outer>: From<Outer> + Into<Outer> {
+	/// Get a reference to the inner from the outer.
+	fn from_ref(outer: &Outer) -> &Self;
+	/// Get a mutable reference to the inner from the outer.
+	fn from_mut(outer: &mut Outer) -> &mut Self;
+}
+
+/// Opposite of `IsWrappedBy` - denotes a type which is a simple wrapper around another type.
+pub trait Wraps: Sized {
+	/// The inner type it is wrapping.
+	type Inner: IsWrappedBy<Self>;
+
+	/// Get a reference to the inner type that is wrapped.
+	fn as_inner_ref(&self) -> &Self::Inner {
+		Self::Inner::from_ref(self)
+	}
+}
+
+impl<T, Outer> IsWrappedBy<Outer> for T
+where
+	Outer: AsRef<Self> + AsMut<Self> + From<Self>,
+	T: From<Outer>,
+{
+	/// Get a reference to the inner from the outer.
+	fn from_ref(outer: &Outer) -> &Self {
+		outer.as_ref()
+	}
+
+	/// Get a mutable reference to the inner from the outer.
+	fn from_mut(outer: &mut Outer) -> &mut Self {
+		outer.as_mut()
+	}
+}
+
+impl<Inner, Outer, T> UncheckedFrom<T> for Outer
+where
+	Outer: Wraps<Inner = Inner>,
+	Inner: IsWrappedBy<Outer> + UncheckedFrom<T>,
+{
+	fn unchecked_from(t: T) -> Self {
+		let inner: Inner = t.unchecked_into();
+		inner.into()
+	}
+}
+
+/// Type which has a particular kind of crypto associated with it.
+pub trait CryptoType {
+	/// The pair key type of this crypto.
+	#[cfg(feature = "full_crypto")]
+	type Pair: Pair;
+}
+
+/// An identifier for a type of cryptographic key.
+///
+/// To avoid clashes with other modules when distributing your module publicly, register your
+/// `KeyTypeId` on the list here by making a PR.
+///
+/// Values whose first character is `_` are reserved for private use and won't conflict with any
+/// public modules.
+#[derive(
+	Copy,
+	Clone,
+	Default,
+	PartialEq,
+	Eq,
+	PartialOrd,
+	Ord,
+	Hash,
+	Encode,
+	Decode,
+	PassByInner,
+	crate::RuntimeDebug,
+	TypeInfo,
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct KeyTypeId(pub [u8; 4]);
+
+impl From<u32> for KeyTypeId {
+	fn from(x: u32) -> Self {
+		Self(x.to_le_bytes())
+	}
+}
+
+impl From<KeyTypeId> for u32 {
+	fn from(x: KeyTypeId) -> Self {
+		u32::from_le_bytes(x.0)
+	}
+}
+
+impl<'a> TryFrom<&'a str> for KeyTypeId {
+	type Error = ();
+
+	fn try_from(x: &'a str) -> Result<Self, ()> {
+		let b = x.as_bytes();
+		if b.len() != 4 {
+			return Err(())
+		}
+		let mut res = KeyTypeId::default();
+		res.0.copy_from_slice(&b[0..4]);
+		Ok(res)
+	}
+}
+
+/// Trait grouping types shared by a VRF signer and verifiers.
+pub trait VrfCrypto {
+	/// VRF input.
+	type VrfInput;
+	/// VRF output.
+	type VrfOutput;
+	/// VRF signing data.
+	type VrfSignData;
+	/// VRF signature.
+	type VrfSignature;
+}
+
+/// VRF Secret Key.
+pub trait VrfSecret: VrfCrypto {
+	/// Get VRF-specific output .
+	fn vrf_output(&self, data: &Self::VrfInput) -> Self::VrfOutput;
+
+	/// Sign VRF-specific data.
+	fn vrf_sign(&self, input: &Self::VrfSignData) -> Self::VrfSignature;
+}
+
+/// VRF Public Key.
+pub trait VrfPublic: VrfCrypto {
+	/// Verify input data signature.
+	fn vrf_verify(&self, data: &Self::VrfSignData, signature: &Self::VrfSignature) -> bool;
+}
+
+/// An identifier for a specific cryptographic algorithm used by a key pair
+#[derive(Debug, Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Encode, Decode)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct CryptoTypeId(pub [u8; 4]);
+
+/// Known key types; this also functions as a global registry of key types for projects wishing to
+/// avoid collisions with each other.
+///
+/// It's not universal in the sense that *all* key types need to be mentioned here, it's just a
+/// handy place to put common key types.
+pub mod key_types {
+	use super::KeyTypeId;
+
+	/// Key type for Babe module, built-in. Identified as `babe`.
+	pub const BABE: KeyTypeId = KeyTypeId(*b"babe");
+	/// Key type for Grandpa module, built-in. Identified as `gran`.
+	pub const GRANDPA: KeyTypeId = KeyTypeId(*b"gran");
+	/// Key type for controlling an account in a Substrate runtime, built-in. Identified as `acco`.
+	pub const ACCOUNT: KeyTypeId = KeyTypeId(*b"acco");
+	/// Key type for Aura module, built-in. Identified as `aura`.
+	pub const AURA: KeyTypeId = KeyTypeId(*b"aura");
+	/// Key type for BEEFY module.
+	pub const BEEFY: KeyTypeId = KeyTypeId(*b"beef");
+	/// Key type for ImOnline module, built-in. Identified as `imon`.
+	pub const IM_ONLINE: KeyTypeId = KeyTypeId(*b"imon");
+	/// Key type for AuthorityDiscovery module, built-in. Identified as `audi`.
+	pub const AUTHORITY_DISCOVERY: KeyTypeId = KeyTypeId(*b"audi");
+	/// Key type for staking, built-in. Identified as `stak`.
+	pub const STAKING: KeyTypeId = KeyTypeId(*b"stak");
+	/// A key type for signing statements
+	pub const STATEMENT: KeyTypeId = KeyTypeId(*b"stmt");
+	/// A key type ID useful for tests.
+	pub const DUMMY: KeyTypeId = KeyTypeId(*b"dumy");
+}
+
+/// Create random values of `Self` given a stream of entropy.
+pub trait FromEntropy: Sized {
+	/// Create a random value of `Self` given a stream of random bytes on `input`. May only fail if
+	/// `input` has an error.
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error>;
+}
+
+impl FromEntropy for bool {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		Ok(input.read_byte()? % 2 == 1)
+	}
+}
+
+macro_rules! impl_from_entropy {
+	($type:ty , $( $others:tt )*) => {
+		impl_from_entropy!($type);
+		impl_from_entropy!($( $others )*);
+	};
+	($type:ty) => {
+		impl FromEntropy for $type {
+			fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+				<Self as codec::Decode>::decode(input)
+			}
+		}
+	}
+}
+
+macro_rules! impl_from_entropy_base {
+	($type:ty , $( $others:tt )*) => {
+		impl_from_entropy_base!($type);
+		impl_from_entropy_base!($( $others )*);
+	};
+	($type:ty) => {
+		impl_from_entropy!($type,
+			[$type; 1], [$type; 2], [$type; 3], [$type; 4], [$type; 5], [$type; 6], [$type; 7], [$type; 8],
+			[$type; 9], [$type; 10], [$type; 11], [$type; 12], [$type; 13], [$type; 14], [$type; 15], [$type; 16],
+			[$type; 17], [$type; 18], [$type; 19], [$type; 20], [$type; 21], [$type; 22], [$type; 23], [$type; 24],
+			[$type; 25], [$type; 26], [$type; 27], [$type; 28], [$type; 29], [$type; 30], [$type; 31], [$type; 32],
+			[$type; 36], [$type; 40], [$type; 44], [$type; 48], [$type; 56], [$type; 64], [$type; 72], [$type; 80],
+			[$type; 96], [$type; 112], [$type; 128], [$type; 160], [$type; 192], [$type; 224], [$type; 256]
+		);
+	}
+}
+
+impl_from_entropy_base!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::DeriveJunction;
+
+	#[derive(Clone, Eq, PartialEq, Debug)]
+	enum TestPair {
+		Generated,
+		GeneratedWithPhrase,
+		GeneratedFromPhrase { phrase: String, password: Option<String> },
+		Standard { phrase: String, password: Option<String>, path: Vec<DeriveJunction> },
+		Seed(Vec<u8>),
+	}
+	impl Default for TestPair {
+		fn default() -> Self {
+			TestPair::Generated
+		}
+	}
+	impl CryptoType for TestPair {
+		type Pair = Self;
+	}
+
+	#[derive(Clone, PartialEq, Eq, Hash, Default)]
+	struct TestPublic;
+	impl AsRef<[u8]> for TestPublic {
+		fn as_ref(&self) -> &[u8] {
+			&[]
+		}
+	}
+	impl AsMut<[u8]> for TestPublic {
+		fn as_mut(&mut self) -> &mut [u8] {
+			&mut []
+		}
+	}
+	impl<'a> TryFrom<&'a [u8]> for TestPublic {
+		type Error = ();
+
+		fn try_from(data: &'a [u8]) -> Result<Self, ()> {
+			Self::from_slice(data)
+		}
+	}
+	impl CryptoType for TestPublic {
+		type Pair = TestPair;
+	}
+	impl Derive for TestPublic {}
+	impl ByteArray for TestPublic {
+		const LEN: usize = 0;
+		fn from_slice(bytes: &[u8]) -> Result<Self, ()> {
+			if bytes.is_empty() {
+				Ok(Self)
+			} else {
+				Err(())
+			}
+		}
+		fn as_slice(&self) -> &[u8] {
+			&[]
+		}
+		fn to_raw_vec(&self) -> Vec<u8> {
+			vec![]
+		}
+	}
+	impl Public for TestPublic {}
+	impl Pair for TestPair {
+		type Public = TestPublic;
+		type Seed = [u8; 8];
+		type Signature = [u8; 0];
+
+		fn generate() -> (Self, <Self as Pair>::Seed) {
+			(TestPair::Generated, [0u8; 8])
+		}
+
+		fn generate_with_phrase(_password: Option<&str>) -> (Self, String, <Self as Pair>::Seed) {
+			(TestPair::GeneratedWithPhrase, "".into(), [0u8; 8])
+		}
+
+		fn from_phrase(
+			phrase: &str,
+			password: Option<&str>,
+		) -> Result<(Self, <Self as Pair>::Seed), SecretStringError> {
+			Ok((
+				TestPair::GeneratedFromPhrase {
+					phrase: phrase.to_owned(),
+					password: password.map(Into::into),
+				},
+				[0u8; 8],
+			))
+		}
+
+		fn derive<Iter: Iterator<Item = DeriveJunction>>(
+			&self,
+			path_iter: Iter,
+			_: Option<[u8; 8]>,
+		) -> Result<(Self, Option<[u8; 8]>), DeriveError> {
+			Ok((
+				match self.clone() {
+					TestPair::Standard { phrase, password, path } => TestPair::Standard {
+						phrase,
+						password,
+						path: path.into_iter().chain(path_iter).collect(),
+					},
+					TestPair::GeneratedFromPhrase { phrase, password } =>
+						TestPair::Standard { phrase, password, path: path_iter.collect() },
+					x =>
+						if path_iter.count() == 0 {
+							x
+						} else {
+							return Err(DeriveError::SoftKeyInPath)
+						},
+				},
+				None,
+			))
+		}
+
+		fn sign(&self, _message: &[u8]) -> Self::Signature {
+			[]
+		}
+
+		fn verify<M: AsRef<[u8]>>(_: &Self::Signature, _: M, _: &Self::Public) -> bool {
+			true
+		}
+
+		fn public(&self) -> Self::Public {
+			TestPublic
+		}
+
+		fn from_seed_slice(seed: &[u8]) -> Result<Self, SecretStringError> {
+			Ok(TestPair::Seed(seed.to_owned()))
+		}
+
+		fn to_raw_vec(&self) -> Vec<u8> {
+			vec![]
+		}
+	}
+
+	#[test]
+	fn interpret_std_seed_should_work() {
+		assert_eq!(
+			TestPair::from_string("0x0123456789abcdef", None),
+			Ok(TestPair::Seed(array_bytes::hex2bytes_unchecked("0123456789abcdef")))
+		);
+	}
+
+	#[test]
+	fn password_override_should_work() {
+		assert_eq!(
+			TestPair::from_string("hello world///password", None),
+			TestPair::from_string("hello world", Some("password")),
+		);
+		assert_eq!(
+			TestPair::from_string("hello world///password", None),
+			TestPair::from_string("hello world///other password", Some("password")),
+		);
+	}
+
+	#[test]
+	fn interpret_std_secret_string_should_work() {
+		assert_eq!(
+			TestPair::from_string("hello world", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world/1", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::soft(1)]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world/DOT", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::soft("DOT")]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world/0123456789012345678901234567890123456789", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::soft("0123456789012345678901234567890123456789")]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world//1", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::hard(1)]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world//DOT", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::hard("DOT")]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world//0123456789012345678901234567890123456789", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::hard("0123456789012345678901234567890123456789")]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world//1/DOT", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::hard(1), DeriveJunction::soft("DOT")]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world//DOT/1", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: None,
+				path: vec![DeriveJunction::hard("DOT"), DeriveJunction::soft(1)]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world///password", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: Some("password".to_owned()),
+				path: vec![]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world//1/DOT///password", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: Some("password".to_owned()),
+				path: vec![DeriveJunction::hard(1), DeriveJunction::soft("DOT")]
+			})
+		);
+		assert_eq!(
+			TestPair::from_string("hello world/1//DOT///password", None),
+			Ok(TestPair::Standard {
+				phrase: "hello world".to_owned(),
+				password: Some("password".to_owned()),
+				path: vec![DeriveJunction::soft(1), DeriveJunction::hard("DOT")]
+			})
+		);
+	}
+
+	#[test]
+	fn accountid_32_from_str_works() {
+		use std::str::FromStr;
+		assert!(AccountId32::from_str("5G9VdMwXvzza9pS8qE8ZHJk3CheHW9uucBn9ngW4C1gmmzpv").is_ok());
+		assert!(AccountId32::from_str(
+			"5c55177d67b064bb5d189a3e1ddad9bc6646e02e64d6e308f5acbb1533ac430d"
+		)
+		.is_ok());
+		assert!(AccountId32::from_str(
+			"0x5c55177d67b064bb5d189a3e1ddad9bc6646e02e64d6e308f5acbb1533ac430d"
+		)
+		.is_ok());
+
+		assert_eq!(
+			AccountId32::from_str("99G9VdMwXvzza9pS8qE8ZHJk3CheHW9uucBn9ngW4C1gmmzpv").unwrap_err(),
+			"invalid ss58 address.",
+		);
+		assert_eq!(
+			AccountId32::from_str(
+				"gc55177d67b064bb5d189a3e1ddad9bc6646e02e64d6e308f5acbb1533ac430d"
+			)
+			.unwrap_err(),
+			"invalid hex address.",
+		);
+		assert_eq!(
+			AccountId32::from_str(
+				"0xgc55177d67b064bb5d189a3e1ddad9bc6646e02e64d6e308f5acbb1533ac430d"
+			)
+			.unwrap_err(),
+			"invalid hex address.",
+		);
+
+		// valid hex but invalid length will be treated as ss58.
+		assert_eq!(
+			AccountId32::from_str(
+				"55c55177d67b064bb5d189a3e1ddad9bc6646e02e64d6e308f5acbb1533ac430d"
+			)
+			.unwrap_err(),
+			"invalid ss58 address.",
+		);
+	}
+}
diff --git a/substrate/primitives/core/src/defer.rs b/substrate/primitives/core/src/defer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..efa9ee5cebb70997449b1b252a1ff977e68b07a5
--- /dev/null
+++ b/substrate/primitives/core/src/defer.rs
@@ -0,0 +1,147 @@
+// 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.
+
+//! Contains the [`crate::defer!`] macro for *deferring* the execution
+//! of code until the current scope is dropped.
+//! This helps with *always* executing cleanup code.
+
+/// Executes the wrapped closure on drop.
+///
+/// Should be used together with the [`crate::defer!`] macro.
+#[must_use]
+pub struct DeferGuard<F: FnOnce()>(pub Option<F>);
+
+impl<F: FnOnce()> DeferGuard<F> {
+	/// Creates a new `DeferGuard` with the given closure.
+	pub fn new(f: F) -> Self {
+		Self(Some(f))
+	}
+}
+
+impl<F: FnOnce()> Drop for DeferGuard<F> {
+	fn drop(&mut self) {
+		self.0.take().map(|f| f());
+	}
+}
+
+/// Executes the given code when the current scope is dropped.
+///
+/// Multiple calls to [`crate::defer!`] will execute the passed codes in reverse order.
+/// This also applies to panic stack unwinding.
+///
+/// # Example
+///
+/// ```rust
+/// use sp_core::defer;
+///
+/// let message = std::cell::RefCell::new("".to_string());
+/// {
+/// 	defer!(
+/// 		message.borrow_mut().push_str("world!");
+/// 	);
+/// 	defer!(
+/// 		message.borrow_mut().push_str("Hello ");
+/// 	);
+/// }
+/// assert_eq!(*message.borrow(), "Hello world!");
+/// ```
+#[macro_export]
+macro_rules! defer(
+	( $( $code:tt )* ) => {
+		let _guard = $crate::defer::DeferGuard(Some(|| { $( $code )* }));
+	};
+);
+
+#[cfg(test)]
+mod test {
+	#[test]
+	fn defer_guard_works() {
+		let mut called = false;
+		{
+			defer!(
+				called = true;
+			);
+		}
+		assert!(called, "DeferGuard should have executed the closure");
+	}
+
+	#[test]
+	/// `defer` executes the code in reverse order of being called.
+	fn defer_guard_order_works() {
+		let called = std::cell::RefCell::new(1);
+
+		defer!(
+			assert_eq!(*called.borrow(), 3);
+		);
+		defer!(
+			assert_eq!(*called.borrow(), 2);
+			*called.borrow_mut() = 3;
+		);
+		defer!({
+			assert_eq!(*called.borrow(), 1);
+			*called.borrow_mut() = 2;
+		});
+	}
+
+	#[test]
+	#[allow(unused_braces)]
+	#[allow(clippy::unnecessary_operation)]
+	fn defer_guard_syntax_works() {
+		let called = std::cell::RefCell::new(0);
+		{
+			defer!(*called.borrow_mut() += 1);
+			defer!(*called.borrow_mut() += 1;); // With ;
+			defer!({ *called.borrow_mut() += 1 });
+			defer!({ *called.borrow_mut() += 1 };); // With ;
+		}
+		assert_eq!(*called.borrow(), 4);
+	}
+
+	#[test]
+	/// `defer` executes the code even in case of a panic.
+	fn defer_guard_panic_unwind_works() {
+		use std::panic::{catch_unwind, AssertUnwindSafe};
+		let mut called = false;
+
+		let should_panic = catch_unwind(AssertUnwindSafe(|| {
+			defer!(called = true);
+			panic!();
+		}));
+
+		assert!(should_panic.is_err(), "DeferGuard should have panicked");
+		assert!(called, "DeferGuard should have executed the closure");
+	}
+
+	#[test]
+	/// `defer` executes the code even in case another `defer` panics.
+	fn defer_guard_defer_panics_unwind_works() {
+		use std::panic::{catch_unwind, AssertUnwindSafe};
+		let counter = std::cell::RefCell::new(0);
+
+		let should_panic = catch_unwind(AssertUnwindSafe(|| {
+			defer!(*counter.borrow_mut() += 1);
+			defer!(
+				*counter.borrow_mut() += 1;
+				panic!();
+			);
+			defer!(*counter.borrow_mut() += 1);
+		}));
+
+		assert!(should_panic.is_err(), "DeferGuard should have panicked");
+		assert_eq!(*counter.borrow(), 3, "DeferGuard should have executed the closure");
+	}
+}
diff --git a/substrate/primitives/core/src/ecdsa.rs b/substrate/primitives/core/src/ecdsa.rs
new file mode 100644
index 0000000000000000000000000000000000000000..05bc679386c3dcf8741ade5221bc4b714693c138
--- /dev/null
+++ b/substrate/primitives/core/src/ecdsa.rs
@@ -0,0 +1,801 @@
+// 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.
+
+//! Simple ECDSA secp256k1 API.
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_runtime_interface::pass_by::PassByInner;
+
+#[cfg(feature = "serde")]
+use crate::crypto::Ss58Codec;
+use crate::crypto::{
+	ByteArray, CryptoType, CryptoTypeId, Derive, Public as TraitPublic, UncheckedFrom,
+};
+#[cfg(feature = "full_crypto")]
+use crate::{
+	crypto::{DeriveError, DeriveJunction, Pair as TraitPair, SecretStringError},
+	hashing::blake2_256,
+};
+#[cfg(all(feature = "full_crypto", not(feature = "std")))]
+use secp256k1::Secp256k1;
+#[cfg(feature = "std")]
+use secp256k1::SECP256K1;
+#[cfg(feature = "full_crypto")]
+use secp256k1::{
+	ecdsa::{RecoverableSignature, RecoveryId},
+	Message, PublicKey, SecretKey,
+};
+#[cfg(feature = "serde")]
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::alloc::{format, string::String};
+#[cfg(feature = "full_crypto")]
+use sp_std::vec::Vec;
+
+/// An identifier used to match public keys against ecdsa keys
+pub const CRYPTO_ID: CryptoTypeId = CryptoTypeId(*b"ecds");
+
+/// A secret seed (which is bytewise essentially equivalent to a SecretKey).
+///
+/// We need it as a different type because `Seed` is expected to be AsRef<[u8]>.
+#[cfg(feature = "full_crypto")]
+type Seed = [u8; 32];
+
+/// The ECDSA compressed public key.
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(
+	Clone,
+	Copy,
+	Encode,
+	Decode,
+	PassByInner,
+	MaxEncodedLen,
+	TypeInfo,
+	Eq,
+	PartialEq,
+	PartialOrd,
+	Ord,
+)]
+pub struct Public(pub [u8; 33]);
+
+impl crate::crypto::FromEntropy for Public {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		let mut result = Self([0u8; 33]);
+		input.read(&mut result.0[..])?;
+		Ok(result)
+	}
+}
+
+impl Public {
+	/// A new instance from the given 33-byte `data`.
+	///
+	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if
+	/// you are certain that the array actually is a pubkey. GIGO!
+	pub fn from_raw(data: [u8; 33]) -> Self {
+		Self(data)
+	}
+
+	/// Create a new instance from the given full public key.
+	///
+	/// This will convert the full public key into the compressed format.
+	#[cfg(feature = "std")]
+	pub fn from_full(full: &[u8]) -> Result<Self, ()> {
+		let pubkey = if full.len() == 64 {
+			// Tag it as uncompressed public key.
+			let mut tagged_full = [0u8; 65];
+			tagged_full[0] = 0x04;
+			tagged_full[1..].copy_from_slice(full);
+			secp256k1::PublicKey::from_slice(&tagged_full)
+		} else {
+			secp256k1::PublicKey::from_slice(full)
+		};
+		pubkey.map(|k| Self(k.serialize())).map_err(|_| ())
+	}
+}
+
+impl ByteArray for Public {
+	const LEN: usize = 33;
+}
+
+impl TraitPublic for Public {}
+
+impl Derive for Public {}
+
+impl AsRef<[u8]> for Public {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Public {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl TryFrom<&[u8]> for Public {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() != Self::LEN {
+			return Err(())
+		}
+		let mut r = [0u8; Self::LEN];
+		r.copy_from_slice(data);
+		Ok(Self::unchecked_from(r))
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl From<Pair> for Public {
+	fn from(x: Pair) -> Self {
+		x.public()
+	}
+}
+
+impl UncheckedFrom<[u8; 33]> for Public {
+	fn unchecked_from(x: [u8; 33]) -> Self {
+		Public(x)
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for Public {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}", self.to_ss58check())
+	}
+}
+
+impl sp_std::fmt::Debug for Public {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		let s = self.to_ss58check();
+		write!(f, "{} ({}...)", crate::hexdisplay::HexDisplay::from(&self.as_ref()), &s[0..8])
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Public {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&self.to_ss58check())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Public {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		Public::from_ss58check(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+/// A signature (a 512-bit value, plus 8 bits for recovery ID).
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(Encode, Decode, MaxEncodedLen, PassByInner, TypeInfo, PartialEq, Eq)]
+pub struct Signature(pub [u8; 65]);
+
+impl TryFrom<&[u8]> for Signature {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() == 65 {
+			let mut inner = [0u8; 65];
+			inner.copy_from_slice(data);
+			Ok(Signature(inner))
+		} else {
+			Err(())
+		}
+	}
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Signature {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&array_bytes::bytes2hex("", self))
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Signature {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let signature_hex = array_bytes::hex2bytes(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))?;
+		Signature::try_from(signature_hex.as_ref())
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+impl Clone for Signature {
+	fn clone(&self) -> Self {
+		let mut r = [0u8; 65];
+		r.copy_from_slice(&self.0[..]);
+		Signature(r)
+	}
+}
+
+impl Default for Signature {
+	fn default() -> Self {
+		Signature([0u8; 65])
+	}
+}
+
+impl From<Signature> for [u8; 65] {
+	fn from(v: Signature) -> [u8; 65] {
+		v.0
+	}
+}
+
+impl AsRef<[u8; 65]> for Signature {
+	fn as_ref(&self) -> &[u8; 65] {
+		&self.0
+	}
+}
+
+impl AsRef<[u8]> for Signature {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Signature {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl sp_std::fmt::Debug for Signature {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "{}", crate::hexdisplay::HexDisplay::from(&self.0))
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl UncheckedFrom<[u8; 65]> for Signature {
+	fn unchecked_from(data: [u8; 65]) -> Signature {
+		Signature(data)
+	}
+}
+
+impl Signature {
+	/// A new instance from the given 65-byte `data`.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use it if
+	/// you are certain that the array actually is a signature. GIGO!
+	pub fn from_raw(data: [u8; 65]) -> Signature {
+		Signature(data)
+	}
+
+	/// A new instance from the given slice that should be 65 bytes long.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use it if
+	/// you are certain that the array actually is a signature. GIGO!
+	pub fn from_slice(data: &[u8]) -> Option<Self> {
+		if data.len() != 65 {
+			return None
+		}
+		let mut r = [0u8; 65];
+		r.copy_from_slice(data);
+		Some(Signature(r))
+	}
+
+	/// Recover the public key from this signature and a message.
+	#[cfg(feature = "full_crypto")]
+	pub fn recover<M: AsRef<[u8]>>(&self, message: M) -> Option<Public> {
+		self.recover_prehashed(&blake2_256(message.as_ref()))
+	}
+
+	/// Recover the public key from this signature and a pre-hashed message.
+	#[cfg(feature = "full_crypto")]
+	pub fn recover_prehashed(&self, message: &[u8; 32]) -> Option<Public> {
+		let rid = RecoveryId::from_i32(self.0[64] as i32).ok()?;
+		let sig = RecoverableSignature::from_compact(&self.0[..64], rid).ok()?;
+		let message = Message::from_slice(message).expect("Message is 32 bytes; qed");
+
+		#[cfg(feature = "std")]
+		let context = SECP256K1;
+		#[cfg(not(feature = "std"))]
+		let context = Secp256k1::verification_only();
+
+		context
+			.recover_ecdsa(&message, &sig)
+			.ok()
+			.map(|pubkey| Public(pubkey.serialize()))
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl From<RecoverableSignature> for Signature {
+	fn from(recsig: RecoverableSignature) -> Signature {
+		let mut r = Self::default();
+		let (recid, sig) = recsig.serialize_compact();
+		r.0[..64].copy_from_slice(&sig);
+		// This is safe due to the limited range of possible valid ids.
+		r.0[64] = recid.to_i32() as u8;
+		r
+	}
+}
+
+/// Derive a single hard junction.
+#[cfg(feature = "full_crypto")]
+fn derive_hard_junction(secret_seed: &Seed, cc: &[u8; 32]) -> Seed {
+	("Secp256k1HDKD", secret_seed, cc).using_encoded(sp_core_hashing::blake2_256)
+}
+
+/// A key pair.
+#[cfg(feature = "full_crypto")]
+#[derive(Clone)]
+pub struct Pair {
+	public: Public,
+	secret: SecretKey,
+}
+
+#[cfg(feature = "full_crypto")]
+impl TraitPair for Pair {
+	type Public = Public;
+	type Seed = Seed;
+	type Signature = Signature;
+
+	/// Make a new key pair from secret seed material. The slice must be 32 bytes long or it
+	/// will return `None`.
+	///
+	/// You should never need to use this; generate(), generate_with_phrase
+	fn from_seed_slice(seed_slice: &[u8]) -> Result<Pair, SecretStringError> {
+		let secret =
+			SecretKey::from_slice(seed_slice).map_err(|_| SecretStringError::InvalidSeedLength)?;
+
+		#[cfg(feature = "std")]
+		let context = SECP256K1;
+		#[cfg(not(feature = "std"))]
+		let context = Secp256k1::signing_only();
+
+		let public = PublicKey::from_secret_key(&context, &secret);
+		let public = Public(public.serialize());
+		Ok(Pair { public, secret })
+	}
+
+	/// Derive a child key from a series of given junctions.
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(
+		&self,
+		path: Iter,
+		_seed: Option<Seed>,
+	) -> Result<(Pair, Option<Seed>), DeriveError> {
+		let mut acc = self.seed();
+		for j in path {
+			match j {
+				DeriveJunction::Soft(_cc) => return Err(DeriveError::SoftKeyInPath),
+				DeriveJunction::Hard(cc) => acc = derive_hard_junction(&acc, &cc),
+			}
+		}
+		Ok((Self::from_seed(&acc), Some(acc)))
+	}
+
+	/// Get the public key.
+	fn public(&self) -> Public {
+		self.public
+	}
+
+	/// Sign a message.
+	fn sign(&self, message: &[u8]) -> Signature {
+		self.sign_prehashed(&blake2_256(message))
+	}
+
+	/// Verify a signature on a message. Returns true if the signature is good.
+	fn verify<M: AsRef<[u8]>>(sig: &Signature, message: M, public: &Public) -> bool {
+		sig.recover(message).map(|actual| actual == *public).unwrap_or_default()
+	}
+
+	/// Return a vec filled with raw data.
+	fn to_raw_vec(&self) -> Vec<u8> {
+		self.seed().to_vec()
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl Pair {
+	/// Get the seed for this key.
+	pub fn seed(&self) -> Seed {
+		self.secret.secret_bytes()
+	}
+
+	/// Exactly as `from_string` except that if no matches are found then, the the first 32
+	/// characters are taken (padded with spaces as necessary) and used as the MiniSecretKey.
+	#[cfg(feature = "std")]
+	pub fn from_legacy_string(s: &str, password_override: Option<&str>) -> Pair {
+		Self::from_string(s, password_override).unwrap_or_else(|_| {
+			let mut padded_seed: Seed = [b' '; 32];
+			let len = s.len().min(32);
+			padded_seed[..len].copy_from_slice(&s.as_bytes()[..len]);
+			Self::from_seed(&padded_seed)
+		})
+	}
+
+	/// Sign a pre-hashed message
+	pub fn sign_prehashed(&self, message: &[u8; 32]) -> Signature {
+		let message = Message::from_slice(message).expect("Message is 32 bytes; qed");
+
+		#[cfg(feature = "std")]
+		let context = SECP256K1;
+		#[cfg(not(feature = "std"))]
+		let context = Secp256k1::signing_only();
+
+		context.sign_ecdsa_recoverable(&message, &self.secret).into()
+	}
+
+	/// Verify a signature on a pre-hashed message. Return `true` if the signature is valid
+	/// and thus matches the given `public` key.
+	pub fn verify_prehashed(sig: &Signature, message: &[u8; 32], public: &Public) -> bool {
+		match sig.recover_prehashed(message) {
+			Some(actual) => actual == *public,
+			None => false,
+		}
+	}
+
+	/// Verify a signature on a message. Returns true if the signature is good.
+	/// Parses Signature using parse_overflowing_slice.
+	#[deprecated(note = "please use `verify` instead")]
+	pub fn verify_deprecated<M: AsRef<[u8]>>(sig: &Signature, message: M, pubkey: &Public) -> bool {
+		let message = libsecp256k1::Message::parse(&blake2_256(message.as_ref()));
+
+		let parse_signature_overflowing = |x: [u8; 65]| {
+			let sig = libsecp256k1::Signature::parse_overflowing_slice(&x[..64]).ok()?;
+			let rid = libsecp256k1::RecoveryId::parse(x[64]).ok()?;
+			Some((sig, rid))
+		};
+
+		let (sig, rid) = match parse_signature_overflowing(sig.0) {
+			Some(sigri) => sigri,
+			_ => return false,
+		};
+		match libsecp256k1::recover(&message, &sig, &rid) {
+			Ok(actual) => pubkey.0 == actual.serialize_compressed(),
+			_ => false,
+		}
+	}
+}
+
+// The `secp256k1` backend doesn't implement cleanup for their private keys.
+// Currently we should take care of wiping the secret from memory.
+// NOTE: this solution is not effective when `Pair` is moved around memory.
+// The very same problem affects other cryptographic backends that are just using
+// `zeroize`for their secrets.
+#[cfg(feature = "full_crypto")]
+impl Drop for Pair {
+	fn drop(&mut self) {
+		let ptr = self.secret.as_mut_ptr();
+		for off in 0..self.secret.len() {
+			unsafe {
+				core::ptr::write_volatile(ptr.add(off), 0);
+			}
+		}
+	}
+}
+
+impl CryptoType for Public {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+impl CryptoType for Signature {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+#[cfg(feature = "full_crypto")]
+impl CryptoType for Pair {
+	type Pair = Pair;
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::crypto::{
+		set_default_ss58_version, PublicError, Ss58AddressFormat, Ss58AddressFormatRegistry,
+		DEV_PHRASE,
+	};
+	use serde_json;
+
+	#[test]
+	fn default_phrase_should_be_used() {
+		assert_eq!(
+			Pair::from_string("//Alice///password", None).unwrap().public(),
+			Pair::from_string(&format!("{}//Alice", DEV_PHRASE), Some("password"))
+				.unwrap()
+				.public(),
+		);
+	}
+
+	#[test]
+	fn seed_and_derive_should_work() {
+		let seed = array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		);
+		let pair = Pair::from_seed(&seed);
+		assert_eq!(pair.seed(), seed);
+		let path = vec![DeriveJunction::Hard([0u8; 32])];
+		let derived = pair.derive(path.into_iter(), None).ok().unwrap();
+		assert_eq!(
+			derived.0.seed(),
+			array_bytes::hex2array_unchecked::<_, 32>(
+				"b8eefc4937200a8382d00050e050ced2d4ab72cc2ef1b061477afb51564fdd61"
+			)
+		);
+	}
+
+	#[test]
+	fn test_vector_should_work() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_full(
+				&array_bytes::hex2bytes_unchecked("8db55b05db86c0b1786ca49f095d76344c9e6056b2f02701a7e7f3c20aabfd913ebbe148dd17c56551a52952371071a6c604b3f3abe8f2c8fa742158ea6dd7d4"),
+			).unwrap(),
+		);
+		let message = b"";
+		let signature = array_bytes::hex2array_unchecked("3dde91174bd9359027be59a428b8146513df80a2a3c7eda2194f64de04a69ab97b753169e94db6ffd50921a2668a48b94ca11e3d32c1ff19cfe88890aa7e8f3c00");
+		let signature = Signature::from_raw(signature);
+		assert!(pair.sign(&message[..]) == signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn test_vector_by_string_should_work() {
+		let pair = Pair::from_string(
+			"0x9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+			None,
+		)
+		.unwrap();
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_full(
+				&array_bytes::hex2bytes_unchecked("8db55b05db86c0b1786ca49f095d76344c9e6056b2f02701a7e7f3c20aabfd913ebbe148dd17c56551a52952371071a6c604b3f3abe8f2c8fa742158ea6dd7d4"),
+			).unwrap(),
+		);
+		let message = b"";
+		let signature = array_bytes::hex2array_unchecked("3dde91174bd9359027be59a428b8146513df80a2a3c7eda2194f64de04a69ab97b753169e94db6ffd50921a2668a48b94ca11e3d32c1ff19cfe88890aa7e8f3c00");
+		let signature = Signature::from_raw(signature);
+		assert!(pair.sign(&message[..]) == signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn generated_pair_should_work() {
+		let (pair, _) = Pair::generate();
+		let public = pair.public();
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		assert!(Pair::verify(&signature, &message[..], &public));
+		assert!(!Pair::verify(&signature, b"Something else", &public));
+	}
+
+	#[test]
+	fn seeded_pair_should_work() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_full(
+				&array_bytes::hex2bytes_unchecked("5676109c54b9a16d271abeb4954316a40a32bcce023ac14c8e26e958aa68fba995840f3de562156558efbfdac3f16af0065e5f66795f4dd8262a228ef8c6d813"),
+			).unwrap(),
+		);
+		let message = array_bytes::hex2bytes_unchecked("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
+		let signature = pair.sign(&message[..]);
+		println!("Correct signature: {:?}", signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+		assert!(!Pair::verify(&signature, "Other message", &public));
+	}
+
+	#[test]
+	fn generate_with_phrase_recovery_possible() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(None);
+		let (pair2, _) = Pair::from_phrase(&phrase, None).unwrap();
+
+		assert_eq!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn generate_with_password_phrase_recovery_possible() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(Some("password"));
+		let (pair2, _) = Pair::from_phrase(&phrase, Some("password")).unwrap();
+
+		assert_eq!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn password_does_something() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(Some("password"));
+		let (pair2, _) = Pair::from_phrase(&phrase, None).unwrap();
+
+		assert_ne!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn ss58check_roundtrip_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let s = public.to_ss58check();
+		println!("Correct: {}", s);
+		let cmp = Public::from_ss58check(&s).unwrap();
+		assert_eq!(cmp, public);
+	}
+
+	#[test]
+	fn ss58check_format_check_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let format = Ss58AddressFormatRegistry::Reserved46Account.into();
+		let s = public.to_ss58check_with_version(format);
+		assert_eq!(Public::from_ss58check_with_version(&s), Err(PublicError::FormatNotAllowed));
+	}
+
+	#[test]
+	fn ss58check_full_roundtrip_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let format = Ss58AddressFormatRegistry::PolkadotAccount.into();
+		let s = public.to_ss58check_with_version(format);
+		let (k, f) = Public::from_ss58check_with_version(&s).unwrap();
+		assert_eq!(k, public);
+		assert_eq!(f, format);
+
+		let format = Ss58AddressFormat::custom(64);
+		let s = public.to_ss58check_with_version(format);
+		let (k, f) = Public::from_ss58check_with_version(&s).unwrap();
+		assert_eq!(k, public);
+		assert_eq!(f, format);
+	}
+
+	#[test]
+	fn ss58check_custom_format_works() {
+		// We need to run this test in its own process to not interfere with other tests running in
+		// parallel and also relying on the ss58 version.
+		if std::env::var("RUN_CUSTOM_FORMAT_TEST") == Ok("1".into()) {
+			use crate::crypto::Ss58AddressFormat;
+			// temp save default format version
+			let default_format = crate::crypto::default_ss58_version();
+			// set current ss58 version is custom "200" `Ss58AddressFormat::Custom(200)`
+
+			set_default_ss58_version(Ss58AddressFormat::custom(200));
+			// custom addr encoded by version 200
+			let addr = "4pbsSkWcBaYoFHrKJZp5fDVUKbqSYD9dhZZGvpp3vQ5ysVs5ybV";
+			Public::from_ss58check(addr).unwrap();
+
+			set_default_ss58_version(default_format);
+			// set current ss58 version to default version
+			let addr = "KWAfgC2aRG5UVD6CpbPQXCx4YZZUhvWqqAJE6qcYc9Rtr6g5C";
+			Public::from_ss58check(addr).unwrap();
+
+			println!("CUSTOM_FORMAT_SUCCESSFUL");
+		} else {
+			let executable = std::env::current_exe().unwrap();
+			let output = std::process::Command::new(executable)
+				.env("RUN_CUSTOM_FORMAT_TEST", "1")
+				.args(&["--nocapture", "ss58check_custom_format_works"])
+				.output()
+				.unwrap();
+
+			let output = String::from_utf8(output.stdout).unwrap();
+			assert!(output.contains("CUSTOM_FORMAT_SUCCESSFUL"));
+		}
+	}
+
+	#[test]
+	fn signature_serialization_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		let serialized_signature = serde_json::to_string(&signature).unwrap();
+		// Signature is 65 bytes, so 130 chars + 2 quote chars
+		assert_eq!(serialized_signature.len(), 132);
+		let signature = serde_json::from_str(&serialized_signature).unwrap();
+		assert!(Pair::verify(&signature, &message[..], &pair.public()));
+	}
+
+	#[test]
+	fn signature_serialization_doesnt_panic() {
+		fn deserialize_signature(text: &str) -> Result<Signature, serde_json::error::Error> {
+			serde_json::from_str(text)
+		}
+		assert!(deserialize_signature("Not valid json.").is_err());
+		assert!(deserialize_signature("\"Not an actual signature.\"").is_err());
+		// Poorly-sized
+		assert!(deserialize_signature("\"abc123\"").is_err());
+	}
+
+	#[test]
+	fn sign_prehashed_works() {
+		let (pair, _, _) = Pair::generate_with_phrase(Some("password"));
+
+		// `msg` shouldn't be mangled
+		let msg = [0u8; 32];
+		let sig1 = pair.sign_prehashed(&msg);
+		let sig2: Signature = {
+			let message = Message::from_slice(&msg).unwrap();
+			SECP256K1.sign_ecdsa_recoverable(&message, &pair.secret).into()
+		};
+		assert_eq!(sig1, sig2);
+
+		// signature is actually different
+		let sig2 = pair.sign(&msg);
+		assert_ne!(sig1, sig2);
+
+		// using pre-hashed `msg` works
+		let msg = b"this should be hashed";
+		let sig1 = pair.sign_prehashed(&blake2_256(msg));
+		let sig2 = pair.sign(msg);
+		assert_eq!(sig1, sig2);
+	}
+
+	#[test]
+	fn verify_prehashed_works() {
+		let (pair, _, _) = Pair::generate_with_phrase(Some("password"));
+
+		// `msg` and `sig` match
+		let msg = blake2_256(b"this should be hashed");
+		let sig = pair.sign_prehashed(&msg);
+		assert!(Pair::verify_prehashed(&sig, &msg, &pair.public()));
+
+		// `msg` and `sig` don't match
+		let msg = blake2_256(b"this is a different message");
+		assert!(!Pair::verify_prehashed(&sig, &msg, &pair.public()));
+	}
+
+	#[test]
+	fn recover_prehashed_works() {
+		let (pair, _, _) = Pair::generate_with_phrase(Some("password"));
+
+		// recovered key matches signing key
+		let msg = blake2_256(b"this should be hashed");
+		let sig = pair.sign_prehashed(&msg);
+		let key = sig.recover_prehashed(&msg).unwrap();
+		assert_eq!(pair.public(), key);
+
+		// recovered key is useable
+		assert!(Pair::verify_prehashed(&sig, &msg, &key));
+
+		// recovered key and signing key don't match
+		let msg = blake2_256(b"this is a different message");
+		let key = sig.recover_prehashed(&msg).unwrap();
+		assert_ne!(pair.public(), key);
+	}
+}
diff --git a/substrate/primitives/core/src/ed25519.rs b/substrate/primitives/core/src/ed25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..151a7229315ebc2d3e6a464929d5d16e7bc842dd
--- /dev/null
+++ b/substrate/primitives/core/src/ed25519.rs
@@ -0,0 +1,627 @@
+// 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.
+
+// tag::description[]
+//! Simple Ed25519 API.
+// end::description[]
+
+#[cfg(feature = "full_crypto")]
+use sp_std::vec::Vec;
+
+use crate::{
+	crypto::ByteArray,
+	hash::{H256, H512},
+};
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+
+#[cfg(feature = "serde")]
+use crate::crypto::Ss58Codec;
+use crate::crypto::{
+	CryptoType, CryptoTypeId, Derive, FromEntropy, Public as TraitPublic, UncheckedFrom,
+};
+#[cfg(feature = "full_crypto")]
+use crate::crypto::{DeriveError, DeriveJunction, Pair as TraitPair, SecretStringError};
+#[cfg(feature = "full_crypto")]
+use core::convert::TryFrom;
+#[cfg(feature = "full_crypto")]
+use ed25519_zebra::{SigningKey, VerificationKey};
+#[cfg(feature = "serde")]
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use sp_runtime_interface::pass_by::PassByInner;
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::alloc::{format, string::String};
+use sp_std::ops::Deref;
+
+/// An identifier used to match public keys against ed25519 keys
+pub const CRYPTO_ID: CryptoTypeId = CryptoTypeId(*b"ed25");
+
+/// A secret seed. It's not called a "secret key" because ring doesn't expose the secret keys
+/// of the key pair (yeah, dumb); as such we're forced to remember the seed manually if we
+/// will need it later (such as for HDKD).
+#[cfg(feature = "full_crypto")]
+type Seed = [u8; 32];
+
+/// A public key.
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(
+	PartialEq,
+	Eq,
+	PartialOrd,
+	Ord,
+	Clone,
+	Copy,
+	Encode,
+	Decode,
+	PassByInner,
+	MaxEncodedLen,
+	TypeInfo,
+)]
+pub struct Public(pub [u8; 32]);
+
+/// A key pair.
+#[cfg(feature = "full_crypto")]
+#[derive(Copy, Clone)]
+pub struct Pair {
+	public: VerificationKey,
+	secret: SigningKey,
+}
+
+impl FromEntropy for Public {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		let mut result = Self([0u8; 32]);
+		input.read(&mut result.0[..])?;
+		Ok(result)
+	}
+}
+
+impl AsRef<[u8; 32]> for Public {
+	fn as_ref(&self) -> &[u8; 32] {
+		&self.0
+	}
+}
+
+impl AsRef<[u8]> for Public {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Public {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl Deref for Public {
+	type Target = [u8];
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl TryFrom<&[u8]> for Public {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() != Self::LEN {
+			return Err(())
+		}
+		let mut r = [0u8; Self::LEN];
+		r.copy_from_slice(data);
+		Ok(Self::unchecked_from(r))
+	}
+}
+
+impl From<Public> for [u8; 32] {
+	fn from(x: Public) -> Self {
+		x.0
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl From<Pair> for Public {
+	fn from(x: Pair) -> Self {
+		x.public()
+	}
+}
+
+impl From<Public> for H256 {
+	fn from(x: Public) -> Self {
+		x.0.into()
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::str::FromStr for Public {
+	type Err = crate::crypto::PublicError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		Self::from_ss58check(s)
+	}
+}
+
+impl UncheckedFrom<[u8; 32]> for Public {
+	fn unchecked_from(x: [u8; 32]) -> Self {
+		Public::from_raw(x)
+	}
+}
+
+impl UncheckedFrom<H256> for Public {
+	fn unchecked_from(x: H256) -> Self {
+		Public::from_h256(x)
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for Public {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}", self.to_ss58check())
+	}
+}
+
+impl sp_std::fmt::Debug for Public {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		let s = self.to_ss58check();
+		write!(f, "{} ({}...)", crate::hexdisplay::HexDisplay::from(&self.0), &s[0..8])
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Public {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&self.to_ss58check())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Public {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		Public::from_ss58check(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+/// A signature (a 512-bit value).
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(Encode, Decode, MaxEncodedLen, PassByInner, TypeInfo, PartialEq, Eq)]
+pub struct Signature(pub [u8; 64]);
+
+impl TryFrom<&[u8]> for Signature {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() == 64 {
+			let mut inner = [0u8; 64];
+			inner.copy_from_slice(data);
+			Ok(Signature(inner))
+		} else {
+			Err(())
+		}
+	}
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Signature {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&array_bytes::bytes2hex("", self))
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Signature {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let signature_hex = array_bytes::hex2bytes(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))?;
+		Signature::try_from(signature_hex.as_ref())
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+impl Clone for Signature {
+	fn clone(&self) -> Self {
+		let mut r = [0u8; 64];
+		r.copy_from_slice(&self.0[..]);
+		Signature(r)
+	}
+}
+
+impl From<Signature> for H512 {
+	fn from(v: Signature) -> H512 {
+		H512::from(v.0)
+	}
+}
+
+impl From<Signature> for [u8; 64] {
+	fn from(v: Signature) -> [u8; 64] {
+		v.0
+	}
+}
+
+impl AsRef<[u8; 64]> for Signature {
+	fn as_ref(&self) -> &[u8; 64] {
+		&self.0
+	}
+}
+
+impl AsRef<[u8]> for Signature {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Signature {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl sp_std::fmt::Debug for Signature {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "{}", crate::hexdisplay::HexDisplay::from(&self.0))
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl UncheckedFrom<[u8; 64]> for Signature {
+	fn unchecked_from(data: [u8; 64]) -> Signature {
+		Signature(data)
+	}
+}
+
+impl Signature {
+	/// A new instance from the given 64-byte `data`.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use it if
+	/// you are certain that the array actually is a signature. GIGO!
+	pub fn from_raw(data: [u8; 64]) -> Signature {
+		Signature(data)
+	}
+
+	/// A new instance from the given slice that should be 64 bytes long.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use it if
+	/// you are certain that the array actually is a signature. GIGO!
+	pub fn from_slice(data: &[u8]) -> Option<Self> {
+		if data.len() != 64 {
+			return None
+		}
+		let mut r = [0u8; 64];
+		r.copy_from_slice(data);
+		Some(Signature(r))
+	}
+
+	/// A new instance from an H512.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use it if
+	/// you are certain that the array actually is a signature. GIGO!
+	pub fn from_h512(v: H512) -> Signature {
+		Signature(v.into())
+	}
+}
+
+impl Public {
+	/// A new instance from the given 32-byte `data`.
+	///
+	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if
+	/// you are certain that the array actually is a pubkey. GIGO!
+	pub fn from_raw(data: [u8; 32]) -> Self {
+		Public(data)
+	}
+
+	/// A new instance from an H256.
+	///
+	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if
+	/// you are certain that the array actually is a pubkey. GIGO!
+	pub fn from_h256(x: H256) -> Self {
+		Public(x.into())
+	}
+
+	/// Return a slice filled with raw data.
+	pub fn as_array_ref(&self) -> &[u8; 32] {
+		self.as_ref()
+	}
+}
+
+impl ByteArray for Public {
+	const LEN: usize = 32;
+}
+
+impl TraitPublic for Public {}
+
+impl Derive for Public {}
+
+/// Derive a single hard junction.
+#[cfg(feature = "full_crypto")]
+fn derive_hard_junction(secret_seed: &Seed, cc: &[u8; 32]) -> Seed {
+	("Ed25519HDKD", secret_seed, cc).using_encoded(sp_core_hashing::blake2_256)
+}
+
+#[cfg(feature = "full_crypto")]
+impl TraitPair for Pair {
+	type Public = Public;
+	type Seed = Seed;
+	type Signature = Signature;
+
+	/// Make a new key pair from secret seed material. The slice must be 32 bytes long or it
+	/// will return `None`.
+	///
+	/// You should never need to use this; generate(), generate_with_phrase
+	fn from_seed_slice(seed_slice: &[u8]) -> Result<Pair, SecretStringError> {
+		let secret =
+			SigningKey::try_from(seed_slice).map_err(|_| SecretStringError::InvalidSeedLength)?;
+		let public = VerificationKey::from(&secret);
+		Ok(Pair { secret, public })
+	}
+
+	/// Derive a child key from a series of given junctions.
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(
+		&self,
+		path: Iter,
+		_seed: Option<Seed>,
+	) -> Result<(Pair, Option<Seed>), DeriveError> {
+		let mut acc = self.secret.into();
+		for j in path {
+			match j {
+				DeriveJunction::Soft(_cc) => return Err(DeriveError::SoftKeyInPath),
+				DeriveJunction::Hard(cc) => acc = derive_hard_junction(&acc, &cc),
+			}
+		}
+		Ok((Self::from_seed(&acc), Some(acc)))
+	}
+
+	/// Get the public key.
+	fn public(&self) -> Public {
+		Public(self.public.into())
+	}
+
+	/// Sign a message.
+	fn sign(&self, message: &[u8]) -> Signature {
+		Signature::from_raw(self.secret.sign(message).into())
+	}
+
+	/// Verify a signature on a message.
+	///
+	/// Returns true if the signature is good.
+	fn verify<M: AsRef<[u8]>>(sig: &Signature, message: M, public: &Public) -> bool {
+		let Ok(public) = VerificationKey::try_from(public.as_slice()) else { return false };
+		let Ok(signature) = ed25519_zebra::Signature::try_from(sig.as_ref()) else { return false };
+		public.verify(&signature, message.as_ref()).is_ok()
+	}
+
+	/// Return a vec filled with raw data.
+	fn to_raw_vec(&self) -> Vec<u8> {
+		self.seed().to_vec()
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl Pair {
+	/// Get the seed for this key.
+	pub fn seed(&self) -> Seed {
+		self.secret.into()
+	}
+
+	/// Exactly as `from_string` except that if no matches are found then, the the first 32
+	/// characters are taken (padded with spaces as necessary) and used as the MiniSecretKey.
+	#[cfg(feature = "std")]
+	pub fn from_legacy_string(s: &str, password_override: Option<&str>) -> Pair {
+		Self::from_string(s, password_override).unwrap_or_else(|_| {
+			let mut padded_seed: Seed = [b' '; 32];
+			let len = s.len().min(32);
+			padded_seed[..len].copy_from_slice(&s.as_bytes()[..len]);
+			Self::from_seed(&padded_seed)
+		})
+	}
+}
+
+impl CryptoType for Public {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+impl CryptoType for Signature {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+#[cfg(feature = "full_crypto")]
+impl CryptoType for Pair {
+	type Pair = Pair;
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::crypto::DEV_PHRASE;
+	use serde_json;
+
+	#[test]
+	fn default_phrase_should_be_used() {
+		assert_eq!(
+			Pair::from_string("//Alice///password", None).unwrap().public(),
+			Pair::from_string(&format!("{}//Alice", DEV_PHRASE), Some("password"))
+				.unwrap()
+				.public(),
+		);
+	}
+
+	#[test]
+	fn seed_and_derive_should_work() {
+		let seed = array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		);
+		let pair = Pair::from_seed(&seed);
+		assert_eq!(pair.seed(), seed);
+		let path = vec![DeriveJunction::Hard([0u8; 32])];
+		let derived = pair.derive(path.into_iter(), None).ok().unwrap().0;
+		assert_eq!(
+			derived.seed(),
+			array_bytes::hex2array_unchecked::<_, 32>(
+				"ede3354e133f9c8e337ddd6ee5415ed4b4ffe5fc7d21e933f4930a3730e5b21c"
+			)
+		);
+	}
+
+	#[test]
+	fn test_vector_should_work() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_raw(array_bytes::hex2array_unchecked(
+				"d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"
+			))
+		);
+		let message = b"";
+		let signature = array_bytes::hex2array_unchecked("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
+		let signature = Signature::from_raw(signature);
+		assert!(pair.sign(&message[..]) == signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn test_vector_by_string_should_work() {
+		let pair = Pair::from_string(
+			"0x9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+			None,
+		)
+		.unwrap();
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_raw(array_bytes::hex2array_unchecked(
+				"d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a"
+			))
+		);
+		let message = b"";
+		let signature = array_bytes::hex2array_unchecked("e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b");
+		let signature = Signature::from_raw(signature);
+		assert!(pair.sign(&message[..]) == signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn generated_pair_should_work() {
+		let (pair, _) = Pair::generate();
+		let public = pair.public();
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		assert!(Pair::verify(&signature, &message[..], &public));
+		assert!(!Pair::verify(&signature, b"Something else", &public));
+	}
+
+	#[test]
+	fn seeded_pair_should_work() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_raw(array_bytes::hex2array_unchecked(
+				"2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee"
+			))
+		);
+		let message = array_bytes::hex2bytes_unchecked("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
+		let signature = pair.sign(&message[..]);
+		println!("Correct signature: {:?}", signature);
+		assert!(Pair::verify(&signature, &message[..], &public));
+		assert!(!Pair::verify(&signature, "Other message", &public));
+	}
+
+	#[test]
+	fn generate_with_phrase_recovery_possible() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(None);
+		let (pair2, _) = Pair::from_phrase(&phrase, None).unwrap();
+
+		assert_eq!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn generate_with_password_phrase_recovery_possible() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(Some("password"));
+		let (pair2, _) = Pair::from_phrase(&phrase, Some("password")).unwrap();
+
+		assert_eq!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn password_does_something() {
+		let (pair1, phrase, _) = Pair::generate_with_phrase(Some("password"));
+		let (pair2, _) = Pair::from_phrase(&phrase, None).unwrap();
+
+		assert_ne!(pair1.public(), pair2.public());
+	}
+
+	#[test]
+	fn ss58check_roundtrip_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let s = public.to_ss58check();
+		println!("Correct: {}", s);
+		let cmp = Public::from_ss58check(&s).unwrap();
+		assert_eq!(cmp, public);
+	}
+
+	#[test]
+	fn signature_serialization_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		let serialized_signature = serde_json::to_string(&signature).unwrap();
+		// Signature is 64 bytes, so 128 chars + 2 quote chars
+		assert_eq!(serialized_signature.len(), 130);
+		let signature = serde_json::from_str(&serialized_signature).unwrap();
+		assert!(Pair::verify(&signature, &message[..], &pair.public()));
+	}
+
+	#[test]
+	fn signature_serialization_doesnt_panic() {
+		fn deserialize_signature(text: &str) -> Result<Signature, serde_json::error::Error> {
+			serde_json::from_str(text)
+		}
+		assert!(deserialize_signature("Not valid json.").is_err());
+		assert!(deserialize_signature("\"Not an actual signature.\"").is_err());
+		// Poorly-sized
+		assert!(deserialize_signature("\"abc123\"").is_err());
+	}
+}
diff --git a/substrate/primitives/core/src/hash.rs b/substrate/primitives/core/src/hash.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ece9b1af794aaaf93185e68c3bede8d71c9cf4e5
--- /dev/null
+++ b/substrate/primitives/core/src/hash.rs
@@ -0,0 +1,120 @@
+// 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 fixed hash type.
+
+pub use primitive_types::{H160, H256, H512};
+
+/// Hash conversion. Used to convert between unbound associated hash types in traits,
+/// implemented by the same hash type.
+/// Panics if used to convert between different hash types.
+pub fn convert_hash<H1: Default + AsMut<[u8]>, H2: AsRef<[u8]>>(src: &H2) -> H1 {
+	let mut dest = H1::default();
+	assert_eq!(dest.as_mut().len(), src.as_ref().len());
+	dest.as_mut().copy_from_slice(src.as_ref());
+	dest
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_h160() {
+		let tests = vec![
+			(Default::default(), "0x0000000000000000000000000000000000000000"),
+			(H160::from_low_u64_be(2), "0x0000000000000000000000000000000000000002"),
+			(H160::from_low_u64_be(15), "0x000000000000000000000000000000000000000f"),
+			(H160::from_low_u64_be(16), "0x0000000000000000000000000000000000000010"),
+			(H160::from_low_u64_be(1_000), "0x00000000000000000000000000000000000003e8"),
+			(H160::from_low_u64_be(100_000), "0x00000000000000000000000000000000000186a0"),
+			(H160::from_low_u64_be(u64::MAX), "0x000000000000000000000000ffffffffffffffff"),
+		];
+
+		for (number, expected) in tests {
+			assert_eq!(
+				format!("{:?}", expected),
+				serde_json::to_string_pretty(&number).expect("Json pretty print failed")
+			);
+			assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
+		}
+	}
+
+	#[test]
+	fn test_h256() {
+		let tests = vec![
+			(
+				Default::default(),
+				"0x0000000000000000000000000000000000000000000000000000000000000000",
+			),
+			(
+				H256::from_low_u64_be(2),
+				"0x0000000000000000000000000000000000000000000000000000000000000002",
+			),
+			(
+				H256::from_low_u64_be(15),
+				"0x000000000000000000000000000000000000000000000000000000000000000f",
+			),
+			(
+				H256::from_low_u64_be(16),
+				"0x0000000000000000000000000000000000000000000000000000000000000010",
+			),
+			(
+				H256::from_low_u64_be(1_000),
+				"0x00000000000000000000000000000000000000000000000000000000000003e8",
+			),
+			(
+				H256::from_low_u64_be(100_000),
+				"0x00000000000000000000000000000000000000000000000000000000000186a0",
+			),
+			(
+				H256::from_low_u64_be(u64::MAX),
+				"0x000000000000000000000000000000000000000000000000ffffffffffffffff",
+			),
+		];
+
+		for (number, expected) in tests {
+			assert_eq!(
+				format!("{:?}", expected),
+				serde_json::to_string_pretty(&number).expect("Json pretty print failed")
+			);
+			assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
+		}
+	}
+
+	#[test]
+	fn test_invalid() {
+		assert!(serde_json::from_str::<H256>(
+			"\"0x000000000000000000000000000000000000000000000000000000000000000\""
+		)
+		.unwrap_err()
+		.is_data());
+		assert!(serde_json::from_str::<H256>(
+			"\"0x000000000000000000000000000000000000000000000000000000000000000g\""
+		)
+		.unwrap_err()
+		.is_data());
+		assert!(serde_json::from_str::<H256>(
+			"\"0x00000000000000000000000000000000000000000000000000000000000000000\""
+		)
+		.unwrap_err()
+		.is_data());
+		assert!(serde_json::from_str::<H256>("\"\"").unwrap_err().is_data());
+		assert!(serde_json::from_str::<H256>("\"0\"").unwrap_err().is_data());
+		assert!(serde_json::from_str::<H256>("\"10\"").unwrap_err().is_data());
+	}
+}
diff --git a/substrate/primitives/core/src/hasher.rs b/substrate/primitives/core/src/hasher.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5c4c40cba8e2d89635b424e8af3c36ba98062966
--- /dev/null
+++ b/substrate/primitives/core/src/hasher.rs
@@ -0,0 +1,58 @@
+// 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.
+
+//! Substrate Blake2b Hasher implementation
+
+pub mod blake2 {
+	use crate::hash::H256;
+	use hash256_std_hasher::Hash256StdHasher;
+	use hash_db::Hasher;
+
+	/// Concrete implementation of Hasher using Blake2b 256-bit hashes
+	#[derive(Debug)]
+	pub struct Blake2Hasher;
+
+	impl Hasher for Blake2Hasher {
+		type Out = H256;
+		type StdHasher = Hash256StdHasher;
+		const LENGTH: usize = 32;
+
+		fn hash(x: &[u8]) -> Self::Out {
+			crate::hashing::blake2_256(x).into()
+		}
+	}
+}
+
+pub mod keccak {
+	use crate::hash::H256;
+	use hash256_std_hasher::Hash256StdHasher;
+	use hash_db::Hasher;
+
+	/// Concrete implementation of Hasher using Keccak 256-bit hashes
+	#[derive(Debug)]
+	pub struct KeccakHasher;
+
+	impl Hasher for KeccakHasher {
+		type Out = H256;
+		type StdHasher = Hash256StdHasher;
+		const LENGTH: usize = 32;
+
+		fn hash(x: &[u8]) -> Self::Out {
+			crate::hashing::keccak_256(x).into()
+		}
+	}
+}
diff --git a/substrate/primitives/core/src/hashing.rs b/substrate/primitives/core/src/hashing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e71d0b54338030fc7adaa684765a373b26d6ef01
--- /dev/null
+++ b/substrate/primitives/core/src/hashing.rs
@@ -0,0 +1,66 @@
+// 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.
+
+//! Hashing functions.
+//!
+//! This module is gated by `full-crypto` feature. If you intend to use any of the functions
+//! defined here within your runtime, you should most likely rather use `sp_io::hashing` instead,
+//! unless you know what you're doing. Using `sp_io` will be more performant, since instead of
+//! computing the hash in WASM it delegates that computation to the host client.
+
+pub use sp_core_hashing::*;
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn blake2b() {
+		assert_eq!(sp_core_hashing_proc_macro::blake2b_64!(b""), blake2_64(b"")[..]);
+		assert_eq!(sp_core_hashing_proc_macro::blake2b_256!(b"test"), blake2_256(b"test")[..]);
+		assert_eq!(sp_core_hashing_proc_macro::blake2b_512!(b""), blake2_512(b"")[..]);
+	}
+
+	#[test]
+	fn keccak() {
+		assert_eq!(sp_core_hashing_proc_macro::keccak_256!(b"test"), keccak_256(b"test")[..]);
+		assert_eq!(sp_core_hashing_proc_macro::keccak_512!(b"test"), keccak_512(b"test")[..]);
+	}
+
+	#[test]
+	fn sha2() {
+		assert_eq!(sp_core_hashing_proc_macro::sha2_256!(b"test"), sha2_256(b"test")[..]);
+	}
+
+	#[test]
+	fn twox() {
+		assert_eq!(sp_core_hashing_proc_macro::twox_128!(b"test"), twox_128(b"test")[..]);
+		assert_eq!(sp_core_hashing_proc_macro::twox_64!(b""), twox_64(b"")[..]);
+	}
+
+	#[test]
+	fn twox_concats() {
+		assert_eq!(
+			sp_core_hashing_proc_macro::twox_128!(b"test", b"123", b"45", b"", b"67890"),
+			super::twox_128(&b"test1234567890"[..]),
+		);
+		assert_eq!(
+			sp_core_hashing_proc_macro::twox_128!(b"test", test, b"45", b"", b"67890"),
+			super::twox_128(&b"testtest4567890"[..]),
+		);
+	}
+}
diff --git a/substrate/primitives/core/src/hexdisplay.rs b/substrate/primitives/core/src/hexdisplay.rs
new file mode 100644
index 0000000000000000000000000000000000000000..30e045dfc52acae9bbd22fecd4a2c8a4edbae979
--- /dev/null
+++ b/substrate/primitives/core/src/hexdisplay.rs
@@ -0,0 +1,120 @@
+// 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.
+
+//! Wrapper type for byte collections that outputs hex.
+
+/// Simple wrapper to display hex representation of bytes.
+pub struct HexDisplay<'a>(&'a [u8]);
+
+impl<'a> HexDisplay<'a> {
+	/// Create new instance that will display `d` as a hex string when displayed.
+	pub fn from<R: AsBytesRef>(d: &'a R) -> Self {
+		HexDisplay(d.as_bytes_ref())
+	}
+}
+
+impl<'a> sp_std::fmt::Display for HexDisplay<'a> {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> Result<(), sp_std::fmt::Error> {
+		if self.0.len() < 1027 {
+			for byte in self.0 {
+				f.write_fmt(format_args!("{:02x}", byte))?;
+			}
+		} else {
+			for byte in &self.0[0..512] {
+				f.write_fmt(format_args!("{:02x}", byte))?;
+			}
+			f.write_str("...")?;
+			for byte in &self.0[self.0.len() - 512..] {
+				f.write_fmt(format_args!("{:02x}", byte))?;
+			}
+		}
+		Ok(())
+	}
+}
+
+impl<'a> sp_std::fmt::Debug for HexDisplay<'a> {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> Result<(), sp_std::fmt::Error> {
+		for byte in self.0 {
+			f.write_fmt(format_args!("{:02x}", byte))?;
+		}
+		Ok(())
+	}
+}
+
+/// Simple trait to transform various types to `&[u8]`
+pub trait AsBytesRef {
+	/// Transform `self` into `&[u8]`.
+	fn as_bytes_ref(&self) -> &[u8];
+}
+
+impl AsBytesRef for &[u8] {
+	fn as_bytes_ref(&self) -> &[u8] {
+		self
+	}
+}
+
+impl AsBytesRef for [u8] {
+	fn as_bytes_ref(&self) -> &[u8] {
+		self
+	}
+}
+
+impl AsBytesRef for sp_std::vec::Vec<u8> {
+	fn as_bytes_ref(&self) -> &[u8] {
+		self
+	}
+}
+
+impl AsBytesRef for sp_storage::StorageKey {
+	fn as_bytes_ref(&self) -> &[u8] {
+		self.as_ref()
+	}
+}
+
+macro_rules! impl_non_endians {
+	( $( $t:ty ),* ) => { $(
+		impl AsBytesRef for $t {
+			fn as_bytes_ref(&self) -> &[u8] { &self[..] }
+		}
+	)* }
+}
+
+impl_non_endians!(
+	[u8; 1], [u8; 2], [u8; 3], [u8; 4], [u8; 5], [u8; 6], [u8; 7], [u8; 8], [u8; 10], [u8; 12],
+	[u8; 14], [u8; 16], [u8; 20], [u8; 24], [u8; 28], [u8; 32], [u8; 40], [u8; 48], [u8; 56],
+	[u8; 64], [u8; 65], [u8; 80], [u8; 96], [u8; 112], [u8; 128], [u8; 144]
+);
+
+/// Format into ASCII + # + hex, suitable for storage key preimages.
+#[cfg(feature = "std")]
+pub fn ascii_format(asciish: &[u8]) -> String {
+	let mut r = String::new();
+	let mut latch = false;
+	for c in asciish {
+		match (latch, *c) {
+			(false, 32..=127) => r.push(*c as char),
+			_ => {
+				if !latch {
+					r.push('#');
+					latch = true;
+				}
+				r.push_str(&format!("{:02x}", *c));
+			},
+		}
+	}
+	r
+}
diff --git a/substrate/primitives/core/src/lib.rs b/substrate/primitives/core/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3a0e1f33f16c9d5fdbded144895fa1aa38bf3d73
--- /dev/null
+++ b/substrate/primitives/core/src/lib.rs
@@ -0,0 +1,484 @@
+// 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.
+
+//! Shareable Substrate types.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+/// Initialize a key-value collection from array.
+///
+/// Creates a vector of given pairs and calls `collect` on the iterator from it.
+/// Can be used to create a `HashMap`.
+#[macro_export]
+macro_rules! map {
+	($( $name:expr => $value:expr ),* $(,)? ) => (
+		vec![ $( ( $name, $value ) ),* ].into_iter().collect()
+	);
+}
+
+#[doc(hidden)]
+pub use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+#[cfg(feature = "serde")]
+pub use serde;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use sp_runtime_interface::pass_by::{PassByEnum, PassByInner};
+use sp_std::{ops::Deref, prelude::*};
+
+pub use sp_debug_derive::RuntimeDebug;
+
+#[cfg(feature = "serde")]
+pub use impl_serde::serialize as bytes;
+
+#[cfg(feature = "full_crypto")]
+pub mod hashing;
+
+#[cfg(feature = "full_crypto")]
+pub use hashing::{blake2_128, blake2_256, keccak_256, twox_128, twox_256, twox_64};
+pub mod crypto;
+pub mod hexdisplay;
+pub use paste;
+
+#[cfg(feature = "bandersnatch-experimental")]
+pub mod bandersnatch;
+#[cfg(feature = "bls-experimental")]
+pub mod bls;
+pub mod defer;
+pub mod ecdsa;
+pub mod ed25519;
+pub mod hash;
+#[cfg(feature = "std")]
+mod hasher;
+pub mod offchain;
+pub mod sr25519;
+pub mod testing;
+#[cfg(feature = "std")]
+pub mod traits;
+pub mod uint;
+
+#[cfg(feature = "bls-experimental")]
+pub use bls::{bls377, bls381};
+
+pub use self::{
+	hash::{convert_hash, H160, H256, H512},
+	uint::{U256, U512},
+};
+#[cfg(feature = "full_crypto")]
+pub use crypto::{ByteArray, DeriveJunction, Pair, Public};
+
+#[cfg(feature = "std")]
+pub use self::hasher::blake2::Blake2Hasher;
+#[cfg(feature = "std")]
+pub use self::hasher::keccak::KeccakHasher;
+pub use hash_db::Hasher;
+
+pub use bounded_collections as bounded;
+#[cfg(feature = "std")]
+pub use bounded_collections::{bounded_btree_map, bounded_vec};
+pub use bounded_collections::{
+	parameter_types, ConstBool, ConstI128, ConstI16, ConstI32, ConstI64, ConstI8, ConstU128,
+	ConstU16, ConstU32, ConstU64, ConstU8, Get, GetDefault, TryCollect, TypedGet,
+};
+pub use sp_storage as storage;
+
+#[doc(hidden)]
+pub use sp_std;
+
+/// Hex-serialized shim for `Vec<u8>`.
+#[derive(PartialEq, Eq, Clone, RuntimeDebug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize, Hash, PartialOrd, Ord))]
+pub struct Bytes(#[cfg_attr(feature = "serde", serde(with = "bytes"))] pub Vec<u8>);
+
+impl From<Vec<u8>> for Bytes {
+	fn from(s: Vec<u8>) -> Self {
+		Bytes(s)
+	}
+}
+
+impl From<OpaqueMetadata> for Bytes {
+	fn from(s: OpaqueMetadata) -> Self {
+		Bytes(s.0)
+	}
+}
+
+impl Deref for Bytes {
+	type Target = [u8];
+	fn deref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl codec::WrapperTypeEncode for Bytes {}
+
+impl codec::WrapperTypeDecode for Bytes {
+	type Wrapped = Vec<u8>;
+}
+
+#[cfg(feature = "std")]
+impl sp_std::str::FromStr for Bytes {
+	type Err = bytes::FromHexError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		bytes::from_hex(s).map(Bytes)
+	}
+}
+
+/// Stores the encoded `RuntimeMetadata` for the native side as opaque type.
+#[derive(Encode, Decode, PartialEq, TypeInfo)]
+pub struct OpaqueMetadata(Vec<u8>);
+
+impl OpaqueMetadata {
+	/// Creates a new instance with the given metadata blob.
+	pub fn new(metadata: Vec<u8>) -> Self {
+		OpaqueMetadata(metadata)
+	}
+}
+
+impl sp_std::ops::Deref for OpaqueMetadata {
+	type Target = Vec<u8>;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+/// Simple blob to hold a `PeerId` without committing to its format.
+#[derive(
+	Default,
+	Clone,
+	Eq,
+	PartialEq,
+	Ord,
+	PartialOrd,
+	Encode,
+	Decode,
+	RuntimeDebug,
+	PassByInner,
+	TypeInfo,
+)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct OpaquePeerId(pub Vec<u8>);
+
+impl OpaquePeerId {
+	/// Create new `OpaquePeerId`
+	pub fn new(vec: Vec<u8>) -> Self {
+		OpaquePeerId(vec)
+	}
+}
+
+/// Provide a simple 4 byte identifier for a type.
+pub trait TypeId {
+	/// Simple 4 byte identifier.
+	const TYPE_ID: [u8; 4];
+}
+
+/// A log level matching the one from `log` crate.
+///
+/// Used internally by `sp_io::logging::log` method.
+#[derive(Encode, Decode, PassByEnum, Copy, Clone)]
+pub enum LogLevel {
+	/// `Error` log level.
+	Error = 1_isize,
+	/// `Warn` log level.
+	Warn = 2_isize,
+	/// `Info` log level.
+	Info = 3_isize,
+	/// `Debug` log level.
+	Debug = 4_isize,
+	/// `Trace` log level.
+	Trace = 5_isize,
+}
+
+impl From<u32> for LogLevel {
+	fn from(val: u32) -> Self {
+		match val {
+			x if x == LogLevel::Warn as u32 => LogLevel::Warn,
+			x if x == LogLevel::Info as u32 => LogLevel::Info,
+			x if x == LogLevel::Debug as u32 => LogLevel::Debug,
+			x if x == LogLevel::Trace as u32 => LogLevel::Trace,
+			_ => LogLevel::Error,
+		}
+	}
+}
+
+impl From<log::Level> for LogLevel {
+	fn from(l: log::Level) -> Self {
+		use log::Level::*;
+		match l {
+			Error => Self::Error,
+			Warn => Self::Warn,
+			Info => Self::Info,
+			Debug => Self::Debug,
+			Trace => Self::Trace,
+		}
+	}
+}
+
+impl From<LogLevel> for log::Level {
+	fn from(l: LogLevel) -> Self {
+		use self::LogLevel::*;
+		match l {
+			Error => Self::Error,
+			Warn => Self::Warn,
+			Info => Self::Info,
+			Debug => Self::Debug,
+			Trace => Self::Trace,
+		}
+	}
+}
+
+/// Log level filter that expresses which log levels should be filtered.
+///
+/// This enum matches the [`log::LevelFilter`] enum.
+#[derive(Encode, Decode, PassByEnum, Copy, Clone)]
+pub enum LogLevelFilter {
+	/// `Off` log level filter.
+	Off = 0_isize,
+	/// `Error` log level filter.
+	Error = 1_isize,
+	/// `Warn` log level filter.
+	Warn = 2_isize,
+	/// `Info` log level filter.
+	Info = 3_isize,
+	/// `Debug` log level filter.
+	Debug = 4_isize,
+	/// `Trace` log level filter.
+	Trace = 5_isize,
+}
+
+impl From<LogLevelFilter> for log::LevelFilter {
+	fn from(l: LogLevelFilter) -> Self {
+		use self::LogLevelFilter::*;
+		match l {
+			Off => Self::Off,
+			Error => Self::Error,
+			Warn => Self::Warn,
+			Info => Self::Info,
+			Debug => Self::Debug,
+			Trace => Self::Trace,
+		}
+	}
+}
+
+impl From<log::LevelFilter> for LogLevelFilter {
+	fn from(l: log::LevelFilter) -> Self {
+		use log::LevelFilter::*;
+		match l {
+			Off => Self::Off,
+			Error => Self::Error,
+			Warn => Self::Warn,
+			Info => Self::Info,
+			Debug => Self::Debug,
+			Trace => Self::Trace,
+		}
+	}
+}
+
+/// Encodes the given value into a buffer and returns the pointer and the length as a single `u64`.
+///
+/// When Substrate calls into Wasm it expects a fixed signature for functions exported
+/// from the Wasm blob. The return value of this signature is always a `u64`.
+/// This `u64` stores the pointer to the encoded return value and the length of this encoded value.
+/// The low `32bits` are reserved for the pointer, followed by `32bit` for the length.
+#[cfg(not(feature = "std"))]
+pub fn to_substrate_wasm_fn_return_value(value: &impl Encode) -> u64 {
+	let encoded = value.encode();
+
+	let ptr = encoded.as_ptr() as u64;
+	let length = encoded.len() as u64;
+	let res = ptr | (length << 32);
+
+	// Leak the output vector to avoid it being freed.
+	// This is fine in a WASM context since the heap
+	// will be discarded after the call.
+	sp_std::mem::forget(encoded);
+
+	res
+}
+
+/// The void type - it cannot exist.
+// Oh rust, you crack me up...
+#[derive(Clone, Decode, Encode, Eq, PartialEq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
+pub enum Void {}
+
+/// Macro for creating `Maybe*` marker traits.
+///
+/// Such a maybe-marker trait requires the given bound when `feature = std` and doesn't require
+/// the bound on `no_std`. This is useful for situations where you require that a type implements
+/// a certain trait with `feature = std`, but not on `no_std`.
+///
+/// # Example
+///
+/// ```
+/// sp_core::impl_maybe_marker! {
+///     /// A marker for a type that implements `Debug` when `feature = std`.
+///     trait MaybeDebug: std::fmt::Debug;
+///     /// A marker for a type that implements `Debug + Display` when `feature = std`.
+///     trait MaybeDebugDisplay: std::fmt::Debug, std::fmt::Display;
+/// }
+/// ```
+#[macro_export]
+macro_rules! impl_maybe_marker {
+	(
+		$(
+			$(#[$doc:meta] )+
+			trait $trait_name:ident: $( $trait_bound:path ),+;
+		)+
+	) => {
+		$(
+			$(#[$doc])+
+			#[cfg(feature = "std")]
+			pub trait $trait_name: $( $trait_bound + )+ {}
+			#[cfg(feature = "std")]
+			impl<T: $( $trait_bound + )+> $trait_name for T {}
+
+			$(#[$doc])+
+			#[cfg(not(feature = "std"))]
+			pub trait $trait_name {}
+			#[cfg(not(feature = "std"))]
+			impl<T> $trait_name for T {}
+		)+
+	}
+}
+
+/// Macro for creating `Maybe*` marker traits.
+///
+/// Such a maybe-marker trait requires the given bound when either `feature = std` or `feature =
+/// serde` is activated.
+///
+/// # Example
+///
+/// ```
+/// sp_core::impl_maybe_marker_std_or_serde! {
+///     /// A marker for a type that implements `Debug` when `feature = serde` or `feature = std`.
+///     trait MaybeDebug: std::fmt::Debug;
+///     /// A marker for a type that implements `Debug + Display` when `feature = serde` or `feature = std`.
+///     trait MaybeDebugDisplay: std::fmt::Debug, std::fmt::Display;
+/// }
+/// ```
+#[macro_export]
+macro_rules! impl_maybe_marker_std_or_serde {
+	(
+		$(
+			$(#[$doc:meta] )+
+			trait $trait_name:ident: $( $trait_bound:path ),+;
+		)+
+	) => {
+		$(
+			$(#[$doc])+
+			#[cfg(any(feature = "serde", feature = "std"))]
+			pub trait $trait_name: $( $trait_bound + )+ {}
+			#[cfg(any(feature = "serde", feature = "std"))]
+			impl<T: $( $trait_bound + )+> $trait_name for T {}
+
+			$(#[$doc])+
+			#[cfg(not(any(feature = "serde", feature = "std")))]
+			pub trait $trait_name {}
+			#[cfg(not(any(feature = "serde", feature = "std")))]
+			impl<T> $trait_name for T {}
+		)+
+	}
+}
+
+/// The maximum number of bytes that can be allocated at one time.
+// The maximum possible allocation size was chosen rather arbitrary, 32 MiB should be enough for
+// everybody.
+pub const MAX_POSSIBLE_ALLOCATION: u32 = 33554432; // 2^25 bytes, 32 MiB
+
+/// Generates a macro for checking if a certain feature is enabled.
+///
+/// These feature checking macros can be used to conditionally enable/disable code in a dependent
+/// crate based on a feature in the crate where the macro is called.
+///
+/// # Example
+///```
+/// sp_core::generate_feature_enabled_macro!(check_std_is_enabled, feature = "std", $);
+/// sp_core::generate_feature_enabled_macro!(check_std_or_serde_is_enabled, any(feature = "std", feature = "serde"), $);
+///
+/// // All the code passed to the macro will then conditionally compiled based on the features
+/// // activated for the crate where the macro was generated.
+/// check_std_is_enabled! {
+///     struct StdEnabled;
+/// }
+///```
+#[macro_export]
+// We need to skip formatting this macro because of this bug:
+// https://github.com/rust-lang/rustfmt/issues/5283
+#[rustfmt::skip]
+macro_rules! generate_feature_enabled_macro {
+	( $macro_name:ident, $feature_name:meta, $d:tt ) => {
+		$crate::paste::paste!{
+			/// Enable/disable the given code depending on
+			#[doc = concat!("`", stringify!($feature_name), "`")]
+			/// being enabled for the crate or not.
+			///
+			/// # Example
+			///
+			/// ```nocompile
+			/// // Will add the code depending on the feature being enabled or not.
+			#[doc = concat!(stringify!($macro_name), "!( println!(\"Hello\") )")]
+			/// ```
+			#[cfg($feature_name)]
+			#[macro_export]
+			macro_rules! [<_ $macro_name>] {
+				( $d ( $d input:tt )* ) => {
+					$d ( $d input )*
+				}
+			}
+
+			/// Enable/disable the given code depending on
+			#[doc = concat!("`", stringify!($feature_name), "`")]
+			/// being enabled for the crate or not.
+			///
+			/// # Example
+			///
+			/// ```nocompile
+			/// // Will add the code depending on the feature being enabled or not.
+			#[doc = concat!(stringify!($macro_name), "!( println!(\"Hello\") )")]
+			/// ```
+			#[cfg(not($feature_name))]
+			#[macro_export]
+			macro_rules! [<_ $macro_name>] {
+				( $d ( $d input:tt )* ) => {};
+			}
+
+			// Work around for: <https://github.com/rust-lang/rust/pull/52234>
+			#[doc(hidden)]
+			pub use [<_ $macro_name>] as $macro_name;
+		}
+	};
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	#[should_panic]
+	fn generate_feature_enabled_macro_panics() {
+		generate_feature_enabled_macro!(if_test, test, $);
+		if_test!(panic!("This should panic"));
+	}
+
+	#[test]
+	fn generate_feature_enabled_macro_works() {
+		generate_feature_enabled_macro!(if_not_test, not(test), $);
+		if_not_test!(panic!("This should not panic"));
+	}
+}
diff --git a/substrate/primitives/core/src/offchain/mod.rs b/substrate/primitives/core/src/offchain/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cef495dfaacdcf3c0ba58610819b758d2d4fd6c6
--- /dev/null
+++ b/substrate/primitives/core/src/offchain/mod.rs
@@ -0,0 +1,788 @@
+// 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.
+
+//! Offchain workers types
+
+use crate::{OpaquePeerId, RuntimeDebug};
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime_interface::pass_by::{PassByCodec, PassByEnum, PassByInner};
+use sp_std::prelude::{Box, Vec};
+
+pub use crate::crypto::KeyTypeId;
+
+#[cfg(feature = "std")]
+pub mod storage;
+#[cfg(feature = "std")]
+pub mod testing;
+
+/// Persistent storage prefix used by the Offchain Worker API when creating a DB key.
+pub const STORAGE_PREFIX: &[u8] = b"storage";
+
+/// Offchain DB persistent (non-fork-aware) storage.
+pub trait OffchainStorage: Clone + Send + Sync {
+	/// Persist a value in storage under given key and prefix.
+	fn set(&mut self, prefix: &[u8], key: &[u8], value: &[u8]);
+
+	/// Clear a storage entry under given key and prefix.
+	fn remove(&mut self, prefix: &[u8], key: &[u8]);
+
+	/// Retrieve a value from storage under given key and prefix.
+	fn get(&self, prefix: &[u8], key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Replace the value in storage if given old_value matches the current one.
+	///
+	/// Returns `true` if the value has been set and false otherwise.
+	fn compare_and_set(
+		&mut self,
+		prefix: &[u8],
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool;
+}
+
+/// A type of supported crypto.
+#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, RuntimeDebug, PassByEnum)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[repr(C)]
+pub enum StorageKind {
+	/// Persistent storage is non-revertible and not fork-aware. It means that any value
+	/// set by the offchain worker triggered at block `N(hash1)` is persisted even
+	/// if that block is reverted as non-canonical and is available for the worker
+	/// that is re-run at block `N(hash2)`.
+	/// This storage can be used by offchain workers to handle forks
+	/// and coordinate offchain workers running on different forks.
+	PERSISTENT = 1_isize,
+	/// Local storage is revertible and fork-aware. It means that any value
+	/// set by the offchain worker triggered at block `N(hash1)` is reverted
+	/// if that block is reverted as non-canonical and is NOT available for the worker
+	/// that is re-run at block `N(hash2)`.
+	LOCAL = 2_isize,
+}
+
+impl TryFrom<u32> for StorageKind {
+	type Error = ();
+
+	fn try_from(kind: u32) -> Result<Self, Self::Error> {
+		match kind {
+			e if e == u32::from(StorageKind::PERSISTENT as u8) => Ok(StorageKind::PERSISTENT),
+			e if e == u32::from(StorageKind::LOCAL as u8) => Ok(StorageKind::LOCAL),
+			_ => Err(()),
+		}
+	}
+}
+
+impl From<StorageKind> for u32 {
+	fn from(c: StorageKind) -> Self {
+		c as u8 as u32
+	}
+}
+
+/// Opaque type for offchain http requests.
+#[derive(
+	Clone, Copy, PartialEq, Eq, PartialOrd, Ord, RuntimeDebug, Encode, Decode, PassByInner,
+)]
+#[cfg_attr(feature = "std", derive(Hash))]
+pub struct HttpRequestId(pub u16);
+
+impl From<HttpRequestId> for u32 {
+	fn from(c: HttpRequestId) -> Self {
+		c.0 as u32
+	}
+}
+
+/// An error enum returned by some http methods.
+#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug, Encode, Decode, PassByEnum)]
+#[repr(C)]
+pub enum HttpError {
+	/// The requested action couldn't been completed within a deadline.
+	DeadlineReached = 1_isize,
+	/// There was an IO Error while processing the request.
+	IoError = 2_isize,
+	/// The ID of the request is invalid in this context.
+	Invalid = 3_isize,
+}
+
+impl TryFrom<u32> for HttpError {
+	type Error = ();
+
+	fn try_from(error: u32) -> Result<Self, Self::Error> {
+		match error {
+			e if e == HttpError::DeadlineReached as u8 as u32 => Ok(HttpError::DeadlineReached),
+			e if e == HttpError::IoError as u8 as u32 => Ok(HttpError::IoError),
+			e if e == HttpError::Invalid as u8 as u32 => Ok(HttpError::Invalid),
+			_ => Err(()),
+		}
+	}
+}
+
+impl From<HttpError> for u32 {
+	fn from(c: HttpError) -> Self {
+		c as u8 as u32
+	}
+}
+
+/// Status of the HTTP request
+#[derive(Clone, Copy, PartialEq, Eq, RuntimeDebug, Encode, Decode, PassByCodec)]
+pub enum HttpRequestStatus {
+	/// Deadline was reached while we waited for this request to finish.
+	///
+	/// Note the deadline is controlled by the calling part, it not necessarily
+	/// means that the request has timed out.
+	DeadlineReached,
+	/// An error has occurred during the request, for example a timeout or the
+	/// remote has closed our socket.
+	///
+	/// The request is now considered destroyed. To retry the request you need
+	/// to construct it again.
+	IoError,
+	/// The passed ID is invalid in this context.
+	Invalid,
+	/// The request has finished with given status code.
+	Finished(u16),
+}
+
+impl From<HttpRequestStatus> for u32 {
+	fn from(status: HttpRequestStatus) -> Self {
+		match status {
+			HttpRequestStatus::Invalid => 0,
+			HttpRequestStatus::DeadlineReached => 10,
+			HttpRequestStatus::IoError => 20,
+			HttpRequestStatus::Finished(code) => u32::from(code),
+		}
+	}
+}
+
+impl TryFrom<u32> for HttpRequestStatus {
+	type Error = ();
+
+	fn try_from(status: u32) -> Result<Self, Self::Error> {
+		match status {
+			0 => Ok(HttpRequestStatus::Invalid),
+			10 => Ok(HttpRequestStatus::DeadlineReached),
+			20 => Ok(HttpRequestStatus::IoError),
+			100..=999 => u16::try_from(status).map(HttpRequestStatus::Finished).map_err(|_| ()),
+			_ => Err(()),
+		}
+	}
+}
+
+/// A blob to hold information about the local node's network state
+/// without committing to its format.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, PassByCodec, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Default))]
+pub struct OpaqueNetworkState {
+	/// PeerId of the local node in SCALE encoded.
+	pub peer_id: OpaquePeerId,
+	/// List of addresses the node knows it can be reached as.
+	pub external_addresses: Vec<OpaqueMultiaddr>,
+}
+
+/// Simple blob to hold a `Multiaddr` without committing to its format.
+#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, PassByInner, TypeInfo)]
+pub struct OpaqueMultiaddr(pub Vec<u8>);
+
+impl OpaqueMultiaddr {
+	/// Create new `OpaqueMultiaddr`
+	pub fn new(vec: Vec<u8>) -> Self {
+		OpaqueMultiaddr(vec)
+	}
+}
+
+/// Opaque timestamp type
+#[derive(
+	Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Default, RuntimeDebug, PassByInner, Encode, Decode,
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Timestamp(u64);
+
+/// Duration type
+#[derive(
+	Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Default, RuntimeDebug, PassByInner, Encode, Decode,
+)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Duration(u64);
+
+impl Duration {
+	/// Create new duration representing given number of milliseconds.
+	pub const fn from_millis(millis: u64) -> Self {
+		Duration(millis)
+	}
+
+	/// Returns number of milliseconds this Duration represents.
+	pub fn millis(&self) -> u64 {
+		self.0
+	}
+}
+
+impl Timestamp {
+	/// Creates new `Timestamp` given unix timestamp in milliseconds.
+	pub fn from_unix_millis(millis: u64) -> Self {
+		Timestamp(millis)
+	}
+
+	/// Increase the timestamp by given `Duration`.
+	pub fn add(&self, duration: Duration) -> Timestamp {
+		Timestamp(self.0.saturating_add(duration.0))
+	}
+
+	/// Decrease the timestamp by given `Duration`
+	pub fn sub(&self, duration: Duration) -> Timestamp {
+		Timestamp(self.0.saturating_sub(duration.0))
+	}
+
+	/// Returns a saturated difference (Duration) between two Timestamps.
+	pub fn diff(&self, other: &Self) -> Duration {
+		Duration(self.0.saturating_sub(other.0))
+	}
+
+	/// Return number of milliseconds since UNIX epoch.
+	pub fn unix_millis(&self) -> u64 {
+		self.0
+	}
+}
+
+bitflags::bitflags! {
+	/// Execution context extra capabilities.
+	pub struct Capabilities: u32 {
+		/// External http calls.
+		const HTTP = 1 << 0;
+		/// Keystore access.
+		const KEYSTORE = 1 << 2;
+		/// Randomness source.
+		const RANDOMNESS = 1 << 3;
+		/// Access to opaque network state.
+		const NETWORK_STATE = 1 << 4;
+		/// Access to offchain worker DB (read only).
+		const OFFCHAIN_DB_READ = 1 << 5;
+		/// Access to offchain worker DB (writes).
+		const OFFCHAIN_DB_WRITE = 1 << 6;
+		/// Manage the authorized nodes
+		const NODE_AUTHORIZATION = 1 << 7;
+		/// Access time related functionality
+		const TIME = 1 << 8;
+	}
+}
+
+/// An extended externalities for offchain workers.
+pub trait Externalities: Send {
+	/// Returns if the local node is a potential validator.
+	///
+	/// Even if this function returns `true`, it does not mean that any keys are configured
+	/// and that the validator is registered in the chain.
+	fn is_validator(&self) -> bool;
+
+	/// Returns information about the local node's network state.
+	fn network_state(&self) -> Result<OpaqueNetworkState, ()>;
+
+	/// Returns current UNIX timestamp (in millis)
+	fn timestamp(&mut self) -> Timestamp;
+
+	/// Pause the execution until `deadline` is reached.
+	fn sleep_until(&mut self, deadline: Timestamp);
+
+	/// Returns a random seed.
+	///
+	/// This is a truly random non deterministic seed generated by host environment.
+	/// Obviously fine in the off-chain worker context.
+	fn random_seed(&mut self) -> [u8; 32];
+
+	/// Initiates a http request given HTTP verb and the URL.
+	///
+	/// Meta is a future-reserved field containing additional, parity-scale-codec encoded
+	/// parameters. Returns the id of newly started request.
+	///
+	/// Returns an error if:
+	/// - No new request identifier could be allocated.
+	/// - The method or URI contain invalid characters.
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<HttpRequestId, ()>;
+
+	/// Append header to the request.
+	///
+	/// Calling this function multiple times with the same header name continues appending new
+	/// headers. In other words, headers are never replaced.
+	///
+	/// Returns an error if:
+	/// - The request identifier is invalid.
+	/// - You have called `http_request_write_body` on that request.
+	/// - The name or value contain invalid characters.
+	///
+	/// An error doesn't poison the request, and you can continue as if the call had never been
+	/// made.
+	fn http_request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()>;
+
+	/// Write a chunk of request body.
+	///
+	/// Calling this function with a non-empty slice may or may not start the
+	/// HTTP request. Calling this function with an empty chunks finalizes the
+	/// request and always starts it. It is no longer valid to write more data
+	/// afterwards.
+	/// Passing `None` as deadline blocks forever.
+	///
+	/// Returns an error if:
+	/// - The request identifier is invalid.
+	/// - `http_response_wait` has already been called on this request.
+	/// - The deadline is reached.
+	/// - An I/O error has happened, for example the remote has closed our request. The request is
+	///   then considered invalid.
+	fn http_request_write_body(
+		&mut self,
+		request_id: HttpRequestId,
+		chunk: &[u8],
+		deadline: Option<Timestamp>,
+	) -> Result<(), HttpError>;
+
+	/// Block and wait for the responses for given requests.
+	///
+	/// Returns a vector of request statuses (the len is the same as ids).
+	/// Note that if deadline is not provided the method will block indefinitely,
+	/// otherwise unready responses will produce `DeadlineReached` status.
+	///
+	/// If a response returns an `IoError`, it is then considered destroyed.
+	/// Its id is then invalid.
+	///
+	/// Passing `None` as deadline blocks forever.
+	fn http_response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus>;
+
+	/// Read all response headers.
+	///
+	/// Returns a vector of pairs `(HeaderKey, HeaderValue)`.
+	///
+	/// Dispatches the request if it hasn't been done yet. It is no longer
+	/// valid to modify the headers or write data to the request.
+	///
+	/// Returns an empty list if the identifier is unknown/invalid, hasn't
+	/// received a response, or has finished.
+	fn http_response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)>;
+
+	/// Read a chunk of body response to given buffer.
+	///
+	/// Dispatches the request if it hasn't been done yet. It is no longer
+	/// valid to modify the headers or write data to the request.
+	///
+	/// Returns the number of bytes written or an error in case a deadline
+	/// is reached or server closed the connection.
+	/// Passing `None` as a deadline blocks forever.
+	///
+	/// If `Ok(0)` or `Err(IoError)` is returned, the request is considered
+	/// destroyed. Doing another read or getting the response's headers, for
+	/// example, is then invalid.
+	///
+	/// Returns an error if:
+	/// - The request identifier is invalid.
+	/// - The deadline is reached.
+	/// - An I/O error has happened, for example the remote has closed our request. The request is
+	///   then considered invalid.
+	fn http_response_read_body(
+		&mut self,
+		request_id: HttpRequestId,
+		buffer: &mut [u8],
+		deadline: Option<Timestamp>,
+	) -> Result<usize, HttpError>;
+
+	/// Set the authorized nodes from runtime.
+	///
+	/// In a permissioned network, the connections between nodes need to reach a
+	/// consensus between participants.
+	///
+	/// - `nodes`: a set of nodes which are allowed to connect for the local node.
+	/// each one is identified with an `OpaquePeerId`, here it just use plain bytes
+	/// without any encoding. Invalid `OpaquePeerId`s are silently ignored.
+	/// - `authorized_only`: if true, only the authorized nodes are allowed to connect,
+	/// otherwise unauthorized nodes can also be connected through other mechanism.
+	fn set_authorized_nodes(&mut self, nodes: Vec<OpaquePeerId>, authorized_only: bool);
+}
+
+impl<T: Externalities + ?Sized> Externalities for Box<T> {
+	fn is_validator(&self) -> bool {
+		(&**self).is_validator()
+	}
+
+	fn network_state(&self) -> Result<OpaqueNetworkState, ()> {
+		(&**self).network_state()
+	}
+
+	fn timestamp(&mut self) -> Timestamp {
+		(&mut **self).timestamp()
+	}
+
+	fn sleep_until(&mut self, deadline: Timestamp) {
+		(&mut **self).sleep_until(deadline)
+	}
+
+	fn random_seed(&mut self) -> [u8; 32] {
+		(&mut **self).random_seed()
+	}
+
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<HttpRequestId, ()> {
+		(&mut **self).http_request_start(method, uri, meta)
+	}
+
+	fn http_request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
+		(&mut **self).http_request_add_header(request_id, name, value)
+	}
+
+	fn http_request_write_body(
+		&mut self,
+		request_id: HttpRequestId,
+		chunk: &[u8],
+		deadline: Option<Timestamp>,
+	) -> Result<(), HttpError> {
+		(&mut **self).http_request_write_body(request_id, chunk, deadline)
+	}
+
+	fn http_response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus> {
+		(&mut **self).http_response_wait(ids, deadline)
+	}
+
+	fn http_response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
+		(&mut **self).http_response_headers(request_id)
+	}
+
+	fn http_response_read_body(
+		&mut self,
+		request_id: HttpRequestId,
+		buffer: &mut [u8],
+		deadline: Option<Timestamp>,
+	) -> Result<usize, HttpError> {
+		(&mut **self).http_response_read_body(request_id, buffer, deadline)
+	}
+
+	fn set_authorized_nodes(&mut self, nodes: Vec<OpaquePeerId>, authorized_only: bool) {
+		(&mut **self).set_authorized_nodes(nodes, authorized_only)
+	}
+}
+
+/// An `*Externalities` implementation with limited capabilities.
+pub struct LimitedExternalities<T> {
+	capabilities: Capabilities,
+	externalities: T,
+}
+
+impl<T> LimitedExternalities<T> {
+	/// Create new externalities limited to given `capabilities`.
+	pub fn new(capabilities: Capabilities, externalities: T) -> Self {
+		Self { capabilities, externalities }
+	}
+
+	/// Check if given capability is allowed.
+	///
+	/// Panics in case it is not.
+	fn check(&self, capability: Capabilities, name: &'static str) {
+		if !self.capabilities.contains(capability) {
+			panic!("Accessing a forbidden API: {}. No: {:?} capability.", name, capability);
+		}
+	}
+}
+
+impl<T: Externalities> Externalities for LimitedExternalities<T> {
+	fn is_validator(&self) -> bool {
+		self.check(Capabilities::KEYSTORE, "is_validator");
+		self.externalities.is_validator()
+	}
+
+	fn network_state(&self) -> Result<OpaqueNetworkState, ()> {
+		self.check(Capabilities::NETWORK_STATE, "network_state");
+		self.externalities.network_state()
+	}
+
+	fn timestamp(&mut self) -> Timestamp {
+		self.check(Capabilities::TIME, "timestamp");
+		self.externalities.timestamp()
+	}
+
+	fn sleep_until(&mut self, deadline: Timestamp) {
+		self.check(Capabilities::TIME, "sleep_until");
+		self.externalities.sleep_until(deadline)
+	}
+
+	fn random_seed(&mut self) -> [u8; 32] {
+		self.check(Capabilities::RANDOMNESS, "random_seed");
+		self.externalities.random_seed()
+	}
+
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<HttpRequestId, ()> {
+		self.check(Capabilities::HTTP, "http_request_start");
+		self.externalities.http_request_start(method, uri, meta)
+	}
+
+	fn http_request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
+		self.check(Capabilities::HTTP, "http_request_add_header");
+		self.externalities.http_request_add_header(request_id, name, value)
+	}
+
+	fn http_request_write_body(
+		&mut self,
+		request_id: HttpRequestId,
+		chunk: &[u8],
+		deadline: Option<Timestamp>,
+	) -> Result<(), HttpError> {
+		self.check(Capabilities::HTTP, "http_request_write_body");
+		self.externalities.http_request_write_body(request_id, chunk, deadline)
+	}
+
+	fn http_response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus> {
+		self.check(Capabilities::HTTP, "http_response_wait");
+		self.externalities.http_response_wait(ids, deadline)
+	}
+
+	fn http_response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
+		self.check(Capabilities::HTTP, "http_response_headers");
+		self.externalities.http_response_headers(request_id)
+	}
+
+	fn http_response_read_body(
+		&mut self,
+		request_id: HttpRequestId,
+		buffer: &mut [u8],
+		deadline: Option<Timestamp>,
+	) -> Result<usize, HttpError> {
+		self.check(Capabilities::HTTP, "http_response_read_body");
+		self.externalities.http_response_read_body(request_id, buffer, deadline)
+	}
+
+	fn set_authorized_nodes(&mut self, nodes: Vec<OpaquePeerId>, authorized_only: bool) {
+		self.check(Capabilities::NODE_AUTHORIZATION, "set_authorized_nodes");
+		self.externalities.set_authorized_nodes(nodes, authorized_only)
+	}
+}
+
+#[cfg(feature = "std")]
+sp_externalities::decl_extension! {
+	/// The offchain worker extension that will be registered at the Substrate externalities.
+	pub struct OffchainWorkerExt(Box<dyn Externalities>);
+}
+
+#[cfg(feature = "std")]
+impl OffchainWorkerExt {
+	/// Create a new instance of `Self`.
+	pub fn new<O: Externalities + 'static>(offchain: O) -> Self {
+		Self(Box::new(offchain))
+	}
+}
+
+/// A externalities extension for accessing the Offchain DB.
+pub trait DbExternalities: Send {
+	/// Sets a value in the local storage.
+	///
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It _is_ persisted between runs.
+	fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8]);
+
+	/// Removes a value in the local storage.
+	///
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It _is_ persisted between runs.
+	fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8]);
+
+	/// Sets a value in the local storage if it matches current value.
+	///
+	/// Since multiple offchain workers may be running concurrently, to prevent
+	/// data races use CAS to coordinate between them.
+	///
+	/// Returns `true` if the value has been set, `false` otherwise.
+	///
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It _is_ persisted between runs.
+	fn local_storage_compare_and_set(
+		&mut self,
+		kind: StorageKind,
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool;
+
+	/// Gets a value from the local storage.
+	///
+	/// If the value does not exist in the storage `None` will be returned.
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It _is_ persisted between runs.
+	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>>;
+}
+
+impl<T: DbExternalities + ?Sized> DbExternalities for Box<T> {
+	fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8]) {
+		(&mut **self).local_storage_set(kind, key, value)
+	}
+
+	fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8]) {
+		(&mut **self).local_storage_clear(kind, key)
+	}
+
+	fn local_storage_compare_and_set(
+		&mut self,
+		kind: StorageKind,
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool {
+		(&mut **self).local_storage_compare_and_set(kind, key, old_value, new_value)
+	}
+
+	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>> {
+		(&mut **self).local_storage_get(kind, key)
+	}
+}
+
+impl<T: DbExternalities> DbExternalities for LimitedExternalities<T> {
+	fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8]) {
+		self.check(Capabilities::OFFCHAIN_DB_WRITE, "local_storage_set");
+		self.externalities.local_storage_set(kind, key, value)
+	}
+
+	fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8]) {
+		self.check(Capabilities::OFFCHAIN_DB_WRITE, "local_storage_clear");
+		self.externalities.local_storage_clear(kind, key)
+	}
+
+	fn local_storage_compare_and_set(
+		&mut self,
+		kind: StorageKind,
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool {
+		self.check(Capabilities::OFFCHAIN_DB_WRITE, "local_storage_compare_and_set");
+		self.externalities
+			.local_storage_compare_and_set(kind, key, old_value, new_value)
+	}
+
+	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>> {
+		self.check(Capabilities::OFFCHAIN_DB_READ, "local_storage_get");
+		self.externalities.local_storage_get(kind, key)
+	}
+}
+
+#[cfg(feature = "std")]
+sp_externalities::decl_extension! {
+	/// The offchain database extension that will be registered at the Substrate externalities.
+	pub struct OffchainDbExt(Box<dyn DbExternalities>);
+}
+
+#[cfg(feature = "std")]
+impl OffchainDbExt {
+	/// Create a new instance of `OffchainDbExt`.
+	pub fn new<O: DbExternalities + 'static>(offchain: O) -> Self {
+		Self(Box::new(offchain))
+	}
+}
+
+/// Abstraction over transaction pool.
+///
+/// This trait is currently used within the `ExternalitiesExtension`
+/// to provide offchain calls with access to the transaction pool without
+/// tight coupling with any pool implementation.
+#[cfg(feature = "std")]
+pub trait TransactionPool {
+	/// Submit transaction.
+	///
+	/// The transaction will end up in the pool and be propagated to others.
+	fn submit_transaction(&mut self, extrinsic: Vec<u8>) -> Result<(), ()>;
+}
+
+#[cfg(feature = "std")]
+sp_externalities::decl_extension! {
+	/// An externalities extension to submit transactions to the pool.
+	pub struct TransactionPoolExt(Box<dyn TransactionPool + Send>);
+}
+
+#[cfg(feature = "std")]
+impl TransactionPoolExt {
+	/// Create a new instance of `TransactionPoolExt`.
+	pub fn new<O: TransactionPool + Send + 'static>(pool: O) -> Self {
+		Self(Box::new(pool))
+	}
+}
+
+/// Change to be applied to the offchain worker db in regards to a key.
+#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+pub enum OffchainOverlayedChange {
+	/// Remove the data associated with the key
+	Remove,
+	/// Overwrite the value of an associated key
+	SetValue(Vec<u8>),
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn timestamp_ops() {
+		let t = Timestamp(5);
+		assert_eq!(t.add(Duration::from_millis(10)), Timestamp(15));
+		assert_eq!(t.sub(Duration::from_millis(10)), Timestamp(0));
+		assert_eq!(t.diff(&Timestamp(3)), Duration(2));
+	}
+
+	#[test]
+	fn capabilities() {
+		let none = Capabilities::empty();
+		let all = Capabilities::all();
+		let some = Capabilities::KEYSTORE | Capabilities::RANDOMNESS;
+
+		assert!(!none.contains(Capabilities::KEYSTORE));
+		assert!(all.contains(Capabilities::KEYSTORE));
+		assert!(some.contains(Capabilities::KEYSTORE));
+		assert!(!none.contains(Capabilities::RANDOMNESS));
+		assert!(all.contains(Capabilities::RANDOMNESS));
+		assert!(!some.contains(Capabilities::TIME));
+	}
+}
diff --git a/substrate/primitives/core/src/offchain/storage.rs b/substrate/primitives/core/src/offchain/storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4db839f1a451a3220f3b71f175dd52187b036164
--- /dev/null
+++ b/substrate/primitives/core/src/offchain/storage.rs
@@ -0,0 +1,184 @@
+// 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.
+
+//! In-memory implementation of offchain workers database.
+
+use crate::offchain::{DbExternalities, OffchainStorage, StorageKind, STORAGE_PREFIX};
+use std::{
+	collections::hash_map::{Entry, HashMap},
+	iter::Iterator,
+};
+
+const LOG_TARGET: &str = "offchain-worker::storage";
+
+/// In-memory storage for offchain workers.
+#[derive(Debug, Clone, Default)]
+pub struct InMemOffchainStorage {
+	storage: HashMap<Vec<u8>, Vec<u8>>,
+}
+
+impl InMemOffchainStorage {
+	/// Consume the offchain storage and iterate over all key value pairs.
+	pub fn into_iter(self) -> impl Iterator<Item = (Vec<u8>, Vec<u8>)> {
+		self.storage.into_iter()
+	}
+
+	/// Iterate over all key value pairs by reference.
+	pub fn iter(&self) -> impl Iterator<Item = (&Vec<u8>, &Vec<u8>)> {
+		self.storage.iter()
+	}
+
+	/// Remove a key and its associated value from the offchain database.
+	pub fn remove(&mut self, prefix: &[u8], key: &[u8]) {
+		let key: Vec<u8> = prefix.iter().chain(key).cloned().collect();
+		self.storage.remove(&key);
+	}
+}
+
+impl OffchainStorage for InMemOffchainStorage {
+	fn set(&mut self, prefix: &[u8], key: &[u8], value: &[u8]) {
+		let key = prefix.iter().chain(key).cloned().collect();
+		self.storage.insert(key, value.to_vec());
+	}
+
+	fn remove(&mut self, prefix: &[u8], key: &[u8]) {
+		let key: Vec<u8> = prefix.iter().chain(key).cloned().collect();
+		self.storage.remove(&key);
+	}
+
+	fn get(&self, prefix: &[u8], key: &[u8]) -> Option<Vec<u8>> {
+		let key: Vec<u8> = prefix.iter().chain(key).cloned().collect();
+		self.storage.get(&key).cloned()
+	}
+
+	fn compare_and_set(
+		&mut self,
+		prefix: &[u8],
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool {
+		let key = prefix.iter().chain(key).cloned().collect();
+
+		match self.storage.entry(key) {
+			Entry::Vacant(entry) =>
+				if old_value.is_none() {
+					entry.insert(new_value.to_vec());
+					true
+				} else {
+					false
+				},
+			Entry::Occupied(ref mut entry) if Some(entry.get().as_slice()) == old_value => {
+				entry.insert(new_value.to_vec());
+				true
+			},
+			_ => false,
+		}
+	}
+}
+
+fn unavailable_yet<R: Default>(name: &str) -> R {
+	tracing::error!(
+		target: LOG_TARGET,
+		"The {:?} API is not available for offchain workers yet. Follow \
+		https://github.com/paritytech/substrate/issues/1458 for details",
+		name
+	);
+	Default::default()
+}
+
+const LOCAL_DB: &str = "LOCAL (fork-aware) DB";
+
+/// Offchain DB that implements [`DbExternalities`] for [`OffchainStorage`].
+#[derive(Debug, Clone)]
+pub struct OffchainDb<Storage> {
+	/// Persistent storage database.
+	persistent: Storage,
+}
+
+impl<Storage> OffchainDb<Storage> {
+	/// Create new instance of Offchain DB.
+	pub fn new(persistent: Storage) -> Self {
+		Self { persistent }
+	}
+}
+
+impl<Storage: OffchainStorage> DbExternalities for OffchainDb<Storage> {
+	fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8]) {
+		tracing::debug!(
+			target: LOG_TARGET,
+			?kind,
+			key = ?array_bytes::bytes2hex("", key),
+			value = ?array_bytes::bytes2hex("", value),
+			"Write",
+		);
+		match kind {
+			StorageKind::PERSISTENT => self.persistent.set(STORAGE_PREFIX, key, value),
+			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
+		}
+	}
+
+	fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8]) {
+		tracing::debug!(
+			target: LOG_TARGET,
+			?kind,
+			key = ?array_bytes::bytes2hex("", key),
+			"Clear",
+		);
+		match kind {
+			StorageKind::PERSISTENT => self.persistent.remove(STORAGE_PREFIX, key),
+			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
+		}
+	}
+
+	fn local_storage_compare_and_set(
+		&mut self,
+		kind: StorageKind,
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool {
+		tracing::debug!(
+			target: LOG_TARGET,
+			?kind,
+			key = ?array_bytes::bytes2hex("", key),
+			new_value = ?array_bytes::bytes2hex("", new_value),
+			old_value = ?old_value.as_ref().map(|s| array_bytes::bytes2hex("", s)),
+			"CAS",
+		);
+		match kind {
+			StorageKind::PERSISTENT =>
+				self.persistent.compare_and_set(STORAGE_PREFIX, key, old_value, new_value),
+			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
+		}
+	}
+
+	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>> {
+		let result = match kind {
+			StorageKind::PERSISTENT => self.persistent.get(STORAGE_PREFIX, key),
+			StorageKind::LOCAL => unavailable_yet(LOCAL_DB),
+		};
+		tracing::debug!(
+			target: LOG_TARGET,
+			?kind,
+			key = ?array_bytes::bytes2hex("", key),
+			result = ?result.as_ref().map(|s| array_bytes::bytes2hex("", s)),
+			"Read",
+		);
+		result
+	}
+}
diff --git a/substrate/primitives/core/src/offchain/testing.rs b/substrate/primitives/core/src/offchain/testing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee3620e701965b5ca4b66fdd7c08d28f29fdf952
--- /dev/null
+++ b/substrate/primitives/core/src/offchain/testing.rs
@@ -0,0 +1,433 @@
+// 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.
+
+//! Utilities for offchain calls testing.
+//!
+//! Namely all ExecutionExtensions that allow mocking
+//! the extra APIs.
+
+use crate::{
+	offchain::{
+		self, storage::InMemOffchainStorage, HttpError, HttpRequestId as RequestId,
+		HttpRequestStatus as RequestStatus, OffchainOverlayedChange, OffchainStorage,
+		OpaqueNetworkState, StorageKind, Timestamp, TransactionPool,
+	},
+	OpaquePeerId,
+};
+use std::{
+	collections::{BTreeMap, VecDeque},
+	sync::Arc,
+};
+
+use parking_lot::RwLock;
+
+/// Pending request.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct PendingRequest {
+	/// HTTP method
+	pub method: String,
+	/// URI
+	pub uri: String,
+	/// Encoded Metadata
+	pub meta: Vec<u8>,
+	/// Request headers
+	pub headers: Vec<(String, String)>,
+	/// Request body
+	pub body: Vec<u8>,
+	/// Has the request been sent already.
+	pub sent: bool,
+	/// Response body
+	pub response: Option<Vec<u8>>,
+	/// Number of bytes already read from the response body.
+	pub read: usize,
+	/// Response headers
+	pub response_headers: Vec<(String, String)>,
+}
+
+/// Sharable "persistent" offchain storage for test.
+#[derive(Debug, Clone, Default)]
+pub struct TestPersistentOffchainDB {
+	persistent: Arc<RwLock<InMemOffchainStorage>>,
+}
+
+impl TestPersistentOffchainDB {
+	const PREFIX: &'static [u8] = b"";
+
+	/// Create a new and empty offchain storage db for persistent items
+	pub fn new() -> Self {
+		Self { persistent: Arc::new(RwLock::new(InMemOffchainStorage::default())) }
+	}
+
+	/// Apply a set of off-chain changes directly to the test backend
+	pub fn apply_offchain_changes(
+		&mut self,
+		changes: impl Iterator<Item = ((Vec<u8>, Vec<u8>), OffchainOverlayedChange)>,
+	) {
+		let mut me = self.persistent.write();
+		for ((_prefix, key), value_operation) in changes {
+			match value_operation {
+				OffchainOverlayedChange::SetValue(val) =>
+					me.set(Self::PREFIX, key.as_slice(), val.as_slice()),
+				OffchainOverlayedChange::Remove => me.remove(Self::PREFIX, key.as_slice()),
+			}
+		}
+	}
+
+	/// Retrieve a key from the test backend.
+	pub fn get(&self, key: &[u8]) -> Option<Vec<u8>> {
+		OffchainStorage::get(self, Self::PREFIX, key)
+	}
+}
+
+impl OffchainStorage for TestPersistentOffchainDB {
+	fn set(&mut self, prefix: &[u8], key: &[u8], value: &[u8]) {
+		self.persistent.write().set(prefix, key, value);
+	}
+
+	fn remove(&mut self, prefix: &[u8], key: &[u8]) {
+		self.persistent.write().remove(prefix, key);
+	}
+
+	fn get(&self, prefix: &[u8], key: &[u8]) -> Option<Vec<u8>> {
+		self.persistent.read().get(prefix, key)
+	}
+
+	fn compare_and_set(
+		&mut self,
+		prefix: &[u8],
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool {
+		self.persistent.write().compare_and_set(prefix, key, old_value, new_value)
+	}
+}
+
+/// Internal state of the externalities.
+///
+/// This can be used in tests to respond or assert stuff about interactions.
+#[derive(Debug, Default)]
+pub struct OffchainState {
+	/// A list of pending requests.
+	pub requests: BTreeMap<RequestId, PendingRequest>,
+	// Queue of requests that the test is expected to perform (in order).
+	expected_requests: VecDeque<PendingRequest>,
+	/// Persistent local storage
+	pub persistent_storage: TestPersistentOffchainDB,
+	/// Local storage
+	pub local_storage: InMemOffchainStorage,
+	/// A supposedly random seed.
+	pub seed: [u8; 32],
+	/// A timestamp simulating the current time.
+	pub timestamp: Timestamp,
+}
+
+impl OffchainState {
+	/// Asserts that pending request has been submitted and fills it's response.
+	pub fn fulfill_pending_request(
+		&mut self,
+		id: u16,
+		expected: PendingRequest,
+		response: impl Into<Vec<u8>>,
+		response_headers: impl IntoIterator<Item = (String, String)>,
+	) {
+		match self.requests.get_mut(&RequestId(id)) {
+			None => {
+				panic!("Missing pending request: {:?}.\n\nAll: {:?}", id, self.requests);
+			},
+			Some(req) => {
+				assert_eq!(*req, expected);
+				req.response = Some(response.into());
+				req.response_headers = response_headers.into_iter().collect();
+			},
+		}
+	}
+
+	fn fulfill_expected(&mut self, id: u16) {
+		if let Some(mut req) = self.expected_requests.pop_back() {
+			let response = req.response.take().expect("Response checked when added.");
+			let headers = std::mem::take(&mut req.response_headers);
+			self.fulfill_pending_request(id, req, response, headers);
+		}
+	}
+
+	/// Add expected HTTP request.
+	///
+	/// This method can be used to initialize expected HTTP requests and their responses
+	/// before running the actual code that utilizes them (for instance before calling into
+	/// runtime). Expected request has to be fulfilled before this struct is dropped,
+	/// the `response` and `response_headers` fields will be used to return results to the callers.
+	/// Requests are expected to be performed in the insertion order.
+	pub fn expect_request(&mut self, expected: PendingRequest) {
+		if expected.response.is_none() {
+			panic!("Expected request needs to have a response.");
+		}
+		self.expected_requests.push_front(expected);
+	}
+}
+
+impl Drop for OffchainState {
+	fn drop(&mut self) {
+		// If we panic! while we are already in a panic, the test dies with an illegal instruction.
+		if !self.expected_requests.is_empty() && !std::thread::panicking() {
+			panic!("Unfulfilled expected requests: {:?}", self.expected_requests);
+		}
+	}
+}
+
+/// Implementation of offchain externalities used for tests.
+#[derive(Clone, Default, Debug)]
+pub struct TestOffchainExt(pub Arc<RwLock<OffchainState>>);
+
+impl TestOffchainExt {
+	/// Create new `TestOffchainExt` and a reference to the internal state.
+	pub fn new() -> (Self, Arc<RwLock<OffchainState>>) {
+		let ext = Self::default();
+		let state = ext.0.clone();
+		(ext, state)
+	}
+
+	/// Create new `TestOffchainExt` and a reference to the internal state.
+	pub fn with_offchain_db(
+		offchain_db: TestPersistentOffchainDB,
+	) -> (Self, Arc<RwLock<OffchainState>>) {
+		let (ext, state) = Self::new();
+		ext.0.write().persistent_storage = offchain_db;
+		(ext, state)
+	}
+}
+
+impl offchain::Externalities for TestOffchainExt {
+	fn is_validator(&self) -> bool {
+		true
+	}
+
+	fn network_state(&self) -> Result<OpaqueNetworkState, ()> {
+		Ok(OpaqueNetworkState { peer_id: Default::default(), external_addresses: vec![] })
+	}
+
+	fn timestamp(&mut self) -> Timestamp {
+		self.0.read().timestamp
+	}
+
+	fn sleep_until(&mut self, deadline: Timestamp) {
+		self.0.write().timestamp = deadline;
+	}
+
+	fn random_seed(&mut self) -> [u8; 32] {
+		self.0.read().seed
+	}
+
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<RequestId, ()> {
+		let mut state = self.0.write();
+		let id = RequestId(state.requests.len() as u16);
+		state.requests.insert(
+			id,
+			PendingRequest {
+				method: method.into(),
+				uri: uri.into(),
+				meta: meta.into(),
+				..Default::default()
+			},
+		);
+		Ok(id)
+	}
+
+	fn http_request_add_header(
+		&mut self,
+		request_id: RequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
+		let mut state = self.0.write();
+		if let Some(req) = state.requests.get_mut(&request_id) {
+			req.headers.push((name.into(), value.into()));
+			Ok(())
+		} else {
+			Err(())
+		}
+	}
+
+	fn http_request_write_body(
+		&mut self,
+		request_id: RequestId,
+		chunk: &[u8],
+		_deadline: Option<Timestamp>,
+	) -> Result<(), HttpError> {
+		let mut state = self.0.write();
+
+		let sent = {
+			let req = state.requests.get_mut(&request_id).ok_or(HttpError::IoError)?;
+			req.body.extend(chunk);
+			if chunk.is_empty() {
+				req.sent = true;
+			}
+			req.sent
+		};
+
+		if sent {
+			state.fulfill_expected(request_id.0);
+		}
+
+		Ok(())
+	}
+
+	fn http_response_wait(
+		&mut self,
+		ids: &[RequestId],
+		_deadline: Option<Timestamp>,
+	) -> Vec<RequestStatus> {
+		let state = self.0.read();
+
+		ids.iter()
+			.map(|id| match state.requests.get(id) {
+				Some(req) if req.response.is_none() => {
+					panic!("No `response` provided for request with id: {:?}", id)
+				},
+				None => RequestStatus::Invalid,
+				_ => RequestStatus::Finished(200),
+			})
+			.collect()
+	}
+
+	fn http_response_headers(&mut self, request_id: RequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
+		let state = self.0.read();
+		if let Some(req) = state.requests.get(&request_id) {
+			req.response_headers
+				.clone()
+				.into_iter()
+				.map(|(k, v)| (k.into_bytes(), v.into_bytes()))
+				.collect()
+		} else {
+			Default::default()
+		}
+	}
+
+	fn http_response_read_body(
+		&mut self,
+		request_id: RequestId,
+		buffer: &mut [u8],
+		_deadline: Option<Timestamp>,
+	) -> Result<usize, HttpError> {
+		let mut state = self.0.write();
+		if let Some(req) = state.requests.get_mut(&request_id) {
+			let response = req
+				.response
+				.as_mut()
+				.unwrap_or_else(|| panic!("No response provided for request: {:?}", request_id));
+
+			if req.read >= response.len() {
+				// Remove the pending request as per spec.
+				state.requests.remove(&request_id);
+				Ok(0)
+			} else {
+				let read = std::cmp::min(buffer.len(), response[req.read..].len());
+				buffer[0..read].copy_from_slice(&response[req.read..req.read + read]);
+				req.read += read;
+				Ok(read)
+			}
+		} else {
+			Err(HttpError::IoError)
+		}
+	}
+
+	fn set_authorized_nodes(&mut self, _nodes: Vec<OpaquePeerId>, _authorized_only: bool) {
+		unimplemented!()
+	}
+}
+
+impl offchain::DbExternalities for TestOffchainExt {
+	fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8]) {
+		let mut state = self.0.write();
+		match kind {
+			StorageKind::LOCAL => state.local_storage.set(b"", key, value),
+			StorageKind::PERSISTENT => state.persistent_storage.set(b"", key, value),
+		};
+	}
+
+	fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8]) {
+		let mut state = self.0.write();
+		match kind {
+			StorageKind::LOCAL => state.local_storage.remove(b"", key),
+			StorageKind::PERSISTENT => state.persistent_storage.remove(b"", key),
+		};
+	}
+
+	fn local_storage_compare_and_set(
+		&mut self,
+		kind: StorageKind,
+		key: &[u8],
+		old_value: Option<&[u8]>,
+		new_value: &[u8],
+	) -> bool {
+		let mut state = self.0.write();
+		match kind {
+			StorageKind::LOCAL =>
+				state.local_storage.compare_and_set(b"", key, old_value, new_value),
+			StorageKind::PERSISTENT =>
+				state.persistent_storage.compare_and_set(b"", key, old_value, new_value),
+		}
+	}
+
+	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>> {
+		let state = self.0.read();
+		match kind {
+			StorageKind::LOCAL => state.local_storage.get(TestPersistentOffchainDB::PREFIX, key),
+			StorageKind::PERSISTENT => state.persistent_storage.get(key),
+		}
+	}
+}
+
+/// The internal state of the fake transaction pool.
+#[derive(Default)]
+pub struct PoolState {
+	/// A vector of transactions submitted from the runtime.
+	pub transactions: Vec<Vec<u8>>,
+}
+
+/// Implementation of transaction pool used for test.
+///
+/// Note that this implementation does not verify correctness
+/// of sent extrinsics. It's meant to be used in contexts
+/// where an actual runtime is not known.
+///
+/// It's advised to write integration tests that include the
+/// actual transaction pool to make sure the produced
+/// transactions are valid.
+#[derive(Default)]
+pub struct TestTransactionPoolExt(Arc<RwLock<PoolState>>);
+
+impl TestTransactionPoolExt {
+	/// Create new `TestTransactionPoolExt` and a reference to the internal state.
+	pub fn new() -> (Self, Arc<RwLock<PoolState>>) {
+		let ext = Self::default();
+		let state = ext.0.clone();
+		(ext, state)
+	}
+}
+
+impl TransactionPool for TestTransactionPoolExt {
+	fn submit_transaction(&mut self, extrinsic: Vec<u8>) -> Result<(), ()> {
+		self.0.write().transactions.push(extrinsic);
+		Ok(())
+	}
+}
diff --git a/substrate/primitives/core/src/sr25519.rs b/substrate/primitives/core/src/sr25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ffa52ef97d1f58f3af2b2f2c62015c411e464ae6
--- /dev/null
+++ b/substrate/primitives/core/src/sr25519.rs
@@ -0,0 +1,1147 @@
+// 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.
+
+//! Simple sr25519 (Schnorr-Ristretto) API.
+//!
+//! Note: `CHAIN_CODE_LENGTH` must be equal to `crate::crypto::JUNCTION_ID_LEN`
+//! for this to work.
+#[cfg(any(feature = "full_crypto", feature = "serde"))]
+use crate::crypto::DeriveJunction;
+#[cfg(feature = "serde")]
+use crate::crypto::Ss58Codec;
+#[cfg(feature = "full_crypto")]
+use crate::crypto::{DeriveError, Pair as TraitPair, SecretStringError};
+#[cfg(feature = "full_crypto")]
+use schnorrkel::{
+	derive::CHAIN_CODE_LENGTH, signing_context, ExpansionMode, Keypair, MiniSecretKey, SecretKey,
+};
+#[cfg(any(feature = "full_crypto", feature = "serde"))]
+use schnorrkel::{
+	derive::{ChainCode, Derivation},
+	PublicKey,
+};
+use sp_std::vec::Vec;
+
+use crate::{
+	crypto::{
+		ByteArray, CryptoType, CryptoTypeId, Derive, FromEntropy, Public as TraitPublic,
+		UncheckedFrom,
+	},
+	hash::{H256, H512},
+};
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_std::ops::Deref;
+
+#[cfg(feature = "full_crypto")]
+use schnorrkel::keys::{MINI_SECRET_KEY_LENGTH, SECRET_KEY_LENGTH};
+#[cfg(feature = "serde")]
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+use sp_runtime_interface::pass_by::PassByInner;
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::alloc::{format, string::String};
+
+// signing context
+#[cfg(feature = "full_crypto")]
+const SIGNING_CTX: &[u8] = b"substrate";
+
+/// An identifier used to match public keys against sr25519 keys
+pub const CRYPTO_ID: CryptoTypeId = CryptoTypeId(*b"sr25");
+
+/// An Schnorrkel/Ristretto x25519 ("sr25519") public key.
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(
+	PartialEq,
+	Eq,
+	PartialOrd,
+	Ord,
+	Clone,
+	Copy,
+	Encode,
+	Decode,
+	PassByInner,
+	MaxEncodedLen,
+	TypeInfo,
+)]
+pub struct Public(pub [u8; 32]);
+
+/// An Schnorrkel/Ristretto x25519 ("sr25519") key pair.
+#[cfg(feature = "full_crypto")]
+pub struct Pair(Keypair);
+
+#[cfg(feature = "full_crypto")]
+impl Clone for Pair {
+	fn clone(&self) -> Self {
+		Pair(schnorrkel::Keypair {
+			public: self.0.public,
+			secret: schnorrkel::SecretKey::from_bytes(&self.0.secret.to_bytes()[..])
+				.expect("key is always the correct size; qed"),
+		})
+	}
+}
+
+impl FromEntropy for Public {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		let mut result = Self([0u8; 32]);
+		input.read(&mut result.0[..])?;
+		Ok(result)
+	}
+}
+
+impl AsRef<[u8; 32]> for Public {
+	fn as_ref(&self) -> &[u8; 32] {
+		&self.0
+	}
+}
+
+impl AsRef<[u8]> for Public {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Public {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+impl Deref for Public {
+	type Target = [u8];
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl From<Public> for [u8; 32] {
+	fn from(x: Public) -> [u8; 32] {
+		x.0
+	}
+}
+
+impl From<Public> for H256 {
+	fn from(x: Public) -> H256 {
+		x.0.into()
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::str::FromStr for Public {
+	type Err = crate::crypto::PublicError;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		Self::from_ss58check(s)
+	}
+}
+
+impl TryFrom<&[u8]> for Public {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() != Self::LEN {
+			return Err(())
+		}
+		let mut r = [0u8; 32];
+		r.copy_from_slice(data);
+		Ok(Self::unchecked_from(r))
+	}
+}
+
+impl UncheckedFrom<[u8; 32]> for Public {
+	fn unchecked_from(x: [u8; 32]) -> Self {
+		Public::from_raw(x)
+	}
+}
+
+impl UncheckedFrom<H256> for Public {
+	fn unchecked_from(x: H256) -> Self {
+		Public::from_h256(x)
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for Public {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}", self.to_ss58check())
+	}
+}
+
+impl sp_std::fmt::Debug for Public {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		let s = self.to_ss58check();
+		write!(f, "{} ({}...)", crate::hexdisplay::HexDisplay::from(&self.0), &s[0..8])
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Public {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&self.to_ss58check())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Public {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		Public::from_ss58check(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+/// An Schnorrkel/Ristretto x25519 ("sr25519") signature.
+#[cfg_attr(feature = "full_crypto", derive(Hash))]
+#[derive(Encode, Decode, MaxEncodedLen, PassByInner, TypeInfo, PartialEq, Eq)]
+pub struct Signature(pub [u8; 64]);
+
+impl TryFrom<&[u8]> for Signature {
+	type Error = ();
+
+	fn try_from(data: &[u8]) -> Result<Self, Self::Error> {
+		if data.len() == 64 {
+			let mut inner = [0u8; 64];
+			inner.copy_from_slice(data);
+			Ok(Signature(inner))
+		} else {
+			Err(())
+		}
+	}
+}
+
+#[cfg(feature = "serde")]
+impl Serialize for Signature {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		serializer.serialize_str(&array_bytes::bytes2hex("", self))
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> Deserialize<'de> for Signature {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: Deserializer<'de>,
+	{
+		let signature_hex = array_bytes::hex2bytes(&String::deserialize(deserializer)?)
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))?;
+		Signature::try_from(signature_hex.as_ref())
+			.map_err(|e| de::Error::custom(format!("{:?}", e)))
+	}
+}
+
+impl Clone for Signature {
+	fn clone(&self) -> Self {
+		let mut r = [0u8; 64];
+		r.copy_from_slice(&self.0[..]);
+		Signature(r)
+	}
+}
+
+impl From<Signature> for [u8; 64] {
+	fn from(v: Signature) -> [u8; 64] {
+		v.0
+	}
+}
+
+impl From<Signature> for H512 {
+	fn from(v: Signature) -> H512 {
+		H512::from(v.0)
+	}
+}
+
+impl AsRef<[u8; 64]> for Signature {
+	fn as_ref(&self) -> &[u8; 64] {
+		&self.0
+	}
+}
+
+impl AsRef<[u8]> for Signature {
+	fn as_ref(&self) -> &[u8] {
+		&self.0[..]
+	}
+}
+
+impl AsMut<[u8]> for Signature {
+	fn as_mut(&mut self) -> &mut [u8] {
+		&mut self.0[..]
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl From<schnorrkel::Signature> for Signature {
+	fn from(s: schnorrkel::Signature) -> Signature {
+		Signature(s.to_bytes())
+	}
+}
+
+impl sp_std::fmt::Debug for Signature {
+	#[cfg(feature = "std")]
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "{}", crate::hexdisplay::HexDisplay::from(&self.0))
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+impl UncheckedFrom<[u8; 64]> for Signature {
+	fn unchecked_from(data: [u8; 64]) -> Signature {
+		Signature(data)
+	}
+}
+
+impl Signature {
+	/// A new instance from the given 64-byte `data`.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use
+	/// it if you are certain that the array actually is a signature, or if you
+	/// immediately verify the signature.  All functions that verify signatures
+	/// will fail if the `Signature` is not actually a valid signature.
+	pub fn from_raw(data: [u8; 64]) -> Signature {
+		Signature(data)
+	}
+
+	/// A new instance from the given slice that should be 64 bytes long.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use it if
+	/// you are certain that the array actually is a signature. GIGO!
+	pub fn from_slice(data: &[u8]) -> Option<Self> {
+		if data.len() != 64 {
+			return None
+		}
+		let mut r = [0u8; 64];
+		r.copy_from_slice(data);
+		Some(Signature(r))
+	}
+
+	/// A new instance from an H512.
+	///
+	/// NOTE: No checking goes on to ensure this is a real signature. Only use it if
+	/// you are certain that the array actually is a signature. GIGO!
+	pub fn from_h512(v: H512) -> Signature {
+		Signature(v.into())
+	}
+}
+
+impl Derive for Public {
+	/// Derive a child key from a series of given junctions.
+	///
+	/// `None` if there are any hard junctions in there.
+	#[cfg(feature = "serde")]
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(&self, path: Iter) -> Option<Public> {
+		let mut acc = PublicKey::from_bytes(self.as_ref()).ok()?;
+		for j in path {
+			match j {
+				DeriveJunction::Soft(cc) => acc = acc.derived_key_simple(ChainCode(cc), &[]).0,
+				DeriveJunction::Hard(_cc) => return None,
+			}
+		}
+		Some(Self(acc.to_bytes()))
+	}
+}
+
+impl Public {
+	/// A new instance from the given 32-byte `data`.
+	///
+	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if
+	/// you are certain that the array actually is a pubkey. GIGO!
+	pub fn from_raw(data: [u8; 32]) -> Self {
+		Public(data)
+	}
+
+	/// A new instance from an H256.
+	///
+	/// NOTE: No checking goes on to ensure this is a real public key. Only use it if
+	/// you are certain that the array actually is a pubkey. GIGO!
+	pub fn from_h256(x: H256) -> Self {
+		Public(x.into())
+	}
+
+	/// Return a slice filled with raw data.
+	pub fn as_array_ref(&self) -> &[u8; 32] {
+		self.as_ref()
+	}
+}
+
+impl ByteArray for Public {
+	const LEN: usize = 32;
+}
+
+impl TraitPublic for Public {}
+
+#[cfg(feature = "std")]
+impl From<MiniSecretKey> for Pair {
+	fn from(sec: MiniSecretKey) -> Pair {
+		Pair(sec.expand_to_keypair(ExpansionMode::Ed25519))
+	}
+}
+
+#[cfg(feature = "std")]
+impl From<SecretKey> for Pair {
+	fn from(sec: SecretKey) -> Pair {
+		Pair(Keypair::from(sec))
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl From<schnorrkel::Keypair> for Pair {
+	fn from(p: schnorrkel::Keypair) -> Pair {
+		Pair(p)
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl From<Pair> for schnorrkel::Keypair {
+	fn from(p: Pair) -> schnorrkel::Keypair {
+		p.0
+	}
+}
+
+#[cfg(feature = "full_crypto")]
+impl AsRef<schnorrkel::Keypair> for Pair {
+	fn as_ref(&self) -> &schnorrkel::Keypair {
+		&self.0
+	}
+}
+
+/// Derive a single hard junction.
+#[cfg(feature = "full_crypto")]
+fn derive_hard_junction(secret: &SecretKey, cc: &[u8; CHAIN_CODE_LENGTH]) -> MiniSecretKey {
+	secret.hard_derive_mini_secret_key(Some(ChainCode(*cc)), b"").0
+}
+
+/// The raw secret seed, which can be used to recreate the `Pair`.
+#[cfg(feature = "full_crypto")]
+type Seed = [u8; MINI_SECRET_KEY_LENGTH];
+
+#[cfg(feature = "full_crypto")]
+impl TraitPair for Pair {
+	type Public = Public;
+	type Seed = Seed;
+	type Signature = Signature;
+
+	/// Get the public key.
+	fn public(&self) -> Public {
+		let mut pk = [0u8; 32];
+		pk.copy_from_slice(&self.0.public.to_bytes());
+		Public(pk)
+	}
+
+	/// Make a new key pair from raw secret seed material.
+	///
+	/// This is generated using schnorrkel's Mini-Secret-Keys.
+	///
+	/// A `MiniSecretKey` is literally what Ed25519 calls a `SecretKey`, which is just 32 random
+	/// bytes.
+	fn from_seed_slice(seed: &[u8]) -> Result<Pair, SecretStringError> {
+		match seed.len() {
+			MINI_SECRET_KEY_LENGTH => Ok(Pair(
+				MiniSecretKey::from_bytes(seed)
+					.map_err(|_| SecretStringError::InvalidSeed)?
+					.expand_to_keypair(ExpansionMode::Ed25519),
+			)),
+			SECRET_KEY_LENGTH => Ok(Pair(
+				SecretKey::from_bytes(seed)
+					.map_err(|_| SecretStringError::InvalidSeed)?
+					.to_keypair(),
+			)),
+			_ => Err(SecretStringError::InvalidSeedLength),
+		}
+	}
+
+	fn derive<Iter: Iterator<Item = DeriveJunction>>(
+		&self,
+		path: Iter,
+		seed: Option<Seed>,
+	) -> Result<(Pair, Option<Seed>), DeriveError> {
+		let seed = seed
+			.and_then(|s| MiniSecretKey::from_bytes(&s).ok())
+			.filter(|msk| msk.expand(ExpansionMode::Ed25519) == self.0.secret);
+
+		let init = self.0.secret.clone();
+		let (result, seed) = path.fold((init, seed), |(acc, acc_seed), j| match (j, acc_seed) {
+			(DeriveJunction::Soft(cc), _) => (acc.derived_key_simple(ChainCode(cc), &[]).0, None),
+			(DeriveJunction::Hard(cc), maybe_seed) => {
+				let seed = derive_hard_junction(&acc, &cc);
+				(seed.expand(ExpansionMode::Ed25519), maybe_seed.map(|_| seed))
+			},
+		});
+		Ok((Self(result.into()), seed.map(|s| MiniSecretKey::to_bytes(&s))))
+	}
+
+	fn sign(&self, message: &[u8]) -> Signature {
+		let context = signing_context(SIGNING_CTX);
+		self.0.sign(context.bytes(message)).into()
+	}
+
+	fn verify<M: AsRef<[u8]>>(sig: &Signature, message: M, pubkey: &Public) -> bool {
+		let Ok(signature) = schnorrkel::Signature::from_bytes(sig.as_ref()) else { return false };
+		let Ok(public) = PublicKey::from_bytes(pubkey.as_ref()) else { return false };
+		public.verify_simple(SIGNING_CTX, message.as_ref(), &signature).is_ok()
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		self.0.secret.to_bytes().to_vec()
+	}
+}
+
+#[cfg(feature = "std")]
+impl Pair {
+	/// Verify a signature on a message. Returns `true` if the signature is good.
+	/// Supports old 0.1.1 deprecated signatures and should be used only for backward
+	/// compatibility.
+	pub fn verify_deprecated<M: AsRef<[u8]>>(sig: &Signature, message: M, pubkey: &Public) -> bool {
+		// Match both schnorrkel 0.1.1 and 0.8.0+ signatures, supporting both wallets
+		// that have not been upgraded and those that have.
+		match PublicKey::from_bytes(pubkey.as_ref()) {
+			Ok(pk) => pk
+				.verify_simple_preaudit_deprecated(SIGNING_CTX, message.as_ref(), &sig.0[..])
+				.is_ok(),
+			Err(_) => false,
+		}
+	}
+}
+
+impl CryptoType for Public {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+impl CryptoType for Signature {
+	#[cfg(feature = "full_crypto")]
+	type Pair = Pair;
+}
+
+#[cfg(feature = "full_crypto")]
+impl CryptoType for Pair {
+	type Pair = Pair;
+}
+
+/// Schnorrkel VRF related types and operations.
+pub mod vrf {
+	use super::*;
+	#[cfg(feature = "full_crypto")]
+	use crate::crypto::VrfSecret;
+	use crate::crypto::{VrfCrypto, VrfPublic};
+	use schnorrkel::{
+		errors::MultiSignatureStage,
+		vrf::{VRF_OUTPUT_LENGTH, VRF_PROOF_LENGTH},
+		SignatureError,
+	};
+
+	const DEFAULT_EXTRA_DATA_LABEL: &[u8] = b"VRF";
+
+	/// Transcript ready to be used for VRF related operations.
+	#[derive(Clone)]
+	pub struct VrfTranscript(pub merlin::Transcript);
+
+	impl VrfTranscript {
+		/// Build a new transcript instance.
+		///
+		/// Each `data` element is a tuple `(domain, message)` used to build the transcript.
+		pub fn new(label: &'static [u8], data: &[(&'static [u8], &[u8])]) -> Self {
+			let mut transcript = merlin::Transcript::new(label);
+			data.iter().for_each(|(l, b)| transcript.append_message(l, b));
+			VrfTranscript(transcript)
+		}
+
+		/// Map transcript to `VrfSignData`.
+		pub fn into_sign_data(self) -> VrfSignData {
+			self.into()
+		}
+	}
+
+	/// VRF input.
+	///
+	/// Technically a transcript used by the Fiat-Shamir transform.
+	pub type VrfInput = VrfTranscript;
+
+	/// VRF input ready to be used for VRF sign and verify operations.
+	#[derive(Clone)]
+	pub struct VrfSignData {
+		/// Transcript data contributing to VRF output.
+		pub(super) transcript: VrfTranscript,
+		/// Extra transcript data to be signed by the VRF.
+		pub(super) extra: Option<VrfTranscript>,
+	}
+
+	impl From<VrfInput> for VrfSignData {
+		fn from(transcript: VrfInput) -> Self {
+			VrfSignData { transcript, extra: None }
+		}
+	}
+
+	// Get a reference to the inner VRF input.
+	impl AsRef<VrfInput> for VrfSignData {
+		fn as_ref(&self) -> &VrfInput {
+			&self.transcript
+		}
+	}
+
+	impl VrfSignData {
+		/// Build a new instance ready to be used for VRF signer and verifier.
+		///
+		/// `input` will contribute to the VRF output bytes.
+		pub fn new(input: VrfTranscript) -> Self {
+			input.into()
+		}
+
+		/// Add some extra data to be signed.
+		///
+		/// `extra` will not contribute to the VRF output bytes.
+		pub fn with_extra(mut self, extra: VrfTranscript) -> Self {
+			self.extra = Some(extra);
+			self
+		}
+	}
+
+	/// VRF signature data
+	#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo)]
+	pub struct VrfSignature {
+		/// VRF output.
+		pub output: VrfOutput,
+		/// VRF proof.
+		pub proof: VrfProof,
+	}
+
+	/// VRF output type suitable for schnorrkel operations.
+	#[derive(Clone, Debug, PartialEq, Eq)]
+	pub struct VrfOutput(pub schnorrkel::vrf::VRFOutput);
+
+	impl Encode for VrfOutput {
+		fn encode(&self) -> Vec<u8> {
+			self.0.as_bytes().encode()
+		}
+	}
+
+	impl Decode for VrfOutput {
+		fn decode<R: codec::Input>(i: &mut R) -> Result<Self, codec::Error> {
+			let decoded = <[u8; VRF_OUTPUT_LENGTH]>::decode(i)?;
+			Ok(Self(schnorrkel::vrf::VRFOutput::from_bytes(&decoded).map_err(convert_error)?))
+		}
+	}
+
+	impl MaxEncodedLen for VrfOutput {
+		fn max_encoded_len() -> usize {
+			<[u8; VRF_OUTPUT_LENGTH]>::max_encoded_len()
+		}
+	}
+
+	impl TypeInfo for VrfOutput {
+		type Identity = [u8; VRF_OUTPUT_LENGTH];
+
+		fn type_info() -> scale_info::Type {
+			Self::Identity::type_info()
+		}
+	}
+
+	/// VRF proof type suitable for schnorrkel operations.
+	#[derive(Clone, Debug, PartialEq, Eq)]
+	pub struct VrfProof(pub schnorrkel::vrf::VRFProof);
+
+	impl Encode for VrfProof {
+		fn encode(&self) -> Vec<u8> {
+			self.0.to_bytes().encode()
+		}
+	}
+
+	impl Decode for VrfProof {
+		fn decode<R: codec::Input>(i: &mut R) -> Result<Self, codec::Error> {
+			let decoded = <[u8; VRF_PROOF_LENGTH]>::decode(i)?;
+			Ok(Self(schnorrkel::vrf::VRFProof::from_bytes(&decoded).map_err(convert_error)?))
+		}
+	}
+
+	impl MaxEncodedLen for VrfProof {
+		fn max_encoded_len() -> usize {
+			<[u8; VRF_PROOF_LENGTH]>::max_encoded_len()
+		}
+	}
+
+	impl TypeInfo for VrfProof {
+		type Identity = [u8; VRF_PROOF_LENGTH];
+
+		fn type_info() -> scale_info::Type {
+			Self::Identity::type_info()
+		}
+	}
+
+	#[cfg(feature = "full_crypto")]
+	impl VrfCrypto for Pair {
+		type VrfInput = VrfTranscript;
+		type VrfOutput = VrfOutput;
+		type VrfSignData = VrfSignData;
+		type VrfSignature = VrfSignature;
+	}
+
+	#[cfg(feature = "full_crypto")]
+	impl VrfSecret for Pair {
+		fn vrf_sign(&self, data: &Self::VrfSignData) -> Self::VrfSignature {
+			let inout = self.0.vrf_create_hash(data.transcript.0.clone());
+
+			let extra = data
+				.extra
+				.as_ref()
+				.map(|e| e.0.clone())
+				.unwrap_or_else(|| merlin::Transcript::new(DEFAULT_EXTRA_DATA_LABEL));
+
+			let proof = self.0.dleq_proove(extra, &inout, true).0;
+
+			VrfSignature { output: VrfOutput(inout.to_output()), proof: VrfProof(proof) }
+		}
+
+		fn vrf_output(&self, input: &Self::VrfInput) -> Self::VrfOutput {
+			let output = self.0.vrf_create_hash(input.0.clone()).to_output();
+			VrfOutput(output)
+		}
+	}
+
+	impl VrfCrypto for Public {
+		type VrfInput = VrfTranscript;
+		type VrfOutput = VrfOutput;
+		type VrfSignData = VrfSignData;
+		type VrfSignature = VrfSignature;
+	}
+
+	impl VrfPublic for Public {
+		fn vrf_verify(&self, data: &Self::VrfSignData, signature: &Self::VrfSignature) -> bool {
+			let do_verify = || {
+				let public = schnorrkel::PublicKey::from_bytes(self)?;
+
+				let inout =
+					signature.output.0.attach_input_hash(&public, data.transcript.0.clone())?;
+
+				let extra = data
+					.extra
+					.as_ref()
+					.map(|e| e.0.clone())
+					.unwrap_or_else(|| merlin::Transcript::new(DEFAULT_EXTRA_DATA_LABEL));
+
+				public.dleq_verify(extra, &inout, &signature.proof.0, true)
+			};
+			do_verify().is_ok()
+		}
+	}
+
+	fn convert_error(e: SignatureError) -> codec::Error {
+		use MultiSignatureStage::*;
+		use SignatureError::*;
+		match e {
+			EquationFalse => "Signature error: `EquationFalse`".into(),
+			PointDecompressionError => "Signature error: `PointDecompressionError`".into(),
+			ScalarFormatError => "Signature error: `ScalarFormatError`".into(),
+			NotMarkedSchnorrkel => "Signature error: `NotMarkedSchnorrkel`".into(),
+			BytesLengthError { .. } => "Signature error: `BytesLengthError`".into(),
+			MuSigAbsent { musig_stage: Commitment } =>
+				"Signature error: `MuSigAbsent` at stage `Commitment`".into(),
+			MuSigAbsent { musig_stage: Reveal } =>
+				"Signature error: `MuSigAbsent` at stage `Reveal`".into(),
+			MuSigAbsent { musig_stage: Cosignature } =>
+				"Signature error: `MuSigAbsent` at stage `Commitment`".into(),
+			MuSigInconsistent { musig_stage: Commitment, duplicate: true } =>
+				"Signature error: `MuSigInconsistent` at stage `Commitment` on duplicate".into(),
+			MuSigInconsistent { musig_stage: Commitment, duplicate: false } =>
+				"Signature error: `MuSigInconsistent` at stage `Commitment` on not duplicate".into(),
+			MuSigInconsistent { musig_stage: Reveal, duplicate: true } =>
+				"Signature error: `MuSigInconsistent` at stage `Reveal` on duplicate".into(),
+			MuSigInconsistent { musig_stage: Reveal, duplicate: false } =>
+				"Signature error: `MuSigInconsistent` at stage `Reveal` on not duplicate".into(),
+			MuSigInconsistent { musig_stage: Cosignature, duplicate: true } =>
+				"Signature error: `MuSigInconsistent` at stage `Cosignature` on duplicate".into(),
+			MuSigInconsistent { musig_stage: Cosignature, duplicate: false } =>
+				"Signature error: `MuSigInconsistent` at stage `Cosignature` on not duplicate"
+					.into(),
+		}
+	}
+
+	#[cfg(feature = "full_crypto")]
+	impl Pair {
+		/// Generate output bytes from the given VRF configuration.
+		pub fn make_bytes<const N: usize>(&self, context: &[u8], input: &VrfInput) -> [u8; N]
+		where
+			[u8; N]: Default,
+		{
+			let inout = self.0.vrf_create_hash(input.0.clone());
+			inout.make_bytes::<[u8; N]>(context)
+		}
+	}
+
+	impl Public {
+		/// Generate output bytes from the given VRF configuration.
+		pub fn make_bytes<const N: usize>(
+			&self,
+			context: &[u8],
+			input: &VrfInput,
+			output: &VrfOutput,
+		) -> Result<[u8; N], codec::Error>
+		where
+			[u8; N]: Default,
+		{
+			let pubkey = schnorrkel::PublicKey::from_bytes(&self.0).map_err(convert_error)?;
+			let inout =
+				output.0.attach_input_hash(&pubkey, input.0.clone()).map_err(convert_error)?;
+			Ok(inout.make_bytes::<[u8; N]>(context))
+		}
+	}
+
+	impl VrfOutput {
+		/// Generate output bytes from the given VRF configuration.
+		pub fn make_bytes<const N: usize>(
+			&self,
+			context: &[u8],
+			input: &VrfInput,
+			public: &Public,
+		) -> Result<[u8; N], codec::Error>
+		where
+			[u8; N]: Default,
+		{
+			public.make_bytes(context, input, self)
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{vrf::*, *};
+	use crate::crypto::{Ss58Codec, VrfPublic, VrfSecret, DEV_ADDRESS, DEV_PHRASE};
+	use serde_json;
+
+	#[test]
+	fn derive_soft_known_pair_should_work() {
+		let pair = Pair::from_string(&format!("{}/Alice", DEV_PHRASE), None).unwrap();
+		// known address of DEV_PHRASE with 1.1
+		let known = array_bytes::hex2bytes_unchecked(
+			"d6c71059dbbe9ad2b0ed3f289738b800836eb425544ce694825285b958ca755e",
+		);
+		assert_eq!(pair.public().to_raw_vec(), known);
+	}
+
+	#[test]
+	fn derive_hard_known_pair_should_work() {
+		let pair = Pair::from_string(&format!("{}//Alice", DEV_PHRASE), None).unwrap();
+		// known address of DEV_PHRASE with 1.1
+		let known = array_bytes::hex2bytes_unchecked(
+			"d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+		);
+		assert_eq!(pair.public().to_raw_vec(), known);
+	}
+
+	#[test]
+	fn verify_known_old_message_should_work() {
+		let public = Public::from_raw(array_bytes::hex2array_unchecked(
+			"b4bfa1f7a5166695eb75299fd1c4c03ea212871c342f2c5dfea0902b2c246918",
+		));
+		// signature generated by the 1.1 version with the same ^^ public key.
+		let signature = Signature::from_raw(array_bytes::hex2array_unchecked(
+			"5a9755f069939f45d96aaf125cf5ce7ba1db998686f87f2fb3cbdea922078741a73891ba265f70c31436e18a9acd14d189d73c12317ab6c313285cd938453202"
+		));
+		let message = b"Verifying that I am the owner of 5G9hQLdsKQswNPgB499DeA5PkFBbgkLPJWkkS6FAM6xGQ8xD. Hash: 221455a3\n";
+		assert!(Pair::verify_deprecated(&signature, &message[..], &public));
+		assert!(!Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn default_phrase_should_be_used() {
+		assert_eq!(
+			Pair::from_string("//Alice///password", None).unwrap().public(),
+			Pair::from_string(&format!("{}//Alice", DEV_PHRASE), Some("password"))
+				.unwrap()
+				.public(),
+		);
+		assert_eq!(
+			Pair::from_string(&format!("{}/Alice", DEV_PHRASE), None)
+				.as_ref()
+				.map(Pair::public),
+			Pair::from_string("/Alice", None).as_ref().map(Pair::public)
+		);
+	}
+
+	#[test]
+	fn default_address_should_be_used() {
+		assert_eq!(
+			Public::from_string(&format!("{}/Alice", DEV_ADDRESS)),
+			Public::from_string("/Alice")
+		);
+	}
+
+	#[test]
+	fn default_phrase_should_correspond_to_default_address() {
+		assert_eq!(
+			Pair::from_string(&format!("{}/Alice", DEV_PHRASE), None).unwrap().public(),
+			Public::from_string(&format!("{}/Alice", DEV_ADDRESS)).unwrap(),
+		);
+		assert_eq!(
+			Pair::from_string("/Alice", None).unwrap().public(),
+			Public::from_string("/Alice").unwrap()
+		);
+	}
+
+	#[test]
+	fn derive_soft_should_work() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let derive_1 = pair.derive(Some(DeriveJunction::soft(1)).into_iter(), None).unwrap().0;
+		let derive_1b = pair.derive(Some(DeriveJunction::soft(1)).into_iter(), None).unwrap().0;
+		let derive_2 = pair.derive(Some(DeriveJunction::soft(2)).into_iter(), None).unwrap().0;
+		assert_eq!(derive_1.public(), derive_1b.public());
+		assert_ne!(derive_1.public(), derive_2.public());
+	}
+
+	#[test]
+	fn derive_hard_should_work() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let derive_1 = pair.derive(Some(DeriveJunction::hard(1)).into_iter(), None).unwrap().0;
+		let derive_1b = pair.derive(Some(DeriveJunction::hard(1)).into_iter(), None).unwrap().0;
+		let derive_2 = pair.derive(Some(DeriveJunction::hard(2)).into_iter(), None).unwrap().0;
+		assert_eq!(derive_1.public(), derive_1b.public());
+		assert_ne!(derive_1.public(), derive_2.public());
+	}
+
+	#[test]
+	fn derive_soft_public_should_work() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let path = Some(DeriveJunction::soft(1));
+		let pair_1 = pair.derive(path.into_iter(), None).unwrap().0;
+		let public_1 = pair.public().derive(path.into_iter()).unwrap();
+		assert_eq!(pair_1.public(), public_1);
+	}
+
+	#[test]
+	fn derive_hard_public_should_fail() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let path = Some(DeriveJunction::hard(1));
+		assert!(pair.public().derive(path.into_iter()).is_none());
+	}
+
+	#[test]
+	fn sr_test_vector_should_work() {
+		let pair = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"9d61b19deffd5a60ba844af492ec2cc44449c5697b326919703bac031cae7f60",
+		));
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_raw(array_bytes::hex2array_unchecked(
+				"44a996beb1eef7bdcab976ab6d2ca26104834164ecf28fb375600576fcc6eb0f"
+			))
+		);
+		let message = b"";
+		let signature = pair.sign(message);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn generated_pair_should_work() {
+		let (pair, _) = Pair::generate();
+		let public = pair.public();
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn messed_signature_should_not_work() {
+		let (pair, _) = Pair::generate();
+		let public = pair.public();
+		let message = b"Signed payload";
+		let Signature(mut bytes) = pair.sign(&message[..]);
+		bytes[0] = !bytes[0];
+		bytes[2] = !bytes[2];
+		let signature = Signature(bytes);
+		assert!(!Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn messed_message_should_not_work() {
+		let (pair, _) = Pair::generate();
+		let public = pair.public();
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		assert!(!Pair::verify(&signature, &b"Something unimportant", &public));
+	}
+
+	#[test]
+	fn seeded_pair_should_work() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		assert_eq!(
+			public,
+			Public::from_raw(array_bytes::hex2array_unchecked(
+				"741c08a06f41c596608f6774259bd9043304adfa5d3eea62760bd9be97634d63"
+			))
+		);
+		let message = array_bytes::hex2bytes_unchecked("2f8c6129d816cf51c374bc7f08c3e63ed156cf78aefb4a6550d97b87997977ee00000000000000000200d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a4500000000000000");
+		let signature = pair.sign(&message[..]);
+		assert!(Pair::verify(&signature, &message[..], &public));
+	}
+
+	#[test]
+	fn ss58check_roundtrip_works() {
+		let (pair, _) = Pair::generate();
+		let public = pair.public();
+		let s = public.to_ss58check();
+		println!("Correct: {}", s);
+		let cmp = Public::from_ss58check(&s).unwrap();
+		assert_eq!(cmp, public);
+	}
+
+	#[test]
+	fn verify_from_old_wasm_works() {
+		// The values in this test case are compared to the output of `node-test.js` in
+		// schnorrkel-js.
+		//
+		// This is to make sure that the wasm library is compatible.
+		let pk = Pair::from_seed(&array_bytes::hex2array_unchecked(
+			"0000000000000000000000000000000000000000000000000000000000000000",
+		));
+		let public = pk.public();
+		let js_signature = Signature::from_raw(array_bytes::hex2array_unchecked(
+			"28a854d54903e056f89581c691c1f7d2ff39f8f896c9e9c22475e60902cc2b3547199e0e91fa32902028f2ca2355e8cdd16cfe19ba5e8b658c94aa80f3b81a00"
+		));
+		assert!(Pair::verify_deprecated(&js_signature, b"SUBSTRATE", &public));
+		assert!(!Pair::verify(&js_signature, b"SUBSTRATE", &public));
+	}
+
+	#[test]
+	fn signature_serialization_works() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let message = b"Something important";
+		let signature = pair.sign(&message[..]);
+		let serialized_signature = serde_json::to_string(&signature).unwrap();
+		// Signature is 64 bytes, so 128 chars + 2 quote chars
+		assert_eq!(serialized_signature.len(), 130);
+		let signature = serde_json::from_str(&serialized_signature).unwrap();
+		assert!(Pair::verify(&signature, &message[..], &pair.public()));
+	}
+
+	#[test]
+	fn signature_serialization_doesnt_panic() {
+		fn deserialize_signature(text: &str) -> Result<Signature, serde_json::error::Error> {
+			serde_json::from_str(text)
+		}
+		assert!(deserialize_signature("Not valid json.").is_err());
+		assert!(deserialize_signature("\"Not an actual signature.\"").is_err());
+		// Poorly-sized
+		assert!(deserialize_signature("\"abc123\"").is_err());
+	}
+
+	#[test]
+	fn vrf_sign_verify() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+
+		let data = VrfTranscript::new(b"label", &[(b"domain1", b"data1")]).into();
+
+		let signature = pair.vrf_sign(&data);
+
+		assert!(public.vrf_verify(&data, &signature));
+	}
+
+	#[test]
+	fn vrf_sign_verify_with_extra() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+
+		let extra = VrfTranscript::new(b"extra", &[(b"domain2", b"data2")]);
+		let data = VrfTranscript::new(b"label", &[(b"domain1", b"data1")])
+			.into_sign_data()
+			.with_extra(extra);
+
+		let signature = pair.vrf_sign(&data);
+
+		assert!(public.vrf_verify(&data, &signature));
+	}
+
+	#[test]
+	fn vrf_make_bytes_matches() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let ctx = b"vrfbytes";
+
+		let input = VrfTranscript::new(b"label", &[(b"domain1", b"data1")]);
+
+		let output = pair.vrf_output(&input);
+
+		let out1 = pair.make_bytes::<32>(ctx, &input);
+		let out2 = output.make_bytes::<32>(ctx, &input, &public).unwrap();
+		assert_eq!(out1, out2);
+
+		let extra = VrfTranscript::new(b"extra", &[(b"domain2", b"data2")]);
+		let data = input.clone().into_sign_data().with_extra(extra);
+		let signature = pair.vrf_sign(&data);
+		assert!(public.vrf_verify(&data, &signature));
+
+		let out3 = public.make_bytes::<32>(ctx, &input, &signature.output).unwrap();
+		assert_eq!(out2, out3);
+	}
+
+	#[test]
+	fn vrf_backend_compat() {
+		let pair = Pair::from_seed(b"12345678901234567890123456789012");
+		let public = pair.public();
+		let ctx = b"vrfbytes";
+
+		let input = VrfInput::new(b"label", &[(b"domain1", b"data1")]);
+		let extra = VrfTranscript::new(b"extra", &[(b"domain2", b"data2")]);
+
+		let data = input.clone().into_sign_data().with_extra(extra.clone());
+		let signature = pair.vrf_sign(&data);
+		assert!(public.vrf_verify(&data, &signature));
+
+		let out1 = pair.make_bytes::<32>(ctx, &input);
+		let out2 = public.make_bytes::<32>(ctx, &input, &signature.output).unwrap();
+		assert_eq!(out1, out2);
+
+		// Direct call to backend version of sign after check with extra params
+		let (inout, proof, _) = pair
+			.0
+			.vrf_sign_extra_after_check(input.0.clone(), |inout| {
+				let out3 = inout.make_bytes::<[u8; 32]>(ctx);
+				assert_eq!(out2, out3);
+				Some(extra.0.clone())
+			})
+			.unwrap();
+		let signature2 =
+			VrfSignature { output: VrfOutput(inout.to_output()), proof: VrfProof(proof) };
+
+		assert!(public.vrf_verify(&data, &signature2));
+		assert_eq!(signature.output, signature2.output);
+	}
+}
diff --git a/substrate/primitives/core/src/testing.rs b/substrate/primitives/core/src/testing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..25f5f9012c99608d89654a5833f588b90fc16e53
--- /dev/null
+++ b/substrate/primitives/core/src/testing.rs
@@ -0,0 +1,197 @@
+// 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.
+
+//! Types that should only be used for testing!
+
+use crate::crypto::KeyTypeId;
+
+/// Key type for generic Ed25519 key.
+pub const ED25519: KeyTypeId = KeyTypeId(*b"ed25");
+/// Key type for generic Sr25519 key.
+pub const SR25519: KeyTypeId = KeyTypeId(*b"sr25");
+/// Key type for generic ECDSA key.
+pub const ECDSA: KeyTypeId = KeyTypeId(*b"ecds");
+/// Key type for generic Bandersnatch key.
+pub const BANDERSNATCH: KeyTypeId = KeyTypeId(*b"band");
+/// Key type for generic BLS12-377 key.
+pub const BLS377: KeyTypeId = KeyTypeId(*b"bls7");
+/// Key type for generic BLS12-381 key.
+pub const BLS381: KeyTypeId = KeyTypeId(*b"bls8");
+
+/// Macro for exporting functions from wasm in with the expected signature for using it with the
+/// wasm executor. This is useful for tests where you need to call a function in wasm.
+///
+/// The input parameters are expected to be SCALE encoded and will be automatically decoded for you.
+/// The output value is also SCALE encoded when returned back to the host.
+///
+/// The functions are feature-gated with `#[cfg(not(feature = "std"))]`, so they are only available
+/// from within wasm.
+///
+/// # Example
+///
+/// ```
+/// # use sp_core::wasm_export_functions;
+///
+/// wasm_export_functions! {
+///     fn test_in_wasm(value: bool, another_value: Vec<u8>) -> bool {
+///         value && another_value.is_empty()
+///     }
+///
+///     fn without_return_value() {
+///         // do something
+///     }
+/// }
+/// ```
+#[macro_export]
+macro_rules! wasm_export_functions {
+	(
+		$(
+			fn $name:ident (
+				$( $arg_name:ident: $arg_ty:ty ),* $(,)?
+			) $( -> $ret_ty:ty )? { $( $fn_impl:tt )* }
+		)*
+	) => {
+		$(
+			$crate::wasm_export_functions! {
+				@IMPL
+				fn $name (
+					$( $arg_name: $arg_ty ),*
+				) $( -> $ret_ty )? { $( $fn_impl )* }
+			}
+		)*
+	};
+	(@IMPL
+		fn $name:ident (
+				$( $arg_name:ident: $arg_ty:ty ),*
+		) { $( $fn_impl:tt )* }
+	) => {
+		#[no_mangle]
+		#[allow(unreachable_code)]
+		#[cfg(not(feature = "std"))]
+		pub fn $name(input_data: *mut u8, input_len: usize) -> u64 {
+			let input: &[u8] = if input_len == 0 {
+				&[0u8; 0]
+			} else {
+				unsafe {
+					$crate::sp_std::slice::from_raw_parts(input_data, input_len)
+				}
+			};
+
+			{
+				let ($( $arg_name ),*) : ($( $arg_ty ),*) = $crate::Decode::decode(
+					&mut &input[..],
+				).expect("Input data is correctly encoded");
+
+				(|| { $( $fn_impl )* })()
+			}
+
+			$crate::to_substrate_wasm_fn_return_value(&())
+		}
+	};
+	(@IMPL
+		fn $name:ident (
+				$( $arg_name:ident: $arg_ty:ty ),*
+		) $( -> $ret_ty:ty )? { $( $fn_impl:tt )* }
+	) => {
+		#[no_mangle]
+		#[allow(unreachable_code)]
+		#[cfg(not(feature = "std"))]
+		pub fn $name(input_data: *mut u8, input_len: usize) -> u64 {
+			let input: &[u8] = if input_len == 0 {
+				&[0u8; 0]
+			} else {
+				unsafe {
+					$crate::sp_std::slice::from_raw_parts(input_data, input_len)
+				}
+			};
+
+			let output $( : $ret_ty )? = {
+				let ($( $arg_name ),*) : ($( $arg_ty ),*) = $crate::Decode::decode(
+					&mut &input[..],
+				).expect("Input data is correctly encoded");
+
+				(|| { $( $fn_impl )* })()
+			};
+
+			$crate::to_substrate_wasm_fn_return_value(&output)
+		}
+	};
+}
+
+/// A task executor that can be used in tests.
+///
+/// Internally this just wraps a `ThreadPool` with a pool size of `8`. This
+/// should ensure that we have enough threads in tests for spawning blocking futures.
+#[cfg(feature = "std")]
+#[derive(Clone)]
+pub struct TaskExecutor(futures::executor::ThreadPool);
+
+#[cfg(feature = "std")]
+impl TaskExecutor {
+	/// Create a new instance of `Self`.
+	pub fn new() -> Self {
+		let mut builder = futures::executor::ThreadPoolBuilder::new();
+		Self(builder.pool_size(8).create().expect("Failed to create thread pool"))
+	}
+}
+
+#[cfg(feature = "std")]
+impl Default for TaskExecutor {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+#[cfg(feature = "std")]
+impl crate::traits::SpawnNamed for TaskExecutor {
+	fn spawn_blocking(
+		&self,
+		_name: &'static str,
+		_group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		self.0.spawn_ok(future);
+	}
+	fn spawn(
+		&self,
+		_name: &'static str,
+		_group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		self.0.spawn_ok(future);
+	}
+}
+
+#[cfg(feature = "std")]
+impl crate::traits::SpawnEssentialNamed for TaskExecutor {
+	fn spawn_essential_blocking(
+		&self,
+		_: &'static str,
+		_: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		self.0.spawn_ok(future);
+	}
+	fn spawn_essential(
+		&self,
+		_: &'static str,
+		_: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		self.0.spawn_ok(future);
+	}
+}
diff --git a/substrate/primitives/core/src/traits.rs b/substrate/primitives/core/src/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..40137053ab7527d5191bc2889642549989d3be30
--- /dev/null
+++ b/substrate/primitives/core/src/traits.rs
@@ -0,0 +1,269 @@
+// 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.
+
+//! Shareable Substrate traits.
+
+use std::{
+	borrow::Cow,
+	fmt::{Debug, Display},
+};
+
+pub use sp_externalities::{Externalities, ExternalitiesExt};
+
+/// The context in which a call is done.
+///
+/// Depending on the context the executor may chooses different kind of heap sizes for the runtime
+/// instance.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
+pub enum CallContext {
+	/// The call is happening in some offchain context.
+	Offchain,
+	/// The call is happening in some on-chain context like building or importing a block.
+	Onchain,
+}
+
+/// Code execution engine.
+pub trait CodeExecutor: Sized + Send + Sync + ReadRuntimeVersion + Clone + 'static {
+	/// Externalities error type.
+	type Error: Display + Debug + Send + Sync + 'static;
+
+	/// Call a given method in the runtime.
+	///
+	/// Returns a tuple of the result (either the output data or an execution error) together with a
+	/// `bool`, which is true if native execution was used.
+	fn call(
+		&self,
+		ext: &mut dyn Externalities,
+		runtime_code: &RuntimeCode,
+		method: &str,
+		data: &[u8],
+		use_native: bool,
+		context: CallContext,
+	) -> (Result<Vec<u8>, Self::Error>, bool);
+}
+
+/// Something that can fetch the runtime `:code`.
+pub trait FetchRuntimeCode {
+	/// Fetch the runtime `:code`.
+	///
+	/// If the `:code` could not be found/not available, `None` should be returned.
+	fn fetch_runtime_code(&self) -> Option<Cow<[u8]>>;
+}
+
+/// Wrapper to use a `u8` slice or `Vec` as [`FetchRuntimeCode`].
+pub struct WrappedRuntimeCode<'a>(pub std::borrow::Cow<'a, [u8]>);
+
+impl<'a> FetchRuntimeCode for WrappedRuntimeCode<'a> {
+	fn fetch_runtime_code(&self) -> Option<Cow<[u8]>> {
+		Some(self.0.as_ref().into())
+	}
+}
+
+/// Type that implements [`FetchRuntimeCode`] and always returns `None`.
+pub struct NoneFetchRuntimeCode;
+
+impl FetchRuntimeCode for NoneFetchRuntimeCode {
+	fn fetch_runtime_code(&self) -> Option<Cow<[u8]>> {
+		None
+	}
+}
+
+/// The Wasm code of a Substrate runtime.
+#[derive(Clone)]
+pub struct RuntimeCode<'a> {
+	/// The code fetcher that can be used to lazily fetch the code.
+	pub code_fetcher: &'a dyn FetchRuntimeCode,
+	/// The optional heap pages this `code` should be executed with.
+	///
+	/// If `None` are given, the default value of the executor will be used.
+	pub heap_pages: Option<u64>,
+	/// The SCALE encoded hash of `code`.
+	///
+	/// The hashing algorithm isn't that important, as long as all runtime
+	/// code instances use the same.
+	pub hash: Vec<u8>,
+}
+
+impl<'a> PartialEq for RuntimeCode<'a> {
+	fn eq(&self, other: &Self) -> bool {
+		self.hash == other.hash
+	}
+}
+
+impl<'a> RuntimeCode<'a> {
+	/// Create an empty instance.
+	///
+	/// This is only useful for tests that don't want to execute any code.
+	pub fn empty() -> Self {
+		Self { code_fetcher: &NoneFetchRuntimeCode, hash: Vec::new(), heap_pages: None }
+	}
+}
+
+impl<'a> FetchRuntimeCode for RuntimeCode<'a> {
+	fn fetch_runtime_code(&self) -> Option<Cow<[u8]>> {
+		self.code_fetcher.fetch_runtime_code()
+	}
+}
+
+/// Could not find the `:code` in the externalities while initializing the [`RuntimeCode`].
+#[derive(Debug)]
+pub struct CodeNotFound;
+
+impl std::fmt::Display for CodeNotFound {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+		write!(f, "the storage entry `:code` doesn't have any code")
+	}
+}
+
+/// A trait that allows reading version information from the binary.
+pub trait ReadRuntimeVersion: Send + Sync {
+	/// Reads the runtime version information from the given wasm code.
+	///
+	/// The version information may be embedded into the wasm binary itself. If it is not present,
+	/// then this function may fallback to the legacy way of reading the version.
+	///
+	/// The legacy mechanism involves instantiating the passed wasm runtime and calling
+	/// `Core_version` on it. This is a very expensive operation.
+	///
+	/// `ext` is only needed in case the calling into runtime happens. Otherwise it is ignored.
+	///
+	/// Compressed wasm blobs are supported and will be decompressed if needed. If uncompression
+	/// fails, the error is returned.
+	///
+	/// # Errors
+	///
+	/// If the version information present in binary, but is corrupted - returns an error.
+	///
+	/// Otherwise, if there is no version information present, and calling into the runtime takes
+	/// place, then an error would be returned if `Core_version` is not provided.
+	fn read_runtime_version(
+		&self,
+		wasm_code: &[u8],
+		ext: &mut dyn Externalities,
+	) -> Result<Vec<u8>, String>;
+}
+
+impl ReadRuntimeVersion for std::sync::Arc<dyn ReadRuntimeVersion> {
+	fn read_runtime_version(
+		&self,
+		wasm_code: &[u8],
+		ext: &mut dyn Externalities,
+	) -> Result<Vec<u8>, String> {
+		(**self).read_runtime_version(wasm_code, ext)
+	}
+}
+
+sp_externalities::decl_extension! {
+	/// An extension that provides functionality to read version information from a given wasm blob.
+	pub struct ReadRuntimeVersionExt(Box<dyn ReadRuntimeVersion>);
+}
+
+impl ReadRuntimeVersionExt {
+	/// Creates a new instance of the extension given a version determinator instance.
+	pub fn new<T: ReadRuntimeVersion + 'static>(inner: T) -> Self {
+		Self(Box::new(inner))
+	}
+}
+
+/// Something that can spawn tasks (blocking and non-blocking) with an assigned name
+/// and optional group.
+#[dyn_clonable::clonable]
+pub trait SpawnNamed: Clone + Send + Sync {
+	/// Spawn the given blocking future.
+	///
+	/// The given `group` and `name` is used to identify the future in tracing.
+	fn spawn_blocking(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	);
+	/// Spawn the given non-blocking future.
+	///
+	/// The given `group` and `name` is used to identify the future in tracing.
+	fn spawn(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	);
+}
+
+impl SpawnNamed for Box<dyn SpawnNamed> {
+	fn spawn_blocking(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		(**self).spawn_blocking(name, group, future)
+	}
+	fn spawn(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		(**self).spawn(name, group, future)
+	}
+}
+
+/// Something that can spawn essential tasks (blocking and non-blocking) with an assigned name
+/// and optional group.
+///
+/// Essential tasks are special tasks that should take down the node when they end.
+#[dyn_clonable::clonable]
+pub trait SpawnEssentialNamed: Clone + Send + Sync {
+	/// Spawn the given blocking future.
+	///
+	/// The given `group` and `name` is used to identify the future in tracing.
+	fn spawn_essential_blocking(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	);
+	/// Spawn the given non-blocking future.
+	///
+	/// The given `group` and `name` is used to identify the future in tracing.
+	fn spawn_essential(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	);
+}
+
+impl SpawnEssentialNamed for Box<dyn SpawnEssentialNamed> {
+	fn spawn_essential_blocking(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		(**self).spawn_essential_blocking(name, group, future)
+	}
+
+	fn spawn_essential(
+		&self,
+		name: &'static str,
+		group: Option<&'static str>,
+		future: futures::future::BoxFuture<'static, ()>,
+	) {
+		(**self).spawn_essential(name, group, future)
+	}
+}
diff --git a/substrate/primitives/core/src/uint.rs b/substrate/primitives/core/src/uint.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b251671dbeea545889acf619c77973434f12defb
--- /dev/null
+++ b/substrate/primitives/core/src/uint.rs
@@ -0,0 +1,92 @@
+// 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.
+
+//! An unsigned fixed-size integer.
+
+pub use primitive_types::{U256, U512};
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::{Decode, Encode};
+
+	macro_rules! test {
+		($name: ident, $test_name: ident) => {
+			#[test]
+			fn $test_name() {
+				let tests = vec![
+					($name::from(0), "0x0"),
+					($name::from(1), "0x1"),
+					($name::from(2), "0x2"),
+					($name::from(10), "0xa"),
+					($name::from(15), "0xf"),
+					($name::from(16), "0x10"),
+					($name::from(1_000), "0x3e8"),
+					($name::from(100_000), "0x186a0"),
+					($name::from(u64::MAX), "0xffffffffffffffff"),
+					($name::from(u64::MAX) + $name::from(1), "0x10000000000000000"),
+				];
+
+				for (number, expected) in tests {
+					assert_eq!(
+						format!("{:?}", expected),
+						serde_json::to_string_pretty(&number).expect("Json pretty print failed")
+					);
+					assert_eq!(number, serde_json::from_str(&format!("{:?}", expected)).unwrap());
+				}
+
+				// Invalid examples
+				assert!(serde_json::from_str::<$name>("\"0x\"").unwrap_err().is_data());
+				assert!(serde_json::from_str::<$name>("\"0xg\"").unwrap_err().is_data());
+				assert!(serde_json::from_str::<$name>("\"\"").unwrap_err().is_data());
+			}
+		};
+	}
+
+	test!(U256, test_u256);
+
+	#[test]
+	fn test_u256_codec() {
+		let res1 = vec![
+			120, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			0, 0, 0, 0,
+		];
+		let res2 = vec![
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+			0xff, 0xff, 0xff, 0xff,
+		];
+
+		assert_eq!(U256::from(120).encode(), res1);
+		assert_eq!(U256::max_value().encode(), res2);
+		assert_eq!(U256::decode(&mut &res1[..]), Ok(U256::from(120)));
+		assert_eq!(U256::decode(&mut &res2[..]), Ok(U256::max_value()));
+	}
+
+	#[test]
+	fn test_large_values() {
+		assert_eq!(
+			serde_json::to_string_pretty(&!U256::zero()).expect("Json pretty print failed"),
+			"\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
+		);
+		assert!(serde_json::from_str::<U256>(
+			"\"0x1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\""
+		)
+		.unwrap_err()
+		.is_data());
+	}
+}
diff --git a/substrate/primitives/crypto/ec-utils/Cargo.toml b/substrate/primitives/crypto/ec-utils/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..90cd38722e0e15b0971ff99e197f373c0354118c
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/Cargo.toml
@@ -0,0 +1,62 @@
+[package]
+name = "sp-crypto-ec-utils"
+version = "0.4.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Host function interface for common elliptic curve operations in Substrate runtimes"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+ark-serialize = { version = "0.4.2", default-features = false }
+ark-ff = { version = "0.4.2", default-features = false }
+ark-ec = { version = "0.4.2", default-features = false }
+ark-std = { version = "0.4.0", default-features = false }
+ark-bls12-377 = { version = "0.4.0", features = ["curve"], default-features = false }
+ark-bls12-381 = { version = "0.4.0", features = ["curve"], default-features = false }
+ark-bw6-761 = { version = "0.4.0", default-features = false }
+ark-ed-on-bls12-381-bandersnatch = { version = "0.4.0", default-features = false }
+ark-ed-on-bls12-377 = { version = "0.4.0", default-features = false }
+sp-std = { version = "8.0.0", path = "../../std", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+ark-scale = { version = "0.0.3", features = ["hazmat"], default-features = false }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../../runtime-interface" }
+
+[dev-dependencies]
+sp-io = { path = "../../io", default-features = false }
+ark-algebra-test-templates = { version = "0.4.2", default-features = false }
+sp-ark-models = { version = "0.4.0-beta", default-features = false }
+sp-ark-bls12-377 = { version = "0.4.0-beta", default-features = false }
+sp-ark-bls12-381 = { version = "0.4.0-beta", default-features = false }
+sp-ark-bw6-761 = { version = "0.4.0-beta", default-features = false }
+sp-ark-ed-on-bls12-377 = { version = "0.4.0-beta", default-features = false }
+sp-ark-ed-on-bls12-381-bandersnatch = { version = "0.4.0-beta", default-features = false }
+
+[features]
+default = [ "std" ]
+std = [
+	"ark-algebra-test-templates/std",
+	"ark-bls12-377/std",
+	"ark-bls12-381/std",
+	"ark-bw6-761/std",
+	"ark-ec/std",
+	"ark-ed-on-bls12-377/std",
+	"ark-ed-on-bls12-381-bandersnatch/std",
+	"ark-ff/std",
+	"ark-scale/std",
+	"ark-serialize/std",
+	"ark-std/std",
+	"codec/std",
+	"sp-ark-bls12-377/std",
+	"sp-ark-bls12-381/std",
+	"sp-ark-bw6-761/std",
+	"sp-ark-ed-on-bls12-377/std",
+	"sp-ark-ed-on-bls12-381-bandersnatch/std",
+	"sp-io/std",
+	"sp-runtime-interface/std",
+	"sp-std/std",
+]
diff --git a/substrate/primitives/crypto/ec-utils/src/bls12_377.rs b/substrate/primitives/crypto/ec-utils/src/bls12_377.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9230479b3bec513e2429055c975a145d91432b3b
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/src/bls12_377.rs
@@ -0,0 +1,103 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Support functions for bls12_377 to improve the performance of
+//! multi_miller_loop, final_exponentiation, msm's and projective
+//! multiplications by host function calls
+
+use crate::utils::{
+	final_exponentiation_generic, msm_sw_generic, mul_projective_generic, multi_miller_loop_generic,
+};
+use ark_bls12_377::{g1, g2, Bls12_377};
+use sp_std::vec::Vec;
+
+/// Compute a multi miller loop through arkworks
+pub fn multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+	multi_miller_loop_generic::<Bls12_377>(a, b)
+}
+
+/// Compute a final exponentiation through arkworks
+pub fn final_exponentiation(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	final_exponentiation_generic::<Bls12_377>(target)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g1::Config>(bases, scalars)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g2::Config>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G1.
+pub fn mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g1::Config>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G2.
+pub fn mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g2::Config>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_bls12_377::{
+		Bls12_377 as Bls12_377Host, G1Projective as G1ProjectiveHost,
+		G2Projective as G2ProjectiveHost, HostFunctions,
+	};
+
+	#[derive(PartialEq, Eq)]
+	struct Host;
+
+	impl HostFunctions for Host {
+		fn bls12_377_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_multi_miller_loop(a, b)
+		}
+		fn bls12_377_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_final_exponentiation(f12)
+		}
+		fn bls12_377_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_msm_g1(bases, bigints)
+		}
+		fn bls12_377_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_msm_g2(bases, bigints)
+		}
+		fn bls12_377_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_mul_projective_g1(base, scalar)
+		}
+		fn bls12_377_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_377_mul_projective_g2(base, scalar)
+		}
+	}
+
+	type Bls12_377 = Bls12_377Host<Host>;
+	type G1Projective = G1ProjectiveHost<Host>;
+	type G2Projective = G2ProjectiveHost<Host>;
+
+	test_group!(g1; G1Projective; sw);
+	test_group!(g2; G2Projective; sw);
+	test_group!(pairing_output; ark_ec::pairing::PairingOutput<Bls12_377>; msm);
+	test_pairing!(pairing; super::Bls12_377);
+}
diff --git a/substrate/primitives/crypto/ec-utils/src/bls12_381.rs b/substrate/primitives/crypto/ec-utils/src/bls12_381.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c707aa581458e8520ac81971b7738b4617eb051
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/src/bls12_381.rs
@@ -0,0 +1,219 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Support functions for bls12_381 to improve the performance of
+//! multi_miller_loop, final_exponentiation, msm's and projective
+//! multiplications by host function calls
+
+use crate::utils::{
+	final_exponentiation_generic, msm_sw_generic, mul_projective_generic, multi_miller_loop_generic,
+};
+use ark_bls12_381::{g1, g2, Bls12_381};
+use sp_std::vec::Vec;
+
+/// Compute a multi miller loop through arkworks
+pub fn multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+	multi_miller_loop_generic::<Bls12_381>(a, b)
+}
+
+/// Compute a final exponentiation through arkworks
+pub fn final_exponentiation(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	final_exponentiation_generic::<Bls12_381>(target)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g1::Config>(bases, scalars)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g2::Config>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G1.
+pub fn mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g1::Config>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks on G2.
+pub fn mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g2::Config>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use ark_ec::{AffineRepr, CurveGroup, Group};
+	use ark_ff::{fields::Field, One, Zero};
+	use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Compress, Validate};
+	use ark_std::{rand::Rng, test_rng, vec, UniformRand};
+	use sp_ark_bls12_381::{
+		fq::Fq, fq2::Fq2, fr::Fr, Bls12_381 as Bls12_381Host, G1Affine as G1AffineHost,
+		G1Projective as G1ProjectiveHost, G2Affine as G2AffineHost,
+		G2Projective as G2ProjectiveHost, HostFunctions,
+	};
+	use sp_ark_models::pairing::PairingOutput;
+
+	#[derive(PartialEq, Eq)]
+	struct Host;
+
+	impl HostFunctions for Host {
+		fn bls12_381_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_multi_miller_loop(a, b)
+		}
+		fn bls12_381_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_final_exponentiation(f12)
+		}
+		fn bls12_381_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_msm_g1(bases, bigints)
+		}
+		fn bls12_381_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_msm_g2(bases, bigints)
+		}
+		fn bls12_381_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_mul_projective_g1(base, scalar)
+		}
+		fn bls12_381_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bls12_381_mul_projective_g2(base, scalar)
+		}
+	}
+
+	type Bls12_381 = Bls12_381Host<Host>;
+	type G1Projective = G1ProjectiveHost<Host>;
+	type G2Projective = G2ProjectiveHost<Host>;
+	type G1Affine = G1AffineHost<Host>;
+	type G2Affine = G2AffineHost<Host>;
+
+	test_group!(g1; G1Projective; sw);
+	test_group!(g2; G2Projective; sw);
+	test_group!(pairing_output; PairingOutput<Bls12_381>; msm);
+	test_pairing!(ark_pairing; super::Bls12_381);
+
+	#[test]
+	fn test_g1_endomorphism_beta() {
+		assert!(sp_ark_bls12_381::g1::BETA.pow([3u64]).is_one());
+	}
+
+	#[test]
+	fn test_g1_subgroup_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		let generator = G1Projective::rand(&mut rng).into_affine();
+		assert!(generator.is_in_correct_subgroup_assuming_on_curve());
+	}
+
+	#[test]
+	fn test_g1_subgroup_non_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		loop {
+			let x = Fq::rand(&mut rng);
+			let greatest = rng.gen();
+
+			if let Some(p) = G1Affine::get_point_from_x_unchecked(x, greatest) {
+				if !<G1Projective as ark_std::Zero>::is_zero(&p.mul_bigint(Fr::characteristic())) {
+					assert!(!p.is_in_correct_subgroup_assuming_on_curve());
+					return
+				}
+			}
+		}
+	}
+
+	#[test]
+	fn test_g2_subgroup_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		let generator = G2Projective::rand(&mut rng).into_affine();
+		assert!(generator.is_in_correct_subgroup_assuming_on_curve());
+	}
+
+	#[test]
+	fn test_g2_subgroup_non_membership_via_endomorphism() {
+		let mut rng = test_rng();
+		loop {
+			let x = Fq2::rand(&mut rng);
+			let greatest = rng.gen();
+
+			if let Some(p) = G2Affine::get_point_from_x_unchecked(x, greatest) {
+				if !<G2Projective as Zero>::is_zero(&p.mul_bigint(Fr::characteristic())) {
+					assert!(!p.is_in_correct_subgroup_assuming_on_curve());
+					return
+				}
+			}
+		}
+	}
+
+	// Test vectors and macro adapted from https://github.com/zkcrypto/bls12_381/blob/e224ad4ea1babfc582ccd751c2bf128611d10936/src/test-data/mod.rs
+	macro_rules! test_vectors {
+		($projective:ident, $affine:ident, $compress:expr, $expected:ident) => {
+			let mut e = $projective::zero();
+
+			let mut v = vec![];
+			{
+				let mut expected = $expected;
+				for _ in 0..1000 {
+					let e_affine = $affine::from(e);
+					let mut serialized = vec![0u8; e.serialized_size($compress)];
+					e_affine.serialize_with_mode(serialized.as_mut_slice(), $compress).unwrap();
+					v.extend_from_slice(&serialized[..]);
+
+					let mut decoded = serialized;
+					let len_of_encoding = decoded.len();
+					(&mut decoded[..]).copy_from_slice(&expected[0..len_of_encoding]);
+					expected = &expected[len_of_encoding..];
+					let decoded =
+						$affine::deserialize_with_mode(&decoded[..], $compress, Validate::Yes)
+							.unwrap();
+					assert_eq!(e_affine, decoded);
+
+					e += &$projective::generator();
+				}
+			}
+
+			assert_eq!(&v[..], $expected);
+		};
+	}
+
+	#[test]
+	fn g1_compressed_valid_test_vectors() {
+		let bytes: &'static [u8] = include_bytes!("test-data/g1_compressed_valid_test_vectors.dat");
+		test_vectors!(G1Projective, G1Affine, Compress::Yes, bytes);
+	}
+
+	#[test]
+	fn g1_uncompressed_valid_test_vectors() {
+		let bytes: &'static [u8] =
+			include_bytes!("test-data/g1_uncompressed_valid_test_vectors.dat");
+		test_vectors!(G1Projective, G1Affine, Compress::No, bytes);
+	}
+
+	#[test]
+	fn g2_compressed_valid_test_vectors() {
+		let bytes: &'static [u8] = include_bytes!("test-data/g2_compressed_valid_test_vectors.dat");
+		test_vectors!(G2Projective, G2Affine, Compress::Yes, bytes);
+	}
+
+	#[test]
+	fn g2_uncompressed_valid_test_vectors() {
+		let bytes: &'static [u8] =
+			include_bytes!("test-data/g2_uncompressed_valid_test_vectors.dat");
+		test_vectors!(G2Projective, G2Affine, Compress::No, bytes);
+	}
+}
diff --git a/substrate/primitives/crypto/ec-utils/src/bw6_761.rs b/substrate/primitives/crypto/ec-utils/src/bw6_761.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f3b4c3c9c9aacdde7a11045136cb3411d7a5867
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/src/bw6_761.rs
@@ -0,0 +1,103 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Support functions for bw6_761 to improve the performance of
+//! multi_miller_loop, final_exponentiation, msm's and projective
+//! multiplications by host function calls.
+
+use crate::utils::{
+	final_exponentiation_generic, msm_sw_generic, mul_projective_generic, multi_miller_loop_generic,
+};
+use ark_bw6_761::{g1, g2, BW6_761};
+use sp_std::vec::Vec;
+
+/// Compute a multi miller loop through arkworks
+pub fn multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+	multi_miller_loop_generic::<BW6_761>(a, b)
+}
+
+/// Compute a final exponentiation through arkworks
+pub fn final_exponentiation(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	final_exponentiation_generic::<BW6_761>(target)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g1::Config>(bases, scalars)
+}
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<g2::Config>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass through
+/// arkworks on G1.
+pub fn mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g1::Config>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass through
+/// arkworks on G2.
+pub fn mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<g2::Config>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_bw6_761::{
+		G1Projective as G1ProjectiveHost, G2Projective as G2ProjectiveHost, HostFunctions,
+		BW6_761 as BW6_761Host,
+	};
+
+	#[derive(PartialEq, Eq)]
+	struct Host;
+
+	impl HostFunctions for Host {
+		fn bw6_761_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_multi_miller_loop(a, b)
+		}
+		fn bw6_761_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_final_exponentiation(f12)
+		}
+		fn bw6_761_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_msm_g1(bases, bigints)
+		}
+		fn bw6_761_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_msm_g2(bases, bigints)
+		}
+		fn bw6_761_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_mul_projective_g1(base, scalar)
+		}
+		fn bw6_761_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::bw6_761_mul_projective_g2(base, scalar)
+		}
+	}
+
+	type BW6_761 = BW6_761Host<Host>;
+	type G1Projective = G1ProjectiveHost<Host>;
+	type G2Projective = G2ProjectiveHost<Host>;
+
+	test_group!(g1; G1Projective; sw);
+	test_group!(g2; G2Projective; sw);
+	test_group!(pairing_output; ark_ec::pairing::PairingOutput<BW6_761>; msm);
+	test_pairing!(pairing; super::BW6_761);
+}
diff --git a/substrate/primitives/crypto/ec-utils/src/ed_on_bls12_377.rs b/substrate/primitives/crypto/ec-utils/src/ed_on_bls12_377.rs
new file mode 100644
index 0000000000000000000000000000000000000000..84a86286180f7b74a73ffce0c5cd9ece83bf0673
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/src/ed_on_bls12_377.rs
@@ -0,0 +1,56 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Support functions for ed_on_bls12_377 to improve the performance of
+//! msm and projective multiplication by host function calls
+
+use crate::utils::{msm_te_generic, mul_projective_te_generic};
+use ark_ed_on_bls12_377::EdwardsConfig;
+use sp_std::vec::Vec;
+
+/// Compute a multi scalar mulitplication for twisted_edwards through
+/// arkworks.
+pub fn msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_te_generic::<EdwardsConfig>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for twisted_edwards
+/// through arkworks.
+pub fn mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_te_generic::<EdwardsConfig>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_ed_on_bls12_377::{EdwardsProjective as EdwardsProjectiveHost, HostFunctions};
+
+	struct Host {}
+
+	impl HostFunctions for Host {
+		fn ed_on_bls12_377_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_377_msm(bases, scalars)
+		}
+		fn ed_on_bls12_377_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_377_mul_projective(base, scalar)
+		}
+	}
+
+	type EdwardsProjective = EdwardsProjectiveHost<Host>;
+	test_group!(te; EdwardsProjective; te);
+}
diff --git a/substrate/primitives/crypto/ec-utils/src/ed_on_bls12_381_bandersnatch.rs b/substrate/primitives/crypto/ec-utils/src/ed_on_bls12_381_bandersnatch.rs
new file mode 100644
index 0000000000000000000000000000000000000000..72b68c3b47182e012b25f0b5beab8cb74d05f874
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/src/ed_on_bls12_381_bandersnatch.rs
@@ -0,0 +1,94 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2017-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.
+
+//! Support functions for ed_on_bls12_381_bandersnatch to improve the
+//! performance of msm' and projective multiplications by host function
+//! calls.
+
+use crate::utils::{
+	msm_sw_generic, msm_te_generic, mul_projective_generic, mul_projective_te_generic,
+};
+use ark_ed_on_bls12_381_bandersnatch::BandersnatchConfig;
+use sp_std::vec::Vec;
+
+/// Compute a multi scalar multiplication for short_weierstrass through
+/// arkworks.
+pub fn sw_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_sw_generic::<BandersnatchConfig>(bases, scalars)
+}
+
+/// Compute a multi scalar mulitplication for twisted_edwards through
+/// arkworks.
+pub fn te_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+	msm_te_generic::<BandersnatchConfig>(bases, scalars)
+}
+
+/// Compute a projective scalar multiplication for short_weierstrass
+/// through arkworks.
+pub fn sw_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_generic::<BandersnatchConfig>(base, scalar)
+}
+
+/// Compute a projective scalar multiplication for twisted_edwards
+/// through arkworks.
+pub fn te_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+	mul_projective_te_generic::<BandersnatchConfig>(base, scalar)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use ark_algebra_test_templates::*;
+	use sp_ark_ed_on_bls12_381_bandersnatch::{
+		EdwardsProjective as EdwardsProjectiveHost, HostFunctions, SWProjective as SWProjectiveHost,
+	};
+
+	pub struct Host {}
+
+	impl HostFunctions for Host {
+		fn ed_on_bls12_381_bandersnatch_te_msm(
+			bases: Vec<u8>,
+			scalars: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_te_msm(bases, scalars)
+		}
+		fn ed_on_bls12_381_bandersnatch_sw_msm(
+			bases: Vec<u8>,
+			scalars: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_sw_msm(bases, scalars)
+		}
+		fn ed_on_bls12_381_bandersnatch_te_mul_projective(
+			base: Vec<u8>,
+			scalar: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_te_mul_projective(base, scalar)
+		}
+		fn ed_on_bls12_381_bandersnatch_sw_mul_projective(
+			base: Vec<u8>,
+			scalar: Vec<u8>,
+		) -> Result<Vec<u8>, ()> {
+			crate::elliptic_curves::ed_on_bls12_381_bandersnatch_sw_mul_projective(base, scalar)
+		}
+	}
+
+	type EdwardsProjective = EdwardsProjectiveHost<Host>;
+	type SWProjective = SWProjectiveHost<Host>;
+
+	test_group!(sw; SWProjective; sw);
+	test_group!(te; EdwardsProjective; te);
+}
diff --git a/substrate/primitives/crypto/ec-utils/src/lib.rs b/substrate/primitives/crypto/ec-utils/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c1877dd5b5d727b7b63104b2d3215e9969f41fe8
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/src/lib.rs
@@ -0,0 +1,264 @@
+// 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.
+
+//! The main elliptic curves trait, allowing Substrate to call into host functions
+//! for operations on elliptic curves.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod bls12_377;
+pub mod bls12_381;
+pub mod bw6_761;
+pub mod ed_on_bls12_377;
+pub mod ed_on_bls12_381_bandersnatch;
+mod utils;
+
+use sp_runtime_interface::runtime_interface;
+
+/// Interfaces for working with elliptic curves related types from within the runtime.
+/// All type are (de-)serialized through the wrapper types from the ark-scale trait,
+/// with ark_scale::{ArkScale, ArkScaleProjective};
+#[runtime_interface]
+pub trait EllipticCurves {
+	/// Compute a multi Miller loop for bls12_37
+	/// Receives encoded:
+	/// a: ArkScale<Vec<ark_ec::bls12::G1Prepared::<ark_bls12_377::Config>>>
+	/// b: ArkScale<Vec<ark_ec::bls12::G2Prepared::<ark_bls12_377::Config>>>
+	/// Returns encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_377::Config>>>
+	fn bls12_377_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::multi_miller_loop(a, b)
+	}
+
+	/// Compute a final exponentiation for bls12_377
+	/// Receives encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_377::Config>>>
+	/// Returns encoded: ArkScale<PairingOutput<Bls12<ark_bls12_377::Config>>>
+	fn bls12_377_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::final_exponentiation(f12)
+	}
+
+	/// Compute a projective multiplication on G1 for bls12_377
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_377::G1Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G1Projective>
+	fn bls12_377_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::mul_projective_g1(base, scalar)
+	}
+
+	/// Compute a projective multiplication on G2 for bls12_377
+	/// through arkworks on G2
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_377::G2Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G2Projective>
+	fn bls12_377_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::mul_projective_g2(base, scalar)
+	}
+
+	/// Compute a msm on G1 for bls12_377
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_377::G1Affine]>
+	/// scalars: ArkScale<&[ark_bls12_377::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G1Projective>
+	fn bls12_377_msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::msm_g1(bases, scalars)
+	}
+
+	/// Compute a msm on G2 for bls12_377
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_377::G2Affine]>
+	/// scalars: ArkScale<&[ark_bls12_377::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_377::G2Projective>
+	fn bls12_377_msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_377::msm_g2(bases, scalars)
+	}
+
+	/// Compute a multi Miller loop on bls12_381
+	/// Receives encoded:
+	/// a: ArkScale<Vec<ark_ec::bls12::G1Prepared::<ark_bls12_381::Config>>>
+	/// b: ArkScale<Vec<ark_ec::bls12::G2Prepared::<ark_bls12_381::Config>>>
+	/// Returns encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_381::Config>>>
+	fn bls12_381_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::multi_miller_loop(a, b)
+	}
+
+	/// Compute a final exponentiation on bls12_381
+	/// Receives encoded: ArkScale<MillerLoopOutput<Bls12<ark_bls12_381::Config>>>
+	/// Returns encoded:ArkScale<PairingOutput<Bls12<ark_bls12_381::Config>>>
+	fn bls12_381_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::final_exponentiation(f12)
+	}
+
+	/// Compute a projective multiplication on G1 for bls12_381
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_381::G1Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G1Projective>
+	fn bls12_381_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::mul_projective_g1(base, scalar)
+	}
+
+	/// Compute a projective multiplication on G2 for bls12_381
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bls12_381::G2Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G2Projective>
+	fn bls12_381_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::mul_projective_g2(base, scalar)
+	}
+
+	/// Compute a msm on G1 for bls12_381
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_381::G1Affine]>
+	/// scalars: ArkScale<&[ark_bls12_381::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G1Projective>
+	fn bls12_381_msm_g1(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::msm_g1(bases, scalars)
+	}
+
+	/// Compute a msm on G2 for bls12_381
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bls12_381::G2Affine]>
+	/// scalars: ArkScale<&[ark_bls12_381::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bls12_381::G2Projective>
+	fn bls12_381_msm_g2(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bls12_381::msm_g2(bases, scalars)
+	}
+
+	/// Compute a multi Miller loop on bw6_761
+	/// Receives encoded:
+	/// a: ArkScale<Vec<ark_ec::bw6::G1Prepared::<ark_bw6_761::Config>>>
+	/// b: ArkScale<Vec<ark_ec::bw6::G2Prepared::<ark_bw6_761::Config>>>
+	/// Returns encoded: ArkScale<MillerLoopOutput<Bls12<ark_bw6_761::Config>>>
+	fn bw6_761_multi_miller_loop(a: Vec<u8>, b: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::multi_miller_loop(a, b)
+	}
+
+	/// Compute a final exponentiation on bw6_761
+	/// Receives encoded: ArkScale<MillerLoopOutput<BW6<ark_bw6_761::Config>>>
+	/// Returns encoded: ArkScale<PairingOutput<BW6<ark_bw6_761::Config>>>
+	fn bw6_761_final_exponentiation(f12: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::final_exponentiation(f12)
+	}
+
+	/// Compute a projective multiplication on G1 for bw6_761
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bw6_761::G1Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G1Projective>
+	fn bw6_761_mul_projective_g1(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::mul_projective_g1(base, scalar)
+	}
+
+	/// Compute a projective multiplication on G2 for bw6_761
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_bw6_761::G2Projective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G2Projective>
+	fn bw6_761_mul_projective_g2(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::mul_projective_g2(base, scalar)
+	}
+
+	/// Compute a msm on G1 for bw6_761
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bw6_761::G1Affine]>
+	/// scalars: ArkScale<&[ark_bw6_761::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G1Projective>
+	fn bw6_761_msm_g1(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::msm_g1(bases, bigints)
+	}
+
+	/// Compute a msm on G2 for bw6_761
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_bw6_761::G2Affine]>
+	/// scalars: ArkScale<&[ark_bw6_761::Fr]>
+	/// Returns encoded: ArkScaleProjective<ark_bw6_761::G2Projective>
+	fn bw6_761_msm_g2(bases: Vec<u8>, bigints: Vec<u8>) -> Result<Vec<u8>, ()> {
+		bw6_761::msm_g2(bases, bigints)
+	}
+
+	/// Compute projective multiplication on ed_on_bls12_377
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_377::EdwardsProjective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_ed_on_bls12_377::EdwardsProjective>
+	fn ed_on_bls12_377_mul_projective(base: Vec<u8>, scalar: Vec<u8>) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_377::mul_projective(base, scalar)
+	}
+
+	/// Compute msm on ed_on_bls12_377
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_ed_on_bls12_377::EdwardsAffine]>
+	/// scalars:
+	/// ArkScale<&[ark_ed_on_bls12_377::Fr]>
+	/// Returns encoded:
+	/// ArkScaleProjective<ark_ed_on_bls12_377::EdwardsProjective>
+	fn ed_on_bls12_377_msm(bases: Vec<u8>, scalars: Vec<u8>) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_377::msm(bases, scalars)
+	}
+
+	/// Compute short weierstrass projective multiplication on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::SWProjective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::SWProjective>
+	fn ed_on_bls12_381_bandersnatch_sw_mul_projective(
+		base: Vec<u8>,
+		scalar: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::sw_mul_projective(base, scalar)
+	}
+
+	/// Compute twisted edwards projective multiplication on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	/// scalar: ArkScale<&[u64]>
+	/// Returns encoded: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	fn ed_on_bls12_381_bandersnatch_te_mul_projective(
+		base: Vec<u8>,
+		scalar: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::te_mul_projective(base, scalar)
+	}
+
+	/// Compute short weierstrass msm on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// bases: ArkScale<&[ark_ed_on_bls12_381_bandersnatch::SWAffine]>
+	/// scalars: ArkScale<&[ark_ed_on_bls12_381_bandersnatch::Fr]>
+	/// Returns encoded:
+	/// ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::SWProjective>
+	fn ed_on_bls12_381_bandersnatch_sw_msm(
+		bases: Vec<u8>,
+		scalars: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::sw_msm(bases, scalars)
+	}
+
+	/// Compute twisted edwards msm on ed_on_bls12_381_bandersnatch
+	/// Receives encoded:
+	/// base: ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	/// scalars: ArkScale<&[ark_ed_on_bls12_381_bandersnatch::Fr]>
+	/// Returns encoded:
+	/// ArkScaleProjective<ark_ed_on_bls12_381_bandersnatch::EdwardsProjective>
+	fn ed_on_bls12_381_bandersnatch_te_msm(
+		bases: Vec<u8>,
+		scalars: Vec<u8>,
+	) -> Result<Vec<u8>, ()> {
+		ed_on_bls12_381_bandersnatch::te_msm(bases, scalars)
+	}
+}
diff --git a/substrate/primitives/crypto/ec-utils/src/test-data/g1_compressed_valid_test_vectors.dat b/substrate/primitives/crypto/ec-utils/src/test-data/g1_compressed_valid_test_vectors.dat
new file mode 100644
index 0000000000000000000000000000000000000000..ea8cd67652d133010e79df8488452450b6f5cb17
Binary files /dev/null and b/substrate/primitives/crypto/ec-utils/src/test-data/g1_compressed_valid_test_vectors.dat differ
diff --git a/substrate/primitives/crypto/ec-utils/src/test-data/g1_uncompressed_valid_test_vectors.dat b/substrate/primitives/crypto/ec-utils/src/test-data/g1_uncompressed_valid_test_vectors.dat
new file mode 100644
index 0000000000000000000000000000000000000000..86abfba945c7b701750d637bffe6701330e10e88
Binary files /dev/null and b/substrate/primitives/crypto/ec-utils/src/test-data/g1_uncompressed_valid_test_vectors.dat differ
diff --git a/substrate/primitives/crypto/ec-utils/src/test-data/g2_compressed_valid_test_vectors.dat b/substrate/primitives/crypto/ec-utils/src/test-data/g2_compressed_valid_test_vectors.dat
new file mode 100644
index 0000000000000000000000000000000000000000..a40bbe251d90e576060adb7eaa2456197878804c
Binary files /dev/null and b/substrate/primitives/crypto/ec-utils/src/test-data/g2_compressed_valid_test_vectors.dat differ
diff --git a/substrate/primitives/crypto/ec-utils/src/test-data/g2_uncompressed_valid_test_vectors.dat b/substrate/primitives/crypto/ec-utils/src/test-data/g2_uncompressed_valid_test_vectors.dat
new file mode 100644
index 0000000000000000000000000000000000000000..92e4bc528e8937a311b502e4940e5e363a1f7c57
Binary files /dev/null and b/substrate/primitives/crypto/ec-utils/src/test-data/g2_uncompressed_valid_test_vectors.dat differ
diff --git a/substrate/primitives/crypto/ec-utils/src/utils.rs b/substrate/primitives/crypto/ec-utils/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5560d5921160509a8f2a00b28ee29331008cc780
--- /dev/null
+++ b/substrate/primitives/crypto/ec-utils/src/utils.rs
@@ -0,0 +1,130 @@
+// 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.
+
+//! The generic executions of the operations on arkworks elliptic curves
+//! which get instantiatied by the corresponding curves.
+use ark_ec::{
+	pairing::{MillerLoopOutput, Pairing, PairingOutput},
+	short_weierstrass,
+	short_weierstrass::SWCurveConfig,
+	twisted_edwards,
+	twisted_edwards::TECurveConfig,
+	CurveConfig, VariableBaseMSM,
+};
+use ark_scale::hazmat::ArkScaleProjective;
+use ark_std::vec::Vec;
+use codec::{Decode, Encode};
+
+const HOST_CALL: ark_scale::Usage = ark_scale::HOST_CALL;
+type ArkScale<T> = ark_scale::ArkScale<T, HOST_CALL>;
+
+pub(crate) fn multi_miller_loop_generic<Curve: Pairing>(
+	g1: Vec<u8>,
+	g2: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let g1 = <ArkScale<Vec<<Curve as Pairing>::G1Affine>> as Decode>::decode(&mut g1.as_slice())
+		.map_err(|_| ())?;
+	let g2 = <ArkScale<Vec<<Curve as Pairing>::G2Affine>> as Decode>::decode(&mut g2.as_slice())
+		.map_err(|_| ())?;
+
+	let result = Curve::multi_miller_loop(g1.0, g2.0).0;
+
+	let result: ArkScale<<Curve as Pairing>::TargetField> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn final_exponentiation_generic<Curve: Pairing>(target: Vec<u8>) -> Result<Vec<u8>, ()> {
+	let target =
+		<ArkScale<<Curve as Pairing>::TargetField> as Decode>::decode(&mut target.as_slice())
+			.map_err(|_| ())?;
+
+	let result = Curve::final_exponentiation(MillerLoopOutput(target.0)).ok_or(())?;
+
+	let result: ArkScale<PairingOutput<Curve>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn msm_sw_generic<Curve: SWCurveConfig>(
+	bases: Vec<u8>,
+	scalars: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let bases =
+		<ArkScale<Vec<short_weierstrass::Affine<Curve>>> as Decode>::decode(&mut bases.as_slice())
+			.map_err(|_| ())?;
+	let scalars = <ArkScale<Vec<<Curve as CurveConfig>::ScalarField>> as Decode>::decode(
+		&mut scalars.as_slice(),
+	)
+	.map_err(|_| ())?;
+
+	let result =
+		<short_weierstrass::Projective<Curve> as VariableBaseMSM>::msm(&bases.0, &scalars.0)
+			.map_err(|_| ())?;
+
+	let result: ArkScaleProjective<short_weierstrass::Projective<Curve>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn msm_te_generic<Curve: TECurveConfig>(
+	bases: Vec<u8>,
+	scalars: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let bases =
+		<ArkScale<Vec<twisted_edwards::Affine<Curve>>> as Decode>::decode(&mut bases.as_slice())
+			.map_err(|_| ())?;
+	let scalars = <ArkScale<Vec<<Curve as CurveConfig>::ScalarField>> as Decode>::decode(
+		&mut scalars.as_slice(),
+	)
+	.map_err(|_| ())?;
+
+	let result = <twisted_edwards::Projective<Curve> as VariableBaseMSM>::msm(&bases.0, &scalars.0)
+		.map_err(|_| ())?;
+
+	let result: ArkScaleProjective<twisted_edwards::Projective<Curve>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn mul_projective_generic<Group: SWCurveConfig>(
+	base: Vec<u8>,
+	scalar: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let base = <ArkScaleProjective<short_weierstrass::Projective<Group>> as Decode>::decode(
+		&mut base.as_slice(),
+	)
+	.map_err(|_| ())?;
+	let scalar = <ArkScale<Vec<u64>> as Decode>::decode(&mut scalar.as_slice()).map_err(|_| ())?;
+
+	let result = <Group as SWCurveConfig>::mul_projective(&base.0, &scalar.0);
+
+	let result: ArkScaleProjective<short_weierstrass::Projective<Group>> = result.into();
+	Ok(result.encode())
+}
+
+pub(crate) fn mul_projective_te_generic<Group: TECurveConfig>(
+	base: Vec<u8>,
+	scalar: Vec<u8>,
+) -> Result<Vec<u8>, ()> {
+	let base = <ArkScaleProjective<twisted_edwards::Projective<Group>> as Decode>::decode(
+		&mut base.as_slice(),
+	)
+	.map_err(|_| ())?;
+	let scalar = <ArkScale<Vec<u64>> as Decode>::decode(&mut scalar.as_slice()).map_err(|_| ())?;
+
+	let result = <Group as TECurveConfig>::mul_projective(&base.0, &scalar.0);
+
+	let result: ArkScaleProjective<twisted_edwards::Projective<Group>> = result.into();
+	Ok(result.encode())
+}
diff --git a/substrate/primitives/database/Cargo.toml b/substrate/primitives/database/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b1105f88ba50f4a71cd5f072e6444a60c08e15ff
--- /dev/null
+++ b/substrate/primitives/database/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "sp-database"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate database trait."
+documentation = "https://docs.rs/sp-database"
+readme = "README.md"
+
+[dependencies]
+kvdb = "0.13.0"
+parking_lot = "0.12.1"
diff --git a/substrate/primitives/database/README.md b/substrate/primitives/database/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd0677eb9eb44ef3d26f1cfecdb1bdbbd371536a
--- /dev/null
+++ b/substrate/primitives/database/README.md
@@ -0,0 +1,3 @@
+The main database trait, allowing Substrate to store data persistently.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/database/src/error.rs b/substrate/primitives/database/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0cc1159b21e7d12a89c5cee053d8bd8b257fad53
--- /dev/null
+++ b/substrate/primitives/database/src/error.rs
@@ -0,0 +1,35 @@
+// 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.
+
+/// The error type for database operations.
+#[derive(Debug)]
+pub struct DatabaseError(pub Box<dyn std::error::Error + Send + Sync + 'static>);
+
+impl std::fmt::Display for DatabaseError {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "{}", self.0)
+	}
+}
+
+impl std::error::Error for DatabaseError {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		None
+	}
+}
+
+/// A specialized `Result` type for database operations.
+pub type Result<T> = std::result::Result<T, DatabaseError>;
diff --git a/substrate/primitives/database/src/kvdb.rs b/substrate/primitives/database/src/kvdb.rs
new file mode 100644
index 0000000000000000000000000000000000000000..735813c368570427275963177703f04d6f69e5a4
--- /dev/null
+++ b/substrate/primitives/database/src/kvdb.rs
@@ -0,0 +1,118 @@
+// 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 wrapper around `kvdb::Database` that implements `sp_database::Database` trait
+use ::kvdb::{DBTransaction, KeyValueDB};
+
+use crate::{error, Change, ColumnId, Database, Transaction};
+
+struct DbAdapter<D: KeyValueDB + 'static>(D);
+
+fn handle_err<T>(result: std::io::Result<T>) -> T {
+	match result {
+		Ok(r) => r,
+		Err(e) => {
+			panic!("Critical database error: {:?}", e);
+		},
+	}
+}
+
+/// Wrap RocksDb database into a trait object that implements `sp_database::Database`
+pub fn as_database<D, H>(db: D) -> std::sync::Arc<dyn Database<H>>
+where
+	D: KeyValueDB + 'static,
+	H: Clone + AsRef<[u8]>,
+{
+	std::sync::Arc::new(DbAdapter(db))
+}
+
+impl<D: KeyValueDB> DbAdapter<D> {
+	// Returns counter key and counter value if it exists.
+	fn read_counter(&self, col: ColumnId, key: &[u8]) -> error::Result<(Vec<u8>, Option<u32>)> {
+		// Add a key suffix for the counter
+		let mut counter_key = key.to_vec();
+		counter_key.push(0);
+		Ok(match self.0.get(col, &counter_key).map_err(|e| error::DatabaseError(Box::new(e)))? {
+			Some(data) => {
+				let mut counter_data = [0; 4];
+				if data.len() != 4 {
+					return Err(error::DatabaseError(Box::new(std::io::Error::new(
+						std::io::ErrorKind::Other,
+						format!("Unexpected counter len {}", data.len()),
+					))))
+				}
+				counter_data.copy_from_slice(&data);
+				let counter = u32::from_le_bytes(counter_data);
+				(counter_key, Some(counter))
+			},
+			None => (counter_key, None),
+		})
+	}
+}
+
+impl<D: KeyValueDB, H: Clone + AsRef<[u8]>> Database<H> for DbAdapter<D> {
+	fn commit(&self, transaction: Transaction<H>) -> error::Result<()> {
+		let mut tx = DBTransaction::new();
+		for change in transaction.0.into_iter() {
+			match change {
+				Change::Set(col, key, value) => tx.put_vec(col, &key, value),
+				Change::Remove(col, key) => tx.delete(col, &key),
+				Change::Store(col, key, value) => match self.read_counter(col, key.as_ref())? {
+					(counter_key, Some(mut counter)) => {
+						counter += 1;
+						tx.put(col, &counter_key, &counter.to_le_bytes());
+					},
+					(counter_key, None) => {
+						let d = 1u32.to_le_bytes();
+						tx.put(col, &counter_key, &d);
+						tx.put_vec(col, key.as_ref(), value);
+					},
+				},
+				Change::Reference(col, key) => {
+					if let (counter_key, Some(mut counter)) =
+						self.read_counter(col, key.as_ref())?
+					{
+						counter += 1;
+						tx.put(col, &counter_key, &counter.to_le_bytes());
+					}
+				},
+				Change::Release(col, key) => {
+					if let (counter_key, Some(mut counter)) =
+						self.read_counter(col, key.as_ref())?
+					{
+						counter -= 1;
+						if counter == 0 {
+							tx.delete(col, &counter_key);
+							tx.delete(col, key.as_ref());
+						} else {
+							tx.put(col, &counter_key, &counter.to_le_bytes());
+						}
+					}
+				},
+			}
+		}
+		self.0.write(tx).map_err(|e| error::DatabaseError(Box::new(e)))
+	}
+
+	fn get(&self, col: ColumnId, key: &[u8]) -> Option<Vec<u8>> {
+		handle_err(self.0.get(col, key))
+	}
+
+	fn contains(&self, col: ColumnId, key: &[u8]) -> bool {
+		handle_err(self.0.has_key(col, key))
+	}
+}
diff --git a/substrate/primitives/database/src/lib.rs b/substrate/primitives/database/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..012f699552d749a1cca49f9655485841a0d8dca2
--- /dev/null
+++ b/substrate/primitives/database/src/lib.rs
@@ -0,0 +1,142 @@
+// 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.
+
+//! The main database trait, allowing Substrate to store data persistently.
+
+pub mod error;
+mod kvdb;
+mod mem;
+
+pub use crate::kvdb::as_database;
+pub use mem::MemDb;
+
+/// An identifier for a column.
+pub type ColumnId = u32;
+
+/// An alteration to the database.
+#[derive(Clone)]
+pub enum Change<H> {
+	Set(ColumnId, Vec<u8>, Vec<u8>),
+	Remove(ColumnId, Vec<u8>),
+	Store(ColumnId, H, Vec<u8>),
+	Reference(ColumnId, H),
+	Release(ColumnId, H),
+}
+
+/// A series of changes to the database that can be committed atomically. They do not take effect
+/// until passed into `Database::commit`.
+#[derive(Default, Clone)]
+pub struct Transaction<H>(pub Vec<Change<H>>);
+
+impl<H> Transaction<H> {
+	/// Create a new transaction to be prepared and committed atomically.
+	pub fn new() -> Self {
+		Transaction(Vec::new())
+	}
+	/// Set the value of `key` in `col` to `value`, replacing anything that is there currently.
+	pub fn set(&mut self, col: ColumnId, key: &[u8], value: &[u8]) {
+		self.0.push(Change::Set(col, key.to_vec(), value.to_vec()))
+	}
+	/// Set the value of `key` in `col` to `value`, replacing anything that is there currently.
+	pub fn set_from_vec(&mut self, col: ColumnId, key: &[u8], value: Vec<u8>) {
+		self.0.push(Change::Set(col, key.to_vec(), value))
+	}
+	/// Remove the value of `key` in `col`.
+	pub fn remove(&mut self, col: ColumnId, key: &[u8]) {
+		self.0.push(Change::Remove(col, key.to_vec()))
+	}
+	/// Store the `preimage` of `hash` into the database, so that it may be looked up later with
+	/// `Database::get`. This may be called multiple times, but subsequent
+	/// calls will ignore `preimage` and simply increase the number of references on `hash`.
+	pub fn store(&mut self, col: ColumnId, hash: H, preimage: Vec<u8>) {
+		self.0.push(Change::Store(col, hash, preimage))
+	}
+	/// Increase the number of references for `hash` in the database.
+	pub fn reference(&mut self, col: ColumnId, hash: H) {
+		self.0.push(Change::Reference(col, hash))
+	}
+	/// Release the preimage of `hash` from the database. An equal number of these to the number of
+	/// corresponding `store`s must have been given before it is legal for `Database::get` to
+	/// be unable to provide the preimage.
+	pub fn release(&mut self, col: ColumnId, hash: H) {
+		self.0.push(Change::Release(col, hash))
+	}
+}
+
+pub trait Database<H: Clone + AsRef<[u8]>>: Send + Sync {
+	/// Commit the `transaction` to the database atomically. Any further calls to `get` or `lookup`
+	/// will reflect the new state.
+	fn commit(&self, transaction: Transaction<H>) -> error::Result<()>;
+
+	/// Retrieve the value previously stored against `key` or `None` if
+	/// `key` is not currently in the database.
+	fn get(&self, col: ColumnId, key: &[u8]) -> Option<Vec<u8>>;
+
+	/// Check if the value exists in the database without retrieving it.
+	fn contains(&self, col: ColumnId, key: &[u8]) -> bool {
+		self.get(col, key).is_some()
+	}
+
+	/// Check value size in the database possibly without retrieving it.
+	fn value_size(&self, col: ColumnId, key: &[u8]) -> Option<usize> {
+		self.get(col, key).map(|v| v.len())
+	}
+
+	/// Call `f` with the value previously stored against `key`.
+	///
+	/// This may be faster than `get` since it doesn't allocate.
+	/// Use `with_get` helper function if you need `f` to return a value from `f`
+	fn with_get(&self, col: ColumnId, key: &[u8], f: &mut dyn FnMut(&[u8])) {
+		self.get(col, key).map(|v| f(&v));
+	}
+
+	/// Check if database supports internal ref counting for state data.
+	///
+	/// For backwards compatibility returns `false` by default.
+	fn supports_ref_counting(&self) -> bool {
+		false
+	}
+
+	/// Remove a possible path-prefix from the key.
+	///
+	/// Not all database implementations use a prefix for keys, so this function may be a noop.
+	fn sanitize_key(&self, _key: &mut Vec<u8>) {}
+}
+
+impl<H> std::fmt::Debug for dyn Database<H> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "Database")
+	}
+}
+
+/// Call `f` with the value previously stored against `key` and return the result, or `None` if
+/// `key` is not currently in the database.
+///
+/// This may be faster than `get` since it doesn't allocate.
+pub fn with_get<R, H: Clone + AsRef<[u8]>>(
+	db: &dyn Database<H>,
+	col: ColumnId,
+	key: &[u8],
+	mut f: impl FnMut(&[u8]) -> R,
+) -> Option<R> {
+	let mut result: Option<R> = None;
+	let mut adapter = |k: &_| {
+		result = Some(f(k));
+	};
+	db.with_get(col, key, &mut adapter);
+	result
+}
diff --git a/substrate/primitives/database/src/mem.rs b/substrate/primitives/database/src/mem.rs
new file mode 100644
index 0000000000000000000000000000000000000000..71ba7a992763683665070c0ac805d19d46c8c265
--- /dev/null
+++ b/substrate/primitives/database/src/mem.rs
@@ -0,0 +1,89 @@
+// 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.
+
+//! In-memory implementation of `Database`
+
+use crate::{error, Change, ColumnId, Database, Transaction};
+use parking_lot::RwLock;
+use std::collections::{hash_map::Entry, HashMap};
+
+#[derive(Default)]
+/// This implements `Database` as an in-memory hash map. `commit` is not atomic.
+pub struct MemDb(RwLock<HashMap<ColumnId, HashMap<Vec<u8>, (u32, Vec<u8>)>>>);
+
+impl<H> Database<H> for MemDb
+where
+	H: Clone + AsRef<[u8]>,
+{
+	fn commit(&self, transaction: Transaction<H>) -> error::Result<()> {
+		let mut s = self.0.write();
+		for change in transaction.0.into_iter() {
+			match change {
+				Change::Set(col, key, value) => {
+					s.entry(col).or_default().insert(key, (1, value));
+				},
+				Change::Remove(col, key) => {
+					s.entry(col).or_default().remove(&key);
+				},
+				Change::Store(col, hash, value) => {
+					s.entry(col)
+						.or_default()
+						.entry(hash.as_ref().to_vec())
+						.and_modify(|(c, _)| *c += 1)
+						.or_insert_with(|| (1, value));
+				},
+				Change::Reference(col, hash) => {
+					if let Entry::Occupied(mut entry) =
+						s.entry(col).or_default().entry(hash.as_ref().to_vec())
+					{
+						entry.get_mut().0 += 1;
+					}
+				},
+				Change::Release(col, hash) => {
+					if let Entry::Occupied(mut entry) =
+						s.entry(col).or_default().entry(hash.as_ref().to_vec())
+					{
+						entry.get_mut().0 -= 1;
+						if entry.get().0 == 0 {
+							entry.remove();
+						}
+					}
+				},
+			}
+		}
+
+		Ok(())
+	}
+
+	fn get(&self, col: ColumnId, key: &[u8]) -> Option<Vec<u8>> {
+		let s = self.0.read();
+		s.get(&col).and_then(|c| c.get(key).map(|(_, v)| v.clone()))
+	}
+}
+
+impl MemDb {
+	/// Create a new instance
+	pub fn new() -> Self {
+		MemDb::default()
+	}
+
+	/// Count number of values in a column
+	pub fn count(&self, col: ColumnId) -> usize {
+		let s = self.0.read();
+		s.get(&col).map(|c| c.len()).unwrap_or(0)
+	}
+}
diff --git a/substrate/primitives/debug-derive/Cargo.toml b/substrate/primitives/debug-derive/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..bbac79a8465040dcf2bc4c9701e1a6b4006501bd
--- /dev/null
+++ b/substrate/primitives/debug-derive/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "sp-debug-derive"
+version = "8.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Macros to derive runtime debug implementation."
+documentation = "https://docs.rs/sp-debug-derive"
+
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.28"
+syn = "2.0.16"
+proc-macro2 = "1.0.56"
+
+[features]
+default = [ "std" ]
+std = []
+# By default `RuntimeDebug` implements `Debug` that outputs `<wasm:stripped>` when `std` is
+# disabled. However, sometimes downstream users need to have the real `Debug` implementation for
+# debugging purposes. If this is required, a user only needs to add this crate as a dependency of
+# their runtime and enable the `force-debug` feature.
+force-debug = []
+
+[dev-dependencies]
diff --git a/substrate/primitives/debug-derive/src/impls.rs b/substrate/primitives/debug-derive/src/impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..76ef8367277b96164ec34fef87fe1f6ab4ae8668
--- /dev/null
+++ b/substrate/primitives/debug-derive/src/impls.rs
@@ -0,0 +1,187 @@
+// 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 proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse_quote, Data, DeriveInput};
+
+pub fn debug_derive(ast: DeriveInput) -> proc_macro::TokenStream {
+	let name_str = ast.ident.to_string();
+	let implementation = implementation::derive(&name_str, &ast.data);
+	let name = &ast.ident;
+	let mut generics = ast.generics.clone();
+	let (impl_generics, ty_generics, where_clause) = {
+		let wh = generics.make_where_clause();
+		for t in ast.generics.type_params() {
+			let name = &t.ident;
+			wh.predicates.push(parse_quote! { #name : core::fmt::Debug });
+		}
+		generics.split_for_impl()
+	};
+	let gen = quote! {
+		impl #impl_generics core::fmt::Debug for #name #ty_generics #where_clause {
+			fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
+				#implementation
+			}
+		}
+	};
+
+	gen.into()
+}
+
+#[cfg(all(not(feature = "std"), not(feature = "force-debug")))]
+mod implementation {
+	use super::*;
+
+	/// Derive the inner implementation of `Debug::fmt` function.
+	///
+	/// Non-std environment. We do nothing to prevent bloating the size of runtime.
+	/// Implement `Printable` if you need to print the details.
+	pub fn derive(_name_str: &str, _data: &Data) -> TokenStream {
+		quote! {
+			fmt.write_str("<wasm:stripped>")
+		}
+	}
+}
+
+#[cfg(any(feature = "std", feature = "force-debug"))]
+mod implementation {
+	use super::*;
+	use proc_macro2::Span;
+	use syn::{token::SelfValue, Ident, Index};
+
+	/// Derive the inner implementation of `Debug::fmt` function.
+	pub fn derive(name_str: &str, data: &Data) -> TokenStream {
+		match *data {
+			Data::Struct(ref s) => derive_struct(name_str, &s.fields),
+			Data::Union(ref u) => derive_fields(name_str, Fields::new(u.fields.named.iter(), None)),
+			Data::Enum(ref e) => derive_enum(name_str, e),
+		}
+	}
+
+	enum Fields {
+		Indexed { indices: Vec<Index> },
+		Unnamed { vars: Vec<Ident> },
+		Named { names: Vec<Ident>, this: Option<SelfValue> },
+	}
+
+	impl Fields {
+		fn new<'a>(fields: impl Iterator<Item = &'a syn::Field>, this: Option<SelfValue>) -> Self {
+			let mut indices = vec![];
+			let mut names = vec![];
+
+			for (i, f) in fields.enumerate() {
+				if let Some(ident) = f.ident.clone() {
+					names.push(ident);
+				} else {
+					indices.push(Index::from(i));
+				}
+			}
+
+			if names.is_empty() {
+				Self::Indexed { indices }
+			} else {
+				Self::Named { names, this }
+			}
+		}
+	}
+
+	fn derive_fields(name_str: &str, fields: Fields) -> TokenStream {
+		match fields {
+			Fields::Named { names, this } => {
+				let names_str: Vec<_> = names.iter().map(|x| x.to_string()).collect();
+
+				let fields = match this {
+					None => quote! { #( .field(#names_str, #names) )* },
+					Some(this) => quote! { #( .field(#names_str, &#this.#names) )* },
+				};
+
+				quote! {
+					fmt.debug_struct(#name_str)
+						#fields
+						.finish()
+				}
+			},
+			Fields::Indexed { indices } => {
+				quote! {
+					fmt.debug_tuple(#name_str)
+						#( .field(&self.#indices) )*
+						.finish()
+				}
+			},
+			Fields::Unnamed { vars } => {
+				quote! {
+					fmt.debug_tuple(#name_str)
+						#( .field(#vars) )*
+						.finish()
+				}
+			},
+		}
+	}
+
+	fn derive_enum(name: &str, e: &syn::DataEnum) -> TokenStream {
+		let v = e.variants.iter().map(|v| {
+			let name = format!("{}::{}", name, v.ident);
+			let ident = &v.ident;
+			match v.fields {
+				syn::Fields::Named(ref f) => {
+					let names: Vec<_> = f.named.iter().flat_map(|f| f.ident.clone()).collect();
+					let fields_impl =
+						derive_fields(&name, Fields::Named { names: names.clone(), this: None });
+					(ident, (quote! { { #( ref #names ),* } }, fields_impl))
+				},
+				syn::Fields::Unnamed(ref f) => {
+					let names = f
+						.unnamed
+						.iter()
+						.enumerate()
+						.map(|(id, _)| Ident::new(&format!("a{}", id), Span::call_site()))
+						.collect::<Vec<_>>();
+					let fields_impl = derive_fields(&name, Fields::Unnamed { vars: names.clone() });
+					(ident, (quote! { ( #( ref #names ),* ) }, fields_impl))
+				},
+				syn::Fields::Unit => {
+					let fields_impl = derive_fields(&name, Fields::Indexed { indices: vec![] });
+					(ident, (quote! {}, fields_impl))
+				},
+			}
+		});
+
+		type Vecs<A, B> = (Vec<A>, Vec<B>);
+		let (variants, others): Vecs<_, _> = v.unzip();
+		let (match_fields, variants_impl): Vecs<_, _> = others.into_iter().unzip();
+
+		quote! {
+			match self {
+				#( Self::#variants #match_fields => #variants_impl, )*
+				_ => Ok(()),
+			}
+		}
+	}
+
+	fn derive_struct(name_str: &str, fields: &syn::Fields) -> TokenStream {
+		match *fields {
+			syn::Fields::Named(ref f) => derive_fields(
+				name_str,
+				Fields::new(f.named.iter(), Some(syn::Token!(self)(Span::call_site()))),
+			),
+			syn::Fields::Unnamed(ref f) =>
+				derive_fields(name_str, Fields::new(f.unnamed.iter(), None)),
+			syn::Fields::Unit => derive_fields(name_str, Fields::Indexed { indices: vec![] }),
+		}
+	}
+}
diff --git a/substrate/primitives/debug-derive/src/lib.rs b/substrate/primitives/debug-derive/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..639dbb6df189cfb25508f700dcaa99018b70280b
--- /dev/null
+++ b/substrate/primitives/debug-derive/src/lib.rs
@@ -0,0 +1,42 @@
+// 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.
+
+//! Macros to derive runtime debug implementation.
+//!
+//! This custom derive implements a `core::fmt::Debug` trait,
+//! but in case the `std` feature is enabled the implementation
+//! will actually print out the structure as regular `derive(Debug)`
+//! would do. If `std` is disabled the implementation will be empty.
+//!
+//! This behaviour is useful to prevent bloating the runtime WASM
+//! blob from unneeded code.
+//!
+//! ```rust
+//! #[derive(sp_debug_derive::RuntimeDebug)]
+//! struct MyStruct;
+//!
+//! assert_eq!(format!("{:?}", MyStruct), "MyStruct");
+//! ```
+
+mod impls;
+
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(RuntimeDebug)]
+pub fn debug_derive(input: TokenStream) -> TokenStream {
+	impls::debug_derive(syn::parse_macro_input!(input))
+}
diff --git a/substrate/primitives/debug-derive/tests/tests.rs b/substrate/primitives/debug-derive/tests/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..da521068e0dcd825086d3d805a89ae159695993f
--- /dev/null
+++ b/substrate/primitives/debug-derive/tests/tests.rs
@@ -0,0 +1,48 @@
+// 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 sp_debug_derive::RuntimeDebug;
+
+#[derive(RuntimeDebug)]
+struct Unnamed(u64, String);
+
+#[derive(RuntimeDebug)]
+struct Named {
+	a: u64,
+	b: String,
+}
+
+#[derive(RuntimeDebug)]
+enum EnumLongName<A> {
+	A,
+	B(A, String),
+	VariantLongName { a: A, b: String },
+}
+
+#[test]
+fn should_display_proper_debug() {
+	use self::EnumLongName as Enum;
+
+	assert_eq!(format!("{:?}", Unnamed(1, "abc".into())), "Unnamed(1, \"abc\")");
+	assert_eq!(format!("{:?}", Named { a: 1, b: "abc".into() }), "Named { a: 1, b: \"abc\" }");
+	assert_eq!(format!("{:?}", Enum::<u64>::A), "EnumLongName::A");
+	assert_eq!(format!("{:?}", Enum::B(1, "abc".into())), "EnumLongName::B(1, \"abc\")");
+	assert_eq!(
+		format!("{:?}", Enum::VariantLongName { a: 1, b: "abc".into() }),
+		"EnumLongName::VariantLongName { a: 1, b: \"abc\" }"
+	);
+}
diff --git a/substrate/primitives/externalities/Cargo.toml b/substrate/primitives/externalities/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..58edbf83a3cef6f779209d4c9e91660e537ac5e7
--- /dev/null
+++ b/substrate/primitives/externalities/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "sp-externalities"
+version = "0.19.0"
+license = "Apache-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate externalities abstraction"
+documentation = "https://docs.rs/sp-externalities"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+environmental = { version = "1.1.3", default-features = false }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-storage = { version = "13.0.0", default-features = false, path = "../storage" }
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "environmental/std", "sp-std/std", "sp-storage/std" ]
diff --git a/substrate/primitives/externalities/README.md b/substrate/primitives/externalities/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3141b2609e6375063dc42b089489451973393cba
--- /dev/null
+++ b/substrate/primitives/externalities/README.md
@@ -0,0 +1,9 @@
+Substrate externalities abstraction
+
+The externalities mainly provide access to storage and to registered extensions. Extensions
+are for example the keystore or the offchain externalities. These externalities are used to
+access the node from the runtime via the runtime interfaces.
+
+This crate exposes the main [`Externalities`] trait.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/externalities/src/extensions.rs b/substrate/primitives/externalities/src/extensions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8b0bbd2c5921b217aadf889adef81dc7a63be0b0
--- /dev/null
+++ b/substrate/primitives/externalities/src/extensions.rs
@@ -0,0 +1,238 @@
+// 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.
+
+//! Externalities extensions storage.
+//!
+//! Externalities support to register a wide variety custom extensions. The [`Extensions`] provides
+//! some convenience functionality to store and retrieve these extensions.
+//!
+//! It is required that each extension implements the [`Extension`] trait.
+
+use crate::Error;
+use sp_std::{
+	any::{Any, TypeId},
+	boxed::Box,
+	collections::btree_map::{BTreeMap, Entry},
+	ops::DerefMut,
+};
+
+/// Marker trait for types that should be registered as [`Externalities`](crate::Externalities)
+/// extension.
+///
+/// As extensions are stored as `Box<Any>`, this trait should give more confidence that the correct
+/// type is registered and requested.
+pub trait Extension: Send + Any {
+	/// Return the extension as `&mut dyn Any`.
+	///
+	/// This is a trick to make the trait type castable into an `Any`.
+	fn as_mut_any(&mut self) -> &mut dyn Any;
+}
+
+impl Extension for Box<dyn Extension> {
+	fn as_mut_any(&mut self) -> &mut dyn Any {
+		(**self).as_mut_any()
+	}
+}
+
+/// Macro for declaring an extension that usable with [`Extensions`].
+///
+/// The extension will be an unit wrapper struct that implements [`Extension`], `Deref` and
+/// `DerefMut`. The wrapped type is given by the user.
+///
+/// # Example
+/// ```
+/// # use sp_externalities::decl_extension;
+/// decl_extension! {
+///     /// Some test extension
+///     struct TestExt(String);
+/// }
+/// ```
+#[macro_export]
+macro_rules! decl_extension {
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis struct $ext_name:ident ($inner:ty);
+	) => {
+		$( #[ $attr ] )*
+		$vis struct $ext_name (pub $inner);
+
+		impl $crate::Extension for $ext_name {
+			fn as_mut_any(&mut self) -> &mut dyn std::any::Any {
+				self
+			}
+		}
+
+		impl std::ops::Deref for $ext_name {
+			type Target = $inner;
+
+			fn deref(&self) -> &Self::Target {
+				&self.0
+			}
+		}
+
+		impl std::ops::DerefMut for $ext_name {
+			fn deref_mut(&mut self) -> &mut Self::Target {
+				&mut self.0
+			}
+		}
+
+		impl From<$inner> for $ext_name {
+			fn from(inner: $inner) -> Self {
+				Self(inner)
+			}
+ 		}
+	};
+	(
+		$( #[ $attr:meta ] )*
+		$vis:vis struct $ext_name:ident;
+	) => {
+		$( #[ $attr ] )*
+		$vis struct $ext_name;
+
+		impl $crate::Extension for $ext_name {
+			fn as_mut_any(&mut self) -> &mut dyn std::any::Any {
+				self
+			}
+		}
+	}
+}
+
+/// Something that provides access to the [`Extensions`] store.
+///
+/// This is a super trait of the [`Externalities`](crate::Externalities).
+pub trait ExtensionStore {
+	/// Tries to find a registered extension by the given `type_id` and returns it as a `&mut dyn
+	/// Any`.
+	///
+	/// It is advised to use [`ExternalitiesExt::extension`](crate::ExternalitiesExt::extension)
+	/// instead of this function to get type system support and automatic type downcasting.
+	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any>;
+
+	/// Register extension `extension` with specified `type_id`.
+	///
+	/// It should return error if extension is already registered.
+	fn register_extension_with_type_id(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn Extension>,
+	) -> Result<(), Error>;
+
+	/// Deregister extension with specified 'type_id' and drop it.
+	///
+	/// It should return error if extension is not registered.
+	fn deregister_extension_by_type_id(&mut self, type_id: TypeId) -> Result<(), Error>;
+}
+
+/// Stores extensions that should be made available through the externalities.
+#[derive(Default)]
+pub struct Extensions {
+	extensions: BTreeMap<TypeId, Box<dyn Extension>>,
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Debug for Extensions {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "Extensions: ({})", self.extensions.len())
+	}
+}
+
+impl Extensions {
+	/// Create new instance of `Self`.
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	/// Register the given extension.
+	pub fn register<E: Extension>(&mut self, ext: E) {
+		let type_id = ext.type_id();
+		self.extensions.insert(type_id, Box::new(ext));
+	}
+
+	/// Register extension `extension` using the given `type_id`.
+	pub fn register_with_type_id(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn Extension>,
+	) -> Result<(), Error> {
+		match self.extensions.entry(type_id) {
+			Entry::Vacant(vacant) => {
+				vacant.insert(extension);
+				Ok(())
+			},
+			Entry::Occupied(_) => Err(Error::ExtensionAlreadyRegistered),
+		}
+	}
+
+	/// Return a mutable reference to the requested extension.
+	pub fn get_mut(&mut self, ext_type_id: TypeId) -> Option<&mut dyn Any> {
+		self.extensions
+			.get_mut(&ext_type_id)
+			.map(DerefMut::deref_mut)
+			.map(Extension::as_mut_any)
+	}
+
+	/// Deregister extension for the given `type_id`.
+	///
+	/// Returns `true` when the extension was registered.
+	pub fn deregister(&mut self, type_id: TypeId) -> bool {
+		self.extensions.remove(&type_id).is_some()
+	}
+
+	/// Returns a mutable iterator over all extensions.
+	pub fn iter_mut(&mut self) -> impl Iterator<Item = (&TypeId, &mut Box<dyn Extension>)> {
+		self.extensions.iter_mut()
+	}
+
+	/// Merge `other` into `self`.
+	///
+	/// If both contain the same extension, the extension instance of `other` will overwrite the
+	/// instance found in `self`.
+	pub fn merge(&mut self, other: Self) {
+		self.extensions.extend(other.extensions);
+	}
+}
+
+impl Extend<Extensions> for Extensions {
+	fn extend<T: IntoIterator<Item = Extensions>>(&mut self, iter: T) {
+		iter.into_iter()
+			.for_each(|ext| self.extensions.extend(ext.extensions.into_iter()));
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	decl_extension! {
+		struct DummyExt(u32);
+	}
+	decl_extension! {
+		struct DummyExt2(u32);
+	}
+
+	#[test]
+	fn register_and_retrieve_extension() {
+		let mut exts = Extensions::new();
+		exts.register(DummyExt(1));
+		exts.register(DummyExt2(2));
+
+		let ext = exts.get_mut(TypeId::of::<DummyExt>()).expect("Extension is registered");
+		let ext_ty = ext.downcast_mut::<DummyExt>().expect("Downcasting works");
+
+		assert_eq!(ext_ty.0, 1);
+	}
+}
diff --git a/substrate/primitives/externalities/src/lib.rs b/substrate/primitives/externalities/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..411ec97a6b82423ee6053027f03deeb802f361d0
--- /dev/null
+++ b/substrate/primitives/externalities/src/lib.rs
@@ -0,0 +1,343 @@
+// 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)]
+
+//! Substrate externalities abstraction
+//!
+//! The externalities mainly provide access to storage and to registered extensions. Extensions
+//! are for example the keystore or the offchain externalities. These externalities are used to
+//! access the node from the runtime via the runtime interfaces.
+//!
+//! This crate exposes the main [`Externalities`] trait.
+
+use sp_std::{
+	any::{Any, TypeId},
+	boxed::Box,
+	vec::Vec,
+};
+
+use sp_storage::{ChildInfo, StateVersion, TrackedStorageKey};
+
+pub use extensions::{Extension, ExtensionStore, Extensions};
+pub use scope_limited::{set_and_run_with_externalities, with_externalities};
+
+mod extensions;
+mod scope_limited;
+
+/// Externalities error.
+#[derive(Debug)]
+pub enum Error {
+	/// Same extension cannot be registered twice.
+	ExtensionAlreadyRegistered,
+	/// Extensions are not supported.
+	ExtensionsAreNotSupported,
+	/// Extension `TypeId` is not registered.
+	ExtensionIsNotRegistered(TypeId),
+	/// Failed to update storage,
+	StorageUpdateFailed(&'static str),
+}
+
+/// Results concerning an operation to remove many keys.
+#[derive(codec::Encode, codec::Decode)]
+#[must_use]
+pub struct MultiRemovalResults {
+	/// A continuation cursor which, if `Some` must be provided to the subsequent removal call.
+	/// If `None` then all removals are complete and no further calls are needed.
+	pub maybe_cursor: Option<Vec<u8>>,
+	/// The number of items removed from the backend database.
+	pub backend: u32,
+	/// The number of unique keys removed, taking into account both the backend and the overlay.
+	pub unique: u32,
+	/// The number of iterations (each requiring a storage seek/read) which were done.
+	pub loops: u32,
+}
+
+impl MultiRemovalResults {
+	/// Deconstruct into the internal components.
+	///
+	/// Returns `(maybe_cursor, backend, unique, loops)`.
+	pub fn deconstruct(self) -> (Option<Vec<u8>>, u32, u32, u32) {
+		(self.maybe_cursor, self.backend, self.unique, self.loops)
+	}
+}
+
+/// The Substrate externalities.
+///
+/// Provides access to the storage and to other registered extensions.
+pub trait Externalities: ExtensionStore {
+	/// Write a key value pair to the offchain storage database.
+	fn set_offchain_storage(&mut self, key: &[u8], value: Option<&[u8]>);
+
+	/// Read runtime storage.
+	fn storage(&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>>;
+
+	/// 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>>;
+
+	/// 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>>;
+
+	/// Set storage entry `key` of current contract being called (effective immediately).
+	fn set_storage(&mut self, key: Vec<u8>, value: Vec<u8>) {
+		self.place_storage(key, Some(value));
+	}
+
+	/// Set child storage entry `key` of current contract being called (effective immediately).
+	fn set_child_storage(&mut self, child_info: &ChildInfo, key: Vec<u8>, value: Vec<u8>) {
+		self.place_child_storage(child_info, key, Some(value))
+	}
+
+	/// Clear a storage entry (`key`) of current contract being called (effective immediately).
+	fn clear_storage(&mut self, key: &[u8]) {
+		self.place_storage(key.to_vec(), None);
+	}
+
+	/// Clear a child storage entry (`key`) of current contract being called (effective
+	/// immediately).
+	fn clear_child_storage(&mut self, child_info: &ChildInfo, key: &[u8]) {
+		self.place_child_storage(child_info, key.to_vec(), None)
+	}
+
+	/// Whether a storage entry exists.
+	fn exists_storage(&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 {
+		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>>;
+
+	/// 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>>;
+
+	/// Clear an entire child storage.
+	///
+	/// Deletes all keys from the overlay and up to `maybe_limit` keys from the backend. No
+	/// limit is applied if `maybe_limit` is `None`. Returns the cursor for the next call as `Some`
+	/// if the child trie deletion operation is incomplete. In this case, it should be passed into
+	/// the next call to avoid unaccounted iterations on the backend. Returns also the the number
+	/// of keys that were removed from the backend, the number of unique keys removed in total
+	/// (including from the overlay) and the number of backend iterations done.
+	///
+	/// As long as `maybe_cursor` is passed from the result of the previous call, then the number of
+	/// iterations done will only ever be one more than the number of keys removed.
+	///
+	/// # Note
+	///
+	/// An implementation is free to delete more keys than the specified limit as long as
+	/// it is able to do that in constant time.
+	fn kill_child_storage(
+		&mut self,
+		child_info: &ChildInfo,
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults;
+
+	/// Clear storage entries which keys are start with the given prefix.
+	///
+	/// `maybe_limit`, `maybe_cursor` and result works as for `kill_child_storage`.
+	fn clear_prefix(
+		&mut self,
+		prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults;
+
+	/// Clear child storage entries which keys are start with the given prefix.
+	///
+	/// `maybe_limit`, `maybe_cursor` and result works as for `kill_child_storage`.
+	fn clear_child_prefix(
+		&mut self,
+		child_info: &ChildInfo,
+		prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults;
+
+	/// Set or clear a storage entry (`key`) of current contract being called (effective
+	/// immediately).
+	fn place_storage(&mut self, key: Vec<u8>, value: Option<Vec<u8>>);
+
+	/// Set or clear a child storage entry.
+	fn place_child_storage(&mut self, child_info: &ChildInfo, key: Vec<u8>, value: Option<Vec<u8>>);
+
+	/// Get the trie root of the current storage map.
+	///
+	/// This will also update all child storage keys in the top-level storage map.
+	///
+	/// The returned hash is defined by the `Block` and is SCALE encoded.
+	fn storage_root(&mut self, state_version: StateVersion) -> Vec<u8>;
+
+	/// Get the trie root of a child storage map.
+	///
+	/// This will also update the value of the child storage keys in the top-level storage map.
+	///
+	/// If the storage root equals the default hash as defined by the trie, the key in the top-level
+	/// storage map will be removed.
+	fn child_storage_root(
+		&mut self,
+		child_info: &ChildInfo,
+		state_version: StateVersion,
+	) -> Vec<u8>;
+
+	/// Append storage item.
+	///
+	/// This assumes specific format of the storage item. Also there is no way to undo this
+	/// operation.
+	fn storage_append(&mut self, key: Vec<u8>, value: Vec<u8>);
+
+	/// Start a new nested transaction.
+	///
+	/// This allows to either commit or roll back all changes made after this call to the
+	/// top changes or the default child changes. For every transaction there cam be a
+	/// matching call to either `storage_rollback_transaction` or `storage_commit_transaction`.
+	/// Any transactions that are still open after returning from runtime are committed
+	/// automatically.
+	///
+	/// Changes made without any open transaction are committed immediately.
+	fn storage_start_transaction(&mut self);
+
+	/// Rollback the last transaction started by `storage_start_transaction`.
+	///
+	/// Any changes made during that storage transaction are discarded. Returns an error when
+	/// no transaction is open that can be closed.
+	fn storage_rollback_transaction(&mut self) -> Result<(), ()>;
+
+	/// Commit the last transaction started by `storage_start_transaction`.
+	///
+	/// Any changes made during that storage transaction are committed. Returns an error when
+	/// no transaction is open that can be closed.
+	fn storage_commit_transaction(&mut self) -> Result<(), ()>;
+
+	/// Index specified transaction slice and store it.
+	fn storage_index_transaction(&mut self, _index: u32, _hash: &[u8], _size: u32) {
+		unimplemented!("storage_index_transaction");
+	}
+
+	/// Renew existing piece of transaction storage.
+	fn storage_renew_transaction_index(&mut self, _index: u32, _hash: &[u8]) {
+		unimplemented!("storage_renew_transaction_index");
+	}
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Wipes all changes from caches and the database.
+	///
+	/// The state will be reset to genesis.
+	fn wipe(&mut self);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Commits all changes to the database and clears all caches.
+	fn commit(&mut self);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Gets the current read/write count for the benchmarking process.
+	fn read_write_count(&self) -> (u32, u32, u32, u32);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Resets read/write count for the benchmarking process.
+	fn reset_read_write_count(&mut self);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Gets the current DB tracking whitelist.
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey>;
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Adds new storage keys to the DB tracking whitelist.
+	fn set_whitelist(&mut self, new: Vec<TrackedStorageKey>);
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Returns estimated proof size for the state queries so far.
+	/// Proof is reset on commit and wipe.
+	fn proof_size(&self) -> Option<u32> {
+		None
+	}
+
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	/// Benchmarking related functionality and shouldn't be used anywhere else!
+	/// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	///
+	/// Get all the keys that have been read or written to during the benchmark.
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)>;
+}
+
+/// Extension for the [`Externalities`] trait.
+pub trait ExternalitiesExt {
+	/// Tries to find a registered extension and returns a mutable reference.
+	fn extension<T: Any + Extension>(&mut self) -> Option<&mut T>;
+
+	/// Register extension `ext`.
+	///
+	/// Should return error if extension is already registered or extensions are not supported.
+	fn register_extension<T: Extension>(&mut self, ext: T) -> Result<(), Error>;
+
+	/// Deregister and drop extension of `T` type.
+	///
+	/// Should return error if extension of type `T` is not registered or
+	/// extensions are not supported.
+	fn deregister_extension<T: Extension>(&mut self) -> Result<(), Error>;
+}
+
+impl ExternalitiesExt for &mut dyn Externalities {
+	fn extension<T: Any + Extension>(&mut self) -> Option<&mut T> {
+		self.extension_by_type_id(TypeId::of::<T>()).and_then(<dyn Any>::downcast_mut)
+	}
+
+	fn register_extension<T: Extension>(&mut self, ext: T) -> Result<(), Error> {
+		self.register_extension_with_type_id(TypeId::of::<T>(), Box::new(ext))
+	}
+
+	fn deregister_extension<T: Extension>(&mut self) -> Result<(), Error> {
+		self.deregister_extension_by_type_id(TypeId::of::<T>())
+	}
+}
diff --git a/substrate/primitives/externalities/src/scope_limited.rs b/substrate/primitives/externalities/src/scope_limited.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2167db7c15280971dc2d274ba7daf481512e23fe
--- /dev/null
+++ b/substrate/primitives/externalities/src/scope_limited.rs
@@ -0,0 +1,39 @@
+// 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.
+
+//! Stores the externalities in an `environmental` value to make it scope limited available.
+
+use crate::Externalities;
+
+environmental::environmental!(ext: trait Externalities);
+
+/// Set the given externalities while executing the given closure. To get access to the
+/// externalities while executing the given closure [`with_externalities`] grants access to them.
+/// The externalities are only set for the same thread this function was called from.
+pub fn set_and_run_with_externalities<F, R>(ext: &mut dyn Externalities, f: F) -> R
+where
+	F: FnOnce() -> R,
+{
+	ext::using(ext, f)
+}
+
+/// Execute the given closure with the currently set externalities.
+///
+/// Returns `None` if no externalities are set or `Some(_)` with the result of the closure.
+pub fn with_externalities<F: FnOnce(&mut dyn Externalities) -> R, R>(f: F) -> Option<R> {
+	ext::with(f)
+}
diff --git a/substrate/primitives/genesis-builder/Cargo.toml b/substrate/primitives/genesis-builder/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7760ceb3b6dbd490cd0ec5cce8222ccb869696b3
--- /dev/null
+++ b/substrate/primitives/genesis-builder/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "sp-genesis-builder"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate GenesisConfig builder API"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+serde_json = { version = "1.0.85", default-features = false, features = ["alloc"] }
+
+[features]
+default = [ "std" ]
+std = [ "serde_json/std", "sp-api/std", "sp-runtime/std", "sp-std/std" ]
diff --git a/substrate/primitives/genesis-builder/README.md b/substrate/primitives/genesis-builder/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a842c95e358ea39968e4f50fd6f3e3d1b67240e
--- /dev/null
+++ b/substrate/primitives/genesis-builder/README.md
@@ -0,0 +1,5 @@
+Substrate genesis builder.
+
+Refer to the module doc for more details.
+
+License: Apache-2.0
diff --git a/substrate/primitives/genesis-builder/src/lib.rs b/substrate/primitives/genesis-builder/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e002cd3aa6f704d8889fd35d04fdd65b46a1b754
--- /dev/null
+++ b/substrate/primitives/genesis-builder/src/lib.rs
@@ -0,0 +1,54 @@
+// 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)]
+
+//! Substrate genesis config builder
+//!
+//! This Runtime API allows to construct `GenesisConfig`, in particular:
+//! - serialize the runtime default `GenesisConfig` struct into json format,
+//! - put the GenesisConfig struct into the storage. Internally this operation calls
+//!   `GenesisBuild::build` function for all runtime pallets, which is typically provided by
+//!   pallet's author.
+//! - deserialize the `GenesisConfig` from given json blob and put `GenesisConfig` into the state
+//!   storage. Allows to build customized configuration.
+//!
+//! Providing externalities with empty storage and putting `GenesisConfig` into storage allows to
+//! catch and build the raw storage of `GenesisConfig` which is the foundation for genesis block.
+
+/// The result type alias, used in build methods. `Err` contains formatted error message.
+pub type Result = core::result::Result<(), sp_runtime::RuntimeString>;
+
+sp_api::decl_runtime_apis! {
+	/// API to interact with GenesisConfig for the runtime
+	pub trait GenesisBuilder {
+		/// Creates the default `GenesisConfig` and returns it as a JSON blob.
+		///
+		/// This function instantiates the default `GenesisConfig` struct for the runtime and serializes it into a JSON
+		/// blob. It returns a `Vec<u8>` containing the JSON representation of the default `GenesisConfig`.
+		fn create_default_config() -> sp_std::vec::Vec<u8>;
+
+		/// Build `GenesisConfig` from a JSON blob not using any defaults and store it in the storage.
+		///
+		/// This function deserializes the full `GenesisConfig` from the given JSON blob and puts it into the storage.
+		/// If the provided JSON blob is incorrect or incomplete or the deserialization fails, an error is returned.
+		/// It is recommended to log any errors encountered during the process.
+		///
+		/// Please note that provided json blob must contain all `GenesisConfig` fields, no defaults will be used.
+		fn build_config(json: sp_std::vec::Vec<u8>) -> Result;
+	}
+}
diff --git a/substrate/primitives/inherents/Cargo.toml b/substrate/primitives/inherents/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d42588ad21a365a3f83048ec416203f44cca5ced
--- /dev/null
+++ b/substrate/primitives/inherents/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "sp-inherents"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Provides types and traits for creating and checking inherents."
+documentation = "https://docs.rs/sp-inherents"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = { version = "0.1.57", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+impl-trait-for-tuples = "0.2.2"
+thiserror = { version = "1.0.30", optional = true }
+sp-runtime = { version = "24.0.0", optional = true, default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[dev-dependencies]
+futures = "0.3.21"
+
+[features]
+default = [ "std" ]
+std = [
+	"async-trait",
+	"codec/std",
+	"scale-info/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"thiserror",
+]
diff --git a/substrate/primitives/inherents/README.md b/substrate/primitives/inherents/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..78aa625fe85692b1d53164415a5b2086d5704186
--- /dev/null
+++ b/substrate/primitives/inherents/README.md
@@ -0,0 +1,17 @@
+Provides types and traits for creating and checking inherents.
+
+Each inherent is added to a produced block. Each runtime decides on which inherents it
+wants to attach to its blocks. All data that is required for the runtime to create the inherents
+is stored in the `InherentData`. This `InherentData` is constructed by the node and given to
+the runtime.
+
+Types that provide data for inherents, should implement `InherentDataProvider` and need to be
+registered at `InherentDataProviders`.
+
+In the runtime, modules need to implement `ProvideInherent` when they can create and/or check
+inherents. By implementing `ProvideInherent`, a module is not enforced to create an inherent.
+A module can also just check given inherents. For using a module as inherent provider, it needs
+to be registered by the `construct_runtime!` macro. The macro documentation gives more
+information on how that is done.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/inherents/src/client_side.rs b/substrate/primitives/inherents/src/client_side.rs
new file mode 100644
index 0000000000000000000000000000000000000000..27479de136f2dedb333883e642d7ddc899446c45
--- /dev/null
+++ b/substrate/primitives/inherents/src/client_side.rs
@@ -0,0 +1,127 @@
+// 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::{Error, InherentData, InherentIdentifier};
+use sp_runtime::traits::Block as BlockT;
+
+/// Something that can create inherent data providers.
+///
+/// It is possible for the caller to provide custom arguments to the callee by setting the
+/// `ExtraArgs` generic parameter.
+///
+/// The crate already provides some convience implementations of this trait for
+/// `Box<dyn CreateInherentDataProviders>` and closures. So, it should not be required to implement
+/// this trait manually.
+#[async_trait::async_trait]
+pub trait CreateInherentDataProviders<Block: BlockT, ExtraArgs>: Send + Sync {
+	/// The inherent data providers that will be created.
+	type InherentDataProviders: InherentDataProvider;
+
+	/// Create the inherent data providers at the given `parent` block using the given `extra_args`.
+	async fn create_inherent_data_providers(
+		&self,
+		parent: Block::Hash,
+		extra_args: ExtraArgs,
+	) -> Result<Self::InherentDataProviders, Box<dyn std::error::Error + Send + Sync>>;
+}
+
+#[async_trait::async_trait]
+impl<F, Block, IDP, ExtraArgs, Fut> CreateInherentDataProviders<Block, ExtraArgs> for F
+where
+	Block: BlockT,
+	F: Fn(Block::Hash, ExtraArgs) -> Fut + Sync + Send,
+	Fut: std::future::Future<Output = Result<IDP, Box<dyn std::error::Error + Send + Sync>>>
+		+ Send
+		+ 'static,
+	IDP: InherentDataProvider + 'static,
+	ExtraArgs: Send + 'static,
+{
+	type InherentDataProviders = IDP;
+
+	async fn create_inherent_data_providers(
+		&self,
+		parent: Block::Hash,
+		extra_args: ExtraArgs,
+	) -> Result<Self::InherentDataProviders, Box<dyn std::error::Error + Send + Sync>> {
+		(*self)(parent, extra_args).await
+	}
+}
+
+#[async_trait::async_trait]
+impl<Block: BlockT, ExtraArgs: Send, IDPS: InherentDataProvider>
+	CreateInherentDataProviders<Block, ExtraArgs>
+	for Box<dyn CreateInherentDataProviders<Block, ExtraArgs, InherentDataProviders = IDPS>>
+{
+	type InherentDataProviders = IDPS;
+
+	async fn create_inherent_data_providers(
+		&self,
+		parent: Block::Hash,
+		extra_args: ExtraArgs,
+	) -> Result<Self::InherentDataProviders, Box<dyn std::error::Error + Send + Sync>> {
+		(**self).create_inherent_data_providers(parent, extra_args).await
+	}
+}
+
+/// Something that provides inherent data.
+#[async_trait::async_trait]
+pub trait InherentDataProvider: Send + Sync {
+	/// Convenience function for creating [`InherentData`].
+	///
+	/// Basically maps around [`Self::provide_inherent_data`].
+	async fn create_inherent_data(&self) -> Result<InherentData, Error> {
+		let mut inherent_data = InherentData::new();
+		self.provide_inherent_data(&mut inherent_data).await?;
+		Ok(inherent_data)
+	}
+
+	/// Provide inherent data that should be included in a block.
+	///
+	/// The data should be stored in the given `InherentData` structure.
+	async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error>;
+
+	/// Convert the given encoded error to a string.
+	///
+	/// If the given error could not be decoded, `None` should be returned.
+	async fn try_handle_error(
+		&self,
+		identifier: &InherentIdentifier,
+		error: &[u8],
+	) -> Option<Result<(), Error>>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+#[async_trait::async_trait]
+impl InherentDataProvider for Tuple {
+	for_tuples!( where #( Tuple: Send + Sync )* );
+	async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error> {
+		for_tuples!( #( Tuple.provide_inherent_data(inherent_data).await?; )* );
+		Ok(())
+	}
+
+	async fn try_handle_error(
+		&self,
+		identifier: &InherentIdentifier,
+		error: &[u8],
+	) -> Option<Result<(), Error>> {
+		for_tuples!( #(
+			if let Some(r) = Tuple.try_handle_error(identifier, error).await { return Some(r) }
+		)* );
+
+		None
+	}
+}
diff --git a/substrate/primitives/inherents/src/lib.rs b/substrate/primitives/inherents/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dd7c294f1e245126bd02ef14a470595dc13841bb
--- /dev/null
+++ b/substrate/primitives/inherents/src/lib.rs
@@ -0,0 +1,506 @@
+// 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.
+
+//! Substrate Inherent Extrinsics
+//!
+//! Inherent extrinsics are extrinsics that are inherently added to each block. However, it is up to
+//! the runtime implementation to require an inherent for each block or to make it optional.
+//! Inherents are mainly used to pass data from the block producer to the runtime. So, inherents
+//! require some part that is running on the client side and some part that is running on the
+//! runtime side. Any data that is required by an inherent is passed as [`InherentData`] from the
+//! client to the runtime when the inherents are constructed.
+//!
+//! The process of constructing and applying inherents is the following:
+//!
+//! 1. The block producer first creates the [`InherentData`] by using the inherent data providers
+//! that are created by [`CreateInherentDataProviders`].
+//!
+//! 2. The [`InherentData`] is passed to the `inherent_extrinsics` function of the `BlockBuilder`
+//! runtime api. This will call the runtime which will create all the inherents that should be
+//! applied to the block.
+//!
+//! 3. Apply each inherent to the block like any normal extrinsic.
+//!
+//! On block import the inherents in the block are checked by calling the `check_inherents` runtime
+//! API. This will also pass an instance of [`InherentData`] which the runtime can use to validate
+//! all inherents. If some inherent data isn't required for validating an inherent, it can be
+//! omitted when providing the inherent data providers for block import.
+//!
+//! # Providing inherent data
+//!
+//! To provide inherent data from the client side, [`InherentDataProvider`] should be implemented.
+//!
+//! ```
+//! use codec::Decode;
+//! use sp_inherents::{InherentIdentifier, InherentData};
+//!
+//! // This needs to be unique for the runtime.
+//! const INHERENT_IDENTIFIER: InherentIdentifier = *b"testinh0";
+//!
+//! /// Some custom inherent data provider
+//! struct InherentDataProvider;
+//!
+//! #[async_trait::async_trait]
+//! impl sp_inherents::InherentDataProvider for InherentDataProvider {
+//! 	async fn provide_inherent_data(
+//! 		&self,
+//! 		inherent_data: &mut InherentData,
+//! 	) -> Result<(), sp_inherents::Error> {
+//! 		// We can insert any data that implements [`codec::Encode`].
+//! 		inherent_data.put_data(INHERENT_IDENTIFIER, &"hello")
+//! 	}
+//!
+//! 	/// When validating the inherents, the runtime implementation can throw errors. We support
+//! 	/// two error modes, fatal and non-fatal errors. A fatal error means that the block is invalid
+//! 	/// and this function here should return `Err(_)` to not import the block. Non-fatal errors
+//! 	/// are allowed to be handled here in this function and the function should return `Ok(())`
+//! 	/// if it could be handled. A non-fatal error is for example that a block is in the future
+//! 	/// from the point of view of the local node. In such a case the block import for example
+//! 	/// should be delayed until the block is valid.
+//! 	///
+//! 	/// If this functions returns `None`, it means that it is not responsible for this error or
+//! 	/// that the error could not be interpreted.
+//! 	async fn try_handle_error(
+//! 		&self,
+//! 		identifier: &InherentIdentifier,
+//! 		mut error: &[u8],
+//! 	) -> Option<Result<(), sp_inherents::Error>> {
+//! 		// Check if this error belongs to us.
+//! 		if *identifier != INHERENT_IDENTIFIER {
+//! 			return None;
+//! 		}
+//!
+//! 		// For demonstration purposes we are using a `String` as error type. In real
+//! 		// implementations it is advised to not use `String`.
+//! 		Some(Err(
+//! 			sp_inherents::Error::Application(Box::from(String::decode(&mut error).ok()?))
+//! 		))
+//! 	}
+//! }
+//! ```
+//!
+//! In the service the relevant inherent data providers need to be passed the block production and
+//! the block import. As already highlighted above, the providers can be different between import
+//! and production.
+//!
+//! ```
+//! # use sp_runtime::testing::ExtrinsicWrapper;
+//! # use sp_inherents::{InherentIdentifier, InherentData};
+//! # use futures::FutureExt;
+//! # type Block = sp_runtime::testing::Block<ExtrinsicWrapper<()>>;
+//! # const INHERENT_IDENTIFIER: InherentIdentifier = *b"testinh0";
+//! # struct InherentDataProvider;
+//! # #[async_trait::async_trait]
+//! # impl sp_inherents::InherentDataProvider for InherentDataProvider {
+//! # 	async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), sp_inherents::Error> {
+//! # 		inherent_data.put_data(INHERENT_IDENTIFIER, &"hello")
+//! # 	}
+//! # 	async fn try_handle_error(
+//! # 		&self,
+//! # 		_: &InherentIdentifier,
+//! # 		_: &[u8],
+//! # 	) -> Option<Result<(), sp_inherents::Error>> {
+//! # 		None
+//! # 	}
+//! # }
+//!
+//! async fn cool_consensus_block_production(
+//! 	// The second parameter to the trait are parameters that depend on what the caller
+//! 	// can provide on extra data.
+//! 	_: impl sp_inherents::CreateInherentDataProviders<Block, ()>,
+//! ) {
+//! 	// do cool stuff
+//! }
+//!
+//! async fn cool_consensus_block_import(
+//! 	_: impl sp_inherents::CreateInherentDataProviders<Block, ()>,
+//! ) {
+//! 	// do cool stuff
+//! }
+//!
+//! async fn build_service(is_validator: bool) {
+//! 	// For block import we don't pass any inherent data provider, because our runtime
+//! 	// does not need any inherent data to validate the inherents.
+//! 	let block_import = cool_consensus_block_import(|_parent, ()| async { Ok(()) });
+//!
+//! 	let block_production = if is_validator {
+//! 		// For block production we want to provide our inherent data provider
+//! 		cool_consensus_block_production(|_parent, ()| async {
+//! 			Ok(InherentDataProvider)
+//! 		}).boxed()
+//! 	} else {
+//! 		futures::future::pending().boxed()
+//! 	};
+//!
+//! 	futures::pin_mut!(block_import);
+//!
+//! 	futures::future::select(block_import, block_production).await;
+//! }
+//! ```
+//!
+//! # Creating the inherent
+//!
+//! As the inherents are created by the runtime, it depends on the runtime implementation on how
+//! to create the inherents. As already described above the client side passes the [`InherentData`]
+//! and expects the runtime to construct the inherents out of it. When validating the inherents,
+//! [`CheckInherentsResult`] is used to communicate the result client side.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![warn(missing_docs)]
+
+use codec::{Decode, Encode};
+
+use sp_std::{
+	collections::btree_map::{BTreeMap, Entry, IntoIter},
+	vec::Vec,
+};
+
+#[cfg(feature = "std")]
+mod client_side;
+
+#[cfg(feature = "std")]
+pub use client_side::*;
+
+/// Errors that occur in context of inherents.
+#[derive(Debug)]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+#[allow(missing_docs)]
+pub enum Error {
+	#[cfg_attr(
+		feature = "std",
+		error("Inherent data already exists for identifier: {}", "String::from_utf8_lossy(_0)")
+	)]
+	InherentDataExists(InherentIdentifier),
+	#[cfg_attr(
+		feature = "std",
+		error("Failed to decode inherent data for identifier: {}", "String::from_utf8_lossy(_1)")
+	)]
+	DecodingFailed(#[cfg_attr(feature = "std", source)] codec::Error, InherentIdentifier),
+	#[cfg_attr(
+		feature = "std",
+		error("There was already a fatal error reported and no other errors are allowed")
+	)]
+	FatalErrorReported,
+	#[cfg(feature = "std")]
+	#[error(transparent)]
+	Application(#[from] Box<dyn std::error::Error + Send + Sync>),
+}
+
+/// An identifier for an inherent.
+pub type InherentIdentifier = [u8; 8];
+
+/// Inherent data to include in a block.
+#[derive(Clone, Default, Encode, Decode, scale_info::TypeInfo)]
+pub struct InherentData {
+	/// All inherent data encoded with parity-scale-codec and an identifier.
+	data: BTreeMap<InherentIdentifier, Vec<u8>>,
+}
+
+impl InherentData {
+	/// Create a new instance.
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	/// Put data for an inherent into the internal storage.
+	///
+	/// # Return
+	///
+	/// Returns `Ok(())` if the data could be inserted and no data for an inherent with the same
+	/// identifier existed, otherwise an error is returned.
+	///
+	/// Inherent identifiers need to be unique, otherwise decoding of these values will not work!
+	pub fn put_data<I: codec::Encode>(
+		&mut self,
+		identifier: InherentIdentifier,
+		inherent: &I,
+	) -> Result<(), Error> {
+		match self.data.entry(identifier) {
+			Entry::Vacant(entry) => {
+				entry.insert(inherent.encode());
+				Ok(())
+			},
+			Entry::Occupied(_) => Err(Error::InherentDataExists(identifier)),
+		}
+	}
+
+	/// Replace the data for an inherent.
+	///
+	/// If it does not exist, the data is just inserted.
+	pub fn replace_data<I: codec::Encode>(&mut self, identifier: InherentIdentifier, inherent: &I) {
+		self.data.insert(identifier, inherent.encode());
+	}
+
+	/// Returns the data for the requested inherent.
+	///
+	/// # Return
+	///
+	/// - `Ok(Some(I))` if the data could be found and deserialized.
+	/// - `Ok(None)` if the data could not be found.
+	/// - `Err(_)` if the data could be found, but deserialization did not work.
+	pub fn get_data<I: codec::Decode>(
+		&self,
+		identifier: &InherentIdentifier,
+	) -> Result<Option<I>, Error> {
+		match self.data.get(identifier) {
+			Some(inherent) => I::decode(&mut &inherent[..])
+				.map_err(|e| Error::DecodingFailed(e, *identifier))
+				.map(Some),
+			None => Ok(None),
+		}
+	}
+
+	/// Get the number of inherents in this instance
+	pub fn len(&self) -> usize {
+		self.data.len()
+	}
+}
+
+/// The result of checking inherents.
+///
+/// It either returns okay for all checks, stores all occurred errors or just one fatal error.
+///
+/// When a fatal error occurs, all other errors are removed and the implementation needs to
+/// abort checking inherents.
+#[derive(Encode, Decode, Clone, scale_info::TypeInfo)]
+pub struct CheckInherentsResult {
+	/// Did the check succeed?
+	okay: bool,
+	/// Did we encounter a fatal error?
+	fatal_error: bool,
+	/// We use the `InherentData` to store our errors.
+	errors: InherentData,
+}
+
+impl Default for CheckInherentsResult {
+	fn default() -> Self {
+		Self { okay: true, errors: InherentData::new(), fatal_error: false }
+	}
+}
+
+impl CheckInherentsResult {
+	/// Create a new instance.
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	/// Put an error into the result.
+	///
+	/// This makes this result resolve to `ok() == false`.
+	///
+	/// # Parameters
+	///
+	/// - identifier - The identifier of the inherent that generated the error.
+	/// - error - The error that will be encoded.
+	pub fn put_error<E: codec::Encode + IsFatalError>(
+		&mut self,
+		identifier: InherentIdentifier,
+		error: &E,
+	) -> Result<(), Error> {
+		// Don't accept any other error
+		if self.fatal_error {
+			return Err(Error::FatalErrorReported)
+		}
+
+		if error.is_fatal_error() {
+			// remove the other errors.
+			self.errors.data.clear();
+		}
+
+		self.errors.put_data(identifier, error)?;
+
+		self.okay = false;
+		self.fatal_error = error.is_fatal_error();
+		Ok(())
+	}
+
+	/// Get an error out of the result.
+	///
+	/// # Return
+	///
+	/// - `Ok(Some(I))` if the error could be found and deserialized.
+	/// - `Ok(None)` if the error could not be found.
+	/// - `Err(_)` if the error could be found, but deserialization did not work.
+	pub fn get_error<E: codec::Decode>(
+		&self,
+		identifier: &InherentIdentifier,
+	) -> Result<Option<E>, Error> {
+		self.errors.get_data(identifier)
+	}
+
+	/// Convert into an iterator over all contained errors.
+	pub fn into_errors(self) -> IntoIter<InherentIdentifier, Vec<u8>> {
+		self.errors.data.into_iter()
+	}
+
+	/// Is this result ok?
+	pub fn ok(&self) -> bool {
+		self.okay
+	}
+
+	/// Is this a fatal error?
+	pub fn fatal_error(&self) -> bool {
+		self.fatal_error
+	}
+}
+
+#[cfg(feature = "std")]
+impl PartialEq for CheckInherentsResult {
+	fn eq(&self, other: &Self) -> bool {
+		self.fatal_error == other.fatal_error &&
+			self.okay == other.okay &&
+			self.errors.data == other.errors.data
+	}
+}
+
+/// Did we encounter a fatal error while checking an inherent?
+///
+/// A fatal error is everything that fails while checking an inherent error, e.g. the inherent
+/// was not found, could not be decoded etc.
+/// Then there are cases where you not want the inherent check to fail, but report that there is an
+/// action required. For example a timestamp of a block is in the future, the timestamp is still
+/// correct, but it is required to verify the block at a later time again and then the inherent
+/// check will succeed.
+pub trait IsFatalError {
+	/// Is this a fatal error?
+	fn is_fatal_error(&self) -> bool;
+}
+
+/// Auxiliary to make any given error resolve to `is_fatal_error() == true` for [`IsFatalError`].
+#[derive(codec::Encode)]
+pub struct MakeFatalError<E>(E);
+
+impl<E: codec::Encode> From<E> for MakeFatalError<E> {
+	fn from(err: E) -> Self {
+		MakeFatalError(err)
+	}
+}
+
+impl<E: codec::Encode> IsFatalError for MakeFatalError<E> {
+	fn is_fatal_error(&self) -> bool {
+		true
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::{Decode, Encode};
+
+	const TEST_INHERENT_0: InherentIdentifier = *b"testinh0";
+	const TEST_INHERENT_1: InherentIdentifier = *b"testinh1";
+
+	#[derive(Encode)]
+	struct NoFatalError<E: codec::Encode>(E);
+	impl<E: codec::Encode> IsFatalError for NoFatalError<E> {
+		fn is_fatal_error(&self) -> bool {
+			false
+		}
+	}
+
+	#[test]
+	fn inherent_data_encodes_and_decodes() {
+		let inherent_0 = vec![1, 2, 3];
+		let inherent_1: u32 = 7;
+
+		let mut data = InherentData::new();
+		data.put_data(TEST_INHERENT_0, &inherent_0).unwrap();
+		data.put_data(TEST_INHERENT_1, &inherent_1).unwrap();
+
+		let encoded = data.encode();
+
+		let decoded = InherentData::decode(&mut &encoded[..]).unwrap();
+
+		assert_eq!(decoded.get_data::<Vec<u32>>(&TEST_INHERENT_0).unwrap().unwrap(), inherent_0);
+		assert_eq!(decoded.get_data::<u32>(&TEST_INHERENT_1).unwrap().unwrap(), inherent_1);
+	}
+
+	#[test]
+	fn adding_same_inherent_returns_an_error() {
+		let mut data = InherentData::new();
+		data.put_data(TEST_INHERENT_0, &8).unwrap();
+		assert!(data.put_data(TEST_INHERENT_0, &10).is_err());
+	}
+
+	#[derive(Clone)]
+	struct TestInherentDataProvider;
+
+	const ERROR_TO_STRING: &str = "Found error!";
+
+	#[async_trait::async_trait]
+	impl InherentDataProvider for TestInherentDataProvider {
+		async fn provide_inherent_data(&self, data: &mut InherentData) -> Result<(), Error> {
+			data.put_data(TEST_INHERENT_0, &42)
+		}
+
+		async fn try_handle_error(
+			&self,
+			_: &InherentIdentifier,
+			_: &[u8],
+		) -> Option<Result<(), Error>> {
+			Some(Err(Error::Application(Box::from(ERROR_TO_STRING))))
+		}
+	}
+
+	#[test]
+	fn create_inherent_data() {
+		let provider = TestInherentDataProvider;
+
+		let inherent_data = futures::executor::block_on(provider.create_inherent_data()).unwrap();
+
+		assert_eq!(inherent_data.get_data::<u32>(&TEST_INHERENT_0).unwrap().unwrap(), 42u32);
+	}
+
+	#[test]
+	fn check_inherents_result_encodes_and_decodes() {
+		let mut result = CheckInherentsResult::new();
+		assert!(result.ok());
+
+		result.put_error(TEST_INHERENT_0, &NoFatalError(2u32)).unwrap();
+		assert!(!result.ok());
+		assert!(!result.fatal_error());
+
+		let encoded = result.encode();
+
+		let decoded = CheckInherentsResult::decode(&mut &encoded[..]).unwrap();
+
+		assert_eq!(decoded.get_error::<u32>(&TEST_INHERENT_0).unwrap().unwrap(), 2);
+		assert!(!decoded.ok());
+		assert!(!decoded.fatal_error());
+	}
+
+	#[test]
+	fn check_inherents_result_removes_other_errors_on_fatal_error() {
+		let mut result = CheckInherentsResult::new();
+		assert!(result.ok());
+
+		result.put_error(TEST_INHERENT_0, &NoFatalError(2u32)).unwrap();
+		assert!(!result.ok());
+		assert!(!result.fatal_error());
+
+		result.put_error(TEST_INHERENT_1, &MakeFatalError(4u32)).unwrap();
+		assert!(!result.ok());
+		assert!(result.fatal_error());
+
+		assert!(result.put_error(TEST_INHERENT_0, &NoFatalError(5u32)).is_err());
+
+		result.into_errors().for_each(|(i, e)| match i {
+			TEST_INHERENT_1 => assert_eq!(u32::decode(&mut &e[..]).unwrap(), 4),
+			_ => panic!("There should be no other error!"),
+		});
+	}
+}
diff --git a/substrate/primitives/io/Cargo.toml b/substrate/primitives/io/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8ff06596efba979fa513533bda71b9fbe0009e4d
--- /dev/null
+++ b/substrate/primitives/io/Cargo.toml
@@ -0,0 +1,99 @@
+[package]
+name = "sp-io"
+version = "23.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "I/O for Substrate runtimes"
+documentation = "https://docs.rs/sp-io"
+readme = "README.md"
+build = "build.rs"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+
+[dependencies]
+bytes = { version = "1.1.0", default-features = false }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["bytes"] }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-keystore = { version = "0.27.0", default-features = false, optional = true, path = "../keystore" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+libsecp256k1 = { version = "0.7", optional = true }
+sp-state-machine = { version = "0.28.0", default-features = false, optional = true, path = "../state-machine" }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../runtime-interface" }
+sp-trie = { version = "22.0.0", default-features = false, optional = true, path = "../trie" }
+sp-externalities = { version = "0.19.0", default-features = false, path = "../externalities" }
+sp-tracing = { version = "10.0.0", default-features = false, path = "../tracing" }
+log = { version = "0.4.17", optional = true }
+secp256k1 = { version = "0.24.0", features = ["recovery", "global-context"], optional = true }
+tracing = { version = "0.1.29", default-features = false }
+tracing-core = { version = "0.1.28", default-features = false}
+
+# Required for backwards compatibility reason, but only used for verifying when `UseDalekExt` is set.
+ed25519-dalek = { version = "2.0.0", default-features = false, optional = true }
+
+[build-dependencies]
+rustversion = "1.0.6"
+
+[features]
+default = [ "std" ]
+std = [
+	"bytes/std",
+	"codec/std",
+	"ed25519-dalek",
+	"libsecp256k1",
+	"log",
+	"secp256k1",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-keystore/std",
+	"sp-runtime-interface/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-tracing/std",
+	"sp-trie/std",
+	"tracing-core/std",
+	"tracing/std",
+]
+
+with-tracing = [ "sp-tracing/with-tracing" ]
+
+# These two features are used for `no_std` builds for the environments which already provides
+# `#[panic_handler]`, `#[alloc_error_handler]` and `#[global_allocator]`.
+#
+# For the regular wasm runtime builds those are not used.
+disable_panic_handler = []
+disable_oom = []
+disable_allocator = []
+
+# This feature flag controls the runtime's behavior when encountering
+# a panic or when it runs out of memory, improving the diagnostics.
+#
+# When enabled the runtime will marshal the relevant error message
+# to the host through the `PanicHandler::abort_on_panic` runtime interface.
+# This gives the caller direct programmatic access to the error message.
+#
+# When disabled the error message will only be printed out in the
+# logs, with the caller receving a generic "wasm `unreachable` instruction executed"
+# error message.
+#
+# This has no effect if both `disable_panic_handler` and `disable_oom`
+# are enabled.
+#
+# WARNING: Enabling this feature flag requires the `PanicHandler::abort_on_panic`
+#          host function to be supported by the host. Do *not* enable it for your
+#          runtime without first upgrading your host client!
+improved_panic_error_reporting = []
+
+# This feature adds BLS crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bls-experimental = [ "sp-keystore/bls-experimental" ]
+
+# This feature adds Bandersnatch crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bandersnatch-experimental = [ "sp-keystore/bandersnatch-experimental" ]
diff --git a/substrate/primitives/io/README.md b/substrate/primitives/io/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a24370cc566b359b2b3aeab195d185dec34f7e78
--- /dev/null
+++ b/substrate/primitives/io/README.md
@@ -0,0 +1,3 @@
+I/O host interface for substrate runtime.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/io/build.rs b/substrate/primitives/io/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8a9c0b6420b29833d95f7bcf7dc6d91a65f3b53c
--- /dev/null
+++ b/substrate/primitives/io/build.rs
@@ -0,0 +1,27 @@
+// 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/>.
+
+#[rustversion::before(1.68)]
+fn main() {
+	if !cfg!(feature = "std") {
+		println!("cargo:rustc-cfg=enable_alloc_error_handler");
+	}
+}
+
+#[rustversion::since(1.68)]
+fn main() {}
diff --git a/substrate/primitives/io/src/lib.rs b/substrate/primitives/io/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ec098a155c9c55644693dd6fffb4bcea0b57bb9e
--- /dev/null
+++ b/substrate/primitives/io/src/lib.rs
@@ -0,0 +1,1938 @@
+// 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.
+
+//! # Substrate Primitives: IO
+//!
+//! This crate contains interfaces for the runtime to communicate with the outside world, ergo `io`.
+//! In other context, such interfaces are referred to as "**host functions**".
+//!
+//! Each set of host functions are defined with an instance of the
+//! [`sp_runtime_interface::runtime_interface`] macro.
+//!
+//! Most notably, this crate contains host functions for:
+//!
+//! - [`hashing`]
+//! - [`crypto`]
+//! - [`trie`]
+//! - [`offchain`]
+//! - [`storage`]
+//! - [`allocator`]
+//! - [`logging`]
+//!
+//! All of the default host functions provided by this crate, and by default contained in all
+//! substrate-based clients are amalgamated in [`SubstrateHostFunctions`].
+//!
+//! ## Externalities
+//!
+//! Host functions go hand in hand with the concept of externalities. Externalities are an
+//! environment in which host functions are provided, and thus can be accessed. Some host functions
+//! are only accessible in an externality environment that provides it.
+//!
+//! A typical error for substrate developers is the following:
+//!
+//! ```should_panic
+//! use sp_io::storage::get;
+//! # fn main() {
+//! let data = get(b"hello world");
+//! # }
+//! ```
+//!
+//! This code will panic with the following error:
+//!
+//! ```no_compile
+//! thread 'main' panicked at '`get_version_1` called outside of an Externalities-provided environment.'
+//! ```
+//!
+//! Such error messages should always be interpreted as "code accessing host functions accessed
+//! outside of externalities".
+//!
+//! An externality is any type that implements [`sp_externalities::Externalities`]. A simple example
+//! of which is [`TestExternalities`], which is commonly used in tests and is exported from this
+//! crate.
+//!
+//! ```
+//! use sp_io::{storage::get, TestExternalities};
+//! # fn main() {
+//! TestExternalities::default().execute_with(|| {
+//! 	let data = get(b"hello world");
+//! });
+//! # }
+//! ```
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(enable_alloc_error_handler, feature(alloc_error_handler))]
+
+use sp_std::vec::Vec;
+
+#[cfg(feature = "std")]
+use tracing;
+
+#[cfg(feature = "std")]
+use sp_core::{
+	crypto::Pair,
+	hexdisplay::HexDisplay,
+	offchain::{OffchainDbExt, OffchainWorkerExt, TransactionPoolExt},
+	storage::ChildInfo,
+};
+#[cfg(feature = "std")]
+use sp_keystore::KeystoreExt;
+
+#[cfg(feature = "bandersnatch-experimental")]
+use sp_core::bandersnatch;
+use sp_core::{
+	crypto::KeyTypeId,
+	ecdsa, ed25519,
+	offchain::{
+		HttpError, HttpRequestId, HttpRequestStatus, OpaqueNetworkState, StorageKind, Timestamp,
+	},
+	sr25519,
+	storage::StateVersion,
+	LogLevel, LogLevelFilter, OpaquePeerId, H256,
+};
+
+#[cfg(feature = "bls-experimental")]
+use sp_core::bls377;
+
+#[cfg(feature = "std")]
+use sp_trie::{LayoutV0, LayoutV1, TrieConfiguration};
+
+use sp_runtime_interface::{
+	pass_by::{PassBy, PassByCodec},
+	runtime_interface, Pointer,
+};
+
+use codec::{Decode, Encode};
+
+#[cfg(feature = "std")]
+use secp256k1::{
+	ecdsa::{RecoverableSignature, RecoveryId},
+	Message, SECP256K1,
+};
+
+#[cfg(feature = "std")]
+use sp_externalities::{Externalities, ExternalitiesExt};
+
+pub use sp_externalities::MultiRemovalResults;
+
+#[cfg(feature = "std")]
+const LOG_TARGET: &str = "runtime::io";
+
+/// Error verifying ECDSA signature
+#[derive(Encode, Decode)]
+pub enum EcdsaVerifyError {
+	/// Incorrect value of R or S
+	BadRS,
+	/// Incorrect value of V
+	BadV,
+	/// Invalid signature
+	BadSignature,
+}
+
+/// The outcome of calling `storage_kill`. Returned value is the number of storage items
+/// removed from the backend from making the `storage_kill` call.
+#[derive(PassByCodec, Encode, Decode)]
+pub enum KillStorageResult {
+	/// All keys to remove were removed, return number of iterations performed during the
+	/// operation.
+	AllRemoved(u32),
+	/// Not all key to remove were removed, return number of iterations performed during the
+	/// operation.
+	SomeRemaining(u32),
+}
+
+impl From<MultiRemovalResults> for KillStorageResult {
+	fn from(r: MultiRemovalResults) -> Self {
+		// We use `loops` here rather than `backend` because that's the same as the original
+		// functionality pre-#11490. This won't matter once we switch to the new host function
+		// since we won't be using the `KillStorageResult` type in the runtime any more.
+		match r.maybe_cursor {
+			None => Self::AllRemoved(r.loops),
+			Some(..) => Self::SomeRemaining(r.loops),
+		}
+	}
+}
+
+/// Interface for accessing the storage from within the runtime.
+#[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> {
+		self.storage(key).map(|s| bytes::Bytes::from(s.to_vec()))
+	}
+
+	/// Get `key` from storage, placing the value into `value_out` and return the number of
+	/// bytes that the entry in storage has beyond the offset or `None` if the storage entry
+	/// 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> {
+		self.storage(key).map(|value| {
+			let value_offset = value_offset as usize;
+			let data = &value[value_offset.min(value.len())..];
+			let written = std::cmp::min(data.len(), value_out.len());
+			value_out[..written].copy_from_slice(&data[..written]);
+			data.len() as u32
+		})
+	}
+
+	/// Set `key` to `value` in the storage.
+	fn set(&mut self, key: &[u8], value: &[u8]) {
+		self.set_storage(key.to_vec(), value.to_vec());
+	}
+
+	/// Clear the storage of the given `key` and its value.
+	fn clear(&mut self, key: &[u8]) {
+		self.clear_storage(key)
+	}
+
+	/// Check whether the given `key` exists in storage.
+	fn exists(&self, key: &[u8]) -> bool {
+		self.exists_storage(key)
+	}
+
+	/// Clear the storage of each key-value pair where the key starts with the given `prefix`.
+	fn clear_prefix(&mut self, prefix: &[u8]) {
+		let _ = Externalities::clear_prefix(*self, prefix, None, None);
+	}
+
+	/// Clear the storage of each key-value pair where the key starts with the given `prefix`.
+	///
+	/// # Limit
+	///
+	/// Deletes all keys from the overlay and up to `limit` keys from the backend if
+	/// it is set to `Some`. No limit is applied when `limit` is set to `None`.
+	///
+	/// The limit can be used to partially delete a prefix storage in case it is too large
+	/// to delete in one go (block).
+	///
+	/// Returns [`KillStorageResult`] to inform about the result.
+	///
+	/// # Note
+	///
+	/// Please note that keys that are residing in the overlay for that prefix when
+	/// issuing this call are all deleted without counting towards the `limit`. Only keys
+	/// written during the current block are part of the overlay. Deleting with a `limit`
+	/// mostly makes sense with an empty overlay for that prefix.
+	///
+	/// Calling this function multiple times per block for the same `prefix` does
+	/// not make much sense because it is not cumulative when called inside the same block.
+	/// The deletion would always start from `prefix` resulting in the same keys being deleted
+	/// every time this function is called with the exact same arguments per block. This happens
+	/// because the keys in the overlay are not taken into account when deleting keys in the
+	/// backend.
+	#[version(2)]
+	fn clear_prefix(&mut self, prefix: &[u8], limit: Option<u32>) -> KillStorageResult {
+		Externalities::clear_prefix(*self, prefix, limit, None).into()
+	}
+
+	/// Partially clear the storage of each key-value pair where the key starts with the given
+	/// prefix.
+	///
+	/// # Limit
+	///
+	/// A *limit* should always be provided through `maybe_limit`. This is one fewer than the
+	/// maximum number of backend iterations which may be done by this operation and as such
+	/// represents the maximum number of backend deletions which may happen. A *limit* of zero
+	/// implies that no keys will be deleted, though there may be a single iteration done.
+	///
+	/// The limit can be used to partially delete a prefix storage in case it is too large or costly
+	/// to delete in a single operation.
+	///
+	/// # Cursor
+	///
+	/// A *cursor* may be passed in to this operation with `maybe_cursor`. `None` should only be
+	/// passed once (in the initial call) for any given `maybe_prefix` value. Subsequent calls
+	/// operating on the same prefix should always pass `Some`, and this should be equal to the
+	/// previous call result's `maybe_cursor` field.
+	///
+	/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once
+	/// the resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+	///
+	/// NOTE: After the initial call for any given prefix, it is important that no keys further
+	/// keys under the same prefix are inserted. If so, then they may or may not be deleted by
+	/// subsequent calls.
+	///
+	/// # Note
+	///
+	/// Please note that keys which are residing in the overlay for that prefix when
+	/// issuing this call are deleted without counting towards the `limit`.
+	#[version(3, register_only)]
+	fn clear_prefix(
+		&mut self,
+		maybe_prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<Vec<u8>>, //< TODO Make work or just Option<Vec<u8>>?
+	) -> MultiRemovalResults {
+		Externalities::clear_prefix(
+			*self,
+			maybe_prefix,
+			maybe_limit,
+			maybe_cursor.as_ref().map(|x| &x[..]),
+		)
+		.into()
+	}
+
+	/// Append the encoded `value` to the storage item at `key`.
+	///
+	/// The storage item needs to implement [`EncodeAppend`](codec::EncodeAppend).
+	///
+	/// # Warning
+	///
+	/// If the storage item does not support [`EncodeAppend`](codec::EncodeAppend) or
+	/// something else fails at appending, the storage item will be set to `[value]`.
+	fn append(&mut self, key: &[u8], value: Vec<u8>) {
+		self.storage_append(key.to_vec(), value);
+	}
+
+	/// "Commit" all existing operations and compute the resulting storage root.
+	///
+	/// The hashing algorithm is defined by the `Block`.
+	///
+	/// Returns a `Vec<u8>` that holds the SCALE encoded hash.
+	fn root(&mut self) -> Vec<u8> {
+		self.storage_root(StateVersion::V0)
+	}
+
+	/// "Commit" all existing operations and compute the resulting storage root.
+	///
+	/// The hashing algorithm is defined by the `Block`.
+	///
+	/// Returns a `Vec<u8>` that holds the SCALE encoded hash.
+	#[version(2)]
+	fn root(&mut self, version: StateVersion) -> Vec<u8> {
+		self.storage_root(version)
+	}
+
+	/// Always returns `None`. This function exists for compatibility reasons.
+	fn changes_root(&mut self, _parent_hash: &[u8]) -> Option<Vec<u8>> {
+		None
+	}
+
+	/// Get the next key in storage after the given one in lexicographic order.
+	fn next_key(&mut self, key: &[u8]) -> Option<Vec<u8>> {
+		self.next_storage_key(key)
+	}
+
+	/// Start a new nested transaction.
+	///
+	/// This allows to either commit or roll back all changes that are made after this call.
+	/// For every transaction there must be a matching call to either `rollback_transaction`
+	/// or `commit_transaction`. This is also effective for all values manipulated using the
+	/// `DefaultChildStorage` API.
+	///
+	/// # Warning
+	///
+	/// This is a low level API that is potentially dangerous as it can easily result
+	/// in unbalanced transactions. For example, FRAME users should use high level storage
+	/// abstractions.
+	fn start_transaction(&mut self) {
+		self.storage_start_transaction();
+	}
+
+	/// Rollback the last transaction started by `start_transaction`.
+	///
+	/// Any changes made during that transaction are discarded.
+	///
+	/// # Panics
+	///
+	/// Will panic if there is no open transaction.
+	fn rollback_transaction(&mut self) {
+		self.storage_rollback_transaction()
+			.expect("No open transaction that can be rolled back.");
+	}
+
+	/// Commit the last transaction started by `start_transaction`.
+	///
+	/// Any changes made during that transaction are committed.
+	///
+	/// # Panics
+	///
+	/// Will panic if there is no open transaction.
+	fn commit_transaction(&mut self) {
+		self.storage_commit_transaction()
+			.expect("No open transaction that can be committed.");
+	}
+}
+
+/// Interface for accessing the child storage for default child trie,
+/// from within the runtime.
+#[runtime_interface]
+pub trait DefaultChildStorage {
+	/// Get a default child storage value for a given key.
+	///
+	/// 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>> {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.child_storage(&child_info, key).map(|s| s.to_vec())
+	}
+
+	/// Allocation efficient variant of `get`.
+	///
+	/// Get `key` from child storage, placing the value into `value_out` and return the number
+	/// of bytes that the entry in storage has beyond the offset or `None` if the storage entry
+	/// 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,
+		storage_key: &[u8],
+		key: &[u8],
+		value_out: &mut [u8],
+		value_offset: u32,
+	) -> Option<u32> {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.child_storage(&child_info, key).map(|value| {
+			let value_offset = value_offset as usize;
+			let data = &value[value_offset.min(value.len())..];
+			let written = std::cmp::min(data.len(), value_out.len());
+			value_out[..written].copy_from_slice(&data[..written]);
+			data.len() as u32
+		})
+	}
+
+	/// Set a child storage value.
+	///
+	/// Set `key` to `value` in the child storage denoted by `storage_key`.
+	fn set(&mut self, storage_key: &[u8], key: &[u8], value: &[u8]) {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.set_child_storage(&child_info, key.to_vec(), value.to_vec());
+	}
+
+	/// Clear a child storage key.
+	///
+	/// For the default child storage at `storage_key`, clear value at `key`.
+	fn clear(&mut self, storage_key: &[u8], key: &[u8]) {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.clear_child_storage(&child_info, key);
+	}
+
+	/// Clear an entire child storage.
+	///
+	/// If it exists, the child storage for `storage_key`
+	/// is removed.
+	fn storage_kill(&mut self, storage_key: &[u8]) {
+		let child_info = ChildInfo::new_default(storage_key);
+		let _ = self.kill_child_storage(&child_info, None, None);
+	}
+
+	/// Clear a child storage key.
+	///
+	/// See `Storage` module `clear_prefix` documentation for `limit` usage.
+	#[version(2)]
+	fn storage_kill(&mut self, storage_key: &[u8], limit: Option<u32>) -> bool {
+		let child_info = ChildInfo::new_default(storage_key);
+		let r = self.kill_child_storage(&child_info, limit, None);
+		r.maybe_cursor.is_none()
+	}
+
+	/// Clear a child storage key.
+	///
+	/// See `Storage` module `clear_prefix` documentation for `limit` usage.
+	#[version(3)]
+	fn storage_kill(&mut self, storage_key: &[u8], limit: Option<u32>) -> KillStorageResult {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.kill_child_storage(&child_info, limit, None).into()
+	}
+
+	/// Clear a child storage key.
+	///
+	/// See `Storage` module `clear_prefix` documentation for `limit` usage.
+	#[version(4, register_only)]
+	fn storage_kill(
+		&mut self,
+		storage_key: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<Vec<u8>>,
+	) -> MultiRemovalResults {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.kill_child_storage(&child_info, maybe_limit, maybe_cursor.as_ref().map(|x| &x[..]))
+			.into()
+	}
+
+	/// 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 {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.exists_child_storage(&child_info, key)
+	}
+
+	/// Clear child default key by prefix.
+	///
+	/// Clear the child storage of each key-value pair where the key starts with the given `prefix`.
+	fn clear_prefix(&mut self, storage_key: &[u8], prefix: &[u8]) {
+		let child_info = ChildInfo::new_default(storage_key);
+		let _ = self.clear_child_prefix(&child_info, prefix, None, None);
+	}
+
+	/// Clear the child storage of each key-value pair where the key starts with the given `prefix`.
+	///
+	/// See `Storage` module `clear_prefix` documentation for `limit` usage.
+	#[version(2)]
+	fn clear_prefix(
+		&mut self,
+		storage_key: &[u8],
+		prefix: &[u8],
+		limit: Option<u32>,
+	) -> KillStorageResult {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.clear_child_prefix(&child_info, prefix, limit, None).into()
+	}
+
+	/// Clear the child storage of each key-value pair where the key starts with the given `prefix`.
+	///
+	/// See `Storage` module `clear_prefix` documentation for `limit` usage.
+	#[version(3, register_only)]
+	fn clear_prefix(
+		&mut self,
+		storage_key: &[u8],
+		prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<Vec<u8>>,
+	) -> MultiRemovalResults {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.clear_child_prefix(
+			&child_info,
+			prefix,
+			maybe_limit,
+			maybe_cursor.as_ref().map(|x| &x[..]),
+		)
+		.into()
+	}
+
+	/// Default child root calculation.
+	///
+	/// "Commit" all existing operations and compute the resulting child storage root.
+	/// The hashing algorithm is defined by the `Block`.
+	///
+	/// Returns a `Vec<u8>` that holds the SCALE encoded hash.
+	fn root(&mut self, storage_key: &[u8]) -> Vec<u8> {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.child_storage_root(&child_info, StateVersion::V0)
+	}
+
+	/// Default child root calculation.
+	///
+	/// "Commit" all existing operations and compute the resulting child storage root.
+	/// The hashing algorithm is defined by the `Block`.
+	///
+	/// Returns a `Vec<u8>` that holds the SCALE encoded hash.
+	#[version(2)]
+	fn root(&mut self, storage_key: &[u8], version: StateVersion) -> Vec<u8> {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.child_storage_root(&child_info, version)
+	}
+
+	/// Child storage key iteration.
+	///
+	/// Get the next key in storage after the given one in lexicographic order in child storage.
+	fn next_key(&mut self, storage_key: &[u8], key: &[u8]) -> Option<Vec<u8>> {
+		let child_info = ChildInfo::new_default(storage_key);
+		self.next_child_storage_key(&child_info, key)
+	}
+}
+
+/// Interface that provides trie related functionality.
+#[runtime_interface]
+pub trait Trie {
+	/// A trie root formed from the iterated items.
+	fn blake2_256_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
+		LayoutV0::<sp_core::Blake2Hasher>::trie_root(input)
+	}
+
+	/// A trie root formed from the iterated items.
+	#[version(2)]
+	fn blake2_256_root(input: Vec<(Vec<u8>, Vec<u8>)>, version: StateVersion) -> H256 {
+		match version {
+			StateVersion::V0 => LayoutV0::<sp_core::Blake2Hasher>::trie_root(input),
+			StateVersion::V1 => LayoutV1::<sp_core::Blake2Hasher>::trie_root(input),
+		}
+	}
+
+	/// A trie root formed from the enumerated items.
+	fn blake2_256_ordered_root(input: Vec<Vec<u8>>) -> H256 {
+		LayoutV0::<sp_core::Blake2Hasher>::ordered_trie_root(input)
+	}
+
+	/// A trie root formed from the enumerated items.
+	#[version(2)]
+	fn blake2_256_ordered_root(input: Vec<Vec<u8>>, version: StateVersion) -> H256 {
+		match version {
+			StateVersion::V0 => LayoutV0::<sp_core::Blake2Hasher>::ordered_trie_root(input),
+			StateVersion::V1 => LayoutV1::<sp_core::Blake2Hasher>::ordered_trie_root(input),
+		}
+	}
+
+	/// A trie root formed from the iterated items.
+	fn keccak_256_root(input: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
+		LayoutV0::<sp_core::KeccakHasher>::trie_root(input)
+	}
+
+	/// A trie root formed from the iterated items.
+	#[version(2)]
+	fn keccak_256_root(input: Vec<(Vec<u8>, Vec<u8>)>, version: StateVersion) -> H256 {
+		match version {
+			StateVersion::V0 => LayoutV0::<sp_core::KeccakHasher>::trie_root(input),
+			StateVersion::V1 => LayoutV1::<sp_core::KeccakHasher>::trie_root(input),
+		}
+	}
+
+	/// A trie root formed from the enumerated items.
+	fn keccak_256_ordered_root(input: Vec<Vec<u8>>) -> H256 {
+		LayoutV0::<sp_core::KeccakHasher>::ordered_trie_root(input)
+	}
+
+	/// A trie root formed from the enumerated items.
+	#[version(2)]
+	fn keccak_256_ordered_root(input: Vec<Vec<u8>>, version: StateVersion) -> H256 {
+		match version {
+			StateVersion::V0 => LayoutV0::<sp_core::KeccakHasher>::ordered_trie_root(input),
+			StateVersion::V1 => LayoutV1::<sp_core::KeccakHasher>::ordered_trie_root(input),
+		}
+	}
+
+	/// Verify trie proof
+	fn blake2_256_verify_proof(root: H256, proof: &[Vec<u8>], key: &[u8], value: &[u8]) -> bool {
+		sp_trie::verify_trie_proof::<LayoutV0<sp_core::Blake2Hasher>, _, _, _>(
+			&root,
+			proof,
+			&[(key, Some(value))],
+		)
+		.is_ok()
+	}
+
+	/// Verify trie proof
+	#[version(2)]
+	fn blake2_256_verify_proof(
+		root: H256,
+		proof: &[Vec<u8>],
+		key: &[u8],
+		value: &[u8],
+		version: StateVersion,
+	) -> bool {
+		match version {
+			StateVersion::V0 => sp_trie::verify_trie_proof::<
+				LayoutV0<sp_core::Blake2Hasher>,
+				_,
+				_,
+				_,
+			>(&root, proof, &[(key, Some(value))])
+			.is_ok(),
+			StateVersion::V1 => sp_trie::verify_trie_proof::<
+				LayoutV1<sp_core::Blake2Hasher>,
+				_,
+				_,
+				_,
+			>(&root, proof, &[(key, Some(value))])
+			.is_ok(),
+		}
+	}
+
+	/// Verify trie proof
+	fn keccak_256_verify_proof(root: H256, proof: &[Vec<u8>], key: &[u8], value: &[u8]) -> bool {
+		sp_trie::verify_trie_proof::<LayoutV0<sp_core::KeccakHasher>, _, _, _>(
+			&root,
+			proof,
+			&[(key, Some(value))],
+		)
+		.is_ok()
+	}
+
+	/// Verify trie proof
+	#[version(2)]
+	fn keccak_256_verify_proof(
+		root: H256,
+		proof: &[Vec<u8>],
+		key: &[u8],
+		value: &[u8],
+		version: StateVersion,
+	) -> bool {
+		match version {
+			StateVersion::V0 => sp_trie::verify_trie_proof::<
+				LayoutV0<sp_core::KeccakHasher>,
+				_,
+				_,
+				_,
+			>(&root, proof, &[(key, Some(value))])
+			.is_ok(),
+			StateVersion::V1 => sp_trie::verify_trie_proof::<
+				LayoutV1<sp_core::KeccakHasher>,
+				_,
+				_,
+				_,
+			>(&root, proof, &[(key, Some(value))])
+			.is_ok(),
+		}
+	}
+}
+
+/// Interface that provides miscellaneous functions for communicating between the runtime and the
+/// node.
+#[runtime_interface]
+pub trait Misc {
+	// NOTE: We use the target 'runtime' for messages produced by general printing functions,
+	// instead of LOG_TARGET.
+
+	/// Print a number.
+	fn print_num(val: u64) {
+		log::debug!(target: "runtime", "{}", val);
+	}
+
+	/// Print any valid `utf8` buffer.
+	fn print_utf8(utf8: &[u8]) {
+		if let Ok(data) = std::str::from_utf8(utf8) {
+			log::debug!(target: "runtime", "{}", data)
+		}
+	}
+
+	/// Print any `u8` slice as hex.
+	fn print_hex(data: &[u8]) {
+		log::debug!(target: "runtime", "{}", HexDisplay::from(&data));
+	}
+
+	/// Extract the runtime version of the given wasm blob by calling `Core_version`.
+	///
+	/// Returns `None` if calling the function failed for any reason or `Some(Vec<u8>)` where
+	/// the `Vec<u8>` holds the SCALE encoded runtime version.
+	///
+	/// # Performance
+	///
+	/// This function may be very expensive to call depending on the wasm binary. It may be
+	/// relatively cheap if the wasm binary contains version information. In that case,
+	/// uncompression of the wasm blob is the dominating factor.
+	///
+	/// If the wasm binary does not have the version information attached, then a legacy mechanism
+	/// may be involved. This means that a runtime call will be performed to query the version.
+	///
+	/// Calling into the runtime may be incredible expensive and should be approached with care.
+	fn runtime_version(&mut self, wasm: &[u8]) -> Option<Vec<u8>> {
+		use sp_core::traits::ReadRuntimeVersionExt;
+
+		let mut ext = sp_state_machine::BasicExternalities::default();
+
+		match self
+			.extension::<ReadRuntimeVersionExt>()
+			.expect("No `ReadRuntimeVersionExt` associated for the current context!")
+			.read_runtime_version(wasm, &mut ext)
+		{
+			Ok(v) => Some(v),
+			Err(err) => {
+				log::debug!(
+					target: LOG_TARGET,
+					"cannot read version from the given runtime: {}",
+					err,
+				);
+				None
+			},
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+sp_externalities::decl_extension! {
+	/// Extension to signal to [`crypt::ed25519_verify`] to use the dalek crate.
+	///
+	/// The switch from `ed25519-dalek` to `ed25519-zebra` was a breaking change.
+	/// `ed25519-zebra` is more permissive when it comes to the verification of signatures.
+	/// This means that some chains may fail to sync from genesis when using `ed25519-zebra`.
+	/// So, this extension can be registered to the runtime execution environment to signal
+	/// that `ed25519-dalek` should be used for verification. The extension can be registered
+	/// in the following way:
+	///
+	/// ```nocompile
+	/// client.execution_extensions().set_extensions_factory(
+	/// 	// Let the `UseDalekExt` extension being registered for each runtime invocation
+	/// 	// until the execution happens in the context of block `1000`.
+	/// 	sc_client_api::execution_extensions::ExtensionBeforeBlock::<Block, UseDalekExt>::new(1000)
+	/// );
+	/// ```
+	pub struct UseDalekExt;
+}
+
+#[cfg(feature = "std")]
+impl Default for UseDalekExt {
+	fn default() -> Self {
+		Self
+	}
+}
+
+/// Interfaces for working with crypto related types from within the runtime.
+#[runtime_interface]
+pub trait Crypto {
+	/// Returns all `ed25519` public keys for the given key id from the keystore.
+	fn ed25519_public_keys(&mut self, id: KeyTypeId) -> Vec<ed25519::Public> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.ed25519_public_keys(id)
+	}
+
+	/// Generate an `ed22519` key for the given key type using an optional `seed` and
+	/// store it in the keystore.
+	///
+	/// The `seed` needs to be a valid utf8.
+	///
+	/// Returns the public key.
+	fn ed25519_generate(&mut self, id: KeyTypeId, seed: Option<Vec<u8>>) -> ed25519::Public {
+		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.ed25519_generate_new(id, seed)
+			.expect("`ed25519_generate` failed")
+	}
+
+	/// Sign the given `msg` with the `ed25519` key that corresponds to the given public key and
+	/// key type in the keystore.
+	///
+	/// Returns the signature.
+	fn ed25519_sign(
+		&mut self,
+		id: KeyTypeId,
+		pub_key: &ed25519::Public,
+		msg: &[u8],
+	) -> Option<ed25519::Signature> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.ed25519_sign(id, pub_key, msg)
+			.ok()
+			.flatten()
+	}
+
+	/// Verify `ed25519` signature.
+	///
+	/// Returns `true` when the verification was successful.
+	fn ed25519_verify(sig: &ed25519::Signature, msg: &[u8], pub_key: &ed25519::Public) -> bool {
+		// We don't want to force everyone needing to call the function in an externalities context.
+		// So, we assume that we should not use dalek when we are not in externalities context.
+		// Otherwise, we check if the extension is present.
+		if sp_externalities::with_externalities(|mut e| e.extension::<UseDalekExt>().is_some())
+			.unwrap_or_default()
+		{
+			use ed25519_dalek::Verifier;
+
+			let Ok(public_key) = ed25519_dalek::VerifyingKey::from_bytes(&pub_key.0) else {
+				return false
+			};
+
+			let sig = ed25519_dalek::Signature::from_bytes(&sig.0);
+
+			public_key.verify(msg, &sig).is_ok()
+		} else {
+			ed25519::Pair::verify(sig, msg, pub_key)
+		}
+	}
+
+	/// Register a `ed25519` signature for batch verification.
+	///
+	/// Batch verification must be enabled by calling [`start_batch_verify`].
+	/// If batch verification is not enabled, the signature will be verified immediately.
+	/// To get the result of the batch verification, [`finish_batch_verify`]
+	/// needs to be called.
+	///
+	/// Returns `true` when the verification is either successful or batched.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
+	fn ed25519_batch_verify(
+		&mut self,
+		sig: &ed25519::Signature,
+		msg: &[u8],
+		pub_key: &ed25519::Public,
+	) -> bool {
+		let res = ed25519_verify(sig, msg, pub_key);
+
+		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {
+			ext.0 &= res;
+		}
+
+		res
+	}
+
+	/// Verify `sr25519` signature.
+	///
+	/// Returns `true` when the verification was successful.
+	#[version(2)]
+	fn sr25519_verify(sig: &sr25519::Signature, msg: &[u8], pub_key: &sr25519::Public) -> bool {
+		sr25519::Pair::verify(sig, msg, pub_key)
+	}
+
+	/// Register a `sr25519` signature for batch verification.
+	///
+	/// Batch verification must be enabled by calling [`start_batch_verify`].
+	/// If batch verification is not enabled, the signature will be verified immediately.
+	/// To get the result of the batch verification, [`finish_batch_verify`]
+	/// needs to be called.
+	///
+	/// Returns `true` when the verification is either successful or batched.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
+	fn sr25519_batch_verify(
+		&mut self,
+		sig: &sr25519::Signature,
+		msg: &[u8],
+		pub_key: &sr25519::Public,
+	) -> bool {
+		let res = sr25519_verify(sig, msg, pub_key);
+
+		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {
+			ext.0 &= res;
+		}
+
+		res
+	}
+
+	/// Start verification extension.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
+	fn start_batch_verify(&mut self) {
+		self.register_extension(VerificationExtDeprecated(true))
+			.expect("Failed to register required extension: `VerificationExt`");
+	}
+
+	/// Finish batch-verification of signatures.
+	///
+	/// Verify or wait for verification to finish for all signatures which were previously
+	/// deferred by `sr25519_verify`/`ed25519_verify`.
+	///
+	/// Will panic if no `VerificationExt` is registered (`start_batch_verify` was not called).
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
+	fn finish_batch_verify(&mut self) -> bool {
+		let result = self
+			.extension::<VerificationExtDeprecated>()
+			.expect("`finish_batch_verify` should only be called after `start_batch_verify`")
+			.0;
+
+		self.deregister_extension::<VerificationExtDeprecated>()
+			.expect("No verification extension in current context!");
+
+		result
+	}
+
+	/// Returns all `sr25519` public keys for the given key id from the keystore.
+	fn sr25519_public_keys(&mut self, id: KeyTypeId) -> Vec<sr25519::Public> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.sr25519_public_keys(id)
+	}
+
+	/// Generate an `sr22519` key for the given key type using an optional seed and
+	/// store it in the keystore.
+	///
+	/// The `seed` needs to be a valid utf8.
+	///
+	/// Returns the public key.
+	fn sr25519_generate(&mut self, id: KeyTypeId, seed: Option<Vec<u8>>) -> sr25519::Public {
+		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.sr25519_generate_new(id, seed)
+			.expect("`sr25519_generate` failed")
+	}
+
+	/// Sign the given `msg` with the `sr25519` key that corresponds to the given public key and
+	/// key type in the keystore.
+	///
+	/// Returns the signature.
+	fn sr25519_sign(
+		&mut self,
+		id: KeyTypeId,
+		pub_key: &sr25519::Public,
+		msg: &[u8],
+	) -> Option<sr25519::Signature> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.sr25519_sign(id, pub_key, msg)
+			.ok()
+			.flatten()
+	}
+
+	/// Verify an `sr25519` signature.
+	///
+	/// Returns `true` when the verification in successful regardless of
+	/// signature version.
+	fn sr25519_verify(sig: &sr25519::Signature, msg: &[u8], pubkey: &sr25519::Public) -> bool {
+		sr25519::Pair::verify_deprecated(sig, msg, pubkey)
+	}
+
+	/// Returns all `ecdsa` public keys for the given key id from the keystore.
+	fn ecdsa_public_keys(&mut self, id: KeyTypeId) -> Vec<ecdsa::Public> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.ecdsa_public_keys(id)
+	}
+
+	/// Generate an `ecdsa` key for the given key type using an optional `seed` and
+	/// store it in the keystore.
+	///
+	/// The `seed` needs to be a valid utf8.
+	///
+	/// Returns the public key.
+	fn ecdsa_generate(&mut self, id: KeyTypeId, seed: Option<Vec<u8>>) -> ecdsa::Public {
+		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.ecdsa_generate_new(id, seed)
+			.expect("`ecdsa_generate` failed")
+	}
+
+	/// Sign the given `msg` with the `ecdsa` key that corresponds to the given public key and
+	/// key type in the keystore.
+	///
+	/// Returns the signature.
+	fn ecdsa_sign(
+		&mut self,
+		id: KeyTypeId,
+		pub_key: &ecdsa::Public,
+		msg: &[u8],
+	) -> Option<ecdsa::Signature> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.ecdsa_sign(id, pub_key, msg)
+			.ok()
+			.flatten()
+	}
+
+	/// Sign the given a pre-hashed `msg` with the `ecdsa` key that corresponds to the given public
+	/// key and key type in the keystore.
+	///
+	/// Returns the signature.
+	fn ecdsa_sign_prehashed(
+		&mut self,
+		id: KeyTypeId,
+		pub_key: &ecdsa::Public,
+		msg: &[u8; 32],
+	) -> Option<ecdsa::Signature> {
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.ecdsa_sign_prehashed(id, pub_key, msg)
+			.ok()
+			.flatten()
+	}
+
+	/// Verify `ecdsa` signature.
+	///
+	/// Returns `true` when the verification was successful.
+	/// This version is able to handle, non-standard, overflowing signatures.
+	fn ecdsa_verify(sig: &ecdsa::Signature, msg: &[u8], pub_key: &ecdsa::Public) -> bool {
+		#[allow(deprecated)]
+		ecdsa::Pair::verify_deprecated(sig, msg, pub_key)
+	}
+
+	/// Verify `ecdsa` signature.
+	///
+	/// Returns `true` when the verification was successful.
+	#[version(2)]
+	fn ecdsa_verify(sig: &ecdsa::Signature, msg: &[u8], pub_key: &ecdsa::Public) -> bool {
+		ecdsa::Pair::verify(sig, msg, pub_key)
+	}
+
+	/// Verify `ecdsa` signature with pre-hashed `msg`.
+	///
+	/// Returns `true` when the verification was successful.
+	fn ecdsa_verify_prehashed(
+		sig: &ecdsa::Signature,
+		msg: &[u8; 32],
+		pub_key: &ecdsa::Public,
+	) -> bool {
+		ecdsa::Pair::verify_prehashed(sig, msg, pub_key)
+	}
+
+	/// Register a `ecdsa` signature for batch verification.
+	///
+	/// Batch verification must be enabled by calling [`start_batch_verify`].
+	/// If batch verification is not enabled, the signature will be verified immediatley.
+	/// To get the result of the batch verification, [`finish_batch_verify`]
+	/// needs to be called.
+	///
+	/// Returns `true` when the verification is either successful or batched.
+	///
+	/// NOTE: Is tagged with `register_only` to keep the functions around for backwards
+	/// compatibility with old runtimes, but it should not be used anymore by new runtimes.
+	/// The implementation emulates the old behavior, but isn't doing any batch verification
+	/// anymore.
+	#[version(1, register_only)]
+	fn ecdsa_batch_verify(
+		&mut self,
+		sig: &ecdsa::Signature,
+		msg: &[u8],
+		pub_key: &ecdsa::Public,
+	) -> bool {
+		let res = ecdsa_verify(sig, msg, pub_key);
+
+		if let Some(ext) = self.extension::<VerificationExtDeprecated>() {
+			ext.0 &= res;
+		}
+
+		res
+	}
+
+	/// Verify and recover a SECP256k1 ECDSA signature.
+	///
+	/// - `sig` is passed in RSV format. V should be either `0/1` or `27/28`.
+	/// - `msg` is the blake2-256 hash of the message.
+	///
+	/// Returns `Err` if the signature is bad, otherwise the 64-byte pubkey
+	/// (doesn't include the 0x04 prefix).
+	/// This version is able to handle, non-standard, overflowing signatures.
+	fn secp256k1_ecdsa_recover(
+		sig: &[u8; 65],
+		msg: &[u8; 32],
+	) -> Result<[u8; 64], EcdsaVerifyError> {
+		let rid = libsecp256k1::RecoveryId::parse(
+			if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as u8,
+		)
+		.map_err(|_| EcdsaVerifyError::BadV)?;
+		let sig = libsecp256k1::Signature::parse_overflowing_slice(&sig[..64])
+			.map_err(|_| EcdsaVerifyError::BadRS)?;
+		let msg = libsecp256k1::Message::parse(msg);
+		let pubkey =
+			libsecp256k1::recover(&msg, &sig, &rid).map_err(|_| EcdsaVerifyError::BadSignature)?;
+		let mut res = [0u8; 64];
+		res.copy_from_slice(&pubkey.serialize()[1..65]);
+		Ok(res)
+	}
+
+	/// Verify and recover a SECP256k1 ECDSA signature.
+	///
+	/// - `sig` is passed in RSV format. V should be either `0/1` or `27/28`.
+	/// - `msg` is the blake2-256 hash of the message.
+	///
+	/// Returns `Err` if the signature is bad, otherwise the 64-byte pubkey
+	/// (doesn't include the 0x04 prefix).
+	#[version(2)]
+	fn secp256k1_ecdsa_recover(
+		sig: &[u8; 65],
+		msg: &[u8; 32],
+	) -> Result<[u8; 64], EcdsaVerifyError> {
+		let rid = RecoveryId::from_i32(if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as i32)
+			.map_err(|_| EcdsaVerifyError::BadV)?;
+		let sig = RecoverableSignature::from_compact(&sig[..64], rid)
+			.map_err(|_| EcdsaVerifyError::BadRS)?;
+		let msg = Message::from_slice(msg).expect("Message is 32 bytes; qed");
+		let pubkey = SECP256K1
+			.recover_ecdsa(&msg, &sig)
+			.map_err(|_| EcdsaVerifyError::BadSignature)?;
+		let mut res = [0u8; 64];
+		res.copy_from_slice(&pubkey.serialize_uncompressed()[1..]);
+		Ok(res)
+	}
+
+	/// Verify and recover a SECP256k1 ECDSA signature.
+	///
+	/// - `sig` is passed in RSV format. V should be either `0/1` or `27/28`.
+	/// - `msg` is the blake2-256 hash of the message.
+	///
+	/// Returns `Err` if the signature is bad, otherwise the 33-byte compressed pubkey.
+	fn secp256k1_ecdsa_recover_compressed(
+		sig: &[u8; 65],
+		msg: &[u8; 32],
+	) -> Result<[u8; 33], EcdsaVerifyError> {
+		let rid = libsecp256k1::RecoveryId::parse(
+			if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as u8,
+		)
+		.map_err(|_| EcdsaVerifyError::BadV)?;
+		let sig = libsecp256k1::Signature::parse_overflowing_slice(&sig[0..64])
+			.map_err(|_| EcdsaVerifyError::BadRS)?;
+		let msg = libsecp256k1::Message::parse(msg);
+		let pubkey =
+			libsecp256k1::recover(&msg, &sig, &rid).map_err(|_| EcdsaVerifyError::BadSignature)?;
+		Ok(pubkey.serialize_compressed())
+	}
+
+	/// Verify and recover a SECP256k1 ECDSA signature.
+	///
+	/// - `sig` is passed in RSV format. V should be either `0/1` or `27/28`.
+	/// - `msg` is the blake2-256 hash of the message.
+	///
+	/// Returns `Err` if the signature is bad, otherwise the 33-byte compressed pubkey.
+	#[version(2)]
+	fn secp256k1_ecdsa_recover_compressed(
+		sig: &[u8; 65],
+		msg: &[u8; 32],
+	) -> Result<[u8; 33], EcdsaVerifyError> {
+		let rid = RecoveryId::from_i32(if sig[64] > 26 { sig[64] - 27 } else { sig[64] } as i32)
+			.map_err(|_| EcdsaVerifyError::BadV)?;
+		let sig = RecoverableSignature::from_compact(&sig[..64], rid)
+			.map_err(|_| EcdsaVerifyError::BadRS)?;
+		let msg = Message::from_slice(msg).expect("Message is 32 bytes; qed");
+		let pubkey = SECP256K1
+			.recover_ecdsa(&msg, &sig)
+			.map_err(|_| EcdsaVerifyError::BadSignature)?;
+		Ok(pubkey.serialize())
+	}
+
+	/// Generate an `bls12-377` key for the given key type using an optional `seed` and
+	/// store it in the keystore.
+	///
+	/// The `seed` needs to be a valid utf8.
+	///
+	/// Returns the public key.
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_generate(&mut self, id: KeyTypeId, seed: Option<Vec<u8>>) -> bls377::Public {
+		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.bls377_generate_new(id, seed)
+			.expect("`bls377_generate` failed")
+	}
+
+	/// Generate a `bandersnatch` key pair for the given key type using an optional
+	/// `seed` and store it in the keystore.
+	///
+	/// The `seed` needs to be a valid utf8.
+	///
+	/// Returns the public key.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_generate(
+		&mut self,
+		id: KeyTypeId,
+		seed: Option<Vec<u8>>,
+	) -> bandersnatch::Public {
+		let seed = seed.as_ref().map(|s| std::str::from_utf8(s).expect("Seed is valid utf8!"));
+		self.extension::<KeystoreExt>()
+			.expect("No `keystore` associated for the current context!")
+			.bandersnatch_generate_new(id, seed)
+			.expect("`bandernatch_generate` failed")
+	}
+}
+
+/// Interface that provides functions for hashing with different algorithms.
+#[runtime_interface]
+pub trait Hashing {
+	/// Conduct a 256-bit Keccak hash.
+	fn keccak_256(data: &[u8]) -> [u8; 32] {
+		sp_core::hashing::keccak_256(data)
+	}
+
+	/// Conduct a 512-bit Keccak hash.
+	fn keccak_512(data: &[u8]) -> [u8; 64] {
+		sp_core::hashing::keccak_512(data)
+	}
+
+	/// Conduct a 256-bit Sha2 hash.
+	fn sha2_256(data: &[u8]) -> [u8; 32] {
+		sp_core::hashing::sha2_256(data)
+	}
+
+	/// Conduct a 128-bit Blake2 hash.
+	fn blake2_128(data: &[u8]) -> [u8; 16] {
+		sp_core::hashing::blake2_128(data)
+	}
+
+	/// Conduct a 256-bit Blake2 hash.
+	fn blake2_256(data: &[u8]) -> [u8; 32] {
+		sp_core::hashing::blake2_256(data)
+	}
+
+	/// Conduct four XX hashes to give a 256-bit result.
+	fn twox_256(data: &[u8]) -> [u8; 32] {
+		sp_core::hashing::twox_256(data)
+	}
+
+	/// Conduct two XX hashes to give a 128-bit result.
+	fn twox_128(data: &[u8]) -> [u8; 16] {
+		sp_core::hashing::twox_128(data)
+	}
+
+	/// Conduct two XX hashes to give a 64-bit result.
+	fn twox_64(data: &[u8]) -> [u8; 8] {
+		sp_core::hashing::twox_64(data)
+	}
+}
+
+/// Interface that provides transaction indexing API.
+#[runtime_interface]
+pub trait TransactionIndex {
+	/// Add transaction index. Returns indexed content hash.
+	fn index(&mut self, extrinsic: u32, size: u32, context_hash: [u8; 32]) {
+		self.storage_index_transaction(extrinsic, &context_hash, size);
+	}
+
+	/// Conduct a 512-bit Keccak hash.
+	fn renew(&mut self, extrinsic: u32, context_hash: [u8; 32]) {
+		self.storage_renew_transaction_index(extrinsic, &context_hash);
+	}
+}
+
+/// Interface that provides functions to access the Offchain DB.
+#[runtime_interface]
+pub trait OffchainIndex {
+	/// Write a key value pair to the Offchain DB database in a buffered fashion.
+	fn set(&mut self, key: &[u8], value: &[u8]) {
+		self.set_offchain_storage(key, Some(value));
+	}
+
+	/// Remove a key and its associated value from the Offchain DB.
+	fn clear(&mut self, key: &[u8]) {
+		self.set_offchain_storage(key, None);
+	}
+}
+
+#[cfg(feature = "std")]
+sp_externalities::decl_extension! {
+	/// Deprecated verification context.
+	///
+	/// Stores the combined result of all verifications that are done in the same context.
+	struct VerificationExtDeprecated(bool);
+}
+
+/// Interface that provides functions to access the offchain functionality.
+///
+/// These functions are being made available to the runtime and are called by the runtime.
+#[runtime_interface]
+pub trait Offchain {
+	/// Returns if the local node is a potential validator.
+	///
+	/// Even if this function returns `true`, it does not mean that any keys are configured
+	/// and that the validator is registered in the chain.
+	fn is_validator(&mut self) -> bool {
+		self.extension::<OffchainWorkerExt>()
+			.expect("is_validator can be called only in the offchain worker context")
+			.is_validator()
+	}
+
+	/// Submit an encoded transaction to the pool.
+	///
+	/// The transaction will end up in the pool.
+	fn submit_transaction(&mut self, data: Vec<u8>) -> Result<(), ()> {
+		self.extension::<TransactionPoolExt>()
+			.expect(
+				"submit_transaction can be called only in the offchain call context with
+				TransactionPool capabilities enabled",
+			)
+			.submit_transaction(data)
+	}
+
+	/// Returns information about the local node's network state.
+	fn network_state(&mut self) -> Result<OpaqueNetworkState, ()> {
+		self.extension::<OffchainWorkerExt>()
+			.expect("network_state can be called only in the offchain worker context")
+			.network_state()
+	}
+
+	/// Returns current UNIX timestamp (in millis)
+	fn timestamp(&mut self) -> Timestamp {
+		self.extension::<OffchainWorkerExt>()
+			.expect("timestamp can be called only in the offchain worker context")
+			.timestamp()
+	}
+
+	/// Pause the execution until `deadline` is reached.
+	fn sleep_until(&mut self, deadline: Timestamp) {
+		self.extension::<OffchainWorkerExt>()
+			.expect("sleep_until can be called only in the offchain worker context")
+			.sleep_until(deadline)
+	}
+
+	/// Returns a random seed.
+	///
+	/// This is a truly random, non-deterministic seed generated by host environment.
+	/// Obviously fine in the off-chain worker context.
+	fn random_seed(&mut self) -> [u8; 32] {
+		self.extension::<OffchainWorkerExt>()
+			.expect("random_seed can be called only in the offchain worker context")
+			.random_seed()
+	}
+
+	/// Sets a value in the local storage.
+	///
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It IS persisted between runs.
+	fn local_storage_set(&mut self, kind: StorageKind, key: &[u8], value: &[u8]) {
+		self.extension::<OffchainDbExt>()
+			.expect(
+				"local_storage_set can be called only in the offchain call context with
+				OffchainDb extension",
+			)
+			.local_storage_set(kind, key, value)
+	}
+
+	/// Remove a value from the local storage.
+	///
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It IS persisted between runs.
+	fn local_storage_clear(&mut self, kind: StorageKind, key: &[u8]) {
+		self.extension::<OffchainDbExt>()
+			.expect(
+				"local_storage_clear can be called only in the offchain call context with
+				OffchainDb extension",
+			)
+			.local_storage_clear(kind, key)
+	}
+
+	/// Sets a value in the local storage if it matches current value.
+	///
+	/// Since multiple offchain workers may be running concurrently, to prevent
+	/// data races use CAS to coordinate between them.
+	///
+	/// Returns `true` if the value has been set, `false` otherwise.
+	///
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It IS persisted between runs.
+	fn local_storage_compare_and_set(
+		&mut self,
+		kind: StorageKind,
+		key: &[u8],
+		old_value: Option<Vec<u8>>,
+		new_value: &[u8],
+	) -> bool {
+		self.extension::<OffchainDbExt>()
+			.expect(
+				"local_storage_compare_and_set can be called only in the offchain call context
+				with OffchainDb extension",
+			)
+			.local_storage_compare_and_set(kind, key, old_value.as_deref(), new_value)
+	}
+
+	/// Gets a value from the local storage.
+	///
+	/// If the value does not exist in the storage `None` will be returned.
+	/// Note this storage is not part of the consensus, it's only accessible by
+	/// offchain worker tasks running on the same machine. It IS persisted between runs.
+	fn local_storage_get(&mut self, kind: StorageKind, key: &[u8]) -> Option<Vec<u8>> {
+		self.extension::<OffchainDbExt>()
+			.expect(
+				"local_storage_get can be called only in the offchain call context with
+				OffchainDb extension",
+			)
+			.local_storage_get(kind, key)
+	}
+
+	/// Initiates a http request given HTTP verb and the URL.
+	///
+	/// Meta is a future-reserved field containing additional, parity-scale-codec encoded
+	/// parameters. Returns the id of newly started request.
+	fn http_request_start(
+		&mut self,
+		method: &str,
+		uri: &str,
+		meta: &[u8],
+	) -> Result<HttpRequestId, ()> {
+		self.extension::<OffchainWorkerExt>()
+			.expect("http_request_start can be called only in the offchain worker context")
+			.http_request_start(method, uri, meta)
+	}
+
+	/// Append header to the request.
+	fn http_request_add_header(
+		&mut self,
+		request_id: HttpRequestId,
+		name: &str,
+		value: &str,
+	) -> Result<(), ()> {
+		self.extension::<OffchainWorkerExt>()
+			.expect("http_request_add_header can be called only in the offchain worker context")
+			.http_request_add_header(request_id, name, value)
+	}
+
+	/// Write a chunk of request body.
+	///
+	/// Writing an empty chunks finalizes the request.
+	/// Passing `None` as deadline blocks forever.
+	///
+	/// Returns an error in case deadline is reached or the chunk couldn't be written.
+	fn http_request_write_body(
+		&mut self,
+		request_id: HttpRequestId,
+		chunk: &[u8],
+		deadline: Option<Timestamp>,
+	) -> Result<(), HttpError> {
+		self.extension::<OffchainWorkerExt>()
+			.expect("http_request_write_body can be called only in the offchain worker context")
+			.http_request_write_body(request_id, chunk, deadline)
+	}
+
+	/// Block and wait for the responses for given requests.
+	///
+	/// Returns a vector of request statuses (the len is the same as ids).
+	/// Note that if deadline is not provided the method will block indefinitely,
+	/// otherwise unready responses will produce `DeadlineReached` status.
+	///
+	/// Passing `None` as deadline blocks forever.
+	fn http_response_wait(
+		&mut self,
+		ids: &[HttpRequestId],
+		deadline: Option<Timestamp>,
+	) -> Vec<HttpRequestStatus> {
+		self.extension::<OffchainWorkerExt>()
+			.expect("http_response_wait can be called only in the offchain worker context")
+			.http_response_wait(ids, deadline)
+	}
+
+	/// Read all response headers.
+	///
+	/// Returns a vector of pairs `(HeaderKey, HeaderValue)`.
+	/// NOTE: response headers have to be read before response body.
+	fn http_response_headers(&mut self, request_id: HttpRequestId) -> Vec<(Vec<u8>, Vec<u8>)> {
+		self.extension::<OffchainWorkerExt>()
+			.expect("http_response_headers can be called only in the offchain worker context")
+			.http_response_headers(request_id)
+	}
+
+	/// Read a chunk of body response to given buffer.
+	///
+	/// Returns the number of bytes written or an error in case a deadline
+	/// is reached or server closed the connection.
+	/// If `0` is returned it means that the response has been fully consumed
+	/// and the `request_id` is now invalid.
+	/// NOTE: this implies that response headers must be read before draining the body.
+	/// Passing `None` as a deadline blocks forever.
+	fn http_response_read_body(
+		&mut self,
+		request_id: HttpRequestId,
+		buffer: &mut [u8],
+		deadline: Option<Timestamp>,
+	) -> Result<u32, HttpError> {
+		self.extension::<OffchainWorkerExt>()
+			.expect("http_response_read_body can be called only in the offchain worker context")
+			.http_response_read_body(request_id, buffer, deadline)
+			.map(|r| r as u32)
+	}
+
+	/// Set the authorized nodes and authorized_only flag.
+	fn set_authorized_nodes(&mut self, nodes: Vec<OpaquePeerId>, authorized_only: bool) {
+		self.extension::<OffchainWorkerExt>()
+			.expect("set_authorized_nodes can be called only in the offchain worker context")
+			.set_authorized_nodes(nodes, authorized_only)
+	}
+}
+
+/// Wasm only interface that provides functions for calling into the allocator.
+#[runtime_interface(wasm_only)]
+pub trait Allocator {
+	/// Malloc the given number of bytes and return the pointer to the allocated memory location.
+	fn malloc(&mut self, size: u32) -> Pointer<u8> {
+		self.allocate_memory(size).expect("Failed to allocate memory")
+	}
+
+	/// Free the given pointer.
+	fn free(&mut self, ptr: Pointer<u8>) {
+		self.deallocate_memory(ptr).expect("Failed to deallocate memory")
+	}
+}
+
+/// WASM-only interface which allows for aborting the execution in case
+/// of an unrecoverable error.
+#[runtime_interface(wasm_only)]
+pub trait PanicHandler {
+	/// Aborts the current execution with the given error message.
+	#[trap_on_return]
+	fn abort_on_panic(&mut self, message: &str) {
+		self.register_panic_error_message(message);
+	}
+}
+
+/// Interface that provides functions for logging from within the runtime.
+#[runtime_interface]
+pub trait Logging {
+	/// Request to print a log message on the host.
+	///
+	/// Note that this will be only displayed if the host is enabled to display log messages with
+	/// given level and target.
+	///
+	/// Instead of using directly, prefer setting up `RuntimeLogger` and using `log` macros.
+	fn log(level: LogLevel, target: &str, message: &[u8]) {
+		if let Ok(message) = std::str::from_utf8(message) {
+			log::log!(target: target, log::Level::from(level), "{}", message)
+		}
+	}
+
+	/// Returns the max log level used by the host.
+	fn max_level() -> LogLevelFilter {
+		log::max_level().into()
+	}
+}
+
+#[derive(Encode, Decode)]
+/// Crossing is a helper wrapping any Encode-Decodeable type
+/// for transferring over the wasm barrier.
+pub struct Crossing<T: Encode + Decode>(T);
+
+impl<T: Encode + Decode> PassBy for Crossing<T> {
+	type PassBy = sp_runtime_interface::pass_by::Codec<Self>;
+}
+
+impl<T: Encode + Decode> Crossing<T> {
+	/// Convert into the inner type
+	pub fn into_inner(self) -> T {
+		self.0
+	}
+}
+
+// useful for testing
+impl<T> core::default::Default for Crossing<T>
+where
+	T: core::default::Default + Encode + Decode,
+{
+	fn default() -> Self {
+		Self(Default::default())
+	}
+}
+
+/// Interface to provide tracing facilities for wasm. Modelled after tokios `tracing`-crate
+/// interfaces. See `sp-tracing` for more information.
+#[runtime_interface(wasm_only, no_tracing)]
+pub trait WasmTracing {
+	/// Whether the span described in `WasmMetadata` should be traced wasm-side
+	/// On the host converts into a static Metadata and checks against the global `tracing`
+	/// dispatcher.
+	///
+	/// When returning false the calling code should skip any tracing-related execution. In general
+	/// within the same block execution this is not expected to change and it doesn't have to be
+	/// checked more than once per metadata. This exists for optimisation purposes but is still not
+	/// cheap as it will jump the wasm-native-barrier every time it is called. So an implementation
+	/// might chose to cache the result for the execution of the entire block.
+	fn enabled(&mut self, metadata: Crossing<sp_tracing::WasmMetadata>) -> bool {
+		let metadata: &tracing_core::metadata::Metadata<'static> = (&metadata.into_inner()).into();
+		tracing::dispatcher::get_default(|d| d.enabled(metadata))
+	}
+
+	/// Open a new span with the given attributes. Return the u64 Id of the span.
+	///
+	/// On the native side this goes through the default `tracing` dispatcher to register the span
+	/// and then calls `clone_span` with the ID to signal that we are keeping it around on the wasm-
+	/// side even after the local span is dropped. The resulting ID is then handed over to the wasm-
+	/// side.
+	fn enter_span(&mut self, span: Crossing<sp_tracing::WasmEntryAttributes>) -> u64 {
+		let span: tracing::Span = span.into_inner().into();
+		match span.id() {
+			Some(id) => tracing::dispatcher::get_default(|d| {
+				// inform dispatch that we'll keep the ID around
+				// then enter it immediately
+				let final_id = d.clone_span(&id);
+				d.enter(&final_id);
+				final_id.into_u64()
+			}),
+			_ => 0,
+		}
+	}
+
+	/// Emit the given event to the global tracer on the native side
+	fn event(&mut self, event: Crossing<sp_tracing::WasmEntryAttributes>) {
+		event.into_inner().emit();
+	}
+
+	/// Signal that a given span-id has been exited. On native, this directly
+	/// proxies the span to the global dispatcher.
+	fn exit(&mut self, span: u64) {
+		tracing::dispatcher::get_default(|d| {
+			let id = tracing_core::span::Id::from_u64(span);
+			d.exit(&id);
+		});
+	}
+}
+
+#[cfg(all(not(feature = "std"), feature = "with-tracing"))]
+mod tracing_setup {
+	use super::{wasm_tracing, Crossing};
+	use core::sync::atomic::{AtomicBool, Ordering};
+	use tracing_core::{
+		dispatcher::{set_global_default, Dispatch},
+		span::{Attributes, Id, Record},
+		Event, Metadata,
+	};
+
+	static TRACING_SET: AtomicBool = AtomicBool::new(false);
+
+	/// The PassingTracingSubscriber implements `tracing_core::Subscriber`
+	/// and pushes the information across the runtime interface to the host
+	struct PassingTracingSubsciber;
+
+	impl tracing_core::Subscriber for PassingTracingSubsciber {
+		fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+			wasm_tracing::enabled(Crossing(metadata.into()))
+		}
+		fn new_span(&self, attrs: &Attributes<'_>) -> Id {
+			Id::from_u64(wasm_tracing::enter_span(Crossing(attrs.into())))
+		}
+		fn enter(&self, _: &Id) {
+			// Do nothing, we already entered the span previously
+		}
+		/// Not implemented! We do not support recording values later
+		/// Will panic when used.
+		fn record(&self, _: &Id, _: &Record<'_>) {
+			unimplemented! {} // this usage is not supported
+		}
+		/// Not implemented! We do not support recording values later
+		/// Will panic when used.
+		fn record_follows_from(&self, _: &Id, _: &Id) {
+			unimplemented! {} // this usage is not supported
+		}
+		fn event(&self, event: &Event<'_>) {
+			wasm_tracing::event(Crossing(event.into()))
+		}
+		fn exit(&self, span: &Id) {
+			wasm_tracing::exit(span.into_u64())
+		}
+	}
+
+	/// Initialize tracing of sp_tracing on wasm with `with-tracing` enabled.
+	/// Can be called multiple times from within the same process and will only
+	/// set the global bridging subscriber once.
+	pub fn init_tracing() {
+		if TRACING_SET.load(Ordering::Relaxed) == false {
+			set_global_default(Dispatch::new(PassingTracingSubsciber {}))
+				.expect("We only ever call this once");
+			TRACING_SET.store(true, Ordering::Relaxed);
+		}
+	}
+}
+
+#[cfg(not(all(not(feature = "std"), feature = "with-tracing")))]
+mod tracing_setup {
+	/// Initialize tracing of sp_tracing not necessary – noop. To enable build
+	/// without std and with the `with-tracing`-feature.
+	pub fn init_tracing() {}
+}
+
+pub use tracing_setup::init_tracing;
+
+/// Allocator used by Substrate when executing the Wasm runtime.
+#[cfg(all(target_arch = "wasm32", not(feature = "std")))]
+struct WasmAllocator;
+
+#[cfg(all(target_arch = "wasm32", not(feature = "disable_allocator"), not(feature = "std")))]
+#[global_allocator]
+static ALLOCATOR: WasmAllocator = WasmAllocator;
+
+#[cfg(all(target_arch = "wasm32", not(feature = "std")))]
+mod allocator_impl {
+	use super::*;
+	use core::alloc::{GlobalAlloc, Layout};
+
+	unsafe impl GlobalAlloc for WasmAllocator {
+		unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+			allocator::malloc(layout.size() as u32)
+		}
+
+		unsafe fn dealloc(&self, ptr: *mut u8, _: Layout) {
+			allocator::free(ptr)
+		}
+	}
+}
+
+/// A default panic handler for WASM environment.
+#[cfg(all(not(feature = "disable_panic_handler"), not(feature = "std")))]
+#[panic_handler]
+#[no_mangle]
+pub fn panic(info: &core::panic::PanicInfo) -> ! {
+	let message = sp_std::alloc::format!("{}", info);
+	#[cfg(feature = "improved_panic_error_reporting")]
+	{
+		panic_handler::abort_on_panic(&message);
+	}
+	#[cfg(not(feature = "improved_panic_error_reporting"))]
+	{
+		logging::log(LogLevel::Error, "runtime", message.as_bytes());
+		core::arch::wasm32::unreachable();
+	}
+}
+
+/// A default OOM handler for WASM environment.
+#[cfg(all(not(feature = "disable_oom"), enable_alloc_error_handler))]
+#[alloc_error_handler]
+pub fn oom(_: core::alloc::Layout) -> ! {
+	#[cfg(feature = "improved_panic_error_reporting")]
+	{
+		panic_handler::abort_on_panic("Runtime memory exhausted.");
+	}
+	#[cfg(not(feature = "improved_panic_error_reporting"))]
+	{
+		logging::log(LogLevel::Error, "runtime", b"Runtime memory exhausted. Aborting");
+		core::arch::wasm32::unreachable();
+	}
+}
+
+/// Type alias for Externalities implementation used in tests.
+#[cfg(feature = "std")]
+pub type TestExternalities = sp_state_machine::TestExternalities<sp_core::Blake2Hasher>;
+
+/// The host functions Substrate provides for the Wasm runtime environment.
+///
+/// All these host functions will be callable from inside the Wasm environment.
+#[cfg(feature = "std")]
+pub type SubstrateHostFunctions = (
+	storage::HostFunctions,
+	default_child_storage::HostFunctions,
+	misc::HostFunctions,
+	wasm_tracing::HostFunctions,
+	offchain::HostFunctions,
+	crypto::HostFunctions,
+	hashing::HostFunctions,
+	allocator::HostFunctions,
+	panic_handler::HostFunctions,
+	logging::HostFunctions,
+	crate::trie::HostFunctions,
+	offchain_index::HostFunctions,
+	transaction_index::HostFunctions,
+);
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{crypto::UncheckedInto, map, storage::Storage};
+	use sp_state_machine::BasicExternalities;
+
+	#[test]
+	fn storage_works() {
+		let mut t = BasicExternalities::default();
+		t.execute_with(|| {
+			assert_eq!(storage::get(b"hello"), None);
+			storage::set(b"hello", b"world");
+			assert_eq!(storage::get(b"hello"), Some(b"world".to_vec().into()));
+			assert_eq!(storage::get(b"foo"), None);
+			storage::set(b"foo", &[1, 2, 3][..]);
+		});
+
+		t = BasicExternalities::new(Storage {
+			top: map![b"foo".to_vec() => b"bar".to_vec()],
+			children_default: map![],
+		});
+
+		t.execute_with(|| {
+			assert_eq!(storage::get(b"hello"), None);
+			assert_eq!(storage::get(b"foo"), Some(b"bar".to_vec().into()));
+		});
+
+		let value = vec![7u8; 35];
+		let storage =
+			Storage { top: map![b"foo00".to_vec() => value.clone()], children_default: map![] };
+		t = BasicExternalities::new(storage);
+
+		t.execute_with(|| {
+			assert_eq!(storage::get(b"hello"), None);
+			assert_eq!(storage::get(b"foo00"), Some(value.clone().into()));
+		});
+	}
+
+	#[test]
+	fn read_storage_works() {
+		let value = b"\x0b\0\0\0Hello world".to_vec();
+		let mut t = BasicExternalities::new(Storage {
+			top: map![b":test".to_vec() => value.clone()],
+			children_default: map![],
+		});
+
+		t.execute_with(|| {
+			let mut v = [0u8; 4];
+			assert_eq!(storage::read(b":test", &mut v[..], 0).unwrap(), value.len() as u32);
+			assert_eq!(v, [11u8, 0, 0, 0]);
+			let mut w = [0u8; 11];
+			assert_eq!(storage::read(b":test", &mut w[..], 4).unwrap(), value.len() as u32 - 4);
+			assert_eq!(&w, b"Hello world");
+		});
+	}
+
+	#[test]
+	fn clear_prefix_works() {
+		let mut t = BasicExternalities::new(Storage {
+			top: map![
+				b":a".to_vec() => b"\x0b\0\0\0Hello world".to_vec(),
+				b":abcd".to_vec() => b"\x0b\0\0\0Hello world".to_vec(),
+				b":abc".to_vec() => b"\x0b\0\0\0Hello world".to_vec(),
+				b":abdd".to_vec() => b"\x0b\0\0\0Hello world".to_vec()
+			],
+			children_default: map![],
+		});
+
+		t.execute_with(|| {
+			// We can switch to this once we enable v3 of the `clear_prefix`.
+			//assert!(matches!(
+			//	storage::clear_prefix(b":abc", None),
+			//	MultiRemovalResults::NoneLeft { db: 2, total: 2 }
+			//));
+			assert!(matches!(
+				storage::clear_prefix(b":abc", None),
+				KillStorageResult::AllRemoved(2),
+			));
+
+			assert!(storage::get(b":a").is_some());
+			assert!(storage::get(b":abdd").is_some());
+			assert!(storage::get(b":abcd").is_none());
+			assert!(storage::get(b":abc").is_none());
+
+			// We can switch to this once we enable v3 of the `clear_prefix`.
+			//assert!(matches!(
+			//	storage::clear_prefix(b":abc", None),
+			//	MultiRemovalResults::NoneLeft { db: 0, total: 0 }
+			//));
+			assert!(matches!(
+				storage::clear_prefix(b":abc", None),
+				KillStorageResult::AllRemoved(0),
+			));
+		});
+	}
+
+	fn zero_ed_pub() -> ed25519::Public {
+		[0u8; 32].unchecked_into()
+	}
+
+	fn zero_ed_sig() -> ed25519::Signature {
+		ed25519::Signature::from_raw([0u8; 64])
+	}
+
+	#[test]
+	fn use_dalek_ext_works() {
+		let mut ext = BasicExternalities::default();
+		ext.register_extension(UseDalekExt::default());
+
+		// With dalek the zero signature should fail to verify.
+		ext.execute_with(|| {
+			assert!(!crypto::ed25519_verify(&zero_ed_sig(), &Vec::new(), &zero_ed_pub()));
+		});
+
+		// But with zebra it should work.
+		BasicExternalities::default().execute_with(|| {
+			assert!(crypto::ed25519_verify(&zero_ed_sig(), &Vec::new(), &zero_ed_pub()));
+		})
+	}
+
+	#[test]
+	fn dalek_should_not_panic_on_invalid_signature() {
+		let mut ext = BasicExternalities::default();
+		ext.register_extension(UseDalekExt::default());
+
+		ext.execute_with(|| {
+			let mut bytes = [0u8; 64];
+			// Make it invalid
+			bytes[63] = 0b1110_0000;
+
+			assert!(!crypto::ed25519_verify(
+				&ed25519::Signature::from_raw(bytes),
+				&Vec::new(),
+				&zero_ed_pub()
+			));
+		});
+	}
+}
diff --git a/substrate/primitives/keyring/Cargo.toml b/substrate/primitives/keyring/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c2d20dba49014fcf2256605d2c05c450b0b6fb51
--- /dev/null
+++ b/substrate/primitives/keyring/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "sp-keyring"
+version = "24.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Keyring support code for the runtime. A set of test accounts."
+documentation = "https://docs.rs/sp-keyring"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+lazy_static = "1.4.0"
+strum = { version = "0.24.1", features = ["derive"], default-features = false }
+sp-core = { version = "21.0.0", path = "../core" }
+sp-runtime = { version = "24.0.0", path = "../runtime" }
+
+[features]
+# This feature adds Bandersnatch crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bandersnatch-experimental = [ "sp-core/bandersnatch-experimental" ]
diff --git a/substrate/primitives/keyring/README.md b/substrate/primitives/keyring/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1610f237df97a8a96f5017f0c15c686661de36e4
--- /dev/null
+++ b/substrate/primitives/keyring/README.md
@@ -0,0 +1,3 @@
+Support code for the runtime. A set of test accounts.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/keyring/src/bandersnatch.rs b/substrate/primitives/keyring/src/bandersnatch.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8de6786a6fbf6384de2308e420201c45a31109f6
--- /dev/null
+++ b/substrate/primitives/keyring/src/bandersnatch.rs
@@ -0,0 +1,209 @@
+// 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 set of well-known keys used for testing.
+
+pub use sp_core::bandersnatch;
+use sp_core::{
+	bandersnatch::{Pair, Public, Signature},
+	crypto::UncheckedFrom,
+	ByteArray, Pair as PairT,
+};
+
+use lazy_static::lazy_static;
+use std::{collections::HashMap, ops::Deref, sync::Mutex};
+
+/// Set of test accounts.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumIter)]
+pub enum Keyring {
+	Alice,
+	Bob,
+	Charlie,
+	Dave,
+	Eve,
+	Ferdie,
+	One,
+	Two,
+}
+
+const PUBLIC_RAW_LEN: usize = <Public as ByteArray>::LEN;
+
+impl Keyring {
+	pub fn from_public(who: &Public) -> Option<Keyring> {
+		Self::iter().find(|&k| &Public::from(k) == who)
+	}
+
+	pub fn from_raw_public(who: [u8; PUBLIC_RAW_LEN]) -> Option<Keyring> {
+		Self::from_public(&Public::unchecked_from(who))
+	}
+
+	pub fn to_raw_public(self) -> [u8; PUBLIC_RAW_LEN] {
+		*Public::from(self).as_ref()
+	}
+
+	pub fn to_raw_public_vec(self) -> Vec<u8> {
+		Public::from(self).to_raw_vec()
+	}
+
+	pub fn sign(self, msg: &[u8]) -> Signature {
+		Pair::from(self).sign(msg)
+	}
+
+	pub fn pair(self) -> Pair {
+		Pair::from_string(&format!("//{}", <&'static str>::from(self)), None)
+			.expect("static values are known good; qed")
+	}
+
+	/// Returns an iterator over all test accounts.
+	pub fn iter() -> impl Iterator<Item = Keyring> {
+		<Self as strum::IntoEnumIterator>::iter()
+	}
+
+	pub fn public(self) -> Public {
+		self.pair().public()
+	}
+
+	pub fn to_seed(self) -> String {
+		format!("//{}", self)
+	}
+
+	/// Create a crypto `Pair` from a numeric value.
+	pub fn numeric(idx: usize) -> Pair {
+		Pair::from_string(&format!("//{}", idx), None).expect("numeric values are known good; qed")
+	}
+}
+
+impl From<Keyring> for &'static str {
+	fn from(k: Keyring) -> Self {
+		match k {
+			Keyring::Alice => "Alice",
+			Keyring::Bob => "Bob",
+			Keyring::Charlie => "Charlie",
+			Keyring::Dave => "Dave",
+			Keyring::Eve => "Eve",
+			Keyring::Ferdie => "Ferdie",
+			Keyring::One => "One",
+			Keyring::Two => "Two",
+		}
+	}
+}
+
+#[derive(Debug)]
+pub struct ParseKeyringError;
+
+impl std::fmt::Display for ParseKeyringError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "ParseKeyringError")
+	}
+}
+
+impl std::str::FromStr for Keyring {
+	type Err = ParseKeyringError;
+
+	fn from_str(s: &str) -> Result<Self, <Self as std::str::FromStr>::Err> {
+		match s {
+			"Alice" => Ok(Keyring::Alice),
+			"Bob" => Ok(Keyring::Bob),
+			"Charlie" => Ok(Keyring::Charlie),
+			"Dave" => Ok(Keyring::Dave),
+			"Eve" => Ok(Keyring::Eve),
+			"Ferdie" => Ok(Keyring::Ferdie),
+			"One" => Ok(Keyring::One),
+			"Two" => Ok(Keyring::Two),
+			_ => Err(ParseKeyringError),
+		}
+	}
+}
+
+lazy_static! {
+	static ref PRIVATE_KEYS: Mutex<HashMap<Keyring, Pair>> =
+		Mutex::new(Keyring::iter().map(|who| (who, who.pair())).collect());
+	static ref PUBLIC_KEYS: HashMap<Keyring, Public> = PRIVATE_KEYS
+		.lock()
+		.unwrap()
+		.iter()
+		.map(|(&who, pair)| (who, pair.public()))
+		.collect();
+}
+
+impl From<Keyring> for Public {
+	fn from(k: Keyring) -> Self {
+		*(*PUBLIC_KEYS).get(&k).unwrap()
+	}
+}
+
+impl From<Keyring> for Pair {
+	fn from(k: Keyring) -> Self {
+		k.pair()
+	}
+}
+
+impl From<Keyring> for [u8; PUBLIC_RAW_LEN] {
+	fn from(k: Keyring) -> Self {
+		*(*PUBLIC_KEYS).get(&k).unwrap().as_ref()
+	}
+}
+
+impl From<Keyring> for &'static [u8; PUBLIC_RAW_LEN] {
+	fn from(k: Keyring) -> Self {
+		PUBLIC_KEYS.get(&k).unwrap().as_ref()
+	}
+}
+
+impl AsRef<[u8; PUBLIC_RAW_LEN]> for Keyring {
+	fn as_ref(&self) -> &[u8; PUBLIC_RAW_LEN] {
+		PUBLIC_KEYS.get(self).unwrap().as_ref()
+	}
+}
+
+impl AsRef<Public> for Keyring {
+	fn as_ref(&self) -> &Public {
+		PUBLIC_KEYS.get(self).unwrap()
+	}
+}
+
+impl Deref for Keyring {
+	type Target = [u8; PUBLIC_RAW_LEN];
+	fn deref(&self) -> &[u8; PUBLIC_RAW_LEN] {
+		PUBLIC_KEYS.get(self).unwrap().as_ref()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{bandersnatch::Pair, Pair as PairT};
+
+	#[test]
+	fn should_work() {
+		assert!(Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Alice!",
+			&Keyring::Alice.public(),
+		));
+		assert!(!Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Bob!",
+			&Keyring::Alice.public(),
+		));
+		assert!(!Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Alice!",
+			&Keyring::Bob.public(),
+		));
+	}
+}
diff --git a/substrate/primitives/keyring/src/ed25519.rs b/substrate/primitives/keyring/src/ed25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3ad86409e905a184b2993f586f5251427f5b920
--- /dev/null
+++ b/substrate/primitives/keyring/src/ed25519.rs
@@ -0,0 +1,204 @@
+// 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.
+
+//! Support code for the runtime. A set of test accounts.
+
+use lazy_static::lazy_static;
+pub use sp_core::ed25519;
+use sp_core::{
+	ed25519::{Pair, Public, Signature},
+	ByteArray, Pair as PairT, H256,
+};
+use sp_runtime::AccountId32;
+use std::{collections::HashMap, ops::Deref};
+
+/// Set of test accounts.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumIter)]
+pub enum Keyring {
+	Alice,
+	Bob,
+	Charlie,
+	Dave,
+	Eve,
+	Ferdie,
+	One,
+	Two,
+}
+
+impl Keyring {
+	pub fn from_public(who: &Public) -> Option<Keyring> {
+		Self::iter().find(|&k| &Public::from(k) == who)
+	}
+
+	pub fn from_account_id(who: &AccountId32) -> Option<Keyring> {
+		Self::iter().find(|&k| &k.to_account_id() == who)
+	}
+
+	pub fn from_raw_public(who: [u8; 32]) -> Option<Keyring> {
+		Self::from_public(&Public::from_raw(who))
+	}
+
+	pub fn to_raw_public(self) -> [u8; 32] {
+		*Public::from(self).as_array_ref()
+	}
+
+	pub fn from_h256_public(who: H256) -> Option<Keyring> {
+		Self::from_public(&Public::from_raw(who.into()))
+	}
+
+	pub fn to_h256_public(self) -> H256 {
+		Public::from(self).as_array_ref().into()
+	}
+
+	pub fn to_raw_public_vec(self) -> Vec<u8> {
+		Public::from(self).to_raw_vec()
+	}
+
+	pub fn to_account_id(self) -> AccountId32 {
+		self.to_raw_public().into()
+	}
+
+	pub fn sign(self, msg: &[u8]) -> Signature {
+		Pair::from(self).sign(msg)
+	}
+
+	pub fn pair(self) -> Pair {
+		Pair::from_string(&format!("//{}", <&'static str>::from(self)), None)
+			.expect("static values are known good; qed")
+	}
+
+	/// Returns an iterator over all test accounts.
+	pub fn iter() -> impl Iterator<Item = Keyring> {
+		<Self as strum::IntoEnumIterator>::iter()
+	}
+
+	pub fn public(self) -> Public {
+		self.pair().public()
+	}
+
+	pub fn to_seed(self) -> String {
+		format!("//{}", self)
+	}
+}
+
+impl From<Keyring> for &'static str {
+	fn from(k: Keyring) -> Self {
+		match k {
+			Keyring::Alice => "Alice",
+			Keyring::Bob => "Bob",
+			Keyring::Charlie => "Charlie",
+			Keyring::Dave => "Dave",
+			Keyring::Eve => "Eve",
+			Keyring::Ferdie => "Ferdie",
+			Keyring::One => "One",
+			Keyring::Two => "Two",
+		}
+	}
+}
+
+impl From<Keyring> for sp_runtime::MultiSigner {
+	fn from(x: Keyring) -> Self {
+		sp_runtime::MultiSigner::Ed25519(x.into())
+	}
+}
+
+lazy_static! {
+	static ref PRIVATE_KEYS: HashMap<Keyring, Pair> =
+		Keyring::iter().map(|i| (i, i.pair())).collect();
+	static ref PUBLIC_KEYS: HashMap<Keyring, Public> =
+		PRIVATE_KEYS.iter().map(|(&name, pair)| (name, pair.public())).collect();
+}
+
+impl From<Keyring> for Public {
+	fn from(k: Keyring) -> Self {
+		*(*PUBLIC_KEYS).get(&k).unwrap()
+	}
+}
+
+impl From<Keyring> for AccountId32 {
+	fn from(k: Keyring) -> Self {
+		k.to_account_id()
+	}
+}
+
+impl From<Keyring> for Pair {
+	fn from(k: Keyring) -> Self {
+		k.pair()
+	}
+}
+
+impl From<Keyring> for [u8; 32] {
+	fn from(k: Keyring) -> Self {
+		*(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
+	}
+}
+
+impl From<Keyring> for H256 {
+	fn from(k: Keyring) -> Self {
+		(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref().into()
+	}
+}
+
+impl From<Keyring> for &'static [u8; 32] {
+	fn from(k: Keyring) -> Self {
+		(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
+	}
+}
+
+impl AsRef<[u8; 32]> for Keyring {
+	fn as_ref(&self) -> &[u8; 32] {
+		(*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
+	}
+}
+
+impl AsRef<Public> for Keyring {
+	fn as_ref(&self) -> &Public {
+		(*PUBLIC_KEYS).get(self).unwrap()
+	}
+}
+
+impl Deref for Keyring {
+	type Target = [u8; 32];
+	fn deref(&self) -> &[u8; 32] {
+		(*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{ed25519::Pair, Pair as PairT};
+
+	#[test]
+	fn should_work() {
+		assert!(Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Alice!",
+			&Keyring::Alice.public(),
+		));
+		assert!(!Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Bob!",
+			&Keyring::Alice.public(),
+		));
+		assert!(!Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Alice!",
+			&Keyring::Bob.public(),
+		));
+	}
+}
diff --git a/substrate/primitives/keyring/src/lib.rs b/substrate/primitives/keyring/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1db18f7edbdc857a7e4731b2993a61290438bd53
--- /dev/null
+++ b/substrate/primitives/keyring/src/lib.rs
@@ -0,0 +1,43 @@
+// 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.
+
+//! Support code for the runtime. A set of test accounts.
+
+/// Test account crypto for sr25519.
+pub mod sr25519;
+
+/// Test account crypto for ed25519.
+pub mod ed25519;
+
+/// Test account crypto for bandersnatch.
+#[cfg(feature = "bandersnatch-experimental")]
+pub mod bandersnatch;
+
+/// Convenience export: Sr25519's Keyring is exposed as `AccountKeyring`,
+/// since it tends to be used for accounts (although it may also be used
+/// by authorities).
+pub use sr25519::Keyring as AccountKeyring;
+
+#[cfg(feature = "bandersnatch-experimental")]
+pub use bandersnatch::Keyring as BandersnatchKeyring;
+pub use ed25519::Keyring as Ed25519Keyring;
+pub use sr25519::Keyring as Sr25519Keyring;
+
+pub mod test {
+	/// The keyring for use with accounts when using the test runtime.
+	pub use super::ed25519::Keyring as AccountKeyring;
+}
diff --git a/substrate/primitives/keyring/src/sr25519.rs b/substrate/primitives/keyring/src/sr25519.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c738cfdc59d9eac368bc2d1925eb600cb8dfba0a
--- /dev/null
+++ b/substrate/primitives/keyring/src/sr25519.rs
@@ -0,0 +1,241 @@
+// 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.
+
+//! Support code for the runtime. A set of test accounts.
+
+use lazy_static::lazy_static;
+pub use sp_core::sr25519;
+use sp_core::{
+	sr25519::{Pair, Public, Signature},
+	ByteArray, Pair as PairT, H256,
+};
+use sp_runtime::AccountId32;
+use std::{collections::HashMap, ops::Deref};
+
+/// Set of test accounts.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::Display, strum::EnumIter)]
+pub enum Keyring {
+	Alice,
+	Bob,
+	Charlie,
+	Dave,
+	Eve,
+	Ferdie,
+	One,
+	Two,
+}
+
+impl Keyring {
+	pub fn from_public(who: &Public) -> Option<Keyring> {
+		Self::iter().find(|&k| &Public::from(k) == who)
+	}
+
+	pub fn from_account_id(who: &AccountId32) -> Option<Keyring> {
+		Self::iter().find(|&k| &k.to_account_id() == who)
+	}
+
+	pub fn from_raw_public(who: [u8; 32]) -> Option<Keyring> {
+		Self::from_public(&Public::from_raw(who))
+	}
+
+	pub fn to_raw_public(self) -> [u8; 32] {
+		*Public::from(self).as_array_ref()
+	}
+
+	pub fn from_h256_public(who: H256) -> Option<Keyring> {
+		Self::from_public(&Public::from_raw(who.into()))
+	}
+
+	pub fn to_h256_public(self) -> H256 {
+		Public::from(self).as_array_ref().into()
+	}
+
+	pub fn to_raw_public_vec(self) -> Vec<u8> {
+		Public::from(self).to_raw_vec()
+	}
+
+	pub fn to_account_id(self) -> AccountId32 {
+		self.to_raw_public().into()
+	}
+
+	pub fn sign(self, msg: &[u8]) -> Signature {
+		Pair::from(self).sign(msg)
+	}
+
+	pub fn pair(self) -> Pair {
+		Pair::from_string(&format!("//{}", <&'static str>::from(self)), None)
+			.expect("static values are known good; qed")
+	}
+
+	/// Returns an iterator over all test accounts.
+	pub fn iter() -> impl Iterator<Item = Keyring> {
+		<Self as strum::IntoEnumIterator>::iter()
+	}
+
+	pub fn public(self) -> Public {
+		self.pair().public()
+	}
+
+	pub fn to_seed(self) -> String {
+		format!("//{}", self)
+	}
+
+	/// Create a crypto `Pair` from a numeric value.
+	pub fn numeric(idx: usize) -> Pair {
+		Pair::from_string(&format!("//{}", idx), None).expect("numeric values are known good; qed")
+	}
+
+	/// Get account id of a `numeric` account.
+	pub fn numeric_id(idx: usize) -> AccountId32 {
+		(*Self::numeric(idx).public().as_array_ref()).into()
+	}
+}
+
+impl From<Keyring> for &'static str {
+	fn from(k: Keyring) -> Self {
+		match k {
+			Keyring::Alice => "Alice",
+			Keyring::Bob => "Bob",
+			Keyring::Charlie => "Charlie",
+			Keyring::Dave => "Dave",
+			Keyring::Eve => "Eve",
+			Keyring::Ferdie => "Ferdie",
+			Keyring::One => "One",
+			Keyring::Two => "Two",
+		}
+	}
+}
+
+impl From<Keyring> for sp_runtime::MultiSigner {
+	fn from(x: Keyring) -> Self {
+		sp_runtime::MultiSigner::Sr25519(x.into())
+	}
+}
+
+#[derive(Debug)]
+pub struct ParseKeyringError;
+
+impl std::fmt::Display for ParseKeyringError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "ParseKeyringError")
+	}
+}
+
+impl std::str::FromStr for Keyring {
+	type Err = ParseKeyringError;
+
+	fn from_str(s: &str) -> Result<Self, <Self as std::str::FromStr>::Err> {
+		match s {
+			"alice" => Ok(Keyring::Alice),
+			"bob" => Ok(Keyring::Bob),
+			"charlie" => Ok(Keyring::Charlie),
+			"dave" => Ok(Keyring::Dave),
+			"eve" => Ok(Keyring::Eve),
+			"ferdie" => Ok(Keyring::Ferdie),
+			"one" => Ok(Keyring::One),
+			"two" => Ok(Keyring::Two),
+			_ => Err(ParseKeyringError),
+		}
+	}
+}
+
+lazy_static! {
+	static ref PRIVATE_KEYS: HashMap<Keyring, Pair> =
+		Keyring::iter().map(|i| (i, i.pair())).collect();
+	static ref PUBLIC_KEYS: HashMap<Keyring, Public> =
+		PRIVATE_KEYS.iter().map(|(&name, pair)| (name, pair.public())).collect();
+}
+
+impl From<Keyring> for AccountId32 {
+	fn from(k: Keyring) -> Self {
+		k.to_account_id()
+	}
+}
+
+impl From<Keyring> for Public {
+	fn from(k: Keyring) -> Self {
+		*(*PUBLIC_KEYS).get(&k).unwrap()
+	}
+}
+
+impl From<Keyring> for Pair {
+	fn from(k: Keyring) -> Self {
+		k.pair()
+	}
+}
+
+impl From<Keyring> for [u8; 32] {
+	fn from(k: Keyring) -> Self {
+		*(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
+	}
+}
+
+impl From<Keyring> for H256 {
+	fn from(k: Keyring) -> Self {
+		(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref().into()
+	}
+}
+
+impl From<Keyring> for &'static [u8; 32] {
+	fn from(k: Keyring) -> Self {
+		(*PUBLIC_KEYS).get(&k).unwrap().as_array_ref()
+	}
+}
+
+impl AsRef<[u8; 32]> for Keyring {
+	fn as_ref(&self) -> &[u8; 32] {
+		(*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
+	}
+}
+
+impl AsRef<Public> for Keyring {
+	fn as_ref(&self) -> &Public {
+		(*PUBLIC_KEYS).get(self).unwrap()
+	}
+}
+
+impl Deref for Keyring {
+	type Target = [u8; 32];
+	fn deref(&self) -> &[u8; 32] {
+		(*PUBLIC_KEYS).get(self).unwrap().as_array_ref()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{sr25519::Pair, Pair as PairT};
+
+	#[test]
+	fn should_work() {
+		assert!(Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Alice!",
+			&Keyring::Alice.public(),
+		));
+		assert!(!Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Bob!",
+			&Keyring::Alice.public(),
+		));
+		assert!(!Pair::verify(
+			&Keyring::Alice.sign(b"I am Alice!"),
+			b"I am Alice!",
+			&Keyring::Bob.public(),
+		));
+	}
+}
diff --git a/substrate/primitives/keystore/Cargo.toml b/substrate/primitives/keystore/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e9e699f4cc6c0b6373d64f7686cbe3f8f6d693ec
--- /dev/null
+++ b/substrate/primitives/keystore/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+name = "sp-keystore"
+version = "0.27.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Keystore primitives."
+documentation = "https://docs.rs/sp-core"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+parking_lot = { version = "0.12.1", default-features = false }
+thiserror = "1.0"
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-externalities = { version = "0.19.0", default-features = false, path = "../externalities" }
+
+[dev-dependencies]
+rand = "0.7.2"
+rand_chacha = "0.2.2"
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "sp-core/std", "sp-externalities/std" ]
+
+# This feature adds BLS crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bls-experimental = [ "sp-core/bls-experimental" ]
+
+# This feature adds Bandersnatch crypto primitives.
+# It should not be used in production since the implementation and interface may still
+# be subject to significant changes.
+bandersnatch-experimental = [ "sp-core/bandersnatch-experimental" ]
diff --git a/substrate/primitives/keystore/src/lib.rs b/substrate/primitives/keystore/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..82062fe7b40a713ca0afa934431e74a307f55108
--- /dev/null
+++ b/substrate/primitives/keystore/src/lib.rs
@@ -0,0 +1,633 @@
+// 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.
+
+//! Keystore traits
+
+pub mod testing;
+
+#[cfg(feature = "bandersnatch-experimental")]
+use sp_core::bandersnatch;
+#[cfg(feature = "bls-experimental")]
+use sp_core::{bls377, bls381};
+use sp_core::{
+	crypto::{ByteArray, CryptoTypeId, KeyTypeId},
+	ecdsa, ed25519, sr25519,
+};
+
+use std::sync::Arc;
+
+/// Keystore error
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Public key type is not supported
+	#[error("Key not supported: {0:?}")]
+	KeyNotSupported(KeyTypeId),
+	/// Validation error
+	#[error("Validation error: {0}")]
+	ValidationError(String),
+	/// Keystore unavailable
+	#[error("Keystore unavailable")]
+	Unavailable,
+	/// Programming errors
+	#[error("An unknown keystore error occurred: {0}")]
+	Other(String),
+}
+
+/// Something that generates, stores and provides access to secret keys.
+pub trait Keystore: Send + Sync {
+	/// Returns all the sr25519 public keys for the given key type.
+	fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<sr25519::Public>;
+
+	/// Generate a new sr25519 key pair for the given key type and an optional seed.
+	///
+	/// Returns an `sr25519::Public` key of the generated key pair or an `Err` if
+	/// something failed during key generation.
+	fn sr25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<sr25519::Public, Error>;
+
+	/// Generate an sr25519 signature for a given message.
+	///
+	/// Receives [`KeyTypeId`] and an [`sr25519::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns an [`sr25519::Signature`] or `None` in case the given `key_type`
+	/// and `public` combination doesn't exist in the keystore.
+	/// An `Err` will be returned if generating the signature itself failed.
+	fn sr25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		msg: &[u8],
+	) -> Result<Option<sr25519::Signature>, Error>;
+
+	/// Generate an sr25519 VRF signature for the given data.
+	///
+	/// Receives [`KeyTypeId`] and an [`sr25519::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns `None` if the given `key_type` and `public` combination doesn't
+	/// exist in the keystore or an `Err` when something failed.
+	fn sr25519_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		data: &sr25519::vrf::VrfSignData,
+	) -> Result<Option<sr25519::vrf::VrfSignature>, Error>;
+
+	/// Generate an sr25519 VRF output for a given input data.
+	///
+	/// Receives [`KeyTypeId`] and an [`sr25519::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns `None` if the given `key_type` and `public` combination doesn't
+	/// exist in the keystore or an `Err` when something failed.
+	fn sr25519_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		input: &sr25519::vrf::VrfInput,
+	) -> Result<Option<sr25519::vrf::VrfOutput>, Error>;
+
+	/// Returns all ed25519 public keys for the given key type.
+	fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<ed25519::Public>;
+
+	/// Generate a new ed25519 key pair for the given key type and an optional seed.
+	///
+	/// Returns an `ed25519::Public` key of the generated key pair or an `Err` if
+	/// something failed during key generation.
+	fn ed25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<ed25519::Public, Error>;
+
+	/// Generate an ed25519 signature for a given message.
+	///
+	/// Receives [`KeyTypeId`] and an [`ed25519::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns an [`ed25519::Signature`] or `None` in case the given `key_type`
+	/// and `public` combination doesn't exist in the keystore.
+	/// An `Err` will be returned if generating the signature itself failed.
+	fn ed25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ed25519::Public,
+		msg: &[u8],
+	) -> Result<Option<ed25519::Signature>, Error>;
+
+	/// Returns all ecdsa public keys for the given key type.
+	fn ecdsa_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa::Public>;
+
+	/// Generate a new ecdsa key pair for the given key type and an optional seed.
+	///
+	/// Returns an `ecdsa::Public` key of the generated key pair or an `Err` if
+	/// something failed during key generation.
+	fn ecdsa_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<ecdsa::Public, Error>;
+
+	/// Generate an ecdsa signature for a given message.
+	///
+	/// Receives [`KeyTypeId`] and an [`ecdsa::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns an [`ecdsa::Signature`] or `None` in case the given `key_type`
+	/// and `public` combination doesn't exist in the keystore.
+	/// An `Err` will be returned if generating the signature itself failed.
+	fn ecdsa_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8],
+	) -> Result<Option<ecdsa::Signature>, Error>;
+
+	/// Generate an ecdsa signature for a given pre-hashed message.
+	///
+	/// Receives [`KeyTypeId`] and an [`ecdsa::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns an [`ecdsa::Signature`] or `None` in case the given `key_type`
+	/// and `public` combination doesn't exist in the keystore.
+	/// An `Err` will be returned if generating the signature itself failed.
+	fn ecdsa_sign_prehashed(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8; 32],
+	) -> Result<Option<ecdsa::Signature>, Error>;
+
+	/// Returns all the bandersnatch public keys for the given key type.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_public_keys(&self, key_type: KeyTypeId) -> Vec<bandersnatch::Public>;
+
+	/// Generate a new bandersnatch key pair for the given key type and an optional seed.
+	///
+	/// Returns an `bandersnatch::Public` key of the generated key pair or an `Err` if
+	/// something failed during key generation.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bandersnatch::Public, Error>;
+
+	/// Generate an bandersnatch signature for a given message.
+	///
+	/// Receives [`KeyTypeId`] and an [`bandersnatch::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns an [`bandersnatch::Signature`] or `None` in case the given `key_type`
+	/// and `public` combination doesn't exist in the keystore.
+	/// An `Err` will be returned if generating the signature itself failed.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		msg: &[u8],
+	) -> Result<Option<bandersnatch::Signature>, Error>;
+
+	/// Generate a bandersnatch VRF signature for the given data.
+	///
+	/// Receives [`KeyTypeId`] and an [`bandersnatch::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns `None` if the given `key_type` and `public` combination doesn't
+	/// exist in the keystore or an `Err` when something failed.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfSignData,
+	) -> Result<Option<bandersnatch::vrf::VrfSignature>, Error>;
+
+	/// Generate a bandersnatch VRF (pre)output for a given input data.
+	///
+	/// Receives [`KeyTypeId`] and an [`bandersnatch::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns `None` if the given `key_type` and `public` combination doesn't
+	/// exist in the keystore or an `Err` when something failed.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfInput,
+	) -> Result<Option<bandersnatch::vrf::VrfOutput>, Error>;
+
+	/// Generate a bandersnatch ring-VRF signature for the given data.
+	///
+	/// Receives [`KeyTypeId`] and an [`bandersnatch::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Also takes a [`bandersnatch::ring_vrf::RingProver`] instance obtained from
+	/// a valid [`bandersnatch::ring_vrf::RingContext`].
+	///
+	/// The ring signature is verifiable if the public key corresponding to the
+	/// signing [`bandersnatch::Pair`] is part of the ring from which the
+	/// [`bandersnatch::ring_vrf::RingProver`] has been constructed.
+	/// If not, the produced signature is just useless.
+	///
+	/// Returns `None` if the given `key_type` and `public` combination doesn't
+	/// exist in the keystore or an `Err` when something failed.
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_ring_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfSignData,
+		prover: &bandersnatch::ring_vrf::RingProver,
+	) -> Result<Option<bandersnatch::ring_vrf::RingVrfSignature>, Error>;
+
+	/// Returns all bls12-381 public keys for the given key type.
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_public_keys(&self, id: KeyTypeId) -> Vec<bls381::Public>;
+
+	/// Returns all bls12-377 public keys for the given key type.
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_public_keys(&self, id: KeyTypeId) -> Vec<bls377::Public>;
+
+	/// Generate a new bls381 key pair for the given key type and an optional seed.
+	///
+	/// Returns an `bls381::Public` key of the generated key pair or an `Err` if
+	/// something failed during key generation.
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bls381::Public, Error>;
+
+	/// Generate a new bls377 key pair for the given key type and an optional seed.
+	///
+	/// Returns an `bls377::Public` key of the generated key pair or an `Err` if
+	/// something failed during key generation.
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bls377::Public, Error>;
+
+	/// Generate a bls381 signature for a given message.
+	///
+	/// Receives [`KeyTypeId`] and a [`bls381::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns an [`bls381::Signature`] or `None` in case the given `key_type`
+	/// and `public` combination doesn't exist in the keystore.
+	/// An `Err` will be returned if generating the signature itself failed.
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls381::Public,
+		msg: &[u8],
+	) -> Result<Option<bls381::Signature>, Error>;
+
+	/// Generate a bls377 signature for a given message.
+	///
+	/// Receives [`KeyTypeId`] and a [`bls377::Public`] key to be able to map
+	/// them to a private key that exists in the keystore.
+	///
+	/// Returns an [`bls377::Signature`] or `None` in case the given `key_type`
+	/// and `public` combination doesn't exist in the keystore.
+	/// An `Err` will be returned if generating the signature itself failed.
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls377::Public,
+		msg: &[u8],
+	) -> Result<Option<bls377::Signature>, Error>;
+
+	/// Insert a new secret key.
+	fn insert(&self, key_type: KeyTypeId, suri: &str, public: &[u8]) -> Result<(), ()>;
+
+	/// List all supported keys of a given type.
+	///
+	/// Returns a set of public keys the signer supports in raw format.
+	fn keys(&self, key_type: KeyTypeId) -> Result<Vec<Vec<u8>>, Error>;
+
+	/// Checks if the private keys for the given public key and key type combinations exist.
+	///
+	/// Returns `true` iff all private keys could be found.
+	fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool;
+
+	/// Convenience method to sign a message using the given key type and a raw public key
+	/// for secret lookup.
+	///
+	/// The message is signed using the cryptographic primitive specified by `crypto_id`.
+	///
+	/// Schemes supported by the default trait implementation:
+	/// - sr25519
+	/// - ed25519
+	/// - ecdsa
+	/// - bandersnatch
+	/// - bls381
+	/// - bls377
+	///
+	/// To support more schemes you can overwrite this method.
+	///
+	/// Returns the SCALE encoded signature if key is found and supported, `None` if the key doesn't
+	/// exist or an error when something failed.
+	fn sign_with(
+		&self,
+		id: KeyTypeId,
+		crypto_id: CryptoTypeId,
+		public: &[u8],
+		msg: &[u8],
+	) -> Result<Option<Vec<u8>>, Error> {
+		use codec::Encode;
+
+		let signature = match crypto_id {
+			sr25519::CRYPTO_ID => {
+				let public = sr25519::Public::from_slice(public)
+					.map_err(|_| Error::ValidationError("Invalid public key format".into()))?;
+				self.sr25519_sign(id, &public, msg)?.map(|s| s.encode())
+			},
+			ed25519::CRYPTO_ID => {
+				let public = ed25519::Public::from_slice(public)
+					.map_err(|_| Error::ValidationError("Invalid public key format".into()))?;
+				self.ed25519_sign(id, &public, msg)?.map(|s| s.encode())
+			},
+			ecdsa::CRYPTO_ID => {
+				let public = ecdsa::Public::from_slice(public)
+					.map_err(|_| Error::ValidationError("Invalid public key format".into()))?;
+
+				self.ecdsa_sign(id, &public, msg)?.map(|s| s.encode())
+			},
+			#[cfg(feature = "bandersnatch-experimental")]
+			bandersnatch::CRYPTO_ID => {
+				let public = bandersnatch::Public::from_slice(public)
+					.map_err(|_| Error::ValidationError("Invalid public key format".into()))?;
+				self.bandersnatch_sign(id, &public, msg)?.map(|s| s.encode())
+			},
+			#[cfg(feature = "bls-experimental")]
+			bls381::CRYPTO_ID => {
+				let public = bls381::Public::from_slice(public)
+					.map_err(|_| Error::ValidationError("Invalid public key format".into()))?;
+				self.bls381_sign(id, &public, msg)?.map(|s| s.encode())
+			},
+			#[cfg(feature = "bls-experimental")]
+			bls377::CRYPTO_ID => {
+				let public = bls377::Public::from_slice(public)
+					.map_err(|_| Error::ValidationError("Invalid public key format".into()))?;
+				self.bls377_sign(id, &public, msg)?.map(|s| s.encode())
+			},
+			_ => return Err(Error::KeyNotSupported(id)),
+		};
+		Ok(signature)
+	}
+}
+
+impl<T: Keystore + ?Sized> Keystore for Arc<T> {
+	fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<sr25519::Public> {
+		(**self).sr25519_public_keys(key_type)
+	}
+
+	fn sr25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<sr25519::Public, Error> {
+		(**self).sr25519_generate_new(key_type, seed)
+	}
+
+	fn sr25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		msg: &[u8],
+	) -> Result<Option<sr25519::Signature>, Error> {
+		(**self).sr25519_sign(key_type, public, msg)
+	}
+
+	fn sr25519_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		data: &sr25519::vrf::VrfSignData,
+	) -> Result<Option<sr25519::vrf::VrfSignature>, Error> {
+		(**self).sr25519_vrf_sign(key_type, public, data)
+	}
+
+	fn sr25519_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		input: &sr25519::vrf::VrfInput,
+	) -> Result<Option<sr25519::vrf::VrfOutput>, Error> {
+		(**self).sr25519_vrf_output(key_type, public, input)
+	}
+
+	fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<ed25519::Public> {
+		(**self).ed25519_public_keys(key_type)
+	}
+
+	fn ed25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<ed25519::Public, Error> {
+		(**self).ed25519_generate_new(key_type, seed)
+	}
+
+	fn ed25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ed25519::Public,
+		msg: &[u8],
+	) -> Result<Option<ed25519::Signature>, Error> {
+		(**self).ed25519_sign(key_type, public, msg)
+	}
+
+	fn ecdsa_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa::Public> {
+		(**self).ecdsa_public_keys(key_type)
+	}
+
+	fn ecdsa_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<ecdsa::Public, Error> {
+		(**self).ecdsa_generate_new(key_type, seed)
+	}
+
+	fn ecdsa_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8],
+	) -> Result<Option<ecdsa::Signature>, Error> {
+		(**self).ecdsa_sign(key_type, public, msg)
+	}
+
+	fn ecdsa_sign_prehashed(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8; 32],
+	) -> Result<Option<ecdsa::Signature>, Error> {
+		(**self).ecdsa_sign_prehashed(key_type, public, msg)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_public_keys(&self, key_type: KeyTypeId) -> Vec<bandersnatch::Public> {
+		(**self).bandersnatch_public_keys(key_type)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bandersnatch::Public, Error> {
+		(**self).bandersnatch_generate_new(key_type, seed)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		msg: &[u8],
+	) -> Result<Option<bandersnatch::Signature>, Error> {
+		(**self).bandersnatch_sign(key_type, public, msg)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfSignData,
+	) -> Result<Option<bandersnatch::vrf::VrfSignature>, Error> {
+		(**self).bandersnatch_vrf_sign(key_type, public, input)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfInput,
+	) -> Result<Option<bandersnatch::vrf::VrfOutput>, Error> {
+		(**self).bandersnatch_vrf_output(key_type, public, input)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_ring_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfSignData,
+		prover: &bandersnatch::ring_vrf::RingProver,
+	) -> Result<Option<bandersnatch::ring_vrf::RingVrfSignature>, Error> {
+		(**self).bandersnatch_ring_vrf_sign(key_type, public, input, prover)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_public_keys(&self, id: KeyTypeId) -> Vec<bls381::Public> {
+		(**self).bls381_public_keys(id)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_public_keys(&self, id: KeyTypeId) -> Vec<bls377::Public> {
+		(**self).bls377_public_keys(id)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bls381::Public, Error> {
+		(**self).bls381_generate_new(key_type, seed)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bls377::Public, Error> {
+		(**self).bls377_generate_new(key_type, seed)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls381::Public,
+		msg: &[u8],
+	) -> Result<Option<bls381::Signature>, Error> {
+		(**self).bls381_sign(key_type, public, msg)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls377::Public,
+		msg: &[u8],
+	) -> Result<Option<bls377::Signature>, Error> {
+		(**self).bls377_sign(key_type, public, msg)
+	}
+
+	fn insert(&self, key_type: KeyTypeId, suri: &str, public: &[u8]) -> Result<(), ()> {
+		(**self).insert(key_type, suri, public)
+	}
+
+	fn keys(&self, key_type: KeyTypeId) -> Result<Vec<Vec<u8>>, Error> {
+		(**self).keys(key_type)
+	}
+
+	fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool {
+		(**self).has_keys(public_keys)
+	}
+}
+
+/// A shared pointer to a keystore implementation.
+pub type KeystorePtr = Arc<dyn Keystore>;
+
+sp_externalities::decl_extension! {
+	/// The keystore extension to register/retrieve from the externalities.
+	pub struct KeystoreExt(KeystorePtr);
+}
+
+impl KeystoreExt {
+	/// Create a new instance of `KeystoreExt`
+	///
+	/// This is more performant as we don't need to wrap keystore in another [`Arc`].
+	pub fn from(keystore: KeystorePtr) -> Self {
+		Self(keystore)
+	}
+
+	/// Create a new instance of `KeystoreExt` using the given `keystore`.
+	pub fn new<T: Keystore + 'static>(keystore: T) -> Self {
+		Self(Arc::new(keystore))
+	}
+}
diff --git a/substrate/primitives/keystore/src/testing.rs b/substrate/primitives/keystore/src/testing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..efa35fd24bf46bd77e235b207e442c717411d8d3
--- /dev/null
+++ b/substrate/primitives/keystore/src/testing.rs
@@ -0,0 +1,534 @@
+// 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.
+
+//! Types that should only be used for testing!
+
+use crate::{Error, Keystore, KeystorePtr};
+
+#[cfg(feature = "bandersnatch-experimental")]
+use sp_core::bandersnatch;
+#[cfg(feature = "bls-experimental")]
+use sp_core::{bls377, bls381};
+use sp_core::{
+	crypto::{ByteArray, KeyTypeId, Pair, VrfSecret},
+	ecdsa, ed25519, sr25519,
+};
+
+use parking_lot::RwLock;
+use std::{collections::HashMap, sync::Arc};
+
+/// A keystore implementation usable in tests.
+#[derive(Default)]
+pub struct MemoryKeystore {
+	/// `KeyTypeId` maps to public keys and public keys map to private keys.
+	keys: Arc<RwLock<HashMap<KeyTypeId, HashMap<Vec<u8>, String>>>>,
+}
+
+impl MemoryKeystore {
+	/// Creates a new instance of `Self`.
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	fn pair<T: Pair>(&self, key_type: KeyTypeId, public: &T::Public) -> Option<T> {
+		self.keys.read().get(&key_type).and_then(|inner| {
+			inner
+				.get(public.as_slice())
+				.map(|s| T::from_string(s, None).expect("seed slice is valid"))
+		})
+	}
+
+	fn public_keys<T: Pair>(&self, key_type: KeyTypeId) -> Vec<T::Public> {
+		self.keys
+			.read()
+			.get(&key_type)
+			.map(|keys| {
+				keys.values()
+					.map(|s| T::from_string(s, None).expect("seed slice is valid"))
+					.map(|p| p.public())
+					.collect()
+			})
+			.unwrap_or_default()
+	}
+
+	fn generate_new<T: Pair>(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<T::Public, Error> {
+		match seed {
+			Some(seed) => {
+				let pair = T::from_string(seed, None)
+					.map_err(|_| Error::ValidationError("Generates a pair.".to_owned()))?;
+				self.keys
+					.write()
+					.entry(key_type)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), seed.into());
+				Ok(pair.public())
+			},
+			None => {
+				let (pair, phrase, _) = T::generate_with_phrase(None);
+				self.keys
+					.write()
+					.entry(key_type)
+					.or_default()
+					.insert(pair.public().to_raw_vec(), phrase);
+				Ok(pair.public())
+			},
+		}
+	}
+
+	fn sign<T: Pair>(
+		&self,
+		key_type: KeyTypeId,
+		public: &T::Public,
+		msg: &[u8],
+	) -> Result<Option<T::Signature>, Error> {
+		let sig = self.pair::<T>(key_type, public).map(|pair| pair.sign(msg));
+		Ok(sig)
+	}
+
+	fn vrf_sign<T: Pair + VrfSecret>(
+		&self,
+		key_type: KeyTypeId,
+		public: &T::Public,
+		data: &T::VrfSignData,
+	) -> Result<Option<T::VrfSignature>, Error> {
+		let sig = self.pair::<T>(key_type, public).map(|pair| pair.vrf_sign(data));
+		Ok(sig)
+	}
+
+	fn vrf_output<T: Pair + VrfSecret>(
+		&self,
+		key_type: KeyTypeId,
+		public: &T::Public,
+		input: &T::VrfInput,
+	) -> Result<Option<T::VrfOutput>, Error> {
+		let preout = self.pair::<T>(key_type, public).map(|pair| pair.vrf_output(input));
+		Ok(preout)
+	}
+}
+
+impl Keystore for MemoryKeystore {
+	fn sr25519_public_keys(&self, key_type: KeyTypeId) -> Vec<sr25519::Public> {
+		self.public_keys::<sr25519::Pair>(key_type)
+	}
+
+	fn sr25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<sr25519::Public, Error> {
+		self.generate_new::<sr25519::Pair>(key_type, seed)
+	}
+
+	fn sr25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		msg: &[u8],
+	) -> Result<Option<sr25519::Signature>, Error> {
+		self.sign::<sr25519::Pair>(key_type, public, msg)
+	}
+
+	fn sr25519_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		data: &sr25519::vrf::VrfSignData,
+	) -> Result<Option<sr25519::vrf::VrfSignature>, Error> {
+		self.vrf_sign::<sr25519::Pair>(key_type, public, data)
+	}
+
+	fn sr25519_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &sr25519::Public,
+		input: &sr25519::vrf::VrfInput,
+	) -> Result<Option<sr25519::vrf::VrfOutput>, Error> {
+		self.vrf_output::<sr25519::Pair>(key_type, public, input)
+	}
+
+	fn ed25519_public_keys(&self, key_type: KeyTypeId) -> Vec<ed25519::Public> {
+		self.public_keys::<ed25519::Pair>(key_type)
+	}
+
+	fn ed25519_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<ed25519::Public, Error> {
+		self.generate_new::<ed25519::Pair>(key_type, seed)
+	}
+
+	fn ed25519_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ed25519::Public,
+		msg: &[u8],
+	) -> Result<Option<ed25519::Signature>, Error> {
+		self.sign::<ed25519::Pair>(key_type, public, msg)
+	}
+
+	fn ecdsa_public_keys(&self, key_type: KeyTypeId) -> Vec<ecdsa::Public> {
+		self.public_keys::<ecdsa::Pair>(key_type)
+	}
+
+	fn ecdsa_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<ecdsa::Public, Error> {
+		self.generate_new::<ecdsa::Pair>(key_type, seed)
+	}
+
+	fn ecdsa_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8],
+	) -> Result<Option<ecdsa::Signature>, Error> {
+		self.sign::<ecdsa::Pair>(key_type, public, msg)
+	}
+
+	fn ecdsa_sign_prehashed(
+		&self,
+		key_type: KeyTypeId,
+		public: &ecdsa::Public,
+		msg: &[u8; 32],
+	) -> Result<Option<ecdsa::Signature>, Error> {
+		let sig = self.pair::<ecdsa::Pair>(key_type, public).map(|pair| pair.sign_prehashed(msg));
+		Ok(sig)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_public_keys(&self, key_type: KeyTypeId) -> Vec<bandersnatch::Public> {
+		self.public_keys::<bandersnatch::Pair>(key_type)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bandersnatch::Public, Error> {
+		self.generate_new::<bandersnatch::Pair>(key_type, seed)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		msg: &[u8],
+	) -> Result<Option<bandersnatch::Signature>, Error> {
+		self.sign::<bandersnatch::Pair>(key_type, public, msg)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		data: &bandersnatch::vrf::VrfSignData,
+	) -> Result<Option<bandersnatch::vrf::VrfSignature>, Error> {
+		self.vrf_sign::<bandersnatch::Pair>(key_type, public, data)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_ring_vrf_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		data: &bandersnatch::vrf::VrfSignData,
+		prover: &bandersnatch::ring_vrf::RingProver,
+	) -> Result<Option<bandersnatch::ring_vrf::RingVrfSignature>, Error> {
+		let sig = self
+			.pair::<bandersnatch::Pair>(key_type, public)
+			.map(|pair| pair.ring_vrf_sign(data, prover));
+		Ok(sig)
+	}
+
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_output(
+		&self,
+		key_type: KeyTypeId,
+		public: &bandersnatch::Public,
+		input: &bandersnatch::vrf::VrfInput,
+	) -> Result<Option<bandersnatch::vrf::VrfOutput>, Error> {
+		self.vrf_output::<bandersnatch::Pair>(key_type, public, input)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_public_keys(&self, key_type: KeyTypeId) -> Vec<bls381::Public> {
+		self.public_keys::<bls381::Pair>(key_type)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bls381::Public, Error> {
+		self.generate_new::<bls381::Pair>(key_type, seed)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls381::Public,
+		msg: &[u8],
+	) -> Result<Option<bls381::Signature>, Error> {
+		self.sign::<bls381::Pair>(key_type, public, msg)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_public_keys(&self, key_type: KeyTypeId) -> Vec<bls377::Public> {
+		self.public_keys::<bls377::Pair>(key_type)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_generate_new(
+		&self,
+		key_type: KeyTypeId,
+		seed: Option<&str>,
+	) -> Result<bls377::Public, Error> {
+		self.generate_new::<bls377::Pair>(key_type, seed)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_sign(
+		&self,
+		key_type: KeyTypeId,
+		public: &bls377::Public,
+		msg: &[u8],
+	) -> Result<Option<bls377::Signature>, Error> {
+		self.sign::<bls377::Pair>(key_type, public, msg)
+	}
+
+	fn insert(&self, key_type: KeyTypeId, suri: &str, public: &[u8]) -> Result<(), ()> {
+		self.keys
+			.write()
+			.entry(key_type)
+			.or_default()
+			.insert(public.to_owned(), suri.to_string());
+		Ok(())
+	}
+
+	fn keys(&self, key_type: KeyTypeId) -> Result<Vec<Vec<u8>>, Error> {
+		let keys = self
+			.keys
+			.read()
+			.get(&key_type)
+			.map(|map| map.keys().cloned().collect())
+			.unwrap_or_default();
+		Ok(keys)
+	}
+
+	fn has_keys(&self, public_keys: &[(Vec<u8>, KeyTypeId)]) -> bool {
+		public_keys
+			.iter()
+			.all(|(k, t)| self.keys.read().get(t).and_then(|s| s.get(k)).is_some())
+	}
+}
+
+impl Into<KeystorePtr> for MemoryKeystore {
+	fn into(self) -> KeystorePtr {
+		Arc::new(self)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{
+		sr25519,
+		testing::{ECDSA, ED25519, SR25519},
+	};
+
+	#[test]
+	fn store_key_and_extract() {
+		let store = MemoryKeystore::new();
+
+		let public = store.ed25519_generate_new(ED25519, None).expect("Generates key");
+
+		let public_keys = store.ed25519_public_keys(ED25519);
+
+		assert!(public_keys.contains(&public.into()));
+	}
+
+	#[test]
+	fn store_unknown_and_extract_it() {
+		let store = MemoryKeystore::new();
+
+		let secret_uri = "//Alice";
+		let key_pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
+
+		store
+			.insert(SR25519, secret_uri, key_pair.public().as_ref())
+			.expect("Inserts unknown key");
+
+		let public_keys = store.sr25519_public_keys(SR25519);
+
+		assert!(public_keys.contains(&key_pair.public().into()));
+	}
+
+	#[test]
+	fn sr25519_vrf_sign() {
+		let store = MemoryKeystore::new();
+
+		let secret_uri = "//Alice";
+		let key_pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
+
+		let data = sr25519::vrf::VrfInput::new(
+			b"Test",
+			&[
+				(b"one", &1_u64.to_le_bytes()),
+				(b"two", &2_u64.to_le_bytes()),
+				(b"three", "test".as_bytes()),
+			],
+		)
+		.into_sign_data();
+
+		let result = store.sr25519_vrf_sign(SR25519, &key_pair.public(), &data);
+		assert!(result.unwrap().is_none());
+
+		store
+			.insert(SR25519, secret_uri, key_pair.public().as_ref())
+			.expect("Inserts unknown key");
+
+		let result = store.sr25519_vrf_sign(SR25519, &key_pair.public(), &data);
+
+		assert!(result.unwrap().is_some());
+	}
+
+	#[test]
+	fn sr25519_vrf_output() {
+		let store = MemoryKeystore::new();
+
+		let secret_uri = "//Alice";
+		let pair = sr25519::Pair::from_string(secret_uri, None).expect("Generates key pair");
+
+		let input = sr25519::vrf::VrfInput::new(
+			b"Test",
+			&[
+				(b"one", &1_u64.to_le_bytes()),
+				(b"two", &2_u64.to_le_bytes()),
+				(b"three", "test".as_bytes()),
+			],
+		);
+
+		let result = store.sr25519_vrf_output(SR25519, &pair.public(), &input);
+		assert!(result.unwrap().is_none());
+
+		store
+			.insert(SR25519, secret_uri, pair.public().as_ref())
+			.expect("Inserts unknown key");
+
+		let preout = store.sr25519_vrf_output(SR25519, &pair.public(), &input).unwrap().unwrap();
+
+		let result = preout.make_bytes::<32>(b"rand", &input, &pair.public());
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn ecdsa_sign_prehashed_works() {
+		let store = MemoryKeystore::new();
+
+		let suri = "//Alice";
+		let pair = ecdsa::Pair::from_string(suri, None).unwrap();
+
+		let msg = sp_core::keccak_256(b"this should be a hashed message");
+
+		// no key in key store
+		let res = store.ecdsa_sign_prehashed(ECDSA, &pair.public(), &msg).unwrap();
+		assert!(res.is_none());
+
+		// insert key, sign again
+		store.insert(ECDSA, suri, pair.public().as_ref()).unwrap();
+
+		let res = store.ecdsa_sign_prehashed(ECDSA, &pair.public(), &msg).unwrap();
+		assert!(res.is_some());
+	}
+
+	#[test]
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_vrf_sign() {
+		use sp_core::testing::BANDERSNATCH;
+
+		let store = MemoryKeystore::new();
+
+		let secret_uri = "//Alice";
+		let key_pair =
+			bandersnatch::Pair::from_string(secret_uri, None).expect("Generates key pair");
+
+		let in1 = bandersnatch::vrf::VrfInput::new("in", "foo");
+		let sign_data =
+			bandersnatch::vrf::VrfSignData::new_unchecked(b"Test", Some("m1"), Some(in1));
+
+		let result = store.bandersnatch_vrf_sign(BANDERSNATCH, &key_pair.public(), &sign_data);
+		assert!(result.unwrap().is_none());
+
+		store
+			.insert(BANDERSNATCH, secret_uri, key_pair.public().as_ref())
+			.expect("Inserts unknown key");
+
+		let result = store.bandersnatch_vrf_sign(BANDERSNATCH, &key_pair.public(), &sign_data);
+
+		assert!(result.unwrap().is_some());
+	}
+
+	#[test]
+	#[cfg(feature = "bandersnatch-experimental")]
+	fn bandersnatch_ring_vrf_sign() {
+		use sp_core::testing::BANDERSNATCH;
+
+		let store = MemoryKeystore::new();
+
+		let ring_ctx = bandersnatch::ring_vrf::RingContext::new_testing();
+
+		let mut pks: Vec<_> = (0..16)
+			.map(|i| bandersnatch::Pair::from_seed(&[i as u8; 32]).public())
+			.collect();
+
+		let prover_idx = 3;
+		let prover = ring_ctx.prover(&pks, prover_idx).unwrap();
+
+		let secret_uri = "//Alice";
+		let pair = bandersnatch::Pair::from_string(secret_uri, None).expect("Generates key pair");
+		pks[prover_idx] = pair.public();
+
+		let in1 = bandersnatch::vrf::VrfInput::new("in1", "foo");
+		let sign_data =
+			bandersnatch::vrf::VrfSignData::new_unchecked(b"Test", &["m1", "m2"], [in1]);
+
+		let result =
+			store.bandersnatch_ring_vrf_sign(BANDERSNATCH, &pair.public(), &sign_data, &prover);
+		assert!(result.unwrap().is_none());
+
+		store
+			.insert(BANDERSNATCH, secret_uri, pair.public().as_ref())
+			.expect("Inserts unknown key");
+
+		let result =
+			store.bandersnatch_ring_vrf_sign(BANDERSNATCH, &pair.public(), &sign_data, &prover);
+
+		assert!(result.unwrap().is_some());
+	}
+}
diff --git a/substrate/primitives/maybe-compressed-blob/Cargo.toml b/substrate/primitives/maybe-compressed-blob/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..67f93c517274c3772c242cd045e9560bb51f851f
--- /dev/null
+++ b/substrate/primitives/maybe-compressed-blob/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "sp-maybe-compressed-blob"
+version = "4.1.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Handling of blobs, usually Wasm code, which may be compresed"
+documentation = "https://docs.rs/sp-maybe-compressed-blob"
+readme = "README.md"
+
+[dependencies]
+thiserror = "1.0"
+zstd = { version = "0.12.3", default-features = false }
diff --git a/substrate/primitives/maybe-compressed-blob/README.md b/substrate/primitives/maybe-compressed-blob/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5bb869c30e4ffd46d15049763e52af6f65e7f05
--- /dev/null
+++ b/substrate/primitives/maybe-compressed-blob/README.md
@@ -0,0 +1,3 @@
+Handling of blobs, typicaly validation code, which may be compressed.
+
+License: Apache-2.0
diff --git a/substrate/primitives/maybe-compressed-blob/src/lib.rs b/substrate/primitives/maybe-compressed-blob/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..add620d4a1a1748340608ca9f0eba24006c8812b
--- /dev/null
+++ b/substrate/primitives/maybe-compressed-blob/src/lib.rs
@@ -0,0 +1,145 @@
+// 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.
+
+//! Handling of blobs that may be compressed, based on an 8-byte magic identifier
+//! at the head.
+
+use std::{
+	borrow::Cow,
+	io::{Read, Write},
+};
+
+// An arbitrary prefix, that indicates a blob beginning with should be decompressed with
+// Zstd compression.
+//
+// This differs from the WASM magic bytes, so real WASM blobs will not have this prefix.
+const ZSTD_PREFIX: [u8; 8] = [82, 188, 83, 118, 70, 219, 142, 5];
+
+/// A recommendation for the bomb limit for code blobs.
+///
+/// This may be adjusted upwards in the future, but is set much higher than the
+/// expected maximum code size. When adjusting upwards, nodes should be updated
+/// before performing a runtime upgrade to a blob with larger compressed size.
+pub const CODE_BLOB_BOMB_LIMIT: usize = 50 * 1024 * 1024;
+
+/// A possible bomb was encountered.
+#[derive(Debug, Clone, PartialEq, thiserror::Error)]
+pub enum Error {
+	/// Decoded size was too large, and the code payload may be a bomb.
+	#[error("Possible compression bomb encountered")]
+	PossibleBomb,
+	/// The compressed value had an invalid format.
+	#[error("Blob had invalid format")]
+	Invalid,
+}
+
+fn read_from_decoder(
+	decoder: impl Read,
+	blob_len: usize,
+	bomb_limit: usize,
+) -> Result<Vec<u8>, Error> {
+	let mut decoder = decoder.take((bomb_limit + 1) as u64);
+
+	let mut buf = Vec::with_capacity(blob_len);
+	decoder.read_to_end(&mut buf).map_err(|_| Error::Invalid)?;
+
+	if buf.len() <= bomb_limit {
+		Ok(buf)
+	} else {
+		Err(Error::PossibleBomb)
+	}
+}
+
+fn decompress_zstd(blob: &[u8], bomb_limit: usize) -> Result<Vec<u8>, Error> {
+	let decoder = zstd::Decoder::new(blob).map_err(|_| Error::Invalid)?;
+
+	read_from_decoder(decoder, blob.len(), bomb_limit)
+}
+
+/// Decode a blob, if it indicates that it is compressed. Provide a `bomb_limit`, which
+/// is the limit of bytes which should be decompressed from the blob.
+pub fn decompress(blob: &[u8], bomb_limit: usize) -> Result<Cow<[u8]>, Error> {
+	if blob.starts_with(&ZSTD_PREFIX) {
+		decompress_zstd(&blob[ZSTD_PREFIX.len()..], bomb_limit).map(Into::into)
+	} else {
+		Ok(blob.into())
+	}
+}
+
+/// Encode a blob as compressed. If the blob's size is over the bomb limit,
+/// this will not compress the blob, as the decoder will not be able to be
+/// able to differentiate it from a compression bomb.
+pub fn compress(blob: &[u8], bomb_limit: usize) -> Option<Vec<u8>> {
+	if blob.len() > bomb_limit {
+		return None
+	}
+
+	let mut buf = ZSTD_PREFIX.to_vec();
+
+	{
+		let mut v = zstd::Encoder::new(&mut buf, 3).ok()?.auto_finish();
+		v.write_all(blob).ok()?;
+	}
+
+	Some(buf)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	const BOMB_LIMIT: usize = 10;
+
+	#[test]
+	fn refuse_to_encode_over_limit() {
+		let mut v = vec![0; BOMB_LIMIT + 1];
+		assert!(compress(&v, BOMB_LIMIT).is_none());
+
+		let _ = v.pop();
+		assert!(compress(&v, BOMB_LIMIT).is_some());
+	}
+
+	#[test]
+	fn compress_and_decompress() {
+		let v = vec![0; BOMB_LIMIT];
+
+		let compressed = compress(&v, BOMB_LIMIT).unwrap();
+
+		assert!(compressed.starts_with(&ZSTD_PREFIX));
+		assert_eq!(&decompress(&compressed, BOMB_LIMIT).unwrap()[..], &v[..])
+	}
+
+	#[test]
+	fn decompresses_only_when_magic() {
+		let v = vec![0; BOMB_LIMIT + 1];
+
+		assert_eq!(&decompress(&v, BOMB_LIMIT).unwrap()[..], &v[..]);
+	}
+
+	#[test]
+	fn possible_bomb_fails() {
+		let encoded_bigger_than_bomb = vec![0; BOMB_LIMIT + 1];
+		let mut buf = ZSTD_PREFIX.to_vec();
+
+		{
+			let mut v = zstd::Encoder::new(&mut buf, 3).unwrap().auto_finish();
+			v.write_all(&encoded_bigger_than_bomb[..]).unwrap();
+		}
+
+		assert_eq!(decompress(&buf[..], BOMB_LIMIT).err(), Some(Error::PossibleBomb));
+	}
+}
diff --git a/substrate/primitives/merkle-mountain-range/Cargo.toml b/substrate/primitives/merkle-mountain-range/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..606774d12d5b3049cad2934a3924a63370aac9a7
--- /dev/null
+++ b/substrate/primitives/merkle-mountain-range/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "sp-mmr-primitives"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Merkle Mountain Range primitives."
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+log = { version = "0.4.17", default-features = false }
+mmr-lib = { package = "ckb-merkle-mountain-range", version = "0.5.2", default-features = false }
+serde = { version = "1.0.163", features = ["derive", "alloc"], default-features = false, optional = true }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-debug-derive = { version = "8.0.0", default-features = false, path = "../debug-derive" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+thiserror = "1.0"
+
+[dev-dependencies]
+array-bytes = "6.1"
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"log/std",
+	"mmr-lib/std",
+	"serde/std",
+	"sp-api/std",
+	"sp-core/std",
+	"sp-debug-derive/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+
+# Serde support without relying on std features.
+serde = [ "dep:serde", "scale-info/serde", "sp-core/serde", "sp-runtime/serde" ]
diff --git a/substrate/primitives/merkle-mountain-range/src/lib.rs b/substrate/primitives/merkle-mountain-range/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c0e75005ead8609a597735ef3ed19a85076dc89
--- /dev/null
+++ b/substrate/primitives/merkle-mountain-range/src/lib.rs
@@ -0,0 +1,642 @@
+// 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.
+
+//! Merkle Mountain Range primitive types.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![warn(missing_docs)]
+
+pub use mmr_lib;
+
+use scale_info::TypeInfo;
+use sp_debug_derive::RuntimeDebug;
+use sp_runtime::traits;
+use sp_std::fmt;
+#[cfg(not(feature = "std"))]
+use sp_std::prelude::Vec;
+
+pub mod utils;
+
+/// Prefix for elements stored in the Off-chain DB via Indexing API.
+pub const INDEXING_PREFIX: &'static [u8] = b"mmr";
+
+/// A type to describe node position in the MMR (node index).
+pub type NodeIndex = u64;
+
+/// A type to describe leaf position in the MMR.
+///
+/// Note this is different from [`NodeIndex`], which can be applied to
+/// both leafs and inner nodes. Leafs will always have consecutive `LeafIndex`,
+/// but might be actually at different positions in the MMR `NodeIndex`.
+pub type LeafIndex = u64;
+
+/// A provider of the MMR's leaf data.
+pub trait LeafDataProvider {
+	/// A type that should end up in the leaf of MMR.
+	type LeafData: FullLeaf + codec::Decode;
+
+	/// The method to return leaf data that should be placed
+	/// in the leaf node appended MMR at this block.
+	///
+	/// This is being called by the `on_initialize` method of
+	/// this pallet at the very beginning of each block.
+	fn leaf_data() -> Self::LeafData;
+}
+
+impl LeafDataProvider for () {
+	type LeafData = ();
+
+	fn leaf_data() -> Self::LeafData {
+		()
+	}
+}
+
+/// New MMR root notification hook.
+pub trait OnNewRoot<Hash> {
+	/// Function called by the pallet in case new MMR root has been computed.
+	fn on_new_root(root: &Hash);
+}
+
+/// No-op implementation of [OnNewRoot].
+impl<Hash> OnNewRoot<Hash> for () {
+	fn on_new_root(_root: &Hash) {}
+}
+
+/// A full leaf content stored in the offchain-db.
+pub trait FullLeaf: Clone + PartialEq + fmt::Debug {
+	/// Encode the leaf either in its full or compact form.
+	///
+	/// NOTE the encoding returned here MUST be `Decode`able into `FullLeaf`.
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F, compact: bool) -> R;
+}
+
+impl<T: codec::Encode + codec::Decode + Clone + PartialEq + fmt::Debug> FullLeaf for T {
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F, _compact: bool) -> R {
+		codec::Encode::using_encoded(self, f)
+	}
+}
+
+/// A helper type to allow using arbitrary SCALE-encoded leaf data in the RuntimeApi.
+///
+/// The point is to be able to verify MMR proofs from external MMRs, where we don't
+/// know the exact leaf type, but it's enough for us to have it SCALE-encoded.
+///
+/// Note the leaf type should be encoded in its compact form when passed through this type.
+/// See [FullLeaf] documentation for details.
+///
+/// This type does not implement SCALE encoding/decoding on purpose to avoid confusion,
+/// it would have to be SCALE-compatible with the concrete leaf type, but due to SCALE limitations
+/// it's not possible to know how many bytes the encoding of concrete leaf type uses.
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[derive(RuntimeDebug, Clone, PartialEq)]
+pub struct OpaqueLeaf(
+	/// Raw bytes of the leaf type encoded in its compact form.
+	///
+	/// NOTE it DOES NOT include length prefix (like `Vec<u8>` encoding would).
+	#[cfg_attr(feature = "serde", serde(with = "sp_core::bytes"))]
+	pub Vec<u8>,
+);
+
+impl OpaqueLeaf {
+	/// Convert a concrete MMR leaf into an opaque type.
+	pub fn from_leaf<T: FullLeaf>(leaf: &T) -> Self {
+		let encoded_leaf = leaf.using_encoded(|d| d.to_vec(), true);
+		OpaqueLeaf::from_encoded_leaf(encoded_leaf)
+	}
+
+	/// Create a `OpaqueLeaf` given raw bytes of compact-encoded leaf.
+	pub fn from_encoded_leaf(encoded_leaf: Vec<u8>) -> Self {
+		OpaqueLeaf(encoded_leaf)
+	}
+
+	/// Attempt to decode the leaf into expected concrete type.
+	pub fn try_decode<T: codec::Decode>(&self) -> Option<T> {
+		codec::Decode::decode(&mut &*self.0).ok()
+	}
+}
+
+impl FullLeaf for OpaqueLeaf {
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F, _compact: bool) -> R {
+		f(&self.0)
+	}
+}
+
+/// A type-safe wrapper for the concrete leaf type.
+///
+/// This structure serves merely to avoid passing raw `Vec<u8>` around.
+/// It must be `Vec<u8>`-encoding compatible.
+///
+/// It is different from [`OpaqueLeaf`], because it does implement `Codec`
+/// and the encoding has to match raw `Vec<u8>` encoding.
+#[derive(codec::Encode, codec::Decode, RuntimeDebug, PartialEq, Eq, TypeInfo)]
+pub struct EncodableOpaqueLeaf(pub Vec<u8>);
+
+impl EncodableOpaqueLeaf {
+	/// Convert a concrete leaf into encodable opaque version.
+	pub fn from_leaf<T: FullLeaf>(leaf: &T) -> Self {
+		let opaque = OpaqueLeaf::from_leaf(leaf);
+		Self::from_opaque_leaf(opaque)
+	}
+
+	/// Given an opaque leaf, make it encodable.
+	pub fn from_opaque_leaf(opaque: OpaqueLeaf) -> Self {
+		Self(opaque.0)
+	}
+
+	/// Try to convert into a [OpaqueLeaf].
+	pub fn into_opaque_leaf(self) -> OpaqueLeaf {
+		// wrap into `OpaqueLeaf` type
+		OpaqueLeaf::from_encoded_leaf(self.0)
+	}
+}
+
+/// An element representing either full data or its hash.
+///
+/// See [Compact] to see how it may be used in practice to reduce the size
+/// of proofs in case multiple [LeafDataProvider]s are composed together.
+/// This is also used internally by the MMR to differentiate leaf nodes (data)
+/// and inner nodes (hashes).
+///
+/// [DataOrHash::hash] method calculates the hash of this element in its compact form,
+/// so should be used instead of hashing the encoded form (which will always be non-compact).
+#[derive(RuntimeDebug, Clone, PartialEq)]
+pub enum DataOrHash<H: traits::Hash, L> {
+	/// Arbitrary data in its full form.
+	Data(L),
+	/// A hash of some data.
+	Hash(H::Output),
+}
+
+impl<H: traits::Hash, L> From<L> for DataOrHash<H, L> {
+	fn from(l: L) -> Self {
+		Self::Data(l)
+	}
+}
+
+mod encoding {
+	use super::*;
+
+	/// A helper type to implement [codec::Codec] for [DataOrHash].
+	#[derive(codec::Encode, codec::Decode)]
+	enum Either<A, B> {
+		Left(A),
+		Right(B),
+	}
+
+	impl<H: traits::Hash, L: FullLeaf> codec::Encode for DataOrHash<H, L> {
+		fn encode_to<T: codec::Output + ?Sized>(&self, dest: &mut T) {
+			match self {
+				Self::Data(l) => l.using_encoded(
+					|data| Either::<&[u8], &H::Output>::Left(data).encode_to(dest),
+					false,
+				),
+				Self::Hash(h) => Either::<&[u8], &H::Output>::Right(h).encode_to(dest),
+			}
+		}
+	}
+
+	impl<H: traits::Hash, L: FullLeaf + codec::Decode> codec::Decode for DataOrHash<H, L> {
+		fn decode<I: codec::Input>(value: &mut I) -> Result<Self, codec::Error> {
+			let decoded: Either<Vec<u8>, H::Output> = Either::decode(value)?;
+			Ok(match decoded {
+				Either::Left(l) => DataOrHash::Data(L::decode(&mut &*l)?),
+				Either::Right(r) => DataOrHash::Hash(r),
+			})
+		}
+	}
+}
+
+impl<H: traits::Hash, L: FullLeaf> DataOrHash<H, L> {
+	/// Retrieve a hash of this item.
+	///
+	/// Depending on the node type it's going to either be a contained value for [DataOrHash::Hash]
+	/// node, or a hash of SCALE-encoded [DataOrHash::Data] data.
+	pub fn hash(&self) -> H::Output {
+		match *self {
+			Self::Data(ref leaf) => leaf.using_encoded(<H as traits::Hash>::hash, true),
+			Self::Hash(ref hash) => *hash,
+		}
+	}
+}
+
+/// A composition of multiple leaf elements with compact form representation.
+///
+/// When composing together multiple [LeafDataProvider]s you will end up with
+/// a tuple of `LeafData` that each element provides.
+///
+/// However this will cause the leaves to have significant size, while for some
+/// use cases it will be enough to prove only one element of the tuple.
+/// That's the rationale for [Compact] struct. We wrap each element of the tuple
+/// into [DataOrHash] and each tuple element is hashed first before constructing
+/// the final hash of the entire tuple. This allows you to replace tuple elements
+/// you don't care about with their hashes.
+#[derive(RuntimeDebug, Clone, PartialEq)]
+pub struct Compact<H, T> {
+	/// Internal tuple representation.
+	pub tuple: T,
+	_hash: sp_std::marker::PhantomData<H>,
+}
+
+impl<H, T> sp_std::ops::Deref for Compact<H, T> {
+	type Target = T;
+
+	fn deref(&self) -> &Self::Target {
+		&self.tuple
+	}
+}
+
+impl<H, T> Compact<H, T> {
+	/// Create a new [Compact] wrapper for a tuple.
+	pub fn new(tuple: T) -> Self {
+		Self { tuple, _hash: Default::default() }
+	}
+}
+
+impl<H, T: codec::Decode> codec::Decode for Compact<H, T> {
+	fn decode<I: codec::Input>(value: &mut I) -> Result<Self, codec::Error> {
+		T::decode(value).map(Compact::new)
+	}
+}
+
+macro_rules! impl_leaf_data_for_tuple {
+	( $( $name:ident : $id:tt ),+ ) => {
+		/// [FullLeaf] implementation for `Compact<H, (DataOrHash<H, Tuple>, ...)>`
+		impl<H, $( $name ),+> FullLeaf for Compact<H, ( $( DataOrHash<H, $name>, )+ )> where
+			H: traits::Hash,
+			$( $name: FullLeaf ),+
+		{
+			fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F, compact: bool) -> R {
+				if compact {
+					codec::Encode::using_encoded(&(
+						$( DataOrHash::<H, $name>::Hash(self.tuple.$id.hash()), )+
+					), f)
+				} else {
+					codec::Encode::using_encoded(&self.tuple, f)
+				}
+			}
+		}
+
+		/// [LeafDataProvider] implementation for `Compact<H, (DataOrHash<H, Tuple>, ...)>`
+		///
+		/// This provides a compact-form encoding for tuples wrapped in [Compact].
+		impl<H, $( $name ),+> LeafDataProvider for Compact<H, ( $( $name, )+ )> where
+			H: traits::Hash,
+			$( $name: LeafDataProvider ),+
+		{
+			type LeafData = Compact<
+				H,
+				( $( DataOrHash<H, $name::LeafData>, )+ ),
+			>;
+
+			fn leaf_data() -> Self::LeafData {
+				let tuple = (
+					$( DataOrHash::Data($name::leaf_data()), )+
+				);
+				Compact::new(tuple)
+			}
+		}
+
+		/// [LeafDataProvider] implementation for `(Tuple, ...)`
+		///
+		/// This provides regular (non-compactable) composition of [LeafDataProvider]s.
+		impl<$( $name ),+> LeafDataProvider for ( $( $name, )+ ) where
+			( $( $name::LeafData, )+ ): FullLeaf,
+			$( $name: LeafDataProvider ),+
+		{
+			type LeafData = ( $( $name::LeafData, )+ );
+
+			fn leaf_data() -> Self::LeafData {
+				(
+					$( $name::leaf_data(), )+
+				)
+			}
+		}
+	}
+}
+
+/// Test functions implementation for `Compact<H, (DataOrHash<H, Tuple>, ...)>`
+#[cfg(test)]
+impl<H, A, B> Compact<H, (DataOrHash<H, A>, DataOrHash<H, B>)>
+where
+	H: traits::Hash,
+	A: FullLeaf,
+	B: FullLeaf,
+{
+	/// Retrieve a hash of this item in its compact form.
+	pub fn hash(&self) -> H::Output {
+		self.using_encoded(<H as traits::Hash>::hash, true)
+	}
+}
+
+impl_leaf_data_for_tuple!(A:0);
+impl_leaf_data_for_tuple!(A:0, B:1);
+impl_leaf_data_for_tuple!(A:0, B:1, C:2);
+impl_leaf_data_for_tuple!(A:0, B:1, C:2, D:3);
+impl_leaf_data_for_tuple!(A:0, B:1, C:2, D:3, E:4);
+
+/// An MMR proof data for a group of leaves.
+#[derive(codec::Encode, codec::Decode, RuntimeDebug, Clone, PartialEq, Eq, TypeInfo)]
+pub struct Proof<Hash> {
+	/// The indices of the leaves the proof is for.
+	pub leaf_indices: Vec<LeafIndex>,
+	/// Number of leaves in MMR, when the proof was generated.
+	pub leaf_count: NodeIndex,
+	/// Proof elements (hashes of siblings of inner nodes on the path to the leaf).
+	pub items: Vec<Hash>,
+}
+
+/// Merkle Mountain Range operation error.
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+#[derive(RuntimeDebug, codec::Encode, codec::Decode, PartialEq, Eq, TypeInfo)]
+pub enum Error {
+	/// Error during translation of a block number into a leaf index.
+	#[cfg_attr(feature = "std", error("Error performing numeric op"))]
+	InvalidNumericOp,
+	/// Error while pushing new node.
+	#[cfg_attr(feature = "std", error("Error pushing new node"))]
+	Push,
+	/// Error getting the new root.
+	#[cfg_attr(feature = "std", error("Error getting new root"))]
+	GetRoot,
+	/// Error committing changes.
+	#[cfg_attr(feature = "std", error("Error committing changes"))]
+	Commit,
+	/// Error during proof generation.
+	#[cfg_attr(feature = "std", error("Error generating proof"))]
+	GenerateProof,
+	/// Proof verification error.
+	#[cfg_attr(feature = "std", error("Invalid proof"))]
+	Verify,
+	/// Leaf not found in the storage.
+	#[cfg_attr(feature = "std", error("Leaf was not found"))]
+	LeafNotFound,
+	/// Mmr Pallet not included in runtime
+	#[cfg_attr(feature = "std", error("MMR pallet not included in runtime"))]
+	PalletNotIncluded,
+	/// Cannot find the requested leaf index
+	#[cfg_attr(feature = "std", error("Requested leaf index invalid"))]
+	InvalidLeafIndex,
+	/// The provided best know block number is invalid.
+	#[cfg_attr(feature = "std", error("Provided best known block number invalid"))]
+	InvalidBestKnownBlock,
+}
+
+impl Error {
+	#![allow(unused_variables)]
+	/// Consume given error `e` with `self` and generate a native log entry with error details.
+	pub fn log_error(self, e: impl fmt::Debug) -> Self {
+		log::error!(
+			target: "runtime::mmr",
+			"[{:?}] MMR error: {:?}",
+			self,
+			e,
+		);
+		self
+	}
+
+	/// Consume given error `e` with `self` and generate a native log entry with error details.
+	pub fn log_debug(self, e: impl fmt::Debug) -> Self {
+		log::debug!(
+			target: "runtime::mmr",
+			"[{:?}] MMR error: {:?}",
+			self,
+			e,
+		);
+		self
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// API to interact with MMR pallet.
+	#[api_version(2)]
+	pub trait MmrApi<Hash: codec::Codec, BlockNumber: codec::Codec> {
+		/// Return the on-chain MMR root hash.
+		fn mmr_root() -> Result<Hash, Error>;
+
+		/// Return the number of MMR blocks in the chain.
+		fn mmr_leaf_count() -> Result<LeafIndex, Error>;
+
+		/// Generate MMR proof for a series of block numbers. If `best_known_block_number = Some(n)`,
+		/// use historical MMR state at given block height `n`. Else, use current MMR state.
+		fn generate_proof(
+			block_numbers: Vec<BlockNumber>,
+			best_known_block_number: Option<BlockNumber>
+		) -> Result<(Vec<EncodableOpaqueLeaf>, Proof<Hash>), Error>;
+
+		/// Verify MMR proof against on-chain MMR for a batch of leaves.
+		///
+		/// Note this function will use on-chain MMR root hash and check if the proof matches the hash.
+		/// Note, the leaves should be sorted such that corresponding leaves and leaf indices have the
+		/// same position in both the `leaves` vector and the `leaf_indices` vector contained in the [Proof]
+		fn verify_proof(leaves: Vec<EncodableOpaqueLeaf>, proof: Proof<Hash>) -> Result<(), Error>;
+
+		/// Verify MMR proof against given root hash for a batch of leaves.
+		///
+		/// Note this function does not require any on-chain storage - the
+		/// proof is verified against given MMR root hash.
+		///
+		/// Note, the leaves should be sorted such that corresponding leaves and leaf indices have the
+		/// same position in both the `leaves` vector and the `leaf_indices` vector contained in the [Proof]
+		fn verify_proof_stateless(root: Hash, leaves: Vec<EncodableOpaqueLeaf>, proof: Proof<Hash>)
+			-> Result<(), Error>;
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use codec::Decode;
+	use sp_core::H256;
+	use sp_runtime::traits::Keccak256;
+
+	pub(crate) fn hex(s: &str) -> H256 {
+		s.parse().unwrap()
+	}
+
+	type Test = DataOrHash<Keccak256, String>;
+	type TestCompact = Compact<Keccak256, (Test, Test)>;
+	type TestProof = Proof<<Keccak256 as traits::Hash>::Output>;
+
+	#[test]
+	fn should_encode_decode_proof() {
+		// given
+		let proof: TestProof = Proof {
+			leaf_indices: vec![5],
+			leaf_count: 10,
+			items: vec![
+				hex("c3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd"),
+				hex("d3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd"),
+				hex("e3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd"),
+			],
+		};
+
+		// when
+		let encoded = codec::Encode::encode(&proof);
+		let decoded = TestProof::decode(&mut &*encoded);
+
+		// then
+		assert_eq!(decoded, Ok(proof));
+	}
+
+	#[test]
+	fn should_encode_decode_correctly_if_no_compact() {
+		// given
+		let cases = vec![
+			Test::Data("Hello World!".into()),
+			Test::Hash(hex("c3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd")),
+			Test::Data("".into()),
+			Test::Data("3e48d6bcd417fb22e044747242451e2c0f3e602d1bcad2767c34808621956417".into()),
+		];
+
+		// when
+		let encoded = cases.iter().map(codec::Encode::encode).collect::<Vec<_>>();
+
+		let decoded = encoded.iter().map(|x| Test::decode(&mut &**x)).collect::<Vec<_>>();
+
+		// then
+		assert_eq!(
+			decoded,
+			cases.into_iter().map(Result::<_, codec::Error>::Ok).collect::<Vec<_>>()
+		);
+		// check encoding correctness
+		assert_eq!(
+			&encoded[0],
+			&array_bytes::hex2bytes_unchecked("00343048656c6c6f20576f726c6421")
+		);
+		assert_eq!(
+			encoded[1].as_slice(),
+			array_bytes::hex2bytes_unchecked(
+				"01c3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd"
+			)
+			.as_slice()
+		);
+	}
+
+	#[test]
+	fn should_return_the_hash_correctly() {
+		// given
+		let a = Test::Data("Hello World!".into());
+		let b = Test::Hash(hex("c3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd"));
+
+		// when
+		let a = a.hash();
+		let b = b.hash();
+
+		// then
+		assert_eq!(a, hex("a9c321be8c24ba4dc2bd73f5300bde67dc57228ab8b68b607bb4c39c5374fac9"));
+		assert_eq!(b, hex("c3e7ba6b511162fead58f2c8b5764ce869ed1118011ac37392522ed16720bbcd"));
+	}
+
+	#[test]
+	fn compact_should_work() {
+		// given
+		let a = Test::Data("Hello World!".into());
+		let b = Test::Data("".into());
+
+		// when
+		let c: TestCompact = Compact::new((a.clone(), b.clone()));
+		let d: TestCompact = Compact::new((Test::Hash(a.hash()), Test::Hash(b.hash())));
+
+		// then
+		assert_eq!(c.hash(), d.hash());
+	}
+
+	#[test]
+	fn compact_should_encode_decode_correctly() {
+		// given
+		let a = Test::Data("Hello World!".into());
+		let b = Test::Data("".into());
+
+		let c: TestCompact = Compact::new((a.clone(), b.clone()));
+		let d: TestCompact = Compact::new((Test::Hash(a.hash()), Test::Hash(b.hash())));
+		let cases = vec![c, d.clone()];
+
+		// when
+		let encoded_compact =
+			cases.iter().map(|c| c.using_encoded(|x| x.to_vec(), true)).collect::<Vec<_>>();
+
+		let encoded =
+			cases.iter().map(|c| c.using_encoded(|x| x.to_vec(), false)).collect::<Vec<_>>();
+
+		let decoded_compact = encoded_compact
+			.iter()
+			.map(|x| TestCompact::decode(&mut &**x))
+			.collect::<Vec<_>>();
+
+		let decoded = encoded.iter().map(|x| TestCompact::decode(&mut &**x)).collect::<Vec<_>>();
+
+		// then
+		assert_eq!(
+			decoded,
+			cases.into_iter().map(Result::<_, codec::Error>::Ok).collect::<Vec<_>>()
+		);
+
+		assert_eq!(decoded_compact, vec![Ok(d.clone()), Ok(d.clone())]);
+	}
+
+	#[test]
+	fn opaque_leaves_should_be_full_leaf_compatible() {
+		// given
+		let a = Test::Data("Hello World!".into());
+		let b = Test::Data("".into());
+
+		let c: TestCompact = Compact::new((a.clone(), b.clone()));
+		let d: TestCompact = Compact::new((Test::Hash(a.hash()), Test::Hash(b.hash())));
+		let cases = vec![c, d.clone()];
+
+		let encoded_compact = cases
+			.iter()
+			.map(|c| c.using_encoded(|x| x.to_vec(), true))
+			.map(OpaqueLeaf::from_encoded_leaf)
+			.collect::<Vec<_>>();
+
+		let opaque = cases.iter().map(OpaqueLeaf::from_leaf).collect::<Vec<_>>();
+
+		// then
+		assert_eq!(encoded_compact, opaque);
+	}
+
+	#[test]
+	fn encode_opaque_leaf_should_be_scale_compatible() {
+		use codec::Encode;
+
+		// given
+		let a = Test::Data("Hello World!".into());
+		let case1 = EncodableOpaqueLeaf::from_leaf(&a);
+		let case2 = EncodableOpaqueLeaf::from_opaque_leaf(OpaqueLeaf(a.encode()));
+		let case3 = a.encode().encode();
+
+		// when
+		let encoded = vec![&case1, &case2].into_iter().map(|x| x.encode()).collect::<Vec<_>>();
+		let decoded = vec![&*encoded[0], &*encoded[1], &*case3]
+			.into_iter()
+			.map(|x| EncodableOpaqueLeaf::decode(&mut &*x))
+			.collect::<Vec<_>>();
+
+		// then
+		assert_eq!(case1, case2);
+		assert_eq!(encoded[0], encoded[1]);
+		// then encoding should also match double-encoded leaf.
+		assert_eq!(encoded[0], case3);
+
+		assert_eq!(decoded[0], decoded[1]);
+		assert_eq!(decoded[1], decoded[2]);
+		assert_eq!(decoded[0], Ok(case2));
+		assert_eq!(decoded[1], Ok(case1));
+	}
+}
diff --git a/substrate/primitives/merkle-mountain-range/src/utils.rs b/substrate/primitives/merkle-mountain-range/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b9171c96a6201eb99a63355841245a2a7853513b
--- /dev/null
+++ b/substrate/primitives/merkle-mountain-range/src/utils.rs
@@ -0,0 +1,215 @@
+// 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.
+
+//! Merkle Mountain Range utilities.
+
+use codec::Encode;
+use mmr_lib::helper;
+
+use sp_runtime::traits::{CheckedAdd, CheckedSub, Header, One};
+#[cfg(not(feature = "std"))]
+use sp_std::prelude::Vec;
+
+use crate::{Error, LeafIndex, NodeIndex};
+
+/// Get the first block with MMR.
+pub fn first_mmr_block_num<H: Header>(
+	best_block_num: H::Number,
+	mmr_leaf_count: LeafIndex,
+) -> Result<H::Number, Error> {
+	let mmr_blocks_count = mmr_leaf_count.try_into().map_err(|_| {
+		Error::InvalidNumericOp
+			.log_debug("The number of leaves couldn't be converted to a block number.")
+	})?;
+	best_block_num
+		.checked_sub(&mmr_blocks_count)
+		.and_then(|last_non_mmr_block| last_non_mmr_block.checked_add(&One::one()))
+		.ok_or_else(|| {
+			Error::InvalidNumericOp
+				.log_debug("The best block should be greater than the number of mmr blocks.")
+		})
+}
+
+/// Convert a block number into a leaf index.
+pub fn block_num_to_leaf_index<H: Header>(
+	block_num: H::Number,
+	first_mmr_block_num: H::Number,
+) -> Result<LeafIndex, Error> {
+	let leaf_idx = block_num.checked_sub(&first_mmr_block_num).ok_or_else(|| {
+		Error::InvalidNumericOp
+			.log_debug("The provided block should be greater than the first mmr block.")
+	})?;
+
+	leaf_idx.try_into().map_err(|_| {
+		Error::InvalidNumericOp.log_debug("Couldn't convert the leaf index to `LeafIndex`.")
+	})
+}
+
+/// MMR nodes & size -related utilities.
+pub struct NodesUtils {
+	no_of_leaves: LeafIndex,
+}
+
+impl NodesUtils {
+	/// Create new instance of MMR nodes utilities for given number of leaves.
+	pub fn new(no_of_leaves: LeafIndex) -> Self {
+		Self { no_of_leaves }
+	}
+
+	/// Calculate number of peaks in the MMR.
+	pub fn number_of_peaks(&self) -> NodeIndex {
+		self.number_of_leaves().count_ones() as NodeIndex
+	}
+
+	/// Return the number of leaves in the MMR.
+	pub fn number_of_leaves(&self) -> LeafIndex {
+		self.no_of_leaves
+	}
+
+	/// Calculate the total size of MMR (number of nodes).
+	pub fn size(&self) -> NodeIndex {
+		2 * self.no_of_leaves - self.number_of_peaks()
+	}
+
+	/// Calculate `LeafIndex` for the leaf that added `node_index` to the MMR.
+	pub fn leaf_index_that_added_node(node_index: NodeIndex) -> LeafIndex {
+		let rightmost_leaf_pos = Self::rightmost_leaf_node_index_from_pos(node_index);
+		Self::leaf_node_index_to_leaf_index(rightmost_leaf_pos)
+	}
+
+	// Translate a _leaf_ `NodeIndex` to its `LeafIndex`.
+	fn leaf_node_index_to_leaf_index(pos: NodeIndex) -> LeafIndex {
+		if pos == 0 {
+			return 0
+		}
+		let peaks = helper::get_peaks(pos);
+		(pos + peaks.len() as u64) >> 1
+	}
+
+	// Starting from any node position get position of rightmost leaf; this is the leaf
+	// responsible for the addition of node `pos`.
+	fn rightmost_leaf_node_index_from_pos(pos: NodeIndex) -> NodeIndex {
+		pos - (helper::pos_height_in_tree(pos) as u64)
+	}
+
+	/// Starting from any leaf index, get the sequence of positions of the nodes added
+	/// to the mmr when this leaf was added (inclusive of the leaf's position itself).
+	/// That is, all of these nodes are right children of their respective parents.
+	pub fn right_branch_ending_in_leaf(leaf_index: LeafIndex) -> Vec<NodeIndex> {
+		let pos = helper::leaf_index_to_pos(leaf_index);
+		let num_parents = leaf_index.trailing_ones() as u64;
+		return (pos..=pos + num_parents).collect()
+	}
+
+	/// Build offchain key from `parent_hash` of block that originally added node `pos` to MMR.
+	///
+	/// This combination makes the offchain (key,value) entry resilient to chain forks.
+	pub fn node_temp_offchain_key<H: Header>(
+		prefix: &[u8],
+		pos: NodeIndex,
+		parent_hash: H::Hash,
+	) -> Vec<u8> {
+		(prefix, pos, parent_hash).encode()
+	}
+
+	/// Build canonical offchain key for node `pos` in MMR.
+	///
+	/// Used for nodes added by now finalized blocks.
+	/// Never read keys using `node_canon_offchain_key` unless you sure that
+	/// there's no `node_offchain_key` key in the storage.
+	pub fn node_canon_offchain_key(prefix: &[u8], pos: NodeIndex) -> sp_std::prelude::Vec<u8> {
+		(prefix, pos).encode()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use mmr_lib::helper::leaf_index_to_pos;
+
+	#[test]
+	fn should_calculate_node_index_from_leaf_index() {
+		for index in 0..100000 {
+			let pos = leaf_index_to_pos(index);
+			assert_eq!(NodesUtils::leaf_node_index_to_leaf_index(pos), index);
+		}
+	}
+
+	#[test]
+	fn should_calculate_right_branch_correctly() {
+		fn left_jump_sequence(leaf_index: LeafIndex) -> Vec<u64> {
+			let pos = leaf_index_to_pos(leaf_index);
+			let mut right_branch_ending_in_leaf = vec![pos];
+			let mut next_pos = pos + 1;
+			while mmr_lib::helper::pos_height_in_tree(next_pos) > 0 {
+				right_branch_ending_in_leaf.push(next_pos);
+				next_pos += 1;
+			}
+			right_branch_ending_in_leaf
+		}
+
+		for leaf_index in 0..100000 {
+			let pos = mmr_lib::helper::leaf_index_to_pos(leaf_index);
+			assert_eq!(NodesUtils::right_branch_ending_in_leaf(pos), left_jump_sequence(pos));
+		}
+	}
+
+	#[test]
+	fn should_calculate_rightmost_leaf_node_index_from_pos() {
+		for pos in 0..100000 {
+			let leaf_pos = NodesUtils::rightmost_leaf_node_index_from_pos(pos);
+			let leaf_index = NodesUtils::leaf_node_index_to_leaf_index(leaf_pos);
+			assert!(NodesUtils::right_branch_ending_in_leaf(leaf_index).contains(&pos));
+		}
+	}
+
+	#[test]
+	fn should_calculate_depth_correctly() {
+		assert_eq!(
+			vec![0, 1, 2, 3, 4, 9, 15, 21]
+				.into_iter()
+				.map(|n| NodesUtils::new(n).number_of_leaves())
+				.collect::<Vec<_>>(),
+			vec![0, 1, 2, 3, 4, 9, 15, 21]
+		);
+	}
+
+	#[test]
+	fn should_calculate_number_of_peaks_correctly() {
+		assert_eq!(
+			vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 21]
+				.into_iter()
+				.map(|n| NodesUtils::new(n).number_of_peaks())
+				.collect::<Vec<_>>(),
+			vec![0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 3]
+		);
+	}
+
+	#[test]
+	fn should_calculate_the_size_correctly() {
+		let leaves = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 21];
+		let sizes = vec![0, 1, 3, 4, 7, 8, 10, 11, 15, 16, 18, 19, 22, 23, 25, 26, 39];
+		assert_eq!(
+			leaves
+				.clone()
+				.into_iter()
+				.map(|n| NodesUtils::new(n).size())
+				.collect::<Vec<_>>(),
+			sizes.clone()
+		);
+	}
+}
diff --git a/substrate/primitives/metadata-ir/Cargo.toml b/substrate/primitives/metadata-ir/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..c06aaa5c48b69e28867e16533d3410f2ce181777
--- /dev/null
+++ b/substrate/primitives/metadata-ir/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "sp-metadata-ir"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Intermediate representation of the runtime metadata."
+documentation = "https://docs.rs/sp-metadata-ir"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+frame-metadata = { version = "16.0.0", default-features = false, features = ["current"] }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "frame-metadata/std", "scale-info/std", "sp-std/std" ]
diff --git a/substrate/primitives/metadata-ir/src/lib.rs b/substrate/primitives/metadata-ir/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..edfa58f8618942e34b6937733cbd2a5f5c4dffbb
--- /dev/null
+++ b/substrate/primitives/metadata-ir/src/lib.rs
@@ -0,0 +1,118 @@
+// 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.
+
+//! Intermediate representation of the runtime metadata.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![warn(missing_docs)]
+
+// Re-export.
+#[doc(hidden)]
+pub use frame_metadata;
+
+mod types;
+use frame_metadata::RuntimeMetadataPrefixed;
+pub use types::*;
+
+mod v14;
+mod v15;
+
+/// Metadata V14.
+const V14: u32 = 14;
+
+/// Metadata V15.
+const V15: u32 = 15;
+
+/// Transform the IR to the specified version.
+///
+/// Use [`supported_versions`] to find supported versions.
+pub fn into_version(metadata: MetadataIR, version: u32) -> Option<RuntimeMetadataPrefixed> {
+	// Note: Unstable metadata version is `u32::MAX` until stabilized.
+	match version {
+		// Latest stable version.
+		V14 => Some(into_v14(metadata)),
+		// Unstable metadata.
+		V15 => Some(into_latest(metadata)),
+		_ => None,
+	}
+}
+
+/// Returns the supported metadata versions.
+pub fn supported_versions() -> sp_std::vec::Vec<u32> {
+	sp_std::vec![V14, V15]
+}
+
+/// Transform the IR to the latest stable metadata version.
+pub fn into_latest(metadata: MetadataIR) -> RuntimeMetadataPrefixed {
+	let latest: frame_metadata::v15::RuntimeMetadataV15 = metadata.into();
+	latest.into()
+}
+
+/// Transform the IR to metadata version 14.
+pub fn into_v14(metadata: MetadataIR) -> RuntimeMetadataPrefixed {
+	let latest: frame_metadata::v14::RuntimeMetadataV14 = metadata.into();
+	latest.into()
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use frame_metadata::{v14::META_RESERVED, RuntimeMetadata};
+	use scale_info::meta_type;
+
+	fn ir_metadata() -> MetadataIR {
+		MetadataIR {
+			pallets: vec![],
+			extrinsic: ExtrinsicMetadataIR {
+				ty: meta_type::<()>(),
+				version: 0,
+				address_ty: meta_type::<()>(),
+				call_ty: meta_type::<()>(),
+				signature_ty: meta_type::<()>(),
+				extra_ty: meta_type::<()>(),
+				signed_extensions: vec![],
+			},
+			ty: meta_type::<()>(),
+			apis: vec![],
+			outer_enums: OuterEnumsIR {
+				call_enum_ty: meta_type::<()>(),
+				event_enum_ty: meta_type::<()>(),
+				error_enum_ty: meta_type::<()>(),
+			},
+		}
+	}
+
+	#[test]
+	fn into_version_14() {
+		let ir = ir_metadata();
+		let metadata = into_version(ir, V14).expect("Should return prefixed metadata");
+
+		assert_eq!(metadata.0, META_RESERVED);
+
+		assert!(matches!(metadata.1, RuntimeMetadata::V14(_)));
+	}
+
+	#[test]
+	fn into_version_15() {
+		let ir = ir_metadata();
+		let metadata = into_version(ir, V15).expect("Should return prefixed metadata");
+
+		assert_eq!(metadata.0, META_RESERVED);
+
+		assert!(matches!(metadata.1, RuntimeMetadata::V15(_)));
+	}
+}
diff --git a/substrate/primitives/metadata-ir/src/types.rs b/substrate/primitives/metadata-ir/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b107d20a8e2bfbf55d0d558bb60346cb7a52dd70
--- /dev/null
+++ b/substrate/primitives/metadata-ir/src/types.rs
@@ -0,0 +1,453 @@
+// 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 codec::Encode;
+use scale_info::{
+	form::{Form, MetaForm, PortableForm},
+	prelude::vec::Vec,
+	IntoPortable, MetaType, Registry,
+};
+
+/// The intermediate representation for the runtime metadata.
+/// Contains the needed context that allows conversion to multiple metadata versions.
+///
+/// # Note
+///
+/// Further fields could be added or removed to ensure proper conversion.
+/// When the IR does not contain enough information to generate a specific version
+/// of the runtime metadata an appropriate default value is used (ie, empty vector).
+pub struct MetadataIR<T: Form = MetaForm> {
+	/// Pallet metadata.
+	pub pallets: Vec<PalletMetadataIR<T>>,
+	/// Metadata of the extrinsic.
+	pub extrinsic: ExtrinsicMetadataIR<T>,
+	/// The type of the `Runtime`.
+	pub ty: T::Type,
+	/// Metadata of the Runtime API.
+	pub apis: Vec<RuntimeApiMetadataIR<T>>,
+	/// The outer enums types as found in the runtime.
+	pub outer_enums: OuterEnumsIR<T>,
+}
+
+/// Metadata of a runtime trait.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct RuntimeApiMetadataIR<T: Form = MetaForm> {
+	/// Trait name.
+	pub name: T::String,
+	/// Trait methods.
+	pub methods: Vec<RuntimeApiMethodMetadataIR<T>>,
+	/// Trait documentation.
+	pub docs: Vec<T::String>,
+}
+
+impl IntoPortable for RuntimeApiMetadataIR {
+	type Output = RuntimeApiMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		RuntimeApiMetadataIR {
+			name: self.name.into_portable(registry),
+			methods: registry.map_into_portable(self.methods),
+			docs: registry.map_into_portable(self.docs),
+		}
+	}
+}
+
+/// Metadata of a runtime method.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct RuntimeApiMethodMetadataIR<T: Form = MetaForm> {
+	/// Method name.
+	pub name: T::String,
+	/// Method parameters.
+	pub inputs: Vec<RuntimeApiMethodParamMetadataIR<T>>,
+	/// Method output.
+	pub output: T::Type,
+	/// Method documentation.
+	pub docs: Vec<T::String>,
+}
+
+impl IntoPortable for RuntimeApiMethodMetadataIR {
+	type Output = RuntimeApiMethodMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		RuntimeApiMethodMetadataIR {
+			name: self.name.into_portable(registry),
+			inputs: registry.map_into_portable(self.inputs),
+			output: registry.register_type(&self.output),
+			docs: registry.map_into_portable(self.docs),
+		}
+	}
+}
+
+/// Metadata of a runtime method parameter.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct RuntimeApiMethodParamMetadataIR<T: Form = MetaForm> {
+	/// Parameter name.
+	pub name: T::String,
+	/// Parameter type.
+	pub ty: T::Type,
+}
+
+impl IntoPortable for RuntimeApiMethodParamMetadataIR {
+	type Output = RuntimeApiMethodParamMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		RuntimeApiMethodParamMetadataIR {
+			name: self.name.into_portable(registry),
+			ty: registry.register_type(&self.ty),
+		}
+	}
+}
+
+/// The intermediate representation for a pallet metadata.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct PalletMetadataIR<T: Form = MetaForm> {
+	/// Pallet name.
+	pub name: T::String,
+	/// Pallet storage metadata.
+	pub storage: Option<PalletStorageMetadataIR<T>>,
+	/// Pallet calls metadata.
+	pub calls: Option<PalletCallMetadataIR<T>>,
+	/// Pallet event metadata.
+	pub event: Option<PalletEventMetadataIR<T>>,
+	/// Pallet constants metadata.
+	pub constants: Vec<PalletConstantMetadataIR<T>>,
+	/// Pallet error metadata.
+	pub error: Option<PalletErrorMetadataIR<T>>,
+	/// Define the index of the pallet, this index will be used for the encoding of pallet event,
+	/// call and origin variants.
+	pub index: u8,
+	/// Pallet documentation.
+	pub docs: Vec<T::String>,
+}
+
+impl IntoPortable for PalletMetadataIR {
+	type Output = PalletMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		PalletMetadataIR {
+			name: self.name.into_portable(registry),
+			storage: self.storage.map(|storage| storage.into_portable(registry)),
+			calls: self.calls.map(|calls| calls.into_portable(registry)),
+			event: self.event.map(|event| event.into_portable(registry)),
+			constants: registry.map_into_portable(self.constants),
+			error: self.error.map(|error| error.into_portable(registry)),
+			index: self.index,
+			docs: registry.map_into_portable(self.docs),
+		}
+	}
+}
+
+/// Metadata of the extrinsic used by the runtime.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct ExtrinsicMetadataIR<T: Form = MetaForm> {
+	/// The type of the extrinsic.
+	///
+	/// Note: Field used for metadata V14 only.
+	pub ty: T::Type,
+	/// Extrinsic version.
+	pub version: u8,
+	/// The type of the address that signes the extrinsic
+	pub address_ty: T::Type,
+	/// The type of the outermost Call enum.
+	pub call_ty: T::Type,
+	/// The type of the extrinsic's signature.
+	pub signature_ty: T::Type,
+	/// The type of the outermost Extra enum.
+	pub extra_ty: T::Type,
+	/// The signed extensions in the order they appear in the extrinsic.
+	pub signed_extensions: Vec<SignedExtensionMetadataIR<T>>,
+}
+
+impl IntoPortable for ExtrinsicMetadataIR {
+	type Output = ExtrinsicMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		ExtrinsicMetadataIR {
+			ty: registry.register_type(&self.ty),
+			version: self.version,
+			address_ty: registry.register_type(&self.address_ty),
+			call_ty: registry.register_type(&self.call_ty),
+			signature_ty: registry.register_type(&self.signature_ty),
+			extra_ty: registry.register_type(&self.extra_ty),
+			signed_extensions: registry.map_into_portable(self.signed_extensions),
+		}
+	}
+}
+
+/// Metadata of an extrinsic's signed extension.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct SignedExtensionMetadataIR<T: Form = MetaForm> {
+	/// The unique signed extension identifier, which may be different from the type name.
+	pub identifier: T::String,
+	/// The type of the signed extension, with the data to be included in the extrinsic.
+	pub ty: T::Type,
+	/// The type of the additional signed data, with the data to be included in the signed payload
+	pub additional_signed: T::Type,
+}
+
+impl IntoPortable for SignedExtensionMetadataIR {
+	type Output = SignedExtensionMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		SignedExtensionMetadataIR {
+			identifier: self.identifier.into_portable(registry),
+			ty: registry.register_type(&self.ty),
+			additional_signed: registry.register_type(&self.additional_signed),
+		}
+	}
+}
+
+/// All metadata of the pallet's storage.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+/// The common prefix used by all storage entries.
+pub struct PalletStorageMetadataIR<T: Form = MetaForm> {
+	/// The common prefix used by all storage entries.
+	pub prefix: T::String,
+	/// Metadata for all storage entries.
+	pub entries: Vec<StorageEntryMetadataIR<T>>,
+}
+
+impl IntoPortable for PalletStorageMetadataIR {
+	type Output = PalletStorageMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		PalletStorageMetadataIR {
+			prefix: self.prefix.into_portable(registry),
+			entries: registry.map_into_portable(self.entries),
+		}
+	}
+}
+
+/// Metadata about one storage entry.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct StorageEntryMetadataIR<T: Form = MetaForm> {
+	/// Variable name of the storage entry.
+	pub name: T::String,
+	/// An `Option` modifier of that storage entry.
+	pub modifier: StorageEntryModifierIR,
+	/// Type of the value stored in the entry.
+	pub ty: StorageEntryTypeIR<T>,
+	/// Default value (SCALE encoded).
+	pub default: Vec<u8>,
+	/// Storage entry documentation.
+	pub docs: Vec<T::String>,
+}
+
+impl IntoPortable for StorageEntryMetadataIR {
+	type Output = StorageEntryMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		StorageEntryMetadataIR {
+			name: self.name.into_portable(registry),
+			modifier: self.modifier,
+			ty: self.ty.into_portable(registry),
+			default: self.default,
+			docs: registry.map_into_portable(self.docs),
+		}
+	}
+}
+
+/// A storage entry modifier indicates how a storage entry is returned when fetched and what the
+/// value will be if the key is not present. Specifically this refers to the "return type" when
+/// fetching a storage entry, and what the value will be if the key is not present.
+///
+/// `Optional` means you should expect an `Option<T>`, with `None` returned if the key is not
+/// present. `Default` means you should expect a `T` with the default value of default if the key is
+/// not present.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub enum StorageEntryModifierIR {
+	/// The storage entry returns an `Option<T>`, with `None` if the key is not present.
+	Optional,
+	/// The storage entry returns `T::Default` if the key is not present.
+	Default,
+}
+
+/// Hasher used by storage maps
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub enum StorageHasherIR {
+	/// 128-bit Blake2 hash.
+	Blake2_128,
+	/// 256-bit Blake2 hash.
+	Blake2_256,
+	/// Multiple 128-bit Blake2 hashes concatenated.
+	Blake2_128Concat,
+	/// 128-bit XX hash.
+	Twox128,
+	/// 256-bit XX hash.
+	Twox256,
+	/// Multiple 64-bit XX hashes concatenated.
+	Twox64Concat,
+	/// Identity hashing (no hashing).
+	Identity,
+}
+
+/// A type of storage value.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub enum StorageEntryTypeIR<T: Form = MetaForm> {
+	/// Plain storage entry (just the value).
+	Plain(T::Type),
+	/// A storage map.
+	Map {
+		/// One or more hashers, should be one hasher per key element.
+		hashers: Vec<StorageHasherIR>,
+		/// The type of the key, can be a tuple with elements for each of the hashers.
+		key: T::Type,
+		/// The type of the value.
+		value: T::Type,
+	},
+}
+
+impl IntoPortable for StorageEntryTypeIR {
+	type Output = StorageEntryTypeIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		match self {
+			Self::Plain(plain) => StorageEntryTypeIR::Plain(registry.register_type(&plain)),
+			Self::Map { hashers, key, value } => StorageEntryTypeIR::Map {
+				hashers,
+				key: registry.register_type(&key),
+				value: registry.register_type(&value),
+			},
+		}
+	}
+}
+
+/// Metadata for all calls in a pallet
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct PalletCallMetadataIR<T: Form = MetaForm> {
+	/// The corresponding enum type for the pallet call.
+	pub ty: T::Type,
+}
+
+impl IntoPortable for PalletCallMetadataIR {
+	type Output = PalletCallMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		PalletCallMetadataIR { ty: registry.register_type(&self.ty) }
+	}
+}
+
+impl From<MetaType> for PalletCallMetadataIR {
+	fn from(ty: MetaType) -> Self {
+		Self { ty }
+	}
+}
+
+/// Metadata about the pallet Event type.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct PalletEventMetadataIR<T: Form = MetaForm> {
+	/// The Event type.
+	pub ty: T::Type,
+}
+
+impl IntoPortable for PalletEventMetadataIR {
+	type Output = PalletEventMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		PalletEventMetadataIR { ty: registry.register_type(&self.ty) }
+	}
+}
+
+impl From<MetaType> for PalletEventMetadataIR {
+	fn from(ty: MetaType) -> Self {
+		Self { ty }
+	}
+}
+
+/// Metadata about one pallet constant.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct PalletConstantMetadataIR<T: Form = MetaForm> {
+	/// Name of the pallet constant.
+	pub name: T::String,
+	/// Type of the pallet constant.
+	pub ty: T::Type,
+	/// Value stored in the constant (SCALE encoded).
+	pub value: Vec<u8>,
+	/// Documentation of the constant.
+	pub docs: Vec<T::String>,
+}
+
+impl IntoPortable for PalletConstantMetadataIR {
+	type Output = PalletConstantMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		PalletConstantMetadataIR {
+			name: self.name.into_portable(registry),
+			ty: registry.register_type(&self.ty),
+			value: self.value,
+			docs: registry.map_into_portable(self.docs),
+		}
+	}
+}
+
+/// Metadata about a pallet error.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct PalletErrorMetadataIR<T: Form = MetaForm> {
+	/// The error type information.
+	pub ty: T::Type,
+}
+
+impl IntoPortable for PalletErrorMetadataIR {
+	type Output = PalletErrorMetadataIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		PalletErrorMetadataIR { ty: registry.register_type(&self.ty) }
+	}
+}
+
+impl From<MetaType> for PalletErrorMetadataIR {
+	fn from(ty: MetaType) -> Self {
+		Self { ty }
+	}
+}
+
+/// The type of the outer enums.
+#[derive(Clone, PartialEq, Eq, Encode, Debug)]
+pub struct OuterEnumsIR<T: Form = MetaForm> {
+	/// The type of the outer `RuntimeCall` enum.
+	pub call_enum_ty: T::Type,
+	/// The type of the outer `RuntimeEvent` enum.
+	pub event_enum_ty: T::Type,
+	/// The module error type of the
+	/// [`DispatchError::Module`](https://docs.rs/sp-runtime/24.0.0/sp_runtime/enum.DispatchError.html#variant.Module) variant.
+	///
+	/// The `Module` variant will be 5 scale encoded bytes which are normally decoded into
+	/// an `{ index: u8, error: [u8; 4] }` struct. This type ID points to an enum type which
+	/// instead interprets the first `index` byte as a pallet variant, and the remaining `error`
+	/// bytes as the appropriate `pallet::Error` type. It is an equally valid way to decode the
+	/// error bytes, and can be more informative.
+	///
+	/// # Note
+	///
+	/// - This type cannot be used directly to decode `sp_runtime::DispatchError` from the chain.
+	///   It provides just the information needed to decode `sp_runtime::DispatchError::Module`.
+	/// - Decoding the 5 error bytes into this type will not always lead to all of the bytes being
+	///   consumed; many error types do not require all of the bytes to represent them fully.
+	pub error_enum_ty: T::Type,
+}
+
+impl IntoPortable for OuterEnumsIR {
+	type Output = OuterEnumsIR<PortableForm>;
+
+	fn into_portable(self, registry: &mut Registry) -> Self::Output {
+		OuterEnumsIR {
+			call_enum_ty: registry.register_type(&self.call_enum_ty),
+			event_enum_ty: registry.register_type(&self.event_enum_ty),
+			error_enum_ty: registry.register_type(&self.error_enum_ty),
+		}
+	}
+}
diff --git a/substrate/primitives/metadata-ir/src/v14.rs b/substrate/primitives/metadata-ir/src/v14.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e1b7a24f76577c09f7f8c8040ae06bf433f9126d
--- /dev/null
+++ b/substrate/primitives/metadata-ir/src/v14.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.
+
+//! Convert the IR to V14 metadata.
+
+use super::types::{
+	ExtrinsicMetadataIR, MetadataIR, PalletCallMetadataIR, PalletConstantMetadataIR,
+	PalletErrorMetadataIR, PalletEventMetadataIR, PalletMetadataIR, PalletStorageMetadataIR,
+	SignedExtensionMetadataIR, StorageEntryMetadataIR, StorageEntryModifierIR, StorageEntryTypeIR,
+	StorageHasherIR,
+};
+
+use frame_metadata::v14::{
+	ExtrinsicMetadata, PalletCallMetadata, PalletConstantMetadata, PalletErrorMetadata,
+	PalletEventMetadata, PalletMetadata, PalletStorageMetadata, RuntimeMetadataV14,
+	SignedExtensionMetadata, StorageEntryMetadata, StorageEntryModifier, StorageEntryType,
+	StorageHasher,
+};
+
+impl From<MetadataIR> for RuntimeMetadataV14 {
+	fn from(ir: MetadataIR) -> Self {
+		RuntimeMetadataV14::new(
+			ir.pallets.into_iter().map(Into::into).collect(),
+			ir.extrinsic.into(),
+			ir.ty,
+		)
+	}
+}
+
+impl From<PalletMetadataIR> for PalletMetadata {
+	fn from(ir: PalletMetadataIR) -> Self {
+		PalletMetadata {
+			name: ir.name,
+			storage: ir.storage.map(Into::into),
+			calls: ir.calls.map(Into::into),
+			event: ir.event.map(Into::into),
+			constants: ir.constants.into_iter().map(Into::into).collect(),
+			error: ir.error.map(Into::into),
+			index: ir.index,
+			// Note: ir.docs not part of v14.
+		}
+	}
+}
+
+impl From<StorageEntryModifierIR> for StorageEntryModifier {
+	fn from(ir: StorageEntryModifierIR) -> Self {
+		match ir {
+			StorageEntryModifierIR::Optional => StorageEntryModifier::Optional,
+			StorageEntryModifierIR::Default => StorageEntryModifier::Default,
+		}
+	}
+}
+
+impl From<StorageHasherIR> for StorageHasher {
+	fn from(ir: StorageHasherIR) -> Self {
+		match ir {
+			StorageHasherIR::Blake2_128 => StorageHasher::Blake2_128,
+			StorageHasherIR::Blake2_256 => StorageHasher::Blake2_256,
+			StorageHasherIR::Blake2_128Concat => StorageHasher::Blake2_128Concat,
+			StorageHasherIR::Twox128 => StorageHasher::Twox128,
+			StorageHasherIR::Twox256 => StorageHasher::Twox256,
+			StorageHasherIR::Twox64Concat => StorageHasher::Twox64Concat,
+			StorageHasherIR::Identity => StorageHasher::Identity,
+		}
+	}
+}
+
+impl From<StorageEntryTypeIR> for StorageEntryType {
+	fn from(ir: StorageEntryTypeIR) -> Self {
+		match ir {
+			StorageEntryTypeIR::Plain(ty) => StorageEntryType::Plain(ty),
+			StorageEntryTypeIR::Map { hashers, key, value } => StorageEntryType::Map {
+				hashers: hashers.into_iter().map(Into::into).collect(),
+				key,
+				value,
+			},
+		}
+	}
+}
+
+impl From<StorageEntryMetadataIR> for StorageEntryMetadata {
+	fn from(ir: StorageEntryMetadataIR) -> Self {
+		StorageEntryMetadata {
+			name: ir.name,
+			modifier: ir.modifier.into(),
+			ty: ir.ty.into(),
+			default: ir.default,
+			docs: ir.docs,
+		}
+	}
+}
+
+impl From<PalletStorageMetadataIR> for PalletStorageMetadata {
+	fn from(ir: PalletStorageMetadataIR) -> Self {
+		PalletStorageMetadata {
+			prefix: ir.prefix,
+			entries: ir.entries.into_iter().map(Into::into).collect(),
+		}
+	}
+}
+
+impl From<PalletCallMetadataIR> for PalletCallMetadata {
+	fn from(ir: PalletCallMetadataIR) -> Self {
+		PalletCallMetadata { ty: ir.ty }
+	}
+}
+
+impl From<PalletEventMetadataIR> for PalletEventMetadata {
+	fn from(ir: PalletEventMetadataIR) -> Self {
+		PalletEventMetadata { ty: ir.ty }
+	}
+}
+
+impl From<PalletConstantMetadataIR> for PalletConstantMetadata {
+	fn from(ir: PalletConstantMetadataIR) -> Self {
+		PalletConstantMetadata { name: ir.name, ty: ir.ty, value: ir.value, docs: ir.docs }
+	}
+}
+
+impl From<PalletErrorMetadataIR> for PalletErrorMetadata {
+	fn from(ir: PalletErrorMetadataIR) -> Self {
+		PalletErrorMetadata { ty: ir.ty }
+	}
+}
+
+impl From<SignedExtensionMetadataIR> for SignedExtensionMetadata {
+	fn from(ir: SignedExtensionMetadataIR) -> Self {
+		SignedExtensionMetadata {
+			identifier: ir.identifier,
+			ty: ir.ty,
+			additional_signed: ir.additional_signed,
+		}
+	}
+}
+
+impl From<ExtrinsicMetadataIR> for ExtrinsicMetadata {
+	fn from(ir: ExtrinsicMetadataIR) -> Self {
+		ExtrinsicMetadata {
+			ty: ir.ty,
+			version: ir.version,
+			signed_extensions: ir.signed_extensions.into_iter().map(Into::into).collect(),
+		}
+	}
+}
diff --git a/substrate/primitives/metadata-ir/src/v15.rs b/substrate/primitives/metadata-ir/src/v15.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a942eb73223b2c80e2d71ef1cb070c45a2ca588f
--- /dev/null
+++ b/substrate/primitives/metadata-ir/src/v15.rs
@@ -0,0 +1,121 @@
+// 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.
+
+//! Convert the IR to V15 metadata.
+
+use crate::OuterEnumsIR;
+
+use super::types::{
+	ExtrinsicMetadataIR, MetadataIR, PalletMetadataIR, RuntimeApiMetadataIR,
+	RuntimeApiMethodMetadataIR, RuntimeApiMethodParamMetadataIR, SignedExtensionMetadataIR,
+};
+
+use frame_metadata::v15::{
+	CustomMetadata, ExtrinsicMetadata, OuterEnums, PalletMetadata, RuntimeApiMetadata,
+	RuntimeApiMethodMetadata, RuntimeApiMethodParamMetadata, RuntimeMetadataV15,
+	SignedExtensionMetadata,
+};
+
+impl From<MetadataIR> for RuntimeMetadataV15 {
+	fn from(ir: MetadataIR) -> Self {
+		RuntimeMetadataV15::new(
+			ir.pallets.into_iter().map(Into::into).collect(),
+			ir.extrinsic.into(),
+			ir.ty,
+			ir.apis.into_iter().map(Into::into).collect(),
+			ir.outer_enums.into(),
+			// Substrate does not collect yet the custom metadata fields.
+			// This allows us to extend the V15 easily.
+			CustomMetadata { map: Default::default() },
+		)
+	}
+}
+
+impl From<RuntimeApiMetadataIR> for RuntimeApiMetadata {
+	fn from(ir: RuntimeApiMetadataIR) -> Self {
+		RuntimeApiMetadata {
+			name: ir.name,
+			methods: ir.methods.into_iter().map(Into::into).collect(),
+			docs: ir.docs,
+		}
+	}
+}
+
+impl From<RuntimeApiMethodMetadataIR> for RuntimeApiMethodMetadata {
+	fn from(ir: RuntimeApiMethodMetadataIR) -> Self {
+		RuntimeApiMethodMetadata {
+			name: ir.name,
+			inputs: ir.inputs.into_iter().map(Into::into).collect(),
+			output: ir.output,
+			docs: ir.docs,
+		}
+	}
+}
+
+impl From<RuntimeApiMethodParamMetadataIR> for RuntimeApiMethodParamMetadata {
+	fn from(ir: RuntimeApiMethodParamMetadataIR) -> Self {
+		RuntimeApiMethodParamMetadata { name: ir.name, ty: ir.ty }
+	}
+}
+
+impl From<PalletMetadataIR> for PalletMetadata {
+	fn from(ir: PalletMetadataIR) -> Self {
+		PalletMetadata {
+			name: ir.name,
+			storage: ir.storage.map(Into::into),
+			calls: ir.calls.map(Into::into),
+			event: ir.event.map(Into::into),
+			constants: ir.constants.into_iter().map(Into::into).collect(),
+			error: ir.error.map(Into::into),
+			index: ir.index,
+			docs: ir.docs,
+		}
+	}
+}
+
+impl From<SignedExtensionMetadataIR> for SignedExtensionMetadata {
+	fn from(ir: SignedExtensionMetadataIR) -> Self {
+		SignedExtensionMetadata {
+			identifier: ir.identifier,
+			ty: ir.ty,
+			additional_signed: ir.additional_signed,
+		}
+	}
+}
+
+impl From<ExtrinsicMetadataIR> for ExtrinsicMetadata {
+	fn from(ir: ExtrinsicMetadataIR) -> Self {
+		ExtrinsicMetadata {
+			version: ir.version,
+			address_ty: ir.address_ty,
+			call_ty: ir.call_ty,
+			signature_ty: ir.signature_ty,
+			extra_ty: ir.extra_ty,
+			signed_extensions: ir.signed_extensions.into_iter().map(Into::into).collect(),
+		}
+	}
+}
+
+impl From<OuterEnumsIR> for OuterEnums {
+	fn from(ir: OuterEnumsIR) -> Self {
+		OuterEnums {
+			call_enum_ty: ir.call_enum_ty,
+			event_enum_ty: ir.event_enum_ty,
+			error_enum_ty: ir.error_enum_ty,
+		}
+	}
+}
diff --git a/substrate/primitives/npos-elections/Cargo.toml b/substrate/primitives/npos-elections/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..7faab23b04fbda6673b4ee04d238eb4702db523b
--- /dev/null
+++ b/substrate/primitives/npos-elections/Cargo.toml
@@ -0,0 +1,48 @@
+[package]
+name = "sp-npos-elections"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "NPoS election algorithm primitives"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, features = ["derive", "alloc"], optional = true }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[dev-dependencies]
+rand = "0.8.5"
+substrate-test-utils = { version = "4.0.0-dev", path = "../../test-utils" }
+
+[features]
+default = [ "std" ]
+bench = []
+std = [
+	"codec/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"dep:serde",
+	"scale-info/serde",
+	"sp-arithmetic/serde",
+	"sp-core/serde",
+	"sp-runtime/serde",
+]
diff --git a/substrate/primitives/npos-elections/README.md b/substrate/primitives/npos-elections/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6881fc6418f3a93e476b097fd049e3fc354be0c7
--- /dev/null
+++ b/substrate/primitives/npos-elections/README.md
@@ -0,0 +1,59 @@
+A set of election algorithms to be used with a substrate runtime, typically within the staking
+sub-system. Notable implementation include:
+
+- [`seq_phragmen`]: Implements the Phragmén Sequential Method. An un-ranked, relatively fast
+  election method that ensures PJR, but does not provide a constant factor approximation of the
+  maximin problem.
+- [`phragmms`]: Implements a hybrid approach inspired by Phragmén which is executed faster but
+  it can achieve a constant factor approximation of the maximin problem, similar to that of the
+  MMS algorithm.
+- [`balance_solution`]: Implements the star balancing algorithm. This iterative process can push
+  a solution toward being more `balanced`, which in turn can increase its score.
+
+### Terminology
+
+This crate uses context-independent words, not to be confused with staking. This is because the
+election algorithms of this crate, while designed for staking, can be used in other contexts as
+well.
+
+`Voter`: The entity casting some votes to a number of `Targets`. This is the same as `Nominator`
+in the context of staking. `Target`: The entities eligible to be voted upon. This is the same as
+`Validator` in the context of staking. `Edge`: A mapping from a `Voter` to a `Target`.
+
+The goal of an election algorithm is to provide an `ElectionResult`. A data composed of:
+- `winners`: A flat list of identifiers belonging to those who have won the election, usually
+  ordered in some meaningful way. They are zipped with their total backing stake.
+- `assignment`: A mapping from each voter to their winner-only targets, zipped with a ration
+  denoting the amount of support given to that particular target.
+
+```rust
+// the winners.
+let winners = vec![(1, 100), (2, 50)];
+let assignments = vec![
+    // A voter, giving equal backing to both 1 and 2.
+    Assignment {
+		who: 10,
+		distribution: vec![(1, Perbill::from_percent(50)), (2, Perbill::from_percent(50))],
+	},
+    // A voter, Only backing 1.
+    Assignment { who: 20, distribution: vec![(1, Perbill::from_percent(100))] },
+];
+
+// the combination of the two makes the election result.
+let election_result = ElectionResult { winners, assignments };
+
+```
+
+The `Assignment` field of the election result is voter-major, i.e. it is from the perspective of
+the voter. The struct that represents the opposite is called a `Support`. This struct is usually
+accessed in a map-like manner, i.e. keyed by voters, therefore it is stored as a mapping called
+`SupportMap`.
+
+Moreover, the support is built from absolute backing values, not ratios like the example above.
+A struct similar to `Assignment` that has stake value instead of ratios is called an
+`StakedAssignment`.
+
+
+More information can be found at: https://arxiv.org/abs/2004.12990
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/npos-elections/fuzzer/.gitignore b/substrate/primitives/npos-elections/fuzzer/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3ebcb104d4a50a19959dc7ff2bc06ee6bb48b31f
--- /dev/null
+++ b/substrate/primitives/npos-elections/fuzzer/.gitignore
@@ -0,0 +1,2 @@
+hfuzz_target
+hfuzz_workspace
diff --git a/substrate/primitives/npos-elections/fuzzer/Cargo.toml b/substrate/primitives/npos-elections/fuzzer/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..acb2b7d89a5c7cbac54bf3053877bc7a3b64f499
--- /dev/null
+++ b/substrate/primitives/npos-elections/fuzzer/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "sp-npos-elections-fuzzer"
+version = "2.0.0-alpha.5"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Fuzzer for phragmén implementation."
+documentation = "https://docs.rs/sp-npos-elections-fuzzer"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive"] }
+honggfuzz = "0.5"
+rand = { version = "0.8", features = ["std", "small_rng"] }
+sp-npos-elections = { version = "4.0.0-dev", path = ".." }
+sp-runtime = { version = "24.0.0", path = "../../runtime" }
+
+[[bin]]
+name = "reduce"
+path = "src/reduce.rs"
+
+[[bin]]
+name = "phragmen_balancing"
+path = "src/phragmen_balancing.rs"
+
+[[bin]]
+name = "phragmms_balancing"
+path = "src/phragmms_balancing.rs"
+
+[[bin]]
+name = "phragmen_pjr"
+path = "src/phragmen_pjr.rs"
diff --git a/substrate/primitives/npos-elections/fuzzer/src/common.rs b/substrate/primitives/npos-elections/fuzzer/src/common.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ebf103401a6296213a54c4c35c4be8156cd24341
--- /dev/null
+++ b/substrate/primitives/npos-elections/fuzzer/src/common.rs
@@ -0,0 +1,170 @@
+// 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.
+
+//! Common fuzzing utils.
+
+// Each function will be used based on which fuzzer binary is being used.
+#![allow(dead_code)]
+
+use rand::{self, seq::SliceRandom, Rng, RngCore};
+use sp_npos_elections::{phragmms, seq_phragmen, BalancingConfig, ElectionResult, VoteWeight};
+use sp_runtime::Perbill;
+use std::collections::{BTreeMap, HashSet};
+
+/// converts x into the range [a, b] in a pseudo-fair way.
+pub fn to_range(x: usize, a: usize, b: usize) -> usize {
+	// does not work correctly if b < 2 * a
+	assert!(b >= 2 * a);
+	let collapsed = x % b;
+	if collapsed >= a {
+		collapsed
+	} else {
+		collapsed + a
+	}
+}
+
+pub enum ElectionType {
+	Phragmen(Option<BalancingConfig>),
+	Phragmms(Option<BalancingConfig>),
+}
+
+pub type AccountId = u64;
+
+/// Generate a set of inputs suitable for fuzzing an election algorithm
+///
+/// Given parameters governing how many candidates and voters should exist, generates a voting
+/// scenario suitable for fuzz-testing an election algorithm.
+///
+/// The returned candidate list is sorted. This sorting property should not affect the result of the
+/// calculation.
+///
+/// The returned voters list is sorted. This enables binary searching for a particular voter by
+/// account id. This sorting property should not affect the results of the calculation.
+///
+/// Each voter's selection of candidates to vote for is sorted.
+///
+/// Note that this does not generate balancing parameters.
+pub fn generate_random_npos_inputs(
+	candidate_count: usize,
+	voter_count: usize,
+	mut rng: impl Rng,
+) -> (usize, Vec<AccountId>, Vec<(AccountId, VoteWeight, Vec<AccountId>)>) {
+	// cache for fast generation of unique candidate and voter ids
+	let mut used_ids = HashSet::with_capacity(candidate_count + voter_count);
+
+	// always generate a sensible desired number of candidates: elections are uninteresting if we
+	// desire 0 candidates, or a number of candidates >= the actual number of candidates present
+	let rounds = rng.gen_range(1..candidate_count);
+
+	// candidates are easy: just a completely random set of IDs
+	let mut candidates: Vec<AccountId> = Vec::with_capacity(candidate_count);
+	for _ in 0..candidate_count {
+		let mut id = rng.gen();
+		// insert returns `false` when the value was already present
+		while !used_ids.insert(id) {
+			id = rng.gen();
+		}
+		candidates.push(id);
+	}
+	candidates.sort();
+	candidates.dedup();
+	assert_eq!(candidates.len(), candidate_count);
+
+	let mut voters = Vec::with_capacity(voter_count);
+	for _ in 0..voter_count {
+		let mut id = rng.gen();
+		// insert returns `false` when the value was already present
+		while !used_ids.insert(id) {
+			id = rng.gen();
+		}
+
+		let vote_weight = rng.gen();
+
+		// it's not interesting if a voter chooses 0 or all candidates, so rule those cases out.
+		let n_candidates_chosen = rng.gen_range(1..candidates.len());
+
+		let mut chosen_candidates = Vec::with_capacity(n_candidates_chosen);
+		chosen_candidates.extend(candidates.choose_multiple(&mut rng, n_candidates_chosen));
+		chosen_candidates.sort();
+		voters.push((id, vote_weight, chosen_candidates));
+	}
+
+	voters.sort();
+	voters.dedup_by_key(|(id, _weight, _chosen_candidates)| *id);
+	assert_eq!(voters.len(), voter_count);
+
+	(rounds, candidates, voters)
+}
+
+pub fn generate_random_npos_result(
+	voter_count: u64,
+	target_count: u64,
+	to_elect: usize,
+	mut rng: impl RngCore,
+	election_type: ElectionType,
+) -> (
+	ElectionResult<AccountId, Perbill>,
+	Vec<AccountId>,
+	Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
+	BTreeMap<AccountId, VoteWeight>,
+) {
+	let prefix = 100_000;
+	// Note, it is important that stakes are always bigger than ed.
+	let base_stake: u64 = 1_000_000_000_000;
+	let ed: u64 = base_stake;
+
+	let mut candidates = Vec::with_capacity(target_count as usize);
+	let mut stake_of: BTreeMap<AccountId, VoteWeight> = BTreeMap::new();
+
+	(1..=target_count).for_each(|acc| {
+		candidates.push(acc);
+		let stake_var = rng.gen_range(ed..100 * ed);
+		stake_of.insert(acc, base_stake + stake_var);
+	});
+
+	let mut voters = Vec::with_capacity(voter_count as usize);
+	(prefix..=(prefix + voter_count)).for_each(|acc| {
+		let edge_per_this_voter = rng.gen_range(1..candidates.len());
+		// all possible targets
+		let mut all_targets = candidates.clone();
+		// we remove and pop into `targets` `edge_per_this_voter` times.
+		let targets = (0..edge_per_this_voter)
+			.map(|_| {
+				let upper = all_targets.len() - 1;
+				let idx = rng.gen_range(0..upper);
+				all_targets.remove(idx)
+			})
+			.collect::<Vec<AccountId>>();
+
+		let stake_var = rng.gen_range(ed..100 * ed);
+		let stake = base_stake + stake_var;
+		stake_of.insert(acc, stake);
+		voters.push((acc, stake, targets));
+	});
+
+	(
+		match election_type {
+			ElectionType::Phragmen(conf) =>
+				seq_phragmen(to_elect, candidates.clone(), voters.clone(), conf).unwrap(),
+			ElectionType::Phragmms(conf) =>
+				phragmms(to_elect, candidates.clone(), voters.clone(), conf).unwrap(),
+		},
+		candidates,
+		voters,
+		stake_of,
+	)
+}
diff --git a/substrate/primitives/npos-elections/fuzzer/src/phragmen_balancing.rs b/substrate/primitives/npos-elections/fuzzer/src/phragmen_balancing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c7aaf6ceed2a8492bb3fd995e0b492555901fa37
--- /dev/null
+++ b/substrate/primitives/npos-elections/fuzzer/src/phragmen_balancing.rs
@@ -0,0 +1,98 @@
+// 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.
+
+//! Fuzzing for sequential phragmen with potential balancing.
+
+mod common;
+
+use common::*;
+use honggfuzz::fuzz;
+use rand::{self, SeedableRng};
+use sp_npos_elections::{
+	assignment_ratio_to_staked_normalized, seq_phragmen, to_supports, BalancingConfig,
+	ElectionResult, EvaluateSupport, VoteWeight,
+};
+use sp_runtime::Perbill;
+
+fn main() {
+	loop {
+		fuzz!(|data: (usize, usize, usize, usize, u64)| {
+			let (mut target_count, mut voter_count, mut iterations, mut to_elect, seed) = data;
+			let rng = rand::rngs::SmallRng::seed_from_u64(seed);
+			target_count = to_range(target_count, 100, 200);
+			voter_count = to_range(voter_count, 100, 200);
+			iterations = to_range(iterations, 0, 30);
+			to_elect = to_range(to_elect, 25, target_count);
+
+			println!(
+				"++ [voter_count: {} / target_count:{} / to_elect:{} / iterations:{}]",
+				voter_count, target_count, to_elect, iterations,
+			);
+			let (unbalanced, candidates, voters, stake_of_tree) = generate_random_npos_result(
+				voter_count as u64,
+				target_count as u64,
+				to_elect,
+				rng,
+				ElectionType::Phragmen(None),
+			);
+
+			let stake_of = |who: &AccountId| -> VoteWeight { *stake_of_tree.get(who).unwrap() };
+
+			let unbalanced_score = {
+				let staked =
+					assignment_ratio_to_staked_normalized(unbalanced.assignments, &stake_of)
+						.unwrap();
+				let score = to_supports(staked.as_ref()).evaluate();
+
+				if score.minimal_stake == 0 {
+					// such cases cannot be improved by balancing.
+					return
+				}
+				score
+			};
+
+			if iterations > 0 {
+				let config = BalancingConfig { iterations, tolerance: 0 };
+				let balanced: ElectionResult<AccountId, sp_runtime::Perbill> =
+					seq_phragmen(to_elect, candidates, voters, Some(config)).unwrap();
+
+				let balanced_score = {
+					let staked =
+						assignment_ratio_to_staked_normalized(balanced.assignments, &stake_of)
+							.unwrap();
+					to_supports(staked.as_ref()).evaluate()
+				};
+
+				let enhance =
+					balanced_score.strict_threshold_better(unbalanced_score, Perbill::zero());
+
+				println!(
+					"iter = {} // {:?} -> {:?} [{}]",
+					iterations, unbalanced_score, balanced_score, enhance,
+				);
+
+				// The only guarantee of balancing is such that the first and third element of the
+				// score cannot decrease.
+				assert!(
+					balanced_score.minimal_stake >= unbalanced_score.minimal_stake &&
+						balanced_score.sum_stake == unbalanced_score.sum_stake &&
+						balanced_score.sum_stake_squared <= unbalanced_score.sum_stake_squared
+				);
+			}
+		});
+	}
+}
diff --git a/substrate/primitives/npos-elections/fuzzer/src/phragmen_pjr.rs b/substrate/primitives/npos-elections/fuzzer/src/phragmen_pjr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..94e697d9c4d8a1ab8e04528a8a288f276246e2e5
--- /dev/null
+++ b/substrate/primitives/npos-elections/fuzzer/src/phragmen_pjr.rs
@@ -0,0 +1,118 @@
+// 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.
+
+//! Fuzzing which ensures that running unbalanced sequential phragmen always produces a result
+//! which satisfies our PJR checker.
+//!
+//! ## Running a single iteration
+//!
+//! Honggfuzz shuts down each individual loop iteration after a configurable time limit.
+//! It can be helpful to run a single iteration on your hardware to help benchmark how long that
+//! time limit should reasonably be. Simply run the program without the `fuzzing` configuration to
+//! run a single iteration: `cargo run --bin phragmen_pjr`.
+//!
+//! ## Running
+//!
+//! Run with `HFUZZ_RUN_ARGS="-t 10" cargo hfuzz run phragmen_pjr`.
+//!
+//! Note the environment variable: by default, `cargo hfuzz` shuts down each iteration after 1
+//! second of runtime. We significantly increase that to ensure that the fuzzing gets a chance to
+//! complete. Running a single iteration can help determine an appropriate value for this parameter.
+//!
+//! ## Debugging a panic
+//!
+//! Once a panic is found, it can be debugged with
+//! `HFUZZ_RUN_ARGS="-t 10" cargo hfuzz run-debug phragmen_pjr hfuzz_workspace/phragmen_pjr/*.fuzz`.
+
+#[cfg(fuzzing)]
+use honggfuzz::fuzz;
+
+#[cfg(not(fuzzing))]
+use clap::Parser;
+
+mod common;
+use common::{generate_random_npos_inputs, to_range};
+use rand::{self, SeedableRng};
+use sp_npos_elections::{pjr_check_core, seq_phragmen_core, setup_inputs, standard_threshold};
+
+type AccountId = u64;
+
+const MIN_CANDIDATES: usize = 250;
+const MAX_CANDIDATES: usize = 1000;
+const MIN_VOTERS: usize = 500;
+const MAX_VOTERS: usize = 2500;
+
+#[cfg(fuzzing)]
+fn main() {
+	loop {
+		fuzz!(|data: (usize, usize, u64)| {
+			let (candidate_count, voter_count, seed) = data;
+			iteration(candidate_count, voter_count, seed);
+		});
+	}
+}
+
+#[cfg(not(fuzzing))]
+#[derive(Debug, Parser)]
+#[command(author, version, about)]
+struct Opt {
+	/// How many candidates participate in this election
+	#[arg(short, long)]
+	candidates: Option<usize>,
+
+	/// How many voters participate in this election
+	#[arg(short, long)]
+	voters: Option<usize>,
+
+	/// Random seed to use in this election
+	#[arg(long)]
+	seed: Option<u64>,
+}
+
+#[cfg(not(fuzzing))]
+fn main() {
+	let opt = Opt::parse();
+	// candidates and voters by default use the maxima, which turn out to be one less than
+	// the constant.
+	iteration(
+		opt.candidates.unwrap_or(MAX_CANDIDATES - 1),
+		opt.voters.unwrap_or(MAX_VOTERS - 1),
+		opt.seed.unwrap_or_default(),
+	);
+}
+
+fn iteration(mut candidate_count: usize, mut voter_count: usize, seed: u64) {
+	let rng = rand::rngs::SmallRng::seed_from_u64(seed);
+	candidate_count = to_range(candidate_count, MIN_CANDIDATES, MAX_CANDIDATES);
+	voter_count = to_range(voter_count, MIN_VOTERS, MAX_VOTERS);
+
+	let (rounds, candidates, voters) =
+		generate_random_npos_inputs(candidate_count, voter_count, rng);
+
+	let (candidates, voters) = setup_inputs(candidates, voters);
+
+	// Run seq-phragmen
+	let (candidates, voters) = seq_phragmen_core::<AccountId>(rounds, candidates, voters)
+		.expect("seq_phragmen must succeed");
+
+	let threshold = standard_threshold(rounds, voters.iter().map(|voter| voter.budget()));
+
+	assert!(
+		pjr_check_core(&candidates, &voters, threshold).is_ok(),
+		"unbalanced sequential phragmen must satisfy PJR",
+	);
+}
diff --git a/substrate/primitives/npos-elections/fuzzer/src/phragmms_balancing.rs b/substrate/primitives/npos-elections/fuzzer/src/phragmms_balancing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..067b788f01cb46e0756cd6133e9ebcfa3b5d7bc1
--- /dev/null
+++ b/substrate/primitives/npos-elections/fuzzer/src/phragmms_balancing.rs
@@ -0,0 +1,94 @@
+// 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.
+
+//! Fuzzing for phragmms.
+
+mod common;
+
+use common::*;
+use honggfuzz::fuzz;
+use rand::{self, SeedableRng};
+use sp_npos_elections::{
+	assignment_ratio_to_staked_normalized, phragmms, to_supports, BalancingConfig, ElectionResult,
+	EvaluateSupport, VoteWeight,
+};
+use sp_runtime::Perbill;
+
+fn main() {
+	loop {
+		fuzz!(|data: (usize, usize, usize, usize, u64)| {
+			let (mut target_count, mut voter_count, mut iterations, mut to_elect, seed) = data;
+			let rng = rand::rngs::SmallRng::seed_from_u64(seed);
+			target_count = to_range(target_count, 100, 200);
+			voter_count = to_range(voter_count, 100, 200);
+			iterations = to_range(iterations, 5, 30);
+			to_elect = to_range(to_elect, 25, target_count);
+
+			println!(
+				"++ [voter_count: {} / target_count:{} / to_elect:{} / iterations:{}]",
+				voter_count, target_count, to_elect, iterations,
+			);
+			let (unbalanced, candidates, voters, stake_of_tree) = generate_random_npos_result(
+				voter_count as u64,
+				target_count as u64,
+				to_elect,
+				rng,
+				ElectionType::Phragmms(None),
+			);
+
+			let stake_of = |who: &AccountId| -> VoteWeight { *stake_of_tree.get(who).unwrap() };
+
+			let unbalanced_score = {
+				let staked =
+					assignment_ratio_to_staked_normalized(unbalanced.assignments, &stake_of)
+						.unwrap();
+				let score = to_supports(&staked).evaluate();
+
+				if score.minimal_stake == 0 {
+					// such cases cannot be improved by balancing.
+					return
+				}
+				score
+			};
+
+			let config = BalancingConfig { iterations, tolerance: 0 };
+			let balanced: ElectionResult<AccountId, Perbill> =
+				phragmms(to_elect, candidates, voters, Some(config)).unwrap();
+
+			let balanced_score = {
+				let staked =
+					assignment_ratio_to_staked_normalized(balanced.assignments, &stake_of).unwrap();
+				to_supports(staked.as_ref()).evaluate()
+			};
+
+			let enhance = balanced_score.strict_threshold_better(unbalanced_score, Perbill::zero());
+
+			println!(
+				"iter = {} // {:?} -> {:?} [{}]",
+				iterations, unbalanced_score, balanced_score, enhance,
+			);
+
+			// The only guarantee of balancing is such that the first and third element of the score
+			// cannot decrease.
+			assert!(
+				balanced_score.minimal_stake >= unbalanced_score.minimal_stake &&
+					balanced_score.sum_stake == unbalanced_score.sum_stake &&
+					balanced_score.sum_stake_squared <= unbalanced_score.sum_stake_squared
+			);
+		});
+	}
+}
diff --git a/substrate/primitives/npos-elections/fuzzer/src/reduce.rs b/substrate/primitives/npos-elections/fuzzer/src/reduce.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9ac34189d2e86eb991c5331997662b51421cb9c0
--- /dev/null
+++ b/substrate/primitives/npos-elections/fuzzer/src/reduce.rs
@@ -0,0 +1,143 @@
+// 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.
+
+//! Fuzzing for the reduce algorithm.
+//!
+//! It that reduce always return a new set og edges in which the bound is kept (`edges_after <= m +
+//! n,`) and the result must effectively be the same, meaning that the same support map should be
+//! computable from both.
+//!
+//! # Running
+//!
+//! Run with `cargo hfuzz run reduce`. `honggfuzz`.
+//!
+//! # Debugging a panic
+//!
+//! Once a panic is found, it can be debugged with
+//! `cargo hfuzz run-debug reduce hfuzz_workspace/reduce/*.fuzz`.
+
+use honggfuzz::fuzz;
+
+mod common;
+use common::to_range;
+use rand::{self, Rng, RngCore, SeedableRng};
+use sp_npos_elections::{reduce, to_support_map, ExtendedBalance, StakedAssignment};
+
+type Balance = u128;
+type AccountId = u64;
+
+/// Or any other token type.
+const KSM: Balance = 1_000_000_000_000;
+
+fn main() {
+	loop {
+		fuzz!(|data: (usize, usize, u64)| {
+			let (mut voter_count, mut target_count, seed) = data;
+			let rng = rand::rngs::SmallRng::seed_from_u64(seed);
+			target_count = to_range(target_count, 100, 1000);
+			voter_count = to_range(voter_count, 100, 2000);
+			let (assignments, winners) =
+				generate_random_phragmen_assignment(voter_count, target_count, 8, 8, rng);
+			reduce_and_compare(&assignments, &winners);
+		});
+	}
+}
+
+fn generate_random_phragmen_assignment(
+	voter_count: usize,
+	target_count: usize,
+	avg_edge_per_voter: usize,
+	edge_per_voter_var: usize,
+	mut rng: impl RngCore,
+) -> (Vec<StakedAssignment<AccountId>>, Vec<AccountId>) {
+	// prefix to distinguish the voter and target account ranges.
+	let target_prefix = 1_000_000;
+	assert!(voter_count < target_prefix);
+
+	let mut assignments = Vec::with_capacity(voter_count as usize);
+	let mut winners: Vec<AccountId> = Vec::new();
+
+	let all_targets = (target_prefix..(target_prefix + target_count))
+		.map(|a| a as AccountId)
+		.collect::<Vec<AccountId>>();
+
+	(1..=voter_count).for_each(|acc| {
+		let mut targets_to_chose_from = all_targets.clone();
+		let targets_to_chose = if edge_per_voter_var > 0 {
+			rng.gen_range(
+				avg_edge_per_voter - edge_per_voter_var..avg_edge_per_voter + edge_per_voter_var,
+			)
+		} else {
+			avg_edge_per_voter
+		};
+
+		let distribution = (0..targets_to_chose)
+			.map(|_| {
+				let target =
+					targets_to_chose_from.remove(rng.gen_range(0..targets_to_chose_from.len()));
+				if winners.iter().all(|w| *w != target) {
+					winners.push(target);
+				}
+				(target, rng.gen_range(1 * KSM..100 * KSM))
+			})
+			.collect::<Vec<(AccountId, ExtendedBalance)>>();
+
+		assignments.push(StakedAssignment { who: (acc as AccountId), distribution });
+	});
+
+	(assignments, winners)
+}
+
+fn assert_assignments_equal(
+	ass1: &Vec<StakedAssignment<AccountId>>,
+	ass2: &Vec<StakedAssignment<AccountId>>,
+) {
+	let support_1 = to_support_map::<AccountId>(ass1);
+	let support_2 = to_support_map::<AccountId>(ass2);
+	for (who, support) in support_1.iter() {
+		assert_eq!(support.total, support_2.get(who).unwrap().total);
+	}
+}
+
+fn reduce_and_compare(assignment: &Vec<StakedAssignment<AccountId>>, winners: &Vec<AccountId>) {
+	let mut altered_assignment = assignment.clone();
+	let n = assignment.len() as u32;
+	let m = winners.len() as u32;
+
+	let edges_before = assignment_len(assignment);
+	let num_changed = reduce(&mut altered_assignment);
+	let edges_after = edges_before - num_changed;
+
+	assert!(
+		edges_after <= m + n,
+		"reduce bound not satisfied. n = {}, m = {}, edges after reduce = {} (removed {})",
+		n,
+		m,
+		edges_after,
+		num_changed,
+	);
+
+	assert_assignments_equal(&assignment, &altered_assignment);
+}
+
+fn assignment_len(assignments: &[StakedAssignment<AccountId>]) -> u32 {
+	let mut counter = 0;
+	assignments
+		.iter()
+		.for_each(|x| x.distribution.iter().for_each(|_| counter += 1));
+	counter
+}
diff --git a/substrate/primitives/npos-elections/src/assignments.rs b/substrate/primitives/npos-elections/src/assignments.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2ac2b9bebd771cf480a36e128133387026681f7e
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/assignments.rs
@@ -0,0 +1,167 @@
+// 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.
+
+//! Structs and helpers for distributing a voter's stake among various winners.
+
+use crate::{ExtendedBalance, IdentifierT, PerThing128};
+#[cfg(feature = "serde")]
+use codec::{Decode, Encode};
+use sp_arithmetic::{
+	traits::{Bounded, Zero},
+	Normalizable, PerThing,
+};
+use sp_core::RuntimeDebug;
+use sp_std::vec::Vec;
+
+/// A voter's stake assignment among a set of targets, represented as ratios.
+#[derive(RuntimeDebug, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(PartialEq, Eq, Encode, Decode))]
+pub struct Assignment<AccountId, P: PerThing> {
+	/// Voter's identifier.
+	pub who: AccountId,
+	/// The distribution of the voter's stake.
+	pub distribution: Vec<(AccountId, P)>,
+}
+
+impl<AccountId: IdentifierT, P: PerThing128> Assignment<AccountId, P> {
+	/// Convert from a ratio assignment into one with absolute values aka. [`StakedAssignment`].
+	///
+	/// It needs `stake` which is the total budget of the voter.
+	///
+	/// Note that this might create _un-normalized_ assignments, due to accuracy loss of `P`. Call
+	/// site might compensate by calling `try_normalize()` on the returned `StakedAssignment` as a
+	/// post-precessing.
+	///
+	/// If an edge ratio is [`Bounded::min_value()`], it is dropped. This edge can never mean
+	/// anything useful.
+	pub fn into_staked(self, stake: ExtendedBalance) -> StakedAssignment<AccountId> {
+		let distribution = self
+			.distribution
+			.into_iter()
+			.filter_map(|(target, p)| {
+				// if this ratio is zero, then skip it.
+				if p.is_zero() {
+					None
+				} else {
+					// NOTE: this mul impl will always round to the nearest number, so we might both
+					// overflow and underflow.
+					let distribution_stake = p * stake;
+					Some((target, distribution_stake))
+				}
+			})
+			.collect::<Vec<(AccountId, ExtendedBalance)>>();
+
+		StakedAssignment { who: self.who, distribution }
+	}
+
+	/// Try and normalize this assignment.
+	///
+	/// If `Ok(())` is returned, then the assignment MUST have been successfully normalized to 100%.
+	///
+	/// ### Errors
+	///
+	/// This will return only if the internal `normalize` fails. This can happen if sum of
+	/// `self.distribution.map(|p| p.deconstruct())` fails to fit inside `UpperOf<P>`. A user of
+	/// this crate may statically assert that this can never happen and safely `expect` this to
+	/// return `Ok`.
+	pub fn try_normalize(&mut self) -> Result<(), &'static str> {
+		self.distribution
+			.iter()
+			.map(|(_, p)| *p)
+			.collect::<Vec<_>>()
+			.normalize(P::one())
+			.map(|normalized_ratios| {
+				self.distribution.iter_mut().zip(normalized_ratios).for_each(
+					|((_, old), corrected)| {
+						*old = corrected;
+					},
+				)
+			})
+	}
+}
+
+/// A voter's stake assignment among a set of targets, represented as absolute values in the scale
+/// of [`ExtendedBalance`].
+#[derive(RuntimeDebug, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(PartialEq, Eq, Encode, Decode))]
+pub struct StakedAssignment<AccountId> {
+	/// Voter's identifier
+	pub who: AccountId,
+	/// The distribution of the voter's stake.
+	pub distribution: Vec<(AccountId, ExtendedBalance)>,
+}
+
+impl<AccountId> StakedAssignment<AccountId> {
+	/// Converts self into the normal [`Assignment`] type.
+	///
+	/// NOTE: This will always round down, and thus the results might be less than a full 100% `P`.
+	/// Use a normalization post-processing to fix this. The data type returned here will
+	/// potentially get used to create a compact type; a compact type requires sum of ratios to be
+	/// less than 100% upon un-compacting.
+	///
+	/// If an edge stake is so small that it cannot be represented in `T`, it is ignored. This edge
+	/// can never be re-created and does not mean anything useful anymore.
+	pub fn into_assignment<P: PerThing>(self) -> Assignment<AccountId, P>
+	where
+		AccountId: IdentifierT,
+	{
+		let stake = self.total();
+		// most likely, the size of the staked assignment and normal assignments will be the same,
+		// so we pre-allocate it to prevent a sudden 2x allocation. `filter_map` starts with a size
+		// of 0 by default.
+		// https://www.reddit.com/r/rust/comments/3spfh1/does_collect_allocate_more_than_once_while/
+		let mut distribution = Vec::<(AccountId, P)>::with_capacity(self.distribution.len());
+		self.distribution.into_iter().for_each(|(target, w)| {
+			let per_thing = P::from_rational(w, stake);
+			if per_thing != Bounded::min_value() {
+				distribution.push((target, per_thing));
+			}
+		});
+
+		Assignment { who: self.who, distribution }
+	}
+
+	/// Try and normalize this assignment.
+	///
+	/// If `Ok(())` is returned, then the assignment MUST have been successfully normalized to
+	/// `stake`.
+	///
+	/// NOTE: current implementation of `.normalize` is almost safe to `expect()` upon. The only
+	/// error case is when the input cannot fit in `T`, or the sum of input cannot fit in `T`.
+	/// Sadly, both of these are dependent upon the implementation of `VoteLimit`, i.e. the limit of
+	/// edges per voter which is enforced from upstream. Hence, at this crate, we prefer returning a
+	/// result and a use the name prefix `try_`.
+	pub fn try_normalize(&mut self, stake: ExtendedBalance) -> Result<(), &'static str> {
+		self.distribution
+			.iter()
+			.map(|(_, ref weight)| *weight)
+			.collect::<Vec<_>>()
+			.normalize(stake)
+			.map(|normalized_weights| {
+				self.distribution.iter_mut().zip(normalized_weights.into_iter()).for_each(
+					|((_, weight), corrected)| {
+						*weight = corrected;
+					},
+				)
+			})
+	}
+
+	/// Get the total stake of this assignment (aka voter budget).
+	pub fn total(&self) -> ExtendedBalance {
+		self.distribution.iter().fold(Zero::zero(), |a, b| a.saturating_add(b.1))
+	}
+}
diff --git a/substrate/primitives/npos-elections/src/balancing.rs b/substrate/primitives/npos-elections/src/balancing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..90dbe7eb7147817882eb85f9ba321619ac74150e
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/balancing.rs
@@ -0,0 +1,199 @@
+// 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.
+
+//! Balancing algorithm implementation.
+//!
+//! Given a committee `A` and an edge weight vector `w`, a balanced solution is one that
+//!
+//! 1. it maximizes the sum of member supports, i.e `Argmax { sum(support(c)) }`. for all `c` in
+//! `A`.
+//! 2. it minimizes the sum of supports squared, i.e `Argmin { sum(support(c).pow(2)) }` for all `c`
+//! in `A`.
+//!
+//! See [`balance`] for more information.
+
+use crate::{BalancingConfig, Edge, ExtendedBalance, IdentifierT, Voter};
+use sp_arithmetic::traits::Zero;
+use sp_std::prelude::*;
+
+/// Balance the weight distribution of a given `voters` at most `iterations` times, or up until the
+/// point where the biggest difference created per iteration of all stakes is `tolerance`. If this
+/// is called with `tolerance = 0`, then exactly `iterations` rounds will be executed, except if no
+/// change has been made (`difference = 0`). `tolerance` and `iterations` are part of the
+/// [`BalancingConfig`] struct.
+///
+/// In almost all cases, a balanced solution will have a better score than an unbalanced solution,
+/// yet this is not 100% guaranteed because the first element of a [`crate::ElectionScore`] does not
+/// directly relate to balancing.
+///
+/// Note that some reference implementation adopt an approach in which voters are balanced randomly
+/// per round. To advocate determinism, we don't do this. In each round, all voters are exactly
+/// balanced once, in the same order.
+///
+/// Also, note that due to re-distribution of weights, the outcome of this function might contain
+/// edges with weight zero. The call site should filter such weight if desirable. Moreover, the
+/// outcome might need balance re-normalization, see `Voter::try_normalize`.
+///
+/// ### References
+///
+/// - [A new approach to the maximum flow problem](https://dl.acm.org/doi/10.1145/48014.61051).
+/// - [Validator election in nominated proof-of-stake](https://arxiv.org/abs/2004.12990) (Appendix
+///   A.)
+/// - [Computing a balanced solution](https://research.web3.foundation/en/latest/polkadot/NPoS/3.%20Balancing.html),
+///   which contains the details of the algorithm implementation.
+pub fn balance<AccountId: IdentifierT>(
+	voters: &mut Vec<Voter<AccountId>>,
+	config: &BalancingConfig,
+) -> usize {
+	if config.iterations == 0 {
+		return 0
+	}
+
+	let mut iter = 0;
+	loop {
+		let mut max_diff = 0;
+		for voter in voters.iter_mut() {
+			let diff = balance_voter(voter, config.tolerance);
+			if diff > max_diff {
+				max_diff = diff;
+			}
+		}
+
+		iter += 1;
+		if max_diff <= config.tolerance || iter >= config.iterations {
+			break iter
+		}
+	}
+}
+
+/// Internal implementation of balancing for one voter.
+pub(crate) fn balance_voter<AccountId: IdentifierT>(
+	voter: &mut Voter<AccountId>,
+	tolerance: ExtendedBalance,
+) -> ExtendedBalance {
+	// create a shallow copy of the elected ones. The original one will not be used henceforth.
+	let mut elected_edges = voter
+		.edges
+		.iter_mut()
+		.filter(|e| e.candidate.borrow().elected)
+		.collect::<Vec<&mut Edge<AccountId>>>();
+
+	// Either empty, or a self vote. Not much to do in either case.
+	if elected_edges.len() <= 1 {
+		return Zero::zero()
+	}
+
+	// amount of stake from this voter that is used in edges.
+	let stake_used =
+		elected_edges.iter().fold(0, |a: ExtendedBalance, e| a.saturating_add(e.weight));
+
+	// backed stake of each of the elected edges.
+	let backed_stakes = elected_edges
+		.iter()
+		.map(|e| e.candidate.borrow().backed_stake)
+		.collect::<Vec<_>>();
+
+	// backed stake of all the edges for whom we've spent some stake.
+	let backing_backed_stake = elected_edges
+		.iter()
+		.filter_map(|e| if e.weight > 0 { Some(e.candidate.borrow().backed_stake) } else { None })
+		.collect::<Vec<_>>();
+
+	let difference = if backing_backed_stake.len() > 0 {
+		let max_stake = backing_backed_stake
+			.iter()
+			.max()
+			.expect("vector with positive length will have a max; qed");
+		let min_stake = backed_stakes
+			.iter()
+			.min()
+			.expect("iterator with positive length will have a min; qed");
+		let mut difference = max_stake.saturating_sub(*min_stake);
+		difference = difference.saturating_add(voter.budget.saturating_sub(stake_used));
+		if difference < tolerance {
+			return difference
+		}
+		difference
+	} else {
+		voter.budget
+	};
+
+	// remove all backings.
+	for edge in elected_edges.iter_mut() {
+		let mut candidate = edge.candidate.borrow_mut();
+		candidate.backed_stake = candidate.backed_stake.saturating_sub(edge.weight);
+		edge.weight = 0;
+	}
+
+	elected_edges.sort_by_key(|e| e.candidate.borrow().backed_stake);
+
+	let mut cumulative_backed_stake = Zero::zero();
+	let mut last_index = elected_edges.len() - 1;
+
+	for (index, edge) in elected_edges.iter().enumerate() {
+		let index = index as ExtendedBalance;
+		let backed_stake = edge.candidate.borrow().backed_stake;
+		let temp = backed_stake.saturating_mul(index);
+		if temp.saturating_sub(cumulative_backed_stake) > voter.budget {
+			// defensive only. length of elected_edges is checked to be above 1.
+			last_index = index.saturating_sub(1) as usize;
+			break
+		}
+		cumulative_backed_stake = cumulative_backed_stake.saturating_add(backed_stake);
+	}
+
+	let last_stake = elected_edges
+		.get(last_index)
+		.expect(
+			"length of elected_edges is greater than or equal 2; last_index index is at the \
+ 			 minimum elected_edges.len() - 1; index is within range; qed",
+		)
+		.candidate
+		.borrow()
+		.backed_stake;
+	let ways_to_split = last_index + 1;
+	let excess = voter
+		.budget
+		.saturating_add(cumulative_backed_stake)
+		.saturating_sub(last_stake.saturating_mul(ways_to_split as ExtendedBalance));
+
+	// Do the final update.
+	for edge in elected_edges.into_iter().take(ways_to_split) {
+		// first, do one scoped borrow to get the previous candidate stake.
+		let candidate_backed_stake = {
+			let candidate = edge.candidate.borrow();
+			candidate.backed_stake
+		};
+
+		let new_edge_weight = (excess / ways_to_split as ExtendedBalance)
+			.saturating_add(last_stake)
+			.saturating_sub(candidate_backed_stake);
+
+		// write the new edge weight
+		edge.weight = new_edge_weight;
+
+		// write the new candidate stake
+		let mut candidate = edge.candidate.borrow_mut();
+		candidate.backed_stake = candidate.backed_stake.saturating_add(new_edge_weight);
+	}
+
+	// excess / ways_to_split can cause a small un-normalized voters to be created.
+	// We won't `expect` here because even a result which is not normalized is not corrupt;
+	let _ = voter.try_normalize_elected();
+
+	difference
+}
diff --git a/substrate/primitives/npos-elections/src/helpers.rs b/substrate/primitives/npos-elections/src/helpers.rs
new file mode 100644
index 0000000000000000000000000000000000000000..082491ea04281b5ebb73c33e7cb970ebc4c18071
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/helpers.rs
@@ -0,0 +1,113 @@
+// 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.
+
+//! Helper methods for npos-elections.
+
+use crate::{Assignment, Error, IdentifierT, PerThing128, StakedAssignment, VoteWeight};
+use sp_arithmetic::PerThing;
+use sp_std::prelude::*;
+
+/// Converts a vector of ratio assignments into ones with absolute budget value.
+///
+/// Note that this will NOT attempt at normalizing the result.
+pub fn assignment_ratio_to_staked<A: IdentifierT, P: PerThing128, FS>(
+	ratios: Vec<Assignment<A, P>>,
+	stake_of: FS,
+) -> Vec<StakedAssignment<A>>
+where
+	for<'r> FS: Fn(&'r A) -> VoteWeight,
+{
+	ratios
+		.into_iter()
+		.map(|a| {
+			let stake = stake_of(&a.who);
+			a.into_staked(stake.into())
+		})
+		.collect()
+}
+
+/// Same as [`assignment_ratio_to_staked`] and try and do normalization.
+pub fn assignment_ratio_to_staked_normalized<A: IdentifierT, P: PerThing128, FS>(
+	ratio: Vec<Assignment<A, P>>,
+	stake_of: FS,
+) -> Result<Vec<StakedAssignment<A>>, Error>
+where
+	for<'r> FS: Fn(&'r A) -> VoteWeight,
+{
+	let mut staked = assignment_ratio_to_staked(ratio, &stake_of);
+	staked.iter_mut().try_for_each(|a| {
+		a.try_normalize(stake_of(&a.who).into()).map_err(Error::ArithmeticError)
+	})?;
+	Ok(staked)
+}
+
+/// Converts a vector of staked assignments into ones with ratio values.
+///
+/// Note that this will NOT attempt at normalizing the result.
+pub fn assignment_staked_to_ratio<A: IdentifierT, P: PerThing>(
+	staked: Vec<StakedAssignment<A>>,
+) -> Vec<Assignment<A, P>> {
+	staked.into_iter().map(|a| a.into_assignment()).collect()
+}
+
+/// Same as [`assignment_staked_to_ratio`] and try and do normalization.
+pub fn assignment_staked_to_ratio_normalized<A: IdentifierT, P: PerThing128>(
+	staked: Vec<StakedAssignment<A>>,
+) -> Result<Vec<Assignment<A, P>>, Error> {
+	let mut ratio = staked.into_iter().map(|a| a.into_assignment()).collect::<Vec<_>>();
+	for assignment in ratio.iter_mut() {
+		assignment.try_normalize().map_err(Error::ArithmeticError)?;
+	}
+	Ok(ratio)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_arithmetic::Perbill;
+
+	#[test]
+	fn into_staked_works() {
+		let assignments = vec![
+			Assignment {
+				who: 1u32,
+				distribution: vec![
+					(10u32, Perbill::from_float(0.5)),
+					(20, Perbill::from_float(0.5)),
+				],
+			},
+			Assignment {
+				who: 2u32,
+				distribution: vec![
+					(10, Perbill::from_float(0.33)),
+					(20, Perbill::from_float(0.67)),
+				],
+			},
+		];
+
+		let stake_of = |_: &u32| -> VoteWeight { 100 };
+		let staked = assignment_ratio_to_staked(assignments, stake_of);
+
+		assert_eq!(
+			staked,
+			vec![
+				StakedAssignment { who: 1u32, distribution: vec![(10u32, 50), (20, 50),] },
+				StakedAssignment { who: 2u32, distribution: vec![(10u32, 33), (20, 67),] }
+			]
+		);
+	}
+}
diff --git a/substrate/primitives/npos-elections/src/lib.rs b/substrate/primitives/npos-elections/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0afe1ec5bb692346fdebbc0cd046b4238b806842
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/lib.rs
@@ -0,0 +1,581 @@
+// 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 set of election algorithms to be used with a substrate runtime, typically within the staking
+//! sub-system. Notable implementation include:
+//!
+//! - [`seq_phragmen`]: Implements the Phragmén Sequential Method. An un-ranked, relatively fast
+//!   election method that ensures PJR, but does not provide a constant factor approximation of the
+//!   maximin problem.
+//! - [`phragmms`](phragmms::phragmms): Implements a hybrid approach inspired by Phragmén which is
+//!   executed faster but it can achieve a constant factor approximation of the maximin problem,
+//!   similar to that of the MMS algorithm.
+//! - [`balance`](balancing::balance): Implements the star balancing algorithm. This iterative
+//!   process can push a solution toward being more "balanced", which in turn can increase its
+//!   score.
+//!
+//! ### Terminology
+//!
+//! This crate uses context-independent words, not to be confused with staking. This is because the
+//! election algorithms of this crate, while designed for staking, can be used in other contexts as
+//! well.
+//!
+//! `Voter`: The entity casting some votes to a number of `Targets`. This is the same as `Nominator`
+//! in the context of staking. `Target`: The entities eligible to be voted upon. This is the same as
+//! `Validator` in the context of staking. `Edge`: A mapping from a `Voter` to a `Target`.
+//!
+//! The goal of an election algorithm is to provide an `ElectionResult`. A data composed of:
+//! - `winners`: A flat list of identifiers belonging to those who have won the election, usually
+//!   ordered in some meaningful way. They are zipped with their total backing stake.
+//! - `assignment`: A mapping from each voter to their winner-only targets, zipped with a ration
+//!   denoting the amount of support given to that particular target.
+//!
+//! ```rust
+//! # use sp_npos_elections::*;
+//! # use sp_runtime::Perbill;
+//! // the winners.
+//! let winners = vec![(1, 100), (2, 50)];
+//! let assignments = vec![
+//!     // A voter, giving equal backing to both 1 and 2.
+//!     Assignment {
+//! 		who: 10,
+//! 		distribution: vec![(1, Perbill::from_percent(50)), (2, Perbill::from_percent(50))],
+//! 	},
+//!     // A voter, Only backing 1.
+//!     Assignment { who: 20, distribution: vec![(1, Perbill::from_percent(100))] },
+//! ];
+//!
+//! // the combination of the two makes the election result.
+//! let election_result = ElectionResult { winners, assignments };
+//! ```
+//!
+//! The `Assignment` field of the election result is voter-major, i.e. it is from the perspective of
+//! the voter. The struct that represents the opposite is called a `Support`. This struct is usually
+//! accessed in a map-like manner, i.e. keyed by voters, therefore it is stored as a mapping called
+//! `SupportMap`.
+//!
+//! Moreover, the support is built from absolute backing values, not ratios like the example above.
+//! A struct similar to `Assignment` that has stake value instead of ratios is called an
+//! `StakedAssignment`.
+//!
+//!
+//! More information can be found at: <https://arxiv.org/abs/2004.12990>
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use sp_arithmetic::{traits::Zero, Normalizable, PerThing, Rational128, ThresholdOrd};
+use sp_core::{bounded::BoundedVec, RuntimeDebug};
+use sp_std::{
+	cell::RefCell, cmp::Ordering, collections::btree_map::BTreeMap, prelude::*, rc::Rc, vec,
+};
+
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+mod assignments;
+pub mod balancing;
+pub mod helpers;
+pub mod node;
+pub mod phragmen;
+pub mod phragmms;
+pub mod pjr;
+pub mod reduce;
+pub mod traits;
+
+pub use assignments::{Assignment, StakedAssignment};
+pub use balancing::*;
+pub use helpers::*;
+pub use phragmen::*;
+pub use phragmms::*;
+pub use pjr::*;
+pub use reduce::reduce;
+pub use traits::{IdentifierT, PerThing128};
+
+/// The errors that might occur in this crate and `frame-election-provider-solution-type`.
+#[derive(Eq, PartialEq, RuntimeDebug)]
+pub enum Error {
+	/// While going from solution indices to ratio, the weight of all the edges has gone above the
+	/// total.
+	SolutionWeightOverflow,
+	/// The solution type has a voter who's number of targets is out of bound.
+	SolutionTargetOverflow,
+	/// One of the index functions returned none.
+	SolutionInvalidIndex,
+	/// One of the page indices was invalid.
+	SolutionInvalidPageIndex,
+	/// An error occurred in some arithmetic operation.
+	ArithmeticError(&'static str),
+	/// The data provided to create support map was invalid.
+	InvalidSupportEdge,
+	/// The number of voters is bigger than the `MaxVoters` bound.
+	TooManyVoters,
+}
+
+/// A type which is used in the API of this crate as a numeric weight of a vote, most often the
+/// stake of the voter. It is always converted to [`ExtendedBalance`] for computation.
+pub type VoteWeight = u64;
+
+/// A type in which performing operations on vote weights are safe.
+pub type ExtendedBalance = u128;
+
+/// The score of an election. This is the main measure of an election's quality.
+///
+/// By definition, the order of significance in [`ElectionScore`] is:
+///
+/// 1. `minimal_stake`.
+/// 2. `sum_stake`.
+/// 3. `sum_stake_squared`.
+#[derive(Clone, Copy, PartialEq, Eq, Encode, Decode, MaxEncodedLen, TypeInfo, Debug, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ElectionScore {
+	/// The minimal winner, in terms of total backing stake.
+	///
+	/// This parameter should be maximized.
+	pub minimal_stake: ExtendedBalance,
+	/// The sum of the total backing of all winners.
+	///
+	/// This parameter should maximized
+	pub sum_stake: ExtendedBalance,
+	/// The sum squared of the total backing of all winners, aka. the variance.
+	///
+	/// Ths parameter should be minimized.
+	pub sum_stake_squared: ExtendedBalance,
+}
+
+impl ElectionScore {
+	/// Iterate over the inner items, first visiting the most significant one.
+	fn iter_by_significance(self) -> impl Iterator<Item = ExtendedBalance> {
+		[self.minimal_stake, self.sum_stake, self.sum_stake_squared].into_iter()
+	}
+
+	/// Compares two sets of election scores based on desirability, returning true if `self` is
+	/// strictly `threshold` better than `other`. In other words, each element of `self` must be
+	/// `self * threshold` better than `other`.
+	///
+	/// Evaluation is done based on the order of significance of the fields of [`ElectionScore`].
+	pub fn strict_threshold_better(self, other: Self, threshold: impl PerThing) -> bool {
+		match self
+			.iter_by_significance()
+			.zip(other.iter_by_significance())
+			.map(|(this, that)| (this.ge(&that), this.tcmp(&that, threshold.mul_ceil(that))))
+			.collect::<Vec<(bool, Ordering)>>()
+			.as_slice()
+		{
+			// threshold better in the `score.minimal_stake`, accept.
+			[(x, Ordering::Greater), _, _] => {
+				debug_assert!(x);
+				true
+			},
+
+			// less than threshold better in `score.minimal_stake`, but more than threshold better
+			// in `score.sum_stake`.
+			[(true, Ordering::Equal), (_, Ordering::Greater), _] => true,
+
+			// less than threshold better in `score.minimal_stake` and `score.sum_stake`, but more
+			// than threshold better in `score.sum_stake_squared`.
+			[(true, Ordering::Equal), (true, Ordering::Equal), (_, Ordering::Less)] => true,
+
+			// anything else is not a good score.
+			_ => false,
+		}
+	}
+}
+
+impl sp_std::cmp::Ord for ElectionScore {
+	fn cmp(&self, other: &Self) -> Ordering {
+		// we delegate this to the lexicographic cmp of slices`, and to incorporate that we want the
+		// third element to be minimized, we swap them.
+		[self.minimal_stake, self.sum_stake, other.sum_stake_squared].cmp(&[
+			other.minimal_stake,
+			other.sum_stake,
+			self.sum_stake_squared,
+		])
+	}
+}
+
+impl sp_std::cmp::PartialOrd for ElectionScore {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+/// Utility struct to group parameters for the balancing algorithm.
+#[derive(Clone, Copy)]
+pub struct BalancingConfig {
+	pub iterations: usize,
+	pub tolerance: ExtendedBalance,
+}
+
+/// A pointer to a candidate struct with interior mutability.
+pub type CandidatePtr<A> = Rc<RefCell<Candidate<A>>>;
+
+/// A candidate entity for the election.
+#[derive(RuntimeDebug, Clone, Default)]
+pub struct Candidate<AccountId> {
+	/// Identifier.
+	who: AccountId,
+	/// Score of the candidate.
+	///
+	/// Used differently in seq-phragmen and max-score.
+	score: Rational128,
+	/// Approval stake of the candidate. Merely the sum of all the voter's stake who approve this
+	/// candidate.
+	approval_stake: ExtendedBalance,
+	/// The final stake of this candidate. Will be equal to a subset of approval stake.
+	backed_stake: ExtendedBalance,
+	/// True if this candidate is already elected in the current election.
+	elected: bool,
+	/// The round index at which this candidate was elected.
+	round: usize,
+}
+
+impl<AccountId> Candidate<AccountId> {
+	pub fn to_ptr(self) -> CandidatePtr<AccountId> {
+		Rc::new(RefCell::new(self))
+	}
+}
+
+/// A vote being casted by a [`Voter`] to a [`Candidate`] is an `Edge`.
+#[derive(Clone)]
+pub struct Edge<AccountId> {
+	/// Identifier of the target.
+	///
+	/// This is equivalent of `self.candidate.borrow().who`, yet it helps to avoid double borrow
+	/// errors of the candidate pointer.
+	who: AccountId,
+	/// Load of this edge.
+	load: Rational128,
+	/// Pointer to the candidate.
+	candidate: CandidatePtr<AccountId>,
+	/// The weight (i.e. stake given to `who`) of this edge.
+	weight: ExtendedBalance,
+}
+
+#[cfg(test)]
+impl<AccountId: Clone> Edge<AccountId> {
+	fn new(candidate: Candidate<AccountId>, weight: ExtendedBalance) -> Self {
+		let who = candidate.who.clone();
+		let candidate = Rc::new(RefCell::new(candidate));
+		Self { weight, who, candidate, load: Default::default() }
+	}
+}
+
+#[cfg(feature = "std")]
+impl<A: IdentifierT> sp_std::fmt::Debug for Edge<A> {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		write!(f, "Edge({:?}, weight = {:?})", self.who, self.weight)
+	}
+}
+
+/// A voter entity.
+#[derive(Clone, Default)]
+pub struct Voter<AccountId> {
+	/// Identifier.
+	who: AccountId,
+	/// List of candidates approved by this voter.
+	edges: Vec<Edge<AccountId>>,
+	/// The stake of this voter.
+	budget: ExtendedBalance,
+	/// Load of the voter.
+	load: Rational128,
+}
+
+#[cfg(feature = "std")]
+impl<A: IdentifierT> std::fmt::Debug for Voter<A> {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		write!(f, "Voter({:?}, budget = {}, edges = {:?})", self.who, self.budget, self.edges)
+	}
+}
+
+impl<AccountId: IdentifierT> Voter<AccountId> {
+	/// Create a new `Voter`.
+	pub fn new(who: AccountId) -> Self {
+		Self {
+			who,
+			edges: Default::default(),
+			budget: Default::default(),
+			load: Default::default(),
+		}
+	}
+
+	/// Returns `true` if `self` votes for `target`.
+	///
+	/// Note that this does not take into account if `target` is elected (i.e. is *active*) or not.
+	pub fn votes_for(&self, target: &AccountId) -> bool {
+		self.edges.iter().any(|e| &e.who == target)
+	}
+
+	/// Returns none if this voter does not have any non-zero distributions.
+	///
+	/// Note that this might create _un-normalized_ assignments, due to accuracy loss of `P`. Call
+	/// site might compensate by calling `normalize()` on the returned `Assignment` as a
+	/// post-processing.
+	pub fn into_assignment<P: PerThing>(self) -> Option<Assignment<AccountId, P>> {
+		let who = self.who;
+		let budget = self.budget;
+		let distribution = self
+			.edges
+			.into_iter()
+			.filter_map(|e| {
+				let per_thing = P::from_rational(e.weight, budget);
+				// trim zero edges.
+				if per_thing.is_zero() {
+					None
+				} else {
+					Some((e.who, per_thing))
+				}
+			})
+			.collect::<Vec<_>>();
+
+		if distribution.len() > 0 {
+			Some(Assignment { who, distribution })
+		} else {
+			None
+		}
+	}
+
+	/// Try and normalize the votes of self.
+	///
+	/// If the normalization is successful then `Ok(())` is returned.
+	///
+	/// Note that this will not distinguish between elected and unelected edges. Thus, it should
+	/// only be called on a voter who has already been reduced to only elected edges.
+	///
+	/// ### Errors
+	///
+	/// This will return only if the internal `normalize` fails. This can happen if the sum of the
+	/// weights exceeds `ExtendedBalance::max_value()`.
+	pub fn try_normalize(&mut self) -> Result<(), &'static str> {
+		let edge_weights = self.edges.iter().map(|e| e.weight).collect::<Vec<_>>();
+		edge_weights.normalize(self.budget).map(|normalized| {
+			// here we count on the fact that normalize does not change the order.
+			for (edge, corrected) in self.edges.iter_mut().zip(normalized.into_iter()) {
+				let mut candidate = edge.candidate.borrow_mut();
+				// first, subtract the incorrect weight
+				candidate.backed_stake = candidate.backed_stake.saturating_sub(edge.weight);
+				edge.weight = corrected;
+				// Then add the correct one again.
+				candidate.backed_stake = candidate.backed_stake.saturating_add(edge.weight);
+			}
+		})
+	}
+
+	/// Same as [`Self::try_normalize`] but the normalization is only limited between elected edges.
+	pub fn try_normalize_elected(&mut self) -> Result<(), &'static str> {
+		let elected_edge_weights = self
+			.edges
+			.iter()
+			.filter_map(|e| if e.candidate.borrow().elected { Some(e.weight) } else { None })
+			.collect::<Vec<_>>();
+		elected_edge_weights.normalize(self.budget).map(|normalized| {
+			// here we count on the fact that normalize does not change the order, and that vector
+			// iteration is deterministic.
+			for (edge, corrected) in self
+				.edges
+				.iter_mut()
+				.filter(|e| e.candidate.borrow().elected)
+				.zip(normalized.into_iter())
+			{
+				let mut candidate = edge.candidate.borrow_mut();
+				// first, subtract the incorrect weight
+				candidate.backed_stake = candidate.backed_stake.saturating_sub(edge.weight);
+				edge.weight = corrected;
+				// Then add the correct one again.
+				candidate.backed_stake = candidate.backed_stake.saturating_add(edge.weight);
+			}
+		})
+	}
+
+	/// This voter's budget.
+	#[inline]
+	pub fn budget(&self) -> ExtendedBalance {
+		self.budget
+	}
+}
+
+/// Final result of the election.
+#[derive(RuntimeDebug)]
+pub struct ElectionResult<AccountId, P: PerThing> {
+	/// Just winners zipped with their approval stake. Note that the approval stake is merely the
+	/// sub of their received stake and could be used for very basic sorting and approval voting.
+	pub winners: Vec<(AccountId, ExtendedBalance)>,
+	/// Individual assignments. for each tuple, the first elements is a voter and the second is the
+	/// list of candidates that it supports.
+	pub assignments: Vec<Assignment<AccountId, P>>,
+}
+
+/// A structure to demonstrate the election result from the perspective of the candidate, i.e. how
+/// much support each candidate is receiving.
+///
+/// This complements the [`ElectionResult`] and is needed to run the balancing post-processing.
+///
+/// This, at the current version, resembles the `Exposure` defined in the Staking pallet, yet they
+/// do not necessarily have to be the same.
+#[derive(RuntimeDebug, Encode, Decode, Clone, Eq, PartialEq, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct Support<AccountId> {
+	/// Total support.
+	pub total: ExtendedBalance,
+	/// Support from voters.
+	pub voters: Vec<(AccountId, ExtendedBalance)>,
+}
+
+impl<AccountId> Default for Support<AccountId> {
+	fn default() -> Self {
+		Self { total: Default::default(), voters: vec![] }
+	}
+}
+
+/// A target-major representation of the the election outcome.
+///
+/// Essentially a flat variant of [`SupportMap`].
+///
+/// The main advantage of this is that it is encodable.
+pub type Supports<A> = Vec<(A, Support<A>)>;
+
+/// Same as `Supports` but bounded by `B`.
+///
+/// To note, the inner `Support` is still unbounded.
+pub type BoundedSupports<A, B> = BoundedVec<(A, Support<A>), B>;
+
+/// Linkage from a winner to their [`Support`].
+///
+/// This is more helpful than a normal [`Supports`] as it allows faster error checking.
+pub type SupportMap<A> = BTreeMap<A, Support<A>>;
+
+/// Build the support map from the assignments.
+pub fn to_support_map<AccountId: IdentifierT>(
+	assignments: &[StakedAssignment<AccountId>],
+) -> SupportMap<AccountId> {
+	let mut supports = <BTreeMap<AccountId, Support<AccountId>>>::new();
+
+	// build support struct.
+	for StakedAssignment { who, distribution } in assignments.iter() {
+		for (c, weight_extended) in distribution.iter() {
+			let support = supports.entry(c.clone()).or_default();
+			support.total = support.total.saturating_add(*weight_extended);
+			support.voters.push((who.clone(), *weight_extended));
+		}
+	}
+
+	supports
+}
+
+/// Same as [`to_support_map`] except it returns a
+/// flat vector.
+pub fn to_supports<AccountId: IdentifierT>(
+	assignments: &[StakedAssignment<AccountId>],
+) -> Supports<AccountId> {
+	to_support_map(assignments).into_iter().collect()
+}
+
+/// Extension trait for evaluating a support map or vector.
+pub trait EvaluateSupport {
+	/// Evaluate a support map. The returned tuple contains:
+	///
+	/// - Minimum support. This value must be **maximized**.
+	/// - Sum of all supports. This value must be **maximized**.
+	/// - Sum of all supports squared. This value must be **minimized**.
+	fn evaluate(&self) -> ElectionScore;
+}
+
+impl<AccountId: IdentifierT> EvaluateSupport for Supports<AccountId> {
+	fn evaluate(&self) -> ElectionScore {
+		let mut minimal_stake = ExtendedBalance::max_value();
+		let mut sum_stake: ExtendedBalance = Zero::zero();
+		// NOTE: The third element might saturate but fine for now since this will run on-chain and
+		// need to be fast.
+		let mut sum_stake_squared: ExtendedBalance = Zero::zero();
+
+		for (_, support) in self {
+			sum_stake = sum_stake.saturating_add(support.total);
+			let squared = support.total.saturating_mul(support.total);
+			sum_stake_squared = sum_stake_squared.saturating_add(squared);
+			if support.total < minimal_stake {
+				minimal_stake = support.total;
+			}
+		}
+
+		ElectionScore { minimal_stake, sum_stake, sum_stake_squared }
+	}
+}
+
+/// Converts raw inputs to types used in this crate.
+///
+/// This will perform some cleanup that are most often important:
+/// - It drops any votes that are pointing to non-candidates.
+/// - It drops duplicate targets within a voter.
+pub fn setup_inputs<AccountId: IdentifierT>(
+	initial_candidates: Vec<AccountId>,
+	initial_voters: Vec<(AccountId, VoteWeight, impl IntoIterator<Item = AccountId>)>,
+) -> (Vec<CandidatePtr<AccountId>>, Vec<Voter<AccountId>>) {
+	// used to cache and access candidates index.
+	let mut c_idx_cache = BTreeMap::<AccountId, usize>::new();
+
+	let candidates = initial_candidates
+		.into_iter()
+		.enumerate()
+		.map(|(idx, who)| {
+			c_idx_cache.insert(who.clone(), idx);
+			Candidate {
+				who,
+				score: Default::default(),
+				approval_stake: Default::default(),
+				backed_stake: Default::default(),
+				elected: Default::default(),
+				round: Default::default(),
+			}
+			.to_ptr()
+		})
+		.collect::<Vec<CandidatePtr<AccountId>>>();
+
+	let voters = initial_voters
+		.into_iter()
+		.filter_map(|(who, voter_stake, votes)| {
+			let mut edges: Vec<Edge<AccountId>> = Vec::new();
+			for v in votes {
+				if edges.iter().any(|e| e.who == v) {
+					// duplicate edge.
+					continue
+				}
+				if let Some(idx) = c_idx_cache.get(&v) {
+					// This candidate is valid + already cached.
+					let mut candidate = candidates[*idx].borrow_mut();
+					candidate.approval_stake =
+						candidate.approval_stake.saturating_add(voter_stake.into());
+					edges.push(Edge {
+						who: v.clone(),
+						candidate: Rc::clone(&candidates[*idx]),
+						load: Default::default(),
+						weight: Default::default(),
+					});
+				} // else {} would be wrong votes. We don't really care about it.
+			}
+			if edges.is_empty() {
+				None
+			} else {
+				Some(Voter { who, edges, budget: voter_stake.into(), load: Rational128::zero() })
+			}
+		})
+		.collect::<Vec<_>>();
+
+	(candidates, voters)
+}
diff --git a/substrate/primitives/npos-elections/src/mock.rs b/substrate/primitives/npos-elections/src/mock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2fc49fd72cd03874c33ddfab637eb1870a3d52dc
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/mock.rs
@@ -0,0 +1,386 @@
+// 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.
+
+//! Mock file for npos-elections.
+
+#![cfg(test)]
+
+use sp_arithmetic::{
+	traits::{One, SaturatedConversion, Zero},
+	PerThing,
+};
+use sp_runtime::assert_eq_error_rate;
+use sp_std::collections::btree_map::BTreeMap;
+
+use crate::{seq_phragmen, Assignment, ElectionResult, ExtendedBalance, PerThing128, VoteWeight};
+
+pub type AccountId = u64;
+
+#[derive(Default, Debug)]
+pub(crate) struct _Candidate<A> {
+	who: A,
+	score: f64,
+	approval_stake: f64,
+	elected: bool,
+}
+
+#[derive(Default, Debug)]
+pub(crate) struct _Voter<A> {
+	who: A,
+	edges: Vec<_Edge<A>>,
+	budget: f64,
+	load: f64,
+}
+
+#[derive(Default, Debug)]
+pub(crate) struct _Edge<A> {
+	who: A,
+	load: f64,
+	candidate_index: usize,
+}
+
+#[derive(Default, Debug, PartialEq)]
+pub(crate) struct _Support<A> {
+	pub own: f64,
+	pub total: f64,
+	pub others: Vec<_Assignment<A>>,
+}
+
+pub(crate) type _Assignment<A> = (A, f64);
+pub(crate) type _SupportMap<A> = BTreeMap<A, _Support<A>>;
+
+#[derive(Debug, Clone)]
+pub(crate) struct _ElectionResult<A: Clone> {
+	pub winners: Vec<(A, ExtendedBalance)>,
+	pub assignments: Vec<(A, Vec<_Assignment<A>>)>,
+}
+
+pub(crate) fn auto_generate_self_voters<A: Clone>(candidates: &[A]) -> Vec<(A, Vec<A>)> {
+	candidates.iter().map(|c| (c.clone(), vec![c.clone()])).collect()
+}
+
+pub(crate) fn elect_float<A>(
+	candidate_count: usize,
+	initial_candidates: Vec<A>,
+	initial_voters: Vec<(A, Vec<A>)>,
+	stake_of: impl Fn(&A) -> VoteWeight,
+) -> Option<_ElectionResult<A>>
+where
+	A: Default + Ord + Copy,
+{
+	let mut elected_candidates: Vec<(A, ExtendedBalance)>;
+	let mut assigned: Vec<(A, Vec<_Assignment<A>>)>;
+	let mut c_idx_cache = BTreeMap::<A, usize>::new();
+	let num_voters = initial_candidates.len() + initial_voters.len();
+	let mut voters: Vec<_Voter<A>> = Vec::with_capacity(num_voters);
+
+	let mut candidates = initial_candidates
+		.into_iter()
+		.enumerate()
+		.map(|(idx, who)| {
+			c_idx_cache.insert(who, idx);
+			_Candidate { who, ..Default::default() }
+		})
+		.collect::<Vec<_Candidate<A>>>();
+
+	voters.extend(initial_voters.into_iter().map(|(who, votes)| {
+		let voter_stake = stake_of(&who) as f64;
+		let mut edges: Vec<_Edge<A>> = Vec::with_capacity(votes.len());
+		for v in votes {
+			if let Some(idx) = c_idx_cache.get(&v) {
+				candidates[*idx].approval_stake = candidates[*idx].approval_stake + voter_stake;
+				edges.push(_Edge { who: v, candidate_index: *idx, ..Default::default() });
+			}
+		}
+		_Voter { who, edges, budget: voter_stake, load: 0f64 }
+	}));
+
+	let to_elect = candidate_count.min(candidates.len());
+	elected_candidates = Vec::with_capacity(candidate_count);
+	assigned = Vec::with_capacity(candidate_count);
+
+	for _round in 0..to_elect {
+		for c in &mut candidates {
+			if !c.elected {
+				c.score = 1.0 / c.approval_stake;
+			}
+		}
+		for n in &voters {
+			for e in &n.edges {
+				let c = &mut candidates[e.candidate_index];
+				if !c.elected && !(c.approval_stake == 0f64) {
+					c.score += n.budget * n.load / c.approval_stake;
+				}
+			}
+		}
+
+		if let Some(winner) = candidates
+			.iter_mut()
+			.filter(|c| !c.elected)
+			.min_by(|x, y| x.score.partial_cmp(&y.score).unwrap_or(sp_std::cmp::Ordering::Equal))
+		{
+			winner.elected = true;
+			for n in &mut voters {
+				for e in &mut n.edges {
+					if e.who == winner.who {
+						e.load = winner.score - n.load;
+						n.load = winner.score;
+					}
+				}
+			}
+
+			elected_candidates.push((winner.who, winner.approval_stake as ExtendedBalance));
+		} else {
+			break
+		}
+	}
+
+	for n in &mut voters {
+		let mut assignment = (n.who, vec![]);
+		for e in &mut n.edges {
+			if let Some(c) =
+				elected_candidates.iter().cloned().map(|(c, _)| c).find(|c| *c == e.who)
+			{
+				if c != n.who {
+					let ratio = e.load / n.load;
+					assignment.1.push((e.who, ratio));
+				}
+			}
+		}
+		if assignment.1.len() > 0 {
+			assigned.push(assignment);
+		}
+	}
+
+	Some(_ElectionResult { winners: elected_candidates, assignments: assigned })
+}
+
+pub(crate) fn equalize_float<A, FS>(
+	mut assignments: Vec<(A, Vec<_Assignment<A>>)>,
+	supports: &mut _SupportMap<A>,
+	tolerance: f64,
+	iterations: usize,
+	stake_of: FS,
+) where
+	for<'r> FS: Fn(&'r A) -> VoteWeight,
+	A: Ord + Clone + std::fmt::Debug,
+{
+	for _i in 0..iterations {
+		let mut max_diff = 0.0;
+		for (voter, assignment) in assignments.iter_mut() {
+			let voter_budget = stake_of(&voter);
+			let diff = do_equalize_float(voter, voter_budget, assignment, supports, tolerance);
+			if diff > max_diff {
+				max_diff = diff;
+			}
+		}
+
+		if max_diff < tolerance {
+			break
+		}
+	}
+}
+
+pub(crate) fn do_equalize_float<A>(
+	voter: &A,
+	budget_balance: VoteWeight,
+	elected_edges: &mut Vec<_Assignment<A>>,
+	support_map: &mut _SupportMap<A>,
+	tolerance: f64,
+) -> f64
+where
+	A: Ord + Clone,
+{
+	let budget = budget_balance as f64;
+	if elected_edges.is_empty() {
+		return 0.0
+	}
+
+	let stake_used = elected_edges.iter().fold(0.0, |s, e| s + e.1);
+
+	let backed_stakes_iter =
+		elected_edges.iter().filter_map(|e| support_map.get(&e.0)).map(|e| e.total);
+
+	let backing_backed_stake = elected_edges
+		.iter()
+		.filter(|e| e.1 > 0.0)
+		.filter_map(|e| support_map.get(&e.0))
+		.map(|e| e.total)
+		.collect::<Vec<f64>>();
+
+	let mut difference;
+	if backing_backed_stake.len() > 0 {
+		let max_stake = backing_backed_stake
+			.iter()
+			.max_by(|x, y| x.partial_cmp(&y).unwrap_or(sp_std::cmp::Ordering::Equal))
+			.expect("vector with positive length will have a max; qed");
+		let min_stake = backed_stakes_iter
+			.min_by(|x, y| x.partial_cmp(&y).unwrap_or(sp_std::cmp::Ordering::Equal))
+			.expect("iterator with positive length will have a min; qed");
+
+		difference = max_stake - min_stake;
+		difference = difference + budget - stake_used;
+		if difference < tolerance {
+			return difference
+		}
+	} else {
+		difference = budget;
+	}
+
+	// Undo updates to support
+	elected_edges.iter_mut().for_each(|e| {
+		if let Some(support) = support_map.get_mut(&e.0) {
+			support.total = support.total - e.1;
+			support.others.retain(|i_support| i_support.0 != *voter);
+		}
+		e.1 = 0.0;
+	});
+
+	elected_edges.sort_by(|x, y| {
+		support_map
+			.get(&x.0)
+			.and_then(|x| support_map.get(&y.0).and_then(|y| x.total.partial_cmp(&y.total)))
+			.unwrap_or(sp_std::cmp::Ordering::Equal)
+	});
+
+	let mut cumulative_stake = 0.0;
+	let mut last_index = elected_edges.len() - 1;
+	elected_edges.iter_mut().enumerate().for_each(|(idx, e)| {
+		if let Some(support) = support_map.get_mut(&e.0) {
+			let stake = support.total;
+			let stake_mul = stake * (idx as f64);
+			let stake_sub = stake_mul - cumulative_stake;
+			if stake_sub > budget {
+				last_index = idx.checked_sub(1).unwrap_or(0);
+				return
+			}
+			cumulative_stake = cumulative_stake + stake;
+		}
+	});
+
+	let last_stake = elected_edges[last_index].1;
+	let split_ways = last_index + 1;
+	let excess = budget + cumulative_stake - last_stake * (split_ways as f64);
+	elected_edges.iter_mut().take(split_ways).for_each(|e| {
+		if let Some(support) = support_map.get_mut(&e.0) {
+			e.1 = excess / (split_ways as f64) + last_stake - support.total;
+			support.total = support.total + e.1;
+			support.others.push((voter.clone(), e.1));
+		}
+	});
+
+	difference
+}
+
+pub(crate) fn create_stake_of(
+	stakes: &[(AccountId, VoteWeight)],
+) -> impl Fn(&AccountId) -> VoteWeight {
+	let mut storage = BTreeMap::<AccountId, VoteWeight>::new();
+	stakes.iter().for_each(|s| {
+		storage.insert(s.0, s.1);
+	});
+	move |who: &AccountId| -> VoteWeight { storage.get(who).unwrap().to_owned() }
+}
+
+pub fn check_assignments_sum<T: PerThing>(assignments: &[Assignment<AccountId, T>]) {
+	for Assignment { distribution, .. } in assignments {
+		let mut sum: u128 = Zero::zero();
+		distribution
+			.iter()
+			.for_each(|(_, p)| sum += p.deconstruct().saturated_into::<u128>());
+		assert_eq!(sum, T::ACCURACY.saturated_into(), "Assignment ratio sum is not 100%");
+	}
+}
+
+pub(crate) fn run_and_compare<Output: PerThing128, FS>(
+	candidates: Vec<AccountId>,
+	voters: Vec<(AccountId, Vec<AccountId>)>,
+	stake_of: FS,
+	to_elect: usize,
+) where
+	Output: PerThing128,
+	FS: Fn(&AccountId) -> VoteWeight,
+{
+	// run fixed point code.
+	let ElectionResult::<_, Output> { winners, assignments } = seq_phragmen(
+		to_elect,
+		candidates.clone(),
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	// run float poc code.
+	let truth_value = elect_float(to_elect, candidates, voters, &stake_of).unwrap();
+
+	assert_eq!(
+		winners.iter().map(|(x, _)| x).collect::<Vec<_>>(),
+		truth_value.winners.iter().map(|(x, _)| x).collect::<Vec<_>>()
+	);
+
+	for Assignment { who, distribution } in assignments.iter() {
+		if let Some(float_assignments) = truth_value.assignments.iter().find(|x| x.0 == *who) {
+			for (candidate, per_thingy) in distribution {
+				if let Some(float_assignment) =
+					float_assignments.1.iter().find(|x| x.0 == *candidate)
+				{
+					assert_eq_error_rate!(
+						Output::from_float(float_assignment.1).deconstruct(),
+						per_thingy.deconstruct(),
+						Output::Inner::one(),
+					);
+				} else {
+					panic!(
+						"candidate mismatch. This should never happen. could not find ({:?}, {:?})",
+						candidate, per_thingy,
+					)
+				}
+			}
+		} else {
+			panic!("nominator mismatch. This should never happen.")
+		}
+	}
+
+	check_assignments_sum(&assignments);
+}
+
+pub(crate) fn build_support_map_float(
+	result: &mut _ElectionResult<AccountId>,
+	stake_of: impl Fn(&AccountId) -> VoteWeight,
+) -> _SupportMap<AccountId> {
+	let mut supports = <_SupportMap<AccountId>>::new();
+	result.winners.iter().map(|(e, _)| (e, stake_of(e) as f64)).for_each(|(e, s)| {
+		let item = _Support { own: s, total: s, ..Default::default() };
+		supports.insert(*e, item);
+	});
+
+	for (n, assignment) in result.assignments.iter_mut() {
+		for (c, r) in assignment.iter_mut() {
+			let nominator_stake = stake_of(n) as f64;
+			let other_stake = nominator_stake * *r;
+			if let Some(support) = supports.get_mut(c) {
+				support.total = support.total + other_stake;
+				support.others.push((*n, other_stake));
+			}
+			*r = other_stake;
+		}
+	}
+	supports
+}
diff --git a/substrate/primitives/npos-elections/src/node.rs b/substrate/primitives/npos-elections/src/node.rs
new file mode 100644
index 0000000000000000000000000000000000000000..caca9561d83970ec935ce8dc86d4415280dedfea
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/node.rs
@@ -0,0 +1,260 @@
+// 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.
+
+//! (very) Basic implementation of a graph node used in the reduce algorithm.
+
+use sp_std::{cell::RefCell, fmt, prelude::*, rc::Rc};
+
+/// The role that a node can accept.
+#[derive(PartialEq, Eq, Ord, PartialOrd, Clone, Debug)]
+pub(crate) enum NodeRole {
+	/// A voter. This is synonym to a nominator in a staking context.
+	Voter,
+	/// A target. This is synonym to a candidate/validator in a staking context.
+	Target,
+}
+
+pub(crate) type RefCellOf<T> = Rc<RefCell<T>>;
+pub(crate) type NodeRef<A> = RefCellOf<Node<A>>;
+
+/// Identifier of a node. This is particularly handy to have a proper `PartialEq` implementation.
+/// Otherwise, self votes wouldn't have been indistinguishable.
+#[derive(PartialOrd, Ord, Clone, PartialEq, Eq)]
+pub(crate) struct NodeId<A> {
+	/// An account-like identifier representing the node.
+	pub who: A,
+	/// The role of the node.
+	pub role: NodeRole,
+}
+
+impl<A> NodeId<A> {
+	/// Create a new [`NodeId`].
+	pub fn from(who: A, role: NodeRole) -> Self {
+		Self { who, role }
+	}
+}
+
+#[cfg(feature = "std")]
+impl<A: fmt::Debug> sp_std::fmt::Debug for NodeId<A> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		write!(
+			f,
+			"Node({:?}, {:?})",
+			self.who,
+			if self.role == NodeRole::Voter { "V" } else { "T" }
+		)
+	}
+}
+
+/// A one-way graph note. This can only store a pointer to its parent.
+#[derive(Clone)]
+pub(crate) struct Node<A> {
+	/// The identifier of the note.
+	pub(crate) id: NodeId<A>,
+	/// The parent pointer.
+	pub(crate) parent: Option<NodeRef<A>>,
+}
+
+impl<A: PartialEq> PartialEq for Node<A> {
+	fn eq(&self, other: &Node<A>) -> bool {
+		self.id == other.id
+	}
+}
+
+impl<A: PartialEq> Eq for Node<A> {}
+
+#[cfg(feature = "std")]
+impl<A: fmt::Debug + Clone> fmt::Debug for Node<A> {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		write!(f, "({:?} --> {:?})", self.id, self.parent.as_ref().map(|p| p.borrow().id.clone()))
+	}
+}
+
+impl<A: PartialEq + Eq + Clone + fmt::Debug> Node<A> {
+	/// Create a new [`Node`]
+	pub fn new(id: NodeId<A>) -> Node<A> {
+		Self { id, parent: None }
+	}
+
+	/// Returns true if `other` is the parent of `who`.
+	pub fn is_parent_of(who: &NodeRef<A>, other: &NodeRef<A>) -> bool {
+		if who.borrow().parent.is_none() {
+			return false
+		}
+		who.borrow().parent.as_ref() == Some(other)
+	}
+
+	/// Removes the parent of `who`.
+	pub fn remove_parent(who: &NodeRef<A>) {
+		who.borrow_mut().parent = None;
+	}
+
+	/// Sets `who`'s parent to be `parent`.
+	pub fn set_parent_of(who: &NodeRef<A>, parent: &NodeRef<A>) {
+		who.borrow_mut().parent = Some(parent.clone());
+	}
+
+	/// Finds the root of `start`. It return a tuple of `(root, root_vec)` where `root_vec` is the
+	/// vector of Nodes leading to the root. Hence the first element is the start itself and the
+	/// last one is the root. As convenient, the root itself is also returned as the first element
+	/// of the tuple.
+	///
+	/// This function detects cycles and breaks as soon a duplicate node is visited, returning the
+	/// cycle up to but not including the duplicate node.
+	///
+	/// If you are certain that no cycles exist, you can use [`root_unchecked`].
+	pub fn root(start: &NodeRef<A>) -> (NodeRef<A>, Vec<NodeRef<A>>) {
+		let mut parent_path: Vec<NodeRef<A>> = Vec::new();
+		let mut visited: Vec<NodeRef<A>> = Vec::new();
+
+		parent_path.push(start.clone());
+		visited.push(start.clone());
+		let mut current = start.clone();
+
+		while let Some(ref next_parent) = current.clone().borrow().parent {
+			if visited.contains(next_parent) {
+				break
+			}
+			parent_path.push(next_parent.clone());
+			current = next_parent.clone();
+			visited.push(current.clone());
+		}
+
+		(current, parent_path)
+	}
+
+	/// Consumes self and wraps it in a `Rc<RefCell<T>>`. This type can be used as the pointer type
+	/// to a parent node.
+	pub fn into_ref(self) -> NodeRef<A> {
+		Rc::from(RefCell::from(self))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	fn id(i: u32) -> NodeId<u32> {
+		NodeId::from(i, NodeRole::Target)
+	}
+
+	#[test]
+	fn basic_create_works() {
+		let node = Node::new(id(10));
+		assert_eq!(node, Node { id: NodeId { who: 10, role: NodeRole::Target }, parent: None });
+	}
+
+	#[test]
+	fn set_parent_works() {
+		let a = Node::new(id(10)).into_ref();
+		let b = Node::new(id(20)).into_ref();
+
+		assert_eq!(a.borrow().parent, None);
+		Node::set_parent_of(&a, &b);
+		assert_eq!(*a.borrow().parent.as_ref().unwrap(), b);
+	}
+
+	#[test]
+	fn get_root_singular() {
+		let a = Node::new(id(1)).into_ref();
+		assert_eq!(Node::root(&a), (a.clone(), vec![a.clone()]));
+	}
+
+	#[test]
+	fn get_root_works() {
+		// 	D <-- A <-- B <-- C
+		// 			\
+		// 			 <-- E
+		let a = Node::new(id(1)).into_ref();
+		let b = Node::new(id(2)).into_ref();
+		let c = Node::new(id(3)).into_ref();
+		let d = Node::new(id(4)).into_ref();
+		let e = Node::new(id(5)).into_ref();
+		let f = Node::new(id(6)).into_ref();
+
+		Node::set_parent_of(&c, &b);
+		Node::set_parent_of(&b, &a);
+		Node::set_parent_of(&e, &a);
+		Node::set_parent_of(&a, &d);
+
+		assert_eq!(Node::root(&e), (d.clone(), vec![e.clone(), a.clone(), d.clone()]));
+
+		assert_eq!(Node::root(&a), (d.clone(), vec![a.clone(), d.clone()]));
+
+		assert_eq!(Node::root(&c), (d.clone(), vec![c.clone(), b.clone(), a.clone(), d.clone()]));
+
+		// 	D 	    A <-- B <-- C
+		// 	F <-- /	\
+		// 			 <-- E
+		Node::set_parent_of(&a, &f);
+
+		assert_eq!(Node::root(&a), (f.clone(), vec![a.clone(), f.clone()]));
+
+		assert_eq!(Node::root(&c), (f.clone(), vec![c.clone(), b.clone(), a.clone(), f.clone()]));
+	}
+
+	#[test]
+	fn get_root_on_cycle() {
+		// A ---> B
+		// |      |
+		//  <---- C
+		let a = Node::new(id(1)).into_ref();
+		let b = Node::new(id(2)).into_ref();
+		let c = Node::new(id(3)).into_ref();
+
+		Node::set_parent_of(&a, &b);
+		Node::set_parent_of(&b, &c);
+		Node::set_parent_of(&c, &a);
+
+		let (root, path) = Node::root(&a);
+		assert_eq!(root, c);
+		assert_eq!(path.clone(), vec![a.clone(), b.clone(), c.clone()]);
+	}
+
+	#[test]
+	fn get_root_on_cycle_2() {
+		// A ---> B
+		// |   |  |
+		//     - C
+		let a = Node::new(id(1)).into_ref();
+		let b = Node::new(id(2)).into_ref();
+		let c = Node::new(id(3)).into_ref();
+
+		Node::set_parent_of(&a, &b);
+		Node::set_parent_of(&b, &c);
+		Node::set_parent_of(&c, &b);
+
+		let (root, path) = Node::root(&a);
+		assert_eq!(root, c);
+		assert_eq!(path.clone(), vec![a.clone(), b.clone(), c.clone()]);
+	}
+
+	#[test]
+	fn node_cmp_stack_overflows_on_non_unique_elements() {
+		// To make sure we don't stack overflow on duplicate who. This needs manual impl of
+		// PartialEq.
+		let a = Node::new(id(1)).into_ref();
+		let b = Node::new(id(2)).into_ref();
+		let c = Node::new(id(3)).into_ref();
+
+		Node::set_parent_of(&a, &b);
+		Node::set_parent_of(&b, &c);
+		Node::set_parent_of(&c, &a);
+
+		Node::root(&a);
+	}
+}
diff --git a/substrate/primitives/npos-elections/src/phragmen.rs b/substrate/primitives/npos-elections/src/phragmen.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c3578065f364cd9eac0a82bc7c6bbf5daef3b632
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/phragmen.rs
@@ -0,0 +1,212 @@
+// 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.
+
+//! Implementation of the sequential-phragmen election method.
+//!
+//! This method is ensured to achieve PJR, yet, it does not achieve a constant factor approximation
+//! to the Maximin problem.
+
+use crate::{
+	balancing, setup_inputs, BalancingConfig, CandidatePtr, ElectionResult, ExtendedBalance,
+	IdentifierT, PerThing128, VoteWeight, Voter,
+};
+use sp_arithmetic::{
+	helpers_128bit::multiply_by_rational_with_rounding,
+	traits::{Bounded, Zero},
+	Rational128, Rounding,
+};
+use sp_std::prelude::*;
+
+/// The denominator used for loads. Since votes are collected as u64, the smallest ratio that we
+/// might collect is `1/approval_stake` where approval stake is the sum of votes. Hence, some number
+/// bigger than u64::MAX is needed. For maximum accuracy we simply use u128;
+const DEN: ExtendedBalance = ExtendedBalance::max_value();
+
+/// Execute sequential phragmen with potentially some rounds of `balancing`. The return type is list
+/// of winners and a weight distribution vector of all voters who contribute to the winners.
+///
+/// - This function is a best effort to elect `rounds` members. Nonetheless, if less candidates are
+///   available, it will only return what is available. It is the responsibility of the call site to
+///   ensure they have provided enough members.
+/// - If `balance` parameter is `Some(i, t)`, `i` iterations of balancing is with tolerance `t` is
+///   performed.
+/// - Returning winners are sorted based on desirability. Voters are unsorted. Nonetheless,
+///   seq-phragmen is in general an un-ranked election and the desirability should not be
+///   interpreted with any significance.
+/// - The returning winners are zipped with their final backing stake. Yet, to get the exact final
+///   weight distribution from the winner's point of view, one needs to build a support map. See
+///   [`crate::SupportMap`] for more info. Note that this backing stake is computed in
+///   ExtendedBalance and may be slightly different that what will be computed from the support map,
+///   due to accuracy loss.
+/// - The accuracy of the returning edge weight ratios can be configured via the `P` generic
+///   argument.
+/// - The returning weight distribution is _normalized_, meaning that it is guaranteed that the sum
+///   of the ratios in each voter's distribution sums up to exactly `P::one()`.
+///
+/// This can only fail of the normalization fails. This can happen if for any of the resulting
+/// assignments, `assignment.distribution.map(|p| p.deconstruct()).sum()` fails to fit inside
+/// `UpperOf<P>`. A user of this crate may statically assert that this can never happen and safely
+/// `expect` this to return `Ok`.
+///
+/// This can only fail if the normalization fails.
+///
+/// Note that rounding errors can potentially cause the output of this function to fail a t-PJR
+/// check where t is the standard threshold. The underlying algorithm is sound, but the conversions
+/// between numeric types can be lossy.
+pub fn seq_phragmen<AccountId: IdentifierT, P: PerThing128>(
+	to_elect: usize,
+	candidates: Vec<AccountId>,
+	voters: Vec<(AccountId, VoteWeight, impl IntoIterator<Item = AccountId>)>,
+	balancing: Option<BalancingConfig>,
+) -> Result<ElectionResult<AccountId, P>, crate::Error> {
+	let (candidates, voters) = setup_inputs(candidates, voters);
+
+	let (candidates, mut voters) = seq_phragmen_core::<AccountId>(to_elect, candidates, voters)?;
+
+	if let Some(ref config) = balancing {
+		// NOTE: might create zero-edges, but we will strip them again when we convert voter into
+		// assignment.
+		let _iters = balancing::balance::<AccountId>(&mut voters, config);
+	}
+
+	let mut winners = candidates
+		.into_iter()
+		.filter(|c_ptr| c_ptr.borrow().elected)
+		// defensive only: seq-phragmen-core returns only up to rounds.
+		.take(to_elect)
+		.collect::<Vec<_>>();
+
+	// sort winners based on desirability.
+	winners.sort_by_key(|c_ptr| c_ptr.borrow().round);
+
+	let mut assignments =
+		voters.into_iter().filter_map(|v| v.into_assignment()).collect::<Vec<_>>();
+	let _ = assignments
+		.iter_mut()
+		.try_for_each(|a| a.try_normalize().map_err(crate::Error::ArithmeticError))?;
+	let winners = winners
+		.into_iter()
+		.map(|w_ptr| (w_ptr.borrow().who.clone(), w_ptr.borrow().backed_stake))
+		.collect();
+
+	Ok(ElectionResult { winners, assignments })
+}
+
+/// Core implementation of seq-phragmen.
+///
+/// This is the internal implementation that works with the types defined in this crate. see
+/// `seq_phragmen` for more information. This function is left public in case a crate needs to use
+/// the implementation in a custom way.
+///
+/// This can only fail if the normalization fails.
+// To create the inputs needed for this function, see [`crate::setup_inputs`].
+pub fn seq_phragmen_core<AccountId: IdentifierT>(
+	to_elect: usize,
+	candidates: Vec<CandidatePtr<AccountId>>,
+	mut voters: Vec<Voter<AccountId>>,
+) -> Result<(Vec<CandidatePtr<AccountId>>, Vec<Voter<AccountId>>), crate::Error> {
+	// we have already checked that we have more candidates than minimum_candidate_count.
+	let to_elect = to_elect.min(candidates.len());
+
+	// main election loop
+	for round in 0..to_elect {
+		// loop 1: initialize score
+		for c_ptr in &candidates {
+			let mut candidate = c_ptr.borrow_mut();
+			if !candidate.elected {
+				// 1 / approval_stake == (DEN / approval_stake) / DEN. If approval_stake is zero,
+				// then the ratio should be as large as possible, essentially `infinity`.
+				if candidate.approval_stake.is_zero() {
+					candidate.score = Bounded::max_value();
+				} else {
+					candidate.score = Rational128::from(DEN / candidate.approval_stake, DEN);
+				}
+			}
+		}
+
+		// loop 2: increment score
+		for voter in &voters {
+			for edge in &voter.edges {
+				let mut candidate = edge.candidate.borrow_mut();
+				if !candidate.elected && !candidate.approval_stake.is_zero() {
+					let temp_n = multiply_by_rational_with_rounding(
+						voter.load.n(),
+						voter.budget,
+						candidate.approval_stake,
+						Rounding::Down,
+					)
+					.unwrap_or(Bounded::max_value());
+					let temp_d = voter.load.d();
+					let temp = Rational128::from(temp_n, temp_d);
+					candidate.score = candidate.score.lazy_saturating_add(temp);
+				}
+			}
+		}
+
+		// loop 3: find the best
+		if let Some(winner_ptr) = candidates
+			.iter()
+			.filter(|c| !c.borrow().elected)
+			.min_by_key(|c| c.borrow().score)
+		{
+			let mut winner = winner_ptr.borrow_mut();
+			// loop 3: update voter and edge load
+			winner.elected = true;
+			winner.round = round;
+			for voter in &mut voters {
+				for edge in &mut voter.edges {
+					if edge.who == winner.who {
+						edge.load = winner.score.lazy_saturating_sub(voter.load);
+						voter.load = winner.score;
+					}
+				}
+			}
+		} else {
+			break
+		}
+	}
+
+	// update backing stake of candidates and voters
+	for voter in &mut voters {
+		for edge in &mut voter.edges {
+			if edge.candidate.borrow().elected {
+				// update internal state.
+				edge.weight = multiply_by_rational_with_rounding(
+					voter.budget,
+					edge.load.n(),
+					voter.load.n(),
+					Rounding::Down,
+				)
+				// If result cannot fit in u128. Not much we can do about it.
+				.unwrap_or(Bounded::max_value());
+			} else {
+				edge.weight = 0
+			}
+			let mut candidate = edge.candidate.borrow_mut();
+			candidate.backed_stake = candidate.backed_stake.saturating_add(edge.weight);
+		}
+
+		// remove all zero edges. These can become phantom edges during normalization.
+		voter.edges.retain(|e| e.weight > 0);
+		// edge of all candidates that eventually have a non-zero weight must be elected.
+		debug_assert!(voter.edges.iter().all(|e| e.candidate.borrow().elected));
+		// inc budget to sum the budget.
+		voter.try_normalize_elected().map_err(crate::Error::ArithmeticError)?;
+	}
+
+	Ok((candidates, voters))
+}
diff --git a/substrate/primitives/npos-elections/src/phragmms.rs b/substrate/primitives/npos-elections/src/phragmms.rs
new file mode 100644
index 0000000000000000000000000000000000000000..df6becf47472f6b6663f217ff6b8a08cd5bf78f9
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/phragmms.rs
@@ -0,0 +1,404 @@
+// 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.
+
+//! Implementation of the PhragMMS method.
+//!
+//! The naming comes from the fact that this method is highly inspired by Phragmen's method, yet it
+//! _also_ provides a constant factor approximation of the Maximin problem, similar to that of the
+//! MMS algorithm.
+
+use crate::{
+	balance, setup_inputs, BalancingConfig, CandidatePtr, ElectionResult, ExtendedBalance,
+	IdentifierT, PerThing128, VoteWeight, Voter,
+};
+use sp_arithmetic::{traits::Bounded, PerThing, Rational128};
+use sp_std::{prelude::*, rc::Rc};
+
+/// Execute the phragmms method.
+///
+/// This can be used interchangeably with `seq-phragmen` and offers a similar API, namely:
+///
+/// - The resulting edge weight distribution is normalized (thus, safe to use for submission).
+/// - The accuracy can be configured via the generic type `P`.
+/// - The algorithm is a _best-effort_ to elect `to_elect`. If less candidates are provided, less
+///   winners are returned, without an error.
+///
+/// This can only fail if the normalization fails. This can happen if for any of the resulting
+/// assignments, `assignment.distribution.map(|p| p.deconstruct()).sum()` fails to fit inside
+/// `UpperOf<P>`. A user of this crate may statically assert that this can never happen and safely
+/// `expect` this to return `Ok`.
+pub fn phragmms<AccountId: IdentifierT, P: PerThing128>(
+	to_elect: usize,
+	candidates: Vec<AccountId>,
+	voters: Vec<(AccountId, VoteWeight, impl IntoIterator<Item = AccountId>)>,
+	balancing: Option<BalancingConfig>,
+) -> Result<ElectionResult<AccountId, P>, crate::Error> {
+	let (candidates, mut voters) = setup_inputs(candidates, voters);
+
+	let mut winners = vec![];
+	for round in 0..to_elect {
+		if let Some(round_winner) = calculate_max_score::<AccountId, P>(&candidates, &voters) {
+			apply_elected::<AccountId>(&mut voters, Rc::clone(&round_winner));
+
+			round_winner.borrow_mut().round = round;
+			round_winner.borrow_mut().elected = true;
+			winners.push(round_winner);
+
+			if let Some(ref config) = balancing {
+				balance(&mut voters, config);
+			}
+		} else {
+			break
+		}
+	}
+
+	let mut assignments =
+		voters.into_iter().filter_map(|v| v.into_assignment()).collect::<Vec<_>>();
+	let _ = assignments
+		.iter_mut()
+		.try_for_each(|a| a.try_normalize())
+		.map_err(crate::Error::ArithmeticError)?;
+	let winners = winners
+		.into_iter()
+		.map(|w_ptr| (w_ptr.borrow().who.clone(), w_ptr.borrow().backed_stake))
+		.collect();
+
+	Ok(ElectionResult { winners, assignments })
+}
+
+/// Find the candidate that can yield the maximum score for this round.
+///
+/// Returns a new `Some(CandidatePtr)` to the winner candidate. The score of the candidate is
+/// updated and can be read from the returned pointer.
+///
+/// If no winner can be determined (i.e. everyone is already elected), then `None` is returned.
+///
+/// This is an internal part of the [`phragmms`].
+pub(crate) fn calculate_max_score<AccountId: IdentifierT, P: PerThing>(
+	candidates: &[CandidatePtr<AccountId>],
+	voters: &[Voter<AccountId>],
+) -> Option<CandidatePtr<AccountId>> {
+	for c_ptr in candidates.iter() {
+		let mut candidate = c_ptr.borrow_mut();
+		if !candidate.elected {
+			candidate.score = Rational128::from(1, P::ACCURACY.into());
+		}
+	}
+
+	for voter in voters.iter() {
+		let mut denominator_contribution: ExtendedBalance = 0;
+
+		// gather contribution from all elected edges.
+		for edge in voter.edges.iter() {
+			let edge_candidate = edge.candidate.borrow();
+			if edge_candidate.elected {
+				let edge_contribution: ExtendedBalance =
+					P::from_rational(edge.weight, edge_candidate.backed_stake).deconstruct().into();
+				denominator_contribution += edge_contribution;
+			}
+		}
+
+		// distribute to all _unelected_ edges.
+		for edge in voter.edges.iter() {
+			let mut edge_candidate = edge.candidate.borrow_mut();
+			if !edge_candidate.elected {
+				let prev_d = edge_candidate.score.d();
+				edge_candidate.score = Rational128::from(1, denominator_contribution + prev_d);
+			}
+		}
+	}
+
+	// finalise the score value, and find the best.
+	let mut best_score = Rational128::zero();
+	let mut best_candidate = None;
+
+	for c_ptr in candidates.iter() {
+		let mut candidate = c_ptr.borrow_mut();
+		if candidate.approval_stake > 0 {
+			// finalise the score value.
+			let score_d = candidate.score.d();
+			let one: ExtendedBalance = P::ACCURACY.into();
+			// Note: the accuracy here is questionable.
+			// First, let's consider what will happen if this saturates. In this case, two very
+			// whale-like validators will be effectively the same and their score will be equal.
+			// This is, more or less fine if the threshold of saturation is high and only a small
+			// subset or ever likely to become saturated. Once saturated, the score of these whales
+			// are effectively the same.
+			// Let's consider when this will happen. The approval stake of a target is the sum of
+			// stake of all the voter who have backed this target. Given the fact that the total
+			// issuance of a sane chain will fit in u128, it is safe to also assume that the
+			// approval stake will, since it is a subset of the total issuance at most.
+			// Finally, the only chance of overflow is multiplication by `one`. This highly depends
+			// on the `P` generic argument. With a PerBill and a 12 decimal token the maximum value
+			// that `candidate.approval_stake` can have is:
+			// (2 ** 128 - 1) / 10**9 / 10**12  = 340,282,366,920,938,463
+			// Assuming that each target will have 200,000 voters, then each voter's stake can be
+			// roughly:
+			// (2 ** 128 - 1) / 10**9 / 10**12 / 200000 = 1,701,411,834,604
+			//
+			// It is worth noting that these value would be _very_ different if one were to use
+			// `PerQuintill` as `P`. For now, we prefer the performance of using `Rational128` here.
+			// For the future, a properly benchmarked pull request can prove that using
+			// `RationalInfinite` as the score type does not introduce significant overhead. Then we
+			// can switch the score type to `RationalInfinite` and ensure compatibility with any
+			// crazy token scale.
+			let score_n =
+				candidate.approval_stake.checked_mul(one).unwrap_or_else(Bounded::max_value);
+			candidate.score = Rational128::from(score_n, score_d);
+
+			// check if we have a new winner.
+			if !candidate.elected && candidate.score > best_score {
+				best_score = candidate.score;
+				best_candidate = Some(Rc::clone(c_ptr));
+			}
+		} else {
+			candidate.score = Rational128::zero();
+		}
+	}
+
+	best_candidate
+}
+
+/// Update the weights of `voters` given that `elected_ptr` has been elected in the previous round.
+///
+/// Updates `voters` in place.
+///
+/// This is an internal part of the [`phragmms`] and should be called after
+/// [`calculate_max_score`].
+pub(crate) fn apply_elected<AccountId: IdentifierT>(
+	voters: &mut Vec<Voter<AccountId>>,
+	elected_ptr: CandidatePtr<AccountId>,
+) {
+	let elected_who = elected_ptr.borrow().who.clone();
+	let cutoff = elected_ptr
+		.borrow()
+		.score
+		.to_den(1)
+		.expect("(n / d) < u128::MAX and (n' / 1) == (n / d), thus n' < u128::MAX'; qed.")
+		.n();
+
+	let mut elected_backed_stake = elected_ptr.borrow().backed_stake;
+	for voter in voters {
+		if let Some(new_edge_index) = voter.edges.iter().position(|e| e.who == elected_who) {
+			let used_budget: ExtendedBalance = voter.edges.iter().map(|e| e.weight).sum();
+
+			let mut new_edge_weight = voter.budget.saturating_sub(used_budget);
+			elected_backed_stake = elected_backed_stake.saturating_add(new_edge_weight);
+
+			// Iterate over all other edges.
+			for (_, edge) in
+				voter.edges.iter_mut().enumerate().filter(|(edge_index, edge_inner)| {
+					*edge_index != new_edge_index && edge_inner.weight > 0
+				}) {
+				let mut edge_candidate = edge.candidate.borrow_mut();
+				if edge_candidate.backed_stake > cutoff {
+					let stake_to_take =
+						edge.weight.saturating_mul(cutoff) / edge_candidate.backed_stake.max(1);
+
+					// subtract this amount from this edge.
+					edge.weight = edge.weight.saturating_sub(stake_to_take);
+					edge_candidate.backed_stake =
+						edge_candidate.backed_stake.saturating_sub(stake_to_take);
+
+					// inject it into the outer loop's edge.
+					elected_backed_stake = elected_backed_stake.saturating_add(stake_to_take);
+					new_edge_weight = new_edge_weight.saturating_add(stake_to_take);
+				}
+			}
+
+			voter.edges[new_edge_index].weight = new_edge_weight;
+		}
+	}
+
+	// final update.
+	elected_ptr.borrow_mut().backed_stake = elected_backed_stake;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{Assignment, ElectionResult};
+	use sp_runtime::{Perbill, Percent};
+	use sp_std::rc::Rc;
+
+	#[test]
+	fn basic_election_manual_works() {
+		//! Manually run the internal steps of phragmms. In each round we select a new winner by
+		//! `max_score`, then apply this change by `apply_elected`, and finally do a `balance`
+		//! round.
+		let candidates = vec![1, 2, 3];
+		let voters = vec![(10, 10, vec![1, 2]), (20, 20, vec![1, 3]), (30, 30, vec![2, 3])];
+
+		let (candidates, mut voters) = setup_inputs(candidates, voters);
+
+		// Round 1
+		let winner =
+			calculate_max_score::<u32, Percent>(candidates.as_ref(), voters.as_ref()).unwrap();
+		assert_eq!(winner.borrow().who, 3);
+		assert_eq!(winner.borrow().score, 50u32.into());
+
+		apply_elected(&mut voters, Rc::clone(&winner));
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 30)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(30, vec![(2, 0), (3, 30)]),
+		);
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 20)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(20, vec![(1, 0), (3, 20)]),
+		);
+
+		// finish the round.
+		winner.borrow_mut().elected = true;
+		winner.borrow_mut().round = 0;
+		drop(winner);
+
+		// balancing makes no difference here but anyhow.
+		let config = BalancingConfig { iterations: 10, tolerance: 0 };
+		balance(&mut voters, &config);
+
+		// round 2
+		let winner =
+			calculate_max_score::<u32, Percent>(candidates.as_ref(), voters.as_ref()).unwrap();
+		assert_eq!(winner.borrow().who, 2);
+		assert_eq!(winner.borrow().score, 25u32.into());
+
+		apply_elected(&mut voters, Rc::clone(&winner));
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 30)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(30, vec![(2, 15), (3, 15)]),
+		);
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 20)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(20, vec![(1, 0), (3, 20)]),
+		);
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 10)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(10, vec![(1, 0), (2, 10)]),
+		);
+
+		// finish the round.
+		winner.borrow_mut().elected = true;
+		winner.borrow_mut().round = 0;
+		drop(winner);
+
+		// balancing will improve stuff here.
+		balance(&mut voters, &config);
+
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 30)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(30, vec![(2, 20), (3, 10)]),
+		);
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 20)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(20, vec![(1, 0), (3, 20)]),
+		);
+		assert_eq!(
+			voters
+				.iter()
+				.find(|x| x.who == 10)
+				.map(|v| (v.who, v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()))
+				.unwrap(),
+			(10, vec![(1, 0), (2, 10)]),
+		);
+	}
+
+	#[test]
+	fn basic_election_works() {
+		let candidates = vec![1, 2, 3];
+		let voters = vec![(10, 10, vec![1, 2]), (20, 20, vec![1, 3]), (30, 30, vec![2, 3])];
+
+		let config = BalancingConfig { iterations: 2, tolerance: 0 };
+		let ElectionResult::<_, Perbill> { winners, assignments } =
+			phragmms(2, candidates, voters, Some(config)).unwrap();
+		assert_eq!(winners, vec![(3, 30), (2, 30)]);
+		assert_eq!(
+			assignments,
+			vec![
+				Assignment { who: 10u64, distribution: vec![(2, Perbill::one())] },
+				Assignment { who: 20, distribution: vec![(3, Perbill::one())] },
+				Assignment {
+					who: 30,
+					distribution: vec![
+						(2, Perbill::from_parts(666666666)),
+						(3, Perbill::from_parts(333333334)),
+					],
+				},
+			]
+		)
+	}
+
+	#[test]
+	fn linear_voting_example_works() {
+		let candidates = vec![11, 21, 31, 41, 51, 61, 71];
+		let voters = vec![
+			(2, 2000, vec![11]),
+			(4, 1000, vec![11, 21]),
+			(6, 1000, vec![21, 31]),
+			(8, 1000, vec![31, 41]),
+			(110, 1000, vec![41, 51]),
+			(120, 1000, vec![51, 61]),
+			(130, 1000, vec![61, 71]),
+		];
+
+		let config = BalancingConfig { iterations: 2, tolerance: 0 };
+		let ElectionResult::<_, Perbill> { winners, assignments: _ } =
+			phragmms(4, candidates, voters, Some(config)).unwrap();
+		assert_eq!(winners, vec![(11, 3000), (31, 2000), (51, 1500), (61, 1500),]);
+	}
+
+	#[test]
+	fn large_balance_wont_overflow() {
+		let candidates = vec![1u32, 2, 3];
+		let mut voters = (0..1000).map(|i| (10 + i, u64::MAX, vec![1, 2, 3])).collect::<Vec<_>>();
+
+		// give a bit more to 1 and 3.
+		voters.push((2, u64::MAX, vec![1, 3]));
+
+		let config = BalancingConfig { iterations: 2, tolerance: 0 };
+		let ElectionResult::<_, Perbill> { winners, assignments: _ } =
+			phragmms(2, candidates, voters, Some(config)).unwrap();
+		assert_eq!(winners.into_iter().map(|(w, _)| w).collect::<Vec<_>>(), vec![1u32, 3]);
+	}
+}
diff --git a/substrate/primitives/npos-elections/src/pjr.rs b/substrate/primitives/npos-elections/src/pjr.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f0e59a25d440b67f65656d7eb04f16743bc1c353
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/pjr.rs
@@ -0,0 +1,626 @@
+// 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.
+
+//! Implements functions and interfaces to check solutions for being t-PJR.
+//!
+//! PJR stands for proportional justified representation. PJR is an absolute measure to make
+//! sure an NPoS solution adheres to a minimum standard.
+//!
+//! See [`pjr_check`] which is the main entry point of the module.
+
+use crate::{
+	Candidate, CandidatePtr, Edge, ExtendedBalance, IdentifierT, Support, SupportMap, Supports,
+	VoteWeight, Voter,
+};
+use sp_arithmetic::{traits::Zero, Perbill};
+use sp_std::{collections::btree_map::BTreeMap, rc::Rc, vec::Vec};
+/// The type used as the threshold.
+///
+/// Just some reading sugar; Must always be same as [`ExtendedBalance`];
+type Threshold = ExtendedBalance;
+
+/// Compute the threshold corresponding to the standard PJR property
+///
+/// `t-PJR` checks can check PJR according to an arbitrary threshold. The threshold can be any
+/// value, but the property gets stronger as the threshold gets smaller. The strongest possible
+/// `t-PJR` property corresponds to `t == 0`.
+///
+/// However, standard PJR is less stringent than that. This function returns the threshold whose
+/// strength corresponds to the standard PJR property.
+///
+/// - `committee_size` is the number of winners of the election.
+/// - `weights` is an iterator of voter stakes. If the sum of stakes is already known,
+///   `std::iter::once(sum_of_stakes)` is appropriate here.
+pub fn standard_threshold(
+	committee_size: usize,
+	weights: impl IntoIterator<Item = ExtendedBalance>,
+) -> Threshold {
+	weights
+		.into_iter()
+		.fold(Threshold::zero(), |acc, elem| acc.saturating_add(elem)) /
+		committee_size.max(1) as Threshold
+}
+
+/// Check a solution to be PJR.
+///
+/// The PJR property is true if `t-PJR` is true when `t == sum(stake) / committee_size`.
+pub fn pjr_check<AccountId: IdentifierT>(
+	supports: &Supports<AccountId>,
+	all_candidates: Vec<AccountId>,
+	all_voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
+) -> Result<(), AccountId> {
+	let t = standard_threshold(
+		supports.len(),
+		all_voters.iter().map(|voter| voter.1 as ExtendedBalance),
+	);
+	t_pjr_check(supports, all_candidates, all_voters, t)
+}
+
+/// Check a solution to be t-PJR.
+///
+/// ### Semantics
+///
+/// The t-PJR property is defined in the paper ["Validator Election in Nominated
+/// Proof-of-Stake"][NPoS], section 5, definition 1.
+///
+/// In plain language, the t-PJR condition is: if there is a group of `N` voters
+/// who have `r` common candidates and can afford to support each of them with backing stake `t`
+/// (i.e `sum(stake(v) for v in voters) == r * t`), then this committee needs to be represented by
+/// at least `r` elected candidates.
+///
+/// Section 5 of the NPoS paper shows that this property can be tested by: for a feasible solution,
+/// if `Max {score(c)} < t` where c is every unelected candidate, then this solution is t-PJR. There
+/// may exist edge cases which satisfy the formal definition of t-PJR but do not pass this test, but
+/// those should be rare enough that we can discount them.
+///
+/// ### Interface
+///
+/// In addition to data that can be computed from the [`Supports`] struct, a PJR check also
+/// needs to inspect un-elected candidates and edges, thus `all_candidates` and `all_voters`.
+///
+/// [NPoS]: https://arxiv.org/pdf/2004.12990v1.pdf
+// ### Implementation Notes
+//
+// The paper uses mathematical notation, which priorities single-symbol names. For programmer ease,
+// we map these to more descriptive names as follows:
+//
+// C      => all_candidates
+// N      => all_voters
+// (A, w) => (candidates, voters)
+//
+// Note that while the names don't explicitly say so, `candidates` are the winning candidates, and
+// `voters` is the set of weighted edges from nominators to winning validators.
+pub fn t_pjr_check<AccountId: IdentifierT>(
+	supports: &Supports<AccountId>,
+	all_candidates: Vec<AccountId>,
+	all_voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
+	t: Threshold,
+) -> Result<(), AccountId> {
+	// First order of business: derive `(candidates, voters)` from `supports`.
+	let (candidates, voters) = prepare_pjr_input(supports, all_candidates, all_voters);
+	// compute with threshold t.
+	pjr_check_core(candidates.as_ref(), voters.as_ref(), t)
+}
+
+/// The internal implementation of the PJR check after having the data converted.
+///
+/// [`pjr_check`] or [`t_pjr_check`] are typically easier to work with.
+///
+/// This function returns an `AccountId` in the `Err` case. This is the counter_example: the ID of
+/// the unelected candidate with the highest prescore, such that `pre_score(counter_example) >= t`.
+pub fn pjr_check_core<AccountId: IdentifierT>(
+	candidates: &[CandidatePtr<AccountId>],
+	voters: &[Voter<AccountId>],
+	t: Threshold,
+) -> Result<(), AccountId> {
+	let unelected = candidates.iter().filter(|c| !c.borrow().elected);
+	let maybe_max_pre_score = unelected
+		.map(|c| (pre_score(Rc::clone(c), voters, t), c.borrow().who.clone()))
+		.max();
+	// if unelected is empty then the solution is indeed PJR.
+	match maybe_max_pre_score {
+		Some((max_pre_score, counter_example)) if max_pre_score >= t => Err(counter_example),
+		_ => Ok(()),
+	}
+}
+
+/// Validate a challenge to an election result.
+///
+/// A challenge to an election result is valid if there exists some counter_example for which
+/// `pre_score(counter_example) >= threshold`. Validating an existing counter_example is
+/// computationally cheaper than re-running the PJR check.
+///
+/// This function uses the standard threshold.
+///
+/// Returns `true` if the challenge is valid: the proposed solution does not satisfy PJR.
+/// Returns `false` if the challenge is invalid: the proposed solution does in fact satisfy PJR.
+pub fn validate_pjr_challenge<AccountId: IdentifierT>(
+	counter_example: AccountId,
+	supports: &Supports<AccountId>,
+	all_candidates: Vec<AccountId>,
+	all_voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
+) -> bool {
+	let threshold = standard_threshold(
+		supports.len(),
+		all_voters.iter().map(|voter| voter.1 as ExtendedBalance),
+	);
+	validate_t_pjr_challenge(counter_example, supports, all_candidates, all_voters, threshold)
+}
+
+/// Validate a challenge to an election result.
+///
+/// A challenge to an election result is valid if there exists some counter_example for which
+/// `pre_score(counter_example) >= threshold`. Validating an existing counter_example is
+/// computationally cheaper than re-running the PJR check.
+///
+/// This function uses a supplied threshold.
+///
+/// Returns `true` if the challenge is valid: the proposed solution does not satisfy PJR.
+/// Returns `false` if the challenge is invalid: the proposed solution does in fact satisfy PJR.
+pub fn validate_t_pjr_challenge<AccountId: IdentifierT>(
+	counter_example: AccountId,
+	supports: &Supports<AccountId>,
+	all_candidates: Vec<AccountId>,
+	all_voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
+	threshold: Threshold,
+) -> bool {
+	let (candidates, voters) = prepare_pjr_input(supports, all_candidates, all_voters);
+	validate_pjr_challenge_core(counter_example, &candidates, &voters, threshold)
+}
+
+/// Validate a challenge to an election result.
+///
+/// A challenge to an election result is valid if there exists some counter_example for which
+/// `pre_score(counter_example) >= threshold`. Validating an existing counter_example is
+/// computationally cheaper than re-running the PJR check.
+///
+/// Returns `true` if the challenge is valid: the proposed solution does not satisfy PJR.
+/// Returns `false` if the challenge is invalid: the proposed solution does in fact satisfy PJR.
+fn validate_pjr_challenge_core<AccountId: IdentifierT>(
+	counter_example: AccountId,
+	candidates: &[CandidatePtr<AccountId>],
+	voters: &[Voter<AccountId>],
+	threshold: Threshold,
+) -> bool {
+	// Performing a linear search of the candidate list is not great, for obvious reasons. However,
+	// the alternatives are worse:
+	//
+	// - we could pre-sort the candidates list in `prepare_pjr_input` (n log n) which would let us
+	//   binary search for the appropriate one here (log n). Overall runtime is `n log n` which is
+	//   worse than the current runtime of `n`.
+	//
+	// - we could probably pre-sort the candidates list in `n` in `prepare_pjr_input` using some
+	//   unsafe code leveraging the existing `candidates_index`: allocate an uninitialized vector of
+	//   appropriate length, then copy in all the elements. We'd really prefer to avoid unsafe code
+	//   in the runtime, though.
+	let candidate =
+		match candidates.iter().find(|candidate| candidate.borrow().who == counter_example) {
+			None => return false,
+			Some(candidate) => candidate.clone(),
+		};
+	pre_score(candidate, voters, threshold) >= threshold
+}
+
+/// Convert the data types that the user runtime has into ones that can be used by this module.
+///
+/// It is expected that this function's interface might change over time, or multiple variants of it
+/// can be provided for different use cases.
+///
+/// The ultimate goal, in any case, is to convert the election data into [`Candidate`] and [`Voter`]
+/// types defined by this crate, whilst setting correct value for some of their fields, namely:
+/// 1. Candidate [`backing_stake`](Candidate::backing_stake) and [`elected`](Candidate::elected) if
+/// they are a winner. 2. Voter edge [`weight`](Edge::weight) if they are backing a winner.
+/// 3. Voter [`budget`](Voter::budget).
+///
+/// None of the `load` or `score` values are used and can be ignored. This is similar to
+/// [`setup_inputs`] function of this crate.
+///
+/// ### Performance (Weight) Notes
+///
+/// Note that the current function is rather unfortunately inefficient. The most significant
+/// slowdown is the fact that a typical solution that need to be checked for PJR only contains a
+/// subset of the entire NPoS edge graph, encoded as `supports`. This only encodes the
+/// edges that actually contribute to a winner's backing stake and ignores the rest to save space.
+/// To check PJR, we need the entire voter set, including those edges that point to non-winners.
+/// This could cause the caller runtime to have to read the entire list of voters, which is assumed
+/// to be expensive.
+///
+/// A sensible user of this module should make sure that the PJR check is executed and checked as
+/// little as possible, and take sufficient economical measures to ensure that this function cannot
+/// be abused.
+fn prepare_pjr_input<AccountId: IdentifierT>(
+	supports: &Supports<AccountId>,
+	all_candidates: Vec<AccountId>,
+	all_voters: Vec<(AccountId, VoteWeight, Vec<AccountId>)>,
+) -> (Vec<CandidatePtr<AccountId>>, Vec<Voter<AccountId>>) {
+	let mut candidates_index: BTreeMap<AccountId, usize> = BTreeMap::new();
+
+	// dump the staked assignments in a voter-major map for faster access down the road.
+	let mut assignment_map: BTreeMap<AccountId, Vec<(AccountId, ExtendedBalance)>> =
+		BTreeMap::new();
+	for (winner_id, Support { voters, .. }) in supports.iter() {
+		for (voter_id, support) in voters.iter() {
+			assignment_map
+				.entry(voter_id.clone())
+				.or_default()
+				.push((winner_id.clone(), *support));
+		}
+	}
+
+	// Convert Suppports into a SupportMap
+	//
+	// As a flat list, we're limited to linear search. That gives the production of `candidates`,
+	// below, a complexity of `O(s*c)`, where `s == supports.len()` and `c == all_candidates.len()`.
+	// For large lists, that's pretty bad.
+	//
+	// A `SupportMap`, as a `BTreeMap`, has access timing of `O(lg n)`. This means that constructing
+	// the map and then indexing from it gives us timing of `O((s + c) * lg(s))`. If in the future
+	// we get access to a deterministic `HashMap`, we can further improve that to `O(s+c)`.
+	//
+	// However, it does mean allocating sufficient space to store all the data again.
+	let supports: SupportMap<AccountId> = supports.iter().cloned().collect();
+
+	// collect all candidates and winners into a unified `Vec<CandidatePtr>`.
+	let candidates = all_candidates
+		.into_iter()
+		.enumerate()
+		.map(|(i, c)| {
+			candidates_index.insert(c.clone(), i);
+
+			// set the backing value and elected flag if the candidate is among the winners.
+			let who = c;
+			let maybe_support = supports.get(&who);
+			let elected = maybe_support.is_some();
+			let backed_stake = maybe_support.map(|support| support.total).unwrap_or_default();
+
+			Candidate {
+				who,
+				elected,
+				backed_stake,
+				score: Default::default(),
+				approval_stake: Default::default(),
+				round: Default::default(),
+			}
+			.to_ptr()
+		})
+		.collect::<Vec<_>>();
+
+	// collect all voters into a unified Vec<Voters>.
+	let voters = all_voters
+		.into_iter()
+		.map(|(v, w, ts)| {
+			let mut edges: Vec<Edge<AccountId>> = Vec::with_capacity(ts.len());
+			for t in ts {
+				if edges.iter().any(|e| e.who == t) {
+					// duplicate edge.
+					continue
+				}
+
+				if let Some(idx) = candidates_index.get(&t) {
+					// if this edge is among the assignments, set the weight as well.
+					let weight = assignment_map
+						.get(&v)
+						.and_then(|d| {
+							d.iter().find_map(|(x, y)| if x == &t { Some(y) } else { None })
+						})
+						.cloned()
+						.unwrap_or_default();
+					edges.push(Edge {
+						who: t,
+						candidate: Rc::clone(&candidates[*idx]),
+						weight,
+						load: Default::default(),
+					});
+				}
+			}
+
+			let who = v;
+			let budget: ExtendedBalance = w.into();
+			Voter { who, budget, edges, load: Default::default() }
+		})
+		.collect::<Vec<_>>();
+
+	(candidates, voters)
+}
+
+/// The pre-score of an unelected candidate.
+///
+/// This is the amount of stake that *all voter* can spare to devote to this candidate without
+/// allowing the backing stake of any other elected candidate to fall below `t`.
+///
+/// In essence, it is the sum(slack(n, t)) for all `n` who vote for `unelected`.
+fn pre_score<AccountId: IdentifierT>(
+	unelected: CandidatePtr<AccountId>,
+	voters: &[Voter<AccountId>],
+	t: Threshold,
+) -> ExtendedBalance {
+	debug_assert!(!unelected.borrow().elected);
+	voters
+		.iter()
+		.filter(|v| v.votes_for(&unelected.borrow().who))
+		.fold(Zero::zero(), |acc: ExtendedBalance, voter| acc.saturating_add(slack(voter, t)))
+}
+
+/// The slack of a voter at a given state.
+///
+/// The slack of each voter, with threshold `t` is the total amount of stake that this voter can
+/// spare to a new potential member, whilst not dropping the backing stake of any of its currently
+/// active members below `t`. In essence, for each of the current active candidates `c`, we assume
+/// that we reduce the edge weight of `voter` to `c` from `w` to `w * min(1 / (t / support(c)))`.
+///
+/// More accurately:
+///
+/// 1. If `c` exactly has `t` backing or less, then we don't generate any slack.
+/// 2. If `c` has more than `t`, then we reduce it to `t`.
+fn slack<AccountId: IdentifierT>(voter: &Voter<AccountId>, t: Threshold) -> ExtendedBalance {
+	let budget = voter.budget;
+	let leftover = voter.edges.iter().fold(Zero::zero(), |acc: ExtendedBalance, edge| {
+		let candidate = edge.candidate.borrow();
+		if candidate.elected {
+			let extra =
+				Perbill::one().min(Perbill::from_rational(t, candidate.backed_stake)) * edge.weight;
+			acc.saturating_add(extra)
+		} else {
+			// No slack generated here.
+			acc
+		}
+	});
+
+	// NOTE: candidate for saturating_log_sub(). Defensive-only.
+	budget.saturating_sub(leftover)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	fn setup_voter(who: u32, votes: Vec<(u32, u128, bool)>) -> Voter<u32> {
+		let mut voter = Voter::new(who);
+		let mut budget = 0u128;
+		let candidates = votes
+			.into_iter()
+			.map(|(t, w, e)| {
+				budget += w;
+				Candidate {
+					who: t,
+					elected: e,
+					backed_stake: w,
+					score: Default::default(),
+					approval_stake: Default::default(),
+					round: Default::default(),
+				}
+			})
+			.collect::<Vec<_>>();
+		let edges = candidates
+			.into_iter()
+			.map(|c| Edge {
+				who: c.who,
+				weight: c.backed_stake,
+				candidate: c.to_ptr(),
+				load: Default::default(),
+			})
+			.collect::<Vec<_>>();
+		voter.edges = edges;
+		voter.budget = budget;
+		voter
+	}
+
+	fn assert_core_failure<AccountId: IdentifierT>(
+		candidates: &[CandidatePtr<AccountId>],
+		voters: &[Voter<AccountId>],
+		t: Threshold,
+	) {
+		let counter_example = pjr_check_core(candidates, voters, t).unwrap_err();
+		assert!(validate_pjr_challenge_core(counter_example, candidates, voters, t));
+	}
+
+	#[test]
+	fn slack_works() {
+		let voter = setup_voter(10, vec![(1, 10, true), (2, 20, true)]);
+
+		assert_eq!(slack(&voter, 15), 5);
+		assert_eq!(slack(&voter, 17), 3);
+		assert_eq!(slack(&voter, 10), 10);
+		assert_eq!(slack(&voter, 5), 20);
+	}
+
+	#[test]
+	fn pre_score_works() {
+		// will give 5 slack
+		let v1 = setup_voter(10, vec![(1, 10, true), (2, 20, true), (3, 0, false)]);
+		// will give no slack
+		let v2 = setup_voter(20, vec![(1, 5, true), (2, 5, true)]);
+		// will give 10 slack.
+		let v3 = setup_voter(30, vec![(1, 20, true), (2, 20, true), (3, 0, false)]);
+
+		let unelected = Candidate {
+			who: 3u32,
+			elected: false,
+			score: Default::default(),
+			approval_stake: Default::default(),
+			backed_stake: Default::default(),
+			round: Default::default(),
+		}
+		.to_ptr();
+		let score = pre_score(unelected, &vec![v1, v2, v3], 15);
+
+		assert_eq!(score, 15);
+	}
+
+	#[test]
+	fn can_convert_data_from_external_api() {
+		let all_candidates = vec![10, 20, 30, 40];
+		let all_voters = vec![
+			(1, 10, vec![10, 20, 30, 40]),
+			(2, 20, vec![10, 20, 30, 40]),
+			(3, 30, vec![10, 30]),
+		];
+		// tuples in voters vector are (AccountId, Balance)
+		let supports: Supports<u32> = vec![
+			(20, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+			(40, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+		];
+
+		let (candidates, voters) = prepare_pjr_input(&supports, all_candidates, all_voters);
+
+		// elected flag and backing must be set correctly
+		assert_eq!(
+			candidates
+				.iter()
+				.map(|c| (c.borrow().who, c.borrow().elected, c.borrow().backed_stake))
+				.collect::<Vec<_>>(),
+			vec![(10, false, 0), (20, true, 15), (30, false, 0), (40, true, 15)],
+		);
+
+		// edge weight must be set correctly
+		assert_eq!(
+			voters
+				.iter()
+				.map(|v| (
+					v.who,
+					v.budget,
+					v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>(),
+				))
+				.collect::<Vec<_>>(),
+			vec![
+				(1, 10, vec![(10, 0), (20, 5), (30, 0), (40, 5)]),
+				(2, 20, vec![(10, 0), (20, 10), (30, 0), (40, 10)]),
+				(3, 30, vec![(10, 0), (30, 0)]),
+			],
+		);
+
+		// fyi. this is not PJR, obviously because the votes of 3 can bump the stake a lot but they
+		// are being ignored.
+		assert_core_failure(&candidates, &voters, 1);
+		assert_core_failure(&candidates, &voters, 10);
+		assert_core_failure(&candidates, &voters, 20);
+	}
+
+	// These next tests ensure that the threshold phase change property holds for us, but that's not
+	// their real purpose. They were written to help develop an intuition about what the threshold
+	// value actually means in layman's terms.
+	//
+	// The results tend to support the intuition that the threshold is the voting power at and below
+	// which a voter's preferences can simply be ignored.
+	#[test]
+	fn find_upper_bound_for_threshold_scenario_1() {
+		let all_candidates = vec![10, 20, 30, 40];
+		let all_voters = vec![
+			(1, 10, vec![10, 20, 30, 40]),
+			(2, 20, vec![10, 20, 30, 40]),
+			(3, 30, vec![10, 30]),
+		];
+		// tuples in voters vector are (AccountId, Balance)
+		let supports: Supports<u32> = vec![
+			(20, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+			(40, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+		];
+
+		let (candidates, voters) = prepare_pjr_input(&supports, all_candidates, all_voters);
+
+		find_threshold_phase_change_for_scenario(candidates, voters);
+	}
+
+	#[test]
+	fn find_upper_bound_for_threshold_scenario_2() {
+		let all_candidates = vec![10, 20, 30, 40];
+		let all_voters = vec![
+			(1, 10, vec![10, 20, 30, 40]),
+			(2, 20, vec![10, 20, 30, 40]),
+			(3, 25, vec![10, 30]),
+		];
+		// tuples in voters vector are (AccountId, Balance)
+		let supports: Supports<u32> = vec![
+			(20, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+			(40, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+		];
+
+		let (candidates, voters) = prepare_pjr_input(&supports, all_candidates, all_voters);
+
+		find_threshold_phase_change_for_scenario(candidates, voters);
+	}
+
+	#[test]
+	fn find_upper_bound_for_threshold_scenario_3() {
+		let all_candidates = vec![10, 20, 30, 40];
+		let all_voters = vec![
+			(1, 10, vec![10, 20, 30, 40]),
+			(2, 20, vec![10, 20, 30, 40]),
+			(3, 35, vec![10, 30]),
+		];
+		// tuples in voters vector are (AccountId, Balance)
+		let supports: Supports<u32> = vec![
+			(20, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+			(40, Support { total: 15, voters: vec![(1, 5), (2, 10)] }),
+		];
+
+		let (candidates, voters) = prepare_pjr_input(&supports, all_candidates, all_voters);
+
+		find_threshold_phase_change_for_scenario(candidates, voters);
+	}
+
+	fn find_threshold_phase_change_for_scenario<AccountId: IdentifierT>(
+		candidates: Vec<CandidatePtr<AccountId>>,
+		voters: Vec<Voter<AccountId>>,
+	) -> Threshold {
+		let mut threshold = 1;
+		let mut prev_threshold = 0;
+
+		// find the binary range containing the threshold beyond which the PJR check succeeds
+		while pjr_check_core(&candidates, &voters, threshold).is_err() {
+			prev_threshold = threshold;
+			threshold = threshold
+				.checked_mul(2)
+				.expect("pjr check must fail before we run out of capacity in u128");
+		}
+
+		// now binary search within that range to find the phase threshold
+		let mut high_bound = threshold;
+		let mut low_bound = prev_threshold;
+
+		while high_bound - low_bound > 1 {
+			// maintain the invariant that low_bound fails and high_bound passes
+			let test = low_bound + ((high_bound - low_bound) / 2);
+			if pjr_check_core(&candidates, &voters, test).is_ok() {
+				high_bound = test;
+			} else {
+				low_bound = test;
+			}
+		}
+
+		println!("highest failing check:   {}", low_bound);
+		println!("lowest succeeding check: {}", high_bound);
+
+		// for a value to be a threshold, it must be the boundary between two conditions
+		let mut unexpected_failures = Vec::new();
+		let mut unexpected_successes = Vec::new();
+		for t in 0..=low_bound {
+			if pjr_check_core(&candidates, &voters, t).is_ok() {
+				unexpected_successes.push(t);
+			}
+		}
+		for t in high_bound..(high_bound * 2) {
+			if pjr_check_core(&candidates, &voters, t).is_err() {
+				unexpected_failures.push(t);
+			}
+		}
+		dbg!(&unexpected_successes, &unexpected_failures);
+		assert!(unexpected_failures.is_empty() && unexpected_successes.is_empty());
+
+		high_bound
+	}
+}
diff --git a/substrate/primitives/npos-elections/src/reduce.rs b/substrate/primitives/npos-elections/src/reduce.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6a5a0159e4efb9ee6d742d94adc1cc328c24aef1
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/reduce.rs
@@ -0,0 +1,923 @@
+// 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.
+
+//! Rust implementation of the Phragmén reduce algorithm. This can be used by any off chain
+//! application to reduce cycles from the edge assignment, which will result in smaller size.
+//!
+//!  ### Notions
+//!  - `m`: size of the committee to elect.
+//!  - `k`: maximum allowed votes (16 as of this writing).
+//!  - `nv ∈ E` means that nominator `n ∈ N` supports the election of candidate `v ∈ V`.
+//!  - A valid solution consists of a tuple `(S, W)` , where `S ⊆ V` is a committee of m validators,
+//!    and `W : E → R ≥ 0` is an edge weight vector which describes how the budget of each nominator
+//!    n is fractionally assigned to n 's elected neighbors.
+//!  - `E_w := { e ∈ E : w_e > 0 }`.
+//!
+//!  ### Algorithm overview
+//!
+//! > We consider the input edge weight vector `w` as a directed flow over `E_w` , where the flow in
+//! > each edge is directed from the nominator to the validator. We build `w′` from `w` by removing
+//! > **circulations** to cancel out the flow over as many edges as possible, while preserving flow
+//! > demands over all vertices and without reverting the flow direction over any edge. As long as
+//! > there is a cycle, we can remove an additional circulation and eliminate at least one new edge
+//! > from `E_w′` . This shows that the algorithm always progresses and will eventually finish with
+//! > an acyclic edge support. We keep a data structure that represents a forest of rooted trees,
+//! > which is initialized as a collection of singletons – one per vertex – and to which edges in
+//! > `E_w` are added one by one, causing the trees to merge. Whenever a new edge creates a cycle,
+//! > we detect it and destroy it by removing a circulation. We also run a pre-computation which is
+//! > designed to detect and remove cycles of length four exclusively. This pre-computation is
+//! > optional, and if we skip it then the running time becomes `O (|E_w| â‹… m), so the
+//! > pre-computation makes sense only if `m >> k` and `|E_w| >> m^2`.
+//!
+//! ### Resources:
+//!
+//! 1. <https://hackmd.io/JOn9x98iS0e0DPWQ87zGWg?view>
+
+use crate::{
+	node::{Node, NodeId, NodeRef, NodeRole},
+	ExtendedBalance, IdentifierT, StakedAssignment,
+};
+use sp_arithmetic::traits::{Bounded, Zero};
+use sp_std::{
+	collections::btree_map::{BTreeMap, Entry::*},
+	prelude::*,
+};
+
+/// Map type used for reduce_4. Can be easily swapped with HashMap.
+type Map<A> = BTreeMap<(A, A), A>;
+
+/// Returns all combinations of size two in the collection `input` with no repetition.
+fn combinations_2<T: Clone>(input: &[T]) -> Vec<(T, T)> {
+	let n = input.len();
+	if n < 2 {
+		return Default::default()
+	}
+
+	let mut comb = Vec::with_capacity(n * (n - 1) / 2);
+	for i in 0..n {
+		for j in i + 1..n {
+			comb.push((input[i].clone(), input[j].clone()))
+		}
+	}
+	comb
+}
+
+/// Returns the count of trailing common elements in two slices.
+pub(crate) fn trailing_common<T: Eq>(t1: &[T], t2: &[T]) -> usize {
+	t1.iter().rev().zip(t2.iter().rev()).take_while(|e| e.0 == e.1).count()
+}
+
+/// Merges two parent roots as described by the reduce algorithm.
+fn merge<A: IdentifierT>(voter_root_path: Vec<NodeRef<A>>, target_root_path: Vec<NodeRef<A>>) {
+	let (shorter_path, longer_path) = if voter_root_path.len() <= target_root_path.len() {
+		(voter_root_path, target_root_path)
+	} else {
+		(target_root_path, voter_root_path)
+	};
+
+	// iterate from last to beginning, skipping the first one. This asserts that
+	// indexing is always correct.
+	shorter_path
+		.iter()
+		.zip(shorter_path.iter().skip(1))
+		.for_each(|(voter, next)| Node::set_parent_of(next, voter));
+	Node::set_parent_of(&shorter_path[0], &longer_path[0]);
+}
+
+/// Reduce only redundant edges with cycle length of 4.
+///
+/// Returns the number of edges removed.
+///
+/// It is strictly assumed that the `who` attribute of all provided assignments are unique. The
+/// result will most likely be corrupt otherwise.
+///
+/// O(|E_w| â‹… k).
+fn reduce_4<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 {
+	let mut combination_map: Map<A> = Map::new();
+	let mut num_changed: u32 = Zero::zero();
+
+	// we have to use the old fashioned loops here with manual indexing. Borrowing assignments will
+	// not work since then there is NO way to mutate it inside.
+	for assignment_index in 0..assignments.len() {
+		let who = assignments[assignment_index].who.clone();
+
+		// all combinations for this particular voter
+		let distribution_ids = &assignments[assignment_index]
+			.distribution
+			.iter()
+			.map(|(t, _p)| t.clone())
+			.collect::<Vec<A>>();
+		let candidate_combinations = combinations_2(distribution_ids);
+
+		for (v1, v2) in candidate_combinations {
+			match combination_map.entry((v1.clone(), v2.clone())) {
+				Vacant(entry) => {
+					entry.insert(who.clone());
+				},
+				Occupied(mut entry) => {
+					let other_who = entry.get_mut();
+
+					// double check if who is still voting for this pair. If not, it means that this
+					// pair is no longer valid and must have been removed in previous rounds. The
+					// reason for this is subtle; candidate_combinations is created once while the
+					// inner loop might remove some edges. Note that if count() > 2, the we have
+					// duplicates.
+					if assignments[assignment_index]
+						.distribution
+						.iter()
+						.filter(|(t, _)| *t == v1 || *t == v2)
+						.count() != 2
+					{
+						continue
+					}
+
+					// check if other_who voted for the same pair v1, v2.
+					let maybe_other_assignments = assignments.iter().find(|a| a.who == *other_who);
+					if maybe_other_assignments.is_none() {
+						continue
+					}
+					let other_assignment =
+						maybe_other_assignments.expect("value is checked to be 'Some'");
+
+					// Collect potential cycle votes
+					let mut other_cycle_votes =
+						other_assignment
+							.distribution
+							.iter()
+							.filter_map(|(t, w)| {
+								if *t == v1 || *t == v2 {
+									Some((t.clone(), *w))
+								} else {
+									None
+								}
+							})
+							.collect::<Vec<(A, ExtendedBalance)>>();
+
+					let other_votes_count = other_cycle_votes.len();
+
+					// If the length is more than 2, then we have identified duplicates. For now, we
+					// just skip. Later on we can early exit and stop processing this data since it
+					// is corrupt anyhow.
+					debug_assert!(other_votes_count <= 2);
+
+					if other_votes_count < 2 {
+						// This is not a cycle. Replace and continue.
+						*other_who = who.clone();
+						continue
+					} else if other_votes_count == 2 {
+						// This is a cycle.
+						let mut who_cycle_votes: Vec<(A, ExtendedBalance)> = Vec::with_capacity(2);
+						assignments[assignment_index].distribution.iter().for_each(|(t, w)| {
+							if *t == v1 || *t == v2 {
+								who_cycle_votes.push((t.clone(), *w));
+							}
+						});
+
+						if who_cycle_votes.len() != 2 {
+							continue
+						}
+
+						// Align the targets similarly. This helps with the circulation below.
+						if other_cycle_votes[0].0 != who_cycle_votes[0].0 {
+							other_cycle_votes.swap(0, 1);
+						}
+
+						// Find min
+						let mut min_value: ExtendedBalance = Bounded::max_value();
+						let mut min_index: usize = 0;
+						let cycle = who_cycle_votes
+							.iter()
+							.chain(other_cycle_votes.iter())
+							.enumerate()
+							.map(|(index, (t, w))| {
+								if *w <= min_value {
+									min_value = *w;
+									min_index = index;
+								}
+								(t.clone(), *w)
+							})
+							.collect::<Vec<(A, ExtendedBalance)>>();
+
+						// min was in the first part of the chained iters
+						let mut increase_indices: Vec<usize> = Vec::new();
+						let mut decrease_indices: Vec<usize> = Vec::new();
+						decrease_indices.push(min_index);
+						if min_index < 2 {
+							// min_index == 0 => sibling_index <- 1
+							// min_index == 1 => sibling_index <- 0
+							let sibling_index = 1 - min_index;
+							increase_indices.push(sibling_index);
+							// valid because the two chained sections of `cycle` are aligned;
+							// index [0, 2] are both voting for v1 or both v2. Same goes for [1, 3].
+							decrease_indices.push(sibling_index + 2);
+							increase_indices.push(min_index + 2);
+						} else {
+							// min_index == 2 => sibling_index <- 3
+							// min_index == 3 => sibling_index <- 2
+							let sibling_index = 3 - min_index % 2;
+							increase_indices.push(sibling_index);
+							// valid because the two chained sections of `cycle` are aligned;
+							// index [0, 2] are both voting for v1 or both v2. Same goes for [1, 3].
+							decrease_indices.push(sibling_index - 2);
+							increase_indices.push(min_index - 2);
+						}
+
+						// apply changes
+						let mut remove_indices: Vec<usize> = Vec::with_capacity(1);
+						increase_indices.into_iter().for_each(|i| {
+							let voter = if i < 2 { who.clone() } else { other_who.clone() };
+							// Note: so this is pretty ambiguous. We should only look for one
+							// assignment that meets this criteria and if we find multiple then that
+							// is a corrupt input. Same goes for the next block.
+							assignments.iter_mut().filter(|a| a.who == voter).for_each(|ass| {
+								ass.distribution
+									.iter_mut()
+									.position(|(t, _)| *t == cycle[i].0)
+									.map(|idx| {
+										let next_value =
+											ass.distribution[idx].1.saturating_add(min_value);
+										ass.distribution[idx].1 = next_value;
+									});
+							});
+						});
+						decrease_indices.into_iter().for_each(|i| {
+							let voter = if i < 2 { who.clone() } else { other_who.clone() };
+							assignments.iter_mut().filter(|a| a.who == voter).for_each(|ass| {
+								ass.distribution
+									.iter_mut()
+									.position(|(t, _)| *t == cycle[i].0)
+									.map(|idx| {
+										let next_value =
+											ass.distribution[idx].1.saturating_sub(min_value);
+										if next_value.is_zero() {
+											ass.distribution.remove(idx);
+											remove_indices.push(i);
+											num_changed += 1;
+										} else {
+											ass.distribution[idx].1 = next_value;
+										}
+									});
+							});
+						});
+
+						// remove either one of them.
+						let who_removed = remove_indices.iter().any(|i| *i < 2usize);
+						let other_removed = remove_indices.into_iter().any(|i| i >= 2usize);
+
+						match (who_removed, other_removed) {
+							(false, true) => {
+								*other_who = who.clone();
+							},
+							(true, false) => {
+								// nothing, other_who can stay there.
+							},
+							(true, true) => {
+								// remove and don't replace
+								entry.remove();
+							},
+							(false, false) => {
+								// Neither of the edges was removed? impossible.
+								panic!("Duplicate voter (or other corrupt input).");
+							},
+						}
+					}
+				},
+			}
+		}
+	}
+
+	num_changed
+}
+
+/// Reduce redundant edges from the edge weight graph, with all possible length.
+///
+/// To get the best performance, this should be called after `reduce_4()`.
+///
+/// Returns the number of edges removed.
+///
+/// It is strictly assumed that the `who` attribute of all provided assignments are unique. The
+/// result will most likely be corrupt otherwise.
+///
+/// O(|Ew| â‹… m)
+fn reduce_all<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 {
+	let mut num_changed: u32 = Zero::zero();
+	let mut tree: BTreeMap<NodeId<A>, NodeRef<A>> = BTreeMap::new();
+
+	// NOTE: This code can heavily use an index cache. Looking up a pair of (voter, target) in the
+	// assignments happens numerous times and and we can save time. For now it is written as such
+	// because abstracting some of this code into a function/closure is super hard due to borrow
+	// checks (and most likely needs unsafe code at the end). For now I will keep it as it and
+	// refactor later.
+
+	// a flat iterator of (voter, target) over all pairs of votes. Similar to reduce_4, we loop
+	// without borrowing.
+	for assignment_index in 0..assignments.len() {
+		let voter = assignments[assignment_index].who.clone();
+
+		let mut dist_index = 0;
+		loop {
+			// A distribution could have been removed. We don't know for sure. Hence, we check.
+			let maybe_dist = assignments[assignment_index].distribution.get(dist_index);
+			if maybe_dist.is_none() {
+				// The rest of this loop is moot.
+				break
+			}
+			let (target, _) = maybe_dist.expect("Value checked to be some").clone();
+
+			// store if they existed already.
+			let voter_id = NodeId::from(voter.clone(), NodeRole::Voter);
+			let target_id = NodeId::from(target.clone(), NodeRole::Target);
+			let voter_exists = tree.contains_key(&voter_id);
+			let target_exists = tree.contains_key(&target_id);
+
+			// create both.
+			let voter_node = tree
+				.entry(voter_id.clone())
+				.or_insert_with(|| Node::new(voter_id).into_ref())
+				.clone();
+			let target_node = tree
+				.entry(target_id.clone())
+				.or_insert_with(|| Node::new(target_id).into_ref())
+				.clone();
+
+			// If one exists but the other one doesn't, or if both do not, then set the existing
+			// one as the parent of the non-existing one and move on. Else, continue with the rest
+			// of the code.
+			match (voter_exists, target_exists) {
+				(false, false) => {
+					Node::set_parent_of(&target_node, &voter_node);
+					dist_index += 1;
+					continue
+				},
+				(false, true) => {
+					Node::set_parent_of(&voter_node, &target_node);
+					dist_index += 1;
+					continue
+				},
+				(true, false) => {
+					Node::set_parent_of(&target_node, &voter_node);
+					dist_index += 1;
+					continue
+				},
+				(true, true) => { /* don't continue and execute the rest */ },
+			};
+
+			let (voter_root, voter_root_path) = Node::root(&voter_node);
+			let (target_root, target_root_path) = Node::root(&target_node);
+
+			if voter_root != target_root {
+				// swap
+				merge(voter_root_path, target_root_path);
+				dist_index += 1;
+			} else {
+				// find common and cycle.
+				let common_count = trailing_common(&voter_root_path, &target_root_path);
+
+				// because roots are the same.
+				//debug_assert_eq!(target_root_path.last().unwrap(),
+				// voter_root_path.last().unwrap()); TODO: @kian
+				// the common path must be non-void..
+				debug_assert!(common_count > 0);
+				// and smaller than btoh
+				debug_assert!(common_count <= voter_root_path.len());
+				debug_assert!(common_count <= target_root_path.len());
+
+				// cycle part of each path will be `path[path.len() - common_count - 1 : 0]`
+				// NOTE: the order of chaining is important! it is always build from [target, ...,
+				// voter]
+				let cycle = target_root_path
+					.iter()
+					.take(target_root_path.len().saturating_sub(common_count).saturating_add(1))
+					.cloned()
+					.chain(
+						voter_root_path
+							.iter()
+							.take(voter_root_path.len().saturating_sub(common_count))
+							.rev()
+							.cloned(),
+					)
+					.collect::<Vec<NodeRef<A>>>();
+
+				// a cycle's length shall always be multiple of two.
+				debug_assert_eq!(cycle.len() % 2, 0);
+
+				// find minimum of cycle.
+				let mut min_value: ExtendedBalance = Bounded::max_value();
+				// The voter and the target pair that create the min edge. These MUST be set by the
+				// end of this code block, otherwise we skip.
+				let mut maybe_min_target: Option<A> = None;
+				let mut maybe_min_voter: Option<A> = None;
+				// The index of the min in opaque cycle list.
+				let mut maybe_min_index: Option<usize> = None;
+				// 1 -> next // 0 -> prev
+				let mut maybe_min_direction: Option<u32> = None;
+
+				// helpers
+				let next_index = |i| {
+					if i < (cycle.len() - 1) {
+						i + 1
+					} else {
+						0
+					}
+				};
+				let prev_index = |i| {
+					if i > 0 {
+						i - 1
+					} else {
+						cycle.len() - 1
+					}
+				};
+
+				for i in 0..cycle.len() {
+					if cycle[i].borrow().id.role == NodeRole::Voter {
+						// NOTE: sadly way too many clones since I don't want to make A: Copy
+						let current = cycle[i].borrow().id.who.clone();
+						let next = cycle[next_index(i)].borrow().id.who.clone();
+						let prev = cycle[prev_index(i)].borrow().id.who.clone();
+						assignments.iter().find(|a| a.who == current).map(|ass| {
+							ass.distribution.iter().find(|d| d.0 == next).map(|(_, w)| {
+								if *w < min_value {
+									min_value = *w;
+									maybe_min_target = Some(next.clone());
+									maybe_min_voter = Some(current.clone());
+									maybe_min_index = Some(i);
+									maybe_min_direction = Some(1);
+								}
+							})
+						});
+						assignments.iter().find(|a| a.who == current).map(|ass| {
+							ass.distribution.iter().find(|d| d.0 == prev).map(|(_, w)| {
+								if *w < min_value {
+									min_value = *w;
+									maybe_min_target = Some(prev.clone());
+									maybe_min_voter = Some(current.clone());
+									maybe_min_index = Some(i);
+									maybe_min_direction = Some(0);
+								}
+							})
+						});
+					}
+				}
+
+				// all of these values must be set by now, we assign them to un-mut values, no
+				// longer being optional either.
+				let (min_value, min_target, min_voter, min_index, min_direction) =
+					match (
+						min_value,
+						maybe_min_target,
+						maybe_min_voter,
+						maybe_min_index,
+						maybe_min_direction,
+					) {
+						(
+							min_value,
+							Some(min_target),
+							Some(min_voter),
+							Some(min_index),
+							Some(min_direction),
+						) => (min_value, min_target, min_voter, min_index, min_direction),
+						_ => {
+							sp_runtime::print("UNREACHABLE code reached in `reduce` algorithm. This must be a bug.");
+							break
+						},
+					};
+
+				// if the min edge is in the voter's sub-chain.
+				// [target, ..., X, Y, ... voter]
+				let target_chunk = target_root_path.len() - common_count;
+				let min_chain_in_voter = (min_index + min_direction as usize) > target_chunk;
+
+				// walk over the cycle and update the weights
+				let mut should_inc_counter = true;
+				let start_operation_add = ((min_index % 2) + min_direction as usize) % 2 == 1;
+				let mut additional_removed = Vec::new();
+				for i in 0..cycle.len() {
+					let current = cycle[i].borrow();
+					if current.id.role == NodeRole::Voter {
+						let prev = cycle[prev_index(i)].borrow();
+						assignments
+							.iter_mut()
+							.enumerate()
+							.filter(|(_, a)| a.who == current.id.who)
+							.for_each(|(target_ass_index, ass)| {
+								ass.distribution
+									.iter_mut()
+									.position(|(t, _)| *t == prev.id.who)
+									.map(|idx| {
+										let next_value = if i % 2 == 0 {
+											if start_operation_add {
+												ass.distribution[idx].1.saturating_add(min_value)
+											} else {
+												ass.distribution[idx].1.saturating_sub(min_value)
+											}
+										} else if start_operation_add {
+											ass.distribution[idx].1.saturating_sub(min_value)
+										} else {
+											ass.distribution[idx].1.saturating_add(min_value)
+										};
+
+										if next_value.is_zero() {
+											// if the removed edge is from the current assignment,
+											// index should NOT be increased.
+											if target_ass_index == assignment_index {
+												should_inc_counter = false
+											}
+											ass.distribution.remove(idx);
+											num_changed += 1;
+											// only add if this is not the min itself.
+											if !(i == min_index && min_direction == 0) {
+												additional_removed.push((
+													cycle[i].clone(),
+													cycle[prev_index(i)].clone(),
+												));
+											}
+										} else {
+											ass.distribution[idx].1 = next_value;
+										}
+									});
+							});
+
+						let next = cycle[next_index(i)].borrow();
+						assignments
+							.iter_mut()
+							.enumerate()
+							.filter(|(_, a)| a.who == current.id.who)
+							.for_each(|(target_ass_index, ass)| {
+								ass.distribution
+									.iter_mut()
+									.position(|(t, _)| *t == next.id.who)
+									.map(|idx| {
+										let next_value = if i % 2 == 0 {
+											if start_operation_add {
+												ass.distribution[idx].1.saturating_sub(min_value)
+											} else {
+												ass.distribution[idx].1.saturating_add(min_value)
+											}
+										} else if start_operation_add {
+											ass.distribution[idx].1.saturating_add(min_value)
+										} else {
+											ass.distribution[idx].1.saturating_sub(min_value)
+										};
+
+										if next_value.is_zero() {
+											// if the removed edge is from the current assignment,
+											// index should NOT be increased.
+											if target_ass_index == assignment_index {
+												should_inc_counter = false
+											}
+											ass.distribution.remove(idx);
+											num_changed += 1;
+											if !(i == min_index && min_direction == 1) {
+												additional_removed.push((
+													cycle[i].clone(),
+													cycle[next_index(i)].clone(),
+												));
+											}
+										} else {
+											ass.distribution[idx].1 = next_value;
+										}
+									});
+							});
+					}
+				}
+
+				// don't do anything if the edge removed itself. This is always the first and last
+				// element
+				let should_reorg = !(min_index == (cycle.len() - 1) && min_direction == 1);
+
+				// re-org.
+				if should_reorg {
+					let min_edge = vec![min_voter, min_target];
+					if min_chain_in_voter {
+						// NOTE: safe; voter_root_path is always bigger than 1 element.
+						for i in 0..voter_root_path.len() - 1 {
+							let current = voter_root_path[i].clone().borrow().id.who.clone();
+							let next = voter_root_path[i + 1].clone().borrow().id.who.clone();
+							if min_edge.contains(&current) && min_edge.contains(&next) {
+								break
+							}
+							Node::set_parent_of(&voter_root_path[i + 1], &voter_root_path[i]);
+						}
+						Node::set_parent_of(&voter_node, &target_node);
+					} else {
+						// NOTE: safe; target_root_path is always bigger than 1 element.
+						for i in 0..target_root_path.len() - 1 {
+							let current = target_root_path[i].clone().borrow().id.who.clone();
+							let next = target_root_path[i + 1].clone().borrow().id.who.clone();
+							if min_edge.contains(&current) && min_edge.contains(&next) {
+								break
+							}
+							Node::set_parent_of(&target_root_path[i + 1], &target_root_path[i]);
+						}
+						Node::set_parent_of(&target_node, &voter_node);
+					}
+				}
+
+				// remove every other node which has collapsed to zero
+				for (r1, r2) in additional_removed {
+					if Node::is_parent_of(&r1, &r2) {
+						Node::remove_parent(&r1);
+					} else if Node::is_parent_of(&r2, &r1) {
+						Node::remove_parent(&r2);
+					}
+				}
+
+				// increment the counter if needed.
+				if should_inc_counter {
+					dist_index += 1;
+				}
+			}
+		}
+	}
+
+	num_changed
+}
+
+/// Reduce the given [`Vec<StakedAssignment<IdentifierT>>`]. This removes redundant edges without
+/// changing the overall backing of any of the elected candidates.
+///
+/// Returns the number of edges removed.
+///
+/// IMPORTANT: It is strictly assumed that the `who` attribute of all provided assignments are
+/// unique. The result will most likely be corrupt otherwise. Furthermore, if the _distribution
+/// vector_ contains duplicate ids, only the first instance is ever updates.
+///
+/// O(min{ |Ew| â‹… k + m3 , |Ew| â‹… m })
+pub fn reduce<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 where {
+	let mut num_changed = reduce_4(assignments);
+	num_changed += reduce_all(assignments);
+	num_changed
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn merging_works() {
+		// 	D <-- A <-- B <-- C
+		//
+		// 		F <-- E
+		let d = Node::new(NodeId::from(1, NodeRole::Target)).into_ref();
+		let a = Node::new(NodeId::from(2, NodeRole::Target)).into_ref();
+		let b = Node::new(NodeId::from(3, NodeRole::Target)).into_ref();
+		let c = Node::new(NodeId::from(4, NodeRole::Target)).into_ref();
+		let e = Node::new(NodeId::from(5, NodeRole::Target)).into_ref();
+		let f = Node::new(NodeId::from(6, NodeRole::Target)).into_ref();
+
+		Node::set_parent_of(&c, &b);
+		Node::set_parent_of(&b, &a);
+		Node::set_parent_of(&a, &d);
+		Node::set_parent_of(&e, &f);
+
+		let path1 = vec![c.clone(), b.clone(), a.clone(), d.clone()];
+		let path2 = vec![e.clone(), f.clone()];
+
+		merge(path1, path2);
+		// 	D <-- A <-- B <-- C
+		// 					  |
+		// 		F --> E --> -->
+		assert_eq!(e.borrow().clone().parent.unwrap().borrow().id.who, 4u32); // c
+	}
+
+	#[test]
+	fn merge_with_len_one() {
+		// 	D <-- A <-- B <-- C
+		//
+		// 		F <-- E
+		let d = Node::new(NodeId::from(1, NodeRole::Target)).into_ref();
+		let a = Node::new(NodeId::from(2, NodeRole::Target)).into_ref();
+		let b = Node::new(NodeId::from(3, NodeRole::Target)).into_ref();
+		let c = Node::new(NodeId::from(4, NodeRole::Target)).into_ref();
+		let f = Node::new(NodeId::from(6, NodeRole::Target)).into_ref();
+
+		Node::set_parent_of(&c, &b);
+		Node::set_parent_of(&b, &a);
+		Node::set_parent_of(&a, &d);
+
+		let path1 = vec![c.clone(), b.clone(), a.clone(), d.clone()];
+		let path2 = vec![f.clone()];
+
+		merge(path1, path2);
+		// 	D <-- A <-- B <-- C
+		// 					  |
+		// 			F -->  -->
+		assert_eq!(f.borrow().clone().parent.unwrap().borrow().id.who, 4u32); // c
+	}
+
+	#[test]
+	fn basic_reduce_4_cycle_works() {
+		use super::*;
+
+		let assignments = vec![
+			StakedAssignment { who: 1, distribution: vec![(10, 25), (20, 75)] },
+			StakedAssignment { who: 2, distribution: vec![(10, 50), (20, 50)] },
+		];
+
+		let mut new_assignments = assignments.clone();
+		let num_reduced = reduce_4(&mut new_assignments);
+
+		assert_eq!(num_reduced, 1);
+		assert_eq!(
+			new_assignments,
+			vec![
+				StakedAssignment { who: 1, distribution: vec![(20, 100),] },
+				StakedAssignment { who: 2, distribution: vec![(10, 75), (20, 25),] },
+			],
+		);
+	}
+
+	#[test]
+	fn basic_reduce_all_cycles_works() {
+		let mut assignments = vec![
+			StakedAssignment { who: 1, distribution: vec![(10, 10)] },
+			StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5)] },
+			StakedAssignment { who: 3, distribution: vec![(20, 15), (40, 15)] },
+			StakedAssignment { who: 4, distribution: vec![(20, 10), (30, 10), (40, 20)] },
+			StakedAssignment { who: 5, distribution: vec![(20, 20), (30, 10), (40, 20)] },
+		];
+
+		assert_eq!(3, reduce_all(&mut assignments));
+
+		assert_eq!(
+			assignments,
+			vec![
+				StakedAssignment { who: 1, distribution: vec![(10, 10),] },
+				StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5),] },
+				StakedAssignment { who: 3, distribution: vec![(20, 30),] },
+				StakedAssignment { who: 4, distribution: vec![(40, 40),] },
+				StakedAssignment { who: 5, distribution: vec![(20, 15), (30, 20), (40, 15),] },
+			],
+		)
+	}
+
+	#[test]
+	fn basic_reduce_works() {
+		let mut assignments = vec![
+			StakedAssignment { who: 1, distribution: vec![(10, 10)] },
+			StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5)] },
+			StakedAssignment { who: 3, distribution: vec![(20, 15), (40, 15)] },
+			StakedAssignment { who: 4, distribution: vec![(20, 10), (30, 10), (40, 20)] },
+			StakedAssignment { who: 5, distribution: vec![(20, 20), (30, 10), (40, 20)] },
+		];
+
+		assert_eq!(3, reduce(&mut assignments));
+
+		assert_eq!(
+			assignments,
+			vec![
+				StakedAssignment { who: 1, distribution: vec![(10, 10),] },
+				StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5),] },
+				StakedAssignment { who: 3, distribution: vec![(20, 30),] },
+				StakedAssignment { who: 4, distribution: vec![(40, 40),] },
+				StakedAssignment { who: 5, distribution: vec![(20, 15), (30, 20), (40, 15),] },
+			],
+		)
+	}
+
+	#[test]
+	fn should_deal_with_self_vote() {
+		let mut assignments = vec![
+			StakedAssignment { who: 1, distribution: vec![(10, 10)] },
+			StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5)] },
+			StakedAssignment { who: 3, distribution: vec![(20, 15), (40, 15)] },
+			StakedAssignment { who: 4, distribution: vec![(20, 10), (30, 10), (40, 20)] },
+			StakedAssignment { who: 5, distribution: vec![(20, 20), (30, 10), (40, 20)] },
+			// self vote from 10 and 20 to itself.
+			StakedAssignment { who: 10, distribution: vec![(10, 100)] },
+			StakedAssignment { who: 20, distribution: vec![(20, 200)] },
+		];
+
+		assert_eq!(3, reduce(&mut assignments));
+
+		assert_eq!(
+			assignments,
+			vec![
+				StakedAssignment { who: 1, distribution: vec![(10, 10),] },
+				StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5),] },
+				StakedAssignment { who: 3, distribution: vec![(20, 30),] },
+				StakedAssignment { who: 4, distribution: vec![(40, 40),] },
+				StakedAssignment { who: 5, distribution: vec![(20, 15), (30, 20), (40, 15),] },
+				// should stay untouched.
+				StakedAssignment { who: 10, distribution: vec![(10, 100)] },
+				StakedAssignment { who: 20, distribution: vec![(20, 200)] },
+			],
+		)
+	}
+
+	#[test]
+	fn reduce_3_common_votes_same_weight() {
+		let mut assignments = vec![
+			StakedAssignment {
+				who: 4,
+				distribution: vec![(1000000, 100), (1000002, 100), (1000004, 100)],
+			},
+			StakedAssignment {
+				who: 5,
+				distribution: vec![(1000000, 100), (1000002, 100), (1000004, 100)],
+			},
+		];
+
+		reduce_4(&mut assignments);
+
+		assert_eq!(
+			assignments,
+			vec![
+				StakedAssignment { who: 4, distribution: vec![(1000000, 200,), (1000004, 100,),] },
+				StakedAssignment { who: 5, distribution: vec![(1000002, 200,), (1000004, 100,),] },
+			],
+		)
+	}
+
+	#[test]
+	#[should_panic]
+	fn reduce_panics_on_duplicate_voter() {
+		let mut assignments = vec![
+			StakedAssignment { who: 1, distribution: vec![(10, 10), (20, 10)] },
+			StakedAssignment { who: 1, distribution: vec![(10, 15), (20, 5)] },
+			StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 15)] },
+		];
+
+		reduce(&mut assignments);
+	}
+
+	#[test]
+	fn should_deal_with_duplicates_target() {
+		let mut assignments = vec![
+			StakedAssignment { who: 1, distribution: vec![(10, 15), (20, 5)] },
+			StakedAssignment {
+				who: 2,
+				distribution: vec![
+					(10, 15),
+					(20, 15),
+					// duplicate
+					(10, 1),
+					// duplicate
+					(20, 1),
+				],
+			},
+		];
+
+		reduce(&mut assignments);
+
+		assert_eq!(
+			assignments,
+			vec![
+				StakedAssignment { who: 1, distribution: vec![(10, 20),] },
+				StakedAssignment {
+					who: 2,
+					distribution: vec![
+						(10, 10),
+						(20, 20),
+						// duplicate votes are silently ignored.
+						(10, 1),
+						(20, 1),
+					],
+				},
+			],
+		)
+	}
+
+	#[test]
+	fn bound_should_be_kept() {
+		let mut assignments = vec![
+			StakedAssignment {
+				who: 1,
+				distribution: vec![(103, 72), (101, 53), (100, 83), (102, 38)],
+			},
+			StakedAssignment {
+				who: 2,
+				distribution: vec![(103, 18), (101, 36), (102, 54), (100, 94)],
+			},
+			StakedAssignment {
+				who: 3,
+				distribution: vec![(100, 96), (101, 35), (102, 52), (103, 69)],
+			},
+			StakedAssignment {
+				who: 4,
+				distribution: vec![(102, 34), (100, 47), (103, 91), (101, 73)],
+			},
+		];
+
+		let winners = vec![103, 101, 100, 102];
+
+		let n = 4;
+		let m = winners.len() as u32;
+		let num_reduced = reduce_all(&mut assignments);
+		assert!(16 - num_reduced <= n + m);
+	}
+}
diff --git a/substrate/primitives/npos-elections/src/tests.rs b/substrate/primitives/npos-elections/src/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..72ae9a0222be1e5bf695eca5edba27e795a0932c
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/tests.rs
@@ -0,0 +1,905 @@
+// 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 npos-elections.
+
+use crate::{
+	balancing, helpers::*, mock::*, seq_phragmen, seq_phragmen_core, setup_inputs, to_support_map,
+	Assignment, BalancingConfig, ElectionResult, ExtendedBalance, StakedAssignment, Support, Voter,
+};
+use sp_arithmetic::{PerU16, Perbill, Percent, Permill};
+use substrate_test_utils::assert_eq_uvec;
+
+#[test]
+fn float_phragmen_poc_works() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![(10, vec![1, 2]), (20, vec![1, 3]), (30, vec![2, 3])];
+	let stake_of = create_stake_of(&[(10, 10), (20, 20), (30, 30), (1, 0), (2, 0), (3, 0)]);
+	let mut phragmen_result = elect_float(2, candidates, voters, &stake_of).unwrap();
+	let winners = phragmen_result.clone().winners;
+	let assignments = phragmen_result.clone().assignments;
+
+	assert_eq_uvec!(winners, vec![(2, 40), (3, 50)]);
+	assert_eq_uvec!(
+		assignments,
+		vec![(10, vec![(2, 1.0)]), (20, vec![(3, 1.0)]), (30, vec![(2, 0.5), (3, 0.5)]),]
+	);
+
+	let mut support_map = build_support_map_float(&mut phragmen_result, &stake_of);
+
+	assert_eq!(
+		support_map.get(&2).unwrap(),
+		&_Support { own: 0.0, total: 25.0, others: vec![(10u64, 10.0), (30u64, 15.0)] }
+	);
+	assert_eq!(
+		support_map.get(&3).unwrap(),
+		&_Support { own: 0.0, total: 35.0, others: vec![(20u64, 20.0), (30u64, 15.0)] }
+	);
+
+	equalize_float(phragmen_result.assignments, &mut support_map, 0.0, 2, stake_of);
+
+	assert_eq!(
+		support_map.get(&2).unwrap(),
+		&_Support { own: 0.0, total: 30.0, others: vec![(10u64, 10.0), (30u64, 20.0)] }
+	);
+	assert_eq!(
+		support_map.get(&3).unwrap(),
+		&_Support { own: 0.0, total: 30.0, others: vec![(20u64, 20.0), (30u64, 10.0)] }
+	);
+}
+
+#[test]
+fn phragmen_core_test_without_edges() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![(10, 10, vec![]), (20, 20, vec![]), (30, 30, vec![])];
+
+	let (candidates, voters) = setup_inputs(candidates, voters);
+
+	assert_eq!(
+		voters
+			.iter()
+			.map(|v| (
+				v.who,
+				v.budget,
+				(v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()),
+			))
+			.collect::<Vec<_>>(),
+		vec![]
+	);
+
+	assert_eq!(
+		candidates
+			.iter()
+			.map(|c_ptr| (
+				c_ptr.borrow().who,
+				c_ptr.borrow().elected,
+				c_ptr.borrow().round,
+				c_ptr.borrow().backed_stake,
+			))
+			.collect::<Vec<_>>(),
+		vec![(1, false, 0, 0), (2, false, 0, 0), (3, false, 0, 0),]
+	);
+}
+
+#[test]
+fn phragmen_core_poc_works() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![(10, 10, vec![1, 2]), (20, 20, vec![1, 3]), (30, 30, vec![2, 3])];
+
+	let (candidates, voters) = setup_inputs(candidates, voters);
+	let (candidates, voters) = seq_phragmen_core(2, candidates, voters).unwrap();
+
+	assert_eq!(
+		voters
+			.iter()
+			.map(|v| (
+				v.who,
+				v.budget,
+				(v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()),
+			))
+			.collect::<Vec<_>>(),
+		vec![(10, 10, vec![(2, 10)]), (20, 20, vec![(3, 20)]), (30, 30, vec![(2, 15), (3, 15)]),]
+	);
+
+	assert_eq!(
+		candidates
+			.iter()
+			.map(|c_ptr| (
+				c_ptr.borrow().who,
+				c_ptr.borrow().elected,
+				c_ptr.borrow().round,
+				c_ptr.borrow().backed_stake,
+			))
+			.collect::<Vec<_>>(),
+		vec![(1, false, 0, 0), (2, true, 1, 25), (3, true, 0, 35),]
+	);
+}
+
+#[test]
+fn balancing_core_works() {
+	let candidates = vec![1, 2, 3, 4, 5];
+	let voters = vec![
+		(10, 10, vec![1, 2]),
+		(20, 20, vec![1, 3]),
+		(30, 30, vec![1, 2, 3, 4]),
+		(40, 40, vec![1, 3, 4, 5]),
+		(50, 50, vec![2, 4, 5]),
+	];
+
+	let (candidates, voters) = setup_inputs(candidates, voters);
+	let (candidates, mut voters) = seq_phragmen_core(4, candidates, voters).unwrap();
+	let config = BalancingConfig { iterations: 4, tolerance: 0 };
+	let iters = balancing::balance::<AccountId>(&mut voters, &config);
+
+	assert!(iters > 0);
+
+	assert_eq!(
+		voters
+			.iter()
+			.map(|v| (
+				v.who,
+				v.budget,
+				(v.edges.iter().map(|e| (e.who, e.weight)).collect::<Vec<_>>()),
+			))
+			.collect::<Vec<_>>(),
+		vec![
+			// note the 0 edge. This is know and not an issue per se. Also note that the stakes are
+			// normalized.
+			(10, 10, vec![(1, 9), (2, 1)]),
+			(20, 20, vec![(1, 9), (3, 11)]),
+			(30, 30, vec![(1, 8), (2, 7), (3, 8), (4, 7)]),
+			(40, 40, vec![(1, 11), (3, 18), (4, 11)]),
+			(50, 50, vec![(2, 30), (4, 20)]),
+		]
+	);
+
+	assert_eq!(
+		candidates
+			.iter()
+			.map(|c_ptr| (
+				c_ptr.borrow().who,
+				c_ptr.borrow().elected,
+				c_ptr.borrow().round,
+				c_ptr.borrow().backed_stake,
+			))
+			.collect::<Vec<_>>(),
+		vec![
+			(1, true, 1, 37),
+			(2, true, 2, 38),
+			(3, true, 3, 37),
+			(4, true, 0, 38),
+			(5, false, 0, 0),
+		]
+	);
+}
+
+#[test]
+fn voter_normalize_ops_works() {
+	use crate::{Candidate, Edge};
+	// normalize
+	{
+		let c1 = Candidate { who: 10, elected: false, ..Default::default() };
+		let c2 = Candidate { who: 20, elected: false, ..Default::default() };
+		let c3 = Candidate { who: 30, elected: false, ..Default::default() };
+
+		let e1 = Edge::new(c1, 30);
+		let e2 = Edge::new(c2, 33);
+		let e3 = Edge::new(c3, 30);
+
+		let mut v = Voter { who: 1, budget: 100, edges: vec![e1, e2, e3], ..Default::default() };
+
+		v.try_normalize().unwrap();
+		assert_eq!(v.edges.iter().map(|e| e.weight).collect::<Vec<_>>(), vec![34, 33, 33]);
+	}
+	// // normalize_elected
+	{
+		let c1 = Candidate { who: 10, elected: false, ..Default::default() };
+		let c2 = Candidate { who: 20, elected: true, ..Default::default() };
+		let c3 = Candidate { who: 30, elected: true, ..Default::default() };
+
+		let e1 = Edge::new(c1, 30);
+		let e2 = Edge::new(c2, 33);
+		let e3 = Edge::new(c3, 30);
+
+		let mut v = Voter { who: 1, budget: 100, edges: vec![e1, e2, e3], ..Default::default() };
+
+		v.try_normalize_elected().unwrap();
+		assert_eq!(v.edges.iter().map(|e| e.weight).collect::<Vec<_>>(), vec![30, 34, 66]);
+	}
+}
+
+#[test]
+fn phragmen_poc_works() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![(10, vec![1, 2]), (20, vec![1, 3]), (30, vec![2, 3])];
+
+	let stake_of = create_stake_of(&[(10, 10), (20, 20), (30, 30)]);
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		2,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners, vec![(2, 25), (3, 35)]);
+	assert_eq_uvec!(
+		assignments,
+		vec![
+			Assignment { who: 10u64, distribution: vec![(2, Perbill::from_percent(100))] },
+			Assignment { who: 20, distribution: vec![(3, Perbill::from_percent(100))] },
+			Assignment {
+				who: 30,
+				distribution: vec![
+					(2, Perbill::from_percent(100 / 2)),
+					(3, Perbill::from_percent(100 / 2)),
+				],
+			},
+		]
+	);
+
+	let staked = assignment_ratio_to_staked(assignments, &stake_of);
+	let support_map = to_support_map::<AccountId>(&staked);
+
+	assert_eq_uvec!(
+		staked,
+		vec![
+			StakedAssignment { who: 10u64, distribution: vec![(2, 10)] },
+			StakedAssignment { who: 20, distribution: vec![(3, 20)] },
+			StakedAssignment { who: 30, distribution: vec![(2, 15), (3, 15),] },
+		]
+	);
+
+	assert_eq!(
+		*support_map.get(&2).unwrap(),
+		Support::<AccountId> { total: 25, voters: vec![(10, 10), (30, 15)] },
+	);
+	assert_eq!(
+		*support_map.get(&3).unwrap(),
+		Support::<AccountId> { total: 35, voters: vec![(20, 20), (30, 15)] },
+	);
+}
+
+#[test]
+fn phragmen_poc_works_with_balancing() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![(10, vec![1, 2]), (20, vec![1, 3]), (30, vec![2, 3])];
+
+	let stake_of = create_stake_of(&[(10, 10), (20, 20), (30, 30)]);
+	let config = BalancingConfig { iterations: 4, tolerance: 0 };
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		2,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		Some(config),
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners, vec![(2, 30), (3, 30)]);
+	assert_eq_uvec!(
+		assignments,
+		vec![
+			Assignment { who: 10u64, distribution: vec![(2, Perbill::from_percent(100))] },
+			Assignment { who: 20, distribution: vec![(3, Perbill::from_percent(100))] },
+			Assignment {
+				who: 30,
+				distribution: vec![
+					(2, Perbill::from_parts(666666666)),
+					(3, Perbill::from_parts(333333334)),
+				],
+			},
+		]
+	);
+
+	let staked = assignment_ratio_to_staked(assignments, &stake_of);
+	let support_map = to_support_map::<AccountId>(&staked);
+
+	assert_eq_uvec!(
+		staked,
+		vec![
+			StakedAssignment { who: 10u64, distribution: vec![(2, 10)] },
+			StakedAssignment { who: 20, distribution: vec![(3, 20)] },
+			StakedAssignment { who: 30, distribution: vec![(2, 20), (3, 10),] },
+		]
+	);
+
+	assert_eq!(
+		*support_map.get(&2).unwrap(),
+		Support::<AccountId> { total: 30, voters: vec![(10, 10), (30, 20)] },
+	);
+	assert_eq!(
+		*support_map.get(&3).unwrap(),
+		Support::<AccountId> { total: 30, voters: vec![(20, 20), (30, 10)] },
+	);
+}
+
+#[test]
+fn phragmen_poc_2_works() {
+	let candidates = vec![10, 20, 30];
+	let voters = vec![(2, vec![10, 20, 30]), (4, vec![10, 20, 40])];
+	let stake_of =
+		create_stake_of(&[(10, 1000), (20, 1000), (30, 1000), (40, 1000), (2, 500), (4, 500)]);
+
+	run_and_compare::<Perbill, _>(candidates.clone(), voters.clone(), &stake_of, 2);
+	run_and_compare::<Permill, _>(candidates.clone(), voters.clone(), &stake_of, 2);
+	run_and_compare::<Percent, _>(candidates.clone(), voters.clone(), &stake_of, 2);
+	run_and_compare::<PerU16, _>(candidates, voters, &stake_of, 2);
+}
+
+#[test]
+fn phragmen_poc_3_works() {
+	let candidates = vec![10, 20, 30];
+	let voters = vec![(2, vec![10, 20, 30]), (4, vec![10, 20, 40])];
+	let stake_of = create_stake_of(&[(10, 1000), (20, 1000), (30, 1000), (2, 50), (4, 1000)]);
+
+	run_and_compare::<Perbill, _>(candidates.clone(), voters.clone(), &stake_of, 2);
+	run_and_compare::<Permill, _>(candidates.clone(), voters.clone(), &stake_of, 2);
+	run_and_compare::<Percent, _>(candidates.clone(), voters.clone(), &stake_of, 2);
+	run_and_compare::<PerU16, _>(candidates, voters, &stake_of, 2);
+}
+
+#[test]
+fn phragmen_accuracy_on_large_scale_only_candidates() {
+	// because of this particular situation we had per_u128 and now rational128. In practice, a
+	// candidate can have the maximum amount of tokens, and also supported by the maximum.
+	let candidates = vec![1, 2, 3, 4, 5];
+	let stake_of = create_stake_of(&[
+		(1, (u64::MAX - 1).into()),
+		(2, (u64::MAX - 4).into()),
+		(3, (u64::MAX - 5).into()),
+		(4, (u64::MAX - 3).into()),
+		(5, (u64::MAX - 2).into()),
+	]);
+
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		2,
+		candidates.clone(),
+		auto_generate_self_voters(&candidates)
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners, vec![(1, 18446744073709551614u128), (5, 18446744073709551613u128)]);
+	assert_eq!(assignments.len(), 2);
+	check_assignments_sum(&assignments);
+}
+
+#[test]
+fn phragmen_accuracy_on_large_scale_voters_and_candidates() {
+	let candidates = vec![1, 2, 3, 4, 5];
+	let mut voters = vec![(13, vec![1, 3, 5]), (14, vec![2, 4])];
+	voters.extend(auto_generate_self_voters(&candidates));
+	let stake_of = create_stake_of(&[
+		(1, (u64::MAX - 1).into()),
+		(2, (u64::MAX - 4).into()),
+		(3, (u64::MAX - 5).into()),
+		(4, (u64::MAX - 3).into()),
+		(5, (u64::MAX - 2).into()),
+		(13, (u64::MAX - 10).into()),
+		(14, u64::MAX.into()),
+	]);
+
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		2,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners, vec![(2, 36893488147419103226u128), (1, 36893488147419103219u128)]);
+
+	assert_eq!(
+		assignments,
+		vec![
+			Assignment { who: 13u64, distribution: vec![(1, Perbill::one())] },
+			Assignment { who: 14, distribution: vec![(2, Perbill::one())] },
+			Assignment { who: 1, distribution: vec![(1, Perbill::one())] },
+			Assignment { who: 2, distribution: vec![(2, Perbill::one())] },
+		]
+	);
+
+	check_assignments_sum(&assignments);
+}
+
+#[test]
+fn phragmen_accuracy_on_small_scale_self_vote() {
+	let candidates = vec![40, 10, 20, 30];
+	let voters = auto_generate_self_voters(&candidates);
+	let stake_of = create_stake_of(&[(40, 0), (10, 1), (20, 2), (30, 1)]);
+
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		3,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners, vec![(20, 2), (10, 1), (30, 1)]);
+	check_assignments_sum(&assignments);
+}
+
+#[test]
+fn phragmen_accuracy_on_small_scale_no_self_vote() {
+	let candidates = vec![40, 10, 20, 30];
+	let voters = vec![(1, vec![10]), (2, vec![20]), (3, vec![30]), (4, vec![40])];
+	let stake_of = create_stake_of(&[
+		(40, 1000), // don't care
+		(10, 1000), // don't care
+		(20, 1000), // don't care
+		(30, 1000), // don't care
+		(4, 0),
+		(1, 1),
+		(2, 2),
+		(3, 1),
+	]);
+
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		3,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners, vec![(20, 2), (10, 1), (30, 1)]);
+	check_assignments_sum(&assignments);
+}
+
+#[test]
+fn phragmen_large_scale_test() {
+	let candidates = vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24];
+	let mut voters = vec![(50, vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24])];
+	voters.extend(auto_generate_self_voters(&candidates));
+	let stake_of = create_stake_of(&[
+		(2, 1),
+		(4, 100),
+		(6, 1000000),
+		(8, 100000000001000),
+		(10, 100000000002000),
+		(12, 100000000003000),
+		(14, 400000000000000),
+		(16, 400000000001000),
+		(18, 18000000000000000),
+		(20, 20000000000000000),
+		(22, 500000000000100000),
+		(24, 500000000000200000),
+		(50, 990000000000000000),
+	]);
+
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		2,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners.iter().map(|(x, _)| *x).collect::<Vec<_>>(), vec![24, 22]);
+	check_assignments_sum(&assignments);
+}
+
+#[test]
+fn phragmen_large_scale_test_2() {
+	let nom_budget: u64 = 1_000_000_000_000_000_000;
+	let c_budget: u64 = 4_000_000;
+
+	let candidates = vec![2, 4];
+	let mut voters = vec![(50, vec![2, 4])];
+	voters.extend(auto_generate_self_voters(&candidates));
+
+	let stake_of =
+		create_stake_of(&[(2, c_budget.into()), (4, c_budget.into()), (50, nom_budget.into())]);
+
+	let ElectionResult::<_, Perbill> { winners, assignments } = seq_phragmen(
+		2,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq_uvec!(winners, vec![(2, 500000000005000000u128), (4, 500000000003000000)]);
+
+	assert_eq_uvec!(
+		assignments,
+		vec![
+			Assignment {
+				who: 50u64,
+				distribution: vec![
+					(2, Perbill::from_parts(500000000)),
+					(4, Perbill::from_parts(500000000)),
+				],
+			},
+			Assignment { who: 2, distribution: vec![(2, Perbill::one())] },
+			Assignment { who: 4, distribution: vec![(4, Perbill::one())] },
+		],
+	);
+
+	check_assignments_sum(&assignments);
+}
+
+#[test]
+fn phragmen_linear_equalize() {
+	let candidates = vec![11, 21, 31, 41, 51, 61, 71];
+	let voters = vec![
+		(2, vec![11]),
+		(4, vec![11, 21]),
+		(6, vec![21, 31]),
+		(8, vec![31, 41]),
+		(110, vec![41, 51]),
+		(120, vec![51, 61]),
+		(130, vec![61, 71]),
+	];
+	let stake_of = create_stake_of(&[
+		(11, 1000),
+		(21, 1000),
+		(31, 1000),
+		(41, 1000),
+		(51, 1000),
+		(61, 1000),
+		(71, 1000),
+		(2, 2000),
+		(4, 1000),
+		(6, 1000),
+		(8, 1000),
+		(110, 1000),
+		(120, 1000),
+		(130, 1000),
+	]);
+
+	run_and_compare::<Perbill, _>(candidates, voters, &stake_of, 2);
+}
+
+#[test]
+fn elect_has_no_entry_barrier() {
+	let candidates = vec![10, 20, 30];
+	let voters = vec![(1, vec![10]), (2, vec![20])];
+	let stake_of = create_stake_of(&[(1, 10), (2, 10)]);
+
+	let ElectionResult::<_, Perbill> { winners, assignments: _ } = seq_phragmen(
+		3,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	// 30 is elected with stake 0. The caller is responsible for stripping this.
+	assert_eq_uvec!(winners, vec![(10, 10), (20, 10), (30, 0),]);
+}
+
+#[test]
+fn phragmen_self_votes_should_be_kept() {
+	let candidates = vec![5, 10, 20, 30];
+	let voters = vec![(5, vec![5]), (10, vec![10]), (20, vec![20]), (1, vec![10, 20])];
+	let stake_of = create_stake_of(&[(5, 5), (10, 10), (20, 20), (1, 8)]);
+
+	let result: ElectionResult<_, Perbill> = seq_phragmen(
+		2,
+		candidates,
+		voters
+			.iter()
+			.map(|(ref v, ref vs)| (*v, stake_of(v), vs.clone()))
+			.collect::<Vec<_>>(),
+		None,
+	)
+	.unwrap();
+
+	assert_eq!(result.winners, vec![(20, 24), (10, 14)]);
+	assert_eq_uvec!(
+		result.assignments,
+		vec![
+			Assignment {
+				who: 1,
+				distribution: vec![
+					(10, Perbill::from_percent(50)),
+					(20, Perbill::from_percent(50)),
+				]
+			},
+			Assignment { who: 10, distribution: vec![(10, Perbill::from_percent(100))] },
+			Assignment { who: 20, distribution: vec![(20, Perbill::from_percent(100))] },
+		]
+	);
+
+	let staked_assignments = assignment_ratio_to_staked(result.assignments, &stake_of);
+	let supports = to_support_map::<AccountId>(&staked_assignments);
+
+	assert_eq!(supports.get(&5u64), None);
+	assert_eq!(
+		supports.get(&10u64).unwrap(),
+		&Support { total: 14u128, voters: vec![(10u64, 10u128), (1u64, 4u128)] },
+	);
+	assert_eq!(
+		supports.get(&20u64).unwrap(),
+		&Support { total: 24u128, voters: vec![(20u64, 20u128), (1u64, 4u128)] },
+	);
+}
+
+#[test]
+fn duplicate_target_is_ignored() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![(10, 100, vec![1, 1, 2, 3]), (20, 100, vec![2, 3]), (30, 50, vec![1, 1, 2])];
+
+	let ElectionResult::<_, Perbill> { winners, assignments } =
+		seq_phragmen(2, candidates, voters, None).unwrap();
+
+	assert_eq!(winners, vec![(2, 140), (3, 110)]);
+	assert_eq!(
+		assignments
+			.into_iter()
+			.map(|x| (x.who, x.distribution.into_iter().map(|(w, _)| w).collect::<Vec<_>>()))
+			.collect::<Vec<_>>(),
+		vec![(10, vec![2, 3]), (20, vec![2, 3]), (30, vec![2]),],
+	);
+}
+
+#[test]
+fn duplicate_target_is_ignored_when_winner() {
+	let candidates = vec![1, 2, 3];
+	let voters = vec![(10, 100, vec![1, 1, 2, 3]), (20, 100, vec![1, 2])];
+
+	let ElectionResult::<_, Perbill> { winners, assignments } =
+		seq_phragmen(2, candidates, voters, None).unwrap();
+
+	assert_eq!(winners, vec![(1, 100), (2, 100)]);
+	assert_eq!(
+		assignments
+			.into_iter()
+			.map(|x| (x.who, x.distribution.into_iter().map(|(w, _)| w).collect::<Vec<_>>()))
+			.collect::<Vec<_>>(),
+		vec![(10, vec![1, 2]), (20, vec![1, 2]),],
+	);
+}
+
+mod assignment_convert_normalize {
+	use super::*;
+	#[test]
+	fn assignment_convert_works() {
+		let staked = StakedAssignment {
+			who: 1 as AccountId,
+			distribution: vec![(20, 100 as ExtendedBalance), (30, 25)],
+		};
+
+		let assignment = staked.clone().into_assignment();
+		assert_eq!(
+			assignment,
+			Assignment {
+				who: 1,
+				distribution: vec![
+					(20, Perbill::from_percent(80)),
+					(30, Perbill::from_percent(20)),
+				]
+			}
+		);
+
+		assert_eq!(assignment.into_staked(125), staked);
+	}
+
+	#[test]
+	fn assignment_convert_will_not_normalize() {
+		assert_eq!(
+			Assignment {
+				who: 1,
+				distribution: vec![(2, Perbill::from_percent(33)), (3, Perbill::from_percent(66)),]
+			}
+			.into_staked(100),
+			StakedAssignment {
+				who: 1,
+				distribution: vec![
+					(2, 33),
+					(3, 66),
+					// sum is not 100!
+				],
+			},
+		);
+
+		assert_eq!(
+			StakedAssignment {
+				who: 1,
+				distribution: vec![
+					(2, 333_333_333_333_333),
+					(3, 333_333_333_333_333),
+					(4, 666_666_666_666_333),
+				],
+			}
+			.into_assignment(),
+			Assignment {
+				who: 1,
+				distribution: vec![
+					(2, Perbill::from_parts(250000000)),
+					(3, Perbill::from_parts(250000000)),
+					(4, Perbill::from_parts(499999999)),
+					// sum is not 100%!
+				]
+			},
+		)
+	}
+
+	#[test]
+	fn assignment_can_normalize() {
+		let mut a = Assignment {
+			who: 1,
+			distribution: vec![
+				(2, Perbill::from_parts(330000000)),
+				(3, Perbill::from_parts(660000000)),
+				// sum is not 100%!
+			],
+		};
+		a.try_normalize().unwrap();
+		assert_eq!(
+			a,
+			Assignment {
+				who: 1,
+				distribution: vec![
+					(2, Perbill::from_parts(340000000)),
+					(3, Perbill::from_parts(660000000)),
+				]
+			},
+		);
+	}
+
+	#[test]
+	fn staked_assignment_can_normalize() {
+		let mut a = StakedAssignment { who: 1, distribution: vec![(2, 33), (3, 66)] };
+		a.try_normalize(100).unwrap();
+		assert_eq!(a, StakedAssignment { who: 1, distribution: vec![(2, 34), (3, 66),] });
+	}
+}
+
+mod score {
+	use super::*;
+	use crate::ElectionScore;
+	use sp_arithmetic::PerThing;
+
+	/// NOTE: in tests, we still use the legacy [u128; 3] since it is more compact. Each `u128`
+	/// corresponds to element at the respective field index of `ElectionScore`.
+	impl From<[ExtendedBalance; 3]> for ElectionScore {
+		fn from(t: [ExtendedBalance; 3]) -> Self {
+			Self { minimal_stake: t[0], sum_stake: t[1], sum_stake_squared: t[2] }
+		}
+	}
+
+	fn is_score_better(this: [u128; 3], that: [u128; 3], p: impl PerThing) -> bool {
+		ElectionScore::from(this).strict_threshold_better(ElectionScore::from(that), p)
+	}
+
+	#[test]
+	fn score_comparison_is_lexicographical_no_epsilon() {
+		let epsilon = Perbill::zero();
+		// only better in the fist parameter, worse in the other two ✅
+		assert_eq!(is_score_better([12, 10, 35], [10, 20, 30], epsilon), true);
+
+		// worse in the first, better in the other two �
+		assert_eq!(is_score_better([9, 30, 10], [10, 20, 30], epsilon), false);
+
+		// equal in the first, the second one dictates.
+		assert_eq!(is_score_better([10, 25, 40], [10, 20, 30], epsilon), true);
+
+		// equal in the first two, the last one dictates.
+		assert_eq!(is_score_better([10, 20, 40], [10, 20, 30], epsilon), false);
+	}
+
+	#[test]
+	fn score_comparison_with_epsilon() {
+		let epsilon = Perbill::from_percent(1);
+
+		{
+			// no more than 1 percent (10) better in the first param.
+			assert_eq!(is_score_better([1009, 5000, 100000], [1000, 5000, 100000], epsilon), false);
+
+			// now equal, still not better.
+			assert_eq!(is_score_better([1010, 5000, 100000], [1000, 5000, 100000], epsilon), false);
+
+			// now it is.
+			assert_eq!(is_score_better([1011, 5000, 100000], [1000, 5000, 100000], epsilon), true);
+		}
+
+		{
+			// First score score is epsilon better, but first score is no longer `ge`. Then this is
+			// still not a good solution.
+			assert_eq!(is_score_better([999, 6000, 100000], [1000, 5000, 100000], epsilon), false);
+		}
+
+		{
+			// first score is equal or better, but not epsilon. Then second one is the determinant.
+			assert_eq!(is_score_better([1005, 5000, 100000], [1000, 5000, 100000], epsilon), false);
+
+			assert_eq!(is_score_better([1005, 5050, 100000], [1000, 5000, 100000], epsilon), false);
+
+			assert_eq!(is_score_better([1005, 5051, 100000], [1000, 5000, 100000], epsilon), true);
+		}
+
+		{
+			// first score and second are equal or less than epsilon more, third is determinant.
+			assert_eq!(is_score_better([1005, 5025, 100000], [1000, 5000, 100000], epsilon), false);
+
+			assert_eq!(is_score_better([1005, 5025, 99_000], [1000, 5000, 100000], epsilon), false);
+
+			assert_eq!(is_score_better([1005, 5025, 98_999], [1000, 5000, 100000], epsilon), true);
+		}
+	}
+
+	#[test]
+	fn score_comparison_large_value() {
+		// some random value taken from eras in kusama.
+		let initial =
+			[12488167277027543u128, 5559266368032409496, 118749283262079244270992278287436446];
+		// this claim is 0.04090% better in the third component. It should be accepted as better if
+		// epsilon is smaller than 5/10_0000
+		let claim =
+			[12488167277027543u128, 5559266368032409496, 118700736389524721358337889258988054];
+
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(1u32, 10_000),), true,);
+
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(2u32, 10_000),), true,);
+
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(3u32, 10_000),), true,);
+
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(4u32, 10_000),), true,);
+
+		assert_eq!(is_score_better(claim, initial, Perbill::from_rational(5u32, 10_000),), false,);
+	}
+
+	#[test]
+	fn ord_works() {
+		// equal only when all elements are equal
+		assert!(ElectionScore::from([10, 5, 15]) == ElectionScore::from([10, 5, 15]));
+		assert!(ElectionScore::from([10, 5, 15]) != ElectionScore::from([9, 5, 15]));
+		assert!(ElectionScore::from([10, 5, 15]) != ElectionScore::from([10, 5, 14]));
+
+		// first element greater, rest don't matter
+		assert!(ElectionScore::from([10, 5, 15]) > ElectionScore::from([8, 5, 25]));
+		assert!(ElectionScore::from([10, 5, 15]) > ElectionScore::from([9, 20, 5]));
+
+		// second element greater, rest don't matter
+		assert!(ElectionScore::from([10, 5, 15]) > ElectionScore::from([10, 4, 25]));
+		assert!(ElectionScore::from([10, 5, 15]) > ElectionScore::from([10, 4, 5]));
+
+		// second element is less, rest don't matter. Note that this is swapped.
+		assert!(ElectionScore::from([10, 5, 15]) > ElectionScore::from([10, 5, 16]));
+		assert!(ElectionScore::from([10, 5, 15]) > ElectionScore::from([10, 5, 25]));
+	}
+}
diff --git a/substrate/primitives/npos-elections/src/traits.rs b/substrate/primitives/npos-elections/src/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d49970873b7072c364e1bf26d713a4498a92578b
--- /dev/null
+++ b/substrate/primitives/npos-elections/src/traits.rs
@@ -0,0 +1,31 @@
+// 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
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// distributed under the License is distributed on an "AS IS" BASIS,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Traits for the npos-election operations.
+
+use crate::ExtendedBalance;
+use sp_arithmetic::PerThing;
+use sp_std::{fmt::Debug, ops::Mul, prelude::*};
+
+/// an aggregator trait for a generic type of a voter/target identifier. This usually maps to
+/// substrate's account id.
+pub trait IdentifierT: Clone + Eq + Ord + Debug + codec::Codec {}
+impl<T: Clone + Eq + Ord + Debug + codec::Codec> IdentifierT for T {}
+
+/// Aggregator trait for a PerThing that can be multiplied by u128 (ExtendedBalance).
+pub trait PerThing128: PerThing + Mul<ExtendedBalance, Output = ExtendedBalance> {}
+impl<T: PerThing + Mul<ExtendedBalance, Output = ExtendedBalance>> PerThing128 for T {}
diff --git a/substrate/primitives/offchain/Cargo.toml b/substrate/primitives/offchain/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0e1c98fb1cf17b8791a4535bd690b669e772944f
--- /dev/null
+++ b/substrate/primitives/offchain/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+description = "Substrate offchain workers primitives"
+name = "sp-offchain"
+version = "4.0.0-dev"
+license = "Apache-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+
+[features]
+default = [ "std" ]
+std = [ "sp-api/std", "sp-core/std", "sp-runtime/std" ]
diff --git a/substrate/primitives/offchain/README.md b/substrate/primitives/offchain/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a8620d3bb9d5b2a6d45e27404891cece853eafc8
--- /dev/null
+++ b/substrate/primitives/offchain/README.md
@@ -0,0 +1,3 @@
+The Offchain Worker runtime api primitives.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/offchain/src/lib.rs b/substrate/primitives/offchain/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..56de4f1589f83b73cb8de3ca706677e0b70c775c
--- /dev/null
+++ b/substrate/primitives/offchain/src/lib.rs
@@ -0,0 +1,37 @@
+// 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.
+
+//! The Offchain Worker runtime api primitives.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![warn(missing_docs)]
+
+/// Re-export of parent module scope storage prefix.
+pub use sp_core::offchain::STORAGE_PREFIX;
+
+sp_api::decl_runtime_apis! {
+	/// The offchain worker api.
+	#[api_version(2)]
+	pub trait OffchainWorkerApi {
+		/// Starts the off-chain task for given block number.
+		#[changed_in(2)]
+		fn offchain_worker(number: sp_runtime::traits::NumberFor<Block>);
+
+		/// Starts the off-chain task for given block header.
+		fn offchain_worker(header: &Block::Header);
+	}
+}
diff --git a/substrate/primitives/panic-handler/Cargo.toml b/substrate/primitives/panic-handler/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e73cfa98ca4182b93b36e0c63103606534b8e0e6
--- /dev/null
+++ b/substrate/primitives/panic-handler/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "sp-panic-handler"
+version = "8.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Custom panic hook with bug report link"
+documentation = "https://docs.rs/sp-panic-handler"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+backtrace = "0.3.64"
+lazy_static = "1.4.0"
+regex = "1.6.0"
diff --git a/substrate/primitives/panic-handler/README.md b/substrate/primitives/panic-handler/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c08396960f4c953abda24049359cbb6649dbc7d2
--- /dev/null
+++ b/substrate/primitives/panic-handler/README.md
@@ -0,0 +1,10 @@
+Custom panic hook with bug report link
+
+This crate provides the [`set`] function, which wraps around [`std::panic::set_hook`] and
+sets up a panic hook that prints a backtrace and invites the user to open an issue to the
+given URL.
+
+By default, the panic handler aborts the process by calling [`std::process::exit`]. This can
+temporarily be disabled by using an [`AbortGuard`].
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/panic-handler/src/lib.rs b/substrate/primitives/panic-handler/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e2a9bfa195a6672d13c472b115b3ca4ed4348325
--- /dev/null
+++ b/substrate/primitives/panic-handler/src/lib.rs
@@ -0,0 +1,245 @@
+// 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.
+
+//! Custom panic hook with bug report link
+//!
+//! This crate provides the [`set`] function, which wraps around [`std::panic::set_hook`] and
+//! sets up a panic hook that prints a backtrace and invites the user to open an issue to the
+//! given URL.
+//!
+//! By default, the panic handler aborts the process by calling [`std::process::exit`]. This can
+//! temporarily be disabled by using an [`AbortGuard`].
+
+use backtrace::Backtrace;
+use regex::Regex;
+use std::{
+	cell::Cell,
+	io::{self, Write},
+	marker::PhantomData,
+	panic::{self, PanicInfo},
+	thread,
+};
+
+thread_local! {
+	static ON_PANIC: Cell<OnPanic> = Cell::new(OnPanic::Abort);
+}
+
+/// Panic action.
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum OnPanic {
+	/// Abort when panic occurs.
+	Abort,
+	/// Unwind when panic occurs.
+	Unwind,
+	/// Always unwind even if someone changes strategy to Abort afterwards.
+	NeverAbort,
+}
+
+/// Set the panic hook.
+///
+/// Calls [`std::panic::set_hook`] to set up the panic hook.
+///
+/// The `bug_url` parameter is an invitation for users to visit that URL to submit a bug report
+/// in the case where a panic happens.
+pub fn set(bug_url: &str, version: &str) {
+	panic::set_hook(Box::new({
+		let version = version.to_string();
+		let bug_url = bug_url.to_string();
+		move |c| panic_hook(c, &bug_url, &version)
+	}));
+}
+
+macro_rules! ABOUT_PANIC {
+	() => {
+		"
+This is a bug. Please report it at:
+
+	{}
+"
+	};
+}
+
+/// Set aborting flag. Returns previous value of the flag.
+fn set_abort(on_panic: OnPanic) -> OnPanic {
+	ON_PANIC.with(|val| {
+		let prev = val.get();
+		match prev {
+			OnPanic::Abort | OnPanic::Unwind => val.set(on_panic),
+			OnPanic::NeverAbort => (),
+		}
+		prev
+	})
+}
+
+/// RAII guard for whether panics in the current thread should unwind or abort.
+///
+/// Sets a thread-local abort flag on construction and reverts to the previous setting when dropped.
+/// Does not implement `Send` on purpose.
+///
+/// > **Note**: Because we restore the previous value when dropped, you are encouraged to leave
+/// > the `AbortGuard` on the stack and let it destroy itself naturally.
+pub struct AbortGuard {
+	/// Value that was in `ABORT` before we created this guard.
+	previous_val: OnPanic,
+	/// Marker so that `AbortGuard` doesn't implement `Send`.
+	_not_send: PhantomData<std::rc::Rc<()>>,
+}
+
+impl AbortGuard {
+	/// Create a new guard. While the guard is alive, panics that happen in the current thread will
+	/// unwind the stack (unless another guard is created afterwards).
+	pub fn force_unwind() -> AbortGuard {
+		AbortGuard { previous_val: set_abort(OnPanic::Unwind), _not_send: PhantomData }
+	}
+
+	/// Create a new guard. While the guard is alive, panics that happen in the current thread will
+	/// abort the process (unless another guard is created afterwards).
+	pub fn force_abort() -> AbortGuard {
+		AbortGuard { previous_val: set_abort(OnPanic::Abort), _not_send: PhantomData }
+	}
+
+	/// Create a new guard. While the guard is alive, panics that happen in the current thread will
+	/// **never** abort the process (even if `AbortGuard::force_abort()` guard will be created
+	/// afterwards).
+	pub fn never_abort() -> AbortGuard {
+		AbortGuard { previous_val: set_abort(OnPanic::NeverAbort), _not_send: PhantomData }
+	}
+}
+
+impl Drop for AbortGuard {
+	fn drop(&mut self) {
+		set_abort(self.previous_val);
+	}
+}
+
+// NOTE: When making any changes here make sure to also change this function in `sc-tracing`.
+fn strip_control_codes(input: &str) -> std::borrow::Cow<str> {
+	lazy_static::lazy_static! {
+		static ref RE: Regex = Regex::new(r#"(?x)
+			\x1b\[[^m]+m|        # VT100 escape codes
+			[
+			  \x00-\x09\x0B-\x1F # ASCII control codes / Unicode C0 control codes, except \n
+			  \x7F               # ASCII delete
+			  \u{80}-\u{9F}      # Unicode C1 control codes
+			  \u{202A}-\u{202E}  # Unicode left-to-right / right-to-left control characters
+			  \u{2066}-\u{2069}  # Same as above
+			]
+		"#).expect("regex parsing doesn't fail; qed");
+	}
+
+	RE.replace_all(input, "")
+}
+
+/// Function being called when a panic happens.
+fn panic_hook(info: &PanicInfo, report_url: &str, version: &str) {
+	let location = info.location();
+	let file = location.as_ref().map(|l| l.file()).unwrap_or("<unknown>");
+	let line = location.as_ref().map(|l| l.line()).unwrap_or(0);
+
+	let msg = match info.payload().downcast_ref::<&'static str>() {
+		Some(s) => *s,
+		None => match info.payload().downcast_ref::<String>() {
+			Some(s) => &s[..],
+			None => "Box<Any>",
+		},
+	};
+
+	let msg = strip_control_codes(msg);
+
+	let thread = thread::current();
+	let name = thread.name().unwrap_or("<unnamed>");
+
+	let backtrace = Backtrace::new();
+
+	let mut stderr = io::stderr();
+
+	let _ = writeln!(stderr);
+	let _ = writeln!(stderr, "====================");
+	let _ = writeln!(stderr);
+	let _ = writeln!(stderr, "Version: {}", version);
+	let _ = writeln!(stderr);
+	let _ = writeln!(stderr, "{:?}", backtrace);
+	let _ = writeln!(stderr);
+	let _ = writeln!(stderr, "Thread '{}' panicked at '{}', {}:{}", name, msg, file, line);
+
+	let _ = writeln!(stderr, ABOUT_PANIC!(), report_url);
+	ON_PANIC.with(|val| {
+		if val.get() == OnPanic::Abort {
+			::std::process::exit(1);
+		}
+	})
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn does_not_abort() {
+		set("test", "1.2.3");
+		let _guard = AbortGuard::force_unwind();
+		::std::panic::catch_unwind(|| panic!()).ok();
+	}
+
+	#[test]
+	fn does_not_abort_after_never_abort() {
+		set("test", "1.2.3");
+		let _guard = AbortGuard::never_abort();
+		let _guard = AbortGuard::force_abort();
+		std::panic::catch_unwind(|| panic!()).ok();
+	}
+
+	fn run_test_in_another_process(
+		test_name: &str,
+		test_body: impl FnOnce(),
+	) -> Option<std::process::Output> {
+		if std::env::var("RUN_FORKED_TEST").is_ok() {
+			test_body();
+			None
+		} else {
+			let output = std::process::Command::new(std::env::current_exe().unwrap())
+				.arg(test_name)
+				.env("RUN_FORKED_TEST", "1")
+				.output()
+				.unwrap();
+
+			assert!(output.status.success());
+			Some(output)
+		}
+	}
+
+	#[test]
+	fn control_characters_are_always_stripped_out_from_the_panic_messages() {
+		const RAW_LINE: &str = "$$START$$\x1B[1;32mIn\u{202a}\u{202e}\u{2066}\u{2069}ner\n\r\x7ftext!\u{80}\u{9f}\x1B[0m$$END$$";
+		const SANITIZED_LINE: &str = "$$START$$Inner\ntext!$$END$$";
+
+		let output = run_test_in_another_process(
+			"control_characters_are_always_stripped_out_from_the_panic_messages",
+			|| {
+				set("test", "1.2.3");
+				let _guard = AbortGuard::force_unwind();
+				let _ = std::panic::catch_unwind(|| panic!("{}", RAW_LINE));
+			},
+		);
+
+		if let Some(output) = output {
+			let stderr = String::from_utf8(output.stderr).unwrap();
+			assert!(!stderr.contains(RAW_LINE));
+			assert!(stderr.contains(SANITIZED_LINE));
+		}
+	}
+}
diff --git a/substrate/primitives/rpc/Cargo.toml b/substrate/primitives/rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..37840c38e79f18c14e6ad851cdcbd336716cd0c4
--- /dev/null
+++ b/substrate/primitives/rpc/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "sp-rpc"
+version = "6.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate RPC primitives and utilities."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+rustc-hash = "1.1.0"
+serde = { version = "1.0.163", features = ["derive"] }
+sp-core = { version = "21.0.0", path = "../core" }
+
+[dev-dependencies]
+serde_json = "1.0.85"
diff --git a/substrate/primitives/rpc/README.md b/substrate/primitives/rpc/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8a9c17edd4755be7c9b040bde1019ea85fabb1be
--- /dev/null
+++ b/substrate/primitives/rpc/README.md
@@ -0,0 +1,3 @@
+Substrate RPC primitives and utilities.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/rpc/src/lib.rs b/substrate/primitives/rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4dbc629bb967ac5f63d9ca0971d34d739fafb1c3
--- /dev/null
+++ b/substrate/primitives/rpc/src/lib.rs
@@ -0,0 +1,34 @@
+// 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.
+
+//! Substrate RPC primitives and utilities.
+
+#![warn(missing_docs)]
+
+pub mod list;
+pub mod number;
+pub mod tracing;
+
+/// A util function to assert the result of serialization and deserialization is the same.
+#[cfg(test)]
+pub(crate) fn assert_deser<T>(s: &str, expected: T)
+where
+	T: std::fmt::Debug + serde::ser::Serialize + serde::de::DeserializeOwned + PartialEq,
+{
+	assert_eq!(serde_json::from_str::<T>(s).unwrap(), expected);
+	assert_eq!(serde_json::to_string(&expected).unwrap(), s);
+}
diff --git a/substrate/primitives/rpc/src/list.rs b/substrate/primitives/rpc/src/list.rs
new file mode 100644
index 0000000000000000000000000000000000000000..860e5161b97c1d4414c63e418f648c13c82936cc
--- /dev/null
+++ b/substrate/primitives/rpc/src/list.rs
@@ -0,0 +1,76 @@
+// 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.
+
+//! RPC a lenient list or value type.
+
+use serde::{Deserialize, Serialize};
+
+/// RPC list or value wrapper.
+///
+/// For some RPCs it's convenient to call them with either
+/// a single value or a whole list of values to get a proper response.
+/// In theory you could do a batch query, but it's:
+/// 1. Less convenient in client libraries
+/// 2. If the response value is small, the protocol overhead might be dominant.
+///
+/// Also it's nice to be able to maintain backward compatibility for methods that
+/// were initially taking a value and now we want to expand them to take a list.
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[serde(untagged)]
+pub enum ListOrValue<T> {
+	/// A list of values of given type.
+	List(Vec<T>),
+	/// A single value of given type.
+	Value(T),
+}
+
+impl<T> ListOrValue<T> {
+	/// Map every contained value using function `F`.
+	///
+	/// This allows to easily convert all values in any of the variants.
+	pub fn map<F: Fn(T) -> X, X>(self, f: F) -> ListOrValue<X> {
+		match self {
+			ListOrValue::List(v) => ListOrValue::List(v.into_iter().map(f).collect()),
+			ListOrValue::Value(v) => ListOrValue::Value(f(v)),
+		}
+	}
+}
+
+impl<T> From<T> for ListOrValue<T> {
+	fn from(n: T) -> Self {
+		ListOrValue::Value(n)
+	}
+}
+
+impl<T> From<Vec<T>> for ListOrValue<T> {
+	fn from(n: Vec<T>) -> Self {
+		ListOrValue::List(n)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::assert_deser;
+
+	#[test]
+	fn should_serialize_and_deserialize() {
+		assert_deser(r#"5"#, ListOrValue::Value(5_u64));
+		assert_deser(r#""str""#, ListOrValue::Value("str".to_string()));
+		assert_deser(r#"[1,2,3]"#, ListOrValue::List(vec![1_u64, 2_u64, 3_u64]));
+	}
+}
diff --git a/substrate/primitives/rpc/src/number.rs b/substrate/primitives/rpc/src/number.rs
new file mode 100644
index 0000000000000000000000000000000000000000..28caa243eb7008a51fc4337cfe881f188bdc95b5
--- /dev/null
+++ b/substrate/primitives/rpc/src/number.rs
@@ -0,0 +1,126 @@
+// 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 number type that can be serialized both as a number or a string that encodes a number in a
+//! string.
+
+use serde::{Deserialize, Serialize};
+use sp_core::U256;
+use std::fmt::Debug;
+
+/// A number type that can be serialized both as a number or a string that encodes a number in a
+/// string.
+///
+/// We allow two representations of the block number as input. Either we deserialize to the type
+/// that is specified in the block type or we attempt to parse given hex value.
+///
+/// The primary motivation for having this type is to avoid overflows when using big integers in
+/// JavaScript (which we consider as an important RPC API consumer).
+#[derive(Copy, Clone, Serialize, Deserialize, Debug, PartialEq)]
+#[serde(untagged)]
+pub enum NumberOrHex {
+	/// The number represented directly.
+	Number(u64),
+	/// Hex representation of the number.
+	Hex(U256),
+}
+
+impl Default for NumberOrHex {
+	fn default() -> Self {
+		Self::Number(Default::default())
+	}
+}
+
+impl NumberOrHex {
+	/// Converts this number into an U256.
+	pub fn into_u256(self) -> U256 {
+		match self {
+			NumberOrHex::Number(n) => n.into(),
+			NumberOrHex::Hex(h) => h,
+		}
+	}
+}
+
+impl From<u32> for NumberOrHex {
+	fn from(n: u32) -> Self {
+		NumberOrHex::Number(n.into())
+	}
+}
+
+impl From<u64> for NumberOrHex {
+	fn from(n: u64) -> Self {
+		NumberOrHex::Number(n)
+	}
+}
+
+impl From<u128> for NumberOrHex {
+	fn from(n: u128) -> Self {
+		NumberOrHex::Hex(n.into())
+	}
+}
+
+impl From<U256> for NumberOrHex {
+	fn from(n: U256) -> Self {
+		NumberOrHex::Hex(n)
+	}
+}
+
+/// An error type that signals an out-of-range conversion attempt.
+pub struct TryFromIntError(pub(crate) ());
+
+impl TryFrom<NumberOrHex> for u32 {
+	type Error = TryFromIntError;
+	fn try_from(num_or_hex: NumberOrHex) -> Result<u32, Self::Error> {
+		num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(()))
+	}
+}
+
+impl TryFrom<NumberOrHex> for u64 {
+	type Error = TryFromIntError;
+	fn try_from(num_or_hex: NumberOrHex) -> Result<u64, Self::Error> {
+		num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(()))
+	}
+}
+
+impl TryFrom<NumberOrHex> for u128 {
+	type Error = TryFromIntError;
+	fn try_from(num_or_hex: NumberOrHex) -> Result<u128, Self::Error> {
+		num_or_hex.into_u256().try_into().map_err(|_| TryFromIntError(()))
+	}
+}
+
+impl From<NumberOrHex> for U256 {
+	fn from(num_or_hex: NumberOrHex) -> U256 {
+		num_or_hex.into_u256()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::assert_deser;
+
+	#[test]
+	fn should_serialize_and_deserialize() {
+		assert_deser(r#""0x1234""#, NumberOrHex::Hex(0x1234.into()));
+		assert_deser(r#""0x0""#, NumberOrHex::Hex(0.into()));
+		assert_deser(r#"5"#, NumberOrHex::Number(5));
+		assert_deser(r#"10000"#, NumberOrHex::Number(10000));
+		assert_deser(r#"0"#, NumberOrHex::Number(0));
+		assert_deser(r#"1000000000000"#, NumberOrHex::Number(1000000000000));
+	}
+}
diff --git a/substrate/primitives/rpc/src/tracing.rs b/substrate/primitives/rpc/src/tracing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eb3fd4784335764163d46faf00e99a961431a614
--- /dev/null
+++ b/substrate/primitives/rpc/src/tracing.rs
@@ -0,0 +1,101 @@
+// 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.
+
+//! Types for working with tracing data
+
+use serde::{Deserialize, Serialize};
+
+use rustc_hash::FxHashMap;
+
+/// Container for all related spans and events for the block being traced.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct BlockTrace {
+	/// Hash of the block being traced
+	pub block_hash: String,
+	/// Parent hash
+	pub parent_hash: String,
+	/// Module targets that were recorded by the tracing subscriber.
+	/// Empty string means record all targets.
+	pub tracing_targets: String,
+	/// Storage key targets used to filter out events that do not have one of the storage keys.
+	/// Empty string means do not filter out any events.
+	pub storage_keys: String,
+	/// Method targets used to filter out events that do not have one of the event method.
+	/// Empty string means do not filter out any events.
+	pub methods: String,
+	/// Vec of tracing spans
+	pub spans: Vec<Span>,
+	/// Vec of tracing events
+	pub events: Vec<Event>,
+}
+
+/// Represents a tracing event, complete with recorded data.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Event {
+	/// Event target
+	pub target: String,
+	/// Associated data
+	pub data: Data,
+	/// Parent id, if it exists
+	pub parent_id: Option<u64>,
+}
+
+/// Represents a single instance of a tracing span.
+///
+/// Exiting a span does not imply that the span will not be re-entered.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Span {
+	/// id for this span
+	pub id: u64,
+	/// id of the parent span, if any
+	pub parent_id: Option<u64>,
+	/// Name of this span
+	pub name: String,
+	/// Target, typically module
+	pub target: String,
+	/// Indicates if the span is from wasm
+	pub wasm: bool,
+}
+
+/// Holds associated values for a tracing span.
+#[derive(Serialize, Deserialize, Default, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Data {
+	/// HashMap of `String` values recorded while tracing
+	pub string_values: FxHashMap<String, String>,
+}
+
+/// Error response for the `state_traceBlock` RPC.
+#[derive(Serialize, Deserialize, Default, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct TraceError {
+	/// Error message
+	pub error: String,
+}
+
+/// Response for the `state_traceBlock` RPC.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub enum TraceBlockResponse {
+	/// Error block tracing response
+	TraceError(TraceError),
+	/// Successful block tracing response
+	BlockTrace(BlockTrace),
+}
diff --git a/substrate/primitives/runtime-interface/Cargo.toml b/substrate/primitives/runtime-interface/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..49ed49e1b417ef9ff2bd3417d29aa10803241927
--- /dev/null
+++ b/substrate/primitives/runtime-interface/Cargo.toml
@@ -0,0 +1,60 @@
+[package]
+name = "sp-runtime-interface"
+version = "17.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate runtime interface"
+documentation = "https://docs.rs/sp-runtime-interface/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+bytes = { version = "1.1.0", default-features = false }
+sp-wasm-interface = { version = "14.0.0", path = "../wasm-interface", default-features = false }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-tracing = { version = "10.0.0", default-features = false, path = "../tracing" }
+sp-runtime-interface-proc-macro = { version = "11.0.0", path = "proc-macro" }
+sp-externalities = { version = "0.19.0", default-features = false, path = "../externalities" }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["bytes"] }
+static_assertions = "1.0.0"
+primitive-types = { version = "0.12.0", default-features = false }
+sp-storage = { version = "13.0.0", default-features = false, path = "../storage" }
+impl-trait-for-tuples = "0.2.2"
+
+[dev-dependencies]
+sp-runtime-interface-test-wasm = { version = "2.0.0", path = "test-wasm" }
+sp-state-machine = { version = "0.28.0", path = "../state-machine" }
+sp-core = { version = "21.0.0", path = "../core" }
+sp-io = { version = "23.0.0", path = "../io" }
+rustversion = "1.0.6"
+trybuild = "1.0.74"
+
+[features]
+default = [ "std" ]
+std = [
+	"bytes/std",
+	"codec/std",
+	"primitive-types/std",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-io/std",
+	"sp-runtime-interface-test-wasm/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-storage/std",
+	"sp-tracing/std",
+	"sp-wasm-interface/std",
+]
+
+# ATTENTION
+#
+# Only use when you know what you are doing.
+#
+# Disables static assertions in `impls.rs` that checks the word size. To prevent any footgun, the
+# check is changed into a runtime check.
+disable_target_static_assertions = []
diff --git a/substrate/primitives/runtime-interface/README.md b/substrate/primitives/runtime-interface/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..49e13f1b2e7436db5301781cf3a9ff300b6081dd
--- /dev/null
+++ b/substrate/primitives/runtime-interface/README.md
@@ -0,0 +1,89 @@
+Substrate runtime interface
+
+This crate provides types, traits and macros around runtime interfaces. A runtime interface is
+a fixed interface between a Substrate runtime and a Substrate node. For a native runtime the
+interface maps to a direct function call of the implementation. For a wasm runtime the interface
+maps to an external function call. These external functions are exported by the wasm executor
+and they map to the same implementation as the native calls.
+
+# Using a type in a runtime interface
+<!-- markdown-link-check-disable -->
+Any type that should be used in a runtime interface as argument or return value needs to
+implement [`RIType`]. The associated type [`FFIType`](https:/docs.rs/sp-runtime-interface/latest/sp_runtime_interface/trait.RIType.html#associatedtype.FFIType)
+is the type that is used in the FFI function to represent the actual type. For example `[T]` is
+represented by an `u64`. The slice pointer and the length will be mapped to an `u64` value.
+For more information see this [table](https:/docs.rs/sp-runtime-interface/latest/sp_runtime_interface/#ffi-type-and-conversion).
+The FFI function definition is used when calling from the wasm runtime into the node.
+
+Traits are used to convert from a type to the corresponding
+[`RIType::FFIType`](https:/docs.rs/sp-runtime-interface/latest/sp_runtime_interface/trait.RIType.html#associatedtype.FFIType).
+Depending on where and how a type should be used in a function signature, a combination of the
+following traits need to be implemented:
+<!-- markdown-link-check-enable -->
+1. Pass as function argument: [`wasm::IntoFFIValue`] and [`host::FromFFIValue`]
+2. As function return value: [`wasm::FromFFIValue`] and [`host::IntoFFIValue`]
+3. Pass as mutable function argument: [`host::IntoPreallocatedFFIValue`]
+
+The traits are implemented for most of the common types like `[T]`, `Vec<T>`, arrays and
+primitive types.
+
+For custom types, we provide the [`PassBy`](https://docs.rs/sp-runtime-interface/latest/sp_runtime_interface/pass_by#PassBy) trait and strategies that define
+how a type is passed between the wasm runtime and the node. Each strategy also provides a derive
+macro to simplify the implementation.
+
+# Performance
+
+To not waste any more performance when calling into the node, not all types are SCALE encoded
+when being passed as arguments between the wasm runtime and the node. For most types that
+are raw bytes like `Vec<u8>`, `[u8]` or `[u8; N]` we pass them directly, without SCALE encoding
+them in front of. The implementation of [`RIType`] each type provides more information on how
+the data is passed.
+
+# Declaring a runtime interface
+
+Declaring a runtime interface is similar to declaring a trait in Rust:
+
+```rust
+#[sp_runtime_interface::runtime_interface]
+trait RuntimeInterface {
+    fn some_function(value: &[u8]) -> bool {
+        value.iter().all(|v| *v > 125)
+    }
+}
+```
+
+For more information on declaring a runtime interface, see
+[`#[runtime_interface]`](https://docs.rs/sp-runtime-interface/latest/sp_runtime_interface/attr.runtime_interface.html).
+
+# FFI type and conversion
+
+The following table documents how values of types are passed between the wasm and
+the host side and how they are converted into the corresponding type.
+
+| Type | FFI type | Conversion |
+|----|----|----|
+| `u8` | `u8` | `Identity` |
+| `u16` | `u16` | `Identity` |
+| `u32` | `u32` | `Identity` |
+| `u64` | `u64` | `Identity` |
+| `i128` | `u32` | `v.as_ptr()` (pointer to a 16 byte array) |
+| `i8` | `i8` | `Identity` |
+| `i16` | `i16` | `Identity` |
+| `i32` | `i32` | `Identity` |
+| `i64` | `i64` | `Identity` |
+| `u128` | `u32` | `v.as_ptr()` (pointer to a 16 byte array) |
+| `bool` | `u8` | `if v { 1 } else { 0 }` |
+| `&str` | `u64` | <code>v.len() 32bit << 32 &#124; v.as_ptr() 32bit</code> |
+| `&[u8]` | `u64` | <code>v.len() 32bit << 32 &#124; v.as_ptr() 32bit</code> |
+| `Vec<u8>` | `u64` | <code>v.len() 32bit << 32 &#124; v.as_ptr() 32bit</code> |
+| `Vec<T> where T: Encode` | `u64` | `let e = v.encode();`<br><br><code>e.len() 32bit << 32 &#124; e.as_ptr() 32bit</code> |
+| `&[T] where T: Encode` | `u64` | `let e = v.encode();`<br><br><code>e.len() 32bit << 32 &#124; e.as_ptr() 32bit</code> |
+| `[u8; N]` | `u32` | `v.as_ptr()` |
+| `*const T` | `u32` | `Identity` |
+| `Option<T>` | `u64` | `let e = v.encode();`<br><br><code>e.len() 32bit << 32 &#124; e.as_ptr() 32bit</code> |
+| [`T where T: PassBy<PassBy=Inner>`](https://docs.rs/sp-runtime-interface/latest/sp_runtime_interface/pass_by#Inner) | Depends on inner | Depends on inner |
+| [`T where T: PassBy<PassBy=Codec>`](https://docs.rs/sp-runtime-interface/latest/sp_runtime_interface/pass_by#Codec) | `u64`| <code>v.len() 32bit << 32 &#124; v.as_ptr() 32bit</code> |
+
+`Identity` means that the value is converted directly into the corresponding FFI type.
+
+License: Apache-2.0
diff --git a/substrate/primitives/runtime-interface/proc-macro/Cargo.toml b/substrate/primitives/runtime-interface/proc-macro/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4b50dfe2a7a138d1689654f21185838fe28f2cfe
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "sp-runtime-interface-proc-macro"
+version = "11.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "This crate provides procedural macros for usage within the context of the Substrate runtime interface."
+documentation = "https://docs.rs/sp-runtime-interface-proc-macro"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+Inflector = "0.11.4"
+proc-macro-crate = "1.1.3"
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full", "visit", "fold", "extra-traits"] }
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/lib.rs b/substrate/primitives/runtime-interface/proc-macro/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e6f060c219e018be7696affa2d908b8799f9b075
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/lib.rs
@@ -0,0 +1,109 @@
+// 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 crate provides procedural macros for usage within the context of the Substrate runtime
+//! interface.
+//!
+//! The following macros are provided:
+//!
+//! 1. The [`#[runtime_interface]`](attr.runtime_interface.html) attribute macro for generating the
+//!    runtime interfaces.
+//! 2. The [`PassByCodec`](derive.PassByCodec.html) derive macro for implementing `PassBy` with
+//! `Codec`. 3. The [`PassByEnum`](derive.PassByInner.html) derive macro for implementing `PassBy`
+//! with `Enum`. 4. The [`PassByInner`](derive.PassByInner.html) derive macro for implementing
+//! `PassBy` with `Inner`.
+
+use syn::{
+	parse::{Parse, ParseStream},
+	parse_macro_input, DeriveInput, ItemTrait, Result, Token,
+};
+
+mod pass_by;
+mod runtime_interface;
+mod utils;
+
+struct Options {
+	wasm_only: bool,
+	tracing: bool,
+}
+
+impl Options {
+	fn unpack(self) -> (bool, bool) {
+		(self.wasm_only, self.tracing)
+	}
+}
+impl Default for Options {
+	fn default() -> Self {
+		Options { wasm_only: false, tracing: true }
+	}
+}
+
+impl Parse for Options {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let mut res = Self::default();
+		while !input.is_empty() {
+			let lookahead = input.lookahead1();
+			if lookahead.peek(runtime_interface::keywords::wasm_only) {
+				let _ = input.parse::<runtime_interface::keywords::wasm_only>();
+				res.wasm_only = true;
+			} else if lookahead.peek(runtime_interface::keywords::no_tracing) {
+				let _ = input.parse::<runtime_interface::keywords::no_tracing>();
+				res.tracing = false;
+			} else if lookahead.peek(Token![,]) {
+				let _ = input.parse::<Token![,]>();
+			} else {
+				return Err(lookahead.error())
+			}
+		}
+		Ok(res)
+	}
+}
+
+#[proc_macro_attribute]
+pub fn runtime_interface(
+	attrs: proc_macro::TokenStream,
+	input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+	let trait_def = parse_macro_input!(input as ItemTrait);
+	let (wasm_only, tracing) = parse_macro_input!(attrs as Options).unpack();
+
+	runtime_interface::runtime_interface_impl(trait_def, wasm_only, tracing)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+#[proc_macro_derive(PassByCodec)]
+pub fn pass_by_codec(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input = parse_macro_input!(input as DeriveInput);
+	pass_by::codec_derive_impl(input)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+#[proc_macro_derive(PassByInner)]
+pub fn pass_by_inner(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input = parse_macro_input!(input as DeriveInput);
+	pass_by::inner_derive_impl(input)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+#[proc_macro_derive(PassByEnum)]
+pub fn pass_by_enum(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input = parse_macro_input!(input as DeriveInput);
+	pass_by::enum_derive_impl(input).unwrap_or_else(|e| e.to_compile_error()).into()
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/pass_by/codec.rs b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/codec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a1b7bccd3acc0a1569a9413324972c299f1a7351
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/codec.rs
@@ -0,0 +1,59 @@
+// 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.
+
+//! Derive macro implementation of `PassBy` with the associated type set to `Codec`.
+//!
+//! It is required that the type implements `Encode` and `Decode` from the `parity-scale-codec`
+//! crate.
+
+use crate::utils::{generate_crate_access, generate_runtime_interface_include};
+
+use syn::{parse_quote, DeriveInput, Generics, Result};
+
+use quote::quote;
+
+use proc_macro2::TokenStream;
+
+/// The derive implementation for `PassBy` with `Codec`.
+pub fn derive_impl(mut input: DeriveInput) -> Result<TokenStream> {
+	add_trait_bounds(&mut input.generics);
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+	let crate_include = generate_runtime_interface_include();
+	let crate_ = generate_crate_access();
+	let ident = input.ident;
+
+	let res = quote! {
+		const _: () = {
+			#crate_include
+
+			impl #impl_generics #crate_::pass_by::PassBy for #ident #ty_generics #where_clause {
+				type PassBy = #crate_::pass_by::Codec<#ident>;
+			}
+		};
+	};
+
+	Ok(res)
+}
+
+/// Add the `codec::Codec` trait bound to every type parameter.
+fn add_trait_bounds(generics: &mut Generics) {
+	let crate_ = generate_crate_access();
+
+	generics
+		.type_params_mut()
+		.for_each(|type_param| type_param.bounds.push(parse_quote!(#crate_::codec::Codec)));
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/pass_by/enum_.rs b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/enum_.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0d05dd9aa51e20b076f293946077a5b40c7418a2
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/enum_.rs
@@ -0,0 +1,101 @@
+// 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.
+
+//! Derive macro implementation of `PassBy` with the associated type set to `Enum`.
+//!
+//! Besides `PassBy`, `TryFrom<u8>` and `From<Self> for u8` are implemented for the type.
+
+use crate::utils::{generate_crate_access, generate_runtime_interface_include};
+
+use syn::{Data, DeriveInput, Error, Fields, Ident, Result};
+
+use quote::quote;
+
+use proc_macro2::{Span, TokenStream};
+
+/// The derive implementation for `PassBy` with `Enum`.
+pub fn derive_impl(input: DeriveInput) -> Result<TokenStream> {
+	let crate_include = generate_runtime_interface_include();
+	let crate_ = generate_crate_access();
+	let ident = input.ident;
+	let enum_fields = get_enum_field_idents(&input.data)?
+		.enumerate()
+		.map(|(i, v)| {
+			let i = i as u8;
+
+			v.map(|v| (quote!(#i => Ok(#ident::#v)), quote!(#ident::#v => #i)))
+		})
+		.collect::<Result<Vec<_>>>()?;
+	let try_from_variants = enum_fields.iter().map(|i| &i.0);
+	let into_variants = enum_fields.iter().map(|i| &i.1);
+
+	let res = quote! {
+		const _: () = {
+			#crate_include
+
+			impl #crate_::pass_by::PassBy for #ident {
+				type PassBy = #crate_::pass_by::Enum<#ident>;
+			}
+
+			impl TryFrom<u8> for #ident {
+				type Error = ();
+
+				fn try_from(inner: u8) -> #crate_::sp_std::result::Result<Self, ()> {
+					match inner {
+						#( #try_from_variants, )*
+						_ => Err(()),
+					}
+				}
+			}
+
+			impl From<#ident> for u8 {
+				fn from(var: #ident) -> u8 {
+					match var {
+						#( #into_variants ),*
+					}
+				}
+			}
+		};
+	};
+
+	Ok(res)
+}
+
+/// Get the enum fields idents of the given `data` object as iterator.
+///
+/// Returns an error if the number of variants is greater than `256`, the given `data` is not an
+/// enum or a variant is not an unit.
+fn get_enum_field_idents(data: &Data) -> Result<impl Iterator<Item = Result<&Ident>>> {
+	match data {
+		Data::Enum(d) =>
+			if d.variants.len() <= 256 {
+				Ok(d.variants.iter().map(|v| {
+					if let Fields::Unit = v.fields {
+						Ok(&v.ident)
+					} else {
+						Err(Error::new(
+							Span::call_site(),
+							"`PassByEnum` only supports unit variants.",
+						))
+					}
+				}))
+			} else {
+				Err(Error::new(Span::call_site(), "`PassByEnum` only supports `256` variants."))
+			},
+		_ => Err(Error::new(Span::call_site(), "`PassByEnum` only supports enums as input type.")),
+	}
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/pass_by/inner.rs b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/inner.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cc51fe44f912f4049eed59922a9f28e0adac2ac9
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/inner.rs
@@ -0,0 +1,110 @@
+// 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.
+
+//! Derive macro implementation of `PassBy` with the associated type set to `Inner` and of the
+//! helper trait `PassByInner`.
+//!
+//! It is required that the type is a newtype struct, otherwise an error is generated.
+
+use crate::utils::{generate_crate_access, generate_runtime_interface_include};
+
+use syn::{parse_quote, Data, DeriveInput, Error, Fields, Generics, Ident, Result, Type};
+
+use quote::quote;
+
+use proc_macro2::{Span, TokenStream};
+
+/// The derive implementation for `PassBy` with `Inner` and `PassByInner`.
+pub fn derive_impl(mut input: DeriveInput) -> Result<TokenStream> {
+	add_trait_bounds(&mut input.generics);
+	let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+	let crate_include = generate_runtime_interface_include();
+	let crate_ = generate_crate_access();
+	let ident = input.ident;
+	let (inner_ty, inner_name) = extract_inner_ty_and_name(&input.data)?;
+
+	let access_inner = match inner_name {
+		Some(ref name) => quote!(self.#name),
+		None => quote!(self.0),
+	};
+
+	let from_inner = match inner_name {
+		Some(name) => quote!(Self { #name: inner }),
+		None => quote!(Self(inner)),
+	};
+
+	let res = quote! {
+		const _: () = {
+			#crate_include
+
+			impl #impl_generics #crate_::pass_by::PassBy for #ident #ty_generics #where_clause {
+				type PassBy = #crate_::pass_by::Inner<Self, #inner_ty>;
+			}
+
+			impl #impl_generics #crate_::pass_by::PassByInner for #ident #ty_generics #where_clause {
+				type Inner = #inner_ty;
+
+				fn into_inner(self) -> Self::Inner {
+					#access_inner
+				}
+
+				fn inner(&self) -> &Self::Inner {
+					&#access_inner
+				}
+
+				fn from_inner(inner: Self::Inner) -> Self {
+					#from_inner
+				}
+			}
+		};
+	};
+
+	Ok(res)
+}
+
+/// Add the `RIType` trait bound to every type parameter.
+fn add_trait_bounds(generics: &mut Generics) {
+	let crate_ = generate_crate_access();
+
+	generics
+		.type_params_mut()
+		.for_each(|type_param| type_param.bounds.push(parse_quote!(#crate_::RIType)));
+}
+
+/// Extract the inner type and optional name from given input data.
+///
+/// It also checks that the input data is a newtype struct.
+fn extract_inner_ty_and_name(data: &Data) -> Result<(Type, Option<Ident>)> {
+	if let Data::Struct(ref struct_data) = data {
+		match struct_data.fields {
+			Fields::Named(ref named) if named.named.len() == 1 => {
+				let field = &named.named[0];
+				return Ok((field.ty.clone(), field.ident.clone()))
+			},
+			Fields::Unnamed(ref unnamed) if unnamed.unnamed.len() == 1 => {
+				let field = &unnamed.unnamed[0];
+				return Ok((field.ty.clone(), field.ident.clone()))
+			},
+			_ => {},
+		}
+	}
+
+	Err(Error::new(
+		Span::call_site(),
+		"Only newtype/one field structs are supported by `PassByInner`!",
+	))
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/pass_by/mod.rs b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f3d51d36248dd8b94ad2ab7c3fb9d5615658cb59
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/pass_by/mod.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.
+
+//! All the `PassBy*` derive implementations.
+
+mod codec;
+mod enum_;
+mod inner;
+
+pub use self::codec::derive_impl as codec_derive_impl;
+pub use enum_::derive_impl as enum_derive_impl;
+pub use inner::derive_impl as inner_derive_impl;
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/bare_function_interface.rs b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/bare_function_interface.rs
new file mode 100644
index 0000000000000000000000000000000000000000..77a29bec3807fa41d224bfb22dd3824e4ff1bb6e
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/bare_function_interface.rs
@@ -0,0 +1,257 @@
+// 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.
+
+//! Generates the bare function interface for a given trait definition.
+//!
+//! The bare functions are the ones that will be called by the user. On the native/host side, these
+//! functions directly execute the provided implementation. On the wasm side, these
+//! functions will prepare the parameters for the FFI boundary, call the external host function
+//! exported into wasm and convert back the result.
+//!
+//! [`generate`] is the entry point for generating for each
+//! trait method one bare function.
+//!
+//! [`function_for_method`] generates the bare
+//! function per trait method. Each bare function contains both implementations. The implementations
+//! are feature-gated, so that one is compiled for the native and the other for the wasm side.
+
+use crate::utils::{
+	create_exchangeable_host_function_ident, create_function_ident_with_version,
+	generate_crate_access, get_function_argument_names, get_function_arguments,
+	get_runtime_interface, RuntimeInterfaceFunction,
+};
+
+use syn::{
+	parse_quote, spanned::Spanned, FnArg, Ident, ItemTrait, Result, Signature, Token, TraitItemFn,
+};
+
+use proc_macro2::{Span, TokenStream};
+
+use quote::{quote, quote_spanned};
+
+use std::iter;
+
+/// Generate one bare function per trait method. The name of the bare function is equal to the name
+/// of the trait method.
+pub fn generate(trait_def: &ItemTrait, is_wasm_only: bool, tracing: bool) -> Result<TokenStream> {
+	let trait_name = &trait_def.ident;
+	let runtime_interface = get_runtime_interface(trait_def)?;
+
+	// latest version dispatch
+	let token_stream: Result<TokenStream> = runtime_interface.latest_versions_to_call().try_fold(
+		TokenStream::new(),
+		|mut t, (latest_version, method)| {
+			t.extend(function_for_method(method, latest_version, is_wasm_only)?);
+			Ok(t)
+		},
+	);
+
+	// earlier versions compatibility dispatch (only std variant)
+	let result: Result<TokenStream> =
+		runtime_interface
+			.all_versions()
+			.try_fold(token_stream?, |mut t, (version, method)| {
+				t.extend(function_std_impl(trait_name, method, version, is_wasm_only, tracing)?);
+				Ok(t)
+			});
+
+	result
+}
+
+/// Generates the bare function implementation for the given method for the host and wasm side.
+fn function_for_method(
+	method: &RuntimeInterfaceFunction,
+	latest_version: u32,
+	is_wasm_only: bool,
+) -> Result<TokenStream> {
+	let std_impl =
+		if !is_wasm_only { function_std_latest_impl(method, latest_version)? } else { quote!() };
+
+	let no_std_impl = function_no_std_impl(method, is_wasm_only)?;
+
+	Ok(quote! {
+		#std_impl
+
+		#no_std_impl
+	})
+}
+
+/// Generates the bare function implementation for `cfg(not(feature = "std"))`.
+fn function_no_std_impl(
+	method: &RuntimeInterfaceFunction,
+	is_wasm_only: bool,
+) -> Result<TokenStream> {
+	let function_name = &method.sig.ident;
+	let host_function_name = create_exchangeable_host_function_ident(&method.sig.ident);
+	let args = get_function_arguments(&method.sig);
+	let arg_names = get_function_argument_names(&method.sig);
+	let return_value = if method.should_trap_on_return() {
+		syn::ReturnType::Type(
+			<Token![->]>::default(),
+			Box::new(syn::TypeNever { bang_token: <Token![!]>::default() }.into()),
+		)
+	} else {
+		method.sig.output.clone()
+	};
+	let maybe_unreachable = if method.should_trap_on_return() {
+		quote! {
+			; core::arch::wasm32::unreachable();
+		}
+	} else {
+		quote! {}
+	};
+
+	let attrs = method.attrs.iter().filter(|a| !a.path().is_ident("version"));
+
+	let cfg_wasm_only = if is_wasm_only {
+		quote! { #[cfg(target_arch = "wasm32")] }
+	} else {
+		quote! {}
+	};
+
+	Ok(quote! {
+		#cfg_wasm_only
+		#[cfg(not(feature = "std"))]
+		#( #attrs )*
+		pub fn #function_name( #( #args, )* ) #return_value {
+			// Call the host function
+			#host_function_name.get()( #( #arg_names, )* )
+			#maybe_unreachable
+		}
+	})
+}
+
+/// Generate call to latest function version for `cfg((feature = "std")`
+///
+/// This should generate simple `fn func(..) { func_version_<latest_version>(..) }`.
+fn function_std_latest_impl(method: &TraitItemFn, latest_version: u32) -> Result<TokenStream> {
+	let function_name = &method.sig.ident;
+	let args = get_function_arguments(&method.sig).map(FnArg::Typed);
+	let arg_names = get_function_argument_names(&method.sig).collect::<Vec<_>>();
+	let return_value = &method.sig.output;
+	let attrs = method.attrs.iter().filter(|a| !a.path().is_ident("version"));
+	let latest_function_name =
+		create_function_ident_with_version(&method.sig.ident, latest_version);
+
+	Ok(quote_spanned! { method.span() =>
+		#[cfg(feature = "std")]
+		#( #attrs )*
+		pub fn #function_name( #( #args, )* ) #return_value {
+			#latest_function_name(
+				#( #arg_names, )*
+			)
+		}
+	})
+}
+
+/// Generates the bare function implementation for `cfg(feature = "std")`.
+fn function_std_impl(
+	trait_name: &Ident,
+	method: &TraitItemFn,
+	version: u32,
+	is_wasm_only: bool,
+	tracing: bool,
+) -> Result<TokenStream> {
+	let function_name = create_function_ident_with_version(&method.sig.ident, version);
+	let function_name_str = function_name.to_string();
+
+	let crate_ = generate_crate_access();
+	let args = get_function_arguments(&method.sig).map(FnArg::Typed).chain(
+		// Add the function context as last parameter when this is a wasm only interface.
+		iter::from_fn(|| {
+			if is_wasm_only {
+				Some(parse_quote!(
+					mut __function_context__: &mut dyn #crate_::sp_wasm_interface::FunctionContext
+				))
+			} else {
+				None
+			}
+		})
+		.take(1),
+	);
+	let return_value = &method.sig.output;
+	let attrs = method.attrs.iter().filter(|a| !a.path().is_ident("version"));
+	// Don't make the function public accessible when this is a wasm only interface.
+	let call_to_trait = generate_call_to_trait(trait_name, method, version, is_wasm_only);
+	let call_to_trait = if !tracing {
+		call_to_trait
+	} else {
+		parse_quote!(
+			#crate_::sp_tracing::within_span! { #crate_::sp_tracing::trace_span!(#function_name_str);
+				#call_to_trait
+			}
+		)
+	};
+
+	Ok(quote_spanned! { method.span() =>
+		#[cfg(feature = "std")]
+		#( #attrs )*
+		fn #function_name( #( #args, )* ) #return_value {
+			#call_to_trait
+		}
+	})
+}
+
+/// Generate the call to the interface trait.
+fn generate_call_to_trait(
+	trait_name: &Ident,
+	method: &TraitItemFn,
+	version: u32,
+	is_wasm_only: bool,
+) -> TokenStream {
+	let crate_ = generate_crate_access();
+	let method_name = create_function_ident_with_version(&method.sig.ident, version);
+	let expect_msg =
+		format!("`{}` called outside of an Externalities-provided environment.", method_name);
+	let arg_names = get_function_argument_names(&method.sig);
+
+	if takes_self_argument(&method.sig) {
+		let instance = if is_wasm_only {
+			Ident::new("__function_context__", Span::call_site())
+		} else {
+			Ident::new("__externalities__", Span::call_site())
+		};
+
+		let impl_ = quote!( #trait_name::#method_name(&mut #instance, #( #arg_names, )*) );
+
+		if is_wasm_only {
+			quote_spanned! { method.span() => #impl_ }
+		} else {
+			quote_spanned! { method.span() =>
+				#crate_::with_externalities(|mut #instance| #impl_).expect(#expect_msg)
+			}
+		}
+	} else {
+		// The name of the trait the interface trait is implemented for
+		let impl_trait_name = if is_wasm_only {
+			quote!( #crate_::sp_wasm_interface::FunctionContext )
+		} else {
+			quote!( #crate_::Externalities )
+		};
+
+		quote_spanned! { method.span() =>
+			<&mut dyn #impl_trait_name as #trait_name>::#method_name(
+				#( #arg_names, )*
+			)
+		}
+	}
+}
+
+/// Returns if the given `Signature` takes a `self` argument.
+fn takes_self_argument(sig: &Signature) -> bool {
+	matches!(sig.inputs.first(), Some(FnArg::Receiver(_)))
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/host_function_interface.rs b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/host_function_interface.rs
new file mode 100644
index 0000000000000000000000000000000000000000..77a9e56eecba5c91e3a36534f8f79da6ead30107
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/host_function_interface.rs
@@ -0,0 +1,466 @@
+// 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.
+
+//! Generates the extern host functions and the implementation for these host functions.
+//!
+//! The extern host functions will be called by the bare function interface from the Wasm side.
+//! The implementation of these host functions will be called on the host side from the Wasm
+//! executor. These implementations call the bare function interface.
+
+use crate::utils::{
+	create_exchangeable_host_function_ident, create_function_ident_with_version,
+	create_host_function_ident, generate_crate_access, get_function_argument_names,
+	get_function_argument_names_and_types_without_ref, get_function_argument_types,
+	get_function_argument_types_ref_and_mut, get_function_argument_types_without_ref,
+	get_function_arguments, get_runtime_interface, RuntimeInterfaceFunction,
+};
+
+use syn::{
+	spanned::Spanned, Error, Ident, ItemTrait, Pat, Result, ReturnType, Signature, TraitItemFn,
+};
+
+use proc_macro2::{Span, TokenStream};
+
+use quote::quote;
+
+use inflector::Inflector;
+
+use std::iter::Iterator;
+
+/// Generate the extern host functions for wasm and the `HostFunctions` struct that provides the
+/// implementations for the host functions on the host.
+pub fn generate(trait_def: &ItemTrait, is_wasm_only: bool) -> Result<TokenStream> {
+	let trait_name = &trait_def.ident;
+	let extern_host_function_impls = get_runtime_interface(trait_def)?
+		.latest_versions_to_call()
+		.try_fold(TokenStream::new(), |mut t, (version, method)| {
+			t.extend(generate_extern_host_function(method, version, trait_name)?);
+			Ok::<_, Error>(t)
+		})?;
+	let exchangeable_host_functions = get_runtime_interface(trait_def)?
+		.latest_versions_to_call()
+		.try_fold(TokenStream::new(), |mut t, (_, m)| {
+		t.extend(generate_exchangeable_host_function(m)?);
+		Ok::<_, Error>(t)
+	})?;
+	let host_functions_struct = generate_host_functions_struct(trait_def, is_wasm_only)?;
+
+	Ok(quote! {
+		/// The implementations of the extern host functions. This special implementation module
+		/// is required to change the extern host functions signature to
+		/// `unsafe fn name(args) -> ret` to make the function implementations exchangeable.
+		#[cfg(not(feature = "std"))]
+		mod extern_host_function_impls {
+			use super::*;
+
+			#extern_host_function_impls
+		}
+
+		#exchangeable_host_functions
+
+		#host_functions_struct
+	})
+}
+
+/// Generate the extern host function for the given method.
+fn generate_extern_host_function(
+	method: &TraitItemFn,
+	version: u32,
+	trait_name: &Ident,
+) -> Result<TokenStream> {
+	let crate_ = generate_crate_access();
+	let args = get_function_arguments(&method.sig);
+	let arg_types = get_function_argument_types_without_ref(&method.sig);
+	let arg_types2 = get_function_argument_types_without_ref(&method.sig);
+	let arg_names = get_function_argument_names(&method.sig);
+	let arg_names2 = get_function_argument_names(&method.sig);
+	let arg_names3 = get_function_argument_names(&method.sig);
+	let function = &method.sig.ident;
+	let ext_function = create_host_function_ident(&method.sig.ident, version, trait_name);
+	let doc_string = format!(
+		" Default extern host function implementation for [`super::{}`].",
+		method.sig.ident,
+	);
+	let return_value = &method.sig.output;
+	let cfg_attrs = method.attrs.iter().filter(|a| a.path().is_ident("cfg"));
+
+	let ffi_return_value = match method.sig.output {
+		ReturnType::Default => quote!(),
+		ReturnType::Type(_, ref ty) => quote! {
+			-> <#ty as #crate_::RIType>::FFIType
+		},
+	};
+
+	let convert_return_value = match return_value {
+		ReturnType::Default => quote!(),
+		ReturnType::Type(_, ref ty) => quote! {
+			<#ty as #crate_::wasm::FromFFIValue>::from_ffi_value(result)
+		},
+	};
+
+	Ok(quote! {
+		#(#cfg_attrs)*
+		#[doc = #doc_string]
+		pub fn #function ( #( #args ),* ) #return_value {
+			extern "C" {
+				/// The extern function.
+				pub fn #ext_function (
+					#( #arg_names: <#arg_types as #crate_::RIType>::FFIType ),*
+				) #ffi_return_value;
+			}
+
+			// Generate all wrapped ffi values.
+			#(
+				let #arg_names2 = <#arg_types2 as #crate_::wasm::IntoFFIValue>::into_ffi_value(
+					&#arg_names2,
+				);
+			)*
+
+			let result = unsafe { #ext_function( #( #arg_names3.get() ),* ) };
+
+			#convert_return_value
+		}
+	})
+}
+
+/// Generate the host exchangeable function for the given method.
+fn generate_exchangeable_host_function(method: &TraitItemFn) -> Result<TokenStream> {
+	let crate_ = generate_crate_access();
+	let arg_types = get_function_argument_types(&method.sig);
+	let function = &method.sig.ident;
+	let exchangeable_function = create_exchangeable_host_function_ident(&method.sig.ident);
+	let doc_string = format!(" Exchangeable host function used by [`{}`].", method.sig.ident);
+	let output = &method.sig.output;
+	let cfg_attrs = method.attrs.iter().filter(|a| a.path().is_ident("cfg"));
+
+	Ok(quote! {
+		#(#cfg_attrs)*
+		#[cfg(not(feature = "std"))]
+		#[allow(non_upper_case_globals)]
+		#[doc = #doc_string]
+		pub static #exchangeable_function : #crate_::wasm::ExchangeableFunction<
+			fn ( #( #arg_types ),* ) #output
+		> = #crate_::wasm::ExchangeableFunction::new(extern_host_function_impls::#function);
+	})
+}
+
+/// Generate the `HostFunctions` struct that implements `wasm-interface::HostFunctions` to provide
+/// implementations for the extern host functions.
+fn generate_host_functions_struct(
+	trait_def: &ItemTrait,
+	is_wasm_only: bool,
+) -> Result<TokenStream> {
+	let crate_ = generate_crate_access();
+
+	let mut host_function_impls = Vec::new();
+	let mut register_bodies = Vec::new();
+	let mut append_hf_bodies = Vec::new();
+
+	for (version, method) in get_runtime_interface(trait_def)?.all_versions() {
+		let (implementation, register_body, append_hf_body) =
+			generate_host_function_implementation(&trait_def.ident, method, version, is_wasm_only)?;
+		host_function_impls.push(implementation);
+		register_bodies.push(register_body);
+		append_hf_bodies.push(append_hf_body);
+	}
+
+	Ok(quote! {
+		#(#host_function_impls)*
+
+		/// Provides implementations for the extern host functions.
+		#[cfg(feature = "std")]
+		pub struct HostFunctions;
+
+		#[cfg(feature = "std")]
+		impl #crate_::sp_wasm_interface::HostFunctions for HostFunctions {
+			fn host_functions() -> Vec<&'static dyn #crate_::sp_wasm_interface::Function> {
+				let mut host_functions_list = Vec::new();
+				#(#append_hf_bodies)*
+				host_functions_list
+			}
+
+			#crate_::sp_wasm_interface::if_wasmtime_is_enabled! {
+				fn register_static<T>(registry: &mut T) -> core::result::Result<(), T::Error>
+					where T: #crate_::sp_wasm_interface::HostFunctionRegistry
+				{
+					#(#register_bodies)*
+					Ok(())
+				}
+			}
+		}
+	})
+}
+
+/// Generates the host function struct that implements `wasm_interface::Function` and returns a
+/// static reference to this struct.
+///
+/// When calling from wasm into the host, we will call the `execute` function that calls the native
+/// implementation of the function.
+fn generate_host_function_implementation(
+	trait_name: &Ident,
+	method: &RuntimeInterfaceFunction,
+	version: u32,
+	is_wasm_only: bool,
+) -> Result<(TokenStream, TokenStream, TokenStream)> {
+	let name = create_host_function_ident(&method.sig.ident, version, trait_name).to_string();
+	let struct_name = Ident::new(&name.to_pascal_case(), Span::call_site());
+	let crate_ = generate_crate_access();
+	let signature = generate_wasm_interface_signature_for_host_function(&method.sig)?;
+
+	let fn_name = create_function_ident_with_version(&method.sig.ident, version);
+	let ref_and_mut = get_function_argument_types_ref_and_mut(&method.sig);
+
+	// List of variable names containing WASM FFI-compatible arguments.
+	let mut ffi_names = Vec::new();
+
+	// List of `$name: $ty` tokens containing WASM FFI-compatible arguments.
+	let mut ffi_args_prototype = Vec::new();
+
+	// List of variable names containing arguments already converted into native Rust types.
+	// Also includes the preceding `&` or `&mut`. To be used to call the actual implementation of
+	// the host function.
+	let mut host_names_with_ref = Vec::new();
+
+	// List of code snippets to copy over the results returned from a host function through
+	// any `&mut` arguments back into WASM's linear memory.
+	let mut copy_data_into_ref_mut_args = Vec::new();
+
+	// List of code snippets to convert dynamic FFI args (`Value` enum) into concrete static FFI
+	// types (`u32`, etc.).
+	let mut convert_args_dynamic_ffi_to_static_ffi = Vec::new();
+
+	// List of code snippets to convert static FFI args (`u32`, etc.) into native Rust types.
+	let mut convert_args_static_ffi_to_host = Vec::new();
+
+	for ((host_name, host_ty), ref_and_mut) in
+		get_function_argument_names_and_types_without_ref(&method.sig).zip(ref_and_mut)
+	{
+		let ffi_name = generate_ffi_value_var_name(&host_name)?;
+		let host_name_ident = match *host_name {
+			Pat::Ident(ref pat_ident) => pat_ident.ident.clone(),
+			_ => unreachable!("`generate_ffi_value_var_name` above would return an error on `Pat` != `Ident`; qed"),
+		};
+
+		let ffi_ty = quote! { <#host_ty as #crate_::RIType>::FFIType };
+		ffi_args_prototype.push(quote! { #ffi_name: #ffi_ty });
+		ffi_names.push(quote! { #ffi_name });
+
+		let convert_arg_error = format!(
+			"could not marshal the '{}' argument through the WASM FFI boundary while executing '{}' from interface '{}'",
+			host_name_ident,
+			method.sig.ident,
+			trait_name
+		);
+		convert_args_static_ffi_to_host.push(quote! {
+			let mut #host_name = <#host_ty as #crate_::host::FromFFIValue>::from_ffi_value(__function_context__, #ffi_name)
+				.map_err(|err| format!("{}: {}", err, #convert_arg_error))?;
+		});
+
+		let ref_and_mut_tokens =
+			ref_and_mut.map(|(token_ref, token_mut)| quote!(#token_ref #token_mut));
+
+		host_names_with_ref.push(quote! { #ref_and_mut_tokens #host_name });
+
+		if ref_and_mut.map(|(_, token_mut)| token_mut.is_some()).unwrap_or(false) {
+			copy_data_into_ref_mut_args.push(quote! {
+				<#host_ty as #crate_::host::IntoPreallocatedFFIValue>::into_preallocated_ffi_value(
+					#host_name,
+					__function_context__,
+					#ffi_name,
+				)?;
+			});
+		}
+
+		let arg_count_mismatch_error = format!(
+			"missing argument '{}': number of arguments given to '{}' from interface '{}' does not match the expected number of arguments",
+			host_name_ident,
+			method.sig.ident,
+			trait_name
+		);
+		convert_args_dynamic_ffi_to_static_ffi.push(quote! {
+			let #ffi_name = args.next().ok_or_else(|| #arg_count_mismatch_error.to_owned())?;
+			let #ffi_name: #ffi_ty = #crate_::sp_wasm_interface::TryFromValue::try_from_value(#ffi_name)
+				.ok_or_else(|| #convert_arg_error.to_owned())?;
+		});
+	}
+
+	let ffi_return_ty = match &method.sig.output {
+		ReturnType::Type(_, ty) => quote! { <#ty as #crate_::RIType>::FFIType },
+		ReturnType::Default => quote! { () },
+	};
+
+	let convert_return_value_host_to_static_ffi = match &method.sig.output {
+		ReturnType::Type(_, ty) => quote! {
+			let __result__ = <#ty as #crate_::host::IntoFFIValue>::into_ffi_value(
+				__result__,
+				__function_context__
+			);
+		},
+		ReturnType::Default => quote! {
+			let __result__ = Ok(__result__);
+		},
+	};
+
+	let convert_return_value_static_ffi_to_dynamic_ffi = match &method.sig.output {
+		ReturnType::Type(_, _) => quote! {
+			let __result__ = Ok(Some(#crate_::sp_wasm_interface::IntoValue::into_value(__result__)));
+		},
+		ReturnType::Default => quote! {
+			let __result__ = Ok(None);
+		},
+	};
+
+	if is_wasm_only {
+		host_names_with_ref.push(quote! {
+			__function_context__
+		});
+	}
+
+	let cfg_attrs: Vec<_> =
+		method.attrs.iter().filter(|a| a.path().is_ident("cfg")).cloned().collect();
+	if version > 1 && !cfg_attrs.is_empty() {
+		return Err(Error::new(
+			method.span(),
+			"Conditional compilation is not supported for versioned functions",
+		))
+	}
+
+	let implementation = quote! {
+		#(#cfg_attrs)*
+		#[cfg(feature = "std")]
+		struct #struct_name;
+
+		#(#cfg_attrs)*
+		#[cfg(feature = "std")]
+		impl #struct_name {
+			fn call(
+				__function_context__: &mut dyn #crate_::sp_wasm_interface::FunctionContext,
+				#(#ffi_args_prototype),*
+			) -> std::result::Result<#ffi_return_ty, String> {
+				#(#convert_args_static_ffi_to_host)*
+				let __result__ = #fn_name(#(#host_names_with_ref),*);
+				#(#copy_data_into_ref_mut_args)*
+				#convert_return_value_host_to_static_ffi
+				__result__
+			}
+		}
+
+		#(#cfg_attrs)*
+		#[cfg(feature = "std")]
+		impl #crate_::sp_wasm_interface::Function for #struct_name {
+			fn name(&self) -> &str {
+				#name
+			}
+
+			fn signature(&self) -> #crate_::sp_wasm_interface::Signature {
+				#signature
+			}
+
+			fn execute(
+				&self,
+				__function_context__: &mut dyn #crate_::sp_wasm_interface::FunctionContext,
+				args: &mut dyn Iterator<Item = #crate_::sp_wasm_interface::Value>,
+			) -> std::result::Result<Option<#crate_::sp_wasm_interface::Value>, String> {
+				#(#convert_args_dynamic_ffi_to_static_ffi)*
+				let __result__ = Self::call(
+					__function_context__,
+					#(#ffi_names),*
+				)?;
+				#convert_return_value_static_ffi_to_dynamic_ffi
+				__result__
+			}
+		}
+	};
+
+	let register_body = quote! {
+		#(#cfg_attrs)*
+		registry.register_static(
+			#crate_::sp_wasm_interface::Function::name(&#struct_name),
+			|mut caller: #crate_::sp_wasm_interface::wasmtime::Caller<T::State>, #(#ffi_args_prototype),*|
+				-> std::result::Result<#ffi_return_ty, #crate_::sp_wasm_interface::anyhow::Error>
+			{
+				T::with_function_context(caller, move |__function_context__| {
+					let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+						#struct_name::call(
+							__function_context__,
+							#(#ffi_names,)*
+						).map_err(#crate_::sp_wasm_interface::anyhow::Error::msg)
+					}));
+					match result {
+						Ok(result) => result,
+						Err(panic) => {
+							let message =
+								if let Some(message) = panic.downcast_ref::<String>() {
+									format!("host code panicked while being called by the runtime: {}", message)
+								} else if let Some(message) = panic.downcast_ref::<&'static str>() {
+									format!("host code panicked while being called by the runtime: {}", message)
+								} else {
+									"host code panicked while being called by the runtime".to_owned()
+								};
+							return Err(#crate_::sp_wasm_interface::anyhow::Error::msg(message));
+						}
+					}
+				})
+			}
+		)?;
+	};
+
+	let append_hf_body = quote! {
+		#(#cfg_attrs)*
+		host_functions_list.push(&#struct_name as &dyn #crate_::sp_wasm_interface::Function);
+	};
+
+	Ok((implementation, register_body, append_hf_body))
+}
+
+/// Generate the `wasm_interface::Signature` for the given host function `sig`.
+fn generate_wasm_interface_signature_for_host_function(sig: &Signature) -> Result<TokenStream> {
+	let crate_ = generate_crate_access();
+	let return_value = match &sig.output {
+		ReturnType::Type(_, ty) => quote! {
+			Some( <<#ty as #crate_::RIType>::FFIType as #crate_::sp_wasm_interface::IntoValue>::VALUE_TYPE )
+		},
+		ReturnType::Default => quote!(None),
+	};
+	let arg_types = get_function_argument_types_without_ref(sig).map(|ty| {
+		quote! {
+			<<#ty as #crate_::RIType>::FFIType as #crate_::sp_wasm_interface::IntoValue>::VALUE_TYPE
+		}
+	});
+
+	Ok(quote! {
+		#crate_::sp_wasm_interface::Signature {
+			args: std::borrow::Cow::Borrowed(&[ #( #arg_types ),* ][..]),
+			return_value: #return_value,
+		}
+	})
+}
+
+/// Generate the variable name that stores the FFI value.
+fn generate_ffi_value_var_name(pat: &Pat) -> Result<Ident> {
+	match pat {
+		Pat::Ident(pat_ident) =>
+			if let Some(by_ref) = pat_ident.by_ref {
+				Err(Error::new(by_ref.span(), "`ref` not supported!"))
+			} else if let Some(sub_pattern) = &pat_ident.subpat {
+				Err(Error::new(sub_pattern.0.span(), "Not supported!"))
+			} else {
+				Ok(Ident::new(&format!("{}_ffi_value", pat_ident.ident), Span::call_site()))
+			},
+		_ => Err(Error::new(pat.span(), "Not supported as variable name!")),
+	}
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/mod.rs b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..008d69b32100807d8fefc945a73722eafdefd2b8
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/mod.rs
@@ -0,0 +1,72 @@
+// 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::utils::generate_runtime_interface_include;
+
+use proc_macro2::{Span, TokenStream};
+
+use syn::{Ident, ItemTrait, Result};
+
+use inflector::Inflector;
+
+use quote::quote;
+
+mod bare_function_interface;
+mod host_function_interface;
+mod trait_decl_impl;
+
+/// Custom keywords supported by the `runtime_interface` attribute.
+pub mod keywords {
+	// Custom keyword `wasm_only` that can be given as attribute to [`runtime_interface`].
+	syn::custom_keyword!(wasm_only);
+	// Disable tracing-macros added to the [`runtime_interface`] by specifying this optional entry
+	syn::custom_keyword!(no_tracing);
+}
+
+/// Implementation of the `runtime_interface` attribute.
+///
+/// It expects the trait definition the attribute was put above and if this should be an wasm only
+/// interface.
+pub fn runtime_interface_impl(
+	trait_def: ItemTrait,
+	is_wasm_only: bool,
+	tracing: bool,
+) -> Result<TokenStream> {
+	let bare_functions = bare_function_interface::generate(&trait_def, is_wasm_only, tracing)?;
+	let crate_include = generate_runtime_interface_include();
+	let mod_name = Ident::new(&trait_def.ident.to_string().to_snake_case(), Span::call_site());
+	let trait_decl_impl = trait_decl_impl::process(&trait_def, is_wasm_only)?;
+	let host_functions = host_function_interface::generate(&trait_def, is_wasm_only)?;
+	let vis = trait_def.vis;
+	let attrs = &trait_def.attrs;
+
+	let res = quote! {
+		#( #attrs )*
+		#vis mod #mod_name {
+			use super::*;
+			#crate_include
+
+			#bare_functions
+
+			#trait_decl_impl
+
+			#host_functions
+		}
+	};
+
+	Ok(res)
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/trait_decl_impl.rs b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/trait_decl_impl.rs
new file mode 100644
index 0000000000000000000000000000000000000000..540e930b0c14bdfcb16f4c43d054ddc6e0bc9442
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/runtime_interface/trait_decl_impl.rs
@@ -0,0 +1,174 @@
+// 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.
+
+//! Checks the trait declaration, makes the trait declaration module local, removes all method
+//! default implementations and implements the trait for `&mut dyn Externalities`.
+
+use crate::utils::{
+	create_function_ident_with_version, generate_crate_access,
+	get_function_argument_types_without_ref, get_runtime_interface,
+};
+
+use syn::{
+	fold::{self, Fold},
+	spanned::Spanned,
+	Error, Generics, ItemTrait, Receiver, Result, TraitItemFn, Type, Visibility,
+};
+
+use proc_macro2::TokenStream;
+
+use quote::quote;
+
+/// Process the given trait definition, by checking that the definition is valid, fold it to the
+/// essential definition and implement this essential definition for `dyn Externalities`.
+pub fn process(trait_def: &ItemTrait, is_wasm_only: bool) -> Result<TokenStream> {
+	let impl_trait = impl_trait_for_externalities(trait_def, is_wasm_only)?;
+	let essential_trait_def = declare_essential_trait(trait_def)?;
+
+	Ok(quote! {
+		#impl_trait
+
+		#essential_trait_def
+	})
+}
+
+/// Converts the given trait definition into the essential trait definition without method
+/// default implementations and visibility set to inherited.
+struct ToEssentialTraitDef {
+	/// All errors found while doing the conversion.
+	errors: Vec<Error>,
+	methods: Vec<TraitItemFn>,
+}
+
+impl ToEssentialTraitDef {
+	fn new() -> Self {
+		ToEssentialTraitDef { errors: vec![], methods: vec![] }
+	}
+
+	fn into_methods(self) -> Result<Vec<TraitItemFn>> {
+		let mut errors = self.errors;
+		let methods = self.methods;
+		if let Some(first_error) = errors.pop() {
+			Err(errors.into_iter().fold(first_error, |mut o, n| {
+				o.combine(n);
+				o
+			}))
+		} else {
+			Ok(methods)
+		}
+	}
+
+	fn process(&mut self, method: &TraitItemFn, version: u32) {
+		let mut folded = self.fold_trait_item_fn(method.clone());
+		folded.sig.ident = create_function_ident_with_version(&folded.sig.ident, version);
+		self.methods.push(folded);
+	}
+
+	fn push_error<S: Spanned>(&mut self, span: &S, msg: &str) {
+		self.errors.push(Error::new(span.span(), msg));
+	}
+
+	fn error_on_generic_parameters(&mut self, generics: &Generics) {
+		if let Some(param) = generics.params.first() {
+			self.push_error(param, "Generic parameters not supported.");
+		}
+	}
+}
+
+impl Fold for ToEssentialTraitDef {
+	fn fold_trait_item_fn(&mut self, mut method: TraitItemFn) -> TraitItemFn {
+		if method.default.take().is_none() {
+			self.push_error(&method, "Methods need to have an implementation.");
+		}
+
+		let arg_types = get_function_argument_types_without_ref(&method.sig);
+		arg_types
+			.filter_map(|ty| match *ty {
+				Type::ImplTrait(impl_trait) => Some(impl_trait),
+				_ => None,
+			})
+			.for_each(|invalid| self.push_error(&invalid, "`impl Trait` syntax not supported."));
+
+		self.error_on_generic_parameters(&method.sig.generics);
+
+		method.attrs.retain(|a| !a.path().is_ident("version"));
+
+		fold::fold_trait_item_fn(self, method)
+	}
+
+	fn fold_item_trait(&mut self, mut trait_def: ItemTrait) -> ItemTrait {
+		self.error_on_generic_parameters(&trait_def.generics);
+
+		trait_def.vis = Visibility::Inherited;
+		fold::fold_item_trait(self, trait_def)
+	}
+
+	fn fold_receiver(&mut self, receiver: Receiver) -> Receiver {
+		if receiver.reference.is_none() {
+			self.push_error(&receiver, "Taking `Self` by value is not allowed.");
+		}
+
+		fold::fold_receiver(self, receiver)
+	}
+}
+
+fn declare_essential_trait(trait_def: &ItemTrait) -> Result<TokenStream> {
+	let trait_ = &trait_def.ident;
+
+	if let Some(param) = trait_def.generics.params.first() {
+		return Err(Error::new(param.span(), "Generic parameters not supported."))
+	}
+
+	let interface = get_runtime_interface(trait_def)?;
+	let mut folder = ToEssentialTraitDef::new();
+	for (version, interface_method) in interface.all_versions() {
+		folder.process(interface_method, version);
+	}
+	let methods = folder.into_methods()?;
+
+	Ok(quote! {
+		trait #trait_ {
+			#( #methods )*
+		}
+	})
+}
+
+/// Implements the given trait definition for `dyn Externalities`.
+fn impl_trait_for_externalities(trait_def: &ItemTrait, is_wasm_only: bool) -> Result<TokenStream> {
+	let trait_ = &trait_def.ident;
+	let crate_ = generate_crate_access();
+	let interface = get_runtime_interface(trait_def)?;
+	let methods = interface.all_versions().map(|(version, method)| {
+		let mut cloned = (*method).clone();
+		cloned.attrs.retain(|a| !a.path().is_ident("version"));
+		cloned.sig.ident = create_function_ident_with_version(&cloned.sig.ident, version);
+		cloned
+	});
+
+	let impl_type = if is_wasm_only {
+		quote!( &mut dyn #crate_::sp_wasm_interface::FunctionContext )
+	} else {
+		quote!( &mut dyn #crate_::Externalities )
+	};
+
+	Ok(quote! {
+		#[cfg(feature = "std")]
+		impl #trait_ for #impl_type {
+			#( #methods )*
+		}
+	})
+}
diff --git a/substrate/primitives/runtime-interface/proc-macro/src/utils.rs b/substrate/primitives/runtime-interface/proc-macro/src/utils.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9818fd6842a639191e1f5e31398646984662f0a7
--- /dev/null
+++ b/substrate/primitives/runtime-interface/proc-macro/src/utils.rs
@@ -0,0 +1,372 @@
+// 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.
+
+//! Util function used by this crate.
+
+use proc_macro2::{Span, TokenStream};
+
+use syn::{
+	parse::Parse, parse_quote, spanned::Spanned, token, Error, FnArg, Ident, ItemTrait, LitInt,
+	Pat, PatType, Result, Signature, TraitItem, TraitItemFn, Type,
+};
+
+use proc_macro_crate::{crate_name, FoundCrate};
+
+use std::{
+	collections::{btree_map::Entry, BTreeMap},
+	env,
+};
+
+use quote::quote;
+
+use inflector::Inflector;
+
+mod attributes {
+	syn::custom_keyword!(register_only);
+}
+
+/// A concrete, specific version of a runtime interface function.
+pub struct RuntimeInterfaceFunction {
+	item: TraitItemFn,
+	should_trap_on_return: bool,
+}
+
+impl std::ops::Deref for RuntimeInterfaceFunction {
+	type Target = TraitItemFn;
+	fn deref(&self) -> &Self::Target {
+		&self.item
+	}
+}
+
+impl RuntimeInterfaceFunction {
+	fn new(item: &TraitItemFn) -> Result<Self> {
+		let mut item = item.clone();
+		let mut should_trap_on_return = false;
+		item.attrs.retain(|attr| {
+			if attr.path().is_ident("trap_on_return") {
+				should_trap_on_return = true;
+				false
+			} else {
+				true
+			}
+		});
+
+		if should_trap_on_return && !matches!(item.sig.output, syn::ReturnType::Default) {
+			return Err(Error::new(
+				item.sig.ident.span(),
+				"Methods marked as #[trap_on_return] cannot return anything",
+			))
+		}
+
+		Ok(Self { item, should_trap_on_return })
+	}
+
+	pub fn should_trap_on_return(&self) -> bool {
+		self.should_trap_on_return
+	}
+}
+
+/// Runtime interface function with all associated versions of this function.
+struct RuntimeInterfaceFunctionSet {
+	latest_version_to_call: Option<u32>,
+	versions: BTreeMap<u32, RuntimeInterfaceFunction>,
+}
+
+impl RuntimeInterfaceFunctionSet {
+	fn new(version: VersionAttribute, trait_item: &TraitItemFn) -> Result<Self> {
+		Ok(Self {
+			latest_version_to_call: version.is_callable().then(|| version.version),
+			versions: BTreeMap::from([(
+				version.version,
+				RuntimeInterfaceFunction::new(trait_item)?,
+			)]),
+		})
+	}
+
+	/// Returns the latest version of this runtime interface function plus the actual function
+	/// implementation.
+	///
+	/// This isn't required to be the latest version, because a runtime interface function can be
+	/// annotated with `register_only` to ensure that the host exposes the host function but it
+	/// isn't used when compiling the runtime.
+	pub fn latest_version_to_call(&self) -> Option<(u32, &RuntimeInterfaceFunction)> {
+		self.latest_version_to_call.map(|v| {
+			(
+			v,
+			self.versions.get(&v).expect(
+				"If latest_version_to_call has a value, the key with this value is in the versions; qed",
+			),
+		)
+		})
+	}
+
+	/// Add a different version of the function.
+	fn add_version(&mut self, version: VersionAttribute, trait_item: &TraitItemFn) -> Result<()> {
+		if let Some(existing_item) = self.versions.get(&version.version) {
+			let mut err = Error::new(trait_item.span(), "Duplicated version attribute");
+			err.combine(Error::new(
+				existing_item.span(),
+				"Previous version with the same number defined here",
+			));
+
+			return Err(err)
+		}
+
+		self.versions
+			.insert(version.version, RuntimeInterfaceFunction::new(trait_item)?);
+		if self.latest_version_to_call.map_or(true, |v| v < version.version) &&
+			version.is_callable()
+		{
+			self.latest_version_to_call = Some(version.version);
+		}
+
+		Ok(())
+	}
+}
+
+/// All functions of a runtime interface grouped by the function names.
+pub struct RuntimeInterface {
+	items: BTreeMap<syn::Ident, RuntimeInterfaceFunctionSet>,
+}
+
+impl RuntimeInterface {
+	/// Returns an iterator over all runtime interface function
+	/// [`latest_version_to_call`](RuntimeInterfaceFunctionSet::latest_version).
+	pub fn latest_versions_to_call(
+		&self,
+	) -> impl Iterator<Item = (u32, &RuntimeInterfaceFunction)> {
+		self.items.iter().filter_map(|(_, item)| item.latest_version_to_call())
+	}
+
+	pub fn all_versions(&self) -> impl Iterator<Item = (u32, &RuntimeInterfaceFunction)> {
+		self.items
+			.iter()
+			.flat_map(|(_, item)| item.versions.iter())
+			.map(|(v, i)| (*v, i))
+	}
+}
+
+/// Generates the include for the runtime-interface crate.
+pub fn generate_runtime_interface_include() -> TokenStream {
+	match crate_name("sp-runtime-interface") {
+		Ok(FoundCrate::Itself) => quote!(),
+		Ok(FoundCrate::Name(crate_name)) => {
+			let crate_name = Ident::new(&crate_name, Span::call_site());
+			quote!(
+				#[doc(hidden)]
+				extern crate #crate_name as proc_macro_runtime_interface;
+			)
+		},
+		Err(e) => {
+			let err = Error::new(Span::call_site(), e).to_compile_error();
+			quote!( #err )
+		},
+	}
+}
+
+/// Generates the access to the `sp-runtime-interface` crate.
+pub fn generate_crate_access() -> TokenStream {
+	if env::var("CARGO_PKG_NAME").unwrap() == "sp-runtime-interface" {
+		quote!(sp_runtime_interface)
+	} else {
+		quote!(proc_macro_runtime_interface)
+	}
+}
+
+/// Create the exchangeable host function identifier for the given function name.
+pub fn create_exchangeable_host_function_ident(name: &Ident) -> Ident {
+	Ident::new(&format!("host_{}", name), Span::call_site())
+}
+
+/// Create the host function identifier for the given function name.
+pub fn create_host_function_ident(name: &Ident, version: u32, trait_name: &Ident) -> Ident {
+	Ident::new(
+		&format!("ext_{}_{}_version_{}", trait_name.to_string().to_snake_case(), name, version),
+		Span::call_site(),
+	)
+}
+
+/// Create the host function identifier for the given function name.
+pub fn create_function_ident_with_version(name: &Ident, version: u32) -> Ident {
+	Ident::new(&format!("{}_version_{}", name, version), Span::call_site())
+}
+
+/// Returns the function arguments of the given `Signature`, minus any `self` arguments.
+pub fn get_function_arguments(sig: &Signature) -> impl Iterator<Item = PatType> + '_ {
+	sig.inputs
+		.iter()
+		.filter_map(|a| match a {
+			FnArg::Receiver(_) => None,
+			FnArg::Typed(pat_type) => Some(pat_type),
+		})
+		.enumerate()
+		.map(|(i, arg)| {
+			let mut res = arg.clone();
+			if let Pat::Wild(wild) = &*arg.pat {
+				let ident =
+					Ident::new(&format!("__runtime_interface_generated_{}_", i), wild.span());
+
+				res.pat = Box::new(parse_quote!( #ident ))
+			}
+
+			res
+		})
+}
+
+/// Returns the function argument names of the given `Signature`, minus any `self`.
+pub fn get_function_argument_names(sig: &Signature) -> impl Iterator<Item = Box<Pat>> + '_ {
+	get_function_arguments(sig).map(|pt| pt.pat)
+}
+
+/// Returns the function argument types of the given `Signature`, minus any `Self` type.
+pub fn get_function_argument_types(sig: &Signature) -> impl Iterator<Item = Box<Type>> + '_ {
+	get_function_arguments(sig).map(|pt| pt.ty)
+}
+
+/// Returns the function argument types, minus any `Self` type. If any of the arguments
+/// is a reference, the underlying type without the ref is returned.
+pub fn get_function_argument_types_without_ref(
+	sig: &Signature,
+) -> impl Iterator<Item = Box<Type>> + '_ {
+	get_function_arguments(sig).map(|pt| pt.ty).map(|ty| match *ty {
+		Type::Reference(type_ref) => type_ref.elem,
+		_ => ty,
+	})
+}
+
+/// Returns the function argument names and types, minus any `self`. If any of the arguments
+/// is a reference, the underlying type without the ref is returned.
+pub fn get_function_argument_names_and_types_without_ref(
+	sig: &Signature,
+) -> impl Iterator<Item = (Box<Pat>, Box<Type>)> + '_ {
+	get_function_arguments(sig).map(|pt| match *pt.ty {
+		Type::Reference(type_ref) => (pt.pat, type_ref.elem),
+		_ => (pt.pat, pt.ty),
+	})
+}
+
+/// Returns the `&`/`&mut` for all function argument types, minus the `self` arg. If a function
+/// argument is not a reference, `None` is returned.
+pub fn get_function_argument_types_ref_and_mut(
+	sig: &Signature,
+) -> impl Iterator<Item = Option<(token::And, Option<token::Mut>)>> + '_ {
+	get_function_arguments(sig).map(|pt| pt.ty).map(|ty| match *ty {
+		Type::Reference(type_ref) => Some((type_ref.and_token, type_ref.mutability)),
+		_ => None,
+	})
+}
+
+/// Returns an iterator over all trait methods for the given trait definition.
+fn get_trait_methods(trait_def: &ItemTrait) -> impl Iterator<Item = &TraitItemFn> {
+	trait_def.items.iter().filter_map(|i| match i {
+		TraitItem::Fn(ref method) => Some(method),
+		_ => None,
+	})
+}
+
+/// The version attribute that can be found above a runtime interface function.
+///
+/// Supports the following formats:
+/// - `#[version(1)]`
+/// - `#[version(1, register_only)]`
+///
+/// While this struct is only for parsing the inner parts inside the `()`.
+struct VersionAttribute {
+	version: u32,
+	register_only: Option<attributes::register_only>,
+}
+
+impl VersionAttribute {
+	/// Is this function version callable?
+	fn is_callable(&self) -> bool {
+		self.register_only.is_none()
+	}
+}
+
+impl Default for VersionAttribute {
+	fn default() -> Self {
+		Self { version: 1, register_only: None }
+	}
+}
+
+impl Parse for VersionAttribute {
+	fn parse(input: syn::parse::ParseStream) -> Result<Self> {
+		let version: LitInt = input.parse()?;
+		let register_only = if input.peek(token::Comma) {
+			let _ = input.parse::<token::Comma>();
+			Some(input.parse()?)
+		} else {
+			if !input.is_empty() {
+				return Err(Error::new(input.span(), "Unexpected token, expected `,`."))
+			}
+
+			None
+		};
+
+		Ok(Self { version: version.base10_parse()?, register_only })
+	}
+}
+
+/// Return [`VersionAttribute`], if present.
+fn get_item_version(item: &TraitItemFn) -> Result<Option<VersionAttribute>> {
+	item.attrs
+		.iter()
+		.find(|attr| attr.path().is_ident("version"))
+		.map(|attr| attr.parse_args())
+		.transpose()
+}
+
+/// Returns all runtime interface members, with versions.
+pub fn get_runtime_interface(trait_def: &ItemTrait) -> Result<RuntimeInterface> {
+	let mut functions: BTreeMap<syn::Ident, RuntimeInterfaceFunctionSet> = BTreeMap::new();
+
+	for item in get_trait_methods(trait_def) {
+		let name = item.sig.ident.clone();
+		let version = get_item_version(item)?.unwrap_or_default();
+
+		if version.version < 1 {
+			return Err(Error::new(item.span(), "Version needs to be at least `1`."))
+		}
+
+		match functions.entry(name.clone()) {
+			Entry::Vacant(entry) => {
+				entry.insert(RuntimeInterfaceFunctionSet::new(version, item)?);
+			},
+			Entry::Occupied(mut entry) => {
+				entry.get_mut().add_version(version, item)?;
+			},
+		}
+	}
+
+	for function in functions.values() {
+		let mut next_expected = 1;
+		for (version, item) in function.versions.iter() {
+			if next_expected != *version {
+				return Err(Error::new(
+					item.span(),
+					format!(
+						"Unexpected version attribute: missing version '{}' for this function",
+						next_expected
+					),
+				))
+			}
+			next_expected += 1;
+		}
+	}
+
+	Ok(RuntimeInterface { items: functions })
+}
diff --git a/substrate/primitives/runtime-interface/src/host.rs b/substrate/primitives/runtime-interface/src/host.rs
new file mode 100644
index 0000000000000000000000000000000000000000..914e575539d2f2a8e31072dcb8aafb0aa2e74ae6
--- /dev/null
+++ b/substrate/primitives/runtime-interface/src/host.rs
@@ -0,0 +1,66 @@
+// 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.
+
+//! Traits required by the runtime interface from the host side.
+
+use crate::RIType;
+
+use sp_wasm_interface::{FunctionContext, Result};
+
+/// Something that can be converted into a ffi value.
+pub trait IntoFFIValue: RIType {
+	/// Convert `self` into a ffi value.
+	fn into_ffi_value(self, context: &mut dyn FunctionContext) -> Result<Self::FFIType>;
+}
+
+/// Something that can be converted into a preallocated ffi value.
+///
+/// Every type parameter that should be given as `&mut` into a runtime interface function, needs
+/// to implement this trait. After executing the host implementation of the runtime interface
+/// function, the value is copied into the preallocated wasm memory.
+///
+/// This should only be used for types which have a fixed size, like slices. Other types like a vec
+/// do not work with this interface, as we can not call into wasm to reallocate memory. So, this
+/// trait should be implemented carefully.
+pub trait IntoPreallocatedFFIValue: RIType {
+	/// As `Self` can be an unsized type, it needs to be represented by a sized type at the host.
+	/// This `SelfInstance` is the sized type.
+	type SelfInstance;
+
+	/// Convert `self_instance` into the given preallocated ffi value.
+	fn into_preallocated_ffi_value(
+		self_instance: Self::SelfInstance,
+		context: &mut dyn FunctionContext,
+		allocated: Self::FFIType,
+	) -> Result<()>;
+}
+
+/// Something that can be created from a ffi value.
+/// Implementations are safe to assume that the `arg` given to `from_ffi_value`
+/// is only generated by the corresponding [`wasm::IntoFFIValue`](crate::wasm::IntoFFIValue)
+/// implementation.
+pub trait FromFFIValue: RIType {
+	/// As `Self` can be an unsized type, it needs to be represented by a sized type at the host.
+	/// This `SelfInstance` is the sized type.
+	type SelfInstance;
+
+	/// Create `SelfInstance` from the given
+	fn from_ffi_value(
+		context: &mut dyn FunctionContext,
+		arg: Self::FFIType,
+	) -> Result<Self::SelfInstance>;
+}
diff --git a/substrate/primitives/runtime-interface/src/impls.rs b/substrate/primitives/runtime-interface/src/impls.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3530b62662a53c53afa14667a77fb7c1c609c582
--- /dev/null
+++ b/substrate/primitives/runtime-interface/src/impls.rs
@@ -0,0 +1,535 @@
+// 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.
+
+//! Provides implementations for the runtime interface traits.
+
+#[cfg(feature = "std")]
+use crate::host::*;
+#[cfg(not(feature = "std"))]
+use crate::wasm::*;
+use crate::{
+	pass_by::{Codec, Enum, Inner, PassBy, PassByInner},
+	util::{pack_ptr_and_len, unpack_ptr_and_len},
+	Pointer, RIType,
+};
+
+#[cfg(all(not(feature = "std"), not(feature = "disable_target_static_assertions")))]
+use static_assertions::assert_eq_size;
+
+#[cfg(feature = "std")]
+use sp_wasm_interface::{FunctionContext, Result};
+
+use codec::{Decode, Encode};
+
+use sp_std::{any::TypeId, mem, vec::Vec};
+
+#[cfg(feature = "std")]
+use sp_std::borrow::Cow;
+
+// Make sure that our assumptions for storing a pointer + its size in `u64` is valid.
+#[cfg(all(not(feature = "std"), not(feature = "disable_target_static_assertions")))]
+assert_eq_size!(usize, u32);
+#[cfg(all(not(feature = "std"), not(feature = "disable_target_static_assertions")))]
+assert_eq_size!(*const u8, u32);
+
+/// Implement the traits for the given primitive traits.
+macro_rules! impl_traits_for_primitives {
+	(
+		$(
+			$rty:ty, $fty:ty,
+		)*
+	) => {
+		$(
+			/// The type is passed directly.
+			impl RIType for $rty {
+				type FFIType = $fty;
+			}
+
+			#[cfg(not(feature = "std"))]
+			impl IntoFFIValue for $rty {
+				type Owned = ();
+
+				fn into_ffi_value(&self) -> WrappedFFIValue<$fty> {
+					(*self as $fty).into()
+				}
+			}
+
+			#[cfg(not(feature = "std"))]
+			impl FromFFIValue for $rty {
+				fn from_ffi_value(arg: $fty) -> $rty {
+					arg as $rty
+				}
+			}
+
+			#[cfg(feature = "std")]
+			impl FromFFIValue for $rty {
+				type SelfInstance = $rty;
+
+				fn from_ffi_value(_: &mut dyn FunctionContext, arg: $fty) -> Result<$rty> {
+					Ok(arg as $rty)
+				}
+			}
+
+			#[cfg(feature = "std")]
+			impl IntoFFIValue for $rty {
+				fn into_ffi_value(self, _: &mut dyn FunctionContext) -> Result<$fty> {
+					Ok(self as $fty)
+				}
+			}
+		)*
+	}
+}
+
+impl_traits_for_primitives! {
+	u8, u32,
+	u16, u32,
+	u32, u32,
+	u64, u64,
+	i8, i32,
+	i16, i32,
+	i32, i32,
+	i64, i64,
+}
+
+/// `bool` is passed as `u32`.
+///
+/// - `1`: true
+/// - `0`: false
+impl RIType for bool {
+	type FFIType = u32;
+}
+
+#[cfg(not(feature = "std"))]
+impl IntoFFIValue for bool {
+	type Owned = ();
+
+	fn into_ffi_value(&self) -> WrappedFFIValue<u32> {
+		if *self { 1 } else { 0 }.into()
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl FromFFIValue for bool {
+	fn from_ffi_value(arg: u32) -> bool {
+		arg == 1
+	}
+}
+
+#[cfg(feature = "std")]
+impl FromFFIValue for bool {
+	type SelfInstance = bool;
+
+	fn from_ffi_value(_: &mut dyn FunctionContext, arg: u32) -> Result<bool> {
+		Ok(arg == 1)
+	}
+}
+
+#[cfg(feature = "std")]
+impl IntoFFIValue for bool {
+	fn into_ffi_value(self, _: &mut dyn FunctionContext) -> Result<u32> {
+		Ok(if self { 1 } else { 0 })
+	}
+}
+
+/// The type is passed as `u64`.
+///
+/// The `u64` value is build by `length 32bit << 32 | pointer 32bit`
+///
+/// If `T == u8` the length and the pointer are taken directly from `Self`.
+/// Otherwise `Self` is encoded and the length and the pointer are taken from the encoded vector.
+impl<T> RIType for Vec<T> {
+	type FFIType = u64;
+}
+
+#[cfg(feature = "std")]
+impl<T: 'static + Encode> IntoFFIValue for Vec<T> {
+	fn into_ffi_value(self, context: &mut dyn FunctionContext) -> Result<u64> {
+		let vec: Cow<'_, [u8]> = if TypeId::of::<T>() == TypeId::of::<u8>() {
+			unsafe { Cow::Borrowed(mem::transmute(&self[..])) }
+		} else {
+			Cow::Owned(self.encode())
+		};
+
+		let ptr = context.allocate_memory(vec.as_ref().len() as u32)?;
+		context.write_memory(ptr, &vec)?;
+
+		Ok(pack_ptr_and_len(ptr.into(), vec.len() as u32))
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: 'static + Decode> FromFFIValue for Vec<T> {
+	type SelfInstance = Vec<T>;
+
+	fn from_ffi_value(context: &mut dyn FunctionContext, arg: u64) -> Result<Vec<T>> {
+		<[T] as FromFFIValue>::from_ffi_value(context, arg)
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: 'static + Encode> IntoFFIValue for Vec<T> {
+	type Owned = Vec<u8>;
+
+	fn into_ffi_value(&self) -> WrappedFFIValue<u64, Vec<u8>> {
+		self[..].into_ffi_value()
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: 'static + Decode> FromFFIValue for Vec<T> {
+	fn from_ffi_value(arg: u64) -> Vec<T> {
+		let (ptr, len) = unpack_ptr_and_len(arg);
+		let len = len as usize;
+
+		if len == 0 {
+			return Vec::new()
+		}
+
+		let data = unsafe { Vec::from_raw_parts(ptr as *mut u8, len, len) };
+
+		if TypeId::of::<T>() == TypeId::of::<u8>() {
+			unsafe { mem::transmute(data) }
+		} else {
+			Self::decode(&mut &data[..]).expect("Host to wasm values are encoded correctly; qed")
+		}
+	}
+}
+
+/// The type is passed as `u64`.
+///
+/// The `u64` value is build by `length 32bit << 32 | pointer 32bit`
+///
+/// If `T == u8` the length and the pointer are taken directly from `Self`.
+/// Otherwise `Self` is encoded and the length and the pointer are taken from the encoded vector.
+impl<T> RIType for [T] {
+	type FFIType = u64;
+}
+
+#[cfg(feature = "std")]
+impl<T: 'static + Decode> FromFFIValue for [T] {
+	type SelfInstance = Vec<T>;
+
+	fn from_ffi_value(context: &mut dyn FunctionContext, arg: u64) -> Result<Vec<T>> {
+		let (ptr, len) = unpack_ptr_and_len(arg);
+
+		let vec = context.read_memory(Pointer::new(ptr), len)?;
+
+		if TypeId::of::<T>() == TypeId::of::<u8>() {
+			Ok(unsafe { mem::transmute(vec) })
+		} else {
+			Ok(Vec::<T>::decode(&mut &vec[..])
+				.expect("Wasm to host values are encoded correctly; qed"))
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl IntoPreallocatedFFIValue for [u8] {
+	type SelfInstance = Vec<u8>;
+
+	fn into_preallocated_ffi_value(
+		self_instance: Self::SelfInstance,
+		context: &mut dyn FunctionContext,
+		allocated: u64,
+	) -> Result<()> {
+		let (ptr, len) = unpack_ptr_and_len(allocated);
+
+		if (len as usize) < self_instance.len() {
+			Err(format!(
+				"Preallocated buffer is not big enough (given {} vs needed {})!",
+				len,
+				self_instance.len()
+			))
+		} else {
+			context.write_memory(Pointer::new(ptr), &self_instance)
+		}
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: 'static + Encode> IntoFFIValue for [T] {
+	type Owned = Vec<u8>;
+
+	fn into_ffi_value(&self) -> WrappedFFIValue<u64, Vec<u8>> {
+		if TypeId::of::<T>() == TypeId::of::<u8>() {
+			let slice = unsafe { mem::transmute::<&[T], &[u8]>(self) };
+			pack_ptr_and_len(slice.as_ptr() as u32, slice.len() as u32).into()
+		} else {
+			let data = self.encode();
+			let ffi_value = pack_ptr_and_len(data.as_ptr() as u32, data.len() as u32);
+			(ffi_value, data).into()
+		}
+	}
+}
+
+/// The type is passed as `u32`.
+///
+/// The `u32` is the pointer to the array.
+impl<const N: usize> RIType for [u8; N] {
+	type FFIType = u32;
+}
+
+#[cfg(not(feature = "std"))]
+impl<const N: usize> IntoFFIValue for [u8; N] {
+	type Owned = ();
+
+	fn into_ffi_value(&self) -> WrappedFFIValue<u32> {
+		(self.as_ptr() as u32).into()
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<const N: usize> FromFFIValue for [u8; N] {
+	fn from_ffi_value(arg: u32) -> [u8; N] {
+		let mut res = [0u8; N];
+		let data = unsafe { Vec::from_raw_parts(arg as *mut u8, N, N) };
+
+		res.copy_from_slice(&data);
+
+		res
+	}
+}
+
+#[cfg(feature = "std")]
+impl<const N: usize> FromFFIValue for [u8; N] {
+	type SelfInstance = [u8; N];
+
+	fn from_ffi_value(context: &mut dyn FunctionContext, arg: u32) -> Result<[u8; N]> {
+		let mut res = [0u8; N];
+		context.read_memory_into(Pointer::new(arg), &mut res)?;
+		Ok(res)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<const N: usize> IntoFFIValue for [u8; N] {
+	fn into_ffi_value(self, context: &mut dyn FunctionContext) -> Result<u32> {
+		let addr = context.allocate_memory(N as u32)?;
+		context.write_memory(addr, &self)?;
+		Ok(addr.into())
+	}
+}
+
+#[cfg(feature = "std")]
+impl<const N: usize> IntoPreallocatedFFIValue for [u8; N] {
+	type SelfInstance = [u8; N];
+
+	fn into_preallocated_ffi_value(
+		self_instance: Self::SelfInstance,
+		context: &mut dyn FunctionContext,
+		allocated: u32,
+	) -> Result<()> {
+		context.write_memory(Pointer::new(allocated), &self_instance)
+	}
+}
+
+impl<T: codec::Codec, E: codec::Codec> PassBy for sp_std::result::Result<T, E> {
+	type PassBy = Codec<Self>;
+}
+
+impl<T: codec::Codec> PassBy for Option<T> {
+	type PassBy = Codec<Self>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+#[tuple_types_no_default_trait_bound]
+impl PassBy for Tuple
+where
+	Self: codec::Codec,
+{
+	type PassBy = Codec<Self>;
+}
+
+/// Implement `PassBy` with `Inner` for the given fixed sized hash types.
+macro_rules! for_primitive_types {
+	{ $( $hash:ident $n:expr ),* $(,)? } => {
+		$(
+			impl PassBy for primitive_types::$hash {
+				type PassBy = Inner<Self, [u8; $n]>;
+			}
+
+			impl PassByInner for primitive_types::$hash {
+				type Inner = [u8; $n];
+
+				fn inner(&self) -> &Self::Inner {
+					&self.0
+				}
+
+				fn into_inner(self) -> Self::Inner {
+					self.0
+				}
+
+				fn from_inner(inner: Self::Inner) -> Self {
+					Self(inner)
+				}
+			}
+		)*
+	}
+}
+
+for_primitive_types! {
+	H160 20,
+	H256 32,
+	H512 64,
+}
+
+/// The type is passed as `u64`.
+///
+/// The `u64` value is build by `length 32bit << 32 | pointer 32bit`
+///
+/// The length and the pointer are taken directly from `Self`.
+impl RIType for str {
+	type FFIType = u64;
+}
+
+#[cfg(feature = "std")]
+impl FromFFIValue for str {
+	type SelfInstance = String;
+
+	fn from_ffi_value(context: &mut dyn FunctionContext, arg: u64) -> Result<String> {
+		let (ptr, len) = unpack_ptr_and_len(arg);
+
+		let vec = context.read_memory(Pointer::new(ptr), len)?;
+
+		// The data is valid utf8, as it is stored as `&str` in wasm.
+		String::from_utf8(vec).map_err(|_| "Invalid utf8 data provided".into())
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl IntoFFIValue for str {
+	type Owned = ();
+
+	fn into_ffi_value(&self) -> WrappedFFIValue<u64, ()> {
+		let bytes = self.as_bytes();
+		pack_ptr_and_len(bytes.as_ptr() as u32, bytes.len() as u32).into()
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: sp_wasm_interface::PointerType> RIType for Pointer<T> {
+	type FFIType = u32;
+}
+
+/// The type is passed as `u32`.
+#[cfg(not(feature = "std"))]
+impl<T> RIType for Pointer<T> {
+	type FFIType = u32;
+}
+
+#[cfg(not(feature = "std"))]
+impl<T> IntoFFIValue for Pointer<T> {
+	type Owned = ();
+
+	fn into_ffi_value(&self) -> WrappedFFIValue<u32> {
+		(*self as u32).into()
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T> FromFFIValue for Pointer<T> {
+	fn from_ffi_value(arg: u32) -> Self {
+		arg as _
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: sp_wasm_interface::PointerType> FromFFIValue for Pointer<T> {
+	type SelfInstance = Self;
+
+	fn from_ffi_value(_: &mut dyn FunctionContext, arg: u32) -> Result<Self> {
+		Ok(Pointer::new(arg))
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: sp_wasm_interface::PointerType> IntoFFIValue for Pointer<T> {
+	fn into_ffi_value(self, _: &mut dyn FunctionContext) -> Result<u32> {
+		Ok(self.into())
+	}
+}
+
+/// Implement the traits for `u128`/`i128`
+macro_rules! for_u128_i128 {
+	($type:ty) => {
+		/// `u128`/`i128` is passed as `u32`.
+		///
+		/// The `u32` is a pointer to an `[u8; 16]` array.
+		impl RIType for $type {
+			type FFIType = u32;
+		}
+
+		#[cfg(not(feature = "std"))]
+		impl IntoFFIValue for $type {
+			type Owned = ();
+
+			fn into_ffi_value(&self) -> WrappedFFIValue<u32> {
+				unsafe { (mem::transmute::<&Self, *const u8>(self) as u32).into() }
+			}
+		}
+
+		#[cfg(not(feature = "std"))]
+		impl FromFFIValue for $type {
+			fn from_ffi_value(arg: u32) -> $type {
+				<$type>::from_le_bytes(<[u8; mem::size_of::<$type>()]>::from_ffi_value(arg))
+			}
+		}
+
+		#[cfg(feature = "std")]
+		impl FromFFIValue for $type {
+			type SelfInstance = $type;
+
+			fn from_ffi_value(context: &mut dyn FunctionContext, arg: u32) -> Result<$type> {
+				let mut res = [0u8; mem::size_of::<$type>()];
+				context.read_memory_into(Pointer::new(arg), &mut res)?;
+				Ok(<$type>::from_le_bytes(res))
+			}
+		}
+
+		#[cfg(feature = "std")]
+		impl IntoFFIValue for $type {
+			fn into_ffi_value(self, context: &mut dyn FunctionContext) -> Result<u32> {
+				let addr = context.allocate_memory(mem::size_of::<$type>() as u32)?;
+				context.write_memory(addr, &self.to_le_bytes())?;
+				Ok(addr.into())
+			}
+		}
+	};
+}
+
+for_u128_i128!(u128);
+for_u128_i128!(i128);
+
+impl PassBy for sp_wasm_interface::ValueType {
+	type PassBy = Enum<sp_wasm_interface::ValueType>;
+}
+
+impl PassBy for sp_wasm_interface::Value {
+	type PassBy = Codec<sp_wasm_interface::Value>;
+}
+
+impl PassBy for sp_storage::TrackedStorageKey {
+	type PassBy = Codec<Self>;
+}
+
+impl PassBy for sp_storage::StateVersion {
+	type PassBy = Enum<Self>;
+}
+
+impl PassBy for sp_externalities::MultiRemovalResults {
+	type PassBy = Codec<Self>;
+}
diff --git a/substrate/primitives/runtime-interface/src/lib.rs b/substrate/primitives/runtime-interface/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f1638880bb6c8655573ad260aac9cd40e6a5592
--- /dev/null
+++ b/substrate/primitives/runtime-interface/src/lib.rs
@@ -0,0 +1,411 @@
+// 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.
+
+// Custom inner attributes are unstable, so we need to faky disable the attribute.
+// rustfmt still honors the attribute to not format the rustdocs below.
+#![cfg_attr(feature = "never", rustfmt::skip)]
+//! Substrate runtime interface
+//!
+//! This crate provides types, traits and macros around runtime interfaces. A runtime interface is
+//! a fixed interface between a Substrate runtime and a Substrate node. For a native runtime the
+//! interface maps to a direct function call of the implementation. For a wasm runtime the interface
+//! maps to an external function call. These external functions are exported by the wasm executor
+//! and they map to the same implementation as the native calls.
+//!
+//! # Using a type in a runtime interface
+//!
+//! Any type that should be used in a runtime interface as argument or return value needs to
+//! implement [`RIType`]. The associated type
+//! [`FFIType`](./trait.RIType.html#associatedtype.FFIType) is the type that is used in the FFI
+//! function to represent the actual type. For example `[T]` is represented by an `u64`. The slice
+//! pointer and the length will be mapped to an `u64` value. For more information see this
+//! [table](#ffi-type-and-conversion). The FFI function definition is used when calling from the
+//! wasm runtime into the node.
+//!
+//! Traits are used to convert from a type to the corresponding
+//! [`RIType::FFIType`](./trait.RIType.html#associatedtype.FFIType).
+//! Depending on where and how a type should be used in a function signature, a combination of the
+//! following traits need to be implemented:
+//! <!-- markdown-link-check-enable -->
+//! 1. Pass as function argument: [`wasm::IntoFFIValue`] and [`host::FromFFIValue`]
+//! 2. As function return value: [`wasm::FromFFIValue`] and [`host::IntoFFIValue`]
+//! 3. Pass as mutable function argument: [`host::IntoPreallocatedFFIValue`]
+//!
+//! The traits are implemented for most of the common types like `[T]`, `Vec<T>`, arrays and
+//! primitive types.
+//!
+//! For custom types, we provide the [`PassBy`](./pass_by#PassBy) trait and strategies that define
+//! how a type is passed between the wasm runtime and the node. Each strategy also provides a derive
+//! macro to simplify the implementation.
+//!
+//! # Performance
+//!
+//! To not waste any more performance when calling into the node, not all types are SCALE encoded
+//! when being passed as arguments between the wasm runtime and the node. For most types that
+//! are raw bytes like `Vec<u8>`, `[u8]` or `[u8; N]` we pass them directly, without SCALE encoding
+//! them in front of. The implementation of [`RIType`] each type provides more information on how
+//! the data is passed.
+//!
+//! # Declaring a runtime interface
+//!
+//! Declaring a runtime interface is similar to declaring a trait in Rust:
+//!
+//! ```
+//! #[sp_runtime_interface::runtime_interface]
+//! trait RuntimeInterface {
+//!     fn some_function(value: &[u8]) -> bool {
+//!         value.iter().all(|v| *v > 125)
+//!     }
+//! }
+//! ```
+//!
+//! For more information on declaring a runtime interface, see
+//! [`#[runtime_interface]`](./attr.runtime_interface.html).
+//!
+//! # FFI type and conversion
+//!
+//! The following table documents how values of types are passed between the wasm and
+//! the host side and how they are converted into the corresponding type.
+//!
+//! | Type | FFI type | Conversion |
+//! |----|----|----|
+//! | `u8` | `u32` | zero-extended to 32-bits |
+//! | `u16` | `u32` | zero-extended to 32-bits |
+//! | `u32` | `u32` | `Identity` |
+//! | `u64` | `u64` | `Identity` |
+//! | `i128` | `u32` | `v.as_ptr()` (pointer to a 16 byte array) |
+//! | `i8` | `i32` | sign-extended to 32-bits |
+//! | `i16` | `i32` | sign-extended to 32-bits |
+//! | `i32` | `i32` | `Identity` |
+//! | `i64` | `i64` | `Identity` |
+//! | `u128` | `u32` | `v.as_ptr()` (pointer to a 16 byte array) |
+//! | `bool` | `u32` | `if v { 1 } else { 0 }` |
+//! | `&str` | `u64` | <code>v.len() 32bit << 32 &#124; v.as_ptr() 32bit</code> |
+//! | `&[u8]` | `u64` | <code>v.len() 32bit << 32 &#124; v.as_ptr() 32bit</code> |
+//! | `Vec<u8>` | `u64` | <code>v.len() 32bit << 32 &#124; v.as_ptr() 32bit</code> |
+//! | `Vec<T> where T: Encode` | `u64` | `let e = v.encode();`<br><br><code>e.len() 32bit << 32 &#124; e.as_ptr() 32bit</code> |
+//! | `&[T] where T: Encode` | `u64` | `let e = v.encode();`<br><br><code>e.len() 32bit << 32 &#124; e.as_ptr() 32bit</code> |
+//! | `[u8; N]` | `u32` | `v.as_ptr()` |
+//! | `*const T` | `u32` | `Identity` |
+//! | `Option<T>` | `u64` | `let e = v.encode();`<br><br><code>e.len() 32bit << 32 &#124; e.as_ptr() 32bit</code> |
+//! | [`T where T: PassBy<PassBy=Inner>`](./pass_by#Inner) | Depends on inner | Depends on inner |
+//! | [`T where T: PassBy<PassBy=Codec>`](./pass_by#Codec)|`u64`|<code>v.len() 32bit << 32 &#124;v.as_ptr() 32bit</code>|
+//!
+//! `Identity` means that the value is converted directly into the corresponding FFI type.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+extern crate self as sp_runtime_interface;
+
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub use sp_wasm_interface;
+
+#[doc(hidden)]
+pub use sp_tracing;
+
+#[doc(hidden)]
+pub use sp_std;
+
+/// Attribute macro for transforming a trait declaration into a runtime interface.
+///
+/// A runtime interface is a fixed interface between a Substrate compatible runtime and the
+/// native node. This interface is callable from a native and a wasm runtime. The macro will
+/// generate the corresponding code for the native implementation and the code for calling from
+/// the wasm side to the native implementation.
+///
+/// The macro expects the runtime interface declaration as trait declaration:
+///
+/// ```
+/// # use sp_runtime_interface::runtime_interface;
+///
+/// #[runtime_interface]
+/// trait Interface {
+///     /// A function that can be called from native/wasm.
+///     ///
+///     /// The implementation given to this function is only compiled on native.
+///     fn call(data: &[u8]) -> Vec<u8> {
+///         // Here you could call some rather complex code that only compiles on native or
+///         // is way faster in native than executing it in wasm.
+///         Vec::new()
+///     }
+///     /// Call function, but different version.
+///     ///
+///     /// For new runtimes, only function with latest version is reachable.
+///     /// But old version (above) is still accessible for old runtimes.
+///     /// Default version is 1.
+///     #[version(2)]
+///     fn call(data: &[u8]) -> Vec<u8> {
+///         // Here you could call some rather complex code that only compiles on native or
+///         // is way faster in native than executing it in wasm.
+///         [17].to_vec()
+///     }
+///
+///     /// Call function, different version and only being registered.
+///     ///
+///     /// This `register_only` version is only being registered, aka exposed to the runtime,
+///     /// but the runtime will still use the version 2 of this function. This is useful for when
+///     /// new host functions should be introduced. Adding new host functions requires that all
+///     /// nodes have the host functions available, because otherwise they fail at instantiation
+///     /// of the runtime. With `register_only` the function will not be used when compiling the
+///     /// runtime, but it will already be there for a future version of the runtime that will
+///     /// switch to using these host function.
+///     #[version(3, register_only)]
+///     fn call(data: &[u8]) -> Vec<u8> {
+///         // Here you could call some rather complex code that only compiles on native or
+///         // is way faster in native than executing it in wasm.
+///         [18].to_vec()
+///     }
+///
+///     /// A function can take a `&self` or `&mut self` argument to get access to the
+///     /// `Externalities`. (The generated method does not require
+///     /// this argument, so the function can be called just with the `optional` argument)
+///     fn set_or_clear(&mut self, optional: Option<Vec<u8>>) {
+///         match optional {
+///             Some(value) => self.set_storage([1, 2, 3, 4].to_vec(), value),
+///             None => self.clear_storage(&[1, 2, 3, 4]),
+///         }
+///     }
+///
+///     /// A function can be gated behind a configuration (`cfg`) attribute.
+///     /// To prevent ambiguity and confusion about what will be the final exposed host
+///     /// functions list, conditionally compiled functions can't be versioned.
+///     /// That is, conditionally compiled functions with `version`s greater than 1
+///     /// are not allowed.
+///     #[cfg(feature = "experimental-function")]
+///     fn gated_call(data: &[u8]) -> Vec<u8> {
+///         [42].to_vec()
+///     }
+/// }
+/// ```
+///
+/// The given example will generate roughly the following code for native:
+///
+/// ```
+/// // The name of the trait is converted to snake case and used as mod name.
+/// //
+/// // Be aware that this module is not `public`, the visibility of the module is determined based
+/// // on the visibility of the trait declaration.
+/// mod interface {
+///     trait Interface {
+///         fn call_version_1(data: &[u8]) -> Vec<u8>;
+///         fn call_version_2(data: &[u8]) -> Vec<u8>;
+///         fn call_version_3(data: &[u8]) -> Vec<u8>;
+///         fn set_or_clear_version_1(&mut self, optional: Option<Vec<u8>>);
+///         #[cfg(feature = "experimental-function")]
+///         fn gated_call_version_1(data: &[u8]) -> Vec<u8>;
+///     }
+///
+///     impl Interface for &mut dyn sp_externalities::Externalities {
+///         fn call_version_1(data: &[u8]) -> Vec<u8> { Vec::new() }
+///         fn call_version_2(data: &[u8]) -> Vec<u8> { [17].to_vec() }
+///         fn call_version_3(data: &[u8]) -> Vec<u8> { [18].to_vec() }
+///         fn set_or_clear_version_1(&mut self, optional: Option<Vec<u8>>) {
+///             match optional {
+///                 Some(value) => self.set_storage([1, 2, 3, 4].to_vec(), value),
+///                 None => self.clear_storage(&[1, 2, 3, 4]),
+///             }
+///         }
+///         #[cfg(feature = "experimental-function")]
+///         fn gated_call_version_1(data: &[u8]) -> Vec<u8> { [42].to_vec() }
+///     }
+///
+///     pub fn call(data: &[u8]) -> Vec<u8> {
+///         // only latest version is exposed
+///         call_version_2(data)
+///     }
+///
+///     fn call_version_1(data: &[u8]) -> Vec<u8> {
+///         <&mut dyn sp_externalities::Externalities as Interface>::call_version_1(data)
+///     }
+///
+///     fn call_version_2(data: &[u8]) -> Vec<u8> {
+///         <&mut dyn sp_externalities::Externalities as Interface>::call_version_2(data)
+///     }
+///
+///     fn call_version_3(data: &[u8]) -> Vec<u8> {
+///         <&mut dyn sp_externalities::Externalities as Interface>::call_version_3(data)
+///     }
+///
+///     pub fn set_or_clear(optional: Option<Vec<u8>>) {
+///         set_or_clear_version_1(optional)
+///     }
+///
+///     fn set_or_clear_version_1(optional: Option<Vec<u8>>) {
+///         sp_externalities::with_externalities(|mut ext| Interface::set_or_clear_version_1(&mut ext, optional))
+///             .expect("`set_or_clear` called outside of an Externalities-provided environment.")
+///     }
+///
+///     #[cfg(feature = "experimental-function")]
+///     pub fn gated_call(data: &[u8]) -> Vec<u8> {
+///         gated_call_version_1(data)
+///     }
+///
+///     #[cfg(feature = "experimental-function")]
+///     fn gated_call_version_1(data: &[u8]) -> Vec<u8> {
+///         <&mut dyn sp_externalities::Externalities as Interface>::gated_call_version_1(data)
+///     }
+///
+///     /// This type implements the `HostFunctions` trait (from `sp-wasm-interface`) and
+///     /// provides the host implementation for the wasm side. The host implementation converts the
+///     /// arguments from wasm to native and calls the corresponding native function.
+///     ///
+///     /// This type needs to be passed to the wasm executor, so that the host functions will be
+///     /// registered in the executor.
+///     pub struct HostFunctions;
+/// }
+/// ```
+///
+/// The given example will generate roughly the following code for wasm:
+///
+/// ```
+/// mod interface {
+///     mod extern_host_functions_impls {
+///         /// Every function is exported by the native code as `ext_FUNCTION_NAME_version_VERSION`.
+///         ///
+///         /// The type for each argument of the exported function depends on
+///         /// `<ARGUMENT_TYPE as RIType>::FFIType`.
+///         ///
+///         /// `key` holds the pointer and the length to the `data` slice.
+///         pub fn call(data: &[u8]) -> Vec<u8> {
+///             extern "C" { pub fn ext_call_version_2(key: u64); }
+///             // Should call into extenal `ext_call_version_2(<[u8] as IntoFFIValue>::into_ffi_value(key))`
+///             // But this is too much to replicate in a doc test so here we just return a dummy vector.
+///             // Note that we jump into the latest version not marked as `register_only` (i.e. version 2).
+///             Vec::new()
+///         }
+///
+///         /// `key` holds the pointer and the length of the `option` value.
+///         pub fn set_or_clear(option: Option<Vec<u8>>) {
+///             extern "C" { pub fn ext_set_or_clear_version_1(key: u64); }
+///             // Same as above
+///         }
+///
+///         /// `key` holds the pointer and the length to the `data` slice.
+///         #[cfg(feature = "experimental-function")]
+///         pub fn gated_call(data: &[u8]) -> Vec<u8> {
+///             extern "C" { pub fn ext_gated_call_version_1(key: u64); }
+///             /// Same as above
+///             Vec::new()
+///         }
+///     }
+///
+///     /// The type is actually `ExchangeableFunction` (from `sp-runtime-interface`) and
+///     /// by default this is initialized to jump into the corresponding function in
+///     /// `extern_host_functions_impls`.
+///     ///
+///     /// This can be used to replace the implementation of the `call` function.
+///     /// Instead of calling into the host, the callee will automatically call the other
+///     /// implementation.
+///     ///
+///     /// To replace the implementation:
+///     ///
+///     /// `host_call.replace_implementation(some_other_impl)`
+///     pub static host_call: () = ();
+///     pub static host_set_or_clear: () = ();
+///     #[cfg(feature = "experimental-feature")]
+///     pub static gated_call: () = ();
+///
+///     pub fn call(data: &[u8]) -> Vec<u8> {
+///         // This is the actual call: `host_call.get()(data)`
+///         //
+///         // But that does not work for several reasons in this example, so we just return an
+///         // empty vector.
+///         Vec::new()
+///     }
+///
+///     pub fn set_or_clear(optional: Option<Vec<u8>>) {
+///         // Same as above
+///     }
+///
+///     #[cfg(feature = "experimental-feature")]
+///     pub fn gated_call(data: &[u8]) -> Vec<u8> {
+///         // Same as above
+///         Vec::new()
+///     }
+/// }
+/// ```
+///
+/// # Argument types
+///
+/// The macro supports any kind of argument type, as long as it implements [`RIType`] and the
+/// required `FromFFIValue`/`IntoFFIValue`. The macro will convert each
+/// argument to the corresponding FFI representation and will call into the host using this FFI
+/// representation. On the host each argument is converted back to the native representation
+/// and the native implementation is called. Any return value is handled in the same way.
+///
+/// # Wasm only interfaces
+///
+/// Some interfaces are only required from within the wasm runtime e.g. the allocator
+/// interface. To support this, the macro can be called like `#[runtime_interface(wasm_only)]`.
+/// This instructs the macro to make two significant changes to the generated code:
+///
+/// 1. The generated functions are not callable from the native side.
+/// 2. The trait as shown above is not implemented for [`Externalities`] and is instead
+/// implemented for `FunctionContext` (from `sp-wasm-interface`).
+///
+/// # Disable tracing
+/// By adding `no_tracing` to the list of options you can prevent the wasm-side interface from
+/// generating the default `sp-tracing`-calls. Note that this is rarely needed but only meant
+/// for the case when that would create a circular dependency. You usually _do not_ want to add
+/// this flag, as tracing doesn't cost you anything by default anyways (it is added as a no-op)
+/// but is super useful for debugging later.
+pub use sp_runtime_interface_proc_macro::runtime_interface;
+
+#[doc(hidden)]
+#[cfg(feature = "std")]
+pub use sp_externalities::{
+	set_and_run_with_externalities, with_externalities, ExtensionStore, Externalities,
+	ExternalitiesExt,
+};
+
+#[doc(hidden)]
+pub use codec;
+
+#[cfg(feature = "std")]
+pub mod host;
+pub(crate) mod impls;
+pub mod pass_by;
+#[cfg(any(not(feature = "std"), doc))]
+pub mod wasm;
+
+mod util;
+
+pub use util::{pack_ptr_and_len, unpack_ptr_and_len};
+
+/// Something that can be used by the runtime interface as type to communicate between wasm and the
+/// host.
+///
+/// Every type that should be used in a runtime interface function signature needs to implement
+/// this trait.
+pub trait RIType {
+	/// The ffi type that is used to represent `Self`.
+	#[cfg(feature = "std")]
+	type FFIType: sp_wasm_interface::IntoValue
+		+ sp_wasm_interface::TryFromValue
+		+ sp_wasm_interface::WasmTy;
+	#[cfg(not(feature = "std"))]
+	type FFIType;
+}
+
+/// A pointer that can be used in a runtime interface function signature.
+#[cfg(not(feature = "std"))]
+pub type Pointer<T> = *mut T;
+
+/// A pointer that can be used in a runtime interface function signature.
+#[cfg(feature = "std")]
+pub type Pointer<T> = sp_wasm_interface::Pointer<T>;
diff --git a/substrate/primitives/runtime-interface/src/pass_by.rs b/substrate/primitives/runtime-interface/src/pass_by.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8d145669adc3cb6a2b733fcac1d41e15d41eb6ab
--- /dev/null
+++ b/substrate/primitives/runtime-interface/src/pass_by.rs
@@ -0,0 +1,433 @@
+// 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.
+
+//! Provides the [`PassBy`](PassBy) trait to simplify the implementation of the
+//! runtime interface traits for custom types.
+//!
+//! [`Codec`], [`Inner`] and [`Enum`] are the provided strategy implementations.
+
+use crate::{
+	util::{pack_ptr_and_len, unpack_ptr_and_len},
+	RIType,
+};
+
+#[cfg(feature = "std")]
+use crate::host::*;
+#[cfg(not(feature = "std"))]
+use crate::wasm::*;
+
+#[cfg(feature = "std")]
+use sp_wasm_interface::{FunctionContext, Pointer, Result};
+
+use sp_std::marker::PhantomData;
+
+#[cfg(not(feature = "std"))]
+use sp_std::vec::Vec;
+
+/// Derive macro for implementing [`PassBy`] with the [`Codec`] strategy.
+///
+/// This requires that the type implements [`Encode`](codec::Encode) and
+/// [`Decode`](codec::Decode) from `parity-scale-codec`.
+///
+/// # Example
+///
+/// ```
+/// # use sp_runtime_interface::pass_by::PassByCodec;
+/// # use codec::{Encode, Decode};
+/// #[derive(PassByCodec, Encode, Decode)]
+/// struct EncodableType {
+///     name: Vec<u8>,
+///     param: u32,
+/// }
+/// ```
+pub use sp_runtime_interface_proc_macro::PassByCodec;
+
+/// Derive macro for implementing [`PassBy`] with the [`Inner`] strategy.
+///
+/// Besides implementing [`PassBy`], this derive also implements the helper trait
+/// [`PassByInner`].
+///
+/// The type is required to be a struct with just one field. The field type needs to implement
+/// the required traits to pass it between the wasm and the native side. (See the runtime
+/// interface crate for more information about these traits.)
+///
+/// # Example
+///
+/// ```
+/// # use sp_runtime_interface::pass_by::PassByInner;
+/// #[derive(PassByInner)]
+/// struct Data([u8; 32]);
+/// ```
+///
+/// ```
+/// # use sp_runtime_interface::pass_by::PassByInner;
+/// #[derive(PassByInner)]
+/// struct Data {
+///     data: [u8; 32],
+/// }
+/// ```
+pub use sp_runtime_interface_proc_macro::PassByInner;
+
+/// Derive macro for implementing [`PassBy`] with the [`Enum`] strategy.
+///
+/// Besides implementing [`PassBy`], this derive also implements `TryFrom<u8>` and
+/// `From<Self> for u8` for the type.
+///
+/// The type is required to be an enum with only unit variants and at maximum `256` variants.
+/// Also it is required that the type implements `Copy`.
+///
+/// # Example
+///
+/// ```
+/// # use sp_runtime_interface::pass_by::PassByEnum;
+/// #[derive(PassByEnum, Copy, Clone)]
+/// enum Data {
+///     Okay,
+///     NotOkay,
+///     // This will not work with the derive.
+///     //Why(u32),
+/// }
+/// ```
+pub use sp_runtime_interface_proc_macro::PassByEnum;
+
+/// Something that should be passed between wasm and the host using the given strategy.
+///
+/// See [`Codec`], [`Inner`] or [`Enum`] for more information about the provided strategies.
+pub trait PassBy: Sized {
+	/// The strategy that should be used to pass the type.
+	type PassBy: PassByImpl<Self>;
+}
+
+/// Something that provides a strategy for passing a type between wasm and the host.
+///
+/// This trait exposes the same functionality as [`crate::host::IntoFFIValue`] and
+/// [`crate::host::FromFFIValue`] to delegate the implementation for a type to a different type.
+///
+/// This trait is used for the host implementation.
+#[cfg(feature = "std")]
+pub trait PassByImpl<T>: RIType {
+	/// Convert the given instance to the ffi value.
+	///
+	/// For more information see: [`crate::host::IntoFFIValue::into_ffi_value`]
+	fn into_ffi_value(instance: T, context: &mut dyn FunctionContext) -> Result<Self::FFIType>;
+
+	/// Create `T` from the given ffi value.
+	///
+	/// For more information see: [`crate::host::FromFFIValue::from_ffi_value`]
+	fn from_ffi_value(context: &mut dyn FunctionContext, arg: Self::FFIType) -> Result<T>;
+}
+
+/// Something that provides a strategy for passing a type between wasm and the host.
+///
+/// This trait exposes the same functionality as [`crate::wasm::IntoFFIValue`] and
+/// [`crate::wasm::FromFFIValue`] to delegate the implementation for a type to a different type.
+///
+/// This trait is used for the wasm implementation.
+#[cfg(not(feature = "std"))]
+pub trait PassByImpl<T>: RIType {
+	/// The owned rust type that is stored with the ffi value in [`crate::wasm::WrappedFFIValue`].
+	type Owned;
+
+	/// Convert the given `instance` into [`crate::wasm::WrappedFFIValue`].
+	///
+	/// For more information see: [`crate::wasm::IntoFFIValue::into_ffi_value`]
+	fn into_ffi_value(instance: &T) -> WrappedFFIValue<Self::FFIType, Self::Owned>;
+
+	/// Create `T` from the given ffi value.
+	///
+	/// For more information see: [`crate::wasm::FromFFIValue::from_ffi_value`]
+	fn from_ffi_value(arg: Self::FFIType) -> T;
+}
+
+impl<T: PassBy> RIType for T {
+	type FFIType = <T::PassBy as RIType>::FFIType;
+}
+
+#[cfg(feature = "std")]
+impl<T: PassBy> IntoFFIValue for T {
+	fn into_ffi_value(
+		self,
+		context: &mut dyn FunctionContext,
+	) -> Result<<T::PassBy as RIType>::FFIType> {
+		T::PassBy::into_ffi_value(self, context)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: PassBy> FromFFIValue for T {
+	type SelfInstance = Self;
+
+	fn from_ffi_value(
+		context: &mut dyn FunctionContext,
+		arg: <T::PassBy as RIType>::FFIType,
+	) -> Result<Self> {
+		T::PassBy::from_ffi_value(context, arg)
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: PassBy> IntoFFIValue for T {
+	type Owned = <T::PassBy as PassByImpl<T>>::Owned;
+
+	fn into_ffi_value(&self) -> WrappedFFIValue<<T::PassBy as RIType>::FFIType, Self::Owned> {
+		T::PassBy::into_ffi_value(self)
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: PassBy> FromFFIValue for T {
+	fn from_ffi_value(arg: <T::PassBy as RIType>::FFIType) -> Self {
+		T::PassBy::from_ffi_value(arg)
+	}
+}
+
+/// The implementation of the pass by codec strategy. This strategy uses a SCALE encoded
+/// representation of the type between wasm and the host.
+///
+/// Use this type as associated type for [`PassBy`] to implement this strategy for a type.
+///
+/// This type expects the type that wants to implement this strategy as generic parameter.
+///
+/// [`PassByCodec`](derive.PassByCodec.html) is a derive macro to implement this strategy.
+///
+/// # Example
+/// ```
+/// # use sp_runtime_interface::pass_by::{PassBy, Codec};
+/// #[derive(codec::Encode, codec::Decode)]
+/// struct Test;
+///
+/// impl PassBy for Test {
+///     type PassBy = Codec<Self>;
+/// }
+/// ```
+pub struct Codec<T: codec::Codec>(PhantomData<T>);
+
+#[cfg(feature = "std")]
+impl<T: codec::Codec> PassByImpl<T> for Codec<T> {
+	fn into_ffi_value(instance: T, context: &mut dyn FunctionContext) -> Result<Self::FFIType> {
+		let vec = instance.encode();
+		let ptr = context.allocate_memory(vec.len() as u32)?;
+		context.write_memory(ptr, &vec)?;
+
+		Ok(pack_ptr_and_len(ptr.into(), vec.len() as u32))
+	}
+
+	fn from_ffi_value(context: &mut dyn FunctionContext, arg: Self::FFIType) -> Result<T> {
+		let (ptr, len) = unpack_ptr_and_len(arg);
+		let vec = context.read_memory(Pointer::new(ptr), len)?;
+		T::decode(&mut &vec[..]).map_err(|e| format!("Could not decode value from wasm: {}", e))
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: codec::Codec> PassByImpl<T> for Codec<T> {
+	type Owned = Vec<u8>;
+
+	fn into_ffi_value(instance: &T) -> WrappedFFIValue<Self::FFIType, Self::Owned> {
+		let data = instance.encode();
+		let ffi_value = pack_ptr_and_len(data.as_ptr() as u32, data.len() as u32);
+		(ffi_value, data).into()
+	}
+
+	fn from_ffi_value(arg: Self::FFIType) -> T {
+		let (ptr, len) = unpack_ptr_and_len(arg);
+		let len = len as usize;
+
+		let encoded = if len == 0 {
+			bytes::Bytes::new()
+		} else {
+			bytes::Bytes::from(unsafe { Vec::from_raw_parts(ptr as *mut u8, len, len) })
+		};
+
+		codec::decode_from_bytes(encoded).expect("Host to wasm values are encoded correctly; qed")
+	}
+}
+
+/// The type is passed as `u64`.
+///
+/// The `u64` value is build by `length 32bit << 32 | pointer 32bit`
+///
+/// `Self` is encoded and the length and the pointer are taken from the encoded vector.
+impl<T: codec::Codec> RIType for Codec<T> {
+	type FFIType = u64;
+}
+
+/// Trait that needs to be implemented by a type that should be passed between wasm and the host,
+/// by using the inner type. See [`Inner`] for more information.
+pub trait PassByInner: Sized {
+	/// The inner type that is wrapped by `Self`.
+	type Inner: RIType;
+
+	/// Consumes `self` and returns the inner type.
+	fn into_inner(self) -> Self::Inner;
+
+	/// Returns the reference to the inner type.
+	fn inner(&self) -> &Self::Inner;
+
+	/// Construct `Self` from the given `inner`.
+	fn from_inner(inner: Self::Inner) -> Self;
+}
+
+/// The implementation of the pass by inner type strategy. The type that uses this strategy will be
+/// passed between wasm and the host by using the wrapped inner type. So, this strategy is only
+/// usable by newtype structs.
+///
+/// Use this type as associated type for [`PassBy`] to implement this strategy for a type. Besides
+/// that the `PassByInner` trait need to be implemented as well.
+///
+/// This type expects the type that wants to use this strategy as generic parameter `T` and the
+/// inner type as generic parameter `I`.
+///
+/// [`PassByInner`](derive.PassByInner.html) is a derive macro to implement this strategy.
+///
+/// # Example
+/// ```
+/// # use sp_runtime_interface::pass_by::{PassBy, Inner, PassByInner};
+/// struct Test([u8; 32]);
+///
+/// impl PassBy for Test {
+///     type PassBy = Inner<Self, [u8; 32]>;
+/// }
+///
+/// impl PassByInner for Test {
+///     type Inner = [u8; 32];
+///
+///     fn into_inner(self) -> [u8; 32] {
+///         self.0
+///     }
+///     fn inner(&self) -> &[u8; 32] {
+///         &self.0
+///     }
+///     fn from_inner(inner: [u8; 32]) -> Self {
+///         Self(inner)
+///     }
+/// }
+/// ```
+pub struct Inner<T: PassByInner<Inner = I>, I: RIType>(PhantomData<(T, I)>);
+
+#[cfg(feature = "std")]
+impl<T: PassByInner<Inner = I>, I: RIType> PassByImpl<T> for Inner<T, I>
+where
+	I: IntoFFIValue + FromFFIValue<SelfInstance = I>,
+{
+	fn into_ffi_value(instance: T, context: &mut dyn FunctionContext) -> Result<Self::FFIType> {
+		instance.into_inner().into_ffi_value(context)
+	}
+
+	fn from_ffi_value(context: &mut dyn FunctionContext, arg: Self::FFIType) -> Result<T> {
+		I::from_ffi_value(context, arg).map(T::from_inner)
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: PassByInner<Inner = I>, I: RIType> PassByImpl<T> for Inner<T, I>
+where
+	I: IntoFFIValue + FromFFIValue,
+{
+	type Owned = I::Owned;
+
+	fn into_ffi_value(instance: &T) -> WrappedFFIValue<Self::FFIType, Self::Owned> {
+		instance.inner().into_ffi_value()
+	}
+
+	fn from_ffi_value(arg: Self::FFIType) -> T {
+		T::from_inner(I::from_ffi_value(arg))
+	}
+}
+
+/// The type is passed as the inner type.
+impl<T: PassByInner<Inner = I>, I: RIType> RIType for Inner<T, I> {
+	type FFIType = I::FFIType;
+}
+
+/// The implementation of the pass by enum strategy. This strategy uses an `u8` internally to pass
+/// the enum between wasm and the host. So, this strategy only supports enums with unit variants.
+///
+/// Use this type as associated type for [`PassBy`] to implement this strategy for a type.
+///
+/// This type expects the type that wants to implement this strategy as generic parameter. Besides
+/// that the type needs to implement `TryFrom<u8>` and `From<Self> for u8`.
+///
+/// [`PassByEnum`](derive.PassByEnum.html) is a derive macro to implement this strategy.
+///
+/// # Example
+/// ```
+/// # use sp_runtime_interface::pass_by::{PassBy, Enum};
+/// #[derive(Clone, Copy)]
+/// enum Test {
+///     Test1,
+///     Test2,
+/// }
+///
+/// impl From<Test> for u8 {
+///     fn from(val: Test) -> u8 {
+///         match val {
+///             Test::Test1 => 0,
+///             Test::Test2 => 1,
+///         }
+///     }
+/// }
+///
+/// impl TryFrom<u8> for Test {
+///     type Error = ();
+///
+///     fn try_from(val: u8) -> Result<Test, ()> {
+///         match val {
+///             0 => Ok(Test::Test1),
+///             1 => Ok(Test::Test2),
+///             _ => Err(()),
+///         }
+///     }
+/// }
+///
+/// impl PassBy for Test {
+///     type PassBy = Enum<Self>;
+/// }
+/// ```
+pub struct Enum<T: Copy + Into<u8> + TryFrom<u8>>(PhantomData<T>);
+
+#[cfg(feature = "std")]
+impl<T: Copy + Into<u8> + TryFrom<u8>> PassByImpl<T> for Enum<T> {
+	fn into_ffi_value(instance: T, _: &mut dyn FunctionContext) -> Result<Self::FFIType> {
+		Ok(instance.into() as u32)
+	}
+
+	fn from_ffi_value(_: &mut dyn FunctionContext, arg: Self::FFIType) -> Result<T> {
+		T::try_from(arg as u8).map_err(|_| format!("Invalid enum discriminant: {}", arg))
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<T: Copy + Into<u8> + TryFrom<u8, Error = ()>> PassByImpl<T> for Enum<T> {
+	type Owned = ();
+
+	fn into_ffi_value(instance: &T) -> WrappedFFIValue<Self::FFIType, Self::Owned> {
+		let value: u8 = (*instance).into();
+		(value as u32).into()
+	}
+
+	fn from_ffi_value(arg: Self::FFIType) -> T {
+		T::try_from(arg as u8).expect("Host to wasm provides a valid enum discriminant; qed")
+	}
+}
+
+/// The type is passed as `u32`.
+///
+/// The value is corresponds to the discriminant of the variant.
+impl<T: Copy + Into<u8> + TryFrom<u8>> RIType for Enum<T> {
+	type FFIType = u32;
+}
diff --git a/substrate/primitives/runtime-interface/src/util.rs b/substrate/primitives/runtime-interface/src/util.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8db32271a0e7e7b682fb4b7012ea897ca8d02640
--- /dev/null
+++ b/substrate/primitives/runtime-interface/src/util.rs
@@ -0,0 +1,60 @@
+// 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.
+
+//! Various utilities that help interfacing with wasm runtime code.
+
+/// Pack a pointer and length into an `u64`.
+pub fn pack_ptr_and_len(ptr: u32, len: u32) -> u64 {
+	// The static assertions from above are changed into a runtime check.
+	#[cfg(all(not(feature = "std"), feature = "disable_target_static_assertions"))]
+	assert_eq!(4, sp_std::mem::size_of::<usize>());
+
+	(u64::from(len) << 32) | u64::from(ptr)
+}
+
+/// Unpacks an `u64` into the pointer and length.
+///
+/// Runtime API functions return a 64-bit value which encodes a pointer in the least-significant
+/// 32-bits and a length in the most-significant 32 bits. This interprets the returned value as a
+/// pointer, length tuple.
+pub fn unpack_ptr_and_len(val: u64) -> (u32, u32) {
+	// The static assertions from above are changed into a runtime check.
+	#[cfg(all(not(feature = "std"), feature = "disable_target_static_assertions"))]
+	assert_eq!(4, sp_std::mem::size_of::<usize>());
+
+	let ptr = (val & (!0u32 as u64)) as u32;
+	let len = (val >> 32) as u32;
+
+	(ptr, len)
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{pack_ptr_and_len, unpack_ptr_and_len};
+
+	#[test]
+	fn ptr_len_packing_unpacking() {
+		const PTR: u32 = 0x1337;
+		const LEN: u32 = 0x7f000000;
+
+		let packed = pack_ptr_and_len(PTR, LEN);
+		let (ptr, len) = unpack_ptr_and_len(packed);
+
+		assert_eq!(PTR, ptr);
+		assert_eq!(LEN, len);
+	}
+}
diff --git a/substrate/primitives/runtime-interface/src/wasm.rs b/substrate/primitives/runtime-interface/src/wasm.rs
new file mode 100644
index 0000000000000000000000000000000000000000..91205addf21a0fead6c36391c24ff77ee97c951e
--- /dev/null
+++ b/substrate/primitives/runtime-interface/src/wasm.rs
@@ -0,0 +1,145 @@
+// 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.
+
+//! Traits required by the runtime interface from the wasm side.
+
+use crate::RIType;
+
+use sp_std::cell::Cell;
+
+/// Something that can be created from a ffi value.
+///
+/// # Safety
+///
+/// It is unsafe behavior to call `Something::into_ffi_value().get()` and take this as input for
+/// `from_ffi_value`. Implementations are safe to assume that the `arg` given to `from_ffi_value`
+/// is only generated by the corresponding [`host::IntoFFIValue`](crate::host::IntoFFIValue)
+/// implementation.
+pub trait FromFFIValue: Sized + RIType {
+	/// Create `Self` from the given ffi value.
+	fn from_ffi_value(arg: Self::FFIType) -> Self;
+}
+
+/// Something that can be converted into a ffi value.
+pub trait IntoFFIValue: RIType {
+	/// The owned rust type that is stored with the ffi value in [`WrappedFFIValue`].
+	///
+	/// If no owned value is required, `()` can be used as a type.
+	type Owned;
+
+	/// Convert `self` into a [`WrappedFFIValue`].
+	fn into_ffi_value(&self) -> WrappedFFIValue<Self::FFIType, Self::Owned>;
+}
+
+/// Represents a wrapped ffi value.
+///
+/// It is either the ffi value itself or the ffi value plus some other owned value. By providing
+/// support for storing another owned value besides the actual ffi value certain performance
+/// optimizations can be applied. For example using the pointer to a `Vec<u8>`, while using the
+/// pointer to a SCALE encoded `Vec<u8>` that is stored in this wrapper for any other `Vec<T>`.
+pub enum WrappedFFIValue<T, O = ()> {
+	Wrapped(T),
+	WrappedAndOwned(T, O),
+}
+
+impl<T: Copy, O> WrappedFFIValue<T, O> {
+	/// Returns the wrapped ffi value.
+	pub fn get(&self) -> T {
+		match self {
+			Self::Wrapped(data) | Self::WrappedAndOwned(data, _) => *data,
+		}
+	}
+}
+
+impl<T, O> From<T> for WrappedFFIValue<T, O> {
+	fn from(val: T) -> Self {
+		WrappedFFIValue::Wrapped(val)
+	}
+}
+
+impl<T, O> From<(T, O)> for WrappedFFIValue<T, O> {
+	fn from(val: (T, O)) -> Self {
+		WrappedFFIValue::WrappedAndOwned(val.0, val.1)
+	}
+}
+
+/// The state of an exchangeable function.
+#[derive(Clone, Copy)]
+enum ExchangeableFunctionState {
+	/// Original function is present
+	Original,
+	/// The function has been replaced.
+	Replaced,
+}
+
+/// A function which implementation can be exchanged.
+///
+/// Internally this works by swapping function pointers.
+pub struct ExchangeableFunction<T>(Cell<(T, ExchangeableFunctionState)>);
+
+impl<T> ExchangeableFunction<T> {
+	/// Create a new instance of `ExchangeableFunction`.
+	pub const fn new(impl_: T) -> Self {
+		Self(Cell::new((impl_, ExchangeableFunctionState::Original)))
+	}
+}
+
+impl<T: Copy> ExchangeableFunction<T> {
+	/// Replace the implementation with `new_impl`.
+	///
+	/// # Panics
+	///
+	/// Panics when trying to replace an already replaced implementation.
+	///
+	/// # Returns
+	///
+	/// Returns the original implementation wrapped in [`RestoreImplementation`].
+	pub fn replace_implementation(&'static self, new_impl: T) -> RestoreImplementation<T> {
+		if let ExchangeableFunctionState::Replaced = self.0.get().1 {
+			panic!("Trying to replace an already replaced implementation!")
+		}
+
+		let old = self.0.replace((new_impl, ExchangeableFunctionState::Replaced));
+
+		RestoreImplementation(self, Some(old.0))
+	}
+
+	/// Restore the original implementation.
+	fn restore_orig_implementation(&self, orig: T) {
+		self.0.set((orig, ExchangeableFunctionState::Original));
+	}
+
+	/// Returns the internal function pointer.
+	pub fn get(&self) -> T {
+		self.0.get().0
+	}
+}
+
+// Wasm does not support threads, so this is safe; qed.
+unsafe impl<T> Sync for ExchangeableFunction<T> {}
+
+/// Restores a function implementation on drop.
+///
+/// Stores a static reference to the function object and the original implementation.
+pub struct RestoreImplementation<T: 'static + Copy>(&'static ExchangeableFunction<T>, Option<T>);
+
+impl<T: Copy> Drop for RestoreImplementation<T> {
+	fn drop(&mut self) {
+		self.0
+			.restore_orig_implementation(self.1.take().expect("Value is only taken on drop; qed"));
+	}
+}
diff --git a/substrate/primitives/runtime-interface/test-wasm-deprecated/Cargo.toml b/substrate/primitives/runtime-interface/test-wasm-deprecated/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d2fd8a2f2c5c432bf25b0e3345bb71d9397a2282
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test-wasm-deprecated/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "sp-runtime-interface-test-wasm-deprecated"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+build = "build.rs"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-core = { version = "21.0.0", default-features = false, path = "../../core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../io" }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../" }
+
+[build-dependencies]
+substrate-wasm-builder = { version = "5.0.0-dev", path = "../../../utils/wasm-builder", optional = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime-interface/std",
+	"substrate-wasm-builder",
+]
diff --git a/substrate/primitives/runtime-interface/test-wasm-deprecated/build.rs b/substrate/primitives/runtime-interface/test-wasm-deprecated/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..651f57388e0d0b56956b3b43343beea536ddfb81
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test-wasm-deprecated/build.rs
@@ -0,0 +1,28 @@
+// 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::new()
+			.with_current_project()
+			.export_heap_base()
+			.import_memory()
+			.disable_runtime_version_section_check()
+			.build();
+	}
+}
diff --git a/substrate/primitives/runtime-interface/test-wasm-deprecated/src/lib.rs b/substrate/primitives/runtime-interface/test-wasm-deprecated/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2f42e60504eb77af41c9107f9a5bb1178ffaf0ea
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test-wasm-deprecated/src/lib.rs
@@ -0,0 +1,63 @@
+// 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 the runtime interface traits and proc macros.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_core::wasm_export_functions;
+use sp_runtime_interface::runtime_interface;
+
+// Include the WASM binary
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+/// Wasm binary unwrapped. If built with `SKIP_WASM_BUILD`, the function panics.
+#[cfg(feature = "std")]
+pub fn wasm_binary_unwrap() -> &'static [u8] {
+	WASM_BINARY.expect(
+		"Development wasm binary is not available. Testing is only supported with the flag \
+		 disabled.",
+	)
+}
+
+/// This function is not used, but we require it for the compiler to include `sp-io`.
+/// `sp-io` is required for its panic and oom handler.
+#[cfg(not(feature = "std"))]
+#[no_mangle]
+pub fn import_sp_io() {
+	sp_io::misc::print_utf8(&[]);
+}
+
+#[runtime_interface]
+pub trait TestApi {
+	fn test_versionning(&self, _data: u32) -> bool {
+		// should not be called
+		unimplemented!()
+	}
+}
+
+wasm_export_functions! {
+	fn test_versionning_works() {
+		// old api allows only 42 and 50
+		assert!(test_api::test_versionning(42));
+		assert!(test_api::test_versionning(50));
+
+		assert!(!test_api::test_versionning(142));
+		assert!(!test_api::test_versionning(0));
+	}
+}
diff --git a/substrate/primitives/runtime-interface/test-wasm/Cargo.toml b/substrate/primitives/runtime-interface/test-wasm/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b1ab8531b0e7d615f18cf97dbcba0bd1ffe3e5d5
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test-wasm/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+name = "sp-runtime-interface-test-wasm"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+build = "build.rs"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+bytes = { version = "1.1.0", default-features = false }
+sp-core = { version = "21.0.0", default-features = false, path = "../../core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../io" }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../std" }
+
+[build-dependencies]
+substrate-wasm-builder = { version = "5.0.0-dev", path = "../../../utils/wasm-builder", optional = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime-interface/std",
+	"sp-std/std",
+	"substrate-wasm-builder",
+]
diff --git a/substrate/primitives/runtime-interface/test-wasm/build.rs b/substrate/primitives/runtime-interface/test-wasm/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..651f57388e0d0b56956b3b43343beea536ddfb81
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test-wasm/build.rs
@@ -0,0 +1,28 @@
+// 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::new()
+			.with_current_project()
+			.export_heap_base()
+			.import_memory()
+			.disable_runtime_version_section_check()
+			.build();
+	}
+}
diff --git a/substrate/primitives/runtime-interface/test-wasm/src/lib.rs b/substrate/primitives/runtime-interface/test-wasm/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cf1ff3bca088fa7ba25047f48a452d775679c0fc
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test-wasm/src/lib.rs
@@ -0,0 +1,323 @@
+// 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 the runtime interface traits and proc macros.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_runtime_interface::runtime_interface;
+
+#[cfg(not(feature = "std"))]
+use sp_std::{mem, prelude::*};
+
+use sp_core::{sr25519::Public, wasm_export_functions};
+
+// Include the WASM binary
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+/// Wasm binary unwrapped. If built with `SKIP_WASM_BUILD`, the function panics.
+#[cfg(feature = "std")]
+pub fn wasm_binary_unwrap() -> &'static [u8] {
+	WASM_BINARY.expect(
+		"Development wasm binary is not available. Testing is only \
+						supported with the flag disabled.",
+	)
+}
+
+/// Used in the `test_array_as_mutable_reference` test.
+const TEST_ARRAY: [u8; 16] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
+
+#[runtime_interface]
+pub trait TestApi {
+	/// Returns the input data as result.
+	fn return_input(data: Vec<u8>) -> Vec<u8> {
+		data
+	}
+
+	/// Returns 16kb data.
+	///
+	/// # Note
+	///
+	/// We return a `Vec<u32>` because this will use the code path that uses SCALE
+	/// to pass the data between native/wasm. (`Vec<u8>` is passed without encoding the
+	/// data)
+	fn return_16kb() -> Vec<u32> {
+		vec![0; 4 * 1024]
+	}
+
+	fn return_option_vec() -> Option<Vec<u8>> {
+		let mut vec = Vec::new();
+		vec.resize(16 * 1024, 0xAA);
+		Some(vec)
+	}
+
+	fn return_option_bytes() -> Option<bytes::Bytes> {
+		let mut vec = Vec::new();
+		vec.resize(16 * 1024, 0xAA);
+		Some(vec.into())
+	}
+
+	/// Set the storage at key with value.
+	fn set_storage(&mut self, key: &[u8], data: &[u8]) {
+		self.place_storage(key.to_vec(), Some(data.to_vec()));
+	}
+
+	/// Copy `hello` into the given mutable reference
+	fn return_value_into_mutable_reference(&self, data: &mut [u8]) {
+		let res = "hello";
+		data[..res.as_bytes().len()].copy_from_slice(res.as_bytes());
+	}
+
+	/// Returns the input data wrapped in an `Option` as result.
+	fn return_option_input(data: Vec<u8>) -> Option<Vec<u8>> {
+		Some(data)
+	}
+
+	/// Get an array as input and returns a subset of this array.
+	fn get_and_return_array(data: [u8; 34]) -> [u8; 16] {
+		let mut res = [0u8; 16];
+		res.copy_from_slice(&data[..16]);
+		res
+	}
+
+	/// Take and fill mutable array.
+	fn array_as_mutable_reference(data: &mut [u8; 16]) {
+		data.copy_from_slice(&TEST_ARRAY);
+	}
+
+	/// Returns the given public key as result.
+	fn return_input_public_key(key: Public) -> Public {
+		key
+	}
+
+	/// A function that is called with invalid utf8 data from the runtime.
+	///
+	/// This also checks that we accept `_` (wild card) argument names.
+	fn invalid_utf8_data(_: &str) {}
+
+	/// Overwrite the native implementation in wasm. The native implementation always returns
+	/// `false` and the replacement function will return always `true`.
+	fn overwrite_native_function_implementation() -> bool {
+		false
+	}
+
+	/// Gets an `u128` and returns this value
+	fn get_and_return_u128(val: u128) -> u128 {
+		val
+	}
+
+	/// Gets an `i128` and returns this value
+	fn get_and_return_i128(val: i128) -> i128 {
+		val
+	}
+
+	fn test_versionning(&self, data: u32) -> bool {
+		data == 42 || data == 50
+	}
+
+	#[version(2)]
+	fn test_versionning(&self, data: u32) -> bool {
+		data == 42
+	}
+
+	fn test_versionning_register_only(&self, data: u32) -> bool {
+		data == 80
+	}
+
+	#[version(2, register_only)]
+	fn test_versionning_register_only(&self, data: u32) -> bool {
+		data == 42
+	}
+
+	/// Returns the input values as tuple.
+	fn return_input_as_tuple(
+		a: Vec<u8>,
+		b: u32,
+		c: Option<Vec<u32>>,
+		d: u8,
+	) -> (Vec<u8>, u32, Option<Vec<u32>>, u8) {
+		(a, b, c, d)
+	}
+}
+
+/// This function is not used, but we require it for the compiler to include `sp-io`.
+/// `sp-io` is required for its panic and oom handler.
+#[no_mangle]
+pub fn import_sp_io() {
+	sp_io::misc::print_utf8(&[]);
+}
+
+wasm_export_functions! {
+	fn test_return_data() {
+		let input = vec![1, 2, 3, 4, 5, 6];
+		let res = test_api::return_input(input.clone());
+
+		assert_eq!(input, res);
+	}
+
+	fn test_return_option_data() {
+		let input = vec![1, 2, 3, 4, 5, 6];
+		let res = test_api::return_option_input(input.clone());
+
+		assert_eq!(Some(input), res);
+	}
+
+	fn test_set_storage() {
+		let key = "hello";
+		let value = "world";
+
+		test_api::set_storage(key.as_bytes(), value.as_bytes());
+	}
+
+	fn test_return_value_into_mutable_reference() {
+		let mut data = vec![1, 2, 3, 4, 5, 6];
+
+		test_api::return_value_into_mutable_reference(&mut data);
+
+		let expected = "hello";
+		assert_eq!(expected.as_bytes(), &data[..expected.len()]);
+	}
+
+	fn test_get_and_return_array() {
+		let mut input = unsafe { mem::MaybeUninit::<[u8; 34]>::zeroed().assume_init() };
+		input.copy_from_slice(&[
+			24, 3, 23, 20, 2, 16, 32, 1, 12, 26, 27, 8, 29, 31, 6, 5, 4, 19, 10, 28, 34, 21, 18, 33, 9,
+			13, 22, 25, 15, 11, 30, 7, 14, 17,
+		]);
+
+		let res = test_api::get_and_return_array(input);
+
+		assert_eq!(&res, &input[..16]);
+	}
+
+	fn test_array_as_mutable_reference() {
+		let mut array = [0u8; 16];
+		test_api::array_as_mutable_reference(&mut array);
+
+		assert_eq!(array, TEST_ARRAY);
+	}
+
+	fn test_return_input_public_key() {
+		let key = Public::try_from(
+			&[
+				1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+				25, 26, 27, 28, 29, 30, 31, 32,
+			][..],
+		).unwrap();
+		let ret_key = test_api::return_input_public_key(key.clone());
+
+		let key_data: &[u8] = key.as_ref();
+		let ret_key_data: &[u8] = ret_key.as_ref();
+		assert_eq!(key_data, ret_key_data);
+	}
+
+	fn test_invalid_utf8_data_should_return_an_error() {
+		let data = vec![0, 159, 146, 150];
+		// I'm an evil hacker, trying to hack!
+		let data_str = unsafe { sp_std::str::from_utf8_unchecked(&data) };
+
+		test_api::invalid_utf8_data(data_str);
+	}
+
+	fn test_overwrite_native_function_implementation() {
+		fn new_implementation() -> bool {
+			true
+		}
+
+		// Check native implementation
+		assert!(!test_api::overwrite_native_function_implementation());
+
+		let _guard = test_api::host_overwrite_native_function_implementation
+			.replace_implementation(new_implementation);
+
+		assert!(test_api::overwrite_native_function_implementation());
+	}
+
+	fn test_u128_i128_as_parameter_and_return_value() {
+		for val in &[u128::MAX, 1u128, 5000u128, u64::MAX as u128] {
+			assert_eq!(*val, test_api::get_and_return_u128(*val));
+		}
+
+		for val in &[i128::MAX, i128::MIN, 1i128, 5000i128, u64::MAX as i128] {
+			assert_eq!(*val, test_api::get_and_return_i128(*val));
+		}
+	}
+
+	fn test_vec_return_value_memory_is_freed() {
+		let mut len = 0;
+		for _ in 0..1024 {
+			len += test_api::return_16kb().len();
+		}
+		assert_eq!(1024 * 1024 * 4, len);
+	}
+
+	fn test_encoded_return_value_memory_is_freed() {
+		let mut len = 0;
+		for _ in 0..1024 {
+			len += test_api::return_option_input(vec![0; 16 * 1024]).map(|v| v.len()).unwrap();
+		}
+		assert_eq!(1024 * 1024 * 16, len);
+	}
+
+	fn test_array_return_value_memory_is_freed() {
+		let mut len = 0;
+		for _ in 0..1024 * 1024 {
+			len += test_api::get_and_return_array([0; 34])[1];
+		}
+		assert_eq!(0, len);
+	}
+
+	fn test_versionning_works() {
+		// we fix new api to accept only 42 as a proper input
+		// as opposed to sp-runtime-interface-test-wasm-deprecated::test_api::verify_input
+		// which accepted 42 and 50.
+		assert!(test_api::test_versionning(42));
+
+		assert!(!test_api::test_versionning(50));
+		assert!(!test_api::test_versionning(102));
+	}
+
+	fn test_versionning_register_only_works() {
+		// Ensure that we will import the version of the runtime interface function that
+		// isn't tagged with `register_only`.
+		assert!(!test_api::test_versionning_register_only(42));
+		assert!(test_api::test_versionning_register_only(80));
+	}
+
+	fn test_return_input_as_tuple() {
+		let a = vec![1, 3, 4, 5];
+		let b = 10000;
+		let c = Some(vec![2, 3]);
+		let d = 5;
+
+		let res = test_api::return_input_as_tuple(a.clone(), b, c.clone(), d);
+
+		assert_eq!(a, res.0);
+		assert_eq!(b, res.1);
+		assert_eq!(c, res.2);
+		assert_eq!(d, res.3);
+	}
+
+	fn test_return_option_vec() {
+		test_api::return_option_vec();
+	}
+
+	fn test_return_option_bytes() {
+		test_api::return_option_bytes();
+	}
+}
diff --git a/substrate/primitives/runtime-interface/test/Cargo.toml b/substrate/primitives/runtime-interface/test/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e5b34c0d27ddf45008d32e6b7b1a35bd199e61ba
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "sp-runtime-interface-test"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+publish = false
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+tracing = "0.1.29"
+tracing-core = "0.1.28"
+sc-executor = { version = "0.10.0-dev", path = "../../../client/executor" }
+sc-executor-common = { version = "0.10.0-dev", path = "../../../client/executor/common" }
+sp-io = { version = "23.0.0", path = "../../io" }
+sp-runtime = { version = "24.0.0", path = "../../runtime" }
+sp-runtime-interface = { version = "17.0.0", path = "../" }
+sp-runtime-interface-test-wasm = { version = "2.0.0", path = "../test-wasm" }
+sp-runtime-interface-test-wasm-deprecated = { version = "2.0.0", path = "../test-wasm-deprecated" }
+sp-state-machine = { version = "0.28.0", path = "../../state-machine" }
diff --git a/substrate/primitives/runtime-interface/test/src/lib.rs b/substrate/primitives/runtime-interface/test/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..215704a1121543f8290623273a1ad6be8295389d
--- /dev/null
+++ b/substrate/primitives/runtime-interface/test/src/lib.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.
+
+//! Integration tests for runtime interface primitives
+#![cfg(test)]
+
+use sp_runtime_interface::*;
+
+use sp_runtime_interface_test_wasm::{test_api::HostFunctions, wasm_binary_unwrap};
+use sp_runtime_interface_test_wasm_deprecated::wasm_binary_unwrap as wasm_binary_deprecated_unwrap;
+
+use sc_executor_common::{runtime_blob::RuntimeBlob, wasm_runtime::AllocationStats};
+use sp_wasm_interface::{ExtendedHostFunctions, HostFunctions as HostFunctionsT};
+
+use std::{
+	collections::HashSet,
+	sync::{Arc, Mutex},
+};
+
+type TestExternalities = sp_state_machine::TestExternalities<sp_runtime::traits::BlakeTwo256>;
+
+fn call_wasm_method_with_result<HF: HostFunctionsT>(
+	binary: &[u8],
+	method: &str,
+) -> (Result<TestExternalities, String>, Option<AllocationStats>) {
+	let mut ext = TestExternalities::default();
+	let mut ext_ext = ext.ext();
+
+	let executor = sc_executor::WasmExecutor::<
+		ExtendedHostFunctions<sp_io::SubstrateHostFunctions, HF>,
+	>::builder()
+	.build();
+
+	let (result, allocation_stats) = executor.uncached_call_with_allocation_stats(
+		RuntimeBlob::uncompress_if_needed(binary).expect("Failed to parse binary"),
+		&mut ext_ext,
+		false,
+		method,
+		&[],
+	);
+	let result = result
+		.map_err(|e| format!("Failed to execute `{}`: {}", method, e))
+		.map(|_| ext);
+	(result, allocation_stats)
+}
+
+fn call_wasm_method<HF: HostFunctionsT>(binary: &[u8], method: &str) -> TestExternalities {
+	call_wasm_method_with_result::<HF>(binary, method).0.unwrap()
+}
+
+#[test]
+fn test_return_data() {
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_return_data");
+}
+
+#[test]
+fn test_return_option_data() {
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_return_option_data");
+}
+
+#[test]
+fn test_set_storage() {
+	let mut ext = call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_set_storage");
+
+	let expected = "world";
+	assert_eq!(expected.as_bytes(), &ext.ext().storage("hello".as_bytes()).unwrap()[..]);
+}
+
+#[test]
+fn test_return_value_into_mutable_reference() {
+	call_wasm_method::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_return_value_into_mutable_reference",
+	);
+}
+
+#[test]
+fn test_get_and_return_array() {
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_get_and_return_array");
+}
+
+#[test]
+fn test_array_as_mutable_reference() {
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_array_as_mutable_reference");
+}
+
+#[test]
+fn test_return_input_public_key() {
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_return_input_public_key");
+}
+
+#[test]
+fn host_function_not_found() {
+	let err = call_wasm_method_with_result::<()>(wasm_binary_unwrap(), "test_return_data")
+		.0
+		.unwrap_err();
+
+	assert!(err.contains("test_return_data"));
+	assert!(err.contains(" Failed to create module"));
+}
+
+#[test]
+#[should_panic(expected = "Invalid utf8 data provided")]
+fn test_invalid_utf8_data_should_return_an_error() {
+	call_wasm_method::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_invalid_utf8_data_should_return_an_error",
+	);
+}
+
+#[test]
+fn test_overwrite_native_function_implementation() {
+	call_wasm_method::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_overwrite_native_function_implementation",
+	);
+}
+
+#[test]
+fn test_u128_i128_as_parameter_and_return_value() {
+	call_wasm_method::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_u128_i128_as_parameter_and_return_value",
+	);
+}
+
+#[test]
+fn test_vec_return_value_memory_is_freed() {
+	call_wasm_method::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_vec_return_value_memory_is_freed",
+	);
+}
+
+#[test]
+fn test_encoded_return_value_memory_is_freed() {
+	call_wasm_method::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_encoded_return_value_memory_is_freed",
+	);
+}
+
+#[test]
+fn test_array_return_value_memory_is_freed() {
+	call_wasm_method::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_array_return_value_memory_is_freed",
+	);
+}
+
+#[test]
+fn test_versionining_with_new_host_works() {
+	// We call to the new wasm binary with new host function.
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_versionning_works");
+
+	// we call to the old wasm binary with a new host functions
+	// old versions of host functions should be called and test should be ok!
+	call_wasm_method::<HostFunctions>(wasm_binary_deprecated_unwrap(), "test_versionning_works");
+}
+
+#[test]
+fn test_versionining_register_only() {
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_versionning_register_only_works");
+}
+
+fn run_test_in_another_process(
+	test_name: &str,
+	test_body: impl FnOnce(),
+) -> Option<std::process::Output> {
+	if std::env::var("RUN_FORKED_TEST").is_ok() {
+		test_body();
+		None
+	} else {
+		let output = std::process::Command::new(std::env::current_exe().unwrap())
+			.arg(test_name)
+			.env("RUN_FORKED_TEST", "1")
+			.output()
+			.unwrap();
+
+		assert!(output.status.success());
+		Some(output)
+	}
+}
+
+#[test]
+fn test_tracing() {
+	// Run in a different process to ensure that the `Span` is registered with our local
+	// `TracingSubscriber`.
+	run_test_in_another_process("test_tracing", || {
+		use std::fmt;
+		use tracing::span::Id as SpanId;
+		use tracing_core::field::{Field, Visit};
+
+		#[derive(Clone)]
+		struct TracingSubscriber(Arc<Mutex<Inner>>);
+
+		struct FieldConsumer(&'static str, Option<String>);
+		impl Visit for FieldConsumer {
+			fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+				if field.name() == self.0 {
+					self.1 = Some(format!("{:?}", value))
+				}
+			}
+		}
+
+		#[derive(Default)]
+		struct Inner {
+			spans: HashSet<String>,
+		}
+
+		impl tracing::subscriber::Subscriber for TracingSubscriber {
+			fn enabled(&self, _: &tracing::Metadata) -> bool {
+				true
+			}
+
+			fn new_span(&self, span: &tracing::span::Attributes) -> tracing::Id {
+				let mut inner = self.0.lock().unwrap();
+				let id = SpanId::from_u64((inner.spans.len() + 1) as _);
+				let mut f = FieldConsumer("name", None);
+				span.record(&mut f);
+				inner.spans.insert(f.1.unwrap_or_else(|| span.metadata().name().to_owned()));
+				id
+			}
+
+			fn record(&self, _: &SpanId, _: &tracing::span::Record) {}
+
+			fn record_follows_from(&self, _: &SpanId, _: &SpanId) {}
+
+			fn event(&self, _: &tracing::Event) {}
+
+			fn enter(&self, _: &SpanId) {}
+
+			fn exit(&self, _: &SpanId) {}
+		}
+
+		let subscriber = TracingSubscriber(Default::default());
+		let _guard = tracing::subscriber::set_default(subscriber.clone());
+
+		// Call some method to generate a trace
+		call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_return_data");
+
+		let inner = subscriber.0.lock().unwrap();
+		assert!(inner.spans.contains("return_input_version_1"));
+	});
+}
+
+#[test]
+fn test_return_input_as_tuple() {
+	call_wasm_method::<HostFunctions>(wasm_binary_unwrap(), "test_return_input_as_tuple");
+}
+
+#[test]
+fn test_returning_option_bytes_from_a_host_function_is_efficient() {
+	let (result, stats_vec) = call_wasm_method_with_result::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_return_option_vec",
+	);
+	result.unwrap();
+	let (result, stats_bytes) = call_wasm_method_with_result::<HostFunctions>(
+		wasm_binary_unwrap(),
+		"test_return_option_bytes",
+	);
+	result.unwrap();
+
+	let stats_vec = stats_vec.unwrap();
+	let stats_bytes = stats_bytes.unwrap();
+
+	// The way we currently implement marshaling of `Option<Vec<u8>>` through
+	// the WASM FFI boundary from the host to the runtime requires that it is
+	// marshaled through SCALE. This is quite inefficient as it requires two
+	// memory allocations inside of the runtime:
+	//
+	//   1) the first allocation to copy the SCALE-encoded blob into the runtime;
+	//   2) and another allocation for the resulting `Vec<u8>` when decoding that blob.
+	//
+	// Both of these allocations are are as big as the `Vec<u8>` which is being
+	// passed to the runtime. This is especially bad when fetching big values
+	// from storage, as it can lead to an out-of-memory situation.
+	//
+	// Our `Option<Bytes>` marshaling is better; it still must go through SCALE,
+	// and it still requires two allocations, however since `Bytes` is zero-copy
+	// only the first allocation is `Vec<u8>`-sized, and the second allocation
+	// which creates the deserialized `Bytes` is tiny, and is only necessary because
+	// the underlying `Bytes` buffer from which we're deserializing gets automatically
+	// turned into an `Arc`.
+	//
+	// So this assertion tests that deserializing `Option<Bytes>` allocates less than
+	// deserializing `Option<Vec<u8>>`.
+	assert_eq!(stats_bytes.bytes_allocated_sum + 16 * 1024 + 8, stats_vec.bytes_allocated_sum);
+}
diff --git a/substrate/primitives/runtime-interface/tests/ui.rs b/substrate/primitives/runtime-interface/tests/ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..821d0b73f268b02ea801247c1ce27520d40150d8
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui.rs
@@ -0,0 +1,33 @@
+// 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 std::env;
+
+#[rustversion::attr(not(stable), ignore)]
+#[test]
+fn ui() {
+	// Only run the ui tests when `RUN_UI_TESTS` is set.
+	if env::var("RUN_UI_TESTS").is_err() {
+		return
+	}
+
+	// As trybuild is using `cargo check`, we don't need the real WASM binaries.
+	env::set_var("SKIP_WASM_BUILD", "1");
+
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/ui/*.rs");
+}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_duplicate_versions.rs b/substrate/primitives/runtime-interface/tests/ui/no_duplicate_versions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..948c327aa1a8b03c0b146031c013e07ca9b589f9
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_duplicate_versions.rs
@@ -0,0 +1,11 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test {
+	#[version(2)]
+	fn test() { }
+	#[version(2)]
+	fn test() { }
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_duplicate_versions.stderr b/substrate/primitives/runtime-interface/tests/ui/no_duplicate_versions.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..592dd9928c9687b875cc10d0d5ea15457c276c2d
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_duplicate_versions.stderr
@@ -0,0 +1,11 @@
+error: Duplicated version attribute
+ --> $DIR/no_duplicate_versions.rs:7:2
+  |
+7 |     #[version(2)]
+  |     ^
+
+error: Previous version with the same number defined here
+ --> $DIR/no_duplicate_versions.rs:5:2
+  |
+5 |     #[version(2)]
+  |     ^
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_feature_gated_method.rs b/substrate/primitives/runtime-interface/tests/ui/no_feature_gated_method.rs
new file mode 100644
index 0000000000000000000000000000000000000000..51e45f178f0c5d1163fd6549dacb8f16ce61bd33
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_feature_gated_method.rs
@@ -0,0 +1,18 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test {
+	fn foo() {}
+
+	#[cfg(feature = "bar-feature")]
+	fn bar() {}
+
+	#[cfg(not(feature = "bar-feature"))]
+	fn qux() {}
+}
+
+fn main() {
+	test::foo();
+	test::bar();
+	test::qux();
+}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_feature_gated_method.stderr b/substrate/primitives/runtime-interface/tests/ui/no_feature_gated_method.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..e8accd62fc68dec8680e093e7b6c0f7b0fc21291
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_feature_gated_method.stderr
@@ -0,0 +1,5 @@
+error[E0425]: cannot find function `bar` in module `test`
+  --> tests/ui/no_feature_gated_method.rs:16:8
+   |
+16 |     test::bar();
+   |           ^^^ not found in `test`
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_gaps_in_versions.rs b/substrate/primitives/runtime-interface/tests/ui/no_gaps_in_versions.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c468f48e37462015c7426f653e0012a528313a25
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_gaps_in_versions.rs
@@ -0,0 +1,17 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test {
+	#[version(1)]
+	fn test2() {}
+	#[version(2)]
+	fn test2() {}
+	#[version(3)]
+	fn test2() {}
+
+	fn test() { }
+	#[version(3)]
+	fn test() { }
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_gaps_in_versions.stderr b/substrate/primitives/runtime-interface/tests/ui/no_gaps_in_versions.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..cdefcf60c56a8c4d27ab352e11cbd42d4198d241
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_gaps_in_versions.stderr
@@ -0,0 +1,5 @@
+error: Unexpected version attribute: missing version '2' for this function
+  --> $DIR/no_gaps_in_versions.rs:13:2
+   |
+13 |     #[version(3)]
+   |     ^
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_method.rs b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_method.rs
new file mode 100644
index 0000000000000000000000000000000000000000..407942eb5ed8899d83a698f7af4b34c6f1ca4ee5
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_method.rs
@@ -0,0 +1,8 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test {
+	fn test<T>() {}
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_method.stderr b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_method.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..8a549753ac9f9abf5f9cf2e1e3cd4e05d1f4b2c4
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_method.stderr
@@ -0,0 +1,5 @@
+error: Generic parameters not supported.
+ --> $DIR/no_generic_parameters_method.rs:5:10
+  |
+5 |     fn test<T>() {}
+  |             ^
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_trait.rs b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_trait.rs
new file mode 100644
index 0000000000000000000000000000000000000000..35efac6761ca28acae520dca795e0995994b4f11
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_trait.rs
@@ -0,0 +1,8 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test<T> {
+	fn test() {}
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_trait.stderr b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_trait.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..794e30bca767d3a3c0aed33713d7baca5d268f28
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_generic_parameters_trait.stderr
@@ -0,0 +1,5 @@
+error: Generic parameters not supported.
+ --> $DIR/no_generic_parameters_trait.rs:4:12
+  |
+4 | trait Test<T> {
+  |            ^
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_method_implementation.rs b/substrate/primitives/runtime-interface/tests/ui/no_method_implementation.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e3cd93e4a97b224857fa34949896d7d53f67a28a
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_method_implementation.rs
@@ -0,0 +1,8 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test {
+	fn test();
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_method_implementation.stderr b/substrate/primitives/runtime-interface/tests/ui/no_method_implementation.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..31b2d39762340a4f09a53780a2a31f9b56def8b4
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_method_implementation.stderr
@@ -0,0 +1,5 @@
+error: Methods need to have an implementation.
+ --> $DIR/no_method_implementation.rs:5:2
+  |
+5 |     fn test();
+  |     ^^
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_versioned_conditional_build.rs b/substrate/primitives/runtime-interface/tests/ui/no_versioned_conditional_build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a4a8a5804bee342f5c224f7ccf886f1cda53ad72
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_versioned_conditional_build.rs
@@ -0,0 +1,12 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test {
+	fn foo() {}
+
+	#[version(2)]
+	#[cfg(feature = "foo-feature")]
+	fn foo() {}
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/no_versioned_conditional_build.stderr b/substrate/primitives/runtime-interface/tests/ui/no_versioned_conditional_build.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..6f50e14278de56abf824522cc5e1d63d63419d7e
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/no_versioned_conditional_build.stderr
@@ -0,0 +1,5 @@
+error: Conditional compilation is not supported for versioned functions
+ --> tests/ui/no_versioned_conditional_build.rs:7:2
+  |
+7 |     #[version(2)]
+  |     ^
diff --git a/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_struct.rs b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_struct.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6f4ae37ea466e1f2f603929c557633c6d2059fcb
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_struct.rs
@@ -0,0 +1,6 @@
+use sp_runtime_interface::pass_by::PassByEnum;
+
+#[derive(PassByEnum)]
+struct Test;
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_struct.stderr b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_struct.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..44fb5a244e03d7a8e9cf71b7e031b00f3b5419ae
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_struct.stderr
@@ -0,0 +1,7 @@
+error: `PassByEnum` only supports enums as input type.
+ --> $DIR/pass_by_enum_with_struct.rs:3:10
+  |
+3 | #[derive(PassByEnum)]
+  |          ^^^^^^^^^^
+  |
+  = note: this error originates in the derive macro `PassByEnum` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_value_variant.rs b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_value_variant.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a03bfdc1aed814f180d6822a74efcc93b05a316c
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_value_variant.rs
@@ -0,0 +1,8 @@
+use sp_runtime_interface::pass_by::PassByEnum;
+
+#[derive(PassByEnum)]
+enum Test {
+	Var0(u32),
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_value_variant.stderr b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_value_variant.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..633dc3bbe8bc4829d32c72acc5ddb6dcd944480d
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/pass_by_enum_with_value_variant.stderr
@@ -0,0 +1,7 @@
+error: `PassByEnum` only supports unit variants.
+ --> $DIR/pass_by_enum_with_value_variant.rs:3:10
+  |
+3 | #[derive(PassByEnum)]
+  |          ^^^^^^^^^^
+  |
+  = note: this error originates in the derive macro `PassByEnum` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/primitives/runtime-interface/tests/ui/pass_by_inner_with_two_fields.rs b/substrate/primitives/runtime-interface/tests/ui/pass_by_inner_with_two_fields.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f496bc3700106b27de4c72d0a3226174e751b03e
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/pass_by_inner_with_two_fields.rs
@@ -0,0 +1,9 @@
+use sp_runtime_interface::pass_by::PassByInner;
+
+#[derive(PassByInner)]
+struct Test {
+	data: u32,
+	data2: u32,
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/pass_by_inner_with_two_fields.stderr b/substrate/primitives/runtime-interface/tests/ui/pass_by_inner_with_two_fields.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..0ffee00210e795532ecbb976cb4b07147c12ecf6
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/pass_by_inner_with_two_fields.stderr
@@ -0,0 +1,7 @@
+error: Only newtype/one field structs are supported by `PassByInner`!
+ --> $DIR/pass_by_inner_with_two_fields.rs:3:10
+  |
+3 | #[derive(PassByInner)]
+  |          ^^^^^^^^^^^
+  |
+  = note: this error originates in the derive macro `PassByInner` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/substrate/primitives/runtime-interface/tests/ui/take_self_by_value.rs b/substrate/primitives/runtime-interface/tests/ui/take_self_by_value.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9c12614d9307726c01c8e3acfcb59bbd5b926abd
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/take_self_by_value.rs
@@ -0,0 +1,8 @@
+use sp_runtime_interface::runtime_interface;
+
+#[runtime_interface]
+trait Test {
+	fn test(self) {}
+}
+
+fn main() {}
diff --git a/substrate/primitives/runtime-interface/tests/ui/take_self_by_value.stderr b/substrate/primitives/runtime-interface/tests/ui/take_self_by_value.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..9b17a63a35cbcd0e3ef6cbb209b99e435840b9de
--- /dev/null
+++ b/substrate/primitives/runtime-interface/tests/ui/take_self_by_value.stderr
@@ -0,0 +1,5 @@
+error: Taking `Self` by value is not allowed.
+ --> $DIR/take_self_by_value.rs:5:10
+  |
+5 |     fn test(self) {}
+  |             ^^^^
diff --git a/substrate/primitives/runtime/Cargo.toml b/substrate/primitives/runtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..52affa6aa70c4311697b6d724001849c2e294c3d
--- /dev/null
+++ b/substrate/primitives/runtime/Cargo.toml
@@ -0,0 +1,73 @@
+[package]
+name = "sp-runtime"
+version = "24.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Runtime Modules shared primitive types."
+documentation = "https://docs.rs/sp-runtime"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] }
+either = { version = "1.5", default-features = false }
+hash256-std-hasher = { version = "0.15.2", default-features = false }
+impl-trait-for-tuples = "0.2.2"
+log = { version = "0.4.17", default-features = false }
+paste = "1.0"
+rand = { version = "0.8.5", optional = true }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, features = ["derive", "alloc"], optional = true }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../application-crypto" }
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-io = { version = "23.0.0", default-features = false, path = "../io" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-weights = { version = "20.0.0", default-features = false, path = "../weights" }
+
+[dev-dependencies]
+rand = "0.8.5"
+serde_json = "1.0.85"
+zstd = { version = "0.12.3", default-features = false }
+sp-api = { version = "4.0.0-dev", path = "../api" }
+sp-state-machine = { version = "0.28.0", path = "../state-machine" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../test-utils/runtime/client" }
+
+[features]
+runtime-benchmarks = []
+try-runtime = []
+default = [ "std" ]
+std = [
+	"codec/std",
+	"either/use_std",
+	"hash256-std-hasher/std",
+	"log/std",
+	"rand",
+	"scale-info/std",
+	"serde/std",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-tracing/std",
+	"sp-weights/std",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"dep:serde",
+	"scale-info/serde",
+	"sp-application-crypto/serde",
+	"sp-arithmetic/serde",
+	"sp-core/serde",
+	"sp-weights/serde",
+]
diff --git a/substrate/primitives/runtime/README.md b/substrate/primitives/runtime/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1515cd8e2961b5a72fee1d39297e51305d16b0a6
--- /dev/null
+++ b/substrate/primitives/runtime/README.md
@@ -0,0 +1,3 @@
+Runtime Modules shared primitive types.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/runtime/src/curve.rs b/substrate/primitives/runtime/src/curve.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2fc032cfafe2d02a2474233936e2facfdcea36b8
--- /dev/null
+++ b/substrate/primitives/runtime/src/curve.rs
@@ -0,0 +1,163 @@
+// 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.
+
+//! Provides some utilities to define a piecewise linear function.
+
+use crate::{
+	traits::{AtLeast32BitUnsigned, SaturatedConversion},
+	Perbill,
+};
+use core::ops::Sub;
+use scale_info::TypeInfo;
+
+/// Piecewise Linear function in [0, 1] -> [0, 1].
+#[derive(PartialEq, Eq, sp_core::RuntimeDebug, TypeInfo)]
+pub struct PiecewiseLinear<'a> {
+	/// Array of points. Must be in order from the lowest abscissas to the highest.
+	pub points: &'a [(Perbill, Perbill)],
+	/// The maximum value that can be returned.
+	pub maximum: Perbill,
+}
+
+fn abs_sub<N: Ord + Sub<Output = N> + Clone>(a: N, b: N) -> N where {
+	a.clone().max(b.clone()) - a.min(b)
+}
+
+impl<'a> PiecewiseLinear<'a> {
+	/// Compute `f(n/d)*d` with `n <= d`. This is useful to avoid loss of precision.
+	pub fn calculate_for_fraction_times_denominator<N>(&self, n: N, d: N) -> N
+	where
+		N: AtLeast32BitUnsigned + Clone,
+	{
+		let n = n.min(d.clone());
+
+		if self.points.is_empty() {
+			return N::zero()
+		}
+
+		let next_point_index = self.points.iter().position(|p| n < p.0 * d.clone());
+
+		let (prev, next) = if let Some(next_point_index) = next_point_index {
+			if let Some(previous_point_index) = next_point_index.checked_sub(1) {
+				(self.points[previous_point_index], self.points[next_point_index])
+			} else {
+				// There is no previous points, take first point ordinate
+				return self.points.first().map(|p| p.1).unwrap_or_else(Perbill::zero) * d
+			}
+		} else {
+			// There is no next points, take last point ordinate
+			return self.points.last().map(|p| p.1).unwrap_or_else(Perbill::zero) * d
+		};
+
+		let delta_y = multiply_by_rational_saturating(
+			abs_sub(n.clone(), prev.0 * d.clone()),
+			abs_sub(next.1.deconstruct(), prev.1.deconstruct()),
+			// Must not saturate as prev abscissa > next abscissa
+			next.0.deconstruct().saturating_sub(prev.0.deconstruct()),
+		);
+
+		// If both subtractions are same sign then result is positive
+		if (n > prev.0 * d.clone()) == (next.1.deconstruct() > prev.1.deconstruct()) {
+			(prev.1 * d).saturating_add(delta_y)
+		// Otherwise result is negative
+		} else {
+			(prev.1 * d).saturating_sub(delta_y)
+		}
+	}
+}
+
+// Compute value * p / q.
+// This is guaranteed not to overflow on whatever values nor lose precision.
+// `q` must be superior to zero.
+fn multiply_by_rational_saturating<N>(value: N, p: u32, q: u32) -> N
+where
+	N: AtLeast32BitUnsigned + Clone,
+{
+	let q = q.max(1);
+
+	// Mul can saturate if p > q
+	let result_divisor_part = (value.clone() / q.into()).saturating_mul(p.into());
+
+	let result_remainder_part = {
+		let rem = value % q.into();
+
+		// Fits into u32 because q is u32 and remainder < q
+		let rem_u32 = rem.saturated_into::<u32>();
+
+		// Multiplication fits into u64 as both term are u32
+		let rem_part = rem_u32 as u64 * p as u64 / q as u64;
+
+		// Can saturate if p > q
+		rem_part.saturated_into::<N>()
+	};
+
+	// Can saturate if p > q
+	result_divisor_part.saturating_add(result_remainder_part)
+}
+
+#[test]
+fn test_multiply_by_rational_saturating() {
+	let div = 100u32;
+	for value in 0..=div {
+		for p in 0..=div {
+			for q in 1..=div {
+				let value: u64 =
+					(value as u128 * u64::MAX as u128 / div as u128).try_into().unwrap();
+				let p = (p as u64 * u32::MAX as u64 / div as u64).try_into().unwrap();
+				let q = (q as u64 * u32::MAX as u64 / div as u64).try_into().unwrap();
+
+				assert_eq!(
+					multiply_by_rational_saturating(value, p, q),
+					(value as u128 * p as u128 / q as u128).try_into().unwrap_or(u64::MAX)
+				);
+			}
+		}
+	}
+}
+
+#[test]
+fn test_calculate_for_fraction_times_denominator() {
+	let curve = PiecewiseLinear {
+		points: &[
+			(Perbill::from_parts(0_000_000_000), Perbill::from_parts(0_500_000_000)),
+			(Perbill::from_parts(0_500_000_000), Perbill::from_parts(1_000_000_000)),
+			(Perbill::from_parts(1_000_000_000), Perbill::from_parts(0_000_000_000)),
+		],
+		maximum: Perbill::from_parts(1_000_000_000),
+	};
+
+	pub fn formal_calculate_for_fraction_times_denominator(n: u64, d: u64) -> u64 {
+		if n <= Perbill::from_parts(0_500_000_000) * d {
+			n + d / 2
+		} else {
+			(d as u128 * 2 - n as u128 * 2).try_into().unwrap()
+		}
+	}
+
+	let div = 100u32;
+	for d in 0..=div {
+		for n in 0..=d {
+			let d: u64 = (d as u128 * u64::MAX as u128 / div as u128).try_into().unwrap();
+			let n: u64 = (n as u128 * u64::MAX as u128 / div as u128).try_into().unwrap();
+
+			let res = curve.calculate_for_fraction_times_denominator(n, d);
+			let expected = formal_calculate_for_fraction_times_denominator(n, d);
+
+			assert!(abs_sub(res, expected) <= 1);
+		}
+	}
+}
diff --git a/substrate/primitives/runtime/src/generic/block.rs b/substrate/primitives/runtime/src/generic/block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..05146e880cb16571d7eb56c61d8f6c318436d74a
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/block.rs
@@ -0,0 +1,135 @@
+// 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.
+
+//! Generic implementation of a block and associated items.
+
+#[cfg(feature = "std")]
+use std::fmt;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use crate::{
+	codec::{Codec, Decode, Encode},
+	traits::{
+		self, Block as BlockT, Header as HeaderT, MaybeSerialize, MaybeSerializeDeserialize,
+		Member, NumberFor,
+	},
+	Justifications,
+};
+use sp_core::RuntimeDebug;
+use sp_std::prelude::*;
+
+/// Something to identify a block.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
+pub enum BlockId<Block: BlockT> {
+	/// Identify by block header hash.
+	Hash(Block::Hash),
+	/// Identify by block number.
+	Number(NumberFor<Block>),
+}
+
+impl<Block: BlockT> BlockId<Block> {
+	/// Create a block ID from a hash.
+	pub const fn hash(hash: Block::Hash) -> Self {
+		BlockId::Hash(hash)
+	}
+
+	/// Create a block ID from a number.
+	pub const fn number(number: NumberFor<Block>) -> Self {
+		BlockId::Number(number)
+	}
+
+	/// Check if this block ID refers to the pre-genesis state.
+	pub fn is_pre_genesis(&self) -> bool {
+		match self {
+			BlockId::Hash(hash) => hash == &Default::default(),
+			BlockId::Number(_) => false,
+		}
+	}
+
+	/// Create a block ID for a pre-genesis state.
+	pub fn pre_genesis() -> Self {
+		BlockId::Hash(Default::default())
+	}
+}
+
+impl<Block: BlockT> Copy for BlockId<Block> {}
+
+#[cfg(feature = "std")]
+impl<Block: BlockT> fmt::Display for BlockId<Block> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "{:?}", self)
+	}
+}
+
+/// Abstraction over a substrate block.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, scale_info::TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
+pub struct Block<Header, Extrinsic> {
+	/// The block header.
+	pub header: Header,
+	/// The accompanying extrinsics.
+	pub extrinsics: Vec<Extrinsic>,
+}
+
+impl<Header, Extrinsic> traits::HeaderProvider for Block<Header, Extrinsic>
+where
+	Header: HeaderT,
+{
+	type HeaderT = Header;
+}
+
+impl<Header, Extrinsic: MaybeSerialize> traits::Block for Block<Header, Extrinsic>
+where
+	Header: HeaderT + MaybeSerializeDeserialize,
+	Extrinsic: Member + Codec + traits::Extrinsic,
+{
+	type Extrinsic = Extrinsic;
+	type Header = Header;
+	type Hash = <Self::Header as traits::Header>::Hash;
+
+	fn header(&self) -> &Self::Header {
+		&self.header
+	}
+	fn extrinsics(&self) -> &[Self::Extrinsic] {
+		&self.extrinsics[..]
+	}
+	fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>) {
+		(self.header, self.extrinsics)
+	}
+	fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self {
+		Block { header, extrinsics }
+	}
+	fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8> {
+		(header, extrinsics).encode()
+	}
+}
+
+/// Abstraction over a substrate block and justification.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
+pub struct SignedBlock<Block> {
+	/// Full block.
+	pub block: Block,
+	/// Block justification.
+	pub justifications: Option<Justifications>,
+}
diff --git a/substrate/primitives/runtime/src/generic/checked_extrinsic.rs b/substrate/primitives/runtime/src/generic/checked_extrinsic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4b0e017f4517b2948e9e0e45a53efc6fe87c82d6
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/checked_extrinsic.rs
@@ -0,0 +1,96 @@
+// 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.
+
+//! Generic implementation of an extrinsic that has passed the verification
+//! stage.
+
+use crate::{
+	traits::{
+		self, DispatchInfoOf, Dispatchable, MaybeDisplay, Member, PostDispatchInfoOf,
+		SignedExtension, ValidateUnsigned,
+	},
+	transaction_validity::{TransactionSource, TransactionValidity},
+};
+
+/// Definition of something that the external world might want to say; its
+/// existence implies that it has been checked and is good, particularly with
+/// regards to the signature.
+#[derive(PartialEq, Eq, Clone, sp_core::RuntimeDebug)]
+pub struct CheckedExtrinsic<AccountId, Call, Extra> {
+	/// Who this purports to be from and the number of extrinsics have come before
+	/// from the same signer, if anyone (note this is not a signature).
+	pub signed: Option<(AccountId, Extra)>,
+
+	/// The function that should be called.
+	pub function: Call,
+}
+
+impl<AccountId, Call, Extra, RuntimeOrigin> traits::Applyable
+	for CheckedExtrinsic<AccountId, Call, Extra>
+where
+	AccountId: Member + MaybeDisplay,
+	Call: Member + Dispatchable<RuntimeOrigin = RuntimeOrigin>,
+	Extra: SignedExtension<AccountId = AccountId, Call = Call>,
+	RuntimeOrigin: From<Option<AccountId>>,
+{
+	type Call = Call;
+
+	fn validate<U: ValidateUnsigned<Call = Self::Call>>(
+		&self,
+		// TODO [#5006;ToDr] should source be passed to `SignedExtension`s?
+		// Perhaps a change for 2.0 to avoid breaking too much APIs?
+		source: TransactionSource,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		if let Some((ref id, ref extra)) = self.signed {
+			Extra::validate(extra, id, &self.function, info, len)
+		} else {
+			let valid = Extra::validate_unsigned(&self.function, info, len)?;
+			let unsigned_validation = U::validate_unsigned(source, &self.function)?;
+			Ok(valid.combine_with(unsigned_validation))
+		}
+	}
+
+	fn apply<U: ValidateUnsigned<Call = Self::Call>>(
+		self,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> crate::ApplyExtrinsicResultWithInfo<PostDispatchInfoOf<Self::Call>> {
+		let (maybe_who, maybe_pre) = if let Some((id, extra)) = self.signed {
+			let pre = Extra::pre_dispatch(extra, &id, &self.function, info, len)?;
+			(Some(id), Some(pre))
+		} else {
+			Extra::pre_dispatch_unsigned(&self.function, info, len)?;
+			U::pre_dispatch(&self.function)?;
+			(None, None)
+		};
+		let res = self.function.dispatch(RuntimeOrigin::from(maybe_who));
+		let post_info = match res {
+			Ok(info) => info,
+			Err(err) => err.post_info,
+		};
+		Extra::post_dispatch(
+			maybe_pre,
+			info,
+			&post_info,
+			len,
+			&res.map(|_| ()).map_err(|e| e.error),
+		)?;
+		Ok(res)
+	}
+}
diff --git a/substrate/primitives/runtime/src/generic/digest.rs b/substrate/primitives/runtime/src/generic/digest.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d7db0f91a482110f6e9da53e0417657aaf579058
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/digest.rs
@@ -0,0 +1,492 @@
+// 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.
+
+//! Generic implementation of a digest.
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::alloc::format;
+
+use sp_std::prelude::*;
+
+use crate::{
+	codec::{Decode, Encode, Error, Input},
+	scale_info::{
+		build::{Fields, Variants},
+		Path, Type, TypeInfo,
+	},
+	ConsensusEngineId,
+};
+use sp_core::RuntimeDebug;
+
+/// Generic header digest.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, TypeInfo, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct Digest {
+	/// A list of logs in the digest.
+	pub logs: Vec<DigestItem>,
+}
+
+impl Digest {
+	/// Get reference to all digest items.
+	pub fn logs(&self) -> &[DigestItem] {
+		&self.logs
+	}
+
+	/// Push new digest item.
+	pub fn push(&mut self, item: DigestItem) {
+		self.logs.push(item);
+	}
+
+	/// Pop a digest item.
+	pub fn pop(&mut self) -> Option<DigestItem> {
+		self.logs.pop()
+	}
+
+	/// Get reference to the first digest item that matches the passed predicate.
+	pub fn log<T: ?Sized, F: Fn(&DigestItem) -> Option<&T>>(&self, predicate: F) -> Option<&T> {
+		self.logs().iter().find_map(predicate)
+	}
+
+	/// Get a conversion of the first digest item that successfully converts using the function.
+	pub fn convert_first<T, F: Fn(&DigestItem) -> Option<T>>(&self, predicate: F) -> Option<T> {
+		self.logs().iter().find_map(predicate)
+	}
+}
+
+/// Digest item that is able to encode/decode 'system' digest items and
+/// provide opaque access to other items.
+#[derive(PartialEq, Eq, Clone, RuntimeDebug)]
+pub enum DigestItem {
+	/// A pre-runtime digest.
+	///
+	/// These are messages from the consensus engine to the runtime, although
+	/// the consensus engine can (and should) read them itself to avoid
+	/// code and state duplication. It is erroneous for a runtime to produce
+	/// these, but this is not (yet) checked.
+	///
+	/// NOTE: the runtime is not allowed to panic or fail in an `on_initialize`
+	/// call if an expected `PreRuntime` digest is not present. It is the
+	/// responsibility of a external block verifier to check this. Runtime API calls
+	/// will initialize the block without pre-runtime digests, so initialization
+	/// cannot fail when they are missing.
+	PreRuntime(ConsensusEngineId, Vec<u8>),
+
+	/// A message from the runtime to the consensus engine. This should *never*
+	/// be generated by the native code of any consensus engine, but this is not
+	/// checked (yet).
+	Consensus(ConsensusEngineId, Vec<u8>),
+
+	/// Put a Seal on it. This is only used by native code, and is never seen
+	/// by runtimes.
+	Seal(ConsensusEngineId, Vec<u8>),
+
+	/// Some other thing. Unsupported and experimental.
+	Other(Vec<u8>),
+
+	/// An indication for the light clients that the runtime execution
+	/// environment is updated.
+	///
+	/// Currently this is triggered when:
+	/// 1. Runtime code blob is changed or
+	/// 2. `heap_pages` value is changed.
+	RuntimeEnvironmentUpdated,
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for DigestItem {
+	fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>
+	where
+		S: serde::Serializer,
+	{
+		self.using_encoded(|bytes| sp_core::bytes::serialize(bytes, seq))
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'a> serde::Deserialize<'a> for DigestItem {
+	fn deserialize<D>(de: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'a>,
+	{
+		let r = sp_core::bytes::deserialize(de)?;
+		Decode::decode(&mut &r[..])
+			.map_err(|e| serde::de::Error::custom(format!("Decode error: {}", e)))
+	}
+}
+
+impl TypeInfo for DigestItem {
+	type Identity = Self;
+
+	fn type_info() -> Type {
+		Type::builder().path(Path::new("DigestItem", module_path!())).variant(
+			Variants::new()
+				.variant("PreRuntime", |v| {
+					v.index(DigestItemType::PreRuntime as u8).fields(
+						Fields::unnamed()
+							.field(|f| f.ty::<ConsensusEngineId>().type_name("ConsensusEngineId"))
+							.field(|f| f.ty::<Vec<u8>>().type_name("Vec<u8>")),
+					)
+				})
+				.variant("Consensus", |v| {
+					v.index(DigestItemType::Consensus as u8).fields(
+						Fields::unnamed()
+							.field(|f| f.ty::<ConsensusEngineId>().type_name("ConsensusEngineId"))
+							.field(|f| f.ty::<Vec<u8>>().type_name("Vec<u8>")),
+					)
+				})
+				.variant("Seal", |v| {
+					v.index(DigestItemType::Seal as u8).fields(
+						Fields::unnamed()
+							.field(|f| f.ty::<ConsensusEngineId>().type_name("ConsensusEngineId"))
+							.field(|f| f.ty::<Vec<u8>>().type_name("Vec<u8>")),
+					)
+				})
+				.variant("Other", |v| {
+					v.index(DigestItemType::Other as u8)
+						.fields(Fields::unnamed().field(|f| f.ty::<Vec<u8>>().type_name("Vec<u8>")))
+				})
+				.variant("RuntimeEnvironmentUpdated", |v| {
+					v.index(DigestItemType::RuntimeEnvironmentUpdated as u8).fields(Fields::unit())
+				}),
+		)
+	}
+}
+
+/// A 'referencing view' for digest item. Does not own its contents. Used by
+/// final runtime implementations for encoding/decoding its log items.
+#[derive(PartialEq, Eq, Clone, RuntimeDebug)]
+pub enum DigestItemRef<'a> {
+	/// A pre-runtime digest.
+	///
+	/// These are messages from the consensus engine to the runtime, although
+	/// the consensus engine can (and should) read them itself to avoid
+	/// code and state duplication.  It is erroneous for a runtime to produce
+	/// these, but this is not (yet) checked.
+	PreRuntime(&'a ConsensusEngineId, &'a [u8]),
+	/// A message from the runtime to the consensus engine. This should *never*
+	/// be generated by the native code of any consensus engine, but this is not
+	/// checked (yet).
+	Consensus(&'a ConsensusEngineId, &'a [u8]),
+	/// Put a Seal on it. This is only used by native code, and is never seen
+	/// by runtimes.
+	Seal(&'a ConsensusEngineId, &'a [u8]),
+	/// Any 'non-system' digest item, opaque to the native code.
+	Other(&'a [u8]),
+	/// Runtime code or heap pages updated.
+	RuntimeEnvironmentUpdated,
+}
+
+/// Type of the digest item. Used to gain explicit control over `DigestItem` encoding
+/// process. We need an explicit control, because final runtimes are encoding their own
+/// digest items using `DigestItemRef` type and we can't auto-derive `Decode`
+/// trait for `DigestItemRef`.
+#[repr(u32)]
+#[derive(Encode, Decode)]
+pub enum DigestItemType {
+	Other = 0,
+	Consensus = 4,
+	Seal = 5,
+	PreRuntime = 6,
+	RuntimeEnvironmentUpdated = 8,
+}
+
+/// Type of a digest item that contains raw data; this also names the consensus engine ID where
+/// applicable. Used to identify one or more digest items of interest.
+#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+pub enum OpaqueDigestItemId<'a> {
+	/// Type corresponding to DigestItem::PreRuntime.
+	PreRuntime(&'a ConsensusEngineId),
+	/// Type corresponding to DigestItem::Consensus.
+	Consensus(&'a ConsensusEngineId),
+	/// Type corresponding to DigestItem::Seal.
+	Seal(&'a ConsensusEngineId),
+	/// Some other (non-prescribed) type.
+	Other,
+}
+
+impl DigestItem {
+	/// Returns a 'referencing view' for this digest item.
+	pub fn dref(&self) -> DigestItemRef {
+		match *self {
+			Self::PreRuntime(ref v, ref s) => DigestItemRef::PreRuntime(v, s),
+			Self::Consensus(ref v, ref s) => DigestItemRef::Consensus(v, s),
+			Self::Seal(ref v, ref s) => DigestItemRef::Seal(v, s),
+			Self::Other(ref v) => DigestItemRef::Other(v),
+			Self::RuntimeEnvironmentUpdated => DigestItemRef::RuntimeEnvironmentUpdated,
+		}
+	}
+
+	/// Returns `Some` if this entry is the `PreRuntime` entry.
+	pub fn as_pre_runtime(&self) -> Option<(ConsensusEngineId, &[u8])> {
+		self.dref().as_pre_runtime()
+	}
+
+	/// Returns `Some` if this entry is the `Consensus` entry.
+	pub fn as_consensus(&self) -> Option<(ConsensusEngineId, &[u8])> {
+		self.dref().as_consensus()
+	}
+
+	/// Returns `Some` if this entry is the `Seal` entry.
+	pub fn as_seal(&self) -> Option<(ConsensusEngineId, &[u8])> {
+		self.dref().as_seal()
+	}
+
+	/// Returns Some if `self` is a `DigestItem::Other`.
+	pub fn as_other(&self) -> Option<&[u8]> {
+		self.dref().as_other()
+	}
+
+	/// Returns the opaque data contained in the item if `Some` if this entry has the id given.
+	pub fn try_as_raw(&self, id: OpaqueDigestItemId) -> Option<&[u8]> {
+		self.dref().try_as_raw(id)
+	}
+
+	/// Returns the data contained in the item if `Some` if this entry has the id given, decoded
+	/// to the type provided `T`.
+	pub fn try_to<T: Decode>(&self, id: OpaqueDigestItemId) -> Option<T> {
+		self.dref().try_to::<T>(id)
+	}
+
+	/// Try to match this to a `Self::Seal`, check `id` matches and decode it.
+	///
+	/// Returns `None` if this isn't a seal item, the `id` doesn't match or when the decoding fails.
+	pub fn seal_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
+		self.dref().seal_try_to(id)
+	}
+
+	/// Try to match this to a `Self::Consensus`, check `id` matches and decode it.
+	///
+	/// Returns `None` if this isn't a consensus item, the `id` doesn't match or
+	/// when the decoding fails.
+	pub fn consensus_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
+		self.dref().consensus_try_to(id)
+	}
+
+	/// Try to match this to a `Self::PreRuntime`, check `id` matches and decode it.
+	///
+	/// Returns `None` if this isn't a pre-runtime item, the `id` doesn't match or
+	/// when the decoding fails.
+	pub fn pre_runtime_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
+		self.dref().pre_runtime_try_to(id)
+	}
+}
+
+impl Encode for DigestItem {
+	fn encode(&self) -> Vec<u8> {
+		self.dref().encode()
+	}
+}
+
+impl codec::EncodeLike for DigestItem {}
+
+impl Decode for DigestItem {
+	#[allow(deprecated)]
+	fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
+		let item_type: DigestItemType = Decode::decode(input)?;
+		match item_type {
+			DigestItemType::PreRuntime => {
+				let vals: (ConsensusEngineId, Vec<u8>) = Decode::decode(input)?;
+				Ok(Self::PreRuntime(vals.0, vals.1))
+			},
+			DigestItemType::Consensus => {
+				let vals: (ConsensusEngineId, Vec<u8>) = Decode::decode(input)?;
+				Ok(Self::Consensus(vals.0, vals.1))
+			},
+			DigestItemType::Seal => {
+				let vals: (ConsensusEngineId, Vec<u8>) = Decode::decode(input)?;
+				Ok(Self::Seal(vals.0, vals.1))
+			},
+			DigestItemType::Other => Ok(Self::Other(Decode::decode(input)?)),
+			DigestItemType::RuntimeEnvironmentUpdated => Ok(Self::RuntimeEnvironmentUpdated),
+		}
+	}
+}
+
+impl<'a> DigestItemRef<'a> {
+	/// Cast this digest item into `PreRuntime`
+	pub fn as_pre_runtime(&self) -> Option<(ConsensusEngineId, &'a [u8])> {
+		match *self {
+			Self::PreRuntime(consensus_engine_id, data) => Some((*consensus_engine_id, data)),
+			_ => None,
+		}
+	}
+
+	/// Cast this digest item into `Consensus`
+	pub fn as_consensus(&self) -> Option<(ConsensusEngineId, &'a [u8])> {
+		match *self {
+			Self::Consensus(consensus_engine_id, data) => Some((*consensus_engine_id, data)),
+			_ => None,
+		}
+	}
+
+	/// Cast this digest item into `Seal`
+	pub fn as_seal(&self) -> Option<(ConsensusEngineId, &'a [u8])> {
+		match *self {
+			Self::Seal(consensus_engine_id, data) => Some((*consensus_engine_id, data)),
+			_ => None,
+		}
+	}
+
+	/// Cast this digest item into `PreRuntime`
+	pub fn as_other(&self) -> Option<&'a [u8]> {
+		match *self {
+			Self::Other(data) => Some(data),
+			_ => None,
+		}
+	}
+
+	/// Try to match this digest item to the given opaque item identifier; if it matches, then
+	/// return the opaque data it contains.
+	pub fn try_as_raw(&self, id: OpaqueDigestItemId) -> Option<&'a [u8]> {
+		match (id, self) {
+			(OpaqueDigestItemId::Consensus(w), &Self::Consensus(v, s)) |
+			(OpaqueDigestItemId::Seal(w), &Self::Seal(v, s)) |
+			(OpaqueDigestItemId::PreRuntime(w), &Self::PreRuntime(v, s))
+				if v == w =>
+				Some(s),
+			(OpaqueDigestItemId::Other, &Self::Other(s)) => Some(s),
+			_ => None,
+		}
+	}
+
+	/// Try to match this digest item to the given opaque item identifier; if it matches, then
+	/// try to cast to the given data type; if that works, return it.
+	pub fn try_to<T: Decode>(&self, id: OpaqueDigestItemId) -> Option<T> {
+		self.try_as_raw(id).and_then(|mut x| Decode::decode(&mut x).ok())
+	}
+
+	/// Try to match this to a `Self::Seal`, check `id` matches and decode it.
+	///
+	/// Returns `None` if this isn't a seal item, the `id` doesn't match or when the decoding fails.
+	pub fn seal_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
+		match self {
+			Self::Seal(v, s) if *v == id => Decode::decode(&mut &s[..]).ok(),
+			_ => None,
+		}
+	}
+
+	/// Try to match this to a `Self::Consensus`, check `id` matches and decode it.
+	///
+	/// Returns `None` if this isn't a consensus item, the `id` doesn't match or
+	/// when the decoding fails.
+	pub fn consensus_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
+		match self {
+			Self::Consensus(v, s) if *v == id => Decode::decode(&mut &s[..]).ok(),
+			_ => None,
+		}
+	}
+
+	/// Try to match this to a `Self::PreRuntime`, check `id` matches and decode it.
+	///
+	/// Returns `None` if this isn't a pre-runtime item, the `id` doesn't match or
+	/// when the decoding fails.
+	pub fn pre_runtime_try_to<T: Decode>(&self, id: &ConsensusEngineId) -> Option<T> {
+		match self {
+			Self::PreRuntime(v, s) if *v == id => Decode::decode(&mut &s[..]).ok(),
+			_ => None,
+		}
+	}
+}
+
+impl<'a> Encode for DigestItemRef<'a> {
+	fn encode(&self) -> Vec<u8> {
+		let mut v = Vec::new();
+
+		match *self {
+			Self::Consensus(val, data) => {
+				DigestItemType::Consensus.encode_to(&mut v);
+				(val, data).encode_to(&mut v);
+			},
+			Self::Seal(val, sig) => {
+				DigestItemType::Seal.encode_to(&mut v);
+				(val, sig).encode_to(&mut v);
+			},
+			Self::PreRuntime(val, data) => {
+				DigestItemType::PreRuntime.encode_to(&mut v);
+				(val, data).encode_to(&mut v);
+			},
+			Self::Other(val) => {
+				DigestItemType::Other.encode_to(&mut v);
+				val.encode_to(&mut v);
+			},
+			Self::RuntimeEnvironmentUpdated => {
+				DigestItemType::RuntimeEnvironmentUpdated.encode_to(&mut v);
+			},
+		}
+
+		v
+	}
+}
+
+impl<'a> codec::EncodeLike for DigestItemRef<'a> {}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_serialize_digest() {
+		let digest = Digest {
+			logs: vec![DigestItem::Other(vec![1, 2, 3]), DigestItem::Seal(*b"test", vec![1, 2, 3])],
+		};
+
+		assert_eq!(
+			serde_json::to_string(&digest).unwrap(),
+			r#"{"logs":["0x000c010203","0x05746573740c010203"]}"#
+		);
+	}
+
+	#[test]
+	fn digest_item_type_info() {
+		let type_info = DigestItem::type_info();
+		let variants = if let scale_info::TypeDef::Variant(variant) = type_info.type_def {
+			variant.variants
+		} else {
+			panic!("Should be a TypeDef::TypeDefVariant")
+		};
+
+		// ensure that all variants are covered by manual TypeInfo impl
+		let check = |digest_item_type: DigestItemType| {
+			let (variant_name, digest_item) = match digest_item_type {
+				DigestItemType::Other => ("Other", DigestItem::Other(Default::default())),
+				DigestItemType::Consensus =>
+					("Consensus", DigestItem::Consensus(Default::default(), Default::default())),
+				DigestItemType::Seal =>
+					("Seal", DigestItem::Seal(Default::default(), Default::default())),
+				DigestItemType::PreRuntime =>
+					("PreRuntime", DigestItem::PreRuntime(Default::default(), Default::default())),
+				DigestItemType::RuntimeEnvironmentUpdated =>
+					("RuntimeEnvironmentUpdated", DigestItem::RuntimeEnvironmentUpdated),
+			};
+			let encoded = digest_item.encode();
+			let variant = variants
+				.iter()
+				.find(|v| v.name == variant_name)
+				.expect(&format!("Variant {} not found", variant_name));
+
+			assert_eq!(encoded[0], variant.index)
+		};
+
+		check(DigestItemType::Other);
+		check(DigestItemType::Consensus);
+		check(DigestItemType::Seal);
+		check(DigestItemType::PreRuntime);
+		check(DigestItemType::RuntimeEnvironmentUpdated);
+	}
+}
diff --git a/substrate/primitives/runtime/src/generic/era.rs b/substrate/primitives/runtime/src/generic/era.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bdc7e9930fb1d3a38a689337b819faa2d63d8b63
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/era.rs
@@ -0,0 +1,252 @@
+// 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.
+
+//! Generic implementation of an unchecked (pre-verification) extrinsic.
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use crate::codec::{Decode, Encode, Error, Input, Output};
+
+/// Era period
+pub type Period = u64;
+
+/// Era phase
+pub type Phase = u64;
+
+/// An era to describe the longevity of a transaction.
+#[derive(PartialEq, Eq, Clone, Copy, sp_core::RuntimeDebug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Era {
+	/// The transaction is valid forever. The genesis hash must be present in the signed content.
+	Immortal,
+
+	/// Period and phase are encoded:
+	/// - The period of validity from the block hash found in the signing material.
+	/// - The phase in the period that this transaction's lifetime begins (and, importantly,
+	/// implies which block hash is included in the signature material). If the `period` is
+	/// greater than 1 << 12, then it will be a factor of the times greater than 1<<12 that
+	/// `period` is.
+	///
+	/// When used on `FRAME`-based runtimes, `period` cannot exceed `BlockHashCount` parameter
+	/// of `system` module.
+	Mortal(Period, Phase),
+}
+
+// E.g. with period == 4:
+// 0         10        20        30        40
+// 0123456789012345678901234567890123456789012
+//              |...|
+//    authored -/   \- expiry
+// phase = 1
+// n = Q(current - phase, period) + phase
+impl Era {
+	/// Create a new era based on a period (which should be a power of two between 4 and 65536
+	/// inclusive) and a block number on which it should start (or, for long periods, be shortly
+	/// after the start).
+	///
+	/// If using `Era` in the context of `FRAME` runtime, make sure that `period`
+	/// does not exceed `BlockHashCount` parameter passed to `system` module, since that
+	/// prunes old blocks and renders transactions immediately invalid.
+	pub fn mortal(period: u64, current: u64) -> Self {
+		let period = period.checked_next_power_of_two().unwrap_or(1 << 16).clamp(4, 1 << 16);
+		let phase = current % period;
+		let quantize_factor = (period >> 12).max(1);
+		let quantized_phase = phase / quantize_factor * quantize_factor;
+
+		Self::Mortal(period, quantized_phase)
+	}
+
+	/// Create an "immortal" transaction.
+	pub fn immortal() -> Self {
+		Self::Immortal
+	}
+
+	/// `true` if this is an immortal transaction.
+	pub fn is_immortal(&self) -> bool {
+		matches!(self, Self::Immortal)
+	}
+
+	/// Get the block number of the start of the era whose properties this object
+	/// describes that `current` belongs to.
+	pub fn birth(self, current: u64) -> u64 {
+		match self {
+			Self::Immortal => 0,
+			Self::Mortal(period, phase) => (current.max(phase) - phase) / period * period + phase,
+		}
+	}
+
+	/// Get the block number of the first block at which the era has ended.
+	pub fn death(self, current: u64) -> u64 {
+		match self {
+			Self::Immortal => u64::MAX,
+			Self::Mortal(period, _) => self.birth(current) + period,
+		}
+	}
+}
+
+impl Encode for Era {
+	fn encode_to<T: Output + ?Sized>(&self, output: &mut T) {
+		match self {
+			Self::Immortal => output.push_byte(0),
+			Self::Mortal(period, phase) => {
+				let quantize_factor = (*period as u64 >> 12).max(1);
+				let encoded = (period.trailing_zeros() - 1).clamp(1, 15) as u16 |
+					((phase / quantize_factor) << 4) as u16;
+				encoded.encode_to(output);
+			},
+		}
+	}
+}
+
+impl codec::EncodeLike for Era {}
+
+impl Decode for Era {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
+		let first = input.read_byte()?;
+		if first == 0 {
+			Ok(Self::Immortal)
+		} else {
+			let encoded = first as u64 + ((input.read_byte()? as u64) << 8);
+			let period = 2 << (encoded % (1 << 4));
+			let quantize_factor = (period >> 12).max(1);
+			let phase = (encoded >> 4) * quantize_factor;
+			if period >= 4 && phase < period {
+				Ok(Self::Mortal(period, phase))
+			} else {
+				Err("Invalid period and phase".into())
+			}
+		}
+	}
+}
+
+/// Add Mortal{N}(u8) variants with the given indices, to describe custom encoding.
+macro_rules! mortal_variants {
+    ($variants:ident, $($index:literal),* ) => {
+		$variants
+		$(
+			.variant(concat!(stringify!(Mortal), stringify!($index)), |v| v
+				.index($index)
+				.fields(scale_info::build::Fields::unnamed().field(|f| f.ty::<u8>()))
+			)
+		)*
+    }
+}
+
+impl scale_info::TypeInfo for Era {
+	type Identity = Self;
+
+	fn type_info() -> scale_info::Type {
+		let variants = scale_info::build::Variants::new().variant("Immortal", |v| v.index(0));
+
+		// this is necessary since the size of the encoded Mortal variant is `u16`, conditional on
+		// the value of the first byte being > 0.
+		let variants = mortal_variants!(
+			variants, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+			22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
+			44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
+			66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87,
+			88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
+			108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
+			125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
+			142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158,
+			159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+			176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
+			193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
+			210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226,
+			227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
+			244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
+		);
+
+		scale_info::Type::builder()
+			.path(scale_info::Path::new("Era", module_path!()))
+			.variant(variants)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn immortal_works() {
+		let e = Era::immortal();
+		assert_eq!(e.birth(0), 0);
+		assert_eq!(e.death(0), u64::MAX);
+		assert_eq!(e.birth(1), 0);
+		assert_eq!(e.death(1), u64::MAX);
+		assert_eq!(e.birth(u64::MAX), 0);
+		assert_eq!(e.death(u64::MAX), u64::MAX);
+		assert!(e.is_immortal());
+
+		assert_eq!(e.encode(), vec![0u8]);
+		assert_eq!(e, Era::decode(&mut &[0u8][..]).unwrap());
+	}
+
+	#[test]
+	fn mortal_codec_works() {
+		let e = Era::mortal(64, 42);
+		assert!(!e.is_immortal());
+
+		let expected = vec![5 + 42 % 16 * 16, 42 / 16];
+		assert_eq!(e.encode(), expected);
+		assert_eq!(e, Era::decode(&mut &expected[..]).unwrap());
+	}
+
+	#[test]
+	fn long_period_mortal_codec_works() {
+		let e = Era::mortal(32768, 20000);
+
+		let expected = vec![(14 + 2500 % 16 * 16) as u8, (2500 / 16) as u8];
+		assert_eq!(e.encode(), expected);
+		assert_eq!(e, Era::decode(&mut &expected[..]).unwrap());
+	}
+
+	#[test]
+	fn era_initialization_works() {
+		assert_eq!(Era::mortal(64, 42), Era::Mortal(64, 42));
+		assert_eq!(Era::mortal(32768, 20000), Era::Mortal(32768, 20000));
+		assert_eq!(Era::mortal(200, 513), Era::Mortal(256, 1));
+		assert_eq!(Era::mortal(2, 1), Era::Mortal(4, 1));
+		assert_eq!(Era::mortal(4, 5), Era::Mortal(4, 1));
+	}
+
+	#[test]
+	fn quantized_clamped_era_initialization_works() {
+		// clamp 1000000 to 65536, quantize 1000001 % 65536 to the nearest 4
+		assert_eq!(Era::mortal(1000000, 1000001), Era::Mortal(65536, 1000001 % 65536 / 4 * 4));
+	}
+
+	#[test]
+	fn mortal_birth_death_works() {
+		let e = Era::mortal(4, 6);
+		for i in 6..10 {
+			assert_eq!(e.birth(i), 6);
+			assert_eq!(e.death(i), 10);
+		}
+
+		// wrong because it's outside of the (current...current + period) range
+		assert_ne!(e.birth(10), 6);
+		assert_ne!(e.birth(5), 6);
+	}
+
+	#[test]
+	fn current_less_than_phase() {
+		// should not panic
+		Era::mortal(4, 3).birth(1);
+	}
+}
diff --git a/substrate/primitives/runtime/src/generic/header.rs b/substrate/primitives/runtime/src/generic/header.rs
new file mode 100644
index 0000000000000000000000000000000000000000..82ab9a61f96d8f26579bf704947b74a206b7ec99
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/header.rs
@@ -0,0 +1,255 @@
+// 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.
+
+//! Generic implementation of a block header.
+
+use crate::{
+	codec::{Codec, Decode, Encode},
+	generic::Digest,
+	scale_info::TypeInfo,
+	traits::{
+		self, AtLeast32BitUnsigned, Hash as HashT, MaybeDisplay, MaybeFromStr,
+		MaybeSerializeDeserialize, Member,
+	},
+};
+use codec::{FullCodec, MaxEncodedLen};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use sp_core::U256;
+use sp_std::fmt::Debug;
+
+/// Abstraction over a block header for a substrate chain.
+#[derive(Encode, Decode, PartialEq, Eq, Clone, sp_core::RuntimeDebug, TypeInfo)]
+#[scale_info(skip_type_params(Hash))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
+#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
+pub struct Header<Number: Copy + Into<U256> + TryFrom<U256>, Hash: HashT> {
+	/// The parent hash.
+	pub parent_hash: Hash::Output,
+	/// The block number.
+	#[cfg_attr(
+		feature = "serde",
+		serde(serialize_with = "serialize_number", deserialize_with = "deserialize_number")
+	)]
+	#[codec(compact)]
+	pub number: Number,
+	/// The state trie merkle root
+	pub state_root: Hash::Output,
+	/// The merkle root of the extrinsics.
+	pub extrinsics_root: Hash::Output,
+	/// A chain-specific digest of data useful for light clients or referencing auxiliary data.
+	pub digest: Digest,
+}
+
+#[cfg(feature = "serde")]
+pub fn serialize_number<S, T: Copy + Into<U256> + TryFrom<U256>>(
+	val: &T,
+	s: S,
+) -> Result<S::Ok, S::Error>
+where
+	S: serde::Serializer,
+{
+	let u256: U256 = (*val).into();
+	serde::Serialize::serialize(&u256, s)
+}
+
+#[cfg(feature = "serde")]
+pub fn deserialize_number<'a, D, T: Copy + Into<U256> + TryFrom<U256>>(d: D) -> Result<T, D::Error>
+where
+	D: serde::Deserializer<'a>,
+{
+	let u256: U256 = serde::Deserialize::deserialize(d)?;
+	TryFrom::try_from(u256).map_err(|_| serde::de::Error::custom("Try from failed"))
+}
+
+impl<Number, Hash> traits::Header for Header<Number, Hash>
+where
+	Number: Member
+		+ MaybeSerializeDeserialize
+		+ MaybeFromStr
+		+ Debug
+		+ Default
+		+ sp_std::hash::Hash
+		+ MaybeDisplay
+		+ AtLeast32BitUnsigned
+		+ FullCodec
+		+ Copy
+		+ MaxEncodedLen
+		+ Into<U256>
+		+ TryFrom<U256>
+		+ TypeInfo,
+	Hash: HashT,
+{
+	type Number = Number;
+	type Hash = <Hash as HashT>::Output;
+	type Hashing = Hash;
+
+	fn new(
+		number: Self::Number,
+		extrinsics_root: Self::Hash,
+		state_root: Self::Hash,
+		parent_hash: Self::Hash,
+		digest: Digest,
+	) -> Self {
+		Self { number, extrinsics_root, state_root, parent_hash, digest }
+	}
+	fn number(&self) -> &Self::Number {
+		&self.number
+	}
+
+	fn set_number(&mut self, num: Self::Number) {
+		self.number = num
+	}
+	fn extrinsics_root(&self) -> &Self::Hash {
+		&self.extrinsics_root
+	}
+
+	fn set_extrinsics_root(&mut self, root: Self::Hash) {
+		self.extrinsics_root = root
+	}
+	fn state_root(&self) -> &Self::Hash {
+		&self.state_root
+	}
+
+	fn set_state_root(&mut self, root: Self::Hash) {
+		self.state_root = root
+	}
+	fn parent_hash(&self) -> &Self::Hash {
+		&self.parent_hash
+	}
+
+	fn set_parent_hash(&mut self, hash: Self::Hash) {
+		self.parent_hash = hash
+	}
+
+	fn digest(&self) -> &Digest {
+		&self.digest
+	}
+
+	fn digest_mut(&mut self) -> &mut Digest {
+		#[cfg(feature = "std")]
+		log::debug!(target: "header", "Retrieving mutable reference to digest");
+		&mut self.digest
+	}
+}
+
+impl<Number, Hash> Header<Number, Hash>
+where
+	Number: Member
+		+ sp_std::hash::Hash
+		+ Copy
+		+ MaybeDisplay
+		+ AtLeast32BitUnsigned
+		+ Codec
+		+ Into<U256>
+		+ TryFrom<U256>,
+	Hash: HashT,
+{
+	/// Convenience helper for computing the hash of the header without having
+	/// to import the trait.
+	pub fn hash(&self) -> Hash::Output {
+		Hash::hash_of(self)
+	}
+}
+
+#[cfg(all(test, feature = "std"))]
+mod tests {
+	use super::*;
+	use crate::traits::BlakeTwo256;
+
+	#[test]
+	fn should_serialize_numbers() {
+		fn serialize(num: u128) -> String {
+			let mut v = vec![];
+			{
+				let mut ser = serde_json::Serializer::new(std::io::Cursor::new(&mut v));
+				serialize_number(&num, &mut ser).unwrap();
+			}
+			String::from_utf8(v).unwrap()
+		}
+
+		assert_eq!(serialize(0), "\"0x0\"".to_owned());
+		assert_eq!(serialize(1), "\"0x1\"".to_owned());
+		assert_eq!(serialize(u64::MAX as u128), "\"0xffffffffffffffff\"".to_owned());
+		assert_eq!(serialize(u64::MAX as u128 + 1), "\"0x10000000000000000\"".to_owned());
+	}
+
+	#[test]
+	fn should_deserialize_number() {
+		fn deserialize(num: &str) -> u128 {
+			let mut der = serde_json::Deserializer::new(serde_json::de::StrRead::new(num));
+			deserialize_number(&mut der).unwrap()
+		}
+
+		assert_eq!(deserialize("\"0x0\""), 0);
+		assert_eq!(deserialize("\"0x1\""), 1);
+		assert_eq!(deserialize("\"0xffffffffffffffff\""), u64::MAX as u128);
+		assert_eq!(deserialize("\"0x10000000000000000\""), u64::MAX as u128 + 1);
+	}
+
+	#[test]
+	fn ensure_format_is_unchanged() {
+		let header = Header::<u32, BlakeTwo256> {
+			parent_hash: BlakeTwo256::hash(b"1"),
+			number: 2,
+			state_root: BlakeTwo256::hash(b"3"),
+			extrinsics_root: BlakeTwo256::hash(b"4"),
+			digest: crate::generic::Digest {
+				logs: vec![crate::generic::DigestItem::Other(b"6".to_vec())],
+			},
+		};
+
+		let header_encoded = header.encode();
+		assert_eq!(
+			header_encoded,
+			vec![
+				146, 205, 245, 120, 196, 112, 133, 165, 153, 34, 86, 240, 220, 249, 125, 11, 25,
+				241, 241, 201, 222, 77, 95, 227, 12, 58, 206, 97, 145, 182, 229, 219, 8, 88, 19,
+				72, 51, 123, 15, 62, 20, 134, 32, 23, 61, 170, 165, 249, 77, 0, 216, 129, 112, 93,
+				203, 240, 170, 131, 239, 218, 186, 97, 210, 237, 225, 235, 134, 73, 33, 73, 151,
+				87, 78, 32, 196, 100, 56, 138, 23, 36, 32, 210, 84, 3, 104, 43, 187, 184, 12, 73,
+				104, 49, 200, 204, 31, 143, 13, 4, 0, 4, 54
+			],
+		);
+		assert_eq!(header, Header::<u32, BlakeTwo256>::decode(&mut &header_encoded[..]).unwrap());
+
+		let header = Header::<u32, BlakeTwo256> {
+			parent_hash: BlakeTwo256::hash(b"1000"),
+			number: 2000,
+			state_root: BlakeTwo256::hash(b"3000"),
+			extrinsics_root: BlakeTwo256::hash(b"4000"),
+			digest: crate::generic::Digest {
+				logs: vec![crate::generic::DigestItem::Other(b"5000".to_vec())],
+			},
+		};
+
+		let header_encoded = header.encode();
+		assert_eq!(
+			header_encoded,
+			vec![
+				197, 243, 254, 225, 31, 117, 21, 218, 179, 213, 92, 6, 247, 164, 230, 25, 47, 166,
+				140, 117, 142, 159, 195, 202, 67, 196, 238, 26, 44, 18, 33, 92, 65, 31, 219, 225,
+				47, 12, 107, 88, 153, 146, 55, 21, 226, 186, 110, 48, 167, 187, 67, 183, 228, 232,
+				118, 136, 30, 254, 11, 87, 48, 112, 7, 97, 31, 82, 146, 110, 96, 87, 152, 68, 98,
+				162, 227, 222, 78, 14, 244, 194, 120, 154, 112, 97, 222, 144, 174, 101, 220, 44,
+				111, 126, 54, 34, 155, 220, 253, 124, 4, 0, 16, 53, 48, 48, 48
+			],
+		);
+		assert_eq!(header, Header::<u32, BlakeTwo256>::decode(&mut &header_encoded[..]).unwrap());
+	}
+}
diff --git a/substrate/primitives/runtime/src/generic/mod.rs b/substrate/primitives/runtime/src/generic/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3687f7cdb3b2b24c087ac47c470b4d39721e2df5
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/mod.rs
@@ -0,0 +1,37 @@
+// 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.
+
+//! Generic implementations of [`crate::traits::Header`], [`crate::traits::Block`] and
+//! [`crate::traits::Extrinsic`].
+
+mod block;
+mod checked_extrinsic;
+mod digest;
+mod era;
+mod header;
+#[cfg(test)]
+mod tests;
+mod unchecked_extrinsic;
+
+pub use self::{
+	block::{Block, BlockId, SignedBlock},
+	checked_extrinsic::CheckedExtrinsic,
+	digest::{Digest, DigestItem, DigestItemRef, OpaqueDigestItemId},
+	era::{Era, Phase},
+	header::Header,
+	unchecked_extrinsic::{SignedPayload, UncheckedExtrinsic},
+};
diff --git a/substrate/primitives/runtime/src/generic/tests.rs b/substrate/primitives/runtime/src/generic/tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b63efeb52212438e3b1c06c4cdb49a56d3f16a2c
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/tests.rs
@@ -0,0 +1,55 @@
+// 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 the generic implementations of Extrinsic/Header/Block.
+
+use super::DigestItem;
+use crate::codec::{Decode, Encode};
+
+#[test]
+fn system_digest_item_encoding() {
+	let item = DigestItem::Consensus([1, 2, 3, 4], vec![5, 6, 7, 8]);
+	let encoded = item.encode();
+	assert_eq!(
+		encoded,
+		vec![
+			4, // type = DigestItemType::Consensus
+			1, 2, 3, 4, 16, 5, 6, 7, 8,
+		]
+	);
+
+	let decoded: DigestItem = Decode::decode(&mut &encoded[..]).unwrap();
+	assert_eq!(item, decoded);
+}
+
+#[test]
+fn non_system_digest_item_encoding() {
+	let item = DigestItem::Other(vec![10, 20, 30]);
+	let encoded = item.encode();
+	assert_eq!(
+		encoded,
+		vec![
+			// type = DigestItemType::Other
+			0,  // length of other data
+			12, // authorities
+			10, 20, 30,
+		]
+	);
+
+	let decoded: DigestItem = Decode::decode(&mut &encoded[..]).unwrap();
+	assert_eq!(item, decoded);
+}
diff --git a/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs b/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0b1cd2b54290e0a829b09029b630a30c7410cb31
--- /dev/null
+++ b/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs
@@ -0,0 +1,545 @@
+// 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.
+
+//! Generic implementation of an unchecked (pre-verification) extrinsic.
+
+use crate::{
+	generic::CheckedExtrinsic,
+	traits::{
+		self, Checkable, Extrinsic, ExtrinsicMetadata, IdentifyAccount, MaybeDisplay, Member,
+		SignaturePayload, SignedExtension,
+	},
+	transaction_validity::{InvalidTransaction, TransactionValidityError},
+	OpaqueExtrinsic,
+};
+use codec::{Compact, Decode, Encode, EncodeLike, Error, Input};
+use scale_info::{build::Fields, meta_type, Path, StaticTypeInfo, Type, TypeInfo, TypeParameter};
+use sp_io::hashing::blake2_256;
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::alloc::format;
+use sp_std::{fmt, prelude::*};
+
+/// Current version of the [`UncheckedExtrinsic`] encoded format.
+///
+/// This version needs to be bumped if the encoded representation changes.
+/// It ensures that if the representation is changed and the format is not known,
+/// the decoding fails.
+const EXTRINSIC_FORMAT_VERSION: u8 = 4;
+
+/// The `SingaturePayload` of `UncheckedExtrinsic`.
+type UncheckedSignaturePayload<Address, Signature, Extra> = (Address, Signature, Extra);
+
+/// A extrinsic right from the external world. This is unchecked and so
+/// can contain a signature.
+#[derive(PartialEq, Eq, Clone)]
+pub struct UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Extra: SignedExtension,
+{
+	/// The signature, address, number of extrinsics have come before from
+	/// the same signer and an era describing the longevity of this transaction,
+	/// if this is a signed extrinsic.
+	pub signature: Option<UncheckedSignaturePayload<Address, Signature, Extra>>,
+	/// The function that should be called.
+	pub function: Call,
+}
+
+impl<Address: TypeInfo, Signature: TypeInfo, Extra: TypeInfo> SignaturePayload
+	for UncheckedSignaturePayload<Address, Signature, Extra>
+{
+	type SignatureAddress = Address;
+	type Signature = Signature;
+	type SignatureExtra = Extra;
+}
+
+/// Manual [`TypeInfo`] implementation because of custom encoding. The data is a valid encoded
+/// `Vec<u8>`, but requires some logic to extract the signature and payload.
+///
+/// See [`UncheckedExtrinsic::encode`] and [`UncheckedExtrinsic::decode`].
+impl<Address, Call, Signature, Extra> TypeInfo
+	for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Address: StaticTypeInfo,
+	Call: StaticTypeInfo,
+	Signature: StaticTypeInfo,
+	Extra: SignedExtension + StaticTypeInfo,
+{
+	type Identity = UncheckedExtrinsic<Address, Call, Signature, Extra>;
+
+	fn type_info() -> Type {
+		Type::builder()
+			.path(Path::new("UncheckedExtrinsic", module_path!()))
+			// Include the type parameter types, even though they are not used directly in any of
+			// the described fields. These type definitions can be used by downstream consumers
+			// to help construct the custom decoding from the opaque bytes (see below).
+			.type_params(vec![
+				TypeParameter::new("Address", Some(meta_type::<Address>())),
+				TypeParameter::new("Call", Some(meta_type::<Call>())),
+				TypeParameter::new("Signature", Some(meta_type::<Signature>())),
+				TypeParameter::new("Extra", Some(meta_type::<Extra>())),
+			])
+			.docs(&["UncheckedExtrinsic raw bytes, requires custom decoding routine"])
+			// Because of the custom encoding, we can only accurately describe the encoding as an
+			// opaque `Vec<u8>`. Downstream consumers will need to manually implement the codec to
+			// encode/decode the `signature` and `function` fields.
+			.composite(Fields::unnamed().field(|f| f.ty::<Vec<u8>>()))
+	}
+}
+
+impl<Address, Call, Signature, Extra: SignedExtension>
+	UncheckedExtrinsic<Address, Call, Signature, Extra>
+{
+	/// New instance of a signed extrinsic aka "transaction".
+	pub fn new_signed(function: Call, signed: Address, signature: Signature, extra: Extra) -> Self {
+		Self { signature: Some((signed, signature, extra)), function }
+	}
+
+	/// New instance of an unsigned extrinsic aka "inherent".
+	pub fn new_unsigned(function: Call) -> Self {
+		Self { signature: None, function }
+	}
+}
+
+impl<Address: TypeInfo, Call: TypeInfo, Signature: TypeInfo, Extra: SignedExtension + TypeInfo>
+	Extrinsic for UncheckedExtrinsic<Address, Call, Signature, Extra>
+{
+	type Call = Call;
+
+	type SignaturePayload = UncheckedSignaturePayload<Address, Signature, Extra>;
+
+	fn is_signed(&self) -> Option<bool> {
+		Some(self.signature.is_some())
+	}
+
+	fn new(function: Call, signed_data: Option<Self::SignaturePayload>) -> Option<Self> {
+		Some(if let Some((address, signature, extra)) = signed_data {
+			Self::new_signed(function, address, signature, extra)
+		} else {
+			Self::new_unsigned(function)
+		})
+	}
+}
+
+impl<Address, AccountId, Call, Signature, Extra, Lookup> Checkable<Lookup>
+	for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Address: Member + MaybeDisplay,
+	Call: Encode + Member,
+	Signature: Member + traits::Verify,
+	<Signature as traits::Verify>::Signer: IdentifyAccount<AccountId = AccountId>,
+	Extra: SignedExtension<AccountId = AccountId>,
+	AccountId: Member + MaybeDisplay,
+	Lookup: traits::Lookup<Source = Address, Target = AccountId>,
+{
+	type Checked = CheckedExtrinsic<AccountId, Call, Extra>;
+
+	fn check(self, lookup: &Lookup) -> Result<Self::Checked, TransactionValidityError> {
+		Ok(match self.signature {
+			Some((signed, signature, extra)) => {
+				let signed = lookup.lookup(signed)?;
+				let raw_payload = SignedPayload::new(self.function, extra)?;
+				if !raw_payload.using_encoded(|payload| signature.verify(payload, &signed)) {
+					return Err(InvalidTransaction::BadProof.into())
+				}
+
+				let (function, extra, _) = raw_payload.deconstruct();
+				CheckedExtrinsic { signed: Some((signed, extra)), function }
+			},
+			None => CheckedExtrinsic { signed: None, function: self.function },
+		})
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn unchecked_into_checked_i_know_what_i_am_doing(
+		self,
+		lookup: &Lookup,
+	) -> Result<Self::Checked, TransactionValidityError> {
+		Ok(match self.signature {
+			Some((signed, _, extra)) => {
+				let signed = lookup.lookup(signed)?;
+				let raw_payload = SignedPayload::new(self.function, extra)?;
+				let (function, extra, _) = raw_payload.deconstruct();
+				CheckedExtrinsic { signed: Some((signed, extra)), function }
+			},
+			None => CheckedExtrinsic { signed: None, function: self.function },
+		})
+	}
+}
+
+impl<Address, Call, Signature, Extra> ExtrinsicMetadata
+	for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Extra: SignedExtension,
+{
+	const VERSION: u8 = EXTRINSIC_FORMAT_VERSION;
+	type SignedExtensions = Extra;
+}
+
+/// A payload that has been signed for an unchecked extrinsics.
+///
+/// Note that the payload that we sign to produce unchecked extrinsic signature
+/// is going to be different than the `SignaturePayload` - so the thing the extrinsic
+/// actually contains.
+pub struct SignedPayload<Call, Extra: SignedExtension>((Call, Extra, Extra::AdditionalSigned));
+
+impl<Call, Extra> SignedPayload<Call, Extra>
+where
+	Call: Encode,
+	Extra: SignedExtension,
+{
+	/// Create new `SignedPayload`.
+	///
+	/// This function may fail if `additional_signed` of `Extra` is not available.
+	pub fn new(call: Call, extra: Extra) -> Result<Self, TransactionValidityError> {
+		let additional_signed = extra.additional_signed()?;
+		let raw_payload = (call, extra, additional_signed);
+		Ok(Self(raw_payload))
+	}
+
+	/// Create new `SignedPayload` from raw components.
+	pub fn from_raw(call: Call, extra: Extra, additional_signed: Extra::AdditionalSigned) -> Self {
+		Self((call, extra, additional_signed))
+	}
+
+	/// Deconstruct the payload into it's components.
+	pub fn deconstruct(self) -> (Call, Extra, Extra::AdditionalSigned) {
+		self.0
+	}
+}
+
+impl<Call, Extra> Encode for SignedPayload<Call, Extra>
+where
+	Call: Encode,
+	Extra: SignedExtension,
+{
+	/// Get an encoded version of this payload.
+	///
+	/// Payloads longer than 256 bytes are going to be `blake2_256`-hashed.
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		self.0.using_encoded(|payload| {
+			if payload.len() > 256 {
+				f(&blake2_256(payload)[..])
+			} else {
+				f(payload)
+			}
+		})
+	}
+}
+
+impl<Call, Extra> EncodeLike for SignedPayload<Call, Extra>
+where
+	Call: Encode,
+	Extra: SignedExtension,
+{
+}
+
+impl<Address, Call, Signature, Extra> Decode for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Address: Decode,
+	Signature: Decode,
+	Call: Decode,
+	Extra: SignedExtension,
+{
+	fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
+		// This is a little more complicated than usual since the binary format must be compatible
+		// with SCALE's generic `Vec<u8>` type. Basically this just means accepting that there
+		// will be a prefix of vector length.
+		let expected_length: Compact<u32> = Decode::decode(input)?;
+		let before_length = input.remaining_len()?;
+
+		let version = input.read_byte()?;
+
+		let is_signed = version & 0b1000_0000 != 0;
+		let version = version & 0b0111_1111;
+		if version != EXTRINSIC_FORMAT_VERSION {
+			return Err("Invalid transaction version".into())
+		}
+
+		let signature = is_signed.then(|| Decode::decode(input)).transpose()?;
+		let function = Decode::decode(input)?;
+
+		if let Some((before_length, after_length)) =
+			input.remaining_len()?.and_then(|a| before_length.map(|b| (b, a)))
+		{
+			let length = before_length.saturating_sub(after_length);
+
+			if length != expected_length.0 as usize {
+				return Err("Invalid length prefix".into())
+			}
+		}
+
+		Ok(Self { signature, function })
+	}
+}
+
+impl<Address, Call, Signature, Extra> Encode for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Address: Encode,
+	Signature: Encode,
+	Call: Encode,
+	Extra: SignedExtension,
+{
+	fn encode(&self) -> Vec<u8> {
+		let mut tmp = Vec::with_capacity(sp_std::mem::size_of::<Self>());
+
+		// 1 byte version id.
+		match self.signature.as_ref() {
+			Some(s) => {
+				tmp.push(EXTRINSIC_FORMAT_VERSION | 0b1000_0000);
+				s.encode_to(&mut tmp);
+			},
+			None => {
+				tmp.push(EXTRINSIC_FORMAT_VERSION & 0b0111_1111);
+			},
+		}
+		self.function.encode_to(&mut tmp);
+
+		let compact_len = codec::Compact::<u32>(tmp.len() as u32);
+
+		// Allocate the output buffer with the correct length
+		let mut output = Vec::with_capacity(compact_len.size_hint() + tmp.len());
+
+		compact_len.encode_to(&mut output);
+		output.extend(tmp);
+
+		output
+	}
+}
+
+impl<Address, Call, Signature, Extra> EncodeLike
+	for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Address: Encode,
+	Signature: Encode,
+	Call: Encode,
+	Extra: SignedExtension,
+{
+}
+
+#[cfg(feature = "serde")]
+impl<Address: Encode, Signature: Encode, Call: Encode, Extra: SignedExtension> serde::Serialize
+	for UncheckedExtrinsic<Address, Call, Signature, Extra>
+{
+	fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>
+	where
+		S: ::serde::Serializer,
+	{
+		self.using_encoded(|bytes| seq.serialize_bytes(bytes))
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'a, Address: Decode, Signature: Decode, Call: Decode, Extra: SignedExtension>
+	serde::Deserialize<'a> for UncheckedExtrinsic<Address, Call, Signature, Extra>
+{
+	fn deserialize<D>(de: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'a>,
+	{
+		let r = sp_core::bytes::deserialize(de)?;
+		Decode::decode(&mut &r[..])
+			.map_err(|e| serde::de::Error::custom(format!("Decode error: {}", e)))
+	}
+}
+
+impl<Address, Call, Signature, Extra> fmt::Debug
+	for UncheckedExtrinsic<Address, Call, Signature, Extra>
+where
+	Address: fmt::Debug,
+	Call: fmt::Debug,
+	Extra: SignedExtension,
+{
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(
+			f,
+			"UncheckedExtrinsic({:?}, {:?})",
+			self.signature.as_ref().map(|x| (&x.0, &x.2)),
+			self.function,
+		)
+	}
+}
+
+impl<Address, Call, Signature, Extra> From<UncheckedExtrinsic<Address, Call, Signature, Extra>>
+	for OpaqueExtrinsic
+where
+	Address: Encode,
+	Signature: Encode,
+	Call: Encode,
+	Extra: SignedExtension,
+{
+	fn from(extrinsic: UncheckedExtrinsic<Address, Call, Signature, Extra>) -> Self {
+		Self::from_bytes(extrinsic.encode().as_slice()).expect(
+			"both OpaqueExtrinsic and UncheckedExtrinsic have encoding that is compatible with \
+				raw Vec<u8> encoding; qed",
+		)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{
+		codec::{Decode, Encode},
+		testing::TestSignature as TestSig,
+		traits::{DispatchInfoOf, IdentityLookup, SignedExtension},
+	};
+	use sp_io::hashing::blake2_256;
+
+	type TestContext = IdentityLookup<u64>;
+	type TestAccountId = u64;
+	type TestCall = Vec<u8>;
+
+	const TEST_ACCOUNT: TestAccountId = 0;
+
+	// NOTE: this is demonstration. One can simply use `()` for testing.
+	#[derive(Debug, Encode, Decode, Clone, Eq, PartialEq, Ord, PartialOrd, TypeInfo)]
+	struct TestExtra;
+	impl SignedExtension for TestExtra {
+		const IDENTIFIER: &'static str = "TestExtra";
+		type AccountId = u64;
+		type Call = ();
+		type AdditionalSigned = ();
+		type Pre = ();
+
+		fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+			Ok(())
+		}
+
+		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(|_| ())
+		}
+	}
+
+	type Ex = UncheckedExtrinsic<TestAccountId, TestCall, TestSig, TestExtra>;
+	type CEx = CheckedExtrinsic<TestAccountId, TestCall, TestExtra>;
+
+	#[test]
+	fn unsigned_codec_should_work() {
+		let ux = Ex::new_unsigned(vec![0u8; 0]);
+		let encoded = ux.encode();
+		assert_eq!(Ex::decode(&mut &encoded[..]), Ok(ux));
+	}
+
+	#[test]
+	fn invalid_length_prefix_is_detected() {
+		let ux = Ex::new_unsigned(vec![0u8; 0]);
+		let mut encoded = ux.encode();
+
+		let length = Compact::<u32>::decode(&mut &encoded[..]).unwrap();
+		Compact(length.0 + 10).encode_to(&mut &mut encoded[..1]);
+
+		assert_eq!(Ex::decode(&mut &encoded[..]), Err("Invalid length prefix".into()));
+	}
+
+	#[test]
+	fn signed_codec_should_work() {
+		let ux = Ex::new_signed(
+			vec![0u8; 0],
+			TEST_ACCOUNT,
+			TestSig(TEST_ACCOUNT, (vec![0u8; 0], TestExtra).encode()),
+			TestExtra,
+		);
+		let encoded = ux.encode();
+		assert_eq!(Ex::decode(&mut &encoded[..]), Ok(ux));
+	}
+
+	#[test]
+	fn large_signed_codec_should_work() {
+		let ux = Ex::new_signed(
+			vec![0u8; 0],
+			TEST_ACCOUNT,
+			TestSig(
+				TEST_ACCOUNT,
+				(vec![0u8; 257], TestExtra).using_encoded(blake2_256)[..].to_owned(),
+			),
+			TestExtra,
+		);
+		let encoded = ux.encode();
+		assert_eq!(Ex::decode(&mut &encoded[..]), Ok(ux));
+	}
+
+	#[test]
+	fn unsigned_check_should_work() {
+		let ux = Ex::new_unsigned(vec![0u8; 0]);
+		assert!(!ux.is_signed().unwrap_or(false));
+		assert!(<Ex as Checkable<TestContext>>::check(ux, &Default::default()).is_ok());
+	}
+
+	#[test]
+	fn badly_signed_check_should_fail() {
+		let ux = Ex::new_signed(
+			vec![0u8; 0],
+			TEST_ACCOUNT,
+			TestSig(TEST_ACCOUNT, vec![0u8; 0]),
+			TestExtra,
+		);
+		assert!(ux.is_signed().unwrap_or(false));
+		assert_eq!(
+			<Ex as Checkable<TestContext>>::check(ux, &Default::default()),
+			Err(InvalidTransaction::BadProof.into()),
+		);
+	}
+
+	#[test]
+	fn signed_check_should_work() {
+		let ux = Ex::new_signed(
+			vec![0u8; 0],
+			TEST_ACCOUNT,
+			TestSig(TEST_ACCOUNT, (vec![0u8; 0], TestExtra).encode()),
+			TestExtra,
+		);
+		assert!(ux.is_signed().unwrap_or(false));
+		assert_eq!(
+			<Ex as Checkable<TestContext>>::check(ux, &Default::default()),
+			Ok(CEx { signed: Some((TEST_ACCOUNT, TestExtra)), function: vec![0u8; 0] }),
+		);
+	}
+
+	#[test]
+	fn encoding_matches_vec() {
+		let ex = Ex::new_unsigned(vec![0u8; 0]);
+		let encoded = ex.encode();
+		let decoded = Ex::decode(&mut encoded.as_slice()).unwrap();
+		assert_eq!(decoded, ex);
+		let as_vec: Vec<u8> = Decode::decode(&mut encoded.as_slice()).unwrap();
+		assert_eq!(as_vec.encode(), encoded);
+	}
+
+	#[test]
+	fn conversion_to_opaque() {
+		let ux = Ex::new_unsigned(vec![0u8; 0]);
+		let encoded = ux.encode();
+		let opaque: OpaqueExtrinsic = ux.into();
+		let opaque_encoded = opaque.encode();
+		assert_eq!(opaque_encoded, encoded);
+	}
+
+	#[test]
+	fn large_bad_prefix_should_work() {
+		let encoded = Compact::<u32>::from(u32::MAX).encode();
+		assert_eq!(
+			Ex::decode(&mut &encoded[..]),
+			Err(Error::from("Not enough data to fill buffer"))
+		);
+	}
+}
diff --git a/substrate/primitives/runtime/src/legacy.rs b/substrate/primitives/runtime/src/legacy.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b134038a128693845d3fe7cc4ddf47a6c99799d5
--- /dev/null
+++ b/substrate/primitives/runtime/src/legacy.rs
@@ -0,0 +1,20 @@
+// 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.
+
+//! Runtime types that existed in old API versions.
+
+pub mod byte_sized_error;
diff --git a/substrate/primitives/runtime/src/legacy/byte_sized_error.rs b/substrate/primitives/runtime/src/legacy/byte_sized_error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a592c751231dc48232cfffb50c593b227893a8ec
--- /dev/null
+++ b/substrate/primitives/runtime/src/legacy/byte_sized_error.rs
@@ -0,0 +1,100 @@
+// 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.
+
+//! Runtime types that existed prior to BlockBuilder API version 6.
+
+use crate::{ArithmeticError, TokenError};
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// [`ModuleError`] type definition before BlockBuilder API version 6.
+#[derive(Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ModuleError {
+	/// Module index, matching the metadata module index.
+	pub index: u8,
+	/// Module specific error value.
+	pub error: u8,
+	/// Optional error message.
+	#[codec(skip)]
+	#[cfg_attr(feature = "serde", serde(skip_deserializing))]
+	pub message: Option<&'static str>,
+}
+
+impl PartialEq for ModuleError {
+	fn eq(&self, other: &Self) -> bool {
+		(self.index == other.index) && (self.error == other.error)
+	}
+}
+
+/// [`DispatchError`] type definition before BlockBuilder API version 6.
+#[derive(Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum DispatchError {
+	/// Some error occurred.
+	Other(
+		#[codec(skip)]
+		#[cfg_attr(feature = "serde", serde(skip_deserializing))]
+		&'static str,
+	),
+	/// Failed to lookup some data.
+	CannotLookup,
+	/// A bad origin.
+	BadOrigin,
+	/// A custom error in a module.
+	Module(ModuleError),
+	/// At least one consumer is remaining so the account cannot be destroyed.
+	ConsumerRemaining,
+	/// There are no providers so the account cannot be created.
+	NoProviders,
+	/// There are too many consumers so the account cannot be created.
+	TooManyConsumers,
+	/// An error to do with tokens.
+	Token(TokenError),
+	/// An arithmetic error.
+	Arithmetic(ArithmeticError),
+}
+
+/// [`DispatchOutcome`] type definition before BlockBuilder API version 6.
+pub type DispatchOutcome = Result<(), DispatchError>;
+
+/// [`ApplyExtrinsicResult`] type definition before BlockBuilder API version 6.
+pub type ApplyExtrinsicResult =
+	Result<DispatchOutcome, crate::transaction_validity::TransactionValidityError>;
+
+/// Convert the legacy `ApplyExtrinsicResult` type to the latest version.
+pub fn convert_to_latest(old: ApplyExtrinsicResult) -> crate::ApplyExtrinsicResult {
+	old.map(|outcome| {
+		outcome.map_err(|e| match e {
+			DispatchError::Other(s) => crate::DispatchError::Other(s),
+			DispatchError::CannotLookup => crate::DispatchError::CannotLookup,
+			DispatchError::BadOrigin => crate::DispatchError::BadOrigin,
+			DispatchError::Module(err) => crate::DispatchError::Module(crate::ModuleError {
+				index: err.index,
+				error: [err.error, 0, 0, 0],
+				message: err.message,
+			}),
+			DispatchError::ConsumerRemaining => crate::DispatchError::ConsumerRemaining,
+			DispatchError::NoProviders => crate::DispatchError::NoProviders,
+			DispatchError::TooManyConsumers => crate::DispatchError::TooManyConsumers,
+			DispatchError::Token(err) => crate::DispatchError::Token(err),
+			DispatchError::Arithmetic(err) => crate::DispatchError::Arithmetic(err),
+		})
+	})
+}
diff --git a/substrate/primitives/runtime/src/lib.rs b/substrate/primitives/runtime/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..dd861ad05de9be9717e337be79f5c17e9d3b676f
--- /dev/null
+++ b/substrate/primitives/runtime/src/lib.rs
@@ -0,0 +1,1126 @@
+// 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.
+
+//! # Substrate Runtime Primitives.
+//!
+//! This crate, among other things, contains a large library of types and utilities that are used in
+//! the Substrate runtime, but are not particularly `FRAME`-oriented.
+//!
+//! ## Block, Header and Extrinsics
+//!
+//! Most notable, this crate contains some of the types and trait that enable important
+//! communication between the client and the runtime. This includes:
+//!
+//! - A set of traits to declare what any block/header/extrinsic type should provide.
+//! 	- [`traits::Block`], [`traits::Header`], [`traits::Extrinsic`]
+//! - A set of types that implement these traits, whilst still providing a high degree of
+//!   configurability via generics.
+//! 	- [`generic::Block`], [`generic::Header`], [`generic::UncheckedExtrinsic`] and
+//!    [`generic::CheckedExtrinsic`]
+//!
+//! ## Runtime API Types
+//!
+//! This crate also contains some types that are often used in conjuncture with Runtime APIs. Most
+//! notable:
+//!
+//! - [`ApplyExtrinsicResult`], and [`DispatchOutcome`], which dictate how the client and runtime
+//!   communicate about the success or failure of an extrinsic.
+//! - [`transaction_validity`], which dictates how the client and runtime communicate about the
+//!  validity of an extrinsic while still in the transaction-queue.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[doc(hidden)]
+pub use codec;
+#[doc(hidden)]
+pub use scale_info;
+#[cfg(feature = "serde")]
+#[doc(hidden)]
+pub use serde;
+#[doc(hidden)]
+pub use sp_std;
+
+#[doc(hidden)]
+pub use paste;
+#[doc(hidden)]
+pub use sp_arithmetic::traits::Saturating;
+
+#[doc(hidden)]
+pub use sp_application_crypto as app_crypto;
+
+pub use sp_core::storage::StateVersion;
+#[cfg(feature = "std")]
+pub use sp_core::storage::{Storage, StorageChild};
+
+use sp_core::{
+	crypto::{self, ByteArray, FromEntropy},
+	ecdsa, ed25519,
+	hash::{H256, H512},
+	sr25519,
+};
+use sp_std::prelude::*;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+#[cfg(all(not(feature = "std"), feature = "serde"))]
+use sp_std::alloc::format;
+
+pub mod curve;
+pub mod generic;
+pub mod legacy;
+mod multiaddress;
+pub mod offchain;
+pub mod runtime_logger;
+mod runtime_string;
+#[cfg(feature = "std")]
+pub mod testing;
+pub mod traits;
+pub mod transaction_validity;
+
+pub use crate::runtime_string::*;
+
+// Re-export Multiaddress
+pub use multiaddress::MultiAddress;
+
+/// Re-export these since they're only "kind of" generic.
+pub use generic::{Digest, DigestItem};
+
+pub use sp_application_crypto::{BoundToRuntimeAppPublic, RuntimeAppPublic};
+/// Re-export this since it's part of the API of this crate.
+pub use sp_core::{
+	bounded::{BoundedBTreeMap, BoundedBTreeSet, BoundedSlice, BoundedVec, WeakBoundedVec},
+	crypto::{key_types, AccountId32, CryptoType, CryptoTypeId, KeyTypeId},
+	TypeId,
+};
+/// Re-export bounded_vec and bounded_btree_map macros only when std is enabled.
+#[cfg(feature = "std")]
+pub use sp_core::{bounded_btree_map, bounded_vec};
+
+/// Re-export `RuntimeDebug`, to avoid dependency clutter.
+pub use sp_core::RuntimeDebug;
+
+/// Re-export big_uint stuff.
+pub use sp_arithmetic::biguint;
+/// Re-export 128 bit helpers.
+pub use sp_arithmetic::helpers_128bit;
+/// Re-export top-level arithmetic stuff.
+pub use sp_arithmetic::{
+	traits::SaturatedConversion, ArithmeticError, FixedI128, FixedI64, FixedPointNumber,
+	FixedPointOperand, FixedU128, FixedU64, InnerOf, PerThing, PerU16, Perbill, Percent, Permill,
+	Perquintill, Rational128, Rounding, UpperOf,
+};
+
+pub use either::Either;
+
+/// The number of bytes of the module-specific `error` field defined in [`ModuleError`].
+/// In FRAME, this is the maximum encoded size of a pallet error type.
+pub const MAX_MODULE_ERROR_ENCODED_SIZE: usize = 4;
+
+/// An abstraction over justification for a block's validity under a consensus algorithm.
+///
+/// Essentially a finality proof. The exact formulation will vary between consensus
+/// algorithms. In the case where there are multiple valid proofs, inclusion within
+/// the block itself would allow swapping justifications to change the block's hash
+/// (and thus fork the chain). Sending a `Justification` alongside a block instead
+/// bypasses this problem.
+///
+/// Each justification is provided as an encoded blob, and is tagged with an ID
+/// to identify the consensus engine that generated the proof (we might have
+/// multiple justifications from different engines for the same block).
+pub type Justification = (ConsensusEngineId, EncodedJustification);
+
+/// The encoded justification specific to a consensus engine.
+pub type EncodedJustification = Vec<u8>;
+
+/// Collection of justifications for a given block, multiple justifications may
+/// be provided by different consensus engines for the same block.
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Debug, Clone, PartialEq, Eq, Encode, Decode)]
+pub struct Justifications(Vec<Justification>);
+
+impl Justifications {
+	/// Return an iterator over the justifications.
+	pub fn iter(&self) -> impl Iterator<Item = &Justification> {
+		self.0.iter()
+	}
+
+	/// Append a justification. Returns false if a justification with the same
+	/// `ConsensusEngineId` already exists, in which case the justification is
+	/// not inserted.
+	pub fn append(&mut self, justification: Justification) -> bool {
+		if self.get(justification.0).is_some() {
+			return false
+		}
+		self.0.push(justification);
+		true
+	}
+
+	/// Return the encoded justification for the given consensus engine, if it
+	/// exists.
+	pub fn get(&self, engine_id: ConsensusEngineId) -> Option<&EncodedJustification> {
+		self.iter().find(|j| j.0 == engine_id).map(|j| &j.1)
+	}
+
+	/// Remove the encoded justification for the given consensus engine, if it exists.
+	pub fn remove(&mut self, engine_id: ConsensusEngineId) {
+		self.0.retain(|j| j.0 != engine_id)
+	}
+
+	/// Return a copy of the encoded justification for the given consensus
+	/// engine, if it exists.
+	pub fn into_justification(self, engine_id: ConsensusEngineId) -> Option<EncodedJustification> {
+		self.into_iter().find(|j| j.0 == engine_id).map(|j| j.1)
+	}
+}
+
+impl IntoIterator for Justifications {
+	type Item = Justification;
+	type IntoIter = sp_std::vec::IntoIter<Self::Item>;
+
+	fn into_iter(self) -> Self::IntoIter {
+		self.0.into_iter()
+	}
+}
+
+impl From<Justification> for Justifications {
+	fn from(justification: Justification) -> Self {
+		Self(vec![justification])
+	}
+}
+
+use traits::{Lazy, Verify};
+
+use crate::traits::IdentifyAccount;
+#[cfg(feature = "serde")]
+pub use serde::{de::DeserializeOwned, Deserialize, Serialize};
+
+/// Complex storage builder stuff.
+#[cfg(feature = "std")]
+pub trait BuildStorage {
+	/// Build the storage out of this builder.
+	fn build_storage(&self) -> Result<sp_core::storage::Storage, String> {
+		let mut storage = Default::default();
+		self.assimilate_storage(&mut storage)?;
+		Ok(storage)
+	}
+	/// Assimilate the storage for this module into pre-existing overlays.
+	fn assimilate_storage(&self, storage: &mut sp_core::storage::Storage) -> Result<(), String>;
+}
+
+/// Something that can build the genesis storage of a module.
+#[cfg(feature = "std")]
+#[deprecated(
+	note = "`BuildModuleGenesisStorage` is planned to be removed in December 2023. Use `BuildStorage` instead of it."
+)]
+pub trait BuildModuleGenesisStorage<T, I>: Sized {
+	/// Create the module genesis storage into the given `storage` and `child_storage`.
+	fn build_module_genesis_storage(
+		&self,
+		storage: &mut sp_core::storage::Storage,
+	) -> Result<(), String>;
+}
+
+#[cfg(feature = "std")]
+impl BuildStorage for sp_core::storage::Storage {
+	fn assimilate_storage(&self, storage: &mut sp_core::storage::Storage) -> Result<(), String> {
+		storage.top.extend(self.top.iter().map(|(k, v)| (k.clone(), v.clone())));
+		for (k, other_map) in self.children_default.iter() {
+			let k = k.clone();
+			if let Some(map) = storage.children_default.get_mut(&k) {
+				map.data.extend(other_map.data.iter().map(|(k, v)| (k.clone(), v.clone())));
+				if !map.child_info.try_update(&other_map.child_info) {
+					return Err("Incompatible child info update".to_string())
+				}
+			} else {
+				storage.children_default.insert(k, other_map.clone());
+			}
+		}
+		Ok(())
+	}
+}
+
+#[cfg(feature = "std")]
+impl BuildStorage for () {
+	fn assimilate_storage(&self, _: &mut sp_core::storage::Storage) -> Result<(), String> {
+		Err("`assimilate_storage` not implemented for `()`".into())
+	}
+}
+
+/// Consensus engine unique ID.
+pub type ConsensusEngineId = [u8; 4];
+
+/// Signature verify that can work with any known signature types.
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Eq, PartialEq, Clone, Encode, Decode, MaxEncodedLen, RuntimeDebug, TypeInfo)]
+pub enum MultiSignature {
+	/// An Ed25519 signature.
+	Ed25519(ed25519::Signature),
+	/// An Sr25519 signature.
+	Sr25519(sr25519::Signature),
+	/// An ECDSA/SECP256k1 signature.
+	Ecdsa(ecdsa::Signature),
+}
+
+impl From<ed25519::Signature> for MultiSignature {
+	fn from(x: ed25519::Signature) -> Self {
+		Self::Ed25519(x)
+	}
+}
+
+impl TryFrom<MultiSignature> for ed25519::Signature {
+	type Error = ();
+	fn try_from(m: MultiSignature) -> Result<Self, Self::Error> {
+		if let MultiSignature::Ed25519(x) = m {
+			Ok(x)
+		} else {
+			Err(())
+		}
+	}
+}
+
+impl From<sr25519::Signature> for MultiSignature {
+	fn from(x: sr25519::Signature) -> Self {
+		Self::Sr25519(x)
+	}
+}
+
+impl TryFrom<MultiSignature> for sr25519::Signature {
+	type Error = ();
+	fn try_from(m: MultiSignature) -> Result<Self, Self::Error> {
+		if let MultiSignature::Sr25519(x) = m {
+			Ok(x)
+		} else {
+			Err(())
+		}
+	}
+}
+
+impl From<ecdsa::Signature> for MultiSignature {
+	fn from(x: ecdsa::Signature) -> Self {
+		Self::Ecdsa(x)
+	}
+}
+
+impl TryFrom<MultiSignature> for ecdsa::Signature {
+	type Error = ();
+	fn try_from(m: MultiSignature) -> Result<Self, Self::Error> {
+		if let MultiSignature::Ecdsa(x) = m {
+			Ok(x)
+		} else {
+			Err(())
+		}
+	}
+}
+
+/// Public key for any known crypto algorithm.
+#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Encode, Decode, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum MultiSigner {
+	/// An Ed25519 identity.
+	Ed25519(ed25519::Public),
+	/// An Sr25519 identity.
+	Sr25519(sr25519::Public),
+	/// An SECP256k1/ECDSA identity (actually, the Blake2 hash of the compressed pub key).
+	Ecdsa(ecdsa::Public),
+}
+
+impl FromEntropy for MultiSigner {
+	fn from_entropy(input: &mut impl codec::Input) -> Result<Self, codec::Error> {
+		Ok(match input.read_byte()? % 3 {
+			0 => Self::Ed25519(FromEntropy::from_entropy(input)?),
+			1 => Self::Sr25519(FromEntropy::from_entropy(input)?),
+			2.. => Self::Ecdsa(FromEntropy::from_entropy(input)?),
+		})
+	}
+}
+
+/// NOTE: This implementations is required by `SimpleAddressDeterminer`,
+/// we convert the hash into some AccountId, it's fine to use any scheme.
+impl<T: Into<H256>> crypto::UncheckedFrom<T> for MultiSigner {
+	fn unchecked_from(x: T) -> Self {
+		ed25519::Public::unchecked_from(x.into()).into()
+	}
+}
+
+impl AsRef<[u8]> for MultiSigner {
+	fn as_ref(&self) -> &[u8] {
+		match *self {
+			Self::Ed25519(ref who) => who.as_ref(),
+			Self::Sr25519(ref who) => who.as_ref(),
+			Self::Ecdsa(ref who) => who.as_ref(),
+		}
+	}
+}
+
+impl traits::IdentifyAccount for MultiSigner {
+	type AccountId = AccountId32;
+	fn into_account(self) -> AccountId32 {
+		match self {
+			Self::Ed25519(who) => <[u8; 32]>::from(who).into(),
+			Self::Sr25519(who) => <[u8; 32]>::from(who).into(),
+			Self::Ecdsa(who) => sp_io::hashing::blake2_256(who.as_ref()).into(),
+		}
+	}
+}
+
+impl From<ed25519::Public> for MultiSigner {
+	fn from(x: ed25519::Public) -> Self {
+		Self::Ed25519(x)
+	}
+}
+
+impl TryFrom<MultiSigner> for ed25519::Public {
+	type Error = ();
+	fn try_from(m: MultiSigner) -> Result<Self, Self::Error> {
+		if let MultiSigner::Ed25519(x) = m {
+			Ok(x)
+		} else {
+			Err(())
+		}
+	}
+}
+
+impl From<sr25519::Public> for MultiSigner {
+	fn from(x: sr25519::Public) -> Self {
+		Self::Sr25519(x)
+	}
+}
+
+impl TryFrom<MultiSigner> for sr25519::Public {
+	type Error = ();
+	fn try_from(m: MultiSigner) -> Result<Self, Self::Error> {
+		if let MultiSigner::Sr25519(x) = m {
+			Ok(x)
+		} else {
+			Err(())
+		}
+	}
+}
+
+impl From<ecdsa::Public> for MultiSigner {
+	fn from(x: ecdsa::Public) -> Self {
+		Self::Ecdsa(x)
+	}
+}
+
+impl TryFrom<MultiSigner> for ecdsa::Public {
+	type Error = ();
+	fn try_from(m: MultiSigner) -> Result<Self, Self::Error> {
+		if let MultiSigner::Ecdsa(x) = m {
+			Ok(x)
+		} else {
+			Err(())
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for MultiSigner {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		match *self {
+			Self::Ed25519(ref who) => write!(fmt, "ed25519: {}", who),
+			Self::Sr25519(ref who) => write!(fmt, "sr25519: {}", who),
+			Self::Ecdsa(ref who) => write!(fmt, "ecdsa: {}", who),
+		}
+	}
+}
+
+impl Verify for MultiSignature {
+	type Signer = MultiSigner;
+	fn verify<L: Lazy<[u8]>>(&self, mut msg: L, signer: &AccountId32) -> bool {
+		match (self, signer) {
+			(Self::Ed25519(ref sig), who) => match ed25519::Public::from_slice(who.as_ref()) {
+				Ok(signer) => sig.verify(msg, &signer),
+				Err(()) => false,
+			},
+			(Self::Sr25519(ref sig), who) => match sr25519::Public::from_slice(who.as_ref()) {
+				Ok(signer) => sig.verify(msg, &signer),
+				Err(()) => false,
+			},
+			(Self::Ecdsa(ref sig), who) => {
+				let m = sp_io::hashing::blake2_256(msg.get());
+				match sp_io::crypto::secp256k1_ecdsa_recover_compressed(sig.as_ref(), &m) {
+					Ok(pubkey) =>
+						&sp_io::hashing::blake2_256(pubkey.as_ref()) ==
+							<dyn AsRef<[u8; 32]>>::as_ref(who),
+					_ => false,
+				}
+			},
+		}
+	}
+}
+
+/// Signature verify that can work with any known signature types..
+#[derive(Eq, PartialEq, Clone, Default, Encode, Decode, RuntimeDebug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct AnySignature(H512);
+
+impl Verify for AnySignature {
+	type Signer = sr25519::Public;
+	fn verify<L: Lazy<[u8]>>(&self, mut msg: L, signer: &sr25519::Public) -> bool {
+		let msg = msg.get();
+		sr25519::Signature::try_from(self.0.as_fixed_bytes().as_ref())
+			.map(|s| s.verify(msg, signer))
+			.unwrap_or(false) ||
+			ed25519::Signature::try_from(self.0.as_fixed_bytes().as_ref())
+				.map(|s| match ed25519::Public::from_slice(signer.as_ref()) {
+					Err(()) => false,
+					Ok(signer) => s.verify(msg, &signer),
+				})
+				.unwrap_or(false)
+	}
+}
+
+impl From<sr25519::Signature> for AnySignature {
+	fn from(s: sr25519::Signature) -> Self {
+		Self(s.into())
+	}
+}
+
+impl From<ed25519::Signature> for AnySignature {
+	fn from(s: ed25519::Signature) -> Self {
+		Self(s.into())
+	}
+}
+
+impl From<DispatchError> for DispatchOutcome {
+	fn from(err: DispatchError) -> Self {
+		Err(err)
+	}
+}
+
+/// This is the legacy return type of `Dispatchable`. It is still exposed for compatibility reasons.
+/// The new return type is `DispatchResultWithInfo`. FRAME runtimes should use
+/// `frame_support::dispatch::DispatchResult`.
+pub type DispatchResult = sp_std::result::Result<(), DispatchError>;
+
+/// Return type of a `Dispatchable` which contains the `DispatchResult` and additional information
+/// about the `Dispatchable` that is only known post dispatch.
+pub type DispatchResultWithInfo<T> = sp_std::result::Result<T, DispatchErrorWithPostInfo<T>>;
+
+/// Reason why a pallet call failed.
+#[derive(Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct ModuleError {
+	/// Module index, matching the metadata module index.
+	pub index: u8,
+	/// Module specific error value.
+	pub error: [u8; MAX_MODULE_ERROR_ENCODED_SIZE],
+	/// Optional error message.
+	#[codec(skip)]
+	#[cfg_attr(feature = "serde", serde(skip_deserializing))]
+	pub message: Option<&'static str>,
+}
+
+impl PartialEq for ModuleError {
+	fn eq(&self, other: &Self) -> bool {
+		(self.index == other.index) && (self.error == other.error)
+	}
+}
+
+/// Errors related to transactional storage layers.
+#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum TransactionalError {
+	/// Too many transactional layers have been spawned.
+	LimitReached,
+	/// A transactional layer was expected, but does not exist.
+	NoLayer,
+}
+
+impl From<TransactionalError> for &'static str {
+	fn from(e: TransactionalError) -> &'static str {
+		match e {
+			TransactionalError::LimitReached => "Too many transactional layers have been spawned",
+			TransactionalError::NoLayer => "A transactional layer was expected, but does not exist",
+		}
+	}
+}
+
+impl From<TransactionalError> for DispatchError {
+	fn from(e: TransactionalError) -> DispatchError {
+		Self::Transactional(e)
+	}
+}
+
+/// Reason why a dispatch call failed.
+#[derive(Eq, Clone, Copy, Encode, Decode, Debug, TypeInfo, PartialEq, MaxEncodedLen)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum DispatchError {
+	/// Some error occurred.
+	Other(
+		#[codec(skip)]
+		#[cfg_attr(feature = "serde", serde(skip_deserializing))]
+		&'static str,
+	),
+	/// Failed to lookup some data.
+	CannotLookup,
+	/// A bad origin.
+	BadOrigin,
+	/// A custom error in a module.
+	Module(ModuleError),
+	/// At least one consumer is remaining so the account cannot be destroyed.
+	ConsumerRemaining,
+	/// There are no providers so the account cannot be created.
+	NoProviders,
+	/// There are too many consumers so the account cannot be created.
+	TooManyConsumers,
+	/// An error to do with tokens.
+	Token(TokenError),
+	/// An arithmetic error.
+	Arithmetic(ArithmeticError),
+	/// The number of transactional layers has been reached, or we are not in a transactional
+	/// layer.
+	Transactional(TransactionalError),
+	/// Resources exhausted, e.g. attempt to read/write data which is too large to manipulate.
+	Exhausted,
+	/// The state is corrupt; this is generally not going to fix itself.
+	Corruption,
+	/// Some resource (e.g. a preimage) is unavailable right now. This might fix itself later.
+	Unavailable,
+	/// Root origin is not allowed.
+	RootNotAllowed,
+}
+
+/// Result of a `Dispatchable` which contains the `DispatchResult` and additional information about
+/// the `Dispatchable` that is only known post dispatch.
+#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct DispatchErrorWithPostInfo<Info>
+where
+	Info: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable,
+{
+	/// Additional information about the `Dispatchable` which is only known post dispatch.
+	pub post_info: Info,
+	/// The actual `DispatchResult` indicating whether the dispatch was successful.
+	pub error: DispatchError,
+}
+
+impl DispatchError {
+	/// Return the same error but without the attached message.
+	pub fn stripped(self) -> Self {
+		match self {
+			DispatchError::Module(ModuleError { index, error, message: Some(_) }) =>
+				DispatchError::Module(ModuleError { index, error, message: None }),
+			m => m,
+		}
+	}
+}
+
+impl<T, E> From<E> for DispatchErrorWithPostInfo<T>
+where
+	T: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable + Default,
+	E: Into<DispatchError>,
+{
+	fn from(error: E) -> Self {
+		Self { post_info: Default::default(), error: error.into() }
+	}
+}
+
+impl From<crate::traits::LookupError> for DispatchError {
+	fn from(_: crate::traits::LookupError) -> Self {
+		Self::CannotLookup
+	}
+}
+
+impl From<crate::traits::BadOrigin> for DispatchError {
+	fn from(_: crate::traits::BadOrigin) -> Self {
+		Self::BadOrigin
+	}
+}
+
+/// Description of what went wrong when trying to complete an operation on a token.
+#[derive(Eq, PartialEq, Clone, Copy, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum TokenError {
+	/// Funds are unavailable.
+	FundsUnavailable,
+	/// Some part of the balance gives the only provider reference to the account and thus cannot
+	/// be (re)moved.
+	OnlyProvider,
+	/// Account cannot exist with the funds that would be given.
+	BelowMinimum,
+	/// Account cannot be created.
+	CannotCreate,
+	/// The asset in question is unknown.
+	UnknownAsset,
+	/// Funds exist but are frozen.
+	Frozen,
+	/// Operation is not supported by the asset.
+	Unsupported,
+	/// Account cannot be created for a held balance.
+	CannotCreateHold,
+	/// Withdrawal would cause unwanted loss of account.
+	NotExpendable,
+	/// Account cannot receive the assets.
+	Blocked,
+}
+
+impl From<TokenError> for &'static str {
+	fn from(e: TokenError) -> &'static str {
+		match e {
+			TokenError::FundsUnavailable => "Funds are unavailable",
+			TokenError::OnlyProvider => "Account that must exist would die",
+			TokenError::BelowMinimum => "Account cannot exist with the funds that would be given",
+			TokenError::CannotCreate => "Account cannot be created",
+			TokenError::UnknownAsset => "The asset in question is unknown",
+			TokenError::Frozen => "Funds exist but are frozen",
+			TokenError::Unsupported => "Operation is not supported by the asset",
+			TokenError::CannotCreateHold =>
+				"Account cannot be created for recording amount on hold",
+			TokenError::NotExpendable => "Account that is desired to remain would die",
+			TokenError::Blocked => "Account cannot receive the assets",
+		}
+	}
+}
+
+impl From<TokenError> for DispatchError {
+	fn from(e: TokenError) -> DispatchError {
+		Self::Token(e)
+	}
+}
+
+impl From<ArithmeticError> for DispatchError {
+	fn from(e: ArithmeticError) -> DispatchError {
+		Self::Arithmetic(e)
+	}
+}
+
+impl From<&'static str> for DispatchError {
+	fn from(err: &'static str) -> DispatchError {
+		Self::Other(err)
+	}
+}
+
+impl From<DispatchError> for &'static str {
+	fn from(err: DispatchError) -> &'static str {
+		use DispatchError::*;
+		match err {
+			Other(msg) => msg,
+			CannotLookup => "Cannot lookup",
+			BadOrigin => "Bad origin",
+			Module(ModuleError { message, .. }) => message.unwrap_or("Unknown module error"),
+			ConsumerRemaining => "Consumer remaining",
+			NoProviders => "No providers",
+			TooManyConsumers => "Too many consumers",
+			Token(e) => e.into(),
+			Arithmetic(e) => e.into(),
+			Transactional(e) => e.into(),
+			Exhausted => "Resources exhausted",
+			Corruption => "State corrupt",
+			Unavailable => "Resource unavailable",
+			RootNotAllowed => "Root not allowed",
+		}
+	}
+}
+
+impl<T> From<DispatchErrorWithPostInfo<T>> for &'static str
+where
+	T: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable,
+{
+	fn from(err: DispatchErrorWithPostInfo<T>) -> &'static str {
+		err.error.into()
+	}
+}
+
+impl traits::Printable for DispatchError {
+	fn print(&self) {
+		use DispatchError::*;
+		"DispatchError".print();
+		match self {
+			Other(err) => err.print(),
+			CannotLookup => "Cannot lookup".print(),
+			BadOrigin => "Bad origin".print(),
+			Module(ModuleError { index, error, message }) => {
+				index.print();
+				error.print();
+				if let Some(msg) = message {
+					msg.print();
+				}
+			},
+			ConsumerRemaining => "Consumer remaining".print(),
+			NoProviders => "No providers".print(),
+			TooManyConsumers => "Too many consumers".print(),
+			Token(e) => {
+				"Token error: ".print();
+				<&'static str>::from(*e).print();
+			},
+			Arithmetic(e) => {
+				"Arithmetic error: ".print();
+				<&'static str>::from(*e).print();
+			},
+			Transactional(e) => {
+				"Transactional error: ".print();
+				<&'static str>::from(*e).print();
+			},
+			Exhausted => "Resources exhausted".print(),
+			Corruption => "State corrupt".print(),
+			Unavailable => "Resource unavailable".print(),
+			RootNotAllowed => "Root not allowed".print(),
+		}
+	}
+}
+
+impl<T> traits::Printable for DispatchErrorWithPostInfo<T>
+where
+	T: Eq + PartialEq + Clone + Copy + Encode + Decode + traits::Printable,
+{
+	fn print(&self) {
+		self.error.print();
+		"PostInfo: ".print();
+		self.post_info.print();
+	}
+}
+
+/// This type specifies the outcome of dispatching a call to a module.
+///
+/// In case of failure an error specific to the module is returned.
+///
+/// Failure of the module call dispatching doesn't invalidate the extrinsic and it is still included
+/// in the block, therefore all state changes performed by the dispatched call are still persisted.
+///
+/// For example, if the dispatching of an extrinsic involves inclusion fee payment then these
+/// changes are going to be preserved even if the call dispatched failed.
+pub type DispatchOutcome = Result<(), DispatchError>;
+
+/// The result of applying of an extrinsic.
+///
+/// This type is typically used in the context of `BlockBuilder` to signal that the extrinsic
+/// in question cannot be included.
+///
+/// A block containing extrinsics that have a negative inclusion outcome is invalid. A negative
+/// result can only occur during the block production, where such extrinsics are detected and
+/// removed from the block that is being created and the transaction pool.
+///
+/// To rehash: every extrinsic in a valid block must return a positive `ApplyExtrinsicResult`.
+///
+/// Examples of reasons preventing inclusion in a block:
+/// - More block weight is required to process the extrinsic than is left in the block being built.
+///   This doesn't necessarily mean that the extrinsic is invalid, since it can still be included in
+///   the next block if it has enough spare weight available.
+/// - The sender doesn't have enough funds to pay the transaction inclusion fee. Including such a
+///   transaction in the block doesn't make sense.
+/// - The extrinsic supplied a bad signature. This transaction won't become valid ever.
+pub type ApplyExtrinsicResult =
+	Result<DispatchOutcome, transaction_validity::TransactionValidityError>;
+
+/// Same as `ApplyExtrinsicResult` but augmented with `PostDispatchInfo` on success.
+pub type ApplyExtrinsicResultWithInfo<T> =
+	Result<DispatchResultWithInfo<T>, transaction_validity::TransactionValidityError>;
+
+/// The error type used as return type in try runtime hooks.
+pub type TryRuntimeError = DispatchError;
+
+/// Verify a signature on an encoded value in a lazy manner. This can be
+/// an optimization if the signature scheme has an "unsigned" escape hash.
+pub fn verify_encoded_lazy<V: Verify, T: codec::Encode>(
+	sig: &V,
+	item: &T,
+	signer: &<V::Signer as IdentifyAccount>::AccountId,
+) -> bool {
+	// The `Lazy<T>` trait expresses something like `X: FnMut<Output = for<'a> &'a T>`.
+	// unfortunately this is a lifetime relationship that can't
+	// be expressed without generic associated types, better unification of HRTBs in type position,
+	// and some kind of integration into the Fn* traits.
+	struct LazyEncode<F> {
+		inner: F,
+		encoded: Option<Vec<u8>>,
+	}
+
+	impl<F: Fn() -> Vec<u8>> traits::Lazy<[u8]> for LazyEncode<F> {
+		fn get(&mut self) -> &[u8] {
+			self.encoded.get_or_insert_with(&self.inner).as_slice()
+		}
+	}
+
+	sig.verify(LazyEncode { inner: || item.encode(), encoded: None }, signer)
+}
+
+/// Checks that `$x` is equal to `$y` with an error rate of `$error`.
+///
+/// # Example
+///
+/// ```rust
+/// # fn main() {
+/// sp_runtime::assert_eq_error_rate!(10, 10, 0);
+/// sp_runtime::assert_eq_error_rate!(10, 11, 1);
+/// sp_runtime::assert_eq_error_rate!(12, 10, 2);
+/// # }
+/// ```
+///
+/// ```rust,should_panic
+/// # fn main() {
+/// sp_runtime::assert_eq_error_rate!(12, 10, 1);
+/// # }
+/// ```
+#[macro_export]
+#[cfg(feature = "std")]
+macro_rules! assert_eq_error_rate {
+	($x:expr, $y:expr, $error:expr $(,)?) => {
+		assert!(
+			($x >= $crate::Saturating::saturating_sub($y, $error)) &&
+				($x <= $crate::Saturating::saturating_add($y, $error)),
+			"{:?} != {:?} (with error rate {:?})",
+			$x,
+			$y,
+			$error,
+		);
+	};
+}
+
+/// Same as [`assert_eq_error_rate`], but intended to be used with floating point number, or
+/// generally those who do not have over/underflow potentials.
+#[macro_export]
+#[cfg(feature = "std")]
+macro_rules! assert_eq_error_rate_float {
+	($x:expr, $y:expr, $error:expr $(,)?) => {
+		assert!(
+			($x >= $y - $error) && ($x <= $y + $error),
+			"{:?} != {:?} (with error rate {:?})",
+			$x,
+			$y,
+			$error,
+		);
+	};
+}
+
+/// Simple blob to hold an extrinsic without committing to its format and ensure it is serialized
+/// correctly.
+#[derive(PartialEq, Eq, Clone, Default, Encode, Decode, TypeInfo)]
+pub struct OpaqueExtrinsic(Vec<u8>);
+
+impl OpaqueExtrinsic {
+	/// Convert an encoded extrinsic to an `OpaqueExtrinsic`.
+	pub fn from_bytes(mut bytes: &[u8]) -> Result<Self, codec::Error> {
+		Self::decode(&mut bytes)
+	}
+}
+
+impl sp_std::fmt::Debug for OpaqueExtrinsic {
+	#[cfg(feature = "std")]
+	fn fmt(&self, fmt: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(fmt, "{}", sp_core::hexdisplay::HexDisplay::from(&self.0))
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn fmt(&self, _fmt: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "serde")]
+impl ::serde::Serialize for OpaqueExtrinsic {
+	fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>
+	where
+		S: ::serde::Serializer,
+	{
+		codec::Encode::using_encoded(&self.0, |bytes| ::sp_core::bytes::serialize(bytes, seq))
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'a> ::serde::Deserialize<'a> for OpaqueExtrinsic {
+	fn deserialize<D>(de: D) -> Result<Self, D::Error>
+	where
+		D: ::serde::Deserializer<'a>,
+	{
+		let r = ::sp_core::bytes::deserialize(de)?;
+		Decode::decode(&mut &r[..])
+			.map_err(|e| ::serde::de::Error::custom(format!("Decode error: {}", e)))
+	}
+}
+
+impl traits::Extrinsic for OpaqueExtrinsic {
+	type Call = ();
+	type SignaturePayload = ();
+}
+
+/// Print something that implements `Printable` from the runtime.
+pub fn print(print: impl traits::Printable) {
+	print.print();
+}
+
+/// Describes on what should happen with a storage transaction.
+pub enum TransactionOutcome<R> {
+	/// Commit the transaction.
+	Commit(R),
+	/// Rollback the transaction.
+	Rollback(R),
+}
+
+impl<R> TransactionOutcome<R> {
+	/// Convert into the inner type.
+	pub fn into_inner(self) -> R {
+		match self {
+			Self::Commit(r) => r,
+			Self::Rollback(r) => r,
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::traits::BlakeTwo256;
+
+	use super::*;
+	use codec::{Decode, Encode};
+	use sp_core::crypto::Pair;
+	use sp_io::TestExternalities;
+	use sp_state_machine::create_proof_check_backend;
+
+	#[test]
+	fn opaque_extrinsic_serialization() {
+		let ex = super::OpaqueExtrinsic(vec![1, 2, 3, 4]);
+		assert_eq!(serde_json::to_string(&ex).unwrap(), "\"0x1001020304\"".to_owned());
+	}
+
+	#[test]
+	fn dispatch_error_encoding() {
+		let error = DispatchError::Module(ModuleError {
+			index: 1,
+			error: [2, 0, 0, 0],
+			message: Some("error message"),
+		});
+		let encoded = error.encode();
+		let decoded = DispatchError::decode(&mut &encoded[..]).unwrap();
+		assert_eq!(encoded, vec![3, 1, 2, 0, 0, 0]);
+		assert_eq!(
+			decoded,
+			DispatchError::Module(ModuleError { index: 1, error: [2, 0, 0, 0], message: None })
+		);
+	}
+
+	#[test]
+	fn dispatch_error_equality() {
+		use DispatchError::*;
+
+		let variants = vec![
+			Other("foo"),
+			Other("bar"),
+			CannotLookup,
+			BadOrigin,
+			Module(ModuleError { index: 1, error: [1, 0, 0, 0], message: None }),
+			Module(ModuleError { index: 1, error: [2, 0, 0, 0], message: None }),
+			Module(ModuleError { index: 2, error: [1, 0, 0, 0], message: None }),
+			ConsumerRemaining,
+			NoProviders,
+			Token(TokenError::FundsUnavailable),
+			Token(TokenError::OnlyProvider),
+			Token(TokenError::BelowMinimum),
+			Token(TokenError::CannotCreate),
+			Token(TokenError::UnknownAsset),
+			Token(TokenError::Frozen),
+			Arithmetic(ArithmeticError::Overflow),
+			Arithmetic(ArithmeticError::Underflow),
+			Arithmetic(ArithmeticError::DivisionByZero),
+		];
+		for (i, variant) in variants.iter().enumerate() {
+			for (j, other_variant) in variants.iter().enumerate() {
+				if i == j {
+					assert_eq!(variant, other_variant);
+				} else {
+					assert_ne!(variant, other_variant);
+				}
+			}
+		}
+
+		// Ignores `message` field in `Module` variant.
+		assert_eq!(
+			Module(ModuleError { index: 1, error: [1, 0, 0, 0], message: Some("foo") }),
+			Module(ModuleError { index: 1, error: [1, 0, 0, 0], message: None }),
+		);
+	}
+
+	#[test]
+	fn multi_signature_ecdsa_verify_works() {
+		let msg = &b"test-message"[..];
+		let (pair, _) = ecdsa::Pair::generate();
+
+		let signature = pair.sign(&msg);
+		assert!(ecdsa::Pair::verify(&signature, msg, &pair.public()));
+
+		let multi_sig = MultiSignature::from(signature);
+		let multi_signer = MultiSigner::from(pair.public());
+		assert!(multi_sig.verify(msg, &multi_signer.into_account()));
+
+		let multi_signer = MultiSigner::from(pair.public());
+		assert!(multi_sig.verify(msg, &multi_signer.into_account()));
+	}
+
+	#[test]
+	fn execute_and_generate_proof_works() {
+		use codec::Encode;
+		use sp_state_machine::Backend;
+		let mut ext = TestExternalities::default();
+
+		ext.insert(b"a".to_vec(), vec![1u8; 33]);
+		ext.insert(b"b".to_vec(), vec![2u8; 33]);
+		ext.insert(b"c".to_vec(), vec![3u8; 33]);
+		ext.insert(b"d".to_vec(), vec![4u8; 33]);
+
+		let pre_root = *ext.backend.root();
+		let (_, proof) = ext.execute_and_prove(|| {
+			sp_io::storage::get(b"a");
+			sp_io::storage::get(b"b");
+			sp_io::storage::get(b"v");
+			sp_io::storage::get(b"d");
+		});
+
+		let compact_proof = proof.clone().into_compact_proof::<BlakeTwo256>(pre_root).unwrap();
+		let compressed_proof = zstd::stream::encode_all(&compact_proof.encode()[..], 0).unwrap();
+
+		// just an example of how you'd inspect the size of the proof.
+		println!("proof size: {:?}", proof.encoded_size());
+		println!("compact proof size: {:?}", compact_proof.encoded_size());
+		println!("zstd-compressed compact proof size: {:?}", &compressed_proof.len());
+
+		// create a new trie-backed from the proof and make sure it contains everything
+		let proof_check = create_proof_check_backend::<BlakeTwo256>(pre_root, proof).unwrap();
+		assert_eq!(proof_check.storage(b"a",).unwrap().unwrap(), vec![1u8; 33]);
+
+		let _ = ext.execute_and_prove(|| {
+			sp_io::storage::set(b"a", &vec![1u8; 44]);
+		});
+
+		// ensure that these changes are propagated to the backend.
+
+		ext.execute_with(|| {
+			assert_eq!(sp_io::storage::get(b"a").unwrap(), vec![1u8; 44]);
+			assert_eq!(sp_io::storage::get(b"b").unwrap(), vec![2u8; 33]);
+		});
+	}
+}
+
+// NOTE: we have to test the sp_core stuff also from a different crate to check that the macro
+// can access the sp_core crate.
+#[cfg(test)]
+mod sp_core_tests {
+	use super::*;
+
+	#[test]
+	#[should_panic]
+	fn generate_feature_enabled_macro_panics() {
+		sp_core::generate_feature_enabled_macro!(if_test, test, $);
+		if_test!(panic!("This should panic"));
+	}
+
+	#[test]
+	fn generate_feature_enabled_macro_works() {
+		sp_core::generate_feature_enabled_macro!(if_not_test, not(test), $);
+		if_not_test!(panic!("This should not panic"));
+	}
+}
diff --git a/substrate/primitives/runtime/src/multiaddress.rs b/substrate/primitives/runtime/src/multiaddress.rs
new file mode 100644
index 0000000000000000000000000000000000000000..89b0a3bcf8cccb0d740aa5f7bc4e750a6e9aaa08
--- /dev/null
+++ b/substrate/primitives/runtime/src/multiaddress.rs
@@ -0,0 +1,64 @@
+// 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.
+
+//! MultiAddress type is a wrapper for multiple downstream account formats.
+
+use codec::{Decode, Encode};
+use sp_std::vec::Vec;
+
+/// A multi-format address wrapper for on-chain accounts.
+#[derive(Encode, Decode, PartialEq, Eq, Clone, crate::RuntimeDebug, scale_info::TypeInfo)]
+#[cfg_attr(feature = "std", derive(Hash))]
+pub enum MultiAddress<AccountId, AccountIndex> {
+	/// It's an account ID (pubkey).
+	Id(AccountId),
+	/// It's an account index.
+	Index(#[codec(compact)] AccountIndex),
+	/// It's some arbitrary raw bytes.
+	Raw(Vec<u8>),
+	/// It's a 32 byte representation.
+	Address32([u8; 32]),
+	/// Its a 20 byte representation.
+	Address20([u8; 20]),
+}
+
+#[cfg(feature = "std")]
+impl<AccountId, AccountIndex> std::fmt::Display for MultiAddress<AccountId, AccountIndex>
+where
+	AccountId: std::fmt::Debug,
+	AccountIndex: std::fmt::Debug,
+{
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		use sp_core::hexdisplay::HexDisplay;
+		match self {
+			Self::Raw(inner) => write!(f, "MultiAddress::Raw({})", HexDisplay::from(inner)),
+			Self::Address32(inner) => {
+				write!(f, "MultiAddress::Address32({})", HexDisplay::from(inner))
+			},
+			Self::Address20(inner) => {
+				write!(f, "MultiAddress::Address20({})", HexDisplay::from(inner))
+			},
+			_ => write!(f, "{:?}", self),
+		}
+	}
+}
+
+impl<AccountId, AccountIndex> From<AccountId> for MultiAddress<AccountId, AccountIndex> {
+	fn from(a: AccountId) -> Self {
+		Self::Id(a)
+	}
+}
diff --git a/substrate/primitives/runtime/src/offchain/http.rs b/substrate/primitives/runtime/src/offchain/http.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bacc0073825bb1412f63f07f0c92ddcbc81e080f
--- /dev/null
+++ b/substrate/primitives/runtime/src/offchain/http.rs
@@ -0,0 +1,611 @@
+// 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 high-level helpers for making HTTP requests from Offchain Workers.
+//!
+//! `sp-io` crate exposes a low level methods to make and control HTTP requests
+//! available only for Offchain Workers. Those might be hard to use
+//! and usually that level of control is not really necessary.
+//! This module aims to provide high-level wrappers for those APIs
+//! to simplify making HTTP requests.
+//!
+//!
+//! Example:
+//! ```rust,no_run
+//! use sp_runtime::offchain::http::Request;
+//!
+//! // initiate a GET request to localhost:1234
+//! let request: Request = Request::get("http://localhost:1234");
+//! let pending = request
+//! 	.add_header("X-Auth", "hunter2")
+//! 	.send()
+//! 	.unwrap();
+//!
+//! // wait for the response indefinitely
+//! let mut response = pending.wait().unwrap();
+//!
+//! // then check the headers
+//! let mut headers = response.headers().into_iter();
+//! assert_eq!(headers.current(), None);
+//!
+//! // and collect the body
+//! let body = response.body();
+//! assert_eq!(body.clone().collect::<Vec<_>>(), b"1234".to_vec());
+//! assert_eq!(body.error(), &None);
+//! ```
+
+use sp_core::{
+	offchain::{
+		HttpError, HttpRequestId as RequestId, HttpRequestStatus as RequestStatus, Timestamp,
+	},
+	RuntimeDebug,
+};
+#[cfg(not(feature = "std"))]
+use sp_std::prelude::vec;
+use sp_std::{prelude::Vec, str};
+
+/// Request method (HTTP verb)
+#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
+pub enum Method {
+	/// GET request
+	Get,
+	/// POST request
+	Post,
+	/// PUT request
+	Put,
+	/// PATCH request
+	Patch,
+	/// DELETE request
+	Delete,
+	/// Custom verb
+	Other(&'static str),
+}
+
+impl AsRef<str> for Method {
+	fn as_ref(&self) -> &str {
+		match *self {
+			Method::Get => "GET",
+			Method::Post => "POST",
+			Method::Put => "PUT",
+			Method::Patch => "PATCH",
+			Method::Delete => "DELETE",
+			Method::Other(m) => m,
+		}
+	}
+}
+
+mod header {
+	use super::*;
+
+	/// A header type.
+	#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
+	pub struct Header {
+		name: Vec<u8>,
+		value: Vec<u8>,
+	}
+
+	impl Header {
+		/// Creates new header given it's name and value.
+		pub fn new(name: &str, value: &str) -> Self {
+			Header { name: name.as_bytes().to_vec(), value: value.as_bytes().to_vec() }
+		}
+
+		/// Returns the name of this header.
+		pub fn name(&self) -> &str {
+			// Header keys are always produced from `&str` so this is safe.
+			// we don't store them as `Strings` to avoid bringing `alloc::String` to sp-std
+			// or here.
+			unsafe { str::from_utf8_unchecked(&self.name) }
+		}
+
+		/// Returns the value of this header.
+		pub fn value(&self) -> &str {
+			// Header values are always produced from `&str` so this is safe.
+			// we don't store them as `Strings` to avoid bringing `alloc::String` to sp-std
+			// or here.
+			unsafe { str::from_utf8_unchecked(&self.value) }
+		}
+	}
+}
+
+/// An HTTP request builder.
+#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
+pub struct Request<'a, T = Vec<&'static [u8]>> {
+	/// Request method
+	pub method: Method,
+	/// Request URL
+	pub url: &'a str,
+	/// Body of the request
+	pub body: T,
+	/// Deadline to finish sending the request
+	pub deadline: Option<Timestamp>,
+	/// Request list of headers.
+	headers: Vec<header::Header>,
+}
+
+impl<T: Default> Default for Request<'static, T> {
+	fn default() -> Self {
+		Request {
+			method: Method::Get,
+			url: "http://localhost",
+			headers: Vec::new(),
+			body: Default::default(),
+			deadline: None,
+		}
+	}
+}
+
+impl<'a> Request<'a> {
+	/// Start a simple GET request
+	pub fn get(url: &'a str) -> Self {
+		Self::new(url)
+	}
+}
+
+impl<'a, T> Request<'a, T> {
+	/// Create new POST request with given body.
+	pub fn post(url: &'a str, body: T) -> Self {
+		let req: Request = Request::default();
+
+		Request { url, body, method: Method::Post, headers: req.headers, deadline: req.deadline }
+	}
+}
+
+impl<'a, T: Default> Request<'a, T> {
+	/// Create a new Request builder with the given URL.
+	pub fn new(url: &'a str) -> Self {
+		Request::default().url(url)
+	}
+
+	/// Change the method of the request
+	pub fn method(mut self, method: Method) -> Self {
+		self.method = method;
+		self
+	}
+
+	/// Change the URL of the request.
+	pub fn url(mut self, url: &'a str) -> Self {
+		self.url = url;
+		self
+	}
+
+	/// Set the body of the request.
+	pub fn body(mut self, body: T) -> Self {
+		self.body = body;
+		self
+	}
+
+	/// Add a header.
+	pub fn add_header(mut self, name: &str, value: &str) -> Self {
+		self.headers.push(header::Header::new(name, value));
+		self
+	}
+
+	/// Set the deadline of the request.
+	pub fn deadline(mut self, deadline: Timestamp) -> Self {
+		self.deadline = Some(deadline);
+		self
+	}
+}
+
+impl<'a, I: AsRef<[u8]>, T: IntoIterator<Item = I>> Request<'a, T> {
+	/// Send the request and return a handle.
+	///
+	/// Err is returned in case the deadline is reached
+	/// or the request timeouts.
+	pub fn send(self) -> Result<PendingRequest, HttpError> {
+		let meta = &[];
+
+		// start an http request.
+		let id = sp_io::offchain::http_request_start(self.method.as_ref(), self.url, meta)
+			.map_err(|_| HttpError::IoError)?;
+
+		// add custom headers
+		for header in &self.headers {
+			sp_io::offchain::http_request_add_header(id, header.name(), header.value())
+				.map_err(|_| HttpError::IoError)?
+		}
+
+		// write body
+		for chunk in self.body {
+			sp_io::offchain::http_request_write_body(id, chunk.as_ref(), self.deadline)?;
+		}
+
+		// finalize the request
+		sp_io::offchain::http_request_write_body(id, &[], self.deadline)?;
+
+		Ok(PendingRequest { id })
+	}
+}
+
+/// A request error
+#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
+pub enum Error {
+	/// Deadline has been reached.
+	DeadlineReached,
+	/// Request had timed out.
+	IoError,
+	/// Unknown error has been encountered.
+	Unknown,
+}
+
+/// A struct representing an uncompleted http request.
+#[derive(PartialEq, Eq, RuntimeDebug)]
+pub struct PendingRequest {
+	/// Request ID
+	pub id: RequestId,
+}
+
+/// A result of waiting for a pending request.
+pub type HttpResult = Result<Response, Error>;
+
+impl PendingRequest {
+	/// Wait for the request to complete.
+	///
+	/// NOTE this waits for the request indefinitely.
+	pub fn wait(self) -> HttpResult {
+		match self.try_wait(None) {
+			Ok(res) => res,
+			Err(_) => panic!("Since `None` is passed we will never get a deadline error; qed"),
+		}
+	}
+
+	/// Attempts to wait for the request to finish,
+	/// but will return `Err` in case the deadline is reached.
+	pub fn try_wait(
+		self,
+		deadline: impl Into<Option<Timestamp>>,
+	) -> Result<HttpResult, PendingRequest> {
+		Self::try_wait_all(vec![self], deadline)
+			.pop()
+			.expect("One request passed, one status received; qed")
+	}
+
+	/// Wait for all provided requests.
+	pub fn wait_all(requests: Vec<PendingRequest>) -> Vec<HttpResult> {
+		Self::try_wait_all(requests, None)
+			.into_iter()
+			.map(|r| match r {
+				Ok(r) => r,
+				Err(_) => panic!("Since `None` is passed we will never get a deadline error; qed"),
+			})
+			.collect()
+	}
+
+	/// Attempt to wait for all provided requests, but up to given deadline.
+	///
+	/// Requests that are complete will resolve to an `Ok` others will return a `DeadlineReached`
+	/// error.
+	pub fn try_wait_all(
+		requests: Vec<PendingRequest>,
+		deadline: impl Into<Option<Timestamp>>,
+	) -> Vec<Result<HttpResult, PendingRequest>> {
+		let ids = requests.iter().map(|r| r.id).collect::<Vec<_>>();
+		let statuses = sp_io::offchain::http_response_wait(&ids, deadline.into());
+
+		statuses
+			.into_iter()
+			.zip(requests.into_iter())
+			.map(|(status, req)| match status {
+				RequestStatus::DeadlineReached => Err(req),
+				RequestStatus::IoError => Ok(Err(Error::IoError)),
+				RequestStatus::Invalid => Ok(Err(Error::Unknown)),
+				RequestStatus::Finished(code) => Ok(Ok(Response::new(req.id, code))),
+			})
+			.collect()
+	}
+}
+
+/// A HTTP response.
+#[derive(RuntimeDebug)]
+pub struct Response {
+	/// Request id
+	pub id: RequestId,
+	/// Response status code
+	pub code: u16,
+	/// A collection of headers.
+	headers: Option<Headers>,
+}
+
+impl Response {
+	fn new(id: RequestId, code: u16) -> Self {
+		Self { id, code, headers: None }
+	}
+
+	/// Retrieve the headers for this response.
+	pub fn headers(&mut self) -> &Headers {
+		if self.headers.is_none() {
+			self.headers = Some(Headers { raw: sp_io::offchain::http_response_headers(self.id) });
+		}
+		self.headers.as_ref().expect("Headers were just set; qed")
+	}
+
+	/// Retrieve the body of this response.
+	pub fn body(&self) -> ResponseBody {
+		ResponseBody::new(self.id)
+	}
+}
+
+/// A buffered byte iterator over response body.
+///
+/// Note that reading the body may return `None` in following cases:
+/// 1. Either the deadline you've set is reached (check via `#error`; In such case you can resume
+///    the reader by setting a new deadline)
+/// 2. Or because of IOError. In such case the reader is not resumable and will keep returning
+///    `None`.
+/// 3. The body has been returned. The reader will keep returning `None`.
+#[derive(Clone)]
+pub struct ResponseBody {
+	id: RequestId,
+	error: Option<HttpError>,
+	buffer: [u8; 4096],
+	filled_up_to: Option<usize>,
+	position: usize,
+	deadline: Option<Timestamp>,
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Debug for ResponseBody {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		fmt.debug_struct("ResponseBody")
+			.field("id", &self.id)
+			.field("error", &self.error)
+			.field("buffer", &self.buffer.len())
+			.field("filled_up_to", &self.filled_up_to)
+			.field("position", &self.position)
+			.field("deadline", &self.deadline)
+			.finish()
+	}
+}
+
+impl ResponseBody {
+	fn new(id: RequestId) -> Self {
+		ResponseBody {
+			id,
+			error: None,
+			buffer: [0_u8; 4096],
+			filled_up_to: None,
+			position: 0,
+			deadline: None,
+		}
+	}
+
+	/// Set the deadline for reading the body.
+	pub fn deadline(&mut self, deadline: impl Into<Option<Timestamp>>) {
+		self.deadline = deadline.into();
+		self.error = None;
+	}
+
+	/// Return an error that caused the iterator to return `None`.
+	///
+	/// If the error is `DeadlineReached` you can resume the iterator by setting
+	/// a new deadline.
+	pub fn error(&self) -> &Option<HttpError> {
+		&self.error
+	}
+}
+
+impl Iterator for ResponseBody {
+	type Item = u8;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.error.is_some() {
+			return None
+		}
+
+		if self.filled_up_to.is_none() {
+			let result =
+				sp_io::offchain::http_response_read_body(self.id, &mut self.buffer, self.deadline);
+			match result {
+				Err(e) => {
+					self.error = Some(e);
+					return None
+				},
+				Ok(0) => return None,
+				Ok(size) => {
+					self.position = 0;
+					self.filled_up_to = Some(size as usize);
+				},
+			}
+		}
+
+		if Some(self.position) == self.filled_up_to {
+			self.filled_up_to = None;
+			return self.next()
+		}
+
+		let result = self.buffer[self.position];
+		self.position += 1;
+		Some(result)
+	}
+}
+
+/// A collection of Headers in the response.
+#[derive(Clone, PartialEq, Eq, RuntimeDebug)]
+pub struct Headers {
+	/// Raw headers
+	pub raw: Vec<(Vec<u8>, Vec<u8>)>,
+}
+
+impl Headers {
+	/// Retrieve a single header from the list of headers.
+	///
+	/// Note this method is linearly looking from all the headers
+	/// comparing them with the needle byte-by-byte.
+	/// If you want to consume multiple headers it's better to iterate
+	/// and collect them on your own.
+	pub fn find(&self, name: &str) -> Option<&str> {
+		let raw = name.as_bytes();
+		for (key, val) in &self.raw {
+			if &**key == raw {
+				return str::from_utf8(val).ok()
+			}
+		}
+		None
+	}
+
+	/// Convert this headers into an iterator.
+	pub fn into_iter(&self) -> HeadersIterator {
+		HeadersIterator { collection: &self.raw, index: None }
+	}
+}
+
+/// A custom iterator traversing all the headers.
+#[derive(Clone, RuntimeDebug)]
+pub struct HeadersIterator<'a> {
+	collection: &'a [(Vec<u8>, Vec<u8>)],
+	index: Option<usize>,
+}
+
+impl<'a> HeadersIterator<'a> {
+	/// Move the iterator to the next position.
+	///
+	/// Returns `true` is `current` has been set by this call.
+	pub fn next(&mut self) -> bool {
+		let index = self.index.map(|x| x + 1).unwrap_or(0);
+		self.index = Some(index);
+		index < self.collection.len()
+	}
+
+	/// Returns current element (if any).
+	///
+	/// Note that you have to call `next` prior to calling this
+	pub fn current(&self) -> Option<(&str, &str)> {
+		self.collection
+			.get(self.index?)
+			.map(|val| (str::from_utf8(&val.0).unwrap_or(""), str::from_utf8(&val.1).unwrap_or("")))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::offchain::{testing, OffchainWorkerExt};
+	use sp_io::TestExternalities;
+
+	#[test]
+	fn should_send_a_basic_request_and_get_response() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let request: Request = Request::get("http://localhost:1234");
+			let pending = request.add_header("X-Auth", "hunter2").send().unwrap();
+			// make sure it's sent correctly
+			state.write().fulfill_pending_request(
+				0,
+				testing::PendingRequest {
+					method: "GET".into(),
+					uri: "http://localhost:1234".into(),
+					headers: vec![("X-Auth".into(), "hunter2".into())],
+					sent: true,
+					..Default::default()
+				},
+				b"1234".to_vec(),
+				None,
+			);
+
+			// wait
+			let mut response = pending.wait().unwrap();
+
+			// then check the response
+			let mut headers = response.headers().into_iter();
+			assert_eq!(headers.current(), None);
+			assert_eq!(headers.next(), false);
+			assert_eq!(headers.current(), None);
+
+			let body = response.body();
+			assert_eq!(body.clone().collect::<Vec<_>>(), b"1234".to_vec());
+			assert_eq!(body.error(), &None);
+		})
+	}
+
+	#[test]
+	fn should_send_huge_response() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let request: Request = Request::get("http://localhost:1234");
+			let pending = request.add_header("X-Auth", "hunter2").send().unwrap();
+			// make sure it's sent correctly
+			state.write().fulfill_pending_request(
+				0,
+				testing::PendingRequest {
+					method: "GET".into(),
+					uri: "http://localhost:1234".into(),
+					headers: vec![("X-Auth".into(), "hunter2".into())],
+					sent: true,
+					..Default::default()
+				},
+				vec![0; 5923],
+				None,
+			);
+
+			// wait
+			let response = pending.wait().unwrap();
+
+			let body = response.body();
+			assert_eq!(body.clone().collect::<Vec<_>>(), vec![0; 5923]);
+			assert_eq!(body.error(), &None);
+		})
+	}
+
+	#[test]
+	fn should_send_a_post_request() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let pending = Request::default()
+				.method(Method::Post)
+				.url("http://localhost:1234")
+				.body(vec![b"1234"])
+				.send()
+				.unwrap();
+			// make sure it's sent correctly
+			state.write().fulfill_pending_request(
+				0,
+				testing::PendingRequest {
+					method: "POST".into(),
+					uri: "http://localhost:1234".into(),
+					body: b"1234".to_vec(),
+					sent: true,
+					..Default::default()
+				},
+				b"1234".to_vec(),
+				Some(("Test".to_owned(), "Header".to_owned())),
+			);
+
+			// wait
+			let mut response = pending.wait().unwrap();
+
+			// then check the response
+			let mut headers = response.headers().into_iter();
+			assert_eq!(headers.current(), None);
+			assert_eq!(headers.next(), true);
+			assert_eq!(headers.current(), Some(("Test", "Header")));
+
+			let body = response.body();
+			assert_eq!(body.clone().collect::<Vec<_>>(), b"1234".to_vec());
+			assert_eq!(body.error(), &None);
+		})
+	}
+}
diff --git a/substrate/primitives/runtime/src/offchain/mod.rs b/substrate/primitives/runtime/src/offchain/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..07abef7c4efad95cdb8c929c0a1577e7737edbce
--- /dev/null
+++ b/substrate/primitives/runtime/src/offchain/mod.rs
@@ -0,0 +1,24 @@
+// 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 collection of higher lever helpers for offchain calls.
+
+pub mod http;
+pub mod storage;
+pub mod storage_lock;
+
+pub use sp_core::offchain::*;
diff --git a/substrate/primitives/runtime/src/offchain/storage.rs b/substrate/primitives/runtime/src/offchain/storage.rs
new file mode 100644
index 0000000000000000000000000000000000000000..23ab7433e66a5ed797d2787054e15080228b6e6c
--- /dev/null
+++ b/substrate/primitives/runtime/src/offchain/storage.rs
@@ -0,0 +1,174 @@
+// 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 set of storage helpers for offchain workers.
+
+use sp_core::offchain::StorageKind;
+
+/// A storage value with a static key.
+pub type StorageValue = StorageValueRef<'static>;
+
+/// An abstraction over local storage value.
+pub struct StorageValueRef<'a> {
+	key: &'a [u8],
+	kind: StorageKind,
+}
+
+/// Reason for not being able to provide the stored value
+#[derive(Debug, PartialEq, Eq)]
+pub enum StorageRetrievalError {
+	/// Value found but undecodable
+	Undecodable,
+}
+
+/// Possible errors when mutating a storage value.
+#[derive(Debug, PartialEq, Eq)]
+pub enum MutateStorageError<T, E> {
+	/// The underlying db failed to update due to a concurrent modification.
+	/// Contains the new value that was not stored.
+	ConcurrentModification(T),
+	/// The function given to us to create the value to be stored failed.
+	/// May be used to signal that having looked at the existing value,
+	/// they don't want to mutate it.
+	ValueFunctionFailed(E),
+}
+
+impl<'a> StorageValueRef<'a> {
+	/// Create a new reference to a value in the persistent local storage.
+	pub fn persistent(key: &'a [u8]) -> Self {
+		Self { key, kind: StorageKind::PERSISTENT }
+	}
+
+	/// Create a new reference to a value in the fork-aware local storage.
+	pub fn local(key: &'a [u8]) -> Self {
+		Self { key, kind: StorageKind::LOCAL }
+	}
+
+	/// Set the value of the storage to encoding of given parameter.
+	///
+	/// Note that the storage may be accessed by workers running concurrently,
+	/// if you happen to write a `get-check-set` pattern you should most likely
+	/// be using `mutate` instead.
+	pub fn set(&self, value: &impl codec::Encode) {
+		value.using_encoded(|val| sp_io::offchain::local_storage_set(self.kind, self.key, val))
+	}
+
+	/// Remove the associated value from the storage.
+	pub fn clear(&mut self) {
+		sp_io::offchain::local_storage_clear(self.kind, self.key)
+	}
+
+	/// Retrieve & decode the value from storage.
+	///
+	/// Note that if you want to do some checks based on the value
+	/// and write changes after that, you should rather be using `mutate`.
+	///
+	/// Returns the value if stored.
+	/// Returns an error if the value could not be decoded.
+	pub fn get<T: codec::Decode>(&self) -> Result<Option<T>, StorageRetrievalError> {
+		sp_io::offchain::local_storage_get(self.kind, self.key)
+			.map(|val| T::decode(&mut &*val).map_err(|_| StorageRetrievalError::Undecodable))
+			.transpose()
+	}
+
+	/// Retrieve & decode the current value and set it to a new value atomically.
+	///
+	/// Function `mutate_val` takes as input the current value and should
+	/// return a new value that is attempted to be written to storage.
+	///
+	/// This function returns:
+	/// 1. `Ok(T)` in case the value has been successfully set.
+	/// 2. `Err(MutateStorageError::ConcurrentModification(T))` in case the value was calculated
+	/// by the passed closure `mutate_val`, but it could not be stored.
+	/// 3. `Err(MutateStorageError::ValueFunctionFailed(_))` in case `mutate_val` returns an error.
+	pub fn mutate<T, E, F>(&self, mutate_val: F) -> Result<T, MutateStorageError<T, E>>
+	where
+		T: codec::Codec,
+		F: FnOnce(Result<Option<T>, StorageRetrievalError>) -> Result<T, E>,
+	{
+		let value = sp_io::offchain::local_storage_get(self.kind, self.key);
+		let decoded = value
+			.as_deref()
+			.map(|mut bytes| T::decode(&mut bytes).map_err(|_| StorageRetrievalError::Undecodable))
+			.transpose();
+
+		let val =
+			mutate_val(decoded).map_err(|err| MutateStorageError::ValueFunctionFailed(err))?;
+
+		let set = val.using_encoded(|new_val| {
+			sp_io::offchain::local_storage_compare_and_set(self.kind, self.key, value, new_val)
+		});
+		if set {
+			Ok(val)
+		} else {
+			Err(MutateStorageError::ConcurrentModification(val))
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::offchain::{testing, OffchainDbExt};
+	use sp_io::TestExternalities;
+
+	#[test]
+	fn should_set_and_get() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain));
+
+		t.execute_with(|| {
+			let val = StorageValue::persistent(b"testval");
+
+			assert_eq!(val.get::<u32>(), Ok(None));
+
+			val.set(&15_u32);
+
+			assert_eq!(val.get::<u32>(), Ok(Some(15_u32)));
+			assert_eq!(val.get::<Vec<u8>>(), Err(StorageRetrievalError::Undecodable));
+			assert_eq!(state.read().persistent_storage.get(b"testval"), Some(vec![15_u8, 0, 0, 0]));
+		})
+	}
+
+	#[test]
+	fn should_mutate() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain));
+
+		t.execute_with(|| {
+			let val = StorageValue::persistent(b"testval");
+
+			let result = val.mutate::<u32, (), _>(|val| {
+				assert_eq!(val, Ok(None));
+
+				Ok(16_u32)
+			});
+			assert_eq!(result, Ok(16_u32));
+			assert_eq!(val.get::<u32>(), Ok(Some(16_u32)));
+			assert_eq!(state.read().persistent_storage.get(b"testval"), Some(vec![16_u8, 0, 0, 0]));
+
+			// mutate again, but this time early-exit.
+			let res = val.mutate::<u32, (), _>(|val| {
+				assert_eq!(val, Ok(Some(16_u32)));
+				Err(())
+			});
+			assert_eq!(res, Err(MutateStorageError::ValueFunctionFailed(())));
+		})
+	}
+}
diff --git a/substrate/primitives/runtime/src/offchain/storage_lock.rs b/substrate/primitives/runtime/src/offchain/storage_lock.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1b795978447df13d037385d9e7dca09a9dd47596
--- /dev/null
+++ b/substrate/primitives/runtime/src/offchain/storage_lock.rs
@@ -0,0 +1,579 @@
+// 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.
+
+//! # Off-chain Storage Lock
+//!
+//! A storage-based lock with a defined expiry time.
+//!
+//! The lock is using Local Storage and allows synchronizing access to critical
+//! section of your code for concurrently running Off-chain Workers. Usage of
+//! `PERSISTENT` variant of the storage persists the lock value across a full node
+//! restart or re-orgs.
+//!
+//! A use case for the lock is to make sure that a particular section of the
+//! code is only run by one Off-chain Worker at a time. This may include
+//! performing a side-effect (i.e. an HTTP call) or alteration of single or
+//! multiple Local Storage entries.
+//!
+//! One use case would be collective updates of multiple data items or append /
+//! remove of i.e. sets, vectors which are stored in the off-chain storage DB.
+//!
+//! ## Example:
+//!
+//! ```rust
+//! # use codec::{Decode, Encode, Codec};
+//! // in your off-chain worker code
+//! use sp_runtime::offchain::{
+//! 		storage::StorageValueRef,
+//! 		storage_lock::{StorageLock, Time},
+//! };
+//!
+//! fn append_to_in_storage_vec<'a, T>(key: &'a [u8], _: T) where T: Codec {
+//!    // `access::lock` defines the storage entry which is used for
+//!    // persisting the lock in the underlying database.
+//!    // The entry name _must_ be unique and can be interpreted as a
+//!    // unique mutex instance reference tag.
+//!    let mut lock = StorageLock::<Time>::new(b"access::lock");
+//!    {
+//!         let _guard = lock.lock();
+//!         let acc = StorageValueRef::persistent(key);
+//!         let v: Vec<T> = acc.get::<Vec<T>>().unwrap().unwrap();
+//!         // modify `v` as desired
+//!         // i.e. perform some heavy computation with
+//!         // side effects that should only be done once.
+//!         acc.set(&v);
+//!         // drop `_guard` implicitly at end of scope
+//!    }
+//! }
+//! ```
+
+use crate::{
+	offchain::storage::{MutateStorageError, StorageRetrievalError, StorageValueRef},
+	traits::BlockNumberProvider,
+};
+use codec::{Codec, Decode, Encode};
+use sp_core::offchain::{Duration, Timestamp};
+use sp_io::offchain;
+use sp_std::fmt;
+
+/// Default expiry duration for time based locks in milliseconds.
+const STORAGE_LOCK_DEFAULT_EXPIRY_DURATION: Duration = Duration::from_millis(20_000);
+
+/// Default expiry duration for block based locks in blocks.
+const STORAGE_LOCK_DEFAULT_EXPIRY_BLOCKS: u32 = 4;
+
+/// Time between checks if the lock is still being held in milliseconds.
+const STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MIN: Duration = Duration::from_millis(10);
+const STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX: Duration = Duration::from_millis(100);
+
+/// Lockable item for use with a persisted storage lock.
+///
+/// Bound for an item that has a stateful ordered meaning
+/// without explicitly requiring `Ord` trait in general.
+pub trait Lockable: Sized {
+	/// An instant type specifying i.e. a point in time.
+	type Deadline: Sized + Codec + Clone;
+
+	/// Calculate the deadline based on a current state
+	/// such as time or block number and derives the deadline.
+	fn deadline(&self) -> Self::Deadline;
+
+	/// Verify the deadline has not expired compared to the
+	/// current state, i.e. time or block number.
+	fn has_expired(deadline: &Self::Deadline) -> bool;
+
+	/// Snooze at least until `deadline` is reached.
+	///
+	/// Note that `deadline` is only passed to allow optimizations
+	/// for `Lockables` which have a time based component.
+	fn snooze(_deadline: &Self::Deadline) {
+		sp_io::offchain::sleep_until(
+			offchain::timestamp().add(STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX),
+		);
+	}
+}
+
+/// Lockable based on the current timestamp with a configurable expiration time.
+#[derive(Encode, Decode)]
+pub struct Time {
+	/// How long the lock will stay valid once `fn lock(..)` or
+	/// `fn try_lock(..)` successfully acquire a lock.
+	expiration_duration: Duration,
+}
+
+impl Default for Time {
+	fn default() -> Self {
+		Self { expiration_duration: STORAGE_LOCK_DEFAULT_EXPIRY_DURATION }
+	}
+}
+
+impl Lockable for Time {
+	type Deadline = Timestamp;
+
+	fn deadline(&self) -> Self::Deadline {
+		offchain::timestamp().add(self.expiration_duration)
+	}
+
+	fn has_expired(deadline: &Self::Deadline) -> bool {
+		offchain::timestamp() > *deadline
+	}
+
+	fn snooze(deadline: &Self::Deadline) {
+		let now = offchain::timestamp();
+		let remainder: Duration = now.diff(deadline);
+		// do not snooze the full duration, but instead snooze max 100ms
+		// it might get unlocked in another thread
+		let snooze = remainder.clamp(
+			STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MIN,
+			STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX,
+		);
+		sp_io::offchain::sleep_until(now.add(snooze));
+	}
+}
+
+/// A deadline based on block number and time.
+#[derive(Encode, Decode, Eq, PartialEq)]
+pub struct BlockAndTimeDeadline<B: BlockNumberProvider> {
+	/// The block number until which the lock is still valid _at least_.
+	pub block_number: <B as BlockNumberProvider>::BlockNumber,
+	/// The timestamp until which the lock is still valid _at least_.
+	pub timestamp: Timestamp,
+}
+
+impl<B: BlockNumberProvider> Clone for BlockAndTimeDeadline<B> {
+	fn clone(&self) -> Self {
+		Self { block_number: self.block_number.clone(), timestamp: self.timestamp }
+	}
+}
+
+impl<B: BlockNumberProvider> Default for BlockAndTimeDeadline<B> {
+	/// Provide the current state of block number and time.
+	fn default() -> Self {
+		Self {
+			block_number: B::current_block_number() + STORAGE_LOCK_DEFAULT_EXPIRY_BLOCKS.into(),
+			timestamp: offchain::timestamp().add(STORAGE_LOCK_DEFAULT_EXPIRY_DURATION),
+		}
+	}
+}
+
+impl<B: BlockNumberProvider> fmt::Debug for BlockAndTimeDeadline<B>
+where
+	<B as BlockNumberProvider>::BlockNumber: fmt::Debug,
+{
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		f.debug_struct("BlockAndTimeDeadline")
+			.field("block_number", &self.block_number)
+			.field("timestamp", &self.timestamp)
+			.finish()
+	}
+}
+
+/// Lockable based on block number and timestamp.
+///
+/// Expiration is defined if both, block number _and_ timestamp
+/// expire.
+pub struct BlockAndTime<B: BlockNumberProvider> {
+	/// Relative block number offset, which is used to determine
+	/// the block number part of the deadline.
+	expiration_block_number_offset: u32,
+	/// Relative duration, used to derive the time based part of
+	/// the deadline.
+	expiration_duration: Duration,
+
+	_phantom: core::marker::PhantomData<B>,
+}
+
+impl<B: BlockNumberProvider> Default for BlockAndTime<B> {
+	fn default() -> Self {
+		Self {
+			expiration_block_number_offset: STORAGE_LOCK_DEFAULT_EXPIRY_BLOCKS,
+			expiration_duration: STORAGE_LOCK_DEFAULT_EXPIRY_DURATION,
+			_phantom: core::marker::PhantomData::<B>,
+		}
+	}
+}
+
+// derive not possible, since `B` does not necessarily implement `trait Clone`
+impl<B: BlockNumberProvider> Clone for BlockAndTime<B> {
+	fn clone(&self) -> Self {
+		Self {
+			expiration_block_number_offset: self.expiration_block_number_offset,
+			expiration_duration: self.expiration_duration,
+			_phantom: core::marker::PhantomData::<B>,
+		}
+	}
+}
+
+impl<B: BlockNumberProvider> Lockable for BlockAndTime<B> {
+	type Deadline = BlockAndTimeDeadline<B>;
+
+	fn deadline(&self) -> Self::Deadline {
+		let block_number = <B as BlockNumberProvider>::current_block_number() +
+			self.expiration_block_number_offset.into();
+		BlockAndTimeDeadline {
+			timestamp: offchain::timestamp().add(self.expiration_duration),
+			block_number,
+		}
+	}
+
+	fn has_expired(deadline: &Self::Deadline) -> bool {
+		offchain::timestamp() > deadline.timestamp &&
+			<B as BlockNumberProvider>::current_block_number() > deadline.block_number
+	}
+
+	fn snooze(deadline: &Self::Deadline) {
+		let now = offchain::timestamp();
+		let remainder: Duration = now.diff(&(deadline.timestamp));
+		let snooze = remainder.clamp(
+			STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MIN,
+			STORAGE_LOCK_PER_CHECK_ITERATION_SNOOZE_MAX,
+		);
+		sp_io::offchain::sleep_until(now.add(snooze));
+	}
+}
+
+/// Storage based lock.
+///
+/// A lock that is persisted in the DB and provides the ability to guard against
+/// concurrent access in an off-chain worker, with a defined expiry deadline
+/// based on the concrete [`Lockable`](Lockable) implementation.
+pub struct StorageLock<'a, L = Time> {
+	// A storage value ref which defines the DB entry representing the lock.
+	value_ref: StorageValueRef<'a>,
+	lockable: L,
+}
+
+impl<'a, L: Lockable + Default> StorageLock<'a, L> {
+	/// Create a new storage lock with a `default()` instance of type `L`.
+	pub fn new(key: &'a [u8]) -> Self {
+		Self::with_lockable(key, Default::default())
+	}
+}
+
+impl<'a, L: Lockable> StorageLock<'a, L> {
+	/// Create a new storage lock with an explicit instance of a lockable `L`.
+	pub fn with_lockable(key: &'a [u8], lockable: L) -> Self {
+		Self { value_ref: StorageValueRef::<'a>::persistent(key), lockable }
+	}
+
+	/// Extend active lock's deadline
+	fn extend_active_lock(&mut self) -> Result<<L as Lockable>::Deadline, ()> {
+		let res = self.value_ref.mutate(
+			|s: Result<Option<L::Deadline>, StorageRetrievalError>| -> Result<<L as Lockable>::Deadline, ()> {
+			match s {
+				// lock is present and is still active, extend the lock.
+				Ok(Some(deadline)) if !<L as Lockable>::has_expired(&deadline) =>
+					Ok(self.lockable.deadline()),
+				// other cases
+				_ => Err(()),
+			}
+		});
+		match res {
+			Ok(deadline) => Ok(deadline),
+			Err(MutateStorageError::ConcurrentModification(_)) => Err(()),
+			Err(MutateStorageError::ValueFunctionFailed(e)) => Err(e),
+		}
+	}
+
+	/// Internal lock helper to avoid lifetime conflicts.
+	fn try_lock_inner(
+		&mut self,
+		new_deadline: L::Deadline,
+	) -> Result<(), <L as Lockable>::Deadline> {
+		let res = self.value_ref.mutate(
+			|s: Result<Option<L::Deadline>, StorageRetrievalError>|
+			-> Result<<L as Lockable>::Deadline, <L as Lockable>::Deadline> {
+				match s {
+					// no lock set, we can safely acquire it
+					Ok(None) => Ok(new_deadline),
+					// write was good, but read failed
+					Err(_) => Ok(new_deadline),
+					// lock is set, but it is expired. We can re-acquire it.
+					Ok(Some(deadline)) if <L as Lockable>::has_expired(&deadline) =>
+						Ok(new_deadline),
+					// lock is present and is still active
+					Ok(Some(deadline)) => Err(deadline),
+				}
+			},
+		);
+		match res {
+			Ok(_) => Ok(()),
+			Err(MutateStorageError::ConcurrentModification(deadline)) => Err(deadline),
+			Err(MutateStorageError::ValueFunctionFailed(e)) => Err(e),
+		}
+	}
+
+	/// A single attempt to lock using the storage entry.
+	///
+	/// Returns a lock guard on success, otherwise an error containing the
+	/// `<Self::Lockable>::Deadline` in for the currently active lock
+	/// by another task `Err(<L as Lockable>::Deadline)`.
+	pub fn try_lock(&mut self) -> Result<StorageLockGuard<'a, '_, L>, <L as Lockable>::Deadline> {
+		self.try_lock_inner(self.lockable.deadline())?;
+		Ok(StorageLockGuard::<'a, '_> { lock: Some(self) })
+	}
+
+	/// Repeated lock attempts until the lock is successfully acquired.
+	///
+	/// If one uses `fn forget(..)`, it is highly likely `fn try_lock(..)`
+	/// is the correct API to use instead of `fn lock(..)`, since that might
+	/// never unlock in the anticipated span i.e. when used with `BlockAndTime`
+	/// during a certain block number span.
+	pub fn lock(&mut self) -> StorageLockGuard<'a, '_, L> {
+		while let Err(deadline) = self.try_lock_inner(self.lockable.deadline()) {
+			L::snooze(&deadline);
+		}
+		StorageLockGuard::<'a, '_, L> { lock: Some(self) }
+	}
+
+	/// Explicitly unlock the lock.
+	fn unlock(&mut self) {
+		self.value_ref.clear();
+	}
+}
+
+/// RAII style guard for a lock.
+pub struct StorageLockGuard<'a, 'b, L: Lockable> {
+	lock: Option<&'b mut StorageLock<'a, L>>,
+}
+
+impl<'a, 'b, L: Lockable> StorageLockGuard<'a, 'b, L> {
+	/// Consume the guard but **do not** unlock the underlying lock.
+	///
+	/// Can be used to implement a grace period after doing some
+	/// heavy computations and sending a transaction to be included
+	/// on-chain. By forgetting the lock, it will stay locked until
+	/// its expiration deadline is reached while the off-chain worker
+	/// can already exit.
+	pub fn forget(mut self) {
+		let _ = self.lock.take();
+	}
+
+	/// Extend the lock by guard deadline if it already exists.
+	///
+	/// i.e. large sets of items for which it is hard to calculate a
+	/// meaning full conservative deadline which does not block for a
+	/// very long time on node termination.
+	pub fn extend_lock(&mut self) -> Result<<L as Lockable>::Deadline, ()> {
+		if let Some(ref mut lock) = self.lock {
+			lock.extend_active_lock()
+		} else {
+			Err(())
+		}
+	}
+}
+
+impl<'a, 'b, L: Lockable> Drop for StorageLockGuard<'a, 'b, L> {
+	fn drop(&mut self) {
+		if let Some(lock) = self.lock.take() {
+			lock.unlock();
+		}
+	}
+}
+
+impl<'a> StorageLock<'a, Time> {
+	/// Explicitly create a time based storage lock with a non-default
+	/// expiration timeout.
+	pub fn with_deadline(key: &'a [u8], expiration_duration: Duration) -> Self {
+		Self {
+			value_ref: StorageValueRef::<'a>::persistent(key),
+			lockable: Time { expiration_duration },
+		}
+	}
+}
+
+impl<'a, B> StorageLock<'a, BlockAndTime<B>>
+where
+	B: BlockNumberProvider,
+{
+	/// Explicitly create a time and block number based storage lock with
+	/// a non-default expiration duration and block number offset.
+	pub fn with_block_and_time_deadline(
+		key: &'a [u8],
+		expiration_block_number_offset: u32,
+		expiration_duration: Duration,
+	) -> Self {
+		Self {
+			value_ref: StorageValueRef::<'a>::persistent(key),
+			lockable: BlockAndTime::<B> {
+				expiration_block_number_offset,
+				expiration_duration,
+				_phantom: core::marker::PhantomData,
+			},
+		}
+	}
+
+	/// Explicitly create a time and block number based storage lock with
+	/// the default expiration duration and a non-default block number offset.
+	pub fn with_block_deadline(key: &'a [u8], expiration_block_number_offset: u32) -> Self {
+		Self {
+			value_ref: StorageValueRef::<'a>::persistent(key),
+			lockable: BlockAndTime::<B> {
+				expiration_block_number_offset,
+				expiration_duration: STORAGE_LOCK_DEFAULT_EXPIRY_DURATION,
+				_phantom: core::marker::PhantomData,
+			},
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::offchain::{testing, OffchainDbExt, OffchainWorkerExt};
+	use sp_io::TestExternalities;
+
+	const VAL_1: u32 = 0u32;
+	const VAL_2: u32 = 0xFFFF_FFFFu32;
+
+	#[test]
+	fn storage_lock_write_unlock_lock_read_unlock() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain.clone()));
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let mut lock = StorageLock::<'_, Time>::new(b"lock_1");
+
+			let val = StorageValueRef::persistent(b"protected_value");
+
+			{
+				let _guard = lock.lock();
+
+				val.set(&VAL_1);
+
+				assert_eq!(val.get::<u32>(), Ok(Some(VAL_1)));
+			}
+
+			{
+				let _guard = lock.lock();
+				val.set(&VAL_2);
+
+				assert_eq!(val.get::<u32>(), Ok(Some(VAL_2)));
+			}
+		});
+		// lock must have been cleared at this point
+		assert_eq!(state.read().persistent_storage.get(b"lock_1"), None);
+	}
+
+	#[test]
+	fn storage_lock_and_forget() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain.clone()));
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let mut lock = StorageLock::<'_, Time>::new(b"lock_2");
+
+			let val = StorageValueRef::persistent(b"protected_value");
+
+			let guard = lock.lock();
+
+			val.set(&VAL_1);
+
+			assert_eq!(val.get::<u32>(), Ok(Some(VAL_1)));
+
+			guard.forget();
+		});
+		// lock must have been cleared at this point
+		let opt = state.read().persistent_storage.get(b"lock_2");
+		assert!(opt.is_some());
+	}
+
+	#[test]
+	fn storage_lock_and_let_expire_and_lock_again() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain.clone()));
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let sleep_until = offchain::timestamp().add(Duration::from_millis(500));
+			let lock_expiration = Duration::from_millis(200);
+
+			let mut lock = StorageLock::<'_, Time>::with_deadline(b"lock_3", lock_expiration);
+
+			{
+				let guard = lock.lock();
+				guard.forget();
+			}
+
+			// assure the lock expires
+			offchain::sleep_until(sleep_until);
+
+			let mut lock = StorageLock::<'_, Time>::new(b"lock_3");
+			let res = lock.try_lock();
+			assert!(res.is_ok());
+			let guard = res.unwrap();
+			guard.forget();
+		});
+
+		// lock must have been cleared at this point
+		let opt = state.read().persistent_storage.get(b"lock_3");
+		assert!(opt.is_some());
+	}
+
+	#[test]
+	fn extend_active_lock() {
+		let (offchain, state) = testing::TestOffchainExt::new();
+		let mut t = TestExternalities::default();
+		t.register_extension(OffchainDbExt::new(offchain.clone()));
+		t.register_extension(OffchainWorkerExt::new(offchain));
+
+		t.execute_with(|| {
+			let lock_expiration = Duration::from_millis(300);
+
+			let mut lock = StorageLock::<'_, Time>::with_deadline(b"lock_4", lock_expiration);
+			let mut guard = lock.lock();
+
+			// sleep_until < lock_expiration
+			offchain::sleep_until(offchain::timestamp().add(Duration::from_millis(200)));
+
+			// the lock is still active, extend it successfully
+			assert_eq!(guard.extend_lock().is_ok(), true);
+
+			// sleep_until < deadline
+			offchain::sleep_until(offchain::timestamp().add(Duration::from_millis(200)));
+
+			// the lock is still active, try_lock will fail
+			let mut lock = StorageLock::<'_, Time>::with_deadline(b"lock_4", lock_expiration);
+			let res = lock.try_lock();
+			assert_eq!(res.is_ok(), false);
+
+			// sleep again untill sleep_until > deadline
+			offchain::sleep_until(offchain::timestamp().add(Duration::from_millis(200)));
+
+			// the lock has expired, failed to extend it
+			assert_eq!(guard.extend_lock().is_ok(), false);
+			guard.forget();
+
+			// try_lock will succeed
+			let mut lock = StorageLock::<'_, Time>::with_deadline(b"lock_4", lock_expiration);
+			let res = lock.try_lock();
+			assert!(res.is_ok());
+			let guard = res.unwrap();
+
+			guard.forget();
+		});
+
+		// lock must have been cleared at this point
+		let opt = state.read().persistent_storage.get(b"lock_4");
+		assert_eq!(opt.unwrap(), vec![132_u8, 3u8, 0, 0, 0, 0, 0, 0]); // 132 + 256 * 3 = 900
+	}
+}
diff --git a/substrate/primitives/runtime/src/runtime_logger.rs b/substrate/primitives/runtime/src/runtime_logger.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b7374b8b6f6c8c40950d977f51bdc4b482441ac5
--- /dev/null
+++ b/substrate/primitives/runtime/src/runtime_logger.rs
@@ -0,0 +1,100 @@
+// 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 logger that can be used to log from the runtime.
+//!
+//! See [`RuntimeLogger`] for more docs.
+
+/// Runtime logger implementation - `log` crate backend.
+///
+/// The logger should be initialized if you want to display
+/// logs inside the runtime that is not necessarily running natively.
+pub struct RuntimeLogger;
+
+impl RuntimeLogger {
+	/// Initialize the logger.
+	///
+	/// This is a no-op when running natively (`std`).
+	#[cfg(feature = "std")]
+	pub fn init() {}
+
+	/// Initialize the logger.
+	///
+	/// This is a no-op when running natively (`std`).
+	#[cfg(not(feature = "std"))]
+	pub fn init() {
+		static LOGGER: RuntimeLogger = RuntimeLogger;
+		let _ = log::set_logger(&LOGGER);
+
+		// Use the same max log level as used by the host.
+		log::set_max_level(sp_io::logging::max_level().into());
+	}
+}
+
+impl log::Log for RuntimeLogger {
+	fn enabled(&self, _: &log::Metadata) -> bool {
+		// The final filtering is done by the host. This is not perfect, as we would still call into
+		// the host for log lines that will be thrown away.
+		true
+	}
+
+	fn log(&self, record: &log::Record) {
+		use sp_std::fmt::Write;
+		let mut w = sp_std::Writer::default();
+		let _ = ::core::write!(&mut w, "{}", record.args());
+
+		sp_io::logging::log(record.level().into(), record.target(), w.inner());
+	}
+
+	fn flush(&self) {}
+}
+
+#[cfg(test)]
+mod tests {
+	use sp_api::ProvideRuntimeApi;
+	use std::{env, str::FromStr};
+	use substrate_test_runtime_client::{
+		runtime::TestAPI, DefaultTestClientBuilderExt, TestClientBuilder, TestClientBuilderExt,
+	};
+
+	#[test]
+	fn ensure_runtime_logger_respects_host_max_log_level() {
+		if env::var("RUN_TEST").is_ok() {
+			sp_tracing::try_init_simple();
+			log::set_max_level(log::LevelFilter::from_str(&env::var("RUST_LOG").unwrap()).unwrap());
+
+			let client = TestClientBuilder::new().build();
+			let runtime_api = client.runtime_api();
+			runtime_api
+				.do_trace_log(client.chain_info().genesis_hash)
+				.expect("Logging should not fail");
+		} else {
+			for (level, should_print) in &[("trace", true), ("info", false)] {
+				let executable = std::env::current_exe().unwrap();
+				let output = std::process::Command::new(executable)
+					.env("RUN_TEST", "1")
+					.env("RUST_LOG", level)
+					.args(&["--nocapture", "ensure_runtime_logger_respects_host_max_log_level"])
+					.output()
+					.unwrap();
+
+				let output = String::from_utf8(output.stderr).unwrap();
+				assert!(output.contains("Hey I'm runtime") == *should_print);
+			}
+		}
+	}
+}
diff --git a/substrate/primitives/runtime/src/runtime_string.rs b/substrate/primitives/runtime/src/runtime_string.rs
new file mode 100644
index 0000000000000000000000000000000000000000..aa0bd52e56fe49a96bd2bd4ea87bf0d62ee2be34
--- /dev/null
+++ b/substrate/primitives/runtime/src/runtime_string.rs
@@ -0,0 +1,155 @@
+// 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 codec::{Decode, Encode};
+use sp_core::RuntimeDebug;
+use sp_std::vec::Vec;
+
+/// A string that wraps a `&'static str` in the runtime and `String`/`Vec<u8>` on decode.
+#[derive(Eq, RuntimeDebug, Clone)]
+pub enum RuntimeString {
+	/// The borrowed mode that wraps a `&'static str`.
+	Borrowed(&'static str),
+	/// The owned mode that wraps a `String`.
+	#[cfg(feature = "std")]
+	Owned(String),
+	/// The owned mode that wraps a `Vec<u8>`.
+	#[cfg(not(feature = "std"))]
+	Owned(Vec<u8>),
+}
+
+impl scale_info::TypeInfo for RuntimeString {
+	type Identity = str;
+
+	fn type_info() -> scale_info::Type {
+		Self::Identity::type_info()
+	}
+}
+
+/// Convenience macro to use the format! interface to get a `RuntimeString::Owned`
+#[macro_export]
+macro_rules! format_runtime_string {
+	($($args:tt)*) => {{
+		#[cfg(feature = "std")]
+		{
+			sp_runtime::RuntimeString::Owned(format!($($args)*))
+		}
+		#[cfg(not(feature = "std"))]
+		{
+			sp_runtime::RuntimeString::Owned(sp_std::alloc::format!($($args)*).as_bytes().to_vec())
+		}
+	}};
+}
+
+impl From<&'static str> for RuntimeString {
+	fn from(data: &'static str) -> Self {
+		Self::Borrowed(data)
+	}
+}
+
+#[cfg(feature = "std")]
+impl From<RuntimeString> for String {
+	fn from(string: RuntimeString) -> Self {
+		match string {
+			RuntimeString::Borrowed(data) => data.to_owned(),
+			RuntimeString::Owned(data) => data,
+		}
+	}
+}
+
+impl Default for RuntimeString {
+	fn default() -> Self {
+		Self::Borrowed(Default::default())
+	}
+}
+
+impl PartialEq for RuntimeString {
+	fn eq(&self, other: &Self) -> bool {
+		self.as_ref() == other.as_ref()
+	}
+}
+
+impl AsRef<[u8]> for RuntimeString {
+	fn as_ref(&self) -> &[u8] {
+		match self {
+			Self::Borrowed(val) => val.as_ref(),
+			Self::Owned(val) => val.as_ref(),
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::ops::Deref for RuntimeString {
+	type Target = str;
+
+	fn deref(&self) -> &str {
+		match self {
+			Self::Borrowed(val) => val,
+			Self::Owned(val) => val,
+		}
+	}
+}
+
+impl Encode for RuntimeString {
+	fn encode(&self) -> Vec<u8> {
+		match self {
+			Self::Borrowed(val) => val.encode(),
+			Self::Owned(val) => val.encode(),
+		}
+	}
+}
+
+impl Decode for RuntimeString {
+	fn decode<I: codec::Input>(value: &mut I) -> Result<Self, codec::Error> {
+		Decode::decode(value).map(Self::Owned)
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for RuntimeString {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		match self {
+			Self::Borrowed(val) => write!(f, "{}", val),
+			Self::Owned(val) => write!(f, "{}", val),
+		}
+	}
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for RuntimeString {
+	fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+		match self {
+			Self::Borrowed(val) => val.serialize(serializer),
+			Self::Owned(val) => val.serialize(serializer),
+		}
+	}
+}
+
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for RuntimeString {
+	fn deserialize<D: serde::Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
+		Ok(Self::Owned(serde::Deserialize::deserialize(de)?))
+	}
+}
+
+/// Create a const [`RuntimeString`].
+#[macro_export]
+macro_rules! create_runtime_str {
+	( $y:expr ) => {{
+		$crate::RuntimeString::Borrowed($y)
+	}};
+}
diff --git a/substrate/primitives/runtime/src/testing.rs b/substrate/primitives/runtime/src/testing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5f94c834a8f295bee945e9d772019e12ed37c828
--- /dev/null
+++ b/substrate/primitives/runtime/src/testing.rs
@@ -0,0 +1,421 @@
+// 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.
+
+//! Testing utilities.
+
+use crate::{
+	codec::{Codec, Decode, Encode, MaxEncodedLen},
+	generic,
+	scale_info::TypeInfo,
+	traits::{
+		self, Applyable, BlakeTwo256, Checkable, DispatchInfoOf, Dispatchable, OpaqueKeys,
+		PostDispatchInfoOf, SignaturePayload, SignedExtension, ValidateUnsigned,
+	},
+	transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError},
+	ApplyExtrinsicResultWithInfo, KeyTypeId,
+};
+use serde::{de::Error as DeError, Deserialize, Deserializer, Serialize, Serializer};
+use sp_core::{
+	crypto::{key_types, ByteArray, CryptoType, Dummy},
+	U256,
+};
+pub use sp_core::{sr25519, H256};
+use std::{
+	cell::RefCell,
+	fmt::{self, Debug},
+	ops::Deref,
+};
+
+/// A dummy type which can be used instead of regular cryptographic primitives.
+///
+/// 1. Wraps a `u64` `AccountId` and is able to `IdentifyAccount`.
+/// 2. Can be converted to any `Public` key.
+/// 3. Implements `RuntimeAppPublic` so it can be used instead of regular application-specific
+///    crypto.
+#[derive(
+	Default,
+	PartialEq,
+	Eq,
+	Clone,
+	Encode,
+	Decode,
+	Debug,
+	Hash,
+	Serialize,
+	Deserialize,
+	PartialOrd,
+	Ord,
+	MaxEncodedLen,
+	TypeInfo,
+)]
+pub struct UintAuthorityId(pub u64);
+
+impl From<u64> for UintAuthorityId {
+	fn from(id: u64) -> Self {
+		UintAuthorityId(id)
+	}
+}
+
+impl From<UintAuthorityId> for u64 {
+	fn from(id: UintAuthorityId) -> u64 {
+		id.0
+	}
+}
+
+impl UintAuthorityId {
+	/// Convert this authority ID into a public key.
+	pub fn to_public_key<T: ByteArray>(&self) -> T {
+		let bytes: [u8; 32] = U256::from(self.0).into();
+		T::from_slice(&bytes).unwrap()
+	}
+}
+
+impl CryptoType for UintAuthorityId {
+	type Pair = Dummy;
+}
+
+impl AsRef<[u8]> for UintAuthorityId {
+	fn as_ref(&self) -> &[u8] {
+		// Unsafe, i know, but it's test code and it's just there because it's really convenient to
+		// keep `UintAuthorityId` as a u64 under the hood.
+		unsafe {
+			std::slice::from_raw_parts(
+				&self.0 as *const u64 as *const _,
+				std::mem::size_of::<u64>(),
+			)
+		}
+	}
+}
+
+thread_local! {
+	/// A list of all UintAuthorityId keys returned to the runtime.
+	static ALL_KEYS: RefCell<Vec<UintAuthorityId>> = RefCell::new(vec![]);
+}
+
+impl UintAuthorityId {
+	/// Set the list of keys returned by the runtime call for all keys of that type.
+	pub fn set_all_keys<T: Into<UintAuthorityId>>(keys: impl IntoIterator<Item = T>) {
+		ALL_KEYS.with(|l| *l.borrow_mut() = keys.into_iter().map(Into::into).collect())
+	}
+}
+
+impl sp_application_crypto::RuntimeAppPublic for UintAuthorityId {
+	const ID: KeyTypeId = key_types::DUMMY;
+
+	type Signature = TestSignature;
+
+	fn all() -> Vec<Self> {
+		ALL_KEYS.with(|l| l.borrow().clone())
+	}
+
+	fn generate_pair(_: Option<Vec<u8>>) -> Self {
+		use rand::RngCore;
+		UintAuthorityId(rand::thread_rng().next_u64())
+	}
+
+	fn sign<M: AsRef<[u8]>>(&self, msg: &M) -> Option<Self::Signature> {
+		Some(TestSignature(self.0, msg.as_ref().to_vec()))
+	}
+
+	fn verify<M: AsRef<[u8]>>(&self, msg: &M, signature: &Self::Signature) -> bool {
+		traits::Verify::verify(signature, msg.as_ref(), &self.0)
+	}
+
+	fn to_raw_vec(&self) -> Vec<u8> {
+		AsRef::<[u8]>::as_ref(self).to_vec()
+	}
+}
+
+impl OpaqueKeys for UintAuthorityId {
+	type KeyTypeIdProviders = ();
+
+	fn key_ids() -> &'static [KeyTypeId] {
+		&[key_types::DUMMY]
+	}
+
+	fn get_raw(&self, _: KeyTypeId) -> &[u8] {
+		self.as_ref()
+	}
+
+	fn get<T: Decode>(&self, _: KeyTypeId) -> Option<T> {
+		self.using_encoded(|mut x| T::decode(&mut x)).ok()
+	}
+}
+
+impl traits::IdentifyAccount for UintAuthorityId {
+	type AccountId = u64;
+
+	fn into_account(self) -> Self::AccountId {
+		self.0
+	}
+}
+
+/// A dummy signature type, to match `UintAuthorityId`.
+#[derive(Eq, PartialEq, Clone, Debug, Hash, Serialize, Deserialize, Encode, Decode, TypeInfo)]
+pub struct TestSignature(pub u64, pub Vec<u8>);
+
+impl traits::Verify for TestSignature {
+	type Signer = UintAuthorityId;
+
+	fn verify<L: traits::Lazy<[u8]>>(&self, mut msg: L, signer: &u64) -> bool {
+		signer == &self.0 && msg.get() == &self.1[..]
+	}
+}
+
+/// Digest item
+pub type DigestItem = generic::DigestItem;
+
+/// Header Digest
+pub type Digest = generic::Digest;
+
+/// Block Header
+pub type Header = generic::Header<u64, BlakeTwo256>;
+
+impl Header {
+	/// A new header with the given number and default hash for all other fields.
+	pub fn new_from_number(number: <Self as traits::Header>::Number) -> Self {
+		Self {
+			number,
+			extrinsics_root: Default::default(),
+			state_root: Default::default(),
+			parent_hash: Default::default(),
+			digest: Default::default(),
+		}
+	}
+}
+
+/// An opaque extrinsic wrapper type.
+#[derive(PartialEq, Eq, Clone, Debug, Encode, Decode)]
+pub struct ExtrinsicWrapper<Xt>(Xt);
+
+impl<Xt> traits::Extrinsic for ExtrinsicWrapper<Xt> {
+	type Call = ();
+	type SignaturePayload = ();
+
+	fn is_signed(&self) -> Option<bool> {
+		None
+	}
+}
+
+impl<Xt: Encode> serde::Serialize for ExtrinsicWrapper<Xt> {
+	fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>
+	where
+		S: ::serde::Serializer,
+	{
+		self.using_encoded(|bytes| seq.serialize_bytes(bytes))
+	}
+}
+
+impl<Xt> From<Xt> for ExtrinsicWrapper<Xt> {
+	fn from(xt: Xt) -> Self {
+		ExtrinsicWrapper(xt)
+	}
+}
+
+impl<Xt> Deref for ExtrinsicWrapper<Xt> {
+	type Target = Xt;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+/// Testing block
+#[derive(PartialEq, Eq, Clone, Serialize, Debug, Encode, Decode, TypeInfo)]
+pub struct Block<Xt> {
+	/// Block header
+	pub header: Header,
+	/// List of extrinsics
+	pub extrinsics: Vec<Xt>,
+}
+
+impl<Xt> traits::HeaderProvider for Block<Xt> {
+	type HeaderT = Header;
+}
+
+impl<
+		Xt: 'static + Codec + Sized + Send + Sync + Serialize + Clone + Eq + Debug + traits::Extrinsic,
+	> traits::Block for Block<Xt>
+{
+	type Extrinsic = Xt;
+	type Header = Header;
+	type Hash = <Header as traits::Header>::Hash;
+
+	fn header(&self) -> &Self::Header {
+		&self.header
+	}
+	fn extrinsics(&self) -> &[Self::Extrinsic] {
+		&self.extrinsics[..]
+	}
+	fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>) {
+		(self.header, self.extrinsics)
+	}
+	fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self {
+		Block { header, extrinsics }
+	}
+	fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8> {
+		(header, extrinsics).encode()
+	}
+}
+
+impl<'a, Xt> Deserialize<'a> for Block<Xt>
+where
+	Block<Xt>: Decode,
+{
+	fn deserialize<D: Deserializer<'a>>(de: D) -> Result<Self, D::Error> {
+		let r = <Vec<u8>>::deserialize(de)?;
+		Decode::decode(&mut &r[..])
+			.map_err(|e| DeError::custom(format!("Invalid value passed into decode: {}", e)))
+	}
+}
+
+/// The signature payload of a `TestXt`.
+type TxSingaturePayload<Extra> = (u64, Extra);
+
+impl<Extra: TypeInfo> SignaturePayload for TxSingaturePayload<Extra> {
+	type SignatureAddress = u64;
+	type Signature = ();
+	type SignatureExtra = Extra;
+}
+
+/// Test transaction, tuple of (sender, call, signed_extra)
+/// with index only used if sender is some.
+///
+/// If sender is some then the transaction is signed otherwise it is unsigned.
+#[derive(PartialEq, Eq, Clone, Encode, Decode, TypeInfo)]
+pub struct TestXt<Call, Extra> {
+	/// Signature of the extrinsic.
+	pub signature: Option<TxSingaturePayload<Extra>>,
+	/// Call of the extrinsic.
+	pub call: Call,
+}
+
+impl<Call, Extra> TestXt<Call, Extra> {
+	/// Create a new `TextXt`.
+	pub fn new(call: Call, signature: Option<(u64, Extra)>) -> Self {
+		Self { call, signature }
+	}
+}
+
+impl<Call, Extra> Serialize for TestXt<Call, Extra>
+where
+	TestXt<Call, Extra>: Encode,
+{
+	fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		self.using_encoded(|bytes| seq.serialize_bytes(bytes))
+	}
+}
+
+impl<Call, Extra> Debug for TestXt<Call, Extra> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(f, "TestXt({:?}, ...)", self.signature.as_ref().map(|x| &x.0))
+	}
+}
+
+impl<Call: Codec + Sync + Send, Context, Extra> Checkable<Context> for TestXt<Call, Extra> {
+	type Checked = Self;
+	fn check(self, _: &Context) -> Result<Self::Checked, TransactionValidityError> {
+		Ok(self)
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn unchecked_into_checked_i_know_what_i_am_doing(
+		self,
+		_: &Context,
+	) -> Result<Self::Checked, TransactionValidityError> {
+		unreachable!()
+	}
+}
+
+impl<Call: Codec + Sync + Send + TypeInfo, Extra: TypeInfo> traits::Extrinsic
+	for TestXt<Call, Extra>
+{
+	type Call = Call;
+	type SignaturePayload = TxSingaturePayload<Extra>;
+
+	fn is_signed(&self) -> Option<bool> {
+		Some(self.signature.is_some())
+	}
+
+	fn new(c: Call, sig: Option<Self::SignaturePayload>) -> Option<Self> {
+		Some(TestXt { signature: sig, call: c })
+	}
+}
+
+impl<Call, Extra> traits::ExtrinsicMetadata for TestXt<Call, Extra>
+where
+	Call: Codec + Sync + Send,
+	Extra: SignedExtension<AccountId = u64, Call = Call>,
+{
+	type SignedExtensions = Extra;
+	const VERSION: u8 = 0u8;
+}
+
+impl<Origin, Call, Extra> Applyable for TestXt<Call, Extra>
+where
+	Call: 'static
+		+ Sized
+		+ Send
+		+ Sync
+		+ Clone
+		+ Eq
+		+ Codec
+		+ Debug
+		+ Dispatchable<RuntimeOrigin = Origin>,
+	Extra: SignedExtension<AccountId = u64, Call = Call>,
+	Origin: From<Option<u64>>,
+{
+	type Call = Call;
+
+	/// Checks to see if this is a valid *transaction*. It returns information on it if so.
+	fn validate<U: ValidateUnsigned<Call = Self::Call>>(
+		&self,
+		source: TransactionSource,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		if let Some((ref id, ref extra)) = self.signature {
+			Extra::validate(extra, id, &self.call, info, len)
+		} else {
+			let valid = Extra::validate_unsigned(&self.call, info, len)?;
+			let unsigned_validation = U::validate_unsigned(source, &self.call)?;
+			Ok(valid.combine_with(unsigned_validation))
+		}
+	}
+
+	/// Executes all necessary logic needed prior to dispatch and deconstructs into function call,
+	/// index and sender.
+	fn apply<U: ValidateUnsigned<Call = Self::Call>>(
+		self,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> ApplyExtrinsicResultWithInfo<PostDispatchInfoOf<Self::Call>> {
+		let maybe_who = if let Some((who, extra)) = self.signature {
+			Extra::pre_dispatch(extra, &who, &self.call, info, len)?;
+			Some(who)
+		} else {
+			Extra::pre_dispatch_unsigned(&self.call, info, len)?;
+			U::pre_dispatch(&self.call)?;
+			None
+		};
+
+		Ok(self.call.dispatch(maybe_who.into()))
+	}
+}
diff --git a/substrate/primitives/runtime/src/traits.rs b/substrate/primitives/runtime/src/traits.rs
new file mode 100644
index 0000000000000000000000000000000000000000..17dc7ce50ea8b90254c41c388b2adf550730cef4
--- /dev/null
+++ b/substrate/primitives/runtime/src/traits.rs
@@ -0,0 +1,2456 @@
+// 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.
+
+//! Primitives for the runtime modules.
+
+use crate::{
+	generic::Digest,
+	scale_info::{MetaType, StaticTypeInfo, TypeInfo},
+	transaction_validity::{
+		TransactionSource, TransactionValidity, TransactionValidityError, UnknownTransaction,
+		ValidTransaction,
+	},
+	DispatchResult,
+};
+use codec::{Codec, Decode, Encode, EncodeLike, FullCodec, MaxEncodedLen};
+use impl_trait_for_tuples::impl_for_tuples;
+#[cfg(feature = "serde")]
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use sp_application_crypto::AppCrypto;
+pub use sp_arithmetic::traits::{
+	checked_pow, ensure_pow, AtLeast32Bit, AtLeast32BitUnsigned, Bounded, CheckedAdd, CheckedDiv,
+	CheckedMul, CheckedShl, CheckedShr, CheckedSub, Ensure, EnsureAdd, EnsureAddAssign, EnsureDiv,
+	EnsureDivAssign, EnsureFixedPointNumber, EnsureFrom, EnsureInto, EnsureMul, EnsureMulAssign,
+	EnsureOp, EnsureOpAssign, EnsureSub, EnsureSubAssign, IntegerSquareRoot, One,
+	SaturatedConversion, Saturating, UniqueSaturatedFrom, UniqueSaturatedInto, Zero,
+};
+use sp_core::{self, storage::StateVersion, Hasher, RuntimeDebug, TypeId};
+#[doc(hidden)]
+pub use sp_core::{
+	parameter_types, ConstBool, ConstI128, ConstI16, ConstI32, ConstI64, ConstI8, ConstU128,
+	ConstU16, ConstU32, ConstU64, ConstU8, Get, GetDefault, TryCollect, TypedGet,
+};
+#[doc(hidden)]
+pub use sp_std::marker::PhantomData;
+use sp_std::{self, fmt::Debug, prelude::*};
+#[cfg(feature = "std")]
+use std::fmt::Display;
+#[cfg(feature = "std")]
+use std::str::FromStr;
+
+/// A lazy value.
+pub trait Lazy<T: ?Sized> {
+	/// Get a reference to the underlying value.
+	///
+	/// This will compute the value if the function is invoked for the first time.
+	fn get(&mut self) -> &T;
+}
+
+impl<'a> Lazy<[u8]> for &'a [u8] {
+	fn get(&mut self) -> &[u8] {
+		self
+	}
+}
+
+/// Some type that is able to be collapsed into an account ID. It is not possible to recreate the
+/// original value from the account ID.
+pub trait IdentifyAccount {
+	/// The account ID that this can be transformed into.
+	type AccountId;
+	/// Transform into an account.
+	fn into_account(self) -> Self::AccountId;
+}
+
+impl IdentifyAccount for sp_core::ed25519::Public {
+	type AccountId = Self;
+	fn into_account(self) -> Self {
+		self
+	}
+}
+
+impl IdentifyAccount for sp_core::sr25519::Public {
+	type AccountId = Self;
+	fn into_account(self) -> Self {
+		self
+	}
+}
+
+impl IdentifyAccount for sp_core::ecdsa::Public {
+	type AccountId = Self;
+	fn into_account(self) -> Self {
+		self
+	}
+}
+
+/// Means of signature verification.
+pub trait Verify {
+	/// Type of the signer.
+	type Signer: IdentifyAccount;
+	/// Verify a signature.
+	///
+	/// Return `true` if signature is valid for the value.
+	fn verify<L: Lazy<[u8]>>(
+		&self,
+		msg: L,
+		signer: &<Self::Signer as IdentifyAccount>::AccountId,
+	) -> bool;
+}
+
+impl Verify for sp_core::ed25519::Signature {
+	type Signer = sp_core::ed25519::Public;
+
+	fn verify<L: Lazy<[u8]>>(&self, mut msg: L, signer: &sp_core::ed25519::Public) -> bool {
+		sp_io::crypto::ed25519_verify(self, msg.get(), signer)
+	}
+}
+
+impl Verify for sp_core::sr25519::Signature {
+	type Signer = sp_core::sr25519::Public;
+
+	fn verify<L: Lazy<[u8]>>(&self, mut msg: L, signer: &sp_core::sr25519::Public) -> bool {
+		sp_io::crypto::sr25519_verify(self, msg.get(), signer)
+	}
+}
+
+impl Verify for sp_core::ecdsa::Signature {
+	type Signer = sp_core::ecdsa::Public;
+	fn verify<L: Lazy<[u8]>>(&self, mut msg: L, signer: &sp_core::ecdsa::Public) -> bool {
+		match sp_io::crypto::secp256k1_ecdsa_recover_compressed(
+			self.as_ref(),
+			&sp_io::hashing::blake2_256(msg.get()),
+		) {
+			Ok(pubkey) => signer.as_ref() == &pubkey[..],
+			_ => false,
+		}
+	}
+}
+
+/// Means of signature verification of an application key.
+pub trait AppVerify {
+	/// Type of the signer.
+	type AccountId;
+	/// Verify a signature. Return `true` if signature is valid for the value.
+	fn verify<L: Lazy<[u8]>>(&self, msg: L, signer: &Self::AccountId) -> bool;
+}
+
+impl<
+		S: Verify<Signer = <<T as AppCrypto>::Public as sp_application_crypto::AppPublic>::Generic>
+			+ From<T>,
+		T: sp_application_crypto::Wraps<Inner = S>
+			+ sp_application_crypto::AppCrypto
+			+ sp_application_crypto::AppSignature
+			+ AsRef<S>
+			+ AsMut<S>
+			+ From<S>,
+	> AppVerify for T
+where
+	<S as Verify>::Signer: IdentifyAccount<AccountId = <S as Verify>::Signer>,
+	<<T as AppCrypto>::Public as sp_application_crypto::AppPublic>::Generic: IdentifyAccount<
+		AccountId = <<T as AppCrypto>::Public as sp_application_crypto::AppPublic>::Generic,
+	>,
+{
+	type AccountId = <T as AppCrypto>::Public;
+	fn verify<L: Lazy<[u8]>>(&self, msg: L, signer: &<T as AppCrypto>::Public) -> bool {
+		use sp_application_crypto::IsWrappedBy;
+		let inner: &S = self.as_ref();
+		let inner_pubkey =
+			<<T as AppCrypto>::Public as sp_application_crypto::AppPublic>::Generic::from_ref(
+				signer,
+			);
+		Verify::verify(inner, msg, inner_pubkey)
+	}
+}
+
+/// An error type that indicates that the origin is invalid.
+#[derive(Encode, Decode, RuntimeDebug)]
+pub struct BadOrigin;
+
+impl From<BadOrigin> for &'static str {
+	fn from(_: BadOrigin) -> &'static str {
+		"Bad origin"
+	}
+}
+
+/// An error that indicates that a lookup failed.
+#[derive(Encode, Decode, RuntimeDebug)]
+pub struct LookupError;
+
+impl From<LookupError> for &'static str {
+	fn from(_: LookupError) -> &'static str {
+		"Can not lookup"
+	}
+}
+
+impl From<LookupError> for TransactionValidityError {
+	fn from(_: LookupError) -> Self {
+		UnknownTransaction::CannotLookup.into()
+	}
+}
+
+/// Means of changing one type into another in a manner dependent on the source type.
+pub trait Lookup {
+	/// Type to lookup from.
+	type Source;
+	/// Type to lookup into.
+	type Target;
+	/// Attempt a lookup.
+	fn lookup(&self, s: Self::Source) -> Result<Self::Target, LookupError>;
+}
+
+/// Means of changing one type into another in a manner dependent on the source type.
+/// This variant is different to `Lookup` in that it doesn't (can cannot) require any
+/// context.
+pub trait StaticLookup {
+	/// Type to lookup from.
+	type Source: Codec + Clone + PartialEq + Debug + TypeInfo;
+	/// Type to lookup into.
+	type Target;
+	/// Attempt a lookup.
+	fn lookup(s: Self::Source) -> Result<Self::Target, LookupError>;
+	/// Convert from Target back to Source.
+	fn unlookup(t: Self::Target) -> Self::Source;
+}
+
+/// A lookup implementation returning the input value.
+#[derive(Default)]
+pub struct IdentityLookup<T>(PhantomData<T>);
+impl<T: Codec + Clone + PartialEq + Debug + TypeInfo> StaticLookup for IdentityLookup<T> {
+	type Source = T;
+	type Target = T;
+	fn lookup(x: T) -> Result<T, LookupError> {
+		Ok(x)
+	}
+	fn unlookup(x: T) -> T {
+		x
+	}
+}
+
+impl<T> Lookup for IdentityLookup<T> {
+	type Source = T;
+	type Target = T;
+	fn lookup(&self, x: T) -> Result<T, LookupError> {
+		Ok(x)
+	}
+}
+
+/// A lookup implementation returning the `AccountId` from a `MultiAddress`.
+pub struct AccountIdLookup<AccountId, AccountIndex>(PhantomData<(AccountId, AccountIndex)>);
+impl<AccountId, AccountIndex> StaticLookup for AccountIdLookup<AccountId, AccountIndex>
+where
+	AccountId: Codec + Clone + PartialEq + Debug,
+	AccountIndex: Codec + Clone + PartialEq + Debug,
+	crate::MultiAddress<AccountId, AccountIndex>: Codec + StaticTypeInfo,
+{
+	type Source = crate::MultiAddress<AccountId, AccountIndex>;
+	type Target = AccountId;
+	fn lookup(x: Self::Source) -> Result<Self::Target, LookupError> {
+		match x {
+			crate::MultiAddress::Id(i) => Ok(i),
+			_ => Err(LookupError),
+		}
+	}
+	fn unlookup(x: Self::Target) -> Self::Source {
+		crate::MultiAddress::Id(x)
+	}
+}
+
+/// Perform a StaticLookup where there are multiple lookup sources of the same type.
+impl<A, B> StaticLookup for (A, B)
+where
+	A: StaticLookup,
+	B: StaticLookup<Source = A::Source, Target = A::Target>,
+{
+	type Source = A::Source;
+	type Target = A::Target;
+
+	fn lookup(x: Self::Source) -> Result<Self::Target, LookupError> {
+		A::lookup(x.clone()).or_else(|_| B::lookup(x))
+	}
+	fn unlookup(x: Self::Target) -> Self::Source {
+		A::unlookup(x)
+	}
+}
+
+/// Extensible conversion trait. Generic over only source type, with destination type being
+/// associated.
+pub trait Morph<A> {
+	/// The type into which `A` is mutated.
+	type Outcome;
+
+	/// Make conversion.
+	fn morph(a: A) -> Self::Outcome;
+}
+
+/// A structure that performs identity conversion.
+impl<T> Morph<T> for Identity {
+	type Outcome = T;
+	fn morph(a: T) -> T {
+		a
+	}
+}
+
+/// Extensible conversion trait. Generic over only source type, with destination type being
+/// associated.
+pub trait TryMorph<A> {
+	/// The type into which `A` is mutated.
+	type Outcome;
+
+	/// Make conversion.
+	fn try_morph(a: A) -> Result<Self::Outcome, ()>;
+}
+
+/// A structure that performs identity conversion.
+impl<T> TryMorph<T> for Identity {
+	type Outcome = T;
+	fn try_morph(a: T) -> Result<T, ()> {
+		Ok(a)
+	}
+}
+
+/// Implementation of `Morph` which converts between types using `Into`.
+pub struct MorphInto<T>(sp_std::marker::PhantomData<T>);
+impl<T, A: Into<T>> Morph<A> for MorphInto<T> {
+	type Outcome = T;
+	fn morph(a: A) -> T {
+		a.into()
+	}
+}
+
+/// Implementation of `TryMorph` which attmepts to convert between types using `TryInto`.
+pub struct TryMorphInto<T>(sp_std::marker::PhantomData<T>);
+impl<T, A: TryInto<T>> TryMorph<A> for TryMorphInto<T> {
+	type Outcome = T;
+	fn try_morph(a: A) -> Result<T, ()> {
+		a.try_into().map_err(|_| ())
+	}
+}
+
+/// Implementation of `Morph` to retrieve just the first element of a tuple.
+pub struct TakeFirst;
+impl<T1> Morph<(T1,)> for TakeFirst {
+	type Outcome = T1;
+	fn morph(a: (T1,)) -> T1 {
+		a.0
+	}
+}
+impl<T1, T2> Morph<(T1, T2)> for TakeFirst {
+	type Outcome = T1;
+	fn morph(a: (T1, T2)) -> T1 {
+		a.0
+	}
+}
+impl<T1, T2, T3> Morph<(T1, T2, T3)> for TakeFirst {
+	type Outcome = T1;
+	fn morph(a: (T1, T2, T3)) -> T1 {
+		a.0
+	}
+}
+impl<T1, T2, T3, T4> Morph<(T1, T2, T3, T4)> for TakeFirst {
+	type Outcome = T1;
+	fn morph(a: (T1, T2, T3, T4)) -> T1 {
+		a.0
+	}
+}
+
+/// Create a `Morph` and/or `TryMorph` impls with a simple closure-like expression.
+///
+/// # Examples
+///
+/// ```
+/// # use sp_runtime::{morph_types, traits::{Morph, TryMorph, TypedGet, ConstU32}};
+/// # use sp_arithmetic::traits::CheckedSub;
+///
+/// morph_types! {
+///    /// Replace by some other value; produce both `Morph` and `TryMorph` implementations
+///    pub type Replace<V: TypedGet> = |_| -> V::Type { V::get() };
+///    /// A private `Morph` implementation to reduce a `u32` by 10.
+///    type ReduceU32ByTen: Morph = |r: u32| -> u32 { r - 10 };
+///    /// A `TryMorph` implementation to reduce a scalar by a particular amount, checking for
+///    /// underflow.
+///    pub type CheckedReduceBy<N: TypedGet>: TryMorph = |r: N::Type| -> Result<N::Type, ()> {
+///        r.checked_sub(&N::get()).ok_or(())
+///    } where N::Type: CheckedSub;
+/// }
+///
+/// trait Config {
+///    type TestMorph1: Morph<u32>;
+///    type TestTryMorph1: TryMorph<u32>;
+///    type TestMorph2: Morph<u32>;
+///    type TestTryMorph2: TryMorph<u32>;
+/// }
+///
+/// struct Runtime;
+/// impl Config for Runtime {
+///    type TestMorph1 = Replace<ConstU32<42>>;
+///    type TestTryMorph1 = Replace<ConstU32<42>>;
+///    type TestMorph2 = ReduceU32ByTen;
+///    type TestTryMorph2 = CheckedReduceBy<ConstU32<10>>;
+/// }
+/// ```
+#[macro_export]
+macro_rules! morph_types {
+	(
+		@DECL $( #[doc = $doc:expr] )* $vq:vis $name:ident ()
+	) => {
+		$( #[doc = $doc] )* $vq struct $name;
+	};
+	(
+		@DECL $( #[doc = $doc:expr] )* $vq:vis $name:ident ( $( $bound_id:ident ),+ )
+	) => {
+		$( #[doc = $doc] )*
+		$vq struct $name < $($bound_id,)* > ( $crate::traits::PhantomData< ( $($bound_id,)* ) > ) ;
+	};
+	(
+		@IMPL $name:ty : ( $( $bounds:tt )* ) ( $( $where:tt )* )
+		= |$var:ident: $var_type:ty| -> $outcome:ty { $( $ex:expr )* }
+	) => {
+		impl<$($bounds)*> $crate::traits::Morph<$var_type> for $name $( $where )? {
+			type Outcome = $outcome;
+			fn morph($var: $var_type) -> Self::Outcome { $( $ex )* }
+		}
+	};
+	(
+		@IMPL_TRY $name:ty : ( $( $bounds:tt )* ) ( $( $where:tt )* )
+		= |$var:ident: $var_type:ty| -> $outcome:ty { $( $ex:expr )* }
+	) => {
+		impl<$($bounds)*> $crate::traits::TryMorph<$var_type> for $name $( $where )? {
+			type Outcome = $outcome;
+			fn try_morph($var: $var_type) -> Result<Self::Outcome, ()> { $( $ex )* }
+		}
+	};
+	(
+		@IMPL $name:ty : () ( $( $where:tt )* )
+		= |$var:ident: $var_type:ty| -> $outcome:ty { $( $ex:expr )* }
+	) => {
+		impl $crate::traits::Morph<$var_type> for $name $( $where )? {
+			type Outcome = $outcome;
+			fn morph($var: $var_type) -> Self::Outcome { $( $ex )* }
+		}
+	};
+	(
+		@IMPL_TRY $name:ty : () ( $( $where:tt )* )
+		= |$var:ident: $var_type:ty| -> $outcome:ty { $( $ex:expr )* }
+	) => {
+		impl $crate::traits::TryMorph<$var_type> for $name $( $where )? {
+			type Outcome = $outcome;
+			fn try_morph($var: $var_type) -> Result<Self::Outcome, ()> { $( $ex )* }
+		}
+	};
+	(
+		@IMPL_BOTH $name:ty : ( $( $bounds:tt )* ) ( $( $where:tt )* )
+		= |$var:ident: $var_type:ty| -> $outcome:ty { $( $ex:expr )* }
+	) => {
+		morph_types! {
+			@IMPL $name : ($($bounds)*) ($($where)*)
+			= |$var: $var_type| -> $outcome { $( $ex )* }
+		}
+		morph_types! {
+			@IMPL_TRY $name : ($($bounds)*) ($($where)*)
+			= |$var: $var_type| -> $outcome { Ok({$( $ex )*}) }
+		}
+	};
+
+	(
+		$( #[doc = $doc:expr] )* $vq:vis type $name:ident
+		$( < $( $bound_id:ident $( : $bound_head:path $( | $bound_tail:path )* )? ),+ > )?
+		$(: $type:tt)?
+		= |_| -> $outcome:ty { $( $ex:expr )* };
+		$( $rest:tt )*
+	) => {
+		morph_types! {
+			$( #[doc = $doc] )* $vq type $name
+			$( < $( $bound_id $( : $bound_head $( | $bound_tail )* )? ),+ > )?
+			EXTRA_GENERIC(X)
+			$(: $type)?
+			= |_x: X| -> $outcome { $( $ex )* };
+			$( $rest )*
+		}
+	};
+	(
+		$( #[doc = $doc:expr] )* $vq:vis type $name:ident
+		$( < $( $bound_id:ident $( : $bound_head:path $( | $bound_tail:path )* )? ),+ > )?
+		$( EXTRA_GENERIC ($extra:ident) )?
+		= |$var:ident: $var_type:ty| -> $outcome:ty { $( $ex:expr )* }
+		$( where $( $where_path:ty : $where_bound_head:path $( | $where_bound_tail:path )* ),* )?;
+		$( $rest:tt )*
+	) => {
+		morph_types! { @DECL $( #[doc = $doc] )* $vq $name ( $( $( $bound_id ),+ )? ) }
+		morph_types! {
+			@IMPL_BOTH $name $( < $( $bound_id ),* > )? :
+			( $( $( $bound_id $( : $bound_head $( + $bound_tail )* )? , )+ )? $( $extra )? )
+			( $( where $( $where_path : $where_bound_head $( + $where_bound_tail )* ),* )? )
+			= |$var: $var_type| -> $outcome { $( $ex )* }
+		}
+		morph_types!{ $($rest)* }
+	};
+	(
+		$( #[doc = $doc:expr] )* $vq:vis type $name:ident
+		$( < $( $bound_id:ident $( : $bound_head:path $( | $bound_tail:path )* )? ),+ > )?
+		$( EXTRA_GENERIC ($extra:ident) )?
+		: Morph
+		= |$var:ident: $var_type:ty| -> $outcome:ty { $( $ex:expr )* }
+		$( where $( $where_path:ty : $where_bound_head:path $( | $where_bound_tail:path )* ),* )?;
+		$( $rest:tt )*
+	) => {
+		morph_types! { @DECL $( #[doc = $doc] )* $vq $name ( $( $( $bound_id ),+ )? ) }
+		morph_types! {
+			@IMPL $name $( < $( $bound_id ),* > )? :
+			( $( $( $bound_id $( : $bound_head $( + $bound_tail )* )? , )+ )? $( $extra )? )
+			( $( where $( $where_path : $where_bound_head $( + $where_bound_tail )* ),* )? )
+			= |$var: $var_type| -> $outcome { $( $ex )* }
+		}
+		morph_types!{ $($rest)* }
+	};
+	(
+		$( #[doc = $doc:expr] )* $vq:vis type $name:ident
+		$( < $( $bound_id:ident $( : $bound_head:path $( | $bound_tail:path )* )? ),+ > )?
+		$( EXTRA_GENERIC ($extra:ident) )?
+		: TryMorph
+		= |$var:ident: $var_type:ty| -> Result<$outcome:ty, ()> { $( $ex:expr )* }
+		$( where $( $where_path:ty : $where_bound_head:path $( | $where_bound_tail:path )* ),* )?;
+		$( $rest:tt )*
+	) => {
+		morph_types! { @DECL $( #[doc = $doc] )* $vq $name ( $( $( $bound_id ),+ )? ) }
+		morph_types! {
+			@IMPL_TRY $name $( < $( $bound_id ),* > )? :
+			( $( $( $bound_id $( : $bound_head $( + $bound_tail )* )? , )+ )? $( $extra )? )
+			( $( where $( $where_path : $where_bound_head $( + $where_bound_tail )* ),* )? )
+			= |$var: $var_type| -> $outcome { $( $ex )* }
+		}
+		morph_types!{ $($rest)* }
+	};
+	() => {}
+}
+
+morph_types! {
+	/// Morpher to disregard the source value and replace with another.
+	pub type Replace<V: TypedGet> = |_| -> V::Type { V::get() };
+
+	/// Mutator which reduces a scalar by a particular amount.
+	pub type ReduceBy<N: TypedGet> = |r: N::Type| -> N::Type {
+		r.checked_sub(&N::get()).unwrap_or(Zero::zero())
+	} where N::Type: CheckedSub | Zero;
+
+	/// A `TryMorph` implementation to reduce a scalar by a particular amount, checking for
+	/// underflow.
+	pub type CheckedReduceBy<N: TypedGet>: TryMorph = |r: N::Type| -> Result<N::Type, ()> {
+		r.checked_sub(&N::get()).ok_or(())
+	} where N::Type: CheckedSub;
+
+	/// A `TryMorph` implementation to enforce an upper limit for a result of the outer morphed type.
+	pub type MorphWithUpperLimit<L: TypedGet, M>: TryMorph = |r: L::Type| -> Result<L::Type, ()> {
+		M::try_morph(r).map(|m| m.min(L::get()))
+	} where L::Type: Ord, M: TryMorph<L::Type, Outcome = L::Type>;
+}
+
+/// Infallible conversion trait. Generic over both source and destination types.
+pub trait Convert<A, B> {
+	/// Make conversion.
+	fn convert(a: A) -> B;
+}
+
+impl<A, B: Default> Convert<A, B> for () {
+	fn convert(_: A) -> B {
+		Default::default()
+	}
+}
+
+/// Reversing infallible conversion trait. Generic over both source and destination types.
+///
+/// This specifically reverses the conversion.
+pub trait ConvertBack<A, B>: Convert<A, B> {
+	/// Make conversion back.
+	fn convert_back(b: B) -> A;
+}
+
+/// Fallible conversion trait returning an [Option]. Generic over both source and destination types.
+pub trait MaybeConvert<A, B> {
+	/// Attempt to make conversion.
+	fn maybe_convert(a: A) -> Option<B>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<A: Clone, B> MaybeConvert<A, B> for Tuple {
+	fn maybe_convert(a: A) -> Option<B> {
+		for_tuples!( #(
+			match Tuple::maybe_convert(a.clone()) {
+				Some(b) => return Some(b),
+				None => {},
+			}
+		)* );
+		None
+	}
+}
+
+/// Reversing fallible conversion trait returning an [Option]. Generic over both source and
+/// destination types.
+pub trait MaybeConvertBack<A, B>: MaybeConvert<A, B> {
+	/// Attempt to make conversion back.
+	fn maybe_convert_back(b: B) -> Option<A>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<A: Clone, B: Clone> MaybeConvertBack<A, B> for Tuple {
+	fn maybe_convert_back(b: B) -> Option<A> {
+		for_tuples!( #(
+			match Tuple::maybe_convert_back(b.clone()) {
+				Some(a) => return Some(a),
+				None => {},
+			}
+		)* );
+		None
+	}
+}
+
+/// Fallible conversion trait which returns the argument in the case of being unable to convert.
+/// Generic over both source and destination types.
+pub trait TryConvert<A, B> {
+	/// Attempt to make conversion. If returning [Result::Err], the inner must always be `a`.
+	fn try_convert(a: A) -> Result<B, A>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<A, B> TryConvert<A, B> for Tuple {
+	fn try_convert(a: A) -> Result<B, A> {
+		for_tuples!( #(
+			let a = match Tuple::try_convert(a) {
+				Ok(b) => return Ok(b),
+				Err(a) => a,
+			};
+		)* );
+		Err(a)
+	}
+}
+
+/// Reversing fallible conversion trait which returns the argument in the case of being unable to
+/// convert back. Generic over both source and destination types.
+pub trait TryConvertBack<A, B>: TryConvert<A, B> {
+	/// Attempt to make conversion back. If returning [Result::Err], the inner must always be `b`.
+
+	fn try_convert_back(b: B) -> Result<A, B>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<A, B> TryConvertBack<A, B> for Tuple {
+	fn try_convert_back(b: B) -> Result<A, B> {
+		for_tuples!( #(
+			let b = match Tuple::try_convert_back(b) {
+				Ok(a) => return Ok(a),
+				Err(b) => b,
+			};
+		)* );
+		Err(b)
+	}
+}
+
+/// Definition for a bi-directional, fallible conversion between two types.
+pub trait MaybeEquivalence<A, B> {
+	/// Attempt to convert reference of `A` into value of `B`, returning `None` if not possible.
+	fn convert(a: &A) -> Option<B>;
+	/// Attempt to convert reference of `B` into value of `A`, returning `None` if not possible.
+	fn convert_back(b: &B) -> Option<A>;
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl<A, B> MaybeEquivalence<A, B> for Tuple {
+	fn convert(a: &A) -> Option<B> {
+		for_tuples!( #(
+			match Tuple::convert(a) {
+				Some(b) => return Some(b),
+				None => {},
+			}
+		)* );
+		None
+	}
+	fn convert_back(b: &B) -> Option<A> {
+		for_tuples!( #(
+			match Tuple::convert_back(b) {
+				Some(a) => return Some(a),
+				None => {},
+			}
+		)* );
+		None
+	}
+}
+
+/// Adapter which turns a [Get] implementation into a [Convert] implementation which always returns
+/// in the same value no matter the input.
+pub struct ConvertToValue<T>(sp_std::marker::PhantomData<T>);
+impl<X, Y, T: Get<Y>> Convert<X, Y> for ConvertToValue<T> {
+	fn convert(_: X) -> Y {
+		T::get()
+	}
+}
+impl<X, Y, T: Get<Y>> MaybeConvert<X, Y> for ConvertToValue<T> {
+	fn maybe_convert(_: X) -> Option<Y> {
+		Some(T::get())
+	}
+}
+impl<X, Y, T: Get<Y>> MaybeConvertBack<X, Y> for ConvertToValue<T> {
+	fn maybe_convert_back(_: Y) -> Option<X> {
+		None
+	}
+}
+impl<X, Y, T: Get<Y>> TryConvert<X, Y> for ConvertToValue<T> {
+	fn try_convert(_: X) -> Result<Y, X> {
+		Ok(T::get())
+	}
+}
+impl<X, Y, T: Get<Y>> TryConvertBack<X, Y> for ConvertToValue<T> {
+	fn try_convert_back(y: Y) -> Result<X, Y> {
+		Err(y)
+	}
+}
+impl<X, Y, T: Get<Y>> MaybeEquivalence<X, Y> for ConvertToValue<T> {
+	fn convert(_: &X) -> Option<Y> {
+		Some(T::get())
+	}
+	fn convert_back(_: &Y) -> Option<X> {
+		None
+	}
+}
+
+/// A structure that performs identity conversion.
+pub struct Identity;
+impl<T> Convert<T, T> for Identity {
+	fn convert(a: T) -> T {
+		a
+	}
+}
+impl<T> ConvertBack<T, T> for Identity {
+	fn convert_back(a: T) -> T {
+		a
+	}
+}
+impl<T> MaybeConvert<T, T> for Identity {
+	fn maybe_convert(a: T) -> Option<T> {
+		Some(a)
+	}
+}
+impl<T> MaybeConvertBack<T, T> for Identity {
+	fn maybe_convert_back(a: T) -> Option<T> {
+		Some(a)
+	}
+}
+impl<T> TryConvert<T, T> for Identity {
+	fn try_convert(a: T) -> Result<T, T> {
+		Ok(a)
+	}
+}
+impl<T> TryConvertBack<T, T> for Identity {
+	fn try_convert_back(a: T) -> Result<T, T> {
+		Ok(a)
+	}
+}
+impl<T: Clone> MaybeEquivalence<T, T> for Identity {
+	fn convert(a: &T) -> Option<T> {
+		Some(a.clone())
+	}
+	fn convert_back(a: &T) -> Option<T> {
+		Some(a.clone())
+	}
+}
+
+/// A structure that performs standard conversion using the standard Rust conversion traits.
+pub struct ConvertInto;
+impl<A: Into<B>, B> Convert<A, B> for ConvertInto {
+	fn convert(a: A) -> B {
+		a.into()
+	}
+}
+impl<A: Into<B>, B> MaybeConvert<A, B> for ConvertInto {
+	fn maybe_convert(a: A) -> Option<B> {
+		Some(a.into())
+	}
+}
+impl<A: Into<B>, B: Into<A>> MaybeConvertBack<A, B> for ConvertInto {
+	fn maybe_convert_back(b: B) -> Option<A> {
+		Some(b.into())
+	}
+}
+impl<A: Into<B>, B> TryConvert<A, B> for ConvertInto {
+	fn try_convert(a: A) -> Result<B, A> {
+		Ok(a.into())
+	}
+}
+impl<A: Into<B>, B: Into<A>> TryConvertBack<A, B> for ConvertInto {
+	fn try_convert_back(b: B) -> Result<A, B> {
+		Ok(b.into())
+	}
+}
+impl<A: Clone + Into<B>, B: Clone + Into<A>> MaybeEquivalence<A, B> for ConvertInto {
+	fn convert(a: &A) -> Option<B> {
+		Some(a.clone().into())
+	}
+	fn convert_back(b: &B) -> Option<A> {
+		Some(b.clone().into())
+	}
+}
+
+/// A structure that performs standard conversion using the standard Rust conversion traits.
+pub struct TryConvertInto;
+impl<A: Clone + TryInto<B>, B> MaybeConvert<A, B> for TryConvertInto {
+	fn maybe_convert(a: A) -> Option<B> {
+		a.clone().try_into().ok()
+	}
+}
+impl<A: Clone + TryInto<B>, B: Clone + TryInto<A>> MaybeConvertBack<A, B> for TryConvertInto {
+	fn maybe_convert_back(b: B) -> Option<A> {
+		b.clone().try_into().ok()
+	}
+}
+impl<A: Clone + TryInto<B>, B> TryConvert<A, B> for TryConvertInto {
+	fn try_convert(a: A) -> Result<B, A> {
+		a.clone().try_into().map_err(|_| a)
+	}
+}
+impl<A: Clone + TryInto<B>, B: Clone + TryInto<A>> TryConvertBack<A, B> for TryConvertInto {
+	fn try_convert_back(b: B) -> Result<A, B> {
+		b.clone().try_into().map_err(|_| b)
+	}
+}
+impl<A: Clone + TryInto<B>, B: Clone + TryInto<A>> MaybeEquivalence<A, B> for TryConvertInto {
+	fn convert(a: &A) -> Option<B> {
+		a.clone().try_into().ok()
+	}
+	fn convert_back(b: &B) -> Option<A> {
+		b.clone().try_into().ok()
+	}
+}
+
+/// Convenience type to work around the highly unergonomic syntax needed
+/// to invoke the functions of overloaded generic traits, in this case
+/// `TryFrom` and `TryInto`.
+pub trait CheckedConversion {
+	/// Convert from a value of `T` into an equivalent instance of `Option<Self>`.
+	///
+	/// This just uses `TryFrom` internally but with this
+	/// variant you can provide the destination type using turbofish syntax
+	/// in case Rust happens not to assume the correct type.
+	fn checked_from<T>(t: T) -> Option<Self>
+	where
+		Self: TryFrom<T>,
+	{
+		<Self as TryFrom<T>>::try_from(t).ok()
+	}
+	/// Consume self to return `Some` equivalent value of `Option<T>`.
+	///
+	/// This just uses `TryInto` internally but with this
+	/// variant you can provide the destination type using turbofish syntax
+	/// in case Rust happens not to assume the correct type.
+	fn checked_into<T>(self) -> Option<T>
+	where
+		Self: TryInto<T>,
+	{
+		<Self as TryInto<T>>::try_into(self).ok()
+	}
+}
+impl<T: Sized> CheckedConversion for T {}
+
+/// Multiply and divide by a number that isn't necessarily the same type. Basically just the same
+/// as `Mul` and `Div` except it can be used for all basic numeric types.
+pub trait Scale<Other> {
+	/// The output type of the product of `self` and `Other`.
+	type Output;
+
+	/// @return the product of `self` and `other`.
+	fn mul(self, other: Other) -> Self::Output;
+
+	/// @return the integer division of `self` and `other`.
+	fn div(self, other: Other) -> Self::Output;
+
+	/// @return the modulo remainder of `self` and `other`.
+	fn rem(self, other: Other) -> Self::Output;
+}
+macro_rules! impl_scale {
+	($self:ty, $other:ty) => {
+		impl Scale<$other> for $self {
+			type Output = Self;
+			fn mul(self, other: $other) -> Self::Output {
+				self * (other as Self)
+			}
+			fn div(self, other: $other) -> Self::Output {
+				self / (other as Self)
+			}
+			fn rem(self, other: $other) -> Self::Output {
+				self % (other as Self)
+			}
+		}
+	};
+}
+impl_scale!(u128, u128);
+impl_scale!(u128, u64);
+impl_scale!(u128, u32);
+impl_scale!(u128, u16);
+impl_scale!(u128, u8);
+impl_scale!(u64, u64);
+impl_scale!(u64, u32);
+impl_scale!(u64, u16);
+impl_scale!(u64, u8);
+impl_scale!(u32, u32);
+impl_scale!(u32, u16);
+impl_scale!(u32, u8);
+impl_scale!(u16, u16);
+impl_scale!(u16, u8);
+impl_scale!(u8, u8);
+
+/// Trait for things that can be clear (have no bits set). For numeric types, essentially the same
+/// as `Zero`.
+pub trait Clear {
+	/// True iff no bits are set.
+	fn is_clear(&self) -> bool;
+
+	/// Return the value of Self that is clear.
+	fn clear() -> Self;
+}
+
+impl<T: Default + Eq + PartialEq> Clear for T {
+	fn is_clear(&self) -> bool {
+		*self == Self::clear()
+	}
+	fn clear() -> Self {
+		Default::default()
+	}
+}
+
+/// A meta trait for all bit ops.
+pub trait SimpleBitOps:
+	Sized
+	+ Clear
+	+ sp_std::ops::BitOr<Self, Output = Self>
+	+ sp_std::ops::BitXor<Self, Output = Self>
+	+ sp_std::ops::BitAnd<Self, Output = Self>
+{
+}
+impl<
+		T: Sized
+			+ Clear
+			+ sp_std::ops::BitOr<Self, Output = Self>
+			+ sp_std::ops::BitXor<Self, Output = Self>
+			+ sp_std::ops::BitAnd<Self, Output = Self>,
+	> SimpleBitOps for T
+{
+}
+
+/// Abstraction around hashing
+// Stupid bug in the Rust compiler believes derived
+// traits must be fulfilled by all type parameters.
+pub trait Hash:
+	'static
+	+ MaybeSerializeDeserialize
+	+ Debug
+	+ Clone
+	+ Eq
+	+ PartialEq
+	+ Hasher<Out = <Self as Hash>::Output>
+{
+	/// The hash type produced.
+	type Output: HashOutput;
+
+	/// Produce the hash of some byte-slice.
+	fn hash(s: &[u8]) -> Self::Output {
+		<Self as Hasher>::hash(s)
+	}
+
+	/// Produce the hash of some codec-encodable value.
+	fn hash_of<S: Encode>(s: &S) -> Self::Output {
+		Encode::using_encoded(s, <Self as Hasher>::hash)
+	}
+
+	/// The ordered Patricia tree root of the given `input`.
+	fn ordered_trie_root(input: Vec<Vec<u8>>, state_version: StateVersion) -> Self::Output;
+
+	/// The Patricia tree root of the given mapping.
+	fn trie_root(input: Vec<(Vec<u8>, Vec<u8>)>, state_version: StateVersion) -> Self::Output;
+}
+
+/// Super trait with all the attributes for a hashing output.
+pub trait HashOutput:
+	Member
+	+ MaybeSerializeDeserialize
+	+ MaybeDisplay
+	+ MaybeFromStr
+	+ Debug
+	+ sp_std::hash::Hash
+	+ AsRef<[u8]>
+	+ AsMut<[u8]>
+	+ Copy
+	+ Ord
+	+ Default
+	+ Encode
+	+ Decode
+	+ EncodeLike
+	+ MaxEncodedLen
+	+ TypeInfo
+{
+}
+
+impl<T> HashOutput for T where
+	T: Member
+		+ MaybeSerializeDeserialize
+		+ MaybeDisplay
+		+ MaybeFromStr
+		+ Debug
+		+ sp_std::hash::Hash
+		+ AsRef<[u8]>
+		+ AsMut<[u8]>
+		+ Copy
+		+ Ord
+		+ Default
+		+ Encode
+		+ Decode
+		+ EncodeLike
+		+ MaxEncodedLen
+		+ TypeInfo
+{
+}
+
+/// Blake2-256 Hash implementation.
+#[derive(PartialEq, Eq, Clone, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct BlakeTwo256;
+
+impl Hasher for BlakeTwo256 {
+	type Out = sp_core::H256;
+	type StdHasher = hash256_std_hasher::Hash256StdHasher;
+	const LENGTH: usize = 32;
+
+	fn hash(s: &[u8]) -> Self::Out {
+		sp_io::hashing::blake2_256(s).into()
+	}
+}
+
+impl Hash for BlakeTwo256 {
+	type Output = sp_core::H256;
+
+	fn ordered_trie_root(input: Vec<Vec<u8>>, version: StateVersion) -> Self::Output {
+		sp_io::trie::blake2_256_ordered_root(input, version)
+	}
+
+	fn trie_root(input: Vec<(Vec<u8>, Vec<u8>)>, version: StateVersion) -> Self::Output {
+		sp_io::trie::blake2_256_root(input, version)
+	}
+}
+
+/// Keccak-256 Hash implementation.
+#[derive(PartialEq, Eq, Clone, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct Keccak256;
+
+impl Hasher for Keccak256 {
+	type Out = sp_core::H256;
+	type StdHasher = hash256_std_hasher::Hash256StdHasher;
+	const LENGTH: usize = 32;
+
+	fn hash(s: &[u8]) -> Self::Out {
+		sp_io::hashing::keccak_256(s).into()
+	}
+}
+
+impl Hash for Keccak256 {
+	type Output = sp_core::H256;
+
+	fn ordered_trie_root(input: Vec<Vec<u8>>, version: StateVersion) -> Self::Output {
+		sp_io::trie::keccak_256_ordered_root(input, version)
+	}
+
+	fn trie_root(input: Vec<(Vec<u8>, Vec<u8>)>, version: StateVersion) -> Self::Output {
+		sp_io::trie::keccak_256_root(input, version)
+	}
+}
+
+/// Something that can be checked for equality and printed out to a debug channel if bad.
+pub trait CheckEqual {
+	/// Perform the equality check.
+	fn check_equal(&self, other: &Self);
+}
+
+impl CheckEqual for sp_core::H256 {
+	#[cfg(feature = "std")]
+	fn check_equal(&self, other: &Self) {
+		use sp_core::hexdisplay::HexDisplay;
+		if self != other {
+			println!(
+				"Hash: given={}, expected={}",
+				HexDisplay::from(self.as_fixed_bytes()),
+				HexDisplay::from(other.as_fixed_bytes()),
+			);
+		}
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn check_equal(&self, other: &Self) {
+		if self != other {
+			"Hash not equal".print();
+			self.as_bytes().print();
+			other.as_bytes().print();
+		}
+	}
+}
+
+impl CheckEqual for super::generic::DigestItem {
+	#[cfg(feature = "std")]
+	fn check_equal(&self, other: &Self) {
+		if self != other {
+			println!("DigestItem: given={:?}, expected={:?}", self, other);
+		}
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn check_equal(&self, other: &Self) {
+		if self != other {
+			"DigestItem not equal".print();
+			(&Encode::encode(self)[..]).print();
+			(&Encode::encode(other)[..]).print();
+		}
+	}
+}
+
+sp_core::impl_maybe_marker!(
+	/// A type that implements Display when in std environment.
+	trait MaybeDisplay: Display;
+
+	/// A type that implements FromStr when in std environment.
+	trait MaybeFromStr: FromStr;
+
+	/// A type that implements Hash when in std environment.
+	trait MaybeHash: sp_std::hash::Hash;
+);
+
+sp_core::impl_maybe_marker_std_or_serde!(
+	/// A type that implements Serialize when in std environment or serde feature is activated.
+	trait MaybeSerialize: Serialize;
+
+	/// A type that implements Serialize, DeserializeOwned and Debug when in std environment or serde feature is activated.
+	trait MaybeSerializeDeserialize: DeserializeOwned, Serialize;
+);
+
+/// A type that can be used in runtime structures.
+pub trait Member: Send + Sync + Sized + Debug + Eq + PartialEq + Clone + 'static {}
+impl<T: Send + Sync + Sized + Debug + Eq + PartialEq + Clone + 'static> Member for T {}
+
+/// Determine if a `MemberId` is a valid member.
+pub trait IsMember<MemberId> {
+	/// Is the given `MemberId` a valid member?
+	fn is_member(member_id: &MemberId) -> bool;
+}
+
+/// Something which fulfills the abstract idea of a Substrate header. It has types for a `Number`,
+/// a `Hash` and a `Hashing`. It provides access to an `extrinsics_root`, `state_root` and
+/// `parent_hash`, as well as a `digest` and a block `number`.
+///
+/// You can also create a `new` one from those fields.
+pub trait Header:
+	Clone + Send + Sync + Codec + Eq + MaybeSerialize + Debug + TypeInfo + 'static
+{
+	/// Header number.
+	type Number: Member
+		+ MaybeSerializeDeserialize
+		+ MaybeFromStr
+		+ Debug
+		+ sp_std::hash::Hash
+		+ Copy
+		+ MaybeDisplay
+		+ AtLeast32BitUnsigned
+		+ Default
+		+ TypeInfo
+		+ MaxEncodedLen
+		+ FullCodec;
+	/// Header hash type
+	type Hash: HashOutput;
+	/// Hashing algorithm
+	type Hashing: Hash<Output = Self::Hash>;
+
+	/// Creates new header.
+	fn new(
+		number: Self::Number,
+		extrinsics_root: Self::Hash,
+		state_root: Self::Hash,
+		parent_hash: Self::Hash,
+		digest: Digest,
+	) -> Self;
+
+	/// Returns a reference to the header number.
+	fn number(&self) -> &Self::Number;
+	/// Sets the header number.
+	fn set_number(&mut self, number: Self::Number);
+
+	/// Returns a reference to the extrinsics root.
+	fn extrinsics_root(&self) -> &Self::Hash;
+	/// Sets the extrinsic root.
+	fn set_extrinsics_root(&mut self, root: Self::Hash);
+
+	/// Returns a reference to the state root.
+	fn state_root(&self) -> &Self::Hash;
+	/// Sets the state root.
+	fn set_state_root(&mut self, root: Self::Hash);
+
+	/// Returns a reference to the parent hash.
+	fn parent_hash(&self) -> &Self::Hash;
+	/// Sets the parent hash.
+	fn set_parent_hash(&mut self, hash: Self::Hash);
+
+	/// Returns a reference to the digest.
+	fn digest(&self) -> &Digest;
+	/// Get a mutable reference to the digest.
+	fn digest_mut(&mut self) -> &mut Digest;
+
+	/// Returns the hash of the header.
+	fn hash(&self) -> Self::Hash {
+		<Self::Hashing as Hash>::hash_of(self)
+	}
+}
+
+// Something that provides the Header Type. Only for internal usage and should only be used
+// via `HeaderFor` or `BlockNumberFor`.
+//
+// This is needed to fix the "cyclical" issue in loading Header/BlockNumber as part of a
+// `pallet::call`. Essentially, `construct_runtime` aggregates all calls to create a `RuntimeCall`
+// that is then used to define `UncheckedExtrinsic`.
+// ```ignore
+// pub type UncheckedExtrinsic =
+// 	generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
+// ```
+// This `UncheckedExtrinsic` is supplied to the `Block`.
+// ```ignore
+// pub type Block = generic::Block<Header, UncheckedExtrinsic>;
+// ```
+// So, if we do not create a trait outside of `Block` that doesn't have `Extrinsic`, we go into a
+// recursive loop leading to a build error.
+//
+// Note that this is a workaround for a compiler bug and should be removed when the compiler
+// bug is fixed.
+#[doc(hidden)]
+pub trait HeaderProvider {
+	/// Header type.
+	type HeaderT: Header;
+}
+
+/// Something which fulfills the abstract idea of a Substrate block. It has types for
+/// `Extrinsic` pieces of information as well as a `Header`.
+///
+/// You can get an iterator over each of the `extrinsics` and retrieve the `header`.
+pub trait Block:
+	HeaderProvider<HeaderT = <Self as Block>::Header>
+	+ Clone
+	+ Send
+	+ Sync
+	+ Codec
+	+ Eq
+	+ MaybeSerialize
+	+ Debug
+	+ 'static
+{
+	/// Type for extrinsics.
+	type Extrinsic: Member + Codec + Extrinsic + MaybeSerialize;
+	/// Header type.
+	type Header: Header<Hash = Self::Hash> + MaybeSerializeDeserialize;
+	/// Block hash type.
+	type Hash: HashOutput;
+
+	/// Returns a reference to the header.
+	fn header(&self) -> &Self::Header;
+	/// Returns a reference to the list of extrinsics.
+	fn extrinsics(&self) -> &[Self::Extrinsic];
+	/// Split the block into header and list of extrinsics.
+	fn deconstruct(self) -> (Self::Header, Vec<Self::Extrinsic>);
+	/// Creates new block from header and extrinsics.
+	fn new(header: Self::Header, extrinsics: Vec<Self::Extrinsic>) -> Self;
+	/// Returns the hash of the block.
+	fn hash(&self) -> Self::Hash {
+		<<Self::Header as Header>::Hashing as Hash>::hash_of(self.header())
+	}
+	/// Creates an encoded block from the given `header` and `extrinsics` without requiring the
+	/// creation of an instance.
+	fn encode_from(header: &Self::Header, extrinsics: &[Self::Extrinsic]) -> Vec<u8>;
+}
+
+/// Something that acts like an `Extrinsic`.
+pub trait Extrinsic: Sized {
+	/// The function call.
+	type Call: TypeInfo;
+
+	/// The payload we carry for signed extrinsics.
+	///
+	/// Usually it will contain a `Signature` and
+	/// may include some additional data that are specific to signed
+	/// extrinsics.
+	type SignaturePayload: SignaturePayload;
+
+	/// Is this `Extrinsic` signed?
+	/// If no information are available about signed/unsigned, `None` should be returned.
+	fn is_signed(&self) -> Option<bool> {
+		None
+	}
+
+	/// Create new instance of the extrinsic.
+	///
+	/// Extrinsics can be split into:
+	/// 1. Inherents (no signature; created by validators during block production)
+	/// 2. Unsigned Transactions (no signature; represent "system calls" or other special kinds of
+	/// calls) 3. Signed Transactions (with signature; a regular transactions with known origin)
+	fn new(_call: Self::Call, _signed_data: Option<Self::SignaturePayload>) -> Option<Self> {
+		None
+	}
+}
+
+/// Something that acts like a [`SignaturePayload`](Extrinsic::SignaturePayload) of an
+/// [`Extrinsic`].
+pub trait SignaturePayload {
+	/// The type of the address that signed the extrinsic.
+	///
+	/// Particular to a signed extrinsic.
+	type SignatureAddress: TypeInfo;
+
+	/// The signature type of the extrinsic.
+	///
+	/// Particular to a signed extrinsic.
+	type Signature: TypeInfo;
+
+	/// The additional data that is specific to the signed extrinsic.
+	///
+	/// Particular to a signed extrinsic.
+	type SignatureExtra: TypeInfo;
+}
+
+impl SignaturePayload for () {
+	type SignatureAddress = ();
+	type Signature = ();
+	type SignatureExtra = ();
+}
+
+/// Implementor is an [`Extrinsic`] and provides metadata about this extrinsic.
+pub trait ExtrinsicMetadata {
+	/// The format version of the `Extrinsic`.
+	///
+	/// By format is meant the encoded representation of the `Extrinsic`.
+	const VERSION: u8;
+
+	/// Signed extensions attached to this `Extrinsic`.
+	type SignedExtensions: SignedExtension;
+}
+
+/// Extract the hashing type for a block.
+pub type HashingFor<B> = <<B as Block>::Header as Header>::Hashing;
+/// Extract the number type for a block.
+pub type NumberFor<B> = <<B as Block>::Header as Header>::Number;
+/// Extract the digest type for a block.
+
+/// A "checkable" piece of information, used by the standard Substrate Executive in order to
+/// check the validity of a piece of extrinsic information, usually by verifying the signature.
+/// Implement for pieces of information that require some additional context `Context` in order to
+/// be checked.
+pub trait Checkable<Context>: Sized {
+	/// Returned if `check` succeeds.
+	type Checked;
+
+	/// Check self, given an instance of Context.
+	fn check(self, c: &Context) -> Result<Self::Checked, TransactionValidityError>;
+
+	/// Blindly check self.
+	///
+	/// ## WARNING
+	///
+	/// DO NOT USE IN PRODUCTION. This is only meant to be used in testing environments. A runtime
+	/// compiled with `try-runtime` should never be in production. Moreover, the name of this
+	/// function is deliberately chosen to prevent developers from ever calling it in consensus
+	/// code-paths.
+	#[cfg(feature = "try-runtime")]
+	fn unchecked_into_checked_i_know_what_i_am_doing(
+		self,
+		c: &Context,
+	) -> Result<Self::Checked, TransactionValidityError>;
+}
+
+/// A "checkable" piece of information, used by the standard Substrate Executive in order to
+/// check the validity of a piece of extrinsic information, usually by verifying the signature.
+/// Implement for pieces of information that don't require additional context in order to be
+/// checked.
+pub trait BlindCheckable: Sized {
+	/// Returned if `check` succeeds.
+	type Checked;
+
+	/// Check self.
+	fn check(self) -> Result<Self::Checked, TransactionValidityError>;
+}
+
+// Every `BlindCheckable` is also a `StaticCheckable` for arbitrary `Context`.
+impl<T: BlindCheckable, Context> Checkable<Context> for T {
+	type Checked = <Self as BlindCheckable>::Checked;
+
+	fn check(self, _c: &Context) -> Result<Self::Checked, TransactionValidityError> {
+		BlindCheckable::check(self)
+	}
+
+	#[cfg(feature = "try-runtime")]
+	fn unchecked_into_checked_i_know_what_i_am_doing(
+		self,
+		_: &Context,
+	) -> Result<Self::Checked, TransactionValidityError> {
+		unreachable!();
+	}
+}
+
+/// A lazy call (module function and argument values) that can be executed via its `dispatch`
+/// method.
+pub trait Dispatchable {
+	/// Every function call from your runtime has an origin, which specifies where the extrinsic was
+	/// generated from. In the case of a signed extrinsic (transaction), the origin contains an
+	/// identifier for the caller. The origin can be empty in the case of an inherent extrinsic.
+	type RuntimeOrigin;
+	/// ...
+	type Config;
+	/// An opaque set of information attached to the transaction. This could be constructed anywhere
+	/// down the line in a runtime. The current Substrate runtime uses a struct with the same name
+	/// to represent the dispatch class and weight.
+	type Info;
+	/// Additional information that is returned by `dispatch`. Can be used to supply the caller
+	/// with information about a `Dispatchable` that is ownly known post dispatch.
+	type PostInfo: Eq + PartialEq + Clone + Copy + Encode + Decode + Printable;
+	/// Actually dispatch this call and return the result of it.
+	fn dispatch(self, origin: Self::RuntimeOrigin)
+		-> crate::DispatchResultWithInfo<Self::PostInfo>;
+}
+
+/// Shortcut to reference the `Info` type of a `Dispatchable`.
+pub type DispatchInfoOf<T> = <T as Dispatchable>::Info;
+/// Shortcut to reference the `PostInfo` type of a `Dispatchable`.
+pub type PostDispatchInfoOf<T> = <T as Dispatchable>::PostInfo;
+
+impl Dispatchable for () {
+	type RuntimeOrigin = ();
+	type Config = ();
+	type Info = ();
+	type PostInfo = ();
+	fn dispatch(
+		self,
+		_origin: Self::RuntimeOrigin,
+	) -> crate::DispatchResultWithInfo<Self::PostInfo> {
+		panic!("This implementation should not be used for actual dispatch.");
+	}
+}
+
+/// Means by which a transaction may be extended. This type embodies both the data and the logic
+/// that should be additionally associated with the transaction. It should be plain old data.
+pub trait SignedExtension:
+	Codec + Debug + Sync + Send + Clone + Eq + PartialEq + StaticTypeInfo
+{
+	/// Unique identifier of this signed extension.
+	///
+	/// This will be exposed in the metadata to identify the signed extension used
+	/// in an extrinsic.
+	const IDENTIFIER: &'static str;
+
+	/// The type which encodes the sender identity.
+	type AccountId;
+
+	/// The type which encodes the call to be dispatched.
+	type Call: Dispatchable;
+
+	/// Any additional data that will go into the signed payload. This may be created dynamically
+	/// from the transaction using the `additional_signed` function.
+	type AdditionalSigned: Encode + TypeInfo;
+
+	/// The type that encodes information that can be passed from pre_dispatch to post-dispatch.
+	type Pre;
+
+	/// Construct any additional data that should be in the signed payload of the transaction. Can
+	/// also perform any pre-signature-verification checks and return an error if needed.
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError>;
+
+	/// Validate a signed transaction for the transaction queue.
+	///
+	/// This function can be called frequently by the transaction queue,
+	/// to obtain transaction validity against current state.
+	/// It should perform all checks that determine a valid transaction,
+	/// that can pay for its execution and quickly eliminate ones
+	/// that are stale or incorrect.
+	///
+	/// Make sure to perform the same checks in `pre_dispatch` function.
+	fn validate(
+		&self,
+		_who: &Self::AccountId,
+		_call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		Ok(ValidTransaction::default())
+	}
+
+	/// Do any pre-flight stuff for a signed transaction.
+	///
+	/// Make sure to perform the same checks as in [`Self::validate`].
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError>;
+
+	/// Validate an unsigned transaction for the transaction queue.
+	///
+	/// This function can be called frequently by the transaction queue
+	/// to obtain transaction validity against current state.
+	/// It should perform all checks that determine a valid unsigned transaction,
+	/// and quickly eliminate ones that are stale or incorrect.
+	///
+	/// Make sure to perform the same checks in `pre_dispatch_unsigned` function.
+	fn validate_unsigned(
+		_call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		Ok(ValidTransaction::default())
+	}
+
+	/// Do any pre-flight stuff for a unsigned transaction.
+	///
+	/// Note this function by default delegates to `validate_unsigned`, so that
+	/// all checks performed for the transaction queue are also performed during
+	/// the dispatch phase (applying the extrinsic).
+	///
+	/// If you ever override this function, you need to make sure to always
+	/// perform the same validation as in `validate_unsigned`.
+	fn pre_dispatch_unsigned(
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<(), TransactionValidityError> {
+		Self::validate_unsigned(call, info, len).map(|_| ()).map_err(Into::into)
+	}
+
+	/// Do any post-flight stuff for an extrinsic.
+	///
+	/// If the transaction is signed, then `_pre` will contain the output of `pre_dispatch`,
+	/// and `None` otherwise.
+	///
+	/// This gets given the `DispatchResult` `_result` from the extrinsic and can, if desired,
+	/// introduce a `TransactionValidityError`, causing the block to become invalid for including
+	/// it.
+	///
+	/// WARNING: It is dangerous to return an error here. To do so will fundamentally invalidate the
+	/// transaction and any block that it is included in, causing the block author to not be
+	/// compensated for their work in validating the transaction or producing the block so far.
+	///
+	/// It can only be used safely when you *know* that the extrinsic is one that can only be
+	/// introduced by the current block author; generally this implies that it is an inherent and
+	/// will come from either an offchain-worker or via `InherentData`.
+	fn post_dispatch(
+		_pre: Option<Self::Pre>,
+		_info: &DispatchInfoOf<Self::Call>,
+		_post_info: &PostDispatchInfoOf<Self::Call>,
+		_len: usize,
+		_result: &DispatchResult,
+	) -> Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	/// Returns the metadata for this signed extension.
+	///
+	/// As a [`SignedExtension`] can be a tuple of [`SignedExtension`]s we need to return a `Vec`
+	/// that holds the metadata of each one. Each individual `SignedExtension` must return
+	/// *exactly* one [`SignedExtensionMetadata`].
+	///
+	/// This method provides a default implementation that returns a vec containing a single
+	/// [`SignedExtensionMetadata`].
+	fn metadata() -> Vec<SignedExtensionMetadata> {
+		sp_std::vec![SignedExtensionMetadata {
+			identifier: Self::IDENTIFIER,
+			ty: scale_info::meta_type::<Self>(),
+			additional_signed: scale_info::meta_type::<Self::AdditionalSigned>()
+		}]
+	}
+}
+
+/// Information about a [`SignedExtension`] for the runtime metadata.
+pub struct SignedExtensionMetadata {
+	/// The unique identifier of the [`SignedExtension`].
+	pub identifier: &'static str,
+	/// The type of the [`SignedExtension`].
+	pub ty: MetaType,
+	/// The type of the [`SignedExtension`] additional signed data for the payload.
+	pub additional_signed: MetaType,
+}
+
+#[impl_for_tuples(1, 12)]
+impl<AccountId, Call: Dispatchable> SignedExtension for Tuple {
+	for_tuples!( where #( Tuple: SignedExtension<AccountId=AccountId, Call=Call,> )* );
+	type AccountId = AccountId;
+	type Call = Call;
+	const IDENTIFIER: &'static str = "You should call `identifier()`!";
+	for_tuples!( type AdditionalSigned = ( #( Tuple::AdditionalSigned ),* ); );
+	for_tuples!( type Pre = ( #( Tuple::Pre ),* ); );
+
+	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(for_tuples!( ( #( Tuple.additional_signed()? ),* ) ))
+	}
+
+	fn validate(
+		&self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		let valid = ValidTransaction::default();
+		for_tuples!( #( let valid = valid.combine_with(Tuple.validate(who, call, info, len)?); )* );
+		Ok(valid)
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		Ok(for_tuples!( ( #( Tuple.pre_dispatch(who, call, info, len)? ),* ) ))
+	}
+
+	fn validate_unsigned(
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity {
+		let valid = ValidTransaction::default();
+		for_tuples!( #( let valid = valid.combine_with(Tuple::validate_unsigned(call, info, len)?); )* );
+		Ok(valid)
+	}
+
+	fn pre_dispatch_unsigned(
+		call: &Self::Call,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<(), TransactionValidityError> {
+		for_tuples!( #( Tuple::pre_dispatch_unsigned(call, info, len)?; )* );
+		Ok(())
+	}
+
+	fn post_dispatch(
+		pre: Option<Self::Pre>,
+		info: &DispatchInfoOf<Self::Call>,
+		post_info: &PostDispatchInfoOf<Self::Call>,
+		len: usize,
+		result: &DispatchResult,
+	) -> Result<(), TransactionValidityError> {
+		match pre {
+			Some(x) => {
+				for_tuples!( #( Tuple::post_dispatch(Some(x.Tuple), info, post_info, len, result)?; )* );
+			},
+			None => {
+				for_tuples!( #( Tuple::post_dispatch(None, info, post_info, len, result)?; )* );
+			},
+		}
+		Ok(())
+	}
+
+	fn metadata() -> Vec<SignedExtensionMetadata> {
+		let mut ids = Vec::new();
+		for_tuples!( #( ids.extend(Tuple::metadata()); )* );
+		ids
+	}
+}
+
+/// Only for bare bone testing when you don't care about signed extensions at all.
+#[cfg(feature = "std")]
+impl SignedExtension for () {
+	type AccountId = u64;
+	type AdditionalSigned = ();
+	type Call = ();
+	type Pre = ();
+	const IDENTIFIER: &'static str = "UnitSignedExtension";
+	fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
+		Ok(())
+	}
+	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(|_| ())
+	}
+}
+
+/// An "executable" piece of information, used by the standard Substrate Executive in order to
+/// enact a piece of extrinsic information by marshalling and dispatching to a named function
+/// call.
+///
+/// Also provides information on to whom this information is attributable and an index that allows
+/// each piece of attributable information to be disambiguated.
+pub trait Applyable: Sized + Send + Sync {
+	/// Type by which we can dispatch. Restricts the `UnsignedValidator` type.
+	type Call: Dispatchable;
+
+	/// Checks to see if this is a valid *transaction*. It returns information on it if so.
+	fn validate<V: ValidateUnsigned<Call = Self::Call>>(
+		&self,
+		source: TransactionSource,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> TransactionValidity;
+
+	/// Executes all necessary logic needed prior to dispatch and deconstructs into function call,
+	/// index and sender.
+	fn apply<V: ValidateUnsigned<Call = Self::Call>>(
+		self,
+		info: &DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> crate::ApplyExtrinsicResultWithInfo<PostDispatchInfoOf<Self::Call>>;
+}
+
+/// A marker trait for something that knows the type of the runtime block.
+pub trait GetRuntimeBlockType {
+	/// The `RuntimeBlock` type.
+	type RuntimeBlock: self::Block;
+}
+
+/// A marker trait for something that knows the type of the node block.
+pub trait GetNodeBlockType {
+	/// The `NodeBlock` type.
+	type NodeBlock: self::Block;
+}
+
+/// Provide validation for unsigned extrinsics.
+///
+/// This trait provides two functions [`pre_dispatch`](Self::pre_dispatch) and
+/// [`validate_unsigned`](Self::validate_unsigned). The [`pre_dispatch`](Self::pre_dispatch)
+/// function is called right before dispatching the call wrapped by an unsigned extrinsic. The
+/// [`validate_unsigned`](Self::validate_unsigned) function is mainly being used in the context of
+/// the transaction pool to check the validity of the call wrapped by an unsigned extrinsic.
+pub trait ValidateUnsigned {
+	/// The call to validate
+	type Call;
+
+	/// Validate the call right before dispatch.
+	///
+	/// This method should be used to prevent transactions already in the pool
+	/// (i.e. passing [`validate_unsigned`](Self::validate_unsigned)) from being included in blocks
+	/// in case they became invalid since being added to the pool.
+	///
+	/// By default it's a good idea to call [`validate_unsigned`](Self::validate_unsigned) from
+	/// within this function again to make sure we never include an invalid transaction. Otherwise
+	/// the implementation of the call or this method will need to provide proper validation to
+	/// ensure that the transaction is valid.
+	///
+	/// Changes made to storage *WILL* be persisted if the call returns `Ok`.
+	fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError> {
+		Self::validate_unsigned(TransactionSource::InBlock, call)
+			.map(|_| ())
+			.map_err(Into::into)
+	}
+
+	/// Return the validity of the call
+	///
+	/// This method has no side-effects. It merely checks whether the call would be rejected
+	/// by the runtime in an unsigned extrinsic.
+	///
+	/// The validity checks should be as lightweight as possible because every node will execute
+	/// this code before the unsigned extrinsic enters the transaction pool and also periodically
+	/// afterwards to ensure the validity. To prevent dos-ing a network with unsigned
+	/// extrinsics, these validity checks should include some checks around uniqueness, for example,
+	/// like checking that the unsigned extrinsic was send by an authority in the active set.
+	///
+	/// Changes made to storage should be discarded by caller.
+	fn validate_unsigned(source: TransactionSource, call: &Self::Call) -> TransactionValidity;
+}
+
+/// Opaque data type that may be destructured into a series of raw byte slices (which represent
+/// individual keys).
+pub trait OpaqueKeys: Clone {
+	/// Types bound to this opaque keys that provide the key type ids returned.
+	type KeyTypeIdProviders;
+
+	/// Return the key-type IDs supported by this set.
+	fn key_ids() -> &'static [crate::KeyTypeId];
+	/// Get the raw bytes of key with key-type ID `i`.
+	fn get_raw(&self, i: super::KeyTypeId) -> &[u8];
+	/// Get the decoded key with key-type ID `i`.
+	fn get<T: Decode>(&self, i: super::KeyTypeId) -> Option<T> {
+		T::decode(&mut self.get_raw(i)).ok()
+	}
+	/// Verify a proof of ownership for the keys.
+	fn ownership_proof_is_valid(&self, _proof: &[u8]) -> bool {
+		true
+	}
+}
+
+/// Input that adds infinite number of zero after wrapped input.
+///
+/// This can add an infinite stream of zeros onto any input, not just a slice as with
+/// `TrailingZerosInput`.
+pub struct AppendZerosInput<'a, T>(&'a mut T);
+
+impl<'a, T> AppendZerosInput<'a, T> {
+	/// Create a new instance from the given byte array.
+	pub fn new(input: &'a mut T) -> Self {
+		Self(input)
+	}
+}
+
+impl<'a, T: codec::Input> codec::Input for AppendZerosInput<'a, T> {
+	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
+		Ok(None)
+	}
+
+	fn read(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
+		let remaining = self.0.remaining_len()?;
+		let completed = if let Some(n) = remaining {
+			let readable = into.len().min(n);
+			// this should never fail if `remaining_len` API is implemented correctly.
+			self.0.read(&mut into[..readable])?;
+			readable
+		} else {
+			// Fill it byte-by-byte.
+			let mut i = 0;
+			while i < into.len() {
+				if let Ok(b) = self.0.read_byte() {
+					into[i] = b;
+					i += 1;
+				} else {
+					break
+				}
+			}
+			i
+		};
+		// Fill the rest with zeros.
+		for i in &mut into[completed..] {
+			*i = 0;
+		}
+		Ok(())
+	}
+}
+
+/// Input that adds infinite number of zero after wrapped input.
+pub struct TrailingZeroInput<'a>(&'a [u8]);
+
+impl<'a> TrailingZeroInput<'a> {
+	/// Create a new instance from the given byte array.
+	pub fn new(data: &'a [u8]) -> Self {
+		Self(data)
+	}
+
+	/// Create a new instance which only contains zeroes as input.
+	pub fn zeroes() -> Self {
+		Self::new(&[][..])
+	}
+}
+
+impl<'a> codec::Input for TrailingZeroInput<'a> {
+	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
+		Ok(None)
+	}
+
+	fn read(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
+		let len_from_inner = into.len().min(self.0.len());
+		into[..len_from_inner].copy_from_slice(&self.0[..len_from_inner]);
+		for i in &mut into[len_from_inner..] {
+			*i = 0;
+		}
+		self.0 = &self.0[len_from_inner..];
+
+		Ok(())
+	}
+}
+
+/// This type can be converted into and possibly from an AccountId (which itself is generic).
+pub trait AccountIdConversion<AccountId>: Sized {
+	/// Convert into an account ID. This is infallible, and may truncate bytes to provide a result.
+	/// This may lead to duplicate accounts if the size of `AccountId` is less than the seed.
+	fn into_account_truncating(&self) -> AccountId {
+		self.into_sub_account_truncating(&())
+	}
+
+	/// Convert into an account ID, checking that all bytes of the seed are being used in the final
+	/// `AccountId` generated. If any bytes are dropped, this returns `None`.
+	fn try_into_account(&self) -> Option<AccountId> {
+		self.try_into_sub_account(&())
+	}
+
+	/// Try to convert an account ID into this type. Might not succeed.
+	fn try_from_account(a: &AccountId) -> Option<Self> {
+		Self::try_from_sub_account::<()>(a).map(|x| x.0)
+	}
+
+	/// Convert this value amalgamated with the a secondary "sub" value into an account ID,
+	/// truncating any unused bytes. This is infallible.
+	///
+	/// NOTE: The account IDs from this and from `into_account` are *not* guaranteed to be distinct
+	/// for any given value of `self`, nor are different invocations to this with different types
+	/// `T`. For example, the following will all encode to the same account ID value:
+	/// - `self.into_sub_account(0u32)`
+	/// - `self.into_sub_account(vec![0u8; 0])`
+	/// - `self.into_account()`
+	///
+	/// Also, if the seed provided to this function is greater than the number of bytes which fit
+	/// into this `AccountId` type, then it will lead to truncation of the seed, and potentially
+	/// non-unique accounts.
+	fn into_sub_account_truncating<S: Encode>(&self, sub: S) -> AccountId;
+
+	/// Same as `into_sub_account_truncating`, but ensuring that all bytes of the account's seed are
+	/// used when generating an account. This can help guarantee that different accounts are unique,
+	/// besides types which encode the same as noted above.
+	fn try_into_sub_account<S: Encode>(&self, sub: S) -> Option<AccountId>;
+
+	/// Try to convert an account ID into this type. Might not succeed.
+	fn try_from_sub_account<S: Decode>(x: &AccountId) -> Option<(Self, S)>;
+}
+
+/// Format is TYPE_ID ++ encode(sub-seed) ++ 00.... where 00... is indefinite trailing zeroes to
+/// fill AccountId.
+impl<T: Encode + Decode, Id: Encode + Decode + TypeId> AccountIdConversion<T> for Id {
+	// Take the `sub` seed, and put as much of it as possible into the generated account, but
+	// allowing truncation of the seed if it would not fit into the account id in full. This can
+	// lead to two different `sub` seeds with the same account generated.
+	fn into_sub_account_truncating<S: Encode>(&self, sub: S) -> T {
+		(Id::TYPE_ID, self, sub)
+			.using_encoded(|b| T::decode(&mut TrailingZeroInput(b)))
+			.expect("All byte sequences are valid `AccountIds`; qed")
+	}
+
+	// Same as `into_sub_account_truncating`, but returns `None` if any bytes would be truncated.
+	fn try_into_sub_account<S: Encode>(&self, sub: S) -> Option<T> {
+		let encoded_seed = (Id::TYPE_ID, self, sub).encode();
+		let account = T::decode(&mut TrailingZeroInput(&encoded_seed))
+			.expect("All byte sequences are valid `AccountIds`; qed");
+		// If the `account` generated has less bytes than the `encoded_seed`, then we know that
+		// bytes were truncated, and we return `None`.
+		if encoded_seed.len() <= account.encoded_size() {
+			Some(account)
+		} else {
+			None
+		}
+	}
+
+	fn try_from_sub_account<S: Decode>(x: &T) -> Option<(Self, S)> {
+		x.using_encoded(|d| {
+			if d[0..4] != Id::TYPE_ID {
+				return None
+			}
+			let mut cursor = &d[4..];
+			let result = Decode::decode(&mut cursor).ok()?;
+			if cursor.iter().all(|x| *x == 0) {
+				Some(result)
+			} else {
+				None
+			}
+		})
+	}
+}
+
+/// Calls a given macro a number of times with a set of fixed params and an incrementing numeral.
+/// e.g.
+/// ```nocompile
+/// count!(println ("{}",) foo, bar, baz);
+/// // Will result in three `println!`s: "0", "1" and "2".
+/// ```
+#[macro_export]
+macro_rules! count {
+	($f:ident ($($x:tt)*) ) => ();
+	($f:ident ($($x:tt)*) $x1:tt) => { $f!($($x)* 0); };
+	($f:ident ($($x:tt)*) $x1:tt, $x2:tt) => { $f!($($x)* 0); $f!($($x)* 1); };
+	($f:ident ($($x:tt)*) $x1:tt, $x2:tt, $x3:tt) => { $f!($($x)* 0); $f!($($x)* 1); $f!($($x)* 2); };
+	($f:ident ($($x:tt)*) $x1:tt, $x2:tt, $x3:tt, $x4:tt) => {
+		$f!($($x)* 0); $f!($($x)* 1); $f!($($x)* 2); $f!($($x)* 3);
+	};
+	($f:ident ($($x:tt)*) $x1:tt, $x2:tt, $x3:tt, $x4:tt, $x5:tt) => {
+		$f!($($x)* 0); $f!($($x)* 1); $f!($($x)* 2); $f!($($x)* 3); $f!($($x)* 4);
+	};
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! impl_opaque_keys_inner {
+	(
+		$( #[ $attr:meta ] )*
+		pub struct $name:ident {
+			$(
+				$( #[ $inner_attr:meta ] )*
+				pub $field:ident: $type:ty,
+			)*
+		}
+	) => {
+		$( #[ $attr ] )*
+		#[derive(
+			Clone, PartialEq, Eq,
+			$crate::codec::Encode,
+			$crate::codec::Decode,
+			$crate::scale_info::TypeInfo,
+			$crate::RuntimeDebug,
+		)]
+		pub struct $name {
+			$(
+				$( #[ $inner_attr ] )*
+				pub $field: <$type as $crate::BoundToRuntimeAppPublic>::Public,
+			)*
+		}
+
+		impl $name {
+			/// Generate a set of keys with optionally using the given seed.
+			///
+			/// The generated key pairs are stored in the keystore.
+			///
+			/// Returns the concatenated SCALE encoded public keys.
+			pub fn generate(seed: Option<$crate::sp_std::vec::Vec<u8>>) -> $crate::sp_std::vec::Vec<u8> {
+				let keys = Self{
+					$(
+						$field: <
+							<
+								$type as $crate::BoundToRuntimeAppPublic
+							>::Public as $crate::RuntimeAppPublic
+						>::generate_pair(seed.clone()),
+					)*
+				};
+				$crate::codec::Encode::encode(&keys)
+			}
+
+			/// Converts `Self` into a `Vec` of `(raw public key, KeyTypeId)`.
+			pub fn into_raw_public_keys(
+				self,
+			) -> $crate::sp_std::vec::Vec<($crate::sp_std::vec::Vec<u8>, $crate::KeyTypeId)> {
+				let mut keys = Vec::new();
+				$(
+					keys.push((
+						$crate::RuntimeAppPublic::to_raw_vec(&self.$field),
+						<
+							<
+								$type as $crate::BoundToRuntimeAppPublic
+							>::Public as $crate::RuntimeAppPublic
+						>::ID,
+					));
+				)*
+
+				keys
+			}
+
+			/// Decode `Self` from the given `encoded` slice and convert `Self` into the raw public
+			/// keys (see [`Self::into_raw_public_keys`]).
+			///
+			/// Returns `None` when the decoding failed, otherwise `Some(_)`.
+			pub fn decode_into_raw_public_keys(
+				encoded: &[u8],
+			) -> Option<$crate::sp_std::vec::Vec<($crate::sp_std::vec::Vec<u8>, $crate::KeyTypeId)>> {
+				<Self as $crate::codec::Decode>::decode(&mut &encoded[..])
+					.ok()
+					.map(|s| s.into_raw_public_keys())
+			}
+		}
+
+		impl $crate::traits::OpaqueKeys for $name {
+			type KeyTypeIdProviders = ( $( $type, )* );
+
+			fn key_ids() -> &'static [$crate::KeyTypeId] {
+				&[
+					$(
+						<
+							<
+								$type as $crate::BoundToRuntimeAppPublic
+							>::Public as $crate::RuntimeAppPublic
+						>::ID
+					),*
+				]
+			}
+
+			fn get_raw(&self, i: $crate::KeyTypeId) -> &[u8] {
+				match i {
+					$(
+						i if i == <
+							<
+								$type as $crate::BoundToRuntimeAppPublic
+							>::Public as $crate::RuntimeAppPublic
+						>::ID =>
+							self.$field.as_ref(),
+					)*
+					_ => &[],
+				}
+			}
+		}
+	};
+}
+
+/// Implement `OpaqueKeys` for a described struct.
+///
+/// Every field type must implement [`BoundToRuntimeAppPublic`](crate::BoundToRuntimeAppPublic).
+/// `KeyTypeIdProviders` is set to the types given as fields.
+///
+/// ```rust
+/// use sp_runtime::{
+/// 	impl_opaque_keys, KeyTypeId, BoundToRuntimeAppPublic, app_crypto::{sr25519, ed25519}
+/// };
+///
+/// pub struct KeyModule;
+/// impl BoundToRuntimeAppPublic for KeyModule { type Public = ed25519::AppPublic; }
+///
+/// pub struct KeyModule2;
+/// impl BoundToRuntimeAppPublic for KeyModule2 { type Public = sr25519::AppPublic; }
+///
+/// impl_opaque_keys! {
+/// 	pub struct Keys {
+/// 		pub key_module: KeyModule,
+/// 		pub key_module2: KeyModule2,
+/// 	}
+/// }
+/// ```
+#[macro_export]
+#[cfg(any(feature = "serde", feature = "std"))]
+macro_rules! impl_opaque_keys {
+	{
+		$( #[ $attr:meta ] )*
+		pub struct $name:ident {
+			$(
+				$( #[ $inner_attr:meta ] )*
+				pub $field:ident: $type:ty,
+			)*
+		}
+	} => {
+		$crate::paste::paste! {
+			use $crate::serde as [< __opaque_keys_serde_import__ $name >];
+
+			$crate::impl_opaque_keys_inner! {
+				$( #[ $attr ] )*
+				#[derive($crate::serde::Serialize, $crate::serde::Deserialize)]
+				#[serde(crate = "__opaque_keys_serde_import__" $name)]
+				pub struct $name {
+					$(
+						$( #[ $inner_attr ] )*
+						pub $field: $type,
+					)*
+				}
+			}
+		}
+	}
+}
+
+#[macro_export]
+#[cfg(all(not(feature = "std"), not(feature = "serde")))]
+#[doc(hidden)]
+macro_rules! impl_opaque_keys {
+	{
+		$( #[ $attr:meta ] )*
+		pub struct $name:ident {
+			$(
+				$( #[ $inner_attr:meta ] )*
+				pub $field:ident: $type:ty,
+			)*
+		}
+	} => {
+		$crate::impl_opaque_keys_inner! {
+			$( #[ $attr ] )*
+			pub struct $name {
+				$(
+					$( #[ $inner_attr ] )*
+					pub $field: $type,
+				)*
+			}
+		}
+	}
+}
+
+/// Trait for things which can be printed from the runtime.
+pub trait Printable {
+	/// Print the object.
+	fn print(&self);
+}
+
+impl<T: Printable> Printable for &T {
+	fn print(&self) {
+		(*self).print()
+	}
+}
+
+impl Printable for u8 {
+	fn print(&self) {
+		(*self as u64).print()
+	}
+}
+
+impl Printable for u32 {
+	fn print(&self) {
+		(*self as u64).print()
+	}
+}
+
+impl Printable for usize {
+	fn print(&self) {
+		(*self as u64).print()
+	}
+}
+
+impl Printable for u64 {
+	fn print(&self) {
+		sp_io::misc::print_num(*self);
+	}
+}
+
+impl Printable for &[u8] {
+	fn print(&self) {
+		sp_io::misc::print_hex(self);
+	}
+}
+
+impl<const N: usize> Printable for [u8; N] {
+	fn print(&self) {
+		sp_io::misc::print_hex(&self[..]);
+	}
+}
+
+impl Printable for &str {
+	fn print(&self) {
+		sp_io::misc::print_utf8(self.as_bytes());
+	}
+}
+
+impl Printable for bool {
+	fn print(&self) {
+		if *self {
+			"true".print()
+		} else {
+			"false".print()
+		}
+	}
+}
+
+impl Printable for sp_weights::Weight {
+	fn print(&self) {
+		self.ref_time().print()
+	}
+}
+
+impl Printable for () {
+	fn print(&self) {
+		"()".print()
+	}
+}
+
+#[impl_for_tuples(1, 12)]
+impl Printable for Tuple {
+	fn print(&self) {
+		for_tuples!( #( Tuple.print(); )* )
+	}
+}
+
+/// Something that can convert a [`BlockId`](crate::generic::BlockId) to a number or a hash.
+#[cfg(feature = "std")]
+pub trait BlockIdTo<Block: self::Block> {
+	/// The error type that will be returned by the functions.
+	type Error: std::error::Error;
+
+	/// Convert the given `block_id` to the corresponding block hash.
+	fn to_hash(
+		&self,
+		block_id: &crate::generic::BlockId<Block>,
+	) -> Result<Option<Block::Hash>, Self::Error>;
+
+	/// Convert the given `block_id` to the corresponding block number.
+	fn to_number(
+		&self,
+		block_id: &crate::generic::BlockId<Block>,
+	) -> Result<Option<NumberFor<Block>>, Self::Error>;
+}
+
+/// Get current block number
+pub trait BlockNumberProvider {
+	/// Type of `BlockNumber` to provide.
+	type BlockNumber: Codec + Clone + Ord + Eq + AtLeast32BitUnsigned;
+
+	/// Returns the current block number.
+	///
+	/// Provides an abstraction over an arbitrary way of providing the
+	/// current block number.
+	///
+	/// In case of using crate `sp_runtime` with the crate `frame-system`,
+	/// it is already implemented for
+	/// `frame_system::Pallet<T: Config>` as:
+	///
+	/// ```ignore
+	/// fn current_block_number() -> Self {
+	///     frame_system::Pallet<Config>::block_number()
+	/// }
+	/// ```
+	/// .
+	fn current_block_number() -> Self::BlockNumber;
+
+	/// Utility function only to be used in benchmarking scenarios, to be implemented optionally,
+	/// else a noop.
+	///
+	/// It allows for setting the block number that will later be fetched
+	/// This is useful in case the block number provider is different than System
+	#[cfg(feature = "runtime-benchmarks")]
+	fn set_block_number(_block: Self::BlockNumber) {}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::codec::{Decode, Encode, Input};
+	#[cfg(feature = "bls-experimental")]
+	use sp_core::{bls377, bls381};
+	use sp_core::{
+		crypto::{Pair, UncheckedFrom},
+		ecdsa, ed25519, sr25519,
+	};
+
+	macro_rules! signature_verify_test {
+		($algorithm:ident) => {
+			let msg = &b"test-message"[..];
+			let wrong_msg = &b"test-msg"[..];
+			let (pair, _) = $algorithm::Pair::generate();
+
+			let signature = pair.sign(&msg);
+			assert!($algorithm::Pair::verify(&signature, msg, &pair.public()));
+
+			assert!(signature.verify(msg, &pair.public()));
+			assert!(!signature.verify(wrong_msg, &pair.public()));
+		};
+	}
+
+	mod t {
+		use sp_application_crypto::{app_crypto, sr25519};
+		use sp_core::crypto::KeyTypeId;
+		app_crypto!(sr25519, KeyTypeId(*b"test"));
+	}
+
+	#[test]
+	fn app_verify_works() {
+		use super::AppVerify;
+		use t::*;
+
+		let s = Signature::try_from(vec![0; 64]).unwrap();
+		let _ = s.verify(&[0u8; 100][..], &Public::unchecked_from([0; 32]));
+	}
+
+	#[derive(Encode, Decode, Default, PartialEq, Debug)]
+	struct U128Value(u128);
+	impl super::TypeId for U128Value {
+		const TYPE_ID: [u8; 4] = [0x0d, 0xf0, 0x0d, 0xf0];
+	}
+	// f00df00d
+
+	#[derive(Encode, Decode, Default, PartialEq, Debug)]
+	struct U32Value(u32);
+	impl super::TypeId for U32Value {
+		const TYPE_ID: [u8; 4] = [0x0d, 0xf0, 0xfe, 0xca];
+	}
+	// cafef00d
+
+	#[derive(Encode, Decode, Default, PartialEq, Debug)]
+	struct U16Value(u16);
+	impl super::TypeId for U16Value {
+		const TYPE_ID: [u8; 4] = [0xfe, 0xca, 0x0d, 0xf0];
+	}
+	// f00dcafe
+
+	type AccountId = u64;
+
+	#[test]
+	fn into_account_truncating_should_work() {
+		let r: AccountId = U32Value::into_account_truncating(&U32Value(0xdeadbeef));
+		assert_eq!(r, 0x_deadbeef_cafef00d);
+	}
+
+	#[test]
+	fn try_into_account_should_work() {
+		let r: AccountId = U32Value::try_into_account(&U32Value(0xdeadbeef)).unwrap();
+		assert_eq!(r, 0x_deadbeef_cafef00d);
+
+		// u128 is bigger than u64 would fit
+		let maybe: Option<AccountId> = U128Value::try_into_account(&U128Value(u128::MAX));
+		assert!(maybe.is_none());
+	}
+
+	#[test]
+	fn try_from_account_should_work() {
+		let r = U32Value::try_from_account(&0x_deadbeef_cafef00d_u64);
+		assert_eq!(r.unwrap(), U32Value(0xdeadbeef));
+	}
+
+	#[test]
+	fn into_account_truncating_with_fill_should_work() {
+		let r: AccountId = U16Value::into_account_truncating(&U16Value(0xc0da));
+		assert_eq!(r, 0x_0000_c0da_f00dcafe);
+	}
+
+	#[test]
+	fn try_into_sub_account_should_work() {
+		let r: AccountId = U16Value::try_into_account(&U16Value(0xc0da)).unwrap();
+		assert_eq!(r, 0x_0000_c0da_f00dcafe);
+
+		let maybe: Option<AccountId> = U16Value::try_into_sub_account(
+			&U16Value(0xc0da),
+			"a really large amount of additional encoded information which will certainly overflow the account id type ;)"
+		);
+
+		assert!(maybe.is_none())
+	}
+
+	#[test]
+	fn try_from_account_with_fill_should_work() {
+		let r = U16Value::try_from_account(&0x0000_c0da_f00dcafe_u64);
+		assert_eq!(r.unwrap(), U16Value(0xc0da));
+	}
+
+	#[test]
+	fn bad_try_from_account_should_fail() {
+		let r = U16Value::try_from_account(&0x0000_c0de_baadcafe_u64);
+		assert!(r.is_none());
+		let r = U16Value::try_from_account(&0x0100_c0da_f00dcafe_u64);
+		assert!(r.is_none());
+	}
+
+	#[test]
+	fn trailing_zero_should_work() {
+		let mut t = super::TrailingZeroInput(&[1, 2, 3]);
+		assert_eq!(t.remaining_len(), Ok(None));
+		let mut buffer = [0u8; 2];
+		assert_eq!(t.read(&mut buffer), Ok(()));
+		assert_eq!(t.remaining_len(), Ok(None));
+		assert_eq!(buffer, [1, 2]);
+		assert_eq!(t.read(&mut buffer), Ok(()));
+		assert_eq!(t.remaining_len(), Ok(None));
+		assert_eq!(buffer, [3, 0]);
+		assert_eq!(t.read(&mut buffer), Ok(()));
+		assert_eq!(t.remaining_len(), Ok(None));
+		assert_eq!(buffer, [0, 0]);
+	}
+
+	#[test]
+	fn ed25519_verify_works() {
+		signature_verify_test!(ed25519);
+	}
+
+	#[test]
+	fn sr25519_verify_works() {
+		signature_verify_test!(sr25519);
+	}
+
+	#[test]
+	fn ecdsa_verify_works() {
+		signature_verify_test!(ecdsa);
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls377_verify_works() {
+		signature_verify_test!(bls377)
+	}
+
+	#[cfg(feature = "bls-experimental")]
+	fn bls381_verify_works() {
+		signature_verify_test!(bls381)
+	}
+}
diff --git a/substrate/primitives/runtime/src/transaction_validity.rs b/substrate/primitives/runtime/src/transaction_validity.rs
new file mode 100644
index 0000000000000000000000000000000000000000..836948493823cb4d137ce90721788e9a78a8ac99
--- /dev/null
+++ b/substrate/primitives/runtime/src/transaction_validity.rs
@@ -0,0 +1,475 @@
+// 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.
+
+//! Transaction validity interface.
+
+use crate::{
+	codec::{Decode, Encode},
+	RuntimeDebug,
+};
+use scale_info::TypeInfo;
+use sp_std::prelude::*;
+
+/// Priority for a transaction. Additive. Higher is better.
+pub type TransactionPriority = u64;
+
+/// Minimum number of blocks a transaction will remain valid for.
+/// `TransactionLongevity::max_value()` means "forever".
+pub type TransactionLongevity = u64;
+
+/// Tag for a transaction. No two transactions with the same tag should be placed on-chain.
+pub type TransactionTag = Vec<u8>;
+
+/// An invalid transaction validity.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, Copy, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum InvalidTransaction {
+	/// The call of the transaction is not expected.
+	Call,
+	/// General error to do with the inability to pay some fees (e.g. account balance too low).
+	Payment,
+	/// General error to do with the transaction not yet being valid (e.g. nonce too high).
+	Future,
+	/// General error to do with the transaction being outdated (e.g. nonce too low).
+	Stale,
+	/// General error to do with the transaction's proofs (e.g. signature).
+	///
+	/// # Possible causes
+	///
+	/// When using a signed extension that provides additional data for signing, it is required
+	/// that the signing and the verifying side use the same additional data. Additional
+	/// data will only be used to generate the signature, but will not be part of the transaction
+	/// itself. As the verifying side does not know which additional data was used while signing
+	/// it will only be able to assume a bad signature and cannot express a more meaningful error.
+	BadProof,
+	/// The transaction birth block is ancient.
+	///
+	/// # Possible causes
+	///
+	/// For `FRAME`-based runtimes this would be caused by `current block number
+	/// - Era::birth block number > BlockHashCount`. (e.g. in Polkadot `BlockHashCount` = 2400, so
+	///   a
+	/// transaction with birth block number 1337 would be valid up until block number 1337 + 2400,
+	/// after which point the transaction would be considered to have an ancient birth block.)
+	AncientBirthBlock,
+	/// The transaction would exhaust the resources of current block.
+	///
+	/// The transaction might be valid, but there are not enough resources
+	/// left in the current block.
+	ExhaustsResources,
+	/// Any other custom invalid validity that is not covered by this enum.
+	Custom(u8),
+	/// An extrinsic with a Mandatory dispatch resulted in Error. This is indicative of either a
+	/// malicious validator or a buggy `provide_inherent`. In any case, it can result in
+	/// dangerously overweight blocks and therefore if found, invalidates the block.
+	BadMandatory,
+	/// An extrinsic with a mandatory dispatch tried to be validated.
+	/// This is invalid; only inherent extrinsics are allowed to have mandatory dispatches.
+	MandatoryValidation,
+	/// The sending address is disabled or known to be invalid.
+	BadSigner,
+}
+
+impl InvalidTransaction {
+	/// Returns if the reason for the invalidity was block resource exhaustion.
+	pub fn exhausted_resources(&self) -> bool {
+		matches!(self, Self::ExhaustsResources)
+	}
+
+	/// Returns if the reason for the invalidity was a mandatory call failing.
+	pub fn was_mandatory(&self) -> bool {
+		matches!(self, Self::BadMandatory)
+	}
+}
+
+impl From<InvalidTransaction> for &'static str {
+	fn from(invalid: InvalidTransaction) -> &'static str {
+		match invalid {
+			InvalidTransaction::Call => "Transaction call is not expected",
+			InvalidTransaction::Future => "Transaction will be valid in the future",
+			InvalidTransaction::Stale => "Transaction is outdated",
+			InvalidTransaction::BadProof => "Transaction has a bad signature",
+			InvalidTransaction::AncientBirthBlock => "Transaction has an ancient birth block",
+			InvalidTransaction::ExhaustsResources => "Transaction would exhaust the block limits",
+			InvalidTransaction::Payment =>
+				"Inability to pay some fees (e.g. account balance too low)",
+			InvalidTransaction::BadMandatory =>
+				"A call was labelled as mandatory, but resulted in an Error.",
+			InvalidTransaction::MandatoryValidation =>
+				"Transaction dispatch is mandatory; transactions must not be validated.",
+			InvalidTransaction::Custom(_) => "InvalidTransaction custom error",
+			InvalidTransaction::BadSigner => "Invalid signing address",
+		}
+	}
+}
+
+/// An unknown transaction validity.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, Copy, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum UnknownTransaction {
+	/// Could not lookup some information that is required to validate the transaction.
+	CannotLookup,
+	/// No validator found for the given unsigned transaction.
+	NoUnsignedValidator,
+	/// Any other custom unknown validity that is not covered by this enum.
+	Custom(u8),
+}
+
+impl From<UnknownTransaction> for &'static str {
+	fn from(unknown: UnknownTransaction) -> &'static str {
+		match unknown {
+			UnknownTransaction::CannotLookup =>
+				"Could not lookup information required to validate the transaction",
+			UnknownTransaction::NoUnsignedValidator =>
+				"Could not find an unsigned validator for the unsigned transaction",
+			UnknownTransaction::Custom(_) => "UnknownTransaction custom error",
+		}
+	}
+}
+
+/// Errors that can occur while checking the validity of a transaction.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, Copy, RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum TransactionValidityError {
+	/// The transaction is invalid.
+	Invalid(InvalidTransaction),
+	/// Transaction validity can't be determined.
+	Unknown(UnknownTransaction),
+}
+
+impl TransactionValidityError {
+	/// Returns `true` if the reason for the error was block resource exhaustion.
+	pub fn exhausted_resources(&self) -> bool {
+		match self {
+			Self::Invalid(e) => e.exhausted_resources(),
+			Self::Unknown(_) => false,
+		}
+	}
+
+	/// Returns `true` if the reason for the error was it being a mandatory dispatch that could not
+	/// be completed successfully.
+	pub fn was_mandatory(&self) -> bool {
+		match self {
+			Self::Invalid(e) => e.was_mandatory(),
+			Self::Unknown(_) => false,
+		}
+	}
+}
+
+impl From<TransactionValidityError> for &'static str {
+	fn from(err: TransactionValidityError) -> &'static str {
+		match err {
+			TransactionValidityError::Invalid(invalid) => invalid.into(),
+			TransactionValidityError::Unknown(unknown) => unknown.into(),
+		}
+	}
+}
+
+impl From<InvalidTransaction> for TransactionValidityError {
+	fn from(err: InvalidTransaction) -> Self {
+		TransactionValidityError::Invalid(err)
+	}
+}
+
+impl From<UnknownTransaction> for TransactionValidityError {
+	fn from(err: UnknownTransaction) -> Self {
+		TransactionValidityError::Unknown(err)
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for TransactionValidityError {
+	fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+		None
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for TransactionValidityError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		let s: &'static str = (*self).into();
+		write!(f, "{}", s)
+	}
+}
+
+/// Information on a transaction's validity and, if valid, on how it relates to other transactions.
+pub type TransactionValidity = Result<ValidTransaction, TransactionValidityError>;
+
+impl From<InvalidTransaction> for TransactionValidity {
+	fn from(invalid_transaction: InvalidTransaction) -> Self {
+		Err(TransactionValidityError::Invalid(invalid_transaction))
+	}
+}
+
+impl From<UnknownTransaction> for TransactionValidity {
+	fn from(unknown_transaction: UnknownTransaction) -> Self {
+		Err(TransactionValidityError::Unknown(unknown_transaction))
+	}
+}
+
+/// The source of the transaction.
+///
+/// Depending on the source we might apply different validation schemes.
+/// For instance we can disallow specific kinds of transactions if they were not produced
+/// by our local node (for instance off-chain workers).
+#[derive(Copy, Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub enum TransactionSource {
+	/// Transaction is already included in block.
+	///
+	/// This means that we can't really tell where the transaction is coming from,
+	/// since it's already in the received block. Note that the custom validation logic
+	/// using either `Local` or `External` should most likely just allow `InBlock`
+	/// transactions as well.
+	InBlock,
+
+	/// Transaction is coming from a local source.
+	///
+	/// This means that the transaction was produced internally by the node
+	/// (for instance an Off-Chain Worker, or an Off-Chain Call), as opposed
+	/// to being received over the network.
+	Local,
+
+	/// Transaction has been received externally.
+	///
+	/// This means the transaction has been received from (usually) "untrusted" source,
+	/// for instance received over the network or RPC.
+	External,
+}
+
+/// Information concerning a valid transaction.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct ValidTransaction {
+	/// Priority of the transaction.
+	///
+	/// Priority determines the ordering of two transactions that have all
+	/// their dependencies (required tags) satisfied.
+	pub priority: TransactionPriority,
+	/// Transaction dependencies
+	///
+	/// A non-empty list signifies that some other transactions which provide
+	/// given tags are required to be included before that one.
+	pub requires: Vec<TransactionTag>,
+	/// Provided tags
+	///
+	/// A list of tags this transaction provides. Successfully importing the transaction
+	/// will enable other transactions that depend on (require) those tags to be included as well.
+	/// Provided and required tags allow Substrate to build a dependency graph of transactions
+	/// and import them in the right (linear) order.
+	pub provides: Vec<TransactionTag>,
+	/// Transaction longevity
+	///
+	/// Longevity describes minimum number of blocks the validity is correct.
+	/// After this period transaction should be removed from the pool or revalidated.
+	pub longevity: TransactionLongevity,
+	/// A flag indicating if the transaction should be propagated to other peers.
+	///
+	/// By setting `false` here the transaction will still be considered for
+	/// including in blocks that are authored on the current node, but will
+	/// never be sent to other peers.
+	pub propagate: bool,
+}
+
+impl Default for ValidTransaction {
+	fn default() -> Self {
+		Self {
+			priority: 0,
+			requires: vec![],
+			provides: vec![],
+			longevity: TransactionLongevity::max_value(),
+			propagate: true,
+		}
+	}
+}
+
+impl ValidTransaction {
+	/// Initiate `ValidTransaction` builder object with a particular prefix for tags.
+	///
+	/// To avoid conflicts between different parts in runtime it's recommended to build `requires`
+	/// and `provides` tags with a unique prefix.
+	pub fn with_tag_prefix(prefix: &'static str) -> ValidTransactionBuilder {
+		ValidTransactionBuilder { prefix: Some(prefix), validity: Default::default() }
+	}
+
+	/// Combine two instances into one, as a best effort. This will take the superset of each of the
+	/// `provides` and `requires` tags, it will sum the priorities, take the minimum longevity and
+	/// the logic *And* of the propagate flags.
+	pub fn combine_with(mut self, mut other: ValidTransaction) -> Self {
+		Self {
+			priority: self.priority.saturating_add(other.priority),
+			requires: {
+				self.requires.append(&mut other.requires);
+				self.requires
+			},
+			provides: {
+				self.provides.append(&mut other.provides);
+				self.provides
+			},
+			longevity: self.longevity.min(other.longevity),
+			propagate: self.propagate && other.propagate,
+		}
+	}
+}
+
+/// `ValidTransaction` builder.
+///
+///
+/// Allows to easily construct `ValidTransaction` and most importantly takes care of
+/// prefixing `requires` and `provides` tags to avoid conflicts.
+#[derive(Default, Clone, RuntimeDebug)]
+pub struct ValidTransactionBuilder {
+	prefix: Option<&'static str>,
+	validity: ValidTransaction,
+}
+
+impl ValidTransactionBuilder {
+	/// Set the priority of a transaction.
+	///
+	/// Note that the final priority for `FRAME` is combined from all `SignedExtension`s.
+	/// Most likely for unsigned transactions you want the priority to be higher
+	/// than for regular transactions. We recommend exposing a base priority for unsigned
+	/// transactions as a runtime module parameter, so that the runtime can tune inter-module
+	/// priorities.
+	pub fn priority(mut self, priority: TransactionPriority) -> Self {
+		self.validity.priority = priority;
+		self
+	}
+
+	/// Set the longevity of a transaction.
+	///
+	/// By default the transaction will be considered valid forever and will not be revalidated
+	/// by the transaction pool. It's recommended though to set the longevity to a finite value
+	/// though. If unsure, it's also reasonable to expose this parameter via module configuration
+	/// and let the runtime decide.
+	pub fn longevity(mut self, longevity: TransactionLongevity) -> Self {
+		self.validity.longevity = longevity;
+		self
+	}
+
+	/// Set the propagate flag.
+	///
+	/// Set to `false` if the transaction is not meant to be gossiped to peers. Combined with
+	/// `TransactionSource::Local` validation it can be used to have special kind of
+	/// transactions that are only produced and included by the validator nodes.
+	pub fn propagate(mut self, propagate: bool) -> Self {
+		self.validity.propagate = propagate;
+		self
+	}
+
+	/// Add a `TransactionTag` to the set of required tags.
+	///
+	/// The tag will be encoded and prefixed with module prefix (if any).
+	/// If you'd rather add a raw `require` tag, consider using `#combine_with` method.
+	pub fn and_requires(mut self, tag: impl Encode) -> Self {
+		self.validity.requires.push(match self.prefix.as_ref() {
+			Some(prefix) => (prefix, tag).encode(),
+			None => tag.encode(),
+		});
+		self
+	}
+
+	/// Add a `TransactionTag` to the set of provided tags.
+	///
+	/// The tag will be encoded and prefixed with module prefix (if any).
+	/// If you'd rather add a raw `require` tag, consider using `#combine_with` method.
+	pub fn and_provides(mut self, tag: impl Encode) -> Self {
+		self.validity.provides.push(match self.prefix.as_ref() {
+			Some(prefix) => (prefix, tag).encode(),
+			None => tag.encode(),
+		});
+		self
+	}
+
+	/// Augment the builder with existing `ValidTransaction`.
+	///
+	/// This method does add the prefix to `require` or `provides` tags.
+	pub fn combine_with(mut self, validity: ValidTransaction) -> Self {
+		self.validity = core::mem::take(&mut self.validity).combine_with(validity);
+		self
+	}
+
+	/// Finalize the builder and produce `TransactionValidity`.
+	///
+	/// Note the result will always be `Ok`. Use `Into` to produce `ValidTransaction`.
+	pub fn build(self) -> TransactionValidity {
+		self.into()
+	}
+}
+
+impl From<ValidTransactionBuilder> for TransactionValidity {
+	fn from(builder: ValidTransactionBuilder) -> Self {
+		Ok(builder.into())
+	}
+}
+
+impl From<ValidTransactionBuilder> for ValidTransaction {
+	fn from(builder: ValidTransactionBuilder) -> Self {
+		builder.validity
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn should_encode_and_decode() {
+		let v: TransactionValidity = Ok(ValidTransaction {
+			priority: 5,
+			requires: vec![vec![1, 2, 3, 4]],
+			provides: vec![vec![4, 5, 6]],
+			longevity: 42,
+			propagate: false,
+		});
+
+		let encoded = v.encode();
+		assert_eq!(
+			encoded,
+			vec![
+				0, 5, 0, 0, 0, 0, 0, 0, 0, 4, 16, 1, 2, 3, 4, 4, 12, 4, 5, 6, 42, 0, 0, 0, 0, 0, 0,
+				0, 0
+			]
+		);
+
+		// decode back
+		assert_eq!(TransactionValidity::decode(&mut &*encoded), Ok(v));
+	}
+
+	#[test]
+	fn builder_should_prefix_the_tags() {
+		const PREFIX: &str = "test";
+		let a: ValidTransaction = ValidTransaction::with_tag_prefix(PREFIX)
+			.and_requires(1)
+			.and_requires(2)
+			.and_provides(3)
+			.and_provides(4)
+			.propagate(false)
+			.longevity(5)
+			.priority(3)
+			.priority(6)
+			.into();
+		assert_eq!(
+			a,
+			ValidTransaction {
+				propagate: false,
+				longevity: 5,
+				priority: 6,
+				requires: vec![(PREFIX, 1).encode(), (PREFIX, 2).encode()],
+				provides: vec![(PREFIX, 3).encode(), (PREFIX, 4).encode()],
+			}
+		);
+	}
+}
diff --git a/substrate/primitives/session/Cargo.toml b/substrate/primitives/session/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..79ccc110aa781686d8497d9662b53c551ebe510a
--- /dev/null
+++ b/substrate/primitives/session/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "sp-session"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Primitives for sessions"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-runtime = { version = "24.0.0", optional = true, path = "../runtime" }
+sp-staking = { version = "4.0.0-dev", default-features = false, path = "../staking" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-keystore = { version = "0.27.0", path = "../keystore", optional = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-core/std",
+	"sp-keystore/std",
+	"sp-runtime/std",
+	"sp-staking/std",
+	"sp-std/std",
+]
diff --git a/substrate/primitives/session/README.md b/substrate/primitives/session/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d1f9d9bc1d5b3cb77125be91d847b97c276833c
--- /dev/null
+++ b/substrate/primitives/session/README.md
@@ -0,0 +1,3 @@
+Substrate core types around sessions.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/session/src/lib.rs b/substrate/primitives/session/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..45395e9766f55920f5ca4700c398aae02bd6decd
--- /dev/null
+++ b/substrate/primitives/session/src/lib.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.
+
+//! Substrate core types around sessions.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+
+#[cfg(feature = "std")]
+use sp_api::ProvideRuntimeApi;
+#[cfg(feature = "std")]
+use sp_runtime::traits::Block as BlockT;
+
+use sp_core::{crypto::KeyTypeId, RuntimeDebug};
+use sp_staking::SessionIndex;
+use sp_std::vec::Vec;
+
+sp_api::decl_runtime_apis! {
+	/// Session keys runtime api.
+	pub trait SessionKeys {
+		/// Generate a set of session keys with optionally using the given seed.
+		/// The keys should be stored within the keystore exposed via runtime
+		/// externalities.
+		///
+		/// The seed needs to be a valid `utf8` string.
+		///
+		/// Returns the concatenated SCALE encoded public keys.
+		fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8>;
+
+		/// Decode the given public session keys.
+		///
+		/// Returns the list of public raw public keys + key type.
+		fn decode_session_keys(encoded: Vec<u8>) -> Option<Vec<(Vec<u8>, KeyTypeId)>>;
+	}
+}
+
+/// Number of validators in a given session.
+pub type ValidatorCount = u32;
+
+/// Proof of membership of a specific key in a given session.
+#[derive(Encode, Decode, Clone, Eq, PartialEq, Default, RuntimeDebug, scale_info::TypeInfo)]
+pub struct MembershipProof {
+	/// The session index on which the specific key is a member.
+	pub session: SessionIndex,
+	/// Trie nodes of a merkle proof of session membership.
+	pub trie_nodes: Vec<Vec<u8>>,
+	/// The validator count of the session on which the specific key is a member.
+	pub validator_count: ValidatorCount,
+}
+
+/// A utility trait to get a session number. This is implemented for
+/// `MembershipProof` below to fetch the session number the given session
+/// membership proof is for. It is useful when we need to deal with key owner
+/// proofs generically (i.e. just typing against the `KeyOwnerProofSystem`
+/// trait) but still restrict their capabilities.
+pub trait GetSessionNumber {
+	fn session(&self) -> SessionIndex;
+}
+
+/// A utility trait to get the validator count of a given session. This is
+/// implemented for `MembershipProof` below and fetches the number of validators
+/// in the session the membership proof is for. It is useful when we need to
+/// deal with key owner proofs generically (i.e. just typing against the
+/// `KeyOwnerProofSystem` trait) but still restrict their capabilities.
+pub trait GetValidatorCount {
+	fn validator_count(&self) -> ValidatorCount;
+}
+
+impl GetSessionNumber for sp_core::Void {
+	fn session(&self) -> SessionIndex {
+		Default::default()
+	}
+}
+
+impl GetValidatorCount for sp_core::Void {
+	fn validator_count(&self) -> ValidatorCount {
+		Default::default()
+	}
+}
+
+impl GetSessionNumber for MembershipProof {
+	fn session(&self) -> SessionIndex {
+		self.session
+	}
+}
+
+impl GetValidatorCount for MembershipProof {
+	fn validator_count(&self) -> ValidatorCount {
+		self.validator_count
+	}
+}
+
+/// Generate the initial session keys with the given seeds, at the given block and store them in
+/// the client's keystore.
+#[cfg(feature = "std")]
+pub fn generate_initial_session_keys<Block, T>(
+	client: std::sync::Arc<T>,
+	at: Block::Hash,
+	seeds: Vec<String>,
+	keystore: sp_keystore::KeystorePtr,
+) -> Result<(), sp_api::ApiError>
+where
+	Block: BlockT,
+	T: ProvideRuntimeApi<Block>,
+	T::Api: SessionKeys<Block>,
+{
+	use sp_api::ApiExt;
+
+	if seeds.is_empty() {
+		return Ok(())
+	}
+
+	let mut runtime_api = client.runtime_api();
+
+	runtime_api.register_extension(sp_keystore::KeystoreExt::from(keystore));
+
+	for seed in seeds {
+		runtime_api.generate_session_keys(at, Some(seed.as_bytes().to_vec()))?;
+	}
+
+	Ok(())
+}
diff --git a/substrate/primitives/staking/Cargo.toml b/substrate/primitives/staking/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8fe2f19ad19f6ee442188d024b8144ebeca9ade6
--- /dev/null
+++ b/substrate/primitives/staking/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "sp-staking"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "A crate which contains primitives that are useful for implementation that uses staking approaches in general. Definitions related to sessions, slashing, etc go here."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+serde = { version = "1.0.163", default-features = false, features = ["derive", "alloc"], optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+impl-trait-for-tuples = "0.2.2"
+
+sp-core = { default-features = false, path = "../core" }
+sp-runtime = { default-features = false, path = "../runtime" }
+sp-std = { default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+runtime-benchmarks = [ "sp-runtime/runtime-benchmarks" ]
diff --git a/substrate/primitives/staking/README.md b/substrate/primitives/staking/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..892e1379d9a53d9677bcc13f5f0ba42b61ae6a0b
--- /dev/null
+++ b/substrate/primitives/staking/README.md
@@ -0,0 +1,4 @@
+A crate which contains primitives that are useful for implementation that uses staking
+approaches in general. Definitions related to sessions, slashing, etc go here.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/staking/src/currency_to_vote.rs b/substrate/primitives/staking/src/currency_to_vote.rs
new file mode 100644
index 0000000000000000000000000000000000000000..556e5bd210426faeb8d774f88a8ebd5dfb1dd029
--- /dev/null
+++ b/substrate/primitives/staking/src/currency_to_vote.rs
@@ -0,0 +1,101 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-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.
+
+use sp_runtime::{
+	traits::{UniqueSaturatedFrom, UniqueSaturatedInto},
+	SaturatedConversion,
+};
+
+/// A trait similar to `Convert` to convert values from `B` an abstract balance type
+/// into u64 and back from u128. (This conversion is used in election and other places where complex
+/// calculation over balance type is needed)
+///
+/// Total issuance of the currency is passed in, but an implementation of this trait may or may not
+/// use it.
+///
+/// # WARNING
+///
+/// the total issuance being passed in implies that the implementation must be aware of the fact
+/// that its values can affect the outcome. This implies that if the vote value is dependent on the
+/// total issuance, it should never ber written to storage for later re-use.
+pub trait CurrencyToVote<B> {
+	/// Convert balance to u64.
+	fn to_vote(value: B, issuance: B) -> u64;
+
+	/// Convert u128 to balance.
+	fn to_currency(value: u128, issuance: B) -> B;
+}
+
+/// An implementation of `CurrencyToVote` tailored for chain's that have a balance type of u128.
+///
+/// The factor is the `(total_issuance / u64::MAX).max(1)`, represented as u64. Let's look at the
+/// important cases:
+///
+/// If the chain's total issuance is less than u64::MAX, this will always be 1, which means that
+/// the factor will not have any effect. In this case, any account's balance is also less. Thus,
+/// both of the conversions are basically an `as`; Any balance can fit in u64.
+///
+/// If the chain's total issuance is more than 2*u64::MAX, then a factor might be multiplied and
+/// divided upon conversion.
+pub struct U128CurrencyToVote;
+
+impl U128CurrencyToVote {
+	fn factor(issuance: u128) -> u128 {
+		(issuance / u64::MAX as u128).max(1)
+	}
+}
+
+impl CurrencyToVote<u128> for U128CurrencyToVote {
+	fn to_vote(value: u128, issuance: u128) -> u64 {
+		(value / Self::factor(issuance)).saturated_into()
+	}
+
+	fn to_currency(value: u128, issuance: u128) -> u128 {
+		value.saturating_mul(Self::factor(issuance))
+	}
+}
+
+/// A naive implementation of `CurrencyConvert` that simply saturates all conversions.
+///
+/// # Warning
+///
+/// This is designed to be used mostly for testing. Use with care, and think about the consequences.
+pub struct SaturatingCurrencyToVote;
+
+impl<B: UniqueSaturatedInto<u64> + UniqueSaturatedFrom<u128>> CurrencyToVote<B>
+	for SaturatingCurrencyToVote
+{
+	fn to_vote(value: B, _: B) -> u64 {
+		value.unique_saturated_into()
+	}
+
+	fn to_currency(value: u128, _: B) -> B {
+		B::unique_saturated_from(value)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<B: UniqueSaturatedInto<u64> + UniqueSaturatedFrom<u128>> CurrencyToVote<B> for () {
+	fn to_vote(value: B, issuance: B) -> u64 {
+		SaturatingCurrencyToVote::to_vote(value, issuance)
+	}
+
+	/// Convert u128 to balance.
+	fn to_currency(value: u128, issuance: B) -> B {
+		SaturatingCurrencyToVote::to_currency(value, issuance)
+	}
+}
diff --git a/substrate/primitives/staking/src/lib.rs b/substrate/primitives/staking/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1621af164b375cfec231777e08af83b839b45892
--- /dev/null
+++ b/substrate/primitives/staking/src/lib.rs
@@ -0,0 +1,275 @@
+// 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 crate which contains primitives that are useful for implementation that uses staking
+//! approaches in general. Definitions related to sessions, slashing, etc go here.
+
+use crate::currency_to_vote::CurrencyToVote;
+use codec::{FullCodec, MaxEncodedLen};
+use scale_info::TypeInfo;
+use sp_core::RuntimeDebug;
+use sp_runtime::{DispatchError, DispatchResult, Saturating};
+use sp_std::{collections::btree_map::BTreeMap, ops::Sub, vec::Vec};
+
+pub mod offence;
+
+pub mod currency_to_vote;
+
+/// Simple index type with which we can count sessions.
+pub type SessionIndex = u32;
+
+/// Counter for the number of eras that have passed.
+pub type EraIndex = u32;
+
+/// Representation of the status of a staker.
+#[derive(RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone))]
+pub enum StakerStatus<AccountId> {
+	/// Chilling.
+	Idle,
+	/// Declaring desire in validate, i.e author blocks.
+	Validator,
+	/// Declaring desire to nominate, delegate, or generally approve of the given set of others.
+	Nominator(Vec<AccountId>),
+}
+
+/// A struct that reflects stake that an account has in the staking system. Provides a set of
+/// methods to operate on it's properties. Aimed at making `StakingInterface` more concise.
+#[derive(RuntimeDebug, Clone, Copy, Eq, PartialEq, Default)]
+pub struct Stake<Balance> {
+	/// The total stake that `stash` has in the staking system. This includes the
+	/// `active` stake, and any funds currently in the process of unbonding via
+	/// [`StakingInterface::unbond`].
+	///
+	/// # Note
+	///
+	/// This is only guaranteed to reflect the amount locked by the staking system. If there are
+	/// non-staking locks on the bonded pair's balance this amount is going to be larger in
+	/// reality.
+	pub total: Balance,
+	/// The total amount of the stash's balance that will be at stake in any forthcoming
+	/// rounds.
+	pub active: Balance,
+}
+
+/// A generic staking event listener.
+///
+/// Note that the interface is designed in a way that the events are fired post-action, so any
+/// pre-action data that is needed needs to be passed to interface methods. The rest of the data can
+/// be retrieved by using `StakingInterface`.
+#[impl_trait_for_tuples::impl_for_tuples(10)]
+pub trait OnStakingUpdate<AccountId, Balance> {
+	/// Fired when the stake amount of someone updates.
+	///
+	/// This is effectively any changes to the bond amount, such as bonding more funds, and
+	/// unbonding.
+	fn on_stake_update(_who: &AccountId, _prev_stake: Option<Stake<Balance>>) {}
+
+	/// Fired when someone sets their intention to nominate.
+	///
+	/// This should never be fired for existing nominators.
+	fn on_nominator_add(_who: &AccountId) {}
+
+	/// Fired when an existing nominator updates their nominations.
+	///
+	/// Note that this is not fired when a nominator changes their stake. For that,
+	/// `on_stake_update` should be used, followed by querying whether `who` was a validator or a
+	/// nominator.
+	fn on_nominator_update(_who: &AccountId, _prev_nominations: Vec<AccountId>) {}
+
+	/// Fired when someone removes their intention to nominate, either due to chill or validating.
+	///
+	/// The set of nominations at the time of removal is provided as it can no longer be fetched in
+	/// any way.
+	fn on_nominator_remove(_who: &AccountId, _nominations: Vec<AccountId>) {}
+
+	/// Fired when someone sets their intention to validate.
+	///
+	/// Note validator preference changes are not communicated, but could be added if needed.
+	fn on_validator_add(_who: &AccountId) {}
+
+	/// Fired when an existing validator updates their preferences.
+	///
+	/// Note validator preference changes are not communicated, but could be added if needed.
+	fn on_validator_update(_who: &AccountId) {}
+
+	/// Fired when someone removes their intention to validate, either due to chill or nominating.
+	fn on_validator_remove(_who: &AccountId) {}
+
+	/// Fired when someone is fully unstaked.
+	fn on_unstake(_who: &AccountId) {}
+
+	/// Fired when a staker is slashed.
+	///
+	/// * `stash` - The stash of the staker whom the slash was applied to.
+	/// * `slashed_active` - The new bonded balance of the staker after the slash was applied.
+	/// * `slashed_unlocking` - A map of slashed eras, and the balance of that unlocking chunk after
+	///   the slash is applied. Any era not present in the map is not affected at all.
+	fn on_slash(
+		_stash: &AccountId,
+		_slashed_active: Balance,
+		_slashed_unlocking: &BTreeMap<EraIndex, Balance>,
+	) {
+	}
+}
+
+/// A generic representation of a staking implementation.
+///
+/// This interface uses the terminology of NPoS, but it is aims to be generic enough to cover other
+/// implementations as well.
+pub trait StakingInterface {
+	/// Balance type used by the staking system.
+	type Balance: Sub<Output = Self::Balance>
+		+ Ord
+		+ PartialEq
+		+ Default
+		+ Copy
+		+ MaxEncodedLen
+		+ FullCodec
+		+ TypeInfo
+		+ Saturating;
+
+	/// AccountId type used by the staking system.
+	type AccountId: Clone + sp_std::fmt::Debug;
+
+	/// Means of converting Currency to VoteWeight.
+	type CurrencyToVote: CurrencyToVote<Self::Balance>;
+
+	/// The minimum amount required to bond in order to set nomination intentions. This does not
+	/// necessarily mean the nomination will be counted in an election, but instead just enough to
+	/// be stored as a nominator. In other words, this is the minimum amount to register the
+	/// intention to nominate.
+	fn minimum_nominator_bond() -> Self::Balance;
+
+	/// The minimum amount required to bond in order to set validation intentions.
+	fn minimum_validator_bond() -> Self::Balance;
+
+	/// Return a stash account that is controlled by a `controller`.
+	///
+	/// ## Note
+	///
+	/// The controller abstraction is not permanent and might go away. Avoid using this as much as
+	/// possible.
+	fn stash_by_ctrl(controller: &Self::AccountId) -> Result<Self::AccountId, DispatchError>;
+
+	/// Number of eras that staked funds must remain bonded for.
+	fn bonding_duration() -> EraIndex;
+
+	/// The current era index.
+	///
+	/// This should be the latest planned era that the staking system knows about.
+	fn current_era() -> EraIndex;
+
+	/// Returns the [`Stake`] of `who`.
+	fn stake(who: &Self::AccountId) -> Result<Stake<Self::Balance>, DispatchError>;
+
+	/// Total stake of a staker, `Err` if not a staker.
+	fn total_stake(who: &Self::AccountId) -> Result<Self::Balance, DispatchError> {
+		Self::stake(who).map(|s| s.total)
+	}
+
+	/// Total active portion of a staker's [`Stake`], `Err` if not a staker.
+	fn active_stake(who: &Self::AccountId) -> Result<Self::Balance, DispatchError> {
+		Self::stake(who).map(|s| s.active)
+	}
+
+	/// Returns whether a staker is unbonding, `Err` if not a staker at all.
+	fn is_unbonding(who: &Self::AccountId) -> Result<bool, DispatchError> {
+		Self::stake(who).map(|s| s.active != s.total)
+	}
+
+	/// Returns whether a staker is FULLY unbonding, `Err` if not a staker at all.
+	fn fully_unbond(who: &Self::AccountId) -> DispatchResult {
+		Self::unbond(who, Self::stake(who)?.active)
+	}
+
+	/// Bond (lock) `value` of `who`'s balance, while forwarding any rewards to `payee`.
+	fn bond(who: &Self::AccountId, value: Self::Balance, payee: &Self::AccountId)
+		-> DispatchResult;
+
+	/// Have `who` nominate `validators`.
+	fn nominate(who: &Self::AccountId, validators: Vec<Self::AccountId>) -> DispatchResult;
+
+	/// Chill `who`.
+	fn chill(who: &Self::AccountId) -> DispatchResult;
+
+	/// Bond some extra amount in `who`'s free balance against the active bonded balance of
+	/// the account. The amount extra actually bonded will never be more than `who`'s free
+	/// balance.
+	fn bond_extra(who: &Self::AccountId, extra: Self::Balance) -> DispatchResult;
+
+	/// Schedule a portion of the active bonded balance to be unlocked at era
+	/// [Self::current_era] + [`Self::bonding_duration`].
+	///
+	/// Once the unlock era has been reached, [`Self::withdraw_unbonded`] can be called to unlock
+	/// the funds.
+	///
+	/// The amount of times this can be successfully called is limited based on how many distinct
+	/// eras funds are schedule to unlock in. Calling [`Self::withdraw_unbonded`] after some unlock
+	/// schedules have reached their unlocking era should allow more calls to this function.
+	fn unbond(stash: &Self::AccountId, value: Self::Balance) -> DispatchResult;
+
+	/// Unlock any funds schedule to unlock before or at the current era.
+	///
+	/// Returns whether the stash was killed because of this withdraw or not.
+	fn withdraw_unbonded(
+		stash: Self::AccountId,
+		num_slashing_spans: u32,
+	) -> Result<bool, DispatchError>;
+
+	/// The ideal number of active validators.
+	fn desired_validator_count() -> u32;
+
+	/// Whether or not there is an ongoing election.
+	fn election_ongoing() -> bool;
+
+	/// Force a current staker to become completely unstaked, immediately.
+	fn force_unstake(who: Self::AccountId) -> DispatchResult;
+
+	/// Checks whether an account `staker` has been exposed in an era.
+	fn is_exposed_in_era(who: &Self::AccountId, era: &EraIndex) -> bool;
+
+	/// Return the status of the given staker, `None` if not staked at all.
+	fn status(who: &Self::AccountId) -> Result<StakerStatus<Self::AccountId>, DispatchError>;
+
+	/// Checks whether or not this is a validator account.
+	fn is_validator(who: &Self::AccountId) -> bool {
+		Self::status(who).map(|s| matches!(s, StakerStatus::Validator)).unwrap_or(false)
+	}
+
+	/// 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) {
+			Ok(StakerStatus::Nominator(t)) => Some(t),
+			_ => None,
+		}
+	}
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn add_era_stakers(
+		current_era: &EraIndex,
+		stash: &Self::AccountId,
+		exposures: Vec<(Self::AccountId, Self::Balance)>,
+	);
+
+	#[cfg(feature = "runtime-benchmarks")]
+	fn set_current_era(era: EraIndex);
+}
+
+sp_core::generate_feature_enabled_macro!(runtime_benchmarks_enabled, feature = "runtime-benchmarks", $);
diff --git a/substrate/primitives/staking/src/offence.rs b/substrate/primitives/staking/src/offence.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8013166374e064ab1b573e57991449567e3845da
--- /dev/null
+++ b/substrate/primitives/staking/src/offence.rs
@@ -0,0 +1,276 @@
+// 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.
+
+//! Common traits and types that are useful for describing offences for usage in environments
+//! that use staking.
+
+use codec::{Decode, Encode};
+use sp_core::Get;
+use sp_runtime::{transaction_validity::TransactionValidityError, DispatchError, Perbill};
+use sp_std::vec::Vec;
+
+use crate::SessionIndex;
+
+/// The kind of an offence, is a byte string representing some kind identifier
+/// e.g. `b"im-online:offlin"`, `b"babe:equivocatio"`
+pub type Kind = [u8; 16];
+
+/// Number of times the offence of this authority was already reported in the past.
+///
+/// Note that we don't buffer offence reporting, so every time we see a new offence
+/// of the same kind, we will report past authorities again.
+/// This counter keeps track of how many times the authority was already reported in the past,
+/// so that we can slash it accordingly.
+pub type OffenceCount = u32;
+
+/// In case of an offence, which conditions get an offending validator disabled.
+#[derive(
+	Clone,
+	Copy,
+	PartialEq,
+	Eq,
+	Hash,
+	PartialOrd,
+	Ord,
+	Encode,
+	Decode,
+	sp_runtime::RuntimeDebug,
+	scale_info::TypeInfo,
+)]
+pub enum DisableStrategy {
+	/// Independently of slashing, this offence will not disable the offender.
+	Never,
+	/// Only disable the offender if it is also slashed.
+	WhenSlashed,
+	/// Independently of slashing, this offence will always disable the offender.
+	Always,
+}
+
+/// A trait implemented by an offence report.
+///
+/// This trait assumes that the offence is legitimate and was validated already.
+///
+/// Examples of offences include: a BABE equivocation or a GRANDPA unjustified vote.
+pub trait Offence<Offender> {
+	/// Identifier which is unique for this kind of an offence.
+	const ID: Kind;
+
+	/// A type that represents a point in time on an abstract timescale.
+	///
+	/// See `Offence::time_slot` for details. The only requirement is that such timescale could be
+	/// represented by a single `u128` value.
+	type TimeSlot: Clone + codec::Codec + Ord;
+
+	/// The list of all offenders involved in this incident.
+	///
+	/// The list has no duplicates, so it is rather a set.
+	fn offenders(&self) -> Vec<Offender>;
+
+	/// The session index that is used for querying the validator set for the `slash_fraction`
+	/// function.
+	///
+	/// This is used for filtering historical sessions.
+	fn session_index(&self) -> SessionIndex;
+
+	/// Return a validator set count at the time when the offence took place.
+	fn validator_set_count(&self) -> u32;
+
+	/// A point in time when this offence happened.
+	///
+	/// This is used for looking up offences that happened at the "same time".
+	///
+	/// The timescale is abstract and doesn't have to be the same across different implementations
+	/// of this trait. The value doesn't represent absolute timescale though since it is interpreted
+	/// along with the `session_index`. Two offences are considered to happen at the same time iff
+	/// both `session_index` and `time_slot` are equal.
+	///
+	/// As an example, for GRANDPA timescale could be a round number and for BABE it could be a slot
+	/// number. Note that for GRANDPA the round number is reset each epoch.
+	fn time_slot(&self) -> Self::TimeSlot;
+
+	/// In which cases this offence needs to disable offenders until the next era starts.
+	fn disable_strategy(&self) -> DisableStrategy {
+		DisableStrategy::WhenSlashed
+	}
+
+	/// A slash fraction of the total exposure that should be slashed for this
+	/// particular offence for the `offenders_count` that happened at a singular `TimeSlot`.
+	///
+	/// `offenders_count` - the count of unique offending authorities for this `TimeSlot`. It is >0.
+	fn slash_fraction(&self, offenders_count: u32) -> Perbill;
+}
+
+/// Errors that may happen on offence reports.
+#[derive(PartialEq, sp_runtime::RuntimeDebug)]
+pub enum OffenceError {
+	/// The report has already been sumbmitted.
+	DuplicateReport,
+
+	/// Other error has happened.
+	Other(u8),
+}
+
+impl sp_runtime::traits::Printable for OffenceError {
+	fn print(&self) {
+		"OffenceError".print();
+		match self {
+			Self::DuplicateReport => "DuplicateReport".print(),
+			Self::Other(e) => {
+				"Other".print();
+				e.print();
+			},
+		}
+	}
+}
+
+/// A trait for decoupling offence reporters from the actual handling of offence reports.
+pub trait ReportOffence<Reporter, Offender, O: Offence<Offender>> {
+	/// Report an `offence` and reward given `reporters`.
+	fn report_offence(reporters: Vec<Reporter>, offence: O) -> Result<(), OffenceError>;
+
+	/// Returns true iff all of the given offenders have been previously reported
+	/// at the given time slot. This function is useful to prevent the sending of
+	/// duplicate offence reports.
+	fn is_known_offence(offenders: &[Offender], time_slot: &O::TimeSlot) -> bool;
+}
+
+impl<Reporter, Offender, O: Offence<Offender>> ReportOffence<Reporter, Offender, O> for () {
+	fn report_offence(_reporters: Vec<Reporter>, _offence: O) -> Result<(), OffenceError> {
+		Ok(())
+	}
+
+	fn is_known_offence(_offenders: &[Offender], _time_slot: &O::TimeSlot) -> bool {
+		true
+	}
+}
+
+/// A trait to take action on an offence.
+///
+/// Used to decouple the module that handles offences and
+/// the one that should punish for those offences.
+pub trait OnOffenceHandler<Reporter, Offender, Res> {
+	/// A handler for an offence of a particular kind.
+	///
+	/// Note that this contains a list of all previous offenders
+	/// as well. The implementer should cater for a case, where
+	/// the same authorities were reported for the same offence
+	/// in the past (see `OffenceCount`).
+	///
+	/// The vector of `slash_fraction` contains `Perbill`s
+	/// the authorities should be slashed and is computed
+	/// according to the `OffenceCount` already. This is of the same length as `offenders.`
+	/// Zero is a valid value for a fraction.
+	///
+	/// The `session` parameter is the session index of the offence.
+	///
+	/// The `disable_strategy` parameter decides if the offenders need to be disabled immediately.
+	///
+	/// The receiver might decide to not accept this offence. In this case, the call site is
+	/// responsible for queuing the report and re-submitting again.
+	fn on_offence(
+		offenders: &[OffenceDetails<Reporter, Offender>],
+		slash_fraction: &[Perbill],
+		session: SessionIndex,
+		disable_strategy: DisableStrategy,
+	) -> Res;
+}
+
+impl<Reporter, Offender, Res: Default> OnOffenceHandler<Reporter, Offender, Res> for () {
+	fn on_offence(
+		_offenders: &[OffenceDetails<Reporter, Offender>],
+		_slash_fraction: &[Perbill],
+		_session: SessionIndex,
+		_disable_strategy: DisableStrategy,
+	) -> Res {
+		Default::default()
+	}
+}
+
+/// A details about an offending authority for a particular kind of offence.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, sp_runtime::RuntimeDebug, scale_info::TypeInfo)]
+pub struct OffenceDetails<Reporter, Offender> {
+	/// The offending authority id
+	pub offender: Offender,
+	/// A list of reporters of offences of this authority ID. Possibly empty where there are no
+	/// particular reporters.
+	pub reporters: Vec<Reporter>,
+}
+
+/// An abstract system to publish, check and process offence evidences.
+///
+/// Implementation details are left opaque and we don't assume any specific usage
+/// scenario for this trait at this level. The main goal is to group together some
+/// common actions required during a typical offence report flow.
+///
+/// Even though this trait doesn't assume too much, this is a general guideline
+/// for a typical usage scenario:
+///
+/// 1. An offence is detected and an evidence is submitted on-chain via the
+///    [`OffenceReportSystem::publish_evidence`] method. This will construct and submit an extrinsic
+///    transaction containing the offence evidence.
+///
+/// 2. If the extrinsic is unsigned then the transaction receiver may want to perform some
+///    preliminary checks before further processing. This is a good place to call the
+///    [`OffenceReportSystem::check_evidence`] method.
+///
+/// 3. Finally the report extrinsic is executed on-chain. This is where the user calls the
+///    [`OffenceReportSystem::process_evidence`] to consume the offence report and enact any
+///    required action.
+pub trait OffenceReportSystem<Reporter, Evidence> {
+	/// Longevity, in blocks, for the evidence report validity.
+	///
+	/// For example, when using the staking pallet this should be set equal
+	/// to the bonding duration in blocks, not eras.
+	type Longevity: Get<u64>;
+
+	/// Publish an offence evidence.
+	///
+	/// Common usage: submit the evidence on-chain via some kind of extrinsic.
+	fn publish_evidence(evidence: Evidence) -> Result<(), ()>;
+
+	/// Check an offence evidence.
+	///
+	/// Common usage: preliminary validity check before execution
+	/// (e.g. for unsigned extrinsic quick checks).
+	fn check_evidence(evidence: Evidence) -> Result<(), TransactionValidityError>;
+
+	/// Process an offence evidence.
+	///
+	/// Common usage: enact some form of slashing directly or by forwarding
+	/// the evidence to a lower level specialized subsystem (e.g. a handler
+	/// implementing `ReportOffence` trait).
+	fn process_evidence(reporter: Reporter, evidence: Evidence) -> Result<(), DispatchError>;
+}
+
+/// Dummy offence report system.
+///
+/// Doesn't do anything special and returns `Ok(())` for all the actions.
+impl<Reporter, Evidence> OffenceReportSystem<Reporter, Evidence> for () {
+	type Longevity = ();
+
+	fn publish_evidence(_evidence: Evidence) -> Result<(), ()> {
+		Ok(())
+	}
+
+	fn check_evidence(_evidence: Evidence) -> Result<(), TransactionValidityError> {
+		Ok(())
+	}
+
+	fn process_evidence(_reporter: Reporter, _evidence: Evidence) -> Result<(), DispatchError> {
+		Ok(())
+	}
+}
diff --git a/substrate/primitives/state-machine/Cargo.toml b/substrate/primitives/state-machine/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0f5613545b5dc984091921efc078a622e36c183f
--- /dev/null
+++ b/substrate/primitives/state-machine/Cargo.toml
@@ -0,0 +1,56 @@
+[package]
+name = "sp-state-machine"
+version = "0.28.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Substrate State Machine"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sp-state-machine"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+hash-db = { version = "0.16.0", default-features = false }
+log = { version = "0.4.17", default-features = false }
+parking_lot = { version = "0.12.1", optional = true }
+rand = { version = "0.8.5", optional = true }
+smallvec = "1.11.0"
+thiserror = { version = "1.0.30", optional = true }
+tracing = { version = "0.1.29", optional = true }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-externalities = { version = "0.19.0", default-features = false, path = "../externalities" }
+sp-panic-handler = { version = "8.0.0", optional = true, path = "../panic-handler" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-trie = { version = "22.0.0", default-features = false, path = "../trie" }
+trie-db = { version = "0.27.1", default-features = false }
+
+[dev-dependencies]
+array-bytes = "6.1"
+pretty_assertions = "1.2.1"
+rand = "0.8.5"
+sp-runtime = { version = "24.0.0", path = "../runtime" }
+assert_matches = "1.5"
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"hash-db/std",
+	"log/std",
+	"parking_lot",
+	"rand",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-panic-handler",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-trie/std",
+	"thiserror",
+	"tracing",
+	"trie-db/std",
+]
diff --git a/substrate/primitives/state-machine/README.md b/substrate/primitives/state-machine/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa244da62d50fc4ee549f1431d8f1dada8b48051
--- /dev/null
+++ b/substrate/primitives/state-machine/README.md
@@ -0,0 +1,3 @@
+Substrate state machine implementation.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/state-machine/src/backend.rs b/substrate/primitives/state-machine/src/backend.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2a25bdc54d9491faaf500f760aae7550dd1dadd3
--- /dev/null
+++ b/substrate/primitives/state-machine/src/backend.rs
@@ -0,0 +1,433 @@
+// 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 backends. These manage the code and storage of contracts.
+
+#[cfg(feature = "std")]
+use crate::trie_backend::TrieBackend;
+use crate::{
+	trie_backend_essence::TrieBackendStorage, ChildStorageCollection, StorageCollection,
+	StorageKey, StorageValue, UsageInfo,
+};
+use codec::Encode;
+use core::marker::PhantomData;
+use hash_db::Hasher;
+use sp_core::storage::{ChildInfo, StateVersion, TrackedStorageKey};
+#[cfg(feature = "std")]
+use sp_core::traits::RuntimeCode;
+use sp_std::vec::Vec;
+use sp_trie::PrefixedMemoryDB;
+
+/// A struct containing arguments for iterating over the storage.
+#[derive(Default)]
+#[non_exhaustive]
+pub struct IterArgs<'a> {
+	/// The prefix of the keys over which to iterate.
+	pub prefix: Option<&'a [u8]>,
+
+	/// The prefix from which to start the iteration from.
+	///
+	/// This is inclusive and the iteration will include the key which is specified here.
+	pub start_at: Option<&'a [u8]>,
+
+	/// If this is `true` then the iteration will *not* include
+	/// the key specified in `start_at`, if there is such a key.
+	pub start_at_exclusive: bool,
+
+	/// The info of the child trie over which to iterate over.
+	pub child_info: Option<ChildInfo>,
+
+	/// Whether to stop iteration when a missing trie node is reached.
+	///
+	/// When a missing trie node is reached the iterator will:
+	///   - return an error if this is set to `false` (default)
+	///   - return `None` if this is set to `true`
+	pub stop_on_incomplete_database: bool,
+}
+
+/// A trait for a raw storage iterator.
+pub trait StorageIterator<H>
+where
+	H: Hasher,
+{
+	/// The state backend over which the iterator is iterating.
+	type Backend;
+
+	/// The error type.
+	type Error;
+
+	/// Fetches the next key from the storage.
+	fn next_key(
+		&mut self,
+		backend: &Self::Backend,
+	) -> Option<core::result::Result<StorageKey, Self::Error>>;
+
+	/// Fetches the next key and value from the storage.
+	fn next_pair(
+		&mut self,
+		backend: &Self::Backend,
+	) -> Option<core::result::Result<(StorageKey, StorageValue), Self::Error>>;
+
+	/// Returns whether the end of iteration was reached without an error.
+	fn was_complete(&self) -> bool;
+}
+
+/// An iterator over storage keys and values.
+pub struct PairsIter<'a, H, I>
+where
+	H: Hasher,
+	I: StorageIterator<H>,
+{
+	backend: Option<&'a I::Backend>,
+	raw_iter: I,
+	_phantom: PhantomData<H>,
+}
+
+impl<'a, H, I> Iterator for PairsIter<'a, H, I>
+where
+	H: Hasher,
+	I: StorageIterator<H>,
+{
+	type Item = Result<(Vec<u8>, Vec<u8>), <I as StorageIterator<H>>::Error>;
+	fn next(&mut self) -> Option<Self::Item> {
+		self.raw_iter.next_pair(self.backend.as_ref()?)
+	}
+}
+
+impl<'a, H, I> Default for PairsIter<'a, H, I>
+where
+	H: Hasher,
+	I: StorageIterator<H> + Default,
+{
+	fn default() -> Self {
+		Self {
+			backend: Default::default(),
+			raw_iter: Default::default(),
+			_phantom: Default::default(),
+		}
+	}
+}
+
+impl<'a, H, I> PairsIter<'a, H, I>
+where
+	H: Hasher,
+	I: StorageIterator<H> + Default,
+{
+	#[cfg(feature = "std")]
+	pub(crate) fn was_complete(&self) -> bool {
+		self.raw_iter.was_complete()
+	}
+}
+
+/// An iterator over storage keys.
+pub struct KeysIter<'a, H, I>
+where
+	H: Hasher,
+	I: StorageIterator<H>,
+{
+	backend: Option<&'a I::Backend>,
+	raw_iter: I,
+	_phantom: PhantomData<H>,
+}
+
+impl<'a, H, I> Iterator for KeysIter<'a, H, I>
+where
+	H: Hasher,
+	I: StorageIterator<H>,
+{
+	type Item = Result<Vec<u8>, <I as StorageIterator<H>>::Error>;
+	fn next(&mut self) -> Option<Self::Item> {
+		self.raw_iter.next_key(self.backend.as_ref()?)
+	}
+}
+
+impl<'a, H, I> Default for KeysIter<'a, H, I>
+where
+	H: Hasher,
+	I: StorageIterator<H> + Default,
+{
+	fn default() -> Self {
+		Self {
+			backend: Default::default(),
+			raw_iter: Default::default(),
+			_phantom: Default::default(),
+		}
+	}
+}
+
+/// The transaction type used by [`Backend`].
+///
+/// This transaction contains all the changes that need to be applied to the backend to create the
+/// state for a new block.
+pub type BackendTransaction<H> = PrefixedMemoryDB<H>;
+
+/// A state backend is used to read state data and can have changes committed
+/// to it.
+///
+/// The clone operation (if implemented) should be cheap.
+pub trait Backend<H: Hasher>: sp_std::fmt::Debug {
+	/// An error type when fetching data is not possible.
+	type Error: super::Error;
+
+	/// Type of trie backend storage.
+	type TrieBackendStorage: TrieBackendStorage<H>;
+
+	/// Type of the raw storage iterator.
+	type RawIter: StorageIterator<H, Backend = Self, Error = Self::Error>;
+
+	/// Get keyed storage or None if there is nothing associated.
+	fn storage(&self, key: &[u8]) -> Result<Option<StorageValue>, Self::Error>;
+
+	/// Get keyed storage value hash or None if there is nothing associated.
+	fn storage_hash(&self, key: &[u8]) -> Result<Option<H::Out>, Self::Error>;
+
+	/// Get keyed child storage or None if there is nothing associated.
+	fn child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<StorageValue>, Self::Error>;
+
+	/// Get child keyed storage value hash or None if there is nothing associated.
+	fn child_storage_hash(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<H::Out>, Self::Error>;
+
+	/// true if a key exists in storage.
+	fn exists_storage(&self, key: &[u8]) -> Result<bool, Self::Error> {
+		Ok(self.storage_hash(key)?.is_some())
+	}
+
+	/// true if a key exists in child storage.
+	fn exists_child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<bool, Self::Error> {
+		Ok(self.child_storage_hash(child_info, key)?.is_some())
+	}
+
+	/// Return the next key in storage in lexicographic order or `None` if there is no value.
+	fn next_storage_key(&self, key: &[u8]) -> Result<Option<StorageKey>, Self::Error>;
+
+	/// Return the next key in child storage in lexicographic order or `None` if there is no value.
+	fn next_child_storage_key(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<StorageKey>, Self::Error>;
+
+	/// Calculate the storage root, with given delta over what is already stored in
+	/// the backend, and produce a "transaction" that can be used to commit.
+	/// Does not include child storage updates.
+	fn storage_root<'a>(
+		&self,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (H::Out, BackendTransaction<H>)
+	where
+		H::Out: Ord;
+
+	/// Calculate the child storage root, with given delta over what is already stored in
+	/// the backend, and produce a "transaction" that can be used to commit. The second argument
+	/// is true if child storage root equals default storage root.
+	fn child_storage_root<'a>(
+		&self,
+		child_info: &ChildInfo,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (H::Out, bool, BackendTransaction<H>)
+	where
+		H::Out: Ord;
+
+	/// Returns a lifetimeless raw storage iterator.
+	fn raw_iter(&self, args: IterArgs) -> Result<Self::RawIter, Self::Error>;
+
+	/// Get an iterator over key/value pairs.
+	fn pairs<'a>(&'a self, args: IterArgs) -> Result<PairsIter<'a, H, Self::RawIter>, Self::Error> {
+		Ok(PairsIter {
+			backend: Some(self),
+			raw_iter: self.raw_iter(args)?,
+			_phantom: Default::default(),
+		})
+	}
+
+	/// Get an iterator over keys.
+	fn keys<'a>(&'a self, args: IterArgs) -> Result<KeysIter<'a, H, Self::RawIter>, Self::Error> {
+		Ok(KeysIter {
+			backend: Some(self),
+			raw_iter: self.raw_iter(args)?,
+			_phantom: Default::default(),
+		})
+	}
+
+	/// Calculate the storage root, with given delta over what is already stored
+	/// in the backend, and produce a "transaction" that can be used to commit.
+	/// Does include child storage updates.
+	fn full_storage_root<'a>(
+		&self,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		child_deltas: impl Iterator<
+			Item = (&'a ChildInfo, impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>),
+		>,
+		state_version: StateVersion,
+	) -> (H::Out, BackendTransaction<H>)
+	where
+		H::Out: Ord + Encode,
+	{
+		let mut txs = BackendTransaction::default();
+		let mut child_roots: Vec<_> = Default::default();
+		// child first
+		for (child_info, child_delta) in child_deltas {
+			let (child_root, empty, child_txs) =
+				self.child_storage_root(child_info, child_delta, state_version);
+			let prefixed_storage_key = child_info.prefixed_storage_key();
+			txs.consolidate(child_txs);
+			if empty {
+				child_roots.push((prefixed_storage_key.into_inner(), None));
+			} else {
+				child_roots.push((prefixed_storage_key.into_inner(), Some(child_root.encode())));
+			}
+		}
+		let (root, parent_txs) = self.storage_root(
+			delta
+				.map(|(k, v)| (k, v.as_ref().map(|v| &v[..])))
+				.chain(child_roots.iter().map(|(k, v)| (&k[..], v.as_ref().map(|v| &v[..])))),
+			state_version,
+		);
+		txs.consolidate(parent_txs);
+
+		(root, txs)
+	}
+
+	/// Register stats from overlay of state machine.
+	///
+	/// By default nothing is registered.
+	fn register_overlay_stats(&self, _stats: &crate::stats::StateMachineStats);
+
+	/// Query backend usage statistics (i/o, memory)
+	///
+	/// Not all implementations are expected to be able to do this. In the
+	/// case when they don't, empty statistics is returned.
+	fn usage_info(&self) -> UsageInfo;
+
+	/// Wipe the state database.
+	fn wipe(&self) -> Result<(), Self::Error> {
+		unimplemented!()
+	}
+
+	/// Commit given transaction to storage.
+	fn commit(
+		&self,
+		_: H::Out,
+		_: BackendTransaction<H>,
+		_: StorageCollection,
+		_: ChildStorageCollection,
+	) -> Result<(), Self::Error> {
+		unimplemented!()
+	}
+
+	/// Get the read/write count of the db
+	fn read_write_count(&self) -> (u32, u32, u32, u32) {
+		unimplemented!()
+	}
+
+	/// Get the read/write count of the db
+	fn reset_read_write_count(&self) {
+		unimplemented!()
+	}
+
+	/// Get the whitelist for tracking db reads/writes
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey> {
+		Default::default()
+	}
+
+	/// Update the whitelist for tracking db reads/writes
+	fn set_whitelist(&self, _: Vec<TrackedStorageKey>) {}
+
+	/// Estimate proof size
+	fn proof_size(&self) -> Option<u32> {
+		unimplemented!()
+	}
+
+	/// Extend storage info for benchmarking db
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> {
+		unimplemented!()
+	}
+}
+
+/// Something that can be converted into a [`TrieBackend`].
+#[cfg(feature = "std")]
+pub trait AsTrieBackend<H: Hasher, C = sp_trie::cache::LocalTrieCache<H>> {
+	/// Type of trie backend storage.
+	type TrieBackendStorage: TrieBackendStorage<H>;
+
+	/// Return the type as [`TrieBackend`].
+	fn as_trie_backend(&self) -> &TrieBackend<Self::TrieBackendStorage, H, C>;
+}
+
+/// Wrapper to create a [`RuntimeCode`] from a type that implements [`Backend`].
+#[cfg(feature = "std")]
+pub struct BackendRuntimeCode<'a, B, H> {
+	backend: &'a B,
+	_marker: PhantomData<H>,
+}
+
+#[cfg(feature = "std")]
+impl<'a, B: Backend<H>, H: Hasher> sp_core::traits::FetchRuntimeCode
+	for BackendRuntimeCode<'a, B, H>
+{
+	fn fetch_runtime_code(&self) -> Option<std::borrow::Cow<[u8]>> {
+		self.backend
+			.storage(sp_core::storage::well_known_keys::CODE)
+			.ok()
+			.flatten()
+			.map(Into::into)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<'a, B: Backend<H>, H: Hasher> BackendRuntimeCode<'a, B, H>
+where
+	H::Out: Encode,
+{
+	/// Create a new instance.
+	pub fn new(backend: &'a B) -> Self {
+		Self { backend, _marker: PhantomData }
+	}
+
+	/// Return the [`RuntimeCode`] build from the wrapped `backend`.
+	pub fn runtime_code(&self) -> Result<RuntimeCode, &'static str> {
+		let hash = self
+			.backend
+			.storage_hash(sp_core::storage::well_known_keys::CODE)
+			.ok()
+			.flatten()
+			.ok_or("`:code` hash not found")?
+			.encode();
+		let heap_pages = self
+			.backend
+			.storage(sp_core::storage::well_known_keys::HEAP_PAGES)
+			.ok()
+			.flatten()
+			.and_then(|d| codec::Decode::decode(&mut &d[..]).ok());
+
+		Ok(RuntimeCode { code_fetcher: self, hash, heap_pages })
+	}
+}
diff --git a/substrate/primitives/state-machine/src/basic.rs b/substrate/primitives/state-machine/src/basic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ace88aee2628f556ebafffa56543a7400c9428aa
--- /dev/null
+++ b/substrate/primitives/state-machine/src/basic.rs
@@ -0,0 +1,442 @@
+// 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.
+
+//! Basic implementation for Externalities.
+
+use crate::{Backend, OverlayedChanges, StorageKey, StorageValue};
+use codec::Encode;
+use hash_db::Hasher;
+use log::warn;
+use sp_core::{
+	storage::{
+		well_known_keys::is_child_storage_key, ChildInfo, StateVersion, Storage, TrackedStorageKey,
+	},
+	traits::Externalities,
+	Blake2Hasher,
+};
+use sp_externalities::{Extension, Extensions, MultiRemovalResults};
+use sp_trie::{empty_child_trie_root, LayoutV0, LayoutV1, TrieConfiguration};
+use std::{
+	any::{Any, TypeId},
+	collections::BTreeMap,
+	iter::FromIterator,
+};
+
+/// Simple Map-based Externalities impl.
+#[derive(Debug)]
+pub struct BasicExternalities {
+	overlay: OverlayedChanges<Blake2Hasher>,
+	extensions: Extensions,
+}
+
+impl BasicExternalities {
+	/// Create a new instance of `BasicExternalities`
+	pub fn new(inner: Storage) -> Self {
+		BasicExternalities { overlay: inner.into(), extensions: Default::default() }
+	}
+
+	/// New basic externalities with empty storage.
+	pub fn new_empty() -> Self {
+		Self::new(Storage::default())
+	}
+
+	/// Insert key/value
+	pub fn insert(&mut self, k: StorageKey, v: StorageValue) {
+		self.overlay.set_storage(k, Some(v));
+	}
+
+	/// Consume self and returns inner storages
+	pub fn into_storages(self) -> Storage {
+		Storage {
+			top: self
+				.overlay
+				.changes()
+				.filter_map(|(k, v)| v.value().map(|v| (k.to_vec(), v.to_vec())))
+				.collect(),
+			children_default: self
+				.overlay
+				.children()
+				.map(|(iter, i)| {
+					(
+						i.storage_key().to_vec(),
+						sp_core::storage::StorageChild {
+							data: iter
+								.filter_map(|(k, v)| v.value().map(|v| (k.to_vec(), v.to_vec())))
+								.collect(),
+							child_info: i.clone(),
+						},
+					)
+				})
+				.collect(),
+		}
+	}
+
+	/// 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.
+	pub fn execute_with_storage<R>(
+		storage: &mut sp_core::storage::Storage,
+		f: impl FnOnce() -> R,
+	) -> R {
+		let mut ext = Self::new(std::mem::take(storage));
+
+		let r = ext.execute_with(f);
+
+		*storage = ext.into_storages();
+
+		r
+	}
+
+	/// Execute the given closure while `self` is set as externalities.
+	///
+	/// Returns the result of the given closure.
+	pub fn execute_with<R>(&mut self, f: impl FnOnce() -> R) -> R {
+		sp_externalities::set_and_run_with_externalities(self, f)
+	}
+
+	/// List of active extensions.
+	pub fn extensions(&mut self) -> &mut Extensions {
+		&mut self.extensions
+	}
+
+	/// Register an extension.
+	pub fn register_extension(&mut self, ext: impl Extension) {
+		self.extensions.register(ext);
+	}
+}
+
+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<_, _>>() &&
+			self.overlay
+				.children()
+				.map(|(iter, i)| (i, iter.map(|(k, v)| (k, v.value())).collect::<BTreeMap<_, _>>()))
+				.collect::<BTreeMap<_, _>>() ==
+				other
+					.overlay
+					.children()
+					.map(|(iter, i)| {
+						(i, iter.map(|(k, v)| (k, v.value())).collect::<BTreeMap<_, _>>())
+					})
+					.collect::<BTreeMap<_, _>>()
+	}
+}
+
+impl FromIterator<(StorageKey, StorageValue)> for BasicExternalities {
+	fn from_iter<I: IntoIterator<Item = (StorageKey, StorageValue)>>(iter: I) -> Self {
+		let mut t = Self::default();
+		iter.into_iter().for_each(|(k, v)| t.insert(k, v));
+		t
+	}
+}
+
+impl Default for BasicExternalities {
+	fn default() -> Self {
+		Self::new(Default::default())
+	}
+}
+
+impl From<BTreeMap<StorageKey, StorageValue>> for BasicExternalities {
+	fn from(map: BTreeMap<StorageKey, StorageValue>) -> Self {
+		Self::from_iter(map.into_iter())
+	}
+}
+
+impl Externalities for BasicExternalities {
+	fn set_offchain_storage(&mut self, _key: &[u8], _value: Option<&[u8]>) {}
+
+	fn storage(&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>> {
+		self.storage(key).map(|v| Blake2Hasher::hash(&v).encode())
+	}
+
+	fn child_storage(&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>> {
+		self.child_storage(child_info, key).map(|v| Blake2Hasher::hash(&v).encode())
+	}
+
+	fn next_storage_key(&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> {
+		self.overlay
+			.child_iter_after(child_info.storage_key(), key)
+			.find_map(|(k, v)| v.value().map(|_| k.to_vec()))
+	}
+
+	fn place_storage(&mut self, key: StorageKey, maybe_value: Option<StorageValue>) {
+		if is_child_storage_key(&key) {
+			warn!(target: "trie", "Refuse to set child storage key via main storage");
+			return
+		}
+
+		self.overlay.set_storage(key, maybe_value)
+	}
+
+	fn place_child_storage(
+		&mut self,
+		child_info: &ChildInfo,
+		key: StorageKey,
+		value: Option<StorageValue>,
+	) {
+		self.overlay.set_child_storage(child_info, key, value);
+	}
+
+	fn kill_child_storage(
+		&mut self,
+		child_info: &ChildInfo,
+		_maybe_limit: Option<u32>,
+		_maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		let count = self.overlay.clear_child_storage(child_info);
+		MultiRemovalResults { maybe_cursor: None, backend: count, unique: count, loops: count }
+	}
+
+	fn clear_prefix(
+		&mut self,
+		prefix: &[u8],
+		_maybe_limit: Option<u32>,
+		_maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		if is_child_storage_key(prefix) {
+			warn!(
+				target: "trie",
+				"Refuse to clear prefix that is part of child storage key via main storage"
+			);
+			let maybe_cursor = Some(prefix.to_vec());
+			return MultiRemovalResults { maybe_cursor, backend: 0, unique: 0, loops: 0 }
+		}
+
+		let count = self.overlay.clear_prefix(prefix);
+		MultiRemovalResults { maybe_cursor: None, backend: count, unique: count, loops: count }
+	}
+
+	fn clear_child_prefix(
+		&mut self,
+		child_info: &ChildInfo,
+		prefix: &[u8],
+		_maybe_limit: Option<u32>,
+		_maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		let count = self.overlay.clear_child_prefix(child_info, prefix);
+		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_root(&mut self, state_version: StateVersion) -> Vec<u8> {
+		let mut top = self
+			.overlay
+			.changes()
+			.filter_map(|(k, v)| v.value().map(|v| (k.clone(), v.clone())))
+			.collect::<BTreeMap<_, _>>();
+		// Single child trie implementation currently allows using the same child
+		// empty root for all child trie. Using null storage key until multiple
+		// type of child trie support.
+		let empty_hash = empty_child_trie_root::<LayoutV1<Blake2Hasher>>();
+		for child_info in self.overlay.children().map(|d| d.1.clone()).collect::<Vec<_>>() {
+			let child_root = self.child_storage_root(&child_info, state_version);
+			if empty_hash[..] == child_root[..] {
+				top.remove(child_info.prefixed_storage_key().as_slice());
+			} else {
+				top.insert(child_info.prefixed_storage_key().into_inner(), child_root);
+			}
+		}
+
+		match state_version {
+			StateVersion::V0 => LayoutV0::<Blake2Hasher>::trie_root(top).as_ref().into(),
+			StateVersion::V1 => LayoutV1::<Blake2Hasher>::trie_root(top).as_ref().into(),
+		}
+	}
+
+	fn child_storage_root(
+		&mut self,
+		child_info: &ChildInfo,
+		state_version: StateVersion,
+	) -> Vec<u8> {
+		if let Some((data, child_info)) = self.overlay.child_changes(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>()
+				.child_storage_root(&child_info, delta, state_version)
+				.0
+		} else {
+			empty_child_trie_root::<LayoutV1<Blake2Hasher>>()
+		}
+		.encode()
+	}
+
+	fn storage_start_transaction(&mut self) {
+		self.overlay.start_transaction()
+	}
+
+	fn storage_rollback_transaction(&mut self) -> Result<(), ()> {
+		self.overlay.rollback_transaction().map_err(drop)
+	}
+
+	fn storage_commit_transaction(&mut self) -> Result<(), ()> {
+		self.overlay.commit_transaction().map_err(drop)
+	}
+
+	fn wipe(&mut self) {}
+
+	fn commit(&mut self) {}
+
+	fn read_write_count(&self) -> (u32, u32, u32, u32) {
+		unimplemented!("read_write_count is not supported in Basic")
+	}
+
+	fn reset_read_write_count(&mut self) {
+		unimplemented!("reset_read_write_count is not supported in Basic")
+	}
+
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey> {
+		unimplemented!("get_whitelist is not supported in Basic")
+	}
+
+	fn set_whitelist(&mut self, _: Vec<TrackedStorageKey>) {
+		unimplemented!("set_whitelist is not supported in Basic")
+	}
+
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> {
+		unimplemented!("get_read_and_written_keys is not supported in Basic")
+	}
+}
+
+impl sp_externalities::ExtensionStore for BasicExternalities {
+	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any> {
+		self.extensions.get_mut(type_id)
+	}
+
+	fn register_extension_with_type_id(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn sp_externalities::Extension>,
+	) -> Result<(), sp_externalities::Error> {
+		self.extensions.register_with_type_id(type_id, extension)
+	}
+
+	fn deregister_extension_by_type_id(
+		&mut self,
+		type_id: TypeId,
+	) -> Result<(), sp_externalities::Error> {
+		if self.extensions.deregister(type_id) {
+			Ok(())
+		} else {
+			Err(sp_externalities::Error::ExtensionIsNotRegistered(type_id))
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{
+		map,
+		storage::{well_known_keys::CODE, Storage, StorageChild},
+	};
+
+	#[test]
+	fn commit_should_work() {
+		let mut ext = BasicExternalities::default();
+		ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
+		ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
+		ext.set_storage(b"dogglesworth".to_vec(), b"cat".to_vec());
+		let root = array_bytes::hex2bytes_unchecked(
+			"39245109cef3758c2eed2ccba8d9b370a917850af3824bc8348d505df2c298fa",
+		);
+
+		assert_eq!(&ext.storage_root(StateVersion::default())[..], &root);
+	}
+
+	#[test]
+	fn set_and_retrieve_code() {
+		let mut ext = BasicExternalities::default();
+
+		let code = vec![1, 2, 3];
+		ext.set_storage(CODE.to_vec(), code.clone());
+
+		assert_eq!(&ext.storage(CODE).unwrap(), &code);
+	}
+
+	#[test]
+	fn children_works() {
+		let child_info = ChildInfo::new_default(b"storage_key");
+		let child_info = &child_info;
+		let mut ext = BasicExternalities::new(Storage {
+			top: Default::default(),
+			children_default: map![
+				child_info.storage_key().to_vec() => StorageChild {
+					data: map![	b"doe".to_vec() => b"reindeer".to_vec()	],
+					child_info: child_info.to_owned(),
+				}
+			],
+		});
+
+		assert_eq!(ext.child_storage(child_info, b"doe"), Some(b"reindeer".to_vec()));
+
+		ext.set_child_storage(child_info, b"dog".to_vec(), b"puppy".to_vec());
+		assert_eq!(ext.child_storage(child_info, b"dog"), Some(b"puppy".to_vec()));
+
+		ext.clear_child_storage(child_info, b"dog");
+		assert_eq!(ext.child_storage(child_info, b"dog"), None);
+
+		let _ = ext.kill_child_storage(child_info, None, None);
+		assert_eq!(ext.child_storage(child_info, b"doe"), None);
+	}
+
+	#[test]
+	fn kill_child_storage_returns_num_elements_removed() {
+		let child_info = ChildInfo::new_default(b"storage_key");
+		let child_info = &child_info;
+		let mut ext = BasicExternalities::new(Storage {
+			top: Default::default(),
+			children_default: map![
+				child_info.storage_key().to_vec() => StorageChild {
+					data: map![
+						b"doe".to_vec() => b"reindeer".to_vec(),
+						b"dog".to_vec() => b"puppy".to_vec(),
+						b"hello".to_vec() => b"world".to_vec(),
+					],
+					child_info: child_info.to_owned(),
+				}
+			],
+		});
+
+		let res = ext.kill_child_storage(child_info, None, None);
+		assert_eq!(res.deconstruct(), (None, 3, 3, 3));
+	}
+
+	#[test]
+	fn basic_externalities_is_empty() {
+		// Make sure no values are set by default in `BasicExternalities`.
+		let storage = BasicExternalities::new_empty().into_storages();
+		assert!(storage.top.is_empty());
+		assert!(storage.children_default.is_empty());
+	}
+}
diff --git a/substrate/primitives/state-machine/src/error.rs b/substrate/primitives/state-machine/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e8e02a26025ca9ef0f6899d3870e9e96c96da22
--- /dev/null
+++ b/substrate/primitives/state-machine/src/error.rs
@@ -0,0 +1,48 @@
+// 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 Errors
+use sp_std::fmt;
+
+/// State Machine Error bound.
+///
+/// This should reflect Wasm error type bound for future compatibility.
+pub trait Error: 'static + fmt::Debug + fmt::Display + Send + Sync {}
+
+impl<T: 'static + fmt::Debug + fmt::Display + Send + Sync> Error for T {}
+
+/// Externalities Error.
+///
+/// Externalities are not really allowed to have errors, since it's assumed that dependent code
+/// would not be executed unless externalities were available. This is included for completeness,
+/// and as a transition away from the pre-existing framework.
+#[derive(Debug, Eq, PartialEq)]
+#[allow(missing_docs)]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+pub enum ExecutionError {
+	#[cfg_attr(feature = "std", error("Backend error {0:?}"))]
+	Backend(crate::DefaultError),
+
+	#[cfg_attr(feature = "std", error("`:code` entry does not exist in storage"))]
+	CodeEntryDoesNotExist,
+
+	#[cfg_attr(feature = "std", error("Unable to generate proof"))]
+	UnableToGenerateProof,
+
+	#[cfg_attr(feature = "std", error("Invalid execution proof"))]
+	InvalidProof,
+}
diff --git a/substrate/primitives/state-machine/src/ext.rs b/substrate/primitives/state-machine/src/ext.rs
new file mode 100644
index 0000000000000000000000000000000000000000..11df46f2a4a3a901753c10a5acf1b6535e61f8ea
--- /dev/null
+++ b/substrate/primitives/state-machine/src/ext.rs
@@ -0,0 +1,1058 @@
+// 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.
+
+//! Concrete externalities implementation.
+
+#[cfg(feature = "std")]
+use crate::overlayed_changes::OverlayedExtensions;
+use crate::{
+	backend::Backend, IndexOperation, IterArgs, OverlayedChanges, StorageKey, StorageValue,
+};
+use codec::{Encode, EncodeAppend};
+use hash_db::Hasher;
+#[cfg(feature = "std")]
+use sp_core::hexdisplay::HexDisplay;
+use sp_core::storage::{
+	well_known_keys::is_child_storage_key, ChildInfo, StateVersion, TrackedStorageKey,
+};
+use sp_externalities::{Extension, ExtensionStore, Externalities, MultiRemovalResults};
+
+use crate::{log_error, trace, warn};
+use sp_std::{
+	any::{Any, TypeId},
+	boxed::Box,
+	cmp::Ordering,
+	vec,
+	vec::Vec,
+};
+#[cfg(feature = "std")]
+use std::error;
+
+const EXT_NOT_ALLOWED_TO_FAIL: &str = "Externalities not allowed to fail within runtime";
+const BENCHMARKING_FN: &str = "\
+	This is a special fn only for benchmarking where a database commit happens from the runtime.
+	For that reason client started transactions before calling into runtime are not allowed.
+	Without client transactions the loop condition garantuees the success of the tx close.";
+
+#[cfg(feature = "std")]
+fn guard() -> sp_panic_handler::AbortGuard {
+	sp_panic_handler::AbortGuard::force_abort()
+}
+
+#[cfg(not(feature = "std"))]
+fn guard() -> () {
+	()
+}
+
+/// Errors that can occur when interacting with the externalities.
+#[cfg(feature = "std")]
+#[derive(Debug, Copy, Clone)]
+pub enum Error<B, E> {
+	/// Failure to load state data from the backend.
+	#[allow(unused)]
+	Backend(B),
+	/// Failure to execute a function.
+	#[allow(unused)]
+	Executor(E),
+}
+
+#[cfg(feature = "std")]
+impl<B: std::fmt::Display, E: std::fmt::Display> std::fmt::Display for Error<B, E> {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		match *self {
+			Error::Backend(ref e) => write!(f, "Storage backend error: {}", e),
+			Error::Executor(ref e) => write!(f, "Sub-call execution error: {}", e),
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl<B: error::Error, E: error::Error> error::Error for Error<B, E> {
+	fn description(&self) -> &str {
+		match *self {
+			Error::Backend(..) => "backend error",
+			Error::Executor(..) => "executor error",
+		}
+	}
+}
+
+/// Wraps a read-only backend, call executor, and current overlayed changes.
+pub struct Ext<'a, H, B>
+where
+	H: Hasher,
+	B: 'a + Backend<H>,
+{
+	/// The overlayed changes to write to.
+	overlay: &'a mut OverlayedChanges<H>,
+	/// The storage backend to read from.
+	backend: &'a B,
+	/// Pseudo-unique id used for tracing.
+	pub id: u16,
+	/// Extensions registered with this instance.
+	#[cfg(feature = "std")]
+	extensions: Option<OverlayedExtensions<'a>>,
+}
+
+impl<'a, H, B> Ext<'a, H, B>
+where
+	H: Hasher,
+	B: Backend<H>,
+{
+	/// Create a new `Ext`.
+	#[cfg(not(feature = "std"))]
+	pub fn new(overlay: &'a mut OverlayedChanges<H>, backend: &'a B) -> Self {
+		Ext { overlay, backend, id: 0 }
+	}
+
+	/// Create a new `Ext` from overlayed changes and read-only backend
+	#[cfg(feature = "std")]
+	pub fn new(
+		overlay: &'a mut OverlayedChanges<H>,
+		backend: &'a B,
+		extensions: Option<&'a mut sp_externalities::Extensions>,
+	) -> Self {
+		Self {
+			overlay,
+			backend,
+			id: rand::random(),
+			extensions: extensions.map(OverlayedExtensions::new),
+		}
+	}
+}
+
+#[cfg(test)]
+impl<'a, H, B> Ext<'a, H, B>
+where
+	H: Hasher,
+	H::Out: Ord + 'static,
+	B: 'a + Backend<H>,
+{
+	pub fn storage_pairs(&self) -> Vec<(StorageKey, StorageValue)> {
+		use std::collections::HashMap;
+
+		self.backend
+			.pairs(Default::default())
+			.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())))
+			.collect::<HashMap<_, _>>()
+			.into_iter()
+			.filter_map(|(k, maybe_val)| maybe_val.map(|val| (k, val)))
+			.collect()
+	}
+}
+
+impl<'a, H, B> Externalities for Ext<'a, H, B>
+where
+	H: Hasher,
+	H::Out: Ord + 'static + codec::Codec,
+	B: Backend<H>,
+{
+	fn set_offchain_storage(&mut self, key: &[u8], value: Option<&[u8]>) {
+		self.overlay.set_offchain_storage(key, value)
+	}
+
+	fn storage(&self, key: &[u8]) -> Option<StorageValue> {
+		let _guard = guard();
+		let result = self
+			.overlay
+			.storage(key)
+			.map(|x| x.map(|x| x.to_vec()))
+			.unwrap_or_else(|| self.backend.storage(key).expect(EXT_NOT_ALLOWED_TO_FAIL));
+
+		// NOTE: be careful about touching the key names – used outside substrate!
+		trace!(
+			target: "state",
+			method = "Get",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			key = %HexDisplay::from(&key),
+			result = ?result.as_ref().map(HexDisplay::from),
+			result_encoded = %HexDisplay::from(
+				&result
+					.as_ref()
+					.map(|v| EncodeOpaqueValue(v.clone()))
+					.encode()
+			),
+		);
+
+		result
+	}
+
+	fn storage_hash(&self, key: &[u8]) -> Option<Vec<u8>> {
+		let _guard = guard();
+		let result = self
+			.overlay
+			.storage(key)
+			.map(|x| x.map(|x| H::hash(x)))
+			.unwrap_or_else(|| self.backend.storage_hash(key).expect(EXT_NOT_ALLOWED_TO_FAIL));
+
+		trace!(
+			target: "state",
+			method = "Hash",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			key = %HexDisplay::from(&key),
+			?result,
+		);
+		result.map(|r| r.encode())
+	}
+
+	fn child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageValue> {
+		let _guard = guard();
+		let result = self
+			.overlay
+			.child_storage(child_info, key)
+			.map(|x| x.map(|x| x.to_vec()))
+			.unwrap_or_else(|| {
+				self.backend.child_storage(child_info, key).expect(EXT_NOT_ALLOWED_TO_FAIL)
+			});
+
+		trace!(
+			target: "state",
+			method = "ChildGet",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			child_info = %HexDisplay::from(&child_info.storage_key()),
+			key = %HexDisplay::from(&key),
+			result = ?result.as_ref().map(HexDisplay::from)
+		);
+
+		result
+	}
+
+	fn child_storage_hash(&self, child_info: &ChildInfo, key: &[u8]) -> Option<Vec<u8>> {
+		let _guard = guard();
+		let result = self
+			.overlay
+			.child_storage(child_info, key)
+			.map(|x| x.map(|x| H::hash(x)))
+			.unwrap_or_else(|| {
+				self.backend.child_storage_hash(child_info, key).expect(EXT_NOT_ALLOWED_TO_FAIL)
+			});
+
+		trace!(
+			target: "state",
+			method = "ChildHash",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			child_info = %HexDisplay::from(&child_info.storage_key()),
+			key = %HexDisplay::from(&key),
+			?result,
+		);
+
+		result.map(|r| r.encode())
+	}
+
+	fn exists_storage(&self, key: &[u8]) -> bool {
+		let _guard = guard();
+		let result = match self.overlay.storage(key) {
+			Some(x) => x.is_some(),
+			_ => self.backend.exists_storage(key).expect(EXT_NOT_ALLOWED_TO_FAIL),
+		};
+
+		trace!(
+			target: "state",
+			method = "Exists",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			key = %HexDisplay::from(&key),
+			%result,
+		);
+
+		result
+	}
+
+	fn exists_child_storage(&self, child_info: &ChildInfo, key: &[u8]) -> bool {
+		let _guard = guard();
+
+		let result = match self.overlay.child_storage(child_info, key) {
+			Some(x) => x.is_some(),
+			_ => self
+				.backend
+				.exists_child_storage(child_info, key)
+				.expect(EXT_NOT_ALLOWED_TO_FAIL),
+		};
+
+		trace!(
+			target: "state",
+			method = "ChildExists",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			child_info = %HexDisplay::from(&child_info.storage_key()),
+			key = %HexDisplay::from(&key),
+			%result,
+		);
+		result
+	}
+
+	fn next_storage_key(&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();
+
+		match (&next_backend_key, overlay_changes.peek()) {
+			(_, None) => next_backend_key,
+			(Some(_), Some(_)) => {
+				for overlay_key in overlay_changes {
+					let cmp = next_backend_key.as_deref().map(|v| v.cmp(overlay_key.0));
+
+					// If `backend_key` is less than the `overlay_key`, we found out next key.
+					if cmp == Some(Ordering::Less) {
+						return next_backend_key
+					} else if overlay_key.1.value().is_some() {
+						// If there exists a value for the `overlay_key` in the overlay
+						// (aka the key is still valid), it means we have found our next key.
+						return Some(overlay_key.0.to_vec())
+					} else if cmp == Some(Ordering::Equal) {
+						// If the `backend_key` and `overlay_key` are equal, it means that we need
+						// to search for the next backend key, because the overlay has overwritten
+						// this key.
+						next_backend_key = self
+							.backend
+							.next_storage_key(overlay_key.0)
+							.expect(EXT_NOT_ALLOWED_TO_FAIL);
+					}
+				}
+
+				next_backend_key
+			},
+			(None, Some(_)) => {
+				// Find the next overlay key that has a value attached.
+				overlay_changes.find_map(|k| k.1.value().as_ref().map(|_| k.0.to_vec()))
+			},
+		}
+	}
+
+	fn next_child_storage_key(&self, child_info: &ChildInfo, key: &[u8]) -> Option<StorageKey> {
+		let mut next_backend_key = self
+			.backend
+			.next_child_storage_key(child_info, key)
+			.expect(EXT_NOT_ALLOWED_TO_FAIL);
+		let mut overlay_changes =
+			self.overlay.child_iter_after(child_info.storage_key(), key).peekable();
+
+		match (&next_backend_key, overlay_changes.peek()) {
+			(_, None) => next_backend_key,
+			(Some(_), Some(_)) => {
+				for overlay_key in overlay_changes {
+					let cmp = next_backend_key.as_deref().map(|v| v.cmp(overlay_key.0));
+
+					// If `backend_key` is less than the `overlay_key`, we found out next key.
+					if cmp == Some(Ordering::Less) {
+						return next_backend_key
+					} else if overlay_key.1.value().is_some() {
+						// If there exists a value for the `overlay_key` in the overlay
+						// (aka the key is still valid), it means we have found our next key.
+						return Some(overlay_key.0.to_vec())
+					} else if cmp == Some(Ordering::Equal) {
+						// If the `backend_key` and `overlay_key` are equal, it means that we need
+						// to search for the next backend key, because the overlay has overwritten
+						// this key.
+						next_backend_key = self
+							.backend
+							.next_child_storage_key(child_info, overlay_key.0)
+							.expect(EXT_NOT_ALLOWED_TO_FAIL);
+					}
+				}
+
+				next_backend_key
+			},
+			(None, Some(_)) => {
+				// Find the next overlay key that has a value attached.
+				overlay_changes.find_map(|k| k.1.value().as_ref().map(|_| k.0.to_vec()))
+			},
+		}
+	}
+
+	fn place_storage(&mut self, key: StorageKey, value: Option<StorageValue>) {
+		let _guard = guard();
+		if is_child_storage_key(&key) {
+			warn!(target: "trie", "Refuse to directly set child storage key");
+			return
+		}
+
+		// NOTE: be careful about touching the key names – used outside substrate!
+		trace!(
+			target: "state",
+			method = "Put",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			key = %HexDisplay::from(&key),
+			value = ?value.as_ref().map(HexDisplay::from),
+			value_encoded = %HexDisplay::from(
+				&value
+					.as_ref()
+					.map(|v| EncodeOpaqueValue(v.clone()))
+					.encode()
+			),
+		);
+
+		self.overlay.set_storage(key, value);
+	}
+
+	fn place_child_storage(
+		&mut self,
+		child_info: &ChildInfo,
+		key: StorageKey,
+		value: Option<StorageValue>,
+	) {
+		trace!(
+			target: "state",
+			method = "ChildPut",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			child_info = %HexDisplay::from(&child_info.storage_key()),
+			key = %HexDisplay::from(&key),
+			value = ?value.as_ref().map(HexDisplay::from),
+		);
+		let _guard = guard();
+
+		self.overlay.set_child_storage(child_info, key, value);
+	}
+
+	fn kill_child_storage(
+		&mut self,
+		child_info: &ChildInfo,
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		trace!(
+			target: "state",
+			method = "ChildKill",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			child_info = %HexDisplay::from(&child_info.storage_key()),
+		);
+		let _guard = guard();
+		let overlay = self.overlay.clear_child_storage(child_info);
+		let (maybe_cursor, backend, loops) =
+			self.limit_remove_from_backend(Some(child_info), None, maybe_limit, maybe_cursor);
+		MultiRemovalResults { maybe_cursor, backend, unique: overlay + backend, loops }
+	}
+
+	fn clear_prefix(
+		&mut self,
+		prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		trace!(
+			target: "state",
+			method = "ClearPrefix",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			prefix = %HexDisplay::from(&prefix),
+		);
+		let _guard = guard();
+
+		if sp_core::storage::well_known_keys::starts_with_child_storage_key(prefix) {
+			warn!(
+				target: "trie",
+				"Refuse to directly clear prefix that is part or contains of child storage key",
+			);
+			return MultiRemovalResults { maybe_cursor: None, backend: 0, unique: 0, loops: 0 }
+		}
+
+		let overlay = self.overlay.clear_prefix(prefix);
+		let (maybe_cursor, backend, loops) =
+			self.limit_remove_from_backend(None, Some(prefix), maybe_limit, maybe_cursor);
+		MultiRemovalResults { maybe_cursor, backend, unique: overlay + backend, loops }
+	}
+
+	fn clear_child_prefix(
+		&mut self,
+		child_info: &ChildInfo,
+		prefix: &[u8],
+		maybe_limit: Option<u32>,
+		maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		trace!(
+			target: "state",
+			method = "ChildClearPrefix",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			child_info = %HexDisplay::from(&child_info.storage_key()),
+			prefix = %HexDisplay::from(&prefix),
+		);
+		let _guard = guard();
+
+		let overlay = self.overlay.clear_child_prefix(child_info, prefix);
+		let (maybe_cursor, backend, loops) = self.limit_remove_from_backend(
+			Some(child_info),
+			Some(prefix),
+			maybe_limit,
+			maybe_cursor,
+		);
+		MultiRemovalResults { maybe_cursor, backend, unique: overlay + backend, loops }
+	}
+
+	fn storage_append(&mut self, key: Vec<u8>, value: Vec<u8>) {
+		trace!(
+			target: "state",
+			method = "Append",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			key = %HexDisplay::from(&key),
+			value = %HexDisplay::from(&value),
+		);
+
+		let _guard = guard();
+
+		let backend = &mut self.backend;
+		let current_value = self.overlay.value_mut_or_insert_with(&key, || {
+			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> {
+		let _guard = guard();
+
+		let (root, _cached) = self.overlay.storage_root(self.backend, state_version);
+
+		trace!(
+			target: "state",
+			method = "StorageRoot",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			storage_root = %HexDisplay::from(&root.as_ref()),
+			cached = %_cached,
+		);
+
+		root.encode()
+	}
+
+	fn child_storage_root(
+		&mut self,
+		child_info: &ChildInfo,
+		state_version: StateVersion,
+	) -> Vec<u8> {
+		let _guard = guard();
+
+		let (root, _cached) = self
+			.overlay
+			.child_storage_root(child_info, self.backend, state_version)
+			.expect(EXT_NOT_ALLOWED_TO_FAIL);
+
+		trace!(
+			target: "state",
+			method = "ChildStorageRoot",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			child_info = %HexDisplay::from(&child_info.storage_key()),
+			storage_root = %HexDisplay::from(&root.as_ref()),
+			cached = %_cached,
+		);
+
+		root.encode()
+	}
+
+	fn storage_index_transaction(&mut self, index: u32, hash: &[u8], size: u32) {
+		trace!(
+			target: "state",
+			method = "IndexTransaction",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			%index,
+			tx_hash = %HexDisplay::from(&hash),
+			%size,
+		);
+
+		self.overlay.add_transaction_index(IndexOperation::Insert {
+			extrinsic: index,
+			hash: hash.to_vec(),
+			size,
+		});
+	}
+
+	/// Renew existing piece of data storage.
+	fn storage_renew_transaction_index(&mut self, index: u32, hash: &[u8]) {
+		trace!(
+			target: "state",
+			method = "RenewTransactionIndex",
+			ext_id = %HexDisplay::from(&self.id.to_le_bytes()),
+			%index,
+			tx_hash = %HexDisplay::from(&hash),
+		);
+
+		self.overlay
+			.add_transaction_index(IndexOperation::Renew { extrinsic: index, hash: hash.to_vec() });
+	}
+
+	fn storage_start_transaction(&mut self) {
+		self.overlay.start_transaction()
+	}
+
+	fn storage_rollback_transaction(&mut self) -> Result<(), ()> {
+		self.overlay.rollback_transaction().map_err(|_| ())
+	}
+
+	fn storage_commit_transaction(&mut self) -> Result<(), ()> {
+		self.overlay.commit_transaction().map_err(|_| ())
+	}
+
+	fn wipe(&mut self) {
+		for _ in 0..self.overlay.transaction_depth() {
+			self.overlay.rollback_transaction().expect(BENCHMARKING_FN);
+		}
+		self.overlay
+			.drain_storage_changes(self.backend, Default::default())
+			.expect(EXT_NOT_ALLOWED_TO_FAIL);
+		self.backend.wipe().expect(EXT_NOT_ALLOWED_TO_FAIL);
+		self.overlay
+			.enter_runtime()
+			.expect("We have reset the overlay above, so we can not be in the runtime; qed");
+	}
+
+	fn commit(&mut self) {
+		// Bench always use latest state.
+		let state_version = StateVersion::default();
+		for _ in 0..self.overlay.transaction_depth() {
+			self.overlay.commit_transaction().expect(BENCHMARKING_FN);
+		}
+		let changes = self
+			.overlay
+			.drain_storage_changes(self.backend, state_version)
+			.expect(EXT_NOT_ALLOWED_TO_FAIL);
+		self.backend
+			.commit(
+				changes.transaction_storage_root,
+				changes.transaction,
+				changes.main_storage_changes,
+				changes.child_storage_changes,
+			)
+			.expect(EXT_NOT_ALLOWED_TO_FAIL);
+		self.overlay
+			.enter_runtime()
+			.expect("We have reset the overlay above, so we can not be in the runtime; qed");
+	}
+
+	fn read_write_count(&self) -> (u32, u32, u32, u32) {
+		self.backend.read_write_count()
+	}
+
+	fn reset_read_write_count(&mut self) {
+		self.backend.reset_read_write_count()
+	}
+
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey> {
+		self.backend.get_whitelist()
+	}
+
+	fn set_whitelist(&mut self, new: Vec<TrackedStorageKey>) {
+		self.backend.set_whitelist(new)
+	}
+
+	fn proof_size(&self) -> Option<u32> {
+		self.backend.proof_size()
+	}
+
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> {
+		self.backend.get_read_and_written_keys()
+	}
+}
+
+impl<'a, H, B> Ext<'a, H, B>
+where
+	H: Hasher,
+	H::Out: Ord + 'static + codec::Codec,
+	B: Backend<H>,
+{
+	fn limit_remove_from_backend(
+		&mut self,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		maybe_limit: Option<u32>,
+		start_at: Option<&[u8]>,
+	) -> (Option<Vec<u8>>, u32, u32) {
+		let iter = match self.backend.keys(IterArgs {
+			child_info: child_info.cloned(),
+			prefix,
+			start_at,
+			..IterArgs::default()
+		}) {
+			Ok(iter) => iter,
+			Err(error) => {
+				log::debug!(target: "trie", "Error while iterating the storage: {}", error);
+				return (None, 0, 0)
+			},
+		};
+
+		let mut delete_count: u32 = 0;
+		let mut loop_count: u32 = 0;
+		let mut maybe_next_key = None;
+		for key in iter {
+			let key = match key {
+				Ok(key) => key,
+				Err(error) => {
+					log::debug!(target: "trie", "Error while iterating the storage: {}", error);
+					break
+				},
+			};
+
+			if maybe_limit.map_or(false, |limit| loop_count == limit) {
+				maybe_next_key = Some(key);
+				break
+			}
+			let overlay = match child_info {
+				Some(child_info) => self.overlay.child_storage(child_info, &key),
+				None => self.overlay.storage(&key),
+			};
+			if !matches!(overlay, Some(None)) {
+				// not pending deletion from the backend - delete it.
+				if let Some(child_info) = child_info {
+					self.overlay.set_child_storage(child_info, key, None);
+				} else {
+					self.overlay.set_storage(key, None);
+				}
+				delete_count = delete_count.saturating_add(1);
+			}
+			loop_count = loop_count.saturating_add(1);
+		}
+
+		(maybe_next_key, delete_count, loop_count)
+	}
+}
+
+/// Implement `Encode` by forwarding the stored raw vec.
+struct EncodeOpaqueValue(Vec<u8>);
+
+impl Encode for EncodeOpaqueValue {
+	fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+		f(&self.0)
+	}
+}
+
+/// Auxialiary structure for appending a value to a storage item.
+pub(crate) struct StorageAppend<'a>(&'a mut Vec<u8>);
+
+impl<'a> StorageAppend<'a> {
+	/// Create a new instance using the given `storage` reference.
+	pub fn new(storage: &'a mut Vec<u8>) -> Self {
+		Self(storage)
+	}
+
+	/// 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>) {
+		let value = vec![EncodeOpaqueValue(value)];
+
+		let item = sp_std::mem::take(self.0);
+
+		*self.0 = match Vec::<EncodeOpaqueValue>::append_or_new(item, &value) {
+			Ok(item) => item,
+			Err(_) => {
+				log_error!(
+					target: "runtime",
+					"Failed to append value, resetting storage item to `[value]`.",
+				);
+				value.encode()
+			},
+		};
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<'a, H, B> ExtensionStore for Ext<'a, H, B>
+where
+	H: Hasher,
+	H::Out: Ord + 'static + codec::Codec,
+	B: Backend<H>,
+{
+	fn extension_by_type_id(&mut self, _type_id: TypeId) -> Option<&mut dyn Any> {
+		None
+	}
+
+	fn register_extension_with_type_id(
+		&mut self,
+		_type_id: TypeId,
+		_extension: Box<dyn Extension>,
+	) -> Result<(), sp_externalities::Error> {
+		Err(sp_externalities::Error::ExtensionsAreNotSupported)
+	}
+
+	fn deregister_extension_by_type_id(
+		&mut self,
+		_type_id: TypeId,
+	) -> Result<(), sp_externalities::Error> {
+		Err(sp_externalities::Error::ExtensionsAreNotSupported)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<'a, H, B> ExtensionStore for Ext<'a, H, B>
+where
+	H: Hasher,
+	B: 'a + Backend<H>,
+{
+	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any> {
+		self.extensions.as_mut().and_then(|exts| exts.get_mut(type_id))
+	}
+
+	fn register_extension_with_type_id(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn Extension>,
+	) -> Result<(), sp_externalities::Error> {
+		if let Some(ref mut extensions) = self.extensions {
+			extensions.register(type_id, extension)
+		} else {
+			Err(sp_externalities::Error::ExtensionsAreNotSupported)
+		}
+	}
+
+	fn deregister_extension_by_type_id(
+		&mut self,
+		type_id: TypeId,
+	) -> Result<(), sp_externalities::Error> {
+		if let Some(ref mut extensions) = self.extensions {
+			if extensions.deregister(type_id) {
+				Ok(())
+			} else {
+				Err(sp_externalities::Error::ExtensionIsNotRegistered(type_id))
+			}
+		} else {
+			Err(sp_externalities::Error::ExtensionsAreNotSupported)
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::InMemoryBackend;
+	use codec::{Decode, Encode};
+	use sp_core::{
+		map,
+		storage::{Storage, StorageChild},
+		Blake2Hasher,
+	};
+
+	type TestBackend = InMemoryBackend<Blake2Hasher>;
+	type TestExt<'a> = Ext<'a, Blake2Hasher, TestBackend>;
+
+	#[test]
+	fn next_storage_key_works() {
+		let mut overlay = OverlayedChanges::default();
+		overlay.set_storage(vec![20], None);
+		overlay.set_storage(vec![30], Some(vec![31]));
+		let backend = (
+			Storage {
+				top: map![
+					vec![10] => vec![10],
+					vec![20] => vec![20],
+					vec![40] => vec![40]
+				],
+				children_default: map![],
+			},
+			StateVersion::default(),
+		)
+			.into();
+
+		let ext = TestExt::new(&mut overlay, &backend, None);
+
+		// next_backend < next_overlay
+		assert_eq!(ext.next_storage_key(&[5]), Some(vec![10]));
+
+		// next_backend == next_overlay but next_overlay is a delete
+		assert_eq!(ext.next_storage_key(&[10]), Some(vec![30]));
+
+		// next_overlay < next_backend
+		assert_eq!(ext.next_storage_key(&[20]), Some(vec![30]));
+
+		// next_backend exist but next_overlay doesn't exist
+		assert_eq!(ext.next_storage_key(&[30]), Some(vec![40]));
+
+		drop(ext);
+		overlay.set_storage(vec![50], Some(vec![50]));
+		let 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]));
+	}
+
+	#[test]
+	fn next_storage_key_works_with_a_lot_empty_values_in_overlay() {
+		let mut overlay = OverlayedChanges::default();
+		overlay.set_storage(vec![20], None);
+		overlay.set_storage(vec![21], None);
+		overlay.set_storage(vec![22], None);
+		overlay.set_storage(vec![23], None);
+		overlay.set_storage(vec![24], None);
+		overlay.set_storage(vec![25], None);
+		overlay.set_storage(vec![26], None);
+		overlay.set_storage(vec![27], None);
+		overlay.set_storage(vec![28], None);
+		overlay.set_storage(vec![29], None);
+		let backend = (
+			Storage {
+				top: map![
+					vec![30] => vec![30]
+				],
+				children_default: map![],
+			},
+			StateVersion::default(),
+		)
+			.into();
+
+		let ext = TestExt::new(&mut overlay, &backend, None);
+
+		assert_eq!(ext.next_storage_key(&[5]), Some(vec![30]));
+
+		drop(ext);
+	}
+
+	#[test]
+	fn next_child_storage_key_works() {
+		let child_info = ChildInfo::new_default(b"Child1");
+		let child_info = &child_info;
+
+		let mut overlay = OverlayedChanges::default();
+		overlay.set_child_storage(child_info, vec![20], None);
+		overlay.set_child_storage(child_info, vec![30], Some(vec![31]));
+		let backend = (
+			Storage {
+				top: map![],
+				children_default: map![
+					child_info.storage_key().to_vec() => StorageChild {
+						data: map![
+							vec![10] => vec![10],
+							vec![20] => vec![20],
+							vec![40] => vec![40]
+						],
+						child_info: child_info.to_owned(),
+					}
+				],
+			},
+			StateVersion::default(),
+		)
+			.into();
+
+		let ext = TestExt::new(&mut overlay, &backend, None);
+
+		// next_backend < next_overlay
+		assert_eq!(ext.next_child_storage_key(child_info, &[5]), Some(vec![10]));
+
+		// next_backend == next_overlay but next_overlay is a delete
+		assert_eq!(ext.next_child_storage_key(child_info, &[10]), Some(vec![30]));
+
+		// next_overlay < next_backend
+		assert_eq!(ext.next_child_storage_key(child_info, &[20]), Some(vec![30]));
+
+		// next_backend exist but next_overlay doesn't exist
+		assert_eq!(ext.next_child_storage_key(child_info, &[30]), Some(vec![40]));
+
+		drop(ext);
+		overlay.set_child_storage(child_info, vec![50], Some(vec![50]));
+		let 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]));
+	}
+
+	#[test]
+	fn child_storage_works() {
+		let child_info = ChildInfo::new_default(b"Child1");
+		let child_info = &child_info;
+		let mut overlay = OverlayedChanges::default();
+		overlay.set_child_storage(child_info, vec![20], None);
+		overlay.set_child_storage(child_info, vec![30], Some(vec![31]));
+		let backend = (
+			Storage {
+				top: map![],
+				children_default: map![
+					child_info.storage_key().to_vec() => StorageChild {
+						data: map![
+							vec![10] => vec![10],
+							vec![20] => vec![20],
+							vec![30] => vec![40]
+						],
+						child_info: child_info.to_owned(),
+					}
+				],
+			},
+			StateVersion::default(),
+		)
+			.into();
+
+		let ext = TestExt::new(&mut overlay, &backend, None);
+
+		assert_eq!(ext.child_storage(child_info, &[10]), Some(vec![10]));
+		assert_eq!(
+			ext.child_storage_hash(child_info, &[10]),
+			Some(Blake2Hasher::hash(&[10]).as_ref().to_vec()),
+		);
+
+		assert_eq!(ext.child_storage(child_info, &[20]), None);
+		assert_eq!(ext.child_storage_hash(child_info, &[20]), None);
+
+		assert_eq!(ext.child_storage(child_info, &[30]), Some(vec![31]));
+		assert_eq!(
+			ext.child_storage_hash(child_info, &[30]),
+			Some(Blake2Hasher::hash(&[31]).as_ref().to_vec()),
+		);
+	}
+
+	#[test]
+	fn clear_prefix_cannot_delete_a_child_root() {
+		let child_info = ChildInfo::new_default(b"Child1");
+		let child_info = &child_info;
+		let mut overlay = OverlayedChanges::default();
+		let backend = (
+			Storage {
+				top: map![],
+				children_default: map![
+					child_info.storage_key().to_vec() => StorageChild {
+						data: map![
+							vec![30] => vec![40]
+						],
+						child_info: child_info.to_owned(),
+					}
+				],
+			},
+			StateVersion::default(),
+		)
+			.into();
+
+		let ext = TestExt::new(&mut overlay, &backend, None);
+
+		use sp_core::storage::well_known_keys;
+		let mut ext = ext;
+		let mut not_under_prefix = well_known_keys::CHILD_STORAGE_KEY_PREFIX.to_vec();
+		not_under_prefix[4] = 88;
+		not_under_prefix.extend(b"path");
+		ext.set_storage(not_under_prefix.clone(), vec![10]);
+
+		let _ = ext.clear_prefix(&[], None, None);
+		let _ = ext.clear_prefix(&well_known_keys::CHILD_STORAGE_KEY_PREFIX[..4], None, None);
+		let mut under_prefix = well_known_keys::CHILD_STORAGE_KEY_PREFIX.to_vec();
+		under_prefix.extend(b"path");
+		let _ = ext.clear_prefix(&well_known_keys::CHILD_STORAGE_KEY_PREFIX[..4], None, None);
+		assert_eq!(ext.child_storage(child_info, &[30]), Some(vec![40]));
+		assert_eq!(ext.storage(not_under_prefix.as_slice()), Some(vec![10]));
+		let _ = ext.clear_prefix(&not_under_prefix[..5], None, None);
+		assert_eq!(ext.storage(not_under_prefix.as_slice()), None);
+	}
+
+	#[test]
+	fn storage_append_works() {
+		let mut data = Vec::new();
+		let mut append = StorageAppend::new(&mut data);
+		append.append(1u32.encode());
+		append.append(2u32.encode());
+		drop(append);
+
+		assert_eq!(Vec::<u32>::decode(&mut &data[..]).unwrap(), vec![1, 2]);
+
+		// Initialize with some invalid data
+		let mut data = vec![1];
+		let mut append = StorageAppend::new(&mut data);
+		append.append(1u32.encode());
+		append.append(2u32.encode());
+		drop(append);
+
+		assert_eq!(Vec::<u32>::decode(&mut &data[..]).unwrap(), vec![1, 2]);
+	}
+}
diff --git a/substrate/primitives/state-machine/src/in_memory_backend.rs b/substrate/primitives/state-machine/src/in_memory_backend.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ce551cec2a473ceacbc1ab99984af2e5ed4b64f4
--- /dev/null
+++ b/substrate/primitives/state-machine/src/in_memory_backend.rs
@@ -0,0 +1,226 @@
+// 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 in memory backend.
+
+use crate::{
+	backend::Backend, trie_backend::TrieBackend, StorageCollection, StorageKey, StorageValue,
+	TrieBackendBuilder,
+};
+use codec::Codec;
+use hash_db::Hasher;
+use sp_core::storage::{ChildInfo, StateVersion, Storage};
+use sp_trie::{empty_trie_root, LayoutV1, PrefixedMemoryDB};
+use std::collections::{BTreeMap, HashMap};
+
+/// Create a new empty instance of in-memory backend.
+pub fn new_in_mem<H>() -> TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H: Hasher,
+	H::Out: Codec + Ord,
+{
+	// V1 is same as V0 for an empty trie.
+	TrieBackendBuilder::new(Default::default(), empty_trie_root::<LayoutV1<H>>()).build()
+}
+
+impl<H: Hasher> TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H::Out: Codec + Ord,
+{
+	/// Copy the state, with applied updates
+	pub fn update<T: IntoIterator<Item = (Option<ChildInfo>, StorageCollection)>>(
+		&self,
+		changes: T,
+		state_version: StateVersion,
+	) -> Self {
+		let mut clone = self.clone();
+		clone.insert(changes, state_version);
+		clone
+	}
+
+	/// Insert values into backend trie.
+	pub fn insert<T: IntoIterator<Item = (Option<ChildInfo>, StorageCollection)>>(
+		&mut self,
+		changes: T,
+		state_version: StateVersion,
+	) {
+		let (top, child) = changes.into_iter().partition::<Vec<_>, _>(|v| v.0.is_none());
+		let (root, transaction) = self.full_storage_root(
+			top.iter().flat_map(|(_, v)| v).map(|(k, v)| (&k[..], v.as_deref())),
+			child.iter().filter_map(|v| {
+				v.0.as_ref().map(|c| (c, v.1.iter().map(|(k, v)| (&k[..], v.as_deref()))))
+			}),
+			state_version,
+		);
+
+		self.apply_transaction(root, transaction);
+	}
+
+	/// Merge trie nodes into this backend.
+	pub fn update_backend(&self, root: H::Out, changes: PrefixedMemoryDB<H>) -> Self {
+		let mut clone = self.backend_storage().clone();
+		clone.consolidate(changes);
+		TrieBackendBuilder::new(clone, root).build()
+	}
+
+	/// Apply the given transaction to this backend and set the root to the given value.
+	pub fn apply_transaction(&mut self, root: H::Out, transaction: PrefixedMemoryDB<H>) {
+		let mut storage = sp_std::mem::take(self).into_storage();
+
+		storage.consolidate(transaction);
+		*self = TrieBackendBuilder::new(storage, root).build();
+	}
+
+	/// Compare with another in-memory backend.
+	pub fn eq(&self, other: &Self) -> bool {
+		self.root() == other.root()
+	}
+}
+
+impl<H: Hasher> Clone for TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H::Out: Codec + Ord,
+{
+	fn clone(&self) -> Self {
+		TrieBackendBuilder::new(self.backend_storage().clone(), *self.root()).build()
+	}
+}
+
+impl<H> Default for TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H: Hasher,
+	H::Out: Codec + Ord,
+{
+	fn default() -> Self {
+		new_in_mem()
+	}
+}
+
+impl<H: Hasher> From<(HashMap<Option<ChildInfo>, BTreeMap<StorageKey, StorageValue>>, StateVersion)>
+	for TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H::Out: Codec + Ord,
+{
+	fn from(
+		(inner, state_version): (
+			HashMap<Option<ChildInfo>, BTreeMap<StorageKey, StorageValue>>,
+			StateVersion,
+		),
+	) -> Self {
+		let mut backend = new_in_mem();
+		backend.insert(
+			inner
+				.into_iter()
+				.map(|(k, m)| (k, m.into_iter().map(|(k, v)| (k, Some(v))).collect())),
+			state_version,
+		);
+		backend
+	}
+}
+
+impl<H: Hasher> From<(Storage, StateVersion)> for TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H::Out: Codec + Ord,
+{
+	fn from((inners, state_version): (Storage, StateVersion)) -> Self {
+		let mut inner: HashMap<Option<ChildInfo>, BTreeMap<StorageKey, StorageValue>> = inners
+			.children_default
+			.into_values()
+			.map(|c| (Some(c.child_info), c.data))
+			.collect();
+		inner.insert(None, inners.top);
+		(inner, state_version).into()
+	}
+}
+
+impl<H: Hasher> From<(BTreeMap<StorageKey, StorageValue>, StateVersion)>
+	for TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H::Out: Codec + Ord,
+{
+	fn from((inner, state_version): (BTreeMap<StorageKey, StorageValue>, StateVersion)) -> Self {
+		let mut expanded = HashMap::new();
+		expanded.insert(None, inner);
+		(expanded, state_version).into()
+	}
+}
+
+impl<H: Hasher> From<(Vec<(Option<ChildInfo>, StorageCollection)>, StateVersion)>
+	for TrieBackend<PrefixedMemoryDB<H>, H>
+where
+	H::Out: Codec + Ord,
+{
+	fn from(
+		(inner, state_version): (Vec<(Option<ChildInfo>, StorageCollection)>, StateVersion),
+	) -> Self {
+		let mut expanded: HashMap<Option<ChildInfo>, BTreeMap<StorageKey, StorageValue>> =
+			HashMap::new();
+		for (child_info, key_values) in inner {
+			let entry = expanded.entry(child_info).or_default();
+			for (key, value) in key_values {
+				if let Some(value) = value {
+					entry.insert(key, value);
+				}
+			}
+		}
+		(expanded, state_version).into()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::backend::{AsTrieBackend, Backend};
+	use sp_core::storage::StateVersion;
+	use sp_runtime::traits::BlakeTwo256;
+
+	/// Assert in memory backend with only child trie keys works as trie backend.
+	#[test]
+	fn in_memory_with_child_trie_only() {
+		let state_version = StateVersion::default();
+		let storage = new_in_mem::<BlakeTwo256>();
+		let child_info = ChildInfo::new_default(b"1");
+		let child_info = &child_info;
+		let storage = storage.update(
+			vec![(Some(child_info.clone()), vec![(b"2".to_vec(), Some(b"3".to_vec()))])],
+			state_version,
+		);
+		let trie_backend = storage.as_trie_backend();
+		assert_eq!(trie_backend.child_storage(child_info, b"2").unwrap(), Some(b"3".to_vec()));
+		let storage_key = child_info.prefixed_storage_key();
+		assert!(trie_backend.storage(storage_key.as_slice()).unwrap().is_some());
+	}
+
+	#[test]
+	fn insert_multiple_times_child_data_works() {
+		let state_version = StateVersion::default();
+		let mut storage = new_in_mem::<BlakeTwo256>();
+		let child_info = ChildInfo::new_default(b"1");
+
+		storage.insert(
+			vec![(Some(child_info.clone()), vec![(b"2".to_vec(), Some(b"3".to_vec()))])],
+			state_version,
+		);
+		storage.insert(
+			vec![(Some(child_info.clone()), vec![(b"1".to_vec(), Some(b"3".to_vec()))])],
+			state_version,
+		);
+
+		assert_eq!(storage.child_storage(&child_info, &b"2"[..]), Ok(Some(b"3".to_vec())));
+		assert_eq!(storage.child_storage(&child_info, &b"1"[..]), Ok(Some(b"3".to_vec())));
+	}
+}
diff --git a/substrate/primitives/state-machine/src/lib.rs b/substrate/primitives/state-machine/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0e2b9bfdfffcf01ae06933d5e02ff6842a80cc77
--- /dev/null
+++ b/substrate/primitives/state-machine/src/lib.rs
@@ -0,0 +1,1964 @@
+// 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.
+
+//! Substrate state machine implementation.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod backend;
+#[cfg(feature = "std")]
+mod basic;
+mod error;
+mod ext;
+#[cfg(feature = "std")]
+mod in_memory_backend;
+pub(crate) mod overlayed_changes;
+#[cfg(feature = "std")]
+mod read_only;
+mod stats;
+#[cfg(feature = "std")]
+mod testing;
+mod trie_backend;
+mod trie_backend_essence;
+
+pub use trie_backend::TrieCacheProvider;
+
+#[cfg(feature = "std")]
+pub use std_reexport::*;
+
+#[cfg(feature = "std")]
+pub use execution::*;
+#[cfg(feature = "std")]
+pub use log::{debug, error as log_error, warn};
+#[cfg(feature = "std")]
+pub use tracing::trace;
+
+/// In no_std we skip logs for state_machine, this macro
+/// is a noops.
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! warn {
+	(target: $target:expr, $message:expr $( , $arg:ident )* $( , )?) => {
+		{
+			$(
+				let _ = &$arg;
+			)*
+		}
+	};
+	($message:expr, $( $arg:expr, )*) => {
+		{
+			$(
+				let _ = &$arg;
+			)*
+		}
+	};
+}
+
+/// In no_std we skip logs for state_machine, this macro
+/// is a noops.
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! debug {
+	(target: $target:expr, $message:expr $( , $arg:ident )* $( , )?) => {
+		{
+			$(
+				let _ = &$arg;
+			)*
+		}
+	};
+}
+
+/// In no_std we skip logs for state_machine, this macro
+/// is a noops.
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! trace {
+	(target: $target:expr, $($arg:tt)+) => {
+		()
+	};
+	($($arg:tt)+) => {
+		()
+	};
+}
+
+/// In no_std we skip logs for state_machine, this macro
+/// is a noops.
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! log_error {
+	(target: $target:expr, $($arg:tt)+) => {
+		()
+	};
+	($($arg:tt)+) => {
+		()
+	};
+}
+
+/// Default error type to use with state machine trie backend.
+#[cfg(feature = "std")]
+pub type DefaultError = String;
+/// Error type to use with state machine trie backend.
+#[cfg(not(feature = "std"))]
+#[derive(Debug, Default, Clone, Copy, Eq, PartialEq)]
+pub struct DefaultError;
+
+#[cfg(not(feature = "std"))]
+impl sp_std::fmt::Display for DefaultError {
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+		write!(f, "DefaultError")
+	}
+}
+
+pub use crate::{
+	backend::{Backend, BackendTransaction, IterArgs, KeysIter, PairsIter, StorageIterator},
+	error::{Error, ExecutionError},
+	ext::Ext,
+	overlayed_changes::{
+		ChildStorageCollection, IndexOperation, OffchainChangesCollection,
+		OffchainOverlayedChanges, OverlayedChanges, StorageChanges, StorageCollection, StorageKey,
+		StorageValue,
+	},
+	stats::{StateMachineStats, UsageInfo, UsageUnit},
+	trie_backend::{TrieBackend, TrieBackendBuilder},
+	trie_backend_essence::{Storage, TrieBackendStorage},
+};
+
+#[cfg(feature = "std")]
+mod std_reexport {
+	pub use crate::{
+		basic::BasicExternalities,
+		error::{Error, ExecutionError},
+		in_memory_backend::new_in_mem,
+		read_only::{InspectState, ReadOnlyExternalities},
+		testing::TestExternalities,
+		trie_backend::create_proof_check_backend,
+	};
+	pub use sp_trie::{
+		trie_types::{TrieDBMutV0, TrieDBMutV1},
+		CompactProof, DBValue, LayoutV0, LayoutV1, MemoryDB, StorageProof, TrieMut,
+	};
+}
+
+#[cfg(feature = "std")]
+mod execution {
+	use crate::backend::AsTrieBackend;
+
+	use super::*;
+	use codec::Codec;
+	use hash_db::Hasher;
+	use smallvec::SmallVec;
+	use sp_core::{
+		hexdisplay::HexDisplay,
+		storage::{ChildInfo, ChildType, PrefixedStorageKey},
+		traits::{CallContext, CodeExecutor, RuntimeCode},
+	};
+	use sp_externalities::Extensions;
+	use sp_trie::PrefixedMemoryDB;
+	use std::collections::{HashMap, HashSet};
+
+	pub(crate) type CallResult<E> = Result<Vec<u8>, E>;
+
+	/// Default handler of the execution manager.
+	pub type DefaultHandler<E> = fn(CallResult<E>, CallResult<E>) -> CallResult<E>;
+
+	/// Trie backend with in-memory storage.
+	pub type InMemoryBackend<H> = TrieBackend<PrefixedMemoryDB<H>, H>;
+
+	/// Storage backend trust level.
+	#[derive(Debug, Clone)]
+	pub enum BackendTrustLevel {
+		/// Panics from trusted backends are considered justified, and never caught.
+		Trusted,
+		/// Panics from untrusted backend are caught and interpreted as runtime error.
+		/// Untrusted backend may be missing some parts of the trie, so panics are not considered
+		/// fatal.
+		Untrusted,
+	}
+
+	/// The substrate state machine.
+	pub struct StateMachine<'a, B, H, Exec>
+	where
+		H: Hasher,
+		B: Backend<H>,
+	{
+		backend: &'a B,
+		exec: &'a Exec,
+		method: &'a str,
+		call_data: &'a [u8],
+		overlay: &'a mut OverlayedChanges<H>,
+		extensions: &'a mut Extensions,
+		runtime_code: &'a RuntimeCode<'a>,
+		stats: StateMachineStats,
+		/// The hash of the block the state machine will be executed on.
+		///
+		/// Used for logging.
+		parent_hash: Option<H::Out>,
+		context: CallContext,
+	}
+
+	impl<'a, B, H, Exec> Drop for StateMachine<'a, B, H, Exec>
+	where
+		H: Hasher,
+		B: Backend<H>,
+	{
+		fn drop(&mut self) {
+			self.backend.register_overlay_stats(&self.stats);
+		}
+	}
+
+	impl<'a, B, H, Exec> StateMachine<'a, B, H, Exec>
+	where
+		H: Hasher,
+		H::Out: Ord + 'static + codec::Codec,
+		Exec: CodeExecutor + Clone + 'static,
+		B: Backend<H>,
+	{
+		/// Creates new substrate state machine.
+		pub fn new(
+			backend: &'a B,
+			overlay: &'a mut OverlayedChanges<H>,
+			exec: &'a Exec,
+			method: &'a str,
+			call_data: &'a [u8],
+			extensions: &'a mut Extensions,
+			runtime_code: &'a RuntimeCode,
+			context: CallContext,
+		) -> Self {
+			Self {
+				backend,
+				exec,
+				method,
+				call_data,
+				extensions,
+				overlay,
+				runtime_code,
+				stats: StateMachineStats::default(),
+				parent_hash: None,
+				context,
+			}
+		}
+
+		/// Set the given `parent_hash` as the hash of the parent block.
+		///
+		/// This will be used for improved logging.
+		pub fn set_parent_hash(mut self, parent_hash: H::Out) -> Self {
+			self.parent_hash = Some(parent_hash);
+			self
+		}
+
+		/// Execute a call using the given state backend, overlayed changes, and call executor.
+		///
+		/// On an error, no prospective changes are written to the overlay.
+		///
+		/// Note: changes to code will be in place if this call is made again. For running partial
+		/// blocks (e.g. a transaction at a time), ensure a different method is used.
+		///
+		/// Returns the SCALE encoded result of the executed function.
+		pub fn execute(&mut self) -> Result<Vec<u8>, Box<dyn Error>> {
+			self.overlay
+				.enter_runtime()
+				.expect("StateMachine is never called from the runtime; qed");
+
+			let mut ext = Ext::new(self.overlay, self.backend, Some(self.extensions));
+
+			let ext_id = ext.id;
+
+			trace!(
+				target: "state",
+				ext_id = %HexDisplay::from(&ext_id.to_le_bytes()),
+				method = %self.method,
+				parent_hash = %self.parent_hash.map(|h| format!("{:?}", h)).unwrap_or_else(|| String::from("None")),
+				input = ?HexDisplay::from(&self.call_data),
+				"Call",
+			);
+
+			let result = self
+				.exec
+				.call(&mut ext, self.runtime_code, self.method, self.call_data, false, self.context)
+				.0;
+
+			self.overlay
+				.exit_runtime()
+				.expect("Runtime is not able to call this function in the overlay; qed");
+
+			trace!(
+				target: "state",
+				ext_id = %HexDisplay::from(&ext_id.to_le_bytes()),
+				?result,
+				"Return",
+			);
+
+			result.map_err(|e| Box::new(e) as Box<_>)
+		}
+	}
+
+	/// Prove execution using the given state backend, overlayed changes, and call executor.
+	pub fn prove_execution<B, H, Exec>(
+		backend: &mut B,
+		overlay: &mut OverlayedChanges<H>,
+		exec: &Exec,
+		method: &str,
+		call_data: &[u8],
+		runtime_code: &RuntimeCode,
+	) -> Result<(Vec<u8>, StorageProof), Box<dyn Error>>
+	where
+		B: AsTrieBackend<H>,
+		H: Hasher,
+		H::Out: Ord + 'static + codec::Codec,
+		Exec: CodeExecutor + Clone + 'static,
+	{
+		let trie_backend = backend.as_trie_backend();
+		prove_execution_on_trie_backend::<_, _, _>(
+			trie_backend,
+			overlay,
+			exec,
+			method,
+			call_data,
+			runtime_code,
+			&mut Default::default(),
+		)
+	}
+
+	/// Prove execution using the given trie backend, overlayed changes, and call executor.
+	/// Produces a state-backend-specific "transaction" which can be used to apply the changes
+	/// to the backing store, such as the disk.
+	/// Execution proof is the set of all 'touched' storage DBValues from the backend.
+	///
+	/// On an error, no prospective changes are written to the overlay.
+	///
+	/// Note: changes to code will be in place if this call is made again. For running partial
+	/// blocks (e.g. a transaction at a time), ensure a different method is used.
+	pub fn prove_execution_on_trie_backend<S, H, Exec>(
+		trie_backend: &TrieBackend<S, H>,
+		overlay: &mut OverlayedChanges<H>,
+		exec: &Exec,
+		method: &str,
+		call_data: &[u8],
+		runtime_code: &RuntimeCode,
+		extensions: &mut Extensions,
+	) -> Result<(Vec<u8>, StorageProof), Box<dyn Error>>
+	where
+		S: trie_backend_essence::TrieBackendStorage<H>,
+		H: Hasher,
+		H::Out: Ord + 'static + codec::Codec,
+		Exec: CodeExecutor + 'static + Clone,
+	{
+		let proving_backend =
+			TrieBackendBuilder::wrap(trie_backend).with_recorder(Default::default()).build();
+
+		let result = StateMachine::<_, H, Exec>::new(
+			&proving_backend,
+			overlay,
+			exec,
+			method,
+			call_data,
+			extensions,
+			runtime_code,
+			CallContext::Offchain,
+		)
+		.execute()?;
+
+		let proof = proving_backend
+			.extract_proof()
+			.expect("A recorder was set and thus, a storage proof can be extracted; qed");
+
+		Ok((result, proof))
+	}
+
+	/// Check execution proof, generated by `prove_execution` call.
+	pub fn execution_proof_check<H, Exec>(
+		root: H::Out,
+		proof: StorageProof,
+		overlay: &mut OverlayedChanges<H>,
+		exec: &Exec,
+		method: &str,
+		call_data: &[u8],
+		runtime_code: &RuntimeCode,
+	) -> Result<Vec<u8>, Box<dyn Error>>
+	where
+		H: Hasher + 'static,
+		Exec: CodeExecutor + Clone + 'static,
+		H::Out: Ord + 'static + codec::Codec,
+	{
+		let trie_backend = create_proof_check_backend::<H>(root, proof)?;
+		execution_proof_check_on_trie_backend::<_, _>(
+			&trie_backend,
+			overlay,
+			exec,
+			method,
+			call_data,
+			runtime_code,
+		)
+	}
+
+	/// Check execution proof on proving backend, generated by `prove_execution` call.
+	pub fn execution_proof_check_on_trie_backend<H, Exec>(
+		trie_backend: &TrieBackend<MemoryDB<H>, H>,
+		overlay: &mut OverlayedChanges<H>,
+		exec: &Exec,
+		method: &str,
+		call_data: &[u8],
+		runtime_code: &RuntimeCode,
+	) -> Result<Vec<u8>, Box<dyn Error>>
+	where
+		H: Hasher,
+		H::Out: Ord + 'static + codec::Codec,
+		Exec: CodeExecutor + Clone + 'static,
+	{
+		StateMachine::<_, H, Exec>::new(
+			trie_backend,
+			overlay,
+			exec,
+			method,
+			call_data,
+			&mut Extensions::default(),
+			runtime_code,
+			CallContext::Offchain,
+		)
+		.execute()
+	}
+
+	/// Generate storage read proof.
+	pub fn prove_read<B, H, I>(backend: B, keys: I) -> Result<StorageProof, Box<dyn Error>>
+	where
+		B: AsTrieBackend<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+		I: IntoIterator,
+		I::Item: AsRef<[u8]>,
+	{
+		let trie_backend = backend.as_trie_backend();
+		prove_read_on_trie_backend(trie_backend, keys)
+	}
+
+	/// State machine only allows a single level
+	/// of child trie.
+	pub const MAX_NESTED_TRIE_DEPTH: usize = 2;
+
+	/// Multiple key value state.
+	/// States are ordered by root storage key.
+	#[derive(PartialEq, Eq, Clone)]
+	pub struct KeyValueStates(pub Vec<KeyValueStorageLevel>);
+
+	/// A key value state at any storage level.
+	#[derive(PartialEq, Eq, Clone)]
+	pub struct KeyValueStorageLevel {
+		/// State root of the level, for
+		/// top trie it is as an empty byte array.
+		pub state_root: Vec<u8>,
+		/// Storage of parents, empty for top root or
+		/// when exporting (building proof).
+		pub parent_storage_keys: Vec<Vec<u8>>,
+		/// Pair of key and values from this state.
+		pub key_values: Vec<(Vec<u8>, Vec<u8>)>,
+	}
+
+	impl<I> From<I> for KeyValueStates
+	where
+		I: IntoIterator<Item = (Vec<u8>, (Vec<(Vec<u8>, Vec<u8>)>, Vec<Vec<u8>>))>,
+	{
+		fn from(b: I) -> Self {
+			let mut result = Vec::new();
+			for (state_root, (key_values, storage_paths)) in b.into_iter() {
+				result.push(KeyValueStorageLevel {
+					state_root,
+					key_values,
+					parent_storage_keys: storage_paths,
+				})
+			}
+			KeyValueStates(result)
+		}
+	}
+
+	impl KeyValueStates {
+		/// Return total number of key values in states.
+		pub fn len(&self) -> usize {
+			self.0.iter().fold(0, |nb, state| nb + state.key_values.len())
+		}
+
+		/// Update last keys accessed from this state.
+		pub fn update_last_key(
+			&self,
+			stopped_at: usize,
+			last: &mut SmallVec<[Vec<u8>; 2]>,
+		) -> bool {
+			if stopped_at == 0 || stopped_at > MAX_NESTED_TRIE_DEPTH {
+				return false
+			}
+			match stopped_at {
+				1 => {
+					let top_last =
+						self.0.get(0).and_then(|s| s.key_values.last().map(|kv| kv.0.clone()));
+					if let Some(top_last) = top_last {
+						match last.len() {
+							0 => {
+								last.push(top_last);
+								return true
+							},
+							2 => {
+								last.pop();
+							},
+							_ => (),
+						}
+						// update top trie access.
+						last[0] = top_last;
+						return true
+					} else {
+						// No change in top trie accesses.
+						// Indicates end of reading of a child trie.
+						last.truncate(1);
+						return true
+					}
+				},
+				2 => {
+					let top_last =
+						self.0.get(0).and_then(|s| s.key_values.last().map(|kv| kv.0.clone()));
+					let child_last =
+						self.0.last().and_then(|s| s.key_values.last().map(|kv| kv.0.clone()));
+
+					if let Some(child_last) = child_last {
+						if last.is_empty() {
+							if let Some(top_last) = top_last {
+								last.push(top_last)
+							} else {
+								return false
+							}
+						} else if let Some(top_last) = top_last {
+							last[0] = top_last;
+						}
+						if last.len() == 2 {
+							last.pop();
+						}
+						last.push(child_last);
+						return true
+					} else {
+						// stopped at level 2 so child last is define.
+						return false
+					}
+				},
+				_ => (),
+			}
+			false
+		}
+	}
+
+	/// Generate range storage read proof, with child tries
+	/// content.
+	/// A size limit is applied to the proof with the
+	/// exception that `start_at` and its following element
+	/// are always part of the proof.
+	/// If a key different than `start_at` is a child trie root,
+	/// the child trie content will be included in the proof.
+	pub fn prove_range_read_with_child_with_size<B, H>(
+		backend: B,
+		size_limit: usize,
+		start_at: &[Vec<u8>],
+	) -> Result<(StorageProof, u32), Box<dyn Error>>
+	where
+		B: AsTrieBackend<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let trie_backend = backend.as_trie_backend();
+		prove_range_read_with_child_with_size_on_trie_backend(trie_backend, size_limit, start_at)
+	}
+
+	/// Generate range storage read proof, with child tries
+	/// content.
+	/// See `prove_range_read_with_child_with_size`.
+	pub fn prove_range_read_with_child_with_size_on_trie_backend<S, H>(
+		trie_backend: &TrieBackend<S, H>,
+		size_limit: usize,
+		start_at: &[Vec<u8>],
+	) -> Result<(StorageProof, u32), Box<dyn Error>>
+	where
+		S: trie_backend_essence::TrieBackendStorage<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		if start_at.len() > MAX_NESTED_TRIE_DEPTH {
+			return Err(Box::new("Invalid start of range."))
+		}
+
+		let recorder = sp_trie::recorder::Recorder::default();
+		let proving_backend =
+			TrieBackendBuilder::wrap(trie_backend).with_recorder(recorder.clone()).build();
+		let mut count = 0;
+
+		let mut child_roots = HashSet::new();
+		let (mut child_key, mut start_at) = if start_at.len() == 2 {
+			let storage_key = start_at.get(0).expect("Checked length.").clone();
+			if let Some(state_root) = proving_backend
+				.storage(&storage_key)
+				.map_err(|e| Box::new(e) as Box<dyn Error>)?
+			{
+				child_roots.insert(state_root);
+			} else {
+				return Err(Box::new("Invalid range start child trie key."))
+			}
+
+			(Some(storage_key), start_at.get(1).cloned())
+		} else {
+			(None, start_at.get(0).cloned())
+		};
+
+		loop {
+			let (child_info, depth) = if let Some(storage_key) = child_key.as_ref() {
+				let storage_key = PrefixedStorageKey::new_ref(storage_key);
+				(
+					Some(match ChildType::from_prefixed_key(storage_key) {
+						Some((ChildType::ParentKeyId, storage_key)) =>
+							ChildInfo::new_default(storage_key),
+						None => return Err(Box::new("Invalid range start child trie key.")),
+					}),
+					2,
+				)
+			} else {
+				(None, 1)
+			};
+
+			let start_at_ref = start_at.as_ref().map(AsRef::as_ref);
+			let mut switch_child_key = None;
+			let mut iter = proving_backend
+				.pairs(IterArgs {
+					child_info,
+					start_at: start_at_ref,
+					start_at_exclusive: true,
+					..IterArgs::default()
+				})
+				.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+
+			while let Some(item) = iter.next() {
+				let (key, value) = item.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+
+				if depth < MAX_NESTED_TRIE_DEPTH &&
+					sp_core::storage::well_known_keys::is_child_storage_key(key.as_slice())
+				{
+					count += 1;
+					// do not add two child trie with same root
+					if !child_roots.contains(value.as_slice()) {
+						child_roots.insert(value);
+						switch_child_key = Some(key);
+						break
+					}
+				} else if recorder.estimate_encoded_size() <= size_limit {
+					count += 1;
+				} else {
+					break
+				}
+			}
+
+			let completed = iter.was_complete();
+
+			if switch_child_key.is_none() {
+				if depth == 1 {
+					break
+				} else if completed {
+					start_at = child_key.take();
+				} else {
+					break
+				}
+			} else {
+				child_key = switch_child_key;
+				start_at = None;
+			}
+		}
+
+		let proof = proving_backend
+			.extract_proof()
+			.expect("A recorder was set and thus, a storage proof can be extracted; qed");
+		Ok((proof, count))
+	}
+
+	/// Generate range storage read proof.
+	pub fn prove_range_read_with_size<B, H>(
+		backend: B,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		size_limit: usize,
+		start_at: Option<&[u8]>,
+	) -> Result<(StorageProof, u32), Box<dyn Error>>
+	where
+		B: AsTrieBackend<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let trie_backend = backend.as_trie_backend();
+		prove_range_read_with_size_on_trie_backend(
+			trie_backend,
+			child_info,
+			prefix,
+			size_limit,
+			start_at,
+		)
+	}
+
+	/// Generate range storage read proof on an existing trie backend.
+	pub fn prove_range_read_with_size_on_trie_backend<S, H>(
+		trie_backend: &TrieBackend<S, H>,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		size_limit: usize,
+		start_at: Option<&[u8]>,
+	) -> Result<(StorageProof, u32), Box<dyn Error>>
+	where
+		S: trie_backend_essence::TrieBackendStorage<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let recorder = sp_trie::recorder::Recorder::default();
+		let proving_backend =
+			TrieBackendBuilder::wrap(trie_backend).with_recorder(recorder.clone()).build();
+		let mut count = 0;
+		let iter = proving_backend
+			// NOTE: Even though the loop below doesn't use these values
+			//       this *must* fetch both the keys and the values so that
+			//       the proof is correct.
+			.pairs(IterArgs {
+				child_info: child_info.cloned(),
+				prefix,
+				start_at,
+				..IterArgs::default()
+			})
+			.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+
+		for item in iter {
+			item.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+			if count == 0 || recorder.estimate_encoded_size() <= size_limit {
+				count += 1;
+			} else {
+				break
+			}
+		}
+
+		let proof = proving_backend
+			.extract_proof()
+			.expect("A recorder was set and thus, a storage proof can be extracted; qed");
+		Ok((proof, count))
+	}
+
+	/// Generate child storage read proof.
+	pub fn prove_child_read<B, H, I>(
+		backend: B,
+		child_info: &ChildInfo,
+		keys: I,
+	) -> Result<StorageProof, Box<dyn Error>>
+	where
+		B: AsTrieBackend<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+		I: IntoIterator,
+		I::Item: AsRef<[u8]>,
+	{
+		let trie_backend = backend.as_trie_backend();
+		prove_child_read_on_trie_backend(trie_backend, child_info, keys)
+	}
+
+	/// Generate storage read proof on pre-created trie backend.
+	pub fn prove_read_on_trie_backend<S, H, I>(
+		trie_backend: &TrieBackend<S, H>,
+		keys: I,
+	) -> Result<StorageProof, Box<dyn Error>>
+	where
+		S: trie_backend_essence::TrieBackendStorage<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+		I: IntoIterator,
+		I::Item: AsRef<[u8]>,
+	{
+		let proving_backend =
+			TrieBackendBuilder::wrap(trie_backend).with_recorder(Default::default()).build();
+		for key in keys.into_iter() {
+			proving_backend
+				.storage(key.as_ref())
+				.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+		}
+
+		Ok(proving_backend
+			.extract_proof()
+			.expect("A recorder was set and thus, a storage proof can be extracted; qed"))
+	}
+
+	/// Generate storage read proof on pre-created trie backend.
+	pub fn prove_child_read_on_trie_backend<S, H, I>(
+		trie_backend: &TrieBackend<S, H>,
+		child_info: &ChildInfo,
+		keys: I,
+	) -> Result<StorageProof, Box<dyn Error>>
+	where
+		S: trie_backend_essence::TrieBackendStorage<H>,
+		H: Hasher,
+		H::Out: Ord + Codec,
+		I: IntoIterator,
+		I::Item: AsRef<[u8]>,
+	{
+		let proving_backend =
+			TrieBackendBuilder::wrap(trie_backend).with_recorder(Default::default()).build();
+		for key in keys.into_iter() {
+			proving_backend
+				.child_storage(child_info, key.as_ref())
+				.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+		}
+
+		Ok(proving_backend
+			.extract_proof()
+			.expect("A recorder was set and thus, a storage proof can be extracted; qed"))
+	}
+
+	/// Check storage read proof, generated by `prove_read` call.
+	pub fn read_proof_check<H, I>(
+		root: H::Out,
+		proof: StorageProof,
+		keys: I,
+	) -> Result<HashMap<Vec<u8>, Option<Vec<u8>>>, Box<dyn Error>>
+	where
+		H: Hasher + 'static,
+		H::Out: Ord + Codec,
+		I: IntoIterator,
+		I::Item: AsRef<[u8]>,
+	{
+		let proving_backend = create_proof_check_backend::<H>(root, proof)?;
+		let mut result = HashMap::new();
+		for key in keys.into_iter() {
+			let value = read_proof_check_on_proving_backend(&proving_backend, key.as_ref())?;
+			result.insert(key.as_ref().to_vec(), value);
+		}
+		Ok(result)
+	}
+
+	/// Check storage range proof with child trie included, generated by
+	/// `prove_range_read_with_child_with_size` call.
+	///
+	/// Returns key values contents and the depth of the pending state iteration
+	/// (0 if completed).
+	pub fn read_range_proof_check_with_child<H>(
+		root: H::Out,
+		proof: StorageProof,
+		start_at: &[Vec<u8>],
+	) -> Result<(KeyValueStates, usize), Box<dyn Error>>
+	where
+		H: Hasher + 'static,
+		H::Out: Ord + Codec,
+	{
+		let proving_backend = create_proof_check_backend::<H>(root, proof)?;
+		read_range_proof_check_with_child_on_proving_backend(&proving_backend, start_at)
+	}
+
+	/// Check child storage range proof, generated by `prove_range_read_with_size` call.
+	pub fn read_range_proof_check<H>(
+		root: H::Out,
+		proof: StorageProof,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		count: Option<u32>,
+		start_at: Option<&[u8]>,
+	) -> Result<(Vec<(Vec<u8>, Vec<u8>)>, bool), Box<dyn Error>>
+	where
+		H: Hasher + 'static,
+		H::Out: Ord + Codec,
+	{
+		let proving_backend = create_proof_check_backend::<H>(root, proof)?;
+		read_range_proof_check_on_proving_backend(
+			&proving_backend,
+			child_info,
+			prefix,
+			count,
+			start_at,
+		)
+	}
+
+	/// Check child storage read proof, generated by `prove_child_read` call.
+	pub fn read_child_proof_check<H, I>(
+		root: H::Out,
+		proof: StorageProof,
+		child_info: &ChildInfo,
+		keys: I,
+	) -> Result<HashMap<Vec<u8>, Option<Vec<u8>>>, Box<dyn Error>>
+	where
+		H: Hasher + 'static,
+		H::Out: Ord + Codec,
+		I: IntoIterator,
+		I::Item: AsRef<[u8]>,
+	{
+		let proving_backend = create_proof_check_backend::<H>(root, proof)?;
+		let mut result = HashMap::new();
+		for key in keys.into_iter() {
+			let value = read_child_proof_check_on_proving_backend(
+				&proving_backend,
+				child_info,
+				key.as_ref(),
+			)?;
+			result.insert(key.as_ref().to_vec(), value);
+		}
+		Ok(result)
+	}
+
+	/// Check storage read proof on pre-created proving backend.
+	pub fn read_proof_check_on_proving_backend<H>(
+		proving_backend: &TrieBackend<MemoryDB<H>, H>,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Box<dyn Error>>
+	where
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		proving_backend.storage(key).map_err(|e| Box::new(e) as Box<dyn Error>)
+	}
+
+	/// Check child storage read proof on pre-created proving backend.
+	pub fn read_child_proof_check_on_proving_backend<H>(
+		proving_backend: &TrieBackend<MemoryDB<H>, H>,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<Vec<u8>>, Box<dyn Error>>
+	where
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		proving_backend
+			.child_storage(child_info, key)
+			.map_err(|e| Box::new(e) as Box<dyn Error>)
+	}
+
+	/// Check storage range proof on pre-created proving backend.
+	///
+	/// Returns a vector with the read `key => value` pairs and a `bool` that is set to `true` when
+	/// all `key => value` pairs could be read and no more are left.
+	pub fn read_range_proof_check_on_proving_backend<H>(
+		proving_backend: &TrieBackend<MemoryDB<H>, H>,
+		child_info: Option<&ChildInfo>,
+		prefix: Option<&[u8]>,
+		count: Option<u32>,
+		start_at: Option<&[u8]>,
+	) -> Result<(Vec<(Vec<u8>, Vec<u8>)>, bool), Box<dyn Error>>
+	where
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let mut values = Vec::new();
+		let mut iter = proving_backend
+			.pairs(IterArgs {
+				child_info: child_info.cloned(),
+				prefix,
+				start_at,
+				stop_on_incomplete_database: true,
+				..IterArgs::default()
+			})
+			.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+
+		while let Some(item) = iter.next() {
+			let (key, value) = item.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+			values.push((key, value));
+			if !count.as_ref().map_or(true, |c| (values.len() as u32) < *c) {
+				break
+			}
+		}
+
+		Ok((values, iter.was_complete()))
+	}
+
+	/// Check storage range proof on pre-created proving backend.
+	///
+	/// See `read_range_proof_check_with_child`.
+	pub fn read_range_proof_check_with_child_on_proving_backend<H>(
+		proving_backend: &TrieBackend<MemoryDB<H>, H>,
+		start_at: &[Vec<u8>],
+	) -> Result<(KeyValueStates, usize), Box<dyn Error>>
+	where
+		H: Hasher,
+		H::Out: Ord + Codec,
+	{
+		let mut result = vec![KeyValueStorageLevel {
+			state_root: Default::default(),
+			key_values: Default::default(),
+			parent_storage_keys: Default::default(),
+		}];
+		if start_at.len() > MAX_NESTED_TRIE_DEPTH {
+			return Err(Box::new("Invalid start of range."))
+		}
+
+		let mut child_roots = HashSet::new();
+		let (mut child_key, mut start_at) = if start_at.len() == 2 {
+			let storage_key = start_at.get(0).expect("Checked length.").clone();
+			let child_key = if let Some(state_root) = proving_backend
+				.storage(&storage_key)
+				.map_err(|e| Box::new(e) as Box<dyn Error>)?
+			{
+				child_roots.insert(state_root.clone());
+				Some((storage_key, state_root))
+			} else {
+				return Err(Box::new("Invalid range start child trie key."))
+			};
+
+			(child_key, start_at.get(1).cloned())
+		} else {
+			(None, start_at.get(0).cloned())
+		};
+
+		let completed = loop {
+			let (child_info, depth) = if let Some((storage_key, state_root)) = child_key.as_ref() {
+				result.push(KeyValueStorageLevel {
+					state_root: state_root.clone(),
+					key_values: Default::default(),
+					parent_storage_keys: Default::default(),
+				});
+
+				let storage_key = PrefixedStorageKey::new_ref(storage_key);
+				(
+					Some(match ChildType::from_prefixed_key(storage_key) {
+						Some((ChildType::ParentKeyId, storage_key)) =>
+							ChildInfo::new_default(storage_key),
+						None => return Err(Box::new("Invalid range start child trie key.")),
+					}),
+					2,
+				)
+			} else {
+				(None, 1)
+			};
+
+			let values = if child_info.is_some() {
+				&mut result.last_mut().expect("Added above").key_values
+			} else {
+				&mut result[0].key_values
+			};
+			let start_at_ref = start_at.as_ref().map(AsRef::as_ref);
+			let mut switch_child_key = None;
+
+			let mut iter = proving_backend
+				.pairs(IterArgs {
+					child_info,
+					start_at: start_at_ref,
+					start_at_exclusive: true,
+					stop_on_incomplete_database: true,
+					..IterArgs::default()
+				})
+				.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+
+			while let Some(item) = iter.next() {
+				let (key, value) = item.map_err(|e| Box::new(e) as Box<dyn Error>)?;
+				values.push((key.to_vec(), value.to_vec()));
+
+				if depth < MAX_NESTED_TRIE_DEPTH &&
+					sp_core::storage::well_known_keys::is_child_storage_key(key.as_slice())
+				{
+					// Do not add two chid trie with same root.
+					if !child_roots.contains(value.as_slice()) {
+						child_roots.insert(value.clone());
+						switch_child_key = Some((key, value));
+						break
+					}
+				}
+			}
+
+			let completed = iter.was_complete();
+
+			if switch_child_key.is_none() {
+				if !completed {
+					break depth
+				}
+				if depth == 1 {
+					break 0
+				} else {
+					start_at = child_key.take().map(|entry| entry.0);
+				}
+			} else {
+				child_key = switch_child_key;
+				start_at = None;
+			}
+		};
+		Ok((KeyValueStates(result), completed))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::{backend::AsTrieBackend, ext::Ext, *};
+	use crate::{execution::CallResult, in_memory_backend::new_in_mem};
+	use assert_matches::assert_matches;
+	use codec::Encode;
+	use sp_core::{
+		map,
+		storage::{ChildInfo, StateVersion},
+		traits::{CallContext, CodeExecutor, Externalities, RuntimeCode},
+		H256,
+	};
+	use sp_runtime::traits::BlakeTwo256;
+	use sp_trie::{
+		trie_types::{TrieDBMutBuilderV0, TrieDBMutBuilderV1},
+		KeySpacedDBMut, PrefixedMemoryDB,
+	};
+	use std::collections::{BTreeMap, HashMap};
+
+	#[derive(Clone)]
+	struct DummyCodeExecutor {
+		native_available: bool,
+		native_succeeds: bool,
+		fallback_succeeds: bool,
+	}
+
+	impl CodeExecutor for DummyCodeExecutor {
+		type Error = u8;
+
+		fn call(
+			&self,
+			ext: &mut dyn Externalities,
+			_: &RuntimeCode,
+			_method: &str,
+			_data: &[u8],
+			use_native: bool,
+			_: CallContext,
+		) -> (CallResult<Self::Error>, bool) {
+			let using_native = use_native && self.native_available;
+			match (using_native, self.native_succeeds, self.fallback_succeeds) {
+				(true, true, _) | (false, _, true) => (
+					Ok(vec![
+						ext.storage(b"value1").unwrap()[0] + ext.storage(b"value2").unwrap()[0],
+					]),
+					using_native,
+				),
+				_ => (Err(0), using_native),
+			}
+		}
+	}
+
+	impl sp_core::traits::ReadRuntimeVersion for DummyCodeExecutor {
+		fn read_runtime_version(
+			&self,
+			_: &[u8],
+			_: &mut dyn Externalities,
+		) -> std::result::Result<Vec<u8>, String> {
+			unimplemented!("Not required in tests.")
+		}
+	}
+
+	#[test]
+	fn execute_works() {
+		execute_works_inner(StateVersion::V0);
+		execute_works_inner(StateVersion::V1);
+	}
+	fn execute_works_inner(state_version: StateVersion) {
+		let backend = trie_backend::tests::test_trie(state_version, None, None);
+		let mut overlayed_changes = Default::default();
+		let wasm_code = RuntimeCode::empty();
+		let mut execution_extensions = &mut Default::default();
+
+		let mut state_machine = StateMachine::new(
+			&backend,
+			&mut overlayed_changes,
+			&DummyCodeExecutor {
+				native_available: true,
+				native_succeeds: true,
+				fallback_succeeds: true,
+			},
+			"test",
+			&[],
+			&mut execution_extensions,
+			&wasm_code,
+			CallContext::Offchain,
+		);
+
+		assert_eq!(state_machine.execute().unwrap(), vec![66]);
+	}
+
+	#[test]
+	fn execute_works_with_native_else_wasm() {
+		execute_works_with_native_else_wasm_inner(StateVersion::V0);
+		execute_works_with_native_else_wasm_inner(StateVersion::V1);
+	}
+	fn execute_works_with_native_else_wasm_inner(state_version: StateVersion) {
+		let backend = trie_backend::tests::test_trie(state_version, None, None);
+		let mut overlayed_changes = Default::default();
+		let wasm_code = RuntimeCode::empty();
+		let mut execution_extensions = &mut Default::default();
+
+		let mut state_machine = StateMachine::new(
+			&backend,
+			&mut overlayed_changes,
+			&DummyCodeExecutor {
+				native_available: true,
+				native_succeeds: true,
+				fallback_succeeds: true,
+			},
+			"test",
+			&[],
+			&mut execution_extensions,
+			&wasm_code,
+			CallContext::Offchain,
+		);
+
+		assert_eq!(state_machine.execute().unwrap(), vec![66]);
+	}
+
+	#[test]
+	fn prove_execution_and_proof_check_works() {
+		prove_execution_and_proof_check_works_inner(StateVersion::V0);
+		prove_execution_and_proof_check_works_inner(StateVersion::V1);
+	}
+	fn prove_execution_and_proof_check_works_inner(state_version: StateVersion) {
+		let executor = DummyCodeExecutor {
+			native_available: true,
+			native_succeeds: true,
+			fallback_succeeds: true,
+		};
+
+		// fetch execution proof from 'remote' full node
+		let mut remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let remote_root = remote_backend.storage_root(std::iter::empty(), state_version).0;
+		let (remote_result, remote_proof) = prove_execution(
+			&mut remote_backend,
+			&mut Default::default(),
+			&executor,
+			"test",
+			&[],
+			&RuntimeCode::empty(),
+		)
+		.unwrap();
+
+		// check proof locally
+		let local_result = execution_proof_check::<BlakeTwo256, _>(
+			remote_root,
+			remote_proof,
+			&mut Default::default(),
+			&executor,
+			"test",
+			&[],
+			&RuntimeCode::empty(),
+		)
+		.unwrap();
+
+		// check that both results are correct
+		assert_eq!(remote_result, vec![66]);
+		assert_eq!(remote_result, local_result);
+	}
+
+	#[test]
+	fn clear_prefix_in_ext_works() {
+		let initial: BTreeMap<_, _> = map![
+			b"aaa".to_vec() => b"0".to_vec(),
+			b"abb".to_vec() => b"1".to_vec(),
+			b"abc".to_vec() => b"2".to_vec(),
+			b"bbb".to_vec() => b"3".to_vec()
+		];
+		let state = InMemoryBackend::<BlakeTwo256>::from((initial, StateVersion::default()));
+		let backend = state.as_trie_backend();
+
+		let mut overlay = OverlayedChanges::default();
+		overlay.set_storage(b"aba".to_vec(), Some(b"1312".to_vec()));
+		overlay.set_storage(b"bab".to_vec(), Some(b"228".to_vec()));
+		overlay.start_transaction();
+		overlay.set_storage(b"abd".to_vec(), Some(b"69".to_vec()));
+		overlay.set_storage(b"bbd".to_vec(), Some(b"42".to_vec()));
+
+		let overlay_limit = overlay.clone();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			let _ = ext.clear_prefix(b"ab", None, None);
+		}
+		overlay.commit_transaction().unwrap();
+
+		assert_eq!(
+			overlay
+				.changes()
+				.map(|(k, v)| (k.clone(), v.value().cloned()))
+				.collect::<HashMap<_, _>>(),
+			map![
+				b"abc".to_vec() => None,
+				b"abb".to_vec() => None,
+				b"aba".to_vec() => None,
+				b"abd".to_vec() => None,
+
+				b"bab".to_vec() => Some(b"228".to_vec()),
+				b"bbd".to_vec() => Some(b"42".to_vec())
+			],
+		);
+
+		let mut overlay = overlay_limit;
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			assert_matches!(
+				ext.clear_prefix(b"ab", Some(1), None).deconstruct(),
+				(Some(_), 1, 3, 1)
+			);
+		}
+		overlay.commit_transaction().unwrap();
+
+		assert_eq!(
+			overlay
+				.changes()
+				.map(|(k, v)| (k.clone(), v.value().cloned()))
+				.collect::<HashMap<_, _>>(),
+			map![
+				b"abb".to_vec() => None,
+				b"aba".to_vec() => None,
+				b"abd".to_vec() => None,
+
+				b"bab".to_vec() => Some(b"228".to_vec()),
+				b"bbd".to_vec() => Some(b"42".to_vec())
+			],
+		);
+	}
+
+	#[test]
+	fn limited_child_kill_works() {
+		let child_info = ChildInfo::new_default(b"sub1");
+		let initial: HashMap<_, BTreeMap<_, _>> = map![
+			Some(child_info.clone()) => map![
+				b"a".to_vec() => b"0".to_vec(),
+				b"b".to_vec() => b"1".to_vec(),
+				b"c".to_vec() => b"2".to_vec(),
+				b"d".to_vec() => b"3".to_vec()
+			],
+		];
+		let backend = InMemoryBackend::<BlakeTwo256>::from((initial, StateVersion::default()));
+
+		let mut overlay = OverlayedChanges::default();
+		overlay.set_child_storage(&child_info, b"1".to_vec(), Some(b"1312".to_vec()));
+		overlay.set_child_storage(&child_info, b"2".to_vec(), Some(b"1312".to_vec()));
+		overlay.set_child_storage(&child_info, b"3".to_vec(), Some(b"1312".to_vec()));
+		overlay.set_child_storage(&child_info, b"4".to_vec(), Some(b"1312".to_vec()));
+
+		{
+			let mut ext = Ext::new(&mut overlay, &backend, None);
+			let r = ext.kill_child_storage(&child_info, Some(2), None);
+			assert_matches!(r.deconstruct(), (Some(_), 2, 6, 2));
+		}
+
+		assert_eq!(
+			overlay
+				.children()
+				.flat_map(|(iter, _child_info)| iter)
+				.map(|(k, v)| (k.clone(), v.value()))
+				.collect::<BTreeMap<_, _>>(),
+			map![
+				b"1".to_vec() => None,
+				b"2".to_vec() => None,
+				b"3".to_vec() => None,
+				b"4".to_vec() => None,
+				b"a".to_vec() => None,
+				b"b".to_vec() => None,
+			],
+		);
+	}
+
+	#[test]
+	fn limited_child_kill_off_by_one_works() {
+		let child_info = ChildInfo::new_default(b"sub1");
+		let initial: HashMap<_, BTreeMap<_, _>> = map![
+			Some(child_info.clone()) => map![
+				b"a".to_vec() => b"0".to_vec(),
+				b"b".to_vec() => b"1".to_vec(),
+				b"c".to_vec() => b"2".to_vec(),
+				b"d".to_vec() => b"3".to_vec()
+			],
+		];
+		let backend = InMemoryBackend::<BlakeTwo256>::from((initial, StateVersion::default()));
+		let mut overlay = OverlayedChanges::default();
+		let mut ext = Ext::new(&mut overlay, &backend, None);
+		let r = ext.kill_child_storage(&child_info, Some(0), None).deconstruct();
+		assert_matches!(r, (Some(_), 0, 0, 0));
+		let r = ext
+			.kill_child_storage(&child_info, Some(1), r.0.as_ref().map(|x| &x[..]))
+			.deconstruct();
+		assert_matches!(r, (Some(_), 1, 1, 1));
+		let r = ext
+			.kill_child_storage(&child_info, Some(4), r.0.as_ref().map(|x| &x[..]))
+			.deconstruct();
+		// Only 3 items remaining to remove
+		assert_matches!(r, (None, 3, 3, 3));
+		let r = ext.kill_child_storage(&child_info, Some(1), None).deconstruct();
+		assert_matches!(r, (Some(_), 0, 0, 1));
+	}
+
+	#[test]
+	fn limited_child_kill_off_by_one_works_without_limit() {
+		let child_info = ChildInfo::new_default(b"sub1");
+		let initial: HashMap<_, BTreeMap<_, _>> = map![
+			Some(child_info.clone()) => map![
+				b"a".to_vec() => b"0".to_vec(),
+				b"b".to_vec() => b"1".to_vec(),
+				b"c".to_vec() => b"2".to_vec(),
+				b"d".to_vec() => b"3".to_vec()
+			],
+		];
+		let backend = InMemoryBackend::<BlakeTwo256>::from((initial, StateVersion::default()));
+		let mut overlay = OverlayedChanges::default();
+		let mut ext = Ext::new(&mut overlay, &backend, None);
+		assert_eq!(ext.kill_child_storage(&child_info, None, None).deconstruct(), (None, 4, 4, 4));
+	}
+
+	#[test]
+	fn set_child_storage_works() {
+		let child_info = ChildInfo::new_default(b"sub1");
+		let child_info = &child_info;
+		let state = new_in_mem::<BlakeTwo256>();
+		let backend = state.as_trie_backend();
+		let mut overlay = OverlayedChanges::default();
+		let mut ext = Ext::new(&mut overlay, backend, None);
+
+		ext.set_child_storage(child_info, b"abc".to_vec(), b"def".to_vec());
+		assert_eq!(ext.child_storage(child_info, b"abc"), Some(b"def".to_vec()));
+		let _ = ext.kill_child_storage(child_info, None, None);
+		assert_eq!(ext.child_storage(child_info, b"abc"), None);
+	}
+
+	#[test]
+	fn append_storage_works() {
+		let reference_data = vec![b"data1".to_vec(), b"2".to_vec(), b"D3".to_vec(), b"d4".to_vec()];
+		let key = b"key".to_vec();
+		let state = new_in_mem::<BlakeTwo256>();
+		let backend = state.as_trie_backend();
+		let mut overlay = OverlayedChanges::default();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+
+			ext.storage_append(key.clone(), reference_data[0].encode());
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![reference_data[0].clone()].encode()));
+		}
+		overlay.start_transaction();
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+
+			for i in reference_data.iter().skip(1) {
+				ext.storage_append(key.clone(), i.encode());
+			}
+			assert_eq!(ext.storage(key.as_slice()), Some(reference_data.encode()));
+		}
+		overlay.rollback_transaction().unwrap();
+		{
+			let ext = Ext::new(&mut overlay, backend, None);
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![reference_data[0].clone()].encode()));
+		}
+	}
+
+	#[test]
+	fn remove_with_append_then_rollback_appended_then_append_again() {
+		#[derive(codec::Encode, codec::Decode)]
+		enum Item {
+			InitializationItem,
+			DiscardedItem,
+			CommitedItem,
+		}
+
+		let key = b"events".to_vec();
+		let state = new_in_mem::<BlakeTwo256>();
+		let backend = state.as_trie_backend();
+		let mut overlay = OverlayedChanges::default();
+
+		// For example, block initialization with event.
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			ext.clear_storage(key.as_slice());
+			ext.storage_append(key.clone(), Item::InitializationItem.encode());
+		}
+		overlay.start_transaction();
+
+		// For example, first transaction resulted in panic during block building
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::InitializationItem].encode()));
+
+			ext.storage_append(key.clone(), Item::DiscardedItem.encode());
+
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem, Item::DiscardedItem].encode()),
+			);
+		}
+		overlay.rollback_transaction().unwrap();
+
+		// Then we apply next transaction which is valid this time.
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+
+			assert_eq!(ext.storage(key.as_slice()), Some(vec![Item::InitializationItem].encode()));
+
+			ext.storage_append(key.clone(), Item::CommitedItem.encode());
+
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem, Item::CommitedItem].encode()),
+			);
+		}
+		overlay.start_transaction();
+
+		// Then only initlaization item and second (committed) item should persist.
+		{
+			let ext = Ext::new(&mut overlay, backend, None);
+			assert_eq!(
+				ext.storage(key.as_slice()),
+				Some(vec![Item::InitializationItem, Item::CommitedItem].encode()),
+			);
+		}
+	}
+
+	fn test_compact(remote_proof: StorageProof, remote_root: &sp_core::H256) -> StorageProof {
+		let compact_remote_proof =
+			remote_proof.into_compact_proof::<BlakeTwo256>(*remote_root).unwrap();
+		compact_remote_proof
+			.to_storage_proof::<BlakeTwo256>(Some(remote_root))
+			.unwrap()
+			.0
+	}
+
+	#[test]
+	fn prove_read_and_proof_check_works() {
+		prove_read_and_proof_check_works_inner(StateVersion::V0);
+		prove_read_and_proof_check_works_inner(StateVersion::V1);
+	}
+	fn prove_read_and_proof_check_works_inner(state_version: StateVersion) {
+		let child_info = ChildInfo::new_default(b"sub1");
+		let missing_child_info = ChildInfo::new_default(b"sub1sub2"); // key will include other child root to proof.
+		let child_info = &child_info;
+		let missing_child_info = &missing_child_info;
+		// fetch read proof from 'remote' full node
+		let remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let remote_root = remote_backend.storage_root(std::iter::empty(), state_version).0;
+		let remote_proof = prove_read(remote_backend, &[b"value2"]).unwrap();
+		let remote_proof = test_compact(remote_proof, &remote_root);
+		// check proof locally
+		let local_result1 =
+			read_proof_check::<BlakeTwo256, _>(remote_root, remote_proof.clone(), &[b"value2"])
+				.unwrap();
+		let local_result2 =
+			read_proof_check::<BlakeTwo256, _>(remote_root, remote_proof, &[&[0xff]]).is_ok();
+		// check that results are correct
+		assert_eq!(
+			local_result1.into_iter().collect::<Vec<_>>(),
+			vec![(b"value2".to_vec(), Some(vec![24]))],
+		);
+		assert_eq!(local_result2, false);
+		// on child trie
+		let remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let remote_root = remote_backend.storage_root(std::iter::empty(), state_version).0;
+		let remote_proof = prove_child_read(remote_backend, child_info, &[b"value3"]).unwrap();
+		let remote_proof = test_compact(remote_proof, &remote_root);
+		let local_result1 = read_child_proof_check::<BlakeTwo256, _>(
+			remote_root,
+			remote_proof.clone(),
+			child_info,
+			&[b"value3"],
+		)
+		.unwrap();
+		let local_result2 = read_child_proof_check::<BlakeTwo256, _>(
+			remote_root,
+			remote_proof.clone(),
+			child_info,
+			&[b"value2"],
+		)
+		.unwrap();
+		let local_result3 = read_child_proof_check::<BlakeTwo256, _>(
+			remote_root,
+			remote_proof,
+			missing_child_info,
+			&[b"dummy"],
+		)
+		.unwrap();
+
+		assert_eq!(
+			local_result1.into_iter().collect::<Vec<_>>(),
+			vec![(b"value3".to_vec(), Some(vec![142; 33]))],
+		);
+		assert_eq!(local_result2.into_iter().collect::<Vec<_>>(), vec![(b"value2".to_vec(), None)]);
+		assert_eq!(local_result3.into_iter().collect::<Vec<_>>(), vec![(b"dummy".to_vec(), None)]);
+	}
+
+	#[test]
+	fn child_read_compact_stress_test() {
+		use rand::{rngs::SmallRng, RngCore, SeedableRng};
+		let mut storage: HashMap<Option<ChildInfo>, BTreeMap<StorageKey, StorageValue>> =
+			Default::default();
+		let mut seed = [0; 32];
+		for i in 0..50u32 {
+			let mut child_infos = Vec::new();
+			let seed_partial = &mut seed[0..4];
+			seed_partial.copy_from_slice(&i.to_be_bytes()[..]);
+			let mut rand = SmallRng::from_seed(seed);
+
+			let nb_child_trie = rand.next_u32() as usize % 25;
+			for _ in 0..nb_child_trie {
+				let key_len = 1 + (rand.next_u32() % 10);
+				let mut key = vec![0; key_len as usize];
+				rand.fill_bytes(&mut key[..]);
+				let child_info = ChildInfo::new_default(key.as_slice());
+				let nb_item = 1 + rand.next_u32() % 25;
+				let mut items = BTreeMap::new();
+				for item in 0..nb_item {
+					let key_len = 1 + (rand.next_u32() % 10);
+					let mut key = vec![0; key_len as usize];
+					rand.fill_bytes(&mut key[..]);
+					let value = vec![item as u8; item as usize + 28];
+					items.insert(key, value);
+				}
+				child_infos.push(child_info.clone());
+				storage.insert(Some(child_info), items);
+			}
+
+			let trie: InMemoryBackend<BlakeTwo256> =
+				(storage.clone(), StateVersion::default()).into();
+			let trie_root = *trie.root();
+			let backend = TrieBackendBuilder::wrap(&trie).with_recorder(Default::default()).build();
+			let mut queries = Vec::new();
+			for c in 0..(5 + nb_child_trie / 2) {
+				// random existing query
+				let child_info = if c < 5 {
+					// 4 missing child trie
+					let key_len = 1 + (rand.next_u32() % 10);
+					let mut key = vec![0; key_len as usize];
+					rand.fill_bytes(&mut key[..]);
+					ChildInfo::new_default(key.as_slice())
+				} else {
+					child_infos[rand.next_u32() as usize % nb_child_trie].clone()
+				};
+
+				if let Some(values) = storage.get(&Some(child_info.clone())) {
+					for _ in 0..(1 + values.len() / 2) {
+						let ix = rand.next_u32() as usize % values.len();
+						for (i, (key, value)) in values.iter().enumerate() {
+							if i == ix {
+								assert_eq!(
+									&backend
+										.child_storage(&child_info, key.as_slice())
+										.unwrap()
+										.unwrap(),
+									value
+								);
+								queries.push((
+									child_info.clone(),
+									key.clone(),
+									Some(value.clone()),
+								));
+								break
+							}
+						}
+					}
+				}
+				for _ in 0..4 {
+					let key_len = 1 + (rand.next_u32() % 10);
+					let mut key = vec![0; key_len as usize];
+					rand.fill_bytes(&mut key[..]);
+					let result = backend.child_storage(&child_info, key.as_slice()).unwrap();
+					queries.push((child_info.clone(), key, result));
+				}
+			}
+
+			let storage_proof = backend.extract_proof().expect("Failed to extract proof");
+			let remote_proof = test_compact(storage_proof, &trie_root);
+			let proof_check =
+				create_proof_check_backend::<BlakeTwo256>(trie_root, remote_proof).unwrap();
+
+			for (child_info, key, expected) in queries {
+				assert_eq!(
+					proof_check.child_storage(&child_info, key.as_slice()).unwrap(),
+					expected,
+				);
+			}
+		}
+	}
+
+	#[test]
+	fn prove_read_with_size_limit_works() {
+		let state_version = StateVersion::V0;
+		let remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let remote_root = remote_backend.storage_root(::std::iter::empty(), state_version).0;
+		let (proof, count) =
+			prove_range_read_with_size(remote_backend, None, None, 0, None).unwrap();
+		// Always contains at least some nodes.
+		assert_eq!(proof.to_memory_db::<BlakeTwo256>().drain().len(), 3);
+		assert_eq!(count, 1);
+		assert_eq!(proof.encoded_size(), 443);
+
+		let remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let (proof, count) =
+			prove_range_read_with_size(remote_backend, None, None, 800, Some(&[])).unwrap();
+		assert_eq!(proof.to_memory_db::<BlakeTwo256>().drain().len(), 9);
+		assert_eq!(count, 85);
+		assert_eq!(proof.encoded_size(), 857);
+		let (results, completed) = read_range_proof_check::<BlakeTwo256>(
+			remote_root,
+			proof.clone(),
+			None,
+			None,
+			Some(count),
+			None,
+		)
+		.unwrap();
+		assert_eq!(results.len() as u32, count);
+		assert_eq!(completed, false);
+		// When checking without count limit, proof may actually contain extra values.
+		let (results, completed) =
+			read_range_proof_check::<BlakeTwo256>(remote_root, proof, None, None, None, None)
+				.unwrap();
+		assert_eq!(results.len() as u32, 101);
+		assert_eq!(completed, false);
+
+		let remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let (proof, count) =
+			prove_range_read_with_size(remote_backend, None, None, 50000, Some(&[])).unwrap();
+		assert_eq!(proof.to_memory_db::<BlakeTwo256>().drain().len(), 11);
+		assert_eq!(count, 132);
+		assert_eq!(proof.encoded_size(), 990);
+
+		let (results, completed) =
+			read_range_proof_check::<BlakeTwo256>(remote_root, proof, None, None, None, None)
+				.unwrap();
+		assert_eq!(results.len() as u32, count);
+		assert_eq!(completed, true);
+	}
+
+	#[test]
+	fn prove_read_with_size_limit_proof_size() {
+		let mut root = H256::default();
+		let mut mdb = PrefixedMemoryDB::<BlakeTwo256>::default();
+		{
+			let mut mdb = KeySpacedDBMut::new(&mut mdb, b"");
+			let mut trie = TrieDBMutBuilderV1::new(&mut mdb, &mut root).build();
+			trie.insert(b"value1", &[123; 1]).unwrap();
+			trie.insert(b"value2", &[123; 10]).unwrap();
+			trie.insert(b"value3", &[123; 100]).unwrap();
+			trie.insert(b"value4", &[123; 1000]).unwrap();
+		}
+
+		let remote_backend: TrieBackend<PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256> =
+			TrieBackendBuilder::new(mdb, root)
+				.with_optional_cache(None)
+				.with_optional_recorder(None)
+				.build();
+
+		let (proof, count) =
+			prove_range_read_with_size(remote_backend, None, None, 1000, None).unwrap();
+
+		assert_eq!(proof.encoded_size(), 1267);
+		assert_eq!(count, 3);
+	}
+
+	#[test]
+	fn inner_state_versioning_switch_proofs() {
+		let mut state_version = StateVersion::V0;
+		let (mut mdb, mut root) = trie_backend::tests::test_db(state_version);
+		{
+			let mut trie = TrieDBMutBuilderV0::from_existing(&mut mdb, &mut root).build();
+			trie.insert(b"foo", vec![1u8; 1_000].as_slice()) // big inner hash
+				.expect("insert failed");
+			trie.insert(b"foo2", vec![3u8; 16].as_slice()) // no inner hash
+				.expect("insert failed");
+			trie.insert(b"foo222", vec![5u8; 100].as_slice()) // inner hash
+				.expect("insert failed");
+		}
+
+		let check_proof = |mdb, root, state_version| -> StorageProof {
+			let remote_backend = TrieBackendBuilder::new(mdb, root).build();
+			let remote_root = remote_backend.storage_root(std::iter::empty(), state_version).0;
+			let remote_proof = prove_read(remote_backend, &[b"foo222"]).unwrap();
+			// check proof locally
+			let local_result1 =
+				read_proof_check::<BlakeTwo256, _>(remote_root, remote_proof.clone(), &[b"foo222"])
+					.unwrap();
+			// check that results are correct
+			assert_eq!(
+				local_result1.into_iter().collect::<Vec<_>>(),
+				vec![(b"foo222".to_vec(), Some(vec![5u8; 100]))],
+			);
+			remote_proof
+		};
+
+		let remote_proof = check_proof(mdb.clone(), root, state_version);
+		// check full values in proof
+		assert!(remote_proof.encode().len() > 1_100);
+		assert!(remote_proof.encoded_size() > 1_100);
+		let root1 = root;
+
+		// do switch
+		state_version = StateVersion::V1;
+		{
+			let mut trie = TrieDBMutBuilderV1::from_existing(&mut mdb, &mut root).build();
+			trie.insert(b"foo222", vec![5u8; 100].as_slice()) // inner hash
+				.expect("insert failed");
+			// update with same value do change
+			trie.insert(b"foo", vec![1u8; 1000].as_slice()) // inner hash
+				.expect("insert failed");
+		}
+		let root3 = root;
+		assert!(root1 != root3);
+		let remote_proof = check_proof(mdb.clone(), root, state_version);
+		// nodes foo is replaced by its hashed value form.
+		assert!(remote_proof.encode().len() < 1000);
+		assert!(remote_proof.encoded_size() < 1000);
+		assert_eq!(remote_proof.encode().len(), remote_proof.encoded_size());
+	}
+
+	#[test]
+	fn prove_range_with_child_works() {
+		let state_version = StateVersion::V0;
+		let remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let remote_root = remote_backend.storage_root(std::iter::empty(), state_version).0;
+		let mut start_at = smallvec::SmallVec::<[Vec<u8>; 2]>::new();
+		let trie_backend = remote_backend.as_trie_backend();
+		let max_iter = 1000;
+		let mut nb_loop = 0;
+		loop {
+			nb_loop += 1;
+			if max_iter == nb_loop {
+				panic!("Too many loop in prove range");
+			}
+			let (proof, count) = prove_range_read_with_child_with_size_on_trie_backend(
+				trie_backend,
+				1,
+				start_at.as_slice(),
+			)
+			.unwrap();
+			// Always contains at least some nodes.
+			assert!(proof.to_memory_db::<BlakeTwo256>().drain().len() > 0);
+			assert!(count < 3); // when doing child we include parent and first child key.
+
+			let (result, completed_depth) = read_range_proof_check_with_child::<BlakeTwo256>(
+				remote_root,
+				proof.clone(),
+				start_at.as_slice(),
+			)
+			.unwrap();
+
+			if completed_depth == 0 {
+				break
+			}
+			assert!(result.update_last_key(completed_depth, &mut start_at));
+		}
+
+		assert_eq!(nb_loop, 10);
+	}
+
+	#[test]
+	fn compact_multiple_child_trie() {
+		let size_no_inner_hash = compact_multiple_child_trie_inner(StateVersion::V0);
+		let size_inner_hash = compact_multiple_child_trie_inner(StateVersion::V1);
+		assert!(size_inner_hash < size_no_inner_hash);
+	}
+	fn compact_multiple_child_trie_inner(state_version: StateVersion) -> usize {
+		// this root will be queried
+		let child_info1 = ChildInfo::new_default(b"sub1");
+		// this root will not be include in proof
+		let child_info2 = ChildInfo::new_default(b"sub2");
+		// this root will be include in proof
+		let child_info3 = ChildInfo::new_default(b"sub");
+		let remote_backend = trie_backend::tests::test_trie(state_version, None, None);
+		let long_vec: Vec<u8> = (0..1024usize).map(|_| 8u8).collect();
+		let (remote_root, transaction) = remote_backend.full_storage_root(
+			std::iter::empty(),
+			vec![
+				(
+					&child_info1,
+					vec![
+						// a inner hashable node
+						(&b"k"[..], Some(&long_vec[..])),
+						// need to ensure this is not an inline node
+						// otherwhise we do not know what is accessed when
+						// storing proof.
+						(&b"key1"[..], Some(&vec![5u8; 32][..])),
+						(&b"key2"[..], Some(&b"val3"[..])),
+					]
+					.into_iter(),
+				),
+				(
+					&child_info2,
+					vec![(&b"key3"[..], Some(&b"val4"[..])), (&b"key4"[..], Some(&b"val5"[..]))]
+						.into_iter(),
+				),
+				(
+					&child_info3,
+					vec![(&b"key5"[..], Some(&b"val6"[..])), (&b"key6"[..], Some(&b"val7"[..]))]
+						.into_iter(),
+				),
+			]
+			.into_iter(),
+			state_version,
+		);
+		let mut remote_storage = remote_backend.backend_storage().clone();
+		remote_storage.consolidate(transaction);
+		let remote_backend = TrieBackendBuilder::new(remote_storage, remote_root).build();
+		let remote_proof = prove_child_read(remote_backend, &child_info1, &[b"key1"]).unwrap();
+		let size = remote_proof.encoded_size();
+		let remote_proof = test_compact(remote_proof, &remote_root);
+		let local_result1 = read_child_proof_check::<BlakeTwo256, _>(
+			remote_root,
+			remote_proof,
+			&child_info1,
+			&[b"key1"],
+		)
+		.unwrap();
+		assert_eq!(local_result1.len(), 1);
+		assert_eq!(local_result1.get(&b"key1"[..]), Some(&Some(vec![5u8; 32])));
+		size
+	}
+
+	#[test]
+	fn child_storage_uuid() {
+		let state_version = StateVersion::V0;
+		let child_info_1 = ChildInfo::new_default(b"sub_test1");
+		let child_info_2 = ChildInfo::new_default(b"sub_test2");
+
+		use crate::trie_backend::tests::test_trie;
+		let mut overlay = OverlayedChanges::default();
+
+		let mut transaction = {
+			let backend = test_trie(state_version, None, None);
+			let mut ext = Ext::new(&mut overlay, &backend, None);
+			ext.set_child_storage(&child_info_1, b"abc".to_vec(), b"def".to_vec());
+			ext.set_child_storage(&child_info_2, b"abc".to_vec(), b"def".to_vec());
+			ext.storage_root(state_version);
+			overlay.drain_storage_changes(&backend, state_version).unwrap().transaction
+		};
+		let mut duplicate = false;
+		for (k, (value, rc)) in transaction.drain().iter() {
+			// look for a key inserted twice: transaction rc is 2
+			if *rc == 2 {
+				duplicate = true;
+				println!("test duplicate for {:?} {:?}", k, value);
+			}
+		}
+		assert!(!duplicate);
+	}
+
+	#[test]
+	fn set_storage_empty_allowed() {
+		let initial: BTreeMap<_, _> = map![
+			b"aaa".to_vec() => b"0".to_vec(),
+			b"bbb".to_vec() => b"".to_vec()
+		];
+		let state = InMemoryBackend::<BlakeTwo256>::from((initial, StateVersion::default()));
+		let backend = state.as_trie_backend();
+
+		let mut overlay = OverlayedChanges::default();
+		overlay.start_transaction();
+		overlay.set_storage(b"ccc".to_vec(), Some(b"".to_vec()));
+		assert_eq!(overlay.storage(b"ccc"), Some(Some(&[][..])));
+		overlay.commit_transaction().unwrap();
+		overlay.start_transaction();
+		assert_eq!(overlay.storage(b"ccc"), Some(Some(&[][..])));
+		assert_eq!(overlay.storage(b"bbb"), None);
+
+		{
+			let mut ext = Ext::new(&mut overlay, backend, None);
+			assert_eq!(ext.storage(b"bbb"), Some(vec![]));
+			assert_eq!(ext.storage(b"ccc"), Some(vec![]));
+			ext.clear_storage(b"ccc");
+			assert_eq!(ext.storage(b"ccc"), None);
+		}
+		overlay.commit_transaction().unwrap();
+		assert_eq!(overlay.storage(b"ccc"), Some(None));
+	}
+}
diff --git a/substrate/primitives/state-machine/src/overlayed_changes/changeset.rs b/substrate/primitives/state-machine/src/overlayed_changes/changeset.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8f2d02fd6840eb33735eb15bcd5c57f8776e6f5c
--- /dev/null
+++ b/substrate/primitives/state-machine/src/overlayed_changes/changeset.rs
@@ -0,0 +1,855 @@
+// 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
+
+//! Houses the code that implements the transactional overlay storage.
+
+use super::{Extrinsics, StorageKey, StorageValue};
+
+#[cfg(not(feature = "std"))]
+use sp_std::collections::btree_set::BTreeSet as Set;
+#[cfg(feature = "std")]
+use std::collections::HashSet as Set;
+
+use crate::warn;
+use smallvec::SmallVec;
+use sp_std::{
+	collections::{btree_map::BTreeMap, btree_set::BTreeSet},
+	hash::Hash,
+};
+
+const PROOF_OVERLAY_NON_EMPTY: &str = "\
+	An OverlayValue is always created with at least one transaction and dropped as soon
+	as the last transaction is removed; qed";
+
+type DirtyKeysSets<K> = SmallVec<[Set<K>; 5]>;
+type Transactions<V> = SmallVec<[InnerValue<V>; 5]>;
+
+/// Error returned when trying to commit or rollback while no transaction is open or
+/// when the runtime is trying to close a transaction started by the client.
+#[derive(Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct NoOpenTransaction;
+
+/// Error when calling `enter_runtime` when already being in runtime execution mode.
+#[derive(Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct AlreadyInRuntime;
+
+/// Error when calling `exit_runtime` when not being in runtime exection mdde.
+#[derive(Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct NotInRuntime;
+
+/// Describes in which mode the node is currently executing.
+#[derive(Debug, Clone, Copy)]
+pub enum ExecutionMode {
+	/// Executing in client mode: Removal of all transactions possible.
+	Client,
+	/// Executing in runtime mode: Transactions started by the client are protected.
+	Runtime,
+}
+
+#[derive(Debug, Default, Clone)]
+#[cfg_attr(test, derive(PartialEq))]
+struct InnerValue<V> {
+	/// Current value. None if value has been deleted.
+	value: V,
+	/// The set of extrinsic indices where the values has been changed.
+	extrinsics: Extrinsics,
+}
+
+/// An overlay that contains all versions of a value for a specific key.
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct OverlayedEntry<V> {
+	/// The individual versions of that value.
+	/// One entry per transactions during that the value was actually written.
+	transactions: Transactions<V>,
+}
+
+impl<V> Default for OverlayedEntry<V> {
+	fn default() -> Self {
+		Self { transactions: SmallVec::new() }
+	}
+}
+
+/// History of value, with removal support.
+pub type OverlayedValue = OverlayedEntry<Option<StorageValue>>;
+
+/// Change set for basic key value with extrinsics index recording and removal support.
+pub type OverlayedChangeSet = OverlayedMap<StorageKey, Option<StorageValue>>;
+
+/// Holds a set of changes with the ability modify them using nested transactions.
+#[derive(Debug, Clone)]
+pub struct OverlayedMap<K, V> {
+	/// Stores the changes that this overlay constitutes.
+	changes: BTreeMap<K, OverlayedEntry<V>>,
+	/// Stores which keys are dirty per transaction. Needed in order to determine which
+	/// values to merge into the parent transaction on commit. The length of this vector
+	/// therefore determines how many nested transactions are currently open (depth).
+	dirty_keys: DirtyKeysSets<K>,
+	/// The number of how many transactions beginning from the first transactions are started
+	/// by the client. Those transactions are protected against close (commit, rollback)
+	/// when in runtime mode.
+	num_client_transactions: usize,
+	/// Determines whether the node is using the overlay from the client or the runtime.
+	execution_mode: ExecutionMode,
+}
+
+impl<K, V> Default for OverlayedMap<K, V> {
+	fn default() -> Self {
+		Self {
+			changes: BTreeMap::new(),
+			dirty_keys: SmallVec::new(),
+			num_client_transactions: Default::default(),
+			execution_mode: Default::default(),
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+impl From<sp_core::storage::StorageMap> for OverlayedMap<StorageKey, Option<StorageValue>> {
+	fn from(storage: sp_core::storage::StorageMap) -> Self {
+		Self {
+			changes: storage
+				.into_iter()
+				.map(|(k, v)| {
+					(
+						k,
+						OverlayedEntry {
+							transactions: SmallVec::from_iter([InnerValue {
+								value: Some(v),
+								extrinsics: Default::default(),
+							}]),
+						},
+					)
+				})
+				.collect(),
+			dirty_keys: Default::default(),
+			num_client_transactions: 0,
+			execution_mode: ExecutionMode::Client,
+		}
+	}
+}
+
+impl Default for ExecutionMode {
+	fn default() -> Self {
+		Self::Client
+	}
+}
+
+impl<V> OverlayedEntry<V> {
+	/// The value as seen by the current transaction.
+	pub fn value_ref(&self) -> &V {
+		&self.transactions.last().expect(PROOF_OVERLAY_NON_EMPTY).value
+	}
+
+	/// The value as seen by the current transaction.
+	pub fn into_value(mut self) -> V {
+		self.transactions.pop().expect(PROOF_OVERLAY_NON_EMPTY).value
+	}
+
+	/// Unique list of extrinsic indices which modified the value.
+	pub fn extrinsics(&self) -> BTreeSet<u32> {
+		let mut set = BTreeSet::new();
+		self.transactions
+			.iter()
+			.for_each(|t| t.extrinsics.copy_extrinsics_into(&mut set));
+		set
+	}
+
+	/// Mutable reference to the most recent version.
+	fn value_mut(&mut self) -> &mut V {
+		&mut self.transactions.last_mut().expect(PROOF_OVERLAY_NON_EMPTY).value
+	}
+
+	/// Remove the last version and return it.
+	fn pop_transaction(&mut self) -> InnerValue<V> {
+		self.transactions.pop().expect(PROOF_OVERLAY_NON_EMPTY)
+	}
+
+	/// Mutable reference to the set which holds the indices for the **current transaction only**.
+	fn transaction_extrinsics_mut(&mut self) -> &mut Extrinsics {
+		&mut self.transactions.last_mut().expect(PROOF_OVERLAY_NON_EMPTY).extrinsics
+	}
+
+	/// 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: 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 {
+			*self.value_mut() = value;
+		}
+
+		if let Some(extrinsic) = at_extrinsic {
+			self.transaction_extrinsics_mut().insert(extrinsic);
+		}
+	}
+}
+
+impl OverlayedEntry<Option<StorageValue>> {
+	/// The value as seen by the current transaction.
+	pub fn value(&self) -> Option<&StorageValue> {
+		self.value_ref().as_ref()
+	}
+}
+
+/// Inserts a key into the dirty set.
+///
+/// Returns true iff we are currently have at least one open transaction and if this
+/// is the first write to the given key that transaction.
+fn insert_dirty<K: Ord + Hash>(set: &mut DirtyKeysSets<K>, key: K) -> bool {
+	set.last_mut().map(|dk| dk.insert(key)).unwrap_or_default()
+}
+
+impl<K: Ord + Hash + Clone, V> OverlayedMap<K, V> {
+	/// Create a new changeset at the same transaction state but without any contents.
+	///
+	/// This changeset might be created when there are already open transactions.
+	/// We need to catch up here so that the child is at the same transaction depth.
+	pub fn spawn_child(&self) -> Self {
+		use sp_std::iter::repeat;
+		Self {
+			changes: Default::default(),
+			dirty_keys: repeat(Set::new()).take(self.transaction_depth()).collect(),
+			num_client_transactions: self.num_client_transactions,
+			execution_mode: self.execution_mode,
+		}
+	}
+
+	/// True if no changes at all are contained in the change set.
+	pub fn is_empty(&self) -> bool {
+		self.changes.is_empty()
+	}
+
+	/// Get an optional reference to the value stored for the specified key.
+	pub fn get<Q>(&self, key: &Q) -> Option<&OverlayedEntry<V>>
+	where
+		K: sp_std::borrow::Borrow<Q>,
+		Q: Ord + ?Sized,
+	{
+		self.changes.get(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>) {
+		let overlayed = self.changes.entry(key.clone()).or_default();
+		overlayed.set(value, insert_dirty(&mut self.dirty_keys, key), at_extrinsic);
+	}
+
+	/// Get a list of all changes as seen by current transaction.
+	pub fn changes(&self) -> impl Iterator<Item = (&K, &OverlayedEntry<V>)> {
+		self.changes.iter()
+	}
+
+	/// 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>)> {
+		self.changes.into_iter()
+	}
+
+	/// Consume this changeset and return all committed changes.
+	///
+	/// Panics:
+	/// Panics if there are open transactions: `transaction_depth() > 0`
+	pub fn drain_commited(self) -> impl Iterator<Item = (K, V)> {
+		assert!(self.transaction_depth() == 0, "Drain is not allowed with open transactions.");
+		self.changes.into_iter().map(|(k, mut v)| (k, v.pop_transaction().value))
+	}
+
+	/// Returns the current nesting depth of the transaction stack.
+	///
+	/// A value of zero means that no transaction is open and changes are committed on write.
+	pub fn transaction_depth(&self) -> usize {
+		self.dirty_keys.len()
+	}
+
+	/// Call this before transfering control to the runtime.
+	///
+	/// This protects all existing transactions from being removed by the runtime.
+	/// Calling this while already inside the runtime will return an error.
+	pub fn enter_runtime(&mut self) -> Result<(), AlreadyInRuntime> {
+		if let ExecutionMode::Runtime = self.execution_mode {
+			return Err(AlreadyInRuntime)
+		}
+		self.execution_mode = ExecutionMode::Runtime;
+		self.num_client_transactions = self.transaction_depth();
+		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 let ExecutionMode::Client = self.execution_mode {
+			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(())
+	}
+
+	/// Start a new nested transaction.
+	///
+	/// This allows to either commit or roll back all changes that were made while this
+	/// transaction was open. Any transaction must be closed by either `commit_transaction`
+	/// or `rollback_transaction` before this overlay can be converted into storage changes.
+	///
+	/// Changes made without any open transaction are committed immediately.
+	pub fn start_transaction(&mut self) {
+		self.dirty_keys.push(Default::default());
+	}
+
+	/// 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 let ExecutionMode::Runtime = self.execution_mode {
+			if !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 {
+				overlayed.pop_transaction();
+
+				// 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 dropped_tx = overlayed.pop_transaction();
+					*overlayed.value_mut() = dropped_tx.value;
+					overlayed.transaction_extrinsics_mut().extend(dropped_tx.extrinsics);
+				}
+			}
+		}
+
+		Ok(())
+	}
+
+	fn has_open_runtime_transactions(&self) -> bool {
+		self.transaction_depth() > self.num_client_transactions
+	}
+}
+
+impl OverlayedChangeSet {
+	/// Get a mutable reference for a value.
+	///
+	/// 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(
+		&mut self,
+		key: StorageKey,
+		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()
+	}
+
+	/// Set all values to deleted which are matched by the predicate.
+	///
+	/// Can be rolled back or committed when called inside a transaction.
+	pub fn clear_where(
+		&mut self,
+		predicate: impl Fn(&[u8], &OverlayedValue) -> bool,
+		at_extrinsic: Option<u32>,
+	) -> 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() {
+				count += 1;
+			}
+			val.set(None, insert_dirty(&mut self.dirty_keys, key.clone()), at_extrinsic);
+		}
+		count
+	}
+
+	/// Get the iterator over all changes that follow the supplied `key`.
+	pub fn changes_after(&self, key: &[u8]) -> impl Iterator<Item = (&[u8], &OverlayedValue)> {
+		use sp_std::ops::Bound;
+		let range = (Bound::Excluded(key), Bound::Unbounded);
+		self.changes.range::<[u8], _>(range).map(|(k, v)| (k.as_slice(), v))
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use pretty_assertions::assert_eq;
+
+	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) {
+		let is: Changes = is
+			.changes()
+			.map(|(k, v)| {
+				(k.as_ref(), (v.value().map(AsRef::as_ref), v.extrinsics().into_iter().collect()))
+			})
+			.collect();
+		assert_eq!(&is, expected);
+	}
+
+	fn assert_drained_changes(is: OverlayedChangeSet, expected: Changes) {
+		let is = is.drain_commited().collect::<Vec<_>>();
+		let expected = expected
+			.iter()
+			.map(|(k, v)| (k.to_vec(), v.0.map(From::from)))
+			.collect::<Vec<_>>();
+		assert_eq!(is, expected);
+	}
+
+	fn assert_drained(is: OverlayedChangeSet, expected: Drained) {
+		let is = is.drain_commited().collect::<Vec<_>>();
+		let expected = expected
+			.iter()
+			.map(|(k, v)| (k.to_vec(), v.map(From::from)))
+			.collect::<Vec<_>>();
+		assert_eq!(is, expected);
+	}
+
+	#[test]
+	fn no_transaction_works() {
+		let mut changeset = OverlayedChangeSet::default();
+		assert_eq!(changeset.transaction_depth(), 0);
+
+		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), Some(1));
+		changeset.set(b"key1".to_vec(), Some(b"val1".to_vec()), Some(2));
+		changeset.set(b"key0".to_vec(), Some(b"val0-1".to_vec()), Some(9));
+
+		assert_drained(changeset, vec![(b"key0", Some(b"val0-1")), (b"key1", Some(b"val1"))]);
+	}
+
+	#[test]
+	fn transaction_works() {
+		let mut changeset = OverlayedChangeSet::default();
+		assert_eq!(changeset.transaction_depth(), 0);
+
+		// no transaction: committed on set
+		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), Some(1));
+		changeset.set(b"key1".to_vec(), Some(b"val1".to_vec()), Some(1));
+		changeset.set(b"key0".to_vec(), Some(b"val0-1".to_vec()), Some(10));
+
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 1);
+
+		// we will commit that later
+		changeset.set(b"key42".to_vec(), Some(b"val42".to_vec()), Some(42));
+		changeset.set(b"key99".to_vec(), Some(b"val99".to_vec()), Some(99));
+
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 2);
+
+		// we will roll that back
+		changeset.set(b"key42".to_vec(), Some(b"val42-rolled".to_vec()), Some(421));
+		changeset.set(b"key7".to_vec(), Some(b"val7-rolled".to_vec()), Some(77));
+		changeset.set(b"key0".to_vec(), Some(b"val0-rolled".to_vec()), Some(1000));
+		changeset.set(b"key5".to_vec(), Some(b"val5-rolled".to_vec()), None);
+
+		// changes contain all changes not only the commmited ones.
+		let all_changes: Changes = vec![
+			(b"key0", (Some(b"val0-rolled"), vec![1, 10, 1000])),
+			(b"key1", (Some(b"val1"), vec![1])),
+			(b"key42", (Some(b"val42-rolled"), vec![42, 421])),
+			(b"key5", (Some(b"val5-rolled"), vec![])),
+			(b"key7", (Some(b"val7-rolled"), vec![77])),
+			(b"key99", (Some(b"val99"), vec![99])),
+		];
+		assert_changes(&changeset, &all_changes);
+
+		// this should be no-op
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 3);
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 4);
+		changeset.rollback_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 3);
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 2);
+		assert_changes(&changeset, &all_changes);
+
+		// roll back our first transactions that actually contains something
+		changeset.rollback_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 1);
+
+		let rolled_back: Changes = vec![
+			(b"key0", (Some(b"val0-1"), vec![1, 10])),
+			(b"key1", (Some(b"val1"), vec![1])),
+			(b"key42", (Some(b"val42"), vec![42])),
+			(b"key99", (Some(b"val99"), vec![99])),
+		];
+		assert_changes(&changeset, &rolled_back);
+
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 0);
+		assert_changes(&changeset, &rolled_back);
+
+		assert_drained_changes(changeset, rolled_back);
+	}
+
+	#[test]
+	fn transaction_commit_then_rollback_works() {
+		let mut changeset = OverlayedChangeSet::default();
+		assert_eq!(changeset.transaction_depth(), 0);
+
+		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), Some(1));
+		changeset.set(b"key1".to_vec(), Some(b"val1".to_vec()), Some(1));
+		changeset.set(b"key0".to_vec(), Some(b"val0-1".to_vec()), Some(10));
+
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 1);
+
+		changeset.set(b"key42".to_vec(), Some(b"val42".to_vec()), Some(42));
+		changeset.set(b"key99".to_vec(), Some(b"val99".to_vec()), Some(99));
+
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 2);
+
+		changeset.set(b"key42".to_vec(), Some(b"val42-rolled".to_vec()), Some(421));
+		changeset.set(b"key7".to_vec(), Some(b"val7-rolled".to_vec()), Some(77));
+		changeset.set(b"key0".to_vec(), Some(b"val0-rolled".to_vec()), Some(1000));
+		changeset.set(b"key5".to_vec(), Some(b"val5-rolled".to_vec()), None);
+
+		let all_changes: Changes = vec![
+			(b"key0", (Some(b"val0-rolled"), vec![1, 10, 1000])),
+			(b"key1", (Some(b"val1"), vec![1])),
+			(b"key42", (Some(b"val42-rolled"), vec![42, 421])),
+			(b"key5", (Some(b"val5-rolled"), vec![])),
+			(b"key7", (Some(b"val7-rolled"), vec![77])),
+			(b"key99", (Some(b"val99"), vec![99])),
+		];
+		assert_changes(&changeset, &all_changes);
+
+		// this should be no-op
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 3);
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 4);
+		changeset.rollback_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 3);
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 2);
+		assert_changes(&changeset, &all_changes);
+
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 1);
+
+		assert_changes(&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_drained_changes(changeset, rolled_back);
+	}
+
+	#[test]
+	fn modify_works() {
+		let mut changeset = OverlayedChangeSet::default();
+		assert_eq!(changeset.transaction_depth(), 0);
+		let init = || b"valinit".to_vec();
+
+		// committed set
+		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), 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");
+
+		changeset.start_transaction();
+		assert_eq!(changeset.transaction_depth(), 1);
+		changeset.start_transaction();
+		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");
+
+		// 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");
+
+		// 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());
+
+		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])),
+		];
+		assert_changes(&changeset, &all_changes);
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 1);
+		assert_changes(&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"key1", (None, vec![1])),
+			(b"key3", (Some(b"valinit-modified"), vec![3])),
+		];
+		assert_changes(&changeset, &rolled_back);
+		assert_drained_changes(changeset, rolled_back);
+	}
+
+	#[test]
+	fn clear_works() {
+		let mut changeset = OverlayedChangeSet::default();
+
+		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), Some(1));
+		changeset.set(b"key1".to_vec(), Some(b"val1".to_vec()), Some(2));
+		changeset.set(b"del1".to_vec(), Some(b"delval1".to_vec()), Some(3));
+		changeset.set(b"del2".to_vec(), Some(b"delval2".to_vec()), Some(4));
+
+		changeset.start_transaction();
+
+		changeset.clear_where(|k, _| k.starts_with(b"del"), Some(5));
+
+		assert_changes(
+			&changeset,
+			&vec![
+				(b"del1", (None, vec![3, 5])),
+				(b"del2", (None, vec![4, 5])),
+				(b"key0", (Some(b"val0"), vec![1])),
+				(b"key1", (Some(b"val1"), vec![2])),
+			],
+		);
+
+		changeset.rollback_transaction().unwrap();
+
+		assert_changes(
+			&changeset,
+			&vec![
+				(b"del1", (Some(b"delval1"), vec![3])),
+				(b"del2", (Some(b"delval2"), vec![4])),
+				(b"key0", (Some(b"val0"), vec![1])),
+				(b"key1", (Some(b"val1"), vec![2])),
+			],
+		);
+	}
+
+	#[test]
+	fn next_change_works() {
+		let mut changeset = OverlayedChangeSet::default();
+
+		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), Some(0));
+		changeset.set(b"key1".to_vec(), Some(b"val1".to_vec()), Some(1));
+		changeset.set(b"key2".to_vec(), Some(b"val2".to_vec()), Some(2));
+
+		changeset.start_transaction();
+
+		changeset.set(b"key3".to_vec(), Some(b"val3".to_vec()), Some(3));
+		changeset.set(b"key4".to_vec(), Some(b"val4".to_vec()), Some(4));
+		changeset.set(b"key11".to_vec(), Some(b"val11".to_vec()), Some(11));
+
+		assert_eq!(changeset.changes_after(b"key0").next().unwrap().0, b"key1");
+		assert_eq!(
+			changeset.changes_after(b"key0").next().unwrap().1.value(),
+			Some(&b"val1".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key1").next().unwrap().0, b"key11");
+		assert_eq!(
+			changeset.changes_after(b"key1").next().unwrap().1.value(),
+			Some(&b"val11".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key11").next().unwrap().0, b"key2");
+		assert_eq!(
+			changeset.changes_after(b"key11").next().unwrap().1.value(),
+			Some(&b"val2".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key2").next().unwrap().0, b"key3");
+		assert_eq!(
+			changeset.changes_after(b"key2").next().unwrap().1.value(),
+			Some(&b"val3".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key3").next().unwrap().0, b"key4");
+		assert_eq!(
+			changeset.changes_after(b"key3").next().unwrap().1.value(),
+			Some(&b"val4".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key4").next(), None);
+
+		changeset.rollback_transaction().unwrap();
+
+		assert_eq!(changeset.changes_after(b"key0").next().unwrap().0, b"key1");
+		assert_eq!(
+			changeset.changes_after(b"key0").next().unwrap().1.value(),
+			Some(&b"val1".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key1").next().unwrap().0, b"key2");
+		assert_eq!(
+			changeset.changes_after(b"key1").next().unwrap().1.value(),
+			Some(&b"val2".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key11").next().unwrap().0, b"key2");
+		assert_eq!(
+			changeset.changes_after(b"key11").next().unwrap().1.value(),
+			Some(&b"val2".to_vec())
+		);
+		assert_eq!(changeset.changes_after(b"key2").next(), None);
+		assert_eq!(changeset.changes_after(b"key3").next(), None);
+		assert_eq!(changeset.changes_after(b"key4").next(), None);
+	}
+
+	#[test]
+	fn no_open_tx_commit_errors() {
+		let mut changeset = OverlayedChangeSet::default();
+		assert_eq!(changeset.transaction_depth(), 0);
+		assert_eq!(changeset.commit_transaction(), Err(NoOpenTransaction));
+	}
+
+	#[test]
+	fn no_open_tx_rollback_errors() {
+		let mut changeset = OverlayedChangeSet::default();
+		assert_eq!(changeset.transaction_depth(), 0);
+		assert_eq!(changeset.rollback_transaction(), Err(NoOpenTransaction));
+	}
+
+	#[test]
+	fn unbalanced_transactions_errors() {
+		let mut changeset = OverlayedChangeSet::default();
+		changeset.start_transaction();
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.commit_transaction(), Err(NoOpenTransaction));
+	}
+
+	#[test]
+	#[should_panic]
+	fn drain_with_open_transaction_panics() {
+		let mut changeset = OverlayedChangeSet::default();
+		changeset.start_transaction();
+		let _ = changeset.drain_commited();
+	}
+
+	#[test]
+	fn runtime_cannot_close_client_tx() {
+		let mut changeset = OverlayedChangeSet::default();
+		changeset.start_transaction();
+		changeset.enter_runtime().unwrap();
+		changeset.start_transaction();
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.commit_transaction(), Err(NoOpenTransaction));
+		assert_eq!(changeset.rollback_transaction(), Err(NoOpenTransaction));
+	}
+
+	#[test]
+	fn exit_runtime_closes_runtime_tx() {
+		let mut changeset = OverlayedChangeSet::default();
+
+		changeset.start_transaction();
+
+		changeset.set(b"key0".to_vec(), Some(b"val0".to_vec()), Some(1));
+
+		changeset.enter_runtime().unwrap();
+		changeset.start_transaction();
+		changeset.set(b"key1".to_vec(), Some(b"val1".to_vec()), Some(2));
+		changeset.exit_runtime().unwrap();
+
+		changeset.commit_transaction().unwrap();
+		assert_eq!(changeset.transaction_depth(), 0);
+
+		assert_drained(changeset, vec![(b"key0", Some(b"val0"))]);
+	}
+
+	#[test]
+	fn enter_exit_runtime_fails_when_already_in_requested_mode() {
+		let mut changeset = OverlayedChangeSet::default();
+
+		assert_eq!(changeset.exit_runtime(), Err(NotInRuntime));
+		assert_eq!(changeset.enter_runtime(), Ok(()));
+		assert_eq!(changeset.enter_runtime(), Err(AlreadyInRuntime));
+		assert_eq!(changeset.exit_runtime(), Ok(()));
+		assert_eq!(changeset.exit_runtime(), Err(NotInRuntime));
+	}
+}
diff --git a/substrate/primitives/state-machine/src/overlayed_changes/mod.rs b/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..28cfecf1dbd62b5387f79cff8938fc6fc9d4bf16
--- /dev/null
+++ b/substrate/primitives/state-machine/src/overlayed_changes/mod.rs
@@ -0,0 +1,1151 @@
+// 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.
+
+//! The overlayed changes to state.
+
+mod changeset;
+mod offchain;
+
+use self::changeset::OverlayedChangeSet;
+use crate::{backend::Backend, stats::StateMachineStats, BackendTransaction, DefaultError};
+use codec::{Decode, Encode};
+use hash_db::Hasher;
+pub use offchain::OffchainOverlayedChanges;
+use sp_core::{
+	offchain::OffchainOverlayedChange,
+	storage::{well_known_keys::EXTRINSIC_INDEX, ChildInfo, StateVersion},
+};
+#[cfg(feature = "std")]
+use sp_externalities::{Extension, Extensions};
+#[cfg(not(feature = "std"))]
+use sp_std::collections::btree_map::BTreeMap as Map;
+use sp_std::{collections::btree_set::BTreeSet, vec::Vec};
+use sp_trie::{empty_child_trie_root, LayoutV1};
+#[cfg(feature = "std")]
+use std::collections::{hash_map::Entry as MapEntry, HashMap as Map};
+#[cfg(feature = "std")]
+use std::{
+	any::{Any, TypeId},
+	boxed::Box,
+};
+
+pub use self::changeset::{AlreadyInRuntime, NoOpenTransaction, NotInRuntime, OverlayedValue};
+
+/// Changes that are made outside of extrinsics are marked with this index;
+pub const NO_EXTRINSIC_INDEX: u32 = 0xffffffff;
+
+/// Storage key.
+pub type StorageKey = Vec<u8>;
+
+/// Storage value.
+pub type StorageValue = Vec<u8>;
+
+/// In memory array of storage values.
+pub type StorageCollection = Vec<(StorageKey, Option<StorageValue>)>;
+
+/// In memory arrays of storage values for multiple child tries.
+pub type ChildStorageCollection = Vec<(StorageKey, StorageCollection)>;
+
+/// In memory array of storage values.
+pub type OffchainChangesCollection = Vec<((Vec<u8>, Vec<u8>), OffchainOverlayedChange)>;
+
+/// Keep trace of extrinsics index for a modified value.
+#[derive(Debug, Default, Eq, PartialEq, Clone)]
+pub struct Extrinsics(Vec<u32>);
+
+impl Extrinsics {
+	/// Extracts extrinsics into a `BTreeSets`.
+	fn copy_extrinsics_into(&self, dest: &mut BTreeSet<u32>) {
+		dest.extend(self.0.iter())
+	}
+
+	/// Add an extrinsics.
+	fn insert(&mut self, ext: u32) {
+		if Some(&ext) != self.0.last() {
+			self.0.push(ext);
+		}
+	}
+
+	/// Extend `self` with `other`.
+	fn extend(&mut self, other: Self) {
+		self.0.extend(other.0.into_iter());
+	}
+}
+
+/// The set of changes that are overlaid onto the backend.
+///
+/// It allows changes to be modified using nestable transactions.
+pub struct OverlayedChanges<H: Hasher> {
+	/// Top level storage changes.
+	top: OverlayedChangeSet,
+	/// Child storage changes. The map key is the child storage key without the common prefix.
+	children: Map<StorageKey, (OverlayedChangeSet, ChildInfo)>,
+	/// Offchain related changes.
+	offchain: OffchainOverlayedChanges,
+	/// Transaction index changes,
+	transaction_index_ops: Vec<IndexOperation>,
+	/// True if extrinsics stats must be collected.
+	collect_extrinsics: bool,
+	/// Collect statistic on this execution.
+	stats: StateMachineStats,
+	/// Caches the "storage transaction" that is created while calling `storage_root`.
+	///
+	/// This transaction can be applied to the backend to persist the state changes.
+	storage_transaction_cache: Option<StorageTransactionCache<H>>,
+}
+
+impl<H: Hasher> Default for OverlayedChanges<H> {
+	fn default() -> Self {
+		Self {
+			top: Default::default(),
+			children: Default::default(),
+			offchain: Default::default(),
+			transaction_index_ops: Default::default(),
+			collect_extrinsics: Default::default(),
+			stats: Default::default(),
+			storage_transaction_cache: None,
+		}
+	}
+}
+
+impl<H: Hasher> Clone for OverlayedChanges<H> {
+	fn clone(&self) -> Self {
+		Self {
+			top: self.top.clone(),
+			children: self.children.clone(),
+			offchain: self.offchain.clone(),
+			transaction_index_ops: self.transaction_index_ops.clone(),
+			collect_extrinsics: self.collect_extrinsics,
+			stats: self.stats.clone(),
+			storage_transaction_cache: self.storage_transaction_cache.clone(),
+		}
+	}
+}
+
+impl<H: Hasher> sp_std::fmt::Debug for OverlayedChanges<H> {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		f.debug_struct("OverlayedChanges")
+			.field("top", &self.top)
+			.field("children", &self.children)
+			.field("offchain", &self.offchain)
+			.field("transaction_index_ops", &self.transaction_index_ops)
+			.field("collect_extrinsics", &self.collect_extrinsics)
+			.field("stats", &self.stats)
+			.field("storage_transaction_cache", &self.storage_transaction_cache)
+			.finish()
+	}
+}
+
+/// Transaction index operation.
+#[derive(Debug, Clone)]
+pub enum IndexOperation {
+	/// Insert transaction into index.
+	Insert {
+		/// Extrinsic index in the current block.
+		extrinsic: u32,
+		/// Data content hash.
+		hash: Vec<u8>,
+		/// Indexed data size.
+		size: u32,
+	},
+	/// Renew existing transaction storage.
+	Renew {
+		/// Extrinsic index in the current block.
+		extrinsic: u32,
+		/// Referenced index hash.
+		hash: Vec<u8>,
+	},
+}
+
+/// A storage changes structure that can be generated by the data collected in [`OverlayedChanges`].
+///
+/// This contains all the changes to the storage and transactions to apply theses changes to the
+/// backend.
+pub struct StorageChanges<H: Hasher> {
+	/// All changes to the main storage.
+	///
+	/// A value of `None` means that it was deleted.
+	pub main_storage_changes: StorageCollection,
+	/// All changes to the child storages.
+	pub child_storage_changes: ChildStorageCollection,
+	/// Offchain state changes to write to the offchain database.
+	pub offchain_storage_changes: OffchainChangesCollection,
+	/// A transaction for the backend that contains all changes from
+	/// [`main_storage_changes`](StorageChanges::main_storage_changes) and from
+	/// [`child_storage_changes`](StorageChanges::child_storage_changes).
+	/// [`offchain_storage_changes`](StorageChanges::offchain_storage_changes).
+	pub transaction: BackendTransaction<H>,
+	/// The storage root after applying the transaction.
+	pub transaction_storage_root: H::Out,
+	/// Changes to the transaction index,
+	#[cfg(feature = "std")]
+	pub transaction_index_changes: Vec<IndexOperation>,
+}
+
+#[cfg(feature = "std")]
+impl<H: Hasher> StorageChanges<H> {
+	/// Deconstruct into the inner values
+	pub fn into_inner(
+		self,
+	) -> (
+		StorageCollection,
+		ChildStorageCollection,
+		OffchainChangesCollection,
+		BackendTransaction<H>,
+		H::Out,
+		Vec<IndexOperation>,
+	) {
+		(
+			self.main_storage_changes,
+			self.child_storage_changes,
+			self.offchain_storage_changes,
+			self.transaction,
+			self.transaction_storage_root,
+			self.transaction_index_changes,
+		)
+	}
+}
+
+impl<H: Hasher> Default for StorageChanges<H> {
+	fn default() -> Self {
+		Self {
+			main_storage_changes: Default::default(),
+			child_storage_changes: Default::default(),
+			offchain_storage_changes: Default::default(),
+			transaction: Default::default(),
+			transaction_storage_root: Default::default(),
+			#[cfg(feature = "std")]
+			transaction_index_changes: Default::default(),
+		}
+	}
+}
+
+/// Storage transactions are calculated as part of the `storage_root`.
+/// These transactions can be reused for importing the block into the
+/// storage. So, we cache them to not require a recomputation of those transactions.
+struct StorageTransactionCache<H: Hasher> {
+	/// Contains the changes for the main and the child storages as one transaction.
+	transaction: BackendTransaction<H>,
+	/// The storage root after applying the transaction.
+	transaction_storage_root: H::Out,
+}
+
+impl<H: Hasher> StorageTransactionCache<H> {
+	fn into_inner(self) -> (BackendTransaction<H>, H::Out) {
+		(self.transaction, self.transaction_storage_root)
+	}
+}
+
+impl<H: Hasher> Clone for StorageTransactionCache<H> {
+	fn clone(&self) -> Self {
+		Self {
+			transaction: self.transaction.clone(),
+			transaction_storage_root: self.transaction_storage_root,
+		}
+	}
+}
+
+impl<H: Hasher> sp_std::fmt::Debug for StorageTransactionCache<H> {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		let mut debug = f.debug_struct("StorageTransactionCache");
+
+		#[cfg(feature = "std")]
+		debug.field("transaction_storage_root", &self.transaction_storage_root);
+
+		#[cfg(not(feature = "std"))]
+		debug.field("transaction_storage_root", &self.transaction_storage_root.as_ref());
+
+		debug.finish()
+	}
+}
+
+impl<H: Hasher> OverlayedChanges<H> {
+	/// Whether no changes are contained in the top nor in any of the child changes.
+	pub fn is_empty(&self) -> bool {
+		self.top.is_empty() && self.children.is_empty()
+	}
+
+	/// Ask to collect/not to collect extrinsics indices where key(s) has been changed.
+	pub fn set_collect_extrinsics(&mut self, collect_extrinsics: bool) {
+		self.collect_extrinsics = collect_extrinsics;
+	}
+
+	/// 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]>> {
+		self.top.get(key).map(|x| {
+			let value = x.value();
+			let size_read = value.map(|x| x.len() as u64).unwrap_or(0);
+			self.stats.tally_read_modified(size_read);
+			value.map(AsRef::as_ref)
+		})
+	}
+
+	/// Should be called when there are changes that require to reset the
+	/// `storage_transaction_cache`.
+	fn mark_dirty(&mut self) {
+		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())?;
+		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);
+		Some(value.map(AsRef::as_ref))
+	}
+
+	/// Set a new value for the specified key.
+	///
+	/// Can be rolled back or committed when called inside a transaction.
+	pub fn set_storage(&mut self, key: StorageKey, val: Option<StorageValue>) {
+		self.mark_dirty();
+
+		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());
+	}
+
+	/// Set a new value for the specified key and child.
+	///
+	/// `None` can be used to delete a value specified by the given key.
+	///
+	/// Can be rolled back or committed when called inside a transaction.
+	pub(crate) fn set_child_storage(
+		&mut self,
+		child_info: &ChildInfo,
+		key: StorageKey,
+		val: Option<StorageValue>,
+	) {
+		self.mark_dirty();
+
+		let extrinsic_index = self.extrinsic_index();
+		let size_write = val.as_ref().map(|x| x.len() as u64).unwrap_or(0);
+		self.stats.tally_write_overlay(size_write);
+		let storage_key = child_info.storage_key().to_vec();
+		let top = &self.top;
+		let (changeset, info) = self
+			.children
+			.entry(storage_key)
+			.or_insert_with(|| (top.spawn_child(), child_info.clone()));
+		let updatable = info.try_update(child_info);
+		debug_assert!(updatable);
+		changeset.set(key, val, extrinsic_index);
+	}
+
+	/// Clear child storage of given storage key.
+	///
+	/// Can be rolled back or committed when called inside a transaction.
+	pub(crate) fn clear_child_storage(&mut self, child_info: &ChildInfo) -> u32 {
+		self.mark_dirty();
+
+		let extrinsic_index = self.extrinsic_index();
+		let storage_key = child_info.storage_key().to_vec();
+		let top = &self.top;
+		let (changeset, info) = self
+			.children
+			.entry(storage_key)
+			.or_insert_with(|| (top.spawn_child(), child_info.clone()));
+		let updatable = info.try_update(child_info);
+		debug_assert!(updatable);
+		changeset.clear_where(|_, _| true, extrinsic_index)
+	}
+
+	/// Removes all key-value pairs which keys share the given prefix.
+	///
+	/// Can be rolled back or committed when called inside a transaction.
+	pub(crate) fn clear_prefix(&mut self, prefix: &[u8]) -> u32 {
+		self.mark_dirty();
+
+		self.top.clear_where(|key, _| key.starts_with(prefix), self.extrinsic_index())
+	}
+
+	/// Removes all key-value pairs which keys share the given prefix.
+	///
+	/// Can be rolled back or committed when called inside a transaction
+	pub(crate) fn clear_child_prefix(&mut self, child_info: &ChildInfo, prefix: &[u8]) -> u32 {
+		self.mark_dirty();
+
+		let extrinsic_index = self.extrinsic_index();
+		let storage_key = child_info.storage_key().to_vec();
+		let top = &self.top;
+		let (changeset, info) = self
+			.children
+			.entry(storage_key)
+			.or_insert_with(|| (top.spawn_child(), child_info.clone()));
+		let updatable = info.try_update(child_info);
+		debug_assert!(updatable);
+		changeset.clear_where(|key, _| key.starts_with(prefix), extrinsic_index)
+	}
+
+	/// Returns the current nesting depth of the transaction stack.
+	///
+	/// A value of zero means that no transaction is open and changes are committed on write.
+	pub fn transaction_depth(&self) -> usize {
+		// The top changeset and all child changesets transact in lockstep and are
+		// therefore always at the same transaction depth.
+		self.top.transaction_depth()
+	}
+
+	/// Start a new nested transaction.
+	///
+	/// This allows to either commit or roll back all changes that where made while this
+	/// transaction was open. Any transaction must be closed by either `rollback_transaction` or
+	/// `commit_transaction` before this overlay can be converted into storage changes.
+	///
+	/// Changes made without any open transaction are committed immediately.
+	pub fn start_transaction(&mut self) {
+		self.top.start_transaction();
+		for (_, (changeset, _)) in self.children.iter_mut() {
+			changeset.start_transaction();
+		}
+		self.offchain.overlay_mut().start_transaction();
+	}
+
+	/// 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.mark_dirty();
+
+		self.top.rollback_transaction()?;
+		retain_map(&mut self.children, |_, (changeset, _)| {
+			changeset
+				.rollback_transaction()
+				.expect("Top and children changesets are started in lockstep; qed");
+			!changeset.is_empty()
+		});
+		self.offchain
+			.overlay_mut()
+			.rollback_transaction()
+			.expect("Top and offchain changesets are started in lockstep; qed");
+		Ok(())
+	}
+
+	/// 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.top.commit_transaction()?;
+		for (_, (changeset, _)) in self.children.iter_mut() {
+			changeset
+				.commit_transaction()
+				.expect("Top and children changesets are started in lockstep; qed");
+		}
+		self.offchain
+			.overlay_mut()
+			.commit_transaction()
+			.expect("Top and offchain changesets are started in lockstep; qed");
+		Ok(())
+	}
+
+	/// Call this before transfering control to the runtime.
+	///
+	/// This protects all existing transactions from being removed by the runtime.
+	/// Calling this while already inside the runtime will return an error.
+	pub fn enter_runtime(&mut self) -> Result<(), AlreadyInRuntime> {
+		self.top.enter_runtime()?;
+		for (_, (changeset, _)) in self.children.iter_mut() {
+			changeset
+				.enter_runtime()
+				.expect("Top and children changesets are entering runtime in lockstep; qed")
+		}
+		self.offchain
+			.overlay_mut()
+			.enter_runtime()
+			.expect("Top and offchain changesets are started in lockstep; qed");
+		Ok(())
+	}
+
+	/// Call this when control returns from the runtime.
+	///
+	/// This commits all dangling transaction left open by the runtime.
+	/// Calling this while outside the runtime will return an error.
+	pub fn exit_runtime(&mut self) -> Result<(), NotInRuntime> {
+		self.top.exit_runtime()?;
+		for (_, (changeset, _)) in self.children.iter_mut() {
+			changeset
+				.exit_runtime()
+				.expect("Top and children changesets are entering runtime in lockstep; qed");
+		}
+		self.offchain
+			.overlay_mut()
+			.exit_runtime()
+			.expect("Top and offchain changesets are started in lockstep; qed");
+		Ok(())
+	}
+
+	/// Consume all changes (top + children) and return them.
+	///
+	/// After calling this function no more changes are contained in this changeset.
+	///
+	/// Panics:
+	/// Panics if `transaction_depth() > 0`
+	pub fn offchain_drain_committed(
+		&mut self,
+	) -> impl Iterator<Item = ((StorageKey, StorageKey), OffchainOverlayedChange)> {
+		self.offchain.drain()
+	}
+
+	/// Get an iterator over all child changes as seen by the current transaction.
+	pub fn children(
+		&self,
+	) -> impl Iterator<Item = (impl Iterator<Item = (&StorageKey, &OverlayedValue)>, &ChildInfo)> {
+		self.children.values().map(|v| (v.0.changes(), &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 optional iterator over all child changes stored under the supplied key.
+	pub fn child_changes(
+		&self,
+		key: &[u8],
+	) -> Option<(impl Iterator<Item = (&StorageKey, &OverlayedValue)>, &ChildInfo)> {
+		self.children.get(key).map(|(overlay, info)| (overlay.changes(), info))
+	}
+
+	/// Get an list of all index operations.
+	pub fn transaction_index_ops(&self) -> &[IndexOperation] {
+		&self.transaction_index_ops
+	}
+
+	/// Drain all changes into a [`StorageChanges`] instance. Leave empty overlay in place.
+	pub fn drain_storage_changes<B: Backend<H>>(
+		&mut self,
+		backend: &B,
+		state_version: StateVersion,
+	) -> Result<StorageChanges<H>, DefaultError>
+	where
+		H::Out: Ord + Encode + 'static,
+	{
+		let (transaction, transaction_storage_root) = match self.storage_transaction_cache.take() {
+			Some(cache) => cache.into_inner(),
+			// If the transaction does not exist, we generate it.
+			None => {
+				self.storage_root(backend, state_version);
+				self.storage_transaction_cache
+					.take()
+					.expect("`storage_transaction_cache` was just initialized; qed")
+					.into_inner()
+			},
+		};
+
+		use sp_std::mem::take;
+		let main_storage_changes = take(&mut self.top).drain_commited();
+		let child_storage_changes = take(&mut self.children)
+			.into_iter()
+			.map(|(key, (val, info))| (key, (val.drain_commited(), info)));
+
+		let offchain_storage_changes = self.offchain_drain_committed().collect();
+
+		#[cfg(feature = "std")]
+		let transaction_index_changes = std::mem::take(&mut self.transaction_index_ops);
+
+		Ok(StorageChanges {
+			main_storage_changes: main_storage_changes.collect(),
+			child_storage_changes: child_storage_changes
+				.map(|(sk, it)| (sk, it.0.collect()))
+				.collect(),
+			offchain_storage_changes,
+			transaction,
+			transaction_storage_root,
+			#[cfg(feature = "std")]
+			transaction_index_changes,
+		})
+	}
+
+	/// Inserts storage entry responsible for current extrinsic index.
+	#[cfg(test)]
+	pub(crate) fn set_extrinsic_index(&mut self, extrinsic_index: u32) {
+		self.top.set(EXTRINSIC_INDEX.to_vec(), Some(extrinsic_index.encode()), None);
+	}
+
+	/// Returns current extrinsic index to use in changes trie construction.
+	/// None is returned if it is not set or changes trie config is not set.
+	/// Persistent value (from the backend) can be ignored because runtime must
+	/// 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> {
+		self.collect_extrinsics.then(|| {
+			self.storage(EXTRINSIC_INDEX)
+				.and_then(|idx| idx.and_then(|idx| Decode::decode(&mut &*idx).ok()))
+				.unwrap_or(NO_EXTRINSIC_INDEX)
+		})
+	}
+
+	/// Generate the storage root using `backend` and all changes
+	/// as seen by the current transaction.
+	///
+	/// Returns the storage root and whether it was already cached.
+	pub fn storage_root<B: Backend<H>>(
+		&mut self,
+		backend: &B,
+		state_version: StateVersion,
+	) -> (H::Out, bool)
+	where
+		H::Out: Ord + Encode,
+	{
+		if let Some(cache) = &self.storage_transaction_cache {
+			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 (root, transaction) = backend.full_storage_root(delta, child_delta, state_version);
+
+		self.storage_transaction_cache =
+			Some(StorageTransactionCache { transaction, transaction_storage_root: root });
+
+		(root, false)
+	}
+
+	/// Generate the child storage root using `backend` and all child changes
+	/// as seen by the current transaction.
+	///
+	/// Returns the child storage root and whether it was already cached.
+	pub fn child_storage_root<B: Backend<H>>(
+		&mut self,
+		child_info: &ChildInfo,
+		backend: &B,
+		state_version: StateVersion,
+	) -> Result<(H::Out, bool), B::Error>
+	where
+		H::Out: Ord + Encode + Decode,
+	{
+		let storage_key = child_info.storage_key();
+		let prefixed_storage_key = child_info.prefixed_storage_key();
+
+		if self.storage_transaction_cache.is_some() {
+			let root = self
+				.storage(prefixed_storage_key.as_slice())
+				.map(|v| Ok(v.map(|v| v.to_vec())))
+				.or_else(|| backend.storage(prefixed_storage_key.as_slice()).map(Some).transpose())
+				.transpose()?
+				.flatten()
+				.and_then(|k| Decode::decode(&mut &k[..]).ok())
+				// V1 is equivalent to V0 on empty root.
+				.unwrap_or_else(empty_child_trie_root::<LayoutV1<H>>);
+
+			return Ok((root, true))
+		}
+
+		let root = if let Some((changes, info)) = self.child_changes(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 {
+			None
+		};
+
+		let root = if let Some((root, is_empty, _)) = root {
+			// We store update in the overlay in order to be able to use
+			// 'self.storage_transaction' cache. This is brittle as it rely on Ext only querying
+			// the trie backend for storage root.
+			// A better design would be to manage 'child_storage_transaction' in a
+			// similar way as 'storage_transaction' but for each child trie.
+			self.set_storage(prefixed_storage_key.into_inner(), (!is_empty).then(|| root.encode()));
+
+			self.mark_dirty();
+
+			root
+		} else {
+			// empty overlay
+			let root = backend
+				.storage(prefixed_storage_key.as_slice())?
+				.and_then(|k| Decode::decode(&mut &k[..]).ok())
+				// V1 is equivalent to V0 on empty root.
+				.unwrap_or_else(empty_child_trie_root::<LayoutV1<H>>);
+
+			root
+		};
+
+		Ok((root, false))
+	}
+
+	/// 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)> {
+		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,
+		storage_key: &[u8],
+		key: &[u8],
+	) -> impl Iterator<Item = (&[u8], &OverlayedValue)> {
+		self.children
+			.get(storage_key)
+			.map(|(overlay, _)| overlay.changes_after(key))
+			.into_iter()
+			.flatten()
+	}
+
+	/// Read only access ot offchain overlay.
+	pub fn offchain(&self) -> &OffchainOverlayedChanges {
+		&self.offchain
+	}
+
+	/// Write a key value pair to the offchain storage overlay.
+	pub fn set_offchain_storage(&mut self, key: &[u8], value: Option<&[u8]>) {
+		use sp_core::offchain::STORAGE_PREFIX;
+		match value {
+			Some(value) => self.offchain.set(STORAGE_PREFIX, key, value),
+			None => self.offchain.remove(STORAGE_PREFIX, key),
+		}
+	}
+
+	/// Add transaction index operation.
+	pub fn add_transaction_index(&mut self, op: IndexOperation) {
+		self.transaction_index_ops.push(op)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<H: Hasher> From<sp_core::storage::Storage> for OverlayedChanges<H> {
+	fn from(storage: sp_core::storage::Storage) -> Self {
+		Self {
+			top: storage.top.into(),
+			children: storage
+				.children_default
+				.into_iter()
+				.map(|(k, v)| (k, (v.data.into(), v.child_info)))
+				.collect(),
+			..Default::default()
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+fn retain_map<K, V, F>(map: &mut Map<K, V>, f: F)
+where
+	K: std::cmp::Eq + std::hash::Hash,
+	F: FnMut(&K, &mut V) -> bool,
+{
+	map.retain(f);
+}
+
+#[cfg(not(feature = "std"))]
+fn retain_map<K, V, F>(map: &mut Map<K, V>, mut f: F)
+where
+	K: Ord,
+	F: FnMut(&K, &mut V) -> bool,
+{
+	let old = sp_std::mem::replace(map, Map::default());
+	for (k, mut v) in old.into_iter() {
+		if f(&k, &mut v) {
+			map.insert(k, v);
+		}
+	}
+}
+
+/// An overlayed extension is either a mutable reference
+/// or an owned extension.
+#[cfg(feature = "std")]
+pub enum OverlayedExtension<'a> {
+	MutRef(&'a mut Box<dyn Extension>),
+	Owned(Box<dyn Extension>),
+}
+
+/// Overlayed extensions which are sourced from [`Extensions`].
+///
+/// The sourced extensions will be stored as mutable references,
+/// while extensions that are registered while execution are stored
+/// as owned references. After the execution of a runtime function, we
+/// can safely drop this object while not having modified the original
+/// list.
+#[cfg(feature = "std")]
+pub struct OverlayedExtensions<'a> {
+	extensions: Map<TypeId, OverlayedExtension<'a>>,
+}
+
+#[cfg(feature = "std")]
+impl<'a> OverlayedExtensions<'a> {
+	/// Create a new instance of overalyed extensions from the given extensions.
+	pub fn new(extensions: &'a mut Extensions) -> Self {
+		Self {
+			extensions: extensions
+				.iter_mut()
+				.map(|(k, v)| (*k, OverlayedExtension::MutRef(v)))
+				.collect(),
+		}
+	}
+
+	/// Return a mutable reference to the requested extension.
+	pub fn get_mut(&mut self, ext_type_id: TypeId) -> Option<&mut dyn Any> {
+		self.extensions.get_mut(&ext_type_id).map(|ext| match ext {
+			OverlayedExtension::MutRef(ext) => ext.as_mut_any(),
+			OverlayedExtension::Owned(ext) => ext.as_mut_any(),
+		})
+	}
+
+	/// Register extension `extension` with the given `type_id`.
+	pub fn register(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn Extension>,
+	) -> Result<(), sp_externalities::Error> {
+		match self.extensions.entry(type_id) {
+			MapEntry::Vacant(vacant) => {
+				vacant.insert(OverlayedExtension::Owned(extension));
+				Ok(())
+			},
+			MapEntry::Occupied(_) => Err(sp_externalities::Error::ExtensionAlreadyRegistered),
+		}
+	}
+
+	/// Deregister extension with the given `type_id`.
+	///
+	/// Returns `true` when there was an extension registered for the given `type_id`.
+	pub fn deregister(&mut self, type_id: TypeId) -> bool {
+		self.extensions.remove(&type_id).is_some()
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::{ext::Ext, new_in_mem, InMemoryBackend};
+	use array_bytes::bytes2hex;
+	use sp_core::{traits::Externalities, Blake2Hasher};
+	use std::collections::BTreeMap;
+
+	fn assert_extrinsics(overlay: &OverlayedChangeSet, key: impl AsRef<[u8]>, expected: Vec<u32>) {
+		assert_eq!(
+			overlay.get(key.as_ref()).unwrap().extrinsics().into_iter().collect::<Vec<_>>(),
+			expected
+		)
+	}
+
+	#[test]
+	fn overlayed_storage_works() {
+		let mut overlayed = OverlayedChanges::<Blake2Hasher>::default();
+
+		let key = vec![42, 69, 169, 142];
+
+		assert!(overlayed.storage(&key).is_none());
+
+		overlayed.start_transaction();
+
+		overlayed.set_storage(key.clone(), Some(vec![1, 2, 3]));
+		assert_eq!(overlayed.storage(&key).unwrap(), Some(&[1, 2, 3][..]));
+
+		overlayed.commit_transaction().unwrap();
+
+		assert_eq!(overlayed.storage(&key).unwrap(), Some(&[1, 2, 3][..]));
+
+		overlayed.start_transaction();
+
+		overlayed.set_storage(key.clone(), Some(vec![]));
+		assert_eq!(overlayed.storage(&key).unwrap(), Some(&[][..]));
+
+		overlayed.set_storage(key.clone(), None);
+		assert!(overlayed.storage(&key).unwrap().is_none());
+
+		overlayed.rollback_transaction().unwrap();
+
+		assert_eq!(overlayed.storage(&key).unwrap(), Some(&[1, 2, 3][..]));
+
+		overlayed.set_storage(key.clone(), None);
+		assert!(overlayed.storage(&key).unwrap().is_none());
+	}
+
+	#[test]
+	fn offchain_overlayed_storage_transactions_works() {
+		use sp_core::offchain::STORAGE_PREFIX;
+		fn check_offchain_content(
+			state: &OverlayedChanges<Blake2Hasher>,
+			nb_commit: usize,
+			expected: Vec<(Vec<u8>, Option<Vec<u8>>)>,
+		) {
+			let mut state = state.clone();
+			for _ in 0..nb_commit {
+				state.commit_transaction().unwrap();
+			}
+			let offchain_data: Vec<_> = state.offchain_drain_committed().collect();
+			let expected: Vec<_> = expected
+				.into_iter()
+				.map(|(key, value)| {
+					let change = match value {
+						Some(value) => OffchainOverlayedChange::SetValue(value),
+						None => OffchainOverlayedChange::Remove,
+					};
+					((STORAGE_PREFIX.to_vec(), key), change)
+				})
+				.collect();
+			assert_eq!(offchain_data, expected);
+		}
+
+		let mut overlayed = OverlayedChanges::default();
+
+		let key = vec![42, 69, 169, 142];
+
+		check_offchain_content(&overlayed, 0, vec![]);
+
+		overlayed.start_transaction();
+
+		overlayed.set_offchain_storage(key.as_slice(), Some(&[1, 2, 3][..]));
+		check_offchain_content(&overlayed, 1, vec![(key.clone(), Some(vec![1, 2, 3]))]);
+
+		overlayed.commit_transaction().unwrap();
+
+		check_offchain_content(&overlayed, 0, vec![(key.clone(), Some(vec![1, 2, 3]))]);
+
+		overlayed.start_transaction();
+
+		overlayed.set_offchain_storage(key.as_slice(), Some(&[][..]));
+		check_offchain_content(&overlayed, 1, vec![(key.clone(), Some(vec![]))]);
+
+		overlayed.set_offchain_storage(key.as_slice(), None);
+		check_offchain_content(&overlayed, 1, vec![(key.clone(), None)]);
+
+		overlayed.rollback_transaction().unwrap();
+
+		check_offchain_content(&overlayed, 0, vec![(key.clone(), Some(vec![1, 2, 3]))]);
+
+		overlayed.set_offchain_storage(key.as_slice(), None);
+		check_offchain_content(&overlayed, 0, vec![(key.clone(), None)]);
+	}
+
+	#[test]
+	fn overlayed_storage_root_works() {
+		let state_version = StateVersion::default();
+		let initial: BTreeMap<_, _> = vec![
+			(b"doe".to_vec(), b"reindeer".to_vec()),
+			(b"dog".to_vec(), b"puppyXXX".to_vec()),
+			(b"dogglesworth".to_vec(), b"catXXX".to_vec()),
+			(b"doug".to_vec(), b"notadog".to_vec()),
+		]
+		.into_iter()
+		.collect();
+		let backend = InMemoryBackend::<Blake2Hasher>::from((initial, state_version));
+		let mut overlay = OverlayedChanges::default();
+
+		overlay.start_transaction();
+		overlay.set_storage(b"dog".to_vec(), Some(b"puppy".to_vec()));
+		overlay.set_storage(b"dogglesworth".to_vec(), Some(b"catYYY".to_vec()));
+		overlay.set_storage(b"doug".to_vec(), Some(vec![]));
+		overlay.commit_transaction().unwrap();
+
+		overlay.start_transaction();
+		overlay.set_storage(b"dogglesworth".to_vec(), Some(b"cat".to_vec()));
+		overlay.set_storage(b"doug".to_vec(), None);
+
+		{
+			let mut ext = Ext::new(&mut overlay, &backend, None);
+			let root = "39245109cef3758c2eed2ccba8d9b370a917850af3824bc8348d505df2c298fa";
+
+			assert_eq!(bytes2hex("", &ext.storage_root(state_version)), root);
+			// Calling a second time should use it from the cache
+			assert_eq!(bytes2hex("", &ext.storage_root(state_version)), root);
+		}
+
+		// Check that the storage root is recalculated
+		overlay.set_storage(b"doug2".to_vec(), Some(b"yes".to_vec()));
+
+		let mut ext = Ext::new(&mut overlay, &backend, None);
+		let root = "5c0a4e35cb967de785e1cb8743e6f24b6ff6d45155317f2078f6eb3fc4ff3e3d";
+		assert_eq!(bytes2hex("", &ext.storage_root(state_version)), root);
+	}
+
+	#[test]
+	fn overlayed_child_storage_root_works() {
+		let state_version = StateVersion::default();
+		let child_info = ChildInfo::new_default(b"Child1");
+		let child_info = &child_info;
+		let backend = new_in_mem::<Blake2Hasher>();
+		let mut overlay = OverlayedChanges::<Blake2Hasher>::default();
+		overlay.start_transaction();
+		overlay.set_child_storage(child_info, vec![20], Some(vec![20]));
+		overlay.set_child_storage(child_info, vec![30], Some(vec![30]));
+		overlay.set_child_storage(child_info, vec![40], Some(vec![40]));
+		overlay.commit_transaction().unwrap();
+		overlay.set_child_storage(child_info, vec![10], Some(vec![10]));
+		overlay.set_child_storage(child_info, vec![30], None);
+
+		{
+			let mut ext = Ext::new(&mut overlay, &backend, None);
+			let child_root = "c02965e1df4dc5baf6977390ce67dab1d7a9b27a87c1afe27b50d29cc990e0f5";
+			let root = "eafb765909c3ed5afd92a0c564acf4620d0234b31702e8e8e9b48da72a748838";
+
+			assert_eq!(
+				bytes2hex("", &ext.child_storage_root(child_info, state_version)),
+				child_root,
+			);
+
+			assert_eq!(bytes2hex("", &ext.storage_root(state_version)), root);
+
+			// Calling a second time should use it from the cache
+			assert_eq!(
+				bytes2hex("", &ext.child_storage_root(child_info, state_version)),
+				child_root,
+			);
+		}
+	}
+
+	#[test]
+	fn extrinsic_changes_are_collected() {
+		let mut overlay = OverlayedChanges::<Blake2Hasher>::default();
+		overlay.set_collect_extrinsics(true);
+
+		overlay.start_transaction();
+
+		overlay.set_storage(vec![100], Some(vec![101]));
+
+		overlay.set_extrinsic_index(0);
+		overlay.set_storage(vec![1], Some(vec![2]));
+
+		overlay.set_extrinsic_index(1);
+		overlay.set_storage(vec![3], Some(vec![4]));
+
+		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]);
+
+		overlay.start_transaction();
+
+		overlay.set_extrinsic_index(3);
+		overlay.set_storage(vec![3], Some(vec![7]));
+
+		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]);
+
+		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]);
+	}
+
+	#[test]
+	fn next_storage_key_change_works() {
+		let mut overlay = OverlayedChanges::<Blake2Hasher>::default();
+		overlay.start_transaction();
+		overlay.set_storage(vec![20], Some(vec![20]));
+		overlay.set_storage(vec![30], Some(vec![30]));
+		overlay.set_storage(vec![40], Some(vec![40]));
+		overlay.commit_transaction().unwrap();
+		overlay.set_storage(vec![10], Some(vec![10]));
+		overlay.set_storage(vec![30], None);
+
+		// next_prospective < next_committed
+		let next_to_5 = overlay.iter_after(&[5]).next().unwrap();
+		assert_eq!(next_to_5.0.to_vec(), vec![10]);
+		assert_eq!(next_to_5.1.value(), Some(&vec![10]));
+
+		// next_committed < next_prospective
+		let next_to_10 = overlay.iter_after(&[10]).next().unwrap();
+		assert_eq!(next_to_10.0.to_vec(), vec![20]);
+		assert_eq!(next_to_10.1.value(), Some(&vec![20]));
+
+		// next_committed == next_prospective
+		let next_to_20 = overlay.iter_after(&[20]).next().unwrap();
+		assert_eq!(next_to_20.0.to_vec(), vec![30]);
+		assert_eq!(next_to_20.1.value(), None);
+
+		// next_committed, no next_prospective
+		let next_to_30 = overlay.iter_after(&[30]).next().unwrap();
+		assert_eq!(next_to_30.0.to_vec(), vec![40]);
+		assert_eq!(next_to_30.1.value(), Some(&vec![40]));
+
+		overlay.set_storage(vec![50], Some(vec![50]));
+		// next_prospective, no next_committed
+		let next_to_40 = overlay.iter_after(&[40]).next().unwrap();
+		assert_eq!(next_to_40.0.to_vec(), vec![50]);
+		assert_eq!(next_to_40.1.value(), Some(&vec![50]));
+	}
+
+	#[test]
+	fn next_child_storage_key_change_works() {
+		let child_info = ChildInfo::new_default(b"Child1");
+		let child_info = &child_info;
+		let child = child_info.storage_key();
+		let mut overlay = OverlayedChanges::<Blake2Hasher>::default();
+		overlay.start_transaction();
+		overlay.set_child_storage(child_info, vec![20], Some(vec![20]));
+		overlay.set_child_storage(child_info, vec![30], Some(vec![30]));
+		overlay.set_child_storage(child_info, vec![40], Some(vec![40]));
+		overlay.commit_transaction().unwrap();
+		overlay.set_child_storage(child_info, vec![10], Some(vec![10]));
+		overlay.set_child_storage(child_info, vec![30], None);
+
+		// next_prospective < next_committed
+		let next_to_5 = overlay.child_iter_after(child, &[5]).next().unwrap();
+		assert_eq!(next_to_5.0.to_vec(), vec![10]);
+		assert_eq!(next_to_5.1.value(), Some(&vec![10]));
+
+		// next_committed < next_prospective
+		let next_to_10 = overlay.child_iter_after(child, &[10]).next().unwrap();
+		assert_eq!(next_to_10.0.to_vec(), vec![20]);
+		assert_eq!(next_to_10.1.value(), Some(&vec![20]));
+
+		// next_committed == next_prospective
+		let next_to_20 = overlay.child_iter_after(child, &[20]).next().unwrap();
+		assert_eq!(next_to_20.0.to_vec(), vec![30]);
+		assert_eq!(next_to_20.1.value(), None);
+
+		// next_committed, no next_prospective
+		let next_to_30 = overlay.child_iter_after(child, &[30]).next().unwrap();
+		assert_eq!(next_to_30.0.to_vec(), vec![40]);
+		assert_eq!(next_to_30.1.value(), Some(&vec![40]));
+
+		overlay.set_child_storage(child_info, vec![50], Some(vec![50]));
+		// next_prospective, no next_committed
+		let next_to_40 = overlay.child_iter_after(child, &[40]).next().unwrap();
+		assert_eq!(next_to_40.0.to_vec(), vec![50]);
+		assert_eq!(next_to_40.1.value(), Some(&vec![50]));
+	}
+}
diff --git a/substrate/primitives/state-machine/src/overlayed_changes/offchain.rs b/substrate/primitives/state-machine/src/overlayed_changes/offchain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..66e7ab5864c065f4d335b7daae9e3c686d9c3ec8
--- /dev/null
+++ b/substrate/primitives/state-machine/src/overlayed_changes/offchain.rs
@@ -0,0 +1,131 @@
+// 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.
+
+//! Overlayed changes for offchain indexing.
+
+use super::changeset::OverlayedMap;
+use sp_core::offchain::OffchainOverlayedChange;
+use sp_std::prelude::Vec;
+
+/// In-memory storage for offchain workers recoding changes for the actual offchain storage
+/// implementation.
+#[derive(Debug, Clone, Default)]
+pub struct OffchainOverlayedChanges(OverlayedMap<(Vec<u8>, Vec<u8>), OffchainOverlayedChange>);
+
+/// Item for iterating over offchain changes.
+///
+/// First element i a tuple of `(prefix, key)`, second element ist the actual change
+/// (remove or set value).
+type OffchainOverlayedChangesItem<'i> = (&'i (Vec<u8>, Vec<u8>), &'i OffchainOverlayedChange);
+
+/// Iterator over offchain changes, owned memory version.
+type OffchainOverlayedChangesItemOwned = ((Vec<u8>, Vec<u8>), OffchainOverlayedChange);
+
+impl OffchainOverlayedChanges {
+	/// Consume the offchain storage and iterate over all key value pairs.
+	pub fn into_iter(self) -> impl Iterator<Item = OffchainOverlayedChangesItemOwned> {
+		self.0.into_changes().map(|kv| (kv.0, kv.1.into_value()))
+	}
+
+	/// Iterate over all key value pairs by reference.
+	pub fn iter(&self) -> impl Iterator<Item = OffchainOverlayedChangesItem> {
+		self.0.changes().map(|kv| (kv.0, kv.1.value_ref()))
+	}
+
+	/// Drain all elements of changeset.
+	pub fn drain(&mut self) -> impl Iterator<Item = OffchainOverlayedChangesItemOwned> {
+		sp_std::mem::take(self).into_iter()
+	}
+
+	/// 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);
+	}
+
+	/// 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(
+			(prefix.to_vec(), key.to_vec()),
+			OffchainOverlayedChange::SetValue(value.to_vec()),
+			None,
+		);
+	}
+
+	/// Obtain a associated value to the given key in storage with prefix.
+	pub fn get(&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()
+	}
+
+	/// Reference to inner change set.
+	pub fn overlay(&self) -> &OverlayedMap<(Vec<u8>, Vec<u8>), OffchainOverlayedChange> {
+		&self.0
+	}
+
+	/// Mutable reference to inner change set.
+	pub fn overlay_mut(
+		&mut self,
+	) -> &mut OverlayedMap<(Vec<u8>, Vec<u8>), OffchainOverlayedChange> {
+		&mut self.0
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use sp_core::offchain::STORAGE_PREFIX;
+
+	#[test]
+	fn test_drain() {
+		let mut ooc = OffchainOverlayedChanges::default();
+		ooc.set(STORAGE_PREFIX, b"kkk", b"vvv");
+		let drained = ooc.drain().count();
+		assert_eq!(drained, 1);
+		let leftover = ooc.iter().count();
+		assert_eq!(leftover, 0);
+
+		ooc.set(STORAGE_PREFIX, b"a", b"v");
+		ooc.set(STORAGE_PREFIX, b"b", b"v");
+		ooc.set(STORAGE_PREFIX, b"c", b"v");
+		ooc.set(STORAGE_PREFIX, b"d", b"v");
+		ooc.set(STORAGE_PREFIX, b"e", b"v");
+		assert_eq!(ooc.iter().count(), 5);
+	}
+
+	#[test]
+	fn test_accumulated_set_remove_set() {
+		let mut ooc = OffchainOverlayedChanges::default();
+		ooc.set(STORAGE_PREFIX, b"ppp", b"qqq");
+		ooc.remove(STORAGE_PREFIX, b"ppp");
+		// keys are equiv, so it will overwrite the value and the overlay will contain
+		// one item
+		assert_eq!(ooc.iter().count(), 1);
+
+		ooc.set(STORAGE_PREFIX, b"ppp", b"rrr");
+		let mut iter = ooc.into_iter();
+		assert_eq!(
+			iter.next(),
+			Some((
+				(STORAGE_PREFIX.to_vec(), b"ppp".to_vec()),
+				OffchainOverlayedChange::SetValue(b"rrr".to_vec())
+			))
+		);
+		assert_eq!(iter.next(), None);
+	}
+}
diff --git a/substrate/primitives/state-machine/src/read_only.rs b/substrate/primitives/state-machine/src/read_only.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2056bf9866358d4d5086fbdf67a7385e7532092f
--- /dev/null
+++ b/substrate/primitives/state-machine/src/read_only.rs
@@ -0,0 +1,244 @@
+// 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.
+
+//! Read-only version of Externalities.
+
+use crate::{Backend, StorageKey, StorageValue};
+use codec::Encode;
+use hash_db::Hasher;
+use sp_core::{
+	storage::{ChildInfo, StateVersion, TrackedStorageKey},
+	traits::Externalities,
+};
+use sp_externalities::MultiRemovalResults;
+use std::{
+	any::{Any, TypeId},
+	marker::PhantomData,
+};
+
+/// Trait for inspecting state in any backend.
+///
+/// Implemented for any backend.
+pub trait InspectState<H: Hasher, B: Backend<H>> {
+	/// Inspect state with a closure.
+	///
+	/// Self will be set as read-only externalities and inspection
+	/// closure will be run against it.
+	///
+	/// Returns the result of the closure.
+	fn inspect_state<F: FnOnce() -> R, R>(&self, f: F) -> R;
+}
+
+impl<H: Hasher, B: Backend<H>> InspectState<H, B> for B
+where
+	H::Out: Encode,
+{
+	fn inspect_state<F: FnOnce() -> R, R>(&self, f: F) -> R {
+		ReadOnlyExternalities::from(self).execute_with(f)
+	}
+}
+
+/// Simple read-only externalities for any backend.
+///
+/// To be used in test for state inspection. Will panic if something writes
+/// to the storage.
+#[derive(Debug)]
+pub struct ReadOnlyExternalities<'a, H: Hasher, B: 'a + Backend<H>> {
+	backend: &'a B,
+	_phantom: PhantomData<H>,
+}
+
+impl<'a, H: Hasher, B: 'a + Backend<H>> From<&'a B> for ReadOnlyExternalities<'a, H, B> {
+	fn from(backend: &'a B) -> Self {
+		ReadOnlyExternalities { backend, _phantom: PhantomData }
+	}
+}
+
+impl<'a, H: Hasher, B: 'a + Backend<H>> ReadOnlyExternalities<'a, H, B>
+where
+	H::Out: Encode,
+{
+	/// Execute the given closure while `self` is set as externalities.
+	///
+	/// Returns the result of the given closure.
+	pub fn execute_with<R>(&mut self, f: impl FnOnce() -> R) -> R {
+		sp_externalities::set_and_run_with_externalities(self, f)
+	}
+}
+
+impl<'a, H: Hasher, B: 'a + Backend<H>> Externalities for ReadOnlyExternalities<'a, H, B>
+where
+	H::Out: Encode,
+{
+	fn set_offchain_storage(&mut self, _key: &[u8], _value: Option<&[u8]>) {
+		panic!("Should not be used in read-only externalities!")
+	}
+
+	fn storage(&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>> {
+		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> {
+		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>> {
+		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> {
+		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> {
+		self.backend
+			.next_child_storage_key(child_info, key)
+			.expect("Backed failed for next_child_storage_key in ReadOnlyExternalities")
+	}
+
+	fn place_storage(&mut self, _key: StorageKey, _maybe_value: Option<StorageValue>) {
+		unimplemented!("place_storage not supported in ReadOnlyExternalities")
+	}
+
+	fn place_child_storage(
+		&mut self,
+		_child_info: &ChildInfo,
+		_key: StorageKey,
+		_value: Option<StorageValue>,
+	) {
+		unimplemented!("place_child_storage not supported in ReadOnlyExternalities")
+	}
+
+	fn kill_child_storage(
+		&mut self,
+		_child_info: &ChildInfo,
+		_maybe_limit: Option<u32>,
+		_maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		unimplemented!("kill_child_storage is not supported in ReadOnlyExternalities")
+	}
+
+	fn clear_prefix(
+		&mut self,
+		_prefix: &[u8],
+		_maybe_limit: Option<u32>,
+		_maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		unimplemented!("clear_prefix is not supported in ReadOnlyExternalities")
+	}
+
+	fn clear_child_prefix(
+		&mut self,
+		_child_info: &ChildInfo,
+		_prefix: &[u8],
+		_maybe_limit: Option<u32>,
+		_maybe_cursor: Option<&[u8]>,
+	) -> MultiRemovalResults {
+		unimplemented!("clear_child_prefix is not supported in ReadOnlyExternalities")
+	}
+
+	fn storage_append(&mut self, _key: Vec<u8>, _value: Vec<u8>) {
+		unimplemented!("storage_append is not supported in ReadOnlyExternalities")
+	}
+
+	fn storage_root(&mut self, _state_version: StateVersion) -> Vec<u8> {
+		unimplemented!("storage_root is not supported in ReadOnlyExternalities")
+	}
+
+	fn child_storage_root(
+		&mut self,
+		_child_info: &ChildInfo,
+		_state_version: StateVersion,
+	) -> Vec<u8> {
+		unimplemented!("child_storage_root is not supported in ReadOnlyExternalities")
+	}
+
+	fn storage_start_transaction(&mut self) {
+		unimplemented!("Transactions are not supported by ReadOnlyExternalities");
+	}
+
+	fn storage_rollback_transaction(&mut self) -> Result<(), ()> {
+		unimplemented!("Transactions are not supported by ReadOnlyExternalities");
+	}
+
+	fn storage_commit_transaction(&mut self) -> Result<(), ()> {
+		unimplemented!("Transactions are not supported by ReadOnlyExternalities");
+	}
+
+	fn wipe(&mut self) {}
+
+	fn commit(&mut self) {}
+
+	fn read_write_count(&self) -> (u32, u32, u32, u32) {
+		unimplemented!("read_write_count is not supported in ReadOnlyExternalities")
+	}
+
+	fn reset_read_write_count(&mut self) {
+		unimplemented!("reset_read_write_count is not supported in ReadOnlyExternalities")
+	}
+
+	fn get_whitelist(&self) -> Vec<TrackedStorageKey> {
+		unimplemented!("get_whitelist is not supported in ReadOnlyExternalities")
+	}
+
+	fn set_whitelist(&mut self, _: Vec<TrackedStorageKey>) {
+		unimplemented!("set_whitelist is not supported in ReadOnlyExternalities")
+	}
+
+	fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> {
+		unimplemented!("get_read_and_written_keys is not supported in ReadOnlyExternalities")
+	}
+}
+
+impl<'a, H: Hasher, B: 'a + Backend<H>> sp_externalities::ExtensionStore
+	for ReadOnlyExternalities<'a, H, B>
+{
+	fn extension_by_type_id(&mut self, _type_id: TypeId) -> Option<&mut dyn Any> {
+		unimplemented!("extension_by_type_id is not supported in ReadOnlyExternalities")
+	}
+
+	fn register_extension_with_type_id(
+		&mut self,
+		_type_id: TypeId,
+		_extension: Box<dyn sp_externalities::Extension>,
+	) -> Result<(), sp_externalities::Error> {
+		unimplemented!("register_extension_with_type_id is not supported in ReadOnlyExternalities")
+	}
+
+	fn deregister_extension_by_type_id(
+		&mut self,
+		_type_id: TypeId,
+	) -> Result<(), sp_externalities::Error> {
+		unimplemented!("deregister_extension_by_type_id is not supported in ReadOnlyExternalities")
+	}
+}
diff --git a/substrate/primitives/state-machine/src/stats.rs b/substrate/primitives/state-machine/src/stats.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c5510961a373268ca44693489bed842209c1e03
--- /dev/null
+++ b/substrate/primitives/state-machine/src/stats.rs
@@ -0,0 +1,131 @@
+// 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.
+
+//! Usage statistics for state db
+
+use sp_std::cell::RefCell;
+#[cfg(feature = "std")]
+use std::time::{Duration, Instant};
+
+/// Measured count of operations and total bytes.
+#[derive(Clone, Debug, Default)]
+pub struct UsageUnit {
+	/// Number of operations.
+	pub ops: u64,
+	/// Number of bytes.
+	pub bytes: u64,
+}
+
+/// Usage statistics for state backend.
+#[derive(Clone, Debug)]
+pub struct UsageInfo {
+	/// Read statistics (total).
+	pub reads: UsageUnit,
+	/// Write statistics (total).
+	pub writes: UsageUnit,
+	/// Write trie nodes statistics.
+	pub nodes_writes: UsageUnit,
+	/// Write into cached state machine
+	/// change overlay.
+	pub overlay_writes: UsageUnit,
+	/// Removed trie nodes statistics.
+	pub removed_nodes: UsageUnit,
+	/// Cache read statistics.
+	pub cache_reads: UsageUnit,
+	/// Modified value read statistics.
+	pub modified_reads: UsageUnit,
+	/// Memory used.
+	pub memory: usize,
+
+	#[cfg(feature = "std")]
+	/// Moment at which current statistics has been started being collected.
+	pub started: Instant,
+	#[cfg(feature = "std")]
+	/// Timespan of the statistics.
+	pub span: Duration,
+}
+
+/// Accumulated usage statistics specific to state machine
+/// crate.
+#[derive(Debug, Default, Clone)]
+pub struct StateMachineStats {
+	/// Number of read query from runtime
+	/// that hit a modified value (in state
+	/// machine overlay).
+	pub reads_modified: RefCell<u64>,
+	/// Size in byte of read queries that
+	/// hit a modified value.
+	pub bytes_read_modified: RefCell<u64>,
+	/// Number of time a write operation
+	/// occurs into the state machine overlay.
+	pub writes_overlay: RefCell<u64>,
+	/// Size in bytes of the writes overlay
+	/// operation.
+	pub bytes_writes_overlay: RefCell<u64>,
+}
+
+impl StateMachineStats {
+	/// Accumulates some registered stats.
+	pub fn add(&self, other: &StateMachineStats) {
+		*self.reads_modified.borrow_mut() += *other.reads_modified.borrow();
+		*self.bytes_read_modified.borrow_mut() += *other.bytes_read_modified.borrow();
+		*self.writes_overlay.borrow_mut() += *other.writes_overlay.borrow();
+		*self.bytes_writes_overlay.borrow_mut() += *other.bytes_writes_overlay.borrow();
+	}
+}
+
+impl UsageInfo {
+	/// Empty statistics.
+	///
+	/// Means no data was collected.
+	pub fn empty() -> Self {
+		Self {
+			reads: UsageUnit::default(),
+			writes: UsageUnit::default(),
+			overlay_writes: UsageUnit::default(),
+			nodes_writes: UsageUnit::default(),
+			removed_nodes: UsageUnit::default(),
+			cache_reads: UsageUnit::default(),
+			modified_reads: UsageUnit::default(),
+			memory: 0,
+			#[cfg(feature = "std")]
+			started: Instant::now(),
+			#[cfg(feature = "std")]
+			span: Default::default(),
+		}
+	}
+	/// Add collected state machine to this state.
+	pub fn include_state_machine_states(&mut self, count: &StateMachineStats) {
+		self.modified_reads.ops += *count.reads_modified.borrow();
+		self.modified_reads.bytes += *count.bytes_read_modified.borrow();
+		self.overlay_writes.ops += *count.writes_overlay.borrow();
+		self.overlay_writes.bytes += *count.bytes_writes_overlay.borrow();
+	}
+}
+
+impl StateMachineStats {
+	/// Tally one read modified operation, of some length.
+	pub fn tally_read_modified(&self, data_bytes: u64) {
+		*self.reads_modified.borrow_mut() += 1;
+		*self.bytes_read_modified.borrow_mut() += data_bytes;
+	}
+	/// Tally one write overlay operation, of some length.
+	pub fn tally_write_overlay(&self, data_bytes: u64) {
+		*self.writes_overlay.borrow_mut() += 1;
+		*self.bytes_writes_overlay.borrow_mut() += data_bytes;
+	}
+}
diff --git a/substrate/primitives/state-machine/src/testing.rs b/substrate/primitives/state-machine/src/testing.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0eb7b6d1118f9aa3cff1caee089d526b3f711d94
--- /dev/null
+++ b/substrate/primitives/state-machine/src/testing.rs
@@ -0,0 +1,516 @@
+// 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.
+
+//! Test implementation for Externalities.
+
+use std::{
+	any::{Any, TypeId},
+	panic::{AssertUnwindSafe, UnwindSafe},
+};
+
+use crate::{
+	backend::Backend, ext::Ext, InMemoryBackend, OverlayedChanges, StorageKey, StorageValue,
+	TrieBackendBuilder,
+};
+
+use hash_db::{HashDB, Hasher};
+use sp_core::{
+	offchain::testing::TestPersistentOffchainDB,
+	storage::{
+		well_known_keys::{is_child_storage_key, CODE},
+		StateVersion, Storage,
+	},
+};
+use sp_externalities::{Extension, ExtensionStore, Extensions};
+use sp_trie::{PrefixedMemoryDB, StorageProof};
+
+/// Simple HashMap-based Externalities impl.
+pub struct TestExternalities<H>
+where
+	H: Hasher + 'static,
+	H::Out: codec::Codec + Ord,
+{
+	/// The overlay changed storage.
+	overlay: OverlayedChanges<H>,
+	offchain_db: TestPersistentOffchainDB,
+	/// Storage backend.
+	pub backend: InMemoryBackend<H>,
+	/// Extensions.
+	pub extensions: Extensions,
+	/// State version to use during tests.
+	pub state_version: StateVersion,
+}
+
+impl<H> TestExternalities<H>
+where
+	H: Hasher + 'static,
+	H::Out: Ord + 'static + codec::Codec,
+{
+	/// Get externalities implementation.
+	pub fn ext(&mut self) -> Ext<H, InMemoryBackend<H>> {
+		Ext::new(&mut self.overlay, &self.backend, Some(&mut self.extensions))
+	}
+
+	/// Create a new instance of `TestExternalities` with storage.
+	pub fn new(storage: Storage) -> Self {
+		Self::new_with_code_and_state(&[], storage, Default::default())
+	}
+
+	/// Create a new instance of `TestExternalities` with storage for a given state version.
+	pub fn new_with_state_version(storage: Storage, state_version: StateVersion) -> Self {
+		Self::new_with_code_and_state(&[], storage, state_version)
+	}
+
+	/// New empty test externalities.
+	pub fn new_empty() -> Self {
+		Self::new_with_code_and_state(&[], Storage::default(), Default::default())
+	}
+
+	/// Create a new instance of `TestExternalities` with code and storage.
+	pub fn new_with_code(code: &[u8], storage: Storage) -> Self {
+		Self::new_with_code_and_state(code, storage, Default::default())
+	}
+
+	/// Create a new instance of `TestExternalities` with code and storage for a given state
+	/// version.
+	pub fn new_with_code_and_state(
+		code: &[u8],
+		mut storage: Storage,
+		state_version: StateVersion,
+	) -> Self {
+		assert!(storage.top.keys().all(|key| !is_child_storage_key(key)));
+
+		storage.top.insert(CODE.to_vec(), code.to_vec());
+
+		let offchain_db = TestPersistentOffchainDB::new();
+
+		let backend = (storage, state_version).into();
+
+		TestExternalities {
+			overlay: OverlayedChanges::default(),
+			offchain_db,
+			extensions: Default::default(),
+			backend,
+			state_version,
+		}
+	}
+
+	/// Returns the overlayed changes.
+	pub fn overlayed_changes(&self) -> &OverlayedChanges<H> {
+		&self.overlay
+	}
+
+	/// Move offchain changes from overlay to the persistent store.
+	pub fn persist_offchain_overlay(&mut self) {
+		self.offchain_db.apply_offchain_changes(self.overlay.offchain_drain_committed());
+	}
+
+	/// A shared reference type around the offchain worker storage.
+	pub fn offchain_db(&self) -> TestPersistentOffchainDB {
+		self.offchain_db.clone()
+	}
+
+	/// Batch insert key/values into backend
+	pub fn batch_insert<I>(&mut self, kvs: I)
+	where
+		I: IntoIterator<Item = (StorageKey, StorageValue)>,
+	{
+		self.backend.insert(
+			Some((None, kvs.into_iter().map(|(k, v)| (k, Some(v))).collect())),
+			self.state_version,
+		);
+	}
+
+	/// Insert key/value into backend
+	pub fn insert(&mut self, k: StorageKey, v: StorageValue) {
+		self.backend.insert(vec![(None, vec![(k, Some(v))])], self.state_version);
+	}
+
+	/// Insert key/value into backend.
+	///
+	/// This only supports inserting keys in child tries.
+	pub fn insert_child(&mut self, c: sp_core::storage::ChildInfo, k: StorageKey, v: StorageValue) {
+		self.backend.insert(vec![(Some(c), vec![(k, Some(v))])], self.state_version);
+	}
+
+	/// Registers the given extension for this instance.
+	pub fn register_extension<E: Any + Extension>(&mut self, ext: E) {
+		self.extensions.register(ext);
+	}
+
+	/// Sets raw storage key/values and a root.
+	///
+	/// This can be used as a fast way to restore the storage state from a backup because the trie
+	/// does not need to be computed.
+	pub fn from_raw_snapshot(
+		raw_storage: Vec<(Vec<u8>, (Vec<u8>, i32))>,
+		storage_root: H::Out,
+		state_version: StateVersion,
+	) -> Self {
+		let mut backend = PrefixedMemoryDB::default();
+
+		for (key, (v, ref_count)) in raw_storage {
+			let mut hash = H::Out::default();
+			let hash_len = hash.as_ref().len();
+
+			if key.len() < hash_len {
+				log::warn!("Invalid key in `from_raw_snapshot`: {key:?}");
+				continue
+			}
+
+			hash.as_mut().copy_from_slice(&key[(key.len() - hash_len)..]);
+
+			// Each time .emplace is called the internal MemoryDb ref count increments.
+			// Repeatedly call emplace to initialise the ref count to the correct value.
+			for _ in 0..ref_count {
+				backend.emplace(hash, (&key[..(key.len() - hash_len)], None), v.clone());
+			}
+		}
+
+		Self {
+			backend: TrieBackendBuilder::new(backend, storage_root).build(),
+			overlay: Default::default(),
+			offchain_db: Default::default(),
+			extensions: Default::default(),
+			state_version,
+		}
+	}
+
+	/// Drains the underlying raw storage key/values and returns the root hash.
+	///
+	/// Useful for backing up the storage in a format that can be quickly re-loaded.
+	pub fn into_raw_snapshot(mut self) -> (Vec<(Vec<u8>, (Vec<u8>, i32))>, H::Out) {
+		let raw_key_values = self
+			.backend
+			.backend_storage_mut()
+			.drain()
+			.into_iter()
+			.filter(|(_, (_, r))| *r > 0)
+			.collect::<Vec<(Vec<u8>, (Vec<u8>, i32))>>();
+
+		(raw_key_values, *self.backend.root())
+	}
+
+	/// Return a new backend with all pending changes.
+	///
+	/// 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();
+		let mut transaction = vec![(None, top)];
+
+		for (child_changes, child_info) in self.overlay.children() {
+			transaction.push((
+				Some(child_info.clone()),
+				child_changes.map(|(k, v)| (k.clone(), v.value().cloned())).collect(),
+			))
+		}
+
+		self.backend.update(transaction, self.state_version)
+	}
+
+	/// Commit all pending changes to the underlying backend.
+	///
+	/// # Panic
+	///
+	/// This will panic if there are still open transactions.
+	pub fn commit_all(&mut self) -> Result<(), String> {
+		let changes = self.overlay.drain_storage_changes(&self.backend, self.state_version)?;
+
+		self.backend
+			.apply_transaction(changes.transaction_storage_root, changes.transaction);
+		Ok(())
+	}
+
+	/// Execute the given closure while `self` is set as externalities.
+	///
+	/// Returns the result of the given closure.
+	pub fn execute_with<R>(&mut self, execute: impl FnOnce() -> R) -> R {
+		let mut ext = self.ext();
+		sp_externalities::set_and_run_with_externalities(&mut ext, execute)
+	}
+
+	/// Execute the given closure while `self`, with `proving_backend` as backend, is set as
+	/// externalities.
+	///
+	/// This implementation will wipe the proof recorded in between calls. Consecutive calls will
+	/// get their own proof from scratch.
+	pub fn execute_and_prove<R>(&mut self, execute: impl FnOnce() -> R) -> (R, StorageProof) {
+		let proving_backend = TrieBackendBuilder::wrap(&self.backend)
+			.with_recorder(Default::default())
+			.build();
+		let mut proving_ext =
+			Ext::new(&mut self.overlay, &proving_backend, Some(&mut self.extensions));
+
+		let outcome = sp_externalities::set_and_run_with_externalities(&mut proving_ext, execute);
+		let proof = proving_backend.extract_proof().expect("Failed to extract storage proof");
+
+		(outcome, proof)
+	}
+
+	/// Execute the given closure while `self` is set as externalities.
+	///
+	/// Returns the result of the given closure, if no panics occurred.
+	/// Otherwise, returns `Err`.
+	pub fn execute_with_safe<R>(
+		&mut self,
+		f: impl FnOnce() -> R + UnwindSafe,
+	) -> Result<R, String> {
+		let mut ext = AssertUnwindSafe(self.ext());
+		std::panic::catch_unwind(move || {
+			sp_externalities::set_and_run_with_externalities(&mut *ext, f)
+		})
+		.map_err(|e| format!("Closure panicked: {:?}", e))
+	}
+}
+
+impl<H: Hasher> std::fmt::Debug for TestExternalities<H>
+where
+	H::Out: Ord + codec::Codec,
+{
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		let pairs: Vec<_> = self
+			.backend
+			.pairs(Default::default())
+			.expect("creating an iterator over all of the pairs doesn't fail in tests")
+			.collect();
+		write!(f, "overlay: {:?}\nbackend: {:?}", self.overlay, pairs)
+	}
+}
+
+impl<H: Hasher> PartialEq for TestExternalities<H>
+where
+	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 {
+		self.as_backend().eq(&other.as_backend())
+	}
+}
+
+impl<H: Hasher> Default for TestExternalities<H>
+where
+	H::Out: Ord + 'static + codec::Codec,
+{
+	fn default() -> Self {
+		// default to default version.
+		Self::new_with_state_version(Storage::default(), Default::default())
+	}
+}
+
+impl<H: Hasher> From<Storage> for TestExternalities<H>
+where
+	H::Out: Ord + 'static + codec::Codec,
+{
+	fn from(storage: Storage) -> Self {
+		Self::new_with_state_version(storage, Default::default())
+	}
+}
+
+impl<H: Hasher> From<(Storage, StateVersion)> for TestExternalities<H>
+where
+	H::Out: Ord + 'static + codec::Codec,
+{
+	fn from((storage, state_version): (Storage, StateVersion)) -> Self {
+		Self::new_with_state_version(storage, state_version)
+	}
+}
+
+impl<H> sp_externalities::ExtensionStore for TestExternalities<H>
+where
+	H: Hasher,
+	H::Out: Ord + codec::Codec,
+{
+	fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any> {
+		self.extensions.get_mut(type_id)
+	}
+
+	fn register_extension_with_type_id(
+		&mut self,
+		type_id: TypeId,
+		extension: Box<dyn Extension>,
+	) -> Result<(), sp_externalities::Error> {
+		self.extensions.register_with_type_id(type_id, extension)
+	}
+
+	fn deregister_extension_by_type_id(
+		&mut self,
+		type_id: TypeId,
+	) -> Result<(), sp_externalities::Error> {
+		if self.extensions.deregister(type_id) {
+			Ok(())
+		} else {
+			Err(sp_externalities::Error::ExtensionIsNotRegistered(type_id))
+		}
+	}
+}
+
+impl<H> sp_externalities::ExternalitiesExt for TestExternalities<H>
+where
+	H: Hasher,
+	H::Out: Ord + codec::Codec,
+{
+	fn extension<T: Any + Extension>(&mut self) -> Option<&mut T> {
+		self.extension_by_type_id(TypeId::of::<T>()).and_then(<dyn Any>::downcast_mut)
+	}
+
+	fn register_extension<T: Extension>(&mut self, ext: T) -> Result<(), sp_externalities::Error> {
+		self.register_extension_with_type_id(TypeId::of::<T>(), Box::new(ext))
+	}
+
+	fn deregister_extension<T: Extension>(&mut self) -> Result<(), sp_externalities::Error> {
+		self.deregister_extension_by_type_id(TypeId::of::<T>())
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::{storage::ChildInfo, traits::Externalities, H256};
+	use sp_runtime::traits::BlakeTwo256;
+
+	#[test]
+	fn commit_should_work() {
+		let storage = Storage::default(); // avoid adding the trie threshold.
+		let mut ext = TestExternalities::<BlakeTwo256>::from((storage, Default::default()));
+		let mut ext = ext.ext();
+		ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
+		ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
+		ext.set_storage(b"dogglesworth".to_vec(), b"cat".to_vec());
+		let root = array_bytes::hex_n_into_unchecked::<_, H256, 32>(
+			"ed4d8c799d996add422395a6abd7545491d40bd838d738afafa1b8a4de625489",
+		);
+		assert_eq!(H256::from_slice(ext.storage_root(Default::default()).as_slice()), root);
+	}
+
+	#[test]
+	fn raw_storage_drain_and_restore() {
+		// Create a TestExternalities with some data in it.
+		let mut original_ext =
+			TestExternalities::<BlakeTwo256>::from((Default::default(), Default::default()));
+		original_ext.insert(b"doe".to_vec(), b"reindeer".to_vec());
+		original_ext.insert(b"dog".to_vec(), b"puppy".to_vec());
+		original_ext.insert(b"dogglesworth".to_vec(), b"cat".to_vec());
+		let child_info = ChildInfo::new_default(&b"test_child"[..]);
+		original_ext.insert_child(child_info.clone(), b"cattytown".to_vec(), b"is_dark".to_vec());
+		original_ext.insert_child(child_info.clone(), b"doggytown".to_vec(), b"is_sunny".to_vec());
+
+		// Apply the backend to itself again to increase the ref count of all nodes.
+		original_ext.backend.apply_transaction(
+			*original_ext.backend.root(),
+			original_ext.backend.clone().into_storage(),
+		);
+
+		// Ensure all have the correct ref counrt
+		assert!(original_ext.backend.backend_storage().keys().values().all(|r| *r == 2));
+
+		// Drain the raw storage and root.
+		let root = *original_ext.backend.root();
+		let (raw_storage, storage_root) = original_ext.into_raw_snapshot();
+
+		// Load the raw storage and root into a new TestExternalities.
+		let recovered_ext = TestExternalities::<BlakeTwo256>::from_raw_snapshot(
+			raw_storage,
+			storage_root,
+			Default::default(),
+		);
+
+		// Check the storage root is the same as the original
+		assert_eq!(root, *recovered_ext.backend.root());
+
+		// Check the original storage key/values were recovered correctly
+		assert_eq!(recovered_ext.backend.storage(b"doe").unwrap(), Some(b"reindeer".to_vec()));
+		assert_eq!(recovered_ext.backend.storage(b"dog").unwrap(), Some(b"puppy".to_vec()));
+		assert_eq!(recovered_ext.backend.storage(b"dogglesworth").unwrap(), Some(b"cat".to_vec()));
+
+		// Check the original child storage key/values were recovered correctly
+		assert_eq!(
+			recovered_ext.backend.child_storage(&child_info, b"cattytown").unwrap(),
+			Some(b"is_dark".to_vec())
+		);
+		assert_eq!(
+			recovered_ext.backend.child_storage(&child_info, b"doggytown").unwrap(),
+			Some(b"is_sunny".to_vec())
+		);
+
+		// Ensure all have the correct ref count after importing
+		assert!(recovered_ext.backend.backend_storage().keys().values().all(|r| *r == 2));
+	}
+
+	#[test]
+	fn set_and_retrieve_code() {
+		let mut ext = TestExternalities::<BlakeTwo256>::default();
+		let mut ext = ext.ext();
+
+		let code = vec![1, 2, 3];
+		ext.set_storage(CODE.to_vec(), code.clone());
+
+		assert_eq!(&ext.storage(CODE).unwrap(), &code);
+	}
+
+	#[test]
+	fn check_send() {
+		fn assert_send<T: Send>() {}
+		assert_send::<TestExternalities<BlakeTwo256>>();
+	}
+
+	#[test]
+	fn commit_all_and_kill_child_storage() {
+		let mut ext = TestExternalities::<BlakeTwo256>::default();
+		let child_info = ChildInfo::new_default(&b"test_child"[..]);
+
+		{
+			let mut ext = ext.ext();
+			ext.place_child_storage(&child_info, b"doe".to_vec(), Some(b"reindeer".to_vec()));
+			ext.place_child_storage(&child_info, b"dog".to_vec(), Some(b"puppy".to_vec()));
+			ext.place_child_storage(&child_info, b"dog2".to_vec(), Some(b"puppy2".to_vec()));
+		}
+
+		ext.commit_all().unwrap();
+
+		{
+			let mut ext = ext.ext();
+
+			assert!(
+				ext.kill_child_storage(&child_info, Some(2), None).maybe_cursor.is_some(),
+				"Should not delete all keys"
+			);
+
+			assert!(ext.child_storage(&child_info, &b"doe"[..]).is_none());
+			assert!(ext.child_storage(&child_info, &b"dog"[..]).is_none());
+			assert!(ext.child_storage(&child_info, &b"dog2"[..]).is_some());
+		}
+	}
+
+	#[test]
+	fn as_backend_generates_same_backend_as_commit_all() {
+		let mut ext = TestExternalities::<BlakeTwo256>::default();
+		{
+			let mut ext = ext.ext();
+			ext.set_storage(b"doe".to_vec(), b"reindeer".to_vec());
+			ext.set_storage(b"dog".to_vec(), b"puppy".to_vec());
+			ext.set_storage(b"dogglesworth".to_vec(), b"cat".to_vec());
+		}
+
+		let backend = ext.as_backend();
+
+		ext.commit_all().unwrap();
+		assert!(ext.backend.eq(&backend), "Both backend should be equal.");
+	}
+}
diff --git a/substrate/primitives/state-machine/src/trie_backend.rs b/substrate/primitives/state-machine/src/trie_backend.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cc7132181f90a0ceab30a66b2d78a54798031b25
--- /dev/null
+++ b/substrate/primitives/state-machine/src/trie_backend.rs
@@ -0,0 +1,1546 @@
+// 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.
+
+//! Trie-based state machine backend.
+
+#[cfg(feature = "std")]
+use crate::backend::AsTrieBackend;
+use crate::{
+	backend::{IterArgs, StorageIterator},
+	trie_backend_essence::{RawIter, TrieBackendEssence, TrieBackendStorage},
+	Backend, StorageKey, StorageValue,
+};
+
+use codec::Codec;
+#[cfg(feature = "std")]
+use hash_db::HashDB;
+use hash_db::Hasher;
+use sp_core::storage::{ChildInfo, StateVersion};
+use sp_trie::PrefixedMemoryDB;
+#[cfg(feature = "std")]
+use sp_trie::{
+	cache::{LocalTrieCache, TrieCache},
+	recorder::Recorder,
+	MemoryDB, StorageProof,
+};
+#[cfg(not(feature = "std"))]
+use sp_trie::{Error, NodeCodec};
+use trie_db::TrieCache as TrieCacheT;
+#[cfg(not(feature = "std"))]
+use trie_db::{node::NodeOwned, CachedValue};
+
+/// A provider of trie caches that are compatible with [`trie_db::TrieDB`].
+pub trait TrieCacheProvider<H: Hasher> {
+	/// Cache type that implements [`trie_db::TrieCache`].
+	type Cache<'a>: TrieCacheT<sp_trie::NodeCodec<H>> + 'a
+	where
+		Self: 'a;
+
+	/// Return a [`trie_db::TrieDB`] compatible cache.
+	///
+	/// The `storage_root` parameter should be the storage root of the used trie.
+	fn as_trie_db_cache(&self, storage_root: H::Out) -> Self::Cache<'_>;
+
+	/// Returns a cache that can be used with a [`trie_db::TrieDBMut`].
+	///
+	/// When finished with the operation on the trie, it is required to call [`Self::merge`] to
+	/// merge the cached items for the correct `storage_root`.
+	fn as_trie_db_mut_cache(&self) -> Self::Cache<'_>;
+
+	/// Merge the cached data in `other` into the provider using the given `new_root`.
+	///
+	/// This must be used for the cache returned by [`Self::as_trie_db_mut_cache`] as otherwise the
+	/// cached data is just thrown away.
+	fn merge<'a>(&'a self, other: Self::Cache<'a>, new_root: H::Out);
+}
+
+#[cfg(feature = "std")]
+impl<H: Hasher> TrieCacheProvider<H> for LocalTrieCache<H> {
+	type Cache<'a> = TrieCache<'a, H> where H: 'a;
+
+	fn as_trie_db_cache(&self, storage_root: H::Out) -> Self::Cache<'_> {
+		self.as_trie_db_cache(storage_root)
+	}
+
+	fn as_trie_db_mut_cache(&self) -> Self::Cache<'_> {
+		self.as_trie_db_mut_cache()
+	}
+
+	fn merge<'a>(&'a self, other: Self::Cache<'a>, new_root: H::Out) {
+		other.merge_into(self, new_root)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<H: Hasher> TrieCacheProvider<H> for &LocalTrieCache<H> {
+	type Cache<'a> = TrieCache<'a, H> where Self: 'a;
+
+	fn as_trie_db_cache(&self, storage_root: H::Out) -> Self::Cache<'_> {
+		(*self).as_trie_db_cache(storage_root)
+	}
+
+	fn as_trie_db_mut_cache(&self) -> Self::Cache<'_> {
+		(*self).as_trie_db_mut_cache()
+	}
+
+	fn merge<'a>(&'a self, other: Self::Cache<'a>, new_root: H::Out) {
+		other.merge_into(self, new_root)
+	}
+}
+
+/// Cache provider that allows construction of a [`TrieBackend`] and satisfies the requirements, but
+/// can never be instantiated.
+#[cfg(not(feature = "std"))]
+pub struct UnimplementedCacheProvider<H> {
+	// Not strictly necessary, but the H bound allows to use this as a drop-in
+	// replacement for the `LocalTrieCache` in no-std contexts.
+	_phantom: core::marker::PhantomData<H>,
+	// Statically prevents construction.
+	_infallible: core::convert::Infallible,
+}
+
+#[cfg(not(feature = "std"))]
+impl<H: Hasher> trie_db::TrieCache<NodeCodec<H>> for UnimplementedCacheProvider<H> {
+	fn lookup_value_for_key(&mut self, _key: &[u8]) -> Option<&CachedValue<H::Out>> {
+		unimplemented!()
+	}
+
+	fn cache_value_for_key(&mut self, _key: &[u8], _value: CachedValue<H::Out>) {
+		unimplemented!()
+	}
+
+	fn get_or_insert_node(
+		&mut self,
+		_hash: H::Out,
+		_fetch_node: &mut dyn FnMut() -> trie_db::Result<NodeOwned<H::Out>, H::Out, Error<H::Out>>,
+	) -> trie_db::Result<&NodeOwned<H::Out>, H::Out, Error<H::Out>> {
+		unimplemented!()
+	}
+
+	fn get_node(&mut self, _hash: &H::Out) -> Option<&NodeOwned<H::Out>> {
+		unimplemented!()
+	}
+}
+
+#[cfg(not(feature = "std"))]
+impl<H: Hasher> TrieCacheProvider<H> for UnimplementedCacheProvider<H> {
+	type Cache<'a> = UnimplementedCacheProvider<H> where H: 'a;
+
+	fn as_trie_db_cache(&self, _storage_root: <H as Hasher>::Out) -> Self::Cache<'_> {
+		unimplemented!()
+	}
+
+	fn as_trie_db_mut_cache(&self) -> Self::Cache<'_> {
+		unimplemented!()
+	}
+
+	fn merge<'a>(&'a self, _other: Self::Cache<'a>, _new_root: <H as Hasher>::Out) {
+		unimplemented!()
+	}
+}
+
+#[cfg(feature = "std")]
+type DefaultCache<H> = LocalTrieCache<H>;
+
+#[cfg(not(feature = "std"))]
+type DefaultCache<H> = UnimplementedCacheProvider<H>;
+
+/// Builder for creating a [`TrieBackend`].
+pub struct TrieBackendBuilder<S: TrieBackendStorage<H>, H: Hasher, C = DefaultCache<H>> {
+	storage: S,
+	root: H::Out,
+	#[cfg(feature = "std")]
+	recorder: Option<Recorder<H>>,
+	cache: Option<C>,
+}
+
+impl<S, H> TrieBackendBuilder<S, H, DefaultCache<H>>
+where
+	S: TrieBackendStorage<H>,
+	H: Hasher,
+{
+	/// Create a new builder instance.
+	pub fn new(storage: S, root: H::Out) -> Self {
+		Self {
+			storage,
+			root,
+			#[cfg(feature = "std")]
+			recorder: None,
+			cache: None,
+		}
+	}
+}
+
+impl<S, H, C> TrieBackendBuilder<S, H, C>
+where
+	S: TrieBackendStorage<H>,
+	H: Hasher,
+{
+	/// Create a new builder instance.
+	pub fn new_with_cache(storage: S, root: H::Out, cache: C) -> Self {
+		Self {
+			storage,
+			root,
+			#[cfg(feature = "std")]
+			recorder: None,
+			cache: Some(cache),
+		}
+	}
+	/// Wrap the given [`TrieBackend`].
+	///
+	/// This can be used for example if all accesses to the trie should
+	/// be recorded while some other functionality still uses the non-recording
+	/// backend.
+	///
+	/// The backend storage and the cache will be taken from `other`.
+	pub fn wrap(other: &TrieBackend<S, H, C>) -> TrieBackendBuilder<&S, H, &C> {
+		TrieBackendBuilder {
+			storage: other.essence.backend_storage(),
+			root: *other.essence.root(),
+			#[cfg(feature = "std")]
+			recorder: None,
+			cache: other.essence.trie_node_cache.as_ref(),
+		}
+	}
+
+	/// Use the given optional `recorder` for the to be configured [`TrieBackend`].
+	#[cfg(feature = "std")]
+	pub fn with_optional_recorder(self, recorder: Option<Recorder<H>>) -> Self {
+		Self { recorder, ..self }
+	}
+
+	/// Use the given `recorder` for the to be configured [`TrieBackend`].
+	#[cfg(feature = "std")]
+	pub fn with_recorder(self, recorder: Recorder<H>) -> Self {
+		Self { recorder: Some(recorder), ..self }
+	}
+
+	/// Use the given optional `cache` for the to be configured [`TrieBackend`].
+	pub fn with_optional_cache<LC>(self, cache: Option<LC>) -> TrieBackendBuilder<S, H, LC> {
+		TrieBackendBuilder {
+			cache,
+			root: self.root,
+			storage: self.storage,
+			#[cfg(feature = "std")]
+			recorder: self.recorder,
+		}
+	}
+
+	/// Use the given `cache` for the to be configured [`TrieBackend`].
+	pub fn with_cache<LC>(self, cache: LC) -> TrieBackendBuilder<S, H, LC> {
+		TrieBackendBuilder {
+			cache: Some(cache),
+			root: self.root,
+			storage: self.storage,
+			#[cfg(feature = "std")]
+			recorder: self.recorder,
+		}
+	}
+
+	/// Build the configured [`TrieBackend`].
+	#[cfg(feature = "std")]
+	pub fn build(self) -> TrieBackend<S, H, C> {
+		TrieBackend {
+			essence: TrieBackendEssence::new_with_cache_and_recorder(
+				self.storage,
+				self.root,
+				self.cache,
+				self.recorder,
+			),
+			next_storage_key_cache: Default::default(),
+		}
+	}
+
+	/// Build the configured [`TrieBackend`].
+	#[cfg(not(feature = "std"))]
+	pub fn build(self) -> TrieBackend<S, H, C> {
+		TrieBackend {
+			essence: TrieBackendEssence::new_with_cache(self.storage, self.root, self.cache),
+			next_storage_key_cache: Default::default(),
+		}
+	}
+}
+
+/// A cached iterator.
+struct CachedIter<S, H, C>
+where
+	H: Hasher,
+{
+	last_key: sp_std::vec::Vec<u8>,
+	iter: RawIter<S, H, C>,
+}
+
+impl<S, H, C> Default for CachedIter<S, H, C>
+where
+	H: Hasher,
+{
+	fn default() -> Self {
+		Self { last_key: Default::default(), iter: Default::default() }
+	}
+}
+
+#[cfg(feature = "std")]
+type CacheCell<T> = parking_lot::Mutex<T>;
+
+#[cfg(not(feature = "std"))]
+type CacheCell<T> = core::cell::RefCell<T>;
+
+#[cfg(feature = "std")]
+fn access_cache<T, R>(cell: &CacheCell<T>, callback: impl FnOnce(&mut T) -> R) -> R {
+	callback(&mut *cell.lock())
+}
+
+#[cfg(not(feature = "std"))]
+fn access_cache<T, R>(cell: &CacheCell<T>, callback: impl FnOnce(&mut T) -> R) -> R {
+	callback(&mut *cell.borrow_mut())
+}
+
+/// Patricia trie-based backend. Transaction type is an overlay of changes to commit.
+pub struct TrieBackend<S: TrieBackendStorage<H>, H: Hasher, C = DefaultCache<H>> {
+	pub(crate) essence: TrieBackendEssence<S, H, C>,
+	next_storage_key_cache: CacheCell<Option<CachedIter<S, H, C>>>,
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H> + Send + Sync>
+	TrieBackend<S, H, C>
+where
+	H::Out: Codec,
+{
+	#[cfg(test)]
+	pub(crate) fn from_essence(essence: TrieBackendEssence<S, H, C>) -> Self {
+		Self { essence, next_storage_key_cache: Default::default() }
+	}
+
+	/// Get backend essence reference.
+	pub fn essence(&self) -> &TrieBackendEssence<S, H, C> {
+		&self.essence
+	}
+
+	/// Get backend storage reference.
+	pub fn backend_storage_mut(&mut self) -> &mut S {
+		self.essence.backend_storage_mut()
+	}
+
+	/// Get backend storage reference.
+	pub fn backend_storage(&self) -> &S {
+		self.essence.backend_storage()
+	}
+
+	/// Set trie root.
+	pub fn set_root(&mut self, root: H::Out) {
+		self.essence.set_root(root)
+	}
+
+	/// Get trie root.
+	pub fn root(&self) -> &H::Out {
+		self.essence.root()
+	}
+
+	/// Consumes self and returns underlying storage.
+	pub fn into_storage(self) -> S {
+		self.essence.into_storage()
+	}
+
+	/// Extract the [`StorageProof`].
+	///
+	/// This only returns `Some` when there was a recorder set.
+	#[cfg(feature = "std")]
+	pub fn extract_proof(mut self) -> Option<StorageProof> {
+		self.essence.recorder.take().map(|r| r.drain_storage_proof())
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H>> sp_std::fmt::Debug
+	for TrieBackend<S, H, C>
+{
+	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
+		write!(f, "TrieBackend")
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H> + Send + Sync> Backend<H>
+	for TrieBackend<S, H, C>
+where
+	H::Out: Ord + Codec,
+{
+	type Error = crate::DefaultError;
+	type TrieBackendStorage = S;
+	type RawIter = crate::trie_backend_essence::RawIter<S, H, C>;
+
+	fn storage_hash(&self, key: &[u8]) -> Result<Option<H::Out>, Self::Error> {
+		self.essence.storage_hash(key)
+	}
+
+	fn storage(&self, key: &[u8]) -> Result<Option<StorageValue>, Self::Error> {
+		self.essence.storage(key)
+	}
+
+	fn child_storage_hash(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<H::Out>, Self::Error> {
+		self.essence.child_storage_hash(child_info, key)
+	}
+
+	fn child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<StorageValue>, Self::Error> {
+		self.essence.child_storage(child_info, key)
+	}
+
+	fn next_storage_key(&self, key: &[u8]) -> Result<Option<StorageKey>, Self::Error> {
+		let (is_cached, mut cache) = access_cache(&self.next_storage_key_cache, Option::take)
+			.map(|cache| (cache.last_key == key, cache))
+			.unwrap_or_default();
+
+		if !is_cached {
+			cache.iter = self.raw_iter(IterArgs {
+				start_at: Some(key),
+				start_at_exclusive: true,
+				..IterArgs::default()
+			})?
+		};
+
+		let next_key = match cache.iter.next_key(self) {
+			None => return Ok(None),
+			Some(Err(error)) => return Err(error),
+			Some(Ok(next_key)) => next_key,
+		};
+
+		cache.last_key.clear();
+		cache.last_key.extend_from_slice(&next_key);
+		access_cache(&self.next_storage_key_cache, |cache_cell| cache_cell.replace(cache));
+
+		#[cfg(debug_assertions)]
+		debug_assert_eq!(
+			self.essence
+				.next_storage_key_slow(key)
+				.expect(
+					"fetching the next key through iterator didn't fail so this shouldn't either"
+				)
+				.as_ref(),
+			Some(&next_key)
+		);
+
+		Ok(Some(next_key))
+	}
+
+	fn next_child_storage_key(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<StorageKey>, Self::Error> {
+		self.essence.next_child_storage_key(child_info, key)
+	}
+
+	fn raw_iter(&self, args: IterArgs) -> Result<Self::RawIter, Self::Error> {
+		self.essence.raw_iter(args)
+	}
+
+	fn storage_root<'a>(
+		&self,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (H::Out, PrefixedMemoryDB<H>)
+	where
+		H::Out: Ord,
+	{
+		self.essence.storage_root(delta, state_version)
+	}
+
+	fn child_storage_root<'a>(
+		&self,
+		child_info: &ChildInfo,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (H::Out, bool, PrefixedMemoryDB<H>)
+	where
+		H::Out: Ord,
+	{
+		self.essence.child_storage_root(child_info, delta, state_version)
+	}
+
+	fn register_overlay_stats(&self, _stats: &crate::stats::StateMachineStats) {}
+
+	fn usage_info(&self) -> crate::UsageInfo {
+		crate::UsageInfo::empty()
+	}
+
+	fn wipe(&self) -> Result<(), Self::Error> {
+		Ok(())
+	}
+}
+
+#[cfg(feature = "std")]
+impl<S: TrieBackendStorage<H>, H: Hasher, C> AsTrieBackend<H, C> for TrieBackend<S, H, C> {
+	type TrieBackendStorage = S;
+
+	fn as_trie_backend(&self) -> &TrieBackend<S, H, C> {
+		self
+	}
+}
+
+/// Create a backend used for checking the proof, using `H` as hasher.
+///
+/// `proof` and `root` must match, i.e. `root` must be the correct root of `proof` nodes.
+#[cfg(feature = "std")]
+pub fn create_proof_check_backend<H>(
+	root: H::Out,
+	proof: StorageProof,
+) -> Result<TrieBackend<MemoryDB<H>, H>, Box<dyn crate::Error>>
+where
+	H: Hasher,
+	H::Out: Codec,
+{
+	let db = proof.into_memory_db();
+
+	if db.contains(&root, hash_db::EMPTY_PREFIX) {
+		Ok(TrieBackendBuilder::new(db, root).build())
+	} else {
+		Err(Box::new(crate::ExecutionError::InvalidProof))
+	}
+}
+
+#[cfg(test)]
+pub mod tests {
+	use crate::{new_in_mem, InMemoryBackend};
+
+	use super::*;
+	use codec::Encode;
+	use sp_core::H256;
+	use sp_runtime::traits::BlakeTwo256;
+	use sp_trie::{
+		cache::{CacheSize, SharedTrieCache},
+		trie_types::{TrieDBBuilder, TrieDBMutBuilderV0, TrieDBMutBuilderV1},
+		KeySpacedDBMut, PrefixedMemoryDB, Trie, TrieCache, TrieMut,
+	};
+	use std::iter;
+	use trie_db::NodeCodec;
+
+	const CHILD_KEY_1: &[u8] = b"sub1";
+
+	type Recorder = sp_trie::recorder::Recorder<BlakeTwo256>;
+	type Cache = LocalTrieCache<BlakeTwo256>;
+	type SharedCache = SharedTrieCache<BlakeTwo256>;
+
+	macro_rules! parameterized_test {
+		($name:ident, $internal_name:ident) => {
+			#[test]
+			fn $name() {
+				let parameters = vec![
+					(StateVersion::V0, None, None),
+					(StateVersion::V0, Some(SharedCache::new(CacheSize::unlimited())), None),
+					(StateVersion::V0, None, Some(Recorder::default())),
+					(
+						StateVersion::V0,
+						Some(SharedCache::new(CacheSize::unlimited())),
+						Some(Recorder::default()),
+					),
+					(StateVersion::V1, None, None),
+					(StateVersion::V1, Some(SharedCache::new(CacheSize::unlimited())), None),
+					(StateVersion::V1, None, Some(Recorder::default())),
+					(
+						StateVersion::V1,
+						Some(SharedCache::new(CacheSize::unlimited())),
+						Some(Recorder::default()),
+					),
+				];
+
+				for (version, cache, recorder) in parameters {
+					eprintln!(
+						"Running with version {:?}, cache enabled {} and recorder enabled {}",
+						version,
+						cache.is_some(),
+						recorder.is_some()
+					);
+
+					let cache = cache.as_ref().map(|c| c.local_cache());
+
+					$internal_name(version, cache, recorder.clone());
+				}
+			}
+		};
+	}
+
+	pub(crate) fn test_db(state_version: StateVersion) -> (PrefixedMemoryDB<BlakeTwo256>, H256) {
+		let child_info = ChildInfo::new_default(CHILD_KEY_1);
+		let mut root = H256::default();
+		let mut mdb = PrefixedMemoryDB::<BlakeTwo256>::default();
+		{
+			let mut mdb = KeySpacedDBMut::new(&mut mdb, child_info.keyspace());
+			match state_version {
+				StateVersion::V0 => {
+					let mut trie = TrieDBMutBuilderV0::new(&mut mdb, &mut root).build();
+					trie.insert(b"value3", &[142; 33]).expect("insert failed");
+					trie.insert(b"value4", &[124; 33]).expect("insert failed");
+				},
+				StateVersion::V1 => {
+					let mut trie = TrieDBMutBuilderV1::new(&mut mdb, &mut root).build();
+					trie.insert(b"value3", &[142; 33]).expect("insert failed");
+					trie.insert(b"value4", &[124; 33]).expect("insert failed");
+				},
+			};
+		};
+
+		{
+			let mut sub_root = Vec::new();
+			root.encode_to(&mut sub_root);
+
+			fn build<L: sp_trie::TrieLayout>(
+				mut trie: sp_trie::TrieDBMut<L>,
+				child_info: &ChildInfo,
+				sub_root: &[u8],
+			) {
+				trie.insert(child_info.prefixed_storage_key().as_slice(), sub_root)
+					.expect("insert failed");
+				trie.insert(b"key", b"value").expect("insert failed");
+				trie.insert(b"value1", &[42]).expect("insert failed");
+				trie.insert(b"value2", &[24]).expect("insert failed");
+				trie.insert(b":code", b"return 42").expect("insert failed");
+				for i in 128u8..255u8 {
+					trie.insert(&[i], &[i]).unwrap();
+				}
+			}
+
+			match state_version {
+				StateVersion::V0 => {
+					let trie = TrieDBMutBuilderV0::new(&mut mdb, &mut root).build();
+					build(trie, &child_info, &sub_root[..])
+				},
+				StateVersion::V1 => {
+					let trie = TrieDBMutBuilderV1::new(&mut mdb, &mut root).build();
+					build(trie, &child_info, &sub_root[..])
+				},
+			};
+		}
+		(mdb, root)
+	}
+
+	pub(crate) fn test_db_with_hex_keys(
+		state_version: StateVersion,
+		keys: &[&str],
+	) -> (PrefixedMemoryDB<BlakeTwo256>, H256) {
+		let mut root = H256::default();
+		let mut mdb = PrefixedMemoryDB::<BlakeTwo256>::default();
+		match state_version {
+			StateVersion::V0 => {
+				let mut trie = TrieDBMutBuilderV0::new(&mut mdb, &mut root).build();
+				for (index, key) in keys.iter().enumerate() {
+					trie.insert(&array_bytes::hex2bytes(key).unwrap(), &[index as u8]).unwrap();
+				}
+			},
+			StateVersion::V1 => {
+				let mut trie = TrieDBMutBuilderV1::new(&mut mdb, &mut root).build();
+				for (index, key) in keys.iter().enumerate() {
+					trie.insert(&array_bytes::hex2bytes(key).unwrap(), &[index as u8]).unwrap();
+				}
+			},
+		};
+		(mdb, root)
+	}
+
+	pub(crate) fn test_trie(
+		hashed_value: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) -> TrieBackend<PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256> {
+		let (mdb, root) = test_db(hashed_value);
+
+		TrieBackendBuilder::new(mdb, root)
+			.with_optional_cache(cache)
+			.with_optional_recorder(recorder)
+			.build()
+	}
+
+	pub(crate) fn test_trie_with_hex_keys(
+		hashed_value: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+		keys: &[&str],
+	) -> TrieBackend<PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256> {
+		let (mdb, root) = test_db_with_hex_keys(hashed_value, keys);
+
+		TrieBackendBuilder::new(mdb, root)
+			.with_optional_cache(cache)
+			.with_optional_recorder(recorder)
+			.build()
+	}
+
+	parameterized_test!(read_from_storage_returns_some, read_from_storage_returns_some_inner);
+	fn read_from_storage_returns_some_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		assert_eq!(
+			test_trie(state_version, cache, recorder).storage(b"key").unwrap(),
+			Some(b"value".to_vec())
+		);
+	}
+
+	parameterized_test!(
+		read_from_child_storage_returns_some,
+		read_from_child_storage_returns_some_inner
+	);
+	fn read_from_child_storage_returns_some_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let test_trie = test_trie(state_version, cache, recorder);
+		assert_eq!(
+			test_trie
+				.child_storage(&ChildInfo::new_default(CHILD_KEY_1), b"value3")
+				.unwrap(),
+			Some(vec![142u8; 33]),
+		);
+		// Change cache entry to check that caching is active.
+		test_trie
+			.essence
+			.cache
+			.write()
+			.child_root
+			.entry(b"sub1".to_vec())
+			.and_modify(|value| {
+				*value = None;
+			});
+		assert_eq!(
+			test_trie
+				.child_storage(&ChildInfo::new_default(CHILD_KEY_1), b"value3")
+				.unwrap(),
+			None,
+		);
+	}
+
+	parameterized_test!(read_from_storage_returns_none, read_from_storage_returns_none_inner);
+	fn read_from_storage_returns_none_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		assert_eq!(
+			test_trie(state_version, cache, recorder).storage(b"non-existing-key").unwrap(),
+			None
+		);
+	}
+
+	parameterized_test!(
+		pairs_are_not_empty_on_non_empty_storage,
+		pairs_are_not_empty_on_non_empty_storage_inner
+	);
+	fn pairs_are_not_empty_on_non_empty_storage_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		assert!(!test_trie(state_version, cache, recorder)
+			.pairs(Default::default())
+			.unwrap()
+			.next()
+			.is_none());
+	}
+
+	#[test]
+	fn pairs_are_empty_on_empty_storage() {
+		assert!(TrieBackendBuilder::<PrefixedMemoryDB<BlakeTwo256>, BlakeTwo256>::new(
+			PrefixedMemoryDB::default(),
+			Default::default(),
+		)
+		.build()
+		.pairs(Default::default())
+		.unwrap()
+		.next()
+		.is_none());
+	}
+
+	parameterized_test!(storage_iteration_works, storage_iteration_works_inner);
+	fn storage_iteration_works_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let trie = test_trie(state_version, cache, recorder);
+
+		// Fetch everything.
+		assert_eq!(
+			trie.keys(Default::default())
+				.unwrap()
+				.map(|result| result.unwrap())
+				.take(5)
+				.collect::<Vec<_>>(),
+			vec![
+				b":child_storage:default:sub1".to_vec(),
+				b":code".to_vec(),
+				b"key".to_vec(),
+				b"value1".to_vec(),
+				b"value2".to_vec(),
+			]
+		);
+
+		// Fetch starting at a given key (full key).
+		assert_eq!(
+			trie.keys(IterArgs { start_at: Some(b"key"), ..IterArgs::default() })
+				.unwrap()
+				.map(|result| result.unwrap())
+				.take(3)
+				.collect::<Vec<_>>(),
+			vec![b"key".to_vec(), b"value1".to_vec(), b"value2".to_vec(),]
+		);
+
+		// Fetch starting at a given key (partial key).
+		assert_eq!(
+			trie.keys(IterArgs { start_at: Some(b"ke"), ..IterArgs::default() })
+				.unwrap()
+				.map(|result| result.unwrap())
+				.take(3)
+				.collect::<Vec<_>>(),
+			vec![b"key".to_vec(), b"value1".to_vec(), b"value2".to_vec(),]
+		);
+
+		// Fetch starting at a given key (empty key).
+		assert_eq!(
+			trie.keys(IterArgs { start_at: Some(b""), ..IterArgs::default() })
+				.unwrap()
+				.map(|result| result.unwrap())
+				.take(5)
+				.collect::<Vec<_>>(),
+			vec![
+				b":child_storage:default:sub1".to_vec(),
+				b":code".to_vec(),
+				b"key".to_vec(),
+				b"value1".to_vec(),
+				b"value2".to_vec(),
+			]
+		);
+
+		// Fetch starting at a given key and with prefix which doesn't match that key.
+		// (Start *before* the prefix.)
+		assert_eq!(
+			trie.keys(IterArgs {
+				prefix: Some(b"value"),
+				start_at: Some(b"key"),
+				..IterArgs::default()
+			})
+			.unwrap()
+			.map(|result| result.unwrap())
+			.collect::<Vec<_>>(),
+			vec![b"value1".to_vec(), b"value2".to_vec(),]
+		);
+
+		// Fetch starting at a given key and with prefix which doesn't match that key.
+		// (Start *after* the prefix.)
+		assert!(trie
+			.keys(IterArgs {
+				prefix: Some(b"value"),
+				start_at: Some(b"vblue"),
+				..IterArgs::default()
+			})
+			.unwrap()
+			.map(|result| result.unwrap())
+			.next()
+			.is_none());
+
+		// Fetch starting at a given key and with prefix which does match that key.
+		assert_eq!(
+			trie.keys(IterArgs {
+				prefix: Some(b"value"),
+				start_at: Some(b"value"),
+				..IterArgs::default()
+			})
+			.unwrap()
+			.map(|result| result.unwrap())
+			.collect::<Vec<_>>(),
+			vec![b"value1".to_vec(), b"value2".to_vec(),]
+		);
+	}
+
+	// This test reproduces an actual real-world issue: https://github.com/polkadot-js/apps/issues/9103
+	parameterized_test!(
+		storage_iter_does_not_return_out_of_prefix_keys,
+		storage_iter_does_not_return_out_of_prefix_keys_inner
+	);
+	fn storage_iter_does_not_return_out_of_prefix_keys_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let trie = test_trie_with_hex_keys(state_version, cache, recorder, &[
+			"6cf4040bbce30824850f1a4823d8c65faeefaa25a5bae16a431719647c1d99da",
+			"6cf4040bbce30824850f1a4823d8c65ff536928ca5ba50039bc2766a48ddbbab",
+			"70f943199f1a2dde80afdaf3f447db834e7b9012096b41c4eb3aaf947f6ea429",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d007fc7effcb0c044a0c41fd8a77eb55d2133058a86d1f4d6f8e45612cd271eefd77f91caeaacfe011b8f41540e0a793b0fd51b245dae19382b45386570f2b545fab75e3277910f7324b55f47c29f9965e8298371404e50ac",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d0179c23cd593c770fde9fc7aa8f84b3e401e654b8986c67728844da0080ec9ee222b41a85708a471a511548302870b53f40813d8354b6d2969e1b7ca9e083ecf96f9647e004ecb41c7f26f0110f778bdb3d9da31bef323d9",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d024de296f88310247001277477f4ace4d0aa5685ea2928d518a807956e4806a656520d6520b8ac259f684aa0d91961d76f697716f04e6c997338d03560ab7d703829fe7b9d0e6d7eff8d8412fc428364c2f474a67b36586d",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d13dc5d83f2361c14d05933eb3182a92ac14665718569703baf1da25c7d571843b6489f03d8549c87bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d1786d20bbb4b91eb1f5765432d750bd0111a0807c8d04f05110ffaf73f4fa7b360422c13bc97efc3a2324d9fa8f954b424c0bcfce7236a2e8107dd31c2042a9860a964f8472fda49749dec3f146e81470b55aa0f3930d854",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d18c246484ec5335a40903e7cd05771be7c0b8459333f1ae2925c3669fc3e5accd0f38c4711a15544bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d1aca749033252ce75245528397430d14cb8e8c09248d81ee5de00b6ae93ee880b6d19a595e6dc106bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d1d6bceb91bc07973e7b3296f83af9f1c4300ce9198cc3b44c54dafddb58f4a43aee44a9bef1a2e9dbfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d203383772f45721232139e1a8863b0f2f8d480bdc15bcc1f2033cf467e137059558da743838f6b58bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d2197cc5c3eb3a6a67538e0dc3eaaf8c820d71310d377499c4a5d276381789e0a234475e69cddf709d207458083d6146d3a36fce7f1fe05b232702bf154096e5e3a8c378bdc237d7a27909acd663563917f0f70bb0e8e61a3",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d4f19c117f2ea36100f753c4885aa8d63b4d65a0dc32106f829f89eeabd52c37105c9bdb75f752469729fa3f0e7d907c1d949192c8e264a1a510c32abe3a05ed50be2262d5bfb981673ec80a07fd2ce28c7f27cd0043a788c",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d547d5aaa651bafa63d077560dfe823ac75665ebf1dcfd96a06e45499f03dda31282977706918d4821b8f41540e0a793b0fd51b245dae19382b45386570f2b545fab75e3277910f7324b55f47c29f9965e8298371404e50ac",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d6037207d54d69a082ea225ab4a412e4b87d6f5612053b07c405cf05ea25e482a4908c0713be2998abfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d63d0920de0c7315ebaed1d639d926961d28af89461c31eca890441e449147d23bb7c9d4fc42d7c16bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d7912c66be82a5972e5bc11c8d10551a296ba9aaff8ca6ab22a8cd1987974b87a97121c871f786d2e17e0a629acf01c38947f170b7e02a9ebb4ee60f83779acb99b71114c01a4f0a60694611a1502c399c77214ffa26e955b",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d7aa00f217f3a374a2f1ca0f388719f84099e8157a8a83c5ccf54eae1617f93933fa976baa629e6febfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d9e1c3c8ab41943cf377b1aa724d7f518a3cfc96a732bdc4658155d09ed2bfc31b5ccbc6d8646b59f1b8f41540e0a793b0fd51b245dae19382b45386570f2b545fab75e3277910f7324b55f47c29f9965e8298371404e50ac",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d9fb8d6d95d5214a3305a4fa07e344eb99fad4be3565d646c8ac5af85514d9c96702c9c207be234958dbdb9185f467d2be3b84e8b2f529f7ec3844b378a889afd6bd31a9b5ed22ffee2019ad82c6692f1736dd41c8bb85726",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8d9fb8d6d95d5214a3305a4fa07e344eb99fad4be3565d646c8ac5af85514d9c96702c9c207be23495ec1caa509591a36a8403684384ce40838c9bd7fc49d933a10d3b26e979273e2f17ebf0bf41cd90e4287e126a59d5a243",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8da7fc066aae2ffe03b36e9a72f9a39cb2befac7e47f320309f31f1c1676288d9596045807304b3d79bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8daf3c377b0fddf7c7ad6d390fab0ab45ac16c21645be880af5cab2fbbeb04820401a4c9f766c17bef9fc14a2e16ade86fe26ee81d4497dc6aab81cc5f5bb0458d6149a763ecb09aefec06950dd61db1ba025401d2a04e3b9d",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8daf3c377b0fddf7c7ad6d390fab0ab45ac16c21645be880af5cab2fbbeb04820401a4c9f766c17befbfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8db60505ba8b77ef03ed805436d3242f26dc828084b12aaf4bcb96af468816a182b5360149398aad6b1dafe949b0918138ceef924f6393d1818a04842301294604972da17b24b31b155e4409a01273733b8d21a156c2e7eb71",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8dbd27136a6e028656073cc840bfabb48fe935880c4c4c990ee98458b2fed308e9765f7f7f717dd3b2862fa5361d3b55afa6040e582687403c852b2d065b24f253276cc581226991f8e1818a78fc64c39da7f0b383c6726e0f",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8dca40d91320edd326500f9e8b5a0b23a8bdf21549f98f0e014f66b6a18bdd78e337a6c05d670c80c88a55d4c7bb6fbae546e2d03ac9ab16e85fe11dad6adfd6a20618905477b831d7d48ca32d0bfd2bdc8dbeba26ffe2c710",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8dd27478512243ed62c1c1f7066021798a464d4cf9099546d5d9907b3369f1b9d7a5aa5d60ca845619bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8de6da5659cbbe1489abbe99c4d3a474f4d1e78edb55a9be68d8f52c6fe730388a298e6f6325db3da7bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8de6da5659cbbe1489abbe99c4d3a474f4d1e78edb55a9be68d8f52c6fe730388a298e6f6325db3da7e94ca3e8c297d82f71e232a2892992d1f6480475fb797ce64e58f773d8fafd9fbcee4bdf4b14f2a71b6d3a428cf9f24b",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8decdd1760c61ff7234f2876dbe817af803170233320d778b92043b2359e3de6d16c9e5359f6302da31c84d6f551ad2a831263ef956f0cdb3b4810cefcb2d0b57bcce7b82007016ae4fe752c31d1a01b589a7966cea03ec65c",
+			"7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8df9981ee6b69eb7af2153af34f39ffc06e2daa5272c99798c8849091284dc8905f2a76b65754c2089bfa5709836ba729443c319659e83ad5ee133e6f11af51d883e56216e9e1bbb1e2920c7c6120cbb55cd469b1f95b61601",
+			"7474449cca95dc5d0c00e71735a6d17d4e7b9012096b41c4eb3aaf947f6ea429",
+			"89d139e01a5eb2256f222e5fc5dbe6b33c9c1284130706f5aea0c8b3d4c54d89",
+			"89d139e01a5eb2256f222e5fc5dbe6b36254e9d55588784fa2a62b726696e2b1"
+		]);
+
+		let key = array_bytes::hex2bytes("7474449cca95dc5d0c00e71735a6d17d3cd15a3fd6e04e47bee3922dbfa92c8da7dad55cf08ffe8194efa962146801b0503092b1ed6a3fa6aee9107334aefd7965bbe568c3d24c6d").unwrap();
+
+		assert_eq!(
+			trie.keys(IterArgs {
+				prefix: Some(&key),
+				start_at: Some(&key),
+				start_at_exclusive: true,
+				..IterArgs::default()
+			})
+			.unwrap()
+			.map(|result| result.unwrap())
+			.collect::<Vec<_>>(),
+			Vec::<Vec<u8>>::new()
+		);
+	}
+
+	parameterized_test!(storage_root_is_non_default, storage_root_is_non_default_inner);
+	fn storage_root_is_non_default_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		assert!(
+			test_trie(state_version, cache, recorder)
+				.storage_root(iter::empty(), state_version)
+				.0 != H256::repeat_byte(0)
+		);
+	}
+
+	parameterized_test!(
+		storage_root_transaction_is_non_empty,
+		storage_root_transaction_is_non_empty_inner
+	);
+	fn storage_root_transaction_is_non_empty_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let (new_root, mut tx) = test_trie(state_version, cache, recorder)
+			.storage_root(iter::once((&b"new-key"[..], Some(&b"new-value"[..]))), state_version);
+		assert!(!tx.drain().is_empty());
+		assert!(
+			new_root !=
+				test_trie(state_version, None, None)
+					.storage_root(iter::empty(), state_version)
+					.0
+		);
+	}
+
+	parameterized_test!(
+		keys_with_empty_prefix_returns_all_keys,
+		keys_with_empty_prefix_returns_all_keys_inner
+	);
+	fn keys_with_empty_prefix_returns_all_keys_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let (test_db, test_root) = test_db(state_version);
+		let expected = TrieDBBuilder::new(&test_db, &test_root)
+			.build()
+			.iter()
+			.unwrap()
+			.map(|d| d.unwrap().0.to_vec())
+			.collect::<Vec<_>>();
+
+		let trie = test_trie(state_version, cache, recorder);
+		let keys: Vec<_> =
+			trie.keys(Default::default()).unwrap().map(|result| result.unwrap()).collect();
+
+		assert_eq!(expected, keys);
+	}
+
+	parameterized_test!(
+		proof_is_empty_until_value_is_read,
+		proof_is_empty_until_value_is_read_inner
+	);
+	fn proof_is_empty_until_value_is_read_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let trie_backend = test_trie(state_version, cache, recorder);
+		assert!(TrieBackendBuilder::wrap(&trie_backend)
+			.with_recorder(Recorder::default())
+			.build()
+			.extract_proof()
+			.unwrap()
+			.is_empty());
+	}
+
+	parameterized_test!(
+		proof_is_non_empty_after_value_is_read,
+		proof_is_non_empty_after_value_is_read_inner
+	);
+	fn proof_is_non_empty_after_value_is_read_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let trie_backend = test_trie(state_version, cache, recorder);
+		let backend = TrieBackendBuilder::wrap(&trie_backend)
+			.with_recorder(Recorder::default())
+			.build();
+		assert_eq!(backend.storage(b"key").unwrap(), Some(b"value".to_vec()));
+		assert!(!backend.extract_proof().unwrap().is_empty());
+	}
+
+	#[test]
+	fn proof_is_invalid_when_does_not_contains_root() {
+		let result = create_proof_check_backend::<BlakeTwo256>(
+			H256::from_low_u64_be(1),
+			StorageProof::empty(),
+		);
+		assert!(result.is_err());
+	}
+
+	parameterized_test!(passes_through_backend_calls, passes_through_backend_calls_inner);
+	fn passes_through_backend_calls_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let trie_backend = test_trie(state_version, cache, recorder);
+		let proving_backend = TrieBackendBuilder::wrap(&trie_backend)
+			.with_recorder(Recorder::default())
+			.build();
+		assert_eq!(trie_backend.storage(b"key").unwrap(), proving_backend.storage(b"key").unwrap());
+		assert_eq!(
+			trie_backend
+				.pairs(Default::default())
+				.unwrap()
+				.map(|result| result.unwrap())
+				.collect::<Vec<_>>(),
+			proving_backend
+				.pairs(Default::default())
+				.unwrap()
+				.map(|result| result.unwrap())
+				.collect::<Vec<_>>()
+		);
+
+		let (trie_root, mut trie_mdb) =
+			trie_backend.storage_root(std::iter::empty(), state_version);
+		let (proving_root, mut proving_mdb) =
+			proving_backend.storage_root(std::iter::empty(), state_version);
+		assert_eq!(trie_root, proving_root);
+		assert_eq!(trie_mdb.drain(), proving_mdb.drain());
+	}
+
+	#[test]
+	fn proof_recorded_and_checked_top() {
+		proof_recorded_and_checked_inner(StateVersion::V0);
+		proof_recorded_and_checked_inner(StateVersion::V1);
+	}
+	fn proof_recorded_and_checked_inner(state_version: StateVersion) {
+		let size_content = 34; // above hashable value threshold.
+		let value_range = 0..64;
+		let contents = value_range
+			.clone()
+			.map(|i| (vec![i], Some(vec![i; size_content])))
+			.collect::<Vec<_>>();
+		let in_memory = InMemoryBackend::<BlakeTwo256>::default();
+		let in_memory = in_memory.update(vec![(None, contents)], state_version);
+		let in_memory_root = in_memory.storage_root(std::iter::empty(), state_version).0;
+		value_range.clone().for_each(|i| {
+			assert_eq!(in_memory.storage(&[i]).unwrap().unwrap(), vec![i; size_content])
+		});
+
+		let trie = in_memory.as_trie_backend();
+		let trie_root = trie.storage_root(std::iter::empty(), state_version).0;
+		assert_eq!(in_memory_root, trie_root);
+		value_range
+			.clone()
+			.for_each(|i| assert_eq!(trie.storage(&[i]).unwrap().unwrap(), vec![i; size_content]));
+
+		for cache in [Some(SharedTrieCache::new(CacheSize::unlimited())), None] {
+			// Run multiple times to have a different cache conditions.
+			for i in 0..5 {
+				if let Some(cache) = &cache {
+					if i == 2 {
+						cache.reset_node_cache();
+					} else if i == 3 {
+						cache.reset_value_cache();
+					}
+				}
+
+				let proving = TrieBackendBuilder::wrap(&trie)
+					.with_recorder(Recorder::default())
+					.with_optional_cache(cache.as_ref().map(|c| c.local_cache()))
+					.build();
+				assert_eq!(proving.storage(&[42]).unwrap().unwrap(), vec![42; size_content]);
+
+				let proof = proving.extract_proof().unwrap();
+
+				let proof_check =
+					create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof)
+						.unwrap();
+				assert_eq!(proof_check.storage(&[42]).unwrap().unwrap(), vec![42; size_content]);
+			}
+		}
+	}
+
+	#[test]
+	fn proof_record_works_with_iter() {
+		proof_record_works_with_iter_inner(StateVersion::V0);
+		proof_record_works_with_iter_inner(StateVersion::V1);
+	}
+	fn proof_record_works_with_iter_inner(state_version: StateVersion) {
+		for cache in [Some(SharedTrieCache::new(CacheSize::unlimited())), None] {
+			// Run multiple times to have a different cache conditions.
+			for i in 0..5 {
+				if let Some(cache) = &cache {
+					if i == 2 {
+						cache.reset_node_cache();
+					} else if i == 3 {
+						cache.reset_value_cache();
+					}
+				}
+
+				let contents = (0..64).map(|i| (vec![i], Some(vec![i]))).collect::<Vec<_>>();
+				let in_memory = InMemoryBackend::<BlakeTwo256>::default();
+				let in_memory = in_memory.update(vec![(None, contents)], state_version);
+				let in_memory_root = in_memory.storage_root(std::iter::empty(), state_version).0;
+				(0..64)
+					.for_each(|i| assert_eq!(in_memory.storage(&[i]).unwrap().unwrap(), vec![i]));
+
+				let trie = in_memory.as_trie_backend();
+				let trie_root = trie.storage_root(std::iter::empty(), state_version).0;
+				assert_eq!(in_memory_root, trie_root);
+				(0..64).for_each(|i| assert_eq!(trie.storage(&[i]).unwrap().unwrap(), vec![i]));
+
+				let proving = TrieBackendBuilder::wrap(&trie)
+					.with_recorder(Recorder::default())
+					.with_optional_cache(cache.as_ref().map(|c| c.local_cache()))
+					.build();
+
+				(0..63).for_each(|i| {
+					assert_eq!(proving.next_storage_key(&[i]).unwrap(), Some(vec![i + 1]))
+				});
+
+				let proof = proving.extract_proof().unwrap();
+
+				let proof_check =
+					create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof)
+						.unwrap();
+				(0..63).for_each(|i| {
+					assert_eq!(proof_check.next_storage_key(&[i]).unwrap(), Some(vec![i + 1]))
+				});
+			}
+		}
+	}
+
+	#[test]
+	fn proof_recorded_and_checked_with_child() {
+		proof_recorded_and_checked_with_child_inner(StateVersion::V0);
+		proof_recorded_and_checked_with_child_inner(StateVersion::V1);
+	}
+	fn proof_recorded_and_checked_with_child_inner(state_version: StateVersion) {
+		let child_info_1 = ChildInfo::new_default(b"sub1");
+		let child_info_2 = ChildInfo::new_default(b"sub2");
+		let child_info_1 = &child_info_1;
+		let child_info_2 = &child_info_2;
+		let contents = vec![
+			(None, (0..64).map(|i| (vec![i], Some(vec![i]))).collect::<Vec<_>>()),
+			(Some(child_info_1.clone()), (28..65).map(|i| (vec![i], Some(vec![i]))).collect()),
+			(Some(child_info_2.clone()), (10..15).map(|i| (vec![i], Some(vec![i]))).collect()),
+		];
+		let in_memory = new_in_mem::<BlakeTwo256>();
+		let in_memory = in_memory.update(contents, state_version);
+		let child_storage_keys = vec![child_info_1.to_owned(), child_info_2.to_owned()];
+		let in_memory_root = in_memory
+			.full_storage_root(
+				std::iter::empty(),
+				child_storage_keys.iter().map(|k| (k, std::iter::empty())),
+				state_version,
+			)
+			.0;
+		(0..64).for_each(|i| assert_eq!(in_memory.storage(&[i]).unwrap().unwrap(), vec![i]));
+		(28..65).for_each(|i| {
+			assert_eq!(in_memory.child_storage(child_info_1, &[i]).unwrap().unwrap(), vec![i])
+		});
+		(10..15).for_each(|i| {
+			assert_eq!(in_memory.child_storage(child_info_2, &[i]).unwrap().unwrap(), vec![i])
+		});
+
+		for cache in [Some(SharedTrieCache::new(CacheSize::unlimited())), None] {
+			// Run multiple times to have a different cache conditions.
+			for i in 0..5 {
+				eprintln!("Running with cache {}, iteration {}", cache.is_some(), i);
+
+				if let Some(cache) = &cache {
+					if i == 2 {
+						cache.reset_node_cache();
+					} else if i == 3 {
+						cache.reset_value_cache();
+					}
+				}
+
+				let trie = in_memory.as_trie_backend();
+				let trie_root = trie.storage_root(std::iter::empty(), state_version).0;
+				assert_eq!(in_memory_root, trie_root);
+				(0..64).for_each(|i| assert_eq!(trie.storage(&[i]).unwrap().unwrap(), vec![i]));
+
+				let proving = TrieBackendBuilder::wrap(&trie)
+					.with_recorder(Recorder::default())
+					.with_optional_cache(cache.as_ref().map(|c| c.local_cache()))
+					.build();
+				assert_eq!(proving.storage(&[42]).unwrap().unwrap(), vec![42]);
+
+				let proof = proving.extract_proof().unwrap();
+
+				let proof_check =
+					create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof)
+						.unwrap();
+				assert!(proof_check.storage(&[0]).is_err());
+				assert_eq!(proof_check.storage(&[42]).unwrap().unwrap(), vec![42]);
+				// note that it is include in root because proof close
+				assert_eq!(proof_check.storage(&[41]).unwrap().unwrap(), vec![41]);
+				assert_eq!(proof_check.storage(&[64]).unwrap(), None);
+
+				let proving = TrieBackendBuilder::wrap(&trie)
+					.with_recorder(Recorder::default())
+					.with_optional_cache(cache.as_ref().map(|c| c.local_cache()))
+					.build();
+				assert_eq!(proving.child_storage(child_info_1, &[64]), Ok(Some(vec![64])));
+				assert_eq!(proving.child_storage(child_info_1, &[25]), Ok(None));
+				assert_eq!(proving.child_storage(child_info_2, &[14]), Ok(Some(vec![14])));
+				assert_eq!(proving.child_storage(child_info_2, &[25]), Ok(None));
+
+				let proof = proving.extract_proof().unwrap();
+				let proof_check =
+					create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof)
+						.unwrap();
+				assert_eq!(
+					proof_check.child_storage(child_info_1, &[64]).unwrap().unwrap(),
+					vec![64]
+				);
+				assert_eq!(proof_check.child_storage(child_info_1, &[25]).unwrap(), None);
+
+				assert_eq!(
+					proof_check.child_storage(child_info_2, &[14]).unwrap().unwrap(),
+					vec![14]
+				);
+				assert_eq!(proof_check.child_storage(child_info_2, &[25]).unwrap(), None);
+			}
+		}
+	}
+
+	/// This tests an edge case when recording a child trie access with a cache.
+	///
+	/// The accessed value/node is in the cache, but not the nodes to get to this value. So,
+	/// the recorder will need to traverse the trie to access these nodes from the backend when the
+	/// storage proof is generated.
+	#[test]
+	fn child_proof_recording_with_edge_cases_works() {
+		child_proof_recording_with_edge_cases_works_inner(StateVersion::V0);
+		child_proof_recording_with_edge_cases_works_inner(StateVersion::V1);
+	}
+	fn child_proof_recording_with_edge_cases_works_inner(state_version: StateVersion) {
+		let child_info_1 = ChildInfo::new_default(b"sub1");
+		let child_info_1 = &child_info_1;
+		let contents = vec![
+			(None, (0..64).map(|i| (vec![i], Some(vec![i]))).collect::<Vec<_>>()),
+			(
+				Some(child_info_1.clone()),
+				(28..65)
+					.map(|i| (vec![i], Some(vec![i])))
+					// Some big value to ensure we get a new node
+					.chain(std::iter::once((vec![65], Some(vec![65; 128]))))
+					.collect(),
+			),
+		];
+		let in_memory = new_in_mem::<BlakeTwo256>();
+		let in_memory = in_memory.update(contents, state_version);
+		let child_storage_keys = vec![child_info_1.to_owned()];
+		let in_memory_root = in_memory
+			.full_storage_root(
+				std::iter::empty(),
+				child_storage_keys.iter().map(|k| (k, std::iter::empty())),
+				state_version,
+			)
+			.0;
+
+		let child_1_root =
+			in_memory.child_storage_root(child_info_1, std::iter::empty(), state_version).0;
+		let trie = in_memory.as_trie_backend();
+		let nodes = {
+			let backend = TrieBackendBuilder::wrap(trie).with_recorder(Default::default()).build();
+			let value = backend.child_storage(child_info_1, &[65]).unwrap().unwrap();
+			let value_hash = BlakeTwo256::hash(&value);
+			assert_eq!(value, vec![65; 128]);
+
+			let proof = backend.extract_proof().unwrap();
+
+			let mut nodes = Vec::new();
+			for node in proof.into_iter_nodes() {
+				let hash = BlakeTwo256::hash(&node);
+				// Only insert the node/value that contains the important data.
+				if hash != value_hash {
+					let node = sp_trie::NodeCodec::<BlakeTwo256>::decode(&node)
+						.unwrap()
+						.to_owned_node::<sp_trie::LayoutV1<BlakeTwo256>>()
+						.unwrap();
+
+					if let Some(data) = node.data() {
+						if data == &vec![65; 128] {
+							nodes.push((hash, node));
+						}
+					}
+				} else if hash == value_hash {
+					nodes.push((hash, trie_db::node::NodeOwned::Value(node.into(), hash)));
+				}
+			}
+
+			nodes
+		};
+
+		let cache = SharedTrieCache::<BlakeTwo256>::new(CacheSize::unlimited());
+		{
+			let local_cache = cache.local_cache();
+			let mut trie_cache = local_cache.as_trie_db_cache(child_1_root);
+
+			// Put the value/node into the cache.
+			for (hash, node) in nodes {
+				trie_cache.get_or_insert_node(hash, &mut || Ok(node.clone())).unwrap();
+
+				if let Some(data) = node.data() {
+					trie_cache.cache_value_for_key(&[65], (data.clone(), hash).into());
+				}
+			}
+		}
+
+		{
+			// Record the access
+			let proving = TrieBackendBuilder::wrap(&trie)
+				.with_recorder(Recorder::default())
+				.with_cache(cache.local_cache())
+				.build();
+			assert_eq!(proving.child_storage(child_info_1, &[65]), Ok(Some(vec![65; 128])));
+
+			let proof = proving.extract_proof().unwrap();
+			// And check that we have a correct proof.
+			let proof_check =
+				create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof).unwrap();
+			assert_eq!(
+				proof_check.child_storage(child_info_1, &[65]).unwrap().unwrap(),
+				vec![65; 128]
+			);
+		}
+	}
+
+	parameterized_test!(
+		storage_proof_encoded_size_estimation_works,
+		storage_proof_encoded_size_estimation_works_inner
+	);
+	fn storage_proof_encoded_size_estimation_works_inner(
+		state_version: StateVersion,
+		cache: Option<Cache>,
+		recorder: Option<Recorder>,
+	) {
+		let has_cache = cache.is_some();
+		let trie_backend = test_trie(state_version, cache, recorder);
+		let keys = &[
+			&b"key"[..],
+			&b"value1"[..],
+			&b"value2"[..],
+			&b"doesnotexist"[..],
+			&b"doesnotexist2"[..],
+		];
+
+		fn check_estimation(
+			backend: TrieBackend<
+				impl TrieBackendStorage<BlakeTwo256>,
+				BlakeTwo256,
+				&'_ LocalTrieCache<BlakeTwo256>,
+			>,
+			has_cache: bool,
+		) {
+			let estimation = backend.essence.recorder.as_ref().unwrap().estimate_encoded_size();
+			let storage_proof = backend.extract_proof().unwrap();
+			let storage_proof_size =
+				storage_proof.into_nodes().into_iter().map(|n| n.encoded_size()).sum::<usize>();
+
+			if has_cache {
+				// Estimation is not entirely correct when we have values already cached.
+				assert!(estimation >= storage_proof_size)
+			} else {
+				assert_eq!(storage_proof_size, estimation);
+			}
+		}
+
+		for n in 0..keys.len() {
+			let backend = TrieBackendBuilder::wrap(&trie_backend)
+				.with_recorder(Recorder::default())
+				.build();
+
+			// Read n keys
+			(0..n).for_each(|i| {
+				backend.storage(keys[i]).unwrap();
+			});
+
+			// Check the estimation
+			check_estimation(backend, has_cache);
+		}
+	}
+
+	#[test]
+	fn new_data_is_added_to_the_cache() {
+		let shared_cache = SharedTrieCache::new(CacheSize::unlimited());
+		let new_data = vec![
+			(&b"new_data0"[..], Some(&b"0"[..])),
+			(&b"new_data1"[..], Some(&b"1"[..])),
+			(&b"new_data2"[..], Some(&b"2"[..])),
+			(&b"new_data3"[..], Some(&b"3"[..])),
+			(&b"new_data4"[..], Some(&b"4"[..])),
+		];
+
+		let new_root = {
+			let trie = test_trie(StateVersion::V1, Some(shared_cache.local_cache()), None);
+			trie.storage_root(new_data.clone().into_iter(), StateVersion::V1).0
+		};
+
+		let local_cache = shared_cache.local_cache();
+		let mut cache = local_cache.as_trie_db_cache(new_root);
+		// All the data should be cached now
+		for (key, value) in new_data {
+			assert_eq!(
+				value.unwrap(),
+				cache.lookup_value_for_key(key).unwrap().data().flatten().unwrap().as_ref()
+			);
+		}
+	}
+
+	/// Test to ensure that recording the same `key` for different tries works as expected.
+	///
+	/// Each trie stores a different value under the same key. The values are big enough to
+	/// be not inlined with `StateVersion::V1`, this is important to test the expected behavior. The
+	/// trie recorder is expected to differentiate key access based on the different storage roots
+	/// of the tries.
+	#[test]
+	fn recording_same_key_access_in_different_tries() {
+		recording_same_key_access_in_different_tries_inner(StateVersion::V0);
+		recording_same_key_access_in_different_tries_inner(StateVersion::V1);
+	}
+	fn recording_same_key_access_in_different_tries_inner(state_version: StateVersion) {
+		let key = b"test_key".to_vec();
+		// Use some big values to ensure that we don't keep them inline
+		let top_trie_val = vec![1; 1024];
+		let child_trie_1_val = vec![2; 1024];
+		let child_trie_2_val = vec![3; 1024];
+
+		let child_info_1 = ChildInfo::new_default(b"sub1");
+		let child_info_2 = ChildInfo::new_default(b"sub2");
+		let child_info_1 = &child_info_1;
+		let child_info_2 = &child_info_2;
+		let contents = vec![
+			(None, vec![(key.clone(), Some(top_trie_val.clone()))]),
+			(Some(child_info_1.clone()), vec![(key.clone(), Some(child_trie_1_val.clone()))]),
+			(Some(child_info_2.clone()), vec![(key.clone(), Some(child_trie_2_val.clone()))]),
+		];
+		let in_memory = new_in_mem::<BlakeTwo256>();
+		let in_memory = in_memory.update(contents, state_version);
+		let child_storage_keys = vec![child_info_1.to_owned(), child_info_2.to_owned()];
+		let in_memory_root = in_memory
+			.full_storage_root(
+				std::iter::empty(),
+				child_storage_keys.iter().map(|k| (k, std::iter::empty())),
+				state_version,
+			)
+			.0;
+		assert_eq!(in_memory.storage(&key).unwrap().unwrap(), top_trie_val);
+		assert_eq!(in_memory.child_storage(child_info_1, &key).unwrap().unwrap(), child_trie_1_val);
+		assert_eq!(in_memory.child_storage(child_info_2, &key).unwrap().unwrap(), child_trie_2_val);
+
+		for cache in [Some(SharedTrieCache::new(CacheSize::unlimited())), None] {
+			// Run multiple times to have a different cache conditions.
+			for i in 0..5 {
+				eprintln!("Running with cache {}, iteration {}", cache.is_some(), i);
+
+				if let Some(cache) = &cache {
+					if i == 2 {
+						cache.reset_node_cache();
+					} else if i == 3 {
+						cache.reset_value_cache();
+					}
+				}
+
+				let trie = in_memory.as_trie_backend();
+				let trie_root = trie.storage_root(std::iter::empty(), state_version).0;
+				assert_eq!(in_memory_root, trie_root);
+
+				let proving = TrieBackendBuilder::wrap(&trie)
+					.with_recorder(Recorder::default())
+					.with_optional_cache(cache.as_ref().map(|c| c.local_cache()))
+					.build();
+				assert_eq!(proving.storage(&key).unwrap().unwrap(), top_trie_val);
+				assert_eq!(
+					proving.child_storage(child_info_1, &key).unwrap().unwrap(),
+					child_trie_1_val
+				);
+				assert_eq!(
+					proving.child_storage(child_info_2, &key).unwrap().unwrap(),
+					child_trie_2_val
+				);
+
+				let proof = proving.extract_proof().unwrap();
+
+				let proof_check =
+					create_proof_check_backend::<BlakeTwo256>(in_memory_root.into(), proof)
+						.unwrap();
+
+				assert_eq!(proof_check.storage(&key).unwrap().unwrap(), top_trie_val);
+				assert_eq!(
+					proof_check.child_storage(child_info_1, &key).unwrap().unwrap(),
+					child_trie_1_val
+				);
+				assert_eq!(
+					proof_check.child_storage(child_info_2, &key).unwrap().unwrap(),
+					child_trie_2_val
+				);
+			}
+		}
+	}
+}
diff --git a/substrate/primitives/state-machine/src/trie_backend_essence.rs b/substrate/primitives/state-machine/src/trie_backend_essence.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4bb51f4a134370795da03d0bbfefc347d72f12cd
--- /dev/null
+++ b/substrate/primitives/state-machine/src/trie_backend_essence.rs
@@ -0,0 +1,915 @@
+// 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.
+
+//! Trie-based state machine backend essence used to read values
+//! from storage.
+
+use crate::{
+	backend::{IterArgs, StorageIterator},
+	trie_backend::TrieCacheProvider,
+	warn, StorageKey, StorageValue,
+};
+use codec::Codec;
+use hash_db::{self, AsHashDB, HashDB, HashDBRef, Hasher, Prefix};
+#[cfg(feature = "std")]
+use parking_lot::RwLock;
+use sp_core::storage::{ChildInfo, ChildType, StateVersion};
+use sp_std::{boxed::Box, marker::PhantomData, vec::Vec};
+#[cfg(feature = "std")]
+use sp_trie::recorder::Recorder;
+use sp_trie::{
+	child_delta_trie_root, delta_trie_root, empty_child_trie_root, read_child_trie_hash,
+	read_child_trie_value, read_trie_value,
+	trie_types::{TrieDBBuilder, TrieError},
+	DBValue, KeySpacedDB, NodeCodec, PrefixedMemoryDB, Trie, TrieCache, TrieDBRawIterator,
+	TrieRecorder,
+};
+#[cfg(feature = "std")]
+use std::{collections::HashMap, sync::Arc};
+// In this module, we only use layout for read operation and empty root,
+// where V1 and V0 are equivalent.
+use sp_trie::LayoutV1 as Layout;
+
+#[cfg(not(feature = "std"))]
+macro_rules! format {
+	( $message:expr, $( $arg:expr )* ) => {
+		{
+			$( let _ = &$arg; )*
+			crate::DefaultError
+		}
+	};
+}
+
+type Result<V> = sp_std::result::Result<V, crate::DefaultError>;
+
+/// Patricia trie-based storage trait.
+pub trait Storage<H: Hasher>: Send + Sync {
+	/// Get a trie node.
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>>;
+}
+
+/// Local cache for child root.
+#[cfg(feature = "std")]
+pub(crate) struct Cache<H> {
+	pub child_root: HashMap<Vec<u8>, Option<H>>,
+}
+
+#[cfg(feature = "std")]
+impl<H> Cache<H> {
+	fn new() -> Self {
+		Cache { child_root: HashMap::new() }
+	}
+}
+
+enum IterState {
+	Pending,
+	FinishedComplete,
+	FinishedIncomplete,
+}
+
+/// A raw iterator over the storage.
+pub struct RawIter<S, H, C>
+where
+	H: Hasher,
+{
+	stop_on_incomplete_database: bool,
+	skip_if_first: Option<StorageKey>,
+	root: H::Out,
+	child_info: Option<ChildInfo>,
+	trie_iter: TrieDBRawIterator<Layout<H>>,
+	state: IterState,
+	_phantom: PhantomData<(S, C)>,
+}
+
+impl<S, H, C> RawIter<S, H, C>
+where
+	H: Hasher,
+	S: TrieBackendStorage<H>,
+	H::Out: Codec + Ord,
+	C: TrieCacheProvider<H> + Send + Sync,
+{
+	#[inline]
+	fn prepare<R>(
+		&mut self,
+		backend: &TrieBackendEssence<S, H, C>,
+		callback: impl FnOnce(
+			&sp_trie::TrieDB<Layout<H>>,
+			&mut TrieDBRawIterator<Layout<H>>,
+		) -> Option<core::result::Result<R, Box<TrieError<<H as Hasher>::Out>>>>,
+	) -> Option<Result<R>> {
+		if !matches!(self.state, IterState::Pending) {
+			return None
+		}
+
+		let result = backend.with_trie_db(self.root, self.child_info.as_ref(), |db| {
+			callback(&db, &mut self.trie_iter)
+		});
+		match result {
+			Some(Ok(key_value)) => Some(Ok(key_value)),
+			None => {
+				self.state = IterState::FinishedComplete;
+				None
+			},
+			Some(Err(error)) => {
+				self.state = IterState::FinishedIncomplete;
+				if matches!(*error, TrieError::IncompleteDatabase(_)) &&
+					self.stop_on_incomplete_database
+				{
+					None
+				} else {
+					Some(Err(format!("TrieDB iteration error: {}", error)))
+				}
+			},
+		}
+	}
+}
+
+impl<S, H, C> Default for RawIter<S, H, C>
+where
+	H: Hasher,
+{
+	fn default() -> Self {
+		Self {
+			stop_on_incomplete_database: false,
+			skip_if_first: None,
+			child_info: None,
+			root: Default::default(),
+			trie_iter: TrieDBRawIterator::empty(),
+			state: IterState::FinishedComplete,
+			_phantom: Default::default(),
+		}
+	}
+}
+
+impl<S, H, C> StorageIterator<H> for RawIter<S, H, C>
+where
+	H: Hasher,
+	S: TrieBackendStorage<H>,
+	H::Out: Codec + Ord,
+	C: TrieCacheProvider<H> + Send + Sync,
+{
+	type Backend = crate::TrieBackend<S, H, C>;
+	type Error = crate::DefaultError;
+
+	#[inline]
+	fn next_key(&mut self, backend: &Self::Backend) -> Option<Result<StorageKey>> {
+		let skip_if_first = self.skip_if_first.take();
+		self.prepare(&backend.essence, |trie, trie_iter| {
+			let mut result = trie_iter.next_key(&trie);
+			if let Some(skipped_key) = skip_if_first {
+				if let Some(Ok(ref key)) = result {
+					if *key == skipped_key {
+						result = trie_iter.next_key(&trie);
+					}
+				}
+			}
+			result
+		})
+	}
+
+	#[inline]
+	fn next_pair(&mut self, backend: &Self::Backend) -> Option<Result<(StorageKey, StorageValue)>> {
+		let skip_if_first = self.skip_if_first.take();
+		self.prepare(&backend.essence, |trie, trie_iter| {
+			let mut result = trie_iter.next_item(&trie);
+			if let Some(skipped_key) = skip_if_first {
+				if let Some(Ok((ref key, _))) = result {
+					if *key == skipped_key {
+						result = trie_iter.next_item(&trie);
+					}
+				}
+			}
+			result
+		})
+	}
+
+	fn was_complete(&self) -> bool {
+		matches!(self.state, IterState::FinishedComplete)
+	}
+}
+
+/// Patricia trie-based pairs storage essence.
+pub struct TrieBackendEssence<S: TrieBackendStorage<H>, H: Hasher, C> {
+	storage: S,
+	root: H::Out,
+	empty: H::Out,
+	#[cfg(feature = "std")]
+	pub(crate) cache: Arc<RwLock<Cache<H::Out>>>,
+	pub(crate) trie_node_cache: Option<C>,
+	#[cfg(feature = "std")]
+	pub(crate) recorder: Option<Recorder<H>>,
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C> TrieBackendEssence<S, H, C> {
+	/// Create new trie-based backend.
+	pub fn new(storage: S, root: H::Out) -> Self {
+		Self::new_with_cache(storage, root, None)
+	}
+
+	/// Create new trie-based backend.
+	pub fn new_with_cache(storage: S, root: H::Out, cache: Option<C>) -> Self {
+		TrieBackendEssence {
+			storage,
+			root,
+			empty: H::hash(&[0u8]),
+			#[cfg(feature = "std")]
+			cache: Arc::new(RwLock::new(Cache::new())),
+			trie_node_cache: cache,
+			#[cfg(feature = "std")]
+			recorder: None,
+		}
+	}
+
+	/// Create new trie-based backend.
+	#[cfg(feature = "std")]
+	pub fn new_with_cache_and_recorder(
+		storage: S,
+		root: H::Out,
+		cache: Option<C>,
+		recorder: Option<Recorder<H>>,
+	) -> Self {
+		TrieBackendEssence {
+			storage,
+			root,
+			empty: H::hash(&[0u8]),
+			cache: Arc::new(RwLock::new(Cache::new())),
+			trie_node_cache: cache,
+			recorder,
+		}
+	}
+
+	/// Get backend storage reference.
+	pub fn backend_storage(&self) -> &S {
+		&self.storage
+	}
+
+	/// Get backend storage mutable reference.
+	pub fn backend_storage_mut(&mut self) -> &mut S {
+		&mut self.storage
+	}
+
+	/// Get trie root.
+	pub fn root(&self) -> &H::Out {
+		&self.root
+	}
+
+	/// Set trie root. This is useful for testing.
+	pub fn set_root(&mut self, root: H::Out) {
+		// If root did change so can have cached content.
+		self.reset_cache();
+		self.root = root;
+	}
+
+	#[cfg(feature = "std")]
+	fn reset_cache(&mut self) {
+		self.cache = Arc::new(RwLock::new(Cache::new()));
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn reset_cache(&mut self) {}
+
+	/// Consumes self and returns underlying storage.
+	pub fn into_storage(self) -> S {
+		self.storage
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H>> TrieBackendEssence<S, H, C> {
+	/// Call the given closure passing it the recorder and the cache.
+	///
+	/// If the given `storage_root` is `None`, `self.root` will be used.
+	#[inline]
+	fn with_recorder_and_cache<R>(
+		&self,
+		storage_root: Option<H::Out>,
+		callback: impl FnOnce(
+			Option<&mut dyn TrieRecorder<H::Out>>,
+			Option<&mut dyn TrieCache<NodeCodec<H>>>,
+		) -> R,
+	) -> R {
+		let storage_root = storage_root.unwrap_or_else(|| self.root);
+		let mut cache = self.trie_node_cache.as_ref().map(|c| c.as_trie_db_cache(storage_root));
+		let cache = cache.as_mut().map(|c| c as _);
+
+		#[cfg(feature = "std")]
+		{
+			let mut recorder = self.recorder.as_ref().map(|r| r.as_trie_recorder(storage_root));
+			let recorder = match recorder.as_mut() {
+				Some(recorder) => Some(recorder as &mut dyn TrieRecorder<H::Out>),
+				None => None,
+			};
+			callback(recorder, cache)
+		}
+
+		#[cfg(not(feature = "std"))]
+		{
+			callback(None, cache)
+		}
+	}
+
+	/// Call the given closure passing it the recorder and the cache.
+	///
+	/// This function must only be used when the operation in `callback` is
+	/// calculating a `storage_root`. It is expected that `callback` returns
+	/// the new storage root. This is required to register the changes in the cache
+	/// for the correct storage root. The given `storage_root` corresponds to the root of the "old"
+	/// trie. If the value is not given, `self.root` is used.
+	#[cfg(feature = "std")]
+	fn with_recorder_and_cache_for_storage_root<R>(
+		&self,
+		storage_root: Option<H::Out>,
+		callback: impl FnOnce(
+			Option<&mut dyn TrieRecorder<H::Out>>,
+			Option<&mut dyn TrieCache<NodeCodec<H>>>,
+		) -> (Option<H::Out>, R),
+	) -> R {
+		let storage_root = storage_root.unwrap_or_else(|| self.root);
+		let mut recorder = self.recorder.as_ref().map(|r| r.as_trie_recorder(storage_root));
+		let recorder = match recorder.as_mut() {
+			Some(recorder) => Some(recorder as &mut dyn TrieRecorder<H::Out>),
+			None => None,
+		};
+
+		let result = if let Some(local_cache) = self.trie_node_cache.as_ref() {
+			let mut cache = local_cache.as_trie_db_mut_cache();
+
+			let (new_root, r) = callback(recorder, Some(&mut cache));
+
+			if let Some(new_root) = new_root {
+				local_cache.merge(cache, new_root);
+			}
+
+			r
+		} else {
+			callback(recorder, None).1
+		};
+
+		result
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn with_recorder_and_cache_for_storage_root<R>(
+		&self,
+		_storage_root: Option<H::Out>,
+		callback: impl FnOnce(
+			Option<&mut dyn TrieRecorder<H::Out>>,
+			Option<&mut dyn TrieCache<NodeCodec<H>>>,
+		) -> (Option<H::Out>, R),
+	) -> R {
+		if let Some(local_cache) = self.trie_node_cache.as_ref() {
+			let mut cache = local_cache.as_trie_db_mut_cache();
+
+			let (new_root, r) = callback(None, Some(&mut cache));
+
+			if let Some(new_root) = new_root {
+				local_cache.merge(cache, new_root);
+			}
+
+			r
+		} else {
+			callback(None, None).1
+		}
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H> + Send + Sync>
+	TrieBackendEssence<S, H, C>
+where
+	H::Out: Codec + Ord,
+{
+	/// Calls the given closure with a [`TrieDb`] constructed for the given
+	/// storage root and (optionally) child trie.
+	#[inline]
+	fn with_trie_db<R>(
+		&self,
+		root: H::Out,
+		child_info: Option<&ChildInfo>,
+		callback: impl FnOnce(&sp_trie::TrieDB<Layout<H>>) -> R,
+	) -> R {
+		let backend = self as &dyn HashDBRef<H, Vec<u8>>;
+		let db = child_info
+			.as_ref()
+			.map(|child_info| KeySpacedDB::new(backend, child_info.keyspace()));
+		let db = db.as_ref().map(|db| db as &dyn HashDBRef<H, Vec<u8>>).unwrap_or(backend);
+
+		self.with_recorder_and_cache(Some(root), |recorder, cache| {
+			let trie = TrieDBBuilder::<H>::new(db, &root)
+				.with_optional_recorder(recorder)
+				.with_optional_cache(cache)
+				.build();
+
+			callback(&trie)
+		})
+	}
+
+	/// Returns the next key in the trie i.e. the minimum key that is strictly superior to `key` in
+	/// lexicographic order.
+	///
+	/// Will always traverse the trie from scratch in search of the key, which is slow.
+	/// Used only when debug assertions are enabled to crosscheck the results of finding
+	/// the next key through an iterator.
+	#[cfg(debug_assertions)]
+	pub fn next_storage_key_slow(&self, key: &[u8]) -> Result<Option<StorageKey>> {
+		self.next_storage_key_from_root(&self.root, None, key)
+	}
+
+	/// Access the root of the child storage in its parent trie
+	fn child_root(&self, child_info: &ChildInfo) -> Result<Option<H::Out>> {
+		#[cfg(feature = "std")]
+		{
+			if let Some(result) = self.cache.read().child_root.get(child_info.storage_key()) {
+				return Ok(*result)
+			}
+		}
+
+		let result = self.storage(child_info.prefixed_storage_key().as_slice())?.map(|r| {
+			let mut hash = H::Out::default();
+
+			// root is fetched from DB, not writable by runtime, so it's always valid.
+			hash.as_mut().copy_from_slice(&r[..]);
+
+			hash
+		});
+
+		#[cfg(feature = "std")]
+		{
+			self.cache.write().child_root.insert(child_info.storage_key().to_vec(), result);
+		}
+
+		Ok(result)
+	}
+
+	/// Return the next key in the child trie i.e. the minimum key that is strictly superior to
+	/// `key` in lexicographic order.
+	pub fn next_child_storage_key(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<StorageKey>> {
+		let child_root = match self.child_root(child_info)? {
+			Some(child_root) => child_root,
+			None => return Ok(None),
+		};
+
+		self.next_storage_key_from_root(&child_root, Some(child_info), key)
+	}
+
+	/// Return next key from main trie or child trie by providing corresponding root.
+	fn next_storage_key_from_root(
+		&self,
+		root: &H::Out,
+		child_info: Option<&ChildInfo>,
+		key: &[u8],
+	) -> Result<Option<StorageKey>> {
+		self.with_trie_db(*root, child_info, |trie| {
+			let mut iter = trie.key_iter().map_err(|e| format!("TrieDB iteration error: {}", e))?;
+
+			// The key just after the one given in input, basically `key++0`.
+			// Note: We are sure this is the next key if:
+			// * size of key has no limit (i.e. we can always add 0 to the path),
+			// * and no keys can be inserted between `key` and `key++0` (this is ensured by sp-io).
+			let mut potential_next_key = Vec::with_capacity(key.len() + 1);
+			potential_next_key.extend_from_slice(key);
+			potential_next_key.push(0);
+
+			iter.seek(&potential_next_key)
+				.map_err(|e| format!("TrieDB iterator seek error: {}", e))?;
+
+			let next_element = iter.next();
+
+			let next_key = if let Some(next_element) = next_element {
+				let next_key =
+					next_element.map_err(|e| format!("TrieDB iterator next error: {}", e))?;
+				Some(next_key)
+			} else {
+				None
+			};
+
+			Ok(next_key)
+		})
+	}
+
+	/// Returns the hash value
+	pub fn storage_hash(&self, key: &[u8]) -> Result<Option<H::Out>> {
+		let map_e = |e| format!("Trie lookup error: {}", e);
+
+		self.with_recorder_and_cache(None, |recorder, cache| {
+			TrieDBBuilder::new(self, &self.root)
+				.with_optional_cache(cache)
+				.with_optional_recorder(recorder)
+				.build()
+				.get_hash(key)
+				.map_err(map_e)
+		})
+	}
+
+	/// Get the value of storage at given key.
+	pub fn storage(&self, key: &[u8]) -> Result<Option<StorageValue>> {
+		let map_e = |e| format!("Trie lookup error: {}", e);
+
+		self.with_recorder_and_cache(None, |recorder, cache| {
+			read_trie_value::<Layout<H>, _>(self, &self.root, key, recorder, cache).map_err(map_e)
+		})
+	}
+
+	/// Returns the hash value
+	pub fn child_storage_hash(&self, child_info: &ChildInfo, key: &[u8]) -> Result<Option<H::Out>> {
+		let child_root = match self.child_root(child_info)? {
+			Some(root) => root,
+			None => return Ok(None),
+		};
+
+		let map_e = |e| format!("Trie lookup error: {}", e);
+
+		self.with_recorder_and_cache(Some(child_root), |recorder, cache| {
+			read_child_trie_hash::<Layout<H>, _>(
+				child_info.keyspace(),
+				self,
+				&child_root,
+				key,
+				recorder,
+				cache,
+			)
+			.map_err(map_e)
+		})
+	}
+
+	/// Get the value of child storage at given key.
+	pub fn child_storage(
+		&self,
+		child_info: &ChildInfo,
+		key: &[u8],
+	) -> Result<Option<StorageValue>> {
+		let child_root = match self.child_root(child_info)? {
+			Some(root) => root,
+			None => return Ok(None),
+		};
+
+		let map_e = |e| format!("Trie lookup error: {}", e);
+
+		self.with_recorder_and_cache(Some(child_root), |recorder, cache| {
+			read_child_trie_value::<Layout<H>, _>(
+				child_info.keyspace(),
+				self,
+				&child_root,
+				key,
+				recorder,
+				cache,
+			)
+			.map_err(map_e)
+		})
+	}
+
+	/// Create a raw iterator over the storage.
+	pub fn raw_iter(&self, args: IterArgs) -> Result<RawIter<S, H, C>> {
+		let root = if let Some(child_info) = args.child_info.as_ref() {
+			let root = match self.child_root(&child_info)? {
+				Some(root) => root,
+				None => return Ok(Default::default()),
+			};
+			root
+		} else {
+			self.root
+		};
+
+		if self.root == Default::default() {
+			// A special-case for an empty storage root.
+			return Ok(Default::default())
+		}
+
+		let trie_iter = self
+			.with_trie_db(root, args.child_info.as_ref(), |db| {
+				let prefix = args.prefix.as_deref().unwrap_or(&[]);
+				if let Some(start_at) = args.start_at {
+					TrieDBRawIterator::new_prefixed_then_seek(db, prefix, &start_at)
+				} else {
+					TrieDBRawIterator::new_prefixed(db, prefix)
+				}
+			})
+			.map_err(|e| format!("TrieDB iteration error: {}", e))?;
+
+		Ok(RawIter {
+			stop_on_incomplete_database: args.stop_on_incomplete_database,
+			skip_if_first: if args.start_at_exclusive {
+				args.start_at.map(|key| key.to_vec())
+			} else {
+				None
+			},
+			child_info: args.child_info,
+			root,
+			trie_iter,
+			state: IterState::Pending,
+			_phantom: Default::default(),
+		})
+	}
+
+	/// Return the storage root after applying the given `delta`.
+	pub fn storage_root<'a>(
+		&self,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (H::Out, PrefixedMemoryDB<H>) {
+		let mut write_overlay = PrefixedMemoryDB::default();
+
+		let root = self.with_recorder_and_cache_for_storage_root(None, |recorder, cache| {
+			let mut eph = Ephemeral::new(self.backend_storage(), &mut write_overlay);
+			let res = match state_version {
+				StateVersion::V0 => delta_trie_root::<sp_trie::LayoutV0<H>, _, _, _, _, _>(
+					&mut eph, self.root, delta, recorder, cache,
+				),
+				StateVersion::V1 => delta_trie_root::<sp_trie::LayoutV1<H>, _, _, _, _, _>(
+					&mut eph, self.root, delta, recorder, cache,
+				),
+			};
+
+			match res {
+				Ok(ret) => (Some(ret), ret),
+				Err(e) => {
+					warn!(target: "trie", "Failed to write to trie: {}", e);
+					(None, self.root)
+				},
+			}
+		});
+
+		(root, write_overlay)
+	}
+
+	/// Returns the child storage root for the child trie `child_info` after applying the given
+	/// `delta`.
+	pub fn child_storage_root<'a>(
+		&self,
+		child_info: &ChildInfo,
+		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
+		state_version: StateVersion,
+	) -> (H::Out, bool, PrefixedMemoryDB<H>) {
+		let default_root = match child_info.child_type() {
+			ChildType::ParentKeyId => empty_child_trie_root::<sp_trie::LayoutV1<H>>(),
+		};
+		let mut write_overlay = PrefixedMemoryDB::default();
+		let child_root = match self.child_root(child_info) {
+			Ok(Some(hash)) => hash,
+			Ok(None) => default_root,
+			Err(e) => {
+				warn!(target: "trie", "Failed to read child storage root: {}", e);
+				default_root
+			},
+		};
+
+		let new_child_root =
+			self.with_recorder_and_cache_for_storage_root(Some(child_root), |recorder, cache| {
+				let mut eph = Ephemeral::new(self.backend_storage(), &mut write_overlay);
+				match match state_version {
+					StateVersion::V0 =>
+						child_delta_trie_root::<sp_trie::LayoutV0<H>, _, _, _, _, _, _>(
+							child_info.keyspace(),
+							&mut eph,
+							child_root,
+							delta,
+							recorder,
+							cache,
+						),
+					StateVersion::V1 =>
+						child_delta_trie_root::<sp_trie::LayoutV1<H>, _, _, _, _, _, _>(
+							child_info.keyspace(),
+							&mut eph,
+							child_root,
+							delta,
+							recorder,
+							cache,
+						),
+				} {
+					Ok(ret) => (Some(ret), ret),
+					Err(e) => {
+						warn!(target: "trie", "Failed to write to trie: {}", e);
+						(None, child_root)
+					},
+				}
+			});
+
+		let is_default = new_child_root == default_root;
+
+		(new_child_root, is_default, write_overlay)
+	}
+}
+
+pub(crate) struct Ephemeral<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> {
+	storage: &'a S,
+	overlay: &'a mut PrefixedMemoryDB<H>,
+}
+
+impl<'a, S: 'a + TrieBackendStorage<H>, H: 'a + Hasher> AsHashDB<H, DBValue>
+	for Ephemeral<'a, S, H>
+{
+	fn as_hash_db<'b>(&'b self) -> &'b (dyn HashDB<H, DBValue> + 'b) {
+		self
+	}
+	fn as_hash_db_mut<'b>(&'b mut self) -> &'b mut (dyn HashDB<H, DBValue> + 'b) {
+		self
+	}
+}
+
+impl<'a, S: TrieBackendStorage<H>, H: Hasher> Ephemeral<'a, S, H> {
+	pub fn new(storage: &'a S, overlay: &'a mut PrefixedMemoryDB<H>) -> Self {
+		Ephemeral { storage, overlay }
+	}
+}
+
+impl<'a, S: 'a + TrieBackendStorage<H>, H: Hasher> hash_db::HashDB<H, DBValue>
+	for Ephemeral<'a, S, H>
+{
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<DBValue> {
+		HashDB::get(self.overlay, key, prefix).or_else(|| {
+			self.storage.get(key, prefix).unwrap_or_else(|e| {
+				warn!(target: "trie", "Failed to read from DB: {}", e);
+				None
+			})
+		})
+	}
+
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		HashDB::get(self, key, prefix).is_some()
+	}
+
+	fn insert(&mut self, prefix: Prefix, value: &[u8]) -> H::Out {
+		HashDB::insert(self.overlay, prefix, value)
+	}
+
+	fn emplace(&mut self, key: H::Out, prefix: Prefix, value: DBValue) {
+		HashDB::emplace(self.overlay, key, prefix, value)
+	}
+
+	fn remove(&mut self, key: &H::Out, prefix: Prefix) {
+		HashDB::remove(self.overlay, key, prefix)
+	}
+}
+
+impl<'a, S: 'a + TrieBackendStorage<H>, H: Hasher> HashDBRef<H, DBValue> for Ephemeral<'a, S, H> {
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<DBValue> {
+		HashDB::get(self, key, prefix)
+	}
+
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		HashDB::contains(self, key, prefix)
+	}
+}
+
+/// Key-value pairs storage that is used by trie backend essence.
+pub trait TrieBackendStorage<H: Hasher>: Send + Sync {
+	/// Get the value stored at key.
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>>;
+}
+
+impl<T: TrieBackendStorage<H>, H: Hasher> TrieBackendStorage<H> for &T {
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>> {
+		(*self).get(key, prefix)
+	}
+}
+
+// This implementation is used by normal storage trie clients.
+#[cfg(feature = "std")]
+impl<H: Hasher> TrieBackendStorage<H> for Arc<dyn Storage<H>> {
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>> {
+		Storage::<H>::get(std::ops::Deref::deref(self), key, prefix)
+	}
+}
+
+impl<H, KF> TrieBackendStorage<H> for sp_trie::GenericMemoryDB<H, KF>
+where
+	H: Hasher,
+	KF: sp_trie::KeyFunction<H> + Send + Sync,
+{
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>> {
+		Ok(hash_db::HashDB::get(self, key, prefix))
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H> + Send + Sync>
+	AsHashDB<H, DBValue> for TrieBackendEssence<S, H, C>
+{
+	fn as_hash_db<'b>(&'b self) -> &'b (dyn HashDB<H, DBValue> + 'b) {
+		self
+	}
+	fn as_hash_db_mut<'b>(&'b mut self) -> &'b mut (dyn HashDB<H, DBValue> + 'b) {
+		self
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H> + Send + Sync> HashDB<H, DBValue>
+	for TrieBackendEssence<S, H, C>
+{
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<DBValue> {
+		if *key == self.empty {
+			return Some([0u8].to_vec())
+		}
+		match self.storage.get(key, prefix) {
+			Ok(x) => x,
+			Err(e) => {
+				warn!(target: "trie", "Failed to read from DB: {}", e);
+				None
+			},
+		}
+	}
+
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		HashDB::get(self, key, prefix).is_some()
+	}
+
+	fn insert(&mut self, _prefix: Prefix, _value: &[u8]) -> H::Out {
+		unimplemented!();
+	}
+
+	fn emplace(&mut self, _key: H::Out, _prefix: Prefix, _value: DBValue) {
+		unimplemented!();
+	}
+
+	fn remove(&mut self, _key: &H::Out, _prefix: Prefix) {
+		unimplemented!();
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: TrieCacheProvider<H> + Send + Sync>
+	HashDBRef<H, DBValue> for TrieBackendEssence<S, H, C>
+{
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<DBValue> {
+		HashDB::get(self, key, prefix)
+	}
+
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		HashDB::contains(self, key, prefix)
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use crate::{Backend, TrieBackend};
+	use sp_core::{Blake2Hasher, H256};
+	use sp_trie::{
+		cache::LocalTrieCache, trie_types::TrieDBMutBuilderV1 as TrieDBMutBuilder, KeySpacedDBMut,
+		PrefixedMemoryDB, TrieMut,
+	};
+
+	#[test]
+	fn next_storage_key_and_next_child_storage_key_work() {
+		let child_info = ChildInfo::new_default(b"MyChild");
+		let child_info = &child_info;
+		// Contains values
+		let mut root_1 = H256::default();
+		// Contains child trie
+		let mut root_2 = H256::default();
+
+		let mut mdb = PrefixedMemoryDB::<Blake2Hasher>::default();
+		{
+			let mut trie = TrieDBMutBuilder::new(&mut mdb, &mut root_1).build();
+			trie.insert(b"3", &[1]).expect("insert failed");
+			trie.insert(b"4", &[1]).expect("insert failed");
+			trie.insert(b"6", &[1]).expect("insert failed");
+		}
+		{
+			let mut mdb = KeySpacedDBMut::new(&mut mdb, child_info.keyspace());
+			// reuse of root_1 implicitly assert child trie root is same
+			// as top trie (contents must remain the same).
+			let mut trie = TrieDBMutBuilder::new(&mut mdb, &mut root_1).build();
+			trie.insert(b"3", &[1]).expect("insert failed");
+			trie.insert(b"4", &[1]).expect("insert failed");
+			trie.insert(b"6", &[1]).expect("insert failed");
+		}
+		{
+			let mut trie = TrieDBMutBuilder::new(&mut mdb, &mut root_2).build();
+			trie.insert(child_info.prefixed_storage_key().as_slice(), root_1.as_ref())
+				.expect("insert failed");
+		};
+
+		let essence_1 = TrieBackendEssence::<_, _, LocalTrieCache<_>>::new(mdb, root_1);
+		let mdb = essence_1.backend_storage().clone();
+		let essence_1 = TrieBackend::from_essence(essence_1);
+
+		assert_eq!(essence_1.next_storage_key(b"2"), Ok(Some(b"3".to_vec())));
+		assert_eq!(essence_1.next_storage_key(b"3"), Ok(Some(b"4".to_vec())));
+		assert_eq!(essence_1.next_storage_key(b"4"), Ok(Some(b"6".to_vec())));
+		assert_eq!(essence_1.next_storage_key(b"5"), Ok(Some(b"6".to_vec())));
+		assert_eq!(essence_1.next_storage_key(b"6"), Ok(None));
+
+		let essence_2 = TrieBackendEssence::<_, _, LocalTrieCache<_>>::new(mdb, root_2);
+
+		assert_eq!(essence_2.next_child_storage_key(child_info, b"2"), Ok(Some(b"3".to_vec())));
+		assert_eq!(essence_2.next_child_storage_key(child_info, b"3"), Ok(Some(b"4".to_vec())));
+		assert_eq!(essence_2.next_child_storage_key(child_info, b"4"), Ok(Some(b"6".to_vec())));
+		assert_eq!(essence_2.next_child_storage_key(child_info, b"5"), Ok(Some(b"6".to_vec())));
+		assert_eq!(essence_2.next_child_storage_key(child_info, b"6"), Ok(None));
+	}
+}
diff --git a/substrate/primitives/statement-store/Cargo.toml b/substrate/primitives/statement-store/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fffb110195d7e05043a5b19fd762735d8811ce31
--- /dev/null
+++ b/substrate/primitives/statement-store/Cargo.toml
@@ -0,0 +1,62 @@
+[package]
+name = "sp-statement-store"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "A crate which contains primitives related to the statement store"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../application-crypto" }
+sp-runtime-interface = { version = "17.0.0", default-features = false, path = "../runtime-interface" }
+sp-externalities = { version = "0.19.0", default-features = false, path = "../externalities" }
+thiserror = { version = "1.0", optional = true }
+
+# ECIES dependencies
+ed25519-dalek = { version = "2.0.0", optional = true }
+x25519-dalek = { version = "2.0.0", optional = true, features = ["static_secrets"] }
+curve25519-dalek = { version = "4.0.0", optional = true }
+aes-gcm = { version = "0.10", optional = true }
+hkdf = { version = "0.12.0", optional = true }
+sha2 = { version = "0.10.7", optional = true }
+rand = { version = "0.8.5", features = ["small_rng"],  optional = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"aes-gcm",
+	"codec/std",
+	"curve25519-dalek",
+	"ed25519-dalek",
+	"hkdf",
+	"rand",
+	"scale-info/std",
+	"sha2",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-runtime-interface/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"thiserror",
+	"x25519-dalek",
+]
+serde = [
+	"scale-info/serde",
+	"sp-application-crypto/serde",
+	"sp-core/serde",
+	"sp-runtime/serde",
+]
diff --git a/substrate/primitives/statement-store/README.md b/substrate/primitives/statement-store/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fb88aaa4ecd9c062a059cf303de3a520fa5bfed9
--- /dev/null
+++ b/substrate/primitives/statement-store/README.md
@@ -0,0 +1,39 @@
+Statement store is an off-chain data-store for signed statements accessible via RPC and OCW.
+
+Nodes hold a number of statements with a proof of authenticity owing to an account ID. OCWs can place items in the data-store (with valid signatures) for any accounts whose keys they control. Users can also submit pre-signed statements via RPC. Statements can also be submitted from on-chain logic through an on-chain event.
+
+A new system event `NewStatement` is added to the runtime. This event allows any account on-chain to declare that they want to make a statement for the store. Within the node store and for broadcasting, the statement would be accompanied with the hash of the block and index of the event within it, essentially taking the place of a real signature.
+
+Statements comprise an optional proof of authenticity (e.g. a signature) and a number of fields. For statements without a proof, nodes would gossip statements randomly with a rate-limiter to minimise the chance of being overrun by a misbehaving node. These will generally be disregarded by nodes unless they are gossiped by several different peers or if a peer pays for it somehow (e.g. gossiping something valuable).
+
+Each field is effectively a key/value pair. Fields must be sorted and the same field type may not be repeated. Depending on which keys are present, clients may index the message for ease of retrieval.
+
+Formally, `Statement` is equivalent to the type `Vec<Field>` and `Field` is the SCALE-encoded enumeration:
+- 0: `AuthenticityProof(Proof)`: The signature of the message. For cryptography where the public key cannot be derived from the signature together with the message data, then this will also include the signer's public key. The message data is all fields of the messages fields except the signature concatenated together *without the length prefix that a `Vec` would usually imply*. This is so that the signature can be derived without needing to re-encode the statement.
+- 1: `DecryptionKey([u8; 32])`: The decryption key identifier which should be used to decrypt the statement's data. In the absense of this field `Data` should be treated as not encrypted.
+- 2: `Priority(u32)`: Priority specifier. Higher priority statements should be kept around at the cost of lower priority statements if multiple statements from the same sender are competing for persistence or transport. Nodes should disregard when considering unsigned statements.
+- 3: `Channel([u8; 32])`: The channel identifier. Only one message of a given channel should be retained at once (the one of highest priority). Nodes should disregard when considering unsigned statements.
+- 4: `Topic1([u8; 32]))`: First topic identifier.
+- 5: `Topic2([u8; 32]))`: Second topic identifier.
+- 6: `Topic3([u8; 32]))`: Third topic identifier.
+- 7: `Topic4([u8; 32]))`: Fourth topic identifier.
+- 8: `Data(Vec<u8>)`: General data segment. No special meaning.
+
+`Proof` is defined as the SCALE-encoded enumeration:
+- 0: `Sr25519 { signature: [u8; 64], signer: [u8; 32] }`
+- 1: `Ed25519 { signature: [u8; 64], signer: [u8; 32] )`
+- 2: `Secp256k1Ecdsa { signature: [u8; 65], signer: [u8; 33] )`
+- 3: `OnChain { who: [u8; 32], block_hash: [u8; 32], event_index: u64 }`
+
+### Potential uses
+
+Potential use-cases are various and include:
+- ring-signature aggregation;
+- messaging;
+- state-channels;
+- deferral of the initial "advertising" phase of multi-party transactions;
+- publication of preimage data whose hash is referenced on-chain;
+- effective transferal of fee payment to a second-party.
+
+
+License: Apache-2.0
diff --git a/substrate/primitives/statement-store/src/ecies.rs b/substrate/primitives/statement-store/src/ecies.rs
new file mode 100644
index 0000000000000000000000000000000000000000..80a040fd4c8e03de91bdd851bb635d506c20208f
--- /dev/null
+++ b/substrate/primitives/statement-store/src/ecies.rs
@@ -0,0 +1,174 @@
+// 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.
+
+// tag::description[]
+//! ECIES encryption scheme using x25519 key exchange and AEAD.
+// end::description[]
+
+use aes_gcm::{aead::Aead, AeadCore, KeyInit};
+use rand::rngs::OsRng;
+use sha2::Digest;
+use sp_core::crypto::Pair;
+
+/// x25519 secret key.
+pub type SecretKey = x25519_dalek::StaticSecret;
+/// x25519 public key.
+pub type PublicKey = x25519_dalek::PublicKey;
+
+/// Encryption or decryption error.
+#[derive(Debug, PartialEq, Eq, thiserror::Error)]
+pub enum Error {
+	/// Generic AES encryption error.
+	#[error("Encryption error")]
+	Encryption,
+	/// Generic AES decryption error.
+	#[error("Decryption error")]
+	Decryption,
+	/// Error reading key data. Not enough data in the buffer.
+	#[error("Bad cypher text")]
+	BadData,
+}
+
+const NONCE_LEN: usize = 12;
+const PK_LEN: usize = 32;
+const AES_KEY_LEN: usize = 32;
+
+fn aes_encrypt(key: &[u8; AES_KEY_LEN], nonce: &[u8], plaintext: &[u8]) -> Result<Vec<u8>, Error> {
+	let enc = aes_gcm::Aes256Gcm::new(key.into());
+
+	enc.encrypt(nonce.into(), aes_gcm::aead::Payload { msg: plaintext, aad: b"" })
+		.map_err(|_| Error::Encryption)
+}
+
+fn aes_decrypt(key: &[u8; AES_KEY_LEN], nonce: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>, Error> {
+	let dec = aes_gcm::Aes256Gcm::new(key.into());
+	dec.decrypt(nonce.into(), aes_gcm::aead::Payload { msg: ciphertext, aad: b"" })
+		.map_err(|_| Error::Decryption)
+}
+
+fn kdf(shared_secret: &[u8]) -> [u8; AES_KEY_LEN] {
+	let hkdf = hkdf::Hkdf::<sha2::Sha256>::new(None, shared_secret);
+	let mut aes_key = [0u8; AES_KEY_LEN];
+	hkdf.expand(b"", &mut aes_key)
+		.expect("There's always enough data for derivation. qed.");
+	aes_key
+}
+
+/// Encrypt `plaintext` with the given public x25519 public key. Decryption can be performed with
+/// the matching secret key.
+pub fn encrypt_x25519(pk: &PublicKey, plaintext: &[u8]) -> Result<Vec<u8>, Error> {
+	let ephemeral_sk = x25519_dalek::StaticSecret::random_from_rng(OsRng);
+	let ephemeral_pk = x25519_dalek::PublicKey::from(&ephemeral_sk);
+
+	let mut shared_secret = ephemeral_sk.diffie_hellman(pk).to_bytes().to_vec();
+	shared_secret.extend_from_slice(ephemeral_pk.as_bytes());
+
+	let aes_key = kdf(&shared_secret);
+
+	let nonce = aes_gcm::Aes256Gcm::generate_nonce(OsRng);
+	let ciphertext = aes_encrypt(&aes_key, &nonce, plaintext)?;
+
+	let mut out = Vec::with_capacity(ciphertext.len() + PK_LEN + NONCE_LEN);
+	out.extend_from_slice(ephemeral_pk.as_bytes());
+	out.extend_from_slice(nonce.as_slice());
+	out.extend_from_slice(ciphertext.as_slice());
+
+	Ok(out)
+}
+
+/// Encrypt `plaintext` with the given ed25519 public key. Decryption can be performed with the
+/// matching secret key.
+pub fn encrypt_ed25519(pk: &sp_core::ed25519::Public, plaintext: &[u8]) -> Result<Vec<u8>, Error> {
+	let ed25519 = curve25519_dalek::edwards::CompressedEdwardsY(pk.0);
+	let x25519 = ed25519.decompress().ok_or(Error::BadData)?.to_montgomery();
+	let montgomery = x25519_dalek::PublicKey::from(x25519.to_bytes());
+	encrypt_x25519(&montgomery, plaintext)
+}
+
+/// Decrypt with the given x25519 secret key.
+pub fn decrypt_x25519(sk: &SecretKey, encrypted: &[u8]) -> Result<Vec<u8>, Error> {
+	if encrypted.len() < PK_LEN + NONCE_LEN {
+		return Err(Error::BadData)
+	}
+	let mut ephemeral_pk: [u8; PK_LEN] = Default::default();
+	ephemeral_pk.copy_from_slice(&encrypted[0..PK_LEN]);
+	let ephemeral_pk = PublicKey::from(ephemeral_pk);
+
+	let mut shared_secret = sk.diffie_hellman(&ephemeral_pk).to_bytes().to_vec();
+	shared_secret.extend_from_slice(ephemeral_pk.as_bytes());
+
+	let aes_key = kdf(&shared_secret);
+
+	let nonce = &encrypted[PK_LEN..PK_LEN + NONCE_LEN];
+	aes_decrypt(&aes_key, &nonce, &encrypted[PK_LEN + NONCE_LEN..])
+}
+
+/// Decrypt with the given ed25519 key pair.
+pub fn decrypt_ed25519(pair: &sp_core::ed25519::Pair, encrypted: &[u8]) -> Result<Vec<u8>, Error> {
+	let raw = pair.to_raw_vec();
+	let hash: [u8; 32] = sha2::Sha512::digest(&raw).as_slice()[..32]
+		.try_into()
+		.map_err(|_| Error::Decryption)?;
+	let secret = x25519_dalek::StaticSecret::from(hash);
+	decrypt_x25519(&secret, encrypted)
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use rand::rngs::OsRng;
+	use sp_core::crypto::Pair;
+
+	#[test]
+	fn basic_x25519_encryption() {
+		let sk = SecretKey::random_from_rng(OsRng);
+		let pk = PublicKey::from(&sk);
+
+		let plain_message = b"An important secret message";
+		let encrypted = encrypt_x25519(&pk, plain_message).unwrap();
+
+		let decrypted = decrypt_x25519(&sk, &encrypted).unwrap();
+		assert_eq!(plain_message, decrypted.as_slice());
+	}
+
+	#[test]
+	fn basic_ed25519_encryption() {
+		let (pair, _) = sp_core::ed25519::Pair::generate();
+		let pk = pair.into();
+
+		let plain_message = b"An important secret message";
+		let encrypted = encrypt_ed25519(&pk, plain_message).unwrap();
+
+		let decrypted = decrypt_ed25519(&pair, &encrypted).unwrap();
+		assert_eq!(plain_message, decrypted.as_slice());
+	}
+
+	#[test]
+	fn fails_on_bad_data() {
+		let sk = SecretKey::random_from_rng(OsRng);
+		let pk = PublicKey::from(&sk);
+
+		let plain_message = b"An important secret message";
+		let encrypted = encrypt_x25519(&pk, plain_message).unwrap();
+
+		assert_eq!(decrypt_x25519(&sk, &[]), Err(Error::BadData));
+		assert_eq!(
+			decrypt_x25519(&sk, &encrypted[0..super::PK_LEN + super::NONCE_LEN - 1]),
+			Err(Error::BadData)
+		);
+	}
+}
diff --git a/substrate/primitives/statement-store/src/lib.rs b/substrate/primitives/statement-store/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..67e7a7b3896b5df81c27539c52135669778882ae
--- /dev/null
+++ b/substrate/primitives/statement-store/src/lib.rs
@@ -0,0 +1,661 @@
+// 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)]
+#![warn(missing_docs)]
+
+//! A crate which contains statement-store primitives.
+
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_application_crypto::RuntimeAppPublic;
+#[cfg(feature = "std")]
+use sp_core::Pair;
+use sp_runtime_interface::pass_by::PassByCodec;
+use sp_std::vec::Vec;
+
+/// Statement topic.
+pub type Topic = [u8; 32];
+/// Decryption key identifier.
+pub type DecryptionKey = [u8; 32];
+/// Statement hash.
+pub type Hash = [u8; 32];
+/// Block hash.
+pub type BlockHash = [u8; 32];
+/// Account id
+pub type AccountId = [u8; 32];
+/// Statement channel.
+pub type Channel = [u8; 32];
+
+/// Total number of topic fields allowed.
+pub const MAX_TOPICS: usize = 4;
+
+#[cfg(feature = "std")]
+pub use store_api::{
+	Error, NetworkPriority, Result, StatementSource, StatementStore, SubmitResult,
+};
+
+#[cfg(feature = "std")]
+mod ecies;
+pub mod runtime_api;
+#[cfg(feature = "std")]
+mod store_api;
+
+mod sr25519 {
+	mod app_sr25519 {
+		use sp_application_crypto::{app_crypto, key_types::STATEMENT, sr25519};
+		app_crypto!(sr25519, STATEMENT);
+	}
+	pub type Public = app_sr25519::Public;
+}
+
+/// Statement-store specific ed25519 crypto primitives.
+pub mod ed25519 {
+	mod app_ed25519 {
+		use sp_application_crypto::{app_crypto, ed25519, key_types::STATEMENT};
+		app_crypto!(ed25519, STATEMENT);
+	}
+	/// Statement-store specific ed25519 public key.
+	pub type Public = app_ed25519::Public;
+	/// Statement-store specific ed25519 key pair.
+	#[cfg(feature = "std")]
+	pub type Pair = app_ed25519::Pair;
+}
+
+mod ecdsa {
+	mod app_ecdsa {
+		use sp_application_crypto::{app_crypto, ecdsa, key_types::STATEMENT};
+		app_crypto!(ecdsa, STATEMENT);
+	}
+	pub type Public = app_ecdsa::Public;
+}
+
+/// Returns blake2-256 hash for the encoded statement.
+#[cfg(feature = "std")]
+pub fn hash_encoded(data: &[u8]) -> [u8; 32] {
+	sp_core::hashing::blake2_256(data)
+}
+
+/// Statement proof.
+#[derive(Encode, Decode, TypeInfo, sp_core::RuntimeDebug, Clone, PartialEq, Eq)]
+pub enum Proof {
+	/// Sr25519 Signature.
+	Sr25519 {
+		/// Signature.
+		signature: [u8; 64],
+		/// Public key.
+		signer: [u8; 32],
+	},
+	/// Ed25519 Signature.
+	Ed25519 {
+		/// Signature.
+		signature: [u8; 64],
+		/// Public key.
+		signer: [u8; 32],
+	},
+	/// Secp256k1 Signature.
+	Secp256k1Ecdsa {
+		/// Signature.
+		signature: [u8; 65],
+		/// Public key.
+		signer: [u8; 33],
+	},
+	/// On-chain event proof.
+	OnChain {
+		/// Account identifier associated with the event.
+		who: AccountId,
+		/// Hash of block that contains the event.
+		block_hash: BlockHash,
+		/// Index of the event in the event list.
+		event_index: u64,
+	},
+}
+
+impl Proof {
+	/// Return account id for the proof creator.
+	pub fn account_id(&self) -> AccountId {
+		match self {
+			Proof::Sr25519 { signer, .. } => *signer,
+			Proof::Ed25519 { signer, .. } => *signer,
+			Proof::Secp256k1Ecdsa { signer, .. } =>
+				<sp_runtime::traits::BlakeTwo256 as sp_core::Hasher>::hash(signer).into(),
+			Proof::OnChain { who, .. } => *who,
+		}
+	}
+}
+
+/// Statement attributes. Each statement is a list of 0 or more fields. Fields may only appear once
+/// and in the order declared here.
+#[derive(Encode, Decode, TypeInfo, sp_core::RuntimeDebug, Clone, PartialEq, Eq)]
+#[repr(u8)]
+pub enum Field {
+	/// Statement proof.
+	AuthenticityProof(Proof) = 0,
+	/// An identifier for the key that `Data` field may be decrypted with.
+	DecryptionKey(DecryptionKey) = 1,
+	/// Priority when competing with other messages from the same sender.
+	Priority(u32) = 2,
+	/// Account channel to use. Only one message per `(account, channel)` pair is allowed.
+	Channel(Channel) = 3,
+	/// First statement topic.
+	Topic1(Topic) = 4,
+	/// Second statement topic.
+	Topic2(Topic) = 5,
+	/// Third statement topic.
+	Topic3(Topic) = 6,
+	/// Fourth statement topic.
+	Topic4(Topic) = 7,
+	/// Additional data.
+	Data(Vec<u8>) = 8,
+}
+
+impl Field {
+	fn discriminant(&self) -> u8 {
+		// This is safe for repr(u8)
+		// see https://doc.rust-lang.org/reference/items/enumerations.html#pointer-casting
+		unsafe { *(self as *const Self as *const u8) }
+	}
+}
+
+/// Statement structure.
+#[derive(TypeInfo, sp_core::RuntimeDebug, PassByCodec, Clone, PartialEq, Eq, Default)]
+pub struct Statement {
+	proof: Option<Proof>,
+	decryption_key: Option<DecryptionKey>,
+	channel: Option<Channel>,
+	priority: Option<u32>,
+	num_topics: u8,
+	topics: [Topic; MAX_TOPICS],
+	data: Option<Vec<u8>>,
+}
+
+impl Decode for Statement {
+	fn decode<I: codec::Input>(input: &mut I) -> core::result::Result<Self, codec::Error> {
+		// Encoding matches that of Vec<Field>. Basically this just means accepting that there
+		// will be a prefix of vector length.
+		let num_fields: codec::Compact<u32> = Decode::decode(input)?;
+		let mut tag = 0;
+		let mut statement = Statement::new();
+		for i in 0..num_fields.into() {
+			let field: Field = Decode::decode(input)?;
+			if i > 0 && field.discriminant() <= tag {
+				return Err("Invalid field order or duplicate fields".into())
+			}
+			tag = field.discriminant();
+			match field {
+				Field::AuthenticityProof(p) => statement.set_proof(p),
+				Field::DecryptionKey(key) => statement.set_decryption_key(key),
+				Field::Priority(p) => statement.set_priority(p),
+				Field::Channel(c) => statement.set_channel(c),
+				Field::Topic1(t) => statement.set_topic(0, t),
+				Field::Topic2(t) => statement.set_topic(1, t),
+				Field::Topic3(t) => statement.set_topic(2, t),
+				Field::Topic4(t) => statement.set_topic(3, t),
+				Field::Data(data) => statement.set_plain_data(data),
+			}
+		}
+		Ok(statement)
+	}
+}
+
+impl Encode for Statement {
+	fn encode(&self) -> Vec<u8> {
+		self.encoded(false)
+	}
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+/// Result returned by `Statement::verify_signature`
+pub enum SignatureVerificationResult {
+	/// Signature is valid and matches this account id.
+	Valid(AccountId),
+	/// Signature has failed verification.
+	Invalid,
+	/// No signature in the proof or no proof.
+	NoSignature,
+}
+
+impl Statement {
+	/// Create a new empty statement with no proof.
+	pub fn new() -> Statement {
+		Default::default()
+	}
+
+	/// Create a new statement with a proof.
+	pub fn new_with_proof(proof: Proof) -> Statement {
+		let mut statement = Self::new();
+		statement.set_proof(proof);
+		statement
+	}
+
+	/// Sign with a key that matches given public key in the keystore.
+	///
+	/// Returns `true` if signing worked (private key present etc).
+	///
+	/// NOTE: This can only be called from the runtime.
+	pub fn sign_sr25519_public(&mut self, key: &sr25519::Public) -> bool {
+		let to_sign = self.signature_material();
+		if let Some(signature) = key.sign(&to_sign) {
+			let proof = Proof::Sr25519 {
+				signature: signature.into_inner().into(),
+				signer: key.clone().into_inner().into(),
+			};
+			self.set_proof(proof);
+			true
+		} else {
+			false
+		}
+	}
+
+	/// Sign with a given private key and add the signature proof field.
+	#[cfg(feature = "std")]
+	pub fn sign_sr25519_private(&mut self, key: &sp_core::sr25519::Pair) {
+		let to_sign = self.signature_material();
+		let proof =
+			Proof::Sr25519 { signature: key.sign(&to_sign).into(), signer: key.public().into() };
+		self.set_proof(proof);
+	}
+
+	/// Sign with a key that matches given public key in the keystore.
+	///
+	/// Returns `true` if signing worked (private key present etc).
+	///
+	/// NOTE: This can only be called from the runtime.
+	pub fn sign_ed25519_public(&mut self, key: &ed25519::Public) -> bool {
+		let to_sign = self.signature_material();
+		if let Some(signature) = key.sign(&to_sign) {
+			let proof = Proof::Ed25519 {
+				signature: signature.into_inner().into(),
+				signer: key.clone().into_inner().into(),
+			};
+			self.set_proof(proof);
+			true
+		} else {
+			false
+		}
+	}
+
+	/// Sign with a given private key and add the signature proof field.
+	#[cfg(feature = "std")]
+	pub fn sign_ed25519_private(&mut self, key: &sp_core::ed25519::Pair) {
+		let to_sign = self.signature_material();
+		let proof =
+			Proof::Ed25519 { signature: key.sign(&to_sign).into(), signer: key.public().into() };
+		self.set_proof(proof);
+	}
+
+	/// Sign with a key that matches given public key in the keystore.
+	///
+	/// Returns `true` if signing worked (private key present etc).
+	///
+	/// NOTE: This can only be called from the runtime.
+	///
+	/// Returns `true` if signing worked (private key present etc).
+	///
+	/// NOTE: This can only be called from the runtime.
+	pub fn sign_ecdsa_public(&mut self, key: &ecdsa::Public) -> bool {
+		let to_sign = self.signature_material();
+		if let Some(signature) = key.sign(&to_sign) {
+			let proof = Proof::Secp256k1Ecdsa {
+				signature: signature.into_inner().into(),
+				signer: key.clone().into_inner().0,
+			};
+			self.set_proof(proof);
+			true
+		} else {
+			false
+		}
+	}
+
+	/// Sign with a given private key and add the signature proof field.
+	#[cfg(feature = "std")]
+	pub fn sign_ecdsa_private(&mut self, key: &sp_core::ecdsa::Pair) {
+		let to_sign = self.signature_material();
+		let proof =
+			Proof::Secp256k1Ecdsa { signature: key.sign(&to_sign).into(), signer: key.public().0 };
+		self.set_proof(proof);
+	}
+
+	/// Check proof signature, if any.
+	pub fn verify_signature(&self) -> SignatureVerificationResult {
+		use sp_runtime::traits::Verify;
+
+		match self.proof() {
+			Some(Proof::OnChain { .. }) | None => SignatureVerificationResult::NoSignature,
+			Some(Proof::Sr25519 { signature, signer }) => {
+				let to_sign = self.signature_material();
+				let signature = sp_core::sr25519::Signature(*signature);
+				let public = sp_core::sr25519::Public(*signer);
+				if signature.verify(to_sign.as_slice(), &public) {
+					SignatureVerificationResult::Valid(*signer)
+				} else {
+					SignatureVerificationResult::Invalid
+				}
+			},
+			Some(Proof::Ed25519 { signature, signer }) => {
+				let to_sign = self.signature_material();
+				let signature = sp_core::ed25519::Signature(*signature);
+				let public = sp_core::ed25519::Public(*signer);
+				if signature.verify(to_sign.as_slice(), &public) {
+					SignatureVerificationResult::Valid(*signer)
+				} else {
+					SignatureVerificationResult::Invalid
+				}
+			},
+			Some(Proof::Secp256k1Ecdsa { signature, signer }) => {
+				let to_sign = self.signature_material();
+				let signature = sp_core::ecdsa::Signature(*signature);
+				let public = sp_core::ecdsa::Public(*signer);
+				if signature.verify(to_sign.as_slice(), &public) {
+					let sender_hash =
+						<sp_runtime::traits::BlakeTwo256 as sp_core::Hasher>::hash(signer);
+					SignatureVerificationResult::Valid(sender_hash.into())
+				} else {
+					SignatureVerificationResult::Invalid
+				}
+			},
+		}
+	}
+
+	/// Calculate statement hash.
+	#[cfg(feature = "std")]
+	pub fn hash(&self) -> [u8; 32] {
+		self.using_encoded(hash_encoded)
+	}
+
+	/// Returns a topic by topic index.
+	pub fn topic(&self, index: usize) -> Option<Topic> {
+		if index < self.num_topics as usize {
+			Some(self.topics[index])
+		} else {
+			None
+		}
+	}
+
+	/// Returns decryption key if any.
+	pub fn decryption_key(&self) -> Option<DecryptionKey> {
+		self.decryption_key
+	}
+
+	/// Convert to internal data.
+	pub fn into_data(self) -> Option<Vec<u8>> {
+		self.data
+	}
+
+	/// Get a reference to the statement proof, if any.
+	pub fn proof(&self) -> Option<&Proof> {
+		self.proof.as_ref()
+	}
+
+	/// Get proof account id, if any
+	pub fn account_id(&self) -> Option<AccountId> {
+		self.proof.as_ref().map(Proof::account_id)
+	}
+
+	/// Get plain data.
+	pub fn data(&self) -> Option<&Vec<u8>> {
+		self.data.as_ref()
+	}
+
+	/// Get plain data len.
+	pub fn data_len(&self) -> usize {
+		self.data().map_or(0, Vec::len)
+	}
+
+	/// Get channel, if any.
+	pub fn channel(&self) -> Option<Channel> {
+		self.channel
+	}
+
+	/// Get priority, if any.
+	pub fn priority(&self) -> Option<u32> {
+		self.priority
+	}
+
+	/// Return encoded fields that can be signed to construct or verify a proof
+	fn signature_material(&self) -> Vec<u8> {
+		self.encoded(true)
+	}
+
+	/// Remove the proof of this statement.
+	pub fn remove_proof(&mut self) {
+		self.proof = None;
+	}
+
+	/// Set statement proof. Any existing proof is overwritten.
+	pub fn set_proof(&mut self, proof: Proof) {
+		self.proof = Some(proof)
+	}
+
+	/// Set statement priority.
+	pub fn set_priority(&mut self, priority: u32) {
+		self.priority = Some(priority)
+	}
+
+	/// Set statement channel.
+	pub fn set_channel(&mut self, channel: Channel) {
+		self.channel = Some(channel)
+	}
+
+	/// Set topic by index. Does noting if index is over `MAX_TOPICS`.
+	pub fn set_topic(&mut self, index: usize, topic: Topic) {
+		if index < MAX_TOPICS {
+			self.topics[index] = topic;
+			self.num_topics = self.num_topics.max(index as u8 + 1);
+		}
+	}
+
+	/// Set decryption key.
+	pub fn set_decryption_key(&mut self, key: DecryptionKey) {
+		self.decryption_key = Some(key);
+	}
+
+	/// Set unencrypted statement data.
+	pub fn set_plain_data(&mut self, data: Vec<u8>) {
+		self.data = Some(data)
+	}
+
+	fn encoded(&self, for_signing: bool) -> Vec<u8> {
+		// Encoding matches that of Vec<Field>. Basically this just means accepting that there
+		// will be a prefix of vector length.
+		let num_fields = if !for_signing && self.proof.is_some() { 1 } else { 0 } +
+			if self.decryption_key.is_some() { 1 } else { 0 } +
+			if self.priority.is_some() { 1 } else { 0 } +
+			if self.channel.is_some() { 1 } else { 0 } +
+			if self.data.is_some() { 1 } else { 0 } +
+			self.num_topics as u32;
+
+		let mut output = Vec::new();
+		// When encoding signature payload, the length prefix is omitted.
+		// This is so that the signature for encoded statement can potentially be derived without
+		// needing to re-encode the statement.
+		if !for_signing {
+			let compact_len = codec::Compact::<u32>(num_fields);
+			compact_len.encode_to(&mut output);
+
+			if let Some(proof) = &self.proof {
+				0u8.encode_to(&mut output);
+				proof.encode_to(&mut output);
+			}
+		}
+		if let Some(decryption_key) = &self.decryption_key {
+			1u8.encode_to(&mut output);
+			decryption_key.encode_to(&mut output);
+		}
+		if let Some(priority) = &self.priority {
+			2u8.encode_to(&mut output);
+			priority.encode_to(&mut output);
+		}
+		if let Some(channel) = &self.channel {
+			3u8.encode_to(&mut output);
+			channel.encode_to(&mut output);
+		}
+		for t in 0..self.num_topics {
+			(4u8 + t).encode_to(&mut output);
+			self.topics[t as usize].encode_to(&mut output);
+		}
+		if let Some(data) = &self.data {
+			8u8.encode_to(&mut output);
+			data.encode_to(&mut output);
+		}
+		output
+	}
+
+	/// Encrypt give data with given key and store both in the statements.
+	#[cfg(feature = "std")]
+	pub fn encrypt(
+		&mut self,
+		data: &[u8],
+		key: &sp_core::ed25519::Public,
+	) -> core::result::Result<(), ecies::Error> {
+		let encrypted = ecies::encrypt_ed25519(key, data)?;
+		self.data = Some(encrypted);
+		self.decryption_key = Some((*key).into());
+		Ok(())
+	}
+
+	/// Decrypt data (if any) with the given private key.
+	#[cfg(feature = "std")]
+	pub fn decrypt_private(
+		&self,
+		key: &sp_core::ed25519::Pair,
+	) -> core::result::Result<Option<Vec<u8>>, ecies::Error> {
+		self.data.as_ref().map(|d| ecies::decrypt_ed25519(key, d)).transpose()
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use crate::{hash_encoded, Field, Proof, SignatureVerificationResult, Statement};
+	use codec::{Decode, Encode};
+	use sp_application_crypto::Pair;
+
+	#[test]
+	fn statement_encoding_matches_vec() {
+		let mut statement = Statement::new();
+		assert!(statement.proof().is_none());
+		let proof = Proof::OnChain { who: [42u8; 32], block_hash: [24u8; 32], event_index: 66 };
+
+		let decryption_key = [0xde; 32];
+		let topic1 = [0x01; 32];
+		let topic2 = [0x02; 32];
+		let data = vec![55, 99];
+		let priority = 999;
+		let channel = [0xcc; 32];
+
+		statement.set_proof(proof.clone());
+		statement.set_decryption_key(decryption_key);
+		statement.set_priority(priority);
+		statement.set_channel(channel);
+		statement.set_topic(0, topic1);
+		statement.set_topic(1, topic2);
+		statement.set_plain_data(data.clone());
+
+		statement.set_topic(5, [0x55; 32]);
+		assert_eq!(statement.topic(5), None);
+
+		let fields = vec![
+			Field::AuthenticityProof(proof.clone()),
+			Field::DecryptionKey(decryption_key),
+			Field::Priority(priority),
+			Field::Channel(channel),
+			Field::Topic1(topic1),
+			Field::Topic2(topic2),
+			Field::Data(data.clone()),
+		];
+
+		let encoded = statement.encode();
+		assert_eq!(statement.hash(), hash_encoded(&encoded));
+		assert_eq!(encoded, fields.encode());
+
+		let decoded = Statement::decode(&mut encoded.as_slice()).unwrap();
+		assert_eq!(decoded, statement);
+	}
+
+	#[test]
+	fn decode_checks_fields() {
+		let topic1 = [0x01; 32];
+		let topic2 = [0x02; 32];
+		let priority = 999;
+
+		let fields = vec![
+			Field::Priority(priority),
+			Field::Topic1(topic1),
+			Field::Topic1(topic1),
+			Field::Topic2(topic2),
+		]
+		.encode();
+
+		assert!(Statement::decode(&mut fields.as_slice()).is_err());
+
+		let fields =
+			vec![Field::Topic1(topic1), Field::Priority(priority), Field::Topic2(topic2)].encode();
+
+		assert!(Statement::decode(&mut fields.as_slice()).is_err());
+	}
+
+	#[test]
+	fn sign_and_verify() {
+		let mut statement = Statement::new();
+		statement.set_plain_data(vec![42]);
+
+		let sr25519_kp = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		let ed25519_kp = sp_core::ed25519::Pair::from_string("//Alice", None).unwrap();
+		let secp256k1_kp = sp_core::ecdsa::Pair::from_string("//Alice", None).unwrap();
+
+		statement.sign_sr25519_private(&sr25519_kp);
+		assert_eq!(
+			statement.verify_signature(),
+			SignatureVerificationResult::Valid(sr25519_kp.public().0)
+		);
+
+		statement.sign_ed25519_private(&ed25519_kp);
+		assert_eq!(
+			statement.verify_signature(),
+			SignatureVerificationResult::Valid(ed25519_kp.public().0)
+		);
+
+		statement.sign_ecdsa_private(&secp256k1_kp);
+		assert_eq!(
+			statement.verify_signature(),
+			SignatureVerificationResult::Valid(sp_core::hashing::blake2_256(
+				&secp256k1_kp.public().0
+			))
+		);
+
+		// set an invalid signature
+		statement.set_proof(Proof::Sr25519 { signature: [0u8; 64], signer: [0u8; 32] });
+		assert_eq!(statement.verify_signature(), SignatureVerificationResult::Invalid);
+
+		statement.remove_proof();
+		assert_eq!(statement.verify_signature(), SignatureVerificationResult::NoSignature);
+	}
+
+	#[test]
+	fn encrypt_decrypt() {
+		let mut statement = Statement::new();
+		let (pair, _) = sp_core::ed25519::Pair::generate();
+		let plain = b"test data".to_vec();
+
+		//let sr25519_kp = sp_core::sr25519::Pair::from_string("//Alice", None).unwrap();
+		statement.encrypt(&plain, &pair.public()).unwrap();
+		assert_ne!(plain.as_slice(), statement.data().unwrap().as_slice());
+
+		let decrypted = statement.decrypt_private(&pair).unwrap();
+		assert_eq!(decrypted, Some(plain));
+	}
+}
diff --git a/substrate/primitives/statement-store/src/runtime_api.rs b/substrate/primitives/statement-store/src/runtime_api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..13f88bc977e9efc8f9be5f9fdcfdd8ac098c8de2
--- /dev/null
+++ b/substrate/primitives/statement-store/src/runtime_api.rs
@@ -0,0 +1,187 @@
+// 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.
+
+//! Runtime support for the statement store.
+
+use crate::{Hash, Statement, Topic};
+use codec::{Decode, Encode};
+use scale_info::TypeInfo;
+use sp_runtime::RuntimeDebug;
+use sp_runtime_interface::{pass_by::PassByEnum, runtime_interface};
+use sp_std::vec::Vec;
+
+#[cfg(feature = "std")]
+use sp_externalities::ExternalitiesExt;
+
+/// Information concerning a valid statement.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct ValidStatement {
+	/// Max statement count for this account, as calculated by the runtime.
+	pub max_count: u32,
+	/// Max total data size for this account, as calculated by the runtime.
+	pub max_size: u32,
+}
+
+/// An reason for an invalid statement.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, Copy, RuntimeDebug, TypeInfo)]
+pub enum InvalidStatement {
+	/// Failed proof validation.
+	BadProof,
+	/// Missing proof.
+	NoProof,
+	/// Validity could not be checked because of internal error.
+	InternalError,
+}
+
+/// The source of the statement.
+///
+/// Depending on the source we might apply different validation schemes.
+#[derive(Copy, Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub enum StatementSource {
+	/// Statement is coming from the on-chain worker.
+	Chain,
+	/// Statement has been received from the gossip network.
+	Network,
+	/// Statement has been submitted over the local api.
+	Local,
+}
+
+impl StatementSource {
+	/// Check if the source allows the statement to be resubmitted to the store, extending its
+	/// expiration date.
+	pub fn can_be_resubmitted(&self) -> bool {
+		match self {
+			StatementSource::Chain | StatementSource::Local => true,
+			StatementSource::Network => false,
+		}
+	}
+}
+
+sp_api::decl_runtime_apis! {
+	/// Runtime API trait for statement validation.
+	pub trait ValidateStatement {
+		/// Validate the statement.
+		fn validate_statement(
+			source: StatementSource,
+			statement: Statement,
+		) -> Result<ValidStatement, InvalidStatement>;
+	}
+}
+
+#[cfg(feature = "std")]
+sp_externalities::decl_extension! {
+	/// The offchain database extension that will be registered at the Substrate externalities.
+	pub struct StatementStoreExt(std::sync::Arc<dyn crate::StatementStore>);
+}
+
+// Host extensions for the runtime.
+#[cfg(feature = "std")]
+impl StatementStoreExt {
+	/// Create new instance of externalities extensions.
+	pub fn new(store: std::sync::Arc<dyn crate::StatementStore>) -> Self {
+		Self(store)
+	}
+}
+
+/// Submission result.
+#[derive(Debug, Eq, PartialEq, Clone, Copy, Encode, Decode, PassByEnum)]
+pub enum SubmitResult {
+	/// Accepted as new.
+	OkNew,
+	/// Known statement
+	OkKnown,
+	/// Statement failed validation.
+	Bad,
+	/// The store is not available.
+	NotAvailable,
+	/// Statement could not be inserted because of priority or size checks.
+	Full,
+}
+
+/// Export functions for the WASM host.
+#[cfg(feature = "std")]
+pub type HostFunctions = (statement_store::HostFunctions,);
+
+/// Host interface
+#[runtime_interface]
+pub trait StatementStore {
+	/// Submit a new new statement. The statement will be broadcast to the network.
+	/// This is meant to be used by the offchain worker.
+	fn submit_statement(&mut self, statement: Statement) -> SubmitResult {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			match store.submit(statement, StatementSource::Chain) {
+				crate::SubmitResult::New(_) => SubmitResult::OkNew,
+				crate::SubmitResult::Known => SubmitResult::OkKnown,
+				crate::SubmitResult::Ignored => SubmitResult::Full,
+				// This should not happen for `StatementSource::Chain`. An existing statement will
+				// be overwritten.
+				crate::SubmitResult::KnownExpired => SubmitResult::Bad,
+				crate::SubmitResult::Bad(_) => SubmitResult::Bad,
+				crate::SubmitResult::InternalError(_) => SubmitResult::Bad,
+			}
+		} else {
+			SubmitResult::NotAvailable
+		}
+	}
+
+	/// Return all statements.
+	fn statements(&mut self) -> Vec<(Hash, Statement)> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.statements().unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+
+	/// Return the data of all known statements which include all topics and have no `DecryptionKey`
+	/// field.
+	fn broadcasts(&mut self, match_all_topics: &[Topic]) -> Vec<Vec<u8>> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.broadcasts(match_all_topics).unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+
+	/// Return the data of all known statements whose decryption key is identified as `dest` (this
+	/// will generally be the public key or a hash thereof for symmetric ciphers, or a hash of the
+	/// private key for symmetric ciphers).
+	fn posted(&mut self, match_all_topics: &[Topic], dest: [u8; 32]) -> Vec<Vec<u8>> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.posted(match_all_topics, dest).unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+
+	/// Return the decrypted data of all known statements whose decryption key is identified as
+	/// `dest`. The key must be available to the client.
+	fn posted_clear(&mut self, match_all_topics: &[Topic], dest: [u8; 32]) -> Vec<Vec<u8>> {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.posted_clear(match_all_topics, dest).unwrap_or_default()
+		} else {
+			Vec::default()
+		}
+	}
+
+	/// Remove a statement from the store by hash.
+	fn remove(&mut self, hash: &Hash) {
+		if let Some(StatementStoreExt(store)) = self.extension::<StatementStoreExt>() {
+			store.remove(hash).unwrap_or_default()
+		}
+	}
+}
diff --git a/substrate/primitives/statement-store/src/store_api.rs b/substrate/primitives/statement-store/src/store_api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..89daa3e963c5697324bb1ebc70cba3be5edd9241
--- /dev/null
+++ b/substrate/primitives/statement-store/src/store_api.rs
@@ -0,0 +1,90 @@
+// 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.
+
+pub use crate::runtime_api::StatementSource;
+use crate::{Hash, Statement, Topic};
+
+/// Statement store error.
+#[derive(Debug, Eq, PartialEq, thiserror::Error)]
+pub enum Error {
+	/// Database error.
+	#[error("Database error: {0:?}")]
+	Db(String),
+	/// Error decoding statement structure.
+	#[error("Error decoding statement: {0:?}")]
+	Decode(String),
+	/// Error making runtime call.
+	#[error("Error calling into the runtime")]
+	Runtime,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+/// Network propagation priority.
+pub enum NetworkPriority {
+	/// High priority. Statement should be broadcast to all peers.
+	High,
+	/// Low priority.
+	Low,
+}
+
+/// Statement submission outcome
+#[derive(Debug, Eq, PartialEq)]
+pub enum SubmitResult {
+	/// Accepted as new with given score
+	New(NetworkPriority),
+	/// Known statement
+	Known,
+	/// Known statement that's already expired.
+	KnownExpired,
+	/// Priority is too low or the size is too big.
+	Ignored,
+	/// Statement failed validation.
+	Bad(&'static str),
+	/// Internal store error.
+	InternalError(Error),
+}
+
+/// Result type for `Error`
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Statement store API.
+pub trait StatementStore: Send + Sync {
+	/// Return all statements.
+	fn statements(&self) -> Result<Vec<(Hash, Statement)>>;
+
+	/// Get statement by hash.
+	fn statement(&self, hash: &Hash) -> Result<Option<Statement>>;
+
+	/// Return the data of all known statements which include all topics and have no `DecryptionKey`
+	/// field.
+	fn broadcasts(&self, match_all_topics: &[Topic]) -> Result<Vec<Vec<u8>>>;
+
+	/// Return the data of all known statements whose decryption key is identified as `dest` (this
+	/// will generally be the public key or a hash thereof for symmetric ciphers, or a hash of the
+	/// private key for symmetric ciphers).
+	fn posted(&self, match_all_topics: &[Topic], dest: [u8; 32]) -> Result<Vec<Vec<u8>>>;
+
+	/// Return the decrypted data of all known statements whose decryption key is identified as
+	/// `dest`. The key must be available to the client.
+	fn posted_clear(&self, match_all_topics: &[Topic], dest: [u8; 32]) -> Result<Vec<Vec<u8>>>;
+
+	/// Submit a statement.
+	fn submit(&self, statement: Statement, source: StatementSource) -> SubmitResult;
+
+	/// Remove a statement from the store.
+	fn remove(&self, hash: &Hash) -> Result<()>;
+}
diff --git a/substrate/primitives/std/Cargo.toml b/substrate/primitives/std/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4c58d147c7a7ae91a94de160f5a07e88645c80a8
--- /dev/null
+++ b/substrate/primitives/std/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "sp-std"
+version = "8.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "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."
+documentation = "https://docs.rs/sp-std"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[features]
+default = [ "std" ]
+std = []
diff --git a/substrate/primitives/std/README.md b/substrate/primitives/std/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6dddd8fbbdd9d2fade460195ac2d9cee0eaf35ad
--- /dev/null
+++ b/substrate/primitives/std/README.md
@@ -0,0 +1,4 @@
+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.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/std/src/lib.rs b/substrate/primitives/std/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c5873b3698de12ea5ab4fff04e794bd9ae0a4532
--- /dev/null
+++ b/substrate/primitives/std/src/lib.rs
@@ -0,0 +1,114 @@
+// 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.
+
+//! 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_attr(not(feature = "std"), no_std)]
+#![cfg_attr(
+	feature = "std",
+	doc = "Substrate runtime standard library as compiled when linked with Rust's standard library."
+)]
+#![cfg_attr(
+	not(feature = "std"),
+	doc = "Substrate's runtime standard library as compiled without Rust's standard library."
+)]
+
+/// Initialize a key-value collection from array.
+///
+/// Creates a vector of given pairs and calls `collect` on the iterator from it.
+/// Can be used to create a `HashMap`.
+#[macro_export]
+macro_rules! map {
+	($( $name:expr => $value:expr ),* $(,)? ) => (
+		vec![ $( ( $name, $value ) ),* ].into_iter().collect()
+	)
+}
+
+/// Feature gate some code that should only be run when `std` feature is enabled.
+///
+/// # Example
+///
+/// ```
+/// use sp_std::if_std;
+///
+/// if_std! {
+///     // This code is only being compiled and executed when the `std` feature is enabled.
+///     println!("Hello native world");
+/// }
+/// ```
+#[cfg(feature = "std")]
+#[macro_export]
+macro_rules! if_std {
+	( $( $code:tt )* ) => {
+		$( $code )*
+	}
+}
+
+#[cfg(not(feature = "std"))]
+#[macro_export]
+macro_rules! if_std {
+	( $( $code:tt )* ) => {};
+}
+
+#[cfg(feature = "std")]
+include!("../with_std.rs");
+
+#[cfg(not(feature = "std"))]
+include!("../without_std.rs");
+
+/// A target for `core::write!` macro - constructs a string in memory.
+#[derive(Default)]
+pub struct Writer(vec::Vec<u8>);
+
+impl fmt::Write for Writer {
+	fn write_str(&mut self, s: &str) -> fmt::Result {
+		self.0.extend(s.as_bytes());
+		Ok(())
+	}
+}
+
+impl Writer {
+	/// Access the content of this `Writer` e.g. for printout
+	pub fn inner(&self) -> &vec::Vec<u8> {
+		&self.0
+	}
+
+	/// Convert into the content of this `Writer`
+	pub fn into_inner(self) -> vec::Vec<u8> {
+		self.0
+	}
+}
+
+/// Prelude of common useful imports.
+///
+/// This should include only things which are in the normal std prelude.
+pub mod prelude {
+	pub use crate::{
+		borrow::ToOwned,
+		boxed::Box,
+		clone::Clone,
+		cmp::{Eq, PartialEq, Reverse},
+		iter::IntoIterator,
+		vec::Vec,
+	};
+
+	// Re-export `vec!` macro here, but not in `std` mode, since
+	// std's prelude already brings `vec!` into the scope.
+	#[cfg(not(feature = "std"))]
+	pub use crate::vec;
+}
diff --git a/substrate/primitives/std/with_std.rs b/substrate/primitives/std/with_std.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b838de07a309a00cd5d548d790a4bb0465efc76f
--- /dev/null
+++ b/substrate/primitives/std/with_std.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.
+
+pub use std::alloc;
+pub use std::any;
+pub use std::borrow;
+pub use std::boxed;
+pub use std::cell;
+pub use std::clone;
+pub use std::cmp;
+pub use std::convert;
+pub use std::default;
+pub use std::fmt;
+pub use std::hash;
+pub use std::iter;
+pub use std::marker;
+pub use std::mem;
+pub use std::num;
+pub use std::ops;
+pub use std::ptr;
+pub use std::rc;
+pub use std::sync;
+pub use std::result;
+pub use std::slice;
+pub use std::str;
+pub use core::time;
+pub use std::vec;
+
+pub mod collections {
+	pub use std::collections::btree_map;
+	pub use std::collections::btree_set;
+	pub use std::collections::vec_deque;
+}
+
+pub mod thread {
+	pub use std::thread::panicking;
+}
diff --git a/substrate/primitives/std/without_std.rs b/substrate/primitives/std/without_std.rs
new file mode 100755
index 0000000000000000000000000000000000000000..80baeae44cc9e20e96ece6fa1db853dfeb384c05
--- /dev/null
+++ b/substrate/primitives/std/without_std.rs
@@ -0,0 +1,65 @@
+// 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.
+
+pub extern crate alloc;
+
+pub use alloc::boxed;
+pub use alloc::rc;
+pub use alloc::sync;
+pub use alloc::vec;
+pub use core::any;
+pub use core::cell;
+pub use core::clone;
+pub use core::cmp;
+pub use core::convert;
+pub use core::default;
+pub use core::fmt;
+pub use core::hash;
+pub use core::iter;
+pub use core::marker;
+pub use core::mem;
+pub use core::num;
+pub use core::ops;
+pub use core::ptr;
+pub use core::result;
+pub use core::slice;
+// Allow interpreting vectors of bytes as strings, but not constructing them.
+pub use core::str;
+pub use core::time;
+// We are trying to avoid certain things here, such as `core::string`
+// (if you need `String` you are probably doing something wrong, since
+// runtime doesn't require anything human readable).
+
+pub mod collections {
+	pub use alloc::collections::btree_map;
+	pub use alloc::collections::btree_set;
+	pub use alloc::collections::vec_deque;
+}
+
+pub mod borrow {
+	pub use core::borrow::*;
+	pub use alloc::borrow::*;
+}
+
+pub mod thread {
+	/// Returns if the current thread is panicking.
+	///
+	/// In wasm this always returns `false`, as we abort on any panic.
+	pub fn panicking() -> bool {
+		false
+	}
+}
diff --git a/substrate/primitives/storage/Cargo.toml b/substrate/primitives/storage/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..42fa01184ff3ed37acd52e060906a21ce8dea50e
--- /dev/null
+++ b/substrate/primitives/storage/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "sp-storage"
+version = "13.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+description = "Storage related primitives"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+documentation = "https://docs.rs/sp-storage/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+impl-serde = { version = "0.4.0", optional = true, default-features = false }
+ref-cast = "1.0.0"
+serde = { version = "1.0.163", default-features = false, features = ["derive", "alloc"], optional = true }
+sp-debug-derive = { version = "8.0.0", default-features = false, path = "../debug-derive" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"impl-serde/std",
+	"serde/std",
+	"sp-debug-derive/std",
+	"sp-std/std",
+]
+
+# Serde support without relying on std features.
+serde = [ "dep:serde", "impl-serde" ]
diff --git a/substrate/primitives/storage/README.md b/substrate/primitives/storage/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c33144fc4f66202804594d6cf0cc6886b5cad339
--- /dev/null
+++ b/substrate/primitives/storage/README.md
@@ -0,0 +1,3 @@
+Primitive types for storage related stuff.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/storage/src/lib.rs b/substrate/primitives/storage/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f8dc40f051c21cdd7b4a2e0f0df36bbd3f103d10
--- /dev/null
+++ b/substrate/primitives/storage/src/lib.rs
@@ -0,0 +1,482 @@
+// 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.
+
+//! Primitive types for storage related stuff.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use core::fmt::Display;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use sp_debug_derive::RuntimeDebug;
+
+use codec::{Decode, Encode};
+use ref_cast::RefCast;
+use sp_std::{
+	ops::{Deref, DerefMut},
+	vec::Vec,
+};
+
+/// Storage key.
+#[derive(PartialEq, Eq, RuntimeDebug)]
+#[cfg_attr(
+	feature = "serde",
+	derive(Serialize, Deserialize, Hash, PartialOrd, Ord, Clone, Encode, Decode)
+)]
+pub struct StorageKey(
+	#[cfg_attr(feature = "serde", serde(with = "impl_serde::serialize"))] pub Vec<u8>,
+);
+
+impl AsRef<[u8]> for StorageKey {
+	fn as_ref(&self) -> &[u8] {
+		self.0.as_ref()
+	}
+}
+
+/// Storage key with read/write tracking information.
+#[derive(
+	PartialEq, Eq, Ord, PartialOrd, sp_std::hash::Hash, RuntimeDebug, Clone, Encode, Decode,
+)]
+pub struct TrackedStorageKey {
+	pub key: Vec<u8>,
+	pub reads: u32,
+	pub writes: u32,
+	pub whitelisted: bool,
+}
+
+impl TrackedStorageKey {
+	/// Create a default `TrackedStorageKey`
+	pub fn new(key: Vec<u8>) -> Self {
+		Self { key, reads: 0, writes: 0, whitelisted: false }
+	}
+	/// Check if this key has been "read", i.e. it exists in the memory overlay.
+	///
+	/// Can be true if the key has been read, has been written to, or has been
+	/// whitelisted.
+	pub fn has_been_read(&self) -> bool {
+		self.whitelisted || self.reads > 0u32 || self.has_been_written()
+	}
+	/// Check if this key has been "written", i.e. a new value will be committed to the database.
+	///
+	/// Can be true if the key has been written to, or has been whitelisted.
+	pub fn has_been_written(&self) -> bool {
+		self.whitelisted || self.writes > 0u32
+	}
+	/// Add a storage read to this key.
+	pub fn add_read(&mut self) {
+		self.reads += 1;
+	}
+	/// Add a storage write to this key.
+	pub fn add_write(&mut self) {
+		self.writes += 1;
+	}
+	/// Whitelist this key.
+	pub fn whitelist(&mut self) {
+		self.whitelisted = true;
+	}
+}
+
+// Easily convert a key to a `TrackedStorageKey` that has been whitelisted.
+impl From<Vec<u8>> for TrackedStorageKey {
+	fn from(key: Vec<u8>) -> Self {
+		Self { key, reads: 0, writes: 0, whitelisted: true }
+	}
+}
+
+/// Storage key of a child trie, it contains the prefix to the key.
+#[derive(PartialEq, Eq, RuntimeDebug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize, Hash, PartialOrd, Ord, Clone))]
+#[repr(transparent)]
+#[derive(RefCast)]
+pub struct PrefixedStorageKey(
+	#[cfg_attr(feature = "serde", serde(with = "impl_serde::serialize"))] Vec<u8>,
+);
+
+impl Deref for PrefixedStorageKey {
+	type Target = Vec<u8>;
+
+	fn deref(&self) -> &Vec<u8> {
+		&self.0
+	}
+}
+
+impl DerefMut for PrefixedStorageKey {
+	fn deref_mut(&mut self) -> &mut Vec<u8> {
+		&mut self.0
+	}
+}
+
+impl PrefixedStorageKey {
+	/// Create a prefixed storage key from its byte array representation.
+	pub fn new(inner: Vec<u8>) -> Self {
+		PrefixedStorageKey(inner)
+	}
+
+	/// Create a prefixed storage key reference.
+	pub fn new_ref(inner: &Vec<u8>) -> &Self {
+		PrefixedStorageKey::ref_cast(inner)
+	}
+
+	/// Get inner key, this should only be needed when writing into parent trie to avoid an
+	/// allocation.
+	pub fn into_inner(self) -> Vec<u8> {
+		self.0
+	}
+}
+
+/// Storage data associated to a [`StorageKey`].
+#[derive(PartialEq, Eq, RuntimeDebug)]
+#[cfg_attr(
+	feature = "serde",
+	derive(Serialize, Deserialize, Hash, PartialOrd, Ord, Clone, Encode, Decode, Default)
+)]
+pub struct StorageData(
+	#[cfg_attr(feature = "serde", serde(with = "impl_serde::serialize"))] pub Vec<u8>,
+);
+
+/// Map of data to use in a storage, it is a collection of
+/// byte key and values.
+#[cfg(feature = "std")]
+pub type StorageMap = std::collections::BTreeMap<Vec<u8>, Vec<u8>>;
+
+/// Child trie storage data.
+#[cfg(feature = "std")]
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct StorageChild {
+	/// Child data for storage.
+	pub data: StorageMap,
+	/// Associated child info for a child
+	/// trie.
+	pub child_info: ChildInfo,
+}
+
+/// Struct containing data needed for a storage.
+#[cfg(feature = "std")]
+#[derive(Default, Debug, Clone)]
+pub struct Storage {
+	/// Top trie storage data.
+	pub top: StorageMap,
+	/// Children trie storage data. Key does not include prefix, only for the `default` trie kind,
+	/// of `ChildType::ParentKeyId` type.
+	pub children_default: std::collections::HashMap<Vec<u8>, StorageChild>,
+}
+
+/// Storage change set
+#[derive(RuntimeDebug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize, PartialEq, Eq))]
+#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
+pub struct StorageChangeSet<Hash> {
+	/// Block hash
+	pub block: Hash,
+	/// A list of changes
+	pub changes: Vec<(StorageKey, Option<StorageData>)>,
+}
+
+/// List of all well known keys and prefixes in storage.
+pub mod well_known_keys {
+	/// Wasm code of the runtime.
+	///
+	/// Stored as a raw byte vector. Required by substrate.
+	pub const CODE: &[u8] = b":code";
+
+	/// Number of wasm linear memory pages required for execution of the runtime.
+	///
+	/// The type of this value is encoded `u64`.
+	pub const HEAP_PAGES: &[u8] = b":heappages";
+
+	/// Current extrinsic index (u32) is stored under this key.
+	///
+	/// Encodes to `0x3a65787472696e7369635f696e646578`.
+	pub const EXTRINSIC_INDEX: &[u8] = b":extrinsic_index";
+
+	/// Current intra-block entropy (a universally unique `[u8; 32]` value) is stored here.
+	///
+	/// Encodes to `0x3a696e747261626c6f636b5f656e74726f7079`.
+	pub const INTRABLOCK_ENTROPY: &[u8] = b":intrablock_entropy";
+
+	/// Prefix of child storage keys.
+	pub const CHILD_STORAGE_KEY_PREFIX: &[u8] = b":child_storage:";
+
+	/// Prefix of the default child storage keys in the top trie.
+	pub const DEFAULT_CHILD_STORAGE_KEY_PREFIX: &[u8] = b":child_storage:default:";
+
+	/// Whether a key is a default child storage key.
+	///
+	/// This is convenience function which basically checks if the given `key` starts
+	/// with `DEFAULT_CHILD_STORAGE_KEY_PREFIX` and doesn't do anything apart from that.
+	pub fn is_default_child_storage_key(key: &[u8]) -> bool {
+		key.starts_with(DEFAULT_CHILD_STORAGE_KEY_PREFIX)
+	}
+
+	/// Whether a key is a child storage key.
+	///
+	/// This is convenience function which basically checks if the given `key` starts
+	/// with `CHILD_STORAGE_KEY_PREFIX` and doesn't do anything apart from that.
+	pub fn is_child_storage_key(key: &[u8]) -> bool {
+		// Other code might depend on this, so be careful changing this.
+		key.starts_with(CHILD_STORAGE_KEY_PREFIX)
+	}
+
+	/// Returns if the given `key` starts with [`CHILD_STORAGE_KEY_PREFIX`] or collides with it.
+	pub fn starts_with_child_storage_key(key: &[u8]) -> bool {
+		if key.len() > CHILD_STORAGE_KEY_PREFIX.len() {
+			key.starts_with(CHILD_STORAGE_KEY_PREFIX)
+		} else {
+			CHILD_STORAGE_KEY_PREFIX.starts_with(key)
+		}
+	}
+}
+
+/// Threshold size to start using trie value nodes in state.
+pub const TRIE_VALUE_NODE_THRESHOLD: u32 = 33;
+
+/// Information related to a child state.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(PartialEq, Eq, Hash, PartialOrd, Ord, Encode, Decode))]
+pub enum ChildInfo {
+	/// This is the one used by default.
+	ParentKeyId(ChildTrieParentKeyId),
+}
+
+impl ChildInfo {
+	/// Instantiates child information for a default child trie
+	/// of kind `ChildType::ParentKeyId`, using an unprefixed parent
+	/// storage key.
+	pub fn new_default(storage_key: &[u8]) -> Self {
+		let data = storage_key.to_vec();
+		ChildInfo::ParentKeyId(ChildTrieParentKeyId { data })
+	}
+
+	/// Same as `new_default` but with `Vec<u8>` as input.
+	pub fn new_default_from_vec(storage_key: Vec<u8>) -> Self {
+		ChildInfo::ParentKeyId(ChildTrieParentKeyId { data: storage_key })
+	}
+
+	/// Try to update with another instance, return false if both instance
+	/// are not compatible.
+	pub fn try_update(&mut self, other: &ChildInfo) -> bool {
+		match self {
+			ChildInfo::ParentKeyId(child_trie) => child_trie.try_update(other),
+		}
+	}
+
+	/// Returns byte sequence (keyspace) that can be use by underlying db to isolate keys.
+	/// This is a unique id of the child trie. The collision resistance of this value
+	/// depends on the type of child info use. For `ChildInfo::Default` it is and need to be.
+	#[inline]
+	pub fn keyspace(&self) -> &[u8] {
+		match self {
+			ChildInfo::ParentKeyId(..) => self.storage_key(),
+		}
+	}
+
+	/// Returns a reference to the location in the direct parent of
+	/// this trie but without the common prefix for this kind of
+	/// child trie.
+	pub fn storage_key(&self) -> &[u8] {
+		match self {
+			ChildInfo::ParentKeyId(ChildTrieParentKeyId { data }) => &data[..],
+		}
+	}
+
+	/// Return a the full location in the direct parent of
+	/// this trie.
+	pub fn prefixed_storage_key(&self) -> PrefixedStorageKey {
+		match self {
+			ChildInfo::ParentKeyId(ChildTrieParentKeyId { data }) =>
+				ChildType::ParentKeyId.new_prefixed_key(data.as_slice()),
+		}
+	}
+
+	/// Returns a the full location in the direct parent of
+	/// this trie.
+	pub fn into_prefixed_storage_key(self) -> PrefixedStorageKey {
+		match self {
+			ChildInfo::ParentKeyId(ChildTrieParentKeyId { mut data }) => {
+				ChildType::ParentKeyId.do_prefix_key(&mut data);
+				PrefixedStorageKey(data)
+			},
+		}
+	}
+
+	/// Returns the type for this child info.
+	pub fn child_type(&self) -> ChildType {
+		match self {
+			ChildInfo::ParentKeyId(..) => ChildType::ParentKeyId,
+		}
+	}
+}
+
+/// Type of child.
+/// It does not strictly define different child type, it can also
+/// be related to technical consideration or api variant.
+#[repr(u32)]
+#[derive(Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "std", derive(Debug))]
+pub enum ChildType {
+	/// If runtime module ensures that the child key is a unique id that will
+	/// only be used once, its parent key is used as a child trie unique id.
+	ParentKeyId = 1,
+}
+
+impl ChildType {
+	/// Try to get a child type from its `u32` representation.
+	pub fn new(repr: u32) -> Option<ChildType> {
+		Some(match repr {
+			r if r == ChildType::ParentKeyId as u32 => ChildType::ParentKeyId,
+			_ => return None,
+		})
+	}
+
+	/// Transform a prefixed key into a tuple of the child type
+	/// and the unprefixed representation of the key.
+	pub fn from_prefixed_key<'a>(storage_key: &'a PrefixedStorageKey) -> Option<(Self, &'a [u8])> {
+		let match_type = |storage_key: &'a [u8], child_type: ChildType| {
+			let prefix = child_type.parent_prefix();
+			if storage_key.starts_with(prefix) {
+				Some((child_type, &storage_key[prefix.len()..]))
+			} else {
+				None
+			}
+		};
+		match_type(storage_key, ChildType::ParentKeyId)
+	}
+
+	/// Produce a prefixed key for a given child type.
+	fn new_prefixed_key(&self, key: &[u8]) -> PrefixedStorageKey {
+		let parent_prefix = self.parent_prefix();
+		let mut result = Vec::with_capacity(parent_prefix.len() + key.len());
+		result.extend_from_slice(parent_prefix);
+		result.extend_from_slice(key);
+		PrefixedStorageKey(result)
+	}
+
+	/// Prefixes a vec with the prefix for this child type.
+	fn do_prefix_key(&self, key: &mut Vec<u8>) {
+		let parent_prefix = self.parent_prefix();
+		let key_len = key.len();
+		if !parent_prefix.is_empty() {
+			key.resize(key_len + parent_prefix.len(), 0);
+			key.copy_within(..key_len, parent_prefix.len());
+			key[..parent_prefix.len()].copy_from_slice(parent_prefix);
+		}
+	}
+
+	/// Returns the location reserved for this child trie in their parent trie if there
+	/// is one.
+	pub fn parent_prefix(&self) -> &'static [u8] {
+		match self {
+			&ChildType::ParentKeyId => well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX,
+		}
+	}
+}
+
+/// A child trie of default type.
+///
+/// It uses the same default implementation as the top trie, top trie being a child trie with no
+/// keyspace and no storage key. Its keyspace is the variable (unprefixed) part of its storage key.
+/// It shares its trie nodes backend storage with every other child trie, so its storage key needs
+/// to be a unique id that will be use only once. Those unique id also required to be long enough to
+/// avoid any unique id to be prefixed by an other unique id.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(PartialEq, Eq, Hash, PartialOrd, Ord, Encode, Decode))]
+pub struct ChildTrieParentKeyId {
+	/// Data is the storage key without prefix.
+	data: Vec<u8>,
+}
+
+impl ChildTrieParentKeyId {
+	/// Try to update with another instance, return false if both instance
+	/// are not compatible.
+	fn try_update(&mut self, other: &ChildInfo) -> bool {
+		match other {
+			ChildInfo::ParentKeyId(other) => self.data[..] == other.data[..],
+		}
+	}
+}
+
+/// Different possible state version.
+///
+/// V0 and V1 uses a same trie implementation, but V1 will write external value node in the trie for
+/// value with size at least `TRIE_VALUE_NODE_THRESHOLD`.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "std", derive(Encode, Decode))]
+pub enum StateVersion {
+	/// Old state version, no value nodes.
+	V0 = 0,
+	/// New state version can use value nodes.
+	V1 = 1,
+}
+
+impl Display for StateVersion {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		match self {
+			StateVersion::V0 => f.write_str("0"),
+			StateVersion::V1 => f.write_str("1"),
+		}
+	}
+}
+
+impl Default for StateVersion {
+	fn default() -> Self {
+		StateVersion::V1
+	}
+}
+
+impl From<StateVersion> for u8 {
+	fn from(version: StateVersion) -> u8 {
+		version as u8
+	}
+}
+
+impl TryFrom<u8> for StateVersion {
+	type Error = ();
+	fn try_from(val: u8) -> sp_std::result::Result<StateVersion, ()> {
+		match val {
+			0 => Ok(StateVersion::V0),
+			1 => Ok(StateVersion::V1),
+			_ => Err(()),
+		}
+	}
+}
+
+impl StateVersion {
+	/// If defined, values in state of size bigger or equal
+	/// to this threshold will use a separate trie node.
+	/// Otherwhise, value will be inlined in branch or leaf
+	/// node.
+	pub fn state_value_threshold(&self) -> Option<u32> {
+		match self {
+			StateVersion::V0 => None,
+			StateVersion::V1 => Some(TRIE_VALUE_NODE_THRESHOLD),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_prefix_default_child_info() {
+		let child_info = ChildInfo::new_default(b"any key");
+		let prefix = child_info.child_type().parent_prefix();
+		assert!(prefix.starts_with(well_known_keys::CHILD_STORAGE_KEY_PREFIX));
+		assert!(prefix.starts_with(well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX));
+	}
+}
diff --git a/substrate/primitives/test-primitives/Cargo.toml b/substrate/primitives/test-primitives/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a14f3fb9b8a4715ea048a93f1b9a8db0ce5bd201
--- /dev/null
+++ b/substrate/primitives/test-primitives/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "sp-test-primitives"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, features = ["derive"], optional = true }
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../application-crypto" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-application-crypto/std",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-std/std",
+]
+
+# Serde support without relying on std features.
+serde = [
+	"dep:serde",
+	"sp-application-crypto/serde",
+	"sp-core/serde",
+	"sp-runtime/serde",
+]
diff --git a/substrate/primitives/test-primitives/src/lib.rs b/substrate/primitives/test-primitives/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..82bdb6967b842914799493c6143a2287c85919e7
--- /dev/null
+++ b/substrate/primitives/test-primitives/src/lib.rs
@@ -0,0 +1,82 @@
+// 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.
+
+//! The Substrate test primitives to share
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+
+pub use sp_application_crypto;
+use sp_application_crypto::sr25519;
+
+pub use sp_core::{hash::H256, RuntimeDebug};
+use sp_runtime::traits::{BlakeTwo256, Extrinsic as ExtrinsicT, Verify};
+use sp_std::vec::Vec;
+
+/// Extrinsic for test-runtime.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, scale_info::TypeInfo)]
+pub enum Extrinsic {
+	IncludeData(Vec<u8>),
+	StorageChange(Vec<u8>, Option<Vec<u8>>),
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for Extrinsic {
+	fn serialize<S>(&self, seq: S) -> Result<S::Ok, S::Error>
+	where
+		S: ::serde::Serializer,
+	{
+		self.using_encoded(|bytes| seq.serialize_bytes(bytes))
+	}
+}
+
+impl ExtrinsicT for Extrinsic {
+	type Call = Extrinsic;
+	type SignaturePayload = ();
+
+	fn is_signed(&self) -> Option<bool> {
+		if let Extrinsic::IncludeData(_) = *self {
+			Some(false)
+		} else {
+			Some(true)
+		}
+	}
+
+	fn new(call: Self::Call, _signature_payload: Option<Self::SignaturePayload>) -> Option<Self> {
+		Some(call)
+	}
+}
+
+/// The signature type used by accounts/transactions.
+pub type AccountSignature = sr25519::Signature;
+/// An identifier for an account on this system.
+pub type AccountId = <AccountSignature as Verify>::Signer;
+/// A simple hash type for all our hashing.
+pub type Hash = H256;
+/// The block number type used in this runtime.
+pub type BlockNumber = u64;
+/// Index of a transaction.
+pub type Nonce = u64;
+/// The item of a block digest.
+pub type DigestItem = sp_runtime::generic::DigestItem;
+/// The digest of a block.
+pub type Digest = sp_runtime::generic::Digest;
+/// A test block.
+pub type Block = sp_runtime::generic::Block<Header, Extrinsic>;
+/// A test block's header.
+pub type Header = sp_runtime::generic::Header<BlockNumber, BlakeTwo256>;
diff --git a/substrate/primitives/timestamp/Cargo.toml b/substrate/primitives/timestamp/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..731a6a1b5d14345b4f8a035ed01481214f2ba0a2
--- /dev/null
+++ b/substrate/primitives/timestamp/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "sp-timestamp"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate core types and inherents for timestamps."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = { version = "0.1.57", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+thiserror = { version = "1.0.30", optional = true }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../inherents" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"async-trait",
+	"codec/std",
+	"sp-inherents/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"thiserror",
+]
diff --git a/substrate/primitives/timestamp/README.md b/substrate/primitives/timestamp/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a61a776912c93b4ab55525cba2d30146466ff905
--- /dev/null
+++ b/substrate/primitives/timestamp/README.md
@@ -0,0 +1,3 @@
+Substrate core types and inherents for timestamps.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/timestamp/src/lib.rs b/substrate/primitives/timestamp/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..eeec73efbc8bee691b43c7cbfd06f4a8399fe674
--- /dev/null
+++ b/substrate/primitives/timestamp/src/lib.rs
@@ -0,0 +1,249 @@
+// 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.
+
+//! Substrate core types and inherents for timestamps.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use codec::{Decode, Encode};
+use sp_inherents::{InherentData, InherentIdentifier, IsFatalError};
+use sp_std::time::Duration;
+
+/// The identifier for the `timestamp` inherent.
+pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"timstap0";
+
+/// The type of the inherent.
+pub type InherentType = Timestamp;
+
+/// Unit type wrapper that represents a timestamp.
+///
+/// Such a timestamp is the time since the UNIX_EPOCH in milliseconds at a given point in time.
+#[derive(Debug, Encode, Decode, Eq, Clone, Copy, Default, Ord)]
+pub struct Timestamp(u64);
+
+impl Timestamp {
+	/// Create new `Self`.
+	pub const fn new(inner: u64) -> Self {
+		Self(inner)
+	}
+
+	/// Returns `self` as [`Duration`].
+	pub const fn as_duration(self) -> Duration {
+		Duration::from_millis(self.0)
+	}
+
+	/// Returns `self` as a `u64` representing the elapsed time since the UNIX_EPOCH in
+	/// milliseconds.
+	pub const fn as_millis(&self) -> u64 {
+		self.0
+	}
+
+	/// Checked subtraction that returns `None` on an underflow.
+	pub fn checked_sub(self, other: Self) -> Option<Self> {
+		self.0.checked_sub(other.0).map(Self)
+	}
+
+	/// The current timestamp using the system time.
+	#[cfg(feature = "std")]
+	pub fn current() -> Self {
+		use std::time::SystemTime;
+
+		let now = SystemTime::now();
+		now.duration_since(SystemTime::UNIX_EPOCH)
+			.expect("Current time is always after unix epoch; qed")
+			.into()
+	}
+}
+
+impl sp_std::ops::Deref for Timestamp {
+	type Target = u64;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl core::ops::Add for Timestamp {
+	type Output = Self;
+
+	fn add(self, other: Self) -> Self {
+		Self(self.0 + other.0)
+	}
+}
+
+impl core::ops::Add<u64> for Timestamp {
+	type Output = Self;
+
+	fn add(self, other: u64) -> Self {
+		Self(self.0 + other)
+	}
+}
+
+impl<T: Into<u64> + Copy> core::cmp::PartialEq<T> for Timestamp {
+	fn eq(&self, eq: &T) -> bool {
+		self.0 == (*eq).into()
+	}
+}
+
+impl<T: Into<u64> + Copy> core::cmp::PartialOrd<T> for Timestamp {
+	fn partial_cmp(&self, other: &T) -> Option<core::cmp::Ordering> {
+		self.0.partial_cmp(&(*other).into())
+	}
+}
+
+#[cfg(feature = "std")]
+impl std::fmt::Display for Timestamp {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.0)
+	}
+}
+
+impl From<u64> for Timestamp {
+	fn from(timestamp: u64) -> Self {
+		Timestamp(timestamp)
+	}
+}
+
+impl From<Timestamp> for u64 {
+	fn from(timestamp: Timestamp) -> u64 {
+		timestamp.0
+	}
+}
+
+impl From<Duration> for Timestamp {
+	fn from(duration: Duration) -> Self {
+		Timestamp(duration.as_millis() as u64)
+	}
+}
+
+/// Errors that can occur while checking the timestamp inherent.
+#[derive(Encode, sp_runtime::RuntimeDebug)]
+#[cfg_attr(feature = "std", derive(Decode, thiserror::Error))]
+pub enum InherentError {
+	/// The time between the blocks is too short.
+	#[cfg_attr(
+		feature = "std",
+		error("The time since the last timestamp is lower than the minimum period.")
+	)]
+	TooEarly,
+	/// The block timestamp is too far in the future
+	#[cfg_attr(feature = "std", error("The timestamp of the block is too far in the future."))]
+	TooFarInFuture,
+}
+
+impl IsFatalError for InherentError {
+	fn is_fatal_error(&self) -> bool {
+		match self {
+			InherentError::TooEarly => true,
+			InherentError::TooFarInFuture => true,
+		}
+	}
+}
+
+impl InherentError {
+	/// Try to create an instance ouf of the given identifier and data.
+	#[cfg(feature = "std")]
+	pub fn try_from(id: &InherentIdentifier, mut data: &[u8]) -> Option<Self> {
+		if id == &INHERENT_IDENTIFIER {
+			<InherentError as codec::Decode>::decode(&mut data).ok()
+		} else {
+			None
+		}
+	}
+}
+
+/// Auxiliary trait to extract timestamp inherent data.
+pub trait TimestampInherentData {
+	/// Get timestamp inherent data.
+	fn timestamp_inherent_data(&self) -> Result<Option<InherentType>, sp_inherents::Error>;
+}
+
+impl TimestampInherentData for InherentData {
+	fn timestamp_inherent_data(&self) -> Result<Option<InherentType>, sp_inherents::Error> {
+		self.get_data(&INHERENT_IDENTIFIER)
+	}
+}
+
+/// Provide duration since unix epoch in millisecond for timestamp inherent.
+#[cfg(feature = "std")]
+pub struct InherentDataProvider {
+	max_drift: InherentType,
+	timestamp: InherentType,
+}
+
+#[cfg(feature = "std")]
+impl InherentDataProvider {
+	/// Create `Self` while using the system time to get the timestamp.
+	pub fn from_system_time() -> Self {
+		Self {
+			max_drift: std::time::Duration::from_secs(60).into(),
+			timestamp: Timestamp::current(),
+		}
+	}
+
+	/// Create `Self` using the given `timestamp`.
+	pub fn new(timestamp: InherentType) -> Self {
+		Self { max_drift: std::time::Duration::from_secs(60).into(), timestamp }
+	}
+
+	/// With the given maximum drift.
+	///
+	/// By default the maximum drift is 60 seconds.
+	///
+	/// The maximum drift is used when checking the inherents of a runtime. If the current timestamp
+	/// plus the maximum drift is smaller than the timestamp in the block, the block will be
+	/// rejected as being too far in the future.
+	pub fn with_max_drift(mut self, max_drift: std::time::Duration) -> Self {
+		self.max_drift = max_drift.into();
+		self
+	}
+
+	/// Returns the timestamp of this inherent data provider.
+	pub fn timestamp(&self) -> InherentType {
+		self.timestamp
+	}
+}
+
+#[cfg(feature = "std")]
+impl sp_std::ops::Deref for InherentDataProvider {
+	type Target = InherentType;
+
+	fn deref(&self) -> &Self::Target {
+		&self.timestamp
+	}
+}
+
+#[cfg(feature = "std")]
+#[async_trait::async_trait]
+impl sp_inherents::InherentDataProvider for InherentDataProvider {
+	async fn provide_inherent_data(
+		&self,
+		inherent_data: &mut InherentData,
+	) -> Result<(), sp_inherents::Error> {
+		inherent_data.put_data(INHERENT_IDENTIFIER, &self.timestamp)
+	}
+
+	async fn try_handle_error(
+		&self,
+		identifier: &InherentIdentifier,
+		error: &[u8],
+	) -> Option<Result<(), sp_inherents::Error>> {
+		Some(Err(sp_inherents::Error::Application(Box::from(InherentError::try_from(
+			identifier, error,
+		)?))))
+	}
+}
diff --git a/substrate/primitives/tracing/Cargo.toml b/substrate/primitives/tracing/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..106e3a725cd06368ded6de6c6ef9518ac05a13b5
--- /dev/null
+++ b/substrate/primitives/tracing/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "sp-tracing"
+version = "10.0.0"
+license = "Apache-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Instrumentation primitives and macros for Substrate."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+# let's default to wasm32
+default-target = "wasm32-unknown-unknown"
+# with the tracing enabled
+features = ["with-tracing"]
+# allowing for linux-gnu here, too, allows for `std` to show up as well
+targets = ["x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"]
+
+[dependencies]
+sp-std = { version = "8.0.0", path = "../std", default-features = false }
+codec = { version = "3.6.1", package = "parity-scale-codec", default-features = false, features = [
+	"derive",
+] }
+tracing = { version = "0.1.29", default-features = false }
+tracing-core = { version = "0.1.28", default-features = false }
+tracing-subscriber = { version = "0.2.25", optional = true, features = [
+	"tracing-log",
+] }
+
+[features]
+default = [ "std" ]
+with-tracing = [ "codec/derive", "codec/full" ]
+std = [
+	"codec/std",
+	"sp-std/std",
+	"tracing-core/std",
+	"tracing-subscriber",
+	"tracing/std",
+	"with-tracing",
+]
diff --git a/substrate/primitives/tracing/README.md b/substrate/primitives/tracing/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d66bb90016c7184e7178d437ab6944e4e36faee2
--- /dev/null
+++ b/substrate/primitives/tracing/README.md
@@ -0,0 +1,15 @@
+Substrate tracing primitives and macros.
+
+To trace functions or individual code in Substrate, this crate provides [`within_span`]
+and [`enter_span`]. See the individual docs for how to use these macros.
+
+Note that to allow traces from wasm execution environment there are
+2 reserved identifiers for tracing `Field` recording, stored in the consts:
+`WASM_TARGET_KEY` and `WASM_NAME_KEY` - if you choose to record fields, you
+must ensure that your identifiers do not clash with either of these.
+
+Additionally, we have a const: `WASM_TRACE_IDENTIFIER`, which holds a span name used
+to signal that the 'actual' span name and target should be retrieved instead from
+the associated Fields mentioned above.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/tracing/src/lib.rs b/substrate/primitives/tracing/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cc65183684667b404d88a2b61ef6105f176b6336
--- /dev/null
+++ b/substrate/primitives/tracing/src/lib.rs
@@ -0,0 +1,252 @@
+// 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.
+
+//! Substrate tracing primitives and macros.
+//!
+//! To trace functions or invidual code in Substrate, this crate provides [`within_span`]
+//! and [`enter_span`]. See the individual docs for how to use these macros.
+//!
+//! Note that to allow traces from wasm execution environment there are
+//! 2 reserved identifiers for tracing `Field` recording, stored in the consts:
+//! `WASM_TARGET_KEY` and `WASM_NAME_KEY` - if you choose to record fields, you
+//! must ensure that your identifiers do not clash with either of these.
+//!
+//! Additionally, we have a const: `WASM_TRACE_IDENTIFIER`, which holds a span name used
+//! to signal that the 'actual' span name and target should be retrieved instead from
+//! the associated Fields mentioned above.
+//!
+//! Note: The `tracing` crate requires trace metadata to be static. This does not work
+//! for wasm code in substrate, as it is regularly updated with new code from on-chain
+//! events. The workaround for this is for the wasm tracing wrappers to put the
+//! `name` and `target` data in the `values` map (normally they would be in the static
+//! metadata assembled at compile time).
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "std")]
+use tracing;
+pub use tracing::{
+	debug, debug_span, error, error_span, event, info, info_span, span, trace, trace_span, warn,
+	warn_span, Level, Span,
+};
+
+pub use crate::types::{
+	WasmEntryAttributes, WasmFieldName, WasmFields, WasmLevel, WasmMetadata, WasmValue,
+	WasmValuesSet,
+};
+#[cfg(feature = "std")]
+pub use crate::types::{WASM_NAME_KEY, WASM_TARGET_KEY, WASM_TRACE_IDENTIFIER};
+
+/// Tracing facilities and helpers.
+///
+/// This is modeled after the `tracing`/`tracing-core` interface and uses that more or
+/// less directly for the native side. Because of certain optimisations the these crates
+/// have done, the wasm implementation diverges slightly and is optimised for that use
+/// case (like being able to cross the wasm/native boundary via scale codecs).
+///
+/// One of said optimisations is that all macros will yield to a `noop` in non-std unless
+/// the `with-tracing` feature is explicitly activated. This allows you to just use the
+/// tracing wherever you deem fit and without any performance impact by default. Only if
+/// the specific `with-tracing`-feature is activated on this crate will it actually include
+/// the tracing code in the non-std environment.
+///
+/// Because of that optimisation, you should not use the `span!` and `span_*!` macros
+/// directly as they yield nothing without the feature present. Instead you should use
+/// `enter_span!` and `within_span!` – which would strip away even any parameter conversion
+/// you do within the span-definition (and thus optimise your performance). For your
+/// convineience you directly specify the `Level` and name of the span or use the full
+/// feature set of `span!`/`span_*!` on it:
+///
+/// # Example
+///
+/// ```rust
+/// sp_tracing::enter_span!(sp_tracing::Level::TRACE, "fn wide span");
+/// {
+/// 		sp_tracing::enter_span!(sp_tracing::trace_span!("outer-span"));
+/// 		{
+/// 			sp_tracing::enter_span!(sp_tracing::Level::TRACE, "inner-span");
+/// 			// ..
+/// 		}  // inner span exists here
+/// 	} // outer span exists here
+///
+/// sp_tracing::within_span! {
+/// 		sp_tracing::debug_span!("debug-span", you_can_pass="any params");
+///     1 + 1;
+///     // some other complex code
+/// } // debug span ends here
+/// ```
+///
+///
+/// # Setup
+///
+/// This project only provides the macros and facilities to manage tracing
+/// it doesn't implement the tracing subscriber or backend directly – that is
+/// up to the developer integrating it into a specific environment. In native
+/// this can and must be done through the regular `tracing`-facitilies, please
+/// see their documentation for details.
+///
+/// On the wasm-side we've adopted a similar approach of having a global
+/// `TracingSubscriber` that the macros call and that does the actual work
+/// of tracking. To provide your tracking, you must implement `TracingSubscriber`
+/// and call `set_tracing_subscriber` at the very beginning of your execution –
+/// the default subscriber is doing nothing, so any spans or events happening before
+/// will not be recorded!
+mod types;
+
+/// Try to init a simple tracing subscriber with log compatibility layer.
+///
+/// Ignores any error. Useful for testing.
+#[cfg(feature = "std")]
+pub fn try_init_simple() {
+	let _ = tracing_subscriber::fmt()
+		.with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
+		.with_writer(std::io::stderr)
+		.try_init();
+}
+
+/// Init a tracing subscriber for logging in tests.
+///
+/// Be aware that this enables `TRACE` by default. It also ignores any error
+/// while setting up the logger.
+///
+/// The logs are not shown by default, logs are only shown when the test fails
+/// or if [`nocapture`](https://doc.rust-lang.org/cargo/commands/cargo-test.html#display-options)
+/// is being used.
+#[cfg(feature = "std")]
+pub fn init_for_tests() {
+	let _ = tracing_subscriber::fmt()
+		.with_max_level(tracing::Level::TRACE)
+		.with_test_writer()
+		.try_init();
+}
+
+/// Runs given code within a tracing span, measuring it's execution time.
+///
+/// If tracing is not enabled, the code is still executed. Pass in level and name or
+/// use any valid `sp_tracing::Span`followe by `;` and the code to execute,
+///
+/// # Example
+///
+/// ```
+/// sp_tracing::within_span! {
+///     sp_tracing::Level::TRACE,
+///     "test-span";
+///     1 + 1;
+///     // some other complex code
+/// }
+///
+/// sp_tracing::within_span! {
+///     sp_tracing::span!(sp_tracing::Level::WARN, "warn-span", you_can_pass="any params");
+///     1 + 1;
+///     // some other complex code
+/// }
+///
+/// sp_tracing::within_span! {
+///     sp_tracing::debug_span!("debug-span", you_can_pass="any params");
+///     1 + 1;
+///     // some other complex code
+/// }
+/// ```
+#[cfg(any(feature = "std", feature = "with-tracing"))]
+#[macro_export]
+macro_rules! within_span {
+	(
+		$span:expr;
+		$( $code:tt )*
+	) => {
+		$span.in_scope(||
+			{
+				$( $code )*
+			}
+		)
+	};
+	(
+		$lvl:expr,
+		$name:expr;
+		$( $code:tt )*
+	) => {
+		{
+			$crate::within_span!($crate::span!($lvl, $name); $( $code )*)
+		}
+	};
+}
+
+#[cfg(all(not(feature = "std"), not(feature = "with-tracing")))]
+#[macro_export]
+macro_rules! within_span {
+	(
+		$span:stmt;
+		$( $code:tt )*
+	) => {
+		$( $code )*
+	};
+	(
+		$lvl:expr,
+		$name:expr;
+		$( $code:tt )*
+	) => {
+		$( $code )*
+	};
+}
+
+/// Enter a span - noop for `no_std` without `with-tracing`
+#[cfg(all(not(feature = "std"), not(feature = "with-tracing")))]
+#[macro_export]
+macro_rules! enter_span {
+	( $lvl:expr, $name:expr ) => {};
+	( $name:expr ) => {}; // no-op
+}
+
+/// Enter a span.
+///
+/// The span will be valid, until the scope is left. Use either level and name
+/// or pass in any valid `sp_tracing::Span` for extended usage. The span will
+/// be exited on drop – which is at the end of the block or to the next
+/// `enter_span!` calls, as this overwrites the local variable. For nested
+/// usage or to ensure the span closes at certain time either put it into a block
+/// or use `within_span!`
+///
+/// # Example
+///
+/// ```
+/// sp_tracing::enter_span!(sp_tracing::Level::TRACE, "test-span");
+/// // previous will be dropped here
+/// sp_tracing::enter_span!(
+/// 	sp_tracing::span!(sp_tracing::Level::DEBUG, "debug-span", params="value"));
+/// sp_tracing::enter_span!(sp_tracing::info_span!("info-span",  params="value"));
+///
+/// {
+/// 		sp_tracing::enter_span!(sp_tracing::Level::TRACE, "outer-span");
+/// 		{
+/// 			sp_tracing::enter_span!(sp_tracing::Level::TRACE, "inner-span");
+/// 			// ..
+/// 		}  // inner span exists here
+/// 	} // outer span exists here
+/// ```
+#[cfg(any(feature = "std", feature = "with-tracing"))]
+#[macro_export]
+macro_rules! enter_span {
+	( $span:expr ) => {
+		// Calling this twice in a row will overwrite (and drop) the earlier
+		// that is a _documented feature_!
+		let __within_span__ = $span;
+		let __tracing_guard__ = __within_span__.enter();
+	};
+	( $lvl:expr, $name:expr ) => {
+		$crate::enter_span!($crate::span!($lvl, $name))
+	};
+}
diff --git a/substrate/primitives/tracing/src/types.rs b/substrate/primitives/tracing/src/types.rs
new file mode 100644
index 0000000000000000000000000000000000000000..003787f310d8c73637189189e58297b2bc5345e4
--- /dev/null
+++ b/substrate/primitives/tracing/src/types.rs
@@ -0,0 +1,669 @@
+// 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 codec::{Decode, Encode};
+/// Types for wasm based tracing. Loosly inspired by `tracing-core` but
+/// optimised for the specific use case.
+use core::{fmt::Debug, format_args};
+use sp_std::{vec, vec::Vec, Writer};
+
+/// The Tracing Level – the user can filter by this
+#[derive(Clone, Encode, Decode, Debug)]
+pub enum WasmLevel {
+	/// This is a fatal errors
+	ERROR,
+	/// This is a warning you should be aware of
+	WARN,
+	/// Nice to now info
+	INFO,
+	/// Further information for debugging purposes
+	DEBUG,
+	/// The lowest level, keeping track of minute detail
+	TRACE,
+}
+
+impl From<&tracing_core::Level> for WasmLevel {
+	fn from(l: &tracing_core::Level) -> WasmLevel {
+		match *l {
+			tracing_core::Level::ERROR => WasmLevel::ERROR,
+			tracing_core::Level::WARN => WasmLevel::WARN,
+			tracing_core::Level::INFO => WasmLevel::INFO,
+			tracing_core::Level::DEBUG => WasmLevel::DEBUG,
+			tracing_core::Level::TRACE => WasmLevel::TRACE,
+		}
+	}
+}
+
+impl core::default::Default for WasmLevel {
+	fn default() -> Self {
+		WasmLevel::TRACE
+	}
+}
+
+/// A paramter value provided to the span/event
+#[derive(Encode, Decode, Clone)]
+pub enum WasmValue {
+	U8(u8),
+	I8(i8),
+	U32(u32),
+	I32(i32),
+	I64(i64),
+	U64(u64),
+	Bool(bool),
+	Str(Vec<u8>),
+	/// Debug or Display call, this is most-likely a print-able UTF8 String
+	Formatted(Vec<u8>),
+	/// SCALE CODEC encoded object – the name should allow the received to know
+	/// how to decode this.
+	Encoded(Vec<u8>),
+}
+
+impl core::fmt::Debug for WasmValue {
+	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+		match self {
+			WasmValue::U8(ref i) => f.write_fmt(format_args!("{}_u8", i)),
+			WasmValue::I8(ref i) => f.write_fmt(format_args!("{}_i8", i)),
+			WasmValue::U32(ref i) => f.write_fmt(format_args!("{}_u32", i)),
+			WasmValue::I32(ref i) => f.write_fmt(format_args!("{}_i32", i)),
+			WasmValue::I64(ref i) => f.write_fmt(format_args!("{}_i64", i)),
+			WasmValue::U64(ref i) => f.write_fmt(format_args!("{}_u64", i)),
+			WasmValue::Bool(ref i) => f.write_fmt(format_args!("{}_bool", i)),
+			WasmValue::Formatted(ref i) | WasmValue::Str(ref i) => {
+				if let Ok(v) = core::str::from_utf8(i) {
+					f.write_fmt(format_args!("{}", v))
+				} else {
+					f.write_fmt(format_args!("{:?}", i))
+				}
+			},
+			WasmValue::Encoded(ref v) => {
+				f.write_str("Scale(")?;
+				for byte in v {
+					f.write_fmt(format_args!("{:02x}", byte))?;
+				}
+				f.write_str(")")
+			},
+		}
+	}
+}
+
+impl From<u8> for WasmValue {
+	fn from(u: u8) -> WasmValue {
+		WasmValue::U8(u)
+	}
+}
+
+impl From<&i8> for WasmValue {
+	fn from(inp: &i8) -> WasmValue {
+		WasmValue::I8(*inp)
+	}
+}
+
+impl From<&str> for WasmValue {
+	fn from(inp: &str) -> WasmValue {
+		WasmValue::Str(inp.as_bytes().to_vec())
+	}
+}
+
+impl From<&&str> for WasmValue {
+	fn from(inp: &&str) -> WasmValue {
+		WasmValue::Str((*inp).as_bytes().to_vec())
+	}
+}
+
+impl From<bool> for WasmValue {
+	fn from(inp: bool) -> WasmValue {
+		WasmValue::Bool(inp)
+	}
+}
+
+impl From<core::fmt::Arguments<'_>> for WasmValue {
+	fn from(inp: core::fmt::Arguments<'_>) -> WasmValue {
+		let mut buf = Writer::default();
+		core::fmt::write(&mut buf, inp).expect("Writing of arguments doesn't fail");
+		WasmValue::Formatted(buf.into_inner())
+	}
+}
+
+impl From<i8> for WasmValue {
+	fn from(u: i8) -> WasmValue {
+		WasmValue::I8(u)
+	}
+}
+
+impl From<i32> for WasmValue {
+	fn from(u: i32) -> WasmValue {
+		WasmValue::I32(u)
+	}
+}
+
+impl From<&i32> for WasmValue {
+	fn from(u: &i32) -> WasmValue {
+		WasmValue::I32(*u)
+	}
+}
+
+impl From<u32> for WasmValue {
+	fn from(u: u32) -> WasmValue {
+		WasmValue::U32(u)
+	}
+}
+
+impl From<&u32> for WasmValue {
+	fn from(u: &u32) -> WasmValue {
+		WasmValue::U32(*u)
+	}
+}
+
+impl From<u64> for WasmValue {
+	fn from(u: u64) -> WasmValue {
+		WasmValue::U64(u)
+	}
+}
+
+impl From<i64> for WasmValue {
+	fn from(u: i64) -> WasmValue {
+		WasmValue::I64(u)
+	}
+}
+
+/// The name of a field provided as the argument name when contstructing an
+/// `event!` or `span!`.
+/// Generally generated automaticaly via `stringify` from an `'static &str`.
+/// Likely print-able.
+#[derive(Encode, Decode, Clone)]
+pub struct WasmFieldName(Vec<u8>);
+
+impl core::fmt::Debug for WasmFieldName {
+	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+		if let Ok(v) = core::str::from_utf8(&self.0) {
+			f.write_fmt(format_args!("{}", v))
+		} else {
+			for byte in self.0.iter() {
+				f.write_fmt(format_args!("{:02x}", byte))?;
+			}
+			Ok(())
+		}
+	}
+}
+
+impl From<Vec<u8>> for WasmFieldName {
+	fn from(v: Vec<u8>) -> Self {
+		WasmFieldName(v)
+	}
+}
+
+impl From<&str> for WasmFieldName {
+	fn from(v: &str) -> Self {
+		WasmFieldName(v.as_bytes().to_vec())
+	}
+}
+
+/// A list of `WasmFieldName`s in the order provided
+#[derive(Encode, Decode, Clone, Debug)]
+pub struct WasmFields(Vec<WasmFieldName>);
+
+impl WasmFields {
+	/// Iterate over the fields
+	pub fn iter(&self) -> core::slice::Iter<'_, WasmFieldName> {
+		self.0.iter()
+	}
+}
+
+impl From<Vec<WasmFieldName>> for WasmFields {
+	fn from(v: Vec<WasmFieldName>) -> WasmFields {
+		WasmFields(v)
+	}
+}
+
+impl From<Vec<&str>> for WasmFields {
+	fn from(v: Vec<&str>) -> WasmFields {
+		WasmFields(v.into_iter().map(|v| v.into()).collect())
+	}
+}
+
+impl WasmFields {
+	/// Create an empty entry
+	pub fn empty() -> Self {
+		WasmFields(Vec::with_capacity(0))
+	}
+}
+
+impl From<&tracing_core::field::FieldSet> for WasmFields {
+	fn from(wm: &tracing_core::field::FieldSet) -> WasmFields {
+		WasmFields(wm.iter().map(|s| s.name().into()).collect())
+	}
+}
+
+/// A list of `WasmFieldName`s with the given `WasmValue` (if provided)
+/// in the order specified.
+#[derive(Encode, Decode, Clone)]
+pub struct WasmValuesSet(Vec<(WasmFieldName, Option<WasmValue>)>);
+
+impl core::fmt::Debug for WasmValuesSet {
+	fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+		let mut wrt = f.debug_struct("");
+		let mut non_str = false;
+		for (f, v) in self.0.iter() {
+			if let Ok(s) = core::str::from_utf8(&f.0) {
+				match v {
+					Some(ref i) => wrt.field(s, i),
+					None => wrt.field(s, &(None as Option<WasmValue>)),
+				};
+			} else {
+				non_str = true;
+			}
+		}
+
+		// FIXME: replace with using `finish_non_exhaustive()` once stable
+		//        https://github.com/rust-lang/rust/issues/67364
+		if non_str {
+			wrt.field("..", &"..");
+		}
+
+		wrt.finish()
+	}
+}
+
+impl From<Vec<(WasmFieldName, Option<WasmValue>)>> for WasmValuesSet {
+	fn from(v: Vec<(WasmFieldName, Option<WasmValue>)>) -> Self {
+		WasmValuesSet(v)
+	}
+}
+impl From<Vec<(&&WasmFieldName, Option<WasmValue>)>> for WasmValuesSet {
+	fn from(v: Vec<(&&WasmFieldName, Option<WasmValue>)>) -> Self {
+		WasmValuesSet(v.into_iter().map(|(k, v)| ((**k).clone(), v)).collect())
+	}
+}
+
+impl From<Vec<(&&str, Option<WasmValue>)>> for WasmValuesSet {
+	fn from(v: Vec<(&&str, Option<WasmValue>)>) -> Self {
+		WasmValuesSet(v.into_iter().map(|(k, v)| ((*k).into(), v)).collect())
+	}
+}
+
+impl WasmValuesSet {
+	/// Create an empty entry
+	pub fn empty() -> Self {
+		WasmValuesSet(Vec::with_capacity(0))
+	}
+}
+
+impl tracing_core::field::Visit for WasmValuesSet {
+	fn record_debug(&mut self, field: &tracing_core::field::Field, value: &dyn Debug) {
+		self.0
+			.push((field.name().into(), Some(WasmValue::from(format_args!("{:?}", value)))))
+	}
+	fn record_i64(&mut self, field: &tracing_core::field::Field, value: i64) {
+		self.0.push((field.name().into(), Some(WasmValue::from(value))))
+	}
+	fn record_u64(&mut self, field: &tracing_core::field::Field, value: u64) {
+		self.0.push((field.name().into(), Some(WasmValue::from(value))))
+	}
+	fn record_bool(&mut self, field: &tracing_core::field::Field, value: bool) {
+		self.0.push((field.name().into(), Some(WasmValue::from(value))))
+	}
+	fn record_str(&mut self, field: &tracing_core::field::Field, value: &str) {
+		self.0.push((field.name().into(), Some(WasmValue::from(value))))
+	}
+}
+/// Metadata provides generic information about the specifc location of the
+/// `span!` or `event!` call on the wasm-side.
+#[derive(Encode, Decode, Clone)]
+pub struct WasmMetadata {
+	/// The name given to `event!`/`span!`, `&'static str` converted to bytes
+	pub name: Vec<u8>,
+	/// The given target to `event!`/`span!` – or module-name, `&'static str` converted to bytes
+	pub target: Vec<u8>,
+	/// The level of this entry
+	pub level: WasmLevel,
+	/// The file this was emitted from – useful for debugging;  `&'static str` converted to bytes
+	pub file: Vec<u8>,
+	/// The specific line number in the file – useful for debugging
+	pub line: u32,
+	/// The module path;  `&'static str` converted to bytes
+	pub module_path: Vec<u8>,
+	/// Whether this is a call  to `span!` or `event!`
+	pub is_span: bool,
+	/// The list of fields specified in the call
+	pub fields: WasmFields,
+}
+
+impl From<&tracing_core::Metadata<'_>> for WasmMetadata {
+	fn from(wm: &tracing_core::Metadata<'_>) -> WasmMetadata {
+		WasmMetadata {
+			name: wm.name().as_bytes().to_vec(),
+			target: wm.target().as_bytes().to_vec(),
+			level: wm.level().into(),
+			file: wm.file().map(|f| f.as_bytes().to_vec()).unwrap_or_default(),
+			line: wm.line().unwrap_or_default(),
+			module_path: wm.module_path().map(|m| m.as_bytes().to_vec()).unwrap_or_default(),
+			is_span: wm.is_span(),
+			fields: wm.fields().into(),
+		}
+	}
+}
+
+impl core::fmt::Debug for WasmMetadata {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		f.debug_struct("WasmMetadata")
+			.field("name", &decode_field(&self.name))
+			.field("target", &decode_field(&self.target))
+			.field("level", &self.level)
+			.field("file", &decode_field(&self.file))
+			.field("line", &self.line)
+			.field("module_path", &decode_field(&self.module_path))
+			.field("is_span", &self.is_span)
+			.field("fields", &self.fields)
+			.finish()
+	}
+}
+
+impl core::default::Default for WasmMetadata {
+	fn default() -> Self {
+		let target = "default".as_bytes().to_vec();
+		WasmMetadata {
+			target,
+			name: Default::default(),
+			level: Default::default(),
+			file: Default::default(),
+			line: Default::default(),
+			module_path: Default::default(),
+			is_span: true,
+			fields: WasmFields::empty(),
+		}
+	}
+}
+
+fn decode_field(field: &[u8]) -> &str {
+	core::str::from_utf8(field).unwrap_or_default()
+}
+
+/// Span or Event Attributes
+#[derive(Encode, Decode, Clone, Debug)]
+pub struct WasmEntryAttributes {
+	/// the parent, if directly specified – otherwise assume most inner span
+	pub parent_id: Option<u64>,
+	/// the metadata of the location
+	pub metadata: WasmMetadata,
+	/// the Values provided
+	pub fields: WasmValuesSet,
+}
+
+impl From<&tracing_core::Event<'_>> for WasmEntryAttributes {
+	fn from(evt: &tracing_core::Event<'_>) -> WasmEntryAttributes {
+		let mut fields = WasmValuesSet(Vec::new());
+		evt.record(&mut fields);
+		WasmEntryAttributes {
+			parent_id: evt.parent().map(|id| id.into_u64()),
+			metadata: evt.metadata().into(),
+			fields,
+		}
+	}
+}
+
+impl From<&tracing_core::span::Attributes<'_>> for WasmEntryAttributes {
+	fn from(attrs: &tracing_core::span::Attributes<'_>) -> WasmEntryAttributes {
+		let mut fields = WasmValuesSet(Vec::new());
+		attrs.record(&mut fields);
+		WasmEntryAttributes {
+			parent_id: attrs.parent().map(|id| id.into_u64()),
+			metadata: attrs.metadata().into(),
+			fields,
+		}
+	}
+}
+
+impl core::default::Default for WasmEntryAttributes {
+	fn default() -> Self {
+		WasmEntryAttributes {
+			parent_id: None,
+			metadata: Default::default(),
+			fields: WasmValuesSet(vec![]),
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+mod std_features {
+
+	use tracing_core::callsite;
+
+	/// Static entry use for wasm-originated metadata.
+	pub struct WasmCallsite;
+	impl callsite::Callsite for WasmCallsite {
+		fn set_interest(&self, _: tracing_core::Interest) {
+			unimplemented!()
+		}
+		fn metadata(&self) -> &tracing_core::Metadata {
+			unimplemented!()
+		}
+	}
+	static CALLSITE: WasmCallsite = WasmCallsite;
+	/// The identifier we are using to inject the wasm events in the generic `tracing` system
+	pub static WASM_TRACE_IDENTIFIER: &str = "wasm_tracing";
+	/// The fieldname for the wasm-originated name
+	pub static WASM_NAME_KEY: &str = "name";
+	/// The fieldname for the wasm-originated target
+	pub static WASM_TARGET_KEY: &str = "target";
+	/// The the list of all static field names we construct from the given metadata
+	pub static GENERIC_FIELDS: &[&str] =
+		&[WASM_TARGET_KEY, WASM_NAME_KEY, "file", "line", "module_path", "params"];
+
+	// Implementation Note:
+	// the original `tracing` crate generates these static metadata entries at every `span!` and
+	// `event!` location to allow for highly optimised filtering. For us to allow level-based
+	// emitting of wasm events we need these static metadata entries to inject into that system. We
+	// then provide generic `From`-implementations picking the right metadata to refer to.
+
+	static SPAN_ERROR_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::ERROR,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::SPAN,
+	);
+
+	static SPAN_WARN_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::WARN,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::SPAN,
+	);
+	static SPAN_INFO_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::INFO,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::SPAN,
+	);
+
+	static SPAN_DEBUG_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::DEBUG,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::SPAN,
+	);
+
+	static SPAN_TRACE_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::TRACE,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::SPAN,
+	);
+
+	static EVENT_ERROR_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::ERROR,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::EVENT,
+	);
+
+	static EVENT_WARN_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::WARN,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::EVENT,
+	);
+
+	static EVENT_INFO_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::INFO,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::EVENT,
+	);
+
+	static EVENT_DEBUG_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::DEBUG,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::EVENT,
+	);
+
+	static EVENT_TRACE_METADATA: tracing_core::Metadata<'static> = tracing::Metadata::new(
+		WASM_TRACE_IDENTIFIER,
+		WASM_TRACE_IDENTIFIER,
+		tracing::Level::TRACE,
+		None,
+		None,
+		None,
+		tracing_core::field::FieldSet::new(
+			GENERIC_FIELDS,
+			tracing_core::identify_callsite!(&CALLSITE),
+		),
+		tracing_core::metadata::Kind::EVENT,
+	);
+
+	// FIXME: this could be done a lot in 0.2 if they opt for using `Cow<str,'static>` instead
+	// 			https://github.com/paritytech/substrate/issues/7134
+	impl From<&crate::WasmMetadata> for &'static tracing_core::Metadata<'static> {
+		fn from(wm: &crate::WasmMetadata) -> &'static tracing_core::Metadata<'static> {
+			match (&wm.level, wm.is_span) {
+				(&crate::WasmLevel::ERROR, true) => &SPAN_ERROR_METADATA,
+				(&crate::WasmLevel::WARN, true) => &SPAN_WARN_METADATA,
+				(&crate::WasmLevel::INFO, true) => &SPAN_INFO_METADATA,
+				(&crate::WasmLevel::DEBUG, true) => &SPAN_DEBUG_METADATA,
+				(&crate::WasmLevel::TRACE, true) => &SPAN_TRACE_METADATA,
+				(&crate::WasmLevel::ERROR, false) => &EVENT_ERROR_METADATA,
+				(&crate::WasmLevel::WARN, false) => &EVENT_WARN_METADATA,
+				(&crate::WasmLevel::INFO, false) => &EVENT_INFO_METADATA,
+				(&crate::WasmLevel::DEBUG, false) => &EVENT_DEBUG_METADATA,
+				(&crate::WasmLevel::TRACE, false) => &EVENT_TRACE_METADATA,
+			}
+		}
+	}
+
+	impl From<crate::WasmEntryAttributes> for tracing::Span {
+		fn from(a: crate::WasmEntryAttributes) -> tracing::Span {
+			let name = std::str::from_utf8(&a.metadata.name).unwrap_or_default();
+			let target = std::str::from_utf8(&a.metadata.target).unwrap_or_default();
+			let file = std::str::from_utf8(&a.metadata.file).unwrap_or_default();
+			let line = a.metadata.line;
+			let module_path = std::str::from_utf8(&a.metadata.module_path).unwrap_or_default();
+			let params = a.fields;
+			let metadata: &tracing_core::metadata::Metadata<'static> = (&a.metadata).into();
+
+			tracing::span::Span::child_of(
+				a.parent_id.map(tracing_core::span::Id::from_u64),
+				metadata,
+				&tracing::valueset! { metadata.fields(), target, name, file, line, module_path, ?params },
+			)
+		}
+	}
+
+	impl crate::WasmEntryAttributes {
+		/// convert the given Attributes to an event and emit it using `tracing_core`.
+		pub fn emit(self: crate::WasmEntryAttributes) {
+			let name = std::str::from_utf8(&self.metadata.name).unwrap_or_default();
+			let target = std::str::from_utf8(&self.metadata.target).unwrap_or_default();
+			let file = std::str::from_utf8(&self.metadata.file).unwrap_or_default();
+			let line = self.metadata.line;
+			let module_path = std::str::from_utf8(&self.metadata.module_path).unwrap_or_default();
+			let params = self.fields;
+			let metadata: &tracing_core::metadata::Metadata<'static> = (&self.metadata).into();
+
+			tracing_core::Event::child_of(
+				self.parent_id.map(tracing_core::span::Id::from_u64),
+				metadata,
+				&tracing::valueset! { metadata.fields(), target, name, file, line, module_path, ?params },
+			)
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+pub use std_features::*;
diff --git a/substrate/primitives/transaction-pool/Cargo.toml b/substrate/primitives/transaction-pool/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cef4a908cc31a4c64e4c00f4ced2e4eaae5ba1a8
--- /dev/null
+++ b/substrate/primitives/transaction-pool/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "sp-transaction-pool"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Transaction pool runtime facing API."
+documentation = "https://docs.rs/sp-transaction-pool"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+
+[features]
+default = [ "std" ]
+std = [ "sp-api/std", "sp-runtime/std" ]
diff --git a/substrate/primitives/transaction-pool/README.md b/substrate/primitives/transaction-pool/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..417565ebfce00c6a9961efa5def9bf327c37dd7f
--- /dev/null
+++ b/substrate/primitives/transaction-pool/README.md
@@ -0,0 +1,3 @@
+Transaction pool primitives types & Runtime API.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/transaction-pool/src/lib.rs b/substrate/primitives/transaction-pool/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..431f429e29f9f12545375e799d753dd9c5864850
--- /dev/null
+++ b/substrate/primitives/transaction-pool/src/lib.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.
+
+//! Transaction pool runtime facing API.
+
+#![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+pub mod runtime_api;
diff --git a/substrate/primitives/transaction-pool/src/runtime_api.rs b/substrate/primitives/transaction-pool/src/runtime_api.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5d321ede40fcb471fb7359016cdb47c97b2420ba
--- /dev/null
+++ b/substrate/primitives/transaction-pool/src/runtime_api.rs
@@ -0,0 +1,55 @@
+// 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.
+
+//! Tagged Transaction Queue Runtime API.
+
+use sp_runtime::{
+	traits::Block as BlockT,
+	transaction_validity::{TransactionSource, TransactionValidity},
+};
+
+sp_api::decl_runtime_apis! {
+	/// The `TaggedTransactionQueue` api trait for interfering with the transaction queue.
+	#[api_version(3)]
+	pub trait TaggedTransactionQueue {
+		/// Validate the transaction.
+		#[changed_in(2)]
+		fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity;
+
+		/// Validate the transaction.
+		#[changed_in(3)]
+		fn validate_transaction(
+			source: TransactionSource,
+			tx: <Block as BlockT>::Extrinsic,
+		) -> TransactionValidity;
+
+		/// Validate the transaction.
+		///
+		/// This method is invoked by the transaction pool to learn details about given transaction.
+		/// The implementation should make sure to verify the correctness of the transaction
+		/// against current state. The given `block_hash` corresponds to the hash of the block
+		/// that is used as current state.
+		///
+		/// Note that this call may be performed by the pool multiple times and transactions
+		/// might be verified in any possible order.
+		fn validate_transaction(
+			source: TransactionSource,
+			tx: <Block as BlockT>::Extrinsic,
+			block_hash: Block::Hash,
+		) -> TransactionValidity;
+	}
+}
diff --git a/substrate/primitives/transaction-storage-proof/Cargo.toml b/substrate/primitives/transaction-storage-proof/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5854eb78a4b7529a3bbbfce88917537cac088232
--- /dev/null
+++ b/substrate/primitives/transaction-storage-proof/Cargo.toml
@@ -0,0 +1,36 @@
+[package]
+name = "sp-transaction-storage-proof"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Transaction storage proof primitives"
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+async-trait = { version = "0.1.57", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-core = { version = "21.0.0", optional = true, path = "../core" }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../inherents" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-trie = { version = "22.0.0", optional = true, path = "../trie" }
+
+[features]
+default = [ "std" ]
+std = [
+	"async-trait",
+	"codec/std",
+	"scale-info/std",
+	"sp-core/std",
+	"sp-inherents/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"sp-trie/std",
+]
diff --git a/substrate/primitives/transaction-storage-proof/README.md b/substrate/primitives/transaction-storage-proof/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a93e1d41fa3fd2192763e669741566ae8aed179
--- /dev/null
+++ b/substrate/primitives/transaction-storage-proof/README.md
@@ -0,0 +1,5 @@
+Transaction Storage Proof Primitives
+
+Contains types and basic code to extract storage proofs for indexed transactions.
+
+License: Apache-2.0
diff --git a/substrate/primitives/transaction-storage-proof/src/lib.rs b/substrate/primitives/transaction-storage-proof/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9d540ae68d163f3d9477c121ec616b7db1dd0c78
--- /dev/null
+++ b/substrate/primitives/transaction-storage-proof/src/lib.rs
@@ -0,0 +1,247 @@
+// 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.
+
+//! Storage proof primitives. Constains types and basic code to extract storage
+//! proofs for indexed transactions.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_std::{prelude::*, result::Result};
+
+use codec::{Decode, Encode};
+use sp_inherents::{InherentData, InherentIdentifier, IsFatalError};
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+
+pub use sp_inherents::Error;
+
+/// The identifier for the proof inherent.
+pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"tx_proof";
+/// Storage period for data.
+pub const DEFAULT_STORAGE_PERIOD: u32 = 100800;
+/// Proof trie value size.
+pub const CHUNK_SIZE: usize = 256;
+
+/// Errors that can occur while checking the storage proof.
+#[derive(Encode, sp_runtime::RuntimeDebug)]
+#[cfg_attr(feature = "std", derive(Decode))]
+pub enum InherentError {
+	InvalidProof,
+	TrieError,
+}
+
+impl IsFatalError for InherentError {
+	fn is_fatal_error(&self) -> bool {
+		true
+	}
+}
+
+/// Holds a chunk of data retrieved from storage along with
+/// a proof that the data was stored at that location in the trie.
+#[derive(Encode, Decode, Clone, PartialEq, Debug, scale_info::TypeInfo)]
+pub struct TransactionStorageProof {
+	/// Data chunk that is proved to exist.
+	pub chunk: Vec<u8>,
+	/// Trie nodes that compose the proof.
+	pub proof: Vec<Vec<u8>>,
+}
+
+/// Auxiliary trait to extract storage proof.
+pub trait TransactionStorageProofInherentData {
+	/// Get the proof.
+	fn storage_proof(&self) -> Result<Option<TransactionStorageProof>, Error>;
+}
+
+impl TransactionStorageProofInherentData for InherentData {
+	fn storage_proof(&self) -> Result<Option<TransactionStorageProof>, Error> {
+		self.get_data(&INHERENT_IDENTIFIER)
+	}
+}
+
+/// Provider for inherent data.
+#[cfg(feature = "std")]
+pub struct InherentDataProvider {
+	proof: Option<TransactionStorageProof>,
+}
+
+#[cfg(feature = "std")]
+impl InherentDataProvider {
+	pub fn new(proof: Option<TransactionStorageProof>) -> Self {
+		InherentDataProvider { proof }
+	}
+}
+
+#[cfg(feature = "std")]
+#[async_trait::async_trait]
+impl sp_inherents::InherentDataProvider for InherentDataProvider {
+	async fn provide_inherent_data(&self, inherent_data: &mut InherentData) -> Result<(), Error> {
+		if let Some(proof) = &self.proof {
+			inherent_data.put_data(INHERENT_IDENTIFIER, proof)
+		} else {
+			Ok(())
+		}
+	}
+
+	async fn try_handle_error(
+		&self,
+		identifier: &InherentIdentifier,
+		mut error: &[u8],
+	) -> Option<Result<(), Error>> {
+		if *identifier != INHERENT_IDENTIFIER {
+			return None
+		}
+
+		let error = InherentError::decode(&mut error).ok()?;
+
+		Some(Err(Error::Application(Box::from(format!("{:?}", error)))))
+	}
+}
+
+/// A utility function to extract a chunk index from the source of randomness.
+pub fn random_chunk(random_hash: &[u8], total_chunks: u32) -> u32 {
+	let mut buf = [0u8; 8];
+	buf.copy_from_slice(&random_hash[0..8]);
+	let random_u64 = u64::from_be_bytes(buf);
+	(random_u64 % total_chunks as u64) as u32
+}
+
+/// A utility function to encode transaction index as trie key.
+pub fn encode_index(input: u32) -> Vec<u8> {
+	codec::Encode::encode(&codec::Compact(input))
+}
+
+/// An interface to request indexed data from the client.
+pub trait IndexedBody<B: BlockT> {
+	/// Get all indexed transactions for a block,
+	/// including renewed transactions.
+	///
+	/// Note that this will only fetch transactions
+	/// that are indexed by the runtime with `storage_index_transaction`.
+	fn block_indexed_body(&self, number: NumberFor<B>) -> Result<Option<Vec<Vec<u8>>>, Error>;
+
+	/// Get block number for a block hash.
+	fn number(&self, hash: B::Hash) -> Result<Option<NumberFor<B>>, Error>;
+}
+
+#[cfg(feature = "std")]
+pub mod registration {
+	use super::*;
+	use sp_runtime::traits::{Block as BlockT, One, Saturating, Zero};
+	use sp_trie::TrieMut;
+
+	type Hasher = sp_core::Blake2Hasher;
+	type TrieLayout = sp_trie::LayoutV1<Hasher>;
+
+	/// Create a new inherent data provider instance for a given parent block hash.
+	pub fn new_data_provider<B, C>(
+		client: &C,
+		parent: &B::Hash,
+	) -> Result<InherentDataProvider, Error>
+	where
+		B: BlockT,
+		C: IndexedBody<B>,
+	{
+		let parent_number = client.number(*parent)?.unwrap_or(Zero::zero());
+		let number = parent_number
+			.saturating_add(One::one())
+			.saturating_sub(DEFAULT_STORAGE_PERIOD.into());
+		if number.is_zero() {
+			// Too early to collect proofs.
+			return Ok(InherentDataProvider::new(None))
+		}
+
+		let proof = match client.block_indexed_body(number)? {
+			Some(transactions) if !transactions.is_empty() =>
+				Some(build_proof(parent.as_ref(), transactions)?),
+			Some(_) | None => {
+				// Nothing was indexed in that block.
+				None
+			},
+		};
+		Ok(InherentDataProvider::new(proof))
+	}
+
+	/// Build a proof for a given source of randomness and indexed transactions.
+	pub fn build_proof(
+		random_hash: &[u8],
+		transactions: Vec<Vec<u8>>,
+	) -> Result<TransactionStorageProof, Error> {
+		let mut db = sp_trie::MemoryDB::<Hasher>::default();
+
+		let mut target_chunk = None;
+		let mut target_root = Default::default();
+		let mut target_chunk_key = Default::default();
+		let mut chunk_proof = Default::default();
+
+		let total_chunks: u64 = transactions
+			.iter()
+			.map(|t| ((t.len() + CHUNK_SIZE - 1) / CHUNK_SIZE) as u64)
+			.sum();
+		let mut buf = [0u8; 8];
+		buf.copy_from_slice(&random_hash[0..8]);
+		let random_u64 = u64::from_be_bytes(buf);
+		let target_chunk_index = random_u64 % total_chunks;
+		// Generate tries for each transaction.
+		let mut chunk_index = 0;
+		for transaction in transactions {
+			let mut transaction_root = sp_trie::empty_trie_root::<TrieLayout>();
+			{
+				let mut trie =
+					sp_trie::TrieDBMutBuilder::<TrieLayout>::new(&mut db, &mut transaction_root)
+						.build();
+				let chunks = transaction.chunks(CHUNK_SIZE).map(|c| c.to_vec());
+				for (index, chunk) in chunks.enumerate() {
+					let index = encode_index(index as u32);
+					trie.insert(&index, &chunk).map_err(|e| Error::Application(Box::new(e)))?;
+					if chunk_index == target_chunk_index {
+						target_chunk = Some(chunk);
+						target_chunk_key = index;
+					}
+					chunk_index += 1;
+				}
+				trie.commit();
+			}
+			if target_chunk.is_some() && target_root == Default::default() {
+				target_root = transaction_root;
+				chunk_proof = sp_trie::generate_trie_proof::<TrieLayout, _, _, _>(
+					&db,
+					transaction_root,
+					&[target_chunk_key.clone()],
+				)
+				.map_err(|e| Error::Application(Box::new(e)))?;
+			}
+		}
+
+		Ok(TransactionStorageProof { proof: chunk_proof, chunk: target_chunk.unwrap() })
+	}
+
+	#[test]
+	fn build_proof_check() {
+		use std::str::FromStr;
+		let random = [0u8; 32];
+		let proof = build_proof(&random, vec![vec![42]]).unwrap();
+		let root = sp_core::H256::from_str(
+			"0xff8611a4d212fc161dae19dd57f0f1ba9309f45d6207da13f2d3eab4c6839e91",
+		)
+		.unwrap();
+		sp_trie::verify_trie_proof::<TrieLayout, _, _, _>(
+			&root,
+			&proof.proof,
+			&[(encode_index(0), Some(proof.chunk))],
+		)
+		.unwrap();
+	}
+}
diff --git a/substrate/primitives/trie/Cargo.toml b/substrate/primitives/trie/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5b6877592c31514bd0d1d4696e110c7a33abb5d2
--- /dev/null
+++ b/substrate/primitives/trie/Cargo.toml
@@ -0,0 +1,65 @@
+[package]
+name = "sp-trie"
+version = "22.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Patricia trie stuff using a parity-scale-codec node format"
+repository = "https://github.com/paritytech/substrate/"
+license = "Apache-2.0"
+edition = "2021"
+homepage = "https://substrate.io"
+documentation = "https://docs.rs/sp-trie"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[[bench]]
+name = "bench"
+harness = false
+
+[dependencies]
+ahash = { version = "0.8.2", optional = true }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+hashbrown = { version = "0.13.2", optional = true }
+hash-db = { version = "0.16.0", default-features = false }
+lazy_static = { version = "1.4.0", optional = true }
+memory-db = { version = "0.32.0", default-features = false }
+nohash-hasher = { version = "0.2.0", optional = true }
+parking_lot = { version = "0.12.1", optional = true }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+thiserror = { version = "1.0.30", optional = true }
+tracing = { version = "0.1.29", optional = true }
+trie-db = { version = "0.27.0", default-features = false }
+trie-root = { version = "0.18.0", default-features = false }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+schnellru = { version = "0.2.1", optional = true }
+
+[dev-dependencies]
+array-bytes = "6.1"
+criterion = "0.4.0"
+trie-bench = "0.37.0"
+trie-standardmap = "0.16.0"
+sp-runtime = { version = "24.0.0", path = "../runtime" }
+
+[features]
+default = [ "std" ]
+std = [
+	"ahash",
+	"codec/std",
+	"hash-db/std",
+	"hashbrown",
+	"lazy_static",
+	"memory-db/std",
+	"nohash-hasher",
+	"parking_lot",
+	"scale-info/std",
+	"schnellru",
+	"sp-core/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"thiserror",
+	"tracing",
+	"trie-db/std",
+	"trie-root/std",
+]
diff --git a/substrate/primitives/trie/README.md b/substrate/primitives/trie/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..634ba4bdead26d4a77e4c284866bf0cb37b3d93c
--- /dev/null
+++ b/substrate/primitives/trie/README.md
@@ -0,0 +1,3 @@
+Utility functions to interact with Substrate's Base-16 Modified Merkle Patricia tree ("trie").
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/trie/benches/bench.rs b/substrate/primitives/trie/benches/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..35aa0b808930b29c81064751d4d548f6893edd90
--- /dev/null
+++ b/substrate/primitives/trie/benches/bench.rs
@@ -0,0 +1,31 @@
+// 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 criterion::{criterion_group, criterion_main, Criterion};
+criterion_group!(benches, benchmark);
+criterion_main!(benches);
+
+fn benchmark(c: &mut Criterion) {
+	trie_bench::standard_benchmark::<
+		sp_trie::LayoutV1<sp_runtime::traits::BlakeTwo256>,
+		sp_trie::TrieStream,
+	>(c, "substrate-blake2");
+	trie_bench::standard_benchmark::<
+		sp_trie::LayoutV1<sp_runtime::traits::BlakeTwo256>,
+		sp_trie::TrieStream,
+	>(c, "substrate-keccak");
+}
diff --git a/substrate/primitives/trie/src/cache/mod.rs b/substrate/primitives/trie/src/cache/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..01f08a78adcf2fff3612b7dfe0aebc83b2b17658
--- /dev/null
+++ b/substrate/primitives/trie/src/cache/mod.rs
@@ -0,0 +1,984 @@
+// 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.
+
+//! Trie Cache
+//!
+//! Provides an implementation of the [`TrieCache`](trie_db::TrieCache) trait.
+//! The implementation is split into three types [`SharedTrieCache`], [`LocalTrieCache`] and
+//! [`TrieCache`]. The [`SharedTrieCache`] is the instance that should be kept around for the entire
+//! lifetime of the node. It will store all cached trie nodes and values on a global level. Then
+//! there is the [`LocalTrieCache`] that should be kept around per state instance requested from the
+//! backend. As there are very likely multiple accesses to the state per instance, this
+//! [`LocalTrieCache`] is used to cache the nodes and the values before they are merged back to the
+//! shared instance. Last but not least there is the [`TrieCache`] that is being used per access to
+//! the state. It will use the [`SharedTrieCache`] and the [`LocalTrieCache`] to fulfill cache
+//! requests. If both of them don't provide the requested data it will be inserted into the
+//! [`LocalTrieCache`] and then later into the [`SharedTrieCache`].
+//!
+//! The [`SharedTrieCache`] is bound to some maximum number of bytes. It is ensured that it never
+//! runs above this limit. However as long as data is cached inside a [`LocalTrieCache`] it isn't
+//! taken into account when limiting the [`SharedTrieCache`]. This means that for the lifetime of a
+//! [`LocalTrieCache`] the actual memory usage could be above the allowed maximum.
+
+use crate::{Error, NodeCodec};
+use hash_db::Hasher;
+use nohash_hasher::BuildNoHashHasher;
+use parking_lot::{Mutex, MutexGuard};
+use schnellru::LruMap;
+use shared_cache::{ValueCacheKey, ValueCacheRef};
+use std::{
+	collections::HashMap,
+	sync::{
+		atomic::{AtomicU64, Ordering},
+		Arc,
+	},
+	time::Duration,
+};
+use trie_db::{node::NodeOwned, CachedValue};
+
+mod shared_cache;
+
+pub use shared_cache::SharedTrieCache;
+
+use self::shared_cache::ValueCacheKeyHash;
+
+const LOG_TARGET: &str = "trie-cache";
+
+/// The maximum amount of time we'll wait trying to acquire the shared cache lock
+/// when the local cache is dropped and synchronized with the share cache.
+///
+/// This is just a failsafe; normally this should never trigger.
+const SHARED_CACHE_WRITE_LOCK_TIMEOUT: Duration = Duration::from_millis(100);
+
+/// The maximum number of existing keys in the shared cache that a single local cache
+/// can promote to the front of the LRU cache in one go.
+///
+/// If we have a big shared cache and the local cache hits all of those keys we don't
+/// want to spend forever bumping all of them.
+const SHARED_NODE_CACHE_MAX_PROMOTED_KEYS: u32 = 1792;
+/// Same as [`SHARED_NODE_CACHE_MAX_PROMOTED_KEYS`].
+const SHARED_VALUE_CACHE_MAX_PROMOTED_KEYS: u32 = 1792;
+
+/// The maximum portion of the shared cache (in percent) that a single local
+/// cache can replace in one go.
+///
+/// We don't want a single local cache instance to have the ability to replace
+/// everything in the shared cache.
+const SHARED_NODE_CACHE_MAX_REPLACE_PERCENT: usize = 33;
+/// Same as [`SHARED_NODE_CACHE_MAX_REPLACE_PERCENT`].
+const SHARED_VALUE_CACHE_MAX_REPLACE_PERCENT: usize = 33;
+
+/// The maximum inline capacity of the local cache, in bytes.
+///
+/// This is just an upper limit; since the maps are resized in powers of two
+/// their actual size will most likely not exactly match this.
+const LOCAL_NODE_CACHE_MAX_INLINE_SIZE: usize = 512 * 1024;
+/// Same as [`LOCAL_NODE_CACHE_MAX_INLINE_SIZE`].
+const LOCAL_VALUE_CACHE_MAX_INLINE_SIZE: usize = 512 * 1024;
+
+/// The maximum size of the memory allocated on the heap by the local cache, in bytes.
+///
+/// The size of the node cache should always be bigger than the value cache. The value
+/// cache is only holding weak references to the actual values found in the nodes and
+/// we account for the size of the node as part of the node cache.
+const LOCAL_NODE_CACHE_MAX_HEAP_SIZE: usize = 8 * 1024 * 1024;
+/// Same as [`LOCAL_NODE_CACHE_MAX_HEAP_SIZE`].
+const LOCAL_VALUE_CACHE_MAX_HEAP_SIZE: usize = 2 * 1024 * 1024;
+
+/// The size of the shared cache.
+#[derive(Debug, Clone, Copy)]
+pub struct CacheSize(usize);
+
+impl CacheSize {
+	/// An unlimited cache size.
+	pub const fn unlimited() -> Self {
+		CacheSize(usize::MAX)
+	}
+
+	/// A cache size `bytes` big.
+	pub const fn new(bytes: usize) -> Self {
+		CacheSize(bytes)
+	}
+}
+
+/// A limiter for the local node cache. This makes sure the local cache doesn't grow too big.
+#[derive(Default)]
+pub struct LocalNodeCacheLimiter {
+	/// The current size (in bytes) of data allocated by this cache on the heap.
+	///
+	/// This doesn't include the size of the map itself.
+	current_heap_size: usize,
+}
+
+impl<H> schnellru::Limiter<H, NodeCached<H>> for LocalNodeCacheLimiter
+where
+	H: AsRef<[u8]> + std::fmt::Debug,
+{
+	type KeyToInsert<'a> = H;
+	type LinkType = u32;
+
+	#[inline]
+	fn is_over_the_limit(&self, length: usize) -> bool {
+		// Only enforce the limit if there's more than one element to make sure
+		// we can always add a new element to the cache.
+		if length <= 1 {
+			return false
+		}
+
+		self.current_heap_size > LOCAL_NODE_CACHE_MAX_HEAP_SIZE
+	}
+
+	#[inline]
+	fn on_insert<'a>(
+		&mut self,
+		_length: usize,
+		key: H,
+		cached_node: NodeCached<H>,
+	) -> Option<(H, NodeCached<H>)> {
+		self.current_heap_size += cached_node.heap_size();
+		Some((key, cached_node))
+	}
+
+	#[inline]
+	fn on_replace(
+		&mut self,
+		_length: usize,
+		_old_key: &mut H,
+		_new_key: H,
+		old_node: &mut NodeCached<H>,
+		new_node: &mut NodeCached<H>,
+	) -> bool {
+		debug_assert_eq!(_old_key.as_ref().len(), _new_key.as_ref().len());
+		self.current_heap_size =
+			self.current_heap_size + new_node.heap_size() - old_node.heap_size();
+		true
+	}
+
+	#[inline]
+	fn on_removed(&mut self, _key: &mut H, cached_node: &mut NodeCached<H>) {
+		self.current_heap_size -= cached_node.heap_size();
+	}
+
+	#[inline]
+	fn on_cleared(&mut self) {
+		self.current_heap_size = 0;
+	}
+
+	#[inline]
+	fn on_grow(&mut self, new_memory_usage: usize) -> bool {
+		new_memory_usage <= LOCAL_NODE_CACHE_MAX_INLINE_SIZE
+	}
+}
+
+/// A limiter for the local value cache. This makes sure the local cache doesn't grow too big.
+#[derive(Default)]
+pub struct LocalValueCacheLimiter {
+	/// The current size (in bytes) of data allocated by this cache on the heap.
+	///
+	/// This doesn't include the size of the map itself.
+	current_heap_size: usize,
+}
+
+impl<H> schnellru::Limiter<ValueCacheKey<H>, CachedValue<H>> for LocalValueCacheLimiter
+where
+	H: AsRef<[u8]>,
+{
+	type KeyToInsert<'a> = ValueCacheRef<'a, H>;
+	type LinkType = u32;
+
+	#[inline]
+	fn is_over_the_limit(&self, length: usize) -> bool {
+		// Only enforce the limit if there's more than one element to make sure
+		// we can always add a new element to the cache.
+		if length <= 1 {
+			return false
+		}
+
+		self.current_heap_size > LOCAL_VALUE_CACHE_MAX_HEAP_SIZE
+	}
+
+	#[inline]
+	fn on_insert(
+		&mut self,
+		_length: usize,
+		key: Self::KeyToInsert<'_>,
+		value: CachedValue<H>,
+	) -> Option<(ValueCacheKey<H>, CachedValue<H>)> {
+		self.current_heap_size += key.storage_key.len();
+		Some((key.into(), value))
+	}
+
+	#[inline]
+	fn on_replace(
+		&mut self,
+		_length: usize,
+		_old_key: &mut ValueCacheKey<H>,
+		_new_key: ValueCacheRef<H>,
+		_old_value: &mut CachedValue<H>,
+		_new_value: &mut CachedValue<H>,
+	) -> bool {
+		debug_assert_eq!(_old_key.storage_key.len(), _new_key.storage_key.len());
+		true
+	}
+
+	#[inline]
+	fn on_removed(&mut self, key: &mut ValueCacheKey<H>, _: &mut CachedValue<H>) {
+		self.current_heap_size -= key.storage_key.len();
+	}
+
+	#[inline]
+	fn on_cleared(&mut self) {
+		self.current_heap_size = 0;
+	}
+
+	#[inline]
+	fn on_grow(&mut self, new_memory_usage: usize) -> bool {
+		new_memory_usage <= LOCAL_VALUE_CACHE_MAX_INLINE_SIZE
+	}
+}
+
+/// A struct to gather hit/miss stats to aid in debugging the performance of the cache.
+#[derive(Default)]
+struct HitStats {
+	shared_hits: AtomicU64,
+	shared_fetch_attempts: AtomicU64,
+	local_hits: AtomicU64,
+	local_fetch_attempts: AtomicU64,
+}
+
+impl std::fmt::Display for HitStats {
+	fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+		let shared_hits = self.shared_hits.load(Ordering::Relaxed);
+		let shared_fetch_attempts = self.shared_fetch_attempts.load(Ordering::Relaxed);
+		let local_hits = self.local_hits.load(Ordering::Relaxed);
+		let local_fetch_attempts = self.local_fetch_attempts.load(Ordering::Relaxed);
+		if shared_fetch_attempts == 0 && local_hits == 0 {
+			write!(fmt, "empty")
+		} else {
+			let percent_local = (local_hits as f32 / local_fetch_attempts as f32) * 100.0;
+			let percent_shared = (shared_hits as f32 / shared_fetch_attempts as f32) * 100.0;
+			write!(
+				fmt,
+				"local hit rate = {}% [{}/{}], shared hit rate = {}% [{}/{}]",
+				percent_local as u32,
+				local_hits,
+				local_fetch_attempts,
+				percent_shared as u32,
+				shared_hits,
+				shared_fetch_attempts
+			)
+		}
+	}
+}
+
+/// A struct to gather hit/miss stats for the node cache and the value cache.
+#[derive(Default)]
+struct TrieHitStats {
+	node_cache: HitStats,
+	value_cache: HitStats,
+}
+
+/// An internal struct to store the cached trie nodes.
+pub(crate) struct NodeCached<H> {
+	/// The cached node.
+	pub node: NodeOwned<H>,
+	/// Whether this node was fetched from the shared cache or not.
+	pub is_from_shared_cache: bool,
+}
+
+impl<H> NodeCached<H> {
+	/// Returns the number of bytes allocated on the heap by this node.
+	fn heap_size(&self) -> usize {
+		self.node.size_in_bytes() - std::mem::size_of::<NodeOwned<H>>()
+	}
+}
+
+type NodeCacheMap<H> = LruMap<H, NodeCached<H>, LocalNodeCacheLimiter, schnellru::RandomState>;
+
+type ValueCacheMap<H> = LruMap<
+	ValueCacheKey<H>,
+	CachedValue<H>,
+	LocalValueCacheLimiter,
+	BuildNoHashHasher<ValueCacheKey<H>>,
+>;
+
+type ValueAccessSet =
+	LruMap<ValueCacheKeyHash, (), schnellru::ByLength, BuildNoHashHasher<ValueCacheKeyHash>>;
+
+/// The local trie cache.
+///
+/// This cache should be used per state instance created by the backend. One state instance is
+/// referring to the state of one block. It will cache all the accesses that are done to the state
+/// which could not be fullfilled by the [`SharedTrieCache`]. These locally cached items are merged
+/// back to the shared trie cache when this instance is dropped.
+///
+/// When using [`Self::as_trie_db_cache`] or [`Self::as_trie_db_mut_cache`], it will lock Mutexes.
+/// So, it is important that these methods are not called multiple times, because they otherwise
+/// deadlock.
+pub struct LocalTrieCache<H: Hasher> {
+	/// The shared trie cache that created this instance.
+	shared: SharedTrieCache<H>,
+
+	/// The local cache for the trie nodes.
+	node_cache: Mutex<NodeCacheMap<H::Out>>,
+
+	/// The local cache for the values.
+	value_cache: Mutex<ValueCacheMap<H::Out>>,
+
+	/// Keeps track of all values accessed in the shared cache.
+	///
+	/// This will be used to ensure that these nodes are brought to the front of the lru when this
+	/// local instance is merged back to the shared cache. This can actually lead to collision when
+	/// two [`ValueCacheKey`]s with different storage roots and keys map to the same hash. However,
+	/// as we only use this set to update the lru position it is fine, even if we bring the wrong
+	/// value to the top. The important part is that we always get the correct value from the value
+	/// cache for a given key.
+	shared_value_cache_access: Mutex<ValueAccessSet>,
+
+	stats: TrieHitStats,
+}
+
+impl<H: Hasher> LocalTrieCache<H> {
+	/// Return self as a [`TrieDB`](trie_db::TrieDB) compatible cache.
+	///
+	/// The given `storage_root` needs to be the storage root of the trie this cache is used for.
+	pub fn as_trie_db_cache(&self, storage_root: H::Out) -> TrieCache<'_, H> {
+		let value_cache = ValueCache::ForStorageRoot {
+			storage_root,
+			local_value_cache: self.value_cache.lock(),
+			shared_value_cache_access: self.shared_value_cache_access.lock(),
+			buffered_value: None,
+		};
+
+		TrieCache {
+			shared_cache: self.shared.clone(),
+			local_cache: self.node_cache.lock(),
+			value_cache,
+			stats: &self.stats,
+		}
+	}
+
+	/// Return self as [`TrieDBMut`](trie_db::TrieDBMut) compatible cache.
+	///
+	/// After finishing all operations with [`TrieDBMut`](trie_db::TrieDBMut) and having obtained
+	/// the new storage root, [`TrieCache::merge_into`] should be called to update this local
+	/// cache instance. If the function is not called, cached data is just thrown away and not
+	/// propagated to the shared cache. So, accessing these new items will be slower, but nothing
+	/// would break because of this.
+	pub fn as_trie_db_mut_cache(&self) -> TrieCache<'_, H> {
+		TrieCache {
+			shared_cache: self.shared.clone(),
+			local_cache: self.node_cache.lock(),
+			value_cache: ValueCache::Fresh(Default::default()),
+			stats: &self.stats,
+		}
+	}
+}
+
+impl<H: Hasher> Drop for LocalTrieCache<H> {
+	fn drop(&mut self) {
+		tracing::debug!(
+			target: LOG_TARGET,
+			"Local node trie cache dropped: {}",
+			self.stats.node_cache
+		);
+
+		tracing::debug!(
+			target: LOG_TARGET,
+			"Local value trie cache dropped: {}",
+			self.stats.value_cache
+		);
+
+		let mut shared_inner = match self.shared.write_lock_inner() {
+			Some(inner) => inner,
+			None => {
+				tracing::warn!(
+					target: LOG_TARGET,
+					"Timeout while trying to acquire a write lock for the shared trie cache"
+				);
+				return
+			},
+		};
+
+		shared_inner.node_cache_mut().update(self.node_cache.get_mut().drain());
+
+		shared_inner.value_cache_mut().update(
+			self.value_cache.get_mut().drain(),
+			self.shared_value_cache_access.get_mut().drain().map(|(key, ())| key),
+		);
+	}
+}
+
+/// The abstraction of the value cache for the [`TrieCache`].
+enum ValueCache<'a, H: Hasher> {
+	/// The value cache is fresh, aka not yet associated to any storage root.
+	/// This is used for example when a new trie is being build, to cache new values.
+	Fresh(HashMap<Arc<[u8]>, CachedValue<H::Out>>),
+	/// The value cache is already bound to a specific storage root.
+	ForStorageRoot {
+		shared_value_cache_access: MutexGuard<'a, ValueAccessSet>,
+		local_value_cache: MutexGuard<'a, ValueCacheMap<H::Out>>,
+		storage_root: H::Out,
+		// The shared value cache needs to be temporarily locked when reading from it
+		// so we need to clone the value that is returned, but we need to be able to
+		// return a reference to the value, so we just buffer it here.
+		buffered_value: Option<CachedValue<H::Out>>,
+	},
+}
+
+impl<H: Hasher> ValueCache<'_, H> {
+	/// Get the value for the given `key`.
+	fn get(
+		&mut self,
+		key: &[u8],
+		shared_cache: &SharedTrieCache<H>,
+		stats: &HitStats,
+	) -> Option<&CachedValue<H::Out>> {
+		stats.local_fetch_attempts.fetch_add(1, Ordering::Relaxed);
+
+		match self {
+			Self::Fresh(map) =>
+				if let Some(value) = map.get(key) {
+					stats.local_hits.fetch_add(1, Ordering::Relaxed);
+					Some(value)
+				} else {
+					None
+				},
+			Self::ForStorageRoot {
+				local_value_cache,
+				shared_value_cache_access,
+				storage_root,
+				buffered_value,
+			} => {
+				// We first need to look up in the local cache and then the shared cache.
+				// It can happen that some value is cached in the shared cache, but the
+				// weak reference of the data can not be upgraded anymore. This for example
+				// happens when the node is dropped that contains the strong reference to the data.
+				//
+				// So, the logic of the trie would lookup the data and the node and store both
+				// in our local caches.
+
+				let hash = ValueCacheKey::hash_data(key, storage_root);
+
+				if let Some(value) = local_value_cache
+					.peek_by_hash(hash.raw(), |existing_key, _| {
+						existing_key.is_eq(storage_root, key)
+					}) {
+					stats.local_hits.fetch_add(1, Ordering::Relaxed);
+
+					return Some(value)
+				}
+
+				stats.shared_fetch_attempts.fetch_add(1, Ordering::Relaxed);
+				if let Some(value) = shared_cache.peek_value_by_hash(hash, storage_root, key) {
+					stats.shared_hits.fetch_add(1, Ordering::Relaxed);
+					shared_value_cache_access.insert(hash, ());
+					*buffered_value = Some(value.clone());
+					return buffered_value.as_ref()
+				}
+
+				None
+			},
+		}
+	}
+
+	/// Insert some new `value` under the given `key`.
+	fn insert(&mut self, key: &[u8], value: CachedValue<H::Out>) {
+		match self {
+			Self::Fresh(map) => {
+				map.insert(key.into(), value);
+			},
+			Self::ForStorageRoot { local_value_cache, storage_root, .. } => {
+				local_value_cache.insert(ValueCacheRef::new(key, *storage_root), value);
+			},
+		}
+	}
+}
+
+/// The actual [`TrieCache`](trie_db::TrieCache) implementation.
+///
+/// If this instance was created for using it with a [`TrieDBMut`](trie_db::TrieDBMut), it needs to
+/// be merged back into the [`LocalTrieCache`] with [`Self::merge_into`] after all operations are
+/// done.
+pub struct TrieCache<'a, H: Hasher> {
+	shared_cache: SharedTrieCache<H>,
+	local_cache: MutexGuard<'a, NodeCacheMap<H::Out>>,
+	value_cache: ValueCache<'a, H>,
+	stats: &'a TrieHitStats,
+}
+
+impl<'a, H: Hasher> TrieCache<'a, H> {
+	/// Merge this cache into the given [`LocalTrieCache`].
+	///
+	/// This function is only required to be called when this instance was created through
+	/// [`LocalTrieCache::as_trie_db_mut_cache`], otherwise this method is a no-op. The given
+	/// `storage_root` is the new storage root that was obtained after finishing all operations
+	/// using the [`TrieDBMut`](trie_db::TrieDBMut).
+	pub fn merge_into(self, local: &LocalTrieCache<H>, storage_root: H::Out) {
+		let ValueCache::Fresh(cache) = self.value_cache else { return };
+
+		if !cache.is_empty() {
+			let mut value_cache = local.value_cache.lock();
+			let partial_hash = ValueCacheKey::hash_partial_data(&storage_root);
+
+			cache.into_iter().for_each(|(k, v)| {
+				let hash = ValueCacheKeyHash::from_hasher_and_storage_key(partial_hash.clone(), &k);
+				let k = ValueCacheRef { storage_root, storage_key: &k, hash };
+				value_cache.insert(k, v);
+			});
+		}
+	}
+}
+
+impl<'a, H: Hasher> trie_db::TrieCache<NodeCodec<H>> for TrieCache<'a, H> {
+	fn get_or_insert_node(
+		&mut self,
+		hash: H::Out,
+		fetch_node: &mut dyn FnMut() -> trie_db::Result<NodeOwned<H::Out>, H::Out, Error<H::Out>>,
+	) -> trie_db::Result<&NodeOwned<H::Out>, H::Out, Error<H::Out>> {
+		let mut is_local_cache_hit = true;
+		self.stats.node_cache.local_fetch_attempts.fetch_add(1, Ordering::Relaxed);
+
+		// First try to grab the node from the local cache.
+		let node = self.local_cache.get_or_insert_fallible(hash, || {
+			is_local_cache_hit = false;
+
+			// It was not in the local cache; try the shared cache.
+			self.stats.node_cache.shared_fetch_attempts.fetch_add(1, Ordering::Relaxed);
+			if let Some(node) = self.shared_cache.peek_node(&hash) {
+				self.stats.node_cache.shared_hits.fetch_add(1, Ordering::Relaxed);
+				tracing::trace!(target: LOG_TARGET, ?hash, "Serving node from shared cache");
+
+				return Ok(NodeCached::<H::Out> { node: node.clone(), is_from_shared_cache: true })
+			}
+
+			// It was not in the shared cache; try fetching it from the database.
+			match fetch_node() {
+				Ok(node) => {
+					tracing::trace!(target: LOG_TARGET, ?hash, "Serving node from database");
+					Ok(NodeCached::<H::Out> { node, is_from_shared_cache: false })
+				},
+				Err(error) => {
+					tracing::trace!(target: LOG_TARGET, ?hash, "Serving node from database failed");
+					Err(error)
+				},
+			}
+		});
+
+		if is_local_cache_hit {
+			tracing::trace!(target: LOG_TARGET, ?hash, "Serving node from local cache");
+			self.stats.node_cache.local_hits.fetch_add(1, Ordering::Relaxed);
+		}
+
+		Ok(&node?
+			.expect("you can always insert at least one element into the local cache; qed")
+			.node)
+	}
+
+	fn get_node(&mut self, hash: &H::Out) -> Option<&NodeOwned<H::Out>> {
+		let mut is_local_cache_hit = true;
+		self.stats.node_cache.local_fetch_attempts.fetch_add(1, Ordering::Relaxed);
+
+		// First try to grab the node from the local cache.
+		let cached_node = self.local_cache.get_or_insert_fallible(*hash, || {
+			is_local_cache_hit = false;
+
+			// It was not in the local cache; try the shared cache.
+			self.stats.node_cache.shared_fetch_attempts.fetch_add(1, Ordering::Relaxed);
+			if let Some(node) = self.shared_cache.peek_node(&hash) {
+				self.stats.node_cache.shared_hits.fetch_add(1, Ordering::Relaxed);
+				tracing::trace!(target: LOG_TARGET, ?hash, "Serving node from shared cache");
+
+				Ok(NodeCached::<H::Out> { node: node.clone(), is_from_shared_cache: true })
+			} else {
+				tracing::trace!(target: LOG_TARGET, ?hash, "Serving node from cache failed");
+
+				Err(())
+			}
+		});
+
+		if is_local_cache_hit {
+			tracing::trace!(target: LOG_TARGET, ?hash, "Serving node from local cache");
+			self.stats.node_cache.local_hits.fetch_add(1, Ordering::Relaxed);
+		}
+
+		match cached_node {
+			Ok(Some(cached_node)) => Some(&cached_node.node),
+			Ok(None) => {
+				unreachable!(
+					"you can always insert at least one element into the local cache; qed"
+				);
+			},
+			Err(()) => None,
+		}
+	}
+
+	fn lookup_value_for_key(&mut self, key: &[u8]) -> Option<&CachedValue<H::Out>> {
+		let res = self.value_cache.get(key, &self.shared_cache, &self.stats.value_cache);
+
+		tracing::trace!(
+			target: LOG_TARGET,
+			key = ?sp_core::hexdisplay::HexDisplay::from(&key),
+			found = res.is_some(),
+			"Looked up value for key",
+		);
+
+		res
+	}
+
+	fn cache_value_for_key(&mut self, key: &[u8], data: CachedValue<H::Out>) {
+		tracing::trace!(
+			target: LOG_TARGET,
+			key = ?sp_core::hexdisplay::HexDisplay::from(&key),
+			"Caching value for key",
+		);
+
+		self.value_cache.insert(key, data);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use trie_db::{Bytes, Trie, TrieDBBuilder, TrieDBMutBuilder, TrieHash, TrieMut};
+
+	type MemoryDB = crate::MemoryDB<sp_core::Blake2Hasher>;
+	type Layout = crate::LayoutV1<sp_core::Blake2Hasher>;
+	type Cache = super::SharedTrieCache<sp_core::Blake2Hasher>;
+	type Recorder = crate::recorder::Recorder<sp_core::Blake2Hasher>;
+
+	const TEST_DATA: &[(&[u8], &[u8])] =
+		&[(b"key1", b"val1"), (b"key2", &[2; 64]), (b"key3", b"val3"), (b"key4", &[4; 64])];
+	const CACHE_SIZE_RAW: usize = 1024 * 10;
+	const CACHE_SIZE: CacheSize = CacheSize::new(CACHE_SIZE_RAW);
+
+	fn create_trie() -> (MemoryDB, TrieHash<Layout>) {
+		let mut db = MemoryDB::default();
+		let mut root = Default::default();
+
+		{
+			let mut trie = TrieDBMutBuilder::<Layout>::new(&mut db, &mut root).build();
+			for (k, v) in TEST_DATA {
+				trie.insert(k, v).expect("Inserts data");
+			}
+		}
+
+		(db, root)
+	}
+
+	#[test]
+	fn basic_cache_works() {
+		let (db, root) = create_trie();
+
+		let shared_cache = Cache::new(CACHE_SIZE);
+		let local_cache = shared_cache.local_cache();
+
+		{
+			let mut cache = local_cache.as_trie_db_cache(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root).with_cache(&mut cache).build();
+			assert_eq!(TEST_DATA[0].1.to_vec(), trie.get(TEST_DATA[0].0).unwrap().unwrap());
+		}
+
+		// Local cache wasn't dropped yet, so there should nothing in the shared caches.
+		assert!(shared_cache.read_lock_inner().value_cache().lru.is_empty());
+		assert!(shared_cache.read_lock_inner().node_cache().lru.is_empty());
+
+		drop(local_cache);
+
+		// Now we should have the cached items in the shared cache.
+		assert!(shared_cache.read_lock_inner().node_cache().lru.len() >= 1);
+		let cached_data = shared_cache
+			.read_lock_inner()
+			.value_cache()
+			.lru
+			.peek(&ValueCacheKey::new_value(TEST_DATA[0].0, root))
+			.unwrap()
+			.clone();
+		assert_eq!(Bytes::from(TEST_DATA[0].1.to_vec()), cached_data.data().flatten().unwrap());
+
+		let fake_data = Bytes::from(&b"fake_data"[..]);
+
+		let local_cache = shared_cache.local_cache();
+		shared_cache.write_lock_inner().unwrap().value_cache_mut().lru.insert(
+			ValueCacheKey::new_value(TEST_DATA[1].0, root),
+			(fake_data.clone(), Default::default()).into(),
+		);
+
+		{
+			let mut cache = local_cache.as_trie_db_cache(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root).with_cache(&mut cache).build();
+
+			// We should now get the "fake_data", because we inserted this manually to the cache.
+			assert_eq!(b"fake_data".to_vec(), trie.get(TEST_DATA[1].0).unwrap().unwrap());
+		}
+	}
+
+	#[test]
+	fn trie_db_mut_cache_works() {
+		let (mut db, root) = create_trie();
+
+		let new_key = b"new_key".to_vec();
+		// Use some long value to not have it inlined
+		let new_value = vec![23; 64];
+
+		let shared_cache = Cache::new(CACHE_SIZE);
+		let mut new_root = root;
+
+		{
+			let local_cache = shared_cache.local_cache();
+
+			let mut cache = local_cache.as_trie_db_mut_cache();
+
+			{
+				let mut trie = TrieDBMutBuilder::<Layout>::from_existing(&mut db, &mut new_root)
+					.with_cache(&mut cache)
+					.build();
+
+				trie.insert(&new_key, &new_value).unwrap();
+			}
+
+			cache.merge_into(&local_cache, new_root);
+		}
+
+		// After the local cache is dropped, all changes should have been merged back to the shared
+		// cache.
+		let cached_data = shared_cache
+			.read_lock_inner()
+			.value_cache()
+			.lru
+			.peek(&ValueCacheKey::new_value(new_key, new_root))
+			.unwrap()
+			.clone();
+		assert_eq!(Bytes::from(new_value), cached_data.data().flatten().unwrap());
+	}
+
+	#[test]
+	fn trie_db_cache_and_recorder_work_together() {
+		let (db, root) = create_trie();
+
+		let shared_cache = Cache::new(CACHE_SIZE);
+
+		for i in 0..5 {
+			// Clear some of the caches.
+			if i == 2 {
+				shared_cache.reset_node_cache();
+			} else if i == 3 {
+				shared_cache.reset_value_cache();
+			}
+
+			let local_cache = shared_cache.local_cache();
+			let recorder = Recorder::default();
+
+			{
+				let mut cache = local_cache.as_trie_db_cache(root);
+				let mut recorder = recorder.as_trie_recorder(root);
+				let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+					.with_cache(&mut cache)
+					.with_recorder(&mut recorder)
+					.build();
+
+				for (key, value) in TEST_DATA {
+					assert_eq!(*value, trie.get(&key).unwrap().unwrap());
+				}
+			}
+
+			let storage_proof = recorder.drain_storage_proof();
+			let memory_db: MemoryDB = storage_proof.into_memory_db();
+
+			{
+				let trie = TrieDBBuilder::<Layout>::new(&memory_db, &root).build();
+
+				for (key, value) in TEST_DATA {
+					assert_eq!(*value, trie.get(&key).unwrap().unwrap());
+				}
+			}
+		}
+	}
+
+	#[test]
+	fn trie_db_mut_cache_and_recorder_work_together() {
+		const DATA_TO_ADD: &[(&[u8], &[u8])] = &[(b"key11", &[45; 78]), (b"key33", &[78; 89])];
+
+		let (db, root) = create_trie();
+
+		let shared_cache = Cache::new(CACHE_SIZE);
+
+		// Run this twice so that we use the data cache in the second run.
+		for i in 0..5 {
+			// Clear some of the caches.
+			if i == 2 {
+				shared_cache.reset_node_cache();
+			} else if i == 3 {
+				shared_cache.reset_value_cache();
+			}
+
+			let recorder = Recorder::default();
+			let local_cache = shared_cache.local_cache();
+			let mut new_root = root;
+
+			{
+				let mut db = db.clone();
+				let mut cache = local_cache.as_trie_db_cache(root);
+				let mut recorder = recorder.as_trie_recorder(root);
+				let mut trie = TrieDBMutBuilder::<Layout>::from_existing(&mut db, &mut new_root)
+					.with_cache(&mut cache)
+					.with_recorder(&mut recorder)
+					.build();
+
+				for (key, value) in DATA_TO_ADD {
+					trie.insert(key, value).unwrap();
+				}
+			}
+
+			let storage_proof = recorder.drain_storage_proof();
+			let mut memory_db: MemoryDB = storage_proof.into_memory_db();
+			let mut proof_root = root;
+
+			{
+				let mut trie =
+					TrieDBMutBuilder::<Layout>::from_existing(&mut memory_db, &mut proof_root)
+						.build();
+
+				for (key, value) in DATA_TO_ADD {
+					trie.insert(key, value).unwrap();
+				}
+			}
+
+			assert_eq!(new_root, proof_root)
+		}
+	}
+
+	#[test]
+	fn cache_lru_works() {
+		let (db, root) = create_trie();
+
+		let shared_cache = Cache::new(CACHE_SIZE);
+
+		{
+			let local_cache = shared_cache.local_cache();
+
+			let mut cache = local_cache.as_trie_db_cache(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root).with_cache(&mut cache).build();
+
+			for (k, _) in TEST_DATA {
+				trie.get(k).unwrap().unwrap();
+			}
+		}
+
+		// Check that all items are there.
+		assert!(shared_cache
+			.read_lock_inner()
+			.value_cache()
+			.lru
+			.iter()
+			.map(|d| d.0)
+			.all(|l| TEST_DATA.iter().any(|d| &*l.storage_key == d.0)));
+
+		// Run this in a loop. The first time we check that with the filled value cache,
+		// the expected values are at the top of the LRU.
+		// The second run is using an empty value cache to ensure that we access the nodes.
+		for _ in 0..2 {
+			{
+				let local_cache = shared_cache.local_cache();
+
+				let mut cache = local_cache.as_trie_db_cache(root);
+				let trie = TrieDBBuilder::<Layout>::new(&db, &root).with_cache(&mut cache).build();
+
+				for (k, _) in TEST_DATA.iter().take(2) {
+					trie.get(k).unwrap().unwrap();
+				}
+			}
+
+			// Ensure that the accessed items are most recently used items of the shared value
+			// cache.
+			assert!(shared_cache
+				.read_lock_inner()
+				.value_cache()
+				.lru
+				.iter()
+				.take(2)
+				.map(|d| d.0)
+				.all(|l| { TEST_DATA.iter().take(2).any(|d| &*l.storage_key == d.0) }));
+
+			// Delete the value cache, so that we access the nodes.
+			shared_cache.reset_value_cache();
+		}
+
+		let most_recently_used_nodes = shared_cache
+			.read_lock_inner()
+			.node_cache()
+			.lru
+			.iter()
+			.map(|d| *d.0)
+			.collect::<Vec<_>>();
+
+		{
+			let local_cache = shared_cache.local_cache();
+
+			let mut cache = local_cache.as_trie_db_cache(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root).with_cache(&mut cache).build();
+
+			for (k, _) in TEST_DATA.iter().skip(2) {
+				trie.get(k).unwrap().unwrap();
+			}
+		}
+
+		// Ensure that the most recently used nodes changed as well.
+		assert_ne!(
+			most_recently_used_nodes,
+			shared_cache
+				.read_lock_inner()
+				.node_cache()
+				.lru
+				.iter()
+				.map(|d| *d.0)
+				.collect::<Vec<_>>()
+		);
+	}
+
+	#[test]
+	fn cache_respects_bounds() {
+		let (mut db, root) = create_trie();
+
+		let shared_cache = Cache::new(CACHE_SIZE);
+		{
+			let local_cache = shared_cache.local_cache();
+
+			let mut new_root = root;
+
+			{
+				let mut cache = local_cache.as_trie_db_cache(root);
+				{
+					let mut trie =
+						TrieDBMutBuilder::<Layout>::from_existing(&mut db, &mut new_root)
+							.with_cache(&mut cache)
+							.build();
+
+					let value = vec![10u8; 100];
+					// Ensure we add enough data that would overflow the cache.
+					for i in 0..CACHE_SIZE_RAW / 100 * 2 {
+						trie.insert(format!("key{}", i).as_bytes(), &value).unwrap();
+					}
+				}
+
+				cache.merge_into(&local_cache, new_root);
+			}
+		}
+
+		assert!(shared_cache.used_memory_size() < CACHE_SIZE_RAW);
+	}
+}
diff --git a/substrate/primitives/trie/src/cache/shared_cache.rs b/substrate/primitives/trie/src/cache/shared_cache.rs
new file mode 100644
index 0000000000000000000000000000000000000000..28b3274fde11ef5d1acae13668805ac3efb6d457
--- /dev/null
+++ b/substrate/primitives/trie/src/cache/shared_cache.rs
@@ -0,0 +1,855 @@
+// 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.
+
+///! Provides the [`SharedNodeCache`], the [`SharedValueCache`] and the [`SharedTrieCache`]
+///! that combines both caches and is exported to the outside.
+use super::{CacheSize, NodeCached};
+use hash_db::Hasher;
+use hashbrown::{hash_set::Entry as SetEntry, HashSet};
+use nohash_hasher::BuildNoHashHasher;
+use parking_lot::{Mutex, RwLock, RwLockWriteGuard};
+use schnellru::LruMap;
+use std::{
+	hash::{BuildHasher, Hasher as _},
+	sync::Arc,
+};
+use trie_db::{node::NodeOwned, CachedValue};
+
+lazy_static::lazy_static! {
+	static ref RANDOM_STATE: ahash::RandomState = ahash::RandomState::default();
+}
+
+pub struct SharedNodeCacheLimiter {
+	/// The maximum size (in bytes) the cache can hold inline.
+	///
+	/// This space is always consumed whether there are any items in the map or not.
+	max_inline_size: usize,
+
+	/// The maximum size (in bytes) the cache can hold on the heap.
+	max_heap_size: usize,
+
+	/// The current size (in bytes) of data allocated by this cache on the heap.
+	///
+	/// This doesn't include the size of the map itself.
+	heap_size: usize,
+
+	/// A counter with the number of elements that got evicted from the cache.
+	///
+	/// Reset to zero before every update.
+	items_evicted: usize,
+
+	/// The maximum number of elements that we allow to be evicted.
+	///
+	/// Reset on every update.
+	max_items_evicted: usize,
+}
+
+impl<H> schnellru::Limiter<H, NodeOwned<H>> for SharedNodeCacheLimiter
+where
+	H: AsRef<[u8]>,
+{
+	type KeyToInsert<'a> = H;
+	type LinkType = u32;
+
+	#[inline]
+	fn is_over_the_limit(&self, _length: usize) -> bool {
+		// Once we hit the limit of max items evicted this will return `false` and prevent
+		// any further evictions, but this is fine because the outer loop which inserts
+		// items into this cache will just detect this and stop inserting new items.
+		self.items_evicted <= self.max_items_evicted && self.heap_size > self.max_heap_size
+	}
+
+	#[inline]
+	fn on_insert(
+		&mut self,
+		_length: usize,
+		key: Self::KeyToInsert<'_>,
+		node: NodeOwned<H>,
+	) -> Option<(H, NodeOwned<H>)> {
+		let new_item_heap_size = node.size_in_bytes() - std::mem::size_of::<NodeOwned<H>>();
+		if new_item_heap_size > self.max_heap_size {
+			// Item's too big to add even if the cache's empty; bail.
+			return None
+		}
+
+		self.heap_size += new_item_heap_size;
+		Some((key, node))
+	}
+
+	#[inline]
+	fn on_replace(
+		&mut self,
+		_length: usize,
+		_old_key: &mut H,
+		_new_key: H,
+		old_node: &mut NodeOwned<H>,
+		new_node: &mut NodeOwned<H>,
+	) -> bool {
+		debug_assert_eq!(_old_key.as_ref(), _new_key.as_ref());
+
+		let new_item_heap_size = new_node.size_in_bytes() - std::mem::size_of::<NodeOwned<H>>();
+		if new_item_heap_size > self.max_heap_size {
+			// Item's too big to add even if the cache's empty; bail.
+			return false
+		}
+
+		let old_item_heap_size = old_node.size_in_bytes() - std::mem::size_of::<NodeOwned<H>>();
+		self.heap_size = self.heap_size - old_item_heap_size + new_item_heap_size;
+		true
+	}
+
+	#[inline]
+	fn on_cleared(&mut self) {
+		self.heap_size = 0;
+	}
+
+	#[inline]
+	fn on_removed(&mut self, _: &mut H, node: &mut NodeOwned<H>) {
+		self.heap_size -= node.size_in_bytes() - std::mem::size_of::<NodeOwned<H>>();
+		self.items_evicted += 1;
+	}
+
+	#[inline]
+	fn on_grow(&mut self, new_memory_usage: usize) -> bool {
+		new_memory_usage <= self.max_inline_size
+	}
+}
+
+pub struct SharedValueCacheLimiter {
+	/// The maximum size (in bytes) the cache can hold inline.
+	///
+	/// This space is always consumed whether there are any items in the map or not.
+	max_inline_size: usize,
+
+	/// The maximum size (in bytes) the cache can hold on the heap.
+	max_heap_size: usize,
+
+	/// The current size (in bytes) of data allocated by this cache on the heap.
+	///
+	/// This doesn't include the size of the map itself.
+	heap_size: usize,
+
+	/// A set with all of the keys deduplicated to save on memory.
+	known_storage_keys: HashSet<Arc<[u8]>>,
+
+	/// A counter with the number of elements that got evicted from the cache.
+	///
+	/// Reset to zero before every update.
+	items_evicted: usize,
+
+	/// The maximum number of elements that we allow to be evicted.
+	///
+	/// Reset on every update.
+	max_items_evicted: usize,
+}
+
+impl<H> schnellru::Limiter<ValueCacheKey<H>, CachedValue<H>> for SharedValueCacheLimiter
+where
+	H: AsRef<[u8]>,
+{
+	type KeyToInsert<'a> = ValueCacheKey<H>;
+	type LinkType = u32;
+
+	#[inline]
+	fn is_over_the_limit(&self, _length: usize) -> bool {
+		self.items_evicted <= self.max_items_evicted && self.heap_size > self.max_heap_size
+	}
+
+	#[inline]
+	fn on_insert(
+		&mut self,
+		_length: usize,
+		mut key: Self::KeyToInsert<'_>,
+		value: CachedValue<H>,
+	) -> Option<(ValueCacheKey<H>, CachedValue<H>)> {
+		match self.known_storage_keys.entry(key.storage_key.clone()) {
+			SetEntry::Vacant(entry) => {
+				let new_item_heap_size = key.storage_key.len();
+				if new_item_heap_size > self.max_heap_size {
+					// Item's too big to add even if the cache's empty; bail.
+					return None
+				}
+
+				self.heap_size += new_item_heap_size;
+				entry.insert();
+			},
+			SetEntry::Occupied(entry) => {
+				key.storage_key = entry.get().clone();
+			},
+		}
+
+		Some((key, value))
+	}
+
+	#[inline]
+	fn on_replace(
+		&mut self,
+		_length: usize,
+		_old_key: &mut ValueCacheKey<H>,
+		_new_key: ValueCacheKey<H>,
+		_old_value: &mut CachedValue<H>,
+		_new_value: &mut CachedValue<H>,
+	) -> bool {
+		debug_assert_eq!(_new_key.storage_key, _old_key.storage_key);
+		true
+	}
+
+	#[inline]
+	fn on_removed(&mut self, key: &mut ValueCacheKey<H>, _: &mut CachedValue<H>) {
+		if Arc::strong_count(&key.storage_key) == 2 {
+			// There are only two instances of this key:
+			//   1) one memoized in `known_storage_keys`,
+			//   2) one inside the map.
+			//
+			// This means that after this remove goes through the `Arc` will be deallocated.
+			self.heap_size -= key.storage_key.len();
+			self.known_storage_keys.remove(&key.storage_key);
+		}
+		self.items_evicted += 1;
+	}
+
+	#[inline]
+	fn on_cleared(&mut self) {
+		self.heap_size = 0;
+		self.known_storage_keys.clear();
+	}
+
+	#[inline]
+	fn on_grow(&mut self, new_memory_usage: usize) -> bool {
+		new_memory_usage <= self.max_inline_size
+	}
+}
+
+type SharedNodeCacheMap<H> =
+	LruMap<H, NodeOwned<H>, SharedNodeCacheLimiter, schnellru::RandomState>;
+
+/// The shared node cache.
+///
+/// Internally this stores all cached nodes in a [`LruMap`]. It ensures that when updating the
+/// cache, that the cache stays within its allowed bounds.
+pub(super) struct SharedNodeCache<H>
+where
+	H: AsRef<[u8]>,
+{
+	/// The cached nodes, ordered by least recently used.
+	pub(super) lru: SharedNodeCacheMap<H>,
+}
+
+impl<H: AsRef<[u8]> + Eq + std::hash::Hash> SharedNodeCache<H> {
+	/// Create a new instance.
+	fn new(max_inline_size: usize, max_heap_size: usize) -> Self {
+		Self {
+			lru: LruMap::new(SharedNodeCacheLimiter {
+				max_inline_size,
+				max_heap_size,
+				heap_size: 0,
+				items_evicted: 0,
+				max_items_evicted: 0, // Will be set during `update`.
+			}),
+		}
+	}
+
+	/// Update the cache with the `list` of nodes which were either newly added or accessed.
+	pub fn update(&mut self, list: impl IntoIterator<Item = (H, NodeCached<H>)>) {
+		let mut access_count = 0;
+		let mut add_count = 0;
+
+		self.lru.limiter_mut().items_evicted = 0;
+		self.lru.limiter_mut().max_items_evicted =
+			self.lru.len() * 100 / super::SHARED_NODE_CACHE_MAX_REPLACE_PERCENT;
+
+		for (key, cached_node) in list {
+			if cached_node.is_from_shared_cache {
+				if self.lru.get(&key).is_some() {
+					access_count += 1;
+
+					if access_count >= super::SHARED_NODE_CACHE_MAX_PROMOTED_KEYS {
+						// Stop when we've promoted a large enough number of items.
+						break
+					}
+
+					continue
+				}
+			}
+
+			self.lru.insert(key, cached_node.node);
+			add_count += 1;
+
+			if self.lru.limiter().items_evicted > self.lru.limiter().max_items_evicted {
+				// Stop when we've evicted a big enough chunk of the shared cache.
+				break
+			}
+		}
+
+		tracing::debug!(
+			target: super::LOG_TARGET,
+			"Updated the shared node cache: {} accesses, {} new values, {}/{} evicted (length = {}, inline size={}/{}, heap size={}/{})",
+			access_count,
+			add_count,
+			self.lru.limiter().items_evicted,
+			self.lru.limiter().max_items_evicted,
+			self.lru.len(),
+			self.lru.memory_usage(),
+			self.lru.limiter().max_inline_size,
+			self.lru.limiter().heap_size,
+			self.lru.limiter().max_heap_size,
+		);
+	}
+
+	/// Reset the cache.
+	fn reset(&mut self) {
+		self.lru.clear();
+	}
+}
+
+/// The hash of [`ValueCacheKey`].
+#[derive(PartialEq, Eq, Clone, Copy, Hash)]
+#[repr(transparent)]
+pub struct ValueCacheKeyHash(u64);
+
+impl ValueCacheKeyHash {
+	pub fn raw(self) -> u64 {
+		self.0
+	}
+}
+
+impl ValueCacheKeyHash {
+	pub fn from_hasher_and_storage_key(
+		mut hasher: impl std::hash::Hasher,
+		storage_key: &[u8],
+	) -> Self {
+		hasher.write(storage_key);
+
+		Self(hasher.finish())
+	}
+}
+
+impl nohash_hasher::IsEnabled for ValueCacheKeyHash {}
+
+/// The key type that is being used to address a [`CachedValue`].
+#[derive(Eq)]
+pub(super) struct ValueCacheKey<H> {
+	/// The storage root of the trie this key belongs to.
+	pub storage_root: H,
+	/// The key to access the value in the storage.
+	pub storage_key: Arc<[u8]>,
+	/// The hash that identifies this instance of `storage_root` and `storage_key`.
+	pub hash: ValueCacheKeyHash,
+}
+
+/// A borrowed variant of [`ValueCacheKey`].
+pub(super) struct ValueCacheRef<'a, H> {
+	/// The storage root of the trie this key belongs to.
+	pub storage_root: H,
+	/// The key to access the value in the storage.
+	pub storage_key: &'a [u8],
+	/// The hash that identifies this instance of `storage_root` and `storage_key`.
+	pub hash: ValueCacheKeyHash,
+}
+
+impl<'a, H> ValueCacheRef<'a, H> {
+	pub fn new(storage_key: &'a [u8], storage_root: H) -> Self
+	where
+		H: AsRef<[u8]>,
+	{
+		let hash = ValueCacheKey::<H>::hash_data(&storage_key, &storage_root);
+		Self { storage_root, storage_key, hash }
+	}
+}
+
+impl<'a, H> From<ValueCacheRef<'a, H>> for ValueCacheKey<H> {
+	fn from(value: ValueCacheRef<'a, H>) -> Self {
+		ValueCacheKey {
+			storage_root: value.storage_root,
+			storage_key: value.storage_key.into(),
+			hash: value.hash,
+		}
+	}
+}
+
+impl<'a, H: std::hash::Hash> std::hash::Hash for ValueCacheRef<'a, H> {
+	fn hash<Hasher: std::hash::Hasher>(&self, state: &mut Hasher) {
+		self.hash.hash(state)
+	}
+}
+
+impl<'a, H> PartialEq<ValueCacheKey<H>> for ValueCacheRef<'a, H>
+where
+	H: AsRef<[u8]>,
+{
+	fn eq(&self, rhs: &ValueCacheKey<H>) -> bool {
+		self.storage_root.as_ref() == rhs.storage_root.as_ref() &&
+			self.storage_key == &*rhs.storage_key
+	}
+}
+
+impl<H> ValueCacheKey<H> {
+	/// Constructs [`Self::Value`].
+	#[cfg(test)] // Only used in tests.
+	pub fn new_value(storage_key: impl Into<Arc<[u8]>>, storage_root: H) -> Self
+	where
+		H: AsRef<[u8]>,
+	{
+		let storage_key = storage_key.into();
+		let hash = Self::hash_data(&storage_key, &storage_root);
+		Self { storage_root, storage_key, hash }
+	}
+
+	/// Returns a hasher prepared to build the final hash to identify [`Self`].
+	///
+	/// See [`Self::hash_data`] for building the hash directly.
+	pub fn hash_partial_data(storage_root: &H) -> impl std::hash::Hasher + Clone
+	where
+		H: AsRef<[u8]>,
+	{
+		let mut hasher = RANDOM_STATE.build_hasher();
+		hasher.write(storage_root.as_ref());
+		hasher
+	}
+
+	/// Hash the `key` and `storage_root` that identify [`Self`].
+	///
+	/// Returns a `u64` which represents the unique hash for the given inputs.
+	pub fn hash_data(key: &[u8], storage_root: &H) -> ValueCacheKeyHash
+	where
+		H: AsRef<[u8]>,
+	{
+		let hasher = Self::hash_partial_data(storage_root);
+
+		ValueCacheKeyHash::from_hasher_and_storage_key(hasher, key)
+	}
+
+	/// Checks whether the key is equal to the given `storage_key` and `storage_root`.
+	#[inline]
+	pub fn is_eq(&self, storage_root: &H, storage_key: &[u8]) -> bool
+	where
+		H: PartialEq,
+	{
+		self.storage_root == *storage_root && *self.storage_key == *storage_key
+	}
+}
+
+// Implement manually so that only `hash` is accessed.
+impl<H: std::hash::Hash> std::hash::Hash for ValueCacheKey<H> {
+	fn hash<Hasher: std::hash::Hasher>(&self, state: &mut Hasher) {
+		self.hash.hash(state)
+	}
+}
+
+impl<H> nohash_hasher::IsEnabled for ValueCacheKey<H> {}
+
+// Implement manually to not have to compare `hash`.
+impl<H: PartialEq> PartialEq for ValueCacheKey<H> {
+	#[inline]
+	fn eq(&self, other: &Self) -> bool {
+		self.is_eq(&other.storage_root, &other.storage_key)
+	}
+}
+
+type SharedValueCacheMap<H> = schnellru::LruMap<
+	ValueCacheKey<H>,
+	CachedValue<H>,
+	SharedValueCacheLimiter,
+	BuildNoHashHasher<ValueCacheKey<H>>,
+>;
+
+/// The shared value cache.
+///
+/// The cache ensures that it stays in the configured size bounds.
+pub(super) struct SharedValueCache<H>
+where
+	H: AsRef<[u8]>,
+{
+	/// The cached nodes, ordered by least recently used.
+	pub(super) lru: SharedValueCacheMap<H>,
+}
+
+impl<H: Eq + std::hash::Hash + Clone + Copy + AsRef<[u8]>> SharedValueCache<H> {
+	/// Create a new instance.
+	fn new(max_inline_size: usize, max_heap_size: usize) -> Self {
+		Self {
+			lru: schnellru::LruMap::with_hasher(
+				SharedValueCacheLimiter {
+					max_inline_size,
+					max_heap_size,
+					heap_size: 0,
+					known_storage_keys: Default::default(),
+					items_evicted: 0,
+					max_items_evicted: 0, // Will be set during `update`.
+				},
+				Default::default(),
+			),
+		}
+	}
+
+	/// Update the cache with the `added` values and the `accessed` values.
+	///
+	/// The `added` values are the ones that have been collected by doing operations on the trie and
+	/// now should be stored in the shared cache. The `accessed` values are only referenced by the
+	/// [`ValueCacheKeyHash`] and represent the values that were retrieved from this shared cache.
+	/// These `accessed` values are being put to the front of the internal [`LruMap`] like the
+	/// `added` ones.
+	pub fn update(
+		&mut self,
+		added: impl IntoIterator<Item = (ValueCacheKey<H>, CachedValue<H>)>,
+		accessed: impl IntoIterator<Item = ValueCacheKeyHash>,
+	) {
+		let mut access_count = 0;
+		let mut add_count = 0;
+
+		for hash in accessed {
+			// Access every node in the map to put it to the front.
+			//
+			// Since we are only comparing the hashes here it may lead us to promoting the wrong
+			// values as the most recently accessed ones. However this is harmless as the only
+			// consequence is that we may accidentally prune a recently used value too early.
+			self.lru.get_by_hash(hash.raw(), |existing_key, _| existing_key.hash == hash);
+			access_count += 1;
+		}
+
+		// Insert all of the new items which were *not* found in the shared cache.
+		//
+		// Limit how many items we'll replace in the shared cache in one go so that
+		// we don't evict the whole shared cache nor we keep spinning our wheels
+		// evicting items which we've added ourselves in previous iterations of this loop.
+
+		self.lru.limiter_mut().items_evicted = 0;
+		self.lru.limiter_mut().max_items_evicted =
+			self.lru.len() * 100 / super::SHARED_VALUE_CACHE_MAX_REPLACE_PERCENT;
+
+		for (key, value) in added {
+			self.lru.insert(key, value);
+			add_count += 1;
+
+			if self.lru.limiter().items_evicted > self.lru.limiter().max_items_evicted {
+				// Stop when we've evicted a big enough chunk of the shared cache.
+				break
+			}
+		}
+
+		tracing::debug!(
+			target: super::LOG_TARGET,
+			"Updated the shared value cache: {} accesses, {} new values, {}/{} evicted (length = {}, known_storage_keys = {}, inline size={}/{}, heap size={}/{})",
+			access_count,
+			add_count,
+			self.lru.limiter().items_evicted,
+			self.lru.limiter().max_items_evicted,
+			self.lru.len(),
+			self.lru.limiter().known_storage_keys.len(),
+			self.lru.memory_usage(),
+			self.lru.limiter().max_inline_size,
+			self.lru.limiter().heap_size,
+			self.lru.limiter().max_heap_size
+		);
+	}
+
+	/// Reset the cache.
+	fn reset(&mut self) {
+		self.lru.clear();
+	}
+}
+
+/// The inner of [`SharedTrieCache`].
+pub(super) struct SharedTrieCacheInner<H: Hasher> {
+	node_cache: SharedNodeCache<H::Out>,
+	value_cache: SharedValueCache<H::Out>,
+}
+
+impl<H: Hasher> SharedTrieCacheInner<H> {
+	/// Returns a reference to the [`SharedValueCache`].
+	#[cfg(test)]
+	pub(super) fn value_cache(&self) -> &SharedValueCache<H::Out> {
+		&self.value_cache
+	}
+
+	/// Returns a mutable reference to the [`SharedValueCache`].
+	pub(super) fn value_cache_mut(&mut self) -> &mut SharedValueCache<H::Out> {
+		&mut self.value_cache
+	}
+
+	/// Returns a reference to the [`SharedNodeCache`].
+	#[cfg(test)]
+	pub(super) fn node_cache(&self) -> &SharedNodeCache<H::Out> {
+		&self.node_cache
+	}
+
+	/// Returns a mutable reference to the [`SharedNodeCache`].
+	pub(super) fn node_cache_mut(&mut self) -> &mut SharedNodeCache<H::Out> {
+		&mut self.node_cache
+	}
+}
+
+/// The shared trie cache.
+///
+/// It should be instantiated once per node. It will hold the trie nodes and values of all
+/// operations to the state. To not use all available memory it will ensure to stay in the
+/// bounds given via the [`CacheSize`] at startup.
+///
+/// The instance of this object can be shared between multiple threads.
+pub struct SharedTrieCache<H: Hasher> {
+	inner: Arc<RwLock<SharedTrieCacheInner<H>>>,
+}
+
+impl<H: Hasher> Clone for SharedTrieCache<H> {
+	fn clone(&self) -> Self {
+		Self { inner: self.inner.clone() }
+	}
+}
+
+impl<H: Hasher> SharedTrieCache<H> {
+	/// Create a new [`SharedTrieCache`].
+	pub fn new(cache_size: CacheSize) -> Self {
+		let total_budget = cache_size.0;
+
+		// Split our memory budget between the two types of caches.
+		let value_cache_budget = (total_budget as f32 * 0.20) as usize; // 20% for the value cache
+		let node_cache_budget = total_budget - value_cache_budget; // 80% for the node cache
+
+		// Split our memory budget between what we'll be holding inline in the map,
+		// and what we'll be holding on the heap.
+		let value_cache_inline_budget = (value_cache_budget as f32 * 0.70) as usize;
+		let node_cache_inline_budget = (node_cache_budget as f32 * 0.70) as usize;
+
+		// Calculate how much memory the maps will be allowed to hold inline given our budget.
+		let value_cache_max_inline_size =
+			SharedValueCacheMap::<H::Out>::memory_usage_for_memory_budget(
+				value_cache_inline_budget,
+			);
+
+		let node_cache_max_inline_size =
+			SharedNodeCacheMap::<H::Out>::memory_usage_for_memory_budget(node_cache_inline_budget);
+
+		// And this is how much data we'll at most keep on the heap for each cache.
+		let value_cache_max_heap_size = value_cache_budget - value_cache_max_inline_size;
+		let node_cache_max_heap_size = node_cache_budget - node_cache_max_inline_size;
+
+		tracing::debug!(
+			target: super::LOG_TARGET,
+			"Configured a shared trie cache with a budget of ~{} bytes (node_cache_max_inline_size = {}, node_cache_max_heap_size = {}, value_cache_max_inline_size = {}, value_cache_max_heap_size = {})",
+			total_budget,
+			node_cache_max_inline_size,
+			node_cache_max_heap_size,
+			value_cache_max_inline_size,
+			value_cache_max_heap_size,
+		);
+
+		Self {
+			inner: Arc::new(RwLock::new(SharedTrieCacheInner {
+				node_cache: SharedNodeCache::new(
+					node_cache_max_inline_size,
+					node_cache_max_heap_size,
+				),
+				value_cache: SharedValueCache::new(
+					value_cache_max_inline_size,
+					value_cache_max_heap_size,
+				),
+			})),
+		}
+	}
+
+	/// Create a new [`LocalTrieCache`](super::LocalTrieCache) instance from this shared cache.
+	pub fn local_cache(&self) -> super::LocalTrieCache<H> {
+		super::LocalTrieCache {
+			shared: self.clone(),
+			node_cache: Default::default(),
+			value_cache: Default::default(),
+			shared_value_cache_access: Mutex::new(super::ValueAccessSet::with_hasher(
+				schnellru::ByLength::new(super::SHARED_VALUE_CACHE_MAX_PROMOTED_KEYS),
+				Default::default(),
+			)),
+			stats: Default::default(),
+		}
+	}
+
+	/// Get a copy of the node for `key`.
+	///
+	/// This will temporarily lock the shared cache for reading.
+	///
+	/// This doesn't change the least recently order in the internal [`LruMap`].
+	#[inline]
+	pub fn peek_node(&self, key: &H::Out) -> Option<NodeOwned<H::Out>> {
+		self.inner.read().node_cache.lru.peek(key).cloned()
+	}
+
+	/// Get a copy of the [`CachedValue`] for `key`.
+	///
+	/// This will temporarily lock the shared cache for reading.
+	///
+	/// This doesn't reorder any of the elements in the internal [`LruMap`].
+	pub fn peek_value_by_hash(
+		&self,
+		hash: ValueCacheKeyHash,
+		storage_root: &H::Out,
+		storage_key: &[u8],
+	) -> Option<CachedValue<H::Out>> {
+		self.inner
+			.read()
+			.value_cache
+			.lru
+			.peek_by_hash(hash.0, |existing_key, _| existing_key.is_eq(storage_root, storage_key))
+			.cloned()
+	}
+
+	/// Returns the used memory size of this cache in bytes.
+	pub fn used_memory_size(&self) -> usize {
+		let inner = self.inner.read();
+		let value_cache_size =
+			inner.value_cache.lru.memory_usage() + inner.value_cache.lru.limiter().heap_size;
+		let node_cache_size =
+			inner.node_cache.lru.memory_usage() + inner.node_cache.lru.limiter().heap_size;
+
+		node_cache_size + value_cache_size
+	}
+
+	/// Reset the node cache.
+	pub fn reset_node_cache(&self) {
+		self.inner.write().node_cache.reset();
+	}
+
+	/// Reset the value cache.
+	pub fn reset_value_cache(&self) {
+		self.inner.write().value_cache.reset();
+	}
+
+	/// Reset the entire cache.
+	pub fn reset(&self) {
+		self.reset_node_cache();
+		self.reset_value_cache();
+	}
+
+	/// Returns the read locked inner.
+	#[cfg(test)]
+	pub(super) fn read_lock_inner(
+		&self,
+	) -> parking_lot::RwLockReadGuard<'_, SharedTrieCacheInner<H>> {
+		self.inner.read()
+	}
+
+	/// Returns the write locked inner.
+	pub(super) fn write_lock_inner(&self) -> Option<RwLockWriteGuard<'_, SharedTrieCacheInner<H>>> {
+		// This should never happen, but we *really* don't want to deadlock. So let's have it
+		// timeout, just in case. At worst it'll do nothing, and at best it'll avert a catastrophe
+		// and notify us that there's a problem.
+		self.inner.try_write_for(super::SHARED_CACHE_WRITE_LOCK_TIMEOUT)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::H256 as Hash;
+
+	#[test]
+	fn shared_value_cache_works() {
+		let mut cache = SharedValueCache::<sp_core::H256>::new(usize::MAX, 10 * 10);
+
+		let key = vec![0; 10];
+
+		let root0 = Hash::repeat_byte(1);
+		let root1 = Hash::repeat_byte(2);
+
+		cache.update(
+			vec![
+				(ValueCacheKey::new_value(&key[..], root0), CachedValue::NonExisting),
+				(ValueCacheKey::new_value(&key[..], root1), CachedValue::NonExisting),
+			],
+			vec![],
+		);
+
+		// Ensure that the basics are working
+		assert_eq!(1, cache.lru.limiter_mut().known_storage_keys.len());
+		assert_eq!(
+			3, // Two instances inside the cache + one extra in `known_storage_keys`.
+			Arc::strong_count(cache.lru.limiter_mut().known_storage_keys.get(&key[..]).unwrap())
+		);
+		assert_eq!(key.len(), cache.lru.limiter().heap_size);
+		assert_eq!(cache.lru.len(), 2);
+		assert_eq!(cache.lru.peek_newest().unwrap().0.storage_root, root1);
+		assert_eq!(cache.lru.peek_oldest().unwrap().0.storage_root, root0);
+		assert!(cache.lru.limiter().heap_size <= cache.lru.limiter().max_heap_size);
+		assert_eq!(cache.lru.limiter().heap_size, 10);
+
+		// Just accessing a key should not change anything on the size and number of entries.
+		cache.update(vec![], vec![ValueCacheKey::hash_data(&key[..], &root0)]);
+		assert_eq!(1, cache.lru.limiter_mut().known_storage_keys.len());
+		assert_eq!(
+			3,
+			Arc::strong_count(cache.lru.limiter_mut().known_storage_keys.get(&key[..]).unwrap())
+		);
+		assert_eq!(key.len(), cache.lru.limiter().heap_size);
+		assert_eq!(cache.lru.len(), 2);
+		assert_eq!(cache.lru.peek_newest().unwrap().0.storage_root, root0);
+		assert_eq!(cache.lru.peek_oldest().unwrap().0.storage_root, root1);
+		assert!(cache.lru.limiter().heap_size <= cache.lru.limiter().max_heap_size);
+		assert_eq!(cache.lru.limiter().heap_size, 10);
+
+		// Updating the cache again with exactly the same data should not change anything.
+		cache.update(
+			vec![
+				(ValueCacheKey::new_value(&key[..], root1), CachedValue::NonExisting),
+				(ValueCacheKey::new_value(&key[..], root0), CachedValue::NonExisting),
+			],
+			vec![],
+		);
+		assert_eq!(1, cache.lru.limiter_mut().known_storage_keys.len());
+		assert_eq!(
+			3,
+			Arc::strong_count(cache.lru.limiter_mut().known_storage_keys.get(&key[..]).unwrap())
+		);
+		assert_eq!(key.len(), cache.lru.limiter().heap_size);
+		assert_eq!(cache.lru.len(), 2);
+		assert_eq!(cache.lru.peek_newest().unwrap().0.storage_root, root0);
+		assert_eq!(cache.lru.peek_oldest().unwrap().0.storage_root, root1);
+		assert!(cache.lru.limiter().heap_size <= cache.lru.limiter().max_heap_size);
+		assert_eq!(cache.lru.limiter().items_evicted, 0);
+		assert_eq!(cache.lru.limiter().heap_size, 10);
+
+		// Add 10 other entries and this should move out two of the initial entries.
+		cache.update(
+			(1..11)
+				.map(|i| vec![i; 10])
+				.map(|key| (ValueCacheKey::new_value(&key[..], root0), CachedValue::NonExisting)),
+			vec![],
+		);
+
+		assert_eq!(cache.lru.limiter().items_evicted, 2);
+		assert_eq!(10, cache.lru.len());
+		assert_eq!(10, cache.lru.limiter_mut().known_storage_keys.len());
+		assert!(cache.lru.limiter_mut().known_storage_keys.get(&key[..]).is_none());
+		assert_eq!(key.len() * 10, cache.lru.limiter().heap_size);
+		assert_eq!(cache.lru.len(), 10);
+		assert!(cache.lru.limiter().heap_size <= cache.lru.limiter().max_heap_size);
+		assert_eq!(cache.lru.limiter().heap_size, 100);
+
+		assert!(matches!(
+			cache.lru.peek(&ValueCacheKey::new_value(&[1; 10][..], root0)).unwrap(),
+			CachedValue::<Hash>::NonExisting
+		));
+
+		assert!(cache.lru.peek(&ValueCacheKey::new_value(&[1; 10][..], root1)).is_none(),);
+
+		assert!(cache.lru.peek(&ValueCacheKey::new_value(&key[..], root0)).is_none());
+		assert!(cache.lru.peek(&ValueCacheKey::new_value(&key[..], root1)).is_none());
+
+		cache.update(
+			vec![(ValueCacheKey::new_value(vec![10; 10], root0), CachedValue::NonExisting)],
+			vec![],
+		);
+
+		assert!(cache.lru.limiter_mut().known_storage_keys.get(&key[..]).is_none());
+	}
+}
diff --git a/substrate/primitives/trie/src/error.rs b/substrate/primitives/trie/src/error.rs
new file mode 100644
index 0000000000000000000000000000000000000000..17be556d3489ab03856a66498ba69de165a1a191
--- /dev/null
+++ b/substrate/primitives/trie/src/error.rs
@@ -0,0 +1,47 @@
+// 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 sp_std::{boxed::Box, vec::Vec};
+
+/// Error type used for trie related errors.
+#[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+pub enum Error<H> {
+	#[cfg_attr(feature = "std", error("Bad format"))]
+	BadFormat,
+	#[cfg_attr(feature = "std", error("Decoding failed: {0}"))]
+	Decode(#[cfg_attr(feature = "std", source)] codec::Error),
+	#[cfg_attr(
+		feature = "std",
+		error("Recorded key ({0:x?}) access with value as found={1}, but could not confirm with trie.")
+	)]
+	InvalidRecording(Vec<u8>, bool),
+	#[cfg_attr(feature = "std", error("Trie error: {0:?}"))]
+	TrieError(Box<trie_db::TrieError<H, Self>>),
+}
+
+impl<H> From<codec::Error> for Error<H> {
+	fn from(x: codec::Error) -> Self {
+		Error::Decode(x)
+	}
+}
+
+impl<H> From<Box<trie_db::TrieError<H, Self>>> for Error<H> {
+	fn from(x: Box<trie_db::TrieError<H, Self>>) -> Self {
+		Error::TrieError(x)
+	}
+}
diff --git a/substrate/primitives/trie/src/lib.rs b/substrate/primitives/trie/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..94155458569bff5dcb880aaae5c49899877a4e01
--- /dev/null
+++ b/substrate/primitives/trie/src/lib.rs
@@ -0,0 +1,1005 @@
+// 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.
+
+//! Utility functions to interact with Substrate's Base-16 Modified Merkle Patricia tree ("trie").
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "std")]
+pub mod cache;
+mod error;
+mod node_codec;
+mod node_header;
+#[cfg(feature = "std")]
+pub mod recorder;
+mod storage_proof;
+mod trie_codec;
+mod trie_stream;
+
+/// Our `NodeCodec`-specific error.
+pub use error::Error;
+/// Various re-exports from the `hash-db` crate.
+pub use hash_db::{HashDB as HashDBT, EMPTY_PREFIX};
+use hash_db::{Hasher, Prefix};
+/// Various re-exports from the `memory-db` crate.
+pub use memory_db::{prefixed_key, HashKey, KeyFunction, PrefixedKey};
+/// The Substrate format implementation of `NodeCodec`.
+pub use node_codec::NodeCodec;
+use sp_std::{borrow::Borrow, boxed::Box, marker::PhantomData, vec::Vec};
+pub use storage_proof::{CompactProof, StorageProof};
+/// Trie codec reexport, mainly child trie support
+/// for trie compact proof.
+pub use trie_codec::{decode_compact, encode_compact, Error as CompactProofError};
+pub use trie_db::proof::VerifyError;
+use trie_db::proof::{generate_proof, verify_proof};
+/// Various re-exports from the `trie-db` crate.
+pub use trie_db::{
+	nibble_ops,
+	node::{NodePlan, ValuePlan},
+	CError, DBValue, Query, Recorder, Trie, TrieCache, TrieConfiguration, TrieDBIterator,
+	TrieDBKeyIterator, TrieDBRawIterator, TrieLayout, TrieMut, TrieRecorder,
+};
+/// The Substrate format implementation of `TrieStream`.
+pub use trie_stream::TrieStream;
+
+/// substrate trie layout
+pub struct LayoutV0<H>(PhantomData<H>);
+
+/// substrate trie layout, with external value nodes.
+pub struct LayoutV1<H>(PhantomData<H>);
+
+impl<H> TrieLayout for LayoutV0<H>
+where
+	H: Hasher,
+{
+	const USE_EXTENSION: bool = false;
+	const ALLOW_EMPTY: bool = true;
+	const MAX_INLINE_VALUE: Option<u32> = None;
+
+	type Hash = H;
+	type Codec = NodeCodec<Self::Hash>;
+}
+
+impl<H> TrieConfiguration for LayoutV0<H>
+where
+	H: Hasher,
+{
+	fn trie_root<I, A, B>(input: I) -> <Self::Hash as Hasher>::Out
+	where
+		I: IntoIterator<Item = (A, B)>,
+		A: AsRef<[u8]> + Ord,
+		B: AsRef<[u8]>,
+	{
+		trie_root::trie_root_no_extension::<H, TrieStream, _, _, _>(input, Self::MAX_INLINE_VALUE)
+	}
+
+	fn trie_root_unhashed<I, A, B>(input: I) -> Vec<u8>
+	where
+		I: IntoIterator<Item = (A, B)>,
+		A: AsRef<[u8]> + Ord,
+		B: AsRef<[u8]>,
+	{
+		trie_root::unhashed_trie_no_extension::<H, TrieStream, _, _, _>(
+			input,
+			Self::MAX_INLINE_VALUE,
+		)
+	}
+
+	fn encode_index(input: u32) -> Vec<u8> {
+		codec::Encode::encode(&codec::Compact(input))
+	}
+}
+
+impl<H> TrieLayout for LayoutV1<H>
+where
+	H: Hasher,
+{
+	const USE_EXTENSION: bool = false;
+	const ALLOW_EMPTY: bool = true;
+	const MAX_INLINE_VALUE: Option<u32> = Some(sp_core::storage::TRIE_VALUE_NODE_THRESHOLD);
+
+	type Hash = H;
+	type Codec = NodeCodec<Self::Hash>;
+}
+
+impl<H> TrieConfiguration for LayoutV1<H>
+where
+	H: Hasher,
+{
+	fn trie_root<I, A, B>(input: I) -> <Self::Hash as Hasher>::Out
+	where
+		I: IntoIterator<Item = (A, B)>,
+		A: AsRef<[u8]> + Ord,
+		B: AsRef<[u8]>,
+	{
+		trie_root::trie_root_no_extension::<H, TrieStream, _, _, _>(input, Self::MAX_INLINE_VALUE)
+	}
+
+	fn trie_root_unhashed<I, A, B>(input: I) -> Vec<u8>
+	where
+		I: IntoIterator<Item = (A, B)>,
+		A: AsRef<[u8]> + Ord,
+		B: AsRef<[u8]>,
+	{
+		trie_root::unhashed_trie_no_extension::<H, TrieStream, _, _, _>(
+			input,
+			Self::MAX_INLINE_VALUE,
+		)
+	}
+
+	fn encode_index(input: u32) -> Vec<u8> {
+		codec::Encode::encode(&codec::Compact(input))
+	}
+}
+
+/// TrieDB error over `TrieConfiguration` trait.
+pub type TrieError<L> = trie_db::TrieError<TrieHash<L>, CError<L>>;
+/// Reexport from `hash_db`, with genericity set for `Hasher` trait.
+pub trait AsHashDB<H: Hasher>: hash_db::AsHashDB<H, trie_db::DBValue> {}
+impl<H: Hasher, T: hash_db::AsHashDB<H, trie_db::DBValue>> AsHashDB<H> for T {}
+/// Reexport from `hash_db`, with genericity set for `Hasher` trait.
+pub type HashDB<'a, H> = dyn hash_db::HashDB<H, trie_db::DBValue> + 'a;
+/// Reexport from `hash_db`, with genericity set for `Hasher` trait.
+/// This uses a `KeyFunction` for prefixing keys internally (avoiding
+/// key conflict for non random keys).
+pub type PrefixedMemoryDB<H> = memory_db::MemoryDB<H, memory_db::PrefixedKey<H>, trie_db::DBValue>;
+/// Reexport from `hash_db`, with genericity set for `Hasher` trait.
+/// This uses a noops `KeyFunction` (key addressing must be hashed or using
+/// an encoding scheme that avoid key conflict).
+pub type MemoryDB<H> = memory_db::MemoryDB<H, memory_db::HashKey<H>, trie_db::DBValue>;
+/// 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.
+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.
+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>;
+/// Querying interface, as in `trie_db` but less generic.
+pub type Lookup<'a, 'cache, L, Q> = trie_db::Lookup<'a, 'cache, L, Q>;
+/// Hash type for a trie layout.
+pub type TrieHash<L> = <<L as TrieLayout>::Hash as Hasher>::Out;
+/// This module is for non generic definition of trie type.
+/// Only the `Hasher` trait is generic in this case.
+pub mod trie_types {
+	use super::*;
+
+	/// Persistent trie database read-access interface for the 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.
+	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.
+	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>>;
+	/// Querying interface, as in `trie_db` but less generic.
+	pub type Lookup<'a, 'cache, H, Q> = trie_db::Lookup<'a, 'cache, LayoutV1<H>, Q>;
+	/// As in `trie_db`, but less generic, error type for the crate.
+	pub type TrieError<H> = trie_db::TrieError<H, super::Error<H>>;
+}
+
+/// Create a proof for a subset of keys in a trie.
+///
+/// The `keys` may contain any set of keys regardless of each one of them is included
+/// in the `db`.
+///
+/// For a key `K` that is included in the `db` a proof of inclusion is generated.
+/// For a key `K` that is not included in the `db` a proof of non-inclusion is generated.
+/// These can be later checked in `verify_trie_proof`.
+pub fn generate_trie_proof<'a, L, I, K, DB>(
+	db: &DB,
+	root: TrieHash<L>,
+	keys: I,
+) -> Result<Vec<Vec<u8>>, Box<TrieError<L>>>
+where
+	L: TrieConfiguration,
+	I: IntoIterator<Item = &'a K>,
+	K: 'a + AsRef<[u8]>,
+	DB: hash_db::HashDBRef<L::Hash, trie_db::DBValue>,
+{
+	generate_proof::<_, L, _, _>(db, &root, keys)
+}
+
+/// Verify a set of key-value pairs against a trie root and a proof.
+///
+/// Checks a set of keys with optional values for inclusion in the proof that was generated by
+/// `generate_trie_proof`.
+/// If the value in the pair is supplied (`(key, Some(value))`), this key-value pair will be
+/// checked for inclusion in the proof.
+/// If the value is omitted (`(key, None)`), this key will be checked for non-inclusion in the
+/// proof.
+pub fn verify_trie_proof<'a, L, I, K, V>(
+	root: &TrieHash<L>,
+	proof: &[Vec<u8>],
+	items: I,
+) -> Result<(), VerifyError<TrieHash<L>, CError<L>>>
+where
+	L: TrieConfiguration,
+	I: IntoIterator<Item = &'a (K, Option<V>)>,
+	K: 'a + AsRef<[u8]>,
+	V: 'a + AsRef<[u8]>,
+{
+	verify_proof::<L, _, _, _>(root, proof, items)
+}
+
+/// Determine a trie root given a hash DB and delta values.
+pub fn delta_trie_root<L: TrieConfiguration, I, A, B, DB, V>(
+	db: &mut DB,
+	mut root: TrieHash<L>,
+	delta: I,
+	recorder: Option<&mut dyn trie_db::TrieRecorder<TrieHash<L>>>,
+	cache: Option<&mut dyn TrieCache<L::Codec>>,
+) -> Result<TrieHash<L>, Box<TrieError<L>>>
+where
+	I: IntoIterator<Item = (A, B)>,
+	A: Borrow<[u8]>,
+	B: Borrow<Option<V>>,
+	V: Borrow<[u8]>,
+	DB: hash_db::HashDB<L::Hash, trie_db::DBValue>,
+{
+	{
+		let mut trie = TrieDBMutBuilder::<L>::from_existing(db, &mut root)
+			.with_optional_cache(cache)
+			.with_optional_recorder(recorder)
+			.build();
+
+		let mut delta = delta.into_iter().collect::<Vec<_>>();
+		delta.sort_by(|l, r| l.0.borrow().cmp(r.0.borrow()));
+
+		for (key, change) in delta {
+			match change.borrow() {
+				Some(val) => trie.insert(key.borrow(), val.borrow())?,
+				None => trie.remove(key.borrow())?,
+			};
+		}
+	}
+
+	Ok(root)
+}
+
+/// Read a value from the trie.
+pub fn read_trie_value<L: TrieLayout, DB: hash_db::HashDBRef<L::Hash, trie_db::DBValue>>(
+	db: &DB,
+	root: &TrieHash<L>,
+	key: &[u8],
+	recorder: Option<&mut dyn TrieRecorder<TrieHash<L>>>,
+	cache: Option<&mut dyn TrieCache<L::Codec>>,
+) -> Result<Option<Vec<u8>>, Box<TrieError<L>>> {
+	TrieDBBuilder::<L>::new(db, root)
+		.with_optional_cache(cache)
+		.with_optional_recorder(recorder)
+		.build()
+		.get(key)
+}
+
+/// Read a value from the trie with given Query.
+pub fn read_trie_value_with<
+	L: TrieLayout,
+	Q: Query<L::Hash, Item = Vec<u8>>,
+	DB: hash_db::HashDBRef<L::Hash, trie_db::DBValue>,
+>(
+	db: &DB,
+	root: &TrieHash<L>,
+	key: &[u8],
+	query: Q,
+) -> Result<Option<Vec<u8>>, Box<TrieError<L>>> {
+	TrieDBBuilder::<L>::new(db, root).build().get_with(key, query)
+}
+
+/// Determine the empty trie root.
+pub fn empty_trie_root<L: TrieConfiguration>() -> <L::Hash as Hasher>::Out {
+	L::trie_root::<_, Vec<u8>, Vec<u8>>(core::iter::empty())
+}
+
+/// Determine the empty child trie root.
+pub fn empty_child_trie_root<L: TrieConfiguration>() -> <L::Hash as Hasher>::Out {
+	L::trie_root::<_, Vec<u8>, Vec<u8>>(core::iter::empty())
+}
+
+/// Determine a child trie root given its ordered contents, closed form. H is the default hasher,
+/// but a generic implementation may ignore this type parameter and use other hashers.
+pub fn child_trie_root<L: TrieConfiguration, I, A, B>(input: I) -> <L::Hash as Hasher>::Out
+where
+	I: IntoIterator<Item = (A, B)>,
+	A: AsRef<[u8]> + Ord,
+	B: AsRef<[u8]>,
+{
+	L::trie_root(input)
+}
+
+/// Determine a child trie root given a hash DB and delta values. H is the default hasher,
+/// but a generic implementation may ignore this type parameter and use other hashers.
+pub fn child_delta_trie_root<L: TrieConfiguration, I, A, B, DB, RD, V>(
+	keyspace: &[u8],
+	db: &mut DB,
+	root_data: RD,
+	delta: I,
+	recorder: Option<&mut dyn TrieRecorder<TrieHash<L>>>,
+	cache: Option<&mut dyn TrieCache<L::Codec>>,
+) -> Result<<L::Hash as Hasher>::Out, Box<TrieError<L>>>
+where
+	I: IntoIterator<Item = (A, B)>,
+	A: Borrow<[u8]>,
+	B: Borrow<Option<V>>,
+	V: Borrow<[u8]>,
+	RD: AsRef<[u8]>,
+	DB: hash_db::HashDB<L::Hash, trie_db::DBValue>,
+{
+	let mut root = TrieHash::<L>::default();
+	// root is fetched from DB, not writable by runtime, so it's always valid.
+	root.as_mut().copy_from_slice(root_data.as_ref());
+
+	let mut db = KeySpacedDBMut::new(db, keyspace);
+	delta_trie_root::<L, _, _, _, _, _>(&mut db, root, delta, recorder, cache)
+}
+
+/// Read a value from the child trie.
+pub fn read_child_trie_value<L: TrieConfiguration, DB>(
+	keyspace: &[u8],
+	db: &DB,
+	root: &TrieHash<L>,
+	key: &[u8],
+	recorder: Option<&mut dyn TrieRecorder<TrieHash<L>>>,
+	cache: Option<&mut dyn TrieCache<L::Codec>>,
+) -> Result<Option<Vec<u8>>, Box<TrieError<L>>>
+where
+	DB: hash_db::HashDBRef<L::Hash, trie_db::DBValue>,
+{
+	let db = KeySpacedDB::new(db, keyspace);
+	TrieDBBuilder::<L>::new(&db, &root)
+		.with_optional_recorder(recorder)
+		.with_optional_cache(cache)
+		.build()
+		.get(key)
+		.map(|x| x.map(|val| val.to_vec()))
+}
+
+/// Read a hash from the child trie.
+pub fn read_child_trie_hash<L: TrieConfiguration, DB>(
+	keyspace: &[u8],
+	db: &DB,
+	root: &TrieHash<L>,
+	key: &[u8],
+	recorder: Option<&mut dyn TrieRecorder<TrieHash<L>>>,
+	cache: Option<&mut dyn TrieCache<L::Codec>>,
+) -> Result<Option<TrieHash<L>>, Box<TrieError<L>>>
+where
+	DB: hash_db::HashDBRef<L::Hash, trie_db::DBValue>,
+{
+	let db = KeySpacedDB::new(db, keyspace);
+	TrieDBBuilder::<L>::new(&db, &root)
+		.with_optional_recorder(recorder)
+		.with_optional_cache(cache)
+		.build()
+		.get_hash(key)
+}
+
+/// Read a value from the child trie with given query.
+pub fn read_child_trie_value_with<L, Q, DB>(
+	keyspace: &[u8],
+	db: &DB,
+	root_slice: &[u8],
+	key: &[u8],
+	query: Q,
+) -> Result<Option<Vec<u8>>, Box<TrieError<L>>>
+where
+	L: TrieConfiguration,
+	Q: Query<L::Hash, Item = DBValue>,
+	DB: hash_db::HashDBRef<L::Hash, trie_db::DBValue>,
+{
+	let mut root = TrieHash::<L>::default();
+	// root is fetched from DB, not writable by runtime, so it's always valid.
+	root.as_mut().copy_from_slice(root_slice);
+
+	let db = KeySpacedDB::new(db, keyspace);
+	TrieDBBuilder::<L>::new(&db, &root)
+		.build()
+		.get_with(key, query)
+		.map(|x| x.map(|val| val.to_vec()))
+}
+
+/// `HashDB` implementation that append a encoded prefix (unique id bytes) in addition to the
+/// prefix of every key value.
+pub struct KeySpacedDB<'a, DB: ?Sized, H>(&'a DB, &'a [u8], PhantomData<H>);
+
+/// `HashDBMut` implementation that append a encoded prefix (unique id bytes) in addition to the
+/// prefix of every key value.
+///
+/// Mutable variant of `KeySpacedDB`, see [`KeySpacedDB`].
+pub struct KeySpacedDBMut<'a, DB: ?Sized, H>(&'a mut DB, &'a [u8], PhantomData<H>);
+
+/// Utility function used to merge some byte data (keyspace) and `prefix` data
+/// before calling key value database primitives.
+fn keyspace_as_prefix_alloc(ks: &[u8], prefix: Prefix) -> (Vec<u8>, Option<u8>) {
+	let mut result = sp_std::vec![0; ks.len() + prefix.0.len()];
+	result[..ks.len()].copy_from_slice(ks);
+	result[ks.len()..].copy_from_slice(prefix.0);
+	(result, prefix.1)
+}
+
+impl<'a, DB: ?Sized, H> KeySpacedDB<'a, DB, H> {
+	/// instantiate new keyspaced db
+	#[inline]
+	pub fn new(db: &'a DB, ks: &'a [u8]) -> Self {
+		KeySpacedDB(db, ks, PhantomData)
+	}
+}
+
+impl<'a, DB: ?Sized, H> KeySpacedDBMut<'a, DB, H> {
+	/// instantiate new keyspaced db
+	pub fn new(db: &'a mut DB, ks: &'a [u8]) -> Self {
+		KeySpacedDBMut(db, ks, PhantomData)
+	}
+}
+
+impl<'a, DB, H, T> hash_db::HashDBRef<H, T> for KeySpacedDB<'a, DB, H>
+where
+	DB: hash_db::HashDBRef<H, T> + ?Sized,
+	H: Hasher,
+	T: From<&'static [u8]>,
+{
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<T> {
+		let derived_prefix = keyspace_as_prefix_alloc(self.1, prefix);
+		self.0.get(key, (&derived_prefix.0, derived_prefix.1))
+	}
+
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		let derived_prefix = keyspace_as_prefix_alloc(self.1, prefix);
+		self.0.contains(key, (&derived_prefix.0, derived_prefix.1))
+	}
+}
+
+impl<'a, DB, H, T> hash_db::HashDB<H, T> for KeySpacedDBMut<'a, DB, H>
+where
+	DB: hash_db::HashDB<H, T>,
+	H: Hasher,
+	T: Default + PartialEq<T> + for<'b> From<&'b [u8]> + Clone + Send + Sync,
+{
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<T> {
+		let derived_prefix = keyspace_as_prefix_alloc(self.1, prefix);
+		self.0.get(key, (&derived_prefix.0, derived_prefix.1))
+	}
+
+	fn contains(&self, key: &H::Out, prefix: Prefix) -> bool {
+		let derived_prefix = keyspace_as_prefix_alloc(self.1, prefix);
+		self.0.contains(key, (&derived_prefix.0, derived_prefix.1))
+	}
+
+	fn insert(&mut self, prefix: Prefix, value: &[u8]) -> H::Out {
+		let derived_prefix = keyspace_as_prefix_alloc(self.1, prefix);
+		self.0.insert((&derived_prefix.0, derived_prefix.1), value)
+	}
+
+	fn emplace(&mut self, key: H::Out, prefix: Prefix, value: T) {
+		let derived_prefix = keyspace_as_prefix_alloc(self.1, prefix);
+		self.0.emplace(key, (&derived_prefix.0, derived_prefix.1), value)
+	}
+
+	fn remove(&mut self, key: &H::Out, prefix: Prefix) {
+		let derived_prefix = keyspace_as_prefix_alloc(self.1, prefix);
+		self.0.remove(key, (&derived_prefix.0, derived_prefix.1))
+	}
+}
+
+impl<'a, DB, H, T> hash_db::AsHashDB<H, T> for KeySpacedDBMut<'a, DB, H>
+where
+	DB: hash_db::HashDB<H, T>,
+	H: Hasher,
+	T: Default + PartialEq<T> + for<'b> From<&'b [u8]> + Clone + Send + Sync,
+{
+	fn as_hash_db(&self) -> &dyn hash_db::HashDB<H, T> {
+		self
+	}
+
+	fn as_hash_db_mut<'b>(&'b mut self) -> &'b mut (dyn hash_db::HashDB<H, T> + 'b) {
+		&mut *self
+	}
+}
+
+/// Constants used into trie simplification codec.
+mod trie_constants {
+	const FIRST_PREFIX: u8 = 0b_00 << 6;
+	pub const LEAF_PREFIX_MASK: u8 = 0b_01 << 6;
+	pub const BRANCH_WITHOUT_MASK: u8 = 0b_10 << 6;
+	pub const BRANCH_WITH_MASK: u8 = 0b_11 << 6;
+	pub const EMPTY_TRIE: u8 = FIRST_PREFIX | (0b_00 << 4);
+	pub const ALT_HASHING_LEAF_PREFIX_MASK: u8 = FIRST_PREFIX | (0b_1 << 5);
+	pub const ALT_HASHING_BRANCH_WITH_MASK: u8 = FIRST_PREFIX | (0b_01 << 4);
+	pub const ESCAPE_COMPACT_HEADER: u8 = EMPTY_TRIE | 0b_00_01;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::{Compact, Decode, Encode};
+	use hash_db::{HashDB, Hasher};
+	use sp_core::Blake2Hasher;
+	use trie_db::{DBValue, NodeCodec as NodeCodecT, Trie, TrieMut};
+	use trie_standardmap::{Alphabet, StandardMap, ValueMode};
+
+	type LayoutV0 = super::LayoutV0<Blake2Hasher>;
+	type LayoutV1 = super::LayoutV1<Blake2Hasher>;
+
+	type MemoryDBMeta<H> = memory_db::MemoryDB<H, memory_db::HashKey<H>, trie_db::DBValue>;
+
+	fn hashed_null_node<T: TrieConfiguration>() -> TrieHash<T> {
+		<T::Codec as NodeCodecT>::hashed_null_node()
+	}
+
+	fn check_equivalent<T: TrieConfiguration>(input: &Vec<(&[u8], &[u8])>) {
+		{
+			let closed_form = T::trie_root(input.clone());
+			let d = T::trie_root_unhashed(input.clone());
+			println!("Data: {:#x?}, {:#x?}", d, Blake2Hasher::hash(&d[..]));
+			let persistent = {
+				let mut memdb = MemoryDBMeta::default();
+				let mut root = Default::default();
+				let mut t = TrieDBMutBuilder::<T>::new(&mut memdb, &mut root).build();
+				for (x, y) in input.iter().rev() {
+					t.insert(x, y).unwrap();
+				}
+				*t.root()
+			};
+			assert_eq!(closed_form, persistent);
+		}
+	}
+
+	fn check_iteration<T: TrieConfiguration>(input: &Vec<(&[u8], &[u8])>) {
+		let mut memdb = MemoryDBMeta::default();
+		let mut root = Default::default();
+		{
+			let mut t = TrieDBMutBuilder::<T>::new(&mut memdb, &mut root).build();
+			for (x, y) in input.clone() {
+				t.insert(x, y).unwrap();
+			}
+		}
+		{
+			let t = TrieDBBuilder::<T>::new(&memdb, &root).build();
+			assert_eq!(
+				input.iter().map(|(i, j)| (i.to_vec(), j.to_vec())).collect::<Vec<_>>(),
+				t.iter()
+					.unwrap()
+					.map(|x| x.map(|y| (y.0, y.1.to_vec())).unwrap())
+					.collect::<Vec<_>>()
+			);
+		}
+	}
+
+	fn check_input(input: &Vec<(&[u8], &[u8])>) {
+		check_equivalent::<LayoutV0>(input);
+		check_iteration::<LayoutV0>(input);
+		check_equivalent::<LayoutV1>(input);
+		check_iteration::<LayoutV1>(input);
+	}
+
+	#[test]
+	fn default_trie_root() {
+		let mut db = MemoryDB::default();
+		let mut root = TrieHash::<LayoutV1>::default();
+		let mut empty = TrieDBMutBuilder::<LayoutV1>::new(&mut db, &mut root).build();
+		empty.commit();
+		let root1 = empty.root().as_ref().to_vec();
+		let root2: Vec<u8> = LayoutV1::trie_root::<_, Vec<u8>, Vec<u8>>(std::iter::empty())
+			.as_ref()
+			.iter()
+			.cloned()
+			.collect();
+
+		assert_eq!(root1, root2);
+	}
+
+	#[test]
+	fn empty_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> = vec![];
+		check_input(&input);
+	}
+
+	#[test]
+	fn leaf_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> = vec![(&[0xaa][..], &[0xbb][..])];
+		check_input(&input);
+	}
+
+	#[test]
+	fn branch_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> =
+			vec![(&[0xaa][..], &[0x10][..]), (&[0xba][..], &[0x11][..])];
+		check_input(&input);
+	}
+
+	#[test]
+	fn extension_and_branch_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> =
+			vec![(&[0xaa][..], &[0x10][..]), (&[0xab][..], &[0x11][..])];
+		check_input(&input);
+	}
+
+	#[test]
+	fn standard_is_equivalent() {
+		let st = StandardMap {
+			alphabet: Alphabet::All,
+			min_key: 32,
+			journal_key: 0,
+			value_mode: ValueMode::Random,
+			count: 1000,
+		};
+		let mut d = st.make();
+		d.sort_by(|(a, _), (b, _)| a.cmp(b));
+		let dr = d.iter().map(|v| (&v.0[..], &v.1[..])).collect();
+		check_input(&dr);
+	}
+
+	#[test]
+	fn extension_and_branch_with_value_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> = vec![
+			(&[0xaa][..], &[0xa0][..]),
+			(&[0xaa, 0xaa][..], &[0xaa][..]),
+			(&[0xaa, 0xbb][..], &[0xab][..]),
+		];
+		check_input(&input);
+	}
+
+	#[test]
+	fn bigger_extension_and_branch_with_value_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> = vec![
+			(&[0xaa][..], &[0xa0][..]),
+			(&[0xaa, 0xaa][..], &[0xaa][..]),
+			(&[0xaa, 0xbb][..], &[0xab][..]),
+			(&[0xbb][..], &[0xb0][..]),
+			(&[0xbb, 0xbb][..], &[0xbb][..]),
+			(&[0xbb, 0xcc][..], &[0xbc][..]),
+		];
+		check_input(&input);
+	}
+
+	#[test]
+	fn single_long_leaf_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> = vec![
+			(
+				&[0xaa][..],
+				&b"ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC"[..],
+			),
+			(&[0xba][..], &[0x11][..]),
+		];
+		check_input(&input);
+	}
+
+	#[test]
+	fn two_long_leaves_is_equivalent() {
+		let input: Vec<(&[u8], &[u8])> = vec![
+			(
+				&[0xaa][..],
+				&b"ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC"[..],
+			),
+			(
+				&[0xba][..],
+				&b"ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC"[..],
+			),
+		];
+		check_input(&input);
+	}
+
+	fn populate_trie<'db, T: TrieConfiguration>(
+		db: &'db mut dyn HashDB<T::Hash, DBValue>,
+		root: &'db mut TrieHash<T>,
+		v: &[(Vec<u8>, Vec<u8>)],
+	) -> TrieDBMut<'db, T> {
+		let mut t = TrieDBMutBuilder::<T>::new(db, root).build();
+		for i in 0..v.len() {
+			let key: &[u8] = &v[i].0;
+			let val: &[u8] = &v[i].1;
+			t.insert(key, val).unwrap();
+		}
+		t
+	}
+
+	fn unpopulate_trie<T: TrieConfiguration>(t: &mut TrieDBMut<'_, T>, v: &[(Vec<u8>, Vec<u8>)]) {
+		for i in v {
+			let key: &[u8] = &i.0;
+			t.remove(key).unwrap();
+		}
+	}
+
+	#[test]
+	fn random_should_work() {
+		random_should_work_inner::<LayoutV1>();
+		random_should_work_inner::<LayoutV0>();
+	}
+	fn random_should_work_inner<L: TrieConfiguration>() {
+		let mut seed = <Blake2Hasher as Hasher>::Out::zero();
+		for test_i in 0..10_000 {
+			if test_i % 50 == 0 {
+				println!("{:?} of 10000 stress tests done", test_i);
+			}
+			let x = StandardMap {
+				alphabet: Alphabet::Custom(b"@QWERTYUIOPASDFGHJKLZXCVBNM[/]^_".to_vec()),
+				min_key: 5,
+				journal_key: 0,
+				value_mode: ValueMode::Index,
+				count: 100,
+			}
+			.make_with(seed.as_fixed_bytes_mut());
+
+			let real = L::trie_root(x.clone());
+			let mut memdb = MemoryDB::default();
+			let mut root = Default::default();
+
+			let mut memtrie = populate_trie::<L>(&mut memdb, &mut root, &x);
+
+			memtrie.commit();
+			if *memtrie.root() != real {
+				println!("TRIE MISMATCH");
+				println!();
+				println!("{:?} vs {:?}", memtrie.root(), real);
+				for i in &x {
+					println!("{:#x?} -> {:#x?}", i.0, i.1);
+				}
+			}
+			assert_eq!(*memtrie.root(), real);
+			unpopulate_trie::<L>(&mut memtrie, &x);
+			memtrie.commit();
+			let hashed_null_node = hashed_null_node::<L>();
+			if *memtrie.root() != hashed_null_node {
+				println!("- TRIE MISMATCH");
+				println!();
+				println!("{:?} vs {:?}", memtrie.root(), hashed_null_node);
+				for i in &x {
+					println!("{:#x?} -> {:#x?}", i.0, i.1);
+				}
+			}
+			assert_eq!(*memtrie.root(), hashed_null_node);
+		}
+	}
+
+	fn to_compact(n: u8) -> u8 {
+		Compact(n).encode()[0]
+	}
+
+	#[test]
+	fn codec_trie_empty() {
+		let input: Vec<(&[u8], &[u8])> = vec![];
+		let trie = LayoutV1::trie_root_unhashed(input);
+		println!("trie: {:#x?}", trie);
+		assert_eq!(trie, vec![0x0]);
+	}
+
+	#[test]
+	fn codec_trie_single_tuple() {
+		let input = vec![(vec![0xaa], vec![0xbb])];
+		let trie = LayoutV1::trie_root_unhashed(input);
+		println!("trie: {:#x?}", trie);
+		assert_eq!(
+			trie,
+			vec![
+				0x42,          // leaf 0x40 (2^6) with (+) key of 2 nibbles (0x02)
+				0xaa,          // key data
+				to_compact(1), // length of value in bytes as Compact
+				0xbb           // value data
+			]
+		);
+	}
+
+	#[test]
+	fn codec_trie_two_tuples_disjoint_keys() {
+		let input = vec![(&[0x48, 0x19], &[0xfe]), (&[0x13, 0x14], &[0xff])];
+		let trie = LayoutV1::trie_root_unhashed(input);
+		println!("trie: {:#x?}", trie);
+		let mut ex = Vec::<u8>::new();
+		ex.push(0x80); // branch, no value (0b_10..) no nibble
+		ex.push(0x12); // slots 1 & 4 are taken from 0-7
+		ex.push(0x00); // no slots from 8-15
+		ex.push(to_compact(0x05)); // first slot: LEAF, 5 bytes long.
+		ex.push(0x43); // leaf 0x40 with 3 nibbles
+		ex.push(0x03); // first nibble
+		ex.push(0x14); // second & third nibble
+		ex.push(to_compact(0x01)); // 1 byte data
+		ex.push(0xff); // value data
+		ex.push(to_compact(0x05)); // second slot: LEAF, 5 bytes long.
+		ex.push(0x43); // leaf with 3 nibbles
+		ex.push(0x08); // first nibble
+		ex.push(0x19); // second & third nibble
+		ex.push(to_compact(0x01)); // 1 byte data
+		ex.push(0xfe); // value data
+
+		assert_eq!(trie, ex);
+	}
+
+	#[test]
+	fn iterator_works() {
+		iterator_works_inner::<LayoutV1>();
+		iterator_works_inner::<LayoutV0>();
+	}
+	fn iterator_works_inner<Layout: TrieConfiguration>() {
+		let pairs = vec![
+			(
+				array_bytes::hex2bytes_unchecked("0103000000000000000464"),
+				array_bytes::hex2bytes_unchecked("0400000000"),
+			),
+			(
+				array_bytes::hex2bytes_unchecked("0103000000000000000469"),
+				array_bytes::hex2bytes_unchecked("0401000000"),
+			),
+		];
+
+		let mut mdb = MemoryDB::default();
+		let mut root = Default::default();
+		let _ = populate_trie::<Layout>(&mut mdb, &mut root, &pairs);
+
+		let trie = TrieDBBuilder::<Layout>::new(&mdb, &root).build();
+
+		let iter = trie.iter().unwrap();
+		let mut iter_pairs = Vec::new();
+		for pair in iter {
+			let (key, value) = pair.unwrap();
+			iter_pairs.push((key, value));
+		}
+
+		assert_eq!(pairs, iter_pairs);
+	}
+
+	#[test]
+	fn proof_non_inclusion_works() {
+		let pairs = vec![
+			(array_bytes::hex2bytes_unchecked("0102"), array_bytes::hex2bytes_unchecked("01")),
+			(array_bytes::hex2bytes_unchecked("0203"), array_bytes::hex2bytes_unchecked("0405")),
+		];
+
+		let mut memdb = MemoryDB::default();
+		let mut root = Default::default();
+		populate_trie::<LayoutV1>(&mut memdb, &mut root, &pairs);
+
+		let non_included_key: Vec<u8> = array_bytes::hex2bytes_unchecked("0909");
+		let proof =
+			generate_trie_proof::<LayoutV1, _, _, _>(&memdb, root, &[non_included_key.clone()])
+				.unwrap();
+
+		// Verifying that the K was not included into the trie should work.
+		assert!(verify_trie_proof::<LayoutV1, _, _, Vec<u8>>(
+			&root,
+			&proof,
+			&[(non_included_key.clone(), None)],
+		)
+		.is_ok());
+
+		// Verifying that the K was included into the trie should fail.
+		assert!(verify_trie_proof::<LayoutV1, _, _, Vec<u8>>(
+			&root,
+			&proof,
+			&[(non_included_key, Some(array_bytes::hex2bytes_unchecked("1010")))],
+		)
+		.is_err());
+	}
+
+	#[test]
+	fn proof_inclusion_works() {
+		let pairs = vec![
+			(array_bytes::hex2bytes_unchecked("0102"), array_bytes::hex2bytes_unchecked("01")),
+			(array_bytes::hex2bytes_unchecked("0203"), array_bytes::hex2bytes_unchecked("0405")),
+		];
+
+		let mut memdb = MemoryDB::default();
+		let mut root = Default::default();
+		populate_trie::<LayoutV1>(&mut memdb, &mut root, &pairs);
+
+		let proof =
+			generate_trie_proof::<LayoutV1, _, _, _>(&memdb, root, &[pairs[0].0.clone()]).unwrap();
+
+		// Check that a K, V included into the proof are verified.
+		assert!(verify_trie_proof::<LayoutV1, _, _, _>(
+			&root,
+			&proof,
+			&[(pairs[0].0.clone(), Some(pairs[0].1.clone()))]
+		)
+		.is_ok());
+
+		// Absence of the V is not verified with the proof that has K, V included.
+		assert!(verify_trie_proof::<LayoutV1, _, _, Vec<u8>>(
+			&root,
+			&proof,
+			&[(pairs[0].0.clone(), None)]
+		)
+		.is_err());
+
+		// K not included into the trie is not verified.
+		assert!(verify_trie_proof::<LayoutV1, _, _, _>(
+			&root,
+			&proof,
+			&[(array_bytes::hex2bytes_unchecked("4242"), Some(pairs[0].1.clone()))]
+		)
+		.is_err());
+
+		// K included into the trie but not included into the proof is not verified.
+		assert!(verify_trie_proof::<LayoutV1, _, _, _>(
+			&root,
+			&proof,
+			&[(pairs[1].0.clone(), Some(pairs[1].1.clone()))]
+		)
+		.is_err());
+	}
+
+	#[test]
+	fn generate_storage_root_with_proof_works_independently_from_the_delta_order() {
+		let proof = StorageProof::decode(&mut &include_bytes!("../test-res/proof")[..]).unwrap();
+		let storage_root =
+			sp_core::H256::decode(&mut &include_bytes!("../test-res/storage_root")[..]).unwrap();
+		// Delta order that is "invalid" so that it would require a different proof.
+		let invalid_delta = Vec::<(Vec<u8>, Option<Vec<u8>>)>::decode(
+			&mut &include_bytes!("../test-res/invalid-delta-order")[..],
+		)
+		.unwrap();
+		// Delta order that is "valid"
+		let valid_delta = Vec::<(Vec<u8>, Option<Vec<u8>>)>::decode(
+			&mut &include_bytes!("../test-res/valid-delta-order")[..],
+		)
+		.unwrap();
+
+		let proof_db = proof.into_memory_db::<Blake2Hasher>();
+		let first_storage_root = delta_trie_root::<LayoutV0, _, _, _, _, _>(
+			&mut proof_db.clone(),
+			storage_root,
+			valid_delta,
+			None,
+			None,
+		)
+		.unwrap();
+		let second_storage_root = delta_trie_root::<LayoutV0, _, _, _, _, _>(
+			&mut proof_db.clone(),
+			storage_root,
+			invalid_delta,
+			None,
+			None,
+		)
+		.unwrap();
+
+		assert_eq!(first_storage_root, second_storage_root);
+	}
+
+	#[test]
+	fn big_key() {
+		let check = |keysize: usize| {
+			let mut memdb = PrefixedMemoryDB::<Blake2Hasher>::default();
+			let mut root = Default::default();
+			let mut t = TrieDBMutBuilder::<LayoutV1>::new(&mut memdb, &mut root).build();
+			t.insert(&vec![0x01u8; keysize][..], &[0x01u8, 0x23]).unwrap();
+			std::mem::drop(t);
+			let t = TrieDBBuilder::<LayoutV1>::new(&memdb, &root).build();
+			assert_eq!(t.get(&vec![0x01u8; keysize][..]).unwrap(), Some(vec![0x01u8, 0x23]));
+		};
+		check(u16::MAX as usize / 2); // old limit
+		check(u16::MAX as usize / 2 + 1); // value over old limit still works
+	}
+
+	#[test]
+	fn node_with_no_children_fail_decoding() {
+		let branch = NodeCodec::<Blake2Hasher>::branch_node_nibbled(
+			b"some_partial".iter().copied(),
+			24,
+			vec![None; 16].into_iter(),
+			Some(trie_db::node::Value::Inline(b"value"[..].into())),
+		);
+		assert!(NodeCodec::<Blake2Hasher>::decode(branch.as_slice()).is_err());
+	}
+}
diff --git a/substrate/primitives/trie/src/node_codec.rs b/substrate/primitives/trie/src/node_codec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..46acde77c0543af88e6f3d62cbfb460fe88c117a
--- /dev/null
+++ b/substrate/primitives/trie/src/node_codec.rs
@@ -0,0 +1,330 @@
+// 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.
+
+//! `NodeCodec` implementation for Substrate's trie format.
+
+use super::node_header::{NodeHeader, NodeKind};
+use crate::{error::Error, trie_constants};
+use codec::{Compact, Decode, Encode, Input};
+use hash_db::Hasher;
+use sp_std::{borrow::Borrow, marker::PhantomData, ops::Range, vec::Vec};
+use trie_db::{
+	nibble_ops,
+	node::{NibbleSlicePlan, NodeHandlePlan, NodePlan, Value, ValuePlan},
+	ChildReference, NodeCodec as NodeCodecT,
+};
+
+/// Helper struct for trie node decoder. This implements `codec::Input` on a byte slice, while
+/// tracking the absolute position. This is similar to `std::io::Cursor` but does not implement
+/// `Read` and `io` is not in `sp-std`.
+struct ByteSliceInput<'a> {
+	data: &'a [u8],
+	offset: usize,
+}
+
+impl<'a> ByteSliceInput<'a> {
+	fn new(data: &'a [u8]) -> Self {
+		ByteSliceInput { data, offset: 0 }
+	}
+
+	fn take(&mut self, count: usize) -> Result<Range<usize>, codec::Error> {
+		if self.offset + count > self.data.len() {
+			return Err("out of data".into())
+		}
+
+		let range = self.offset..(self.offset + count);
+		self.offset += count;
+		Ok(range)
+	}
+}
+
+impl<'a> Input for ByteSliceInput<'a> {
+	fn remaining_len(&mut self) -> Result<Option<usize>, codec::Error> {
+		Ok(Some(self.data.len().saturating_sub(self.offset)))
+	}
+
+	fn read(&mut self, into: &mut [u8]) -> Result<(), codec::Error> {
+		let range = self.take(into.len())?;
+		into.copy_from_slice(&self.data[range]);
+		Ok(())
+	}
+
+	fn read_byte(&mut self) -> Result<u8, codec::Error> {
+		if self.offset + 1 > self.data.len() {
+			return Err("out of data".into())
+		}
+
+		let byte = self.data[self.offset];
+		self.offset += 1;
+		Ok(byte)
+	}
+}
+
+/// Concrete implementation of a [`NodeCodecT`] with SCALE encoding.
+///
+/// It is generic over `H` the [`Hasher`].
+#[derive(Default, Clone)]
+pub struct NodeCodec<H>(PhantomData<H>);
+
+impl<H> NodeCodecT for NodeCodec<H>
+where
+	H: Hasher,
+{
+	const ESCAPE_HEADER: Option<u8> = Some(trie_constants::ESCAPE_COMPACT_HEADER);
+	type Error = Error<H::Out>;
+	type HashOut = H::Out;
+
+	fn hashed_null_node() -> <H as Hasher>::Out {
+		H::hash(<Self as NodeCodecT>::empty_node())
+	}
+
+	fn decode_plan(data: &[u8]) -> Result<NodePlan, Self::Error> {
+		let mut input = ByteSliceInput::new(data);
+
+		let header = NodeHeader::decode(&mut input)?;
+		let contains_hash = header.contains_hash_of_value();
+
+		let branch_has_value = if let NodeHeader::Branch(has_value, _) = &header {
+			*has_value
+		} else {
+			// hashed_value_branch
+			true
+		};
+
+		match header {
+			NodeHeader::Null => Ok(NodePlan::Empty),
+			NodeHeader::HashedValueBranch(nibble_count) | NodeHeader::Branch(_, nibble_count) => {
+				let padding = nibble_count % nibble_ops::NIBBLE_PER_BYTE != 0;
+				// check that the padding is valid (if any)
+				if padding && nibble_ops::pad_left(data[input.offset]) != 0 {
+					return Err(Error::BadFormat)
+				}
+				let partial = input.take(
+					(nibble_count + (nibble_ops::NIBBLE_PER_BYTE - 1)) /
+						nibble_ops::NIBBLE_PER_BYTE,
+				)?;
+				let partial_padding = nibble_ops::number_padding(nibble_count);
+				let bitmap_range = input.take(BITMAP_LENGTH)?;
+				let bitmap = Bitmap::decode(&data[bitmap_range])?;
+				let value = if branch_has_value {
+					Some(if contains_hash {
+						ValuePlan::Node(input.take(H::LENGTH)?)
+					} else {
+						let count = <Compact<u32>>::decode(&mut input)?.0 as usize;
+						ValuePlan::Inline(input.take(count)?)
+					})
+				} else {
+					None
+				};
+				let mut children = [
+					None, None, None, None, None, None, None, None, None, None, None, None, None,
+					None, None, None,
+				];
+				for i in 0..nibble_ops::NIBBLE_LENGTH {
+					if bitmap.value_at(i) {
+						let count = <Compact<u32>>::decode(&mut input)?.0 as usize;
+						let range = input.take(count)?;
+						children[i] = Some(if count == H::LENGTH {
+							NodeHandlePlan::Hash(range)
+						} else {
+							NodeHandlePlan::Inline(range)
+						});
+					}
+				}
+				Ok(NodePlan::NibbledBranch {
+					partial: NibbleSlicePlan::new(partial, partial_padding),
+					value,
+					children,
+				})
+			},
+			NodeHeader::HashedValueLeaf(nibble_count) | NodeHeader::Leaf(nibble_count) => {
+				let padding = nibble_count % nibble_ops::NIBBLE_PER_BYTE != 0;
+				// check that the padding is valid (if any)
+				if padding && nibble_ops::pad_left(data[input.offset]) != 0 {
+					return Err(Error::BadFormat)
+				}
+				let partial = input.take(
+					(nibble_count + (nibble_ops::NIBBLE_PER_BYTE - 1)) /
+						nibble_ops::NIBBLE_PER_BYTE,
+				)?;
+				let partial_padding = nibble_ops::number_padding(nibble_count);
+				let value = if contains_hash {
+					ValuePlan::Node(input.take(H::LENGTH)?)
+				} else {
+					let count = <Compact<u32>>::decode(&mut input)?.0 as usize;
+					ValuePlan::Inline(input.take(count)?)
+				};
+
+				Ok(NodePlan::Leaf {
+					partial: NibbleSlicePlan::new(partial, partial_padding),
+					value,
+				})
+			},
+		}
+	}
+
+	fn is_empty_node(data: &[u8]) -> bool {
+		data == <Self as NodeCodecT>::empty_node()
+	}
+
+	fn empty_node() -> &'static [u8] {
+		&[trie_constants::EMPTY_TRIE]
+	}
+
+	fn leaf_node(partial: impl Iterator<Item = u8>, number_nibble: usize, value: Value) -> Vec<u8> {
+		let contains_hash = matches!(&value, Value::Node(..));
+		let mut output = if contains_hash {
+			partial_from_iterator_encode(partial, number_nibble, NodeKind::HashedValueLeaf)
+		} else {
+			partial_from_iterator_encode(partial, number_nibble, NodeKind::Leaf)
+		};
+		match value {
+			Value::Inline(value) => {
+				Compact(value.len() as u32).encode_to(&mut output);
+				output.extend_from_slice(value);
+			},
+			Value::Node(hash) => {
+				debug_assert!(hash.len() == H::LENGTH);
+				output.extend_from_slice(hash);
+			},
+		}
+		output
+	}
+
+	fn extension_node(
+		_partial: impl Iterator<Item = u8>,
+		_nbnibble: usize,
+		_child: ChildReference<<H as Hasher>::Out>,
+	) -> Vec<u8> {
+		unreachable!("No extension codec.")
+	}
+
+	fn branch_node(
+		_children: impl Iterator<Item = impl Borrow<Option<ChildReference<<H as Hasher>::Out>>>>,
+		_maybe_value: Option<Value>,
+	) -> Vec<u8> {
+		unreachable!("No extension codec.")
+	}
+
+	fn branch_node_nibbled(
+		partial: impl Iterator<Item = u8>,
+		number_nibble: usize,
+		children: impl Iterator<Item = impl Borrow<Option<ChildReference<<H as Hasher>::Out>>>>,
+		value: Option<Value>,
+	) -> Vec<u8> {
+		let contains_hash = matches!(&value, Some(Value::Node(..)));
+		let mut output = match (&value, contains_hash) {
+			(&None, _) =>
+				partial_from_iterator_encode(partial, number_nibble, NodeKind::BranchNoValue),
+			(_, false) =>
+				partial_from_iterator_encode(partial, number_nibble, NodeKind::BranchWithValue),
+			(_, true) =>
+				partial_from_iterator_encode(partial, number_nibble, NodeKind::HashedValueBranch),
+		};
+
+		let bitmap_index = output.len();
+		let mut bitmap: [u8; BITMAP_LENGTH] = [0; BITMAP_LENGTH];
+		(0..BITMAP_LENGTH).for_each(|_| output.push(0));
+		match value {
+			Some(Value::Inline(value)) => {
+				Compact(value.len() as u32).encode_to(&mut output);
+				output.extend_from_slice(value);
+			},
+			Some(Value::Node(hash)) => {
+				debug_assert!(hash.len() == H::LENGTH);
+				output.extend_from_slice(hash);
+			},
+			None => (),
+		}
+		Bitmap::encode(
+			children.map(|maybe_child| match maybe_child.borrow() {
+				Some(ChildReference::Hash(h)) => {
+					h.as_ref().encode_to(&mut output);
+					true
+				},
+				&Some(ChildReference::Inline(inline_data, len)) => {
+					inline_data.as_ref()[..len].encode_to(&mut output);
+					true
+				},
+				None => false,
+			}),
+			bitmap.as_mut(),
+		);
+		output[bitmap_index..bitmap_index + BITMAP_LENGTH]
+			.copy_from_slice(&bitmap[..BITMAP_LENGTH]);
+		output
+	}
+}
+
+// utils
+
+/// Encode and allocate node type header (type and size), and partial value.
+/// It uses an iterator over encoded partial bytes as input.
+fn partial_from_iterator_encode<I: Iterator<Item = u8>>(
+	partial: I,
+	nibble_count: usize,
+	node_kind: NodeKind,
+) -> Vec<u8> {
+	let mut output = Vec::with_capacity(4 + (nibble_count / nibble_ops::NIBBLE_PER_BYTE));
+	match node_kind {
+		NodeKind::Leaf => NodeHeader::Leaf(nibble_count).encode_to(&mut output),
+		NodeKind::BranchWithValue => NodeHeader::Branch(true, nibble_count).encode_to(&mut output),
+		NodeKind::BranchNoValue => NodeHeader::Branch(false, nibble_count).encode_to(&mut output),
+		NodeKind::HashedValueLeaf =>
+			NodeHeader::HashedValueLeaf(nibble_count).encode_to(&mut output),
+		NodeKind::HashedValueBranch =>
+			NodeHeader::HashedValueBranch(nibble_count).encode_to(&mut output),
+	};
+	output.extend(partial);
+	output
+}
+
+const BITMAP_LENGTH: usize = 2;
+
+/// Radix 16 trie, bitmap encoding implementation,
+/// it contains children mapping information for a branch
+/// (children presence only), it encodes into
+/// a compact bitmap encoding representation.
+pub(crate) struct Bitmap(u16);
+
+impl Bitmap {
+	pub fn decode(data: &[u8]) -> Result<Self, codec::Error> {
+		let value = u16::decode(&mut &data[..])?;
+		if value == 0 {
+			Err("Bitmap without a child.".into())
+		} else {
+			Ok(Bitmap(value))
+		}
+	}
+
+	pub fn value_at(&self, i: usize) -> bool {
+		self.0 & (1u16 << i) != 0
+	}
+
+	pub fn encode<I: Iterator<Item = bool>>(has_children: I, dest: &mut [u8]) {
+		let mut bitmap: u16 = 0;
+		let mut cursor: u16 = 1;
+		for v in has_children {
+			if v {
+				bitmap |= cursor
+			}
+			cursor <<= 1;
+		}
+		dest[0] = (bitmap % 256) as u8;
+		dest[1] = (bitmap / 256) as u8;
+	}
+}
diff --git a/substrate/primitives/trie/src/node_header.rs b/substrate/primitives/trie/src/node_header.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c118ee07b8cbd362b457d4b496861beec435d34d
--- /dev/null
+++ b/substrate/primitives/trie/src/node_header.rs
@@ -0,0 +1,173 @@
+// 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.
+
+//! The node header.
+
+use crate::trie_constants;
+use codec::{Decode, Encode, Input, Output};
+use sp_std::iter::once;
+
+/// A node header
+#[derive(Copy, Clone, PartialEq, Eq, sp_core::RuntimeDebug)]
+pub(crate) enum NodeHeader {
+	Null,
+	// contains wether there is a value and nibble count
+	Branch(bool, usize),
+	// contains nibble count
+	Leaf(usize),
+	// contains nibble count.
+	HashedValueBranch(usize),
+	// contains nibble count.
+	HashedValueLeaf(usize),
+}
+
+impl NodeHeader {
+	pub(crate) fn contains_hash_of_value(&self) -> bool {
+		matches!(self, NodeHeader::HashedValueBranch(_) | NodeHeader::HashedValueLeaf(_))
+	}
+}
+
+/// NodeHeader without content
+pub(crate) enum NodeKind {
+	Leaf,
+	BranchNoValue,
+	BranchWithValue,
+	HashedValueLeaf,
+	HashedValueBranch,
+}
+
+impl Encode for NodeHeader {
+	fn encode_to<T: Output + ?Sized>(&self, output: &mut T) {
+		match self {
+			NodeHeader::Null => output.push_byte(trie_constants::EMPTY_TRIE),
+			NodeHeader::Branch(true, nibble_count) =>
+				encode_size_and_prefix(*nibble_count, trie_constants::BRANCH_WITH_MASK, 2, output),
+			NodeHeader::Branch(false, nibble_count) => encode_size_and_prefix(
+				*nibble_count,
+				trie_constants::BRANCH_WITHOUT_MASK,
+				2,
+				output,
+			),
+			NodeHeader::Leaf(nibble_count) =>
+				encode_size_and_prefix(*nibble_count, trie_constants::LEAF_PREFIX_MASK, 2, output),
+			NodeHeader::HashedValueBranch(nibble_count) => encode_size_and_prefix(
+				*nibble_count,
+				trie_constants::ALT_HASHING_BRANCH_WITH_MASK,
+				4,
+				output,
+			),
+			NodeHeader::HashedValueLeaf(nibble_count) => encode_size_and_prefix(
+				*nibble_count,
+				trie_constants::ALT_HASHING_LEAF_PREFIX_MASK,
+				3,
+				output,
+			),
+		}
+	}
+}
+
+impl codec::EncodeLike for NodeHeader {}
+
+impl Decode for NodeHeader {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		let i = input.read_byte()?;
+		if i == trie_constants::EMPTY_TRIE {
+			return Ok(NodeHeader::Null)
+		}
+		match i & (0b11 << 6) {
+			trie_constants::LEAF_PREFIX_MASK => Ok(NodeHeader::Leaf(decode_size(i, input, 2)?)),
+			trie_constants::BRANCH_WITH_MASK =>
+				Ok(NodeHeader::Branch(true, decode_size(i, input, 2)?)),
+			trie_constants::BRANCH_WITHOUT_MASK =>
+				Ok(NodeHeader::Branch(false, decode_size(i, input, 2)?)),
+			trie_constants::EMPTY_TRIE => {
+				if i & (0b111 << 5) == trie_constants::ALT_HASHING_LEAF_PREFIX_MASK {
+					Ok(NodeHeader::HashedValueLeaf(decode_size(i, input, 3)?))
+				} else if i & (0b1111 << 4) == trie_constants::ALT_HASHING_BRANCH_WITH_MASK {
+					Ok(NodeHeader::HashedValueBranch(decode_size(i, input, 4)?))
+				} else {
+					// do not allow any special encoding
+					Err("Unallowed encoding".into())
+				}
+			},
+			_ => unreachable!(),
+		}
+	}
+}
+
+/// Returns an iterator over encoded bytes for node header and size.
+/// Size encoding allows unlimited, length inefficient, representation, but
+/// is bounded to 16 bit maximum value to avoid possible DOS.
+pub(crate) fn size_and_prefix_iterator(
+	size: usize,
+	prefix: u8,
+	prefix_mask: usize,
+) -> impl Iterator<Item = u8> {
+	let max_value = 255u8 >> prefix_mask;
+	let l1 = sp_std::cmp::min((max_value as usize).saturating_sub(1), size);
+	let (first_byte, mut rem) = if size == l1 {
+		(once(prefix + l1 as u8), 0)
+	} else {
+		(once(prefix + max_value as u8), size - l1)
+	};
+	let next_bytes = move || {
+		if rem > 0 {
+			if rem < 256 {
+				let result = rem - 1;
+				rem = 0;
+				Some(result as u8)
+			} else {
+				rem = rem.saturating_sub(255);
+				Some(255)
+			}
+		} else {
+			None
+		}
+	};
+	first_byte.chain(sp_std::iter::from_fn(next_bytes))
+}
+
+/// Encodes size and prefix to a stream output.
+fn encode_size_and_prefix<W>(size: usize, prefix: u8, prefix_mask: usize, out: &mut W)
+where
+	W: Output + ?Sized,
+{
+	for b in size_and_prefix_iterator(size, prefix, prefix_mask) {
+		out.push_byte(b)
+	}
+}
+
+/// Decode size only from stream input and header byte.
+fn decode_size(
+	first: u8,
+	input: &mut impl Input,
+	prefix_mask: usize,
+) -> Result<usize, codec::Error> {
+	let max_value = 255u8 >> prefix_mask;
+	let mut result = (first & max_value) as usize;
+	if result < max_value as usize {
+		return Ok(result)
+	}
+	result -= 1;
+	loop {
+		let n = input.read_byte()? as usize;
+		if n < 255 {
+			return Ok(result + n + 1)
+		}
+		result += 255;
+	}
+}
diff --git a/substrate/primitives/trie/src/recorder.rs b/substrate/primitives/trie/src/recorder.rs
new file mode 100644
index 0000000000000000000000000000000000000000..728dc836205b57f9d9ce7b8fd8190c0ef8eac681
--- /dev/null
+++ b/substrate/primitives/trie/src/recorder.rs
@@ -0,0 +1,710 @@
+// 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.
+
+//! Trie recorder
+//!
+//! Provides an implementation of the [`TrieRecorder`](trie_db::TrieRecorder) trait. It can be used
+//! to record storage accesses to the state to generate a [`StorageProof`].
+
+use crate::{NodeCodec, StorageProof};
+use codec::Encode;
+use hash_db::Hasher;
+use parking_lot::Mutex;
+use std::{
+	collections::{HashMap, HashSet},
+	marker::PhantomData,
+	mem,
+	ops::DerefMut,
+	sync::{
+		atomic::{AtomicUsize, Ordering},
+		Arc,
+	},
+};
+use trie_db::{RecordedForKey, TrieAccess};
+
+const LOG_TARGET: &str = "trie-recorder";
+
+/// Stores all the information per transaction.
+#[derive(Default)]
+struct Transaction<H> {
+	/// Stores transaction information about [`RecorderInner::recorded_keys`].
+	///
+	/// For each transaction we only store the `storage_root` and the old states per key. `None`
+	/// state means that the key wasn't recorded before.
+	recorded_keys: HashMap<H, HashMap<Arc<[u8]>, Option<RecordedForKey>>>,
+	/// Stores transaction information about [`RecorderInner::accessed_nodes`].
+	///
+	/// For each transaction we only store the hashes of added nodes.
+	accessed_nodes: HashSet<H>,
+}
+
+/// The internals of [`Recorder`].
+struct RecorderInner<H> {
+	/// The keys for that we have recorded the trie nodes and if we have recorded up to the value.
+	///
+	/// Mapping: `StorageRoot -> (Key -> RecordedForKey)`.
+	recorded_keys: HashMap<H, HashMap<Arc<[u8]>, RecordedForKey>>,
+
+	/// Currently active transactions.
+	transactions: Vec<Transaction<H>>,
+
+	/// The encoded nodes we accessed while recording.
+	///
+	/// Mapping: `Hash(Node) -> Node`.
+	accessed_nodes: HashMap<H, Vec<u8>>,
+}
+
+impl<H> Default for RecorderInner<H> {
+	fn default() -> Self {
+		Self {
+			recorded_keys: Default::default(),
+			accessed_nodes: Default::default(),
+			transactions: Vec::new(),
+		}
+	}
+}
+
+/// The trie recorder.
+///
+/// It can be used to record accesses to the trie and then to convert them into a [`StorageProof`].
+pub struct Recorder<H: Hasher> {
+	inner: Arc<Mutex<RecorderInner<H::Out>>>,
+	/// The estimated encoded size of the storage proof this recorder will produce.
+	///
+	/// We store this in an atomic to be able to fetch the value while the `inner` is may locked.
+	encoded_size_estimation: Arc<AtomicUsize>,
+}
+
+impl<H: Hasher> Default for Recorder<H> {
+	fn default() -> Self {
+		Self { inner: Default::default(), encoded_size_estimation: Arc::new(0.into()) }
+	}
+}
+
+impl<H: Hasher> Clone for Recorder<H> {
+	fn clone(&self) -> Self {
+		Self {
+			inner: self.inner.clone(),
+			encoded_size_estimation: self.encoded_size_estimation.clone(),
+		}
+	}
+}
+
+impl<H: Hasher> Recorder<H> {
+	/// Returns the recorder as [`TrieRecorder`](trie_db::TrieRecorder) compatible type.
+	///
+	/// - `storage_root`: The storage root of the trie for which accesses are recorded. This is
+	///   important when recording access to different tries at once (like top and child tries).
+	///
+	/// NOTE: This locks a mutex that stays locked until the return value is dropped.
+	#[inline]
+	pub fn as_trie_recorder(
+		&self,
+		storage_root: H::Out,
+	) -> impl trie_db::TrieRecorder<H::Out> + '_ {
+		TrieRecorder::<H, _> {
+			inner: self.inner.lock(),
+			storage_root,
+			encoded_size_estimation: self.encoded_size_estimation.clone(),
+			_phantom: PhantomData,
+		}
+	}
+
+	/// Drain the recording into a [`StorageProof`].
+	///
+	/// While a recorder can be cloned, all share the same internal state. After calling this
+	/// function, all other instances will have their internal state reset as well.
+	///
+	/// If you don't want to drain the recorded state, use [`Self::to_storage_proof`].
+	///
+	/// Returns the [`StorageProof`].
+	pub fn drain_storage_proof(self) -> StorageProof {
+		let mut recorder = mem::take(&mut *self.inner.lock());
+		StorageProof::new(recorder.accessed_nodes.drain().map(|(_, v)| v))
+	}
+
+	/// Convert the recording to a [`StorageProof`].
+	///
+	/// In contrast to [`Self::drain_storage_proof`] this doesn't consumes and doesn't clears the
+	/// recordings.
+	///
+	/// Returns the [`StorageProof`].
+	pub fn to_storage_proof(&self) -> StorageProof {
+		let recorder = self.inner.lock();
+		StorageProof::new(recorder.accessed_nodes.values().cloned())
+	}
+
+	/// Returns the estimated encoded size of the proof.
+	///
+	/// The estimation is based on all the nodes that were accessed until now while
+	/// accessing the trie.
+	pub fn estimate_encoded_size(&self) -> usize {
+		self.encoded_size_estimation.load(Ordering::Relaxed)
+	}
+
+	/// Reset the state.
+	///
+	/// This discards all recorded data.
+	pub fn reset(&self) {
+		mem::take(&mut *self.inner.lock());
+		self.encoded_size_estimation.store(0, Ordering::Relaxed);
+	}
+
+	/// Start a new transaction.
+	pub fn start_transaction(&self) {
+		let mut inner = self.inner.lock();
+		inner.transactions.push(Default::default());
+	}
+
+	/// Rollback the latest transaction.
+	///
+	/// Returns an error if there wasn't any active transaction.
+	pub fn rollback_transaction(&self) -> Result<(), ()> {
+		let mut inner = self.inner.lock();
+
+		// We locked `inner` and can just update the encoded size locally and then store it back to
+		// the atomic.
+		let mut new_encoded_size_estimation = self.encoded_size_estimation.load(Ordering::Relaxed);
+		let transaction = inner.transactions.pop().ok_or(())?;
+
+		transaction.accessed_nodes.into_iter().for_each(|n| {
+			if let Some(old) = inner.accessed_nodes.remove(&n) {
+				new_encoded_size_estimation =
+					new_encoded_size_estimation.saturating_sub(old.encoded_size());
+			}
+		});
+
+		transaction.recorded_keys.into_iter().for_each(|(storage_root, keys)| {
+			keys.into_iter().for_each(|(k, old_state)| {
+				if let Some(state) = old_state {
+					inner.recorded_keys.entry(storage_root).or_default().insert(k, state);
+				} else {
+					inner.recorded_keys.entry(storage_root).or_default().remove(&k);
+				}
+			});
+		});
+
+		self.encoded_size_estimation
+			.store(new_encoded_size_estimation, Ordering::Relaxed);
+
+		Ok(())
+	}
+
+	/// Commit the latest transaction.
+	///
+	/// Returns an error if there wasn't any active transaction.
+	pub fn commit_transaction(&self) -> Result<(), ()> {
+		let mut inner = self.inner.lock();
+
+		let transaction = inner.transactions.pop().ok_or(())?;
+
+		if let Some(parent_transaction) = inner.transactions.last_mut() {
+			parent_transaction.accessed_nodes.extend(transaction.accessed_nodes);
+
+			transaction.recorded_keys.into_iter().for_each(|(storage_root, keys)| {
+				keys.into_iter().for_each(|(k, old_state)| {
+					parent_transaction
+						.recorded_keys
+						.entry(storage_root)
+						.or_default()
+						.entry(k)
+						.or_insert(old_state);
+				})
+			});
+		}
+
+		Ok(())
+	}
+}
+
+/// The [`TrieRecorder`](trie_db::TrieRecorder) implementation.
+struct TrieRecorder<H: Hasher, I> {
+	inner: I,
+	storage_root: H::Out,
+	encoded_size_estimation: Arc<AtomicUsize>,
+	_phantom: PhantomData<H>,
+}
+
+impl<H: Hasher, I: DerefMut<Target = RecorderInner<H::Out>>> TrieRecorder<H, I> {
+	/// Update the recorded keys entry for the given `full_key`.
+	fn update_recorded_keys(&mut self, full_key: &[u8], access: RecordedForKey) {
+		let inner = self.inner.deref_mut();
+
+		let entry =
+			inner.recorded_keys.entry(self.storage_root).or_default().entry(full_key.into());
+
+		let key = entry.key().clone();
+
+		// We don't need to update the record if we only accessed the `Hash` for the given
+		// `full_key`. Only `Value` access can be an upgrade from `Hash`.
+		let entry = if matches!(access, RecordedForKey::Value) {
+			entry.and_modify(|e| {
+				if let Some(tx) = inner.transactions.last_mut() {
+					// Store the previous state only once per transaction.
+					tx.recorded_keys
+						.entry(self.storage_root)
+						.or_default()
+						.entry(key.clone())
+						.or_insert(Some(*e));
+				}
+
+				*e = access;
+			})
+		} else {
+			entry
+		};
+
+		entry.or_insert_with(|| {
+			if let Some(tx) = inner.transactions.last_mut() {
+				// The key wasn't yet recorded, so there isn't any old state.
+				tx.recorded_keys
+					.entry(self.storage_root)
+					.or_default()
+					.entry(key)
+					.or_insert(None);
+			}
+
+			access
+		});
+	}
+}
+
+impl<H: Hasher, I: DerefMut<Target = RecorderInner<H::Out>>> trie_db::TrieRecorder<H::Out>
+	for TrieRecorder<H, I>
+{
+	fn record(&mut self, access: TrieAccess<H::Out>) {
+		let mut encoded_size_update = 0;
+
+		match access {
+			TrieAccess::NodeOwned { hash, node_owned } => {
+				tracing::trace!(
+					target: LOG_TARGET,
+					hash = ?hash,
+					"Recording node",
+				);
+
+				let inner = self.inner.deref_mut();
+
+				inner.accessed_nodes.entry(hash).or_insert_with(|| {
+					let node = node_owned.to_encoded::<NodeCodec<H>>();
+
+					encoded_size_update += node.encoded_size();
+
+					if let Some(tx) = inner.transactions.last_mut() {
+						tx.accessed_nodes.insert(hash);
+					}
+
+					node
+				});
+			},
+			TrieAccess::EncodedNode { hash, encoded_node } => {
+				tracing::trace!(
+					target: LOG_TARGET,
+					hash = ?hash,
+					"Recording node",
+				);
+
+				let inner = self.inner.deref_mut();
+
+				inner.accessed_nodes.entry(hash).or_insert_with(|| {
+					let node = encoded_node.into_owned();
+
+					encoded_size_update += node.encoded_size();
+
+					if let Some(tx) = inner.transactions.last_mut() {
+						tx.accessed_nodes.insert(hash);
+					}
+
+					node
+				});
+			},
+			TrieAccess::Value { hash, value, full_key } => {
+				tracing::trace!(
+					target: LOG_TARGET,
+					hash = ?hash,
+					key = ?sp_core::hexdisplay::HexDisplay::from(&full_key),
+					"Recording value",
+				);
+
+				let inner = self.inner.deref_mut();
+
+				inner.accessed_nodes.entry(hash).or_insert_with(|| {
+					let value = value.into_owned();
+
+					encoded_size_update += value.encoded_size();
+
+					if let Some(tx) = inner.transactions.last_mut() {
+						tx.accessed_nodes.insert(hash);
+					}
+
+					value
+				});
+
+				self.update_recorded_keys(full_key, RecordedForKey::Value);
+			},
+			TrieAccess::Hash { full_key } => {
+				tracing::trace!(
+					target: LOG_TARGET,
+					key = ?sp_core::hexdisplay::HexDisplay::from(&full_key),
+					"Recorded hash access for key",
+				);
+
+				// We don't need to update the `encoded_size_update` as the hash was already
+				// accounted for by the recorded node that holds the hash.
+				self.update_recorded_keys(full_key, RecordedForKey::Hash);
+			},
+			TrieAccess::NonExisting { full_key } => {
+				tracing::trace!(
+					target: LOG_TARGET,
+					key = ?sp_core::hexdisplay::HexDisplay::from(&full_key),
+					"Recorded non-existing value access for key",
+				);
+
+				// Non-existing access means we recorded all trie nodes up to the value.
+				// Not the actual value, as it doesn't exist, but all trie nodes to know
+				// that the value doesn't exist in the trie.
+				self.update_recorded_keys(full_key, RecordedForKey::Value);
+			},
+		};
+
+		self.encoded_size_estimation.fetch_add(encoded_size_update, Ordering::Relaxed);
+	}
+
+	fn trie_nodes_recorded_for_key(&self, key: &[u8]) -> RecordedForKey {
+		self.inner
+			.recorded_keys
+			.get(&self.storage_root)
+			.and_then(|k| k.get(key).copied())
+			.unwrap_or(RecordedForKey::None)
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use trie_db::{Trie, TrieDBBuilder, TrieDBMutBuilder, TrieHash, TrieMut, TrieRecorder};
+
+	type MemoryDB = crate::MemoryDB<sp_core::Blake2Hasher>;
+	type Layout = crate::LayoutV1<sp_core::Blake2Hasher>;
+	type Recorder = super::Recorder<sp_core::Blake2Hasher>;
+
+	const TEST_DATA: &[(&[u8], &[u8])] =
+		&[(b"key1", &[1; 64]), (b"key2", &[2; 64]), (b"key3", &[3; 64]), (b"key4", &[4; 64])];
+
+	fn create_trie() -> (MemoryDB, TrieHash<Layout>) {
+		let mut db = MemoryDB::default();
+		let mut root = Default::default();
+
+		{
+			let mut trie = TrieDBMutBuilder::<Layout>::new(&mut db, &mut root).build();
+			for (k, v) in TEST_DATA {
+				trie.insert(k, v).expect("Inserts data");
+			}
+		}
+
+		(db, root)
+	}
+
+	#[test]
+	fn recorder_works() {
+		let (db, root) = create_trie();
+
+		let recorder = Recorder::default();
+
+		{
+			let mut trie_recorder = recorder.as_trie_recorder(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+				.with_recorder(&mut trie_recorder)
+				.build();
+			assert_eq!(TEST_DATA[0].1.to_vec(), trie.get(TEST_DATA[0].0).unwrap().unwrap());
+		}
+
+		let storage_proof = recorder.drain_storage_proof();
+		let memory_db: MemoryDB = storage_proof.into_memory_db();
+
+		// Check that we recorded the required data
+		let trie = TrieDBBuilder::<Layout>::new(&memory_db, &root).build();
+		assert_eq!(TEST_DATA[0].1.to_vec(), trie.get(TEST_DATA[0].0).unwrap().unwrap());
+	}
+
+	#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+	struct RecorderStats {
+		accessed_nodes: usize,
+		recorded_keys: usize,
+		estimated_size: usize,
+	}
+
+	impl RecorderStats {
+		fn extract(recorder: &Recorder) -> Self {
+			let inner = recorder.inner.lock();
+
+			let recorded_keys =
+				inner.recorded_keys.iter().flat_map(|(_, keys)| keys.keys()).count();
+
+			Self {
+				recorded_keys,
+				accessed_nodes: inner.accessed_nodes.len(),
+				estimated_size: recorder.estimate_encoded_size(),
+			}
+		}
+	}
+
+	#[test]
+	fn recorder_transactions_rollback_work() {
+		let (db, root) = create_trie();
+
+		let recorder = Recorder::default();
+		let mut stats = vec![RecorderStats::default()];
+
+		for i in 0..4 {
+			recorder.start_transaction();
+			{
+				let mut trie_recorder = recorder.as_trie_recorder(root);
+				let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+					.with_recorder(&mut trie_recorder)
+					.build();
+
+				assert_eq!(TEST_DATA[i].1.to_vec(), trie.get(TEST_DATA[i].0).unwrap().unwrap());
+			}
+			stats.push(RecorderStats::extract(&recorder));
+		}
+
+		assert_eq!(4, recorder.inner.lock().transactions.len());
+
+		for i in 0..5 {
+			assert_eq!(stats[4 - i], RecorderStats::extract(&recorder));
+
+			let storage_proof = recorder.to_storage_proof();
+			let memory_db: MemoryDB = storage_proof.into_memory_db();
+
+			// Check that we recorded the required data
+			let trie = TrieDBBuilder::<Layout>::new(&memory_db, &root).build();
+
+			// Check that the required data is still present.
+			for a in 0..4 {
+				if a < 4 - i {
+					assert_eq!(TEST_DATA[a].1.to_vec(), trie.get(TEST_DATA[a].0).unwrap().unwrap());
+				} else {
+					// All the data that we already rolled back, should be gone!
+					assert!(trie.get(TEST_DATA[a].0).is_err());
+				}
+			}
+
+			if i < 4 {
+				recorder.rollback_transaction().unwrap();
+			}
+		}
+
+		assert_eq!(0, recorder.inner.lock().transactions.len());
+	}
+
+	#[test]
+	fn recorder_transactions_commit_work() {
+		let (db, root) = create_trie();
+
+		let recorder = Recorder::default();
+
+		for i in 0..4 {
+			recorder.start_transaction();
+			{
+				let mut trie_recorder = recorder.as_trie_recorder(root);
+				let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+					.with_recorder(&mut trie_recorder)
+					.build();
+
+				assert_eq!(TEST_DATA[i].1.to_vec(), trie.get(TEST_DATA[i].0).unwrap().unwrap());
+			}
+		}
+
+		let stats = RecorderStats::extract(&recorder);
+		assert_eq!(4, recorder.inner.lock().transactions.len());
+
+		for _ in 0..4 {
+			recorder.commit_transaction().unwrap();
+		}
+		assert_eq!(0, recorder.inner.lock().transactions.len());
+		assert_eq!(stats, RecorderStats::extract(&recorder));
+
+		let storage_proof = recorder.to_storage_proof();
+		let memory_db: MemoryDB = storage_proof.into_memory_db();
+
+		// Check that we recorded the required data
+		let trie = TrieDBBuilder::<Layout>::new(&memory_db, &root).build();
+
+		// Check that the required data is still present.
+		for i in 0..4 {
+			assert_eq!(TEST_DATA[i].1.to_vec(), trie.get(TEST_DATA[i].0).unwrap().unwrap());
+		}
+	}
+
+	#[test]
+	fn recorder_transactions_commit_and_rollback_work() {
+		let (db, root) = create_trie();
+
+		let recorder = Recorder::default();
+
+		for i in 0..2 {
+			recorder.start_transaction();
+			{
+				let mut trie_recorder = recorder.as_trie_recorder(root);
+				let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+					.with_recorder(&mut trie_recorder)
+					.build();
+
+				assert_eq!(TEST_DATA[i].1.to_vec(), trie.get(TEST_DATA[i].0).unwrap().unwrap());
+			}
+		}
+
+		recorder.rollback_transaction().unwrap();
+
+		for i in 2..4 {
+			recorder.start_transaction();
+			{
+				let mut trie_recorder = recorder.as_trie_recorder(root);
+				let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+					.with_recorder(&mut trie_recorder)
+					.build();
+
+				assert_eq!(TEST_DATA[i].1.to_vec(), trie.get(TEST_DATA[i].0).unwrap().unwrap());
+			}
+		}
+
+		recorder.rollback_transaction().unwrap();
+
+		assert_eq!(2, recorder.inner.lock().transactions.len());
+
+		for _ in 0..2 {
+			recorder.commit_transaction().unwrap();
+		}
+
+		assert_eq!(0, recorder.inner.lock().transactions.len());
+
+		let storage_proof = recorder.to_storage_proof();
+		let memory_db: MemoryDB = storage_proof.into_memory_db();
+
+		// Check that we recorded the required data
+		let trie = TrieDBBuilder::<Layout>::new(&memory_db, &root).build();
+
+		// Check that the required data is still present.
+		for i in 0..4 {
+			if i % 2 == 0 {
+				assert_eq!(TEST_DATA[i].1.to_vec(), trie.get(TEST_DATA[i].0).unwrap().unwrap());
+			} else {
+				assert!(trie.get(TEST_DATA[i].0).is_err());
+			}
+		}
+	}
+
+	#[test]
+	fn recorder_transaction_accessed_keys_works() {
+		let key = TEST_DATA[0].0;
+		let (db, root) = create_trie();
+
+		let recorder = Recorder::default();
+
+		{
+			let trie_recorder = recorder.as_trie_recorder(root);
+			assert!(matches!(trie_recorder.trie_nodes_recorded_for_key(key), RecordedForKey::None));
+		}
+
+		recorder.start_transaction();
+		{
+			let mut trie_recorder = recorder.as_trie_recorder(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+				.with_recorder(&mut trie_recorder)
+				.build();
+
+			assert_eq!(
+				sp_core::Blake2Hasher::hash(TEST_DATA[0].1),
+				trie.get_hash(TEST_DATA[0].0).unwrap().unwrap()
+			);
+			assert!(matches!(trie_recorder.trie_nodes_recorded_for_key(key), RecordedForKey::Hash));
+		}
+
+		recorder.start_transaction();
+		{
+			let mut trie_recorder = recorder.as_trie_recorder(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+				.with_recorder(&mut trie_recorder)
+				.build();
+
+			assert_eq!(TEST_DATA[0].1.to_vec(), trie.get(TEST_DATA[0].0).unwrap().unwrap());
+			assert!(matches!(
+				trie_recorder.trie_nodes_recorded_for_key(key),
+				RecordedForKey::Value,
+			));
+		}
+
+		recorder.rollback_transaction().unwrap();
+		{
+			let trie_recorder = recorder.as_trie_recorder(root);
+			assert!(matches!(trie_recorder.trie_nodes_recorded_for_key(key), RecordedForKey::Hash));
+		}
+
+		recorder.rollback_transaction().unwrap();
+		{
+			let trie_recorder = recorder.as_trie_recorder(root);
+			assert!(matches!(trie_recorder.trie_nodes_recorded_for_key(key), RecordedForKey::None));
+		}
+
+		recorder.start_transaction();
+		{
+			let mut trie_recorder = recorder.as_trie_recorder(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+				.with_recorder(&mut trie_recorder)
+				.build();
+
+			assert_eq!(TEST_DATA[0].1.to_vec(), trie.get(TEST_DATA[0].0).unwrap().unwrap());
+			assert!(matches!(
+				trie_recorder.trie_nodes_recorded_for_key(key),
+				RecordedForKey::Value,
+			));
+		}
+
+		recorder.start_transaction();
+		{
+			let mut trie_recorder = recorder.as_trie_recorder(root);
+			let trie = TrieDBBuilder::<Layout>::new(&db, &root)
+				.with_recorder(&mut trie_recorder)
+				.build();
+
+			assert_eq!(
+				sp_core::Blake2Hasher::hash(TEST_DATA[0].1),
+				trie.get_hash(TEST_DATA[0].0).unwrap().unwrap()
+			);
+			assert!(matches!(
+				trie_recorder.trie_nodes_recorded_for_key(key),
+				RecordedForKey::Value
+			));
+		}
+
+		recorder.rollback_transaction().unwrap();
+		{
+			let trie_recorder = recorder.as_trie_recorder(root);
+			assert!(matches!(
+				trie_recorder.trie_nodes_recorded_for_key(key),
+				RecordedForKey::Value
+			));
+		}
+
+		recorder.rollback_transaction().unwrap();
+		{
+			let trie_recorder = recorder.as_trie_recorder(root);
+			assert!(matches!(trie_recorder.trie_nodes_recorded_for_key(key), RecordedForKey::None));
+		}
+	}
+}
diff --git a/substrate/primitives/trie/src/storage_proof.rs b/substrate/primitives/trie/src/storage_proof.rs
new file mode 100644
index 0000000000000000000000000000000000000000..6c871d73b043a997820b9a5645e459d7739dfc48
--- /dev/null
+++ b/substrate/primitives/trie/src/storage_proof.rs
@@ -0,0 +1,202 @@
+// 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 codec::{Decode, Encode};
+use hash_db::{HashDB, Hasher};
+use scale_info::TypeInfo;
+use sp_std::{
+	collections::btree_set::BTreeSet,
+	iter::{DoubleEndedIterator, IntoIterator},
+	vec::Vec,
+};
+// Note that `LayoutV1` usage here (proof compaction) is compatible
+// with `LayoutV0`.
+use crate::LayoutV1 as Layout;
+
+/// A proof that some set of key-value pairs are included in the storage trie. The proof contains
+/// the storage values so that the partial storage backend can be reconstructed by a verifier that
+/// does not already have access to the key-value pairs.
+///
+/// The proof consists of the set of serialized nodes in the storage trie accessed when looking up
+/// the keys covered by the proof. Verifying the proof requires constructing the partial trie from
+/// the serialized nodes and performing the key lookups.
+#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode, TypeInfo)]
+pub struct StorageProof {
+	trie_nodes: BTreeSet<Vec<u8>>,
+}
+
+impl StorageProof {
+	/// Constructs a storage proof from a subset of encoded trie nodes in a storage backend.
+	pub fn new(trie_nodes: impl IntoIterator<Item = Vec<u8>>) -> Self {
+		StorageProof { trie_nodes: BTreeSet::from_iter(trie_nodes) }
+	}
+
+	/// Returns a new empty proof.
+	///
+	/// An empty proof is capable of only proving trivial statements (ie. that an empty set of
+	/// key-value pairs exist in storage).
+	pub fn empty() -> Self {
+		StorageProof { trie_nodes: BTreeSet::new() }
+	}
+
+	/// Returns whether this is an empty proof.
+	pub fn is_empty(&self) -> bool {
+		self.trie_nodes.is_empty()
+	}
+
+	/// Convert into an iterator over encoded trie nodes in lexicographical order constructed
+	/// from the proof.
+	pub fn into_iter_nodes(self) -> impl Sized + DoubleEndedIterator<Item = Vec<u8>> {
+		self.trie_nodes.into_iter()
+	}
+
+	/// Create an iterator over encoded trie nodes in lexicographical order constructed
+	/// from the proof.
+	pub fn iter_nodes(&self) -> impl Sized + DoubleEndedIterator<Item = &Vec<u8>> {
+		self.trie_nodes.iter()
+	}
+
+	/// Convert into plain node vector.
+	pub fn into_nodes(self) -> BTreeSet<Vec<u8>> {
+		self.trie_nodes
+	}
+
+	/// Creates a [`MemoryDB`](crate::MemoryDB) from `Self`.
+	pub fn into_memory_db<H: Hasher>(self) -> crate::MemoryDB<H> {
+		self.into()
+	}
+
+	/// Creates a [`MemoryDB`](crate::MemoryDB) from `Self` reference.
+	pub fn to_memory_db<H: Hasher>(&self) -> crate::MemoryDB<H> {
+		self.into()
+	}
+
+	/// Merges multiple storage proofs covering potentially different sets of keys into one proof
+	/// covering all keys. The merged proof output may be smaller than the aggregate size of the
+	/// input proofs due to deduplication of trie nodes.
+	pub fn merge(proofs: impl IntoIterator<Item = Self>) -> Self {
+		let trie_nodes = proofs
+			.into_iter()
+			.flat_map(|proof| proof.into_iter_nodes())
+			.collect::<BTreeSet<_>>()
+			.into_iter()
+			.collect();
+
+		Self { trie_nodes }
+	}
+
+	/// Encode as a compact proof with default trie layout.
+	pub fn into_compact_proof<H: Hasher>(
+		self,
+		root: H::Out,
+	) -> Result<CompactProof, crate::CompactProofError<H::Out, crate::Error<H::Out>>> {
+		let db = self.into_memory_db();
+		crate::encode_compact::<Layout<H>, crate::MemoryDB<H>>(&db, &root)
+	}
+
+	/// Encode as a compact proof with default trie layout.
+	pub fn to_compact_proof<H: Hasher>(
+		&self,
+		root: H::Out,
+	) -> Result<CompactProof, crate::CompactProofError<H::Out, crate::Error<H::Out>>> {
+		let db = self.to_memory_db();
+		crate::encode_compact::<Layout<H>, crate::MemoryDB<H>>(&db, &root)
+	}
+
+	/// Returns the estimated encoded size of the compact proof.
+	///
+	/// Running this operation is a slow operation (build the whole compact proof) and should only
+	/// be in non sensitive path.
+	///
+	/// Return `None` on error.
+	pub fn encoded_compact_size<H: Hasher>(self, root: H::Out) -> Option<usize> {
+		let compact_proof = self.into_compact_proof::<H>(root);
+		compact_proof.ok().map(|p| p.encoded_size())
+	}
+}
+
+impl<H: Hasher> From<StorageProof> for crate::MemoryDB<H> {
+	fn from(proof: StorageProof) -> Self {
+		From::from(&proof)
+	}
+}
+
+impl<H: Hasher> From<&StorageProof> for crate::MemoryDB<H> {
+	fn from(proof: &StorageProof) -> Self {
+		let mut db = crate::MemoryDB::default();
+		proof.iter_nodes().for_each(|n| {
+			db.insert(crate::EMPTY_PREFIX, &n);
+		});
+		db
+	}
+}
+
+/// Storage proof in compact form.
+#[derive(Debug, PartialEq, Eq, Clone, Encode, Decode, TypeInfo)]
+pub struct CompactProof {
+	pub encoded_nodes: Vec<Vec<u8>>,
+}
+
+impl CompactProof {
+	/// Return an iterator on the compact encoded nodes.
+	pub fn iter_compact_encoded_nodes(&self) -> impl Iterator<Item = &[u8]> {
+		self.encoded_nodes.iter().map(Vec::as_slice)
+	}
+
+	/// Decode to a full storage_proof.
+	pub fn to_storage_proof<H: Hasher>(
+		&self,
+		expected_root: Option<&H::Out>,
+	) -> Result<(StorageProof, H::Out), crate::CompactProofError<H::Out, crate::Error<H::Out>>> {
+		let mut db = crate::MemoryDB::<H>::new(&[]);
+		let root = crate::decode_compact::<Layout<H>, _, _>(
+			&mut db,
+			self.iter_compact_encoded_nodes(),
+			expected_root,
+		)?;
+		Ok((
+			StorageProof::new(db.drain().into_iter().filter_map(|kv| {
+				if (kv.1).1 > 0 {
+					Some((kv.1).0)
+				} else {
+					None
+				}
+			})),
+			root,
+		))
+	}
+
+	/// Convert self into a [`MemoryDB`](crate::MemoryDB).
+	///
+	/// `expected_root` is the expected root of this compact proof.
+	///
+	/// Returns the memory db and the root of the trie.
+	pub fn to_memory_db<H: Hasher>(
+		&self,
+		expected_root: Option<&H::Out>,
+	) -> Result<(crate::MemoryDB<H>, H::Out), crate::CompactProofError<H::Out, crate::Error<H::Out>>>
+	{
+		let mut db = crate::MemoryDB::<H>::new(&[]);
+		let root = crate::decode_compact::<Layout<H>, _, _>(
+			&mut db,
+			self.iter_compact_encoded_nodes(),
+			expected_root,
+		)?;
+
+		Ok((db, root))
+	}
+}
diff --git a/substrate/primitives/trie/src/trie_codec.rs b/substrate/primitives/trie/src/trie_codec.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f29e009c4761e8503b57fde00bb2af6cb3b3330d
--- /dev/null
+++ b/substrate/primitives/trie/src/trie_codec.rs
@@ -0,0 +1,207 @@
+// 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.
+
+//! Compact proof support.
+//!
+//! This uses compact proof from trie crate and extends
+//! it to substrate specific layout and child trie system.
+
+use crate::{CompactProof, HashDBT, TrieConfiguration, TrieHash, EMPTY_PREFIX};
+use sp_std::{boxed::Box, vec::Vec};
+use trie_db::{CError, Trie};
+
+/// Error for trie node decoding.
+#[derive(Debug)]
+#[cfg_attr(feature = "std", derive(thiserror::Error))]
+pub enum Error<H, CodecError> {
+	#[cfg_attr(feature = "std", error("Invalid root {0:x?}, expected {1:x?}"))]
+	RootMismatch(H, H),
+	#[cfg_attr(feature = "std", error("Missing nodes in the proof"))]
+	IncompleteProof,
+	#[cfg_attr(feature = "std", error("Child node content with no root in proof"))]
+	ExtraneousChildNode,
+	#[cfg_attr(feature = "std", error("Proof of child trie {0:x?} not in parent proof"))]
+	ExtraneousChildProof(H),
+	#[cfg_attr(feature = "std", error("Invalid root {0:x?}, expected {1:x?}"))]
+	InvalidChildRoot(Vec<u8>, Vec<u8>),
+	#[cfg_attr(feature = "std", error("Trie error: {0:?}"))]
+	TrieError(Box<trie_db::TrieError<H, CodecError>>),
+}
+
+impl<H, CodecError> From<Box<trie_db::TrieError<H, CodecError>>> for Error<H, CodecError> {
+	fn from(error: Box<trie_db::TrieError<H, CodecError>>) -> Self {
+		Error::TrieError(error)
+	}
+}
+
+/// Decode a compact proof.
+///
+/// Takes as input a destination `db` for decoded node and `encoded`
+/// an iterator of compact encoded nodes.
+///
+/// Child trie are decoded in order of child trie root present
+/// in the top trie.
+pub fn decode_compact<'a, L, DB, I>(
+	db: &mut DB,
+	encoded: I,
+	expected_root: Option<&TrieHash<L>>,
+) -> Result<TrieHash<L>, Error<TrieHash<L>, CError<L>>>
+where
+	L: TrieConfiguration,
+	DB: HashDBT<L::Hash, trie_db::DBValue> + hash_db::HashDBRef<L::Hash, trie_db::DBValue>,
+	I: IntoIterator<Item = &'a [u8]>,
+{
+	let mut nodes_iter = encoded.into_iter();
+	let (top_root, _nb_used) = trie_db::decode_compact_from_iter::<L, _, _>(db, &mut nodes_iter)?;
+
+	// Only check root if expected root is passed as argument.
+	if let Some(expected_root) = expected_root {
+		if expected_root != &top_root {
+			return Err(Error::RootMismatch(top_root, *expected_root))
+		}
+	}
+
+	let mut child_tries = Vec::new();
+	{
+		// fetch child trie roots
+		let trie = crate::TrieDBBuilder::<L>::new(db, &top_root).build();
+
+		let mut iter = trie.iter()?;
+
+		let childtrie_roots = sp_core::storage::well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX;
+		if iter.seek(childtrie_roots).is_ok() {
+			loop {
+				match iter.next() {
+					Some(Ok((key, value))) if key.starts_with(childtrie_roots) => {
+						// we expect all default child trie root to be correctly encoded.
+						// see other child trie functions.
+						let mut root = TrieHash::<L>::default();
+						// still in a proof so prevent panic
+						if root.as_mut().len() != value.as_slice().len() {
+							return Err(Error::InvalidChildRoot(key, value))
+						}
+						root.as_mut().copy_from_slice(value.as_ref());
+						child_tries.push(root);
+					},
+					// allow incomplete database error: we only
+					// require access to data in the proof.
+					Some(Err(error)) => match *error {
+						trie_db::TrieError::IncompleteDatabase(..) => (),
+						e => return Err(Box::new(e).into()),
+					},
+					_ => break,
+				}
+			}
+		}
+	}
+
+	if !HashDBT::<L::Hash, _>::contains(db, &top_root, EMPTY_PREFIX) {
+		return Err(Error::IncompleteProof)
+	}
+
+	let mut previous_extracted_child_trie = None;
+	let mut nodes_iter = nodes_iter.peekable();
+	for child_root in child_tries.into_iter() {
+		if previous_extracted_child_trie.is_none() && nodes_iter.peek().is_some() {
+			let (top_root, _) = trie_db::decode_compact_from_iter::<L, _, _>(db, &mut nodes_iter)?;
+			previous_extracted_child_trie = Some(top_root);
+		}
+
+		// we do not early exit on root mismatch but try the
+		// other read from proof (some child root may be
+		// in proof without actual child content).
+		if Some(child_root) == previous_extracted_child_trie {
+			previous_extracted_child_trie = None;
+		}
+	}
+
+	if let Some(child_root) = previous_extracted_child_trie {
+		// A child root was read from proof but is not present
+		// in top trie.
+		return Err(Error::ExtraneousChildProof(child_root))
+	}
+
+	if nodes_iter.next().is_some() {
+		return Err(Error::ExtraneousChildNode)
+	}
+
+	Ok(top_root)
+}
+
+/// Encode a compact proof.
+///
+/// Takes as input all full encoded node from the proof, and
+/// the root.
+/// Then parse all child trie root and compress main trie content first
+/// then all child trie contents.
+/// Child trie are ordered by the order of their roots in the top trie.
+pub fn encode_compact<L, DB>(
+	partial_db: &DB,
+	root: &TrieHash<L>,
+) -> Result<CompactProof, Error<TrieHash<L>, CError<L>>>
+where
+	L: TrieConfiguration,
+	DB: HashDBT<L::Hash, trie_db::DBValue> + hash_db::HashDBRef<L::Hash, trie_db::DBValue>,
+{
+	let mut child_tries = Vec::new();
+	let mut compact_proof = {
+		let trie = crate::TrieDBBuilder::<L>::new(partial_db, root).build();
+
+		let mut iter = trie.iter()?;
+
+		let childtrie_roots = sp_core::storage::well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX;
+		if iter.seek(childtrie_roots).is_ok() {
+			loop {
+				match iter.next() {
+					Some(Ok((key, value))) if key.starts_with(childtrie_roots) => {
+						let mut root = TrieHash::<L>::default();
+						if root.as_mut().len() != value.as_slice().len() {
+							// some child trie root in top trie are not an encoded hash.
+							return Err(Error::InvalidChildRoot(key.to_vec(), value.to_vec()))
+						}
+						root.as_mut().copy_from_slice(value.as_ref());
+						child_tries.push(root);
+					},
+					// allow incomplete database error: we only
+					// require access to data in the proof.
+					Some(Err(error)) => match *error {
+						trie_db::TrieError::IncompleteDatabase(..) => (),
+						e => return Err(Box::new(e).into()),
+					},
+					_ => break,
+				}
+			}
+		}
+
+		trie_db::encode_compact::<L>(&trie)?
+	};
+
+	for child_root in child_tries {
+		if !HashDBT::<L::Hash, _>::contains(partial_db, &child_root, EMPTY_PREFIX) {
+			// child proof are allowed to be missing (unused root can be included
+			// due to trie structure modification).
+			continue
+		}
+
+		let trie = crate::TrieDBBuilder::<L>::new(partial_db, &child_root).build();
+		let child_proof = trie_db::encode_compact::<L>(&trie)?;
+
+		compact_proof.extend(child_proof);
+	}
+
+	Ok(CompactProof { encoded_nodes: compact_proof })
+}
diff --git a/substrate/primitives/trie/src/trie_stream.rs b/substrate/primitives/trie/src/trie_stream.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f57b80f978ffb1484b2301fdb612cf6b805c4321
--- /dev/null
+++ b/substrate/primitives/trie/src/trie_stream.rs
@@ -0,0 +1,147 @@
+// 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.
+
+//! `TrieStream` implementation for Substrate's trie format.
+
+use crate::{
+	node_header::{size_and_prefix_iterator, NodeKind},
+	trie_constants,
+};
+use codec::{Compact, Encode};
+use hash_db::Hasher;
+use sp_std::vec::Vec;
+use trie_root;
+
+/// Codec-flavored TrieStream.
+#[derive(Default, Clone)]
+pub struct TrieStream {
+	/// Current node buffer.
+	buffer: Vec<u8>,
+}
+
+impl TrieStream {
+	// useful for debugging but not used otherwise
+	pub fn as_raw(&self) -> &[u8] {
+		&self.buffer
+	}
+}
+
+fn branch_node_bit_mask(has_children: impl Iterator<Item = bool>) -> (u8, u8) {
+	let mut bitmap: u16 = 0;
+	let mut cursor: u16 = 1;
+	for v in has_children {
+		if v {
+			bitmap |= cursor
+		}
+		cursor <<= 1;
+	}
+	((bitmap % 256) as u8, (bitmap / 256) as u8)
+}
+
+/// Create a leaf/branch node, encoding a number of nibbles.
+fn fuse_nibbles_node(nibbles: &[u8], kind: NodeKind) -> impl Iterator<Item = u8> + '_ {
+	let size = nibbles.len();
+	let iter_start = match kind {
+		NodeKind::Leaf => size_and_prefix_iterator(size, trie_constants::LEAF_PREFIX_MASK, 2),
+		NodeKind::BranchNoValue =>
+			size_and_prefix_iterator(size, trie_constants::BRANCH_WITHOUT_MASK, 2),
+		NodeKind::BranchWithValue =>
+			size_and_prefix_iterator(size, trie_constants::BRANCH_WITH_MASK, 2),
+		NodeKind::HashedValueLeaf =>
+			size_and_prefix_iterator(size, trie_constants::ALT_HASHING_LEAF_PREFIX_MASK, 3),
+		NodeKind::HashedValueBranch =>
+			size_and_prefix_iterator(size, trie_constants::ALT_HASHING_BRANCH_WITH_MASK, 4),
+	};
+	iter_start
+		.chain(if nibbles.len() % 2 == 1 { Some(nibbles[0]) } else { None })
+		.chain(nibbles[nibbles.len() % 2..].chunks(2).map(|ch| ch[0] << 4 | ch[1]))
+}
+
+use trie_root::Value as TrieStreamValue;
+impl trie_root::TrieStream for TrieStream {
+	fn new() -> Self {
+		Self { buffer: Vec::new() }
+	}
+
+	fn append_empty_data(&mut self) {
+		self.buffer.push(trie_constants::EMPTY_TRIE);
+	}
+
+	fn append_leaf(&mut self, key: &[u8], value: TrieStreamValue) {
+		let kind = match &value {
+			TrieStreamValue::Inline(..) => NodeKind::Leaf,
+			TrieStreamValue::Node(..) => NodeKind::HashedValueLeaf,
+		};
+		self.buffer.extend(fuse_nibbles_node(key, kind));
+		match &value {
+			TrieStreamValue::Inline(value) => {
+				Compact(value.len() as u32).encode_to(&mut self.buffer);
+				self.buffer.extend_from_slice(value);
+			},
+			TrieStreamValue::Node(hash) => {
+				self.buffer.extend_from_slice(hash.as_slice());
+			},
+		};
+	}
+
+	fn begin_branch(
+		&mut self,
+		maybe_partial: Option<&[u8]>,
+		maybe_value: Option<TrieStreamValue>,
+		has_children: impl Iterator<Item = bool>,
+	) {
+		if let Some(partial) = maybe_partial {
+			let kind = match &maybe_value {
+				None => NodeKind::BranchNoValue,
+				Some(TrieStreamValue::Inline(..)) => NodeKind::BranchWithValue,
+				Some(TrieStreamValue::Node(..)) => NodeKind::HashedValueBranch,
+			};
+
+			self.buffer.extend(fuse_nibbles_node(partial, kind));
+			let bm = branch_node_bit_mask(has_children);
+			self.buffer.extend([bm.0, bm.1].iter());
+		} else {
+			unreachable!("trie stream codec only for no extension trie");
+		}
+		match maybe_value {
+			None => (),
+			Some(TrieStreamValue::Inline(value)) => {
+				Compact(value.len() as u32).encode_to(&mut self.buffer);
+				self.buffer.extend_from_slice(value);
+			},
+			Some(TrieStreamValue::Node(hash)) => {
+				self.buffer.extend_from_slice(hash.as_slice());
+			},
+		}
+	}
+
+	fn append_extension(&mut self, _key: &[u8]) {
+		debug_assert!(false, "trie stream codec only for no extension trie");
+	}
+
+	fn append_substream<H: Hasher>(&mut self, other: Self) {
+		let data = other.out();
+		match data.len() {
+			0..=31 => data.encode_to(&mut self.buffer),
+			_ => H::hash(&data).as_ref().encode_to(&mut self.buffer),
+		}
+	}
+
+	fn out(self) -> Vec<u8> {
+		self.buffer
+	}
+}
diff --git a/substrate/primitives/trie/test-res/invalid-delta-order b/substrate/primitives/trie/test-res/invalid-delta-order
new file mode 100644
index 0000000000000000000000000000000000000000..e46f280dc29bb2cbc3a28faeabe51efc747ba4af
Binary files /dev/null and b/substrate/primitives/trie/test-res/invalid-delta-order differ
diff --git a/substrate/primitives/trie/test-res/proof b/substrate/primitives/trie/test-res/proof
new file mode 100644
index 0000000000000000000000000000000000000000..278bea0bfbbc7fb16364eddbded70c884dd7ab71
Binary files /dev/null and b/substrate/primitives/trie/test-res/proof differ
diff --git a/substrate/primitives/trie/test-res/storage_root b/substrate/primitives/trie/test-res/storage_root
new file mode 100644
index 0000000000000000000000000000000000000000..758626802e15fce51207139cc5c67589f0c55878
--- /dev/null
+++ b/substrate/primitives/trie/test-res/storage_root
@@ -0,0 +1 @@
+‡=Ô[Á42%áJP¢Áh¦Kwé)Rª 0¤Ô­u¿Ã
\ No newline at end of file
diff --git a/substrate/primitives/trie/test-res/valid-delta-order b/substrate/primitives/trie/test-res/valid-delta-order
new file mode 100644
index 0000000000000000000000000000000000000000..4df6e62ec133b05cab2b53f00c8a4286eef70865
Binary files /dev/null and b/substrate/primitives/trie/test-res/valid-delta-order differ
diff --git a/substrate/primitives/version/Cargo.toml b/substrate/primitives/version/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f53a1e2e0c1a4d1afc41b4db48df06d824db1bc7
--- /dev/null
+++ b/substrate/primitives/version/Cargo.toml
@@ -0,0 +1,42 @@
+[package]
+name = "sp-version"
+version = "22.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Version module for the Substrate runtime; Provides a function that returns the runtime version."
+documentation = "https://docs.rs/sp-version"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+impl-serde = { version = "0.4.0", default-features = false, optional = true }
+parity-wasm = { version = "0.45", optional = true }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163",  default-features = false, features = ["derive", "alloc"], optional = true }
+thiserror = { version = "1.0.30", optional = true }
+sp-core-hashing-proc-macro = { version = "9.0.0", path = "../core/hashing/proc-macro" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../runtime" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+sp-version-proc-macro = { version = "8.0.0", default-features = false, path = "proc-macro" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"impl-serde/std",
+	"parity-wasm",
+	"scale-info/std",
+	"serde/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"thiserror",
+]
+
+# Serde support without relying on std features.
+serde = [ "dep:serde", "impl-serde", "sp-runtime/serde" ]
diff --git a/substrate/primitives/version/README.md b/substrate/primitives/version/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..84f0ae57d9dbeef1c84e4e01a8769b5f886e4501
--- /dev/null
+++ b/substrate/primitives/version/README.md
@@ -0,0 +1,3 @@
+Version module for the Substrate runtime; Provides a function that returns the runtime version.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/version/proc-macro/Cargo.toml b/substrate/primitives/version/proc-macro/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..33c14c9e715e4e2b3e5f3f9a5b68e6276a2169a4
--- /dev/null
+++ b/substrate/primitives/version/proc-macro/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "sp-version-proc-macro"
+version = "8.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Macro for defining a runtime version."
+documentation = "https://docs.rs/sp-api-proc-macro"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[lib]
+proc-macro = true
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = [ "derive" ] }
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full", "fold", "extra-traits", "visit"] }
+
+[dev-dependencies]
+sp-version = { version = "22.0.0", path = ".." }
diff --git a/substrate/primitives/version/proc-macro/src/decl_runtime_version.rs b/substrate/primitives/version/proc-macro/src/decl_runtime_version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7ca2d9b71f60a8059b4b3004ef3c089f3d110002
--- /dev/null
+++ b/substrate/primitives/version/proc-macro/src/decl_runtime_version.rs
@@ -0,0 +1,262 @@
+// 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 codec::Encode;
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+use syn::{
+	parse::{Error, Result},
+	parse_macro_input,
+	spanned::Spanned as _,
+	Expr, ExprLit, FieldValue, ItemConst, Lit,
+};
+
+/// This macro accepts a `const` item that has a struct initializer expression of
+/// `RuntimeVersion`-like type. The macro will pass through this declaration and append an item
+/// declaration that will lead to emitting a wasm custom section with the contents of
+/// `RuntimeVersion`.
+pub fn decl_runtime_version_impl(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let item = parse_macro_input!(input as ItemConst);
+	decl_runtime_version_impl_inner(item)
+		.unwrap_or_else(|e| e.to_compile_error())
+		.into()
+}
+
+fn decl_runtime_version_impl_inner(item: ItemConst) -> Result<TokenStream> {
+	let runtime_version = ParseRuntimeVersion::parse_expr(&item.expr)?.build(item.expr.span())?;
+	let link_section =
+		generate_emit_link_section_decl(&runtime_version.encode(), "runtime_version");
+
+	Ok(quote! {
+		#item
+		#link_section
+	})
+}
+
+/// This is a duplicate of `sp_version::RuntimeVersion`. We cannot unfortunately use the original
+/// declaration, because if we directly depend on `sp_version` from this proc-macro cargo will
+/// enable `std` feature even for `no_std` wasm runtime builds.
+///
+/// One difference from the original definition is the `apis` field. Since we don't actually parse
+/// `apis` from this macro it will always be emitteed as empty. An empty vector can be encoded as
+/// a zero-byte, thus `u8` is sufficient here.
+#[derive(Encode)]
+struct RuntimeVersion {
+	spec_name: String,
+	impl_name: String,
+	authoring_version: u32,
+	spec_version: u32,
+	impl_version: u32,
+	apis: u8,
+	transaction_version: u32,
+	state_version: u8,
+}
+
+#[derive(Default, Debug)]
+struct ParseRuntimeVersion {
+	spec_name: Option<String>,
+	impl_name: Option<String>,
+	authoring_version: Option<u32>,
+	spec_version: Option<u32>,
+	impl_version: Option<u32>,
+	transaction_version: Option<u32>,
+	state_version: Option<u8>,
+}
+
+impl ParseRuntimeVersion {
+	fn parse_expr(init_expr: &Expr) -> Result<ParseRuntimeVersion> {
+		let init_expr = match init_expr {
+			Expr::Struct(ref e) => e,
+			_ =>
+				return Err(Error::new(init_expr.span(), "expected a struct initializer expression")),
+		};
+
+		let mut parsed = ParseRuntimeVersion::default();
+		for field_value in init_expr.fields.iter() {
+			parsed.parse_field_value(field_value)?;
+		}
+		Ok(parsed)
+	}
+
+	fn parse_field_value(&mut self, field_value: &FieldValue) -> Result<()> {
+		let field_name = match field_value.member {
+			syn::Member::Named(ref ident) => ident,
+			syn::Member::Unnamed(_) =>
+				return Err(Error::new(field_value.span(), "only named members must be used")),
+		};
+
+		fn parse_once<T>(
+			value: &mut Option<T>,
+			field: &FieldValue,
+			parser: impl FnOnce(&Expr) -> Result<T>,
+		) -> Result<()> {
+			if value.is_some() {
+				Err(Error::new(field.span(), "field is already initialized before"))
+			} else {
+				*value = Some(parser(&field.expr)?);
+				Ok(())
+			}
+		}
+
+		if field_name == "spec_name" {
+			parse_once(&mut self.spec_name, field_value, Self::parse_str_literal)?;
+		} else if field_name == "impl_name" {
+			parse_once(&mut self.impl_name, field_value, Self::parse_str_literal)?;
+		} else if field_name == "authoring_version" {
+			parse_once(&mut self.authoring_version, field_value, Self::parse_num_literal)?;
+		} else if field_name == "spec_version" {
+			parse_once(&mut self.spec_version, field_value, Self::parse_num_literal)?;
+		} else if field_name == "impl_version" {
+			parse_once(&mut self.impl_version, field_value, Self::parse_num_literal)?;
+		} else if field_name == "transaction_version" {
+			parse_once(&mut self.transaction_version, field_value, Self::parse_num_literal)?;
+		} else if field_name == "state_version" {
+			parse_once(&mut self.state_version, field_value, Self::parse_num_literal_u8)?;
+		} else if field_name == "apis" {
+			// Intentionally ignored
+			//
+			// The definition will pass through for the declaration, however, it won't get into
+			// the "runtime_version" custom section. `impl_runtime_apis` is responsible for
+			// generating a custom section with the supported runtime apis descriptor.
+		} else {
+			return Err(Error::new(field_name.span(), "unknown field"))
+		}
+
+		Ok(())
+	}
+
+	fn parse_num_literal(expr: &Expr) -> Result<u32> {
+		let lit = match *expr {
+			Expr::Lit(ExprLit { lit: Lit::Int(ref lit), .. }) => lit,
+			_ =>
+				return Err(Error::new(
+					expr.span(),
+					"only numeric literals (e.g. `10`) are supported here",
+				)),
+		};
+		lit.base10_parse::<u32>()
+	}
+
+	fn parse_num_literal_u8(expr: &Expr) -> Result<u8> {
+		let lit = match *expr {
+			Expr::Lit(ExprLit { lit: Lit::Int(ref lit), .. }) => lit,
+			_ =>
+				return Err(Error::new(
+					expr.span(),
+					"only numeric literals (e.g. `10`) are supported here",
+				)),
+		};
+		lit.base10_parse::<u8>()
+	}
+
+	fn parse_str_literal(expr: &Expr) -> Result<String> {
+		let mac = match *expr {
+			Expr::Macro(syn::ExprMacro { ref mac, .. }) => mac,
+			_ => return Err(Error::new(expr.span(), "a macro expression is expected here")),
+		};
+
+		let lit: ExprLit = mac.parse_body().map_err(|e| {
+			Error::new(
+				e.span(),
+				format!("a single literal argument is expected, but parsing is failed: {}", e),
+			)
+		})?;
+
+		match lit.lit {
+			Lit::Str(ref lit) => Ok(lit.value()),
+			_ => Err(Error::new(lit.span(), "only string literals are supported here")),
+		}
+	}
+
+	fn build(self, span: Span) -> Result<RuntimeVersion> {
+		macro_rules! required {
+			($e:expr) => {
+				$e.ok_or_else(|| {
+					Error::new(span, format!("required field '{}' is missing", stringify!($e)))
+				})?
+			};
+		}
+
+		let Self {
+			spec_name,
+			impl_name,
+			authoring_version,
+			spec_version,
+			impl_version,
+			transaction_version,
+			state_version,
+		} = self;
+
+		Ok(RuntimeVersion {
+			spec_name: required!(spec_name),
+			impl_name: required!(impl_name),
+			authoring_version: required!(authoring_version),
+			spec_version: required!(spec_version),
+			impl_version: required!(impl_version),
+			transaction_version: required!(transaction_version),
+			state_version: required!(state_version),
+			apis: 0,
+		})
+	}
+}
+
+fn generate_emit_link_section_decl(contents: &[u8], section_name: &str) -> TokenStream {
+	let len = contents.len();
+	quote! {
+		const _: () = {
+			#[cfg(not(feature = "std"))]
+			#[link_section = #section_name]
+			static SECTION_CONTENTS: [u8; #len] = [#(#contents),*];
+		};
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::borrow::Cow;
+
+	#[test]
+	fn version_can_be_deserialized() {
+		let version_bytes = RuntimeVersion {
+			spec_name: "hello".to_string(),
+			impl_name: "world".to_string(),
+			authoring_version: 10,
+			spec_version: 265,
+			impl_version: 1,
+			apis: 0,
+			transaction_version: 2,
+			state_version: 1,
+		}
+		.encode();
+
+		assert_eq!(
+			sp_version::RuntimeVersion::decode_with_version_hint(&mut &version_bytes[..], Some(4))
+				.unwrap(),
+			sp_version::RuntimeVersion {
+				spec_name: "hello".into(),
+				impl_name: "world".into(),
+				authoring_version: 10,
+				spec_version: 265,
+				impl_version: 1,
+				apis: Cow::Owned(vec![]),
+				transaction_version: 2,
+				state_version: 1,
+			},
+		);
+	}
+}
diff --git a/substrate/primitives/version/proc-macro/src/lib.rs b/substrate/primitives/version/proc-macro/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4f9179f3196a118300c35e5b97beb9413afa027c
--- /dev/null
+++ b/substrate/primitives/version/proc-macro/src/lib.rs
@@ -0,0 +1,32 @@
+// 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 proc-macro that generates a custom wasm section from a given RuntimeVersion declaration
+//!
+//! This macro is re-exported from the `sp_version::runtime_version` and intended to be used from
+//! there. Documentation can also be found there.
+
+#![recursion_limit = "512"]
+
+use proc_macro::TokenStream;
+
+mod decl_runtime_version;
+
+#[proc_macro_attribute]
+pub fn runtime_version(_: TokenStream, input: TokenStream) -> TokenStream {
+	decl_runtime_version::decl_runtime_version_impl(input)
+}
diff --git a/substrate/primitives/version/src/embed.rs b/substrate/primitives/version/src/embed.rs
new file mode 100644
index 0000000000000000000000000000000000000000..096a7009a4fc55f2400b49be5a6f8f2e3227bf13
--- /dev/null
+++ b/substrate/primitives/version/src/embed.rs
@@ -0,0 +1,56 @@
+// 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.
+
+//! Provides functionality to embed a [`RuntimeVersion`](crate::RuntimeVersion) as custom section
+//! into a WASM file.
+
+use codec::Encode;
+use parity_wasm::elements::{deserialize_buffer, serialize, Module};
+
+#[derive(Clone, Copy, Eq, PartialEq, Debug, thiserror::Error)]
+pub enum Error {
+	#[error("Deserializing wasm failed")]
+	Deserialize,
+	#[error("Serializing wasm failed")]
+	Serialize,
+}
+
+/// Embed the given `version` to the given `wasm` blob.
+///
+/// If there was already a runtime version embedded, this will be overwritten.
+///
+/// Returns the new WASM blob.
+pub fn embed_runtime_version(
+	wasm: &[u8],
+	mut version: crate::RuntimeVersion,
+) -> Result<Vec<u8>, Error> {
+	let mut module: Module = deserialize_buffer(wasm).map_err(|_| Error::Deserialize)?;
+
+	let apis = version
+		.apis
+		.iter()
+		.map(Encode::encode)
+		.flat_map(|v| v.into_iter())
+		.collect::<Vec<u8>>();
+
+	module.set_custom_section("runtime_apis", apis);
+
+	version.apis.to_mut().clear();
+	module.set_custom_section("runtime_version", version.encode());
+
+	serialize(module).map_err(|_| Error::Serialize)
+}
diff --git a/substrate/primitives/version/src/lib.rs b/substrate/primitives/version/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bd8408bb4a48ae28b51c7ead0012bfa240e26ddf
--- /dev/null
+++ b/substrate/primitives/version/src/lib.rs
@@ -0,0 +1,458 @@
+// 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.
+
+//! Substrate runtime version
+//!
+//! Each runtime that should be executed by a Substrate based node needs to have a runtime version.
+//! The runtime version is defined by [`RuntimeVersion`]. The runtime version is used to
+//! distinguish different runtimes. The most important field is the
+//! [`spec_version`](RuntimeVersion::spec_version). The `spec_version` should be increased in a
+//! runtime when a new runtime build includes breaking changes that would make other runtimes unable
+//! to import blocks built by this runtime or vice-versa, where the new runtime could not import
+//! blocks built by the old runtime. The runtime version also carries other version information
+//! about the runtime, see [`RuntimeVersion`] for more information on this.
+//!
+//! Substrate will fetch the runtime version from a `wasm` blob by first checking the
+//! `runtime_version` link section or calling the `Core::version` runtime api. The link section can
+//! be generated in the runtime using the [`runtime_version`] attribute. The `Core` runtime api also
+//! needs to be implemented for the runtime using `impl_runtime_apis!`.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "std")]
+use std::collections::HashSet;
+#[cfg(feature = "std")]
+use std::fmt;
+
+use codec::{Decode, Encode, Input};
+use scale_info::TypeInfo;
+use sp_runtime::RuntimeString;
+pub use sp_runtime::{create_runtime_str, StateVersion};
+#[doc(hidden)]
+pub use sp_std;
+
+#[cfg(feature = "std")]
+use sp_runtime::traits::Block as BlockT;
+
+#[cfg(feature = "std")]
+pub mod embed;
+
+/// An attribute that accepts a version declaration of a runtime and generates a custom wasm
+/// section with the equivalent contents.
+///
+/// The custom section allows to read the version of the runtime without having to execute any
+/// code. Instead, the generated custom section can be relatively easily parsed from the wasm
+/// binary. The identifier of the custom section is "runtime_version".
+///
+/// A shortcoming of this macro is that it is unable to embed information regarding supported
+/// APIs. This is supported by the `construct_runtime!` macro.
+///
+/// # Usage
+///
+/// This macro accepts a const item like the following:
+///
+/// ```rust
+/// use sp_version::{create_runtime_str, RuntimeVersion};
+///
+/// #[sp_version::runtime_version]
+/// pub const VERSION: RuntimeVersion = RuntimeVersion {
+/// 	spec_name: create_runtime_str!("test"),
+/// 	impl_name: create_runtime_str!("test"),
+/// 	authoring_version: 10,
+/// 	spec_version: 265,
+/// 	impl_version: 1,
+/// 	apis: RUNTIME_API_VERSIONS,
+/// 	transaction_version: 2,
+/// 	state_version: 1,
+/// };
+///
+/// # const RUNTIME_API_VERSIONS: sp_version::ApisVec = sp_version::create_apis_vec!([]);
+/// ```
+///
+/// It will pass it through and add code required for emitting a custom section. The
+/// information that will go into the custom section is parsed from the item declaration. Due
+/// to that, the macro is somewhat rigid in terms of the code it accepts. There are the
+/// following considerations:
+///
+/// - The `spec_name` and `impl_name` must be set by a macro-like expression. The name of the
+///   macro doesn't matter though.
+///
+/// - `authoring_version`, `spec_version`, `impl_version` and `transaction_version` must be set
+///   by a literal. Literal must be an integer. No other expressions are allowed there. In
+///   particular, you can't supply a constant variable.
+///
+/// - `apis` doesn't have any specific constraints. This is because this information doesn't
+///   get into the custom section and is not parsed.
+///
+/// # Compilation Target & "std" feature
+///
+/// This macro assumes it will be used within a runtime. By convention, a runtime crate defines
+/// a feature named "std". This feature is enabled when the runtime is compiled to native code
+/// and disabled when it is compiled to the wasm code.
+///
+/// The custom section can only be emitted while compiling to wasm. In order to detect the
+/// compilation target we use the "std" feature. This macro will emit the custom section only
+/// if the "std" feature is **not** enabled.
+///
+/// Including this macro in the context where there is no "std" feature and the code is not
+/// compiled to wasm can lead to cryptic linking errors.
+pub use sp_version_proc_macro::runtime_version;
+
+/// The identity of a particular API interface that the runtime might provide.
+///
+/// The id is generated by hashing the name of the runtime api with BLAKE2 using a hash size
+/// of 8 bytes.
+///
+/// The name of the runtime api is the name of the trait when using `decl_runtime_apis!` macro. So,
+/// in the following runtime api declaration:
+///
+/// ```nocompile
+/// decl_runtime_apis! {
+///     trait TestApi {
+///         fn do_test();
+///     }
+/// }
+/// ```
+///
+/// The name of the trait would be `TestApi` and would be taken as input to the BLAKE2 hash
+/// function.
+///
+/// As Rust supports renaming of traits, the name of a runtime api given to `impl_runtime_apis!`
+/// doesn't need to be the same as in `decl_runtime_apis!`, but only the name in
+/// `decl_runtime_apis!` is the important one!
+pub type ApiId = [u8; 8];
+
+/// A vector of pairs of `ApiId` and a `u32` for version.
+pub type ApisVec = sp_std::borrow::Cow<'static, [(ApiId, u32)]>;
+
+/// Create a vector of Api declarations.
+#[macro_export]
+macro_rules! create_apis_vec {
+	( $y:expr ) => {
+		$crate::sp_std::borrow::Cow::Borrowed(&$y)
+	};
+}
+
+/// Runtime version.
+/// This should not be thought of as classic Semver (major/minor/tiny).
+/// This triplet have different semantics and mis-interpretation could cause problems.
+/// In particular: bug fixes should result in an increment of `spec_version` and possibly
+/// `authoring_version`, absolutely not `impl_version` since they change the semantics of the
+/// runtime.
+#[derive(Clone, PartialEq, Eq, Encode, Default, sp_runtime::RuntimeDebug, TypeInfo)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
+pub struct RuntimeVersion {
+	/// Identifies the different Substrate runtimes. There'll be at least polkadot and node.
+	/// A different on-chain spec_name to that of the native runtime would normally result
+	/// in node not attempting to sync or author blocks.
+	pub spec_name: RuntimeString,
+
+	/// Name of the implementation of the spec. This is of little consequence for the node
+	/// and serves only to differentiate code of different implementation teams. For this
+	/// codebase, it will be parity-polkadot. If there were a non-Rust implementation of the
+	/// Polkadot runtime (e.g. C++), then it would identify itself with an accordingly different
+	/// `impl_name`.
+	pub impl_name: RuntimeString,
+
+	/// `authoring_version` is the version of the authorship interface. An authoring node
+	/// will not attempt to author blocks unless this is equal to its native runtime.
+	pub authoring_version: u32,
+
+	/// Version of the runtime specification. A full-node will not attempt to use its native
+	/// runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`,
+	/// `spec_version` and `authoring_version` are the same between Wasm and native.
+	pub spec_version: u32,
+
+	/// Version of the implementation of the specification. Nodes are free to ignore this; it
+	/// serves only as an indication that the code is different; as long as the other two versions
+	/// are the same then while the actual code may be different, it is nonetheless required to
+	/// do the same thing.
+	/// Non-consensus-breaking optimizations are about the only changes that could be made which
+	/// would result in only the `impl_version` changing.
+	pub impl_version: u32,
+
+	/// List of supported API "features" along with their versions.
+	#[cfg_attr(
+		feature = "serde",
+		serde(
+			serialize_with = "apis_serialize::serialize",
+			deserialize_with = "apis_serialize::deserialize",
+		)
+	)]
+	pub apis: ApisVec,
+
+	/// All existing dispatches are fully compatible when this number doesn't change. If this
+	/// number changes, then `spec_version` must change, also.
+	///
+	/// This number must change when an existing dispatchable (module ID, dispatch ID) is changed,
+	/// either through an alteration in its user-level semantics, a parameter
+	/// added/removed/changed, a dispatchable being removed, a module being removed, or a
+	/// dispatchable/module changing its index.
+	///
+	/// It need *not* change when a new module is added or when a dispatchable is added.
+	pub transaction_version: u32,
+
+	/// Version of the state implementation used by this runtime.
+	/// Use of an incorrect version is consensus breaking.
+	pub state_version: u8,
+}
+
+impl RuntimeVersion {
+	/// `Decode` while giving a "version hint"
+	///
+	/// There exists multiple versions of [`RuntimeVersion`] and they are versioned using the `Core`
+	/// runtime api:
+	/// - `Core` version < 3 is a runtime version without a transaction version and state version.
+	/// - `Core` version 3 is a runtime version without a state version.
+	/// - `Core` version 4 is the latest runtime version.
+	pub fn decode_with_version_hint<I: Input>(
+		input: &mut I,
+		core_version: Option<u32>,
+	) -> Result<RuntimeVersion, codec::Error> {
+		let spec_name = Decode::decode(input)?;
+		let impl_name = Decode::decode(input)?;
+		let authoring_version = Decode::decode(input)?;
+		let spec_version = Decode::decode(input)?;
+		let impl_version = Decode::decode(input)?;
+		let apis = Decode::decode(input)?;
+		let core_version =
+			if core_version.is_some() { core_version } else { core_version_from_apis(&apis) };
+		let transaction_version =
+			if core_version.map(|v| v >= 3).unwrap_or(false) { Decode::decode(input)? } else { 1 };
+		let state_version =
+			if core_version.map(|v| v >= 4).unwrap_or(false) { Decode::decode(input)? } else { 0 };
+		Ok(RuntimeVersion {
+			spec_name,
+			impl_name,
+			authoring_version,
+			spec_version,
+			impl_version,
+			apis,
+			transaction_version,
+			state_version,
+		})
+	}
+}
+
+impl Decode for RuntimeVersion {
+	fn decode<I: Input>(input: &mut I) -> Result<Self, codec::Error> {
+		Self::decode_with_version_hint(input, None)
+	}
+}
+
+#[cfg(feature = "std")]
+impl fmt::Display for RuntimeVersion {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		write!(
+			f,
+			"{}-{} ({}-{}.tx{}.au{})",
+			self.spec_name,
+			self.spec_version,
+			self.impl_name,
+			self.impl_version,
+			self.transaction_version,
+			self.authoring_version,
+		)
+	}
+}
+
+#[cfg(feature = "std")]
+fn has_api_with<P: Fn(u32) -> bool>(apis: &ApisVec, id: &ApiId, predicate: P) -> bool {
+	apis.iter().any(|(s, v)| s == id && predicate(*v))
+}
+
+/// Returns the version of the `Core` runtime api.
+pub fn core_version_from_apis(apis: &ApisVec) -> Option<u32> {
+	let id = sp_core_hashing_proc_macro::blake2b_64!(b"Core");
+	apis.iter().find(|(s, _v)| s == &id).map(|(_s, v)| *v)
+}
+
+#[cfg(feature = "std")]
+impl RuntimeVersion {
+	/// Check if this version matches other version for calling into runtime.
+	pub fn can_call_with(&self, other: &RuntimeVersion) -> bool {
+		self.spec_version == other.spec_version &&
+			self.spec_name == other.spec_name &&
+			self.authoring_version == other.authoring_version
+	}
+
+	/// Check if the given api with `api_id` is implemented and the version passes the given
+	/// `predicate`.
+	pub fn has_api_with<P: Fn(u32) -> bool>(&self, id: &ApiId, predicate: P) -> bool {
+		has_api_with(&self.apis, id, predicate)
+	}
+
+	/// Returns the api version found for api with `id`.
+	pub fn api_version(&self, id: &ApiId) -> Option<u32> {
+		self.apis.iter().find_map(|a| (a.0 == *id).then(|| a.1))
+	}
+}
+
+impl RuntimeVersion {
+	/// Returns state version to use for update.
+	///
+	/// For runtime with core api version less than 4,
+	/// V0 trie version will be applied to state.
+	/// Otherwhise, V1 trie version will be use.
+	pub fn state_version(&self) -> StateVersion {
+		// If version > than 1, keep using latest version.
+		self.state_version.try_into().unwrap_or(StateVersion::V1)
+	}
+}
+
+/// The version of the native runtime.
+///
+/// In contrast to the bare [`RuntimeVersion`] this also carries a list of `spec_version`s of
+/// runtimes this native runtime can be used to author blocks for.
+#[derive(Debug)]
+#[cfg(feature = "std")]
+pub struct NativeVersion {
+	/// Basic runtime version info.
+	pub runtime_version: RuntimeVersion,
+	/// Authoring runtimes (`spec_version`s) that this native runtime supports.
+	pub can_author_with: HashSet<u32>,
+}
+
+#[cfg(feature = "std")]
+impl NativeVersion {
+	/// Check if this version matches other version for authoring blocks.
+	///
+	/// # Return
+	///
+	/// - Returns `Ok(())` when authoring is supported.
+	/// - Returns `Err(_)` with a detailed error when authoring is not supported.
+	pub fn can_author_with(&self, other: &RuntimeVersion) -> Result<(), String> {
+		if self.runtime_version.spec_name != other.spec_name {
+			Err(format!(
+				"`spec_name` does not match `{}` vs `{}`",
+				self.runtime_version.spec_name, other.spec_name,
+			))
+		} else if self.runtime_version.authoring_version != other.authoring_version &&
+			!self.can_author_with.contains(&other.authoring_version)
+		{
+			Err(format!(
+				"`authoring_version` does not match `{version}` vs `{other_version}` and \
+				`can_author_with` not contains `{other_version}`",
+				version = self.runtime_version.authoring_version,
+				other_version = other.authoring_version,
+			))
+		} else {
+			Ok(())
+		}
+	}
+}
+
+#[cfg(feature = "std")]
+/// Returns the version of the native runtime.
+pub trait GetNativeVersion {
+	/// Returns the version of the native runtime.
+	fn native_version(&self) -> &NativeVersion;
+}
+
+/// Something that can provide the runtime version at a given block.
+#[cfg(feature = "std")]
+pub trait GetRuntimeVersionAt<Block: BlockT> {
+	/// Returns the version of runtime at the given block.
+	fn runtime_version(&self, at: <Block as BlockT>::Hash) -> Result<RuntimeVersion, String>;
+}
+
+#[cfg(feature = "std")]
+impl<T: GetRuntimeVersionAt<Block>, Block: BlockT> GetRuntimeVersionAt<Block>
+	for std::sync::Arc<T>
+{
+	fn runtime_version(&self, at: <Block as BlockT>::Hash) -> Result<RuntimeVersion, String> {
+		(&**self).runtime_version(at)
+	}
+}
+
+#[cfg(feature = "std")]
+impl<T: GetNativeVersion> GetNativeVersion for std::sync::Arc<T> {
+	fn native_version(&self) -> &NativeVersion {
+		(&**self).native_version()
+	}
+}
+
+#[cfg(feature = "serde")]
+mod apis_serialize {
+	use super::*;
+	use impl_serde::serialize as bytes;
+	use serde::{de, ser::SerializeTuple, Serializer};
+	use sp_std::vec::Vec;
+
+	#[derive(Serialize)]
+	struct ApiId<'a>(#[serde(serialize_with = "serialize_bytesref")] &'a super::ApiId, &'a u32);
+
+	pub fn serialize<S>(apis: &ApisVec, ser: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		let len = apis.len();
+		let mut seq = ser.serialize_tuple(len)?;
+		for (api, ver) in &**apis {
+			seq.serialize_element(&ApiId(api, ver))?;
+		}
+		seq.end()
+	}
+
+	pub fn serialize_bytesref<S>(&apis: &&super::ApiId, ser: S) -> Result<S::Ok, S::Error>
+	where
+		S: Serializer,
+	{
+		bytes::serialize(apis, ser)
+	}
+
+	#[derive(Deserialize)]
+	struct ApiIdOwned(#[serde(deserialize_with = "deserialize_bytes")] super::ApiId, u32);
+
+	pub fn deserialize<'de, D>(deserializer: D) -> Result<ApisVec, D::Error>
+	where
+		D: de::Deserializer<'de>,
+	{
+		struct Visitor;
+		impl<'de> de::Visitor<'de> for Visitor {
+			type Value = ApisVec;
+
+			fn expecting(&self, formatter: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result {
+				formatter.write_str("a sequence of api id and version tuples")
+			}
+
+			fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
+			where
+				V: de::SeqAccess<'de>,
+			{
+				let mut apis = Vec::new();
+				while let Some(value) = visitor.next_element::<ApiIdOwned>()? {
+					apis.push((value.0, value.1));
+				}
+				Ok(apis.into())
+			}
+		}
+		deserializer.deserialize_seq(Visitor)
+	}
+
+	pub fn deserialize_bytes<'de, D>(d: D) -> Result<super::ApiId, D::Error>
+	where
+		D: de::Deserializer<'de>,
+	{
+		let mut arr = [0; 8];
+		bytes::deserialize_check_len(d, bytes::ExpectedLen::Exact(&mut arr[..]))?;
+		Ok(arr)
+	}
+}
diff --git a/substrate/primitives/wasm-interface/Cargo.toml b/substrate/primitives/wasm-interface/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..cac78fc2521bebc5301976fd39eaac90093fc26f
--- /dev/null
+++ b/substrate/primitives/wasm-interface/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "sp-wasm-interface"
+version = "14.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Types and traits for interfacing between the host and the wasm runtime."
+documentation = "https://docs.rs/sp-wasm-interface"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+impl-trait-for-tuples = "0.2.2"
+log = { version = "0.4.17", optional = true }
+wasmtime = { version = "8.0.1", default-features = false, optional = true }
+anyhow = { version = "1.0.68", optional = true }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [ "codec/std", "log", "sp-std/std", "wasmtime" ]
+wasmtime = [ "anyhow", "dep:wasmtime" ]
diff --git a/substrate/primitives/wasm-interface/README.md b/substrate/primitives/wasm-interface/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7e6c46581ae43c19b3b9b73d3d2b7975017c1a38
--- /dev/null
+++ b/substrate/primitives/wasm-interface/README.md
@@ -0,0 +1,3 @@
+Types and traits for interfacing between the host and the wasm runtime.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/primitives/wasm-interface/src/lib.rs b/substrate/primitives/wasm-interface/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9d5d2bb358d57926bedd69ce5b38132df8761151
--- /dev/null
+++ b/substrate/primitives/wasm-interface/src/lib.rs
@@ -0,0 +1,623 @@
+// 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.
+
+//! Types and traits for interfacing between the host and the wasm runtime.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use sp_std::{borrow::Cow, iter::Iterator, marker::PhantomData, mem, result, vec, vec::Vec};
+
+#[cfg(not(all(feature = "std", feature = "wasmtime")))]
+#[macro_export]
+macro_rules! if_wasmtime_is_enabled {
+	($($token:tt)*) => {};
+}
+
+#[cfg(all(feature = "std", feature = "wasmtime"))]
+#[macro_export]
+macro_rules! if_wasmtime_is_enabled {
+    ($($token:tt)*) => {
+        $($token)*
+    }
+}
+
+if_wasmtime_is_enabled! {
+	// Reexport wasmtime so that its types are accessible from the procedural macro.
+	pub use wasmtime;
+
+	// Wasmtime uses anyhow types but doesn't reexport them.
+	pub use anyhow;
+}
+
+/// Result type used by traits in this crate.
+#[cfg(feature = "std")]
+pub type Result<T> = result::Result<T, String>;
+#[cfg(not(feature = "std"))]
+pub type Result<T> = result::Result<T, &'static str>;
+
+/// Value types supported by Substrate on the boundary between host/Wasm.
+#[derive(Copy, Clone, PartialEq, Debug, Eq)]
+pub enum ValueType {
+	/// An `i32` value type.
+	I32,
+	/// An `i64` value type.
+	I64,
+	/// An `f32` value type.
+	F32,
+	/// An `f64` value type.
+	F64,
+}
+
+impl From<ValueType> for u8 {
+	fn from(val: ValueType) -> u8 {
+		match val {
+			ValueType::I32 => 0,
+			ValueType::I64 => 1,
+			ValueType::F32 => 2,
+			ValueType::F64 => 3,
+		}
+	}
+}
+
+impl TryFrom<u8> for ValueType {
+	type Error = ();
+
+	fn try_from(val: u8) -> sp_std::result::Result<ValueType, ()> {
+		match val {
+			0 => Ok(Self::I32),
+			1 => Ok(Self::I64),
+			2 => Ok(Self::F32),
+			3 => Ok(Self::F64),
+			_ => Err(()),
+		}
+	}
+}
+
+/// Values supported by Substrate on the boundary between host/Wasm.
+#[derive(PartialEq, Debug, Clone, Copy, codec::Encode, codec::Decode)]
+pub enum Value {
+	/// A 32-bit integer.
+	I32(i32),
+	/// A 64-bit integer.
+	I64(i64),
+	/// A 32-bit floating-point number stored as raw bit pattern.
+	///
+	/// You can materialize this value using `f32::from_bits`.
+	F32(u32),
+	/// A 64-bit floating-point number stored as raw bit pattern.
+	///
+	/// You can materialize this value using `f64::from_bits`.
+	F64(u64),
+}
+
+impl Value {
+	/// Returns the type of this value.
+	pub fn value_type(&self) -> ValueType {
+		match self {
+			Value::I32(_) => ValueType::I32,
+			Value::I64(_) => ValueType::I64,
+			Value::F32(_) => ValueType::F32,
+			Value::F64(_) => ValueType::F64,
+		}
+	}
+
+	/// Return `Self` as `i32`.
+	pub fn as_i32(&self) -> Option<i32> {
+		match self {
+			Self::I32(val) => Some(*val),
+			_ => None,
+		}
+	}
+}
+
+/// Provides `Sealed` trait to prevent implementing trait `PointerType` and `WasmTy` outside of this
+/// crate.
+mod private {
+	pub trait Sealed {}
+
+	impl Sealed for u8 {}
+	impl Sealed for u16 {}
+	impl Sealed for u32 {}
+	impl Sealed for u64 {}
+
+	impl Sealed for i32 {}
+	impl Sealed for i64 {}
+}
+
+/// Something that can be wrapped in a wasm `Pointer`.
+///
+/// This trait is sealed.
+pub trait PointerType: Sized + private::Sealed {
+	/// The size of the type in wasm.
+	const SIZE: u32 = mem::size_of::<Self>() as u32;
+}
+
+impl PointerType for u8 {}
+impl PointerType for u16 {}
+impl PointerType for u32 {}
+impl PointerType for u64 {}
+
+/// Type to represent a pointer in wasm at the host.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Pointer<T: PointerType> {
+	ptr: u32,
+	_marker: PhantomData<T>,
+}
+
+impl<T: PointerType> Pointer<T> {
+	/// Create a new instance of `Self`.
+	pub fn new(ptr: u32) -> Self {
+		Self { ptr, _marker: Default::default() }
+	}
+
+	/// Calculate the offset from this pointer.
+	///
+	/// `offset` is in units of `T`. So, `3` means `3 * mem::size_of::<T>()` as offset to the
+	/// pointer.
+	///
+	/// Returns an `Option` to respect that the pointer could probably overflow.
+	pub fn offset(self, offset: u32) -> Option<Self> {
+		offset
+			.checked_mul(T::SIZE)
+			.and_then(|o| self.ptr.checked_add(o))
+			.map(|ptr| Self { ptr, _marker: Default::default() })
+	}
+
+	/// Create a null pointer.
+	pub fn null() -> Self {
+		Self::new(0)
+	}
+
+	/// Cast this pointer of type `T` to a pointer of type `R`.
+	pub fn cast<R: PointerType>(self) -> Pointer<R> {
+		Pointer::new(self.ptr)
+	}
+}
+
+impl<T: PointerType> From<u32> for Pointer<T> {
+	fn from(ptr: u32) -> Self {
+		Pointer::new(ptr)
+	}
+}
+
+impl<T: PointerType> From<Pointer<T>> for u32 {
+	fn from(ptr: Pointer<T>) -> Self {
+		ptr.ptr
+	}
+}
+
+impl<T: PointerType> From<Pointer<T>> for u64 {
+	fn from(ptr: Pointer<T>) -> Self {
+		u64::from(ptr.ptr)
+	}
+}
+
+impl<T: PointerType> From<Pointer<T>> for usize {
+	fn from(ptr: Pointer<T>) -> Self {
+		ptr.ptr as _
+	}
+}
+
+impl<T: PointerType> IntoValue for Pointer<T> {
+	const VALUE_TYPE: ValueType = ValueType::I32;
+	fn into_value(self) -> Value {
+		Value::I32(self.ptr as _)
+	}
+}
+
+impl<T: PointerType> TryFromValue for Pointer<T> {
+	fn try_from_value(val: Value) -> Option<Self> {
+		match val {
+			Value::I32(val) => Some(Self::new(val as _)),
+			_ => None,
+		}
+	}
+}
+
+/// The word size used in wasm. Normally known as `usize` in Rust.
+pub type WordSize = u32;
+
+/// The Signature of a function
+#[derive(Eq, PartialEq, Debug, Clone)]
+pub struct Signature {
+	/// The arguments of a function.
+	pub args: Cow<'static, [ValueType]>,
+	/// The optional return value of a function.
+	pub return_value: Option<ValueType>,
+}
+
+impl Signature {
+	/// Create a new instance of `Signature`.
+	pub fn new<T: Into<Cow<'static, [ValueType]>>>(
+		args: T,
+		return_value: Option<ValueType>,
+	) -> Self {
+		Self { args: args.into(), return_value }
+	}
+
+	/// Create a new instance of `Signature` with the given `args` and without any return value.
+	pub fn new_with_args<T: Into<Cow<'static, [ValueType]>>>(args: T) -> Self {
+		Self { args: args.into(), return_value: None }
+	}
+}
+
+/// A trait that requires `RefUnwindSafe` when `feature = std`.
+#[cfg(feature = "std")]
+pub trait MaybeRefUnwindSafe: std::panic::RefUnwindSafe {}
+#[cfg(feature = "std")]
+impl<T: std::panic::RefUnwindSafe> MaybeRefUnwindSafe for T {}
+
+/// A trait that requires `RefUnwindSafe` when `feature = std`.
+#[cfg(not(feature = "std"))]
+pub trait MaybeRefUnwindSafe {}
+#[cfg(not(feature = "std"))]
+impl<T> MaybeRefUnwindSafe for T {}
+
+/// Something that provides a function implementation on the host for a wasm function.
+pub trait Function: MaybeRefUnwindSafe + Send + Sync {
+	/// Returns the name of this function.
+	fn name(&self) -> &str;
+	/// Returns the signature of this function.
+	fn signature(&self) -> Signature;
+	/// Execute this function with the given arguments.
+	fn execute(
+		&self,
+		context: &mut dyn FunctionContext,
+		args: &mut dyn Iterator<Item = Value>,
+	) -> Result<Option<Value>>;
+}
+
+impl PartialEq for dyn Function {
+	fn eq(&self, other: &Self) -> bool {
+		other.name() == self.name() && other.signature() == self.signature()
+	}
+}
+
+/// Context used by `Function` to interact with the allocator and the memory of the wasm instance.
+pub trait FunctionContext {
+	/// Read memory from `address` into a vector.
+	fn read_memory(&self, address: Pointer<u8>, size: WordSize) -> Result<Vec<u8>> {
+		let mut vec = vec![0; size as usize];
+		self.read_memory_into(address, &mut vec)?;
+		Ok(vec)
+	}
+	/// Read memory into the given `dest` buffer from `address`.
+	fn read_memory_into(&self, address: Pointer<u8>, dest: &mut [u8]) -> Result<()>;
+	/// Write the given data at `address` into the memory.
+	fn write_memory(&mut self, address: Pointer<u8>, data: &[u8]) -> Result<()>;
+	/// Allocate a memory instance of `size` bytes.
+	fn allocate_memory(&mut self, size: WordSize) -> Result<Pointer<u8>>;
+	/// Deallocate a given memory instance.
+	fn deallocate_memory(&mut self, ptr: Pointer<u8>) -> Result<()>;
+	/// Registers a panic error message within the executor.
+	///
+	/// This is meant to be used in situations where the runtime
+	/// encounters an unrecoverable error and intends to panic.
+	///
+	/// Panicking in WASM is done through the [`unreachable`](https://webassembly.github.io/spec/core/syntax/instructions.html#syntax-instr-control)
+	/// instruction which causes an unconditional trap and immediately aborts
+	/// the execution. It does not however allow for any diagnostics to be
+	/// passed through to the host, so while we do know that *something* went
+	/// wrong we don't have any direct indication of what *exactly* went wrong.
+	///
+	/// As a workaround we use this method right before the execution is
+	/// actually aborted to pass an error message to the host so that it
+	/// can associate it with the next trap, and return that to the caller.
+	///
+	/// A WASM trap should be triggered immediately after calling this method;
+	/// otherwise the error message might be associated with a completely
+	/// unrelated trap.
+	///
+	/// It should only be called once, however calling it more than once
+	/// is harmless and will overwrite the previously set error message.
+	fn register_panic_error_message(&mut self, message: &str);
+}
+
+if_wasmtime_is_enabled! {
+	/// A trait used to statically register host callbacks with the WASM executor,
+	/// so that they call be called from within the runtime with minimal overhead.
+	///
+	/// This is used internally to interface the wasmtime-based executor with the
+	/// host functions' definitions generated through the runtime interface macro,
+	/// and is not meant to be used directly.
+	pub trait HostFunctionRegistry {
+		type State;
+		type Error;
+		type FunctionContext: FunctionContext;
+
+		/// Wraps the given `caller` in a type which implements `FunctionContext`
+		/// and calls the given `callback`.
+		fn with_function_context<R>(
+			caller: wasmtime::Caller<Self::State>,
+			callback: impl FnOnce(&mut dyn FunctionContext) -> R,
+		) -> R;
+
+		/// Registers a given host function with the WASM executor.
+		///
+		/// The function has to be statically callable, and all of its arguments
+		/// and its return value have to be compatible with WASM FFI.
+		fn register_static<Params, Results>(
+			&mut self,
+			fn_name: &str,
+			func: impl wasmtime::IntoFunc<Self::State, Params, Results> + 'static,
+		) -> core::result::Result<(), Self::Error>;
+	}
+}
+
+/// Something that provides implementations for host functions.
+pub trait HostFunctions: 'static + Send + Sync {
+	/// Returns the host functions `Self` provides.
+	fn host_functions() -> Vec<&'static dyn Function>;
+
+	if_wasmtime_is_enabled! {
+		/// Statically registers the host functions.
+		fn register_static<T>(registry: &mut T) -> core::result::Result<(), T::Error>
+		where
+			T: HostFunctionRegistry;
+	}
+}
+
+#[impl_trait_for_tuples::impl_for_tuples(30)]
+impl HostFunctions for Tuple {
+	fn host_functions() -> Vec<&'static dyn Function> {
+		let mut host_functions = Vec::new();
+
+		for_tuples!( #( host_functions.extend(Tuple::host_functions()); )* );
+
+		host_functions
+	}
+
+	#[cfg(all(feature = "std", feature = "wasmtime"))]
+	fn register_static<T>(registry: &mut T) -> core::result::Result<(), T::Error>
+	where
+		T: HostFunctionRegistry,
+	{
+		for_tuples!(
+			#( Tuple::register_static(registry)?; )*
+		);
+
+		Ok(())
+	}
+}
+
+/// A wrapper which merges two sets of host functions, and allows the second set to override
+/// the host functions from the first set.
+pub struct ExtendedHostFunctions<Base, Overlay> {
+	phantom: PhantomData<(Base, Overlay)>,
+}
+
+impl<Base, Overlay> HostFunctions for ExtendedHostFunctions<Base, Overlay>
+where
+	Base: HostFunctions,
+	Overlay: HostFunctions,
+{
+	fn host_functions() -> Vec<&'static dyn Function> {
+		let mut base = Base::host_functions();
+		let overlay = Overlay::host_functions();
+		base.retain(|host_fn| {
+			!overlay.iter().any(|ext_host_fn| host_fn.name() == ext_host_fn.name())
+		});
+		base.extend(overlay);
+		base
+	}
+
+	if_wasmtime_is_enabled! {
+		fn register_static<T>(registry: &mut T) -> core::result::Result<(), T::Error>
+		where
+			T: HostFunctionRegistry,
+		{
+			struct Proxy<'a, T> {
+				registry: &'a mut T,
+				seen_overlay: std::collections::HashSet<String>,
+				seen_base: std::collections::HashSet<String>,
+				overlay_registered: bool,
+			}
+
+			impl<'a, T> HostFunctionRegistry for Proxy<'a, T>
+			where
+				T: HostFunctionRegistry,
+			{
+				type State = T::State;
+				type Error = T::Error;
+				type FunctionContext = T::FunctionContext;
+
+				fn with_function_context<R>(
+					caller: wasmtime::Caller<Self::State>,
+					callback: impl FnOnce(&mut dyn FunctionContext) -> R,
+				) -> R {
+					T::with_function_context(caller, callback)
+				}
+
+				fn register_static<Params, Results>(
+					&mut self,
+					fn_name: &str,
+					func: impl wasmtime::IntoFunc<Self::State, Params, Results> + 'static,
+				) -> core::result::Result<(), Self::Error> {
+					if self.overlay_registered {
+						if !self.seen_base.insert(fn_name.to_owned()) {
+							log::warn!(
+								target: "extended_host_functions",
+								"Duplicate base host function: '{}'",
+								fn_name,
+							);
+
+							// TODO: Return an error here?
+							return Ok(())
+						}
+
+						if self.seen_overlay.contains(fn_name) {
+							// Was already registered when we went through the overlay, so just ignore it.
+							log::debug!(
+								target: "extended_host_functions",
+								"Overriding base host function: '{}'",
+								fn_name,
+							);
+
+							return Ok(())
+						}
+					} else if !self.seen_overlay.insert(fn_name.to_owned()) {
+						log::warn!(
+							target: "extended_host_functions",
+							"Duplicate overlay host function: '{}'",
+							fn_name,
+						);
+
+						// TODO: Return an error here?
+						return Ok(())
+					}
+
+					self.registry.register_static(fn_name, func)
+				}
+			}
+
+			let mut proxy = Proxy {
+				registry,
+				seen_overlay: Default::default(),
+				seen_base: Default::default(),
+				overlay_registered: false,
+			};
+
+			// The functions from the `Overlay` can override those from the `Base`,
+			// so `Overlay` is registered first, and then we skip those functions
+			// in `Base` if they were already registered from the `Overlay`.
+			Overlay::register_static(&mut proxy)?;
+			proxy.overlay_registered = true;
+			Base::register_static(&mut proxy)?;
+
+			Ok(())
+		}
+	}
+}
+
+/// A trait for types directly usable at the WASM FFI boundary without any conversion at all.
+///
+/// This trait is sealed and should not be implemented downstream.
+#[cfg(all(feature = "std", feature = "wasmtime"))]
+pub trait WasmTy: wasmtime::WasmTy + private::Sealed {}
+
+/// A trait for types directly usable at the WASM FFI boundary without any conversion at all.
+///
+/// This trait is sealed and should not be implemented downstream.
+#[cfg(not(all(feature = "std", feature = "wasmtime")))]
+pub trait WasmTy: private::Sealed {}
+
+impl WasmTy for i32 {}
+impl WasmTy for u32 {}
+impl WasmTy for i64 {}
+impl WasmTy for u64 {}
+
+/// Something that can be converted into a wasm compatible `Value`.
+pub trait IntoValue {
+	/// The type of the value in wasm.
+	const VALUE_TYPE: ValueType;
+
+	/// Convert `self` into a wasm `Value`.
+	fn into_value(self) -> Value;
+}
+
+/// Something that can may be created from a wasm `Value`.
+pub trait TryFromValue: Sized {
+	/// Try to convert the given `Value` into `Self`.
+	fn try_from_value(val: Value) -> Option<Self>;
+}
+
+macro_rules! impl_into_and_from_value {
+	(
+		$(
+			$type:ty, $( < $gen:ident >, )? $value_variant:ident,
+		)*
+	) => {
+		$(
+			impl $( <$gen> )? IntoValue for $type {
+				const VALUE_TYPE: ValueType = ValueType::$value_variant;
+				fn into_value(self) -> Value { Value::$value_variant(self as _) }
+			}
+
+			impl $( <$gen> )? TryFromValue for $type {
+				fn try_from_value(val: Value) -> Option<Self> {
+					match val {
+						Value::$value_variant(val) => Some(val as _),
+						_ => None,
+					}
+				}
+			}
+		)*
+	}
+}
+
+impl_into_and_from_value! {
+	u8, I32,
+	u16, I32,
+	u32, I32,
+	u64, I64,
+	i8, I32,
+	i16, I32,
+	i32, I32,
+	i64, I64,
+}
+
+/// Typed value that can be returned from a function.
+///
+/// Basically a `TypedValue` plus `Unit`, for functions which return nothing.
+#[derive(Clone, Copy, PartialEq, codec::Encode, codec::Decode, Debug)]
+pub enum ReturnValue {
+	/// For returning nothing.
+	Unit,
+	/// For returning some concrete value.
+	Value(Value),
+}
+
+impl From<Value> for ReturnValue {
+	fn from(v: Value) -> ReturnValue {
+		ReturnValue::Value(v)
+	}
+}
+
+impl ReturnValue {
+	/// Maximum number of bytes `ReturnValue` might occupy when serialized with `SCALE`.
+	///
+	/// Breakdown:
+	///  1 byte for encoding unit/value variant
+	///  1 byte for encoding value type
+	///  8 bytes for encoding the biggest value types available in wasm: f64, i64.
+	pub const ENCODED_MAX_SIZE: usize = 10;
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::Encode;
+
+	#[test]
+	fn pointer_offset_works() {
+		let ptr = Pointer::<u32>::null();
+
+		assert_eq!(ptr.offset(10).unwrap(), Pointer::new(40));
+		assert_eq!(ptr.offset(32).unwrap(), Pointer::new(128));
+
+		let ptr = Pointer::<u64>::null();
+
+		assert_eq!(ptr.offset(10).unwrap(), Pointer::new(80));
+		assert_eq!(ptr.offset(32).unwrap(), Pointer::new(256));
+	}
+
+	#[test]
+	fn return_value_encoded_max_size() {
+		let encoded = ReturnValue::Value(Value::I64(-1)).encode();
+		assert_eq!(encoded.len(), ReturnValue::ENCODED_MAX_SIZE);
+	}
+}
diff --git a/substrate/primitives/weights/Cargo.toml b/substrate/primitives/weights/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..0ee32fbd8d6ea307831a71684e941b5f4860b62b
--- /dev/null
+++ b/substrate/primitives/weights/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "sp-weights"
+version = "20.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Types and traits for interfacing between the host and the wasm runtime."
+documentation = "https://docs.rs/sp-wasm-interface"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+serde = { version = "1.0.163", default-features = false, optional = true, features = ["derive", "alloc"] }
+smallvec = "1.11.0"
+sp-arithmetic = { version = "16.0.0", default-features = false, path = "../arithmetic" }
+sp-core = { version = "21.0.0", default-features = false, path = "../core" }
+sp-debug-derive = { version = "8.0.0", default-features = false, path = "../debug-derive" }
+sp-std = { version = "8.0.0", default-features = false, path = "../std" }
+
+[features]
+default = [ "std" ]
+std = [
+	"codec/std",
+	"scale-info/std",
+	"serde/std",
+	"sp-arithmetic/std",
+	"sp-core/std",
+	"sp-debug-derive/std",
+	"sp-std/std",
+]
+# By default some types have documentation, `full-metadata-docs` allows to add documentation to
+# more types in the metadata.
+full-metadata-docs = [ "scale-info/docs" ]
+
+# Serde support without relying on std features.
+serde = [
+	"dep:serde",
+	"scale-info/serde",
+	"sp-arithmetic/serde",
+	"sp-core/serde",
+]
diff --git a/substrate/primitives/weights/src/lib.rs b/substrate/primitives/weights/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..36cf864dd5389b08c5e692fc691050b3895f8cb1
--- /dev/null
+++ b/substrate/primitives/weights/src/lib.rs
@@ -0,0 +1,369 @@
+// 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.
+
+//! # Primitives for transaction weighting.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+// TODO remove once `OldWeight` is gone. I dont know why this is needed, maybe by one of the macros
+// of `OldWeight`.
+#![allow(deprecated)]
+
+extern crate self as sp_weights;
+
+mod weight_meter;
+mod weight_v2;
+
+use codec::{CompactAs, Decode, Encode, MaxEncodedLen};
+use scale_info::TypeInfo;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+use smallvec::SmallVec;
+use sp_arithmetic::{
+	traits::{BaseArithmetic, SaturatedConversion, Unsigned},
+	Perbill,
+};
+use sp_core::Get;
+use sp_debug_derive::RuntimeDebug;
+
+pub use weight_meter::*;
+pub use weight_v2::*;
+
+pub mod constants {
+	pub const WEIGHT_REF_TIME_PER_SECOND: u64 = 1_000_000_000_000;
+	pub const WEIGHT_REF_TIME_PER_MILLIS: u64 = 1_000_000_000;
+	pub const WEIGHT_REF_TIME_PER_MICROS: u64 = 1_000_000;
+	pub const WEIGHT_REF_TIME_PER_NANOS: u64 = 1_000;
+
+	pub const WEIGHT_PROOF_SIZE_PER_MB: u64 = 1024 * 1024;
+	pub const WEIGHT_PROOF_SIZE_PER_KB: u64 = 1024;
+}
+
+/// The old weight type.
+///
+/// NOTE: This type exists purely for compatibility purposes! Use [`weight_v2::Weight`] in all other
+/// cases.
+#[derive(
+	Decode,
+	Encode,
+	CompactAs,
+	PartialEq,
+	Eq,
+	Clone,
+	Copy,
+	RuntimeDebug,
+	Default,
+	MaxEncodedLen,
+	TypeInfo,
+)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+#[deprecated(note = "Will be removed soon; use `Weight` instead.")]
+pub struct OldWeight(pub u64);
+
+/// The weight of database operations that the runtime can invoke.
+///
+/// NOTE: This is currently only measured in computational time, and will probably
+/// be updated all together once proof size is accounted for.
+#[derive(Clone, Copy, Eq, PartialEq, Default, RuntimeDebug, Encode, Decode, TypeInfo)]
+pub struct RuntimeDbWeight {
+	pub read: u64,
+	pub write: u64,
+}
+
+impl RuntimeDbWeight {
+	pub fn reads(self, r: u64) -> Weight {
+		Weight::from_parts(self.read.saturating_mul(r), 0)
+	}
+
+	pub fn writes(self, w: u64) -> Weight {
+		Weight::from_parts(self.write.saturating_mul(w), 0)
+	}
+
+	pub fn reads_writes(self, r: u64, w: u64) -> Weight {
+		let read_weight = self.read.saturating_mul(r);
+		let write_weight = self.write.saturating_mul(w);
+		Weight::from_parts(read_weight.saturating_add(write_weight), 0)
+	}
+}
+
+/// One coefficient and its position in the `WeightToFee`.
+///
+/// One term of polynomial is calculated as:
+///
+/// ```ignore
+/// coeff_integer * x^(degree) + coeff_frac * x^(degree)
+/// ```
+///
+/// The `negative` value encodes whether the term is added or subtracted from the
+/// overall polynomial result.
+#[derive(Clone, Encode, Decode, TypeInfo)]
+pub struct WeightToFeeCoefficient<Balance> {
+	/// The integral part of the coefficient.
+	pub coeff_integer: Balance,
+	/// The fractional part of the coefficient.
+	pub coeff_frac: Perbill,
+	/// True iff the coefficient should be interpreted as negative.
+	pub negative: bool,
+	/// Degree/exponent of the term.
+	pub degree: u8,
+}
+
+impl<Balance> WeightToFeeCoefficient<Balance>
+where
+	Balance: BaseArithmetic + From<u32> + Copy + Unsigned,
+{
+	/// Evaluate the term at `x` and saturatingly amalgamate into `result`.
+	///
+	/// The unsigned value for the term is calculated as:
+	/// ```ignore
+	/// (frac * x^(degree) + integer * x^(degree))
+	/// ```
+	/// Depending on the value of `negative`, it is added or subtracted from the `result`.
+	pub fn saturating_eval(&self, mut result: Balance, x: Balance) -> Balance {
+		let power = x.saturating_pow(self.degree.into());
+
+		let frac = self.coeff_frac * power; // Overflow safe.
+		let integer = self.coeff_integer.saturating_mul(power);
+		// Do not add them together here to avoid an underflow.
+
+		if self.negative {
+			result = result.saturating_sub(frac);
+			result = result.saturating_sub(integer);
+		} else {
+			result = result.saturating_add(frac);
+			result = result.saturating_add(integer);
+		}
+
+		result
+	}
+}
+
+/// A list of coefficients that represent a polynomial.
+pub type WeightToFeeCoefficients<T> = SmallVec<[WeightToFeeCoefficient<T>; 4]>;
+
+/// A list of coefficients that represent a polynomial.
+///
+/// Can be [eval](Self::eval)uated at a specific `u64` to get the fee. The evaluations happens by
+/// summing up all term [results](`WeightToFeeCoefficient::saturating_eval`). The order of the
+/// coefficients matters since it uses saturating arithmetic. This struct does therefore not model a
+/// polynomial in the mathematical sense (polynomial ring).
+///
+/// For visualization purposes, the formulas of the unsigned terms look like:
+///
+/// ```ignore
+/// (c[0].frac * x^(c[0].degree) + c[0].integer * x^(c[0].degree))
+/// (c[1].frac * x^(c[1].degree) + c[1].integer * x^(c[1].degree))
+/// ...
+/// ```
+/// Depending on the value of `c[i].negative`, each term is added or subtracted from the result.
+/// The result is initialized as zero.
+pub struct FeePolynomial<Balance> {
+	coefficients: SmallVec<[WeightToFeeCoefficient<Balance>; 4]>,
+}
+
+impl<Balance> From<WeightToFeeCoefficients<Balance>> for FeePolynomial<Balance> {
+	fn from(coefficients: WeightToFeeCoefficients<Balance>) -> Self {
+		Self { coefficients }
+	}
+}
+
+impl<Balance> FeePolynomial<Balance>
+where
+	Balance: BaseArithmetic + From<u32> + Copy + Unsigned,
+{
+	/// Evaluate the polynomial at a specific `x`.
+	pub fn eval(&self, x: u64) -> Balance {
+		self.coefficients.iter().fold(Balance::zero(), |acc, term| {
+			term.saturating_eval(acc, Balance::saturated_from(x))
+		})
+	}
+}
+
+/// A trait that describes the weight to fee calculation.
+pub trait WeightToFee {
+	/// The type that is returned as result from calculation.
+	type Balance: BaseArithmetic + From<u32> + Copy + Unsigned;
+
+	/// Calculates the fee from the passed `weight`.
+	fn weight_to_fee(weight: &Weight) -> Self::Balance;
+}
+
+/// A trait that describes the weight to fee calculation as polynomial.
+///
+/// An implementor should only implement the `polynomial` function.
+pub trait WeightToFeePolynomial {
+	/// The type that is returned as result from polynomial evaluation.
+	type Balance: BaseArithmetic + From<u32> + Copy + Unsigned;
+
+	/// Returns a polynomial that describes the weight to fee conversion.
+	///
+	/// This is the only function that should be manually implemented. Please note
+	/// that all calculation is done in the probably unsigned `Balance` type. This means
+	/// that the order of coefficients is important as putting the negative coefficients
+	/// first will most likely saturate the result to zero mid evaluation.
+	fn polynomial() -> WeightToFeeCoefficients<Self::Balance>;
+}
+
+impl<T> WeightToFee for T
+where
+	T: WeightToFeePolynomial,
+{
+	type Balance = <Self as WeightToFeePolynomial>::Balance;
+
+	/// Calculates the fee from the passed `weight` according to the `polynomial`.
+	///
+	/// This should not be overridden in most circumstances. Calculation is done in the
+	/// `Balance` type and never overflows. All evaluation is saturating.
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		let poly: FeePolynomial<Self::Balance> = Self::polynomial().into();
+		poly.eval(weight.ref_time())
+	}
+}
+
+/// Implementor of `WeightToFee` that maps one unit of weight to one unit of fee.
+pub struct IdentityFee<T>(sp_std::marker::PhantomData<T>);
+
+impl<T> WeightToFee for IdentityFee<T>
+where
+	T: BaseArithmetic + From<u32> + Copy + Unsigned,
+{
+	type Balance = T;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time())
+	}
+}
+
+/// Implementor of [`WeightToFee`] that uses a constant multiplier.
+/// # Example
+///
+/// ```
+/// # use sp_core::ConstU128;
+/// # use sp_weights::ConstantMultiplier;
+/// // Results in a multiplier of 10 for each unit of weight (or length)
+/// type LengthToFee = ConstantMultiplier::<u128, ConstU128<10u128>>;
+/// ```
+pub struct ConstantMultiplier<T, M>(sp_std::marker::PhantomData<(T, M)>);
+
+impl<T, M> WeightToFee for ConstantMultiplier<T, M>
+where
+	T: BaseArithmetic + From<u32> + Copy + Unsigned,
+	M: Get<T>,
+{
+	type Balance = T;
+
+	fn weight_to_fee(weight: &Weight) -> Self::Balance {
+		Self::Balance::saturated_from(weight.ref_time()).saturating_mul(M::get())
+	}
+}
+
+#[cfg(test)]
+#[allow(dead_code)]
+mod tests {
+	use super::*;
+	use smallvec::smallvec;
+
+	type Balance = u64;
+
+	// 0.5x^3 + 2.333x^2 + 7x - 10_000
+	struct Poly;
+	impl WeightToFeePolynomial for Poly {
+		type Balance = Balance;
+
+		fn polynomial() -> WeightToFeeCoefficients<Self::Balance> {
+			smallvec![
+				WeightToFeeCoefficient {
+					coeff_integer: 0,
+					coeff_frac: Perbill::from_float(0.5),
+					negative: false,
+					degree: 3
+				},
+				WeightToFeeCoefficient {
+					coeff_integer: 2,
+					coeff_frac: Perbill::from_rational(1u32, 3u32),
+					negative: false,
+					degree: 2
+				},
+				WeightToFeeCoefficient {
+					coeff_integer: 7,
+					coeff_frac: Perbill::zero(),
+					negative: false,
+					degree: 1
+				},
+				WeightToFeeCoefficient {
+					coeff_integer: 10_000,
+					coeff_frac: Perbill::zero(),
+					negative: true,
+					degree: 0
+				},
+			]
+		}
+	}
+
+	#[test]
+	fn polynomial_works() {
+		// 100^3/2=500000 100^2*(2+1/3)=23333 700 -10000
+		assert_eq!(Poly::weight_to_fee(&Weight::from_parts(100, 0)), 514033);
+		// 10123^3/2=518677865433 10123^2*(2+1/3)=239108634 70861 -10000
+		assert_eq!(Poly::weight_to_fee(&Weight::from_parts(10_123, 0)), 518917034928);
+	}
+
+	#[test]
+	fn polynomial_does_not_underflow() {
+		assert_eq!(Poly::weight_to_fee(&Weight::zero()), 0);
+		assert_eq!(Poly::weight_to_fee(&Weight::from_parts(10, 0)), 0);
+	}
+
+	#[test]
+	fn polynomial_does_not_overflow() {
+		assert_eq!(Poly::weight_to_fee(&Weight::MAX), Balance::max_value() - 10_000);
+	}
+
+	#[test]
+	fn identity_fee_works() {
+		assert_eq!(IdentityFee::<Balance>::weight_to_fee(&Weight::zero()), 0);
+		assert_eq!(IdentityFee::<Balance>::weight_to_fee(&Weight::from_parts(50, 0)), 50);
+		assert_eq!(IdentityFee::<Balance>::weight_to_fee(&Weight::MAX), Balance::max_value());
+	}
+
+	#[test]
+	fn constant_fee_works() {
+		use sp_core::ConstU128;
+		assert_eq!(
+			ConstantMultiplier::<u128, ConstU128<100u128>>::weight_to_fee(&Weight::zero()),
+			0
+		);
+		assert_eq!(
+			ConstantMultiplier::<u128, ConstU128<10u128>>::weight_to_fee(&Weight::from_parts(
+				50, 0
+			)),
+			500
+		);
+		assert_eq!(
+			ConstantMultiplier::<u128, ConstU128<1024u128>>::weight_to_fee(&Weight::from_parts(
+				16, 0
+			)),
+			16384
+		);
+		assert_eq!(
+			ConstantMultiplier::<u128, ConstU128<{ u128::MAX }>>::weight_to_fee(
+				&Weight::from_parts(2, 0)
+			),
+			u128::MAX
+		);
+	}
+}
diff --git a/substrate/primitives/weights/src/weight_meter.rs b/substrate/primitives/weights/src/weight_meter.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3b0b21ea8799ac44d6dcc787e379b725fab628d4
--- /dev/null
+++ b/substrate/primitives/weights/src/weight_meter.rs
@@ -0,0 +1,287 @@
+// 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.
+
+//! Contains the `WeightMeter` primitive to meter weight usage.
+
+use super::Weight;
+
+use sp_arithmetic::Perbill;
+
+/// Meters consumed weight and a hard limit for the maximal consumable weight.
+///
+/// Can be used to check if enough weight for an operation is available before committing to it.
+///
+/// # Example
+///
+/// ```rust
+/// use sp_weights::{Weight, WeightMeter};
+///
+/// // The weight is limited to (10, 0).
+/// let mut meter = WeightMeter::from_limit(Weight::from_parts(10, 0));
+/// // There is enough weight remaining for an operation with (6, 0) weight.
+/// assert!(meter.try_consume(Weight::from_parts(6, 0)).is_ok());
+/// assert_eq!(meter.remaining(), Weight::from_parts(4, 0));
+/// // There is not enough weight remaining for an operation with (5, 0) weight.
+/// assert!(!meter.try_consume(Weight::from_parts(5, 0)).is_ok());
+/// // The total limit is obviously unchanged:
+/// assert_eq!(meter.limit(), Weight::from_parts(10, 0));
+/// ```
+#[derive(Debug, Clone)]
+pub struct WeightMeter {
+	/// The already consumed weight.
+	consumed: Weight,
+
+	/// The maximal consumable weight.
+	limit: Weight,
+}
+
+impl WeightMeter {
+	/// Creates [`Self`] from a limit for the maximal consumable weight.
+	pub fn from_limit(limit: Weight) -> Self {
+		Self { consumed: Weight::zero(), limit }
+	}
+
+	/// Creates [`Self`] with the maximal possible limit for the consumable weight.
+	pub fn max_limit() -> Self {
+		Self::from_limit(Weight::MAX)
+	}
+
+	/// The already consumed weight.
+	pub fn consumed(&self) -> Weight {
+		self.consumed
+	}
+
+	/// The limit can ever be accrued.
+	pub fn limit(&self) -> Weight {
+		self.limit
+	}
+
+	/// The remaining weight that can still be consumed.
+	pub fn remaining(&self) -> Weight {
+		self.limit.saturating_sub(self.consumed)
+	}
+
+	/// The ratio of consumed weight to the limit.
+	///
+	/// Calculates one ratio per component and returns the largest.
+	///
+	/// # Example
+	/// ```rust
+	/// use sp_weights::{Weight, WeightMeter};
+	/// use sp_arithmetic::Perbill;
+	///
+	/// let mut meter = WeightMeter::from_limit(Weight::from_parts(10, 20));
+	/// // Nothing consumed so far:
+	/// assert_eq!(meter.consumed_ratio(), Perbill::from_percent(0));
+	/// meter.consume(Weight::from_parts(5, 5));
+	/// // The ref-time is the larger ratio:
+	/// assert_eq!(meter.consumed_ratio(), Perbill::from_percent(50));
+	/// meter.consume(Weight::from_parts(1, 10));
+	/// // Now the larger ratio is proof-size:
+	/// assert_eq!(meter.consumed_ratio(), Perbill::from_percent(75));
+	/// // Eventually it reaches 100%:
+	/// meter.consume(Weight::from_parts(4, 0));
+	/// assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));
+	/// // Saturating the second component won't change anything anymore:
+	/// meter.consume(Weight::from_parts(0, 5));
+	/// assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));
+	/// ```
+	pub fn consumed_ratio(&self) -> Perbill {
+		let time = Perbill::from_rational(self.consumed.ref_time(), self.limit.ref_time());
+		let pov = Perbill::from_rational(self.consumed.proof_size(), self.limit.proof_size());
+		time.max(pov)
+	}
+
+	/// Consume some weight and defensively fail if it is over the limit. Saturate in any case.
+	#[deprecated(note = "Use `consume` instead. Will be removed after December 2023.")]
+	pub fn defensive_saturating_accrue(&mut self, w: Weight) {
+		self.consume(w);
+	}
+
+	/// Consume some weight and defensively fail if it is over the limit. Saturate in any case.
+	pub fn consume(&mut self, w: Weight) {
+		self.consumed.saturating_accrue(w);
+		debug_assert!(self.consumed.all_lte(self.limit), "Weight counter overflow");
+	}
+
+	/// Consume the given weight after checking that it can be consumed and return `true`. Otherwise
+	/// do nothing and return `false`.
+	#[deprecated(note = "Use `try_consume` instead. Will be removed after December 2023.")]
+	pub fn check_accrue(&mut self, w: Weight) -> bool {
+		self.try_consume(w).is_ok()
+	}
+
+	/// Consume the given weight after checking that it can be consumed.
+	///
+	/// Returns `Ok` if the weight can be consumed or otherwise an `Err`.
+	pub fn try_consume(&mut self, w: Weight) -> Result<(), ()> {
+		self.consumed.checked_add(&w).map_or(Err(()), |test| {
+			if test.any_gt(self.limit) {
+				Err(())
+			} else {
+				self.consumed = test;
+				Ok(())
+			}
+		})
+	}
+
+	/// Check if the given weight can be consumed.
+	#[deprecated(note = "Use `can_consume` instead. Will be removed after December 2023.")]
+	pub fn can_accrue(&self, w: Weight) -> bool {
+		self.can_consume(w)
+	}
+
+	/// Check if the given weight can be consumed.
+	pub fn can_consume(&self, w: Weight) -> bool {
+		self.consumed.checked_add(&w).map_or(false, |t| t.all_lte(self.limit))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use crate::*;
+	use sp_arithmetic::traits::Zero;
+
+	#[test]
+	fn weight_meter_remaining_works() {
+		let mut meter = WeightMeter::from_limit(Weight::from_parts(10, 20));
+
+		assert!(meter.check_accrue(Weight::from_parts(5, 0)));
+		assert_eq!(meter.consumed, Weight::from_parts(5, 0));
+		assert_eq!(meter.remaining(), Weight::from_parts(5, 20));
+
+		assert!(meter.check_accrue(Weight::from_parts(2, 10)));
+		assert_eq!(meter.consumed, Weight::from_parts(7, 10));
+		assert_eq!(meter.remaining(), Weight::from_parts(3, 10));
+
+		assert!(meter.check_accrue(Weight::from_parts(3, 10)));
+		assert_eq!(meter.consumed, Weight::from_parts(10, 20));
+		assert_eq!(meter.remaining(), Weight::from_parts(0, 0));
+	}
+
+	#[test]
+	fn weight_meter_can_accrue_works() {
+		let meter = WeightMeter::from_limit(Weight::from_parts(1, 1));
+
+		assert!(meter.can_accrue(Weight::from_parts(0, 0)));
+		assert!(meter.can_accrue(Weight::from_parts(1, 1)));
+		assert!(!meter.can_accrue(Weight::from_parts(0, 2)));
+		assert!(!meter.can_accrue(Weight::from_parts(2, 0)));
+		assert!(!meter.can_accrue(Weight::from_parts(2, 2)));
+	}
+
+	#[test]
+	fn weight_meter_check_accrue_works() {
+		let mut meter = WeightMeter::from_limit(Weight::from_parts(2, 2));
+
+		assert!(meter.check_accrue(Weight::from_parts(0, 0)));
+		assert!(meter.check_accrue(Weight::from_parts(1, 1)));
+		assert!(!meter.check_accrue(Weight::from_parts(0, 2)));
+		assert!(!meter.check_accrue(Weight::from_parts(2, 0)));
+		assert!(!meter.check_accrue(Weight::from_parts(2, 2)));
+		assert!(meter.check_accrue(Weight::from_parts(0, 1)));
+		assert!(meter.check_accrue(Weight::from_parts(1, 0)));
+	}
+
+	#[test]
+	fn weight_meter_check_and_can_accrue_works() {
+		let mut meter = WeightMeter::max_limit();
+
+		assert!(meter.can_accrue(Weight::from_parts(u64::MAX, 0)));
+		assert!(meter.check_accrue(Weight::from_parts(u64::MAX, 0)));
+
+		assert!(meter.can_accrue(Weight::from_parts(0, u64::MAX)));
+		assert!(meter.check_accrue(Weight::from_parts(0, u64::MAX)));
+
+		assert!(!meter.can_accrue(Weight::from_parts(0, 1)));
+		assert!(!meter.check_accrue(Weight::from_parts(0, 1)));
+
+		assert!(!meter.can_accrue(Weight::from_parts(1, 0)));
+		assert!(!meter.check_accrue(Weight::from_parts(1, 0)));
+
+		assert!(meter.can_accrue(Weight::zero()));
+		assert!(meter.check_accrue(Weight::zero()));
+	}
+
+	#[test]
+	fn consumed_ratio_works() {
+		let mut meter = WeightMeter::from_limit(Weight::from_parts(10, 20));
+
+		assert!(meter.check_accrue(Weight::from_parts(5, 0)));
+		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(50));
+		assert!(meter.check_accrue(Weight::from_parts(0, 12)));
+		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(60));
+
+		assert!(meter.check_accrue(Weight::from_parts(2, 0)));
+		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(70));
+		assert!(meter.check_accrue(Weight::from_parts(0, 4)));
+		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(80));
+
+		assert!(meter.check_accrue(Weight::from_parts(3, 0)));
+		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));
+		assert!(meter.check_accrue(Weight::from_parts(0, 4)));
+		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));
+	}
+
+	#[test]
+	fn try_consume_works() {
+		let mut meter = WeightMeter::from_limit(Weight::from_parts(10, 0));
+
+		assert!(meter.try_consume(Weight::from_parts(11, 0)).is_err());
+		assert!(meter.consumed().is_zero(), "No modification");
+
+		assert!(meter.try_consume(Weight::from_parts(9, 0)).is_ok());
+		assert!(meter.try_consume(Weight::from_parts(2, 0)).is_err());
+		assert!(meter.try_consume(Weight::from_parts(1, 0)).is_ok());
+		assert!(meter.remaining().is_zero());
+		assert_eq!(meter.consumed(), Weight::from_parts(10, 0));
+	}
+
+	#[test]
+	fn can_consume_works() {
+		let mut meter = WeightMeter::from_limit(Weight::from_parts(10, 0));
+
+		assert!(!meter.can_consume(Weight::from_parts(11, 0)));
+		assert!(meter.consumed().is_zero(), "No modification");
+
+		assert!(meter.can_consume(Weight::from_parts(9, 0)));
+		meter.consume(Weight::from_parts(9, 0));
+		assert!(!meter.can_consume(Weight::from_parts(2, 0)));
+		assert!(meter.can_consume(Weight::from_parts(1, 0)));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	fn consume_works() {
+		let mut meter = WeightMeter::from_limit(Weight::from_parts(5, 10));
+
+		meter.consume(Weight::from_parts(4, 0));
+		assert_eq!(meter.remaining(), Weight::from_parts(1, 10));
+		meter.consume(Weight::from_parts(1, 0));
+		assert_eq!(meter.remaining(), Weight::from_parts(0, 10));
+		meter.consume(Weight::from_parts(0, 10));
+		assert_eq!(meter.consumed(), Weight::from_parts(5, 10));
+	}
+
+	#[test]
+	#[cfg(debug_assertions)]
+	#[should_panic(expected = "Weight counter overflow")]
+	fn consume_defensive_fail() {
+		let mut meter = WeightMeter::from_limit(Weight::from_parts(10, 0));
+		let _ = meter.consume(Weight::from_parts(11, 0));
+	}
+}
diff --git a/substrate/primitives/weights/src/weight_v2.rs b/substrate/primitives/weights/src/weight_v2.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3946cfe42c8d0efb7b7de4811c6ab2a2a8d08c15
--- /dev/null
+++ b/substrate/primitives/weights/src/weight_v2.rs
@@ -0,0 +1,646 @@
+// 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 codec::{Decode, Encode, MaxEncodedLen};
+use core::ops::{Add, AddAssign, Div, Mul, Sub, SubAssign};
+use sp_arithmetic::traits::{Bounded, CheckedAdd, CheckedSub, Zero};
+use sp_debug_derive::RuntimeDebug;
+
+use super::*;
+
+#[derive(
+	Encode, Decode, MaxEncodedLen, TypeInfo, Eq, PartialEq, Copy, Clone, RuntimeDebug, Default,
+)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct Weight {
+	#[codec(compact)]
+	/// The weight of computational time used based on some reference hardware.
+	ref_time: u64,
+	#[codec(compact)]
+	/// The weight of storage space used by proof of validity.
+	proof_size: u64,
+}
+
+impl Weight {
+	/// Set the reference time part of the weight.
+	pub const fn set_ref_time(mut self, c: u64) -> Self {
+		self.ref_time = c;
+		self
+	}
+
+	/// Set the storage size part of the weight.
+	pub const fn set_proof_size(mut self, c: u64) -> Self {
+		self.proof_size = c;
+		self
+	}
+
+	/// Return the reference time part of the weight.
+	pub const fn ref_time(&self) -> u64 {
+		self.ref_time
+	}
+
+	/// Return the storage size part of the weight.
+	pub const fn proof_size(&self) -> u64 {
+		self.proof_size
+	}
+
+	/// Return a mutable reference to the reference time part of the weight.
+	pub fn ref_time_mut(&mut self) -> &mut u64 {
+		&mut self.ref_time
+	}
+
+	/// Return a mutable reference to the storage size part of the weight.
+	pub fn proof_size_mut(&mut self) -> &mut u64 {
+		&mut self.proof_size
+	}
+
+	/// The maximal weight in all dimensions.
+	pub const MAX: Self = Self { ref_time: u64::MAX, proof_size: u64::MAX };
+
+	/// Get the conservative min of `self` and `other` weight.
+	pub fn min(&self, other: Self) -> Self {
+		Self {
+			ref_time: self.ref_time.min(other.ref_time),
+			proof_size: self.proof_size.min(other.proof_size),
+		}
+	}
+
+	/// Get the aggressive max of `self` and `other` weight.
+	pub fn max(&self, other: Self) -> Self {
+		Self {
+			ref_time: self.ref_time.max(other.ref_time),
+			proof_size: self.proof_size.max(other.proof_size),
+		}
+	}
+
+	/// Try to add some `other` weight while upholding the `limit`.
+	pub fn try_add(&self, other: &Self, limit: &Self) -> Option<Self> {
+		let total = self.checked_add(other)?;
+		if total.any_gt(*limit) {
+			None
+		} else {
+			Some(total)
+		}
+	}
+
+	/// Construct [`Weight`] from weight parts, namely reference time and proof size weights.
+	pub const fn from_parts(ref_time: u64, proof_size: u64) -> Self {
+		Self { ref_time, proof_size }
+	}
+
+	/// Construct [`Weight`] from the same weight for all parts.
+	pub const fn from_all(value: u64) -> Self {
+		Self { ref_time: value, proof_size: value }
+	}
+
+	/// Saturating [`Weight`] addition. Computes `self + rhs`, saturating at the numeric bounds of
+	/// all fields instead of overflowing.
+	pub const fn saturating_add(self, rhs: Self) -> Self {
+		Self {
+			ref_time: self.ref_time.saturating_add(rhs.ref_time),
+			proof_size: self.proof_size.saturating_add(rhs.proof_size),
+		}
+	}
+
+	/// Saturating [`Weight`] subtraction. Computes `self - rhs`, saturating at the numeric bounds
+	/// of all fields instead of overflowing.
+	pub const fn saturating_sub(self, rhs: Self) -> Self {
+		Self {
+			ref_time: self.ref_time.saturating_sub(rhs.ref_time),
+			proof_size: self.proof_size.saturating_sub(rhs.proof_size),
+		}
+	}
+
+	/// Saturating [`Weight`] scalar multiplication. Computes `self.field * scalar` for all fields,
+	/// saturating at the numeric bounds of all fields instead of overflowing.
+	pub const fn saturating_mul(self, scalar: u64) -> Self {
+		Self {
+			ref_time: self.ref_time.saturating_mul(scalar),
+			proof_size: self.proof_size.saturating_mul(scalar),
+		}
+	}
+
+	/// Saturating [`Weight`] scalar division. Computes `self.field / scalar` for all fields,
+	/// saturating at the numeric bounds of all fields instead of overflowing.
+	pub const fn saturating_div(self, scalar: u64) -> Self {
+		Self {
+			ref_time: self.ref_time.saturating_div(scalar),
+			proof_size: self.proof_size.saturating_div(scalar),
+		}
+	}
+
+	/// Saturating [`Weight`] scalar exponentiation. Computes `self.field.pow(exp)` for all fields,
+	/// saturating at the numeric bounds of all fields instead of overflowing.
+	pub const fn saturating_pow(self, exp: u32) -> Self {
+		Self {
+			ref_time: self.ref_time.saturating_pow(exp),
+			proof_size: self.proof_size.saturating_pow(exp),
+		}
+	}
+
+	/// Increment [`Weight`] by `amount` via saturating addition.
+	pub fn saturating_accrue(&mut self, amount: Self) {
+		*self = self.saturating_add(amount);
+	}
+
+	/// Reduce [`Weight`] by `amount` via saturating subtraction.
+	pub fn saturating_reduce(&mut self, amount: Self) {
+		*self = self.saturating_sub(amount);
+	}
+
+	/// Checked [`Weight`] addition. Computes `self + rhs`, returning `None` if overflow occurred.
+	pub const fn checked_add(&self, rhs: &Self) -> Option<Self> {
+		let ref_time = match self.ref_time.checked_add(rhs.ref_time) {
+			Some(t) => t,
+			None => return None,
+		};
+		let proof_size = match self.proof_size.checked_add(rhs.proof_size) {
+			Some(s) => s,
+			None => return None,
+		};
+		Some(Self { ref_time, proof_size })
+	}
+
+	/// Checked [`Weight`] subtraction. Computes `self - rhs`, returning `None` if overflow
+	/// occurred.
+	pub const fn checked_sub(&self, rhs: &Self) -> Option<Self> {
+		let ref_time = match self.ref_time.checked_sub(rhs.ref_time) {
+			Some(t) => t,
+			None => return None,
+		};
+		let proof_size = match self.proof_size.checked_sub(rhs.proof_size) {
+			Some(s) => s,
+			None => return None,
+		};
+		Some(Self { ref_time, proof_size })
+	}
+
+	/// Checked [`Weight`] scalar multiplication. Computes `self.field * scalar` for each field,
+	/// returning `None` if overflow occurred.
+	pub const fn checked_mul(self, scalar: u64) -> Option<Self> {
+		let ref_time = match self.ref_time.checked_mul(scalar) {
+			Some(t) => t,
+			None => return None,
+		};
+		let proof_size = match self.proof_size.checked_mul(scalar) {
+			Some(s) => s,
+			None => return None,
+		};
+		Some(Self { ref_time, proof_size })
+	}
+
+	/// Checked [`Weight`] scalar division. Computes `self.field / scalar` for each field, returning
+	/// `None` if overflow occurred.
+	pub const fn checked_div(self, scalar: u64) -> Option<Self> {
+		let ref_time = match self.ref_time.checked_div(scalar) {
+			Some(t) => t,
+			None => return None,
+		};
+		let proof_size = match self.proof_size.checked_div(scalar) {
+			Some(s) => s,
+			None => return None,
+		};
+		Some(Self { ref_time, proof_size })
+	}
+
+	/// Calculates how many `other` fit into `self`.
+	///
+	/// Divides each component of `self` against the same component of `other`. Returns the minimum
+	/// of all those divisions. Returns `None` in case **all** components of `other` are zero.
+	///
+	/// This returns `Some` even if some components of `other` are zero as long as there is at least
+	/// one non-zero component in `other`. The division for this particular component will then
+	/// yield the maximum value (e.g u64::MAX). This is because we assume not every operation and
+	/// hence each `Weight` will necessarily use each resource.
+	pub const fn checked_div_per_component(self, other: &Self) -> Option<u64> {
+		let mut all_zero = true;
+		let ref_time = match self.ref_time.checked_div(other.ref_time) {
+			Some(ref_time) => {
+				all_zero = false;
+				ref_time
+			},
+			None => u64::MAX,
+		};
+		let proof_size = match self.proof_size.checked_div(other.proof_size) {
+			Some(proof_size) => {
+				all_zero = false;
+				proof_size
+			},
+			None => u64::MAX,
+		};
+		if all_zero {
+			None
+		} else {
+			Some(if ref_time < proof_size { ref_time } else { proof_size })
+		}
+	}
+
+	/// Try to increase `self` by `amount` via checked addition.
+	pub fn checked_accrue(&mut self, amount: Self) -> Option<()> {
+		self.checked_add(&amount).map(|new_self| *self = new_self)
+	}
+
+	/// Try to reduce `self` by `amount` via checked subtraction.
+	pub fn checked_reduce(&mut self, amount: Self) -> Option<()> {
+		self.checked_sub(&amount).map(|new_self| *self = new_self)
+	}
+
+	/// Return a [`Weight`] where all fields are zero.
+	pub const fn zero() -> Self {
+		Self { ref_time: 0, proof_size: 0 }
+	}
+
+	/// Constant version of Add for `ref_time` component with u64.
+	///
+	/// Is only overflow safe when evaluated at compile-time.
+	pub const fn add_ref_time(self, scalar: u64) -> Self {
+		Self { ref_time: self.ref_time + scalar, proof_size: self.proof_size }
+	}
+
+	/// Constant version of Add for `proof_size` component with u64.
+	///
+	/// Is only overflow safe when evaluated at compile-time.
+	pub const fn add_proof_size(self, scalar: u64) -> Self {
+		Self { ref_time: self.ref_time, proof_size: self.proof_size + scalar }
+	}
+
+	/// Constant version of Sub for `ref_time` component with u64.
+	///
+	/// Is only overflow safe when evaluated at compile-time.
+	pub const fn sub_ref_time(self, scalar: u64) -> Self {
+		Self { ref_time: self.ref_time - scalar, proof_size: self.proof_size }
+	}
+
+	/// Constant version of Sub for `proof_size` component with u64.
+	///
+	/// Is only overflow safe when evaluated at compile-time.
+	pub const fn sub_proof_size(self, scalar: u64) -> Self {
+		Self { ref_time: self.ref_time, proof_size: self.proof_size - scalar }
+	}
+
+	/// Constant version of Div with u64.
+	///
+	/// Is only overflow safe when evaluated at compile-time.
+	pub const fn div(self, scalar: u64) -> Self {
+		Self { ref_time: self.ref_time / scalar, proof_size: self.proof_size / scalar }
+	}
+
+	/// Constant version of Mul with u64.
+	///
+	/// Is only overflow safe when evaluated at compile-time.
+	pub const fn mul(self, scalar: u64) -> Self {
+		Self { ref_time: self.ref_time * scalar, proof_size: self.proof_size * scalar }
+	}
+
+	/// Returns true if any of `self`'s constituent weights is strictly greater than that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn any_gt(self, other: Self) -> bool {
+		self.ref_time > other.ref_time || self.proof_size > other.proof_size
+	}
+
+	/// Returns true if all of `self`'s constituent weights is strictly greater than that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn all_gt(self, other: Self) -> bool {
+		self.ref_time > other.ref_time && self.proof_size > other.proof_size
+	}
+
+	/// Returns true if any of `self`'s constituent weights is strictly less than that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn any_lt(self, other: Self) -> bool {
+		self.ref_time < other.ref_time || self.proof_size < other.proof_size
+	}
+
+	/// Returns true if all of `self`'s constituent weights is strictly less than that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn all_lt(self, other: Self) -> bool {
+		self.ref_time < other.ref_time && self.proof_size < other.proof_size
+	}
+
+	/// Returns true if any of `self`'s constituent weights is greater than or equal to that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn any_gte(self, other: Self) -> bool {
+		self.ref_time >= other.ref_time || self.proof_size >= other.proof_size
+	}
+
+	/// Returns true if all of `self`'s constituent weights is greater than or equal to that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn all_gte(self, other: Self) -> bool {
+		self.ref_time >= other.ref_time && self.proof_size >= other.proof_size
+	}
+
+	/// Returns true if any of `self`'s constituent weights is less than or equal to that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn any_lte(self, other: Self) -> bool {
+		self.ref_time <= other.ref_time || self.proof_size <= other.proof_size
+	}
+
+	/// Returns true if all of `self`'s constituent weights is less than or equal to that of the
+	/// `other`'s, otherwise returns false.
+	pub const fn all_lte(self, other: Self) -> bool {
+		self.ref_time <= other.ref_time && self.proof_size <= other.proof_size
+	}
+
+	/// Returns true if any of `self`'s constituent weights is equal to that of the `other`'s,
+	/// otherwise returns false.
+	pub const fn any_eq(self, other: Self) -> bool {
+		self.ref_time == other.ref_time || self.proof_size == other.proof_size
+	}
+
+	// NOTE: `all_eq` does not exist, as it's simply the `eq` method from the `PartialEq` trait.
+}
+
+impl Zero for Weight {
+	fn zero() -> Self {
+		Self::zero()
+	}
+
+	fn is_zero(&self) -> bool {
+		self == &Self::zero()
+	}
+}
+
+impl Add for Weight {
+	type Output = Self;
+	fn add(self, rhs: Self) -> Self {
+		Self {
+			ref_time: self.ref_time + rhs.ref_time,
+			proof_size: self.proof_size + rhs.proof_size,
+		}
+	}
+}
+
+impl Sub for Weight {
+	type Output = Self;
+	fn sub(self, rhs: Self) -> Self {
+		Self {
+			ref_time: self.ref_time - rhs.ref_time,
+			proof_size: self.proof_size - rhs.proof_size,
+		}
+	}
+}
+
+impl<T> Mul<T> for Weight
+where
+	T: Mul<u64, Output = u64> + Copy,
+{
+	type Output = Self;
+	fn mul(self, b: T) -> Self {
+		Self { ref_time: b * self.ref_time, proof_size: b * self.proof_size }
+	}
+}
+
+#[cfg(any(test, feature = "std", feature = "runtime-benchmarks"))]
+impl From<u64> for Weight {
+	fn from(value: u64) -> Self {
+		Self::from_parts(value, value)
+	}
+}
+
+#[cfg(any(test, feature = "std", feature = "runtime-benchmarks"))]
+impl From<(u64, u64)> for Weight {
+	fn from(value: (u64, u64)) -> Self {
+		Self::from_parts(value.0, value.1)
+	}
+}
+
+macro_rules! weight_mul_per_impl {
+	($($t:ty),* $(,)?) => {
+		$(
+			impl Mul<Weight> for $t {
+				type Output = Weight;
+				fn mul(self, b: Weight) -> Weight {
+					Weight {
+						ref_time: self * b.ref_time,
+						proof_size: self * b.proof_size,
+					}
+				}
+			}
+		)*
+	}
+}
+weight_mul_per_impl!(
+	sp_arithmetic::Percent,
+	sp_arithmetic::PerU16,
+	sp_arithmetic::Permill,
+	sp_arithmetic::Perbill,
+	sp_arithmetic::Perquintill,
+);
+
+macro_rules! weight_mul_primitive_impl {
+	($($t:ty),* $(,)?) => {
+		$(
+			impl Mul<Weight> for $t {
+				type Output = Weight;
+				fn mul(self, b: Weight) -> Weight {
+					Weight {
+						ref_time: u64::from(self) * b.ref_time,
+						proof_size: u64::from(self) * b.proof_size,
+					}
+				}
+			}
+		)*
+	}
+}
+weight_mul_primitive_impl!(u8, u16, u32, u64);
+
+impl<T> Div<T> for Weight
+where
+	u64: Div<T, Output = u64>,
+	T: Copy,
+{
+	type Output = Self;
+	fn div(self, b: T) -> Self {
+		Self { ref_time: self.ref_time / b, proof_size: self.proof_size / b }
+	}
+}
+
+impl CheckedAdd for Weight {
+	fn checked_add(&self, rhs: &Self) -> Option<Self> {
+		self.checked_add(rhs)
+	}
+}
+
+impl CheckedSub for Weight {
+	fn checked_sub(&self, rhs: &Self) -> Option<Self> {
+		self.checked_sub(rhs)
+	}
+}
+
+impl core::fmt::Display for Weight {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+		write!(f, "Weight(ref_time: {}, proof_size: {})", self.ref_time, self.proof_size)
+	}
+}
+
+impl Bounded for Weight {
+	fn min_value() -> Self {
+		Zero::zero()
+	}
+	fn max_value() -> Self {
+		Self::MAX
+	}
+}
+
+impl AddAssign for Weight {
+	fn add_assign(&mut self, other: Self) {
+		*self = Self {
+			ref_time: self.ref_time + other.ref_time,
+			proof_size: self.proof_size + other.proof_size,
+		};
+	}
+}
+
+impl SubAssign for Weight {
+	fn sub_assign(&mut self, other: Self) {
+		*self = Self {
+			ref_time: self.ref_time - other.ref_time,
+			proof_size: self.proof_size - other.proof_size,
+		};
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn is_zero_works() {
+		assert!(Weight::zero().is_zero());
+		assert!(!Weight::from_parts(1, 0).is_zero());
+		assert!(!Weight::from_parts(0, 1).is_zero());
+		assert!(!Weight::MAX.is_zero());
+	}
+
+	#[test]
+	fn from_parts_works() {
+		assert_eq!(Weight::from_parts(0, 0), Weight { ref_time: 0, proof_size: 0 });
+		assert_eq!(Weight::from_parts(5, 5), Weight { ref_time: 5, proof_size: 5 });
+		assert_eq!(
+			Weight::from_parts(u64::MAX, u64::MAX),
+			Weight { ref_time: u64::MAX, proof_size: u64::MAX }
+		);
+	}
+
+	#[test]
+	fn from_all_works() {
+		assert_eq!(Weight::from_all(0), Weight::from_parts(0, 0));
+		assert_eq!(Weight::from_all(5), Weight::from_parts(5, 5));
+		assert_eq!(Weight::from_all(u64::MAX), Weight::from_parts(u64::MAX, u64::MAX));
+	}
+
+	#[test]
+	fn from_u64_works() {
+		assert_eq!(Weight::from_all(0), 0_u64.into());
+		assert_eq!(Weight::from_all(123), 123_u64.into());
+		assert_eq!(Weight::from_all(u64::MAX), u64::MAX.into());
+	}
+
+	#[test]
+	fn from_u64_pair_works() {
+		assert_eq!(Weight::from_parts(0, 1), (0, 1).into());
+		assert_eq!(Weight::from_parts(123, 321), (123u64, 321u64).into());
+		assert_eq!(Weight::from_parts(u64::MAX, 0), (u64::MAX, 0).into());
+	}
+
+	#[test]
+	fn saturating_reduce_works() {
+		let mut weight = Weight::from_parts(10, 20);
+		weight.saturating_reduce(Weight::from_all(5));
+		assert_eq!(weight, Weight::from_parts(5, 15));
+		weight.saturating_reduce(Weight::from_all(5));
+		assert_eq!(weight, Weight::from_parts(0, 10));
+		weight.saturating_reduce(Weight::from_all(11));
+		assert!(weight.is_zero());
+		weight.saturating_reduce(Weight::from_all(u64::MAX));
+		assert!(weight.is_zero());
+	}
+
+	#[test]
+	fn checked_accrue_works() {
+		let mut weight = Weight::from_parts(10, 20);
+		assert!(weight.checked_accrue(Weight::from_all(2)).is_some());
+		assert_eq!(weight, Weight::from_parts(12, 22));
+		assert!(weight.checked_accrue(Weight::from_parts(u64::MAX, 0)).is_none());
+		assert!(weight.checked_accrue(Weight::from_parts(0, u64::MAX)).is_none());
+		assert_eq!(weight, Weight::from_parts(12, 22));
+		assert!(weight
+			.checked_accrue(Weight::from_parts(u64::MAX - 12, u64::MAX - 22))
+			.is_some());
+		assert_eq!(weight, Weight::MAX);
+		assert!(weight.checked_accrue(Weight::from_parts(1, 0)).is_none());
+		assert!(weight.checked_accrue(Weight::from_parts(0, 1)).is_none());
+		assert_eq!(weight, Weight::MAX);
+	}
+
+	#[test]
+	fn checked_reduce_works() {
+		let mut weight = Weight::from_parts(10, 20);
+		assert!(weight.checked_reduce(Weight::from_all(2)).is_some());
+		assert_eq!(weight, Weight::from_parts(8, 18));
+		assert!(weight.checked_reduce(Weight::from_parts(9, 0)).is_none());
+		assert!(weight.checked_reduce(Weight::from_parts(0, 19)).is_none());
+		assert_eq!(weight, Weight::from_parts(8, 18));
+		assert!(weight.checked_reduce(Weight::from_parts(8, 0)).is_some());
+		assert_eq!(weight, Weight::from_parts(0, 18));
+		assert!(weight.checked_reduce(Weight::from_parts(0, 18)).is_some());
+		assert!(weight.is_zero());
+	}
+
+	#[test]
+	fn checked_div_per_component_works() {
+		assert_eq!(
+			Weight::from_parts(10, 20).checked_div_per_component(&Weight::from_parts(2, 10)),
+			Some(2)
+		);
+		assert_eq!(
+			Weight::from_parts(10, 200).checked_div_per_component(&Weight::from_parts(2, 10)),
+			Some(5)
+		);
+		assert_eq!(
+			Weight::from_parts(10, 200).checked_div_per_component(&Weight::from_parts(1, 10)),
+			Some(10)
+		);
+		assert_eq!(
+			Weight::from_parts(10, 200).checked_div_per_component(&Weight::from_parts(2, 1)),
+			Some(5)
+		);
+		assert_eq!(
+			Weight::from_parts(10, 200).checked_div_per_component(&Weight::from_parts(0, 10)),
+			Some(20)
+		);
+		assert_eq!(
+			Weight::from_parts(10, 200).checked_div_per_component(&Weight::from_parts(1, 0)),
+			Some(10)
+		);
+		assert_eq!(
+			Weight::from_parts(0, 200).checked_div_per_component(&Weight::from_parts(2, 3)),
+			Some(0)
+		);
+		assert_eq!(
+			Weight::from_parts(10, 0).checked_div_per_component(&Weight::from_parts(2, 3)),
+			Some(0)
+		);
+		assert_eq!(
+			Weight::from_parts(10, 200).checked_div_per_component(&Weight::from_parts(0, 0)),
+			None,
+		);
+		assert_eq!(
+			Weight::from_parts(0, 0).checked_div_per_component(&Weight::from_parts(0, 0)),
+			None,
+		);
+	}
+}
diff --git a/substrate/rustfmt.toml b/substrate/rustfmt.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f6fbe80064fce44b2417af4f8a6929ce7a7a47ef
--- /dev/null
+++ b/substrate/rustfmt.toml
@@ -0,0 +1,24 @@
+# Basic
+hard_tabs = true
+max_width = 100
+use_small_heuristics = "Max"
+# Imports
+imports_granularity = "Crate"
+reorder_imports = true
+# Consistency
+newline_style = "Unix"
+# Format comments
+comment_width = 100
+wrap_comments = true
+# Misc
+chain_width = 80
+spaces_around_ranges = false
+binop_separator = "Back"
+reorder_impl_items = false
+match_arm_leading_pipes = "Preserve"
+match_arm_blocks = false
+match_block_trailing_comma = true
+trailing_comma = "Vertical"
+trailing_semicolon = false
+use_field_init_shorthand = true
+edition = "2021"
diff --git a/substrate/scripts/ci/common/lib.sh b/substrate/scripts/ci/common/lib.sh
new file mode 100755
index 0000000000000000000000000000000000000000..08c2fe81ada04bb6efcacb67833cfd78cccfe208
--- /dev/null
+++ b/substrate/scripts/ci/common/lib.sh
@@ -0,0 +1,117 @@
+#!/bin/sh
+
+api_base="https://api.github.com/repos"
+
+# Function to take 2 git tags/commits and get any lines from commit messages
+# that contain something that looks like a PR reference: e.g., (#1234)
+sanitised_git_logs(){
+  git --no-pager log --pretty=format:"%s" "$1...$2" |
+  # Only find messages referencing a PR
+  grep -E '\(#[0-9]+\)' |
+  # Strip any asterisks
+  sed 's/^* //g' |
+  # And add them all back
+  sed 's/^/* /g'
+}
+
+# Returns the last published release on github
+# Note: we can't just use /latest because that ignores prereleases
+# repo: 'organization/repo'
+# Usage: last_github_release "$repo"
+last_github_release(){
+  i=0
+  # Iterate over releases until we find the last release that's not just a draft
+  while [ $i -lt 29 ]; do
+    out=$(curl -H "Authorization: token $GITHUB_RELEASE_TOKEN" -s "$api_base/$1/releases" | jq ".[$i]")
+    echo "$out"
+    # Ugh when echoing to jq, we need to translate newlines into spaces :/
+    if [ "$(echo "$out" | tr '\r\n' ' ' | jq '.draft')" = "false" ]; then
+      echo "$out" | tr '\r\n' ' ' | jq '.tag_name'
+      return
+    else
+      i=$((i + 1))
+    fi
+  done
+}
+
+# Checks whether a tag on github has been verified
+# repo: 'organization/repo'
+# tagver: 'v1.2.3'
+# Usage: check_tag $repo $tagver
+check_tag () {
+  repo=$1
+  tagver=$2
+  tag_out=$(curl -H "Authorization: token $GITHUB_RELEASE_TOKEN" -s "$api_base/$repo/git/refs/tags/$tagver")
+  tag_sha=$(echo "$tag_out" | jq -r .object.sha)
+  object_url=$(echo "$tag_out" | jq -r .object.url)
+  if [ "$tag_sha" = "null" ]; then
+    return 2
+  fi
+  verified_str=$(curl -H "Authorization: token $GITHUB_RELEASE_TOKEN" -s "$object_url" | jq -r .verification.verified)
+  if [ "$verified_str" = "true" ]; then
+    # Verified, everything is good
+    return 0
+  else
+    # Not verified. Bad juju.
+    return 1
+  fi
+}
+
+# Checks whether a given PR has a given label.
+# repo: 'organization/repo'
+# pr_id: 12345
+# label: B1-silent
+# Usage: has_label $repo $pr_id $label
+has_label(){
+  repo="$1"
+  pr_id="$2"
+  label="$3"
+
+  # These will exist if the function is called in Gitlab.
+  # If the function's called in Github, we should have GITHUB_ACCESS_TOKEN set
+  # already.
+  if [ -n "$GITHUB_RELEASE_TOKEN" ]; then
+    GITHUB_TOKEN="$GITHUB_RELEASE_TOKEN"
+  elif [ -n "$GITHUB_PR_TOKEN" ]; then
+    GITHUB_TOKEN="$GITHUB_PR_TOKEN"
+  fi
+
+  out=$(curl -H "Authorization: token $GITHUB_TOKEN" -s "$api_base/$repo/pulls/$pr_id")
+  [ -n "$(echo "$out" | tr -d '\r\n' | jq ".labels | .[] | select(.name==\"$label\")")" ]
+}
+
+# Formats a message into a JSON string for posting to Matrix
+# message: 'any plaintext message'
+# formatted_message: '<strong>optional message formatted in <em>html</em></strong>'
+# Usage: structure_message $content $formatted_content (optional)
+structure_message() {
+  if [ -z "$2" ]; then
+    body=$(jq -Rs --arg body "$1" '{"msgtype": "m.text", $body}' < /dev/null)
+  else
+    body=$(jq -Rs --arg body "$1" --arg formatted_body "$2" '{"msgtype": "m.text", $body, "format": "org.matrix.custom.html", $formatted_body}' < /dev/null)
+  fi
+  echo "$body"
+}
+
+# Post a message to a matrix room
+# body: '{body: "JSON string produced by structure_message"}'
+# room_id: !fsfSRjgjBWEWffws:matrix.parity.io
+# access_token: see https://matrix.org/docs/guides/client-server-api/
+# Usage: send_message $body (json formatted) $room_id $access_token
+send_message() {
+  curl -XPOST -d "$1" "https://m.parity.io/_matrix/client/r0/rooms/$2/send/m.room.message?access_token=$3"
+}
+
+# Check for runtime changes between two commits. This is defined as any changes
+# to bin/node/src/runtime, frame/ and primitives/sr_* trees.
+has_runtime_changes() {
+  from=$1
+  to=$2
+  if git diff --name-only "${from}...${to}" \
+    | grep -q -e '^frame/' -e '^primitives/'
+  then
+    return 0
+  else
+    return 1
+  fi
+}
diff --git a/substrate/scripts/ci/deny.toml b/substrate/scripts/ci/deny.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5297d07143c225b65290b22ff4728be87a0261cb
--- /dev/null
+++ b/substrate/scripts/ci/deny.toml
@@ -0,0 +1,118 @@
+[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-cli" },
+    { 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-network" },
+    { allow = ["GPL-3.0 WITH Classpath-exception-2.0"], name = "sc-network-bitswap" },
+    { 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-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-network-statement" },
+    { 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 = "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/scripts/ci/docker/subkey.Dockerfile b/substrate/scripts/ci/docker/subkey.Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..a24595d915a1a44662a1339d7e7c76e55118ab9c
--- /dev/null
+++ b/substrate/scripts/ci/docker/subkey.Dockerfile
@@ -0,0 +1,31 @@
+FROM docker.io/library/ubuntu:20.04
+
+# metadata
+ARG VCS_REF
+ARG BUILD_DATE
+ARG IMAGE_NAME
+
+LABEL io.parity.image.authors="devops-team@parity.io" \
+	io.parity.image.vendor="Parity Technologies" \
+	io.parity.image.title="${IMAGE_NAME}" \
+	io.parity.image.description="Subkey: key generating utility for Substrate." \
+	io.parity.image.source="https://github.com/paritytech/substrate/blob/${VCS_REF}/scripts/ci/docker/subkey.Dockerfile" \
+	io.parity.image.revision="${VCS_REF}" \
+	io.parity.image.created="${BUILD_DATE}" \
+	io.parity.image.documentation="https://github.com/paritytech/substrate/tree/${VCS_REF}/subkey"
+
+# show backtraces
+ENV RUST_BACKTRACE 1
+
+# add user
+RUN useradd -m -u 1000 -U -s /bin/sh -d /subkey subkey
+
+# add subkey binary to docker image
+COPY ./subkey /usr/local/bin
+
+USER subkey
+
+# check if executable works in this container
+RUN /usr/local/bin/subkey --version
+
+ENTRYPOINT ["/usr/local/bin/subkey"]
diff --git a/substrate/scripts/ci/docker/subkey.Dockerfile.README.md b/substrate/scripts/ci/docker/subkey.Dockerfile.README.md
new file mode 100644
index 0000000000000000000000000000000000000000..30a5e8212150e1035075893def8b0f13f6678fa2
--- /dev/null
+++ b/substrate/scripts/ci/docker/subkey.Dockerfile.README.md
@@ -0,0 +1,8 @@
+# The `subkey` program is a key management utility for Substrate-based blockchains. You can use the `subkey` program to perform the following tasks:
+
+* Generate and inspect cryptographically-secure public and private key pairs.
+* Restore keys from secret phrases and raw seeds.
+* Sign and verify signatures on messages.
+* Sign and verify signatures for encoded transactions.
+* Derive hierarchical deterministic child key pairs.
+* [Documentation](https://docs.substrate.io/reference/command-line-tools/subkey/)
\ No newline at end of file
diff --git a/substrate/scripts/ci/docker/substrate.Dockerfile b/substrate/scripts/ci/docker/substrate.Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..5c7909afc0eec790fa30af50201462af5538e3c6
--- /dev/null
+++ b/substrate/scripts/ci/docker/substrate.Dockerfile
@@ -0,0 +1,45 @@
+FROM docker.io/library/ubuntu:20.04
+
+# metadata
+ARG VCS_REF
+ARG BUILD_DATE
+ARG IMAGE_NAME
+
+LABEL io.parity.image.authors="devops-team@parity.io" \
+	io.parity.image.vendor="Parity Technologies" \
+	io.parity.image.title="${IMAGE_NAME}" \
+	io.parity.image.description="Substrate: The platform for blockchain innovators." \
+	io.parity.image.source="https://github.com/paritytech/substrate/blob/${VCS_REF}/scripts/ci/docker/Dockerfile" \
+	io.parity.image.revision="${VCS_REF}" \
+	io.parity.image.created="${BUILD_DATE}" \
+	io.parity.image.documentation="https://wiki.parity.io/Parity-Substrate"
+
+# show backtraces
+ENV RUST_BACKTRACE 1
+
+# install tools and dependencies
+RUN apt-get update && \
+	DEBIAN_FRONTEND=noninteractive apt-get upgrade -y && \
+	DEBIAN_FRONTEND=noninteractive apt-get install -y \
+		libssl1.1 \
+		ca-certificates \
+		curl && \
+# apt cleanup
+	apt-get autoremove -y && \
+	apt-get clean && \
+	find /var/lib/apt/lists/ -type f -not -name lock -delete; \
+# add user
+	useradd -m -u 1000 -U -s /bin/sh -d /substrate substrate
+
+# add substrate binary to docker image
+COPY ./substrate /usr/local/bin
+
+USER substrate
+
+# check if executable works in this container
+RUN /usr/local/bin/substrate --version
+
+EXPOSE 30333 9933 9944
+VOLUME ["/substrate"]
+
+ENTRYPOINT ["/usr/local/bin/substrate"]
diff --git a/substrate/scripts/ci/docker/substrate.Dockerfile.README.md b/substrate/scripts/ci/docker/substrate.Dockerfile.README.md
new file mode 100644
index 0000000000000000000000000000000000000000..557fd8f835d73ac5628f33f1ea086b174803e69c
--- /dev/null
+++ b/substrate/scripts/ci/docker/substrate.Dockerfile.README.md
@@ -0,0 +1 @@
+# Substrate Docker Image
\ No newline at end of file
diff --git a/substrate/scripts/ci/github/check_labels.sh b/substrate/scripts/ci/github/check_labels.sh
new file mode 100755
index 0000000000000000000000000000000000000000..7b0aed9fe73455d01a15c19bba83592eb1989747
--- /dev/null
+++ b/substrate/scripts/ci/github/check_labels.sh
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+set -e
+
+#shellcheck source=../common/lib.sh
+source "$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )/../common/lib.sh"
+
+repo="$GITHUB_REPOSITORY"
+pr="$GITHUB_PR"
+
+ensure_labels() {
+  for label in "$@"; do
+    if has_label "$repo" "$pr" "$label"; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+# Must have one of the following labels
+releasenotes_labels=(
+  'B0-silent'
+  'B3-apinoteworthy'
+  'B5-clientnoteworthy'
+  'B7-runtimenoteworthy'
+)
+
+criticality_labels=(
+  'C1-low 📌'
+  'C3-medium 📣'
+  'C7-high ��'
+  'C9-critical ‼�'
+)
+
+audit_labels=(
+  'D1-audited �'
+  'D2-notlive 💤'
+  'D3-trivial 🧸'
+  'D5-nicetohaveaudit ⚠�'
+  'D9-needsaudit 👮'
+)
+
+echo "[+] Checking release notes (B) labels"
+if ensure_labels "${releasenotes_labels[@]}";  then
+  echo "[+] Release notes label detected. All is well."
+else
+  echo "[!] Release notes label not detected. Please add one of: ${releasenotes_labels[*]}"
+  exit 1
+fi
+
+echo "[+] Checking release criticality (C) labels"
+if ensure_labels "${criticality_labels[@]}";  then
+  echo "[+] Release criticality label detected. All is well."
+else
+  echo "[!] Release criticality label not detected. Please add one of: ${criticality_labels[*]}"
+  exit 1
+fi
+
+if has_runtime_changes origin/master "${HEAD_SHA}"; then
+  echo "[+] Runtime changes detected. Checking audit (D) labels"
+  if ensure_labels "${audit_labels[@]}";  then
+    echo "[+] Release audit label detected. All is well."
+  else
+    echo "[!] Release audit label not detected. Please add one of: ${audit_labels[*]}"
+    exit 1
+  fi
+fi
+
+exit 0
diff --git a/substrate/scripts/ci/github/generate_changelog.sh b/substrate/scripts/ci/github/generate_changelog.sh
new file mode 100755
index 0000000000000000000000000000000000000000..32ac1760a6117846ca5a32f7a9058db1fbf7cc5c
--- /dev/null
+++ b/substrate/scripts/ci/github/generate_changelog.sh
@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+
+# shellcheck source=../common/lib.sh
+source "$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )/../common/lib.sh"
+
+version="$2"
+last_version="$1"
+
+all_changes="$(sanitised_git_logs "$last_version" "$version")"
+runtime_changes=""
+api_changes=""
+client_changes=""
+changes=""
+migrations=""
+
+while IFS= read -r line; do
+  pr_id=$(echo "$line" | sed -E 's/.*#([0-9]+)\)$/\1/')
+
+  # Skip if the PR has the silent label - this allows us to skip a few requests
+  if has_label 'paritytech/substrate' "$pr_id" 'B0-silent'; then
+    continue
+  fi
+  if has_label 'paritytech/substrate' "$pr_id" 'B3-apinoteworthy' ; then
+    api_changes="$api_changes
+$line"
+  fi
+  if has_label 'paritytech/substrate' "$pr_id" 'B5-clientnoteworthy'; then
+    client_changes="$client_changes
+$line"
+  fi
+  if has_label 'paritytech/substrate' "$pr_id" 'B7-runtimenoteworthy'; then
+    runtime_changes="$runtime_changes
+$line"
+  fi
+  if has_label 'paritytech/substrate' "$pr_id" 'E1-runtime-migration'; then
+    migrations="$migrations
+$line"
+  fi
+done <<< "$all_changes"
+
+# Make the substrate section if there are any substrate changes
+if [ -n "$runtime_changes" ] ||
+   [ -n "$api_changes" ] ||
+   [ -n "$client_changes" ] ||
+   [ -n "$migrations" ]; then
+  changes=$(cat << EOF
+Substrate changes
+-----------------
+
+EOF
+)
+  if [ -n "$runtime_changes" ]; then
+    changes="$changes
+
+Runtime
+-------
+$runtime_changes"
+  fi
+  if [ -n "$client_changes" ]; then
+    changes="$changes
+
+Client
+------
+$client_changes"
+  fi
+  if [ -n "$api_changes" ]; then
+    changes="$changes
+
+API
+---
+$api_changes"
+  fi
+  release_text="$release_text
+
+$changes"
+fi
+if [ -n "$migrations" ]; then
+  changes="$changes
+
+Runtime Migrations
+------------------
+$migrations"
+fi
+
+echo "$changes"
diff --git a/substrate/scripts/ci/gitlab/check-each-crate.py b/substrate/scripts/ci/gitlab/check-each-crate.py
new file mode 100755
index 0000000000000000000000000000000000000000..adad4f5bd583543b4610cd010a9cefbd04bc5401
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/check-each-crate.py
@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+# A script that checks each workspace crate individually.
+# It's relevant to check workspace crates individually because otherwise their compilation problems
+# due to feature misconfigurations won't be caught, as exemplified by
+# https://github.com/paritytech/substrate/issues/12705
+#
+# `check-each-crate.py target_group groups_total`
+#
+# - `target_group`: Integer starting from 1, the group this script should execute.
+# - `groups_total`: Integer starting from 1, total number of groups.
+
+import subprocess, sys
+
+# Get all crates
+output = subprocess.check_output(["cargo", "tree", "--locked", "--workspace", "--depth", "0", "--prefix", "none"])
+
+# Convert the output into a proper list
+crates = []
+for line in output.splitlines():
+	if line != b"":
+		crates.append(line.decode('utf8').split(" ")[0])
+
+# Make the list unique and sorted
+crates = list(set(crates))
+crates.sort()
+
+target_group = int(sys.argv[1]) - 1
+groups_total = int(sys.argv[2])
+
+if len(crates) == 0:
+	print("No crates detected!", file=sys.stderr)
+	sys.exit(1)
+
+print(f"Total crates: {len(crates)}", file=sys.stderr)
+
+crates_per_group = len(crates) // groups_total
+
+# If this is the last runner, we need to take care of crates
+# after the group that we lost because of the integer division.
+if target_group + 1 == groups_total:
+	overflow_crates = len(crates) % groups_total
+else:
+	overflow_crates = 0
+
+print(f"Crates per group: {crates_per_group}", file=sys.stderr)
+
+# Check each crate
+for i in range(0, crates_per_group + overflow_crates):
+	crate = crates_per_group * target_group + i
+
+	print(f"Checking {crates[crate]}", file=sys.stderr)
+
+	res = subprocess.run(["cargo", "check", "--locked", "-p", crates[crate]])
+
+	if res.returncode != 0:
+		sys.exit(1)
diff --git a/substrate/scripts/ci/gitlab/check_runtime.sh b/substrate/scripts/ci/gitlab/check_runtime.sh
new file mode 100755
index 0000000000000000000000000000000000000000..71d6965ecf4fb028b7e08a507125a4ba4ca1330e
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/check_runtime.sh
@@ -0,0 +1,121 @@
+#!/bin/sh
+#
+#
+# check for any changes in the node/src/runtime, frame/ and primitives/sr_* trees. if
+# there are any changes found, it should mark the PR breaksconsensus and
+# "auto-fail" the PR if there isn't a change in the runtime/src/lib.rs file
+# that alters the version.
+
+set -e # fail on any error
+
+#shellcheck source=../common/lib.sh
+. "$(dirname "${0}")/../common/lib.sh"
+
+VERSIONS_FILE="bin/node/runtime/src/lib.rs"
+
+boldprint () { printf "|\n| \033[1m%s\033[0m\n|\n" "${@}"; }
+boldcat () { printf "|\n"; while read -r l; do printf "| \033[1m%s\033[0m\n" "${l}"; done; printf "|\n" ; }
+
+github_label () {
+	echo
+	echo "# run github-api job for labeling it ${1}"
+	curl -sS -X POST \
+		-F "token=${CI_JOB_TOKEN}" \
+		-F "ref=master" \
+		-F "variables[LABEL]=${1}" \
+		-F "variables[PRNO]=${CI_COMMIT_REF_NAME}" \
+		"${GITLAB_API}/projects/${GITHUB_API_PROJECT}/trigger/pipeline"
+}
+
+
+boldprint "latest 10 commits of ${CI_COMMIT_REF_NAME}"
+git log --graph --oneline --decorate=short -n 10
+
+boldprint "make sure the master branch and release tag are available in shallow clones"
+git fetch --depth="${GIT_DEPTH:-100}" origin master
+git fetch --depth="${GIT_DEPTH:-100}" origin release
+git tag -f release FETCH_HEAD
+git log -n1 release
+
+
+boldprint "check if the wasm sources changed"
+if ! has_runtime_changes origin/master "${CI_COMMIT_SHA}"
+then
+	boldcat <<-EOT
+
+	no changes to the runtime source code detected
+
+	EOT
+
+	exit 0
+fi
+
+
+
+# check for spec_version updates: if the spec versions changed, then there is
+# consensus-critical logic that has changed. the runtime wasm blobs must be
+# rebuilt.
+
+add_spec_version="$(git diff tags/release ${CI_COMMIT_SHA} -- "${VERSIONS_FILE}" \
+	| sed -n -r "s/^\+[[:space:]]+spec_version: +([0-9]+),$/\1/p")"
+sub_spec_version="$(git diff tags/release ${CI_COMMIT_SHA} -- "${VERSIONS_FILE}" \
+	| sed -n -r "s/^\-[[:space:]]+spec_version: +([0-9]+),$/\1/p")"
+
+
+
+if [ "${add_spec_version}" != "${sub_spec_version}" ]
+then
+
+	boldcat <<-EOT
+
+		changes to the runtime sources and changes in the spec version.
+
+		spec_version: ${sub_spec_version} -> ${add_spec_version}
+
+	EOT
+	exit 0
+
+else
+	# check for impl_version updates: if only the impl versions changed, we assume
+	# there is no consensus-critical logic that has changed.
+
+	add_impl_version="$(git diff tags/release ${CI_COMMIT_SHA} -- "${VERSIONS_FILE}" \
+		| sed -n -r 's/^\+[[:space:]]+impl_version: +([0-9]+),$/\1/p')"
+	sub_impl_version="$(git diff tags/release ${CI_COMMIT_SHA} -- "${VERSIONS_FILE}" \
+		| sed -n -r 's/^\-[[:space:]]+impl_version: +([0-9]+),$/\1/p')"
+
+
+	# see if the impl version changed
+	if [ "${add_impl_version}" != "${sub_impl_version}" ]
+	then
+		boldcat <<-EOT
+
+		changes to the runtime sources and changes in the impl version.
+
+		impl_version: ${sub_impl_version} -> ${add_impl_version}
+
+		EOT
+		exit 0
+	fi
+
+
+	boldcat <<-EOT
+
+	wasm source files changed but not the spec/impl version. If changes made do not alter logic,
+	just bump 'impl_version'. If they do change logic, bump 'spec_version'.
+
+	source file directories:
+	- bin/node/src/runtime
+	- frame
+	- primitives/sr-*
+
+	versions file: ${VERSIONS_FILE}
+
+	EOT
+fi
+
+# dropped through. there's something wrong;  exit 1.
+
+exit 1
+
+# vim: noexpandtab
diff --git a/substrate/scripts/ci/gitlab/check_signed.sh b/substrate/scripts/ci/gitlab/check_signed.sh
new file mode 100755
index 0000000000000000000000000000000000000000..20d47c2304767e0d61e6ac7cd4b08afe27dfc97e
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/check_signed.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+# shellcheck source=../common/lib.sh
+source "$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )/../common/lib.sh"
+
+version="$CI_COMMIT_TAG"
+
+echo '[+] Checking tag has been signed'
+check_tag "paritytech/substrate" "$version"
+case $? in
+  0) echo '[+] Tag found and has been signed'; exit 0
+    ;;
+  1) echo '[!] Tag found but has not been signed. Aborting release.'; exit 1
+    ;;
+  2) echo '[!] Tag not found. Aborting release.'; exit 1
+esac
diff --git a/substrate/scripts/ci/gitlab/ensure-deps.sh b/substrate/scripts/ci/gitlab/ensure-deps.sh
new file mode 100755
index 0000000000000000000000000000000000000000..7087200cef5185878431a89c013bacbd7417b4fd
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/ensure-deps.sh
@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+
+# The script is meant to check if the rules regarding packages
+# dependencies are satisfied.
+# The general format is:
+# [top-lvl-dir] MESSAGE/[other-top-dir]
+
+# For instance no crate within `./client` directory
+# is allowed to import any crate with a directory path containing `frame`.
+# Such rule is just: `client crates must not depend on anything in /frame`.
+
+# The script should be run from the main repo directory!
+
+set -u
+
+# HARD FAILING
+MUST_NOT=(
+	"client crates must not depend on anything in /frame"
+	"client crates must not depend on anything in /node"
+	"frame crates must not depend on anything in /node"
+	"frame crates must not depend on anything in /client"
+	"primitives crates must not depend on anything in /frame"
+)
+
+# ONLY DISPLAYED, script still succeeds
+PLEASE_DONT=(
+	"primitives crates should not depend on anything in /client"
+)
+
+VIOLATIONS=()
+PACKAGES=()
+
+function check_rule() {
+	rule=$1
+	from=$(echo $rule | cut -f1 -d\ )
+	to=$(echo $rule | cut -f2 -d\/)
+
+	cd $from
+	echo "Checking rule '$rule'"
+	packages=$(find -name Cargo.toml | xargs grep -wn "path.*\.\.\/$to")
+	has_references=$(echo -n $packages | wc -c)
+	if [ "$has_references" != "0" ]; then
+		VIOLATIONS+=("$rule")
+		# Find packages that violate:
+		PACKAGES+=("$packages")
+	fi
+	cd - > /dev/null
+}
+
+for rule in "${MUST_NOT[@]}"
+do
+	check_rule "$rule";
+done
+
+# Only the MUST NOT will be counted towards failure
+HARD_VIOLATIONS=${#VIOLATIONS[@]}
+
+
+for rule in "${PLEASE_DONT[@]}"
+do
+	check_rule "$rule";
+done
+
+# Display violations and fail
+I=0
+for v in "${VIOLATIONS[@]}"
+do
+	cat << EOF
+
+===========================================
+======= Violation of rule: $v
+===========================================
+${PACKAGES[$I]}
+
+
+EOF
+	I=$I+1
+done
+
+exit $HARD_VIOLATIONS
diff --git a/substrate/scripts/ci/gitlab/pipeline/build.yml b/substrate/scripts/ci/gitlab/pipeline/build.yml
new file mode 100644
index 0000000000000000000000000000000000000000..8f63f6ecc3911270d5b12000e1a94ab6df35ef52
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/pipeline/build.yml
@@ -0,0 +1,215 @@
+# This file is part of .gitlab-ci.yml
+# Here are all jobs that are executed during "build" stage
+
+# PIPELINE_SCRIPTS_TAG can be found in the project variables
+
+.check-dependent-project:
+  stage: build
+  # DAG: this is artificial dependency
+  needs:
+    - job: cargo-clippy
+      artifacts: false
+  extends:
+    - .docker-env
+    - .test-refs-no-trigger-prs-only
+  variables:
+    RUSTFLAGS: "-D warnings"
+  script:
+    - cargo install --locked --git https://github.com/paritytech/try-runtime-cli --rev a93c9b5abe5d31a4cf1936204f7e5c489184b521
+    - git clone
+      --depth=1
+      --branch="$PIPELINE_SCRIPTS_TAG"
+      https://github.com/paritytech/pipeline-scripts
+    - ./pipeline-scripts/check_dependent_project.sh
+      --org paritytech
+      --dependent-repo "$DEPENDENT_REPO"
+      --github-api-token "$GITHUB_PR_TOKEN"
+      --extra-dependencies "$EXTRA_DEPENDENCIES"
+      --companion-overrides "$COMPANION_OVERRIDES"
+
+.check-runtime-migration:
+  extends:
+    - .check-dependent-project
+    - .test-refs-no-trigger-prs-only
+  variables:
+    DEPENDENT_REPO: polkadot
+    COMPANION_OVERRIDES: |
+      substrate: polkadot-v*
+      polkadot: release-v*
+    COMPANION_CHECK_COMMAND: >
+      time cargo build --release -p "$NETWORK"-runtime --features try-runtime &&
+      time try-runtime \
+          --runtime ./target/release/wbuild/"$NETWORK"-runtime/target/wasm32-unknown-unknown/release/"$NETWORK"_runtime.wasm \
+          on-runtime-upgrade --checks=pre-and-post live --uri wss://${NETWORK}-try-runtime-node.parity-chains.parity.io:443
+
+# Individual jobs are set up for each dependent project so that they can be ran in parallel.
+# Arguably we could generate a job for each companion in the PR's description using Gitlab's
+# parent-child pipelines but that's more complicated.
+
+check-runtime-migration-polkadot:
+  extends:
+    - .check-runtime-migration
+  variables:
+    NETWORK: polkadot
+
+check-runtime-migration-kusama:
+  extends: .check-runtime-migration
+  variables:
+    NETWORK: kusama
+
+check-runtime-migration-rococo:
+  extends: .check-runtime-migration
+  variables:
+    NETWORK: rococo
+  allow_failure: true
+
+check-runtime-migration-westend:
+  extends: .check-runtime-migration
+  variables:
+    NETWORK: westend
+
+check-dependent-polkadot:
+  extends: .check-dependent-project
+  variables:
+    DEPENDENT_REPO: polkadot
+    COMPANION_OVERRIDES: |
+      substrate: polkadot-v*
+      polkadot: release-v*
+    # enable the same feature flags as polkadot's test-linux-stable
+    COMPANION_CHECK_COMMAND: >
+      cargo check --all-targets --workspace
+      --features=runtime-benchmarks,runtime-metrics,try-runtime
+  rules:
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ #PRs
+
+check-dependent-cumulus:
+  extends: .check-dependent-project
+  variables:
+    DEPENDENT_REPO: cumulus
+    EXTRA_DEPENDENCIES: polkadot
+    COMPANION_OVERRIDES: |
+      substrate: polkadot-v*
+      polkadot: release-v*
+  rules:
+    - if: $CI_COMMIT_REF_NAME =~ /^[0-9]+$/ #PRs
+
+build-linux-substrate:
+  stage: build
+  extends:
+    - .collect-artifacts
+    - .docker-env
+    - .build-refs
+  variables:
+    # this variable gets overriden by "rusty-cachier environment inject", use the value as default
+    CARGO_TARGET_DIR: "$CI_PROJECT_DIR/target"
+  needs:
+    - job: test-linux-stable
+      artifacts: false
+  before_script:
+    - !reference [.timestamp, before_script]
+    - !reference [.job-switcher, before_script]
+    - mkdir -p ./artifacts/substrate/
+    - !reference [.rusty-cachier, before_script]
+    # tldr: we need to checkout the branch HEAD explicitly because of our dynamic versioning approach while building the substrate binary
+    # see https://github.com/paritytech/ci_cd/issues/682#issuecomment-1340953589
+    - git checkout -B "$CI_COMMIT_REF_NAME" "$CI_COMMIT_SHA"
+  script:
+    - rusty-cachier snapshot create
+    - WASM_BUILD_NO_COLOR=1 time cargo build --locked --release -p node-cli --verbose
+    - mv $CARGO_TARGET_DIR/release/substrate-node ./artifacts/substrate/substrate
+    - echo -n "Substrate version = "
+    - if [ "${CI_COMMIT_TAG}" ]; then
+      echo "${CI_COMMIT_TAG}" | tee ./artifacts/substrate/VERSION;
+      else
+      ./artifacts/substrate/substrate --version |
+      cut -d ' ' -f 2 | tee ./artifacts/substrate/VERSION;
+      fi
+    - sha256sum ./artifacts/substrate/substrate | tee ./artifacts/substrate/substrate.sha256
+    - cp -r ./scripts/ci/docker/substrate.Dockerfile ./artifacts/substrate/
+    - printf '\n# building node-template\n\n'
+    - ./scripts/ci/node-template-release.sh ./artifacts/substrate/substrate-node-template.tar.gz
+    - rusty-cachier cache upload
+
+.build-subkey:
+  stage: build
+  extends:
+    - .collect-artifacts
+    - .docker-env
+    - .publish-refs
+  variables:
+    # this variable gets overriden by "rusty-cachier environment inject", use the value as default
+    CARGO_TARGET_DIR: "$CI_PROJECT_DIR/target"
+  before_script:
+    - !reference [.timestamp, before_script]
+    - !reference [.job-switcher, before_script]
+    - mkdir -p ./artifacts/subkey
+    - !reference [.rusty-cachier, before_script]
+  script:
+    - rusty-cachier snapshot create
+    - cd ./bin/utils/subkey
+    - SKIP_WASM_BUILD=1 time cargo build --locked --release --verbose
+    - cd -
+    - mv $CARGO_TARGET_DIR/release/subkey ./artifacts/subkey/.
+    - echo -n "Subkey version = "
+    - ./artifacts/subkey/subkey --version |
+      sed -n -E 's/^subkey ([0-9.]+.*)/\1/p' |
+      tee ./artifacts/subkey/VERSION;
+    - sha256sum ./artifacts/subkey/subkey | tee ./artifacts/subkey/subkey.sha256
+    - cp -r ./scripts/ci/docker/subkey.Dockerfile ./artifacts/subkey/
+    - rusty-cachier cache upload
+
+build-subkey-linux:
+  extends: .build-subkey
+
+build-subkey-macos:
+  extends: .build-subkey
+  # duplicating before_script & script sections from .build-subkey hidden job
+  # to overwrite rusty-cachier integration as it doesn't work on macos
+  before_script:
+    # skip timestamp script, the osx bash doesn't support printf %()T
+    - !reference [.job-switcher, before_script]
+    - mkdir -p ./artifacts/subkey
+  script:
+    - cd ./bin/utils/subkey
+    - SKIP_WASM_BUILD=1 time cargo build --locked --release --verbose
+    - cd -
+    - mv ./target/release/subkey ./artifacts/subkey/.
+    - echo -n "Subkey version = "
+    - ./artifacts/subkey/subkey --version |
+      sed -n -E 's/^subkey ([0-9.]+.*)/\1/p' |
+      tee ./artifacts/subkey/VERSION;
+    - sha256sum ./artifacts/subkey/subkey | tee ./artifacts/subkey/subkey.sha256
+    - cp -r ./scripts/ci/docker/subkey.Dockerfile ./artifacts/subkey/
+  after_script: [""]
+  tags:
+    - osx
+
+build-rustdoc:
+  stage: build
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    SKIP_WASM_BUILD: 1
+    DOC_INDEX_PAGE: "substrate/index.html" # default redirected page
+    # this variable gets overriden by "rusty-cachier environment inject", use the value as default
+    CARGO_TARGET_DIR: "$CI_PROJECT_DIR/target"
+  artifacts:
+    name: "${CI_JOB_NAME}_${CI_COMMIT_REF_NAME}-doc"
+    when: on_success
+    expire_in: 7 days
+    paths:
+      - ./crate-docs/
+  # DAG: this is artificial dependency
+  needs:
+    - job: cargo-clippy
+      artifacts: false
+  script:
+    - rusty-cachier snapshot create
+    - time cargo doc --locked --workspace --all-features --verbose --no-deps
+    - rm -f $CARGO_TARGET_DIR/doc/.lock
+    - mv $CARGO_TARGET_DIR/doc ./crate-docs
+    # FIXME: remove me after CI image gets nonroot
+    - chown -R nonroot:nonroot ./crate-docs
+    - echo "<meta http-equiv=refresh content=0;url=${DOC_INDEX_PAGE}>" > ./crate-docs/index.html
+    - rusty-cachier cache upload
diff --git a/substrate/scripts/ci/gitlab/pipeline/check.yml b/substrate/scripts/ci/gitlab/pipeline/check.yml
new file mode 100644
index 0000000000000000000000000000000000000000..576daec9b43311ff39cb076c1f8b706b4751db85
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/pipeline/check.yml
@@ -0,0 +1,78 @@
+# This file is part of .gitlab-ci.yml
+# Here are all jobs that are executed during "check" stage
+
+check-runtime:
+  stage: check
+  extends:
+    - .kubernetes-env
+    - .test-refs-no-trigger-prs-only
+  variables:
+    CI_IMAGE: "paritytech/tools:latest"
+    GITLAB_API: "https://gitlab.parity.io/api/v4"
+    GITHUB_API_PROJECT: "parity%2Finfrastructure%2Fgithub-api"
+  script:
+    - ./scripts/ci/gitlab/check_runtime.sh
+  allow_failure: true
+
+check-signed-tag:
+  stage: check
+  extends: .kubernetes-env
+  variables:
+    CI_IMAGE: "paritytech/tools:latest"
+  rules:
+    - if: $CI_COMMIT_REF_NAME =~ /^ci-release-.*$/
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+  script:
+    - ./scripts/ci/gitlab/check_signed.sh
+
+test-dependency-rules:
+  stage: check
+  extends:
+    - .kubernetes-env
+    - .test-refs-no-trigger-prs-only
+  variables:
+    CI_IMAGE: "paritytech/tools:latest"
+  script:
+    - ./scripts/ci/gitlab/ensure-deps.sh
+
+test-rust-features:
+  stage: check
+  extends:
+    - .kubernetes-env
+    - .test-refs-no-trigger-prs-only
+  script:
+    - git clone
+      --depth=1
+      --branch="$PIPELINE_SCRIPTS_TAG"
+      https://github.com/paritytech/pipeline-scripts
+    - bash ./pipeline-scripts/rust-features.sh .
+
+test-rust-feature-propagation:
+  stage: check
+  extends:
+    - .kubernetes-env
+    - .test-refs-no-trigger-prs-only
+  script:
+    - cargo install --locked --version 0.7.4 -q -f zepter && zepter --version
+    - echo "👉 Hello developer! If you see this CI check failing then it means that one of the crates is missing a feature for one of its dependencies. The output below tells you which feature needs to be added for which dependency to which crate. You can do this by modifying the Cargo.toml file. For more context see the MR where this check was introduced https://github.com/paritytech/substrate/pull/14660"
+    - zepter lint propagate-feature --feature try-runtime --left-side-feature-missing=ignore --workspace --feature-enables-dep="try-runtime:frame-try-runtime" --locked
+    - zepter lint propagate-feature --feature runtime-benchmarks --left-side-feature-missing=ignore --workspace --feature-enables-dep="runtime-benchmarks:frame-benchmarking" --locked
+    - zepter lint propagate-feature --feature std --left-side-feature-missing=ignore --workspace --locked
+  allow_failure: true # Experimental
+
+test-prometheus-alerting-rules:
+  stage: check
+  extends: .kubernetes-env
+  variables:
+    CI_IMAGE: "paritytech/tools:latest"
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    - if: $CI_COMMIT_BRANCH
+      changes:
+        - .gitlab-ci.yml
+        - ./scripts/ci/monitoring/**/*
+  script:
+    - promtool check rules ./scripts/ci/monitoring/alerting-rules/alerting-rules.yaml
+    - cat ./scripts/ci/monitoring/alerting-rules/alerting-rules.yaml |
+      promtool test rules ./scripts/ci/monitoring/alerting-rules/alerting-rule-tests.yaml
diff --git a/substrate/scripts/ci/gitlab/pipeline/publish.yml b/substrate/scripts/ci/gitlab/pipeline/publish.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c90af7ba347ba83914d35b100ec94f88886f54b1
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/pipeline/publish.yml
@@ -0,0 +1,270 @@
+# This file is part of .gitlab-ci.yml
+# Here are all jobs that are executed during "publish" stage
+
+.build-push-docker-image-common:
+  extends:
+    - .kubernetes-env
+  stage: publish
+  variables:
+    CI_IMAGE: $BUILDAH_IMAGE
+    GIT_STRATEGY: none
+    DOCKERFILE: $PRODUCT.Dockerfile
+    IMAGE_NAME: docker.io/$IMAGE_PATH
+  before_script:
+    - !reference [.kubernetes-env, before_script]
+    - cd ./artifacts/$PRODUCT/
+    - VERSION="$(cat ./VERSION)"
+    - echo "${PRODUCT} version = ${VERSION}"
+    - test -z "${VERSION}" && exit 1
+  script:
+    - test "$DOCKER_USER" -a "$DOCKER_PASS" ||
+      ( echo "no docker credentials provided"; exit 1 )
+    - $BUILDAH_COMMAND build
+      --format=docker
+      --build-arg VCS_REF="${CI_COMMIT_SHA}"
+      --build-arg BUILD_DATE="$(date -u '+%Y-%m-%dT%H:%M:%SZ')"
+      --build-arg IMAGE_NAME="${IMAGE_PATH}"
+      --tag "$IMAGE_NAME:$VERSION"
+      --tag "$IMAGE_NAME:latest"
+      --file "$DOCKERFILE" .
+    - echo "$DOCKER_PASS" |
+      buildah login --username "$DOCKER_USER" --password-stdin docker.io
+    - $BUILDAH_COMMAND info
+    - $BUILDAH_COMMAND push --format=v2s2 "$IMAGE_NAME:$VERSION"
+    - $BUILDAH_COMMAND push --format=v2s2 "$IMAGE_NAME:latest"
+  after_script:
+    - buildah logout --all
+    - echo "SUBSTRATE_IMAGE_NAME=${IMAGE_NAME}" | tee -a ./artifacts/$PRODUCT/build.env
+    - IMAGE_TAG="$(cat ./artifacts/$PRODUCT/VERSION)"
+    - echo "SUBSTRATE_IMAGE_TAG=${IMAGE_TAG}"   | tee -a ./artifacts/$PRODUCT/build.env
+    - cat ./artifacts/$PRODUCT/build.env
+
+.build-push-docker-image:
+  extends:
+    - .publish-refs
+    - .build-push-docker-image-common
+  variables:
+    IMAGE_PATH: parity/$PRODUCT
+    DOCKER_USER: $Docker_Hub_User_Parity
+    DOCKER_PASS: $Docker_Hub_Pass_Parity
+
+.push-docker-image-description:
+  stage: publish
+  extends:
+    - .kubernetes-env
+  variables:
+    CI_IMAGE: paritytech/dockerhub-description
+    DOCKERHUB_REPOSITORY: parity/$PRODUCT
+    DOCKER_USERNAME: $Docker_Hub_User_Parity
+    DOCKER_PASSWORD: $Docker_Hub_Pass_Parity
+    README_FILEPATH: $CI_PROJECT_DIR/scripts/ci/docker/$PRODUCT.Dockerfile.README.md
+  rules:
+    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE == "push"
+      changes:
+        - scripts/ci/docker/$PRODUCT.Dockerfile.README.md
+  before_script:
+    - echo
+  script:
+    - cd / && sh entrypoint.sh
+
+# publish image to docker.io/paritypr, (e.g. for later use in zombienet testing)
+.build-push-image-temporary:
+  extends:
+    - .build-refs
+    - .build-push-docker-image-common
+  variables:
+    IMAGE_PATH: paritypr/$PRODUCT
+    DOCKER_USER: $PARITYPR_USER
+    DOCKER_PASS: $PARITYPR_PASS
+
+publish-docker-substrate:
+  extends: .build-push-docker-image
+  needs:
+    - job: build-linux-substrate
+      artifacts: true
+  variables:
+    PRODUCT: substrate
+
+publish-docker-description-substrate:
+  extends: .push-docker-image-description
+  variables:
+    PRODUCT: substrate
+    SHORT_DESCRIPTION: "Substrate Docker Image."
+
+publish-docker-substrate-temporary:
+  extends: .build-push-image-temporary
+  needs:
+    - job: build-linux-substrate
+      artifacts: true
+  variables:
+    PRODUCT: substrate
+  artifacts:
+    reports:
+      # this artifact is used in zombienet-tests job
+      # https://docs.gitlab.com/ee/ci/multi_project_pipelines.html#with-variable-inheritance
+      dotenv: ./artifacts/$PRODUCT/build.env
+    expire_in: 24h
+
+publish-docker-subkey:
+  extends: .build-push-docker-image
+  needs:
+    - job: build-subkey-linux
+      artifacts: true
+  variables:
+    PRODUCT: subkey
+
+publish-docker-description-subkey:
+  extends: .push-docker-image-description
+  variables:
+    PRODUCT: subkey
+    SHORT_DESCRIPTION: "The subkey program is a key management utility for Substrate-based blockchains."
+
+publish-s3-release:
+  stage: publish
+  extends:
+    - .publish-refs
+    - .kubernetes-env
+  needs:
+    - job: build-linux-substrate
+      artifacts: true
+    - job: build-subkey-linux
+      artifacts: true
+  image: paritytech/awscli:latest
+  variables:
+    GIT_STRATEGY: none
+    BUCKET: "releases.parity.io"
+    PREFIX: "substrate/${ARCH}-${DOCKER_OS}"
+  script:
+    - aws s3 sync ./artifacts/ s3://${BUCKET}/${PREFIX}/$(cat ./artifacts/substrate/VERSION)/
+    - echo "update objects in latest path"
+    - aws s3 sync s3://${BUCKET}/${PREFIX}/$(cat ./artifacts/substrate/VERSION)/ s3://${BUCKET}/${PREFIX}/latest/
+  after_script:
+    - aws s3 ls s3://${BUCKET}/${PREFIX}/latest/
+      --recursive --human-readable --summarize
+
+publish-rustdoc:
+  stage: publish
+  extends: .kubernetes-env
+  variables:
+    CI_IMAGE: node:16
+    GIT_DEPTH: 100
+    RUSTDOCS_DEPLOY_REFS: "master"
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    - if: $CI_PIPELINE_SOURCE == "web" && $CI_COMMIT_REF_NAME == "master"
+    - if: $CI_COMMIT_REF_NAME == "master"
+    - if: $CI_COMMIT_REF_NAME =~ /^monthly-20[0-9]{2}-[0-9]{2}.*$/ # to support: monthly-2021-09+1
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+  # `needs:` can be removed after CI image gets nonroot. In this case `needs:` stops other
+  # artifacts from being dowloaded by this job.
+  needs:
+    - job: build-rustdoc
+      artifacts: true
+  script:
+    # If $CI_COMMIT_REF_NAME doesn't match one of $RUSTDOCS_DEPLOY_REFS space-separated values, we
+    # exit immediately.
+    # Putting spaces at the front and back to ensure we are not matching just any substring, but the
+    # whole space-separated value.
+    - '[[ " ${RUSTDOCS_DEPLOY_REFS} " =~ " ${CI_COMMIT_REF_NAME} " ]] || exit 0'
+    # setup ssh
+    - eval $(ssh-agent)
+    - ssh-add - <<< ${GITHUB_SSH_PRIV_KEY}
+    - mkdir ~/.ssh && touch ~/.ssh/known_hosts
+    - ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
+    # Set git config
+    - git config user.email "devops-team@parity.io"
+    - git config user.name "${GITHUB_USER}"
+    - git config remote.origin.url "git@github.com:/paritytech/${CI_PROJECT_NAME}.git"
+    - git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
+    - git fetch origin gh-pages
+    # Save README and docs
+    - cp -r ./crate-docs/ /tmp/doc/
+    - cp README.md /tmp/doc/
+    # we don't need to commit changes because we copy docs to /tmp
+    - git checkout gh-pages --force
+    # Install `index-tpl-crud` and generate index.html based on RUSTDOCS_DEPLOY_REFS
+    - which index-tpl-crud &> /dev/null || yarn global add @substrate/index-tpl-crud
+    - index-tpl-crud upsert ./index.html ${CI_COMMIT_REF_NAME}
+    # Ensure the destination dir doesn't exist.
+    - rm -rf ${CI_COMMIT_REF_NAME}
+    - mv -f /tmp/doc ${CI_COMMIT_REF_NAME}
+    # Upload files
+    - git add --all
+    # `git commit` has an exit code of > 0 if there is nothing to commit.
+    # This causes GitLab to exit immediately and marks this job failed.
+    # We don't want to mark the entire job failed if there's nothing to
+    # publish though, hence the `|| true`.
+    - git commit -m "___Updated docs for ${CI_COMMIT_REF_NAME}___" ||
+      echo "___Nothing to commit___"
+    - git push origin gh-pages --force
+  after_script:
+    - rm -rf .git/ ./*
+
+publish-draft-release:
+  stage: publish
+  image: paritytech/tools:latest
+  rules:
+    - if: $CI_COMMIT_REF_NAME =~ /^ci-release-.*$/
+    - if: $CI_COMMIT_REF_NAME =~ /^v[0-9]+\.[0-9]+.*$/ # i.e. v1.0, v2.1rc1
+  script:
+    - ./scripts/ci/gitlab/publish_draft_release.sh
+  allow_failure: true
+
+.publish-crates-template:
+  stage: publish
+  extends:
+    - .crates-publishing-template
+    - .crates-publishing-pipeline
+  # We don't want multiple jobs racing to publish crates as it's redundant and they might overwrite
+  # the releases of one another. Use resource_group to ensure that at most one instance of this job
+  # is running at any given time.
+  resource_group: crates-publishing
+  # crates.io currently rate limits crate publishing at 1 per minute:
+  # https://github.com/paritytech/release-engineering/issues/123#issuecomment-1335509748
+  # Taking into account the 202 (as of Dec 07, 2022) publishable Substrate crates, in the worst
+  # case, due to the rate limits alone, we'd have to wait through at least 202 minutes of delay.
+  # Taking into account also the verification steps and extra synchronization delays after
+  # publishing the crate, the job needs to have a much higher timeout than average.
+  timeout: 9h
+  # A custom publishing environment is used for us to be able to set up protected secrets
+  # specifically for it
+  environment: publish-crates
+  script:
+    - rusty-cachier snapshot create
+    - git clone
+      --depth 1
+      --branch "$RELENG_SCRIPTS_BRANCH"
+      https://github.com/paritytech/releng-scripts.git
+    - CRATESIO_TARGET_INSTANCE=default ./releng-scripts/publish-crates
+    - rusty-cachier cache upload
+
+publish-crates:
+  extends: .publish-crates-template
+  # publish-crates should only be run if publish-crates-locally passes
+  needs:
+    - job: check-crate-publishing
+      artifacts: false
+
+publish-crates-manual:
+  extends: .publish-crates-template
+  when: manual
+  interruptible: false
+
+check-crate-publishing:
+  stage: publish
+  extends:
+    - .crates-publishing-template
+    - .crates-publishing-pipeline
+  # When lots of crates are taken into account (for example on master where all crates are tested)
+  # the job might take a long time, as evidenced by:
+  # https://gitlab.parity.io/parity/mirrors/substrate/-/jobs/2269364
+  timeout: 4h
+  script:
+    - rusty-cachier snapshot create
+    - git clone
+      --depth 1
+      --branch "$RELENG_SCRIPTS_BRANCH"
+      https://github.com/paritytech/releng-scripts.git
+    - CRATESIO_TARGET_INSTANCE=local ./releng-scripts/publish-crates
+    - rusty-cachier cache upload
diff --git a/substrate/scripts/ci/gitlab/pipeline/test.yml b/substrate/scripts/ci/gitlab/pipeline/test.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ab294ccb436d823bc61c4e6dd54afffab031a1fc
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/pipeline/test.yml
@@ -0,0 +1,494 @@
+# This file is part of .gitlab-ci.yml
+# Here are all jobs that are executed during "test" stage
+
+# It's more like a check and it belongs to the previous stage, but we want to run this job with real tests in parallel
+find-fail-ci-phrase:
+  stage: test
+  variables:
+    CI_IMAGE: "paritytech/tools:latest"
+    ASSERT_REGEX: "FAIL-CI"
+    GIT_DEPTH: 1
+  extends:
+    - .kubernetes-env
+  script:
+    - set +e
+    - rg --line-number --hidden --type rust --glob '!{.git,target}' "$ASSERT_REGEX" .; exit_status=$?
+    - if [ $exit_status -eq 0 ]; then
+      echo "$ASSERT_REGEX was found, exiting with 1";
+      exit 1;
+      else
+      echo "No $ASSERT_REGEX was found, exiting with 0";
+      exit 0;
+      fi
+
+cargo-deny-licenses:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    CARGO_DENY_CMD: "cargo deny --all-features check licenses -c ./scripts/ci/deny.toml"
+  script:
+    - rusty-cachier snapshot create
+    - $CARGO_DENY_CMD --hide-inclusion-graph
+    - rusty-cachier cache upload
+  after_script:
+    - !reference [.rusty-cachier, 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
+  artifacts:
+    name: $CI_COMMIT_SHORT_SHA
+    expire_in: 3 days
+    when: always
+    paths:
+      - deny.log
+
+cargo-fmt:
+  stage: test
+  variables:
+    RUSTY_CACHIER_TOOLCHAIN: nightly
+  extends:
+    - .docker-env
+    - .test-refs
+  script:
+    - rusty-cachier snapshot create
+    - cargo +nightly fmt --all -- --check
+    - rusty-cachier cache upload
+
+cargo-fmt-manifest:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  script:
+    - cargo install zepter --locked --version 0.10.0 -q -f --no-default-features && zepter --version
+    - echo "👉 Hello developer! If you see this CI check failing then it means that one of the your changes in a Cargo.toml file introduced ill-formatted or unsorted features. Please take a look at 'docs/STYLE_GUIDE.md#manifest-formatting' to find out more."
+    - zepter format features --check
+  allow_failure: true # Experimental
+
+cargo-clippy:
+  stage: test
+  # this is an artificial job dependency, for pipeline optimization using GitLab's DAGs
+  needs:
+    - job: cargo-fmt
+      artifacts: false
+  extends:
+    - .docker-env
+    - .test-refs
+  script:
+    - echo $RUSTFLAGS
+    - cargo version && cargo clippy --version
+    - rusty-cachier snapshot create
+    - SKIP_WASM_BUILD=1 env -u RUSTFLAGS cargo clippy --locked --all-targets --workspace
+    - rusty-cachier cache upload
+
+cargo-check-benches:
+  stage: test
+  variables:
+    CI_JOB_NAME: "cargo-check-benches"
+  extends:
+    - .docker-env
+    - .test-refs-check-benches
+    - .collect-artifacts
+    - .pipeline-stopper-artifacts
+  before_script:
+    - !reference [.timestamp, before_script]
+    # perform rusty-cachier operations before any further modifications to the git repo to make cargo feel cheated not so much
+    - !reference [.rust-info-script, script]
+    - !reference [.job-switcher, before_script]
+    - !reference [.rusty-cachier, before_script]
+    - !reference [.pipeline-stopper-vars, script]
+    # merges in the master branch on PRs. skip if base is not master
+    - 'if [ $CI_COMMIT_REF_NAME != "master" ]; then
+      BASE=$(curl -s -H "Authorization: Bearer ${GITHUB_PR_TOKEN}" https://api.github.com/repos/paritytech/substrate/pulls/${CI_COMMIT_REF_NAME} | jq -r .base.ref);
+      printf "Merging base branch %s\n" "${BASE:=master}";
+      if [ $BASE != "master" ]; then
+      echo "$BASE is not master, skipping merge";
+      else
+      git config user.email "ci@gitlab.parity.io";
+      git fetch origin "refs/heads/${BASE}";
+      git merge --verbose --no-edit FETCH_HEAD;
+      fi
+      fi'
+  parallel: 2
+  script:
+    - rusty-cachier snapshot create
+    - mkdir -p ./artifacts/benches/$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA
+    # this job is executed in parallel on two runners
+    - echo "___Running benchmarks___";
+    - case ${CI_NODE_INDEX} in
+      1)
+      SKIP_WASM_BUILD=1 time cargo check --locked --benches --all;
+      cargo run --locked --release -p node-bench -- ::trie::read::small --json
+      | tee ./artifacts/benches/$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA/::trie::read::small.json;
+      echo "___Uploading cache for rusty-cachier___";
+      rusty-cachier cache upload
+      ;;
+      2)
+      cargo run --locked --release -p node-bench -- ::node::import::sr25519::transfer_keep_alive::paritydb::small --json
+      | tee ./artifacts/benches/$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA/::node::import::sr25519::transfer_keep_alive::paritydb::small.json
+      ;;
+      esac
+
+node-bench-regression-guard:
+  # it's not belong to `build` semantically, but dag jobs can't depend on each other
+  # within the single stage - https://gitlab.com/gitlab-org/gitlab/-/issues/30632
+  # more: https://github.com/paritytech/substrate/pull/8519#discussion_r608012402
+  stage: build
+  extends:
+    - .docker-env
+    - .test-refs-no-trigger-prs-only
+  needs:
+    # this is a DAG
+    - job: cargo-check-benches
+      artifacts: true
+    # polls artifact from master to compare with current result
+    # need to specify both parallel jobs from master because of the bug
+    # https://gitlab.com/gitlab-org/gitlab/-/issues/39063
+    - project: $CI_PROJECT_PATH
+      job: "cargo-check-benches 1/2"
+      ref: master
+      artifacts: true
+    - project: $CI_PROJECT_PATH
+      job: "cargo-check-benches 2/2"
+      ref: master
+      artifacts: true
+  variables:
+    CI_IMAGE: "paritytech/node-bench-regression-guard:latest"
+  before_script:
+    - !reference [.timestamp, before_script]
+  script:
+    - echo "------- IMPORTANT -------"
+    - echo "node-bench-regression-guard depends on the results of a cargo-check-benches job"
+    - echo "In case of this job failure, check your pipeline's cargo-check-benches"
+    - "node-bench-regression-guard --reference artifacts/benches/master-*
+      --compare-with artifacts/benches/$CI_COMMIT_REF_NAME-$CI_COMMIT_SHORT_SHA"
+  after_script: [""]
+
+cargo-check-try-runtime-and-experimental:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  script:
+    - rusty-cachier snapshot create
+    - time cargo check --workspace --locked --features try-runtime,experimental
+    - rusty-cachier cache upload
+
+test-deterministic-wasm:
+  stage: test
+  # this is an artificial job dependency, for pipeline optimization using GitLab's DAGs
+  needs:
+    - job: cargo-check-try-runtime-and-experimental
+      artifacts: false
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    WASM_BUILD_NO_COLOR: 1
+    # this variable gets overriden by "rusty-cachier environment inject", use the value as default
+    CARGO_TARGET_DIR: "$CI_PROJECT_DIR/target"
+  script:
+    - rusty-cachier snapshot create
+    # build runtime
+    - cargo build --locked --verbose --release -p kitchensink-runtime
+    # make checksum
+    - sha256sum $CARGO_TARGET_DIR/release/wbuild/kitchensink-runtime/target/wasm32-unknown-unknown/release/kitchensink_runtime.wasm > checksum.sha256
+    # clean up
+    - rm -rf $CARGO_TARGET_DIR/release/wbuild
+    # build again
+    - cargo build --locked --verbose --release -p kitchensink-runtime
+    # confirm checksum
+    - sha256sum -c ./checksum.sha256
+    # clean up again, don't put release binaries into the cache
+    - rm -rf $CARGO_TARGET_DIR/release/wbuild
+    - rusty-cachier cache upload
+
+test-linux-stable:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+    - .pipeline-stopper-artifacts
+  variables:
+    # Enable debug assertions since we are running optimized builds for testing
+    # but still want to have debug assertions.
+    RUSTFLAGS: "-C debug-assertions -D warnings"
+    RUST_BACKTRACE: 1
+    WASM_BUILD_NO_COLOR: 1
+    WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings"
+    # Ensure we run the UI tests.
+    RUN_UI_TESTS: 1
+    # needed for rusty-cachier to keep cache in test-linux-stable folder and not in test-linux-stable-1/3
+    CI_JOB_NAME: "test-linux-stable"
+  parallel: 3
+  script:
+    - rusty-cachier snapshot create
+    # this job runs all tests in former runtime-benchmarks, frame-staking and wasmtime tests
+    # tests are partitioned by nextest and executed in parallel on $CI_NODE_TOTAL runners
+    - echo "Node index - ${CI_NODE_INDEX}. Total amount - ${CI_NODE_TOTAL}"
+    - time cargo nextest run --workspace
+      --locked
+      --release
+      --verbose
+      --features runtime-benchmarks,try-runtime,experimental
+      --manifest-path ./bin/node/cli/Cargo.toml
+      --partition count:${CI_NODE_INDEX}/${CI_NODE_TOTAL}
+    # run runtime-api tests with `enable-staging-api` feature
+    - time cargo nextest run -p sp-api-test --features enable-staging-api
+    # we need to update cache only from one job
+    - if [ ${CI_NODE_INDEX} == 1 ]; then rusty-cachier cache upload; fi
+    # Upload tests results to Elasticsearch
+    - echo "Upload test results to Elasticsearch"
+    - cat target/nextest/default/junit.xml | xq . > target/nextest/default/junit.json
+    - |
+      curl -v -XPOST --http1.1 \
+      -u ${ELASTIC_USERNAME}:${ELASTIC_PASSWORD} \
+      https://elasticsearch.parity-build.parity.io/unit-tests/_doc/${CI_JOB_ID} \
+      -H 'Content-Type: application/json' \
+      -d @target/nextest/default/junit.json || echo "failed to upload junit report"
+  artifacts:
+    when: always
+    paths:
+      - target/nextest/default/junit.xml
+    reports:
+      junit: target/nextest/default/junit.xml
+
+test-frame-support:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    # Enable debug assertions since we are running optimized builds for testing
+    # but still want to have debug assertions.
+    RUSTFLAGS: "-C debug-assertions -D warnings"
+    RUST_BACKTRACE: 1
+    WASM_BUILD_NO_COLOR: 1
+    WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings"
+    # Ensure we run the UI tests.
+    RUN_UI_TESTS: 1
+  script:
+    - rusty-cachier snapshot create
+    - cat /cargo_target_dir/debug/.fingerprint/memory_units-759eddf317490d2b/lib-memory_units.json || true
+    - time cargo test --verbose --locked -p frame-support-test --features=frame-feature-testing,no-metadata-docs,try-runtime,experimental --manifest-path ./frame/support/test/Cargo.toml
+    - time cargo test --verbose --locked -p frame-support-test --features=frame-feature-testing,frame-feature-testing-2,no-metadata-docs,try-runtime,experimental --manifest-path ./frame/support/test/Cargo.toml
+    - SUBSTRATE_TEST_TIMEOUT=1 time cargo test -p substrate-test-utils --release --verbose --locked -- --ignored timeout
+    - cat /cargo_target_dir/debug/.fingerprint/memory_units-759eddf317490d2b/lib-memory_units.json || true
+    - rusty-cachier cache upload
+
+# This job runs tests that don't work with cargo-nextest in test-linux-stable
+test-linux-stable-extra:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    # Enable debug assertions since we are running optimized builds for testing
+    # but still want to have debug assertions.
+    RUSTFLAGS: "-C debug-assertions -D warnings"
+    RUST_BACKTRACE: 1
+    WASM_BUILD_NO_COLOR: 1
+    WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings"
+    # Ensure we run the UI tests.
+    RUN_UI_TESTS: 1
+  script:
+    - rusty-cachier snapshot create
+    # Run node-cli tests
+    # TODO: add to test-linux-stable-nextest after fix https://github.com/paritytech/substrate/issues/11321
+    - time cargo test node-cli --workspace --locked --release --verbose --features runtime-benchmarks --manifest-path ./bin/node/cli/Cargo.toml
+    # Run doctests
+    # TODO: add to test-linux-stable-nextest after fix https://github.com/nextest-rs/nextest/issues/16
+    - time cargo test --doc --workspace --locked --release --verbose --features runtime-benchmarks --manifest-path ./bin/node/cli/Cargo.toml
+    - rusty-cachier cache upload
+
+# This job runs all benchmarks defined in the `/bin/node/runtime` once to check that there are no errors.
+quick-benchmarks:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    # Enable debug assertions since we are running optimized builds for testing
+    # but still want to have debug assertions.
+    RUSTFLAGS: "-C debug-assertions -D warnings"
+    RUST_BACKTRACE: "full"
+    WASM_BUILD_NO_COLOR: 1
+    WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings"
+  script:
+    - rusty-cachier snapshot create
+    - time cargo run --locked --release -p node-cli --features runtime-benchmarks -- benchmark pallet --wasm-execution compiled --chain dev --pallet "*" --extrinsic "*" --steps 2 --repeat 1
+    - rusty-cachier cache upload
+
+test-frame-examples-compile-to-wasm:
+  # into one job
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    # Enable debug assertions since we are running optimized builds for testing
+    # but still want to have debug assertions.
+    RUSTFLAGS: "-C debug-assertions"
+    RUST_BACKTRACE: 1
+  script:
+    - rusty-cachier snapshot create
+    - cd ./frame/examples/offchain-worker/
+    - cargo build --locked --target=wasm32-unknown-unknown --no-default-features
+    - cd ../basic
+    - cargo build --locked --target=wasm32-unknown-unknown --no-default-features
+    - rusty-cachier cache upload
+
+test-linux-stable-int:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+    - .pipeline-stopper-artifacts
+  variables:
+    # Enable debug assertions since we are running optimized builds for testing
+    # but still want to have debug assertions.
+    RUSTFLAGS: "-C debug-assertions -D warnings"
+    RUST_BACKTRACE: 1
+    WASM_BUILD_NO_COLOR: 1
+    WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings"
+    # Ensure we run the UI tests.
+    RUN_UI_TESTS: 1
+  script:
+    - rusty-cachier snapshot create
+    - WASM_BUILD_NO_COLOR=1
+      RUST_LOG=sync=trace,consensus=trace,client=trace,state-db=trace,db=trace,forks=trace,state_db=trace,storage_cache=trace
+      time cargo test -p node-cli --release --verbose --locked -- --ignored
+    - rusty-cachier cache upload
+
+# more information about this job can be found here:
+# https://github.com/paritytech/substrate/pull/6916
+check-tracing:
+  stage: test
+  # this is an artificial job dependency, for pipeline optimization using GitLab's DAGs
+  needs:
+    - job: test-linux-stable-int
+      artifacts: false
+  extends:
+    - .docker-env
+    - .test-refs
+    - .pipeline-stopper-artifacts
+  script:
+    - rusty-cachier snapshot create
+    # with-tracing must be explicitly activated, we run a test to ensure this works as expected in both cases
+    - time cargo test --locked --manifest-path ./primitives/tracing/Cargo.toml --no-default-features
+    - time cargo test --locked --manifest-path ./primitives/tracing/Cargo.toml --no-default-features --features=with-tracing
+    - rusty-cachier cache upload
+
+# more information about this job can be found here:
+# https://github.com/paritytech/substrate/pull/3778
+test-full-crypto-feature:
+  stage: test
+  # this is an artificial job dependency, for pipeline optimization using GitLab's DAGs
+  needs:
+    - job: check-tracing
+      artifacts: false
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    # Enable debug assertions since we are running optimized builds for testing
+    # but still want to have debug assertions.
+    RUSTFLAGS: "-C debug-assertions"
+    RUST_BACKTRACE: 1
+  script:
+    - rusty-cachier snapshot create
+    - cd primitives/core/
+    - time cargo build --locked --verbose --no-default-features --features full_crypto
+    - cd ../application-crypto
+    - time cargo build --locked --verbose --no-default-features --features full_crypto
+    - rusty-cachier cache upload
+
+check-rustdoc:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+  variables:
+    SKIP_WASM_BUILD: 1
+    RUSTDOCFLAGS: "-Dwarnings"
+  script:
+    - rusty-cachier snapshot create
+    - time cargo doc --locked --workspace --all-features --verbose --no-deps
+    - rusty-cachier cache upload
+
+cargo-check-each-crate:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+    - .collect-artifacts
+    - .pipeline-stopper-artifacts
+  variables:
+    # $CI_JOB_NAME is set manually so that rusty-cachier can share the cache for all
+    # "cargo-check-each-crate I/N" jobs
+    CI_JOB_NAME: cargo-check-each-crate
+  script:
+    - rusty-cachier snapshot create
+    - PYTHONUNBUFFERED=x time ./scripts/ci/gitlab/check-each-crate.py "$CI_NODE_INDEX" "$CI_NODE_TOTAL"
+    # need to update cache only from one job
+    - if [ "$CI_NODE_INDEX" == 1 ]; then rusty-cachier cache upload; fi
+  parallel: 2
+
+cargo-check-each-crate-macos:
+  stage: test
+  extends:
+    - .test-refs
+    - .collect-artifacts
+    - .pipeline-stopper-artifacts
+  before_script:
+    # skip timestamp script, the osx bash doesn't support printf %()T
+    - !reference [.job-switcher, before_script]
+    - !reference [.rust-info-script, script]
+    - !reference [.pipeline-stopper-vars, script]
+  variables:
+    SKIP_WASM_BUILD: 1
+  script:
+    # TODO: enable rusty-cachier once it supports Mac
+    # TODO: use parallel jobs, as per cargo-check-each-crate, once more Mac runners are available
+    # - time ./scripts/ci/gitlab/check-each-crate.py 1 1
+    - time cargo check --workspace --locked
+  tags:
+    - osx
+
+cargo-hfuzz:
+  stage: test
+  extends:
+    - .docker-env
+    - .test-refs
+    - .pipeline-stopper-artifacts
+  variables:
+    # max 10s per iteration, 60s per file
+    HFUZZ_RUN_ARGS: >
+      --exit_upon_crash
+      --exit_code_upon_crash 1
+      --timeout 10
+      --run_time 60
+    # use git version of honggfuzz-rs until v0.5.56 is out, we need a few recent changes:
+    # https://github.com/rust-fuzz/honggfuzz-rs/pull/75 to avoid breakage on debian
+    # https://github.com/rust-fuzz/honggfuzz-rs/pull/81 fix to the above pr
+    # https://github.com/rust-fuzz/honggfuzz-rs/pull/82 fix for handling rusty-cachier's absolute CARGO_TARGET_DIR
+    HFUZZ_BUILD_ARGS: >
+      --config=patch.crates-io.honggfuzz.git="https://github.com/altaua/honggfuzz-rs"
+      --config=patch.crates-io.honggfuzz.rev="205f7c8c059a0d98fe1cb912cdac84f324cb6981"
+  artifacts:
+    name: "hfuzz-$CI_COMMIT_SHORT_SHA"
+    expire_in: 7 days
+    when: on_failure
+    paths:
+      - primitives/arithmetic/fuzzer/hfuzz_workspace/
+  script:
+    - cd ./primitives/arithmetic/fuzzer
+    - rusty-cachier snapshot create
+    - cargo hfuzz build
+    - rusty-cachier cache upload
+    - for target in $(cargo read-manifest | jq -r '.targets | .[] | .name'); do
+      cargo hfuzz run "$target" || { printf "fuzzing failure for %s\n" "$target"; exit 1; }; done
diff --git a/substrate/scripts/ci/gitlab/pipeline/zombienet.yml b/substrate/scripts/ci/gitlab/pipeline/zombienet.yml
new file mode 100644
index 0000000000000000000000000000000000000000..31ee510343278943838420679705212d61e75d2d
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/pipeline/zombienet.yml
@@ -0,0 +1,67 @@
+# This file is part of .gitlab-ci.yml
+# Here are all jobs that are executed during "zombienet" stage
+
+# common settings for all zombienet jobs
+.zombienet-common:
+  before_script:
+    - echo "Zombie-net Tests Config"
+    - echo "${ZOMBIENET_IMAGE}"
+    - echo "${SUBSTRATE_IMAGE_NAME} ${SUBSTRATE_IMAGE_TAG}"
+    - echo "${GH_DIR}"
+    - export DEBUG=zombie,zombie::network-node
+    - export ZOMBIENET_INTEGRATION_TEST_IMAGE=${SUBSTRATE_IMAGE_NAME}:${SUBSTRATE_IMAGE_TAG}
+    - echo "${ZOMBIENET_INTEGRATION_TEST_IMAGE}"
+  stage: zombienet
+  image: "${ZOMBIENET_IMAGE}"
+  needs:
+    - job: publish-docker-substrate-temporary
+  extends:
+    - .kubernetes-env
+    - .zombienet-refs
+  variables:
+    GH_DIR: "https://github.com/paritytech/substrate/tree/${CI_COMMIT_SHA}/zombienet"
+    FF_DISABLE_UMASK_FOR_DOCKER_EXECUTOR: 1
+  artifacts:
+    name: "${CI_JOB_NAME}_${CI_COMMIT_REF_NAME}"
+    when: always
+    expire_in: 2 days
+    paths:
+      - ./zombienet-logs
+  after_script:
+    - mkdir -p ./zombienet-logs
+    - cp /tmp/zombie*/logs/* ./zombienet-logs/
+  retry: 2
+  tags:
+    - zombienet-polkadot-integration-test
+
+zombienet-0000-block-building:
+  extends:
+    - .zombienet-common
+  script:
+    - /home/nonroot/zombie-net/scripts/ci/run-test-env-manager.sh
+      --github-remote-dir="${GH_DIR}/0000-block-building"
+      --test="block-building.zndsl"
+
+zombienet-0001-basic-warp-sync:
+  extends:
+    - .zombienet-common
+  script:
+    - /home/nonroot/zombie-net/scripts/ci/run-test-env-manager.sh
+      --github-remote-dir="${GH_DIR}/0001-basic-warp-sync"
+      --test="test-warp-sync.zndsl"
+
+zombienet-0002-validators-warp-sync:
+  extends:
+    - .zombienet-common
+  script:
+    - /home/nonroot/zombie-net/scripts/ci/run-test-env-manager.sh
+      --github-remote-dir="${GH_DIR}/0002-validators-warp-sync"
+      --test="test-validators-warp-sync.zndsl"
+
+zombienet-0003-block-building-warp-sync:
+  extends:
+    - .zombienet-common
+  script:
+    - /home/nonroot/zombie-net/scripts/ci/run-test-env-manager.sh
+      --github-remote-dir="${GH_DIR}/0003-block-building-warp-sync"
+      --test="test-block-building-warp-sync.zndsl"
diff --git a/substrate/scripts/ci/gitlab/prettier.sh b/substrate/scripts/ci/gitlab/prettier.sh
new file mode 100755
index 0000000000000000000000000000000000000000..299bbee179dcaeff3fbadffd89fb4548ac878555
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/prettier.sh
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+# meant to be installed via
+#   git config filter.ci-prettier.clean "scripts/ci/gitlab/prettier.sh"
+
+prettier --parser yaml
diff --git a/substrate/scripts/ci/gitlab/publish_draft_release.sh b/substrate/scripts/ci/gitlab/publish_draft_release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..88d1de0e04fe3c17245d5e7dd95e5dd632625ad3
--- /dev/null
+++ b/substrate/scripts/ci/gitlab/publish_draft_release.sh
@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+
+# shellcheck source=../common/lib.sh
+source "$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )/../common/lib.sh"
+
+version="$CI_COMMIT_TAG"
+
+# Note that this is not the last *tagged* version, but the last *published* version
+last_version=$(last_github_release 'paritytech/substrate')
+
+release_text="$(./generate_release_text.sh "$last_version" "$version")"
+
+echo "[+] Pushing release to github"
+# Create release on github
+release_name="Substrate $version"
+data=$(jq -Rs --arg version "$version" \
+  --arg release_name "$release_name" \
+  --arg release_text "$release_text" \
+'{
+  "tag_name": $version,
+  "target_commitish": "master",
+  "name": $release_name,
+  "body": $release_text,
+  "draft": true,
+  "prerelease": false
+}' < /dev/null)
+
+out=$(curl -s -X POST --data "$data" -H "Authorization: token $GITHUB_RELEASE_TOKEN" "$api_base/paritytech/substrate/releases")
+
+html_url=$(echo "$out" | jq -r .html_url)
+
+if [ "$html_url" == "null" ]
+then
+  echo "[!] Something went wrong posting:"
+  echo "$out"
+else
+  echo "[+] Release draft created: $html_url"
+fi
+
+echo '[+] Sending draft release URL to Matrix'
+
+msg_body=$(cat <<EOF
+**Release pipeline for Substrate $version complete.**
+Draft release created: $html_url
+EOF
+)
+formatted_msg_body=$(cat <<EOF
+<strong>Release pipeline for Substrate $version complete.</strong><br />
+Draft release created: $html_url
+EOF
+)
+send_message "$(structure_message "$msg_body" "$formatted_msg_body")" "!aJymqQYtCjjqImFLSb:parity.io" "$RELEASENOTES_MATRIX_V2_ACCESS_TOKEN"
+
+echo "[+] Done! Maybe the release worked..."
diff --git a/substrate/scripts/ci/monitoring/alerting-rules/alerting-rule-tests.yaml b/substrate/scripts/ci/monitoring/alerting-rules/alerting-rule-tests.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..df5e020d067eafcdcf6f0e04a26ed4811d57d4e1
--- /dev/null
+++ b/substrate/scripts/ci/monitoring/alerting-rules/alerting-rule-tests.yaml
@@ -0,0 +1,239 @@
+rule_files:
+    - /dev/stdin
+
+evaluation_interval: 1m
+
+tests:
+    - interval: 1m
+      input_series:
+          - series: 'substrate_sub_libp2p_peers_count{
+              job="substrate",
+              pod="substrate-abcdef01234-abcdef",
+              instance="substrate-abcdef01234-abcdef",
+            }'
+            values: '3 2+0x4 1+0x9' # 3 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
+
+          - series: 'substrate_sub_txpool_validations_scheduled{
+              job="substrate",
+              pod="substrate-abcdef01234-abcdef",
+              instance="substrate-abcdef01234-abcdef",
+            }'
+            values: '11+1x10 22+2x30 10043x5'
+
+          - series: 'substrate_sub_txpool_validations_finished{
+              job="substrate",
+              pod="substrate-abcdef01234-abcdef",
+              instance="substrate-abcdef01234-abcdef",
+            }'
+            values: '0+1x42 42x5'
+
+          - series: 'substrate_block_height{
+              status="best", job="substrate",
+              pod="substrate-abcdef01234-abcdef",
+              instance="substrate-abcdef01234-abcdef",
+            }'
+            values: '1+1x3 4+0x13' # 1 2 3 4 4 4 4 4 4 4 4 4 ...
+
+          - series: 'substrate_block_height{
+              status="finalized",
+              job="substrate",
+              pod="substrate-abcdef01234-abcdef",
+              instance="substrate-abcdef01234-abcdef",
+            }'
+            values: '1+1x3 4+0x13' # 1 2 3 4 4 4 4 4 4 4 4 4 ...
+
+      alert_rule_test:
+
+          ######################################################################
+          # Block production
+          ######################################################################
+
+          - eval_time: 6m
+            alertname: BlockProductionSlow
+            exp_alerts:
+          - eval_time: 7m
+            alertname: BlockProductionSlow
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                      status: best
+                  exp_annotations:
+                      message: "Best block on instance
+                      substrate-abcdef01234-abcdef increases by less than 1 per
+                      minute for more than 3 minutes."
+
+          - eval_time: 14m
+            alertname: BlockProductionSlow
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                      status: best
+                  exp_annotations:
+                      message: "Best block on instance
+                      substrate-abcdef01234-abcdef increases by less than 1 per
+                      minute for more than 3 minutes."
+                - exp_labels:
+                      severity: critical
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                      status: best
+                  exp_annotations:
+                      message: "Best block on instance
+                      substrate-abcdef01234-abcdef increases by less than 1 per
+                      minute for more than 10 minutes."
+
+          ######################################################################
+          # Block finalization
+          ######################################################################
+
+          - eval_time: 6m
+            alertname: BlockFinalizationSlow
+            exp_alerts:
+          - eval_time: 7m
+            alertname: BlockFinalizationSlow
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                      status: finalized
+                  exp_annotations:
+                      message: "Finalized block on instance
+                      substrate-abcdef01234-abcdef increases by less than 1 per
+                      minute for more than 3 minutes."
+
+          - eval_time: 14m
+            alertname: BlockFinalizationSlow
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                      status: finalized
+                  exp_annotations:
+                      message: "Finalized block on instance
+                      substrate-abcdef01234-abcdef increases by less than 1 per
+                      minute for more than 3 minutes."
+                - exp_labels:
+                      severity: critical
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                      status: finalized
+                  exp_annotations:
+                      message: "Finalized block on instance
+                      substrate-abcdef01234-abcdef increases by less than 1 per
+                      minute for more than 10 minutes."
+
+          ######################################################################
+          # Transaction queue
+          ######################################################################
+
+          - eval_time: 11m
+            alertname: TransactionQueueSizeIncreasing
+            # Number of validations scheduled and finished both grow at a rate
+            # of 1 in the first 10 minutes, thereby the queue is not increasing
+            # in size, thus don't expect an alert.
+            exp_alerts:
+          - eval_time: 22m
+            alertname: TransactionQueueSizeIncreasing
+            # Number of validations scheduled is growing twice as fast as the
+            # number of validations finished after minute 10. Thus expect
+            # warning alert after 20 minutes.
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                  exp_annotations:
+                      message: "The transaction pool size on node
+                      substrate-abcdef01234-abcdef has been monotonically
+                      increasing for more than 10 minutes."
+          - eval_time: 43m
+            alertname: TransactionQueueSizeIncreasing
+            # Number of validations scheduled is growing twice as fast as the
+            # number of validations finished after minute 10. Thus expect
+            # both warning and critical alert after 40 minutes.
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                  exp_annotations:
+                      message: "The transaction pool size on node
+                      substrate-abcdef01234-abcdef has been monotonically
+                      increasing for more than 10 minutes."
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                  exp_annotations:
+                      message: "The transaction pool size on node
+                      substrate-abcdef01234-abcdef has been monotonically
+                      increasing for more than 30 minutes."
+          - eval_time: 49m
+            alertname: TransactionQueueSizeHigh
+            # After minute 43 the number of validations scheduled jumps up
+            # drastically while the number of validations finished stays the
+            # same. Thus expect an alert.
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                  exp_annotations:
+                      message: "The transaction pool size on node
+                      substrate-abcdef01234-abcdef has been above 10_000 for more
+                      than 5 minutes."
+
+          ######################################################################
+          # Networking
+          ######################################################################
+
+          - eval_time: 3m # Values: 3 2 2
+            alertname: NumberOfPeersLow
+            exp_alerts:
+          - eval_time: 4m # Values: 2 2 2
+            alertname: NumberOfPeersLow
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                  exp_annotations:
+                      message: "The node substrate-abcdef01234-abcdef has less
+                      than 3 peers for more than 3 minutes"
+
+          - eval_time: 16m # Values: 3 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1
+            alertname: NumberOfPeersLow
+            exp_alerts:
+                - exp_labels:
+                      severity: warning
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                  exp_annotations:
+                      message: "The node substrate-abcdef01234-abcdef has less
+                      than 3 peers for more than 3 minutes"
+                - exp_labels:
+                      severity: critical
+                      pod: substrate-abcdef01234-abcdef
+                      instance: substrate-abcdef01234-abcdef
+                      job: substrate
+                  exp_annotations:
+                      message: "The node substrate-abcdef01234-abcdef has less
+                      than 3 peers for more than 15 minutes"
diff --git a/substrate/scripts/ci/monitoring/alerting-rules/alerting-rules.yaml b/substrate/scripts/ci/monitoring/alerting-rules/alerting-rules.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4171f92f68feff11d2f10cbeeea63be64f80f546
--- /dev/null
+++ b/substrate/scripts/ci/monitoring/alerting-rules/alerting-rules.yaml
@@ -0,0 +1,171 @@
+groups:
+- name: substrate.rules
+  rules:
+
+  ##############################################################################
+  # Block production
+  ##############################################################################
+
+  - alert: BlockProductionSlow
+    annotations:
+      message: 'Best block on instance {{ $labels.instance }} increases by
+      less than 1 per minute for more than 3 minutes.'
+    expr: increase(substrate_block_height{status="best"}[1m]) < 1
+    for: 3m
+    labels:
+      severity: warning
+  - alert: BlockProductionSlow
+    annotations:
+      message: 'Best block on instance {{ $labels.instance }} increases by
+      less than 1 per minute for more than 10 minutes.'
+    expr: increase(substrate_block_height{status="best"}[1m]) < 1
+    for: 10m
+    labels:
+      severity: critical
+
+  ##############################################################################
+  # Block finalization
+  ##############################################################################
+
+  - alert: BlockFinalizationSlow
+    expr: increase(substrate_block_height{status="finalized"}[1m]) < 1
+    for: 3m
+    labels:
+      severity: warning
+    annotations:
+      message: 'Finalized block on instance {{ $labels.instance }} increases by
+      less than 1 per minute for more than 3 minutes.'
+  - alert: BlockFinalizationSlow
+    expr: increase(substrate_block_height{status="finalized"}[1m]) < 1
+    for: 10m
+    labels:
+      severity: critical
+    annotations:
+      message: 'Finalized block on instance {{ $labels.instance }} increases by
+      less than 1 per minute for more than 10 minutes.'
+  - alert: BlockFinalizationLaggingBehind
+    # Under the assumption of an average block production of 6 seconds,
+    # "best" and "finalized" being more than 10 blocks apart would imply
+    # more than a 1 minute delay between block production and finalization.
+    expr: '(substrate_block_height{status="best"} - ignoring(status)
+    substrate_block_height{status="finalized"}) > 10'
+    for: 8m
+    labels:
+      severity: critical
+    annotations:
+      message: "Block finalization on instance {{ $labels.instance }} is behind
+      block production by {{ $value }} for more than 8 minutes."
+
+  ##############################################################################
+  # Transaction queue
+  ##############################################################################
+
+  - alert: TransactionQueueSizeIncreasing
+    expr: 'increase(substrate_sub_txpool_validations_scheduled[5m]) -
+    increase(substrate_sub_txpool_validations_finished[5m]) > 0'
+    for: 10m
+    labels:
+      severity: warning
+    annotations:
+      message: 'The transaction pool size on node {{ $labels.instance }} has
+      been monotonically increasing for more than 10 minutes.'
+  - alert: TransactionQueueSizeIncreasing
+    expr: 'increase(substrate_sub_txpool_validations_scheduled[5m]) -
+    increase(substrate_sub_txpool_validations_finished[5m]) > 0'
+    for: 30m
+    labels:
+      severity: warning
+    annotations:
+      message: 'The transaction pool size on node {{ $labels.instance }} has
+      been monotonically increasing for more than 30 minutes.'
+  - alert: TransactionQueueSizeHigh
+    expr: 'substrate_sub_txpool_validations_scheduled -
+    substrate_sub_txpool_validations_finished > 10000'
+    for: 5m
+    labels:
+      severity: warning
+    annotations:
+      message: 'The transaction pool size on node {{ $labels.instance }} has
+      been above 10_000 for more than 5 minutes.'
+
+  ##############################################################################
+  # Networking
+  ##############################################################################
+
+  - alert: NumberOfPeersLow
+    expr: substrate_sub_libp2p_peers_count < 3
+    for: 3m
+    labels:
+      severity: warning
+    annotations:
+      message: 'The node {{ $labels.instance }} has less than 3 peers for more
+      than 3 minutes'
+  - alert: NumberOfPeersLow
+    expr: substrate_sub_libp2p_peers_count < 3
+    for: 15m
+    labels:
+      severity: critical
+    annotations:
+      message: 'The node {{ $labels.instance }} has less than 3 peers for more
+      than 15 minutes'
+  - alert: NoIncomingConnection
+    expr: increase(substrate_sub_libp2p_incoming_connections_total[20m]) == 0
+    labels:
+      severity: warning
+    annotations:
+      message: 'The node {{ $labels.instance }} has not received any new incoming
+      TCP connection in the past 20 minutes. Is it connected to the Internet?'
+
+  ##############################################################################
+  # System
+  ##############################################################################
+
+  - alert: NumberOfFileDescriptorsHigh
+    expr: 'node_filefd_allocated{chain!=""} > 10000'
+    for: 3m
+    labels:
+      severity: warning
+    annotations:
+      message: 'The node {{ $labels.instance }} has more than 10_000 file
+      descriptors allocated for more than 3 minutes'
+
+  ##############################################################################
+  # Others
+  ##############################################################################
+
+  - alert: AuthorityDiscoveryDiscoveryFailureHigh
+    expr: 'substrate_authority_discovery_handle_value_found_event_failure /
+    ignoring(name)
+    substrate_authority_discovery_dht_event_received{name="value_found"} > 0.5'
+    for: 2h
+    labels:
+      severity: warning
+    annotations:
+      message: 'Authority discovery on node {{ $labels.instance }} fails to
+      process more than 50 % of the values found on the DHT for more than 2
+      hours.'
+
+  - alert: UnboundedChannelPersistentlyLarge
+    expr: '(
+        (substrate_unbounded_channel_len{action = "send"} -
+            ignoring(action) substrate_unbounded_channel_len{action = "received"})
+        or on(instance) substrate_unbounded_channel_len{action = "send"}
+    ) >= 200'
+    for: 5m
+    labels:
+      severity: warning
+    annotations:
+      message: 'Channel {{ $labels.entity }} on node {{ $labels.instance }} contains
+      more than 200 items for more than 5 minutes. Node might be frozen.'
+
+  - alert: UnboundedChannelVeryLarge
+    expr: '(
+        (substrate_unbounded_channel_len{action = "send"} -
+            ignoring(action) substrate_unbounded_channel_len{action = "received"})
+        or on(instance) substrate_unbounded_channel_len{action = "send"}
+    ) > 15000'
+    labels:
+      severity: warning
+    annotations:
+      message: 'Channel {{ $labels.entity }} on node {{ $labels.instance }} contains more than
+      15000 items.'
diff --git a/substrate/scripts/ci/monitoring/grafana-dashboards/README_dashboard.md b/substrate/scripts/ci/monitoring/grafana-dashboards/README_dashboard.md
new file mode 100644
index 0000000000000000000000000000000000000000..50f54a107e93398f121ac4504c49ec117db3d36f
--- /dev/null
+++ b/substrate/scripts/ci/monitoring/grafana-dashboards/README_dashboard.md
@@ -0,0 +1,7 @@
+## Substrate Dashboard
+
+Shared templated Grafana dashboards.
+
+To import the dashboards follow the [Grafana
+documentation](https://grafana.com/docs/grafana/latest/reference/export_import/).
+You can see an example setup [here](./substrate-networking.json).
diff --git a/substrate/scripts/ci/monitoring/grafana-dashboards/substrate-networking.json b/substrate/scripts/ci/monitoring/grafana-dashboards/substrate-networking.json
new file mode 100644
index 0000000000000000000000000000000000000000..abd675ed13ec3b994b1f6c03e1d8afb5ecd7ffa5
--- /dev/null
+++ b/substrate/scripts/ci/monitoring/grafana-dashboards/substrate-networking.json
@@ -0,0 +1,2813 @@
+{
+  "__inputs": [
+    {
+      "name": "VAR_METRIC_NAMESPACE",
+      "type": "constant",
+      "label": "Prefix of the metrics",
+      "value": "substrate",
+      "description": ""
+    }
+  ],
+  "__requires": [
+    {
+      "type": "panel",
+      "id": "dashlist",
+      "name": "Dashboard list",
+      "version": ""
+    },
+    {
+      "type": "grafana",
+      "id": "grafana",
+      "name": "Grafana",
+      "version": "7.3.6"
+    },
+    {
+      "type": "panel",
+      "id": "graph",
+      "name": "Graph",
+      "version": ""
+    },
+    {
+      "type": "datasource",
+      "id": "prometheus",
+      "name": "Prometheus",
+      "version": "1.0.0"
+    }
+  ],
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "limit": 100,
+        "name": "Annotations & Alerts",
+        "showIn": 0,
+        "type": "dashboard"
+      },
+      {
+        "datasource": "$data_source",
+        "enable": true,
+        "expr": "count(count(${metric_namespace}_sub_libp2p_connections / max_over_time(${metric_namespace}_sub_libp2p_connections[1h]) < 0.1) >= count(${metric_namespace}_sub_libp2p_connections) / 10)",
+        "hide": false,
+        "iconColor": "#C4162A",
+        "limit": 100,
+        "name": "Connection losses events",
+        "showIn": 0,
+        "step": "5m",
+        "tags": [],
+        "titleFormat": "Network-wide connectivity loss",
+        "type": "tags"
+      }
+    ]
+  },
+  "description": "Information related to the networking layer of Substrate",
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 0,
+  "id": null,
+  "iteration": 1621244671073,
+  "links": [],
+  "panels": [
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 0
+      },
+      "id": 27,
+      "panels": [],
+      "title": "Transport",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 1
+      },
+      "hiddenSeries": false,
+      "id": 19,
+      "interval": "",
+      "legend": {
+        "alignAsTable": false,
+        "avg": false,
+        "current": false,
+        "hideEmpty": false,
+        "max": false,
+        "min": false,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "maxPerRow": 12,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [
+        {
+          "$$hashKey": "object:70",
+          "alias": "established (in)",
+          "color": "#37872D"
+        },
+        {
+          "$$hashKey": "object:71",
+          "alias": "established (out)",
+          "color": "#C4162A"
+        },
+        {
+          "$$hashKey": "object:72",
+          "alias": "pending (out)",
+          "color": "#FF7383"
+        },
+        {
+          "$$hashKey": "object:73",
+          "alias": "closed-recently",
+          "color": "#FADE2A",
+          "steppedLine": true
+        }
+      ],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "(\n  sum(${metric_namespace}_sub_libp2p_connections_opened_total{direction=\"in\", instance=~\"${nodename}\"}) by (instance) -\n  sum(${metric_namespace}_sub_libp2p_connections_closed_total{direction=\"in\", instance=~\"${nodename}\"}) by (instance)\n)\n\n# Because `closed_total` can be null, this serves as fallback\nor on(instance) sum(${metric_namespace}_sub_libp2p_connections_opened_total{direction=\"in\", instance=~\"${nodename}\"}) by (instance)",
+          "format": "time_series",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "established (in)",
+          "refId": "A"
+        },
+        {
+          "expr": "(\n  sum(${metric_namespace}_sub_libp2p_connections_opened_total{direction=\"out\", instance=~\"${nodename}\"}) by (instance) -\n  sum(${metric_namespace}_sub_libp2p_connections_closed_total{direction=\"out\", instance=~\"${nodename}\"}) by (instance)\n)\n\n# Because `closed_total` can be null, this serves as fallback\nor on(instance) sum(${metric_namespace}_sub_libp2p_connections_opened_total{direction=\"out\", instance=~\"${nodename}\"}) by (instance)",
+          "hide": false,
+          "instant": false,
+          "interval": "",
+          "legendFormat": "established (out)",
+          "refId": "C"
+        },
+        {
+          "expr": "sum by (instance) (${metric_namespace}_sub_libp2p_pending_connections{instance=~\"${nodename}\"})",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "pending (out)",
+          "refId": "B"
+        },
+        {
+          "expr": "sum(rate(${metric_namespace}_sub_libp2p_connections_closed_total{instance=~\"${nodename}\"}[$__interval]))",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "closed-per-sec",
+          "refId": "D"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Average transport-level (TCP, QUIC, ...) connections",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:100",
+          "format": "short",
+          "label": "Connections",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:101",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 7
+      },
+      "hiddenSeries": false,
+      "id": 189,
+      "interval": "",
+      "legend": {
+        "alignAsTable": false,
+        "avg": false,
+        "current": false,
+        "hideEmpty": false,
+        "max": false,
+        "min": false,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "maxPerRow": 12,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "1 - \n\navg(\n  ${metric_namespace}_sub_libp2p_distinct_peers_connections_opened_total{instance=~\"${nodename}\"} - ${metric_namespace}_sub_libp2p_distinct_peers_connections_closed_total{instance=~\"${nodename}\"}\n) by (instance)\n\n/\n\navg(\r\n  sum(${metric_namespace}_sub_libp2p_connections_opened_total{instance=~\"${nodename}\"}) by (instance) - sum(${metric_namespace}_sub_libp2p_connections_closed_total{instance=~\"${nodename}\"}) by (instance)\r\n) by (instance)",
+          "format": "time_series",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Percentage of peers for which we have more than one connection open",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:184",
+          "format": "percentunit",
+          "label": "",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:185",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": true,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 13
+      },
+      "hiddenSeries": false,
+      "id": 39,
+      "interval": "",
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": false,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [
+        {
+          "$$hashKey": "object:263",
+          "alias": "/.*/",
+          "color": "#FF780A"
+        }
+      ],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "increase(${metric_namespace}_sub_libp2p_incoming_connections_handshake_errors_total{instance=~\"${nodename}\"}[$__rate_interval])",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "{{reason}}",
+          "refId": "A"
+        },
+        {
+          "expr": "increase(${metric_namespace}_sub_libp2p_listeners_errors_total{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "pre-handshake",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Number of incoming connection errors",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:270",
+          "format": "short",
+          "label": "Errors",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:271",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "description": "",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {}
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 19
+      },
+      "hiddenSeries": false,
+      "id": 4,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_sub_libp2p_network_bytes_total{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{direction}}",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Network bandwidth",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:352",
+          "format": "binBps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:353",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": true,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 7,
+        "w": 24,
+        "x": 0,
+        "y": 25
+      },
+      "hiddenSeries": false,
+      "id": 81,
+      "interval": "",
+      "legend": {
+        "alignAsTable": false,
+        "avg": false,
+        "current": false,
+        "hideEmpty": true,
+        "hideZero": true,
+        "max": false,
+        "min": false,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": false,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "increase(${metric_namespace}_sub_libp2p_pending_connections_errors_total{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{reason}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Dialing attempt errors",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:431",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:432",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 7,
+        "w": 24,
+        "x": 0,
+        "y": 32
+      },
+      "hiddenSeries": false,
+      "id": 46,
+      "interval": "",
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "maxPerRow": 12,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_sub_libp2p_connections_closed_total{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{reason}} ({{direction}})",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Disconnects/sec",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:514",
+          "decimals": null,
+          "format": "cps",
+          "label": "Disconnects",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:515",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 39
+      },
+      "id": 167,
+      "panels": [],
+      "repeat": null,
+      "title": "Sync",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 5,
+        "w": 24,
+        "x": 0,
+        "y": 40
+      },
+      "hiddenSeries": false,
+      "id": 101,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "${metric_namespace}_sub_libp2p_peerset_num_requested{instance=~\"${nodename}\"}",
+          "interval": "",
+          "legendFormat": "peers-requested",
+          "refId": "A"
+        },
+        {
+          "expr": "${metric_namespace}_sub_libp2p_peers_count{instance=~\"${nodename}.*\"}",
+          "interval": "",
+          "legendFormat": "peers-count",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Number of peer slots filled",
+      "tooltip": {
+        "shared": true,
+        "sort": 1,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:679",
+          "format": "none",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "$$hashKey": "object:680",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 45
+      },
+      "id": 29,
+      "panels": [],
+      "repeat": "request_protocol_out",
+      "title": "Outbound requests (${request_protocol_out})",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 46
+      },
+      "hiddenSeries": false,
+      "id": 148,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_sub_libp2p_requests_out_success_total_count{instance=~\"${nodename}\", protocol=\"${request_protocol_out}\"}[$__rate_interval]) + on(instance) sum(rate(${metric_namespace}_sub_libp2p_requests_out_failure_total{instance=~\"${nodename}\", protocol=\"${request_protocol_out}\"}[$__rate_interval])) by (instance)\n\nor\n\nrate(${metric_namespace}_sub_libp2p_requests_out_success_total_count{instance=~\"${nodename}\", protocol=\"${request_protocol_out}\"}[$__rate_interval])",
+          "hide": false,
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Requests emitted per second",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:209",
+          "format": "reqps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:210",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 50
+      },
+      "hiddenSeries": false,
+      "id": 448,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(${metric_namespace}_sub_libp2p_requests_out_failure_total{instance=~\"${nodename}\", protocol=\"${request_protocol_out}\", reason != \"obsolete\"}[$__rate_interval])) by (instance, reason)",
+          "hide": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{reason}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Outbound requests failures (other than \"obsolete\")",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:209",
+          "format": "reqps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:210",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 54
+      },
+      "hiddenSeries": false,
+      "id": 256,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.5, sum(rate(${metric_namespace}_sub_libp2p_requests_out_success_total_bucket{instance=~\"${nodename}\", protocol=\"${request_protocol_out}\"}[$__rate_interval])) by (instance, le)) > 0",
+          "instant": false,
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Median request answer time",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:1069",
+          "format": "s",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:1070",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 58
+      },
+      "hiddenSeries": false,
+      "id": 257,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(${metric_namespace}_sub_libp2p_requests_out_success_total_bucket{instance=~\"${nodename}\", protocol=\"${request_protocol_out}\"}[$__rate_interval])) by (instance, le)) > 0",
+          "instant": false,
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "99th percentile request answer time",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:988",
+          "format": "s",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:989",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 62
+      },
+      "id": 504,
+      "panels": [],
+      "repeat": "request_protocol_in",
+      "title": "Inbound requests (${request_protocol_in})",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 63
+      },
+      "hiddenSeries": false,
+      "id": 151,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_sub_libp2p_requests_in_success_total_count{instance=~\"${nodename}\", protocol=\"${request_protocol_in}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Requests served per second",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:907",
+          "format": "reqps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:908",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 67
+      },
+      "hiddenSeries": false,
+      "id": 449,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(${metric_namespace}_sub_libp2p_requests_in_failure_total{instance=~\"${nodename}\", protocol=\"${request_protocol_in}\"}[$__rate_interval])) by (instance, reason)",
+          "hide": false,
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{reason}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Inbound requests failures",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:209",
+          "format": "reqps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:210",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 71
+      },
+      "hiddenSeries": false,
+      "id": 258,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.5, sum(rate(${metric_namespace}_sub_libp2p_requests_in_success_total_bucket{instance=~\"${nodename}\", protocol=\"${request_protocol_in}\"}[$__rate_interval])) by (instance, le))",
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Median request serving time",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:666",
+          "format": "s",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:667",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 4,
+        "w": 24,
+        "x": 0,
+        "y": 75
+      },
+      "hiddenSeries": false,
+      "id": 259,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(${metric_namespace}_sub_libp2p_requests_in_success_total_bucket{instance=~\"${nodename}\", protocol=\"${request_protocol_in}\"}[$__rate_interval])) by (instance, le))",
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "99th percentile request serving time",
+      "tooltip": {
+        "shared": false,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:747",
+          "format": "s",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:748",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 79
+      },
+      "id": 23,
+      "panels": [],
+      "repeat": "notif_protocol",
+      "title": "Notifications (${notif_protocol})",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 80
+      },
+      "hiddenSeries": false,
+      "id": 447,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": true,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "${metric_namespace}_sub_libp2p_notifications_streams_opened_total{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"} - ${metric_namespace}_sub_libp2p_notifications_streams_closed_total{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"}",
+          "interval": "",
+          "legendFormat": "{{instance}}",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Number of open substreams",
+      "tooltip": {
+        "shared": false,
+        "sort": 1,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:896",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:897",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 86
+      },
+      "hiddenSeries": false,
+      "id": 486,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": true,
+        "rightSide": false,
+        "show": false,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_sub_libp2p_notifications_streams_closed_total{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"}[$__rate_interval])",
+          "interval": "",
+          "intervalFactor": 4,
+          "legendFormat": "{{instance}}",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Substreams closed/sec",
+      "tooltip": {
+        "shared": false,
+        "sort": 1,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:484",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:485",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 92
+      },
+      "hiddenSeries": false,
+      "id": 31,
+      "interval": "",
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "maxPerRow": 12,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [
+        {
+          "$$hashKey": "object:399",
+          "alias": "/(in)/",
+          "color": "#73BF69"
+        },
+        {
+          "$$hashKey": "object:400",
+          "alias": "/(out)/",
+          "color": "#F2495C"
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "avg by (direction) (rate(${metric_namespace}_sub_libp2p_notifications_sizes_count{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"}[$__rate_interval]))",
+          "interval": "",
+          "legendFormat": "{{direction}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Number of network notifications",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:413",
+          "format": "short",
+          "label": "Notifs/sec",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:414",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 98
+      },
+      "hiddenSeries": false,
+      "id": 37,
+      "interval": "",
+      "legend": {
+        "alignAsTable": false,
+        "avg": false,
+        "current": false,
+        "hideEmpty": false,
+        "hideZero": false,
+        "max": false,
+        "min": false,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "maxPerRow": 12,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [
+        {
+          "$$hashKey": "object:492",
+          "alias": "/(in)/",
+          "color": "#73BF69"
+        },
+        {
+          "$$hashKey": "object:493",
+          "alias": "/(out)/",
+          "color": "#F2495C"
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "avg(rate(${metric_namespace}_sub_libp2p_notifications_sizes_sum{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"}[$__rate_interval])) by (direction)",
+          "instant": false,
+          "interval": "",
+          "legendFormat": "{{direction}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Average bandwidth used by notifications",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:506",
+          "format": "Bps",
+          "label": "Bandwidth",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:507",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 104
+      },
+      "hiddenSeries": false,
+      "id": 16,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "${metric_namespace}_sub_libp2p_out_events_notifications_sizes{instance=~\"${nodename}\", protocol=\"${notif_protocol}\", action=\"sent\"} - ignoring(action) ${metric_namespace}_sub_libp2p_out_events_notifications_sizes{instance=~\"${nodename}\", protocol=\"${notif_protocol}\", action=\"received\"}",
+          "interval": "",
+          "legendFormat": "{{name}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Total sizes of notifications waiting to be delivered to the rest of Substrate",
+      "tooltip": {
+        "shared": false,
+        "sort": 1,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:232",
+          "format": "bytes",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:233",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 1,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 110
+      },
+      "hiddenSeries": false,
+      "id": 21,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(rate(${metric_namespace}_sub_libp2p_notifications_sizes_sum{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"}[$__rate_interval])) by (direction, protocol) / sum(rate(${metric_namespace}_sub_libp2p_notifications_sizes_count{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"}[$__rate_interval])) by (direction, protocol)",
+          "format": "time_series",
+          "interval": "",
+          "legendFormat": "{{direction}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Average size of sent and received notifications",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:322",
+          "format": "bytes",
+          "label": "Max. notification size",
+          "logBase": 10,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:323",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 1,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 116
+      },
+      "hiddenSeries": false,
+      "id": 134,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": false,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, sum(irate(${metric_namespace}_sub_libp2p_notifications_sizes_bucket{instance=~\"${nodename}\", protocol=\"${notif_protocol}\"}[$__rate_interval])) by (direction, le))",
+          "format": "time_series",
+          "interval": "",
+          "legendFormat": "{{direction}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "99th percentile of size of sent and received notifications",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:244",
+          "format": "bytes",
+          "label": "Max. notification size",
+          "logBase": 10,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:245",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 122
+      },
+      "id": 52,
+      "panels": [],
+      "title": "GrandPa",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": true,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 123
+      },
+      "hiddenSeries": false,
+      "id": 54,
+      "interval": "1m",
+      "legend": {
+        "alignAsTable": true,
+        "avg": false,
+        "current": false,
+        "hideEmpty": true,
+        "hideZero": true,
+        "max": false,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": true,
+        "values": true
+      },
+      "lines": false,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "repeatDirection": "h",
+      "seriesOverrides": [
+        {
+          "$$hashKey": "object:366",
+          "alias": "/discard/",
+          "color": "#FA6400",
+          "zindex": -2
+        },
+        {
+          "$$hashKey": "object:367",
+          "alias": "/keep/",
+          "color": "#73BF69",
+          "zindex": 2
+        },
+        {
+          "$$hashKey": "object:368",
+          "alias": "/process_and_discard/",
+          "color": "#5794F2"
+        }
+      ],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_finality_grandpa_communication_gossip_validator_messages{instance=~\"${nodename}\"}[$__interval])",
+          "interval": "",
+          "legendFormat": "{{message}} => {{action}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "GrandPa messages received from the network, and action",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:409",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:410",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 129
+      },
+      "id": 25,
+      "panels": [],
+      "repeat": null,
+      "title": "Kademlia & authority-discovery",
+      "type": "row"
+    },
+    {
+      "datasource": null,
+      "description": "",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {}
+        },
+        "overrides": []
+      },
+      "folderId": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 130
+      },
+      "headings": true,
+      "id": 423,
+      "limit": 10,
+      "pluginVersion": "7.2.1",
+      "query": "kademlia",
+      "recent": false,
+      "search": false,
+      "starred": false,
+      "tags": [],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Kademlia and Authority Discovery metrics moved to \"kademlia-and-authority-discovery\" dashboard.",
+      "type": "dashlist"
+    }
+  ],
+  "refresh": false,
+  "schemaVersion": 26,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": [
+      {
+        "allValue": null,
+        "current": {},
+        "datasource": "$data_source",
+        "definition": "${metric_namespace}_process_start_time_seconds",
+        "error": null,
+        "hide": 0,
+        "includeAll": false,
+        "label": "Instance name filter",
+        "multi": true,
+        "name": "nodename",
+        "options": [],
+        "query": "${metric_namespace}_process_start_time_seconds",
+        "refresh": 1,
+        "regex": "/instance=\"(.*?)\"/",
+        "skipUrlSync": false,
+        "sort": 1,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      },
+      {
+        "allValue": null,
+        "current": {},
+        "datasource": "$data_source",
+        "definition": "${metric_namespace}_sub_libp2p_notifications_streams_opened_total{instance=~\"${nodename}\"}",
+        "error": null,
+        "hide": 2,
+        "includeAll": true,
+        "label": null,
+        "multi": false,
+        "name": "notif_protocol",
+        "options": [],
+        "query": "${metric_namespace}_sub_libp2p_notifications_streams_opened_total{instance=~\"${nodename}\"}",
+        "refresh": 1,
+        "regex": "/protocol=\"(.*?)\"/",
+        "skipUrlSync": false,
+        "sort": 5,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      },
+      {
+        "allValue": null,
+        "current": {},
+        "datasource": "$data_source",
+        "definition": "${metric_namespace}_sub_libp2p_requests_in_success_total_count{instance=~\"${nodename}\"}",
+        "error": null,
+        "hide": 2,
+        "includeAll": true,
+        "label": null,
+        "multi": false,
+        "name": "request_protocol_in",
+        "options": [],
+        "query": "${metric_namespace}_sub_libp2p_requests_in_success_total_count{instance=~\"${nodename}\"}",
+        "refresh": 1,
+        "regex": "/protocol=\"(.*?)\"/",
+        "skipUrlSync": false,
+        "sort": 5,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      },
+      {
+        "current": {
+          "selected": false,
+          "text": "prometheus.parity-mgmt",
+          "value": "prometheus.parity-mgmt"
+        },
+        "error": null,
+        "hide": 0,
+        "includeAll": false,
+        "label": "Source of data",
+        "multi": false,
+        "name": "data_source",
+        "options": [],
+        "query": "prometheus",
+        "queryValue": "",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "type": "datasource"
+      },
+      {
+        "current": {
+          "value": "${VAR_METRIC_NAMESPACE}",
+          "text": "${VAR_METRIC_NAMESPACE}",
+          "selected": false
+        },
+        "error": null,
+        "hide": 2,
+        "label": "Prefix of the metrics",
+        "name": "metric_namespace",
+        "options": [
+          {
+            "value": "${VAR_METRIC_NAMESPACE}",
+            "text": "${VAR_METRIC_NAMESPACE}",
+            "selected": false
+          }
+        ],
+        "query": "${VAR_METRIC_NAMESPACE}",
+        "skipUrlSync": false,
+        "type": "constant"
+      },
+      {
+        "allValue": null,
+        "current": {},
+        "datasource": "$data_source",
+        "definition": "${metric_namespace}_sub_libp2p_requests_out_success_total_count{instance=~\"${nodename}\"}",
+        "error": null,
+        "hide": 2,
+        "includeAll": true,
+        "label": null,
+        "multi": false,
+        "name": "request_protocol_out",
+        "options": [],
+        "query": "${metric_namespace}_sub_libp2p_requests_out_success_total_count{instance=~\"${nodename}\"}",
+        "refresh": 1,
+        "regex": "/protocol=\"(.*?)\"/",
+        "skipUrlSync": false,
+        "sort": 5,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      }
+    ]
+  },
+  "time": {
+    "from": "now-12h",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ]
+  },
+  "timezone": "utc",
+  "title": "Substrate Networking",
+  "uid": "vKVuiD9Zk",
+  "version": 176
+}
\ No newline at end of file
diff --git a/substrate/scripts/ci/monitoring/grafana-dashboards/substrate-service-tasks.json b/substrate/scripts/ci/monitoring/grafana-dashboards/substrate-service-tasks.json
new file mode 100644
index 0000000000000000000000000000000000000000..ce7e9f78cd8ae033b5a9d0b2bcc6886e08c8b73b
--- /dev/null
+++ b/substrate/scripts/ci/monitoring/grafana-dashboards/substrate-service-tasks.json
@@ -0,0 +1,1064 @@
+{
+  "__inputs": [
+    {
+      "name": "VAR_METRIC_NAMESPACE",
+      "type": "constant",
+      "label": "Prefix of the metrics",
+      "value": "substrate",
+      "description": ""
+    }
+  ],
+  "__requires": [
+    {
+      "type": "grafana",
+      "id": "grafana",
+      "name": "Grafana",
+      "version": "7.3.6"
+    },
+    {
+      "type": "panel",
+      "id": "graph",
+      "name": "Graph",
+      "version": ""
+    },
+    {
+      "type": "datasource",
+      "id": "prometheus",
+      "name": "Prometheus",
+      "version": "1.0.0"
+    },
+    {
+      "type": "panel",
+      "id": "text",
+      "name": "Text",
+      "version": ""
+    }
+  ],
+  "annotations": {
+    "list": [
+      {
+        "$$hashKey": "object:326",
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "limit": 100,
+        "name": "Annotations & Alerts",
+        "showIn": 0,
+        "type": "dashboard"
+      },
+      {
+        "$$hashKey": "object:327",
+        "datasource": "$data_source",
+        "enable": true,
+        "expr": "increase(${metric_namespace}_tasks_ended_total{reason=\"panic\", instance=~\"${nodename}\"}[10m])",
+        "hide": true,
+        "iconColor": "rgba(255, 96, 96, 1)",
+        "limit": 100,
+        "name": "Task panics",
+        "rawQuery": "SELECT\n  extract(epoch from time_column) AS time,\n  text_column as text,\n  tags_column as tags\nFROM\n  metric_table\nWHERE\n  $__timeFilter(time_column)\n",
+        "showIn": 0,
+        "step": "10m",
+        "tags": [],
+        "textFormat": "{{instance}} - {{task_name}}",
+        "titleFormat": "Panic!",
+        "type": "tags"
+      },
+      {
+        "$$hashKey": "object:621",
+        "datasource": "$data_source",
+        "enable": true,
+        "expr": "changes(${metric_namespace}_process_start_time_seconds{instance=~\"${nodename}\"}[10m])",
+        "hide": false,
+        "iconColor": "#8AB8FF",
+        "name": "Node reboots",
+        "showIn": 0,
+        "step": "10m",
+        "textFormat": "{{instance}}",
+        "titleFormat": "Reboots"
+      }
+    ]
+  },
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 0,
+  "id": null,
+  "iteration": 1621244116095,
+  "links": [],
+  "panels": [
+    {
+      "datasource": null,
+      "description": "",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {}
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 0
+      },
+      "id": 42,
+      "options": {
+        "content": "",
+        "mode": "markdown"
+      },
+      "pluginVersion": "7.3.6",
+      "repeat": "nodename",
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "$nodename",
+      "type": "text"
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 1
+      },
+      "id": 29,
+      "panels": [],
+      "title": "Tasks",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 3,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 2
+      },
+      "hiddenSeries": false,
+      "id": 11,
+      "interval": "",
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": false,
+        "hideEmpty": false,
+        "hideZero": false,
+        "max": false,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_tasks_polling_duration_sum{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{task_name}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "CPU time spent on each task",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:2721",
+          "format": "percentunit",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:2722",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 3,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 8
+      },
+      "hiddenSeries": false,
+      "id": 30,
+      "interval": "",
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": false,
+        "hideEmpty": false,
+        "hideZero": false,
+        "max": false,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(${metric_namespace}_tasks_polling_duration_count{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{task_name}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Task polling rate per second",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:2571",
+          "format": "cps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:2572",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 14
+      },
+      "hiddenSeries": false,
+      "id": 43,
+      "interval": "",
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "hideEmpty": true,
+        "hideZero": false,
+        "max": true,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "increase(${metric_namespace}_tasks_polling_duration_sum{instance=~\"${nodename}\"}[$__rate_interval]) / increase(${metric_namespace}_tasks_polling_duration_count{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{task_name}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Average time it takes to call Future::poll()",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:2571",
+          "format": "s",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "$$hashKey": "object:2572",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": true,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 20
+      },
+      "hiddenSeries": false,
+      "id": 15,
+      "interval": "",
+      "legend": {
+        "alignAsTable": true,
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": true,
+        "values": true
+      },
+      "lines": false,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": true,
+      "targets": [
+        {
+          "expr": "increase(${metric_namespace}_tasks_spawned_total{instance=~\"${nodename}\"}[$__rate_interval])",
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{task_name}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Number of tasks started",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:771",
+          "format": "short",
+          "label": null,
+          "logBase": 10,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "$$hashKey": "object:772",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 26
+      },
+      "hiddenSeries": false,
+      "id": 2,
+      "interval": "",
+      "legend": {
+        "alignAsTable": true,
+        "avg": false,
+        "current": true,
+        "max": true,
+        "min": true,
+        "rightSide": true,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "${metric_namespace}_tasks_spawned_total{instance=~\"${nodename}\"} - sum(${metric_namespace}_tasks_ended_total{instance=~\"${nodename}\"}) without(reason)\n\n# Fallback if tasks_ended_total is null for that task\nor on(instance, task_name) ${metric_namespace}_tasks_spawned_total{instance=~\"${nodename}\"}",
+          "interval": "",
+          "legendFormat": "{{task_name}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Number of tasks running",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:919",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "$$hashKey": "object:920",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "decimals": null,
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 6,
+        "w": 24,
+        "x": 0,
+        "y": 32
+      },
+      "hiddenSeries": false,
+      "id": 7,
+      "interval": "",
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": false,
+        "hideEmpty": true,
+        "hideZero": true,
+        "max": false,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "null as zero",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": true,
+      "targets": [
+        {
+          "expr": "irate(${metric_namespace}_tasks_polling_duration_bucket{instance=~\"${nodename}\", le=\"+Inf\"}[$__rate_interval])\n    - ignoring(le)\n  irate(${metric_namespace}_tasks_polling_duration_bucket{instance=~\"${nodename}\", le=\"1.024\"}[$__rate_interval]) > 0",
+          "interval": "",
+          "legendFormat": "{{task_name}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Number of calls to `Future::poll` that took more than one second",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:3040",
+          "decimals": null,
+          "format": "cps",
+          "label": "Calls to `Future::poll`/second",
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "$$hashKey": "object:3041",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "collapsed": false,
+      "datasource": null,
+      "gridPos": {
+        "h": 1,
+        "w": 24,
+        "x": 0,
+        "y": 38
+      },
+      "id": 27,
+      "panels": [],
+      "title": "Unbounded Channels",
+      "type": "row"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 7,
+        "w": 24,
+        "x": 0,
+        "y": 39
+      },
+      "hiddenSeries": false,
+      "id": 32,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": false,
+        "max": true,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "(\n  ${metric_namespace}_unbounded_channel_len{instance=~\"${nodename}\", action = \"send\"} - ignoring(action) ${metric_namespace}_unbounded_channel_len{instance=~\"${nodename}\", action = \"received\"}\n)\n\n# Fallback if the `received` is null\nor on(instance) ${metric_namespace}_unbounded_channel_len{instance=~\"${nodename}\", action = \"send\"}",
+          "interval": "",
+          "legendFormat": "{{entity}}",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Unbounded channels size",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:626",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:627",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "$data_source",
+      "fieldConfig": {
+        "defaults": {
+          "custom": {},
+          "links": []
+        },
+        "overrides": []
+      },
+      "fill": 0,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 7,
+        "w": 24,
+        "x": 0,
+        "y": 46
+      },
+      "hiddenSeries": false,
+      "id": 33,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": false,
+        "max": false,
+        "min": false,
+        "rightSide": true,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 1,
+      "nullPointMode": "connected",
+      "options": {
+        "alertThreshold": true
+      },
+      "percentage": false,
+      "pluginVersion": "7.3.6",
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "repeat": "nodename",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "irate(${metric_namespace}_unbounded_channel_len{instance=~\"${nodename}\", action = \"send\"}[$__rate_interval])",
+          "interval": "",
+          "legendFormat": "{{entity}}",
+          "refId": "B"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Unbounded channels message sending rate (1s)",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "$$hashKey": "object:626",
+          "format": "cps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "$$hashKey": "object:627",
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    }
+  ],
+  "refresh": false,
+  "schemaVersion": 26,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": [
+      {
+        "allValue": null,
+        "current": {},
+        "datasource": "$data_source",
+        "definition": "${metric_namespace}_process_start_time_seconds",
+        "error": null,
+        "hide": 0,
+        "includeAll": false,
+        "label": "Instance filter",
+        "multi": true,
+        "name": "nodename",
+        "options": [],
+        "query": "${metric_namespace}_process_start_time_seconds",
+        "refresh": 1,
+        "regex": "/instance=\"(.*?)\"/",
+        "skipUrlSync": false,
+        "sort": 0,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      },
+      {
+        "current": {
+          "value": "${VAR_METRIC_NAMESPACE}",
+          "text": "${VAR_METRIC_NAMESPACE}",
+          "selected": false
+        },
+        "error": null,
+        "hide": 2,
+        "label": "Prefix of the metrics",
+        "name": "metric_namespace",
+        "options": [
+          {
+            "value": "${VAR_METRIC_NAMESPACE}",
+            "text": "${VAR_METRIC_NAMESPACE}",
+            "selected": false
+          }
+        ],
+        "query": "${VAR_METRIC_NAMESPACE}",
+        "skipUrlSync": false,
+        "type": "constant"
+      },
+      {
+        "current": {
+          "selected": false,
+          "text": "prometheus.parity-mgmt",
+          "value": "prometheus.parity-mgmt"
+        },
+        "error": null,
+        "hide": 0,
+        "includeAll": false,
+        "label": "Source of all the data",
+        "multi": false,
+        "name": "data_source",
+        "options": [],
+        "query": "prometheus",
+        "refresh": 1,
+        "regex": "",
+        "skipUrlSync": false,
+        "type": "datasource"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-12h",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ]
+  },
+  "timezone": "utc",
+  "title": "Substrate Service Tasks",
+  "uid": "3LA6XNqZz",
+  "version": 69
+}
\ No newline at end of file
diff --git a/substrate/scripts/ci/node-template-release.sh b/substrate/scripts/ci/node-template-release.sh
new file mode 100755
index 0000000000000000000000000000000000000000..09ef98e04627a023ed0892e96a3a5bc798df5a11
--- /dev/null
+++ b/substrate/scripts/ci/node-template-release.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+set -e
+
+export TERM=xterm
+PROJECT_ROOT=`git rev-parse --show-toplevel`
+
+if [ "$#" -ne 1 ]; then
+  echo "node-template-release.sh path_to_target_archive"
+  exit 1
+fi
+
+PATH_TO_ARCHIVE=$1
+cd $PROJECT_ROOT/scripts/ci/node-template-release
+
+cargo run $PROJECT_ROOT/bin/node-template $PROJECT_ROOT/$PATH_TO_ARCHIVE
diff --git a/substrate/scripts/ci/node-template-release/Cargo.toml b/substrate/scripts/ci/node-template-release/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1fc35b63b1df25817525e41ef5537022ac4c7374
--- /dev/null
+++ b/substrate/scripts/ci/node-template-release/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "node-template-release"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "GPL-3.0 WITH Classpath-exception-2.0"
+homepage = "https://substrate.io"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive"] }
+flate2 = "1.0"
+fs_extra = "1.3"
+glob = "0.3"
+tar = "0.4"
+tempfile = "3"
+toml_edit = "0.19"
+itertools = "0.10"
diff --git a/substrate/scripts/ci/node-template-release/src/main.rs b/substrate/scripts/ci/node-template-release/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9681d73fa6fccdea2d4db5037372f841bc4c300b
--- /dev/null
+++ b/substrate/scripts/ci/node-template-release/src/main.rs
@@ -0,0 +1,424 @@
+use std::{
+	collections::HashMap,
+	fs::{self, File, OpenOptions},
+	path::{Path, PathBuf},
+	process::Command,
+};
+
+use clap::Parser;
+use flate2::{write::GzEncoder, Compression};
+use fs_extra::dir::{self, CopyOptions};
+use glob;
+use itertools::Itertools;
+use tar;
+use tempfile;
+use toml_edit::{self, value, Array, Item, Table};
+
+const SUBSTRATE_GIT_URL: &str = "https://github.com/paritytech/substrate.git";
+
+type CargoToml = toml_edit::Document;
+
+#[derive(Debug, PartialEq)]
+struct Dependency {
+	name: String,
+	version: Option<String>,
+	default_features: Option<bool>,
+}
+
+type Dependencies = HashMap<String, HashMap<String, Dependency>>;
+
+#[derive(Parser)]
+struct Options {
+	/// The path to the `node-template` source.
+	#[arg()]
+	node_template: PathBuf,
+	/// The path where to output the generated `tar.gz` file.
+	#[arg()]
+	output: PathBuf,
+}
+
+/// Copy the `node-template` to the given path.
+fn copy_node_template(node_template: &Path, dest_path: &Path) {
+	let options = CopyOptions::new();
+	dir::copy(node_template, dest_path, &options).expect("Copies node-template to tmp dir");
+}
+
+/// Find all `Cargo.toml` files in the given path.
+fn find_cargo_tomls(path: &PathBuf) -> Vec<PathBuf> {
+	let path = format!("{}/**/*.toml", path.display());
+
+	let glob = glob::glob(&path).expect("Generates globbing pattern");
+
+	let mut result = Vec::new();
+	glob.into_iter().for_each(|file| match file {
+		Ok(file) => result.push(file),
+		Err(e) => println!("{:?}", e),
+	});
+
+	if result.is_empty() {
+		panic!("Did not found any `Cargo.toml` files.");
+	}
+
+	result
+}
+
+/// Parse the given `Cargo.toml`.
+fn parse_cargo_toml(file: &Path) -> CargoToml {
+	fs::read_to_string(file)
+		.unwrap_or_else(|e| panic!("Failed to read `{}`: {}", file.display(), e))
+		.parse()
+		.unwrap_or_else(|e| panic!("Failed to parse `{}`: {}", file.display(), e))
+}
+
+/// Write the given `Cargo.toml` to the given path.
+fn write_cargo_toml(path: &Path, cargo_toml: CargoToml) {
+	fs::write(path, cargo_toml.to_string())
+		.unwrap_or_else(|e| panic!("Failed to write `{}`: {}", path.display(), e));
+}
+
+/// Gets the latest commit id of the repository given by `path`.
+fn get_git_commit_id(path: &Path) -> String {
+	let mut dir = path;
+	while !dir.join(".git").exists() {
+		dir = dir
+			.parent()
+			.expect(&format!("Node template ({}) should be in a git repository.", path.display()));
+	}
+
+	let git = dir.join(".git");
+	let head = git.join("HEAD");
+	let head_contents = fs::read_to_string(head).expect("Repository should have a HEAD");
+	let branch = head_contents.strip_prefix("ref: ").expect(".git/HEAD to start 'ref: '").trim();
+	let mut commit = fs::read_to_string(git.join(branch)).expect("Head references a commit");
+	commit.truncate(commit.trim_end().len());
+	commit
+}
+
+/// Rewrites git dependencies:
+/// - inserts `workspace = true`;
+/// - removes `path`;
+/// - removes `version`;
+/// - removes `default-features`
+/// - and returns the dependencies that were rewritten.
+fn update_git_dependencies<F: Copy + Fn(&str) -> bool>(
+	cargo_toml: &mut CargoToml,
+	path_filter: F,
+) -> Dependencies {
+	let process_dep = |dep: (toml_edit::KeyMut, &mut Item)| -> Option<Dependency> {
+		let (key, value) = dep;
+		value
+			.as_table_like_mut()
+			.filter(|dep| {
+				dep.get("path").and_then(|path| path.as_str()).map(path_filter).unwrap_or(false)
+			})
+			.map(|dep| {
+				dep.insert("workspace", toml_edit::value(true));
+				dep.remove("path");
+
+				Dependency {
+					name: key.get().to_string(),
+					version: dep
+						.remove("version")
+						.and_then(|version| version.as_str().map(|s| s.to_string())),
+					default_features: dep.remove("default-features").and_then(|b| b.as_bool()),
+				}
+			})
+	};
+
+	["dependencies", "build-dependencies", "dev-dependencies"]
+		.into_iter()
+		.map(|table| -> (String, HashMap<String, Dependency>) {
+			(
+				table.to_string(),
+				cargo_toml[table]
+					.as_table_mut()
+					.into_iter()
+					.flat_map(|deps| deps.iter_mut().filter_map(process_dep))
+					.map(|dep| (dep.name.clone(), dep))
+					.collect(),
+			)
+		})
+		.collect()
+}
+
+/// Processes all `Cargo.toml` files, aggregates dependencies and saves the changes.
+fn process_cargo_tomls(cargo_tomls: &Vec<PathBuf>) -> Dependencies {
+	/// Merge dependencies from one collection in another.
+	fn merge_deps(into: &mut Dependencies, from: Dependencies) {
+		from.into_iter().for_each(|(table, deps)| {
+			into.entry(table).or_insert_with(HashMap::new).extend(deps);
+		});
+	}
+
+	cargo_tomls.iter().fold(Dependencies::new(), |mut acc, path| {
+		let mut cargo_toml = parse_cargo_toml(&path);
+
+		let mut cargo_toml_path = path.clone();
+		cargo_toml_path.pop(); // remove `Cargo.toml` from the path
+		let deps = update_git_dependencies(&mut cargo_toml, |dep_path| {
+			!cargo_toml_path.join(dep_path).exists()
+		});
+
+		write_cargo_toml(&path, cargo_toml);
+		merge_deps(&mut acc, deps);
+		acc
+	})
+}
+
+/// Update the top level (workspace) `Cargo.toml` file.
+///
+/// - Adds `workspace` definition
+/// - Adds dependencies
+/// - Adds `profile.release` = `panic = unwind`
+fn update_root_cargo_toml(
+	cargo_toml: &mut CargoToml,
+	members: &[String],
+	deps: Dependencies,
+	commit_id: &str,
+) {
+	let mut workspace = Table::new();
+	workspace.insert("members", value(Array::from_iter(members.iter())));
+
+	let mut workspace_dependencies = Table::new();
+	deps.values()
+		.flatten()
+		.sorted_by_key(|(name, _)| *name)
+		.for_each(|(name, dep)| {
+			if let Some(version) = &dep.version {
+				workspace_dependencies[name]["version"] = value(version);
+			}
+			if let Some(default_features) = dep.default_features {
+				workspace_dependencies[name]["default-features"] = value(default_features);
+			}
+			workspace_dependencies[name]["git"] = value(SUBSTRATE_GIT_URL);
+			workspace_dependencies[name]["rev"] = value(commit_id);
+		});
+
+	workspace.insert("dependencies", Item::Table(workspace_dependencies));
+	cargo_toml.insert("workspace", Item::Table(workspace));
+
+	let mut panic_unwind = Table::new();
+	panic_unwind.insert("panic", value("unwind"));
+	let mut profile = Table::new();
+	profile.insert("release", Item::Table(panic_unwind));
+	cargo_toml.insert("profile", Item::Table(profile.into()));
+}
+
+fn process_root_cargo_toml(
+	root_cargo_toml_path: &Path,
+	root_deps: Dependencies,
+	cargo_tomls: &[PathBuf],
+	node_template_path: &PathBuf,
+	commit_id: &str,
+) {
+	let mut root_cargo_toml = parse_cargo_toml(root_cargo_toml_path);
+	let workspace_members = cargo_tomls
+		.iter()
+		.map(|p| {
+			p.strip_prefix(node_template_path)
+				.expect("Workspace member is a child of the node template path!")
+				.parent()
+				// We get the `Cargo.toml` paths as workspace members, but for the `members` field
+				// we just need the path.
+				.expect("The given path ends with `Cargo.toml` as file name!")
+				.display()
+				.to_string()
+		})
+		.collect::<Vec<_>>();
+
+	update_root_cargo_toml(&mut root_cargo_toml, &workspace_members, root_deps, commit_id);
+	write_cargo_toml(&root_cargo_toml_path, root_cargo_toml);
+}
+
+/// Build and test the generated node-template
+fn build_and_test(path: &Path, cargo_tomls: &[PathBuf]) {
+	// Build node
+	assert!(Command::new("cargo")
+		.args(&["build", "--all"])
+		.current_dir(path)
+		.status()
+		.expect("Compiles node")
+		.success());
+
+	// Test node
+	assert!(Command::new("cargo")
+		.args(&["test", "--all"])
+		.current_dir(path)
+		.status()
+		.expect("Tests node")
+		.success());
+
+	// Remove all `target` directories
+	for toml in cargo_tomls {
+		let mut target_path = toml.clone();
+		target_path.pop();
+		target_path = target_path.join("target");
+
+		if target_path.exists() {
+			fs::remove_dir_all(&target_path)
+				.expect(&format!("Removes `{}`", target_path.display()));
+		}
+	}
+}
+
+fn main() {
+	let options = Options::parse();
+
+	// Copy node-template to a temp build dir.
+	let build_dir = tempfile::tempdir().expect("Creates temp build dir");
+	let node_template_folder = options
+		.node_template
+		.canonicalize()
+		.expect("Node template path exists")
+		.file_name()
+		.expect("Node template folder is last element of path")
+		.to_owned();
+	copy_node_template(&options.node_template, build_dir.path());
+
+	// The path to the node-template in the build dir.
+	let node_template_path = build_dir.path().join(node_template_folder);
+	let root_cargo_toml_path = node_template_path.join("Cargo.toml");
+
+	// Get all `Cargo.toml` files in the node-template
+	let mut cargo_tomls = find_cargo_tomls(&node_template_path);
+
+	// Check if top level Cargo.toml exists. If not, create one in the destination,
+	// else remove it from the list, as this requires some special treatments.
+	if let Some(index) = cargo_tomls.iter().position(|x| *x == root_cargo_toml_path) {
+		cargo_tomls.remove(index);
+	} else {
+		OpenOptions::new()
+			.create(true)
+			.write(true)
+			.open(root_cargo_toml_path.clone())
+			.expect("Create root level `Cargo.toml` failed.");
+	}
+
+	// Process all `Cargo.toml` files.
+	let root_deps = process_cargo_tomls(&cargo_tomls);
+	process_root_cargo_toml(
+		&root_cargo_toml_path,
+		root_deps,
+		&cargo_tomls,
+		&node_template_path,
+		&get_git_commit_id(&options.node_template),
+	);
+
+	// Add root rustfmt to node template build path.
+	let node_template_rustfmt_toml_path = node_template_path.join("rustfmt.toml");
+	let root_rustfmt_toml = &options.node_template.join("../../rustfmt.toml");
+	if root_rustfmt_toml.exists() {
+		fs::copy(&root_rustfmt_toml, &node_template_rustfmt_toml_path)
+			.expect("Copying rustfmt.toml.");
+	}
+
+	build_and_test(&node_template_path, &cargo_tomls);
+
+	let output = GzEncoder::new(
+		File::create(&options.output).expect("Creates output file"),
+		Compression::default(),
+	);
+	let mut tar = tar::Builder::new(output);
+	tar.append_dir_all("substrate-node-template", node_template_path)
+		.expect("Writes substrate-node-template archive");
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_update_git_dependencies() {
+		let toml = r#"
+[dev-dependencies]
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+[dependencies]
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-io = { version = "7.0.0", path = "../../../../primitives/io" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../../../frame/system" }
+"#;
+		let mut cargo_toml = toml.parse::<CargoToml>().expect("invalid doc");
+		let actual_deps = update_git_dependencies(&mut cargo_toml, |_| true);
+
+		assert_eq!(actual_deps.len(), 3);
+		assert_eq!(actual_deps.get("dependencies").unwrap().len(), 2);
+		assert_eq!(actual_deps.get("dev-dependencies").unwrap().len(), 0);
+		assert_eq!(
+			actual_deps.get("dependencies").unwrap().get("sp-io").unwrap(),
+			&Dependency {
+				name: "sp-io".into(),
+				version: Some("7.0.0".into()),
+				default_features: None
+			}
+		);
+		assert_eq!(
+			actual_deps.get("dependencies").unwrap().get("frame-system").unwrap(),
+			&Dependency {
+				name: "frame-system".into(),
+				version: Some("4.0.0-dev".into()),
+				default_features: Some(false),
+			}
+		);
+
+		let expected_toml = r#"
+[dev-dependencies]
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+
+[dependencies]
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-io = { workspace = true }
+frame-system = { workspace = true }
+"#;
+		assert_eq!(cargo_toml.to_string(), expected_toml);
+	}
+
+	#[test]
+	fn test_update_root_cargo_toml() {
+		let mut cargo_toml = CargoToml::new();
+		update_root_cargo_toml(
+			&mut cargo_toml,
+			&vec!["node".into(), "pallets/template".into(), "runtime".into()],
+			Dependencies::from([
+				(
+					"dependencies".into(),
+					HashMap::from([
+						(
+							"sp-io".into(),
+							Dependency {
+								name: "sp-io".into(),
+								version: Some("7.0.0".into()),
+								default_features: None,
+							},
+						),
+						(
+							"frame-system".into(),
+							Dependency {
+								name: "frame-system".into(),
+								version: Some("4.0.0-dev".into()),
+								default_features: Some(true),
+							},
+						),
+					]),
+				),
+				("dev-dependencies".into(), HashMap::new()),
+				("build-dependencies".into(), HashMap::new()),
+			]),
+			"commit_id",
+		);
+
+		let expected_toml = r#"[workspace]
+members = ["node", "pallets/template", "runtime"]
+
+[workspace.dependencies]
+frame-system = { version = "4.0.0-dev", default-features = true, git = "https://github.com/paritytech/substrate.git", rev = "commit_id" }
+sp-io = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", rev = "commit_id" }
+
+[profile]
+
+[profile.release]
+panic = "unwind"
+"#;
+		assert_eq!(cargo_toml.to_string(), expected_toml);
+	}
+}
diff --git a/substrate/scripts/run_all_benchmarks.sh b/substrate/scripts/run_all_benchmarks.sh
new file mode 100755
index 0000000000000000000000000000000000000000..83848100a7e5189f312411fb42eae7d4eb6a43c4
--- /dev/null
+++ b/substrate/scripts/run_all_benchmarks.sh
@@ -0,0 +1,166 @@
+#!/usr/bin/env bash
+
+# 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 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
+
+while getopts 'bfp:v' flag; do
+  case "${flag}" in
+    b)
+      # Skip build.
+      skip_build='true'
+      ;;
+    f)
+      # 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
+      ;;
+    p)
+      # Start at pallet
+      start_pallet="${OPTARG}"
+      ;;
+    v)
+      # Echo all executed commands.
+      set -x
+      ;;
+    *)
+      # Exit early.
+      echo "Bad options. Check Script."
+      exit 1
+      ;;
+  esac
+done
+
+
+if [ "$skip_build" != true ]
+then
+  echo "[+] Compiling Substrate benchmarks..."
+  cargo build --profile=production --locked --features=runtime-benchmarks --bin substrate
+fi
+
+# The executable to use.
+SUBSTRATE=./target/production/substrate
+
+# 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"
+)
+
+# Load all pallet names in an array.
+ALL_PALLETS=($(
+  $SUBSTRATE benchmark pallet --list --chain=dev |\
+    tail -n+2 |\
+    cut -d',' -f1 |\
+    sort |\
+    uniq
+))
+
+# Filter out the excluded pallets by concatenating the arrays and discarding duplicates.
+PALLETS=($({ printf '%s\n' "${ALL_PALLETS[@]}" "${EXCLUDED_PALLETS[@]}"; } | sort | uniq -u))
+
+echo "[+] Benchmarking ${#PALLETS[@]} Substrate pallets by excluding ${#EXCLUDED_PALLETS[@]} from ${#ALL_PALLETS[@]}."
+
+# Define the error file.
+ERR_FILE="benchmarking_errors.txt"
+# Delete the error file before each run.
+rm -f $ERR_FILE
+
+# Benchmark each pallet.
+for PALLET in "${PALLETS[@]}"; do
+  # If `-p` is used, skip benchmarks until the start pallet.
+  if [ ! -z "$start_pallet" ] && [ "$start_pallet" != "$PALLET" ]
+  then
+    echo "[+] Skipping ${PALLET}..."
+    continue
+  else
+    unset start_pallet
+  fi
+
+  FOLDER="$(echo "${PALLET#*_}" | tr '_' '-')";
+  WEIGHT_FILE="./frame/${FOLDER}/src/weights.rs"
+  echo "[+] Benchmarking $PALLET with weight file $WEIGHT_FILE";
+
+  OUTPUT=$(
+    $SUBSTRATE benchmark pallet \
+    --chain=dev \
+    --steps=50 \
+    --repeat=20 \
+    --pallet="$PALLET" \
+    --extrinsic="*" \
+    --wasm-execution=compiled \
+    --heap-pages=4096 \
+    --output="$WEIGHT_FILE" \
+    --header="./HEADER-APACHE2" \
+    --template=./.maintain/frame-weight-template.hbs 2>&1
+  )
+  if [ $? -ne 0 ]; then
+    echo "$OUTPUT" >> "$ERR_FILE"
+    echo "[-] Failed to benchmark $PALLET. Error written to $ERR_FILE; continuing..."
+  fi
+done
+
+# Update the block and extrinsic overhead weights.
+echo "[+] Benchmarking block and extrinsic overheads..."
+OUTPUT=$(
+  $SUBSTRATE benchmark overhead \
+  --chain=dev \
+  --wasm-execution=compiled \
+  --weight-path="./frame/support/src/weights/" \
+  --header="./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 the machine..."
+OUTPUT=$(
+  $SUBSTRATE benchmark machine --chain=dev 2>&1
+)
+if [ $? -ne 0 ]; then
+  # Do not write the error to the error file since it is not a benchmarking error.
+  echo "[-] Failed the machine benchmark:\n$OUTPUT"
+fi
+
+# Check if the error file exists.
+if [ -f "$ERR_FILE" ]; then
+  echo "[-] Some benchmarks failed. See: $ERR_FILE"
+  exit 1
+else
+  echo "[+] All benchmarks passed."
+  exit 0
+fi
diff --git a/substrate/src/lib.rs b/substrate/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..16a606778965792fcfa5e9f1639ef960e47a7fe2
--- /dev/null
+++ b/substrate/src/lib.rs
@@ -0,0 +1,297 @@
+// 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/>.
+
+//! # Substrate
+//!
+//! Substrate is a Rust framework for building blockchains in a modular and extensible way. While in
+//! itself un-opinionated, it is the main engine behind the Polkadot ecosystem.
+//!
+//! [![github]](https://github.com/paritytech/substrate/) - [![polkadot]](https://polkadot.network)
+//!
+//! This crate in itself does not contain any code and is just meant ot be a documentation hub for
+//! substrate-based crates.
+//!
+//! ## Overview
+//!
+//! Substrate approaches blockchain development with an acknowledgement of a few self-evident
+//! truths:
+//!
+//! 1. Society and technology evolves.
+//! 2. Humans are fallible.
+//!
+//! This, specifically, makes the task of designing a correct, safe and long-lasting blockchain
+//! system hard.
+//!
+//! Nonetheless, in order to achieve this goal, substrate embraces the following:
+//!
+//! 1. Use of **Rust** as a modern, and safe programming language, which limits human error through
+//!    various means, most notably memory safety.
+//! 2. Substrate is written from the ground-up with a generic, modular and extensible design. This
+//!    ensures that software components can be easily swapped and upgraded. Examples of this is
+//!    multiple consensus mechanisms provided by Substrate, as listed below.
+//! 3. Lastly, the final blockchain system created with the above properties needs to be
+//!    upgradeable. In order to achieve this, Substrate is designed as a meta-protocol, whereby the
+//!    application logic of the blockchain (called "Runtime") is encoded as a Wasm blob, and is
+//!    stored onchain. The rest of the system (called "Client") acts as the executor of the Wasm
+//!    blob.
+//!
+//! In essence, the meta-protocol of all Substrate based chains is the "Runtime as Wasm blob"
+//! accord. This enables the Runtime to become inherently upgradeable (without forks). The upgrade
+//! is merely a matter of the Wasm blob being changed in the chain state, which is, in principle,
+//! same as updating an account's balance.
+//!
+//! To learn more about the substrate architecture using some visuals, see [`substrate_diagram`].
+//!
+//! `FRAME`, Substrate's default runtime development library takes the above even further by
+//! embracing a declarative programming model whereby correctness is enhanced and the system is
+//! highly configurable through parameterization.
+//!
+//! All in all, this design enables all substrate-based chains to achieve forkless, self-enacting
+//! upgrades out of the box. Combined with governance abilities that are shipped with `FRAME`, this
+//! enables a chain to survive the test of time.
+//!
+//! ## How to Get Stared
+//!
+//! Most developers want to leave the client side code as-is, and focus on the runtime. To do so,
+//! look into the [`frame_support`] crate, which is the entry point crate into runtime development
+//! with FRAME.
+//!
+//! > Side note, it is entirely possible to craft a substrate-based runtime without FRAME, an
+//! > example of which can be found [here](https://github.com/JoshOrndorff/frameless-node-template).
+//!
+//! In more broad terms, the following avenues exist into developing with substrate:
+//!
+//! * **Templates**: A number of substrate-based templates exist and they can be used for various
+//!   purposes, with zero to little additional code needed. All of these templates contain runtimes
+//!   that are highly configurable and are likely suitable for basic needs.
+//! * `FRAME`: If need, one can customize that runtime even further, by using `FRAME` and developing
+//!   custom modules.
+//! * **Core**: To the contrary, some developers may want to customize the client side software to
+//!   achieve novel goals such as a new consensus engine, or a new database backend. While
+//!   Substrate's main configurability is in the runtime, the client is also highly generic and can
+//!   be customized to a great extent.
+//!
+//! ## Structure
+//!
+//! Substrate is a massive cargo workspace with hundreds of crates, therefore it is useful to know
+//! how to navigate its crates.
+//!
+//! In broad terms, it is divided into three categories:
+//!
+//! * `sc-*` (short for *substrate-client*) crates, located under `./client` folder. These are all
+//!   the client crates. Notable examples are crates such as [`sc-network`], various consensus
+//!   crates, [`sc-rpc-api`] and [`sc-client-db`], all of which are expected to reside in the client
+//!   side.
+//! * `sp-*` (short for *substrate-primitives*) crates, located under `./primitives` folder. These
+//!   are the traits that glue the client and runtime together, but are not opinionated about what
+//!   framework is using for building the runtime. Notable examples are [`sp-api`] and [`sp-io`],
+//!   which form the communication bridge between the client and runtime, as explained in
+//!   [`substrate_diagram`].
+//! * `pallet-*` and `frame-*` crates, located under `./frame` folder. These are the crates related
+//!   to FRAME. See [`frame_support`] for more information.
+//!
+//! ### Wasm Build
+//!
+//! Many of the Substrate crates, such as entire `sp-*`, need to compile to both Wasm (when a Wasm
+//! runtime is being generated) and native (for example, when testing). To achieve this, Substrate
+//! follows the convention of the Rust community, and uses a `feature = "std"` to signify that a
+//!  crate is being built with the standard library, and is built for native. Otherwise, it is built
+//!  for `no_std`.
+//!
+//! This can be summarized in `#![cfg_attr(not(feature = "std"), no_std)]`, which you can often find
+//! in any Substrate-based runtime.
+//!
+//! Substrate-based runtimes use [`substrate-wasm-builder`] in their `build.rs` to automatically
+//! build their Wasm files as a part of normal build commandsOnce built, the wasm file is placed in
+//! `./target/{debug|release}/wbuild/{runtime_name}.wasm`.
+//!
+//! ### Binaries
+//!
+//! Multiple binaries are shipped with substrate, the most important of which are located in the
+//! `./bin` folder.
+//!
+//! * [`node`] is an extensive substrate node that contains the superset of all runtime and client
+//!   side features. The corresponding runtime, called [`kitchensink_runtime`] contains all of the
+//!   modules that are provided with `FRAME`. This node and runtime is only used for testing and
+//!   demonstration.
+//!     * [`chain-spec-builder`]: Utility to build more detailed chain-specs for the aforementioned
+//!       node. Other projects typically contain a `build-spec` subcommand that does the same.
+//! * [`node-template`]: a template node that contains a minimal set of features and can act as a
+//!   starting point of a project.
+//! * [`subkey`]: Substrate's key management utility.
+//!
+//! ### Anatomy of a Binary Crate
+//!
+//! From the above, [`node`] and [`node-template`] are essentially blueprints of a substrate-based
+//! project, as the name of the latter is implying. Each substrate-based project typically contains
+//! the following:
+//!
+//! * Under `./runtime`, a `./runtime/src/lib.rs` which is the top level runtime amalgamator file.
+//!   This file typically contains the [`frame_support::construct_runtime`] macro, which is the
+//!   final definition of a runtime.
+//!
+//! * Under `./node`, a `main.rs`, which is the point, and a `./service.rs`, which contains all the
+//!   client side components. Skimming this file yields an overview of the networking, database,
+//!   consensus and similar client side components.
+//!
+//! > The above two are conventions, not rules.
+//!
+//! ## Parachain?
+//!
+//! As noted above, Substrate is the main engine behind the Polkadot ecosystem. One of the ways
+//! through which Polkadot can be utilized is by building "parachains", blockchains that are
+//! connected to Polkadot's shared security.
+//!
+//! To build a parachain, one could use [`Cumulus`](https://github.com/paritytech/cumulus/), the
+//! library on top of Substrate, empowering any substrate-based chain to be a Polkadot parachain.
+//!
+//! ## Where To Go Next?
+//!
+//! Additional noteworthy crates within substrate:
+//!
+//! - RPC APIs of a Substrate node: [`sc-rpc-api`]/[`sc-rpc`]
+//! - CLI Options of a Substrate node: [`sc-cli`]
+//! - All of the consensus related crates provided by Substrate:
+//!     - [`sc-consensus-aura`]
+//!     - [`sc-consensus-babe`]
+//!     - [`sc-consensus-grandpa`]
+//!     - [`sc-consensus-beefy`]
+//!     - [`sc-consensus-manual-seal`]
+//!     - [`sc-consensus-pow`]
+//!
+//! Additional noteworthy external resources:
+//!
+//! - [Substrate Developer Hub](https://substrate.dev)
+//! - [Parity Tech's Documentation Hub](https://paritytech.github.io/)
+//! - [Frontier: Substrate's Ethereum Compatibility Library](https://paritytech.github.io/frontier/)
+//! - [Polkadot Wiki](https://wiki.polkadot.network/en/)
+//!
+//! Notable upstream crates:
+//!
+//! - [`parity-scale-codec`](https://github.com/paritytech/parity-scale-codec)
+//! - [`parity-db`](https://github.com/paritytech/parity-db)
+//! - [`trie`](https://github.com/paritytech/trie)
+//! - [`parity-common`](https://github.com/paritytech/parity-common)
+//!
+//! Templates:
+//!
+//! - classic [`substrate-node-template`](https://github.com/substrate-developer-hub/substrate-node-template)
+//! - classic [cumulus-parachain-template](https://github.com/substrate-developer-hub/substrate-parachain-template)
+//! - [`extended-parachain-template`](https://github.com/paritytech/extended-parachain-template)
+//! - [`frontier-parachain-template`](https://github.com/paritytech/frontier-parachain-template)
+//!
+//! [polkadot]:
+//!     https://img.shields.io/badge/polkadot-E6007A?style=for-the-badge&logo=polkadot&logoColor=white
+//! [github]:
+//!     https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
+//! [`sp-io`]: ../sp_io/index.html
+//! [`sp-api`]: ../sp_api/index.html
+//! [`sp-api`]: ../sp_api/index.html
+//! [`sc-client-db`]: ../sc_client_db/index.html
+//! [`sc-network`]: ../sc_network/index.html
+//! [`sc-rpc-api`]: ../sc_rpc_api/index.html
+//! [`sc-rpc`]: ../sc_rpc/index.html
+//! [`sc-cli`]: ../sc_cli/index.html
+//! [`sc-consensus-aura`]: ../sc_consensus_aura/index.html
+//! [`sc-consensus-babe`]: ../sc_consensus_babe/index.html
+//! [`sc-consensus-grandpa`]: ../sc_consensus_grandpa/index.html
+//! [`sc-consensus-beefy`]: ../sc_consensus_beefy/index.html
+//! [`sc-consensus-manual-seal`]: ../sc_consensus_manual_seal/index.html
+//! [`sc-consensus-pow`]: ../sc_consensus_pow/index.html
+//! [`node`]: ../node_cli/index.html
+//! [`node-template`]: ../node_template/index.html
+//! [`kitchensink_runtime`]: ../kitchensink_runtime/index.html
+//! [`subkey`]: ../subkey/index.html
+//! [`chain-spec-builder`]: ../chain_spec_builder/index.html
+//! [`substrate-wasm-builder`]: https://crates.io/crates/substrate-wasm-builder
+
+#![deny(rustdoc::broken_intra_doc_links)]
+#![deny(rustdoc::private_intra_doc_links)]
+
+#[cfg_attr(doc, aquamarine::aquamarine)]
+/// In this module, we explore substrate at a more depth. First, let's establish substrate being
+/// divided into a client and runtime.
+///
+/// ```mermaid
+/// graph TB
+/// subgraph Substrate
+/// 	direction LR
+/// 	subgraph Client
+/// 	end
+/// 	subgraph Runtime
+/// 	end
+/// end
+/// ```
+///
+/// The client and the runtime of course need to communicate. This is done through two concepts:
+///
+/// 1. Host functions: a way for the (Wasm) runtime to talk to the client. All host functions are
+///    defined in [`sp-io`]. For example, [`sp-io::storage`] are the set of host functions that
+///    allow the runtime to read and write data to the on-chain state.
+/// 2. Runtime APIs: a way for the client to talk to the Wasm runtime. Runtime APIs are defined
+///    using macros and utilities in [`sp-api`]. For example, [`sp-api::Core`] is the most basic
+///    runtime API that any blockchain must implement in order to be able to (re) execute blocks.
+///
+/// ```mermaid
+/// graph TB
+/// subgraph Substrate
+/// 	direction LR
+/// 	subgraph Client
+/// 	end
+/// 	subgraph Runtime
+/// 	end
+/// 	Client --runtime-api--> Runtime
+/// 	Runtime --host-functions--> Client
+/// end
+/// ```
+///
+/// Finally, let's expand the diagram a bit further and look at the internals of each component:
+///
+/// ```mermaid
+/// graph TB
+/// subgraph Substrate
+/// 	direction LR
+/// 	subgraph Client
+/// 		Database
+/// 		Networking
+/// 		Consensus
+/// 	end
+/// 	subgraph Runtime
+/// 		subgraph FRAME
+/// 			direction LR
+/// 			Governance
+/// 			Currency
+/// 			Staking
+/// 			Identity
+/// 		end
+/// 	end
+/// 	Client --runtime-api--> Runtime
+/// 	Runtime --host-functions--> Client
+/// end
+/// ```
+///
+/// As noted the runtime contains all of the application specific logic of the blockchain. This is
+/// usually written with `FRAME`. The client, on the other hand, contains reusable and generic
+/// components that are not specific to one single blockchain, such as networking, database, and the
+/// consensus engine.
+///
+/// [`sp-io`]: ../../sp_io/index.html
+/// [`sp-api`]: ../../sp_api/index.html
+/// [`sp-io::storage`]: ../../sp_io/storage/index.html
+/// [`sp-api::Core`]: ../../sp_api/trait.Core.html
+pub mod substrate_diagram {}
diff --git a/substrate/test-utils/Cargo.toml b/substrate/test-utils/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1b98b23e0b2541e1c2168259473f3df587dc0068
--- /dev/null
+++ b/substrate/test-utils/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "substrate-test-utils"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate test utilities"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+futures = "0.3.16"
+tokio = { version = "1.22.0", features = ["macros", "time"] }
+substrate-test-utils-derive = { version = "0.10.0-dev", path = "./derive" }
+
+[dev-dependencies]
+trybuild = { version = "1.0.74", features = [ "diff" ] }
+sc-service = { version = "0.10.0-dev", path = "../client/service" }
diff --git a/substrate/test-utils/cli/Cargo.toml b/substrate/test-utils/cli/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..20418d602886d5080c3dbfc587c4c8d07f0ee8d4
--- /dev/null
+++ b/substrate/test-utils/cli/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "substrate-cli-test-utils"
+description = "CLI testing utilities"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+substrate-rpc-client = { path = "../../utils/frame/rpc/client" }
+sp-rpc = { version = "6.0.0", path = "../../primitives/rpc" }
+assert_cmd = "2.0.10"
+nix = "0.26.2"
+regex = "1.7.3"
+tokio = { version = "1.22.0", features = ["full"] }
+node-primitives = { path = "../../bin/node/primitives" }
+node-cli = { path = "../../bin/node/cli" }
+sc-cli = { path = "../../client/cli" }
+sc-service = { path = "../../client/service" }
+futures = "0.3.28"
+
+[features]
+try-runtime = [ "node-cli/try-runtime" ]
diff --git a/substrate/test-utils/cli/build.rs b/substrate/test-utils/cli/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a68cb706e8fbdc2526aa18730f0e7ddb9719f838
--- /dev/null
+++ b/substrate/test-utils/cli/build.rs
@@ -0,0 +1,25 @@
+// 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 std::env;
+
+fn main() {
+	if let Ok(profile) = env::var("PROFILE") {
+		println!("cargo:rustc-cfg=build_type=\"{}\"", profile);
+	}
+}
diff --git a/substrate/test-utils/cli/src/lib.rs b/substrate/test-utils/cli/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..99119a44d2e9896adc445e53c9dfaa8da3695b7b
--- /dev/null
+++ b/substrate/test-utils/cli/src/lib.rs
@@ -0,0 +1,358 @@
+// 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/>.
+
+#![cfg(unix)]
+
+use assert_cmd::cargo::cargo_bin;
+use nix::{
+	sys::signal::{kill, Signal, Signal::SIGINT},
+	unistd::Pid,
+};
+use node_primitives::{Hash, Header};
+use regex::Regex;
+use sp_rpc::{list::ListOrValue, number::NumberOrHex};
+use std::{
+	io::{BufRead, BufReader, Read},
+	ops::{Deref, DerefMut},
+	path::{Path, PathBuf},
+	process::{self, Child, Command},
+	time::Duration,
+};
+use tokio::io::{AsyncBufReadExt, AsyncRead};
+
+/// Similar to [`crate::start_node`] spawns a node, but works in environments where the substrate
+/// binary is not accessible with `cargo_bin("substrate-node")`, and allows customising the args
+/// passed in.
+///
+/// Helpful if you need a Substrate dev node running in the background of a project external to
+/// `substrate`.
+///
+/// The downside compared to using [`crate::start_node`] is that this method is blocking rather than
+/// returning a [`Child`]. Therefore, you may want to call this method inside a new thread.
+///
+/// # Example
+/// ```ignore
+/// // Spawn a dev node.
+/// let _ = std::thread::spawn(move || {
+///     match common::start_node_inline(vec!["--dev", "--rpc-port=12345"]) {
+///         Ok(_) => {}
+///         Err(e) => {
+///             panic!("Node exited with error: {}", e);
+///         }
+///     }
+/// });
+/// ```
+pub fn start_node_inline(args: Vec<&str>) -> Result<(), sc_service::error::Error> {
+	use sc_cli::SubstrateCli;
+
+	// Prepend the args with some dummy value because the first arg is skipped.
+	let cli_call = std::iter::once("node-template").chain(args);
+	let cli = node_cli::Cli::from_iter(cli_call);
+	let runner = cli.create_runner(&cli.run).unwrap();
+	runner.run_node_until_exit(|config| async move { node_cli::service::new_full(config, cli) })
+}
+
+/// Starts a new Substrate node in development mode with a temporary chain.
+///
+/// This function creates a new Substrate node using the `substrate` binary.
+/// It configures the node to run in development mode (`--dev`) with a temporary chain (`--tmp`),
+/// sets the WebSocket port to 45789 (`--ws-port=45789`).
+///
+/// # Returns
+///
+/// A [`Child`] process representing the spawned Substrate node.
+///
+/// # Panics
+///
+/// This function will panic if the `substrate` binary is not found or if the node fails to start.
+///
+/// # Examples
+///
+/// ```ignore
+/// use my_crate::start_node;
+///
+/// let child = start_node();
+/// // Interact with the Substrate node using the WebSocket port 45789.
+/// // When done, the node will be killed when the `child` is dropped.
+/// ```
+///
+/// [`Child`]: std::process::Child
+pub fn start_node() -> Child {
+	Command::new(cargo_bin("substrate-node"))
+		.stdout(process::Stdio::piped())
+		.stderr(process::Stdio::piped())
+		.args(&["--dev", "--tmp", "--rpc-port=45789", "--no-hardware-benchmarks"])
+		.spawn()
+		.unwrap()
+}
+
+/// Builds the Substrate project using the provided arguments.
+///
+/// This function reads the CARGO_MANIFEST_DIR environment variable to find the root workspace
+/// directory. It then runs the `cargo b` command in the root directory with the specified
+/// arguments.
+///
+/// This can be useful for building the Substrate binary with a desired set of features prior
+/// to using the binary in a CLI test.
+///
+/// # Arguments
+///
+/// * `args: &[&str]` - A slice of string references representing the arguments to pass to the
+///   `cargo b` command.
+///
+/// # Panics
+///
+/// This function will panic if:
+///
+/// * The CARGO_MANIFEST_DIR environment variable is not set.
+/// * The root workspace directory cannot be determined.
+/// * The 'cargo b' command fails to execute.
+/// * The 'cargo b' command returns a non-successful status.
+///
+/// # Examples
+///
+/// ```ignore
+/// build_substrate(&["--features=try-runtime"]);
+/// ```
+pub fn build_substrate(args: &[&str]) {
+	let is_release_build = !cfg!(build_type = "debug");
+
+	// Get the root workspace directory from the CARGO_MANIFEST_DIR environment variable
+	let mut cmd = Command::new("cargo");
+
+	cmd.arg("build").arg("-p=node-cli");
+
+	if is_release_build {
+		cmd.arg("--release");
+	}
+
+	let output = cmd
+		.args(args)
+		.output()
+		.expect(format!("Failed to execute 'cargo b' with args {:?}'", args).as_str());
+
+	if !output.status.success() {
+		panic!(
+			"Failed to execute 'cargo b' with args {:?}': \n{}",
+			args,
+			String::from_utf8_lossy(&output.stderr)
+		);
+	}
+}
+
+/// Takes a readable tokio stream (e.g. from a child process `ChildStderr` or `ChildStdout`) and
+/// a `Regex` pattern, and checks each line against the given pattern as it is produced.
+/// The function returns OK(()) as soon as a line matching the pattern is found, or an Err if
+/// the stream ends without any lines matching the pattern.
+///
+/// # Arguments
+///
+/// * `child_stream` - An async tokio stream, e.g. from a child process `ChildStderr` or
+///   `ChildStdout`.
+/// * `re` - A `Regex` pattern to search for in the stream.
+///
+/// # Returns
+///
+/// * `Ok(())` if a line matching the pattern is found.
+/// * `Err(String)` if the stream ends without any lines matching the pattern.
+///
+/// # Examples
+///
+/// ```ignore
+/// use regex::Regex;
+/// use tokio::process::Command;
+/// use tokio::io::AsyncRead;
+///
+/// # async fn run() {
+/// let child = Command::new("some-command").stderr(std::process::Stdio::piped()).spawn().unwrap();
+/// let stderr = child.stderr.unwrap();
+/// let re = Regex::new("error:").unwrap();
+///
+/// match wait_for_pattern_match_in_stream(stderr, re).await {
+///     Ok(()) => println!("Error found in stderr"),
+///     Err(e) => println!("Error: {}", e),
+/// }
+/// # }
+/// ```
+pub async fn wait_for_stream_pattern_match<R>(stream: R, re: Regex) -> Result<(), String>
+where
+	R: AsyncRead + Unpin,
+{
+	let mut stdio_reader = tokio::io::BufReader::new(stream).lines();
+	while let Ok(Some(line)) = stdio_reader.next_line().await {
+		match re.find(line.as_str()) {
+			Some(_) => return Ok(()),
+			None => (),
+		}
+	}
+	Err(String::from("Stream closed without any lines matching the regex."))
+}
+
+/// Run the given `future` and panic if the `timeout` is hit.
+pub async fn run_with_timeout(timeout: Duration, future: impl futures::Future<Output = ()>) {
+	tokio::time::timeout(timeout, future).await.expect("Hit timeout");
+}
+
+/// Wait for at least n blocks to be finalized from a specified node
+pub async fn wait_n_finalized_blocks(n: usize, url: &str) {
+	use substrate_rpc_client::{ws_client, ChainApi};
+
+	let mut built_blocks = std::collections::HashSet::new();
+	let block_duration = Duration::from_secs(2);
+	let mut interval = tokio::time::interval(block_duration);
+	let rpc = ws_client(url).await.unwrap();
+
+	loop {
+		if let Ok(block) = ChainApi::<(), Hash, Header, ()>::finalized_head(&rpc).await {
+			built_blocks.insert(block);
+			if built_blocks.len() > n {
+				break
+			}
+		};
+		interval.tick().await;
+	}
+}
+
+/// Run the node for a while (3 blocks)
+pub async fn run_node_for_a_while(base_path: &Path, args: &[&str]) {
+	run_with_timeout(Duration::from_secs(60 * 10), async move {
+		let mut cmd = Command::new(cargo_bin("substrate-node"))
+			.stdout(process::Stdio::piped())
+			.stderr(process::Stdio::piped())
+			.args(args)
+			.arg("-d")
+			.arg(base_path)
+			.spawn()
+			.unwrap();
+
+		let stderr = cmd.stderr.take().unwrap();
+
+		let mut child = KillChildOnDrop(cmd);
+
+		let ws_url = extract_info_from_output(stderr).0.ws_url;
+
+		// Let it produce some blocks.
+		wait_n_finalized_blocks(3, &ws_url).await;
+
+		child.assert_still_running();
+
+		// Stop the process
+		child.stop();
+	})
+	.await
+}
+
+pub async fn block_hash(block_number: u64, url: &str) -> Result<Hash, String> {
+	use substrate_rpc_client::{ws_client, ChainApi};
+
+	let rpc = ws_client(url).await.unwrap();
+
+	let result = ChainApi::<(), Hash, Header, ()>::block_hash(
+		&rpc,
+		Some(ListOrValue::Value(NumberOrHex::Number(block_number))),
+	)
+	.await
+	.map_err(|_| "Couldn't get block hash".to_string())?;
+
+	match result {
+		ListOrValue::Value(maybe_block_hash) if maybe_block_hash.is_some() =>
+			Ok(maybe_block_hash.unwrap()),
+		_ => Err("Couldn't get block hash".to_string()),
+	}
+}
+
+pub struct KillChildOnDrop(pub Child);
+
+impl KillChildOnDrop {
+	/// Stop the child and wait until it is finished.
+	///
+	/// Asserts if the exit status isn't success.
+	pub fn stop(&mut self) {
+		self.stop_with_signal(SIGINT);
+	}
+
+	/// Same as [`Self::stop`] but takes the `signal` that is sent to stop the child.
+	pub fn stop_with_signal(&mut self, signal: Signal) {
+		kill(Pid::from_raw(self.id().try_into().unwrap()), signal).unwrap();
+		assert!(self.wait().unwrap().success());
+	}
+
+	/// Asserts that the child is still running.
+	pub fn assert_still_running(&mut self) {
+		assert!(self.try_wait().unwrap().is_none(), "the process should still be running");
+	}
+}
+
+impl Drop for KillChildOnDrop {
+	fn drop(&mut self) {
+		let _ = self.0.kill();
+	}
+}
+
+impl Deref for KillChildOnDrop {
+	type Target = Child;
+
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+
+impl DerefMut for KillChildOnDrop {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.0
+	}
+}
+
+/// Information extracted from a running node.
+pub struct NodeInfo {
+	pub ws_url: String,
+	pub db_path: PathBuf,
+}
+
+/// Extract [`NodeInfo`] from a running node by parsing its output.
+///
+/// Returns the [`NodeInfo`] and all the read data.
+pub fn extract_info_from_output(read: impl Read + Send) -> (NodeInfo, String) {
+	let mut data = String::new();
+
+	let ws_url = BufReader::new(read)
+		.lines()
+		.find_map(|line| {
+			let line = line.expect("failed to obtain next line while extracting node info");
+			data.push_str(&line);
+			data.push_str("\n");
+
+			// does the line contain our port (we expect this specific output from substrate).
+			let sock_addr = match line.split_once("Running JSON-RPC server: addr=") {
+				None => return None,
+				Some((_, after)) => after.split_once(",").unwrap().0,
+			};
+
+			Some(format!("ws://{}", sock_addr))
+		})
+		.unwrap_or_else(|| {
+			eprintln!("Observed node output:\n{}", data);
+			panic!("We should get a WebSocket address")
+		});
+
+	// Database path is printed before the ws url!
+	let re = Regex::new(r"Database: .+ at (\S+)").unwrap();
+	let db_path = PathBuf::from(re.captures(data.as_str()).unwrap().get(1).unwrap().as_str());
+
+	(NodeInfo { ws_url, db_path }, data)
+}
diff --git a/substrate/test-utils/client/Cargo.toml b/substrate/test-utils/client/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d921a879fba2eabfee1757ce08ca706871c7f6ed
--- /dev/null
+++ b/substrate/test-utils/client/Cargo.toml
@@ -0,0 +1,38 @@
+[package]
+name = "substrate-test-client"
+description = "Client testing utilities"
+version = "2.0.1"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+async-trait = "0.1.57"
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+serde = "1.0.163"
+serde_json = "1.0.85"
+sc-client-api = { version = "4.0.0-dev", path = "../../client/api" }
+sc-client-db = { version = "0.10.0-dev", default-features = false, features = [
+	"test-helpers",
+], path = "../../client/db" }
+sc-consensus = { version = "0.10.0-dev", path = "../../client/consensus/common" }
+sc-executor = { version = "0.10.0-dev", path = "../../client/executor" }
+sc-offchain = { version = "4.0.0-dev", path = "../../client/offchain" }
+sc-service = { version = "0.10.0-dev", default-features = false, features = [
+	"test-helpers",
+], path = "../../client/service" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-keyring = { version = "24.0.0", path = "../../primitives/keyring" }
+sp-keystore = { version = "0.27.0", path = "../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../primitives/state-machine" }
diff --git a/substrate/test-utils/client/src/client_ext.rs b/substrate/test-utils/client/src/client_ext.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8efa7b5f07f8d71664a79a7b3633afc0f7ca3fb3
--- /dev/null
+++ b/substrate/test-utils/client/src/client_ext.rs
@@ -0,0 +1,207 @@
+// 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.
+
+//! Client extension for tests.
+
+use sc_client_api::{backend::Finalizer, client::BlockBackend};
+use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy};
+use sc_service::client::Client;
+use sp_consensus::{BlockOrigin, Error as ConsensusError};
+use sp_runtime::{traits::Block as BlockT, Justification, Justifications};
+
+/// Extension trait for a test client.
+pub trait ClientExt<Block: BlockT>: Sized {
+	/// Finalize a block.
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+	) -> sp_blockchain::Result<()>;
+
+	/// Returns hash of the genesis block.
+	fn genesis_hash(&self) -> <Block as BlockT>::Hash;
+}
+
+/// Extension trait for a test client around block importing.
+#[async_trait::async_trait]
+pub trait ClientBlockImportExt<Block: BlockT>: Sized {
+	/// Import block to the chain. No finality.
+	async fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError>;
+
+	/// Import a block and make it our best block if possible.
+	async fn import_as_best(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+	) -> Result<(), ConsensusError>;
+
+	/// Import a block and finalize it.
+	async fn import_as_final(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+	) -> Result<(), ConsensusError>;
+
+	/// Import block with justification(s), finalizes block.
+	async fn import_justified(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+		justifications: Justifications,
+	) -> Result<(), ConsensusError>;
+}
+
+impl<B, E, RA, Block> ClientExt<Block> for Client<B, E, Block, RA>
+where
+	B: sc_client_api::backend::Backend<Block>,
+	E: sc_client_api::CallExecutor<Block> + sc_executor::RuntimeVersionOf + 'static,
+	Self: BlockImport<Block, Error = ConsensusError>,
+	Block: BlockT,
+{
+	fn finalize_block(
+		&self,
+		hash: Block::Hash,
+		justification: Option<Justification>,
+	) -> sp_blockchain::Result<()> {
+		Finalizer::finalize_block(self, hash, justification, true)
+	}
+
+	fn genesis_hash(&self) -> <Block as BlockT>::Hash {
+		self.block_hash(0u32.into()).unwrap().unwrap()
+	}
+}
+
+/// This implementation is required, because of the weird api requirements around `BlockImport`.
+#[async_trait::async_trait]
+impl<Block: BlockT, T> ClientBlockImportExt<Block> for std::sync::Arc<T>
+where
+	for<'r> &'r T: BlockImport<Block, Error = ConsensusError>,
+	T: Send + Sync,
+{
+	async fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.body = Some(extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+
+	async fn import_as_best(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+	) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.body = Some(extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+
+	async fn import_as_final(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+	) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.body = Some(extrinsics);
+		import.finalized = true;
+		import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+
+	async fn import_justified(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+		justifications: Justifications,
+	) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.justifications = Some(justifications);
+		import.body = Some(extrinsics);
+		import.finalized = true;
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+}
+
+#[async_trait::async_trait]
+impl<B, E, RA, Block: BlockT> ClientBlockImportExt<Block> for Client<B, E, Block, RA>
+where
+	Self: BlockImport<Block, Error = ConsensusError>,
+	RA: Send,
+	B: Send + Sync,
+	E: Send,
+{
+	async fn import(&mut self, origin: BlockOrigin, block: Block) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.body = Some(extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+
+	async fn import_as_best(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+	) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.body = Some(extrinsics);
+		import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+
+	async fn import_as_final(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+	) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.body = Some(extrinsics);
+		import.finalized = true;
+		import.fork_choice = Some(ForkChoiceStrategy::Custom(true));
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+
+	async fn import_justified(
+		&mut self,
+		origin: BlockOrigin,
+		block: Block,
+		justifications: Justifications,
+	) -> Result<(), ConsensusError> {
+		let (header, extrinsics) = block.deconstruct();
+		let mut import = BlockImportParams::new(origin, header);
+		import.justifications = Some(justifications);
+		import.body = Some(extrinsics);
+		import.finalized = true;
+		import.fork_choice = Some(ForkChoiceStrategy::LongestChain);
+
+		BlockImport::import_block(self, import).await.map(|_| ())
+	}
+}
diff --git a/substrate/test-utils/client/src/lib.rs b/substrate/test-utils/client/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..90e15e0f8d53e1b6a3457113ddb7ee7c6fd32be8
--- /dev/null
+++ b/substrate/test-utils/client/src/lib.rs
@@ -0,0 +1,449 @@
+// 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.
+
+//! Client testing utilities.
+
+#![warn(missing_docs)]
+
+pub mod client_ext;
+
+pub use self::client_ext::{ClientBlockImportExt, ClientExt};
+pub use sc_client_api::{execution_extensions::ExecutionExtensions, BadBlocks, ForkBlocks};
+pub use sc_client_db::{self, Backend, BlocksPruning};
+pub use sc_executor::{self, NativeElseWasmExecutor, WasmExecutionMethod, WasmExecutor};
+pub use sc_service::{client, RpcHandlers};
+pub use sp_consensus;
+pub use sp_keyring::{
+	ed25519::Keyring as Ed25519Keyring, sr25519::Keyring as Sr25519Keyring, AccountKeyring,
+};
+pub use sp_keystore::{Keystore, KeystorePtr};
+pub use sp_runtime::{Storage, StorageChild};
+
+use futures::{future::Future, stream::StreamExt};
+use sc_client_api::BlockchainEvents;
+use sc_service::client::{ClientConfig, LocalCallExecutor};
+use serde::Deserialize;
+use sp_core::{storage::ChildInfo, testing::TaskExecutor};
+use sp_runtime::{
+	codec::Encode,
+	traits::{Block as BlockT, Header},
+	OpaqueExtrinsic,
+};
+use std::{
+	collections::{HashMap, HashSet},
+	pin::Pin,
+	sync::Arc,
+};
+
+/// A genesis storage initialization trait.
+pub trait GenesisInit: Default {
+	/// Construct genesis storage.
+	fn genesis_storage(&self) -> Storage;
+}
+
+impl GenesisInit for () {
+	fn genesis_storage(&self) -> Storage {
+		Default::default()
+	}
+}
+
+/// A builder for creating a test client instance.
+pub struct TestClientBuilder<Block: BlockT, ExecutorDispatch, Backend: 'static, G: GenesisInit> {
+	genesis_init: G,
+	/// The key is an unprefixed storage key, this only contains
+	/// default child trie content.
+	child_storage_extension: HashMap<Vec<u8>, StorageChild>,
+	backend: Arc<Backend>,
+	_executor: std::marker::PhantomData<ExecutorDispatch>,
+	fork_blocks: ForkBlocks<Block>,
+	bad_blocks: BadBlocks<Block>,
+	enable_offchain_indexing_api: bool,
+	no_genesis: bool,
+}
+
+impl<Block: BlockT, ExecutorDispatch, G: GenesisInit> Default
+	for TestClientBuilder<Block, ExecutorDispatch, Backend<Block>, G>
+{
+	fn default() -> Self {
+		Self::with_default_backend()
+	}
+}
+
+impl<Block: BlockT, ExecutorDispatch, G: GenesisInit>
+	TestClientBuilder<Block, ExecutorDispatch, Backend<Block>, G>
+{
+	/// Create new `TestClientBuilder` with default backend.
+	pub fn with_default_backend() -> Self {
+		let backend = Arc::new(Backend::new_test(std::u32::MAX, std::u64::MAX));
+		Self::with_backend(backend)
+	}
+
+	/// Create new `TestClientBuilder` with default backend and pruning window size
+	pub fn with_pruning_window(blocks_pruning: u32) -> Self {
+		let backend = Arc::new(Backend::new_test(blocks_pruning, 0));
+		Self::with_backend(backend)
+	}
+
+	/// Create new `TestClientBuilder` with default backend and storage chain mode
+	pub fn with_tx_storage(blocks_pruning: u32) -> Self {
+		let backend =
+			Arc::new(Backend::new_test_with_tx_storage(BlocksPruning::Some(blocks_pruning), 0));
+		Self::with_backend(backend)
+	}
+}
+
+impl<Block: BlockT, ExecutorDispatch, Backend, G: GenesisInit>
+	TestClientBuilder<Block, ExecutorDispatch, Backend, G>
+{
+	/// Create a new instance of the test client builder.
+	pub fn with_backend(backend: Arc<Backend>) -> Self {
+		TestClientBuilder {
+			backend,
+			child_storage_extension: Default::default(),
+			genesis_init: Default::default(),
+			_executor: Default::default(),
+			fork_blocks: None,
+			bad_blocks: None,
+			enable_offchain_indexing_api: false,
+			no_genesis: false,
+		}
+	}
+
+	/// Alter the genesis storage parameters.
+	pub fn genesis_init_mut(&mut self) -> &mut G {
+		&mut self.genesis_init
+	}
+
+	/// Give access to the underlying backend of these clients
+	pub fn backend(&self) -> Arc<Backend> {
+		self.backend.clone()
+	}
+
+	/// Extend child storage
+	pub fn add_child_storage(
+		mut self,
+		child_info: &ChildInfo,
+		key: impl AsRef<[u8]>,
+		value: impl AsRef<[u8]>,
+	) -> Self {
+		let storage_key = child_info.storage_key();
+		let entry = self.child_storage_extension.entry(storage_key.to_vec()).or_insert_with(|| {
+			StorageChild { data: Default::default(), child_info: child_info.clone() }
+		});
+		entry.data.insert(key.as_ref().to_vec(), value.as_ref().to_vec());
+		self
+	}
+
+	/// Sets custom block rules.
+	pub fn set_block_rules(
+		mut self,
+		fork_blocks: ForkBlocks<Block>,
+		bad_blocks: BadBlocks<Block>,
+	) -> Self {
+		self.fork_blocks = fork_blocks;
+		self.bad_blocks = bad_blocks;
+		self
+	}
+
+	/// Enable the offchain indexing api.
+	pub fn enable_offchain_indexing_api(mut self) -> Self {
+		self.enable_offchain_indexing_api = true;
+		self
+	}
+
+	/// Disable writing genesis.
+	pub fn set_no_genesis(mut self) -> Self {
+		self.no_genesis = true;
+		self
+	}
+
+	/// Build the test client with the given native executor.
+	pub fn build_with_executor<RuntimeApi>(
+		self,
+		executor: ExecutorDispatch,
+	) -> (
+		client::Client<Backend, ExecutorDispatch, Block, RuntimeApi>,
+		sc_consensus::LongestChain<Backend, Block>,
+	)
+	where
+		ExecutorDispatch:
+			sc_client_api::CallExecutor<Block> + sc_executor::RuntimeVersionOf + Clone + 'static,
+		Backend: sc_client_api::backend::Backend<Block>,
+		<Backend as sc_client_api::backend::Backend<Block>>::OffchainStorage: 'static,
+	{
+		let storage = {
+			let mut storage = self.genesis_init.genesis_storage();
+			// Add some child storage keys.
+			for (key, child_content) in self.child_storage_extension {
+				storage.children_default.insert(
+					key,
+					StorageChild {
+						data: child_content.data.into_iter().collect(),
+						child_info: child_content.child_info,
+					},
+				);
+			}
+
+			storage
+		};
+
+		let client_config = ClientConfig {
+			offchain_indexing_api: self.enable_offchain_indexing_api,
+			no_genesis: self.no_genesis,
+			..Default::default()
+		};
+
+		let genesis_block_builder = sc_service::GenesisBlockBuilder::new(
+			&storage,
+			!client_config.no_genesis,
+			self.backend.clone(),
+			executor.clone(),
+		)
+		.expect("Creates genesis block builder");
+
+		let spawn_handle = Box::new(TaskExecutor::new());
+
+		let client = client::Client::new(
+			self.backend.clone(),
+			executor,
+			spawn_handle,
+			genesis_block_builder,
+			self.fork_blocks,
+			self.bad_blocks,
+			None,
+			None,
+			client_config,
+		)
+		.expect("Creates new client");
+
+		let longest_chain = sc_consensus::LongestChain::new(self.backend);
+
+		(client, longest_chain)
+	}
+}
+
+impl<Block: BlockT, D, Backend, G: GenesisInit>
+	TestClientBuilder<
+		Block,
+		client::LocalCallExecutor<Block, Backend, NativeElseWasmExecutor<D>>,
+		Backend,
+		G,
+	> where
+	D: sc_executor::NativeExecutionDispatch,
+{
+	/// Build the test client with the given native executor.
+	pub fn build_with_native_executor<RuntimeApi, I>(
+		self,
+		executor: I,
+	) -> (
+		client::Client<
+			Backend,
+			client::LocalCallExecutor<Block, Backend, NativeElseWasmExecutor<D>>,
+			Block,
+			RuntimeApi,
+		>,
+		sc_consensus::LongestChain<Backend, Block>,
+	)
+	where
+		I: Into<Option<NativeElseWasmExecutor<D>>>,
+		D: sc_executor::NativeExecutionDispatch + 'static,
+		Backend: sc_client_api::backend::Backend<Block> + 'static,
+	{
+		let executor = executor.into().unwrap_or_else(|| {
+			NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build())
+		});
+		let executor = LocalCallExecutor::new(
+			self.backend.clone(),
+			executor.clone(),
+			Default::default(),
+			ExecutionExtensions::new(None, Arc::new(executor)),
+		)
+		.expect("Creates LocalCallExecutor");
+
+		self.build_with_executor(executor)
+	}
+}
+
+/// The output of an RPC transaction.
+pub struct RpcTransactionOutput {
+	/// The output string of the transaction if any.
+	pub result: String,
+	/// An async receiver if data will be returned via a callback.
+	pub receiver: futures::channel::mpsc::UnboundedReceiver<String>,
+}
+
+impl std::fmt::Debug for RpcTransactionOutput {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		write!(f, "RpcTransactionOutput {{ result: {:?}, receiver }}", self.result)
+	}
+}
+
+/// An error for when the RPC call fails.
+#[derive(Deserialize, Debug)]
+pub struct RpcTransactionError {
+	/// A Number that indicates the error type that occurred.
+	pub code: i64,
+	/// A String providing a short description of the error.
+	pub message: String,
+	/// A Primitive or Structured value that contains additional information about the error.
+	pub data: Option<serde_json::Value>,
+}
+
+impl std::fmt::Display for RpcTransactionError {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		std::fmt::Debug::fmt(self, f)
+	}
+}
+
+/// An extension trait for `RpcHandlers`.
+#[async_trait::async_trait]
+pub trait RpcHandlersExt {
+	/// Send a transaction through the RpcHandlers.
+	async fn send_transaction(
+		&self,
+		extrinsic: OpaqueExtrinsic,
+	) -> Result<RpcTransactionOutput, RpcTransactionError>;
+}
+
+#[async_trait::async_trait]
+impl RpcHandlersExt for RpcHandlers {
+	async fn send_transaction(
+		&self,
+		extrinsic: OpaqueExtrinsic,
+	) -> Result<RpcTransactionOutput, RpcTransactionError> {
+		let (result, rx) = self
+			.rpc_query(&format!(
+				r#"{{
+						"jsonrpc": "2.0",
+						"method": "author_submitExtrinsic",
+						"params": ["0x{}"],
+						"id": 0
+					}}"#,
+				array_bytes::bytes2hex("", &extrinsic.encode())
+			))
+			.await
+			.expect("valid JSON-RPC request object; qed");
+		parse_rpc_result(result, rx)
+	}
+}
+
+pub(crate) fn parse_rpc_result(
+	result: String,
+	receiver: futures::channel::mpsc::UnboundedReceiver<String>,
+) -> Result<RpcTransactionOutput, RpcTransactionError> {
+	let json: serde_json::Value =
+		serde_json::from_str(&result).expect("the result can only be a JSONRPC string; qed");
+	let error = json.as_object().expect("JSON result is always an object; qed").get("error");
+
+	if let Some(error) = error {
+		return Err(serde_json::from_value(error.clone())
+			.expect("the JSONRPC result's error is always valid; qed"))
+	}
+
+	Ok(RpcTransactionOutput { result, receiver })
+}
+
+/// An extension trait for `BlockchainEvents`.
+pub trait BlockchainEventsExt<C, B>
+where
+	C: BlockchainEvents<B>,
+	B: BlockT,
+{
+	/// Wait for `count` blocks to be imported in the node and then exit. This function will not
+	/// return if no blocks are ever created, thus you should restrict the maximum amount of time of
+	/// the test execution.
+	fn wait_for_blocks(&self, count: usize) -> Pin<Box<dyn Future<Output = ()> + Send>>;
+}
+
+impl<C, B> BlockchainEventsExt<C, B> for C
+where
+	C: BlockchainEvents<B>,
+	B: BlockT,
+{
+	fn wait_for_blocks(&self, count: usize) -> Pin<Box<dyn Future<Output = ()> + Send>> {
+		assert!(count > 0, "'count' argument must be greater than 0");
+
+		let mut import_notification_stream = self.import_notification_stream();
+		let mut blocks = HashSet::new();
+
+		Box::pin(async move {
+			while let Some(notification) = import_notification_stream.next().await {
+				if notification.is_new_best {
+					blocks.insert(*notification.header.number());
+					if blocks.len() == count {
+						break
+					}
+				}
+			}
+		})
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	#[test]
+	fn parses_error_properly() {
+		let (_, rx) = futures::channel::mpsc::unbounded();
+		assert!(super::parse_rpc_result(
+			r#"{
+				"jsonrpc": "2.0",
+				"result": 19,
+				"id": 1
+			}"#
+			.to_string(),
+			rx
+		)
+		.is_ok());
+
+		let (_, rx) = futures::channel::mpsc::unbounded();
+		let error = super::parse_rpc_result(
+			r#"{
+				"jsonrpc": "2.0",
+				"error": {
+					"code": -32601,
+					"message": "Method not found"
+				},
+				"id": 1
+			}"#
+			.to_string(),
+			rx,
+		)
+		.unwrap_err();
+		assert_eq!(error.code, -32601);
+		assert_eq!(error.message, "Method not found");
+		assert!(error.data.is_none());
+
+		let (_, rx) = futures::channel::mpsc::unbounded();
+		let error = super::parse_rpc_result(
+			r#"{
+				"jsonrpc": "2.0",
+				"error": {
+					"code": -32601,
+					"message": "Method not found",
+					"data": 42
+				},
+				"id": 1
+			}"#
+			.to_string(),
+			rx,
+		)
+		.unwrap_err();
+		assert_eq!(error.code, -32601);
+		assert_eq!(error.message, "Method not found");
+		assert!(error.data.is_some());
+	}
+}
diff --git a/substrate/test-utils/derive/Cargo.toml b/substrate/test-utils/derive/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b5d73b8e99396e34f861d5bf7b81484cf69cc6eb
--- /dev/null
+++ b/substrate/test-utils/derive/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "substrate-test-utils-derive"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate test utilities macros"
+publish = false
+
+[dependencies]
+proc-macro-crate = "1.1.3"
+proc-macro2 = "1.0.56"
+quote = "1.0.28"
+syn = { version = "2.0.16", features = ["full"] }
+
+[lib]
+proc-macro = true
diff --git a/substrate/test-utils/derive/src/lib.rs b/substrate/test-utils/derive/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0291d825e768cec16e8e5f3cb979fe7d78e8c759
--- /dev/null
+++ b/substrate/test-utils/derive/src/lib.rs
@@ -0,0 +1,73 @@
+// 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 proc_macro::{Span, TokenStream};
+use proc_macro_crate::{crate_name, FoundCrate};
+use quote::quote;
+
+#[proc_macro_attribute]
+pub fn test(args: TokenStream, item: TokenStream) -> TokenStream {
+	let input = syn::parse_macro_input!(item as syn::ItemFn);
+
+	parse_knobs(input, args.into()).unwrap_or_else(|e| e.to_compile_error().into())
+}
+
+fn parse_knobs(
+	mut input: syn::ItemFn,
+	args: proc_macro2::TokenStream,
+) -> Result<TokenStream, syn::Error> {
+	let sig = &mut input.sig;
+	let body = &input.block;
+	let attrs = &input.attrs;
+	let vis = input.vis;
+
+	if !sig.inputs.is_empty() {
+		return Err(syn::Error::new_spanned(&sig, "No arguments expected for tests."))
+	}
+
+	let crate_name = match crate_name("substrate-test-utils") {
+		Ok(FoundCrate::Itself) => syn::Ident::new("substrate_test_utils", Span::call_site().into()),
+		Ok(FoundCrate::Name(crate_name)) => syn::Ident::new(&crate_name, Span::call_site().into()),
+		Err(e) => return Err(syn::Error::new_spanned(&sig, e)),
+	};
+
+	let header = {
+		quote! {
+			#[#crate_name::tokio::test( #args )]
+		}
+	};
+
+	let result = quote! {
+		#header
+		#(#attrs)*
+		#vis #sig {
+			if #crate_name::tokio::time::timeout(
+				std::time::Duration::from_secs(
+					std::env::var("SUBSTRATE_TEST_TIMEOUT")
+						.ok()
+						.and_then(|x| x.parse().ok())
+						.unwrap_or(600)),
+				async move { #body },
+			).await.is_err() {
+				panic!("The test took too long!");
+			}
+		}
+	};
+
+	Ok(result.into())
+}
diff --git a/substrate/test-utils/runtime/Cargo.toml b/substrate/test-utils/runtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..fe517843aff73cb36c21d61eae72431a2e2bb948
--- /dev/null
+++ b/substrate/test-utils/runtime/Cargo.toml
@@ -0,0 +1,112 @@
+[package]
+name = "substrate-test-runtime"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+build = "build.rs"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+sp-application-crypto = { version = "23.0.0", default-features = false, path = "../../primitives/application-crypto", features = ["serde"]  }
+sp-consensus-aura = { version = "0.10.0-dev", default-features = false, path = "../../primitives/consensus/aura", features = ["serde"] }
+sp-consensus-babe = { version = "0.10.0-dev", default-features = false, path = "../../primitives/consensus/babe", features = ["serde"] }
+sp-genesis-builder = { version = "0.1.0-dev", default-features = false, path = "../../primitives/genesis-builder" }
+sp-block-builder = { version = "4.0.0-dev", default-features = false, path = "../../primitives/block-builder" }
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-inherents = { version = "4.0.0-dev", default-features = false, path = "../../primitives/inherents" }
+sp-keyring = { version = "24.0.0", optional = true, path = "../../primitives/keyring" }
+sp-offchain = { version = "4.0.0-dev", default-features = false, path = "../../primitives/offchain" }
+sp-core = { version = "21.0.0", default-features = false, path = "../../primitives/core" }
+sp-std = { version = "8.0.0", default-features = false, path = "../../primitives/std" }
+sp-io = { version = "23.0.0", default-features = false, path = "../../primitives/io" }
+frame-support = { version = "4.0.0-dev", default-features = false, path = "../../frame/support" }
+sp-version = { version = "22.0.0", default-features = false, path = "../../primitives/version" }
+sp-session = { version = "4.0.0-dev", default-features = false, path = "../../primitives/session" }
+sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
+sp-runtime = { version = "24.0.0", default-features = false, path = "../../primitives/runtime", features = ["serde"] }
+pallet-babe = { version = "4.0.0-dev", default-features = false, path = "../../frame/babe" }
+pallet-balances = { version = "4.0.0-dev", default-features = false, path = "../../frame/balances" }
+frame-executive = { version = "4.0.0-dev", default-features = false, path = "../../frame/executive" }
+frame-system = { version = "4.0.0-dev", default-features = false, path = "../../frame/system" }
+frame-system-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../frame/system/rpc/runtime-api" }
+pallet-timestamp = { version = "4.0.0-dev", default-features = false, path = "../../frame/timestamp" }
+sp-consensus-grandpa = { version = "4.0.0-dev", default-features = false, path = "../../primitives/consensus/grandpa", features = ["serde"] }
+sp-trie = { version = "22.0.0", default-features = false, path = "../../primitives/trie" }
+sp-transaction-pool = { version = "4.0.0-dev", default-features = false, path = "../../primitives/transaction-pool" }
+trie-db = { version = "0.27.0", default-features = false }
+sc-service = { version = "0.10.0-dev", default-features = false, optional = true, features = ["test-helpers"], path = "../../client/service" }
+sp-state-machine = { version = "0.28.0", default-features = false, path = "../../primitives/state-machine" }
+sp-externalities = { version = "0.19.0", default-features = false, path = "../../primitives/externalities" }
+
+# 3rd party
+array-bytes = { version = "6.1", optional = true }
+log = { version = "0.4.17", default-features = false }
+serde = { version = "1.0.163", features = ["alloc", "derive"], default-features = false }
+serde_json = { version = "1.0.85", default-features = false, features = ["alloc"] }
+
+[dev-dependencies]
+futures = "0.3.21"
+sc-block-builder = { version = "0.10.0-dev", path = "../../client/block-builder" }
+sc-executor = { version = "0.10.0-dev", path = "../../client/executor" }
+sc-executor-common = { version = "0.10.0-dev", path = "../../client/executor/common" }
+sp-consensus = { version = "0.10.0-dev", path = "../../primitives/consensus/common" }
+substrate-test-runtime-client = { version = "2.0.0", path = "./client" }
+sp-tracing = { version = "10.0.0", path = "../../primitives/tracing" }
+json-patch = { version = "1.0.0", default-features = false }
+
+[build-dependencies]
+substrate-wasm-builder = { version = "5.0.0-dev", path = "../../utils/wasm-builder", optional = true }
+
+[features]
+default = [ "std" ]
+
+std = [
+	"array-bytes",
+	"codec/std",
+	"frame-executive/std",
+	"frame-support/std",
+	"frame-system-rpc-runtime-api/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-babe/std",
+	"pallet-balances/std",
+	"pallet-timestamp/std",
+	"sc-executor/std",
+	"sc-service",
+	"scale-info/std",
+	"sp-api/std",
+	"sp-application-crypto/std",
+	"sp-block-builder/std",
+	"sp-consensus-aura/std",
+	"sp-consensus-babe/std",
+	"sp-consensus-grandpa/std",
+	"sp-core/std",
+	"sp-externalities/std",
+	"sp-genesis-builder/std",
+	"sp-inherents/std",
+	"sp-io/std",
+	"sp-keyring",
+	"sp-offchain/std",
+	"sp-runtime/std",
+	"sp-session/std",
+	"sp-state-machine/std",
+	"sp-std/std",
+	"sp-tracing/std",
+	"sp-transaction-pool/std",
+	"sp-trie/std",
+	"sp-version/std",
+	"substrate-wasm-builder",
+	"trie-db/std",
+]
+# Special feature to disable logging
+disable-logging = [ "sp-api/disable-logging" ]
+
+#Enabling this flag will disable GenesisBuilder API implementation in runtime.
+disable-genesis-builder = []
diff --git a/substrate/test-utils/runtime/build.rs b/substrate/test-utils/runtime/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..230606635f7dc5a4fa452dc7f5dfd021747a6002
--- /dev/null
+++ b/substrate/test-utils/runtime/build.rs
@@ -0,0 +1,57 @@
+// 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.
+
+const BUILD_NO_GENESIS_BUILDER_SUPPORT_ENV: &str = "BUILD_NO_GENESIS_BUILDER_SUPPORT";
+
+fn main() {
+	#[cfg(feature = "std")]
+	{
+		substrate_wasm_builder::WasmBuilder::new()
+			.with_current_project()
+			.export_heap_base()
+			// Note that we set the stack-size to 1MB explicitly even though it is set
+			// 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")
+			.import_memory()
+			.build();
+	}
+
+	#[cfg(feature = "std")]
+	if std::env::var(BUILD_NO_GENESIS_BUILDER_SUPPORT_ENV).is_ok() {
+		substrate_wasm_builder::WasmBuilder::new()
+			.with_current_project()
+			.export_heap_base()
+			.append_to_rust_flags("-Clink-arg=-zstack-size=1048576")
+			.set_file_name("wasm_binary_no_genesis_builder")
+			.import_memory()
+			.enable_feature("disable-genesis-builder")
+			.build();
+	}
+	println!("cargo:rerun-if-env-changed={}", BUILD_NO_GENESIS_BUILDER_SUPPORT_ENV);
+
+	#[cfg(feature = "std")]
+	{
+		substrate_wasm_builder::WasmBuilder::new()
+			.with_current_project()
+			.export_heap_base()
+			.import_memory()
+			.set_file_name("wasm_binary_logging_disabled.rs")
+			.enable_feature("disable-logging")
+			.build();
+	}
+}
diff --git a/substrate/test-utils/runtime/client/Cargo.toml b/substrate/test-utils/runtime/client/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..8269fb72fe5085451de792ed958ad51e7b440919
--- /dev/null
+++ b/substrate/test-utils/runtime/client/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "substrate-test-runtime-client"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+futures = "0.3.21"
+sc-block-builder = { version = "0.10.0-dev", path = "../../../client/block-builder" }
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api" }
+sc-consensus = { version = "0.10.0-dev", path = "../../../client/consensus/common" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-consensus = { version = "0.10.0-dev", path = "../../../primitives/consensus/common" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+substrate-test-client = { version = "2.0.0", path = "../../client" }
+substrate-test-runtime = { version = "2.0.0", path = "../../runtime" }
diff --git a/substrate/test-utils/runtime/client/src/block_builder_ext.rs b/substrate/test-utils/runtime/client/src/block_builder_ext.rs
new file mode 100644
index 0000000000000000000000000000000000000000..78863209e33e9fe98f4332b46ba60e06e12fd1ad
--- /dev/null
+++ b/substrate/test-utils/runtime/client/src/block_builder_ext.rs
@@ -0,0 +1,76 @@
+// 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.
+
+//! Block Builder extensions for tests.
+
+use sc_client_api::backend;
+use sp_api::{ApiExt, ProvideRuntimeApi};
+
+use sc_block_builder::BlockBuilderApi;
+use substrate_test_runtime::*;
+
+/// Extension trait for test block builder.
+pub trait BlockBuilderExt {
+	/// Add transfer extrinsic to the block.
+	fn push_transfer(
+		&mut self,
+		transfer: substrate_test_runtime::Transfer,
+	) -> Result<(), sp_blockchain::Error>;
+
+	/// Add unsigned storage change extrinsic to the block.
+	fn push_storage_change(
+		&mut self,
+		key: Vec<u8>,
+		value: Option<Vec<u8>>,
+	) -> Result<(), sp_blockchain::Error>;
+
+	/// Adds an extrinsic which pushes DigestItem to header's log
+	fn push_deposit_log_digest_item(
+		&mut self,
+		log: sp_runtime::generic::DigestItem,
+	) -> Result<(), sp_blockchain::Error>;
+}
+
+impl<'a, A, B> BlockBuilderExt
+	for sc_block_builder::BlockBuilder<'a, substrate_test_runtime::Block, A, B>
+where
+	A: ProvideRuntimeApi<substrate_test_runtime::Block> + 'a,
+	A::Api: BlockBuilderApi<substrate_test_runtime::Block> + ApiExt<substrate_test_runtime::Block>,
+	B: backend::Backend<substrate_test_runtime::Block>,
+{
+	fn push_transfer(
+		&mut self,
+		transfer: substrate_test_runtime::Transfer,
+	) -> Result<(), sp_blockchain::Error> {
+		self.push(transfer.into_unchecked_extrinsic())
+	}
+
+	fn push_storage_change(
+		&mut self,
+		key: Vec<u8>,
+		value: Option<Vec<u8>>,
+	) -> Result<(), sp_blockchain::Error> {
+		self.push(ExtrinsicBuilder::new_storage_change(key, value).build())
+	}
+
+	fn push_deposit_log_digest_item(
+		&mut self,
+		log: sp_runtime::generic::DigestItem,
+	) -> Result<(), sp_blockchain::Error> {
+		self.push(ExtrinsicBuilder::new_deposit_log_digest_item(log).build())
+	}
+}
diff --git a/substrate/test-utils/runtime/client/src/lib.rs b/substrate/test-utils/runtime/client/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7428a7de3a096f343d28b39b618f353578649c74
--- /dev/null
+++ b/substrate/test-utils/runtime/client/src/lib.rs
@@ -0,0 +1,243 @@
+// 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.
+
+//! Client testing utilities.
+
+#![warn(missing_docs)]
+
+pub mod trait_tests;
+
+mod block_builder_ext;
+
+pub use sc_consensus::LongestChain;
+use std::sync::Arc;
+pub use substrate_test_client::*;
+pub use substrate_test_runtime as runtime;
+
+pub use self::block_builder_ext::BlockBuilderExt;
+
+use sp_core::storage::ChildInfo;
+use substrate_test_runtime::genesismap::GenesisStorageBuilder;
+
+/// A prelude to import in tests.
+pub mod prelude {
+	// Trait extensions
+	pub use super::{
+		BlockBuilderExt, ClientBlockImportExt, ClientExt, DefaultTestClientBuilderExt,
+		TestClientBuilderExt,
+	};
+	// Client structs
+	pub use super::{
+		Backend, ExecutorDispatch, LocalExecutorDispatch, NativeElseWasmExecutor, TestClient,
+		TestClientBuilder, WasmExecutionMethod,
+	};
+	// Keyring
+	pub use super::{AccountKeyring, Sr25519Keyring};
+}
+
+/// A unit struct which implements `NativeExecutionDispatch` feeding in the
+/// hard-coded runtime.
+pub struct LocalExecutorDispatch;
+
+impl sc_executor::NativeExecutionDispatch for LocalExecutorDispatch {
+	type ExtendHostFunctions = ();
+
+	fn dispatch(method: &str, data: &[u8]) -> Option<Vec<u8>> {
+		substrate_test_runtime::api::dispatch(method, data)
+	}
+
+	fn native_version() -> sc_executor::NativeVersion {
+		substrate_test_runtime::native_version()
+	}
+}
+
+/// Test client database backend.
+pub type Backend = substrate_test_client::Backend<substrate_test_runtime::Block>;
+
+/// Test client executor.
+pub type ExecutorDispatch = client::LocalCallExecutor<
+	substrate_test_runtime::Block,
+	Backend,
+	NativeElseWasmExecutor<LocalExecutorDispatch>,
+>;
+
+/// Parameters of test-client builder with test-runtime.
+#[derive(Default)]
+pub struct GenesisParameters {
+	heap_pages_override: Option<u64>,
+	extra_storage: Storage,
+	wasm_code: Option<Vec<u8>>,
+}
+
+impl GenesisParameters {
+	/// Set the wasm code that should be used at genesis.
+	pub fn set_wasm_code(&mut self, code: Vec<u8>) {
+		self.wasm_code = Some(code);
+	}
+
+	/// Access extra genesis storage.
+	pub fn extra_storage(&mut self) -> &mut Storage {
+		&mut self.extra_storage
+	}
+}
+
+impl GenesisInit for GenesisParameters {
+	fn genesis_storage(&self) -> Storage {
+		GenesisStorageBuilder::default()
+			.with_heap_pages(self.heap_pages_override)
+			.with_wasm_code(&self.wasm_code)
+			.with_extra_storage(self.extra_storage.clone())
+			.build()
+	}
+}
+
+/// A `TestClient` with `test-runtime` builder.
+pub type TestClientBuilder<E, B> = substrate_test_client::TestClientBuilder<
+	substrate_test_runtime::Block,
+	E,
+	B,
+	GenesisParameters,
+>;
+
+/// Test client type with `LocalExecutorDispatch` and generic Backend.
+pub type Client<B> = client::Client<
+	B,
+	client::LocalCallExecutor<
+		substrate_test_runtime::Block,
+		B,
+		NativeElseWasmExecutor<LocalExecutorDispatch>,
+	>,
+	substrate_test_runtime::Block,
+	substrate_test_runtime::RuntimeApi,
+>;
+
+/// A test client with default backend.
+pub type TestClient = Client<Backend>;
+
+/// A `TestClientBuilder` with default backend and executor.
+pub trait DefaultTestClientBuilderExt: Sized {
+	/// Create new `TestClientBuilder`
+	fn new() -> Self;
+}
+
+impl DefaultTestClientBuilderExt for TestClientBuilder<ExecutorDispatch, Backend> {
+	fn new() -> Self {
+		Self::with_default_backend()
+	}
+}
+
+/// A `test-runtime` extensions to `TestClientBuilder`.
+pub trait TestClientBuilderExt<B>: Sized {
+	/// Returns a mutable reference to the genesis parameters.
+	fn genesis_init_mut(&mut self) -> &mut GenesisParameters;
+
+	/// Override the default value for Wasm heap pages.
+	fn set_heap_pages(mut self, heap_pages: u64) -> Self {
+		self.genesis_init_mut().heap_pages_override = Some(heap_pages);
+		self
+	}
+
+	/// Add an extra value into the genesis storage.
+	///
+	/// # Panics
+	///
+	/// Panics if the key is empty.
+	fn add_extra_child_storage<K: Into<Vec<u8>>, V: Into<Vec<u8>>>(
+		mut self,
+		child_info: &ChildInfo,
+		key: K,
+		value: V,
+	) -> Self {
+		let storage_key = child_info.storage_key().to_vec();
+		let key = key.into();
+		assert!(!storage_key.is_empty());
+		assert!(!key.is_empty());
+		self.genesis_init_mut()
+			.extra_storage
+			.children_default
+			.entry(storage_key)
+			.or_insert_with(|| StorageChild {
+				data: Default::default(),
+				child_info: child_info.clone(),
+			})
+			.data
+			.insert(key, value.into());
+		self
+	}
+
+	/// Add an extra child value into the genesis storage.
+	///
+	/// # Panics
+	///
+	/// Panics if the key is empty.
+	fn add_extra_storage<K: Into<Vec<u8>>, V: Into<Vec<u8>>>(mut self, key: K, value: V) -> Self {
+		let key = key.into();
+		assert!(!key.is_empty());
+		self.genesis_init_mut().extra_storage.top.insert(key, value.into());
+		self
+	}
+
+	/// Build the test client.
+	fn build(self) -> Client<B> {
+		self.build_with_longest_chain().0
+	}
+
+	/// Build the test client and longest chain selector.
+	fn build_with_longest_chain(
+		self,
+	) -> (Client<B>, sc_consensus::LongestChain<B, substrate_test_runtime::Block>);
+
+	/// Build the test client and the backend.
+	fn build_with_backend(self) -> (Client<B>, Arc<B>);
+}
+
+impl<B> TestClientBuilderExt<B>
+	for TestClientBuilder<
+		client::LocalCallExecutor<
+			substrate_test_runtime::Block,
+			B,
+			NativeElseWasmExecutor<LocalExecutorDispatch>,
+		>,
+		B,
+	> where
+	B: sc_client_api::backend::Backend<substrate_test_runtime::Block> + 'static,
+{
+	fn genesis_init_mut(&mut self) -> &mut GenesisParameters {
+		Self::genesis_init_mut(self)
+	}
+
+	fn build_with_longest_chain(
+		self,
+	) -> (Client<B>, sc_consensus::LongestChain<B, substrate_test_runtime::Block>) {
+		self.build_with_native_executor(None)
+	}
+
+	fn build_with_backend(self) -> (Client<B>, Arc<B>) {
+		let backend = self.backend();
+		(self.build_with_native_executor(None).0, backend)
+	}
+}
+
+/// Creates new client instance used for tests.
+pub fn new() -> Client<Backend> {
+	TestClientBuilder::new().build()
+}
+
+/// Create a new native executor.
+pub fn new_native_or_wasm_executor() -> NativeElseWasmExecutor<LocalExecutorDispatch> {
+	NativeElseWasmExecutor::new_with_wasm_executor(WasmExecutor::builder().build())
+}
diff --git a/substrate/test-utils/runtime/client/src/trait_tests.rs b/substrate/test-utils/runtime/client/src/trait_tests.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5fce7a2860b755c10b57173b01b9a29d9e8f6740
--- /dev/null
+++ b/substrate/test-utils/runtime/client/src/trait_tests.rs
@@ -0,0 +1,421 @@
+// 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 that should hold for all implementations of certain traits.
+//! to test implementations without duplication.
+
+#![allow(missing_docs)]
+
+use std::sync::Arc;
+
+use crate::{
+	AccountKeyring, BlockBuilderExt, ClientBlockImportExt, TestClientBuilder, TestClientBuilderExt,
+};
+use futures::executor::block_on;
+use sc_block_builder::BlockBuilderProvider;
+use sc_client_api::{
+	backend,
+	blockchain::{Backend as BlockChainBackendT, HeaderBackend},
+};
+use sp_consensus::BlockOrigin;
+use sp_runtime::traits::Block as BlockT;
+use substrate_test_runtime::{self, Transfer};
+
+/// helper to test the `leaves` implementation for various backends
+pub fn test_leaves_for_backend<B: 'static>(backend: Arc<B>)
+where
+	B: backend::Backend<substrate_test_runtime::Block>,
+{
+	// block tree:
+	// G -> A1 -> A2 -> A3 -> A4 -> A5
+	// 		A1 -> B2 -> B3 -> B4
+	// 			  B2 -> C3
+	// 		A1 -> D2
+
+	let mut client = TestClientBuilder::with_backend(backend.clone()).build();
+	let blockchain = backend.blockchain();
+
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	assert_eq!(blockchain.leaves().unwrap(), vec![genesis_hash]);
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a1.hash()]);
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	assert_eq!(blockchain.leaves().unwrap(), vec![a2.hash()]);
+
+	// A2 -> A3
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+
+	assert_eq!(blockchain.leaves().unwrap(), vec![a3.hash()]);
+
+	// A3 -> A4
+	let a4 = client
+		.new_block_at(a3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a4.hash()]);
+
+	// A4 -> A5
+	let a5 = client
+		.new_block_at(a4.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash()]);
+
+	// A1 -> B2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+
+	// this push is required as otherwise B2 has the same hash as A2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let b2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b2.hash()]);
+
+	// B2 -> B3
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b3.hash()]);
+
+	// B3 -> B4
+	let b4 = client
+		.new_block_at(b3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b4.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b4.hash()]);
+
+	// // B2 -> C3
+	let mut builder = client.new_block_at(b2.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise C3 has the same hash as B3 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1,
+			nonce: 1,
+		})
+		.unwrap();
+	let c3 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b4.hash(), c3.hash()]);
+
+	// A1 -> D2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise D2 has the same hash as B2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1,
+			nonce: 0,
+		})
+		.unwrap();
+	let d2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
+	assert_eq!(blockchain.leaves().unwrap(), vec![a5.hash(), b4.hash(), c3.hash(), d2.hash()]);
+}
+
+/// helper to test the `children` implementation for various backends
+pub fn test_children_for_backend<B: 'static>(backend: Arc<B>)
+where
+	B: backend::LocalBackend<substrate_test_runtime::Block>,
+{
+	// block tree:
+	// G -> A1 -> A2 -> A3 -> A4 -> A5
+	// 		A1 -> B2 -> B3 -> B4
+	// 			  B2 -> C3
+	// 		A1 -> D2
+
+	let mut client = TestClientBuilder::with_backend(backend.clone()).build();
+	let blockchain = backend.blockchain();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	// A2 -> A3
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+
+	// A3 -> A4
+	let a4 = client
+		.new_block_at(a3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
+
+	// A4 -> A5
+	let a5 = client
+		.new_block_at(a4.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
+
+	// A1 -> B2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise B2 has the same hash as A2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let b2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	// B2 -> B3
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
+
+	// B3 -> B4
+	let b4 = client
+		.new_block_at(b3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b4)).unwrap();
+
+	// // B2 -> C3
+	let mut builder = client.new_block_at(b2.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise C3 has the same hash as B3 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1,
+			nonce: 1,
+		})
+		.unwrap();
+	let c3 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, c3.clone())).unwrap();
+
+	// A1 -> D2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise D2 has the same hash as B2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1,
+			nonce: 0,
+		})
+		.unwrap();
+	let d2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, d2.clone())).unwrap();
+
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	let children1 = blockchain.children(a4.hash()).unwrap();
+	assert_eq!(vec![a5.hash()], children1);
+
+	let children2 = blockchain.children(a1.hash()).unwrap();
+	assert_eq!(vec![a2.hash(), b2.hash(), d2.hash()], children2);
+
+	let children3 = blockchain.children(genesis_hash).unwrap();
+	assert_eq!(vec![a1.hash()], children3);
+
+	let children4 = blockchain.children(b2.hash()).unwrap();
+	assert_eq!(vec![b3.hash(), c3.hash()], children4);
+}
+
+pub fn test_blockchain_query_by_number_gets_canonical<B: 'static>(backend: Arc<B>)
+where
+	B: backend::LocalBackend<substrate_test_runtime::Block>,
+{
+	// block tree:
+	// G -> A1 -> A2 -> A3 -> A4 -> A5
+	// 		A1 -> B2 -> B3 -> B4
+	// 			  B2 -> C3
+	// 		A1 -> D2
+	let mut client = TestClientBuilder::with_backend(backend.clone()).build();
+	let blockchain = backend.blockchain();
+
+	// G -> A1
+	let a1 = client.new_block(Default::default()).unwrap().build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, a1.clone())).unwrap();
+
+	// A1 -> A2
+	let a2 = client
+		.new_block_at(a1.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a2.clone())).unwrap();
+
+	// A2 -> A3
+	let a3 = client
+		.new_block_at(a2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a3.clone())).unwrap();
+
+	// A3 -> A4
+	let a4 = client
+		.new_block_at(a3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a4.clone())).unwrap();
+
+	// A4 -> A5
+	let a5 = client
+		.new_block_at(a4.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, a5.clone())).unwrap();
+
+	// A1 -> B2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise B2 has the same hash as A2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 41,
+			nonce: 0,
+		})
+		.unwrap();
+	let b2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, b2.clone())).unwrap();
+
+	// B2 -> B3
+	let b3 = client
+		.new_block_at(b2.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b3.clone())).unwrap();
+
+	// B3 -> B4
+	let b4 = client
+		.new_block_at(b3.hash(), Default::default(), false)
+		.unwrap()
+		.build()
+		.unwrap()
+		.block;
+	block_on(client.import(BlockOrigin::Own, b4)).unwrap();
+
+	// // B2 -> C3
+	let mut builder = client.new_block_at(b2.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise C3 has the same hash as B3 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1,
+			nonce: 1,
+		})
+		.unwrap();
+	let c3 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, c3)).unwrap();
+
+	// A1 -> D2
+	let mut builder = client.new_block_at(a1.hash(), Default::default(), false).unwrap();
+	// this push is required as otherwise D2 has the same hash as B2 and won't get imported
+	builder
+		.push_transfer(Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Ferdie.into(),
+			amount: 1,
+			nonce: 0,
+		})
+		.unwrap();
+	let d2 = builder.build().unwrap().block;
+	block_on(client.import(BlockOrigin::Own, d2)).unwrap();
+
+	let genesis_hash = client.chain_info().genesis_hash;
+
+	assert_eq!(blockchain.hash(0).unwrap().unwrap(), genesis_hash);
+	assert_eq!(blockchain.hash(1).unwrap().unwrap(), a1.hash());
+	assert_eq!(blockchain.hash(2).unwrap().unwrap(), a2.hash());
+	assert_eq!(blockchain.hash(3).unwrap().unwrap(), a3.hash());
+	assert_eq!(blockchain.hash(4).unwrap().unwrap(), a4.hash());
+	assert_eq!(blockchain.hash(5).unwrap().unwrap(), a5.hash());
+}
diff --git a/substrate/test-utils/runtime/src/extrinsic.rs b/substrate/test-utils/runtime/src/extrinsic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..05ffb7db5d5b95d6d6dbadf5f48da563c04a4c59
--- /dev/null
+++ b/substrate/test-utils/runtime/src/extrinsic.rs
@@ -0,0 +1,207 @@
+// 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.
+
+//! Provides utils for building the `Extrinsic` instances used with `substrate-test-runtime`.
+
+use crate::{
+	substrate_test_pallet::pallet::Call as PalletCall, AccountId, Balance, BalancesCall,
+	CheckSubstrateCall, Extrinsic, Nonce, Pair, RuntimeCall, SignedPayload, TransferData,
+};
+use codec::Encode;
+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_std::prelude::*;
+
+/// Transfer used in test substrate pallet. Extrinsic is created and signed using this data.
+#[derive(Clone)]
+pub struct Transfer {
+	/// Transfer sender and signer of created extrinsic
+	pub from: Pair,
+	/// The recipient of the transfer
+	pub to: AccountId,
+	/// Amount of transfer
+	pub amount: Balance,
+	/// Sender's account nonce at which transfer is valid
+	pub nonce: u64,
+}
+
+impl Transfer {
+	/// Convert into a signed unchecked extrinsic.
+	pub fn into_unchecked_extrinsic(self) -> Extrinsic {
+		ExtrinsicBuilder::new_transfer(self).build()
+	}
+}
+
+impl Default for TransferData {
+	fn default() -> Self {
+		Self {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Bob.into(),
+			amount: 0,
+			nonce: 0,
+		}
+	}
+}
+
+/// If feasible converts given `Extrinsic` to `TransferData`
+impl TryFrom<&Extrinsic> for TransferData {
+	type Error = ();
+	fn try_from(uxt: &Extrinsic) -> Result<Self, Self::Error> {
+		match uxt {
+			Extrinsic {
+				function: RuntimeCall::Balances(BalancesCall::transfer_allow_death { dest, value }),
+				signature: Some((from, _, (CheckNonce(nonce), ..))),
+			} => Ok(TransferData { from: *from, to: *dest, amount: *value, nonce: *nonce }),
+			Extrinsic {
+				function: RuntimeCall::SubstrateTest(PalletCall::bench_call { transfer }),
+				signature: None,
+			} => Ok(transfer.clone()),
+			_ => Err(()),
+		}
+	}
+}
+
+/// Generates `Extrinsic`
+pub struct ExtrinsicBuilder {
+	function: RuntimeCall,
+	signer: Option<Pair>,
+	nonce: Option<Nonce>,
+}
+
+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 }
+	}
+
+	/// 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 }
+	}
+
+	/// Create builder for `pallet_call::bench_transfer` from given `TransferData`.
+	pub fn new_bench_call(transfer: TransferData) -> Self {
+		Self::new_unsigned(PalletCall::bench_call { transfer })
+	}
+
+	/// Create builder for given `Transfer`. Transfer `nonce` will be used as `Extrinsic` nonce.
+	/// Transfer `from` will be used as Extrinsic signer.
+	pub fn new_transfer(transfer: Transfer) -> Self {
+		Self {
+			nonce: Some(transfer.nonce),
+			signer: Some(transfer.from.clone()),
+			..Self::new(BalancesCall::transfer_allow_death {
+				dest: transfer.to,
+				value: transfer.amount,
+			})
+		}
+	}
+
+	/// Create builder for `PalletCall::include_data` call using given parameters
+	pub fn new_include_data(data: Vec<u8>) -> Self {
+		Self::new(PalletCall::include_data { data })
+	}
+
+	/// Create builder for `PalletCall::storage_change` call using given parameters. Will
+	/// create unsigned Extrinsic.
+	pub fn new_storage_change(key: Vec<u8>, value: Option<Vec<u8>>) -> Self {
+		Self::new_unsigned(PalletCall::storage_change { key, value })
+	}
+
+	/// Create builder for `PalletCall::offchain_index_set` call using given parameters
+	pub fn new_offchain_index_set(key: Vec<u8>, value: Vec<u8>) -> Self {
+		Self::new(PalletCall::offchain_index_set { key, value })
+	}
+
+	/// Create builder for `PalletCall::offchain_index_clear` call using given parameters
+	pub fn new_offchain_index_clear(key: Vec<u8>) -> Self {
+		Self::new(PalletCall::offchain_index_clear { key })
+	}
+
+	/// Create builder for `PalletCall::indexed_call` call using given parameters
+	pub fn new_indexed_call(data: Vec<u8>) -> Self {
+		Self::new(PalletCall::indexed_call { data })
+	}
+
+	/// Create builder for `PalletCall::new_deposit_log_digest_item` call using given `log`
+	pub fn new_deposit_log_digest_item(log: sp_runtime::generic::DigestItem) -> Self {
+		Self::new_unsigned(PalletCall::deposit_log_digest_item { log })
+	}
+
+	/// Create builder for `PalletCall::Call::new_deposit_log_digest_item`
+	pub fn new_fill_block(ratio: Perbill) -> Self {
+		Self::new(PalletCall::fill_block { ratio })
+	}
+
+	/// Create builder for `PalletCall::call_do_not_propagate` call using given parameters
+	pub fn new_call_do_not_propagate() -> Self {
+		Self::new(PalletCall::call_do_not_propagate {})
+	}
+
+	/// Create builder for `PalletCall::call_with_priority` call using given parameters
+	pub fn new_call_with_priority(priority: TransactionPriority) -> Self {
+		Self::new(PalletCall::call_with_priority { priority })
+	}
+
+	/// Create builder for `PalletCall::read` call using given parameters
+	pub fn new_read(count: u32) -> Self {
+		Self::new_unsigned(PalletCall::read { count })
+	}
+
+	/// Create builder for `PalletCall::read` call using given parameters
+	pub fn new_read_and_panic(count: u32) -> Self {
+		Self::new_unsigned(PalletCall::read_and_panic { count })
+	}
+
+	/// Unsigned `Extrinsic` will be created
+	pub fn unsigned(mut self) -> Self {
+		self.signer = None;
+		self
+	}
+
+	/// Given `nonce` will be set in `Extrinsic`
+	pub fn nonce(mut self, nonce: Nonce) -> Self {
+		self.nonce = Some(nonce);
+		self
+	}
+
+	/// Extrinsic will be signed by `signer`
+	pub fn signer(mut self, signer: Pair) -> Self {
+		self.signer = Some(signer);
+		self
+	}
+
+	/// Build `Extrinsic` using embedded parameters
+	pub fn build(self) -> Extrinsic {
+		if let Some(signer) = self.signer {
+			let extra = (
+				CheckNonce::from(self.nonce.unwrap_or(0)),
+				CheckWeight::new(),
+				CheckSubstrateCall {},
+			);
+			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)
+		} else {
+			Extrinsic::new_unsigned(self.function)
+		}
+	}
+}
diff --git a/substrate/test-utils/runtime/src/genesismap.rs b/substrate/test-utils/runtime/src/genesismap.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8a4d6dbe4a71a59c9d1086f4eb61b3618211690b
--- /dev/null
+++ b/substrate/test-utils/runtime/src/genesismap.rs
@@ -0,0 +1,178 @@
+// 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.
+
+//! Tool for creating the genesis block.
+
+use super::{
+	currency, substrate_test_pallet, wasm_binary_unwrap, AccountId, Balance, RuntimeGenesisConfig,
+};
+use codec::Encode;
+use sc_service::construct_genesis_block;
+use sp_core::{
+	sr25519,
+	storage::{well_known_keys, StateVersion, Storage},
+	Pair,
+};
+use sp_keyring::{AccountKeyring, Sr25519Keyring};
+use sp_runtime::{
+	traits::{Block as BlockT, Hash as HashT, Header as HeaderT},
+	BuildStorage,
+};
+
+/// Builder for generating storage from substrate-test-runtime genesis config.
+///
+/// Default storage can be extended with additional key-value pairs.
+pub struct GenesisStorageBuilder {
+	/// Authorities accounts used by any component requiring an authority set (e.g. babe).
+	authorities: Vec<AccountId>,
+	/// Accounts to be endowed with some funds.
+	balances: Vec<(AccountId, u64)>,
+	/// Override default number of heap pages.
+	heap_pages_override: Option<u64>,
+	/// Additional storage key pairs that will be added to the genesis map.
+	extra_storage: Storage,
+	/// Optional wasm code override.
+	wasm_code: Option<Vec<u8>>,
+}
+
+impl Default for GenesisStorageBuilder {
+	/// Creates a builder with default settings for `substrate_test_runtime`.
+	fn default() -> Self {
+		Self::new(
+			vec![
+				Sr25519Keyring::Alice.into(),
+				Sr25519Keyring::Bob.into(),
+				Sr25519Keyring::Charlie.into(),
+			],
+			(0..16_usize)
+				.into_iter()
+				.map(|i| AccountKeyring::numeric(i).public())
+				.chain(vec![
+					AccountKeyring::Alice.into(),
+					AccountKeyring::Bob.into(),
+					AccountKeyring::Charlie.into(),
+				])
+				.collect(),
+			1000 * currency::DOLLARS,
+		)
+	}
+}
+
+impl GenesisStorageBuilder {
+	/// Creates a storage builder for genesis config. `substrage test runtime`
+	/// [`RuntimeGenesisConfig`] is initialized with provided `authorities`, `endowed_accounts` with
+	/// given balance. Key-value pairs from `extra_storage` will be injected into built storage.
+	/// `HEAP_PAGES` key and value will also be placed into storage.
+	pub fn new(
+		authorities: Vec<AccountId>,
+		endowed_accounts: Vec<AccountId>,
+		balance: Balance,
+	) -> Self {
+		GenesisStorageBuilder {
+			authorities,
+			balances: endowed_accounts.into_iter().map(|a| (a, balance)).collect(),
+			heap_pages_override: None,
+			extra_storage: Default::default(),
+			wasm_code: None,
+		}
+	}
+
+	/// Override default wasm code to be placed into RuntimeGenesisConfig.
+	pub fn with_wasm_code(mut self, wasm_code: &Option<Vec<u8>>) -> Self {
+		self.wasm_code = wasm_code.clone();
+		self
+	}
+
+	pub fn with_heap_pages(mut self, heap_pages_override: Option<u64>) -> Self {
+		self.heap_pages_override = heap_pages_override;
+		self
+	}
+
+	pub fn with_extra_storage(mut self, storage: Storage) -> Self {
+		self.extra_storage = storage;
+		self
+	}
+
+	/// A `RuntimeGenesisConfig` from internal configuration
+	pub fn genesis_config(&self) -> RuntimeGenesisConfig {
+		let authorities_sr25519: Vec<_> = self
+			.authorities
+			.clone()
+			.into_iter()
+			.map(|id| sr25519::Public::from(id))
+			.collect();
+
+		RuntimeGenesisConfig {
+			system: frame_system::GenesisConfig {
+				code: self.wasm_code.clone().unwrap_or(wasm_binary_unwrap().to_vec()),
+				..Default::default()
+			},
+			babe: pallet_babe::GenesisConfig {
+				authorities: authorities_sr25519
+					.clone()
+					.into_iter()
+					.map(|x| (x.into(), 1))
+					.collect(),
+				epoch_config: Some(crate::TEST_RUNTIME_BABE_EPOCH_CONFIGURATION),
+				..Default::default()
+			},
+			substrate_test: substrate_test_pallet::GenesisConfig {
+				authorities: authorities_sr25519.clone(),
+				..Default::default()
+			},
+			balances: pallet_balances::GenesisConfig { balances: self.balances.clone() },
+		}
+	}
+
+	/// Builds the `RuntimeGenesisConfig` and returns its storage.
+	pub fn build(self) -> Storage {
+		let mut storage = self
+			.genesis_config()
+			.build_storage()
+			.expect("Build storage from substrate-test-runtime RuntimeGenesisConfig");
+
+		if let Some(heap_pages) = self.heap_pages_override {
+			storage.top.insert(well_known_keys::HEAP_PAGES.into(), heap_pages.encode());
+		}
+
+		storage.top.extend(self.extra_storage.top.clone());
+		storage.children_default.extend(self.extra_storage.children_default.clone());
+
+		storage
+	}
+}
+
+pub fn insert_genesis_block(storage: &mut Storage) -> sp_core::hash::H256 {
+	let child_roots = storage.children_default.iter().map(|(sk, child_content)| {
+		let state_root =
+			<<<crate::Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
+				child_content.data.clone().into_iter().collect(),
+				sp_runtime::StateVersion::V1,
+			);
+		(sk.clone(), state_root.encode())
+	});
+	// add child roots to storage
+	storage.top.extend(child_roots);
+	let state_root = <<<crate::Block as BlockT>::Header as HeaderT>::Hashing as HashT>::trie_root(
+		storage.top.clone().into_iter().collect(),
+		sp_runtime::StateVersion::V1,
+	);
+	let block: crate::Block = construct_genesis_block(state_root, StateVersion::V1);
+	let genesis_hash = block.header.hash();
+
+	genesis_hash
+}
diff --git a/substrate/test-utils/runtime/src/lib.rs b/substrate/test-utils/runtime/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b116c8556815f3eef73e08252faab9d9f586ff24
--- /dev/null
+++ b/substrate/test-utils/runtime/src/lib.rs
@@ -0,0 +1,1450 @@
+// 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.
+
+//! The Substrate runtime. This can be compiled with `#[no_std]`, ready for Wasm.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "std")]
+pub mod extrinsic;
+#[cfg(feature = "std")]
+pub mod genesismap;
+pub mod substrate_test_pallet;
+
+use codec::{Decode, Encode};
+#[cfg(not(feature = "disable-genesis-builder"))]
+use frame_support::genesis_builder_helper::{build_config, create_default_config};
+use frame_support::{
+	construct_runtime,
+	dispatch::DispatchClass,
+	parameter_types,
+	traits::{ConstU32, ConstU64},
+	weights::{
+		constants::{BlockExecutionWeight, ExtrinsicBaseWeight, WEIGHT_REF_TIME_PER_SECOND},
+		Weight,
+	},
+};
+use frame_system::{
+	limits::{BlockLength, BlockWeights},
+	CheckNonce, CheckWeight,
+};
+use scale_info::TypeInfo;
+use sp_std::prelude::*;
+#[cfg(not(feature = "std"))]
+use sp_std::vec;
+
+use sp_application_crypto::{ecdsa, ed25519, sr25519, RuntimeAppPublic};
+use sp_core::{OpaqueMetadata, RuntimeDebug};
+use sp_trie::{
+	trie_types::{TrieDBBuilder, TrieDBMutBuilderV1},
+	PrefixedMemoryDB, StorageProof,
+};
+use trie_db::{Trie, TrieMut};
+
+use sp_api::{decl_runtime_apis, impl_runtime_apis};
+pub use sp_core::hash::H256;
+use sp_inherents::{CheckInherentsResult, InherentData};
+use sp_runtime::{
+	create_runtime_str, impl_opaque_keys,
+	traits::{BlakeTwo256, Block as BlockT, DispatchInfoOf, NumberFor, Verify},
+	transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError},
+	ApplyExtrinsicResult, Perbill,
+};
+#[cfg(any(feature = "std", test))]
+use sp_version::NativeVersion;
+use sp_version::RuntimeVersion;
+
+pub use sp_consensus_babe::{AllowedSlots, BabeEpochConfiguration, Slot};
+
+pub use pallet_balances::Call as BalancesCall;
+
+pub type AuraId = sp_consensus_aura::sr25519::AuthorityId;
+#[cfg(feature = "std")]
+pub use extrinsic::{ExtrinsicBuilder, Transfer};
+
+const LOG_TARGET: &str = "substrate-test-runtime";
+
+// Include the WASM binary
+#[cfg(feature = "std")]
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+
+#[cfg(feature = "std")]
+pub mod wasm_binary_logging_disabled {
+	include!(concat!(env!("OUT_DIR"), "/wasm_binary_logging_disabled.rs"));
+}
+
+/// Wasm binary unwrapped. If built with `SKIP_WASM_BUILD`, the function panics.
+#[cfg(feature = "std")]
+pub fn wasm_binary_unwrap() -> &'static [u8] {
+	WASM_BINARY.expect(
+		"Development wasm binary is not available. Testing is only supported with the flag \
+		 disabled.",
+	)
+}
+
+/// Wasm binary unwrapped. If built with `SKIP_WASM_BUILD`, the function panics.
+#[cfg(feature = "std")]
+pub fn wasm_binary_logging_disabled_unwrap() -> &'static [u8] {
+	wasm_binary_logging_disabled::WASM_BINARY.expect(
+		"Development wasm binary is not available. Testing is only supported with the flag \
+		 disabled.",
+	)
+}
+
+/// Test runtime version.
+#[sp_version::runtime_version]
+pub const VERSION: RuntimeVersion = RuntimeVersion {
+	spec_name: create_runtime_str!("test"),
+	impl_name: create_runtime_str!("parity-test"),
+	authoring_version: 1,
+	spec_version: 2,
+	impl_version: 2,
+	apis: RUNTIME_API_VERSIONS,
+	transaction_version: 1,
+	state_version: 1,
+};
+
+fn version() -> RuntimeVersion {
+	VERSION
+}
+
+/// Native version.
+#[cfg(any(feature = "std", test))]
+pub fn native_version() -> NativeVersion {
+	NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
+}
+
+/// Transfer data extracted from Extrinsic containing `Balances::transfer_allow_death`.
+#[derive(Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct TransferData {
+	pub from: AccountId,
+	pub to: AccountId,
+	pub amount: Balance,
+	pub nonce: Nonce,
+}
+
+/// The address format for describing accounts.
+pub type Address = sp_core::sr25519::Public;
+pub type Signature = sr25519::Signature;
+#[cfg(feature = "std")]
+pub type Pair = sp_core::sr25519::Pair;
+
+/// The SignedExtension to the basic transaction logic.
+pub type SignedExtra = (CheckNonce<Runtime>, CheckWeight<Runtime>, CheckSubstrateCall);
+/// The payload being signed in transactions.
+pub type SignedPayload = sp_runtime::generic::SignedPayload<RuntimeCall, SignedExtra>;
+/// Unchecked extrinsic type as expected by this runtime.
+pub type Extrinsic =
+	sp_runtime::generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
+
+/// An identifier for an account on this system.
+pub type AccountId = <Signature as Verify>::Signer;
+/// A simple hash type for all our hashing.
+pub type Hash = H256;
+/// The hashing algorithm used.
+pub type Hashing = BlakeTwo256;
+/// The block number type used in this runtime.
+pub type BlockNumber = u64;
+/// Index of a transaction.
+pub type Nonce = u64;
+/// The item of a block digest.
+pub type DigestItem = sp_runtime::generic::DigestItem;
+/// The digest of a block.
+pub type Digest = sp_runtime::generic::Digest;
+/// A test block.
+pub type Block = sp_runtime::generic::Block<Header, Extrinsic>;
+/// A test block's header.
+pub type Header = sp_runtime::generic::Header<BlockNumber, Hashing>;
+/// Balance of an account.
+pub type Balance = u64;
+
+decl_runtime_apis! {
+	#[api_version(2)]
+	pub trait TestAPI {
+		/// Return the balance of the given account id.
+		fn balance_of(id: AccountId) -> u64;
+		/// A benchmark function that adds one to the given value and returns the result.
+		fn benchmark_add_one(val: &u64) -> u64;
+		/// A benchmark function that adds one to each value in the given vector and returns the
+		/// result.
+		fn benchmark_vector_add_one(vec: &Vec<u64>) -> Vec<u64>;
+		/// A function for that the signature changed in version `2`.
+		#[changed_in(2)]
+		fn function_signature_changed() -> Vec<u64>;
+		/// The new signature.
+		fn function_signature_changed() -> u64;
+		/// trie no_std testing
+		fn use_trie() -> u64;
+		/// Calls function in the loop using never-inlined function pointer
+		fn benchmark_indirect_call() -> u64;
+		/// Calls function in the loop
+		fn benchmark_direct_call() -> u64;
+		/// Allocates vector with given capacity.
+		fn vec_with_capacity(size: u32) -> Vec<u8>;
+		/// Returns the initialized block number.
+		fn get_block_number() -> u64;
+
+		/// Test that `ed25519` crypto works in the runtime.
+		///
+		/// Returns the signature generated for the message `ed25519` and the public key.
+		fn test_ed25519_crypto() -> (ed25519::AppSignature, ed25519::AppPublic);
+		/// Test that `sr25519` crypto works in the runtime.
+		///
+		/// Returns the signature generated for the message `sr25519`.
+		fn test_sr25519_crypto() -> (sr25519::AppSignature, sr25519::AppPublic);
+		/// Test that `ecdsa` crypto works in the runtime.
+		///
+		/// Returns the signature generated for the message `ecdsa`.
+		fn test_ecdsa_crypto() -> (ecdsa::AppSignature, ecdsa::AppPublic);
+		/// Run various tests against storage.
+		fn test_storage();
+		/// Check a witness.
+		fn test_witness(proof: StorageProof, root: crate::Hash);
+		/// Test that ensures that we can call a function that takes multiple
+		/// arguments.
+		fn test_multiple_arguments(data: Vec<u8>, other: Vec<u8>, num: u32);
+		/// Traces log "Hey I'm runtime."
+		fn do_trace_log();
+		/// Verify the given signature, public & message bundle.
+		fn verify_ed25519(sig: ed25519::Signature, public: ed25519::Public, message: Vec<u8>) -> bool;
+		/// Write the given `value` under the given `key` into the storage and then optional panic.
+		fn write_key_value(key: Vec<u8>, value: Vec<u8>, panic: bool);
+	}
+}
+
+pub type Executive = frame_executive::Executive<
+	Runtime,
+	Block,
+	frame_system::ChainContext<Runtime>,
+	Runtime,
+	AllPalletsWithSystem,
+>;
+
+#[derive(Copy, Clone, PartialEq, Eq, Encode, Decode, RuntimeDebug, TypeInfo)]
+pub struct CheckSubstrateCall;
+
+impl sp_runtime::traits::Printable for CheckSubstrateCall {
+	fn print(&self) {
+		"CheckSubstrateCall".print()
+	}
+}
+
+impl sp_runtime::traits::Dispatchable for CheckSubstrateCall {
+	type RuntimeOrigin = CheckSubstrateCall;
+	type Config = CheckSubstrateCall;
+	type Info = CheckSubstrateCall;
+	type PostInfo = CheckSubstrateCall;
+
+	fn dispatch(
+		self,
+		_origin: Self::RuntimeOrigin,
+	) -> sp_runtime::DispatchResultWithInfo<Self::PostInfo> {
+		panic!("This implementation should not be used for actual dispatch.");
+	}
+}
+
+impl sp_runtime::traits::SignedExtension for CheckSubstrateCall {
+	type AccountId = AccountId;
+	type Call = RuntimeCall;
+	type AdditionalSigned = ();
+	type Pre = ();
+	const IDENTIFIER: &'static str = "CheckSubstrateCall";
+
+	fn additional_signed(
+		&self,
+	) -> sp_std::result::Result<Self::AdditionalSigned, TransactionValidityError> {
+		Ok(())
+	}
+
+	fn validate(
+		&self,
+		_who: &Self::AccountId,
+		call: &Self::Call,
+		_info: &DispatchInfoOf<Self::Call>,
+		_len: usize,
+	) -> TransactionValidity {
+		log::trace!(target: LOG_TARGET, "validate");
+		match call {
+			RuntimeCall::SubstrateTest(ref substrate_test_call) =>
+				substrate_test_pallet::validate_runtime_call(substrate_test_call),
+			_ => Ok(Default::default()),
+		}
+	}
+
+	fn pre_dispatch(
+		self,
+		who: &Self::AccountId,
+		call: &Self::Call,
+		info: &sp_runtime::traits::DispatchInfoOf<Self::Call>,
+		len: usize,
+	) -> Result<Self::Pre, TransactionValidityError> {
+		self.validate(who, call, info, len).map(drop)
+	}
+}
+
+construct_runtime!(
+	pub enum Runtime
+	{
+		System: frame_system,
+		Babe: pallet_babe,
+		SubstrateTest: substrate_test_pallet::pallet,
+		Balances: pallet_balances,
+	}
+);
+
+/// We assume that ~10% of the block weight is consumed by `on_initialize` handlers.
+/// This is used to limit the maximal weight of a single extrinsic.
+const AVERAGE_ON_INITIALIZE_RATIO: Perbill = Perbill::from_percent(10);
+/// We allow `Normal` extrinsics to fill up the block up to 75%, the rest can be used
+/// by  Operational  extrinsics.
+const NORMAL_DISPATCH_RATIO: Perbill = Perbill::from_percent(75);
+/// Max weight, actual value does not matter for test runtime.
+const MAXIMUM_BLOCK_WEIGHT: Weight =
+	Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND.saturating_mul(2), u64::MAX);
+
+parameter_types! {
+	pub const BlockHashCount: BlockNumber = 2400;
+	pub const Version: RuntimeVersion = VERSION;
+
+	pub RuntimeBlockLength: BlockLength =
+		BlockLength::max_with_normal_ratio(5 * 1024 * 1024, NORMAL_DISPATCH_RATIO);
+
+	pub RuntimeBlockWeights: BlockWeights = BlockWeights::builder()
+		.base_block(BlockExecutionWeight::get())
+		.for_class(DispatchClass::all(), |weights| {
+			weights.base_extrinsic = ExtrinsicBaseWeight::get();
+		})
+		.for_class(DispatchClass::Normal, |weights| {
+			weights.max_total = Some(NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT);
+		})
+		.for_class(DispatchClass::Operational, |weights| {
+			weights.max_total = Some(MAXIMUM_BLOCK_WEIGHT);
+			// Operational transactions have some extra reserved space, so that they
+			// are included even if block reached `MAXIMUM_BLOCK_WEIGHT`.
+			weights.reserved = Some(
+				MAXIMUM_BLOCK_WEIGHT - NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT
+			);
+		})
+		.avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO)
+		.build_or_panic();
+}
+
+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 {
+	use crate::Balance;
+	const MILLICENTS: Balance = 1_000_000_000;
+	const CENTS: Balance = 1_000 * MILLICENTS; // assume this is worth about a cent.
+	pub const DOLLARS: Balance = 100 * CENTS;
+}
+
+parameter_types! {
+	pub const ExistentialDeposit: Balance = 1 * currency::DOLLARS;
+	// For weight estimation, we assume that the most locks on an individual account will be 50.
+	// This number may need to be adjusted in the future if this assumption no longer holds true.
+	pub const MaxLocks: u32 = 50;
+	pub const MaxReserves: u32 = 50;
+}
+
+impl pallet_balances::Config for Runtime {
+	type MaxLocks = MaxLocks;
+	type MaxReserves = MaxReserves;
+	type ReserveIdentifier = [u8; 8];
+	type Balance = Balance;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = ExistentialDeposit;
+	type AccountStore = System;
+	type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = RuntimeHoldReason;
+	type MaxHolds = ConstU32<1>;
+}
+
+impl substrate_test_pallet::Config for Runtime {}
+
+// Required for `pallet_babe::Config`.
+impl pallet_timestamp::Config for Runtime {
+	type Moment = u64;
+	type OnTimestampSet = Babe;
+	type MinimumPeriod = ConstU64<500>;
+	type WeightInfo = pallet_timestamp::weights::SubstrateWeight<Runtime>;
+}
+
+parameter_types! {
+	pub const EpochDuration: u64 = 6;
+}
+
+impl pallet_babe::Config for Runtime {
+	type EpochDuration = EpochDuration;
+	type ExpectedBlockTime = ConstU64<10_000>;
+	type EpochChangeTrigger = pallet_babe::SameAuthoritiesForever;
+	type DisabledValidators = ();
+	type KeyOwnerProof = sp_core::Void;
+	type EquivocationReportSystem = ();
+	type WeightInfo = ();
+	type MaxAuthorities = ConstU32<10>;
+	type MaxNominators = ConstU32<100>;
+}
+
+/// Adds one to the given input and returns the final result.
+#[inline(never)]
+fn benchmark_add_one(i: u64) -> u64 {
+	i + 1
+}
+
+fn code_using_trie() -> u64 {
+	let pairs = [
+		(b"0103000000000000000464".to_vec(), b"0400000000".to_vec()),
+		(b"0103000000000000000469".to_vec(), b"0401000000".to_vec()),
+	]
+	.to_vec();
+
+	let mut mdb = PrefixedMemoryDB::default();
+	let mut root = sp_std::default::Default::default();
+	{
+		let mut t = TrieDBMutBuilderV1::<Hashing>::new(&mut mdb, &mut root).build();
+		for (key, value) in &pairs {
+			if t.insert(key, value).is_err() {
+				return 101
+			}
+		}
+	}
+
+	let trie = TrieDBBuilder::<Hashing>::new(&mdb, &root).build();
+	let res = if let Ok(iter) = trie.iter() { iter.flatten().count() as u64 } else { 102 };
+
+	res
+}
+
+impl_opaque_keys! {
+	pub struct SessionKeys {
+		pub ed25519: ed25519::AppPublic,
+		pub sr25519: sr25519::AppPublic,
+		pub ecdsa: ecdsa::AppPublic,
+	}
+}
+
+pub(crate) const TEST_RUNTIME_BABE_EPOCH_CONFIGURATION: BabeEpochConfiguration =
+	BabeEpochConfiguration {
+		c: (3, 10),
+		allowed_slots: AllowedSlots::PrimaryAndSecondaryPlainSlots,
+	};
+
+impl_runtime_apis! {
+	impl sp_api::Core<Block> for Runtime {
+		fn version() -> RuntimeVersion {
+			version()
+		}
+
+		fn execute_block(block: Block) {
+			log::trace!(target: LOG_TARGET, "execute_block: {block:#?}");
+			Executive::execute_block(block);
+		}
+
+		fn initialize_block(header: &<Block as BlockT>::Header) {
+			log::trace!(target: LOG_TARGET, "initialize_block: {header:#?}");
+			Executive::initialize_block(header);
+		}
+	}
+
+	impl sp_api::Metadata<Block> for Runtime {
+		fn metadata() -> OpaqueMetadata {
+			unimplemented!()
+		}
+
+		fn metadata_at_version(_version: u32) -> Option<OpaqueMetadata> {
+			unimplemented!()
+		}
+		fn metadata_versions() -> sp_std::vec::Vec<u32> {
+			unimplemented!()
+		}
+	}
+
+	impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<Block> for Runtime {
+		fn validate_transaction(
+			source: TransactionSource,
+			utx: <Block as BlockT>::Extrinsic,
+			block_hash: <Block as BlockT>::Hash,
+		) -> TransactionValidity {
+			let validity = Executive::validate_transaction(source, utx.clone(), block_hash);
+			log::trace!(target: LOG_TARGET, "validate_transaction {:?} {:?}", utx, validity);
+			validity
+		}
+	}
+
+	impl sp_block_builder::BlockBuilder<Block> for Runtime {
+		fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
+			Executive::apply_extrinsic(extrinsic)
+		}
+
+		fn finalize_block() -> <Block as BlockT>::Header {
+			log::trace!(target: LOG_TARGET, "finalize_block");
+			Executive::finalize_block()
+		}
+
+		fn inherent_extrinsics(_data: InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
+			vec![]
+		}
+
+		fn check_inherents(_block: Block, _data: InherentData) -> CheckInherentsResult {
+			CheckInherentsResult::new()
+		}
+	}
+
+	impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Nonce> for Runtime {
+		fn account_nonce(account: AccountId) -> Nonce {
+			System::account_nonce(account)
+		}
+	}
+
+	impl self::TestAPI<Block> for Runtime {
+		fn balance_of(id: AccountId) -> u64 {
+			Balances::free_balance(id)
+		}
+
+		fn benchmark_add_one(val: &u64) -> u64 {
+			val + 1
+		}
+
+		fn benchmark_vector_add_one(vec: &Vec<u64>) -> Vec<u64> {
+			let mut vec = vec.clone();
+			vec.iter_mut().for_each(|v| *v += 1);
+			vec
+		}
+
+		fn function_signature_changed() -> u64 {
+			1
+		}
+
+		fn use_trie() -> u64 {
+			code_using_trie()
+		}
+
+		fn benchmark_indirect_call() -> u64 {
+			let function = benchmark_add_one;
+			(0..1000).fold(0, |p, i| p + function(i))
+		}
+		fn benchmark_direct_call() -> u64 {
+			(0..1000).fold(0, |p, i| p + benchmark_add_one(i))
+		}
+
+		fn vec_with_capacity(size: u32) -> Vec<u8> {
+			Vec::with_capacity(size as usize)
+		}
+
+		fn get_block_number() -> u64 {
+			System::block_number()
+		}
+
+		fn test_ed25519_crypto() -> (ed25519::AppSignature, ed25519::AppPublic) {
+			test_ed25519_crypto()
+		}
+
+		fn test_sr25519_crypto() -> (sr25519::AppSignature, sr25519::AppPublic) {
+			test_sr25519_crypto()
+		}
+
+		fn test_ecdsa_crypto() -> (ecdsa::AppSignature, ecdsa::AppPublic) {
+			test_ecdsa_crypto()
+		}
+
+		fn test_storage() {
+			test_read_storage();
+			test_read_child_storage();
+		}
+
+		fn test_witness(proof: StorageProof, root: crate::Hash) {
+			test_witness(proof, root);
+		}
+
+		fn test_multiple_arguments(data: Vec<u8>, other: Vec<u8>, num: u32) {
+			assert_eq!(&data[..], &other[..]);
+			assert_eq!(data.len(), num as usize);
+		}
+
+		fn do_trace_log() {
+			log::trace!("Hey I'm runtime");
+		}
+
+		fn verify_ed25519(sig: ed25519::Signature, public: ed25519::Public, message: Vec<u8>) -> bool {
+			sp_io::crypto::ed25519_verify(&sig, &message, &public)
+		}
+
+		fn write_key_value(key: Vec<u8>, value: Vec<u8>, panic: bool) {
+			sp_io::storage::set(&key, &value);
+
+			if panic {
+				panic!("I'm just following my master");
+			}
+		}
+	}
+
+	impl sp_consensus_aura::AuraApi<Block, AuraId> for Runtime {
+		fn slot_duration() -> sp_consensus_aura::SlotDuration {
+			sp_consensus_aura::SlotDuration::from_millis(1000)
+		}
+
+		fn authorities() -> Vec<AuraId> {
+			SubstrateTest::authorities().into_iter().map(|auth| AuraId::from(auth)).collect()
+		}
+	}
+
+	impl sp_consensus_babe::BabeApi<Block> for Runtime {
+		fn configuration() -> sp_consensus_babe::BabeConfiguration {
+			let epoch_config = Babe::epoch_config().unwrap_or(TEST_RUNTIME_BABE_EPOCH_CONFIGURATION);
+			sp_consensus_babe::BabeConfiguration {
+				slot_duration: Babe::slot_duration(),
+				epoch_length: EpochDuration::get(),
+				c: epoch_config.c,
+				authorities: Babe::authorities().to_vec(),
+				randomness: Babe::randomness(),
+				allowed_slots: epoch_config.allowed_slots,
+			}
+		}
+
+		fn current_epoch_start() -> Slot {
+			Babe::current_epoch_start()
+		}
+
+		fn current_epoch() -> sp_consensus_babe::Epoch {
+			Babe::current_epoch()
+		}
+
+		fn next_epoch() -> sp_consensus_babe::Epoch {
+			Babe::next_epoch()
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			_equivocation_proof: sp_consensus_babe::EquivocationProof<
+			<Block as BlockT>::Header,
+			>,
+			_key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			None
+		}
+
+		fn generate_key_ownership_proof(
+			_slot: sp_consensus_babe::Slot,
+			_authority_id: sp_consensus_babe::AuthorityId,
+		) -> Option<sp_consensus_babe::OpaqueKeyOwnershipProof> {
+			None
+		}
+	}
+
+	impl sp_offchain::OffchainWorkerApi<Block> for Runtime {
+		fn offchain_worker(header: &<Block as BlockT>::Header) {
+			let ext = Extrinsic::new_unsigned(
+				substrate_test_pallet::pallet::Call::storage_change{
+					key:b"some_key".encode(),
+					value:Some(header.number.encode())
+				}.into(),
+			);
+			sp_io::offchain::submit_transaction(ext.encode()).unwrap();
+		}
+	}
+
+	impl sp_session::SessionKeys<Block> for Runtime {
+		fn generate_session_keys(_: Option<Vec<u8>>) -> Vec<u8> {
+			SessionKeys::generate(None)
+		}
+
+		fn decode_session_keys(
+			encoded: Vec<u8>,
+		) -> Option<Vec<(Vec<u8>, sp_core::crypto::KeyTypeId)>> {
+			SessionKeys::decode_into_raw_public_keys(&encoded)
+		}
+	}
+
+	impl sp_consensus_grandpa::GrandpaApi<Block> for Runtime {
+		fn grandpa_authorities() -> sp_consensus_grandpa::AuthorityList {
+			Vec::new()
+		}
+
+		fn current_set_id() -> sp_consensus_grandpa::SetId {
+			0
+		}
+
+		fn submit_report_equivocation_unsigned_extrinsic(
+			_equivocation_proof: sp_consensus_grandpa::EquivocationProof<
+			<Block as BlockT>::Hash,
+			NumberFor<Block>,
+			>,
+			_key_owner_proof: sp_consensus_grandpa::OpaqueKeyOwnershipProof,
+		) -> Option<()> {
+			None
+		}
+
+		fn generate_key_ownership_proof(
+			_set_id: sp_consensus_grandpa::SetId,
+			_authority_id: sp_consensus_grandpa::AuthorityId,
+		) -> Option<sp_consensus_grandpa::OpaqueKeyOwnershipProof> {
+			None
+		}
+	}
+
+	#[cfg(not(feature = "disable-genesis-builder"))]
+	impl sp_genesis_builder::GenesisBuilder<Block> for Runtime {
+		fn create_default_config() -> Vec<u8> {
+			create_default_config::<RuntimeGenesisConfig>()
+		}
+
+		fn build_config(config: Vec<u8>) -> sp_genesis_builder::Result {
+			build_config::<RuntimeGenesisConfig>(config)
+		}
+	}
+}
+
+fn test_ed25519_crypto() -> (ed25519::AppSignature, ed25519::AppPublic) {
+	let public0 = ed25519::AppPublic::generate_pair(None);
+	let public1 = ed25519::AppPublic::generate_pair(None);
+	let public2 = ed25519::AppPublic::generate_pair(None);
+
+	let all = ed25519::AppPublic::all();
+	assert!(all.contains(&public0));
+	assert!(all.contains(&public1));
+	assert!(all.contains(&public2));
+
+	let signature = public0.sign(&"ed25519").expect("Generates a valid `ed25519` signature.");
+	assert!(public0.verify(&"ed25519", &signature));
+	(signature, public0)
+}
+
+fn test_sr25519_crypto() -> (sr25519::AppSignature, sr25519::AppPublic) {
+	let public0 = sr25519::AppPublic::generate_pair(None);
+	let public1 = sr25519::AppPublic::generate_pair(None);
+	let public2 = sr25519::AppPublic::generate_pair(None);
+
+	let all = sr25519::AppPublic::all();
+	assert!(all.contains(&public0));
+	assert!(all.contains(&public1));
+	assert!(all.contains(&public2));
+
+	let signature = public0.sign(&"sr25519").expect("Generates a valid `sr25519` signature.");
+	assert!(public0.verify(&"sr25519", &signature));
+	(signature, public0)
+}
+
+fn test_ecdsa_crypto() -> (ecdsa::AppSignature, ecdsa::AppPublic) {
+	let public0 = ecdsa::AppPublic::generate_pair(None);
+	let public1 = ecdsa::AppPublic::generate_pair(None);
+	let public2 = ecdsa::AppPublic::generate_pair(None);
+
+	let all = ecdsa::AppPublic::all();
+	assert!(all.contains(&public0));
+	assert!(all.contains(&public1));
+	assert!(all.contains(&public2));
+
+	let signature = public0.sign(&"ecdsa").expect("Generates a valid `ecdsa` signature.");
+
+	assert!(public0.verify(&"ecdsa", &signature));
+	(signature, public0)
+}
+
+fn test_read_storage() {
+	const KEY: &[u8] = b":read_storage";
+	sp_io::storage::set(KEY, b"test");
+
+	let mut v = [0u8; 4];
+	let r = sp_io::storage::read(KEY, &mut v, 0);
+	assert_eq!(r, Some(4));
+	assert_eq!(&v, b"test");
+
+	let mut v = [0u8; 4];
+	let r = sp_io::storage::read(KEY, &mut v, 4);
+	assert_eq!(r, Some(0));
+	assert_eq!(&v, &[0, 0, 0, 0]);
+}
+
+fn test_read_child_storage() {
+	const STORAGE_KEY: &[u8] = b"unique_id_1";
+	const KEY: &[u8] = b":read_child_storage";
+	sp_io::default_child_storage::set(STORAGE_KEY, KEY, b"test");
+
+	let mut v = [0u8; 4];
+	let r = sp_io::default_child_storage::read(STORAGE_KEY, KEY, &mut v, 0);
+	assert_eq!(r, Some(4));
+	assert_eq!(&v, b"test");
+
+	let mut v = [0u8; 4];
+	let r = sp_io::default_child_storage::read(STORAGE_KEY, KEY, &mut v, 8);
+	assert_eq!(r, Some(0));
+	assert_eq!(&v, &[0, 0, 0, 0]);
+}
+
+fn test_witness(proof: StorageProof, root: crate::Hash) {
+	use sp_externalities::Externalities;
+	let db: sp_trie::MemoryDB<crate::Hashing> = proof.into_memory_db();
+	let backend = sp_state_machine::TrieBackendBuilder::<_, crate::Hashing>::new(db, root).build();
+	let mut overlay = sp_state_machine::OverlayedChanges::default();
+	let mut ext = sp_state_machine::Ext::new(
+		&mut overlay,
+		&backend,
+		#[cfg(feature = "std")]
+		None,
+	);
+	assert!(ext.storage(b"value3").is_some());
+	assert!(ext.storage_root(Default::default()).as_slice() == &root[..]);
+	ext.place_storage(vec![0], Some(vec![1]));
+	assert!(ext.storage_root(Default::default()).as_slice() != &root[..]);
+}
+
+/// Some tests require the hashed keys of the storage. As the values of hashed keys are not trivial
+/// to guess, this small module provides the values of the keys, and the code which is required to
+/// generate the keys.
+#[cfg(feature = "std")]
+pub mod storage_key_generator {
+	use super::*;
+	use sp_core::Pair;
+	use sp_keyring::AccountKeyring;
+
+	/// Generate hex string without prefix
+	pub(super) fn hex<T>(x: T) -> String
+	where
+		T: array_bytes::Hex,
+	{
+		x.hex(Default::default())
+	}
+
+	fn concat_hashes(input: &Vec<&[u8]>) -> String {
+		input.iter().map(|s| sp_core::hashing::twox_128(s)).map(hex).collect()
+	}
+
+	fn twox_64_concat(x: &[u8]) -> Vec<u8> {
+		sp_core::hashing::twox_64(x).iter().chain(x.iter()).cloned().collect::<Vec<_>>()
+	}
+
+	/// Generate the hashed storage keys from the raw literals. These keys are expected to be be in
+	/// storage with given substrate-test runtime.
+	pub fn generate_expected_storage_hashed_keys(custom_heap_pages: bool) -> Vec<String> {
+		let mut literals: Vec<&[u8]> = vec![b":code", b":extrinsic_index"];
+
+		if custom_heap_pages {
+			literals.push(b":heappages");
+		}
+
+		let keys: Vec<Vec<&[u8]>> = vec![
+			vec![b"Babe", b":__STORAGE_VERSION__:"],
+			vec![b"Babe", b"Authorities"],
+			vec![b"Babe", b"EpochConfig"],
+			vec![b"Babe", b"NextAuthorities"],
+			vec![b"Babe", b"SegmentIndex"],
+			vec![b"Balances", b":__STORAGE_VERSION__:"],
+			vec![b"Balances", b"TotalIssuance"],
+			vec![b"SubstrateTest", b":__STORAGE_VERSION__:"],
+			vec![b"SubstrateTest", b"Authorities"],
+			vec![b"System", b":__STORAGE_VERSION__:"],
+			vec![b"System", b"LastRuntimeUpgrade"],
+			vec![b"System", b"ParentHash"],
+			vec![b"System", b"UpgradedToTripleRefCount"],
+			vec![b"System", b"UpgradedToU32RefCount"],
+		];
+
+		let mut expected_keys = keys.iter().map(concat_hashes).collect::<Vec<String>>();
+		expected_keys.extend(literals.into_iter().map(hex));
+
+		let balances_map_keys = (0..16_usize)
+			.into_iter()
+			.map(|i| AccountKeyring::numeric(i).public().to_vec())
+			.chain(vec![
+				AccountKeyring::Alice.public().to_vec(),
+				AccountKeyring::Bob.public().to_vec(),
+				AccountKeyring::Charlie.public().to_vec(),
+			])
+			.map(|pubkey| {
+				sp_core::hashing::blake2_128(&pubkey)
+					.iter()
+					.chain(pubkey.iter())
+					.cloned()
+					.collect::<Vec<u8>>()
+			})
+			.map(|hash_pubkey| {
+				[concat_hashes(&vec![b"System", b"Account"]), hex(hash_pubkey)].concat()
+			});
+
+		expected_keys.extend(balances_map_keys);
+
+		expected_keys.push(
+			[
+				concat_hashes(&vec![b"System", b"BlockHash"]),
+				hex(0u64.using_encoded(twox_64_concat)),
+			]
+			.concat(),
+		);
+
+		expected_keys.sort();
+		expected_keys
+	}
+
+	/// Provides the commented list of hashed keys. This contains a hard-coded list of hashed keys
+	/// that would be generated by `generate_expected_storage_hashed_keys`. This list is provided
+	/// for the debugging convenience only. Value of each hex-string is documented with the literal
+	/// origin.
+	///
+	/// `custom_heap_pages`: Should be set to `true` when the state contains the `:heap_pages` key
+	/// aka when overriding the heap pages to be used by the executor.
+	pub fn get_expected_storage_hashed_keys(custom_heap_pages: bool) -> Vec<&'static str> {
+		let mut res = vec![
+			//SubstrateTest|:__STORAGE_VERSION__:
+			"00771836bebdd29870ff246d305c578c4e7b9012096b41c4eb3aaf947f6ea429",
+			//SubstrateTest|Authorities
+			"00771836bebdd29870ff246d305c578c5e0621c4869aa60c02be9adcc98a0d1d",
+			//Babe|:__STORAGE_VERSION__:
+			"1cb6f36e027abb2091cfb5110ab5087f4e7b9012096b41c4eb3aaf947f6ea429",
+			//Babe|Authorities
+			"1cb6f36e027abb2091cfb5110ab5087f5e0621c4869aa60c02be9adcc98a0d1d",
+			//Babe|SegmentIndex
+			"1cb6f36e027abb2091cfb5110ab5087f66e8f035c8adbe7f1547b43c51e6f8a4",
+			//Babe|NextAuthorities
+			"1cb6f36e027abb2091cfb5110ab5087faacf00b9b41fda7a9268821c2a2b3e4c",
+			//Babe|EpochConfig
+			"1cb6f36e027abb2091cfb5110ab5087fdc6b171b77304263c292cc3ea5ed31ef",
+			//System|:__STORAGE_VERSION__:
+			"26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429",
+			//System|UpgradedToU32RefCount
+			"26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710",
+			//System|ParentHash
+			"26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc",
+			//System::BlockHash|0
+			"26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746bb1bdbcacd6ac9340000000000000000",
+			//System|UpgradedToTripleRefCount
+			"26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439",
+
+			// System|Account|blake2_128Concat("//11")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da901cae4e3edfbb32c91ed3f01ab964f4eeeab50338d8e5176d3141802d7b010a55dadcd5f23cf8aaafa724627e967e90e",
+			// System|Account|blake2_128Concat("//4")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da91b614bd4a126f2d5d294e9a8af9da25248d7e931307afb4b68d8d565d4c66e00d856c6d65f5fed6bb82dcfb60e936c67",
+			// System|Account|blake2_128Concat("//7")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da94b21aff9fe1e8b2fc4b0775b8cbeff28ba8e2c7594dd74730f3ca835e95455d199261897edc9735d602ea29615e2b10b",
+			// System|Account|blake2_128Concat("//Bob")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da94f9aea1afa791265fae359272badc1cf8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+			// System|Account|blake2_128Concat("//3")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95786a2916fcb81e1bd5dcd81e0d2452884617f575372edb5a36d85c04cdf2e4699f96fe33eb5f94a28c041b88e398d0c",
+			// System|Account|blake2_128Concat("//14")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95b8542d9672c7b7e779cc7c1e6b605691c2115d06120ea2bee32dd601d02f36367564e7ddf84ae2717ca3f097459652e",
+			// System|Account|blake2_128Concat("//6")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da996c30bdbfab640838e6b6d3c33ab4adb4211b79e34ee8072eab506edd4b93a7b85a14c9a05e5cdd056d98e7dbca87730",
+			// System|Account|blake2_128Concat("//9")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da99dc65b1339ec388fbf2ca0cdef51253512c6cfd663203ea16968594f24690338befd906856c4d2f4ef32dad578dba20c",
+			// System|Account|blake2_128Concat("//8")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da99e6eb5abd62f5fd54793da91a47e6af6125d57171ff9241f07acaa1bb6a6103517965cf2cd00e643b27e7599ebccba70",
+			// System|Account|blake2_128Concat("//Charlie")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b0edae20838083f2cde1c4080db8cf8090b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22",
+			// System|Account|blake2_128Concat("//10")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9d0052993b6f3bd0544fd1f5e4125b9fbde3e789ecd53431fe5c06c12b72137153496dace35c695b5f4d7b41f7ed5763b",
+			// System|Account|blake2_128Concat("//1")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9d6b7e9a5f12bc571053265dade10d3b4b606fc73f57f03cdb4c932d475ab426043e429cecc2ffff0d2672b0df8398c48",
+			// System|Account|blake2_128Concat("//Alice")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+			// System|Account|blake2_128Concat("//2")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9e1a35f56ee295d39287cbffcfc60c4b346f136b564e1fad55031404dd84e5cd3fa76bfe7cc7599b39d38fd06663bbc0a",
+			// System|Account|blake2_128Concat("//5")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9e2c1dc507e2035edbbd8776c440d870460c57f0008067cc01c5ff9eb2e2f9b3a94299a915a91198bd1021a6c55596f57",
+			// System|Account|blake2_128Concat("//0")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9eca0e653a94f4080f6311b4e7b6934eb2afba9278e30ccf6a6ceb3a8b6e336b70068f045c666f2e7f4f9cc5f47db8972",
+			// System|Account|blake2_128Concat("//13")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9ee8bf7ef90fc56a8aa3b90b344c599550c29b161e27ff8ba45bf6bad4711f326fc506a8803453a4d7e3158e993495f10",
+			// System|Account|blake2_128Concat("//12")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9f5d6f1c082fe63eec7a71fcad00f4a892e3d43b7b0d04e776e69e7be35247cecdac65504c579195731eaf64b7940966e",
+			// System|Account|blake2_128Concat("//15")
+			"26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9fbf0818841edf110e05228a6379763c4fc3c37459d9bdc61f58a5ebc01e9e2305a19d390c0543dc733861ec3cf1de01f",
+			// System|LastRuntimeUpgrade
+			"26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8",
+			// :code
+			"3a636f6465",
+			// :extrinsic_index
+			"3a65787472696e7369635f696e646578",
+			// Balances|:__STORAGE_VERSION__:
+			"c2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429",
+			// Balances|TotalIssuance
+			"c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80",
+		];
+
+		if custom_heap_pages {
+			// :heappages
+			res.push("3a686561707061676573");
+		}
+
+		res
+	}
+
+	#[test]
+	fn expected_keys_vec_are_matching() {
+		assert_eq!(
+			storage_key_generator::get_expected_storage_hashed_keys(false),
+			storage_key_generator::generate_expected_storage_hashed_keys(false),
+		);
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use codec::Encode;
+	use frame_support::dispatch::DispatchInfo;
+	use sc_block_builder::BlockBuilderProvider;
+	use sp_api::{ApiExt, ProvideRuntimeApi};
+	use sp_consensus::BlockOrigin;
+	use sp_core::{storage::well_known_keys::HEAP_PAGES, traits::CallContext};
+	use sp_keyring::AccountKeyring;
+	use sp_runtime::{
+		traits::{Hash as _, SignedExtension},
+		transaction_validity::{InvalidTransaction, ValidTransaction},
+	};
+	use substrate_test_runtime_client::{
+		prelude::*, runtime::TestAPI, DefaultTestClientBuilderExt, TestClientBuilder,
+	};
+
+	#[test]
+	fn heap_pages_is_respected() {
+		// This tests that the on-chain `HEAP_PAGES` parameter is respected.
+
+		// Create a client devoting only 8 pages of wasm memory. This gives us ~512k of heap memory.
+		let mut client = TestClientBuilder::new().set_heap_pages(8).build();
+		let best_hash = client.chain_info().best_hash;
+
+		// Try to allocate 1024k of memory on heap. This is going to fail since it is twice larger
+		// than the heap.
+		let mut runtime_api = client.runtime_api();
+		// This is currently required to allocate the 1024k of memory as configured above.
+		runtime_api.set_call_context(CallContext::Onchain);
+		let ret = runtime_api.vec_with_capacity(best_hash, 1048576);
+		assert!(ret.is_err());
+
+		// Create a block that sets the `:heap_pages` to 32 pages of memory which corresponds to
+		// ~2048k of heap memory.
+		let (new_at_hash, block) = {
+			let mut builder = client.new_block(Default::default()).unwrap();
+			builder.push_storage_change(HEAP_PAGES.to_vec(), Some(32u64.encode())).unwrap();
+			let block = builder.build().unwrap().block;
+			let hash = block.header.hash();
+			(hash, block)
+		};
+
+		futures::executor::block_on(client.import(BlockOrigin::Own, block)).unwrap();
+
+		// Allocation of 1024k while having ~2048k should succeed.
+		let ret = client.runtime_api().vec_with_capacity(new_at_hash, 1048576);
+		assert!(ret.is_ok());
+	}
+
+	#[test]
+	fn test_storage() {
+		let client = TestClientBuilder::new().build();
+		let runtime_api = client.runtime_api();
+		let best_hash = client.chain_info().best_hash;
+
+		runtime_api.test_storage(best_hash).unwrap();
+	}
+
+	fn witness_backend() -> (sp_trie::MemoryDB<crate::Hashing>, crate::Hash) {
+		let mut root = crate::Hash::default();
+		let mut mdb = sp_trie::MemoryDB::<crate::Hashing>::default();
+		{
+			let mut trie =
+				sp_trie::trie_types::TrieDBMutBuilderV1::new(&mut mdb, &mut root).build();
+			trie.insert(b"value3", &[142]).expect("insert failed");
+			trie.insert(b"value4", &[124]).expect("insert failed");
+		};
+		(mdb, root)
+	}
+
+	#[test]
+	fn witness_backend_works() {
+		let (db, root) = witness_backend();
+		let backend =
+			sp_state_machine::TrieBackendBuilder::<_, crate::Hashing>::new(db, root).build();
+		let proof = sp_state_machine::prove_read(backend, vec![b"value3"]).unwrap();
+		let client = TestClientBuilder::new().build();
+		let runtime_api = client.runtime_api();
+		let best_hash = client.chain_info().best_hash;
+
+		runtime_api.test_witness(best_hash, proof, root).unwrap();
+	}
+
+	pub fn new_test_ext() -> sp_io::TestExternalities {
+		genesismap::GenesisStorageBuilder::new(
+			vec![AccountKeyring::One.public().into(), AccountKeyring::Two.public().into()],
+			vec![AccountKeyring::One.into(), AccountKeyring::Two.into()],
+			1000 * currency::DOLLARS,
+		)
+		.build()
+		.into()
+	}
+
+	#[test]
+	fn validate_storage_keys() {
+		assert_eq!(
+			genesismap::GenesisStorageBuilder::default()
+				.build()
+				.top
+				.keys()
+				.cloned()
+				.map(storage_key_generator::hex)
+				.collect::<Vec<_>>(),
+			storage_key_generator::get_expected_storage_hashed_keys(false)
+		);
+	}
+
+	#[test]
+	fn validate_unsigned_works() {
+		sp_tracing::try_init_simple();
+		new_test_ext().execute_with(|| {
+			let failing_calls = vec![
+				substrate_test_pallet::Call::bench_call { transfer: Default::default() },
+				substrate_test_pallet::Call::include_data { data: vec![] },
+				substrate_test_pallet::Call::fill_block { ratio: Perbill::from_percent(50) },
+			];
+			let succeeding_calls = vec![
+				substrate_test_pallet::Call::deposit_log_digest_item {
+					log: DigestItem::Other(vec![]),
+				},
+				substrate_test_pallet::Call::storage_change { key: vec![], value: None },
+				substrate_test_pallet::Call::read { count: 0 },
+				substrate_test_pallet::Call::read_and_panic { count: 0 },
+			];
+
+			for call in failing_calls {
+				assert_eq!(
+					<SubstrateTest as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+						TransactionSource::External,
+						&call,
+					),
+					InvalidTransaction::Call.into(),
+				);
+			}
+
+			for call in succeeding_calls {
+				assert_eq!(
+					<SubstrateTest as sp_runtime::traits::ValidateUnsigned>::validate_unsigned(
+						TransactionSource::External,
+						&call,
+					),
+					Ok(ValidTransaction {
+						provides: vec![BlakeTwo256::hash_of(&call).encode()],
+						..Default::default()
+					})
+				);
+			}
+		});
+	}
+
+	#[test]
+	fn check_substrate_check_signed_extension_works() {
+		sp_tracing::try_init_simple();
+		new_test_ext().execute_with(|| {
+			let x = sp_keyring::AccountKeyring::Alice.into();
+			let info = DispatchInfo::default();
+			let len = 0_usize;
+			assert_eq!(
+				CheckSubstrateCall {}
+					.validate(
+						&x,
+						&ExtrinsicBuilder::new_call_with_priority(16).build().function,
+						&info,
+						len
+					)
+					.unwrap()
+					.priority,
+				16
+			);
+
+			assert_eq!(
+				CheckSubstrateCall {}
+					.validate(
+						&x,
+						&ExtrinsicBuilder::new_call_do_not_propagate().build().function,
+						&info,
+						len
+					)
+					.unwrap()
+					.propagate,
+				false
+			);
+		})
+	}
+
+	#[cfg(not(feature = "disable-genesis-builder"))]
+	mod genesis_builder_tests {
+		use super::*;
+		use crate::genesismap::GenesisStorageBuilder;
+		use sc_executor::{error::Result, WasmExecutor};
+		use sc_executor_common::runtime_blob::RuntimeBlob;
+		use serde_json::json;
+		use sp_application_crypto::Ss58Codec;
+		use sp_core::traits::Externalities;
+		use sp_genesis_builder::Result as BuildResult;
+		use sp_state_machine::BasicExternalities;
+		use std::{fs, io::Write};
+		use storage_key_generator::hex;
+
+		pub fn executor_call(
+			ext: &mut dyn Externalities,
+			method: &str,
+			data: &[u8],
+		) -> Result<Vec<u8>> {
+			let executor = WasmExecutor::<sp_io::SubstrateHostFunctions>::builder().build();
+			executor.uncached_call(
+				RuntimeBlob::uncompress_if_needed(wasm_binary_unwrap()).unwrap(),
+				ext,
+				true,
+				method,
+				data,
+			)
+		}
+
+		#[test]
+		fn build_minimal_genesis_config_works() {
+			sp_tracing::try_init_simple();
+			let default_minimal_json = r#"{"system":{"code":"0x"},"babe":{"authorities":[],"epochConfig":{"c": [ 3, 10 ],"allowed_slots":"PrimaryAndSecondaryPlainSlots"}},"substrateTest":{"authorities":[]},"balances":{"balances":[]}}"#;
+			let mut t = BasicExternalities::new_empty();
+
+			executor_call(&mut t, "GenesisBuilder_build_config", &default_minimal_json.encode())
+				.unwrap();
+
+			let mut keys = t.into_storages().top.keys().cloned().map(hex).collect::<Vec<String>>();
+			keys.sort();
+
+			let mut expected = [
+				//SubstrateTest|Authorities
+				"00771836bebdd29870ff246d305c578c5e0621c4869aa60c02be9adcc98a0d1d",
+				//Babe|SegmentIndex
+				"1cb6f36e027abb2091cfb5110ab5087f66e8f035c8adbe7f1547b43c51e6f8a4",
+				//Babe|EpochConfig
+				"1cb6f36e027abb2091cfb5110ab5087fdc6b171b77304263c292cc3ea5ed31ef",
+				//System|UpgradedToU32RefCount
+				"26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710",
+				//System|ParentHash
+				"26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc",
+				//System::BlockHash|0
+				"26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746bb1bdbcacd6ac9340000000000000000",
+				//System|UpgradedToTripleRefCount
+				"26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439",
+
+				// System|LastRuntimeUpgrade
+				"26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8",
+				// :code
+				"3a636f6465",
+				// :extrinsic_index
+				"3a65787472696e7369635f696e646578",
+				// Balances|TotalIssuance
+				"c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80",
+
+				// added by on_genesis:
+				// Balances|:__STORAGE_VERSION__:
+				"c2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429",
+				//System|:__STORAGE_VERSION__:
+				"26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429",
+				//Babe|:__STORAGE_VERSION__:
+				"1cb6f36e027abb2091cfb5110ab5087f4e7b9012096b41c4eb3aaf947f6ea429",
+				//SubstrateTest|:__STORAGE_VERSION__:
+				"00771836bebdd29870ff246d305c578c4e7b9012096b41c4eb3aaf947f6ea429",
+				].into_iter().map(String::from).collect::<Vec<_>>();
+			expected.sort();
+
+			assert_eq!(keys, expected);
+		}
+
+		#[test]
+		fn default_config_as_json_works() {
+			sp_tracing::try_init_simple();
+			let mut t = BasicExternalities::new_empty();
+			let r = executor_call(&mut t, "GenesisBuilder_create_default_config", &vec![]).unwrap();
+			let r = Vec::<u8>::decode(&mut &r[..]).unwrap();
+			let json = String::from_utf8(r.into()).expect("returned value is json. qed.");
+
+			let expected = r#"{"system":{"code":"0x"},"babe":{"authorities":[],"epochConfig":null},"substrateTest":{"authorities":[]},"balances":{"balances":[]}}"#;
+			assert_eq!(expected.to_string(), json);
+		}
+
+		#[test]
+		fn build_config_from_json_works() {
+			sp_tracing::try_init_simple();
+			let j = include_str!("test_json/default_genesis_config.json");
+
+			let mut t = BasicExternalities::new_empty();
+			let r = executor_call(&mut t, "GenesisBuilder_build_config", &j.encode()).unwrap();
+			let r = BuildResult::decode(&mut &r[..]);
+			assert!(r.is_ok());
+
+			let keys = t.into_storages().top.keys().cloned().map(hex).collect::<Vec<String>>();
+			assert_eq!(keys, storage_key_generator::get_expected_storage_hashed_keys(false));
+		}
+
+		#[test]
+		fn build_config_from_invalid_json_fails() {
+			sp_tracing::try_init_simple();
+			let j = include_str!("test_json/default_genesis_config_invalid.json");
+			let mut t = BasicExternalities::new_empty();
+			let r = executor_call(&mut t, "GenesisBuilder_build_config", &j.encode()).unwrap();
+			let r = BuildResult::decode(&mut &r[..]).unwrap();
+			log::info!("result: {:#?}", r);
+			assert_eq!(r, Err(
+				sp_runtime::RuntimeString::Owned(
+					"Invalid JSON blob: unknown field `renamed_authorities`, expected `authorities` or `epochConfig` at line 6 column 25".to_string(),
+				))
+			);
+		}
+
+		#[test]
+		fn build_config_from_incomplete_json_fails() {
+			sp_tracing::try_init_simple();
+			let j = include_str!("test_json/default_genesis_config_incomplete.json");
+
+			let mut t = BasicExternalities::new_empty();
+			let r = executor_call(&mut t, "GenesisBuilder_build_config", &j.encode()).unwrap();
+			let r =
+				core::result::Result::<(), sp_runtime::RuntimeString>::decode(&mut &r[..]).unwrap();
+			assert_eq!(
+				r,
+				Err(sp_runtime::RuntimeString::Owned(
+					"Invalid JSON blob: missing field `authorities` at line 13 column 3"
+						.to_string()
+				))
+			);
+		}
+
+		#[test]
+		fn write_default_config_to_tmp_file() {
+			if std::env::var("WRITE_DEFAULT_JSON_FOR_STR_GC").is_ok() {
+				sp_tracing::try_init_simple();
+				let mut file = fs::OpenOptions::new()
+					.create(true)
+					.write(true)
+					.open("/tmp/default_genesis_config.json")
+					.unwrap();
+
+				let j = serde_json::to_string(&GenesisStorageBuilder::default().genesis_config())
+					.unwrap()
+					.into_bytes();
+				file.write_all(&j).unwrap();
+			}
+		}
+
+		#[test]
+		fn build_genesis_config_with_patch_json_works() {
+			//this tests shows how to do patching on native side
+			sp_tracing::try_init_simple();
+
+			let mut t = BasicExternalities::new_empty();
+			let r = executor_call(&mut t, "GenesisBuilder_create_default_config", &vec![]).unwrap();
+			let r = Vec::<u8>::decode(&mut &r[..]).unwrap();
+			let mut default_config: serde_json::Value =
+				serde_json::from_slice(&r[..]).expect("returned value is json. qed.");
+
+			// Patch default json with some custom values:
+			let patch = json!({
+				"babe": {
+					"epochConfig": {
+						"c": [
+							7,
+							10
+						],
+						"allowed_slots": "PrimaryAndSecondaryPlainSlots"
+					}
+				},
+				"substrateTest": {
+					"authorities": [
+						AccountKeyring::Ferdie.public().to_ss58check(),
+						AccountKeyring::Alice.public().to_ss58check()
+					],
+				}
+			});
+
+			json_patch::merge(&mut default_config, &patch);
+
+			// Build genesis config using custom json:
+			let mut t = BasicExternalities::new_empty();
+			executor_call(
+				&mut t,
+				"GenesisBuilder_build_config",
+				&default_config.to_string().encode(),
+			)
+			.unwrap();
+
+			// Ensure that custom values are in the genesis storage:
+			let storage = t.into_storages();
+			let get_from_storage = |key: &str| -> Vec<u8> {
+				storage.top.get(&array_bytes::hex2bytes(key).unwrap()).unwrap().clone()
+			};
+
+			//SubstrateTest|Authorities
+			let value: Vec<u8> = get_from_storage(
+				"00771836bebdd29870ff246d305c578c5e0621c4869aa60c02be9adcc98a0d1d",
+			);
+			let authority_key_vec =
+				Vec::<sp_core::sr25519::Public>::decode(&mut &value[..]).unwrap();
+			assert_eq!(authority_key_vec.len(), 2);
+			assert_eq!(authority_key_vec[0], sp_keyring::AccountKeyring::Ferdie.public());
+			assert_eq!(authority_key_vec[1], sp_keyring::AccountKeyring::Alice.public());
+
+			//Babe|Authorities
+			let value: Vec<u8> = get_from_storage(
+				"1cb6f36e027abb2091cfb5110ab5087fdc6b171b77304263c292cc3ea5ed31ef",
+			);
+			assert_eq!(
+				BabeEpochConfiguration::decode(&mut &value[..]).unwrap(),
+				BabeEpochConfiguration {
+					c: (7, 10),
+					allowed_slots: AllowedSlots::PrimaryAndSecondaryPlainSlots
+				}
+			);
+
+			// Ensure that some values are default ones:
+			// Balances|TotalIssuance
+			let value: Vec<u8> = get_from_storage(
+				"c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80",
+			);
+			assert_eq!(u64::decode(&mut &value[..]).unwrap(), 0);
+
+			// :code
+			let value: Vec<u8> = get_from_storage("3a636f6465");
+			assert!(Vec::<u8>::decode(&mut &value[..]).is_err());
+
+			//System|ParentHash
+			let value: Vec<u8> = get_from_storage(
+				"26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc",
+			);
+			assert_eq!(H256::decode(&mut &value[..]).unwrap(), [69u8; 32].into());
+		}
+	}
+}
diff --git a/substrate/test-utils/runtime/src/substrate_test_pallet.rs b/substrate/test-utils/runtime/src/substrate_test_pallet.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ed1ad990472ba2053998f4d5ac4944ec91b4b7d7
--- /dev/null
+++ b/substrate/test-utils/runtime/src/substrate_test_pallet.rs
@@ -0,0 +1,252 @@
+// 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.
+
+//! # substrate-test pallet
+//!
+//! Provides functionality used in unit-tests of numerous modules across substrate that require
+//! functioning runtime. Some calls are allowed to be submitted as unsigned extrinsics, however most
+//! of them requires signing. Refer to `pallet::Call` for further details.
+
+use frame_support::{pallet_prelude::*, storage};
+use sp_core::sr25519::Public;
+use sp_runtime::{
+	traits::Hash,
+	transaction_validity::{
+		InvalidTransaction, TransactionSource, TransactionValidity, ValidTransaction,
+	},
+};
+use sp_std::prelude::*;
+
+pub use self::pallet::*;
+
+const LOG_TARGET: &str = "substrate_test_pallet";
+
+#[frame_support::pallet(dev_mode)]
+pub mod pallet {
+	use super::*;
+	use crate::TransferData;
+	use frame_system::pallet_prelude::*;
+	use sp_core::storage::well_known_keys;
+	use sp_runtime::{traits::BlakeTwo256, transaction_validity::TransactionPriority, Perbill};
+
+	#[pallet::pallet]
+	#[pallet::without_storage_info]
+	pub struct Pallet<T>(_);
+
+	#[pallet::config]
+	pub trait Config: frame_system::Config {}
+
+	#[pallet::storage]
+	#[pallet::getter(fn authorities)]
+	pub type Authorities<T> = StorageValue<_, Vec<Public>, ValueQuery>;
+
+	#[pallet::genesis_config]
+	#[derive(frame_support::DefaultNoBound)]
+	pub struct GenesisConfig<T: Config> {
+		pub authorities: Vec<Public>,
+		#[serde(skip)]
+		pub _config: sp_std::marker::PhantomData<T>,
+	}
+
+	#[pallet::genesis_build]
+	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {
+		fn build(&self) {
+			<Authorities<T>>::put(self.authorities.clone());
+		}
+	}
+
+	#[pallet::call]
+	impl<T: Config> Pallet<T> {
+		/// Legacy call used in transaction pool benchmarks.
+		#[pallet::call_index(0)]
+		#[pallet::weight(100)]
+		pub fn bench_call(_origin: OriginFor<T>, _transfer: TransferData) -> DispatchResult {
+			Ok(())
+		}
+
+		/// Implicitly fill a block body with some data.
+		#[pallet::call_index(1)]
+		#[pallet::weight(100)]
+		pub fn include_data(origin: OriginFor<T>, _data: Vec<u8>) -> DispatchResult {
+			frame_system::ensure_signed(origin)?;
+			Ok(())
+		}
+
+		/// Put/delete some data from storage. Intended to use as an unsigned extrinsic.
+		#[pallet::call_index(2)]
+		#[pallet::weight(100)]
+		pub fn storage_change(
+			_origin: OriginFor<T>,
+			key: Vec<u8>,
+			value: Option<Vec<u8>>,
+		) -> DispatchResult {
+			match value {
+				Some(value) => storage::unhashed::put_raw(&key, &value),
+				None => storage::unhashed::kill(&key),
+			}
+			Ok(())
+		}
+
+		/// Write a key value pair to the offchain database.
+		#[pallet::call_index(3)]
+		#[pallet::weight(100)]
+		pub fn offchain_index_set(
+			origin: OriginFor<T>,
+			key: Vec<u8>,
+			value: Vec<u8>,
+		) -> DispatchResult {
+			frame_system::ensure_signed(origin)?;
+			sp_io::offchain_index::set(&key, &value);
+			Ok(())
+		}
+
+		/// Remove a key and an associated value from the offchain database.
+		#[pallet::call_index(4)]
+		#[pallet::weight(100)]
+		pub fn offchain_index_clear(origin: OriginFor<T>, key: Vec<u8>) -> DispatchResult {
+			frame_system::ensure_signed(origin)?;
+			sp_io::offchain_index::clear(&key);
+			Ok(())
+		}
+
+		/// Create an index for this call.
+		#[pallet::call_index(5)]
+		#[pallet::weight(100)]
+		pub fn indexed_call(origin: OriginFor<T>, data: Vec<u8>) -> DispatchResult {
+			frame_system::ensure_signed(origin)?;
+			let content_hash = sp_io::hashing::blake2_256(&data);
+			let extrinsic_index: u32 =
+				storage::unhashed::get(well_known_keys::EXTRINSIC_INDEX).unwrap();
+			sp_io::transaction_index::index(extrinsic_index, data.len() as u32, content_hash);
+			Ok(())
+		}
+
+		/// Deposit given digest items into the system storage. They will be included in a header
+		/// during finalization.
+		#[pallet::call_index(6)]
+		#[pallet::weight(100)]
+		pub fn deposit_log_digest_item(
+			_origin: OriginFor<T>,
+			log: sp_runtime::generic::DigestItem,
+		) -> DispatchResult {
+			<frame_system::Pallet<T>>::deposit_log(log);
+			Ok(())
+		}
+
+		/// This call is validated as `ValidTransaction` with given priority.
+		#[pallet::call_index(7)]
+		#[pallet::weight(100)]
+		pub fn call_with_priority(
+			_origin: OriginFor<T>,
+			_priority: TransactionPriority,
+		) -> DispatchResult {
+			Ok(())
+		}
+
+		/// This call is validated as non-propagable `ValidTransaction`.
+		#[pallet::call_index(8)]
+		#[pallet::weight(100)]
+		pub fn call_do_not_propagate(_origin: OriginFor<T>) -> DispatchResult {
+			Ok(())
+		}
+
+		/// Fill the block weight up to the given ratio.
+		#[pallet::call_index(9)]
+		#[pallet::weight(*_ratio * T::BlockWeights::get().max_block)]
+		pub fn fill_block(origin: OriginFor<T>, _ratio: Perbill) -> DispatchResult {
+			ensure_signed(origin)?;
+			Ok(())
+		}
+
+		/// Read X times from the state some data.
+		///
+		/// Panics if it can not read `X` times.
+		#[pallet::call_index(10)]
+		#[pallet::weight(100)]
+		pub fn read(_origin: OriginFor<T>, count: u32) -> DispatchResult {
+			Self::execute_read(count, false)
+		}
+
+		/// Read X times from the state some data and then panic!
+		///
+		/// Returns `Ok` if it didn't read anything.
+		#[pallet::call_index(11)]
+		#[pallet::weight(100)]
+		pub fn read_and_panic(_origin: OriginFor<T>, count: u32) -> DispatchResult {
+			Self::execute_read(count, true)
+		}
+	}
+
+	impl<T: Config> Pallet<T> {
+		fn execute_read(read: u32, panic_at_end: bool) -> DispatchResult {
+			let mut next_key = vec![];
+			for _ in 0..(read as usize) {
+				if let Some(next) = sp_io::storage::next_key(&next_key) {
+					// Read the value
+					sp_io::storage::get(&next);
+
+					next_key = next;
+				} else {
+					if panic_at_end {
+						return Ok(())
+					} else {
+						panic!("Could not read {read} times from the state");
+					}
+				}
+			}
+
+			if panic_at_end {
+				panic!("BYE")
+			} else {
+				Ok(())
+			}
+		}
+	}
+
+	#[pallet::validate_unsigned]
+	impl<T: Config> ValidateUnsigned for Pallet<T> {
+		type Call = Call<T>;
+
+		fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
+			log::trace!(target: LOG_TARGET, "validate_unsigned {call:?}");
+			match call {
+				// Some tests do not need to be complicated with signer and nonce, some need
+				// reproducible block hash (call signature can't be there).
+				// Offchain testing requires storage_change.
+				Call::deposit_log_digest_item { .. } |
+				Call::storage_change { .. } |
+				Call::read { .. } |
+				Call::read_and_panic { .. } => Ok(ValidTransaction {
+					provides: vec![BlakeTwo256::hash_of(&call).encode()],
+					..Default::default()
+				}),
+				_ => Err(TransactionValidityError::Invalid(InvalidTransaction::Call)),
+			}
+		}
+	}
+}
+
+pub fn validate_runtime_call<T: pallet::Config>(call: &pallet::Call<T>) -> TransactionValidity {
+	log::trace!(target: LOG_TARGET, "validate_runtime_call {call:?}");
+	match call {
+		Call::call_do_not_propagate {} =>
+			Ok(ValidTransaction { propagate: false, ..Default::default() }),
+		Call::call_with_priority { priority } =>
+			Ok(ValidTransaction { priority: *priority, ..Default::default() }),
+		_ => Ok(Default::default()),
+	}
+}
diff --git a/substrate/test-utils/runtime/src/test_json/README.md b/substrate/test-utils/runtime/src/test_json/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d6ae55c34639dcd601c94e1ee0ed2a3ac9e04a6
--- /dev/null
+++ b/substrate/test-utils/runtime/src/test_json/README.md
@@ -0,0 +1,24 @@
+`default_genesis_config.json` file has been generated by the following code:
+```
+	use crate::genesismap::GenesisStorageBuilder;
+	#[test]
+	fn write_default_config_to_tmp_file() {
+		let j = json::to_string(&GenesisStorageBuilder::default().genesis_config()).unwrap().into_bytes();
+		let mut file = fs::OpenOptions::new()
+			.create(true)
+			.write(true)
+			.open("/tmp/default_genesis_config.json").unwrap();
+		file.write_all(&j);
+	}
+```
+
+`:code` field has been manually truncated to reduce file size. Test is only
+comparing keys, not the values.
+
+`default_genesis_config_invalid.json` is just a broken copy of
+`default_genesis_config.json` with `authorities` field renamed to
+`renamed_authorities`.
+
+
+`default_genesis_config_invalid.json` is just an imcomplete copy of
+`default_genesis_config.json` with `babe::authorities` field removed.
diff --git a/substrate/test-utils/runtime/src/test_json/default_genesis_config.json b/substrate/test-utils/runtime/src/test_json/default_genesis_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..b0218d417daa57e46b32efff28187fc48b96b4b9
--- /dev/null
+++ b/substrate/test-utils/runtime/src/test_json/default_genesis_config.json
@@ -0,0 +1,115 @@
+{
+  "system": {
+    "code": "0x52"
+  },
+  "babe": {
+    "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
+      ]
+    ]
+  }
+}
diff --git a/substrate/test-utils/runtime/src/test_json/default_genesis_config_incomplete.json b/substrate/test-utils/runtime/src/test_json/default_genesis_config_incomplete.json
new file mode 100644
index 0000000000000000000000000000000000000000..e25730ee11cf01b59d84ae0d85d29a49c636f8f7
--- /dev/null
+++ b/substrate/test-utils/runtime/src/test_json/default_genesis_config_incomplete.json
@@ -0,0 +1,101 @@
+{
+  "system": {
+    "code": "0x52"
+  },
+  "babe": {
+    "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
+      ]
+    ]
+  }
+}
diff --git a/substrate/test-utils/runtime/src/test_json/default_genesis_config_invalid.json b/substrate/test-utils/runtime/src/test_json/default_genesis_config_invalid.json
new file mode 100644
index 0000000000000000000000000000000000000000..00550efaeec9f5c8d5e48e79629ebedd208f75ee
--- /dev/null
+++ b/substrate/test-utils/runtime/src/test_json/default_genesis_config_invalid.json
@@ -0,0 +1,115 @@
+{
+  "system": {
+    "code": "0x52"
+  },
+  "babe": {
+    "renamed_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
+      ]
+    ]
+  }
+}
diff --git a/substrate/test-utils/runtime/transaction-pool/Cargo.toml b/substrate/test-utils/runtime/transaction-pool/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..18efb2c8a0a6142f1939beebc052b961130a6e7a
--- /dev/null
+++ b/substrate/test-utils/runtime/transaction-pool/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "substrate-test-runtime-transaction-pool"
+version = "2.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+futures = "0.3.21"
+parking_lot = "0.12.1"
+thiserror = "1.0"
+sc-transaction-pool = { version = "4.0.0-dev", path = "../../../client/transaction-pool" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../client/transaction-pool/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../client" }
diff --git a/substrate/test-utils/runtime/transaction-pool/src/lib.rs b/substrate/test-utils/runtime/transaction-pool/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7b529200440279a59a74bdb9d3dbf315a21d9261
--- /dev/null
+++ b/substrate/test-utils/runtime/transaction-pool/src/lib.rs
@@ -0,0 +1,384 @@
+// 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.
+
+//! Test utils for the transaction pool together with the test runtime.
+//!
+//! See [`TestApi`] for more information.
+
+use codec::Encode;
+use futures::future::ready;
+use parking_lot::RwLock;
+use sp_blockchain::{CachedHeaderMetadata, TreeRoute};
+use sp_runtime::{
+	generic::{self, BlockId},
+	traits::{
+		BlakeTwo256, Block as BlockT, Hash as HashT, Header as _, NumberFor, TrailingZeroInput,
+	},
+	transaction_validity::{
+		InvalidTransaction, TransactionSource, TransactionValidity, TransactionValidityError,
+		ValidTransaction,
+	},
+};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use substrate_test_runtime_client::{
+	runtime::{
+		AccountId, Block, BlockNumber, Extrinsic, ExtrinsicBuilder, Hash, Header, Nonce, Transfer,
+		TransferData,
+	},
+	AccountKeyring::{self, *},
+};
+
+/// Error type used by [`TestApi`].
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub struct Error(#[from] sc_transaction_pool_api::error::Error);
+
+impl sc_transaction_pool_api::error::IntoPoolError for Error {
+	fn into_pool_error(self) -> Result<sc_transaction_pool_api::error::Error, Self> {
+		Ok(self.0)
+	}
+}
+
+pub enum IsBestBlock {
+	Yes,
+	No,
+}
+
+impl IsBestBlock {
+	pub fn is_best(&self) -> bool {
+		matches!(self, Self::Yes)
+	}
+}
+
+impl From<bool> for IsBestBlock {
+	fn from(is_best: bool) -> Self {
+		if is_best {
+			Self::Yes
+		} else {
+			Self::No
+		}
+	}
+}
+
+#[derive(Default)]
+pub struct ChainState {
+	pub block_by_number: BTreeMap<BlockNumber, Vec<(Block, IsBestBlock)>>,
+	pub block_by_hash: HashMap<Hash, Block>,
+	pub nonces: HashMap<AccountId, u64>,
+	pub invalid_hashes: HashSet<Hash>,
+}
+
+/// Test Api for transaction pool.
+pub struct TestApi {
+	valid_modifier: RwLock<Box<dyn Fn(&mut ValidTransaction) + Send + Sync>>,
+	chain: RwLock<ChainState>,
+	validation_requests: RwLock<Vec<Extrinsic>>,
+}
+
+impl TestApi {
+	/// Test Api with Alice nonce set initially.
+	pub fn with_alice_nonce(nonce: u64) -> Self {
+		let api = Self::empty();
+
+		api.chain.write().nonces.insert(Alice.into(), nonce);
+
+		api
+	}
+
+	/// Default Test Api
+	pub fn empty() -> Self {
+		let api = TestApi {
+			valid_modifier: RwLock::new(Box::new(|_| {})),
+			chain: Default::default(),
+			validation_requests: RwLock::new(Default::default()),
+		};
+
+		// Push genesis block
+		api.push_block(0, Vec::new(), true);
+
+		api
+	}
+
+	/// Set hook on modify valid result of transaction.
+	pub fn set_valid_modifier(&self, modifier: Box<dyn Fn(&mut ValidTransaction) + Send + Sync>) {
+		*self.valid_modifier.write() = modifier;
+	}
+
+	/// Push block under given number.
+	pub fn push_block(
+		&self,
+		block_number: BlockNumber,
+		xts: Vec<Extrinsic>,
+		is_best_block: bool,
+	) -> Header {
+		let parent_hash = {
+			let chain = self.chain.read();
+			block_number
+				.checked_sub(1)
+				.and_then(|num| {
+					chain.block_by_number.get(&num).map(|blocks| blocks[0].0.header.hash())
+				})
+				.unwrap_or_default()
+		};
+
+		self.push_block_with_parent(parent_hash, xts, is_best_block)
+	}
+
+	/// Push a block using the given `parent`.
+	///
+	/// Panics if `parent` does not exists.
+	pub fn push_block_with_parent(
+		&self,
+		parent: Hash,
+		xts: Vec<Extrinsic>,
+		is_best_block: bool,
+	) -> Header {
+		// `Hash::default()` is the genesis parent hash
+		let block_number = if parent == Hash::default() {
+			0
+		} else {
+			*self
+				.chain
+				.read()
+				.block_by_hash
+				.get(&parent)
+				.expect("`parent` exists")
+				.header()
+				.number() + 1
+		};
+
+		let header = Header {
+			number: block_number,
+			digest: Default::default(),
+			extrinsics_root: Hash::random(),
+			parent_hash: parent,
+			state_root: Default::default(),
+		};
+
+		self.add_block(Block::new(header.clone(), xts), is_best_block);
+
+		header
+	}
+
+	/// Add a block to the internal state.
+	pub fn add_block(&self, block: Block, is_best_block: bool) {
+		let hash = block.header.hash();
+		let block_number = block.header.number();
+
+		let mut chain = self.chain.write();
+		chain.block_by_hash.insert(hash, block.clone());
+
+		if is_best_block {
+			chain
+				.block_by_number
+				.entry(*block_number)
+				.or_default()
+				.iter_mut()
+				.for_each(|x| {
+					x.1 = IsBestBlock::No;
+				});
+		}
+
+		chain
+			.block_by_number
+			.entry(*block_number)
+			.or_default()
+			.push((block, is_best_block.into()));
+	}
+
+	fn hash_and_length_inner(ex: &Extrinsic) -> (Hash, usize) {
+		let encoded = ex.encode();
+		(BlakeTwo256::hash(&encoded), encoded.len())
+	}
+
+	/// Mark some transaction is invalid.
+	///
+	/// Next time transaction pool will try to validate this
+	/// extrinsic, api will return invalid result.
+	pub fn add_invalid(&self, xts: &Extrinsic) {
+		self.chain.write().invalid_hashes.insert(Self::hash_and_length_inner(xts).0);
+	}
+
+	/// Query validation requests received.
+	pub fn validation_requests(&self) -> Vec<Extrinsic> {
+		self.validation_requests.read().clone()
+	}
+
+	/// get a reference to the chain state
+	pub fn chain(&self) -> &RwLock<ChainState> {
+		&self.chain
+	}
+
+	/// Increment nonce in the inner state.
+	pub fn increment_nonce(&self, account: AccountId) {
+		let mut chain = self.chain.write();
+		chain.nonces.entry(account).and_modify(|n| *n += 1).or_insert(1);
+	}
+
+	/// Calculate a tree route between the two given blocks.
+	pub fn tree_route(
+		&self,
+		from: Hash,
+		to: Hash,
+	) -> Result<sp_blockchain::TreeRoute<Block>, Error> {
+		sp_blockchain::tree_route(self, from, to)
+	}
+}
+
+impl sc_transaction_pool::ChainApi for TestApi {
+	type Block = Block;
+	type Error = Error;
+	type ValidationFuture = futures::future::Ready<Result<TransactionValidity, Error>>;
+	type BodyFuture = futures::future::Ready<Result<Option<Vec<Extrinsic>>, Error>>;
+
+	fn validate_transaction(
+		&self,
+		at: &BlockId<Self::Block>,
+		_source: TransactionSource,
+		uxt: <Self::Block as BlockT>::Extrinsic,
+	) -> Self::ValidationFuture {
+		self.validation_requests.write().push(uxt.clone());
+
+		match self.block_id_to_number(at) {
+			Ok(Some(number)) => {
+				let found_best = self
+					.chain
+					.read()
+					.block_by_number
+					.get(&number)
+					.map(|blocks| blocks.iter().any(|b| b.1.is_best()))
+					.unwrap_or(false);
+
+				// If there is no best block, we don't know based on which block we should validate
+				// the transaction. (This is not required for this test function, but in real
+				// environment it would fail because of this).
+				if !found_best {
+					return ready(Ok(Err(TransactionValidityError::Invalid(
+						InvalidTransaction::Custom(1),
+					))))
+				}
+			},
+			Ok(None) =>
+				return ready(Ok(Err(TransactionValidityError::Invalid(
+					InvalidTransaction::Custom(2),
+				)))),
+			Err(e) => return ready(Err(e)),
+		}
+
+		let (requires, provides) = if let Ok(transfer) = TransferData::try_from(&uxt) {
+			let chain_nonce = self.chain.read().nonces.get(&transfer.from).cloned().unwrap_or(0);
+			let requires =
+				if chain_nonce == transfer.nonce { vec![] } else { vec![vec![chain_nonce as u8]] };
+			let provides = vec![vec![transfer.nonce as u8]];
+
+			(requires, provides)
+		} else {
+			(Vec::new(), vec![uxt.encode()])
+		};
+
+		if self.chain.read().invalid_hashes.contains(&self.hash_and_length(&uxt).0) {
+			return ready(Ok(Err(TransactionValidityError::Invalid(InvalidTransaction::Custom(0)))))
+		}
+
+		let mut validity =
+			ValidTransaction { priority: 1, requires, provides, longevity: 64, propagate: true };
+
+		(self.valid_modifier.read())(&mut validity);
+
+		ready(Ok(Ok(validity)))
+	}
+
+	fn block_id_to_number(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<NumberFor<Self::Block>>, Error> {
+		Ok(match at {
+			generic::BlockId::Hash(x) =>
+				self.chain.read().block_by_hash.get(x).map(|b| *b.header.number()),
+			generic::BlockId::Number(num) => Some(*num),
+		})
+	}
+
+	fn block_id_to_hash(
+		&self,
+		at: &BlockId<Self::Block>,
+	) -> Result<Option<<Self::Block as BlockT>::Hash>, Error> {
+		Ok(match at {
+			generic::BlockId::Hash(x) => Some(*x),
+			generic::BlockId::Number(num) =>
+				self.chain.read().block_by_number.get(num).and_then(|blocks| {
+					blocks.iter().find(|b| b.1.is_best()).map(|b| b.0.header().hash())
+				}),
+		})
+	}
+
+	fn hash_and_length(&self, ex: &<Self::Block as BlockT>::Extrinsic) -> (Hash, usize) {
+		Self::hash_and_length_inner(ex)
+	}
+
+	fn block_body(&self, hash: <Self::Block as BlockT>::Hash) -> Self::BodyFuture {
+		futures::future::ready(Ok(self
+			.chain
+			.read()
+			.block_by_hash
+			.get(&hash)
+			.map(|b| b.extrinsics().to_vec())))
+	}
+
+	fn block_header(
+		&self,
+		hash: <Self::Block as BlockT>::Hash,
+	) -> Result<Option<<Self::Block as BlockT>::Header>, Self::Error> {
+		Ok(self.chain.read().block_by_hash.get(&hash).map(|b| b.header().clone()))
+	}
+
+	fn tree_route(
+		&self,
+		from: <Self::Block as BlockT>::Hash,
+		to: <Self::Block as BlockT>::Hash,
+	) -> Result<TreeRoute<Self::Block>, Self::Error> {
+		sp_blockchain::tree_route::<Block, TestApi>(self, from, to).map_err(Into::into)
+	}
+}
+
+impl sp_blockchain::HeaderMetadata<Block> for TestApi {
+	type Error = Error;
+
+	fn header_metadata(&self, hash: Hash) -> Result<CachedHeaderMetadata<Block>, Self::Error> {
+		let chain = self.chain.read();
+		let block = chain.block_by_hash.get(&hash).expect("Hash exists");
+
+		Ok(block.header().into())
+	}
+
+	fn insert_header_metadata(&self, _: Hash, _: CachedHeaderMetadata<Block>) {
+		unimplemented!("Not implemented for tests")
+	}
+
+	fn remove_header_metadata(&self, _: Hash) {
+		unimplemented!("Not implemented for tests")
+	}
+}
+
+/// Generate transfer extrinsic with a given nonce.
+///
+/// Part of the test api.
+pub fn uxt(who: AccountKeyring, nonce: Nonce) -> Extrinsic {
+	let dummy = codec::Decode::decode(&mut TrailingZeroInput::zeroes()).unwrap();
+	let transfer = Transfer { from: who.into(), to: dummy, nonce, amount: 1 };
+	ExtrinsicBuilder::new_transfer(transfer).build()
+}
diff --git a/substrate/test-utils/src/lib.rs b/substrate/test-utils/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1ad702893683f696728bc1ecfb10e832b480da22
--- /dev/null
+++ b/substrate/test-utils/src/lib.rs
@@ -0,0 +1,77 @@
+// 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.
+
+//! Test utils
+
+#[doc(hidden)]
+pub use futures;
+/// Marks async function to be executed by an async runtime suitable to test environment.
+///
+/// # Requirements
+///
+/// You must have tokio in the `[dev-dependencies]` of your crate to use this macro.
+///
+/// # Example
+///
+/// ```
+/// #[substrate_test_utils::test]
+/// async fn basic_test() {
+///     assert!(true);
+/// }
+/// ```
+pub use substrate_test_utils_derive::test;
+#[doc(hidden)]
+pub use tokio;
+
+/// Panic when the vectors are different, without taking the order into account.
+///
+/// # Examples
+///
+/// ```rust
+/// #[macro_use]
+/// # use substrate_test_utils::{assert_eq_uvec};
+/// # fn main() {
+/// assert_eq_uvec!(vec![1,2], vec![2,1]);
+/// # }
+/// ```
+///
+/// ```rust,should_panic
+/// #[macro_use]
+/// # use substrate_test_utils::{assert_eq_uvec};
+/// # fn main() {
+/// assert_eq_uvec!(vec![1,2,3], vec![2,1]);
+/// # }
+/// ```
+#[macro_export]
+macro_rules! assert_eq_uvec {
+	( $x:expr, $y:expr $(,)? ) => {
+		$crate::__assert_eq_uvec!($x, $y);
+		$crate::__assert_eq_uvec!($y, $x);
+	};
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __assert_eq_uvec {
+	( $x:expr, $y:expr ) => {
+		$x.iter().for_each(|e| {
+			if !$y.contains(e) {
+				panic!("vectors not equal: {:?} != {:?}", $x, $y);
+			}
+		});
+	};
+}
diff --git a/substrate/test-utils/test-crate/Cargo.toml b/substrate/test-utils/test-crate/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..67966dd2b6015df041cec01e71571e6efa5620de
--- /dev/null
+++ b/substrate/test-utils/test-crate/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "substrate-test-utils-test-crate"
+version = "0.1.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+publish = false
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dev-dependencies]
+tokio = { version = "1.22.0", features = ["macros"] }
+sc-service = { version = "0.10.0-dev", path = "../../client/service" }
+test-utils = { package = "substrate-test-utils", version = "4.0.0-dev", path = ".." }
diff --git a/substrate/test-utils/test-crate/src/main.rs b/substrate/test-utils/test-crate/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cab4cc6e924d7b0d1731477f5c3d3833153690f2
--- /dev/null
+++ b/substrate/test-utils/test-crate/src/main.rs
@@ -0,0 +1,25 @@
+// 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/>.
+
+#[cfg(test)]
+#[test_utils::test]
+async fn basic_test() {
+	assert!(true);
+}
+
+fn main() {}
diff --git a/substrate/test-utils/tests/basic.rs b/substrate/test-utils/tests/basic.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e8c46b1e837d2f7f6cfde7ea980aabc37c998667
--- /dev/null
+++ b/substrate/test-utils/tests/basic.rs
@@ -0,0 +1,49 @@
+// 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/>.
+
+#[substrate_test_utils::test]
+async fn basic_test() {
+	assert!(true);
+}
+
+#[substrate_test_utils::test]
+#[should_panic(expected = "boo!")]
+async fn panicking_test() {
+	panic!("boo!");
+}
+
+#[substrate_test_utils::test(flavor = "multi_thread", worker_threads = 1)]
+async fn basic_test_with_args() {
+	assert!(true);
+}
+
+// NOTE: enable this test only after setting SUBSTRATE_TEST_TIMEOUT to a smaller value
+//
+// SUBSTRATE_TEST_TIMEOUT=1 cargo test -- --ignored timeout
+#[substrate_test_utils::test]
+#[should_panic(expected = "test took too long")]
+#[ignore]
+async fn timeout() {
+	tokio::time::sleep(std::time::Duration::from_secs(
+		std::env::var("SUBSTRATE_TEST_TIMEOUT")
+			.expect("env var SUBSTRATE_TEST_TIMEOUT has been provided by the user")
+			.parse::<u64>()
+			.unwrap() + 1,
+	))
+	.await;
+}
diff --git a/substrate/test-utils/tests/ui.rs b/substrate/test-utils/tests/ui.rs
new file mode 100644
index 0000000000000000000000000000000000000000..baf822bb87a49c8e43278c2686afc2811aee6c09
--- /dev/null
+++ b/substrate/test-utils/tests/ui.rs
@@ -0,0 +1,23 @@
+// 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/>.
+
+#[test]
+fn substrate_test_utils_derive_trybuild() {
+	let t = trybuild::TestCases::new();
+	t.compile_fail("tests/ui/too-many-func-parameters.rs");
+}
diff --git a/substrate/test-utils/tests/ui/too-many-func-parameters.rs b/substrate/test-utils/tests/ui/too-many-func-parameters.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0eece5f9e6130cea8b291beae2256185ae1659af
--- /dev/null
+++ b/substrate/test-utils/tests/ui/too-many-func-parameters.rs
@@ -0,0 +1,24 @@
+// 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/>.
+
+#[substrate_test_utils::test]
+async fn too_many_func_parameters(_: u32) {
+	assert!(true);
+}
+
+fn main() {}
diff --git a/substrate/test-utils/tests/ui/too-many-func-parameters.stderr b/substrate/test-utils/tests/ui/too-many-func-parameters.stderr
new file mode 100644
index 0000000000000000000000000000000000000000..1b1630022e4f7e48aa6ad346e756257ab9544752
--- /dev/null
+++ b/substrate/test-utils/tests/ui/too-many-func-parameters.stderr
@@ -0,0 +1,5 @@
+error: No arguments expected for tests.
+  --> $DIR/too-many-func-parameters.rs:20:1
+   |
+20 | async fn too_many_func_parameters(_: u32) {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/substrate/utils/binary-merkle-tree/Cargo.toml b/substrate/utils/binary-merkle-tree/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f619a5ab5503b9315b81da61a7d201cc42e05aea
--- /dev/null
+++ b/substrate/utils/binary-merkle-tree/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "binary-merkle-tree"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+repository = "https://github.com/paritytech/substrate"
+description = "A no-std/Substrate compatible library to construct binary merkle tree."
+homepage = "https://substrate.io"
+
+[dependencies]
+array-bytes = { version = "6.1", optional = true }
+log = { version = "0.4", default-features = false, optional = true }
+hash-db = { version = "0.16.0", default-features = false }
+
+[dev-dependencies]
+array-bytes = "6.1"
+env_logger = "0.9"
+sp-core = { version = "21.0.0", path = "../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../primitives/runtime" }
+
+[features]
+debug = [ "array-bytes", "log" ]
+default = [ "debug", "std" ]
+std = [ "hash-db/std", "log/std", "sp-core/std", "sp-runtime/std" ]
diff --git a/substrate/utils/binary-merkle-tree/src/lib.rs b/substrate/utils/binary-merkle-tree/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0efab9186c25fdc8f711b2c2de6f931192b250bd
--- /dev/null
+++ b/substrate/utils/binary-merkle-tree/src/lib.rs
@@ -0,0 +1,809 @@
+// 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)]
+#![warn(missing_docs)]
+
+//! This crate implements a simple binary Merkle Tree utilities required for inter-op with Ethereum
+//! bridge & Solidity contract.
+//!
+//! The implementation is optimised for usage within Substrate Runtime and supports no-std
+//! compilation targets.
+//!
+//! Merkle Tree is constructed from arbitrary-length leaves, that are initially hashed using the
+//! same hasher as the inner nodes.
+//! Inner nodes are created by concatenating child hashes and hashing again. The implementation
+//! does not perform any sorting of the input data (leaves) nor when inner nodes are created.
+//!
+//! If the number of leaves is not even, last leaf (hash of) is promoted to the upper layer.
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+#[cfg(not(feature = "std"))]
+use alloc::vec;
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+
+use hash_db::Hasher;
+
+/// Construct a root hash of a Binary Merkle Tree created from given leaves.
+///
+/// See crate-level docs for details about Merkle Tree construction.
+///
+/// In case an empty list of leaves is passed the function returns a 0-filled hash.
+pub fn merkle_root<H, I>(leaves: I) -> H::Out
+where
+	H: Hasher,
+	H::Out: Default + AsRef<[u8]>,
+	I: IntoIterator,
+	I::Item: AsRef<[u8]>,
+{
+	let iter = leaves.into_iter().map(|l| <H as Hasher>::hash(l.as_ref()));
+	merkelize::<H, _, _>(iter, &mut ()).into()
+}
+
+fn merkelize<H, V, I>(leaves: I, visitor: &mut V) -> H::Out
+where
+	H: Hasher,
+	H::Out: Default + AsRef<[u8]>,
+	V: Visitor<H::Out>,
+	I: Iterator<Item = H::Out>,
+{
+	let upper = Vec::with_capacity((leaves.size_hint().1.unwrap_or(0).saturating_add(1)) / 2);
+	let mut next = match merkelize_row::<H, _, _>(leaves, upper, visitor) {
+		Ok(root) => return root,
+		Err(next) if next.is_empty() => return H::Out::default(),
+		Err(next) => next,
+	};
+
+	let mut upper = Vec::with_capacity((next.len().saturating_add(1)) / 2);
+	loop {
+		visitor.move_up();
+
+		match merkelize_row::<H, _, _>(next.drain(..), upper, visitor) {
+			Ok(root) => return root,
+			Err(t) => {
+				// swap collections to avoid allocations
+				upper = next;
+				next = t;
+			},
+		};
+	}
+}
+
+/// A generated merkle proof.
+///
+/// The structure contains all necessary data to later on verify the proof and the leaf itself.
+#[derive(Debug, PartialEq, Eq)]
+pub struct MerkleProof<H, L> {
+	/// Root hash of generated merkle tree.
+	pub root: H,
+	/// Proof items (does not contain the leaf hash, nor the root obviously).
+	///
+	/// This vec contains all inner node hashes necessary to reconstruct the root hash given the
+	/// leaf hash.
+	pub proof: Vec<H>,
+	/// Number of leaves in the original tree.
+	///
+	/// This is needed to detect a case where we have an odd number of leaves that "get promoted"
+	/// to upper layers.
+	pub number_of_leaves: usize,
+	/// Index of the leaf the proof is for (0-based).
+	pub leaf_index: usize,
+	/// Leaf content.
+	pub leaf: L,
+}
+
+/// A trait of object inspecting merkle root creation.
+///
+/// It can be passed to [`merkelize_row`] or [`merkelize`] functions and will be notified
+/// about tree traversal.
+trait Visitor<T> {
+	/// We are moving one level up in the tree.
+	fn move_up(&mut self);
+
+	/// We are creating an inner node from given `left` and `right` nodes.
+	///
+	/// Note that in case of last odd node in the row `right` might be empty.
+	/// The method will also visit the `root` hash (level 0).
+	///
+	/// The `index` is an index of `left` item.
+	fn visit(&mut self, index: usize, left: &Option<T>, right: &Option<T>);
+}
+
+/// No-op implementation of the visitor.
+impl<T> Visitor<T> for () {
+	fn move_up(&mut self) {}
+	fn visit(&mut self, _index: usize, _left: &Option<T>, _right: &Option<T>) {}
+}
+
+/// Construct a Merkle Proof for leaves given by indices.
+///
+/// The function constructs a (partial) Merkle Tree first and stores all elements required
+/// to prove requested item (leaf) given the root hash.
+///
+/// Both the Proof and the Root Hash is returned.
+///
+/// # Panic
+///
+/// The function will panic if given `leaf_index` is greater than the number of leaves.
+pub fn merkle_proof<H, I, T>(leaves: I, leaf_index: usize) -> MerkleProof<H::Out, T>
+where
+	H: Hasher,
+	H::Out: Default + Copy + AsRef<[u8]>,
+	I: IntoIterator<Item = T>,
+	I::IntoIter: ExactSizeIterator,
+	T: AsRef<[u8]>,
+{
+	let mut leaf = None;
+	let iter = leaves.into_iter().enumerate().map(|(idx, l)| {
+		let hash = <H as Hasher>::hash(l.as_ref());
+		if idx == leaf_index {
+			leaf = Some(l);
+		}
+		hash
+	});
+
+	/// The struct collects a proof for single leaf.
+	struct ProofCollection<T> {
+		proof: Vec<T>,
+		position: usize,
+	}
+
+	impl<T> ProofCollection<T> {
+		fn new(position: usize) -> Self {
+			ProofCollection { proof: Default::default(), position }
+		}
+	}
+
+	impl<T: Copy> Visitor<T> for ProofCollection<T> {
+		fn move_up(&mut self) {
+			self.position /= 2;
+		}
+
+		fn visit(&mut self, index: usize, left: &Option<T>, right: &Option<T>) {
+			// we are at left branch - right goes to the proof.
+			if self.position == index {
+				if let Some(right) = right {
+					self.proof.push(*right);
+				}
+			}
+			// we are at right branch - left goes to the proof.
+			if self.position == index + 1 {
+				if let Some(left) = left {
+					self.proof.push(*left);
+				}
+			}
+		}
+	}
+
+	let number_of_leaves = iter.len();
+	let mut collect_proof = ProofCollection::new(leaf_index);
+
+	let root = merkelize::<H, _, _>(iter, &mut collect_proof);
+	let leaf = leaf.expect("Requested `leaf_index` is greater than number of leaves.");
+
+	#[cfg(feature = "debug")]
+	log::debug!(
+		"[merkle_proof] Proof: {:?}",
+		collect_proof
+			.proof
+			.iter()
+			.map(|s| array_bytes::bytes2hex("", s))
+			.collect::<Vec<_>>()
+	);
+
+	MerkleProof { root, proof: collect_proof.proof, number_of_leaves, leaf_index, leaf }
+}
+
+/// Leaf node for proof verification.
+///
+/// Can be either a value that needs to be hashed first,
+/// or the hash itself.
+#[derive(Debug, PartialEq, Eq)]
+pub enum Leaf<'a, H> {
+	/// Leaf content.
+	Value(&'a [u8]),
+	/// Hash of the leaf content.
+	Hash(H),
+}
+
+impl<'a, H, T: AsRef<[u8]>> From<&'a T> for Leaf<'a, H> {
+	fn from(v: &'a T) -> Self {
+		Leaf::Value(v.as_ref())
+	}
+}
+
+/// Verify Merkle Proof correctness versus given root hash.
+///
+/// The proof is NOT expected to contain leaf hash as the first
+/// element, but only all adjacent nodes required to eventually by process of
+/// concatenating and hashing end up with given root hash.
+///
+/// The proof must not contain the root hash.
+pub fn verify_proof<'a, H, P, L>(
+	root: &'a H::Out,
+	proof: P,
+	number_of_leaves: usize,
+	leaf_index: usize,
+	leaf: L,
+) -> bool
+where
+	H: Hasher,
+	H::Out: PartialEq + AsRef<[u8]>,
+	P: IntoIterator<Item = H::Out>,
+	L: Into<Leaf<'a, H::Out>>,
+{
+	if leaf_index >= number_of_leaves {
+		return false
+	}
+
+	let leaf_hash = match leaf.into() {
+		Leaf::Value(content) => <H as Hasher>::hash(content),
+		Leaf::Hash(hash) => hash,
+	};
+
+	let hash_len = <H as Hasher>::LENGTH;
+	let mut combined = vec![0_u8; hash_len * 2];
+	let mut position = leaf_index;
+	let mut width = number_of_leaves;
+	let computed = proof.into_iter().fold(leaf_hash, |a, b| {
+		if position % 2 == 1 || position + 1 == width {
+			combined[..hash_len].copy_from_slice(&b.as_ref());
+			combined[hash_len..].copy_from_slice(&a.as_ref());
+		} else {
+			combined[..hash_len].copy_from_slice(&a.as_ref());
+			combined[hash_len..].copy_from_slice(&b.as_ref());
+		}
+		let hash = <H as Hasher>::hash(&combined);
+		#[cfg(feature = "debug")]
+		log::debug!(
+			"[verify_proof]: (a, b) {:?}, {:?} => {:?} ({:?}) hash",
+			array_bytes::bytes2hex("", a),
+			array_bytes::bytes2hex("", b),
+			array_bytes::bytes2hex("", hash),
+			array_bytes::bytes2hex("", &combined)
+		);
+		position /= 2;
+		width = ((width - 1) / 2) + 1;
+		hash
+	});
+
+	root == &computed
+}
+
+/// Processes a single row (layer) of a tree by taking pairs of elements,
+/// concatenating them, hashing and placing into resulting vector.
+///
+/// In case only one element is provided it is returned via `Ok` result, in any other case (also an
+/// empty iterator) an `Err` with the inner nodes of upper layer is returned.
+fn merkelize_row<H, V, I>(
+	mut iter: I,
+	mut next: Vec<H::Out>,
+	visitor: &mut V,
+) -> Result<H::Out, Vec<H::Out>>
+where
+	H: Hasher,
+	H::Out: AsRef<[u8]>,
+	V: Visitor<H::Out>,
+	I: Iterator<Item = H::Out>,
+{
+	#[cfg(feature = "debug")]
+	log::debug!("[merkelize_row]");
+	next.clear();
+
+	let hash_len = <H as Hasher>::LENGTH;
+	let mut index = 0;
+	let mut combined = vec![0_u8; hash_len * 2];
+	loop {
+		let a = iter.next();
+		let b = iter.next();
+		visitor.visit(index, &a, &b);
+
+		#[cfg(feature = "debug")]
+		log::debug!(
+			"  {:?}\n  {:?}",
+			a.as_ref().map(|s| array_bytes::bytes2hex("", s)),
+			b.as_ref().map(|s| array_bytes::bytes2hex("", s))
+		);
+
+		index += 2;
+		match (a, b) {
+			(Some(a), Some(b)) => {
+				combined[..hash_len].copy_from_slice(a.as_ref());
+				combined[hash_len..].copy_from_slice(b.as_ref());
+
+				next.push(<H as Hasher>::hash(&combined));
+			},
+			// Odd number of items. Promote the item to the upper layer.
+			(Some(a), None) if !next.is_empty() => {
+				next.push(a);
+			},
+			// Last item = root.
+			(Some(a), None) => return Ok(a),
+			// Finish up, no more items.
+			_ => {
+				#[cfg(feature = "debug")]
+				log::debug!(
+					"[merkelize_row] Next: {:?}",
+					next.iter().map(|s| array_bytes::bytes2hex("", s)).collect::<Vec<_>>()
+				);
+				return Err(next)
+			},
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_core::H256;
+	use sp_runtime::traits::Keccak256;
+
+	#[test]
+	fn should_generate_empty_root() {
+		// given
+		let _ = env_logger::try_init();
+		let data: Vec<[u8; 1]> = Default::default();
+
+		// when
+		let out = merkle_root::<Keccak256, _>(data);
+
+		// then
+		assert_eq!(
+			array_bytes::bytes2hex("", out),
+			"0000000000000000000000000000000000000000000000000000000000000000"
+		);
+	}
+
+	#[test]
+	fn should_generate_single_root() {
+		// given
+		let _ = env_logger::try_init();
+		let data = vec![array_bytes::hex2array_unchecked::<_, 20>(
+			"E04CC55ebEE1cBCE552f250e85c57B70B2E2625b",
+		)];
+
+		// when
+		let out = merkle_root::<Keccak256, _>(data);
+
+		// then
+		assert_eq!(
+			array_bytes::bytes2hex("", out),
+			"aeb47a269393297f4b0a3c9c9cfd00c7a4195255274cf39d83dabc2fcc9ff3d7"
+		);
+	}
+
+	#[test]
+	fn should_generate_root_pow_2() {
+		// given
+		let _ = env_logger::try_init();
+		let data = vec![
+			array_bytes::hex2array_unchecked::<_, 20>("E04CC55ebEE1cBCE552f250e85c57B70B2E2625b"),
+			array_bytes::hex2array_unchecked::<_, 20>("25451A4de12dcCc2D166922fA938E900fCc4ED24"),
+		];
+
+		// when
+		let out = merkle_root::<Keccak256, _>(data);
+
+		// then
+		assert_eq!(
+			array_bytes::bytes2hex("", out),
+			"697ea2a8fe5b03468548a7a413424a6292ab44a82a6f5cc594c3fa7dda7ce402"
+		);
+	}
+
+	#[test]
+	fn should_generate_root_complex() {
+		let _ = env_logger::try_init();
+		let test = |root, data| {
+			assert_eq!(array_bytes::bytes2hex("", &merkle_root::<Keccak256, _>(data)), root);
+		};
+
+		test(
+			"aff1208e69c9e8be9b584b07ebac4e48a1ee9d15ce3afe20b77a4d29e4175aa3",
+			vec!["a", "b", "c"],
+		);
+
+		test(
+			"b8912f7269068901f231a965adfefbc10f0eedcfa61852b103efd54dac7db3d7",
+			vec!["a", "b", "a"],
+		);
+
+		test(
+			"dc8e73fe6903148ff5079baecc043983625c23b39f31537e322cd0deee09fa9c",
+			vec!["a", "b", "a", "b"],
+		);
+
+		test(
+			"fb3b3be94be9e983ba5e094c9c51a7d96a4fa2e5d8e891df00ca89ba05bb1239",
+			vec!["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"],
+		);
+	}
+
+	#[test]
+	fn should_generate_and_verify_proof_simple() {
+		// given
+		let _ = env_logger::try_init();
+		let data = vec!["a", "b", "c"];
+
+		// when
+		let proof0 = merkle_proof::<Keccak256, _, _>(data.clone(), 0);
+		assert!(verify_proof::<Keccak256, _, _>(
+			&proof0.root,
+			proof0.proof.clone(),
+			data.len(),
+			proof0.leaf_index,
+			&proof0.leaf,
+		));
+
+		let proof1 = merkle_proof::<Keccak256, _, _>(data.clone(), 1);
+		assert!(verify_proof::<Keccak256, _, _>(
+			&proof1.root,
+			proof1.proof,
+			data.len(),
+			proof1.leaf_index,
+			&proof1.leaf,
+		));
+
+		let proof2 = merkle_proof::<Keccak256, _, _>(data.clone(), 2);
+		assert!(verify_proof::<Keccak256, _, _>(
+			&proof2.root,
+			proof2.proof,
+			data.len(),
+			proof2.leaf_index,
+			&proof2.leaf
+		));
+
+		// then
+		assert_eq!(
+			array_bytes::bytes2hex("", &proof0.root),
+			array_bytes::bytes2hex("", &proof1.root)
+		);
+		assert_eq!(
+			array_bytes::bytes2hex("", &proof2.root),
+			array_bytes::bytes2hex("", &proof1.root)
+		);
+
+		assert!(!verify_proof::<Keccak256, _, _>(
+			&array_bytes::hex2array_unchecked(
+				"fb3b3be94be9e983ba5e094c9c51a7d96a4fa2e5d8e891df00ca89ba05bb1239"
+			)
+			.into(),
+			proof0.proof,
+			data.len(),
+			proof0.leaf_index,
+			&proof0.leaf
+		));
+
+		assert!(!verify_proof::<Keccak256, _, _>(
+			&proof0.root.into(),
+			vec![],
+			data.len(),
+			proof0.leaf_index,
+			&proof0.leaf
+		));
+	}
+
+	#[test]
+	fn should_generate_and_verify_proof_complex() {
+		// given
+		let _ = env_logger::try_init();
+		let data = vec!["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"];
+
+		for l in 0..data.len() {
+			// when
+			let proof = merkle_proof::<Keccak256, _, _>(data.clone(), l);
+			// then
+			assert!(verify_proof::<Keccak256, _, _>(
+				&proof.root,
+				proof.proof,
+				data.len(),
+				proof.leaf_index,
+				&proof.leaf
+			));
+		}
+	}
+
+	#[test]
+	fn should_generate_and_verify_proof_large() {
+		// given
+		let _ = env_logger::try_init();
+		let mut data = vec![];
+		for i in 1..16 {
+			for c in 'a'..'z' {
+				if c as usize % i != 0 {
+					data.push(c.to_string());
+				}
+			}
+
+			for l in 0..data.len() {
+				// when
+				let proof = merkle_proof::<Keccak256, _, _>(data.clone(), l);
+				// then
+				assert!(verify_proof::<Keccak256, _, _>(
+					&proof.root,
+					proof.proof,
+					data.len(),
+					proof.leaf_index,
+					&proof.leaf
+				));
+			}
+		}
+	}
+
+	#[test]
+	fn should_generate_and_verify_proof_large_tree() {
+		// given
+		let _ = env_logger::try_init();
+		let mut data = vec![];
+		for i in 0..6000 {
+			data.push(format!("{}", i));
+		}
+
+		for l in (0..data.len()).step_by(13) {
+			// when
+			let proof = merkle_proof::<Keccak256, _, _>(data.clone(), l);
+			// then
+			assert!(verify_proof::<Keccak256, _, _>(
+				&proof.root,
+				proof.proof,
+				data.len(),
+				proof.leaf_index,
+				&proof.leaf
+			));
+		}
+	}
+
+	#[test]
+	#[should_panic]
+	fn should_panic_on_invalid_leaf_index() {
+		let _ = env_logger::try_init();
+		merkle_proof::<Keccak256, _, _>(vec!["a"], 5);
+	}
+
+	#[test]
+	fn should_generate_and_verify_proof_on_test_data() {
+		let addresses = vec![
+			"0x9aF1Ca5941148eB6A3e9b9C741b69738292C533f",
+			"0xDD6ca953fddA25c496165D9040F7F77f75B75002",
+			"0x60e9C47B64Bc1C7C906E891255EaEC19123E7F42",
+			"0xfa4859480Aa6D899858DE54334d2911E01C070df",
+			"0x19B9b128470584F7209eEf65B69F3624549Abe6d",
+			"0xC436aC1f261802C4494504A11fc2926C726cB83b",
+			"0xc304C8C2c12522F78aD1E28dD86b9947D7744bd0",
+			"0xDa0C2Cba6e832E55dE89cF4033affc90CC147352",
+			"0xf850Fd22c96e3501Aad4CDCBf38E4AEC95622411",
+			"0x684918D4387CEb5E7eda969042f036E226E50642",
+			"0x963F0A1bFbb6813C0AC88FcDe6ceB96EA634A595",
+			"0x39B38ad74b8bCc5CE564f7a27Ac19037A95B6099",
+			"0xC2Dec7Fdd1fef3ee95aD88EC8F3Cd5bd4065f3C7",
+			"0x9E311f05c2b6A43C2CCF16fB2209491BaBc2ec01",
+			"0x927607C30eCE4Ef274e250d0bf414d4a210b16f0",
+			"0x98882bcf85E1E2DFF780D0eB360678C1cf443266",
+			"0xFBb50191cd0662049E7C4EE32830a4Cc9B353047",
+			"0x963854fc2C358c48C3F9F0A598B9572c581B8DEF",
+			"0xF9D7Bc222cF6e3e07bF66711e6f409E51aB75292",
+			"0xF2E3fd32D063F8bBAcB9e6Ea8101C2edd899AFe6",
+			"0x407a5b9047B76E8668570120A96d580589fd1325",
+			"0xEAD9726FAFB900A07dAd24a43AE941d2eFDD6E97",
+			"0x42f5C8D9384034A9030313B51125C32a526b6ee8",
+			"0x158fD2529Bc4116570Eb7C80CC76FEf33ad5eD95",
+			"0x0A436EE2E4dEF3383Cf4546d4278326Ccc82514E",
+			"0x34229A215db8FeaC93Caf8B5B255e3c6eA51d855",
+			"0xEb3B7CF8B1840242CB98A732BA464a17D00b5dDF",
+			"0x2079692bf9ab2d6dc7D79BBDdEE71611E9aA3B72",
+			"0x46e2A67e5d450e2Cf7317779f8274a2a630f3C9B",
+			"0xA7Ece4A5390DAB18D08201aE18800375caD78aab",
+			"0x15E1c0D24D62057Bf082Cb2253dA11Ef0d469570",
+			"0xADDEF4C9b5687Eb1F7E55F2251916200A3598878",
+			"0xe0B16Fb96F936035db2b5A68EB37D470fED2f013",
+			"0x0c9A84993feaa779ae21E39F9793d09e6b69B62D",
+			"0x3bc4D5148906F70F0A7D1e2756572655fd8b7B34",
+			"0xFf4675C26903D5319795cbd3a44b109E7DDD9fDe",
+			"0xCec4450569A8945C6D2Aba0045e4339030128a92",
+			"0x85f0584B10950E421A32F471635b424063FD8405",
+			"0xb38bEe7Bdc0bC43c096e206EFdFEad63869929E3",
+			"0xc9609466274Fef19D0e58E1Ee3b321D5C141067E",
+			"0xa08EA868cF75268E7401021E9f945BAe73872ecc",
+			"0x67C9Cb1A29E964Fe87Ff669735cf7eb87f6868fE",
+			"0x1B6BEF636aFcdd6085cD4455BbcC93796A12F6E2",
+			"0x46B37b243E09540b55cF91C333188e7D5FD786dD",
+			"0x8E719E272f62Fa97da93CF9C941F5e53AA09e44a",
+			"0xa511B7E7DB9cb24AD5c89fBb6032C7a9c2EfA0a5",
+			"0x4D11FDcAeD335d839132AD450B02af974A3A66f8",
+			"0xB8cf790a5090E709B4619E1F335317114294E17E",
+			"0x7f0f57eA064A83210Cafd3a536866ffD2C5eDCB3",
+			"0xC03C848A4521356EF800e399D889e9c2A25D1f9E",
+			"0xC6b03DF05cb686D933DD31fCa5A993bF823dc4FE",
+			"0x58611696b6a8102cf95A32c25612E4cEF32b910F",
+			"0x2ed4bC7197AEF13560F6771D930Bf907772DE3CE",
+			"0x3C5E58f334306be029B0e47e119b8977B2639eb4",
+			"0x288646a1a4FeeC560B349d210263c609aDF649a6",
+			"0xb4F4981E0d027Dc2B3c86afA0D0fC03d317e83C0",
+			"0xaAE4A87F8058feDA3971f9DEd639Ec9189aA2500",
+			"0x355069DA35E598913d8736E5B8340527099960b8",
+			"0x3cf5A0F274cd243C0A186d9fCBdADad089821B93",
+			"0xca55155dCc4591538A8A0ca322a56EB0E4aD03C4",
+			"0xE824D0268366ec5C4F23652b8eD70D552B1F2b8B",
+			"0x84C3e9B25AE8a9b39FF5E331F9A597F2DCf27Ca9",
+			"0xcA0018e278751De10d26539915d9c7E7503432FE",
+			"0xf13077dE6191D6c1509ac7E088b8BE7Fe656c28b",
+			"0x7a6bcA1ec9Db506e47ac6FD86D001c2aBc59C531",
+			"0xeA7f9A2A9dd6Ba9bc93ca615C3Ddf26973146911",
+			"0x8D0d8577e16F8731d4F8712BAbFa97aF4c453458",
+			"0xB7a7855629dF104246997e9ACa0E6510df75d0ea",
+			"0x5C1009BDC70b0C8Ab2e5a53931672ab448C17c89",
+			"0x40B47D1AfefEF5eF41e0789F0285DE7b1C31631C",
+			"0x5086933d549cEcEB20652CE00973703CF10Da373",
+			"0xeb364f6FE356882F92ae9314fa96116Cf65F47d8",
+			"0xdC4D31516A416cEf533C01a92D9a04bbdb85EE67",
+			"0x9b36E086E5A274332AFd3D8509e12ca5F6af918d",
+			"0xBC26394fF36e1673aE0608ce91A53B9768aD0D76",
+			"0x81B5AB400be9e563fA476c100BE898C09966426c",
+			"0x9d93C8ae5793054D28278A5DE6d4653EC79e90FE",
+			"0x3B8E75804F71e121008991E3177fc942b6c28F50",
+			"0xC6Eb5886eB43dD473f5BB4e21e56E08dA464D9B4",
+			"0xfdf1277b71A73c813cD0e1a94B800f4B1Db66DBE",
+			"0xc2ff2cCc98971556670e287Ff0CC39DA795231ad",
+			"0x76b7E1473f0D0A87E9B4a14E2B179266802740f5",
+			"0xA7Bc965660a6EF4687CCa4F69A97563163A3C2Ef",
+			"0xB9C2b47888B9F8f7D03dC1de83F3F55E738CebD3",
+			"0xEd400162E6Dd6bD2271728FFb04176bF770De94a",
+			"0xE3E8331156700339142189B6E555DCb2c0962750",
+			"0xbf62e342Bc7706a448EdD52AE871d9C4497A53b1",
+			"0xb9d7A1A111eed75714a0AcD2dd467E872eE6B03D",
+			"0x03942919DFD0383b8c574AB8A701d89fd4bfA69D",
+			"0x0Ef4C92355D3c8c7050DFeb319790EFCcBE6fe9e",
+			"0xA6895a3cf0C60212a73B3891948ACEcF1753f25E",
+			"0x0Ed509239DB59ef3503ded3d31013C983d52803A",
+			"0xc4CE8abD123BfAFc4deFf37c7D11DeCd5c350EE4",
+			"0x4A4Bf59f7038eDcd8597004f35d7Ee24a7Bdd2d3",
+			"0x5769E8e8A2656b5ed6b6e6fa2a2bFAeaf970BB87",
+			"0xf9E15cCE181332F4F57386687c1776b66C377060",
+			"0xc98f8d4843D56a46C21171900d3eE538Cc74dbb5",
+			"0x3605965B47544Ce4302b988788B8195601AE4dEd",
+			"0xe993BDfdcAac2e65018efeE0F69A12678031c71d",
+			"0x274fDf8801385D3FAc954BCc1446Af45f5a8304c",
+			"0xBFb3f476fcD6429F4a475bA23cEFdDdd85c6b964",
+			"0x806cD16588Fe812ae740e931f95A289aFb4a4B50",
+			"0xa89488CE3bD9C25C3aF797D1bbE6CA689De79d81",
+			"0xd412f1AfAcf0Ebf3Cd324593A231Fc74CC488B12",
+			"0xd1f715b2D7951d54bc31210BbD41852D9BF98Ed1",
+			"0xf65aD707c344171F467b2ADba3d14f312219cE23",
+			"0x2971a4b242e9566dEF7bcdB7347f5E484E11919B",
+			"0x12b113D6827E07E7D426649fBd605f427da52314",
+			"0x1c6CA45171CDb9856A6C9Dba9c5F1216913C1e97",
+			"0x11cC6ee1d74963Db23294FCE1E3e0A0555779CeA",
+			"0x8Aa1C721255CDC8F895E4E4c782D86726b068667",
+			"0xA2cDC1f37510814485129aC6310b22dF04e9Bbf0",
+			"0xCf531b71d388EB3f5889F1f78E0d77f6fb109767",
+			"0xBe703e3545B2510979A0cb0C440C0Fba55c6dCB5",
+			"0x30a35886F989db39c797D8C93880180Fdd71b0c8",
+			"0x1071370D981F60c47A9Cd27ac0A61873a372cBB2",
+			"0x3515d74A11e0Cb65F0F46cB70ecf91dD1712daaa",
+			"0x50500a3c2b7b1229c6884505D00ac6Be29Aecd0C",
+			"0x9A223c2a11D4FD3585103B21B161a2B771aDA3d1",
+			"0xd7218df03AD0907e6c08E707B15d9BD14285e657",
+			"0x76CfD72eF5f93D1a44aD1F80856797fBE060c70a",
+			"0x44d093cB745944991EFF5cBa151AA6602d6f5420",
+			"0x626516DfF43bf09A71eb6fd1510E124F96ED0Cde",
+			"0x6530824632dfe099304E2DC5701cA99E6d031E08",
+			"0x57e6c423d6a7607160d6379A0c335025A14DaFC0",
+			"0x3966D4AD461Ef150E0B10163C81E79b9029E69c3",
+			"0xF608aCfd0C286E23721a3c347b2b65039f6690F1",
+			"0xbfB8FAac31A25646681936977837f7740fCd0072",
+			"0xd80aa634a623a7ED1F069a1a3A28a173061705c7",
+			"0x9122a77B36363e24e12E1E2D73F87b32926D3dF5",
+			"0x62562f0d1cD31315bCCf176049B6279B2bfc39C2",
+			"0x48aBF7A2a7119e5675059E27a7082ba7F38498b2",
+			"0xb4596983AB9A9166b29517acD634415807569e5F",
+			"0x52519D16E20BC8f5E96Da6d736963e85b2adA118",
+			"0x7663893C3dC0850EfC5391f5E5887eD723e51B83",
+			"0x5FF323a29bCC3B5b4B107e177EccEF4272959e61",
+			"0xee6e499AdDf4364D75c05D50d9344e9daA5A9AdF",
+			"0x1631b0BD31fF904aD67dD58994C6C2051CDe4E75",
+			"0xbc208e9723D44B9811C428f6A55722a26204eEF2",
+			"0xe76103a222Ee2C7Cf05B580858CEe625C4dc00E1",
+			"0xC71Bb2DBC51760f4fc2D46D84464410760971B8a",
+			"0xB4C18811e6BFe564D69E12c224FFc57351f7a7ff",
+			"0xD11DB0F5b41061A887cB7eE9c8711438844C298A",
+			"0xB931269934A3D4432c084bAAc3d0de8143199F4f",
+			"0x070037cc85C761946ec43ea2b8A2d5729908A2a1",
+			"0x2E34aa8C95Ffdbb37f14dCfBcA69291c55Ba48DE",
+			"0x052D93e8d9220787c31d6D83f87eC7dB088E998f",
+			"0x498dAC6C69b8b9ad645217050054840f1D91D029",
+			"0xE4F7D60f9d84301e1fFFd01385a585F3A11F8E89",
+			"0xEa637992f30eA06460732EDCBaCDa89355c2a107",
+			"0x4960d8Da07c27CB6Be48a79B96dD70657c57a6bF",
+			"0x7e471A003C8C9fdc8789Ded9C3dbe371d8aa0329",
+			"0xd24265Cc10eecb9e8d355CCc0dE4b11C556E74D7",
+			"0xDE59C8f7557Af779674f41CA2cA855d571018690",
+			"0x2fA8A6b3b6226d8efC9d8f6EBDc73Ca33DDcA4d8",
+			"0xe44102664c6c2024673Ff07DFe66E187Db77c65f",
+			"0x94E3f4f90a5f7CBF2cc2623e66B8583248F01022",
+			"0x0383EdBbc21D73DEd039E9C1Ff6bf56017b4CC40",
+			"0x64C3E49898B88d1E0f0d02DA23E0c00A2Cd0cA99",
+			"0xF4ccfB67b938d82B70bAb20975acFAe402E812E1",
+			"0x4f9ee5829e9852E32E7BC154D02c91D8E203e074",
+			"0xb006312eF9713463bB33D22De60444Ba95609f6B",
+			"0x7Cbe76ef69B52110DDb2e3b441C04dDb11D63248",
+			"0x70ADEEa65488F439392B869b1Df7241EF317e221",
+			"0x64C0bf8AA36Ba590477585Bc0D2BDa7970769463",
+			"0xA4cDc98593CE52d01Fe5Ca47CB3dA5320e0D7592",
+			"0xc26B34D375533fFc4c5276282Fa5D660F3d8cbcB",
+		];
+		let root: H256 = array_bytes::hex2array_unchecked(
+			"72b0acd7c302a84f1f6b6cefe0ba7194b7398afb440e1b44a9dbbe270394ca53",
+		)
+		.into();
+
+		let data = addresses
+			.into_iter()
+			.map(|address| array_bytes::hex2bytes_unchecked(&address))
+			.collect::<Vec<_>>();
+
+		for l in 0..data.len() {
+			// when
+			let proof = merkle_proof::<Keccak256, _, _>(data.clone(), l);
+			assert_eq!(array_bytes::bytes2hex("", &proof.root), array_bytes::bytes2hex("", &root));
+			assert_eq!(proof.leaf_index, l);
+			assert_eq!(&proof.leaf, &data[l]);
+
+			// then
+			assert!(verify_proof::<Keccak256, _, _>(
+				&proof.root,
+				proof.proof,
+				data.len(),
+				proof.leaf_index,
+				&proof.leaf
+			));
+		}
+
+		let proof = merkle_proof::<Keccak256, _, _>(data.clone(), data.len() - 1);
+
+		assert_eq!(
+			proof,
+			MerkleProof {
+				root,
+				proof: vec![
+					array_bytes::hex2array_unchecked(
+						"340bcb1d49b2d82802ddbcf5b85043edb3427b65d09d7f758fbc76932ad2da2f"
+					)
+					.into(),
+					array_bytes::hex2array_unchecked(
+						"ba0580e5bd530bc93d61276df7969fb5b4ae8f1864b4a28c280249575198ff1f"
+					)
+					.into(),
+					array_bytes::hex2array_unchecked(
+						"d02609d2bbdb28aa25f58b85afec937d5a4c85d37925bce6d0cf802f9d76ba79"
+					)
+					.into(),
+					array_bytes::hex2array_unchecked(
+						"ae3f8991955ed884613b0a5f40295902eea0e0abe5858fc520b72959bc016d4e"
+					)
+					.into(),
+				],
+				number_of_leaves: data.len(),
+				leaf_index: data.len() - 1,
+				leaf: array_bytes::hex2array_unchecked::<_, 20>(
+					"c26B34D375533fFc4c5276282Fa5D660F3d8cbcB"
+				)
+				.to_vec(),
+			}
+		);
+	}
+}
diff --git a/substrate/utils/build-script-utils/Cargo.toml b/substrate/utils/build-script-utils/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..35096f282ef0ca25f04cc27def334d30f2d8d7a3
--- /dev/null
+++ b/substrate/utils/build-script-utils/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "substrate-build-script-utils"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Crate with utility functions for `build.rs` scripts."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
diff --git a/substrate/utils/build-script-utils/README.md b/substrate/utils/build-script-utils/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..1c184f67326e3c3170b1a92767deffbdcbfa9c70
--- /dev/null
+++ b/substrate/utils/build-script-utils/README.md
@@ -0,0 +1,3 @@
+Crate with utility functions for `build.rs` scripts.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/utils/build-script-utils/src/git.rs b/substrate/utils/build-script-utils/src/git.rs
new file mode 100644
index 0000000000000000000000000000000000000000..057ee0af15f7623ba7e9fddbd799dc75f6605e1a
--- /dev/null
+++ b/substrate/utils/build-script-utils/src/git.rs
@@ -0,0 +1,125 @@
+// 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 std::{env, fs, fs::File, io, io::Read, path::PathBuf};
+
+/// Make sure the calling `build.rs` script is rerun when `.git/HEAD` or the ref of `.git/HEAD`
+/// changed.
+///
+/// The file is searched from the `CARGO_MANIFEST_DIR` upwards. If the file can not be found,
+/// a warning is generated.
+pub fn rerun_if_git_head_changed() {
+	let mut manifest_dir = PathBuf::from(
+		env::var("CARGO_MANIFEST_DIR").expect("`CARGO_MANIFEST_DIR` is always set by cargo."),
+	);
+	let manifest_dir_copy = manifest_dir.clone();
+
+	while manifest_dir.parent().is_some() {
+		match get_git_paths(&manifest_dir) {
+			Err(err) => {
+				eprintln!("cargo:warning=Unable to read the Git repository: {}", err);
+
+				return
+			},
+			Ok(None) => {},
+			Ok(Some(paths)) => {
+				for p in paths {
+					println!("cargo:rerun-if-changed={}", p.display());
+				}
+
+				return
+			},
+		}
+
+		manifest_dir.pop();
+	}
+
+	println!(
+		"cargo:warning=Could not find `.git/HEAD` searching from `{}` upwards!",
+		manifest_dir_copy.display(),
+	);
+}
+
+// Code taken from https://github.com/rustyhorde/vergen/blob/8d522db8c8e16e26c0fc9ea8e6b0247cbf5cca84/src/output/envvar.rs
+fn get_git_paths(path: &PathBuf) -> Result<Option<Vec<PathBuf>>, io::Error> {
+	let git_dir_or_file = path.join(".git");
+
+	if let Ok(metadata) = fs::metadata(&git_dir_or_file) {
+		if metadata.is_dir() {
+			// Echo the HEAD path
+			let git_head_path = git_dir_or_file.join("HEAD");
+
+			// Determine where HEAD points and echo that path also.
+			let mut f = File::open(&git_head_path)?;
+			let mut git_head_contents = String::new();
+			let _ = f.read_to_string(&mut git_head_contents)?;
+			let ref_vec: Vec<&str> = git_head_contents.split(": ").collect();
+
+			if ref_vec.len() == 2 {
+				let current_head_file = ref_vec[1];
+				let git_refs_path = git_dir_or_file.join(current_head_file);
+
+				Ok(Some(vec![git_head_path, git_refs_path]))
+			} else {
+				Err(io::Error::new(
+					io::ErrorKind::Other,
+					"You are most likely in a detached HEAD state",
+				))
+			}
+		} else if metadata.is_file() {
+			// We are in a worktree, so find out where the actual worktrees/<name>/HEAD file is.
+			let mut git_file = File::open(&git_dir_or_file)?;
+			let mut git_contents = String::new();
+			let _ = git_file.read_to_string(&mut git_contents)?;
+			let dir_vec: Vec<&str> = git_contents.split(": ").collect();
+			let git_path = dir_vec[1].trim();
+
+			// Echo the HEAD psth
+			let git_head_path = PathBuf::from(git_path).join("HEAD");
+
+			// Find out what the full path to the .git dir is.
+			let mut actual_git_dir = PathBuf::from(git_path);
+			actual_git_dir.pop();
+			actual_git_dir.pop();
+
+			// Determine where HEAD points and echo that path also.
+			let mut f = File::open(&git_head_path)?;
+			let mut git_head_contents = String::new();
+			let _ = f.read_to_string(&mut git_head_contents)?;
+			let ref_vec: Vec<&str> = git_head_contents.split(": ").collect();
+
+			if ref_vec.len() == 2 {
+				let current_head_file = ref_vec[1];
+				let git_refs_path = actual_git_dir.join(current_head_file);
+
+				Ok(Some(vec![git_head_path, git_refs_path]))
+			} else {
+				Err(io::Error::new(
+					io::ErrorKind::Other,
+					"You are most likely in a detached HEAD state",
+				))
+			}
+		} else {
+			Err(io::Error::new(
+				io::ErrorKind::Other,
+				"Invalid .git format (Not a directory or a file)",
+			))
+		}
+	} else {
+		Ok(None)
+	}
+}
diff --git a/substrate/utils/build-script-utils/src/lib.rs b/substrate/utils/build-script-utils/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7bab35c9879eca634f4e45012acf90227661523d
--- /dev/null
+++ b/substrate/utils/build-script-utils/src/lib.rs
@@ -0,0 +1,24 @@
+// 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.
+
+//! Crate with utility functions for `build.rs` scripts.
+
+mod git;
+mod version;
+
+pub use git::*;
+pub use version::*;
diff --git a/substrate/utils/build-script-utils/src/version.rs b/substrate/utils/build-script-utils/src/version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4ee5376ed322d1a3fc3b1d5eb1677f4f93a3a3ea
--- /dev/null
+++ b/substrate/utils/build-script-utils/src/version.rs
@@ -0,0 +1,56 @@
+// 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 std::{borrow::Cow, process::Command};
+
+/// Generate the `cargo:` key output
+pub fn generate_cargo_keys() {
+	let commit = if let Ok(hash) = std::env::var("SUBSTRATE_CLI_GIT_COMMIT_HASH") {
+		Cow::from(hash.trim().to_owned())
+	} else {
+		// We deliberately set the length here to `11` to ensure that
+		// the emitted hash is always of the same length; otherwise
+		// it can (and will!) vary between different build environments.
+		match Command::new("git").args(&["rev-parse", "--short=11", "HEAD"]).output() {
+			Ok(o) if o.status.success() => {
+				let sha = String::from_utf8_lossy(&o.stdout).trim().to_owned();
+				Cow::from(sha)
+			},
+			Ok(o) => {
+				println!("cargo:warning=Git command failed with status: {}", o.status);
+				Cow::from("unknown")
+			},
+			Err(err) => {
+				println!("cargo:warning=Failed to execute git command: {}", err);
+				Cow::from("unknown")
+			},
+		}
+	};
+
+	println!("cargo:rustc-env=SUBSTRATE_CLI_IMPL_VERSION={}", get_version(&commit))
+}
+
+fn get_version(impl_commit: &str) -> String {
+	let commit_dash = if impl_commit.is_empty() { "" } else { "-" };
+
+	format!(
+		"{}{}{}",
+		std::env::var("CARGO_PKG_VERSION").unwrap_or_default(),
+		commit_dash,
+		impl_commit
+	)
+}
diff --git a/substrate/utils/fork-tree/Cargo.toml b/substrate/utils/fork-tree/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ece7cac8fd3080afac27bfdc7e9ac5f6a32c0587
--- /dev/null
+++ b/substrate/utils/fork-tree/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "fork-tree"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Utility library for managing tree-like ordered data with logic for pruning the tree while finalizing nodes."
+documentation = "https://docs.rs/fork-tree"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] }
diff --git a/substrate/utils/fork-tree/README.md b/substrate/utils/fork-tree/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fef7db57f68f21ed590bc6df8e3a3444dc544476
--- /dev/null
+++ b/substrate/utils/fork-tree/README.md
@@ -0,0 +1,4 @@
+Utility library for managing tree-like ordered data with logic for pruning
+the tree while finalizing nodes.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/utils/fork-tree/src/lib.rs b/substrate/utils/fork-tree/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..cd175166b9cdf4129b4718592dc2277b8c78103f
--- /dev/null
+++ b/substrate/utils/fork-tree/src/lib.rs
@@ -0,0 +1,1609 @@
+// 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.
+
+//! Utility library for managing tree-like ordered data with logic for pruning
+//! the tree while finalizing nodes.
+
+#![warn(missing_docs)]
+
+use codec::{Decode, Encode};
+use std::{cmp::Reverse, fmt};
+
+/// Error occurred when iterating with the tree.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Error<E> {
+	/// Adding duplicate node to tree.
+	Duplicate,
+	/// Finalizing descendent of tree node without finalizing ancestor(s).
+	UnfinalizedAncestor,
+	/// Imported or finalized node that is an ancestor of previously finalized node.
+	Revert,
+	/// Error thrown by user when checking for node ancestry.
+	Client(E),
+}
+
+impl<E: std::error::Error> fmt::Display for Error<E> {
+	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		let message = match *self {
+			Error::Duplicate => "Hash already exists in Tree".into(),
+			Error::UnfinalizedAncestor => "Finalized descendent of Tree node without finalizing its ancestor(s) first".into(),
+			Error::Revert => "Tried to import or finalize node that is an ancestor of a previously finalized node".into(),
+			Error::Client(ref err) => format!("Client error: {}", err),
+		};
+		write!(f, "{}", message)
+	}
+}
+
+impl<E: std::error::Error> std::error::Error for Error<E> {}
+
+impl<E: std::error::Error> From<E> for Error<E> {
+	fn from(err: E) -> Error<E> {
+		Error::Client(err)
+	}
+}
+
+/// Result of finalizing a node (that could be a part of the tree or not).
+#[derive(Debug, PartialEq)]
+pub enum FinalizationResult<V> {
+	/// The tree has changed, optionally return the value associated with the finalized node.
+	Changed(Option<V>),
+	/// The tree has not changed.
+	Unchanged,
+}
+
+/// Filtering action.
+#[derive(Debug, PartialEq)]
+pub enum FilterAction {
+	/// Remove the node and its subtree.
+	Remove,
+	/// Maintain the node.
+	KeepNode,
+	/// Maintain the node and its subtree.
+	KeepTree,
+}
+
+/// A tree data structure that stores several nodes across multiple branches.
+///
+/// Top-level branches are called roots. The tree has functionality for
+/// finalizing nodes, which means that node is traversed, and all competing
+/// branches are pruned. It also guarantees that nodes in the tree are finalized
+/// in order. Each node is uniquely identified by its hash but can be ordered by
+/// its number. In order to build the tree an external function must be provided
+/// when interacting with the tree to establish a node's ancestry.
+#[derive(Clone, Debug, Decode, Encode, PartialEq)]
+pub struct ForkTree<H, N, V> {
+	roots: Vec<Node<H, N, V>>,
+	best_finalized_number: Option<N>,
+}
+
+impl<H, N, V> ForkTree<H, N, V>
+where
+	H: PartialEq,
+	N: Ord,
+{
+	/// Create a new empty tree instance.
+	pub fn new() -> ForkTree<H, N, V> {
+		ForkTree { roots: Vec::new(), best_finalized_number: None }
+	}
+
+	/// Rebalance the tree.
+	///
+	/// For each tree level sort child nodes by max branch depth (decreasing).
+	///
+	/// Most operations in the tree are performed with depth-first search
+	/// starting from the leftmost node at every level, since this tree is meant
+	/// to be used in a blockchain context, a good heuristic is that the node
+	/// we'll be looking for at any point will likely be in one of the deepest chains
+	/// (i.e. the longest ones).
+	pub fn rebalance(&mut self) {
+		self.roots.sort_by_key(|n| Reverse(n.max_depth()));
+		let mut stack: Vec<_> = self.roots.iter_mut().collect();
+		while let Some(node) = stack.pop() {
+			node.children.sort_by_key(|n| Reverse(n.max_depth()));
+			stack.extend(node.children.iter_mut());
+		}
+	}
+
+	/// Import a new node into the tree.
+	///
+	/// The given function `is_descendent_of` should return `true` if the second
+	/// hash (target) is a descendent of the first hash (base).
+	///
+	/// This method assumes that nodes in the same branch are imported in order.
+	///
+	/// Returns `true` if the imported node is a root.
+	// WARNING: some users of this method (i.e. consensus epoch changes tree) currently silently
+	// rely on a **post-order DFS** traversal. If we are using instead a top-down traversal method
+	// then the `is_descendent_of` closure, when used after a warp-sync, may end up querying the
+	// backend for a block (the one corresponding to the root) that is not present and thus will
+	// return a wrong result.
+	pub fn import<F, E>(
+		&mut self,
+		hash: H,
+		number: N,
+		data: V,
+		is_descendent_of: &F,
+	) -> Result<bool, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+	{
+		if let Some(ref best_finalized_number) = self.best_finalized_number {
+			if number <= *best_finalized_number {
+				return Err(Error::Revert)
+			}
+		}
+
+		let (children, is_root) =
+			match self.find_node_where_mut(&hash, &number, is_descendent_of, &|_| true)? {
+				Some(parent) => (&mut parent.children, false),
+				None => (&mut self.roots, true),
+			};
+
+		if children.iter().any(|elem| elem.hash == hash) {
+			return Err(Error::Duplicate)
+		}
+
+		children.push(Node { data, hash, number, children: Default::default() });
+
+		if children.len() == 1 {
+			// Rebalance may be required only if we've extended the branch depth.
+			self.rebalance();
+		}
+
+		Ok(is_root)
+	}
+
+	/// Iterates over the existing roots in the tree.
+	pub fn roots(&self) -> impl Iterator<Item = (&H, &N, &V)> {
+		self.roots.iter().map(|node| (&node.hash, &node.number, &node.data))
+	}
+
+	fn node_iter(&self) -> impl Iterator<Item = &Node<H, N, V>> {
+		// we need to reverse the order of roots to maintain the expected
+		// ordering since the iterator uses a stack to track state.
+		ForkTreeIterator { stack: self.roots.iter().rev().collect() }
+	}
+
+	/// Iterates the nodes in the tree in pre-order.
+	pub fn iter(&self) -> impl Iterator<Item = (&H, &N, &V)> {
+		self.node_iter().map(|node| (&node.hash, &node.number, &node.data))
+	}
+
+	/// Map fork tree into values of new types.
+	///
+	/// Tree traversal technique (e.g. BFS vs DFS) is left as not specified and
+	/// may be subject to change in the future. In other words, your predicates
+	/// should not rely on the observed traversal technique currently in use.
+	pub fn map<VT, F>(self, f: &mut F) -> ForkTree<H, N, VT>
+	where
+		F: FnMut(&H, &N, V) -> VT,
+	{
+		let mut queue: Vec<_> =
+			self.roots.into_iter().rev().map(|node| (usize::MAX, node)).collect();
+		let mut next_queue = Vec::new();
+		let mut output = Vec::new();
+
+		while !queue.is_empty() {
+			for (parent_index, node) in queue.drain(..) {
+				let new_data = f(&node.hash, &node.number, node.data);
+				let new_node = Node {
+					hash: node.hash,
+					number: node.number,
+					data: new_data,
+					children: Vec::with_capacity(node.children.len()),
+				};
+
+				let node_id = output.len();
+				output.push((parent_index, new_node));
+
+				for child in node.children.into_iter().rev() {
+					next_queue.push((node_id, child));
+				}
+			}
+
+			std::mem::swap(&mut queue, &mut next_queue);
+		}
+
+		let mut roots = Vec::new();
+		while let Some((parent_index, new_node)) = output.pop() {
+			if parent_index == usize::MAX {
+				roots.push(new_node);
+			} else {
+				output[parent_index].1.children.push(new_node);
+			}
+		}
+
+		ForkTree { roots, best_finalized_number: self.best_finalized_number }
+	}
+
+	/// Find a node in the tree that is the deepest ancestor of the given
+	/// block hash and which passes the given predicate.
+	///
+	/// The given function `is_descendent_of` should return `true` if the
+	/// second hash (target) is a descendent of the first hash (base).
+	pub fn find_node_where<F, E, P>(
+		&self,
+		hash: &H,
+		number: &N,
+		is_descendent_of: &F,
+		predicate: &P,
+	) -> Result<Option<&Node<H, N, V>>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+		P: Fn(&V) -> bool,
+	{
+		let maybe_path = self.find_node_index_where(hash, number, is_descendent_of, predicate)?;
+		Ok(maybe_path.map(|path| {
+			let children =
+				path.iter().take(path.len() - 1).fold(&self.roots, |curr, &i| &curr[i].children);
+			&children[path[path.len() - 1]]
+		}))
+	}
+
+	/// Same as [`find_node_where`](ForkTree::find_node_where), but returns mutable reference.
+	pub fn find_node_where_mut<F, E, P>(
+		&mut self,
+		hash: &H,
+		number: &N,
+		is_descendent_of: &F,
+		predicate: &P,
+	) -> Result<Option<&mut Node<H, N, V>>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+		P: Fn(&V) -> bool,
+	{
+		let maybe_path = self.find_node_index_where(hash, number, is_descendent_of, predicate)?;
+		Ok(maybe_path.map(|path| {
+			let children = path
+				.iter()
+				.take(path.len() - 1)
+				.fold(&mut self.roots, |curr, &i| &mut curr[i].children);
+			&mut children[path[path.len() - 1]]
+		}))
+	}
+
+	/// Same as [`find_node_where`](ForkTree::find_node_where), but returns indices.
+	///
+	/// The returned indices represent the full path to reach the matching node starting
+	/// from one of the roots, i.e. the earliest index in the traverse path goes first,
+	/// and the final index in the traverse path goes last.
+	///
+	/// If a node is found that matches the predicate the returned path should always
+	/// contain at least one index, otherwise `None` is returned.
+	//
+	// WARNING: some users of this method (i.e. consensus epoch changes tree) currently silently
+	// rely on a **post-order DFS** traversal. If we are using instead a top-down traversal method
+	// then the `is_descendent_of` closure, when used after a warp-sync, will end up querying the
+	// backend for a block (the one corresponding to the root) that is not present and thus will
+	// return a wrong result.
+	pub fn find_node_index_where<F, E, P>(
+		&self,
+		hash: &H,
+		number: &N,
+		is_descendent_of: &F,
+		predicate: &P,
+	) -> Result<Option<Vec<usize>>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+		P: Fn(&V) -> bool,
+	{
+		let mut stack = vec![];
+		let mut root_idx = 0;
+		let mut found = false;
+		let mut is_descendent = false;
+
+		while root_idx < self.roots.len() {
+			if *number <= self.roots[root_idx].number {
+				root_idx += 1;
+				continue
+			}
+			// The second element in the stack tuple tracks what is the **next** children
+			// index to search into. If we find an ancestor then we stop searching into
+			// alternative branches and we focus on the current path up to the root.
+			stack.push((&self.roots[root_idx], 0));
+			while let Some((node, i)) = stack.pop() {
+				if i < node.children.len() && !is_descendent {
+					stack.push((node, i + 1));
+					if node.children[i].number < *number {
+						stack.push((&node.children[i], 0));
+					}
+				} else if is_descendent || is_descendent_of(&node.hash, hash)? {
+					is_descendent = true;
+					if predicate(&node.data) {
+						found = true;
+						break
+					}
+				}
+			}
+
+			// If the element we are looking for is a descendent of the current root
+			// then we can stop the search.
+			if is_descendent {
+				break
+			}
+			root_idx += 1;
+		}
+
+		Ok(if found {
+			// The path is the root index followed by the indices of all the children
+			// we were processing when we found the element (remember the stack
+			// contains the index of the **next** children to process).
+			let path: Vec<_> =
+				std::iter::once(root_idx).chain(stack.iter().map(|(_, i)| *i - 1)).collect();
+			Some(path)
+		} else {
+			None
+		})
+	}
+
+	/// Prune the tree, removing all non-canonical nodes.
+	///
+	/// We find the node in the tree that is the deepest ancestor of the given hash
+	/// and that passes the given predicate. If such a node exists, we re-root the
+	/// tree to this node. Otherwise the tree remains unchanged.
+	///
+	/// The given function `is_descendent_of` should return `true` if the second
+	/// hash (target) is a descendent of the first hash (base).
+	///
+	/// Returns all pruned nodes data.
+	pub fn prune<F, E, P>(
+		&mut self,
+		hash: &H,
+		number: &N,
+		is_descendent_of: &F,
+		predicate: &P,
+	) -> Result<impl Iterator<Item = (H, N, V)>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+		P: Fn(&V) -> bool,
+	{
+		let new_root_path =
+			match self.find_node_index_where(hash, number, is_descendent_of, predicate)? {
+				Some(path) => path,
+				None => return Ok(RemovedIterator { stack: Vec::new() }),
+			};
+
+		let mut removed = std::mem::take(&mut self.roots);
+
+		// Find and detach the new root from the removed nodes
+		let root_siblings = new_root_path
+			.iter()
+			.take(new_root_path.len() - 1)
+			.fold(&mut removed, |curr, idx| &mut curr[*idx].children);
+		let root = root_siblings.remove(new_root_path[new_root_path.len() - 1]);
+		self.roots = vec![root];
+
+		// If, because of the `predicate`, the new root is not the deepest ancestor
+		// of `hash` then we can remove all the nodes that are descendants of the new
+		// `root` but not ancestors of `hash`.
+		let mut curr = &mut self.roots[0];
+		loop {
+			let mut maybe_ancestor_idx = None;
+			for (idx, child) in curr.children.iter().enumerate() {
+				if child.number < *number && is_descendent_of(&child.hash, hash)? {
+					maybe_ancestor_idx = Some(idx);
+					break
+				}
+			}
+			let Some(ancestor_idx) = maybe_ancestor_idx else {
+				// Now we are positioned just above block identified by `hash`
+				break
+			};
+			// Preserve only the ancestor node, the siblings are removed
+			let mut next_siblings = std::mem::take(&mut curr.children);
+			let next = next_siblings.remove(ancestor_idx);
+			curr.children = vec![next];
+			removed.append(&mut next_siblings);
+			curr = &mut curr.children[0];
+		}
+
+		// Curr now points to our direct ancestor, if necessary remove any node that is
+		// not a descendant of `hash`.
+		let children = std::mem::take(&mut curr.children);
+		for child in children {
+			if child.number == *number && child.hash == *hash ||
+				*number < child.number && is_descendent_of(hash, &child.hash)?
+			{
+				curr.children.push(child);
+			} else {
+				removed.push(child);
+			}
+		}
+
+		self.rebalance();
+
+		Ok(RemovedIterator { stack: removed })
+	}
+
+	/// Finalize a root in the tree and return it, return `None` in case no root
+	/// with the given hash exists. All other roots are pruned, and the children
+	/// of the finalized node become the new roots.
+	pub fn finalize_root(&mut self, hash: &H) -> Option<V> {
+		self.roots
+			.iter()
+			.position(|node| node.hash == *hash)
+			.map(|position| self.finalize_root_at(position))
+	}
+
+	/// Finalize root at given position. See `finalize_root` comment for details.
+	fn finalize_root_at(&mut self, position: usize) -> V {
+		let node = self.roots.swap_remove(position);
+		self.roots = node.children;
+		self.best_finalized_number = Some(node.number);
+		node.data
+	}
+
+	/// Finalize a node in the tree. This method will make sure that the node
+	/// being finalized is either an existing root (and return its data), or a
+	/// node from a competing branch (not in the tree), tree pruning is done
+	/// accordingly. The given function `is_descendent_of` should return `true`
+	/// if the second hash (target) is a descendent of the first hash (base).
+	pub fn finalize<F, E>(
+		&mut self,
+		hash: &H,
+		number: N,
+		is_descendent_of: &F,
+	) -> Result<FinalizationResult<V>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+	{
+		if let Some(ref best_finalized_number) = self.best_finalized_number {
+			if number <= *best_finalized_number {
+				return Err(Error::Revert)
+			}
+		}
+
+		// check if one of the current roots is being finalized
+		if let Some(root) = self.finalize_root(hash) {
+			return Ok(FinalizationResult::Changed(Some(root)))
+		}
+
+		// make sure we're not finalizing a descendent of any root
+		for root in self.roots.iter() {
+			if number > root.number && is_descendent_of(&root.hash, hash)? {
+				return Err(Error::UnfinalizedAncestor)
+			}
+		}
+
+		// we finalized a block earlier than any existing root (or possibly
+		// another fork not part of the tree). make sure to only keep roots that
+		// are part of the finalized branch
+		let mut changed = false;
+		let roots = std::mem::take(&mut self.roots);
+
+		for root in roots {
+			if root.number > number && is_descendent_of(hash, &root.hash)? {
+				self.roots.push(root);
+			} else {
+				changed = true;
+			}
+		}
+
+		self.best_finalized_number = Some(number);
+
+		if changed {
+			Ok(FinalizationResult::Changed(None))
+		} else {
+			Ok(FinalizationResult::Unchanged)
+		}
+	}
+
+	/// Finalize a node in the tree and all its ancestors. The given function
+	/// `is_descendent_of` should return `true` if the second hash (target) is
+	// a descendent of the first hash (base).
+	pub fn finalize_with_ancestors<F, E>(
+		&mut self,
+		hash: &H,
+		number: N,
+		is_descendent_of: &F,
+	) -> Result<FinalizationResult<V>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+	{
+		if let Some(ref best_finalized_number) = self.best_finalized_number {
+			if number <= *best_finalized_number {
+				return Err(Error::Revert)
+			}
+		}
+
+		// check if one of the current roots is being finalized
+		if let Some(root) = self.finalize_root(hash) {
+			return Ok(FinalizationResult::Changed(Some(root)))
+		}
+
+		// we need to:
+		// 1) remove all roots that are not ancestors AND not descendants of finalized block;
+		// 2) if node is descendant - just leave it;
+		// 3) if node is ancestor - 'open it'
+		let mut changed = false;
+		let mut idx = 0;
+		while idx != self.roots.len() {
+			let (is_finalized, is_descendant, is_ancestor) = {
+				let root = &self.roots[idx];
+				let is_finalized = root.hash == *hash;
+				let is_descendant =
+					!is_finalized && root.number > number && is_descendent_of(hash, &root.hash)?;
+				let is_ancestor = !is_finalized &&
+					!is_descendant && root.number < number &&
+					is_descendent_of(&root.hash, hash)?;
+				(is_finalized, is_descendant, is_ancestor)
+			};
+
+			// if we have met finalized root - open it and return
+			if is_finalized {
+				return Ok(FinalizationResult::Changed(Some(self.finalize_root_at(idx))))
+			}
+
+			// if node is descendant of finalized block - just leave it as is
+			if is_descendant {
+				idx += 1;
+				continue
+			}
+
+			// if node is ancestor of finalized block - remove it and continue with children
+			if is_ancestor {
+				let root = self.roots.swap_remove(idx);
+				self.roots.extend(root.children);
+				changed = true;
+				continue
+			}
+
+			// if node is neither ancestor, nor descendant of the finalized block - remove it
+			self.roots.swap_remove(idx);
+			changed = true;
+		}
+
+		self.best_finalized_number = Some(number);
+
+		if changed {
+			Ok(FinalizationResult::Changed(None))
+		} else {
+			Ok(FinalizationResult::Unchanged)
+		}
+	}
+
+	/// Checks if any node in the tree is finalized by either finalizing the
+	/// node itself or a node's descendent that's not in the tree, guaranteeing
+	/// that the node being finalized isn't a descendent of (or equal to) any of
+	/// the node's children. Returns `Some(true)` if the node being finalized is
+	/// a root, `Some(false)` if the node being finalized is not a root, and
+	/// `None` if no node in the tree is finalized. The given `predicate` is
+	/// checked on the prospective finalized root and must pass for finalization
+	/// to occur. The given function `is_descendent_of` should return `true` if
+	/// the second hash (target) is a descendent of the first hash (base).
+	pub fn finalizes_any_with_descendent_if<F, P, E>(
+		&self,
+		hash: &H,
+		number: N,
+		is_descendent_of: &F,
+		predicate: P,
+	) -> Result<Option<bool>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+		P: Fn(&V) -> bool,
+	{
+		if let Some(ref best_finalized_number) = self.best_finalized_number {
+			if number <= *best_finalized_number {
+				return Err(Error::Revert)
+			}
+		}
+
+		// check if the given hash is equal or a descendent of any node in the
+		// tree, if we find a valid node that passes the predicate then we must
+		// ensure that we're not finalizing past any of its child nodes.
+		for node in self.node_iter() {
+			if predicate(&node.data) && (node.hash == *hash || is_descendent_of(&node.hash, hash)?)
+			{
+				for child in node.children.iter() {
+					if child.number <= number &&
+						(child.hash == *hash || is_descendent_of(&child.hash, hash)?)
+					{
+						return Err(Error::UnfinalizedAncestor)
+					}
+				}
+
+				return Ok(Some(self.roots.iter().any(|root| root.hash == node.hash)))
+			}
+		}
+
+		Ok(None)
+	}
+
+	/// Finalize a root in the tree by either finalizing the node itself or a
+	/// node's descendent that's not in the tree, guaranteeing that the node
+	/// being finalized isn't a descendent of (or equal to) any of the root's
+	/// children. The given `predicate` is checked on the prospective finalized
+	/// root and must pass for finalization to occur. The given function
+	/// `is_descendent_of` should return `true` if the second hash (target) is a
+	/// descendent of the first hash (base).
+	pub fn finalize_with_descendent_if<F, P, E>(
+		&mut self,
+		hash: &H,
+		number: N,
+		is_descendent_of: &F,
+		predicate: P,
+	) -> Result<FinalizationResult<V>, Error<E>>
+	where
+		E: std::error::Error,
+		F: Fn(&H, &H) -> Result<bool, E>,
+		P: Fn(&V) -> bool,
+	{
+		if let Some(ref best_finalized_number) = self.best_finalized_number {
+			if number <= *best_finalized_number {
+				return Err(Error::Revert)
+			}
+		}
+
+		// check if the given hash is equal or a a descendent of any root, if we
+		// find a valid root that passes the predicate then we must ensure that
+		// we're not finalizing past any children node.
+		let mut position = None;
+		for (i, root) in self.roots.iter().enumerate() {
+			if predicate(&root.data) && (root.hash == *hash || is_descendent_of(&root.hash, hash)?)
+			{
+				for child in root.children.iter() {
+					if child.number <= number &&
+						(child.hash == *hash || is_descendent_of(&child.hash, hash)?)
+					{
+						return Err(Error::UnfinalizedAncestor)
+					}
+				}
+
+				position = Some(i);
+				break
+			}
+		}
+
+		let node_data = position.map(|i| {
+			let node = self.roots.swap_remove(i);
+			self.roots = node.children;
+			self.best_finalized_number = Some(node.number);
+			node.data
+		});
+
+		// Retain only roots that are descendents of the finalized block (this
+		// happens if the node has been properly finalized) or that are
+		// ancestors (or equal) to the finalized block (in this case the node
+		// wasn't finalized earlier presumably because the predicate didn't
+		// pass).
+		let mut changed = false;
+		let roots = std::mem::take(&mut self.roots);
+
+		for root in roots {
+			let retain = root.number > number && is_descendent_of(hash, &root.hash)? ||
+				root.number == number && root.hash == *hash ||
+				is_descendent_of(&root.hash, hash)?;
+
+			if retain {
+				self.roots.push(root);
+			} else {
+				changed = true;
+			}
+		}
+
+		self.best_finalized_number = Some(number);
+
+		match (node_data, changed) {
+			(Some(data), _) => Ok(FinalizationResult::Changed(Some(data))),
+			(None, true) => Ok(FinalizationResult::Changed(None)),
+			(None, false) => Ok(FinalizationResult::Unchanged),
+		}
+	}
+
+	/// Remove from the tree some nodes (and their subtrees) using a `filter` predicate.
+	///
+	/// The `filter` is called over tree nodes and returns a filter action:
+	/// - `Remove` if the node and its subtree should be removed;
+	/// - `KeepNode` if we should maintain the node and keep processing the tree.
+	/// - `KeepTree` if we should maintain the node and its entire subtree.
+	///
+	/// An iterator over all the pruned nodes is returned.
+	pub fn drain_filter<F>(&mut self, filter: F) -> impl Iterator<Item = (H, N, V)>
+	where
+		F: Fn(&H, &N, &V) -> FilterAction,
+	{
+		let mut removed = vec![];
+		let mut retained = Vec::new();
+
+		let mut queue: Vec<_> = std::mem::take(&mut self.roots)
+			.into_iter()
+			.rev()
+			.map(|node| (usize::MAX, node))
+			.collect();
+		let mut next_queue = Vec::new();
+
+		while !queue.is_empty() {
+			for (parent_idx, mut node) in queue.drain(..) {
+				match filter(&node.hash, &node.number, &node.data) {
+					FilterAction::KeepNode => {
+						let node_idx = retained.len();
+						let children = std::mem::take(&mut node.children);
+						retained.push((parent_idx, node));
+						for child in children.into_iter().rev() {
+							next_queue.push((node_idx, child));
+						}
+					},
+					FilterAction::KeepTree => {
+						retained.push((parent_idx, node));
+					},
+					FilterAction::Remove => {
+						removed.push(node);
+					},
+				}
+			}
+
+			std::mem::swap(&mut queue, &mut next_queue);
+		}
+
+		while let Some((parent_idx, node)) = retained.pop() {
+			if parent_idx == usize::MAX {
+				self.roots.push(node);
+			} else {
+				retained[parent_idx].1.children.push(node);
+			}
+		}
+
+		if !removed.is_empty() {
+			self.rebalance();
+		}
+		RemovedIterator { stack: removed }
+	}
+}
+
+// Workaround for: https://github.com/rust-lang/rust/issues/34537
+use node_implementation::Node;
+
+mod node_implementation {
+	use super::*;
+
+	#[derive(Clone, Debug, Decode, Encode, PartialEq)]
+	pub struct Node<H, N, V> {
+		pub hash: H,
+		pub number: N,
+		pub data: V,
+		pub children: Vec<Node<H, N, V>>,
+	}
+
+	impl<H: PartialEq, N: Ord, V> Node<H, N, V> {
+		/// Finds the max depth among all branches descendent from this node.
+		pub fn max_depth(&self) -> usize {
+			let mut max: usize = 0;
+			let mut stack = vec![(self, 0)];
+			while let Some((node, height)) = stack.pop() {
+				if height > max {
+					max = height;
+				}
+				node.children.iter().for_each(|n| stack.push((n, height + 1)));
+			}
+			max
+		}
+	}
+}
+
+struct ForkTreeIterator<'a, H, N, V> {
+	stack: Vec<&'a Node<H, N, V>>,
+}
+
+impl<'a, H, N, V> Iterator for ForkTreeIterator<'a, H, N, V> {
+	type Item = &'a Node<H, N, V>;
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.stack.pop().map(|node| {
+			// child nodes are stored ordered by max branch height (decreasing),
+			// we want to keep this ordering while iterating but since we're
+			// using a stack for iterator state we need to reverse it.
+			self.stack.extend(node.children.iter().rev());
+			node
+		})
+	}
+}
+
+struct RemovedIterator<H, N, V> {
+	stack: Vec<Node<H, N, V>>,
+}
+
+impl<H, N, V> Iterator for RemovedIterator<H, N, V> {
+	type Item = (H, N, V);
+
+	fn next(&mut self) -> Option<Self::Item> {
+		self.stack.pop().map(|mut node| {
+			// child nodes are stored ordered by max branch height (decreasing),
+			// we want to keep this ordering while iterating but since we're
+			// using a stack for iterator state we need to reverse it.
+			let children = std::mem::take(&mut node.children);
+
+			self.stack.extend(children.into_iter().rev());
+			(node.hash, node.number, node.data)
+		})
+	}
+}
+
+#[cfg(test)]
+mod test {
+	use crate::FilterAction;
+
+	use super::{Error, FinalizationResult, ForkTree};
+
+	#[derive(Debug, PartialEq)]
+	struct TestError;
+
+	impl std::fmt::Display for TestError {
+		fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+			write!(f, "TestError")
+		}
+	}
+
+	impl std::error::Error for TestError {}
+
+	fn test_fork_tree<'a>(
+	) -> (ForkTree<&'a str, u64, u32>, impl Fn(&&str, &&str) -> Result<bool, TestError>) {
+		let mut tree = ForkTree::new();
+
+		#[rustfmt::skip]
+		//
+		//     +---B-c-C---D---E
+		//     |
+		//     |   +---G
+		//     |   | 
+		// 0---A---F---H---I
+		//     |       |
+		//     |       +---L-m-M---N
+		//     |           |
+		//     |           +---O
+		//     +---J---K
+		//
+		// (where N is not a part of fork tree)
+		//
+		// NOTE: the tree will get automatically rebalance on import and won't be laid out like the
+		// diagram above. the children will be ordered by subtree depth and the longest branches
+		// will be on the leftmost side of the tree.
+		let is_descendent_of = |base: &&str, block: &&str| -> Result<bool, TestError> {
+			let letters = vec!["B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O"];
+			// This is a trick to have lowercase blocks be direct parents of their
+			// uppercase correspondent (A excluded)
+			let block = block.to_uppercase();
+			match (*base, block) {
+				("A", b) => Ok(letters.into_iter().any(|n| n == b)),
+				("B" | "c", b) => Ok(b == "C" || b == "D" || b == "E"),
+				("C", b) => Ok(b == "D" || b == "E"),
+				("D", b) => Ok(b == "E"),
+				("E", _) => Ok(false),
+				("F", b) =>
+					Ok(b == "G" || b == "H" || b == "I" || b == "L" || b == "M" || b == "N" || b == "O"),
+				("G", _) => Ok(false),
+				("H", b) => Ok(b == "I" || b == "L" || b == "M" || b == "N" || b == "O"),
+				("I", _) => Ok(false),
+				("J", b) => Ok(b == "K"),
+				("K", _) => Ok(false),
+				("L", b) => Ok(b == "M" || b == "N" || b == "O"),
+				("m", b) => Ok(b == "M" || b == "N"),
+				("M", b) => Ok(b == "N"),
+				("O", _) => Ok(false),
+				("0", _) => Ok(true),
+				_ => Ok(false),
+			}
+		};
+
+		tree.import("A", 10, 1, &is_descendent_of).unwrap();
+		tree.import("B", 20, 2, &is_descendent_of).unwrap();
+		tree.import("C", 30, 3, &is_descendent_of).unwrap();
+		tree.import("D", 40, 4, &is_descendent_of).unwrap();
+		tree.import("E", 50, 5, &is_descendent_of).unwrap();
+		tree.import("F", 20, 2, &is_descendent_of).unwrap();
+		tree.import("G", 30, 3, &is_descendent_of).unwrap();
+		tree.import("H", 30, 3, &is_descendent_of).unwrap();
+		tree.import("I", 40, 4, &is_descendent_of).unwrap();
+		tree.import("L", 40, 4, &is_descendent_of).unwrap();
+		tree.import("M", 50, 5, &is_descendent_of).unwrap();
+		tree.import("O", 50, 5, &is_descendent_of).unwrap();
+		tree.import("J", 20, 2, &is_descendent_of).unwrap();
+		tree.import("K", 30, 3, &is_descendent_of).unwrap();
+
+		(tree, is_descendent_of)
+	}
+
+	#[test]
+	fn import_doesnt_revert() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		tree.finalize_root(&"A");
+
+		assert_eq!(tree.best_finalized_number, Some(10));
+
+		assert_eq!(tree.import("A", 10, 1, &is_descendent_of), Err(Error::Revert));
+	}
+
+	#[test]
+	fn import_doesnt_add_duplicates() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		assert_eq!(tree.import("A", 10, 1, &is_descendent_of), Err(Error::Duplicate));
+
+		assert_eq!(tree.import("I", 40, 4, &is_descendent_of), Err(Error::Duplicate));
+
+		assert_eq!(tree.import("G", 30, 3, &is_descendent_of), Err(Error::Duplicate));
+
+		assert_eq!(tree.import("K", 30, 3, &is_descendent_of), Err(Error::Duplicate));
+	}
+
+	#[test]
+	fn finalize_root_works() {
+		let finalize_a = || {
+			let (mut tree, ..) = test_fork_tree();
+
+			assert_eq!(tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(), vec![("A", 10)]);
+
+			// finalizing "A" opens up three possible forks
+			tree.finalize_root(&"A");
+
+			assert_eq!(
+				tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(),
+				vec![("B", 20), ("F", 20), ("J", 20)],
+			);
+
+			tree
+		};
+
+		{
+			let mut tree = finalize_a();
+
+			// finalizing "B" will progress on its fork and remove any other competing forks
+			tree.finalize_root(&"B");
+
+			assert_eq!(tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(), vec![("C", 30)],);
+
+			// all the other forks have been pruned
+			assert!(tree.roots.len() == 1);
+		}
+
+		{
+			let mut tree = finalize_a();
+
+			// finalizing "J" will progress on its fork and remove any other competing forks
+			tree.finalize_root(&"J");
+
+			assert_eq!(tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(), vec![("K", 30)],);
+
+			// all the other forks have been pruned
+			assert!(tree.roots.len() == 1);
+		}
+	}
+
+	#[test]
+	fn finalize_works() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		let original_roots = tree.roots.clone();
+
+		// finalizing a block prior to any in the node doesn't change the tree
+		assert_eq!(tree.finalize(&"0", 0, &is_descendent_of), Ok(FinalizationResult::Unchanged));
+
+		assert_eq!(tree.roots, original_roots);
+
+		// finalizing "A" opens up three possible forks
+		assert_eq!(
+			tree.finalize(&"A", 10, &is_descendent_of),
+			Ok(FinalizationResult::Changed(Some(1))),
+		);
+
+		assert_eq!(
+			tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(),
+			vec![("B", 20), ("F", 20), ("J", 20)],
+		);
+
+		// finalizing anything lower than what we observed will fail
+		assert_eq!(tree.best_finalized_number, Some(10));
+
+		assert_eq!(tree.finalize(&"Z", 10, &is_descendent_of), Err(Error::Revert));
+
+		// trying to finalize a node without finalizing its ancestors first will fail
+		assert_eq!(tree.finalize(&"H", 30, &is_descendent_of), Err(Error::UnfinalizedAncestor));
+
+		// after finalizing "F" we can finalize "H"
+		assert_eq!(
+			tree.finalize(&"F", 20, &is_descendent_of),
+			Ok(FinalizationResult::Changed(Some(2))),
+		);
+
+		assert_eq!(
+			tree.finalize(&"H", 30, &is_descendent_of),
+			Ok(FinalizationResult::Changed(Some(3))),
+		);
+
+		assert_eq!(
+			tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(),
+			vec![("L", 40), ("I", 40)],
+		);
+
+		// finalizing a node from another fork that isn't part of the tree clears the tree
+		assert_eq!(
+			tree.finalize(&"Z", 50, &is_descendent_of),
+			Ok(FinalizationResult::Changed(None)),
+		);
+
+		assert!(tree.roots.is_empty());
+	}
+
+	#[test]
+	fn finalize_with_ancestor_works() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		let original_roots = tree.roots.clone();
+
+		// finalizing a block prior to any in the node doesn't change the tree
+		assert_eq!(
+			tree.finalize_with_ancestors(&"0", 0, &is_descendent_of),
+			Ok(FinalizationResult::Unchanged),
+		);
+
+		assert_eq!(tree.roots, original_roots);
+
+		// finalizing "A" opens up three possible forks
+		assert_eq!(
+			tree.finalize_with_ancestors(&"A", 10, &is_descendent_of),
+			Ok(FinalizationResult::Changed(Some(1))),
+		);
+
+		assert_eq!(
+			tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(),
+			vec![("B", 20), ("F", 20), ("J", 20)],
+		);
+
+		// finalizing H:
+		// 1) removes roots that are not ancestors/descendants of H (B, J)
+		// 2) opens root that is ancestor of H (F -> G+H)
+		// 3) finalizes the just opened root H (H -> I + L)
+		assert_eq!(
+			tree.finalize_with_ancestors(&"H", 30, &is_descendent_of),
+			Ok(FinalizationResult::Changed(Some(3))),
+		);
+
+		assert_eq!(
+			tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(),
+			vec![("L", 40), ("I", 40)],
+		);
+
+		assert_eq!(tree.best_finalized_number, Some(30));
+
+		// finalizing N (which is not a part of the tree):
+		// 1) removes roots that are not ancestors/descendants of N (I)
+		// 2) opens root that is ancestor of N (L -> M+O)
+		// 3) removes roots that are not ancestors/descendants of N (O)
+		// 4) opens root that is ancestor of N (M -> {})
+		assert_eq!(
+			tree.finalize_with_ancestors(&"N", 60, &is_descendent_of),
+			Ok(FinalizationResult::Changed(None)),
+		);
+
+		assert_eq!(tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(), vec![],);
+
+		assert_eq!(tree.best_finalized_number, Some(60));
+	}
+
+	#[test]
+	fn finalize_with_descendent_works() {
+		#[derive(Debug, PartialEq)]
+		struct Change {
+			effective: u64,
+		}
+
+		let (mut tree, is_descendent_of) = {
+			let mut tree = ForkTree::new();
+
+			let is_descendent_of = |base: &&str, block: &&str| -> Result<bool, TestError> {
+				// A0 #1 - (B #2) - (C #5) - D #10 - E #15 - (F #100)
+				//                            \
+				//                             - (G #100)
+				//
+				// A1 #1
+				//
+				// Nodes B, C, F and G  are not part of the tree.
+				match (*base, *block) {
+					("A0", b) => Ok(b == "B" || b == "C" || b == "D" || b == "E" || b == "G"),
+					("A1", _) => Ok(false),
+					("C", b) => Ok(b == "D"),
+					("D", b) => Ok(b == "E" || b == "F" || b == "G"),
+					("E", b) => Ok(b == "F"),
+					_ => Ok(false),
+				}
+			};
+
+			let is_root = tree.import("A0", 1, Change { effective: 5 }, &is_descendent_of).unwrap();
+			assert!(is_root);
+			let is_root = tree.import("A1", 1, Change { effective: 5 }, &is_descendent_of).unwrap();
+			assert!(is_root);
+			let is_root =
+				tree.import("D", 10, Change { effective: 10 }, &is_descendent_of).unwrap();
+			assert!(!is_root);
+			let is_root =
+				tree.import("E", 15, Change { effective: 50 }, &is_descendent_of).unwrap();
+			assert!(!is_root);
+
+			(tree, is_descendent_of)
+		};
+
+		assert_eq!(
+			tree.finalizes_any_with_descendent_if(
+				&"B",
+				2,
+				&is_descendent_of,
+				|c| c.effective <= 2,
+			),
+			Ok(None),
+		);
+
+		// finalizing "D" is not allowed since it is not a root.
+		assert_eq!(
+			tree.finalize_with_descendent_if(&"D", 10, &is_descendent_of, |c| c.effective <= 10),
+			Err(Error::UnfinalizedAncestor)
+		);
+
+		// finalizing "D" will finalize a block from the tree, but it can't be applied yet
+		// since it is not a root change.
+		assert_eq!(
+			tree.finalizes_any_with_descendent_if(&"D", 10, &is_descendent_of, |c| c.effective ==
+				10),
+			Ok(Some(false)),
+		);
+
+		// finalizing "E" is not allowed since there are not finalized anchestors.
+		assert_eq!(
+			tree.finalizes_any_with_descendent_if(&"E", 15, &is_descendent_of, |c| c.effective ==
+				10),
+			Err(Error::UnfinalizedAncestor)
+		);
+
+		// finalizing "B" doesn't finalize "A0" since the predicate doesn't pass,
+		// although it will clear out "A1" from the tree
+		assert_eq!(
+			tree.finalize_with_descendent_if(&"B", 2, &is_descendent_of, |c| c.effective <= 2),
+			Ok(FinalizationResult::Changed(None)),
+		);
+
+		assert_eq!(tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(), vec![("A0", 1)],);
+
+		// finalizing "C" will finalize the node "A0" and prune it out of the tree
+		assert_eq!(
+			tree.finalizes_any_with_descendent_if(
+				&"C",
+				5,
+				&is_descendent_of,
+				|c| c.effective <= 5,
+			),
+			Ok(Some(true)),
+		);
+
+		assert_eq!(
+			tree.finalize_with_descendent_if(&"C", 5, &is_descendent_of, |c| c.effective <= 5),
+			Ok(FinalizationResult::Changed(Some(Change { effective: 5 }))),
+		);
+
+		assert_eq!(tree.roots().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(), vec![("D", 10)],);
+
+		// finalizing "F" will fail since it would finalize past "E" without finalizing "D" first
+		assert_eq!(
+			tree.finalizes_any_with_descendent_if(&"F", 100, &is_descendent_of, |c| c.effective <=
+				100,),
+			Err(Error::UnfinalizedAncestor),
+		);
+
+		// it will work with "G" though since it is not in the same branch as "E"
+		assert_eq!(
+			tree.finalizes_any_with_descendent_if(&"G", 100, &is_descendent_of, |c| c.effective <=
+				100),
+			Ok(Some(true)),
+		);
+
+		assert_eq!(
+			tree.finalize_with_descendent_if(&"G", 100, &is_descendent_of, |c| c.effective <= 100),
+			Ok(FinalizationResult::Changed(Some(Change { effective: 10 }))),
+		);
+
+		// "E" will be pruned out
+		assert_eq!(tree.roots().count(), 0);
+	}
+
+	#[test]
+	fn iter_iterates_in_preorder() {
+		let (tree, ..) = test_fork_tree();
+		assert_eq!(
+			tree.iter().map(|(h, n, _)| (*h, *n)).collect::<Vec<_>>(),
+			vec![
+				("A", 10),
+				("B", 20),
+				("C", 30),
+				("D", 40),
+				("E", 50),
+				("F", 20),
+				("H", 30),
+				("L", 40),
+				("M", 50),
+				("O", 50),
+				("I", 40),
+				("G", 30),
+				("J", 20),
+				("K", 30),
+			],
+		);
+	}
+
+	#[test]
+	fn minimizes_calls_to_is_descendent_of() {
+		use std::sync::atomic::{AtomicUsize, Ordering};
+
+		let n_is_descendent_of_calls = AtomicUsize::new(0);
+
+		let is_descendent_of = |_: &&str, _: &&str| -> Result<bool, TestError> {
+			n_is_descendent_of_calls.fetch_add(1, Ordering::SeqCst);
+			Ok(true)
+		};
+
+		{
+			// Deep tree where we want to call `finalizes_any_with_descendent_if`. The
+			// search for the node should first check the predicate (which is cheaper) and
+			// only then call `is_descendent_of`
+			let mut tree = ForkTree::new();
+			let letters = vec!["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"];
+
+			for (i, letter) in letters.iter().enumerate() {
+				tree.import::<_, TestError>(*letter, i, i, &|_, _| Ok(true)).unwrap();
+			}
+
+			// "L" is a descendent of "K", but the predicate will only pass for "K",
+			// therefore only one call to `is_descendent_of` should be made
+			assert_eq!(
+				tree.finalizes_any_with_descendent_if(&"L", 11, &is_descendent_of, |i| *i == 10,),
+				Ok(Some(false)),
+			);
+
+			assert_eq!(n_is_descendent_of_calls.load(Ordering::SeqCst), 1);
+		}
+
+		n_is_descendent_of_calls.store(0, Ordering::SeqCst);
+
+		{
+			// Multiple roots in the tree where we want to call `finalize_with_descendent_if`.
+			// The search for the root node should first check the predicate (which is cheaper)
+			// and only then call `is_descendent_of`
+			let mut tree = ForkTree::new();
+			let letters = vec!["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K"];
+
+			for (i, letter) in letters.iter().enumerate() {
+				tree.import::<_, TestError>(*letter, i, i, &|_, _| Ok(false)).unwrap();
+			}
+
+			// "L" is a descendent of "K", but the predicate will only pass for "K",
+			// therefore only one call to `is_descendent_of` should be made
+			assert_eq!(
+				tree.finalize_with_descendent_if(&"L", 11, &is_descendent_of, |i| *i == 10,),
+				Ok(FinalizationResult::Changed(Some(10))),
+			);
+
+			assert_eq!(n_is_descendent_of_calls.load(Ordering::SeqCst), 1);
+		}
+	}
+
+	#[test]
+	fn map_works() {
+		let (mut tree, _) = test_fork_tree();
+
+		// Extend the single root fork-tree to also excercise the roots order during map.
+		let is_descendent_of = |_: &&str, _: &&str| -> Result<bool, TestError> { Ok(false) };
+		let is_root = tree.import("A1", 10, 1, &is_descendent_of).unwrap();
+		assert!(is_root);
+		let is_root = tree.import("A2", 10, 1, &is_descendent_of).unwrap();
+		assert!(is_root);
+
+		let old_tree = tree.clone();
+		let new_tree = tree.map(&mut |hash, _, _| hash.to_owned());
+
+		// Check content and order
+		assert!(new_tree.iter().all(|(hash, _, data)| hash == data));
+		assert_eq!(
+			old_tree.iter().map(|(hash, _, _)| *hash).collect::<Vec<_>>(),
+			new_tree.iter().map(|(hash, _, _)| *hash).collect::<Vec<_>>(),
+		);
+	}
+
+	#[test]
+	fn prune_works_for_in_tree_hashes() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		let removed = tree.prune(&"C", &30, &is_descendent_of, &|_| true).unwrap();
+
+		assert_eq!(tree.roots.iter().map(|node| node.hash).collect::<Vec<_>>(), vec!["B"]);
+
+		assert_eq!(
+			tree.iter().map(|(hash, _, _)| *hash).collect::<Vec<_>>(),
+			vec!["B", "C", "D", "E"],
+		);
+
+		assert_eq!(
+			removed.map(|(hash, _, _)| hash).collect::<Vec<_>>(),
+			vec!["A", "F", "H", "L", "M", "O", "I", "G", "J", "K"]
+		);
+
+		let removed = tree.prune(&"E", &50, &is_descendent_of, &|_| true).unwrap();
+
+		assert_eq!(tree.roots.iter().map(|node| node.hash).collect::<Vec<_>>(), vec!["D"]);
+
+		assert_eq!(tree.iter().map(|(hash, _, _)| *hash).collect::<Vec<_>>(), vec!["D", "E"]);
+
+		assert_eq!(removed.map(|(hash, _, _)| hash).collect::<Vec<_>>(), vec!["B", "C"]);
+	}
+
+	#[test]
+	fn prune_works_for_out_of_tree_hashes() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		let removed = tree.prune(&"c", &25, &is_descendent_of, &|_| true).unwrap();
+
+		assert_eq!(tree.roots.iter().map(|node| node.hash).collect::<Vec<_>>(), vec!["B"]);
+
+		assert_eq!(
+			tree.iter().map(|(hash, _, _)| *hash).collect::<Vec<_>>(),
+			vec!["B", "C", "D", "E"],
+		);
+
+		assert_eq!(
+			removed.map(|(hash, _, _)| hash).collect::<Vec<_>>(),
+			vec!["A", "F", "H", "L", "M", "O", "I", "G", "J", "K"]
+		);
+	}
+
+	#[test]
+	fn prune_works_for_not_direct_ancestor() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		// This is to re-root the tree not at the immediate ancestor, but the one just before.
+		let removed = tree.prune(&"m", &45, &is_descendent_of, &|height| *height == 3).unwrap();
+
+		assert_eq!(tree.roots.iter().map(|node| node.hash).collect::<Vec<_>>(), vec!["H"]);
+
+		assert_eq!(tree.iter().map(|(hash, _, _)| *hash).collect::<Vec<_>>(), vec!["H", "L", "M"],);
+
+		assert_eq!(
+			removed.map(|(hash, _, _)| hash).collect::<Vec<_>>(),
+			vec!["O", "I", "A", "B", "C", "D", "E", "F", "G", "J", "K"]
+		);
+	}
+
+	#[test]
+	fn prune_works_for_far_away_ancestor() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		let removed = tree.prune(&"m", &45, &is_descendent_of, &|height| *height == 2).unwrap();
+
+		assert_eq!(tree.roots.iter().map(|node| node.hash).collect::<Vec<_>>(), vec!["F"]);
+
+		assert_eq!(
+			tree.iter().map(|(hash, _, _)| *hash).collect::<Vec<_>>(),
+			vec!["F", "H", "L", "M"],
+		);
+
+		assert_eq!(
+			removed.map(|(hash, _, _)| hash).collect::<Vec<_>>(),
+			vec!["O", "I", "G", "A", "B", "C", "D", "E", "J", "K"]
+		);
+	}
+
+	#[test]
+	fn find_node_backtracks_after_finding_highest_descending_node() {
+		let mut tree = ForkTree::new();
+
+		// A - B
+		//  \
+		//   — C
+		//
+		let is_descendent_of = |base: &&str, block: &&str| -> Result<bool, TestError> {
+			match (*base, *block) {
+				("A", b) => Ok(b == "B" || b == "C" || b == "D"),
+				("B", b) | ("C", b) => Ok(b == "D"),
+				("0", _) => Ok(true),
+				_ => Ok(false),
+			}
+		};
+
+		tree.import("A", 1, 1, &is_descendent_of).unwrap();
+		tree.import("B", 2, 2, &is_descendent_of).unwrap();
+		tree.import("C", 2, 4, &is_descendent_of).unwrap();
+
+		// when searching the tree we reach node `C`, but the
+		// predicate doesn't pass. we should backtrack to `B`, but not to `A`,
+		// since "B" fulfills the predicate.
+		let node = tree.find_node_where(&"D", &3, &is_descendent_of, &|data| *data < 3).unwrap();
+
+		assert_eq!(node.unwrap().hash, "B");
+	}
+
+	#[test]
+	fn rebalance_works() {
+		let (mut tree, _) = test_fork_tree();
+
+		// the tree is automatically rebalanced on import, therefore we should iterate in preorder
+		// exploring the longest forks first. check the ascii art above to understand the expected
+		// output below.
+		assert_eq!(
+			tree.iter().map(|(h, _, _)| *h).collect::<Vec<_>>(),
+			vec!["A", "B", "C", "D", "E", "F", "H", "L", "M", "O", "I", "G", "J", "K"],
+		);
+
+		// let's add a block "P" which is a descendent of block "O"
+		let is_descendent_of = |base: &&str, block: &&str| -> Result<bool, TestError> {
+			match (*base, *block) {
+				(b, "P") => Ok(vec!["A", "F", "H", "L", "O"].into_iter().any(|n| n == b)),
+				_ => Ok(false),
+			}
+		};
+
+		tree.import("P", 60, 6, &is_descendent_of).unwrap();
+
+		// this should re-order the tree, since the branch "A -> B -> C -> D -> E" is no longer tied
+		// with 5 blocks depth. additionally "O" should be visited before "M" now, since it has one
+		// descendent "P" which makes that branch 6 blocks long.
+		assert_eq!(
+			tree.iter().map(|(h, _, _)| *h).collect::<Vec<_>>(),
+			["A", "F", "H", "L", "O", "P", "M", "I", "G", "B", "C", "D", "E", "J", "K"]
+		);
+	}
+
+	#[test]
+	fn drain_filter_works() {
+		let (mut tree, _) = test_fork_tree();
+
+		let filter = |h: &&str, _: &u64, _: &u32| match *h {
+			"A" | "B" | "F" | "G" => FilterAction::KeepNode,
+			"C" => FilterAction::KeepTree,
+			"H" | "J" => FilterAction::Remove,
+			_ => panic!("Unexpected filtering for node: {}", *h),
+		};
+
+		let removed = tree.drain_filter(filter);
+
+		assert_eq!(
+			tree.iter().map(|(h, _, _)| *h).collect::<Vec<_>>(),
+			["A", "B", "C", "D", "E", "F", "G"]
+		);
+
+		assert_eq!(
+			removed.map(|(h, _, _)| h).collect::<Vec<_>>(),
+			["H", "L", "M", "O", "I", "J", "K"]
+		);
+	}
+
+	#[test]
+	fn find_node_index_works() {
+		let (tree, is_descendent_of) = test_fork_tree();
+
+		let path = tree
+			.find_node_index_where(&"D", &40, &is_descendent_of, &|_| true)
+			.unwrap()
+			.unwrap();
+		assert_eq!(path, [0, 0, 0]);
+
+		let path = tree
+			.find_node_index_where(&"O", &50, &is_descendent_of, &|_| true)
+			.unwrap()
+			.unwrap();
+		assert_eq!(path, [0, 1, 0, 0]);
+
+		let path = tree
+			.find_node_index_where(&"N", &60, &is_descendent_of, &|_| true)
+			.unwrap()
+			.unwrap();
+		assert_eq!(path, [0, 1, 0, 0, 0]);
+	}
+
+	#[test]
+	fn find_node_index_with_predicate_works() {
+		let is_descendent_of = |parent: &char, child: &char| match *parent {
+			'A' => Ok(['B', 'C', 'D', 'E', 'F'].contains(child)),
+			'B' => Ok(['C', 'D'].contains(child)),
+			'C' => Ok(['D'].contains(child)),
+			'E' => Ok(['F'].contains(child)),
+			'D' | 'F' => Ok(false),
+			_ => Err(TestError),
+		};
+
+		// A(t) --- B(f) --- C(t) --- D(f)
+		//      \-- E(t) --- F(f)
+		let mut tree: ForkTree<char, u8, bool> = ForkTree::new();
+		tree.import('A', 1, true, &is_descendent_of).unwrap();
+		tree.import('B', 2, false, &is_descendent_of).unwrap();
+		tree.import('C', 3, true, &is_descendent_of).unwrap();
+		tree.import('D', 4, false, &is_descendent_of).unwrap();
+
+		tree.import('E', 2, true, &is_descendent_of).unwrap();
+		tree.import('F', 3, false, &is_descendent_of).unwrap();
+
+		let path = tree
+			.find_node_index_where(&'D', &4, &is_descendent_of, &|&value| !value)
+			.unwrap()
+			.unwrap();
+		assert_eq!(path, [0, 0]);
+
+		let path = tree
+			.find_node_index_where(&'D', &4, &is_descendent_of, &|&value| value)
+			.unwrap()
+			.unwrap();
+		assert_eq!(path, [0, 0, 0]);
+
+		let path = tree
+			.find_node_index_where(&'F', &3, &is_descendent_of, &|&value| !value)
+			.unwrap();
+		assert_eq!(path, None);
+
+		let path = tree
+			.find_node_index_where(&'F', &3, &is_descendent_of, &|&value| value)
+			.unwrap()
+			.unwrap();
+		assert_eq!(path, [0, 1]);
+	}
+
+	#[test]
+	fn find_node_works() {
+		let (tree, is_descendent_of) = test_fork_tree();
+
+		let node = tree.find_node_where(&"B", &20, &is_descendent_of, &|_| true).unwrap().unwrap();
+		assert_eq!((node.hash, node.number), ("A", 10));
+
+		let node = tree.find_node_where(&"D", &40, &is_descendent_of, &|_| true).unwrap().unwrap();
+		assert_eq!((node.hash, node.number), ("C", 30));
+
+		let node = tree.find_node_where(&"O", &50, &is_descendent_of, &|_| true).unwrap().unwrap();
+		assert_eq!((node.hash, node.number), ("L", 40));
+
+		let node = tree.find_node_where(&"N", &60, &is_descendent_of, &|_| true).unwrap().unwrap();
+		assert_eq!((node.hash, node.number), ("M", 50));
+	}
+
+	#[test]
+	fn post_order_traversal_requirement() {
+		let (mut tree, is_descendent_of) = test_fork_tree();
+
+		// Test for the post-order DFS traversal requirement as specified by the
+		// `find_node_index_where` and `import` comments.
+		let is_descendent_of_for_post_order = |parent: &&str, child: &&str| match *parent {
+			"A" => Err(TestError),
+			"K" if *child == "Z" => Ok(true),
+			_ => is_descendent_of(parent, child),
+		};
+
+		// Post order traversal requirement for `find_node_index_where`
+		let path = tree
+			.find_node_index_where(&"N", &60, &is_descendent_of_for_post_order, &|_| true)
+			.unwrap()
+			.unwrap();
+		assert_eq!(path, [0, 1, 0, 0, 0]);
+
+		// Post order traversal requirement for `import`
+		let res = tree.import(&"Z", 100, 10, &is_descendent_of_for_post_order);
+		assert_eq!(res, Ok(false));
+		assert_eq!(
+			tree.iter().map(|node| *node.0).collect::<Vec<_>>(),
+			vec!["A", "B", "C", "D", "E", "F", "H", "L", "M", "O", "I", "G", "J", "K", "Z"],
+		);
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/Cargo.toml b/substrate/utils/frame/benchmarking-cli/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..4b142c205c4d7f057c9c021ec0daa7859c98f1c5
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/Cargo.toml
@@ -0,0 +1,68 @@
+[package]
+name = "frame-benchmarking-cli"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "CLI for benchmarking FRAME"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+array-bytes = "6.1"
+chrono = "0.4"
+clap = { version = "4.2.5", features = ["derive"] }
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+comfy-table = { version = "7.0.1", default-features = false }
+handlebars = "4.2.2"
+Inflector = "0.11.4"
+itertools = "0.10.3"
+lazy_static = "1.4.0"
+linked-hash-map = "0.5.4"
+log = "0.4.17"
+rand = { version = "0.8.4", features = ["small_rng"] }
+rand_pcg = "0.3.1"
+serde = "1.0.163"
+serde_json = "1.0.85"
+thiserror = "1.0.30"
+thousands = "0.2.0"
+frame-benchmarking = { version = "4.0.0-dev", path = "../../../frame/benchmarking" }
+frame-support = { version = "4.0.0-dev", path = "../../../frame/support" }
+frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
+sc-block-builder = { version = "0.10.0-dev", path = "../../../client/block-builder" }
+sc-cli = { version = "0.10.0-dev", default-features = false, path = "../../../client/cli" }
+sc-client-api = { version = "4.0.0-dev", path = "../../../client/api" }
+sc-client-db = { version = "0.10.0-dev", default-features = false, path = "../../../client/db" }
+sc-executor = { version = "0.10.0-dev", path = "../../../client/executor" }
+sc-service = { version = "0.10.0-dev", default-features = false, path = "../../../client/service" }
+sc-sysinfo = { version = "6.0.0-dev", path = "../../../client/sysinfo" }
+sp-api = { version = "4.0.0-dev", path = "../../../primitives/api" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-database = { version = "4.0.0-dev", path = "../../../primitives/database" }
+sp-externalities = { version = "0.19.0", path = "../../../primitives/externalities" }
+sp-inherents = { version = "4.0.0-dev", path = "../../../primitives/inherents" }
+sp-keystore = { version = "0.27.0", path = "../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+sp-state-machine = { version = "0.28.0", path = "../../../primitives/state-machine" }
+sp-storage = { version = "13.0.0", path = "../../../primitives/storage" }
+sp-trie = { version = "22.0.0", path = "../../../primitives/trie" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+sp-wasm-interface = { version = "14.0.0", path = "../../../primitives/wasm-interface" }
+gethostname = "0.2.3"
+
+[features]
+default = [ "rocksdb" ]
+runtime-benchmarks = [
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"sc-client-db/runtime-benchmarks",
+	"sc-service/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+]
+rocksdb = [ "sc-cli/rocksdb", "sc-client-db/rocksdb" ]
diff --git a/substrate/utils/frame/benchmarking-cli/README.md b/substrate/utils/frame/benchmarking-cli/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e6a48b61fd22741f42466dae5d8ee6eccd56d035
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/README.md
@@ -0,0 +1,46 @@
+# The Benchmarking CLI
+
+This crate contains commands to benchmark various aspects of Substrate and the hardware.  
+All commands are exposed by the Substrate node but can be exposed by any Substrate client.  
+The goal is to have a comprehensive suite of benchmarks that cover all aspects of Substrate and the hardware that its running on.
+
+Invoking the root benchmark command prints a help menu:  
+```sh
+$ cargo run --profile=production -- benchmark
+
+Sub-commands concerned with benchmarking.
+
+USAGE:
+    substrate benchmark <SUBCOMMAND>
+
+OPTIONS:
+    -h, --help       Print help information
+    -V, --version    Print version information
+
+SUBCOMMANDS:
+    block       Benchmark the execution time of historic blocks
+    machine     Command to benchmark the hardware.
+    overhead    Benchmark the execution overhead per-block and per-extrinsic
+    pallet      Benchmark the extrinsic weight of FRAME Pallets
+    storage     Benchmark the storage speed of a chain snapshot
+```
+
+All examples use the `production` profile for correctness which makes the compilation *very* slow; for testing you can use `--release`.  
+For the final results the `production` profile and reference hardware should be used, otherwise the results are not comparable.
+
+The sub-commands are explained in depth here:  
+- [block] Compare the weight of a historic block to its actual resource usage
+- [machine] Gauges the speed of the hardware
+- [overhead] Creates weight files for the *Block*- and *Extrinsic*-base weights
+- [pallet] Creates weight files for a Pallet
+- [storage] Creates weight files for *Read* and *Write* storage operations
+
+License: Apache-2.0
+
+<!-- LINKS -->
+
+[pallet]: ../../../frame/benchmarking/README.md
+[machine]: src/machine/README.md
+[storage]: src/storage/README.md
+[overhead]: src/overhead/README.md
+[block]: src/block/README.md
diff --git a/substrate/utils/frame/benchmarking-cli/build.rs b/substrate/utils/frame/benchmarking-cli/build.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1545d1e0c21e9416b8df6f591c1a1f7307b05996
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/build.rs
@@ -0,0 +1,31 @@
+// 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 std::env;
+
+/// Exposes build environment variables to the rust code.
+///
+/// - The build profile as `build_profile`
+/// - The optimization level as `build_opt_level`
+pub fn main() {
+	if let Ok(opt_level) = env::var("OPT_LEVEL") {
+		println!("cargo:rustc-cfg=build_opt_level={:?}", opt_level);
+	}
+	if let Ok(profile) = env::var("PROFILE") {
+		println!("cargo:rustc-cfg=build_profile={:?}", profile);
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/block/README.md b/substrate/utils/frame/benchmarking-cli/src/block/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7e99f0df9d43b9ccfd65b61c650c2846fb168605
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/block/README.md
@@ -0,0 +1,118 @@
+# The `benchmark block` command
+
+The whole benchmarking process in Substrate aims to predict the resource usage of an unexecuted block.  
+This command measures how accurate this prediction was by executing a block and comparing the predicted weight to its actual resource usage.  
+It can be used to measure the accuracy of the pallet benchmarking.
+
+In the following it will be explained once for Polkadot and once for Substrate.  
+
+## Polkadot # 1
+<sup>(Also works for Kusama, Westend and Rococo)</sup>
+
+
+Suppose you either have a synced Polkadot node or downloaded a snapshot from [Polkachu].  
+This example uses a pruned ParityDB snapshot from the 2022-4-19 with the last block being 9939462.  
+For pruned snapshots you need to know the number of the last block (to be improved [here]).    
+Pruned snapshots normally store the last 256 blocks, archive nodes can use any block range.  
+
+In this example we will benchmark just the last 10 blocks:  
+```sh
+cargo run --profile=production -- benchmark block --from 9939453 --to 9939462 --db paritydb
+```
+
+Output:
+```pre
+Block 9939453 with     2 tx used   4.57% of its weight (    26,458,801 of    579,047,053 ns)    
+Block 9939454 with     3 tx used   4.80% of its weight (    28,335,826 of    590,414,831 ns)    
+Block 9939455 with     2 tx used   4.76% of its weight (    27,889,567 of    586,484,595 ns)    
+Block 9939456 with     2 tx used   4.65% of its weight (    27,101,306 of    582,789,723 ns)    
+Block 9939457 with     2 tx used   4.62% of its weight (    26,908,882 of    582,789,723 ns)    
+Block 9939458 with     2 tx used   4.78% of its weight (    28,211,440 of    590,179,467 ns)    
+Block 9939459 with     4 tx used   4.78% of its weight (    27,866,077 of    583,260,451 ns)    
+Block 9939460 with     3 tx used   4.72% of its weight (    27,845,836 of    590,462,629 ns)    
+Block 9939461 with     2 tx used   4.58% of its weight (    26,685,119 of    582,789,723 ns)    
+Block 9939462 with     2 tx used   4.60% of its weight (    26,840,938 of    583,697,101 ns)    
+```
+
+### Output Interpretation
+
+<sup>(Only results from reference hardware are relevant)</sup>
+
+Each block is executed multiple times and the results are averaged.  
+The percent number is the interesting part and indicates how much weight was used as compared to how much was predicted.  
+The closer to 100% this is without exceeding 100%, the better.  
+If it exceeds 100%, the block is marked with "**OVER WEIGHT!**" to easier spot them. This is not good since then the benchmarking under-estimated the weight.  
+This would mean that an honest validator would possibly not be able to keep up with importing blocks since users did not pay for enough weight.  
+If that happens the validator could lag behind the chain and get slashed for missing deadlines.  
+It is therefore important to investigate any overweight blocks.  
+
+In this example you can see an unexpected result; only < 5% of the weight was used!  
+The measured blocks can be executed much faster than predicted.  
+This means that the benchmarking process massively over-estimated the execution time.  
+Since they are off by so much, it is an issue [polkadot#5192].  
+
+The ideal range for these results would be 85-100%.
+
+## Polkadot # 2
+
+Let's take a more interesting example where the blocks use more of their predicted weight.  
+Every day when validators pay out rewards, the blocks are nearly full.  
+Using an archive node here is the easiest.  
+
+The Polkadot blocks TODO-TODO for example contain large batch transactions for staking payout.  
+
+```sh
+cargo run --profile=production -- benchmark block --from TODO --to TODO --db paritydb
+```
+
+```pre
+TODO
+```
+
+## Substrate
+
+It is also possible to try the procedure in Substrate, although it's a bit boring.  
+
+First you need to create some blocks with either a local or dev chain.  
+This example will use the standard development spec.  
+Pick a non existing directory where the chain data will be stored, eg `/tmp/dev`.
+```sh
+cargo run --profile=production -- --dev -d /tmp/dev
+```
+You should see after some seconds that it started to produce blocks:  
+```pre
+…
+✨ Imported #1 (0x801d…9189)
+…
+```
+You can now kill the node with `Ctrl+C`. Then measure how long it takes to execute these blocks:  
+```sh
+cargo run --profile=production -- benchmark block --from 1 --to 1 --dev -d /tmp/dev --pruning archive
+```
+This will benchmark the first block. If you killed the node at a later point, you can measure multiple blocks.
+```pre
+Block 1 with     1 tx used  72.04% of its weight (     4,945,664 of      6,864,702 ns)
+```
+
+In this example the block used ~72% of its weight.  
+The benchmarking therefore over-estimated the effort to execute the block.  
+Since this block is empty, its not very interesting.
+
+## Arguments
+
+- `--from` Number of the first block to measure (inclusive).
+- `--to` Number of the last block to measure (inclusive).
+- `--repeat` How often each block should be measured.
+- [`--db`]
+- [`--pruning`]
+
+License: Apache-2.0
+
+<!-- LINKS -->
+
+[Polkachu]: https://polkachu.com/snapshots
+[here]: https://github.com/paritytech/substrate/issues/11141
+[polkadot#5192]: https://github.com/paritytech/polkadot/issues/5192
+
+[`--db`]: ../shared/README.md#arguments
+[`--pruning`]: ../shared/README.md#arguments
diff --git a/substrate/utils/frame/benchmarking-cli/src/block/bench.rs b/substrate/utils/frame/benchmarking-cli/src/block/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c9a7fb1ad33dfd3d5145b7ca671bc36d932119bc
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/block/bench.rs
@@ -0,0 +1,181 @@
+// 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.
+
+//! Contains the core benchmarking logic.
+
+use codec::DecodeAll;
+use frame_support::weights::constants::WEIGHT_REF_TIME_PER_NANOS;
+use frame_system::ConsumedWeight;
+use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
+use sc_cli::{Error, Result};
+use sc_client_api::{
+	Backend as ClientBackend, BlockBackend, HeaderBackend, StorageProvider, UsageProvider,
+};
+use sp_api::{ApiExt, Core, HeaderT, ProvideRuntimeApi};
+use sp_blockchain::Error::RuntimeApiError;
+use sp_runtime::{generic::BlockId, traits::Block as BlockT, DigestItem, OpaqueExtrinsic};
+use sp_storage::StorageKey;
+
+use clap::Args;
+use log::{info, warn};
+use serde::Serialize;
+use std::{fmt::Debug, marker::PhantomData, sync::Arc, time::Instant};
+use thousands::Separable;
+
+use crate::shared::{StatSelect, Stats};
+
+/// Log target for printing block weight info.
+const LOG_TARGET: &'static str = "benchmark::block::weight";
+
+/// Parameters for modifying the benchmark behaviour.
+#[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
+pub struct BenchmarkParams {
+	/// Number of the first block to consider.
+	#[arg(long)]
+	pub from: u32,
+
+	/// Last block number to consider.
+	#[arg(long)]
+	pub to: u32,
+
+	/// Number of times that the benchmark should be repeated for each block.
+	#[arg(long, default_value_t = 10)]
+	pub repeat: u32,
+}
+
+/// Convenience closure for the [`Benchmark::run()`] function.
+pub struct Benchmark<Block, BA, C> {
+	client: Arc<C>,
+	params: BenchmarkParams,
+	_p: PhantomData<(Block, BA, C)>,
+}
+
+/// Helper for nano seconds.
+type NanoSeconds = u64;
+
+impl<Block, BA, C> Benchmark<Block, BA, C>
+where
+	Block: BlockT<Extrinsic = OpaqueExtrinsic>,
+	BA: ClientBackend<Block>,
+	C: BlockBuilderProvider<BA, Block, C>
+		+ ProvideRuntimeApi<Block>
+		+ StorageProvider<Block, BA>
+		+ UsageProvider<Block>
+		+ BlockBackend<Block>
+		+ HeaderBackend<Block>,
+	C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+{
+	/// Returns a new [`Self`] from the arguments.
+	pub fn new(client: Arc<C>, params: BenchmarkParams) -> Self {
+		Self { client, params, _p: PhantomData }
+	}
+
+	/// Benchmark the execution speed of historic blocks and log the results.
+	pub fn run(&self) -> Result<()> {
+		if self.params.from == 0 {
+			return Err("Cannot benchmark the genesis block".into())
+		}
+
+		for i in self.params.from..=self.params.to {
+			let block_num = BlockId::Number(i.into());
+			let hash = self.client.expect_block_hash_from_id(&block_num)?;
+			let consumed = self.consumed_weight(hash)?;
+
+			let block = self.client.block(hash)?.ok_or(format!("Block {} not found", block_num))?;
+			let block = self.unsealed(block.block);
+			let took = self.measure_block(&block, *block.header().parent_hash())?;
+
+			self.log_weight(i, block.extrinsics().len(), consumed, took);
+		}
+
+		Ok(())
+	}
+
+	/// Return the average *execution* aka. *import* time of the block.
+	fn measure_block(&self, block: &Block, parent_hash: Block::Hash) -> Result<NanoSeconds> {
+		let mut record = Vec::<NanoSeconds>::default();
+		// Interesting part here:
+		// Execute the block multiple times and collect stats about its execution time.
+		for _ in 0..self.params.repeat {
+			let block = block.clone();
+			let runtime_api = self.client.runtime_api();
+			let start = Instant::now();
+
+			runtime_api
+				.execute_block(parent_hash, block)
+				.map_err(|e| Error::Client(RuntimeApiError(e)))?;
+
+			record.push(start.elapsed().as_nanos() as NanoSeconds);
+		}
+
+		let took = Stats::new(&record)?.select(StatSelect::Average);
+		Ok(took)
+	}
+
+	/// Returns the total nanoseconds of a [`frame_system::ConsumedWeight`] for a block number.
+	///
+	/// This is the post-dispatch corrected weight and is only available
+	/// after executing the block.
+	fn consumed_weight(&self, block_hash: Block::Hash) -> Result<NanoSeconds> {
+		// Hard-coded key for System::BlockWeight. It could also be passed in as argument
+		// for the benchmark, but I think this should work as well.
+		let hash = array_bytes::hex2bytes(
+			"26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96",
+		)?;
+		let key = StorageKey(hash);
+
+		let mut raw_weight = &self
+			.client
+			.storage(block_hash, &key)?
+			.ok_or(format!("Could not find System::BlockWeight for block: {}", block_hash))?
+			.0[..];
+
+		let weight = ConsumedWeight::decode_all(&mut raw_weight)?;
+		// Should be divisible, but still use floats in case we ever change that.
+		Ok((weight.total().ref_time() as f64 / WEIGHT_REF_TIME_PER_NANOS as f64).floor()
+			as NanoSeconds)
+	}
+
+	/// Prints the weight info of a block to the console.
+	fn log_weight(&self, num: u32, num_ext: usize, consumed: NanoSeconds, took: NanoSeconds) {
+		// The ratio of weight that the block used vs what it consumed.
+		// This should in general not exceed 100% (minus outliers).
+		let percent = (took as f64 / consumed as f64) * 100.0;
+
+		let msg = format!(
+			"Block {} with {: >5} tx used {: >6.2}% of its weight ({: >14} of {: >14} ns)",
+			num,
+			num_ext,
+			percent,
+			took.separate_with_commas(),
+			consumed.separate_with_commas()
+		);
+
+		if took <= consumed {
+			info!(target: LOG_TARGET, "{}", msg);
+		} else {
+			warn!(target: LOG_TARGET, "{} - OVER WEIGHT!", msg);
+		}
+	}
+
+	/// Removes the consensus seal from the block.
+	fn unsealed(&self, block: Block) -> Block {
+		let (mut header, exts) = block.deconstruct();
+		header.digest_mut().logs.retain(|item| !matches!(item, DigestItem::Seal(_, _)));
+		Block::new(header, exts)
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/block/cmd.rs b/substrate/utils/frame/benchmarking-cli/src/block/cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ee12c1c5dac33fc60ecec0726734d8f9482540a8
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/block/cmd.rs
@@ -0,0 +1,117 @@
+// 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.
+
+//! Contains the [`BlockCmd`] as entry point for the CLI to execute
+//! the *block* benchmark.
+
+use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
+use sc_cli::{CliConfiguration, ImportParams, Result, SharedParams};
+use sc_client_api::{Backend as ClientBackend, BlockBackend, StorageProvider, UsageProvider};
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_blockchain::HeaderBackend;
+use sp_runtime::{traits::Block as BlockT, OpaqueExtrinsic};
+
+use clap::Parser;
+use std::{fmt::Debug, sync::Arc};
+
+use super::bench::{Benchmark, BenchmarkParams};
+
+/// Benchmark the execution time of historic blocks.
+///
+/// This can be used to verify that blocks do not use more weight than they consumed
+/// in their `WeightInfo`. Example:
+///
+/// Let's say you are on a Substrate chain and want to verify that the first 3 blocks
+/// did not use more weight than declared which would otherwise be an issue.
+/// To test this with a dev node, first create one with a temp directory:
+///
+/// $ substrate --dev -d /tmp/my-dev --wasm-execution compiled
+///
+/// And wait some time to let it produce 3 blocks. Then benchmark them with:
+///
+/// $ substrate benchmark-block --from 1 --to 3 --dev -d /tmp/my-dev
+///   --wasm-execution compiled --pruning archive
+///
+/// The output will be similar to this:
+///
+/// Block 1 with 1 tx used 77.34% of its weight ( 5,308,964 of 6,864,645 ns)
+/// Block 2 with 1 tx used 77.99% of its weight ( 5,353,992 of 6,864,645 ns)
+/// Block 3 with 1 tx used 75.91% of its weight ( 5,305,938 of 6,989,645 ns)
+///
+/// The percent number is important and indicates how much weight
+/// was used as compared to the consumed weight.
+/// This number should be below 100% for reference hardware.
+#[derive(Debug, Parser)]
+pub struct BlockCmd {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub params: BenchmarkParams,
+
+	/// Enable the Trie cache.
+	///
+	/// This should only be used for performance analysis and not for final results.
+	#[arg(long)]
+	pub enable_trie_cache: bool,
+}
+
+impl BlockCmd {
+	/// Benchmark the execution time of historic blocks and compare it to their consumed weight.
+	///
+	/// Output will be printed to console.
+	pub fn run<Block, BA, C>(&self, client: Arc<C>) -> Result<()>
+	where
+		Block: BlockT<Extrinsic = OpaqueExtrinsic>,
+		BA: ClientBackend<Block>,
+		C: BlockBuilderProvider<BA, Block, C>
+			+ BlockBackend<Block>
+			+ ProvideRuntimeApi<Block>
+			+ StorageProvider<Block, BA>
+			+ UsageProvider<Block>
+			+ HeaderBackend<Block>,
+		C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+	{
+		// Put everything in the benchmark type to have the generic types handy.
+		Benchmark::new(client, self.params.clone()).run()
+	}
+}
+
+// Boilerplate
+impl CliConfiguration for BlockCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+
+	fn trie_cache_maximum_size(&self) -> Result<Option<usize>> {
+		if self.enable_trie_cache {
+			Ok(self.import_params().map(|x| x.trie_cache_maximum_size()).unwrap_or_default())
+		} else {
+			Ok(None)
+		}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/block/mod.rs b/substrate/utils/frame/benchmarking-cli/src/block/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9fbd4ea70801366fda761dd442497869a14fcf9a
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/block/mod.rs
@@ -0,0 +1,24 @@
+// 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.
+
+//! Crate to benchmark the execution time of historic blocks
+//! and compare it to their consumed weight.
+
+mod bench;
+mod cmd;
+
+pub use cmd::BlockCmd;
diff --git a/substrate/utils/frame/benchmarking-cli/src/extrinsic/bench.rs b/substrate/utils/frame/benchmarking-cli/src/extrinsic/bench.rs
new file mode 100644
index 0000000000000000000000000000000000000000..693b9f99f08e88151df43db025dec3f19b44d2e4
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/extrinsic/bench.rs
@@ -0,0 +1,204 @@
+// 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.
+
+//! Contains the core benchmarking logic.
+
+use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
+use sc_cli::{Error, Result};
+use sc_client_api::Backend as ClientBackend;
+use sp_api::{ApiExt, Core, ProvideRuntimeApi};
+use sp_blockchain::{
+	ApplyExtrinsicFailed::Validity,
+	Error::{ApplyExtrinsicFailed, RuntimeApiError},
+};
+use sp_runtime::{
+	traits::Block as BlockT,
+	transaction_validity::{InvalidTransaction, TransactionValidityError},
+	Digest, DigestItem, OpaqueExtrinsic,
+};
+
+use clap::Args;
+use log::info;
+use serde::Serialize;
+use std::{marker::PhantomData, sync::Arc, time::Instant};
+
+use super::ExtrinsicBuilder;
+use crate::shared::{StatSelect, Stats};
+
+/// Parameters to configure an *overhead* benchmark.
+#[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
+pub struct BenchmarkParams {
+	/// Rounds of warmups before measuring.
+	#[arg(long, default_value_t = 10)]
+	pub warmup: u32,
+
+	/// How many times the benchmark should be repeated.
+	#[arg(long, default_value_t = 100)]
+	pub repeat: u32,
+
+	/// Maximal number of extrinsics that should be put into a block.
+	///
+	/// Only useful for debugging.
+	#[arg(long)]
+	pub max_ext_per_block: Option<u32>,
+}
+
+/// The results of multiple runs in nano seconds.
+pub(crate) type BenchRecord = Vec<u64>;
+
+/// Holds all objects needed to run the *overhead* benchmarks.
+pub(crate) struct Benchmark<Block, BA, C> {
+	client: Arc<C>,
+	params: BenchmarkParams,
+	inherent_data: sp_inherents::InherentData,
+	digest_items: Vec<DigestItem>,
+	_p: PhantomData<(Block, BA)>,
+}
+
+impl<Block, BA, C> Benchmark<Block, BA, C>
+where
+	Block: BlockT<Extrinsic = OpaqueExtrinsic>,
+	BA: ClientBackend<Block>,
+	C: BlockBuilderProvider<BA, Block, C>
+		+ ProvideRuntimeApi<Block>
+		+ sp_blockchain::HeaderBackend<Block>,
+	C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+{
+	/// Create a new [`Self`] from the arguments.
+	pub fn new(
+		client: Arc<C>,
+		params: BenchmarkParams,
+		inherent_data: sp_inherents::InherentData,
+		digest_items: Vec<DigestItem>,
+	) -> Self {
+		Self { client, params, inherent_data, digest_items, _p: PhantomData }
+	}
+
+	/// Benchmark a block with only inherents.
+	pub fn bench_block(&self) -> Result<Stats> {
+		let (block, _) = self.build_block(None)?;
+		let record = self.measure_block(&block)?;
+		Stats::new(&record)
+	}
+
+	/// Benchmark the time of an extrinsic in a full block.
+	///
+	/// First benchmarks an empty block, analogous to `bench_block` and use it as baseline.
+	/// Then benchmarks a full block built with the given `ext_builder` and subtracts the baseline
+	/// from the result.
+	/// This is necessary to account for the time the inherents use.
+	pub fn bench_extrinsic(&self, ext_builder: &dyn ExtrinsicBuilder) -> Result<Stats> {
+		let (block, _) = self.build_block(None)?;
+		let base = self.measure_block(&block)?;
+		let base_time = Stats::new(&base)?.select(StatSelect::Average);
+
+		let (block, num_ext) = self.build_block(Some(ext_builder))?;
+		let num_ext = num_ext.ok_or_else(|| Error::Input("Block was empty".into()))?;
+		let mut records = self.measure_block(&block)?;
+
+		for r in &mut records {
+			// Subtract the base time.
+			*r = r.saturating_sub(base_time);
+			// Divide by the number of extrinsics in the block.
+			*r = ((*r as f64) / (num_ext as f64)).ceil() as u64;
+		}
+
+		Stats::new(&records)
+	}
+
+	/// Builds a block with some optional extrinsics.
+	///
+	/// Returns the block and the number of extrinsics in the block
+	/// that are not inherents.
+	/// Returns a block with only inherents if `ext_builder` is `None`.
+	fn build_block(
+		&self,
+		ext_builder: Option<&dyn ExtrinsicBuilder>,
+	) -> Result<(Block, Option<u64>)> {
+		let mut builder = self.client.new_block(Digest { logs: self.digest_items.clone() })?;
+		// Create and insert the inherents.
+		let inherents = builder.create_inherents(self.inherent_data.clone())?;
+		for inherent in inherents {
+			builder.push(inherent)?;
+		}
+
+		// Return early if `ext_builder` is `None`.
+		let ext_builder = if let Some(ext_builder) = ext_builder {
+			ext_builder
+		} else {
+			return Ok((builder.build()?.block, None))
+		};
+
+		// Put as many extrinsics into the block as possible and count them.
+		info!("Building block, this takes some time...");
+		let mut num_ext = 0;
+		for nonce in 0..self.max_ext_per_block() {
+			let ext = ext_builder.build(nonce)?;
+			match builder.push(ext.clone()) {
+				Ok(()) => {},
+				Err(ApplyExtrinsicFailed(Validity(TransactionValidityError::Invalid(
+					InvalidTransaction::ExhaustsResources,
+				)))) => break, // Block is full
+				Err(e) => return Err(Error::Client(e)),
+			}
+			num_ext += 1;
+		}
+		if num_ext == 0 {
+			return Err("A Block must hold at least one extrinsic".into())
+		}
+		info!("Extrinsics per block: {}", num_ext);
+		let block = builder.build()?.block;
+
+		Ok((block, Some(num_ext)))
+	}
+
+	/// Measures the time that it take to execute a block or an extrinsic.
+	fn measure_block(&self, block: &Block) -> Result<BenchRecord> {
+		let mut record = BenchRecord::new();
+		let genesis = self.client.info().genesis_hash;
+
+		info!("Running {} warmups...", self.params.warmup);
+		for _ in 0..self.params.warmup {
+			self.client
+				.runtime_api()
+				.execute_block(genesis, block.clone())
+				.map_err(|e| Error::Client(RuntimeApiError(e)))?;
+		}
+
+		info!("Executing block {} times", self.params.repeat);
+		// Interesting part here:
+		// Execute a block multiple times and record each execution time.
+		for _ in 0..self.params.repeat {
+			let block = block.clone();
+			let runtime_api = self.client.runtime_api();
+			let start = Instant::now();
+
+			runtime_api
+				.execute_block(genesis, block)
+				.map_err(|e| Error::Client(RuntimeApiError(e)))?;
+
+			let elapsed = start.elapsed().as_nanos();
+			record.push(elapsed as u64);
+		}
+
+		Ok(record)
+	}
+
+	fn max_ext_per_block(&self) -> u32 {
+		self.params.max_ext_per_block.unwrap_or(u32::MAX)
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/extrinsic/cmd.rs b/substrate/utils/frame/benchmarking-cli/src/extrinsic/cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4c3a6ed1bcd7816ba388c3d07c33fe9a8cfa7361
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/extrinsic/cmd.rs
@@ -0,0 +1,151 @@
+// 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 sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
+use sc_cli::{CliConfiguration, ImportParams, Result, SharedParams};
+use sc_client_api::Backend as ClientBackend;
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_runtime::{traits::Block as BlockT, DigestItem, OpaqueExtrinsic};
+
+use clap::{Args, Parser};
+use log::info;
+use serde::Serialize;
+use std::{fmt::Debug, sync::Arc};
+
+use super::{
+	bench::{Benchmark, BenchmarkParams},
+	extrinsic_factory::ExtrinsicFactory,
+};
+
+/// Benchmark the execution time of different extrinsics.
+///
+/// This is calculated by filling a block with a specific extrinsic and executing the block.
+/// The result time is then divided by the number of extrinsics in that block.
+///
+/// NOTE: The BlockExecutionWeight is ignored  in this case since it
+// is very small compared to the total block execution time.
+#[derive(Debug, Parser)]
+pub struct ExtrinsicCmd {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub params: ExtrinsicParams,
+}
+
+/// The params for the [`ExtrinsicCmd`].
+#[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
+pub struct ExtrinsicParams {
+	#[clap(flatten)]
+	pub bench: BenchmarkParams,
+
+	/// List all available pallets and extrinsics.
+	///
+	/// The format is CSV with header `pallet, extrinsic`.
+	#[arg(long)]
+	pub list: bool,
+
+	/// Pallet name of the extrinsic to benchmark.
+	#[arg(long, value_name = "PALLET", required_unless_present = "list")]
+	pub pallet: Option<String>,
+
+	/// Extrinsic to benchmark.
+	#[arg(long, value_name = "EXTRINSIC", required_unless_present = "list")]
+	pub extrinsic: Option<String>,
+
+	/// Enable the Trie cache.
+	///
+	/// This should only be used for performance analysis and not for final results.
+	#[arg(long)]
+	pub enable_trie_cache: bool,
+}
+
+impl ExtrinsicCmd {
+	/// Benchmark the execution time of a specific type of extrinsic.
+	///
+	/// The output will be printed to console.
+	pub fn run<Block, BA, C>(
+		&self,
+		client: Arc<C>,
+		inherent_data: sp_inherents::InherentData,
+		digest_items: Vec<DigestItem>,
+		ext_factory: &ExtrinsicFactory,
+	) -> Result<()>
+	where
+		Block: BlockT<Extrinsic = OpaqueExtrinsic>,
+		BA: ClientBackend<Block>,
+		C: BlockBuilderProvider<BA, Block, C>
+			+ ProvideRuntimeApi<Block>
+			+ sp_blockchain::HeaderBackend<Block>,
+		C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+	{
+		// Short circuit if --list was specified.
+		if self.params.list {
+			let list: Vec<String> = ext_factory.0.iter().map(|b| b.name()).collect();
+			info!(
+				"Listing available extrinsics ({}):\npallet, extrinsic\n{}",
+				list.len(),
+				list.join("\n")
+			);
+			return Ok(())
+		}
+
+		let pallet = self.params.pallet.clone().unwrap_or_default();
+		let extrinsic = self.params.extrinsic.clone().unwrap_or_default();
+		let ext_builder = match ext_factory.try_get(&pallet, &extrinsic) {
+			Some(ext_builder) => ext_builder,
+			None =>
+				return Err("Unknown pallet or extrinsic. Use --list for a complete list.".into()),
+		};
+
+		let bench = Benchmark::new(client, self.params.bench.clone(), inherent_data, digest_items);
+		let stats = bench.bench_extrinsic(ext_builder)?;
+		info!(
+			"Executing a {}::{} extrinsic takes[ns]:\n{:?}",
+			ext_builder.pallet(),
+			ext_builder.extrinsic(),
+			stats
+		);
+
+		Ok(())
+	}
+}
+
+// Boilerplate
+impl CliConfiguration for ExtrinsicCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+
+	fn trie_cache_maximum_size(&self) -> Result<Option<usize>> {
+		if self.params.enable_trie_cache {
+			Ok(self.import_params().map(|x| x.trie_cache_maximum_size()).unwrap_or_default())
+		} else {
+			Ok(None)
+		}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/extrinsic/extrinsic_factory.rs b/substrate/utils/frame/benchmarking-cli/src/extrinsic/extrinsic_factory.rs
new file mode 100644
index 0000000000000000000000000000000000000000..9a209e9c56cffe89bf5a79f0503194ff688bc05f
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/extrinsic/extrinsic_factory.rs
@@ -0,0 +1,70 @@
+// 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.
+
+//! Provides the [`ExtrinsicFactory`] and the [`ExtrinsicBuilder`] types.
+//! Is used by the *overhead* and *extrinsic* benchmarks to build extrinsics.
+
+use sp_runtime::OpaqueExtrinsic;
+
+/// Helper to manage [`ExtrinsicBuilder`] instances.
+#[derive(Default)]
+pub struct ExtrinsicFactory(pub Vec<Box<dyn ExtrinsicBuilder>>);
+
+impl ExtrinsicFactory {
+	/// Returns a builder for a pallet and extrinsic name.
+	///
+	/// Is case in-sensitive.
+	pub fn try_get(&self, pallet: &str, extrinsic: &str) -> Option<&dyn ExtrinsicBuilder> {
+		let pallet = pallet.to_lowercase();
+		let extrinsic = extrinsic.to_lowercase();
+
+		self.0
+			.iter()
+			.find(|b| b.pallet() == pallet && b.extrinsic() == extrinsic)
+			.map(|b| b.as_ref())
+	}
+}
+
+/// Used by the benchmark to build signed extrinsics.
+///
+/// The built extrinsics only need to be valid in the first block
+/// who's parent block is the genesis block.
+/// This assumption simplifies the generation of the extrinsics.
+/// The signer should be one of the pre-funded dev accounts.
+pub trait ExtrinsicBuilder {
+	/// Name of the pallet this builder is for.
+	///
+	/// Should be all lowercase.
+	fn pallet(&self) -> &str;
+
+	/// Name of the extrinsic this builder is for.
+	///
+	/// Should be all lowercase.
+	fn extrinsic(&self) -> &str;
+
+	/// Builds an extrinsic.
+	///
+	/// Will be called multiple times with increasing nonces.
+	fn build(&self, nonce: u32) -> std::result::Result<OpaqueExtrinsic, &'static str>;
+}
+
+impl dyn ExtrinsicBuilder + '_ {
+	/// Name of this builder in CSV format: `pallet, extrinsic`.
+	pub fn name(&self) -> String {
+		format!("{}, {}", self.pallet(), self.extrinsic())
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/extrinsic/mod.rs b/substrate/utils/frame/benchmarking-cli/src/extrinsic/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4e8a66c0286a1ca3e7a311b9cd70b82d8216cbb2
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/extrinsic/mod.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.
+
+//! Benchmark the time it takes to execute a specific extrinsic.
+//! This is a generalization of the *overhead* benchmark which can only measure `System::Remark`
+//! extrinsics.
+
+pub mod bench;
+pub mod cmd;
+pub mod extrinsic_factory;
+
+pub use cmd::ExtrinsicCmd;
+pub use extrinsic_factory::{ExtrinsicBuilder, ExtrinsicFactory};
diff --git a/substrate/utils/frame/benchmarking-cli/src/lib.rs b/substrate/utils/frame/benchmarking-cli/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..0ef2c299de63e8ac83bd8c0bd4c0ba501828d6f6
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/lib.rs
@@ -0,0 +1,121 @@
+// 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.
+
+//! Contains the root [`BenchmarkCmd`] command and exports its sub-commands.
+
+mod block;
+mod extrinsic;
+mod machine;
+mod overhead;
+mod pallet;
+mod shared;
+mod storage;
+
+pub use block::BlockCmd;
+pub use extrinsic::{ExtrinsicBuilder, ExtrinsicCmd, ExtrinsicFactory};
+pub use machine::{MachineCmd, SUBSTRATE_REFERENCE_HARDWARE};
+pub use overhead::OverheadCmd;
+pub use pallet::PalletCmd;
+pub use sc_service::BasePath;
+pub use storage::StorageCmd;
+
+use sc_cli::{CliConfiguration, DatabaseParams, ImportParams, PruningParams, Result, SharedParams};
+
+/// The root `benchmarking` command.
+///
+/// Has no effect itself besides printing a help menu of the sub-commands.
+#[derive(Debug, clap::Subcommand)]
+pub enum BenchmarkCmd {
+	Pallet(PalletCmd),
+	Storage(StorageCmd),
+	Overhead(OverheadCmd),
+	Block(BlockCmd),
+	Machine(MachineCmd),
+	Extrinsic(ExtrinsicCmd),
+}
+
+/// Unwraps a [`BenchmarkCmd`] into its concrete sub-command.
+macro_rules! unwrap_cmd {
+	{
+		$self:expr,
+		$cmd:ident,
+		$code:expr
+	} => {
+		match $self {
+			BenchmarkCmd::Pallet($cmd) => $code,
+			BenchmarkCmd::Storage($cmd) => $code,
+			BenchmarkCmd::Overhead($cmd) => $code,
+			BenchmarkCmd::Block($cmd) => $code,
+			BenchmarkCmd::Machine($cmd) => $code,
+			BenchmarkCmd::Extrinsic($cmd) => $code,
+		}
+	}
+}
+
+/// Forward the [`CliConfiguration`] trait implementation.
+///
+/// Each time a sub-command exposes a new config option, it must be added here.
+impl CliConfiguration for BenchmarkCmd {
+	fn shared_params(&self) -> &SharedParams {
+		unwrap_cmd! {
+			self, cmd, cmd.shared_params()
+		}
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		unwrap_cmd! {
+			self, cmd, cmd.import_params()
+		}
+	}
+
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		unwrap_cmd! {
+			self, cmd, cmd.database_params()
+		}
+	}
+
+	fn base_path(&self) -> Result<Option<BasePath>> {
+		let inner = unwrap_cmd! {
+			self, cmd, cmd.base_path()
+		};
+
+		// If the base path was not provided, benchmark command shall use temporary path. Otherwise
+		// we may end up using shared path, which may be inappropriate for benchmarking.
+		match inner {
+			Ok(None) => Some(BasePath::new_temp_dir()).transpose().map_err(|e| e.into()),
+			e => e,
+		}
+	}
+
+	fn pruning_params(&self) -> Option<&PruningParams> {
+		unwrap_cmd! {
+			self, cmd, cmd.pruning_params()
+		}
+	}
+
+	fn trie_cache_maximum_size(&self) -> Result<Option<usize>> {
+		unwrap_cmd! {
+			self, cmd, cmd.trie_cache_maximum_size()
+		}
+	}
+
+	fn chain_id(&self, is_dev: bool) -> Result<String> {
+		unwrap_cmd! {
+			self, cmd, cmd.chain_id(is_dev)
+		}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/machine/README.md b/substrate/utils/frame/benchmarking-cli/src/machine/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f22a8ea54b81dbf9f4336809fde0671cda2aed11
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/machine/README.md
@@ -0,0 +1,71 @@
+# The `benchmark machine` command
+
+Different Substrate chains can have different hardware requirements.  
+It is therefore important to be able to quickly gauge if a piece of hardware fits a chains' requirements.  
+The `benchmark machine` command archives this by measuring key metrics and making them comparable.  
+
+Invoking the command looks like this:  
+```sh
+cargo run --profile=production -- benchmark machine --dev
+```
+
+## Output
+
+The output on reference hardware:  
+
+```pre
++----------+----------------+---------------+--------------+-------------------+
+| Category | Function       | Score         | Minimum      | Result            |
++----------+----------------+---------------+--------------+-------------------+
+| CPU      | BLAKE2-256     | 1023.00 MiB/s | 1.00 GiB/s   | ✅ Pass ( 99.4 %) |
++----------+----------------+---------------+--------------+-------------------+
+| CPU      | SR25519-Verify | 665.13 KiB/s  | 666.00 KiB/s | ✅ Pass ( 99.9 %) |
++----------+----------------+---------------+--------------+-------------------+
+| Memory   | Copy           | 14.39 GiB/s   | 14.32 GiB/s  | ✅ Pass (100.4 %) |
++----------+----------------+---------------+--------------+-------------------+
+| Disk     | Seq Write      | 457.00 MiB/s  | 450.00 MiB/s | ✅ Pass (101.6 %) |
++----------+----------------+---------------+--------------+-------------------+
+| Disk     | Rnd Write      | 190.00 MiB/s  | 200.00 MiB/s | ✅ Pass ( 95.0 %) |
++----------+----------------+---------------+--------------+-------------------+
+```
+
+The *score* is the average result of each benchmark. It always adheres to "higher is better".  
+
+The *category* indicate which part of the hardware was benchmarked:  
+- **CPU** Processor intensive task
+- **Memory** RAM intensive task
+- **Disk** Hard drive intensive task
+
+The *function* is the concrete benchmark that was run:  
+- **BLAKE2-256** The throughput of the [Blake2-256] cryptographic hashing function with 32 KiB input. The [blake2_256 function] is used in many places in Substrate. The throughput of a hash function strongly depends on the input size, therefore we settled to use a fixed input size for comparable results.
+- **SR25519 Verify** Sr25519 is an optimized version of the [Curve25519] signature scheme. Signature verification is used by Substrate when verifying extrinsics and blocks.
+- **Copy** The throughput of copying memory from one place in the RAM to another.
+- **Seq Write** The throughput of writing data to the storage location sequentially. It is important that the same disk is used that will later-on be used to store the chain data.
+- **Rnd Write** The throughput of writing data to the storage location in a random order. This is normally much slower than the sequential write.
+
+The *score* needs to reach the *minimum* in order to pass the benchmark. This can be reduced with the `--tolerance` flag.
+
+The *result* indicated if a specific benchmark was passed by the machine or not. The percent number is the relative score reached to the *minimum* that is needed. The `--tolerance` flag is taken into account for this decision. For example a benchmark that passes even with 95% since the *tolerance* was set to 10% would look like this: `✅ Pass ( 95.0 %)`.
+
+## Interpretation
+
+Ideally all results show a `Pass` and the program exits with code 0. Currently some of the benchmarks can fail even on reference hardware; they are still being improved to make them more deterministic.  
+Make sure to run nothing else on the machine when benchmarking it.  
+You can re-run them multiple times to get more reliable results.
+
+## Arguments
+
+- `--tolerance` A percent number to reduce the *minimum* requirement. This should be used to ignore outliers of the benchmarks. The default value is 10%.
+- `--verify-duration` How long the verification benchmark should run.
+- `--disk-duration` How long the *read* and *write* benchmarks should run each.
+- `--allow-fail` Always exit the program with code 0.
+- `--chain` / `--dev` Specify the chain config to use. This will be used to compare the results with the requirements of the chain (WIP).
+- [`--base-path`]
+
+License: Apache-2.0
+
+<!-- LINKS -->
+[Blake2-256]: https://www.blake2.net/
+[blake2_256 function]: https://crates.parity.io/sp_core/hashing/fn.blake2_256.html
+[Curve25519]: https://en.wikipedia.org/wiki/Curve25519
+[`--base-path`]: ../shared/README.md#arguments
diff --git a/substrate/utils/frame/benchmarking-cli/src/machine/hardware.rs b/substrate/utils/frame/benchmarking-cli/src/machine/hardware.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5a4b7c797b6f184d9326e2a2cdee0b0336ac827e
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/machine/hardware.rs
@@ -0,0 +1,68 @@
+// 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.
+
+//! Contains types to define hardware requirements.
+
+use lazy_static::lazy_static;
+use sc_sysinfo::Requirements;
+
+lazy_static! {
+	/// The hardware requirements as measured on reference hardware.
+	///
+	/// These values are provided by Parity, however it is possible
+	/// to use your own requirements if you are running a custom chain.
+	pub static ref SUBSTRATE_REFERENCE_HARDWARE: Requirements = {
+		let raw = include_bytes!("reference_hardware.json").as_slice();
+		serde_json::from_slice(raw).expect("Hardcoded data is known good; qed")
+	};
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sc_sysinfo::{Metric, Requirement, Requirements, Throughput};
+
+	/// `SUBSTRATE_REFERENCE_HARDWARE` can be decoded.
+	#[test]
+	fn json_static_data() {
+		let raw = serde_json::to_string(&*SUBSTRATE_REFERENCE_HARDWARE).unwrap();
+		let decoded: Requirements = serde_json::from_str(&raw).unwrap();
+
+		assert_eq!(decoded, SUBSTRATE_REFERENCE_HARDWARE.clone());
+	}
+
+	/// The hard-coded values are correct.
+	#[test]
+	fn json_static_data_is_correct() {
+		assert_eq!(
+			*SUBSTRATE_REFERENCE_HARDWARE,
+			Requirements(vec![
+				Requirement { metric: Metric::Blake2256, minimum: Throughput::from_mibs(783.27) },
+				Requirement {
+					metric: Metric::Sr25519Verify,
+					minimum: Throughput::from_kibs(560.670000128),
+				},
+				Requirement {
+					metric: Metric::MemCopy,
+					minimum: Throughput::from_gibs(11.4925205078125003),
+				},
+				Requirement { metric: Metric::DiskSeqWrite, minimum: Throughput::from_mibs(950.0) },
+				Requirement { metric: Metric::DiskRndWrite, minimum: Throughput::from_mibs(420.0) },
+			])
+		);
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/machine/mod.rs b/substrate/utils/frame/benchmarking-cli/src/machine/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fb9f14c9a4af18ed540c74849934b6e124f4671e
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/machine/mod.rs
@@ -0,0 +1,240 @@
+// 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.
+
+//! Contains the [`MachineCmd`] as entry point for the node
+//! and the core benchmarking logic.
+
+pub mod hardware;
+
+use std::{boxed::Box, fs, path::Path};
+
+use clap::Parser;
+use comfy_table::{Row, Table};
+use log::{error, info, warn};
+
+use sc_cli::{CliConfiguration, Result, SharedParams};
+use sc_service::Configuration;
+use sc_sysinfo::{
+	benchmark_cpu, benchmark_disk_random_writes, benchmark_disk_sequential_writes,
+	benchmark_memory, benchmark_sr25519_verify, ExecutionLimit, Metric, Requirement, Requirements,
+	Throughput,
+};
+
+use crate::shared::check_build_profile;
+pub use hardware::SUBSTRATE_REFERENCE_HARDWARE;
+
+/// Command to benchmark the hardware.
+///
+/// Runs multiple benchmarks and prints their output to console.
+/// Can be used to gauge if the hardware is fast enough to keep up with a chain's requirements.
+/// This command must be integrated by the client since the client can set compiler flags
+/// which influence the results.
+///
+/// You can use the `--base-path` flag to set a location for the disk benchmarks.
+#[derive(Debug, Parser)]
+pub struct MachineCmd {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	/// Do not return an error if any check fails.
+	///
+	/// Should only be used for debugging.
+	#[arg(long)]
+	pub allow_fail: bool,
+
+	/// Set a fault tolerance for passing a requirement.
+	///
+	/// 10% means that the test would pass even when only 90% score was archived.
+	/// Can be used to mitigate outliers of the benchmarks.
+	#[arg(long, default_value_t = 10.0, value_name = "PERCENT")]
+	pub tolerance: f64,
+
+	/// Time limit for the verification benchmark.
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
+	pub verify_duration: f32,
+
+	/// Time limit for the hash function benchmark.
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
+	pub hash_duration: f32,
+
+	/// Time limit for the memory benchmark.
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
+	pub memory_duration: f32,
+
+	/// Time limit for each disk benchmark.
+	#[arg(long, default_value_t = 5.0, value_name = "SECONDS")]
+	pub disk_duration: f32,
+}
+
+/// Helper for the result of a concrete benchmark.
+struct BenchResult {
+	/// Did the hardware pass the benchmark?
+	passed: bool,
+
+	/// The absolute score that was archived.
+	score: Throughput,
+
+	/// The score relative to the minimal required score.
+	///
+	/// Is in range [0, 1].
+	rel_score: f64,
+}
+
+/// Errors that can be returned by the this command.
+#[derive(Debug, thiserror::Error)]
+#[allow(missing_docs)]
+pub enum Error {
+	#[error("One of the benchmarks had a score that was lower than its requirement")]
+	UnmetRequirement,
+
+	#[error("The build profile is unfit for benchmarking: {0}")]
+	BadBuildProfile(String),
+
+	#[error("Benchmark results are off by at least factor 100")]
+	BadResults,
+}
+
+impl MachineCmd {
+	/// Execute the benchmark and print the results.
+	pub fn run(&self, cfg: &Configuration, requirements: Requirements) -> Result<()> {
+		self.validate_args()?;
+		// Ensure that the dir exists since the node is not started to take care of it.
+		let dir = cfg.database.path().ok_or("No DB directory provided")?;
+		fs::create_dir_all(dir)?;
+
+		info!("Running machine benchmarks...");
+		let mut results = Vec::new();
+		for requirement in &requirements.0 {
+			let result = self.run_benchmark(requirement, &dir)?;
+			results.push(result);
+		}
+		self.print_summary(requirements, results)
+	}
+
+	/// Benchmarks a specific metric of the hardware and judges the resulting score.
+	fn run_benchmark(&self, requirement: &Requirement, dir: &Path) -> Result<BenchResult> {
+		// Dispatch the concrete function from `sc-sysinfo`.
+
+		let score = self.measure(&requirement.metric, dir)?;
+		let rel_score = score.as_bytes() / requirement.minimum.as_bytes();
+
+		// Sanity check if the result is off by factor >100x.
+		if rel_score >= 100.0 || rel_score <= 0.01 {
+			self.check_failed(Error::BadResults)?;
+		}
+		let passed = rel_score >= (1.0 - (self.tolerance / 100.0));
+		Ok(BenchResult { passed, score, rel_score })
+	}
+
+	/// Measures a metric of the hardware.
+	fn measure(&self, metric: &Metric, dir: &Path) -> Result<Throughput> {
+		let verify_limit = ExecutionLimit::from_secs_f32(self.verify_duration);
+		let disk_limit = ExecutionLimit::from_secs_f32(self.disk_duration);
+		let hash_limit = ExecutionLimit::from_secs_f32(self.hash_duration);
+		let memory_limit = ExecutionLimit::from_secs_f32(self.memory_duration);
+
+		let score = match metric {
+			Metric::Blake2256 => benchmark_cpu(hash_limit),
+			Metric::Sr25519Verify => benchmark_sr25519_verify(verify_limit),
+			Metric::MemCopy => benchmark_memory(memory_limit),
+			Metric::DiskSeqWrite => benchmark_disk_sequential_writes(disk_limit, dir)?,
+			Metric::DiskRndWrite => benchmark_disk_random_writes(disk_limit, dir)?,
+		};
+		Ok(score)
+	}
+
+	/// Prints a human-readable summary.
+	fn print_summary(&self, requirements: Requirements, results: Vec<BenchResult>) -> Result<()> {
+		// Use a table for nicer console output.
+		let mut table = Table::new();
+		table.set_header(["Category", "Function", "Score", "Minimum", "Result"]);
+		// Count how many passed and how many failed.
+		let (mut passed, mut failed) = (0, 0);
+		for (requirement, result) in requirements.0.iter().zip(results.iter()) {
+			if result.passed {
+				passed += 1
+			} else {
+				failed += 1
+			}
+
+			table.add_row(result.to_row(requirement));
+		}
+		// Print the table and a summary.
+		info!(
+			"\n{}\nFrom {} benchmarks in total, {} passed and {} failed ({:.0?}% fault tolerance).",
+			table,
+			passed + failed,
+			passed,
+			failed,
+			self.tolerance
+		);
+		// Print the final result.
+		if failed != 0 {
+			info!("The hardware fails to meet the requirements");
+			self.check_failed(Error::UnmetRequirement)?;
+		} else {
+			info!("The hardware meets the requirements ");
+		}
+		// Check that the results were not created by a bad build profile.
+		if let Err(err) = check_build_profile() {
+			self.check_failed(Error::BadBuildProfile(err))?;
+		}
+		Ok(())
+	}
+
+	/// Returns `Ok` if [`self.allow_fail`] is set and otherwise the error argument.
+	fn check_failed(&self, e: Error) -> Result<()> {
+		if !self.allow_fail {
+			error!("Failing since --allow-fail is not set");
+			Err(sc_cli::Error::Application(Box::new(e)))
+		} else {
+			warn!("Ignoring error since --allow-fail is set: {:?}", e);
+			Ok(())
+		}
+	}
+
+	/// Validates the CLI arguments.
+	fn validate_args(&self) -> Result<()> {
+		if self.tolerance > 100.0 || self.tolerance < 0.0 {
+			return Err("The --tolerance argument is out of range".into())
+		}
+		Ok(())
+	}
+}
+
+impl BenchResult {
+	/// Format [`Self`] as row that can be printed in a table.
+	fn to_row(&self, req: &Requirement) -> Row {
+		let passed = if self.passed { "✅ Pass" } else { "� Fail" };
+		vec![
+			req.metric.category().into(),
+			req.metric.name().into(),
+			format!("{}", self.score),
+			format!("{}", req.minimum),
+			format!("{} ({: >5.1?} %)", passed, self.rel_score * 100.0),
+		]
+		.into()
+	}
+}
+
+// Boilerplate
+impl CliConfiguration for MachineCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/machine/reference_hardware.json b/substrate/utils/frame/benchmarking-cli/src/machine/reference_hardware.json
new file mode 100644
index 0000000000000000000000000000000000000000..c2fb4c7d4a285b470a02169391a308a6703fc97e
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/machine/reference_hardware.json
@@ -0,0 +1,22 @@
+[
+	{
+		"metric": "Blake2256",
+		"minimum": 783.27
+	},
+	{
+		"metric": "Sr25519Verify",
+		"minimum": 0.547529297
+	},
+	{
+		"metric": "MemCopy",
+		"minimum": 11768.341
+	},
+	{
+		"metric": "DiskSeqWrite",
+		"minimum": 950.0
+	},
+	{
+		"metric": "DiskRndWrite",
+		"minimum": 420.0
+	}
+]
diff --git a/substrate/utils/frame/benchmarking-cli/src/overhead/README.md b/substrate/utils/frame/benchmarking-cli/src/overhead/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..390bc09e41701ed5b3fe03308ea3857d5ba41ed1
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/overhead/README.md
@@ -0,0 +1,138 @@
+# The `benchmark overhead` command
+
+Each time an extrinsic or a block is executed, a fixed weight is charged as "execution overhead".
+This is necessary since the weight that is calculated by the pallet benchmarks does not include this overhead.
+The exact overhead to can vary per Substrate chain and needs to be calculated per chain.
+This command calculates the exact values of these overhead weights for any Substrate chain that supports it.
+
+## How does it work?
+
+The benchmark consists of two parts; the [`BlockExecutionWeight`] and the [`ExtrinsicBaseWeight`].
+Both are executed sequentially when invoking the command.
+
+## BlockExecutionWeight
+
+The block execution weight is defined as the weight that it takes to execute an *empty block*.
+It is measured by constructing an empty block and measuring its executing time.
+The result are written to a `block_weights.rs` file which is created from a template.
+The file will contain the concrete weight value and various statistics about the measurements. For example:
+```rust
+/// Time to execute an empty block.
+/// Calculated by multiplying the *Average* with `1` and adding `0`.
+///
+/// Stats [NS]:
+///   Min, Max: 3_508_416, 3_680_498
+///   Average:  3_532_484
+///   Median:   3_522_111
+///   Std-Dev:  27070.23
+///
+/// Percentiles [NS]:
+///   99th: 3_631_863
+///   95th: 3_595_674
+///   75th: 3_526_435
+pub const BlockExecutionWeight: Weight =
+    Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(3_532_484), 0);
+```
+
+In this example it takes 3.5 ms to execute an empty block. That means that it always takes at least 3.5 ms to execute *any* block.
+This constant weight is therefore added to each block to ensure that Substrate budgets enough time to execute it.
+
+## ExtrinsicBaseWeight
+
+The extrinsic base weight is defined as the weight that it takes to execute an *empty* extrinsic.
+An *empty* extrinsic is also called a *NO-OP*. It does nothing and is the equivalent to the empty block form above.
+The benchmark now constructs a block which is filled with only NO-OP extrinsics.
+This block is then executed many times and the weights are measured.
+The result is divided by the number of extrinsics in that block and the results are written to `extrinsic_weights.rs`.
+
+The relevant section in the output file looks like this:
+```rust
+ /// Time to execute a NO-OP extrinsic, for example `System::remark`.
+/// Calculated by multiplying the *Average* with `1` and adding `0`.
+///
+/// Stats [NS]:
+///   Min, Max: 67_561, 69_855
+///   Average:  67_745
+///   Median:   67_701
+///   Std-Dev:  264.68
+///
+/// Percentiles [NS]:
+///   99th: 68_758
+///   95th: 67_843
+///   75th: 67_749
+pub const ExtrinsicBaseWeight: Weight =
+    Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(67_745), 0);
+```
+
+In this example it takes 67.7 µs to execute a NO-OP extrinsic. That means that it always takes at least 67.7 µs to execute *any* extrinsic.
+This constant weight is therefore added to each extrinsic to ensure that Substrate budgets enough time to execute it.
+
+## Invocation
+
+The base command looks like this (for debugging you can use `--release`):
+```sh
+cargo run --profile=production -- benchmark overhead --dev
+```
+
+Output:
+```pre
+# BlockExecutionWeight
+Running 10 warmups...
+Executing block 100 times
+Per-block execution overhead [ns]:
+Total: 353248430
+Min: 3508416, Max: 3680498
+Average: 3532484, Median: 3522111, Stddev: 27070.23
+Percentiles 99th, 95th, 75th: 3631863, 3595674, 3526435
+Writing weights to "block_weights.rs"
+
+# Setup
+Building block, this takes some time...
+Extrinsics per block: 12000
+
+# ExtrinsicBaseWeight
+Running 10 warmups...
+Executing block 100 times
+Per-extrinsic execution overhead [ns]:
+Total: 6774590
+Min: 67561, Max: 69855
+Average: 67745, Median: 67701, Stddev: 264.68
+Percentiles 99th, 95th, 75th: 68758, 67843, 67749
+Writing weights to "extrinsic_weights.rs"
+```
+
+The complete command for Polkadot looks like this:
+```sh
+cargo run --profile=production -- benchmark overhead --chain=polkadot-dev --wasm-execution=compiled --weight-path=runtime/polkadot/constants/src/weights/
+```
+
+This will overwrite the 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) files in the Polkadot runtime directory.
+You can try the same for *Rococo* and to see that the results slightly differ.
+👉 It is paramount to use `--profile=production` and `--wasm-execution=compiled` as the results are otherwise useless.
+
+## Output Interpretation
+
+Lower is better. The less weight the execution overhead needs, the better.
+Since the weights of the overhead is charged per extrinsic and per block, a larger weight results in less extrinsics per block.
+Minimizing this is important to have a large transaction throughput.
+
+## Arguments
+
+- `--chain` / `--dev` Set the chain specification.
+- `--weight-path` Set the output directory or file to write the weights to.
+- `--repeat` Set the repetitions of both benchmarks.
+- `--warmup` Set the rounds of warmup before measuring.
+- `--wasm-execution` Should be set to `compiled` for correct results.
+- [`--mul`](../shared/README.md#arguments)
+- [`--add`](../shared/README.md#arguments)
+- [`--metric`](../shared/README.md#arguments)
+- [`--weight-path`](../shared/README.md#arguments)
+- [`--header`](../shared/README.md#arguments)
+
+License: Apache-2.0
+
+<!-- LINKS -->
+[`ExtrinsicBaseWeight`]: https://github.com/paritytech/substrate/blob/580ebae17fa30082604f1c9720f6f4a1cfe95b50/frame/support/src/weights/extrinsic_weights.rs#L26
+[`BlockExecutionWeight`]: https://github.com/paritytech/substrate/blob/580ebae17fa30082604f1c9720f6f4a1cfe95b50/frame/support/src/weights/block_weights.rs#L26
+
+[System::Remark]: https://github.com/paritytech/substrate/blob/580ebae17fa30082604f1c9720f6f4a1cfe95b50/frame/system/src/lib.rs#L382
diff --git a/substrate/utils/frame/benchmarking-cli/src/overhead/cmd.rs b/substrate/utils/frame/benchmarking-cli/src/overhead/cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5a4c37b1f6f07301766a6693fde250c769c50e58
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/overhead/cmd.rs
@@ -0,0 +1,175 @@
+// 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.
+
+//! Contains the [`OverheadCmd`] as entry point for the CLI to execute
+//! the *overhead* benchmarks.
+
+use sc_block_builder::{BlockBuilderApi, BlockBuilderProvider};
+use sc_cli::{CliConfiguration, ImportParams, Result, SharedParams};
+use sc_client_api::Backend as ClientBackend;
+use sc_service::Configuration;
+use sp_api::{ApiExt, ProvideRuntimeApi};
+use sp_runtime::{traits::Block as BlockT, DigestItem, OpaqueExtrinsic};
+
+use clap::{Args, Parser};
+use log::info;
+use serde::Serialize;
+use std::{fmt::Debug, path::PathBuf, sync::Arc};
+
+use crate::{
+	extrinsic::{
+		bench::{Benchmark, BenchmarkParams as ExtrinsicBenchmarkParams},
+		ExtrinsicBuilder,
+	},
+	overhead::template::TemplateData,
+	shared::{HostInfoParams, WeightParams},
+};
+
+/// Benchmark the execution overhead per-block and per-extrinsic.
+#[derive(Debug, Parser)]
+pub struct OverheadCmd {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub import_params: ImportParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub params: OverheadParams,
+}
+
+/// Configures the benchmark, the post-processing and weight generation.
+#[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
+pub struct OverheadParams {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub weight: WeightParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub bench: ExtrinsicBenchmarkParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub hostinfo: HostInfoParams,
+
+	/// Add a header to the generated weight output file.
+	///
+	/// Good for adding LICENSE headers.
+	#[arg(long, value_name = "PATH")]
+	pub header: Option<PathBuf>,
+
+	/// Enable the Trie cache.
+	///
+	/// This should only be used for performance analysis and not for final results.
+	#[arg(long)]
+	pub enable_trie_cache: bool,
+}
+
+/// Type of a benchmark.
+#[derive(Serialize, Clone, PartialEq, Copy)]
+pub(crate) enum BenchmarkType {
+	/// Measure the per-extrinsic execution overhead.
+	Extrinsic,
+	/// Measure the per-block execution overhead.
+	Block,
+}
+
+impl OverheadCmd {
+	/// Measure the per-block and per-extrinsic execution overhead.
+	///
+	/// Writes the results to console and into two instances of the
+	/// `weights.hbs` template, one for each benchmark.
+	pub fn run<Block, BA, C>(
+		&self,
+		cfg: Configuration,
+		client: Arc<C>,
+		inherent_data: sp_inherents::InherentData,
+		digest_items: Vec<DigestItem>,
+		ext_builder: &dyn ExtrinsicBuilder,
+	) -> Result<()>
+	where
+		Block: BlockT<Extrinsic = OpaqueExtrinsic>,
+		BA: ClientBackend<Block>,
+		C: BlockBuilderProvider<BA, Block, C>
+			+ ProvideRuntimeApi<Block>
+			+ sp_blockchain::HeaderBackend<Block>,
+		C::Api: ApiExt<Block> + BlockBuilderApi<Block>,
+	{
+		if ext_builder.pallet() != "system" || ext_builder.extrinsic() != "remark" {
+			return Err(format!("The extrinsic builder is required to build `System::Remark` extrinsics but builds `{}` extrinsics instead", ext_builder.name()).into());
+		}
+		let bench = Benchmark::new(client, self.params.bench.clone(), inherent_data, digest_items);
+
+		// per-block execution overhead
+		{
+			let stats = bench.bench_block()?;
+			info!("Per-block execution overhead [ns]:\n{:?}", stats);
+			let template = TemplateData::new(BenchmarkType::Block, &cfg, &self.params, &stats)?;
+			template.write(&self.params.weight.weight_path)?;
+		}
+		// per-extrinsic execution overhead
+		{
+			let stats = bench.bench_extrinsic(ext_builder)?;
+			info!("Per-extrinsic execution overhead [ns]:\n{:?}", stats);
+			let template = TemplateData::new(BenchmarkType::Extrinsic, &cfg, &self.params, &stats)?;
+			template.write(&self.params.weight.weight_path)?;
+		}
+
+		Ok(())
+	}
+}
+
+impl BenchmarkType {
+	/// Short name of the benchmark type.
+	pub(crate) fn short_name(&self) -> &'static str {
+		match self {
+			Self::Extrinsic => "extrinsic",
+			Self::Block => "block",
+		}
+	}
+
+	/// Long name of the benchmark type.
+	pub(crate) fn long_name(&self) -> &'static str {
+		match self {
+			Self::Extrinsic => "ExtrinsicBase",
+			Self::Block => "BlockExecution",
+		}
+	}
+}
+
+// Boilerplate
+impl CliConfiguration for OverheadCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn import_params(&self) -> Option<&ImportParams> {
+		Some(&self.import_params)
+	}
+
+	fn trie_cache_maximum_size(&self) -> Result<Option<usize>> {
+		if self.params.enable_trie_cache {
+			Ok(self.import_params().map(|x| x.trie_cache_maximum_size()).unwrap_or_default())
+		} else {
+			Ok(None)
+		}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/overhead/mod.rs b/substrate/utils/frame/benchmarking-cli/src/overhead/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..00cde66fd7221c8c9b865f15e72a65a300577153
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/overhead/mod.rs
@@ -0,0 +1,21 @@
+// 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.
+
+pub mod cmd;
+pub mod template;
+
+pub use cmd::OverheadCmd;
diff --git a/substrate/utils/frame/benchmarking-cli/src/overhead/template.rs b/substrate/utils/frame/benchmarking-cli/src/overhead/template.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7c8c92b07d747c725ecb9e3408ccfc686e12258a
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/overhead/template.rs
@@ -0,0 +1,125 @@
+// 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.
+
+//! Converts a benchmark result into [`TemplateData`] and writes
+//! it into the `weights.hbs` template.
+
+use sc_cli::Result;
+use sc_service::Configuration;
+
+use handlebars::Handlebars;
+use log::info;
+use serde::Serialize;
+use std::{env, fs, path::PathBuf};
+
+use crate::{
+	overhead::cmd::{BenchmarkType, OverheadParams},
+	shared::{Stats, UnderscoreHelper},
+};
+
+static VERSION: &str = env!("CARGO_PKG_VERSION");
+static TEMPLATE: &str = include_str!("./weights.hbs");
+
+/// Data consumed by Handlebar to fill out the `weights.hbs` template.
+#[derive(Serialize, Debug, Clone)]
+pub(crate) struct TemplateData {
+	/// Short name of the benchmark. Can be "block" or "extrinsic".
+	long_name: String,
+	/// Long name of the benchmark. Can be "BlockExecution" or "ExtrinsicBase".
+	short_name: String,
+	/// Name of the runtime. Taken from the chain spec.
+	runtime_name: String,
+	/// Version of the benchmarking CLI used.
+	version: String,
+	/// Date that the template was filled out.
+	date: String,
+	/// Hostname of the machine that executed the benchmarks.
+	hostname: String,
+	/// CPU name of the machine that executed the benchmarks.
+	cpuname: String,
+	/// Header for the generated file.
+	header: String,
+	/// Command line arguments that were passed to the CLI.
+	args: Vec<String>,
+	/// Params of the executed command.
+	params: OverheadParams,
+	/// Stats about the benchmark result.
+	stats: Stats,
+	/// The resulting weight in ns.
+	weight: u64,
+}
+
+impl TemplateData {
+	/// Returns a new [`Self`] from the given params.
+	pub(crate) fn new(
+		t: BenchmarkType,
+		cfg: &Configuration,
+		params: &OverheadParams,
+		stats: &Stats,
+	) -> Result<Self> {
+		let weight = params.weight.calc_weight(stats)?;
+		let header = params
+			.header
+			.as_ref()
+			.map(|p| std::fs::read_to_string(p))
+			.transpose()?
+			.unwrap_or_default();
+
+		Ok(TemplateData {
+			short_name: t.short_name().into(),
+			long_name: t.long_name().into(),
+			runtime_name: cfg.chain_spec.name().into(),
+			version: VERSION.into(),
+			date: chrono::Utc::now().format("%Y-%m-%d (Y/M/D)").to_string(),
+			hostname: params.hostinfo.hostname(),
+			cpuname: params.hostinfo.cpuname(),
+			header,
+			args: env::args().collect::<Vec<String>>(),
+			params: params.clone(),
+			stats: stats.clone(),
+			weight,
+		})
+	}
+
+	/// Fill out the `weights.hbs` HBS template with its own data.
+	/// Writes the result to `path` which can be a directory or a file.
+	pub fn write(&self, path: &Option<PathBuf>) -> Result<()> {
+		let mut handlebars = Handlebars::new();
+		// Format large integers with underscores.
+		handlebars.register_helper("underscore", Box::new(UnderscoreHelper));
+		// Don't HTML escape any characters.
+		handlebars.register_escape_fn(|s| -> String { s.to_string() });
+
+		let out_path = self.build_path(path)?;
+		let mut fd = fs::File::create(&out_path)?;
+		info!("Writing weights to {:?}", fs::canonicalize(&out_path)?);
+		handlebars
+			.render_template_to_write(TEMPLATE, &self, &mut fd)
+			.map_err(|e| format!("HBS template write: {:?}", e).into())
+	}
+
+	/// Build a path for the weight file.
+	fn build_path(&self, weight_out: &Option<PathBuf>) -> Result<PathBuf> {
+		let mut path = weight_out.clone().unwrap_or_else(|| PathBuf::from("."));
+
+		if !path.is_dir() {
+			return Err("Need directory as --weight-path".into())
+		}
+		path.push(format!("{}_weights.rs", self.short_name));
+		Ok(path)
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/overhead/weights.hbs b/substrate/utils/frame/benchmarking-cli/src/overhead/weights.hbs
new file mode 100644
index 0000000000000000000000000000000000000000..6e364facc12f47a9dfcf9af13f04422fe86cdc11
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/overhead/weights.hbs
@@ -0,0 +1,76 @@
+{{header}}
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION {{version}}
+//! DATE: {{date}}
+//! HOSTNAME: `{{hostname}}`, CPU: `{{cpuname}}`
+//!
+//! SHORT-NAME: `{{short_name}}`, LONG-NAME: `{{long_name}}`, RUNTIME: `{{runtime_name}}`
+//! WARMUPS: `{{params.bench.warmup}}`, REPEAT: `{{params.bench.repeat}}`
+//! WEIGHT-PATH: `{{params.weight.weight_path}}`
+//! WEIGHT-METRIC: `{{params.weight.weight_metric}}`, WEIGHT-MUL: `{{params.weight.weight_mul}}`, WEIGHT-ADD: `{{params.weight.weight_add}}`
+
+// Executed Command:
+{{#each args as |arg|}}
+//   {{arg}}
+{{/each}}
+
+use sp_core::parameter_types;
+use sp_weights::{constants::WEIGHT_REF_TIME_PER_NANOS, Weight};
+
+parameter_types! {
+	{{#if (eq short_name "block")}}
+	/// Time to execute an empty block.
+	{{else}}
+	/// Time to execute a NO-OP extrinsic, for example `System::remark`.
+	{{/if}}
+	/// Calculated by multiplying the *{{params.weight.weight_metric}}* with `{{params.weight.weight_mul}}` and adding `{{params.weight.weight_add}}`.
+	///
+	/// Stats nanoseconds:
+	///   Min, Max: {{underscore stats.min}}, {{underscore stats.max}}
+	///   Average:  {{underscore stats.avg}}
+	///   Median:   {{underscore stats.median}}
+	///   Std-Dev:  {{stats.stddev}}
+	///
+	/// Percentiles nanoseconds:
+	///   99th: {{underscore stats.p99}}
+	///   95th: {{underscore stats.p95}}
+	///   75th: {{underscore stats.p75}}
+	pub const {{long_name}}Weight: Weight =
+		Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul({{underscore weight}}), 0);
+}
+
+#[cfg(test)]
+mod test_weights {
+	use sp_weights::constants;
+
+	/// Checks that the weight exists and is sane.
+	// NOTE: If this test fails but you are sure that the generated values are fine,
+	// you can delete it.
+	#[test]
+	fn sane() {
+		let w = super::{{long_name}}Weight::get();
+
+		{{#if (eq short_name "block")}}
+		// At least 100 µs.
+		assert!(
+			w.ref_time() >= 100u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
+			"Weight should be at least 100 µs."
+		);
+		// At most 50 ms.
+		assert!(
+			w.ref_time() <= 50u64 * constants::WEIGHT_REF_TIME_PER_MILLIS,
+			"Weight should be at most 50 ms."
+		);
+		{{else}}
+		// At least 10 µs.
+		assert!(
+			w.ref_time() >= 10u64 * constants::WEIGHT_REF_TIME_PER_MICROS,
+			"Weight should be at least 10 µs."
+		);
+		// At most 1 ms.
+		assert!(
+			w.ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+			"Weight should be at most 1 ms."
+		);
+		{{/if}}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/pallet/README.md b/substrate/utils/frame/benchmarking-cli/src/pallet/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..72845652de653fe2d2c675a41c7709aa25051791
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/pallet/README.md
@@ -0,0 +1,3 @@
+The pallet command is explained in [frame/benchmarking](../../../../../frame/benchmarking/README.md).
+
+License: Apache-2.0
diff --git a/substrate/utils/frame/benchmarking-cli/src/pallet/command.rs b/substrate/utils/frame/benchmarking-cli/src/pallet/command.rs
new file mode 100644
index 0000000000000000000000000000000000000000..84da3aaa02c00ec86fe4ead0438706aab64d6476
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/pallet/command.rs
@@ -0,0 +1,762 @@
+// 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::{writer, PalletCmd};
+use codec::{Decode, Encode};
+use frame_benchmarking::{
+	Analysis, BenchmarkBatch, BenchmarkBatchSplitResults, BenchmarkList, BenchmarkParameter,
+	BenchmarkResult, BenchmarkSelector,
+};
+use frame_support::traits::StorageInfo;
+use linked_hash_map::LinkedHashMap;
+use sc_cli::{execution_method_from_cli, CliConfiguration, Result, SharedParams};
+use sc_client_db::BenchmarkingState;
+use sc_executor::WasmExecutor;
+use sc_service::Configuration;
+use serde::Serialize;
+use sp_core::{
+	offchain::{
+		testing::{TestOffchainExt, TestTransactionPoolExt},
+		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
+	},
+	traits::{CallContext, ReadRuntimeVersionExt},
+};
+use sp_externalities::Extensions;
+use sp_keystore::{testing::MemoryKeystore, KeystoreExt};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use sp_state_machine::StateMachine;
+use std::{collections::HashMap, fmt::Debug, fs, str::FromStr, time};
+
+/// Logging target
+const LOG_TARGET: &'static str = "frame::benchmark::pallet";
+
+/// The inclusive range of a component.
+#[derive(Serialize, Debug, Clone, Eq, PartialEq)]
+pub(crate) struct ComponentRange {
+	/// Name of the component.
+	name: String,
+	/// Minimal valid value of the component.
+	min: u32,
+	/// Maximal valid value of the component.
+	max: u32,
+}
+
+/// How the PoV size of a storage item should be estimated.
+#[derive(clap::ValueEnum, Debug, Eq, PartialEq, Clone, Copy)]
+pub enum PovEstimationMode {
+	/// Use the maximal encoded length as provided by [`codec::MaxEncodedLen`].
+	MaxEncodedLen,
+	/// Measure the accessed value size in the pallet benchmarking and add some trie overhead.
+	Measured,
+	/// Do not estimate the PoV size for this storage item or benchmark.
+	Ignored,
+}
+
+impl FromStr for PovEstimationMode {
+	type Err = &'static str;
+
+	fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+		match s {
+			"MaxEncodedLen" => Ok(Self::MaxEncodedLen),
+			"Measured" => Ok(Self::Measured),
+			"Ignored" => Ok(Self::Ignored),
+			_ => unreachable!("The benchmark! macro should have prevented this"),
+		}
+	}
+}
+
+/// Maps (pallet, benchmark) -> ((pallet, storage) -> PovEstimationMode)
+pub(crate) type PovModesMap =
+	HashMap<(Vec<u8>, Vec<u8>), HashMap<(String, String), PovEstimationMode>>;
+
+// This takes multiple benchmark batches and combines all the results where the pallet, instance,
+// and benchmark are the same.
+fn combine_batches(
+	time_batches: Vec<BenchmarkBatch>,
+	db_batches: Vec<BenchmarkBatch>,
+) -> Vec<BenchmarkBatchSplitResults> {
+	if time_batches.is_empty() && db_batches.is_empty() {
+		return Default::default()
+	}
+
+	let mut all_benchmarks =
+		LinkedHashMap::<_, (Vec<BenchmarkResult>, Vec<BenchmarkResult>)>::new();
+
+	db_batches
+		.into_iter()
+		.for_each(|BenchmarkBatch { pallet, instance, benchmark, results }| {
+			// We use this key to uniquely identify a benchmark among batches.
+			let key = (pallet, instance, benchmark);
+
+			match all_benchmarks.get_mut(&key) {
+				// We already have this benchmark, so we extend the results.
+				Some(x) => x.1.extend(results),
+				// New benchmark, so we add a new entry with the initial results.
+				None => {
+					all_benchmarks.insert(key, (Vec::new(), results));
+				},
+			}
+		});
+
+	time_batches
+		.into_iter()
+		.for_each(|BenchmarkBatch { pallet, instance, benchmark, results }| {
+			// We use this key to uniquely identify a benchmark among batches.
+			let key = (pallet, instance, benchmark);
+
+			match all_benchmarks.get_mut(&key) {
+				// We already have this benchmark, so we extend the results.
+				Some(x) => x.0.extend(results),
+				None => panic!("all benchmark keys should have been populated by db batches"),
+			}
+		});
+
+	all_benchmarks
+		.into_iter()
+		.map(|((pallet, instance, benchmark), (time_results, db_results))| {
+			BenchmarkBatchSplitResults { pallet, instance, benchmark, time_results, db_results }
+		})
+		.collect::<Vec<_>>()
+}
+
+/// Explains possible reasons why the metadata for the benchmarking could not be found.
+const ERROR_METADATA_NOT_FOUND: &'static str = "Did not find the benchmarking metadata. \
+This could mean that you either did not build the node correctly with the \
+`--features runtime-benchmarks` flag, or the chain spec that you are using was \
+not created by a node that was compiled with the flag";
+
+impl PalletCmd {
+	/// Runs the command and benchmarks the chain.
+	pub fn run<BB, ExtraHostFunctions>(&self, config: Configuration) -> Result<()>
+	where
+		BB: BlockT + Debug,
+		<<<BB as BlockT>::Header as HeaderT>::Number as std::str::FromStr>::Err: std::fmt::Debug,
+		ExtraHostFunctions: sp_wasm_interface::HostFunctions,
+	{
+		let _d = self.execution.as_ref().map(|exec| {
+			// We print the warning at the end, since there is often A LOT of output.
+			sp_core::defer::DeferGuard::new(move || {
+				log::warn!(
+					target: LOG_TARGET,
+					"⚠�  Argument `--execution` is deprecated. Its value of `{exec}` has on effect.",
+				)
+			})
+		});
+
+		if let Some(output_path) = &self.output {
+			if !output_path.is_dir() && output_path.file_name().is_none() {
+				return Err("Output file or path is invalid!".into())
+			}
+		}
+
+		if let Some(header_file) = &self.header {
+			if !header_file.is_file() {
+				return Err("Header file is invalid!".into())
+			};
+		}
+
+		if let Some(handlebars_template_file) = &self.template {
+			if !handlebars_template_file.is_file() {
+				return Err("Handlebars template file is invalid!".into())
+			};
+		}
+
+		if let Some(json_input) = &self.json_input {
+			let raw_data = match std::fs::read(json_input) {
+				Ok(raw_data) => raw_data,
+				Err(error) =>
+					return Err(format!("Failed to read {:?}: {}", json_input, error).into()),
+			};
+			let batches: Vec<BenchmarkBatchSplitResults> = match serde_json::from_slice(&raw_data) {
+				Ok(batches) => batches,
+				Err(error) =>
+					return Err(format!("Failed to deserialize {:?}: {}", json_input, error).into()),
+			};
+			return self.output_from_results(&batches)
+		}
+
+		let spec = config.chain_spec;
+		let pallet = self.pallet.clone().unwrap_or_default();
+		let pallet = pallet.as_bytes();
+		let extrinsic = self.extrinsic.clone().unwrap_or_default();
+		let extrinsic_split: Vec<&str> = extrinsic.split(',').collect();
+		let extrinsics: Vec<_> = extrinsic_split.iter().map(|x| x.trim().as_bytes()).collect();
+
+		let genesis_storage = spec.build_storage()?;
+		let mut changes = Default::default();
+		let cache_size = Some(self.database_cache_size as usize);
+		let state_with_tracking = BenchmarkingState::<BB>::new(
+			genesis_storage.clone(),
+			cache_size,
+			// Record proof size
+			true,
+			// Enable storage tracking
+			true,
+		)?;
+		let state_without_tracking = BenchmarkingState::<BB>::new(
+			genesis_storage,
+			cache_size,
+			// Do not record proof size
+			false,
+			// Do not enable storage tracking
+			false,
+		)?;
+
+		let method =
+			execution_method_from_cli(self.wasm_method, self.wasmtime_instantiation_strategy);
+
+		let executor = WasmExecutor::<(
+			sp_io::SubstrateHostFunctions,
+			frame_benchmarking::benchmarking::HostFunctions,
+			ExtraHostFunctions,
+		)>::builder()
+		.with_execution_method(method)
+		.with_max_runtime_instances(2)
+		.with_runtime_cache_size(2)
+		.build();
+
+		let extensions = || -> Extensions {
+			let mut extensions = Extensions::default();
+			let (offchain, _) = TestOffchainExt::new();
+			let (pool, _) = TestTransactionPoolExt::new();
+			let keystore = MemoryKeystore::new();
+			extensions.register(KeystoreExt::new(keystore));
+			extensions.register(OffchainWorkerExt::new(offchain.clone()));
+			extensions.register(OffchainDbExt::new(offchain));
+			extensions.register(TransactionPoolExt::new(pool));
+			extensions.register(ReadRuntimeVersionExt::new(executor.clone()));
+			extensions
+		};
+
+		// Get Benchmark List
+		let state = &state_without_tracking;
+		let result = StateMachine::new(
+			state,
+			&mut changes,
+			&executor,
+			"Benchmark_benchmark_metadata",
+			&(self.extra).encode(),
+			&mut extensions(),
+			&sp_state_machine::backend::BackendRuntimeCode::new(state).runtime_code()?,
+			CallContext::Offchain,
+		)
+		.execute()
+		.map_err(|e| format!("{}: {}", ERROR_METADATA_NOT_FOUND, e))?;
+
+		let (list, storage_info) =
+			<(Vec<BenchmarkList>, Vec<StorageInfo>) as Decode>::decode(&mut &result[..])
+				.map_err(|e| format!("Failed to decode benchmark metadata: {:?}", e))?;
+
+		// Use the benchmark list and the user input to determine the set of benchmarks to run.
+		let mut benchmarks_to_run = Vec::new();
+		list.iter()
+			.filter(|item| pallet.is_empty() || pallet == &b"*"[..] || pallet == &item.pallet[..])
+			.for_each(|item| {
+				for benchmark in &item.benchmarks {
+					let benchmark_name = &benchmark.name;
+					if extrinsic.is_empty() ||
+						extrinsic.as_bytes() == &b"*"[..] ||
+						extrinsics.contains(&&benchmark_name[..])
+					{
+						benchmarks_to_run.push((
+							item.pallet.clone(),
+							benchmark.name.clone(),
+							benchmark.components.clone(),
+							benchmark.pov_modes.clone(),
+						))
+					}
+				}
+			});
+		// Convert `Vec<u8>` to `String` for better readability.
+		let benchmarks_to_run: Vec<_> = benchmarks_to_run
+			.into_iter()
+			.map(|b| {
+				(
+					b.0,
+					b.1,
+					b.2,
+					b.3.into_iter()
+						.map(|(p, s)| {
+							(String::from_utf8(p).unwrap(), String::from_utf8(s).unwrap())
+						})
+						.collect(),
+				)
+			})
+			.collect();
+
+		if benchmarks_to_run.is_empty() {
+			return Err("No benchmarks found which match your input.".into())
+		}
+
+		if self.list {
+			// List benchmarks instead of running them
+			list_benchmark(benchmarks_to_run);
+			return Ok(())
+		}
+
+		// Run the benchmarks
+		let mut batches = Vec::new();
+		let mut batches_db = Vec::new();
+		let mut timer = time::SystemTime::now();
+		// Maps (pallet, extrinsic) to its component ranges.
+		let mut component_ranges = HashMap::<(Vec<u8>, Vec<u8>), Vec<ComponentRange>>::new();
+		let pov_modes = Self::parse_pov_modes(&benchmarks_to_run)?;
+
+		for (pallet, extrinsic, components, _) in benchmarks_to_run.clone() {
+			log::info!(
+				target: LOG_TARGET,
+				"Starting benchmark: {}::{}",
+				String::from_utf8(pallet.clone()).expect("Encoded from String; qed"),
+				String::from_utf8(extrinsic.clone()).expect("Encoded from String; qed"),
+			);
+			let all_components = if components.is_empty() {
+				vec![Default::default()]
+			} else {
+				let mut all_components = Vec::new();
+				for (idx, (name, low, high)) in components.iter().enumerate() {
+					let lowest = self.lowest_range_values.get(idx).cloned().unwrap_or(*low);
+					let highest = self.highest_range_values.get(idx).cloned().unwrap_or(*high);
+
+					let diff =
+						highest.checked_sub(lowest).ok_or("`low` cannot be higher than `high`")?;
+
+					// The slope logic needs at least two points
+					// to compute a slope.
+					if self.steps < 2 {
+						return Err("`steps` must be at least 2.".into())
+					}
+
+					let step_size = (diff as f32 / (self.steps - 1) as f32).max(0.0);
+
+					for s in 0..self.steps {
+						// This is the value we will be testing for component `name`
+						let component_value =
+							((lowest as f32 + step_size * s as f32) as u32).clamp(lowest, highest);
+
+						// Select the max value for all the other components.
+						let c: Vec<(BenchmarkParameter, u32)> = components
+							.iter()
+							.enumerate()
+							.map(|(idx, (n, _, h))| {
+								if n == name {
+									(*n, component_value)
+								} else {
+									(*n, *self.highest_range_values.get(idx).unwrap_or(h))
+								}
+							})
+							.collect();
+						all_components.push(c);
+					}
+
+					component_ranges
+						.entry((pallet.clone(), extrinsic.clone()))
+						.or_default()
+						.push(ComponentRange { name: name.to_string(), min: lowest, max: highest });
+				}
+				all_components
+			};
+			for (s, selected_components) in all_components.iter().enumerate() {
+				// First we run a verification
+				if !self.no_verify {
+					let state = &state_without_tracking;
+					let result = StateMachine::new(
+						state,
+						&mut changes,
+						&executor,
+						"Benchmark_dispatch_benchmark",
+						&(
+							&pallet,
+							&extrinsic,
+							&selected_components.clone(),
+							true, // run verification code
+							1,    // no need to do internal repeats
+						)
+							.encode(),
+						&mut extensions(),
+						&sp_state_machine::backend::BackendRuntimeCode::new(state)
+							.runtime_code()?,
+						CallContext::Offchain,
+					)
+					.execute()
+					.map_err(|e| {
+						format!("Error executing and verifying runtime benchmark: {}", e)
+					})?;
+					// Dont use these results since verification code will add overhead.
+					let _batch =
+						<std::result::Result<Vec<BenchmarkBatch>, String> as Decode>::decode(
+							&mut &result[..],
+						)
+						.map_err(|e| format!("Failed to decode benchmark results: {:?}", e))?
+						.map_err(|e| {
+							format!(
+								"Benchmark {}::{} failed: {}",
+								String::from_utf8_lossy(&pallet),
+								String::from_utf8_lossy(&extrinsic),
+								e
+							)
+						})?;
+				}
+				// Do one loop of DB tracking.
+				{
+					let state = &state_with_tracking;
+					let result = StateMachine::new(
+						state, // todo remove tracking
+						&mut changes,
+						&executor,
+						"Benchmark_dispatch_benchmark",
+						&(
+							&pallet.clone(),
+							&extrinsic.clone(),
+							&selected_components.clone(),
+							false, // dont run verification code for final values
+							self.repeat,
+						)
+							.encode(),
+						&mut extensions(),
+						&sp_state_machine::backend::BackendRuntimeCode::new(state)
+							.runtime_code()?,
+						CallContext::Offchain,
+					)
+					.execute()
+					.map_err(|e| format!("Error executing runtime benchmark: {}", e))?;
+
+					let batch =
+						<std::result::Result<Vec<BenchmarkBatch>, String> as Decode>::decode(
+							&mut &result[..],
+						)
+						.map_err(|e| format!("Failed to decode benchmark results: {:?}", e))??;
+
+					batches_db.extend(batch);
+				}
+				// Finally run a bunch of loops to get extrinsic timing information.
+				for r in 0..self.external_repeat {
+					let state = &state_without_tracking;
+					let result = StateMachine::new(
+						state, // todo remove tracking
+						&mut changes,
+						&executor,
+						"Benchmark_dispatch_benchmark",
+						&(
+							&pallet.clone(),
+							&extrinsic.clone(),
+							&selected_components.clone(),
+							false, // dont run verification code for final values
+							self.repeat,
+						)
+							.encode(),
+						&mut extensions(),
+						&sp_state_machine::backend::BackendRuntimeCode::new(state)
+							.runtime_code()?,
+						CallContext::Offchain,
+					)
+					.execute()
+					.map_err(|e| format!("Error executing runtime benchmark: {}", e))?;
+
+					let batch =
+						<std::result::Result<Vec<BenchmarkBatch>, String> as Decode>::decode(
+							&mut &result[..],
+						)
+						.map_err(|e| format!("Failed to decode benchmark results: {:?}", e))??;
+
+					batches.extend(batch);
+
+					// Show progress information
+					if let Ok(elapsed) = timer.elapsed() {
+						if elapsed >= time::Duration::from_secs(5) {
+							timer = time::SystemTime::now();
+
+							log::info!(
+								target: LOG_TARGET,
+								"Running  benchmark: {}.{}({} args) {}/{} {}/{}",
+								String::from_utf8(pallet.clone())
+									.expect("Encoded from String; qed"),
+								String::from_utf8(extrinsic.clone())
+									.expect("Encoded from String; qed"),
+								components.len(),
+								s + 1, // s starts at 0.
+								all_components.len(),
+								r + 1,
+								self.external_repeat,
+							);
+						}
+					}
+				}
+			}
+		}
+
+		// Combine all of the benchmark results, so that benchmarks of the same pallet/function
+		// are together.
+		let batches = combine_batches(batches, batches_db);
+		self.output(&batches, &storage_info, &component_ranges, pov_modes)
+	}
+
+	fn output(
+		&self,
+		batches: &[BenchmarkBatchSplitResults],
+		storage_info: &[StorageInfo],
+		component_ranges: &HashMap<(Vec<u8>, Vec<u8>), Vec<ComponentRange>>,
+		pov_modes: PovModesMap,
+	) -> Result<()> {
+		// Jsonify the result and write it to a file or stdout if desired.
+		if !self.jsonify(&batches)? {
+			// Print the summary only if `jsonify` did not write to stdout.
+			self.print_summary(&batches, &storage_info, pov_modes.clone())
+		}
+
+		// Create the weights.rs file.
+		if let Some(output_path) = &self.output {
+			writer::write_results(
+				&batches,
+				&storage_info,
+				&component_ranges,
+				pov_modes,
+				self.default_pov_mode,
+				output_path,
+				self,
+			)?;
+		}
+
+		Ok(())
+	}
+
+	/// Re-analyze a batch historic benchmark timing data. Will not take the PoV into account.
+	fn output_from_results(&self, batches: &[BenchmarkBatchSplitResults]) -> Result<()> {
+		let mut component_ranges =
+			HashMap::<(Vec<u8>, Vec<u8>), HashMap<String, (u32, u32)>>::new();
+		for batch in batches {
+			let range = component_ranges
+				.entry((batch.pallet.clone(), batch.benchmark.clone()))
+				.or_default();
+			for result in &batch.time_results {
+				for (param, value) in &result.components {
+					let name = param.to_string();
+					let (ref mut min, ref mut max) = range.entry(name).or_insert((*value, *value));
+					if *value < *min {
+						*min = *value;
+					}
+					if *value > *max {
+						*max = *value;
+					}
+				}
+			}
+		}
+
+		let component_ranges: HashMap<_, _> = component_ranges
+			.into_iter()
+			.map(|(key, ranges)| {
+				let ranges = ranges
+					.into_iter()
+					.map(|(name, (min, max))| ComponentRange { name, min, max })
+					.collect();
+				(key, ranges)
+			})
+			.collect();
+
+		self.output(batches, &[], &component_ranges, Default::default())
+	}
+
+	/// Jsonifies the passed batches and writes them to stdout or into a file.
+	/// Can be configured via `--json` and `--json-file`.
+	/// Returns whether it wrote to stdout.
+	fn jsonify(&self, batches: &[BenchmarkBatchSplitResults]) -> Result<bool> {
+		if self.json_output || self.json_file.is_some() {
+			let json = serde_json::to_string_pretty(&batches)
+				.map_err(|e| format!("Serializing into JSON: {:?}", e))?;
+
+			if let Some(path) = &self.json_file {
+				fs::write(path, json)?;
+			} else {
+				print!("{json}");
+				return Ok(true)
+			}
+		}
+
+		Ok(false)
+	}
+
+	/// Prints the results as human-readable summary without raw timing data.
+	fn print_summary(
+		&self,
+		batches: &[BenchmarkBatchSplitResults],
+		storage_info: &[StorageInfo],
+		pov_modes: PovModesMap,
+	) {
+		for batch in batches.iter() {
+			// Print benchmark metadata
+			println!(
+					"Pallet: {:?}, Extrinsic: {:?}, Lowest values: {:?}, Highest values: {:?}, Steps: {:?}, Repeat: {:?}",
+					String::from_utf8(batch.pallet.clone()).expect("Encoded from String; qed"),
+					String::from_utf8(batch.benchmark.clone()).expect("Encoded from String; qed"),
+					self.lowest_range_values,
+					self.highest_range_values,
+					self.steps,
+					self.repeat,
+				);
+
+			// Skip raw data + analysis if there are no results
+			if batch.time_results.is_empty() {
+				continue
+			}
+
+			if !self.no_storage_info {
+				let mut storage_per_prefix = HashMap::<Vec<u8>, Vec<BenchmarkResult>>::new();
+				let pov_mode = pov_modes
+					.get(&(batch.pallet.clone(), batch.benchmark.clone()))
+					.cloned()
+					.unwrap_or_default();
+
+				let comments = writer::process_storage_results(
+					&mut storage_per_prefix,
+					&batch.db_results,
+					storage_info,
+					&pov_mode,
+					self.default_pov_mode,
+					self.worst_case_map_values,
+					self.additional_trie_layers,
+				);
+				println!("Raw Storage Info\n========");
+				for comment in comments {
+					println!("{}", comment);
+				}
+				println!();
+			}
+
+			// Conduct analysis.
+			if !self.no_median_slopes {
+				println!("Median Slopes Analysis\n========");
+				if let Some(analysis) =
+					Analysis::median_slopes(&batch.time_results, BenchmarkSelector::ExtrinsicTime)
+				{
+					println!("-- Extrinsic Time --\n{}", analysis);
+				}
+				if let Some(analysis) =
+					Analysis::median_slopes(&batch.db_results, BenchmarkSelector::Reads)
+				{
+					println!("Reads = {:?}", analysis);
+				}
+				if let Some(analysis) =
+					Analysis::median_slopes(&batch.db_results, BenchmarkSelector::Writes)
+				{
+					println!("Writes = {:?}", analysis);
+				}
+				if let Some(analysis) =
+					Analysis::median_slopes(&batch.db_results, BenchmarkSelector::ProofSize)
+				{
+					println!("Recorded proof Size = {:?}", analysis);
+				}
+				println!();
+			}
+			if !self.no_min_squares {
+				println!("Min Squares Analysis\n========");
+				if let Some(analysis) =
+					Analysis::min_squares_iqr(&batch.time_results, BenchmarkSelector::ExtrinsicTime)
+				{
+					println!("-- Extrinsic Time --\n{}", analysis);
+				}
+				if let Some(analysis) =
+					Analysis::min_squares_iqr(&batch.db_results, BenchmarkSelector::Reads)
+				{
+					println!("Reads = {:?}", analysis);
+				}
+				if let Some(analysis) =
+					Analysis::min_squares_iqr(&batch.db_results, BenchmarkSelector::Writes)
+				{
+					println!("Writes = {:?}", analysis);
+				}
+				if let Some(analysis) =
+					Analysis::min_squares_iqr(&batch.db_results, BenchmarkSelector::ProofSize)
+				{
+					println!("Recorded proof Size = {:?}", analysis);
+				}
+				println!();
+			}
+		}
+	}
+
+	/// Parses the PoV modes per benchmark that were specified by the `#[pov_mode]` attribute.
+	fn parse_pov_modes(
+		benchmarks: &Vec<(
+			Vec<u8>,
+			Vec<u8>,
+			Vec<(BenchmarkParameter, u32, u32)>,
+			Vec<(String, String)>,
+		)>,
+	) -> Result<PovModesMap> {
+		use std::collections::hash_map::Entry;
+		let mut parsed = PovModesMap::new();
+
+		for (pallet, call, _components, pov_modes) in benchmarks {
+			for (pallet_storage, mode) in pov_modes {
+				let mode = PovEstimationMode::from_str(&mode)?;
+				let splits = pallet_storage.split("::").collect::<Vec<_>>();
+				if splits.is_empty() || splits.len() > 2 {
+					return Err(format!(
+						"Expected 'Pallet::Storage' as storage name but got: {}",
+						pallet_storage
+					)
+					.into())
+				}
+				let (pov_pallet, pov_storage) = (splits[0], splits.get(1).unwrap_or(&"ALL"));
+
+				match parsed
+					.entry((pallet.clone(), call.clone()))
+					.or_default()
+					.entry((pov_pallet.to_string(), pov_storage.to_string()))
+				{
+					Entry::Occupied(_) =>
+						return Err(format!(
+							"Cannot specify pov_mode tag twice for the same key: {}",
+							pallet_storage
+						)
+						.into()),
+					Entry::Vacant(e) => {
+						e.insert(mode);
+					},
+				}
+			}
+		}
+		Ok(parsed)
+	}
+}
+
+impl CliConfiguration for PalletCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn chain_id(&self, _is_dev: bool) -> Result<String> {
+		Ok(match self.shared_params.chain {
+			Some(ref chain) => chain.clone(),
+			None => "dev".into(),
+		})
+	}
+}
+
+/// List the benchmarks available in the runtime, in a CSV friendly format.
+fn list_benchmark(
+	benchmarks_to_run: Vec<(
+		Vec<u8>,
+		Vec<u8>,
+		Vec<(BenchmarkParameter, u32, u32)>,
+		Vec<(String, String)>,
+	)>,
+) {
+	println!("pallet, benchmark");
+	for (pallet, extrinsic, _, _) in benchmarks_to_run {
+		println!("{}, {}", String::from_utf8_lossy(&pallet), String::from_utf8_lossy(&extrinsic));
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/pallet/mod.rs b/substrate/utils/frame/benchmarking-cli/src/pallet/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c69ce1765fc9dc490f1e0f40966ca07948b6b523
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/pallet/mod.rs
@@ -0,0 +1,204 @@
+// 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.
+
+mod command;
+mod writer;
+
+use crate::shared::HostInfoParams;
+use sc_cli::{
+	WasmExecutionMethod, WasmtimeInstantiationStrategy, DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
+	DEFAULT_WASM_EXECUTION_METHOD,
+};
+use std::{fmt::Debug, path::PathBuf};
+
+// Add a more relaxed parsing for pallet names by allowing pallet directory names with `-` to be
+// used like crate names with `_`
+fn parse_pallet_name(pallet: &str) -> std::result::Result<String, String> {
+	Ok(pallet.replace("-", "_"))
+}
+
+/// Benchmark the extrinsic weight of FRAME Pallets.
+#[derive(Debug, clap::Parser)]
+pub struct PalletCmd {
+	/// Select a FRAME Pallet to benchmark, or `*` for all (in which case `extrinsic` must be `*`).
+	#[arg(short, long, value_parser = parse_pallet_name, required_unless_present_any = ["list", "json_input"])]
+	pub pallet: Option<String>,
+
+	/// Select an extrinsic inside the pallet to benchmark, or `*` for all.
+	#[arg(short, long, required_unless_present_any = ["list", "json_input"])]
+	pub extrinsic: Option<String>,
+
+	/// Select how many samples we should take across the variable components.
+	#[arg(short, long, default_value_t = 50)]
+	pub steps: u32,
+
+	/// Indicates lowest values for each of the component ranges.
+	#[arg(long = "low", value_delimiter = ',')]
+	pub lowest_range_values: Vec<u32>,
+
+	/// Indicates highest values for each of the component ranges.
+	#[arg(long = "high", value_delimiter = ',')]
+	pub highest_range_values: Vec<u32>,
+
+	/// Select how many repetitions of this benchmark should run from within the wasm.
+	#[arg(short, long, default_value_t = 20)]
+	pub repeat: u32,
+
+	/// Select how many repetitions of this benchmark should run from the client.
+	///
+	/// NOTE: Using this alone may give slower results, but will afford you maximum Wasm memory.
+	#[arg(long, default_value_t = 1)]
+	pub external_repeat: u32,
+
+	/// Print the raw results in JSON format.
+	#[arg(long = "json")]
+	pub json_output: bool,
+
+	/// Write the raw results in JSON format into the given file.
+	#[arg(long, conflicts_with = "json_output")]
+	pub json_file: Option<PathBuf>,
+
+	/// Don't print the median-slopes linear regression analysis.
+	#[arg(long)]
+	pub no_median_slopes: bool,
+
+	/// Don't print the min-squares linear regression analysis.
+	#[arg(long)]
+	pub no_min_squares: bool,
+
+	/// Output the benchmarks to a Rust file at the given path.
+	#[arg(long)]
+	pub output: Option<PathBuf>,
+
+	/// Add a header file to your outputted benchmarks.
+	#[arg(long)]
+	pub header: Option<PathBuf>,
+
+	/// Path to Handlebars template file used for outputting benchmark results. (Optional)
+	#[arg(long)]
+	pub template: Option<PathBuf>,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub hostinfo_params: HostInfoParams,
+
+	/// Which analysis function to use when outputting benchmarks:
+	/// * min-squares (default)
+	/// * median-slopes
+	/// * max (max of min squares and median slopes for each value)
+	#[arg(long)]
+	pub output_analysis: Option<String>,
+
+	/// Which analysis function to use when analyzing measured proof sizes.
+	#[arg(long, default_value("median-slopes"))]
+	pub output_pov_analysis: Option<String>,
+
+	/// The PoV estimation mode of a benchmark if no `pov_mode` attribute is present.
+	#[arg(long, default_value("max-encoded-len"), value_enum)]
+	pub default_pov_mode: command::PovEstimationMode,
+
+	/// Set the heap pages while running benchmarks. If not set, the default value from the client
+	/// is used.
+	#[arg(long)]
+	pub heap_pages: Option<u64>,
+
+	/// Disable verification logic when running benchmarks.
+	#[arg(long)]
+	pub no_verify: bool,
+
+	/// Display and run extra benchmarks that would otherwise not be needed for weight
+	/// construction.
+	#[arg(long)]
+	pub extra: bool,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: sc_cli::SharedParams,
+
+	/// Method for executing Wasm runtime code.
+	#[arg(
+		long = "wasm-execution",
+		value_name = "METHOD",
+		value_enum,
+		ignore_case = true,
+		default_value_t = DEFAULT_WASM_EXECUTION_METHOD,
+	)]
+	pub wasm_method: WasmExecutionMethod,
+
+	/// The WASM instantiation method to use.
+	///
+	/// Only has an effect when `wasm-execution` is set to `compiled`.
+	#[arg(
+		long = "wasm-instantiation-strategy",
+		value_name = "STRATEGY",
+		default_value_t = DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
+		value_enum,
+	)]
+	pub wasmtime_instantiation_strategy: WasmtimeInstantiationStrategy,
+
+	/// DEPRECATED: This argument has no effect.
+	#[arg(long = "execution")]
+	pub execution: Option<String>,
+
+	/// Limit the memory the database cache can use.
+	#[arg(long = "db-cache", value_name = "MiB", default_value_t = 1024)]
+	pub database_cache_size: u32,
+
+	/// List the benchmarks that match your query rather than running them.
+	///
+	/// When nothing is provided, we list all benchmarks.
+	#[arg(long)]
+	pub list: bool,
+
+	/// If enabled, the storage info is not displayed in the output next to the analysis.
+	///
+	/// This is independent of the storage info appearing in the *output file*. Use a Handlebar
+	/// template for that purpose.
+	#[arg(long)]
+	pub no_storage_info: bool,
+
+	/// The assumed default maximum size of any `StorageMap`.
+	///
+	/// When the maximum size of a map is not defined by the runtime developer,
+	/// this value is used as a worst case scenario. It will affect the calculated worst case
+	/// PoV size for accessing a value in a map, since the PoV will need to include the trie
+	/// nodes down to the underlying value.
+	#[clap(long = "map-size", default_value = "1000000")]
+	pub worst_case_map_values: u32,
+
+	/// Adjust the PoV estimation by adding additional trie layers to it.
+	///
+	/// This should be set to `log16(n)` where `n` is the number of top-level storage items in the
+	/// runtime, eg. `StorageMap`s and `StorageValue`s. A value of 2 to 3 is usually sufficient.
+	/// Each layer will result in an additional 495 bytes PoV per distinct top-level access.
+	/// Therefore multiple `StorageMap` accesses only suffer from this increase once. The exact
+	/// number of storage items depends on the runtime and the deployed pallets.
+	#[clap(long, default_value = "2")]
+	pub additional_trie_layers: u8,
+
+	/// A path to a `.json` file with existing benchmark results generated with `--json` or
+	/// `--json-file`. When specified the benchmarks are not actually executed, and the data for
+	/// the analysis is read from this file.
+	#[arg(long)]
+	pub json_input: Option<PathBuf>,
+
+	/// Allow overwriting a single file with multiple results.
+	///
+	/// This exists only to restore legacy behaviour. It should never actually be needed.
+	#[arg(long)]
+	pub unsafe_overwrite_results: bool,
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/pallet/template.hbs b/substrate/utils/frame/benchmarking-cli/src/pallet/template.hbs
new file mode 100644
index 0000000000000000000000000000000000000000..1e5e294acba263aa4f3abf97e4249ce5917d9d42
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/pallet/template.hbs
@@ -0,0 +1,65 @@
+{{header}}
+//! Autogenerated weights for `{{pallet}}`
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION {{version}}
+//! DATE: {{date}}, STEPS: `{{cmd.steps}}`, REPEAT: `{{cmd.repeat}}`, LOW RANGE: `{{cmd.lowest_range_values}}`, HIGH RANGE: `{{cmd.highest_range_values}}`
+//! WORST CASE MAP SIZE: `{{cmd.worst_case_map_values}}`
+//! HOSTNAME: `{{hostname}}`, CPU: `{{cpuname}}`
+//! WASM-EXECUTION: `{{cmd.wasm_execution}}`, CHAIN: `{{cmd.chain}}`, DB CACHE: {{cmd.db_cache}}
+
+// Executed Command:
+{{#each args as |arg|}}
+// {{arg}}
+{{/each}}
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(unused_parens)]
+#![allow(unused_imports)]
+#![allow(missing_docs)]
+
+use frame_support::{traits::Get, weights::Weight};
+use core::marker::PhantomData;
+
+/// Weight functions for `{{pallet}}`.
+pub struct WeightInfo<T>(PhantomData<T>);
+impl<T: frame_system::Config> {{pallet}}::WeightInfo for WeightInfo<T> {
+	{{#each benchmarks as |benchmark|}}
+	{{#each benchmark.comments as |comment|}}
+	/// {{comment}}
+	{{/each}}
+	{{#each benchmark.component_ranges as |range|}}
+	/// The range of component `{{range.name}}` is `[{{range.min}}, {{range.max}}]`.
+	{{/each}}
+	fn {{benchmark.name~}}
+	(
+		{{~#each benchmark.components as |c| ~}}
+		{{~#if (not c.is_used)}}_{{/if}}{{c.name}}: u32, {{/each~}}
+	) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `{{benchmark.base_recorded_proof_size}}{{#each benchmark.component_recorded_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		//  Estimated: `{{benchmark.base_calculated_proof_size}}{{#each benchmark.component_calculated_proof_size as |cp|}} + {{cp.name}} * ({{cp.slope}} ±{{underscore cp.error}}){{/each}}`
+		// Minimum execution time: {{underscore benchmark.min_execution_time}}_000 picoseconds.
+		Weight::from_parts({{underscore benchmark.base_weight}}, 0)
+			.saturating_add(Weight::from_parts(0, {{benchmark.base_calculated_proof_size}}))
+			{{#each benchmark.component_weight as |cw|}}
+			// Standard Error: {{underscore cw.error}}
+			.saturating_add(Weight::from_parts({{underscore cw.slope}}, 0).saturating_mul({{cw.name}}.into()))
+			{{/each}}
+			{{#if (ne benchmark.base_reads "0")}}
+			.saturating_add(T::DbWeight::get().reads({{benchmark.base_reads}}))
+			{{/if}}
+			{{#each benchmark.component_reads as |cr|}}
+			.saturating_add(T::DbWeight::get().reads(({{cr.slope}}_u64).saturating_mul({{cr.name}}.into())))
+			{{/each}}
+			{{#if (ne benchmark.base_writes "0")}}
+			.saturating_add(T::DbWeight::get().writes({{benchmark.base_writes}}))
+			{{/if}}
+			{{#each benchmark.component_writes as |cw|}}
+			.saturating_add(T::DbWeight::get().writes(({{cw.slope}}_u64).saturating_mul({{cw.name}}.into())))
+			{{/each}}
+			{{#each benchmark.component_calculated_proof_size as |cp|}}
+			.saturating_add(Weight::from_parts(0, {{cp.slope}}).saturating_mul({{cp.name}}.into()))
+			{{/each}}
+	}
+	{{/each}}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/pallet/writer.rs b/substrate/utils/frame/benchmarking-cli/src/pallet/writer.rs
new file mode 100644
index 0000000000000000000000000000000000000000..69c95d13c098530a0b1c09ef569c5ff976bf02e3
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/pallet/writer.rs
@@ -0,0 +1,1355 @@
+// 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.
+
+// Outputs benchmark results to Rust files that can be ingested by the runtime.
+
+use std::{
+	collections::{HashMap, HashSet},
+	fs,
+	path::PathBuf,
+};
+
+use inflector::Inflector;
+use itertools::Itertools;
+use serde::Serialize;
+
+use crate::{
+	pallet::command::{ComponentRange, PovEstimationMode, PovModesMap},
+	shared::UnderscoreHelper,
+	PalletCmd,
+};
+use frame_benchmarking::{
+	Analysis, AnalysisChoice, BenchmarkBatchSplitResults, BenchmarkResult, BenchmarkSelector,
+};
+use frame_support::traits::StorageInfo;
+use sp_core::hexdisplay::HexDisplay;
+use sp_runtime::traits::Zero;
+
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+const TEMPLATE: &str = include_str!("./template.hbs");
+
+// This is the final structure we will pass to the Handlebars template.
+#[derive(Serialize, Default, Debug, Clone)]
+struct TemplateData {
+	args: Vec<String>,
+	date: String,
+	hostname: String,
+	cpuname: String,
+	version: String,
+	pallet: String,
+	instance: String,
+	header: String,
+	cmd: CmdData,
+	benchmarks: Vec<BenchmarkData>,
+}
+
+// This was the final data we have about each benchmark.
+#[derive(Serialize, Default, Debug, Clone, PartialEq)]
+struct BenchmarkData {
+	name: String,
+	components: Vec<Component>,
+	#[serde(serialize_with = "string_serialize")]
+	base_weight: u128,
+	#[serde(serialize_with = "string_serialize")]
+	base_reads: u128,
+	#[serde(serialize_with = "string_serialize")]
+	base_writes: u128,
+	#[serde(serialize_with = "string_serialize")]
+	base_calculated_proof_size: u128,
+	#[serde(serialize_with = "string_serialize")]
+	base_recorded_proof_size: u128,
+	component_weight: Vec<ComponentSlope>,
+	component_reads: Vec<ComponentSlope>,
+	component_writes: Vec<ComponentSlope>,
+	component_calculated_proof_size: Vec<ComponentSlope>,
+	component_recorded_proof_size: Vec<ComponentSlope>,
+	component_ranges: Vec<ComponentRange>,
+	comments: Vec<String>,
+	#[serde(serialize_with = "string_serialize")]
+	min_execution_time: u128,
+}
+
+// This forwards some specific metadata from the `PalletCmd`
+#[derive(Serialize, Default, Debug, Clone)]
+struct CmdData {
+	steps: u32,
+	repeat: u32,
+	lowest_range_values: Vec<u32>,
+	highest_range_values: Vec<u32>,
+	wasm_execution: String,
+	chain: String,
+	db_cache: u32,
+	analysis_choice: String,
+	worst_case_map_values: u32,
+	additional_trie_layers: u8,
+}
+
+// This encodes the component name and whether that component is used.
+#[derive(Serialize, Debug, Clone, Eq, PartialEq)]
+struct Component {
+	name: String,
+	is_used: bool,
+}
+
+// This encodes the slope of some benchmark related to a component.
+#[derive(Serialize, Debug, Clone, Eq, PartialEq)]
+struct ComponentSlope {
+	name: String,
+	#[serde(serialize_with = "string_serialize")]
+	slope: u128,
+	#[serde(serialize_with = "string_serialize")]
+	error: u128,
+}
+
+// Small helper to create an `io::Error` from a string.
+fn io_error(s: &str) -> std::io::Error {
+	use std::io::{Error, ErrorKind};
+	Error::new(ErrorKind::Other, s)
+}
+
+// This function takes a list of `BenchmarkBatch` and organizes them by pallet into a `HashMap`.
+// So this: `[(p1, b1), (p1, b2), (p2, b1), (p1, b3), (p2, b2)]`
+// Becomes:
+//
+// ```
+// p1 -> [b1, b2, b3]
+// p2 -> [b1, b2]
+// ```
+fn map_results(
+	batches: &[BenchmarkBatchSplitResults],
+	storage_info: &[StorageInfo],
+	component_ranges: &HashMap<(Vec<u8>, Vec<u8>), Vec<ComponentRange>>,
+	pov_modes: PovModesMap,
+	default_pov_mode: PovEstimationMode,
+	analysis_choice: &AnalysisChoice,
+	pov_analysis_choice: &AnalysisChoice,
+	worst_case_map_values: u32,
+	additional_trie_layers: u8,
+) -> Result<HashMap<(String, String), Vec<BenchmarkData>>, std::io::Error> {
+	// Skip if batches is empty.
+	if batches.is_empty() {
+		return Err(io_error("empty batches"))
+	}
+
+	let mut all_benchmarks = HashMap::<_, Vec<BenchmarkData>>::new();
+
+	for batch in batches {
+		// Skip if there are no results
+		if batch.time_results.is_empty() {
+			continue
+		}
+
+		let pallet_string = String::from_utf8(batch.pallet.clone()).unwrap();
+		let instance_string = String::from_utf8(batch.instance.clone()).unwrap();
+		let benchmark_data = get_benchmark_data(
+			batch,
+			storage_info,
+			&component_ranges,
+			pov_modes.clone(),
+			default_pov_mode,
+			analysis_choice,
+			pov_analysis_choice,
+			worst_case_map_values,
+			additional_trie_layers,
+		);
+		let pallet_benchmarks = all_benchmarks.entry((pallet_string, instance_string)).or_default();
+		pallet_benchmarks.push(benchmark_data);
+	}
+	Ok(all_benchmarks)
+}
+
+// Get an iterator of errors.
+fn extract_errors(errors: &Option<Vec<u128>>) -> impl Iterator<Item = u128> + '_ {
+	errors
+		.as_ref()
+		.map(|e| e.as_slice())
+		.unwrap_or(&[])
+		.iter()
+		.copied()
+		.chain(std::iter::repeat(0))
+}
+
+// Analyze and return the relevant results for a given benchmark.
+fn get_benchmark_data(
+	batch: &BenchmarkBatchSplitResults,
+	storage_info: &[StorageInfo],
+	// Per extrinsic component ranges.
+	component_ranges: &HashMap<(Vec<u8>, Vec<u8>), Vec<ComponentRange>>,
+	pov_modes: PovModesMap,
+	default_pov_mode: PovEstimationMode,
+	analysis_choice: &AnalysisChoice,
+	pov_analysis_choice: &AnalysisChoice,
+	worst_case_map_values: u32,
+	additional_trie_layers: u8,
+) -> BenchmarkData {
+	// Analyze benchmarks to get the linear regression.
+	let analysis_function = match analysis_choice {
+		AnalysisChoice::MinSquares => Analysis::min_squares_iqr,
+		AnalysisChoice::MedianSlopes => Analysis::median_slopes,
+		AnalysisChoice::Max => Analysis::max,
+	};
+	let pov_analysis_function = match pov_analysis_choice {
+		AnalysisChoice::MinSquares => Analysis::min_squares_iqr,
+		AnalysisChoice::MedianSlopes => Analysis::median_slopes,
+		AnalysisChoice::Max => Analysis::max,
+	};
+
+	let extrinsic_time = analysis_function(&batch.time_results, BenchmarkSelector::ExtrinsicTime)
+		.expect("analysis function should return an extrinsic time for valid inputs");
+	let reads = analysis_function(&batch.db_results, BenchmarkSelector::Reads)
+		.expect("analysis function should return the number of reads for valid inputs");
+	let writes = analysis_function(&batch.db_results, BenchmarkSelector::Writes)
+		.expect("analysis function should return the number of writes for valid inputs");
+	let recorded_proof_size =
+		pov_analysis_function(&batch.db_results, BenchmarkSelector::ProofSize)
+			.expect("analysis function should return proof sizes for valid inputs");
+
+	// Analysis data may include components that are not used, this filters out anything whose value
+	// is zero.
+	let mut used_components = Vec::new();
+	let mut used_extrinsic_time = Vec::new();
+	let mut used_reads = Vec::new();
+	let mut used_writes = Vec::new();
+	let mut used_calculated_proof_size = Vec::<ComponentSlope>::new();
+	let mut used_recorded_proof_size = Vec::<ComponentSlope>::new();
+
+	extrinsic_time
+		.slopes
+		.into_iter()
+		.zip(extrinsic_time.names.iter())
+		.zip(extract_errors(&extrinsic_time.errors))
+		.for_each(|((slope, name), error)| {
+			if !slope.is_zero() {
+				if !used_components.contains(&name) {
+					used_components.push(name);
+				}
+				used_extrinsic_time.push(ComponentSlope { name: name.clone(), slope, error });
+			}
+		});
+	reads
+		.slopes
+		.into_iter()
+		.zip(reads.names.iter())
+		.zip(extract_errors(&reads.errors))
+		.for_each(|((slope, name), error)| {
+			if !slope.is_zero() {
+				if !used_components.contains(&name) {
+					used_components.push(name);
+				}
+				used_reads.push(ComponentSlope { name: name.clone(), slope, error });
+			}
+		});
+	writes
+		.slopes
+		.into_iter()
+		.zip(writes.names.iter())
+		.zip(extract_errors(&writes.errors))
+		.for_each(|((slope, name), error)| {
+			if !slope.is_zero() {
+				if !used_components.contains(&name) {
+					used_components.push(name);
+				}
+				used_writes.push(ComponentSlope { name: name.clone(), slope, error });
+			}
+		});
+	recorded_proof_size
+		.slopes
+		.into_iter()
+		.zip(recorded_proof_size.names.iter())
+		.zip(extract_errors(&recorded_proof_size.errors))
+		.for_each(|((slope, name), error)| {
+			if !slope.is_zero() {
+				// These are only for comments, so don't touch the `used_components`.
+				used_recorded_proof_size.push(ComponentSlope { name: name.clone(), slope, error });
+			}
+		});
+	used_recorded_proof_size.sort_by(|a, b| a.name.cmp(&b.name));
+
+	// We add additional comments showing which storage items were touched.
+	// We find the worst case proof size, and use that as the final proof size result.
+	let mut storage_per_prefix = HashMap::<Vec<u8>, Vec<BenchmarkResult>>::new();
+	let pov_mode = pov_modes
+		.get(&(batch.pallet.clone(), batch.benchmark.clone()))
+		.cloned()
+		.unwrap_or_default();
+	let comments = process_storage_results(
+		&mut storage_per_prefix,
+		&batch.db_results,
+		storage_info,
+		&pov_mode,
+		default_pov_mode,
+		worst_case_map_values,
+		additional_trie_layers,
+	);
+
+	let proof_size_per_components = storage_per_prefix
+		.iter()
+		.map(|(prefix, results)| {
+			let proof_size = analysis_function(results, BenchmarkSelector::ProofSize)
+				.expect("analysis function should return proof sizes for valid inputs");
+			let slope = proof_size
+				.slopes
+				.into_iter()
+				.zip(proof_size.names.iter())
+				.zip(extract_errors(&proof_size.errors))
+				.map(|((slope, name), error)| ComponentSlope { name: name.clone(), slope, error })
+				.collect::<Vec<_>>();
+			(prefix.clone(), slope, proof_size.base)
+		})
+		.collect::<Vec<_>>();
+
+	let mut base_calculated_proof_size = 0;
+	// Sum up the proof sizes per component
+	for (_, slope, base) in proof_size_per_components.iter() {
+		base_calculated_proof_size = base_calculated_proof_size.max(*base);
+		for component in slope.iter() {
+			let mut found = false;
+			for used_component in used_calculated_proof_size.iter_mut() {
+				if used_component.name == component.name {
+					used_component.slope = used_component.slope.max(component.slope);
+					found = true;
+					break
+				}
+			}
+			if !found && !component.slope.is_zero() {
+				if !used_components.contains(&&component.name) {
+					used_components.push(&component.name);
+				}
+				used_calculated_proof_size.push(ComponentSlope {
+					name: component.name.clone(),
+					slope: component.slope,
+					error: component.error,
+				});
+			}
+		}
+	}
+	used_calculated_proof_size.sort_by(|a, b| a.name.cmp(&b.name));
+
+	// This puts a marker on any component which is entirely unused in the weight formula.
+	let components = batch.time_results[0]
+		.components
+		.iter()
+		.map(|(name, _)| -> Component {
+			let name_string = name.to_string();
+			let is_used = used_components.contains(&&name_string);
+			Component { name: name_string, is_used }
+		})
+		.collect::<Vec<_>>();
+
+	let component_ranges = component_ranges
+		.get(&(batch.pallet.clone(), batch.benchmark.clone()))
+		.map(|c| c.clone())
+		.unwrap_or_default();
+
+	BenchmarkData {
+		name: String::from_utf8(batch.benchmark.clone()).unwrap(),
+		components,
+		base_weight: extrinsic_time.base,
+		base_reads: reads.base,
+		base_writes: writes.base,
+		base_calculated_proof_size,
+		base_recorded_proof_size: recorded_proof_size.base,
+		component_weight: used_extrinsic_time,
+		component_reads: used_reads,
+		component_writes: used_writes,
+		component_calculated_proof_size: used_calculated_proof_size,
+		component_recorded_proof_size: used_recorded_proof_size,
+		component_ranges,
+		comments,
+		min_execution_time: extrinsic_time.minimum,
+	}
+}
+
+/// Create weight file from benchmark data and Handlebars template.
+pub(crate) fn write_results(
+	batches: &[BenchmarkBatchSplitResults],
+	storage_info: &[StorageInfo],
+	component_ranges: &HashMap<(Vec<u8>, Vec<u8>), Vec<ComponentRange>>,
+	pov_modes: PovModesMap,
+	default_pov_mode: PovEstimationMode,
+	path: &PathBuf,
+	cmd: &PalletCmd,
+) -> Result<(), sc_cli::Error> {
+	// Use custom template if provided.
+	let template: String = match &cmd.template {
+		Some(template_file) => fs::read_to_string(template_file)?,
+		None => TEMPLATE.to_string(),
+	};
+
+	// Use header if provided
+	let header_text = match &cmd.header {
+		Some(header_file) => {
+			let text = fs::read_to_string(header_file)?;
+			text
+		},
+		None => String::new(),
+	};
+
+	// Date string metadata
+	let date = chrono::Utc::now().format("%Y-%m-%d").to_string();
+
+	// Full CLI args passed to trigger the benchmark.
+	let args = std::env::args().collect::<Vec<String>>();
+
+	// Which analysis function should be used when outputting benchmarks
+	let analysis_choice: AnalysisChoice =
+		cmd.output_analysis.clone().try_into().map_err(io_error)?;
+	let pov_analysis_choice: AnalysisChoice =
+		cmd.output_pov_analysis.clone().try_into().map_err(io_error)?;
+
+	if cmd.additional_trie_layers > 4 {
+		println!(
+			"WARNING: `additional_trie_layers` is unexpectedly large. It assumes {} storage items.",
+			16f64.powi(cmd.additional_trie_layers as i32)
+		)
+	}
+
+	// Capture individual args
+	let cmd_data = CmdData {
+		steps: cmd.steps,
+		repeat: cmd.repeat,
+		lowest_range_values: cmd.lowest_range_values.clone(),
+		highest_range_values: cmd.highest_range_values.clone(),
+		wasm_execution: cmd.wasm_method.to_string(),
+		chain: format!("{:?}", cmd.shared_params.chain),
+		db_cache: cmd.database_cache_size,
+		analysis_choice: format!("{:?}", analysis_choice),
+		worst_case_map_values: cmd.worst_case_map_values,
+		additional_trie_layers: cmd.additional_trie_layers,
+	};
+
+	// New Handlebars instance with helpers.
+	let mut handlebars = handlebars::Handlebars::new();
+	handlebars.register_helper("underscore", Box::new(UnderscoreHelper));
+	handlebars.register_helper("join", Box::new(JoinHelper));
+	// Don't HTML escape any characters.
+	handlebars.register_escape_fn(|s| -> String { s.to_string() });
+
+	// Organize results by pallet into a JSON map
+	let all_results = map_results(
+		batches,
+		storage_info,
+		component_ranges,
+		pov_modes,
+		default_pov_mode,
+		&analysis_choice,
+		&pov_analysis_choice,
+		cmd.worst_case_map_values,
+		cmd.additional_trie_layers,
+	)?;
+	let mut created_files = Vec::new();
+
+	for ((pallet, instance), results) in all_results.iter() {
+		let mut file_path = path.clone();
+		// If a user only specified a directory...
+		if file_path.is_dir() {
+			// Start with "path/to/pallet_name".
+			let mut file_name = pallet.clone();
+			// Check if there might be multiple instances benchmarked.
+			if all_results.keys().any(|(p, i)| p == pallet && i != instance) {
+				// Append "_instance_name".
+				file_name = format!("{}_{}", file_name, instance.to_snake_case());
+			}
+			// "mod::pallet_name.rs" becomes "mod_pallet_name.rs".
+			file_path.push(file_name.replace("::", "_"));
+			file_path.set_extension("rs");
+		}
+
+		let hbs_data = TemplateData {
+			args: args.clone(),
+			date: date.clone(),
+			hostname: cmd.hostinfo_params.hostname(),
+			cpuname: cmd.hostinfo_params.cpuname(),
+			version: VERSION.to_string(),
+			pallet: pallet.to_string(),
+			instance: instance.to_string(),
+			header: header_text.clone(),
+			cmd: cmd_data.clone(),
+			benchmarks: results.clone(),
+		};
+
+		let mut output_file = fs::File::create(&file_path)?;
+		handlebars
+			.render_template_to_write(&template, &hbs_data, &mut output_file)
+			.map_err(|e| io_error(&e.to_string()))?;
+		println!("Created file: {:?}", &file_path);
+		created_files.push(file_path);
+	}
+
+	let overwritten_files = created_files.iter().duplicates().collect::<Vec<_>>();
+	if !overwritten_files.is_empty() {
+		let msg = format!(
+			"Multiple results were written to the same file. This can happen when \
+		there are multiple instances of a pallet deployed and `--output` forces the output of all \
+		instances into the same file. Use `--unsafe-overwrite-results` to ignore this error. The \
+		affected files are: {:?}",
+			overwritten_files
+		);
+
+		if cmd.unsafe_overwrite_results {
+			println!("{msg}");
+		} else {
+			return Err(msg.into())
+		}
+	}
+	Ok(())
+}
+
+/// This function looks at the keys touched during the benchmark, and the storage info we collected
+/// from the pallets, and creates comments with information about the storage keys touched during
+/// each benchmark.
+///
+/// It returns informational comments for human consumption.
+pub(crate) fn process_storage_results(
+	storage_per_prefix: &mut HashMap<Vec<u8>, Vec<BenchmarkResult>>,
+	results: &[BenchmarkResult],
+	storage_info: &[StorageInfo],
+	pov_modes: &HashMap<(String, String), PovEstimationMode>,
+	default_pov_mode: PovEstimationMode,
+	worst_case_map_values: u32,
+	additional_trie_layers: u8,
+) -> Vec<String> {
+	let mut comments = Vec::new();
+	let mut storage_info_map = storage_info
+		.iter()
+		.map(|info| (info.prefix.clone(), info))
+		.collect::<HashMap<_, _>>();
+
+	// Special hack to show `Skipped Metadata`
+	let skip_storage_info = StorageInfo {
+		pallet_name: b"Skipped".to_vec(),
+		storage_name: b"Metadata".to_vec(),
+		prefix: b"Skipped Metadata".to_vec(),
+		max_values: None,
+		max_size: None,
+	};
+	storage_info_map.insert(skip_storage_info.prefix.clone(), &skip_storage_info);
+
+	// Special hack to show `Benchmark Override`
+	let benchmark_override = StorageInfo {
+		pallet_name: b"Benchmark".to_vec(),
+		storage_name: b"Override".to_vec(),
+		prefix: b"Benchmark Override".to_vec(),
+		max_values: None,
+		max_size: None,
+	};
+	storage_info_map.insert(benchmark_override.prefix.clone(), &benchmark_override);
+
+	// This tracks the keys we already identified, so we only generate a single comment.
+	let mut identified_prefix = HashSet::<Vec<u8>>::new();
+	let mut identified_key = HashSet::<Vec<u8>>::new();
+
+	// TODO Emit a warning for unused `pov_mode` attributes.
+
+	// We have to iterate in reverse order to catch the largest values for read/write since the
+	// components start low and then increase and only the first value is used.
+	for result in results.iter().rev() {
+		for (key, reads, writes, whitelisted) in &result.keys {
+			// skip keys which are whitelisted
+			if *whitelisted {
+				continue
+			}
+
+			let prefix_length = key.len().min(32);
+			let prefix = key[0..prefix_length].to_vec();
+			let is_key_identified = identified_key.contains(key);
+			let is_prefix_identified = identified_prefix.contains(&prefix);
+
+			let mut prefix_result = result.clone();
+			let key_info = storage_info_map.get(&prefix);
+			let max_size = key_info.and_then(|k| k.max_size);
+
+			let override_pov_mode = match key_info {
+				Some(StorageInfo { pallet_name, storage_name, .. }) => {
+					let pallet_name =
+						String::from_utf8(pallet_name.clone()).expect("encoded from string");
+					let storage_name =
+						String::from_utf8(storage_name.clone()).expect("encoded from string");
+
+					// Is there an override for the storage key?
+					pov_modes.get(&(pallet_name.clone(), storage_name)).or(
+						// .. or for the storage prefix?
+						pov_modes.get(&(pallet_name, "ALL".to_string())).or(
+							// .. or for the benchmark?
+							pov_modes.get(&("ALL".to_string(), "ALL".to_string())),
+						),
+					)
+				},
+				None => None,
+			};
+			let is_all_ignored = pov_modes.get(&("ALL".to_string(), "ALL".to_string())) ==
+				Some(&PovEstimationMode::Ignored);
+			if is_all_ignored && override_pov_mode != Some(&PovEstimationMode::Ignored) {
+				panic!("The syntax currently does not allow to exclude single keys from a top-level `Ignored` pov-mode.");
+			}
+
+			let pov_overhead = single_read_pov_overhead(
+				key_info.and_then(|i| i.max_values),
+				worst_case_map_values,
+			);
+
+			let used_pov_mode = match (override_pov_mode, max_size, default_pov_mode) {
+				// All is ignored by default and no override:
+				(None, _, PovEstimationMode::Ignored)  => {
+					prefix_result.proof_size = 0;
+					PovEstimationMode::Ignored
+				},
+				// Some is ignored by override, maybe all:
+				(Some(PovEstimationMode::Ignored), _, _) => {
+					// If this is applied to All keys, then we also remove the base weight and just set all to zero.
+					if is_all_ignored {
+						prefix_result.proof_size = 0;
+					} else {
+						// Otherwise we just don't *increase* `proof_size` for this key.
+					}
+					PovEstimationMode::Ignored
+				},
+				(Some(PovEstimationMode::Measured), _, _)|
+				(None, _, PovEstimationMode::Measured) |
+				// Use best effort in this case since failing would be really annoying.
+				(None, None, PovEstimationMode::MaxEncodedLen) => {
+					// We add the overhead for a single read each time. In a more advanced version
+					// we could take node re-using into account and over-estimate a bit less.
+					prefix_result.proof_size += pov_overhead * *reads;
+					PovEstimationMode::Measured
+				},
+				(Some(PovEstimationMode::MaxEncodedLen), Some(max_size), _) |
+				(None, Some(max_size), PovEstimationMode::MaxEncodedLen) => {
+					prefix_result.proof_size = (pov_overhead + max_size) * *reads;
+					PovEstimationMode::MaxEncodedLen
+				},
+				(Some(PovEstimationMode::MaxEncodedLen), None, _) => {
+					panic!("Key does not have MEL bound but MEL PoV estimation mode was specified {:?}", &key);
+				},
+			};
+			// Add the additional trie layer overhead for every new prefix.
+			if *reads > 0 && !is_all_ignored {
+				prefix_result.proof_size += 15 * 33 * additional_trie_layers as u32;
+			}
+			storage_per_prefix.entry(prefix.clone()).or_default().push(prefix_result);
+
+			match (is_key_identified, is_prefix_identified) {
+				// We already did everything, move on...
+				(true, true) => continue,
+				(false, true) => {
+					// track newly identified key
+					identified_key.insert(key.clone());
+				},
+				(false, false) => {
+					// track newly identified key and prefix
+					identified_key.insert(key.clone());
+					identified_prefix.insert(prefix.clone());
+				},
+				// Not possible. If the key is known, the prefix is too.
+				(true, false) => unreachable!(),
+			}
+
+			// For any new prefix, we should write some comment about the number of reads and
+			// writes.
+			if !is_prefix_identified {
+				match key_info {
+					Some(key_info) => {
+						let comment = format!(
+							"Storage: `{}::{}` (r:{} w:{})",
+							String::from_utf8(key_info.pallet_name.clone())
+								.expect("encoded from string"),
+							String::from_utf8(key_info.storage_name.clone())
+								.expect("encoded from string"),
+							reads,
+							writes,
+						);
+						comments.push(comment)
+					},
+					None => {
+						let comment = format!(
+							"Storage: UNKNOWN KEY `0x{}` (r:{} w:{})",
+							HexDisplay::from(key),
+							reads,
+							writes,
+						);
+						comments.push(comment)
+					},
+				}
+			}
+
+			// For any new key, we should add the PoV impact.
+			if !is_key_identified {
+				match key_info {
+					Some(key_info) => {
+						match worst_case_pov(
+							key_info.max_values,
+							key_info.max_size,
+							!is_prefix_identified,
+							worst_case_map_values,
+						) {
+							Some(new_pov) => {
+								let comment = format!(
+									"Proof: `{}::{}` (`max_values`: {:?}, `max_size`: {:?}, added: {}, mode: `{:?}`)",
+									String::from_utf8(key_info.pallet_name.clone())
+										.expect("encoded from string"),
+									String::from_utf8(key_info.storage_name.clone())
+										.expect("encoded from string"),
+									key_info.max_values,
+									key_info.max_size,
+									new_pov,
+									used_pov_mode,
+								);
+								comments.push(comment)
+							},
+							None => {
+								let pallet = String::from_utf8(key_info.pallet_name.clone())
+									.expect("encoded from string");
+								let item = String::from_utf8(key_info.storage_name.clone())
+									.expect("encoded from string");
+								let comment = format!(
+									"Proof: `{}::{}` (`max_values`: {:?}, `max_size`: {:?}, mode: `{:?}`)",
+									pallet, item, key_info.max_values, key_info.max_size,
+									used_pov_mode,
+								);
+								comments.push(comment);
+							},
+						}
+					},
+					None => {
+						let comment = format!(
+							"Proof: UNKNOWN KEY `0x{}` (r:{} w:{})",
+							HexDisplay::from(key),
+							reads,
+							writes,
+						);
+						comments.push(comment)
+					},
+				}
+			}
+		}
+	}
+
+	comments
+}
+
+/// The PoV overhead when reading a key the first time out of a map with `max_values` entries.
+fn single_read_pov_overhead(max_values: Option<u32>, worst_case_map_values: u32) -> u32 {
+	let max_values = max_values.unwrap_or(worst_case_map_values);
+	let depth: u32 = easy_log_16(max_values);
+	// Normally we have 16 entries of 32 byte hashes per tree layer. In the new trie
+	// layout the hashes are prefixed by their compact length, hence 33 instead. The proof
+	// compaction can compress one node per layer since we send the value itself,
+	// therefore we end up with a size of `15 * 33` per layer.
+	depth * 15 * 33
+}
+
+/// Given the max values and max size of some storage item, calculate the worst
+/// case PoV.
+///
+/// # Arguments
+/// * `max_values`: The maximum number of values in the storage item. `None` for  unbounded items.
+/// * `max_size`: The maximum size of the value in the storage. `None` for unbounded items.
+fn worst_case_pov(
+	max_values: Option<u32>,
+	max_size: Option<u32>,
+	is_new_prefix: bool,
+	worst_case_map_values: u32,
+) -> Option<u32> {
+	if let Some(max_size) = max_size {
+		let trie_size: u32 = if is_new_prefix {
+			single_read_pov_overhead(max_values, worst_case_map_values)
+		} else {
+			0
+		};
+
+		Some(trie_size + max_size)
+	} else {
+		None
+	}
+}
+
+/// A simple match statement which outputs the log 16 of some value.
+fn easy_log_16(i: u32) -> u32 {
+	match i {
+		i if i == 0 => 0,
+		i if i <= 16 => 1,
+		i if i <= 256 => 2,
+		i if i <= 4_096 => 3,
+		i if i <= 65_536 => 4,
+		i if i <= 1_048_576 => 5,
+		i if i <= 16_777_216 => 6,
+		i if i <= 268_435_456 => 7,
+		_ => 8,
+	}
+}
+
+// A helper to join a string of vectors.
+#[derive(Clone, Copy)]
+struct JoinHelper;
+impl handlebars::HelperDef for JoinHelper {
+	fn call<'reg: 'rc, 'rc>(
+		&self,
+		h: &handlebars::Helper,
+		_: &handlebars::Handlebars,
+		_: &handlebars::Context,
+		_rc: &mut handlebars::RenderContext,
+		out: &mut dyn handlebars::Output,
+	) -> handlebars::HelperResult {
+		use handlebars::JsonRender;
+		let param = h.param(0).unwrap();
+		let value = param.value();
+		let joined = if value.is_array() {
+			value
+				.as_array()
+				.unwrap()
+				.iter()
+				.map(|v| v.render())
+				.collect::<Vec<String>>()
+				.join(" ")
+		} else {
+			value.render()
+		};
+		out.write(&joined)?;
+		Ok(())
+	}
+}
+
+// u128 does not serialize well into JSON for `handlebars`, so we represent it as a string.
+fn string_serialize<S>(x: &u128, s: S) -> Result<S::Ok, S::Error>
+where
+	S: serde::Serializer,
+{
+	s.serialize_str(&x.to_string())
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+	use frame_benchmarking::{BenchmarkBatchSplitResults, BenchmarkParameter, BenchmarkResult};
+
+	fn test_data(
+		pallet: &[u8],
+		benchmark: &[u8],
+		param: BenchmarkParameter,
+		base: u32,
+		slope: u32,
+	) -> BenchmarkBatchSplitResults {
+		let mut results = Vec::new();
+		for i in 0..5 {
+			results.push(BenchmarkResult {
+				components: vec![(param, i)],
+				extrinsic_time: (base + slope * i).into(),
+				storage_root_time: (base + slope * i).into(),
+				reads: (base + slope * i).into(),
+				repeat_reads: 0,
+				writes: (base + slope * i).into(),
+				repeat_writes: 0,
+				proof_size: (i + 1) * 1024,
+				// All R/W come from this key:
+				keys: vec![(b"bounded".to_vec(), (base + slope * i), (base + slope * i), false)],
+			})
+		}
+
+		return BenchmarkBatchSplitResults {
+			pallet: [pallet.to_vec(), b"_pallet".to_vec()].concat(),
+			instance: b"instance".to_vec(),
+			benchmark: [benchmark.to_vec(), b"_benchmark".to_vec()].concat(),
+			time_results: results.clone(),
+			db_results: results,
+		}
+	}
+
+	fn test_storage_info() -> Vec<StorageInfo> {
+		vec![StorageInfo {
+			pallet_name: b"bounded".to_vec(),
+			storage_name: b"bounded".to_vec(),
+			prefix: b"bounded".to_vec(),
+			max_values: Some(1 << 20),
+			max_size: Some(32),
+		}]
+	}
+
+	fn test_pov_mode() -> PovModesMap {
+		let mut map = PovModesMap::new();
+		map.entry((b"scheduler".to_vec(), b"first_benchmark".to_vec()))
+			.or_default()
+			.insert(("scheduler".into(), "mel".into()), PovEstimationMode::MaxEncodedLen);
+		map.entry((b"scheduler".to_vec(), b"first_benchmark".to_vec()))
+			.or_default()
+			.insert(("scheduler".into(), "measured".into()), PovEstimationMode::Measured);
+		map
+	}
+
+	fn check_data(benchmark: &BenchmarkData, component: &str, base: u128, slope: u128) {
+		assert_eq!(
+			benchmark.components,
+			vec![Component { name: component.to_string(), is_used: true },],
+		);
+		// Weights multiplied by 1,000
+		assert_eq!(benchmark.base_weight, base * 1_000);
+		assert_eq!(
+			benchmark.component_weight,
+			vec![ComponentSlope { name: component.to_string(), slope: slope * 1_000, error: 0 }]
+		);
+		// DB Reads/Writes are untouched
+		assert_eq!(benchmark.base_reads, base);
+		assert_eq!(
+			benchmark.component_reads,
+			vec![ComponentSlope { name: component.to_string(), slope, error: 0 }]
+		);
+		assert_eq!(benchmark.base_writes, base);
+		assert_eq!(
+			benchmark.component_writes,
+			vec![ComponentSlope { name: component.to_string(), slope, error: 0 }]
+		);
+		// Measure PoV is correct
+		assert_eq!(benchmark.base_recorded_proof_size, 1024);
+		assert_eq!(
+			benchmark.component_recorded_proof_size,
+			vec![ComponentSlope { name: component.to_string(), slope: 1024, error: 0 }]
+		);
+	}
+
+	/// We measure a linear proof size but select `pov_mode = MEL` with a present MEL bound for the
+	/// type. This should result in the measured PoV being ignored and the MEL used instead.
+	#[test]
+	fn pov_mode_mel_constant_works() {
+		let mut results = Vec::new();
+		for i in 0..5 {
+			results.push(BenchmarkResult {
+				components: vec![(BenchmarkParameter::s, i)],
+				extrinsic_time: 0,
+				storage_root_time: 0,
+				reads: 1,
+				repeat_reads: 777,
+				writes: 888,
+				repeat_writes: 999,
+				proof_size: i * 1024,
+				keys: vec![(b"mel".to_vec(), 1, 1, false)],
+			})
+		}
+
+		let data = BenchmarkBatchSplitResults {
+			pallet: b"scheduler".to_vec(),
+			instance: b"instance".to_vec(),
+			benchmark: b"first_benchmark".to_vec(),
+			time_results: results.clone(),
+			db_results: results,
+		};
+
+		let storage_info = vec![StorageInfo {
+			pallet_name: b"scheduler".to_vec(),
+			storage_name: b"mel".to_vec(),
+			prefix: b"mel".to_vec(),
+			max_values: None,
+			max_size: Some(1 << 22), // MEL of 4 MiB
+		}];
+
+		let mapped_results = map_results(
+			&[data],
+			&storage_info,
+			&Default::default(),
+			test_pov_mode(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+		let result =
+			mapped_results.get(&("scheduler".to_string(), "instance".to_string())).unwrap()[0]
+				.clone();
+
+		let base = result.base_calculated_proof_size;
+		assert!(result.component_calculated_proof_size.is_empty(), "There is no slope");
+		// It's a map with 5 layers overhead:
+		assert_eq!(base, (1 << 22) + 15 * 33 * 5);
+	}
+
+	/// Record a small linear proof size but since MEL is selected and available it should be used
+	/// instead.
+	#[test]
+	fn pov_mode_mel_linear_works() {
+		let mut results = Vec::new();
+		for i in 0..5 {
+			results.push(BenchmarkResult {
+				components: vec![(BenchmarkParameter::s, i)],
+				extrinsic_time: 0,
+				storage_root_time: 0,
+				reads: 123,
+				repeat_reads: 777,
+				writes: 888,
+				repeat_writes: 999,
+				proof_size: i * 1024,
+				keys: vec![("mel".as_bytes().to_vec(), i, 1, false)],
+			})
+		}
+
+		let data = BenchmarkBatchSplitResults {
+			pallet: b"scheduler".to_vec(),
+			instance: b"instance".to_vec(),
+			benchmark: b"first_benchmark".to_vec(),
+			time_results: results.clone(),
+			db_results: results,
+		};
+
+		let storage_info = vec![StorageInfo {
+			pallet_name: b"scheduler".to_vec(),
+			storage_name: b"mel".to_vec(),
+			prefix: b"mel".to_vec(),
+			max_values: None,
+			max_size: Some(1 << 22), // MEL of 4 MiB
+		}];
+
+		let mapped_results = map_results(
+			&[data],
+			&storage_info,
+			&Default::default(),
+			test_pov_mode(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+		let result =
+			mapped_results.get(&("scheduler".to_string(), "instance".to_string())).unwrap()[0]
+				.clone();
+
+		let base = result.base_calculated_proof_size;
+		assert_eq!(result.component_calculated_proof_size.len(), 1, "There is a slope");
+		let slope = result.component_calculated_proof_size[0].clone().slope;
+		assert_eq!(base, 0);
+		// It's a map with 5 layers overhead:
+		assert_eq!(slope, (1 << 22) + 15 * 33 * 5);
+	}
+
+	#[test]
+	fn pov_mode_measured_const_works() {
+		let mut results = Vec::new();
+		for i in 0..5 {
+			results.push(BenchmarkResult {
+				components: vec![(BenchmarkParameter::s, i)],
+				extrinsic_time: 0,
+				storage_root_time: 0,
+				reads: 123,
+				repeat_reads: 777,
+				writes: 888,
+				repeat_writes: 999,
+				proof_size: 1024,
+				keys: vec![("measured".as_bytes().to_vec(), 1, 1, false)],
+			})
+		}
+
+		let data = BenchmarkBatchSplitResults {
+			pallet: b"scheduler".to_vec(),
+			instance: b"instance".to_vec(),
+			benchmark: b"first_benchmark".to_vec(),
+			time_results: results.clone(),
+			db_results: results,
+		};
+
+		let storage_info = vec![StorageInfo {
+			pallet_name: b"scheduler".to_vec(),
+			storage_name: b"measured".to_vec(),
+			prefix: b"measured".to_vec(),
+			max_values: None,
+			max_size: Some(1 << 22), // MEL of 4 MiB
+		}];
+
+		let mapped_results = map_results(
+			&[data],
+			&storage_info,
+			&Default::default(),
+			test_pov_mode(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+		let result =
+			mapped_results.get(&("scheduler".to_string(), "instance".to_string())).unwrap()[0]
+				.clone();
+
+		let base = result.base_calculated_proof_size;
+		assert!(result.component_calculated_proof_size.is_empty(), "There is no slope");
+		// 5 Trie layers overhead because of the 1M max elements in that map:
+		assert_eq!(base, 1024 + 15 * 33 * 5);
+	}
+
+	#[test]
+	fn pov_mode_measured_linear_works() {
+		let mut results = Vec::new();
+		for i in 0..5 {
+			results.push(BenchmarkResult {
+				components: vec![(BenchmarkParameter::s, i)],
+				extrinsic_time: 0,
+				storage_root_time: 0,
+				reads: 123,
+				repeat_reads: 777,
+				writes: 888,
+				repeat_writes: 999,
+				proof_size: i * 1024,
+				keys: vec![("measured".as_bytes().to_vec(), i, 1, false)],
+			})
+		}
+
+		let data = BenchmarkBatchSplitResults {
+			pallet: b"scheduler".to_vec(),
+			instance: b"instance".to_vec(),
+			benchmark: b"first_benchmark".to_vec(),
+			time_results: results.clone(),
+			db_results: results,
+		};
+
+		let storage_info = vec![StorageInfo {
+			pallet_name: b"scheduler".to_vec(),
+			storage_name: b"measured".to_vec(),
+			prefix: b"measured".to_vec(),
+			max_values: None,
+			max_size: Some(1 << 22), // MEL of 4 MiB
+		}];
+
+		let mapped_results = map_results(
+			&[data],
+			&storage_info,
+			&Default::default(),
+			test_pov_mode(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+		let result =
+			mapped_results.get(&("scheduler".to_string(), "instance".to_string())).unwrap()[0]
+				.clone();
+
+		let base = result.base_calculated_proof_size;
+		assert_eq!(result.component_calculated_proof_size.len(), 1, "There is a slope");
+		let slope = result.component_calculated_proof_size[0].clone().slope;
+		assert_eq!(base, 0);
+		// It's a map with 5 layers overhead:
+		assert_eq!(slope, 1024 + 15 * 33 * 5);
+	}
+
+	#[test]
+	fn pov_mode_ignored_linear_works() {
+		let mut results = Vec::new();
+		for i in 0..5 {
+			results.push(BenchmarkResult {
+				components: vec![(BenchmarkParameter::s, i)],
+				extrinsic_time: 0,
+				storage_root_time: 0,
+				reads: 123,
+				repeat_reads: 777,
+				writes: 888,
+				repeat_writes: 999,
+				proof_size: i * 1024,
+				keys: vec![("ignored".as_bytes().to_vec(), i, 1, false)],
+			})
+		}
+
+		let data = BenchmarkBatchSplitResults {
+			pallet: b"scheduler".to_vec(),
+			instance: b"instance".to_vec(),
+			benchmark: b"first_benchmark".to_vec(),
+			time_results: results.clone(),
+			db_results: results,
+		};
+
+		let storage_info = vec![StorageInfo {
+			pallet_name: b"scheduler".to_vec(),
+			storage_name: b"ignored".to_vec(),
+			prefix: b"ignored".to_vec(),
+			max_values: None,
+			max_size: Some(1 << 22), // MEL of 4 MiB
+		}];
+
+		let mapped_results = map_results(
+			&[data],
+			&storage_info,
+			&Default::default(),
+			test_pov_mode(),
+			PovEstimationMode::Ignored,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+		let result =
+			mapped_results.get(&("scheduler".to_string(), "instance".to_string())).unwrap()[0]
+				.clone();
+
+		let base = result.base_calculated_proof_size;
+		assert!(result.component_calculated_proof_size.is_empty(), "There is no slope");
+		assert_eq!(base, 0);
+	}
+
+	#[test]
+	fn map_results_works() {
+		let mapped_results = map_results(
+			&[
+				test_data(b"first", b"first", BenchmarkParameter::a, 10, 3),
+				test_data(b"first", b"second", BenchmarkParameter::b, 9, 2),
+				test_data(b"second", b"first", BenchmarkParameter::c, 3, 4),
+				test_data(b"bounded", b"bounded", BenchmarkParameter::d, 4, 6),
+			],
+			&test_storage_info(),
+			&Default::default(),
+			Default::default(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+
+		let first_benchmark = &mapped_results
+			.get(&("first_pallet".to_string(), "instance".to_string()))
+			.unwrap()[0];
+		assert_eq!(first_benchmark.name, "first_benchmark");
+		check_data(first_benchmark, "a", 10, 3);
+
+		let second_benchmark = &mapped_results
+			.get(&("first_pallet".to_string(), "instance".to_string()))
+			.unwrap()[1];
+		assert_eq!(second_benchmark.name, "second_benchmark");
+		check_data(second_benchmark, "b", 9, 2);
+
+		let second_pallet_benchmark = &mapped_results
+			.get(&("second_pallet".to_string(), "instance".to_string()))
+			.unwrap()[0];
+		assert_eq!(second_pallet_benchmark.name, "first_benchmark");
+		check_data(second_pallet_benchmark, "c", 3, 4);
+
+		let bounded_pallet_benchmark = &mapped_results
+			.get(&("bounded_pallet".to_string(), "instance".to_string()))
+			.unwrap()[0];
+		assert_eq!(bounded_pallet_benchmark.name, "bounded_benchmark");
+		check_data(bounded_pallet_benchmark, "d", 4, 6);
+		// (5 * 15 * 33 + 32) * 4 = 10028
+		assert_eq!(bounded_pallet_benchmark.base_calculated_proof_size, 10028);
+		// (5 * 15 * 33 + 32) * 6 = 15042
+		assert_eq!(
+			bounded_pallet_benchmark.component_calculated_proof_size,
+			vec![ComponentSlope { name: "d".into(), slope: 15042, error: 0 }]
+		);
+	}
+
+	#[test]
+	fn additional_trie_layers_work() {
+		let mapped_results = map_results(
+			&[test_data(b"first", b"first", BenchmarkParameter::a, 10, 3)],
+			&test_storage_info(),
+			&Default::default(),
+			Default::default(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			2,
+		)
+		.unwrap();
+		let with_layer = &mapped_results
+			.get(&("first_pallet".to_string(), "instance".to_string()))
+			.unwrap()[0];
+		let mapped_results = map_results(
+			&[test_data(b"first", b"first", BenchmarkParameter::a, 10, 3)],
+			&test_storage_info(),
+			&Default::default(),
+			Default::default(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+		let without_layer = &mapped_results
+			.get(&("first_pallet".to_string(), "instance".to_string()))
+			.unwrap()[0];
+
+		assert_eq!(
+			without_layer.base_calculated_proof_size + 2 * 15 * 33,
+			with_layer.base_calculated_proof_size
+		);
+		// The additional trie layers ONLY affect the base weight, not the components.
+		assert_eq!(
+			without_layer.component_calculated_proof_size,
+			with_layer.component_calculated_proof_size
+		);
+	}
+
+	#[test]
+	fn template_works() {
+		let all_results = map_results(
+			&[
+				test_data(b"first", b"first", BenchmarkParameter::a, 10, 3),
+				test_data(b"first", b"second", BenchmarkParameter::b, 9, 2),
+				test_data(b"second", b"first", BenchmarkParameter::c, 3, 4),
+			],
+			&test_storage_info(),
+			&Default::default(),
+			Default::default(),
+			PovEstimationMode::MaxEncodedLen,
+			&AnalysisChoice::default(),
+			&AnalysisChoice::MedianSlopes,
+			1_000_000,
+			0,
+		)
+		.unwrap();
+
+		// New Handlebars instance with helpers.
+		let mut handlebars = handlebars::Handlebars::new();
+		handlebars.register_helper("underscore", Box::new(UnderscoreHelper));
+		handlebars.register_helper("join", Box::new(JoinHelper));
+		// Don't HTML escape any characters.
+		handlebars.register_escape_fn(|s| -> String { s.to_string() });
+
+		for ((_pallet, _instance), results) in all_results.iter() {
+			let hbs_data = TemplateData { benchmarks: results.clone(), ..Default::default() };
+
+			let output = handlebars.render_template(&TEMPLATE, &hbs_data);
+			assert!(output.is_ok());
+			println!("{:?}", output);
+		}
+	}
+
+	#[test]
+	fn easy_log_16_works() {
+		assert_eq!(easy_log_16(0), 0);
+		assert_eq!(easy_log_16(1), 1);
+		assert_eq!(easy_log_16(16), 1);
+		assert_eq!(easy_log_16(17), 2);
+		assert_eq!(easy_log_16(16u32.pow(2)), 2);
+		assert_eq!(easy_log_16(16u32.pow(2) + 1), 3);
+		assert_eq!(easy_log_16(16u32.pow(3)), 3);
+		assert_eq!(easy_log_16(16u32.pow(3) + 1), 4);
+		assert_eq!(easy_log_16(16u32.pow(4)), 4);
+		assert_eq!(easy_log_16(16u32.pow(4) + 1), 5);
+		assert_eq!(easy_log_16(16u32.pow(5)), 5);
+		assert_eq!(easy_log_16(16u32.pow(5) + 1), 6);
+		assert_eq!(easy_log_16(16u32.pow(6)), 6);
+		assert_eq!(easy_log_16(16u32.pow(6) + 1), 7);
+		assert_eq!(easy_log_16(16u32.pow(7)), 7);
+		assert_eq!(easy_log_16(16u32.pow(7) + 1), 8);
+		assert_eq!(easy_log_16(u32::MAX), 8);
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/shared/README.md b/substrate/utils/frame/benchmarking-cli/src/shared/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..08e25b0e08f769ad016d3422fb9215ca44a84634
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/shared/README.md
@@ -0,0 +1,16 @@
+# Shared code
+
+Contains code that is shared among multiple sub-commands.
+
+## Arguments
+
+- `--mul` Multiply the result with a factor. Can be used to manually adjust for future chain growth.
+- `--add` Add a value to the result. Can be used to manually offset the results.
+- `--metric` Set the metric to use for calculating the final weight from the raw data. Defaults to `average`.
+- `--weight-path` Set the file or directory to write the weight files to.
+- `--db` The database backend to use. This depends on your snapshot.
+- `--pruning` Set the pruning mode of the node. Some benchmarks require you to set this to `archive`.
+- `--base-path` The location on the disk that should be used for the benchmarks. You can try this on different disks or even on a mounted RAM-disk. It is important to use the same location that will later-on be used to store the chain data to get the correct results.
+- `--header` Optional file header which will be prepended to the weight output file. Can be used for adding LICENSE headers.
+
+License: Apache-2.0
diff --git a/substrate/utils/frame/benchmarking-cli/src/shared/mod.rs b/substrate/utils/frame/benchmarking-cli/src/shared/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f8aa49b867f7d4cc84585086532290d50e20c379
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/shared/mod.rs
@@ -0,0 +1,134 @@
+// 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.
+
+//! Code that is shared among all benchmarking sub-commands.
+
+pub mod record;
+pub mod stats;
+pub mod weight_params;
+
+pub use record::BenchRecord;
+pub use stats::{StatSelect, Stats};
+pub use weight_params::WeightParams;
+
+use clap::Args;
+use rand::prelude::*;
+use sc_sysinfo::gather_sysinfo;
+use serde::Serialize;
+
+/// A Handlebars helper to add an underscore after every 3rd character,
+/// i.e. a separator for large numbers.
+#[derive(Clone, Copy)]
+pub struct UnderscoreHelper;
+
+impl handlebars::HelperDef for UnderscoreHelper {
+	fn call<'reg: 'rc, 'rc>(
+		&self,
+		h: &handlebars::Helper,
+		_: &handlebars::Handlebars,
+		_: &handlebars::Context,
+		_rc: &mut handlebars::RenderContext,
+		out: &mut dyn handlebars::Output,
+	) -> handlebars::HelperResult {
+		use handlebars::JsonRender;
+		let param = h.param(0).unwrap();
+		let underscore_param = underscore(param.value().render());
+		out.write(&underscore_param)?;
+		Ok(())
+	}
+}
+
+/// Add an underscore after every 3rd character, i.e. a separator for large numbers.
+fn underscore<Number>(i: Number) -> String
+where
+	Number: std::string::ToString,
+{
+	let mut s = String::new();
+	let i_str = i.to_string();
+	let a = i_str.chars().rev().enumerate();
+	for (idx, val) in a {
+		if idx != 0 && idx % 3 == 0 {
+			s.insert(0, '_');
+		}
+		s.insert(0, val);
+	}
+	s
+}
+
+/// Returns an rng and the seed that was used to create it.
+///
+/// Uses a random seed if none is provided.
+pub fn new_rng(seed: Option<u64>) -> (impl rand::Rng, u64) {
+	let seed = seed.unwrap_or(rand::thread_rng().gen::<u64>());
+	(rand_pcg::Pcg64::seed_from_u64(seed), seed)
+}
+
+/// Returns an error if a debug profile is detected.
+///
+/// The rust compiler only exposes the binary information whether
+/// or not we are in a `debug` build.
+/// This means that `release` and `production` cannot be told apart.
+/// This function additionally checks for OPT-LEVEL = 3.
+pub fn check_build_profile() -> Result<(), String> {
+	if cfg!(build_profile = "debug") {
+		Err("Detected a `debug` profile".into())
+	} else if !cfg!(build_opt_level = "3") {
+		Err("The optimization level is not set to 3".into())
+	} else {
+		Ok(())
+	}
+}
+
+/// Parameters to configure how the host info will be determined.
+#[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
+#[command(rename_all = "kebab-case")]
+pub struct HostInfoParams {
+	/// Manually override the hostname to use.
+	#[arg(long)]
+	pub hostname_override: Option<String>,
+
+	/// Specify a fallback hostname if no-one could be detected automatically.
+	///
+	/// Note: This only exists to make the `hostname` function infallible.
+	#[arg(long, default_value = "<UNKNOWN>")]
+	pub hostname_fallback: String,
+
+	/// Specify a fallback CPU name if no-one could be detected automatically.
+	///
+	/// Note: This only exists to make the `cpuname` function infallible.
+	#[arg(long, default_value = "<UNKNOWN>")]
+	pub cpuname_fallback: String,
+}
+
+impl HostInfoParams {
+	/// Returns the hostname of the machine.
+	///
+	/// Can be used to track on which machine a benchmark was run.
+	pub fn hostname(&self) -> String {
+		self.hostname_override
+			.clone()
+			.or(gethostname::gethostname().into_string().ok())
+			.unwrap_or(self.hostname_fallback.clone())
+	}
+
+	/// Returns the CPU name of the current machine.
+	///
+	/// Can be used to track on which machine a benchmark was run.
+	pub fn cpuname(&self) -> String {
+		gather_sysinfo().cpu.unwrap_or(self.cpuname_fallback.clone())
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/shared/record.rs b/substrate/utils/frame/benchmarking-cli/src/shared/record.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d82caa172d07d84f68417e38ce70a3ab9abb86ff
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/shared/record.rs
@@ -0,0 +1,72 @@
+// 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.
+
+//! Defines the [`BenchRecord`] and its facilities for computing [`super::Stats`].
+
+use sc_cli::Result;
+use sc_service::Configuration;
+
+use log::info;
+use serde::Serialize;
+use std::{fs, path::PathBuf, time::Duration};
+
+use super::Stats;
+
+/// Raw output of a Storage benchmark.
+#[derive(Debug, Default, Clone, Serialize)]
+pub struct BenchRecord {
+	/// Multi-Map of value sizes and the time that it took to access them.
+	ns_per_size: Vec<(u64, u64)>,
+}
+
+impl BenchRecord {
+	/// Appends a new record. Uses safe casts.
+	pub fn append(&mut self, size: usize, d: Duration) -> Result<()> {
+		let size: u64 = size.try_into().map_err(|e| format!("Size overflow u64: {}", e))?;
+		let ns: u64 = d
+			.as_nanos()
+			.try_into()
+			.map_err(|e| format!("Nanoseconds overflow u64: {}", e))?;
+		self.ns_per_size.push((size, ns));
+		Ok(())
+	}
+
+	/// Returns the statistics for *time* and *value size*.
+	pub fn calculate_stats(self) -> Result<(Stats, Stats)> {
+		let (size, time): (Vec<_>, Vec<_>) = self.ns_per_size.into_iter().unzip();
+		let size = Stats::new(&size)?;
+		let time = Stats::new(&time)?;
+		Ok((time, size)) // The swap of time/size here is intentional.
+	}
+
+	/// Unless a path is specified, saves the raw results in a json file in the current directory.
+	/// Prefixes it with the DB name and suffixed with `path_suffix`.
+	pub fn save_json(&self, cfg: &Configuration, out_path: &PathBuf, suffix: &str) -> Result<()> {
+		let mut path = PathBuf::from(out_path);
+		if path.is_dir() || path.as_os_str().is_empty() {
+			path.push(&format!("{}_{}", cfg.database, suffix).to_lowercase());
+			path.set_extension("json");
+		}
+
+		let json = serde_json::to_string_pretty(&self)
+			.map_err(|e| format!("Serializing as JSON: {:?}", e))?;
+
+		fs::write(&path, json)?;
+		info!("Raw data written to {:?}", fs::canonicalize(&path)?);
+		Ok(())
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/shared/stats.rs b/substrate/utils/frame/benchmarking-cli/src/shared/stats.rs
new file mode 100644
index 0000000000000000000000000000000000000000..5c724456ddb9a9f7f449ffd19bcbf3c4ef8c4b60
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/shared/stats.rs
@@ -0,0 +1,188 @@
+// 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.
+
+//! Handles statistics that were generated from benchmarking results and
+//! that can be used to fill out weight templates.
+
+use sc_cli::Result;
+
+use serde::Serialize;
+use std::{fmt, result, str::FromStr};
+
+/// Various statistics that help to gauge the quality of the produced weights.
+/// Will be written to the weight file and printed to console.
+#[derive(Serialize, Default, Clone)]
+pub struct Stats {
+	/// Sum of all values.
+	pub sum: u64,
+	/// Minimal observed value.
+	pub min: u64,
+	/// Maximal observed value.
+	pub max: u64,
+
+	/// Average of all values.
+	pub avg: u64,
+	/// Median of all values.
+	pub median: u64,
+	/// Standard derivation of all values.
+	pub stddev: f64,
+
+	/// 99th percentile. At least 99% of all values are below this threshold.
+	pub p99: u64,
+	/// 95th percentile. At least 95% of all values are below this threshold.
+	pub p95: u64,
+	/// 75th percentile. At least 75% of all values are below this threshold.
+	pub p75: u64,
+}
+
+/// Selects a specific field from a [`Stats`] object.
+/// Not all fields are available.
+#[derive(Debug, Clone, Copy, Serialize, PartialEq)]
+pub enum StatSelect {
+	/// Select the maximum.
+	Maximum,
+	/// Select the average.
+	Average,
+	/// Select the median.
+	Median,
+	/// Select the 99th percentile.
+	P99Percentile,
+	/// Select the 95th percentile.
+	P95Percentile,
+	/// Select the 75th percentile.
+	P75Percentile,
+}
+
+impl Stats {
+	/// Calculates statistics and returns them.
+	pub fn new(xs: &Vec<u64>) -> Result<Self> {
+		if xs.is_empty() {
+			return Err("Empty input is invalid".into())
+		}
+		let (avg, stddev) = Self::avg_and_stddev(xs);
+
+		Ok(Self {
+			sum: xs.iter().sum(),
+			min: *xs.iter().min().expect("Checked for non-empty above"),
+			max: *xs.iter().max().expect("Checked for non-empty above"),
+
+			avg: avg as u64,
+			median: Self::percentile(xs.clone(), 0.50),
+			stddev: (stddev * 100.0).round() / 100.0, // round to 1/100
+
+			p99: Self::percentile(xs.clone(), 0.99),
+			p95: Self::percentile(xs.clone(), 0.95),
+			p75: Self::percentile(xs.clone(), 0.75),
+		})
+	}
+
+	/// Returns the selected stat.
+	pub fn select(&self, s: StatSelect) -> u64 {
+		match s {
+			StatSelect::Maximum => self.max,
+			StatSelect::Average => self.avg,
+			StatSelect::Median => self.median,
+			StatSelect::P99Percentile => self.p99,
+			StatSelect::P95Percentile => self.p95,
+			StatSelect::P75Percentile => self.p75,
+		}
+	}
+
+	/// Returns the *average* and the *standard derivation*.
+	fn avg_and_stddev(xs: &Vec<u64>) -> (f64, f64) {
+		let avg = xs.iter().map(|x| *x as f64).sum::<f64>() / xs.len() as f64;
+		let variance = xs.iter().map(|x| (*x as f64 - avg).powi(2)).sum::<f64>() / xs.len() as f64;
+		(avg, variance.sqrt())
+	}
+
+	/// Returns the specified percentile for the given data.
+	/// This is best effort since it ignores the interpolation case.
+	fn percentile(mut xs: Vec<u64>, p: f64) -> u64 {
+		xs.sort();
+		let index = (xs.len() as f64 * p).ceil() as usize - 1;
+		xs[index.clamp(0, xs.len() - 1)]
+	}
+}
+
+impl fmt::Debug for Stats {
+	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+		writeln!(f, "Total: {}", self.sum)?;
+		writeln!(f, "Min: {}, Max: {}", self.min, self.max)?;
+		writeln!(f, "Average: {}, Median: {}, Stddev: {}", self.avg, self.median, self.stddev)?;
+		write!(f, "Percentiles 99th, 95th, 75th: {}, {}, {}", self.p99, self.p95, self.p75)
+	}
+}
+
+impl Default for StatSelect {
+	/// Returns the `Average` selector.
+	fn default() -> Self {
+		Self::Average
+	}
+}
+
+impl FromStr for StatSelect {
+	type Err = &'static str;
+
+	fn from_str(day: &str) -> result::Result<Self, Self::Err> {
+		match day.to_lowercase().as_str() {
+			"max" => Ok(Self::Maximum),
+			"average" => Ok(Self::Average),
+			"median" => Ok(Self::Median),
+			"p99" => Ok(Self::P99Percentile),
+			"p95" => Ok(Self::P95Percentile),
+			"p75" => Ok(Self::P75Percentile),
+			_ => Err("String was not a StatSelect"),
+		}
+	}
+}
+
+#[cfg(test)]
+mod test_stats {
+	use super::Stats;
+	use rand::{seq::SliceRandom, thread_rng};
+
+	#[test]
+	fn stats_correct() {
+		let mut data: Vec<u64> = (1..=100).collect();
+		data.shuffle(&mut thread_rng());
+		let stats = Stats::new(&data).unwrap();
+
+		assert_eq!(stats.sum, 5050);
+		assert_eq!(stats.min, 1);
+		assert_eq!(stats.max, 100);
+
+		assert_eq!(stats.avg, 50);
+		assert_eq!(stats.median, 50); // 50.5 to be exact.
+		assert_eq!(stats.stddev, 28.87); // Rounded with 1/100 precision.
+
+		assert_eq!(stats.p99, 99);
+		assert_eq!(stats.p95, 95);
+		assert_eq!(stats.p75, 75);
+	}
+
+	#[test]
+	fn no_panic_short_lengths() {
+		// Empty input does error.
+		assert!(Stats::new(&vec![]).is_err());
+
+		// Different small input lengths are fine.
+		for l in 1..10 {
+			let data = (0..=l).collect();
+			assert!(Stats::new(&data).is_ok());
+		}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/shared/weight_params.rs b/substrate/utils/frame/benchmarking-cli/src/shared/weight_params.rs
new file mode 100644
index 0000000000000000000000000000000000000000..10230ba305f485954c6a6eca0ef0b0aa749dcbb3
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/shared/weight_params.rs
@@ -0,0 +1,95 @@
+// 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.
+
+//! Calculates a weight from the [`super::Stats`] of a benchmark result.
+
+use sc_cli::Result;
+
+use clap::Args;
+use serde::Serialize;
+use std::path::PathBuf;
+
+use super::{StatSelect, Stats};
+
+/// Configures the weight generation.
+#[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
+pub struct WeightParams {
+	/// File or directory to write the *weight* files to.
+	///
+	/// For Substrate this should be `frame/support/src/weights`.
+	#[arg(long)]
+	pub weight_path: Option<PathBuf>,
+
+	/// Select a specific metric to calculate the final weight output.
+	#[arg(long = "metric", default_value = "average")]
+	pub weight_metric: StatSelect,
+
+	/// Multiply the resulting weight with the given factor. Must be positive.
+	///
+	/// Is applied before `weight_add`.
+	#[arg(long = "mul", default_value_t = 1.0)]
+	pub weight_mul: f64,
+
+	/// Add the given offset to the resulting weight.
+	///
+	/// Is applied after `weight_mul`.
+	#[arg(long = "add", default_value_t = 0)]
+	pub weight_add: u64,
+}
+
+/// Calculates the final weight by multiplying the selected metric with
+/// `weight_mul` and adding `weight_add`.
+/// Does not use safe casts and can overflow.
+impl WeightParams {
+	pub fn calc_weight(&self, stat: &Stats) -> Result<u64> {
+		if self.weight_mul.is_sign_negative() || !self.weight_mul.is_normal() {
+			return Err("invalid floating number for `weight_mul`".into())
+		}
+		let s = stat.select(self.weight_metric) as f64;
+		let w = s.mul_add(self.weight_mul, self.weight_add as f64).ceil();
+		Ok(w as u64) // No safe cast here since there is no `From<f64>` for `u64`.
+	}
+}
+
+#[cfg(test)]
+mod test_weight_params {
+	use super::WeightParams;
+	use crate::shared::{StatSelect, Stats};
+
+	#[test]
+	fn calc_weight_works() {
+		let stats = Stats { avg: 113, ..Default::default() };
+		let params = WeightParams {
+			weight_metric: StatSelect::Average,
+			weight_mul: 0.75,
+			weight_add: 3,
+			..Default::default()
+		};
+
+		let want = (113.0f64 * 0.75 + 3.0).ceil() as u64; // Ceil for overestimation.
+		let got = params.calc_weight(&stats).unwrap();
+		assert_eq!(want, got);
+	}
+
+	#[test]
+	fn calc_weight_detects_negative_mul() {
+		let stats = Stats::default();
+		let params = WeightParams { weight_mul: -0.75, ..Default::default() };
+
+		assert!(params.calc_weight(&stats).is_err());
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/storage/README.md b/substrate/utils/frame/benchmarking-cli/src/storage/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f61b7ba1bddd0cd324be80dd41d95a456dda9eed
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/storage/README.md
@@ -0,0 +1,106 @@
+# The `benchmark storage` command
+
+The cost of storage operations in a Substrate chain depends on the current chain state.  
+It is therefore important to regularly update these weights as the chain grows.  
+This sub-command measures the cost of storage operations for a concrete snapshot.  
+
+For the Substrate node it looks like this (for debugging you can use `--release`):  
+```sh
+cargo run --profile=production -- benchmark storage --dev --state-version=1
+```
+
+Running the command on Substrate itself is not verify meaningful, since the genesis state of the `--dev` chain spec is used.  
+
+The output for the Polkadot client with a recent chain snapshot will give you a better impression. A recent snapshot can be downloaded from [Polkachu].  
+Then run (remove the `--db=paritydb` if you have a RocksDB snapshot):
+```sh
+cargo run --profile=production -- benchmark storage --dev --state-version=0 --db=paritydb --weight-path runtime/polkadot/constants/src/weights
+```
+
+This takes a while since reads and writes all keys from the snapshot:
+```pre
+# The 'read' benchmark
+Preparing keys from block BlockId::Number(9939462)    
+Reading 1379083 keys    
+Time summary [ns]:
+Total: 19668919930
+Min: 6450, Max: 1217259
+Average: 14262, Median: 14190, Stddev: 3035.79
+Percentiles 99th, 95th, 75th: 18270, 16190, 14819
+Value size summary:
+Total: 265702275
+Min: 1, Max: 1381859
+Average: 192, Median: 80, Stddev: 3427.53
+Percentiles 99th, 95th, 75th: 3368, 383, 80    
+
+# The 'write' benchmark
+Preparing keys from block BlockId::Number(9939462)    
+Writing 1379083 keys    
+Time summary [ns]:
+Total: 98393809781
+Min: 12969, Max: 13282577
+Average: 71347, Median: 69499, Stddev: 25145.27
+Percentiles 99th, 95th, 75th: 135839, 106129, 79239
+Value size summary:
+Total: 265702275
+Min: 1, Max: 1381859
+Average: 192, Median: 80, Stddev: 3427.53
+Percentiles 99th, 95th, 75th: 3368, 383, 80
+
+Writing weights to "paritydb_weights.rs"
+```
+You will see that the [paritydb_weights.rs] files was modified and now contains new weights. 
+The exact command for Polkadot can be seen at the top of the file.  
+This uses the most recent block from your snapshot which is printed at the top.  
+The value size summary tells us that the pruned Polkadot chain state is ~253 MiB in size.  
+Reading a value on average takes (in this examples) 14.3 µs and writing 71.3 µs.  
+The interesting part in the generated weight file tells us the weight constants and some statistics about the measurements:
+```rust
+/// Time to read one storage item.
+/// Calculated by multiplying the *Average* of all values with `1.1` and adding `0`.
+///
+/// Stats [NS]:
+///   Min, Max: 4_611, 1_217_259
+///   Average:  14_262
+///   Median:   14_190
+///   Std-Dev:  3035.79
+///
+/// Percentiles [NS]:
+///   99th: 18_270
+///   95th: 16_190
+///   75th: 14_819
+read: 14_262 * constants::WEIGHT_REF_TIME_PER_NANOS,
+
+/// Time to write one storage item.
+/// Calculated by multiplying the *Average* of all values with `1.1` and adding `0`.
+///
+/// Stats [NS]:
+///   Min, Max: 12_969, 13_282_577
+///   Average:  71_347This works under the assumption that the *average* read a
+///   Median:   69_499
+///   Std-Dev:  25145.27
+///
+/// Percentiles [NS]:
+///   99th: 135_839
+///   95th: 106_129
+///   75th: 79_239
+write: 71_347 * constants::WEIGHT_REF_TIME_PER_NANOS,
+```
+
+## Arguments
+
+- `--db` Specify which database backend to use. This greatly influences the results.
+- `--state-version` Set the version of the state encoding that this snapshot uses. Should be set to `1` for Substrate `--dev` and `0` for Polkadot et al. Using the wrong version can corrupt the snapshot.
+- [`--mul`](../shared/README.md#arguments)
+- [`--add`](../shared/README.md#arguments)
+- [`--metric`](../shared/README.md#arguments)
+- [`--weight-path`](../shared/README.md#arguments)
+- `--json-read-path` Write the raw 'read' results to this file or directory.
+- `--json-write-path` Write the raw 'write' results to this file or directory.
+- [`--header`](../shared/README.md#arguments)
+
+License: Apache-2.0
+
+<!-- LINKS -->
+[Polkachu]: https://polkachu.com/snapshots
+[paritydb_weights.rs]: https://github.com/paritytech/polkadot/blob/c254e5975711a6497af256f6831e9a6c752d28f5/runtime/polkadot/constants/src/weights/paritydb_weights.rs#L60
diff --git a/substrate/utils/frame/benchmarking-cli/src/storage/cmd.rs b/substrate/utils/frame/benchmarking-cli/src/storage/cmd.rs
new file mode 100644
index 0000000000000000000000000000000000000000..307c9207fdaf9851c8d2acf1ccd1511c738951fe
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/storage/cmd.rs
@@ -0,0 +1,233 @@
+// 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 sc_cli::{CliConfiguration, DatabaseParams, PruningParams, Result, SharedParams};
+use sc_client_api::{Backend as ClientBackend, StorageProvider, UsageProvider};
+use sc_client_db::DbHash;
+use sc_service::Configuration;
+use sp_blockchain::HeaderBackend;
+use sp_database::{ColumnId, Database};
+use sp_runtime::traits::{Block as BlockT, HashingFor};
+use sp_state_machine::Storage;
+use sp_storage::{ChildInfo, ChildType, PrefixedStorageKey, StateVersion};
+
+use clap::{Args, Parser};
+use log::info;
+use rand::prelude::*;
+use serde::Serialize;
+use sp_runtime::generic::BlockId;
+use std::{fmt::Debug, path::PathBuf, sync::Arc};
+
+use super::template::TemplateData;
+use crate::shared::{new_rng, HostInfoParams, WeightParams};
+
+/// Benchmark the storage speed of a chain snapshot.
+#[derive(Debug, Parser)]
+pub struct StorageCmd {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: SharedParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub database_params: DatabaseParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub pruning_params: PruningParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub params: StorageParams,
+}
+
+/// Parameters for modifying the benchmark behaviour and the post processing of the results.
+#[derive(Debug, Default, Serialize, Clone, PartialEq, Args)]
+pub struct StorageParams {
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub weight_params: WeightParams,
+
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub hostinfo: HostInfoParams,
+
+	/// Skip the `read` benchmark.
+	#[arg(long)]
+	pub skip_read: bool,
+
+	/// Skip the `write` benchmark.
+	#[arg(long)]
+	pub skip_write: bool,
+
+	/// Specify the Handlebars template to use for outputting benchmark results.
+	#[arg(long)]
+	pub template_path: Option<PathBuf>,
+
+	/// Add a header to the generated weight output file.
+	///
+	/// Good for adding LICENSE headers.
+	#[arg(long, value_name = "PATH")]
+	pub header: Option<PathBuf>,
+
+	/// Path to write the raw 'read' results in JSON format to. Can be a file or directory.
+	#[arg(long)]
+	pub json_read_path: Option<PathBuf>,
+
+	/// Path to write the raw 'write' results in JSON format to. Can be a file or directory.
+	#[arg(long)]
+	pub json_write_path: Option<PathBuf>,
+
+	/// Rounds of warmups before measuring.
+	#[arg(long, default_value_t = 1)]
+	pub warmups: u32,
+
+	/// The `StateVersion` to use. Substrate `--dev` should use `V1` and Polkadot `V0`.
+	/// Selecting the wrong version can corrupt the DB.
+	#[arg(long, value_parser = clap::value_parser!(u8).range(0..=1))]
+	pub state_version: u8,
+
+	/// Trie cache size in bytes.
+	///
+	/// Providing `0` will disable the cache.
+	#[arg(long, value_name = "Bytes", default_value_t = 67108864)]
+	pub trie_cache_size: usize,
+
+	/// Enable the Trie cache.
+	///
+	/// This should only be used for performance analysis and not for final results.
+	#[arg(long)]
+	pub enable_trie_cache: bool,
+
+	/// Include child trees in benchmark.
+	#[arg(long)]
+	pub include_child_trees: bool,
+}
+
+impl StorageCmd {
+	/// Calls into the Read and Write benchmarking functions.
+	/// Processes the output and writes it into files and stdout.
+	pub fn run<Block, BA, C>(
+		&self,
+		cfg: Configuration,
+		client: Arc<C>,
+		db: (Arc<dyn Database<DbHash>>, ColumnId),
+		storage: Arc<dyn Storage<HashingFor<Block>>>,
+	) -> Result<()>
+	where
+		BA: ClientBackend<Block>,
+		Block: BlockT<Hash = DbHash>,
+		C: UsageProvider<Block> + StorageProvider<Block, BA> + HeaderBackend<Block>,
+	{
+		let mut template = TemplateData::new(&cfg, &self.params)?;
+
+		let block_id = BlockId::<Block>::Number(client.usage_info().chain.best_number);
+		template.set_block_number(block_id.to_string());
+
+		if !self.params.skip_read {
+			self.bench_warmup(&client)?;
+			let record = self.bench_read(client.clone())?;
+			if let Some(path) = &self.params.json_read_path {
+				record.save_json(&cfg, path, "read")?;
+			}
+			let stats = record.calculate_stats()?;
+			info!("Time summary [ns]:\n{:?}\nValue size summary:\n{:?}", stats.0, stats.1);
+			template.set_stats(Some(stats), None)?;
+		}
+
+		if !self.params.skip_write {
+			self.bench_warmup(&client)?;
+			let record = self.bench_write(client, db, storage)?;
+			if let Some(path) = &self.params.json_write_path {
+				record.save_json(&cfg, path, "write")?;
+			}
+			let stats = record.calculate_stats()?;
+			info!("Time summary [ns]:\n{:?}\nValue size summary:\n{:?}", stats.0, stats.1);
+			template.set_stats(None, Some(stats))?;
+		}
+
+		template.write(&self.params.weight_params.weight_path, &self.params.template_path)
+	}
+
+	/// Returns the specified state version.
+	pub(crate) fn state_version(&self) -> StateVersion {
+		match self.params.state_version {
+			0 => StateVersion::V0,
+			1 => StateVersion::V1,
+			_ => unreachable!("Clap set to only allow 0 and 1"),
+		}
+	}
+
+	/// Returns Some if child node and None if regular
+	pub(crate) fn is_child_key(&self, key: Vec<u8>) -> Option<ChildInfo> {
+		if let Some((ChildType::ParentKeyId, storage_key)) =
+			ChildType::from_prefixed_key(&PrefixedStorageKey::new(key))
+		{
+			return Some(ChildInfo::new_default(storage_key))
+		}
+		None
+	}
+
+	/// Run some rounds of the (read) benchmark as warmup.
+	/// See `frame_benchmarking_cli::storage::read::bench_read` for detailed comments.
+	fn bench_warmup<B, BA, C>(&self, client: &Arc<C>) -> Result<()>
+	where
+		C: UsageProvider<B> + StorageProvider<B, BA>,
+		B: BlockT + Debug,
+		BA: ClientBackend<B>,
+	{
+		let hash = client.usage_info().chain.best_hash;
+		let mut keys: Vec<_> = client.storage_keys(hash, None, None)?.collect();
+		let (mut rng, _) = new_rng(None);
+		keys.shuffle(&mut rng);
+
+		for i in 0..self.params.warmups {
+			info!("Warmup round {}/{}", i + 1, self.params.warmups);
+			for key in keys.as_slice() {
+				let _ = client
+					.storage(hash, &key)
+					.expect("Checked above to exist")
+					.ok_or("Value unexpectedly empty");
+			}
+		}
+
+		Ok(())
+	}
+}
+
+// Boilerplate
+impl CliConfiguration for StorageCmd {
+	fn shared_params(&self) -> &SharedParams {
+		&self.shared_params
+	}
+
+	fn database_params(&self) -> Option<&DatabaseParams> {
+		Some(&self.database_params)
+	}
+
+	fn pruning_params(&self) -> Option<&PruningParams> {
+		Some(&self.pruning_params)
+	}
+
+	fn trie_cache_maximum_size(&self) -> Result<Option<usize>> {
+		if self.params.enable_trie_cache && self.params.trie_cache_size > 0 {
+			Ok(Some(self.params.trie_cache_size))
+		} else {
+			Ok(None)
+		}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/storage/mod.rs b/substrate/utils/frame/benchmarking-cli/src/storage/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..188cc5e3d4e41293aef23426b19b18a1a602d7b7
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/storage/mod.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.
+
+pub mod cmd;
+pub mod read;
+pub mod template;
+pub mod write;
+
+pub use cmd::StorageCmd;
diff --git a/substrate/utils/frame/benchmarking-cli/src/storage/read.rs b/substrate/utils/frame/benchmarking-cli/src/storage/read.rs
new file mode 100644
index 0000000000000000000000000000000000000000..fe72364269d505907f34cf7f4332c768323f7af6
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/storage/read.rs
@@ -0,0 +1,87 @@
+// 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 sc_cli::Result;
+use sc_client_api::{Backend as ClientBackend, StorageProvider, UsageProvider};
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+
+use log::info;
+use rand::prelude::*;
+use std::{fmt::Debug, sync::Arc, time::Instant};
+
+use super::cmd::StorageCmd;
+use crate::shared::{new_rng, BenchRecord};
+
+impl StorageCmd {
+	/// Benchmarks the time it takes to read a single Storage item.
+	/// Uses the latest state that is available for the given client.
+	pub(crate) fn bench_read<B, BA, C>(&self, client: Arc<C>) -> Result<BenchRecord>
+	where
+		C: UsageProvider<B> + StorageProvider<B, BA>,
+		B: BlockT + Debug,
+		BA: ClientBackend<B>,
+		<<B as BlockT>::Header as HeaderT>::Number: From<u32>,
+	{
+		let mut record = BenchRecord::default();
+		let best_hash = client.usage_info().chain.best_hash;
+
+		info!("Preparing keys from block {}", best_hash);
+		// Load all keys and randomly shuffle them.
+		let mut keys: Vec<_> = client.storage_keys(best_hash, None, None)?.collect();
+		let (mut rng, _) = new_rng(None);
+		keys.shuffle(&mut rng);
+
+		let mut child_nodes = Vec::new();
+		// Interesting part here:
+		// Read all the keys in the database and measure the time it takes to access each.
+		info!("Reading {} keys", keys.len());
+		for key in keys.as_slice() {
+			match (self.params.include_child_trees, self.is_child_key(key.clone().0)) {
+				(true, Some(info)) => {
+					// child tree key
+					for ck in client.child_storage_keys(best_hash, info.clone(), None, None)? {
+						child_nodes.push((ck.clone(), info.clone()));
+					}
+				},
+				_ => {
+					// regular key
+					let start = Instant::now();
+					let v = client
+						.storage(best_hash, &key)
+						.expect("Checked above to exist")
+						.ok_or("Value unexpectedly empty")?;
+					record.append(v.0.len(), start.elapsed())?;
+				},
+			}
+		}
+
+		if self.params.include_child_trees {
+			child_nodes.shuffle(&mut rng);
+
+			info!("Reading {} child keys", child_nodes.len());
+			for (key, info) in child_nodes.as_slice() {
+				let start = Instant::now();
+				let v = client
+					.child_storage(best_hash, info, key)
+					.expect("Checked above to exist")
+					.ok_or("Value unexpectedly empty")?;
+				record.append(v.0.len(), start.elapsed())?;
+			}
+		}
+		Ok(record)
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/storage/template.rs b/substrate/utils/frame/benchmarking-cli/src/storage/template.rs
new file mode 100644
index 0000000000000000000000000000000000000000..43aea75b4771165e7fb56922d6fe3c5d776452ac
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/storage/template.rs
@@ -0,0 +1,149 @@
+// 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 sc_cli::Result;
+use sc_service::Configuration;
+
+use log::info;
+use serde::Serialize;
+use std::{env, fs, path::PathBuf};
+
+use super::cmd::StorageParams;
+use crate::shared::{Stats, UnderscoreHelper};
+
+static VERSION: &str = env!("CARGO_PKG_VERSION");
+static TEMPLATE: &str = include_str!("./weights.hbs");
+
+/// Data consumed by Handlebar to fill out the `weights.hbs` template.
+#[derive(Serialize, Default, Debug, Clone)]
+pub(crate) struct TemplateData {
+	/// Name of the database used.
+	db_name: String,
+	/// Block number that was used.
+	block_number: String,
+	/// Name of the runtime. Taken from the chain spec.
+	runtime_name: String,
+	/// Version of the benchmarking CLI used.
+	version: String,
+	/// Date that the template was filled out.
+	date: String,
+	/// Hostname of the machine that executed the benchmarks.
+	hostname: String,
+	/// CPU name of the machine that executed the benchmarks.
+	cpuname: String,
+	/// Header for the generated file.
+	header: String,
+	/// Command line arguments that were passed to the CLI.
+	args: Vec<String>,
+	/// Storage params of the executed command.
+	params: StorageParams,
+	/// The weight for one `read`.
+	read_weight: u64,
+	/// The weight for one `write`.
+	write_weight: u64,
+	/// Stats about a `read` benchmark. Contains *time* and *value size* stats.
+	/// The *value size* stats are currently not used in the template.
+	read: Option<(Stats, Stats)>,
+	/// Stats about a `write` benchmark. Contains *time* and *value size* stats.
+	/// The *value size* stats are currently not used in the template.
+	write: Option<(Stats, Stats)>,
+}
+
+impl TemplateData {
+	/// Returns a new [`Self`] from the given configuration.
+	pub fn new(cfg: &Configuration, params: &StorageParams) -> Result<Self> {
+		let header = params
+			.header
+			.as_ref()
+			.map(|p| std::fs::read_to_string(p))
+			.transpose()?
+			.unwrap_or_default();
+
+		Ok(TemplateData {
+			db_name: format!("{}", cfg.database),
+			runtime_name: cfg.chain_spec.name().into(),
+			version: VERSION.into(),
+			date: chrono::Utc::now().format("%Y-%m-%d (Y/M/D)").to_string(),
+			hostname: params.hostinfo.hostname(),
+			cpuname: params.hostinfo.cpuname(),
+			header,
+			args: env::args().collect::<Vec<String>>(),
+			params: params.clone(),
+			..Default::default()
+		})
+	}
+
+	/// Sets the stats and calculates the final weights.
+	pub fn set_stats(
+		&mut self,
+		read: Option<(Stats, Stats)>,
+		write: Option<(Stats, Stats)>,
+	) -> Result<()> {
+		if let Some(read) = read {
+			self.read_weight = self.params.weight_params.calc_weight(&read.0)?;
+			self.read = Some(read);
+		}
+		if let Some(write) = write {
+			self.write_weight = self.params.weight_params.calc_weight(&write.0)?;
+			self.write = Some(write);
+		}
+		Ok(())
+	}
+
+	/// Sets the block id that was used.
+	pub fn set_block_number(&mut self, block_number: String) {
+		self.block_number = block_number
+	}
+
+	/// Fills out the `weights.hbs` or specified HBS template with its own data.
+	/// Writes the result to `path` which can be a directory or file.
+	pub fn write(&self, path: &Option<PathBuf>, hbs_template: &Option<PathBuf>) -> Result<()> {
+		let mut handlebars = handlebars::Handlebars::new();
+		// Format large integers with underscore.
+		handlebars.register_helper("underscore", Box::new(UnderscoreHelper));
+		// Don't HTML escape any characters.
+		handlebars.register_escape_fn(|s| -> String { s.to_string() });
+		// Use custom template if provided.
+		let template = match hbs_template {
+			Some(template) if template.is_file() => fs::read_to_string(template)?,
+			Some(_) => return Err("Handlebars template is not a valid file!".into()),
+			None => TEMPLATE.to_string(),
+		};
+
+		let out_path = self.build_path(path);
+		let mut fd = fs::File::create(&out_path)?;
+		info!("Writing weights to {:?}", fs::canonicalize(&out_path)?);
+
+		handlebars
+			.render_template_to_write(&template, &self, &mut fd)
+			.map_err(|e| format!("HBS template write: {:?}", e).into())
+	}
+
+	/// Builds a path for the weight file.
+	fn build_path(&self, weight_out: &Option<PathBuf>) -> PathBuf {
+		let mut path = match weight_out {
+			Some(p) => PathBuf::from(p),
+			None => PathBuf::new(),
+		};
+
+		if path.is_dir() || path.as_os_str().is_empty() {
+			path.push(format!("{}_weights", self.db_name.to_lowercase()));
+			path.set_extension("rs");
+		}
+		path
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/storage/weights.hbs b/substrate/utils/frame/benchmarking-cli/src/storage/weights.hbs
new file mode 100644
index 0000000000000000000000000000000000000000..135b18b1937468d760435448391860f55490d581
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/storage/weights.hbs
@@ -0,0 +1,95 @@
+{{header}}
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION {{version}}
+//! DATE: {{date}}
+//! HOSTNAME: `{{hostname}}`, CPU: `{{cpuname}}`
+//!
+//! DATABASE: `{{db_name}}`, RUNTIME: `{{runtime_name}}`
+//! BLOCK-NUM: `{{block_number}}`
+//! SKIP-WRITE: `{{params.skip_write}}`, SKIP-READ: `{{params.skip_read}}`, WARMUPS: `{{params.warmups}}`
+//! STATE-VERSION: `V{{params.state_version}}`, STATE-CACHE-SIZE: `{{params.state_cache_size}}`
+//! WEIGHT-PATH: `{{params.weight_params.weight_path}}`
+//! METRIC: `{{params.weight_params.weight_metric}}`, WEIGHT-MUL: `{{params.weight_params.weight_mul}}`, WEIGHT-ADD: `{{params.weight_params.weight_add}}`
+
+// Executed Command:
+{{#each args as |arg|}}
+//   {{arg}}
+{{/each}}
+
+/// Storage DB weights for the `{{runtime_name}}` runtime and `{{db_name}}`.
+pub mod constants {
+	use frame_support::weights::constants;
+	use sp_core::parameter_types;
+	use sp_weights::RuntimeDbWeight;
+
+	parameter_types! {
+		{{#if (eq db_name "ParityDb")}}
+		/// `ParityDB` can be enabled with a feature flag, but is still experimental. These weights
+		/// are available for brave runtime engineers who may want to try this out as default.
+		{{else}}
+		/// By default, Substrate uses `RocksDB`, so this will be the weight used throughout
+		/// the runtime.
+		{{/if}}
+		pub const {{db_name}}Weight: RuntimeDbWeight = RuntimeDbWeight {
+			/// Time to read one storage item.
+			/// Calculated by multiplying the *{{params.weight_params.weight_metric}}* of all values with `{{params.weight_params.weight_mul}}` and adding `{{params.weight_params.weight_add}}`.
+			///
+			/// Stats nanoseconds:
+			///   Min, Max: {{underscore read.0.min}}, {{underscore read.0.max}}
+			///   Average:  {{underscore read.0.avg}}
+			///   Median:   {{underscore read.0.median}}
+			///   Std-Dev:  {{read.0.stddev}}
+			///
+			/// Percentiles nanoseconds:
+			///   99th: {{underscore read.0.p99}}
+			///   95th: {{underscore read.0.p95}}
+			///   75th: {{underscore read.0.p75}}
+			read: {{underscore read_weight}} * constants::WEIGHT_REF_TIME_PER_NANOS,
+
+			/// Time to write one storage item.
+			/// Calculated by multiplying the *{{params.weight_params.weight_metric}}* of all values with `{{params.weight_params.weight_mul}}` and adding `{{params.weight_params.weight_add}}`.
+			///
+			/// Stats nanoseconds:
+			///   Min, Max: {{underscore write.0.min}}, {{underscore write.0.max}}
+			///   Average:  {{underscore write.0.avg}}
+			///   Median:   {{underscore write.0.median}}
+			///   Std-Dev:  {{write.0.stddev}}
+			///
+			/// Percentiles nanoseconds:
+			///   99th: {{underscore write.0.p99}}
+			///   95th: {{underscore write.0.p95}}
+			///   75th: {{underscore write.0.p75}}
+			write: {{underscore write_weight}} * constants::WEIGHT_REF_TIME_PER_NANOS,
+		};
+	}
+
+	#[cfg(test)]
+	mod test_db_weights {
+		use super::constants::{{db_name}}Weight as W;
+		use sp_weights::constants;
+
+		/// Checks that all weights exist and have sane values.
+		// NOTE: If this test fails but you are sure that the generated values are fine,
+		// you can delete it.
+		#[test]
+		fn bound() {
+			// At least 1 µs.
+			assert!(
+				W::get().reads(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Read weight should be at least 1 µs."
+			);
+			assert!(
+				W::get().writes(1).ref_time() >= constants::WEIGHT_REF_TIME_PER_MICROS,
+				"Write weight should be at least 1 µs."
+			);
+			// At most 1 ms.
+			assert!(
+				W::get().reads(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Read weight should be at most 1 ms."
+			);
+			assert!(
+				W::get().writes(1).ref_time() <= constants::WEIGHT_REF_TIME_PER_MILLIS,
+				"Write weight should be at most 1 ms."
+			);
+		}
+	}
+}
diff --git a/substrate/utils/frame/benchmarking-cli/src/storage/write.rs b/substrate/utils/frame/benchmarking-cli/src/storage/write.rs
new file mode 100644
index 0000000000000000000000000000000000000000..4def1909ead5e0ef1675eeb8ca9bcd777b606005
--- /dev/null
+++ b/substrate/utils/frame/benchmarking-cli/src/storage/write.rs
@@ -0,0 +1,245 @@
+// 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 sc_cli::Result;
+use sc_client_api::{Backend as ClientBackend, StorageProvider, UsageProvider};
+use sc_client_db::{DbHash, DbState, DbStateBuilder};
+use sp_api::StateBackend;
+use sp_blockchain::HeaderBackend;
+use sp_database::{ColumnId, Transaction};
+use sp_runtime::traits::{Block as BlockT, HashingFor, Header as HeaderT};
+use sp_trie::PrefixedMemoryDB;
+
+use log::{info, trace};
+use rand::prelude::*;
+use sp_storage::{ChildInfo, StateVersion};
+use std::{
+	fmt::Debug,
+	sync::Arc,
+	time::{Duration, Instant},
+};
+
+use super::cmd::StorageCmd;
+use crate::shared::{new_rng, BenchRecord};
+
+impl StorageCmd {
+	/// Benchmarks the time it takes to write a single Storage item.
+	/// Uses the latest state that is available for the given client.
+	pub(crate) fn bench_write<Block, BA, H, C>(
+		&self,
+		client: Arc<C>,
+		(db, state_col): (Arc<dyn sp_database::Database<DbHash>>, ColumnId),
+		storage: Arc<dyn sp_state_machine::Storage<HashingFor<Block>>>,
+	) -> Result<BenchRecord>
+	where
+		Block: BlockT<Header = H, Hash = DbHash> + Debug,
+		H: HeaderT<Hash = DbHash>,
+		BA: ClientBackend<Block>,
+		C: UsageProvider<Block> + HeaderBackend<Block> + StorageProvider<Block, BA>,
+	{
+		// Store the time that it took to write each value.
+		let mut record = BenchRecord::default();
+
+		let best_hash = client.usage_info().chain.best_hash;
+		let header = client.header(best_hash)?.ok_or("Header not found")?;
+		let original_root = *header.state_root();
+		let trie = DbStateBuilder::<Block>::new(storage.clone(), original_root).build();
+
+		info!("Preparing keys from block {}", best_hash);
+		// Load all KV pairs and randomly shuffle them.
+		let mut kvs: Vec<_> = trie.pairs(Default::default())?.collect();
+		let (mut rng, _) = new_rng(None);
+		kvs.shuffle(&mut rng);
+		info!("Writing {} keys", kvs.len());
+
+		let mut child_nodes = Vec::new();
+
+		// Generate all random values first; Make sure there are no collisions with existing
+		// db entries, so we can rollback all additions without corrupting existing entries.
+		for key_value in kvs {
+			let (k, original_v) = key_value?;
+			match (self.params.include_child_trees, self.is_child_key(k.to_vec())) {
+				(true, Some(info)) => {
+					let child_keys =
+						client.child_storage_keys(best_hash, info.clone(), None, None)?;
+					for ck in child_keys {
+						child_nodes.push((ck.clone(), info.clone()));
+					}
+				},
+				_ => {
+					// regular key
+					let mut new_v = vec![0; original_v.len()];
+					loop {
+						// Create a random value to overwrite with.
+						// NOTE: We use a possibly higher entropy than the original value,
+						// could be improved but acts as an over-estimation which is fine for now.
+						rng.fill_bytes(&mut new_v[..]);
+						if check_new_value::<Block>(
+							db.clone(),
+							&trie,
+							&k.to_vec(),
+							&new_v,
+							self.state_version(),
+							state_col,
+							None,
+						) {
+							break
+						}
+					}
+
+					// Write each value in one commit.
+					let (size, duration) = measure_write::<Block>(
+						db.clone(),
+						&trie,
+						k.to_vec(),
+						new_v.to_vec(),
+						self.state_version(),
+						state_col,
+						None,
+					)?;
+					record.append(size, duration)?;
+				},
+			}
+		}
+
+		if self.params.include_child_trees {
+			child_nodes.shuffle(&mut rng);
+			info!("Writing {} child keys", child_nodes.len());
+
+			for (key, info) in child_nodes {
+				if let Some(original_v) = client
+					.child_storage(best_hash, &info.clone(), &key)
+					.expect("Checked above to exist")
+				{
+					let mut new_v = vec![0; original_v.0.len()];
+					loop {
+						rng.fill_bytes(&mut new_v[..]);
+						if check_new_value::<Block>(
+							db.clone(),
+							&trie,
+							&key.0,
+							&new_v,
+							self.state_version(),
+							state_col,
+							Some(&info),
+						) {
+							break
+						}
+					}
+
+					let (size, duration) = measure_write::<Block>(
+						db.clone(),
+						&trie,
+						key.0,
+						new_v.to_vec(),
+						self.state_version(),
+						state_col,
+						Some(&info),
+					)?;
+					record.append(size, duration)?;
+				}
+			}
+		}
+
+		Ok(record)
+	}
+}
+
+/// Converts a Trie transaction into a DB transaction.
+/// Removals are ignored and will not be included in the final tx.
+/// `invert_inserts` replaces all inserts with removals.
+fn convert_tx<B: BlockT>(
+	db: Arc<dyn sp_database::Database<DbHash>>,
+	mut tx: PrefixedMemoryDB<HashingFor<B>>,
+	invert_inserts: bool,
+	col: ColumnId,
+) -> Transaction<DbHash> {
+	let mut ret = Transaction::<DbHash>::default();
+
+	for (mut k, (v, rc)) in tx.drain().into_iter() {
+		if rc > 0 {
+			db.sanitize_key(&mut k);
+			if invert_inserts {
+				ret.remove(col, &k);
+			} else {
+				ret.set(col, &k, &v);
+			}
+		}
+		// < 0 means removal - ignored.
+		// 0 means no modification.
+	}
+	ret
+}
+
+/// Measures write benchmark
+/// if `child_info` exist then it means this is a child tree key
+fn measure_write<Block: BlockT>(
+	db: Arc<dyn sp_database::Database<DbHash>>,
+	trie: &DbState<Block>,
+	key: Vec<u8>,
+	new_v: Vec<u8>,
+	version: StateVersion,
+	col: ColumnId,
+	child_info: Option<&ChildInfo>,
+) -> Result<(usize, Duration)> {
+	let start = Instant::now();
+	// Create a TX that will modify the Trie in the DB and
+	// calculate the root hash of the Trie after the modification.
+	let replace = vec![(key.as_ref(), Some(new_v.as_ref()))];
+	let stx = match child_info {
+		Some(info) => trie.child_storage_root(info, replace.iter().cloned(), version).2,
+		None => trie.storage_root(replace.iter().cloned(), version).1,
+	};
+	// Only the keep the insertions, since we do not want to benchmark pruning.
+	let tx = convert_tx::<Block>(db.clone(), stx.clone(), false, col);
+	db.commit(tx).map_err(|e| format!("Writing to the Database: {}", e))?;
+	let result = (new_v.len(), start.elapsed());
+
+	// Now undo the changes by removing what was added.
+	let tx = convert_tx::<Block>(db.clone(), stx.clone(), true, col);
+	db.commit(tx).map_err(|e| format!("Writing to the Database: {}", e))?;
+	Ok(result)
+}
+
+/// Checks if a new value causes any collision in tree updates
+/// returns true if there is no collision
+/// if `child_info` exist then it means this is a child tree key
+fn check_new_value<Block: BlockT>(
+	db: Arc<dyn sp_database::Database<DbHash>>,
+	trie: &DbState<Block>,
+	key: &Vec<u8>,
+	new_v: &Vec<u8>,
+	version: StateVersion,
+	col: ColumnId,
+	child_info: Option<&ChildInfo>,
+) -> bool {
+	let new_kv = vec![(key.as_ref(), Some(new_v.as_ref()))];
+	let mut stx = match child_info {
+		Some(info) => trie.child_storage_root(info, new_kv.iter().cloned(), version).2,
+		None => trie.storage_root(new_kv.iter().cloned(), version).1,
+	};
+	for (mut k, (_, rc)) in stx.drain().into_iter() {
+		if rc > 0 {
+			db.sanitize_key(&mut k);
+			if db.get(col, &k).is_some() {
+				trace!("Benchmark-store key creation: Key collision detected, retry");
+				return false
+			}
+		}
+	}
+	true
+}
diff --git a/substrate/utils/frame/frame-utilities-cli/Cargo.toml b/substrate/utils/frame/frame-utilities-cli/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f2665cde5142103adec933547dfc932a2fac568c
--- /dev/null
+++ b/substrate/utils/frame/frame-utilities-cli/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "substrate-frame-cli"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "cli interface for FRAME"
+documentation = "https://docs.rs/substrate-frame-cli"
+readme = "README.md"
+
+[dependencies]
+clap = { version = "4.2.5", features = ["derive"] }
+frame-support = { version = "4.0.0-dev", path = "../../../frame/support" }
+frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
+sc-cli = { version = "0.10.0-dev", path = "../../../client/cli" }
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+
+[features]
+default = []
diff --git a/substrate/utils/frame/frame-utilities-cli/README.md b/substrate/utils/frame/frame-utilities-cli/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b1e4f869af7580687e663c5bf2e3c89a1badd35a
--- /dev/null
+++ b/substrate/utils/frame/frame-utilities-cli/README.md
@@ -0,0 +1,3 @@
+frame-system CLI utilities
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/utils/frame/frame-utilities-cli/src/lib.rs b/substrate/utils/frame/frame-utilities-cli/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..97129e36f7e9c04664a793d75d00e8bf8a86a413
--- /dev/null
+++ b/substrate/utils/frame/frame-utilities-cli/src/lib.rs
@@ -0,0 +1,22 @@
+// 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-system CLI utilities
+
+mod pallet_id;
+
+pub use pallet_id::PalletIdCmd;
diff --git a/substrate/utils/frame/frame-utilities-cli/src/pallet_id.rs b/substrate/utils/frame/frame-utilities-cli/src/pallet_id.rs
new file mode 100644
index 0000000000000000000000000000000000000000..abc0cdb3ff52b355596e4b1cd25c67ee0508d951
--- /dev/null
+++ b/substrate/utils/frame/frame-utilities-cli/src/pallet_id.rs
@@ -0,0 +1,88 @@
+// 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.
+
+//! Implementation of the `palletid` subcommand
+
+use clap::Parser;
+use frame_support::PalletId;
+use sc_cli::{
+	utils::print_from_uri, with_crypto_scheme, CryptoSchemeFlag, Error, KeystoreParams,
+	OutputTypeFlag,
+};
+use sp_core::crypto::{unwrap_or_default_ss58_version, Ss58AddressFormat, Ss58Codec};
+use sp_runtime::traits::AccountIdConversion;
+
+/// The `palletid` command
+#[derive(Debug, Parser)]
+#[command(name = "palletid", about = "Inspect a module ID address")]
+pub struct PalletIdCmd {
+	/// The module ID used to derive the account
+	id: String,
+
+	/// network address format
+	#[arg(
+		long,
+		value_name = "NETWORK",
+		value_parser = sc_cli::parse_ss58_address_format,
+		ignore_case = true,
+	)]
+	pub network: Option<Ss58AddressFormat>,
+
+	#[allow(missing_docs)]
+	#[command(flatten)]
+	pub output_scheme: OutputTypeFlag,
+
+	#[allow(missing_docs)]
+	#[command(flatten)]
+	pub crypto_scheme: CryptoSchemeFlag,
+
+	#[allow(missing_docs)]
+	#[command(flatten)]
+	pub keystore_params: KeystoreParams,
+}
+
+impl PalletIdCmd {
+	/// runs the command
+	pub fn run<R>(&self) -> Result<(), Error>
+	where
+		R: frame_system::Config,
+		R::AccountId: Ss58Codec,
+	{
+		if self.id.len() != 8 {
+			return Err("a module id must be a string of 8 characters".into())
+		}
+		let password = self.keystore_params.read_password()?;
+
+		let id_fixed_array: [u8; 8] = self.id.as_bytes().try_into().map_err(|_| {
+			"Cannot convert argument to palletid: argument should be 8-character string"
+		})?;
+
+		let account_id: R::AccountId = PalletId(id_fixed_array).into_account_truncating();
+
+		with_crypto_scheme!(
+			self.crypto_scheme.scheme,
+			print_from_uri(
+				&account_id.to_ss58check_with_version(unwrap_or_default_ss58_version(self.network)),
+				password,
+				self.network,
+				self.output_scheme.output_type
+			)
+		);
+
+		Ok(())
+	}
+}
diff --git a/substrate/utils/frame/generate-bags/Cargo.toml b/substrate/utils/frame/generate-bags/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e8d7d51ead89765ee7541c577d8689678f69c48b
--- /dev/null
+++ b/substrate/utils/frame/generate-bags/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "generate-bags"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Bag threshold generation script for pallet-bag-list"
+
+[dependencies]
+# FRAME
+frame-support = { version = "4.0.0-dev", path = "../../../frame/support" }
+frame-election-provider-support = { version = "4.0.0-dev", path = "../../../frame/election-provider-support" }
+frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
+pallet-staking = { version = "4.0.0-dev", path = "../../../frame/staking" }
+sp-staking = { version = "4.0.0-dev", path = "../../../primitives/staking" }
+
+# third party
+chrono = { version = "0.4.19" }
+num-format = "0.4.3"
diff --git a/substrate/utils/frame/generate-bags/node-runtime/Cargo.toml b/substrate/utils/frame/generate-bags/node-runtime/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..373a31e79d51017a84a3c30695c3ae3bb06d8c0f
--- /dev/null
+++ b/substrate/utils/frame/generate-bags/node-runtime/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "node-runtime-generate-bags"
+version = "3.0.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Bag threshold generation script for pallet-bag-list and kitchensink-runtime."
+publish = false
+
+[dependencies]
+kitchensink-runtime = { version = "3.0.0-dev", path = "../../../../bin/node/runtime" }
+generate-bags = { version = "4.0.0-dev", path = "../" }
+
+# third-party
+clap = { version = "4.2.5", features = ["derive"] }
diff --git a/substrate/utils/frame/generate-bags/node-runtime/src/main.rs b/substrate/utils/frame/generate-bags/node-runtime/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..b8d233814752c69014ca232fb41fcc8d176882f7
--- /dev/null
+++ b/substrate/utils/frame/generate-bags/node-runtime/src/main.rs
@@ -0,0 +1,52 @@
+// 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.
+
+//! Make the set of bag thresholds to be used with pallet-bags-list.
+
+use clap::Parser;
+use generate_bags::generate_thresholds;
+use std::path::PathBuf;
+
+#[derive(Debug, Parser)]
+// #[clap(author, version, about)]
+struct Opt {
+	/// How many bags to generate.
+	#[arg(long, default_value_t = 200)]
+	n_bags: usize,
+
+	/// Where to write the output.
+	output: PathBuf,
+
+	/// The total issuance of the currency used to create `VoteWeight`.
+	#[arg(short, long)]
+	total_issuance: u128,
+
+	/// The minimum account balance (i.e. existential deposit) for the currency used to create
+	/// `VoteWeight`.
+	#[arg(short, long)]
+	minimum_balance: u128,
+}
+
+fn main() -> Result<(), std::io::Error> {
+	let Opt { n_bags, output, total_issuance, minimum_balance } = Opt::parse();
+	generate_thresholds::<kitchensink_runtime::Runtime>(
+		n_bags,
+		&output,
+		total_issuance,
+		minimum_balance,
+	)
+}
diff --git a/substrate/utils/frame/generate-bags/src/lib.rs b/substrate/utils/frame/generate-bags/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..923017261a44b3ce065dab99a55046ebfdcae594
--- /dev/null
+++ b/substrate/utils/frame/generate-bags/src/lib.rs
@@ -0,0 +1,262 @@
+// 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.
+
+//! Support code to ease the process of generating bag thresholds.
+//!
+//! NOTE: this assume the runtime implements [`pallet_staking::Config`], as it requires an
+//! implementation of the traits [`frame_support::traits::Currency`] and `CurrencyToVote`.
+//!
+//! The process of adding bags to a runtime requires only four steps.
+//!
+//! 1. Update the runtime definition.
+//!
+//!    ```ignore
+//!    parameter_types!{
+//!         pub const BagThresholds: &'static [u64] = &[];
+//!    }
+//!
+//!    impl pallet_bags_list::Config for Runtime {
+//!         // <snip>
+//!         type BagThresholds = BagThresholds;
+//!    }
+//!    ```
+//!
+//! 2. Write a little program to generate the definitions. This program exists only to hook together
+//! the runtime definitions with the various calculations here. Take a look at
+//! _utils/frame/generate_bags/node-runtime_ for an example.
+//!
+//! 3. Run that program:
+//!
+//!    ```sh,notrust
+//!    $ cargo run -p node-runtime-generate-bags -- --total-issuance 1234 --minimum-balance 1
+//! output.rs    ```
+//!
+//! 4. Update the runtime definition.
+//!
+//!    ```diff,notrust
+//!    + mod output;
+//!    - pub const BagThresholds: &'static [u64] = &[];
+//!    + pub const BagThresholds: &'static [u64] = &output::THRESHOLDS;
+//!    ```
+
+use frame_election_provider_support::VoteWeight;
+use frame_support::traits::Get;
+use std::{
+	io::Write,
+	path::{Path, PathBuf},
+};
+
+/// Compute the existential weight for the specified configuration.
+///
+/// Note that this value depends on the current issuance, a quantity known to change over time.
+/// This makes the project of computing a static value suitable for inclusion in a static,
+/// generated file _excitingly unstable_.
+fn existential_weight<T: pallet_staking::Config>(
+	total_issuance: u128,
+	minimum_balance: u128,
+) -> VoteWeight {
+	use sp_staking::currency_to_vote::CurrencyToVote;
+
+	T::CurrencyToVote::to_vote(
+		minimum_balance
+			.try_into()
+			.map_err(|_| "failed to convert minimum_balance to type Balance")
+			.unwrap(),
+		total_issuance
+			.try_into()
+			.map_err(|_| "failed to convert total_issuance to type Balance")
+			.unwrap(),
+	)
+}
+
+/// Return the path to a header file used in this repository if is exists.
+///
+/// Just searches the git working directory root for files matching certain patterns; it's
+/// pretty naive.
+fn path_to_header_file() -> Option<PathBuf> {
+	let mut workdir: &Path = &std::env::current_dir().ok()?;
+	while !workdir.join(".git").exists() {
+		workdir = workdir.parent()?;
+	}
+
+	for file_name in &["HEADER-APACHE2", "HEADER-GPL3", "HEADER", "file_header.txt"] {
+		let path = workdir.join(file_name);
+		if path.exists() {
+			return Some(path)
+		}
+	}
+	None
+}
+
+/// Create an underscore formatter: a formatter which inserts `_` every 3 digits of a number.
+fn underscore_formatter() -> num_format::CustomFormat {
+	num_format::CustomFormat::builder()
+		.grouping(num_format::Grouping::Standard)
+		.separator("_")
+		.build()
+		.expect("format described here meets all constraints")
+}
+
+/// Compute the constant ratio for the thresholds.
+///
+/// This ratio ensures that each bag, with the possible exceptions of certain small ones and the
+/// final one, is a constant multiple of the previous, while fully occupying the `VoteWeight`
+/// space.
+pub fn constant_ratio(existential_weight: VoteWeight, n_bags: usize) -> f64 {
+	((VoteWeight::MAX as f64 / existential_weight as f64).ln() / ((n_bags - 1) as f64)).exp()
+}
+
+/// Compute the list of bag thresholds.
+///
+/// Returns a list of exactly `n_bags` elements, except in the case of overflow.
+/// The first element is always `existential_weight`.
+/// The last element is always `VoteWeight::MAX`.
+///
+/// All other elements are computed from the previous according to the formula
+/// `threshold[k + 1] = (threshold[k] * ratio).max(threshold[k] + 1);`
+pub fn thresholds(
+	existential_weight: VoteWeight,
+	constant_ratio: f64,
+	n_bags: usize,
+) -> Vec<VoteWeight> {
+	const WEIGHT_LIMIT: f64 = VoteWeight::MAX as f64;
+
+	let mut thresholds = Vec::with_capacity(n_bags);
+
+	if n_bags > 1 {
+		thresholds.push(existential_weight);
+	}
+
+	while n_bags > 0 && thresholds.len() < n_bags - 1 {
+		let last = thresholds.last().copied().unwrap_or(existential_weight);
+		let successor = (last as f64 * constant_ratio).round().max(last as f64 + 1.0);
+		if successor < WEIGHT_LIMIT {
+			thresholds.push(successor as VoteWeight);
+		} else {
+			eprintln!("unexpectedly exceeded weight limit; breaking threshold generation loop");
+			break
+		}
+	}
+
+	thresholds.push(VoteWeight::MAX);
+
+	debug_assert_eq!(thresholds.len(), n_bags);
+	debug_assert!(n_bags == 0 || thresholds[0] == existential_weight);
+	debug_assert!(n_bags == 0 || thresholds[thresholds.len() - 1] == VoteWeight::MAX);
+
+	thresholds
+}
+
+/// Write a thresholds module to the path specified.
+///
+/// Parameters:
+/// - `n_bags` the number of bags to generate.
+/// - `output` the path to write to; should terminate with a Rust module name, i.e.
+///   `foo/bar/thresholds.rs`.
+/// - `total_issuance` the total amount of the currency in the network.
+/// - `minimum_balance` the minimum balance of the currency required for an account to exist (i.e.
+///   existential deposit).
+///
+/// This generated module contains, in order:
+///
+/// - The contents of the header file in this repository's root, if found.
+/// - Module documentation noting that this is autogenerated and when.
+/// - Some associated constants.
+/// - The constant array of thresholds.
+pub fn generate_thresholds<T: pallet_staking::Config>(
+	n_bags: usize,
+	output: &Path,
+	total_issuance: u128,
+	minimum_balance: u128,
+) -> Result<(), std::io::Error> {
+	// ensure the file is accessable
+	if let Some(parent) = output.parent() {
+		if !parent.exists() {
+			std::fs::create_dir_all(parent)?;
+		}
+	}
+
+	// copy the header file
+	if let Some(header_path) = path_to_header_file() {
+		std::fs::copy(header_path, output)?;
+	}
+
+	// open an append buffer
+	let file = std::fs::OpenOptions::new().create(true).append(true).open(output)?;
+	let mut buf = std::io::BufWriter::new(file);
+
+	// create underscore formatter and format buffer
+	let mut num_buf = num_format::Buffer::new();
+	let format = underscore_formatter();
+
+	// module docs
+	let now = chrono::Utc::now();
+	writeln!(buf)?;
+	writeln!(buf, "//! Autogenerated bag thresholds.")?;
+	writeln!(buf, "//!")?;
+	writeln!(buf, "//! Generated on {}", now.to_rfc3339())?;
+	writeln!(buf, "//! Arguments")?;
+	writeln!(buf, "//! Total issuance: {}", &total_issuance)?;
+	writeln!(buf, "//! Minimum balance: {}", &minimum_balance)?;
+
+	writeln!(
+		buf,
+		"//! for the {} runtime.",
+		<T as frame_system::Config>::Version::get().spec_name,
+	)?;
+
+	let existential_weight = existential_weight::<T>(total_issuance, minimum_balance);
+	num_buf.write_formatted(&existential_weight, &format);
+	writeln!(buf)?;
+	writeln!(buf, "/// Existential weight for this runtime.")?;
+	writeln!(buf, "#[cfg(any(test, feature = \"std\"))]")?;
+	writeln!(buf, "#[allow(unused)]")?;
+	writeln!(buf, "pub const EXISTENTIAL_WEIGHT: u64 = {};", num_buf.as_str())?;
+
+	// constant ratio
+	let constant_ratio = constant_ratio(existential_weight, n_bags);
+	writeln!(buf)?;
+	writeln!(buf, "/// Constant ratio between bags for this runtime.")?;
+	writeln!(buf, "#[cfg(any(test, feature = \"std\"))]")?;
+	writeln!(buf, "#[allow(unused)]")?;
+	writeln!(buf, "pub const CONSTANT_RATIO: f64 = {:.16};", constant_ratio)?;
+
+	// thresholds
+	let thresholds = thresholds(existential_weight, constant_ratio, n_bags);
+	writeln!(buf)?;
+	writeln!(buf, "/// Upper thresholds delimiting the bag list.")?;
+	writeln!(buf, "pub const THRESHOLDS: [u64; {}] = [", thresholds.len())?;
+	for threshold in &thresholds {
+		num_buf.write_formatted(threshold, &format);
+		// u64::MAX, with spacers every 3 digits, is 26 characters wide
+		writeln!(buf, "	{:>26},", num_buf.as_str())?;
+	}
+	writeln!(buf, "];")?;
+
+	// thresholds balance
+	writeln!(buf)?;
+	writeln!(buf, "/// Upper thresholds delimiting the bag list.")?;
+	writeln!(buf, "pub const THRESHOLDS_BALANCES: [u128; {}] = [", thresholds.len())?;
+	for threshold in thresholds {
+		num_buf.write_formatted(&threshold, &format);
+		// u64::MAX, with spacers every 3 digits, is 26 characters wide
+		writeln!(buf, "	{:>26},", num_buf.as_str())?;
+	}
+	writeln!(buf, "];")?;
+
+	Ok(())
+}
diff --git a/substrate/utils/frame/remote-externalities/Cargo.toml b/substrate/utils/frame/remote-externalities/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..75f25bf322f903910e34f993b59c7bec9eefb476
--- /dev/null
+++ b/substrate/utils/frame/remote-externalities/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "frame-remote-externalities"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "An externalities provided environment that can load itself from remote nodes or cached files"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["http-client"] }
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+log = "0.4.17"
+serde = "1.0.163"
+sp-core = { version = "21.0.0", path = "../../../primitives/core" }
+sp-state-machine = { version = "0.28.0", path = "../../../primitives/state-machine" }
+sp-io = { version = "23.0.0", path = "../../../primitives/io" }
+sp-runtime = { version = "24.0.0", path = "../../../primitives/runtime" }
+tokio = { version = "1.22.0", features = ["macros", "rt-multi-thread"] }
+substrate-rpc-client = { path = "../rpc/client" }
+futures = "0.3"
+async-recursion = "1.0.4"
+indicatif = "0.17.3"
+spinners = "4.1.0"
+tokio-retry = "0.3.0"
+
+[dev-dependencies]
+sp-tracing = { version = "10.0.0", path = "../../../primitives/tracing" }
+
+[features]
+remote-test = []
diff --git a/substrate/utils/frame/remote-externalities/src/lib.rs b/substrate/utils/frame/remote-externalities/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..072ea6ef5e5970a6fe377e742e04d623f0c34607
--- /dev/null
+++ b/substrate/utils/frame/remote-externalities/src/lib.rs
@@ -0,0 +1,1429 @@
+// 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.
+
+//! # Remote Externalities
+//!
+//! An equivalent of `sp_io::TestExternalities` that can load its state from a remote substrate
+//! based chain, or a local state snapshot file.
+
+use async_recursion::async_recursion;
+use codec::{Compact, Decode, Encode};
+use indicatif::{ProgressBar, ProgressStyle};
+use jsonrpsee::{
+	core::params::ArrayParams,
+	http_client::{HttpClient, HttpClientBuilder},
+};
+use log::*;
+use serde::de::DeserializeOwned;
+use sp_core::{
+	hashing::twox_128,
+	hexdisplay::HexDisplay,
+	storage::{
+		well_known_keys::{is_default_child_storage_key, DEFAULT_CHILD_STORAGE_KEY_PREFIX},
+		ChildInfo, ChildType, PrefixedStorageKey, StorageData, StorageKey,
+	},
+};
+use sp_runtime::{
+	traits::{Block as BlockT, HashingFor},
+	StateVersion,
+};
+use sp_state_machine::TestExternalities;
+use spinners::{Spinner, Spinners};
+use std::{
+	cmp::max,
+	fs,
+	ops::{Deref, DerefMut},
+	path::{Path, PathBuf},
+	time::{Duration, Instant},
+};
+use substrate_rpc_client::{rpc_params, BatchRequestBuilder, ChainApi, ClientT, StateApi};
+use tokio_retry::{strategy::FixedInterval, Retry};
+
+type KeyValue = (StorageKey, StorageData);
+type TopKeyValues = Vec<KeyValue>;
+type ChildKeyValues = Vec<(ChildInfo, Vec<KeyValue>)>;
+type SnapshotVersion = Compact<u16>;
+
+const LOG_TARGET: &str = "remote-ext";
+const DEFAULT_HTTP_ENDPOINT: &str = "https://rpc.polkadot.io:443";
+const SNAPSHOT_VERSION: SnapshotVersion = Compact(3);
+
+/// The snapshot that we store on disk.
+#[derive(Decode, Encode)]
+struct Snapshot<B: BlockT> {
+	snapshot_version: SnapshotVersion,
+	state_version: StateVersion,
+	block_hash: B::Hash,
+	// <Vec<Key, (Value, MemoryDbRefCount)>>
+	raw_storage: Vec<(Vec<u8>, (Vec<u8>, i32))>,
+	storage_root: B::Hash,
+}
+
+impl<B: BlockT> Snapshot<B> {
+	pub fn new(
+		state_version: StateVersion,
+		block_hash: B::Hash,
+		raw_storage: Vec<(Vec<u8>, (Vec<u8>, i32))>,
+		storage_root: B::Hash,
+	) -> Self {
+		Self {
+			snapshot_version: SNAPSHOT_VERSION,
+			state_version,
+			block_hash,
+			raw_storage,
+			storage_root,
+		}
+	}
+
+	fn load(path: &PathBuf) -> Result<Snapshot<B>, &'static str> {
+		let bytes = fs::read(path).map_err(|_| "fs::read failed.")?;
+		// The first item in the SCALE encoded struct bytes is the snapshot version. We decode and
+		// check that first, before proceeding to decode the rest of the snapshot.
+		let snapshot_version = SnapshotVersion::decode(&mut &*bytes)
+			.map_err(|_| "Failed to decode snapshot version")?;
+
+		if snapshot_version != SNAPSHOT_VERSION {
+			return Err("Unsupported snapshot version detected. Please create a new snapshot.")
+		}
+
+		Decode::decode(&mut &*bytes).map_err(|_| "Decode failed")
+	}
+}
+
+/// An externalities that acts exactly the same as [`sp_io::TestExternalities`] but has a few extra
+/// bits and pieces to it, and can be loaded remotely.
+pub struct RemoteExternalities<B: BlockT> {
+	/// The inner externalities.
+	pub inner_ext: TestExternalities<HashingFor<B>>,
+	/// The block hash it which we created this externality env.
+	pub block_hash: B::Hash,
+}
+
+impl<B: BlockT> Deref for RemoteExternalities<B> {
+	type Target = TestExternalities<HashingFor<B>>;
+	fn deref(&self) -> &Self::Target {
+		&self.inner_ext
+	}
+}
+
+impl<B: BlockT> DerefMut for RemoteExternalities<B> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.inner_ext
+	}
+}
+
+/// The execution mode.
+#[derive(Clone)]
+pub enum Mode<B: BlockT> {
+	/// Online. Potentially writes to a snapshot file.
+	Online(OnlineConfig<B>),
+	/// Offline. Uses a state snapshot file and needs not any client config.
+	Offline(OfflineConfig),
+	/// Prefer using a snapshot file if it exists, else use a remote server.
+	OfflineOrElseOnline(OfflineConfig, OnlineConfig<B>),
+}
+
+impl<B: BlockT> Default for Mode<B> {
+	fn default() -> Self {
+		Mode::Online(OnlineConfig::default())
+	}
+}
+
+/// Configuration of the offline execution.
+///
+/// A state snapshot config must be present.
+#[derive(Clone)]
+pub struct OfflineConfig {
+	/// The configuration of the state snapshot file to use. It must be present.
+	pub state_snapshot: SnapshotConfig,
+}
+
+/// Description of the transport protocol (for online execution).
+#[derive(Debug, Clone)]
+pub enum Transport {
+	/// Use the `URI` to open a new WebSocket connection.
+	Uri(String),
+	/// Use HTTP connection.
+	RemoteClient(HttpClient),
+}
+
+impl Transport {
+	fn as_client(&self) -> Option<&HttpClient> {
+		match self {
+			Self::RemoteClient(client) => Some(client),
+			_ => None,
+		}
+	}
+
+	// Build an HttpClient from a URI.
+	async fn init(&mut self) -> Result<(), &'static str> {
+		if let Self::Uri(uri) = self {
+			log::debug!(target: LOG_TARGET, "initializing remote client to {:?}", uri);
+
+			// If we have a ws uri, try to convert it to an http uri.
+			// We use an HTTP client rather than WS because WS starts to choke with "accumulated
+			// message length exceeds maximum" errors after processing ~10k keys when fetching
+			// from a node running a default configuration.
+			let uri = if uri.starts_with("ws://") {
+				let uri = uri.replace("ws://", "http://");
+				log::info!(target: LOG_TARGET, "replacing ws:// in uri with http://: {:?} (ws is currently unstable for fetching remote storage, for more see https://github.com/paritytech/jsonrpsee/issues/1086)", uri);
+				uri
+			} else if uri.starts_with("wss://") {
+				let uri = uri.replace("wss://", "https://");
+				log::info!(target: LOG_TARGET, "replacing wss:// in uri with https://: {:?} (ws is currently unstable for fetching remote storage, for more see https://github.com/paritytech/jsonrpsee/issues/1086)", uri);
+				uri
+			} else {
+				uri.clone()
+			};
+			let http_client = HttpClientBuilder::default()
+				.max_request_body_size(u32::MAX)
+				.request_timeout(std::time::Duration::from_secs(60 * 5))
+				.build(uri)
+				.map_err(|e| {
+					log::error!(target: LOG_TARGET, "error: {:?}", e);
+					"failed to build http client"
+				})?;
+
+			*self = Self::RemoteClient(http_client)
+		}
+
+		Ok(())
+	}
+}
+
+impl From<String> for Transport {
+	fn from(uri: String) -> Self {
+		Transport::Uri(uri)
+	}
+}
+
+impl From<HttpClient> for Transport {
+	fn from(client: HttpClient) -> Self {
+		Transport::RemoteClient(client)
+	}
+}
+
+/// Configuration of the online execution.
+///
+/// A state snapshot config may be present and will be written to in that case.
+#[derive(Clone)]
+pub struct OnlineConfig<B: BlockT> {
+	/// The block hash at which to get the runtime state. Will be latest finalized head if not
+	/// provided.
+	pub at: Option<B::Hash>,
+	/// An optional state snapshot file to WRITE to, not for reading. Not written if set to `None`.
+	pub state_snapshot: Option<SnapshotConfig>,
+	/// The pallets to scrape. These values are hashed and added to `hashed_prefix`.
+	pub pallets: Vec<String>,
+	/// Transport config.
+	pub transport: Transport,
+	/// Lookout for child-keys, and scrape them as well if set to true.
+	pub child_trie: bool,
+	/// Storage entry key prefixes to be injected into the externalities. The *hashed* prefix must
+	/// be given.
+	pub hashed_prefixes: Vec<Vec<u8>>,
+	/// Storage entry keys to be injected into the externalities. The *hashed* key must be given.
+	pub hashed_keys: Vec<Vec<u8>>,
+}
+
+impl<B: BlockT> OnlineConfig<B> {
+	/// Return rpc (http) client reference.
+	fn rpc_client(&self) -> &HttpClient {
+		self.transport
+			.as_client()
+			.expect("http client must have been initialized by now; qed.")
+	}
+
+	fn at_expected(&self) -> B::Hash {
+		self.at.expect("block at must be initialized; qed")
+	}
+}
+
+impl<B: BlockT> Default for OnlineConfig<B> {
+	fn default() -> Self {
+		Self {
+			transport: Transport::from(DEFAULT_HTTP_ENDPOINT.to_owned()),
+			child_trie: true,
+			at: None,
+			state_snapshot: None,
+			pallets: Default::default(),
+			hashed_keys: Default::default(),
+			hashed_prefixes: Default::default(),
+		}
+	}
+}
+
+impl<B: BlockT> From<String> for OnlineConfig<B> {
+	fn from(t: String) -> Self {
+		Self { transport: t.into(), ..Default::default() }
+	}
+}
+
+/// Configuration of the state snapshot.
+#[derive(Clone)]
+pub struct SnapshotConfig {
+	/// The path to the snapshot file.
+	pub path: PathBuf,
+}
+
+impl SnapshotConfig {
+	pub fn new<P: Into<PathBuf>>(path: P) -> Self {
+		Self { path: path.into() }
+	}
+}
+
+impl From<String> for SnapshotConfig {
+	fn from(s: String) -> Self {
+		Self::new(s)
+	}
+}
+
+impl Default for SnapshotConfig {
+	fn default() -> Self {
+		Self { path: Path::new("SNAPSHOT").into() }
+	}
+}
+
+/// Builder for remote-externalities.
+pub struct Builder<B: BlockT> {
+	/// Custom key-pairs to be injected into the final externalities. The *hashed* keys and values
+	/// must be given.
+	hashed_key_values: Vec<KeyValue>,
+	/// The keys that will be excluded from the final externality. The *hashed* key must be given.
+	hashed_blacklist: Vec<Vec<u8>>,
+	/// Connectivity mode, online or offline.
+	mode: Mode<B>,
+	/// If provided, overwrite the state version with this. Otherwise, the state_version of the
+	/// remote node is used. All cache files also store their state version.
+	///
+	/// Overwrite only with care.
+	overwrite_state_version: Option<StateVersion>,
+}
+
+impl<B: BlockT> Default for Builder<B> {
+	fn default() -> Self {
+		Self {
+			mode: Default::default(),
+			hashed_key_values: Default::default(),
+			hashed_blacklist: Default::default(),
+			overwrite_state_version: None,
+		}
+	}
+}
+
+// Mode methods
+impl<B: BlockT> Builder<B> {
+	fn as_online(&self) -> &OnlineConfig<B> {
+		match &self.mode {
+			Mode::Online(config) => config,
+			Mode::OfflineOrElseOnline(_, config) => config,
+			_ => panic!("Unexpected mode: Online"),
+		}
+	}
+
+	fn as_online_mut(&mut self) -> &mut OnlineConfig<B> {
+		match &mut self.mode {
+			Mode::Online(config) => config,
+			Mode::OfflineOrElseOnline(_, config) => config,
+			_ => panic!("Unexpected mode: Online"),
+		}
+	}
+}
+
+// RPC methods
+impl<B: BlockT> Builder<B>
+where
+	B::Hash: DeserializeOwned,
+	B::Header: DeserializeOwned,
+{
+	const PARALLEL_REQUESTS: usize = 4;
+	const BATCH_SIZE_INCREASE_FACTOR: f32 = 1.10;
+	const BATCH_SIZE_DECREASE_FACTOR: f32 = 0.50;
+	const INITIAL_BATCH_SIZE: usize = 5000;
+	// nodes by default will not return more than 1000 keys per request
+	const DEFAULT_KEY_DOWNLOAD_PAGE: u32 = 1000;
+	const KEYS_PAGE_MAX_RETRIES: usize = 12;
+	const KEYS_PAGE_RETRY_INTERVAL: Duration = Duration::from_secs(5);
+
+	async fn rpc_get_storage(
+		&self,
+		key: StorageKey,
+		maybe_at: Option<B::Hash>,
+	) -> Result<Option<StorageData>, &'static str> {
+		trace!(target: LOG_TARGET, "rpc: get_storage");
+		self.as_online().rpc_client().storage(key, maybe_at).await.map_err(|e| {
+			error!(target: LOG_TARGET, "Error = {:?}", e);
+			"rpc get_storage failed."
+		})
+	}
+
+	/// Get the latest finalized head.
+	async fn rpc_get_head(&self) -> Result<B::Hash, &'static str> {
+		trace!(target: LOG_TARGET, "rpc: finalized_head");
+
+		// sadly this pretty much unreadable...
+		ChainApi::<(), _, B::Header, ()>::finalized_head(self.as_online().rpc_client())
+			.await
+			.map_err(|e| {
+				error!(target: LOG_TARGET, "Error = {:?}", e);
+				"rpc finalized_head failed."
+			})
+	}
+
+	async fn get_keys_single_page(
+		&self,
+		prefix: Option<StorageKey>,
+		start_key: Option<StorageKey>,
+		at: B::Hash,
+	) -> Result<Vec<StorageKey>, &'static str> {
+		self.as_online()
+			.rpc_client()
+			.storage_keys_paged(prefix, Self::DEFAULT_KEY_DOWNLOAD_PAGE, start_key, Some(at))
+			.await
+			.map_err(|e| {
+				error!(target: LOG_TARGET, "Error = {:?}", e);
+				"rpc get_keys failed"
+			})
+	}
+
+	/// Get all the keys at `prefix` at `hash` using the paged, safe RPC methods.
+	async fn rpc_get_keys_paged(
+		&self,
+		prefix: StorageKey,
+		at: B::Hash,
+	) -> Result<Vec<StorageKey>, &'static str> {
+		let mut last_key: Option<StorageKey> = None;
+		let mut all_keys: Vec<StorageKey> = vec![];
+		let keys = loop {
+			// This loop can hit the node with very rapid requests, occasionally causing it to
+			// error out in CI (https://github.com/paritytech/substrate/issues/14129), so we retry.
+			let retry_strategy = FixedInterval::new(Self::KEYS_PAGE_RETRY_INTERVAL)
+				.take(Self::KEYS_PAGE_MAX_RETRIES);
+			let get_page_closure =
+				|| self.get_keys_single_page(Some(prefix.clone()), last_key.clone(), at);
+			let page = Retry::spawn(retry_strategy, get_page_closure).await?;
+			let page_len = page.len();
+
+			all_keys.extend(page);
+
+			if page_len < Self::DEFAULT_KEY_DOWNLOAD_PAGE as usize {
+				log::debug!(target: LOG_TARGET, "last page received: {}", page_len);
+				break all_keys
+			} else {
+				let new_last_key =
+					all_keys.last().expect("all_keys is populated; has .last(); qed");
+				log::debug!(
+					target: LOG_TARGET,
+					"new total = {}, full page received: {}",
+					all_keys.len(),
+					HexDisplay::from(new_last_key)
+				);
+				last_key = Some(new_last_key.clone());
+			};
+		};
+
+		Ok(keys)
+	}
+
+	/// Fetches storage data from a node using a dynamic batch size.
+	///
+	/// This function adjusts the batch size on the fly to help prevent overwhelming the node with
+	/// large batch requests, and stay within request size limits enforced by the node.
+	///
+	/// # Arguments
+	///
+	/// * `client` - An `Arc` wrapped `HttpClient` used for making the requests.
+	/// * `payloads` - A vector of tuples containing a JSONRPC method name and `ArrayParams`
+	/// * `batch_size` - The initial batch size to use for the request. The batch size will be
+	///   adjusted dynamically in case of failure.
+	///
+	/// # Returns
+	///
+	/// Returns a `Result` with a vector of `Option<StorageData>`, where each element corresponds to
+	/// the storage data for the given method and parameters. The result will be an `Err` with a
+	/// `String` error message if the request fails.
+	///
+	/// # Errors
+	///
+	/// This function will return an error if:
+	/// * The batch request fails and the batch size is less than 2.
+	/// * There are invalid batch params.
+	/// * There is an error in the batch response.
+	///
+	/// # Example
+	///
+	/// ```ignore
+	/// use your_crate::{get_storage_data_dynamic_batch_size, HttpClient, ArrayParams};
+	/// use std::sync::Arc;
+	///
+	/// async fn example() {
+	///     let client = HttpClient::new();
+	///     let payloads = vec![
+	///         ("some_method".to_string(), ArrayParams::new(vec![])),
+	///         ("another_method".to_string(), ArrayParams::new(vec![])),
+	///     ];
+	///     let initial_batch_size = 10;
+	///
+	///     let storage_data = get_storage_data_dynamic_batch_size(client, payloads, batch_size).await;
+	///     match storage_data {
+	///         Ok(data) => println!("Storage data: {:?}", data),
+	///         Err(e) => eprintln!("Error fetching storage data: {}", e),
+	///     }
+	/// }
+	/// ```
+	#[async_recursion]
+	async fn get_storage_data_dynamic_batch_size(
+		client: &HttpClient,
+		payloads: Vec<(String, ArrayParams)>,
+		batch_size: usize,
+		bar: &ProgressBar,
+	) -> Result<Vec<Option<StorageData>>, String> {
+		// All payloads have been processed
+		if payloads.is_empty() {
+			return Ok(vec![])
+		};
+
+		log::debug!(
+			target: LOG_TARGET,
+			"Remaining payloads: {} Batch request size: {}",
+			payloads.len(),
+			batch_size,
+		);
+
+		// Payloads to attempt to process this batch
+		let page = payloads.iter().take(batch_size).cloned().collect::<Vec<_>>();
+
+		// Build the batch request
+		let mut batch = BatchRequestBuilder::new();
+		for (method, params) in page.iter() {
+			batch
+				.insert(method, params.clone())
+				.map_err(|_| "Invalid batch method and/or params")?
+		}
+		let batch_response = match client.batch_request::<Option<StorageData>>(batch).await {
+			Ok(batch_response) => batch_response,
+			Err(e) => {
+				if batch_size < 2 {
+					return Err(e.to_string())
+				}
+
+				log::debug!(
+					target: LOG_TARGET,
+					"Batch request failed, trying again with smaller batch size. {}",
+					e.to_string()
+				);
+
+				return Self::get_storage_data_dynamic_batch_size(
+					client,
+					payloads,
+					max(1, (batch_size as f32 * Self::BATCH_SIZE_DECREASE_FACTOR) as usize),
+					bar,
+				)
+				.await
+			},
+		};
+
+		// Collect the data from this batch
+		let mut data: Vec<Option<StorageData>> = vec![];
+		let batch_response_len = batch_response.len();
+		for item in batch_response.into_iter() {
+			match item {
+				Ok(x) => data.push(x),
+				Err(e) => return Err(e.message().to_string()),
+			}
+		}
+		bar.inc(batch_response_len as u64);
+
+		// Return this data joined with the remaining keys
+		let remaining_payloads = payloads.iter().skip(batch_size).cloned().collect::<Vec<_>>();
+		let mut rest = Self::get_storage_data_dynamic_batch_size(
+			client,
+			remaining_payloads,
+			max(batch_size + 1, (batch_size as f32 * Self::BATCH_SIZE_INCREASE_FACTOR) as usize),
+			bar,
+		)
+		.await?;
+		data.append(&mut rest);
+		Ok(data)
+	}
+
+	/// Synonym of `getPairs` that uses paged queries to first get the keys, and then
+	/// map them to values one by one.
+	///
+	/// This can work with public nodes. But, expect it to be darn slow.
+	pub(crate) async fn rpc_get_pairs_paged(
+		&self,
+		prefix: StorageKey,
+		at: B::Hash,
+		pending_ext: &mut TestExternalities<HashingFor<B>>,
+	) -> Result<Vec<KeyValue>, &'static str> {
+		let start = Instant::now();
+		let mut sp = Spinner::with_timer(Spinners::Dots, "Scraping keys...".into());
+		let keys = self
+			.rpc_get_keys_paged(prefix.clone(), at)
+			.await?
+			.into_iter()
+			.collect::<Vec<_>>();
+		sp.stop_with_message(format!(
+			"✅ Found {} keys ({:.2}s)",
+			keys.len(),
+			start.elapsed().as_secs_f32()
+		));
+		if keys.is_empty() {
+			return Ok(Default::default())
+		}
+
+		let client = self.as_online().rpc_client();
+		let payloads = keys
+			.iter()
+			.map(|key| ("state_getStorage".to_string(), rpc_params!(key, at)))
+			.collect::<Vec<_>>();
+
+		let bar = ProgressBar::new(payloads.len() as u64);
+		bar.enable_steady_tick(Duration::from_secs(1));
+		bar.set_message("Downloading key values".to_string());
+		bar.set_style(
+			ProgressStyle::with_template(
+				"[{elapsed_precise}] {msg} {per_sec} [{wide_bar}] {pos}/{len} ({eta})",
+			)
+			.unwrap()
+			.progress_chars("=>-"),
+		);
+		let payloads_chunked = payloads.chunks((&payloads.len() / Self::PARALLEL_REQUESTS).max(1));
+		let requests = payloads_chunked.map(|payload_chunk| {
+			Self::get_storage_data_dynamic_batch_size(
+				&client,
+				payload_chunk.to_vec(),
+				Self::INITIAL_BATCH_SIZE,
+				&bar,
+			)
+		});
+		// Execute the requests and move the Result outside.
+		let storage_data_result: Result<Vec<_>, _> =
+			futures::future::join_all(requests).await.into_iter().collect();
+		// Handle the Result.
+		let storage_data = match storage_data_result {
+			Ok(storage_data) => storage_data.into_iter().flatten().collect::<Vec<_>>(),
+			Err(e) => {
+				log::error!(target: LOG_TARGET, "Error while getting storage data: {}", e);
+				return Err("Error while getting storage data")
+			},
+		};
+		bar.finish_with_message("✅ Downloaded key values");
+		print!("\n");
+
+		// Check if we got responses for all submitted requests.
+		assert_eq!(keys.len(), storage_data.len());
+
+		let key_values = keys
+			.iter()
+			.zip(storage_data)
+			.map(|(key, maybe_value)| match maybe_value {
+				Some(data) => (key.clone(), data),
+				None => {
+					log::warn!(target: LOG_TARGET, "key {:?} had none corresponding value.", &key);
+					let data = StorageData(vec![]);
+					(key.clone(), data)
+				},
+			})
+			.collect::<Vec<_>>();
+
+		let mut sp = Spinner::with_timer(Spinners::Dots, "Inserting keys into DB...".into());
+		let start = Instant::now();
+		pending_ext.batch_insert(key_values.clone().into_iter().filter_map(|(k, v)| {
+			// Don't insert the child keys here, they need to be inserted seperately with all their
+			// data in the load_child_remote function.
+			match is_default_child_storage_key(&k.0) {
+				true => None,
+				false => Some((k.0, v.0)),
+			}
+		}));
+		sp.stop_with_message(format!(
+			"✅ Inserted keys into DB ({:.2}s)",
+			start.elapsed().as_secs_f32()
+		));
+		Ok(key_values)
+	}
+
+	/// Get the values corresponding to `child_keys` at the given `prefixed_top_key`.
+	pub(crate) async fn rpc_child_get_storage_paged(
+		client: &HttpClient,
+		prefixed_top_key: &StorageKey,
+		child_keys: Vec<StorageKey>,
+		at: B::Hash,
+	) -> Result<Vec<KeyValue>, &'static str> {
+		let child_keys_len = child_keys.len();
+
+		let payloads = child_keys
+			.iter()
+			.map(|key| {
+				(
+					"childstate_getStorage".to_string(),
+					rpc_params![
+						PrefixedStorageKey::new(prefixed_top_key.as_ref().to_vec()),
+						key,
+						at
+					],
+				)
+			})
+			.collect::<Vec<_>>();
+
+		let bar = ProgressBar::new(payloads.len() as u64);
+		let storage_data = match Self::get_storage_data_dynamic_batch_size(
+			client,
+			payloads,
+			Self::INITIAL_BATCH_SIZE,
+			&bar,
+		)
+		.await
+		{
+			Ok(storage_data) => storage_data,
+			Err(e) => {
+				log::error!(target: LOG_TARGET, "batch processing failed: {:?}", e);
+				return Err("batch processing failed")
+			},
+		};
+
+		assert_eq!(child_keys_len, storage_data.len());
+
+		Ok(child_keys
+			.iter()
+			.zip(storage_data)
+			.map(|(key, maybe_value)| match maybe_value {
+				Some(v) => (key.clone(), v),
+				None => {
+					log::warn!(target: LOG_TARGET, "key {:?} had no corresponding value.", &key);
+					(key.clone(), StorageData(vec![]))
+				},
+			})
+			.collect::<Vec<_>>())
+	}
+
+	pub(crate) async fn rpc_child_get_keys(
+		client: &HttpClient,
+		prefixed_top_key: &StorageKey,
+		child_prefix: StorageKey,
+		at: B::Hash,
+	) -> Result<Vec<StorageKey>, &'static str> {
+		// This is deprecated and will generate a warning which causes the CI to fail.
+		#[allow(warnings)]
+		let child_keys = substrate_rpc_client::ChildStateApi::storage_keys(
+			client,
+			PrefixedStorageKey::new(prefixed_top_key.as_ref().to_vec()),
+			child_prefix,
+			Some(at),
+		)
+		.await
+		.map_err(|e| {
+			error!(target: LOG_TARGET, "Error = {:?}", e);
+			"rpc child_get_keys failed."
+		})?;
+
+		debug!(
+			target: LOG_TARGET,
+			"[thread = {:?}] scraped {} child-keys of the child-bearing top key: {}",
+			std::thread::current().id(),
+			child_keys.len(),
+			HexDisplay::from(prefixed_top_key)
+		);
+
+		Ok(child_keys)
+	}
+}
+
+impl<B: BlockT + DeserializeOwned> Builder<B>
+where
+	B::Hash: DeserializeOwned,
+	B::Header: DeserializeOwned,
+{
+	/// Load all of the child keys from the remote config, given the already scraped list of top key
+	/// pairs.
+	///
+	/// `top_kv` need not be only child-bearing top keys. It should be all of the top keys that are
+	/// included thus far.
+	///
+	/// This function concurrently populates `pending_ext`. the return value is only for writing to
+	/// cache, we can also optimize further.
+	async fn load_child_remote(
+		&self,
+		top_kv: &[KeyValue],
+		pending_ext: &mut TestExternalities<HashingFor<B>>,
+	) -> Result<ChildKeyValues, &'static str> {
+		let child_roots = top_kv
+			.into_iter()
+			.filter_map(|(k, _)| is_default_child_storage_key(k.as_ref()).then(|| k.clone()))
+			.collect::<Vec<_>>();
+
+		if child_roots.is_empty() {
+			info!(target: LOG_TARGET, "👩�👦 no child roots found to scrape",);
+			return Ok(Default::default())
+		}
+
+		info!(
+			target: LOG_TARGET,
+			"👩�👦 scraping child-tree data from {} top keys",
+			child_roots.len(),
+		);
+
+		let at = self.as_online().at_expected();
+
+		let client = self.as_online().rpc_client();
+		let mut child_kv = vec![];
+		for prefixed_top_key in child_roots {
+			let child_keys =
+				Self::rpc_child_get_keys(&client, &prefixed_top_key, StorageKey(vec![]), at)
+					.await?;
+
+			let child_kv_inner =
+				Self::rpc_child_get_storage_paged(&client, &prefixed_top_key, child_keys, at)
+					.await?;
+
+			let prefixed_top_key = PrefixedStorageKey::new(prefixed_top_key.clone().0);
+			let un_prefixed = match ChildType::from_prefixed_key(&prefixed_top_key) {
+				Some((ChildType::ParentKeyId, storage_key)) => storage_key,
+				None => {
+					log::error!(target: LOG_TARGET, "invalid key: {:?}", prefixed_top_key);
+					return Err("Invalid child key")
+				},
+			};
+
+			let info = ChildInfo::new_default(un_prefixed);
+			let key_values =
+				child_kv_inner.iter().cloned().map(|(k, v)| (k.0, v.0)).collect::<Vec<_>>();
+			child_kv.push((info.clone(), child_kv_inner));
+			for (k, v) in key_values {
+				pending_ext.insert_child(info.clone(), k, v);
+			}
+		}
+
+		Ok(child_kv)
+	}
+
+	/// Build `Self` from a network node denoted by `uri`.
+	///
+	/// This function concurrently populates `pending_ext`. the return value is only for writing to
+	/// cache, we can also optimize further.
+	async fn load_top_remote(
+		&self,
+		pending_ext: &mut TestExternalities<HashingFor<B>>,
+	) -> Result<TopKeyValues, &'static str> {
+		let config = self.as_online();
+		let at = self
+			.as_online()
+			.at
+			.expect("online config must be initialized by this point; qed.");
+		log::info!(target: LOG_TARGET, "scraping key-pairs from remote at block height {:?}", at);
+
+		let mut keys_and_values = Vec::new();
+		for prefix in &config.hashed_prefixes {
+			let now = std::time::Instant::now();
+			let additional_key_values =
+				self.rpc_get_pairs_paged(StorageKey(prefix.to_vec()), at, pending_ext).await?;
+			let elapsed = now.elapsed();
+			log::info!(
+				target: LOG_TARGET,
+				"adding data for hashed prefix: {:?}, took {:.2}s",
+				HexDisplay::from(prefix),
+				elapsed.as_secs_f32()
+			);
+			keys_and_values.extend(additional_key_values);
+		}
+
+		for key in &config.hashed_keys {
+			let key = StorageKey(key.to_vec());
+			log::info!(
+				target: LOG_TARGET,
+				"adding data for hashed key: {:?}",
+				HexDisplay::from(&key)
+			);
+			match self.rpc_get_storage(key.clone(), Some(at)).await? {
+				Some(value) => {
+					pending_ext.insert(key.clone().0, value.clone().0);
+					keys_and_values.push((key, value));
+				},
+				None => {
+					log::warn!(
+						target: LOG_TARGET,
+						"no data found for hashed key: {:?}",
+						HexDisplay::from(&key)
+					);
+				},
+			}
+		}
+
+		Ok(keys_and_values)
+	}
+
+	/// The entry point of execution, if `mode` is online.
+	///
+	/// initializes the remote client in `transport`, and sets the `at` field, if not specified.
+	async fn init_remote_client(&mut self) -> Result<(), &'static str> {
+		// First, initialize the http client.
+		self.as_online_mut().transport.init().await?;
+
+		// Then, if `at` is not set, set it.
+		if self.as_online().at.is_none() {
+			let at = self.rpc_get_head().await?;
+			log::info!(
+				target: LOG_TARGET,
+				"since no at is provided, setting it to latest finalized head, {:?}",
+				at
+			);
+			self.as_online_mut().at = Some(at);
+		}
+
+		// Then, a few transformation that we want to perform in the online config:
+		let online_config = self.as_online_mut();
+		online_config
+			.pallets
+			.iter()
+			.for_each(|p| online_config.hashed_prefixes.push(twox_128(p.as_bytes()).to_vec()));
+
+		if online_config.child_trie {
+			online_config.hashed_prefixes.push(DEFAULT_CHILD_STORAGE_KEY_PREFIX.to_vec());
+		}
+
+		// Finally, if by now, we have put any limitations on prefixes that we are interested in, we
+		// download everything.
+		if online_config
+			.hashed_prefixes
+			.iter()
+			.filter(|p| *p != DEFAULT_CHILD_STORAGE_KEY_PREFIX)
+			.count() == 0
+		{
+			log::info!(
+				target: LOG_TARGET,
+				"since no prefix is filtered, the data for all pallets will be downloaded"
+			);
+			online_config.hashed_prefixes.push(vec![]);
+		}
+
+		Ok(())
+	}
+
+	/// Load the data from a remote server. The main code path is calling into `load_top_remote` and
+	/// `load_child_remote`.
+	///
+	/// Must be called after `init_remote_client`.
+	async fn load_remote_and_maybe_save(
+		&mut self,
+	) -> Result<TestExternalities<HashingFor<B>>, &'static str> {
+		let state_version =
+			StateApi::<B::Hash>::runtime_version(self.as_online().rpc_client(), None)
+				.await
+				.map_err(|e| {
+					error!(target: LOG_TARGET, "Error = {:?}", e);
+					"rpc runtime_version failed."
+				})
+				.map(|v| v.state_version())?;
+		let mut pending_ext = TestExternalities::new_with_code_and_state(
+			Default::default(),
+			Default::default(),
+			self.overwrite_state_version.unwrap_or(state_version),
+		);
+
+		// Load data from the remote into `pending_ext`.
+		let top_kv = self.load_top_remote(&mut pending_ext).await?;
+		self.load_child_remote(&top_kv, &mut pending_ext).await?;
+
+		// If we need to save a snapshot, save the raw storage and root hash to the snapshot.
+		if let Some(path) = self.as_online().state_snapshot.clone().map(|c| c.path) {
+			let (raw_storage, storage_root) = pending_ext.into_raw_snapshot();
+			let snapshot = Snapshot::<B>::new(
+				state_version,
+				self.as_online()
+					.at
+					.expect("set to `Some` in `init_remote_client`; must be called before; qed"),
+				raw_storage.clone(),
+				storage_root,
+			);
+			let encoded = snapshot.encode();
+			log::info!(
+				target: LOG_TARGET,
+				"writing snapshot of {} bytes to {:?}",
+				encoded.len(),
+				path
+			);
+			std::fs::write(path, encoded).map_err(|_| "fs::write failed")?;
+
+			// pending_ext was consumed when creating the snapshot, need to reinitailize it
+			return Ok(TestExternalities::from_raw_snapshot(
+				raw_storage,
+				storage_root,
+				self.overwrite_state_version.unwrap_or(state_version),
+			))
+		}
+
+		Ok(pending_ext)
+	}
+
+	async fn do_load_remote(&mut self) -> Result<RemoteExternalities<B>, &'static str> {
+		self.init_remote_client().await?;
+		let block_hash = self.as_online().at_expected();
+		let inner_ext = self.load_remote_and_maybe_save().await?;
+		Ok(RemoteExternalities { block_hash, inner_ext })
+	}
+
+	fn do_load_offline(
+		&mut self,
+		config: OfflineConfig,
+	) -> Result<RemoteExternalities<B>, &'static str> {
+		let mut sp = Spinner::with_timer(Spinners::Dots, "Loading snapshot...".into());
+		let start = Instant::now();
+		info!(target: LOG_TARGET, "Loading snapshot from {:?}", &config.state_snapshot.path);
+		let Snapshot { snapshot_version: _, block_hash, state_version, raw_storage, storage_root } =
+			Snapshot::<B>::load(&config.state_snapshot.path)?;
+
+		let inner_ext = TestExternalities::from_raw_snapshot(
+			raw_storage,
+			storage_root,
+			self.overwrite_state_version.unwrap_or(state_version),
+		);
+		sp.stop_with_message(format!("✅ Loaded snapshot ({:.2}s)", start.elapsed().as_secs_f32()));
+
+		Ok(RemoteExternalities { inner_ext, block_hash })
+	}
+
+	pub(crate) async fn pre_build(mut self) -> Result<RemoteExternalities<B>, &'static str> {
+		let mut ext = match self.mode.clone() {
+			Mode::Offline(config) => self.do_load_offline(config)?,
+			Mode::Online(_) => self.do_load_remote().await?,
+			Mode::OfflineOrElseOnline(offline_config, _) => {
+				match self.do_load_offline(offline_config) {
+					Ok(x) => x,
+					Err(_) => self.do_load_remote().await?,
+				}
+			},
+		};
+
+		// inject manual key values.
+		if !self.hashed_key_values.is_empty() {
+			log::info!(
+				target: LOG_TARGET,
+				"extending externalities with {} manually injected key-values",
+				self.hashed_key_values.len()
+			);
+			ext.batch_insert(self.hashed_key_values.into_iter().map(|(k, v)| (k.0, v.0)));
+		}
+
+		// exclude manual key values.
+		if !self.hashed_blacklist.is_empty() {
+			log::info!(
+				target: LOG_TARGET,
+				"excluding externalities from {} keys",
+				self.hashed_blacklist.len()
+			);
+			for k in self.hashed_blacklist {
+				ext.execute_with(|| sp_io::storage::clear(&k));
+			}
+		}
+
+		Ok(ext)
+	}
+}
+
+// Public methods
+impl<B: BlockT + DeserializeOwned> Builder<B>
+where
+	B::Hash: DeserializeOwned,
+	B::Header: DeserializeOwned,
+{
+	/// Create a new builder.
+	pub fn new() -> Self {
+		Default::default()
+	}
+
+	/// Inject a manual list of key and values to the storage.
+	pub fn inject_hashed_key_value(mut self, injections: Vec<KeyValue>) -> Self {
+		for i in injections {
+			self.hashed_key_values.push(i.clone());
+		}
+		self
+	}
+
+	/// Blacklist this hashed key from the final externalities. This is treated as-is, and should be
+	/// pre-hashed.
+	pub fn blacklist_hashed_key(mut self, hashed: &[u8]) -> Self {
+		self.hashed_blacklist.push(hashed.to_vec());
+		self
+	}
+
+	/// Configure a state snapshot to be used.
+	pub fn mode(mut self, mode: Mode<B>) -> Self {
+		self.mode = mode;
+		self
+	}
+
+	/// The state version to use.
+	pub fn overwrite_state_version(mut self, version: StateVersion) -> Self {
+		self.overwrite_state_version = Some(version);
+		self
+	}
+
+	pub async fn build(self) -> Result<RemoteExternalities<B>, &'static str> {
+		let mut ext = self.pre_build().await?;
+		ext.commit_all().unwrap();
+
+		info!(
+			target: LOG_TARGET,
+			"initialized state externalities with storage root {:?} and state_version {:?}",
+			ext.as_backend().root(),
+			ext.state_version
+		);
+
+		Ok(ext)
+	}
+}
+
+#[cfg(test)]
+mod test_prelude {
+	pub(crate) use super::*;
+	pub(crate) use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper, H256 as Hash};
+	pub(crate) type Block = RawBlock<ExtrinsicWrapper<Hash>>;
+
+	pub(crate) fn init_logger() {
+		let _ = sp_tracing::try_init_simple();
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::test_prelude::*;
+
+	#[tokio::test]
+	async fn can_load_state_snapshot() {
+		init_logger();
+		Builder::<Block>::new()
+			.mode(Mode::Offline(OfflineConfig {
+				state_snapshot: SnapshotConfig::new("test_data/proxy_test"),
+			}))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+	}
+
+	#[tokio::test]
+	async fn can_exclude_from_snapshot() {
+		init_logger();
+
+		// get the first key from the snapshot file.
+		let some_key = Builder::<Block>::new()
+			.mode(Mode::Offline(OfflineConfig {
+				state_snapshot: SnapshotConfig::new("test_data/proxy_test"),
+			}))
+			.build()
+			.await
+			.expect("Can't read state snapshot file")
+			.execute_with(|| {
+				let key =
+					sp_io::storage::next_key(&[]).expect("some key must exist in the snapshot");
+				assert!(sp_io::storage::get(&key).is_some());
+				key
+			});
+
+		Builder::<Block>::new()
+			.mode(Mode::Offline(OfflineConfig {
+				state_snapshot: SnapshotConfig::new("test_data/proxy_test"),
+			}))
+			.blacklist_hashed_key(&some_key)
+			.build()
+			.await
+			.expect("Can't read state snapshot file")
+			.execute_with(|| assert!(sp_io::storage::get(&some_key).is_none()));
+	}
+}
+
+#[cfg(all(test, feature = "remote-test"))]
+mod remote_tests {
+	use super::test_prelude::*;
+	use std::os::unix::fs::MetadataExt;
+
+	#[tokio::test]
+	async fn state_version_is_kept_and_can_be_altered() {
+		const CACHE: &'static str = "state_version_is_kept_and_can_be_altered";
+		init_logger();
+
+		// first, build a snapshot.
+		let ext = Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				pallets: vec!["Proxy".to_owned()],
+				child_trie: false,
+				state_snapshot: Some(SnapshotConfig::new(CACHE)),
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap();
+
+		// now re-create the same snapshot.
+		let cached_ext = Builder::<Block>::new()
+			.mode(Mode::Offline(OfflineConfig { state_snapshot: SnapshotConfig::new(CACHE) }))
+			.build()
+			.await
+			.unwrap();
+
+		assert_eq!(ext.state_version, cached_ext.state_version);
+
+		// now overwrite it
+		let other = match ext.state_version {
+			StateVersion::V0 => StateVersion::V1,
+			StateVersion::V1 => StateVersion::V0,
+		};
+		let cached_ext = Builder::<Block>::new()
+			.mode(Mode::Offline(OfflineConfig { state_snapshot: SnapshotConfig::new(CACHE) }))
+			.overwrite_state_version(other)
+			.build()
+			.await
+			.unwrap();
+
+		assert_eq!(cached_ext.state_version, other);
+	}
+
+	#[tokio::test]
+	async fn snapshot_block_hash_works() {
+		const CACHE: &'static str = "snapshot_block_hash_works";
+		init_logger();
+
+		// first, build a snapshot.
+		let ext = Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				pallets: vec!["Proxy".to_owned()],
+				child_trie: false,
+				state_snapshot: Some(SnapshotConfig::new(CACHE)),
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap();
+
+		// now re-create the same snapshot.
+		let cached_ext = Builder::<Block>::new()
+			.mode(Mode::Offline(OfflineConfig { state_snapshot: SnapshotConfig::new(CACHE) }))
+			.build()
+			.await
+			.unwrap();
+
+		assert_eq!(ext.block_hash, cached_ext.block_hash);
+	}
+
+	#[tokio::test]
+	async fn child_keys_are_loaded() {
+		const CACHE: &'static str = "snapshot_retains_storage";
+		init_logger();
+
+		// create an ext with children keys
+		let child_ext = Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				pallets: vec!["Proxy".to_owned()],
+				child_trie: true,
+				state_snapshot: Some(SnapshotConfig::new(CACHE)),
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap();
+
+		// create an ext without children keys
+		let ext = Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				pallets: vec!["Proxy".to_owned()],
+				child_trie: false,
+				state_snapshot: Some(SnapshotConfig::new(CACHE)),
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap();
+
+		// there should be more keys in the child ext.
+		assert!(
+			child_ext.as_backend().backend_storage().keys().len() >
+				ext.as_backend().backend_storage().keys().len()
+		);
+	}
+
+	#[tokio::test]
+	async fn offline_else_online_works() {
+		const CACHE: &'static str = "offline_else_online_works_data";
+		init_logger();
+		// this shows that in the second run, we use the remote and create a snapshot.
+		Builder::<Block>::new()
+			.mode(Mode::OfflineOrElseOnline(
+				OfflineConfig { state_snapshot: SnapshotConfig::new(CACHE) },
+				OnlineConfig {
+					pallets: vec!["Proxy".to_owned()],
+					child_trie: false,
+					state_snapshot: Some(SnapshotConfig::new(CACHE)),
+					..Default::default()
+				},
+			))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+
+		// this shows that in the second run, we are not using the remote
+		Builder::<Block>::new()
+			.mode(Mode::OfflineOrElseOnline(
+				OfflineConfig { state_snapshot: SnapshotConfig::new(CACHE) },
+				OnlineConfig {
+					transport: "ws://non-existent:666".to_owned().into(),
+					..Default::default()
+				},
+			))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+
+		let to_delete = std::fs::read_dir(Path::new("."))
+			.unwrap()
+			.into_iter()
+			.map(|d| d.unwrap())
+			.filter(|p| p.path().file_name().unwrap_or_default() == CACHE)
+			.collect::<Vec<_>>();
+
+		assert!(to_delete.len() == 1);
+		std::fs::remove_file(to_delete[0].path()).unwrap();
+	}
+
+	#[tokio::test]
+	async fn can_build_one_small_pallet() {
+		init_logger();
+		Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				pallets: vec!["Proxy".to_owned()],
+				child_trie: false,
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+	}
+
+	#[tokio::test]
+	async fn can_build_few_pallet() {
+		init_logger();
+		Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				pallets: vec!["Proxy".to_owned(), "Multisig".to_owned()],
+				child_trie: false,
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+	}
+
+	#[tokio::test(flavor = "multi_thread")]
+	async fn can_create_snapshot() {
+		const CACHE: &'static str = "can_create_snapshot";
+		init_logger();
+
+		Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				state_snapshot: Some(SnapshotConfig::new(CACHE)),
+				pallets: vec!["Proxy".to_owned()],
+				child_trie: false,
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+
+		let to_delete = std::fs::read_dir(Path::new("."))
+			.unwrap()
+			.into_iter()
+			.map(|d| d.unwrap())
+			.filter(|p| p.path().file_name().unwrap_or_default() == CACHE)
+			.collect::<Vec<_>>();
+
+		assert!(to_delete.len() == 1);
+		let to_delete = to_delete.first().unwrap();
+		assert!(std::fs::metadata(to_delete.path()).unwrap().size() > 1);
+		std::fs::remove_file(to_delete.path()).unwrap();
+	}
+
+	#[tokio::test]
+	async fn can_create_child_snapshot() {
+		const CACHE: &'static str = "can_create_child_snapshot";
+		init_logger();
+		Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				state_snapshot: Some(SnapshotConfig::new(CACHE)),
+				pallets: vec!["Crowdloan".to_owned()],
+				child_trie: true,
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+
+		let to_delete = std::fs::read_dir(Path::new("."))
+			.unwrap()
+			.into_iter()
+			.map(|d| d.unwrap())
+			.filter(|p| p.path().file_name().unwrap_or_default() == CACHE)
+			.collect::<Vec<_>>();
+
+		assert!(to_delete.len() == 1);
+		let to_delete = to_delete.first().unwrap();
+		assert!(std::fs::metadata(to_delete.path()).unwrap().size() > 1);
+		std::fs::remove_file(to_delete.path()).unwrap();
+	}
+
+	#[tokio::test]
+	async fn can_build_big_pallet() {
+		if std::option_env!("TEST_WS").is_none() {
+			return
+		}
+		init_logger();
+		Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				transport: std::option_env!("TEST_WS").unwrap().to_owned().into(),
+				pallets: vec!["Staking".to_owned()],
+				child_trie: false,
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+	}
+
+	#[tokio::test]
+	async fn can_fetch_all() {
+		if std::option_env!("TEST_WS").is_none() {
+			return
+		}
+		init_logger();
+		Builder::<Block>::new()
+			.mode(Mode::Online(OnlineConfig {
+				transport: std::option_env!("TEST_WS").unwrap().to_owned().into(),
+				..Default::default()
+			}))
+			.build()
+			.await
+			.unwrap()
+			.execute_with(|| {});
+	}
+}
diff --git a/substrate/utils/frame/remote-externalities/test_data/proxy_test b/substrate/utils/frame/remote-externalities/test_data/proxy_test
new file mode 100644
index 0000000000000000000000000000000000000000..f0b1b4f5af40bc8a159c9ee250bee7849cababae
Binary files /dev/null and b/substrate/utils/frame/remote-externalities/test_data/proxy_test differ
diff --git a/substrate/utils/frame/rpc/client/Cargo.toml b/substrate/utils/frame/rpc/client/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d39fbbdf48603596035d4ba58633492c3420b433
--- /dev/null
+++ b/substrate/utils/frame/rpc/client/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "substrate-rpc-client"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Shared JSON-RPC client"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+jsonrpsee = { version = "0.16.2", features = ["ws-client"] }
+sc-rpc-api = { version = "0.10.0-dev", path = "../../../../client/rpc-api" }
+async-trait = "0.1.57"
+serde = "1"
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+log = "0.4"
+
+[dev-dependencies]
+tokio = { version = "1.22.0", features = ["macros", "rt-multi-thread", "sync"] }
+sp-core = { path = "../../../../primitives/core" }
diff --git a/substrate/utils/frame/rpc/client/src/lib.rs b/substrate/utils/frame/rpc/client/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..a6a667bef5681005c381f8cf171d6185ecf03e51
--- /dev/null
+++ b/substrate/utils/frame/rpc/client/src/lib.rs
@@ -0,0 +1,269 @@
+// 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.
+
+//! # Shared JSON-RPC client related code and abstractions.
+//!
+//! It exposes a `WebSocket JSON-RPC` client that implements the RPC interface in [`sc-rpc-api`]
+//! along with some abstractions.
+//!
+//! ## Usage
+//!
+//! ```no_run
+//! # use substrate_rpc_client::{ws_client, StateApi};
+//! # use sp_core::{H256, storage::StorageKey};
+//!
+//! #[tokio::main]
+//! async fn main() {
+//!
+//!     let client = ws_client("ws://127.0.0.1:9944").await.unwrap();
+//!     client.storage(StorageKey(vec![]), Some(H256::zero())).await.unwrap();
+//!
+//!     // if all type params are not known you need to provide type params
+//!     StateApi::<H256>::storage(&client, StorageKey(vec![]), None).await.unwrap();
+//! }
+//! ```
+
+use async_trait::async_trait;
+use serde::de::DeserializeOwned;
+use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
+use std::collections::VecDeque;
+
+pub use jsonrpsee::{
+	core::{
+		client::{ClientT, Subscription, SubscriptionClientT},
+		params::BatchRequestBuilder,
+		Error, RpcResult,
+	},
+	rpc_params,
+	ws_client::{WsClient, WsClientBuilder},
+};
+pub use sc_rpc_api::{
+	author::AuthorApiClient as AuthorApi, chain::ChainApiClient as ChainApi,
+	child_state::ChildStateApiClient as ChildStateApi, dev::DevApiClient as DevApi,
+	offchain::OffchainApiClient as OffchainApi, state::StateApiClient as StateApi,
+	system::SystemApiClient as SystemApi,
+};
+
+/// Create a new `WebSocket` connection with shared settings.
+pub async fn ws_client(uri: impl AsRef<str>) -> Result<WsClient, String> {
+	WsClientBuilder::default()
+		.max_request_body_size(u32::MAX)
+		.request_timeout(std::time::Duration::from_secs(60 * 10))
+		.connection_timeout(std::time::Duration::from_secs(60))
+		.max_notifs_per_subscription(1024)
+		.build(uri)
+		.await
+		.map_err(|e| format!("`WsClientBuilder` failed to build: {:?}", e))
+}
+
+/// Abstraction over RPC calling for headers.
+#[async_trait]
+pub trait HeaderProvider<Block: BlockT>
+where
+	Block::Header: HeaderT,
+{
+	/// Awaits for the header of the block with hash `hash`.
+	async fn get_header(&self, hash: Block::Hash) -> Block::Header;
+}
+
+#[async_trait]
+impl<Block: BlockT> HeaderProvider<Block> for WsClient
+where
+	Block::Header: DeserializeOwned,
+{
+	async fn get_header(&self, hash: Block::Hash) -> Block::Header {
+		ChainApi::<(), Block::Hash, Block::Header, ()>::header(self, Some(hash))
+			.await
+			.unwrap()
+			.unwrap()
+	}
+}
+
+/// Abstraction over RPC subscription for finalized headers.
+#[async_trait]
+pub trait HeaderSubscription<Block: BlockT>
+where
+	Block::Header: HeaderT,
+{
+	/// Await for the next finalized header from the subscription.
+	///
+	/// Returns `None` if either the subscription has been closed or there was an error when reading
+	/// an object from the client.
+	async fn next_header(&mut self) -> Option<Block::Header>;
+}
+
+#[async_trait]
+impl<Block: BlockT> HeaderSubscription<Block> for Subscription<Block::Header>
+where
+	Block::Header: DeserializeOwned,
+{
+	async fn next_header(&mut self) -> Option<Block::Header> {
+		match self.next().await {
+			Some(Ok(header)) => Some(header),
+			None => {
+				log::warn!("subscription closed");
+				None
+			},
+			Some(Err(why)) => {
+				log::warn!("subscription returned error: {:?}. Probably decoding has failed.", why);
+				None
+			},
+		}
+	}
+}
+
+/// Stream of all finalized headers.
+///
+/// Returned headers are guaranteed to be ordered. There are no missing headers (even if some of
+/// them lack justification).
+pub struct FinalizedHeaders<
+	'a,
+	Block: BlockT,
+	HP: HeaderProvider<Block>,
+	HS: HeaderSubscription<Block>,
+> {
+	header_provider: &'a HP,
+	subscription: HS,
+	fetched_headers: VecDeque<Block::Header>,
+	last_returned: Option<<Block::Header as HeaderT>::Hash>,
+}
+
+impl<'a, Block: BlockT, HP: HeaderProvider<Block>, HS: HeaderSubscription<Block>>
+	FinalizedHeaders<'a, Block, HP, HS>
+where
+	<Block as BlockT>::Header: DeserializeOwned,
+{
+	pub fn new(header_provider: &'a HP, subscription: HS) -> Self {
+		Self {
+			header_provider,
+			subscription,
+			fetched_headers: VecDeque::new(),
+			last_returned: None,
+		}
+	}
+
+	/// Reads next finalized header from the subscription. If some headers (without justification)
+	/// have been skipped, fetches them as well. Returns number of headers that have been fetched.
+	///
+	/// All fetched headers are stored in `self.fetched_headers`.
+	async fn fetch(&mut self) -> usize {
+		let last_finalized = match self.subscription.next_header().await {
+			Some(header) => header,
+			None => return 0,
+		};
+
+		self.fetched_headers.push_front(last_finalized.clone());
+
+		let mut last_finalized_parent = *last_finalized.parent_hash();
+		let last_returned = self.last_returned.unwrap_or(last_finalized_parent);
+
+		while last_finalized_parent != last_returned {
+			let parent_header = self.header_provider.get_header(last_finalized_parent).await;
+			self.fetched_headers.push_front(parent_header.clone());
+			last_finalized_parent = *parent_header.parent_hash();
+		}
+
+		self.fetched_headers.len()
+	}
+
+	/// Get the next finalized header.
+	pub async fn next(&mut self) -> Option<Block::Header> {
+		if self.fetched_headers.is_empty() {
+			self.fetch().await;
+		}
+
+		if let Some(header) = self.fetched_headers.pop_front() {
+			self.last_returned = Some(header.hash());
+			Some(header)
+		} else {
+			None
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use sp_runtime::testing::{Block as TBlock, ExtrinsicWrapper, Header, H256};
+	use std::sync::Arc;
+	use tokio::sync::Mutex;
+
+	type Block = TBlock<ExtrinsicWrapper<()>>;
+	type BlockNumber = u64;
+	type Hash = H256;
+
+	struct MockHeaderProvider(pub Arc<Mutex<VecDeque<BlockNumber>>>);
+
+	fn headers() -> Vec<Header> {
+		let mut headers = vec![Header::new_from_number(0)];
+		for n in 1..11 {
+			headers.push(Header {
+				parent_hash: headers.last().unwrap().hash(),
+				..Header::new_from_number(n)
+			})
+		}
+		headers
+	}
+
+	#[async_trait]
+	impl HeaderProvider<Block> for MockHeaderProvider {
+		async fn get_header(&self, _hash: Hash) -> Header {
+			let height = self.0.lock().await.pop_front().unwrap();
+			headers()[height as usize].clone()
+		}
+	}
+
+	struct MockHeaderSubscription(pub VecDeque<BlockNumber>);
+
+	#[async_trait]
+	impl HeaderSubscription<Block> for MockHeaderSubscription {
+		async fn next_header(&mut self) -> Option<Header> {
+			self.0.pop_front().map(|h| headers()[h as usize].clone())
+		}
+	}
+
+	#[tokio::test]
+	async fn finalized_headers_works_when_every_block_comes_from_subscription() {
+		let heights = vec![4, 5, 6, 7];
+
+		let provider = MockHeaderProvider(Default::default());
+		let subscription = MockHeaderSubscription(heights.clone().into());
+		let mut headers = FinalizedHeaders::new(&provider, subscription);
+
+		for h in heights {
+			assert_eq!(h, headers.next().await.unwrap().number);
+		}
+		assert_eq!(None, headers.next().await);
+	}
+
+	#[tokio::test]
+	async fn finalized_headers_come_from_subscription_and_provider_if_in_need() {
+		let all_heights = 3..11;
+		let heights_in_subscription = vec![3, 4, 6, 10];
+		// Consecutive headers will be requested in the reversed order.
+		let heights_not_in_subscription = vec![5, 9, 8, 7];
+
+		let provider = MockHeaderProvider(Arc::new(Mutex::new(heights_not_in_subscription.into())));
+		let subscription = MockHeaderSubscription(heights_in_subscription.into());
+		let mut headers = FinalizedHeaders::new(&provider, subscription);
+
+		for h in all_heights {
+			assert_eq!(h, headers.next().await.unwrap().number);
+		}
+		assert_eq!(None, headers.next().await);
+	}
+}
diff --git a/substrate/utils/frame/rpc/state-trie-migration-rpc/Cargo.toml b/substrate/utils/frame/rpc/state-trie-migration-rpc/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9eee52aacba76a0b4f17d699c4f2b09829a067fc
--- /dev/null
+++ b/substrate/utils/frame/rpc/state-trie-migration-rpc/Cargo.toml
@@ -0,0 +1,32 @@
+[package]
+name = "substrate-state-trie-migration-rpc"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Node-specific RPC methods for interaction with state trie migration."
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false }
+serde = { version = "1", features = ["derive"] }
+
+sp-core = { path = "../../../../primitives/core" }
+sp-state-machine = { path = "../../../../primitives/state-machine" }
+sp-trie = { path = "../../../../primitives/trie" }
+trie-db = "0.27.0"
+
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+
+# Substrate Dependencies
+sc-client-api = { version = "4.0.0-dev", path = "../../../../client/api" }
+sc-rpc-api = { version = "0.10.0-dev", path = "../../../../client/rpc-api" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+
+[dev-dependencies]
+serde_json = "1"
diff --git a/substrate/utils/frame/rpc/state-trie-migration-rpc/README.md b/substrate/utils/frame/rpc/state-trie-migration-rpc/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..03bbfdf1b59394cd205ed236d684918921893ce2
--- /dev/null
+++ b/substrate/utils/frame/rpc/state-trie-migration-rpc/README.md
@@ -0,0 +1,3 @@
+Node-specific RPC methods for interaction with trie migration.
+
+License: Apache-2.0
diff --git a/substrate/utils/frame/rpc/state-trie-migration-rpc/src/lib.rs b/substrate/utils/frame/rpc/state-trie-migration-rpc/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..d1175fdea907ad5f61a4e2515f19b62c29391910
--- /dev/null
+++ b/substrate/utils/frame/rpc/state-trie-migration-rpc/src/lib.rs
@@ -0,0 +1,177 @@
+// 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.
+
+//! Rpc for state migration.
+
+use jsonrpsee::{
+	core::{Error as JsonRpseeError, RpcResult},
+	proc_macros::rpc,
+	types::error::{CallError, ErrorCode, ErrorObject},
+};
+use sc_rpc_api::DenyUnsafe;
+use serde::{Deserialize, Serialize};
+use sp_runtime::traits::Block as BlockT;
+use std::sync::Arc;
+
+use sp_core::{
+	storage::{ChildInfo, ChildType, PrefixedStorageKey},
+	Hasher,
+};
+use sp_state_machine::backend::AsTrieBackend;
+use sp_trie::{
+	trie_types::{TrieDB, TrieDBBuilder},
+	KeySpacedDB, Trie,
+};
+use trie_db::{
+	node::{NodePlan, ValuePlan},
+	TrieDBNodeIterator,
+};
+
+fn count_migrate<'a, H: Hasher>(
+	storage: &'a dyn trie_db::HashDBRef<H, Vec<u8>>,
+	root: &'a H::Out,
+) -> std::result::Result<(u64, u64, TrieDB<'a, 'a, H>), String> {
+	let mut nb = 0u64;
+	let mut total_nb = 0u64;
+	let trie = TrieDBBuilder::new(storage, root).build();
+	let iter_node =
+		TrieDBNodeIterator::new(&trie).map_err(|e| format!("TrieDB node iterator error: {}", e))?;
+	for node in iter_node {
+		let node = node.map_err(|e| format!("TrieDB node iterator error: {}", e))?;
+		match node.2.node_plan() {
+			NodePlan::Leaf { value, .. } | NodePlan::NibbledBranch { value: Some(value), .. } => {
+				total_nb += 1;
+				if let ValuePlan::Inline(range) = value {
+					if (range.end - range.start) as u32 >=
+						sp_core::storage::TRIE_VALUE_NODE_THRESHOLD
+					{
+						nb += 1;
+					}
+				}
+			},
+			_ => (),
+		}
+	}
+	Ok((nb, total_nb, trie))
+}
+
+/// Check trie migration status.
+pub fn migration_status<H, B>(backend: &B) -> std::result::Result<MigrationStatusResult, String>
+where
+	H: Hasher,
+	H::Out: codec::Codec,
+	B: AsTrieBackend<H>,
+{
+	let trie_backend = backend.as_trie_backend();
+	let essence = trie_backend.essence();
+	let (top_remaining_to_migrate, total_top, trie) = count_migrate(essence, essence.root())?;
+
+	let mut child_remaining_to_migrate = 0;
+	let mut total_child = 0;
+	let mut child_roots: Vec<(ChildInfo, Vec<u8>)> = Vec::new();
+	// get all child trie roots
+	for key_value in trie.iter().map_err(|e| format!("TrieDB node iterator error: {}", e))? {
+		let (key, value) = key_value.map_err(|e| format!("TrieDB node iterator error: {}", e))?;
+		if key[..].starts_with(sp_core::storage::well_known_keys::DEFAULT_CHILD_STORAGE_KEY_PREFIX)
+		{
+			let prefixed_key = PrefixedStorageKey::new(key);
+			let (_type, unprefixed) = ChildType::from_prefixed_key(&prefixed_key).unwrap();
+			child_roots.push((ChildInfo::new_default(unprefixed), value));
+		}
+	}
+	for (child_info, root) in child_roots {
+		let mut child_root = H::Out::default();
+		let storage = KeySpacedDB::new(essence, child_info.keyspace());
+
+		child_root.as_mut()[..].copy_from_slice(&root[..]);
+		let (nb, total_top, _) = count_migrate(&storage, &child_root)?;
+		child_remaining_to_migrate += nb;
+		total_child += total_top;
+	}
+
+	Ok(MigrationStatusResult {
+		top_remaining_to_migrate,
+		child_remaining_to_migrate,
+		total_top,
+		total_child,
+	})
+}
+
+/// Current state migration status.
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[serde(deny_unknown_fields)]
+pub struct MigrationStatusResult {
+	/// Number of top items that should migrate.
+	pub top_remaining_to_migrate: u64,
+	/// Number of child items that should migrate.
+	pub child_remaining_to_migrate: u64,
+	/// Number of top items that we will iterate on.
+	pub total_top: u64,
+	/// Number of child items that we will iterate on.
+	pub total_child: u64,
+}
+
+/// Migration RPC methods.
+#[rpc(server)]
+pub trait StateMigrationApi<BlockHash> {
+	/// Check current migration state.
+	///
+	/// This call is performed locally without submitting any transactions. Thus executing this
+	/// won't change any state. Nonetheless it is a VERY costy call that should be
+	/// only exposed to trusted peers.
+	#[method(name = "state_trieMigrationStatus")]
+	fn call(&self, at: Option<BlockHash>) -> RpcResult<MigrationStatusResult>;
+}
+
+/// An implementation of state migration specific RPC methods.
+pub struct StateMigration<C, B, BA> {
+	client: Arc<C>,
+	backend: Arc<BA>,
+	deny_unsafe: DenyUnsafe,
+	_marker: std::marker::PhantomData<(B, BA)>,
+}
+
+impl<C, B, BA> StateMigration<C, B, BA> {
+	/// Create new state migration rpc for the given reference to the client.
+	pub fn new(client: Arc<C>, backend: Arc<BA>, deny_unsafe: DenyUnsafe) -> Self {
+		StateMigration { client, backend, deny_unsafe, _marker: Default::default() }
+	}
+}
+
+impl<C, B, BA> StateMigrationApiServer<<B as BlockT>::Hash> for StateMigration<C, B, BA>
+where
+	B: BlockT,
+	C: Send + Sync + 'static + sc_client_api::HeaderBackend<B>,
+	BA: 'static + sc_client_api::backend::Backend<B>,
+{
+	fn call(&self, at: Option<<B as BlockT>::Hash>) -> RpcResult<MigrationStatusResult> {
+		self.deny_unsafe.check_if_safe()?;
+
+		let hash = at.unwrap_or_else(|| self.client.info().best_hash);
+		let state = self.backend.state_at(hash).map_err(error_into_rpc_err)?;
+		migration_status(&state).map_err(error_into_rpc_err)
+	}
+}
+
+fn error_into_rpc_err(err: impl std::fmt::Display) -> JsonRpseeError {
+	JsonRpseeError::Call(CallError::Custom(ErrorObject::owned(
+		ErrorCode::InternalError.code(),
+		"Error while checking migration state",
+		Some(err.to_string()),
+	)))
+}
diff --git a/substrate/utils/frame/rpc/support/Cargo.toml b/substrate/utils/frame/rpc/support/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..032840d457c35aaefd60df5ef790588dad8fee55
--- /dev/null
+++ b/substrate/utils/frame/rpc/support/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "substrate-frame-rpc-support"
+version = "3.0.0"
+authors = [
+	"Parity Technologies <admin@parity.io>",
+	"Andrew Dirksen <andrew@dirksen.com>",
+]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Substrate RPC for FRAME's support"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+jsonrpsee = { version = "0.16.2", features = ["jsonrpsee-types"] }
+serde = "1"
+frame-support = { version = "4.0.0-dev", path = "../../../../frame/support" }
+sc-rpc-api = { version = "0.10.0-dev", path = "../../../../client/rpc-api" }
+sp-storage = { version = "13.0.0", path = "../../../../primitives/storage" }
+
+[dev-dependencies]
+scale-info = "2.1.1"
+jsonrpsee = { version = "0.16.2", features = ["ws-client", "jsonrpsee-types"] }
+tokio = "1.22.0"
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+frame-system = { version = "4.0.0-dev", path = "../../../../frame/system" }
diff --git a/substrate/utils/frame/rpc/support/README.md b/substrate/utils/frame/rpc/support/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca5750612931ce385a2251b86a350afca5dd97da
--- /dev/null
+++ b/substrate/utils/frame/rpc/support/README.md
@@ -0,0 +1,4 @@
+Combines [sc_rpc_api::state::StateClient] with [frame_support::storage::generator] traits
+to provide strongly typed chain state queries over rpc.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/utils/frame/rpc/support/src/lib.rs b/substrate/utils/frame/rpc/support/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..2d8e45cbfc69f009a808f13cac9ba4170dfcf2eb
--- /dev/null
+++ b/substrate/utils/frame/rpc/support/src/lib.rs
@@ -0,0 +1,184 @@
+// 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.
+
+//! Combines [sc_rpc_api::state::StateApiClient] with [frame_support::storage::generator] traits
+//! to provide strongly typed chain state queries over rpc.
+
+#![warn(missing_docs)]
+
+use codec::{DecodeAll, FullCodec, FullEncode};
+use core::marker::PhantomData;
+use frame_support::storage::generator::{StorageDoubleMap, StorageMap, StorageValue};
+use jsonrpsee::core::Error as RpcError;
+use sc_rpc_api::state::StateApiClient;
+use serde::{de::DeserializeOwned, Serialize};
+use sp_storage::{StorageData, StorageKey};
+
+/// A typed query on chain state usable from an RPC client.
+///
+/// ```no_run
+/// # use jsonrpsee::core::Error as RpcError;
+/// # use jsonrpsee::ws_client::WsClientBuilder;
+/// # use codec::Encode;
+/// # use frame_support::{construct_runtime, traits::ConstU32};
+/// # use substrate_frame_rpc_support::StorageQuery;
+/// # use sc_rpc_api::state::StateApiClient;
+/// # use sp_runtime::{traits::{BlakeTwo256, IdentityLookup}, testing::Header};
+/// #
+/// # construct_runtime!(
+/// # 	pub enum TestRuntime
+/// # 	{
+/// # 		System: frame_system::{Pallet, Call, Config<T>, Storage, Event<T>},
+/// # 		Test: pallet_test::{Pallet, Storage},
+/// # 	}
+/// # );
+/// #
+/// # type Hash = sp_core::H256;
+/// #
+/// # impl frame_system::Config for TestRuntime {
+/// # 	type BaseCallFilter = ();
+/// # 	type BlockWeights = ();
+/// # 	type BlockLength = ();
+/// # 	type RuntimeOrigin = RuntimeOrigin;
+/// # 	type RuntimeCall = RuntimeCall;
+/// # 	type Nonce = u64;
+/// # 	type Hash = Hash;
+/// # 	type Hashing = BlakeTwo256;
+/// # 	type AccountId = u64;
+/// # 	type Lookup = IdentityLookup<Self::AccountId>;
+/// # 	type Block = frame_system::mocking::MockBlock<TestRuntime>;
+/// # 	type RuntimeEvent = RuntimeEvent;
+/// # 	type BlockHashCount = ();
+/// # 	type DbWeight = ();
+/// # 	type Version = ();
+/// # 	type PalletInfo = PalletInfo;
+/// # 	type AccountData = ();
+/// # 	type OnNewAccount = ();
+/// # 	type OnKilledAccount = ();
+/// # 	type SystemWeightInfo = ();
+/// # 	type SS58Prefix = ();
+/// # 	type OnSetCode = ();
+/// # 	type MaxConsumers = ConstU32<16>;
+/// # }
+/// #
+/// # impl pallet_test::Config for TestRuntime {}
+/// #
+///
+/// pub type Loc = (i64, i64, i64);
+/// pub type Block = u8;
+///
+/// // Note that all fields are marked pub.
+/// pub use self::pallet_test::*;
+///
+/// #[frame_support::pallet]
+/// mod pallet_test {
+/// 	use super::*;
+/// 	use frame_support::pallet_prelude::*;
+///
+/// 	#[pallet::pallet]
+/// 	pub struct Pallet<T>(_);
+///
+/// 	#[pallet::config]
+/// 	pub trait Config: frame_system::Config {}
+///
+/// 	#[pallet::storage]
+/// 	pub type LastActionId<T> = StorageValue<_, u64, ValueQuery>;
+///
+/// 	#[pallet::storage]
+/// 	pub type Voxels<T> = StorageMap<_, Blake2_128Concat, Loc, Block>;
+///
+/// 	#[pallet::storage]
+/// 	pub type Actions<T> = StorageMap<_, Blake2_128Concat, u64, Loc>;
+///
+/// 	#[pallet::storage]
+/// 	pub type Prefab<T> = StorageDoubleMap<
+/// 		_,
+/// 		Blake2_128Concat, u128,
+/// 		Blake2_128Concat, (i8, i8, i8), Block
+/// 	>;
+/// }
+///
+/// #[tokio::main]
+/// async fn main() -> Result<(), RpcError> {
+///     let cl = WsClientBuilder::default().build("ws://[::1]:9944").await?;
+///
+///     let q = StorageQuery::value::<LastActionId<TestRuntime>>();
+///     let hash = None::<Hash>;
+///     let _: Option<u64> = q.get(&cl, hash).await?;
+///
+///     let q = StorageQuery::map::<Voxels<TestRuntime>, _>((0, 0, 0));
+///     let _: Option<Block> = q.get(&cl, hash).await?;
+///
+///     let q = StorageQuery::map::<Actions<TestRuntime>, _>(12);
+///     let _: Option<Loc> = q.get(&cl, hash).await?;
+///
+///     let q = StorageQuery::double_map::<Prefab<TestRuntime>, _, _>(3, (0, 0, 0));
+///     let _: Option<Block> = q.get(&cl, hash).await?;
+///
+///     Ok(())
+/// }
+/// ```
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
+pub struct StorageQuery<V> {
+	key: StorageKey,
+	_spook: PhantomData<V>,
+}
+
+impl<V: FullCodec> StorageQuery<V> {
+	/// Create a storage query for a StorageValue.
+	pub fn value<St: StorageValue<V>>() -> Self {
+		Self { key: StorageKey(St::storage_value_final_key().to_vec()), _spook: PhantomData }
+	}
+
+	/// Create a storage query for a value in a StorageMap.
+	pub fn map<St: StorageMap<K, V>, K: FullEncode>(key: K) -> Self {
+		Self { key: StorageKey(St::storage_map_final_key(key)), _spook: PhantomData }
+	}
+
+	/// Create a storage query for a value in a StorageDoubleMap.
+	pub fn double_map<St: StorageDoubleMap<K1, K2, V>, K1: FullEncode, K2: FullEncode>(
+		key1: K1,
+		key2: K2,
+	) -> Self {
+		Self { key: StorageKey(St::storage_double_map_final_key(key1, key2)), _spook: PhantomData }
+	}
+
+	/// Send this query over RPC, await the typed result.
+	///
+	/// Hash should be `<YourRuntime as frame::Config>::Hash`.
+	///
+	/// # Arguments
+	///
+	/// state_client represents a connection to the RPC server.
+	///
+	/// block_index indicates the block for which state will be queried. A value of None indicates
+	/// the latest block.
+	pub async fn get<Hash, StateClient>(
+		self,
+		state_client: &StateClient,
+		block_index: Option<Hash>,
+	) -> Result<Option<V>, RpcError>
+	where
+		Hash: Send + Sync + 'static + DeserializeOwned + Serialize,
+		StateClient: StateApiClient<Hash> + Sync,
+	{
+		let opt: Option<StorageData> = state_client.storage(self.key, block_index).await?;
+		opt.map(|encoded| V::decode_all(&mut &encoded.0[..]))
+			.transpose()
+			.map_err(|decode_err| RpcError::Custom(decode_err.to_string()))
+	}
+}
diff --git a/substrate/utils/frame/rpc/system/Cargo.toml b/substrate/utils/frame/rpc/system/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..f93f32ad64f2efc1d5e3a6211dfa3989d00b008a
--- /dev/null
+++ b/substrate/utils/frame/rpc/system/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "substrate-frame-rpc-system"
+version = "4.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "FRAME's system exposed over Substrate RPC"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+codec = { package = "parity-scale-codec", version = "3.6.1" }
+jsonrpsee = { version = "0.16.2", features = ["client-core", "server", "macros"] }
+futures = "0.3.21"
+log = "0.4.17"
+frame-system-rpc-runtime-api = { version = "4.0.0-dev", path = "../../../../frame/system/rpc/runtime-api" }
+sc-rpc-api = { version = "0.10.0-dev", path = "../../../../client/rpc-api" }
+sc-transaction-pool-api = { version = "4.0.0-dev", path = "../../../../client/transaction-pool/api" }
+sp-api = { version = "4.0.0-dev", path = "../../../../primitives/api" }
+sp-block-builder = { version = "4.0.0-dev", path = "../../../../primitives/block-builder" }
+sp-blockchain = { version = "4.0.0-dev", path = "../../../../primitives/blockchain" }
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+
+[dev-dependencies]
+sc-transaction-pool = { version = "4.0.0-dev", path = "../../../../client/transaction-pool" }
+tokio = "1.22.0"
+assert_matches = "1.3.0"
+sp-tracing = { version = "10.0.0", path = "../../../../primitives/tracing" }
+substrate-test-runtime-client = { version = "2.0.0", path = "../../../../test-utils/runtime/client" }
diff --git a/substrate/utils/frame/rpc/system/README.md b/substrate/utils/frame/rpc/system/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..38986983d93c5b3794f93c56d50840de9a4ead18
--- /dev/null
+++ b/substrate/utils/frame/rpc/system/README.md
@@ -0,0 +1,3 @@
+System FRAME specific RPC methods.
+
+License: Apache-2.0
\ No newline at end of file
diff --git a/substrate/utils/frame/rpc/system/src/lib.rs b/substrate/utils/frame/rpc/system/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1eff71e3390a38af2f1cd0d2ba417783a86ee5a2
--- /dev/null
+++ b/substrate/utils/frame/rpc/system/src/lib.rs
@@ -0,0 +1,337 @@
+// 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.
+
+//! System FRAME specific RPC methods.
+
+use std::{fmt::Display, sync::Arc};
+
+use codec::{self, Codec, Decode, Encode};
+use jsonrpsee::{
+	core::{async_trait, RpcResult},
+	proc_macros::rpc,
+	types::error::{CallError, ErrorObject},
+};
+
+use sc_rpc_api::DenyUnsafe;
+use sc_transaction_pool_api::{InPoolTransaction, TransactionPool};
+use sp_api::ApiExt;
+use sp_block_builder::BlockBuilder;
+use sp_blockchain::HeaderBackend;
+use sp_core::{hexdisplay::HexDisplay, Bytes};
+use sp_runtime::{legacy, traits};
+
+pub use frame_system_rpc_runtime_api::AccountNonceApi;
+
+/// System RPC methods.
+#[rpc(client, server)]
+pub trait SystemApi<BlockHash, AccountId, Nonce> {
+	/// Returns the next valid index (aka nonce) for given account.
+	///
+	/// This method takes into consideration all pending transactions
+	/// currently in the pool and if no transactions are found in the pool
+	/// it fallbacks to query the index from the runtime (aka. state nonce).
+	#[method(name = "system_accountNextIndex", aliases = ["account_nextIndex"])]
+	async fn nonce(&self, account: AccountId) -> RpcResult<Nonce>;
+
+	/// Dry run an extrinsic at a given block. Return SCALE encoded ApplyExtrinsicResult.
+	#[method(name = "system_dryRun", aliases = ["system_dryRunAt"])]
+	async fn dry_run(&self, extrinsic: Bytes, at: Option<BlockHash>) -> RpcResult<Bytes>;
+}
+
+/// Error type of this RPC api.
+pub enum Error {
+	/// The transaction was not decodable.
+	DecodeError,
+	/// The call to runtime failed.
+	RuntimeError,
+}
+
+impl From<Error> for i32 {
+	fn from(e: Error) -> i32 {
+		match e {
+			Error::RuntimeError => 1,
+			Error::DecodeError => 2,
+		}
+	}
+}
+
+/// An implementation of System-specific RPC methods on full client.
+pub struct System<P: TransactionPool, C, B> {
+	client: Arc<C>,
+	pool: Arc<P>,
+	deny_unsafe: DenyUnsafe,
+	_marker: std::marker::PhantomData<B>,
+}
+
+impl<P: TransactionPool, C, B> System<P, C, B> {
+	/// Create new `FullSystem` given client and transaction pool.
+	pub fn new(client: Arc<C>, pool: Arc<P>, deny_unsafe: DenyUnsafe) -> Self {
+		Self { client, pool, deny_unsafe, _marker: Default::default() }
+	}
+}
+
+#[async_trait]
+impl<P, C, Block, AccountId, Nonce>
+	SystemApiServer<<Block as traits::Block>::Hash, AccountId, Nonce> for System<P, C, Block>
+where
+	C: sp_api::ProvideRuntimeApi<Block>,
+	C: HeaderBackend<Block>,
+	C: Send + Sync + 'static,
+	C::Api: AccountNonceApi<Block, AccountId, Nonce>,
+	C::Api: BlockBuilder<Block>,
+	P: TransactionPool + 'static,
+	Block: traits::Block,
+	AccountId: Clone + Display + Codec + Send + 'static,
+	Nonce: Clone + Display + Codec + Send + traits::AtLeast32Bit + 'static,
+{
+	async fn nonce(&self, account: AccountId) -> RpcResult<Nonce> {
+		let api = self.client.runtime_api();
+		let best = self.client.info().best_hash;
+
+		let nonce = api.account_nonce(best, account.clone()).map_err(|e| {
+			CallError::Custom(ErrorObject::owned(
+				Error::RuntimeError.into(),
+				"Unable to query nonce.",
+				Some(e.to_string()),
+			))
+		})?;
+		Ok(adjust_nonce(&*self.pool, account, nonce))
+	}
+
+	async fn dry_run(
+		&self,
+		extrinsic: Bytes,
+		at: Option<<Block as traits::Block>::Hash>,
+	) -> RpcResult<Bytes> {
+		self.deny_unsafe.check_if_safe()?;
+		let api = self.client.runtime_api();
+		let best_hash = at.unwrap_or_else(||
+			// If the block hash is not supplied assume the best block.
+			self.client.info().best_hash);
+
+		let uxt: <Block as traits::Block>::Extrinsic =
+			Decode::decode(&mut &*extrinsic).map_err(|e| {
+				CallError::Custom(ErrorObject::owned(
+					Error::DecodeError.into(),
+					"Unable to dry run extrinsic",
+					Some(e.to_string()),
+				))
+			})?;
+
+		let api_version = api
+			.api_version::<dyn BlockBuilder<Block>>(best_hash)
+			.map_err(|e| {
+				CallError::Custom(ErrorObject::owned(
+					Error::RuntimeError.into(),
+					"Unable to dry run extrinsic.",
+					Some(e.to_string()),
+				))
+			})?
+			.ok_or_else(|| {
+				CallError::Custom(ErrorObject::owned(
+					Error::RuntimeError.into(),
+					"Unable to dry run extrinsic.",
+					Some(format!("Could not find `BlockBuilder` api for block `{:?}`.", best_hash)),
+				))
+			})?;
+
+		let result = if api_version < 6 {
+			#[allow(deprecated)]
+			api.apply_extrinsic_before_version_6(best_hash, uxt)
+				.map(legacy::byte_sized_error::convert_to_latest)
+				.map_err(|e| {
+					CallError::Custom(ErrorObject::owned(
+						Error::RuntimeError.into(),
+						"Unable to dry run extrinsic.",
+						Some(e.to_string()),
+					))
+				})?
+		} else {
+			api.apply_extrinsic(best_hash, uxt).map_err(|e| {
+				CallError::Custom(ErrorObject::owned(
+					Error::RuntimeError.into(),
+					"Unable to dry run extrinsic.",
+					Some(e.to_string()),
+				))
+			})?
+		};
+
+		Ok(Encode::encode(&result).into())
+	}
+}
+
+/// Adjust account nonce from state, so that tx with the nonce will be
+/// placed after all ready txpool transactions.
+fn adjust_nonce<P, AccountId, Nonce>(pool: &P, account: AccountId, nonce: Nonce) -> Nonce
+where
+	P: TransactionPool,
+	AccountId: Clone + std::fmt::Display + Encode,
+	Nonce: Clone + std::fmt::Display + Encode + traits::AtLeast32Bit + 'static,
+{
+	log::debug!(target: "rpc", "State nonce for {}: {}", account, nonce);
+	// Now we need to query the transaction pool
+	// and find transactions originating from the same sender.
+	//
+	// Since extrinsics are opaque to us, we look for them using
+	// `provides` tag. And increment the nonce if we find a transaction
+	// that matches the current one.
+	let mut current_nonce = nonce.clone();
+	let mut current_tag = (account.clone(), nonce).encode();
+	for tx in pool.ready() {
+		log::debug!(
+			target: "rpc",
+			"Current nonce to {}, checking {} vs {:?}",
+			current_nonce,
+			HexDisplay::from(&current_tag),
+			tx.provides().iter().map(|x| format!("{}", HexDisplay::from(x))).collect::<Vec<_>>(),
+		);
+		// since transactions in `ready()` need to be ordered by nonce
+		// it's fine to continue with current iterator.
+		if tx.provides().get(0) == Some(&current_tag) {
+			current_nonce += traits::One::one();
+			current_tag = (account.clone(), current_nonce.clone()).encode();
+		}
+	}
+
+	current_nonce
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	use assert_matches::assert_matches;
+	use futures::executor::block_on;
+	use jsonrpsee::{core::Error as JsonRpseeError, types::error::CallError};
+	use sc_transaction_pool::BasicPool;
+	use sp_runtime::{
+		generic::BlockId,
+		transaction_validity::{InvalidTransaction, TransactionValidityError},
+		ApplyExtrinsicResult,
+	};
+	use substrate_test_runtime_client::{runtime::Transfer, AccountKeyring};
+
+	#[tokio::test]
+	async fn should_return_next_nonce_for_some_account() {
+		sp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let pool =
+			BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
+
+		let source = sp_runtime::transaction_validity::TransactionSource::External;
+		let new_transaction = |nonce: u64| {
+			let t = Transfer {
+				from: AccountKeyring::Alice.into(),
+				to: AccountKeyring::Bob.into(),
+				amount: 5,
+				nonce,
+			};
+			t.into_unchecked_extrinsic()
+		};
+		// Populate the pool
+		let ext0 = new_transaction(0);
+		block_on(pool.submit_one(&BlockId::number(0), source, ext0)).unwrap();
+		let ext1 = new_transaction(1);
+		block_on(pool.submit_one(&BlockId::number(0), source, ext1)).unwrap();
+
+		let accounts = System::new(client, pool, DenyUnsafe::Yes);
+
+		// when
+		let nonce = accounts.nonce(AccountKeyring::Alice.into()).await;
+
+		// then
+		assert_eq!(nonce.unwrap(), 2);
+	}
+
+	#[tokio::test]
+	async fn dry_run_should_deny_unsafe() {
+		sp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let pool =
+			BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
+
+		let accounts = System::new(client, pool, DenyUnsafe::Yes);
+
+		// when
+		let res = accounts.dry_run(vec![].into(), None).await;
+		assert_matches!(res, Err(JsonRpseeError::Call(CallError::Custom(e))) => {
+			assert!(e.message().contains("RPC call is unsafe to be called externally"));
+		});
+	}
+
+	#[tokio::test]
+	async fn dry_run_should_work() {
+		sp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let pool =
+			BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
+
+		let accounts = System::new(client, pool, DenyUnsafe::No);
+
+		let tx = Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Bob.into(),
+			amount: 5,
+			nonce: 0,
+		}
+		.into_unchecked_extrinsic();
+
+		// when
+		let bytes = accounts.dry_run(tx.encode().into(), None).await.expect("Call is successful");
+
+		// then
+		let apply_res: ApplyExtrinsicResult = Decode::decode(&mut bytes.as_ref()).unwrap();
+		assert_eq!(apply_res, Ok(Ok(())));
+	}
+
+	#[tokio::test]
+	async fn dry_run_should_indicate_error() {
+		sp_tracing::try_init_simple();
+
+		// given
+		let client = Arc::new(substrate_test_runtime_client::new());
+		let spawner = sp_core::testing::TaskExecutor::new();
+		let pool =
+			BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
+
+		let accounts = System::new(client, pool, DenyUnsafe::No);
+
+		let tx = Transfer {
+			from: AccountKeyring::Alice.into(),
+			to: AccountKeyring::Bob.into(),
+			amount: 5,
+			nonce: 100,
+		}
+		.into_unchecked_extrinsic();
+
+		// when
+		let bytes = accounts.dry_run(tx.encode().into(), None).await.expect("Call is successful");
+
+		// then
+		let apply_res: ApplyExtrinsicResult = Decode::decode(&mut bytes.as_ref()).unwrap();
+		assert_eq!(apply_res, Err(TransactionValidityError::Invalid(InvalidTransaction::Future)));
+	}
+}
diff --git a/substrate/utils/frame/try-runtime/cli/Cargo.toml b/substrate/utils/frame/try-runtime/cli/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2d8d9b476a450e7a47b02086978c19da952e918b
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/Cargo.toml
@@ -0,0 +1,60 @@
+[package]
+name = "try-runtime-cli"
+version = "0.10.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+description = "Cli command runtime testing and dry-running"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+remote-externalities = { version = "0.10.0-dev", path = "../../remote-externalities", package = "frame-remote-externalities" }
+sc-cli = { version = "0.10.0-dev", path = "../../../../client/cli" }
+sc-executor = { version = "0.10.0-dev", path = "../../../../client/executor" }
+sp-consensus-aura = { path = "../../../../primitives/consensus/aura" }
+sp-consensus-babe = { path = "../../../../primitives/consensus/babe" }
+sp-core = { version = "21.0.0", path = "../../../../primitives/core" }
+sp-externalities = { version = "0.19.0", path = "../../../../primitives/externalities" }
+sp-inherents = { path = "../../../../primitives/inherents" }
+sp-io = { version = "23.0.0", path = "../../../../primitives/io" }
+sp-keystore = { version = "0.27.0", path = "../../../../primitives/keystore" }
+sp-runtime = { version = "24.0.0", path = "../../../../primitives/runtime" }
+sp-rpc = { version = "6.0.0", path = "../../../../primitives/rpc" }
+sp-state-machine = { version = "0.28.0", path = "../../../../primitives/state-machine" }
+sp-timestamp = { path = "../../../../primitives/timestamp" }
+sp-transaction-storage-proof = { path = "../../../../primitives/transaction-storage-proof" }
+sp-version = { version = "22.0.0", path = "../../../../primitives/version" }
+sp-debug-derive = { path = "../../../../primitives/debug-derive" }
+sp-api = { path = "../../../../primitives/api" }
+sp-weights = { version = "20.0.0", path = "../../../../primitives/weights" }
+frame-try-runtime = { optional = true, path = "../../../../frame/try-runtime" }
+substrate-rpc-client = { path = "../../rpc/client" }
+
+async-trait = "0.1.57"
+clap = { version = "4.2.5", features = ["derive"] }
+hex = { version = "0.4.3", default-features = false }
+log = "0.4.17"
+parity-scale-codec = "3.6.1"
+serde = "1.0.163"
+serde_json = "1.0.85"
+zstd = { version = "0.12.3", default-features = false }
+
+[dev-dependencies]
+assert_cmd = "2.0.10"
+node-primitives = { path = "../../../../bin/node/primitives" }
+regex = "1.7.3"
+substrate-cli-test-utils = { path = "../../../../test-utils/cli" }
+tempfile = "3.1.0"
+tokio = "1.27.0"
+
+[features]
+try-runtime = [
+	"frame-try-runtime/try-runtime",
+	"sp-debug-derive/force-debug",
+	"sp-runtime/try-runtime",
+	"substrate-cli-test-utils/try-runtime",
+]
diff --git a/substrate/utils/frame/try-runtime/cli/src/block_building_info.rs b/substrate/utils/frame/try-runtime/cli/src/block_building_info.rs
new file mode 100644
index 0000000000000000000000000000000000000000..db24d06ef0a157c81bc2f114b76352117a671a3a
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/block_building_info.rs
@@ -0,0 +1,152 @@
+// 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::BlockT;
+use parity_scale_codec::Encode;
+use sc_cli::Result;
+use sp_consensus_aura::{Slot, SlotDuration, AURA_ENGINE_ID};
+use sp_consensus_babe::{
+	digests::{PreDigest, SecondaryPlainPreDigest},
+	BABE_ENGINE_ID,
+};
+use sp_inherents::{InherentData, InherentDataProvider};
+use sp_runtime::{Digest, DigestItem};
+use sp_timestamp::TimestampInherentData;
+
+/// Something that can create inherent data providers and pre-runtime digest.
+///
+/// It is possible for the caller to provide custom arguments to the callee by setting the
+/// `ExtraArgs` generic parameter.
+///
+/// This module already provides some convenience implementation of this trait for closures. So, it
+/// should not be required to implement it directly.
+#[async_trait::async_trait]
+pub trait BlockBuildingInfoProvider<Block: BlockT, ExtraArgs = ()> {
+	type InherentDataProviders: InherentDataProvider;
+
+	async fn get_inherent_providers_and_pre_digest(
+		&self,
+		parent_hash: Block::Hash,
+		extra_args: ExtraArgs,
+	) -> Result<(Self::InherentDataProviders, Vec<DigestItem>)>;
+}
+
+#[async_trait::async_trait]
+impl<F, Block, IDP, ExtraArgs, Fut> BlockBuildingInfoProvider<Block, ExtraArgs> for F
+where
+	Block: BlockT,
+	F: Fn(Block::Hash, ExtraArgs) -> Fut + Sync + Send,
+	Fut: std::future::Future<Output = Result<(IDP, Vec<DigestItem>)>> + Send + 'static,
+	IDP: InherentDataProvider + 'static,
+	ExtraArgs: Send + 'static,
+{
+	type InherentDataProviders = IDP;
+
+	async fn get_inherent_providers_and_pre_digest(
+		&self,
+		parent: Block::Hash,
+		extra_args: ExtraArgs,
+	) -> Result<(Self::InherentDataProviders, Vec<DigestItem>)> {
+		(*self)(parent, extra_args).await
+	}
+}
+
+/// Provides [`BlockBuildingInfoProvider`] implementation for chains that include timestamp inherent
+/// and use Aura for a block production.
+///
+/// It depends only on the expected block production frequency, i.e. `blocktime_millis`.
+pub fn timestamp_with_aura_info<Block: BlockT>(
+	blocktime_millis: u64,
+) -> impl BlockBuildingInfoProvider<Block, Option<(InherentData, Digest)>> {
+	move |_, maybe_prev_info: Option<(InherentData, Digest)>| async move {
+		let timestamp_idp = match maybe_prev_info {
+			Some((inherent_data, _)) => sp_timestamp::InherentDataProvider::new(
+				inherent_data.timestamp_inherent_data().unwrap().unwrap() + blocktime_millis,
+			),
+			None => sp_timestamp::InherentDataProvider::from_system_time(),
+		};
+
+		let slot =
+			Slot::from_timestamp(*timestamp_idp, SlotDuration::from_millis(blocktime_millis));
+		let digest = vec![DigestItem::PreRuntime(AURA_ENGINE_ID, slot.encode())];
+
+		Ok((timestamp_idp, digest))
+	}
+}
+
+/// Provides [`BlockBuildingInfoProvider`] implementation for chains that include timestamp inherent
+/// and use Babe for a block production.
+///
+/// It depends only on the expected block production frequency, i.e. `blocktime_millis`.
+pub fn timestamp_with_babe_info<Block: BlockT>(
+	blocktime_millis: u64,
+) -> impl BlockBuildingInfoProvider<Block, Option<(InherentData, Digest)>> {
+	move |_, maybe_prev_info: Option<(InherentData, Digest)>| async move {
+		let timestamp_idp = match maybe_prev_info {
+			Some((inherent_data, _)) => sp_timestamp::InherentDataProvider::new(
+				inherent_data.timestamp_inherent_data().unwrap().unwrap() + blocktime_millis,
+			),
+			None => sp_timestamp::InherentDataProvider::from_system_time(),
+		};
+
+		let slot =
+			Slot::from_timestamp(*timestamp_idp, SlotDuration::from_millis(blocktime_millis));
+		let slot_idp = sp_consensus_babe::inherents::InherentDataProvider::new(slot);
+
+		let digest = vec![DigestItem::PreRuntime(
+			BABE_ENGINE_ID,
+			PreDigest::SecondaryPlain(SecondaryPlainPreDigest { slot, authority_index: 0 })
+				.encode(),
+		)];
+
+		Ok(((slot_idp, timestamp_idp), digest))
+	}
+}
+
+/// Provides [`BlockBuildingInfoProvider`] implementation for chains that use:
+///  - timestamp inherent,
+///  - Babe for a block production (inherent + digest),
+///  - uncles inherent,
+///  - storage proof inherent
+///
+/// It depends only on the expected block production frequency, i.e. `blocktime_millis`.
+pub fn substrate_info<Block: BlockT>(
+	blocktime_millis: u64,
+) -> impl BlockBuildingInfoProvider<Block, Option<(InherentData, Digest)>> {
+	move |_, maybe_prev_info: Option<(InherentData, Digest)>| async move {
+		let timestamp_idp = match maybe_prev_info {
+			Some((inherent_data, _)) => sp_timestamp::InherentDataProvider::new(
+				inherent_data.timestamp_inherent_data().unwrap().unwrap() + blocktime_millis,
+			),
+			None => sp_timestamp::InherentDataProvider::from_system_time(),
+		};
+
+		let slot =
+			Slot::from_timestamp(*timestamp_idp, SlotDuration::from_millis(blocktime_millis));
+		let slot_idp = sp_consensus_babe::inherents::InherentDataProvider::new(slot);
+
+		let storage_proof_idp = sp_transaction_storage_proof::InherentDataProvider::new(None);
+
+		let digest = vec![DigestItem::PreRuntime(
+			BABE_ENGINE_ID,
+			PreDigest::SecondaryPlain(SecondaryPlainPreDigest { slot, authority_index: 0 })
+				.encode(),
+		)];
+
+		Ok(((slot_idp, timestamp_idp, storage_proof_idp), digest))
+	}
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/commands/create_snapshot.rs b/substrate/utils/frame/try-runtime/cli/src/commands/create_snapshot.rs
new file mode 100644
index 0000000000000000000000000000000000000000..102336d644219aae35c84d6aa3de4838bd527ef2
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/commands/create_snapshot.rs
@@ -0,0 +1,78 @@
+// 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::{build_executor, LiveState, SharedParams, State, LOG_TARGET};
+use sc_executor::sp_wasm_interface::HostFunctions;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::{fmt::Debug, str::FromStr};
+use substrate_rpc_client::{ws_client, StateApi};
+
+/// Configurations of the [`crate::Command::CreateSnapshot`].
+#[derive(Debug, Clone, clap::Parser)]
+pub struct CreateSnapshotCmd {
+	/// The source of the snapshot. Must be a remote node.
+	#[clap(flatten)]
+	pub from: LiveState,
+
+	/// The snapshot path to write to.
+	///
+	/// If not provided `<spec-name>-<spec-version>@<block-hash>.snap` will be used.
+	pub snapshot_path: Option<String>,
+}
+
+/// inner command for `Command::CreateSnapshot`.
+pub(crate) async fn create_snapshot<Block, HostFns>(
+	shared: SharedParams,
+	command: CreateSnapshotCmd,
+) -> sc_cli::Result<()>
+where
+	Block: BlockT + serde::de::DeserializeOwned,
+	Block::Hash: serde::de::DeserializeOwned,
+	Block::Header: serde::de::DeserializeOwned,
+	<Block::Hash as FromStr>::Err: Debug,
+	NumberFor<Block>: FromStr,
+	<NumberFor<Block> as FromStr>::Err: Debug,
+	HostFns: HostFunctions,
+{
+	let snapshot_path = command.snapshot_path;
+	if !matches!(shared.runtime, crate::Runtime::Existing) {
+		return Err("creating a snapshot is only possible with --runtime existing.".into())
+	}
+
+	let path = match snapshot_path {
+		Some(path) => path,
+		None => {
+			let rpc = ws_client(&command.from.uri).await.unwrap();
+			let remote_spec = StateApi::<Block::Hash>::runtime_version(&rpc, None).await.unwrap();
+			let path_str = format!(
+				"{}-{}@{}.snap",
+				remote_spec.spec_name.to_lowercase(),
+				remote_spec.spec_version,
+				command.from.at.clone().unwrap_or("latest".to_owned())
+			);
+			log::info!(target: LOG_TARGET, "snapshot path not provided (-s), using '{}'", path_str);
+			path_str.into()
+		},
+	};
+
+	let executor = build_executor::<HostFns>(&shared);
+	let _ = State::Live(command.from)
+		.into_ext::<Block, HostFns>(&shared, &executor, Some(path.into()), false)
+		.await?;
+
+	Ok(())
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/commands/execute_block.rs b/substrate/utils/frame/try-runtime/cli/src/commands/execute_block.rs
new file mode 100644
index 0000000000000000000000000000000000000000..1f1b6ec7d9b910feab8591afa8358d1cfbfef811
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/commands/execute_block.rs
@@ -0,0 +1,170 @@
+// 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::{
+	build_executor, full_extensions, rpc_err_handler, state_machine_call_with_proof, LiveState,
+	SharedParams, State, LOG_TARGET,
+};
+use parity_scale_codec::Encode;
+use sc_executor::sp_wasm_interface::HostFunctions;
+use sp_rpc::{list::ListOrValue, number::NumberOrHex};
+use sp_runtime::{
+	generic::SignedBlock,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor},
+};
+use std::{fmt::Debug, str::FromStr};
+use substrate_rpc_client::{ws_client, ChainApi};
+
+/// Configurations of the [`crate::Command::ExecuteBlock`].
+///
+/// This will always call into `TryRuntime_execute_block`, which can optionally skip the state-root
+/// check (useful for trying a unreleased runtime), and can execute runtime sanity checks as well.
+#[derive(Debug, Clone, clap::Parser)]
+pub struct ExecuteBlockCmd {
+	/// Which try-state targets to execute when running this command.
+	///
+	/// Expected values:
+	/// - `all`
+	/// - `none`
+	/// - A comma separated list of pallets, as per pallet names in `construct_runtime!()` (e.g.
+	///   `Staking, System`).
+	/// - `rr-[x]` where `[x]` is a number. Then, the given number of pallets are checked in a
+	///   round-robin fashion.
+	#[arg(long, default_value = "all")]
+	pub try_state: frame_try_runtime::TryStateSelect,
+
+	/// The ws uri from which to fetch the block.
+	///
+	/// This will always fetch the next block of whatever `state` is referring to, because this is
+	/// the only sensible combination. In other words, if you have the state of block `n`, you
+	/// should execute block `n+1` on top of it.
+	///
+	/// If `state` is `Live`, this can be ignored and the same uri is used for both.
+	#[arg(
+		long,
+		value_parser = crate::parse::url
+	)]
+	pub block_ws_uri: Option<String>,
+
+	/// The state type to use.
+	#[command(subcommand)]
+	pub state: State,
+}
+
+impl ExecuteBlockCmd {
+	fn block_ws_uri<Block: BlockT>(&self) -> String
+	where
+		<Block::Hash as FromStr>::Err: Debug,
+	{
+		match (&self.block_ws_uri, &self.state) {
+			(Some(block_ws_uri), State::Snap { .. }) => block_ws_uri.to_owned(),
+			(Some(block_ws_uri), State::Live { .. }) => {
+				log::error!(target: LOG_TARGET, "--block-uri is provided while state type is live, Are you sure you know what you are doing?");
+				block_ws_uri.to_owned()
+			},
+			(None, State::Live(LiveState { uri, .. })) => uri.clone(),
+			(None, State::Snap { .. }) => {
+				panic!("either `--block-uri` must be provided, or state must be `live`");
+			},
+		}
+	}
+}
+
+pub(crate) async fn execute_block<Block, HostFns>(
+	shared: SharedParams,
+	command: ExecuteBlockCmd,
+) -> sc_cli::Result<()>
+where
+	Block: BlockT + serde::de::DeserializeOwned,
+	<Block::Hash as FromStr>::Err: Debug,
+	Block::Hash: serde::de::DeserializeOwned,
+	Block::Header: serde::de::DeserializeOwned,
+	<NumberFor<Block> as TryInto<u64>>::Error: Debug,
+	HostFns: HostFunctions,
+{
+	let executor = build_executor::<HostFns>(&shared);
+	let ext = command.state.into_ext::<Block, HostFns>(&shared, &executor, None, true).await?;
+
+	// get the block number associated with this block.
+	let block_ws_uri = command.block_ws_uri::<Block>();
+	let rpc = ws_client(&block_ws_uri).await?;
+	let next_hash = next_hash_of::<Block>(&rpc, ext.block_hash).await?;
+
+	log::info!(target: LOG_TARGET, "fetching next block: {:?} ", next_hash);
+
+	let block = ChainApi::<(), Block::Hash, Block::Header, SignedBlock<Block>>::block(
+		&rpc,
+		Some(next_hash),
+	)
+	.await
+	.map_err(rpc_err_handler)?
+	.expect("header exists, block should also exist; qed")
+	.block;
+
+	// A digest item gets added when the runtime is processing the block, so we need to pop
+	// the last one to be consistent with what a gossiped block would contain.
+	let (mut header, extrinsics) = block.deconstruct();
+	header.digest_mut().pop();
+	let block = Block::new(header, extrinsics);
+
+	// for now, hardcoded for the sake of simplicity. We might customize them one day.
+	let state_root_check = false;
+	let signature_check = false;
+	let payload = (block.clone(), state_root_check, signature_check, command.try_state).encode();
+
+	let _ = state_machine_call_with_proof::<Block, HostFns>(
+		&ext,
+		&executor,
+		"TryRuntime_execute_block",
+		&payload,
+		full_extensions(executor.clone()),
+		shared.export_proof,
+	)?;
+
+	Ok(())
+}
+
+pub(crate) async fn next_hash_of<Block: BlockT>(
+	rpc: &substrate_rpc_client::WsClient,
+	hash: Block::Hash,
+) -> sc_cli::Result<Block::Hash>
+where
+	Block: BlockT + serde::de::DeserializeOwned,
+	Block::Header: serde::de::DeserializeOwned,
+{
+	let number = ChainApi::<(), Block::Hash, Block::Header, ()>::header(rpc, Some(hash))
+		.await
+		.map_err(rpc_err_handler)
+		.and_then(|maybe_header| maybe_header.ok_or("header_not_found").map(|h| *h.number()))?;
+
+	let next = number + sp_runtime::traits::One::one();
+
+	let next_hash = match ChainApi::<(), Block::Hash, Block::Header, ()>::block_hash(
+		rpc,
+		Some(ListOrValue::Value(NumberOrHex::Number(
+			next.try_into().map_err(|_| "failed to convert number to block number")?,
+		))),
+	)
+	.await
+	.map_err(rpc_err_handler)?
+	{
+		ListOrValue::Value(t) => t.expect("value passed in; value comes out; qed"),
+		_ => unreachable!(),
+	};
+
+	Ok(next_hash)
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/commands/fast_forward.rs b/substrate/utils/frame/try-runtime/cli/src/commands/fast_forward.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f1dee16debe7339edc4f3cc1ba01829f2fbacc99
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/commands/fast_forward.rs
@@ -0,0 +1,262 @@
+// 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::{
+	block_building_info::BlockBuildingInfoProvider, build_executor, full_extensions,
+	rpc_err_handler, state_machine_call, BlockT, LiveState, SharedParams, State,
+};
+use parity_scale_codec::{Decode, Encode};
+use sc_cli::Result;
+use sc_executor::{sp_wasm_interface::HostFunctions, WasmExecutor};
+use serde::de::DeserializeOwned;
+use sp_core::H256;
+use sp_inherents::{InherentData, InherentDataProvider};
+use sp_runtime::{
+	traits::{HashingFor, Header, NumberFor, One},
+	Digest,
+};
+use sp_state_machine::TestExternalities;
+use std::{fmt::Debug, str::FromStr};
+use substrate_rpc_client::{ws_client, ChainApi};
+
+/// Configurations of the [`crate::Command::FastForward`].
+#[derive(Debug, Clone, clap::Parser)]
+pub struct FastForwardCmd {
+	/// How many blocks should be processed. If `None`, then blocks will be produced and processed
+	/// in a loop.
+	#[arg(long)]
+	n_blocks: Option<u64>,
+
+	/// The state type to use.
+	#[command(subcommand)]
+	state: State,
+
+	/// The ws uri from which to fetch the block.
+	///
+	/// If `state` is `Live`, this is ignored. Otherwise, it must not be empty.
+	#[arg(long, value_parser = crate::parse::url)]
+	block_ws_uri: Option<String>,
+
+	/// Which try-state targets to execute when running this command.
+	///
+	/// Expected values:
+	/// - `all`
+	/// - `none`
+	/// - A comma separated list of pallets, as per pallet names in `construct_runtime!()` (e.g.
+	///   `Staking, System`).
+	/// - `rr-[x]` where `[x]` is a number. Then, the given number of pallets are checked in a
+	///   round-robin fashion.
+	#[arg(long, default_value = "all")]
+	try_state: frame_try_runtime::TryStateSelect,
+}
+
+impl FastForwardCmd {
+	fn block_ws_uri(&self) -> &str {
+		match self.state {
+			State::Live(LiveState { ref uri, .. }) => &uri,
+			_ => self
+				.block_ws_uri
+				.as_ref()
+				.expect("Either `--block-uri` must be provided, or state must be `live`"),
+		}
+	}
+}
+
+/// Read the block number corresponding to `hash` with an RPC call to `ws_uri`.
+async fn get_block_number<Block: BlockT>(
+	hash: Block::Hash,
+	ws_uri: &str,
+) -> Result<NumberFor<Block>>
+where
+	Block::Header: DeserializeOwned,
+{
+	let rpc = ws_client(ws_uri).await?;
+	Ok(ChainApi::<(), Block::Hash, Block::Header, ()>::header(&rpc, Some(hash))
+		.await
+		.map_err(rpc_err_handler)
+		.and_then(|maybe_header| maybe_header.ok_or("header_not_found").map(|h| *h.number()))?)
+}
+
+/// Call `method` with `data` and return the result. `externalities` will not change.
+fn dry_run<T: Decode, Block: BlockT, HostFns: HostFunctions>(
+	externalities: &TestExternalities<HashingFor<Block>>,
+	executor: &WasmExecutor<HostFns>,
+	method: &'static str,
+	data: &[u8],
+) -> Result<T> {
+	let (_, result) = state_machine_call::<Block, HostFns>(
+		externalities,
+		executor,
+		method,
+		data,
+		full_extensions(executor.clone()),
+	)?;
+
+	Ok(<T>::decode(&mut &*result)?)
+}
+
+/// Call `method` with `data` and actually save storage changes to `externalities`.
+async fn run<Block: BlockT, HostFns: HostFunctions>(
+	externalities: &mut TestExternalities<HashingFor<Block>>,
+	executor: &WasmExecutor<HostFns>,
+	method: &'static str,
+	data: &[u8],
+) -> Result<()> {
+	let (mut changes, _) = state_machine_call::<Block, HostFns>(
+		externalities,
+		executor,
+		method,
+		data,
+		full_extensions(executor.clone()),
+	)?;
+
+	let storage_changes =
+		changes.drain_storage_changes(&externalities.backend, externalities.state_version)?;
+
+	externalities
+		.backend
+		.apply_transaction(storage_changes.transaction_storage_root, storage_changes.transaction);
+
+	Ok(())
+}
+
+/// Produce next empty block.
+async fn next_empty_block<
+	Block: BlockT,
+	HostFns: HostFunctions,
+	BBIP: BlockBuildingInfoProvider<Block, Option<(InherentData, Digest)>>,
+>(
+	externalities: &mut TestExternalities<HashingFor<Block>>,
+	executor: &WasmExecutor<HostFns>,
+	parent_height: NumberFor<Block>,
+	parent_hash: Block::Hash,
+	block_building_info_provider: &Option<BBIP>,
+	previous_block_building_info: Option<(InherentData, Digest)>,
+) -> Result<(Block, Option<(InherentData, Digest)>)> {
+	let (maybe_inherent_data, pre_digest) = match &block_building_info_provider {
+		None => (None, Default::default()),
+		Some(bbip) => {
+			let (inherent_data_provider, pre_digest) = bbip
+				.get_inherent_providers_and_pre_digest(parent_hash, previous_block_building_info)
+				.await?;
+			let inherent_data = inherent_data_provider
+				.create_inherent_data()
+				.await
+				.map_err(|e| sc_cli::Error::Input(format!("I don't know how to convert {e:?}")))?;
+
+			(Some(inherent_data), Digest { logs: pre_digest })
+		},
+	};
+
+	let header = Block::Header::new(
+		parent_height + One::one(),
+		Default::default(),
+		Default::default(),
+		parent_hash,
+		pre_digest.clone(),
+	);
+	let mut extrinsics = <Vec<Block::Extrinsic>>::new();
+
+	run::<Block, _>(externalities, executor, "Core_initialize_block", &header.encode()).await?;
+
+	if let Some(ref inherent_data) = maybe_inherent_data {
+		extrinsics = dry_run::<Vec<Block::Extrinsic>, Block, _>(
+			externalities,
+			executor,
+			"BlockBuilder_inherent_extrinsics",
+			&inherent_data.encode(),
+		)?;
+	}
+
+	for xt in &extrinsics {
+		run::<Block, _>(externalities, executor, "BlockBuilder_apply_extrinsic", &xt.encode())
+			.await?;
+	}
+
+	let header = dry_run::<Block::Header, Block, _>(
+		externalities,
+		executor,
+		"BlockBuilder_finalize_block",
+		&[0u8; 0],
+	)?;
+
+	run::<Block, _>(externalities, executor, "BlockBuilder_finalize_block", &[0u8; 0]).await?;
+
+	Ok((Block::new(header, extrinsics), (maybe_inherent_data.map(|id| (id, pre_digest)))))
+}
+
+pub(crate) async fn fast_forward<Block, HostFns, BBIP>(
+	shared: SharedParams,
+	command: FastForwardCmd,
+	block_building_info_provider: Option<BBIP>,
+) -> Result<()>
+where
+	Block: BlockT<Hash = H256> + DeserializeOwned,
+	Block::Header: DeserializeOwned,
+	<Block::Hash as FromStr>::Err: Debug,
+	NumberFor<Block>: FromStr,
+	<NumberFor<Block> as FromStr>::Err: Debug,
+	HostFns: HostFunctions,
+	BBIP: BlockBuildingInfoProvider<Block, Option<(InherentData, Digest)>>,
+{
+	let executor = build_executor::<HostFns>(&shared);
+	let ext = command.state.into_ext::<Block, HostFns>(&shared, &executor, None, true).await?;
+
+	let mut last_block_hash = ext.block_hash;
+	let mut last_block_number =
+		get_block_number::<Block>(last_block_hash, command.block_ws_uri()).await?;
+	let mut prev_block_building_info = None;
+
+	let mut ext = ext.inner_ext;
+
+	for _ in 1..=command.n_blocks.unwrap_or(u64::MAX) {
+		// We are saving state before we overwrite it while producing new block.
+		let backend = ext.as_backend();
+
+		log::info!("Producing new empty block at height {:?}", last_block_number + One::one());
+
+		let (next_block, new_block_building_info) = next_empty_block::<Block, HostFns, BBIP>(
+			&mut ext,
+			&executor,
+			last_block_number,
+			last_block_hash,
+			&block_building_info_provider,
+			prev_block_building_info,
+		)
+		.await?;
+
+		log::info!("Produced a new block: {:?}", next_block.header());
+
+		// And now we restore previous state.
+		ext.backend = backend;
+
+		let state_root_check = true;
+		let signature_check = true;
+		let payload =
+			(next_block.clone(), state_root_check, signature_check, command.try_state.clone())
+				.encode();
+		run::<Block, _>(&mut ext, &executor, "TryRuntime_execute_block", &payload).await?;
+
+		log::info!("Executed the new block");
+
+		prev_block_building_info = new_block_building_info;
+		last_block_hash = next_block.hash();
+		last_block_number += One::one();
+	}
+
+	Ok(())
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/commands/follow_chain.rs b/substrate/utils/frame/try-runtime/cli/src/commands/follow_chain.rs
new file mode 100644
index 0000000000000000000000000000000000000000..53db5e64346326944554b82dcb572f3fe0299e7c
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/commands/follow_chain.rs
@@ -0,0 +1,203 @@
+// 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::{
+	build_executor, full_extensions, parse, rpc_err_handler, state_machine_call_with_proof,
+	LiveState, SharedParams, State, LOG_TARGET,
+};
+use parity_scale_codec::{Decode, Encode};
+use sc_executor::sp_wasm_interface::HostFunctions;
+use serde::{de::DeserializeOwned, Serialize};
+use sp_core::H256;
+use sp_runtime::{
+	generic::SignedBlock,
+	traits::{Block as BlockT, Header as HeaderT, NumberFor},
+};
+use std::{fmt::Debug, str::FromStr};
+use substrate_rpc_client::{ws_client, ChainApi, FinalizedHeaders, Subscription, WsClient};
+
+const SUB: &str = "chain_subscribeFinalizedHeads";
+const UN_SUB: &str = "chain_unsubscribeFinalizedHeads";
+
+/// Configurations of the [`crate::Command::FollowChain`].
+#[derive(Debug, Clone, clap::Parser)]
+pub struct FollowChainCmd {
+	/// The url to connect to.
+	#[arg(short, long, value_parser = parse::url)]
+	pub uri: String,
+
+	/// If set, then the state root check is enabled.
+	#[arg(long)]
+	pub state_root_check: bool,
+
+	/// Which try-state targets to execute when running this command.
+	///
+	/// Expected values:
+	/// - `all`
+	/// - `none`
+	/// - A comma separated list of pallets, as per pallet names in `construct_runtime!()` (e.g.
+	///   `Staking, System`).
+	/// - `rr-[x]` where `[x]` is a number. Then, the given number of pallets are checked in a
+	///   round-robin fashion.
+	#[arg(long, default_value = "all")]
+	pub try_state: frame_try_runtime::TryStateSelect,
+
+	/// If present, a single connection to a node will be kept and reused for fetching blocks.
+	#[arg(long)]
+	pub keep_connection: bool,
+}
+
+/// Start listening for with `SUB` at `url`.
+///
+/// Returns a pair `(client, subscription)` - `subscription` alone will be useless, because it
+/// relies on the related alive `client`.
+async fn start_subscribing<Header: DeserializeOwned + Serialize + Send + Sync + 'static>(
+	url: &str,
+) -> sc_cli::Result<(WsClient, Subscription<Header>)> {
+	let client = ws_client(url).await.map_err(|e| sc_cli::Error::Application(e.into()))?;
+
+	log::info!(target: LOG_TARGET, "subscribing to {:?} / {:?}", SUB, UN_SUB);
+
+	let sub = ChainApi::<(), (), Header, ()>::subscribe_finalized_heads(&client)
+		.await
+		.map_err(|e| sc_cli::Error::Application(e.into()))?;
+	Ok((client, sub))
+}
+
+pub(crate) async fn follow_chain<Block, HostFns>(
+	shared: SharedParams,
+	command: FollowChainCmd,
+) -> sc_cli::Result<()>
+where
+	Block: BlockT<Hash = H256> + DeserializeOwned,
+	Block::Header: DeserializeOwned,
+	<Block::Hash as FromStr>::Err: Debug,
+	NumberFor<Block>: FromStr,
+	<NumberFor<Block> as FromStr>::Err: Debug,
+	HostFns: HostFunctions,
+{
+	let (rpc, subscription) = start_subscribing::<Block::Header>(&command.uri).await?;
+	let mut finalized_headers: FinalizedHeaders<Block, _, _> =
+		FinalizedHeaders::new(&rpc, subscription);
+
+	let mut maybe_state_ext = None;
+	let executor = build_executor::<HostFns>(&shared);
+
+	while let Some(header) = finalized_headers.next().await {
+		let hash = header.hash();
+		let number = header.number();
+
+		let block =
+			ChainApi::<(), Block::Hash, Block::Header, SignedBlock<Block>>::block(&rpc, Some(hash))
+				.await
+				.or_else(|e| {
+					if matches!(e, substrate_rpc_client::Error::ParseError(_)) {
+						log::error!(
+							target: LOG_TARGET,
+							"failed to parse the block format of remote against the local \
+							codebase. The block format has changed, and follow-chain cannot run in \
+							this case. Try running this command in a branch of your codebase that
+							has the same block format as the remote chain. For now, we replace the \
+							block with an empty one."
+						);
+					}
+					Err(rpc_err_handler(e))
+				})?
+				.expect("if header exists, block should also exist.")
+				.block;
+
+		log::debug!(
+			target: LOG_TARGET,
+			"new block event: {:?} => {:?}, extrinsics: {}",
+			hash,
+			number,
+			block.extrinsics().len()
+		);
+
+		// create an ext at the state of this block, whatever is the first subscription event.
+		if maybe_state_ext.is_none() {
+			let state = State::Live(LiveState {
+				uri: command.uri.clone(),
+				// a bit dodgy, we have to un-parse the has to a string again and re-parse it
+				// inside.
+				at: Some(hex::encode(header.parent_hash().encode())),
+				pallet: vec![],
+				child_tree: true,
+			});
+			let ext = state.into_ext::<Block, HostFns>(&shared, &executor, None, true).await?;
+			maybe_state_ext = Some(ext);
+		}
+
+		let state_ext =
+			maybe_state_ext.as_mut().expect("state_ext either existed or was just created");
+
+		let result = state_machine_call_with_proof::<Block, HostFns>(
+			state_ext,
+			&executor,
+			"TryRuntime_execute_block",
+			(block, command.state_root_check, true, command.try_state.clone())
+				.encode()
+				.as_ref(),
+			full_extensions(executor.clone()),
+			shared
+				.export_proof
+				.as_ref()
+				.map(|path| path.as_path().join(&format!("{}.json", number))),
+		);
+
+		if let Err(why) = result {
+			log::error!(
+				target: LOG_TARGET,
+				"failed to execute block {:?} due to {:?}",
+				number,
+				why
+			);
+			continue
+		}
+
+		let (mut changes, encoded_result) = result.expect("checked to be Ok; qed");
+
+		let consumed_weight = <sp_weights::Weight as Decode>::decode(&mut &*encoded_result)
+			.map_err(|e| format!("failed to decode weight: {:?}", e))?;
+
+		let storage_changes = changes
+			.drain_storage_changes(
+				&state_ext.backend,
+				// Note that in case a block contains a runtime upgrade, state version could
+				// potentially be incorrect here, this is very niche and would only result in
+				// unaligned roots, so this use case is ignored for now.
+				state_ext.state_version,
+			)
+			.unwrap();
+
+		state_ext.backend.apply_transaction(
+			storage_changes.transaction_storage_root,
+			storage_changes.transaction,
+		);
+
+		log::info!(
+			target: LOG_TARGET,
+			"executed block {}, consumed weight {}, new storage root {:?}",
+			number,
+			consumed_weight,
+			state_ext.as_backend().root(),
+		);
+	}
+
+	log::error!(target: LOG_TARGET, "ws subscription must have terminated.");
+	Ok(())
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/commands/mod.rs b/substrate/utils/frame/try-runtime/cli/src/commands/mod.rs
new file mode 100644
index 0000000000000000000000000000000000000000..37902e676e3db3d7714dda9a522ec3220ab9ad3a
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/commands/mod.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.
+
+pub mod create_snapshot;
+pub mod execute_block;
+pub mod fast_forward;
+pub mod follow_chain;
+pub mod offchain_worker;
+pub mod on_runtime_upgrade;
diff --git a/substrate/utils/frame/try-runtime/cli/src/commands/offchain_worker.rs b/substrate/utils/frame/try-runtime/cli/src/commands/offchain_worker.rs
new file mode 100644
index 0000000000000000000000000000000000000000..ac95384fb8aa5a128a116e5f7e6bc2ec3b23aa6d
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/commands/offchain_worker.rs
@@ -0,0 +1,102 @@
+// 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::{
+	build_executor, commands::execute_block::next_hash_of, full_extensions, parse, rpc_err_handler,
+	state_machine_call, LiveState, SharedParams, State, LOG_TARGET,
+};
+use parity_scale_codec::Encode;
+use sc_executor::sp_wasm_interface::HostFunctions;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::{fmt::Debug, str::FromStr};
+use substrate_rpc_client::{ws_client, ChainApi};
+
+/// Configurations of the [`crate::Command::OffchainWorker`].
+#[derive(Debug, Clone, clap::Parser)]
+pub struct OffchainWorkerCmd {
+	/// The ws uri from which to fetch the header.
+	///
+	/// If the `live` state type is being used, then this can be omitted, and is equal to whatever
+	/// the `state::uri` is. Only use this (with care) when combined with a snapshot.
+	#[arg(
+		long,
+		value_parser = parse::url
+	)]
+	pub header_ws_uri: Option<String>,
+
+	/// The state type to use.
+	#[command(subcommand)]
+	pub state: State,
+}
+
+impl OffchainWorkerCmd {
+	fn header_ws_uri<Block: BlockT>(&self) -> String
+	where
+		<Block::Hash as FromStr>::Err: Debug,
+	{
+		match (&self.header_ws_uri, &self.state) {
+			(Some(header_ws_uri), State::Snap { .. }) => header_ws_uri.to_owned(),
+			(Some(header_ws_uri), State::Live { .. }) => {
+				log::error!(target: LOG_TARGET, "--header-uri is provided while state type is live, this will most likely lead to a nonsensical result.");
+				header_ws_uri.to_owned()
+			},
+			(None, State::Live(LiveState { uri, .. })) => uri.clone(),
+			(None, State::Snap { .. }) => {
+				panic!("either `--header-uri` must be provided, or state must be `live`");
+			},
+		}
+	}
+}
+
+pub(crate) async fn offchain_worker<Block, HostFns>(
+	shared: SharedParams,
+	command: OffchainWorkerCmd,
+) -> sc_cli::Result<()>
+where
+	Block: BlockT + serde::de::DeserializeOwned,
+	Block::Header: serde::de::DeserializeOwned,
+	<Block::Hash as FromStr>::Err: Debug,
+	NumberFor<Block>: FromStr,
+	<NumberFor<Block> as FromStr>::Err: Debug,
+	HostFns: HostFunctions,
+{
+	let executor = build_executor(&shared);
+	// we first build the externalities with the remote code.
+	let ext = command.state.into_ext::<Block, HostFns>(&shared, &executor, None, true).await?;
+
+	let header_ws_uri = command.header_ws_uri::<Block>();
+
+	let rpc = ws_client(&header_ws_uri).await?;
+	let next_hash = next_hash_of::<Block>(&rpc, ext.block_hash).await?;
+	log::info!(target: LOG_TARGET, "fetching next header: {:?} ", next_hash);
+
+	let header = ChainApi::<(), Block::Hash, Block::Header, ()>::header(&rpc, Some(next_hash))
+		.await
+		.map_err(rpc_err_handler)
+		.map(|maybe_header| maybe_header.ok_or("Header does not exist"))??;
+	let payload = header.encode();
+
+	let _ = state_machine_call::<Block, HostFns>(
+		&ext,
+		&executor,
+		"OffchainWorkerApi_offchain_worker",
+		&payload,
+		full_extensions(executor.clone()),
+	)?;
+
+	Ok(())
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/commands/on_runtime_upgrade.rs b/substrate/utils/frame/try-runtime/cli/src/commands/on_runtime_upgrade.rs
new file mode 100644
index 0000000000000000000000000000000000000000..67988a3d1aadad2d53778e1626166c4a00a47584
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/commands/on_runtime_upgrade.rs
@@ -0,0 +1,89 @@
+// 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::{build_executor, state_machine_call_with_proof, SharedParams, State, LOG_TARGET};
+use frame_try_runtime::UpgradeCheckSelect;
+use parity_scale_codec::{Decode, Encode};
+use sc_executor::sp_wasm_interface::HostFunctions;
+use sp_runtime::traits::{Block as BlockT, NumberFor};
+use sp_weights::Weight;
+use std::{fmt::Debug, str::FromStr};
+
+/// Configurations of the [`crate::Command::OnRuntimeUpgrade`].
+#[derive(Debug, Clone, clap::Parser)]
+pub struct OnRuntimeUpgradeCmd {
+	/// The state type to use.
+	#[command(subcommand)]
+	pub state: State,
+
+	/// Select which optional checks to perform. Selects all when no value is given.
+	///
+	/// - `none`: Perform no checks.
+	/// - `all`: Perform all checks (default when --checks is present with no value).
+	/// - `pre-and-post`: Perform pre- and post-upgrade checks (default when the arg is not
+	///   present).
+	/// - `try-state`: Perform the try-state checks.
+	///
+	/// Performing any checks will potentially invalidate the measured PoV/Weight.
+	// NOTE: The clap attributes make it backwards compatible with the previous `--checks` flag.
+	#[clap(long,
+		default_value = "pre-and-post",
+		default_missing_value = "all",
+		num_args = 0..=1,
+		require_equals = true,
+		verbatim_doc_comment)]
+	pub checks: UpgradeCheckSelect,
+}
+
+pub(crate) async fn on_runtime_upgrade<Block, HostFns>(
+	shared: SharedParams,
+	command: OnRuntimeUpgradeCmd,
+) -> sc_cli::Result<()>
+where
+	Block: BlockT + serde::de::DeserializeOwned,
+	<Block::Hash as FromStr>::Err: Debug,
+	Block::Header: serde::de::DeserializeOwned,
+	NumberFor<Block>: FromStr,
+	<NumberFor<Block> as FromStr>::Err: Debug,
+	HostFns: HostFunctions,
+{
+	let executor = build_executor(&shared);
+	let ext = command.state.into_ext::<Block, HostFns>(&shared, &executor, None, true).await?;
+
+	let (_, encoded_result) = state_machine_call_with_proof::<Block, HostFns>(
+		&ext,
+		&executor,
+		"TryRuntime_on_runtime_upgrade",
+		command.checks.encode().as_ref(),
+		Default::default(), // we don't really need any extensions here.
+		shared.export_proof,
+	)?;
+
+	let (weight, total_weight) = <(Weight, Weight) as Decode>::decode(&mut &*encoded_result)
+		.map_err(|e| format!("failed to decode weight: {:?}", e))?;
+
+	log::info!(
+		target: LOG_TARGET,
+		"TryRuntime_on_runtime_upgrade executed without errors. Consumed weight = ({} ps, {} byte), total weight = ({} ps, {} byte) ({:.2} %, {:.2} %).",
+		weight.ref_time(), weight.proof_size(),
+		total_weight.ref_time(), total_weight.proof_size(),
+		(weight.ref_time() as f64 / total_weight.ref_time().max(1) as f64) * 100.0,
+		(weight.proof_size() as f64 / total_weight.proof_size().max(1) as f64) * 100.0,
+	);
+
+	Ok(())
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/lib.rs b/substrate/utils/frame/try-runtime/cli/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..73952ce816af426e8ff6749879269cd2fe378abe
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/lib.rs
@@ -0,0 +1,701 @@
+// 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.
+
+//! # Try-runtime
+//!
+//! Substrate's `try-runtime` subcommand has been migrated to a [standalone
+//! CLI](https://github.com/paritytech/try-runtime-cli).
+//!
+//! It is no longer maintained here and will be removed in the future.
+
+#![cfg(feature = "try-runtime")]
+
+use crate::block_building_info::BlockBuildingInfoProvider;
+use parity_scale_codec::Decode;
+use remote_externalities::{
+	Builder, Mode, OfflineConfig, OnlineConfig, RemoteExternalities, SnapshotConfig,
+};
+use sc_cli::{
+	execution_method_from_cli, CliConfiguration, RuntimeVersion, WasmExecutionMethod,
+	WasmtimeInstantiationStrategy, DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
+	DEFAULT_WASM_EXECUTION_METHOD,
+};
+use sc_executor::{
+	sp_wasm_interface::HostFunctions, HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY,
+};
+use sp_core::{
+	hexdisplay::HexDisplay,
+	offchain::{
+		testing::{TestOffchainExt, TestTransactionPoolExt},
+		OffchainDbExt, OffchainWorkerExt, TransactionPoolExt,
+	},
+	storage::well_known_keys,
+	traits::{CallContext, ReadRuntimeVersion, ReadRuntimeVersionExt},
+	twox_128, H256,
+};
+use sp_externalities::Extensions;
+use sp_inherents::InherentData;
+use sp_keystore::{testing::MemoryKeystore, KeystoreExt};
+use sp_runtime::{
+	traits::{BlakeTwo256, Block as BlockT, Hash as HashT, HashingFor, NumberFor},
+	DeserializeOwned, Digest,
+};
+use sp_state_machine::{
+	CompactProof, OverlayedChanges, StateMachine, TestExternalities, TrieBackendBuilder,
+};
+use sp_version::StateVersion;
+use std::{fmt::Debug, path::PathBuf, str::FromStr};
+
+pub mod block_building_info;
+pub mod commands;
+pub(crate) mod parse;
+pub(crate) const LOG_TARGET: &str = "try-runtime::cli";
+
+/// Possible commands of `try-runtime`.
+#[derive(Debug, Clone, clap::Subcommand)]
+pub enum Command {
+	/// Execute the migrations of the given runtime
+	///
+	/// This uses a custom runtime api call, namely "TryRuntime_on_runtime_upgrade". The code path
+	/// only triggers all of the `on_runtime_upgrade` hooks in the runtime, and optionally
+	/// `try_state`.
+	///
+	/// See [`frame_try_runtime::TryRuntime`] and
+	/// [`commands::on_runtime_upgrade::OnRuntimeUpgradeCmd`] for more information.
+	OnRuntimeUpgrade(commands::on_runtime_upgrade::OnRuntimeUpgradeCmd),
+
+	/// Executes the given block against some state.
+	///
+	/// This uses a custom runtime api call, namely "TryRuntime_execute_block". Some checks, such
+	/// as state-root and signature checks are always disabled, and additional checks like
+	/// `try-state` can be enabled.
+	///
+	/// See [`frame_try_runtime::TryRuntime`] and [`commands::execute_block::ExecuteBlockCmd`] for
+	/// more information.
+	ExecuteBlock(commands::execute_block::ExecuteBlockCmd),
+
+	/// Executes *the offchain worker hooks* of a given block against some state.
+	///
+	/// This executes the same runtime api as normal block import, namely
+	/// `OffchainWorkerApi_offchain_worker`.
+	///
+	/// See [`frame_try_runtime::TryRuntime`] and [`commands::offchain_worker::OffchainWorkerCmd`]
+	/// for more information.
+	OffchainWorker(commands::offchain_worker::OffchainWorkerCmd),
+
+	/// Follow the given chain's finalized blocks and apply all of its extrinsics.
+	///
+	/// This is essentially repeated calls to [`Command::ExecuteBlock`].
+	///
+	/// This allows the behavior of a new runtime to be inspected over a long period of time, with
+	/// realistic transactions coming as input.
+	///
+	/// NOTE: this does NOT execute the offchain worker hooks of mirrored blocks. This might be
+	/// added in the future.
+	///
+	/// This does not support snapshot states, and can only work with a remote chain. Upon first
+	/// connections, starts listening for finalized block events. Upon first block notification, it
+	/// initializes the state from the remote node, and starts applying that block, plus all the
+	/// blocks that follow, to the same growing state.
+	///
+	/// This can only work if the block format between the remote chain and the new runtime being
+	/// tested has remained the same, otherwise block decoding might fail.
+	FollowChain(commands::follow_chain::FollowChainCmd),
+
+	/// Produce a series of empty, consecutive blocks and execute them one-by-one.
+	///
+	/// To compare it with [`Command::FollowChain`]:
+	///  - we don't have the delay of the original blocktime (for Polkadot 6s), but instead, we
+	///    execute every block immediately
+	///  - the only data that will be put into blocks are pre-runtime digest items and inherent
+	///    extrinsics; both things should be defined in your node CLI handling level
+	FastForward(commands::fast_forward::FastForwardCmd),
+
+	/// Create a new snapshot file.
+	CreateSnapshot(commands::create_snapshot::CreateSnapshotCmd),
+}
+
+#[derive(Debug, Clone)]
+pub enum Runtime {
+	/// Use the given path to the wasm binary file.
+	///
+	/// It must have been compiled with `try-runtime`.
+	Path(PathBuf),
+
+	/// Use the code of the remote node, or the snapshot.
+	///
+	/// In almost all cases, this is not what you want, because the code in the remote node does
+	/// not have any of the try-runtime custom runtime APIs.
+	Existing,
+}
+
+impl FromStr for Runtime {
+	type Err = String;
+
+	fn from_str(s: &str) -> Result<Self, Self::Err> {
+		Ok(match s.to_lowercase().as_ref() {
+			"existing" => Runtime::Existing,
+			x @ _ => Runtime::Path(x.into()),
+		})
+	}
+}
+
+/// Shared parameters of the `try-runtime` commands
+#[derive(Debug, Clone, clap::Parser)]
+#[group(skip)]
+pub struct SharedParams {
+	/// Shared parameters of substrate cli.
+	///
+	/// TODO: this is only needed because try-runtime is embedded in the substrate CLI. It should
+	/// go away.
+	#[allow(missing_docs)]
+	#[clap(flatten)]
+	pub shared_params: sc_cli::SharedParams,
+
+	/// The runtime to use.
+	///
+	/// Must be a path to a wasm blob, compiled with `try-runtime` feature flag.
+	///
+	/// Or, `existing`, indicating that you don't want to overwrite the runtime. This will use
+	/// whatever comes from the remote node, or the snapshot file. This will most likely not work
+	/// against a remote node, as no (sane) blockchain should compile its onchain wasm with
+	/// `try-runtime` feature.
+	#[arg(long)]
+	pub runtime: Runtime,
+
+	/// Type of wasm execution used.
+	#[arg(
+		long = "wasm-execution",
+		value_name = "METHOD",
+		value_enum,
+		ignore_case = true,
+		default_value_t = DEFAULT_WASM_EXECUTION_METHOD,
+	)]
+	pub wasm_method: WasmExecutionMethod,
+
+	/// The WASM instantiation method to use.
+	///
+	/// Only has an effect when `wasm-execution` is set to `compiled`.
+	#[arg(
+		long = "wasm-instantiation-strategy",
+		value_name = "STRATEGY",
+		default_value_t = DEFAULT_WASMTIME_INSTANTIATION_STRATEGY,
+		value_enum,
+	)]
+	pub wasmtime_instantiation_strategy: WasmtimeInstantiationStrategy,
+
+	/// The number of 64KB pages to allocate for Wasm execution. Defaults to
+	/// [`sc_service::Configuration.default_heap_pages`].
+	#[arg(long)]
+	pub heap_pages: Option<u64>,
+
+	/// Path to a file to export the storage proof into (as a JSON).
+	/// If several blocks are executed, the path is interpreted as a folder
+	/// where one file per block will be written (named `{block_number}-{block_hash}`).
+	#[clap(long)]
+	pub export_proof: Option<PathBuf>,
+
+	/// Overwrite the `state_version`.
+	///
+	/// Otherwise `remote-externalities` will automatically set the correct state version.
+	#[arg(long, value_parser = parse::state_version)]
+	pub overwrite_state_version: Option<StateVersion>,
+}
+
+/// Our `try-runtime` command.
+///
+/// See [`Command`] for more info.
+#[derive(Debug, Clone, clap::Parser)]
+pub struct TryRuntimeCmd {
+	#[clap(flatten)]
+	pub shared: SharedParams,
+
+	#[command(subcommand)]
+	pub command: Command,
+}
+
+/// A `Live` variant [`State`]
+#[derive(Debug, Clone, clap::Args)]
+pub struct LiveState {
+	/// The url to connect to.
+	#[arg(
+		short,
+		long,
+		value_parser = parse::url,
+	)]
+	uri: String,
+
+	/// The block hash at which to fetch the state.
+	///
+	/// If non provided, then the latest finalized head is used.
+	#[arg(
+		short,
+		long,
+		value_parser = parse::hash,
+	)]
+	at: Option<String>,
+
+	/// A pallet to scrape. Can be provided multiple times. If empty, entire chain state will
+	/// be scraped.
+	#[arg(short, long, num_args = 1..)]
+	pallet: Vec<String>,
+
+	/// Fetch the child-keys as well.
+	///
+	/// Default is `false`, if specific `--pallets` are specified, `true` otherwise. In other
+	/// words, if you scrape the whole state the child tree data is included out of the box.
+	/// Otherwise, it must be enabled explicitly using this flag.
+	#[arg(long)]
+	child_tree: bool,
+}
+
+/// The source of runtime *state* to use.
+#[derive(Debug, Clone, clap::Subcommand)]
+pub enum State {
+	/// Use a state snapshot as the source of runtime state.
+	Snap {
+		#[arg(short, long)]
+		snapshot_path: PathBuf,
+	},
+
+	/// Use a live chain as the source of runtime state.
+	Live(LiveState),
+}
+
+impl State {
+	/// Create the [`remote_externalities::RemoteExternalities`] using [`remote-externalities`] from
+	/// self.
+	///
+	/// This will override the code as it sees fit based on [`SharedParams::Runtime`]. It will also
+	/// check the spec-version and name.
+	pub(crate) async fn into_ext<Block: BlockT + DeserializeOwned, HostFns: HostFunctions>(
+		&self,
+		shared: &SharedParams,
+		executor: &WasmExecutor<HostFns>,
+		state_snapshot: Option<SnapshotConfig>,
+		try_runtime_check: bool,
+	) -> sc_cli::Result<RemoteExternalities<Block>>
+	where
+		Block::Header: DeserializeOwned,
+		<Block::Hash as FromStr>::Err: Debug,
+	{
+		let builder = match self {
+			State::Snap { snapshot_path } =>
+				Builder::<Block>::new().mode(Mode::Offline(OfflineConfig {
+					state_snapshot: SnapshotConfig::new(snapshot_path),
+				})),
+			State::Live(LiveState { pallet, uri, at, child_tree }) => {
+				let at = match at {
+					Some(at_str) => Some(hash_of::<Block>(at_str)?),
+					None => None,
+				};
+				Builder::<Block>::new().mode(Mode::Online(OnlineConfig {
+					at,
+					transport: uri.to_owned().into(),
+					state_snapshot,
+					pallets: pallet.clone(),
+					child_trie: *child_tree,
+					hashed_keys: vec![
+						// we always download the code, but we almost always won't use it, based on
+						// `Runtime`.
+						well_known_keys::CODE.to_vec(),
+						// we will always download this key, since it helps detect if we should do
+						// runtime migration or not.
+						[twox_128(b"System"), twox_128(b"LastRuntimeUpgrade")].concat(),
+						[twox_128(b"System"), twox_128(b"Number")].concat(),
+					],
+					hashed_prefixes: vec![],
+				}))
+			},
+		};
+
+		// possibly overwrite the state version, should hardly be needed.
+		let builder = if let Some(state_version) = shared.overwrite_state_version {
+			log::warn!(
+				target: LOG_TARGET,
+				"overwriting state version to {:?}, you better know what you are doing.",
+				state_version
+			);
+			builder.overwrite_state_version(state_version)
+		} else {
+			builder
+		};
+
+		// then, we prepare to replace the code based on what the CLI wishes.
+		let maybe_code_to_overwrite = match shared.runtime {
+			Runtime::Path(ref path) => Some(std::fs::read(path).map_err(|e| {
+				format!("error while reading runtime file from {:?}: {:?}", path, e)
+			})?),
+			Runtime::Existing => None,
+		};
+
+		// build the main ext.
+		let mut ext = builder.build().await?;
+
+		// actually replace the code if needed.
+		if let Some(new_code) = maybe_code_to_overwrite {
+			let original_code = ext
+				.execute_with(|| sp_io::storage::get(well_known_keys::CODE))
+				.expect("':CODE:' is always downloaded in try-runtime-cli; qed");
+
+			// NOTE: see the impl notes of `read_runtime_version`, the ext is almost not used here,
+			// only as a backup.
+			ext.insert(well_known_keys::CODE.to_vec(), new_code.clone());
+			let old_version = <RuntimeVersion as Decode>::decode(
+				&mut &*executor.read_runtime_version(&original_code, &mut ext.ext()).unwrap(),
+			)
+			.unwrap();
+			log::info!(
+				target: LOG_TARGET,
+				"original spec: {:?}-{:?}, code hash: {:?}",
+				old_version.spec_name,
+				old_version.spec_version,
+				HexDisplay::from(BlakeTwo256::hash(&original_code).as_fixed_bytes()),
+			);
+			let new_version = <RuntimeVersion as Decode>::decode(
+				&mut &*executor.read_runtime_version(&new_code, &mut ext.ext()).unwrap(),
+			)
+			.unwrap();
+			log::info!(
+				target: LOG_TARGET,
+				"new spec: {:?}-{:?}, code hash: {:?}",
+				new_version.spec_name,
+				new_version.spec_version,
+				HexDisplay::from(BlakeTwo256::hash(&new_code).as_fixed_bytes())
+			);
+
+			if new_version.spec_name != old_version.spec_name {
+				return Err("Spec names must match.".into())
+			}
+		}
+
+		// whatever runtime we have in store now must have been compiled with try-runtime feature.
+		if try_runtime_check {
+			if !ensure_try_runtime::<Block, HostFns>(&executor, &mut ext) {
+				return Err("given runtime is NOT compiled with try-runtime feature!".into())
+			}
+		}
+
+		Ok(ext)
+	}
+}
+
+pub const DEPRECATION_NOTICE: &str = "Substrate's `try-runtime` subcommand has been migrated to a standalone CLI (https://github.com/paritytech/try-runtime-cli). It is no longer being maintained here and will be removed entirely some time after January 2024. Please remove this subcommand from your runtime and use the standalone CLI.";
+
+impl TryRuntimeCmd {
+	// Can't reuse DEPRECATION_NOTICE in the deprecated macro
+	#[deprecated(
+		note = "Substrate's `try-runtime` subcommand has been migrated to a standalone CLI (https://github.com/paritytech/try-runtime-cli). It is no longer being maintained here and will be removed entirely some time after January 2024. Please remove this subcommand from your runtime and use the standalone CLI."
+	)]
+	pub async fn run<Block, HostFns, BBIP>(
+		&self,
+		block_building_info_provider: Option<BBIP>,
+	) -> sc_cli::Result<()>
+	where
+		Block: BlockT<Hash = H256> + DeserializeOwned,
+		Block::Header: DeserializeOwned,
+		<Block::Hash as FromStr>::Err: Debug,
+		<NumberFor<Block> as FromStr>::Err: Debug,
+		<NumberFor<Block> as TryInto<u64>>::Error: Debug,
+		NumberFor<Block>: FromStr,
+		HostFns: HostFunctions,
+		BBIP: BlockBuildingInfoProvider<Block, Option<(InherentData, Digest)>>,
+	{
+		match &self.command {
+			Command::OnRuntimeUpgrade(ref cmd) =>
+				commands::on_runtime_upgrade::on_runtime_upgrade::<Block, HostFns>(
+					self.shared.clone(),
+					cmd.clone(),
+				)
+				.await,
+			Command::OffchainWorker(cmd) =>
+				commands::offchain_worker::offchain_worker::<Block, HostFns>(
+					self.shared.clone(),
+					cmd.clone(),
+				)
+				.await,
+			Command::ExecuteBlock(cmd) =>
+				commands::execute_block::execute_block::<Block, HostFns>(
+					self.shared.clone(),
+					cmd.clone(),
+				)
+				.await,
+			Command::FollowChain(cmd) =>
+				commands::follow_chain::follow_chain::<Block, HostFns>(
+					self.shared.clone(),
+					cmd.clone(),
+				)
+				.await,
+			Command::FastForward(cmd) =>
+				commands::fast_forward::fast_forward::<Block, HostFns, BBIP>(
+					self.shared.clone(),
+					cmd.clone(),
+					block_building_info_provider,
+				)
+				.await,
+			Command::CreateSnapshot(cmd) =>
+				commands::create_snapshot::create_snapshot::<Block, HostFns>(
+					self.shared.clone(),
+					cmd.clone(),
+				)
+				.await,
+		}
+	}
+}
+
+impl CliConfiguration for TryRuntimeCmd {
+	fn shared_params(&self) -> &sc_cli::SharedParams {
+		&self.shared.shared_params
+	}
+
+	fn chain_id(&self, _is_dev: bool) -> sc_cli::Result<String> {
+		Ok(match self.shared.shared_params.chain {
+			Some(ref chain) => chain.clone(),
+			None => "dev".into(),
+		})
+	}
+}
+
+/// Get the hash type of the generic `Block` from a `hash_str`.
+pub(crate) fn hash_of<Block: BlockT>(hash_str: &str) -> sc_cli::Result<Block::Hash>
+where
+	<Block::Hash as FromStr>::Err: Debug,
+{
+	hash_str
+		.parse::<<Block as BlockT>::Hash>()
+		.map_err(|e| format!("Could not parse block hash: {:?}", e).into())
+}
+
+/// Build all extensions that we typically use.
+pub(crate) fn full_extensions<H: HostFunctions>(wasm_executor: WasmExecutor<H>) -> Extensions {
+	let mut extensions = Extensions::default();
+	let (offchain, _offchain_state) = TestOffchainExt::new();
+	let (pool, _pool_state) = TestTransactionPoolExt::new();
+	let keystore = MemoryKeystore::new();
+	extensions.register(OffchainDbExt::new(offchain.clone()));
+	extensions.register(OffchainWorkerExt::new(offchain));
+	extensions.register(KeystoreExt::new(keystore));
+	extensions.register(TransactionPoolExt::new(pool));
+	extensions.register(ReadRuntimeVersionExt::new(wasm_executor));
+
+	extensions
+}
+
+/// Build wasm executor by default config.
+pub(crate) fn build_executor<H: HostFunctions>(shared: &SharedParams) -> WasmExecutor<H> {
+	let heap_pages = shared
+		.heap_pages
+		.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |p| HeapAllocStrategy::Static { extra_pages: p as _ });
+
+	WasmExecutor::builder()
+		.with_execution_method(execution_method_from_cli(
+			shared.wasm_method,
+			shared.wasmtime_instantiation_strategy,
+		))
+		.with_onchain_heap_alloc_strategy(heap_pages)
+		.with_offchain_heap_alloc_strategy(heap_pages)
+		.build()
+}
+
+/// Ensure that the given `ext` is compiled with `try-runtime`
+fn ensure_try_runtime<Block: BlockT, HostFns: HostFunctions>(
+	executor: &WasmExecutor<HostFns>,
+	ext: &mut TestExternalities<HashingFor<Block>>,
+) -> bool {
+	use sp_api::RuntimeApiInfo;
+	let final_code = ext
+		.execute_with(|| sp_io::storage::get(well_known_keys::CODE))
+		.expect("':CODE:' is always downloaded in try-runtime-cli; qed");
+	let final_version = <RuntimeVersion as Decode>::decode(
+		&mut &*executor.read_runtime_version(&final_code, &mut ext.ext()).unwrap(),
+	)
+	.unwrap();
+	final_version
+		.api_version(&<dyn frame_try_runtime::TryRuntime<Block>>::ID)
+		.is_some()
+}
+
+/// Execute the given `method` and `data` on top of `ext`, returning the results (encoded) and the
+/// state `changes`.
+pub(crate) fn state_machine_call<Block: BlockT, HostFns: HostFunctions>(
+	ext: &TestExternalities<HashingFor<Block>>,
+	executor: &WasmExecutor<HostFns>,
+	method: &'static str,
+	data: &[u8],
+	mut extensions: Extensions,
+) -> sc_cli::Result<(OverlayedChanges<HashingFor<Block>>, Vec<u8>)> {
+	let mut changes = Default::default();
+	let encoded_results = StateMachine::new(
+		&ext.backend,
+		&mut changes,
+		executor,
+		method,
+		data,
+		&mut extensions,
+		&sp_state_machine::backend::BackendRuntimeCode::new(&ext.backend).runtime_code()?,
+		CallContext::Offchain,
+	)
+	.execute()
+	.map_err(|e| format!("failed to execute '{}': {}", method, e))
+	.map_err::<sc_cli::Error, _>(Into::into)?;
+
+	Ok((changes, encoded_results))
+}
+
+/// Same as [`state_machine_call`], but it also computes and prints the storage proof in different
+/// size and formats.
+///
+/// Make sure [`LOG_TARGET`] is enabled in logging.
+pub(crate) fn state_machine_call_with_proof<Block: BlockT, HostFns: HostFunctions>(
+	ext: &TestExternalities<HashingFor<Block>>,
+	executor: &WasmExecutor<HostFns>,
+	method: &'static str,
+	data: &[u8],
+	mut extensions: Extensions,
+	maybe_export_proof: Option<PathBuf>,
+) -> sc_cli::Result<(OverlayedChanges<HashingFor<Block>>, Vec<u8>)> {
+	use parity_scale_codec::Encode;
+
+	let mut changes = Default::default();
+	let backend = ext.backend.clone();
+	let runtime_code_backend = sp_state_machine::backend::BackendRuntimeCode::new(&backend);
+	let proving_backend =
+		TrieBackendBuilder::wrap(&backend).with_recorder(Default::default()).build();
+	let runtime_code = runtime_code_backend.runtime_code()?;
+
+	let pre_root = *backend.root();
+	let encoded_results = StateMachine::new(
+		&proving_backend,
+		&mut changes,
+		executor,
+		method,
+		data,
+		&mut extensions,
+		&runtime_code,
+		CallContext::Offchain,
+	)
+	.execute()
+	.map_err(|e| format!("failed to execute {}: {}", method, e))
+	.map_err::<sc_cli::Error, _>(Into::into)?;
+
+	let proof = proving_backend
+		.extract_proof()
+		.expect("A recorder was set and thus, a storage proof can be extracted; qed");
+
+	if let Some(path) = maybe_export_proof {
+		let mut file = std::fs::File::create(&path).map_err(|e| {
+			log::error!(
+				target: LOG_TARGET,
+				"Failed to create file {}: {:?}",
+				path.to_string_lossy(),
+				e
+			);
+			e
+		})?;
+
+		log::info!(target: LOG_TARGET, "Writing storage proof to {}", path.to_string_lossy());
+
+		use std::io::Write as _;
+		file.write_all(storage_proof_to_raw_json(&proof).as_bytes()).map_err(|e| {
+			log::error!(
+				target: LOG_TARGET,
+				"Failed to write storage proof to {}: {:?}",
+				path.to_string_lossy(),
+				e
+			);
+			e
+		})?;
+	}
+
+	let proof_size = proof.encoded_size();
+	let compact_proof = proof
+		.clone()
+		.into_compact_proof::<HashingFor<Block>>(pre_root)
+		.map_err(|e| {
+			log::error!(target: LOG_TARGET, "failed to generate compact proof {}: {:?}", method, e);
+			e
+		})
+		.unwrap_or(CompactProof { encoded_nodes: Default::default() });
+
+	let compact_proof_size = compact_proof.encoded_size();
+	let compressed_proof = zstd::stream::encode_all(&compact_proof.encode()[..], 0)
+		.map_err(|e| {
+			log::error!(
+				target: LOG_TARGET,
+				"failed to generate compressed proof {}: {:?}",
+				method,
+				e
+			);
+			e
+		})
+		.unwrap_or_default();
+
+	let proof_nodes = proof.into_nodes();
+
+	let humanize = |s| {
+		if s < 1024 * 1024 {
+			format!("{:.2} KB ({} bytes)", s as f64 / 1024f64, s)
+		} else {
+			format!(
+				"{:.2} MB ({} KB) ({} bytes)",
+				s as f64 / (1024f64 * 1024f64),
+				s as f64 / 1024f64,
+				s
+			)
+		}
+	};
+	log::debug!(
+		target: LOG_TARGET,
+		"proof: 0x{}... / {} nodes",
+		HexDisplay::from(&proof_nodes.iter().flatten().cloned().take(10).collect::<Vec<_>>()),
+		proof_nodes.len()
+	);
+	log::debug!(target: LOG_TARGET, "proof size: {}", humanize(proof_size));
+	log::debug!(target: LOG_TARGET, "compact proof size: {}", humanize(compact_proof_size),);
+	log::debug!(
+		target: LOG_TARGET,
+		"zstd-compressed compact proof {}",
+		humanize(compressed_proof.len()),
+	);
+
+	log::debug!(target: LOG_TARGET, "{} executed without errors.", method);
+
+	Ok((changes, encoded_results))
+}
+
+pub(crate) fn rpc_err_handler(error: impl Debug) -> &'static str {
+	log::error!(target: LOG_TARGET, "rpc error: {:?}", error);
+	"rpc error."
+}
+
+/// Converts a [`sp_state_machine::StorageProof`] into a JSON string.
+fn storage_proof_to_raw_json(storage_proof: &sp_state_machine::StorageProof) -> String {
+	serde_json::Value::Object(
+		storage_proof
+			.to_memory_db::<sp_runtime::traits::BlakeTwo256>()
+			.drain()
+			.iter()
+			.map(|(key, (value, _n))| {
+				(
+					format!("0x{}", hex::encode(key.as_bytes())),
+					serde_json::Value::String(format!("0x{}", hex::encode(value))),
+				)
+			})
+			.collect(),
+	)
+	.to_string()
+}
diff --git a/substrate/utils/frame/try-runtime/cli/src/parse.rs b/substrate/utils/frame/try-runtime/cli/src/parse.rs
new file mode 100644
index 0000000000000000000000000000000000000000..336a36baf2416a4e538ca650eb163fc1f9e53686
--- /dev/null
+++ b/substrate/utils/frame/try-runtime/cli/src/parse.rs
@@ -0,0 +1,53 @@
+// 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.
+
+//! Utils for parsing user input
+
+use sp_version::StateVersion;
+
+pub(crate) fn hash(block_hash: &str) -> Result<String, String> {
+	let (block_hash, offset) = if let Some(block_hash) = block_hash.strip_prefix("0x") {
+		(block_hash, 2)
+	} else {
+		(block_hash, 0)
+	};
+
+	if let Some(pos) = block_hash.chars().position(|c| !c.is_ascii_hexdigit()) {
+		Err(format!(
+			"Expected block hash, found illegal hex character at position: {}",
+			offset + pos,
+		))
+	} else {
+		Ok(block_hash.into())
+	}
+}
+
+pub(crate) fn url(s: &str) -> Result<String, &'static str> {
+	if s.starts_with("ws://") || s.starts_with("wss://") {
+		// could use Url crate as well, but lets keep it simple for now.
+		Ok(s.to_string())
+	} else {
+		Err("not a valid WS(S) url: must start with 'ws://' or 'wss://'")
+	}
+}
+
+pub(crate) fn state_version(s: &str) -> Result<StateVersion, &'static str> {
+	s.parse::<u8>()
+		.map_err(|_| ())
+		.and_then(StateVersion::try_from)
+		.map_err(|_| "Invalid state version.")
+}
diff --git a/substrate/utils/prometheus/Cargo.toml b/substrate/utils/prometheus/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..e84a6f4b303415bbe869c24a081728cdc6cb4900
--- /dev/null
+++ b/substrate/utils/prometheus/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+description = "Endpoint to expose Prometheus metrics"
+name = "substrate-prometheus-endpoint"
+version = "0.10.0-dev"
+license = "Apache-2.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+homepage = "https://substrate.io"
+repository = "https://github.com/paritytech/substrate/"
+readme = "README.md"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+hyper = { version = "0.14.16", default-features = false, features = ["http1", "server", "tcp"] }
+log = "0.4.17"
+prometheus = { version = "0.13.0", default-features = false }
+thiserror = "1.0"
+tokio = { version = "1.22.0", features = ["parking_lot"] }
+
+[dev-dependencies]
+hyper = { version = "0.14.16", features = ["client"] }
+tokio = { version = "1.22.0", features = ["rt-multi-thread"] }
diff --git a/substrate/utils/prometheus/README.md b/substrate/utils/prometheus/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9dd0882105c698e382c8d35b31244ca06e3127e1
--- /dev/null
+++ b/substrate/utils/prometheus/README.md
@@ -0,0 +1,16 @@
+# Substrate Prometheus Exporter
+
+## Introduction
+
+[Prometheus](https://prometheus.io/) is one of the most widely used monitoring tools for managing highly available services supported by [Cloud Native Computing Foundation](https://www.cncf.io/). By providing Prometheus metrics in Substrate, node operators can easily adopt widely used display/alert tools such
+as [Grafana](https://grafana.com/) and [Alertmanager](https://prometheus.io/docs/alerting/alertmanager/). Easy access to such monitoring tools will benefit parachain developers/operators and validators to have much higher availability of their services.
+
+Metrics will be served under `/metrics` on TCP port 9615 by default.
+
+## Quick Start
+ 
+1. From the root of the repository start Substrate `cargo run --release`.
+
+2. In another terminal run `curl localhost:9615/metrics` to retrieve the metrics.
+
+To learn how to configure Prometheus see the Prometheus [Getting Started](https://prometheus.io/docs/prometheus/latest/getting_started/) guide.
\ No newline at end of file
diff --git a/substrate/utils/prometheus/src/lib.rs b/substrate/utils/prometheus/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..581666635ab54698d0426bc80007e245ee8568fe
--- /dev/null
+++ b/substrate/utils/prometheus/src/lib.rs
@@ -0,0 +1,161 @@
+// 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 hyper::{
+	http::StatusCode,
+	server::Server,
+	service::{make_service_fn, service_fn},
+	Body, Request, Response,
+};
+pub use prometheus::{
+	self,
+	core::{
+		AtomicF64 as F64, AtomicI64 as I64, AtomicU64 as U64, GenericCounter as Counter,
+		GenericCounterVec as CounterVec, GenericGauge as Gauge, GenericGaugeVec as GaugeVec,
+	},
+	exponential_buckets, Error as PrometheusError, Histogram, HistogramOpts, HistogramVec, Opts,
+	Registry,
+};
+use prometheus::{core::Collector, Encoder, TextEncoder};
+use std::net::SocketAddr;
+
+mod sourced;
+
+pub use sourced::{MetricSource, SourcedCounter, SourcedGauge, SourcedMetric};
+
+pub fn register<T: Clone + Collector + 'static>(
+	metric: T,
+	registry: &Registry,
+) -> Result<T, PrometheusError> {
+	registry.register(Box::new(metric.clone()))?;
+	Ok(metric)
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+	/// Hyper internal error.
+	#[error(transparent)]
+	Hyper(#[from] hyper::Error),
+
+	/// Http request error.
+	#[error(transparent)]
+	Http(#[from] hyper::http::Error),
+
+	/// i/o error.
+	#[error(transparent)]
+	Io(#[from] std::io::Error),
+
+	#[error("Prometheus port {0} already in use.")]
+	PortInUse(SocketAddr),
+}
+
+async fn request_metrics(req: Request<Body>, registry: Registry) -> Result<Response<Body>, Error> {
+	if req.uri().path() == "/metrics" {
+		let metric_families = registry.gather();
+		let mut buffer = vec![];
+		let encoder = TextEncoder::new();
+		encoder.encode(&metric_families, &mut buffer).unwrap();
+
+		Response::builder()
+			.status(StatusCode::OK)
+			.header("Content-Type", encoder.format_type())
+			.body(Body::from(buffer))
+			.map_err(Error::Http)
+	} else {
+		Response::builder()
+			.status(StatusCode::NOT_FOUND)
+			.body(Body::from("Not found."))
+			.map_err(Error::Http)
+	}
+}
+
+/// Initializes the metrics context, and starts an HTTP server
+/// to serve metrics.
+pub async fn init_prometheus(prometheus_addr: SocketAddr, registry: Registry) -> Result<(), Error> {
+	let listener = tokio::net::TcpListener::bind(&prometheus_addr)
+		.await
+		.map_err(|_| Error::PortInUse(prometheus_addr))?;
+
+	init_prometheus_with_listener(listener, registry).await
+}
+
+/// Init prometheus using the given listener.
+async fn init_prometheus_with_listener(
+	listener: tokio::net::TcpListener,
+	registry: Registry,
+) -> Result<(), Error> {
+	let listener = hyper::server::conn::AddrIncoming::from_listener(listener)?;
+	log::info!("〽� Prometheus exporter started at {}", listener.local_addr());
+
+	let service = make_service_fn(move |_| {
+		let registry = registry.clone();
+
+		async move {
+			Ok::<_, hyper::Error>(service_fn(move |req: Request<Body>| {
+				request_metrics(req, registry.clone())
+			}))
+		}
+	});
+
+	let server = Server::builder(listener).serve(service);
+
+	let result = server.await.map_err(Into::into);
+
+	result
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use hyper::{Client, Uri};
+
+	#[test]
+	fn prometheus_works() {
+		const METRIC_NAME: &str = "test_test_metric_name_test_test";
+
+		let runtime = tokio::runtime::Runtime::new().expect("Creates the runtime");
+
+		let listener = runtime
+			.block_on(tokio::net::TcpListener::bind("127.0.0.1:0"))
+			.expect("Creates listener");
+
+		let local_addr = listener.local_addr().expect("Returns the local addr");
+
+		let registry = Registry::default();
+		register(
+			prometheus::Counter::new(METRIC_NAME, "yeah").expect("Creates test counter"),
+			&registry,
+		)
+		.expect("Registers the test metric");
+
+		runtime.spawn(init_prometheus_with_listener(listener, registry));
+
+		runtime.block_on(async {
+			let client = Client::new();
+
+			let res = client
+				.get(Uri::try_from(&format!("http://{}/metrics", local_addr)).expect("Parses URI"))
+				.await
+				.expect("Requests metrics");
+
+			let buf = hyper::body::to_bytes(res).await.expect("Converts body to bytes");
+
+			let body = String::from_utf8(buf.to_vec()).expect("Converts body to String");
+			assert!(body.contains(&format!("{} 0", METRIC_NAME)));
+		});
+	}
+}
diff --git a/substrate/utils/prometheus/src/sourced.rs b/substrate/utils/prometheus/src/sourced.rs
new file mode 100644
index 0000000000000000000000000000000000000000..8adaefa09d28f0775138f09a51034c1ae7f433f4
--- /dev/null
+++ b/substrate/utils/prometheus/src/sourced.rs
@@ -0,0 +1,157 @@
+// 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.
+
+//! Metrics that are collected from existing sources.
+
+use prometheus::{
+	core::{Collector, Desc, Describer, Number, Opts},
+	proto,
+};
+use std::{cmp::Ordering, marker::PhantomData};
+
+/// A counter whose values are obtained from an existing source.
+///
+/// > **Note*: The counter values provided by the source `S`
+/// > must be monotonically increasing. Otherwise use a
+/// > [`SourcedGauge`] instead.
+pub type SourcedCounter<S> = SourcedMetric<Counter, S>;
+
+/// A gauge whose values are obtained from an existing source.
+pub type SourcedGauge<S> = SourcedMetric<Gauge, S>;
+
+/// The type of a sourced counter.
+#[derive(Copy, Clone)]
+pub enum Counter {}
+
+/// The type of a sourced gauge.
+#[derive(Copy, Clone)]
+pub enum Gauge {}
+
+/// A metric whose values are obtained from an existing source,
+/// instead of being independently recorded.
+#[derive(Debug, Clone)]
+pub struct SourcedMetric<T, S> {
+	source: S,
+	desc: Desc,
+	_type: PhantomData<T>,
+}
+
+/// A source of values for a [`SourcedMetric`].
+pub trait MetricSource: Sync + Send + Clone {
+	/// The type of the collected values.
+	type N: Number;
+	/// Collects the current values of the metrics from the source.
+	fn collect(&self, set: impl FnMut(&[&str], Self::N));
+}
+
+impl<T: SourcedType, S: MetricSource> SourcedMetric<T, S> {
+	/// Creates a new metric that obtains its values from the given source.
+	pub fn new(opts: &Opts, source: S) -> prometheus::Result<Self> {
+		let desc = opts.describe()?;
+		Ok(Self { source, desc, _type: PhantomData })
+	}
+}
+
+impl<T: SourcedType, S: MetricSource> Collector for SourcedMetric<T, S> {
+	fn desc(&self) -> Vec<&Desc> {
+		vec![&self.desc]
+	}
+
+	fn collect(&self) -> Vec<proto::MetricFamily> {
+		let mut counters = Vec::new();
+
+		self.source.collect(|label_values, value| {
+			let mut m = proto::Metric::default();
+
+			match T::proto() {
+				proto::MetricType::COUNTER => {
+					let mut c = proto::Counter::default();
+					c.set_value(value.into_f64());
+					m.set_counter(c);
+				},
+				proto::MetricType::GAUGE => {
+					let mut g = proto::Gauge::default();
+					g.set_value(value.into_f64());
+					m.set_gauge(g);
+				},
+				t => {
+					log::error!("Unsupported sourced metric type: {:?}", t);
+				},
+			}
+
+			debug_assert_eq!(self.desc.variable_labels.len(), label_values.len());
+			match self.desc.variable_labels.len().cmp(&label_values.len()) {
+				Ordering::Greater => {
+					log::warn!("Missing label values for sourced metric {}", self.desc.fq_name)
+				},
+				Ordering::Less => {
+					log::warn!("Too many label values for sourced metric {}", self.desc.fq_name)
+				},
+				Ordering::Equal => {},
+			}
+
+			m.set_label(
+				self.desc
+					.variable_labels
+					.iter()
+					.zip(label_values)
+					.map(|(l_name, l_value)| {
+						let mut l = proto::LabelPair::default();
+						l.set_name(l_name.to_string());
+						l.set_value(l_value.to_string());
+						l
+					})
+					.chain(self.desc.const_label_pairs.iter().cloned())
+					.collect::<Vec<_>>(),
+			);
+
+			counters.push(m);
+		});
+
+		let mut m = proto::MetricFamily::default();
+		m.set_name(self.desc.fq_name.clone());
+		m.set_help(self.desc.help.clone());
+		m.set_field_type(T::proto());
+		m.set_metric(counters);
+
+		vec![m]
+	}
+}
+
+/// Types of metrics that can obtain their values from an existing source.
+pub trait SourcedType: private::Sealed + Sync + Send {
+	#[doc(hidden)]
+	fn proto() -> proto::MetricType;
+}
+
+impl SourcedType for Counter {
+	fn proto() -> proto::MetricType {
+		proto::MetricType::COUNTER
+	}
+}
+
+impl SourcedType for Gauge {
+	fn proto() -> proto::MetricType {
+		proto::MetricType::GAUGE
+	}
+}
+
+mod private {
+	pub trait Sealed {}
+	impl Sealed for super::Counter {}
+	impl Sealed for super::Gauge {}
+}
diff --git a/substrate/utils/wasm-builder/Cargo.toml b/substrate/utils/wasm-builder/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..13f344ebfa3a7f669c28b1b52a8a8c0fab9336ee
--- /dev/null
+++ b/substrate/utils/wasm-builder/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "substrate-wasm-builder"
+version = "5.0.0-dev"
+authors = ["Parity Technologies <admin@parity.io>"]
+description = "Utility for building WASM binaries"
+edition = "2021"
+readme = "README.md"
+repository = "https://github.com/paritytech/substrate/"
+license = "Apache-2.0"
+homepage = "https://substrate.io"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]
+
+[dependencies]
+ansi_term = "0.12.1"
+build-helper = "0.1.1"
+cargo_metadata = "0.15.4"
+strum = { version = "0.24.1", features = ["derive"] }
+tempfile = "3.1.0"
+toml = "0.7.3"
+walkdir = "2.3.2"
+sp-maybe-compressed-blob = { version = "4.1.0-dev", path = "../../primitives/maybe-compressed-blob" }
+filetime = "0.2.16"
+wasm-opt = "0.114"
+parity-wasm = "0.45"
diff --git a/substrate/utils/wasm-builder/README.md b/substrate/utils/wasm-builder/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b1ccb1b35b10e9e1bc42cd1d6726a82895fc1a7c
--- /dev/null
+++ b/substrate/utils/wasm-builder/README.md
@@ -0,0 +1,89 @@
+# Wasm builder is a utility for building a project as a Wasm binary
+
+The Wasm builder is a tool that integrates the process of building the WASM binary of your project into the main
+`cargo` build process.
+
+## Project setup
+
+A project that should be compiled as a Wasm binary needs to:
+
+1. Add a `build.rs` file.
+2. Add `wasm-builder` as dependency into `build-dependencies` (can be made optional and only enabled when `std` feature is used).
+
+The `build.rs` file needs to contain the following code:
+
+```rust
+fn main() {
+    #[cfg(feature = "std")]
+    {
+        substrate_wasm_builder::WasmBuilder::new()
+            // Tell the builder to build the project (crate) this `build.rs` is part of.
+            .with_current_project()
+            // Make sure to export the `heap_base` global, this is required by Substrate
+            .export_heap_base()
+            // Build the Wasm file so that it imports the memory (need to be provided by at instantiation)
+            .import_memory()
+            // Build it.
+            .build();
+    }
+}
+```
+
+As the final step, you need to add the following to your project:
+
+```rust
+include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+```
+
+This will include the generated Wasm binary as two constants `WASM_BINARY` and `WASM_BINARY_BLOATY`.
+The former is a compact Wasm binary and the latter is the Wasm binary as being generated by the compiler.
+Both variables have `Option<&'static [u8]>` as type.
+
+### Features
+
+Wasm builder supports to enable cargo features while building the Wasm binary. By default it will
+enable all features in the wasm build that are enabled for the native build except the
+`default` and `std` features. Besides that, wasm builder supports the special `runtime-wasm`
+feature. This `runtime-wasm` feature will be enabled by the wasm builder when it compiles the
+Wasm binary. If this feature is not present, it will not be enabled.
+
+## Environment variables
+
+By using environment variables, you can configure which Wasm binaries are built and how:
+
+- `SKIP_WASM_BUILD` - Skips building any Wasm binary. This is useful when only native should be recompiled.
+                      If this is the first run and there doesn't exist a Wasm binary, this will set both
+                      variables to `None`.
+- `WASM_BUILD_TYPE` - Sets the build type for building Wasm binaries. Supported values are `release` or `debug`.
+                      By default the build type is equal to the build type used by the main build.
+- `FORCE_WASM_BUILD` - Can be set to force a Wasm build. On subsequent calls the value of the variable
+                       needs to change. As wasm-builder instructs `cargo` to watch for file changes
+                       this environment variable should only be required in certain circumstances.
+- `WASM_BUILD_RUSTFLAGS` - Extend `RUSTFLAGS` given to `cargo build` while building the wasm binary.
+- `WASM_BUILD_NO_COLOR` - Disable color output of the wasm build.
+- `WASM_TARGET_DIRECTORY` - Will copy any build Wasm binary to the given directory. The path needs
+                           to be absolute.
+- `WASM_BUILD_TOOLCHAIN` - The toolchain that should be used to build the Wasm binaries. The
+                           format needs to be the same as used by cargo, e.g. `nightly-2020-02-20`.
+- `CARGO_NET_OFFLINE` - If `true`, `--offline` will be passed to all processes launched to prevent network access. Useful in offline environments.
+
+Each project can be skipped individually by using the environment variable `SKIP_PROJECT_NAME_WASM_BUILD`.
+Where `PROJECT_NAME` needs to be replaced by the name of the cargo project, e.g. `node-runtime` will
+be `NODE_RUNTIME`.
+
+## Prerequisites:
+
+Wasm builder requires the following prerequisites for building the Wasm binary:
+
+- rust nightly + `wasm32-unknown-unknown` toolchain
+
+or
+
+- rust stable and version at least 1.68.0 + `wasm32-unknown-unknown` toolchain
+
+If a specific rust is installed with `rustup`, it is important that the wasm target is
+installed as well. For example if installing the rust from 20.02.2020 using `rustup
+install nightly-2020-02-20`, the wasm target needs to be installed as well `rustup target add
+wasm32-unknown-unknown --toolchain nightly-2020-02-20`.
+
+License: Apache-2.0
diff --git a/substrate/utils/wasm-builder/src/builder.rs b/substrate/utils/wasm-builder/src/builder.rs
new file mode 100644
index 0000000000000000000000000000000000000000..208b56077669e19d5d61c490cbcc22bfa4bff471
--- /dev/null
+++ b/substrate/utils/wasm-builder/src/builder.rs
@@ -0,0 +1,289 @@
+// 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 std::{
+	env,
+	path::{Path, PathBuf},
+	process,
+};
+
+/// Returns the manifest dir from the `CARGO_MANIFEST_DIR` env.
+fn get_manifest_dir() -> PathBuf {
+	env::var("CARGO_MANIFEST_DIR")
+		.expect("`CARGO_MANIFEST_DIR` is always set for `build.rs` files; qed")
+		.into()
+}
+
+/// First step of the [`WasmBuilder`] to select the project to build.
+pub struct WasmBuilderSelectProject {
+	/// This parameter just exists to make it impossible to construct
+	/// this type outside of this crate.
+	_ignore: (),
+}
+
+impl WasmBuilderSelectProject {
+	/// Use the current project as project for building the WASM binary.
+	///
+	/// # Panics
+	///
+	/// Panics if the `CARGO_MANIFEST_DIR` variable is not set. This variable
+	/// is always set by `Cargo` in `build.rs` files.
+	pub fn with_current_project(self) -> WasmBuilder {
+		WasmBuilder {
+			rust_flags: Vec::new(),
+			file_name: None,
+			project_cargo_toml: get_manifest_dir().join("Cargo.toml"),
+			features_to_enable: Vec::new(),
+			disable_runtime_version_section_check: false,
+		}
+	}
+
+	/// Use the given `path` as project for building the WASM binary.
+	///
+	/// Returns an error if the given `path` does not points to a `Cargo.toml`.
+	pub fn with_project(self, path: impl Into<PathBuf>) -> Result<WasmBuilder, &'static str> {
+		let path = path.into();
+
+		if path.ends_with("Cargo.toml") && path.exists() {
+			Ok(WasmBuilder {
+				rust_flags: Vec::new(),
+				file_name: None,
+				project_cargo_toml: path,
+				features_to_enable: Vec::new(),
+				disable_runtime_version_section_check: false,
+			})
+		} else {
+			Err("Project path must point to the `Cargo.toml` of the project")
+		}
+	}
+}
+
+/// The builder for building a wasm binary.
+///
+/// The builder itself is separated into multiple structs to make the setup type safe.
+///
+/// Building a wasm binary:
+///
+/// 1. Call [`WasmBuilder::new`] to create a new builder.
+/// 2. Select the project to build using the methods of [`WasmBuilderSelectProject`].
+/// 3. Set additional `RUST_FLAGS` or a different name for the file containing the WASM code using
+///    methods of [`WasmBuilder`].
+/// 4. Build the WASM binary using [`Self::build`].
+pub struct WasmBuilder {
+	/// Flags that should be appended to `RUST_FLAGS` env variable.
+	rust_flags: Vec<String>,
+	/// The name of the file that is being generated in `OUT_DIR`.
+	///
+	/// Defaults to `wasm_binary.rs`.
+	file_name: Option<String>,
+	/// The path to the `Cargo.toml` of the project that should be built
+	/// for wasm.
+	project_cargo_toml: PathBuf,
+	/// Features that should be enabled when building the wasm binary.
+	features_to_enable: Vec<String>,
+	/// Should the builder not check that the `runtime_version` section exists in the wasm binary?
+	disable_runtime_version_section_check: bool,
+}
+
+impl WasmBuilder {
+	/// Create a new instance of the builder.
+	pub fn new() -> WasmBuilderSelectProject {
+		WasmBuilderSelectProject { _ignore: () }
+	}
+
+	/// Enable exporting `__heap_base` as global variable in the WASM binary.
+	///
+	/// This adds `-Clink-arg=--export=__heap_base` to `RUST_FLAGS`.
+	pub fn export_heap_base(mut self) -> Self {
+		self.rust_flags.push("-Clink-arg=--export=__heap_base".into());
+		self
+	}
+
+	/// Set the name of the file that will be generated in `OUT_DIR`.
+	///
+	/// This file needs to be included to get access to the build WASM binary.
+	///
+	/// If this function is not called, `file_name` defaults to `wasm_binary.rs`
+	pub fn set_file_name(mut self, file_name: impl Into<String>) -> Self {
+		self.file_name = Some(file_name.into());
+		self
+	}
+
+	/// Instruct the linker to import the memory into the WASM binary.
+	///
+	/// This adds `-C link-arg=--import-memory` to `RUST_FLAGS`.
+	pub fn import_memory(mut self) -> Self {
+		self.rust_flags.push("-C link-arg=--import-memory".into());
+		self
+	}
+
+	/// Append the given `flag` to `RUST_FLAGS`.
+	///
+	/// `flag` is appended as is, so it needs to be a valid flag.
+	pub fn append_to_rust_flags(mut self, flag: impl Into<String>) -> Self {
+		self.rust_flags.push(flag.into());
+		self
+	}
+
+	/// Enable the given feature when building the wasm binary.
+	///
+	/// `feature` needs to be a valid feature that is defined in the project `Cargo.toml`.
+	pub fn enable_feature(mut self, feature: impl Into<String>) -> Self {
+		self.features_to_enable.push(feature.into());
+		self
+	}
+
+	/// Disable the check for the `runtime_version` wasm section.
+	///
+	/// By default the `wasm-builder` will ensure that the `runtime_version` section will
+	/// exists in the build wasm binary. This `runtime_version` section is used to get the
+	/// `RuntimeVersion` without needing to call into the wasm binary. However, for some
+	/// use cases (like tests) you may want to disable this check.
+	pub fn disable_runtime_version_section_check(mut self) -> Self {
+		self.disable_runtime_version_section_check = true;
+		self
+	}
+
+	/// Build the WASM binary.
+	pub fn build(self) {
+		let out_dir = PathBuf::from(env::var("OUT_DIR").expect("`OUT_DIR` is set by cargo!"));
+		let file_path =
+			out_dir.join(self.file_name.clone().unwrap_or_else(|| "wasm_binary.rs".into()));
+
+		if check_skip_build() {
+			// If we skip the build, we still want to make sure to be called when an env variable
+			// changes
+			generate_rerun_if_changed_instructions();
+
+			provide_dummy_wasm_binary_if_not_exist(&file_path);
+
+			return
+		}
+
+		build_project(
+			file_path,
+			self.project_cargo_toml,
+			self.rust_flags.into_iter().map(|f| format!("{} ", f)).collect(),
+			self.features_to_enable,
+			self.file_name,
+			!self.disable_runtime_version_section_check,
+		);
+
+		// As last step we need to generate our `rerun-if-changed` stuff. If a build fails, we don't
+		// want to spam the output!
+		generate_rerun_if_changed_instructions();
+	}
+}
+
+/// Generate the name of the skip build environment variable for the current crate.
+fn generate_crate_skip_build_env_name() -> String {
+	format!(
+		"SKIP_{}_WASM_BUILD",
+		env::var("CARGO_PKG_NAME")
+			.expect("Package name is set")
+			.to_uppercase()
+			.replace('-', "_"),
+	)
+}
+
+/// Checks if the build of the WASM binary should be skipped.
+fn check_skip_build() -> bool {
+	env::var(crate::SKIP_BUILD_ENV).is_ok() ||
+		env::var(generate_crate_skip_build_env_name()).is_ok()
+}
+
+/// Provide a dummy WASM binary if there doesn't exist one.
+fn provide_dummy_wasm_binary_if_not_exist(file_path: &Path) {
+	if !file_path.exists() {
+		crate::write_file_if_changed(
+			file_path,
+			"pub const WASM_BINARY: Option<&[u8]> = None;\
+			 pub const WASM_BINARY_BLOATY: Option<&[u8]> = None;",
+		);
+	}
+}
+
+/// Generate the `rerun-if-changed` instructions for cargo to make sure that the WASM binary is
+/// rebuilt when needed.
+fn generate_rerun_if_changed_instructions() {
+	// Make sure that the `build.rs` is called again if one of the following env variables changes.
+	println!("cargo:rerun-if-env-changed={}", crate::SKIP_BUILD_ENV);
+	println!("cargo:rerun-if-env-changed={}", crate::FORCE_WASM_BUILD_ENV);
+	println!("cargo:rerun-if-env-changed={}", generate_crate_skip_build_env_name());
+}
+
+/// Build the currently built project as wasm binary.
+///
+/// The current project is determined by using the `CARGO_MANIFEST_DIR` environment variable.
+///
+/// `file_name` - The name + path of the file being generated. The file contains the
+/// constant `WASM_BINARY`, which contains the built wasm binary.
+///
+/// `project_cargo_toml` - The path to the `Cargo.toml` of the project that should be built.
+///
+/// `default_rustflags` - Default `RUSTFLAGS` that will always be set for the build.
+///
+/// `features_to_enable` - Features that should be enabled for the project.
+///
+/// `wasm_binary_name` - The optional wasm binary name that is extended with
+/// `.compact.compressed.wasm`. If `None`, the project name will be used.
+///
+/// `check_for_runtime_version_section` - Should the wasm binary be checked for the
+/// `runtime_version` section?
+fn build_project(
+	file_name: PathBuf,
+	project_cargo_toml: PathBuf,
+	default_rustflags: String,
+	features_to_enable: Vec<String>,
+	wasm_binary_name: Option<String>,
+	check_for_runtime_version_section: bool,
+) {
+	let cargo_cmd = match crate::prerequisites::check() {
+		Ok(cmd) => cmd,
+		Err(err_msg) => {
+			eprintln!("{}", err_msg);
+			process::exit(1);
+		},
+	};
+
+	let (wasm_binary, bloaty) = crate::wasm_project::create_and_compile(
+		&project_cargo_toml,
+		&default_rustflags,
+		cargo_cmd,
+		features_to_enable,
+		wasm_binary_name,
+		check_for_runtime_version_section,
+	);
+
+	let (wasm_binary, wasm_binary_bloaty) = if let Some(wasm_binary) = wasm_binary {
+		(wasm_binary.wasm_binary_path_escaped(), bloaty.wasm_binary_bloaty_path_escaped())
+	} else {
+		(bloaty.wasm_binary_bloaty_path_escaped(), bloaty.wasm_binary_bloaty_path_escaped())
+	};
+
+	crate::write_file_if_changed(
+		file_name,
+		format!(
+			r#"
+				pub const WASM_BINARY: Option<&[u8]> = Some(include_bytes!("{wasm_binary}"));
+				pub const WASM_BINARY_BLOATY: Option<&[u8]> = Some(include_bytes!("{wasm_binary_bloaty}"));
+			"#,
+			wasm_binary = wasm_binary,
+			wasm_binary_bloaty = wasm_binary_bloaty,
+		),
+	);
+}
diff --git a/substrate/utils/wasm-builder/src/lib.rs b/substrate/utils/wasm-builder/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..c9011f97be711d9338c3cd572f4c105a910ca581
--- /dev/null
+++ b/substrate/utils/wasm-builder/src/lib.rs
@@ -0,0 +1,334 @@
+// 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.
+
+//! # Wasm builder is a utility for building a project as a Wasm binary
+//!
+//! The Wasm builder is a tool that integrates the process of building the WASM binary of your
+//! project into the main `cargo` build process.
+//!
+//! ## Project setup
+//!
+//! A project that should be compiled as a Wasm binary needs to:
+//!
+//! 1. Add a `build.rs` file.
+//! 2. Add `wasm-builder` as dependency into `build-dependencies`.
+//!
+//! The `build.rs` file needs to contain the following code:
+//!
+//! ```no_run
+//! use substrate_wasm_builder::WasmBuilder;
+//!
+//! fn main() {
+//!     WasmBuilder::new()
+//!         // Tell the builder to build the project (crate) this `build.rs` is part of.
+//!         .with_current_project()
+//!         // Make sure to export the `heap_base` global, this is required by Substrate
+//!         .export_heap_base()
+//!         // Build the Wasm file so that it imports the memory (need to be provided by at instantiation)
+//!         .import_memory()
+//!         // Build it.
+//!         .build()
+//! }
+//! ```
+//!
+//! As the final step, you need to add the following to your project:
+//!
+//! ```ignore
+//! include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
+//! ```
+//!
+//! This will include the generated Wasm binary as two constants `WASM_BINARY` and
+//! `WASM_BINARY_BLOATY`. The former is a compact Wasm binary and the latter is the Wasm binary as
+//! being generated by the compiler. Both variables have `Option<&'static [u8]>` as type.
+//!
+//! ### Feature
+//!
+//! Wasm builder supports to enable cargo features while building the Wasm binary. By default it
+//! will enable all features in the wasm build that are enabled for the native build except the
+//! `default` and `std` features. Besides that, wasm builder supports the special `runtime-wasm`
+//! feature. This `runtime-wasm` feature will be enabled by the wasm builder when it compiles the
+//! Wasm binary. If this feature is not present, it will not be enabled.
+//!
+//! ## Environment variables
+//!
+//! By using environment variables, you can configure which Wasm binaries are built and how:
+//!
+//! - `SKIP_WASM_BUILD` - Skips building any Wasm binary. This is useful when only native should be
+//!   recompiled. If this is the first run and there doesn't exist a Wasm binary, this will set both
+//!   variables to `None`.
+//! - `WASM_BUILD_TYPE` - Sets the build type for building Wasm binaries. Supported values are
+//!   `release` or `debug`. By default the build type is equal to the build type used by the main
+//!   build.
+//! - `FORCE_WASM_BUILD` - Can be set to force a Wasm build. On subsequent calls the value of the
+//!   variable needs to change. As wasm-builder instructs `cargo` to watch for file changes this
+//!   environment variable should only be required in certain circumstances.
+//! - `WASM_BUILD_RUSTFLAGS` - Extend `RUSTFLAGS` given to `cargo build` while building the wasm
+//!   binary.
+//! - `WASM_BUILD_NO_COLOR` - Disable color output of the wasm build.
+//! - `WASM_TARGET_DIRECTORY` - Will copy any build Wasm binary to the given directory. The path
+//!   needs to be absolute.
+//! - `WASM_BUILD_TOOLCHAIN` - The toolchain that should be used to build the Wasm binaries. The
+//!   format needs to be the same as used by cargo, e.g. `nightly-2020-02-20`.
+//! - `WASM_BUILD_WORKSPACE_HINT` - Hint the workspace that is being built. This is normally not
+//!   required as we walk up from the target directory until we find a `Cargo.toml`. If the target
+//!   directory is changed for the build, this environment variable can be used to point to the
+//!   actual workspace.
+//! - `CARGO_NET_OFFLINE` - If `true`, `--offline` will be passed to all processes launched to
+//!   prevent network access. Useful in offline environments.
+//!
+//! Each project can be skipped individually by using the environment variable
+//! `SKIP_PROJECT_NAME_WASM_BUILD`. Where `PROJECT_NAME` needs to be replaced by the name of the
+//! cargo project, e.g. `kitchensink-runtime` will be `NODE_RUNTIME`.
+//!
+//! ## Prerequisites:
+//!
+//! Wasm builder requires the following prerequisites for building the Wasm binary:
+//!
+//! - rust nightly + `wasm32-unknown-unknown` toolchain
+//!
+//! or
+//!
+//! - rust stable and version at least 1.68.0 + `wasm32-unknown-unknown` toolchain
+//!
+//! If a specific rust is installed with `rustup`, it is important that the wasm target is
+//! installed as well. For example if installing the rust from 20.02.2020 using `rustup
+//! install nightly-2020-02-20`, the wasm target needs to be installed as well `rustup target add
+//! wasm32-unknown-unknown --toolchain nightly-2020-02-20`.
+
+use std::{
+	env, fs,
+	io::BufRead,
+	path::{Path, PathBuf},
+	process::Command,
+};
+use version::Version;
+
+mod builder;
+mod prerequisites;
+mod version;
+mod wasm_project;
+
+pub use builder::{WasmBuilder, WasmBuilderSelectProject};
+
+/// Environment variable that tells us to skip building the wasm binary.
+const SKIP_BUILD_ENV: &str = "SKIP_WASM_BUILD";
+
+/// Environment variable that tells us whether we should avoid network requests
+const OFFLINE: &str = "CARGO_NET_OFFLINE";
+
+/// Environment variable to force a certain build type when building the wasm binary.
+/// Expects "debug", "release" or "production" as value.
+///
+/// When unset the WASM binary uses the same build type as the main cargo build with
+/// the exception of a debug build: In this case the wasm build defaults to `release` in
+/// order to avoid a slowdown when not explicitly requested.
+const WASM_BUILD_TYPE_ENV: &str = "WASM_BUILD_TYPE";
+
+/// Environment variable to extend the `RUSTFLAGS` variable given to the wasm build.
+const WASM_BUILD_RUSTFLAGS_ENV: &str = "WASM_BUILD_RUSTFLAGS";
+
+/// Environment variable to set the target directory to copy the final wasm binary.
+///
+/// The directory needs to be an absolute path.
+const WASM_TARGET_DIRECTORY: &str = "WASM_TARGET_DIRECTORY";
+
+/// Environment variable to disable color output of the wasm build.
+const WASM_BUILD_NO_COLOR: &str = "WASM_BUILD_NO_COLOR";
+
+/// Environment variable to set the toolchain used to compile the wasm binary.
+const WASM_BUILD_TOOLCHAIN: &str = "WASM_BUILD_TOOLCHAIN";
+
+/// Environment variable that makes sure the WASM build is triggered.
+const FORCE_WASM_BUILD_ENV: &str = "FORCE_WASM_BUILD";
+
+/// Environment variable that hints the workspace we are building.
+const WASM_BUILD_WORKSPACE_HINT: &str = "WASM_BUILD_WORKSPACE_HINT";
+
+/// Write to the given `file` if the `content` is different.
+fn write_file_if_changed(file: impl AsRef<Path>, content: impl AsRef<str>) {
+	if fs::read_to_string(file.as_ref()).ok().as_deref() != Some(content.as_ref()) {
+		fs::write(file.as_ref(), content.as_ref())
+			.unwrap_or_else(|_| panic!("Writing `{}` can not fail!", file.as_ref().display()));
+	}
+}
+
+/// Copy `src` to `dst` if the `dst` does not exist or is different.
+fn copy_file_if_changed(src: PathBuf, dst: PathBuf) {
+	let src_file = fs::read_to_string(&src).ok();
+	let dst_file = fs::read_to_string(&dst).ok();
+
+	if src_file != dst_file {
+		fs::copy(&src, &dst).unwrap_or_else(|_| {
+			panic!("Copying `{}` to `{}` can not fail; qed", src.display(), dst.display())
+		});
+	}
+}
+
+/// Get a cargo command that should be used to invoke the compilation.
+fn get_cargo_command() -> CargoCommand {
+	let env_cargo =
+		CargoCommand::new(&env::var("CARGO").expect("`CARGO` env variable is always set by cargo"));
+	let default_cargo = CargoCommand::new("cargo");
+	let wasm_toolchain = env::var(WASM_BUILD_TOOLCHAIN).ok();
+
+	// First check if the user requested a specific toolchain
+	if let Some(cmd) =
+		wasm_toolchain.map(|t| CargoCommand::new_with_args("rustup", &["run", &t, "cargo"]))
+	{
+		cmd
+	} else if env_cargo.supports_substrate_wasm_env() {
+		env_cargo
+	} else if default_cargo.supports_substrate_wasm_env() {
+		default_cargo
+	} else {
+		// If no command before provided us with a cargo that supports our Substrate wasm env, we
+		// try to search one with rustup. If that fails as well, we return the default cargo and let
+		// the prequisities check fail.
+		get_rustup_command().unwrap_or(default_cargo)
+	}
+}
+
+/// Get the newest rustup command that supports our Substrate wasm env.
+///
+/// Stable versions are always favored over nightly versions even if the nightly versions are
+/// newer.
+fn get_rustup_command() -> Option<CargoCommand> {
+	let host = format!("-{}", env::var("HOST").expect("`HOST` is always set by cargo"));
+
+	let output = Command::new("rustup").args(&["toolchain", "list"]).output().ok()?.stdout;
+	let lines = output.as_slice().lines();
+
+	let mut versions = Vec::new();
+	for line in lines.filter_map(|l| l.ok()) {
+		let rustup_version = line.trim_end_matches(&host);
+
+		let cmd = CargoCommand::new_with_args("rustup", &["run", &rustup_version, "cargo"]);
+
+		if !cmd.supports_substrate_wasm_env() {
+			continue
+		}
+
+		let Some(cargo_version) = cmd.version() else { continue };
+
+		versions.push((cargo_version, rustup_version.to_string()));
+	}
+
+	// Sort by the parsed version to get the latest version (greatest version) at the end of the
+	// vec.
+	versions.sort_by_key(|v| v.0);
+	let version = &versions.last()?.1;
+
+	Some(CargoCommand::new_with_args("rustup", &["run", &version, "cargo"]))
+}
+
+/// Wraps a specific command which represents a cargo invocation.
+#[derive(Debug)]
+struct CargoCommand {
+	program: String,
+	args: Vec<String>,
+	version: Option<Version>,
+}
+
+impl CargoCommand {
+	fn new(program: &str) -> Self {
+		let version = Self::extract_version(program, &[]);
+
+		CargoCommand { program: program.into(), args: Vec::new(), version }
+	}
+
+	fn new_with_args(program: &str, args: &[&str]) -> Self {
+		let version = Self::extract_version(program, args);
+
+		CargoCommand {
+			program: program.into(),
+			args: args.iter().map(ToString::to_string).collect(),
+			version,
+		}
+	}
+
+	fn command(&self) -> Command {
+		let mut cmd = Command::new(&self.program);
+		cmd.args(&self.args);
+		cmd
+	}
+
+	fn extract_version(program: &str, args: &[&str]) -> Option<Version> {
+		let version = Command::new(program)
+			.args(args)
+			.arg("--version")
+			.output()
+			.ok()
+			.and_then(|o| String::from_utf8(o.stdout).ok())?;
+
+		Version::extract(&version)
+	}
+
+	/// Returns the version of this cargo command or `None` if it failed to extract the version.
+	fn version(&self) -> Option<Version> {
+		self.version
+	}
+
+	/// Check if the supplied cargo command supports our Substrate wasm environment.
+	///
+	/// This means that either the cargo version is at minimum 1.68.0 or this is a nightly cargo.
+	///
+	/// Assumes that cargo version matches the rustc version.
+	fn supports_substrate_wasm_env(&self) -> bool {
+		// `RUSTC_BOOTSTRAP` tells a stable compiler to behave like a nightly. So, when this env
+		// variable is set, we can assume that whatever rust compiler we have, it is a nightly
+		// compiler. For "more" information, see:
+		// https://github.com/rust-lang/rust/blob/fa0f7d0080d8e7e9eb20aa9cbf8013f96c81287f/src/libsyntax/feature_gate/check.rs#L891
+		if env::var("RUSTC_BOOTSTRAP").is_ok() {
+			return true
+		}
+
+		let Some(version) = self.version() else { return false };
+
+		// Check if major and minor are greater or equal than 1.68 or this is a nightly.
+		version.major > 1 || (version.major == 1 && version.minor >= 68) || version.is_nightly
+	}
+}
+
+/// Wraps a [`CargoCommand`] and the version of `rustc` the cargo command uses.
+struct CargoCommandVersioned {
+	command: CargoCommand,
+	version: String,
+}
+
+impl CargoCommandVersioned {
+	fn new(command: CargoCommand, version: String) -> Self {
+		Self { command, version }
+	}
+
+	/// Returns the `rustc` version.
+	fn rustc_version(&self) -> &str {
+		&self.version
+	}
+}
+
+impl std::ops::Deref for CargoCommandVersioned {
+	type Target = CargoCommand;
+
+	fn deref(&self) -> &CargoCommand {
+		&self.command
+	}
+}
+
+/// Returns `true` when color output is enabled.
+fn color_output_enabled() -> bool {
+	env::var(crate::WASM_BUILD_NO_COLOR).is_err()
+}
diff --git a/substrate/utils/wasm-builder/src/prerequisites.rs b/substrate/utils/wasm-builder/src/prerequisites.rs
new file mode 100644
index 0000000000000000000000000000000000000000..f5a985ab92b5d6b4b6b680aa5dad43eabef8cc4e
--- /dev/null
+++ b/substrate/utils/wasm-builder/src/prerequisites.rs
@@ -0,0 +1,180 @@
+// 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::{write_file_if_changed, CargoCommand, CargoCommandVersioned};
+
+use std::{fs, path::Path};
+
+use ansi_term::Color;
+use tempfile::tempdir;
+
+/// Print an error message.
+fn print_error_message(message: &str) -> String {
+	if super::color_output_enabled() {
+		Color::Red.bold().paint(message).to_string()
+	} else {
+		message.into()
+	}
+}
+
+/// Checks that all prerequisites are installed.
+///
+/// Returns the versioned cargo command on success.
+pub(crate) fn check() -> Result<CargoCommandVersioned, String> {
+	let cargo_command = crate::get_cargo_command();
+
+	if !cargo_command.supports_substrate_wasm_env() {
+		return Err(print_error_message(
+			"Cannot compile the WASM runtime: no compatible Rust compiler found!\n\
+			 Install at least Rust 1.68.0 or a recent nightly version.",
+		))
+	}
+
+	check_wasm_toolchain_installed(cargo_command)
+}
+
+/// Create the project that will be used to check that the wasm toolchain is installed and to
+/// extract the rustc version.
+fn create_check_toolchain_project(project_dir: &Path) {
+	let lib_rs_file = project_dir.join("src/lib.rs");
+	let main_rs_file = project_dir.join("src/main.rs");
+	let build_rs_file = project_dir.join("build.rs");
+	let manifest_path = project_dir.join("Cargo.toml");
+
+	write_file_if_changed(
+		&manifest_path,
+		r#"
+			[package]
+			name = "wasm-test"
+			version = "1.0.0"
+			edition = "2021"
+			build = "build.rs"
+
+			[lib]
+			name = "wasm_test"
+			crate-type = ["cdylib"]
+
+			[workspace]
+		"#,
+	);
+	write_file_if_changed(lib_rs_file, "pub fn test() {}");
+
+	// We want to know the rustc version of the rustc that is being used by our cargo command.
+	// The cargo command is determined by some *very* complex algorithm to find the cargo command
+	// that supports nightly.
+	// The best solution would be if there is a `cargo rustc --version` command, which sadly
+	// doesn't exists. So, the only available way of getting the rustc version is to build a project
+	// and capture the rustc version in this build process. This `build.rs` is exactly doing this.
+	// It gets the rustc version by calling `rustc --version` and exposing it in the `RUSTC_VERSION`
+	// environment variable.
+	write_file_if_changed(
+		build_rs_file,
+		r#"
+			fn main() {
+				let rustc_cmd = std::env::var("RUSTC").ok().unwrap_or_else(|| "rustc".into());
+
+				let rustc_version = std::process::Command::new(rustc_cmd)
+					.arg("--version")
+					.output()
+					.ok()
+					.and_then(|o| String::from_utf8(o.stdout).ok());
+
+				println!(
+					"cargo:rustc-env=RUSTC_VERSION={}",
+					rustc_version.unwrap_or_else(|| "unknown rustc version".into()),
+				);
+			}
+		"#,
+	);
+	// Just prints the `RURSTC_VERSION` environment variable that is being created by the
+	// `build.rs` script.
+	write_file_if_changed(
+		main_rs_file,
+		r#"
+			fn main() {
+				println!("{}", env!("RUSTC_VERSION"));
+			}
+		"#,
+	);
+}
+
+fn check_wasm_toolchain_installed(
+	cargo_command: CargoCommand,
+) -> Result<CargoCommandVersioned, String> {
+	let temp = tempdir().expect("Creating temp dir does not fail; qed");
+	fs::create_dir_all(temp.path().join("src")).expect("Creating src dir does not fail; qed");
+	create_check_toolchain_project(temp.path());
+
+	let err_msg = print_error_message("Rust WASM toolchain not installed, please install it!");
+	let manifest_path = temp.path().join("Cargo.toml").display().to_string();
+
+	let mut build_cmd = cargo_command.command();
+	// Chdir to temp to avoid including project's .cargo/config.toml
+	// by accident - it can happen in some CI environments.
+	build_cmd.current_dir(&temp);
+	build_cmd.args(&[
+		"build",
+		"--target=wasm32-unknown-unknown",
+		"--manifest-path",
+		&manifest_path,
+	]);
+
+	if super::color_output_enabled() {
+		build_cmd.arg("--color=always");
+	}
+
+	let mut run_cmd = cargo_command.command();
+	// Chdir to temp to avoid including project's .cargo/config.toml
+	// by accident - it can happen in some CI environments.
+	run_cmd.current_dir(&temp);
+	run_cmd.args(&["run", "--manifest-path", &manifest_path]);
+
+	// Unset the `CARGO_TARGET_DIR` to prevent a cargo deadlock
+	build_cmd.env_remove("CARGO_TARGET_DIR");
+	run_cmd.env_remove("CARGO_TARGET_DIR");
+
+	// Make sure the host's flags aren't used here, e.g. if an alternative linker is specified
+	// in the RUSTFLAGS then the check we do here will break unless we clear these.
+	build_cmd.env_remove("CARGO_ENCODED_RUSTFLAGS");
+	run_cmd.env_remove("CARGO_ENCODED_RUSTFLAGS");
+	build_cmd.env_remove("RUSTFLAGS");
+	run_cmd.env_remove("RUSTFLAGS");
+
+	build_cmd.output().map_err(|_| err_msg.clone()).and_then(|s| {
+		if s.status.success() {
+			let version = run_cmd.output().ok().and_then(|o| String::from_utf8(o.stdout).ok());
+			Ok(CargoCommandVersioned::new(
+				cargo_command,
+				version.unwrap_or_else(|| "unknown rustc version".into()),
+			))
+		} else {
+			match String::from_utf8(s.stderr) {
+				Ok(ref err) if err.contains("linker `rust-lld` not found") =>
+					Err(print_error_message("`rust-lld` not found, please install it!")),
+				Ok(ref err) => Err(format!(
+					"{}\n\n{}\n{}\n{}{}\n",
+					err_msg,
+					Color::Yellow.bold().paint("Further error information:"),
+					Color::Yellow.bold().paint("-".repeat(60)),
+					err,
+					Color::Yellow.bold().paint("-".repeat(60)),
+				)),
+				Err(_) => Err(err_msg),
+			}
+		}
+	})
+}
diff --git a/substrate/utils/wasm-builder/src/version.rs b/substrate/utils/wasm-builder/src/version.rs
new file mode 100644
index 0000000000000000000000000000000000000000..e4f7d98be61876840a9ca70f3e29176ba92c5a99
--- /dev/null
+++ b/substrate/utils/wasm-builder/src/version.rs
@@ -0,0 +1,215 @@
+// 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 std::cmp::Ordering;
+
+/// The version of rustc/cargo.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Version {
+	pub major: u32,
+	pub minor: u32,
+	pub patch: u32,
+	pub is_nightly: bool,
+	pub year: Option<u32>,
+	pub month: Option<u32>,
+	pub day: Option<u32>,
+}
+
+impl Version {
+	/// Returns if `self` is a stable version.
+	pub fn is_stable(&self) -> bool {
+		!self.is_nightly
+	}
+
+	/// Return if `self` is a nightly version.
+	pub fn is_nightly(&self) -> bool {
+		self.is_nightly
+	}
+
+	/// Extract from the given `version` string.
+	pub fn extract(version: &str) -> Option<Self> {
+		let mut is_nightly = false;
+		let version_parts = version
+			.trim()
+			.split(" ")
+			.nth(1)?
+			.split(".")
+			.filter_map(|v| {
+				if let Some(rest) = v.strip_suffix("-nightly") {
+					is_nightly = true;
+					rest.parse().ok()
+				} else {
+					v.parse().ok()
+				}
+			})
+			.collect::<Vec<u32>>();
+
+		if version_parts.len() != 3 {
+			return None
+		}
+
+		let date_parts = version
+			.split(" ")
+			.nth(3)
+			.map(|date| {
+				date.split("-")
+					.filter_map(|v| v.trim().strip_suffix(")").unwrap_or(v).parse().ok())
+					.collect::<Vec<u32>>()
+			})
+			.unwrap_or_default();
+
+		Some(Version {
+			major: version_parts[0],
+			minor: version_parts[1],
+			patch: version_parts[2],
+			is_nightly,
+			year: date_parts.get(0).copied(),
+			month: date_parts.get(1).copied(),
+			day: date_parts.get(2).copied(),
+		})
+	}
+}
+
+/// Ordering is done in the following way:
+///
+/// 1. `stable` > `nightly`
+/// 2. Then compare major, minor and patch.
+/// 3. Last compare the date.
+impl Ord for Version {
+	fn cmp(&self, other: &Self) -> Ordering {
+		if self == other {
+			return Ordering::Equal
+		}
+
+		// Ensure that `stable > nightly`
+		if self.is_stable() && other.is_nightly() {
+			return Ordering::Greater
+		} else if self.is_nightly() && other.is_stable() {
+			return Ordering::Less
+		}
+
+		let to_compare = [
+			(Some(self.major), Some(other.major)),
+			(Some(self.minor), Some(other.minor)),
+			(Some(self.patch), Some(other.patch)),
+			(self.year, other.year),
+			(self.month, other.month),
+			(self.day, other.day),
+		];
+
+		to_compare
+			.iter()
+			.find_map(|(l, r)| if l != r { l.partial_cmp(&r) } else { None })
+			// We already checked this right at the beginning, so we should never return here
+			// `Equal`.
+			.unwrap_or(Ordering::Equal)
+	}
+}
+
+impl PartialOrd for Version {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(self.cmp(other))
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn version_compare_and_extract_works() {
+		let version_1_66_0 = Version::extract("cargo 1.66.0 (d65d197ad 2022-11-15)").unwrap();
+		let version_1_66_1 = Version::extract("cargo 1.66.1 (d65d197ad 2022-11-15)").unwrap();
+		let version_1_66_0_nightly =
+			Version::extract("cargo 1.66.0-nightly (d65d197ad 2022-10-15)").unwrap();
+		let version_1_66_0_nightly_older_date =
+			Version::extract("cargo 1.66.0-nightly (d65d197ad 2022-10-14)").unwrap();
+		let version_1_65_0 = Version::extract("cargo 1.65.0 (d65d197ad 2022-10-15)").unwrap();
+		let version_1_65_0_older_date =
+			Version::extract("cargo 1.65.0 (d65d197ad 2022-10-14)").unwrap();
+
+		assert!(version_1_66_1 > version_1_66_0);
+		assert!(version_1_66_1 > version_1_65_0);
+		assert!(version_1_66_1 > version_1_66_0_nightly);
+		assert!(version_1_66_1 > version_1_66_0_nightly_older_date);
+		assert!(version_1_66_1 > version_1_65_0_older_date);
+
+		assert!(version_1_66_0 > version_1_65_0);
+		assert!(version_1_66_0 > version_1_66_0_nightly);
+		assert!(version_1_66_0 > version_1_66_0_nightly_older_date);
+		assert!(version_1_66_0 > version_1_65_0_older_date);
+
+		assert!(version_1_65_0 > version_1_66_0_nightly);
+		assert!(version_1_65_0 > version_1_66_0_nightly_older_date);
+		assert!(version_1_65_0 > version_1_65_0_older_date);
+
+		let mut versions = vec![
+			version_1_66_0,
+			version_1_66_0_nightly,
+			version_1_66_0_nightly_older_date,
+			version_1_65_0_older_date,
+			version_1_65_0,
+			version_1_66_1,
+		];
+		versions.sort_by(|a, b| b.cmp(a));
+
+		let expected_versions_order = vec![
+			version_1_66_1,
+			version_1_66_0,
+			version_1_65_0,
+			version_1_65_0_older_date,
+			version_1_66_0_nightly,
+			version_1_66_0_nightly_older_date,
+		];
+		assert_eq!(expected_versions_order, versions);
+	}
+
+	#[test]
+	fn parse_with_newline() {
+		let version_1_66_0 = Version::extract("cargo 1.66.0 (d65d197ad 2022-11-15)\n").unwrap();
+		assert_eq!(
+			Version {
+				major: 1,
+				minor: 66,
+				patch: 0,
+				is_nightly: false,
+				year: Some(2022),
+				month: Some(11),
+				day: Some(15),
+			},
+			version_1_66_0,
+		);
+	}
+
+	#[test]
+	fn version_without_hash_and_date() {
+		// Apparently there are installations that print without the hash and date.
+		let version_1_69_0 = Version::extract("cargo 1.69.0-nightly").unwrap();
+		assert_eq!(
+			Version {
+				major: 1,
+				minor: 69,
+				patch: 0,
+				is_nightly: true,
+				year: None,
+				month: None,
+				day: None,
+			},
+			version_1_69_0,
+		);
+	}
+}
diff --git a/substrate/utils/wasm-builder/src/wasm_project.rs b/substrate/utils/wasm-builder/src/wasm_project.rs
new file mode 100644
index 0000000000000000000000000000000000000000..849af853c6da4647df7bd8bdd0135e6e1e8ac381
--- /dev/null
+++ b/substrate/utils/wasm-builder/src/wasm_project.rs
@@ -0,0 +1,930 @@
+// 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::{write_file_if_changed, CargoCommandVersioned, OFFLINE};
+
+use build_helper::rerun_if_changed;
+use cargo_metadata::{CargoOpt, Metadata, MetadataCommand};
+use parity_wasm::elements::{deserialize_buffer, Module};
+use std::{
+	borrow::ToOwned,
+	collections::HashSet,
+	env, fs,
+	hash::{Hash, Hasher},
+	ops::Deref,
+	path::{Path, PathBuf},
+	process,
+};
+use strum::{EnumIter, IntoEnumIterator};
+use toml::value::Table;
+use walkdir::WalkDir;
+
+/// Colorize an info message.
+///
+/// Returns the colorized message.
+fn colorize_info_message(message: &str) -> String {
+	if super::color_output_enabled() {
+		ansi_term::Color::Yellow.bold().paint(message).to_string()
+	} else {
+		message.into()
+	}
+}
+
+/// Holds the path to the bloaty WASM binary.
+pub struct WasmBinaryBloaty(PathBuf);
+
+impl WasmBinaryBloaty {
+	/// Returns the escaped path to the bloaty wasm binary.
+	pub fn wasm_binary_bloaty_path_escaped(&self) -> String {
+		self.0.display().to_string().escape_default().to_string()
+	}
+
+	/// Returns the path to the wasm binary.
+	pub fn wasm_binary_bloaty_path(&self) -> &Path {
+		&self.0
+	}
+}
+
+/// Holds the path to the WASM binary.
+pub struct WasmBinary(PathBuf);
+
+impl WasmBinary {
+	/// Returns the path to the wasm binary.
+	pub fn wasm_binary_path(&self) -> &Path {
+		&self.0
+	}
+
+	/// Returns the escaped path to the wasm binary.
+	pub fn wasm_binary_path_escaped(&self) -> String {
+		self.0.display().to_string().escape_default().to_string()
+	}
+}
+
+fn crate_metadata(cargo_manifest: &Path) -> Metadata {
+	let mut cargo_lock = cargo_manifest.to_path_buf();
+	cargo_lock.set_file_name("Cargo.lock");
+
+	let cargo_lock_existed = cargo_lock.exists();
+
+	// If we can find a `Cargo.lock`, we assume that this is the workspace root and there exists a
+	// `Cargo.toml` that we can use for getting the metadata.
+	let cargo_manifest = if let Some(mut cargo_lock) = find_cargo_lock(cargo_manifest) {
+		cargo_lock.set_file_name("Cargo.toml");
+		cargo_lock
+	} else {
+		cargo_manifest.to_path_buf()
+	};
+
+	let mut crate_metadata_command = create_metadata_command(cargo_manifest);
+	crate_metadata_command.features(CargoOpt::AllFeatures);
+
+	let crate_metadata = crate_metadata_command
+		.exec()
+		.expect("`cargo metadata` can not fail on project `Cargo.toml`; qed");
+	// If the `Cargo.lock` didn't exist, we need to remove it after
+	// calling `cargo metadata`. This is required to ensure that we don't change
+	// the build directory outside of the `target` folder. Commands like
+	// `cargo publish` require this.
+	if !cargo_lock_existed {
+		let _ = fs::remove_file(&cargo_lock);
+	}
+
+	crate_metadata
+}
+
+/// Creates the WASM project, compiles the WASM binary and compacts the WASM binary.
+///
+/// # Returns
+///
+/// The path to the compact WASM binary and the bloaty WASM binary.
+pub(crate) fn create_and_compile(
+	project_cargo_toml: &Path,
+	default_rustflags: &str,
+	cargo_cmd: CargoCommandVersioned,
+	features_to_enable: Vec<String>,
+	wasm_binary_name: Option<String>,
+	check_for_runtime_version_section: bool,
+) -> (Option<WasmBinary>, WasmBinaryBloaty) {
+	let wasm_workspace_root = get_wasm_workspace_root();
+	let wasm_workspace = wasm_workspace_root.join("wbuild");
+
+	let crate_metadata = crate_metadata(project_cargo_toml);
+
+	let project = create_project(
+		project_cargo_toml,
+		&wasm_workspace,
+		&crate_metadata,
+		crate_metadata.workspace_root.as_ref(),
+		features_to_enable,
+	);
+
+	let profile = build_project(&project, default_rustflags, cargo_cmd);
+	let (wasm_binary, wasm_binary_compressed, bloaty) =
+		compact_wasm_file(&project, profile, project_cargo_toml, wasm_binary_name);
+
+	if check_for_runtime_version_section {
+		ensure_runtime_version_wasm_section_exists(bloaty.wasm_binary_bloaty_path());
+	}
+
+	wasm_binary
+		.as_ref()
+		.map(|wasm_binary| copy_wasm_to_target_directory(project_cargo_toml, wasm_binary));
+
+	wasm_binary_compressed.as_ref().map(|wasm_binary_compressed| {
+		copy_wasm_to_target_directory(project_cargo_toml, wasm_binary_compressed)
+	});
+
+	let final_wasm_binary = wasm_binary_compressed.or(wasm_binary);
+
+	generate_rerun_if_changed_instructions(
+		project_cargo_toml,
+		&project,
+		&wasm_workspace,
+		final_wasm_binary.as_ref(),
+		&bloaty,
+	);
+
+	if let Err(err) = adjust_mtime(&bloaty, final_wasm_binary.as_ref()) {
+		build_helper::warning!("Error while adjusting the mtime of the wasm binaries: {}", err)
+	}
+
+	(final_wasm_binary, bloaty)
+}
+
+/// Ensures that the `runtime_version` wasm section exists in the given wasm file.
+///
+/// If the section can not be found, it will print an error and exit the builder.
+fn ensure_runtime_version_wasm_section_exists(wasm: &Path) {
+	let wasm_blob = fs::read(wasm).expect("`{wasm}` was just written and should exist; qed");
+
+	let module: Module = match deserialize_buffer(&wasm_blob) {
+		Ok(m) => m,
+		Err(e) => {
+			println!("Failed to deserialize `{}`: {e:?}", wasm.display());
+			process::exit(1);
+		},
+	};
+
+	if !module.custom_sections().any(|cs| cs.name() == "runtime_version") {
+		println!(
+			"Couldn't find the `runtime_version` wasm section. \
+				  Please ensure that you are using the `sp_version::runtime_version` attribute macro!"
+		);
+		process::exit(1);
+	}
+}
+
+/// Adjust the mtime of the bloaty and compressed/compact wasm files.
+///
+/// We add the bloaty and the compressed/compact wasm file to the `rerun-if-changed` files.
+/// Cargo/Rustc determines based on the timestamp of the `invoked.timestamp` file that can be found
+/// in the `OUT_DIR/..`, if it needs to rerun a `build.rs` script. The problem is that this
+/// `invoked.timestamp` is created when the `build.rs` is executed and the wasm binaries are created
+/// later. This leads to them having a later mtime than the `invoked.timestamp` file and thus,
+/// cargo/rustc always re-executes the `build.rs` script. To hack around this, we copy the mtime of
+/// the `invoked.timestamp` to the wasm binaries.
+fn adjust_mtime(
+	bloaty_wasm: &WasmBinaryBloaty,
+	compressed_or_compact_wasm: Option<&WasmBinary>,
+) -> std::io::Result<()> {
+	let out_dir = build_helper::out_dir();
+	let invoked_timestamp = out_dir.join("../invoked.timestamp");
+
+	// Get the mtime of the `invoked.timestamp`
+	let metadata = fs::metadata(invoked_timestamp)?;
+	let mtime = filetime::FileTime::from_last_modification_time(&metadata);
+
+	filetime::set_file_mtime(bloaty_wasm.wasm_binary_bloaty_path(), mtime)?;
+	if let Some(binary) = compressed_or_compact_wasm.as_ref() {
+		filetime::set_file_mtime(binary.wasm_binary_path(), mtime)?;
+	}
+
+	Ok(())
+}
+
+/// Find the `Cargo.lock` relative to the `OUT_DIR` environment variable.
+///
+/// If the `Cargo.lock` cannot be found, we emit a warning and return `None`.
+fn find_cargo_lock(cargo_manifest: &Path) -> Option<PathBuf> {
+	fn find_impl(mut path: PathBuf) -> Option<PathBuf> {
+		loop {
+			if path.join("Cargo.lock").exists() {
+				return Some(path.join("Cargo.lock"))
+			}
+
+			if !path.pop() {
+				return None
+			}
+		}
+	}
+
+	if let Ok(workspace) = env::var(crate::WASM_BUILD_WORKSPACE_HINT) {
+		let path = PathBuf::from(workspace);
+
+		if path.join("Cargo.lock").exists() {
+			return Some(path.join("Cargo.lock"))
+		} else {
+			build_helper::warning!(
+				"`{}` env variable doesn't point to a directory that contains a `Cargo.lock`.",
+				crate::WASM_BUILD_WORKSPACE_HINT,
+			);
+		}
+	}
+
+	if let Some(path) = find_impl(build_helper::out_dir()) {
+		return Some(path)
+	}
+
+	build_helper::warning!(
+		"Could not find `Cargo.lock` for `{}`, while searching from `{}`. \
+		 To fix this, point the `{}` env variable to the directory of the workspace being compiled.",
+		cargo_manifest.display(),
+		build_helper::out_dir().display(),
+		crate::WASM_BUILD_WORKSPACE_HINT,
+	);
+
+	None
+}
+
+/// Extract the crate name from the given `Cargo.toml`.
+fn get_crate_name(cargo_manifest: &Path) -> 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 package = cargo_toml
+		.get("package")
+		.and_then(|t| t.as_table())
+		.expect("`package` key exists in valid `Cargo.toml`; qed");
+
+	package
+		.get("name")
+		.and_then(|p| p.as_str())
+		.map(ToOwned::to_owned)
+		.expect("Package name exists; qed")
+}
+
+/// Returns the name for the wasm binary.
+fn get_wasm_binary_name(cargo_manifest: &Path) -> String {
+	get_crate_name(cargo_manifest).replace('-', "_")
+}
+
+/// Returns the root path of the wasm workspace.
+fn get_wasm_workspace_root() -> PathBuf {
+	let mut out_dir = build_helper::out_dir();
+
+	loop {
+		match out_dir.parent() {
+			Some(parent) if out_dir.ends_with("build") => return parent.to_path_buf(),
+			_ =>
+				if !out_dir.pop() {
+					break
+				},
+		}
+	}
+
+	panic!("Could not find target dir in: {}", build_helper::out_dir().display())
+}
+
+fn create_project_cargo_toml(
+	wasm_workspace: &Path,
+	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(
+		&fs::read_to_string(workspace_root_path.join("Cargo.toml"))
+			.expect("Workspace root `Cargo.toml` exists; qed"),
+	)
+	.expect("Workspace root `Cargo.toml` is a valid toml file; qed");
+
+	let mut wasm_workspace_toml = Table::new();
+
+	// Add different profiles which are selected by setting `WASM_BUILD_TYPE`.
+	let mut release_profile = Table::new();
+	release_profile.insert("panic".into(), "abort".into());
+	release_profile.insert("lto".into(), "thin".into());
+
+	let mut production_profile = Table::new();
+	production_profile.insert("inherits".into(), "release".into());
+	production_profile.insert("lto".into(), "fat".into());
+	production_profile.insert("codegen-units".into(), 1.into());
+
+	let mut dev_profile = Table::new();
+	dev_profile.insert("panic".into(), "abort".into());
+
+	let mut profile = Table::new();
+	profile.insert("release".into(), release_profile.into());
+	profile.insert("production".into(), production_profile.into());
+	profile.insert("dev".into(), dev_profile.into());
+
+	wasm_workspace_toml.insert("profile".into(), profile.into());
+
+	// Add patch section from the project root `Cargo.toml`
+	while let Some(mut patch) =
+		workspace_toml.remove("patch").and_then(|p| p.try_into::<Table>().ok())
+	{
+		// Iterate over all patches and make the patch path absolute from the workspace root path.
+		patch
+			.iter_mut()
+			.filter_map(|p| {
+				p.1.as_table_mut().map(|t| t.iter_mut().filter_map(|t| t.1.as_table_mut()))
+			})
+			.flatten()
+			.for_each(|p| {
+				p.iter_mut().filter(|(k, _)| k == &"path").for_each(|(_, v)| {
+					if let Some(path) = v.as_str().map(PathBuf::from) {
+						if path.is_relative() {
+							*v = workspace_root_path.join(path).display().to_string().into();
+						}
+					}
+				})
+			});
+
+		wasm_workspace_toml.insert("patch".into(), patch.into());
+	}
+
+	let mut package = Table::new();
+	package.insert("name".into(), format!("{}-wasm", crate_name).into());
+	package.insert("version".into(), "1.0.0".into());
+	package.insert("edition".into(), "2021".into());
+
+	wasm_workspace_toml.insert("package".into(), package.into());
+
+	let mut lib = Table::new();
+	lib.insert("name".into(), wasm_binary.into());
+	lib.insert("crate-type".into(), vec!["cdylib".to_string()].into());
+
+	wasm_workspace_toml.insert("lib".into(), lib.into());
+
+	let mut dependencies = Table::new();
+
+	let mut wasm_project = Table::new();
+	wasm_project.insert("package".into(), crate_name.into());
+	wasm_project.insert("path".into(), crate_path.display().to_string().into());
+	wasm_project.insert("default-features".into(), false.into());
+	wasm_project.insert("features".into(), enabled_features.collect::<Vec<_>>().into());
+
+	dependencies.insert("wasm-project".into(), wasm_project.into());
+
+	wasm_workspace_toml.insert("dependencies".into(), dependencies.into());
+
+	wasm_workspace_toml.insert("workspace".into(), Table::new().into());
+
+	write_file_if_changed(
+		wasm_workspace.join("Cargo.toml"),
+		toml::to_string_pretty(&wasm_workspace_toml).expect("Wasm workspace toml is valid; qed"),
+	);
+}
+
+/// Find a package by the given `manifest_path` in the metadata. In case it can't be found by its
+/// manifest_path, fallback to finding it by name; this is necessary during publish because the
+/// package's manifest path will be *generated* within a specific packaging directory, thus it won't
+/// be found by its original path anymore.
+///
+/// Panics if the package could not be found.
+fn find_package_by_manifest_path<'a>(
+	pkg_name: &str,
+	manifest_path: &Path,
+	crate_metadata: &'a cargo_metadata::Metadata,
+) -> &'a cargo_metadata::Package {
+	if let Some(pkg) = crate_metadata.packages.iter().find(|p| p.manifest_path == manifest_path) {
+		return pkg
+	}
+
+	let pkgs_by_name = crate_metadata
+		.packages
+		.iter()
+		.filter(|p| p.name == pkg_name)
+		.collect::<Vec<_>>();
+
+	if let Some(pkg) = pkgs_by_name.first() {
+		if pkgs_by_name.len() > 1 {
+			panic!(
+				"Found multiple packages matching the name {pkg_name} ({manifest_path:?}): {:?}",
+				pkgs_by_name
+			);
+		} else {
+			return pkg
+		}
+	} else {
+		panic!("Failed to find entry for package {pkg_name} ({manifest_path:?}).");
+	}
+}
+
+/// Get a list of enabled features for the project.
+fn project_enabled_features(
+	pkg_name: &str,
+	cargo_manifest: &Path,
+	crate_metadata: &cargo_metadata::Metadata,
+) -> Vec<String> {
+	let package = find_package_by_manifest_path(pkg_name, cargo_manifest, crate_metadata);
+
+	let std_enabled = package.features.get("std");
+
+	let mut enabled_features = package
+		.features
+		.iter()
+		.filter(|(f, v)| {
+			let mut feature_env = f.replace("-", "_");
+			feature_env.make_ascii_uppercase();
+
+			// If this is a feature that corresponds only to an optional dependency
+			// and this feature is enabled by the `std` feature, we assume that this
+			// is only done through the `std` feature. This is a bad heuristic and should
+			// be removed after namespaced features are landed:
+			// https://doc.rust-lang.org/cargo/reference/unstable.html#namespaced-features
+			// Then we can just express this directly in the `Cargo.toml` and do not require
+			// this heuristic anymore. However, for the transition phase between now and namespaced
+			// features already being present in nightly, we need this code to make
+			// runtimes compile with all the possible rustc versions.
+			if v.len() == 1 &&
+				v.get(0).map_or(false, |v| *v == format!("dep:{}", f)) &&
+				std_enabled.as_ref().map(|e| e.iter().any(|ef| ef == *f)).unwrap_or(false)
+			{
+				return false
+			}
+
+			// We don't want to enable the `std`/`default` feature for the wasm build and
+			// we need to check if the feature is enabled by checking the env variable.
+			*f != "std" &&
+				*f != "default" && env::var(format!("CARGO_FEATURE_{}", feature_env))
+				.map(|v| v == "1")
+				.unwrap_or_default()
+		})
+		.map(|d| d.0.clone())
+		.collect::<Vec<_>>();
+
+	enabled_features.sort();
+	enabled_features
+}
+
+/// Returns if the project has the `runtime-wasm` feature
+fn has_runtime_wasm_feature_declared(
+	pkg_name: &str,
+	cargo_manifest: &Path,
+	crate_metadata: &cargo_metadata::Metadata,
+) -> bool {
+	let package = find_package_by_manifest_path(pkg_name, cargo_manifest, crate_metadata);
+
+	package.features.keys().any(|k| k == "runtime-wasm")
+}
+
+/// Create the project used to build the wasm binary.
+///
+/// # Returns
+///
+/// The path to the created wasm project.
+fn create_project(
+	project_cargo_toml: &Path,
+	wasm_workspace: &Path,
+	crate_metadata: &Metadata,
+	workspace_root_path: &Path,
+	features_to_enable: Vec<String>,
+) -> 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_wasm_binary_name(project_cargo_toml);
+	let wasm_project_folder = wasm_workspace.join(&crate_name);
+
+	fs::create_dir_all(wasm_project_folder.join("src"))
+		.expect("Wasm project dir create can not fail; qed");
+
+	let mut enabled_features =
+		project_enabled_features(&crate_name, project_cargo_toml, crate_metadata);
+
+	if has_runtime_wasm_feature_declared(&crate_name, project_cargo_toml, crate_metadata) {
+		enabled_features.push("runtime-wasm".into());
+	}
+
+	let mut enabled_features = enabled_features.into_iter().collect::<HashSet<_>>();
+	enabled_features.extend(features_to_enable.into_iter());
+
+	create_project_cargo_toml(
+		&wasm_project_folder,
+		workspace_root_path,
+		&crate_name,
+		crate_path,
+		&wasm_binary,
+		enabled_features.into_iter(),
+	);
+
+	write_file_if_changed(
+		wasm_project_folder.join("src/lib.rs"),
+		"#![no_std] pub use wasm_project::*;",
+	);
+
+	if let Some(crate_lock_file) = find_cargo_lock(project_cargo_toml) {
+		// Use the `Cargo.lock` of the main project.
+		crate::copy_file_if_changed(crate_lock_file, wasm_project_folder.join("Cargo.lock"));
+	}
+
+	wasm_project_folder
+}
+
+/// The cargo profile that is used to build the wasm project.
+#[derive(Debug, EnumIter)]
+enum Profile {
+	/// The `--profile dev` profile.
+	Debug,
+	/// The `--profile release` profile.
+	Release,
+	/// The `--profile production` profile.
+	Production,
+}
+
+impl Profile {
+	/// Create a profile by detecting which profile is used for the main build.
+	///
+	/// We cannot easily determine the profile that is used by the main cargo invocation
+	/// because the `PROFILE` environment variable won't contain any custom profiles like
+	/// "production". It would only contain the builtin profile where the custom profile
+	/// inherits from. This is why we inspect the build path to learn which profile is used.
+	///
+	/// # Note
+	///
+	/// Can be overriden by setting [`crate::WASM_BUILD_TYPE_ENV`].
+	fn detect(wasm_project: &Path) -> Profile {
+		let (name, overriden) = if let Ok(name) = env::var(crate::WASM_BUILD_TYPE_ENV) {
+			(name, true)
+		} else {
+			// First go backwards to the beginning of the target directory.
+			// Then go forwards to find the "wbuild" directory.
+			// We need to go backwards first because when starting from the root there
+			// might be a chance that someone has a "wbuild" directory somewhere in the path.
+			let name = wasm_project
+				.components()
+				.rev()
+				.take_while(|c| c.as_os_str() != "target")
+				.collect::<Vec<_>>()
+				.iter()
+				.rev()
+				.take_while(|c| c.as_os_str() != "wbuild")
+				.last()
+				.expect("We put the wasm project within a `target/.../wbuild` path; qed")
+				.as_os_str()
+				.to_str()
+				.expect("All our profile directory names are ascii; qed")
+				.to_string();
+			(name, false)
+		};
+		match (Profile::iter().find(|p| p.directory() == name), overriden) {
+			// When not overriden by a env variable we default to using the `Release` profile
+			// for the wasm build even when the main build uses the debug build. This
+			// is because the `Debug` profile is too slow for normal development activities.
+			(Some(Profile::Debug), false) => Profile::Release,
+			// For any other profile or when overriden we take it at face value.
+			(Some(profile), _) => profile,
+			// For non overriden unknown profiles we fall back to `Release`.
+			// This allows us to continue building when a custom profile is used for the
+			// main builds cargo. When explicitly passing a profile via env variable we are
+			// not doing a fallback.
+			(None, false) => {
+				let profile = Profile::Release;
+				build_helper::warning!(
+					"Unknown cargo profile `{}`. Defaulted to `{:?}` for the runtime build.",
+					name,
+					profile,
+				);
+				profile
+			},
+			// Invalid profile specified.
+			(None, true) => {
+				// We use println! + exit instead of a panic in order to have a cleaner output.
+				println!(
+					"Unexpected profile name: `{}`. One of the following is expected: {:?}",
+					name,
+					Profile::iter().map(|p| p.directory()).collect::<Vec<_>>(),
+				);
+				process::exit(1);
+			},
+		}
+	}
+
+	/// The name of the profile as supplied to the cargo `--profile` cli option.
+	fn name(&self) -> &'static str {
+		match self {
+			Self::Debug => "dev",
+			Self::Release => "release",
+			Self::Production => "production",
+		}
+	}
+
+	/// The sub directory within `target` where cargo places the build output.
+	///
+	/// # Note
+	///
+	/// Usually this is the same as [`Self::name`] with the exception of the debug
+	/// profile which is called `dev`.
+	fn directory(&self) -> &'static str {
+		match self {
+			Self::Debug => "debug",
+			_ => self.name(),
+		}
+	}
+
+	/// Whether the resulting binary should be compacted and compressed.
+	fn wants_compact(&self) -> bool {
+		!matches!(self, Self::Debug)
+	}
+}
+
+/// Check environment whether we should build without network
+fn offline_build() -> bool {
+	env::var(OFFLINE).map_or(false, |v| v == "true")
+}
+
+/// Build the project to create the WASM binary.
+fn build_project(
+	project: &Path,
+	default_rustflags: &str,
+	cargo_cmd: CargoCommandVersioned,
+) -> Profile {
+	let manifest_path = project.join("Cargo.toml");
+	let mut build_cmd = cargo_cmd.command();
+
+	let rustflags = format!(
+		"-C target-cpu=mvp -C target-feature=-sign-ext -C link-arg=--export-table {} {}",
+		default_rustflags,
+		env::var(crate::WASM_BUILD_RUSTFLAGS_ENV).unwrap_or_default(),
+	);
+
+	build_cmd
+		.args(&["rustc", "--target=wasm32-unknown-unknown"])
+		.arg(format!("--manifest-path={}", manifest_path.display()))
+		.env("RUSTFLAGS", rustflags)
+		// Unset the `CARGO_TARGET_DIR` to prevent a cargo deadlock (cargo locks a target dir
+		// exclusive). The runner project is created in `CARGO_TARGET_DIR` and executing it will
+		// create a sub target directory inside of `CARGO_TARGET_DIR`.
+		.env_remove("CARGO_TARGET_DIR")
+		// As we are being called inside a build-script, this env variable is set. However, we set
+		// our own `RUSTFLAGS` and thus, we need to remove this. Otherwise cargo favors this
+		// env variable.
+		.env_remove("CARGO_ENCODED_RUSTFLAGS")
+		// We don't want to call ourselves recursively
+		.env(crate::SKIP_BUILD_ENV, "");
+
+	if super::color_output_enabled() {
+		build_cmd.arg("--color=always");
+	}
+
+	let profile = Profile::detect(project);
+	build_cmd.arg("--profile");
+	build_cmd.arg(profile.name());
+
+	if offline_build() {
+		build_cmd.arg("--offline");
+	}
+
+	println!("{}", colorize_info_message("Information that should be included in a bug report."));
+	println!("{} {:?}", colorize_info_message("Executing build command:"), build_cmd);
+	println!("{} {}", colorize_info_message("Using rustc version:"), cargo_cmd.rustc_version());
+
+	match build_cmd.status().map(|s| s.success()) {
+		Ok(true) => profile,
+		// Use `process.exit(1)` to have a clean error output.
+		_ => process::exit(1),
+	}
+}
+
+/// Compact the WASM binary using `wasm-gc` and compress it using zstd.
+fn compact_wasm_file(
+	project: &Path,
+	profile: Profile,
+	cargo_manifest: &Path,
+	out_name: Option<String>,
+) -> (Option<WasmBinary>, Option<WasmBinary>, WasmBinaryBloaty) {
+	let default_out_name = get_wasm_binary_name(cargo_manifest);
+	let out_name = out_name.unwrap_or_else(|| default_out_name.clone());
+	let in_path = project
+		.join("target/wasm32-unknown-unknown")
+		.join(profile.directory())
+		.join(format!("{}.wasm", default_out_name));
+
+	let (wasm_compact_path, wasm_compact_compressed_path) = if profile.wants_compact() {
+		let wasm_compact_path = project.join(format!("{}.compact.wasm", out_name,));
+		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)
+			.expect("Failed to compact generated WASM binary.");
+
+		let wasm_compact_compressed_path =
+			project.join(format!("{}.compact.compressed.wasm", out_name));
+		if compress_wasm(&wasm_compact_path, &wasm_compact_compressed_path) {
+			(Some(WasmBinary(wasm_compact_path)), Some(WasmBinary(wasm_compact_compressed_path)))
+		} else {
+			(Some(WasmBinary(wasm_compact_path)), None)
+		}
+	} else {
+		(None, None)
+	};
+
+	let bloaty_path = project.join(format!("{}.wasm", out_name));
+	fs::copy(in_path, &bloaty_path).expect("Copying the bloaty file to the project dir.");
+
+	(wasm_compact_path, wasm_compact_compressed_path, WasmBinaryBloaty(bloaty_path))
+}
+
+fn compress_wasm(wasm_binary_path: &Path, compressed_binary_out_path: &Path) -> bool {
+	use sp_maybe_compressed_blob::CODE_BLOB_BOMB_LIMIT;
+
+	let data = fs::read(wasm_binary_path).expect("Failed to read WASM binary");
+	if let Some(compressed) = sp_maybe_compressed_blob::compress(&data, CODE_BLOB_BOMB_LIMIT) {
+		fs::write(compressed_binary_out_path, &compressed[..])
+			.expect("Failed to write WASM binary");
+
+		true
+	} else {
+		build_helper::warning!(
+			"Writing uncompressed wasm. Exceeded maximum size {}",
+			CODE_BLOB_BOMB_LIMIT,
+		);
+
+		false
+	}
+}
+
+/// Custom wrapper for a [`cargo_metadata::Package`] to store it in
+/// a `HashSet`.
+#[derive(Debug)]
+struct DeduplicatePackage<'a> {
+	package: &'a cargo_metadata::Package,
+	identifier: String,
+}
+
+impl<'a> From<&'a cargo_metadata::Package> for DeduplicatePackage<'a> {
+	fn from(package: &'a cargo_metadata::Package) -> Self {
+		Self {
+			package,
+			identifier: format!("{}{}{:?}", package.name, package.version, package.source),
+		}
+	}
+}
+
+impl<'a> Hash for DeduplicatePackage<'a> {
+	fn hash<H: Hasher>(&self, state: &mut H) {
+		self.identifier.hash(state);
+	}
+}
+
+impl<'a> PartialEq for DeduplicatePackage<'a> {
+	fn eq(&self, other: &Self) -> bool {
+		self.identifier == other.identifier
+	}
+}
+
+impl<'a> Eq for DeduplicatePackage<'a> {}
+
+impl<'a> Deref for DeduplicatePackage<'a> {
+	type Target = cargo_metadata::Package;
+
+	fn deref(&self) -> &Self::Target {
+		self.package
+	}
+}
+
+fn create_metadata_command(path: impl Into<PathBuf>) -> MetadataCommand {
+	let mut metadata_command = MetadataCommand::new();
+	metadata_command.manifest_path(path);
+
+	if offline_build() {
+		metadata_command.other_options(vec!["--offline".to_owned()]);
+	}
+	metadata_command
+}
+
+/// Generate the `rerun-if-changed` instructions for cargo to make sure that the WASM binary is
+/// rebuilt when needed.
+fn generate_rerun_if_changed_instructions(
+	cargo_manifest: &Path,
+	project_folder: &Path,
+	wasm_workspace: &Path,
+	compressed_or_compact_wasm: Option<&WasmBinary>,
+	bloaty_wasm: &WasmBinaryBloaty,
+) {
+	// Rerun `build.rs` if the `Cargo.lock` changes
+	if let Some(cargo_lock) = find_cargo_lock(cargo_manifest) {
+		rerun_if_changed(cargo_lock);
+	}
+
+	let metadata = create_metadata_command(project_folder.join("Cargo.toml"))
+		.exec()
+		.expect("`cargo metadata` can not fail!");
+
+	let package = metadata
+		.packages
+		.iter()
+		.find(|p| p.manifest_path == cargo_manifest)
+		.expect("The crate package is contained in its own metadata; qed");
+
+	// Start with the dependencies of the crate we want to compile for wasm.
+	let mut dependencies = package.dependencies.iter().collect::<Vec<_>>();
+
+	// Collect all packages by follow the dependencies of all packages we find.
+	let mut packages = HashSet::new();
+	packages.insert(DeduplicatePackage::from(package));
+
+	while let Some(dependency) = dependencies.pop() {
+		let path_or_git_dep =
+			dependency.source.as_ref().map(|s| s.starts_with("git+")).unwrap_or(true);
+
+		let package = metadata
+			.packages
+			.iter()
+			.filter(|p| !p.manifest_path.starts_with(wasm_workspace))
+			.find(|p| {
+				// Check that the name matches and that the version matches or this is
+				// a git or path dep. A git or path dependency can only occur once, so we don't
+				// need to check the version.
+				(path_or_git_dep || dependency.req.matches(&p.version)) && dependency.name == p.name
+			});
+
+		if let Some(package) = package {
+			if packages.insert(DeduplicatePackage::from(package)) {
+				dependencies.extend(package.dependencies.iter());
+			}
+		}
+	}
+
+	// Make sure that if any file/folder of a dependency change, we need to rerun the `build.rs`
+	packages.iter().for_each(package_rerun_if_changed);
+
+	compressed_or_compact_wasm.map(|w| rerun_if_changed(w.wasm_binary_path()));
+	rerun_if_changed(bloaty_wasm.wasm_binary_bloaty_path());
+
+	// Register our env variables
+	println!("cargo:rerun-if-env-changed={}", crate::SKIP_BUILD_ENV);
+	println!("cargo:rerun-if-env-changed={}", crate::WASM_BUILD_TYPE_ENV);
+	println!("cargo:rerun-if-env-changed={}", crate::WASM_BUILD_RUSTFLAGS_ENV);
+	println!("cargo:rerun-if-env-changed={}", crate::WASM_TARGET_DIRECTORY);
+	println!("cargo:rerun-if-env-changed={}", crate::WASM_BUILD_TOOLCHAIN);
+}
+
+/// Track files and paths related to the given package to rerun `build.rs` on any relevant change.
+fn package_rerun_if_changed(package: &DeduplicatePackage) {
+	let mut manifest_path = package.manifest_path.clone();
+	if manifest_path.ends_with("Cargo.toml") {
+		manifest_path.pop();
+	}
+
+	WalkDir::new(&manifest_path)
+		.into_iter()
+		.filter_entry(|p| {
+			// Ignore this entry if it is a directory that contains a `Cargo.toml` that is not the
+			// `Cargo.toml` related to the current package. This is done to ignore sub-crates of a
+			// crate. If such a sub-crate is a dependency, it will be processed independently
+			// anyway.
+			p.path() == manifest_path || !p.path().is_dir() || !p.path().join("Cargo.toml").exists()
+		})
+		.filter_map(|p| p.ok().map(|p| p.into_path()))
+		.filter(|p| {
+			p.is_dir() || p.extension().map(|e| e == "rs" || e == "toml").unwrap_or_default()
+		})
+		.for_each(rerun_if_changed);
+}
+
+/// Copy the WASM binary to the target directory set in `WASM_TARGET_DIRECTORY` environment
+/// variable. If the variable is not set, this is a no-op.
+fn copy_wasm_to_target_directory(cargo_manifest: &Path, wasm_binary: &WasmBinary) {
+	let target_dir = match env::var(crate::WASM_TARGET_DIRECTORY) {
+		Ok(path) => PathBuf::from(path),
+		Err(_) => return,
+	};
+
+	if !target_dir.is_absolute() {
+		// We use println! + exit instead of a panic in order to have a cleaner output.
+		println!(
+			"Environment variable `{}` with `{}` is not an absolute path!",
+			crate::WASM_TARGET_DIRECTORY,
+			target_dir.display(),
+		);
+		process::exit(1);
+	}
+
+	fs::create_dir_all(&target_dir).expect("Creates `WASM_TARGET_DIRECTORY`.");
+
+	fs::copy(
+		wasm_binary.wasm_binary_path(),
+		target_dir.join(format!("{}.wasm", get_wasm_binary_name(cargo_manifest))),
+	)
+	.expect("Copies WASM binary to `WASM_TARGET_DIRECTORY`.");
+}
diff --git a/substrate/zombienet/0000-block-building/block-building.toml b/substrate/zombienet/0000-block-building/block-building.toml
new file mode 100644
index 0000000000000000000000000000000000000000..42ebbb58ac1a6f57e018e5753a7fe6a6928a109f
--- /dev/null
+++ b/substrate/zombienet/0000-block-building/block-building.toml
@@ -0,0 +1,15 @@
+[settings]
+enable_tracing = false
+
+[relaychain]
+default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
+default_command = "substrate"
+chain = "local"
+
+  [[relaychain.nodes]]
+  name = "alice"
+  validator = true
+
+  [[relaychain.nodes]]
+  name = "bob"
+  validator = true
diff --git a/substrate/zombienet/0000-block-building/block-building.zndsl b/substrate/zombienet/0000-block-building/block-building.zndsl
new file mode 100644
index 0000000000000000000000000000000000000000..6ad5f3d89fda5c468c4736ef768716657b4e435d
--- /dev/null
+++ b/substrate/zombienet/0000-block-building/block-building.zndsl
@@ -0,0 +1,17 @@
+Description: Block building
+Network: ./block-building.toml
+Creds: config
+
+alice: reports node_roles is 4
+bob: reports node_roles is 4
+
+alice: reports peers count is at least 1
+bob: reports peers count is at least 1
+
+alice: reports block height is at least 5 within 20 seconds
+bob: reports block height is at least 5 within 20 seconds
+
+alice: count of log lines containing "error" is 0 within 2 seconds
+bob: count of log lines containing "error" is 0 within 2 seconds
+
+alice: js-script ./transaction-gets-finalized.js within 30 seconds
diff --git a/substrate/zombienet/0000-block-building/transaction-gets-finalized.js b/substrate/zombienet/0000-block-building/transaction-gets-finalized.js
new file mode 100644
index 0000000000000000000000000000000000000000..d16e85f2c4e607d2beea0d13c3bcb9a29840e6b9
--- /dev/null
+++ b/substrate/zombienet/0000-block-building/transaction-gets-finalized.js
@@ -0,0 +1,59 @@
+//based on: https://polkadot.js.org/docs/api/examples/promise/transfer-events
+
+const assert = require("assert");
+
+async function run(nodeName, networkInfo, args) {
+  const {wsUri, userDefinedTypes} = networkInfo.nodesByName[nodeName];
+  const api = await zombie.connect(wsUri, userDefinedTypes);
+
+  // Construct the keyring after the API (crypto has an async init)
+  const keyring = new zombie.Keyring({ type: "sr25519" });
+
+  // Add Alice to our keyring with a hard-derivation path (empty phrase, so uses dev)
+  const alice = keyring.addFromUri('//Alice');
+  const bob = '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty';
+
+  // Create a extrinsic, transferring 10^20 units to Bob
+  const transfer = api.tx.balances.transferAllowDeath(bob, 10n**20n);
+
+  let transaction_success_event = false;
+  try {
+    await new Promise( async (resolve, reject) => {
+      const unsubscribe = await transfer
+        .signAndSend(alice, { nonce: -1 }, ({ events = [], status }) => {
+          console.log('Transaction status:', status.type);
+
+          if (status.isInBlock) {
+            console.log('Included at block hash', status.asInBlock.toHex());
+            console.log('Events:');
+
+            events.forEach(({ event: { data, method, section }, phase }) => {
+              console.log('\t', phase.toString(), `: ${section}.${method}`, data.toString());
+
+              if (section=="system" && method =="ExtrinsicSuccess") {
+                transaction_success_event = true;
+              }
+            });
+          } else if (status.isFinalized) {
+            console.log('Finalized block hash', status.asFinalized.toHex());
+            unsubscribe();
+            if (transaction_success_event) {
+              resolve();
+            } else {
+              reject("ExtrinsicSuccess has not been seen");
+            }
+          } else if (status.isError) {
+            unsubscribe();
+            reject("Transaction status.isError");
+          }
+
+        });
+    });
+  } catch (error) {
+    assert.fail("Transfer promise failed, error: " + error);
+  }
+
+  assert.ok("test passed");
+}
+
+module.exports = { run }
diff --git a/substrate/zombienet/0001-basic-warp-sync/README.md b/substrate/zombienet/0001-basic-warp-sync/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7550ca89236fbe6e50f901498376db324e594283
--- /dev/null
+++ b/substrate/zombienet/0001-basic-warp-sync/README.md
@@ -0,0 +1,101 @@
+# Test design
+The `warp-sync` test works on predefined database which is stored in the cloud and
+fetched by the test. `alice` and `bob` nodes are spun up using this database snapshot in full node mode.
+
+As `warp-sync` requires at least 3 peers, the test spawns the `charlie` full node which uses the same database snapshot.
+
+The `dave` node executed with `--sync warp` syncs database with the rest of the network.
+
+# How to prepare database
+Database was prepared using the following zombienet file (`generate-warp-sync-database.toml`):
+```
+[relaychain]
+default_image = "docker.io/parity/substrate:master"
+default_command = "substrate"
+
+chain = "gen-db"
+
+chain_spec_path = "chain-spec.json"
+
+  [[relaychain.nodes]]
+  name = "alice"
+  validator = true
+
+  [[relaychain.nodes]]
+  name = "bob"
+  validator = true
+```
+
+The zombienet shall be executed with the following command, and run for some period of time to allow for few grandpa eras.
+```
+./zombienet-linux spawn --dir ./db-test-gen --provider native generate-warp-sync-database.toml
+```
+
+Once the zombienet is stopped, the database snapshot
+(`{alice,bob}/data/chains/local_testnet/db/` dirs) was created using the following
+commands:
+```bash
+mkdir -p db-snapshot/{alice,bob}/data/chains/local_testnet/db/  
+cp -r db-test-gen/alice/data/chains/local_testnet/db/full db-snapshot/alice/data/chains/local_testnet/db/  
+cp -r db-test-gen/bob/data/chains/local_testnet/db/full   db-snapshot/bob/data/chains/local_testnet/db/
+```
+
+The file format should be `tar.gz`. File shall contain `local_testnet` folder and its subfolders, e.g.:
+```
+$ tar tzf chains.tgz | head
+local_testnet/
+local_testnet/db/
+local_testnet/db/full/
+...
+local_testnet/db/full/000469.log
+```
+
+Sample command to prepare archive:
+```
+tar -C db-snapshot/alice/data/chains/ -czf chains.tgz local_testnet
+```
+
+Also refer to: [zombienet#578](https://github.com/paritytech/zombienet/issues/578)
+
+The `raw` chain-spec shall also be saved: `db-test-gen/gen-db-raw.json`.
+
+# Where to upload database
+The access to this [bucket](https://console.cloud.google.com/storage/browser/zombienet-db-snaps/) is required.
+
+Sample public path is: `https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-0bb3f0be2ce41b5615b224215bcc8363aa0416a6.tgz`.
+
+The database file path should be `substrate/XXXX-test-name/file-SHA1SUM.tgz`, where `SHA1SUM` is a `sha1sum` of the file.
+
+# Chain spec
+Chain spec was simply built with:
+```
+substrate build-spec --chain=local > chain-spec.json
+```
+
+Please note that `chain-spec.json` committed into repository is `raw` version produced by `zombienet` during database snapshot generation. Zombienet applies some modifications to plain versions of chain-spec.
+
+# Run the test
+Test can be run with the following command:
+```
+zombienet-linux test --dir db-snapshot --provider native test-warp-sync.zndsl
+```
+
+*NOTE*: currently blocked by: [zombienet#578](https://github.com/paritytech/zombienet/issues/578)
+
+
+# Save some time hack
+Substrate can be patched to reduce the grandpa session period.
+```
+diff --git a/bin/node/runtime/src/constants.rs b/bin/node/runtime/src/constants.rs
+index 23fb13cfb0..89f8646291 100644
+--- a/bin/node/runtime/src/constants.rs
++++ b/bin/node/runtime/src/constants.rs
+@@ -63,7 +63,7 @@ pub mod time {
+ 
+    // NOTE: Currently it is not possible to change the epoch duration after the chain has started.
+    //       Attempting to do so will brick block production.
+-   pub const EPOCH_DURATION_IN_BLOCKS: BlockNumber = 10 * MINUTES;
++   pub const EPOCH_DURATION_IN_BLOCKS: BlockNumber = 1 * MINUTES / 2;
+    pub const EPOCH_DURATION_IN_SLOTS: u64 = {
+        const SLOT_FILL_RATE: f64 = MILLISECS_PER_BLOCK as f64 / SLOT_DURATION as f64
+```
diff --git a/substrate/zombienet/0001-basic-warp-sync/chain-spec.json b/substrate/zombienet/0001-basic-warp-sync/chain-spec.json
new file mode 100644
index 0000000000000000000000000000000000000000..8c09e7c7b03215ae5c6833fa359e047581b3e03b
--- /dev/null
+++ b/substrate/zombienet/0001-basic-warp-sync/chain-spec.json
@@ -0,0 +1,192 @@
+{
+  "name": "Local Testnet",
+  "id": "local_testnet",
+  "chainType": "Local",
+  "bootNodes": [
+    "/ip4/127.0.0.1/tcp/30333/p2p/12D3KooWFvMbTsNZ8peGS8dbnRvNDBspstupzwYC9NVwbzGCLtDt"
+  ],
+  "telemetryEndpoints": null,
+  "protocolId": null,
+  "properties": null,
+  "forkBlocks": null,
+  "badBlocks": null,
+  "lightSyncState": null,
+  "codeSubstitutes": {},
+  "genesis": {
+    "raw": {
+      "top": {
+        "0x074b65e262fcd5bd9c785caf7f42e00a4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x0e7b504e5df47062be129a8958a7a1271689c014e0a5b9a8ca8aafdff753c41c": "0xe8030000000000000000000000000000",
+        "0x0e7b504e5df47062be129a8958a7a1274e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x0e7b504e5df47062be129a8958a7a127ecf0c2087a354172a7b5a9a7735fe2ff": "0xc0890100",
+        "0x0e7b504e5df47062be129a8958a7a127fb88d072992a4a52ce055d9181748f1f": "0x0a000000000000000000000000000000",
+        "0x0f6738a0ee80c8e74cd2c7417c1e25564e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1809d78346727a0ef58c0fa03bafa3234e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1a736d37504c2e3fb73dad160c55b2914e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f5e0621c4869aa60c02be9adcc98a0d1d": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480100000000000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f66e8f035c8adbe7f1547b43c51e6f8a4": "0x00000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087faacf00b9b41fda7a9268821c2a2b3e4c": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480100000000000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087fdc6b171b77304263c292cc3ea5ed31ef": "0x0100000000000000040000000000000001",
+        "0x2099d7f109d6e535fb000bba623fd4404c014e6bf8b8c2c011e7290b85696bb3": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x2099d7f109d6e535fb000bba623fd4404e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2099d7f109d6e535fb000bba623fd4409f99a2ce711f3a31b2fc05604c93f179": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x267ada16405529c2f7ef2727d71edbde4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96": "0x00000000071c0d84db3a00",
+        "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01",
+        "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9007cbc1270b5b091758f9c42f5915b3e8ac59e11963af19174d0b94d5d78041c233f55d2e19324665bafdfb62925af2d": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da923a05cabf6d3bde7ca3ef0d11596b5611cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da932a5935f6edc617ae178fef9eb1e211fbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x000000000300000001000000000000000000a0dec5adc935360000000000000000000000000000000000000000000000000064a7b3b6e00d0000000000000000000064a7b3b6e00d0000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da94f9aea1afa791265fae359272badc1cf8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95ecffd7b6c0f78751baa9d281e0bfa3a6d6f646c70792f74727372790000000000000000000000000000000000000000": "0x0000000000000000010000000000000000407a10f35a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da96f2e33376834a63c86a195bcf685aebbfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x000000000300000001000000000000000000a0dec5adc935360000000000000000000000000000000000000000000000000064a7b3b6e00d0000000000000000000064a7b3b6e00d0000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da98578796c363c105114787203e4d93ca6101191192fc877c24d725b337120fa3edc63d227bbc92705db1e2cb65f56981a": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b0edae20838083f2cde1c4080db8cf8090b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b321d16960ce1d9190b61e2421cc60131e07379407fecc4b89eb7dbd287c2c781cfb1907a96947a3eb18e4f8e7198625": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9e5e802737cce3a54b0bc9e3d3e6be26e306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9edeaa42c2163f68084a988529a0e2ec5e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9f3f619a1c2956443880db9cc9a13d058e860f1b1c7227f7c22602f53f15af80747814dffd839719731ee3bba6edc126c": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x3104106e6f6465",
+        "0x2aeddc77fe58c98d50bd37f1b90840f94e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2b06af9719ac64d755623cda8ddd9b944e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2b06af9719ac64d755623cda8ddd9b949f99a2ce711f3a31b2fc05604c93f179": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x2c5de123c468aef7f3ac2ab3a76f87ce4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c24e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c298ef7dc060436e4ed803af07632b89b65153cb1f00942ff401000000": "0x601de9615313b00e8cea3ef84e79e50b2fb70e2c8a47cff478b9fe8b3fa8f2db02000000",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c298ef7dc060436e4ed803af07632b89b6b4def25cfda6ef3a00000000": "0x601de9615313b00e8cea3ef84e79e50b2fb70e2c8a47cff478b9fe8b3fa8f2db02000000",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c2ff3ae12770bea2e48d9bde7385e7a25f": "0x0000000002000000",
+        "0x3a2d6c9353500637d8f8e3e0fa0bb1c54e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x3a2d6c9353500637d8f8e3e0fa0bb1c5ba7fb8745735dc3be2a2c61a72c39e78": "0x00",
+        "0x3a636f6465": "0x52bc537646db8e0528b52ffd0058dc2705bea5c66d15541040ac6c3ae971bcf5f1040221a8d1f8b7c17e61bf21cce87411480b10bd8daa5e3c2b65f8c4aa364e5a8ddf27c0313827d06a2d6334e074db9ca7d876ac8d052862b9984530f4d340bda4edddd6e4de5ba624536717e1139e14df2d875c7f7086dc3fa3d398b64f50fffc58fbf4fb73ffb0d39cc2b86761cfe6d3073b9c1fcee7fe611b7f4875f9a7d8cfe208fdf493f4d3b07d9a73ad05c8cf39e5c4dde679c3c8391b9ceec4fd78c824d218e4cfb79cb8be9cb301eace3b7f8a274c182edb72e2e83349855e7e4a2a795d7e27998b94f46d92b42eb543afcbcf5f5c9e5bf2d52dfd9b2f93dc33262710e3fc79b943e09fe2d00f8dd7edc4350b92a692a2facb7adddffddd3d89e9babb7b8e0b9d61050b2b4ddf3efdfdb3f629e9edfe9c18c4f8715bebf42d6f6e3ff74be1b9c0c8b9187cb89c83618e5bce6ebf90cb3918729745244063391ee9710cdb87bfbbbffc6047f275725e904518e7f53cec48efa788c4bd67d104a4eb81534cd2bd67cbeebb075b4c32deee59a43da30fd2d0c979410f3db2fb2972cfcad89d0f822c7ab644bade3b59d6eeddc9925eef8f34e8645980eb0fb2f8d9b2cafddec99273d7bf234bee5995292c3051e1fa97dcb31285eb5f76255cff23de917c3f72c8afaeaeac6ef74e96462e7d70864ed2ef48be2c9ef05d8f1cfa6e67cb79dd0ecdabababab5b225d7f4a72cfa6a53d9bcf739903246f521840fe916b813c65e41c0c50b7b60fe76078bafc61ff4c1bbfac7d3887b3bafc37979f73580490ef389f9f5920c8edc3f3cee7075fdc3e4cdba79f1f9c200db97df896f532c31e008355cff83a7dff7e1791b4e5097b400cb89ef19def24533b4524b567fe2c96c02292fe233d5900f2edfed96d8f34d29c2680f3270934e67054b7a4b7bfceaf95fd879b568e777e395e3aa7139fded3ff484f77779fef3ebbbfdeb6364afae9f74c32bf6dd9ef3de714c839e5df7e908f8c208b30f2fbb388847f8a2354c1e170305cb6dcb3b2de7eb0436e9ff9edc33deb3fd24ed29ef50f602cc7dbfda0ac7df8f683331cdba73fd63efefdb2f699b79f45244e492a38b708a9def9f54e6ba3643efdf9d41acdeb964524d396f3ce3fd247fa2f7380e4736a01f2e59c72bcfd606d9fb266c81ce3fc32bc0d3a198071be3f3f8b27cc0f725b7bc6cf3d2be99da45f916a7e3f38c349d21b7211a2597587be4b05e6ceef17b908d1c4dd21112e95f0ceef777111a289bb43225c2ade9ddfffe2224413778744b8f3fb594c4271b83bff48831d3217995ffa73cff86bfb94f3faf3834ed69ef11719fdf9592481f68cdf6ded19ff91063b9c64df908b10cddca5e2ddf9fd2217219ab83b24c29ddf3fc51346dc9d1fb60fdf7e16934cdc9d7fa48ff4913ed24c72cff839a76dd0789903a49e5d06c80dcee7f629f9a7e59ef1f323cd2903720ee774f91b22454f610414ad21610c79c190160c991a32c6102286c0604808865831440c2057860431c469881042da10f28221370c9961881742e6186245881c426630248b1035848421248e214d42de18b224644a081b42bc08a11212032164081943081842d6102203212e102286902e84782184cb902d845821a44ac8154248304520a449080d3d36e8a9ea99a3478e9e387ad4e8f1d233464f0c7a723d5b7aace849414f153d24e839a247aa678b1e287a9ee889ea71a207891e237a44d053821ea89e247a94e81941cf0a7a5ad0c3821d11f448d1d3448f163c3af070a046c68e1a3b69eca0b173c68e193b65ecc060478c9d17ec84b103c64e979d2f76bcd8e982878947069e251e259e241e2b3c31f0c0c083dbb9dab963c78e9d3776e0d891c1ce971d2e3b2ed8e162678b9da99d1becd86087063b74ecccb133831d3976e2d8a963c76aa7063c1be0b9b293c50e163b2cd859c18e0a76a476aed8b162a78a9da89d12ec3cb143821d26768cd82962c769e7879d1b767cd80162c7033b42ec7460070440ec0072c70e13901b00b9da69dab101481640ba00f102880b807001b20490278094000813407e000204902cb51acc20a61390a51a0d80c850fb52bba376558ba3660710a5da1c409280e06a5635388058a9cda026478d8e9a1bb5aada1b35366a30a86d51aba236454d899a096a4c0059a386a546430d57b3528361e76987089d2f74dcd0a9d25943270d1d2a1d18e88ca123860e1b3a73e880a123874e0c74e0d02943270c9d3674ccd0214387063a32d0a9814e171d2b9d3774d0d0a143470d9d17e8cc40270e1d2f3a67e808a143848e077478d0c9a263834e0d3a34e8e0a0d3019da61f6afc80e3c71a3fc2f8d1821f5dfcd8e207173fbc981ef8f1c40f277e90e047133f98f8b1c4ab04f34b8f0c604288573fbebca26a54d0c8f083aa2af9f0c2c71735197e88a1d3c33787ec8e9009f6434d1b36573a869a0bbc2f3a778473d49e422ec2168453e11630203c1bfce0522347784527869a17542d68984219603d7442c086a8f902e34167294cea425023469df26e50e3a5878c70a926d5259b1d6267c8bebc5eb0d303cc03a1d2384307467490a583a70e74a851eaa0033d8e10bfc070a8568c3db8be78687c74f408e2c545b481cb4a8f14e06c51657851856d8c3bc8bc78c5c047d40f2d6476c83421bb416581cb062f2f2f34646ed42d7c24e164f1ec78a9e15223e6c54b63d4e2c38a48c78c1d95a9068d5a11f54aad04b51d5c68b86010adc61a6ad4a0597aa541a39463031033726aa08901c9445e21ade05841c6602307a9f423f827300d1b19f4d4f1657000825718382da827e8b0886ef4808123021c23708ae809030704384ce02c81c3054709215d709cf8f1c1f900ce062a10383e8852b468d0b2c26962c686991a7048b09303ce08704a504bc306861a326ad8b0d9400d0c6ac0c8990187861a3a74385063464fe12ce1c4e003063ec6f831831e40f4f0c04b8c1f67782ce8d104a8460fa79d257afcd003043fcc905981103764a2e8a1030803d005433e007ab179b201818d10f406a01dd48ece868e0956431743dd42bff4e8402743074387ebac74576a0a2a15758aae06b1aadbc07f60c68c971daf2f558a1e5a3aa577aae9a24bea66a077b8946a9868c8a0a1010d1d3435a061636606345e66e2a091c18c1c346bd0a83143c7cc1c3469ec0411ce40860b4d0b605a68585093aa69a131a25ba2c982e605b52d343e8c1bb0c901f6011808604f3c88784551b9c8ae646dc072f820fe88991bbcc0e88ae888e88c70c9d03dc18aa8319851a3f683c8c60c1a325f646e206303992b19ab191a66b0c850f1a282460c9c20707ac00142e60a192b6049302b3255c8a4e03df03f00d181831d4419d4c6b0517a55895334493b30b41534565c4b2e1ccca99682300d980e5e0d6057604cf306e31a3655231b3e62f08241f5e245c66b0c0eb48c408c3f8c1eb08943868b07e2d5454d1aaf2b5e5b6cdc78a9604c0387089c271928402e5e55d86001af6aba8871d4d0a0070f3634d4d8d1c3071b2b21ce268b8d0d3367d4bc01bba1c68d1f2ea859e387979a18c09a6c7880d95073364b3565d0ab9a19d4b2b091e175831a2b180d3859d4d421b6f17ae2d5c4cb891f37a89101784718c3cb0697198e858f261717ae12b846e02ac2b585eb042e295c53b8927081c015e59a72b5c07584ab0617169716ae14b8b270f5e0f2800b0bd710ae255c4eb884706d7129e17ac2b5838b07d70f2e1b5c50b8a270657171c065848b05ae15b8987055e1bac275832b07d7932b042e205c1f7005e15241cf54cd183364b862a8b99a2943ac439cc3e606110e9106e21be21d40bec0711273220a8068b169c3956433c3aca3c6c4b303073cbccee891c30e0e385c841b7899a1e30510aa1a143555b5276a4e4c2d707ee080033b576021d88961a7069c295810af357464086100bfe0203141600387cc13322600bbc0f100e8458f25c02dc030769a00c1787d51b1709d51b3807140acc1cb8b9a06ce11343000c204a40c58075e65d868a9b1012ba9fe00dba1034137448ba047053369bc6cf0838d1e3df464515bd0566ab8ecf0a0d34563f1d9507bc0116205162a544da22e5195a81e783272a2462a9e8b189731052e3b64553eb8689911bee18901048d57171d2d3836e0d48033838e0e325f006143c68b8f06b5a57a458c8b2ae5aa636c72a5d1e303a21db58a1a11b5281f31e058a92800a2850f18ea0a5e50d4cc21dea0a606231a43b8801101f321b4e25b8833a82a10e5a849c2d10296c533e3470c6a5c5073064e08bc1fbc19bc2b5e0c3d33e8b1a367e81a7a072057b4161b1d76b4b8c2a01903e452bb41cf17206a0021a3cb0244059d53a743d7d4d1d075a0d3d2fdd005d1c305080f3d5d741ce87ce87ae878e880e0d1d2edd079a0cba1fb40874377031016e00c61f3464d0daf0d9d1c7ab010b700d7d0b9a1870d73861b367676e0e14167079e2606e060c101838621e3820ea39de8259a896ea29fe82e1dd55f34091a0a97aa5cfc106fc423417304cd123448e41891e38408845884e834163192603402e4400d23c6464c8e980c649e64909029a207971e60f4e822a7889c12e488409c41e4808885468a460b1a15c4ba88c120e60558450503b442d64566860c8c19ab993b66eae8b1460f1af460237644ac043124782cf168e22143ab8adaa56545cb8bda45eb8b2fe245f042f838818f2d3e50f02178103c11b12b625bc4a44627c629c6a81814b12d3113f810c207123e86a8d9e0b9e1d1e1bd018301ac0cd8182316a31763163eacf0d1021f57c8acd00981ec8a0f86efca1783a884480271095087ea0270872a06a8e585e5b5c38b86d612b5205a4c842c08c908b1a835d42cd586fa058d153eb4f808c2070fad21ea0b5a21086f107e69bd117620ecc1d3a2268697453746774617032058d870c026861aaa9a1bd8d450e3854d520d1c364d3638d4dc5113860dae260e1ba69a2f80cca16307101bec28d145f42cd136340d4056d0589aa973681e3acb9ca3710d03902ee6d5acc1b4c184a3c76a5acdaa49032052736ab66066b164a260b2604e31a5983f4ca989c584629e60e6a609261573cbfcc05cc1b46246318998219843cca46965c6309f260c1357c50215983e3c994d4ea8b820a505a1261098400424f08006a49000144e40c001941820090953082300100091282c38c07979c648c16a072a6a528125539a00b1b0640938fd4914a0254b5abf8127529c003dc1f92b5c548401202551a440292a025a00f94c1cbc0c34bf24d4c40914222946455058f0e0956c3e89895a68e1f556b8a80848a8c7c7c0310f03b7700099c7f1e05c090935712224d48400349c3bb848084a1323a0274b80802cf0018e1d2cc50251a02cc10011900b434ba04cb94651805ac04013141ee70b03ad7003067a22c5c992274da4084d71c1060c64d4048a519426464551a0c870ea6021a1264e8c9c3421328a228500301c2b067212454a94254d9c44918200a3282e4871e2e4f6c0a9019429170345500a80814be2d020041c3a7270e660189c19b01ccc82132953806c70e26022175680628128529c2c8132e50255a0894d06a78a8b9e1035b90010d19215a24079120568ca1228536e91901429284481d2821404581c38780a14168a8880a25c40ca120c00057d80f3063f018ab20294a2282e18357122850a14178680961811499902444404c70d7e026589115011910b4e6870dae0222028465088a4b060e44293252b2c8132e53699f2244a1322127ce0c8802f0065ca25020a2292e28013481c361808c80520171290c213a015566892c20f9c35b828c809100b4ebc7091511420222016a240791c35a240b1800d4e1aec044a5114284446558096604068ca94264b88809e084171c116e4448a90ed06070d6e614913a3264f9a18011d0086734606a00835816204250a14191c3338c88914a10a2c013272c109501520189c3298480a01429e404215686214c5050b2c3172024404e54914284b96d0e880367c2083918403c3ca97cb4820e770b83b919cc66355b1aae694f951efc6c6fb273d1bcff3bc27c99b1b8ffc1beadfc75f7f5d6b77adb39bf963effa7d5d2be576e68ffb03e9f4fad1a6def7791fd013fe987a7b5f777fb4995b74ff9add99b2338b226566ffd8fbbe9deea87760f7d755efcfbbfb1b476ef70aced44a99ba7762f56e96d8ac3a99bac74ce64a65cd72cf9d3f0fdbe9d7ec2f661bfe987ecceca4dde9e73895dbbb72f5cf690794fac7edb4d93f76fa71d3ef73f7bc8fb6536766ca9429534ad9fb28f5f6ef83317b53a64c993fca4e653e66a7cced9476bb575ae5cafef19021428430c8eed4e5a20e7a575abbdd0586cc937a5ead1f738fcc9f3b6598bb5377efd1dd2be0eeb0eab5d6dae3d8b4dbdde79c3e67d3f6f6a6d4bbbf6edaecd46beaf5fc2af5c09d3af5599dddbf70c645db43f7daa42ba5ee2ff6f656bb7fee1574265d57ef4a7b093b8d31b37fd3dd41b052a069482b0dc31aef1a760fc309788712a8719ed3bf5ab97b727fdc13e4eb09e21e0176770a1386ddd3b9bb99fba3f9421aeace94db2140a97baeaf7eeef4f3a8473d66af52eade5fb7fb473fef8ffbc6fb3effe6fc981bf600dab4ddbb2937b37fdd1f7bceee7d2008a34054a820303bbfda1dc0cc3e3bef98b9fb989bb9eb66c7ac6eba772c67ee58ecccdd64ef581d77ce9a5dd771d7755d73d779c71db3983b666618666f6731c73033b35831cc95997aadeedd9f7b8e7b7737a51ed0ee80f6cbddbfe6699e6e8fba7703ba76f7a49501ed7937ad1fe5e9cddd1f7f5fc7d49dba376d4f61d20528c0030e9d7f780218051ad6f41ac7a969202774cb7cddb06eeafd79b57e8e0098ce016a351d6f1a86ec734e9eacf6febeef874c7ba594c62adb7ccc95a73bedd0dd457710e6e476b06d427666a6dd4ca33edd41f77228655a29ad94b6f70ca5b45217a5d4044a5db429f5da5e2b58bfaf6777fb6cfe3e9c0efae3e993d99550e7ea6cc3ce6266af71f7cf6b6776f630c63e67c8ede2768ecd364077e8edce727767d51866f7ca732661febc69f3474343536b7dbd5e73ce5adbbd84f6f6aa57efd09d046feaeefe7277eef9f5d7947e1f87cedeee4dab778314ac2085e9eee6ea9f37280382ec3ed929ad15a4947e1ff7d7d49d7d4e0ec3574e873e42483d44e2341e76bb7bddcdeeeeecfc7ddc55669e9f659cf979e8ec79dd4eabd7dab47af5efebaed56937add4a35e53da3da7cf39270c4c7be73c3bca6af72e403b28d33dfba360d7fc79d8dd9336a594b67f4e00dbc7edec3d99bbdd3fff3e76e6767667766f6766a6a0e73ebdbda977f7f4cf999d5266fed89ddb9d32333365fe98bfef6b76ff989d7a5f6f7766767777fed8bddbbbbf23dff7cd6aedafcee97d3319113c99effbbcef930d4000edc950af7e9fabbdfdfbbeefebfebe98f77dfc7d9ff3f77decf4fb78ec9a366d9036edcfdbddbd73ea7ded1fcf39448a2153380f6e0c10496901a805cf8805a448219a0242009e0011013d2192b2c427841e20284446207c0043d323a5a60b72d2a402424252402852d3c3470f1a1e464550aa00dd742d48e981620120a22996031b98284053a634b9f10b00450122ea0e5a806214c50522cb81058c5ce8c14115201696184581423465899322282ddc0cf1e95145ca058c7c3461a1c8475013274e80827c42e8e1c14188f40459d20314d444a8024b5688028585a2262cbc102128413c00f8800807690244e4032868895115a0283a3e3e807922048505274b8c845c686201a027b4ce88a88951d1073d1cfcac00a5888c7190220c00052d710245a8022e4c99111575d0e29ea22220a2292d4871b28408888a142740444b9a143d7102b42448904f083d539c0015fdb0587062d4a4024b58288212058a05661f60c002508880a870608980a200adb00400414208a1e709d0122946533040e4a4039610101520a125559ab480035b418ad09215a240596105294234b3051f0c446401275284849adcc054017a12054acc94169a181501b500c5e87b449102c5c84993a2284d888c96184169a1022e14d1584f80808a96b420e5499426443606c8a88951d1922022291730028a92032bf2596116821150d19227519a2c01226a32a5052943c62640424e9600add084488a51d112a1264ea4088140250a90b338c8922852a014110151594224c5a8c91328424da82c2982b2240a94262c38b18005a42c31aa02c401952840fe03aba3f986d44cf805a466c28dc462c247472c9009b7c20e09e9e8e8ab48ee47484820528b09231d1dbd8e8e68bb33399a4847474794c9d13cbacddb64f2c27c611e1d1d1d1d3192787474243261a48f8f908e909c9190e6d1d16482348f909ac96dde6ecde485f9c20bcd848f90909cc9d13c3a6a2647f36832e1a3a3a323a48e1e1d21cda3598f26d264723499091f1d39133e426a267c74c448481f13a47974e4313942ea98204d24a46682349991281346426a268c8484e44c9026d264c248938905bc342633cf168a9a70ff6aba2dbecb9bc2179ba6703ceccdfb193b61ec6d8ad3fa61f6369d5af6e654377762d95b3bc9d8a6622aae72ea625e8cbd219102ec61fec6fa1bd3105beb6f48a4d0bd3775fb6f48a450bfeb5c0ec6de580fb373b4b709e5b4fe97bd4d97bd7993686fdd14da9ec24d2876c109ea68a220cbde9296425bcbde904881f5f46f93eaf6330db1517b63d949e5b47efa9ebdcd29a7f577f6d6d5766e7a36a8a2065a90800530cca9a9c58c21d4f882082b9f3dea2b9a5002872dbef460a37656517915a572a2534d533447713977a250de975e0555e5509eedb450755fba13d5955367bb266fa25ff6d477757507185faca087266a3ba6cecd37bc08c30c20a4c2b0b1cdbf6cdced8f8b1dbc7842862cdcb0b1cd6d87735a7f39ab6eff1cc138bfec70b7bba9cb1c1c59a4d933361c31c711671c31c611611cc165882e59dc0c8c9c1b4288db0f5ece0d41c5104fcc1a30bbb3b395796543826b58f0c86e3ffffc59fbcc3075fb6f74daa76fffecd86d16fe36cee5c961ce39d9c66a98c3873984d395f5cc2d371260cf8668c26947f0b30d091c10081bb60640bafc2fc840c4b644c4d6cf362bf3cad61609b64773ea809492486310fd0f6e89d41d5dfa25eb006cc6ed2c11b57b26eb7724253b57a2ca562d8eb568a25fb228f9c105278b10f8e01e4da4ae9b0b281f40e625e61c9ad77fde00f293f00738346f3f0f5e6ef8dd3759346f7f8b25f065d9a0f9ac269a5cebdea8de21bebae0b73842f8ad16d87db348ce817ed8e586cf7a10ecc26e3dab45253409ebc33fd2247c0ffe24c16791e1bba8a4fe9c96b936cbb6936bf3590f9265b3a8d43be477e08c269237db8dc9f47f5c3a9f7970bade7f28a8b003166eabf159fbd878dde7cc98b0204667f3d1a38ddbe9b44fe9fd8c3baeef25842a30699f8ea54c689f79bbe7d1c274bb1fd2519edb3117299f9a5bf219b7ab3fe57edffc46deed07694efb74443d45254beef7f5fbe6cf32ebb00559a2094852782dcffb727edf64b51fe99125d2f5823c31c967bfff6cf98267cb79bb497f70762bf16f25d3b34ae677f737e00e425c8fec260cb7accfb9197c18c158fb78df3d1549a85fbe709564c270eb83dcb8fbbd47d68f2cbde73fe21e0c777e7b55f502d6fe793dffd83ee2f3c7daa7f5cc7ff339ed539f7fd63ede23dd16297e25914010fc231d9236f559396cb9f4451dbc07b95cfa1e07ceb8f441fa208834c367b1c00727f8437ec1076b908d92ef3bfab93e259feb03bf3ec86a3d5f56cb8e509ff5ac1db25cfaaddf21e9d2a0eebf0fbf92f3b25c1ca1d56ab56c50f725fd22a4138a906ef841de9f40ffb3a5f7a165f165d52e6431b4e5ed86ef912fd27b89394839935ebfc41cc4fb693be2210976a147fabf48b6555209cb06894f5f7c16910c896314df3df03d5b8a0f5a1bf0bfef94d017ad0d6895d4f7be821ed9fa2fa8d64f49fd6a12fa2c5b7a0f3e089265f836ace70bbe47dab0ec08dd830f5abe1c98e3d2071fecd06b3d68cb794befc3073d6c91e197f386df8d002601c1f767d9a179c57a7ffaa02d5b1f92e0bc1e396f8be43b2ff3ed8618b9fcec359c0168182ebf8b87c8d1446a7568039884410f5924c16d39a75802fbcf13fafd595f562e52bf6479e86439aff760fbe5760ffb32c8a1279e40df6d59af7bef950e7e210d3bd10095eccb22e7edbc9fff89273458c5138edcd6b3c8790d8024c56d3dd80a5926208d10e50e1dd52421cefdaa880024a7db7ab04396480292d31d62725b0fd6b0251a00c986db7a100c5962121eae1259a20948b7f5a02b641da0cbd7fdb8997976aef2a8e97a0f86218b65cbda2e5779e474bd6f91cc3a65ebe787e209fd2d5b4e164356927ecfbacaa39b4588ebfdbc959c17ac618b49e8fb4f71c86f903802d2ed3eebd9f91e34df46498981dbcf17a94e2f892c583c0a0ee4c09405072f138710ecefb7e99e67f7ec9136ddcffbfd07a3ffc1f5ffbec9ee677bedb5c7df5ee59eecfd11f7c8ee821dd90fce59c3d83f3b0f3b1a765dbff7839d38028be17d3357f3dcc976ecd907d791bee95b803c3b3082b387b193b89cf3418ddb405cce7540eace2ee778b04a6264a5ea96485178b774e1062b2eff6bf6303a1597731f58e2ce2d977340bc71752ee780e0c01449686541758798dcaa1feed091eb9646658c2103e296464f408065dcd2688632ba5b168141821f504cddb2286aea561c8eaf2effe56f1dc0a179e98394ecbeebbeb8f300fe6dcb5c08dab8f4e9cfef49da28e9beb8f4bb2f6e598474e977cf7788afaeae1ae9f6776ddc79c4964b5ef2821d3689733bb2fbe24e9184a72233ad512b7927c1eeea5a9b24f3fd4998efd608e4dc105eae51dfce96fd54e6f547bae47592bc6d045e7ea46ef69739ee7cd9eb3ffbf9fd5d3401490adae4fca60d23e76e38e3d6ffde6b7d25cbd607b1be7ef7dffb834d860fba481bd7f32d91aeeb3fb2ecb643af4bc5a8afebc31769e3fa79c70769d80f36699384e270177c7afd82df645f16934c5c8b24b8fe458eff91ae6fd2c317492f48c38f643aee8bf40b76e147f20dee8bec0bd29edc7dd41b3ffc8f643bee8bbbd9d425be5f317c316e48f68fe4eb8ff88bec38e8fbfa6e029214f5b9d63fd260f308f3bf2926f9beda24f11bbedfd0964851e070b749f0c129ce1a46f05d24f8305cb04317093ee86f5c90cac1735cb00b5d64d177a9f45d81685ef0a98864d230820f52710416e3820f7247bb72e0027f0b2e86eb22792ed8627d83e233d75aa0f8618b2cfdb23e64852dd6832451288afd21eb5b248b26b00e8b9fe707ebecd8336aed752beb996b7e5ec029c3482fe76e78c19461ec2ee76e880173ad83eff3bceffb496ae0fbbe2f0d9049708add5cebbabbab5ceb7e921ae8ba67711124fddd73e5225420097c5f0f32333373cf6772dec9af906baf6f3203a3ebc50f1ffc0c8cad677dfdef33307afe7af5bf5edfaf31c05792efbf1659de777d677d7dcfbd7a2cf0abef2495796bfd6f72bbcbfdddfead36a8fef72c1ea0b26c8974599375abee5eff880fdd6ed76675edda3ff9491bfff9fe4ddaf83b59c291cbac537effbd937cbfff2a9151788744b873caadcf621226b77eb5cc3a247c64593fc8ff7bb092966888ab70b86b04735bef6e14ded6d767f1842997f547ba92444322dce69abf91776b5f7f164954dfc8bbad6751c992cb7a9c2111eee41aeb2bcb32ebb83842f7b592f3bf725efe8e2cfbe733b5b5674e8e757e5880ecc1bc7bb0f307a7c86d03bfb625d2ed79fb9899ffe33bc9a1dbfd6693437e5fd33259d25a2793ee43dfd5d5d5975b9b1cf25bed9077cfde7f64f93d95f10a511c0cb7ec1ffabec07075a9d4921544bf3edb72bcfc4d86fd54beb27f8888ca778b90eeb42c2261efdba86febbd6fd9a1f9e5521669d497beb5493273d7bf4524fe1ec9e57cef9da4d29ef7b61cba5dfa5d8974bff9555bde6efd26677777fd598434e423f0f77b437e29b5414aa892f96e83f89b59b3e2d03327768055c6166f787a2663152e32bf6fee52f1441f1f7cf1a5ede37df8fccc7359dc7a2e3243f2b9c673f9bd24f5c93abf4e92ef145b606b04d66b5e904524fcc1c69eb59ef5e04f11c9b425d29d2cb2458295a4326f392feb2749655e16eb2bc99782ae6987fcda8ce077feb4cf35fe792bc9b241f5c1a7e250bdde8321f862fd14e7d2e86f59967f82952cebb35ab644baad89a405daf276c19f248bf49eac33bf340092149759673eeb8ff8d0ed7a3fcb5be490b3fc59e4541afdc726f97e64ed7a6425c119ceff489b6987e6f52c6fc1e1ee8feb8900f426a431a8fb0f6ed9d989a5677c3937830fe0c4d23e7ce9037111229e4b043f12a7f1f399ad6793966a36ef99626c58da2776e9d70c29632c85eec4d233fa3c68a090e4fdfc23fdc2584e2c977ec9685cfa37fed16974f8e004104e4051e17036efa96d92382a821a4010431027b0252dd56cf399626cfc494b6dfb9e6900b6f91ec93400db0d8914e6df50701afd3975e97b7f432285ef3d7b3be234fa9fbd219182f7d3dede69f43dcbc3b9dcfc92a7980632a8800837c230820c2efed21f1283916d483a6071821f7e98a2cb1233b0b18dbfe4b9f4594ce17138dbc4d23e1f5cfa9c436dd06ceaa63f80cc454a1ea457d93e2dfa1da547d73b332eb55de97df43f1bc5b3a5f742ae44d5edacf7a5dbf276a92b612d6cb89e25a2765f1e5d21241fae17450049b9db7d496d59e57a14d6a2e9765f66e052cf46e1336e67a79e50b0f30515f4062df7e672aee9cb053bec48226efc47afabab2b1f6c2c227033632861650d1cfd39e4575797085c0f1a86c8e244d48153125238a3297cc62502b7f30515382a0248ca55c1b1164d36fe3203b77be60030ef949cb3a1896b342f1131f0193696c5f11936b637fea3283f7c000c18bee070b66a7149389c8dbfbcbddb720a48c34af253d2bfc506ec7c31c5958d9fc506c0c81823047758b9bab2f1c7aeb77702d02925bba7f3ab5df7fe951cbbce6b345cece2b8b29e754fc979410fe97b1d9d9776c3c0bf72112f65d77f7a7d67bd7befdefbb3bcaf9ebf7befdfbbfb77e4bca047f2ed90b41bf48f74bff7d37b1bfaf3f6b5a17078df7d5e47ce4b495ab9c6ed06c8dd532ee23d7fe791437ad6bd1997a767ddb3e865ad52df7f5adffdcc7fc0effea67d68cfea774f848b3cd7ea770f9263d3eab7c8dab4caa3fa8fac69f5bb97b50febbbe72db71c72bbe7c145ea3b55e891fcc1eafb43dd9b9ed5ef9f3fc5fa36dffbed6bf37dcfb91ad4b89cab018d2beb597d6f885e96e59ed58e6bfc2c528f9cf7a891ba7625406e9fcf9ffe47cedb91f45924a17be6da08fef4711082c503f8d3af4f6d592ffd7e8a4355926280017787ca0bdcc08eabeb7d11d2f56cd1674bfadd91423529061868951695545b56015924a1a34fc511bc67ae95dd47ceeb911d126a6d92f8d3f7a736a89fdaa1db2dfdf677b353007e0f4e1109f8e1775f49f1998bb8de7bd0458e8074cbf0c1677184ea0aaacf1f9265fdf9e014d9835dced520c6edb8e6b53842f78b64fd16392f08b278807e16eb4592f52d92e7b3888465cb79d996ac6716d90ffe9106990c1f24f9822c92c0367cb043909c9745125a97b956f283e00cc1f08f34872059490c8ce183dfba654d526f688358df2059b27e2ae967cd568be4cb22f956be5e475292f68cc3e95a409e32d22f65b77b9eaee3b9dd773fa47b5913b7fb9bfe695b67e4763ab7fbb17dfabbaeeb9e733a1bc4b923907932cf27207fb0b0673114daa77c1adab8b92573b9f4bbff6af7f7f3bee42ef77b229f4f594b689f7264a17dbe37d23e35f77b15da87733534ddef25d03fd4e6dc85b7dcefb97d6c6e19bb2591fb757fa46fc0263f21a608eef760874df6952171bf07b927bb6b685e5dfe3ed63ef4bfefbfe79ccf0671953fcdda074baee797b21bf6e176ec3e092ebba1fea37fec9200f20e19230d586eff386120bbc029c3487b369f67fc29e92414d0b9b87bcdedfff096e3cd097b46a3009e230826bad0800439dc20031bc760d4b288643e1db17ce9b17d64b73fac3c6d783987a58d4badac67937336009968ec1ab6cf1c3b00b91c1b745dcd30c70d888445871b9e7000a34b1177d85804e7734ec943ce7bc1497b36699f4049f06cf9d7fbca1f8cf6cc96467e5b2f6b1ff0fd6fdae7033f16cb96ac6f3deb0b7b36b6cfc77a7ff023e7055924873f451278dcd096e1b7fe23f986a4915fd683b379baeb23f98224df168be49e95b23bbffacf95b771d3986be5cd9db6f4409fd323f98a30bf9246dd9d21d86195eb3d93652d2b7fb0c9624ecffcbfff9e7d4c52b29cd7238dfcf24f72ec19dbced69ef578bffa0fc5e170389ccd7fc645fc7acee569cdce03eee493b1d6366e7f289bc187db7ff3649ccff34ee110c96bc42b6d5cce5d11e3967ffb0a16f7fd47a769fd8d047c79df5988b40fe7ae7cb9fd46a67882ff7c1681c672d63d11cecdc074fb75fa67dafa8ddcdcb44f3f933c3d6b9d9ef57b47922cce581c615e9d9e4d71d6b37e0a8c47b7b60fe774371d0790c9381ff48e9832e2703818669f30bb7da4670e23e736c0e57e709d72112e1a3977258acb972fd885948bf4e5d2bffbf9a00bb26b24bbfd4e96936888af6ebfd177e9839ea8e4d52473adf4af9cc4fbee5924c1ff3bd24ef2ad64d97d39afff47da28f1bebf6d50f7def3a5245f4f54f2c1f52c73cd9f8a48ba196576fb67dae6d31695700da2cc6e5b3bb9d6efe209b3eb96b9d6967b3691be498d00b9dd7f2673bb2d274e54f2baf49da4422fb5cccecc5ce3205dbc7a7693bd05387f82977332bc60a6d132ccc0bbcb3919eaa0fea0fbd0bc9acf62166f06f1724e863ba693f37e97734c42b02ee7984470653d6363d620037617b9d621d7fa99ccc0c839a62dd72fe7985070cbcadf2f32c9d4c495f1e775d535763b80dc0ee89e1af9ad1d69e437c9c4e170b83b9f92464eef7c4ae7146386ee0f3a39599c7fa4bbeefd5d44e23d73f2eb9fe2fc16bde7a40138b18cf3d9320d387f9224f0052739831657d6b2cbb9a52fae2c1eb688645eced55075653d6b71885ee61a7f8b4886e6d5a5e15a7f8b24cc4b9f4916f927392f9343f3eace771109b5b19ef54f52c6b57e273530724e862362345c846fff28e322ad20fac10e1685174e923d58d833ee597973e7bb2ee764c8e2ca7a361f64ea3db973790e20370876cf3dab5df7471a04596c40bf2d912efd239b3b8b2af8b7bd21d96ef4dbe64ede906cf48f746d9fcafed35f1af95561e4cb29cc777b3bb22d213124c2f57eda3a92da72deee3db2f4db7d93fe47bc6d2ca6e0b6f9479a927c9b641bf74fb521f9517733813c34726ea98ddb5dce2d65b90c63918479fd8fb423cda9c4a70246160d807429b521d29c0570b204e49e913091f8a74842503fdf20b64347977fb200b202e81d2ff8a29d9b8074fbdb863df3f7a79d4742bfff91e6f6b119a1dfdfbd9f4f6bfbb82dbb0ff2a7ef791fb64f5f6fbc2a00590123f8a2bf84e5f2fc72de69c39ed1a70fbe4c18fdfb878e2e1d9a97da0a80dc20b74f7bc824c8394a6d8497a77d4a23df3ee5cc48fbd0f7d7699feffa8fedc3392531ae7fac7fdae639d79fdb27259834ff120097ec88e099bf976002e096d4a1fca71301d3fc69ade328fbffe0961fb478025371fb6b869431f214976f49adae9b20e91af5a5cff405705954d25d6abb6e7e51204319f90b14e42eecf21727e052afecd2f940a0187279faf7a5ce65066282f173da87763f85726eb524bd030a19dcf9a3fffcf4ec87acc6ed9e26d9badbd95228e73e1b23dbe6b482883b3830f586153a9c61732ba048e3baec7e4ed3e603891abdcb3928a86ef9777aed5e80dc3eedd94a96f5d6ffb8c8e77111afe3229d73116f2ed2938b4cae79cfdeb441defb7b5e93b567f57bef67b565add7fbeff3bcaea3d4bdb9487def6792ef76d523eb7b5d3f3bf4dda07e4a96fe4548b7bf497b98028bcbb929a2e829a06e0bd13ede50fcd3494cebff61a6958d85e5c33c2b3bcbed2f6197610f8021978342ea1af5f5279a4d65be006e8b27787742b14e7f0f31f2852a29974b446fc95d54e8d9a463246f433581ce3c9b30da339d9e75397358ac6736582e7d1bcf8ed0d77bf642055f6ef7448c4471fb5930ea1fcff517a07d38f74413b779b84c223ee3ed248ac3a27f9240272438f7441bfd1ef9002b73900fc045910fc045d133be3ced53d621edc329788015b639447c76ec9b9e35ec0131e47ac677bcdec30fce56f25c2682f4c412414081613583191c61632a2ef3cf8ef40fb5f1330466940f4fe0da89266eb71351dc6e9e198ce53febfb6e0ab2489e32185bcfb7f5f3bfd6f741f4e9839d888465025292efa72d83be9f22fd8f0cf23e4a270f6bfa1b15ac19e286d3283c37c83fec197ffdf69e7e29c473ebb31eac64ed591be3f77c9b45d6cbfe536dfdb59e4065de69a98dc2733d1b44bfb32358aeb3677077f7f9eeb3c7985eb610caa17d93dc44c5718650cef422c4236344172210e2f9beeffbbeeffb84be28dce5234beec25d7478867011f0f96ffa67e6f530cf1f8e3d00a6b7c9c4629e5b16461221f331b171e61b1623ebd9477bf67d0c19ebd9f733e437edfb1639eb190cc917f6ef3f32b0960c599bf63d8c1c7bf6fd48f2f4ecfb1739a467dfbbc802f4ec7b912ca167df87a4093dfb1e2451e0daf7ec3f449af67d3f7f8a23f46d59eed95763ba0b0128da92874b17c6e2b22dc51785786e149e1b147eabe4b9b30c6dc973c3cf893dffb70fecf9cbd88d79181869a467fd317248d3622cf8230cf94e9bffca9189e28ffe03f3e3f7c3902c22196d19fe57fe15df4596e3156d19de72e48bc20dfabe1e39d2d8b487cf96b3fb31598e2e11c808c67f1739739aebbb63f7fbf0b97fc2a67dff3d7873bf77912212d1d69e7d7fc443922c6577da3246b2ec67bb882ee3f89e9d43e61879cb9d638cf5997462ccb83c1632def295467e8634adfbafd67194c9fe673c3debc68f2c6796ebd9982582c575e6be7624c039bbdd29ed989cff8948645f8c6cbd18d97a3306237fe7e22a76e8206d752c2fac3d63ffce3fa8b3b567ccb3d6cbcc9fabac72e9e5cbb34507a50e7ed37b1aae75f4e69486d487be77e1e4e2fb96eeee20839f0472b808e55cfade046bc8e4bbe82efd4f4442ffa667fc32aef14f19c930a21d2dbfeffba8571a399805e46286dc1b605b9670895cfa538c71be1091cbcc52e8bc80bad3d9656a4ba4282e7df79f618cf35d88b75c3acb18e74f2e287da702049fa76e39a48cf5112ea202d7c42fdff5e5ec87884effcc9ce6e1f74cbb7eb5338db11c5b3cac073b474906ba30a28ba62bc4c3c5849eb946a74d7186e4bc2209640463498488ffbcdeffc88b046718b2fc27d6347fff58f86a8c446e8b88ff2421517fe96daff72f40fb94d5a7be7f09edd3ad677d68cb1b6f81ef42442eeb5d547253010e42405d21ee7259f4b2c8b23d7b7d2491c953617b4ed417e7943377bbef723b59ff94e0b4ee8938ad7b7e06b2c548ffd6b30ec8d408648ab19c5aa696f6e96f6b342f121fdae7733aa27d3e4b0454fb44b58f4d4f2cb77bbedfe8b4eebbf17295a55c05640463f725a8c045d0184ba6badd3379d23ef5bb670137a56fed530acdeefcfeeeab98506dc95c5c44e259233a9be05af71d4219fb482023602d3dcf184baeba5df7538c4a2255e6531212f497de2644fb94d3a97de8779f0f8b48be5aad106f51a28121b8f042758598ea4e7a3d925e4a7208f363fdc3b66aebcaf176b652e7fa7733f7d9c0df97eeeeddc75dd7f1cc72bcefefc85276f9fbb2eb3aaed1779f1e59c62e7764195eae43b8c66347070d27173d3db2b6c6e8d9dab376a6773ecffe32bc73ea08d7d8081109e480219433847f96c3c577f937936a72573bebc541bbae637ecafcb2aeeb28384da0725ba270fd2759f2dc39e79ce5ec9ad0b37e27857898cbed233deb9fbc85889139bb5c29223d6b4a96425198ea064d8b44a73fa1d333de22813b9fff36c5a8bcb94239977bec596cda92c89ddffd4ce7bdf7294444c65bbce9348020c8df24ebdce6b94de476f9df7739b7ab48c25a8fb450cee5a79c33e43291cbb2d28bf5cc93fdf5a6673b7276bbfca6946b311691944244eefcb6b3fbc299bffbd2f3f83dfe208fe716fc938b7e3ab718e7cf1890e075dd7bd77d10a5f426d67d4929ed485b32b9dd53727631cea746dded3a4b72d9755de74f20b70fbd6077777b7bcb00f697eeee3d6bbfccf432fbf897dd3788a8af5f5d3107807ee9de414e49a2795b095f5d5d6effb2bb8d5a890817c9a76701e98325330d625ba70b2a7391c945f896f4b9b6c6382f7dfa5e7b367ffec806f885970dd0e6394b505582d9ed449313b8ef8201726fc0eaf60c07708740ee12702901167480f38f984c7c694288af7d027039c744976be4d7bfc8fdb84873cd595150b18aeec585f791f1b1bcd4d7e55c1371b0445ccb69006b53a8456c05e1a247bc6050239d02165601d3da2226468232623130323cf50a3855408239aedf2e0196db3fc4c80765c84528002e915bde9044fe4454c6cb3ff4978a5fce5d4af6b8200d295943ca2ee88594e471c12fa4e4cc056b48c9980bb2424ac25cb0155232c805c190923c170c434a861714434ab62ee80a29c9bae02ba4a477c131a46477415848497a419890927ec19890927dc1180c2c2626e3b24446e3ddc9ddd0b580f30aa8286e49a19a8082f280169d86c262ced9ed05ea0caa840f4a24415929d1841249283184a7441b6228a1c496fa8d97734ac8515d31b0bca6568b0360750ac1277189dc12276831e10ae7d42b146364282e505bc46496f012c25c2616de662249092c4b58dd3126b3c41bb5c28493891a6238c74416d8f8728921d8625518170c16e04cc1571954d3edc94dc059c41836146e323373126d24e18593f8726524c87c11d39fad4a9ebaced39673887333b72a798ada72e6b69c35151628d87f3f8e0ffbbcf88f0c4dd9552fc8946d35f323e3f15134b6b574ee3fd9287694d31aca69dd4f4e6ba75c12b95bce2a9eba652f4199ec74923dccccc7bccccfe75156198c2dff636c29b3e5e8d45aaa6664ac66aa50cdcce0bccc30cd3055cd34cd3459c954dd923249d9d1025bcdccd4cc8cac8b4cf6fd4de53f3c686c6c2ccf6a6a2c0d0d0d0f4b79f008656f4566ca66acf7f3a7d37492eae9659c54cf1ff3b3cbf3ebd9a614fb39f52fb2e78e71dad74f29191a1e5353aacb949215999fb132a599b7223369ec0b323b3363a79722a4db39ae75c76c59636c39c2d85206b3e56cb4e5f7bfc8ceb195950b9ef84007d0880304b6594b2db551830db87165fb5c8ba8343c80abc3043656d73147087032e08ab0816c2859e9d2050c4e6063a7b95e7ca79af1c2644714554d6ea585e25ea04e2fd0a714c0616b24a66e4999a46ee75cb3d9d8b2a54c566df9f7b3b9dced9fe5b4388d9d3c5bd6a7ce962394d3f8525bca8e2411e534be6ecbbf50311dd303c83925cddd999f89e241130545c38366522d4eebe741e79cb28ac9c46233333433333c66666a64646256c94aec9564373ff333df3236375f4dcddbd467ffe161797c0d8bc682cf36997d61c6be20f3ad076913283e65125f4f712fd8bbd5b7555b5575eef3a8ea50ac677fe2a9b5bdb853d15792b1de45e6adc4629e6d4a32d6a73e86a45ae69496a9db1ff3e59c1a81d32d1b57c563d556fed34f4eebafa3ac9f6e3f68ad1ad731b69f26ae9fc62a1be7d47c9a5652d3d64f9d1a14fff55552b7ab6e4ff194ffc8c4bac81e05a74d2a1e305e669e9d36be8cccb3d35c6fc563cf4e0bbf63969d063e28533ff6e28c65a7b15ee65f3c2c3badf5330fbbc92ccff7532dfec3c3a2e0b4f93330b6e42e773ecc965566b42553ddf92f5b8e31cb4e73d992bddcf9a22d65a12db9eace07a996dbcfe33f2d5b56962dc7caf3f178b6ac9dadf3eb6521c1348c1c20e780ec3face707adaaa68d454e1b4fd127a7e12ad3d8c44f71fee3ef24d3323631ddae2375f72e5053fec3b62e54d40b7d826a2aae7226ff513a8ab1d5af4fadf0c9296c396979a55ba8a5c97f94beb7e255eb4c4eebffac37b93375d465bafddec5f2fbf7f4bd9fdfb2b63fdb9e65a7cda6a6f2a2e5f6971d75fbbbc97fc62a1bddbbc828eef697dfdf915063e950936d2fa34fd73673d38b97cfab9a39a8692515859bca35531729a7b537a99a3edda64ffed3475831061a1da86105b67e0ae53fae830dbe1061441054d8fa6994ffcca519c0b8b2baf2c2d64f73fe13e40a1ecab85ada62eba752fe339da82307263a70c0d95a4bffd4e23fb76903bf5bdfacff89f21feffba784fd55fc07b42538adb79838ff695914fa2793ffb0ac0afdb3a95a262f789605a7f537f52e5cebf72eb7dfddbd9f8971d2aa0f89f6584515ff61b0b2be9c5a2e2f4d1beb5fb077f173abf52087e2873ffeebcbc974f92b09b333cacb6827d4d2b4bd443b9f467e1496a60df6adfa254b7dc939f04b2297c32f792effcc7f6e283c3f8c9c52e48b9c5d5ce4a422a717d6f3d72a4ef347c169e2f38f22682753cbcea6b6a5cc4e2d4e9bb6fc3bbf9c52f367b30abe3f4f0debfb13a995b258ef5f82ff80e0cf9c361fb4ffd992a5eefcf23d5b724ec6b263674b22d569d4963c7776cd8a01e49cb273255b3dfd92a7a82dd996b3cbb664abeb930463399d9e6ec9565655fed3a50b1595172fe594f29fdb1fc5d8fca793ffdcc4f7befbc207bf64a9af6b3deb4bce755ffdef4b22b79c4e2e7b7b41f4eccc697d7bc1fb723a85f641a95ccbca589c8baa76fc884079b6b2d34a9e6e2175d31480a327fb76da7ddebb9effc3faac16188ab19779feeaaed7088b81791ba6698bc9ccf0a8f9a4a56aa37999272df1d86c6c0d0d199391313c666448598ca4e120f363c8fab15a1c040c6b6c6e38480f1f381cc425be46184ccd746fba8db445df738deb9e7ef8370773b85ce35e56bcfef737f7a77f0bedadab9ce650537846960b1c5b7ff3b1a79ce6b73975e3d9e404c29acaebec6d56fd847a7d2e741c2bd7385c2ee46155415541b1fe6b2a707cb6815fb693d89a4ea3eb4b1e5ff65db64e89a1958176ec26961dab954d1dc5d83e5b9dd6cf36cfb28dfa0b69762b0b9073ca59553faf7bfef71ffafc1ed991569c9256fc236f325fc91b8f3f8ab1252d8936eafdd2b4794d947e47ff567f69daeadfba168bbb5f9ab6ce5b323154ad5f9ab6968cbd252d89b62426116c32bf346d37245288bdccdf78d8db8c5d9a3619ff987f8cbd4d2aa7f9c3d8a5696bf9c3ec14a7f9b3ec8d89d3fc47bb346d9dffcbfecd6597a6addadbe8347fd14ea71b3bcd3fb44bd3e6f9837636396daa7aef8d9dd3ccd129ef998ae7e3aad69793aa658f626cddb3ec518c8d3edbbeafcfb6fae584aae4477a6447ca9c369f92efb4396348b3bfafea8ef44b59f9b79cf5dc31127dcbf5ce62bd7d4104bf5b2dd0bec00a9f3efb4f685f68bd7e3efb8f52d873c73834ef2765530affc624c4f6b22f802efb42f879569e95ff88564914ad67e534ffd02a85e1f753eab3e583560904676eda52d6b24aadb7525fa96539ca69fed47a562cabc47a2bd5be409f6d4a2ccb4eeb9f504efb703d778c44def7cf2546ce2181eb27a927ce2181bb9e37359f9efce766c58f626cb5f5dfaa3259fdd638de723edd9884d858764cd9acf80bec3411aa6c4f3d778c7fdb9673887ecf1de308ccb5b256f6979fd44c629c498ce5e7e459959f5397f9d4b7fca43e29ff994f4ef3af751c65b25b7e52d79ffdffe23ea74fea73e2336ee94d7956de54cf2d3d9cf7e4e13aa82e1d54ec9694aa63a26add9236d128dad4ddd2735e5c8be7bacab5485955b513aea59eaed55339ad7826ee4beec253d6eb7389712a31cedb5fcea7afea32074715a9eb97179066c766c5a9288e15ff52d361ec26e78be9b159695cffd2fc6cfeb2390f9be3d8fc039bdb9bf74c426c9dc454b359712bdc92676ba6b675cbd630b6aeb1b5b53508b6b6b7ee9984786c24c9ca6763e2b1f52fb9cd3b9b8b3697b1790f9b7760737bf36712d24ebbb637fa4731b6ef6bcf7b2b2eeb3acf8e6e6f4c426cfe4c426cb718b7ecb4f94731362621366fd21cf8fec334b6d34f5a7a99edfba4a5d1e63df8fcd57f929886d89262bf44c4d6faa5d096b4f436d6d7e797f94f12d34d28be5c3ffe528e0d7cfe318969664b5a2262837dd2128f2de6976636985f92d9c64f5ae2b179335bc741e6272dbd8d7290f9cc21cce78f215d1c643e0c297290f930f2c541e68fe4c821cc7f91321c64be8b8c7190f92239c341e687240f0e321f24652c647e8bfc38c87c16197290f995ac1c020799ef91351c647e47de7090f994ecc141e63be98383cc6f128783cc3f8a99ad05e8d15f8a6123494c3c36ff256a6ba71d7dfeafb25addf3879dadaed70883f1e78fb111262ac34698c21936c214e3c146986e646c842987868d30e9d8daca9c6684a9deb011a6b1071b6192f960234c6febe7c761234c331b1ba1964536e276ac61236ddf69f3f98fe86c2a9073ca6e0a89b1ec9e3a29f1add05c14ebadb00b4e500714d3101bfd9b9527ffb137b732886013eded86f3eccd7b1944b0b1ec0de9082a64e8ec0d034a503029b18226ae6c371944b0517b3b52c38730b43c75c9c1e6f4bb4f5a0a6d5e8faf55b79f296663799de7e35bd489aae3f134f63c62ddcb4ce13ccc146da2f65dfc1b1229906fff063ef9379b07e9e76ecbbe86e2fe657fc3ddfe9c8b1c7ccecccddf904821e667fed6317ffbfec614b3f98714eab6573914cdbbfe0675fbab6ee7d89bf81cd8b7f63692f6760404dfc6de68aec6dea8ccdefcade778d81bc7622f636f74caa7702c6d82c9be656fd487a5b4875dd2b1d5677d39e658f5a6e66d605ee4f1dd7a98538beaf657279967395131958dbd895f639938ad7fc6de50705a7f8cbdf138adffb3b7251ddbf7a1bd5128af72a886a2b15df53cc5e3c9441e33cf637c2fe6f523d46d575d280e21c40b47257abe100422480d636ff0b0421925c6f9bee3f44b77770edddddd8180618e12351a86620e3a345dfc10c3d02592e0e038b95d25d205e1be42100b1a1d43590c66b090470c1fc0843de0f020268c3131cee79c58c8030b0732618b0576266cbd80e411be154f65a10f2a7068c287818f9a3096450f9b7044c10dbd0963399b1ea10f236a7c846710118387cb0c8be72d3223e390a9537322dca0508e713e75777797c1096169c4ea87231731950c7d60016343191630ca41f82d8d342714a35e1d842010aeea410802217e10be72086761cb0990d2c2708c560521fcae60fd087d00e1e9842d233a2021521312e37ce7aacb5f1391f07750e37c7777770a24a470305bba13864174e5093d2e6690b053639ceffccc3b406a3a3f40a0cd3ef0a0831c0e2cf9383e7adcd8d4d0c878ccc8c46260785c43f3eada24e1b93eaedbd202b608af5e3dfc3aea125fcf2292f18f34c82212d81f6998ef594412c3748c7d0ecf902305402105264fa618e1926653cf3a4bab95e32d5a9ae6985a9a6696f6d1021391cc2ae66c82b7cc288edc1614de64ea59e3dc0027132ea97d7c1ce793771daa00469c3052654a1b56538caabceaf0c1881025108922c2021339bc3079c2822b8e26225a4c1832c5101550f0d20585145410d7984943b0a0c043029e128ed0c152470a5042488615cfc4a5a053021d223c7610e11942045ca30d9d39549849319bbd0c669f336bd54135f322811c26847264630d1e7cb0caea773f4b4452ddb84e2f483a2994735b767eeb33c1c82dd2a8bbad56cbd69b198ce574fad6b784e8a72212f08477f0c90d15df4d8cf5e54d7973c1564bd602bf7ecb96e07f7fc46364949b5b3ef944245f3512c7752b747363be18cb822c0aef5ba4904c268bc53e161945764b16ae7ffdde1391781f8fecc278304484622808bf450ac5ca5819bb2d4a416e9fd67b6194d82d85aeff4796fede772292d0bd1cb742b10b0b613a53c613bce8077e39dedc502af47e0fb6c872bce00bfcd7d3fea14d03fff5e10c403877c07f3d8fafffc872ca108f4f45242f6b44ef28bbe3f82f925ea3f009d7b748a1f00365b2da7a6f916578c177b20caf0b7cd7d719803a77c0773d8b43e1f56c697443f09d74bd8b485ce183e477757555c70dad5078c50767e822e975d156f97018f9bdfb1669e4d73ba8919d9c2c67cb967f5bb29b1bd9188b8de16d7d19b640f0f35bff48b3482a2db2acb7f54e96357c7f3a03c073a7a4b7f5fe21c93d6bfd1107ed90b7ba67916595a1d92292eeb31e299e403b6a67cce4a00890bf2231f2cf0180ff334aa9fd2029891f1b500308aa314b07738cafcb393594408063ac76ccde185d7074808291950608368ca3173433466f8a668391750508698c2214514fb33ad200c20318a4418307b934965890460c52e377830fc8183d393ec861a46f7840c358d360638c0ed0183b30406862ac5b7800c4c892ea800553d0e2780206682cd102348ca08931d6343ad862a4657460c6c802c3832c63ddc28df15b0108478c314e80f0c4c81ac1075d8c303efcf8800e5acec0b2c6194a5db8d8f2410f638d0c3c9861ac29f062fca2e8e089b1b5841523ab08da0c660c7141b0327e977366fc70671c3043cb9d9fc3050f6a9871cbe761dd3c7f09fe439f7f8afff8b3cdf3cf9cffccd6f31f61c17f68cf38cff6f5fc44fcc7d5e3397cfe09e53f391ffb98e757c17f609e3d781e9f5ff6fc28f88f8fe7afe23f33cfa408822deb05e19bb499fd07dfc177e48d55aaf99bf748cbc1dbffff481cabe475f0b3af24cd2a75f7b407c91cab94f3cfc18b648ffeeeebc3480fac07effd072f439256c9929ff33c481f568926f3f56948259b57f2f15978b9207c4cc7d6c3c7dffc8b54f261affcb02989efe36bbe5563afb86c386f639568fef537f68a8c4de9fb9a97d97cec5b1f432ad9c4fee65d37effa98bde236251eff7a16a97463afd46c4ab0bf717deb29a9e4b25704605302df47cb5eb9b129b5bee66dec95984dc9e6e9c3904a32d55ea1b129d5aff9b657aa4dc9e6fb9d66af4c9b52ec6f5ec65ef16c4aaef7f19dbd02635392f9d7cf904a337bc5c6a6d4bdcd07f64a8e4d49f6aff7e04352c9037ba5655382f1ec95974d297c1fdf81bd42c4a6e47dcd8fa4921525245b8ebdf2814dc9e6fddf5ea1d99466fec5fa7ff227a9c481bdd236a5f16fde8a1292cdda2b03b029bdde87556259a5f19560af04f34ab18ff92bd3e6e3497be5c7a6c4fa1aab54f357a6edadd27ca57e257fa5eee9e3904a3656e9cab4d9bc0fabe4bdd2f74aac9fdf83548af91bab646395645e69e69578bc12cdcbfecab4d55825f095c257125fe9f5ae3fe2209047b94b43b2d3f865e4cc69fc3c48149cc63f4356711abf0c399d9cc61f23abd3f863481ea7f1c3902a380de734fe919c4f4e637e1749c469fc22c9c469fc2139999cc60f9213ca69fc2d52e6347e1679c469fc9564c1694d4ee3f7c819e534fe8e7ca7f153b204a7f13b39c569fc4d4e2d4ecb398d1f691ed1ba12017283fcdc73c738c284e25abf0a5cebf6c058765303317ee397b381184ba6fa619cb7ac138a8b14f10f054dfe8f6a4e8f6a2fcfa45d62087e3b8d51dd62d5afbbbb9b54e02245303f14f47abe4530b6a9b856ebe787d97236bebe9c512b98ba8d858bbcec7f2d8e9a358ddf6539b4207b5354546b4671b5519f8dba1dc5b5fe26b6d591868061b3aa4175db73652dc752e6e4d04bfc21309cf3f54114ea5f41f4881b97f841f44926065121626010751abd20ea43cffa893a5b06512d3deb328836f5accb8f36d1b3fe209aa567fded14fbf7be7bfafe9ef39f98a5514eeb87b1ecb40e46479bcbe572b95cee874659772fb7dd8b7b712d5ab468712d2d56fdaa5aacfa55454949494949b5935454545454543b39393939d1262ba7282b2b2b2bab693535353535f534f5f4f4f4f4549f260e377113377113a70277e12edc85bbf0f0f0f0f0f0f0781dad4d342a2a2a2aaafb69136da24d54ae2ef234e322e00fb59c862068cbefd97ca2962d6f7a36653d9bb19ecdb167734eff30ca25866054944b0cc1a828aa16ab7e54542d56fda8a85aacfa514545b9c4108c8a72d9b28ab61cc3a81b2515e54d2d56edffbca9d56255fb7969b1aa179d5c2e97cbb596afcb75aa5a4719ada202499d5b555555552555252525252535a5a6d3749a4efdd3a98a95959595150a3cc5533c35f33a3a6bafe7d3ea55fa51a6fe80538db2060093d314b79c5d3ab2ec926b531c8173458a3c5abba9fba0f97c51e0daa4f1cf6c62f1cfecd234c50880203272a4b9eeb41276fdc18ea47736f98f6cfc88fa0ecddb3f9b6617ff91c9c6b1cbfdbc26a70d5cf3aad9e7d1ef1ec67276995daeff6c721f6532dad44e1e0c40ce017bee1887986b1f0a5c842f5bb23d307a141929b841e1d77cbf47d13e6590f83639d7df6c797d0fa9f17d60017b9c29987f2e314f7ebf77699f92af626fbfdfc5689f3248e639285dcbd7e780742c3debb7a433f5ac9f243da967fd4f3aae67fd3864fb20dbaa67fd3dc8be21bbaa67fd3664d790eda56773d24cd9e43167a60ce9627817e7e2538e854bf916cf79141ee53476b716b0c5aadddddd44aa8f54d6a19792bdcc5cb3e03fb58ea34ce6e57e2587442691d9fd50277573924d5cebff6c39f3d23ebdb47be9597727f5ace7979ef59ca367fd234c25d336960e8ce5f40282b1e78e916f0a5c643ecf8b4596cb392c926ed95e5860753d4bfbf8f45cd3ed7ce1fc5318e2f926b2a9b8083b55d3d7677debc1ef20c6a27ef7a74ced1334ad479111059628ec68ca65d9a245ca072c9ca684e0f2d43e41dee58a1ed13e412ec6d5d597ebdf3e8c657b89baccb5efcb49e54d5eaebf37799337f984729affa4f3b3448ce564bafe93a9a96758faa7b364e99ff6c187fe692184e89f3ea29be8997f3b8d2591eb445eb6ace0d8126d2963fdadb63af27091cf76d4f765375151f97ca69d37a93a8a8b7cefad6e7a96fd6acbff9494df1677529df15f4ad99ca367d496e3d06ca367fe2328999dd481712289930505a5df7bffd510fcd68b1fbee892c17ebc8979988f199a5f24f3b197b132b11818d8f8728921d862d5cfeb6833d163bbab5dec76a7dd77d8c25f6a3d75dbf676e4bdf72fffa6dd1fdd34adfe47acef64fd47ded3efabff512b46bfffa8be077ef7fd51ebfd975a369817addf7fd4bd0763fdf74720cc78043ee85a6ad9446b0567fcdb52cbe6b256705a7fc40261fe1efda3eefb996a6cafbf3deb8fc0ff7ea9651bad151c97bdb1beeffa47fef4996a6c626841cb2dd6d3ee8fbeaf7f3beabe6b59fab72396ad7f3bf2af7ff43dad479f773beae891b7fd0e01363f2840ea03b8d93c538dcded8dfe6dc9b3f90fe11c7d5bd8dcde965c367fa6191b1d9ab4b3f2ba62aab1f9dface02cb53a6aade0dc8ec49f792baf1a5b4d0c667481b0f075139b81195d60cc0b269b81898d2e500616139b898d30957a3132638f99188ceb8fc21f6f40d6d7fd91f74e440f1b9a97752f93592b38b7a3dab2a1b156706e472d5ad9064db69b9a9918cc08fe51f8aebf2db56c36d60a0e8dccde986a6c3ceceda8f5333198d105b2beee8fc2f7bf1dd59f89c18c2e90e57f14fef7b723fa33b1bf1dc93cccdf8e627efcdb11ec5d7f3b7a3df8b723f1bf3f0a9f35637364ec18b31f636330f6066665a395bdec8dcbc6449bf347a17dd08e2dcb2c1b56fbd9da21f4df8e3c1b760821f41f515b3b84f96e6987d0cf7f6433595220fb73fdaf7cb074bdf83cfeeb19e661cfb18f29737a46c690dfb37e1812468ea4cc458a64488e2d16890433671b20b74f10578d4145b8bae38eeb4135280c1a836241b2a09ba0b7422204e5f8d5d51dd7e71060cf1d2351918f21fe21d60fd51ffa7ec8fba1ee87e80f157d53b7bf0809d16422b6e5b39e8865cb9bfa44d596b2ef893e5bc6bc27f26c39764fd4d932ec1913515b52a9b9fe44fddedc6da9ccdc69735873c600e4f629f2bca2aefba12216ab55148645afd758040313f345ee324533333c8a643f34bf48f643343688686868841186e60fc57ec87f08f643ae1fa20fbe92fa4afa8766dbf2f6a4b1a56cdaf279d872e62626634b8fd952068bb1250ccc9631d768cb97cb9623f8546a405b862d5bb2a8d45cfa546a6e2da9d4dccf96df16d7f3efec10ced5d5d5a5b6a45273dd96df16d7bf34f2ae5b2a33b7ad6cd227c09b1eb3c8b44c33f3f26a6c280f598d89c9843d9b45da8e21172132a2b7fba1d7a532c3e2224446dea53f24c2a512bb5d1122a3befe437ea9c844eff95d9e8db5b80895f07645a8d0db15a102738b506951e94bed4dcf66112ae3eda7e2ba5e848a77dde6f46c1669eb47804c9fc8e87b7eda7d5eebf96b6db15ccf1f82a14b7cfe1136fe2bf6fc31d78589bd917763de68e60ebd2e8fe7978557e689a8d0cbe38de89d79a3d81d12e1da1019c15cd91319b52ecd1351f1aecd1bf5ad792222a3f1fa7822a37a7bfccd1bc9ee905f1c2223d725a2d217c736d7e61b7977be0fd2b936bf0749b936ff86ecb836df8664716d7e0d59b9369f86fcb8365f467a5c9bcf830cb9367f8604b9365f866c716d7e8c7c716dd66a23d7605c83e1da0cd764b816e35a0cd768b826e31a0faedd70cd866b355cabd56af3917c4cb7ea26a9154859b1245585941452725f4460031ee478aafae28a10b0ae48828731368e35a717d4000c28a83881162fae08afc8218771e6724eaa885b8eef6b744edd690f358c327777291bae63b1b9ffbbbbf70da3eb724e0a861b5ece5d41c7ed2ee7aea8aa01581241dd1e21c18f449090107fdb2877fe5123cd1e01acedd34dd6f993e79c64cfb9022e5cb8542e5c64df5812b9a38f7fe3e0e978f6bb9c9e7161755688e77a9ee7d93f03acb4769de75531c6f5aa80010c150b1876f0210926a82742d0c515705cd1e50a29afbb2e2d83c7e58aa4eb793ef4522b1db9e08d29b810e38c2fbcb03117ae250fe74ca29e2d5e688163ea06343eb0851561b0ac30e3035dd7759d155bb07458baa2b5250b261e991552d430bb12b028a55356f4205af154831532b8acd0e1735070cbe7f18cc86d69aa62cb16301a872e72d862820f6879838c2b1b6dc1a53fc271691572e8d04ab1cbb92d465cf0726e0b102ab83296fd749bca7f3c2fb3ca9b534ef3ec0b1eae8b6745c5349ba6962a4f4c3cfef37d7f49a47b1b25df69de5447da34807ef79d7da13eb5b10d9ce1870485044c9bf77d47ffb347ded3ee864403e61b245801ce569ffeedc8fbefab3df2fe85a3cfe25c0c1964c1d9e8d3eefb65fe4343701cd94f651f71e73fd934a07befbb299b06d0f79ebe376d1d3992b643eafe3cc0e33f6de3075f4f77faeb5d4fa442eb59df302caa70ab475a01e20b302f3a6883bd5b2414a6c2bcdcf994eaceffaa5ce6e9cc53d807f3627d507c5004ad4d3fab71534e9b0fd3c5a6adee7c5733b55337b5963bbf2389ba17c1fa300f635f807d7db689301ff331f685ef619e6de0b745d2b18f817dec5954e1fb986f62baf3452d777e8cb4f11ec9167bb02389fa55783debfd895468bdebfd871a70033ffcd737e026fef8ad07a7a802eceb4f5185ef611e85a4fa30e1d787b136f4679eaa386d3e8cc4d9d0e974e7cb58a8182975e7c790365e54eeceef4652e634a2a27987868814a0801f2252c1a601ad7f7dab9f48059b06bc5e10fff56c83f9b648baa70ffbef41d8b3a882f81f0c09236dfa916cf5412a2a806d49ad7f3500fcd6b7a882f8af175508bff52caa30da97b5f1774d89644856929dd6226ddca2c01d42974ada34928d9d763422755d5d0072775227c5643763cc47d9181bc7366698819513d440b5851646884ed45063e3e51c1549b0018eded9efd97432a767b418dc510618531da0428a2c7ea82148a25688e7765dd7f97377871b556429430d2f6164810596ee061afe676b7ccefbcfe83f9ffdb276dd8fb8ebdd6ee9765d47ed1af53f27bc9ca30204b77c9e6e066f94c5a8e8c0951e65e5786354d8304367a9b8b2e44d41b798428c18a618c30a8fcbb929d0b8f4726e0a32b8413abf2fc3eb799e57dff33ccff3bc8fa43da39ef7a3ccfb59fb08f15c5a1b07907368bf0da57d3bb8f38914a07f2ad5cc9dc0eacea992e7ce1c0a7077feecce2a140c714b2377caeeb4bad4fb3ec08ad50c99c21e1083975bdbc7610f88c1a9677cc1c9ddaeb6338e31e672ee04572e4f39317af7a5ce0562022f2935c11b9732d9e8c7fa87da28a5b3ac945213b07129a5fea3db8e83cb39135c71c5cb39134071cbf1697b1726f0c10447c891e3e58cf096cb43faa7daf87352545dd8e59c144997c5fe233ddd18633fffa69c1d19eb99900c9c88c1972b1a8050818d5e71e98fb92a2efd9bfee11c0e8793c1463fa77fd8466de95688675c63e45b8eb7dae6fc26c79813a3783907051cb77eb9e5f828005fcc3e77a6902f403a521b92aee58ea45c73bf8d9c7ba2897291eefb3b2e22c7954d27e9144e97a7e8aaae3f38d4fd34724e055d9e6ec9530eb502dca5560ed573c7d8cf391574f1efa4fce7880aa09ac65153b92e5254d75530d534be65e7e5fa774efe43a7a895ffb49414e788102969f5c68e366e8a8bb42dfa7ea8e8b3fec435ff69c535fff9d4a58318dbce2f5c73ce498971cbee72fd5b88b1ac01e01f87fa1ff6e11f0fa54da8c4a9150cb4899a041d536a06680441400353156030482c168e08048a26d7f80114801098b2545a9fcaf42888814a19430821841802000020002030334c0002449b3da1f71f290cec0d6a2eda91cd9c18032ff0dca5a25b87109f947ed71b47ba08981d9bf2eb8274611b9bb453e3e7ac8da1b052cda092de2ca54eb20d304da0082804cda4a1f3c20b1db431f06a0187aaa837b4efb965f92729070114f4bcea59b995635e6ab964472cf4a36ab4b19709c2ca9de559662a421ffc529d1a7b238b3f2aedbd15738daf14666fd4f24795bdb76256f795d26a6f84fde51b60d7db9446a2d08e90226a9d8d122b1a6cb88ea4185e8ab8e828c0b547bbd13679d2e8eb62008f3df7c003341b2a56a1313c5bee8c133f55ef2b6be3a8f64de1d95bb8527d6f859fb221f71f6bcd8b6c8a9d7e5ae19cbd1d83b6ef5dca812c912fb71f29ccf63e3881fc2ddb5d2cbf8e2013a84318cfc5ea0ddb63bb22e7865cad61f213d625e0059b3965d0d0ba019f1b9c8f463543f237858748ee5ea3cc8ce2e9169db250f69c42c4957ef25f05bf927d337805e7a9c127a68ab304437b4fdf1cec75c4976720c5cf675cbc7c9600104ec31deab1daa6da90ea2e68b2d3fb183b47fada1739a348859ad424dfcd9b5a51a636050bdaa24005bb3e09d32a06af898c3ed46bd7ac2df71250bb69135da4b3230e9a600952a3cc8dcc1ef833daf8af458999fb360a2a0b55ccab6b747098d712665194cb54527b1c476b4e091333379dbd6d06867ef58142c14f115b2b940d25b4d25e5dc424683aff6af940c398b7e6d19b796ea7247d57f6f1b29f5a3042643962d66c46aea38ee900a581e4719715dac6a44d115c8616ed20a5c64ae32713d2162995829cb618dba14a67e654b9a7aa0ad972cd3565b969a3ac543a5ca6a717047923c352c8baaad3acab74ac18f070c0da4cd214b5d89b3bab2805208b9e7870c36ad252ece6816850c9a571009a29569705ebaac0e73f4d13750b574673759a8e009465223fd72f4de9a84d861936f12ed4982c4395d1424c35e51c48136a3bb71e1d79b70b521edddfdd699a24380f1faa9b9e956b7b3d41859a768f66a9d89e720e4ef1c4423e57ef896749b13efdcf6ce9e1356c06ce10e06fa93e1305e565f67da0669b831e088c05fa2f19bc2ebf67657f7d691c9ce87d1f5761c8bbe256fe5cb3f027af104fab7322ded5187c0c5e42ee42ce8a270b5b252e3f050235054a7b7bf28ab5bea6c6b4f4964b56e2cb65ff8d2cea2a8a4b3f71ed05c0442127b2aa9aa3d5949d533991365698308826d8568c9a443f916060611e49de48596136deddaaca8651c4e1c762906a01a1b40da9f7888ada2ba960e322b592daa3de0455ba1582813a54d77f8d896cf131506088a9bba9f2e218a5a46f5ec66a4faf1697b1753c30fa2d759189369d38b8d6059246990ab474780e435d3f1772b935304f056102dd56386b9372ef6b781125778254d44995bab3eda025a1b15072bad43cc1afd5682b16ce25195ebae8309c013ed5bbfaa9c7820349259df8681249971dfd2c01ddc3db884b424f3a0126be38a999dec88aa3d05b904b4bd83d2ee6043c1d394cfae52f77a340521e074963371f336152fe576a72774a16cc67fe0188393e5257b75f154c9409184dc7882e8e76c44c617f8bbe191a9eafe4d9243cae15e21df29d5863ca452ef3245a288ba66b90922243c5425aba5c8c845af81354dfb276445e7638df27521ac547dbc3cba9a395ba982649ee347c062f49167dbeb91b7d93f4daeadffcdf3b893749e28ea96747a2251dd12dcddf32d81258ac5e1626fd71cad511914d5d789326ef8c6c39e122d373d120c1974946253fc4bfb63eed5e467fba65f46440959dd836ea6d27bc4a21e599bf34788ad8bd92bc90f8902deffc3049c8b70c9de0629f23c561da895c73531c7471978f3e349ec1402aaeb5a6420bfec49334613ba38eb3267466eb8ce8d59adf4b3e7fa89e2274c0b2c1d5e34047f6fa091d695fe9d1064ba530cecb62fcef245c4b8f43d09f1cfb284d2456bb7aacc819ca1888b7dbe2ca0ff83c8994bef1da1806f9c27a7ebb01f4066e489df2076af97793f05fc779fded8cc8857e1fa2017d627eeefda020eaf90d931dea0bf2ef799e2b75c10b0f8c339059b86124a8db6a81dc435fb43b9890082202d636438c8a86aba073f75df8e3cb00f25ec6f0720a6cd342f71ee185cf3ecc02d4534e7487cf64be6feb6ec18d340400426452f811407ee619e2f0a440bf0d20f1252a42c6506345663530c1585405f964c212073a6ff8b86b0d61a2ae9c0511f5e57ec7bb433e6514688a56697d15b4c70ba4dff9ab8ba44f7a83dc758e4cf30c54e781d89513d83d6c9915014b882ac53f346c1c4b54bdb424b3db0688c95498cb9cd1f3912197cad54afadd7992b8f40e38baf374eb32a5e899740e46de3a43a8f39bfe7c9f77fb734e886a2212d4c175032075d54e4f44663a096901c81b5d71042a0f83841fc18dcfbda063064b2b09936097c6d75db9116b120847d2f7e01baca50e9ee5276548f69e0b460954143ed52ace21ac28e0c83f9e3d68202df581b25a558ab3dea6f7903571f32706ea6f46e7d1e53f6d15283d8ec329093f492b9eb51e5911020f4c6275593de84cc4fa54886d513dfec010bf4ac8111316299d70238b13cb64835f4849c7656d2e0a85cbaf474a1b9ef97cc84dbcad93e7bdf19c407ddfbbdfcb660f84cb303a705bea1c8ca65fb7955df5a2799b464b5499d4ffb010399475a9bf24a1a5aa03ef2c7dd2742b2336842a1b2c0ad87730a7c4ca3f80e15e3855f446d650449477629f313c4f6fb4a4217a4a3923e2f24408ec1d306fe55d3ce2f2f74536516422b51e0064cdd56b59be5baedd1e0d3f181055d0133f7cc1fe93eaa5410f74a11b148f70902a9f4e2676a6b4ac09fe8adc5f2a4f92aa5b8eda56735b937214772fda15e585d2c2a28777e3e755039e14322c5e88726dd471b446e35431e4a16d93141a72c3cc5fc1e0ce7731033d8ed114ad8b28fb8134a6a282c1fc20b6c5bd8caf1dc90d42bb6a4b01633d71b7b117faef2ff0a21c6a04c3e80736d1bbe6e843733cfd43091f91d2457f54f5355960682c21079aa9029fd89d215e307f6a4302057a57c42e62e034e52adf29c32f54f2d3d99d80053b9635ef497c564f733fd658c2b2819f189c57e9ab1ca23f1f2edf474eabbaa0371d966c29c6a30ec7cf09e866b7f88dddf0491ded82d9750976336d482c070633bb3b74b3fb1bd64564faff999dc059947cee8bc9d7815955e5e7a395c65a9988e184cfa2aba11d7a67263257d80c86466de8f6608bbe5ce27fe78cec69c143a2f2fa3064b76765d5c5d29e4f467b4d60793bfa8711d61bcd37bd612e548d115f7e3601fb39192e1fc068ec54b4eb8c9bfbc03f0d32c346d587193b8ea03f89d7c3b0388800ce66685019b0302d438b54cda15e038f79fc73f15bba5e4eefa3854b37d6ed5b9871a4c68d574525fd6e5007eac2a7ab425f0f09b43d6b8bb407bdd007d57dfec15cc52977cc66dbd6aad4cf6ebb25c7c66c7477729dbd1e4102b4911dfc436e9c29b3aad343aa41ef334246749f382e62d8d479cac350015db653088a4e93b24be39fa1beb8e1add7776c9826d28c4e8a96d554e4e62560277dd21e413f73e700c1b10e90a442a210b5c402d206d083c21b9b9a166ce94ac1f82a51040b1f3125afd009698a7b3faa49f4758298e68b352fbaf599bcece122f88bb819e604cc23088b88bd725c06333d184a2fe4285c4adb755ee942c78e0dffe0ca705cd465f6cf41406053e51ba9f5d14894bc014deaee964462db16cd2b60296041e8c4028d9db38eb6acb9a1451d6f72e963f8a96bb4ca7913b7e16a174162118e1d94dcb0593f660ee859b9736261b26643ce67ff9f7cb76152f0f222db9042a421a9d4b642938423414faca9aafca9ac52a4e42fefe1fcb3a9769c4daabe989c05ddc21873df5c3296475701c66f8e8e05e3e4626b0bb90c5c81913b61afcfa5bed9f78b5d667473e9752ece61a6b78bbdc0c0f572d765d9e2566c5112dffe7a7967743bb8568337ee2c091e2cd153c350a1ef642ca8e59a70b18be35a73b227334de8796aa5a5f908ce82566553f0758566843c57684a09a19e832946a089080e73ec42c0e15dffa5d3fc3a22ed6eee702894ef04c694441d3882bab5e3b19b77bb39b9134f94c88af0dacdf39e785c32ce9e98219758ee795b329c4a3283c89609c765679600e120e0da74e43590531452a8370f7acdc890af227ef833ed3f89dd90c8c4212c55c15753ebe2d2d9f8d70034966d14f77a869443d5e7dd4f25387ce285d9fe78cffb02122ba74e6ec3d7316672bde6f746497f635c08deb205c8fba9babffdf05937e10c0ce4b7c43971ab6ccd20005665d40581912a831504cc53d99e2078a2609b21aa271506b5435301ef04c6d6457862dfae833c81651b0f1ba9dcc52a791f2aff85393f5d68a7855ab398698775e08463158fb97bbf52eb4ee24fac01c1a5354f3d257ff4745dd952081fbdd08ea83dcd92f6ae1863a07dd78ba04d4290fed64b1c6014814cd81c90ec593fd8fc8c9e66b6c4284518ca65711cdf049454e5a59a16f34e93c1fd23c2445da0b891957c66f9b7466cbc1fc32b0a382351bc5b631b89834eddb2a8d35d2c4f2261733aaadb940cfacc87c0403e7d8ba238d3f1314c24f4941115f54a5041b2fc58816ae3864ec399039a91f8502577fc5e9918a5c0e752ab49da983b4b752de08a80bf1d76cba9f556393aa8ee96a2d9d76f3a8fec390782b9205334370d4f25d0f29510e2f471c6684044fa496ac299c91e9cf4dad132aba8437a109d4b188b6381dccd4af3d725174dbbca4ba552a85440ef9cd9a2a2ce1b0658827443de4eb17e69e3ebd75c3eacec4710b3ee4c188d391abb468db4fce44553bfd415f77672ba125a64755f54e99547dc8ca391131c80eb8b647d9f2b18d07b17d015be5927b2a40a66bbdc312e16731e49afc6efadd90b887593c8f0b8ab7c48a8837d2918e7b9b2ce4b12cc5211481b78b474713c641762d99a8aa0aa5fb258a62a393fb6320e78f168251db5e5b57aeb0d02ea9adcc80d00245fc80b9b1000f99ebffebcd30bdfd3fe403aa53a590a57f94ebb7d4511a1e9e0442465b695f028e6eba26cab08cce4bd653d01a2494db4487a3dcdc294f84dc59c341ce6f57c976863b57e1c376cd23fea5c09ae5ede3444c64404597f3f3700f12dc40fdbfcc89cb974adddc12545701f469326f207c133d0e620693202b01a031c8f102835953a465db484773104294f553ce22e39a560466b228950fe8594d689cadaff46a6b27f4e6e6b26313ac6365b1a27268a86e41bdb58d392abd83920819849a02631c279e96adda9889d39e3be786535a4ead7082aa2641d98820623ef3a77bcccebe6adc609d7d2eafda7efdb410b95844a8542b575d27ccda880f4c430f8c40f9ca179b09fff92163c85214f868e9a91fe9dcea6fdc336d507b73aaedbf3275509a8ddea008f3a04e5847b6ae6b006c7b4655231cc72021e81cb57cae946139c848cf14f3eac4f842b16b066d8e2354def71ae1498e3b6dac3375d7f1653a41de6187acfef508754220543135350ca52ba889eabb99aed267c66d7a7627acbe02a279711a81bbebaf5eae1c9133973f49e66f9c6835bea8ee90033c0dcb5a3dea5ba9d7c3a65c454448d6eda84c84ecd37120b0d8e18f3bf1491ae04dc9fb8a980d92486aaa7ff1795f166f6ce68079ac865491a2b63250b5eb7728acfc0968cf9f753ed242c871a6a4d98c43393c93d281ecf57fe38bfbe7df0bbf3f5cdd764dc7cffb471273a2c76a9810446a1c374f97bc526978649b85703a35e6a6e02429332ac0d99f08a41bbea26920312ce7a72d4ad4bcfb2682e1d1de0174d36aa0d34abd484d402463d7916b493b31c135971183a4214ae08f2ef4c8d5b16e2ff523225e1d5e2c263d71fa0b1e0e2b9739fbc53e46261cd3e6f7430c2baceab7dacfa6e80f3c78406efc56e47a642c4de674c8b5d7cd35161e98669cd281daea8be38ce44a3a790012e4e78f2da5c1c0ac58c0340db48d6e7a1e13255ead70dd2e4a27c4d3af4bb7a517290d679628884204515a079c8ae88ecb4681903a942059fb88880ddcb8d47415132e20251249bd05aa612adaabd5cc0832e680c9faef141a7ee4abcf6c5613159737bc49cd19fe629a5f1be80b35cf8c79d78d591a96cb121569ae5c61df116e892e4090bded4b1b15628c1f85e2831f5414c8d0aadd23e8950c7d3694885a57ace181a0bd4b93dd6742033b4b982c5cce4c66586c3f3b1f682a9ef939a64b197e260b6c5edfc670847719916f30c7127d7b410344119fa2c0af3f72066cae9a77af860fb5ebbce040579efc9174301ef5ced5da526b5f20689a7905da5c733fcb7f638ffe874cc977a9d16eabcfd6f82734be5bac2249c28ebcc59e54a2bad5c69e546c0080ed310755e92eaa5a74d9537f8921efbc44ac80fa2a7775c46ac323495bf245eec0a02e64b99e2e6f0acc6f7a2625bb6d81124e2f7c857d09d08c9f065f0d70d78e3aabf2c8fe93268e87915e7121768a0c5dae4a80b502002d86d462394dfb084145326330cf6ed07196d69bd5ce3dfbbfbc629e78ff792c4071317a6dd87cd79fab4f436a6ec909a98233ddb29e058b802a16b4c66d537bac5c8aad17412ae3d0c3f3a4f663dabb21d51b393a96c23e41cf7acb5d10044a7e8146bd97e9f43dba6bfb67fefc076d7826dbf2fc01672e0762c4708c5cb2088307d946e52d7cb124cf662a0cb003702adaf04c0345175b811ec78bcd83989788f4e1b4389789fe4dda5ee4d74da8d54fbde74852312ea0c790ec4ce2a98a419d4b735def0dc3f20e6c0177c1f676532c82487b1d5648541255404d0cab3c6bbb9483628e098e6e823a18406276b89152fddabe3ab79a3fb063e06277a710a31197a50d815da9ba850d8633da651e85bf2945d10f58d559a9eb2790fdfb65c841e04bd5afc866cfe55bce1dd1738d1d2526e04e7fd7e59e1a35302c3511cf560c8fbfd080e1da8b05137ebb0e1ee3afc97bf49fc18031abc78bb60536b59514be897565860f2b22db46d52daedf17e0476a962ca623042a2a79ef79b8f2815258014be8610c01b17c89c7a5111ec4bbde5e67255f7ff18b4ef6a23a5e2be22186c1256b5b985809773e3ed2de021e8354add2140e28e298e31c7b19feb0c3fe768aa8c33f9ff2c6895f2fc12c01713c7147e1ed5238b6f429e70f6dd475e5f2f26645005e23ca1bc15f2872c9f985331550a198863031a98da57103656a596bbec59350157ea33a60d0428a78d711bd6a807d49371cc728c1abfb8a6aae18c34d0b2b36fc0533f4c929d6d01572763904996ed490ff3f41c37a44fa6eb8993050330e71b5463223bd8b53788cf6f648d7d2db560290c1051e6450723fb978a0c213f0bd1af931561c271da4881e8397c02f79b1a75b67db28d6f6f20051bdda420fd7c4612b20a3cbf9778f96301c4a70981940a072d2f16feae28627b44a64981e84bd589c105d1406eacd04b583fc2d78b2162e5c2b6b32026ca2794d38464d52211b47f2101ec587dc58e470e0b8bcedc70e31f5e02e2ae12d31f99fbe766657e943ccabf125d627343edde9df62e9de6a5b5838121e3f9fcb21d66a893986b295dbb78e95dca72a153110bcbd2efca9f860203b717b06e1b2a2640dbd133a3c80d3b7f474f176898ceb2b2772e0dab1f460367f61d11795fa715b91d3f17e507b47031d7a432bc7861d1f45db58651491bd0fd197a30a51ffff9fa2ccf40e934aeb4dcfbef2fb76d4e74c7233840be7bb858202832b39cc70328959c10045cbb234e06a2c1281acac44e7a2f84c7f7fa30f4308bbd045612a72f1377d55dae2ba29ef36bc95c195437c1a2cc4313c5528f6790c9120f38157128e41cbf10406a72b85e0507b7e1228a3f2a80e6b85d29554fb1872046ed90deb2d0e170023928856dc52f3671e60d928cf63edf42886fd2d4bcb17359f59a07ce5048edf58f6fd55965d770220ce1fafa445a0c11ddc30c271540d3f8135d170bdba4ded555d8ad4b3534296f2b0a762da4bea83d60d89373d5c742bb07c4cfb76c0b823edb23ecf1871ed27300461a3d38e360ee80d2e338fca6ad682b06481e8e83888d758f9c4f37764f83d8ac023944ead7e0a5664559e8bab6451b120d42088dce7ada71cf4a1c3bed6fcb48193d39482b288abba24643bcec7442d5759e9b3094c52dd1a1390a166713d6a0a37b3c7350481b187e25d71cbfc1feafcda1eb22b5d8730dedcf9be91adb6ecb16144a25631a496c5c66ebcee41d00b4640003eb9b1d394f5f8ee79736e2929ce3791b1cc3df155e6dd80b2bc7f91ad13c1997874e15ac12488acc3f4b56d50582f0423087562b03c5e14cab16d17910cd795ed4c93e496aec1c8e42b259af81988b6fa1b51a5e488049e14d63290d30463343ae3cf120486af08f1c0f37fdceaa01ae14858b4a7b33a1b33c1a12588bd226edc4b4b9e1950f63c6c1b91ed74cdcf08498cac054231dfda990740021df3369b6b917e083f70bd4650c5f4debbf50c304c2c02920f1ff289abb20c24c23f22a7fd0d09b3913960cfa389173cb50b1f33181fd6abcfb34618c82a073353a14dae776fe127aa44a747296904b4dc0cbb7d2462e042552d0f9a7770e103a780df978a841f8cd6e4d18a91eba4e27d15e4e2bbb5fd1ce94b332fc4737a572399f759f2d2de70d92bbdbf391252b54d4f9d2a85d6aa832c5ac0f259bb6e013ba2f6d387fdefbe287834c341e91eaa162ea5470ea969e6aeacab5edc457b0bfcf526f0be7d998d3acb54876ee31fe93b885ca08e03fd1101a9f6283b664cd8b66f7ae81af8c330f168269a3a00a2c0835be103c2365db06607e1b80df50733be2f24002d1af85080efdf2891ce24b98475708d11c44a9ada84e8ec23e5b6540f76a277df5beb0078ff182e145082c0b48e70b745ad2651bbb70bc8e4a44da8bfd261341f8b1b9f0eff3f5bf8f4cecb0fe8637b6414d0fe7dede56801b0c153b3bc732fe6905419785c47e72f5c74dca782f222d82c987d84d46c3f83849577f2f1312d9f7c43231455d231806b26dfb51d8ba02fa1be8a6899e3eccb2f5296a1ce3657f20cd4173ab6d5c6642f29621cbff6f5f3ffef84151fb5da5bee1f5de807e861ef139f4b5d0c8eb07ada9136931878d4dbab9de4a8a783a8672f17e87d089e3d744b63154270cfa78a78fe1cfa704129f5fa478885f56fe8e6cd20e377c600fdf148f36798aa837e0bc17ac305960771d14666f739edab5822869e9f5131173b050a24d269c7bc12eef2af6cfe83165b10677ec60f740aa0e14e8edfa28e6412999eac68e15de1d1fff9b82492156030b289ba7836893213fde4d4ca4d6489c2133a8332edc8f8e483452c05ab127846b65fc5930b858c4f6fd0adc85e18fc675aeafc65d9b9ced088ef36a8602b422833128d4263be2cf94612d8b6809da3fc68f4611417b55ea332ec007171df88497c2d16f589402e30bb79ed859d31d9d83f6904bff7f2431e7120b7517bd94dc57fe1ccc3965094d4c8e8be8a2e5481b575cc5ec4f76122c0318b34f5ea50322def9c366a9a9956b9089d7326c330655b82edbad92b26b29f2fd87ab40b833cdcc711dfc62f9cd7bf9eb0738d4cbeeeec7ddd4b6015639ebc1f7d1c01f716642d54edbb40c3a5c5aa960a7dbe6a063966885fa62d49b28ea00681281ccdce548ebfcbf26e751f1b299a8dc3c21023195d54d3347bd3ce61a69da8605f89c6d161737efe6b5e527544cdf3827f3e62ebf33a7d7520031b79f3b8967ff40822c9467bda6d2bf3c06b0e5b42791c3b04db66ba7aa48f10424ed7cb763ab0cffab6af5e679af3183869c74b4e2f63d2ee48f26712972c2d4e1e4849dc4c75f7a3100f5a165f5e15697dc70a5a3ce1f9d3998e8ee3e110c87ef83a5fbc2a20f64abcebe87293ac719fe5b20ac2afcfa7dd558e9be395d0d972a074512b12391d7a856e1eab046b1542cf803f928923f0350a1d76efe4800c91d65eb9659b051104f7163bedae3d2157fade540eccb48e49522780ed91c88b4882f1e6d5a9e4e956859ef320223ea68a57c7bb565981bb56086007e70335f42c08ff6d1ce6a24850a91251ccf43e9b9617100fee0f149ba9b3bbc944eb403286996ff9774228e77b6f9fcec469e0a3704fee9f7077cbef9c3e93117f8cbd5d915b3c53ad34a76cc7decdc8fce33cb69fd1a3db3d11f9963ec58c302e7288290b5a3614a0be453e048ac50974dcbcf9dbae46a11a2d01ba9d9493d386007defb4108f7504d77601c4925a6daad1c5363942e014ef97b2e7dc4a6bde641f4abcd86c5c178ccae69e39aed0f09980653a7d598a67d87587c06110e005a754854af55ef79fdf2034e5efba7bcfff842e16cb8ad4f524331a30ed6ca4b7d121bc637b804f90307a5c9175644db5e0917add4308549dbd5e51a4b45a208df16be7b50dd54e58545da5ec79bb82174614fea40bba4e5433357ff87c143611e007b7ed55347838820b5364dfd7de952e6fd5bfb344420f8ecf3370f611f1b8ca86c9f1dfc5151f5c3b3de30d55ec60359d2292e926c6a7595f5dbc7300730539f47274c2ffe43306cf8ee6bb2b18693b1dc4095bda26f3360a7d247ec03d03693849c8e3f91a802bad6cc4a9a4620f93c0d3e1a4c744c6cccc1d7a9e955431c43649497d61f3d162d53379f79cee4cbe6bcdc2d61751f09612519cae44ba28c9d9c481806c777a2070465aa43dc7b50ad106e6dadf39cd189d95d647b22a8ca6d931d7cd4da0bf9fe28cc59e705ee3a7e3368e5df8e746a0540ea25c8e769f6dbe1d9b5ece225b7c796066500bf6ebc057520700e429d65a4bf05bd72cead9948242ae7131f21941a627a08c6ee5635749207777ec455eefce4c13a8e956b4509c4a88bb6d7190c73399899730719b5c97974cb960cb578e885a1e3d1e1099dd25a1565d2e3cbce28987d10a8a7d9125c41f0163c50d7bb3bc7eb4a9bec9cc4facbcc08e202dd50f820bd081f446fe007d35b7c60d01b1fa136a46e92cf79aefff226dc939b539589da8912f1a6b4481dfdccad4b23ee88ac7312ca70d9b3f2073aa1a579d8fe7573bc7fa2bef54c696c6fdf7e78d4519e4c70c0c24eb83497faf40dad191c6e70faa3e93ef1d4c0b9eb43ec8716fdaa9ffe9f2dd04c99625a72e36f9ac234b0b681f406702964653482d682f1f31fef22bf1fbfcc0abb32da30bc7887cd6e1080f2d610fdc3c070a05da2ff98797c02832842b37a31486af908247de748b1b685700e2429d718f46ca2b34d19be94d8182562464ef17dbbf66dc9a516a2ef0715879561d631f86bad67db5a330f5d3143db4864349b4e5e439e6a145353bfca7928f2feace6eb5e4f935d923728bcfb8b800028ef0487a83fbe1b680b9a91fbc49d1847f4b0bc6d1d810bd1501affba3eb024258d5b681c5257f7bcf598307101af3bb497916507da43ced9205c51360fdcfa0ec6f9c3d6907a49c3944942ed6b1403321c3f47189122d85e842c1bfea28ac0f786ea654cfca4badd50bc7521af9093e0bb0ce3af8d27af12451912a7e03f9ba0884a04a6f63c436d3e690703b53f8016f8b6c884824a342b9d4bd811eaa40f474e30e1c54b7ce52f91e860f07616aac89882820a69da2f20aa2f5a7e48b6ae869c82ad837cac55af7c9e5a685474730c7618be629379d8a54b4bf5d6354c2dde2d975fc749a699de5bcf32dfe13e06054df534d6608db699e91390cb95e39778d8f185a045c9a6ded78cbb8bebb23c9a1657a9b4865c78a40a224b6ca1b7e087d0ad7113b3ea9dcbf4e5c377949d01abf2c32bba86950ca4d43aa3e271cbfa86608830fed8589fd5f57021ecbd1e54da6438a2454ef04a642a9fd42f4fab6590527517b7dd68956e86bbe299359914199efaf4397ae386da63f6c14e4a36c81f054218576a384b5108b23cbe4cac271234053799dacbd91adcd74df345dce2345c3a9707059cba4dca3537d37ee0ea4cec7a8fe6a79446e06814c687a9c68818f439d39aaeaebcd3e2cfe75774397f32430b66bd3877911495c0b90ec1f01cb2451211e8fac316c1084aca550cac2d1cf43f788f935a21c0a17b13f88290c543e6931996c1e25e5f1cfd818d68f1d718a14012873a7568e4a9c3ace3871dc91a530c3f8b3c08a115bbc421eedf719a144536195e12bdd800777f408e6e9aaf1d3b1b0bb87ffc3c94e084a0819bd9d3abf590030552b44ce0fafb924615dfb78247e8c7fee88ab90e7e2fb0f2f3d0369979b5e7fa727d6eb82cbceccbe6c2cfd363a489149a724e02405120bf626e544ca0fc97abcdba3054a11e20cee642794a24f5032853cbea21072372b64424a011e0df224280a169000737dc72ca147dfb1449e13e8e677e24480e70a695a9813dcdc5b1e3b94335331815de9e233d6bb925f0d7d308a3643d99d31fb370823cab57677ea5ad136b1b45c389b3894ae5f5d2f3b31d2ebb1e1d08906819b867c13fbe7975824bee474b0ed6c4081ae26e36685abb04e98ba00838ccb34b2f802a02014695e898ded7a225c4104411f9f92120a301c48795bcf49412e8bdce70dbf5198df4dc5113a9d52dc7ba1289e4b06191ae36940f6b13dfc92f6f18f669e92e0c3d5136c18859daa4a2557298b148187e29d8705f06809d260a3e5f676e2316ab31df76b55d641610ff61c97b823ed61e45fb25b89ad18d96d9168c1be55674a901cd7174e0498f1a1959721c12bf32c59a6d1b0b7acc96e006f714aaf451669379fb9637e82057cb1e8ba710c43ed117efddc17d4b67ecbec195561f8d195d0b51a654142b29848324853cc777a8fc1a561382e3e232004670bb3cd56762ae8341344618d4d47208f9ae5cc52718b08f889da9a97e06a80f700af8dcf73618428cb7379e7c5b5052b59918b751a4f32224c61a66047a9d609ef5cf7252744b2127b7b0dcd7f4d8d13419201b06df235b024967dc87a922b4aac44fd1ef94ca98805203aced89ba43710323d67c2ffd03dc483c224fe43dbadfcce5aea24ad2bcede482b31e9ab7a13b324162d56635f5aebac9329954e1d1636841199d58b8b0842b667111739611d939f35196b8329c0015252758e78be56e19c3f1d6e7b73d4973a07edee1c8f31d9f1d20c23403b2a69d1afbc501a68c5d04a537f5b6f7f7d8170edf8dfa4ea72f16891514b5d8cbb41345bf16564761d5c89ee29274db5a9a08350f6a2952bd1a9f8631b85a59ce5d056e32625c6c658d19dbc973c83bf165489269f42f7c502bd3c52ebad09cd44b8ab5e1762a868c442724e615c2e6aabeaa3e46c1ab7e6104a9f8312b55e914184f51eface583add07f9da6228d3b514c31ddbaaca1e2c5399ea3000df3342ae2ce01dfebf17217421e038494c4b3f8a52cb91b36c77299fa336043a349a2a5f5d4896a244afe4726e94f2f1cd02e89a8cc400eca22979c08e8fbee7aa0ead455ad470eec33fc85211e56fca0e18f50dbb16823a543c0268c73bdc87d7a13ad4465e7599845368875b45e64e77f9ac29910108941c4df04224bee7e0af26808da05b6f30a0d558ff366302d5b9441918617386790e390d43dd8972b5025c6c003aea8906482493b7eb6987e1c89e66b4cf8d66a6432f225636563d47896aa06320b538703bd7233d2d1529cbe7c7ee2dd4423412b1455299adba9e05be87f440f5e14012d7e44c0a70f243ea516758995fb4641dad229c4b2df55f4ed2569830fb84e55ddc040e7687690240734c5bc05981b9d3ac122aa490e35b08dcf2cb5ca0f9c3affeeca04cbdbedc41302e1f76e456709531f609d1747f497efa36735819d20bb73efffac7e9eff52b0b59e4d3378f92827dfd5044f3097f927bcc27172a13e535873bc7ee971f36e2991b3e5285ca6d09c9b166b6b2383a7107018ab6b541699593207c7925a0c5050de446612391dac6b634082cad3711cadd66844153421af90ca6ec7a352020316d835c08861f77717622817ab926a6137490c2df60c003e46831b23ed3539f988fd966b029475e30ccfdedaa30e92e76fdaf4b1ae25e58bc6623d7b0929aaeac3d7481d9575a46aeda762796905a64186caeb0bd257d996e9fe03c602b168926d04f5b3968ef45f001c25311619ac1114e23fd8b1f382abdc0b49754ab15076aff23f4159bd0fe8d8546f24b812f542c1fab63a0b775563536c8fab6282a5450a59ba64521d033718dbbd107e388c2a55fd0e4711900eb7ffb18f10f7f17ec0bc10d484c1f998edbfa3218494f575857949868393238dd66bb50341c84409381a5c5858a3090a9a5e3b58533aaaedaec495607d3fc465dbb027d826ee187dc2d706a0e058902d099e6bc132daee3c5c5e197d20835cc6942e849f9fd7a20cb3c51f707a9caf9af5c11c19bb3a83385cc47d78e1191d231f8ab3d1d9e783c7a17147e14f2e8cafd98a4cf8f1f9ffe7b1de3e8fd2385fe6e16743bd53565ba155d8b4f40320b9581ece0b38edf24bdebc6ba75c1fcf395c07a846cdd367357e89fe81b277ba6c89bf63ea5ca94e4784b72e43615990f0c0d770aad51c735ee622927c9ac3672eb2a61cb3aceea79f601296b9ee528c6354265d92cf2e03311e97acfc850799408287c1e6ea83720320c2a0e42edff504fcd6828da11b30e5fcaa543794f068cbf16518f78073053f5056c69896d91d70b7f471f180938f2178d0d091153276065fb61fe168fec0a4768f2e52ec14dc5c6281026d6bca4897d4a04f074a38b2710160171b4d2dd41e0245ef7da941f11e1c2d79d6ca006d018b395bfc52b92cb4473910a29ce103749da71e5f1feb322497717a0000ecda2e68e412d0ee340f70aab402bc7fabf24c05ecfed15496fd39a6b658b6f098bce75a34662085a725f364e6fc72b38368ca87693e2ee25a06cab2f13c10633ad73b4610a0edb78bab3efc06f38b29d3540aa3f72bc90efa1e3bf52e0bcd928af40844e9cc78b7df1e7d01f822e608089c4007f1578090ec3b3c1e9b25b89c2b07d48d6c7c7fdb0dc4b3899a32c7456fd13a8082b44dd67413911bf6bc98e8502520b8b90edadeca68de6641375b4cb4535fa9283490fc18de9d4df6e03e9b66b13103cc9ba7d5f3536e4e8814b5d70c2f01c7fb69161128cd4aff928ec7a4ab49e6bab1c7fe7927dc7adda2a08f0d1c37391d73346781c2aefa346499ea2e5d2ede2108fc44a03a8c38166dd0c4a95162db39cd9b834c7d804c4d3ab9eb3635502deab599d5bfb95d72b59c90614a5b0d74eaf9cdfd00982b5aeaeba9ccee837140dac541f5d0f80381e1a6a9730c4f8f7e8b592c539f96e73b7516b998db9b6940b65d5a0f0221eda939af58f93e7d77a24b06c49ff53589f8342ac16f6fc94ff29dfb4a585afee9ea933122e8981223bf3efd4af410088ffca42ee334992d706f527a8d8f9989af067e5a9a2cb1dcf0bea18232260654431dd51726d2483c29add94c217d05bb8f8df072f3290689d49212f3cea2fbc337c2c0a9812ee72cfb1d7acb55f9c35d61e5443e6aff8c447252f4aa7a1c1a61c06ecdca76b8edf64881827726e0601e59b5fb844b99f7ada63a13627730e93ec90310a41ee5c744b0c1870a1844a91155f0f08c4e160f9e8ba0a0decef6d6ced168987d707bfbb50e03073924d44e4238f11b1b9002bcf11b746dce92af119f877e66bce32ede73a19bab999413994040d76bc561c893cec7801149659b8ef301d6256931b573ebcb4b5ce0df690b72f8c242a9586967dfecfd553b34ac214c3dae889f4ff465a916d8849cb108a4dc1bb46d2e4753dc85642762e9d4283287ba83db9657a2e62004f4b0d620a89cb1a8784b54e34aad099ebc1ad7da627aba9597158639a5bfc526e68674a278d7b0587598890192478083dc5015f28582c8c423d6b7df57e2c03e92f99a19231ca14db9243bf11a8bab0a0e52b3bd1d4669e67461f34c00dfd0c48617bd01416c725384c3ab741c7f9c3b6da7fd521d4298563ef8353d0496a901838de4541b4559cbd589b083a13a5fb626ea4c8c042f89535ce839ab143ec88a50e3db04b581c7278f551a8a0c88f2dcc588482abcca00ab84d498b8fe29b401bbbbfa42a4cc226c1723dd88090ae5b22ba8917b5a060f2238fb5182ee2d41fd51783b1ce5e08f16626f5150a104e8d63eb005c41916c3b78ff58b8c4eba0dbf7ccec9aa6d2ccc3187a3a3c3e57243b0440e80824362fcfce297ae40bf0dffc84b19e9a44a14ae41cb024b9744ab18ede9e9e2cac6836fdb89bfc895a99275fac83c1baa87f0efc48166f755a68405144199f467d9e57b559937a996ae5a5f18f8295ee7db7a98a459850aeed35e90a245a0c6575de32d8eb0a2a7de98741e77e219d80119beefd82086712390ec8a2a37e78aa88704aa86a250c2f91d85cfafa9debbb80f82eb54509b6bbbe00e6225374e4a47fb5554c833ca88ba7eec656e9a5a403f7c0843687d500d2e66659f5ac6e26a922e047d0d0c9e25d47b4e48879a0caef173b279536eeea391eaacc1c095d2bce4f5e1a700839dd29cff2c1a158d13d28883594972f14f4bc943dbf18c1486a472445615dbf93f665fd7422e5b5382f6b9d148d0608df5f9209313c53139c979a50c6ad89841cf08101b2c6a84b18fab12f08fbfc2ca794c2c51817d67f36a01b56cb36ad8911d2fe033cc1359926ab888be8b04e6456ecd63805422364c752783210f6ea0dbfbf1607c35e9d40945be8d54d4d7fc90e7571e20cc7f8bda3b6547dd170a3e917606cea48db513251ec0129194d1342637a7ba2387ed867bfe195e002436a2f8f93fd2e79ed9eec513d79d2a185daa39101982a301e09c7c1c225ac2a62d9a3fb42db993f9a3f774e321c6843008dd08f367d3ee56f0543be85e04438800b0a64513803b6ab4a312663f544386e738e6f443e3fc04d0a4f81269f1ce79121e9f9466cad5c5eb475f26834f72cf718638528c3e086107f32ae58b8e29b3c9b8583796e9c240c0faf9435b770d89b007d2397b2746a1d9851f1b9c9b59efeb06afb1620d64dd67687b5745721b673c94adad2a4404c602bddbb2d23658d969318f449527b0f128cac9931845bfc300420011f792e93535fd3ea2126caf2c6b864cbb6bab4d30214e246464078127706dea43bd1db23d6563ced164200c029ecdd9e3330ef7d76092a4c2806c348170dcfdc08625bcb20cdcc4ad32ad2d289bf6af7d119037f605b5afbf130a6092e072dce1beb864023a9f79c5a3a5f98dab3a65515609b404d5ced7bc1375aa94ca605f68846ac4ac88bb194d6f6da7aef92c63733af3c43c30810409578e3d8e22d31d0b06283d6924c9bb4901042a939610c44bd3feb72862b816866ad20a54de52c01758813ca8b6ac36be0c97708225c799a837cb3cccc967080bfaed5163cf3d8382d0a7c5f482bfbcdf0a4ea2513670bc39a5e00fdf19370dc6542f5c3226d04b4d2c0c8a65bae7c481bc49ac926aed78aac0af2cb110aece11b8f2b6fb6cad716f50441029f1ffddefdce253c4708d22604a82b2f5016a63271cd02e506c7ee1c80cb4ced4e47f6383fa6eee82aa0472af9552e176672d5592362440923fda58a8509a950cad878e023c075f585dc3552eaa4af92367ec4659bf5cfd8e6afd04c17df69629aaf19d1855479b5f1d7c722602babecbaa9186e8895c4115b8238bfab23413046e63be7970c971d902fb5ca2ff4dec4a236343bea3abf1845c1b469d73a1582d164635cfcf2a04ec1e215e89b940fca1cbafddc50fca43805600a8e086e85195800ed609459d79690f4a0514c53c0f32c1c1b08222a1950c04972abeed430e0f17eeff06544212756bf8d66c5dac489283fc60846329da5412f28a0a83d30ce860d16f201887c0af84de974d009e0018964aff08d4a9fb14785d023bc804899568df516bfa449263b931b92fb3cd3a4f2708fdd851783d1362ca45ff38a0cded50a959292da82accb2164b0ba6e0d6ae606d2109b53f666359995afa62923bb4c3254b0bef114505603218e9a56528fef28461b3483249d1e9be49f2445b7a3b878eb4cfb1036ffc01f57ad9908c34da333896b780d4f748046462c192b269501842175b0e67d9d29481ba563f82c6b56f3421c637bce9bb65f7017c4cbba2ee7d9616657655095c1319e295d1e00c640eb26f2f431e1ae4587a4343a79b870d4528c8e0f69595a624599e938458ba643a20681980ab6970b017ac0d7efb1b5e83f1b1d1b063926abd58deca36d3565288acc2d4088b8e13896da1e46350c39c5e761abfc4703271e668c1059894bdff08f0614aa4772d9f72e40ca6e04fc34193503ef1c082e75c79095e9839c18185ff4a1551f946cd70456766db1d0a4f39e59c52f62cdbce32ed8a8d3dcc41fbdf155471ab636e474c6eed245703acd50824f44e0d6295915c1412371d0dd2536287265c93a71b58b937d47b6a8671bc106c95d7aab570c244ccba305e40c4d55127dbd9c5a9ba9447fb46c313266191a701c076b04f76ec98206554d22c4669aa6c85c0c762d20bbe3f6a9f1ca611594438f7895240610c58f75aad70cd75470f9a007a30d8b5a66b6cd5bcf836809b187d1ae86248f569bc749900106cc2baf43949fc306c496b9a6a34ec5baddea773dcb7be6e2f04e0e8839f302abd884c807aa696edf973eeaf905e67d6d1ec80e4026696ed140ae4713a22c64b59ea37cbbfe1b35c3ca0e35f07a2990236b360f30ad7e84b23b55ba60505cfdf008b59d44305570b0a6c4b61ed2fb085c6be5482d0a77ff94280fec16f228d04adeeffec810cebc7be2a3943f40c67fd14b0b35c4a3764e1b639249720dd7827cdb22a04e235c9299802b7cfea5b7e9b07a554046400639ac884ba9f7ca5c0315daeae4ad29a4a780f5bd9929780f771215b229624002975ab68241f120a3611a03619244c0cf5d911a6e70449cb23930c93c99c03bb04c229418c1d2547720e3b3f5f11a0e84f0f51fba5af4768708271f0d432dcd8c1f808bb517fca85b7eb18b4ed187e5fe7dfb29277cdf1e9b9278c766e79590745e3c9648a4a94b9f5111b59ff4aad2266bd4dcbb7515195fab0ba485c4b62bd46873652e4fe998bc4fe4ac1a50d4b0eed44010b2540927b78d2ef5310655f3234c947811482fd9c0c6cf8d57d82494189b66697dc8798404ea234f787ffd54f04af4e555e138802ff0328b4c181612b4d80208dbfe6fd60659c42b0cf8af21dfba0e02b4ae205ceb8d55ba19c43d801e50abce08d4456940b0b515ad01552167dd7149183d6d7fcc918d5c22d5a993660a5d87f30da0149d4d0b147d6e525d843a242acd3368170c7568ac5c4dc2c83b5623bc4197daa2e0a13c07552705d4dc3717ea70adad8004b6c51d8766d22d61599fb693ace46d0d7edaf0a79f426834864b8fc06c7faf4e63cff3dfc316a740bde3001f18212b212881d40245ce78e0ec4fbc0ff945338c6d62800ae1449d7404da370037535090fb2dc3507c93e817a9f9b5dc5ba646915052059b0130c385531acd4a53d6ef234cad7165e4983c14920a6b1dd439844c3e49a52035ee80c3f81caf89952fc057db6bc1bff7c84b99672ba5292ae0930bb2ffacb8c8c6eaacceb0de43af7b79575dc5e36931cf83f68165942fb9de822b40f64fb78069f6d9c4665b39d6c5a356dea6c7f23c5f638119327621b2f5921f5a38475344a68af2ac4c0f4c06f1dac3127766da05c31da5ccbcf18b6cf3ecd417178c808cce370407c25219795f8fd540c9cc89977073c9fc4d8638d7f1b18a056b42ba00da1a4ec79674148924d98e4d9dfd73e5260f663507af88dbd72c9b713ed17a919c655c4fca9b71693899e4d54dd0d7fda5dee217f563d1dcec94593801d3a5284a4968d5cda17684dd1ef507c10caf1ca437aceb7d0af69e89afc4bab4a19d5a3cb79d2061cea20e49495ff6ff4f5b6da38298de4dbcf9188b581a927935ae7da7395a63d717c8ac5eb18f1f5915e6dcfb781c4092d23fa99817d889bedeb5190597d71c448f9b70346d64334d17cae44d9fd1cd6abd6a1d1d331ac63e837550d40ae851ee34b314dca48f9de4d3d458cd0c7b422494006ca41798f11c6fefca4879067a76c39bcf38af2791c92ea1e810d041f517ea35690b4c32cccfa2ab67cad629c718014d15d0e79764f1e06fbbee7388d92db5c918955692f2e4e6ce4802bbc02cbc6016b35dabd0b3d7c5e6c50973edb775a83f9f51cc05e6674d572f0bdab7dc19438ace4fcda2c8787ed7cc0094b21c5127c6ed177f6364cdd5e92076b7d9b7f9a4859ac965fd2e454bdb77ab009e205a2b8cf0ec12c3cc6800e2745c3cd5d021e34bfb6cced466231f4446b3b0843de787a01c1c04d7b7380246d95a9d82bd2cae6d967b9edd23a9f8e6a2a61f96d5e277650b2057ad66aa25138cc5e91266e3be80733d781805527e225d91b044f2b3a1cecfabb3ae8e095f8b1eafb2ad148b8c6d410701f6c4dffecb8f431a49e70f337d1dd584b9a6095069ea7d87e14402c5483ccb79c815860349a6fc9eeb639cfd52fe2fcd5808d066a66c6300322d74e199fa8c014c78b5424abc5949dcb81c7e5cae3d6dd813a45c4582bd5bfb8450b03ae76ee5ea2ff5a1a3db944a2d5c638414ed72eec1656b46e2167f77dc9761e4243021bc45f7990b953ad35eda2538395ed7870f350cef1ba503aba18f172dde2d46de2343e22de42d3ea1c2ce175a73bd67f36c108ad619e7fb06bd27262e320e95d21774dc1b8cb65355f3db34c36bbd2f596b1e4334be8265e6d27e6667a8e163336ffaacfec3473d3bbedfd5b8b964210594fd36304cd97cb09daf43e20eaeebe79f08829e0700e685a3f98078c98e302a0f5fdb7d8d3a1ab30521ad8f42dfd27c7f9974f55f2978efe8f1124b194eda34f5fc79a825b8868e3796bf411bfbea58b0afdb042941457f3f321dc53128a36b89dbb2dd85bb9f96faa21961a3448033f29b2ee181443999cc30fea01d5e24ccfd0c5463eb8f51e9a1a8983a30093ba61393e1e8aa5287c92009f1a7058b09acdddee731e7a6c4861afc55c7091f2aa5c8ef698fa39eb79e0af6ba2eabbc5df753a0b36cbdfe42d955a3143cd93271cb8f012652c43e54775a31cc3e3c9b60fe8e495c395937bdfb8422a340a3071b8245a12c4f2480edc87ea8fc93101fed600f825a4314fa0482adf0eacdb07a029c1f2f07de4c4fd3a5c0107a6631078867a3a812c272cd2b97addd7c3b4c0c7c19e13396721783c4f9272ea714669dee5c51d246dee723fecfff678deb7c37756c4538a2b1945250e67c6c117e75d0a619163be94891e7f13ea29b7fad1edb8988bb19ca2af144ac13acdabff82d07dd1a6d72f527d0c1c988f3ed1bf0fa1cdde0bdec42b838035e659a8b2c53e1231ceb843235bfb1d7eb52dac6a6af0dd4feda255bdfbe90a80d5b24ab259f358e4f1fdd42ce99778784529ce1088e9ddb178ac67345e4c80bcce2120715a1ab4e17c0790abaa4b395439b5153ec5ad3fa4018bca598f242c5200df5c3d4ca72f72f4236e70b797355843533b291a40c63ad423ed5c16838c586142cefeaf2f4073fd06fd1198db10d4e327a9454a04fdb0afbd25dbde2d15179920e06664e6986a9551e6d0e750231c91f81065aa5cc56f313373c110c7f022e05a39b2b021b6f59d28733088dc715c31a410483dc68f022e9286016b05ca4a306182b829f5fa3140aaadf5160359b14eae2daaf5d9e0e55d52a97313d46c0ab641de352f092cbacdd880d85e0ee3be096076fa84c23cf3280fe1d4406da0bf9f233e1ea908944b8bd1964c5f8f0f765ac4c0fe9a9e0dbbbe42a6f8fb8b4b9e423fbf56393256669012a4dc005c89325a5ee52f14f98402e22b5bb2ff04692007853f3f3a376c7cf9c23c987b5e443c2d488a05c8295d0f0f84c6ca7360d3f22f3632f0c30377167e8d75b10c515fc21ad07824e0ef2b53971f73edaf1653c5ccca861cc44cae8354b3e92b4d99bbf7e590ab7a982dbfe883b872b2bf4c72841209f0ca3895360cdc5e7e484738d7e4b6886e227c1e2e2f1526d583117d7c654a75688b0c0f1310b6cf6f2c7dd49dc3a84d0010f2b83839852265f1fff3c307404f18b5926493b6de12288b1e703cc5f7f5ea06ef1dd2011202c80ffcea302c6758de23336d03c5d25f3df577790a4de49efd09472ba626a60573fd3320afc9893dbb35cbeb08014003cc61bdff6bb1d5c46590164c2c7a0b82f1707b8f42789a6e9b96640fff53f71c62840ddc5eb34aa4d3f3ffd8b9cc782a993dc2fff8b636b75ee60087bfec016c72cba50c76d30f9da80d8638f029d4db221e00d40a908fb7ca99f32c671387cd3448972d84a69459dd1a17f1b40e5512b04e46cc28b5c8156ad54c13720b0faeb614a97e08bb4a78039ea027bfccff6db0637cdd6e0ec832423ca170ad3deb57ffe3343c34f069a5349fd8eb8de975a56587044472f49b370550fff00b16e9fe39ce7e0afb4b8c0e43e234a4db043c88d04284e5228cca274ff92236ffe0f68ee67be398a65dc407da34fd518f807840732e79b881a06fda39874e17964b0f4742c2714e3e70d92055827725bbc7942d9dc4828d3227c7735267230ed24fbad8e9883907a1e336963125a2366390709741dc89e9448fdd2145be4e6d34a4d1d91470dac20b4eb76b970ca456f8572fc4633fc2598247b792687b1c7b331a3b4461f0012e4e9c9ee9b04dc587dc8371141a655998648ff89e91ea9264bba62c8e825489d9c7b6913443b8b2141bea76f451f489d05cd8241023b948b112a703a173fd65c849ff96ad41837bd93a18a59dd35fee4e6f87a9e5aaf775041f5da2d8112a138c0cb8594454a45ca083886b4e310d0137d663668d80b30a9ecaadb345d561049d459bddf0ae98bcd165f3d1ec3fda3e856e095d7d0800feb329b39f95c9fe291876825792a3203f4cdc3addca09a724f687018a24e104c3dce0bf414d27c0bb2d14bfc1f5860f3bb1d1b84869e0c8949b867e390207d96b9506fdbd486deefac20a0b1fc459983bc0e0b98aee13da113a36ad2fdc654a2f9fd8128409c00ca213bd405f60f97c85f4332738288791db25ca328b4e7b3adb7c0fef638f5cb4b1b31e94e47b9ab1e2e9a13753e1ac41f849edc5777d3e79e911225d79a952d93ac11bc52b67451cd6b87cd75c58e5ec3d2c1790d1637276914bda8b547057b6f09f9056cff04dfd118043bae7b50b13af90a8cf86475d6391ca5b22b0a23d769a35ade080c36174db8df670d0b7555619623dba5f03abe959f440ef0fe46f5c3b243c71d9f7e8a50aea522d08a3a89548150983254d893e3c26c8258f62008eac8e3187c0db5942ae141e62412aec3771cd63e1fa224b42a59847c6e7484ed31b26a1fd8381cc0ac1b86e6873ad8ddff7a50b08836baee156592c2e418a7c6b3294d246683b645f046163430e170d4d989fae7861782e9e85a4a8d677f8bbe23ffc486cbe8efe00a4832bda64d452a3000311df6aaa591268dd750376ae9ae734810613de6931414f2c3d202c82bec35f761dbf0588b62177647db07a0e9f9643862cc51e6403f02914657a27f457d717f19afa00bf6084b6b34731f5b9964ea7cea07d5fc5a85c12a00210272f19b38803a94e9a412f7de54621888be887f213fc7d9c336a07c5cb0bdc4dd73508109047147332fdf6ac19d17d0afb263dea52bf6a651a5a55ca912ffb69c71e36c05dc2484dc2aac4d0f848e18ee5718edeb123600c02b8df0614883dd215e67070e83b980571522882f83a1e9ce8e828ab2bfe34f42558e6a9817745974927ae5333d244821f67d9df9c95495ea16745e861e5f70b72027b74e25f0d125871b44f3463eb9a068bcef7cc2e5516bb9f3328e897121b563e302d606248b579f57b2deaa605316584c1ee99e24c5a257a590124cbde59c00253c501317b40c2afce813c59075b831ad1e47fd01ce1b9ea012264450f8d083cb43541c6b772bb254f0ea63ece3168b9a27ae823339c97bf53bcc40755ef1ad035c9046fc2f43d0730498fc4f82c511b831d1f6f671ffbd0f60aed8d1eda8b0a6c318dd5006684b14fe4a9b0d4289fb208146c66bcfa93837cbdc17268465e11b3bc4ec000eba5b06edffda7bb5b530b8f076b6de88621c368be445efc6934f7da18263e4945fff49415072fdc2432368dc42cd6fde6a9dbc6999eb59bea5f2bc2c1a311322b57dbbc7d66815760a6245b0a8801501fc46d4c86204072ea71310dc2170ece85a1a4e93fdb5f3279ba9ef0d8b214e89733782b3073cd170ba670e47d832f8d44d8cc452cbaaeda04e4bc0c8a5243f98713b02cac0047c88d02d7be6a9e661c47367b2d984668ed2631e89d848a37ff8f8b7466fca64fc614be9c9da3cbc16fce7138d531ba6d1cbc5f82cc7fb4988c4693f6fad48d115a621fa5a1386c3a158c28c25a8ef9dc7afe78faa7a3563650455c591a0d943da8b1854a3284fb24f48f8520da6e6ce0a50ee7b2deced0701ec88adfcbced1801c4f10b605819f80522e20b15084141fbfca155e9687368b7bac253f77f83bbea5c3a0a03ac22aca32e7dfaa5bc33b3ddd928ab92af639675012a1f14c7ac8e4370cde2f184e1ede5465f7e7e567f3ba9313ea13e3b371c0ab55900b58463fa2b623f2c2080b8bd6f0f040552f2a3177953cf405d8d64f1cd6f260cd10bbb1601cf91239eef86da322d064eaba184c4ff115858062197f40b1b91bddc8db374aadd3248036e6107e12d416d5b45e4e0a87f5e7366446c84d16451d93f985e9dc5dbc64394b513bf93b560abd74eb79bac566cdfd7fb0fefe8da81f9fcb266991ede82bcc349e8bf7302175f6abc5a2416043252e160e04c232deba30f24f5b9cec79f61801c199db899468416c198e9adcb709034392d70076c5eaf585cfc1f102ca014081a18ae0a5e32bc6acca708a6c160c57acc3aa20169e2bf91ea91c10aa8a2a58b2d498c69fb5ee647cba92832fa4473bdb495e17f6bf2cdc42a82b2e2bc0f7aa8884b16f147021f23b06554a56a21f9b0d9f235bffb1a1a9edb2e3b012cc3777409541acf5b275561741ece824ac7d026f0c39ff21e284ecaadafa04c34bc72ec88c8082cc287295d9c217ef957de0e1bd90401db8dc3b7361777cd144deb06d680236367a2b055381d645d6330af6005ce078240fe72b7ca0c303286c50f68ac2a419106b6d863a9b97f5cd88fc70aad3b8cb8cad39af5f736e88bd98415ebd8574e562f1c614eacf50215e1c82a930f3e2e82df5a21da4bd7120bd320b8f2eb6cc6d542e995e34d900988f5a94954c33bbca43fb6ade09cc973c836d9230ee66a2c0b4831ad630f49691ee0a1cb1465ec1ae046407f225fa016553e46bfdc4ccf459105440ee49e7da5db84014e2ca337069a8998de3b3cc25aba6db94dac1530fd577f6846e09e4e1f5c9914d6b0c78bf7ff28e9881437cc0e00ac98277405a7e8066963a29156f6a41d2d6a9630c903da922c9d720ff8fba2adf52e117f595cc200ae9ef0e7b51966af7e78c5ca656c549b6d617b8ed4aa9127f7ae7d80630f5536ac75ad2b56300dc9e1bf14a71d6b7850c312c702bfae60d0a6d50f76e07a9e3f6347506f636b13d271468b01ac1605de2217f5f0beb2f2e85c26ab56e6a91a108275b0bf844c958b0af0222ae7ecac2b96ea4f56f9ae0aee3b7845a7dd181ee81575fc1f440eebe579d10078131b2379103566478b904b5f28680a5fc9f3684f84bd7eb99967a9f2278595f330bbc41d10f7088c540d0d19a93b65aabbee34b26f2d6002aa1dd673837adbca65866675b2a125a352fb68384298c38e825f986f052db5bfbd1216aa11855509527d20411442b376f6424aa518d081a9371b6cd032718b22a6f0cc6e9667db39525e5a671575a706e6e5e644bf8b3b158ce06bdd9593f11a0f1d641109c25c9c0ab03b9349633aa57318914c4702a53223eef1923db68cb1c5020d905c01d0dcd38433006ad5255116a3dc5aa7e084d8ab10d1f270d1c786724d6c8760784d109314249181fdeef836d59c79ae748aeb2fadf41ae298d92d0ddba53f1f1f1ff30ea125361a23578ad4b937caa11a384fafa1c4978c19b71ff2f3b609810971bc6be60c0fb31acc3ef21cde2b85fd21aff4958e738b981883b7f30dc7ce85aff73e4ba80d4759108954456b8601d3c93c4010b24ece63159ea22bb69f02b60db70af792a2fa220b1035cc745c6018a5e967edc1bcf2e9a2ead4ce3077810b6f5c2847b43b85511e3ef8dc4dcd31a6158fa8ab3ec035d8bd4f134eeab0bbe1fd52c5c141e06577af66599783ab038af045885f2aa6da28f48408f667f8ea5b59587b5c475a1b1e55262b217157993e50549d4927766119e674a733cbe8caba446bda7cef55a0364a41e1aaa69f965c139b829dc7427e62d36873d7e19081ee1ca699422c92bdf8288e340b8ca33a9a35c58a92263d3b5070c62ba0b6313ba837040f4639a22d34982149ed38fa1204117cc7af4c959e0650dbb161f97ec704463b16a1589a08c096da40464431affdb0d6c0ab84e554db7aea6cbc316ac951f79a8c9459daadaff17f543c9c4859d36334b7518c52e9e06dee6723a41f96840d2386d329eeb316709c1d95caddf882b8cfebf27ee199854b124e1adfcd81b3c1e5f4ccbfe23430cbf72b49bb05c7879ed1aeb2acb1bc7325b900938318c7104d8dd2057eb604426907a637ed7e19c6d7336d83d112b83f3aa5fc6ff0984ad06cc6b576f6ec62c38f37f7b5080ece2c62d3025205eec7ef77c2f5c618669f1e5bf20d792365e6c44d3983f83128179a89c7cce1f7f9add93c736c36eefabbd2f501d1d423199663227edc8b90efa5256ad8c8206dae862489644544aae2b5342f9a2f4b325477667b2fef471db6c1144b15fb04e1f41a87a43f14ba69515b4cab35d5ba326fe8ee6917f867b9bd4e50a8f2230b06c8bba75dfac5785815c846c533e0983e997aac1dc83ff73577f4740df9ca1fcc3bed13b611da3ed055b25b12780f32cbe708a56a79952bc6e3d23c99312246b90d38d3e3c6c2e3c55ff2f04ea1303ae45b3617988af9ecfa86c6808f1b6bdba20c4cfda71e6430c58fb6c0e9c82cc0d0a9a2e63bf8e93eece12a943eb702e748081e9b4d2e37fb920ccbfa6dde536d9f6dee7f7abf2c6c13b0effcd1dd4990a52cc3cc6687ca703675dd1cc074b308e7fa60d57076e56383d5e5f02e1bfe29592fa6ae0e8c90ffbd94e8757f89cbdb196d1502cc598368cba4989beb574a8ac3022354c30a9fcd6a560c9e53c4975fd7757d74334459df724a84d6706975a56094de3e9d39090389951b903fc16fe19e6f8c80716f7b9137f6911e40b5540f57c27a47c68f40475000231e8c613fbde599d0a08d9276c2f58fcb1df2f111428af03f2e9d7d1c942c4fa58c67eae69bd5e51400b097d544b6be51e8c28c66048315e3d5cdf79aebebdca54118d5f32f5e024144027a63c6f162cf51527d130c5a068c8a213318b7f40776de479df22dba62d764b5b57b88c7b864a62d088466307de16f7e2d36751ebc1e2c4d046d2d1b6fb46f14c592589eb6fc5ed105b73692674121b979988efaa673f93b32dfb4641ad085da16e1e3a2cd9a9abf9678d3c6db4ac74c51132a0bb1d858bd9f247c016bf870a2dcb824231408875fda4ef8fa2c52114c7ee586e213834540e622014d6acb682ffcc2cccbfd13571f1266051578669dbd9622319359d66d27f14042feec254952d3549d8b027bad35780315b0657360aa18ef18c10917a0a9937d276cee2e8a4495b1c2d7c6c3ac8a06a69f31324b026b0295fdb3474d5b3c1b606eb62d851a1e2d84fc3576f99a300016aa356b11baba1e0dfec87eb544743ba15c92ed5c3565706ca8b521e5ba8631070dc1d1d63b5307fd2e871acc1268f0da20719202ff0f99f7f0f53aff74b773676415e9b1455e749d291e126bd032798675fd4725a2cb877d0e83d9840c74cc6e93d4c0011ca01a4100e396ad83ad8ba3bf80d3e3a93b4048edd829678d3bf9060af91c49c06c5c92d5d4827b310cc21d75817f02cd8bf4515155f90812d30ee24f69743314677574515b5c0463fd3a49aadec3d61be3067e41755a76cfa96e44d4dce5990ec80cb998ace89e5c8c728af14cbbcad72ef6559e0d65100e879db9934b71c4856f53a49b490509c2984f8612793afe9f285d17338e80a47ce8392239a1c451025f70ff2390538b89a5c1fade36f54e28cb17391294919f780f945fd047b639787c588ff4e9913e77348fd09e8ffcdad96fc16f52f72967b50d2de81ef3037455bec94e6e6f36809804b7306776c639daea9a85fe120c60eb6019526d3493490f65d5c9f4d7260b6dff838b311e1240f849c44e40a8a082a86843461a033df32f2c5f10c13c642b22563f15e83696f71c875294cf5706c5fb10fc7feb9ac57a4bb033ae537d35b204c4a9b0e6569c85a1e4ddc8d48371519ad438a7623eaa621a57934518f2d867b65d6b2582daee8f78be9db3a1076d945cef90d7edc816074cd461f4a71171da3536e38517aa1a7c1bd18433e0d86f82da4eddd6defbdb79452ca5d0c400d950d3e6f5e740975cdbaf8fce0bafc74d1527e6a3d2009cdaad4805cec0431010a42e2484bebc5dc1bc82648c8c802f16f563d929511f2372dbabab4173f59e082b69c28d2dfb188b60555c1e566f563f5fb665d50fe7513f250516bee2322fa4d73376bb0ad185a31b482546188288bad5f42d1b7055b39ad9e18824b4b1f134254c2ef9ba5e2eb0df3d7c777909f766f3368eb9b762b2202cdca2ab38ab0ef25dc8bbffda6159d3d7c0ef45db384be2dc821118538dc02c2f466e122310516687ed3bcb7857a1f74a48505373f852a0e4cb418af5bb8f3ead14bcae8a814abffdc9b8a37472e4a513497545cc446bb40eaa97d282da791bedc219544bafa8f0a8b045ee1ca9aab9b46b33547ab2e54735724faebb5e63edf483aebdece68ebfb66fd75f24559ab8cfa0287c3e170385c08e6d09c035f0c94ecdae541b7d977c6212d0c43f4b34f038be70ebd04bdfcfc9d57443b507e46f78d0f511bdfb9bffd4380fb7dcf0cf913c1d26c212cf594481e99ad79953a532289efe7932c711903e641871ec2768ef7e03fb7ffa15faf52889a427a82c8311ebd3faf8e1f077f9fefc68f553cce589724974cebe1943c3ac4d9cf67b73b1e64d92b566a679633b618b63dc0284f3993415ba7953c3f7aca5717d1a77c89117f4acf522b83ac64a0d287082a673c08959a4a9e59115f10bd3ccd267b96a083e7be9f7d67ff9cc4e78be0f7dfb9af8a526646b495fa871565d00e43258d4b262ac310f2ad34a31495e411162579a445191b221a95f52af9ae9edd82f0b687ceeef80fbed6a3b21c23ba28431c2c5219b4c3952f26309e9030cca68a3fbbfd218005ff7bfc96f715c328b3123746592211934ad04ba6a0fcb47485f1028743ab63c4dde6aa458b8040de6bc3e826eef4bda86851c8b68635ac210882a07f3db0f2c4ad5fdcb4174317efed3b73e842cf81d0bfed1fa29846d31aac9ed1a334dabf3ec6f904b77b6f89b1115a6febad22997b6f0c245555adb5d65a6badb5561c36e24ad1d55e115b9ceb91bd169b35f2077ee1a7f1ecda9b74034caa3c2d74a9e88dfbefdaafe62f15fd7a908ab808a3903f10346b842888e2f88de398c7118fe3388e771ced388e63ddb99eb3d974d10f346b5cf3828bf3675e604bb3863541f333cd6c9a26bed634cdaac5518faf6bab6e6a7ad9d7eb553fd8ce318eaf175996668d7bab47d54d1396c1f0af63fd9a69dacb34807db234611606abb9b437566dbaea982607f60d017009dea233186d26c6625acbec27e1e0dc9a8c6adcb7d5235a53adc6fd593daaae5303415f746b2d3565b058f176496c9408ae180d92967034eecd4ffaa29a878746c3341a8d766d85c1768effd120968afefa6d7f8988e218414ae36a194e998473c63b7767c7eed411b64d2093e1e0e4e4cc664d3bb527043f112747cfececeaecd096684b3c97c77eb3593dd2d1d9d9e1e1b9d1683d3d311f1f5c9251ad4040f8da71c7a67b2abe9687a67b74896bad866bb55bb322cd6c227bcc1a3eb4ffb13f15f7f8d89f5bc340b9abc6fd1bf5a866f0d57b86e53d77c5caa01e55c7251989e8a8e26523cb7bae3022cb219308768b156916b2f29ebbac718d8c4a23f2351a1989a191ad3cb0d247cf4a5befcf4f2da82654ddab9baf4ef6ce1345672a542ccd48aad5665b3134444434a335dd6645452c74ac458b16b0162d5ab468f1657c5bd8da53339b6640b4594dac41b66c02f2201bbed1846c4dee33dab56fab3f43f1b5280ac27e0800fefdedc15f5488f4d3ac71ffdcfaaa5061eb07733f4fb309b5e605e58a3a7487ecd0a7c2244036c25d5bb1b862e887be2811d1ed5654c4a285db6824d228864848e08794f145b24848485506db3986cc26a2dbad286909572b8b92058b580bb3a9fc8c32bed6a88ab08de38988cc1a96bc990618c1772002dcad88450b23b3c6fd5a8f8ef0b5b51e552f329bc4ebf8a2b5bf7bf6778bb6d66a3d8b9f495cadb579cfc0d246ddba3316b4598dd455377f6b43f445599806b06f74a76817481e64fd30d1d769607bdab03a5ba4ea464797cce72e3fdf33a3d8baa88da02fba4b24dc8b180cb3a9c6b03144d8cef147f90343717c91a5098b69d9114ece4c678787d6e3f353030a12f21355615b3144742b62d1c2081f5d5b9182fea21b036f510838216bade5d72a02b25eb2d65a6beda006fe6c91acd7f879eb625d72496bd6c05fe33e07f64350ddf2e8d23d3615b0f315bd17a05ffebefce12f5f20d82ec1570ffa8a6e0c7c05edad6086596b6f40777e8ccb2aabf7265a74e7382f0dda7a07f9b768e27b4b6c7a366bd8372ff89c03fbe641149b4d1fca817d83f3f6e0e782dff96d8da4afb37b13af12ce68ae471fd8af393bd5bd4935b951301e3111b8d136b6641b94c1d1204bc4e0deec6bc6bd595ec525e5d86eb3269d7bab269947c7e78869dc11631c866088437c86a82649fbb9ce5967b9c4d556b0fcc8b004cdcf926399bd963d332c3d2f1d7fc57268268c06334d8f5d530d6e8b5b6f9af6edbe6f1bb797682ce1a01b67f418c750186aa2dfb967dc974ece399b5245659ef50a559e505010134035dfb8194035b4de22dd0d70aa8914ecace68c2ddc52122ee9b7d5cd48b28b8a9d1516b4d45bc344cd05f57a3d23c8a0a939a0ded501add15253a6f6e3fb9644d67ed07a8b2aaff2ec54af17c512d490277dd658121b9cd1cde877e525f9b03caa06c201d56a49fc18fdd45ba4857323029cb3ca8cb8fc86baed77e51971d9d8711a971c4bd1dc719db3feecac9ff3af276b8db465362f7839462f4fdb12aa9209355743894aa1d26bcd95636c24fdf3986fd14400e9a2d3b8d78afd604755c2f51642cdfda061b53acb542bd2ce327d20c7c37842af3527f3d07f646809f5196791b26b748bff64c2d09e2570389e1de7c3e39b66b348d849ecc383d65b647b18e7dcb5d7413e77199e3bf6dbeaac91cffe9df5a6b55366038c6edbe3711cc7711cc7711cc7711cc7711cc7711cc7711cc7711cc7711cc7711cb168e3e91609635ca3618c6bbfadce26264b831f1feffdfcf47a3e3ebd5e8f8bdeb6b7ad4e4bcd56199e1a0d9ce3a9b7c842ddf8aeba6050b3d2b470f4ad67b519361f1eda8f4ea3b550f125e70a638c4b1f2743d78e4d04947ebb91a10ce63c8ebd5a267be537b7dd7078ceb07e20c7c3ec558865e8be619045caf64ac7501ae65ddd5bc6bab7fbc4bb4f50ecd57dba4f3d3eeba9b7483c79f6ca066d2909c7d333e3e1e9e909122228485ba49186e65b346ef1a9b43133bad974199ccbb7a8ac5d6e64afd1b0d49beba191e4575a74973f3aad6ca1a2462dcabec31f259863cfa9b91ec75e2f2ecbb284f59c5697b33c5c9443d27765122b52e915e631c7a6024ab7569bc7ea62386e9964ae694c342c920df4deb255118d2d967bcb8e516ba54f5c6fd86967588bb065aaf8cace0fe44000d66e9178384723866627419a571a6aafb2e72b9cb33d5c943d6334db5e6d076d755769e39cf22e9fae5216af52f8f5b3e346cf5e9ef8142dd2e83430e8e1299e1de4dfb8f2756e1be563073fd06cfa5ce7b43f3bede79cf6abc539edcb4efbfab41fb36fda27edfb540bf47df4733c2e3a46cff1ac16892c1d9f1bc7934e0b63be5b6c15347e94b4efd88f5e6b8ec777ce8fa66fd88f5e5626dbb348d9471f3d8fe8b661f4a1eb30bbcf4e8719a5dd9b0ee7689edd2d137ef3e685bec763354773acb3e3aa84e3d8c39af3713c3a769f33ac45a3e39cb8de46979db51ef59ca387423f3a6d44f78def47c72602467474b4bcb78cbe3e6bbd6df2b1f39cb516edd863a791ddf62c935891b067a2c71e137aecb0d76374db3035ec34cf7db397e716c1dfc01f3a79ee325b2411c561fe7c7739d7fa3882acb67d9f1ef41ad9e2ac35fad14551747b6ea3174791c6c5dd72a45be748ab93d7e2961e74129be6a9c12d02fd737b7ebef556f7d662b3e9739cf4721ad79ed8bf93036c36c57cebaf9bf675fbd77dfb5ac5ebb1f3e7f398cf5c9f3f5976fe64f4670132375d03999b9edd4471c090510db4eba0384cd78e63e632cf91c2ce9f05c47ce63f1faa41cc673f1ac0dc74989b8e73fe7caee339d29cf3e7437f1690e338ae418ee3f8e738280e183e54031cd74171fc7cae7111e839521cc7f1f3a11d68a0e33bce809af2107111e833df4171e0d8f11d5407cd91e6788ed4ace9ec9673d614e7aca9ecaca93e6b1a3b73a4b033475a9e9bf6a0db8bde001d708623e8514435b8b70c666d34f69b331de499e8006e1148e3de40bf4ff4e719e4815e6d20ca81fb145ef108f1c918a9b3f7fa6ffd585b5d35650fd83155af32b82e8a9ad694b484f6f377edda2da0166107a32bc229cdf9bb5e6133837a84773cdd5bfd8dabbab75aedc5b0ab9b45a1abf7aca0abdf1834f62aa6f8695c5e0884d669eb4d28f5d04081ed495276eaa744516b1acd337abbb70e7a3d124dd7dfc09fef0d076c8dd52ef500e7a3862a1e47a8c0c3619db0814956ea81a52188375569b53136f8d6ad1367c04ca5624ef0822e253f304c9a22bc948c9d3ab4d15b8cb5d16f64527052d8eaa51e845ae59945ef4c3eb1a384def982fb6280fce0a578aac8d653ad328e2c09612bbde77dd29638ea1345cce8520f88f45b5bc29523572919dbc9b23fa4802295064037e429256f894f2bc5c30b4e2989afad382b398344554ac684c6e82dead03e2488524826ce2abdb310114ec24e113d85de59d64368081cb687901ca4521c1ec89670aaf1a4d27a29d8b7b7be6342ac4b6f114848ad0b171d78b5fc02480fbc948c65367a67120a718a29466ff127434d255195de1d9c46d8a564d797035010bd45924de53255a54befe39cb64c38ee94142698e8520f5e5fa052187e0c50cbbcf55ae62dd2972bba948c8950f4ce2fc6a0ed25a9ce48e19091e155e68c68268af04c96b18c11b90b9b714144e3842ce36334234378e6074e991e6740087110c93019cb44e19cf9209b717a911973660d4c099c32278468869067ce9489612433251cc28c4e2c53430e9a15341925f98c0d26192e386782d065b68466bc8848f81c09c9408166ce8867ae40abd10c980f4d8f98192be11929ca7811cd2891cfac5006cc2884c606bc4a395bf9e94ed5dedd81533d98dd39ded226c8d381bd114fe55de5e5a97a759fb62c2feb70efbbcabc7b05ea763c7c957b1f0fdcd9a99e6eeadb029f2ecf5e7d4fe0957dc2b96f07c3d75a6b73c618631fc771b4d6da529cfdadfd35fab3c7da9f81bc00202f0dfa96f8626c36651367f382ecd96cca68fdf087718da4c7582b3f59afb5166374976fad78f517e77bd1259eac38e75c7ece18573dce5586f59cdda2376c6dd7f51cd7f9b9680633c7f12eebf312b7c02f5f9f9d77ea52603de7bc5597878bacec94f9f8723287312dd3315849be463104a770ce56657dbc9d9f6497b481ac7b09976b0f43de7a046e4e5bc0ba8d9bab3ceb343078eb349d75c739a61d64e0e95062862dbad4faed955aaf5d5f4d5bbb1e0ce993c4a555a0db03afc2ed49a25eaf52be81ff7a154dd0d77116579cf5ac16c9bd5ea50c8a3324fafaa967444367bdb9c8af67507c95344f415f17aa79d1adde2c0279bd4a2dfc7a06c55709d3b3bf6e33a2d2d7836e462d5814d59bc572f47a958efc7a06c55709d33833da5fc72dbda0afd792968e8c5ab0a8378ba5f6f17a9590fc7a06c55709d338b31d9a8dda5f9f310021fafa0f8d0120b938326a516f164b3d7be1d73328be4a98c699edd07c6a37bebf8e410647f4f59e0364f00287e4e2c8a8de2c967a46e3f17a9562f8f50c8aaf12a671663b349f5a905fd7200241f4759a03221003c60b1c928ba37ab358ea19ad76865eaf12057e3d83e2ab84699cd90ecda716e4a8edf6d737d080127d7dc7021aa02029068c17382417f566b1d4335acdef39cbb93832526a41018ba4a2183718442f86702b906c36ee0ddfb837ace3811b39250a9262c0788143aa378ba59ed16a6ebb275801928ba325a35c0b2516141425dd6210c1187ab10267f37b5d04ba26fa7a8e57b3060e5d054b39250a9262c07881ab378ba59ed16a6ebbc9bc5e2526bf9e41f155c234ce6c87e6530b72d436746361e40297c4c3470cfa3a8e930f2619152ce59428488a01e345bd592cf58c5673dbcde89e00f0eb19145f254ce3cc76683eb520476d433716462e703092969ea060d0d7f5102800cc609251c1524e8982a41830eacd62a967b49adb6e4638b3bc27cceb55b2c0af67507c95308d33dba1f9d4821cb50ddd5818b9c0c148525a9a119544067d3db64b6241000030834946054b39250a9262d49bc552cf6835b7dd8c7049f77cbf9e41f155c234ce6c87e6530b72d436746361e4020723496949c68c1ba0d4d40afabad964ea6958100000cc609251c1524e8982a418305ee0905c1c19b5605174231a5a6143cb7b0ac0af67cb94e4d741cb14c3af8b9609865f7f59a6d4af9796e9855f8759a6f7ebda32e1fc3a8e65a2e1d7679609c9afef58260bfc3acd32b9f0eb3e9629007ebd66998efc7a906502805f77cb64e4d751cb34c3afdb2c530bbf3e649998fcfacd32b1f0eb2c2c930cbf6e64998afcba0bcb54815fc759a69b5f87619996fc7a926522f2eb4a9629e7d7972cd3905f97619994fcfa0ccbb4c2af07c03251e0d76958269ba5baa74f94be356c156aa708e04cc1bffeafbf4e03f6d72dc0f9eb01d8f9eb00f0f9eb3382fe3a13fad7650cfdf50a58fcf525177f3d07e3af2b29fd750ace6a91b68cbf9e74568b743dc6792dd2751867b648d75f9ca245ba8e3b4b8b741de9d416e9ba8b736691ae1f9d348b74dde8ac59a4eb2d4eb748d7599c368b74bde8bc59a4ebb7d3c8225d273a7116e9fad0996491aeaf38972cd275db39c3225d2a1aebecc53832988af346feebe8e9a7d01974029db5f3e7dc3376c5b2abd563a761e7397715f3d8774e9d7357358f7d76eecaf5d873308fc72e3bb7f5f1d8f5193bb78d7aecb073db248fdd3ccb735baab753bef268380c361001cee5d44ae15c4ef56b44f752e589e8ae57352bc420baadcee943b785da6574db295bf5d8df1a599135337ad3bee646b8ab847f30fa559ea59a5279336e8052533396664425594a5a7a824ac2253df62f3b68847bec9fd1cd480dd7cd76eb69d9dc860d4b0c58fb40daacbc38dba83df64f033411dcf0c00c475bb23113c10d6db33133f280164149bb91fd46b9717cf938679ff349578b847d8be5cdd5d42784708a2d25903085ae8717352510117eb50732388ce912c4051282209115e69081d72386ac333a22241ce1252c011128d4c0c584294af092664bf8840b574ee083102e1f2768e120d38da03ba1491256824033259c80133444818035c58820cecc109aa0cd1340bcf940c90d55cc3819ba0a13840a6d94d47082324c3c18a306092134b4095302191680382289102098b9210d162354e0208a287e2051831211ae1491c2f77ddff77df58a13595db6a420458931bd20e80b1282d8f0f402991344208284f033cd0891a5a3049e8e26d23cc4e7127a7cceeeb7abf47ddf057a14896255e487ad11c6bcc981e9f7c1bef2802893132409149128165a5882462b3bd1c2536865245a4bb4866811d1ca45b4f0105a369c3f3014c717599a3272776f37c9bd5d276153f776a9eeedfacd57e92a5da57a95ae52bd4a96eae62c8f3745eae6ecd454b5bb5d92a79bb34f4f96c7cd599dcefaf8ea22b8390fd8b8b90d947a5c5f7d833bf35a97d06abe337af59b118f57c7252dd1bcfa8cab642ac1bcfa007abc3a0607c8c0c7ab6be080085ca5254e9efe78f59f2278158bb556349b6c93aca91b60b8cbb29b013211f3b4f419b9929461c0dac2e117ae7a46d76cca41ed550afa478bdef6ca8a59e2e469cd73fcbac5ba01a85da59cab94e3d76b39388d2ec5253f3f3229f4ec5ce2e3398d0f49c6a2746d498fe7343d262642dbfcdeee121acd34c99c451b2de1e11983e824dcbddd253bbe63863df48ca57bbb4b7496febace87b7f400ee9299e734da62dd227b756fd7730b1a837bbb9e465b191220b09e82af3c20a29e8cfd344086c3c608596276a9cc6b7aa5eece5c404d655ecd05dc5486ea0ba2a065cc4e8b18aa1f231ef49002892198f86063450c1018728200c2abf22901f1c2e585228c40e31466cdd83543ce194957948f1a6648a28627217ed8906f789203c8981c80a0d2040f3acc0026081f6fc2207e8040e583820f614029524723a465e9ab5dad6e8f5bda00575a57ddaa3b874e14d19d6347e3310284fe43b13f4675d809692bc63bfb5773ae18638c6eec1f8a2d768b51119bf12763d65a6badd5daeada005b895759342ec637dc92dbbb4bb1975729fba4a0eb571a37973f2760ce19dd9f874e7edf9773fef2f77d9f8bf9dc95778a637df988e67bab34b1ee172abae39cddd1b2aa156d49e3ae886efdb2ec2097204714f1206a7bb6cc55027368367d4c501122cd6fcbcb4df9bfd3fe0b225c31e2b7dde51d50570682d9e7339b3218fa7590891e65d0fcb6f7011f9cd83f27b3d9f4e126bbf572aa392ecb91c95ce6158699e7380e1c9fe5a01e5c29a63ce1a03a1cc741af0e17d92e5c64f5059900b184807db061041f9cf8d064874f903c7ee5f9f0f47921ab6d83bcb7d5b1e8bef2aef06aef2b0f87153e3f551956ab1e5906dcf442e1a211f4ce4f6015ce7d5074ed74dabfa92a9c9351648b148f87733952eb9fd5778573301d7cd8f2a44bad7f5938b7012ecaca3d9c6bf1c313434ce952eb590be7725479f3e6cd1b2bbef207e22cabd1fdf5defa063897b770917574572dd4b4254aa2dfeeedd3db4f2a4fe5aa9ef54feb09e7729a58c2422fb59ea1b670ce3a815579f76d655e9109469e9cde7e4f34fb41bdfd2eba7317a8ed2786ac968903fb1d84808310fc1af56b3db24cf5abd71564b56dbc55ad16abef8d096d7d6b7bf1ed8729460b153d543867c99f0e4e4e6f26f9c01cb41330ac584211872c16e49088664988e37805a7e3647c895680bebcc8320baef270608ad14205f8611ef766734296592cd83433486966090096f16f997bebf162c24e007cf51ff79910b0d80c724b4c972bfca631415928da105a2643eb9d37329c0a8094c0c9917a5a3d9a4de5cc723c23cc7494b6e8ec7ca1e025c40ecf0f49578e858796f318ee413c5aed19abff70095584e0e7617a024f5a7fdd678773396a7803b5440a13da30712487df3e5c9ae8fd20c148942474e9f6c1f2dba792397383086f8cd031e44dba7d70f8ed63a5c46f9f2b1f2c2d3e44b444fddd3eaf2b9fd795cfabd7f3eaf9bc7a3e3d3c9cb33991850c0f4c7c6872c495df3d25b061099b10ac38a10211e9eeb1f2bba7891d9a10f245ca153247d2ddc3fbdda375e677cf16d70b494f941792297f774fd54baaa7c94baa87ea55d5b3fbdb23f5d7693d9cab5746b6ac382199e2cd90b4ca6f9ad65f29765052f5419a3457e9a6ddf09be6e2062468b2a42cb1cb92ee1e2abf7b9c9e86fcf5dd03d513b5040dcc123431fe9b96d545ebd245c37a39d1aa5e4e34decbc9eaafd3743857a580e255094105104a3062ca6f9a5391d490ac1c74d0ea6242ba694f527ed3a0aad090c58b0b6894880122dd341b7ed3a4fefaa64dfdfd4d1bc1f08c607878d4f070fddd3c5dbdde5f1eadbfceb3c3b96a35441026a0f8e0893354d228bf79a4feeea4b2d2a4f0c31133e9e699aafacd531535044b08266868d811916e9e1a7ef3585d61fdf5cd93c5236664c243e49944fddd3c50533c3ea67886f0ba783c3a1ea7bfbec3c3b9edc48ea9a822524cb540c3ef9d094031460910281cdc2c49f7ce0cbf77ca1c4105c994a91a76a090ee1daadf3b5a7f7def6ced70b5d989d266cadfbd5335ea769a8cba1daaf169076a7cdad98d3b527f5da787732ba24822a48d14179b23a0fcd691009728322d0041c20e27a45b4786df3a5d1948212545083abce1724af7ce93df3b4e7f7def3ced0cd1a203468b98bf5b27eb4aa7cb950e564fa7aaa7c3d3b1faeb3a3a9c2362d3c49724d448c98a4aa77eeb0899a201092c4f5c31a12add3a4e7eeb4021400d1537663e6063048574ebc4f05b47eaaf6f9d291d2a91481b91889bbf7bd625eed4883baea959d6546f4aebafcf76385787f0f1440813c61899c22385e1f74c2acbc9c9852d4e4ca124ddb326bf670228a2862a40a208614c0ee99ebdf07b66f5d7f7ec6a86956646244dd4df3d0bb766e1d64cd4e588ba99a89be5d0c0820845ac10a5072e5f5cf89df332b264ca1a2e19485022dd394c7ee7f040a50405ae3146207993ee1ca9df395a7f7de76ce57069c989a225674a4e931caa9edf39555739505739bb1c29adae9c9d43fb9d133ec1099fe0e0e0d07ee3845538210e1627281ca9bfbe71a672af74e3508541da8441dca8e1e2f92deb0aa1645921542f84d29221ca191f3e64d8c1ab926ed992dfb22aabbfbe6557322c7009191170095994cc876cc8ce6f19545757974cd7e56495a5b7d65c5674142b53feea2ad04a37b1a2cad250597a9725f5d7633d9cab65821882ca961dba9a3ca5b685df312d28944cd165b1c1865dba634a7ec77688b082113b62d0b9a9926e9de4b776faeb5b3f6910490c44128bc5b0fec6b2c0581518e38131abbf1ed3e1dc986508104ce0a16b8824290bbf634e3574545cbe484121871ee98e9de077ac2e2143171790eca6d44049770cc9ef98d45fdfb1a918d5126d9670f317d6f575c1d47c5d5ca0130c7482814e30d80ee7162085cb0f2976f84164f71b56c14441452607246d8c18936ed80abf613ca826ac4ee044854c0ee9861df90ddb3018961518112b517f619f15ecb3827d59e69705fbb260260fe7727c70240c12416cd9c1c41babc26f33688a561b116490a2254cba4d1bf5dbbcfab1e48413aeb658e121dda635f2dbdca6c985c48c8264ca5fb3c95f73eaaf592565424999bb6d4afdf5b287739509146890f232246a2b4d5ae477a95501178e58f9a1042740504977b9f596c8efb28b053655a474ecca2c916e13eab7e9f4d7b7f9640ef97494603e1da598b24b89f5b7ccfa9ccaaacfa9e4edd2eaaf973a9c3b40126b9ca0e1618db92185dfa5539625b4788152c24b0c26a4bb44e17749d543af0c9621b8146193eef284dfa5d45fdfe554ceef92ca0bd9c68b9bbf6457ce22d5e42c2e2d324baba7a5f5d7c91dcee500f2e508167638e10986ad21bfc91ac4944eca0a503790c025dda409bfc9aa024001b36608992b4c82a49b14f29bb4faeb9bbc22b19e90449e9051a40f72c85f12aaaaab8ad46d9287733c49daa059e2e4c7961382fc7e591d200c1145b4803ca52993eed7d5d3ef57d60d26f8b801ca171d2944a5fbd5d3faebfbb5f5e2ca415e517290d794579317d5df57557e41e5d72ebf7a38577b505d4a1429e28d115da92de1f7a895801d2660713a8344d491748f5b16c8ef71851b98b4b015458519a8a4fbf5e3f7cbe9afefd7d36b081ec1e0514cf97bccc263173c62e1b10a8f3c3c5afdf551877320b841480c63c490b01322f5f17b749a8185146a006303971ee91e9f9e84df23d411dd0c312c41262b041de91e7723fc1ea5fefa1ea7462a6c456c83ad886e443522d75fb1cb4accb2ea59ed706e5cd2c4901e42662823432ac26f512a07942f49a69440e5871ebea45b9c72fa2d3ae143161eae7a38d1a149ba45de87f05bb4faeb5bbc12b1701091080e2246bd7e8b50184af4210ec1525d584ad461291ece6de089335474d0d1c2134a52107e873b4c6d21c14b218a3031a43bbcfa1ebfc3ac0d58e04161450b0f880ee90e7b3c7e875a7f7d875b215711619422c229e3efb04a2b6ca215527585505de12e94faeb600fe7ea159e0e2d4360d5d0c312e98edfa09690962c3fd610c9024256bac1ad0f7e835d7fa5da8809a31b42058974873a1dbf43a7bfbec3a7bfe1102d20182d62c474835db0fe825957e0942b100be85402160d52449460f2258874834f7f75bf412850eaaf6f702a074b37487589b4b944dcfcfdbaee4ecddd714d7d5953bd292da9bf417a28618286aa89287a48f737f56f7e7f559fd55fdfdf15ceef0f2bcd47244dd4df0f6aebf3f1776bc85fcf5d9fee86a9526303902e42ac4e904ef13b5bfded42a5851f94b8e92125ddf94a8adf994b0a2c418ad4b0860990746737bfb3d65fdf794bfc9db9bce4285ea6fcddb949aecacabb9da57232fc7802ca8e24ba256914bfb156d5902436403142e40459e9c650fcc65d5d57968082c85615978f74e736bfb3d3d390bfbe3354f83b473dc1609e88d9b88badc245559867b10ee7aa559b34407a3abef850a4eb3776c25039e81842ca933527004937de3df11b4bfdf5df98eaaf8e3656879bbf4eb8488d13d743e1a2acbbc3b95a86479612c82c59410a98d489df57aaea5a31b9bf2fd6022e91ea25eaefbe500ef0f1376bc83bfdf59c0670975205f5667ddb285fc194bf396618a2ebc70a3c64f8b2246de2b7b55a00102427f43802831b2ce9b63daeff6db9feda24346e91f56da3fefa03aad2586fd62ffe3d8af96b9b84e9b643ec1313bfad53056c8c10420424b844e892b27927217e408982cc942d4b6cd9f284e50b1a273a1de9016e4e57b4c7922f639e44118509e9c5b9ba0686105ad0a1c908315c49ef9aaf00981e11212c99024c557a95f8eb38f0affb127acb9ce82dd3e9abb76e6ba2b7eebd75f3047aebdd5b3791e8ada7deba6ea2776cebadeb17f4d6bab74e1ad13b76f5d663af58158faaf382de31a7b7aee382de315b0c7ac3786fdd0683deb0abb76e96a037ece9ad9b3ff48675d1dbecbdf59e2d7a9b5b597a9b5ff436796f9dcca2b7f9f4d66961f42e7b6f9d2684dee5d65bdf71a37739f5d677a0d0bbe4bd7520357a97bab70e8484dee5d35bcf50e84d3ad19b9c7aebb318f426796f9d4704bd49dd5be771d29b7c7aeb2f2bbd5f576ffd9545ef57efadbfb2f47e49bdf557958be8abeaad874588553fbcb8e2458f994da2f3f41ebbdeba57d1fbe5f4d6c75e888ebdb7be0208cee5d4ba4cea2ad5add00a0a940f6d1f3acc6c0a5d08bdc7a9b7ee60f41e796f7db645ef51f7d6675af41e9fdebab6416ff1eaadeb287a8bbdb73ea3a2b7389ba2b7b844efb005bd45dd5b171241eff0eaad8342e81d5ab10e6ee90d5abd75708dde60d65b9711a13728f5d6750f7a7f5d6f5df3a037e8f4d683b4e8fd59bdf5202bbdbfac87f2200882a283601623511ff27ce8a6d9149679d14bb34924cd269066a57768934aef9cf5d64d287a67adb74e12d13b57bd75b288de19eaadc79eacc780e88dbbdefa8bca7ac983de7807bd7110ebe293deb7ebadf7e460bd078bde77eaad0745e96db7de7a5011bdafee15c03583171d4800697325cd497cbe62e4c7679f65bfe1ec349d4ea77b4ab3111fb6f8d05f665398035daca3d9048a6653b6593827d3c9743624f496e9defa96eddeba6c274b72a5080f9539c9745f14fd5f0ef779fd7e979f7fcf3e7b95faecf92ac5f88c6585309fb1ec867c76d06ccab52a7d0f66b3e92ba5d0af2dfd5aa34b157419a5ad1859e13176db8d56b352a489ff3c5f2516ff55a50a840b9fadd98471ff15a1bf5ed1ee65bc1144e9a4e82d9e59e449e1b42a9538691e4b5f29320196b2b09489e505c58ac345d8afc61883a8888b70d5bde1f034deb6eab1ae1be7a2a979accbdcaab13cb5bcca9205b2e441014b59cac298a5e804acdc71428c953b49e81268069aac9465d1db5e5d5d5d5d5d5de1943b5b39a598c4ac14d55ce9944e75b553024599c18856caa674f5945a47f629655bc49f12a8aa572b3f1ab4804a5993a0527fd02554025df172674ded2c3f1d325a962da8284536b652e45a51c246182a452432515926b9955f1ad16e5c510964456f7b7525b228c5234a71a66b34bfb528714cd6f78b5c6599ac0d6f947345dc339e342a7b6a4eac4538173a765c95f1557f5199b2579ede9465caa82da22255e15c88da2b32323c268fca9b9a6faf663a92aed2b6568f1dbb6851ab12682eca0f8af592442a3f5114af704e0cfa7c75f86660448ab637e79c69554697067ffb571df40e1f7c38572cd2ea598de09716c1ec9f69dc100cbf0fbdf13d08826808becf68c6e126a4675c7e58c962d046ed267e9e453dea10c5a9a0ad6f1c4ec4b966d3222449ad5e95212b0d0dbaeb99d6355ba6cf33ba6fe01b2d63dabde1330404b83a5b8fb2676c367dd93400f9e6cd6f1c3add67b483d16f885f91b2571c21b83f82f8419403fc23fadf35b5b4f52dea19cdde1bf8b3df376f42803d3f652c6af03fd75ba4812e82a7067d8b354a54d3b2e72ca2f8f6998681116d7d572b119b4d1f885ad3003a2e00e1c20f016e463b80d3ad21abb5b5625a5355aa32aad7db757d6f5729a7deae5f1ae700ead1f59c8c36d5db1dc0bdbdbea216fca0d19bf6167ccd6d94d72da8325e7fbd8a4f1863a85b84c590062ec24966b5f681f6dcb6123bbe50160a63df007f7e4f31f41c8ae199dfa2153c71a8d634dadeb8c7f5fac65d259427de0f8d756b64abaa76aa4a5dd036a1592a5e2d4700639d2a5230377d8ba55b290fe01c0c45f57d6dcf8ecfd0471bb6a610b551e69fe5b4786934f75bb652958751297b355e9007d1f6642cbbce4fe801dc9cbeb8a58d2b1f04cffab9ad36fb8c73b6fd2dd7a2ecb5cf5b97b6c74ed06c7dfd1aab36cf15004e9ec67cebbc132e8df9e629ddab87d64df00b40ccab93d6afd9047a788a2f7a782e8179ec7412d3d1699c03b8b7ebaf13832ae6e9e7cde8c49d49df396346ebd23fe2579ef884f6df3acb0d51e0d31880d72bf2662ad2b595b69fff88fee342fe23a2190079cd831cfb2549bb23f393e8a4488aa4e8a26f27495288f42092249d244992244992244992c4c9f199a9cb4c9224e943923d64a9494d239dd42167a4e79038a4cb48922449922449922449922435192361a4499664261de8ac9782ecb553c445d97f4e1b2996f072cd45d77f81fe73ddc783fce7a219d4fcc7813c3bf6d1c5fcf432dd6a6151d4bae2a0f3ea70d1cb814edb858b5eaf97bf5e4ee3be5e2ff7e979bd5eafd7ebf57ac972665eea382cc6f3bd5eaf57cfeb4543b7c8836ebdf3d241b7d5fd6bf6ca7939ce4bf6728d6e0bf5afd7ebf57abd5eafd7ebf57abd5e31747f4e30747f4f26fa2a5f24ba3fddbf72d7bfbc76d64bc1e73fa7888b3ef739352efabcda5e2807409ebe2110a4f56ab356c7c32d6ab1b5d8626bb17f19049d043ff0033ff0fbec67cfcff3c901fe2e309f568faef730a9ba53ae9276faeaf9c4dddb122eba8e4bbab71b8446df2a7cabee5548020f540f3ae8a15fbbc4741a97667b9eaaf4005586ace71c6b9175515753ac47d663e7cf75d26d0a3b7fae979ed30bf07360dffc580527bebe66b1a184c7eddb8f6118e210dda367979db11376bedc9a178c2e827ecfcfc76b36ddd0ab79033f017aba9ca17af0a2366e0fba350dd0d3e50c9407d1254e9e9a68d22db2e29b674dabf9a138f14737554afe2ee14e1af5c8fad882f6df22f9354b95247fd1adafeeadbe58af5e170c81b426a8faec3f4cf4b6bb7dadfe7abd17ad36eee9817babb5d6ef73d2def2dbb9da8b737514f475a1223014185bae9ca1d8fc7dd94eb1903f300cc12fc3903f300ca33e10fcb21afb81e0976308c2e6efcb762a7f6018825f7efa2167305ac6e49c79743927f18484fc8161087e590b981cacad923f10fcb2182e536e905a22e74ce6ea03c12f73d1d223e74c43fec03004bf1c953f300cc12f47e50f0c43f0cb4168f8c1bafd40f0cb27a86073b64ba6c879899c57e821e76c06e37b31d8f5808688b77e1b418a2b34a001b3c3e38a4081bcf8e6308761ce91befda56bae1cbdba5895aa522ed14aa215fbdf1d7ef5af32cdb048d7ab93e1f9d5b1de3e7386e863eafce775dfdf33c07afb5e21787cebedcbe07f2478ec7914abcfc6797df55bb357276b48d3222a81c704705b2d8665d4deffdc667cc1effb2c0c58ad479fe31ce22d8390a4bd49f2ae3c2da8bf713f06f2050c9cc2ccfa47adf94a5951b5028be8cb9010222e2229a2158874ecb819290a43a464851344552c3e2822f2e4c663280a16405a90c04209d18e1622ecc06237a445f401113a2f5c3d845022081e0c584154f0a10513ed8344914ec3c614d9a071b89c408b3810e1a0c32945635644515a714249eca981826c9321493497c49001c68b3cdbc2e9c8806481b25c581b9423738891d8f3a5c52c0c0b7287a24c2be2b68308686b684665137980a8105f3ba0e26bcce9563c07e1201494673d00e92a353bbbf2d3c4070cc393412674b20ccd2c6bac9c1cc4038e48e341766b7c195f70ef05f7332fb8f55e6dda10dbc132b93373ec84b22a7dd96dce8ef3bd5d8b5ed4de7b2f112f116a24a9883d59c22024a0f87ae10381b0f98dd0d6efcd366808f26b42c3a277feac944ffa5665dc6a9dc80e38b06ffefa0df1b3571bf9bda0770622a37307e1df10ffe702ac538fac59c3fc8a8af588a719503fbf0ec8e987e2f020e7f0cd14babfe8ce135a3c33ce395f8b03db1efc7dbf5d5cc415875f79686cb8d7f2b2a665dc17ed5ec67b7b86042f5b9248abdb31da46f13194e0a1c3951f8e20a24c5a2b88820b550e3bd82401c142f1d66553aa8cfc96039f4f5da56fcf40073cf67beedb5f7c4fd4c6edb17f32a90f95ed6449eecd7acf11bd653b190f99d355cabd951129222223521455e4a368c8df5d0425dbdd64bb22d9aee8c6c3b91a4c52d0b1c044162042dafcbe59d00684221f38a10b018874dfba7edf96d270e95a808147096fd27d7be2f74debafefdbd64db7b9e936b7db8deaef6ddfa0feeefeea9bd45f27eae15c8e11ca08e11df18147922652277e1369fddd41260a0626929cc9926ea2267e137101e20305365c88981242ba6f5cbf6f4e7f7ddf9e6e43b41081d122e6ef26cad257445df4151196ee1155e91e114ff788acfe3a910ee7aa9a214852c0c1c81a18aa30f19bc8490a0612945c45e124dd444fcfe6371114971f393061e20b5710e926da1149fdf54d3445fe26a2d244da68226efeee21bd1bd2bb213d35a4a786f4d4d0d00ee7f609bcbc312187373a6459e2f7d00b3a2755218871626647ba87b67e0f518006303a6489a2030d27a47b68cdef21abbfbe87ae62bf87b0d20c1149331405e3f710d4d6908fd8d690bfbea24beb86747ac8e9afafe0e15c03c20061c6092423bc014289df2bac9ae84a82ca981c88689921dd2bae92f8bd220b4b6bab0d4f47e449ba57a8f9bd62af58c1a56545142d2ba6ac68b282eaef5e51155b115b115b21f5d76d3d9cc340cc112c167ab0c10d9a1489df362d105c684184351fc80025ddb6237edb7a1f6831028a1e5a745049f70add0aa7bfbe573cc17eaf18127b6203137b621363eb62c3fabb6d595536dedf6db3faeb361dcee588caa18525588c14699225cd6f1b9a188ee872e689d319a874dbb47edbb0b4c023ca09549e5449b70dcd6f9bd414d55fdfb62adb94980e156d623adcfcdd2aba624e2ad43871fd85c2453128adbfae628773357448783494800505efcc6f1552434dfc80626a0a4c1050d2ad62cacc6f1555171082e68a8b10639a48926e15bc32bf555805f15bc595fead020b96460511581a15512a7ca818f277ab80826da16e605b2a78fc75948773475a469280b0638a2921647ea35a47a889828d151d2a40916ef4ca88df6856932294e8a1890f51a8a41bed15f11bd5bafa8d6ea51be5824541a3c0a2a0538e7ea355301eda8447054361280c95faeb670fe76a9b1d08563d429042e607dbfb7d563160a80851040952b89192eed312f1fbb422021b2082d8d1852724dde810bf51a7bfbed12774084c84130c4c04317ff7097b3a614f276c77c276276c779e3b40f1c16e2a4a93273ec6fc3e3da0c5083233f08010c142ba4f31bfcf18d63cb952c1071a76a090ee73f7617e9f527f7d9f53e6ef930a4c1b306efe6eefeaa9e9716d79d6566f4bebaffb0ee754b8e131f1810213bb35a910bf7d04a7204ea08a820c9523e97630bfbd4a032b5ba8a0b0830c4d9049b767fd76abbfbefdcab198381126517fdda1cc29f7313584d7c5731dcfe9af0bf1702ec71122d0a4e08305166ab0f2e5b7908c1dce7039c1c525cc07e9160ae2b75056069c78a932844d1125b449b71010bf85b690902982902982909010d5df2d54650a4199423b5348eaaf07f5700e035d636e6842c9921f74c0fa1d54a138320213676ec04ac2857407fdf03b288745489a10aa70c16221dd423efc1672faeb5be849680898203060c4fcdd4159bda02ebd20acada0aaad20de0eb2faeb413a9c8bc0162740b0a10ae10b0ea997df414e2190828411509cb070440de90ebafa1d046505c5ca4aea863160d21dd4c3ef20a9bfbe83a682a84a266d4a266efe6ea0ae2935535c3ca02c5e8fa7f5d781763817aa41c24409251f9c8025e5e13790140792f0c035029b2e1ba64837d00ebf81a480a1ca13504988d8ca4a375097df401b0808ab0d109136517f37105409e4a3041a52d6ba4a205d09e4f4d76b3c9c7b00970f7690f24215ac255c7ed774a60c3145550a2a84a14a776dcbef5a16053c1c4cb08107066b8a74d7b4fcae69fdf55ddbaa7191b528646d4aad09d5df5dabead5a07ab55d4f4aeba7abe6f4d777ede96f6d08c9e4070cc944ccdf1f72ea879cfa21793f24ef87e4fdfce8702ec79414ab16744873830b4c58fdfe410ae2861b868042450712e9fec9f2fba7eaf0640bcb0a63acae9449f78f0ebf7fa4fefafe99027fff50b569d3c6cddfedd345ea7cd4903a1f2ef2c9278b7cf2e99101a022a814091a0f7349a714325323c00040002317003028180c8a06a328c9b144f90114000e63b65260521e0824f220857110648c210a004000008000008001a588ca00984ddc1a451fbaf9cfb961c8ff7b3289e65cadbdd42222f66c6dd6ab7c1bdf1cf354aef12ef285df769b694d6dc1a333d0b5a3f8c7961c74a0d18c4e3dd24813a7e9f27ff25e9a1dd91c9326343a600a343ef5146b088a2bb11db8e2bd1fc26e9e0acd637d1d476173dfddbcad8b587b7267872f7993e8e7dacf52614b1bdeaafcd3e9be3aa9665dfd2e71d8f38ead7514b0b51baa7d7eab015f23ca901cc98c0413bace4278363584745700bc2f7ca205439e90da644d1af0b2c967765d8da3d3df290edd2f9cf2f48b3bdca118d5d6219b6ae8b4c33159f190f0ad12d23661796dbf0d3d46d64c6096ca0565c41bc82e53925b09e0195e730346a1c0642ac0762c782667a657bd58983e3a8369db82fc14df4c805591c5fbe8a63c420b9f468bce76a6f6e011d37547d5725005fadc4e0fd345637e8e0cb18c4ae6dd1061371328c52b1243f80e949c444a63ba5761a8afe2977ec36594747496e8fef731c433c3eeb1d0d4fcc9fdf6b11859b24e1a25930c61d914d4faba54e98d5ed4fa360a3d63e77d8aa7829e273a89c921b8aed9487bb9631e24bb547289d42e9521f2525d787d157d6f87f49345f26d501e97472c6e0d1eab884ca5d0a58fd4dbf8f3918233d097deff66b59aafda223d13c89e77d3a2ef63da73678d9de076508298328aa1c0f6c8bbaeae0dcca05c424cec1a375b4140a5c3e1a600280a39219be2449bdc19889004b31d38a7abb8d11953520f59b045ae700a7da6a498aed89686f7e93aead269de6e7c31b9abd054b762f40cb42cda90661a5b4a99290828a69def47260d649b6b29dd69b987a21275aada3f4c3616e554ad56832442805a962a68854d48274f4a9379ea14136e4c3e8b34d6377e003f991b3b73e4954f2920b0a5cbaf78b2852ccc7d6f7bc11981e052475c585592380b8d49ed07aad0b6b4f3aee88367545be5f15a2636cf5a225089fc7fc859ff7d41bfda5379385a2293bc6a1e9bc464b9b2a059484323829b897417ddd929969b47ad0a1ddf0339df0f15388d7c1e88a801cce4e69b09988e7b99428bbb2bc51bb64ddf4f022d57f4feb932ef720745e33c403818245b4f786ec3445ff9b020a71299336c04ddadb0b968f1081b6981a7b05a70276f8a3e2475ec520972156ecb28d02b08c266e1ea436434c9b06eb243fd122bf46219028429b3c013b9b6746ab970370f957df6fd2f64f4edc25d7a53f220339b5337a1c145c448f46f9d2f638b9a1288abfe40a3ca171740f87c1da80fc6349a5cb97f64094a383086c0dcae24701e8b0e17ccc5c07accae4233dad06aa3f31c706e046b7e50e7e9012e270c941886884026fa8dd0cb94b8dfd96a9bb854b39853bb78b30b30d209e810e5f256e703a6a041dee10f28cc625cc31ed8dc3520c2f8593c4632196fd7a2a8d9a0739414c4692c11b771f94e059c92aab39bd05bd24ec8189dccbd68b43e246ae26b2169b03bf141a60d200e280b6e6826703a008e9eddaebb7c5c3e5aa63cd390c8884e9e5f203755dec2f9bcaf695e54d5990806af7b6795acc3450fbb5534e322068ed64018e2f83ed9ef25705b193f2eb28fc91190b3c4685e17053dbe12eaaad9e4b683e9e35b32dfa544f1e87e301a1c4a6a5519be059303174506af9813a142da9596c9f9be4025a77ffb80d9de20e5db07286065345dd331684fa9dc4c352704695315322e616356d685f5aa05b043aefcd8882a949190870984a2a0ac1711d1f32bbe380a5169c09fdb553805cb7839203d0e961b5c3b6712d736b0178dc0c8fdc3604458418ef59a1495ec17edbdb0fd93e482a505b98e645884c80cfccaa2ebcc151a4a59593d76476620572e0288eda5954c755846875d40ac7c68114296488107a4231b80358a59fa70b383f0d36f684a5119885bea4c36415da8f7e8e4b551d995b449472234e3e14f58c2e75bbb060e558b7014abdce08fc5bc86dd8d83d18df260375ab882fcb42866eaec9ad651cf204ef9790048beef049781281b24a0b6aa0af03f183259e16a4ae993d60d471ad0220cf65220df03161ea5d63150ac17e5828c4130603d662d2b7bca17cfeb7cb85913df739cc507e3edafa0525d79d0c432ee0611f908d7bbc0a4774701c159ccad6177486e090f8e1c26c2432b74dd77c9109bf448dc2b1a4d2594d3f90b5260b1f31bda13e67ff72b008d1c7b5813333008eabc0ab8e65b7943d79827b130f38fa6b3560131e08352224285d60ad88cf75986348845da5b733b53b4f6b2a722259df684eb8a197029e92f568a2328bff318b4f6bac434abf55c42b357f0955d4e879607e48cb80849dc3cee84f722fe6daedbfd4cc20cbaa08904212285acc9f76b2f9955511db465e06dd0a82d9052fdd53da7c962ca46052153222a0d7e8f7a82fd0cba40458bd8105b97c4fd3bd2728d0b0797559fcbe18279dab5b9a541ae2423f23e971d0fe1d60ef654a3b512932aa0ea8e369d8240358f3d177e410c37ec8b918b4a7e97a243b382ba64e96924e571117f7458b358242b6795f0afb0fa388445fe239e16cf02d1be3e6df042448478e1bc457769af7e9705c560038c239c0132892f0e270e30408e3f8ff30388a864794d9f1d8511e9940a802a88ad15716c87d127116145711ef66089106924c820dc365d58b73e8832248a65ade3ea71a224bf922885053a7b8371eee4c3988b55d516e545bc6e16468f800f27808423fd5291b48db1ea191a76afe23448a6af1277c06994c93b41354182680169c2843ab568f9ce0718fe09d05f3aa1f9b51aeb41cfa0c61be9935ed6841a1da7d44b15439934f91c5c412857b17b4fa0c89dd026c15ae385ea91c9a906505e3acc355dda2e9ea456de8a793d5f3299d80a9230f0ce2c4874d849c8041603445b9e26aed63592e7b51d4bdd4c88c9c39a7cdf40ac46fd4b48daba5523e440b8a4a44147ebe6666fb573dbf1b2359bcc94fbb656bdd1871efcf0d343a5a1cb3f4c545905919fb0e9da13a75a97a7cbe996b30fe5562190c095150871da3088bdfb3b235daf2378c3f1a6df731d7fc8875257a1b79fda8859abab929b323932b3e8059187c810170466ec1a012018f5c16fff5837e1e203cb1a110f85a23d09b23acc203f0818b7cb9b082fa1bd61446f68b5e03d58a54e2bd96a32437b3e817b459c661966891ada83fc2aac6da067c268ad1b58a88c1fa290553f059d3c30638956901de9d54485f5269b10befd432eec6d1a1ab0cc8a15b2453f2562c781526acde7801927b34893f06373533b7d45e6b48c4ba67d09900efee3e23162e238ac260bae8ef40a22b255264c0c3f21ede8b771d884692692e93f0ef41656946de9c9c48df1125a902fedfe302622fdfd23eed8633a1ab3c00a2b65b20fc67d2b913327b3a62b8912564d3781ccfc83713331dd27e782955322330f1ffb9859f8806e76ddde7021ad993051d9d6bd4eec18a7b4644e566a86d4d83864c2c426920dcd9c8895879b326902b2a14d5362e25053a64c2083ffb9b8d56f80b492721ce0ca09e3b13a3efedb415726ac3181ccff810dd5bb28d7e79890af32c6245a2eb3e2976034bd4e6f084d2f5aa0fd257493ff6cedd36c84b4087cd42bdbc44ba029a51dca82990a4767203b454a90ebefba85dbba68e356900edff736e47094354ea2855b898c9edc0ecc225bbb48fd7ee7896122cca36eb0bf3d850d82dae5665cfa9314c8b435b858f38556080139d75cf5da329d6345f4f12ae567c09dfa7213c130a08a4e90d4aa3b149384fed197e3e9477129567cc28f4a3847701d85cefb443f7718209ef39de54064c203cc2e07a9e31d01a934a57080af926fee6e5d37fe1ea521f6c674e5c8b44ed060246968eec115a0bb88e0098dd38be8e0d2a7832ba10eae4b325cf893e13232ffb06dae919aa1bae8d0d1f0b221c40a6ee862a2cb5e4d0714bcfb4a90fa3f3be27e64e92fdd64562c1caf3a87e0e96db1888000949f57014c69543bc7f05861d99cfe52db502d7b1af734c23b289c6182b2422d007b8195c932001c6c3fef3b1b3864f2067bf37cf8579a0c28466851c129e684437b6a7ef03cf06843c5d3cd0fe73ce5b215f54e373ffcb424e03654e12654f6e8fc1f49d92fa264323626bcfaae27342a64a33d4f09e32ed5a62cc85f0aa4c846381b297093222f4d1220fb4f64465e0ca7dcac093f3eaed7c36a7d09d4cc832dc5c15084cae1b96644ed951f18fb6d95930056e34cf3a2ca5b6ed0f6809c9da8b29517da5f008e020bb6ccd9799773b5999cd49eb715def6ec2eac642b4adc5eb185e9adf196977edbbd1331e867a8ce6dcc46cbd39d08edf85e80a3a967fb6a701457642b3b6f5be1855987f1396e9991d913a99868f6a55c23cb36fa9191101754a98a8e72a9f9e4a4cab429fd3a2771ec26d668590e339a39c94d7c687f245174db142e813901572587117075de0f83632315b37d0bf7dd455e649e9be53cf49c7cbecd459dc72821124a79601cc008aab5fec97a88375dfb7681a5aa4fb89d8bc40096e803c76a7ed9b7662c06a3f1327fd75d9dbf0a4f79729b0362ceca7466814a4fe0a9484d16b1b6acfa8cb5ace96f5aaa7f7cca31322ead83cfec42ce1205249bb845c14f9e1b7208f9c389a323aa820a8fe11c95a6a7d5bb5d4e35a7b190a4893578512ea3bed8484ba220a610d20c59aa5dd4c2b01dc5933a08e4bd6993e19922d8c509293b355736992042b58528d3280039fc0c3069eca6881234248338b9553a350df75c7f3956501c5cc0dca0c3f662ca6d9e0cce59f58b491c1aa71572702580c50698b7895da5a3e135e2d7a423024aaf7ca9fa1490b24cddc0e507b86167f263e5cf811e1b086eee70a1da8813507b5a0842b5e38a8fce326bd784108ed6a15f8eb5454850ee1d5a255d5cefb00b5e7a72234919859216dcbf7764b37cf55a32db7f6a6231a9b4c02b7d9478d263aa4ddbec17be80ae16f8bebf5f897e9658d4d7debff96542c658de7725754c5823eb134829f9c0da5cbb9d2c2f7d5f80e06ea244ccb5a3bb789963589fa5bc947dea01e293b509473be1dfe3cd60277f28ed50a59ba77c0c297a28d9e84629d64c80e9b7cd8dac03b02ac31f44477532884c09b00be7de1b71ac0d2c33c2461bcfa848d4983c833663d383393c590b80e9c8d9a95853ab5783c55c9c8c4afafba0347a7d192498e7b38829ddf3b8af967fee0023afbed51f7a5c73008cb8185dd3351a53b62bbd62fc74b02948005829938a905225c98302e795aefd0c2160bd7d113181824a3b8bb4ca79a17108c11faf4be4bcc4963b6b280f107787126fe5ce523a487019daceda0ac19d0a6a982247e0668f07955033fd80f668381a07443e6d854dc63156722aa9d71c9a90824dad985af379e78812b7e0451f161351403e74ad4bf00067c7cb433478e438e06779f3d7a1e4a8d69c1c63c0590bf4ca3e18b9841e8ae086ba00822f9478139895d6ed92e9e2a905b7d2daad989f46def36eeb5a37e2eec5899755eed980d75a2fbf5a1ec6e20b64fffe8681d999cda81e790dd0650bbaebe074bb9e78dd9ed1d4f7ed8e078e4ea2cf3f5cb501ee9b49cce98601063ceab24b4883d670fd72f301ba80ed73332f0edfd2390ff702226192f95a702cd767276ff17a11b87a79bfc81bfca5d02bfbb893eac560d4150bd82989659a32737d06256323d8e61020adc76a3a741101b506a1d501416d1a4abc7b9108bafc12b004f93da056573d9993f7a2822cefcd1034608d60f3be8d22a0a6311121eea938d6e8eda267294070b23e8f64994aafb95edd4708936005ebf2ba4282e2060176d1be11558a6664ac90e4eb923ebd25aee87d0cc9f3a83ff73d935c7e72bb8e794e6025fd5bb33fbcb32b8934164120c8fcb28307face6c2afbdf80ac6a06f640a816ca84a31380a3b138f96debb920689701f19327ae48be359c9b27963eb0f45687fa95f7d888beb4836607bf022c9a71b9d649079a271dd7226be9762643c9730b0cbd1b6d041baa65a447f231f84432ae121000326a32e488a01ce3d051f2d4e8b23e53eb0b4d5cb81712760de61828c35058b8c9ae89eaa85f8293eed0b70104e3e9f0997e4e879232bd392902816b792bf96264f442cf5825da4a24d6cce9a453c8e5188fbf0d508c5d468874c374f7050d8e58726810c81f1ed0062d303d0bc289b5ae7986409d6c586e9331021e874e0afb0e915ab0c8403b0c9e022dd6e974b7b61a60933e2b0c859df4bd48e0839288408cd1e1276550810871c30bd053b50153ff758d83967fd7c1779b9bf0b829c30c98d5c71df838891845b1f4256bc45c2268a33e40408df62df428d7800e4dd0bb0ebe1bdb84c7471986c0549cc2c0e7580fa422decd6a2ff549fb350766b16e063da049a96209dec7134ac46add0c501a430358fbcc7ba82496ad61553a5c3639bc3560d734fb13f0eba8a6f1159dad44f5ecbc6e0501422e8c18c223d80514bdf5e29b1734313cbff05a0820bf9bd124602d479094885b834e18772341028abb2d6616a820739c1305d59fc53323b73b7b3887b2da9def9060bde6570e7f40564ff7e598516f3cd75557c0736d25924e958430a0519a643a183d598fa7c50ae46fa34989ea6fc4fd0b0e5e022ea0b7a585b93f871fe91f0181aa7b8dfdf48a7e78dad35508581b5f75b7bf79898aef7b8724b53680afdbcfa692b72daeb800667fdf778c3232151a33c7dceba9e904e33642b15026e027593b26de1663fd3134c53efd07a705a2a277b6d65845bc8df1b1b0c754631ecc3dc1f622c1f19608e17727da8ed45c7ad38259694776dd713bef6ae7fb8296455859cbd49fe76b64e62ecb46dc35b2015882b80bf432c04c5e97ec9183d0e94053ec7ec53a24c887bbf63b4a30f3ac740cca4f0c4edccf83663764d3dde5118177fdccb8fa922b500b99e0dde9e98efb900cf727b1b715094475dd1506f070f3ccbd5330c7839d0bc2b1355c6351ed1a4b80b8b4fd662f1abe4677a0d39a82504afd79087554074b98613db55a5161c4825d19e5a173b9486a4fe9722201f8ac91b2deb558a83d1560740d10cb71fe45cbb125f1536f657daab26c995ac93ecd5623d0c49c6c29417475c8b7d7da8a49de1ef82e5c50aa85e92e9fa25bd3b59490ec1f182f90220e6c9d3dda03e676f26ef384c027078964f11b3acb9edf188734ab8cdc889bf71abc4041a7fc64e733951f06b49b551777b7f481df974784aced2540054d8bc14ddd38b8a593657a1390701e14b6178848346e0d2431e3b9f0b83b51e02d49bb82aa8d0907e71362838655a8d1c0b798a4fd0858ed8623f4cc7847f758be0bd1a894b489a54176f34af19786657be77fde0a0f66e970f0ab6c323ed33b9a2bd58d8768f535aa686c97b5bd12db1acc955066e47cdbb8b0ee0ffc4b78cf4e1104824ce3ededa5e168f6f0275c41120fe2aa41c4d56795225e82e18437c9f2464bafda3a7acf8825ee5eaf8346b494ff932c0dbfa1873afcaaf0be3f2d304ae5ac84ac7fda4baf5d3cdd94c9fcec4ea83d1ad99600b89ba928719117223081699196c1f058f0e2f458a9bdc172edcc8d6d833ebc5cf929a0ed3937dab80888a2e19ad5d2c6dfac4d842a8fb5515d4e7e278ea572729b1d75d2b8cbe65bd5d20ca72c5e70116d4a919b0c42458a8d1c5c0db95c7147343cd1ce75ae1cf0ddda17484995281ef575a06558fcbcd8f8955b78cedf8f3ad053482da3ca8a8c4268c6388b257d160cad4bb8634a3be743f3403e6b797014b9327ccc02d405f9a2472dc05830a1471a264ea008c968296e2da4bc80fc303462614614dcfcbcd71ac0a1af1cfc79bc233a4ae3c15691501abdc18440c409000d811e89caaf57c4734b1cda101535ae6a08390cc2aa778a44403e75b276fba8b20949531fa481ff8a7176f0e4a8b527acebd2ebc2af8a935aeab85e3b27cbb2643d4aa8d5cf052add460e5d0d50248abd0a309f0bdf883f843ef7e7219a968e64f9d6f7b8cf3334acd044c63a5316e1d0ea89e1ea13c6c0faaefe7c03c4853750c8bf591e6448a6a3dd0734e7ea2652b0b321d516cc98fe5a042bf754a5d6ed54e28ef1de1e6588cc280b1760dfa4b92d322d025f4c6c0f7a1800b8c9a31a8dbf9dc732d59a5caedf273963ca7f5b83ed9bbc38fff45702159e04ad5a41d9980b3d6cfa40f4e6e73096b17843d47887dfdfa867cc0899b16f57b5dc173d407072095ba490be9601d19560e025affd6c3fd7c72b888ae28a0ec089ea787cf622e4038bfc30c9e3b14430b77d3f9e2e9955c9fc53bec34e6b2a7fd9b6ec69a7437cbd112e3a8c52e5115aa5dfe206b53b0407521bc8c62b86fca04e4960f144d7f2f24972c019d6a001e8f5f0884b4f3ea124aab54cbdc12d6d0e7fbe953293a6c1359f3d2593f794c3a2898ed250cacea02ec41ecf08312b999794fafba93070a0883a7b1524cc59fba3bb85a02942bd2e0d4160f1686b98815f8b96ffccd2b406f581661b70e921a0a2ac80c15ff39c9f133aa0204cec49142024cb765397103bf1f92989af2d67116e133ea8a8e86bd323b5c256584661fe1f366d40e3aa20be536254ce39ae4e65f812459779a91ea84a1dc9f0d58533d205820462ad75f484d43151de8b765bb8fb060fd183739f834c8aa4387e483075a3c89f4d8fce0e7a163d0f7bcc9b276611b57122ade7f5a03916a861be49a04068093a094e11deeb2fa00b21795218eb897cf0e59b555f738c92299d7146995ea78b274a69353f632d5c31c39e4cdbdf79a91761bdf08305938617d5efc49f755aa0e6b5c6bf3223c9f9058b33fdf2a88479e96428419e484bfd46a8a741f31cfc7d4d521c11a9a1c680b1bff22b306173095c6d3224274dd22db0e4fd467f9990fff220b758e21b4f406f9acb6eac1c993250de2d35cda3156d71ebb25ef04476e3e0cbea9882590744c3be8cca0ba5146fbe7f3dcef9d7a74ecb14884158704ed2aeff71871939e9874a5c6606af1f80cf558c1857dc4855de7460d4511126c922215c3e742340b31d1b5c3b75c848a71d71e6f411274e3b1e0bbc306801ccafa0c24e30aeeff05bbf99de67a47cb6f9dd2a471819902dbbe4e13f2b700ec818e7d5cfdfb759c0909b0ffb1105e3475cc00d382ed67a2a9321e5eda935e9960ccbc2da161f65fcc009e8efd76dda3fb759ce9ca624b9a51bc1d25470eaec57cd68bdc9e40406221871d87eefc7e074c5b064de1f97a7f874603671b74156e2e9e2b8416234bfabb8b9b1498df26dda1995549ecaa2d6b47e406daf69f5c8824bd11d2bb6581f3f7012b74ee68ea0624c3ef044597e1bbc7bfd047c087376b1bb49a575e6b4ed52531f1ef9d8671e77c8c6f500a0365ddf2ec8f8e58d0177d8d8a52832298678e6f27781d35a3c4fd4c87eb124863e8f644a01a630ffcd5c45a137d57a14fe3a1e2f87d2f10cec055a5753c351b3355520821ae8e90144e65b3d4410b5046da3d54800aed416770de131bea0df5d0e6fa1abac86944d5bcef9a9061f5dc82757e998fdefb399ec5584834dfc4ba4f47db06991bd1c7ea8452443fbd12c9c65979f66093a5ccbe708e1a5498a1722619a93cca0004c355b70edb15d1f5b3a601aa6b8d647cdb147a034da108e24448ff708a5d34b979327258edeeadead7b2edc619199863ed14db7b5b4a7a54adb74f45a1988762a2e1098d81277134d7bae71e526b5473ed7a8729ddb5d0ea3d3a20a57b13c4825aa64ca96e0909c2384d7b0f30fb3de700afb1887675accb6e401711fba90632520fb680e5f28c518b2784dda01017dc01475a245e3560d324047758ea20dadcbe1fa590b641d3051697069985b00ac1cf8a5c1ff7ac920093ab8606e52264cbf63d7e8c034e32699455cf8d1a2ba5a7f80f77c3795940d8de31759c66af7c333103b7fce6182eabd3fe7f051c0a515c513bc87a5ab8b292a6d7b350eabaae8b4584e6d1dc67d85f9bc0c6e912f69209ecf93291272b659e2069d0354c36d4b744bf9d744e05aa98d94d40ef903cf4a33e4751b66cc238a9fba76e1bf2b136819a3be28e6fc16d8293d73b75ddc691a393f7793154d550d2ef70c8c99cf9de43c1fb58b1770835e819d8c590f9c34995e818d4734319dee4a18cbc9a4372002663e275d4283733c6ad80f69361f768fbd9cd1805e454074d487ebd9e398116f14f22810f94f826c01b903e9b463ae9d050e2a6cc801c4ef9e3d7afa8d174f172e44914d8208699d85f0fd77efdf3d7b849e922f52f24d5238bfa59e9be8e411b3cd0ed770f34fa8ee9d7e318632d1761fc03287710e6f86415989ed8e6857b82f81597b2917434d1a72f0423ce20afd758085b152d02e07aba0998e7c9a75993e3701319e70ba52ee49d07e65bb3491c9eb96cd1247779441ad1284a30be8b7a162188d97628898a318ad09485f419f44a2119d7aa6bb5c63b4885cfc65dc284474847c8954964f07f8db960545d6ed93fe8aa96dec8cdbb208c8963dce210dffa58f45a63923feef227c4f48659b27a2452ca04573f369efc7cfaa39e90f7bbc926617be5839d9aec0b85b0765f527ffa39deb652860e5a4a53ab64d6cee1dfd345a0cf0f7f7a54a120d6e3278d78ee1145c456ec76d58f454525baea32bcf14952008939d338160179510ef2ed0324525a2470f499733857cbb5132c3bede02842e5b5347186e8f5b13c3aee74af83818643eb4c23e7f10ee10696b90a07df12444af27d75765c52dfe9211869af2c1dbf0ad9bd768a31c9c3fcdbcc3c39d54a0b24408969c8ba15bc31398af27180bfdd0e47009e8a1a553623bf67d2f281a428e1ee9a70fbb98cbf234b4a0814be188d57bdf432380d3a6a6b1a800cda084184ef999d3843bd8fe96f4ccd7042670597696c382cdffff90137bd36d7bf6cef744ac335c5dd75ccc5250a954a1b600200a758f655bcfca7ca6a2448c340b242dddfbcc5b02ac6c7b62280067d49712319607c255c78b4466610e790eea16ebaf9765fa21c5a198e64260112c05ba9382fcb9573bf730504a0b59cc16f914fb8c640d9009bc94dd1128b260184970ad6d20af4476c883a557250abef836ea1a5820ff10456a84b29c24ca66aecb31dabc89b2d98c4dd50cc571101795fbe9677c2eadbe349b1fd22ad5ba6e6490e96934886376c79567291ccc13c10020c25811ea15691655a0417566a5c163dc6c60336e6cb08ca53e903ee50bf82edd7d5508169b2cc2fb2d9e9e79504455bce4ffa821b3bfa8c1f31faba1f9dfc81875f7b2f2f97fee01ef3f56f6e85c3cb428310494dea4454f03a1f182da2387a597878ae59f070b0b640f124be61e2d7b6459dac9288f438ab90b7f22cd750f74209e10d773bc2495909d36a13d4d4b6a3d5f96f83d9096a87b722d757b542efdf670a1aacfbc40b7f724b207ed9b0edaece34e7d1c4d651552af72881d9803e3f30b266654b461d6259f36125db2a50da697d4b561f8259f3652a5b6db06d3efbd6d24452f97b4ff27e13243ef683da48c43c1cc9b64b5a176d97da9fb86f02816b329924411489c501812d3a8ad606d0146113ecb42bc8b919cbaddae0c66948909a629a246d0683b65dda31d4605f79413619c505c757c809ac4c98c7780d25b9b032f0e313789efa0a4d4e017b329524018d15b9be4dedc4edbd35e8e6568bd34cb99bd4dcbcabd3f9699bd302e137b732c37f56a2c7ff6722c43eea558ceecede84e60ef233ae2c732a8f6c9f92658b9894c8f9099a9b60eeeb0c336dc80f19d7d5f01ff46d5f07393d53373b7ab2b717fa933e5865227e6ce566fcaad56ffc4cdaa0e999ba49e39775b5d99fb4b9d393794c7666ece708a19db4b663659197d7765ccb0571031c520420edda58622d7dec7e859ee4324e8dd874dd0741f3a41cb3edc04cdfb3009baefc32668dd8749d07a1f2641eb3ecc04adfb30095aedc32468dd8771da6509320ea2b50a79f4e6ce337e5499f81713949d4e2aa5969b2ed1e457350cb309e37bf76a8b26acd7e08d4250436914111a5a5020d44082e252c352148e1a84a2286888124553031214c41aaea258d4e08242b0861214911a5aa240d440f2e4510d5ae2ee01b89ff6b6d23e1967470a5b710389bd8a5da7bd22d105c84b6852c3703faab5d09075c08e60a65707108e6cf751226990044e47cae72df795af1f7e3ea1c14bb32978fb2d28a18b0c6a47d24407e86db92a3f3655e1bd88594e436c355481d09f19fba94f2da6039ececa6a2ba1db369304359350a72516ec7cecded51b1f4064ba791aa75bffc0da11fee13708c8b8fe9057483cee7b22cba86e228915ebb46bd2143a590672c82bf340cb89463f793628d9af50fcb3ccf3a6f0b8bada356f807fbe0afeba3c173428774d5b014a5a52d0ba091adaf7b38b308133229f6ab544fb40af14949c3dba11da660d92e10782c84df32ecab758743b1629114645abbf4998a1d0126ffcc3a1d0a04dc094fc10e31d7d7de0fc53c855d810ac644a513cfedad39bb61fa8218009f4549a1f1920122cb3b891ded681030a6e5060c54291c8a20af0068ff9f402097710e4155177efdb30b243496212cd5878d58650fef871238488f6cbdd69070db7f4f8a6dfe1baeea6ecd48060088d15101c0f9d5c2b175389f6f2d540243d884f0d4c47e0373273a72034ec36ae693fb5837a6a3bc959b85c6f026966187a10da300f610d99c0c3e17fb340959320be4a683ed3b530f8496ba55a0a18c527dbd8f347bb0e23647156a450f3431d6b8d4bde9ad9c55d0004012cc62418eb10e39509e6f77f6afa0c86d96fa2c3c27523d82fc5c040b2cf6a34bc06d9c26513a23dd1771a42dacab4a0c038d99f61c00b575eaa0ec8dbe42a773942d82a923816423a58af41b65d0d9528b05dd75c7540561e1611825c33ea0179594483e07d108218e109a7d31460277728bfb887a89155ea5ab6e5ba8f8a83c5a70a6d376ef4bb60dbe55bd971c4df31b61d48189dfdcb5870631e3257e67b5248517ace70b1e4b42253518224f0a8558b7719c4c91b9f837b10637c4cae21c6f8807fee5fb803fa7bfffed9aff4fb7dfddd5fe8f75efcbfdff41f066e8a505cb01b44e6242e3fd2aa67ce67fb8262fc0fd4ca1be1a153cc366ad50a9a5bf58296ab5ed0ecaaf7bfbdeaf5632ad5c303e73572c07558b9880016a73859ad0daa24dc943d1d3b0730078a86e85d311e69d769b1a321ed96873ac9775ba1240f040c27744670d94e8209d3049053f4c9a2850a4137916854b56a84aca506bca0d115e44185048d4dfb3b3d445ff8ba469a36cdbea834cb51a259105e39b72c1132aa7dcc519557243af3b5427e3df49070421cc0fb86d0a65a0059a4a4bfb360f8f49aea084dd5ca39254d8d255aa69a030bf3321dc609fb0966247802d67e10b5461567ff8980bfc97c831d6aad5181183f71c0ed3381b7e2d0b461b383b07dba7e8d2bc92670f843ef8d20f3bd74163e3aebd215d8c890036988238459bfc3263b6c3b889aac2a461f0b643f3cdbb402773be3f5a879120d2393a1c06c8b5a8ff8884d14206f8bb414c7f7bb5b3cf29f8472ec94409bb3e3083f64efc0f9e6d220114a6a02770391b31b86f320afa6d3d819bc6660a35281fc9d170d061a10796ad6000a8c8963684011c2a4395464856a656eef0193c3b662709eeed769bd3e60741b0ec67a837b4feb9f8017f097510e63f42b76fb0a96e306affe1b5299b0e38f9683ff51bd6f4144f551c2889b1838dc22db9a3b1a742e75ee1500231fd565b5adb1efc7afc6600cabdf84713377be876af28f2ccdf3cc6ef971b3ad034709c6ff8b30f1ff76bfc6b81541088d6f53d1f24d25a98f339704038d51be8c4e0ec2745057192a9c444530b38ba8d57ce150d15774a8c0654cf19debe0aaa829a6a8427bbea12b4f1a25b2c63a94b5fe5c9429ec51a617e22b3c2305c05f5104ad034746582c42dccdd1ac5d6ce523a2b383d4e98a83ec19aecd590f1c6097064cf7f0a8bf08d1f78e55b0fa5250c99ea43407d706431cb42248e4122686fc1f674860fd0765139f1526f451b415653c9dc1d2cd5f9fabb4bf2a0d44aea6bf4efd13f89726d653f60e3bfde2c92a1b871196f7f997e85a93fe8ec948d494be0597f2c6a873f780c8ef3c8238380acb747b462003e6463410a1fca9ca27503af986504a7365ea451c3588a5f7fa23c4199a0b1e6661587d821320eb323998176026156a3a0dd04495acf90425724b9c67f441b9413a1b02d145921929d5054711fe604cca4fa26084ead2912aecc4c16a261fabad8747859d19451036ae8d8be5fa1f479d40051d1144f6be80826c7846648a34df0af6f61674cb0d56adce67d8eff71f9ffa18e951bbdf9dfe66d671a0aec902c08e8fe2297c8edf6b823ef1010f7f71a44f2318612539b58ac033df658c0fc3b2747cac106a417305a37baff069cafe733c1a19067707713a6d543abadbed259b5f74247702e053801dca07add35e77ed4f4491c5624ad0abdc05c4d8641e84ef293327c875ab65653d8c81443a571f8e5f74e5a2f240996c441eb6567d64349392e7bfd5e513453d76eee12ea57dda92c2bb35c99f8f44a18ffe04e5aa8be4fa10d8558738bfb1ad28bc5c357cedb7e067861f186dbbb3a245960965927901f5c23f9004a2e27005ecb7c3b9352d4cb0c0b4d2d630d8e32371a64377dbd2af7900d45ecc30950e2643c76ccdb546daec8e6223e2bc9bf8b5425b0a2d24ad75e055472234cb101a81e7180dead1278b1e09abf3c7355aa4d5c0d16e97e81a711646c6975c6c3efbe6e8687a5a20304037f3e9cebda2d2978bd3028f7bcaa1d09e3889a49472e7655bd50428c67731fd43fc2443e0fe4063a48b880b9b75015dc58455fbeb2f81ba2923730cea811425dbd4dff6cb20e76c33e8e4f528506721fffde6ba9dad16a32d3949b4ef1930f8bedc94df49b7c002e4285cc5c8124656ef9021ebe6b9018aa1a7481daef874c19e7d710e52d1640a4809b3490562c75feba6ead42d17c6d2e1fef5aaff8b7d012ca1aa424838d4280e5052d2ff93cc1a20b2394cc889305e324ce2b5c643a06051cc679cbfd0811e503197350f38ded07eadd56cbcc0f9d222a21f14be5741b8ec479bd388ccc517c4d42908d3c398cf37b2ac243a6c78ade57ea7730c51b30273e2e5e637363ec74567635c6056609a3c6b59eecbede479deecd0b2a7a4655f73e3569f2ed324eba9e1ff1520a2b4905af6c0af514daab6ac69232e5637be5091385079cdc2248c063ca1b985149239f1433b06081381f11b81b3a968d90775d6f3e55442a4b8f3f3184fd181e4e6762f0afde111dd22080814703b1e8886fffda8de78dbd5eeba706bb1ed45803c233e05121f04a613dcac7ba7ee2b34ac59a2ca9f439ff06f7fd158f84f8d508a3d4aaca7505c7bd07b54ecaee5bc708619bfaa0ed09709df31c6c4f21310f11bdb3f2bb89df2ba91ee7f7d425116290b19ef5cc3cdf56404b46951c0c8874c678b38986c88b2fb6b2973c13a57269323f5ec79f876612d4b58fb91c44586ac06cedbf7ae14b67fb009cdb3c5318fb90adfbd6c6c48765b0b774cb05656b1ec65762fb6d728b2aad69ad00bc8a0f692348357eb87530467343bffeb1284262a3fb3dff9a8b075fada0b76e05065b0307f14a765f79af62ea7ddb916e23d76c7dee007dca04eb8d8187516c2ffe7f505d3f5abefb8b68c124288937dadb9930f77d395be797c2a4a7e60ab9aced9cc3d4976c77f1682e847b27571f284d8f3a514482b3f37b000b07950c45955f900f31d95c937b99bab8ca47d1e7c83b0bc459f11a19f74fe2c695e72bc8ea395cedac4b38abd2ff977eaf906c0c43eeae22a93032a7870d01e19bfafae85ffa9a0f3e069bc0374bbbe968176173b38e4c5383a35d80e4e863500e21905f53875dd4d78a0a5167e30fe1b87d34b058bcc55e4e22c83fe4f84cac685c81efa79ecae4a310b5946793fd85ad07c983daf78b0522b20105b88e251a85dc8a7348328f4ee44775e3e901eba5928c2e4a900c02be691f12fc17f014a3020f68370e63c242f120f822210281406693e1e897e47446785755bc4c3899b5f5220fb96a21742b45ff1c207c99369b21494b365a757307b070a11cbf3123ecb1bbb242996e907319e05e397b96caa6efbb7658ba41e4135c5f9962f7e0422be3ebe65e6d6cf69234bc15fa008f0780137fab22d3b01f08091f96e154e218c8c7c25fecf1851bcaa7a87a93572ee23fd5c07eb0bee3eb4243ec8d5d3fcfa0ac38931664682b7506be24d5f7927abb13d5220ada0198536889fa4369e97f1b60dea267dc127b17238b89b29de63cf74d19bdeab661fc9728796dd58b981f0f37a98124019be0afeea881ce2a58da5780f662531b30dd0e44035eff384e77c3c53d7204712b82224b5cd96cd69c6e05b61f8a8421f006741af436c36b573e0c32d62067db26a0edbd89616698bd4a2d7a8626f15dc670aaf110701e6f24d03d90aac01b7ee0ce42f957f7fc73b9c40d290d5dc885a1e1b911b9211398e8be81a3454f1994a26a89ea276f884bba7e8290b0bdf5ceff1eb39e70b749210340053aed762ececa2763938c8e3e1624aa79e9a388a5078631b4bf7b1d71b7ff492b03879d24f7d4efe48aced9423421656f270c5dc9b4587fce4a1197487ab5b92b7eb079cdbde043c6b60ce5c3480b4168ea0b335c2e32aebd5c4adfa95ccdb8796f854e097f0abeb4cd2a85d0be6ce5463bb14de77c2eb2d30cc17ea507d6a066e8727d2133c62a286376bbfeb5be8f6d4fe8adc44371685ebf9d843edde3cadb992ad9eae20272ec18fff90f44a602c13a64218756e0affc3ec8919d70f11b86eecadd3e481b5334de453a4ed9ba318a7df66a3366e18e16ffc6386452e0f1cfbe6f61e41b5b6423fb1cd40ae5a884dd68c2e396fc5041cc957f4827e8b796268b7c97c25f80ba7c6f8eb8906c240a52162402c6669a62f6953c77525d241e13a0cfc42e8e9107cddd492b08a452e9845a16eaaa942df3428150915e8e62a0dca2a6af6b7cb3cf2fee2a267cb831de31f1357f1ca9263a3cd0c05c87264e20f192dd59412abdff08bd5bfe8dad4ab0674a81cb631a1a202309ffcee12bd58ed3ab9c01585c3b20eb9aed7ebebae70c6326ed8eb19c1b05d48de221504784f30282bfb3a52e7d0c0ca25601abf79eabe090855f26880bc8b7f1d77c6514ac1f09ab2d29321de96c570d726f6467cde180f895ec3c2fbeae36680c66c08d053d7816d484578de03d64c22457b53b8cfbfa40fab9ad1cfd93a8343d7db99529b5cece2e0853bc7f0c20f348797e8f3bb208f2949e64bd788c9626880e8de2e21d092e906cf31e2bf756d33f27d8cbbf2a0a06916ccac5118b3cf9a15dc265f61f874637a17b3f026abb91651d02e2f74be731cc86d4d32e174bf2bbd84c31a6ae5d3f7e9a129d24422e2b61611f852a505706abe7f21893fd5bfb0c0f606260a06871796246bff54b9b1fb4bf57cfc8cd6d72ff3bf9b31471c84c1a51be4774e5c0a17911e8c35a3f4d281a061e94bb5a75df2b9e1f0f21b6bcb0b38a37a3ef32e549b74181e32230c950bb842061fcd8f6ece4b4178ff27b8b8c17da1eb987ac6c1ac84bb41afa445190652c6d8e21457b8677813399d59d40c9d5e4038edd0eb97992cfd3607ec75d1b5b2ff97ae76d93a041a598b9b42ae5e2a840a72058ab80e854af4e2ecdda6387520473db9c345ba22eaa93d33d6991ffbfc996ee939d17cde47d2d4b73b4d10ad6dc0762b0b626a8a411358f362e89a942c7a8b466cc21770b5061bcf26faa3811df30592b8194850377900d4da4dba5196c6eccab2cb091bf4551eca27df5afccb0a955b5f43ae71df731ec3b02c93ab27a000c7304cb3011bdf2db43bf375f1910d58b6c44e270423b5e480160b8301e05b28c0e2404d403636e0114aef7181ca5dbf17a0e274f34609e59fb6b023a50b969862209d4a0e0d1021305ecb60a13fbb58ce2f81306dd7ab2181409975458129d875694ae7a13c1a35495fc76647f80b310acbb78c4ede3c2812947472f011606919b6ba04dec376b3e734a07b506804377c7ea4f6120c7d851690fbd561c01ae76b8b79e1935c122910b263ec61be06c75bc2c7f611ec1508971615c22641ef0e0e3ae003ddd25a4ccfed87b82815fae19da3573c813479c6997212fe2b215be94be2921a73dec66bb97f25b92510bffa04c25a85bae883704c91cbc82ab3fccda12732d94a36b29823ca4746affa834bc7be26afc809abeb9269b5493fa9e9fd27794d1711a85adc3a93871591dac2ce4cc39a8332dab7290bd7423cbb63678dcf2dd2ecc72f243ec9489834080d2c2ee06f4ea5c20d69b9afee922fe2ef3e4c99e80fa54785d4d32990bee9051f460fe02dda20af7b70bfca7a1e3c1b5c42d2e509961a102745eacb08e8b3019e79dcc019444bd2042d4cef10f1bbc665ee2164051a4adf0d4a278b97dc50d69d387b4fe0a015a2d8d3b95492bbf54b10400af950c9cc5b7910ebaad51e09a0129f5183660db0f579242e6ab4d0e70e98d0590b427ba1969f05e949c2d28061351bf832e63c134bd2945dadf3e36823faa5f19bcce6b8ddb8af81b643b892594f0a4c35ed9b77383083ee8e06ad155ff61359a939f6dc39ad6af842b56b4304c562089a1e5f2b32d21a8a6cbe96cab661da67ce0baed4719fec895af4179814f0741b893bfdc21d275a4ed8a4d0af98d641ff746396e0d669c92fa6ec5094db8a3b10ac697fe3ab8aac1d4318cfa36a0f56e91f6de0579aee033f77e9a757d7284368ce5e8b374a08540c8bfa08d55ca6fa036d8c30ff3d6d8dda98c2b4e9742c68f1ef89c5935b0b930791aa39bc756cb2139b6114d856d9ac9cfa940abbd0abf6d959b56c169cd211c2b1cc72a89f43fb52b0e728ccb64d4b6b4f42e9d600dc0f8542ec300258f2275afd6c32860ea73f82f1d77504183906a9801372d70f56fc6700295b99a83e4cbfa524045a33896df7015237377d9748a0341e5a5faecbdd0d9f902f429913836eddcbeb276ebebbb1d2223beba63e69fe30298f387d87e1f04755200ac8cbc93529bef2bd80962a25ae865e4bafa033bf29b0924957812c228984c2738812d203f65af8ce20c281e940e9c9f0c6b99c4906ff397173ea1f815790e3a55088e78d3fd82f3f7638e30cde40384373c1e02477d9579bd6de1993560dae29e0b12e0624d3639217ed873c6926b3460688d428fad0aeb687db9fcc3b36af336f75806f920060b7c3c01ed9e76b43a67d31330f578187e684b9a7cb0773178070528f9e1be1f3c36a96f3812050cf491a1e414efda1f46dd1c4da13b7dc1614a627d27366d30dfc5e01a52f3212eb208398396a4818d774364bb814be91fd7e27f36f2ed61cbb6f81bae58dfe61a7b19a29978c79f9f1fa23c3da26a9124c81bd8a6e7ee09a5e1f4e6056c1ff6bb2a9131d0e2e5edf6034a59d4dc23beb14d673b55ce77618ad1e91b88a8ce0955291f773ee8be47fca68f44c64612a62db627296d50f74445b47222151142e0235701d166872d863298bad5d9a9bba068a030bedc470fb834cedff4dcca543f36e84515722dd1cdaec754a591e2b2ffe70c334d0c4e12e10f0fe9fbae674b9e743ed0f59d674a45b17c44de1149d4a0078062924580ef266394d70d4f5d436248bd5c5c9156342b9fdf0496988349aea451d356ecc639f8f2322aa0c354933e1aace38c4602b6419d424e27e873cd401f4d74bce890a33e6b831260c899a1be34f709f43f68d58796b80e3fc8d3970d8a29ea3d70353f550561faa2a76315adf09ee7f9414669e1ac9f87261dfdaa4b5ceaef76f9d34f9264711033aaec27ac1e5998e95ba38da9be1f83736f0b9057d0f6477ffff38ab0b9daee2b907688bf35681ab33372cd4431464f335ffd6039d1582957816b91348c0a66623b9422795d797eb7a087edce1b35e0debaa8ab2d53665c8e43880bf0fdeb1a0b38273e5bdfb6c16d52ebcf28db601d146b4bbee54857bec63d10fc2bcb486e7694eeacca8d91307cfbec3935d2d762316c5616d02c1f91553520266aa56949ce2487dd2617ac020d83e9b47f5d677cd0a455a24caaa1244126eee3d6c6ab6d94608dc5d0675658c3861348aac0f46deed4d0e19d1981ecea73f28e2854c62f5f7f5078869f3e18f7e77b2be0843935d50be495e9b5635978c77aade571ee4aac066895332300435e00e79418362cd2cb03f4164a8c1a348b80deec28c1553435e97aeea1a4cd3c0662108b32aeeec32ff109f58914e20c1b742c715e1b50b8b47aee944b64b11a691454887dd9a2316e7f7cdf38d195a2e91aaf97a46fbc29efb5dcbc63c89ffb5143ab8d4b243470a158b07850bf1084295148b422e024817830aa615c8874c208a8537a24385054725d462bfddedb83ccb227cf4b34287970257f545f3d34148e8e6c26fff538458b91ecbfd59229f178a2b395d68da5cf4a30ce4452698f0135306e7d7fcc0348ccaad10b25df686bdc8d131c46309012e115894744663756279538b17891640d460680f95cb89a5ad0434e13905bcf9da7a6fafe672301afef0c3b72d67aedb8ed8f147e68a164c60c4b65906765e564714f0b0d534ee1f1f91da6dfbe05f3109670b76be344f044cc2690898f25de1183e8340e5bd5c2a27a4b585e32b428d90a675a67cf610fe5761228b8e6c029961b36b64a840960ea1c3e9529cb1d6ade5cae23f6bbd671546d28304979c51f7aaac25528ddac359a11f8cd632758f401bfc44fcc19e76ba8832bb11ac80458cd8a6433b88821cbc80374b057dbcf4607d0072504c14434cf61de7feb2515dd597999f9270227dd9d7c9c242e9d5d8436a46d2195accd86d90c28ec236f44864c1363b734f6570ad865fd5edf34f4ffd3e6493b50b84509bff453382097ccf9ada958380befe2966463f86ce83dec5886e8fed484b62352fe2754bb457f411da78891766bcd7832f9eaeac14e4dd693b8c92b34ad0d821e81573b7bbff2205901092429cb9e2d8c841b730abe05b9d32a3f4081928fdab4395960d8a26e70b81d73030ef2a1399f708cc4663780716cc78ab8e56414b0f1139611735caaf157a9f7829f4595c4bcf35fcc61d67507d08f0aca0028e4f508b4b052737bdbf46a0f70a2d9e43d2b24b07dcc6f3052a2470da80d2c50d72204dca81f9246d4034838aeaa262608096de97dfdf00d491f0e8be274f02ca624a3fa3f5fb46af1ea3aa57e5f70ac1d478a4ab7e0f84460013ea1ba3d42517f185f1c7c854681c4218ca810ce011c30d5d205054c58812d1ac946d38671a00b3ff3ed8ad2be3f4f981f8c59712f14b8dcdef20d26d8082b7f139935e9cde131c350ef97b1f3c29f459ac456f6b543bb94b1407cb50d0ae19f0ee428f79935c73999730e15164627a23e8b7fbbc123ecc78bd505090e9a20c2f485f0cb8e074e16edebb753b9c41b74366539b9617f1a0753581eeb44402e93c5cb01ee8215da3f4eabcafc2c639ba18e55f192b29a24f8011a54716beb885ab10a79caa3bb75a690bedad7b9f832fdd5f112d579296fef347fb487e506d2d835fe05988130b3c7ab8058f735360287bee1775848e5400b473d8dee5e5e49e088065727d72673f788ad2d63905209c9c90d5d7970b96494a2733abe136454a48722ed19f392a6caefbe082c109a568ec110cf146020410e6ae3584444cb4d59754ae8b4d22d52c3bf7f2ec907dcda65e4ada081231df4562a7032f2c4d964d10b8a3287c615e89151649e08b97008e464a0867e15286277cb9492b71abf136ff0497ce8808a8c8cbf1e52f8a856dab61e56c1755937951ec7c70dea12eeb5ae848384457212c317d46c942f377f0463b30043b41f0a0f67bb12f4c0807f0c304ea2005dffad0057602fa7c633656d18bf681bda8ae2f7ae73b336c2d034719f0692398353aff7d16ca0671c61d7f5adbc448a1cca51f4de6d571c4751706094f1be1602be5664f6eaa6372071c8ccea8de6a2f06ab83c2273be27727082661878944d76228ea601c1531a01807d7c2f9298f0fa4eb8a4a2f0fa78b91ca7e0a9210dcce16249532a4630746383c072e303df59aa34a019e25af6f2dac4809a77d6f90a29ccfb9f94ca4e3d39473035e61594a49bc296d3ae5b1a804a7323a972a1552b56aa68f12684519f02be794d06c5e9849dd3f5150beac987d80d2572ba1103230c1030ce349618d8519ca772d9921d12a89f2c83103af0fc8b5d189dd90841df9c911ab72d28319cad9b544edabe35886309e107ccc09e96e3284e0c87948b598caa90b022fef9b03726c59b7f23e02bd34ebcc9a185d623f599527957a4846003dda1bbdaba360687323df9d5e9f0a10c911d45c4fb8bdf0e8557fdfb45323174f49bb33036a7046e8deb57e602cf8b890657da8ae5c1cf97c763bfcebb5e62307de5ec47f0a7c307c61702dff064907854ca69a55493da7273bb08222b17eaaee7fda7c0a18644d84505de606da2be649464765d77d111159e96a8c44d66b4d59bf162a1aaecaa8c464fea76cbb117b55a71c378cbdb38edd1e8ca58e00d3c8c97bdd8f12dbf147c13c01a4c9000e26788631d62d3b736036882f57a397a5ee2ebb0a9946b6aaaed0f56182d795941216a947afe632b3848765c00cb0cab8aa3f7797978d3bb54b088a4058bbfbb660377da40625952210c0e8083d1623402060ebdf8dc697ef93118f15190f36c911d9088a78ddb18ef7b6a353d16bfb28952f3df6a520abaf632a00a5115ac909586741495e172c1862cb9af65bd2472be1ad2c5a96093ad05be1d113c4ee6ab50e50d766d3a1021a790b9d20a1b40210d2c9875b8ba95b5b8e1ec3e2bc85d7c5e11ed456d4303b49408a6ed7d5844ddfc2185ed7bba8a265c63e47992ca6fb0e597721f44e1eecc1100b11e6f0b96ea0e4d7a8c35d79e865a32de001606555fe5c25aab513fe434779afb16190168038c20cc496e114c7987343d8adc9976bfb2e689e1e3da4af10f6b6c7f726a9b9abc9339e988169831dbdb1a52af73cf6cc7a83b2f18f6306bcafacb21fa1934c92eeb94f26e9b06b128ceee241f294056a7160f6273c071ad600cf1ad829f164590cd507011264bb0741676e4008d28fece5e0a8f59448e4b35a8b735c1ea2880333f07033d8815bf022e2285b0ca525ce3acac512b4dd1353e1cd97140886b1d48d03a6ca31c2d0b83bf98008c8ddbbd66a6bb192ec0689ed92c93b35f246f69e8e946e6af5e81ce52af6a9c2590a2790e46f6ccf38456a017aca453e93560f09b9981c2e422e2c834864f3545b026987fa5a01d729ba98fe84c0316946fcc4371653dd99f2e560ae0b4bc60162412b0bf3975987ba294b59e2877ece0b71b6c448dc2d99e1f856e1cb4b84699ec1311cea4d29a2e3824bb703480da5c08efee30408bfd6b9272481a39caed7c82402eb3988a6893a3f5f8576a84946a8e2f3600f31f7f2c9fc27aa4a70b6bba8f6609764bb2ae05e43411b34f4ae1e665084258e4c0904698c2d6b9da455f2b3a68c876c6ac722e7cfb22d658f26fe74a9b438d48f51f4529e02b8178f6457c832f4e8ecd3a7c762037552a5ee8b7fca1dee72be675431a99a289668201f6dcd4b37bbce033a3c59e5e115ca00f7702a86df9b5b27915122a7357b4a16bae0ccc855103271dc4dcce6112965d42de6ada72f51909a08351900146c317ee13b27d8bcadc42a860b1b0472ddb272afcdb71e89485044019a3ec47b3ca960463d651eac263959f01380f8f919e2437872c0759b8e5c09264e0dac8e027e662c2abf75c1b1940c21e84e87a754d703713872cf1699547109aec7dcfc3238ff05873f96c1554eaefd0bbe377a29e80de5b85d83700e540b3b9d3ce0b024e41104ba6537aa5820da19a703cdaa62056cecf1c67c309c701df078e6b31026ed56e5e75da84c77bcc89632450232d54fd155fb03b19508b05002a310906a7321517d409d21fef5df3695bbdf86bd0ea43c5562c30411d9ddb6dc52a694640a3f0a930a7a0a49baab77559830c7a7c6777777ff23dbc3af9478632d47f7ec6c867d0c2141fd7d521f305e89359e34a89f2251047586342258a1c41caa2e939821478d31ce58718253da345236ad60819af6464ec125205c6567da9a6823679ae60f3346ee1760de63188691e6d2442a1f46397f985e029991b46dc70b368d944dea038aa0a0f5b943c690109eb08365825dc7d102a232658b9cf1de8a5c2959ca28658c314a12c827121dc3c14475d62d7fb617836c624448d8633f4c4c462c462931a90452d65fdab4171489667452d77b3e856ac618e35c4f6e552aa191f387b9bdb0756d240ff5fbcee380f5e2a3e20ba5336872386b2576d1054432c618a39452f20aba075ac728a594524a19638c2d85849146d05926d823c5467bea07817888c5253e020285fd3c94f1100f4d3efab9d19e192c7105f6386b0510c208218430ce28230ce6466512ccd2a13a91214bb22c215a32549d159fb92f0956fd21843470f5603761a8773295793217c166009b4c5af4d87fb0496d9e73a7a8a87987818ea8e4ba39bc3337ea10c3a28c58ef6059e0cb5f722ea58cceeeebec316e841c9296d25f3e74a34590c51e93f882b9517e652a7882c5abbe22131cfabb7b978461779e654a39290a4b02859a1b151a827232544a29e5bb9498942e4991247f3d967a786c1913844390ec52c2b9514a29254c179bf5c984978c31c618a5941247062ed7faccd15bc818638c314a29a5143782a1b880a3ec22482388e2db8821cd1831677c4c76362f6463e3332c903354df81a33acee6f3bff9f25ff3d001eae8201e1c1d280cf62f5926dd3413a9bd1c1bd4cdac0659616b6bfa4b2468ed30b922b2ca8e48890414230a7a7102f44550955c34fc7e6805917b9c3366934d36516cdc666e34c610b988d18f986a8c928a18e3a909378521a5134fc5fffa6408598b17f8dc286b21e4594c76648c31c618a39452da3cf119a44c22e7d87d85aacb44af46e832665294bde8eeee32b6df444d34708da62db0eedb24accf199dd0969312ca871042093b1a21a53db06c73229b2fe3cbc766b7af611b0efed14b3db0c6a45319d316a94829638cac448c3e027667c87d53e3016a1c4069b7fdba1a3f2e25bfe66103d4d11f9da06c803ca00ed4d16f32c1bc984c5b47eae6954a7ac9f97af17968d55c9ad86f823a7352ba03777a073939f84a7ad13a6e6be277a4eebb40f587ebc507c2258645efe0cf0b9c4570f9a432533024647a073b14935366922435b94919a3141a236f949a4cff9e874205712224b4519b1d2fc28c9874f7f7624449ac0b82094921a1fe190fe551b0852b7f4eefedbf444a229f40a1a6a99238b842f59c2b01d86555ea0cb03451013568d30038f842264d28312c4a8ce314f772b06a7bf79f476c9acc49229988b4eccbcb71c4c663cf0676d99e4b3f622a94d6afb66e07a6e92b70bf34de90e9930336afc9d2073dd18b5adc622946295b40a564e7cd64faf73c14cac66688cfd090f7cc209baf7dc47ebd38434926ca038d5ee4a6324bffa2c52998905e5ed3344eaee2ca575a6f1ad72bcd378de39526378d83ab12b7c90702137fbec3ffe88e27d013101823f1e917bb13adf33f4a2af590118b353edd9afead293881788d2fe9de2ce504b411f85eb77e303e0ebb11f8f1bd3bfdf01adf6b746e7f7dcec738b6dca394524a19638ccd33371aa57494ff6cdfba787ea64419aa47f6cabc828357ef41e95af966d81dd5d97bd97254a7a4ffb68a55ffb83c8440df1bec4a75a70175f7652132a6fb4c4b4d2fa58deb53f6481829e388b0d715eb866c4d7f944d723dc0b9d12b252a425d5ca930702ab141d5dfcbf1cdb81f99a90c650fd8f57a977ac8ff7e6d548fc9b41923b2281bb03303180fadda3ac84af5286dc1da6ca4b4b1e12a090358e9c7d7ecb509975fb46eb78644ca7ac46e8b564bedef8c3126b8628c53ba122637794e789e6f3fa1ad9452c640e73b16b7927c79c1482e47e05b943039355226a794513a9531658c5101793029860e5ec293d2cedddd1fb58355a5f7df4e229fd88169fabf4d9decda1f720e2184117b77c5103b222cbab92f0ec9b51e3b4f2261ba74e9327d90b24a9cb3e3dc4a1fa594b2b4a132cc83d08a3d4a4391509913892e6397b14fe10546fb48caa67ccd378d944d140ff451933b0c7e8f1d9d7f2b976cc881b521e421a2d8cc629c9352938905514a8f95480aa29991668c2065267f9b1f9bf5e933444248299f638c12462965472b40992d605d8c31ff79f43f948cff6c62fcb7ae17d306a580ac173f3edc940ff67a8b2af693ba806e32b8189cc906c8a634b05e1361afb499b48e2483b4aa08114efda0814d01b15e0c5797263e0ce771585420fa8bb4cae6074eed7ad35597083930a8feb04a8e0e1a86e3686afc35000ed51f66dd733562a0fac327f273a35b946d8112030e688cfdc055a4ca773f62aaf29deb266c131554ca29698fd89d9c78ebd35d069a0d8aa46da5196440d9d94da67fcf43a16c6c823c212434434ccbca1333ec68d0abf092242d470fa594d216accf1c359e307a410e9fc2f424e39c93e161d773251e3960a2417c3860abfa0f3940395472a654ef207cc97d471cd6df1a7fe89877cba457c067009aeaa68f729bad1527439aa6df145fba52f7cd2d8618ea4765cdba1f4a23a0f0872cad7187dc7b805576356e7016e1ff91e3d7bec6183fcacb3c59857decbe24ae0435354dbf0c0c5ad008bd015dba74f1ea7567fa68638c1c638cec0426d9a3a0497fe8b0d46362f2bd63a23552168954f9f1715a8b5becbcd483df25d63986b1173b9451c739bfb93941e5c7ee9b1f8397eff0096d71288c8a1f464e760b7fc71328c40176499a9b35967c6c855d2c01d92e409274a90628857579e7d1dda33bc767c618638cf993891bb1ece1aaa8fb84a911a67e94865865e76d4d3f8ce7ad4f19042c71450a32ae1d48265a3254d9c71fa7997bae431f18507f9f506afc2fa6ca0e026d4d3ff30028723dc0fa41a0f5097da40ecf0ff461a21fccd803a13fbbbb7bc78fc31c343b0a9b7e26ff221d7c715075af82ba0fc117047a85754dca01dd57fd7888833a0542106272508fcf60ae63a5ffe8f69f09e6bf5fd5cb7fa41ae767a82428c744fb207860b158ac157d0d869bf1f2428d01a840898ba51a6718a9fe839638b934f1b7971a3fe37cc02a89c657fd7f60553ef683d6ecbd044456d921d92e95d4c5ad8932ebbe10d408975f66e75b13bf582310d57f13105d8947d4e48882d7dce28c524a29638c11670a97bbe646d751805109ab9450a894914b3da27b1258e543f9fcb2f301d6d83918fbc26646f2a098935293e91f6709972b4ae95e7d0521a270c8f88c1118b61ee61553e2476670007d0105e7c0cc10ca8b012966537a703e918f5ef56e08f67ceef28744312487d60acc103cd0c2d74a4f5d00e4386c22e4cffcfb1153f57fef09f5ee6f6f9aa691cf2528930aa69ff14c0330c2144698a65a8475cc3e3e6dd5f6f2f1513b30ac09c576ac176d24875a6f879217ee4b9ea3368e6a26129771cb039511930f8fd8d4f8b00424c6132c5430eb9622076cea129923d9a3f8c8aa7964734286bd76f7ef086f9539ce87a51f70044ba4f8630f5f3efcc861ddbe7663c713a8ffd6f8b3d423da90533d7ae7f3c86684298c30c556034e38c5ad1ddae75da2d8d08bbdf9e582cdcb00d42a197e6d3a195ec0829efa6d3e6775eaee44011e2fc30b51c0db744aa4f42be0bb13c2e36578193a253c3e679504b5f99bf72c45bdcf407b23f7a6eb3e5759157c35cdfec48212e1e324d4fdadb1053627a526d3bfe7a1b00d9680406c8bc79d84c8f0de7b9d12254bf68a26785652fe952ce11f7811b492c2bd005e86cf59cd1550f8de2f8edf6f56b73875fafdd661d5007ebf9b70eac6ef374fab08f0fbddc3291bbfdf4f5895e3f73b0aa74cbfdf3fadaaf9fd06e2548ddf6f2aac2ac0efb7154ed1f8fd0e6a958edf6f214ecdf8fdc6c22ad4afccaf017ebf8b3825e3f77b0bab0ef0fb6dd447ad42c0ef3bcb99b06ac7efbb4e02dc09ab52bfef4fdca755aadf6c67347d402406ea986e0600ddcc4c07b560b07f7a00852e48423dd0228469c70748e899010097030b88cb8145657b80edd4fde778e213f6f69fe366466362c8909941a386c9c60deebbefbaeff41cf75cf7e178fe9cbaa51edfc11e1edc76c3650ae06c38f8ea8fa1fb260cdd0bdd67dac7c191ae905ceced9f38d21047d2c2debe0d8ef4626fdfc491b8705a8bbd7d1a9cd684bdfd199cd623c36932380d88d3acb0b71fc36942eced534ecba215692a4e3b6a9afd14a76d619afd04701a51d3ecefe0342c4cb38f004e0b3a00a751619a7d03701a8ad39e30cdbe0e4ee3699afd02709a0ed3ecd7701aab69f673702423a6d92700472a6a9afd0170a42c4cb34fc391849a66dfe3485698663ff35998ee9b1fddbaefb5eef32aaaf29fb2f98c85531ff6535786bd53d6d1c035a3b2cf2e4edd1862222818d57d2ee22dac62b21169e9a98b62b1154e6d152864a9fb1cd4aa5eed6793b11f4e7d994fdddfcf7c3875823e300a36855318104685539c82ba8fb9302b9c6214d49db20f547f92a01f746547381d006e5718f7f1ab6eadba1f3920ae52f705c02951b2243be2b59272f25f82802a442b2927effc55dd88bde5a95f7624031700ee60506644bf7e99bfeac2eea34b85bdec0802b1b70fbdd89badfb31f0d00fbab69fba0058522327009ce3096d673e7ed57e1e9df992874b5402e52752e12f078027d49344f835c2a036bca5f6f3164ec9f77e6d967a402b4a38cdbac9200832cc1da5a139c51fa462a5967acc1fefce9c29d3027d1b7461a67bf6fa73b0e7ede09784c22a29f377df35274171dbbd79a1eeef600fc21d2c58425e0ef6a012edb727318944ca489dc7218128f6e092c642b4da5ee3966c53ecacb4b721087bf07db0870327f8c649e9d73829d873a9c7ecb6090a3f86236c0802b3391db0454ff5ca838f205bece860c362b9a1ab0366acf37bb6f468d85ee7b373fbb0a9a424519bdc5753e7673fb98fa6cecebe01d4993177c4a662d84f200da8185714a7b01d2cc51ffe7c2deab7afec6b08d1ec49af91b89f29ba52dbf38250448aa854f83bb08ab3879f638d2a3c41fd76d41802d51a0889c33ee3fa39853d01aad82a5330aa6c434424a808a7becdc203a7aa4c014b859f837dec00dbab70cb10e8967ef0e4fab774034fee6bc66d1529bc2a97cd39272966393e9b1a2712d8e5c70ac108203a706a76275a6588a644a938326e071e046da907a8cb8328b450616976a61a50d30ae8e755f8455ab52b081fe38a703bc0af82ae1076762842048876972e15b2480c5305160c62270a3b2b25374c3464b418982f75da155eaed546822e2082cf8af44b78044106aed5e97356383e6705c3e7acfe7356dde7ac6cd4982123062d2979f9527712927de94b9d92d2679fb37ae17356317cce8afb9c55ce6abfe376098e33695028fc18388ffb2f5ee07070a82ef4e3d7eb05d71084ad96d1d18b3d7eb1e746157b21817e04b437b0f2bb0df6463e7f16a2ca4fd8e3fe99e63ed4dc7a6ea6769f2938849c88b23daed791f6f34511f5eb27cd8a3db429ec71048a3fcf13a56391cb81e2eb753464145f928b5e6c0dbf47f7865cb61dac2b5c5b7e98f04e8b75459525ead74fbae30fa7bee8457dd5299c621d13d425aef038d9b6137792008e3f3d8e0e081c7ffa3867fc79acd4235e9103290e903838de86e823e827c6ae0738030714d61ebc7eb185838b91cbbc686f606cb57e34aefc71a855710a512ce510c491177bd35de3ab5571e85539c630047d810138e24fabbce8856e9b669be6f923117b1363b0354540559401a4e1ffbf71e3e78badeee2cfd630571b54e8e745ce434d4ae06abbcf5463cb8615f4e3d76b6f56d59449bffad5a4b2084e1d10a71702ae4ea7ee147f57a7e7f71e5a63c842e3891b628397ba5700fdd41d88e080dee06c70afa5062763050adff4847ef107a855fcc5d2f03387e1aa3c82ca1f9b88ca40ec12e257a603fa404c7810d47120f843839bc1411e2450f832fc32f8618802ece1600c0e965894870d0aabc2180eba60100f7de1e050d3f0938ce0a645e8064e7ca2f84cf9f9b9a1c42d6cd2a567e54da0f09d09744b3574750224799df0b2220bc756dc012ae271c25ed429a27eb149e579e23d3d0ed4aaf8b38329b6ecac3c0bede2a7f26b6fe4de7021d2c21e3fd1162f2aa2c21ebbab7320f6f86100837eb1058de20bbef6a62bbfd6d21b4211da424bebb057a942d4abf8d2db8be051855cd8732bb1ee1536d0c2a499e5452d9d56b39af0ce4ee52dd5f0428d3f4ba05ffca9b0f4a3eb27822abfc4ed4aeb0d08fc5ec8ced5bb6fc9ae366ea32085240cad346e57923302dfdf091d25a854e9c9520f50d7950517d47e6d0d7f3cc5893dbf38152b3f1b716a5d5c742a3f1f754f4761d5328188b9706aab58b1c3af2fbaa2d87eb814a17e3d31e9409cfa62cbc5a9af5f419cfa9c4788535ffca95438c52d22eae7565af5f32b7588fae1a89951fca92cb457e800063552910cd4048d2d4e9dd8c55666165cb17b5d81414cd08f836ef07eed4dec4e34c81a3f762cb435fc469c622c5916faf5e3d756f78a185851bf6671166e827e3cc429ef4e4060779b0d481c13715116e8a6020ae58d1c8c5346da6e24712721a49c95c69d84684a66d3f86b9fb3da2d66d98bdd89867571a1739240af4e12e0df7eeb44407afe5dc1f7d7be243c597e7c589add0f9b1a5535beaac6c7691cc66123d9c7245cb3eef4237ee7035723f2d7c5854e95aa2ab97515fd548ddb1589db55e4785055f83be39299075a16148abf8683e3005665f2d7abf3f73f9b39290d92714998a6794801dd69c2284545285e90b781df6462ef701887530b21dc66d80961af83b0d75c15d42bbf0338f590fd0b66be2144bd3237f110324326eaee76ef6e6feff676ffa1113a8311c3d6ece7d4ad5b82e1051ca71b364c3568cc9091112386c2bc94368d944d4c466f2ef5e330dd6e7709cc61662d1af42c28bfc6dceefe12bb6ef729e95e62a0eda6f87d57d5fcb0dbdd87bb8421057cd7fbb77b994de0b367edc7aa91e6947feeee1b77abdd95800855a0dfd736cd78393835e4dffe93bdc781df886fecf57774c83db3ee7cf8717a924ed215be0b216ef799e0cf55650f29cc370db71d5f76303eec9c3d538c5d0f5e8f982a7c29c828a57c9798c4a4d7d825e10adfa9e0eef0c6468feefe53da9003ab57ffe07fcc70c297330ba1186394d284ea41a1e6464d419a97c327cfdea29412c3b028636904d24b3df8796e14a3a2273e0c2207b1d6374a29a59432c618db05ebf38aefdec88f9a8a42a171dc7a4bda6c6757d9fdd6c4e84fe4dd87d8b418639c73d2dea22d6fee5bd45bd1dca84de5b701428c5146982e3c89b076be3531e70a4e93f4113e3d57e201f17be80453ba54434ef59fd8b70f5cb1d7e6d6a51fde0cfb65ce0e4957ac93bda51b62e745c02eda421e0da1e47c602863e46f1fb8eb41c687ab23fe46eeea48baca6e3958614bc84c76aa9c1897b1883c077bf23df6e4a3d893b5853a28e3fa0af659d7575a8853d8cbff30ef6d4e5658eaf14215146ba12afda769a4730b63b0873fadea16c6e5c022b928afe47bd1ded474517d8b2a3f3641950febe90822dfb4e662d5b00de36690251ab0da8f7158d5b00dfbaef2fb8a8c51e5f79133d991df58a4785265073db3a4b0523fcf1b6b71ea93d9e1d487c3d4c33a9ce256932ad949953cf5c381956ee00f6c6a7bf91ed814cccb1712c406f940ac0afe348d7cf9436a7c3c173c13a623a809aafc60104172bda85236e99d22ec658dfa75508d26823c7a0ad4217f4aee2754f9f0a755dc6a9ad27f35de53f9301bc72d2c3d05f2682c56877ce923a8e93ecfa8fe162d1f05c2d6c82aaaecda4efab1871c0631d8b0bbe6614f76cb3aecc91df65ea874d0d6cc981c82f069177bf25fba06624f9686a0f2fb49fbc497dfadeca589ca2b4c2325ed1a4ba95bf6b6eeeb2c59117bab7133b0275fcb36c8e1d0c05867f30215f49ba9f2bf47710a56f95e0e4ec927717d853d99752dc49efcd975107bf284f51556f50f8bc5626225bf8338b5a9ead3c57a5bbf1a5a6896a5d95a7db02ccdf6c04ed54bd9631c576d7138e36417f49bdf030a7d28ad5fd1ee84fdae5887694ed8c38a75dc624f7e2605fd2ab520bf0eaaf26515f49b55be7c29492cc384b633d88a9df268ad2eedbaf3273d73c23d8a5b76ca9a7f383585819808bef0c354b054c873a542d65261f6ed9287531fb37a38f5b98ff4e1d4d747d2c9d17ef2898c52e1cf1406ba822ea74eeb59b765ddc47100a74a0fd9461e65599665fd5fd72c6866d9c3ecb3eca83a15fea1428ae591b1a00e9f2fc78c8f8d3ce29e8c057970142d9bd977f771fdf88759d079380ae4e14fa08eae87ab951fcc873d1e7e88e91cc9a3c95d0f70739e5651da499ea6c93a2ddb6612f4c37c6a14f6a0ff34cd13c8c3a5581df0a14f2ab606fec7f5f327153e73e73eb16e95574ffde4d12ce2d409e661253dfc8cfbdc0763b52a16613e58cf9be6cb2dc097612c0fd904eae0c2a923188eca14b54af2b46c0279482b5007fc37519e58d4a4d2d9c9a31eb3339966117b5b785a25839a069aa8d4acfbb028f06510d67d33ebac3319f452e567cfcccc2c5bf667533b6bc9035f5a813ca411d4c163a5c2ee301ff68eb6868b34823c6418ab630b5b035f4aa30a7f4615d4ffcb58af0a3356c6246bcd17a78c38d5c3fc24b36a0f7f1e712afb197984b57290fe93473d24a195df3bcf9342f2cad6609143328b0cc2ea80cf9c1cc2d640199471415f062d2adb81611b58689a0679eb66e6c85c12f443d5c9d0e173fd6085023b254b564b20f30d7c23d710429844728c2ee690c400a94020f67aa83affb7aa16ba8999b3ebc8f5bc5a2d14b95b684b0f35d1164e9dd61b4b6751a27ead056ed0d52ad872d5102bb4b235fe730594e10b06cd49a9c9e4cd23e88732d5ee866c8d7f0bb52a87a5f1f77642757f8d3179c56f5467c2aa77412c9cda2a5e04d50f6af988a840e425561550503fc8059311eef070cabf5d9c3aed7812f5834eaa0f55c7e16f62820e6995d734fede3494aae7a2f07fa65f9b09b49dd1b64077c3381a8333f22396ce561172e2a8a8bd198891a8f061aaf93b46977ac4d0b46d7ef940302b2c6931629adbd8830e85edb319323eb26464c9c822bda67dd6efdda576271f5bfd6bd8eadd8e2ffce7e7541c7e79e75e301b0f6774321d5c1a9c263dd6652f349094d841939d1da8e0ca125cb0cdd9bd5b317607444f44396a96cb0a52b297eb78f38f886d1a473f868342e349dd897f57349e76277e58e56fede7a0a02f5d13753dd459d8831f040dae7598a69535a15b321b77f2df1a3f5691385ec8c274c594202afbe7f0bc2a8a2a77a82aa8869580f0b0002654bad30f9727e8a9fe393db43139b05eec6dd53458f267ce077892c00b2780a2490f6b45e3a1d4f8053071558e46b784c6d378cd937005b20026aedabf0026aeda1d9425343a29fd52fc736870529a8b559bdb0cecd9b007677085aaf5e00ea70afd96b469dc565802224fd082dacf251c505cb06a7748d0fdaf5b9bc5e4c072c11765cfa120027af9b0a1499090201042f86a5513f58b6a41e1179b65b0772835a1f8053db65a2d085403048240104b8b080241a01a5d340d7914424643746832b443dfd0465be58ba37ac4a953bf026a8cc161f8f810b9b6e8d76b6f4e2ff4809a2a4c85df437bc3117161556fb12a08e44d2a7426b5bfa85f85232a08b151e6ddea8ceec0f8f30e4c0627c43a974fec7cfae19bbe7e5261d7722d68276169e067f5eb2157510f6d0d7c1c9e4103fa75ab5bada2f1f0db8855d5781853bf6ef5f7cede34511b310d7c58a36b2d760c7ddd1afaba15d3aeee83810f879e40bf6e56d011a8c0840aeb0c20aac1284ee2c62eb81971a9d1680b976ef08d4b409c61bf7c4aaad635769f076af3cbd51f0cfc276cc43615a029157e4701721e226a17bfac20d42e3ea27edde48b55f1503fec9d21232afc9e25885c0bfaf5d0107c085953a0c154bbe3d7d6c077223aeb56b9024f6d22f6e07f5ce3b724015fd590a93dd4aa1a73526a32fd7b5eb76874ddea1935a05a7f01f4858f0637025441ab58a155bd76516bab8071d45b6a0c81c2d20ddc8d6d5d02d23380e82cf558538cbf476e87726009a5f6b3528fd6e1428d5c8c0a4b3ff6bfb81bf483a31ab95861e986fdd8ed7a5e7b873dd82df6206b68ab7c81a5c25ac261bf3b243570edffe1b597d4f68d39fa16fd50d1e18fde2ff8e2d409b6a08e0a9af00e4c41d8f3b335f0fbd43dc4a958e1779626f2963761157ce26a2d9cda2a5db02afc36fa9ce53a15cae8dddae1d4077f2a7c58e448ebc06e52e1cf2c40e8f0676fbabfbb1fb6063e57f8700aa79430810f59ec4116e4610ffe0b3ef48bac0a3fb25a059df4ace0c756dc8952a114ab2f36893d3398013f803e82ec8dac39a0cd5718c0a0ce0c83f6861f3ebcc2a97df804d81af87c621f9cea0adf06f8413875a3c2ff01326115f41112c2a9adc245940ab554b85c2ae48fde28f8397038f511000671ea94e2d60c15ae950ab9637803e7e0d4c9042b8ebd81b50a196d3f75dfb4022a43ab0200b323e8fcd951c685c422f990a6b0caa687c464a82ea949dd8fd4438a5217be738a531ff422b238f57193d3dcdcc888fa3997ba91c984dd476ad5a5375841492d4ef1d4ec8853cc5c482c66c9bc8cd88347ecedcbb05d3c3172ad92a0ff302441bdb731711fac375ef317cddffcab5537bf34de0de7b9ab69b8de781cb6e118688f6cd8f8ccc6bb8d8fcf47a7c7f1f088536e63834279debfc9c4dd112cd530bfbbcf6117b926f4c3a2d47dd3e9e38fbfbef9d1cff4fde7d9645bd85ba34affc37e6a76d4d5a031a3fb4c2fd37defc9e83e0f15a3cb7c62bacf86494033a0de65af0c003a14fe9715d57d2c0aa7e00d6e2b89fb3ca8eed313f7ad95e73e3efad68a0d1a6607b940f11e87e1ab55cc3c5e0c4ad02f3b621ee8a2d014bbece8e326fbabf116006e573e30c110786ab4a005364db30f03125ef72686ffe6c2f01fdd176c1efbf5d77a93813b09f1f6a80a32385a799fb3dad21d11b023051d1e2c75ffe38fb7442f728483ea26e9ee7878310fc31d51b8c2cc5354c4a9d3101d38d126caf8691f3633146193cdc6c0c23b2f226e93a90f6fcae8db05fd3628898fe5d2926a320618b36930193d749bbbbb79316e3eca6b150f41a8cfce07c6f14a060a283f377bd9cb975363f8e285080aff232a0ac2362818803ad355e66e69fc913932fb47766f006b414a2e5b08b9bb7f6fe1eededdc61d68ee1ee72faf296851281b5e158a72499886872a502f6d51108c319cc561140ac53242deeef80298232d998f6188a828089c1886cd396d5c41a8aeeca93999c79cdd3d7fd99bf3677f4fd39c1deca67ceadd67a23d9f605be4a62ab05ed32c033090753f96a6bf3faebe593706d45ffeb7434578f801b2b6ca16a6d4fe21adca59f5ac3a4ca8d72fc9f3421e2fac4a92ac853c26abee7329763fe277334da8425b06d21a5fcec7e128a1b47e356798a6df25778a0feb16e1d82113185a0f4966c57ee1ea805ca3f7472cc6f81873d862bb3bb1b918ff7cf66214babfdf8500eababa7083ba6dc951d7d545a7d22c51c618e30fa2b020fe0c630140a2928ac05cdc0750d7d58527d497baae30ac34c32e30c182164840794161042618c8034b851e72aad0b245123b34d882cb166ae081ed2183c15a931ee7cb462aedd30d81173e3a7861d1d30323aaf0000d586083214461052bf0a4000c29fead28d2c41456149e8085a585a7987eae94d27fd0050c301da7262a432915b02c91456271052be850da052ba84c951c0c5552dd2a2e29ea47a1cc00084940c2105d24618515fcacf81f85c222830758698214a0d0a0084f5c8941fd4c0c797a6044142bb4c0e4f50fc42a28383822092944a1042ef8c7f46f031858e0678b1457086309415491c50b725084235eb005125842f8008b140844c10509b478a9c0083ac8224a9421a8c064052c7801152014094e4c38a009275842093818421255a860c21646208494524a29603efe1447909ad0993e9b18429e40081a26a8e28a294498011458780a200d8b2634a1e352d4efb5d0821cb55d5a5842d69a257091832368e1043d2862d5388c9deabac2e84295755d611ccd1bf8a854b0042030907022075380d2802d88a2f841124f68190285ca228a1ca86c3982082bb610644416cf62b148f099989ffedb000a24559ad0320250115c6042164f88f84901128ae0420411522c9607fc60092ac842062e2eac7041e5a75f8427b60a472062a2488a249a5471e2e708294d3401b40510b0f4e4e04089297494782541c78a19c4ced4b680051e37f104284d749c3cf1411195d5ee20082c28a83882111257acf8b7c4a88ae5ab2b8c292ada335b80bb40a89f8c8e23258e6a503d0c1254f8cd50fd7795850549e86942ca162656fe9453eca4faa338e5bf83532fd5dfc60141f6065688048450b52be99cca51631735da38827ef4a12b0b46a834aa3f34716ab759c56f9dad12418c1bc4bf83b14e8a11f8fdb25392b392bfa520b23bed6a36cd0ef933d511e4c386203f4026426c56cb16ed6bb978a71835838d0e14ff0eeeee6462e61d6c89ddc19c3333c78da61a5136ecb54692dc45d86bced1348d0477b0581a89599cfab6cb163169e7540ff293cc9ab5e64ac6afb79261b392f15f8d19646c1a89967e3f07ccc7bc36a4fecec29d1dffbc36fd98d2cb520fda49622d7d978080a04b972e433576473ccac1ca9da53217a4f4d2750f51c372f6c6bd1669950d4cd3df3ed8b381038fc4b3714170d89afe1b56c79459263bc8ca02876a7f7f6bdf0f593e3f7b8d29cbc77ce85a9adfac5a0972562188f19a73d833a77d89db3824b08b977a68a46f9246fa56890008192f045cc950c9e84e41627c8c4e095c8940c6c7f89c553faa39c80daba37f72386c8db63725ac8b9c0d5bd36d037b1d3b0f870e6850ef7c49b8fa3369776ee0514046272546b7a52031bad3aefabbd44352c8da9ae6536cd2ae2bfdd0497774f611c48686acbdd9da5880426d1c4c38d8eb2cec7cb0c7ff896098860b34fa3bb393a47d64f833c31e435485306633750c8704da4882d6a8ebc2821335d62d4152851c3fbc02856010e5e01574296dda7b85091a407168b66da651ce14d331313486b6c9b4850d7605dcc10a0ae2d407afa87c8581f415f0676e948353ba586db8a810540254c9ec4d12f686fefef73764fc500c380489d81a7e22b008085ba43eaaddb75da01c0cda1a6ef8a7de2c5b8b534df8a196161f5566ee85bc44508761e987d7207ecac54a847f074e1580e115508769b8053b4839ae366e403f1311e80787b4186159960cfbd47cc6985583f636ad8af1a55f2bf205e6b71352408506a87088a6428f63e8da80705543fbfcdbb4fba829497ce1bef764fc6743e6bf18d58cffb25a7ab82a1a5f2a3d8d199c0c27835b4e3ee44affc221698097b8e592b07fc376137bd0bd189d088088f142c0558c183f572d444a975363e4ac62fc6c1ab601fdca8d031aa3c7c6178ed5102b7bf7ecb9e7413813c01ac3e210167b081288e8e0f13b76dddd9d65bf599665998c09676bfcb353961539e2cf03a7369e04fc246152dd1d8baec7c14cd46fdb1b2ed62bdca0faebc0a902547fcd27b0375185f21d5be35e6de480fa0f69d59c1b58ff22fb45f50dc3d4aa97edfd5d1301102faf9562d7dc02125053240075863f1b185c5591a629e2382de793beaf3375b351b798ba65757bb8aa18bf6d1f83dba5217d0c4782e14893f4cd6d5fe2e6f7c675fc2dcde79ecf73766d92b942bfc8114fd235fea08453f3b90577f885dba669f662077f484c89b4dfd83372423a65339048ef836866a872a551f9718208e941e5d78155db05178bc51ac1ba8c822a3f2acb814525f56d91f30a2a2f1121b74d235292341287636b60eb57da2fabb49fbf714a3edc39c334d98e2f28c923751e7b9c7133f3833a7eb9124e4132d2d3b9fbd8cc3aec5b7345923135daccd5fc96cd2afba1f6cb55863d4e3787c4541b07ac7a00a63a56bb33e2b4e58300f34e02dda50bf74bec1b5bb9ecdc5aa0824c38bc1c54a0eb7a15d5cff41aaadf34e1f0729c82ccdf2a84592bed69abb2e79f1a6ccdd57c12c744089bd5fcd65c69118ad691709a94713cd4f8b9bbbb8c08a85b02b253a8db4139f92b59d70a04f34190a5dc9bfffdbb20d97b17815d651d4b8e34d0b65535bad082b5da1b1ac4a11f6a6dd29a33e2b4d4cfdce9477c7eee3ed819e13f75e7fd3935a7f6e9c7e7d4e6706023fdd388bf372cf1b78c43ee02ef6abbcb3c789779975b08389f5f6bcd5586ed66dd94dcf743ed561a49c2d565d4947b330fde8575ee4299b3dba6e95d02ed82aecb8ba2fa4d2f788884306b158d78d1f28275f28f8fbde44eded1b08a5dcb8651edf9afe263bf2dd32a621f39b92dba8a0f4b3460753b1ffacbea72adb98abf252002a8db4101417c1cf6eed285b74b975594400356b1dba659f6b6b9abdc605b9bbc49595e02b72ea6c60ed4fe41a31663cf6de376353921ae7570131081f0ea2708947efb21a56efb21fb3bb650247b94fd16d59c55ce8a3d761fd43826da538ec9f6dc0e3028923daa497ad70092869cdabb8ace958020a062afc94deb6f58fda7c64969d9dddd5e7ac93a1fb8627362327af747d78eb6ad9282fd6e15e209705f2190c562b1e0d27856fd03952727c5dddd7d484b0a129b6a2449d7f95ecd59fde84702bb544e7ec631c95e0829486c6a9236407ce64a35e464dcaebc6309888c2a716858fbb18c93e20363dd3de3cbec7c607f8c1d092bda72ca35081debe07a1108efef770e562d629c0f2cb1f7d681d6bdb1c7ee8ddda8f2b1caed33f6e9c7c23af906d8a57a27a10efeb81a81ff4988c9ae86af2cf706f26824904beddaa51fdeddd6f0c76f23b1ab61ab07b1da7a80eed009ac5446d25db854f88ca4bb7479e903c3ae078c75c0eef3973fbccf5f7e977050e2f18708620948a56fa8442c98ca9a5432442410000000026315000020140a068482f1804cd223dd0714000c7eac486a4a170985610e04318a216388210400001000011019a26d003f377ab5bb613e6773c7b7ad172515035068d34b4714ff6b36f4da4ef25b18a866ebec8c5ed5ae3710351334a1fa1a35d8d8b174c1cb07a3cddcf370caa0a4f18ca71e5e99be454e27a5bbd3b4d9de8b10fe01d9231f0e709c8260969bde5826edd42652b55b6554c5c67c4d7150b093502931c43656081818b8e4e561203835855b6ba3580ab49429c045171e75af299afe39e2b17855625631fe2efcfd492ec320efbd472ac454ac0d48a413ca6d17ac683863bc003292ece4136a8965134b23c12d9811a31c2595432145f489df68ed5a99f95d0190fd1c40642dfdc45792c4d0df4a89242691056950718080448f40d6cd63c0ea76833a10ac5466b185d102a1a4e7355839cb5ebea1d23bd392a94185e4cefe1e6720f9f29400cd831ec228dea517aaa5eaa7fd2751af49dde8252993126f0f9581b70a8d136fe121d0b971d95314e17ec59010fac9bb7099e2554d4da0ea396844a78753a088b156a13c35b0eccd07f5e52c5748f32479dc65943ed57b9e024b7540fa8ab3b360f07ad38f0b4be0d40889f2839aa56db96b347e05a1a45117722763bb0b7ee74d12c4ae40f590b045b8f6bde26caaf3b7f07379cd3891ed63cd382985e53184e3302c1af07ae6302ccb3d0162060a79104d50032e374709d3b2352aa940126a124d79d880190b85fad77cbe4de686e74b00e1da5deb53274074d1fa9f4eff58fe56dfe05ed1b5a4a9dc50998fa3b8bc46dca3da9ac6d4d5e4878a5ce0b424aedccf5ed6175071495bab00615c6cdcc45b2bc936a77e46aec17f6a6741608de59c18565aaddf8f9a98592c3e6b9420226b4510ed8b4a4a44a2c55822d87c10f7293f21a2a941620984b42b51d2a423d1325f18d98a3fb7ecfd3cf49b48e4b259d678e7efbc6f2b21d87ba3151f0b7b8d3b16a8fb5bd8a3de6f575b6f462d367ddb2d0d6d04dfa37731b791b020fce10a45e8bb872140ff05f1fe61eda5fdf7a7cab18fe24cfcadb5fd4971c8d79274cd9c019e3c3c79af8af682a2ea5bc6855f9267ffff6699908005ebd5250ce40f72aa81d73cf979c417a32fa676b7e582309174706aa7ba44be174219de7c7521a5fa8e07609ddd62350b69e245fcb8f7506f9c9f803b330f2be207b12576284b970715b935c7925b216a1fc0e73f6124472a400b158805e52178a5c404a1d65c916f563415684f90bf0fa7309fe49d7c9eba8e64cb5b9784778059d16543dd218e5fd94730d675b81bfe103fef107f1bf9ae58375e39248ecf4625eca9d31ecbc31dff20b894cbdf73e49911aebcb04e34fa05dd270cf385476397d9e7c91acb81c6fc04bfac104d93f05f0f053c667b47348c0523852215fd47c6913073ddc5efb8378a65e143b861c687e438d9cccb30a89f7072af4b2aa5199301ff23dba48c45f6ba662b9a912fbd49533e14de2da404e36389f052a431bf84983ee5c586e2c73345554642e1ca39a4d0220162bd7e23a0b0e6cf0b1f051b8b9c8c9c11da9a91742d3b660994fc5a78fc09fdf2354dc9570ca1f3a798d40b861bc03d4916845d32063d460b76ec4e5674535bb53b1631522eb46873e13419d20412c24cd02ea3b0be9780bb0dd7ad4a4146a9cf9bea45012b4c3d643de2613dab88ed250903698938a8acc6c28cd685da380aef9d36c0f5a0c1815936a268d3e41957e15804be307f9ab066f5d8ef7701c57a22b946c337bfc63cabd55d7e2f1fab31951d9d8aefaa2cc918f74e3519dfba80947184987f5f22e05321df6a8ba96ba6edbaed4521888cb65a410f893c97482b2ed783d89a103583856d1e6108849072e3036ef39f6e76fe4d3a4b6111fa7badec21f45caf9efc9fb8331219df48783a862be17c2466eba2d3679f8e1fa728e84812dcdeb1c4e0d023e7f32e1f0768fbabe1fc896184363d9f314006a945ff67042a23813cc6b53ffaaafeb0f26480e5458c774b0a493fc8f8ead0774708975ca0d9a4069fb21354fc8037cb3c8849c2fa42c7157b89286b2da1f412556e66475199af4e450d6169a8cd68e07a65ffdd4c2857be10f02df592be35e5275857609e02980a7cf32b77ef9dfee5e6ebc6e5c675d3edc675d3f5e6f5e675c3fdc6cd6eb8ff19b99fbff927c4c5f109072ff7473bdd16df1df5eb8de6a5ac0df4edb08ca5579d79dda5ffe12a1d1018cf8bbe172168e0a7bbed5e2abc6d54fe26a8529266ba3c2477e67a6045d4e2ab5ef98173209562a4e71023df1a619548448218499e589ed90975f1c6d5aa394337c2e32f214e547d71aeeef764a028aae6798cce850b3f839ccee4ec37a4be16eb11e22033e67587b863675e130318f1d1602a414f824075f8357b151b85f110723038cb02bd8b462c65d0621e7993f4635267c8ebc5068d3df1cbb41e9b848967f232ed17db6dec092ff3151bc2658e3dfad7841f8a1e56c5e60c4d19dc88b4054a00ece8b87ac0793ebc1000eec281cf8b27615aa01f25e3afd0b8f7ce03c7ef8dd00898ad28e62dcdb11b408e27de71f3321341d9a8deb9f2f2db0471ca006148ec19054ee8302e35d9378e072dfcfd44e840dc61fa2550b52af66a96937c8a8cc5fe737f43c1a2f6591404c2729e645b9487e70efa7ebd05be6287de044badf7666c4ed4feb51193f42bb9613f79e293a96b204aa383eb9f941bed3347eef13eb25af4434358111b3096092ed31eeb06334504a4edf4dbe4ba59e782fc56495355beb7c5d6d9440b7a6e9489855ecce444c882fbbde221ce00c275921c6f93d8ef43ae1d47815c49201edf2aa880b29edd166c1748b11354ac7b365c6a14749454893af162fa8b78e3ab25bbca0ad69dcf3c3ab34d3a48ae6b4bf76e97a6a982c4b8449ac10c405c6cf077dd54940365253560b7ee4c4b4475403c65d28c2c759c53d7097235521fe5f5a8e9429965a43a6f548f83ca70427f05c3a35bed4bf1b4a95da7265b2513beee10942f2ca95c8daa5c073e6030fcbb60f5cff4cb003d2df06405e2d2655def0b0a1a7243423c409eeeb5d22a0f4cd2714d87459b6095b510db21feb7b7b4715c9b615d43bfa65f89bf941b27c80b1f41b48611daa2b11bda36c5bf3224ed2a4ceb1a377d3129b3af4a492815c298e734fd96cd5c056a1ccdb93527c65e4d47f11ac058d550140ca90eb39517638fddaace56822f30768faae5237e1f55c3d08f3a6321bcb90f8a599caf72c97404484e985f8f28e3c813507c10d42ba427ab83cdb76e86856260ed86b23e5a13cfe74041450f6013d516cb0aea6afa82aae6d1ecd1cfaad36d8a85acf24419c50e63da3ec8ee934cc4dd000e177a4df31d369901ab7670dfbd494b27a16dc6c8e8d77f585cfbf0c45bc9c8dc86a4584bbc24c1385289310d0e0cad3efd8a1a862d8b06074838b6a9b52dab0827a2cb60646f16cb4323da13615342c9cbfc866646e513f53a5b4101d92eb63cc811e198a2b76b99d21454e32f02d8a06c56446e4f90783f0d72ad3ca1f7eeb8e6ccfc8361495f79a53e1077d316e7dd8758c5d582199002e666a8a5e5c64aec2e37384615abe9c52a8eb4e915455144c7949fa9b7a7e69d81b275aef28d32a69e4cd4bc11e196cbeec649eb0838cad87536708627419d5799538c0924276af4e10eb867dd6448fcece16ec464d78856b2b40a8b2cb5745685d2544bad13666b4230d19cb5ab9ce9bfabd2a3e7f6df82b02e744bd312434e1c26c68a79f5a8d9c56eeac28360985291f9b020d4a4f30fe1c1da0668eee333f91d4208996271b57e39e7ac239b24d92f61561ee335007e08b3ffb5be396983ea0ed3dfc4f24cf8d3cf8a8f4a662870e057ce0924d031c1ba98bdbbca5dbdb0478352e6478089d96adfb243cd5adb2af412ffa8e85a7cc60d3bf0ed0fed6ebb638efa405bb183551b35f27da1abf6d5864845270eb8c284e1510f8cd8a8212aa13780eca6db6a02a406ccb9c8b7322c2779828efa72238792930b88594e3f7b14bde0bb007708869dc115327065423b7671e35380a8476a70b0c4ac28dc9ae62469a98a29aa88658c1f1fb472ea88de83eee85c72b295165d8922a560e249541274f441cea02cb6b885664052e1022fe209759114609260e06bbe326c2e73e725dc281136b5cf0417abfb3451ae9d83dd52657041ad6e7f70efc4b97ca602623581181f991d06e3e3fa25803a78d12acef6caaf1607127900b7225dc81e81cbf566ab1d005735278e026e041f3d10613981aef008fc75bc277bf243cb94f7af030530431d817a0bf7132e252fb3b6c64c6b5ad53b29290a38096823f22a23961fa0289add9851277f335edb08e90ce950575c2178dff053d927456ddb8c2ef58e68148685b7c4a07a1e429f28a71df96ab8b68d294411dd33ff1137600ab2399b1a2b9a9901fbccaa97fe886263dd8b4ddc7115220416d52dae0c3c04f9388ecca5e76ad5c84d09f60cade4ef45443733f0bcc55e1cf9609b4ac71636e7afcd59e03c36a9e2fe72e2de3108d2f1b75e8556ccf2218a9739721968add49eade57e3ebc15328cd1332c0f0c0e3de997b853c3a6b134da6865fdc8867a7186017dd812a1cb9026f321e49c27f409b26906afb980c5d95ad2042394bb1db3a7a094b4ff2eab417998f6eb7ebbe7bae9369b7521b6c87cd9a666c302ba0e4deea8a6904a0fb8a9b8f920420871230a3a4eb5e4a9282855b3b15f7543117832439fc1e7aaa3166c2bc45db3877a3b80569c606268bf6327093146a0e035134298f03c8edd736412c2ddfea52cb484618163e0b47848662586d1f4e19a6d17da0a561a68af1cf04c62c8760cce06f41f09ea0496fc186c4512cb54d265344864f81c47d58c043438485835d31b1526da80b46a3bda075df8616580db1c5eb11d701de4f37e86a8f11eb472ce4ccedb8884f038e617ccc486b6b4b34d7f39670a0ec2a013ec0b99aee1c2d473e2b1922d5b8deeb2cb9b359ab4ffd1293e64702c53a927288d6ccf579387a48622df94ad0e4540b3c0a4b5007de1ddb3d64caa4bc2bd52c75c9f901a973a0a41850961e52616f6aa27e4cf08c205b20704fa84588c891be84226479e1ac6411715d6dac3c00855e37e8633963f0fc291608a95132c856caa8b9b5a6ec7d62a15ac6fb4fea54299475597523ae48917c093ca6ed24d70138c4e89a67e8df9bcc7b7998fcf8f6c32a4f1d5baeeb2ac984c382b70d3d1c0a154c5dc28d60c2adbc70a01881e7d67c980f2e336c783399058070b2209bd4afd09e929226780fd5baa2ef7ff464031b05824a8ac42e889e85d9e6212732f4c3f30d3d8701ab37ad231a655a1ae023728a303557d5e6e98b68bd7da95b7b15e9ffb6b4de2daade39c9abcbc619885ece1414cb595c3bb9132b41e142c87403adfa706f0daef98af834507c9c0628962ab657a01d6e07e5aa1365d2e248eb7cf47b0a5cb42cc2b3c32f91000102ed721b51bf1602e7cd3d5a4f6606c96b6f3aa1745aa0b1a8ec0285e46f0a01d91c846d82b83100475fa9ed12250e13641b51128e5a69e7e123fea07aeeadb0d1627483797071053b81628c8bb42d0f5bc20cba0c0df9e844854704a116c3714381c7478f64e1daf2838d8fe7fcbb629cbeb2c21c3e060d1d39baf60068327c9284575ec96a8401c4791cc48ca3df2c1a1b421645ace5c1f66139222dce0adad47cea0174ecc3a374aa3d1f2b5e3e8b48748d85e3a940d7352a805bd7c9591e549b6a6330f31d851531a3f2780ea1729b0bb145e920610369e00446da2a428912e1b8509118fb39029bde68cf02093b047533bdf8d114c2ccb956ea7a1b90b6d63684be84d37273b9f06e65553e8ef6db3d2bcdb4e2bfc126edbb54aba3015dbc3e4227b96648af98671ed6d286f375d6dce40cccd60d6b2c34f910ba84dd22aae682a23a4676b7e34f3f9e0f347301ff35be4b1808765246aee8d0193030570510c2d16471e8620985b52f82282c0422a2d603a3d387599e1c247324cd74b6ddc7ca1b1ecb890a1c857454728a2b0474d72a7bb5163fa5bce701076dda943d32e8bea413af0e13253de6aa3fe9ec13016f30b828bf3be7fbcffdf3b36ef11b2a2bf4c8f95fa36aec40f96d5ee2085578b8008530dc2dfe6fa573f21702dcb2686a64fef40160e8738c1810b2ad7c298d37eb0a3953985f0af10e08d9ae67041d50d800c38028a0e38c7b9aad57b24752a67db9f771b5a959570e2efc39c8f900a6290d66f26cab4d3bb540d069ddb31bbb7e96d10cadf7dfd9337b95f65e006f0dbc8f732293c510cb8530fcd93e15e81564ea390a80ac2876b75f24e3ffbc217dd7d05d35bdaa11bc619e7734082034c7c485d2d4041b9610eb221aed05182242cde059461c3c0b818d4a0c03c83bbf864ddfd745f9a937ed2936394287350b4ccac57c6601b65ecfdf0a81c70e6e285dbfa38b2c47654621f002f12c1b33a5d4e23b45da467eeb6578f86f6840cda781b221c3f18b97ee9a2dcfef2a9c7fe16ede06004d067436990090c2585ececc6ee86964e02dec5de68eb3c64cbd016e25746bc18c491188c1d2c7fa4115bb05d1c8285ca51bf7090fe68ac50090f3a140ae70d88afd2d085b8649d146923f1facaa537badbed807b80d662ba08b0b728dd9f2e1193419b1a45bc6bcbd2418c07ae1b037c0b225487c7db855d19d05c4dcbd3537765cba5410df7b2fd08e030a4ac17b207bbd4cb9dfd6baf0e3d31db8918784055bbc3bf077316ea1dbabf74c831e5f7518556550d3e372ac08b28d3082ac26f5b145face5a8253143239e8c214cee939005d1eaf77063aa72b7e1bb6f656eefa5ab54d451f953ed61f788461d8cd50279074d341d1691668feb7ca4858e9d6c907e4e2401c4dc29077416014ac9f1345935b8b59beea17ea7d924471b9efd8c03971ae0d9bd40c663029954e9068f3974208b688caac6b1e90db97312e01d8d8cb97073cce05fcf85ac5fcbe831613a58299f07d9869d42bb3c84f0f448a1d9ea9850a457d590353d8244d423ea95e07fb494530d5ffd538fa03b85484d939dc0d59238cbc4726f7139d3ab699bd6a0aa99ba728aa1226a4235e6c09f038e7d3d3d28ca16ce021a2fbfd85c90e66281bcd2124808e92d5f1f9d46baa3577d93e58ebda38671baa9a212651f8bfc72b61bfc85b80da9f4d6aed850fbe6512c3b1740236bac56463a497df357cace294ae31493ccf5915e9d6313048da035c809e8285a23b711052196a82eca830585de3fc564e83cc0a965dc1b25cc0432e1db47f6d89c0969505151d5bfdfaf4cf02382dec9ea91e409b6411a26b5940a1bafc3da0c14b974a5ae1ba534a5afd108e6341f8f4f86bbabd07300007223fefeef8543fbc207342018e957b88802d6ea17b398ac4cb5a05133f6eab839537f6b0c89133f3a114aecab88bb776e409612419f09dea656c16b5f4125a3cca32a2c0938707e3663d6b8b2c0a982598d9b4c8b30ac2fcf5a71f858c0f121e871a09f8b2b259ddb6219cee464432e93b2143d405bbb5f30dabfb20260b2bad0be4cd45edd8979dc1905b57f50652ccb16ebf50ce68ccacd66f35816138e06406d5a45cfd67d1ff2251c29fb378f11410dcfa5d39886f3d6d2e13838bbbec5936ad912c562945812d4a02926e50fe89ccc29001572fdd5a0bc87c1213e829ac54a8bd5e39294e71e696941c1678698f5c9eb4bbd0c5b3dd834b54bd629eba7d45808c983b1f6556570f3d2ddde0860306105f3ef18b52632fce3f7d8511cd4d129180758890113d29c1f46e3910a1b7fffc8478a7e15a0c8a86510861614af5a86c66240533f6e2f5e79a997bbc05bb70fe5c69bc5c0dbb1242b2018f684a596e6928496b605db8962f91ad2748132247db5855f27989e869b4781c37df347cef335cd61ce99393e9c78dbde19e55099cd48251574931e615d6af68fb1830e742b6141c7347d0fe89f03866d4665cec8e188333df6a8168510f52a929de4180b4dbe97d2302d4dc733d3d057a0d44200eaa8562a464d429005cb804e00d4154df4a7e7572cd8c56c6f35b860416d80f4b164945f3551ee171b0e922ee3dd3746e77432c27457e49c9baf2c463c4eaa5fc1b2e55e84142773acf6cceb70becd25377050d1901fe5dc4f82777651ca2671a0994457372a88617f47e896365fb7d0d2630ef70d250fd8ad269a1d1b8d615d45b0e7947953867fbb8f82093ecc07501ae06f0699fd383e57d23427fda748868d46831683a375a0f2d522b6bb988dd8e5693d693882cad11b7fe74397496c79b7cfacce01232020fa2b13ff0b4017aebb24b37d2cae2ba2c8680ad70684ccc01923369eb6c08b2ccf3050a85baee3b5c7657c13bcbe4df0720766037f093ea6f3a745f7031b3367d24ac6f694e34c533c47838623335f49ad5a5f7b85e1980283841adb9be0a4b930354214391e796c051b3523d11987dbf4ddcc3aab83bc818191c76278c5e9468d01a3e9c3e3d08526d9c53b39e550b80abe04bc2193989f124ca73b3e4d373c7672e2df8d45a78c85608d61c02f81bfde5afab9fb845ddfb173d0e7c7719f65b89e3864524ed14e54887da35e192aa967a49e8712947449ccd465497a1e3f8e5aa4a56122385703260e781dc0e123be0688fcd2b4f655523941ab242aad40c461dc386c160a8ccf39ecc017c52d19ed38d1772b5c70d74e2a53232b020d75c6a0bdcec0d2a7e97114ff66f49aa358b8ab63a4eb451d5230351e20ebcfe4c6470b9825caff1e82b2d7fed3771902c1fbeb6dc2840f31e93b7bb44c18ad3244d152521210510b6e3d507eabfcc8f1169b1c503631c8d29d95fcff95221dc492a06a5d8f55decefef653e219e8d2d9c655507fe0de978befb3b694ecd660db1927c5460fcfea93eab27cbcbee0521ccf339dacac74f9323b149e9e50eba2bbd4e6d6f21c54e2fb489236e3266a0b0db1f27171b70148cf8404324384b17013f43c45f32690e92d3f36d24a32aadf180d936ce5e22a2f52ee46923b44be6ef6fa2e25bc257dc63d0b5ea5d6b7f54ca1e233f12d5a6c3dfac15e865f0aaa33e5d4b3cd44b62b3621c592e312da4c3884468c861b7e9ef5cf32d613a888320b8d506ebd336f404b7532da2bf93ecef13402278d1ab0c3cc38e2faf85a00508c675fc1dda1d407af9c9c9f0cbd45db155167fddc2a4fc702f7dc45e1205759e50691d2bb31c9c6ee900b63ae15f43c32c99c3d7843606f724374933b22405aa81700fabec8d034a6453f305f68eecb3883a579d90febc625194b9a84034fb72a95386aaa662e6b2b1e6353d5e3416ce3ca67e7463845179c43f633199ac4404ccef2ad050cfc2b1c575b368e14d928a0759f34664f3d078e56b17a027f3a62e19cfca5bdc81e5eb0cd7f73aca6a40adc8c45fd6d3ccbdf78362ca2f9e8e2f07e39b571dadfe9b08a959def576d7d7036b8421d45ddf888e6a0cc384bc57126488d1ec6779d9469f4494e60d4467c2e12223a7108ec564e2925b9e8f5c91119c4715a42035b4291474eed855cb294d69f232029db6b03b1a1751d34b038dbf934eb81d46c078fcb474516e9e04e72c4979478a2fb8697715fb18114e0e0320c3bc5e79835ebee5fb3468706b1d93d96fa2a3373ac7e5e28182740483bf5918405222e13641475310e63ac60295206a11fa141d1014101a4fbd0565e8845760fe424294b458a66670dc144aceae853a3009b12770926346606fa01cfd1422cd536bd7a34849d6d331d7370dd0adc365ad720063013bbf393dbc3abab4986280821944fd81837a65850e83eeae9c9e52c5fe403eafebc83775203a14a3d0d351cd0f0b40f6a9bc8340168dec8e6aa8b588885f687a1758a2a894ee7f7e5125d522cbb5f0389764815f3da7467e0e88f3c03ec8d2e15bb01ff53e5fbc22fb4211fc0dbc0472aaa8cee97bafc190b33b3cd1ed1bb281cf6c19c94617c5f496752448656e1abf3e37c3946a25845c2efdc8efe6df563c24334103132586c1aa7627fd95707308f33a693e7849698804bc99b6b0874b5e8ef94414c3320406021455faed68f05376b6290dd288fd50227966070afad681cfbe241ac50155ba00279adfe2a6d842f14c6fe54115efdcd503a264cccfc7dc9095ae909fdbbff6bfb881679b9e3080c4aecffbfcc043d7c2d731a652f60737a209361500c02e0099f2e9befd39d5eabba98626baa854beca1d51cdde819368b67195d12a0c3e7f0bb7df218d6ec85ef0757e764b87d00674148dda870d6e5cbc4d1476b30890f74687b7f64378da481c37183347c4143b0daa1aa4c6cbe35a98d9d61175204c73603e6814dc6cd00953b0f10ce6a5b3cbbba2e703c9fa0879297458793d95ca1575e03ff265f9a9b569383dc5e94df14ba7204f34aa86e51c00df341bc3a8eb57df6b135f16b01bac7da6ca265af0e8ef8e53d2f69dd9cc1b84d0a1337a8cf0901768be4d5a23a82deff1a7f68866d9280d7df16417bfca2f30ce5b117c81c7a2b2cf789ef2372465e31a9524fa965c0b0a2da0c325d0f69720d25bd49038ab1cee418a6e2d4b8a129f9dae8d07e64adaf9cea2485f477f03d72609bb99b0ec600af2a1e0a11946d18910f495872d1fbe0e3090271c03a9e74095da90234ba249616044c3d1038eaa3183a8aa9a8c84d3b673c7d840476830e244d1b19e6fdbd6c05bcf336eafa2128072b3d97dd345061b144c4bbcdafb0b16db59a2bfab1b847ea40d183c1bd7730787bc1f91db15e7b758a966992baa6837608eed4519ba45a1b611564788fce29e0f88d5c11a26746c6ee0a3e3327efd8a31774adafed080d4a49f3b0164903009f97ab9e532770ad0cef7beffcb607216eea8026fb497d6a48e4c0d8706282abeacd1a58bd876d39e5ad8b54e78a5f28881af27653c3539fd06f6d0d66463bd557441440469332b0272793e782eff237c73575fab3a030bfa284526d95d89c1b9c041ff0b68113ba713e191e2a40aaed97bfe44420a1b0954480d8fd5db81aa31e003afc0c292984250ed599b2df105124eb7afef43045f617c544424b07f241d151509992b6f19c09479a5c92185165bc595bc5a2e02b72bdec2eaa386667911b5a54d2c1f9e75886ecda5cc1a5af1ff3203c863f98a20f342da55da62b01ebdc48c93d3cc5b72171df8fcb62b4bcdd533d90d493b07ad2428261984a075387f702adea3ff1446183ca1bd706d870f82d6fdb22c8ef905a7cf0d34ff57570eb262cfa2e6255c331b4028c215f1eef3de545e069eca52d5a3725b57091296aae4b1ffc87987b28b2e591d4717015e6319c4182193e4269ec515993a83aba7c21b935190e56dcbe33aec6d6b501384c590fd7524464c370043c2becd636f574dc18d26ae1c27909b428be71190859d94ba77d6d64151825280178286b0fefe7f6a5cd8af505d0ba29c05bea2556acb0fde62878136fbd99d26e290816ca8afa03477d6be4b0eb4112c5bb7dfdcf962828bee15ebce9ad9bd001771241604289db16074947eaa6201a308eeacb2bbb75360e4ce80c32a2d0de4028c00d3a9ac8af175a42bf564b87579c1cb37f065751b9e53e067a70683c34e02bb34b95736acf6b31605654b86810ee64512a751d395159f52bf1905d156b3ab709f68b94b976cdc737eb6d96d47b816e91230cc51ac78f7de223c70364cc2214a043d4fb9349d26e94309540078b1f1472bbae0e84893f523c31440cda29c352a067983868b1cc4935c0981a7674a89c48fd3daf4524b300b9956e54e9359ca7016a9f6c29b1fedbc99ede995b41617240a0c9ab53a72b7996533f3584d3e2c6a0011346173ec65ec01b23578c0c358c0fc7af9173b081689c5930ee4b510967c602eaa2fbc28f56e66a41854363cad7b2ae0984cfec4fbeb4e96e5d559956ffa7fb02cc8991dc870b08bb8606ad9455950e9406c6b592f9d210950fe58fdb8ac101cff9f60f0b60fdcdebbb473122ef8730552e1479f462dad68a993a7dd1981b21634bbcbe9294d41493c87ffe26c1344572f38ff84900666250402bbe0fc1e86ef30d48521463e973a42085da45dd18ed0c3d59a56446cfe06fb8d63941d79a62f20715800baacf3fb40c769d0a7f0c290dff1764538a7e37f65a996939fba1d841ba9b90abfcc65e757b9488d38f884421da665881021f1c4365f1291e56ef5ec76eeab0d204c54835f82642a13fde36fbb80ebecfe4c8eebb56b13906ed4dd22829b48a0f530b6824a262be77b9171bd08d8c7154f5c0e90fa4691d8fa696a7835020c1841c5d549679d3473b4f07d3774390e8fca31f8c8f30c524a5eff708ec4e0f53b3ac9da378119046f14693918ff3499cbea0e0ffa0d6dcc21857c905c558d5039e1d0505fc174d2faeed90a3d1a24a80c6b50919e7f5af72841c03bd895ea3ec4c84fe85075c307e239f915c38262b98d49612ac3aa4ed0f464480ad3789251b2131012e1bea8efce99b60d8bae984ecd3f6696a61a0541d275d643390998aca62a9789c04de27e5644fe52182ca337614e3961df5ede92c65cbf8a5c6c0cf4045c229310dbfe9ef8a3a42fa34abc7a606e7e69466f8486615ef139d4e257caf13eaf634f6188bd04c037736ea6a7bf783463a23f40802f43bde08c80528aa6422f4b869541100a3ad677c41d28185c86cc4c3b509dc01dd1581a1f09635c547ff7b3bf792cefe3d3104040fea7302438492345dde3ec9cb916a01891323a9c34f5b38ceabe47c1919752dc444711de5670f702142570227e161541c4d1a900e32fc6b09b4e1cf4082e676647ecf0404c70c575bb90384078b340a4f4ae76c5c1ba1088bd518c4fc14d8c32e0cbc65c0a2cee3fc6edd5ccf2228f93a93cd622082c2cd4ee614776d45c67021e28ee6ec77e8c437f85d923ec6375a8d3d1500eaa5d465d08b9eee0ce59b9191dee77e77c37695a57a546d13b9ccf42bc8fc5bbcd2f70952921c20694411858e0225ea94d7d86d48e046833cd401b72ce94a4415233dba5b983e06a662b69f21624abc613d80398ac2177667f56489b48fb45e93c95636dc8c465aab680f040ab0c773e10e05cb129703c1000b5fc0dfc4f32ba4be3d9c738a9d6a4086c0706ffc4d1ec08bb5f9fa7df24a84a3924857410f2cd3e9186b42a0010fc0545b644de56e9ba2f209d9b6f95b8eacddebc8e2dafc10acec466e455d186e27443134b6e27f591f096de8bf365756a7eb12743c33ef03531a8e950b450dbd170524385d6d2ac9469357be0fce6a3401f647c3dbe8e8343f13000f3b624ed16f704855cf53804dc2af0fe7210abd5319f1f6558d5ff40a4323601c95ad2661046d2ec327f660e6b69aedff825b90b6ab01f5354e03d653ebea6270688e20095c6492fb5ebb6268851e95f27e167b77b19797ddaca6518d7283ad3e5eaab8ca880cedc37f667688085d4a29c1d791e002d983b3c31a87ef5229d3083ded95ead402b78f716989e315619b641f11203eb49b1a451b00701383e382e080c84d2c675be7eaf48452879f88d7516ca04baf1d5fa54d610f9798cc7928de56bfaf705389d6ce4438a16b7848ebb9f6ab418369c51f72f5bc16e926628666dc63148df66686deaa9d45aa2f36e54f14538ce105ab35ac04c44567be15387643ff0fdb6cae0ce9c3a85ec15cbe485e0b4e96cb12de946be7319c3527b8cecc58fc1a92e687ca66005e87e91fa5622e978abf8f508316a6ca220445901048167d8e7bedf98347600101d1c120506002028eb1750ab4c2be3473d6e4d0aae7c2cef6f8577a200bb1e6554b26de6e965c2594d76ed3167b341c0c49b48946902a4d808b82e1a36af0594909891cec57a4486581e37c04c89daa2181de7104f1c8308604ddd1e029b747f9b7af0f228b8690cfc0c9b68c5a34fa7c4d078dd5577bdd7bf443d9cca7823fc1635b5c0fae65b621276768c030c35d9d073613591d5a7916ecf5af7cdc0897fb68432d9e93f25ed5318b86a6a0da8e4126a42a011be885f0bf5df2071412bfecef2b8cbdfa90bb7e2ae8702e85bfff1e732bf541dd2cde0f5e39f498b65be3b83933cd624465b722a4e52e3038d4efe310be15d4735ed0570be421de546880fff9d502ea49ddb98dec4eafee9c93fb1bfc77461fdc35fb034092401cf74a125015b6f09e52eed0138c4ecd49ee64380515da49957512dad8ee044eef060b7b1debc48358e596e49f3f82fb38179e4d3fb25cd99af884caab2f6764613ef18030df31784ceab1bb40e9382f4aa696f334f908a370ddc14b70d316e9ae93f82b81b2e66a5742bca027acc94c7f1290aaea9130b9ee841123dcfcf6abbe94fc70621c8af7e09ad8b3cd3258f3621e1622fbd99c661a8431754dd49f7dd1bcc8a40c81628f2c0df6e23fb897841dbc7b82c2ab877739ad4e43f7466a987c20c4a4bf0e286fd1a34c02194c46280ef30eace9cbc62dbb1c21be78599d20979a5d8a4ecb31b5e8125031da50d8b3e645fa062639bd1ba340b2e22fcf06ba4bb2c58424ded7fd7c35068966bc859fe48fbf1c2e770cb89de049fc393e913a487a0c228c6c66f564f60d4c248247a51912a1b023ee9e92d43b3900ace1e1ae30201bdc4f59a8bbe512220a65cab16b6e952e0f98c7750bec33a11b96bb3eab5b03b4e03f338748eb3482e665a6648a6349291d068c522be61da3689a75749551c5c9e82aca10e62b8f05bc3e2882d4a30edb55d8f1b3ffa6f2d10d26f52b9a38e590aaa0115e0992e3406e09270f03a3093b26d5a9feada1e7aabeeccf8fb128be603fd7313c5e9754fd074a6e533d6033b62625ab2cbe7f47642cc719654b3b96f7aef73402b1241399e6f87b63dd6fdad57aa28caa1fc35dc11d0f6abf552a2a6a12b9739d226eb8029cf4a6b57114104a492ad170fa75e807f24c175ecd20a31a3205e51248fbbf7907e1887f013634fc21fb051d6036cf8f6dc220ed39e8d3056beed5f593fa00357b9c17327d14c480683390b57888e0aef319fa56805642d9c58965676340629f1729becedb473059650264b1bf2d6e595e7eda059f595a7edef8792c9e5210ab5322f509ecc5037e759e8242496f119a56d6d7a6b28985d7c10e23dbbbf127227460fc439cd8e9c30874c80c2a1951c1a15259f12644173088300c6b80d8b840cf6bee1f2e0f98414674ee7f323538b29a5f10736aa39743978479579f40c5ef5832fa211e315415578162ec1cfcfc0ae524fbe754e3c15c56adcd7e1d1dcd0cef8b9b7f1278f56762068242138372c5edd1f883f9ec903a12333966a5c71f6293623f7a63648e5e3d7924569765104b58374ad2c2654158b1e94c3ee075fe40b20c52c3da7450fa7a3bbd2830652121f56299af10a5739b87328886e26d810334f30481695bdfdd04650eb668628b8a487a6f045d423a90ad6fbd112059bc812c9791f9c4cdc9d68cbb791b19af03cdb7756b30e9a0d7041b58e091507df2eb039052d947011eab0a72046e9c55bc1a45f708633ce5b5cac508e2018c9a512fd48891f21888094e6ad3ab2bc8cb4ae8c804e0ce9ffcd5004872d3045cce3680e2f676912562a57f6260778ff8100ed544454f6b672e27f5aa0505ba5a648c61c13eb16579c76fa986fd82e6cd63cdfa1606b17d2004f643ae1b0fe0b13f3eac65dfe906376bb02b7e11c17438ca458b01733af6915ee5b8690fcaff7c0af759dd167b599dfc6cf9aabbca6cdcace2a94deebbdfca5c11e917e64cf961cc8c29168c410eca9f3f24fe23cacf51cf6c8317f69c2601b90ca761b92f3e2c063f5df41f9390af587acb014f8a19714c8de40dc0b234c71b2c5a5b8382c0cd9cdd1fc6e1690d48cfbbd17d60e0f325ae3feab4f9b7ac016bad58e96687a308263be84c924c03d663617ef8b2f88ce62381935dbf9a5b275a3ccebc298080083cff471d819e23713fe105c30c203e9ff99ae052fdac47aa6ec924e5a53831a5fdce3251ee85824284e0b1f45676e5cca603a45405eb98fc64f4bf8003d736e869ccd99c66fb4f4b4ef1387e0a145d81eeb6acd91d7ef274b60470a04a32d43fe53f98c2475149ebb0a425a3e87d8a16d664e5073abd6ba43d7748f54757d592b8c4f857b51f9d692a5a1b4620da0d95a48ee1b2626b75cacdb17a34264f91aecdaf6ea5e1a2a381a92af3546c204fac86a40a2f01f606264f4067a902c4261e1af98007c2c46e3148784b0bcd7ec6176197d64b76e104d7236eb577cb88ff4a3f6530b4bd8583a5d100cd02db88c64b6f5a2a456284cd022cfcd2981e8c889eb54464ef1650c1b0ea803974e05d727bc01723ec65d5dbd2c64195bc2f02acfb62165ef97ebcca9295ff6a31bfb96ed8b9c43e70b0e29d3925d43d6d07c1d058398c570da909dd23be25bb2c02c1b9a7f1885a5d0f7bb13317c76a772e698369948411a38a4a8161d0dd8be8eefdb6314702ff4ca8ef02da3500cf1b399dd291d086f008708614a1a5dde41ed364206e13f15fb00e54e5e4fdd7580e5bb09b507c542b09e2f46a82d558e6c640df3164e51d9aac1864cc9b982d6c8057ae2d6fcc31ff22533ccbb95a2df33566e071a306158dc01efd77ca1ff1a7b661af5d15330f2ed55efb73d8008efe6dbea3c03743cf21e8f5a6b0828900370badcd8df6e51610c725378646c5fc300e886b22104343ea1de191b41a05796c850e3b59c32983dd6feabbff874253292c6e464e00442ee1586b0b9452002650b7e147c55ea8aa6ca6129ef227f7b6d7c13442e7b01f48d98c47870328d9f961d9bf49911861d935cb18ce5246b04e0f3058d33e46a9f28d6e156dd62b5c633440c8221d71a5c12bf5b6104acea94e69955e2119ddf65b9fc2ad3d5a0524ec4fd765ec97cb9003135ce31d674d239b0a16a59b8021dd91aa215589618ed0b2e3fe62c57f42d1ed600707b5b764abf009daf8ed9d54d458a4b7d91f51a8961229a4ac01d6cecc9d9c1e0125eec0f2ccd9bc400e3a6640a1683e8596760ae73bcd9469bcef912c2109f0675eca2438a8313e7d4c06e087d1f8a07d8f50fdb963142c75e43d59801921701004f08b3ebee574a90c92066232a037b9fdd097e325f300b6f1d6793961180ca73dc58d9d5654cee84d62027f215736c2462d8e8694ac8039633419c563e7e0eddff8c591c5bec7f5e34d809d010301a55c65272a1d50418c7ed0edd1886e49b62e8e0363bbc8fecbc987fd5bbe31d1805251d88514cdfbf7d1a113504bf64133bbd776d5af1fc3e7785ba58d4334fa0033e20b4ac56974ea8b35bb11b8de12a3f2af067742f0774b2cc99645e6e3ff048887514dae88af3aac78f2257a5c627134c40a14aa10f42c8183d01075a6e60ab94012e58a7164ef0d714ad96b27d0395a7d9df22af6c02461e475fb1c03aca0e515831ce2164b70877ea4f359036289e1c257963aa827eeafd8f1a184f3dbec109f7728a9f03fba01846a9d7121c5bf6957a00a3c95e2e3effc5cc96c214450a383cc00eebde608a37f6e52c53802b6820b1208622bb870204332df8cb425c0230bd3faa6792f514462c0554c96b39301f7bc884c07d0b2b0ded407a6dc6829202e89904385e4a6c2d0bf3550ddf5007e5d4a18311882362ac5792cbf12b0ebc6aa7a358f5b18a72cf9821d7f804ca206bc804a0ae734bc86573c67e1df8b8e5f119274766ce6e6ef295af6706876065bf6b7535256444c58445f70e80901587d9b333a6f9dbf1440173af9e1632565ad9bea741eff3896e64f17d73427b24bcdecc50b80fe31ba345c84fbc7b3d82722a46070faec51879c1e5fd0b854eea3e09e2c0bdb009a06b7d5188c9aa1f904185bb3bf1fe192b7eef5ef7791c7c081d986b0304e3f9d3fd173af2d3bc06736aa03f50ba787f0d497509a0cd7a16629853dc84a8c852cb0c9b1cd72112120e5ac57f339af7448fdfd003dd04ecbefb19fddf55778b869d191581182c84da051f55169196193cd91a6dfa028b2e6411c7309141222c2d61947e5c5230cd69df1391f3312bac67045c1adfa0caa9022f5cab051d5302e36541083110d2abd78e7e1abb6222e1d488dd89a20e75a1112c001c4fc9f8747afa88516463aa48bfbe606a219dc30cef0af2f8d90fbed0344806558cba64997210f779e9e45f2b080c3499416fbb3eac1a978318ed9f4fd34c6fc764a689177105047697acf52d93e8472a3190c6798901b36dadae0864eed48165ce57765d61272031a229d6605be903e38b3ab044730ca7f0bf28c182cb4d892ecfeba20ee72dd13d7bcefcf92a053ca91ffaf301a486ad92fb396cbdebfb3920864116a41a1d9dd27f5ebb53e4dc6a6fb4d656a6f4678b7197132046141040add4b2a135c027da490c22ce2ef5fef5d569ab94275f00b9be8a1055fd0055a19870788f1f37e61e9bc24c8b4f1852ec1a2c3e622a73ac3aa7fe57c0d2ae1bf372047d1dde0b6e46069d71113e34824b9bfd6d7206d706b0df6b389a17441954b45665bad78ec6e24a5d222daa406158ee49db4f3d964f8d7d908a132a805b65b5439f62f2a679c764b7260c2eaecec3a35019a0ad9fa4b35be9dd113fbd9e3858ea8f243c038bf283856a14642f6cba12abd3b9c7df3843e148522d2a5906b93e035ffadf996bdf6c648c45c84aafbada85302d3053b4c9ad653a57490ae578358f6bbea9901146417586e9a11e57cf050a4d574fe8087db4b98035aa6e4c84c416f19832c0737f5578829dfc64c38ce32768adb9c81cc655ac1d12e19d0d696da098f8cc2d10c66a7fb8b7004e71f91376f2f35230988784b8e911eba83ee469078ba79d1cd8097e472ecc0d5f233bb558e6dcb17509010f71c225cab060d5991004bad2014e0ff4eacae4337dc325acb80e63e9c5963b7ad6e52012ef07748b21b7b5be9eb79dc97fd8820c848c8ded194317ba556b9b58e364ef82b6986629f56d4ff65aae25e90e94271f0825996302c5cf2833cb825895c97431e5f417a483b8e7f3a61c3fabec64f8b0688be30a1588d2a337a16eca94e4228e6c5e608586cf6dd13345b408b2650a62073ea6e3038a6e0aece2bf6800513041f4073de9d53888969ae66142d5dfb7e2f0ad8a99607f2deb46db4a1dce01b311608e7562587d1adb9a1e9fcb326025410c629e0aa2148a5863d6a9c76b353c67c43ecb158ff0efaf596570614edba03f98e9f55c31daf8a7f4d8200defa06055e14337a8db6af16049fdd257aba5f76c54556489ad91466f800751c79af635c37aefd3e665d57c830805428f0ecf2fdb2caaaf55e2d8ccb7f96219c2fd5306d931771d8e206a761300e50a937782372767f7edff86c5adea81bb92b8128cd17c23313bca0dc00db8bae083496e215a0de67582f6f20ceb75dac2bb4afd98f2a6cf9dd780eebcd6fcb66203bacfc293944cf93aa72441c23df722f07c07161bebe940464f8a8fbe6f9e3cea2cc834b7c30236d3bd6db17479b14bf63b8442aba68ac1e2573b79536e6155aedfb17b82417273558261b97f9bbaa2a80ea96273f1e8df597d91df824ace3452377c5b96a48bc8b434e838d2d95ec218a35799e81833c067de69ac2836a0f57cb37dc07396ae0bebd0abbb1072bd0fb0a2c30b2d9155b304754b175cd6d94cb4b44758ebaa38dc8aaa5957a9dd012aabf7620fc425d05a30979ef357253b1227b89569b685eac691d45aea740f30701b341b51869572430f1a1c70df06150df65eacc14a1df08d446bd51ba730056b143b086031a500a2a0129211b4f45fc11b311d37b0d9e273fb6b3dbd0f0cea5d13b3a67e5856a51af7835de2fa32904366fad847229dd4af2a72d3ec12cef9e301d8ea34b18c6531867e4127fcacfe419240b427c662b6fbbf0a7b969abd2fe6484fd6da591b8e03cbe21dfae0809d6de5b0418966ea510503b8f3f3599050b6dd7e11924f429dc69b2d1f82d9305a7401e716fbfd53f8d51b0b7fd5f3ec53eb0fe8b76062ed9260a740626f8ccd3cbeb38d646dee589075d039ef7208f83e3373bcec38b05820c05fff0b681ef98a384bfb1b933198f2df981e8445729247cfe186dfc7c756683914e5df31296b162623309c2f86db977e1acb8904f8ef9e3f3665826c1c2ddb5c3411f8424d040afc982042b8845f734d2a7c0bebf0f0da25684e54bcaf4062271a080c3a9b81f601378c9ab74a3a22d8b902256efa8c48c3ad3dfdb295c5fbecf286eab755cb8be7f5205ec61f17bebf8464f817713224da978b44f8dcb9a7cf720626b2a47aa3360b91d712477ed3c61220e6029802a904ef16cba696206f455781a71bb73f0127bbd002670c9ccf1f132ce0a32be28fec58d7418c1f3c5b4b0681c3b73fca26077a88939f4960ee07721f1859e33f9b8b2191022883e724494588741e2fb858c1c823b34c20c2b1b96c609cb396d4ef7891870ac572c5d5c60e60f6709bd613e3809764109305f01adae46105e533602452572f8690f09e8ae449ceaa82386c90d62c22c5236a31aa3589c6ac38f864238ab0bee3a86dfd674db6281557a9e034975d3da35976d6a3a42cd87494821d9dd5ca0cec2753d1a45f6f2dbae438fd077500bd3268389c57793af96d834854b5f02124dca720def1c66d285c63d316ac4bd482bc492147c60720ca0de0c1f5bc4608679e1226a1150a717a45c66468b04714ef17f88ad968169a43c80d6c7cfb8f50dde222eb957e7ddfe5ab517e8d17bc5aa3426097ab67ad2b6cb2d5a56e70494673a465868277ba7d2d3f5654d180fbb6cf727fdadb85260e3383e183ab0db365dd8b661a2189df0a9f93c0fba98640f5699859212933ede180d2056bf8fde789aa1317020d220b5236fb351112c838d25f3bbc054a197e76e4addd2b0edaaa3ba1eae32a39aab52c1a40d04f85e281a69e5f24502deabc3862b004d6ef22c6ef0e97bc0b7d3abccec9f40517bcc06cce9e5e83ca14229120ba21b1e4672f6a60b53543adb6013fd60c89de7bf59622350b5e054260ba5eaf461269d222dbcdbb3b3b1ed46269929396bae63a0ed98db64a35791f5a307c308b242182d1f881335e7470f24145446a9d71065a02759047d439e714783dba45693f8f9de0e490b834bf861c68d9fea284f4cb9c523efe3f9393591e25ec9cfec12f8f37bc8e42dc3664678941ad2768c73927711dea2f42af9256617bd527f339c68c3f95bef715b442c3eef239e07525cc8e68d2590e6d4386b111b42ac60507b9c4048633a390c89ddd42feb4995b8bcc71d27acd4d4452d071d5f1a7327f51b86b8b0a747f1b46faf80789b81f4c323f67256603040095a34d6477f47a17098d4661829be1be804e3d69e95fd3a0a3fdc4457c76de7908b73dfcbd24cb5cf69041be019449a573b5d6a972b1dfaf351e4c20224e70323cde8986d509413cec84b017c7f3de1349a6b78da62b5389060f37d5aa4165bd11c7f6238de1c0c08deb6c760e108897a9e5a53f281e8863d1c4758dc0a15f3e3e927cafb6f5bdcafa920bb86924c119c44e1a482208278e222140bac402068280953cef01e60838b1da8898112ff941a4969c496309ccb300fcdc7ed72457a131f67886587344b15e2c0b8753faf395b432ac1bc82af3a2e0967c250532f0858fb4f6bba4479952b1795a2164a78fa9e3aec4203aa5131281faec613b4489109bfb9d1a6ae516af4f11953d65f3b1bc15f2d66a46ed473caa07e321e697b06483957a0f1aad5dee791b005fc57580cb4b4c0872f597d7d7b5ebe53b9c34983eacd97a18f83cfc5697f8f9d01fc280f2af023efbb1a795135a1fac6d66ae10285bfe7efa17d4911fa650b088dc6e393340ec6cbf9879649c27f59733638e4c1d260fdf808ec9762254e6cb8b66e2694933db23a8052f11526c75083f212ce0b63831f5ffd93acb91f9716d042706c4d6ce06350b72b341cfe54fb30721a97e5a2e203edbeaddc482a634efade976873fe04b93679877fa4e17e1ea812930c4a755365466517cd649e53f9c7dc99406f9687c1620636971419c85cc37539c80823c9c4472e50a7c5e95ec1bd725c02bc768d31154bd70da3b2e7447ae8b438c6387d772904551fb9ec94b8b4ff52c3d9403a6421f946e10197a016be6e401c531497ad9ac3317465d6dc5f676bdecf28a67b05380d5205f05dfcf1ea6bd031f704d3819bb332e8a57cf1d74d66c82470db235f66f96483ee3b6f80b4e6ec1709f26c59aebb28d54b757a3b5e7d4b4ac6f53f596c6d9f0deb1f2ef343311bbeaed4320f22837114d58880d05b250203abbda419731584f001d30e633aa6f8395c04e1597162a0c3ea572e58c5b423eac970b180fa25b770b9380c120bb37e7968ad5da8fb6a58bbe1ec88f368a628a8cee426274f5a20134d933d785697cb3b58859573addaaf3e0adbfe6d182c2aa56d8e52d0270c2b44813560bf3739ee468ebe74e1e8d910885dcc48504a661506fd7744fc0091f8f26d08893dc85b0fc8917e273f129350bc268ac897f1792c2752112c64d3f2c18b4e3fb38782c3354aa0b81689dd087d742895d23c98aa26727e61125f764f4b78d78a6a82c543ed5423d88e395c2ae7e279794d67a6159c0faa5017b0c4bc03d231d53cdfc3abe089dee5c4209fdcb93acd3c802bcda62170d47156adce77cdaec5b6801e07adfe56153b80325d3a37df6fef3bc623423daa63640d08dd15a8b7a2a4f4650951702fcb5307980ef1fa87d53d874931b0d4e7198907b9c0cd1fdf87a79111376184e88554b08143c091235197971cdce96407d2749fc271d286c752fa1981c2871cc049990f6eec5c51a657fcf4ee7862f578562df757d674f80edfa86a826d080405b1ee0246e60e978241a6db45ed6f59a90b82843820294e269e2ea0e6066345992c4a607641c1fb48eabf528b2cd2ed3897fe3be18992734cdf1a1b6a0497443bb6a7688f70e0b3220c5d0c73569e889976c70e0cfdd9111ab1829919d9b8a840e6435dcd7274238cb8689abdba6a0b6abde895655020f6f4d28f7edded0ceedb8d77c64b098026a210ab6a5261ee66b6d73a4369f8001ffcc67b25c6760fbd5a8bb3c4ad8f3f50b00a85ff61a8ec6e96ed2ca5aa537f9b115af98f82f46c15780f44a57409c69884bf8ddc48625c4376874eecaf928426e751d125a4db14af2737e227c98ba713f69909b2b46ff00cdd9c58e647d9b9e1762da520607e8b39baf9b707584ee277c55e51b8ea0e9cb039f2badc3b1acb230d6da22f8525f3054418711c66c69fcae312bc3808f098c17ed489c9861702ecbc2f9b9f4e48bea2914c8c158d1804b30df29af34522307832faf004ec720a0abcb5199a18ecb816e6fc5a14f5090a541d264cf9dfa83c31ead138ca5615b8b72d94b321feedefa56e8c9b4baa64c358a974f9af29134fd304b798243ceb3477b032f2c638f73260c9685623c57ac0b33c450821c78b6be2f9917ef5779b137c3a4e06c28f287d7645cce97c8891825c1d442cfc38af9b9b6e452c90a71f27b55388ff34a4f56b5c5c1cd69fbf19e7947e1aace7b60378e375ee65ddd702f986d9c24c19d1ad712026fe021b3e98b7254c64634364626b2ec625082138c9517441677e0568326eba12b939c04e473641e49c49eb2ecd72bc0cbfbe8aa3a11d91e2c32db1ab2d90dd16b001f8b4d9711d3f684124c6d9bc2a9dd885536613d295d11bc51ac7b2005a4d299a6952a903c06235b2f97dd6c4cb364d41e43bc3b445b4a2afd81b86b222729418a62806ee42af7b877b67f9a1b17ce61f9bc907f2be311b7d74f70f300b4ad76f08480d3b6aca0b48ca68a57a3930f54f438fd046ea82fbda6c6cc76a87ae52a03f006b2b75b0b6f4a832e53d496455c3a42dfa667a8d380a72e8a451812f4964b21b1a67afc228554a8488757a01523d59048a5e4a8b1ee4ef13a45aa4c98dc39ed77642bf094d45c41e83919ef5b28eb06e99e8cf76066173d4b6cf7fe5662d18a8afe4c1c26dea11e79857135d25878abc0a02ec408a62eda2d7a6f861226c9a99b3daaefb4fa3cd07b9199609fb27c0d1af0810bb335c28dda91425542db993dffb7e127725c5002cd793f33197fb82800a076178913b54359a44cf5328e149cde8c1576b83544eaabf341deb45f394da6230e0862a1c7c6c10bdc66358771b5a144dd2db223b595f8cc32bc79225034fc05dbaec1302904c7291091ea791793e7adb41ee4b22564198445745750b274751cfa052e18f550c0b4a60645c6cc6eb748a4836e3e75153787496ff230f6b5fc9abcca6a19ca4288c1185fd1f27988a21f8d1784b0766304d2da89be3781df4b8807fd735387a4299674a0c2e6e005fb953b5ff8b1f6715fe9c71404a246f1cb0f06e96c8897f271a17556c7ba0896568590e2aa41638317bedd969febc50112bfdff8744e43475d6974bdc6118a322f69fdd07493254c9fcb47dc2cf87d89a7cbb65e2d2399dab7667174d7fb21e427b39614e2963155f18b22ebd8ae875c2dcbd8e864b903c13a8d7d9e1fbe7b46df27820759b844fd5bf47cc3a5fe53d3d48a2cb344217916ece7e6c00cb847ed9918a887c5373da3ca224341025ebc9437b903de8bd84d977493f3125774bb0fc9f6fc94e7a4af7397f97d60356babb2939032bef769694d79c291356d658ce5441a67ea118ccafba69a4c8e100d730389aacf46a6a49023bcdd9aef4aecf81a3a0b9144cbe9cf3cedf8d8b4040c3f6dae8e44a38c7acf6e0582b709f90fe38186b3d82ff56b800867b1fc4102bce2ad5ffb856725b82f08a7974f2ac14e52f75422834f1c589c6177166ac552fea5623afd8587d512973a993551454aee3e0ca01b7d9a2ddf44b0a6b563ae335946e1c485a2f149787a4c6e410586f57b1952f53c75be5d87123a0a733d3ae465651a508f172ed5a1768c1cdf1470cd7f1b61fc76c67daff94c3dd33a5de821f08b6d128fc6e72ce24821ea945366e05f0cef469c064ae33bf48912f1b03ff9ea20a5e7d0f2adfdd48d5de69812a8a921ac48f7ff90b832819e2c472c82aa584360633c32185fe92257eed0161b2f8ac8d836c7153f6a51957760b35a1d6d665b58e35a1006dcb37450e0a6bc425ddd4cdb281d5254f991c0a193ae1c1824191b8fc29133cf0f180cc62b2bfee3718f875f909792f7c51c2a228945b5413e15d5515e721576889f942c97657382c29e6bf201584929f4fbd60cb1dedebdc87952e8b516c069a701a15e0bbfed1af9517de5e85ddce3281d07dc20f2a0a65411ca6d54412d5763e3f8443e889a7aa49a831bbfc9c0e84fb1f04feec07c50031c2fe91e2fb02ce28261508e48fcd42027aa03d27da747b3de5f95f95ec1439262726c9fb27a676d70e0ecdb2472570b1e70a40f853569be95cc57bab0d7e57d7a6904c749dd7955cb55d35113aa481be3b98effc3d662f7a595dcbe57cc00cd7abb613a31829756462e2a971b99e8283556ad0469a981590da86f1e14e0c7fef61ea00ddaad8441bcd631e9f68c3ad1e420d59d24d184a3c5e0d1bc3f230a4d24fd4430a2907aebcf28322a0cd9cb368e53a3420f121362dfc4843b190fa026f56f9f006978e6913fe3afa1ee2641ecfd52cb0f1f5f1fa68517d9a4567e0958255c28787f6eb294cc01dde4a82c7c3ddd2934ebde822a2cb0c1d0343a7e4cdbc638a9345a78f9380a96af9ac1131c6d3544e4e734cd33d4e08fe77fbc32638b88b7a61359c79462b131b4a53dc3be738de25aef21dce548b2b462125d6e6e167c409bcfadb1dd3e8fd937017be40b0e2bd58312b13438d9aa92e10148bb1b496aa41d818446d48a688b4fb65947977f6fcb0d6a113a053bbb363a85da5dc6f5f91d54db2892d977f8c2c2e404ed0d403c8d607a6035e915164a5b5ef8bd462a04f24073f528649bab27510f61af5669bd98ac7a15b3d706e751f217e4f4582f9cac9e42a310c3688226076f761f5fbf102f2c9dbe30b573340401dc9edcdd2b3a9459a00021959d441cd1f59b53b2ee7bd62e8382351bbe8b5e3f95e9e282bebe9c48f34a24fe377ca46f559c754e46746ae5a2ec32367eaacf56ea9360b92b31a647542b99da86c3c8a6065c24e5f9d1cac23d41b8810bd2a2ec55f4a52ac3cbe8de1d94916d392497c31c0767828883f938c090f18db508274a4e80d206f0aba97f07f6aaa59b062bfb7c7f5f0f9d381ceb4b9e54103be29ffb4efcd43d6a076e91e7ae3bb79e2b1bc512ae0e54648327e0e3f47d347f5113aec681dfc71800d151773c3aed31c03e45d7f9a7917f144531fb726acec0fa583849fa8d7c36a39a7deb0c8c150884985f402e50b7b384555610150b7afbdda9d5a46c19e6e79ec9e14c835e9685bca997141c73f701cce9d94f4bccd5cfa7e1f25a0411ac7311b08a6e10ab633782e8fc2799debb0454b5adc5dd77ad97aabd3eff8cb373ccf8032ba461549508d74f7062aad45ac7e2012a07bc91ce41a253bfe2463de0e5ea2ef32186121aa3c65fea6c667c55304f776c621c0d99189ab5bd761deaaa021c011a6681084af1e61ffa6420b2a3ba73675505e7428138d47706aaa4b630e1fcde009daea0a84895a12bc1123826f9d69d0f3670778a0320039bc1ba93a43658d41139fd7f296b863e6a6ddf6f5ab75bfe707f1d97eea9fae733268e17e8f703400169994590c6f2da7d55b7a446c4a59e50c62dfac0670f261a87374b894b405cb3623370e0530aaae36982f31f57abf2c2f5de9f0fe8c5d2a226aba51ff0d13108b4f8c9d421ba9030d66aec6d88b0226974e219ccdf3617568483af6fb37485170b6e3977841048aa70bf493fd4a17eab2a20c7d41f4960e91a5af8d09ca7da9a34b62bf95fccb07353915d15cdbb238f53d6dc1b61b6c0ac853ce216c172183d971ebd9e90f19c7ed23efd3e642e95f8488bb55c8d4ec472bff9a8fa8accb8cc5a586990efb70f0b3445113479dd6fd517aa15e36de2204ff7c181ac898bd7129c17017d91cd8f8c57d01cb4ae8995f7043474a9e4fc1062d7f4e8d0d95cadc1a2f4f44999c02d962e8357981ced71fe64968fe72486563b6e1d070aa5f523abca9f9f99ac43fcafaa452c72684492e40ba4e8a2cb3abc21013b23508c34565318e4aada1cf6a645ae0906edf030b6b4936460942c603f5da29ca358473e7d08d0d53c1b5f059559cfae579bc3ada96ccf0fd56cb7a0b921e408d3afdecdd7cf36ea83ab805ede9c4cb1bd30ada118e2828899050829e0fa9afd306d53f0b6b42edb20014e80183d73f9f7d06c69950d436f8cb1be43a12a95a7b1abb94090d790875e92232cb213b516b36f3d9d4a7cbe67d55568fd095c70db0a52b2e0e18dff623b24735d002dad91ad0368e0f6f1b3d4fa3b2384056301a34e6406359f9d408e308c5b70a75db5f395b479ca2b001a2a5104a5f89c922cd4d4482539ddf20d589023bb0f07c70bd3405521b4a86b12036283a768defc7ec32b08a7e63c09cf4316cb6c9e242c56a207c422f4c97cbe0edbc2d3be4c7d3951567afad7bce6a7b8b1f85468f97d63e6fa833944dd5d8d31fd0c5ffe6af822ac9245432b75deeb6296058345f3a8ee36fe42aaef01edd48c541099e3182e76d1f19df1003f14eb997708dc25a42f46fa300ae10edbf73b45f748f002400f93de9fef9fe92c03b48e9e8bb41e92c868328c78eeb53e92908dd85596f04da1383a7b3e6194763d55187e3220780a7a20fd501b31e5cd32052925640135cde8219955aff51ea08c5973acba08816c681569be9120c785e0ed54b9659a071a036ea6b21ef874512193d0141863673402613c2b0ea3c6161312f0007c08161607bd97bc404ddc522b42abdc1a8af10abce2eaa93465d1ca1adaeaeb3535e269beec6977ae59c76d0dd5d5668c92444c02b1f48dc356ae6ac0c9891f597710e8940217ddda28f1d8c815af094c48194d96dec3f397a460e1358919defcbe6b6011f7e04670e96e5928a9e08d2aa04a8852c9ee8faf5dfa748b9b063d7013ed7c8c911b3d8f8da1f3a62a87b4dcb4da545ef17931d8beea0bfc86dcc99160aa56ecd047b54248b2f00ad85d38d7f693afee7fbfa2128d018f99937dce7094db93f6bf0eaafb4d736bb8cbf5b7fb84efb93150127f16a30b353a6a9c3d9273ed790d90ca5cbbea36d80555c025cfa488e25eba5ae7d5c566d8540dcad41c80be280a3def80daccb8be3958f4e144d8a52290017864e4d2fbbeadb30200f88fda044e0c7438d8fde36cc56dab54264ce91140c7cb7ca2835e28748aebdabff0f0c4ff606b69fec88aa00b5dfdc10be5c37db87e3ffe8c858207429d37d1650772c9e7acb15bdc46af3353219b0919c792334a74a3ad9fbfa646340a8961037ab4f5ad1879aedf735e6d092c6b778021529a342acf125a44047eb094a8066fc2803844994b947123c1d4548a7804a9a642a1b99636574b67531884f4068d3f3e84d795368fb21399462c01f79ed4c89f24c58755c8423fd8b821a96257874ce559d8bf92e8f00309587029872e9a0ab108f846a386c245dcd1892b5c3dfd9a86ff085478f350d12b4f9f11b0bcca23d26af3c53ffafc6120f653cc441d675ca61e6384a09a7b75b347b24409633e3bce09011330ca3e3e0a04728a926910a36e0ea91c9b7340c50e2347270ddc2a8da6b816507f0657d532678004a8fc4b13abb08d28a85596f293346d9d8a42a5a70f662fc9cb07a6703bdb242fa139c2d861a9575a8f6207a10f8eee1d6a0d832fcb39f65461e7e734be83f1795bad95d21646a99a9fc5f0bb32d672780c27fdd0bcdd9404d343a7526291ce4238dd835790efd1429da4bf874964572044e403430fa9161dba21f70f703e2f635fe0c77c846b517fd2203039cdcbbf8ad13c6f3af43af3a8c92fc144ad1b4f8bf6a71c1ce9a238d256277e93aac5a4c0521a150bbb01a873c8907479f28d820a51639650d9c6cec2d0885d7724955b670a346725a04e2fb3b33082e55c3191ed6f823abfe671ee28921d919c6a1eb5b11aa0ce8346d739ff81fdf452ae2d74dedecc6bd93c5d0b45f94d5cd1eb40b15ea3a2524197f3ebd198520ab466c97b0231fe8629a8c273399e17e7a23a7bf9b76c281555653a07f986c72bfde7636d4616592a953a79afd01f01286a30f83049e489b395903b0fec128f9f3a074d986f9a4764350f0bcd0e54c6a3cf8b29778b775fa95b50f0af0034e1ca4ed93c4d3206e7541a01c134c62291125625a940b12a8e308e2fab3962764a80735cfc823d0d08aab4728565565d1fc6a205fcdd42228492f1c3a6f17cb0f6b5f9ca0674a8c592f11fc6a98a249a52c1e8f548cc28fbb73bb6324c895f862b2565a60b31ca61cd461f52b523193e27c598477e46d043e87012314e7234649958b8d3ea9fae87ec089af840f1304e061b65736c7d8809075585dad0d3699a7904aa1a3a8cc510ef7d5331ab1aba16bbd2d94d080887f8ce7d5d42f4816d70ed637486f5d00e654ffe14d52c3081021a8cfedc416ba75d7d6b2bc7111729e2409f4a03602f510ad65b33ebea2e98a54988e063a851ae3f3c0ff43b8136206132793b4a3ae32ad5b60358ea4fd3fe03e4746a945183085c6127e3c0b7ae06fc6c0b4bda553f12c9538a0f9f0fb86925a00000393c60b2c3b410cd4532ec09b069c89a819f95ae60af26ec66cb619c502b69188ff2c7ac883445008b909a77b81f97c20e5027487020e1100223817a1ffc7ce380412c0151956c1884e72bf1dba0202a6b25e2f2ee1c876f2f0296bf6a8f790fda128c9ce581e5401caecb39b0605606d6680cb2c05b33e8069569f9150d0ec2f9defae1fd30af0dd01e4ca75f829c81d6a29080cc9667985b76bfbc799a2fb65ce1a43382a9a512bc0c4185d562977ded362468a8be1e9a3fcefaa1f6f33374fecf3ea3e4150b0dc108e5335ad6e317f426e4055dee4b0414ba9e6df0f73f270e3701fbe2031cdf2927723840115c8a08aa8f7072f303bd4bc6554edbb2cedbc12036ce2866200434117ae83a45e59526342d1ead13981147d1b91dea622ef50c8d1f378b005fc06d5ee210b61f92c6267e9cf46efc41b55d37b800f2a619c2c2bc255052399650e2a5a8b1f2818fef77d1ade04b052d45295a6b561d92455efc1981e3260cc568f25a496a164013bf83ab9ba1b17df021668be876f9b61a194cdb92a731269fff309ee834e8563d5ebcde36b8f801bc300c2c1140cbdc12fc28e978889f12dc25299acbd37b8fca11effa843e0b72cf0b0cd474e678844ac4a41aa39b4d6a0d4f43a0bc05c4034134e14ac7444bbd301677a2b10837d4e24cd467058d47aa21cfec762bdb72794a0a2bc0143b90596fb4a0ef9e67afccb35bec6c54f25aaf8d4edf6d2d1e73f3cc18eddc61cfc89ba29bcd1f5aaaaae0952e79f042a58ad68628d515d2a6ed0e9b10e5a42736b3172dad43e4659fcdffe275750c9be96506a066e6d1d839c255446991457248e3597dda864b4f00176959fc0f3a7c6f1bcc672f2b0ccd4a5ccd46ecdb3b9a63a05a85beff49e8f88e98d3890349f92207d338e1337b34472e09a0b098cb43c9c9a034882dd34d893a364f65131a07a2f5da74f592834db75a9b3066030ec30f5f28ce8bf08af571ff4c47e8af12c6196c85b0975f88a3f089143e835b7a1879ec3443460d62b2b60915b88ba0791c6475388f47c398d026d3ab1ee8dce226203e9fb13820fec0fcb9b34f82e16e60a8efc192e0c381a1417306bce978eb8d05e958931c9aa533e8d0116f32e0cbe982b0e6fff77e19ed904fd2ecede624924e8bff0545de88763d4decadb6b07dd6115e9d402b999da3ce19a66317c02215914d15bd016d5cc13e674c27a7d0e2221cbbbccb0092031b42d52749212c297ecf6c4ee983f48ec0756a318aa168b934838d3c3324a0d2498ba3206a7cf8fe2dd13a9a5c29cff5c905caa9469760c80739a75f67f28cd02299e57f46b8623484cb00cbf6859a4298e5117f1cc41a61d1943199dbdeeeef45040870d5d3aa48763433f2370b0cd2a52c4bcf9440c55f3492e2e65f3914b0b380a655cdcd48d49608c64d981a47de3933385535bff5952d9376b4287d3ead35b307663c79d71bb4c007e68fa298c080ae047064b2f636c189278a4bb97784de29675ad1d8042baa85a23f810b601dab69161cf493108bcf7f6a1f67c397db571cdd169caec777dcdda34abfabf6ea70beacb82593c7f680a58f8a09e988f845616d2a7ea2a15bb166d04c1d32ded1ddc3be2562f6c252a7e49de157a2482a4ae92715ea1461a3a0159a990fcb344c37ff81bb0998100252ed801d8b98b067d53d11801145e7a6300e104ebe01405445f37ffe7856b66ce4ca3ef3838e0d6439df1a4e86fe767fd16fdceaa0d20c74fe91f3bcbfe7078fb3cbc7a67e61b6ebc8044cbe1a72fe2f7015aa71bc464cc078b630038a555d985dd73c2ad80e4ca6bd372829564690c857f14f3671d7f4737d7ff5367ec68198a1569f563859f5c60b7443980cc1eca7e4a0419a6ac875bfc598fb890cedf31f430ceb416d344b7eb007ce3eb9c8483faa824c7313b84269850ce88471b05838889064ca57c31ac480678f38f3d94c14718995aed836bbb72986dad40dfe4a65a24f2da03fc25042a6157a95a30d815271df1a9248c74b1cddde5f6e2a8e6ba65edffe82edb4892c5790a2d1d4de854167a7c90fa12714c2f6e57e904a07904ec884081213bc56c66429fcb8f0660d4baf7a451d822a6ced5476bdbdbb61142c82664ef2df70e5c0acb0a680aa44ffa19defe76eeb3fb7cd3cc96d0e74806897e589f475bd55a0e5b49cdfda846f490ca54327d6693e964f2ccd8fc99407307fcdc79d6a51e587b2f0af583e092252c968c138aa9a43de5db8ef2713f7db7441a556b62cd1699b3c3c3e289f9c9c0cf8f063210f343b2dcb5d7dc6f246b4ddb4d1876bf1dc65dfb4c4bebbad6b49efd997ebfd2533ab47387d96e4f43ae3b636283b4414afaf6c990be5dfbec35d35fdc4d18a6530fb3e75ef1ebbe8461a4dfbfb4f697d52c69c3dcc8eb42a6c8403991647cf6299ff6d3c71de5db6efabc97beeea34f74d2177a0cc5560aa9a5b4565219625c99819f1f0dc4fc34bd01249555faa6efe354865da67b718a9e647fffb2bfa7bfda4918b65d3b8cbbb5daed8772ed3bddf4dd8f3e12d54894462f5c6bb3c3eeed33fcd27ec23052ab6297e95dabb3528652ae7b9209d7d488ec4b58dbba90e53c91e88b2dda212d405ba347b38436cbd60c3404a1826290cc913b4a3eee337cde515fe8299fe9324a285f8a9e4895862fb65264a0f0f8087991a0eb22080a1a81b5f7a2503f088a404890b5f7a2503f08364a173af71a138a0a78b225148e3bd1c87daca9924028b3e2ca7cc7a23964b1240e6d3343160d59b8b39ee4b8d039cf74ef332d1b02b283cc7d1b727517322513e9d3208c865d349443287353dcce618ca57470efbec3fbe931e442691f289b18f787931a55ca956a94777fa1bc8b13e58d5f29efde694ff94ccbce16946b32a77be7beee9c0e1947f94bc651304cc71ed65d068ed3e217ca5330eca461da9dfbabe3ba9317fa4ab8a686f49ad125cd0dce4e689433495f6c09098a693d1283a7eba2eb64b4b16449cc85424ae1b6a3bed3657cde51bed2492926ce76295f6c914cae26ae26381abfcc0cfcfc6820b6b5f7a2502c6bea80f47bbbf79a93c52e53d7e1549f8ba6eddd5fdbbbf73b0cd3e14aef7e3acc2bbdf3be9d708aceacab190f8943dba474a4fcf457ca4f18a6d387999ef23a1d05c34a3fe118327dde4b5fca9aeea55ea5772fa5ec7778377d47f7d2a7c384e3f44a385aef761f8de109f974fd1095b1d8be96acb985bc6ca150e157dc0cdfe9a8cfbb8c0fe5a42fe5a510377a7767f8620bf5c5968c2fb648251cb345e6ecc470cc98a99a583af9f991959be2ce4cc167e0e74703ac19ca40cccf9c2d76ce392de5b6a3fcf49a947bdc86537d199f69e9b8489f993bbdfbebd47da615aeae1637660ec498e832f37c8fe862f366a79d38b4f1a7a35e8ee8d29fa7400c65202dba0615dcd3bd7337dd3ee52a1db61da58461a5a7749d0cda60eb64f8e55d0686a5600fc350f009cbe86497b1291ddcb7bf381c67865fa6973009d7d4dcd7885ee39d7bcde8db4bd36efbbad0c813dd98fb0394f568c86b8484db970fa515794e94cf3fe5d38ef2653f7ddb475fe9a42f65ea2ef26228555b285f6c9dbed81a7db165127db1d5c5cc16a984c7496318895df49d8c19dcf0ae061257240e3102c547d9f203b78a2bb3f10f6cc59597178016ae7c877e48d5f3105ba45b207ddaa7407888ad9a1aeddb6bb297de3855b18bf498ede767ccb46444bf9f8f3ab4dbbf2c86e9347e6537615809cb88601b96d191317dbbf6995608e6a923633ae9abd922c2291da56f4ff545b7f6a2dbcf6f2f7dbbd9e7bbd297ea974ebae84be9289df454e35709c716e9a2df7b114e354eed4891020f4ee06447e9262ca3f312bd84613a2f7bd161dab7ef109d034a20e1890b68685a220ccb6e2c7d243cfa745ca2675f4ad3b62f25c23535a1d774afd9aebdc67b0df71afbecb1b5512153356f3fee9345640ecd4d6cd9d8ca7e4cd5fca4204933b33922ba947cb8a23126ad953597559248b0649784e879a29914095aafb821cbdec8228d43959c9a9996906575958078c3ccf017a03daedce0862c1edd129b7559837af2451799c562b1589946a94a5c913ff97451e5345d4e1f0e47e8014fab93dee9935538a20a39ad6e7a13264f70c3049ed6e91fac04318b214a5a76dac027a8a5332f714a0753e9a6cf64d267f2fd4c1e7d268b3e93439fc9de6772f799cc7d266f9fc9f63359fb4cce3e93eb676025c88410d43abd0434c2a0a48582f279b1c13b1285bc8edbec923caf61f19dbea6b1a2a06058095a51a54b5d81e8ec0c51d5f79ec3b3c4a851176eec398305573ec7c7160c4fcc22c9933c9fa387667122cf4320bac4aca5663847573c4fb36f2f8e9117aeec9f79d3459530fee40cdbd0d4e8a4224a33d1a45f77c9bd7bd7494f7bd7c54945b4a3d402cf3ad194807dbdf172afe86691cda2edf6bbdb760f257a2612fde2f08a3ec2212a775ff82cbf98c3d71cb877b7a11ba125fab65f9fbd5a955dc3ae2de85a8c03bf3498612737ac91b3d7a89fcc3294837db5e1fd667827d477950f9c1bee8752da2c6fb3c84c4a8baff59e33cfc69ca2077308e62035d71f2f097349ccfdb03f06c495c9720016b0c1d9ad7883767b613030080c0b813568823c4f6337bc12e8e6d44bbbbdc5b058869686532e6d66a69544fbe254e510cab2932909d3030d59b68087c7933c234b18b178354b2a521b53ce796f63db51074dc3b012b4aad0c5709e74b13b635629cd689665d9a946c4cd88c0a17999aa3ee5d9999167a785fc08d260cd3020ec3c519329f6a6c5d120fd15375ce5db60f78c46c5aee675b16b25907a5601c306701557faddb11a675927c4aca43102945393b29364c9901b213e3f82c0accacab31764d5b07142d59a932787489aec5dcfc62c91d56ca12d1db4b59a2a6a69dcd16c6896987b88c151e4c5460e14ea07c1d5aa8bce15f3c1751dd73dc41479b19143ce6957d765a74a4619623e9a25b4425e2e986649913435437a88e9e1e57ac1bc62ae18ce1671b55a1d86c68ae58ae1e1a3c60b1874151b66a3507395a3596068ac58ae181e3e6abc445a83c62a7a34583456ab154d0b2abda71936d21ce3ca6b344b7871a81c7c71bd7ab061754f36a8fcde19570554a974028971a3125dfaa5db565cd7719dc3c5b259d1a811dba28cb83d344b687bd878c111f323082c87cb7a396c34d8e2613b4fd6060e1b2f3796090f2bba34901cf25324c80f2137384790c07a2889e1e1831557807e04f9010403e2e142175552dd16635d276d78c4f49034f2864804830fa0dcffd16d9ccc71bd9aa55fc0d249906149eece85b4d08dfad260a31a943e70ef1e72f7ded13a49f5fdd436a359c2f853eb411aed57346a744bf40250184836aec6f0a033e28a6cd06bf0d9edd7e125bc73ef66e806d71cf57c34d87fbd77ed5ea4d5d60d5f1be98ec6c566511207896788376cd886384f6933959ecbf203bd3c4d9d81d7f2b8c71c230bf7d07eebece779d693527ad6fbe6799e77ee0b676c0dddf02c8b7cb8bdf33e9abbedd3b66bdb69839a77db2cdbfb1e0e376c716c508b59d34e3ba44376972be64d8cdb03c73498fd93c2ed87f127025523ba1fe2533bc46bef3c731ce5c4167ba459ea61eaadbd17853aaa491399a4c12a711aacb7b3451e69547d9548ecb5a87b14f81588caac1ca27245e57aed8b1905ae583c3eb9c678882d98a9aa625ca9a4c1fa0ccb9d06eb27852ba7ac4d38ddc88356e220f105e20df3d3621c110a793ee4f2f4a1691c71a50c37bcf9d6e89621ded2eebdf7765d4a323379a770c3e8130407bda49138b4bc41d2c8badddd6dfae28692c607874facf206f99b53cd4906f2071d0653b001142d450a72761a5996652846e415dc20d3537a148b434343938216b5414f2fcd810e4c34410c5d48c10bc400a345a3c8947699524a293d856e509397b36cc615395469400e6da091c525648f61b42267437c51051429a8428f0a8030040539fb8a358427677f3122673d446021672f856e64b11e1c81232160082264fa1bba416f2290f4a8c8e189460e67e44c256736e42c873472868224c09cdda2a0276747d9e4ec6f96cca6670814e4ec2356a6032a9a082253c0135114ba9145a146a60f152144cf8c9cdd339249968e4e11c418999e531142103b310959258a205240809cdd460186abc5584d105a90f5d414c139ab91b32ccbb2b39aa53ebac45c4f2917997edacc467616bdb3e50718b2e8c1177e983831452b83226755d080660753f8020c9d24b4b22539ab020956e4ec349a45cb599665d96807379663de71b133bc78b4f79e5033ac56356dc990aa0448f361013da19e68925920b23062064dd505828b18f445391114041a9bae77b64414bc40664dd3b4d3207c11842733d35059eb398112596341ab5efba34bcc5a56c49156c53c8125485a1573682f0a8922f754837278df1141bd44aa3dab59560f20834bca91878b2105f0220603d0c2f572e4e12227c9ed72e4e12249017eae8c1c79b8904245836b73e4e1a209aa2cae28471e2ea4001ee16639f270d185ca095c7ca1251f01345531d397f6420a99e6d873040ec5e962086eec0102498e3d401891b721c71e1300753c59a2c0f86329cd33356dfd992ad9627dfac90a77d0a499a40b00f1939f34283f693a30834c1f76900ea52a903a48faf8045dc004364b08a50f95ed65593f6995fcfc3a2805d75adad59fd962ab882af92b9c3801284b2a04fdcc96d8720214647de28a9ca1226d00c1556356835658a10609e5809a856679ee8ba0661965f90ea743d22df2c80f67827086d70a2f69b4a60f92d84e93243f4e0421cb276450b384bd24cb870d463d92e5659d42969776489697960a4b45db6021b5f0e9427ee15333443eb1ca611fe138eb0364e346e39721cd626f6c911b7b636fec8dbdb145ec8dcdb13b56490ee993e5b9d08dc638ea14341acda6fefc6ca11b5d8f344bcda93b35a7e6d49c9cd9125b3b4a787c6aac8769433726860123ba00e0e7a626cf7469b2836c6caa1a871588c70d9ed9626353257fdb07757d5041d9e736e1b13e1ccd7dae3f3eb21e4e9ef8110426a483105d3c10ad903d309338c2c429ba45a6817e92a6c11a9a2136f2ed4474f1403d9039c693ec236e91a9cf159ee4e863852d72687d7cb6f8c9d6a759a2cf15ac681612901b7d8c009467c8910a3168b20c51a04f9329f6000dede08189533be489c31c62f6c147dc22630fc42d1a89db3c3434b9af10db014dde22d74f1291370dde1829522409ce9128c0901b89f5c9c9d9d949d248942cf16162254f83f230e878bea027490c1189e14e2a633c2af5f80331e4e9cdeed460ac8127db49170d368bc4a913d56205c6624e6c036e0f4d1557b493a8ea8709c832f718bd85c9823c51d060c8bd0a23f7971869b01f672a82368c1134ca7d181905d0184e40d9438382ecc51772a53396819a259c4672374b7711841c71c88a0fc137d8a780912e3418b97b8cdcd12587987f40c5157a525c918fb345c3332da94d19144a1c197b8a6e1cc24dbdb6db6f384efba55ef6da2dd6709099e7e35313ebe85686230eedad8844c99e55d65a7b061157625a637615bb553a5bc64e947a79adec342f917934935996c52aaa2a204a7e5bc7d1d99ce4a2260a81c82f9c91e3b3500e5e68c38d2cdbb8f285b44a9c5c6bf5116333c680c46b73688e0be53033e56e846883f15d77e3dab822bfd0bb9103cd368a3a11271289449b4824125991481365a24a4553d42229baa1b6654207e4071d6e9e77d103c921e6781e628b5ef2f85e1f8c18b7c7c3f80324440b1720413daae2251039595681849decb595fdf0ad842c71b89a715483a89924c6a03b73fc0cdda89a0dba33b4430fc9d95f6237118c394630d59d7b97b7cf005914c5851bc626303dccb709721afc4f13458a18094216326d5ae9875570c3991cbb71634ce9aa473a6822884c7118794ec793a2c65092572231dce77005529ce77972b4aa51524ca49208273b59d2c7fd7a5493dddaa4cf5e633f7ae314c52e92f6793fd39ad9b5bf320dc3742e86d98f0edb9e5d510e8943db68cfaea3bde257f6118689bceedc76ab3d7b66394fdbba5006d469419f3c49e10923908c138acd913ba3fbd347bafd52dda62fd5da97ea6c33b99ab89ac8202020a01e69f1ea2d5a8cdb0f59150810d00fb3abcdbad61ad2b9571d2ac35dfb0764ee7b9cd231bafd0eeeda65745edab9cbd88f2ea3f3e2aee154cb8c6e71aa239008e20f21d16566ae08398434811c01a55ca6d2f6d7e8dbeb372ed53cc4d6a8d5de0f201a6e0cd6de8b42fd2048234392439b5d9f382f456688916232625e4cdadc948e3a9df4a13ce513ddfb42efbe7bee1b75cacb6c9145705c1966ad563a622cc678d0e18a2b73ce3963766b310f40329c6aaef4d36b4c4739c5a9c62e6edbba14ae54ea300ce5a6c34e2f95bafba5fa5d37a58d597d712a7b37c2a90c7bdfb68bbe947d77d1435f4a4777d15316efe82e4aedf01ebaf7d04cce707fb40c10a098a67c3af528dd63cb7b6c99be542d7da98a5d35f735a353981e427e4423576c47644457935db6b86e12ebdee91bef26f49d6cdf7491c6e99c50ece726d6a46f6c6868fa2674d15fba6f668ba88814e130fe28d13e9acf4b17d1377dd32de822fa265e30ff00a4def8a1e254db7881f911a45b9a8633591c25695347afe17eba992dd2364e1ee10d631a2c5bd97723d8ef5354f58c1b0dbbb6bee924ba88d73c681cb412d987fb4b7bf387c3b099968c4d9574d2431a049aaf466822cd32b3226da459ea90fbc596bc29822377244f8e92fbc956119c9c1d253cd927fbaa0d5da4735a49fb344eef74ac6fa66aaebc99ac4b4328994699151de5d34a1fe9a65166b78cc7498c931f4052020102fac1b4b5e8f735da4975db4aa34fd1b7bf441bd660573412e1687d709234362938397207f5d99f3eed29a3934a753b95eeddecb9d7681fdd6ddb4efabc3d75ff6a3761d8e81a9631c9a4bc64b5cba0dc3ebc2b199d17eaf73232ce7df4c9a07e9ff2c1745e28144ee9189d7baabffdde6ff81e86721998fb08cbe8bc4cdf2e83f2d139946f9fe9a3efd6c3d88f0ea37dbbbd8ed1ada69d3e9dfa6ef4d2b7d2a8f4eda4a75edb49df768c4678c7f6d14730edf7b1451a7da5ed2361ea1a5121d2a6484e698676e7822eaa507ab984d2f7982d324e23bd07572cd4c75dc6d73de543f9fd4cb75faa6ea72f551f4a652f7d4b94528a83524a51534529a594d24829a5946625d26b45a174ef122551fa55a9547abfd47587a19ca3b4eb3eee4b357e7ffb4c4bd3629a45667a1e37d248b7a4f8a08f4fa296b58bde94cefd553a87613a5dc2a97afcb2ef308c746b755cf7289f8c8ecc09a7babbe99321754f55d2b9a75ea47327e1780ea72ae621b62eaee941efd18be8b72e34a254f260a193fd05bd7c119a3c67509e4ea69db13c451867f4893e7724d752c293a74f9e9e2c325b66d054cdd9c4499e4524cedca1b8831a6806379c3bdbbc22a88a08d4134e27363c441e160fe6cedc993d789e3ca078eecc9daec1bd84b7c84ee835dc453b9ab5386c9a5463978753edfdb5ddc31b27c21268aa66ccf327679b2d5e1325b365eecc6edaed93adb933adbd77a7795a49fb28992df701dbc3f6699eed8bad0edd706defe6ce74622a993ff38a3c67153dd349c7162d21ea20a01db225c2b09956037dd3e666e27411ee9c4c9a25ec2e0228dfe91b9df4d7e824f0de843f55364e95bc992d323af332a48f2e53fabd7d0da574903efa8bf4d1c4afd22fbe53652f7bfec754d1897f78915e3a0fb1d50316838148b8f4b9a68a9ef48d7e1fc6d8c453c695b8321fa76af4f5177a5c0e1b4702149863e4d0b756a29d3ec66791a9768d6aef6f9f0f2dea6f13e1d40ea2cbe720c2b1c14dbe747fa16f5fe8338481b293af8b741291652ad14a9c14913c3eb14ce9c4892bf41d96390dd27358e2b492cdbbb36b1a4c20bbbbbbbbbbbbbbbbbb5b7677db8bea6f49109bab17128936d971b6a6e6f6a5e67cd7ddc3b0d0bbc33ce9356d7920b0d57bf7852ee2ecf62d13e14f76dc66cb4099306bad5ad4773f0d6e91ab3671e85e8e07d4a9cce0662fd246fa488ce6c5f5b1cae10766c255eede5de6ccda7de2d05ed4bb87e04d7409e52ac5edbcc3f4a13bfbf61cb2778dc3794e6a9f30dfbcac974344962e2282f5b58b7c98d9625bf5ffc47d1357ea43f76e441209e170fbdcae3d9cf7f09d1f6afbdceec3fca9c13aab7d2825f76aad943951552f71c87da806ebbb5a67d7dd13964570779106ebb57ac366a23613b9be999038f4ebb970c32ec2a2d22c757ece39a7176b6863c53ef44e280a1ac11f4184fc90427e48ef2fed7a892ef337c796ee947b188f9029f707704b8cce7d36b6157af7d508c16a856e635ba38732485ba0f7d116987d555f57347c61dc9adac18633d9e2983f32dcdac9195b52d1129ee8a1bf44384e5508a7ec438fadd7a74afb08a76ce83b460f61191d9911aeb161b5ba0b615bdc778444b8665e08dbea1e5b1e76bd7c39aae85b3542dc568c090863121610862203c25845a6bfb305e647e2e6a1b75fa4d69334190aee0bee15fd35bae8f222d14f18069b91f2a5d24f1806bb33a4df4b895ff7270c83cdd819aead10dd4dd3f8c1c34402cd1a1bdc340dd2110eae8ca3340b77da9d5e2a992d293ccdc2a45942a740d1a5e485c8f2d2a01514658a61d1448b08441095f2c596e94727c5ad398c403274e3be93e2663f82d450c4ed3cc369787dd83499c62f9a88c211b01006115f006ad1d3f0499b4f0060dc27cd92d96878862f5632dc50dad8d4e98cd3194e25ce8c2fa5fda92fa5e11f5ea9cf380fb13503c32e4e3db66678f8149ef1451a3ec3e50c34c8af741a3e199fe1433d86487fe9b8a21df5c9f8a44dabe869fb1c9146a8cffd2493d0279334d8207d0acae8933c9fb459c2f45367c212d0b27c04a81722486f634ec99ccc268925d08659ab06c15879f566d4dd4d273fa7cc892bf311cb9d06230f8e1fd927cbf679992371f0e28a892d8748225922f9b6772a49dcbef797e80244e6eef3f9cbd9261a8d46229168f4eddaa7e592c9f4fb1da5d26fe932285f4afef4d8227d2989533a4847f98efb139639fd1e05cbe8bc4ef85e86f4d8eab24fcbda2512890359d3aaf921448ca08efcf8ec072b7d2fae982fb644210dcb1c9b371ddc0a06d7b605940830b8f9b1a146534a299594de076aada596524a297e5981ac06a72b8c44c861244296407f3ed62c210ba6074ae99663cf12262cb511e7ce6740e858a64db46850cb6d93a495f4cee5473b3f3932269bcc16dba26f9be8a265fa1e22b2c03448b7e89698a9a27247f2cc16ee07faa2696a32c5400fc9b49443885e8a6bf397d2d1ede84ec23542bca5935d473bf7fbd40eeef7dc2fae21fdbef4e9a476e8db374ee9307bc2589283344e499be812caf47208a594def9d5a01bf64e2b992da553d3e99ba777327d67fa52db675aa52fb5e11f5ea59bce436c99300cc433ad9055c23a1d82a6aff4d100c38d2daed59deb1b7a243649a64b32bdc1992dd6de4b7f3fd27782d11830cdd243440cf490fb23b5904d1aa4177d92678786505bb48a9e760dcd939f2f32a5b28b4cfbd3b2b599f4c556e672b0b971dbc4151ddc8a5d158cdb8f65ddc5baa8427ff821c8cdf24066196872109bb3937e1fca941ea477c1348823bad8d3eb105950f4acc8928a200522c7a0adfb81c082e0e689551ae4bed1bd4f14fa40d64f4d5cee5c7d78999abfd3fb8bbbf7790fc374267e79bf1816a7273bcf4fcb327423a523f4d15f211ca76a845f9faaec33845753458f23aed07bdfa78abefb5834a54304b79eabe1a6f1a776bdc110c4f0931590e310ba004556a7bc46e965f6507ec391f6a53c8739eece7338dc3ecbc50064798e468a71acb8707978f4f07129b970c3f81379785cba1379e4b51c7ba0c8228777053702653f6861cd29d2826cf1405bf52f1d2324bac8cf8b20f6704d5304371408892b93155d4279561c2382084ed7d67329ae5fccb985161db1d08105686a9db3d67a591bcc76b3a19da15b35cb74e9af441c62bc2114b78883a4efc6e100b27c78036a0000c061cdf2214aeeb8d26f2d6e189b8820e24043ded0ef5f20b6b060a20b6509c30b510b395221776c61916608bfdc8f724e29e7074a1c06106f90af3400904359664ef89899899cac3bf372f6f8653bcc07913ae8e2bbb3ac3d309bc956cd128a38ac5bc5f2f7e44597ea925db6962d146e189b6020ba3421cbb3a6aa87980b441c5e30d1a5de47f2842c1044e6791f335319ca81c6184331c31ffdece7810dc6b366cbed97c4a1c61be2258f96e3c3d8042666d0c5568d7c8c57e9d67b6096090b2cbfb3de5213216ffb96e60909db431ac9939ab860e931a3138a438778c3fcc42c23b05e592fb86174d2835a7befa39356d95a71443de8bad8639ece5833ed2079c64fd3deefb2ac434a2badd92773d5c1cbd9bbfe428d6adaa95671d75f988591ce9a793674233e76ee7e16c3997bebf8b067e7b066cba4b392529a6913d3ec21a594ee44eb7516636a06a81c1f67a593d619638b26a594dad43cdb2c61bc8c93ce39e7ec8e0b5aa0546a418a49062d68215a21597e5a1a032dcc89238ef25352e9a493bdd560c5799b25c6497134d88f361a6c1afd15adda0fae0d2058b38cc2e0aa3cd3ea0ceaa4d32c3dddebd9d922a3aa3e461a7d5e5ec6b85e965846907a1bb789626b53cc0210714111d900446e28c71e17d428e17239f6204186fc9ba172d68344177296654560308a9ba98aa018ee28c71e247e4023dc9b630f1231247cae82044e0ebfaa2790544a2ae795d3e6d974d22a86541837a4d9569b9d5a39a2b2fa7431c618230ebf1c278d94ce397bce49bb637777ce6194360a3244dd21ae7cc7d67ec0dcb4717ee243b905503f8632a8e7082472d8345dd3437213c91da3a1a109a29b8432890872b408430c2ab0410f6243c8a1f4d9410e654c62d1319913ebe8a40540c8a28e4f72d7cc9c808830960862084bc08101931cca224608914389238fe48eabd9e24310648083253b4fb65085560b213721db196b42104f8c410b1e317e5a3d45ee5f9cece54682152a4600c1003f99126122532264c8f43674838239461c0c90b96ba11b5c4619b182fce5ed59e8c6c6534365468352e786a8972b9ab42afeb42a66ea04045a5d11c4a26955cc4ab069d56c41a1622d6092eded9b25a4ff28fd8cdb90e2db9843546e154185ac69a7a59f9c653c4520e9236ed8b19f1690868606081e1a1a3b5bfae7e7a68b4c234f27a42e58790576e1ca10e544e264c9495114f6ca1863dd682127e0450d4ce0042a827002103d4e94411453f8a6894c4f8375a2072567286591e98d0d5880844c8f0adda07726891b90a10c487821451450340f144540913296b08230327d4a8480154f38a2022504f2618cc1586b2d8ceb158b7fb960228d1a8df1f33dc4263e31c618e3a682ac09b3091fa8481423dcb630ae9cc748f923251631461a638cf81469157725c4adb13d7b26d1c959653fac92892b1fb1684a29a594524a69a59452dab19e2554fc4049cc162bd151634716d4fd4e344b89c32c561da02eaaa88c9260439e3f9805716b27133058b58cb3e7258e9f0ae8c5157a0a647f5149bce8327f85ae4f01f0b933f245e9e0cab7066ed7168951d4663c7d7170e5e365164839f6576badb931ea92727833496679f9cc8594e76d6c91a48c73e5a3ca6c25745165e200274f7ff28bbbcad6de3b43301603820f9cb83b477cea1463c874708489c9cf33450bace8eea69466b5577727c623d6c3478cbe6009cd6685c4b559ce9d314615f4102aa707c6cda1bd3f3589631aeca15dbb0f7d1e0dcec693ca39e59453ce4b1cf6889973db68f3e83135ec9a314d9afcc4f468c2c34793263051a820df0cd44595f06e3d37dec881916e8903144f1cb9993f11078e1c4bf29c3c730a2249b6b879d6501a2bf21444bac8da125411f2c431ada5d1e012f6abd962f1276d7b848a1f1b6a4829aba4524ada5236c1d3b35b543ac618e3a3c4df887059f3190d54661744e4f4e2662339311be4a9a494524a29b5d6524b29a594ca15488f70795e6ce0c841a9b53725c79e2558b841ac0875b670349e4e94c3a756d5c7305cfad076f40341672b23cfa3c41b503d327dd5e8274a5c49a963a044707e86700399be5a8066fb6dc3a7b8321fa2783ee4792e8227587e11661553d639e794724e29a7aca11b92ce1ccdd2b3e79c731291854b26aba856c898f4913e32267d60af4019963e71a51e003cb8dbedb577f64bedc09c2af53a890a52b841196a603ae11236b265bfa38629705a4038a086a755821aa6c069592c839aaa6aa7aad630058e9d42078253e5801a9e96c51f0d2f50997d5631a2a422d8cf6c1ad44595b0d264da302b1aa48ff93448e792e812338d5d6be9ec209a0eea201a1e164b071949b89904b61dce9b36d3264ecec4f521d833dbac26b38c7e4183324c812850a6ef9d69edbdf3872aa1c8d4c79b3eddf4e927dd12c21d9b35dd90da759ef499dc073355f4351c71a1d8bcf8dae17ed238b62a9c357348a6dd1de4136b42df1d343b1ac213e7389c4428928963278e3671b28933a5c8f491dad4bad32db932ff40e9251d22aae88bc834894b95c8f41587a84c73ba90e589a94d5ca19f5c1177d263267786120a9c4c3f71664b131155f447e4c4c0064ada2674a3876472c68c8a26964bdac6da7b51a89634422a8de905b4b9276eaf4212e85ca3cf3d71b5980b26ba94327d0f99e6ba7c0d5fdc17fbe1c81eb7e87dc3dd8e6e7b5703127706ad794c00bd10b6c686d5daf01755f442d8d60d2b35e4edadc4a79095b8c6d6c5c5f71e0d43bd6733e4a641b06d6e6ca88fe842730fd17ac81c92da214b452a71673645245132809be8c283835c95c835895cdb87c329b9e18dc3323aafd0b9cb78dfbe830b9df3bc875216bf369cb2dfb8879e7a710f9debcec9fa1a90b832f4e1a896082f727df7b54d6f32c8620964a3c4460229b119722381b61c1b4cd5b7cd270c44a14cf631f10a64693736077da4bb69cfee96565861450e591a62d20994859f5a4317eeaa4392c644972fd3f7882e2497d9b6e3fadb2605e9690d5f5c170ee2dae7a05fb1bacf292ffa4ccb1b8930ec7e34d36a199dd7fde832a48b2e733fa29d6374993f19882afa3801c0832b3ae9323342291da48bbee37ea44374d277884ec2309d1dd20a3be0e2062fa0a16991f09daa968e9c4662cb0be11da593b08c8e8ce8252c33ba5f6c75a21cd1a553de67b28747df2a4774e94c65e69eb85a5c999d3d9c23aed05beef3eea98b9b61f0ab22973ff50b72460e929d9c06737696d41c6a9454a0c9a1a4024dd67a882e33d3675996512a8f9044642a83c840f33386259206692c94e1304621d37758823c710f394d7bd29eb427fd86855bf151e04fd735721a046bf491adfa4e466a73844597104e7419407499b9be91ecc0a20bcd0258c2cd00b073654ed114c52eeedeeb87705fe37c9d33557513e3f60d8e146e289db48d932adae64b7243e9244ea18323b9737de7c4313861840b4b2801c517805a7d443a914e52605c0d770e1ec2adb48b066be3cc961cefa1eff01ec232ddb94e86bb875316df06e736c5d5b004c2d24983f5b80877c2d480c455d5fa6ef694dd54442986c595fa9211892ab5b6760521503124f4840655e8a20a08be0630dc50f2f0742f3ca28b448991690c43a6d18b4c1faf90e9398d4a9ed992b2b4ebcedd5afce2be61d8760ea7ec630bc6bdc3298b6d8b6e53dc8aa5120de322dc50eeb4f66672b51c2fb9d76aaa68c6e4d21c99dc28a5ec2ad2308fb8428f852b314824d2189dc2912194083231b129c1e0081f538e3d4b96a084114422a571efbdac958bd2d31a4b9ac8deb54a744055634224887e712bada75bf670db28addfb66b1bddb62daae86128add46a543bd55e1aa477f9c034cb8b521bcd224fa190020d6f96415759d1a55b624b8cac0b4417fa18558dbae25611df80d8e29aaa992cfbae596bad36f6d859638d353eca1669f871657ef20702ab42f0f9810abaa88223bacc56b7b8af1475b839f440a6b2d5511129ae4452a68d6f5cb93adc4c7f587b5936bae5029dbcaa32ca31267b8e115d648e4d5c54c84c0306c61583b9f75e18d72be67ac1b85e30ac55ccd535ba67ffd8c8227ee479d8c82e71ccd7a3c196f23c7ac4f9f81ecd127177ecd851bb7da77d3d627834d83c9a45daf77b584dc6f0e8d119c681590df6bf9706adb0c28a1cdd3de2974c91c3db3fb8a1cd194d271f35d20580501271ac001d820c60a045567d2ceadd034518446826788191eeeeeeeea63dbb9b3261c2c4a7079f263e384a39f62c319243544f7592592a8c484204303ca9f72ddd979d861abac171b53ed380c9cebd725cf6ec3e7030cdc2d5d75aeb39bc7d309febd560cd7e3badeb05f39cadb8706bbc6aed898248ceea911bdaf823457df7f282ef6db63be77d355a555970fbe14aae7498fdfe61766d2c2348bfaa24c8fd4af30441e719a748fb4bd355c7d16870fb3e55f516b5c44b532f6eb8ca3514325373ca6ccaf53d82748ba8de064eaebd53a35922cf929c5cebcf92277218bb90118b5c3fe9aa59263dcdec8c08223c8944c8f133a24bccf2973474a3b69438e8434dd3341ccda2e16e1c0dea109365966326571b3824061b6c9ea661a359ba098d1e2880624ddc7e54e95ad34515ce4991b8420fd420ed2f32d56692a964ee34487170399ce812caa3df67f473e77ead440060dc89a495a4e44b13091039464ae2cb934a1876b19d2aedb0119e69350e9be7c6fb911d7d8461a393704ccd9e58f2ccb42c0ebdfd3b676862dbc9eef9d9fbd15ff7a36b3a0a86dd9b1ae5a37b6bdff7afd1efe8250c5b8d7034dda27c2f5dfa8bf41289849a2aad278cf4128e5355fae88dbae0fb46dbb8e38a761957343b5517a859681660ec9b21779374644b2b99aaedfd2e64e38624301f7ae82fed63d5d1c073650ed10fc19138589c9e1e239de6cd39499ff6d117e7d612ef207d8465644aa35f1c5bb195ea1da4df7b1930dbefb8279d84654cf8e2b7ec6db9433bb774424316985802354849a49209e5f6d36442e9e429e5744af9c5d7963eba45f9bd2d7df457e9238cf28b47275de6a67c32a593a8a4ac1775414c95a2190120002000c314002020100c870362f18040226b931f14000d83aa4e6e4c1ac9d32888614e216308318400000001181111d2b40920ba942a8cbde81c14c3fdea0a82824b6abf724bd5fff5abba7e36cd081f42841a3e8d589954911c46deff43d4a417d352a5d0bf67278edc51fbabef31ae69679b2f1dd7c53718eb4ee3afb8976666a8e4a974971f14e7bfdf38fbde0ca8c6dc55ec5d42fa48ad8d2ecca73c5f6996e2f723d936103f66e275c9145969712f4612c0b4531b223d07758f54d2fe9d5b254d19c99c68c975561f8a97eb15c2e93bec2a5bbd2d9fac9874f4cbf027ae16f95b9dc32c4f565a0d2dde3ea347a88ea53a6e693af227ab8074de3b2db55046dc750c71d88229e79b6ba4ccb7bf918896d0459cd1e659e21344a9c2c948c1f580b88168fd34359736516b624f824f43d4cbceaa5157c429c9d4203232548654acd9f60cf4d5077d4f4e1249fd985da0b1dca5d7b1915f5fb94fc274ae5616a5b25e6d5170303271e1b05d68bf326a82f8d260bbf471cbaf7a35e9025707ca0043f5fb7ab67a840b8b3263ecc7a7ddcd4ca2c30387d8b46b73f237b8df39c7a7e7683cff2cbcbb2193eee4b46756a84d1c2b465119c01182ea14d3cd3412a64fa67c286e7f82c3ef05221cea799a616fb80a57c5270400df974dea340696b8046bfadbb678cce68e7c8d00faa8552057e02b5fb713560ae861610cf83d2e4e6bf81943810214c7fd0402c44a772326ea421f35d8bb1800341d473566097ecf7143f5b041522aba2f3f8bca1d41f35ad19a653f799877d78ea3a01b13047cb28f6a8a34ecaed45ef33d6bf160c45298e1c6ce52a533d086fe5afa71844882ac39f71a41367c99d302a77f10f59b4bd36df93aa7b2d1552dbc1232add751559116803536225b4b0a121dba218946e5136d0e835a344bf0ba5a7ce6e16d03068bdb3a852a69785b99a7949d32f24b00937601115dbf53e1e5f7a7287eae0f4532a0d76323d926d91bfc7010afc08de1a571209d26f999481337e3352418b104402042636689f359abcf1d93235f48d5872853dc3f7f3ad2bd331c7cdc15c9d26996c706b6d20785c8e81f1f91cf58df09529a6e46d78a0955eed735b51fd8ddbb65e6aae25de354b86647473697135a38ab943b7235353d654ecb64608e63cb11a83e88a9c62b920735e21b7831b5c2f39f289cfded3b3d641d8e781679335c8a9079e768c77461e814e3e0021cc9f25738c7225091cf68dcb2006da4adb010fc4f8c0546d0e76c93b1b3224ecc30c4ff942c4781139cc82ff2293312b3bf47f2aefc7eae52618ec3c09fc1d3df7203bc0c850d1039b68cbddcea7fb8c622d6b9d9c07aab8a1e94e21dbda163626c5317278f0f06ca4ba80220e22ca74839e36d422158da641399e40921df24305e7e82ed435c376bb999e24e1260d285b6a889a0d7228a209187a20001d53b9d38256b37eb7b20a24fc8d251f69ccb4dcf071ea9432bf5f31467bf588e446c442d0a3fcac9456c150de2f062ac465c443a4b26f569e763cc131502652ff50963634a3b7297ed7edca438a27f163d318a37d428c664bf4e2f501236ec7c18c1d4c97aae59be2c689146c1d4d0d90e5552f8216bc9e2b6de2c813ad9c1b7fc487a7c1bc86c4d279e2870207f616f06022e5fd97eca0a0f0c05f5271b51f3d21e15cfb147bb692a72ed7acd5988deeda8b571b821aa63329dc7676b69b753e1e288a4263bd9221bbd1271b345f8a62c23ca5c946d31b0ac65ee7c057af86d8e3ae749202f030baa6ca2cb060cebcdb88593f0733d995bed518ad7b36225a57ae709c23847026329eceed3d0a0b680e29db470a3ac7ce5b80c0d368bc1a3993d949e9a83e1a4319b740b02e58ad6a0820ab7a017adb3d06d00c8ba74dc4ea33e52ebd244af9152de63303c1e2b38e0b66d317bf611b9fb039518c189f8db5f6a5502e2c9210746fba55065f4631a725041fed2511b0da29ec8373c15a5efa4bb7eba86802f5d5a1dc854bae79daf08254c837fc2b36db3ebe78d09d7950dfbe9a5405010ea4de4aa0807a1340e88284e10cb8d90a2f13935479c3f43df595b3440f2889b7f35d87b3356e3b162afe6b4927ec0ebe42392ec9fb999b4fcc2588912d430e4558d174f54bb361c4ff8ef4b163ec0e790f9dff1ed7c29cf8bc9e64f572ff7dd22eca03f609bab34fe18a4762c25593cd178674ea7b502874384956254f085b83fb3e2d7f7e318f08a01cf8b8c49f495ee913b6101418c659b00c640104ede37e2a3a4024733529d721d4003b5e5b786c29a7388450b3a641ac258ad9091b9bb5cff234c89b72c886b043c21cbddb5c6102d24264426ba7fbe73faf96e1dd2e69c50fcb430792c64a0e3ff061b0439e4c8a88794aaf6d299ee70f8fb3a79c779936d6fafa153a11be724991b0069a8fa52ecf46709a6c4435665917ec884383125606c7775c21a035430de4293ac57cbbda062ccfc23f546c2be6049383bd3f83964a411475d24fbd8c9e43a6712183b120f5009fb080eba7d0b0aa3ac2149a8229f3091a94a820c14219ed5f5914b32bf934fb7ac5f128218b94c128b2b691350239d536e907b74ac039f3f2e69dc721927668118607c1b68fc0ab47f85e79026b2ce30f14c29834ec3f14ce5fbe05d0f1e4e60c1d9a1ee42a79c41d659f2f24b0e1f82edfd56bbe680cacf94694a1760c3144333d55bc7f4d9529d5f8489e2350ef480b787f865293c5152fd9ef71c432a358a0829676949b0fbacc62b9b36f623f03ddffb1e3e91531ec8c128d54407a1e2b82880c465afa49d2fbf0fdf099a8b6807bb2f881ee22caa658f6ac1f1616f133d5ca35d2193abb8d4baac97bd1c4cfc3128866f8eafb35ca1ee82f2b005b8575bea9f27ec427885d50214f1fe6277d71b09b07130556a2cabf00ed30c9c20d0dd9fac0dd6696baf139e6c07ca531e1c8c6e1a3084b0e6e0d50ae7275a2e14140c8696734ef8fc243ed3bb27ec253e2366b99804ce1f90b094e00a5826500b1ec278068d9c5bc017c71c307331f2b332ecbea224bdaa14fa6357ab8b300d2dc81d97144029a9c1f87efd592fe367c51b3836c8ebc51fe6b8b85c123e6f92a9fd7f0dd62bcefe2b0f00a51c75250851df3e74ba4e678e5c49d88dacea588556380fce909cff8039b82d811e0585eeffc727834bd8b8dc6601573e8fbbfba51489b97f8a12d8fe4849761f6578df5ffb8cc4a5ec3a3cde9060385227f28411e8b282fb124558a600deed95789138c922928e4de8c03a82eff7fd4d05dc0501e400388efbd2b91920156622d7f214b60721ff5e1fd3f75e121ad75f76fef59fe249d860b505865d44e486c6114580aa86ab911ce832c155ddd186b5ba2279c00a40c89261e14c926b4490364d17d1559fdb6f79d73482d6b400d73fb05aa973a3fa096317964ade506c46db2aa910f91ae70267c83d62a701817aac49d2d8db3bab47cc7b6198bc75a327cfff3695f557dabd673448d45115a151138d2d23dc5a31788916aaf88f3ca1bfcfb1240e0c32ad0eb13dc1f5b6342a3090695c1a87c735bab6f26a0af94b57b5480d4c9b4e91935899a82c662457cf91a7616ff42d541ba3ea0d46724a4729dbe6f5a063af1fcd6708ca048152fdab2efc64e85f9c2f93054524e7a21a743ea9824712d23921a4a1302109b4783609a22ef39407ad727ce30a02ef619ce69d4886502ea8703104510f52d1d961f642d0212b0bc87d6833b8e34fb6f4cdd55aae01a63fa305fe141d7a6b20541e3054642392c0dea3984fb6f7b3a8deb36c1111eba7dfcddbee491bf7dcf1fb590aeab2716cd9993af260eabdf21e3323295a34bf5f9583f6ad63030ccc6e32a2025c429ae047640390374f01822fa23c72ce5a9dfbe386498e706069f4895cc518b49f9069d39b2587875200bdbc830372e4003d57ac6448bab4402224bce39b1d2268de6cfa0e1bef3232dcc66810fa447280227ba8c81694e1b55a060295b66735bec3b69929d90e8d51db54bfaf4008ea06e5f7eec487dcadd53cb657495bff8dbe03d74bad404af68385497799faba6eb2207b6a943a63b3f03c68c80f3275bc1a0bd332ad79416df200bbce6ec7c8551de0ba6939d0f932a171ce482f1de0fb926b94ef5685febe1610cc3edb4aff83805153de8ea2e9f9e5e332a9967feddbc29c5a00e17b75b7d59b2a6d53c249730a749b6540c870f18388f102b085e44bdb44889c2d956a70360395465bd0e34b40ab5c009f2896278258f705fd28c2f2596a79c10de9d6657336b44f658b390e4e4149bb3682dddd2b2fb48dab1750726bbe1a059bc60c0831589ac33f750ad1beca08f5cfcf0a407dd8c09b28fdd3d9ec31fbd5ab1fc54978bcf9e6a857bd794c7bdbb3a4e9298d07ec1c855ad8030b0520d42df0ab770317a3235f78d1281622604401195becbee5143bada08130deea7f2301e3b6172d7a8715e223bcf31645b27e0e558e5e5ebe610ec4a8b73ee667fba15728dd0e2234009a7ff9e6b96579a3d04fc84dbb5a277181fb379315dd0dd7d820afeb4cc69668a8690d493f3a54604f06fcb73e0dafa07befe56198d76bc7e67d47da62698b0f3b1047386e110e2b5d84da07ce4930f25bcd6ec27fb98c2c7e52f5a4e3922fcd05587c3fcf4649449b8fea7cd947df28f9da4f6506fafd229008bdcb101ff1ad4e0493eff08cf720dceb6852e5d40827881130e003c2ad9e54f15794eabae60b5a7d29075d40c7e9c264d7c5c426b00719a1ac3369c1fa29f1c89d192e1304542709ebfd8a15e724912936aa3cbb48ade181c70ae8b4635c3d604a9686e8432bfe909f6365c1ba7ca85fd3c424f9ccd91556dac0a137022b57cbd5615a189f8c4ac403204bbd61ddc4fe568aa1b24eee6676d8e1a50c4e4d3aed42f21d0b0aa73a806cfd3561657979d4c335be15f0579ef847107b0562dc126b454e39443267a441722ac106583e7e06dfbf9704290b659e9e11ec901f31b00dfaf26e5edec1341ee2bb3260a1872ae7b471307bb97c112be0bafc848de2b7e7860d62e517b6f7516b2c5f26493d6f7cc9f2de67c93e44214cb72c04d46277184c4fa5a31bce681153484768618cd68e147553953517ba55c0ea5867a4088e2d480d31ae67c9b6a3c6d6bc9e21a32c85d89a9d4733ec97e5390942daec9e6d357b2609a6c58f20a76b7e0040ca48d0bc2fcea5132e9ece05fbe4669e275c5cdc02de7398513c79190f3ea0d16410e7bec85e7b055beeec354deb090617b64c72f4075e5ce16e590b599ad61cd043b603f9085be0d6af7d586e7359016dfcf26e5e18abfc99b32e4915346d9b76309d25ee98f7da743adce963b25b7eabf7f976cbd9d1af9f2f46a287c8cb79ec0ea37861a60838c00d2ec566bccd4e812f0842d4db134ed77359df06959eceac428239e854052fdd86d14941c71bb9adc208551f39e3329769104e0c8eb24742735b828c2e2247d8d6453ebb881ae45ca8887521833b545886039302b9ac39ebae366307a4d9d9d3f4f40276d073282e3c51e5f510da1cfdeb6ceb0f45bdb38a64320810a8efd61e0527d6290adceecbd775d47ea2b8f51cf6d06b68516b2dc305f11b656f6c3b6d8da64d4c7741a2a6c056cb64713abf8bdccb655be03cf8292f271ec0e8a468391b4dbf66d975a8005c418b8a56bca370a448b59aa1b37294616ca10c59fc130d7187520dc90a6b6864d2b7432d4ac0e3a7c87853c8dacb90c9630d7c2272fa499214ba803da96f7aba412410cca108698f74e0b2513748833427eca73a3e79ca3c54c6451611367efabcdd872406d8d3b28abbd91ab70c0ce1542f4464e957a59993dbeb2518961ee07201170b1049a010c407c01d9643bc42948e676f14b6271a416e05cb140832cd7601a2906a16876605ddbf5228a00b78efaab6662889966d902bfa16467ca55db9c9dcbbf43fcf4ed74d7bad523288f494f1c3dab4e2422c0ac4fbfc7e7d8cfaed6f97981546c5171023e460c447414c1bb1fe1807374da41f78d4240c54885655ce55fd4429484da394f1f7949b0239512fd02c2ba92398bc4d7eefdd94fdcd14532eec727be4e5c7bad11381c7c2544a7d9b67a5826f11b1e4776aae6eb636c2d0bf32ea995bdfb803ffd8a7a565e23587cd66c3986ae179f6b129399f286aad7e4ce26efce8532c01e85850ad58f609eb6370a7dce18b8018c85824f37e545b95df1b7e04638c11546c006ba5c904212833b48c0caac3a21e367370cc100df488d20e221d1c071e06c16c28682b7a877475b6e123dba7c4420809d3747b653928c2fbb55a8614be89a5aec4e20b36b0430939971975ba923d92c54a8fe760f14b5d9e78f6141234b6507fa84b06c87f47c7939de2dfcbe6f910c3d056fa4977b51eee5781c4c536ab4af17fd623b417e3be4c567f18c29353d42534ab4a460b55be0bb5eb85295b16697499d165de1d5f3e402d51563c83a3e25503ecc45343253ef75d71f358bdae4fc65dbd7397c8937530371b34c803d3ce74b464840b595b84ca08671a610281fe8c1b3db9ff89387926d21acaea6967ca3174cadae1dd6585dfb606ab396b2827e0a57195524ff9a1326d427964a27fa8d3dbfbff44e550fac481ee644e1d89552af309c9efe2cf841d2126fee500d5802f22b60411c899e14b0ff836ccb85429ca8a2050d4d623e691184941ee4afa9e29ef8b865110d6861c4e2f305d9a8351979f4ebbbe759ee0cc9bb1637a78285897fd321ecb937ef08cac77666e5caaab72e2355b11416ae100b304799f5d416e59066edc0b833c01a3410c1b9f04959a1b62e320316a9268d7f1774a215ff21b62ef2896b8353335a32903abd275760197aaba2c6d8918d24424eb0f492315abf235c01b1a29a8b713d121f9f32e0d48a952c2882191fd836e085cceac673cad2f847ff40292e3c12f2764d29c4b2931f2c2b489abacd2b32aff72b1b0c58d242fff95c88cc99bd122d147f6d6a270403c0d8569dfe492478fb051fdfd5564286104b78c1c9155c048000d26276925961efdd6b8feae919f1a5de380f474007b4f9149ebe8bb5e229e4fea7ca54e11efda06d5ae5b930406e0d8a94c16bed42ce73e6d217c6bb5fda479247be06b8fabec7b99954952feab89ca34eccc4a3039c527955fd78f12c85f3069a7758287c57c27a9651e4304e07e4acafc3f6b56152fb7f5d0484656d3c378f5ab38346e70735de0461db6ed4d491f9af1699a0cf3dcf6aafbc3b7a77a053433abc351a6af39d59fcba3aea431b19d7571ea22dfb11c71321ace3b8c37fe23c874766ff44a4320a75d54130d80ec7621df0219b8a8d3e116f5e1d0e85a38f0a84c15dd40af3ed4796a5291dcdf7b012b89c528a348a06b5f9db31b4e18d345f36ded3be82a879744cce0847b0e13fba15c013ae892f0ee8c7c6840c1a5ac7318de809d9c2ea43f2e3a5136e8858f82bafc7b14ad066120226191be7ea480658ed5103c85d3224b110359236e647d5163f2e2f9603a6851bd367e395c84b4898196faabf63eebf1e4314493bd14f09eee37c4f42b4b86de4afae186f5b5d75fa5941dcb0ed5afd66c7f4070ab0b4585632d3c0e8de767d1865ea03bf397cd50e4fe0d7e0203a00b656f2003d3f6f591ec2ea1c6ac7542a567e39c366ef52ae892915081e360014adf7a594227c8f4bb03c4371343f4e24ec34bc23ec80cf1e7db1534186dbada216d7b9cce945e87614222eca43e0e33304c05939e44f5754e7ede6ad2f6268fc142619351163e7b34778a5c7807ead0695d07113e7a11c176a94021c3ed9d0cef3e4b274ae293aed5d9d3e9cfc45e35f5dd2d4b4ae761229b05f8c81db99330c207131b319a13d527980cbc82cb0704fc465ea75f02c4cf9bcb9c320a9721e27a4e9c333133737412cf8af2b3692334d3c4a0fa6b0d6eec86f69c1f88582c6d7645c9cbec53a8a47658ec3e1de06c9cf5fa67e4031e6db6895b6ae9315f67339fa290511850ffdf64f1dd5ed66c08cfd53fecfda9b66c7b49d9fa242a835a9da124ac62891871c1fa5be35e0ad9eb2b27ce3cd42e767ed91e4486bba2ce72df8c112bdd0b79b3562ee5f531d0f01a97f64238ea8b28f054fe4f37b6ae859f56d17acea721d3b7eac6f3d7a85f2e8930bf1856b8ac75cde72eadbed59d53f717cb8cb54c56589f60c995801e94391fc4724e35f0551e3b301f17e40584ee415819b3b7fc12d92f3429c3b54079acc852647a023279c2d036a6e29d480618a9df651e150166a137efcc2e309c3f72b8bb590cad436477909f0b8b0d94b9e6c7e1d682d248d67403c55ce1ca82ce8207b626e4ba6d737a16c7612a61e93984dd6c28a46f281fb34122bcb7c248ae39207674ae287a1f79387df61395cb6679443e482493926bf10290ff5666ae014d6b82b6bf139ddd89a9e34460640b3caf0b70485f4d37ab6ab6362429ad0c8658b76b900602ae8ccad4bfa3582bc323ae946d1b75e44d88ca86d0e5f637a6150882ae0f6aae405ea12d6df77ac663e28ab6e63ac9d3b8082c951d2f83df4550f2e645d4892498c52a3dc023f4bbc5500a3dd810a382966ea97d0697cb4fbb338a4f0b078f367ba4938059f5ed83a54f39788bb8404c35309bb49943d730237444bcd1467f268d8c83c6356bd751820ee3c9c576d3e538d5a87d63e0fa4d35ec0ecc6c08976f9c768e593d7229d4f3e4670f7063698fd873ed5712c0bbc2fcb87a08c432d3523798cf0119d51270496dd5e2fe3e56132962dee12d2c2f3c8f41f8fb29fc13975fe24ac35d696fc52bde035f4134584a005936c80a4102fb56d517fbca6b689da0b0cbe0652848599c0737597fbae03741fb0bd756fd40ae849d8c15ebbdb1adcfce40091323cd7f0a2d06f0fcba69a35c0db345b3170d6d03b7cccaec060b39402f8ee244c649b2523db53c25b6b4ce6512e08d2dec88ec22b203a2901ce5f433f6748b6aff81085733a1174ec4a3c55219f0962c00d8dca47fb4953f768e0a7b45f2147cbb8fd0871a2f180d82af43d00b3cb0b88fd63ec21e89e1e2221d69c7bf8a01cac477750127a4d4e99ad4c9bb999ef51e493b8c8e39c305fa0b86284dcf6c1e714c40330316d555eddba7674a83d2bbc8762a22f69d4ae2ff64381a2fe68a6a2e07871d4f27a9df04aff1ee0ba714262ccd301c7c3e4f18ec3e05a0f9d49c0bf6bb287fc7611aaacda61533305e7b488d4e03701f8d26632847e523797198d2ee4c8c8865cf1876e9b2bcfc1cdfbe6271a231922616a2aaf372894f6f30d28b065e3274f89faf3e02a24b0a541f3d5995d509511d0eba57da48e857f40882b2a65683b1a48d59bcd823f34094b754365c2db67dee8857b277a206a21f42de6ed2c55fd11ffd8d665114c780d8b7de7e685dc7f6fb36b05db99afb5fb745d74984524677c6babd41bc08b1228a2288dbc19af134abd271d76de955e0c5f4aee350a12487ed1013310a72ae9bc44af61a650d1a8b3f006044ae90930423b0b45a9d669502b90bdb098f9b4ecc5c8622e7429a0dbcef72b0cf84c865a8e938138af67523985787f0ab9b97da16f9cc888beafe8823e0a02b8b200756d81ee15adeabfc0eab9e6a3180a6f7c7bb1dacc65de75bd082d13b1b5fd055c487c6f1bc423ece879ee7f87348cecb87b6a8513032635bd29017deb751c9e08582117b880f6c355db47ad76de14a141da2bb894063cadd5c70520ba0015b286f61eabed0d88ded949251b40a1a23b151a1877329e86cdbdb1310936f05cb4550e069192a93af62573c4b708ab221d94210b874e5825bd6b2c52e78e8644773420f3759c654ba1e5d258ade0963191b5a1dd2a1ddaca4669666deb77496021ed3a14f0ac93b0c7babdc59789ae8a7280149a8d38d1ff581fa38b94c16ee8654ca1b6507a9a2b8b0bbb06b58d49e109e2d9019766926667e3fb0c2c2a41e783f7e9eff953e86750555e0d24aec890e9951583924fe18987eb161cdb84b13161c8d41caadf7e0bd6f64ee815053ccc00bc967c84584fcdbe49890a747cb647d014d48deeaa024afde198581960957923c48d94b32e93af7f9eecf7c635c68c2742cec1c880f20207dde5f8ad586e55d6f0987ee5b2519fe8cef1379f8dce8b39a42e38889f7e1e4c6aa3066b780d7ef584c3fba1b54cb268ac10ea5db8aaf13f1ee2136dd87325541233fbee10f25b3d1515bfbf8ce2e3c66bb0867ff1ae219f8805caad54b0a3191ed46f7e61d18020c3c9d8f475d077e188218459fd796c46b7598899898b03a0464140a2154bb93cea55f60d6d6742781cb0494b0954483360abf280d7460b52d3fe84d95b60ac9ed9b977cd6b65cc9cfbe7b08dbfe3af58c2e8d8b847271e0bc4542c1989982a0a22f5453e0852eb76d6eb362ffe82e709133431e846acb9184fb4f44918fe97389528384c01f81eefc1a1fb7157b3b864a2007111d5fb554a6d0ff87097af4ccca2db136b7e23f79d6aaad245ff998800442ab84a424ba24ff38599655418db7c07da9376e5a474a9c7d81668f8acdbe6e17c3f49035e01954d57538a98ad3667d2b332916cedefb47e5202d76441e6acdef3c748ad0fcc267698327f32b8331bf3234590be98077ff14537119c4f2dcc7f64c25f2f76bb187dbcba8e5a227b4f41d43a56b6449279adeca752e449362c7d0818fd99a4baa620e7e057426b15b43daf1832c4219959dbc6534b6667d13312c8ab12d38f7f5ea7f8b69498eb8abaf8a716db958eb8706451414f956e505758890ccc4bcdb44e3ae04d1d2a21603c53367a9e6eb009d4171bba4779cba21816fe0ce2c371dbb09f018c59ca15813e0a04119475bab3c1f0d3ca79884a1ba3d8f264367db973ca699a26bba920aeffb8c98d4acd309a8eafc04f52a4f5d4ce1adda7e0dc7d89e759e2ff479463e34a5676f56f796f6ad4e5ee454660dd642cfb5a874d4886a402ce029744bcefe5f81bedb06b1dd5b1f63d6da35bf22636efe884ae42582bf46baf6e0592385a31c853d564e89ab538bc12ed56fceb7dfb3e037b93d70ae7c315edab48a9c561ccd9dc91955660d371eef1548c88cdb8acb9fbe5ddc4cf7e4f461c335e0f8a3e8f2bfa8e3ce1227b17cbb943fec9e811eb3be16b4bb442d3cacf352dc9feb05c0ee0b3f044dca5477f3994cd25088209bf36fdd82424d8d695d0c5a722aee9ecf28c352958b2882a901e93c4c10ca49e7973e17f96fd56b99efa37dc15a2f45ced1cd63b972b18c1f1d7a7fb6dbe4e483b91a6d842d8e141f3bba1277310b41acee62472f184d24aa2e6423a3943c05e408a20231099174373c763e690950b0ea6e31075d414818c4536aca58f98f5ebebe3488b4a1ffd1e023ea9df786666643d2a4b729f0060eb53886182a9f03435cd75f318c2549a79366761dddd71ddc21d5ff01aec0c9a33d4fb649f99759a393764df9c3db4119e8d73b53dac303a8ffa3f92936ca1f4abf8d0629837090a863d85775d3d4e26e99dcf03cca4c9cf32c9d98154e391b6c5ce72f28e912181ee7fda8046181f69caa360506644df207ee55e8a17223bcdb3719518dcbee8796a0a5ca43003a757a841e88563cd4b72eec2c62f2b081a60213e25b810ea0fcea7dad26861dd7ed56c98767fb7b5a5a6aee612b843a9930bfe15bbf25b6c2aecb170361c67faf22a5066ac01b1c4c9f416b13f4a1081604bd2054f9e46363b67866577d0c621046f7188ce6397ac60844e8d8a818ef1fa09e851958bb252381b84afc7f382fbfb9d7c857fcd79fc8acfaa2f78f88ce3899e0cf7146b5011880d1a1946103572b4eb3092ecc77c4d744d03229a4be0599007439da4ef36fc69c5f59b229a46e13c616064829997155caf03bb0fc07dcefba8477adce1d668edabd14a708fa5a496950148901429609dbafafe7d6ee9432376415a9d4ccdeb11446da6a17bfc3015c6c449a0c9a371fbcb7b24c9d75757ffdfca3f0c043d91124c776ec3b5083ff0cf93448ac917acd9ebb2bf44aa4f5d78b138c50cea407ea53887ba4c162dee9ad00aa1e7ae861a8219aedcade0f05b14374f8d12cc7562a4058c2620308902948dfe6099b0d6ab962ca116d6d97668413fe562fd1a6308ac0f25e8034d8366781757775c88417709273b14e5775f4aaae8d7592b848a2eea62cfbfba52884742dff83cb50b1ce52b31c2896077430c9b3e633e9784b6876e32d065276df0451a1d32c0cc6fbd87e75b93049d37e6caa0fc6ca82250742229863dc0c0dd58ea17249bd06bf7856b3e28d0f5959e9dfd0de7552a892821c1e9cebd1b54aae2bd5adcc79d6937997a086f2ac7e8d1491a27ecfa0e6bddf443b797689d04d576469934cd21fc9f80e65b1c8100fbf423a0a1ddf908dd24ff14bf8f05b9fc8506e4b8a90be677da9560c2afc83de491cc4b97f94403abac0f0a194fe64be626019bf8426dca240383b6b8b7f8ee2d330d5efad6939ccd898bd0d0d8e0142389737439d98512164a7c1a6882194e72292abb10cb6590c0ca258fc4eb274ea4e3c342bf379927aa4477b962f150394ea6832831c8fccf69a5d8a0b32128e18a4344f1551cb06d2950222ba23b1c8c89655dddab670f4846308349cb9c0232deec73a8f44e26fe46f03eb45e5818b704bc967528a9e3620ab508089ca2b9588d23a9b664742892c6927e758dc1223fd388b65fae4fb55b416935de3d050b654918b8e9f78d91b49b994a69c179e1a2d80789b4e1a70843111a8d3bb7350fcba57d154838bbc1dea4f9159001b5bdc71f35a629f69448d2650fa0032919423aa1ca27b606a6fb4256346dbd0a60e3384f5bc9e1f177a4205e8be892ca8f6919246029471131f4efa04f69f26a3d23a3ca07a57a993acda25b63457e1254400a61d9e4e5cdfc13199bc835bd22a848d6fe05801ae7b8fa8a10b30bb7d9c8e4cb583e8aa5ae4830c9f14b933354dee709f909c1df1c744e6124d06a7708e5b1dee475f0a2c06719bdddbc88e4e43b50733fb956e4033bddba17c3c2b66047f32f304e54f56db386d4a0d10e52f93b8440a164719928625ef4a683e9666a56b0320717c0f9f14fb5edf9fce986b23cff84a2aee5271ce5f9798bafa4fe6f6c7e7812711692e83363c017b946c0f91d6f8be40eacf2fb827bae3d54d6d4f9387b8e92f3f82a1392b25f22f64174a19e14149a533725048908b6292200567ed9fe2010c1a7ea3347727ee569d472d03e260065991e26af101c251ba23a7d7480643295fb203d5b7a3b3e6e25af36a9c47ad7b9c38498e771dcfcf31574b8390c9191075abab3f89d01bd559effae6fd0c75e488cfc6379b8bb0dd3be1f5374c87758c011ab5b0313a0b34a32375b190eaea9760f336c664952e07beabfc838b9b8a81a5c420bc1d2856a83b67e6ec93c1b6258aaeca26b04145cf218cefd7b613aa83e3b9cdeee9fb3f1f228bbd6ae65f874212705c407752a0b1d740caae552627de4ea66e87360a180e31827b7c9fb0835d9c7ab168706ff865dfc7e1deb6e85d1a544baf53944d11fa0f6cf35c6355e202dbcecc76c52f3d188a43db6cc9dd73a4f8469a824b196f62124d32370f5a85ea45c14abfd037b752383cb7c5ce4725f42251b4ddcef8b6ad07e5449de1e58cb0fe500f6251ca865ad36c08340110ece19144bab4cece6964cfe2cc3bd1d29d1f193260ce92e734034630f2a35dc34103de3a7dd0e8b8c03d6edd8dd277ab4a7785710528ba32afe6a9225ae4c188bc5ebd50634fba8cc59ea7aaf3c7d0d052325daa473d2871e2f3161fccc44876a1c79595f6a46366296ed1b0c1cc49bd5cab8e05f59855139b602dbb0e1825889b2315de3594e6883d720db5558ab61b58efb142ae4c35b26a14972fd034ce7a9c831207f2a17aafe4de3d0bd1dce621babaed2fc8e1f561660b9626a7902a80d0ea0867508c9c0236c2900dd38d595b3d1c5e5d787b3dd92a23edec5716aa1e56d28f1987b215ce02664fa6b212ac3c842ebb7c579b3881c61ebebced8a06acdacb30ccdaaeda6ea8dcf57cbeff0eaa54252f18709be6c46358d9656054aebb848c7cd1b53223f36e94a5262215b004176f6963f05102b736dde71a69ffc688758c0961515525228552c4f630ec468399d151891721bb00a3a1ab5a92fd29ba2f3f465784c904adae0b00190ca8b0ff5cf003e63c258a2dde978f139c25b7f591c064e854521d02336fa3ed5953f9e6b66795c1a3c58affa386f8e752d4d57b8b57a88a4bbd31a297bc82da93217c67f803278cc3b8c6618154445edadf6e512e79dddfd81383ccebeadbe3ecf42e7ad28a18880963254c9e661bff80a7c84f7d7c53aa7fe71afb3c5004ce2e37ce595e88c642599718affcbf64c904780f035931b5c98985693ff9c6403a2b10be6750e6eebc11867ea182f0134ab5bb5c79a5fb7f527750958cb0e08229b4377591d30f91d1a534ff23e87f5c2054c11a57ba12fa3c2b976c00c1346185f5ce14de8ae218266e45ddddf98344364f4f214178f6954bcee6855bd3296b610e0fb69c8bd219aad27987fa31879e4743006e5e0f92d6bd15cf2f4b95fa0d8b7218ab21647b0bb1c0b83fd16ef26d9148d389bb09c5963cf9c9d4f6f539d827fa269cbe81c815c4f0752eb32d86352ba3e3e0427b78244d1e360c5504f830394b40948ccc8686a6578759b6991a4df92984876467262e6636642cd55877420344bc6569715e12071e692a7cb22711d90feb500f83d3df3f1c32f2183ef4fae32de6e8afdcef1facf6bbd531703d0a2a8838a503aabeb506bbf9fb87e2836082e1c9c55b0e5c082c0005b62a7778580858ac9d4d82171888b2c605d24b137281cc4556faf70d786dcbd9ecb11836b15e5fd7ea078399ddbeea4c4394fce1c704fde18a3588ba080cec67ea2bc3312cacb2a500d60b8e54ef07e95b3ef689ededb284e8c9c30b587443c77a1628cb3340ca7796768fafdd32442bc2b182d8c30fa54967c312894179aeb37e6002bf92f76af8adf5c12a0a43a7b419a178ca582d4e7190fa735411f01b8246ddc10d866916bee3dc55b59e58facc2713350bdeec614c937012efd402a99c5ca83b1c801d879c456ec4ae621d58c01d65680e52329ad87700789000a5c802ec7734bd7048b6b03fa009bc98e4a7eb2c34d3bd5b811042424680f5bc6c257cc32726f24995f53cd1ff4c746631f090e60892fa7b9e7d1f0d683121e2fa89b09d8594974064b33d11a9ea517200b2d570355eeb9a39f8cae722f970053879cba5ffb90c551e72adaebbdd15fefdfa0f3cf4e04ef9b67f9fab96bfb5d72d6cbf196fa98f1ee1e878ffa145c9bc4aa3e411954494aff8b80bdd7049fb3c814ec70dbdb414c34db693d6f5787592a0f1ebf7c1b89bfcb3fff936d7d7cc07326a52a57206c33ab8571101a11ce9245a6196e1e5f922edd50a3ad03b8e36fcc21667453c4399b0f4ee39f15550985c911cce8d26cf7ab1b815e7216a8e96b8a812462207f8a51e9a54923138a0ac220bd00bb11ef91e1e79f53ac8a70783e7a6998680e36000d002d53ba97fd51a09774f18d9a4220ce50c39fe527ae1024f2f285848ae29af638a1f5eb056305609f5e15cabd7b90f15442765684a010cfe570db9ba66de5ada9bdcc9456a3957bfb48d7f8051ab2234dcce2b8b01ae557c182a8e9500d4867951925f01016cd52046d8325f45add9128200fcd952cbc13230d6ef0563b0bdaafc71ae3c4f3f6e68d5b873f164fa1b479ae98428bb1e3cc034dc658b8ea4980e0fdf7adf91d61992d50a36597734fece06d591028ac47ccc25d7d988101e6b5cb656c34e362af5094e92c20e0d1f3c36dbe2f8cfa0a84372210ba20357e76f18e47e3e4006f1cfa400d087a61fcd2f101b11befeaafdb2994576a78f75839b6a69174175af485abc0e0a6dd81e12377ef180101d3f6d21c36eb58ba64c26f12a1d97c086ca5846a36eb3462bf35697fffc9bc1b97d0266f85c8118dc6594cf4ca82fb8405433583610c50642728ab66df25b1bb94c5efba828b7df6eeaec9530cc9ea33106e18a71790e0e4e531247379efde8299d39980e50a9176e18ce6aa82ff11b5c7f1694ea16294f737bcff2a0d9b4b26bd39db9d4961a32210e5321c667a95be90acac699a906accaf29ef36762e878789970f13fe6160db446ad1d868fc6857e68ee66d6d085b863ed18846e55e501a8aed72dcf5f08bb7ff70b48e50a144e7a037d214043015c69b0f18f16fdb7f9166dfb55a68480567cadb4fb21fe84559bf57e35285b43e3aeb1e5ac4feee183e701a834a55b0cd4b2f61eb9f37ca8a9e1efdc97921304be01b18e1d8a2d50f2c7978d090590f5c8ad4ace6b78b551e65cea365c8e352c5b4d6ae57c5a32e6eb632426b6e6cfb290198222b29705b4219c632e95124ea3d35f2925e45358733ba4ad75a7490ee8e77f8c623bdd3ba5a7c054e922fb8269e684ae154ecc668738bafe1a0188dd3beda462d254bccbb8187a9cc0af38f7b86ba2750b4a83b7a69da5a8316aec1db8a4f1fae550f37deea4ae9d47ece3f63fcb8abd655a94e4a13c3dcea1c662ff564e18662602ee74df9841be146c1c537454c28c53f4ccdac8c632c4991e8eacc8671782fec92f9b7d2495692f01880d715eeb4be0389c94533b93703818e330155076f9aa9be168007635b1f526d1ae5c92df354b5595c8f6bed3cde41ad916a3ee440ba1b65a93bae9994c4f8e601e079493963ee67061874ed5da40cdc0dad7247f68596979ab7105188584309ab480e699430b5a433b3c3013fbd4a1103ee8b570ddae0e9bc2f4567a94da0d98b2f182c944f3b919caf8c009fb15b91057713ee370272adcd8199de644ded7c908803c28b47eea19f486e21cf39d0576605ad7018612958263f1e672d044026f20eb1998ce3a4eb5704353e56b9b34b852dc948dc9bdbf1e8ea0a92a11c0e69c1ddfe16f39449f730681897cab56c9ac9b7d010005b1a93201adcdeb8a75390c6ff54b5bde37028332de40ec70694ce8fecd780f66c031cbfd4aa7c7d4383e5db1d2451baec921a76bbfceeaaee1530d7bec19525713c63f37a1b18df145dcbed6e981d600a6e1ec26b540e92601e841eb7114379313738f413fbade80b2f501f9bea60d12a43a045780cb4b373aa6d610e206ca386b99ec7fa1ab6681a9320bb86402d6456a8866ef352efd816affa080c327aeb164b11c3a51c467a5c78ee303787b0ac4ff528feec12ca3914f778d57b31d8a7eb2b8763d95fc40662d230d0b38b0e5054c775ff232cca8182b3896e6c8d1a2deb67ef93701b60768ab267073c7c89a070257ab1c771f9859c63414cb4f7b00371efde5d423028016cd0110c06e83069ccc4b26762deb14628080bf62b3700526069166038d95e9b1b1124775efc20bab823a52505ba008f3be66d99009d7730983766a9101f6ec5da1c69405036fe5de161db26d6ea785083ac9114148221fb14858b5f911a561296961b2fb232b0adc013b6802a2df0a766aa0524007f932a585782a54be574ef37a4db1095cce6be681302874a9fb8b1f992e2e0fe8ddbb4e84898cc168153e21d70f2bb2c8b9492782e169a753d9cb525e8d49a2500d34eb0a2e938ed7307563d48b321749501595da7af439ccf5861677e3b90632669029110ba5d59e2bb4b6f832425830e954a04d994421dc8a739c9878282fcdc5a928e20cfb8498b4687f921469938265809e04fd7ad21a0773a96e034b02f066edc0fd0afbd445f88487a72973d333ca5037a2d9f90c5eb0619616dc4c575d80569d9827e26a277d841586f9eef6394a325b5a9da5816b0690c558aa29a1331c55c38ec713216efbfb9322ff24cdc82e4d4034b3d65ea8c84efefbd3e5b116471a9920b77088a9d898fcb49cf8c4db764fbebb39b39d7b7b25b121d7ef7958930de12ab652153b0e893673c23b12b60c96f8a7c28d0ba6b5fccfa50594cfa6890e32988cf4ac0cd60480a57a84e4e25f21ac2eed7c9ed841fad933e2777f7f09a13bcf80988dae86dbe877d4e2e6d57c49d22625db425d9c44611310c5f46514c1a2c0f6b61ff1620410c05dcba6e427b9650d3baa8ab87e031f5a8cab39c1fde0be43302f8404f5571e5af37901145875c1d3fce05d7f777e1ef2f012850594b004888133fac7d0e4dff2b04711364bc49509c2f7e629b3a4f991497d542efa31b4eab2e0625f9d3272247e1c4030f9a19416fb5935622bcace9f200fbd6b7704e655e223135a99f78ff664764b0174a824c4ee3b0192c2768094d7c30fc2ed5f70cc6ab68fa1b493902d21cad675f0934c31e77b79fd45011bd0e6c6fa386f39f942d62ba5adfe773eb958318a52ba4c81e075e1411f7538ae17ad9d89d7f6875940226f6d00f823a9c58ef23480e25949414a5f090ccea2542db643f22c2560e906ce76684a618e231164ebace175f8b31e3bfed98153775b3a2004dc9314832d5ae47daf51ee6a813b073832949408cf1ad7cfcfc7f51cd2bd4bdd969751863183fe118995b7a268f35ce53443b6e12cfa4bc34c084e6d3e9215b6b51e477cf5248998da802478bb3192781efc22bfd2b2f85fb536a2e55e0295c094f92ae205a15bbf77e709b5a6b8157832c2d3e67669fb054c1f37c535fccfa7e409f4cd81fe8fabcf52ea3991ccc37016b661ff5bdd1d362ecb0d547a4351d567e1a839ca9e3c5bf27a9769528d86762e0358b7cb1b5a51115ea31c2afa086c93865c2410096e29f320b21f1c0887f25bcc50b320934fc9daf1d6589cfd66bc267f77d1128003c18b5c9ac345e883ac5ee11c5c41f543df29718dcda23807b1736fcaf2613003844b709a76c35d89173668af77459416981f036830aeef0eaeb1ca09d711bea22350f2a49db81dfe1b5a97886d6a15cb98190dbcbb877a3fdf629c30f16a6dbc2d674285f746fb1c2e4dc81f42b52f064ffb8a32da578d4ce9b76abef5a91947760496d1281804ab6f5bc079e19f02fc1ac63f76402f7a01beda48a08230a9dee6de6b8c8998cece6a4b3d3a37e880dedabe170153c9abc9541140cd00b9be5a0678cfbb72f268f145f265eaa781c34e8572b96327a64fe48d57827d492fa52f48907c0726062fd737640661d835221668cbcfd44c18b8debdf7c4efc016d4def3660e89921e037c27c7cb8c350741ccf2ac9b16c7ec14acc7e4b10d25ebd205d7728224187ea93867da359a8a6ad25d56a6e55c9b56c7b5ee3abe763d6b672725238c8c6037e8435fbcad8120f61617690bb2c454aed5e3c3a96f7d9c09342a3170040ba6e8d29021c70326cb3b8187e14c9aa1465b010a933724962ee485d4a46e1aa9d2d34d485827f3cfe37039050029d6d9625888806cdd36c0e1735c0ef6da4e709518ac074949a3c299b54168abce3198140d1de4d1bd92e48d59daa82abf6efe19c71cbc62f58b4efe1290d3e53381f0fe6915aa39492fad9e830408fabd9f25f0aceff1d41e9f51670e3cde28d1f89dcca8c1205df05b2e6c49ce41a81a9bd1907fb8fd2827f41952e5cb779f1401f3893b6a09bd0aebaab5b136590235e02f74f98fd49390757d8e55df118b7accaebeff5e707b4c2dc06e0cdf03d6444b63ddf3f2b7642e585774130b8433a322f989b485f6947a1e9f961a9dfe9fc3ef02228fa1586503d389ccf054d5c5c75c3bd96e065180487783ece3d78f79fd925ddda2c371ffa5fcce34c1e1462d54090d56ad53fc0090617983fc9778893d016ffdd7d809d440149b3447c6567ab62e4b43a90c784f4d42c777dff2554775e325d1c3100bfaa1bb997aaeae09f5c8ec8418345aed6d18de9855388c3fc992e3dc70ddebbf76cceb7fe39883301da39e36de59900d16d9db725f864746823bb16eb2820f1f6e4f39a3026e90d14a0f773fe6ff0ee3cfc8ba0884e0fed0e24c5a4f97c6d0e5ed7e07606e06aa4d5171cb43105dde426b9f227e69800a77f0797874bc401cf356cbfc83f8ff46cf1a38163d58199403ff40ab0177d994b63771332b0a7adf6674aa05b720dfe350fe87907ce62cfbe711c34b75a3e6eef46582058425ceb36c6e28e091e262054059cac5b54050ce32e8c3174db761ab30fc66972d95cd0d64961633405807e0d007556f5102dc2a49007832771b84cc8253c71bd62b07fea9e4772a7ec7aab58b23316faa9baac9a6f32395c986bd4398077f13cf5d2c0ddf0e6ebc469f46eeaf22f1e21714ecb417406a1b90192da3f1d4495c24cf6ffd5d101283b4649796ce7d5a802891d59ece54cebee724ea25adbb4f35512ba0d03570b1990b77c0578cd3364b7e51def8863d4268d1d6f3ec90d2bab2f557233d0d94e1a364474485c72e07cc9f90dd393aa587200c7680cb7e0011238712be6eddae7d5658a5f87a60432fcf767210978716a2283cb0220e5f9724a85107dbe64019e2763722dc8c6319909ccd96161512e216b137d044536ff5eca2434182c31c0662e620cc56752162d5b3fc894812f3b6eb862b4d7b8da5921f73e5d03dc8599526509cdbda1d6e8d80198018a5a91665a9d9fa7b3e841b769834d97d49932971db5659070201c4116ff76a0ee14eac2ca39ebd5baf84eebbf3cf8c2e3af8bad70d973f1067d12744c4b652ce27c2c1b80112115cdca62fff9e27de482a5ea08c6a63b633c514c73b3b52aaa47b1d79a65ede2f58f5b8cf5caea9070050d4159c71c0b9a4d6b552531ecedfec19e61b69ce0591ff82c6197f73478eb6b8fa7e62743169c92b5dbddd52c185029dfe5b558c7af6c7a919dd947c7492798112fd9772a62303014c62702ef28846a4279d129118662791a8ad1c157b9095dc022165cae6f190824e5841cab8c67a9ccbb432a5f18b8d2d3c89c57251bd22d4b62e4865c1d230c32b4b81b825fb074665699c8507af4c97bf4582ee10a1829b3994710b27e19cc96a1d4a8b8385e9b3b95b13694750eea4820d7917b322e6817dd048ef06d7bb21069cb5e5faae526cc71d9823d58635d49cc3221eb57db3aa779b5d38d94c87261048282fabe0afb000f5c53a3ffdd98b3eee06d37c8536e50fbb6b54f197a94bf8ea7ee7036feb187fbe2dfe1cd57637a54acb74ba3bf009e1bbe308a2041c61584b1644fa562000ee0320f33f50d34ed1900cecb47f91eb82a2ccfce0c8707651e422e913aea2ccee913e8ec318dd4aadfd9f687c8d27e61d30695ca6599c07f7b0a8c03d2f0f4859cb69d082462aac6634c59928942cbed1a5a18e439f5e9a3e8dda433d092d38f4a1e2dac01f36cb7cf9e0ef41b21cd4e9898557d15c1318a884a3090364245b86af30149a19866506f0d5e80d8f946142bd4930761b994c6fee386a891704809442f8b43fa770185123c9dddb3918e6c9ebfae5adfe866f66c0627553982f7cff6112636462ab2aba37c4f6ce5cc77e3570354785c2436e49d1d774ca2b9b8299805896a4a88390ad8d821e0c96f8efe651e4f7da2bab403a1c7fb3c74529390ad51ada3c59fa0b02bd22198a3ea84e291957a0554f22948ae7262f74fc312b1dbfe4363a32c04f7d126561e88d0806e2658c38e83d88ce9ce88bffefba70cad88c090f9ad9c9f5c7f933e80b69862dbf43bfc3f0c726eac154eb71e6a8db358a60670b5a310b6541c22c2d81dd250fea72f899a641570219215d52145c703d39008b6e5d31775ca33c57db4818a6909f69ec5ab55a5a6c680775d281c593cb21efc3dffd4a1b78519a893d259d525ee0a9c8e980c9d339c348dd0315746f14b1d2276e5b34c83c60be9ee5bc173c5a7ef69a5fc66a93482a6cbb45690d0ee970e577ca1998c614abb5f35711e00bcb9f90fc50e84b8e47cabad62526873921bf58b5f8bce088c99cc48a377114c0699796897242ffb2d7e2ff4e334cbc1330d3ae17b92e004a56c937c58a6a44b386bda191846ba8d140d2a09bf46f374987d330d8789607a353f5b84bf979db1fcf591174074e6fa06141bc046725d481b39c60ecd7d1a5cd9246f3485719911c2e8a8cc71ee9b7897ab385dc5836d28aa8de7da5b44a6b16545267a718db680765bde65630bb513be1fd796097da98d13ff347daf38a8e535035682b3c530fca9438f7596c07b04ca338132899c851a09b0f0b9cd22807fd9ad4188c16b68bf28ef36a1b1942d474886d7d87518e2bb7b8fa8cabf6ff95038f39e724b979a600f73526f0bcbc59155c609ab86f5e13a009ef1c201616d9f3dfd08816988631464ea60baa276b8f114a8b25d11aa70871de5928f7c6924e22bfd23f8a9330e5144f429573b65d72c21697a070924a2ba0c96fb84b83bc369809b41dea790ec0ce2205e695cdf5e74f53a268ca6d222b21b134638ff7bc1752482f8c47c3bc972d15be545b56601eaf81b55f0d0d3c1eb7aa26dcaf3831ed471bf02cd247df61dd4a6919688ff15bf80b1f16f4d017a30d7121fccbd875372f28d585797202fbbd9cf499ab0082c1dc4cb12303689fbfa89f73765943e4e9c8615c9ecfbcdcc0554a06fb192ae3bd403e834b1adfb0fbf1e06e4f8e921afe7fe707fd0ec9aa0150249c80dbeadd8c3b00e409f83501c10450830edcb9c578e443ed9a81130731c15e41cc04bb00d0c19e06d28f873915cee7b67fd4bf4f1e56fa0f53a127d00337bef1b0daad2867259ead6dc3926d096c053bbec653f99cfd89e433ef5332b0eab9cf96ec78f7e4b9284330729fc23464064200f9e6a9d1da6b487db3c210763d0b6d3bb3070ea95b5d2604946214aecab35051e2f8bf9262be2bb49125ba70a599fbc0377f029a79f32460dfb0df9ee305211a2b4d190a82130b26a0fdad7270e88a5b455d73dc8bce88e1c9f4f6e02a2d9a558a1631406d2db441b32c513dd7b2c3739be0d2d5ea4b5b4a460d3d90af5f9ec20337c7c2c784cb9fd796b1b4e2ad9615a258bd11ac8e92652188896e7799e57f7f249ec23233294b88c8151b5995739219ef0fa17eea76493ee56ddd7c5cd47ff779c361a83f2d1407c584a4c9b64193f61d14bae8bfdd45d151484fcbd61566cae7b8f1eb51e8c958e398fab2bfa08c2c8f8611bdc7466b23230bc2469be14d2c9aa20de768e4368a6ed3848867296d88a165b009de62a00a4f512c93ff57a70dde11ab1078a74b5115be11e43c39517a5ca141346654353c9094d0d4bf35ceb90f383776c47d57420a0721040966b6c1d62e0e997f7c2d3bab51e0be7549c17982bf84e6950901acbb71a44458ef48191c6a7bc6965f61624b48fcfe41ea4c1d54327cb34f7ac221d063b2e0b25520fb4db3523d39be5f20c85ee5a5d88c7da538110dd9fda0d0a62e2391945220732a02885e7b98d0a58009d00a3a723ffb9e5470aaf7e0ef1eb2012ad42522930da389e2b7b8bf6dd8dd44687c5a40585df8dced13e219fc298c74662d9714039092aa6c3e1642880c6f8d4d5243dd87be90fdcf3fbdd9bf5813124fcd7bf3dbcab63201e88d252c876ac5194b4f6d086296d5935ffcfc5cb99cb54b966906a39cc28695a1851906484b392c27b7d195917dabc9f5b3958969dc0cecb925d8f55639722da479ff0d2c232c87d3981ef17a9ab12cc8a61b04ae12edca7f2a48f363c9d18d6d5819b19ee19003bd2e87455418272156ad11ebe17492f9dfb1d3e128689c15a16844f473e628f61fabd0b88fadbdf124eea6dad220042b32e11d87c6a1d5787dc6761127566bdab8357ed1b4768f90d6611483161d22b4a8389186d6996f643496734388306ce548ec410c36c00198ff25ac2f229b9ed53a29581cc744e2e7d8d92490dd28360c14c93598baac073f86fa123f80c531a66e8affc021df8e749432c82839a3bd28122108a8442bebac3434c8a16512ab55955018555f867b7642b9db597894a75ab0000c81f2d1ba821a1a87a1b3ec952e4d2cb8286934537700c6a8603d545bd127f6cfd3e51b35422d0b2e2f007e9a55c284005ddc70d85b2f8df037d3c75406614e0e6a1c077ed9d8d5632779eb870c6ffea54f21ce636b58c94e3a5c437c7d6976d98b3cfa85bde04e2de1553ab7a214abf4ef299652a954418e423bb0da3b49a2d341cbd563cf535779fd9630e88c4de16c02a17d7c36ffe88c10f29c1558e764ba7925ef6c544493b7cdaa8c64c604378ba3a02986fd92a4acdd341a8c0c7bb3f1f7d9d9b7ee58154979b526944e9f7751faa3274230904d4011379cf228be33625d4cec99b9baef68f972fa9f3211a9576535938589bed476b56a5729cb1d9707d4cf43fd6ed0b4905db78439c4318620aec3353342d9203c745d171e85652ada68c2171b556c98ef3f8b0b54a9d2cc0e83c6e5c83ff7c4a6ff5ba22e18d42cddedce718e217d9a21d08d61bebd244b612990112b9fe9cdec3872d4be6d386a73ebb4db0ba5d9f7e21476f6e9ff929a608f52fc711a40d68bb7fae3b06a76718dc9836f5b2cf5a0eb86b529d33183692b028de22db2127c7201a1522de8f22716d09b6cbf1c49b72fb7bd212cc57280db71fc19b9d210a6aa08410440ef76b5f40f73fdf1b7abb41b532e84a03d65dc1c8fe63badb0f5227ab847eb58772ce7dc80bac4287e1e1f5677e908d91a035e5808e9c907eef7876ccde5de7987da71a8f81ae3402dbce411f4515d24fd23bf26d7005d4794ccb965ba56dd83c7cbdfee0cbda9ff7005a1c6ad912a44754dae1a1da6ac49bf288bb8f89c8e7df2d49d98e0c92a304bed8974b46f3b0846296b6dcdc1910f82adfe392decbeb5711772e9f89cd384dcb39c44a1ee077eac184bcb95133c273b7654fbc32ca2a19d783555687aa08388391ab83687ba635e7c8117a620d2658e203fdd06f835623bdc0a9d1f67ea1899e5ec8ffe6224d1db6b3fab67e1252a5ec256ce229ffd39d41259bad1d69a46ce425a005628427d395c0971d0711cc7443e23f3e34b53066a47ce124d8a70c7fd9bf5d61716309d63bfd3aff346054cd1ea73bf0eefa90a1b8cc407069946ddc5b35f7affb6a2bdaddd9792c056c9aba563027e1dccb3119e25f723815bc87de3cbcc770ccbc8ace611f10e47dbe7bad85a2a77b17249c3cafcdd1ddac81f09bb8f70aaf17cb8ca28a5c3a4ea836ed7153f86773a160bf24457ba03809a6469a292ae03a58981a8b1fd87c42431a23ca944501a3c8be85c339c32aae8344a51882a537362f392112efd0a0f62e1b89ce5abe7b08e50a1a3788f8f5dc9e27d7acefde45394b27f77cd22ffbcb26002665e29161b6a908a2801615842cff2491dc1c32a4319dcf622f9a438eee9a029eb80f8bf9e3507a5b7ea938d7cd82169964b6e7d08118982b1328c5316951d699ce2b967607a94df334ec8db489cde8f03f85c1953dae353bc7580d248af29958f941655da334a4135a24539e0e9b88bd898e944d0005640dfd4fe42691ac8b002d08bb1f63c602bf4fed452c190a7b00d93e16cbbe4d24eef721a64d3c84063a32a86539dde55e826264557fce17c04e130918369ab05f5efa631156d2c60f7469b5ccd7ac47dad4714a4524af2a9586f3908d7b2b8a6803f3d6fb58d5a25a412963ac1417ae9edbe25ae17a05e2debc7b470bbaa96e75c3a5966d9daecef89f8b201277a91b8f1467691344bb74a9292822fb6a2fb56be348509e9fc25c1cdd7a0397fd918aa89d6cdc1d51ce9ea0f12ea90cf71682ee34c3362e86d4438df91269162ec7afe9c55b9446a957c4c54a3ff475145d9a6b6888117db4e5eaef1386c221a36cef00c16a2f045b9975e15386033a40ef364c3a1e6c33b74e531ed4592de4a34a84388d2c3aa5a23ded91e4095e5c759960fcfd6f92aaa77372c47715a99b2c48d256de89b11c09c7b5fe2fa78ff22af4e45b99d2c964e4b11c5a37764aed5b30d611ca8c24441e99f960107b4dd07932c5a866d51a0e0cc1ea511541673c44bb94063254860f2679491490640f8c9fb0eb357dbc7ff6c4c2c0778f245018f4da9eb1ebd01ded5c649568e9c6711d811727595ccd4fe4aa0d30647f6796dca042f24746ee7bbe4b5d8d97893cf04944666375771f159ece94482db13f4715a4cf55369689a23c53e170e0bb06bdfd2ee15f9a89d5fc132ade3713db680b7fc368d4bc6b39f6e1f68e7aabd8882deea7461df0211c5426e8cf441e863fdb02e051f5f2f3a15ba7555ebe67b8fea237905bff2e1c2722a412b7c860c3317b6b882db62da647dcaf31a8838088e0c3c0bf4dc411d807e81401e72bf114dea5c1c6436a1a298f332be146f2fec813f1bb54c5707f06be8707c016c9c5a31013e10581bba3c5858750e91514464413e7e88f71a89c92b29b5ad9859b920d7921c85643e18b4f28a75b7060a7218eca89946b62daab95ec39468e071c3861bd773c5cc8b3b639fea3fa278d65a75b9693f2dc0aae433aa4758816d5be7c52e8f64facaa5e78a359e4e39da8ba28991ecf200a3eef2564310bd5b2cd0bea1978c5a89b1a8f5898c637afb718dded1d2f173809134cf29ee3875e5bfae417608fc2bd3dff223a854b9702f9aedc06302d0681c199142edf24eddd33505133192ea41115d8d5242f14791067755ccd10ec98b1b8c4090d4dc5d1ed2bf804ae8eccba4a2d6b4a1b017080e105656f642bf99a80f71d98b7612a1c337048da3d10769c12373ab3c3866560abe4dddd8a01ebc0f00bf670b36e232e160ed07f6a4794d1f717cc2e2daec2e579baf1eaab862be879a8c33f7b9aeced65941ebf2bfa66d2662585caa87724d639dc1a87662439131371e71259f6307ba194d70fab5f59190a0f057b301220076dcbd02320d558602f7698781f5a609ffc291d339618cdd6f1a69e4fb7eccfae65c7507d1b361d880b2982075b676f64d5f3cc909cf50f833a2ce390eadfaa0d41d7996848ebcfff4333d9cd080eb120ecb0df74f92347bbdddcfae579dc14eb05ec23fe354b5d0f09fe94beb6d672706319ef985e5693703c818356242601effec71d2f204746608c53a1ae490d4a2dcfde8ee032c99d7057d6f635b260e811fd882eb490cbc510f7e6ace0c08a1f8e38406963829bd55db708381155a81a52c2b2b4f67796144d965b2c8d38908aa8f0372c3d91e0559aa37365a669c661380d49c107eb60a4c81440c33ab19a71234d167f8a89dfbed148ec217ed97447ace156b4537e0d460728b5c280385c65d313be39baa27ce3f44a532fcd56577947b2edb9bb24c95b5932778e2a6647b2e9bb4df2267eb0ae8329ef9ff284191aef781769b9575becff7d51c5d028974b4c3981c4f4c7b0fc47614d2a99791868f6331046603f3a2588194fdbbfdd998f8049a565bedaf51df07d6892174d19b4876a3f5b1c4f7c5e414373a2ad9874351fdd092dbf8f6fca5c3c645942809a341e7c16c2ad354c759dd39a81faafd4cefa27aa40a914d3c4a5c0419d12e10e039e1166564e1dfd0d1c11991b2f7075c212b69e1b2b1287a387a133a7945213e6d503ce976a5aaa58ea3cc4b0445b24a2c145bfea82778d1ccd086baae94c9518df7e185e404fdeda70e3b0f2dc53b1928b977cd4d9dfb526cf374b9e4b34e740e4bc975f1ead44b2632e1875773861a996388d9566c8037d19943067691b9d7a429418d5387314e69454c91ae403f99d717c92eb0f78fba6228e61ae2e7d01caed2c9fe645013b56b9926db39f0c4fd6d067c8b3b9c9d0bf72e040195ff6b7d6b8bcb5b78b302017869b8690e2ca1a728c1e17d9d154ae12031f01129fd4e955090f31098d3a1655ba9b87b307a9c2c78af427e7196470eb453410ff9870e70669b60651a221166ba6299bb95571825247aaf92e028c1bb5ebd9915c5215c462c8f4b1dab28a95dde7cf2bd1f5f76a7447dc3fb6521dddb6e7b1bedfd76c53d2eb43eab18b23a4bf06d4503e84054e87e666ae0339f87d1fca555bcfe01459818e053bc99aaafef4d5df2810e8db206e31068459c31538142c9311042036c65e98090f331ed60b0bd4b77f30000ed4636610e83a2a664f2e3592c7144fa89ef3e78fecf4fd4072168168a2c5620a5c60119e48cd8393fded6962b22d5f9091f83626ab1a0d1e47aaf37cc3c647590ca6450844d460c4bd8bcad09294af2f527bf63d9c9457826755ffe4d1494839a39b7aadf80198fd179f99d2260bd213770a450a58b7f4ffabeecb6c0cdf066210570ea29d05b2905aa47413d512980a404195bc1ebcdcb6620b62b120142ba720cdd4c36ebb705bf42098a0afa6b4287782b38f514d22b5829ef4ecd30240311c795e886988048f34acc6009a2dd95a82aafed03326905af4abbd258a09f834a312e5366b35b7eeb502ae405a21b5f8b2e68c3a9e71a28e7c2699908de08a9385ed73ef65351af80faf37f78d8a2473742f6df73d2f508cc790c8c0d23539d37f74bfa2a0254fda72ffa2b3acfe4d2fb99ae727738066ddd0b6eeab8907d00fe444a38ac1e8bf63c67f93a9de4944a54deebc49952878bcccab035b0e4871cbc220a5d7dbdd2aff185a6bd5a118a345a29c6c9111bfd96833283b6839664153dc43646c2deca06755095c82098e30213c985dbc15dd1bb967370078c65577a50302ddea93917f2060be444967424c96f6bf3b2dfcd1002138439e400fe3d66dd0d38969df0f61cfea2fa041ac8aa7cf89b02bb63053c040cd416af653ba2e8b7b9271f0f56f0438a491614917de7208e63e4c926cf514fc97a7884602c348dc20d02d14cd5aac8ec0ce7fba996e2ac4a2dca2a347876f88a3706f6274e21a91ff43596fb4f088360d314b7054c25c127840c00a7338f00ea50f952ca8b5cc6c3619aff0278317a7700498a3053c764c0c85331585d36466ac76e78b7dfa88e42ba633ddd3f1491f84a0c2cc1a6d56f78dbf4bcd48c53b9e6234e32d29acce12f06f793634c236afe1f360c294c78feb8d548dacd6cb5f861ff590b7d8041037cf918c25c5687e0c2b69f30bfeebabd6b76024f11fd04855e36b2f5666de151b8b681cdf2d97088a20388f0aba54c08123bf6982b2ee4a300ffc1bf292f25a5007df8b73a5dc5dea2a3226fb400f91deee720601ab4c63df6dc4ecc54661b9a18c93fcdb0199bc410ee40192b9608f1000b3a986ace01e7823ba0027cc1544ab4a003650d12af1227d66db74c78934d7216f378a3d20711f15723fa7b4bee9a880a1fe5060282738b75afb5661f95cb7cb635f42386dd299b28b9706f6c08b0a10cacf71fe250bd90b246b430972b6cfd8a5727b62119ca3afa9918aa36424121fa1ea0638cd4e4c0200585c1023d5127e93cf585a05dc7d485fbbdef7b68d6911d0ed0f4ab6be285a842ddd051c4958d8d9d89d403560b3e78a2d7cc37d08aac26783f31e607dd375f4c552ac477809712073838d30f4e57b24e729d580b781294d763b25c7d3f55e34fb5ec46922d948d2d364951129ba75bbcdc8592a67fe1355a5a4b42707d14b938467a9d43c5fea7a2ae564c0467281a6e3ce255ab60f0b7eff7f7f24dc7b057f2f02fb5479dd954f90f15063d1b4db248429d627e8f234dc2df15d639592e550b3915c7d8ad4e9e7fdcd4d43480930c450dc942630f3238c2e7b176e912e10d7ba2c590be9da0367e4ce7ca02c63a23dc3e2aec3f6e437fcb0753447260a556f8409e24486b2fa72ded0c624b14b0c53313c40244942de5f76e89cc44f1cd62124f48d18c1a0da12d775e9c40beafc8a36770863c9a58952e03ed141240ba04e0dd4cf88b11507b9bf58bf4746bee50cf3792d1af80db365290f25837da91f429a3d064a195876158a32c6ede883a0e245951777c163106de1822c82f093abda3ce1b5fcf61a77972af3de3f7e2892ef55dd25d25f6ae7df6b01927187925ec17feeca6a64f00c64f1646e4d3b52cf75706bda87454d01115b5f67202741c19b5ea04a3c9ae94a999346ad0e90c74d519c4aa4acc6a4a58affa368c5b66afbde5a6b0f7c4fd1bfb24dbce0df84693c0260f22366cb1b2d2aa24036ac494717f296bd1f4b6ce8e75a0451910c3c3fa2a5e48ebf0e25cebfe2738a50b44f313e9486e6ae1e50cac3f20229fe1934a7005665dabffbc725140d13788984a5c12b0c8095a648699946bc37ad362d2ab79a84cf8d4bc0346227a52b40b2ef6e7f1047bd98022b88e71767e8eb8f61f70c81436bbe0a17abad222d0010c26f5b0f26d4b28a3feb1eb2a34af3ec491d63ff6a7da0aae0fd8ead6977fc02b61961cdecf001a6984e41fe7bc0b9a8ad24dc6f3789b8d3eeddd443de6bd3a12abf34ebc2ee7152cc298369f2720e10371929b3b5c38e9a6d7ea91aa4e14c00115beb87b0aa0464eee762d5eb474e77a11bc9a8fe1462cd018dc18060dc3bc8f0703178b3177ea984321610afab35cdba70e7539a8120460383d11889645987b070c481a35e713a2db71acca2e9d06046a41dc2fff6d4d9c916443b5b83b7d99fda4a3b0998c292787b65e8219da5edc0a63488a1c04c37e1ad4469a2821bb38dc9467f05b70ca3f26e640c9b14675042f5125c54b060c70b3f1264c61d0fd0479034796340290a7230060b9be7969c07dd2fd7c01dd33f8542c67665266e51f59946be712209e1e8bed1847982c4788a20839aeab4cf35ffea55e9eeeae1eed2fe8566c81063f3fc8179dfd25004a41e41e347012c2dfe66809d1d659bc6ed1e4a0977a229ad8ecf356105dc845c1211758837d55fbd9ccbf6f7de4cf0fa6e9423e2ee376b303dd4dca73b490eec3ec7fc1253f4fc898802d593edf976c9b38c5d1f9d37d0f7e6d5cdbac952664913596750ef5805413101401176be1fffa292bce4dfaa2261300a0041254eb1ff38a75645bd4c1ffd0446a281ff6f5b1bfe820ed69d32dd47f8cb6f81843801e0f2ff3b52c103dd60abbff87388133e294c9411fb777bbc9818e26e5b80eedc054c40282b280fca915e313c911aa5a0d8f0348ed7072d0147c898f2317b2490e16c0cdf0f3065c035724a19245de8926f3647db59850f32e8e29fed16aa27df418ae91f5c93911aa0205a29e9c70aea54db6c261a569a8864f1002e89db5bd07ddf76ab8c00c767d1218f40f3db05d211f027cdf7debaa0e731a95df72381ef094df45cb9ca0ad7a81ae600c2df4977fb722de929c7f0922f41298f1cf79d0ae17a3e46a6e16cedff9490356a5d211cf8dde32f949b649f493065afa31f1f34c325c425132d0b9baaa196b8302354527579ef2b759eade6745eacbbc11dc4219cd6f1a01b9f05f82952f8233485c9f57079107a80aeb11def45b06c5b0c46a3c7040677bc09de93c9c3b21be4877e02f90f01e77492f25260e3ee9764df120b830c48376c86d206b5c0b2a4b4311b845fe757b7522f500e92aa636b539c14c01fc2c20fc956ceff9b74fd087c3314dcf81ff8e24c06adf0ffc669634bac29c1cbc0d142588bc3f52de2881b6290ea00750ecb9b2a9e204d45102405fa58af25c02166482632df5cc525c751ac1873aeaf9cbe6893f494c999b4bc2c68837bafa865949bbdc3c445290f6ddfce018de6d9bc19ec01931b1c1bb918f34755fbbd61f4bbb089c60cf9b14b169ff0a077754b47a9c4945a12ba50830f3fae3d6fa0e199f5a77211a942351979eb19cd1b9d97ad5bd340873fc5c19e7a83028fefc6f571883490dfbf1bcc41e89c0b7a404ae77b6b2318c17813d9f0ff29b1b147d49cc7553646feac11a47bd2a20c59eaab4b730085f06c0e6d19fb26922f1ee1f05328d76c7e11f0aa90aad0f7aff603d92d3d5eb7b99ba39ccfad6ee3abc1f400c2d770b0af645bc652dc6666bb4f24b8c93400179e52862beb6a1254c97ce6e9de196adab02b623ddde97d3cc766173290cded705e1a8e81519cc19836b77bda6478edb5ea9fa41ef2ed53561d6a4bef3e62ef84f0ed339b1eb4c9a5677644b12824557b609541f6690976ec64d7456dc1d712ec6fe573990a63537742e586d07b7a6d5d6b7a4f2ce3db2328905014762c809bf622ccbe50ccda3742ad30c9c4c19895b5681e6f338b92895fdc217f2bc408dd02502f9027723ca9b8640abd22b39a4332240a7634d9048838e0c3f5c18acbd36f6f87e8cb9ecc7abbb8089366a7d5eb6c3d01a7842c4af95fd11fb3c48a793e2956b3042e8fe14bba5aebd16b71cce0d5d892645ab16ab19da271bf8b755d4938cdacac96e64da98c20e29cc4acfdf1b4f56851e2d80e1dd277e1fd57c86d05340b602fd52c8059e3e3d7e90b6ca7bb78087c0d1fefd90b1a17a4db4cf817b33eb1d507a83929f9099c169f67c27eb6d83b85f48da368c4ab28db4a76de41bd9967f55e0fba0a4c55aca8222a3b79b53a7cd58a462f6234c2d210c60a7adb9d69370a20993a7fd0e60f22c9a0c84f3c4b8404f8c09a47f412e9456f8babe3c636f2500f28d49dbd3abe8678d4dc2535af179d4d2dce797e0f26881cf05b0ed804922dcabef989484114dad59acd856edb10b41400c10dd2dae21503072d95f2615451580a6f8e3222dfb890d5dbe27e41b46ae2720546ce8947d2e6c8866e7467366def50ac1f37fad5169d263cff7773dbb35f8b563290a2229df50a8df80b2841ed830a81e21ffa07f2435b0652bb8c51a279e60816aed7bbfe5ea35ccc2450eb2b3fb5728bcfdd1e5357ceb26b597bf2b71872231a136e67c36845990d8a959035456032a63d67a5a30145ea503994e4191ec1e2aaa874b6a029bdd3c29cfe5f63c1694a45895bb0f30e2c0a823ea2fd6918ebd058120d24bf33f000cbd49fc7ab310afae7e6b5ab39dd9481695cc0a48eca57e98a0f6edf52dd99b6cb9a59429a51475077307a907d099497bfe9e821dec58885b34dc62a1199ec80765f70df91ece8dd6a03c839ce9b1ecb949cd63268ee59e7a64b0d670344ff31a0d3fe4c73e9e6080cffc5c19cb9e460334199c3a78bc1b2e2e48ba5946506f7a9e8b870e560de892cbb5e41a8ad262c245c9e55a720d452162b96a66686a6866a6ccb2168b8b926bc9e5e2e2ea2f5a0708a00ac46a535b6538fee632c3bda79cbb56eadad59ecfb44be9071757abd56ab55aadafbdfc9801c9e572b95c2e170de887f250ae191a578d2b860ba929caf52ecfb514d3329454f8ec0411bcd4f9f3b3e7e745aa5a8cf7776d32f33edd62209583542c757bc80191595c4e539d5b696e37a05c6568af3f08e7466b50f24d1c0886542ce34080d948e0b404850a25966035a1f90915d0da63da63271858d37e25d39540e6655e93e156503c009fbf04503c003f7b7982811f76363054e881cf3a205eb5af407bdc8f36f39b0e9ff619ae37ae57edf9db88423346d51b29f413126fc00ea73d98b781049d9376a8da62d29e3b92f6dc6d7ca19ee448edf9c6c4855a67be7f659329eb3efe2dcbba8f5ffbd3fbb8c6cd6721b1cec73205fc6ab5f2b195bb130cdb84e924242714a93dc76213047579c1d23bbcf26f2425cf5c9eda9a755f67a9ce318ca53a9defa9786ae79380fe01d37d3ca7ee536d1d4472ee6c0cd18f4e28b95df21d99b70983c6aea886a391e11ac991609ac6096d6ad9fe9d5aa0f72eef4e2dddddbddd0db7683c4c544a9807de2e2a3f90de591f13892641c15ee63faf2148a1f2cecc333fceea6cafbd6927c6f3f3f44ecd0e7d7ede1dcc621cdcee803755724de8d3224f758aa974915cd3a6c970fbe3dc3e5127e7dc1ed128e2e48473ab0326f3098d829af227a1981cd023e8e6dc52716e7150316ebec62fb3859e34de3c2d736e6ad9e6cc6cce6d13319e38b746158339f598266c621b746e8b284e14fac1189b7308f0817e53c6e6dc01686824cdd89c3300adc9e21c8faaf1807ed0b91d4ce6131a0545c5b3a27ad60a9585733d558bfbf313655e724d64ba7ec935a1dd760bdf66b3395700cac5cdc6a43b0b0f1695158fca4f41457902c40a6a1555b138bef8520c2eae2d6973903c65e5886873aee01d9cc4e2e8ef25f848edaf41829eb039b7332305cee9987840bf89c2e65c0b262c9cd3f14d709b7304a89333bd0c87c3ff40f1d7b83dc7b429e0f838c939f61a0aa71ed88d630ebbcdb91cb4051ff4e05df483ceb1508344bf89b339a7faa2699173386a70a0c2e6dc00ba702ea79ab81b4d687c6cbed0af860ad114ed6d4ce8dc0d19977302d887ada453fdcde449eda7e198885b2e88f66085cdb9154e3882b7611ce4362fb5f151eb508ca3f105dd0eded89cf3b024657171692fdd45fb80e68bc780e8077336e70240e96989016ccea98063730e00345a10aacd391c9a1816b0b03997c26f3feb51284a592cae88cce3f03f321d94cdd2a9fe66a22f9a2af58959fbfef321fc98d75638f598a9ceb5f445b562226e716cce97428dc7ada76ab8754a04b3be3d3ba8e5d89ceb564504d89ce3e83c42bfa96373ee6990b02465e1d8c5b192a7963cc553d47e966271d07cf1543f0be80423d06fb6b0615c13da563ad59f718c85e324cec22e14b8078ba3df3914aae909fda04d127636e74e989ee27678886c90406980f563a2130f28d6cdf6b4026cced9548c6b32f3936322a6d21e4fe954bf9c827eb06773ae46c5b826f425c7454c45a66322203467a3ba609a01415a0cef88d5c60bfa4158dd7fba37f48636e0d3de81f06f1847671f7be4c36fde617af89a16398f5c57ad6bafff97d307a8fd156e8e7f370f7ac375e56aeab9f188df577fe7c19bb3a71ed039ef2ab150e89c066dbc58c85b64b2621dbaf70ea0f70e189b9b717c9a9c01e5f7b8bed19b3bc640d3ba09cabfeecec528bb5bba43e85cba4008210c1146e8485d60eb7c44e0af167d1b07be38ba75f7d2254e8de30df30e3861cba97295ef70159beaeee391e1a43d825150e835bdc39b5466a1ca2716aa3470fd3889fd0ae5c5e124e88fb168dee1244ef5735d15eb6c7b9c456d156c75f38e95d1575e4c4a6b5037988c527a49baf0d07d0df04244514a5a355a609dc510c2a8292cbc1861e2c50701e4404f758bbcbc4005197891818cba455cbc1c89777777bd07e70fb5226887eae88bde689df87d80d8d92cff77361d4df1674ee8abb808b63f5175d152151c8a8a54b9010de20e2fb943fc886508b14b0e3b4001862b2a7191c312e10ae6840653d7284912499e4cd102830371050cf08570922cf0935c1159052076eece76842f00156adf50a576078ed73c6ac307e23562988cd371f8bf19a7c296b638951fd6f0135446a11d028f69b9bbbb3b33bbbb4b8feece746803407c77976e7436c18068d105b010e5e66616742bd5b12240bdf26cdbb62c7b53f7e33de53f99fb28636f7a1bf9304fe427eb6cf8f4dadb48e0f4da9f3a1b6c03b5fff43612e663303d8ca9c3ba184e359cba205ac79265475459fea8fd9a8f8f7f5201aa9a71369889b3c13a096c6f83fde989fc642f01eddf068b61c3be86adc3ba186a78223fa66f55e5eefb51650744556568cf67f061ee6ce4f3dbc8ce05acce24b074581d56c27afefdeeee1856dff9cbe6388ab23226d67fb9fbb19c0cfb31b4e72bc38f0fceda407bfbab045b315a051fcc48a23c3e1ac6cfc3a30b4cc6d051162e35c6960ef55bd7567494850918b78a8b1a8150e3df88b2fb9b257e7eac5facd84709b335a2f163e499b2e3a992072e9892648b4d0c7376447ef6b7bb522ca6ae51932c6a7758f74dfac3a2dff415c4000911484a29a5921d322600e580a48909905026a07062d54f7c71021efebf091640a8b6402285d0a2c3115478d1610b0d3a0a2962600458e504592069a2a5dea8a1355ed7a889154e68cbcdcf809d9dfd3d39806de03e22bdf1a9477cc901cd1ff9918ba1573ff297fb4a50bf10c0daaab1f3ee2b410cf4477ef16d1460aab103414c855d13f9eb83aa7a9fe655c542f3d7c10d5f885054b78aba39f0c2a546098f66bc25a32641ac24f9e32f6164057dcc43edb701fa98090f7a4a6d278cb8a27af7b1d26c2c5c8dab803210cebbbbb8b104b19cc548ed25b5d7df37f04e06b86dd89e2dbb535d3c3d3d3972701c8dd861a0f3d99ce6d14259e9a7b99d6ccf3a8abfb8cff6b030b03dbbcdaecd699f9882148a39c675c03b1bf9fe1fdbc82e067ee8e37c54bd93b67648506f43825f4b010a9d2aa03f54a420b60895795136ecaad50a0a0a0ae2968cb0b165a32756b539cb4b9be29f29a8fcdf168157d4abdc3577a94c4434b9b5571ea0a500853a11acb3ed467887e7119aa4f22f2fa9fcaec3f6cce7ef2ebb3337c56f43e5c9df4a73528a4211050505316fcfd3c43fb66e3db55aadf679797fff019bb31f143429ea9b835ac789608f9f6750f959e096f3cfc9cc44ad266a2566a1ee100d910f4d6da373569f1dd42dedbf0ee22a9c72c94e36e5bf4d6c133d3d3972701c0d1adc921dec5848e3b8a5853ad1f6c0f7f7d76a402613b210b77a4a7bfe454de479d0c32dd53f460ff467d51e507b9d05ef2cb7d1f696a2edc1de86af504ba046d002550595c269c81e7b4d4a295fc3ae547e2bb2d002938f715c8922514f691da5a5a6e2de49d5db4b94b0e5cf4cdc280653aaf313db93bdbf133551018a7c9f4062b985663df889ad90fbb88adc42f9e57452a3d5b18daa176d4e134a5390424d2b45e58f2888c8777835dd79c5add841c0f49ac641272a47e4478b5c07606783d9605d0cfd3df810f0518d1c1f55c86dedf721ac6794a0f5c3ca5159541657d2c6e88162bb9caf529042b3ba3d337b7eb66103857228fb5dd230bb4e82e529e69ae81f5a89a0cd518259add36a9d1d6a1d9bfd45d23a41adc384db7699d59e867a42f7d4a36356ebb8bb43d6a232e44056b7d005f2d4f2f2b28fcde1ef1e720be5b81fe887aaad04a891b4cebac01cd81cf6b13dfbb13027a528d47a1116ead7409cc43f27a528d4ffe7f1764db439fc0ee4abf6d8573bfbc395c50de4acd9a720e452ed3a84973a80ba46432c51b5de94e6dc02d63e3a3a6a94114d62a72c22e65ba8a7a8f9654e2527aa44bd71059402142772c5852e872e560a4850fa7209efc415f32fb3b4616510db637afafd72b53dbcf207a982da520719c4e62ce15467dd278be20bb0ee934ac0ee93466cf749225ce82a579bd38f6384d20eb573ebd591efb0ab8196bfa0bec609fde2172d58c787faf4302fabf00ebd82b282816416b55f3e219dec4e5c49a3f8257e9142dbe39b66caa0cb7768bea78ccb559d88a6531a6a1da905c3749fdcc2c8897c2752147b353a510d117465d8546f922bf90e7520fa8fa2be4936d4fe5e6d8f33d2f6ecf397dacc456dee52794b6daea2f6c7952bb9922b05c09536a73fc6b81e520eb2c0d2f289dc1c00218b2bf90b2d9dd48e4ad854b752f003900ae04a87da3648a12446628e5fe2176050a9fd722585a2f40ec792455a678dbe78523b4a24416040513fd94232022308f5934f3e0954fb393252af1118536a7f2cb283fa451e221224107018aed43a6b34840a6abf7b699d156abf73f207949f4f326c4ad0fd4d09caef10908fc3fc99f99898a72fa3c37a0d7b882814a548744e4a55aaae407b5df3343f239fd854bf14b5bf0aa5ba45c21c6a7f0dcd8c944ea4112a0959446dd9fa47a1565f6aff4a0acd2003735e6391f65a0ac52f9bd32fc345256c0bfd948b602c01fa63b818c6b2d06f02a211287e59b9746a2e8af6d2aa58eb6ceda56269b55ad9f0b3c44a11205793fa39abb6890913f57325fda5f6c36521b0d47e9c661254fb864c5d1a59e5d40a75bb1c75bb9e8a6aa2ee6b6e05eb70506bef4af0ce6ca24af52bb5df93f01f76875b9bea4715f1b55210b5df83b647e968624747be33f30dd37d936edd87cae487a25dccd73e6aafffeba30fd68f839edf63a5d78e5ac7ad60cfb1b052db7fe8209f93d25652f220131065a1ae4382a600857eada4a4a198a07bea74a05f077590efa8828e1ec0eea9566d0f7caeada4a41463ec3eba425dba297e5e4e6dce7e9f3a4606da5229a59473e54af98e75b283b07b50d5d6d322c671c58afa8227155279c1120c6050210cb8a85015a5385185922258441942f203ad547845cb912184b8c1d5c5163f108a20c85042b7f20ed3096416355601000b02c1aaf04a0ca290e669fc385ef7d57736528ffec5213254fb97e3f83c1e0742fee6f7719fbee1a9452aea1cf8e112c40227f343082184703e67a6ccb565779ab529ffd9858bea4d5c2bd81d6eb50baad3d4af5932a8fefca4394a7d9e2cd45e2b5b84d94eebce6404ad47726c38438d147600be90b84e57cd1f0ed315e55ff72c4d68821236b129236cc2c464844d684213fc1d09249cedd1da4d0e3388b33dd3835128f4364e1cc6f1f90d1e38aca3539df26a04b039fdb1f3ce9398c4a2d79ee76d4e1838dbb34daca71235e8c8448db1c6e78931c6185315fed60005157ecf18638cd1852a460405810809546cf9899da5c62d6ac46a8c31c61b75594a961c434028e68c188649214241d7a0803c157d67a5e840870844d19212450f11e081d2cb2e2855ab8abad862071981a32f9dda5547e009a04e6d8da927ba50c20a5350d30d01d0820715b878f1c30bbc60b202165e144151188dba454b10a2c2d6124dca0ff55bf85ceccac085123ec16e0e413b104695dcd9f8d8caffc256eeba0f7e0888549f765a5b6653fd348ab8d40c28e8477d053ce79b9ea1474c4e547b0a80d5d4c1d9bc5009e324f562bd39243ec7249ac6eb0ce34f7f08b963b7504b11df414a29e50f5030821720615151855505952baee400042b60384141144140c8a658416b872794ae8851b4608a1e5e43614bc056498e3046080097141900200846528600c011c5ea1a4979c1f4a72ea5f420a548fdbef20c623a5ef50e54edeea851942f5555d7e88820542d46b9c3585aca855a90ca1f3dc98e91e00ffdd86584c414779ec244acb6a2c2671eaaa8f07dc0e7221d42d4f4df9cd23aa687dd42609d3f613f44a9eaee6024f6e13bbcfa767807d3c9ae7321d67e46e21dfdc3e2800f77d48f5d7cc5d57d2aef3b0c728783f763020ee3070af69f10af3aa0a08b650f5f83f1e32e60ba0ff57468534b5424431847da9e609cfba60386f43875db1eb7752bc4abf6262e6e409b5ad60cdad4d68a446b53bbfbbd9bb3b51765377f92be2852fb073e77c1406e6a3f3f7f6b7d6ac23dde0d55054880f3dd78ab03df91000bec7cedfaf2582bf575f8e985e8b54ebf00ab8f28b4b89ec9b471bc9e694d23a830fbc180f6fa3ddf89a153bc43015e60e8f6cec7e6f43fa13efc7df80560e22f41f14585eac1962da4173d4829a554819722546104282e20c2059d2404138694219a8a2a264802bc92859222f1e33671c5bc1206108e6843b8c088c88a14459cc00737cc2956469a8afabd0f2d1e27bc07f55b24a4badf2a1da1a56e171f688110aa68b9c1122d48e2c7b11c61a5ba472104510a8660a2080b58f0e3af4ae1080d848c8c8c5870c38fff0cfe85d6353a62ca1147645a767b365effad3d7f17bcef5437e7f48257f7d30b587517e00bd9e905b9dc524a97129a60fc7d7a6e4e3fbf8908b46b3f991e802350adaed11142d81b1d11449552055a943c95f24265ea1a1dc13a0248059de8eda671bcdef13ac5af52f114151d1d2121c9d87da1df561f7513655c0f821d4542f977773b082184104208216466ee7677a1bb37ef36ec61629cefee32fce973be4318338fd9c4a07c87d9c4645c8a02e5668f2d73df56b185fb37dac389c9fec9e35aa4221ecf3d1dde411f150f8ff612f0791b17949188d062988d8cc0a1327ba89bcd41fd6eaaff5052752f0249f522aaa83b447ebab97768da3069a8e7ac1046201f9610621d01a38a255354f80fb1183101054208e1a90796a37e5b0e8690d0208a2a290a5bd48c410aa0b8e0cb1660e030742503362842020a1f562084112994cc304b99c54e477bce037a315a70a37e5bc56680a562180d84a818851edc2a5b2c11e40589269696fc402427a298004e3a37fac333685529df291d5aad563b1ce105cca473a3d93eb1031dac503f1d15f2582a589c7051e14348045185464418c9c0880c7cf004880a9fc7e7891315be0f1fd6088aab2655da3a271acc099d60590192a7763a1182110864594ae221b1850d50758b8e0045b5d28c8c60c1beb0d59f856ce4b141961bb22fa43d66e6863437ff727333fbe021419613b2b44186c8204286ac8fca0b32a48656dadd20429a0767dbc9757f743e8a509cda36b406d55e3f1fd12bc4c7d6bf0fb70b226408f6dfee90d6599e9352f6b129fe211c7bc41844c8108fa73d5e0a524377b7c733a4756a689d8f37d03142d426e1ec7791cfb055d7263ed728e37d5a4b323284ba2e33011b5a49467e508178980c34b763f4fc966f0f4de5e5d5af9432cbb239b1971c08b03a1f62523a0c1c06ac7c9a0f8ba8d4dddd2625e0869658fd9c60e0971d10afdf7cc871434bac6a9f1c306374b2f380a972c7455a45d0cf592c2424f41d47696f635ed39eb34d487bcb4166e64c2205e140b043b86e0b5c5ea406b3ede90598ff1689b7188eab0d29d4a789ee2e96f6564224ed2d0cea20ab3d56dd77972bb5a40775bdbbefac2f4b4c7e7ddaa769e6b7ab756a7ebf5bbec3937ea8cfe3a11b43083f20f3634e3d32245de602e78145aa1d8043754f351d92b38b9fa6fbe6ce74dfa4b4fb509eb3f6b2fb78ea56f82d1598d36bbf9d7a9c3ade3856c241ededdb9801fd980933691d5eb5b73f817c27884dffd6227d80dd656dcf4cdd7724eec3ee746b53fbbb9f759f2ba9fb2dc4ee386bdfa609f473d6909f1833289d018d988052f92643710f399cbfe1792b6954fb655996bd7c9f6ea19d936ec6dad4b6507b926b26ed2dfca73931804895add6e12a65c74aecda82ee774ba875be5e62d24f5a67c906beb7eaf2903c3ecc25a04832c00717ea4a5ae7e101647436fcfb23e3f77765644e640c3fdadb476a269dda8f5cb7322c5a75f96568cf480333b4b7fbdc7dde02121894df1ec6098912c3a694d23d761edda5ecba854bdaff407dc6d8b967d3e1cbce3d7670c2d8cdb781e653e343b8df8120aafafd00a26a61b98f85baec39eac28f4788ac0e39fad9cc1a5ba8df6e0fef3e8f70dbcb511bbee6de428d1f2b6cd96d1c39288c4125a0220c5457f8f0a8fbd204384cd01d361b6a7cb871c2232a61c224e878f1e85015c173e2068e14aba3bd8552aada833096a0db9768eb1be37f83aaa11bb682083b1d081dee8e7686ee0edd89488e476032bb2123460dcd8c0c8d81396d5a669a37ac563c28254d89c51831d61833bd4f9b30e639e7d6850959c4706664680ccc69d33008fc40a2800c491998c105a4cb15083119a974dca360e3841b9b1a34503364c4a8a139c26225090a5ad26a11212464c4d0901244444d141555393aba828464455252162e97164a4a4e3049e70ca537287884224c663c37363568a066c888514333234363606e58ad8c00011d61b19204052d69b5881012326268688a92942c624f63604e9b86fdf8142dc0c711047e20558007ea42289b586366d6186a52ca8e060d4229a536a1d4349865d9369526f59245ccaba19991a13130a74dc34c33d6d025284609b1a247c1c60937363568a066c888514373c36a650408e8088b9524286849ab458490901143434a101135515454e5e8e80a12921549494a2e083119f9f52f145e365e27bc6e5e36af1a2f1a2fd46bc64bc62bc6abe645f39a79c9bce82be605f33abdb697f632bde62bbea494d2a7943e6334b9c7d8d160828ec5d88ef1438fb086eacf32c687f26394cf9551e093164c663730a74dcb4c533260ca528cd221364d28fcc7e3ff3b00f7df1675ff6d134b2576dca360e3841b9b1a34503364c4a8a19991a13130a7adcad1d11524242b9292b27069a1a464d2dca4b9c91402697a8dddf421e82ae794262d738f99d330db7bcbe0e61daf87612eb3cfa64f475fe218260a26b3f87abd5eafd7ebf57abd5eaf215f6e58ad8c00011d61b19204052d69b59e2879c164c623be6cbc4e78ddbc6c5e355e345ea8d78c978c578c57cd8be635f39279d157cc0be6757a6d2fed458490901143434a101135515464456935a4a3060dd40c19316a686664680ccc69bb61b53202047484c54a1214b4a4d57a22243444833324209df01f8f8dff7a78d838e1c6a6060dd40c19316a686664680ccc11162b4950d092568b0821212386869420226aa2a8c8cad1d109ac19f9de29927d111ca8093c8c307ea0c4c741f50365fe37e99ae69ca1f406857a08461631c905f3bc1c2a158f2e72c5ba2123460dcd8c0c8d81396d1a669a37ac563c0001c5e0998586c9ec690ccc69d332d3941590c115c3d80d3730a74dc34c3332c0c789a50e8a68fca7aaf15f0e9bff74dcfca7c373635383066a868c18353433323406e6b4699c24286849ab458490901143435388888a6cd85484c92cbe5eafd7ebf57abd5eafd7ebf5ca5eaf9764254a4b344c66386b9a7386d21a2854f7bf82e7e550a97a78787e7c8a16e0e308023f902820435206667001d90076b4c264e6c557cd8be635f39279d157cc0be6757a6d2fed95bd4caff992af1a86ac260ab89545ecf41f0ae6bf1a31ffddd0ff6cc8fcf733ff7534ffe1d4fca7428cff3c19ffad30e3bf1ba8ff06a0925c503364c4a8a199e17a78787e7c8a16e0e308023f90282043520666d8b86f034a34045912c1901b562b360204c44798c54a386806674f3099c535cd3943690d14aafbbfa11487344cce68ffd56cffc940c5d7f6d25e3550a8ee7f054f7239542f13cbe70c9a583e67d004a18931c69e1707d65d319618f6d8f27c3c11091aefc8fe9bf03f53fc6f9bffc198fea3d80e5ed39c3394d640a13ac6c138fa2197c734886910c3b48c7971ccdff9b0e7cc76fe3a176fc02e4a68b3757625774787f0e50eddddddddddddddddb0218410368410c2861042c6b1ce45dbd581d07b4743b82b3dba943a107a775dbbbbfb61175386685d232f5a35092b758dbc4842d535f2a2c8b99bf93eeddc56ee36fe1a6817f3dcd1ae06a89d1e06a6b379000dcdcccb3c09683a09c8689d4cb73f9048e537c51334c524787200063f21b0deb4d7031802a5375a68ec4e0dab68b375761f528f54833176b32b4177b300f573a5947008ab1c080dad8290c3135aae349150828014456b28b5f2c5529ce24a500a6a50b4260917248104126134667d2eb62fe1c77d47653bf3bda34e3d078d7f5de030ea6eceeee6f4360cd31b1cd00f35e1eac7dd77329e1f3304414914b7ae11e1f620b07824f49b3b284f39ca860a14109e6ef6807e1e8fd6b9d13ab1759689708344bb0685e3a9183e0a158361ae61355840b1179a4e87e93e140c46f331cc3c8d4cf779357b98ee9b35bca7b29fe9b8209a51ad63de61defdb5a3fa09e98a3dccc7701f911af37dea11f31a9f5c680e7b98a732446a0b8995761d04c6015333339853f7cdb9751fd53a1397753b6fd4ee38f6625454b2551886614934d635222af2bf0423300a2459832d7870a4a3f84f5d28e8f71ec70382b40653f4c0d81596cb1a1cedf02fc591cad403742e3249f7a6e7993ac36e4c4079e3c137aaea0bc0fe7e00c87e46f9180facced5d3a90767ee9ccd1b5e53e1110015e47cacc33887cec59845397fce2e4ad3ab4c3894670df40ab7530fd6d89db9adcced796d08bdb339a2692b6b6b304a6c9adaa3c466a6c9530fafcd4159db9db92f46754ed5ad71a76e9d4f067f3042df1cc6d8157e9dc39999b48dfb6454e7beaefa6b9a6fdb729f7fc3f63e186fdea142a8c44cda688296d10c0000044100f3150000300c0a870342a1509646cab03e14800b739e42745a329ac6b21c4761180419ea8001c010430040000666a4d100d0df795064311ead65739644e40f58d6d7d089910dde5a6450c003bd139a4667ee089c9e430be73a8ea1522c421564652a7fe88484262d4c7de3442e4ef095221ccd1477b1c01742d59e3aa3c6e52e799b1cff4561f37e28ac7fa8340ae0d1068d3c4e120163cf1eea548dfe0bf4beb6593d54af47777ca04379f0fec2dd2023f1904834a15428953881b2ac036fbb044643a4427c471ec9e520e7ad5707e81ea4bb5ba0c62270eea9deb49f2f50599a0e9c6d610d24017d80d3a1af5301defb70de48e57814baa059841ad02f0f1d09b6542fb7009c8d5a04bc01bc8bd6674c5c8a265273a75554ffbfb4fd99a50221497fb1c0cf988a351ed7adecce5f0d696c3c5a6d394f4f1b5f0caab64af889fab749fd56ad7bd06a8b72d83b1130f942ea13c1a34ecbf1812577ca9ce88a0df98353b6bf924231a30d45ba4a4154174554da53a0e06540ddd5bbd80bda6c712eacb2d393e50256644ca044672ac681d5721d57a3d2b36f5405d131f362d02d360f7086530543bdd056e6eddf7109841946237ad1030cc04927252ec439263842eedde300f25ce859e460148ee615029f20850064bd01235ede6813610c8e1b4cabc0b2d70d78539d0182fa1f40e5e7ef2d82ae070ca3b048407507d8f2e7f7f9068c31a46d093d8b956fc0840cd5ae720f788626094a750bd69c9ab65e7b8035c270dd85ce8e1f1576e0f025819324b9ac586f30663ee34bd12d18f376b7cdf40cb4ed162c0d75acb7411c4bb89fd10db699bd050b32b46edfb6b6070ce27a5c241fb61d386cf492097ccc059af8a3d4e4151d119235a768d469e6e1d565b567de6a635441691c91e989be5333902c92ec5e6cd308b17a601a8b6fbcec7c83d96cbb208671c05380771a8d0b0c3fb01ce3f1dc746f70d426ba00501d3f5dec5202669d090c68718fd50413988a3736373ec778e79210a88896951cd1e514514a581fab28c82f151e4da366e94782f3f1cc0644c571be3c65830a381fa0364adf7ce615553fbc65f8f26a72f4d6fb6c8802e65f61435ca39db3f85d08bb1f76ba6c8c3e0712a57d29c52e27e3dfb34edbc418de55a8696282919a75d60a099e5817c4d81b227c19f827ac932a455832c5bf4be1bba015ab1742b8b3290a2e9b9c2a7537624ee69173af4e34ab5c49b99b3acdf78586521b7d628addddc1a36859b8f79b8217b781c8f9a4b6b5827b9a1411aa811218fdc68b5c1c0678ca25b5081c0e3152db45eadd4e8cbd613bbdc991b758dd7a5e765a9b0cd76ba891f5c209e04be9196809ff53ff3f22632d9b47cabef33078b50740ed0f2a020bc8e1eeafe34422364d82264cc67994897afd3465dfe7944a7bc6e2a997e58ef464802fcdee263af90836a2f6456aba9cc6bfcb329d99f17daf7ff2a909b494ce5df9bf31ce92bbc7ccb9e732906ad4ee29a87541ee6d76349eccf5c9d7c0814262d4badc4123a4c6456da52462decc5c576d7df7858901dc2d0dc4e88c8712637cea1d1c82ade48f21dfc7ebb2e7e574b54cc80eba0634f80db44d8dbad324502308500c92e8eef143c24328020d45474dc3a0cc2bd01ea2880f1be68222e47278a9c6fc9382b08621dc09b4729b04c0f0e63d240dad460d77ff87d4595350c42eb728852205a312d2d76990c9f1c8589fe4f5b130e2194834cdcb54bb388c7f977d7a138e3d9ff8d5caeeb69268aa4b9fc0d43bef0c71c3dbcd5f1624ca8388d0b2805287b3f16fd9a66136baef238a7c3280add275d7ef67c499c4f69a30e7bc7f668c2bed1f33779ddbd78c0dc26615d33e7df328ae240e8c8fcf4ce12012810aef8ff1cde2e74124317de6ca06c6e5bbb7a182ad3c47c65067bf7135b1ce697ff70979407b833d413c20ef708f8007b0371c9e8db0f939ecfe9e184a5acd59e91c9d118338d091aa496bc48dd9d280ae2e67272dac33c635f0a1ba7dbaec6ca50c351344113856a3a59b731fa4667cc076c0158307c29479f835bb30b24c4523cb12808b0eedc8e31e260a18082814243048c902d9502516e584269c4fc8e50a923dec5ff2998a842f9ebc68a435962aad1b0ea76b7e793a917275110c2741018cb14be13ce6526387427d424f1e13ba53b4add431c9349f50b3c61f3d8145d6be94aa1b38a8e89213b584e434a1d253546f1617772f5e838c071b9127e40ace55ff197b06f35d83245b85ea3de48088a4bd2c4597f3b16fb3a7c36cec6d56d7b1ae3ad5bdee3ad791f54533837cf5a69a32628daf4f4729ef062f0a7dba733b7c8eb1d214936c081c953662ef163e7f0ef3ac14ee73bd0ef6c2049e1b0bacc8f69514a06b623842675d886316682a7fec877e8fdb7e0ed0eac30edfc049b69a97f05533d1fc3b387705fc2492301889e45595ae072f3c8c7eb33e420846a20a5c82b23668940c50cb45c23d467fb1ea415cba14f47f037a70ee9f8735bc0da0003facb729d6a0d0c8ec68413ee73e37905d0bc6de20c572880da62e3251ffb982d41c8f2e90906532fbc2d2a7d25c6747b0511a9653a66f7ac49be061bed33989e6f61b6c90dc4be5bdc3be29e1aeb4c1a9ef16a63e094e6390511fc83e453f3ea7c9c69d8e1b4b8eb7185e9db238b3ebe78810e2eeb7ad202bcff13112d149f469f42474bea1ab1b469fb67a6fa51577e5b8ba236d484af528b1c59fab24742877332ee36c2b08022aba9cc045685f7e274b3ab3c7df070bf839f6f3aa7f978549c77b6daa1de3baf7c5921f4386ef2ff34066265667e2c45376700089aebde43b96749b8e7fcb4a5ac0119fc22ad2d841b284f0f63f353c88fd675a0f69aedfa8c5f655b6caa866868907981936b27d7f19619686d503d90c97178534ae06ac93a59520ba355be79ccd1cedd67e15497a3c997c443ec9658b23f1b5f79164d52132b29a612c6723d1eb5ac9b8fa9f21e760f1d2c142b937cf45b41e068fac75015587e3e36fb249677e54df3fe83c318075450f819cf4f4b843a55914ca0da4ea296f3f1ff1a510220a5d8ec022b45f7c97acc9a07e477da97c98ae1abe554431dd3ce5725b9888549e545ba8ab119cc04468b444d5f11ddfca9cad6e7c4eb6f3b9105d5d57e996b4191d0e3407e46d068b36518a1d6ea0a3b52f7d87251df3a36fb24a03f7c5db8c5c6302b94aa5206179293f052dc9b3eb7aabc04b4cbb80848953ed738a210d7ccda514ba9cc1476f3ee61d96f4ddad8ad5514f76c840e205457dee2ed0a9479217e90e66bcd8c31079dfd0bd32111d8208e3091f20bf4f6f4332f128b596086ad7af5e09de29efb4e7c07e657f098fbcd34112aabe7b9fe07accc09279f643e3b8541f16f5ba4f32019bcd54c1eb531607796c2d789e33ec72c23216461ffa8ceaf9fa3d866307c0a8f6e8ad6c5a0b1de239f2ed0d923623fbbcb1dd3dc3ab19e1a610974a85f73b73ea315834fa5a42b2f7f88eaca71d4ba180ad2ad6c5c77d213cfc5d4a8cb2c3e633c4f38b0f9052ec8ec2fa0ec23087d612a77d41a8ae25706f71d8146c30a9276ff05138c6b008cc40ba9bf70f9cd2bc6ec67090291a34232045387e6d696d03b96703894d074ec635d0c15fc9cb736850c7ff4f6b98685ccc06e4eff2dd1026323aeaebfaae06e2b6633b998790b4bbadca9fd68700d9338de539cc53839f6a9a8b721d880bd8d9fa196dde968eef8e37297c57dbda24f3c4def97686c7350027db4760ee218dbad664b4c05b1735c77cbc73b876000e0dab04e5c7a3b34a60dddbb1a60214d874e29bba9155e5cd1475faec963ad9889d4abcac18a2bda43ad971332e3cd0f961263b155b63b19f6689acc082ec27d2b72a38bb609078dc85bd576045873172549ad4c600bc0e1706b5bf3426dc6ca74812025330451d81d8dc643a16817af9e13385942e3c6c0de4302501a43bb027fe3d18b6e156e19aebfe6b0bf6e3bcfd181cda0ed654b92a432ba0ffee05f613fc4bea680446ad040f6d0a2ca458b65c050769f94b1fd0ff492b6a0b6fb50ef3bd9063238646f96ae75a893ae15709aad73aacc2b8a7b8fe44d356fdf879ec319ef9985ad49e17cec4538b4e00bfb2c3d8495d1480fd1f1752767a18ee8459454fce06c8b02450d6dcf50dac32e951453b0c98e1fe7e2e3de61566cd3079f4bac8fe404acf07237d0406210e2f7f800dc2534ee689f48eab0fe0af6fc8e60a821759fa76383dad01a00b11f260b7cbad6079e05eabd455f88e608c3615ae191cd60727e7de3b08ee483d60689edf9bb43f765e7e0c47ffd1047d13dac247f1268d2c8e17a765d6ff48fc1fed4b3bb443605a5ee55b42d54464497785436a0f74fa4669dea8b3921012c73af3327dc75f82126a68fa36b0e8b059e0de4009fd6a20d715fda45227b9c1d82e37007702c52cf5cd929535a777269869596a7766301d9a734b98e9a8c8701e3e1711199a014feba06b91cba96b9234a97e3fca33b91d122db83a8d142202854ab2a3232761483f03f31df63de5cc63b58cd8b61252b9507ef8bddb540dc9d8b776b8b3174dfb65a9d626ab4219b01b1018d9146f59ce21a0e7e386986366c79d2552b165518b868187328943d20724055a8b1cded27b78c287b9494110f2e8abfc61794176ce0f999953ec14992ccd6cf66c85b5ffd798751f23458e4c177ae9fb3c30bad18d0ec743b40924b4a1f2b6e89250695e6d01935e3c0dc9ce3f2c61b062e739390cf475be0eccdab1655502b070949a5f499d59b9ac08c19cdf28c1850e5d2d072bd0eb64c442f1810fea0762972bdc05e69f2dca7de0a19b63f62c1f8bad0b49ea1be7c963d85f51195ce9f1bd0aa38a80b89c22216d3e88e7012934b65db8af45671f79eff83301efe623453172d0ba0cd103319619761f18fc4e34707d1358c32015e5b58d2e1774988b84db402d051572d3f9497e57ba965e3e3cad30a43a1f25ca25b43901580108d3e6170ce01806ae1a09ebd08a04b3e1169dbab9c1aff4cc3f15fc8e5e0eb16fc9ca8d0cf9fe54a5da107fa6daa580e007636c7146ebfdc2ae45a23059b58d90f203b48680743b458c6fa916e3a368d1720cdf07855e13bd1f53e9b0853754827d16f96e2d2809ab3cf1bef14fc37c0d36679f5a0ffbeae887b99a3959b64faeddd853285608e2fa0c9bd35febed6fec065e0d983cbd8c187924757664a8a1a52b2b8239682a5f8d825fc5d821967a86390d3f67f8587cc2a46a274bc406449f1052635c7680e4e9e36f918cf459759ebe40f5cdb278094c7a3fa635c163f922471f31902eed7d9e3cde038abad625f7da1ff2405cfb3bfe5813747a1607bc223ff872c27663e9c8113ac4b81c569b8adb78072b471bf497600deaece3631666a400f9d1d4993bd3ba4a98d7598443f529d7b2949584e26a8740af14e66aeb2974dfb2908a269e07a87a3b6d1910f956deffaada1417e463f4834feb0eba9bc4e7a58344bafa5de615bab8fbebd6c604a6c28f82923c423f7b18ddbb6c0d221a0839a40a9884d694588150112893a8a72f7c1b4984fcc1f0b666d4868b0b6f46490710d47defe952a20bbe4d46929a59086fd39989c6ff4e01f33775112dd31f0a1c6b9dcdd8b1e40c4aa7e3578ba4d29742bc796cc7fff3dbea996345ff02b705e253a16c7400479fa29d257c9024a38eeff5a36f386354167a59e86e7d04bd74238bc3fc1c020d8ef2eed09bf0c5ab03ebc5dac26c2670a53b3545997577faa1e952be4843c1d474001a87bb15bb92d4b919809bdcaaf77a2427b0113d4248e67253782de84f09487167295a3aa038e9091ea44ebc09b7b2e963b73bfb07312b55255e0777fb601fbf2ad561399947d7b55b36cadfe8c39eb7f07a606a4c348d4dfb7a7fa07c989f72739c42e096be1e0d3c35525f4799d89fd26273a32b7e1f2a7e01a83b7e4029e125218276b6e5568d97e7d5f78c449bfad2b66c991452890e2ec07bd555f5c99dd50e59212de51211af6cb6827cc6f9b17381056e433a18e4f3c132a4c6fa4708fcf3078143f80a1559a6d8b9d10a0689f4fc61425db27380b00e6cca6a2b6047de0ad42af6b6b7dd3adff083c0360a6214cd9e984c8f0a48f8bab19ea50a2b93d04bd972a3a04c05abcaa20e346732c91b58a5944c1505ca36ebcfae15ad9c5c0ec3f3cb6acc271be14d2927f4afa1282d5fc7673887d6c08a279152ec4292fa2a7e6a99bf32885ef541c4fb45c9d15b181c8511ed5c9d4e44d8b656374146cad1bd6c602b892a816efe15f4234266ea2f44d45a8abd90b06e54939d05055bec508c5b76017b815c893115f164dc0b9432d6417efbd137f214c8b4370813d997f26f2f0e8c44ab8ea402d6defb8d32c1879aad03afdc204fa3b03a8ad00baa06f5196b4e0cf582ba8e2c110856ff46edd4e524583796744266489d9423e3782aa9b25c515402456613775356028df4b348b77d9fab9612c22285022b40352346627a1388015821ea8a747d8ded86809e215402a9017250fd61b106f216d465a4c6e822f930ae7f723dd1c57a98dd91bd0bc3a94b7d01560477c0846323eba415220177449bde08ed83a2c3504e52958936ca2639b5d8e6a71ca5669686015f1c645e520dafad39addb64f3cdbc510127c4e495b55201d0afc324cdd87093bd90b6f83d0e0404a25d82dc0ec66a1bf7b601f80f65bb70edbd5edfeba657cb077f4969d7c5e323f5719a7bfb8662ac24996a8f4ff1a8762f057fc9211fd0cae983efc840ec734e605f5e6509629b18e64620206d58253bb22bb03f480e42ab31a796e0f5c1ef57625322cfd184843e6bcc2a34c1f58df7222a7c3790433b7b6cbfd47646155e420cdf42dfc1a27c366d1293ad92df4a7d01a81cfbfbcc98a3de66d935c8afe64335bf1480a8af8d443af41b0bfe830b940a718fa880fc74a83a85b7952e907385eef739858601124a21e0f9a4c898b21e04eeaab7c59315e9f40da080a04b94bd2403714ee0caf44d35319f9ca87e1a6bbb5f7810a100f957f95485e85713654d9fed3233fca2ae425c10475ce586bfbd55db18562ce13e57a293b11411363781cb950e8e70e38012d6c02e4f06251476c14a2a30e21f8d950860e20028f8bab834f1efae6c6e81c0ec8f4c834273398f06eac1a065717b58410a03c109633270851a1f7636684415fa4cc530efff811b7e2571760fb11ce09e797d0e599012013e376f2e04c6c68d47cf077ad701153f3ea2fa478348e50fcb2e05a1218e862bdf9616d603a8fdfd2adff361b9fef6f8b19edfcf2c1dfee1fc8e86ee47573d83ac16d7c871877bce5751bf1fb09948bf858d43d70f96347b052bf2054008810e84037daf658b41a34c7fc8678abb1b11eb37b2de8f8389e05bcf1fdc816cc736219bae92a531fdcd671b2ea485b6e56463d81ffceeaf34ba5062eb537249b136b9564b2a83373bc8e934bfed3d8c66ad83f0e5d851d6cb23c18832a22f4ef93e2641ddf13c8791f06cb2eb2017ae72138f89fe1c85f2e57f2438348e6999c0ddd0cdf5438622640b6ee30796a4b4d4fb517e425b1aa9de428eb56285414240aa00a418661b5724124e29d1f08af8f6dbc8e834f574e6c085950342ca7209794a794e14fd583f4c807860e87029112a7c58db8915d116499f0af0a1cde3867eba69ca6fec51a16c8bdc9e750c35181d4f7b54624dc6692a9e083ad55f69109ba79b2e5a7c8706b0eef5df4ed13f955833c4d9949e2e0d44894694540fff8cf50e253a26f4c094f4a176a162a8ba2be16d894b1c4dcc572d01e04e8d3fa6c19e007a0886600ed5e5228041dea74138ce05528cba891a70b935ba81b208001a75e29d2736b124a85a6ab50e440b147dcaec352575167876bb07fba9e06f3390bf2e46039aea0188f8653456b810805cd2dfea5fb7bc626194c123e97da879e63bb3be3b830c86661dbc29d29651e32fd9ef156c95128652ab3a47c6b5fad20fe61d18d1220bdbf6ee0dedbcfb5f549e765ee92eaa151908ef72b29baed959920547f96ecf38fded3dcb668c9c703d66f37efaabc092fdb4594b46b673589c67e4df6a2dde5c9525290f9272ccc963edc4cc47133888733c4bcfae643754f248e984f476e63653a7623808c32001a191fc4ede45b04afa77da9e2524d9b7e62f44bdcf8820c421022116874f40f2338146e3137be335016a8271ba53dcbae0485fa7a147dc45253e19c2995fb68b0385cfa8ee0e7b51b0075bd75d651fe7d3ddcd948edd303d9dd149c607b32d0a90174e7fc22f4828b0403040a1d602dc520ec239a1f6ddf523322c9fcbc2ea02585f92dab2683442d7fc519df92e6f0b0a4925c5224814128538ab53962f56acfb068e00628c54edf44a2c23014629036ac7211e07919f61ca1ec7bdd6d8cdc431e8a17b15f65268d5c5b46b84bc09706b708f62613b480bef02adc1b69a6d5bf041afedfb1015a439e3fd36516eae779024b7e607e1162b1ff69c5cfbcc25210fbe20257827019ebd97ca25b9d8c639c913c715a18636bffd41acac736f050da63012a53f6c1bc918b21b064008b7c952b505e20fdf3e6ee9b3487d92442d100326ea15da1162c12039e7aeb3698754ee526c182ac4b327596514a2dd126671513eb609fe787f0c98e03b048881f613a66cb636ef4b84e0d4066f1608439be18e23e60e42ddc1d423ef57f7094587c682ef243319eb1523482389fcaf2eda2e0e9a635ab67b0b161d8c4612ae2a8f7a465881762b3bdb04203e209d4c3a5a1d307d42af73016e1c4a47140d305e5d3d32df9b6780e7f32a5b7b7532ed50614b8316ca9187ff652744db4e18faf3658f9dac1000d88cf283a3fd0e5d6ca229599e6aaf4f8ead73048d5c0803e47a5516e8e80defba2929ced244a30f268398d2e6aca80367861d605b2b6f7881fbc4bb86d0b6c03bb4704782251d3935d398863df66aaf9531ab00649afa44bc478bde633e739abc7aaecee9387af290898538521e1e1160f9429f50769daf79506e85f3d8187c20d89555cbb5c398c502e376a80b5a5d8f853ae59648e99eeba0672e121da01c3f72783de68543eb9f24feb5d9dced675119f758ef2efe309099d5c33536eea5fa0c5960b9ac90694b498f4eea9ce02ea426d14a9b1bcb9bcfe8f743c69175a6d5f83aefd3b8a60d932c24bd6bb1945dc905949138db8b41f2da228efe3e7ddc80a689e77d80398d4b50f1a414ab513a3f9abc133a91623d6d20b8ebfd2d65d872291099a3fb4c807b087aa0c1902bee1e3501cf16b2ca68898a045e3c70974da81b4a0771e81bd8e54cba3ab409e92923b0a21a569701e95f800d2f061c752c3abb3d8debf906bcad8b952344817d84a486d4828201d84bacde7a8aa2948dd5488446ed65d34c3747b3631ad3e9f16735ffc227092f697a856f366b8014bc69557d6a7062139dfcbafc5c7b1c36662ce66ff97d3778d183693ecab98cfbe941602d6e3c60bf6a9388147a45896e29d4925fc7e12c72d32a25b5b256206640e8fbd7224202e584188f52ac593e13fdc7d4a5e81337af345796bbd65894e0b5e86c19d9c8bba0663dc6bf4a4663b167bc14592577c803916b0d4e2467c1a2d12ac1463744b18af81d28cbe8f822dd51c1201c4275d6b79e3acd08b00f475003057088abf5fdaa30571ff0e62e419c8d086994cb5163abb796e86943142a8e622a6efa5ecfab5041db15e26d1ffa69136f7ae3bb9eed26407385b72a02e81f3a2daaa6e094e5208c38a84624c64f80fc81d7d9caad4b0aca4953b0eee10529b4a4272f97ef05b49630273dde627f6121e39afce8e575917826fcc131cf113fbeba77f2a265f3eb38611c8a5418bfdbd916cfaa06f4b95fcc0ca5d1c6e5bc48cc1e5d221e3664f098c008ab98cbc929299bc6dfb89ad30580cb2d69830d9a885934218be71570c08f8aac52d4e32de961368063aa7f72a913d98ffa0e09c9d377ac42652ecfd29241ee6369a7b3f4b167f4d7799ac227378aac77aa1c431796c6cc27a422919556157f6f7e7aa17aef1d26239afbaa735b7f0d4941546e6e0bc27bbd4b848c2b55e3f7b7bd639fbc31ffce601225043bc09205b307f020fbf96e734a7f9fb4919dc3c30f82b8b63a35c88b6e007f6f82ba89c30d72238288599711e000fdfd84d8d05ccce8b02f63a5ef4af63764936f48a9b443fc621cb15e439b6043e98eb58d7d2ba85d0ca354025c35524c05393588c75d4ca621ed4f66197e893b5c4e5b04b9496ea94334d32c446d995da7c8d59335a42c5a0d4ae1cda57b3c3b5b6d2c68cc873e056726b059a22e7435eac8a5889bdd2d456c6bedfe386bf519ac9dcac4740f7724eadde37cf22de3a243b3ed97a4fb834107019bc8b97092036d60095ef0eea350d29cf0be4f1e6dde1691453de32a5469d2e675f91846284cd5ea828a85746cd7346f2f8426a1c19df7cb0815d9e9d35290772034f21c756f88d5006de821cae6851125a5da3dbb48b8725fd3a31a25c3195c2e8ba295521c62e856e66d7b68c3d232e2dfd4170939f514605c2a22f3766d52b5005b92c11cc0bf8acce29789eb33ac008f303651b3ff7c645650391f46d4cb1a87a743c524c5842490101eca0a0b56eb74421541bd9f0ac39683603c50c99efc3704c9bea057ecc451baa944b0822355e3f59108a67da51103337deff97dca62378c1d07f17393775e3800100e73e5ff1c24bfcada77d9fe10226546939a9d4b58d995fe679981f0533832bb11a9dd3eb602c7f65e3d35cb15bed3a6e1d8b11e1aa40177b45ed3199edd77e0a2efd584996c46a8913c6fc8589617fdef789253f9279e76c161cbe4d3a8f439c28cd963cb8163fab40b9a0cd8de13abf7c826040a5241fa1a8fd1324eb40906f1f40f9188944362e983d39ab89b87d622df8b32b19c1dbc4d97c4fb9b4cc287ff50de6ec9487bfc6767b2f1b781c853c9f139e1dcebe1c1d7927514b68eaf2b0abeae8c442c775a20598b91456910c819132d19b30fdce330aae2ef32a90db888ef5e09fd5d747c5e54dbf130af6c29677c120ea94e61812530b76b1e60c6dfa31a3a4230c36a90fbfc8846bf932620e3e28c4e863b7992012014668cca1e7346d593a8ac436de93830077cf915f948917d0c21ec2511d831b32ecb99c77fa3c8bbf8542b01ca252d179aed4c24109a2bba3fce9bce75b80f13a3ddf96af9094e3157edf29411e677afe1127188f442ae59a6a5d2ed26c9cd0ba8d9ae3560790e40cbc829b4950585e97bdad5b3908e9a4e108f6a3274fc7915677b74a16091904c21b546bb01beb7c3fee40c8b41ffd07bca9a1187d1eb35cd2cce60b1cef23d58618b255a12ac6a5f0badb9af5abf40bf5d0f201b91b4b9cafe4b0d66c60f7146a6ee25ef7f750a81d6f935027d00ef70e9f48b75d800b0d305db87b8d9e39a1d152fbd1abe6e6dfe0340c70fd2887af99a04a36f173d5ee7210aaca7db26727a5e5e261dceacd56ffcf3fc2038d07ef4a93c12699dae49de9079616e9b38dadbe6bd1c3bedc967f150ef4f02783de16eb8b74121287049024fef877ebd8de1682faacb7962a8fecacd5370bacee8c2302191b0fdef9a79d4a18cbe5ca5ef3bad66fe55fefd8d9dc35e08e8bb11ddbcb9bfbe9b122a6b76b8dc66d99a064f26faf3096a4de5465ae8dacfdbb4840f9334475b8357d42140802c104bbbfa2fffe827859ed650ccbcf5c7dee37b288b34158a355889067261faf5af94d6d2e2cec9caca7edc1662e68a74fb41d9d5ce39fc9fb38539b89e1ad71a7fe2d658385463eff43d63f106f2171c92c559885af31c0ab7ae85a8e031208e899844278eea1d3da9aa5e4a94e8d9b73549ead2085088f13bdd567e1e2e23923072ab76220881d015e3fb390687449bc8ad829ab6286823d18bb8440dbec107c72d15f281e316e4c0548aad0fd8e9d7e7706a427ae31db9c2732d4cfdd671cb99d5c7ad6555f9f583a60930ec2da44dc5423637f9a3b655c284b8269e9a0fd9e446096468056e7a6d598190398341421726f366ee0261c6d0ad1203198378f1881d9ffe0061319105af7f2f9fe91357cb5033999c0c0f32496a4cf22878368556c146eb1ba76433e3921bfb36dc09e1fa738ef170a634a64ad9c2c93d485a7dd7d38a0895d936e29284af993f425c224c3c22c4916790c311bd120eb970b43307cb9273c98501ead19ca024ddca20ed8a78b797d4b164b3223f8a33790f94f1daaedfcdf523808207e8383cdfc5fa2913507d176d1630a08b2f8a090081c41ad355ea28606ca789cc2aacbe421e13bfffc564ea6e245acb8f7514f6f94da50b60fa95a3d256697aec17c633e1ab278fb4c4ba3acda78ffdd628cc1277f9432d2c681419a8973500ab4ded261d4b42b3edb16f4198e89302822bf11727fe79a5143b43d40dfcb1ef38a6ad491a788c4bda413bde92ef99e44604db7fde66a0ef8a3c4c3a30498e5ec09b2a65abbd1c10e906853cf88a05119aa502b8f8fd03e9647c81e1887ef754ae16fbaf6e387db28643b8b66a4e9e7faf31d087f5e1350257bc5c802a07998bf666a33fc3f60b28d9835dcebf8c5809e622378670814c30b9dd457159fb26b53e1c95e168660809b882ddc1c3d4549288db429866d34c76220154ddd4ab9e5596c13f60e13cf96bf5f831737c841c40aafa8e905cd01d7ab146bfd12aad52c7a685d8515377ebc87b2a9b1c3e6a93e0ac6a54d68a86260ddf635adaf7b09598a7d21c060a04e0c9273540f449264330a1d8d3f2a33cd214b7d4b76489a8eb05246f31457281204fd66872eb4057ed6284e4ad0f8095c26b3f54a17ebbbc427c68b12586e5104ff44053f4ac1f17aa6a8a59a4567d7e30b5394b69ac5dda4b22ba27d1c0251d2e60f627cf05e2c984cf15f84e0a9842896dc232d1347dd9a1fb0cbf58c2c039258059c52731179d1fcb8913b1c1a158858a408172d333c2f894e7877824f0b1507daa2733aaba1cfcbeaf786dfac0cf36624f6146a8173df41f0daaceb7d50e5dc2472c079d5adc8361313e20d8f575c031ede05dddbb7865d982f272dce26837d7fb61c6990e77379061ae6ce5b9fc9f3355bd4ff9a7db73f940fdfe0eb48a1152e89c4928723e9edc14bce90b22779c1b72f36bf24856720cb33f6a809bc9d2ad421fed5227bce558898c88f3f23114a453e7af0b0a760f9483396b571a37a4f255037ea0b2986f9a1f398bc80869d5d7d1de832cc72a10645984cd021c490e97306ef075a842a3791b2ca4816f3d23733ca16e917342c1203d8c846b1ab1be32eafe49924c8e1b81489d892215e90c59026138d530d1577b2f8010057e218bf92446dd05de7d6b9678420e0ffe060cb9412de06edc13e639d5a655b08ac6e3523aadd118ee1b108b5902e9f0cd94f59f9b21b25abadd84112b91a60ef254c0f394da418e64431e6eded88c865a976ae8b6332b92e02c324ce0238aeeeb94f1776b98401f04da5fb7e167fe892753678f7bffbfc1829c2ad70529723034e1bd36b9ca33716114aa3b90bd8c13b4fcdb9fc8a0235715a1463a91d7ef8814842283b1258808f4ad671c0e7611d7ff28f98300b79b63e266b7d0443ff9c99f7ca59936cfb22543b319f4ae0f8612416d7ee803b04c63c275d721f6fad0b60dc7a053fb11c72e33a78424addca64160ec17c71c5f0094cd63d2df90d565873ce629ff1f0bec2412a5253932cb1f931b36f566f757061fee36a8b4c4548793ff9e71cf318743f4a1c9488be3994f7b7e86c6e1281db3e77804bf2c7622474d9d9c4ca648988fed0e6d84bca4aac8479dcd701568470bd61f0c0b2888a1f23a35b559c0b816acfd6c1e53b892f17b9ecdb8650498a2eb11c812c800ff12a02b563beb2ef9efdcaaab337fa9572e92eba5aea0bad4877fce4843427637b7fd88535a30829795afff493e9998b5aaae17cbb6cb83b561a84061beb8619da0ca7a2e5142f10096d9890c65502ac423a1b164c23afa34de779d0ff0ef6d883f44c9628dab15b6d5dd7ce05118633e841f563d65ebd0b2614094a2e1b0de1f9c3f230f167c8dd67e2a20fe7f90ddff7b06f55b7462db05987eac44bfe9432bff0133585b7494c9a4c93b76edaff2e6d22a0e93e1e9e1985c9f8dda50822ae7747a8ab46ba238f438985335129a133fba59fcb64e969414be2ed36efd293956e3c89c5ebf846283b6a2d78cd2a5e3858e18c51cfa4255a0121b4af12ec4a3295fe949668d6907f7b5f0b9f9640b239d6d6367073680ab93f2cb1851ed0aacb307fe3145bdf49df5fbd414e3c225d645aa86c26f5896f1d7aaf13cc0a00cc2dedd5d3453bbba6830d804ad401b8fab7f6510dba3a21d65d5468e1107a7ddd63c06645ce6c7f89e82fb95439384811ad02a1ef00f16bca32421490c87f6d3d140d1ba6234ff9a3b74e66e774aec2807fe18700587a5090a6aa5f0f00e868f459d93831af24186695eb3c33d68cf6df43d2d3d1bd6f6420f1d7ef572d8e5d1d60d9f5071ffaab15d02417b4d6c94ace7a8246fb6bb4c2d45f04ec2f44400dac6fdc84798834340191dc18b137a836fd394798eed4ebfc39be3850e33893de7f928deb834d8cfa9342e2eb1250506f0d555007098d0a21cc8e4e3a636eff171ce4160a842f925ff50c3b1d257d699723b3b0d47225b092139d06c9043b87c0bd370d17064c7fa9b35ecfa6c0acd3aa3ad8170850d3c9a5d2bcf14221d77378e28dce1070af311c3c5a72247d9a43eeae38c0fbede23f500cb8a372df5b2c6a1437725dbb82f94dacfe713b8854c1607ef473d8b437bcc5866cb10a8bf9f7d056e6501d2e89ee8b52546ac2c1153f00b7a765eb435eba65bac805fe592142aeafeb5019d6d0f15a6730ce85837e2a08478c2dbef608b0c7912667f3576817d187ac4a22836bca24addffac70c15cce5604b0d7749d856cf75f7875c50b747ede9a43d3878708283283bf908efb14d4544ac28e96a7ef042a54ed91599496c40bf9fbfeea1a49c7760449c5d4f7008d7224d4b3829aac6b55a3f2295966d31821e20de126a7bc34a17d65f1db753ad4868a847c95a79b6d1b037ca9403f12639c5d94eac2e8087b0d302f914fb068290f77be34a0ead151b5e673273b54c0a986c85101d3616387644d3d535905e9baa83618092c54841479a06043804e081821364af4a5bd7151e77606ae4756e415a6debc80fc31e0f40665cb4521ad0eb25f09c307687630652570d83defe779d94d8bda202dd68b64b7f64c39edea7b911f58b975bfbc2de1c1ccd55bbd5c5d98b3e3a6a44899d4733dd5e73f5091ae98d83cce87a252d710a63b68b6b4d738e78b24b4413463850def2ac43fa0a87b9fae3d84a53df24655d86dd6a367f92eec4f52a2dfe029bf0d39fdf1562f38419a95fa3f1a9cb44d35b944c02b499304de70db1430a535522898b77eb812a54d0a8bdc3eb5c07f12e5c215def461a268a01fc77e2f3d43ae5daaf1092ad043548adba9db475f903985cf2075e1dfe217d44105466f6f107349c0290aa4f7e2f5d3a1dc1c8fde1ca8c79332014b6cc839bc05faa9e5405948cb91955c07e00dadeda8f0dea0a8e6cc6a6d93d20b769821f5aa4db2c0998f274583e6e5a648eee828a996341e1497c63118aab06c06c7195b80aacb62d6be6e8a10fc50ca56b9b94ab03a3c338e3a16be7aaa6b3d385bbea89c81b5b907a0c8c2fed07770ad3b1c8390f4c1215313e6981235160fda3bf0f46421b834856c83c6c42a575cbcd255cf4e9419f56565647bc1406f4aeceaa601732585496c4d0fa05b221b55179c211b90934b756c7c00afe15894635538d2267924c6c244a01bb536e08dcd1b35887db3d746dd7bc14923b54a3497da8637dda356beccdc18696cf58e69ab762792d874aa1e44c5a8dd577974d1c667f1e8a0aa72814bca3f937786b74a13198b9355606f8b11fb174a8b8b2d9c81bbafe90bebec204a3a93050328eaa3285f2f056199597bcc353e14b308bb5c3e22d91edd401124e03727bad236899b8fc26d0b51dcacc2b0da9414aa7683c3af2393cb106ca6223d4bcb37b77706a31bff303252e2c015dd0cd91a28fe85a9c28391e988ce70827c1db78ced988d71963e3e6de4b0588101375f33b79cb8d57c09a1c3637663da52523aab19532c031b883922e4ef836f34b515b3dee861f7907fa04c0cd4e083d68225d86851cb9f671c81672804714a9020acd0ca0be4f9c33eafd9286b844fab9c2a8580b5f79c7ed7992bb34c19eb5ee1aa38ebd620c999b91ffec0902d5fa933c47667c0628272ff3e9d58e623049ae0c3caa0f7223a48bd647a58ce1e95a62ba21b7505121cbd13411982ddf338793177c821ef7e2454dd2180c7e968f24cf53efbf7e962f769ded72c00c7312ea2dbd47ca95ca1eff0aeec8a8f331bd7405b44840cb0ba3b0cfded40a208730fe62e537c99561714de7d4f3c81e0824d7a045db8da8f9c88e1114a9a0c97e1fccb7f0126a95d942350ac132157eed442117c22cd69487a004c08d03eff97569e18adf23d2b54dbc924433b6efe4e20f42311ccdd66943bd5e31db7d4b1052446626486800a178347c5475274751719c7ff66073d2120652cdc9f1affc2a350583ede431cc85ec00dc441a6b529592a8aeea99047d257a05744f281982f8178c9a1364e21c9dd63fdae573e2b47f87b138a4b3597377a507e898492dfa61bb255c40fafc8bd9349896abe0a08b191cf1adb21432660a663656c53bae3b8f7db657878b2bb2d93e62ea399aeb6f5757e775b8e7fb3696da882d24d6f9465f1566edc0d2d6c08d2cd1a5dc56f30f9c47f78fedbd58d09ddac40b279026d513b7f9c1ab721dd1f8a6835218b0c62d8e03c6af48d530d6ba7c74ed3f11b51ac0b9a8f319ced2cd2846b6ed308a1551551dd598fd2f406e8731af3a8da3dc6fbbed744e4b22b3d73d5331bbb7245082ac9df6d72fd59db877d9b8bd442d0f671ef0eb2b872439c1eeb6b92368c52b662536b1e85645705511119f00949d5f2890652d1a71d5457674eb761b9d02657498f9b9f7bd8a2cf1cd6b1d5b45d64c00c7f2be2e546ab6e74d491898addc3e762c4476cddd4e5711f5a4ab6153e333204faa185c56c2a81628ddbf4004ccf4ce649c120d20fa33219d0196dcc0c7bafe2e34eaf327171a72a52c93528559ccc5961e1d502b158a7a701114c47f35cfedff455c23a67f5de66887b46bcda187dcb46f00c16e2225e88fc9fcbe5667a0676bbd527d371bd08eb4abec65801c226e021da0e0526dd1882755901482e8070572a43366ac23da5a14bc96330afb604b5367f64ac9fea96321efb0ddad7c329b3feee015b6a668e4473aa520c94ec95d4e367b50fbcdfcfd81e173052526cb65a34aa748476112c0c25dd60eb7a532d90f541bb948dc26018f4443bc714c6e67c0a18dacd5c6141b2ba8cca6bc820658d6de9523a8a42066fb0b3b56eed8f9ddf2d3735f87fc49ed82542fc2f8c4b1b71b1ae93c62ea07f1cc052c9dfbfa52f2f180943ca05feb7d5dfb04f57d4de9136542f9facb60af908e6c4a047496bf382a1658ec47d3a27be7027ec8555222f9f16dff7029983ba3bf0e99a913ee6f98ae03bf295f86469f935e0c0e89658d116a697009a0ab5a99a7434d55c25a770d4b57a741a55dcd7ae33ee33e819bad15413789fa3f1a6f116bd45c9cfcd8f0de0fe6c71814939633b8cc3bbab36ba416e0fc45a5ede806620506a6e5e222f0eae213c7e3a3a359fa4354a6d9e04dab5ced04bd140a0ed447f9ca458a9899933495f0337ae057093e52ad9aab05c6e4e161a540cc70e4f24bc7140ba401b836897e8651eccabf4fc3a1c0c829668dbbfc3448dd5cb20575753e7b1fb97a098386a10c9fc551021eb23eb681dca3c440b98b9bdc80723afdf5f22bbe5989755e2129648133ac04c1975118af613dfe9883d2982cfae922a19b44a875ca75ed3f5b92f704a2a0c8ac787e9f090f1b0c6f66223985544b68a5696f2afffd15601443e29d2afc6d9ffdb4f32b67e4e8720fb29102cdf4383e58ccbbafb106264e5a2fe47ff0f0e573c2e98b849a9f1b3129686a071e9b57540cbad68dd72e553dca204ee40ed99e0367ca45e42ca058f9c14da69349c183d8fc49d8236a0e81c9daed7082366627e9c95f72f67acacb320ed35c915d1abb8e49340e41bd3c04cc591a115e1664a9b6d8397097d9a6622a7c60e7869194589be5c0c7d6f0854dcb9f535625af328875c6266c3c0ff3df818ade7283bc1aaedee4b29e90666ccfe4e2b0d451f0972105ad695abde4cb846bd99573060701d477496c20f5c8a611cda86e46e6194b8b2974cad6b5fed3af15df6447fedb1922d54f71e325e7f27a8303fa42f60c14c6caab36ec22053599b1091540235472e37e774eaf461a4a64c54b9a482629495326b53b08c825e0d19a725f14d12fa7e2efac47bb2cbdc598af68f24e7f338c5d55950b2d47e09b6037e30247083a29038785da56134b57863725531cd427c13af0298dce83e68f17d13a85c2e28fe7d34a05250583b1a4732ca0090be652819091c161205f7edba145eb9f65351a85ebbce227e9aced84dc34de4cab1af36f52a01f287f1b8d58f35a17306270a19c057809e24ff4b78082df40a77de032f987d7827299f616be6249f4e5a3e190cc6aeb85ef605e27b80001a4ec66357ef621ad06649953c201770cdf8ab794ba2d74500a65aad04b9c8d793237185e79aca34c5b8d3399be558c70e4e907e9e70d798d62cb1888b1b0d6aeea4ab6c90c9a2b045221ec0a1df232b6bec70ebd5accf45927311c96e3a463d03039a27c137caff88b36ad06388da213ec1fc0c75c6c646faa14da7fc748dc01be9e6b62236053d79a50181fffe0700fd7d78815c3b99445ae88140febede19210e7dbb3db72b4c55b63cfd78aaefd598595faa58f9e72d00bd9b102bedc15fd31f33fd3a840c19987a91b1142b1f26df9635230eacc243f27b4fce3b1ef62cbcee2b30f3ac216218376d40db08bc35ad5f4a6f5ac0008a9032ed17e78798de71ba21709c63fddc113f14f320799c29e7ba89871e9225ac953bc3457e45470ede7b9fcd70714abc8dc19a4802bd06ab1acd59d69816778d55e7c9f10ed257d28e9c6e9ae0e3d53485a20ef6c2a46d6355a64ccadb040450dfa5f12c3f535c296e08e1183a685b57ada0ff8960a6a0d895e09c511fc79aacbcd03026b47eeb3ab4eb57beac82492303e129c3e168028c112518bb7ebb9fa4269617cb2ab61484914993a79a3f117434dc928047f2f549bc7fd0a3c4e593c7a554d046a94e549cf505fadc3537301f3be458add522bdcf5fdbc9942dcb34c158cb713e2df0ef0db5c7ef5500bff6bb2822c71a88b2c094d1ffc7e130a53552b4b3fab54e8372be661614df20cb7396a788eb565e30979e3c2b318a51257323b0f99ae03d179247f888ab731227111791f95134c2efd1dd44ab7857440fab93bbe07e6ca3e9b0d5468aa1c478ebc60606f5716b6a1bb53c366fe23fcdd205369178acd5dd230abbb0734270ed92436b5e73d0bfab9e956be48f2c31ad986acd2dbc06dea2763ce85e55ca73fb13e3d12fb5e8267cb7450057e4f4a0d1a7e3436ab139ec637c0cfd8d5bf14cc6e43cc61665973524a86121c07ae6611e43a5adbebe35549b42a4488fa0914243d47d13368da811e38483b67ebe5a4ea2f09a23b70dad0dd3693ba771899dce8da192f9b9536b801d3e0391968da8416b762aac180e30add2c730c85e400c27b419a2af339e481522297e3283566d296aa7691c15a87bd8c3a831ef477e13e9ac3d44e62731757b1838ae3b88ea3a5db9eb9c7b38bf16aa75cbe2ae9faede2366a17f9a208b3da4af81b2af3a7ca7b6a8c874d5f0d59e20a26143e911d4ba99925a47c5cf23c72d788bcb756a75653bd55cb0c13cb93e930b2e4ab236318e85d441b52af6793996abeac4e692961f7d335baf155068a2e99625def90b8434b80357e484381a791ed7ebf981d7dd5c202a15bd2536845660dff3a9a1ca6e9b7a2f904d1920cd7954918812ba863411a026440fbae3dcb3459d8a2c44695d23eb3abb56e2dc1935632787b33989b9876c6c3b03e50021740d3ba464d536e85a486004812ad1544ed10c4751ae13344102c44e50695a569ffe6d4083d5b26c2f46d7c5840c27856f45938bb13bd91e193c4f61c1f5ec2ce8e3a322a3b535a992633c3c82b62e5a3b81eee21d620fab80af635b1f85da35d204b07e5b6455d3db7e352f9f2968edce3a0c34fb0ac425da027b98d509d0862ad351763d7c4c9a4432b2cf741e2385bb26e7acb333b093aed231bc695330b188f140dcb89d752b9f9cf11716a076bf19690e8196f0ac4483e775625500edbb88e78a3befb70cbac0634ae3b998aa0b34db39f0c088f2196550552015a405c20cb171bccd981445b21176c24ebbbc32b2931c15a0f84fdeb8a9650f6af563f60b374da42601a6f7c9e1ac6ecb854712ccd5a9e811cdbe2229d8d517ff7e809e758bf7c03a88884bd33f7f1cff3c4e317d612e57c42af0da0deca619ec7a16f49131aaa68d42c4119565da3af3aab8804cf3e81b9c4cd389bf1c95c229a049b696d2f20b348b68d1c41441158a1a866446164e9fb4367dd861f287bd543eb164f57b1e80985bfbb0a75be18ada1ab4079301502bc7fbc086d2691082f4fd94c90c9429c99a703d724ea4287b70d58759a75ea71106b0e9745fbac0ac1d4b8d6b6c06b885413e3165f0fbea378507ff3c470a9acf63d241777f486386cbc66755d170e8a5a80fdc88d26b018aa35739993e7e8992ccb2ccd4edcba28e6cfb6241efe1689dd2f1aae17a4c1f765e5136a2288db67da39672195e702596a0b70b47299741f4e83390e3f342c046f2545766807f7b5d7ec0d867ba5e086ca36067a3e9c48ae593e101c9b517df65a4d2aaa16d3c996a1fcbe7fceb97a1f5bba29715407900f03f4e072335c34be830a347f75b74431496e01bea0f6767c3e7094be5669b514526fe0e55e808ed29f649542d2b641308cbd9b5f899d3fa8557891cc925bce017ebb6ad0c2fea702cc88dbcee394038c6f0b340db763e5fe15587df7d396da30abb4e3261a3fd41a36b17646fedc3ab94e585e989dab3ab2ccf4601e272bd1340e99ea9ed62eeedc719733b3077aecc88a1a77635003e81c1192d817f52afe089fd96df5f61f2c0f4bcd6490acbb9ee362247b8553860b5192d32b9592343c52f51897b45e3184c2986c2281572bc18a50463a2047c234fe0e7182c4f80600dd2c282209d207027be10db7e706e71f17e9c2ea51fec610fe718a5bca17387fed873dd0ecd822921d280487ffce790df1cf8e538c3d2864ca7532db8208f4bddd4a0fa9fd8b38b87c921d762cbb10b490af8262ecc0eb162b9d4218721a71c19618ec7e0392b9cc9ee104ed99474ae02a21b9af976b7b126696d075bc0c253106ad98fb7112844a6f5c91d2dc74cbb81d0225b2ca6baccdb8a21d08b3c500449aff7cf3bc704827acf1ed25ab076a0756d4f435b96c7b3f78793c311739242dff63a0ea974782d6135d49222f2d66f3a801a9f87eddbbef3d4f8bb9d14697587ef19a190562f768ee29b79563f4a7c3b9f906cf54cd1badba02d2ed7fbd5748988759103732fb186d2d1f2107ee1e8a706dc5e82149d7ed370d425a67c3f61686c652616e5eb6d782798ffff47b0a697a02a767655534c1bc1ecb71534b1798dda5c59adcf3a606a08c470d630c48c04ac34f6fca0baee01628d8b52d35257db44e995f3902ed32a84115168399107f2e4ce29733e5e9885f890cf53bab977906c42053d92b91831f42ac0f9562495c29dabe1162d57b2afc61d53cc893522818ac13cb266406b6659c2b8256401656e6cf45e43faa3b08a05dfd0307e6abd2365db2c7b13cce1b62c296d1b839899fcb4ddd31d17929822870756b93efd48f65ce56c0456ed0d376d7ac275282beacdba789253affafc7c162cb205178b92814a447c0a58563eb212e2c57693c25a42d820dbd5bd9df82c38e2e0cfb37823dbb5eb9924a848c83f5e87d53b324855499615300e8bdfc06beeb90bb2357e729f1f5c9c1ed405708ef046d602192ed4c3314b2e882ca19a175bf3a2cf2fb579ca16a4a008147684d7d10cc978abc1a15df0999d00950b92c34fec9340a25bf95e3b82f74b046c20be1ee9cea051055961e997e5c2e314141177a745c328aba7fafd05149b4430135836eca3cf076cbed9c34c3f7a93b6a8e8231266b24368a8b85c694bf7a30a046b74e25955f3615d404585759d215c38ced97abc0eec14251fd0f3541a6124ebe4b0309aad20459f750910cf1fbaaa49b7ab023a7244815e1ae4f5a299123548226d512bf52995aaf7112bc5470142587bad7258cad0ffbd9e5cd720dddfb467a61cac7cdbf0ba8be4be4d5690cc6bf9c2cc7ba65e8ba0ac2bda65aeb969502aa4a1c78e079b1cab3dcac5fad3618953660b40eb0d3487153decebee55dd0fe8f3da986268e7f980ef85395d02b277eae1a079b0ffe9df8b7a3dc7fa208125193c597c5cffb5f6337d58374fc5fe08c0c11bc6d7d114acff3898afe8a8eb47c8855983dbf2c57e0742f3e909cca9221ca770001bea85283cae48429e1466ca9669a4823e5b2842c89a462f6bad5c9b257e8ba1d1adb45382c5ac695d92683f06fe1838ee8da71a35741d3e208e664abccac8f311e8eaae2702f75199eb32efa0ba3d986638fa160096ff52c6aa2eccb10994de7ca31d1b41e75e765d546f0d29ca1596c66e0a59117b2fffa8965517c79dcc1dca80245f37960f606b468de54d8c53a481070ec5a136a228e38daae7fade7a9901044410a0622afd92bd0f75e4186316e3848d975077b9cd2f9445cdd53f8b12d9e9b84a1253f28e335bb5e6b7ca142fc70ebfb9d1a0160d6b740c7f920cb6156ace9a7ddb1eda66d2526151335eb012482b2559b3dca10980349a6a79919a7f0a27b29ac634589715ec9960c9368a5d1e5ad6a54b502b99f81a72483e6db177ab9e6a388a6350b3c9d4dc1a9568f6ab37f0ca9fdff3cebcd75ed1a9d65ac211bb086247334fbbe72d1f2a1ec892446ff72e425f1bf535a9e352d6237dba279d24f2c4cfcc15f18a38073955ad568e208d5c2fbf44f6991d6bebc2314ef3114de5d33c5825c412fe9b8e1ecfdf5e6895522a11fd82c8520579b6699f756cacb3ad361d18f726f57607606f009de77c45a37eac0a5ef501ad875632f44b65696370613cee04283529bc539ff8ab8dc71609c730c682f997548c6b0f878fa5c3a915d4a414fa995b038582c18ac14cbc38eab69a0cd06cc3829fd1955736bea523608fa040ca5f25a1c3b078bd821a093775a22e45f03aa4e3f578d18e9653a78ee96968390f999a04d4d8dfa929f14585c3c59118acbac5731584424fb8b054105c18503ba616bd91acd517c11902cca023e9b339c2745b1441bf5902189d035786038ef7468d2102e1803ee2d0823380214cdb80aefe2d9542231a63182d1a4d1e8cb9aa95c7dfbec0e45fd99e01260ccc7f6a8797f842dc1b1c4fd00adf9c01213731d793ed1ef15cead98ef8ad8600a4b6c22c0b4a6ed630fc3fa6edab6ff1cdb93da7fdb01482529b0927e00dfd849da00a5f0a3af79ca756dc81bf38b55dd992a5c4b195fbad7879170eb6583ed6e6da9567f48b6c29165e094ac78c9314885ca81dce5e83d20ad5abe1748a85a8d77797f425d0c212ecb2d9c4340080c304ee4ec611bc1b4c746c2028b213cfda833a8ab031bbdc86f1573794918cdba8b9b12446de3ab41f432c06b0473964832934b056df907d4d0886174e93207012ba0510a2a720fbc123df3d7973994a2d37d17bbde65a9052c32ea4a9eeca6376f6892efaccb15f2d2f3147e6323012227e06df99c3290224fffdbefddfc0419b35c43f3ff605622c3f1f637d705c6f85735332539ddf944f08899e9f10db362360f1fd81887d9ff1b19883e160d33e8c43303543637dc2ef471838e675033d6422e75718011fad2d2aa95b88ede49e63515e01b4a67dfdfc10a7bdea9fc44c367b32b5bf1373c93f7408590214f8917fafdac853e0ac06caf29c02ddf46e3e9fe6dd42cbdba99f3443b32c03844d7317c46b3736ff1790c121d27f58d02e031464a79d14cb8fa87a0f36cac25e161ae0c86a579ba9dddc25c9f22a894988eb3f082a4db6364d4124b163c427433707bd65f8749a2fe9e48dbb95ec522ee1532647ef4c3d3914245934d1956b65e62c480e138ea381c008cc36ebe541931164619c0423ad3f1b006b7180a670f8ec42a1c5d23adb34f94e8923b6cbdab6e9bc461c1d4e760aa02c9a58ee57060bdd61e69e418db70caaf5d627c8c28b279b0616573d1156edd31aa896783d6b9d8476c399596f6212b2118d9c4252fe9582c1d7eabfa64b63eda4f02831d2c26877654ba5bff1f7221ac21e1978691d5f0ad133cbae796a41c4cfcee54742b8c32b3b3ebf665920ff9c5064256242f9b3123960dfcd6b8b565b05e6fa4c242869cd191ecea62ea130c4022cc75d73722e90214529268a1116da3c388f7a8444f2e38fdf232d6d937a6f927ff639e46822a590bc08334165ed541fe4df286b04e692b3dab68fccca13f343cf2b7194d964600e40c7e01bd482923517bb537f3dca989c551a8677e92a8dffe401a379e020e8cfc5a50f208cb28d2277a3f0b757346c8c5949910935816cff07c5907aa121737b5ec576ba6eb598ca38df1bf9f9ce58e7bba9a326f1f79c371601885cbf5f869ef7ab61de86aab68cb84ac34d8b00719f0b9d79202e34709ccd22c865f825a4592229932b87c68c24e499a99b9be071737a506e80644bda5c286e0eb35d7619a4a482c4f07da3b2775941a499b0b3f5fbd3a203fa0d071d210b358c4f40f33f26ab5ab24db6090e90ce194403aeaecd0c710dd65795a035a4ffd32be81f52b095c2eab2cc1c50ace483e6767ff07df49f26d32563d8694edff2c0dbe650cc0e0d8a78f71854d8b0dc1758155cfdce898d62e813727465086f016468572999e70c8f7599d3a1354c71f3e8daf43b02ade7568ebf03cb076ca99107f81f04cd8748062fa4fe710ad3539493982f23e810a3cd7cb9e0fafb22b939132219f65f8402a77a4dcdf086e2f299026bd5731088b97434779c3a91f063cc9067807b9929ba5c956722dc00482329780a6bc4934025743e02e0ac2b844c3acf44352203a5947804369db5ca4da286d75d68d6f2422be879c3877257725ca3a84f81a73e5a81878164c130a1b53ab3e07a3aa990fa30144de232cb800f910443088a9cf5087ec0425b0832b30765179ff971f412c48acc27764aa2970c71ea67c2ac841c0264e80213a495c07cd7b548cff5f87453f314772d0b64523a4ac346e9a7638a9778531cbd0ecb60ebf7c801ca4a42628954b6bbfb9fe749bf421efef45f71b970627fd0832f00159414c0fa210346f2d3845a5bc917325360827db8e375bae6c56f410c79ab3a7fd70f1a0fba61c1a621bd058c16c7118420a037f5ba8d7260f0c897b19b656565d633d350859f5648c8160c63f2ff1b56819d5bc90febcf4eda5c0e7a2ef10149d7a5baa45afa7f7d423f54220f4342625a48a5878718f04888ba5c4826dbdcd4555e8075537bc473dff94aefec723d89d81838f646611219e01df5ea5515f5530b358e16783424811bcca5e5316dfb61a8f67d84106c745b0b170bbb7d42d0197e39d1a6d12114ef37488a0715d063e84e98fad7e342e2d5b3b0843cc1f456b10a9a2644297791076801cad64081674c08925bb49b324eabfe08f75c12f46308e710d3219f6941204b87322f0d3164ed50d01c8238460597a83a713ddfa14a8bb5daa0e983775317d21c24c17cc8da373c96620ff27c31f57978213bc7edaf03112cfb1fb3997129eb31d5708c2a6b605a7d4b109540c96803eb938dba7cea21c5edb5ca7255aa480ff3ae4d1d188366b91b984cde973022509fd9d301368dadd383439e5dc7eea2bb0e9cbb660c7bfc0224403fff18a8daaba7fed38c06919eea938ed5adc281643325d1de87365f00aff9d50c68036a020b8313f0a67a971cbb6350e14f0a8c06aef9954c8efb6b4be2fb4a13d688109098852e02fc55bbcc01baf052648cae44a93cca4fca29168dfea1d06b9c9344b8a374f7c1058344a47001c9ffc08ed3d0156652d9f2882615ae76d8d1377224a84dfb298c83f2cfb6c3cef1f849519c9ecf5e7e52e62ce9c66f85a9400c63fbd02b3d37e13f2c89809e12741be003afc88f995ba60b5477650f63df60bd30ad03921bb65b4c84582d912426a153b537c7d824cec8e1dfbb33b2cf30ccb31ffd013232d3d53c691cc262cc171a3ae9da97cf5fe677433728acdc3294ea79dd250cea4d9aaf2bd51a0010b586dce393017e292cc0459a835fc652d7cd66abb0500d95e3f04eb309f3ca90dfec8c1119c691fff1a04a384ddcfceb74e3162940920b76e64c80cf4ce4a5b3cd449c839b19c2e0068dd8c46fc506e9a905a4a16c3d21665a0916014aca5468390f8ebcbb375601afe0544b194eb97283aaa499733fed3944241086a1d82001691b75fc051a011e1c98651318b48b8d109d821cef3663627986bc49ddb55b93d60fd720a8759f315ef947b541981c32c403ad430e5b9cc87be358fe514d4d9b6ed211c77e72c71c136412728fb037faddf07e84a03a91bb28feb3c44a96604d781e3b8d100b51b651e029d19fb6b5261307ebcf27bdadeeee7c8fc6658785cc1323aa2a7f5d12d639ad71e91332f80ceb3111d8e701a815ef294ce7e2d247052c99e9b64413e61c87e1b7e96198f8a6244b94b124e7b2228ef653dc35b48e15a148664a360d21278907392cec5b37ab60d703ccc71f2016f33eaab3fac531ff92d840230d2a038b5e15c3e482c42b2465ee1e0542fa0dda7d5f5241cf8536fe98c4de80910eaa0bffae1397a1967e7b00f2afcddcea6023357028ec884ed5e5dc38da4d704f6259f3058d4bc2614739cc6230c9f1467c35c8bb4b6421680020c365f619a407f45cc5bc0197069e6991aac28e3f1589bb59fc99ca1b5aca2284b08e441eb576f2b708b64d414b2223e46f6fb55225005395bb1c8ef94079a7df2d26437051e149f6544bd10a66585604ef294c9bf9a783b17117ffc3a05ddd7073b629bda6a582270f3ed12e3ca40a9a83cd1d8148aef840e8fde04a4f2942b5900b7c79dd941f72be5dddea884c8421293cf08e6527400099672e1288e1ab957df1ba3090fe9aebeda5b48ef6bac2a39fbca30b5baa3691d4ec7661bcd2bdf5ec4f2d7cc3018e9e7da8f9571aa2501f9d3d5678091ae413e81bc9368f1193fa95ee437cd27447d944094cbd034a04639f5a304cca9a0e7589ed157bf66477b1ff7608fca9fdfbff9b9b3b641b094267b4eaa879bbbe76e5fe3b015a3336b8f3383f78bf2ab4a968fc14f467b68e18009de8475ceb0a13775033867d5ac9e00a1c4d5a6f5ad2f69652ca9452b009ff09ad095eb8a6db7857f58d46d363fa463fc134fa3b11e9f6771a6f2818488a1dd0eba24361a01fecb7e7fa36c95879d371110431afe5b190ebf9bf96d76a7d656fd916b7ba6a3df72a22e7f8661fc8cb2f2f8bcc402dca7903099ea45a6bad319c9925d11b7ab228d140b9602559a94af294a5861dda3ca1823d7102aa82c902ca87294fbaf8e1066773434f1625fa54cd98ca2689c6d0a40b13830c459e89145190512203021688f0c2e48a270f6aa9dadac31319ea931b5ab0b8169a685f3248d3b2da7452da462ebdd1dff1a79452002061e5652d38a4db6f474f0bee86647a59b8e61d679836600c2ef3f08e993bd2f87570154d0a799e770156f23cb6e23a6b711d851f5b85978b599ed8595428782a5c7724fe3c65b26432b71b8070250ed368f7cc73698f10e4ada265209c0cc442f66c09f6e59d1439ce10eded5aed97ec58a3e1c4d2c8c1810e1a3b3d3e1198d4c795cf0a885151974f5e3c88b9590766f6251ffbb0eddd521c6ebf7d7d1222190c84c4ca6019d3ca72c752daa42802f57dfdaa61336d4e2a72370b4f3e661bdddf5a2b8714b8f2fb8bb96c96534a798f6af795efa4cd6d9fbf688773fab794d2369b062510490c2d24619e2419a1460b12aa27ac16992254f8d61a37355902b01801451528a84070c50a2c2c9cd43047c0b086504a29e5374f6e562062840e55508e65864ea1c2e3bc10224bee8e5fab51fc54a5544b96268cf820c92029cb113b6a94c8c2e58ef6a7c097f7dff368fdabf55feb83c8f79ee9eb61cfe3fb9818c4f5dfc3c4204e41c07f3ddb2ae879dffa59f74734f9336bb63694a306866c035fa2c758d36511efc8fb22f0bda7542c7a7deb0556af138b5a2f4523ffd61bc9f73e5777420326282dedc1d7acfb23db8e5927ee402261040d9ad896e779b226c2082f9cec2281af50be8b6afa2443fbce18305f7ed17c5934df138d48903ff4a7c8f2a74a833276bef4dc9334917a35d83673cfeb231b0f31484bb4df75eb7974deb7bee547363adf45084708e97be883e52a11e80a5fff0f03cd9e6be5fb17c97759c522f99e68f47246e5f3f0ef5c9cd978487146c51dadf73a845d96423590d65961e54f4a933ff3bdb09b73d22ecda17817ec8c490342ad9cc639a409dd751fb61ec4c2c73ef20776598706652cdb8c9c8a5c2edfe57bdf2c72bd271a59978b46523462514eeb123d7fb67963ed4efaae679b0ce57bcfc3df25067105b1cd04ccdf0104a9087786ad188bdf54d11c1c047105f9bec500efe543c0e554e412adfce9209ea844993eaf7eeb8beab7bebfd5bd271a79dfbd518bbd8732eb56e87d51cbf3de251abd510ed9f6a1d8514693b2497fd2bcccd77dcff53e88fff7dcef7a1ec2513fc793f0c3856c5071509f6bad5855378765cd1df9ea7aaba3b48a85ead67fa13bb251f9f38be4cff9522c7a19c97f8947362a8e3fe6a5dffd9ce6b4a6893e4eab5fff93e0d0044ad8d1e7d66ffde873d9fffb22ff4ff4c4a27e17787dfa369da2e0512ace18505f3e8fee5d0ce2dfbd14833815f9771f447efdbc56fdee6794b65cf5bb96ab25a97cb16e6fc640954f9fc7fc2a0611833815d59fe2cc16a47b29ce5adcf179dd34f9131e712ff4c1f6f31d6934ff0efdc9c73e9efc99fd4736125adc815482064e6cce69b2d6dc8124dfd6ddb5c4bec964322677cf75e00456260c8ac359ece6f67f356883fb61b1e0e5af6003d806eb6b89c81f0f2ad8facfbb76d878745be0c7be88be053bf96c03c3991465b656947d2c55ee68afec6ab70377c04422f5c1270212fd9275fd170bd9666d38d47d0d3656e7777e26ffa8fb991477207993fce9de99e48fd2d0ed5e03275609e7bb9cefbe8ff8d304dfb1ad7b9a31a03ef822d087e9fc4e0c49e902490a7db0f2f90279cd5eafef81746fd47ddf3ca8bbdd779307517121184fdd3752f7d475dd94dbf591dbfdeb7beadea978902b7dafee9d18a8fb9d1088fce95ea7fb5619eb504eebfe25fa93d3baeec5275676bf430ae588b3ef63247890fcee7548211c71f6893c40fab00f521f7c1eb08f7d4c0c421ff66ceb5e042964bfebbc8060c915c0652f3454dd0e08fbbdcf3748f4896f47be828560d81a796ebf7c2f949d2bcd1725564daa246c7e58ec8e9c5f65ea459b78cdc91d193765b2891d6560083e4ef31acfe52e3f20dd1935d9c48e3469e5abff4db6e1dd4343b50e5e5696071848135684115a6ca39fc19dfb00fea93fd20ec0dba2080c543f47093b7653d61bb621654c6c0b5944807471eb7718b6c1ced46a6e8de25632b70e89b9d5b3b2da4d4b4c52a889d6818586ba69484b3714c4d8ba4ddf3def251ab9bef546df473ba1c8f5df090d609b953ff54d6800dbbc6f00dbe67fa291914cfed43fb2c91f69b24619cbb6d6b36dfee8cdfc8f6cdd14ce5cdc81d438f953bfa15a8326d6f5f903a9ef79d666ddfa1a38b1557efd7e924250d599a450ebeb7b9314aa9f58df25d67770075238df15ca5752656a75538c27ab81be5e3ff4c176cf77eca66eaadfb5833b54af56ef755d68821df7a1b973d87ec3c73edf87c5c23e2c96079c31e08b604871662b3afa22850f30d8ba975fd4bd148bea7bfd23db2d72d96ab0b1ddd7df81d489550d0e25d95116fa60e9f31d87d8fc00a5852cacb842c35ebab9964fbe9295d16e4bffef0322979ce6f5482e8d4777be6d59f3ac1c7b35b28698a24b1a234b7a58c346bc61b2a68d99124c29520596272d1e2693c89552ca1987bbc1063254a4c8a0851a2c2c34998207a90c0e862c5ba496f0ab2b5c58f71cde04eba362ce39e79c73ce2b5cb430320409a41470b0cd3477ce39e79c5fceda862e1560acc8a003939929407089818a2b4c7460340095a58817485071e5031a299d264652b850a384eba1c817567ee5ca085a4c388922aa34fd80431a2f8e988200586438024a0b16397421c50f3e504a29a594524aa1585862045a72534c0461a3515c4a29a594524a7718c87fecb9fe3d6c835d72210127a2f0d084e588ac2dce5c5121a74991264fcc60254a114c707028de804e1c0cab01a3d3c4b160198105154cbcc062c604ac2d9e3c59a214849b27babc98f8110f63de2031c40b356099f29c95282a5ff28d99c27577e22c2bd084952d597c81c4cb5499194baec0f04407295c38391182167bd381e86047cb36baeb36b7c99e76dda54c227b5a7727ca3a83da878f4c27c1cc2cce21b3bae7dfb1879ed37cd049a778c2bc3e68d72d95c99852ea31f3147fd0eb2fbd88adcf5eadf2877af2a7abacb2ca8e79dacbf3798a9465e8e38e3b578eb992622945963ffd1e333f03b5ccaeb1fce3ebdaf80a37bc44ffb8c1652019069779f8877f8a2f83feb43b0ce442dc7d0acbfc1ecdc65a5ecbcbf2644e29a7b5ded7f758a8eb2c9e353c6be49c9d0b3feae59fdf2985dd009e73ce89355a2cdb3fca50b2fd9ed378ced7654aeb0b92a964fa94a7052b2995799776b13801dff33bdf231a39ed8845e1fb88463d1fbe518c17ffc866413863c0051fe3828f312bb2e07bde82ef7919e18cbecf1fd93efc97f145ff329ebe0c19ef231acde81fd964bcd18c8a2714f93c06df00b621c5780c4423230c1e03d1473cb27dcfb3ade747598fc8b618e205e1d10c7370feebd705e1914d0cd916866cfb906d3242b659101ed9186cbd53fda8b7257ad50a9647f430a33f4979d0d4070b9de67f3aaf0e5d5716b2edeb20e779fe6370e771be43fb3ce128de1d91e773489c30271c7d884e8b85f07d7ff0bd8f219e7fe1c8253b8ff339e17874731e0724caa1f43de0707c9e709c97e777c2b1efced3b0861536d49138bf131e5d1d71004d03e76738d6b8389f43e684e0e384ae8785e38c1b7b1b8eaf1b13619f43c2c2fa603895427f721a94d3e4c34022973897785fbdf9e5ca3975a5c089ebc18e8ee39c8e30899daf249bf9a79b6f87732e71c7c578f92ee5423df4e53b94074d318718e29c923f522a9c54f207e7342a6a74772d58bee3c44d9c377138a93495a6d2954e257f80b03f451c8e891b1af2260a12e5e0c08d4dc0e4dcac6f119594586105218c501652104e80bb630dcb1ee9788c283cb4765ecbf5bd4058cce2f4effc8e38e67c8bb30f76bebfc551e777de493af9f3849e6f30e7efe88438a1b58285af304aabdfebafcd3e13c76791efabeeeeeef4ba4f2969f2a7264a29a54bd9b49aacd297a27bd3d04567f70ef61da197ced9ad3a67ab9bd22a25129a90e70c0116e28030420abcbe0cdc7e497fb69c68269a2128173e5f57cb342af2ec98465ff67c815becff4cc1f6bc4c26853eb0e67ac19e6d36146301b874000bb832a7c509dcaf7330609b81a890d9c47b4911dc623f5a69cdf39a44cb3a5969ad34031fecce652d50b840ebc1e6bc01c01bdb61411bc27a6aac99322e18f9e23f1c8687913101a83273c41d2d2dcb0cee8e5ffbe1e3037c9cc3ce7f2a9b0a4ead31235bccdcb6dd563a2a4f539a62f676bbfda84f4d5198a0c0708e48dd8003e788940d51a02cb5129813c58b121f43bdd44a9dd4482f9daa23a0a8d1498dd437201f8f14313bd478a48891d2b7ac36fc3e5c14d8d086871914d8d026046daeac466859e5c614793e63a8f8757850ed3c2a291cd5c74b121c6ef776766f3b291c5dcd832a0d8018294bf89005408c143143b5193e9300307c9962070402c0f0458a199271b47bdbc94f4eca62a488d9e1766f67f7b6eb6a53ef19a45e776f6d37e7f5f0a86b9da68f7db22e8da56d9b27853c2b73a197e7341b7f87b2bbbbbbbb650f0ab6866c9320d10efa9ff77ab9d0ab461bdb59f7b9b13c293d2576ac5df953865eada291101b156fd5c9f45c36bda1e9796fbd9a1372a6dbed96c456eb53857aa2893b565c95fa1feb541d13e5e54d1e99e18e526949ce8f7249e74719e5098a0cd51d254e4aedfc28a7787e9461aebfcc492ba43b4a2cd966821f6516053f4e24a52527aedc7132cd28b21f67138c1f2795eb3f71e39c7222eb8e936a86a9e0c75935fb719eb9fe136b66e59ac0b92345ba1ee329136d9272474aa95cff9142dd1fa9d4f5a754b4eaca1d698e9eb9fea61e79a2883b56a5bae4ba6749284d5f64957c73640a8f73ccb4a24bd40aa557d76d236d731dcc94ebd31d0c133ef5a58601c3d379bcc40d2b9705d21554a67021e608054d535c3db504973b36d51d3bccf5aeea31d7cf4061024a0c848dbe347a13099cd8b9a353b9ee6ee5ba4b5d7f1e9dcaddcb1d3de767ae3f7390bdff3240a2ef8f80673968e4d1555421c2e72ff831079f0b442136a71e3ec4fff7219d942871bbe27ff8168044e1874cc59521e3638044322cf81e90c882d78db17363fc8cf19e991be36d0eeac628c3c28df133902886ec08a5dbf31580443db323eeec618044b30a5e06125500c3092617c6530012c190c97e029048e67329c85d0a9e0724a26082097e07249ac0f29009c1e5791d908867c7b6f33920d18ecef398aaabf33820918e276fce5b9028872685867098c04102078704575c1c0c2e0ece5b2717a704555c9c31572ecec740229c21da0fe530c25a31d61ac0e2b8638d6b9f77b8b600d7dab74c9cb9f66555415cfb9fe4daa73581c4b55f23810dd73e0c24b243ae1b7b10248ac196007361ff02896042e07f2011f8aabae3ce7d8577ecb92fa0fb7abdfd725f4b44b92f3134dcd7bb40a2d77fef72595d97eb3d90c8555b60baadef40a2d6f5c254b99e19cf76168009e256f96092eebcb9dba25b90c30fd5a65ad65e4d8937b6bead696ee5b9b5d65a2bce6b47833bf630a18416258a48820a1f3276f4e6eb460d246a88a105092c544b77fed3a8c0dcf9b5249ceefc184834876aad3a2e14e941892a374954f02d7aa0c0823164a6ee38e34b0e253022052398b418f1e68826ee7c1848346bad74bbdd54a0c2050c324dbc6a2c819bcabaf3655ec4dcf94f4408ee7c5a8d0821eefca122a898829a536d9ca25089c2218b93275c8b2c3cd82f83a924b7be8bca13b0560008d0c5aa4b955bdf135d40a2c9480d527ed022eb4a198f893beef4383144d4ad5f65530529983441040b524800e5a6cb08902845820b9b5b7f7a7fc4a44d15140d48a84052c536b3e8d283102f0baeb0a34cc6369ccb9958106768b398d99c71a700ee9c5235dc2995c59d5c906cc982021d3c18920b5f0a3930890bae214a2fa6262da4a7ef07275e0a2e235ee850a86a458d515289e0bca8354be810ac6ecb902693470a750b0c2f48f6a6c7a30813e52d4d30f01882dba225061e448e6c19f38407529519a8cfc1a2659dd75a31e8d245959f2bb82ea6a46c8ccbb82e8ec840073bbb8ceb220d00907851e40d086a489aea1839cfb16f31096e7b9e4be9628fcbbcad3c07d5583efd503220acec89359a459250e188cd68e785b89b9bcd29f66ddb098500e0c8cde624e5b374cfe8c8858923900b7b0fc7791ba55190204284e0ae7f8e7b61a10907f8e28bac5166dd9ccff910bc98788209fdc585b12d278cbd5b715ae3a0947a1022013cc536e86d98d75f6e5aa8609edc51d4223814b19c7f82ddd35cd88fbe060ad49b9cd0b1c00e625c173dc74057566718c8a75873fb5d7a3206732c35b718cc83c2cd46b080d3ac744bddfe5c4bf9f270d655fe04d368878281fa5b0ffb58ce83d03f9c56c28f9d43a32302c9f27ba38f348d2bb6e1a9e11bb06ffeeee839b631bbfd7e866dc8b7dfef51f08dd8f7fb146c23e763b19b63a517f6d591b173476e57e574ce2879100bf510b7bebaa2e2b97ed3d2c9f11c15da9de1343f83c51dfdeaf663d52072793be8cb9de3a07339e618dbb9b66a346c038b6db4d886ebfb3b8b6d7cdfdf6fd8c6ebfbfde6485af08d9ed234fa463f358dcef9b1dddcfec6826fe4bcce8fdd05dfd0f96ef2254953b8b86cd886f7bf5ad7437965d867ae988172574daca3601a7cf93be92a754e071ba3ba7df908a5db37a96f3495297da3ab9a46f78d1ed3b2a6536e3ff912032931902f5172fb1d89c770fb1d06a6d1af139e00fb1c49a56f3813a6d1ef4e6e3f0e95db6fc39ea2a3601afdb0b0d5308d7e306c2ca75d856dc540cd40fdadb0730cd41f463dd891b360583916a8aec8dd907076ec1bece948d2153bf6111eaa27dc0eadd44b5cb0632bc16e4f550cc19406ca12942476ec250a8ce45098d24c1de5891d9bc93e15914295a62939d8b19b5e4c8ec3228527a6272a4eecd84fb72e5c18e9e2e607282b33d8b1a126c09acaa2089b348d6ba99c1c1555509921d253fd85891d7baa02aa21724cc034558769c18e4da581522e4d19aa9c9baa3141d8b1ab5e4f5db6c0ea92c552e7fa8c153b76ce454595a686a099424a6275f5821ddbeaaabb4db539c3e436e50688a936423456b779b26363d1dc1553b92bca7456bf01811d3b6b3e2d2d21c40dc9c98e7ecb80ea48921f89620a8c4b1451a2b8442186cb992ca52558ece84a4f309eb8c0d0c40506325c9450e1b2e4c51214253bfa12ceed892c24a6284aece84c2da521d24861d5e44e831d5d09b7c50d6bb29ea8f8d304538986a7efc6a40a282b382911d8d1713bb928235f0c29e253fe658a1d7d6a4c054a5262c24889b9024b4a892b29313938958711c28e4e0584a3f2059557f918afaa54b919d8e0925879cecf006147cf71172afa06046ee5576e055261ad5003c814b502ceb1bc0d0f7674ac3617e4864073c5d4c2a73484153c0c8126cab3fc4d0d76f4ac2532aa2e5a246175e982885c973650ba643d7143a2624779a34f4833507961c591a4263bca233838a9b42489ebb66407a5255176944a4762514837798b2262064b0b17555143965882e2831de5d21230b70549d29314a62d48ae6c51ca3145b9c18e92a975cb59110595155c344d81623f6ff965eaf64b2a0f9ae0f6cb2c59180f629c1a9c3c63e5a3c4926fa6740975fb5b090aa766c9f5ef97563c68e6a27c725a3fcf95f2692a197971b5aa8c81fc9bb3f5c29b5b94239ae4a465a85879b57a6d6a509222a5345de1aca865802f4a3cd95ae2914d4a59ef63205bc50ebe1448d0643372bd908ea266cae624ffc8f6b54257c82091d7d55951eb67452d57382b3ab2e590267487d41582ecb68701d9ed6f2155b7fb1a8edd74ab27a56ced2ef4414122da6275797786de6dc9cec12e1fb3003e9642d236a5b777f05506f244727a908b3d7ec82bc48fdc35f0f5f821af8b33297ee0cf01797bf077df78a2f365f28786423a2b21b52648a86c4eb3fea3dbe2cc028d1442e34d53968d7d838f4e1ab29a2b2c4b36dad5f7c49b90fad5c8a9fbfa4642e8cfefaa2864be73d9a0ff6397019070b619b2ed897ddedddd3d0f62a64dc76eda83d28e763de83b9deeeed5ddeb8feeeeb5dbdddd6b37adb46b57698fdad5aed2b047f557ed78ba5e7ab35dca1e3de99c41d26ff4ed1eece8dde9cd3b6ba55cc1c06030180c06832989599c9c17ceeb735e39e0386f4c84812f58ef4cd17df7bb9444b97f9dda703d832074627f77fb9c507ff495df0ce57fde4f7faff6140c21f43c1cf57eca64d68e5eec5d9c9e373de8aff733304862bbefd75b80840bb08dee2995219359ae79907d9ca73fe441f43f1bbe9c063e4e689d063e831f607071c4e934f073b8f5faee2c4fe81b0b4fe80b0bc7d605c597d3acd36efdc4f979a2e7c9efeebb47cb1934a5777b3f767777777beeb3d66e6f47a1e594b8fbf1abc3d677e151ec82633803c17bdcd6bbf75edf0aa86cdf762f1cbd1edefb4f30047f31508ebed19752cfeb72f878c4583b4b782fb95852e537db70792f5d9fc33de48077fd7d4e087ff4edff5e14a42cf4f2a752faccccf45be2d8ba14e7524f1c615cda458a2fb782cb5da4e0e17eee7d47df7bf672ec6875debf14caf90a03ff25be2803ebf7f55ba0582ba0a28e1d2dd11347d98591b3d369948ab30edcbfe6bece6377fed49f320dc77eefe70c9a72fa8d13fab2e7795ef764af2b90c1f673b7cbe512e56d47a1a707fb150463f9c71d7da36f6dbd8be3bc1ce8eb89b30fe4175fb03b56cb6d12174873ce39e79c5ab6d8c2ca953f63c8c7837a9aaefcd7e8197dec3352a52b9fbfbf7850470025b6fb640d17727d5f1084f92ed1fb1ed6a0025ce2d823a3ff8130c348f90a7388bd2bf6333441c8ed76f6d2fa1efc75fd9c52a34b9cb99e8a2f97e89910bbde832fa9c658c936b7a4a5284f56a6c2e4ae661645f22047727ac9a90a8220deefbdbe1fb712ff97962ddadcd77f200852ca693ba29c0af9b6402b85fdc04ff080afeb3d68bf2d90081499698cdffbbf9e411082dcefa7260882df4f94524ee340dfeebdb0ef1667ae7f072a20769981bc10e4944c8281644b34a1e594d32437a5b0f9359461c620774e5152814ad851e2a86efb3355f29c2633b3bff4319fd2e94d3e376faeebe75f5da0cb5adc58b99fbf725caed073c8913c612e51feb844ef1369e174212427ef918abceb8bd06c4eafa7dff77db1b0ef9c733a61c71ebedf2be4eb66ca35c0652d592c5ddc652f97b56425dd9d1e0f8dedfe73c2ca6f70becbe572b93e27ece77a97cbe5daf120970873c55c2e97cbe582c580b03d4ef3d6cb157af7f57a851cf0ae0b043f19c85fac000c247362b1e9e5844e385370fea3af1fb621f6e070c99eb0d8b740d87f1ee8c1843d831dc4fe85a3033bf060de97f862a059072fa7bdc41eb18379633171c86931256ceb7b7a767660b158ec5fb1900023b0b1afd669fd31716708471c3d02046169072fd08a218c7d77c2eef6dc0edc715ae3709a1c62200240d94f1c77ae164f974b70594b9698fbb95e5ec89f1376945d097ecb55410d33f687bc2e79bf594c3c0184f9c1f7531c5dff89de77f70b47ef8b8923901b73b99e9dc6379675edc73e87bb4ce8ae15c7be31317489a06520091359bccc409d43ce5bb6f1bd74fd50d390eff964ff999f681968fe50dfc0611af3a5ce7d39cd479f11e7ce2b5f3db7e70fdba8f7831f06ea8fb90e13669ecccccc93999927f374f38db5878164723e9db3328737586571e48e3b35c6da8ed3e7015f134c9897190887813c7e859681b2eed853c1072c6bc1c2ea71d846d8d7f320b681e463af49e1103dae1d43b519bad25fe08338682fb3d5602199ac7910ecfbb99b89ed86751048170693fd912de719023c3fc11751f032d1c8a973c471e882df6211cf4f70646b71ac5d1004c57e863a73c10745761a4ccce1b19c3f22b23018ec3de070fc11c679753e271cfbe63c2c0473421c9d30f63938e2009a46ecc170ac71639f43dae9b41a56d8873d188e5c55e3824d60e875e883abaeace5b1abbe17569f41b33b12c7bd2b7dc4e290695d66c22acc6526aca42e1017bccc84150cb73bf0b1cf38b9fb56add5937df7934da92696bdebce0f5609c3ef41f6c5b2d0c3f88ffc0e3f9c170e48543f4cad46cee34c1c1c1c9c9fa109325e5447fe13159ec1a23f99d00e25f54bec3895c239c36e9eb7d3dab73c9fc33bb43f799e41229ecfe155f729c0c1365cc8a9e48f95424426f87f22305e06052f3e910a3e94fd054f64f616e4b8209cd1bfe0637c18ce76c470b623ce18207ecf1789013a5970d04982c5883539580069795d03a1b33618207ce5e5ba216e799db367bd4e66ab4e0224104d53c63ccd97d5837c24b7bc4ec7649a2c6786b1afee641b55555521034d1a65ecdc9de241f25fb46f592daf6ba6dab7acac2c20f2a78d1dffceffff7faf8a40fbaffaaaafd2d18940fbaaaffaaa87c23e791015176a1f206118ef2f9e959595e5b4fe2e060f1f5fe0052b6ca6d8e4961cf12d2ee042ae25edeb738d08a49c4fbb70a4728a3d66276957b1c7a44dbb6743f1e4e30bb880c4e6089b26595417545703de352176fb93bc7c7c811a97a358f8d242d3e5a8a42fb788cb5149b7fb3eb42f36ad6efda82bb26e157ff8dd80ec8e406eb7dbfd21bbfd6065a6cdaf5efd49c51ed7ebc6fa7356b1077d797bd4dfd9a9228e2345a46d486773d2c0bcfd7ec3dd6eee21d9d1ab4924a8e4ecd9fde524e9a0ed124bf0dff153af43fee8e4ecd84c5f241353333593753925ede7fcdc71e24d5a86d61c34b5eb81a5843cffe9762967cff939efe998f9d19ef7d211823733f1d43d5826f7a1c5c4403558a6afa1953f4dd5a3c4ec266e1eda9f81b837171b05a621bf134b903fb2c5212530501776ec269ab73463a96fcc97efd1a858fbda6b799d7b1e9691b1ba894f5337e91b93a984eeaef94f0fe508c5a6d15f4397459cb9ea2a69951ba16fd06a7fb214ea3c76b968dcf2baae25d6e48f7ccf7a9d4ca4c91f1d9c1dbba99b9a264e0998cee96a9da41c1e4c24aefc190e154046bb4193d17288d8916941e3ebe6c0b96c2c175a2707cf6b87d2491e340a09b18d66a0a6c91c363de5ec9e3b4ca64fcf0e5fdd4973da1c3a0077a131d0147f6402b8d2935db1e3506d2866c3c7e3bcfde1153bf298dbcccece8cc3c809cb357a54b02c8e3db7ad1447a32b9f8f26f3d16c1ad51ca5c29b2815982e6d1ba54c9f7ed75adbf5dc6ac960f00f7d119cd632cc62e97fb114ecd838cfb356267b991403d13fe3340f8d8dd1c48eb599fc7ae79dc9e725a2d8e2f212516471c7ce758e568a8bb1a455633e076c2376e988c325ca1888fe055d58cf72e541b866c25fd84cf887829d856d34e8f4c2e152974b1c5b864b41d90a3d90a8d5b53a113665297d0ba0b0f5ebe5a823315c7939eac8d2a5f5e7bf6a388d3e1dc01256c7e5c0698dd5420363ce29ddddc5277777779fb25f3bd7ffebe934af041edb609e724e1c9df8441bca5db5acd166481bee58c39d597ef9d8a756ab31820f1c595f86a8aafacd15bed16a9886cc72c75a96cb625fc1a8902de6d0c6835cf4b1e2683ef619fdd603a8358dda320b856dbd477f874cfe8823b05feb86be7f3d0fd7776290ee5dff1283381575ef1267fe3571e6570c54bffa19db594eab5f3f0463a5486b2c97c8a28cdb1d964315bd5a9349211db52a73d4fc26abbecadf1c634ba0973e093e74882085be2394f21f61f9c187bdeb3f4f6cbd80c81fea33f931ab99c46ab562e24bd4d1a2af1cf2879e2063a06efdeb257d5848935d38434ffecc8ac07f3d28b2fc697f7deb5f624b647feec0ed102b4b9039a4d0f7f475009142afa7fc632dacc91ffa3487d653f6a4508d7f78aa255af9c37e3b246ef669320b8ad8d90e24efbbc7b97d5da3cc2fff8de5cbcabef043990cf6fbd7fbcf9d1d2cdfef5fe26cc7f7b306b0ed13dbf6fa198fb6bdbe6d2ff1e58f8c81eac7b6589907dfb7dee8b50309c9f52fa4d67fe26cfec7b8d93462f9e3fad6cf6fb5fe138d5aa251ad32185aacf572d487affe67a590b4d51ffd368d2a59c643cfb2ca0069eb442b9fb0f4bfdb1bcd910d699e68b24203153a8c913514b1446e49c9932f5524c9a4a8335777e7725411365a2e3ffd915d0be36e0ffee9ce74ce661c53dc01986760fe5cccdc62af19a873af9479824c93eedea07706c6175632b851410635b43332e490666882f1c577b2d25aa3ae9248b232bb237380124c0188ba228204575277b4566677c4cb512c48b16f03922dc858d855065b2c5826032d1654a2089b7339aa0a2e071184a91285829cac65b437510c9171396a851ab620411249282811c3840b2637de9021b5d65a398082439aabdb11596b240d4542c026290d45e342eb7294162c53522debbcd25a690650589ccb5157b8d09454f941b2f672d4151c9eb8f2441645a4086965aa0c915a6bad33cc550d449e5a628604c1c290145ddc91712c1525451452e48cd4bce63f4e4fac60c4c2de6470439b0c6ef6438341d513187861e9e5a8dc981f2ad6bb1c950bf3349b0c5551556e789f28235f5c7a390a8ad51dbfd62447dfa33e6ad77a33dcf16b90e18e4338b424943b32d55208eec863ae3c73c44b142fa4a2aa9031442d3de9d45c5145d2940a498419e248ca1b23382c490551440b36f93aa4900796a678818d1a1e8c28d964eeda1ddae5282757dc9ccb514e7277b44f83068c90220d0f52acf04413f904eadbc242adb5562b48da90a0852e7e6823612002ea85c90313921e28a53074435c86247838628635e4b9bc4f9496a66b2f476959bae3d73a2f7ecc60f065c99f389a21c907334850b88105304b6868152d545beb981699289076d6b82e471589e2c2b81c55e48b10b59ad76ad349e9a44961e5e5a8225eee68a558bf1c55a4cb944e8660353de09c308249912f2cc8265145b87407966680c10b93149535b65a8d2a92e58e5fab8146abd59418695fab81a10245052a0c946432c40a0a2570814c0a6b9a904b34704314370481c20878b805e15794c8d8e18b2263b07893c3937f2899e48eb21741d21434ec60868724ff503cd29ccd1a2b68b24082839632b51a184fa3064a22e112e4b0830b6c567022428bff20388cfb5b28773327542a31c0a188353621ae289bd3f48cdc0808bcb06213a2010b36a749a9bf6ad83c30b9a264933571c6a37e97664c931b6c426057b6fa9d68d44e048182954d488e0bb62ad27c83fe23db375f7456548d3c230aacac10c2260414c25637e8d0680055aa18926513e2512bc860abf906fd95f61824b26461a37da553d4154bf787bc19cc78d059d39f4f43ebdede3e1b0528eedeee2e9f711fdb867090f083032a574a29a594b286d736f76e8b3ed3e50d1ffbcc781835154fb6fa4e10e89ebe37c666f48db159f913847d79b98b104977ac5d2995dc18f4c18eb22b7f2e40bb1c756b73a36e672e47ddc2005d8ebae1703f64a11ad45208bac45045893636f90d82d04d10c672d44d863bdfdd8bf8e4532674b87df2d541635df1847e138e6ef747dfe64aafb790759b1d69b1eb1f631b5dc17510013c639c2fbf7f8ade112ebfdab5d2ee64d470afd49bb8e8b47d8bcfbf63a07ec97dfb7b6ebf8e22179281a5c50b2b35866ef317e93c76fdafdee9d806ffcdc969934f5934b998b2d8c273045600545d5c58b20605ef65e50e76b4ddc213160d48724aacc87a7ab09e10b164c8fb2cb1e3d36684c08eb44ea6596a951953ab21c58eb5dbbca209d7550b433898ec3834a9a8b49082d3224b0e0e60b023e3a67094bc48c17991e28497262b2f529ae84840163bf2540c8b6a4892253b8a6cb0235329cd2b8e7c57ec204204b6d891ab3e2c2cb0a4a061040b70ce958b62418a112324f880b2235b794ab92ad250596151c28f2a7664ac1615152b50210390a114a884ccf695412c95b2810000001000a315002020100a87842291480ee4d1b87c14800b759852785295caa34912e428884106194000218400008c31c42034662400841b56c86f71fa51417e37e4a71efd4006fa43a135d3dd9925766406335d98e1f3e42b414e52679ac03f9b8fadb2dee55c91f30e1778182846c5412f0ffa798402a4f097292e3f54c25f9bf50c5a21bfbc262d9f838ccf13512bf4298100996c1df0280bc341994c870ab3476634a005339c3ac35044545f0142aaafcb7d202390cf0e4619ad6342aee4896ff35f326500502460c97e021613232e30b7204cbe25e8d5798ee4187c6478ed99443a591507d17ee3f4044db28af9c22619afd3a4239f17ec93c277f28adcd5b12617c01685ea8c298b4fa3d65432d88bc90533c25157b51de23d6e2949123f0c450d880224a9cbfed72488d92710e8b226ed4321e6827097a4e04bc62e2e0a1d64c3da301fbb474a3afd9bc9cdbfe5fe9b20f199d9f0a907e4e9c9b7781d3914c58569fa7036dea1014008d1ca956e1b0e3c39d5e9635d5bedb8c92cc67d04a3ffd72f4696a91e01014c7d70bb6622a11365cd44828e603513073a02a899d4b7a23e85e5a2bda008ca259ce31112c100d47009363ef61b191bc7c2f60784631d254fd276a92219cdcb8de3125580c78bf433350ff14ba7523a0f1c12370fb631cd1d121e115a9be519f7dd5c922f02fa60dc1de55cb7e4790180facc5afa2332de183dce8bee354b21b45c62d69236ef2117f24b4405fee26f65e12f22c25bca9ece60c8e7d7dee37f2c11ec111aec2cd05792923b459d8e705ea15603cdf780e8559bc0a233c572a11c44f6df3d4f933733e9aca49e091339e428d9152f693fdc3274887c1ed38afac03b8162d70c32bcd8c4cd123276b829764c4c55610929aa9823c6b90c8ce21238edeb5e85faea737c4667331cfe8021ce1b669c6a789678861770b2a3962896746e7d7c7e501f18f50377e6323d27fadba284e56d9c46440ddd99b80e0fb7f5790c79193e6991c8db54f059fb01842936962dba14f3a73b0b4f62b1ec615d9d9c4d6d16f8b58f5f86305e517f4a1e0f6f61257baaffdd9b5ce6c01a6f85ea0dc58fa0ea13706ffa74c43727a1352e52f47229761169b983a3e23a562d7721af8002cbb03f866f0426f1e1801f62f99bb2933ba87670e11faf1e3b5903e40da79c3c87b1f4f819f9e01842de0b853f88576255d8a9ed0af895fd66348f2a07b3a5088497b9551c71de3680ae0322c1aa22931084f63b6492df2705fa031976583f01e568ece8af6c4d79ce5f5c59859e18135340d925f33139bc3a3731fb57177ebc4469508db24e289f37635f6008889323ab619f542c1f4b14be1d67b08fba2b576748c32e764558742cc1c40d583fd07b256ce20f28c3484c020155d8c8e2adb1110e8c9e3a4df7c2b33e58a9a7e91b64ea71afa9de5c7a1477e44288d3969f0dc465e5303d132924e1a10225790e101df415554b9efb7343201ce30b3b7ce9b45930a0b5ea74e296274da48b24628f4c94f004e06a5c089d88ff510c7d32d020ce5749f9dd54b6144708df323539aca15de33859670536ada3ee520a7b26f779c21fd5ae9b08c9298dc99eaebf440c4ff7e789ae30a8d221a2818c72bc07627527953e2e6e5037b9e2df569de38a95a5297d9c4db126b4c17b7054d2185549476bc3a402612353abe2e2d53945376a5cbd34cea40eb305f028f655648a4db4fefda2b4b67bf9d85739d13963ec899175688d8a2d0c33cc15831e10040f02fd3d316878e79a528b78a0c6435da6c25ce340d11c9fbc71456e2794791c94c214d9052118ed20add31cade11088cf3a407de4bbe8102d7d28132a9bec53c4881bd99f47398332c0cd517ecf456fcc1179316f452c7e6c3249c4a0165eba2ba422eae611a5465b3e8a3faf6b35cc5c1a216b649e4bdb8afd3077940ac2635f7eb166dc10edb075d5e1735021fdffd40b51fd28ac28cd742b756b4db53133ec632cb56f5942347191cd7e6302f14fcaa6645482478598055d683c69c1a592c3f6ca1666aeba3d043e40afd031d11c79084d629c932679ad7f8e465826f199954919508baa410c204cca2a60446307875713040b242b6a223352e6452fc5b9374f90ddc0684fc98add717c36c9fa0111575e43c2514e535fab39d6392017714691276deab6621e547308212a62ac848a8d78dae616383eeb0f4326fc1ef4b460d6060eea79b96318c8ea79513259e56c95160e62cec5ac56e93331a81a1639eb4b8a6a687f4c1db40cd5850b11a45db9b946fbfd284085c10500c37e26354723ce43e00d335e227acacae44a6b3539f363cd35fcc772d8726ba3f44ba304f0c2f9722b894eecc9c2da2496672c8770a2ca56c63764ca5738923b8b37d5c42a0251e6b66d6c7d9abe487c1e7231dabedab3215adff85e1fc7f6513aed6eb14bcb70c19aaf24ad82d413e364b531ea42f54cc7858d969f07116be9bb2e0300c32915da84f61a6b1298c5472abd8e95228a1c660a62563268545b54ecd57ae16fc10aeb2c9eb4855e941ec079276aeb134b1c76d03d8f5245b8379f22e82b500939b4bc17639f547948145660c96af5ce8a391dc34fcd46d3fa2b3ea23c6745f799f3c4d42e8952de67a925d8f1189692d24d0f8049f239026bda8b68ce7d62a5c0ccf09ca400f349a7631529ee4e26e7332fc4ca9f623c486b32b20edd172fccb7354c6d032b3b9ecf5a5cb960c5cfc7c12ec65bbbed92983280356d989cbb4ebecd6569020aea7e20352b3bb2fb69aee8a6a51df0d067ce3790361571e73820820437ea77f28791374a8904907a70ad84b30595491009b21887301019d8cde5688095ca3b56317d39894ddf196e1128c5629707ee3949ccd528ef7c4e7a0754c231dbac62e0577390cbd9311f60ec3cb8e96c3d4f60a1b4019771bdde4bd4a7e4b780071829878b16304288c69aebc0d34444f6ad1a07dc9f2a3083f214f54b53511246c4134be6b180219d9fda0be16a1c4d1ca6671df8f1d72fc22fa607704f52c9c810cbce163c7e8bc8843a770b96c958ae5387cb6df7f36b210fbb3459225f06b83e6c7bc8756f9403ba56ccc47c59043d04d3b750a516e60f56928e3860504956004554f6b7a0affb84a0b536980414e880133edd9fbea08010fd5c0918a1ead00e6810c51030e0d6e17c14d3ef862857e0dd2c503b7db37c234497773a5483ec6d7d9fb7beb43b7cf25b7ac86ef370a2c42ce03b60848e6f18930b6f9fe19961a6450ac39d9a55de5cb6943fe226ca981a68d77a989aa17ab483c4dd957bd2ca80f6e5f9f61c0f5a5f5967b02d7f6161d0e58a7a2176bc64f8bbb0ff17797b7a1796d40b092b78d907b9970055e4537e2a6e3713772e07a58a7a326cd600c2add81aba8dc9f1466474ee7e126fe0e021300c97162ca537083d4c88bae6313e61c46bd7ea07e456504707cd1165880b636213703c068645cf205d855307ced1c81043a691c2351e6e571d93375ecebf127be3a3cb2c2094cb8a66d47dfdf26071603385f8661f65d099ddd7c22648f6c5e861de69184ae19ca63ee7a1d68607f56aceb9e369b12e7b1ed37261d9dc1361910e633806d77a8ea7a067d6cc101f39a2503ef46247f505726e242c3d2103140f401986032a030bfdb7ce5a6b1591dbf6381ea31e88dc47b03634fb1be460c0d9d7d91d7965e67c9e70a5c833de5d52cf12f64e94ce265efcac479f97809ff9ba13cdb4d7094635a1a63fa04eba1b1b1d3b71b3f2c2b2716cb92b0aa7922872de90d4be1bcf06ea21cda6653e7f2df5f3aa0b33ebead26ab7618e26cea3040d8b83406460f79390839cf83dcb63d26280333194036c26b5716aa10542667907dbfe5d3f1197b4aa0c4e85596d297f8527defa46280de22946203a49a2b48b363850ff260061072a49e42a7aec7b10d5b4e672716cfee4ad125bfc9741eaeffb3380c34cf02faf2be702901256a5ed80e4f684b87ffd87d962c46bcf7bc11b667d728da01e4f5f17adafc0e7e61baf43e3636b695266a2433559bcf5d7698fc913c59b518aeb4b6c66e8e8c37d30ef931212733329cdbfea178dd2804411f2b6591fffd5144a787f4b3cdb8cfd083257d81bdc4edac8fe5c2844f8228b6cc45da57d72b8fb0f62f30e42bda5dd50fa2e834090f509caf7e35bc5a4d43ba829916776256218d8d43d1094fc580796356c45ef880bdd476bbe9e933150892ef8a81b897fa46de126617d52c23c9d9d0aad823cee0e4f2bbbc0758b2ab0ce0d4d343a89d4779083544521a3b80480319c6f7d9587e08064381416a74e492478bcb0830a90598b90a2e3c115ded0db6fb04a438da79ca254c54bd77558ce2612800a7db2cfe7917076b8df4cfa1cf1faf20a668dde5d128fdca12374ec36fcbb1f77f7f1c9ee2bf12a744b6b53137edcaa9b776ea94f34c1e4cbcdf2bf02092e0a691e2883f16c852b119eb012640e7cb697426b133703df66e6615fc8753cecf57e28ac8ae88a6bf800b5da25343b89b6f868393bf0c79ce2719fb825b9568569be30bc3d5806aaab6a19f2d056857d275d563211d0c11d40d06f65d7a260cfcbafea4a6bcfd422c60ec284abb50a98465537bb4a7c83322aa591b6429b3a6698913153b799a0bf09cbefc7714b60b7ac6d3e20f984bec3620f53ae44153540daa67034fc85b09aff1f29cc015478da5559651122ba8501a67ea0ec02db71dd865bb49b381374fb84a23e44644badb7f17a6c4f606f6befe6b6f89a0510a10677bbb4d7e9e165010e3646b67beb85eb102a628ba121075705e536eaa2d6fe55bf0fbcc4250cf007ea711cfe59e5b6720850484d2890d591e5d12de986e75afceb10620b96f6ac0e27c8ca34fe4ca17b1a0852b392455912f45817f39cf02a968331031c823ed8e022c0d06789c61eda6832e9c192ce590b5ddc885d74fb570828880086f5ba29124dc73c9e1f18f8cb83a1eecc8d51ffbb0bbfbf4e671ea104004c4a97b1aaa346a87e02fe9373371ee006d5a4d4012c166c0e3f40a72c77a96bdde65caa49d3f084aed6f65c532abf408ae08cf3b513491a7e09140d7355c89410f16444cd855626314a3bdd0af929772252f17672207cc8239ddc75418d3aeb0e598d4263cd3eb0c4122b866b042d4fdd6cd32b200b0ab1e8fe08f5ca4dbc302807c2cdd494b91dea769564b1aa9d4d83529d1d786f471db47f9dbf812c3843e433611dcd4b07391db4d6e4db7ecff3cfc0c1ade2f451be34cf7d00d86a482614d1b015dc99437ab043756346f361466ffe977d8c6a4bedf4a37414cf7f8814a98a06a4d11ef139081432eb85e856f033ec62addfa2f91c683f52f6bc17108662b6cf4a899fcbc4e840b858fe3127d9912e4ba84352f88c8d34b4338473dc94c206deef759957c90157d712a0e534a485a8ea755d2acd8ff22b5ec754c21487e5d96551e275b10e20338bb0fc243cdf6511a04d66dbcd9a0c59b1657c9a924c78be832b1242a65c02f041293079ab2c598aeb600211b909fbe694ceb1a91faac3f8037dc370d8af630e4637d8644b517309f9074aba1c8edbbfb857cc617e972f10c672ecac8da1ccbc7c680d4d8e38dc6f83865446736e90b4b6540e1145a7e7d4f201833df2c22317721320a43f922a629b197460b21bac26470e3012cdbc5d384c5bef5209805648a41a4c5126e3c7129dbd1d48718bb316f71012f504fe1687cbffa8358f0667e528e578a0463ab8839ba62bfd36e8216d8d9fdf301723527c20f87cfa612652e6f657fc92d57f98359e733d481e8f1cb9ad14cdf7f725920572c678782d9271c8733aa1629a9c9dea4012e5b0e8117f1bfd81c74324a28d92661c9376196bb0ee04e3883889fd99a18a4131d189d9a0ca03e73d0d6c167d53c7f58db13aca35a323c572473bd03de31c1d69aa4337b8a794cf5ea962fd49c035137dc600bdeb23f5fbb080f30e7bdb3c5de8a24954aa534d0ea27fc20270eede74fc4d270781c39119a859af32ccd19c9ef0875032448bc93808db1c4304694485f53b4dc507b52879a027adf3476269a8434272bd12220505682fbe978702073925255462b3a5cb14d90742cc29592266dcbbf28dd6c3571358bc6428fa28993e333189c60b9821cc89f813ca58b0c6a3da74fcf0387f888f1943a1e3306ee4854577b25500dd28a84ac5fd1026f76933435ece7f38bccb0ef16c744284abf84f3a24b9f03d81a3c09449f6e2e7f684ae73749e08bf4992cfc9d7e4e95f3045ee15746c3aae5ff62b10cd9fb705b9eabaad56ebf5e1d2a4f975dc27965097c833016d59eda716530ad9e29e58e2f2ba171399cc3303e5ae3907584bf5346e6b119f0b0a9fb2f5a617bdefade95f4a36e2861a4ccc047b3a3f655b4ff9f65ed139f7c1308f32a22c6f5b56c0d38054d024fb26ad4b7c6220ffd7912ccfab37b59590f1a3490c53afa5870b8463d7e6251a9448d575e4327039a2416bb65d25cfd6ee136d595e6bf28e96b60a58590a805f166d4d0c8ea09eb431a81be04dcb6a5475dea07f0593afbc7dd138a9ff99aac9778bf440d3e8473fe34a663d0c018faeb09bdd5c1d283ac464cefbebc942b49ee6f4bccf3c2e59248cd7bd3c5c0d93c9b68e34c70403a73e2d839b36ad4b424adcd7eca3a4b34b2e4aa294c847bf977559c58eee92299ace0fabd21d7439c6659d7c74ddc78e9d0710354e45f45f6fe396a247be17fb7067eeb344b000787dca4e003d133fd045d75c97e176320d3264fa91324411d3d6080cb99eb2332a26f204cee4d7ce2d8d399618481dca8d8bb577a183f1ecf971c9b94ee228dce1384ee7c76a9715861055cb09a933ab602b2920d41091eb5c14ff15809430c901aaffcd70ecc051e87fa6d62f9a97e48e4a60347f96d0bce2e8dec8ec3ecafd291b9a2dfdcb1219650d1bcd0b4685a4b6302c3351a5f030a799172a6464d3032889fbe1777d41f42a5959442551cff5242c8247a03750457c416f0662b6041352d1435855348f81566769593b1c8eca46e86ae44ffa4eb90a2af3789d3ab3c893b54778742271342e390c1c686d59a22586fb3ac42439011697dfa5127a83f1412d36e3dcc7697087d07b6fa472b9abfa79535fde6adc820c5f0e65d1cdaec158fcb0fceee5641ba6ea5623b95410ae1367bd55a265c78805db58af2fc062916dff637a9ccd0afce96c349867ae41c7a1686d68f056219aacc81a8c291930f9f4602a9e861aa0af51710e05c594434d56445f23cdee64b8c5d43eafe2e6904e97a8fe59b36c8ad1e7e8574ba29ee1478a180d0bbffe8e5db0eac4b47f9f78d91285fa3414aa7293409848037188c0750cd2a349948b7c32795d0e48b4566f7255249f48d56fb2d1785ec3e4934a3365cb35af90b02ec768685ba199072041c4b3d6fc7f099495ae99da95255adabc5fc6b3ea26ee056a445950003afdc03891bd0964ae84e6f6361b98999515378da4037c2b2dba5d5f91da039afa378fc7a382be0079792ae9fcbb5e2920e4514c155eb025bd08bd142b5bc67fc3772fa6feb355d02c50f969b281e43804804b5b01703c9fc386888d4f3bc808c61412de13a3b70e66518e56ec8de304b2901d789effa31cdc8d12331663a1a9c61f62c0584c99f5ddd782158e3df32f5509d191e06bf97defdf704688d80fb48b68b42b0e009005d8361b758ad1fbcbf655c4b2a965449a359738c91ea7f13a528a83880022c893f51020941815c8f6996c36fdf537c9ae3e11272e9334a57a911f8a563c47089a4f33c6b05bc95c002db0e040089ba31503222b6b54525837bdc6966df58548e790a38941b7b28df87bc6c7c9c66860a15913999769cc125ef58f83203833625062ec5675aafb700b489366786c14d621ca9edb5297f590ca43f71a2c93211cd7e7338dc1dd8ebb1015c5d12424470c46a0dd7a8f2862171319cb482092da1a9866e56b5f20afc1cdfa0247d783368164409d05f95807e1f7fdc143ead9269e916c125dac91d2cc0b267fcb641e4c08a28067b4508b77d106fd4849642696f820982df7344ed9910a2004ccd8704c2cbf10917ad74c242e5808f9e39122299a3ff4dc66f3ef957666564a3225cbec265086bd05351c3ecbff9c41219ab8cf3ef1ac58501442b083c09a8d43b26b8d1aa886ccb046d04e152f471b77432816139a18ff6f20edbde91351ce7c4f4be25a6109812ca62dd66eb558ad28fd6decc03263fc7ce143f60af7575d2048213b5011b78ca3e2c78c64dd6e38291b46b34ae6abc1f188057d17296bbbecd5b08c0395120211f3e9e2d588d34975f8c6cdaa3929ef58fd1f393b085bfb0deb11b433c449961c48195ff4011a493492fba7d4e54e94a3c38d1521280116ba5ff19b627d858898c403b4dcb0d1c80e39fb9acdb1b836d6a7605e93281cb1f64746e6913a8910e27abc301b4ddf69a77038cacf1f36a4ca51706aadebe9e0313585adf901482c0de6b14154724ff40308a4076d024ade8b088441d7fe1d17b15bc8bed23921b6101b05f9436b382ebea409e6be863b340cfb103608a87da97775e8cd056c688353112942790ed56ab9da46322977ba0c426af2046bf4025cfa04ad8809dd04d9321f7087b135cadbaf5126dc5c1182421496f8b50d230f5d9a103f0fa1a2d42b4407f876a92b416be125ac60f0c9c10ead93145134cd1cd8b968768bd42af51da46073c0a19dbb405cc30976c1f3874324bbd425e846303b8c8c01542d6863233a122c1144910a8b2396ad987306a4a2dc8273a40d741b60625150922d0167738bac7e4f6b6ca52ab1cd0ada5e55d5d5752d9019f707206290d49b31c3018af200419258098cd159141c34d1fd803ad74a382a4fd32c57d11a932a0c6d9561fe176513e0cdbb61cee338fb54769c20084255b3ded5093fe0783796b18b85d5d93e650f5e39c53e317bc0e881a75c542a36653e517bc0525f5370c68487183b6e3c4f7e9e9ef258a0d67e09474c70c475e761cbd19bc62cb9714c79e9cc13e1d884e4c226f133e181068456373ae0cdae6b2d141dc72b477b0d864a57f5b5d3f32b6bec7e8d262d8a694a030ea07071418da035f40d4bed45df3c18aaefb09817a51e667e81e97d077849033beb4ecf4be80b504de9baba66bca16141bc89bdeab8bd66af424b266e6fb79d09ce85775615d43a99ddef8ad2f6813a7b0f8603ab8f6e6ff9b3064fef8b1843c8915d4616921e58c93593760469b8dad6017e6b289acf31b8b2ca59570ae8bbb622a1538cf7bcd7e41bf59101d56634d39064217d21d63ec8cce3a1b746ef54fcd124607fb34893792122e5cde06d875e2a7330c20383d2af3b07dc37a3389d1ec6197ad2e0586a46d700cd656a339bdc00792a796e3a07131a01a9f47d872938a326074abd889f81f8fad0f2634c1b8c6eac8af67ff9fc9ad0c1a862748e04fad1c8454e6cee6fe83804a0f16f68a6b4737aed674b5caf706e8ac8ef421e6e7f434e799bdfe8426c359764492900d6a7f1742e3a32a0277731c82430cb7bf2c4fde836c50632ee7cffdec82c03e336a1042d3307239ced5b886bc13a23e0a7bfef22c1721d97214e8c50fceb2b4189a583610eda9ad21a0a60866a165a799184b520baace846a7e79a6ac1dc74cbc53c67f30ebfb622a9586a3714e9592da159a5debe8ef376708fd5dec1b17e83d5ebbdb41814935a69ac4c5194d13927bf7fc501a5f5fbd929251f9ec33800c5632a1236f844a75b49106adad7254e06e48a1b13ae4cc0f09463d6ff283e68cd7a01c52720e0c22c9140447295798afb48c93c242df820ff06d70928fc6959be3a16cac9854b572de7f7006af27ec864b576f3b4222d91ed2aab11e66ae912c1040e0a1cf1cdefec6eaa263bbb85ae81c724145f093520014597200a9710d9127f0b3e6601928453910e17a85f1700038486bd8c132556b894455130a96cab26441c0bc9510a2977e87ff002991331f5aa8d4700632fb2f11ddaef0203ad8c14e2cc2cd7dc0163e03582a78a78074d103cc4790f0325056dc2f044b37a80ea8397ebb9581c5d22123415506f9a081e9424dd3413000460cb144a8f093f619971faf6d98a3bded5c8150e7413166232ed59b2a4f099696c62f47a84c39930d26ba981b41aa55d0469519d6a4acb8269aa5471e45c94652ef611a88460bb31c7bb2596fcf65929e2ca36297de3ff4e6027e4d503135649d8fdd91669d324ed39a1061a3439a53a5a60a326dfeb45eec36f832018b5b444f0bf1524b45cdbcf6133bd96a4dafa1c9efca189f8e1260cb2246d8f02c4842406161ad13ed4a55a87b294eb4789fd175437eed5b028727ffe7439b1c3b4962407c30ae26991404edc855c4a01c5b54010584e81680ce4808f1ba314b00ccfba5f19c02ca4a4e14357bfc41f98a3377238f98de8844d1c3ca022591707774f4352b2a1c5d3e856ac9f5660bcb587e8c3580d6c76fe9c396e06ac5e8040ccaa46037549f8d900d9c29c40f96a1863c86aeb7c375f5d3c484fb534902702304fef264025ab229fe65e509871800b224b20ccea288fe7a38787a3b7442f300101b79ce690583384cadcb2546d468d34318fb3280a853cb6d60bd4f33d2143dfd03c062772ca6c9ba4317a3b61dc658da3e35c91a2fc6e2b1552579c52359a109e27667e7294cffddd04a0937808253b7f84dd977f9a1e00b88a219ea7dc50d329fdf0d9d0ca0c23882d1aad09353bb1ff4a53f3250949c67d1da8d420556b4d399de51a0c1dc77b64dfd5c669e6d84efc158fec2313fe629cacd1733c4a5f8c71a77218f2a56950376c64d7302c4b56c31fd3d44959d6afad7bdd39dbdb4d514855c480f23d106dd50844209b0a546723a4c4c82b2f1d71dc3460338f8d59c139c842d5b22de4709c1317182084200a338990fd59f7ce54cd90991d2128454a0823be45aa93e14446f90d808f06ce74c76f3ed2ed03b0dbf5cb80fce8936eee86dd636dba53a6c66c51b567c1262da575c4e3f6bae55ed01830892898fa9578f4596ef081fc05ad20c6c58fdd0dcf9f316b42eff73de75ae1737f10f5f9aa6898b7c8838197a4cffce9ddb44465c92bb6e77a1f79a172ded3a893f17beec8431da52cf0ecc0f78ae3d6ecd3da29eedf8769669d3e9bc7e6e0e59a160110e4e82af2894800721638c65f60fbe3e80b6d89fc99b52cbfb50292f3c7f513bb221f42234d64197a56260bad1f06df318236cea18bb5700149cb01473e335d7cd6ec47d4ae8c902077106287d67db85809837bb821064c9ae0ff9552405a68929e054cb5af4d845b6d342184b55aa25e7efd55e379ceaa9f8672817762842a1958162306ff629d0bd6d6c7e991d61c00343e2b400244c5f483a163a9a76ef38b8e8750e0b07d4be5716ec971e0eb409db861747134338c8989bd4325f3d7b5c999cf7ff595f841959225f04d5d170522941e4242a972e12f5abc280ccb6738669007b59871ce7597f9596b003b41c233b50f35c950793c3a625898fdada168fd0d18c81db19f51313161545845d8db20b339eb7acc5cfe4119b746d671b1e80c3fcb29a0c86b22088fa77ac035a07eec5bbbd364c0d7c4258c3591cc102844fa863353590206604838b78558ecb075a4cb6738bd2e4c203ef9a6990b8077c627f472d0bee8c2140ef111468d8afa022d9d76117ca87b7f562bd0892f16b574a924ddbee141166977844943c09b3e65004a5bf0c34ccc6c60b70d774f6758b860de80cd08d5dae3d0951c5bda3eb9f3ead78e19b26e2b16cd280641c4a320c051ce540433997b337f5f2110be182a954eee183ef8a93ac4d9f250531e5a921c79e78bbde82d4995da489170a73f9e4db0df0c203655f0e52f41305e35365908131867fabcbe1a54d0198c1d001d11af417a6e0a7e75a7fceb8645563e33fe0ea2aaa4c4d84c7b03c7f05ec37e2bb1e011bca3f17df3076dc4ad2d2d242c42ca857cdaed821a0a95438cb5018b43e305a8d188b890adb3504180c7536a90daa81ec34130865db10c82f9501b67a8f50a0c02fa63b8a8ada4967fcd9d7096f7dce32d854e0e25339b217382d835c555f6d0d840f72d0b1a8f8078f55d7afa537ebccdc6a75981a74f60f7f11b600408a7e417ed66b889f940fdd779c7bd194af212853687378f56a0b70fc89b47aebc32dfaff70e392f74382fd14a06f4e43a74479bd371bbf86a09ecbb77bd6acd63e2673d392f61330dedc85c4531316016c08a1c3ebe72060b7a0df1615da352da4b849123a5f0390e3536b2b020899d99ad0c2ef0d9f963e0d203764cdd806f92e8485ad4537bac7756ed400946897d756a569b00687daf7f519e73b75161f0cddcf79cd4ab672e45a6d8e97637a3b2ed1e520a983782752ec266d22ab3b75479ef5a9ef74f5c2ffefa4523dea50a3ff507dadbdf1bcede271233116c70a9493fb8943b903b84b2b340b63109b327c12914cf9f200eb131b0e0df5f7982482c37bf784881c7d8c294221c8b989cf0dfbd0367f07202207ce08d0590e9507db901a2def4478df167fc7801bebeb7633ccbbe3aea84377b533d6d00c90cf9ffa7e20d8809bcdad167cf47ad4ea2790177825eeea966c020f83dccf087dcc27cd05c1bfe448419ca557c94d7513dd0228139b7ea58561c1ba303064f3b5b90580feab4ac661677cb373f9d52d8044c40e120b5b4459c9f795aac1ed50be1c1d18a72703a42ab317bf108bd2c701a955618b240e2fc14c22221085061c28cbcc83c491780115367c83057491b516cb15c1fefb132bdf617eb942fea8cc97526fc2ba21cd3266d82412876b9a0f83578e7faa3e631c16f8749329eaa03d7cd9718b44d2c8429539cfa8eed9ef2d634692c048645e5f2c641539c83563e8514f758bfd2850d7bfe15024421875917ae698cdc1108304ecd83539766e0b22e820edd45121b336072e67acebcb2e1a9beadb84f06248e4f72b0a00288ba59f67ccca91cd94b56cc6c1e8ea77b385bf2c7ce0aaf026c12fd2d7428a5e482a0fdb2362ec17be85fe971759ffd054919a45cdffa348ab0e5e812030159cc03b19d78b2d57be5c076a2d09f54a91f91a49ba38deefc794483c836ea63ed4252b1312f2617c9948a867d6d7c9f95ab61fd6af15f95d66c265bf9a98fbd75c3e73aa30e0af0f8b1e035b13a9d0bb613e8de0556ae00be92606bc95a90ab20462a7cd6b5b9b5fb252926704257f87f4e3887eccb60620efbe4d17cb84c9424c342f989162ecf423588cf36aad32cc19b0b0eb1b1ace3a87092bd070b0464216d203aab6ddef2b2758374d2f10094b4152c7ba5da4995e89bd4765a7adbaa87d5762846d79d52e6621c10e203ba175e7edf5ede13e761c2cfaa5cc17e5cb64618f69853c091ef9fbbabd8b57c9e2d72a14e23d3ebbb67010d8f472c9805423df1e68dcd526e21891d5b0f235e7a59aab86e75f882fcfd28fe8e2aebdd6d2b19d8b9b19a2807349686eb1606dea25cf97b2e587d203232137924fca1db45dd2be7de55b6a760dbb01e5b2661b3381994eb61a24ccbda60bd322646a7ac4114ab145a1c3473ea36a6628a5fed87a616fc3ea760ca41579e138b62731e66143167f791c88a67820b56292353c9f9f318db9a142be455127972a298055e93315f9e548c6518e1cae6fa1406b6ac8f136f4b0a217d2de576672ea170824b1dcea9dd37431707a0bf6a12d411f163bb30d90b5d972394d7b6c32e87b7b5b7b88f6c88e265c2324565f92fcb17008f6c5f9e99323271165a0aa6a81494490d7b935981dc43c5296da0ad648d16551654ee2b7a98bbe0f8d0a5841d2aaad430aa8cda85a2ddab1be7d2049f241c3e5baf1ec8d341b36f8eb49c1ee56083c6d28f71cd6f4653cbd98507081e795a066e226c0fb4d2c6e1fd7fb7e177bb0d390319b4e0948c720ba8b1ae58c6280247b777a7324eb1d57c9fe7330ae227f9e4a49350e44726936775937367fb46b624b6f69ce3a06bf0e7f9480d29061d72c495e0d7b4c9d66289d944857fc37925368e3c34d03429e1e5273bc27918535a15e7336c140ac8124e9c2e9b561880179812cd08e33ce09ea7ac52197b34c9da3aad9435be0d6aa53357fa1303870de46ddb4358694ca249e4632b25d56f4b458f9b0dcf5c91764bf8a94524c589c3756bc0b0af4f2badd46e6ee0ac4e6156723f6f6746312a50495dfe4d5a1f1fc85412b61363b5b1bf5f6d29e1e2c6946868852701d5bb057df911b71f550481dc191d8901a445c12b698ade5583ae67a0f226d1247d3fa6dce4a78a0cfe98d9b4b0581b47b88f36c34abb8e7737964df85e012e77640ca78265a13f4d3428329c1e53f6e152cf4715f8b129145142156d8dfff644233ff2d175d79f87bd37e1948fae2f574b1d274b0ec13bde05ef8db54f1982cc795a40119ee01099662614e7201635d490e7243caae301d912c0b703d8dbba7a78d299d1fa70293202bf7cd10a7f8bbb3bd231bc8a97b0b0060817e13e747687db9876febade1be570d631772395cb676fab1fce95322ec350d9672423da22ea02b930f3bfa90bda31dfd614047feed67c1e4cf11c4ca91fc2f6b74f5383521e5c1cec9e3d81a8e5d948b5400c87f9a0fac49508eff3e1f95911d5dd13f3f1df388466a3af4b1c397446e11f2630b55b061d9b76f2ff7b71885a8ad424ad8f4da9f5b901f5707b438c2246983018866826cf7eade1b921ec3251f5a6283d37699964998d56472bd1a08fe463da4a91ed118af90bf3a7ff0d49fc554f5aa79e38836f6b19ba777cf37f8241aa725dee6d7fc0f1dbd3e059c6b69b75dc280217426f1f3a251dda3fe726e24a0bd10bda449bd55df63cb9bc0ce77f0a32aef85c78d69978e9de58392a631dd21c0dea658065d1a5c2597763c846ac512e0cd160e9448d1d7cda8a5198cd8a825434d4a0170cc266aaef5a78c7d030ae80f136dc41692473b059d04b1e972943d86086ea019511d615e21272599c051e54e458b5873eb3450437a251dd7fcaa5f6b549f1cd2dd1c82dcb680be32a1af7f38f20067e7a249edaf75ff4699cf5d25b52ccf8c35945cedb620f0b9236b267e804141012da3b543abe6bcde1f1e363621ae94da82f61cda86eeb1b2c0e4523035499201ed5ec1933f73104ebaf827eb8bd1fbaa09f829a7206e8369619a47be9ef37f6563e31271c9cb44bd580747ec37cb50f32629a6233c07239cd8ca0b091cb24cce0bebaba8362701d7570b8d13a960d6ba7316ccb9d12737436617e8cac9921a7e15604cb692da81213980b4742882c2cf0d38cfe221b8deae1d01bb26e4ec56486e02cda2b172a7944cc79857a8744533ecb0e5d8d59a67be46712c48ba5d2fa34fac8fc8b3b12f3bcf5a06844ae2c44462761d752a8de2cb38b0018e868581ebacd22690392810704661b5b3536c8281fcb7e1ca7f216892a1b09abe4260a96cff14138920f514a3e86139bcd09875be55d9b45e8a674980170c2731f53f221f7937c9474a400d35900bc75a41ff4d50beef98cd403e4e7b30a89041d6a107bb376dccbb081368e5d5e64828a2e302ba0b5123c048249c60751ae5c747716ec4bbaecfc1c687ee3c34bae01e5ca8c22e1d791f12a72be28d16c4e6efb85c162741b27f2c9d5c7cf704734892da45aa0cf00062c390c5275fb52c7a2f900c1029afdcedd88cdde606925011a85c42d6f3c70af95c399ca9a7322b5cc23e58543fec4ee52a87532d33106f8a4d0167e9b7db2f16e016a0c86ba70fe6c03a712897083ead0d3b31175c331db5963c30408370c08b11e7f457ea44954a54a6f1c15ed771eb2a0fb1335a42967fd05809a1f6c3c3376a6fc80657a9842eda066c91f9fd9043b889f822f83c11fb28e83fcaf2864e5785d0ddbbf60da73b86539feaada1b551eccde7df9deb238a963666179416234587ffa89eb4e19b2a992ae6d68a07e18a672a958df1c69c1f872a9e2c9b2cea80b223aa626b3b23d81ce4a598d2d7c374cc978fff163eac42c84a6c0cf88ca6c279579ded7d6f621ab72e180f5b0279c7b72dbadf5e04ac30d0764834e83d5f15b1e50a9046a94c6fb653af7ef215a08428809b8a58032e78dad5ab058cafe3124c000144920d85333c62dac934dd83c7060d7dacd811dc81ad13275a020e202f8f9b8632577249dc1a8a2dc25ffb727fdcfdb7f9af9ac6ec8a6f096260f7af709b689a22dd2f187ebb73df5e439d2f9361a14b98c48f9eca0c5259abd3722dbb3bbf98b83ca4f440b6552b1837d7aef7c607aee0a78e18a0ff430591b78f62cd99fa314bf7396733b2e7d946b5ebc34d0d86158bc6175d5cdc99560970f34e1aeff5650cf47e4237cca0b53a981862d0e8931b0ef3d8500496e04dbebbbf15ccae0da299dc0fddc597027e4eaafef71bee2d6d74829fe1dbf3d2d7836115a80cc5aace84838ab19e5714dfb010b8c79b0008c6f8d350d3c8687dcb2e48ec269d8ccfaa9d773e7207e1dd28a3857144a4d52057cfaac8bfd41a34321509e9b52c16358b068917d5832c6654647c4e2d305072df04c35b2178bd08b8c29e91a417128ae5ebb95df1a24a06d1f1b1eab3b5b1ddf1818d613909ce3234242c2aa8cc5e163009bd4403e03732846ceadcc36fa935d62209bad635a69c4e13a71f4bed4f81a9d514aecc664cbfc638763add6f8b99ec84a280cf5e9683e07b20b11f1cb0fede3eb5ea69af42e40ec973ab65fe40f5bf283aeb72556df84c4808cb28231132532d2dca7f78a99c857e7c67ef2b1357b28b994988d90a8640d8ed9083d315e71d5162c7ce8d08d4660ba990109ab991ac399b951ce4c46b3fe7873a39021e7e12b04e653a305ba793a54003c46769dee3197f2ad465a298cbc42f3d7a1f480efe98d0253cd95342c4cd22049cbf0b0c267a104c8b33f961e2af95026fbda6d204736b18b49700f8e87a21d096acb73dc1a7ff29f49032c5c2e7a45594740fd4800a368f7e08758f2450a803a717f5ec012549c04bac9163b8a99ab94cd5941671781c0f8fcfafde5279e14be8e5360e18d26e85740bd89085e1df9bc3189fdd34c6e9538f47d061a2c1fdf2529f4b2494a5f0f6de1e40b3156dff9b59f4299844a507cbb36f7bfda9c35454f47b3690986958f46c80710edd2d116c5e0e4faf7c5a68682439bb925a164969048d9e86f2474aba183af13f6dbee1e839e9c36e0a6aa342c86722b6e171280e1ed4e58531ac8129cc0beaa041af085c63c777a5a66e21c2b58b18379948c3f5e5fb3051517b889348deadb315425536fe5dde70fecbfe37a5e3660efe3c87e8ece9576674bb93db3d0b47f3a771cbd8e7fff13887b7bac15735d7c6d9c6ac15dd22a400f3deccc24949ae9219c9ca1e8fc88fd798cfe5ecc8d259a84fd442be39514c7d0b7fd08ef112fb70df9f231362776ed9a766409b8b809b043c681159bcfb72331de75cdd6bebd4c453fd704bf7dd295499067191511415a4536897bb943a6f5f5397ed9a8ab85ed1cff8782a3e889769e5306737b81249517ee2a105479b54f45be9d580f83d85c8039d9b34ad6312d86c6bc48c30a3dc1c3297d855d49ced13e2f353f9e41f252b6a83e72b6afd2a5e7cf54068ee99f2191935166c7d7135db821b3fb4b5b598bb0413b1a30d8bb731e19f57b969083ee6bf340b5547dc0fc121de1d079ac11336e0cc865d22986d3b95826fa6de54a45e9d09f63f2154a6da26dc785d33b36e6004414424fd95dca6682601fc1d61417713aa6a2e0ad11c03e6cdebe24ef83ac1191f5c77f43135db0e3f7fe515b185873d6f6ceebaf125fef4500e4754569303240d40e6d5c7308cb1d27efe375c5a6d613abbd2b196cb04becd63fd8e1612bdb291848e6089a5258991254c0f4c6f4737f27c3e6fe218f59b7e3fdb5423066cd2eed6fa539b4d0018ae4ad65ef9034d7b1592556e7d5aa8051bbfb112236bc6869385e19ced1e2fc2c4db4625d439cca0a309146071687ec3f7cfc94e3aa282c84f080aaab2e4462f841537eaa96378bb74e2c2c7e24f38a3f720aa5f37b4b34bc5d1b2e38ae1fc869fc8b558a35cb6e509670a24a4fd9d024ff6b2d2ce730e0f0359495fcd98a2199ca42b35613db27865dafbcc75c719767c48708733e65b53d052ea0922b1546b33d76cd9b1b0b11bb1b79aed07a20e8c4a99f0a37132c6b86903f556db9130b354698e3303e50c73aabeaa670a6aa297c1ac7e9c66f708fc5bdbf397474a34274f448d7935d8b040285192b6600cd66042fd41400815fa9e2f838c315c1a02fb820c1dfb36d5fcbedca77aad73ce9420e7e52a757edef19e21909bcbac302c7b1075db767ff16e8c933ab79b7ba4b8938f1ee2e759cbd383aeb18bdc883d21b8d03d0a312cb2c307d754889022acca3169054122d191dec1546eeb6b12b8bc940307c36fdb9105d512b5d631ac344dafd65096e51dab35d1c33fb1c1bdc6f535f8467dc5b54b888c6e58e2894fea19fc684dcc35e22e1126a7520d75d736a8ce3e91655dc1e8f46a99cd05c5411d72b6e1ad6b34e5bcedb860ed62310e96a431fbfcebfa14a444bb134a73251c3c1a33f75c11f66d97c813fadfcf0af55f00efd498ab1bb1ca18dda349098c881046e7989b162888d63841172a5bcf65b42af81887b60e9aee9f27b6eb1a1957e6b1fcc8f807642e568621dbbabae3abaa7d03ec80b915f155d01e6aa08f2f6d3e24bbb4c881a49dbce2de1d45f7f999c8336304838de2d3a57db7f23d8fb29026021268cd3200bd7d8937fdd2052eddeb68d8510bf3562438ea0eb21f5eb5611f4f8e6e0871716e786e552e4b480c5026bcc85b7103d65c7059dd30239ea05a4cc337b658020b061174d5c00e5a19ac7c3bc42c2b9310dc491fd37d50451a67aad59a6f12ea4b65a5077e7ea387589955108d7d838457d82c90bbdf0d2ff79627ff9b604de9d2cb55e10329daae942a4c5eec8c53525c53367b1f3e971b63f4a05e36faa7065ac35eb21ae0dd8dac51b045d4fa68babfece59979cb36c54cef4e4363d86377d0d667bf30263d4d70c9f95d620d1a9b1c584bc3f08a940dbd6db17528dcd1ffe1e68d28b54be1347ce0c91e3abb56dda5ba9b32ed448cfde6368f41910160b19b908f3b5609cd833827c990579298fdbc527868f01aa563851f094847dca8644eeb300d19dd419da702f8bd79b2b77a2d210d5f849bf6f771533a9e9a5593baeae695252629a61fb341478dd8151571873031793548503f53791692d5318d39d93abd6cc5e77f5683bea336673382b647829101cc83b2c49405d10a8a50a5b4ac733cdfd8f55d4a2cc36d2144ac51c95a6878a041fe2c79302e7d69b11112d4214a3cc2d6d54ad40b9b08953842f1ae0352bd98938bb615ce3b9197a8b39e25fc62dfc7ef784695315aceb4724bcf8d3c7a4c0105fdcbd8d8508adeec78aca5d536d34840f2d0d4d33019e7fcb75df9becc703243141d5cf935f9d42f6b36e3f67655845ab79add0f050c0ce40e7e28179673bf54c52950469aafb65303d0e27bae68c18b741ba8f7c1fe8f9633066d49c47b523c6f09d7e441895fe50a71dcfac15e0fcb13f5082d2fc94a5df8965b5e11ddc4d11d36f69cae7e93694e214a0996a0705ea35139b3f6b9177343ab967c6d848a43367be183948083883f4765312b5094103b66e8c8d35cadfe3c776154649a9385a8442c86a391b23bba19ebbbf1d0201471337522399b781b5376b9c3ded4db9a00f271904655ac4ae42474a2cc0b1d0f3528f72c57e5e62f800a2c6c8d19413e51c42f6081bcca51ef3d87f16e16db9597beff6801a76c3adf2793a939d296f302a351902a3a9dffbd185ddc24f9eba8d57dc001be14c69b5749c6f6c6a7eb6163b1e1571c6f107abb3b9a1be3f3fc0f888e69d07bf07c24be2e01913f7df895511c74ed0197681ae1f86559ecb64a09f869c50412a9d8ea3759f356aad509da3617f739cb1b95da1e19b5140e8c0ceca139274d2ad7d41247b275ead5039d27667547520f7755f9e2c5c2c6836e5f4027b0160801bfd3240e73a65d1a97f3bb48e431c241028e49eb846939baec30c42c717f4cae9f89a62d2fc51ad6dae1cccd268f606eca0c96dcdaae574fd31152524bc787c244c69b31543bd1c488b29f7101f8e425eef3c6abd2bc0c55b308b305b30d1e7387462087522117596cf1dfd14a079430e312f137220959a27864c8f7b4a2a1fdecfdf7bce75508ee81679731f32d1f7f3198e3f535bfdfa09170ff6cc0a95719916083a0e8ad9d3e47120c9e98ffc7e9398dff0d74fcb3361b51b4f24d293c722cb7a5ad8954b114192833d3b1953ebc1e8d12fbab74116e56d0e07519ad354ab86056234cef3704aa91c1262b4d3db4fcc12c7a554a10051f52800a0dc718c519effe3fd329057226eee2121d848fe075fc439955a509a5c1ff8506c68d54e6bf338995b6750f9433dbebc89bbc3be0b8c650f2352925dd5b22dfb43834f15aed82f3f70c32a948cfb11b4867088fe0569c2f5ba14c012f23df7076eba3b55e2cc70527d42ab4e57191f8a25ceb41b9d4d01dc64a8efc67fada379ff5d48c33a0e1c3521387fb0952918d8427b695e8862f40c222f20d30a13c7c6cc8a679fc2cb8e469018c977c31168ad502dd28428530d1b630e95ca75d90543b64da9470b0a08ba9b1d45b956360cd7a61e4d9fd5f339de6c508b4831b55a222159f573d55de262c44e3efea22dccd0063826ae5882ffa001f78930142330c4d652c067431fb9a574fd40fc436b4b04d3e9cce778c02569f12dc180e092e8629fc7c38a70867360dc6da0d5e37c9c14733816595ec3e418887e9b9119fe8100374c6823bf5d06d5d1d1469354971be8640850805827dfa6f0475dc530737d8e552701cb47a35498dc2e01285f910aa51583e810d622bd16b450a78089c1dd5731e1cc5bb4fbfb2911b3c8aea094426c16985f27b085e89ed84baf28f85eb3cec2d31c65116978a44a575087b72150ddc6460babe6a332962faeb90c4002887d174dd01bd4194e04488afcfe402d54b05fd70f9d19daddfa35e9427eac7f4ea0c4cd24bbb1fa04e7543df268f32cf221b57b1fe9156c034c4aab5576d7e91820be44060874136b4bcbcc6b4f27681575d3ac2c0f396b3fc9e8913c225bf35b8cbbd3e4825412f53c6b4ce56305961ae0abf8ee5412eae33462bc489b6c28a3821e2f89afcdbc34fac7fd573699e46f2b381daedc84b34f91718ecb7de5268734f547f15d21089c88b5bb1bb1b5df6ff1ba655212acacb9a1d7afc9927abd09fb7493fe49bd010d73e0c6f5597c7babcc094c915c4a1414583e6239f0b75537d975540e73f3e8bc0d1b28c073072a1b0596bb36a69696c514dbe9bed38ca8b624962632461e4a784c64dc0f258d2c383d0fdbca7a08c39224e0dfa6e13d99d70cb5290cec2d725181c86ac2e4dc3fcb2a5e630ac60ac4085d76b162abf6c90a3969274ed348ff8c2493ab00b7251da422eacf82247cb2f0b0f4f31bcd82ce43c6a8160ceab52db4d5aaede3f71f878cd109e6795a01b7ecb23365511cf890ce9a45609fe555ee41680d902141d3cb45b46400cb08e53b688df527b14ec84264d0ca6ed9b3615f55e4f4384d0c6d4489cd75ead20a2db945632752c965d06a402f9ce0b0adae1caf70a77ca665e2b3642cbf93557356ba98b4a46dbea590f6fbcdfe359717f1c465a2b7aefa88894f329c22f04e1e3199189a71955e727edb4638f849d133ea0e747b1f3043400d4a2b8d881794cd24cd299bce6cce65ee63603c56d076a4a427b7b86fc48be1f436ac3cb21d969014c803f0ab5dcf72a72e8293db0c4f0d8b4751349e144df9aaaefdfd875a98cbbf9858aab07326e3e44d91c51813cdb84861117bde4e5dc7a84f9bca8e960801c35d29e3b592543f5bf197982646e510b6d53c697bd3518e462d7788b04d66626952dfc99e652064cf68eb6993eea16ea02c30361a1e69c413590f44cae96e8d6a9e1931a45379a742c246bdb78a11497d6622eb2e0aceb201781a1a22b6c1425319aaaa10a9dad236d99eb1019b884ff186d6759e18948b8fdd46d6cf83f5efbc390a14e97f8781fffb40811dfd57bc684fece0db13aa6a1c214493f19cb0707d9cf72d9602293ca31bbe5b8d3834094a8d0e92feb4aeafad66853ae8c3b6dd410abc5c1a5e94137b325200fcb0545d6121a790afc49a8c8cec757f68f5991b0c00fa1086d54040d1452a819a5c1aef4f3738a6db25505a7b703b11659fd0897b62c36f951a4e0abcf1aa3e10e0c9e0e44fea6c1a95cb7c5a36d9933f9445fd45752fe1f1f680af3e92172c55fc159d0f911f9ed2116a323ffdd64faa074e649017f7cedf28515ce3d46cc6d01611617fae87d82df6df30546c589e9817b9694e4db98c63b0b9ec204eed41186b62e4dc60e69dd9fb5e3db4264293b1111aa1be2bf9bd982f2635445f53c1688e52143233a10d374e01895d072ab317b6e878de15a65f991f93d367e634a8019b4166927c9a24b98ac0725278a7dc9afc616e381782d503be9e49422b45377d34ac9bfc0089b037bdfbb0fc7eddc00dcfcaa597d181e39b7ad17586fa8cdea62d8dd906f56333cc6a831b9d03cc5b90c37339b6227489ea9900dd5e1d5908c28020694d9a3cf024cbee07ac85add847c1aaf2b0b62b303e2d512b7c08fe72e17c603a9b7c581a7b3fda3c522c3e30f080921431e3a4596ffcc941612685df714c506e0b216eac8cc7d9691ade7cde74edc2fe418da8b3fde3224eb882444a4392807d44d161e5d6c51dd3b771dd6a4bb30b91a20eb64766b8540336473dd097dfc3490e8de885f345995c8142fcfc62747bea4983f02bb69e1d567a7c0784e456d326a41e697ca8a8f342c28203df70ea7534e6df76201d93acc2f9951ea250261215ac58348ef6f32e1e7fb5e7e69d9dc8107d9a253b4ce4efbd5c6a8075b23434b293fab8042e9ab62161373a9679132b775394c8c6013489ad462c86a24431ed68abbda932058ddd126a4b088e3b4575752404072d48cef7d4a83e6ba7034ef779bd527ff4906b6a62e15d4869f51bd30047a7b60c9e29522d6b02cbe992283552200559a76552a5cf4d684686376d2b69572d58ef12c2bb560c54a9e17295c8727e5ed5b601eebb2ed7bc9d4f52001b12d5ab85123dd70db77b346b12eba8aa653bdcc49ed987dcd9b6fa9e8073c71a311a06c31442e39f7d6954f05400284403af0c880a71f3a096289f9c97f8756a485baca2066f230e0abc16cc07ca8119caf43d44ed5ccdea9af525b3fa5e9c363121d15e6e898215d6a9dae0764599d66bc88bc037f291c879f31b05e9be4467522ee6d36fb1ce9603202d0f6cbb30532a962f3881e604af270b9d639d622457985216e1657d25bcdcc0df17bd023a5729c4f151162514e1874e3d970be14dd08704172488098370c27a90f74e15b0a5a1612d29feeef192c412454da4040ddcd0722963c254b874dfb158253845fbf7b6015b0833ca2cd024c9200096cc9df8a4a41ca0881011b1392401da68cec795093af2e2e7f83916089733fd4ec303dd9457e17a2e44eca9615f62ccfa3870ce672f2f34a0e92bf60072799442adf708c17c163c0d97b483fce83f12893abad2b3c66c1b1ed0e2484170799a561b5a6c9d6c3fcced52b61e14cab90698d4dc9093b6e09aeb491e278eee4c6f257fe4fbdf77f79a672cd5515c78e49e9dc3e81b0d51db9f4d970bceaa75e531383c16420759d972e8f7a7362410f0a2aeb0014fa0fa76b4546b42c8e15cd4f7c0b5228240e4f0c6ef6007debb09c1b4c8e63e21798d5554c21044bcc2a6e7a2136a6757bd456ea7217bd0e88aa3226d65611c205431747d132602d7f7409cd74c167471f8a7041f60b4d41ee292d551377078a5fb9361961513278cacef52356f1064a44ae356380b8bcb6739254beb5a3a6cc5feae7c4f99dbe81073fa38fd3905bc159d13b4e896bd023bba3f076e276444d87360b3811eeede71b96cee3682a27d35282fd6f44989e73f4138c4a29eaacb47cc28f2c5f2f2933218476c497737ed4501ce3e624598b6ef0efe7de6a37d25a051264094fb366622ad6f1be5ad5c3dd49655f0977c802a55e6e570622135047dd0ac1984ad7c6b0ef865ab2e64d15ba658edf0a89595c2a96470eb134283976accf90a919931e1247f39f15296f667b09700e990ca37ce8a85b9fa32cbecb6238a493a416201f6b24beb3e45371c973744430ae02d85237d510c2a5ba7106eb4106cabf774d04ad3a08c66e84675739dad7b11268a21bf2f7e51baf213f4dbfde2ce71fed0c043d37ab246a288d96ef4131124c9f6aa4eafba1d2355ed51a15711e2b827329ab1415cf7c61cc6d2ff614a2c9d05500b310efc37d8bc05f853d6da21d0eac7e9a91ca31841402d249db15a370a44f75ed3991ca3c7a51a9b84e5d765d316402c11ddb9df587908e08054961f9052c1aa5327002f1e2f8bbc3bb594fff81d8236558cf5548a40c4b1b03721e3275c561aa58b28f1fec346091afc844435828685e71cf35814d50886a0012f3fd0857e3303d15f11b2a0a2b6df2d71a9fac43b0084e11063cb411400f4fb08cf6e9021a498f018f66bab530b20e58f0fcea73f64c6d71906adf320cff8f1556eb4c9bd4570d362d1b7db57e8115a8bfde565a4a2430ff5bee598cd0e01ffea8b3fbeba0db07286a4fa5d61aea62608f6ca5376ca18bca8f3a60585fd47d8cb7ae18b2969adea0748bed7ec7442d0f88f5cae067d899c0b9023a76c6388e22cc050eb0b55801c1634a971b4ddbc2d3ad671a57928a13f321d9e335e56ad02fa724fcae024189cca7587d498df9fb9c978a2eeee7ce73c892459f0452ac026b20f1f08dd4d3daa48b8a508a5ca9aeaa8f67bda8fd57c837877d5924a4caff0f185688c4336beeb1034b700f52ea05eca02e38a3fe60e813522e082ef724cab829511e0fbaca9a8eade836e33d3356e41bf2e1f156984b189f56a464fd8cea525b448225407c1a41c845ff5e3fc49c0fe37ee766f0c0caa2efdeae03bba2c0d1a28b28a1d14abef0274162e109a54fd0279f86e9650d038bd6e5648611f1dbc141d110eea7ae35468598dff70a8a31da0516c45f40b5dd835c419fb1844fc593d343d78a2a68d05794fa08d5630fae41036431b8bb5393e139eba0eba01ea0876ed7f6a93ded9cc30733f55d9e67cedc7e741a20f5ebac0ad89fa43b8cc78aa42c886032cef1c11293cf21d23ea0873c0ef7e5be5179918b97d783cce1c1bb965c4dc30b6244e16bbc3d56deac22f5cd50625a95d3f6e4272609e3c0d85dcf23d66bbc3197e73a096ea919a88b1f0c62eb4eafc28162623cb1e96e523f6f08a1fee78a64f6949d1b4cde3361ea87455776582f7df350a30768c5550bd648d6f4234a66cfcf3696cd337357153e2a1fa3f57a6fad70b369b6766b46d9326ab4ddc3183f9e603c9ac3409017acb59636ad0b1e7a9c65743aceed41ddc86b0f08caf5e4e980dd5f326eabc28e1ce681f62307a2f4b7e2c031765f8931c449e8178688fccfbddebf6456f475de2791e12f8e62c434cdafb0a84cf00b5490a36b4548e59bd7a9a40c4417cad2567e8ab2725dd0bb6e1f31072dbe354b78e4695ab14c41824da053256cf8a8c08e118f0d335bef1d324ab554dc01e4b00962f272e9c092fe1134f4153f7f41f4362306088e5e936642260e35bb9a8a7de6f7833a0ccc26ee9ee69d5c5c48909f1bc01028fe64a0fa55bafe8b02302f0f8c2182c254a9fd584ced26ae066c3c56fa68281489fe8cf0dfcf08cf6a93fa9a83d7186145fb5034485b99724f8a3603b54fca0ba520d87a2151b20f75931dffb2dd128b8d79fa20a8da46ea6b97e8d4c4f2ec12bb07b6ba8d781d3712af3ca4d0b1a9f37c57ccb2bbc4c53fc3324feba1c7745f59ea2c010932994243bd40268841bc44eec3e40bbf5ab275a02b1abe007bd399e0b8ce14b12a28ba0c77864c89e05cb5a78ac626ba25e9bb487c5956c8eb16f42b8423536878352dac51a1c92b25b5f583f3bbd52c50a235958cf45b0497cada21a28ca88424c69bf6a8f5e270e27599802c69fdbc0af25e8f70b6e5d66360f95499904e5516c39e7e3b1486bd57a55ba24e002028c164d3614aecb67d141a5bca59172acfa2819f860aded79af98e2107d4da7fea951f16803630644afff40b27e8911a23916f958d579f7780775556001a64a80c10b3547119c29823c8e6f6221ea62f2cb7e7a16bae65baf063169db7b4451bb545da46b5f77f1ac5df1ff72ef38898164d53b23bebcdcdb71d7d45e3fa3266cca0027f87c8e8eb6bfcd5213c01407ee2810ca8a1ac73a63fc5e345be45174753380949448e786161e1de2863e4c76f32fecbf5443b07c1e31c7c579d4fc94632797586f8f363baa792849914a98484f91255aec102e65ff4a92d5602ffef95c437179a5d2c483b724c403d0a1b84ca08f7fd3ec0a78abdbb7b05e1bf110308fdff06e141927fcbc11f340c27e9bc82fb043e1db113239202307473cf339cb291014307da46022786cfbe62bce9f8877ebfb67134312a92345d24a88082d63e0cdd4b7870203e874255b458fe5f3804f3ed0ec25670af750b50f60fb8acff97d707741ccf770928634dbf63d6dfc3925ff9efe8f32ed70ff71f2dc5907aba4cf35a661875ae222693057ddeb481c668c00656b714d9e0391bc1c8c9983f2c308b2f4e69c1620a6dc6c3cae2e3e1873ea13e31d1fa29cc15806580e534e1a48c319f6f28f00e3c817ccd451c82cc28bb95623f4d8adacb54eb9ad0fe7e0b52385281a4930c28c2a33d1b2b2a141aa219dd6adee1c59b172159e466d0071b092368d658315f9e65c6f6ae63c376adf3309f05ca3411848e14af0347c2e446915951dcb91f2ce9918e09d1cc1201cd1da2e7ebf6c3bca0fd8c40985e2519c892915de2ffee9b50d76e54051d7d21353230092ff24e0dbfbadaacf9f85d56c9873974b4382f424ce4007b93d01a37490155e716103de87055724886d57c68468f440c5ab75317b0c101260d3d3f70b790b4e8a10a3fdd846b40ad1731a868d48bd5dc0ffcaa7c3fd6c0a4ce9e085386670175d056a53161b7b35caf514e93f4e51cd54e6906356c390b8c93dffb07c7b0ca69ffdd83bb7e0d309ed6c788bcd3e3d42584af4e49e103614dba2b78cc23b35b2e8228d81d849c7ff133bab5c8adf8264479f86126e1090b897df48f9b3778171049ff92b44010f1cf03f02e32e196a14fa09717cbc829c7cd619bf03ef832d995f2848d0a265abce8bbc8fa2a2d0e430071e8feb302bccc320a05d15aa8a99e88e414f2212bb81466179e51194d1c5a01d9e274d85782d49cddbc46cacf3a14ca1072be7e9bd1799621c41e050e4f423078e025acca7e2d6603f63ef4d61a3e79518036f0e1b0c4521b6dfb4fedc938308baaa7f8833282e24cc0037ce1b27ccb0a411c3bc735a0907045a6665f80e92ad1a844fd47eb4004ee922f5c7a586c46524242603aec740fe292eaf876d47699158faec3c784d0267142d2b9a4dab63acd4ae53ff7caf051615eaaa09d4293b0233e3498667e97a475e6472d8e9cf44fdb26729a570994d223d1e3a424ed686accf7f895d9459b1d5a95d79fbebf67057248922c6751163a1dcf8471b41c49470c29f1f922a2f4d77eb6d00da4135cb688e9960eb28eac5ac380a376e04b86b623b7b4a2cb1a051f5851ef0489afce94bb94b7a8c3682c00b4882051e8b9aa6aa6bd60eb0fc43410255b19749c08d4091fb20dd8e11bcf3f810ab03e7ccc98341747201268c649bee58110048d3d2aeadf623ef2a1fd0c77c30bd7224a93562dbf6377fad34b0dcc60445373e1ec6b2c591b0a450ea32f78623bba2cdf0ae3b1fb4661d4e68a865e6e4869d9727b371a78e87d7439b3bcf7125c169d47ec8d13da26820b215ca0cafac680bde1e66288d7cd7b5585dcd062272350ef5ab500a3644d368e5aac7379843a174ddfdf46150f926dc60d0fd5eb3b3bd399012c1ba36ad0d9d5d77e88c601cf410e56f83cb43896929e6745a0f8e4a43a30e5501205119577328783ffba93e6ece4b52cdaebea94e26dc7c228703ad2cbcfdedd949bb20ca040b786c441791a45a7c986ca4bca556d2b9a42c273008aa13bcd3309db652f608582348187809e4adfeb4a24d5abd7aa26da0791be3b799c1f3c83586ece4d63a83149309296f959fba783ac627cc009ad18f050c88a30be908eac13d503fbed0f6d981f16de606ff194cd97ee6c43407c894bb5c2ba7ff3102533fe649df333b924c2d5d28bc0149723578881229239fd802a8fdf6a56f1bb53c09a91a913c499649601248acda2845d015c14af42f0c9971346139de39630c20c5a60f651f02f6926b29632b641790516582f9f0a3e42e626228feb4ed6abcdad4a614e3cd57da7fddea64ce6303e4e2e6f26bbe629549943f6d6081ddd6997b9008f0dd4e78b761249f84f5632e4800c4fb05921191a6ca173fd1f17c4af8f2171c00509a48c4f8d960906cb86e3aab7b0e79fef798ef5938c8d822dfec981f2dd3bc31375fdd17635204acfac307a3487d0451171c12ee1a209f103cb2b7c45fe2d358e9c5d2b2dd9d300271d3735bb2514ad3adf67699c2b3ef3f802d0d1a08aebd49361c0f9c5b134d1f214768bc6e1cc588fb0fa3aec1221bbc1bb3757378d82807861fef9c634f13d9e9b9c3891039de80cfae1fb7c30d78212860da6046beb7317bc7e760c7777eaaa046cc4f02ba68314657309c19a50367919a9f3e8ff1b54898cbec5cee96c4aea4aa90266193660efbae272cac2e61f18c5c3202f108aba1620d8c2f020182801ec0f2100a6d1b363a90ae07c5bead6fe25784bcefacfb1bd97b4b29654a32a5145804040483043fc46088142a539e9052c462600b059835f57a71bd18d1a8dee2eba3d6d0f057b6592fdfb24adb238558bf2d8ff555b64232f7d547ad61f92adbac6c7b96678568f9172c991048ac96ab86c52ae960cdd130002a180e31f0dfe20d228a6079ec8b68f9173a2d4ac074b27ccbf7fbf2a88d96502c58e6434bf622d34637e410d866399b65fd0a673839d69095ddc8b1feff2dab94838363e87a1c1c39164ece6549232d9fe2d135faedfa95ccc655ba715d2ba3d168a5aa5aaa2a23addc609a6be5b7ea476f55a51b3682aaef01c7cacacaca252556246f304d2565766394d9b8c134bb7384a3aaaa1cd670dc108bc5fa4d8b2c8bf4625996949794524a79c9eaa5bca4252d69b9110dabaaa48d1ba7972775295ed8cfc52e33d8a5c205529230062e84fc4197f7eeb7efef377f98b53710deedededf0fd2d58227537d6edb0fb750bf166e2ab4143448c023aa19c1f73a113899452d3fea6d550a0c92367f93479ec98fc6e79dcf26c0f931d22c49789155a86425608733770ce71b303c2fda658cb9895df65cbec76cae9fb47d59178c75c6cab8028cbbddb238898a6a94a7a86e43712c800349a517ed49ad1cb6ce3afdee22ac6cc850443c68f5a0343662fe58bc7fe07cbb73c101931dbb8c25eb0582b2596910e2396571942acbcb3947e20a9c0e8c6e829a03256328de44cbfa24026eb480e816de68335ecdaf877db87d90e1cd678d7adfb2ded60cdc9dfc132a2b1d241964fb125df6df22f292fab64bd351ad1b0ac2b46964cd9147fd3118db8325ebfc5b7de8aa5527c7959d688c675c9aa5ac96854d9c51ae3304dccb6fd6aab321c9d384cb32f7fa755551fe3ea5428d4cd0cf86e9b19925e2084f0dab0c931cad2cf4a961a4208e146194ab028f22aa6e10c3de841163d903b4d3451d44415192eb420d4d811420861b8ac86f35ad6b2afe557cb57825143fe84ee1d3e7efb30779e915873dfcc211cbdaedc5d811e1743767e6420a4040c51e2c3f70f5e315648603fa900c217865c1a7b982afe00bc80d980ff227c09af8fa51e3ee1e8537c1919653060f6acbdf752098c0a28ba98efdd0fb01212cc7df5a92bdb80cceb65bc7e4735e05bee610f9faefaf70c2be8a073f3491852c6a7c409cf7c34ccf782fc5021ca3f29ea7192c4542ee693113e148a69f4c97c0f3303017dd2139db0d4d2eb033be3abacebbdeff8de7b3038ab015fbe7ced17b9c03097caba2eab8a80cef71edfc1a8117fbed23eaed8e224307f17d2c77e349c0e3a6174432402b044f38a111d57b3190c2430fc7d78cf26b0ffde87150249673ee8c31762ffbd10485ce603ccd409f1b21b9480adab29a989df14f9f92f2ad8f614d08782a53fb820899423528278ca114454a4f474a11342f8e0eb52ab6624c69d2396c2583e225c1fbb034405888a8bf921fe7a1b403afc36808080522faa1c71717952a031dc3b1f2b78e74365dc0b1f6c53206c8642d127eae40a05fa1915d113344b539518d1641a819f627fcf7746c7369719e1791930eb5ea559c2850648b8ac80861c4c71f1a1a10916eff251a2e779bc873023b06d77b41d229e69b4c741c13a6a138f1c6942e707a55924148a1645222c45c0b6f5f16142476de24f1678f972478029400108a00cb880c6708f4365acc0b41808d335f879453a3a7a042d113bb6e7b5f7105589cd8c065093d4d882699d796665db02d17126f73196743e46f72265541bee1f6804531b87a94d4735997879f898bc58131857035b31777ffee4cb2934c4e0d758c75cd7b80373bd45357e8d8198ebef618ac5ecbbe7c5fa1151889aba00379ddd9d1dc2989b1467bd8d85f7ebf7e083dd3b58b18bb0eeeef6e8839dbf113c9722780dbf9d045a8c7d02191a3b48c2ee4b62b06661caebf7fc79630f0667c5139a05afdff3e73d22c21a28ee04a902617b15c8e0a4bdfbf573944382f9bbfb7bbe648808ca69c60b9b9e417b601a7ffd1b3ee0e4d880d6a80c853c652663587337acdd50044c8b790ce1ab1e84aff2e7f253ec19ac640c6b314eb6d40a42c055c95635974073c7f7b2205e670fbe4cb3de7d8cd556104d8bc1c931a34c4e4142cffb47cac50a6cd3283b7ac44822318dba3410ac7de6c90aa32fafc4101114b70c3720bcea7ae5724f340b53dc498c6bf1c518939c463b38275d181244db97f272a2a3b3fbf3c7cccccc9c392f6d3de0e4871042f8aff478b004999cc1e601c6ccccddbd8ebbd7b97b9db9db77e3c608a360294c3fd74419afdf830f767cbe6193f302d6dd1a83bf479cac32fb1abf63d5de0826bfebeece56659663ec67448c4d42475595a5094c1fbedd1ed696486683b525d2dddd4b647b4a3b647bf4692cec59225de5e4d8d7d26e8411427f858e3fc5d2aa5e96aa4a36aaea5996f5a41cc9fe37aae17fbd0d55eb2d592ac9973f83b5eef15e4544395e5766433f6e31b391a584307d9dfafd02a834aaaa663e58eb1dac45e9d922f05b1deccc331d2d59609b0add70291bdabdddfcbd0203e75cf78e94eeee0f2ecb88c693b0d71f6cd75d42b573ce41e8205ce71e3a084fb09d73fd9e7b19cafd7b7ed1f1ce38e33d84ce41f7dcbdbb25bd406cbe2ef55477f7dff6e7de95600183b96285a5ab990ac1367ac04197c33937849c910ec59a0ed3c4f8d6c1cf6199a3c3555b7e4508e1cbec848270468c314a1d7e8d68b8846e79749f21a584988eb6fab78ebe33f60c2847343cba8dd6d1513df7482fefbd6ee8ba1b967e3ad70dddebe79c73eea4c8589285c9b41ad8defd1cce98d5d10e1c64deb0c97d8a515530ff4d0b01434063b46bf7209c4b30d9f735d7fe5e5dd3b217d6629c2efd8aec4c54877aef596f35c26a4403be3895b9e4dceebe760f3b704d20fad7c8f5298e9594efd9893594945e954634aaca23af389837aad16f392a7ef5562c954e712687bb4bc8f022f5a8068a6922cc50a7c928ae20c3767087df33379bdcbf0c87693ce30c4786d305ecc47f61158f9460694c40ddb8682edac60005d85545bf7e0f3ed81da7a0a0dd06bafbf337c39d80e955554546de17b5e13190610996830b62da0a4642069827fd6bdae904a439130e4370bd03054cf5af61ac397f2a92cc28606e27059c4ea7d3e974caa1323910718299519bbe809a0a1db41196bc7ecf9f7764d40d4980de7bfe9ca4fa5aa3833953ec42843a383848a4229c85333f6e899d9d203b5660c1ee6ed3d06c9a768108c484859a8914371c61db62f8b6f4a66abd9560baccb25bf55e611a46627cf32746830ee183cfc130835876e102b6ad0fff4cf113a39d4e33393a6e8e080d3d39d24414a7d3e9743a9d7252806dec73f26102867f9e3869a593ca9c26f39ed486e7d545c0bc446facbdfbf5731ef1c032e1c764b28ac482e8803b53d5f8da69820f112245889060dbf69c7a86c0a498462f1f2208050535219a1b6a6e1a4ad3b4d7b409401930c371261b54806d0c04c4049e5c0d94d12ce4031b4a2d2d9d6117c768afdff32122283c7e18e9e1f9fa3d7fdefe8a520522fd5cc96cb896ab840035f15725abf480d6d4c4eeb4794096d80373bd6532c63dd107c5348e089122fde4891327575cd1a40993b9699aa6695a0e36b9cfc1010b28a6713e37f8c1ebf79c6558ae3bc4aef184212228afda2f16403cf5b5289e7714495acadc5c5cf80626d8b63f3fcc404344507c5a7b01c9a016211b50bbeb2bcbf16a27227cae3b7b374cf32858ea520936cb5db0b43909a67ff3e0e6e387250622e59584c89c7a55e2ccca162e3b65f08135a1671a850de123826f3be57818ae19bd62a3920e9d3662a808c771fc3d0e0ee78793e1e028451cac392f6055c90de1c877590faca11c6ac6cce30724574604d30a2d85bff7f62d33ef430821fcb74bc4ddfbb9f773efb7ebfebabd776494214bb1845dae08330df7ab7dc7be355a262f06afee41f74f4387f00d114159c93670c7e8842a314b3848151ee22176e278dc107ea2b1141e622a6ec70999ee9f778cc638d818c9a4e289a955d66750356d8c646e3ce42cf0214e986e7bd1b8a8b95002dbbc4811a6790232136ac33e38e889d188f0a1280a17334cd35595654130c5a9d48c869026bed48c979af152d97b103e1acf66a466c05497092ea6d1d601cbdc1f690c6c87e395b9414c8e23d5f6d703936377cb6bf481c9afdad563f2bbaede7d4c75314d1341f99906a51a8cd6905093c78fb9af3a73df470560a647f6c8ea3e715a263f1bb442eba465587b9d2c1729988cf5611f159c6620e9b5d3ebeab6ac6c3b36838197ebe2466dfcc6010e40296a4335401900821e2a93c3110c6fd4c67b0a3e2722448a14e190cc806ddbd333e4f4989999b50984da04055058292ee22286c251e8e400036c632226e22729286e681540b8430522e810bea1202127344e34cd3d01db5648a8899290a48bbb7b555553f66b20e9d40080ad061b38e0520310bbab23c6a7043a84ef46131a7aa2314dccced41dfc41414242397c3a9d4e454551a250494d1e3973377b895d0574081f7c7e5d2e2e2f2f303537dc198a351bae88d1b58fcfe3e0189203a55272a8ecce0a41ddbc6abc82890bd3fd86000dc374bf2da0a43516180d816d27d4699f3323703398579baaa66da3a0408a2387ce0e95713cd4e478a2b041a6734d9ac09c50674e601bbb2017238675cf885b8e20c2c47d69bd04846387b183bebf0efaee3e04feaea43073615363320bd853e1832bccedc47cc4d21f9410d242480b283f509cdbe0101fbb0b86e3cb8be68af5dc624fe7fe456fe791ff65f3b930f02b1f5896aab2bad730ccddbcce9fdd7719863575cead7bfbbc9d332bb373ccbcda0e33332bb36bc15a67d700d8c63666deb25619552765dde3f3d8afbb338deedac58e0d9f7784cfabe817d67bafa5e9570783edebcd5a6520f4ded8cfb5eb6fa7704af9fb98cbac9bb461af99661f3412218470480adae7d160058e073310f99122b60842c2c303173f4158010f5b502942944491dcc1922e9a54d1c5130c3006aca74ed10591c9075d3cd186740125092225446a300322b438a245920dc8dce732401865f7b231b8549300d574360603d4c4598c262f99cca2433cd28177e7f2af940256aa02ebe74b4d2f231c56a24861e90f48489912450b213f54621005c67b0d3a8194a94127e862eacb6a6c357ddae8500485a5038c11f74cddfe0fcb296408172ec32a4c09218410c22020844f4addc27237fb9dafbbba2eb391f79c70c2df69d7775f73777f1d3358da74bc533f3fa90cbfe7ce637c8d84b5c8708d85e53a87cab876ce0531e9288e080b735e776b672eb2d6ceb96f6e02e327aa6ae0fbdf85fff103e27929e60a6cfbf8de1be2ac192f01ebdfddcdfcbb5b477392d7ef515fa639b42efc8659103d3d6329b8a7d52c805c6825444586869c14a181326099b0c412459ae05004b6ad90d0154588526af386869ca4b630379da2331dd217b06d8584ae48a9cd9b4452284263ad3252c2779aec1f137a0b163688bbc2ce921aba055878a719f705f7f71c421dc23f7952852a40010a4c60021290d080b9690dd0344dd3340568cd05d4a4b50d3b9a8f108478788444c1644811137b647f36898e0ecd622a16a652406b58244ba653844da11bd514217c9d18e1f2c408e52e0f0fcff22c4f559d2047336c11e5d3622c2dc6d262acaad262dc568eab7e107655599f62ab6a29a5bcaeb6b690a51baf2606520ca5d186aaaad0ec1b737fc75f2e8b18049ea1a5a8c1080a8542a152286772989017f02e84259e6ced0e0d64fab315a55ef2922069a84b357eec355447d5b875db31f78a7db590114c6af3def3e7fd1bea0028140a8532c0d2686035f7a80ca8cc4a91496db897f939e66d752b9b951cd0c95b6b8f394d406de09394308592b4484280d668cee4da5d8c1849d329801c61f2db080a0a7a95d912065e7a6ce0c6f0a236ec2f4a524db57d8ff1e5a53be3f1638bb83406662f31103f5615b73f8f511b864668fbb2022f6ada1ca4c9e3c7644c4dcbeb8ef0d81d82110f0d63bf0dc86c87fb63eef36a0c765e6776eb56de4329af070584fe5a922c55cdfa8dd1923700f568c4157b0a96b8e0744ab91a949af8af203e3ee48e838367480e873dc43804db3468eaa032ff026cd321140e1dd446a5081eeae66d2378dda81bd40deac6279883a8b48d9b0731ab118004100053160000180c060483e180703c502451f914800f638a3e745234140844418e03298ae228c618420030041963084146a1a14107e32dc3d1252b309dd7fa2bc0260079069572cfdd25f0912778bff438acfd9fc4976d00892659e065144eb16a5cc5703f884abc36ec39236ac9c68d22f6e8dfa9c3a2e0689183a8b9b2e418026f1413a23a74a79d2f4fc72542a96905712f3deb2e4531df19e7c0e10e287f6d526f88756e52b727ec51c9fede104e2c3f650d0d090a14c493773849f2a8d8e49a7722596df977ff473ddd6bf929325352d82d02c772d2f10a1ba7c21bc6f6669c807882078fcaa7754a09af00aca0de2b5c291d08c12261090a0f716772ee185e9a3f5fd7820abd449c3d71a03acfbabca4a9aa8ead156be86d6c98de91fbfda227167382dec6ba64cac7a1273009f2c48c16793ba387921bf88293cc582e19e2e058fbd918441e4d030758968975a6bc2a24ca886e9161b84f4f619fe4cba73e775f2985728c8d7cb80f84baef87cc221d1fdffdc0e8b36261c39ef596fb889522843127c9f02c5bf723e22d9c77103d53a8b3b467cbcd70d441bd9043c416a5b9894e80a28c580a7aad37a643bc85460e67af37ace7611ce4517666e2d1737b287fefbf53b37ddab7920e087a6ada1b2dc7a9222179c8fb465cd2c27124757e6476fb7317b7b070896f2b2a5725683da7ebd52634c1d0d732d25de98b488423cb0a07be5e440b8c3f7173c48ab255a8d4f08920620a0b0262ae3858d66f92bfc215a462f4ab9ec066a74c32c4411c77cbf2f2af5bd97ca2a0b8a4f34ace709d8862ad4f5c15a5f074acb7bc720397ea0e50f9b45f845b7fca5925fe750af5e3c4e039c9be96becf7affca4afd7315cb64d276a998bf5f7aefb6d64f70c4e0497604780aefba6bb9580ed4470635a02ce349bf79a2c87fbf87fb17def7793ec92667a06c322b5a46ccf986e89e52c221293b95c33d2dcf5cc8f9fea810e38a4c257d615f359989c57ed79212a9e20f04fd1e045dcb9619677c2353b809c48787f9c1f4c119a01b0aad3a8006a23623b173de268a308dd1f286643599a366c277fafcc6b304e80fd667c9474b61fd6c82a1d998cf082bb8c6dcf29da4957f3286bcb93f6e6d497669a4a4084e54222410d0d1c543030fd0e326c4c6903bbe3d7731db407a623a41a3d7f5b6943a2bb6fe63d2621e6eafc9cbd408e214fada0c4f7c6b7003b9e22c9ac29d851bda1be502af396da6567eef582742cbf80bdc1756e1974d332d2a90507934be2ddb9916c97c88fae15befd0b1acaa06cf0ae97b65ec5104b13e2b729a5e9c117c6503c78c55cdf8e2fb3bc1ae62becfed8a0aa76989c8e6e84e9bd4a66d308826a604d0a170d1dc5d37e88f9a1937630bed3ffd4ca3899990f005511c1d3999bf833e5ad7136548c3977e96c1f9fa6a22fb7f72e12fbbf9534f8bf7960de7e0b86081a2dc883200ef0046000d7b5424c4bdc443b374118dda2a3008007b99b625e52eda4b3d2180355a9591ca6dae395db38bd5e66ee8ed179ce12c97a46bbb4aff9a361f481487b12943c8e7bb34c577a180145288b34353dc659e999fe6142f6002ea0437a472dcc4d053ade531d56f2303a59c22a6ac0f213e5cc2bdfe40bda80bb0f41c4d73525fb8451d0c2506db1cc6a1c0948b986c243423d52ad65169166cafb029e770de7a25c6100aa75cbd122a5a29d5d2b23f92104ab1bc0d8569282a7dcbffeb66251c490c005c6f1c40ffcf6771f2230b80abf8468a92bcd8da023a0fc26269c3d574e66c9943d7c28614119e4e0a7b71b54a4a2b486bbfa9b8e6c996fb8cec6248db170f020a560765ae9df90214c5b1623cb33588f87c01effd151e26bf3b45650d0e2b18b0b1cd23b04842df3e687fa28de7aaca8436702c7a6e166569adf90da6e9aa1c0fd0c65f0b64812a2d1dc6a63924f3d3e2d13d648d97380ea56509c53526b002511e933543b46cb09463ad4bc5c3e4b121bf622f015742bf76835417224e5ebfc63bceb42200f80579eec1fe471a30905bdcad33ec7e36a33b3436a2617246af64f9543a422f53369a5a6e75eacf6b57307d8410b81e239cb9c130d45d143500ece27e0253baaf3f1095eb97acda7891c5755725c9452e5eaaec3e5fc740e707854b62185f74d26b756a599c8d82bb8126b28f0f4943d59a1c5d415d5597bc2cc0f643055500b84a455a768da16ee34a57696cfed198c89b6c509e0e2635c585229404e76f7147c5b6cc73d03a083a78e2c7ee96fff9aba14e925e458618540e171d3c929a094f3c396483ff9632e1c5ad8bfbb611097a85ea23fdfc13214ef0ee3dd06b67d805306a588029dd59873a9a84882ad100b799bbff483b44a54cf4af18961fe9422b20d9a2bfb20955115995842279365c97d77b145dc2d39b4431b753ab06bd573bad8a76b55d65a779238ae2c748150473a9bf3ce516a3283b03092d42f17d0af4109d54cbb324fe109a8998e40bc4341bb7fb2724ed875bfc04aa78cdf12fad6e0d73bb8370f3cd5dea055906a1472cf2df66e9f801ca39d174db1de9da875f416b7b1951d55a7d0a4681efbd7843f769ca8a55a7535f6dcb1df52df8ad8e82773acf407d7228d28b92851c60e2df939a7e5143b1a3eb0e8048ae7cc8a415bc276c6996d73f790f9f08ff254c4b7403481d0902e40acb349ec5f48407b05d5768d9fbfa0e5cbb88be68dbdc59740bf05ceb10d6785981635a8a871956b99dd85d25bbd2e8f5e5b3c44a83e1edc5b9efbfcb9cf902dac53f413e8a43b0942f521e2d6ab2ba237705f6bbd5d8d797e3f788b6d03d87360c5abaa967e74ab22d93fd226f5ca5b9a19875511abc0d883fdb7f060e520ede22391ba4e86ee181bcc5a1347a63ba29968ffcd16cd8c972382dcec61cc72083962a8ce45efad0611d940195a9b97e0b8a162d6e601507107a40efd12b09f455ff7953a34a57137a9cb7e7d95b8dac2068197c3786d8a8a11ba05213fe306bc99c070670be8a0926ef2a4dcebe3d09ac76ac206317c7c4acf6547dd51313e7f979092027c7951daaf7b24298a116736cfc1a2bcf90a91682571c325595548ae8fda47a62d8eea2670e7dd1a5d91c7abb4b299436ef807641cf19572ecc6fa4662979e1bd145efec0c26e39678c4d6984f45e143130c0071ae448a36758acbcf521560913c2600012135c879bb8dfd75afe6f568c571899c22744fdff38d2fcf8d72b90a691be4dcd0dc71d32953a37d0ae133ec1607304c42cc103e2092858d5301cdc7bdcc2c3d4090109071fa09e20142cd062af13d09f1da11e77a0711b97d0df886c21df7d4f0f23f5faf5021eeaf942bbb853d487048766646b481242ebc5e74d5ed648985208dc9c6a61943e7962a625c2d705fabbf840893302d6346f729c087c7f9d34ff97cb9ae3db3b49a215be9951a728558fcc2564dba3cece45a34799c181b5e2c6f7b03f98984262853fcc2269c93857a68ddd8a01c8a065737585202aa172cbaedd78228cd8f54d2fbcd24774d906e64fd8530170dbff84127f5ffec779c7e2a6a57dac009c357b00c9d63a8cc0c30ea20b6dd2b8916eae0f07db64199a8eecf0cdaa0113a8412866cb1336877f0c3d8a8800487888e03e0b0190ab936dae58cbbf610e0ab9e835963fc570b902d867781327c76d5d876268ff6642042c59415be738c04c48f1d46aeafcb171b9a898ea95bb7d2a142e4816ecfb96e5e67eae12f7965312111560fecd486b761bcb42054664986ac5a6781ce7f85070a611eea49fcda12684238fc73f90dc2d9c46ab11fddd48fd7e86d3d8f119ac2936bf1ceeb6b1424bbba8f0ebb8d1dcd02442fb92aaafd9eb9c028526a29d5fd1d34b5ed9c150cf915b81de6034343ff5e5ec45f1cb8cb82e2a0085772a728112c88b88f98caca38228e0479d8d2c4431a44dd7a4b43f513b037ed8a1167124230bb62434bf47786cad4b5ca2809ffd7af6a6c700b042d3c1d74e0590193f4197f65fb37885d86ff8a710cbc451f3cefb04bb7e13a538db8cf9cea37423d8ac44e016d8cf84c44b9f63f01b170b0a8abd869d824a399c46240043293b24c567b36b5a1df40a3119d4d17b5b2f21c70fbae7aa256159a113e1813f0cd272c8fa1edc833da0ab3910523c2577b1dfaff6cc93c5ac8f5ac33ef680c14786c6fd600f2dc180b9e96f63c896e35e43e13a60b05224f8cf11fed8d85b859e75d0341235f73e60b8d385efe0db1ca614babf3fdd073b7ac3eb03e5e8cf34db305188031b1899e9f30148f444074691256d7fdfcde7e7251e08697175d25b1a2cfc6a69e63eaa08a3bd3e925513b10c766c502eb616e5e2a34545682e7f4b12caf7d6a41c81197553d3185bf0fdaf187ca54fe7cc1af5c6463a41ca786c4d60e76a2cf71294fb0ecdb9da3e2765f679e3157bc48c7b684116d5e76a13a0474db2bae834e93e1408944a3377a0ee3e48e066e1a4b6d164a1f0dad493a8bcda73c8832d256375f7c8bbc3beecc3523ab3ff53c4b59bd5d7aa76a2d617df64d87743d5601cf306f1edcf67a742b2462e652fdecd1fadd5ff5a188847c090cedbe91b07f11be7a0c5ead55724fde695667b2748da1dd4b4ccc16f3ac9d1d12e238451e02a6e568299bbc482a695d7907131f1ff76e69876570e9fbc590547d0a578af61018046788c64f6a36c1c683f55c665e5c597f3f3c04149894547d691cd93a6fd3ead19c602d385a55ae653847f812c071ca623b58cb4aeef98861a58432e499e991c33d61004b102443283018bb8ff7420a1e0a0bfd955e79fdaf57c438b6687a7c382a93a16f78147fb2087a20066d0cc3645e4a6c0a7b6fc3428af50826441e7bccbb84c92567935caca940479dbd78b569d9dae0d693d0c83ae597223bfe23024292c36d1e3bd9d755fb4d7d59db78e75d9ab5c06af0de5582791b223606790bbaa6169cf38fa2caa82a1e46d549938987a9ec3de7df22b693c620f3b885c37d2a604e78dc26796016ef5b81a3274cddff09cdf898d84f9e1e990026ffce732c37cb35fcbf8f8272c3613b9a2b7312caa9b7556e16bd7e8ca811c85d8d59d3e358c1b6f44fa9449687a01a8da8878ccd2b73697f225667ecbbfcd166958d2185041ce9b03b0908070f44e9827440c7aa87653f354fbdd4589ff4ddcb27cffe4a0755aa4b1fd51602dfb3c842dc1c0ab78b748c7afd08d1d5418d874921bd0da8b447839aee22371fa4c2ca4a182ad249704d86db449ed91422fda4311018c7da08645f46d7ed8eb207349a1cedf2e4bed7449c5cf5615c16b887f186aa44e69e0b52cace5e8948b190b19ddab7a7fa22a7778589d3e7e1964ad2fbc142063e0adde6750c238a40d39bd93e3c8087822c869c4cd8e12c6d075ed958fc7e06a0172d99bc4328fcc952c60069e14c70427a91c43d8bd5c650cc874836224f6157563aa8af9ab1e1536d1e6967a2d8409959ff1e03b6ec44f46ae70b6d48d1ce93c1b3d38e1466300a3ec8980e9551ecfc90299124b957dd5062cdf648786c70d8c6596e8b57d287eaa87aaa1116e406df1708a2a03396be27ef79338e1498a8e82c747b099b2a791827cf97bb4b70ee24d612db8f6862a8bdc9553d831114be17ba9a1223d6f919e952174802a755753337a7a7ad63e7a2d9e3a5d723a2d530bb703838b20567f34101fd1c40ba07e60ed212f1bb6b0c89f963bb1133d59dfac88f2eab5c7fc146f51d321f830de09760ed9d8afa6c4e50bc02bc560f6d2f026065cc14107471d3b40b4ca80b76a9697266e6a58b239236ee06ecc25cb4bc5e353bee892da74527310810cc6eb7ac3f1f40c3ed7cba8ddf8e270ed0c53966b98797d06c6e75d7b55014c315617ae4560af12e639aebf60232b7f852ec9d479010b3f328affea318075f5731d1f68f4066060977428b1cc935a8a9681b4b144c394f8719e80db9d01f23a18952387d513181ad082e87264ed2f6ed18a4dc1533d0a35997712718bedb972b873eee40a2a2df8de6739aa9e322bdbc4fb71601e03a5a5c05da08f179dd5c2a1eb3076383d052ba2790b19d992f1001eaa70f61f17adf456b6bccdf0aae90dabb80cb0bf303e5fc1ee1fd129f74198490dd877e7eebf9a2df0e6032432bd0699f0229803debc0da4e58ada9f4979551a51f5a9cac181db016d4dcf17090910000abfb5d7c89f35f803f2af27259ea6f8c3e8c2849e2332697a89d5020f46ef07cd770bf1540fea48ab0fd336905e9c347d3379fe41f248a388bc004a050d072f381513f64f7843802f865ff3fd9805a10e93685d59403122f68d2bd8871d5157867e9b7635842690f6532d70b4cbb22b930548640b9cdccbd0ff1e6928f70d2305472d6a13cd4513f6b46745ff86f54318eef2eb8a023ae06211e0f6923df53f7c36574664c1987ed1df5c5adc085e3e110ce91cb791d1fcfd9903b38d3d6615d3e90e75ef81b27de481e9b454dbc9b4994da8b4ce704616499645e019c21d90d0a3daa60760832019816978fda118ba67f67ea0f930fda00e275eef1c1b17d7973726cecd9b75308f9631508f0ec34f606cb92a5d1ec3dc747e44b22fa88827059ae67f32d7beb422ed85948e4bcfa0b9ae1b7ed355a3792101e67619c9f2cba9c440d7f1c51adf1c21acbd7c46982c09467c4463fad0175f16ad4b1130b9ab20671d412274338313d0cba4caf1202674d2144a9501991d4585c8ac48d00cbc0828bfb15149c7311e1210949f74beb65e81a49403401d6a669621b52ce362a8911f04a60ec415980b78fcfebff641e093465091403aa4206bdfc7767b97cc0c8e6da82e97226ffd6fd40644aefec499a666268996d2ee7f27f50c066d97d2118d118b5f754c83632a791765e500002121ba23234c49e17310ad04be4592f31221ea5faf4ccb80af8c14befea77e4d3e1f1e056111a19ba29bbf688736fcfd4a1f04cecbb170dcf51c542ff6a3df4610e173c2d79d0708f976a75f7e1e6d8476294a62af717c92afe490d6221f5d1cdff520681516f47161480fe89c043257c60ac8635a3c57db15fba1d3cd8d71b5af4b121fa3c30e27fd2562d953e22343c816317e90fcb18784bebf259a8a3705fb249c4a74f0e178190bbe24cd352775911b53f09467fbdb3de80c9424a1f73b15e82895886920ee8147b3d1498a4a123d3191e680cc0aaf7a3295bbc64eda3f32fc3aa08764c2492ec5d59ebf4a002b2f2f1d42a6308a00fda7fef23b5c892317b24b00abd135a58ce5701c5d868642238cf32969f264e28803ac71f5483212c94b66bb0b58a719a181025d17f1cc381b9cd7c3c877d236ab68be2e5ca94cb8a3847b7da3a55af18b0dd460742730c790bc19130f33f6ea11019865b1ec1937ebb98378a26a4085c04b00b21d1a62b6b8e116242c5c303bd0e5971eece4e54230ba9ca99cee962b2e89319da81566eaf50dde148327073f93e9a275a665e938342bfa3843675048d0ef8183ab4bc015775e11722490a02c399a29ba427133a25b618f164b496807784f5d8a5f6ac49349d467320e740c9eb6ea08604874f07b906293e8a71a855298917b7060a845e40401ab40ed74082a31a97080605ae7626e256d4e8ea3bf68987c2f0a7b5c653e6431261a0b3266307673cc330c8fc84441abca6d1a95707d621a2aaaee762b0e01cfc89bbad795fc71b5bfef138ed619cffef71b9d05e2c8d394954c5c21a07be021318035bd3f2dd890eedcdff3d024740c9441a4c228651ee48144a1610886d52f07d52f80046620d17dbf58830fa30d1e086cbdde0e8798379629693a9b107643fd51430f5c20e85f5f16084b0a5f5971dcdabe0696c0fe41e1de64eab245d2a2ccb4811b2b2a5de54b57357a9a80a6bca9a79e1193dd1a9a6098ecf8162ea7b2c26a21484f08d32daa41b3b1a1d9826e575bafb7eb5d74b28dd46ab98f57d2d3712fb55a5bd55b955b518b0fc68ac7b9878e61a3c69c629916a6e6aa084e4fc17d47f48e3f843c7e8010eb6c8a88d184400f1bc4198322c1aaf55863fddb0021d3b3c0cf4fee7b2c685617f49e64884b3014e836c0e02a6c59516affa8446bb119c87ffff6b2aaa2fe3cde9a54204eacc1e38d49f3dfd656dda91b5cafe586f5655de7e4658625b600c1dac54176c7b10e81a2dd75f2a25c9743ec394c8347e10a225c2e0e5c0c26a6015e6aef8bb078fa888329d40b450766d639c041d3fddc1048f99e847b0031f09ff9acd3d97455760c55cee5709ad1a40339f879af2509cd68290c6809d3d0182c4cbbd8f611a40eb62ec1c72557edefdcecdda00e3134b5b8e41fec0a003dd2c3506b4bb2dbcf588398ee49040bab7460f1bf2af4cd0d061dc7126e54988505e64f596be25fc828a0c9f1b62cb4f1c5973f0cf9ed439a4dbe68414db052caeefe64008b2ea722b080ff3d0fad241241999f9468ac3bacc28c2776644250268b7c3a4b3906b4b3350a8d141023797459f6c02ede1b74b98db06bf44e30822aca84daebd80d82c32291cce91ac304a80b4869dfebb7151493169da0c419e2d0edab5813aa2febddd1dcdde643e97ebc2ae881074762fceb1dd4ccf9a57a03ac831397509fb913f02663d6ed03c2e03a41aa387fbbc62ef16d214744bf9d96df55f78392a4d25ccc34c0aaa7ca7c4cf3dd47f508391df3e839db57f7b93838c3dddeb73e8e75cdb8898178c868e325028a86eeb271394e8ca2e9b12fb2f172405d6322ab678a404b091aa52cd18978cd32230fa2e4e6f04ebc34faf5bab8f35e4d11d6ebb2640094da629fae19de32868d75ed825f8864108873194c39ebdf25417c4020d0f721ecc4ef525f3d36e4dd63d62a0b878a91a1662315b440f3b1c0d04140012744991c2f3585dd68bf73bfdc804e394ce17c9801074e8b270c616d0160dfb2e0e6435d3020f45de64f1fd55e1b93dd17ba2e6e4a2592351b44598d732114a764c45c895546af728cc919bc4013ec5dc48094aebc1b477d396c4356aa4cd233dc3dcd322e69295e6e246af8bdbf50b410d86136e0e38c5d2ca1b887f07a99d610e5f6b8c4ce27793c1358ab34ddcf63f2b64b65c6ed06207810576fb591543600107e80e49ca619c14936c4c029fa50a4cc2034bc398da83ab6968452f451c833f45b3558207004dc060e77e437e06a17f2c93d4405316ec26c3066b6c828abeeb80ca85c52c88b8ceeb1012513dd2e298c5625a4edabbd1e8b2b495337085df65eb7f05d12e1d03e1234721541f85546141d233326dafdb85a93ab615864e96c46042f700e6b4e43bc65d454b7798df39359e2681b8b6fcdb223d2723449626f106fb9187e043e9aaea82be91247708ef1111f31a46db2788234ffe29800553e2d3a7e73ec9fdf41e6e95ed35c97a4e28513baadb0ddd952cddfa0b91002c46a7a82d802dc73f66522ad3639f886d7aa52f32bac2f1564b819049fd87d7960cba44dcbaa5453c9144df9d684a708056a596309922cae60b8c123b88fd951b0859816791cc1f7232d01ae4fd5d3ab3bc7e15dab9224dc799c934e89e06d231f5bc475a685d4053a9f3991434416fc83b103490cf4e1d882e64fccb6d4aa3d4d19cee4f91a11002ef25288c2c0085cf053b4e7a81fbd1df14ae177f66382c271f78c0f605635d6b53569ffe09b339fa90e3ba63c08a25eafa97f5c554f65373ad254c359e79ae98404b5570793d20f9a92a323aed1aab908769de5c0dfeb13a808b4a58b832f4c6e2e9d0c890e8aad48e063c1b82e04c83e67e34f67bbe963404148bdd8cf6cc0797ae998c84068f3bb3dfbc592af6268bb39cda9b9bc55513933ef62ea18d2b69b4bb5f9ae515f718a77fed7363393fa1097a126847bbc556df26932a3797968dfd63bc928f7c73575c72fcfcf38e70a93e80f9823096bf7b920c2e2cf69be33486e7c90f78c01a75a0770ff0ea613452340755cd0c83696f19beefa7988f5a0772eca56b3db6b450d829854867462465d88a5b278bdc5b75a2dab07cf2a47b4bfff10bce98576ba64bc72cdc12fbd7cf0e675ff41d002582fdcc5ff80d4bc476130ac8fab9729e746a2c9a23782bb57ee515d01f4036042df31593935ede2305d54eb2bfa4cb64aa752a952f60aca5fc8d4fac98175cd697206c7e0961674fcb1031c28b2c9ae9b2ba8a8e861a009cac598eca6a72c26541f219f2a074cc6b88040008d5234f704bb44fa1a28f8b1a4e0aba961da23eb93ec452e8b1ce6d450c01de456eacbedf8845c0ef1ec507aa684d572a6c6d510fa3569066482f40cbccb6d0046227e45264a74139d3a31106d13764b6562f82fe0673351facb4ffffbdfcfc85a30b99b3f2ceb38a6858a7d5006283ce8d2f9526f7eb942a8c886736df899e7c8c6388c0600b4479ff9751013380d0c640ef9445c2e8a9c8d86e75f4ab0a045b12cdaf1fd0d81171dc4396f2b88149f1d6a714e58857f04b954be2d48cd198cf244150c8431abfa02a551d16db246199ac36327142dfb42e57dd990aead33bf41764b8161274801148d3fd506baed5aa18a3c39ca078d08f8b1823c1e0ebf83af0c5a5697407857d580e32573f717dc8a0325c46a8782e7f10af319c230c422a5c6d4f23bcc18e016b09fe90e1a0ee05072fa07e799abc40b7ee9ebc2ce6d5d835b05c7e17db5c1c813d05ef2d3b9aca1d3388293edc512f0624b95a8ca8a15012abf54b67348462b4efa5ddfb56491804236ead4d9d2ec0c1dfbe85ba3a47ed59b12c675e19308b515132b2601bd62b2a10fdba37550f9451e2bf5c01bcf6e45fb66439bd2239f2773c38739eb5c119d26c9a38d6c7475726dc8f6db7acb1bb48d5cd055a7bbf87b22d3bbaab0937d306a408b289155f748d63683d464341118270e86b631c2cc6448e34abf3904d6b27104f80e8762c398e39db084559ae88c3309a52a999bc40be1c09b8ed0c9bc027fd753935ed3cfe4875ec0a2354aee2fab065e1dc10b9f428621cec5c23e4b9058701c4efcb1d81fa68f5a6cf5b87415cd1fea63d5e8b74bcbbc94593373e9aa8552754554da69cce451d28770459d622b7eaa0e057f5a5b2174ce039c40fde8eedee81339981f5116e4b27de56d4d42d1235897cce28375aa95508b14cccaad574859e1084d0b9d581a637c14aa8b132a66c03d1eadac01a2fae834b083c7f606d911c5fd496059bcab9ff82c12da259eaa2d115f395c2a91f91ed154e22e4aa1a8e05e4527c4a19943cfd1c42accd41525586a01fff8e66fa06c876b2e80be2c22f1aa9c2a57860e18f78704999a83257e5686b197feb97f9ebe47494586c34ff91b587b68ce05700b9b72b94f28f1522f0f08cd2a1be22a83fc826daaa20552baf3c9a9abfa88d7313d5c99767482814d9146cc431edaf7849c12ac1a6f7828737acded992383d8622847980e30d116b00e70eec3043c839259601e7378fab8cd9ccda075ba245fb6a1f0b62cbfa3a69b8c1ae753c677f517c8e52aa5e8f861e54264a2c43e524a8e36d2fbbb8b949adcc2ced9dcfd09e3d82f3fd703acc4077cb8292f5ab61cd830c6d43be9855461ab7e2da48f233d53df31c37a058045c76ea4c7a2046f572f54873bcd2db17e78bd488e4af2002949bd5f3969f7de5f7053dc844a28702de30b8b104411c2f8d6bd527ab3321efe83947ef3318732bcfcc6a74e43800240fb0f028e53de04540b80b7ec1bf15605707140b0c57eafc8efaff8182bffefa5627551462394cd8ff91c3f3e1e87fcedd3cb504cc49a93cded15f9e2eb0f0c27732a2cf846c6cc77da5b3383d3c2a50d9d87b4ed94472ea7b55ba2f2ec0fac5b98fba936aab4bea63e791b40bb270775d8497c078d046d3069d28dbda02aa3e6ae0663e83bd102dceb4464e80d0b8d4bd19f33568075f3d508c1bf060ef9bb8a4caa0d15aa6ea98a120a1b6a6ebf599ab1b74d526edf7c9e00851465f26843bac5df8a0a3f604aa6cca8b088ff5859141a66dc6c506be24347086309fb9f161cc2b035475a3424c0ef3eb0f70bce43c280698aeb960f58fc608e662f4cc046af85219b88f460786c5b78f97aa0fc8f3e34537ebf86a2c0b4f5618d042b5c99c428068c3e79a9c7997d35fbd35c0f93439e48f022875a432755d5cec569a6904097a1a99fc1348413bba428fd672553a40c595da1e721838e0a547b6ab1a1f1a08e8d4265f2f9273258f60379ac15bd15077b8656239310758b422ac3667d1b14f4c91c88f6075e742a98b5ce08d1ce57e2643333ce97e42a76083f8f2cbdc484a152ddf43f9b26368cea0cc58987dbc690527a80ea8cce61cd8db7774a6563a3cc92983ad3564bb0e83be9b52bdbd32aef41193da50cf1e1a4d755997a5ede7288e4d48f43876080bedd047309cf83d2f651054a42719f599343978dd444bc6d0f3ec99f30ea4c0cd2de5e2f642784efe7aa4d595e3d6e3c528d2c3cb1f184132500605e51c9e2642a5db48e116f650905e49ed81373d1e2ed86726604938149e5f33a7293a013e9bd0d43d29f594ca0536166e33987dc61db4e0917329cc93c2833391f398e6a4c0383fe4a1fa1f709d9176bdb92536ab646d751e59dd02db2d7a9e0108409e7170277d5f858dac385bd40bce6e0886a7b4b33bf4924bc1f2423e3cc5698ef272edaa02bca8cb9000e4120fe35b43e7e9c801c0cc5da4a93013dcfb665d05f5a954266e20a9705b8799582f8f8cbf0291e681740caadb6cbcdae5eddd814e49c080bce664cab1d8ba040713f0d3849e898d7e36ac411919fb56018b80d403dfe62d603ad6745769b60d0b6046e9d1b4a9c896ece6ce644c2f6b922273abf60e825b639a8034238450f93f822f4d96630af25b68db1b8be58a8316f2313c5f09c6ac8ececbfff4081a9a938da4e1efe57ab3cfe69115911afa49897f0eff48f450c962168644b1ce7796058c260570ba229b8df9f7e85286cf1d38d5ce78b4a9f82d4b448a0124b1dec0f47e0473a5d8d07d9c13f42734ffcd29c450538c8f6c640d56919fc7f230fdbc387130c9fc8eaf02ed16cb74cf7a4eb3816371ab3192f6d82ce8472e42653d22a5fae0ab296d935e647c5a1c5d9909ec6528cf83cf7a4d00b0f74b0e4355900ed127e64baf6836cb8c18985a0bb48b28e2cddd0c83c05ecf088f45fdc814fd915e9207075dd8303281660411f70733f50a661d57d2dfd5a2a296313ba43c7571ee5c46e464826ccbe1a6d8726b67d0a4e56fc2ee76bf0b85c36dff559c1ecf33d4a32b97f81ac0fb3a1ef5fc8db98723f4cc5d2aff315ce2e0a4010112fb97e9b527f41bd67b2a66d43dd3586207f1d654948151cd44ca321e756c5cba9d44b9e8f724344c4e94814d82314394c28733b4877013d1e6cc237e4d74101c84f49ba9a7d00dcdb668b3c3b507e900887d9115aa991fc797609217b6a3de8f7bcb078659a668ec21166c538fe894eb143b3df42cafec0b8a583182ba2c8ae314afcdff3b215ccc60a21dc18b730d59d0d47ec0245c60a65e5440acc76c0dafc93ae373f8b6f56274e079d995ea79ab561fb4c15a5c307b19a617510b3c20c215e3da04ae61b9036685c3b105026d02ab1278da66627f11990970f347d22e47170894f02c2769f5aa0d5f6db46cf3ee996c68ede1dea816bf49158eb9a3a68ea6f613d4c4edd46a9b295637a4c6b2c8c3fe690d61090ad3aa6ea10321e6b559d6a453f716bf19860ca76fe01e8d8e794643beaf0bf322a0771494a2645a95016531daaf5c7a21b4db01c558749e3e159d952b02652d5f81a59fccaf8ae3f280e727c965e1d3fe67ee427e1fe64f1aab09032d7a09f5aaee06c2d4a34a897c1134d9a220e8e0c9b7fb935ca4401aeb6942732c99b8401ff2aca2398249c590f0cfa0d5639e22ecf1aacee33491a5a4e2d78882659dc06d3f0186b09ff8f4bbec1b6e161d164c9a8e3cafa1ed2278a2c8b283a85988884acd6484b618395181c9ba38abe4f7c57aef001fff311fb36504a8b11e9ae46272f810111dcbb5a62478691b84eb9ecdbb514a69646b4ed801f3e8b78e913b89de9cd902244d9cddf12244db728227795977a1814d065e8752d885edf1b4d65d427ac0550bba5417281eb56c05753720dc997c56a08c44a1332f4b46569e13c0568187d8cd7ac97a158c5720167da760119e015bdf1db7d893e0e4a5e40bf0254db2ec91155413d9cfd912a0242e6d27bb974a01444d99436296944c4dee492cbc1a086f250db52ccd47cf478b501332138f086fd367ba991573affd6bc0382975ff0bd10eeba529c6d9dfc12d987ebc49b7954053fecd8d1725f77d75704fcb258c836faf56b7d1a04702903b5a0a7c4c217feaa9b2dcdda821d7eada0da9766cb4996ebeff3fcb283897ae568417b4bda3e3c4dc729a39ec3e4274184316e842adf06e6a528231d82d3c2ddbf9fefbd06f749602089161601e4093f67c4cfd1e8aca4167104346836752cce382ba0868226f0d9428dfce013ed1da11469c158678cd9c8fbed77cde8287702e8bcb3a5f0b12caeb141701747caf5a6d9e694dbb6c24295241a1aed81a7d7e49e22fc0e4a22756e4548e1a222f3da9d318a387db1ab0d8e54a62bc9d2d48a50e98d7db21c18322e3032dfa2d5df302015bcb687910ac3a23708fb32b3128b03f653dae55d9b7370de05305bf6d5e54ee9488f2e426ce857a5fa9b33c3863b5810a1dd8664aac0b703439ca0d038c18b2c63fa24ce3575b5c4f42430088b140e7fbbf1420712f8bf92043c01bc522774d50a33da91a2f22e476bc05dc5d8a308a9829357e1b15477e171c960dec328cd521dcc3c8330ccdf52910b11223069e672ef024fe761a618befd11814951b2015da51ed54193c22d1d6836a6d706f4a42af4ab275ddb9f6ded2339722c9f3fd029b5304c30b07b0fbc0dd092a386b502f802aafd202f554242caa1059f85c7e41fc1d1b866b4349facaba4255b0f849b225b10a513d496c6ce70ba6cbdf166992fb329cf1f5ceed998770d56174de6f724881cdac946eb34d1c506f8ba86cc69b97d90c8b2a0e4400b54debe16e69c6654d2b9f1d36b34f80272169cbcfeed61c5a22f146da42a9b3b9411cd790b2a8b569c7554557e55e555d10b0d0474d75ce281cd59fa3701545170407dc76070bc03e81f6367175d54da3f9dc3d10534fd8869fea87afb0c7f4c527066fb025c2ebed3f5d8bbae1082a2cb5acb1b7bc659ec2ce0f95ff10d8ba2cb1a3ffe56fcd2e4eac18b5216cad870c9b81f4c29acdf211990dff82d7ad422d52e7f8d8b097358a596dd3f19dad9315fb5c51f1f9ed9a0095a396d7ee36c07d1320aaaa3df05d120362dd8490ce469a55b89b0b1bed5fe317edfa1c0e19106046396ab0934af72be7be909835f651a153c2bf208269ee4270067ee0c6dc0e66a52c7340c6d86da2e5dda9dd30d8f7a34e931b7625a30efb196ea2b8b1a1fac2d3250791c79f3ac92a92684107218119ef83d5374e4d78538b497f7ccc8425ea5cd1b7512f0ee1ba2bd1c5981b9f7741164743808341b91cafa456038417a15c049f2169a44e87cc50fb549a62cdaf0cbe85a4bba4af70adb5d479dca07fc654ad1105120b877c4d66f979e6149a7ceb655888f4b51d4d4f5e6b3a82e00bd423b23d334856ed1997562cca85921dfcc512cd01bffa23b5b88053c7d279720057a0933029fdbc049f8ceef897411a919a624198bea23c89b3211c6c84fd77712c9de5b38cf2cd73423ed15de063ead87a817cb85bbbd8e58ac46a202ce112babb60f648eab22a3e9a71e702d8a5e01192136bc1ef4a619d4d0310ac9c14e8d0e80ff9dcaf887dce2795a48416f4e64ae0188a67cb9d1abc3f1e85157bf3aeb6dbd3f6ae40257f95ec3005d530def59031e6360f6468c30a4cd34514240e08a8cc08961bdbaab75590a5692043c17b8cc3d6780d955c4f1792b781a93f45612b932e221210f17429b00b4b35008145482f218abab9870c30e191d0871727ae944c6ed1571978477328fd986509f1276fa6adad31fc978fc5e96db5b7404db0e7086d5b373be097a1390c8a92e617be7848e0856f5a5e53d4376f12c3967fddfe04ff868cd428131ef2444b573d0e7e7899b2a5a869a2ed19da1b2b70453b883e74394feb55f53ccb510e5e0965e2828492022a8a7f88c6f31c5bc6d72f41dca8744a54c562b22401a5dc368d5ae15980f0da0554a0ec133d8bcc023abb40646344e6d17f486dde77ebb0fe3e49ce0acb6afb6e11cf70d874de6c7c2b484e57efde757ac154c4d53ac149bc8b77f414808b2a8b71a3091a81c3710e2a9d36de5747066a9b54cca337b10ea947944079de1791066e959b3192d15ea7959bc1bb39663dd9cef5dbd1f36f20d6fe7b0949c37b7ae135ef57e70de21042b54266ebe7a743089a783920aa537d88f09208d8b392a4fe77d24793fd3484bf6de780b65b2b3fcdcecaffc48000d252076a2d44fde6c283ac595e0f99f8f389780271ec6852f3f63608b47183942aa757f07421b718522199772b50f07580b7e4e98b848e6d5f6d1d784e7b8b8994d0f2b66bd1ea465724f6ab50fc4157215ed830be3e792b0c908a61ae01875698cef994dcf63b8447532893ef274cc25b7a8230840d1d442bc30f3eccce9485472ab1b3ae7a20a7d40089e7d7287048de485c6ade633549feb12cfec21f13e9b93877f32302dc77ebf0bd6f20325c6590236c9c0eaf156777b282724361d3099eb116948601a6f41f5abf30834ed32338f169e4002b3d026231a48a70bef6d6b72cf3df05dfba0b03e4a357ca678b885f3f542c8fc195b52b4ae1e34df456fc42d28021c8ee01c3cc9ec2b6612d17044c5ad99431c9dd7c65155c85b8e0e8760b300f60e4e41e141743820c73b011acbfeb514662c53121e0e8d5e752eb1e8c639dae88638e4ef0334e50374d508e8b31a74acd35801724e8be6f70cd5f0b3c67854283912626aa3d8f2d861a2813752bb55059354e09025da3184235f983808bc11dd8371668c39d49360a4e81ce740d03cf7a4926726b908468029eb280c08f6ab1f32fde9b9beab2ad2fd2217c8c0946e928e49d8e6f901478ab904994568bd4bcca65a92ea0ac847efaf359dcce8517cca9e42c62506ccd0e8732256e1b0250603d41223da7346b75962b6129b46665962307d9563b9813049b0c4d099ee2b31e19544cd33a34392f9a1db0ccd83c7c7ed9598f484247a2d591f0851bd728d13607891ad099345082e1592e7de18e938315063c05cb5cfda080aa52b2ef8e12134c8015dd4287f456aec4b3a842b858e4e7fe6ac348cb0c17360cc32910022ce688921394672bfa1017c757c0cbb871bd85206f64d3c4530c1c6eee1435f61b0356813951920a5626a4a1ba512eb232940c80ba154db09a4782075e87c5cd399bdf80f8a09358b22c0dc5a65f3af50db313913b5bfc6b70d93104f4ea4707ec5c6413e96a849bb9ce589060b725689d5b4ebba4b5306c0d795eb505495ff90675b2dbbf023381e3271c5631ce9be67ef2d838684d3178625ed2d5be716e72fc965c690602f36295f64baaa5507984d45e3250971d9c0f97211b6e67e44a431bf3e7c09566de3f59fd7289ca0dbe7dcaccc49b6e68d8ea5fe81d2b9f793848c2b35196ee684d15d026e802013ca54a2798ada5b29e4d5fba9398ebcd5ab3db9baad6ac6b702375e8d3dffbf6ed5ec7794ec8b28b88b5a5edf578858ec65deb1b6c4c2ee4bde05c8325f9d3ff17a72db12083265590da06ab3f875b0735971ebe7a0048d4767e330647796454572423045047011cfc903a82dde9bbd4338319785fd38c34e19014a2bd6a920f6480c39aa17de8790334c562cfb61494a90dc14a50a95f01a2a82185e63d9190f0caa75a3daeb79f8025848e472da38c13036ce84eb48a79d0b0d1267a7c5ad0733d0bb050603142edeb4a06044d17427b781b27039abe21b17024b3f273903c4a7401957c90709df19a4451e404221ab48f05ac0914e0556086e15447f7e90309edd83a96a7f9ec3bdd37c87e8970f10043441363f3f769bdc48e299662b229b781c53f7d00a7d39bd8eb771662932fddc90d40a2becfec6c0206fff2a6a8ba62f933111591fefb4367cbab6bcc840d8bdd7e052925a878bc1d1369f88629f75c4729e2c7036f652dea484396fd48124f4187d144429aa57e9106d214e7dc212db4365ac8f4e0b3d24134113d1250b3afd606ad1bf7a141affefcd99530f6640e9dde85108b04474ebd1ab8bd673b51ce328dd4e3cdb314f0c8f962e3106b68589df552e11e7903f87527778c3fef9f4fcef42f7822c7ba86ec3e69ab27316a8f96ee6b9ccca6ac3ab346815144563d07b9be14af51fc21cce51dca2aec0910a5d29a8703331df63198139f9004459a0d90638ef7534c9028ed620e2faca92fcecd3aa57cbaadecbc7a0a9159fefd2ee89f793007820d3418991d907e61baa1fc668ee4f8ddff5c77cf488059b9a9b0f5a277b28842588e75270c1e77fe0d9263e940809a7bf95224078a6804448f2c4ea20521cc7b2171de2603585228bbc91a398df4dd927f690972a8ad928167649d34b116bdb020574c04370ed6da5e7f928bfdf263cf1591a4fb63ec147d880d0555e40c022092959e0e7e9f86014334f7afc874940e1f9d15d61db7c8d45ad7698db4b495d238494df84f7074352761afc8f4dc48da95174cd84f9fc02c0f3da4d53e685159ebab0c2a6e2a7af29fb8cd5b555f091e9d20ac014d8e7a32e34b3a030ff6937ca54596ffa865199e49c4e5257b6a5a843ae49bb2c8a58789c4639fd6e769b086f174d0b1f96a187a41b0f5656b8b80237aa8066169d12eb690944835ef2f9160212ec62378a09d43153c9ef9fef570953dabec02a51439575079e680d23b5a8bfe370020ff32a5909aa828f3b5bdb6fcc8af6d75b9f8ae112eefe561f51602a97225b3580264d105ec6fba8dc052d6f9e2000be6ee3c077f6020aee3d52ab39069c4015d8d9355386e7566dbf237d00b0f9326de98cae0fe1c44c4bcf047ccde6a4baf9a7f8b8d533bab5f2dcbea68193da8289a5d068c162002e93047de2d35e4f07cc52b6a65cbf66f8b536b1aba664e41fa7f67e7823b70894dd5937649a7c0a199526f9928bdf722e8aa444c01c8e31e8882a80d5d7ecedffde4637795161d06d9be4960d40ee103a3ca9aba9ae5e4d9beaa8c18b415d7e790c966213f8dd29d4b54ee55cd580d06b99427ead75fed4d1b1ce42a4ba29a9f41039f542d130eb2a331c41ca853941393e9bd1f7596d963e66506c4e06371334b65b79cfb677d61b6bfce635894c06f9ae1d6b5e9144d0c10622a57a934cbca5f6df39240ddba8073ce6fdc8454b74e43fb229e9f7b5450aa98ba4b85c0b14415cdd4433a0ac0ce309c52d7ad733d845952cc7246bdb406ac822d95096e90d814baa71821cb4e39ec432163f6f305c4fb76c6561cb2923dde27c17e5339145b47fb9bfe450c052d893b99e4f7302364433932e4a5e26b0184387bdb403c6e26e646dcf3ea58269f083ee1911b759e9af8d141c0a6cd24a1473194c228bf562426ae37667ea055cd4fd8b7f6c91b77040e239189a79607acbfa7f1038e3187ac3f9f4eec9bf1ce4f04b67a4aeafff2ed629e6ee031d7679774afa270bbb784175cb0a7644fffacbf40438177bb03ee10ee53346403c1a284430bfdd0de66af05430fe8413a26d6bd791c7bf4ebd1acf637098711efa7eae8a6e73aff547a421587cbf508c9b5271e8a5057d136dff739a1fc05f45ef44d553e2b95ff1eccce39b7c5a8447ae1b78a4a6bdb4a09505a7d8f25280ce2a7cde2f6268062a07c8c3985a0136001bbdb602d5713543e8389debcac84df0f156f61dcf2c3e3e462e49b39d3f16c009f8cecfeab0ee65b2a5ef168a9f21ae25e4061a1c2df63a409ab85a4506a2eee736139612ff79044f62bab0a4750e56dde97248eaf9d745346f5a4d6173849ccc8d5f02c2bd55886162c8a795332c2673c7c857f5d689fd37cba093c0ee588926a1f7f5a071ea3452340d41597682663f39de020bcc3b60b0f2c2a3890a4c893d41f26c7097e679a1bc798c3d4bae849079048866861b2305b8f7e9a4a111607c9ba33fa594b7922cbb620de516aa172e6b0d41c033f890110644963578e61e6eaca32cd2e57caf1825fb93bc6f09705f06dbb88160168ac5fa76296042e17b5cccd9c3720032882ff476ff7000ed4dad02d3186dc25bf0b41b02fc53f5a292fe25a4fac97afe7965a377a9fd09779d3e5eed756bc10b6b61bcdd2d354b43ae5cbdc75a2bdeb3a18b6736ffb671d5d1ba2fd8ed4430fca2edd450aad22c253f88805e2bfb44dc8d4a617f37f49bfeadc8b8a97b69f40ed43003ca5166785b30ce424a07026d0563d3624b9e585045b675d6f88af2f2650b0a863ac375b916ef185a765479f0392e82b1fc2c59c513b167383d6704629dbda1392dda331023d02c5379d0573c7b3edcb730b3f3cff125217befbde59652ca246584074d07580746320713d115f6efcb79c4d8398c0a696811fb8f161b4ac638dc9672bb94c7de85d409ebb17320a5443207fb66451e29d163b74618e76c8d1efb8ff65890635e038243192e13aa3d09276358e289e88a8b89ea10c456bfd76b074de4f9b5d62ded9980c3d13770f4e72e98bdf41c30fbbef454a8e1a763b7d66f10cb8473497966a6492e0b6369e462ff0eea3dadad991765cfdf2457f233f7d6124e32dbe06da5c2c9189688a5114ac3d4c5ac13cf3a33c59dd1692fbdd3da7c9a8a9b96b3fd1de89cc9134f3ba7a5d576fe80ca2b355666f369aa8ca394a336b7a320bdd5e6ebc9c9e916576e9bb3d3c0dc3d719cbc76823033a5a1c8aa524ad90e020eed6e5b314867edeead0739daa7e368bd4a5a6d7733ac6d574a99d17a86a33da59436b576d4a7b596a3b46a1d05b1ecada3603d2339ed4caeb5d64a67d6d7959d2caed5522f5c4a29a574aa524a596badb5562ff294b56a980911194ac9504a260d194ac9504aa64c1a329492212aa30d7112c76a3808f57e64d8478fa60c671680016b43397f3e85644efb0b9e0b2db6c7b4cdb6e0b3b47155051438ceebd19cf34e68c9c26915f734d055630d6431a95c6834b4032171b43f7d0b21731ac914125a80c7a389ebaac469d13d9f4353680aa986c8546b8d6a427c35e31acf4f8b9e4bc920e9124fcf52fca4ac1c4824f1a33c82f59c488c9933e69c530236c4d0303ddd508689d6a444492899dfc4738e538ad1112c871fe7d2e4b2f9386363a6ecf264c9044a82708202d49a94499432b36676b3835c2e170fd31b520288899a49b09fde4b930b2945e68cd9657ece897482a04963ce3969d83c0d973f3c0da741430a134fc367783d34da490d92124dbec6b3d75393b3a7bc9e9c8a42c6a71ce5f5a45028f7bc1e54f6a204f15ee79cd7d3d56c79ce2513cff9e6f5709b4fc9b3d56836afa95ef3aa6945535e4b0204afcde035c75e8ff601d2d0e31b24b47cf655e1ba520550bebcc5625c3aa0043de5e95cf434262a86a1dc7b7dd8c205cd099cd0e204d6bad488bf4d90f99bfa7befbd4fb0ecf82d96780bf298fd090e7ffde27ba99080bbf7de7b594eae08c20cab595e13a323db164e5d132c48b426ae89971c300b6584b6262c38920135925ec91f71ee02043008426a1206d0cbc94f08582043e4c48720169a849c9400a8014c8c9c2001c4c216474e9e48c2020c8c6aceb09ab55a926d5e221991428430b088b20598dcbd443232832422224cf9090a80999c7a89f433f4c50f124ffc40e12c2a9c8ca1095119436528a1b12e7d0447d4aade9609218b3c4e8b2717dbc4e4d3bf2ef26c59b98133d6a2f530296b3e8ba40b94c773eb228bf254b756ecaaff2856cefa9defbdd8859e0be93e50d5a2f5e0c81224436d2d097eccf116477ceb2d5abff19166aef8c287232e578b3a8fc67d5db65b89a399ba09123298ca70e5600229685c689ac660da62362c571966dba25a9dcee974ceef7a67860d25b78f5c0d25198bdc9e5d467ad0d57458ab614f81984d6dbd6066a90e101062b94b5d91658b1d7e39fefbc27de1beb8900497f558fa419f66901018114c245dcff51ed02dcd39bb55c9e35ca22658bf49a1ca505b94d8dbfba99f30cef99b42736922993ba6d2c4d14adf48be5b1cee7a08390dd1272257d1cb08cc8fd4c83775b5d84a734787d163cc2a6aa3986c435a5a4899e8ca4b6e400daf81ef837c4f81c8344fe5ac431910276338c2c818466328b9b8202aa2a34498248941248653bf60cc9827a630929e8ee88f112e308ac0782ae3e933901f080864a466a5d3cf34c9a7e9edb125a963a3c2f17a86a8b5d62aa7d3d945e8104dd3d4dedf5376eaa686758cba6a0f5121fab2e16d1acda514a3445a795b25a34396070934d44343f410ee21cad44df488aeda312c2f1db986a8100da2afef1b1a1a72ad00c263a74cfd31313149a61a86b0d323fa7d97c7d3a1efa3b6bab223629eb9d6229e007044ca5b8b268f19a988230178eb9bd763712de18857099400838594297489985a6bbd7992479694357ec479eb7289b75e7126810adefab7e4ad7bef48a4129c1173344009a4a126ae2d4b6468112788626b0e2290c04494f1d5b3a326967873f563f7b58aaf4844dc60f4d56db64ddd0f752888afd8fab0be1889b1394ba7c77810be7eb92ba3648a122c3708c5944c716448496c042a00b1a4a40b20158496104999ae8c5e896d1a2a6fede4412a8900f6d6dbf5226491062644b691921d0905c5c893525a6b6d254a7d299ca199acd43b0d6b476186f9f5254df333f46b91390d93396d43961842501ef1df681c74fb0cfde3acf9d622736a97e9332db616c9a342af7a8c18305eacf826244c4628500dbb89f369516cba847de0640c4a9c80f102230999ba1565fbd2b7a2dc33295545b65e613926501f75524f1b4ed89c3c351967f2d48425f41c75b6a24c7f86da0364be01648e0d9fa3ab38796daba595565aab05a9137db24ecf3c51273379a430aa449774cc64eb29bf6ec1ceb90c95023d3f9239d4fdb90b6af2a88aa437a1fa388fde8b9f312fd87c7a2798900a1b70bdf819e382f1c7a3fa68a4443cf50e1ca90d638b9982872dc4f450bb9ae480c482a7def1a74e943a5198cca14e614e79a44ed4a99337757aea488410947b86dbde0d7db2734939e8ca488b64e486f5518bd4c71c96671ed1d65affb99ea7516647cd534debd6b954388b64ce9469349350c2f3ba0c0c4d7120ab03459c1651a107bfb528c5a8c529472ddaec5b53ae97bb20933cc11b2d5acf204eaf2c0b9438accf10640e94b7d979b48e0cb717e4c92473cd79e1640c565e62573aa350f2f376ceafe79cf34eebd65a2c28161c754ed6306b9a38a4903a66986d51253b76c5624bb228e72862619c33a543928aa2fbf7e55cf47d2e242a8cf260b7b021dade03ba859faed3d3cde92967b41919519eed888a1f679435c13823a7ad4ace9ae60eae0989630ba9837b42e650a7463267883c72464f7d33a23c0d83e5cf45f1c7cd6886238bba165444e22029112bc5eb2079b420ba72cd1d163671507769413e04c128b5520cd156bdce84a44a4891ba85cd1dd9d3c4419dba164479e813623cb530091be229bd22f494a67ecc96640ef5322dd2cc296b6a91d2316b921486f3e74d14e98970ab2bf2a6183386081afaaa62a4e90a11a22b36c03a06548a10ba62435191e6f055ede029f68b4e9eda524b8d24f258b52c5b142f8f88cb4a749f9883be0d67f3957105ebbf3aaf87528ea31dfe6810875112e9a56be0248f386585ebb42ee348c963ad49c04bf77e988180a41ab13c561a366080687fb8bbbf5fbd33b106ddc7820d3a8c73630fcce4117fddcbe604b9060f073b747043c2d286854a67c991f2583de8a42aab168ff0d966e70be797f5e086d27ce5072c9d7f0902019e6c96f2511e2b88036673251cc019d939620949494a4a5c66d69522a961ad1f783dd5034a716a98002080a7dc45041b2fdd032f64e3d54baf60371ba857edaa7cbb1a68b028c256de13364410800e00bc748e881bf39512411e7108f57573268fb547cf11bf9e50109b624c4fe711ab7d7a3ddc00c258c794478c03e7fc7deea2c89a2fdc83bff4400679c40408ea845445373627050802238fd58397ce8dd065d747c0f325c4f79da1fea42474b5836e5eeee0965db493457d960e0fba9a35a6aa481e717e52a73c6ea3ca54990dcdbd837fcb22675511271c47bbc3584addde7b25186bedbcf25e6b6dadaa5aa59492524a697777eb349d61ed30febeee9e362fa90447a9e5e5ea65d5ba9f86e30cdf614d15f93e8d410c2c92dfe418c460bc6169cf51fc35fb5a29a55d6fd42c7bea17dbea9cd7d3dd466bf52c08e69c93ca7b9db22e9d5d6bad1a94c9e0386fe0b0c2a6b47691a758bbc8bc5dd5a2740dcae4e9b8c5fc72529ab95a25adf5de7b6ba594d6ec95b9f6da5a6bd55cdab95d8b6515d265aaefd3b67a2de6bc32da56b39a6badf55acc755e190f4b9e35f33a6bd5b86dd3327bc95cbfb6d6cc6b9d30d8b56450489cc471ae69ad813797a20b558a9a735a87bb70a4e135d5f7691d963ac2b983a250e36bea8e976da28f4f18176a21e6b84d7bade332ceb3365ece53e2a01fe86eab92af732994ddb814d8e3b3010cb28794a7739b95a2a65d97a207e6a62d4d58a5ce759dd763dd9b3b54ee58e917d549a9a3276c09d6e459dab33a795af0c70a7a2ef584101c1753923c28805053acf84c8eb179db658c278ce0a919a454f514c7a9e32a9e7aa6fe35d1c55377249e22393186d1d3536f297982de6e915f473c15a47ed8a1b3e20955840f1c97208f092642b07561eab0e8a0f9a880897be12d4bdbd22babb8cb8bae2413311f7c52006302063f3419b97af0b1c2c8a8071e7cae10322a010f3e312123293bf87081195d09f2d9f2649368c0c5899c7a896483183a10c94174caf825121120a62042048e75f9d571c660a8a4d7e1f74d27b80a562f05196cd76e3f417e8741ec6fa0abcfcbf4585a2f05d902cf1b94cf49aeadd7c33927bf10c1010636e09f1d7e248fcf3df2f8fe2087782d244a86915d24151f19327f21b9a03c124c2ff50e75ecf61ed12e7287b467465be6b1cb1ef398cb637bc563dfbae49a9caab42937e7061b80372d7c426e1ed0adeb1cf806fe8542a60e2598e2490e5a1414b49e68524b94d74f4bc890ee86d613940fc95460a5f544f331075d217b89969c280f8bae700aa6d43b35eea36db2461f1ead11c67e9fc84c3d63dbaae48cebaa64ef477f295bd5ebf1b9a17e9d83b0c6e80a7b06de50df20ac4c4d7485bd82c92f649fe82d7a7c891edfa1c7d7f5f8be1edfa0c76e63168be4c9fce6b1db29bd73d43b358edd26491ded1f76492d938d8faa1fad91063e5a2a1ebb7d519e2cb446f87fb42fb03ac99c6a46aeb06357961ac6e3ba4457d89f62c9a37db5973cd6a5c7d8ab1592875597a48e49231c3f3259cc58bd7c3351235532b74774855d7a12b86e8de80a3b8fa64979a444449cd68d9eda22d3f0b19f28914d980ac74c54c3f1c35b953c5aa3948fd5db3b98e11b0df0468bd81bbc115bc42e9f01a9b0fac6254fecfd243eb5881bcd63dfb6e4544d78420eab13c83d57ad95c730db84d43c1af2680f92c85928e4490b995f0f85c8319e285af282c9d5ca42ecae9634616e3fbd94134d049916b5883d1552a21631f64b947d70f619e00cf37f481d9b63f7a13ccd4457d8714e61e750a0fc0d94df4cd825b6fdf4f98de6b9d449af3095d22bdc44e66007e50e7a84c48167cf6d4bb6b676addfdced582cd11a69e196ecdf1b68034d9489e9e808069bb1212712a71165fa8d62fc7dce8302a13fcee7b6701cc2f43ee61005b14f30887dab5129bd6ac72115cafe45dbd712722c91bb27f2f4ab9467488d90c917d47ec8d2c49205f038ba99d685deb1dffe02d0b7cf97440193058c7c177d3b0cbd93999424795b6951ef8cd40895d23bd4c9b77737bd14ea1b6997af42fef68e873c9d47d3a3ad67fcc0c918b87079bd5e499cecbd768bead5722057f0c909f2250cf2acc19bad1952f08547af107f5459a194822d4a90b6cc0029055470607008b01553fcde9b44149a8e3a73ac00fa5a3b89134014e32c35e1a46f7e578a7c2c588a319d398382f602054f38bc709072c3d367003f9014b5010542568ee0f2d2ca112fa0f19b19194315463f473724f919ea19d8ae497ec65b6fa30204215d41f2d665116f2d75ba02e5c72e7aebba42c58f3de5ad9d6d9bacf0f58ebdd6553b640fca4f90c67333e90529c8a0797b7611dedfc673d36341f3ee6aafbcdced5a0be19194a6e0f670d8e099107c830078db610f9b947d04e9951dc149cebc1b49061a7d967111d2a29d209216a36fb083f71d72032579eb1f2c6951e2c7b9f401985cbd4738416925e8a5b74292d46225cb4b6f85ab85b20048567cca793427bd9e9437889de835b0bb3661fc04717ce6e998c9de09f4a3b802835f7e823bcf496e6eb2ceaa859f731bd24f5083e7384e7a0270411e7da83e9b1883a3086b7ae9e998495af2d33914cc043f4104fcf474ccc078a8f1bd42167a6d3d2d4b969fa0cd679e0928ef10b7e63ce8cd747933e705718338bc3d7f6bae037163253f41033cc7693ec1d9d1e95d97cf35d6b4c7a1750c66ae81a38f769486a588c14f90009f8155e6d010843eaa03471f5fd8655d9662ca4fb0009f819dccf911a47e56c1f80902e039e9ad90b578a73441f319de4cef97f3a078f47143eb13ec6e28b5b002cac151a565cb4f90f519a881a30534d087eafb06eaa8052f85ccfd2f289194927c8633e585207e82e14b6f85cc259682c84ff07b892d853d75bfa0449a22f617df5c9748515cffe0550f84f31b02998f0a479b4779d722762e93b351362080f01287a30fd5639fe1383c77935ef0d24b013b0daf711e3dbb098af017f452b8a10ccea3db6380e633ac1ecab9eb61efc0f92660e7c0f91c9e586250b68892dfddb44ba4242b2f91b018f113bce990019acb1645781b3fbdae459473d43be1b62009a416bc94621291b493a246218f8465e92798e3bb934851bc7e821fbcf452981b9a414db24703a2b1209ffed2d7c4f7216617cc300df0a6ebba5c3b1478a36929f046736d626d0678c339e79b731c5803e2c61c28df03b78e4e303ec1b994042848f593531e9b60687cf1aa1db2e73304c14249e6f56991bc0d225a1332c7e1a87aec5cf7dc8979b4e4d1b863b11853ac29e6147bdad1f2e29238a80d1b8f026de85c81478c375c446346b1a3182cb684029d9317dc41e6e040cd97ab45eb63b55e8af0e2c48b142f53bc24e96879519239f2b9bbfae9ad1e05ae1ed7a6a6a332f248e56533fcd16203c55c73fe0cd1bc0ba2a7855c665353513657d03c3b613e9a3e4a41f389a4458d869f6e83fc741cf167467dd84c14d8403a5e720fd11f5d6c8ca39e29682ea4458dca167dd864e7d10d94f35cd609c9951cc244b9e833922bed0a2800f05acef3681498f318942a787a097b89d465cb5ff1fa0f5e227591f29cd669e06c0a9bba145104d1b4ce659d06cea7a32b623bb449d64dd488af8e99acb92c0a421fb502ca37405f86d94def84ce35ce51e31606a13f9d73ebf54c07e14a96e102d3fd65389d66538b5665258f3e6cc2116716678fa45fb12c5bd4326e03c7efb7e975285be6e8e94cf753bb94d0b491dea12678eb5369168591517e7d7a5a389f269a89e425c99c4eca8c9b4b8f85e94e7a678e38484b5497d50ba2c29135def0e969e1db67e6bd834275a89a02c709e4538836f1b4931b37a68b3635925e59b7363d28cff7a1c2cc7edf2f160a3d2a6c003fca2d131bb7804af5d35b6cd15a950d68a4c84cd37a32db87b72ee50863f3f0d6fb8824c13a0ec71f8fa7d69a57c3006a3a923a2e3d821e71c32ecd91d4a185fdd2e9925d0852c1ce688777ce39a7ca6f03e970c9b8f2a0181cc37b7de2b468e7b401279a5e596fcda7b7de320686d2f374cb7a27e91eb3e9ad6b7367be756d86b66d87dd3d7dc020dd42d5622e7030c08035d1c2d0a2b52fc0d0a2d5c01c39509895434bbece594785e3073e47f3cf557ee3c60be78652bede8937faa5853e3e8e428b3a54e47b820a3e2dda51e543fccce96d816a5909bda3eda0dcde70b4c05f9f5c4d2da0455b82064e47813e7eb468bd877c9518294f01f58e9d28b7fea3772447bd9e6906956ac187ea512ffc0cc7394e478152f3f1f3c17a1cba4079a63c62593bc1348f8d4fb7311bf035f6ab815ab41bfc04259252166f2d90ccb17e25bf28400515578a145d314274a548100541ca6597edb89c2ca1c6a57fde0898e1d2bb1a0464976e933397dfdc9185aaf98df91167ee58491c7646e8a1386d0d88e92a4bbab2b2f581972cadcfa2deb961c01c737c367f1cef4b691e969559e6371bb54ddbfcef78b9ab6930f40ee79b11a9a3bab5ae0f2ffcca34c47963b264075b953c30d0150c94a731ced7fbfbfa0556c03b08a88786fdea320fe319b628c5021c8a88690103072db67001c5481364c8c08829a264b1c1c9ac4c492c0bc5124058e9258ba6af8edd71b22c82b8588a135e9d91c5ebeb972f6fad95ec3858108de0d3996441c4054b5d50b9610cfa848932342c8ce044d1b26035ab0373c60757181c7c180a134410511813bcc244e941284cd21108588185b102041038620af365070854390ab3050f548ec28c910304a8307d354b61352bca8f1850641a2f917ed26071430f4d727d897403098c18d1e58627696e90f2c31d01ca4285e3acfc7047b63280b250e1b828595c2e233680968881c2868d0fc9880d20d7123150d8b00145cc754ea65259a5d539314c9a74680919c215910255a69794e9ced6789d3dafabf1e6161d949ca0256488a6248a2459e4eebcc65acf7377eebc1a8bf20e47cf6f4620ed27b40ca3e75c8327c8cf35ed1c38c2f039e49c07f57cc2c42c91f97bcdfcbdb79f832a79ec180338bf01e3faf5eb9cedbae92fd3df8ec9ce42f2d0eb5507c943c306d3abebb5c7f8f0372cf3d7c72ac46da1d650c8e4c23485a92564c846054a4b0317326446085ad587cc2f925a4f524ebd86d6061b803588aeae6b0056a126e13a05ebab48f63ce5637dd5787b69bf28cf34fcfb824638662eb0163f4ed88b0bc7d48c70acae26e1067dcd8bf2b417b9ba391c5bcc5fe75ef5f51de34290abd39ee1f811c9f56738ba9099b40488574bc8900d8a0fad27d387cc145cd17a9272ffa8e4b1632160c1b9b763134657d72f1ef353afc92e6174c6955e082687b94e5dbde3f9756aa4773abfde31a963fbeb0d46eab87fc3f1eb2ffee6e6e2efd85ab080f29b145232749e72947b9ed2209c4abdea6eead407369816af7b6037b578bd03fbcced588bb7c77419b09d5abcd733a516efd2bd1e02963aa4c2827389b1c1b9c46c6564e1b632b2282063b744327669e7c4d22b9808902035408310960e175abcb5928ab7d60f80c3ddd039af013318c4aa5a5ce13a0e715ab4dfa7815fd6b44e2a2053df52b9e67a0d28e50afc361c9c3983d8e7401c15c7398fc6a07dae3b2e03f33b9f5e0fc63d1e8a0b551d289f66dbd488641a9e401dd72fa13bb9a32345b9430089a50e96ccb1ae52b1b20b6bae098ec894295b1954a8e08cd475b5495bd21fab4d8b99579f4b9e04a84fd8e80e4a1ded46fc0cfd33f45b2d896cadcd42ae660244965afc2f43418380b250e1a86099b2f9b724872046bea68750648ae937edf480861afc1cbda0a14dca921d9c704438224b2ce162441811652b632b830922b62a990a9d9146738a06e40fa9c3c65b0f2275c8ef495e328738e21979b528640119968c028f164340ca4b4b34bcd1ac07c92fa985eb47ac85ebabedb14e85c821189169add685fe9ac81ab6529cf81a560a2583415ab4aedc2f5d79cb001089c37a0d7fc81ceb1c9c208ffe35ab2e843e43e41fd631ce4ed65a4b438bd67f380d3fc21fd4696302280b150e0cb7440c1436c2d8b8a19ebd06fbdc504f79f69b94d7f80cf73e2a2160e11a8950074dc941720688025d59af01adb5b65abfd5390faad6bab5d67a2a64512c99456dcedfe7f54bf6f10305f6a02b6b9d26e5ead662c0ba0fa9a3bf71fe7c9664787f41ef258ebd55b060fbe284c8921e63230c14ce35440c60c6bc9a7208ba612c81a523de709c4f6593f9d8f5681fcdc3d2116f388e6c1a6dbae9e9e441f274109d403c6da78e01c993e94aeae09eba0fa9a37ef3279341bd83b2b0837c64ce03e48a3a8bae288bf53d2da8d32b8aa3e4116f3fe69f8eb73272ff985fdab6211199f66811ca8f1e48799447d80c182eef4aac0d883c666fcf9e045269d2a449d3aa2d64978b490d6d5a3b22fbc8829247dcdd587032862f498a94c6a83f5e8620f535ef3a07727da401871ba8f116a494524a432099b7822c3d0c643e760e879e0aa31602b93ee2e93ed7418c7f8621902c6442bf7012a79b2a2ddc5c7aee398f6ea9bc0b8b741de6b6ceafd7aef39f1a5a5df893726f0b81648e352628cfc0142acca173da85120cdbb9e7cdeadd9c5e89d0ac67f7a4938657c88bb195d01b88b73072b0bc9e59adb5f3a66a5eb34c63d54bfdc3517553de58a73818cf6ffab8f1d3592de668517a074359ceb00653a6dead754dd7a0647052aee44803f5ea3fd64720c058c38fd22509928451c88fb2a6907f86e38f9febd47f6ca5610e5feb877aed1bfe50ff09c71f6f4306d4fc0ca524806cd51426fee9429e4caf610ea96d812438e2f086d9e29c7399b3b9901a5a5bbb0c41ea03c97cd47c03f4997460f3bb85456a70b58a081992a64a165d80310619695a9bffd4d0dac29fceb9300492b9740b32d9864cd7d150d0cb08111b5a45649ad6ab466b0b73d8fc670b2f38fe781b6e60e4f0b57e36e79c8639e0d60fa62be943648c888c1f2e63ba94f1a4f5f3a47d0ba9cb1b1287d21e8e887ecc4743eea4fd907d74169625260fec4157ed1d8893701044a6432d8a7d5d903af0b7bf30a50ecebb8af1dc4490a7cdb6853917b528851aa1c92315a2453b45429489cc69bf61ca54c85f680474deee0215ea9d9132f9f6a644dfde4e2813a9c33bf0463b42f57dde8114a8574d5f1f6c91c7a654322dea1d3a4a399dfab0348221db4969b13da66971a38ad3b7d6a12cd6b7731ca5aea72727a7a69cf4a8348d1656410b99220800000100c314000028100c08c5429148200fe464df0314000b85903a72549bcb836910a3200a32c0184208008000000800801087aaa60800c804c07847778a62af42045c3eefb1395633e29e034b5cdf2546325fbc9c514f576782761573019d19b546730653acc2cc978365d94273680b7ab0d6ba402a841a45626b2a7826cc0148433ad8c14b87bdb74671d85c2fc8e1cd5df4eff07fc2f3af20fe69ede617637829b6f1ac2acea81d7b731e23d615868225d8d30e4a2fd73a9ee00fdb3bb0379f2c623787d6ff0e60bde4e2429651c41054f1b8e5eb177d93487f1a85c27fffeb02c5ee47001de08d4d4e3da1a43b78d0cd36823dfcfd63ab1559e12971e51e16ad1d9aac40d1b8a1d5c36535fd152cdc1dd743a6d1e713dd022c657f81aa1b1ddbb6ffcae518ad2be036bceaf2921aa2705002f800c7774a43b0ce527d08b6496bed3e58b2761805597beb0c54416617d55f1b56af38d66223fbd0a748bfc1abad4d37eb1cb6c53d2572046012dbc8ad1bb71d254c3a3cb7c2e3dafb5f5a980f5c0bcf895fafada1b01c51473e5f878fa12557bf4d03819c452e6f12e2930139c8d49e428e443fa2428e924dc486bc24fa881878a5eb7e4cac4db4c33e138c559a01664d15c9de976c24c17b5706157cccb889fe8b74a68fdc3dc5d1e105186a265886585229a734336ddc1636a4af7ccaaca6ddc215b168432cb21f5cc0beff97ed10668377117741ea4e0f3bd6094655b7986652629084ecb289add5684280d798e06fe7c76f2dd87b0b80c6d881dede7223cf0df9aabd8beb883623568337f4eabd45978e1e8874268ec27d758f2532d17ba33b412f940e2c3aa0f4ddacc85d4d89299fdb772c99897e86f4d6737bd32d3df748eec647ee3edc273419315e634e5a6c633eb08a285b4d240cd05aab26cd03c1faa733e8e2ddf046250cc643a48e2f4b14500262a0095c55191d8b7e95851ca50daefed250b591c12e1f27cea70f3844a68eaa475d344ce97aef58357f5a422136c8d1fe0da71686bef4fecd995dd063a9faef2bda19214a5b53976c43765fec464fd51921955d1cb6be50b676617246b8478ca199345ed4fe1a90006ac71abdd7e67b3b1780ddfa7087d73d18fc125f72379742ea53aa3087501ed05505f77d03e141d17fdca58a194ae6d0c3040397839e50c2346a68db07d05c2dfa9d7f84c1cf3973f67a0f7a382238e01e438756988ad898382dec85da89415f9d93bad46179f09ec8ef6e037a8ac7145f753d6528ebfe58bb482feed01572e5f6413e4f7eb147d9e7570bc205523acbbe61a3cb0387a5b206768dc06055259084c297f7d579bb1dc111afb5defbbf1d15ee906a5e81033acca506cb4a6e9468ed0563273e2d88d221c33e56bdb1c7160e48a876ce33926373eaf2aa82588be50b23e6366c5704446ae843ca862cdfec095680aab539b47e3f445bdf47b92032a3487f5b76d1e2202c3282bc794d2f216d7b16bf4593d654868899018f277eae3f8faba52e7c31aeaae28fdd02f09d4032d3c3b7b30e9411460b3cab5d78d182d63484b6cb23b69315305a9d9a496b9899c4defdcca32ab49c06efa833c6e110e30e0e8acc1ba2ea4561595cef8a4bb8bc6a5520ef01a4ff440c6bfd79a6d175045316452ce210924922315e8d66b83a70966a8f2962788b7730a48439c0c57b50a3163d96adcaf00e8c58928bf5e783eee9f7b9533683224120d8c6fbce093b5cf4e17bd49cd8ec0dc92480420e5ea6fa84c455798b19cccaf848dce911cba782654134648acd0024ba76416ea60957934c9b2586926a42e08bcc6a3915093a968ed2eaf9561160d5b5a798c41377d03a62ebd9ea92c56e65eaa1e918bb67ad93c4d8c0b7e91209736a37da56e81c540a097037024cb036586efa74a4262ca2d657bba891bea062f9026b07ffcb72aaee241b57c1d563027cdfcda26064625d9adcb55825ca7cd8ab0de4595c62f72e236d5595f588094b439dd8b73177fafc8b8518787ffe52df8a56d030a1819e651fcdea99b504db92a225d1202c6c09f9a13c11231a443ff9b99efa069efd92979f4f702dc291b11f316fdc25965832d7605c31193a2947ff72dc8dd500b70802f66daea38bda1eb816f1d2eb0a28fc2411f77a7d5445cd181120e65663e9ec3d12b9b088f9a365f215c0ced12e609c478f0f8bd0fa58d2f5dfecff35d7e121921b90809b93198aa87ba951c80be1f90036629d5b15c67cebf3d496f120e9df73c60bb3b831906e7825194d91319d9ba2b65720eec3e7e3292168157621f2796903e8cb0cd5ad2b5f85f5a1fdcaa42772ee681b7c3a0209ed17218475fa3928b0401e2bad58841677bc944569126e3f1d148abec182d675042ec67a6f1be04dc4716bf184b398c903621717c280132166226e5f549901c16d963e80b4d295543bcb52fbd3e57f548ddfa59c460ddc5a1efce7908f3af2647087f57258507ea2661a66c937bb28509516795888da0695c34e116d433e305ec12cf9d6912e881c2f8a76b1e2e4ecf4742f3118656312552ce3da13a8f37b4e846503f51520ce9d76b10f2419ee8d88b5e4715bad2ddaf1ad1ae58436353cf49b1a719577186b4bd0c48403564039398b9bd6054b8bf13732349794951afcc2adc2265cc215a8e7c17a2516c9a325940469611fc5ea0aed01c03d8d035ddf7fde924dd6b32b8866256f35fca8886f5a4153c445366f61c0bb452a2ff470b0c4f1ed6dd9bd229998be2910743241261156fbb9feda06160c6201a02782ca826232e4f799922bec0f2794a16588fa930952dc4b3cde1ac6a174df06ff9eaf4e46c7caa56040a429ce1a79f15828970cf01a5c806fd636ead0e9df1953890bde4c8fa4639c05db3e0fc9bc0078c67e52683aba9d5528ec84864fbf4e42879d1ac22c28f0977d2c5cc565455db7c7a7fb5160ce50a67a58ad1e6ef4eae88de23df15a9043b9b5297179c238abd060b40798bca8731db0557b35b51c8304a9d7fb63017622a05e2b0ef967f29d1dda46d5b740d2b9f72b4b4f3ec7829eef860d9217b54045dce60b23d4bc8921e5f33caf44bbbe4c05b55fd24d3c00a7f2fff1bfc02e6c2ccd077a2cd8fffbdf1d54245da179e3a1269fee5b49c77123fea85bba483f55a507b8d50f512c4566c2787a59514b02af6c508fcb0082fed5dd2a26b356ba7ef692c9dd18b6e59500b7524c2cb0722b25d082593da662e301b0d6c39769bfaea7f3ab1244e95c9fce51f95c75b11e383cc210e55194832dc2c4b5bc9a977ff0e205beccea0a7bb4ebd82d1bc3a9fd819da5cd48f959ce2c7298ca44bfa02023e4de912c2ba61389de414c837c8ce7bd587017ae64da958b875084bb77c306b8a0c8520dfddce7e072cc0eed5e62364336c02a841efe26f0bfbc79ca321c8eb8ac8935678c599cc85c898673ca03fa93d052917a94364561bd32d3cefd43de8c5656b538d2e151e9bf018f170ebf7f2a8b5a31a79bf049a3fbc9b00e45dce6d81b8d9b4f45e4053b6c741a8a3e1bb364ec15b7718d488fc3c59449992aaf97a1e24d108166cc200a653607ba74325e1b8f0ec9cb25a87c15b4188aa8fd4673e0d68c56067ed2ea874065176af3ed165484b2fc8b0d2f78c80d7aba42ef9d66e3619d3da9d10bb6562604d5adc509b5dad6be2c0205cc915c8f099118c4d0b0bdec8dfda7d266da81ae89f8a6eb30c3e515b8bd846d985c463fad024185eef147a81aaa23b4b761955b027711d49655df8854ec2ccb62206a45f8763634ff0374b5e02737791f02bb47edfb037296d897de719e91d50b92b27ec7d44debbb2776cef3d762408c1466ccdd991d906cb0586f0947fab9987aba1ed5b7beb899f20401f53a79c084d4abeacd3777a60c137220248aeec16e8db96666627e3c4f1b8a5edaaac1535925a8b17ab9595336c800c368f078dd7c497526858b2f330c953a18d1f199550d5b13b709f66255c42c90748c4d884dd8934a82d7c832674990e2c530523a1d9b70f7dad0da3190be9e8486735baab7af0c6a39cbf1f98f67fecfd9fcd81dc4d9d396b7d5862fb0effae3052bb49f27c3c06e46b2bb92977d4be43a32d513c89ef0644447d1697a3ead73d57eaba307b29d884289744de4937cb65864650997a207f7ac5d11c3553e3ca3005e683cb74e79be7b787c31d6bc2bc6fe1025d57cb72623819ae8eca69232971d645c381841b72de279ee4e7bb7f543841c264b85501bc492424bf1ab2184b7d2f4fe1d48450bac1e91512e1e6e117069f66298d3debb42b8999a261bc135446fa74d27219a5fbe8f45696577c87f6f7096c059546712b1fe7156b03d4428cb242d2b56290caccd8927aa18ab3f7db81bd0a6efc765266b76b4090cb6420f68aab7c5db9a54d8c326602dc6a0c27aa7689e159a148f494829b82bd2ae450757536e95c89b6b4da68e897fa20d4e737aa559493b19ad5675a451d27c785f034d5f3151cba0305840c72ea9cf0c6c3369a9abc998f035696f40605549c942c8c26df2591d8eeaf429fffe619f4f9afb78a10e57cf8e12b4298b459565b6f2ab3f7d5c13cb07ca53ebecf431881471fd49b0a6e0371c7266f4bd1529b546855c5406713d2373ae3a294c82ec1034012c956c95889f36afe71b77ff65bb7c0b05071e5f398d55c13537015f0b2f2f4d3c72bdb337addd708a41eaed5b626d09b49ce479e5be7676bd72ecbaf154a11d448ce1571091657c91cf73dd66c58160b61510851c17d90a9ccd9ffc435888c1f364dba51b11f65404ec8bbcdc945cf7b3d3ca1e758a130681879002bd0332d1149fd31bc9d1f2611754cc59d788b2b4bb40215abd0ca033e579292ea907f6b0f30dcc8540fd0ac55475698fe9fc28286208ab0d0fa1bbf09493889ee0ab19d4f7902815334182359be35cce0ba28918a8dba75202a470349f3cf4a8d00b9b765ec78bbca9679179bc57008ad28b77119b8ae8f0889d582318fa6ac6df0924af10399ca8f6c8047a88b651e3892d22d76e0166603796fd69522a3cb88c59ce36312830d16a88e35a43aae866d58d4c78b4c6f116de4fde286a8d9f2d8eef7d70cf9b28633e3760f046d331d15cb4aaaa766d4ee566fd6e0b1c15b29a870f6c335b3de247e267cd5020fb3c365dab1309af01107d8d4d69ef6824ef12d4b3bc5aac83bef9c636a27113e5bd09531089f5e514c09cbe9d80f8544dcf7bb2fa0f4f65548c2a827812dd36c1f49f2a85ba0337b1e278c26358b274335a3f9e632a2f75accb2bff78f45d8f3c142d34746abde7fb592668e568db0224aa35522c4fe6291670f0e0c7ec1b4e829bda17edc6cca97df589ff45b0aea3e9a6f70bd088d6c0959741423f87f3ec210c7fb93f79e393337d8e59f68ac40b652ef684322aeaea11affcc733676310be2860d8aa0183562eb00b198ec628ecca18edc841e533fa1a31b7a98dae68d094a3396b319997e289ef389d09c251f23296332eb3750fbe3c0bc9ca3b30c10aac1af8a89140feb4560004e758844d71fc26693e5020a5d35da4648213283be0862223c3bacca945e27a0dbb90939ce7d91d5e2ce1e6d2097a28c9a3237d32580e3183187961661ff6771d74aecd538be3c0891d26f0bbd9693dabdb1ce18135f2d7db42833d7a390166c48968397abf9c058ce251b279ee9ffc4c7709ccb077c0d21d4c915ad87c9143300c3c36b277eac6c2929d903beb9d1ca6251aeee830fed76d63844d7b73805b8846ddc7be2d377dd8883064528f0d05219905a70b370113a01227cc8fd4463360be2c62f5093bd1f7881d51fa7b71c69fb1bb1f6ebf00504dd41594d168ee702d81b9c6441d31f97d587ed7abc3b70c382eda4e9d3f64e86010196b8613090d3ea64e7036fb9ab876d5390daada4c74c0dc4fe89e2ec0735d3cedc3754d7b922a6d40410e51a47022c6477f036564555ba430978216ea1681fcc3ea06efa7d32ce98ab73f4823771e2c9f022cc84143aa1bc3913f9b1867c4fd3a27c6eb1d9290cfd457907655d44addcd3ad2726dd351e98a0c2bc831745e3ddff79b9d228ad638ce92273290bdaf47eb54b2d457c6df2226981c5b41cddb291e14d48058de736720fa7151ea79a6bbdb90f3779159bbd577b011680c7a1fe3db4fb5bbcb2ca2b7008ea0d1c22970fd6bae591564070006488eb5cd0bdd12f3a477125293a1fc7515329b1c1be54f53999e874f522b4633c6276e5d27e02bcad0b75c2f4bca4529a44b8ad2231b608b280bb7d9d1771d1baffedc9dcd906edaa43dbf43bac2652cc1c78586e520da1574b3161e043e755680380a511748d8d6c7078d2cc0bb699d6b2ed7e2e4d6a2508536462894188f06f570c60f182a92882b643350c22b85eae96ec9cf1300cf7acb00e1aa2e29a3872975be0ad3f104a126e5d37e640e53bfe7aaae15e74393cbd9984c99b293e9ea4636423e811dcbc585e6a6be97db4f9e187887568ebe04ba8e47375044fe5fac39b7446dbb1b0b196530896fc00c0b012fdbe40d13e5f2172b2dc3af6cfbdd62acd0b13174e13cc126ca5b44c341cc43d9ffda0d0cafd4b8a54ca125724f653e4864d51a797b63037f48c261745311bf8d27c410b60228c13afb6c184965469f25ce033550bbb03ce70d5cf28a2f219f7a30ad2cd72ac3ee52dc9b56a0fb3e5d2bcd8120c1260649621968891b1f1de6a626e14d7bb2f8389faa8a9e97838cc2a67c23bdeb028f6862f1fde349915ac1e69d419e5740f5971f559a4be3a2da91338831fa8dda71568e160f06021dd75dcc772b6802c70aaa5588087ff01d5795baedace066395bf32e13dc7477559200d799c4c717f28a21b82945a1a4c4a077e89a149b94d891d2a377a66d6eeb3aa92dc1ecb576ed1241a96814a46da8ccafbcb081b5736d4e90a666c3368ba6792bef17b6e02e5840dafbbaef7df9df9d84fd950d4f0ab930e0d735d93dbc923f4f19341e447b2ce22fb27ceaeccc67dd6faba4550c78b61925cd7d2fd789e7e41fe6bdc7e451032a442f547a4e64ff4dcea090dfbe5eb2ed04f5427df0d8808ae5bb2e9fa79626f4e2c2a6ec2485e54f251424747308560e11a24343e02eff07ec4961221f799614b8713908596d8a400bf91e5d741db91bf1890c3856a7bba7876e1f6d3501850eaf899c0eb76b50fa51b65876989b8634215a663cc54439d5d27a4999d4fe8270a00a2b30046aec809dddd8368885324c129f3a3ecb8cec18db0f046de988643a34a533b52b5dd140b9df3897c8c0aea401f30ff0892df608b26c5e7eb3b17913026dbfe757a3e7fd88bef645700ce3947c6868e369e8e60eeaf4e746c6e3f409cd6fbb0beb404188aaa6f4c5eae5e8ff89312f6a7d8063c3e008fc34cd74f97e52431d42857dc5f7bf86e214f78389e2464658786b5889d33c91ab278d2add0122ec450ce51ec529e307fb46aa7f96e98f925119ef3bc7d836346338d18bf4859e9d67f907748675be65321a46f3312877a34ffeb3ae7500429de8bc423ea758a55279402155d106a446566f0d684d50b77cc97b4034ecfd11a059e4e91e5cd40a7a78276330ead47a3a32c7886b4e3ab94d2978ca64adde5453ebd46df2f766582a6ae39377da521439479d4e70f03bb70b101a21f8eaa988843762525236d4212d1d31785f3b7f16911f897a0b0d6c4acb63fe03feffdfbe821c0d908bdb83813558b9db6253abec82205adcfe71e401e0897f30f3fd192e534f26736359ab24a959baaee44c446eca96a1729e4b900624533c710c1a95314fb106f15729dd62b74b7345dc242ac46ad0114bff663fc011cc2c16dd093413758ad1246c435c796d434123d5798baff894a6c60626b60750c505840776e32000f44d18748ec3b38dc2a4ef87e1ee4f130e2768b38d45eee75eee9d7faa68889bf22295914c9b43eb80ca335ef4a09e841cb00b2ac34573b342d4722eaf837091d6b4220e1263290f006c2500534ca478a29504aecda8bc7e1090fd63d81a9815af311f338f49bffae5f206385e2bd2ab9d6ccea77fb1b1263ecb428dda194dd756b5fb13ce1ae19532d41669cca28711eb44c86718bfae91a382a1e8ca4e1e502e8686533c04aa4734cc189df5c12594c96eee18d21706858c350a3129a873f7c936755e8ab373a35d90b2ef271673359fba688050318a9644a66737e2b66603097e4005e783656d71eab1b5c79c7dd21453cecaf9e417534333e3c4953dec02c44da472495a0086e29a017e0c5fbdfaee1948d5e4ead29c78c52eaf14fafdf09ec09c7a53a6a8773cae0be90d2b75c3be34dc3c36b6df59dc148c0163f3480746fa027a32c953d04996d1c8beaa2fed6c835c9a56675d1f2a24e731d8cdfc809f20744cc0c56fb7e0139769bd057ae106d0487954bbe51579cc42b303df1f07e42ca58a41714cac5d669e43457c7c387d3fc83975088198b395fd3b4965c42c7b0d20e2d5b231d03ac30961d6b9fa1d12e73b7078799f8412ca3021b4045e3a6b34c976b281e327155f67e5d76489d4243eba0150d3fc9af300926debb7d394b6b121adcbc2a2351465ad06b497059430d46f970d0475cf3c8d605c16094316cdb2c6f7f6a6141f4d5ae01ea3f476502bb9fa2bc04fef37625d89614c480a3732cb6643b984549bf623d33b5ba9fd50a77e8f86edbbc83316810b0ce86f4cd2170aeb9d611ec3d8c718a83c7a20b79dde15dadb7530ded64d4b5dcf38fce242582329f9d6b2d70e7f78add99abfe700b3c0741d6ccd0cb5a8a5e913724fc3a89ba16547d2b3ee0c48e36c1a5dda14e740b8955e03debb344bfccb25c1888524de63c6804b546c419fecb95ea41ae7324275ace92a99695afd356abf5c32d432ae104654a61ceae1cb409c5ec0c6e13a513ea6e67de8101046365b749c25d29e4fb1e193c224dc03ec48d9aad7d9687478395062766f1964e7f75243c98db05269174f145149f816113382d8bf337d028b2ed03b98449e48f1c28f3dd3669d9c17a8a27fcd18d28abdbd3a5057f054a8746ee9fa172a9467a1e7941aefa9f38790b2878f2b85c4ac240b06d9019761ce37d8782db30fc6a6ed3094223a3b96efd290ccd85702a4ecb8dfe069aeee384281f705c1a1710fe9060439b05df3c3f7673f38b24fbb9cccb87ad2e5dc84a75dc77f2bb03a4bb700ffa82a017d09b48e6e1373015469c09357e0894aa22d3a0eb5ecfb078acb222d004e8e1b3f46652b419bedf149815b8cd143402f70220a76046c1c3cdfc8b28ed911a6ce754c718c20fed989007d07389648f2e4f85aad282f0ec26cfd5afdd8478320cdea21884a44e618d514eded2d18e5f51b7c7cbbbeac558751ea844d937d7f1c7664dd10408aa2b23bf87dc57f8f4cb64f04bb2108e6899ef2f7b2e449f3e429669dbd69c5ff705ec8d616781a512a602469f1880c6ac596237d602ce35fdc4d9021269a97fb8074c890fd117dbc587d5ac360906cc07f799d3f17abdd6496cc8a9ebaf5b8c2231097ceef6409e63f2a25cbe306f79b00ea9bab38bfaa9bae97b2a14f6a50fb2156c9331c6dfd2950524d1c0108dcf44aba1002ea6a1ea530eab216c731131b482f52ea75415fe8eabf4f11ada7036dd8081523a17b6010b5ea8ef0795bddeac1e7f42d710371f00d881eecc0d7e8e0900f02927764ca33070ebd12a841d6d3495b380a2fbc346423cc4b11a2fa1021bf567c3a8e3e9ac87f02cc16098bea6ede1074c527dadc29a80ed57ce3eb684659039462ceef603a9ec1dfcbc26832f5e3a27c3b7b8e02b297e8881d9a528a02d01fed9b3c1f8792a5f0570c8e261a5a29713bda9bc0fa4c9b5af332d0bc0988a883f9f1dd4b1e0238b7aa34aaee15f23a90849e7be6af8919888128abd00afa80e839852b88bfa0298f878e0a62a39af6140ea1cda4d37c8baabaf07498239a04deeeb59b8b7f8e43fac96c7e3e11ac7d6fb613d26643189e8c068cba9ac075ffbfd3ffefa4c8f26eb34bc914384b07aba06eb957a21a02402ec0b4ca122d3d00de6c16bd64b04d98ada1ca2c71bf3fda34c0cb603558337619a531f4e786224777da08fe0e54e083ea0f6a48c019fcce2edc4732b16aa203c2dc77eb7ff6b7047b524dd9bdb88b01fab841b4c3cad0ce22e7c8870d31bce93967f09583e635de14fbb8a10fe95aa6101dbc5c4c3b1a7a2722cee3b0e94bdf39ee8dd9608e6e22e92c6e2262907f72f0a5a2b7af8908ea9aa924e41d13cbba7cf1ed1841aec16051a2faed66cf96713f9b05e502dcc5722485ac11dbc3889a08112c5f6b8e72dd57905ecf8891d98ff4fa615b4fca0fe93f56a21e7831d0a3eb363d5ea20b2120942b434bf4c3586b3924d375442c59411d8f91790a16ba8f2bf8322b8631628b3cb201b08dc02eb2f54fc6721cb2beb47ff5f62d01ad019177dcf94bde373d58991cad74b0b37db45e97f03765eb7f06e8641305519801e46dd422aff8c65dd78ce8dc2ae80552e658876613ae24e1e082943fc6ec1f53ebf60bf8acde3e5f9ccba39f2e443c190286bb4b526e5fc38c69be2abd470f15e3505e9f9446dab80712ef019abbfdc16a3d5b818225313471c0b45314fd9706126bc85c3bae0b9f7aecfc80c7ab898fb4456797e9a748e94dd08ceff58f18441e8bd41df47a7022239ffacad6a79325f9421d08f4c81c621fdee3bd9185c78f1768aae42f9d6e74c5d4b33fe454a754ccbd5feae7efb687004e569d79af6cc538eda04341dcdc4c140e22ac17b5270cd37b712b6195f3c0c6c299984e78aaf3be5d8dbd785e18b0b58de4ec46038d545227615983a5ba217ab7a0d400b1624d9fa254b7d8e092f06646c9ea557de72b8dcecda8267603759dc58a7ee097566048cfa4580f790b0e9c2a8de1fc05b48ffaa20600a10388a77d44b4829569202fbe10e6e54dc0d4c39642b6b0f3253ef7dc764c896d897a0ac5ce077d7f2aecb22416ec44e3fcae0cf99f77ecf9e3aa85eb7a50a1bc5a279c40a45cd0732a99fa967fc870cde5cd9865a89362bd5af786349e737b70fe5c54f52bfdf90f829a78072007880b2df682906e611ddbab939104299c0bb78c182642f8909a93e58d3d56002a9242259e0a06a674af7854203f2ff8c55b8f3c911a140630ba6832e7ced3799fa6e2e4f7cb6b2efc26327e028aeb52865b8328bf2745145bd868b7b5fe7bb1c03bda037be8b13faaa9c9da5db6fcf055e7f0fd59ddf66006a1e2b33a815bfc0d1ee7df62545f359ae0a07e001ac56b59a019674b2e0edaf2567a35abb0b40c612f65c21af620c1a8783a09cda88c01c908f688c893cc0e90f70bafdb3a80c7dbfcc574e0a0eefa05637be9d9cfc8856527a829b0207d17ad486c881e0c8074e8e807734523d403e0c4e7dc0a0bb3eb84aaf01df34d2c00069a8d3646224a7f4bce96804ca74d02069812c538bc4772b01b63d1895fb7e7a0771ca22e6efa73d2516251da333310f095608b9b9c9a0f8d8b808268e3d710218289a1293df318ba543521561fb57ccd98eef73e7565c362319d07b57a5c67df699719a4ab70e51235c18d59dcc014df08b1d75653369dc16b7102f4cb534fa828efaef19eec0df9f10389cbb233c06631ff5eb4e25547b21bc5d25e09aefc978e98a5af91dd5a748431d774b0a1d38423d271da3a9e1731f858cfbb6286c152241a667b723024f135d2a9436a035c5633b420f38175f6ecffe8ad869a56c14c78f89712fd35c5357f71bfbdac3104642b5a62f134e7fc8e9f047dd925b4d0e9a709172ca6cd3c344dccf0b5d17f7f882e2b5c81c570bf855cda92d1d97bfe2f103ee264332660fa57807a58f9ab6530c7b6b984bbc3a7daacce621642513e85f37dbcd421e6adf5ae764b9b64c2fdc47187192c68f16f615ca7edf987d117739dc7920de9d2b7f917034b37444f488161133bcb609a6b586cb32d41817cb502f42c96ef625ef6ba7045cb4c8d1c10f8cee86805e63056848534e04b01889d5e7614c1c1d87f9194044906db2bbbcc96d88cbcac930bb02a56de121a107b51eb67c86d66db7b59879ed79faf887449a34573f4bd38525acd4a355852e0e6328aeff41343a7bd285a9515cccf7d27636e3a0f0e755eee1bf5d4c8a716e9212a7d36bd7250d6255d7868f75ceb2510d8a36a14d2abf7abc0bcf2e33585cc2bff3784b890f78fea584dbd84d886ceb93d8a1cf6829147f22daa19d85d5a006e01753f484a99461619a567f1729f286b51e8d3d4205be768d22ca07375905853e5cb8c5a4b3532625f0bb4a1563df02ad233fe0f1e3e88a791ec4e0c07e1d621a9f052c963aa6dde02df6722649340088c26c83ebeb53c49473d0822443767526aa422afce8852fac6080dd90ed81b0290d3f1d8b8e141ac258c26dc469736855636f63e0f251fa4184678bb039ce0aaf5247a5aec47d93d17344b0d701a1168df0926e7551c847111ea00f37ec79d0ab674b5c01a2762198df803b0998561ff956a8114ddeac273b53c808c5774c632e26a1344608e71cd720d901db9334eb6e36e4c27773d9cd0a40de072cf3bd71afef9b1bff0d01737a8dab3ef9dc8cfc89956dd50e5eea663b7e266ff042b22ce2add235ea5628469ad7b50eb988cf020d80fddf977df93f1031f74994cdb4d88c3310197406d0fc1379e3b91421596465040bd500e275b5ef1f77b4bb105afc2c4684e0c6d6abf6227f48e8057c184bf7313933141581e95489902f6f0ea86c643d9ba018febc98694093300f851d8ff52817f69c805c1fe3535bd9ddbbfc400e3c217543950a5c3bc99838e114fd55ea9200b228bac4e9d20d87c15564f00d143d1e00a45954053da15242bfdef7ca2cd69ff60fea8896ff9a4616d6ae84d9408ab8733a87a5e3d642e6bc92e16ef57243a359e83c51d5adf6cf5f51636c9fa8ecac699b2ce78669db8ebe04f43f38bb53adfece5ef666251bd4795bd689716086815ef76c0d8d228343c097efdd4632555de08c69e98e2f91738776ef88d203adf3552b503fd4381385f9f7e7340bc8381da712fb952709199bf570b45069903c77dcb608526e8882724dd1a459affae4d999a1267be00a1f2042ddd899a028be5331860f9b39d001ff509e243d9e636346ad4189c4fd9351d06d4ba128c1c4e91df7f96fd71859cd07c8d378927d0d1040a31184a141722cf8e96d72cadbec660c178944a7106cc3a1b97c824c741f33d137503c1e55575d538db5032717969c7fdcf89d5faa692fe9016f1c7b7477185a06ec6ed03a660b36ec115825628b22f8621fe895c04e36d6f97fb523295d70a2eb1ec2a1c5f8ec2fe9dcad70094b63b890b05bcd173407f092dc8373f25c1420ccde3bc5084c70d5eaf2b2b1995745e4cfec75fa6b882fd09c31e5d36e2a57056efa4d475bc18f007891f83337fd5a9cf262daefb57e56d830562622265b29067fcc42e64867fc71501cfad996841e60f10244b41ee01622fbdbc5615050b9be2b08b4fd7e4f6c06227f720a8d02c410595ffe8cc4aed707f022ecf917284a8d3e871c50cef30328f69c5c526138b14298070215994634fef1cc2213713e90bcda24767b84172513f066652b9074f34a0499a6cd0365769c1a3ff5fa10b3380c970adead64306c51cbfc2d4c44c8c6f2776028b49f11718466c3861e40cfc49a1860067629f36d52fcf1cb222958c8c65269a947067662bf24082adf5d0f3fd9d34938be4e22e1ecb8453df2dfdd0f81c3c52ef28270c1b08feada6f9ec6ddc177b2f24b515021dd74df595bcc35a7aa154bf6e770161d2969a54bee6c3dca42d7cc444372da1542581e840c4c729259e51fb6e753fea441b6c4197cc6d4d57d3b491d68e8e4ad2a8f4d10f99b930a28695aa80c109982d1540289cca45f7267699ac0ccdf594598d370b185a117ac3afa9764d9525b550d12dc6f2143d41137b21f1ed0b31fc430d934ea2a938fdd60ee85c742645f24c6770e3448b59e7344b6a561afc7a76fc1a2efa8da16fd3601b9a6843fc83990156f6746e81836fda5fadef4c52eb54da10792a8e6048592d0b5f7cabe31963ef48b4f0c68b0c4b6a729de7030fc0596904f1b0e25419a225f407768e8253a989fd4306fd71001408f80beb6d3e7bc30755cf9ed10f0a515cb8dac5d4a0939ae50fd5e7fbf71e0fff878bc88e040a46f7c47439f9dc6e9e8430572da2d4efebdbcb59a7df4473e9c6015a84b742c519a8b5b9933a58135dab4d0feea5f0efa413d57737b3dba0de981dfdf23aa51e08db8aa24a7d68ad2caa1283134045f444ce97473271c76572c90aff2b4f10d006149818047cf2a900ef0ef34a6406e1bb9f5e438040a6c27e2ec197c2357c8cec32e231abb48b20407994403688940c4b8d6a0f8470ad695d24aa00c083992857a00d5889d73265894a0307bbc546ba01bf17feb60e2dcf4123a721da5d59f5a47e0d08d949d19d20c5ac7d694b6417916501c89fb0518b0c5ab0be8b3d8f60f15eaadb2a65511273255853cce06e7616db6dc48e79c06e63492d5243690d52ec79a66a0f1ac65d5ea2737b324c0a8a1c72a12768e406d54f8fb5419387a270c6627bab9f3f1cb00774e639333d696ebf6666699a574a283270d17d05d68c8e2eca900eb5e72a7d0e6dbb5a7b23d4c2e99ed7808131b5b04cfa281fc0d38cc5677e55fa3eac13ba2b325f887698d59029138dd3afcec9f950c6578e573973e04e6302a33c7a0a0d10544ea43d5f7eb5b5badbeaf63d4fc2d636e19aecc54ec6a12048226a878b66ff7e35c114c438c0423982df94ada9f80506e3aafa4f90eee5220030d15b746d0ab45b37ed63bda7c0e7241a84a46d79a6c5bbffac788e9119845b83364aabd5e2c1fbb8909f23ffa56001db509ffa3ca57da35c7ccb14d1ad21f89c1735a016407d60518c5b6bbce4e79dadd126ae0f883d80723f9e2e8ccd75990b80529c04ff568059b527b5c82cbb2c14851e7b252464cde9531eddd886ba096c8a904b516ea01f06f80e682234a1071722cffcff7dfafefaa73b2431b31e88271bb7cb93a596e48470ef32d4bfa7486d904fdd7babd89e1756b850ba6318c68f05ef45c6b92ceb47833f2f81950a19ff39c0f1042be5a442ba6fdb738580713b0058618b4685e081a32c8208eed57d50fd0bf271d721eb5a0bec1e753066be82714a0b93aecbb729d0df8ea368741ebec11781c067a6d48821822b370186b2e1e6c20e7b2c4b0e55e7d6e1211a3fd6fa81adfd3a7fd114cee79fd75c7aea2dd2e2aa87632840b2c75d13a4631a87d73c7fed14ebc9f4f604d22c1408ff7d27504fe68e4d0e8860daff1b9cfcecb29a425a63e004b454deceaf5f6e94b49fc775400f1ae021c6b582774c18d280c7cf6732e455798c1f719a3c42e6adf011716a38deb6ca293a57a1d4a51f9412851db92d054f22edb91dfd62e6b52be3a64f92521238d6393565a46cf0fac72f38a3cdc2b60a6ebb3eff89b1b5db544941b46cf64d68ff555c8653cb86ba6753b3e3e87bfcf62aa140be722bc452cec56fc8647d8b01edc7071ba5a04aeb598a2eb5067dc4c375cc81f553a11d586f9bed470db9916d6431708ef4f3f162549b0d8192f36159f20235cad552e822d6f27fb9ca14b1bab94dee7cf81be67aaf913eff0e512b7904afe179466adf109bd74bc0c105251b91557f050b13ed4185b69292a9131b03298da5dfeffdd8be5dda7f65f838d0b6fec298c8c445dfe6421afffc3ab88207974af4deac3c9805243cbe41a85cecba93f8ab6d2ee0a7cf30b091fc739fb7850d190a7289a0c297207f87b159a0561d55400fc6de42bc18db19b0673d45d1fde93d6ad557011883186c0c99f01439e51a213fea6958e784b5d7a89b74a64910c758a38425b9b9e6891c32665313b825909ce7c5cc3498b061edb562b8da00b0d94e3112051023c63848087e41cb9e9d5ef30e6dc1c772c730e92c36a00fb5a76f3184113b3aa680459b4e4ecb6575644e27144f46c93e9c2bb359428dd05fac819963db353defac9ba605f6506ebdadf953895a60f23cf55c2ada02c20c16f4887385383602b23aa16a6b75940d19b404bbd5a2058905cc34b70dadc14519a119bbcabd533f47de6f4756944966a96aac379460aa55231692cbbbba35606d037561a4769f19962d01dd2de5ff4b17dfbc4a04cb20ec7e3ebcb0d8326e0d77e9bfb3ec0b17dec52dc2de60b47c1ec360e0162ddfc82018b50962a7a7efb97cc038347646b2ef453c6af4a9d3b7c9e0df8a5d9018dafeafae65d8b6022d0400ea512bb80f3a3dff9dbddd909c792d289fffd196ffcc3fdc3ed4597e182b1cacc9eeb6de434545066cbdb5fcfdf0b28205170da8032a104199b5451e6a65ea15c6898e681531dd096741dc3546f6fcac4cce11c429574065544d085c2bbc02807993f386b6060ee0b56caafba312fed026f524ceadfc55490d8f41160fb4ed3d702359b320c0ca62944a833e344a8d24079ade725b853b3ac979023504cda981810cfcd6b230540da59783ee0cd4cdd773c16b1aa68f52bccf825fc6bf701c73b73522efe067ae4762dfbaf4b6823c6cd7d522a9b84b597283cfe5ba748c42c1cf9227d8a28d37be1843c54e91e2a7fc5cbce2f689a1b79a4d88898f8afd619ee6883752eee43233b12570db76eb9fb8791bee3ff20c7b5e77fde9c64bd8e8c3146850cf0bb81d74f72ac26303a866811da35388113158a891cc2ed6746a5581aa163ba9c736031e37b54bfb6ff00b424e50102554109567aa16b814cb4ee905800c820287c1512bb241da79cb4f5eb276579a83746181a071f6215b3bcdc90cd057e17fb06e43e19d92ed01df4101d43306b60b4aabaf073e4d10a7844c0d47ccaa06b30fd437488921521de8d354da6d2af9ff5873e4ab190cdc9445e4d629b5bd56d866a7d292256d51804be07f35c336a2a53910aeb12ee3ca68221e00d3909a87a0cf76a55d4140d9c5701eaeb7d05c2475610268207ad0d674f56db3eb62d8e89d800655150174b8a4cf6c747124dc15c9798e5ba0dd62a04e8e67b82f7c950dbf8af6aa9197382704a911aff2e458ab934fd7fda4a5620dc02185e972c93cb2b8a8a8317fdef0a9e7ee03f1babaca7760a941114f43c96ea71bc00f532a6dd63fb497aa8a4421c63eac8ca722f636a27cbbf94ac3a81f000ceb3b97864acd43c2f07fcd2b55c30507b2ef1481f6387c33b5902175de5b8baca2be6f900af631c26ae1c93ad9404691d337188555b4aaf9a70820e53ee9caf1b2f284f62908287bc1abdb7d55357006326a6177890a79642b0a270e94cd629d65e0a1eed0e8d340e901c3d720bdc3a28f01a1876e26db30e0d0323111c7f8b0bfdda65e88a6da16b9af2938582a1a16e9f8eb054a01a50ecf05b2dc5a7619aa6249d865974dfa1f2c69c5524029eb3a05ff382b2573c30077485397975a9e6bfa649a4a8072b7ec42349991b30328d330c6e111aac471c664210ca01ca57db6ceb3b01d9c3196140459b42f70df7bd24d1bac7a753c014e3a407df854e157e11b833c19e613ab7e7da017e16c1ac9bb1df67236ab56c013f48504c3b2dd19931384cc055fddbe83351d074af7da1119538b4332be2ba8406ac94c7cbb2c7e98cb68f08265d17f94244c0dd88c957bc58cecd1313bc1e0f1e3b2361381f1b58920d6618890860db7a321c8724c41d826facc5c56f9705b41d3efda5fbe0f7ca3bdb93099250e495136d2f8211b88202684749f86f3d26820c6c7b0c367a1ca3dbfb31f80986b1c3389b4872593d31a84e6a25b131091974764e01452fb5270637e41bfcc5aaba6632e164e68a2811ec5d17f6b94cd79128a9512b3f2f7dff1f18132dc540b36f1f2ce798daff58ef873e1209e6e2ff9821f26101241e8f47ba58c52875d6ca85dcbd1b72238b540bc0a9c4c41ff33868aa0822c70a8870b08cb5d80914ef160a3378da4c388d1a7335363806bbaf1b0e9cd689327dddfdb327b894b091457748d3dc30e605d63abb2ab27606473b94801791e3d9d0692782546ec582337c490fe09943d3e99e46371c1f788810f32b94acdda5936304a585b3d8ebe64092d1b8f6249989785cf13c6ea70bbd94eba8f281e38bd796c424dbda62fd2f9801690e16b6ccd9b3ff9ae9897b245294ccb71f25effbe4f0256d3f514e532794e792e0fcd5b017a4a02e68b86b0d22a169a1d42b7e20da054ba4f8c4d65fb330f729231de9a258a44895c2f926e4b9b4d16befbb2ff1ae9147cafebbe32523788f504bdc1f95b9f0a5e87423867d9e2e3ee6a44211021d46db7cececa656ddf6338ea0c77719217f192881d7cec3f3a26eef04cf2b1937900bb38f79f45bc95777bbc11636232d8e198a9330be3ec4b4677afd2342b98a22d6285279b49b2f6372f259f84fc38536f3900a4d63351744894b4ae9825da6ef650e1dbde149230482f64abc1250aa1c51c4c304db7323de36c3e6a78de0a5fa496246ecefb657edd048221be03d15baec12e72e34a1727947a66acd961c35368361717ecf9177ea0f15bf4eeb7c60aa1a5baf6e1b4a2445842cc3f8b2078b62df2424e59ac2773075a749661cf085119f8a0d997c8ba1efd3b84aa090b4aeddc42c730500d295c1462e993c7c63b338402843a307e16b2409a6b4bab98505dcd4e53ce1b339ae071f938aacf44853dd9b66c17d5a85e81baead308543ee1e8a1b64badc316b1a0b250d36b5a8c992c45379fda70f3dac5382b687f470b91640b2aebc55cd681f9f24df4b9da3303a61fdb1fbfb1efb93f38193c6d08b48d0946a2a7190202d08b7f65eb7fdd1567da5541540bec7314a250e10a1b2d4b476cccb05764acd82858c857392f532b8eb1de95a82c9df013709342ece1a1371c210791ac5b45b70e0c3f0cd0ba6048e413dc458b593450e32c63edce10ac9ef21ad1b4dc825c1510c4aa3278bea3e8bf7b9893dc9fcdeb4a510b65679f608db85940bad7071b7f83bfcb61d08b211e05b255e8b022ee90812189a69873934cf8e94f469cfc7a7488d51132ab8ae55d90bff0d5f9370ea6dd847c4f2d4d54c8fb6825004dbc32d869a056e9cf3cf3d1e0967579520e3eac734eb2621576dd5ab1ceb9fbaedcb225468fd3df2b473abc7578dcc33786773c1da1ebfe2d2108018ae2f93d957f72016bd2fa30eb64c9b3b9df3046edb284a9e86523040beca619afbfa1fe873c786c0f4d1afbc71928f58fbd1bd3ee2f1ee929a5181c64fc24a351d58b5567b4cfbf0228ec373f0a15834f66191bb7ec622ba406f58ae6ce5637e79d7bc83c632350845dcb8fa14241ea1988f0c41ac20ed17d3ab20e5b721737417532e98891c164717f0ffa66b1f8473f8bb8a6d5d2933cf26b46420f794acdd8e904e22fa4cdb530d8c43be850c85ec143b21c3a6faa21bd41078a8e509e9fa09fc48d5747f37652790bc6f29b60adc9f0faebe7ccc21a69670c58023355c4da98852a2f9ed027db7ca2012bc6021ca6b6fea003423405a3c3330803e7f0debfdd0e7a568ea4e9ae51e930dda296f42ff213df04fd1a5420e567125d4f27dbe5adfc67f4e8544f78a1fc3c78507e5292bb970d1be158484d394607000656bcb5f27a830ff7cc4fdce386ab7ad67147cbc66fd57d56a909c3e850a4adbe8192bd1567310673579364780f5d7da7a17dd2ad247b35580961ee44d288d14f72c84167204f455490aa47a39f955b56be55068365f87bf1307b3fab238801fb59ca41283ad2c16f85ced17dec48590f925ee84396ce2ad70ac400381ca959ff1f4129840a932daab92112788bff75cbcf97abe50844bc4166fbe97b7922617b5dd81a91b9c0a8f46823cb168a75b5eb9aaac37e6260fc40fa3afaefaa5bce19e43d1575e4a0f9d332a29f123aab1a590182d7dc1c5624de05d4508acee1bf9ee36d6a33f3385f347f4a885be7b31e0d4a6bc8249a1641eb43f1c1e6994a2ea3b16eebdec04acde26a27d6aa9d7d0339968e7c8721729d85537e38118519fae8a41c965b23c0b7f5c65a38ef79dbef49cd8f975dc7f87759560ecbcc4026540d90a142e953e571f25927fffde1891b22e3c07c1861cf1f37759230586b499a8f4fe2fa31f5645eedf1841ba6527a492c42d6484b25b7e0c2dc4bea2a70e13459c34274e33def0535ff417a851539ee782ac5db3621073d814cb7acaadf1834c73bb36801f802b4b96acbfa4c5004fe59d2bd32a24576cda0f33b41fdce3ab5eeac4c47c8419b501e22c94532c1899f50743a4adb682ceced311479af705b43f718e08946112c486232f6de6ec16569d1da3ed57174bf973035b52fd4d780b3262a732c1001c35faedf21a1d691354bc3662ee43d9453e5d393070d32b7c62b9f14e0ffb845a6d0e1eb2618d2e1b91d20c36d601620d4c64fff067b9c54891e30824e5f77c1944e8eee66d624d69e5465d667c326a9a8ba9a2a3919ca3bcf9afa0d70300337a9a109c3b77e52e07420b161cb735f8a55dc7c695ac5cb8a2bcea0365560c74f8160b10e879693db13a131f9cb6094a16b4076ba397c4bdcbc011189a6dd73dc7e9483a42ddea5ac11a7b3c0aa9655150eba55a3ba56aba086b51585b9037283c6b65955417cc8a6b514fbce1da452ed2aa0a83fc019c85ce05de6900191589ed772623ad73283a92fbb9b07299c89dca21d452b6537a695a55b286fdfa2e37eb4dda913c7cdc96d8042659533c9707a72ddf0bdd652722739402817887bb96cd8ea77fedf9da12e51aeb58e837b41002d4b7f563ae1f07f355dca70179e36cc41e55f0fde64a823708ae088a69694d4cb5db5f756a26f21b99cd56fa04ed050dde746f06162869244a8605d766074d590e3b5d350f06b68d731be29532bd24979080d78aac31c207fe53614a9e74cb36e5f8b2e5a41bbfbe0783004c77a0a649e1ccdab450f1544688da6ddb016d10a819c2793158997924ecef636c34c36427c29f0648423a59aa0ba9860594c1629f69a5039731c898fda902e17f5ce62e541b56a84c6917cacf72cc67a137ff34927c58ff84b6c8584c68141b6d3fd3a7ab403ecbdd08dc1ca63d9ddb8c2de8e7a9fb6f625140dd123707110a326227ccbc7842bfd5aa9ed027fc155a2ef8da030a6386b3312270f548eefc6c88eb20f5c46663795dd9631dbfe45575d5fa9035af6546b47d679b02036cc01881feaaf032c5b23241b675b41801d8b37be5a8961849b9f56c79e0bda89d700f529926fa3eab15f7351ab8d67a5fae2f6a71630667ced0ad0f9d5a754ef5ec8045c8dc438aefe8c0795557b2db4a93ae0b410281acd793a37b0d66697e15c1ad2f244d537a554bf36d53e160aa8ee9a77eb2053a3ea6ef5d435bcaa77ea8c29e9a373862d17038b3f41b7e342cee7b9e180ce21ee0dbd5838e7e989153353138d77d4903631410ffb91777db7f5b9bebd5d66aec6594aae2ef16fbadf63cd0ed9af01dc57b02ed7f489ab03d5e2eba8caf5d04d511840dce48355be0da1c8c5f65caeb8149a6acb1b59b50a4d8903868729d148e8d4274d7e91cb16b59e82ab10c8c3d714f4f54926c3ac55eb97b72d4ba78b72815187fcebef017dbeeed57b062df85b7df8f28348760806fea24f8c1600b6e5c9ad7e17e32cff29d42cfcaec2457f856ab7f30cd1ae01d321914ab0733a8921566407954b9fba629c0448a6ccf3187fa62750b70c07d89db7702be336f1001b33360acc7a05f2cc374a4f70ad15ff34c52ded921bb5599e5b86ebbb1e41b3117c465946caabcd25666fd1d7edf75c0706e2ab513775f8c8a238c49eb3b0e9c6ae3aba42f60094b7c7cc8ec07834d272dd997f7f44183bab7f6f5178e20479b7216729750a18ebf5677e9a1319e0b0a1c22d9fe55adc259ffaaba8f34f3b131e006b8ffbf47e82d244a6804293a9139147953c8171e7b0be689c35ff633e54ac95e6719ea7ea5cfeaad03f31c63a8dfbe06578c1abc8569ce1f9a00d1ef61d165e0d3e3b347a0ce03d44f4335074d86ad6e6a40f692d9415a01dc76a88ebc9030d41118f33be2ac3146de9345858c0d06ae288f2a7b7ac75eef79d35c84d1a3fd42b5cb7faf16a2a9eab9dcb33059ab867ac513bca348e091af38ee6ed54de90dcac28c86168038b5f599e713240bda2c40402984ace1410fd9c8d4e8fc31570865c574290a98f5768761ed68258807aae184709bfa986db86fa690129e9305a74e884df6c5cd5b45bfdbcca3aa3dea13b9b8e982e1805d21044a969a370889cced618bb32ca38ee18efeab32246355104e21a51ade50290b3206c8cb419c844ea497bff09863dc0adb8f5c3a025dec5e51ea3eec5f3ab824a5955cf590db9a875f9dbb52e735b634d8cfe5f28615474c354f346a0bbc22ab5dae87da94742ea3e7bd28a3aa8f7b0cb9cba91401092aa77b608d3518b2b04a7f1e93e065be6ae931a0e7a6eceb93ea78e57788bfb59d3b2b45ddb286a513fd0a48103ce416d08dd331f771526473435079441ca0a060e40f393b4b3fe77e16b8d6bc1c94b0800756e852bc0ddffa73e8c897dfd3c332ba21c507aed811da3d0be39ff6597a0fe50135a74eddcb7c4f68c863cb1837e4a208af34d561e0d84a7a45fe854b961d0fb1492db9862ac80f5ee5eccac19583283524049dc578b0b8284daec6181e1d4b308b1500584e5ec0504563a1de8fc00ef25a685101547a2aff6ab62886ab5811f4fb00e2005dffd74a21dfbb8debd16188c701514c472d12ca0a93d5e1f575d02cbb6520077f997465f797a2527d4c6dd28f1d1e98419c45d76b78f2af5df5ed4ba5de31127e4f1056f075a72f716d77e2a8d3201b1dacb59d22a61ece1ffd3e3d8e1b87e08fc7890b850fadf1334853acd03b1feb2f824fbc771c050494fee381c7542730b597b5eca41af19d4f9b43c22cee22cb27ed6ae5e0606f772ff849918b7de30b08a57bf21a1b89dcaf66c999507d032610e45d5094d913e842a98144744ccfaca195bcf61b96f9a5b751ca651d0a4af77e835c3e09e0efaf6665efda482573842bfe235b0ea00437d914d93277f0d76c0c97a5fed00b014560b27cbaf94e8e2b343d8869d771c9baaa7963a4f769ec11ae617228b5fedf936d75b7fb9cfda1fd0228a066cddcfde670fef4749f7f3b5ca0133893db5839bb2f69c9cc42d0d9854259c05e179f466ca8f15d9ac52a0401c5d4dbfd1606268457b7af377bdef8524079ed339e267ae1a65478999821828a6fa57108ca3a780a382a55b0558c3136e3bd3fe451731eed7e855d713aab78e9ebec43e6310ea79c7a10ccd187c86d35e9deb96c5adb4826783d21840e3c36048b3f2f96ccef819d125ab0ea24d9807d0535f1c855753cfa7def4a2863a8be3d3d40cac6055abf27b738bdfdba734f729ddb8f894429c05ee3efe25bd1d030a8d5a8e78e0edabb5d667b9d2c5331727cf167c6d5058747388a59844f0157ca85c4730251dfe464324010691bf767e287b21337a01133f1230cfbbac12d43bb40967f3775306b13e6e4fd7097b8694287d46f1a8671fa20cf33d51665f89de15cd6b8d4362574c690ba57187839447c95f69f5120e51e4d95efb0760bfd2c4c8991e1a4a8c0b79d1d614ca444c928a56675ecdaa31aa90931451a4ea464984691d322041bd05ebc8635900f4447809e503a112068034374f2dd364e16a95b85ce610786446efa473d9a0e350be60208cce974a09bb991a6406227c92711c01c1106ceec16c7ef1b218d0285bfb34af34d7b8253083eecc5360a820daa4237e441f071fc464fefd4b27edb0f480ef192ae587fa99a805045574ad5a0dc5149808549b6bb7d73852040dce7cbf0ed5f0721bbdc5824f56bf3875bd756c258d104e1f36f94b1364aa26a2e49ce0a11c1fb9d5e8dcb886abe4f0f9d1f27c0716ed71b1342b3348a599e422f56858ed5a87093683a82fe03022a95e4aad209fcd48eb1059091fa0744853cd044e69ba6c29f460e9f4d8af0a10b7fafb4f5c9c70aaae6f688925618bbc27d09cad29bbd93c37dcf6a3c9ceb309efdd0dd21e25a83645fbbfb2b87a7e93407e31264f89f6af4ed3e4022f4640961cf9d098b56fcb129cf4971dc3b9b8fc70eccca2ef332252979afac760e20af6cf26c6d09b54b42290f17ff4a9eec01dab5aa5d463b5c55573b9c7290ee33b953cc781fe99c81154fbe121e5e66f1750d326827c263ea3a9681e5dc0256d2a52975d400fece0314c8335a32e59980537ba80cf416b433dd6b9df0314bebb17446d0646c629235c5c6393d1b0d157094a1cee84bb1aa393074dbe4f16852fbae8a09db910af7a3bd2adccfeaf013d98587c51c78e96653539b62d4c636398491758c1746ff273716d7e0d78e63aea748bf9a48237a589d9baffe2fb64244480a4014e341c969d8fe6077cff35c998149cea5bd1706c6cfc2de6531ad1aa84ecddc68ae1c37360b95ce355293b8295b9c804f72c761f3b57ef2471fc2e183e90d14afdc70c9ef4e98e0b46643596e995263606c3867f45daee83114e74e50c3149d69fc933c0ed990789aa0b71f54b1c5a01a8afca063e29f4152054595a21e101d395a491ee8c6d9bf1d91eae4913a09d90910ac0513b10b0fc6513e17f96584c7d9cfa6bc86ab1ed366df18e1b4abc30d0efe08f1d3680096bf9b376ff81c43d04dd4cc802601329b3b26b435d2ec04c12fe278c66d20979941b91ab1ac55ace047b55014c0ede4ee29d0d99086c2821556f4a91179d56cd5ec1feaf0054a9fc0ce0af4ec6c917f156a639d91629985b13542d569483751a3cc134e22d614e84dd2049aab3ec31297a79acfdd5b2e77fc3b287baccee5157fcdaa1a2cdd6614f9db583b6abd06e90d50885a23489e7a9857472fefc7a5c475352a3aa08ad5d2d18845d8f0cb2f8859f2d758f0f67af6116888b3c5ade1e2ee78ced3e5f0bfe25940940b99e7bf1e45fb87f843462f3fbb7dfd8eda26c8af81b4b4ac7160a2e7f887edaef3a81912b5cd859c81e11946c72f6ffd0168437131f03a5340e714066e67f66b2ab2f55ed676e84fb27ba9428905ced0a5f7a119ace3a840a9c9af0d903e399ca912505c12cc4f3e6cdaba7e11bbb3135b4b7e36677fd6859830084d8c4b0e74ccd02d03157c021dfd255ff3537e405e3f1d0fe836c2f1cb4deebb392cc02e6d4c05c2dd910d0ffd18e42f674647bf1440f5166266f5d52be6fd9539fc52d487b82459e73b5e0ca251216d76c69e0fb4c4019e9b4a501ccb53158a967955c81eeece059a5b0207fc28eda87de2470627f8af7185a818b9893a24c81f3920a25e196d668589492cc434bde85ba8926c5fcb23c57f3d301937d59731a0a3d2008c28a5324098b2bbd263c0f9a1074fdabe4a85121b72a74d0b1314385c757be1a86b50537998f3efb14999ab9c69afd4fad3badc61eed9499025a69283ac0bb55bdea481d09ad2569bde73c6f6927e76035ee3a7f80c49cde86b0cff1bdd4cd575391b271755e2eb54e6191c58bfec1961029f178aa74497bfdb42aa6e59bc16d58c95073ac95842b62b46fdcbc309d9ee4b424dcaa48bb17c5dc6240e5b6a2ef2c3dba724a79f4ef1490a8797fad94073897f428eb08cc76b86a6bfd465a694e3d7c33fd9efd540e9c72d2ca80743774e246d1c8d47e55be6853f5ae0029283a522f46f93fdac991513ff38b7471c802023738a479ebd9d38e638da04d557dfa8cd4573f8a3b2a13c19e6baf482e8d9bd0885a58cfbe4dc53c107ac456ecd7a087b3bea4276d52a1479441a00505c66377d6fe693682738494b3af989a84b6252287b2d78fccb585b410c90d849cfe568103712239c1704148bbda4b342fe07a46d7b0cec8046a04fa23ff468c009ca41c4565a93b432fe50b46ac56cfc0f4e1840c4894bd3357726ca7c36ac2625d48104b707e126dbac7bd7b49f8958d6af26797c3037fa6c6cc0346872f0c4ee63a8c76faf67cc06f3dc6800e99bd53c3bd80ab522e700c78b0b1e052220427042ab99e8d5920d0ba4a0789afab4ff41b19c0d004ede52fd750e36730b063c54713c06f4eefc3c7a3c396b6910303b55651867664b102a26208e9c012ec964a317dce1fb2c3685af643016533fbd608ac93ef43cd92bd09917b4b99524a018508f708df0842b10b283f09d80a7026ca1f6dd7c69db8c65251523dd29d47d943e3f628b548130a0df5cead0d2e413be2a33efa78247feaf4d5d928234d182baf073e507e2ab859430d7270a60d30747f770d48adeed3292b7b2c958783e3717b685c822653efb304b304b46ecfc9ee45001ea15f7a3cf855de4a51a5b75bca745945c0e3f13649f070910081b74942ebdcd3517785c242d5b059ceb033d592b5e373a64d15b43f643dff7cff1d9fa3faf8fd9ccaebaaeac358551feb78a3c171c1eb5ab8c9056b7596719c4179d75f1d44acf1679051bebfa68b4625dbcfa06d9a8cf125ef96338ceabe6bc7866dba76f917bb5ddd7c0119be7f9bbe84a9fd1d83c12a5f408698c43bcaca2085294354c608856d9763d1b58ed569669943c1e3510f87358ba2acedb185862e1e8623619eb03d98ba6a079d9373b04b3d974a3df34c116997b7b0b33b3fb118f34ef348275baf7cd8fc77cd196936b2f97d2e6a215ca8aed9a51b165073dd125ae01170707890e3f77fb6c7bcf1011097c054780447e22fdf3175d571aa70659bc756783539292635cfd6b8eb8a2fbd6e5df1d928321fc95a167fd398411d2ca9e5c0f11894443c90e190ede01c600237bcdf17ff8d07848448112335ad5a0384f11013edece710a09d1b1e37b5028e54dfd1ce06a3da72ac05b46b57b833f0c6e37df1db78abfdca95c7a0f6d5782ceacfab292f060d77e640abd6f6c531891e69da9176a41db5f66d47234790340fcfded2d89c9ae5ff3411ef91cfdf4d3be397489123acfa987635d4eab837f9cb27106b37d55022c94f2bf2973b41c39648d59be7a979f871b035a1fdcdbd65993bc0cbeadf1851485299b9b977c025008c9ab8b32c97eff29392bf5ddccccc1f9ddbdca4ca42757021703b46f624c68b538cc98a12121528474c1475868c19d4986804b7bbbbbbbbbbbb628290e0b3b31d37f1c8e9b0c8fa1387002f16e06aea6e29a39400309c6c3163e8b5acf164c46dddc8ed07caa072c3531151173750bac1e886a4309cfaece8b19391b9eba279970b2e0422caef33b2affb141b63d4589aa67dfbde55dfe2b66d31fa5744f66ee8d2dd37c61853bdec3451882863163251926127d34f9ca5b9dcd98948501c1276b056aecb65f4d9f136668ccdae038e893613edba4f868cc2704c945f3291f74800d8907af94154bf3d173fa005536c50f9db0f69514aed555f90f6b5e2fbf8cb83e4d78adf0882c8d7be2097bf3c09b87d12d027f555e9d00534e587bf9ab08419d22e873242640bf59fc925987224c3ca4e8c3136e9581500329a54f9a908c61893d0004510485f286d6962058c47c42f0c1369ac18c71655fe54c30555fe46b184991a0863c450e5cbb83748428818638cd10331c610c3a5c6d805e7504950e26a982c66d5c8a096a48005944c8c998c0d1d8ec814dd1023f38215349119a2c80260c82cc124ca0c2616706a22c3e5862f51646650a444068c1b88c898b1c102543c8911030e16f87284130401c058c2e40585872c4ba0b858da07644e4d929a8c692f64311b906c20c306a2346cf0c42436864912d4f2482d6a1e5f933146c9bc05b7756577a4fa737b715d712291cc51b8fd40184e2b706202bba1090c3064326a46d54c8ddf0bdb997aa46b0b488e7aa3c62f4c81f6c9ad9bf632ba103f5617e2e344fab1564434aca9fd610df46de07098a1494abb3f5a23bd758de1f60363c42c812d61d2637ca006514a9c94c8606d300e1cd0fd30d6b8ad4292daea1a6afc3589732fa979ae72724137c62825ff7e2dff50a0a9fd6d6533a4fc5ce88f31da3e8a7493730e628c51070be87ed27d77e516a594a1ac45bad8b030ae0eebf8816effec662835d3b959fb26d77df9752791dc5a382b92b342a3b78203da68a38d36826ccce58713638c5e39d2a7f281c7f766f6707804fed87275687751ca9e1da3267bf8a0b6ab1177706298b56be3152e80baa9fe3c9a67f7a34ea8bbbb7bb84cd9ddd7290046d058c3ae76cbfc3a64386e1fb79f31ca9f3f5b93114afafaf3c7285beef4246ec2f776c13f8747e09f3bf6c5dfa4b5bb7ffb87ee66f160f6ff68bbda8b3c61a41b54ddbbe3ae9432eeee8e4be3393f8489839cda6fcf693cc250ff9652fe87c03b48000c60445c84616262064668a0c90e34389343163b98e2454049f913ef24452bd0e287a41df84003154f8a4fc2d6eeee6167ecd27425873262ae8851014622ea01c64c51c516269808a20897c1961a30c1c1f184aaa0faf7f6e8da3121ae80820c8c95b07240f96ba5c0fe49aa2bb50bb4c0a28595ca7f02901061988490c2534480a2fddaf342c5ff218292b0bf886b5f0b3d2415db2e4998a95df73739b93a21fef869178ba084b6526817be166bc7c7441ab573e4b7eb5d3cdac5eb84a5490dd74989863e4d34b9be38e38aeedeb5cb9d992977c739a7cfe9cfc349a1daefcae572bc82c0bfc06da852deceeaf84f6efa967aeee9b19e3f8efbfdb39eb5e38fb48b3ea1fee1ec7cf8330bdc49c5384e0a0dbbba404fb3a62fbcd4dd528699caaabba50c3195ab91ff020afcdafb884976482843631bd53bc6ed07bc80925153a25423538dae3dafa426b58f5a8c5fa87d2e685c94518b316ada27bf7dc12b7f8575b1e3eaede12cd5df54fe4d6a1abf4ca5bcd5e9dac57146d6b6692b5e1dde38068573c518638c316ad23deeaed4b64ddb18ddbdbbbbb5f8b1bbffa8abd32cd69ccc3fdab5b4bb37d6c6d327b46b3f046ef7a04b4d4ac571aa94a66d8cabc9d9dc944a95da1c57f456673fceb66d4bb172ea4a7777df388c7126d95dc6a86952326fdba64929b79a252dae5edd7ca6acb15dedda326874cf9152935195d32eafc6e75d1fdecdae9bbda5e3563c68341937d50a38c6892915192783855e09796215d7b9bb0fe936329b18db2aa678a4562c16a5fe43687cb058354dc494a879bc86de44d58daaae8a53a53457a9542ae7544e44cf709b23e78ef628b56d5b75504043625c6e95d3a57efce5e3a3c2ea476a05e4bda254bb9a48232202f235eeab7e56af38a75d3f9b8771dac5dbca472af08fa69641798fea5543ed045381add68243bed6146e41d94588004155debc6264a4d2a2a6b9e611082866fdf191ca63236e83c2b33585e91e0f92a4b49556ea587be94d6b2828a82abfc734cf92a9f2f90c17b54bee88d1fed83ba8e03687cb21a3b3ca3258122c06c5240595bafdf6feb1d991aa9b31b5f1a91bd05aa183a13585e6190c62908bf852bb9b53e551cee11f23cb1145c366637b18ccbe787ba8b13c1d667b3aca5f1c420c34aace9fac0fbb29ab27ef612ff6c54fa64ce577352aff93f70ccabfb065bebd87937aefaf7e1a4ff5b1886b7afe2e5bf273dcf5d3190ab5b35379d67ef29eee992b6366820fd00f7ff1bc12e3591028a076f17fd0792cf3177f121495839bbb6b9aa6757c0f716aaf2ae020c7fd148750a2822d757e3fb51857c845705445fac5ef1fab7f44188a05f70a4490534a54881a6e540b322068b850a9c631228b585d1dd4c5e26949cb512c06ab61d80a29507e2d5f30ae82b4a6b0c0f717abc0055b53b45f9065441935dc99bb76a4e7e3af2b43b5178885ba92c52e3b10b4cb818a29a104ae288b448a18d515eb68294a110c3c298a13356428bb9483931a466e77a10122f01ef91de0bf998081e1ac6bc4909e86b1a268f547c2b0a2a51f70a8fe4466ad2f701b2ea31449f9236fc87e78cff4214d3274c5d03fb8e9a57e67474b7d3796d0709b90782472d73aaa8ad66906a2eee9fad5bfaa256e8041c3598dcc663bdb59ca7be6f7e41eeeb7c7c63daad4eaf403790ff7a9f8d5dffcd2bef0c6497ee107b53fb6b7363882c4c89c4dadbdccd45c3a6132543ba85ffd48bc8784f66242ec9e552d41bbf697e3c47b4eb0affe18a692271c90ac0e0fe12f88a328d155f79777797957d3de59ba74e9d2fd71982e6cc27c0cd61ad6aee62149049dc5269a18d2344dd38e905490180263831a59a4903dc1a4c687a218c8a198e44a524a29a5c6b47d318368484a29935c79028b35a6502286882e9c698a303da8be94012545b524a7abcbb483ac0cd72df93442b04147101d0307b34359ff392e1e06604206008b1504c8328500aaa05add25a62e71dd054b4ef0a07ddd25a62975abbbc474e44d96fa0a099ce1e405982b76f8618cff2b5b0f9a51d1126954839438bb03254ee567668900a4d0ad2e130f3708a3868d8728d5290ed30e666aaa2e130f5cd490fe5cc2b7d490f500335fa0aefcb0035292ebf0af7445ffd36c41f77763661cd89318f3182d95dd573e689e7bd54b6edd66bdd77d230e272326ef3d52aa714a793bb1976d979d9aa7bf9bff7d766a9efd7ed058a27fd050da11f6b9a95decd42eae5c436eaa1c26a9dbd51ecafbd347351f3d1b7e72eeb86df536de115f7d8d27a45d71e58366cacdf7cac7ea93acec0d47357925e811627737efcb18a5bbdc26f6d23c2958d38b81daba1f3fb1d2c7499c5457c5ad8c454e9abcb84daae3525d978ace3aeac14ac7a58a624d4c36f1db091bf911151db02751b5417e2e95e4b1cacf58f8dba9297e69721813466a29ed62362ac2b1030d39eae663682855ee1b8fc911af4ffc73fbc2f9313f0d214284610cf5ad80aabe85e6514d6905b9f1fbb552d829ad203537bf5f6b63128eea9e7801f2976cc98ebbc48393ea41e51e1ba39913a3213889872d356c2a957bd7c9b35476a2863c2602aea3024ab43d36080530dcfc0d0d409ce7e728efc1f982664802a200e7614801ced3c020ce1704821fc09b1b5f1008a2802b213734006f40d615fafc9579da5c000605fb2a0e28d4c5507352eecf63a80f7ca0fba9d4f37a5b395ef5735c149ff11a66039d1f721217e73782197dcad971a620c314685a6afbfdf678ac34cf7e0c2526da5c00f6648408d582862b2352a47b3e0097a3b8547e3ed3b05dda010a6e871f87057787a356879f9f78f093cbd5319bce4983f382168c17322881422c45d1f442b4040a0c1a018b2d305088c13c394206c65640abb7d0c0cc0cecd14314483118c845efe834b16558230b224e76ee05ad0da03043060a390d4ead15be209e728319a240a1550d33d03f4619b460e6040aad5e8004fac72f8865e0a48918284473c611e8df6eabb112276494c0f616148adc38f4182bc0785a2e509834711919506902395f42c31846a0d026a31b460a18249093ee04ca4a1328d49d39e268dab08596797483153230888198c129060af90e47a076460a1033b06938228a285003a306982890eb68342d6b1c29f10ed6698b2632e712f58453ff10454313c8f96ed114451228d400323d84891a0c6a98411328b4d383981844275c684004725ad79e27110326723003b9ad6b2f686540d4c00914ea34aa84818019c0cc402e654506284ea0d00e94334dc09c56407b4108c0818c245068aba0828015283102b9ae6b0f0135d8900472abaebd03b4414311c8d174ed711618cc10052e93922e512047bbf6dc8719c8000672365d7b41ae0519658a40a1950e4f14dd74ed79d10f349881dc8daebd20f985071a66a0d03a1501469caebd78650b2d92400e47d79e63a146124720373dd0d13550e982040a31bb1358cc38710472dcb5d76a982992815b85194dc840cebbf63887299e20818cc31145c8c0a03ea3062398b604092b92402166bec107eb7bfa98dc75cf751dcd8faf7e3e7b21d8597561f5f397b43871dead9ea5303333f3b6d1d4d43c57b3d56c5b951f4b69573f8dec35e856b93528576e0d2a2b173bd51a5a975aa1a0aadbef340f8b45a993eb3ff0e19b67fbfa1989f2cf9cb88455ad41b515ffae363ea2195237b903a49582fc14f091ea4377e276f2399dbc67c1e94a1ee522384143f752bbdfbdc8afb5fd5657bf54f28e6d338d9e3ef8f0114be1595dfdacabd5b3e72b2f7e77146bd84523e0da0a838645e2d6004abfbf95be161fb5cb632967d0bf12553525ba8572636957c76a33c5ca1ed7560ae189324ddf708184adc7713268e0fa4bbed7efde1159b1a0618b69a7586d294c5868377d1dfbacd0fdb063304683e3a464667ed9d139c4bfb065a21605f8b55f41fe7e30eccbd73e18aa04d967180cf2f96b2cabe3bffef2e7dcb3820ec94f0890cd0d686a5ffeae239c5e66476a0e7ad05251430e780085b62cd0007fb4a630ac700128b45d010350bef605ad164d4e4a80429b1210a0fcb61510f2a8fc49407f7fad207f7ba92465c497d60a9f267ffbb4179a33dc40e70e166d0591d383f6092e567801063cec2fe5e73c1454fbd9cd5782d5c310ef7922eeda1e5e0b44b6ede5a1fd7aa14fd55ee09e9db5d0fc0d51a29188d742bbfaa714dba30544fbf8da47262a667599a880aa05a8cb4485953a9b87a97e5da62f522a173b5f49b949606b94c0566d86b2b216b5fed82cab06a46b7f093c1026a9fd496a7f3f0da4df05ed350f4800aafcb65d75733c32e198be38a9367599bec0bedd1853af799b53a5b7af79aa8f5e00ea265dc6df3eae50e89f807cd9d5cda95acec6af43a22e4c76256e66228d33c47df3040d5766831ab342458a07b6c7cff668ee9f2d1e83a7d82f8f45fc34ff682e445aca5ad6b226d24da4894c2dd409112832994cf603886a319b1cbac848e7b0cd3245462277195f70cf0356cbf67cfbe2af41ab600b1d587186146210000a0454f61e95dd0b5e4f29a985763191fe3eb023f87f42768c2d4d2e040d295454932225d174515c03494a9467686790ea0f6dc30119cda4ddcc8e934f4c16ee0c8b152ad508926d9a91718f4b4c14ef88f11943c61828471e738fcd8cf88b998d301bd16464239a9c363a90329ba5543355145c1a45508c60b1b2b9fcc53db7d6a28be23aee3eea280dc4aa8b7240c39d4d1ab9e7169ba3a0b151236ca53a9bcd664a9369622370699f1e4858b8a3847009fc710c438cb00c5a40b9913468d8b00ebba836a9bc89bc67f51edf699a703cde11ba8eedf3dee6711e9fe20d2e768cf8f8f8e4482aa28b895ec0eb4eaed1ced9a60eb149678a494a95834f556a23cee1a870dd8d0edd0a071a32d18a0627079a9a9b266ae80d26166a08b5c942e30e269b9b3528efcd0d336ee044a191c331e273860f0e19d0f8fc383aefe5222226f282fafbac8f07396e80918395c5647573a3abe33f844be0cf6647b8f1c54cc756417dce9821c30a13319940820924101111f9fcf08f65e5d0f16388dbe112f8a70008b0d9016b87fba6053d77543bce83c71b5de2dc51ed481c208af8949a130d37c6f270a763b2e3a345dec0a0e12209194af59f1d1f7f2d2e0e1d380e070dcabbbbdddd3631a0fc5a7c5985f24edffdb40f8165357edddd0d44eceeeed8dd317677f4c254f566efd8da1641f9e3abee8dbadb366b65709b13c68e9ddca6cdeac4df1882d4be6c44b0994046d9695b472937d9cd8a6f33048d326a51eedd44d149bbfa7520456ece2dceda1efc5df9bb591d790304d555fbea7d495509ba3d761dcbdf5d6af365949299e76b9d9c40ac470da58ddae51f1849d13185c6a32e4654b99aee612727560b8d1144598c9115437efae019c939c9830f5929c7c7c8454382e2508d2f24d620699ed6c718a353c4e98f1f7fb6d8a02def9b7e1869887ff0852c1d5f485939be90e5c117521c319c2f9c4621f59b161b34ec66ee365f386521ad29f21dde3a79cb521f51f50ffac610aec99afb2c5839ff0eff863e55b00d4766662766e06ea2061f93962dae2899a8419558a65489455665134330f183ecc9a104462e4dfeb38625a6b8e2a5ba6a36c1344e57643a7fce7905cb15236a76708ff8f30aac4625246afcd6ca47a4341011e58b0e9e58d0448728b248d1344dfb20f5a44445893035be8e958f488bf83259719f60cae149e205498c5102a96a4890a9dae758f9d05c55601113638cd183950f197657e454eda3f6338caa3d3d628caa3dcb4a1355fb474287236ea8dae358f9d05c581c01e6468c31e270d951441a463451841155fb1b2b1f1aa54bc49002eae8090dba28e150182104b793ce8ede6c971a76496324c5a0c6b759f9883963681874e5438b677471b50668da965043126a6842d59629842a59aab021832664f005112d20a28baafd5639aadad3346591a166a90a518df157ed84937c4dd3344d8bb17972545966aea6254a142f4a4a645c3465c9c2c251e4da1e4ee5892acc1237a8a416638c93a67eb99c06d490c7135a96ac3040d57ed218aaf62ced9f49d5de25c41455fb9d1554ed7d8670aadaffb0a06a4b31b8220b6e4372a2c6d7b4170c41668d1fd6b8f2e505dec5883238b9f221674e036a5c42ea414c8d1fe94e943151d4700415596600e35c9460c0006003d452e3c777aa695786543896a65099223c99da26b7edc809903094acec6003a8288c80c8949682f8c208880d8a5831a4a52c456c6abc92e84ddda52c2f4882eea8bb9445869913b3073821bb517709872527742883f67b6fef2e37af7cf65ee8caa05dc39f6550aee1772d5710e83a3dafda1534741de99e4e721e924907d89ebef9f83bdbc3e6e9872b5b2f56b387f86b6adae86071f7ae0ebf8dd749de53a45ff1e36b5ff1a39918d3a871e38259286a7cd5174bc5b88076aa317e38239176bd14347424588def48716e7c1f6a16941a9dd438654c20f0c154606b05185ab45d314aeaaa3102404643972b27d2744a8b18a4356541d6ae363eefbbfcb5fc85eb64820f945251513c8a694d4949fc1c0d1b51c16691e324ef6125fca4f247a548c44944f10b3916e78cb18bab18e5aa536ddf7393316a1a5be917d7481cda3d8d6ba7fb58feab5fb0fb9045e4323281e8a7f37ef82b16c41be22f21575443463256412d05015b828192f61a0c90ea9a517749ca957f0a43bd1899c0af02f7778c8cdcc87dce55d1eaf0774882f00f274569cc7bf84914218ae0278e19ad0e3bed60b1b4546a4e6e7ee4542b1fa9e7150af3b7d7e616a3f69af69aa63113738e07e1bef3f9e13e97efa83e745556815540a010fe9091d888a1b831565081db17d16c38aa53b62f88c1d60adbcf9f1f0cf3b7af06d97efe377bfe825b7703e12f2e0b9847c130e03d2278012606b6806cbb0aa27dad0952d54fef705610ede517d49ab2e3affe7eed7b97bf3af60fa02b50fef953d4a10b19454c45f3e733c1b468991d390c894a0f35eca893665d44651cac0b0065a2f88b37f2392a95f21ae6af281c2ccfaefc56b24df4042b4b37015086527e9ab2d509829fae18b183862573445136b6879f6417557ed8f116dbc3515c832adb68abf69325a1629d7cf7f7afe352352b1fbefdc79523f1fc6ececa3554cb5a42495977547f61cf729e15030d218a2e5964e02165e84aaee44a4a3e49d876bee7a4dd51fb926f6482f4915be891595bfd496a557dd8505256fe9c50ac1c28c74aded34ff6253f4a1155be92944e6db43a12ca09a71ad20a15c4a0ea7f3809003464074d367e8c9fe302628107e530ed35951f877754aef1fd9f66a73efc9bac3e2028eddf811ea9d1a4055328b78ceeee21cc7c0758aabbbbcbb8d345530c607bf47b7f5d506e57bb583a50ce3bd512b4e917a309f1f311e10a6522a8b7093f3eed62614157c77b806145b1c58747102933dcb66a620201fafddc0e2fa85d60031318b8c30b0a126223643cc4c02af377bc083aa040b8974254ee93d4766a9e30cda3e359bff9c66a0f7ad6b0380fa85d1bf7add607df4c1e4ebb5aad0f85ae2dae6edf5468533bb598ed7b4cf77094eddb8a53dd24b87deb03ee08168668336a9eb0a554212a109ff1c2c40994ad35bb99460d0ef7d1766d34eaf01a69fbe875d20e19286c7b96c74349dbb3d3f639be90a56a1c8ff385cfbaf185ac8d05866e543620a5e6a1f9ed1b4bf3a8d0db37d3f6d07e93cf79e1576ec8eaa777f3d10b8b2c540739d2757e3fde4fa14fbd01e16d3cd5afbcd67caef341f05a292198d8526b1a69076b7b6e87b75d10310403819a67fe4685053210a680f03b3ca0e6f9eeb7e7be1049e57e7a21923a9fdd0be777c441f85af31764a15fdb775f6b7eacf313c2c445cd99f3fb8f80fcd5d378ad14668802a85d714f65e5f168d79684d4aeed456883ce57a179e647a45ddbeff0b81ccc62e0ae2ab06df377dab5bd099e4fbbb64fe5405fc906757e612bd52d6ca4bafdb46b73b6cf0587511568dd1fb076a054287f1bbfbd233ea5fb58e8178f61a24e89d95e917d4261bfdfbd10ec537561bf91585f682b050f859eb457a576f77bce20ede2ef3d3e94ca3ba5fbcd2bb24fb55d8b71a7985591e45af4199130fd19699e0d970cba83052fa85ffcdb218942fb1b22a45d5f147de2518195449178096a62183f50f3c8a3caaf42f3b0a050fe1fdc2d7911537b3581fd0e6218128e88902726e2e13a21baacccccac04c6520c5566662ade4cad1d12b444f146f9f8ec33d7354a7032071774ab5c41802b03d16a2b85cf058d9bdb24abbf0a5400474b5ebc8ce1a63db369cbd462ed3021a6ba6e897a73fc58bb1878ea2e49115565f4a8e6e100fd10a10dca83846ddad9d99e6caf71e1769ca191080b438eb4a66d5d1847f45059fb8aac530a5d18473cf199554e56c2bf9d26e8d6d8cf0e25bc20edeaa75cc352146264f4d6d7d6b25e987d90419a877f9be1e989334a0051c39e2d085150ee57cfadbc86f217b39ed0d404bb75da50298772198c363bcc7bbaafe53df39eedb74a46cbbff9dd07c30743151852afe27ece397ffe0043270aaa1224154ed91eb67d42f361f8d4b79cea22f53d09c181ea43156c1f02559db27d3020f1d747c45faa2e54dffa2bf53191bf70c044f3abe2dfbdea4356179d8fbf1884293445f35bcdb7622b7e53bad80c8a6ac84620704137075dc6a00106c230bf05443ff54940fa0555f1dfbe06a95d9cdac2cbb1652876aa4d5e08183014ab468a30602856a7c020b4c9c0d46f9fda425b260216da5fd84f7593810ba63ed82603b7afc5338ef217d450c38e70f217ffa6c9dfbe4e1ad3444c5a16726da6767592bfa648bad2a4863d6b275dc4db5a9750ba87953419542a379da91cbdc3e6d6b61766a6957ffb884af3eccf28109cbf12b4d5bfe0a6b630abfab0f40416232c2d20db02c2ad9fa2fa84546095fe24759ff793d424b50544abfdb552bfadedabac1b695af27342bf260155e3ee744ee8cece67478436e886446d6666d5582bc149521db3fc6c36cf458c9663a9e90cb7d8ab7f10edd931455f869cd849141f691d817e0489c2e15504ba87edd1411b336307513c81421cc59725c02afda0062435811f4ea369fd3fedfdf0819ef00389f70075511cd43024ebf403c9eab88deae7871bd5b56b7bdea889a30534649db0f2a1fdaea226a36c7d0ed777252809ed72c7a9db05091e6ac84426f8d4241dabbae05a40fd49407e76fe1610f3b7fe62b0fb19ec8fbef6fe24e0802e9fa04203b58be3d57e394ee809f6e5ef2f85913e3e8a3a8a95c1450551fb439b96c02a02ea360d9d51696da212e539417168a1336e67bc8b1815e18ef0c38ebf711ff990d632b1d2f7d43d4def8186ac1424a9306385cb11182454c3c3141780f4855a32a411036b825a01fe351e9256803390d404e47327c5867f0b5989abef121458aa4735cc4bf56f22265090a9feeda47b968b24180c16c32e4d61a63ae8cf6d6c85612dd7e2af6a8e1d1224341c551aa2ddb3d2d675bef2d1d1acc47450fcb44350f304bdabc29dca4afcd3dda7f23ba11060a15382ae334cb56a354143b6c25492c4a86ea00cc54fedf2ff9ad0a54fabe36fa3023a47c0f5e90857b9339f676ca679564b104c75fe74549a4154fde9a0e6d96fa2213fc57797a2fab399edb1b5bb9f6284220a29b5bf9c6f9783536cb49fb6f16a94bcd4137eac50212cc4232ebfbbe3f7d7fa515598693c01390e5de718e2a3d0709f7866c84c5c8e01161242991583630c50804eeddf1edb7136b553b59fb74788105f7d47646aeaa8f36dea4cd5f9d3c6f358db0b0ee0df55737bf7053c046739fd82a05c4f5804833e3319e23d3f29eb818474169403dcc37dfc211bd81ea98ff353de065627fe72805ff1e38c7b465c356a8c435627c6c8c31237cca0e14ecafa77ad53051888029302abd31598abc57eb1646a8e9ae372fa6643b5046d9edd1e110c6003fbf20f67eaeb6f00db83045c9989b9690af1971764684531c6d2594c7fe9981ce3588f0bac0e06f8e5afa37e21463885e4b0802ec736a6e5c0a996a04cc6b22064a1a87c44d096dde430146e98392965b11c025b7dceee2c88b4d0aed412f42b83f277165886b828d13c6100b8abe9ed129959939b9c526eb29b638c31ae4777d75ec02a6f5d3235b70c547fee8eac52b1b721d3344d8bd107ae6776a8a3ae4df476775f01e1182a4ebf2825c3a293d9bb70817243ebcfb5e3f3365f3379720ddbf0cd17b2ea46433a3f74edf8a4bc3db9bddbb67c21847803a75ffbad1415f46342d070ce36a2e669178f76c9ee62f7a87e555e0bed496de7495bfe9fde96507e2d885b80431950606090d08241620656892f5423464b1358a5bf0532644370a2a88b47f7a89e559a27ff0b1d0214a479b69701a6a8a8a42ef64435756646000000008314000020100a860462b1482c1a1236691e14000c7b9a427c56990a84519203310a21630c01000000000008608066c4120025949beb342a08da99c14bd40aed6e5ae059c18bece3e31c32031202481e301737c55a5b07996a4ef450ab8c2c9344c846b0b4ed9c39f2e3e8455d22c6257bcaade8167c40387c9bf12f38617fdf5e8a2ea2c7bab614bd54564dd3a17670f89de9fe9a112a22d00169d178fb531749f72dd5877d220f48ff91ab95c5b8268c8f25c178a7404d68694635be7478476851009fafed2039e96ab767e9e83ac46814d3d4ca2b497301e6338da96dea5e2729b3d48a6dc9a6d87dbc21cfb8d6f41ed4a8735b32a40039082e76c6040c40bc1a446ba2c5f59ca560a3c5451c72bd6bfb325a370f2c9d559ff0d6f893ab4fd1f12021e520069a0b14516b6e0305a22945032da57ff829965ede15325b2ab9320edd598e99f7b3e45d98eb05bf6f44c1bec7a7860ed09932b335007cc3d6f09de42cb657c656d9edf2369de1cd2eb564b865d9fe0321ce12d8312c8509375c4f2a62f0cdeeadbcbcc761d82f2f5b80e6ca90018b2a9e704d2c94fcd6a170ad44d4ffa4faf775322fa1579b46436aa18636555991c2c3a06467aa2d27554715e24a3d38b2aa1d61f45d7398236e5d57b35a4d3011bd71c6ca5d175f0d215d1be0ea7eb60eabdea5ebdff72ed14081ac7342bb16eb2a84f3643b2707906d419451504e2ab2460bd8267ba6abe7e26782a7d0550e3d1b826450ce28e53d3d325785889bb5f17648aaa8e011338940c4c03c2be6fa9427e5ada20d6ada7118b4f507f07d0990ce6c835a1d9ae8d8ad303a4cc1a7975b6ce2a9b378a1cab18bef6e11bd7db76dbecc43830b5d3737dee3e5f06013567dcda06c34d1438de4423fe6f985ea5ba9bcea516c58a060cd26846d2b9abe4bc1c98b08d69255f68221b9a75c9018be647c0e5de9f24a5ba6844ed731fba7e47ac6fdb12cd543dedbe1c3b10ff92d4219b935d7485d0b8bfc446c94d299a4f87b9af0a838b0978f3481cab9933c6cc36f4cb86d52f3c61d63d307c9b28680d1f364b9b1c8dab150383a7222ac62492a5c686a9835a0d513a08dda2463c144a490ed1dcd06dc77f16e3c9d0b94dcde994b0f13d5069433403a4834ae2c03f76ac35318415d3f208e3748e1ee9ff10a859fab119769aa2a63ba9a7823d9c72f4b1ef903730a7a46d9d2cdbd77ff8367e2e871594a6e75dd028f7b9086bad736b6247c859011fa399f401c43b8a742cd9ae6cdcac91ac54a1c9e7cd241bea75782ae3bc9e53f9b7ca7c8f0ad8edc40a297681b2d32f574b0ddd1eae80e0eedbdd61d69e3390e359ea48a393985c96d8397d570f74d7e6e9ed7872bdd8f299815a6d5721d05c17845597d8bf9e64c8ebc5d33126c9c35b5d7011ee389bb5e19b8808cfe9055e606eed1795297ca82966dc8ba3532dba779e7f91f14c0f25e8460c9a4ee4f238247a07f5d624d25548d8f0d15d6dfaa3bf4afced947f0ddad0d1d9ac8b9254dc21f769e44db7bba0f96354d7b45a7e0d89523a666da797c33b17572127faf0ff3ac99d0088b7e966765ee61590731521e813f07311b2251a5959c858f9601aa44d11f53fa49a8e62fa06a5efff21a07a2647b5bd85e31a465ec3b2be336f94ed4db158173fe8719450e01f99cdb3486540eb93edb6036baa5853fc5f8d312491a6cad9896d0271892f12dfa7b8f0388017beb01c3faaadfd32a4b189b72ab2daed67499490dd426de2a40d1f7ec5d56271ae571b680d48d341c3269ee8a96442280579123815fd02e97bddeabd35bb7257ea4ec1af879df3f74ae0c01c6f56c7076fe3ef7e05bf0d552ccd2c733c7a0cbe9546053c312a870ee00db5f3ee538a969fca0ce58e672824025a679ce5216e6eeacf3f505820175ed3be7a5bcba5460dbf1ebd60ef02d610f3c3f90cba9e7648b4187455f724c5f9c9f7aec75da96555116ecf3f3fdc218649260d406174def4f2e2fd267e81cfc8d7881d1c92dbf9ea3f5f154e81832cc46cf1cb0344b7962e31fbd5471f728928e93e69d692670a3c84259f220c66045f1cf5b75baaa7cb0e7ecd804c5afcdb5bfc7c4f8c8ed88d8eed88eda0a6629be786b8048da6d3a2a29f2aa7d965a1550cac60aa52bbbd72c665f54ca6a5d5b2a96f02790f000dea89a31fdf32a9091c6cff0c4eb1f6fc6781d349876f8e1ac2b23bdd70d43348a09c35e3b22bba9ac6486b4de48388afd0203ed374b0346ef63650a0c0dc33fbcd6e3d1f550526c252c313beee7f8815c809c0a0aa431bf552228eabf8864a558b2c1139bec6d35a49e2b7d9d3289cb40cb3832960e6ae2a903bbface4bb5a99fd5b1a8bb24e897e62cdaa3518a0424df95d2146611e29742899449e0927ee966cd051005f36cf42e0bbaf5ffab32b0e7b5e892a665351b2023232ae6f5e8a59da1ce9b54d67b4c6ff3b1810cae5b9a154514266a98cf040645efb3dfb63aa5270217648623142fec434f1bc7e85c4dff0c03f4375fc9cec82941e533bd73a889b932f829ce7b343e6be751fa1fc5b7e5f5bb99af0842199218465909134e78404490113e247b12328fd15b10e40b4a9e70ba961ca33ab1a8098923d29288f1ad6ae190497d2538c52748d3ca7c63276961871ed89e44d2d781b8272a8b89eb47f24007038b2fdac94fb49cd859854ac757cd192a8c4346a01c6f3f0e55f0bfaa33cc79463166a2e2d1fe7b623b52ef03e2560e813f1ee2f13c9f125a1f49f259abf95b4add92ed9b2ad2ec303c41789bb1cfb3c9cff949653f6f967f462b7175d4919e65f021189b2c40db4cb6012c6db9462b70690208ef7dd6070191f7d000dbb022c630093cd3257f81b2d2c2e9d2bac7194ea88f4228766636ca966cd997ec13b20c7fa672291090e7a370e3b5dbe826dbb9f546e4fbca1d20597c57c7ba254d4a3b5c6f625ec79561012156c77d581878412c89f76401ecf2e684804aaab91525138b7d42255a4069cdb5d2c4e54234282ea76b05d96b6772ce236068cef19c5b0438ac8c37895c8352cc0fda0bc3add46852950dc1164546f8b853f1099b9fa9ddd38cd922481aa35c12ea5e1bdca18b577f1567d391fc64b7d5d04361bfdaa5c6536772f6e5db87efc213fdca1b38f20bf81d2a7918c74a5e0c6d3fdd4dee3c6db28791d667823316ac4e01b4e407aaac34edc907d790cc1353c67accaa7380c9a937fb58ef3630662d90e7b39b38c0101b606183eb5d5da9267fcd6801bc20d79528a571e3cce59b3b2e8da18fdf55806a3cb16fea53e3728b07eebc2979e108f8d2d9b532423d231e506c0546b2a7793284d9a07aaea5d03ecd9446d6a27f8b551dc233b1d869e85f654fe929477169c237d13542ad3810ef416c39e0e4dec26d093682873d6d909dd8cee81c07f72add41da08950eb414712285b63d1fa6a0a99b1d2a80bcf4dcbd8f407f3492cb86b4901141ade321c9b7147c20ec43306cf6d8d72b2fb3c962a2e1b547d18e239f4b9c43d65fb58a181e09a0e43ecef88bf95cc7858a6ddc8c0e8c8a8d3b3fb407e37d2a17cc05832d064a4779f1d3f346b74ff69f0a5e88cc5b7a56d6113aa55ac246f96bae29a6cbd62131b56973b7bae3bf81fa0ccafbde42e1996212a081d6d47b6807ed3a5d9186d4afe6d31535b3a71dd6fc41cb83f1906ef84eb21afbc487d95f16dcbf9301f03dc10cd19ab81ad9be7bd9a68b4a4e5d70d8d7d77789302ac51db2bf43f53ca3647b4bf3064c51ec0f5f5dcd40dfdd28bc2d94d132cc829d13349c9e6a0571e3848b2b0228222491c2ac0d7b31e56c942f5ed68bea2724deac0271b0c2dd8677f707d4b0636408e0eb619c5e89def5ccec3304378e622ca32ea91fbbdeb97849da203b157a8951e1ea4bda398ff50195f042fa29a464c76126be7191fe2365e7bef6f5adc696f30c5ab448edc05019b47533efd2d1a8e9a98fe2d2f4f71da215cb33d6b5527132174d202ce7f46eed2682782c472200bc296330a43d6164f4a4c0e8841e907f3bae7b61a9f00deeda2385a7ee777a3bf1f67c65f55c81ccbec3e582f22f2897432d2dbd6e071d5bd68678bb4562d645c79950edd76dc7ce9a26712c3b788875f6b7daf8dee73f79737f314c2623a24acbdbb193958ffe8c3f834c659dad64901b437b736e823824d066221f9f296c4b07c961e8431238518c86e4a20ad19a8e14bd1b772234e0568b6c690bd31935380b6cc9f50b5ef9eed3af09fb477359a3f226e6087793d5e49ba0343cc5e6b8e41534c1a6015eeda31e3871306aa5075471542bd9b324417e10f09789e663bae8f6464847544fb56fde9f8810ece2aa1af6df348888352d3d2dcfc0c19efe4445b65721baa97730f665fe1e3dfdd9cae5c7281e553868b48c43cc863540a8eec6422cb36620147aa6a07e8df4865b62bf0336f71d99058aa51aa302fb2e3f26aa795233cce1adc34ea64029ba611fb03070bf8f5c3a619cf28f282efe9deed6ef22142bd61d9e15c360e4df2b90b3e25e590b9ba564e2944a4966e7e334c64c71ec10163ed9c9e45ebe08a3940066b96bb75cab2c3020cade315faa88964168ae278fe6ffece6898f92a4e4820a84fc04da65026092b58d522dda43c703d746f61f198300635f47dd5640f3d07c15de9c05c05bf87e463e11867141e6949cc905cd84de3175e64b8918fb9a60297b654e8828a4e5dc978c3208b52a14f34a234086da23ae5427fb012be53d3d5a260e45755659458c9624ad84813ef999b24c3c05a4f1ac88e0580b437f4f001f7df7c344cc226f07dd43cb0e8832b6a330c0d5b89160d968c8795b246065516f958c9faad7f64532ef0c20c72d393ca7a0a63afd936835c53836e3c4949708cca9bd452f24d2df384ad2fba0636872482b2c72ca73a8272d5dca3081bb49022b312925c717be76cd4b20ba54d6fde0ba3a34ec9f520e42634a59f83ece07341c16e490bd7cb0ee488705fce61b00ba28282f14fe49dada049e96d3ea7c5ee08bb984c8896d16a83aee3aeb7255296f21b01bc43a2dd4eb06ba5e208fc5c2b343b691b96aba210c06ce91439f09ad60ecdbb596d885999b6758b9ecdbf8f96e966fc3af177a1efd6fd9197f55050c0a93ae7f5a4a1c38e855b462930a7282f7008aeb9d694f6e4134dc359085fda9ca36c205db9fd3aebe8bbbd5bec90cdb3b005c809d8af3aa4c1024a2afaf5bddab8f94a50ae23b4b5bd00fb9edb99bcf1fb0f3deeb6cf16ee2cb310f4b679d9470be66b7b4fa11a845eb2acde4687d1e0b19128fdc2d8815c222041cf6282cc4f7e2dfeb3a3aa13890fe4c19e223788914aa52082578214a027dcd12ac9558d59bce8bb718ba3592a6df05eabe9e83256bcfe2a00c114f513ffa81d1064684b0c9f8d488f913d518c08a9634f09e6a0c8776bd68e7868808832a1300ed1db4ab2719cdc4c6e4f8e2bc55702d411c351c29d2643738ee67ed12ce5da1d099d57590eabf96ecea7ed375516973bc9234af21d3c0c197d0b45a662133912d18caafcb44a09a5a3cfff99748e07dd590c5fce43d50631be3ab47936ee1c4e43f171f2b865fab372a60d956cc4025d6c93bb8afc259439ed9cf38f7a7c95fa2d7f7e3afb63e43b904d6f2cd12090ba11dd3ab90d08eee8d49b8fee235238d8d3275a8ff44962c4d00eb1cd41d2dc54ab0a41d7d86d60c93152cfbef5c0ca3f803831d0f1c14100c64a9a260ed6fe43e2dd41788795cab5e373e1ade5f354f858ec509d2b6e59736cb4d25f37749703ce7f6664f47ba82c21f2386b55aa9b427218d1195ca79f8072e7f0dee8d09f0cf7b868d14061a2cfaeea8d67791bb916f7e8d2a87b05c112730a4b0a9c064ab8134c6cafebabf20156ca9840a38e7e53975f061c76e8335c021ef521f7554e8eadb7bc726ff20a4c4297221642e3a7c4923b854f6888a9985fe6e3f1ca48296385683c5b9372c609068569459c9d9ece3d452826ef245008c09814804fc097aa40a7e0db1dca621041bd08207ca708c3c03537af66d52f4608fbf49c0a56e5d87c734e39a451c7c975a07d5a65aaf63005548b6b82b9645db2d6e4133b46cec7067eb8bac33f2dcee9e22479ed878b866b68fc75e51439457c42aec219b0401884a6f8db72bcd0a662f4e275c520f663565a10610135f5f4924e9d54a0a03d2ffde49039c684b95741e0f7b35c173c8f915aff228137912fba39a768cd4575b788bff724102b929155b91d74001393cbe84af7d46552fb7a9c52b92d86500fd41e4d4cf7465372c8bad7d15db2043fc9b7ca2df98cbaa90d1df75b504a7b82a3705423a17d22acc5c8de3444edef7c41e47995091bbf47fa343924752e6e3b51e210f1248a5960a79c3590933410efcd04a52001a73ea87c9a461d9fb476859a4d64a28c651056b2c93ce99e7f422751d21738ad857212e2baea08158efd8f47ce8b74460d6c928136aba46bc3674d853601026ad5fdfb2d485780be8da5b0d82c98714b6cde9d72a2a747fe6eb29389c40fa75c127812ad3afd5a15622fb55022f8dd0bf5fdfb79adbf08ae2de79131d476b7216818d133fecb35f3bb4c5eab12efed4e125daf8f0ac0a48e6cec99c4225ae4d913c5730186a081236616611d094d3b7fea045756a779eeade5c2c38cf99e5555de212e3506614343492f7f178072b698d77c124eb990fa12f80143ea745a46ed73e8b667d6a9e072e3d5c99a821918b3615c7932c85874236e8590a7814a3b9d8f6fb2c018c5ed045f9c37885b5beab2e5b8cbb05c4af5965bbd6e21ffd0ee71dde62559804070273904a0699d07634d6f373743836c68a5c0d27fb5c9e87ee55f6408aac5ea7aecf5dd543218acee9ca3183041a7993b42da88179c1a657f3a43bb3ff16241b519e8aeee937e80d4b00f892ea09bdeb76f908cb0d81e3984e42e8dcc0df59bde0448e5e5bba48437c1cca8aa4cd69bfc138a9ae8ff0b3c352ed1a489dd720555deb55f05ad0bc8a62a5cde8a82746aca9da02342d18aafaa63fde1c98e7ac68a3f832adaa9ebc594f70aeafaac5157d6d9584ce11b5b130cc2dd872dbfff93d0977f91bebfab4ed7f92c13c8ea7b2bb6425a6e7a501c819b76864eb305b27e004786d71a2e9b0b85a64b2a2326c55e60a586adefaeb15aa6d9357b542755b45cb27431f53206ce52c11f46ee6f22641001d83e28b801e4bad813e7e83c6bbe1a6ab456384f19723c140319846d7353b6e4ca01ffb7e5aa88ce57bfb4af38781b2d388b03864df8bef400bff1517482428067bd2f285bf43ac8593f54788b404370c757647705a15ba1e5d940cdae74c7623905d6b5d3cb356ac38badeff3e899a34deb7dce17f9cfc173613dcc9b62b1cdb0672d64a954dd90370d22c6d65e89c77c72b462014370f9bd57b49938dd17e6c4464aea2d0e63124ab89c6ffe10468ce7b23c828bc51a3ba7cc28d1457fd50bddec21b738340b0b5e6b9c8ab8416d01f89e36b76a667160d9a0039dfd885d35ad84264c9525aa531ae66dcef1822f703e3e909141e29f26325a0830c7b4972be562788ac5e50af9dfb99749cb544e0b21c3ae1cb1cfb44254cb8b162973bc17279c94215d5f4479d86f94f8910b633d6797d8a16adeeff1b126d6707c99d073ce089ddf3c475fc2a328917169d7c614d649c541a659155f523e44858fac6a804a31bd1252950804e844a430f64e0a203890bab444fd84425209496c5fa43d5f5452064482029c6c6c018f069d30577d018ba006fb44e4a0635422efbca3586892c0e01d0b35bed3abf1d02d9e32d02c907e9e4f9dbed8e5bf60a28c955dbd51dafad029bbfb829da53a655c8c3673ded35b7901c98c56a904b8bc557acbc264f38771909f90b2a20f79d8f24e37e41fa898068686235cae85ba9fc32e243e234fc3995bfa3d27ff8520bb491c0f356193557716b353a0f65e5b46acbf4e4a14b7f341b9dcd6122f9aba0e6aea55d3db4def82787882021ed08665181b35084f519f86b4e720e159d04c9c9915281e135c3f2ac4a1a790a67f591b01779214bf9b7e6f9f2c0b6ed88c1c907eda0e9cf552c6448692ed9829c2dafa593b32e2f7f20f94c41ca6c8098ab43537adcb9637d4d2e3afbd12931e875882aabe67a1c034211b575c5725fbbe98e4ae1aaec5aa44f1a9bcdbae868366c43968525459198fe89d368482d8d6154c0314849580abc34bfed219f171d08173991342b2b9dd3ce1e298e3dd5c87f634ea72ac6ac5253062cc4418b5c03af73adf7319068415775135d19ca4dfaafcc4a1c5c81382f689458b144d2d5c857a4fe9a012ce69b6398cbb8979b4c177f6f4478bb92e09f033f032c1b817d99e0968ef9f95b8a3b600ff4850c4830c8f226cdb4ac9b8192a138a12d32453786e4be7eb4abe343063e6a6a64454aea7632ec613dc872b3858fa4b2d29b1de3b111d8c1f1121540970999c73821623ba927afb9abd090c65daf437e1760de8977cda703e043f7016a128c2b17c2fb5ae246408ab280827dbf5525565507bc02ca56089384d007cb9dc4e649c9a4f4870137dea2611fe7dc54f09e2d0e2e83b67ec873c64dfd44f7bd25bceb52d08662389cedba8f174db93c24b7a6721170eb804d6953da084a6454c61780a8c4cc9a0ec816d26c19f0cfd5edf20086e037fb3905d490114c107aa59a08a3e09642f8f8197b7a5f121a6c61a3f3d1a3aa7e1fb7dc2974485f021eb0064da66515b41b77e0b4503d6c6351629f55f7be94859f4620c6aef4d34e2730255574883f33b4de348e09fd3089be315e1e775506b75455c5acd7517256aceb4a9650d1a6990f713b44512526d3cfdb064df0b0ce8788ddb2a433a265c67a6bf5a5fac5a5ee633008cc4271d044ca40e994420cb1412dff0b2c65b479dd20679a6ea5268e8a0d33b48530ad1b822111b4f312a4322ae2e4b7b00c2b8c4f1094fa7dc55798f01141d6eed89f88089cdb288315db50f1477f64b48c6fa1819c38e03e52e5eb563ad94a729dcdb8916a4794fb78dfa9c28d182a0ea12e5a560bfd34be1c3c413f13c52106e604b814f23f18ad3826a0109fb14c1adce0345831d39700d6f4f9ef22e8ceb46855c3609b0cc5c34a5fc546a97b74c5f3bd84ebede1e798de74ad54d963625cc00fb45e7652481dceacbd7280c30786067bd7b7228a0cd0c3427087aad96ab11684e8b59865373102a628605471a476023c9e79ca1096d1ef01f9fbc1519c55e19286e4909ec13dc20318f434c047a6ed0887a1a973835ff0ac7b757ccadbf24febc63a53cf5add643da960a5ad78b12623637959940ca7185a5b314e5ca1a9e7d777cd5002f682e05d3fc21e1624774086d5451b9420ad8b3d042e38b90079d78565be5185a68c4b113da0abdf7a758c35cc636ee7dddd53e078d77b8cc54701536b979491600bab02832332def1bcd73b34a441b525ae77aae318aa2786532684dc5ee13f7fc52a0cade15b086cb861edbf21f0907b2e73f50fdd3509799bb117522d3a5cc643cff9d5b07ae50f188441bee420d8a2efc3bb013f582b22439a5d0464919944fd8816edd694d827541a5c8eaa3aa7bbadc27391b82d8f442b5487f7100a186818d67031ea3103db375899b1eba23b3c0f6d41fee2eb18cc795a8c2723a26145beb918792112cdc5f5dcb93e11f748f18cc525a3459f474c7744bd5ea5b1a251ca33f199bbc87ccef9c0a3a43e2b82dedd3102ab17f0dec9d281fe0969c5f175eb90dbeaf92e061b667cf5c3819e1e3d5a91eef7b6a4d5466fdf2091eed321ceb78bea8e395573066d8df8b650215771b9d3f2e4fcc354a4fda1bf4d7fe5901903be8bc7696fe436a72e2e8cdc1205e754af016edf187a8f2cd2a2da3b335ddb47bd83949000d9743dc04ad0621d42471455f2322331e744ce7246dcca279a5f9f30bfc72d4e7de8a02d24930240280457b0cf212f465b7ae951c7d7ba1a54bbd28aa579375d3f3161a89c3df9f1740356e578b1b364aba992121962e36f2b96d4178dc1142d1d4cc5174e9b11030f6fef82541da218bdc49b6b115f967ed929fb019f2df5f51ea9c0a59fc6beb7ea99c30d08093d31f49ea9856bdb17eb1a73fb953ce362203eb7d3cde1b8d1a55f81233dff4a54ca3f60bb856793a855571004363099abf71a092bf3ea3fbf7f5b7241379a3b1347c603b0489995f60fd279c973f6b9f9d8cace18f2b7991591bef90fdf5283c21e65ad024fabac0de9a61af0fb69f268e8d69b5b5e0ae4001907a8715eb5c7f5c2d8d95830bc02ac5bbf059791c0fd28d1d2e2f6ceae94de1767058dc86d82e7bad218af6ba59fb1dd951974c274a43de9236d7f5c60a4394104c85b024e99140ec6a5baaede28bfaa256336b4274ab905c6e8bee5e92c55e8dc917c966015c6315f07c1d8c822d5dd036180a5dd2db3f6508ed8ee32a6a0efb0a4d1b8c59f26981f70b811ed26818c7004fe0ccf44e758c8c28ef019448be469422514de3fe4603f0cbb8dcd405029c7a63ae74a886e4ed392f374f742d4cdaab4d326160d47d559b8ec21f725d1cb9827bbec15599ab7191ffd09b514b246b7b50404b68ae576ccf2fb6198ff0ea591a7f15355e43a11af4c61625ea302a805b39d7fd8fcd97ca915b53c989655b2ca666bce5d2fc384096bc3a55d4e0d9d79607e829a708e888f7960bd6ee06c2e4e11948c2d35afc04b88cd50ce4c06ebbd07bf54999018bf9b2fa092d1e9436b4c1f0947123b27e5137858ab55b1a9f8913f3667d1c588d362065cdeb656cb0dfc1b1fea4b7e2eefa2e38ef09126c9a39926a40db466bedf2df53dd0201e00c914bb4cefe797353039141de0269ab7719d9d477b184ff63bb7634274af6fc5169f78fc65d1aba9b8216107bbb67bdaa3bcda654722add7f2b32582e798f8d074c838ae7b8c34017e30c87f5764d82bd020bd72d544a4fb2170061c19ce40d10fe8d11d5892a4db3331f055a757e6b3a42ea973efdf1e1ea6436755027ee967a0499b762cba390a1923da2978706703f28e3fb01456f3d5352c18644f16ec55e38a3907a13f2f63ca41b75383a855119e5d22fd60bdf1809d7e30f4b62beb9cad5d2717d97d700fa14480cbb8d6053ed86b2b618c5b3f680a00518dfc4ad6236c9a4128c8187c71bfab5c0c7568b51b2aac54d62b9fd604dba152c7c2b27606c3f8091367de8d04b703d3c3a2800cbb8b3b1b0cc50561fe09059ab97233a827577a435192fe00e8f1917008723551ac688068fe5c75081e33c62a23786cfed5a5c10b1e9b763cf4b7f384e8a9f382882aaef4263e8d4ca32106eddab2f7c87f7f15ef114577e0f1e0e3d5aea118158415f930e6b0f3135a77016c65f3dc810d64d161a9bef1611b7308fa516d96747743f8bf9a60decb6dd4e9f7ad9df420c25084dad62257f963e49288ee0dd309c854f73cc34d4a53edf54d654c49047b23a59c6f13f65cedb3902a226b61bff68b3b6e64a6f8c5330da8e636e0b819c0e76fd426132dbb12436a4cd280afedaed90e772f3c5c46c76cdb6fe6e7b770a521270dd6eb1510e59713fedbaf874434bd78f297bdcc42cb4c2f4da9fa018003cbcdddfab79b432e77cb8972a130a8b4c689d23017dd1753f7dad7c48de8d85e3933f5c9d718897119891c38d4a3a93e7454abb7808c8e4fc4fa230ef4925d0339e92d1ada7b5cc5a482df4a054fd1603548234a7443bc9a2d7b664967c3b5b84b6d9825e27f0fe8f3626ac41985f54807237a95cb2a9af87b01a7462cf43556b902a33b335cd17153b08780528d56871402c5a3107b1f40f1d62548b38b53346b7434ac301d5218b2a5b1a02078a1dfd4d75a27499398d1584dae3a7627d2e53de5c3b6bbb8222ad23a904863d68982a4646b027e21f6a8d5574398bd6f30a6c913027faee3b880a4f5c038a0eb7d3af133f96273c64c408a4001870a93384474678001a88789795ef91a3f214823ddfe8b833f64f61344e9ef3c8923fa1d2ea35927e1030b0a70921842374fe8cfbe1379c0d23c06024954fd4b4b77c98c8ef93beb96c6b165aa1669d32a0897eb705a9031f9636fc9ed8e98610a24ea878b8349198945285005435485833e707b3a91bf6907506f119aa4da0503c5dc7baee6e855ba98c7cc33abae0e23dae57cb8654e1e90fcbaa1ca35697a25061d225ba2b626699b4802515fdf271f324a3af9dac3fceeab0339bfbbf00934912ab1c05f80cfbfae102cd39c978437c61b17d391788a0b0613b86b51d8f5079a32f8498224025e835077f57ff1f055af2846245427d4cb4fd97e6c526a9d7c417c0f6e051b2e1d3520a45b6865bf53b05dfacaddc4a39ab1ac06657ae2fa80ffd19003e2448de43cef866a44d59b0e211264338bca0bc480308fee2ff9950660a2813029a85836ebc758abecd548fc96c020eefd2ae1ef93435cd692b26b72e3ec803eefaa7b8a908bcfa74e939ba82f50a49a1c4e45ef0b6b610f37911f8d28d01f455cf17588d9db97c47780cefd4d32be7c9a4309d31fa2710d4d0bb3c847e8b43cbae682a2974c01ad8fc5563954ec75094bf3f4e55e28728bc425160f4e9621a3a41486dc4c641c08ba3bf170b715d486e355d5059277007297c7a8dda904aab666a411a92a8a88e7314819cda8089653c38ac789fa7e1dfa0bcae9a9aa3eacf03368ca0f59a47e94af0b09a564602734b3e768e48e6b05eaf7be03586a5fa03c73121085295397903994b3c0238fad942ffa17bca3a774abdddc278de187079b60e00a4c775409e3b61dbf5a59b02df8b77ed1fb2ed8041dbf88f9028e36c78b20037a5d2bf60b1d8f58638e3c743289260a5bfcae7946951cd640be6cb80612796f746cdd76977522c4126101d3f0bb0b1f94bcbc9728cab904397719205ed21ee1ac9409052ed54e3e46cf391009956f1884a89c7f0c2b4dce98a5419cb78067dd7a1822b46777dd07945d68d4d7d34698a1a3f7ca2c4998835212e4ad403fdae85a02c45e226b8318abcff5b791182b64c1c90b118d9c29d91dc147d5818b3681154d32d3b33ff8e56ac2192d4052527cf7e8566b489135c78286ae6ac87a295df5d6561a9eeb3038836b58f8a563643afa1680440925d5398883f10508741be320ac6c58d230f8eeaf63140d6c60ac900d24f5c6b5b60f6d813edb94c991f5676157320f3db6fd33e2a8ab87e92f7f7c7718fb507399a85adafe3942f8267216486910f6787ad1b455993c05fb075a0fb6f048d01a502d8b9da96b3752356a944339ceded31007ea022e0d4796471fe2661040587232758e46d6714f81fa53883bcf0ea5590a9ec9e7c4b94a6ec399aad3b81f60e8a2a07f924efc52701ac53eb8e25718c301e16a373b10cd997f7a2ecce6f270ec04dd4c27a2c5636b6b20889e4e6911108764a8e48c2739d83a4e8e66f95a9121899625efaba6cd348aba1fe5b60ec1d6bd2803cb5eac75efab6472a9bddfb6453bc98dadc6c246a1152484c31352cd7785baa371a8785cf59f64fb0e840acc2dd9de1a64d17903e5cc707fc986271dbdba632caf479829eeaa6708945d4003ced1017b4769ff7038f83f32d21b67a3ee778fa1a5d2ebd33776dd796da8466ee68d07f35ee4107b61f00bed982f94d8069451b9b042e78e5ac365fc4816c2c9923ed63c483c7d639aa16e7ad4fbcb8354f748bc3bb67a5bafe70cb48ac175ddd9f9c6d86d58e0911e9bb5f7e9d598012f3135733a0c8a9106358d429ad64603bbf6c57c5d0a3a391c591dda9168bd1feae8de23640a41f1d7d9cee48798e21d0fb4a8d7cd8d7652d991a246b6d57d338d7f965d7e4683f0ae48eccecf0a475245f9f33bad5ec4c688943553a0f94b496de195b5eea86adad1adc0afc65dda9f70e43d853a184df9eed774a322a97d8d1b82304263067b17a5d50928baa384fae2bc007929c22c05bb74e3c7435330aec68df4a40e9622462881a9fa160a6e9493aaf00fc665c2baf1eca494086ee05b59cc74e4cfd91dd0818fcea0f53dbb50b75965b402dbd1e82664a592af2089980799ac343ec0b70c36754b9f7c82d237008b46994e8be4c6a00b545bd1186e370dad3e398e61abf20f980dd4eedf53003f9d3307b30ea7105590a29d2fe55e02388339be7d0cb8a243fd572bb4197e5fc5f5b912a69f09b6a5294848bdd19a652da4fd5c638d9d7879c04bdd441cca7a25a80da135373b5febeaec2f36b2fa4a33d143679e4eac89f15e2cf2ef34550c590c40426a854a627bd9c5ffa2c85cd2e43423ae40c1764a6b07acfe6be5040cc3477250b9fa725f4382e57e0ee2babe440e36434ab19b0ec2f001cbcf821788c2a02e8b2a23b525a7a7f01cfced901640d87c3a48bac72169d92d2c178fbc4881c1d8e2a9f1f411bbb578950b6c5b34af6013cc16af496938044b983981a97ef8031371ae8f028eef7d649f4a0560e70153ff6ccbb72c807b1f39e473de24b6d27d7b6808376b7553223fdc63ed22eaaa595c26e9f3ecb30fc6c9e1586a14773bdeaf2da5c6003e783ec65dfc25bcf354afb64368e9c538d3708e5dc635e2b62ba7a9f62344331510b7652f60e04fa399fe5723935d44d6cb78be7ebe96b57e7dd384d61e2b3cbfcd739dd13ee46959a537091d60b373acef04a3889286789287b060ed76d189fee6708c5f8f1af9119ca241f6b934f0b9a78d487f72912d943ee74fdf7267f2670e6ecc8bee4c2ace3dc3d6f61e3de2e92d993450d10cd5e29ac7e91c0f47c4e6b142258e075356271a64b122348e072762ada3f11899d5b71c8c0680a6b61aa142de67025b57640e35c577d937953d1791e1d34ec1529e7ec01535b875f87417cf4194e36843f664d5c7f72aa31765900be30d760fdad5245d4696d35a6cc05ea853173e50fac202a4e2d903b3d876b34f6ba09ce6eda810b6e5e0d47a664072d09967c18f71f37917aeb9e47cd1c5d02f5da2c0618aeba171719a03ceac7f94aeac2f10363f09a5cb8a3240703d1b6afe0d3ea0d00a72bee9acff19cbac28be12012a37d55b79fba3705763b75d16aac8209bd164771411b3ec96c0e7bfaaf604074e71336e1b60d8bb53801ae258c2d9659d9780514b9319fb8eef09bae972ceed2bfe91f7ce41c861b3c186be4119306f94d9b0a183ab0e0a0c20dd5e217cdecac65113f8a7c320e177544e6eee8b3ff4eb76ca1196eec3b722bd0a16ebefe705ef777ff4e86ed751c6a7f80562f1419b9e7dd01f7f9c0f7b919407316d824964ee2c14663b3c3b0602565dae13059336dd9afcfd9042c4af74abf25b5ad9e4bd49795ef3e01371a5e84084494823b8f93191d14a1c2b9d059be8169866222ab532b233f7a0aaf1613517cada50f71057d6880e118bdca0d8f6265ba1f8582faf97b1d04d8d85e26b1b22f3a501ab930aca7129a05aa7e8f4ab2d68110d0f9684cdac3af5332c753213deaa98a7f079eefce267cb69f7c67634c74eada140b30b3ed83a0d2f8ccf65e73d3259942d1c3dd5de409608612869a198e21c51598cb5b07d674daceb0df4a58640716e2e139fcfedf43da2de3a64a4ce6e7a8f672f3590a1a2cda3c2c4edcb1a885b09343439a15c62b11b26b44f4ad05935722fb4c98cdae873c9be541c207437ffbe2b7a80227b064572552f878e39f838734fde73ba21d8466f8d62c83321d354a10c3a6dbc81ae53c57bf03dee816b7de38c4144b98983e71d9d05fec4c08c53622a70f80c9b268928b659aa6cfd95fe6fa451d021789a9630a71f7c2b1d20e73624d3e7892591d9cae0654052e5caa40aa689c66b111f6e70ef4d98382a0e3123192eedaeb23de64a2f22e68081e533cb840c42db55de4a3e5646c9e0d7b3fb842f7a640dca6fee3abcbedb40f6ab311494961ee2e823189bf6d8aa91f46c333d9f384d3cd43ffbabfadefdf7a7e9a6f7baebf73a483ce68c775af34e846ae009318e83646edb920a31ecd4ff3bb0eaa9badfe6a1d26c66b86ee69e23c67abe4eef8638a6abac625605dda1229853cfc2c31fcc562179a6078db6a82a38e22c3cab143ecf1866d9fc41d5ce8cfbf1cef0eb67d989dc40836246e5e88331b479959983f4ec91d24061c0c88cb7f03c78a1b76e4f9303a2690f0308542bef979959e06f78a4152eca5f9899424b086320ad320025b893310c4c36aa0be34532d9f025a88b5e11e2b4b986b90c4e0511aa0e2c65d06de49d85bd1d7823cc819504f80b6327913e2b8b5aaa491829ec66d9b75ba5ddf5a6bb6ababc950d1046004fb04ffca53a79d8673d695468bb6cee9eed83d101e0cabce36add74ba5730ed7f04876e862fd07a2998c14a0bfe2c9d6d25bc8bb8873707e97197eaf78390a080744790bd61d5dece8360f156da94a3a61d225f68c92e2b0da4a59817bf7f81ddcd16f3a20d649f82cbd38e18637da7306f8968aca7de2c16072626fed7cfff047607001a7bdafcdb52cda29897aea74c59402564d11e9ea0edae44872ee60a8011867cc53fa38401594a3d38a32e060d84c0329b53e1d9a8190a9358f4863544efc945a1d737cd77f5c6e598605956b7c9211e4d8f880b2d8053511601d6289cef348e1f9727598a21a57f99e830d030a2db74ca7e0d1cfc621fc81a05087dedc0b7a3f4a302b63e5799e50d3d9de36534afd1d5e209d6756923916010f94fa44f079fd8f6e6f27645bb0abecf1eec911e1204f529db990528d435293524904cc5362a533d278ca267085ddd44ffcc2a0a023425dd41764b719cbe5b5c8989b40def1417caf775738ae660db10b4982064272a70aadeb92dc7720ca6dddf8625ab312058ced1922592bacd722d17566d4d8ef5212210a86c8c5910aaa06b43de1ea53aa011450c12e84bc58a1acf17b2a014a92eee2b8505288b880fcf8ddbfe7da413467a0a29635d3a6e4a9141bffafa63cdfb21d124df06b2aa82585ee1f178722d4de0931e88aeb9b0823ef4a4ad0bc04c97d02358404c8075ccb9bb71364352ac4a9223a55e009f548037d98f8c6f0d53715938b3fc607983a7990531605ff47322a511a7b7507eecf4889acbe8f2957dd5a2a53137b4ef3e920a2769834e23931f45f70321dc7a425b6b131a229a8c4d7c1087699c1814d751c7c806eb22fa120e07a3f7a59fdbf51c00494d1d9cc947b14ef3103aacfd51a0268469c76a628182e6b170dd8ce36f52b329f89543d85cf0d0c5b87ea24384f2242bcc35317d53e0a91c15d1c921657c05e1098611d2fda349760ac815b7c61d2da030e67aacd20358f54c255add543f22e5afee28bbeb969a661934590ecc1c3d8cd66633ed6207c7d8605a2c9d72bbf8fd6cb6652f37b51120e634c0a438938dfd68ddc941519e8545fea41fbcb2e65e77158f7bbce6c561a951b4ee6bbab3cdbb36ff2ff8e1048422aad5099f9617438ede1979361032887ff2ce2c2f28aa01f692116994dc05450f572ab435778731277000f48ae60288cb01609ca1ca60dbb48e35c1a85824934c9a7b8eede5408e3714b88fead02c511c162502bc4d0c8f33da4166c16acc1884336e123675460d171c33f20955c894bf05737a68e3081b5882f7441a2625daeef79ec96b244423a4f992628be30db48815a9dae2eecdab262f1f9c54df3603a419ed5fd8dd7e0353181c3035dfda84a06270e3db5c4e2a3ee695b2bf5391bb2008094dc4bf417547e0785c17ea56c1e7abbf5cafb40f9c428f8cb35370ab5092b38bd2b33cc88dbe85f7cfaff06771e4fe664cd89bda8f8a9e4695f4fbaa5b0bf148c6373dc77cebc0d8009c05031722303e7ff6e4f49660202ec20d6d6924d8b716364cc8ff60c837ad1086f484fcf64cf71f747bd0a72ab48b7c8ff61fc403adde3253fe6b6f8a726b20c9ab2b8efe03e6a22dcfe30f004b2cf5219f79fb881931be2dd5a5236b3bb3413e02548b28ad729b6e263c444c41d42d4162cf4e3c83e1c6985e84939a8c4c9f5995613fb353ea5f49acb808fb872f2f5d2382f451541b6b0eaa46057fae52c9d7ad15b2d2034ca8f82444098cd644d68c4d5003622b41cff80eaba989a54f1d9ee1be8515cd41caa27c85bd30875ef752e2e27d934f9f74d2d4eb94637968ef5a420a63676c83c942fe03f1dbd1b2aa608faa1a1093d9fde94e3e835ae1c40e29251a85e4ed40c2f5b7a2fcf62768650af7634c8153203024dd6d63c3d085c0a8ab720b66f022d1b9674dfc98e0ea5fdd854d48270b796c935102cc32ed0a389e79cb3fe3261537e741cfcb5209c5d4725161d2f4cb199737debea6b7497d5883567c00c967fa432b1fd511822a907ab5019e2d0289ce79d25561c95064a3e73bd54470bae829825cf1278dee01931314fb3ab93e573807ed7df3f655050ad51597e4d494aa55c08775be61c6c62ac7336454bad1bc8b9dcef3f6b8a88107f8c87dd0ac3c0d5372513f5887335905743d39cd66f20abde60bc0b96623dfec7c1d6c1962fa06495d9723946b1318609cbb7c87c1e952fe8f61beb352ab1f0b4b6cb14e970f48a730b69ff7be4afd9000572c6a83bf45168cb9948bebece7098e2b02e89b0e00141ca8e9e7517c3804c3f1d2233509100b5fb01138f8e50cde1414cb5d33fdaff786acd6f64854ff0d635bacff49aee8a62db2afdd05736e4ccd26ead9b99086bb046250c0de2a53b12a29e81b8f8241c33f737b506823c7259e9eb37ce7c50783ec24d858cf5503b8b044c962af1be529c79f2e1de78d64a728d02ec4e9360d7d69d5bbdd9a13e2a865e9cb6f9bf2c09a5bf98e7345747df37c335dea394143d2fec9091d3d3d237fdabbb4d21429ac60a0b83fa9db382dda7f0d444ecd5ac1009aec380b5a7b6264b9c4ad50b67575dac4a28e96686004f2371267be1cac849ac5b900cc51370d5d6aa11aab3d73dc102d91f329a5e94a60cca5740a9e02531d35e7231558b28fc6455d11b6b3e88dd9b8a59160dd646746125cdae8f19ccb41a47d33083e93073e67ab23d4a04f5c2f76d4b02340183720f52439083195a2964f8b661b7fd05146c1c6f783896e3b5cbf64a24aca407f3791dcf76103bf47343720029dbe239d897bb2d66d766a8ab1710ce4a1ca111d11e17ab3f29168f315d41338845bbe3ed30f5c75a0406c1d3755155a9860511bb05e8b5410dbd6836f0429687d10ae29b2171d0c2b8be71c06322ddee6cad1b6b6b3593a77a724184499a59a00198b83e1ea944ae574f00753d64191bb00d69db13db487946f03d97a9aee4b3ec6e105a0c771062349ee4d32acb30cadac76d5c68b00b26e956528f2d474a188a03489aa88744fd630f0c889b512bc993046919a97480e96ba2dd6525bfd567f95c5588e14d5c2c540393d7e11c9438e07e00141700610229138e94f92980321ba75df15de13b17d10e4d5947122e217d488590ba802142d1069ba847f060bfd6de1bcf10cce23a22515b86c6ca7f037aae88cecb0e252c5d76c113b07eb5a463ca95028861a0890bc3bd228cb77efd30b68fc8b134492b42b5a16b0b292a3ba2247d457844ba775fcefb05bdd7771fb79f40bb60f48de308a953c093a5b3986c06e0f0ca3785e0060295a59529e69007c7a688d815deb50230adfc90c3ed1df4a9f65e27c05a7272ba58f5a9165cfdf07119fcc228e0f5a32eda758fc690ef6a65b7b887b584bfbf54e7fb559202c7a6fc628c82cba006ea866cf288c7d4990c4ad44b8242bbf80f3d13658f4f1f8397349b61ae4dd616dc24d0fb3fd0df0e267c2409806439d14807a0ac4ebfb84803c3cd0d92b0ba2495fa4f8489ce8057625be66fd40cc99539c98f7849193aab82767fd2b4badcdf70d57dd86b0f670d89c24a97da7eaf510b6a73a95592b287824eb7cf21563f0f8630f767e80c3b04c202ee36580fee19fa80abc78dd28017a134093722db8b5aa122173ed4d1eb0765605bda2e82347487c78e065a20c52862cab7d059dff69c5f01ee140330163df3fbc36f989f9dfb39868fa608cd0dcf17b9e3bbe44b4bb31b790bfdee40d8f62d1c6a9e8674ab6d0bf11c151d4dc4808ced08fc03094f0edf5f73123f877967921b0529148db8f49180049836fed2ff509ab28b58de46010ecd1603680f0a687626ff97a5ffc01f63081d6063f69385b5c8b40c0c68c1efd500410a4292106afc743ae5b054936ccab21c7946f899678d57c8ea324d84228c2ca0b24b7fbf3354bc8d5697571ce0c47744492a2e906aaefa9bd2ac2084e205dd58e25d5427ae63f65c905c2b7c3c6abe82e8380334204dbdb66c32722f645b8d0e054d27abcd5773280234feeb8c7fd907c568dedd247c2bed67d547dd6fc58faa6486f50f4da612bbd9cd68c4d0b24ce2df10a2eecd4183753131eb191859768ecef0c32a5f9e26c8e85b068c9a922bfa9e216304d37c2c49984d16450e0d2584440f91edaa6ae7e6e7abb661f436758f067a9f0f43ca9b82c4edb5583aef9da02a6d0f520c3655db6916cfd8a3d8de73cb6618ae56ffdc2e16de5e4b3c86881d48934b73db6b47f144e2d42659034479b1b398fa2ad90ecf6bdf22c923de9e304070793b4d32ba7f4f05535aeb3a0af4fe3c90442323b331a5416dcbea2edc590ea359fbaa8982e73e28485e86401edc51b72560afee7c4d79f87d7e6e1703d360707fc01f17f8a23bc24e98d19d9f37fe1d19ddc2754123e878ba26547402e9367359d40ef916bc289f36a5b63bdf336a63f4e23f211a3cd0afa6763ce09237066874ccc77ddcdde214e406275aec9eecc7c85ecd666d54ff08a508af33c958cb1086f0b63ad85815eab4617d34a71f486d835602504ab82ba172b559755e6a200fe09e25d55b12d49ab4db4f4f5d134688b22e755a7f75d6316f4edcd88f87dcb8a6bcc9eaddd31d9508289271d64c956743aff3f6666f80b7774d44f5d6b35f10c31f47f6a420450c0ba0f235c80f6b5078dc5ea1abce0cb0144cf60f5634e6c24cdea5f4140b581448b6c70950995fbb5d96499dec3c12dd1260f26c81e98ce7a6dcc40398b9d1efc62c46908768c6ce60b04be82c2510f5411ac9898bcc04f469e842ab79b2abfc0aa369e9d993f37457a2adaedfcd84f52a127b854b038b174e6fabd668ec33cd8540aff6c73381732d54b5bcb6ceb2ef10336390e0747247032da9db6b275f196bf65f80d0d1eb6d06713bbab48bcef4cf78011abaca99c0df1f237ddf34a5e09a75fe1563e09425e2e4291d50bfcf6b85dd25fdd9d0174f9e654440e991296c8c395ac6bdf03d54827a437cdf8e61b7995adb6f1d5cacfe2faeaa368be7d37036b4d40fd91900ad7ea668fc0e614417bb16e62111cf5be8ccfd95a17d877a6c900fae797fa3b6162824adedf38dd59cfa949e797cf8b8bc5369bd3ab017d2cbb95fd6637117c08582a0cbc17ffefb5307a512ac322d9888ba36bf4d8928241cf69e0f866146accac95aa59a7e06115f5db1c732e7198d5ee86186709000915a5c78030966bd95c6e53e079ebff20f65f7bdadae2348880900c1229433ec0c5ce1f22c7302a32cbe860549dbb89890f917ac4141fdcb2900eb0f840f1bc1d8e083e5d9dbd3b38a12338345581e53068a07be6a1bc605617b87986124952ced9c7d199b4eaccb366dd4338b70248db90936bada8a417ae357cf54bd41e70fdce12f05eb40b47bb8bb066a3e7b3bafe7aa82e1c32f14ec3876d9f5e0b54e66fc603929bafeaa0799547265e800859f28a0671ab0c8588b015dfc2a4149d09dc8ed197e74a58fbd597ce28b43d56d8a126e508db508dc28b8da17a6880368dd884c0d1276cb9fdfaa549ba4096d30b58c41ad1338387b3479b791627ffcd9c542a65ba49232d7f94ef54d18c3fc60c29d0187e228387598f15337b64bef3f3133e8bc367a01df3e65efd14c8373c245195380ac2cb2b8760b8278470c4b1bfb75fcd9e523f5a69d9d962b4695b5f659afe6d24dbb26a0b67b857083f7f0f718a0110eb879fff0c79a80e5f72c13b64e8e206a4b36259d14fa31cf01a80617e5deb4ef092503ee1a01ad90e7115ef89ba7a92c55196d0509b6c6c15918d738fc1326da169974f6b0da7b77da8ca462181b27d75157b757490457220a7c7e93d31862e1230c578f8f11538a54148ac72338db3c11c6e494345f7bbd3ba0a486f151bb72402f641e321251c08b82a2bccfbd4d8d93204752583dddc8fb36dea1a80fda6693d38b3489ac43440f55b8337d5b3d8412ea35480cab494dd2cc3a8bfd913492750a35ea78a25bae3221590a8d5a8e054e53c9e926120c63daed779ca354b86dbdd5d09ed5fcabdfce30c9a53329e8517715ffb89d3a89a331d37ce70673158cc04e5b75f43be68d78ddf9e63b8b35435bc3812844648c36b4a836601cbad9bd754cc0f875158a627e48f6f316538fb309532b7fbc1a3051b2bc7c9bad1889397415ebdf556be1c587513ad8b04aa66e5dccfb36bc57e03853f52e73bf1b4aeedafadf7756fe07ce66fcc8a14cd8af03069a0e5e6135045f0f8830b3cd3e2e5f23b91378af1b2a22c5b4340fac8db4456a1b165d76975caf3d4c263abeff92b6ee9dd9cc379e8321258ce4322bee5b7bee0ec05357568db17dbf4df684a239ad0b678c40147e73faf5ddf2440e92142682ba82b54297ff48f1a8839dc62cd524a62e932e39d0eb2cc7db4254f210a70f80640df0aabcea7beedc496baa5f87d2a3be20124f456a1262990e93d1e850e0568ed0354f4128424504d600334278146ffc052846424e6ebb233bdb1c561709b182ec7a67e371eaefc4a09c650d7785c588455d3e5c6f2f0cf70799278a685419eda16fa0adc03883ecb9d71f53d3a353038b29fb48fd6c4c804b09e8be4de9f0749e18fc80065694ec1662cf44de97f2fe4fa9fd0cc32b04279c3b1a3bbb18924c98b524a55a7c5f4053bb65713d07dbcf74182e8fa8a7cb1291209a58deb47997b5fb5f281f6028515af21904215cab456e90c004aceac3e2a1757b8a8963d9a271a80e1856533c3844253679cc8f495dda6addbc98d8d8f0b1903b797e6f8d6736902e535e5d7084de8b98a98a265d60f091a0ff8f0415c654877ded29c9eeb95b9aa26abb6c7a21076ac8db903f358e94ce38b0adbe7f61714fa8c028340bcf92b80126181f30a082d88ac0a07c42fa4435ee0dee6fc6917dc0a0ad0db573c024d1ab868d72e876b0e428624964c952ef79fef55f85355821db4fe1e1136dacd26825abeef7971ec42509da3370ea5ff31971d5590e03de35096ccad299602a55047c8ab3485d41563196c5b4d3880ab605c73eb5eb8165ff5ee5473820e93e46d42cc71f700982a32ecf64ff1a565e58ae1a4649dfab17096718e6ff5df6dc059e9c65c4538072336a6ee1ab29d9138d017da1971335e8a71a433f6d13781bea4c80279d2656c0fae2b011198cfa13b0989e228fe2a8c29061d85155d69b51814235b03427276ee228c79a9ff8a3005e3260a942392a9b62ac89181456c40e9665a906e6ea42ea99d4a632c67f6c7958b10662b01541fa53b2e865f3641515d2a685d408db977496d8a610f8977abfbdd27d941c2add24edb67d0d86a7304cdb9637b75f1a054d228c600ff5466a4df03cf5a2b53c367050e8e7179be9e76e8946b9c3917d146c43a78af0756011af07245aa3d74c84752f9b0d08024c532b077221ee8e695d66e572a66042e65d47a505dca98578c8adb02f7d1c2a94c83f459d58f5ed936a9274805dc4ec5d29788edb8b6818d3108f0b73f733a623b08c15e176e8a40cc179e8371f04a55418fc081e5a9e9d2dec90b69cfb0ede5be668284e337c7a6cbc3209698fa366c5c413e3bc0b199c31409c729abef337ee7073b9b1e529d3ae0418054371e9da6979973be3c56b36e12c85374fe238865cfcb55e5f30ba80ef00d2bfc2c79022c8fcc31cb137c6a878f9969921d604ae98899e9d519c75d95171073f12adf00a2ae17d0940407ba4cc0cee2bc82ef564a87d5b0701df35e417cb9a113ced67f0af049aa5953c3aaa3bd40a5a8d56c8280c0b12d4f0a3ffaafae3503637c889eda78e7faebe83bb2b7c353ac04ad8f36c3d4e587c5ec1e0d63c2484b0aab8b297ccddaa1987d96be1209facf100166d11a7d17203d6950cf1cb3bef2ef2d4039120464f7f828f3f7bb99bf82d170ffc320f5f5bda400fc6a7f300e446033bc5f7ebbd4217d853f379fe1b197a3e1b3e02166f4d54394fd3a014b1ef6f3eeaed1cf8a538051b192df38f161a1afda14768b792c609e0b612c2826995414413f65cd5c6f827e922e8b8d5cdf5016dc62db320a212aac3d02a4c3cbd86b6a4381d27be74b4b718502e89886aa485784f20d6eb07a878886e2ced02a9f34d42016b8114d55eb0ce2efe413d6f0336ad4294fa6683acfcdb79520688fd7a2db9fcb9f3e430a24b3ef359467b858b3ac4aae79ec836c62184c2d666d2b1dc3ccc21db6dfcf566689f87e5872e7938524312c563545c8c7c187124f3dd1d4bbcccb0cb654d32efe785d4afa96f5a6ff9879ad1f93bea579049e46edab020ab9e30a9e8e9be68f76e2bc02c51b24328eb2a6d0a3bcce9e4625b0a9bab52b203b50fceeb063d898cf3184f400447443eda016f1874631edd5311134d726608a4523e091b7b8b7eedb22d9826274cf4700aef3f177196bfc1f92e1042be2439c77b4bbc1dee8e5ca28a69448a9014a1a9fd2d5d14b3103bd7cee397fa9d4e34f097f3491a49d50a5fe66e00e92942740839994ff9a88db1c00b8e28102f61d2e0a37e228424a33e8cb64024d34a8de220cfd2c51ba0091c2a227dc84714a60f0f9e4a0fc04cc852542216c5a756e33c914e18e3a297556ac19ad2d796e633de97daa53ed0d66ebb8153f8cd2fd01b197f9c8f3bf89805c694edf192fd134eb942f37820971df1bf096eddbe609563e7637891ef1ffd8c1f557afbaadc7de1cf4545647ce41e51444591b072431c4ec6cf094c2716c365ed2498a81a44f4f10314b15927dfea8c012dc089549f11800b76680a4dd946003ade35ac309a4c420a7517cb1399d5f8cfd91ce8e8d92dcd680b66e6dde5902a4f86df016007d489413689c72c2d4088f5535aadd953295be45b2edf2282593b14f9e77cdd4af04c2d7473b1d3b02ddf76169695ba6320271a1e0d33a00f50c024622c7f6010ece88e03e0e238af667af9d72582dd973e84bc5477593c5611cde8d79285b41c7096313bdb1431520acdae2c1368a2fa5fc7e2012f1d23d355c2bbd319471b77a22844af1566f668bd54b52b4500bd8887a037a843b747bd46dc97689bb32b00fdc518add482328b30461954db7edd1b158a3a2d97caa11059a1bf397ff81b971bd24e8ad96067edffbfa3093d7e9f34639eb5551f3d6e9bc1743d8d6f98a66c9311a14a86f761171f931200ce45d62c34341ff4f677a24b563309b3441b799c2d66b755ed84c571ac1a1747a8e2d460ae239814c142b6ef7d0f1328e11b620b956b5c5996372b9305d001ff4bbf6197fbe40f62d19396234191ad09cd27dcfa0a1410ece3a7355b4e59a6ec71da467360f0a80b9a47fb212dda2a3b2823822511289a69f3a48f6b913207d55a2735a07333f283287b4177c55d1a309be5287b23b94b4f30597ae7a843797dfc04d9d32f3826138f772116631bcdc1f0f252214c0be07a269d9f92e09071221d12e2f4df8e846d6265f78dcf95a07a6a66b2e054cb1f401ad7abdf81bc410532741465850b06d00a282c81561daac2a7945894d2e9ddb80ec7e84dab9c9444ec9a48aeb0bee07eecfb87b305762aefe45e613a62b2e1b5cd2125b945bf346aedb4f1dcb01ff20a70b9d55d445464330a0365ca78ef64c280c25e0f2dfd1f90e9b3dfb8255db412b2793cf91a914d66ee574d8c5481275f2ffc0bd20907ed232e40cf572f650f3b9b20df3c1da05cc511eb1cafc01f3460520d59540608d83bee506c9d49c5dae91f91cd4bf6af4e7ba7ca1913e0e3d22f3fed6f9fba77096a4bfcd09b47f26f1ff64785634666c682e0a2113af42955a70d68095e9567d8d65a7af37ef9d705ad91428222b88276c01a82e425c044cceb2e4d950d3109d1d1f0497bfa5308782de55e93648329c06aa7c4d0216142a4371d0ca5e10e08afc4eda47d343c37b63dd056e5202e3d397c0d212e66a5f1d50406d8c0eb047a8727d7aa0a6f5c24f27e3be894a262862960318f1e3b8ba8a44433f13932945e0108d3ff43439f5743501b415c76d031acc351ca63299f8987ed37e74d7b5365d9057d7fc72a5f8baaaf0b107b854887b09cf2a1c25a684211017a66506fdcacdf4067505129a0c93cdf33143f0cc6615644217bf6c9e21138174877b948dfba3fbef1ab9e99d5a1fdd4493b98040f186aedfef02e1be02e6ee091b958ce8cb0165eaf629331622a5c9705475faced7e17483e220dfa71cf2ae6b04bcf9ba76ad7f2fd8a07d23a8dac6a99ba8bfc929b403f86c64991af57d8c68d8c820645189038691069634454286100704555d647db9828d0007fe4409c9c35e1cb0fa283519dbd3bed45025b60a8e83c487025fca91d8e3e3d828d9a182ff331ebf1bf5a7244fe1edbbe172ea0af4ffa4445a91d168896e42b9f108de91866970c31b6d4d496e00d6f321c933781981aab303bddd364c6ee14978f6dfb448cb4882843516417bbcb6abb0d800d812d2bbdea9d3863af8d9e6af982d0f4e95a1d53ea25534bf23080f6077ca0a2579a5a810dd8615d6ed065d0981a13d10e0215410049c4f949dfc343736edaad8a42d443d0b0ef5b0a342564da2959dcae5d02014c8de1b16f15c0c4db6129e6bc1c1ae74efc756d3d74aa2eadf1236ba95ac256450dcbd78111bc9e38c0aa0c989f6c0d11169ce76ad9f1603eda75de1a7994705748b07e2fe33f707576c80983a3ab82d9235e63dcee29eace753bd8d2e766cb8966be84d9350bc082cb4f71db2e50c1912acf8766193de087a5cb51ae7897a423429b350e314fb57d0fdf3b7419d72c257df3587c919b6dec98ef14278a6c0eecdaebf830875e591f4aa98d9b15c99aff07071b1a98938496a230159b9bcb091b064d44276ac168268246ec19bd67d56453181b12e453ce92666d5ec0b18008d0f925f8188354108fa508834cfec3f84fb836fd40b3b6ca1d7915beb26c88ea44fc9c7de840d8d65cb149ac6bc1655923cb48c449a36e94c256ab6baad13070991588e4e61aba968630df9cf5783a7a0991a8593f0fc7f9fa01769feebb28e8dcdcc77b10a795b0650b956a94597120825018daaab3023cf6091bf7a9cb98ac96078f008731512a3caacf61e5f764d8a57acf0ee61661527361ead048be13be85ad95733129ab05e4d521a1da81f08107e2bfe8bd92533c9d8a756ecdf5b6b9619430b0fb5e4684d0260048bba35ef5daf623938731956b3eacf37ddcd8e268e3bc5351aa6b85367d7da0c0cf37fef0cac309182b6571fdb08775d887e75489865b6380c599551204a0a21e51e7cec8299a31180f4158b573c5cb6d3a8a3bd61f668c36f7337443d231cc60778b249ed011f3c5ac38142cb3e46fc604d40d33084180a7e4b128d0b5c89e25c439179318c088359b3777d2c4443159057c6c5043471bdde99710b04c10999538670a290935cbabc7a2129441b426c046d33421a35e9168b8d4b1b1c6ced3adaecf038539611e5a92bb4657cb937e775325d2e0b5953b448e7b9cbe586af04d7c1aa4442e8813ee399c5fa3a9f58ba7fdc6865bd27df63692294d041a158343aa41f4686de6c3e92630fd906b4c3b16cceb174e2ea7e58ebd7447d3a3d11dc5cff66820d6a0c7364092aa0be5bf0f8d6923bab94fe830956799e47c1c430c9bb6b6dfc9a649ec90baa78b2b359b288af9334259a3bd8c3437ed7c884fb94a0e5eb7ac86471d57f865326cb15618681198e001ac8822833ea83b2095fea41c8af99be51ad2c97308e88facd973845286a98a592e86f5b93f2a6bbcb72ccbe03c7c21009ed392c86cb1f97b056bad56aede49fe6489ad9dff61d489f59571c88fb64a6d7c2019ae3e980265cb43a44e8da2111a8258140c31e93c5d14503913a705a1c1e81edfa348e06d9c28b4dda02d98185868145cc43d72187082c388ace7e19ee9e2b30f4f18f25c9545830235b46ed5838ed0b2b8193b8058cc0bf5abe9b3733a735e2e61ad6a11e435ea32f77530455aa65c06be6d1c74b9e9d385d4be1e41856f62df0cff507ef5f99717c8c98ee151f72a828472a17e73b66c303054cab0965aca620beb0a43996cd91427081d585376c4f04f58e5f74387aca95daaeb2130dbc08acb4d9b81a4f98eeeed61c050bbc0e59d0a18f9927bc5170e403da59663b295e98a1797e5434df7d8cc39f785b7492fb31a65b4ef8b791f26acc252111837b448fef81b9bf0e6d24b9fd718abc11dc1bbb103a5643d45d504b467364907c7186df40c585352abf72519e8c73abc055a8e44e4d0681cd89dcad907254e84ce83b718a1b643a6b564004b9eb36b7340e834a08ad0caecb1f2576c400be6034647b248d2bd3f8a7c6b037034edf8fbeff6c3bd04f3e952fa3d0bd93673bc332b1abaa31b2ac2792fb742fbfc6d477c02204423ea1dd55eb3a0e9acedbed6f182dc80747f488a4d9cccd280f6355226e6e0473f3805489e77c3ac8b832401011f97b6283996d347e97f98d8d639e1142626365a3f186eca5da5a39712ac1ff366e63f74e8f5c4e13f40915f3e1fee2add369bb880ea668564c2d1748035a13c14f42f65c88732a26859a8fcae53f0d84c593fc8d9754df6639d539cb612b90e9ebcb9b0909caf258aa70fccddcefdfb7e12bbe4d9662936922e31bb927817be35362efaafff252f493f97580725810213b3af048ed0b1089729f1705dc2c1572a9060e1314454b57bad6f3505cbbea99fd98490fb88dbaa56ff2221f6faee10835f6e4584e8152668d1715677ec9c70bac658c2dbae6a9a8f01e6ba59b85df1cc63c0c893e04faf53af156a76bf77c707478cc177b71e5f90f9cb422f1428467b6a7c812ac44e81a38c9cdf192c85cb74c727bb016f9e40385c5114e99bc48d5cc0fa09cd763a9d80b5647ba643b0d85d1e288954c35328f1647bae4a7915db438f2f8e3f6d2aa88718ffcaa62af6cad51d435dff35f2d98c61ed1ee68399e8afdbb60aec14c7baa63ef8c38b03110d8fb44b1c5e9b293cd10f5bb0c7c3973f7ca907fdbd72ff83ff35011d0d1029a63110d1702f9d7e61827adddc5b1068d4a3879c252e494d88c7c0e1a77a7df12934e405e00f4e2145990404c44e284bed917c65a083982e55463d73ee058051ed2b5260c501812236ed8137268cfddf25e5ec40b74cacb8c2684c0df7a19fdd7df1346813994b61fb52800d5cdc878571b448da9320894a8269813e96b19fd3ae5a76a4990fa817caff7b9521724243f889eaac25cc377d6df64c9e501d8d44b30f71aba685f85b1ae9857a23d133cb47196b807d4ebb8766936c28bd58d5acad1ceb31cdb59a6826f25cf866d430c3b34af96d174df7a6dfc252cbb0dcf5fc15946a3b3253380be242e3e40079cd26d11c9e730ed48043047f81bca6523027f88a364ecd66b2c083a3dc3139907225dc66263da3513e49bef5ae844c9e4ba4abd3a2ef82f0c31bbbdff516f9d879bba8a8ce59133464d5043e1b1101a552c9f29661e6cc3031b478bd4e1bf7fac6b79e6c09125ce59988a7d1c1b7c278ac13b79f275fe53c8675a7509e6bd4ab87674206cedde3e9af682da4c76bc8b33292013c4ec41e5cf0e71b5becfb528190b58832fdcdee718987cb6ab679bff3d31809e48628a7269abf99e4ec376cdba18aadb642c990f12d3a017e0d26c617db836d2d0296a36cd4fc189050713c7bd7963750bf1059b73b1614aafae80bd0c6e2552abbfb352a34f2639499d226177b22adfa30429c14dd992354800c4b451a374f55490bd6d02d03663f3f0da91fb52c671634ceafb7b7f3e7499c3699c130f75afedc1ddee42e5940f73ce5463f96b857f0073f31476dcc42929adeeacf672f9325ba53c189fe2ebc162efc1a8478fdcd805796455cedf8ed31e87b932b751b006a33246cb2beb94ebe44a9257a5983fd1a9d9f317d3dd10bda11438323283335bc746ed4bb74f4e3bb98d559d000d490ec843cfbdd7587557d462f09ed0620f52c5c6fff7c54e4d593c3341f68405791c1e9b01ca233f029263ce65ea386b180f1e7a9cc5eee69154479bd017484f03269e4cd7f60226e2801227012f713d6abea192cfa6089383c856b4ccbc3c3e3845a507a5051dd9be7c885138d7a1dee1dd6afda4d84aec3b7fbc31c6232af11234b3a0c95c4e4a4e5cad9b56b8b325d69c257a037f38d293feb77a59c1102504f5040612f6a96cd6bc5ea000a626249aa85d0b0fd854c68217e9db8b6e0b1fe833d13f5fbbd6b0788e64961dca7c6a9a362aaa58d508313cc5fb368dbb57f48d9921633a92256bf49a13e4c00369f7dc4566a66f46732945a49baa75198abc50e170373ce3a381cb3bad4b040285654572e6c8213e2d2b8b4407160d4c17695a5d5d9d653b16a12e39ba490ef49ca9c075f2e01c701f725a5198095803ef4601ec5432026c8ed9d33dc38ba021458c24323bfc2345e006b5b029b0434f28e04280ed1443058f53228aaa314cfd1918c2abe80c4aae3f5582bef8576e4ca7a78912fdf9be2ac9d690852cd504e07e59c8faf35bca2a785417339674292cb5a19659a8a98ce9641c48c35dc831bf61d24b09c78c2b67abfade50ef405c288b036d6e4cac9c1271411af959235f602dc3e4e7e882406110f4e47555b44d04e788956e33439d81f33e5c318e1c156e148c10e003d6008641c26d0593cee1282e5acf7dcc4eccee4ed4b36b48ab3ed1b274046a83a5f102f808aa17062dec3324a1e1e6d415ee1e2257f3f93400cb5a6efc1bcfc517024fef04e0a95b3da94d40aab810f24943854a10dfb89b9cf9d0d10fb68a61085800ba14581100af53c3c326fb103c3c9ff012d91db2d44c31579f29f522175a470c89e8adc62bc1a57113839711395c94188003edf748e477550387d636b3f04debf1d65c1974b39c75202235b2ce9e5c5743148224632df292b88bae45c77ccde542c9ca16864ebfae169e04da5a365b1714c72460d4d4203e9385ac86be04c99b090bd2a071e28570b2f71a360324c0357adbd7fcebc8d65c1693c74956ea85bf6e7d823c0268c84ce6a57c7b48e23205e15bd2a68f43606ef4e8d3fc2a1fce594df950c95717af73c00c845b10e3e2fd1d168bedd362759654d113902de61c25859292b152529cfa200dfdaf6161dd96585be5a6dd9ec6e5decfcbbc5f78b99b18b9481fc8db9327b1a384991109d01a804f38756aba10baa0324c6487e339fe2b0db6acdc1096c1051cb303af0c8278869ad1439702bca63293634ddac1856f0147b082fe6332ecad08829f34a72cbcf969c5a24cb1dca073bde74e0cfd183631dbdb1870c0ffaa61d82f80de0c6c4d616a3117574a82809c06a4883ca63e0314342550efc395355540dd8bb8e49c844818784274bfd86465350a8987586625e41bcff984f6edbb440f1ceb42edf8c759aa184f3ee9fd0f06fa6769f98062978f7438d36e72e55d9ab190ef09b27037e477193157ae7b8cf9e808c3bfab668ec1acaf224cf21a41ae7068a34c2bc22a518129f7794f966369dbaf0984c3b4f88d070ca32d4b988c3a18d7bef087233d6ec03cf20d768d41c5e1eca012e434aa1412d08026a5de46c24cc370f8d387030657ef46d4e6744f342070c77771be046210bda3e075d27a4626f16e6a87afb45c95c524aa536f00ae2782aa0915cf5e3bb038159038a58ba5d1824cb04a237d7a94a842d3bd075a37770c7edf0dd11b20a17fb12c05a8223278d57788109a721b8052b0d3cbed9eac8c48e4ffc83e97bff6a9b184118e2c09169e79e16881127df462fbb4f581099a6031e7d8380b9f5499640dbb1f1a445d02d3e9450f96f9c8a5b43eb4e3205527da9fbc799eb5597bd8c761808add79c2e59d0a2161e02f60bcb96d2013f78d97a519f5be94a7827ddae8f6af915671ae50716b64098a2d9b0e309d7158b269248dafcf3666c47cb08d52854803e6e20ad4173e1d7a683d63b9b487204bce22a2f18a2ab87f0a44fc846a3e4c728c2691caa226263b1fcd6a821e279269d0e38ffd30d852947008a180bd1ab7e431a8fc83585c8d8968ee6fb2d6daa3f695837eb558064ce81d3e4f23362c7a30b8def0e1cad6b527ada0df038ed347461d956e7fcd60a7c98bd36b3021513a403c8148f181c03d8fc3f04cdd2b8f8e4124121c408f9f8cc945ef9169c0c8bf072c6826823242e077f2325d6dd0f5de852dd2af1fcfe123cefd014de7237839ef4ae393752bfc43bc6ef06a2339046561c81a5026660293186a703631fe24a76b13323b1509dcd7be0ae1cf6c6922f8013756e8d71108f02ac42473f21f80d70e710e3953f5f1690e22bbb3b8594837409e3eb7519699ede13d5ca6b0aa33765c198d4c0180b2cfbd743afc36777a346276e9fd27c0fc58e10dbdadf3cd45540204d718cd52f8d87313d44fe9b6e9993e519127981878a32203437695f21a5d421d01a8a5c68de7c23042494758ef5d344ca8c3d063d4cb9a570e736ec3e824f575e5d59093de70b271359c5491b5997d2825a5af0112b89a96897d93dccb15ecfeb0488b83d0f731cda2e920e388728daea48b29a32b1adf517079f3345fb296e47365df70aa9598a735e317e060f8a9eeb5c2bdaa2372c3bf5bb2fec4059703a62a0185f0cfa94cf734cd26ed49c06f7a2149d0e7eaa628f588e5d5afc74815b24c04d3e0d306e0ee0a4954f2290d94e7163d5722252b18561f1f5c1476d6b1d75d000c0cf8de0aef25ba24d976d7a7d128d4e2f9b1b41e6d54d5d5bf9397ceef6c311ae8b3a08fad0dcb013a1424a22a65bf7de311aa487bbdd42e7d12797fb46016fd41de6effc87ea790049b86cd186e31c56c448b8554c416482c96d423bf7e449250ff8f1f35d52e07b3188ea7379df6ec42bf30129fdbe06e08eee3481d8888e43ee481bca4363aa6800f53f4877e2ead080625b3e0bd0c71f16640996830d79e5340e91ca80a94e565d94bf4c8134504c581b878cf64f3e87f979ebf9c6a8858786e028568580422ba525584c8b24ea4711b217034fbbe97b3aa73824ddb74df7baaea1fb54b7cc6659acd7c2df81ee5b88c1e7e6b93c82fb04af84b5d583e3e4cb2ebb9a32191397f13b648140cb165fd0803256269bfe1d4020e0c01cdab84f30c5d2b11d43a57c7c3ef5747814508607ec20ca4645a1a0a3e2445d96ef6dc5f7ec5c7c73a9caf42252370b34617b92974017f9924b66764b4e4ecd2fb5814afb2dd413a8a9b12183ec19fed07b5d3839a2643229051139805de8821b962e301161321b1823398e7c3ad40cf155bbbe254af605d610aa6b9f2635b5c065c443d515fd49594053ac6d54ef8875631679637d65f12cbd9542812b57722090da030df62683e30095887a65d7f4e28219f3ed27bfefdab21a31b1665fe59101154698ba9327ee232453eabc5cf943d7e14e33ef703e4b00f891b0e62579567ea8df6063588001fc8edadb34c76cc8f49fbbdaf152e5f60e11285d13358869156283211fb0dd002962200707290494e6a6d07fd22cf3888e40b44d7f8222df9eef51ad11a94117a706c241cbf573f44f6fd502fc345b68cd12ed202b8b89d1072dcd76855a410c889923400d1f68ab640c0ce55e27d8f1e5dee76480523b45abf216863e158ace23579ac4fdbf069fab8476a3afc580859d170050d2d39086df7be33bda9d9881e7a788de0dcf7bea40905a6bca36bc2d04dc81d692a5e11a7cc3a6a7777731c40651a2b5da7acbcd00680c5d476a74321c9fff4ff3085b7eb36103cb0bff1e9b38d0e398e1f9d67c22288c1257ceb910d0f5942b26aa0e31b08bff4c1aad1cf151a952ad91ac6889b2a79e076ac00df04183578208305475e7453d6abf66c03ede7bd3a9bcbe386ec8b3e56e5b3643d97164a06a4e1e04ea7c6b945071fd73c4e12275384f4fbee39271612add7343edcd19048e3dbc72cf78b90bb2927d989274122064d39691326317055439506bf101c5c763070f87fc5cd8233b1c229fdd02a64bbf2792b86d864eccddd7c21a133846ad737deacbba40342702d3ffc1e8b83dd2c273e0cd7bd2cc7691dd290118a64c3965e1615df8bda12fb1218f3b5a0c9f0f79153f4e4590436f6311a08ee66044bd8b8a534c674385771d0d513fcef14b43098489126497774c0ff59ddd5de28df632ccb1a353b40ffa1709a40a073b303ddb557532422aa850e31949a768b4e7603cde96d075c87e492d291418bed49b96cf69e3c651f33247a5e9400c698bfb665b3d5a4addecee71c0057c84847a65a4b0af2f42660d02ce4a8a8c907484038ac40e43092aa4d050bddcb00afbbd70b253bac8233b753990da2223c17f2f03354f4778c8fd6d8d8b1f43c2b7c02e809c0ad65822e5b1688c1f70f0685d0c31742c2886793bb122ab3cc047594d387930b10adfb88ce10d84703ddb75f393dfaa24bc903643b889611c7b03d9b88faf7060b5c43ff8464a42514c8237f1d8fb11bc6c44ddc952f56954350945a02a4fd537c9caad27f120bc8e3278f91bf2b68b998991b1955f374dfadf87a978aacf0fa253743b735678f36bf52b1ff1783f92589e1394568e5c7ea924048eb632facbb07aff3456fa96ce301c4904173ec82c728007a2e7b9402e3ae81b1fe51e980cd41b5b83e079181389507cff283a610c1d4b0aa06641344933bcadf5f6248acdba454bb054066aa3aac8f40a4701a20ad8594a6fdd14a6db03b961347f407058cce7c18cdb50661b842a081ccd7fdc0de7a0f4428b37fb09ff1da08e912d083ab20f3e53fbaad162aed0f8bbff263bcfd34978d2a78e08efca093ac15d8011337bd7617c001d4b5c45253fd83edf9151f59b9b280dd531b3a560b21d2aa37c77c9d25b83a343b993740bc5e568e49f22546a8599d622874e276aae802166b2583a5b5503cef5ae8f1af4c6e5e1314be8ffdaa512705cf7008f849a45cb4c473585e6f892c06f620954f76a077b3c92cc62ca368f2de1847a8b96d7eee47ec584bd8514a43f8ffab21bc07b41104daeb82995c30ccba9a0e251d2a102168e36481dce2c0d163f09bf18284e080c6488505424ba5c256ad2ca04381c9334548b60574387598b96fd7f1d76954156f4dfc445d8b88ed585ffc2104c7858e5cabde0b8da691496b7bb735b9a594322519d9095c094609453b64fad3484b9e93274b261268594af776caad6e49f5bc77ded7bfec7c4dcb4442510f0da81f5e8061ca0b9313198511605831005330a165cc172699116392e4f900f0e1872ac44801922d26808225082856386fd4336008c0194c9c0126d7c7e027063450810214966e505a413a0d71c39c73ce1e6f68ae7274ace8c24486972a5670c40a9acab0a18c33c4389921e50c1472fd1ede50ad2408a28647ec124446d1d413793e8f8e183c5480058a29a35c7f07930a78c091eb5f20450aa6b0c01baa1b971c1480494111b97eec36f9114956cc39e704bda109801e39cc914222d725505084822272fd1d6fa8ea3821b50206b9be0e6fa85a219ca0c97133986fc7c832c60a79be8e37346f5217343806500031a41003863c1fbf5e4c4a00c316585280c20a098510355b2b7e07bb5b8c10d4e4f99f373473c894084396411846e4fa9f4385eea28ee45adf460d91ebdff0866a17f50421b07202a65cdf863754b7271d308ec895e96b784375b3628a1f2576f80835608a57a2162f9074783145982861b6f862875cbf07e88b2e72fd1f4082e4784375bb225a10ee00a36403cc152610c204b55c1fe60d551d1474395dd472858a92ebbfc010e5fa34b0121266b821072eb40c219f20620515ce1417f8708145174170a143aeffa242b48af7755dafa09ba6e2eb17242e50f8c224d7b7f186aa1135d4787122cf7719d9e450e143835ca3960aab61b8d428c68a14acb0a28b5cffbeac3023d7ff2b9ac8f5412c72c8f57bb01893eb03d5b8e4fa3fb21022d707b294450a725dd2e2895c1f842d74c8f52d90812d98727d225e6878bd6aad482899894133edcaf34a9729baa45053830e1722b0105197b8c872ad5aaae821572c5e86115dbcfbbaae976b56c18214797ef73a620bee36518124cf5f7d3184956b9b9e92c8138bce9309b9d65a6badb5d65a6badb566b92087ae297c9862cb0979fedd52459e4f5f3f905133a3531679ce295158b5d65aeb4e9e45042db1f7058ba2498597164734a2c832bbe1128563b7486293b76d73bdb098820595d78d422a494d97292b6437d784992b8b231b1750a0a9c2a866861566b67072452992a935d14c79e1621135c3840b2d2e453258acc0d262ea66f922ca66191343b785118b89122e8b266f04ab2b689d9621544f9c653a62b718ad66d32ef1586cf2c4633187f7554bb2802a9cc25861015a142d69197364015434a9b0002b8ea4a02149920287a2055cf1248514240be082f4399a4c6dfdb295564aab8e272e8d1c9762b872e472392ec5c0c50a3184912403d113198a7ab85549d365d174b020430e3218b1e446278ea0e59d2519a05892a1cb7dffc273bd9c80b224d39f5132998c05195680a48b4ed470845ad0c2ad39c18223eeab091597660af874594a607155392e359122ff52932b4ca83a4930189d48622ad31c645cbb45cce8da1c979a7851c495c971a9c91832382162e2ae725c7292828e14eecc71c9c9121b392ecd30460fa782eef60ebcd0c20d2fc8eeeeeeee186eb6736d312846cfb12f6b73fe25c494835105827e3ac3c9184252b6a726b8ddb382843d665cebb13e2342dd07ab5f2b16c27a0e17693deb8b70dfbd11211ae74cfeb45e7ebc2dfce2aecc7bcf61ef693ecad8ccdf6dd24209667e437ab2bf63a97463c60d6d035ac8fb8ef5716db749eb240eb7928c612bb7f3be48eb65dec345baafc1600d4c9c47642d066daf3c49c8128757929125966164f9f3732207392ca5c615d785a5918cc999bf1f8258cc602040637ce0032d5c448a90d6771f65ec65f007baaeebbec320f88005eeb7f0c5edf4dd87f1098b16b64464cc7bcff3dec320f80057996e7fe8442d2ca50616f7bd0fbb080bcfc718dc772c25077fc95509799f0ad75f853530a5d3978bc3885b6bb88e8d3c87e0affaf9e1dce0aade5ff5dc6c99a3acfdc8300ee563c70e9dad8ba1edec6b2a064510f42efa916c21f9124a3a5296b827cfa2e8d2684a1c76b307190b5142f16f0ba7466beed3126ace6613ffc148618ca498299b4573891f492319258732cad1e752554297e240f553314b563df7f50bc17f72d063f2064b407dfa1c547f0e749e2a2712e33e2a1c420d679e218ce0b92ec0e248bf10fc371a427d7ffbd14b802a048b00bc7909880e4aa9fac54c9b62507de95f8b3c3f93c8634bc41f9985962b57644d8350d67cec78bd646454d39f1479d8978831f95934451ee9a59f6a2a2b8e43764327f269244a9e1ff3c4b52831b2d6535ee38c58ff1870f800e4a5c28d1ebee1fe7020b2d25aa794524a29a594725229250754f5616cfaad1be2c2ac94db263729e595745220b449bc575c07e2df06af136ef430941b46a60dbaa393d2de6c383d95f3757c839e5a5cfb405cdaeda3106c73f78a9baacb7be50c0264851b9970dd95ef6d822c4109b61792bace1b6a2d0e7abb3bf548bd9dce0c8c9cb41c4d1a35256530dbb918db5dab238f1affc3c01e5f7212931d6a7af48064d2069bff74cddbe994d14a14145d249ddd1435e53eb2a1c254713159bef5861c07894eb20271b3d70f241079e4ab96b81209cba317686e28f9e3a2f93c8aca55ad7c48f58ae72742a41f1a41c24074caa111a41cc2fce6def5c1fc6dde8810cd07f3a22330999f79966c72c1904fb27cf9c47d4287923469e4a054d17db9c47dbc972f84e65d2ff33580e65db2fcf120dfb12bf9fd9c8a741a6e3515717dcdfb27858585b8de0617b179d7d77c456a9ee6af1897bebf74288fa202459372b0dae028635d83a3941bcd93311eb974d93d329c51a8bfd0a964f93964dc501ee121aa57492877a92807a5fb181c675cff469247625c9d12ae7f9d5df9b11eb9f263457271686404528aecb8a37040b961877941b9f2b54c18910c4b40e71fc8c854ca96c1acb8321ca1e6f72f00cdcb775acf644c65853e31e2b8012021414145351d4509239dc8a14b1d4d41426a922f9f38b9d374b8f2639634ea94ce9671b21286caac84f2c88a54b7d42487b28b4c924c5dee510cdab23c8a729fbcf84f902c2e618162924eb24ba52d619dd454a46b4992f2a89564902ea16a209157dca71fe93aa883918ecff151e76b212ec77795acbd5729c7176b2c71e5bbcf741a89ce21c7e74daee40298b4d3f94c68a1300ecea8e9f704b7a1ba269b24b9928d25f746de799d0f811e082e4ebcc0c504a83184e6cbaf6b2e80f939e6ebf86291ceefe0225284e4f81cb888fc4d8a101daff345e4e7f8fb51fee8e022fe3a709431d6b33ec71765ecfe90b1f96ef3fae834609f63ff7e278536bce12b13c1f11dfed5f7aaff1b4f3f4aafc6b79e88fc71190e1cda0f87afc7e1dfc021986de01a3804ca3fe48f7b7197cdcfc1a187c9f36138b434f00b872e26cfbfc1e1cb06879228cfafc1e1bb300d0ec1192c83c39efc6ae110c89540599d5f2beee1121163f3ab402d912796dc4991677e9ddee4e0fc39abf48e945575be28e4440e4eaf1263f39700b1e449c5865d8989eb8e83882b8dde5949465d6ef8b1ff2a03c04028f7a7179e73832f8932461bc1eebb1122d87d47c4ebb82279f52dc580b2524e282eea6c51c6de5e4e1d392bddbe5b750772b95b712b1528bd0d883ba3cbfd2d3d9244942a35262644a13f29729f965522134d2abb90ea48460a555fc6c9eede906398fc2f7706024b0e5545d51bf24ee6606fde90e3d8e28676ca4e5931d6be5ecf7943931e1539d81d11d20d3b5957f41a81aabeaf2bea64f4ad980fcaf673fb8ec83b99fb548fe2b1d9b9937545ee13ab4a36e52086bae12dba45ee538418395415d12197dbff70ba750d1c2e4d8e5bb68c206ba0fd48ca7268a537646be470433f72cae176d4e3847b73e5aafeb574433b7593c4a54734949472d8c972ffd1a447b9df33923f5b918cf51fe5de68b93ff490727b49b99f4611eb4b0e3d2bb228748b84b8e1565494fbb7221bb7a2dc5fa162cc63ac50381c52a1324c7e14f2280e937f24e6fe94e4e1bae34e8a314a96c450b6ed3b6a2a777f03a6d086ed94dc8eecd496d4b84706e972016b2f2d6ba5a824d418e6452fd418d64d2e112b640a3586f513b95063291c44107463c08893a21cc470e1c315412c49117534a3a2d4b049c0095210484b556c01430b162b284e0006892701133932753ed0b8187f36b757c6a8c521fd4ae9eb65ed638b438c514afa93cef8515c8cd14b8eef4a3551b76337998a5a26b65de692f27cf9752698fd5eb38836ec47fa21e0d0beea6df521752d8675509f6e1d1ac9f439efbc0ebed0089df282b813417ff9e188608f18f3ffc99e43c38716f24608f3733831ac83cff53fd74975b044e83179e27f9593ab56d56e5ceb762c4f86c635f3381fbd211a35df3eab5d754e62065ef4688841d5d5e3a36bdd97f9f845dc87f5f17be623cdc7ef27add44c34c2d6f28adf556206eda57bd87cd84b3ff149e0c2cf0cc949f48f42d481e8df474070086c890ae81efea01733d8d13dfc77d830176af310503b281a384d5e5e37b89b6c70e85e831baa9110e0b9c6042e9a9e4599cd198f95813e12f552e6b6820c6179386c31de6db647013d3dcd75d4d7611c7429f7b73874a2ecbfe1b0c5647f2f76646fa8c8e30ffb0eaa280639ecbbbb63b7fc09c31d06aa4a4375e1331c9791eaf999423019ea8e0f2304514970a92d2185822c4d542c2b54289c4890274427011347d4b6265078188e7208eee8f172648261492da1d229636cc5e860fc5983129b5015a24253889b1dad1bcb0acc4686f5aacd93a492c478fc8ebaf225c7ee22c76f2f3108a78d9cdae829c6be32a5ca94a51cbf9562108d8f4528e49824472639badebf9fc87cd84744eda489688841351f9f7af6145bd64443c808139f480ceafe87178f31c6da1621518aece4b129c420c7171283bcf701a44190dc9175a2df9cebcaaf0ee7a3dfece2099c4fe626314a5d3c71c3062c49eaca97dcef44b98bdc8f63e3833dec6dfc8d1b30182ceac6d719e7eb6c03ca0b8d8f7ef3937949889c1a9fd3942a35a4a7a51a9f8dcdc33ee7b9ce1bcab1b1b1b992f375a6f175863129d1f862c6e9dc45ce247751e4a9f968cd376b3e995b0437af2f03dd4e723f95dc35af4fe665dee66f6e6464648e6ebece355f679b36ea2691a7ff8bd945a7ccb532c098a1f9641f74d110329a06d5b35a19341f8bc5adbca119160bcfc88821e27d747a9fcc718ad6931721518adc2fd55bb2773f554b019dbd272191a7df931ff50264a7ded413000d72a62a4f0146b2ca474f4b47d6513f2ff7fb8edcefad93376fa8d6ce5de4e98f3987e8f63bd9e818153b2bad95ee94e0cae4c8d40253d1f572646a61881c2a6801e97e0b32b8a0baafeb7a41c9335a700188abca91a98523605a20daa1dd9a239392339894444d2f48321633a53b3f5c1a53e8d002450e9fcab53932295122ef38a14409dc40491253922472f83d3d4877f98fcb63fd4aaab9b13c57c751a970707ab23eefeb56d64655b3727134b6bb92eb64951b9098251ec113d063c68c19d31eebb65a57a6a37165a51c9d3ca95743bd9a1ad652afa6c6b40102410bf6006d30326e38694c98bcd1572f8f4e2b99ed7dfda42c20dc6c09c620dfe13e1debc8838100727f3880ec1d1b87e6ffc69cb37538295dca28a594aa18a5a4966e73d6bad139638c314629e5cab9961de99cb3fb557fce3a65f458364c5c8cf12565534a698cf1467635b8bc26add1c53bf2dc2e8a09e46084d9703d3796db6fc3ed0cb3e1469b29433a5d730c4ae30ced628c118740e594b1975295ce6c49c97594524aa99452ca158beb28a59452cab1ba19b59aad6e46a9ec94895bcf50cab9bae8451c4ae0ca6ec76f88ce53eaea62e49194524a29a594524a6d7c8cbe2ddc7ef9b4bb439d1c256aa5b5ba1cc442d4248fe058667904efa93c82e777106f5b0e558ed5089ee387f5e72aabb6ca7539e2d75a6bac35c6aeb6fa7632b5d63a536ba5b17155cea69b33da5a9fbb795557df7412a0945219a3d71fa2e30dcdc773ce9b5965f64c719a4637a51ae6e4258fe0596a86f4e5770f05e7e33c75725e37382e53029d9bc5e95577f7a455ca2e5772b9b252dc45b3abb8928a2b7174b0b3a1a1abf1c2d0b470984564ae6cda9a6290dd2d251829c1483926090d5232f13061e84c1266d231b015b88a3b779e71b13dc33a885fe414814ead9bc579e5f8bde2b8ef5b71ddcb7d54acf8ed31c8fecafb4ef515c144ba2d534d42e4f1b7dd4d718f74d11204c82c71cfa43062510f37ad9b5e03a4d00a379216aeb3e96a3c8fe5b2400d04164d6bc6a99b76901ef03a9879cadc1cbf08526e26d6cacdd0b4726a60d5d874d14b6edc9187bacd0d2701073f887315243ae174919b9a9a542a2f9c4b94d3ac553d7d57c96d82e5745064efa6d844ec2cd97d065a4e8dce02c10a883c37861a366cdc90403d3d3df267c571dfcabfb8f118470caa407afac7693247cca0a3ba87bf183b56756b50345f254d164af4a7adc53baa33e825620f7f2f5d8c7237214613f7e1d078dde0ccc701135bc1cba8f20512313098925049929464ca28989220fd1b4d773a414b122c2fe2a27325994cb66405160a52b49294548832836486d73243c76ab574726b47abd5f25a1f8fc8ad9f2d26246372eb6f95dc6afdaf00456e3d8824b7be87052772eb8156c8ad99536e254912a3cf67cff33c4f0531d93be2c4a4c2112ecb9373652e27733f392e8527994ba18bcc7939ca036042a10935b273fb28c656837664ea23533a001aaf6090c3a8a50bcd804ad126f2c9611fc9b49768403f66c994bebd24a420d37f2165fa1f0231327db0042032fd9e12aec8f481984a1893e903214acaf48310a520d3ff000428993299e045a69f01fa44729089c08ba21e32653ae14ba64c011f975799f33af9a9b2cd5cab93df96b9dbc9af669ab9998e867375359d8d8b66a6e686151ac9b00e6e3a37f68091d92ea6a38e7bccb9e1c69f2a748c1d63eceed8dd91c6ee27dca42f99f8f4affc22209bd33d467713b8f84831469d3927954e1d989c2955b6fb72e5538a6d94f5ba125b1d816a256537b74fd2f9d58f66d5eab33182f4adfcb939f5bd5a6abf036bdf1b52596c75b0364c4509d9c4001de3733b5f1402bf22345000e3884c68e7b92e020267e14b91d0055f040400e0e2284a28f616c8b80fd991675ec6bf70479699f91fee9fcccc476f68c6a6c647cf068d4fc7fff0170a3766fcd6b5dd0be686b2c88fcc8e5a375afff26f73ffa68efc6cae09c1fdf79ca9c30d5f5eebe2e0d3d40d250ddf7cbbbe717c7b43aee75c2e3a66cc182c3947a5aea5399af33b1ff70dfe0e88fb776cb8709f06ced30f07e77f382725c5e108343ffd6cd89367ce174aa770484f479de04a263188fecb071d72c5a1acc1667b4614f9c4084bda279b3868cdb8345ff3f6551f4a1a77b3a972a85e7a43aa8ae36b8e987138def960f279fccecf0f0653bdfc0dfc602adc001ebff330893de081779ee7c1876dd8039e079f0783df12fcac8c71bf5357cfad6256e178ca89f023cf77bdcb254254ca12873ff2c421b85ec7ff70ff5cafc3e70f77bc4d11b6ed13c100746772b223e24ad294f6297d42975c7243b90ffdde41c096a964b1581deb6547955a0afcb61b9c100115b42652fe944e93d2734fda6c311996fb6553948a8a4c4952b925131130e4502a5dc9dd3fa52b2146892b5f02259a6c9c4d173d0e74bcebfd73fd8effe1396f9f03df88d0dc79f085ec3c08f3e78932362516b20373ac0121e0f3e0223fb003a2101019eb0fb283ed86a5c03e0af1f0ce87bcf20f5fcd6ff5f60b3fabb0857d21d4bff987b45f97f375dfe3e3b103fbf09837d46117eb69bca1d5bbbca1ee5d1feb7574cf7a6ef5dd2865afcd9a94a2ae92d39383c0fe90f31ba1f3dc70e0f78f7b9a83c3435e19c7db1c3d1cffc3c31c78484fc6f1f83f2917e7693c87f3859db717a5b1610cf4641d1adfde100dd8f7309d8fded01724e7619653b9761e076f3938b4301cde1756816190fcfaf971a0f3f7fd0f7f7da10e6e3d8daff307e5869396fb713c1ed293bf9f1dfe6cfe3e188eef93dfde3f27bbefc3f1850d73dc0135caf4bf8f59ca9c9e6a505153535150b5272737f223a424a5a626a524243f8a9a729917f98ce6349f4d452935393dd5a0a06a4f4e4d4a3d6b5a1bf511525212521fb551d37a166b112a2a6c595117b56c2aaa07282af5e0f1f100b953e6fe87b7de88833c3c7a7c3c3e1e108bb0e5b033067a3287c320f987e3577d18d85e7a43f8fffb42780cebc0cbfe5ef6778c819e4c7108ad973df95b2663fd4684769e87061c108544e0de0151087c1eb8481110708fdf791e1fde1e9fe411b66ce7a3d08e0f63144f186b418840bc835fd25a7eadf7aff53c1f2cc88e8771d8015168078e3226b4f3300f5a68e75b6807f74cc65a166b29b5fec6e79f94eb5fc36dd4a851a3468d1a356a7c9d6dd8f8ba461b19b9769ea3f9c2ceafb7f9866e705e62b007e855bf3dad6559a353df5ce539387cc1f04603d315b698c3385f3842cd37ef72798d95351f63cd4b0cf6b83e04ba71bd7f353fbff0e6dd1baab979aebb1b8c3d8cc76a5c51f2d1915f71b05fe67ede34d4c29ee47ddde746df852b4b9afc89427d5434739fb02ff87c890ba0df82afa75c00fdb12fba00e4e7448d50f392dcdfb289b4b966881b4db511c881bff33e80b2a4d5ecef3407dbc886eb4d6a9fdcf9bc04c42758c88edd6886f2481a6530cb270787b8b20a491483a2fc96e1953e2e254dd27c892bb32ca72021d9194c49c6fa618e3bc98ac4342d4edd4a2d3b9a328a6a1a54cf6a71aae73df6c41028dc3ae8595681d093e50f395718033d5985c320d27654023c3066cc18a7bce1213de0ce178566974b8b415dee974631a8c34cf9f7909e3ca427cfef28077b4ae9facff61026ee2929cfe17243497bb2f3f40bb0b3f30dfefc064123f7a118e66fb37fcfef89a11c543d216950547ac8b2cbeca79def0989bdd41cd4a1a5fcc7c378acbfa71c3bd40ac9fd9e42eb3092d6500ef63794910e9f8018545219e5766f6dec6926e647fc3b3c947712dd34504a95a69cd035ed0195e74feb2428e28c07a294522a71f28422cf773a060633c6488113279c7084a48288a93a43539e566a92ea4b511493932f96cc4878400b3424478c9824c961f60025494c3308a1e40149a03a147a3607bfdc558e4b4a4e782d2d51a2134ea5ec7ee3c5f599776f68e667e48cfc5519575a4e46e6391919ee7ee190b7ffc3657dcb71975e7ae9a5dc8febe387b688f8e3c231c65898091a6c25bbccf159cfd18ef51ce775ed7160bf22c929e57c6eca29e5949999796e662674654a714711417a1c788e52463e6c2e711f9783bd4d23ff79e43e51fce72c923f52d692fcc9bbc830eee332647feb0d61e9bc8aab57e6b8c8bd27399555197766d673fe0aba00c8d2822c71228e3f4e8b5f0c8ab97b80a4bfc45362a6a46c6aca5a6855c6ad1a90b28fa48f309e6864f23a80cd23da7d2865f3894c5a7bedfde849a4c8e3f208c71137743146fe75e6412ae54a2499342391ac375d262af5d1d7aa54ef17be72eb0b6d9e42ba1269db5e25b1f538f0fc23f2f8d323f789b2b5979e3295dda5cb29739f302acd22f70925929c9262e4530e27d13c92fdeb064c4d9eb237921e20b047de97b419fcc0b2a7c9ad1543a14940ac9227f6e13d34df061e73202986a43aef9da424e33a50dc6071c3e8247ffec445a450db42f2e9c4b097833b40f901f184b8501123424032d61d6b4e515f28c150c5dd9d521a630c928daf74f9caf366712b0e87b8f0063fb3e31fab14eee7f0a504be72f74b8544189d6adb10d50417471814700722bb39a7063a87ffeee3ca9f41087bfe3669ca91a949d2528e4c3248e56792c14bae3f9da4bcf1722703e2529ef89b4febcfa7923b32790cd8de4a0fa828e01404073fd672e22b7b7f54124d94a69c90bd8833b2632b59e847dbf445fbff8cecafe39fe3378cdb0f5edfc8c8b4bf2ed78d6e5b75291b241f5e3c76d92af5188a5290fd75bc658c42e215c52aa1d65aeb96335a485070220c192238b2811ba0c6a0a054c2962db63cbde045f17483122c6242d081394185e7cc781d95540ebfc722795b69ad7495040d546011a3c313a229b6b43013c5161c9a98f7755df7c6315a48b1f0c2d30c4e2c4df1658b628a3050ee65e264c3840b2624a0b92e262652324e8e4c4c96e43075d2ba59d58aeb58565e4111003916c522abba325f6c2266895c7e8b1cff00d18bfebb86a5e3a4322a6b9b71cd0a04fe903f351f7ffb2800426dc8c416a0ab4d8c4c36400ad16022644c7d2ec47577bfeebc8e2e57adcb39e9e0ae643890b96d0ab7a7cc8c4a2929a986a456cb1b627dcbe3c0b3ea672c919679e71ff88f17452872fc05b8064282282006a9b647723b9b4569b55adf2d3cbd157655dd6a48b547b2b328dbaccea2047902c2cd7433ded0f6331e079eebd7d86c1988535ea441d105397eacd66a5ddbac962405f84f276d76f65ed4b575c6acb596da95da14990fa88773b95c3536b55be5b420cad9500f4c1b1b9b9bd7ecc95ed4b5eee17f5f2f3abda8e633236a2de946fecc7cf8caf672f78b4232ab4c693fab85284ebfcc95f9eca521f18412391a2d9623b1fc6bb1d6760a0009285cbe2c51b3a20769c50f38d81e2b434c996925994c76245ec9f406a554504a63971fa464fa3f4801b104105053aabc10c409327d20415ec8f43f10022aceef07223b65afed0be48354cd0d510aa4207e90c2f85025d79ff186aa0f5b7c209190e75f6f68ced083095a35381080872ab2f42025d767d9d04981c20309b9bee70dd59a274c5290d0a8c9218a19b9d6e7bca16a8520aa5959e014254b14151130b02c8f284620c5084ac8f3b74b850b5b6badb56576108369075a9e4fef9c53096fce39e7bcb88acfa18f5cc15cebd10db91e89c9f51f9c814987292865e40a14047777a0687941060c0bbe9ed490d84cc9987df2850a355a9c6c9e4c417125d560c181862317682470410897a32892ccb658418896a3308a8e987020e30425990bd6056e8b5703926ddbb62a68b40aa3cbc311551551dc2b872232a5db539ae569cb52dbb2406d59a2b62c531edbc026b668a7bd82a6ea525d2f2b64326673f86205da258a902e53b61cca6032a5a02205d385b26426048b1294274a8438d5a008a144c8144d509a8e087932fa9e90b4525a2d78e1d21c979a5ce1056dc9c9931811b7cb71c9490f3b29383102cc618b135c1a26a42d3a90f0e1dae4b8e4c48a0b922c39215a7232c61126883c168fd825b7c9eb89c72213513c167308c68e80628cb991e3120d496a947d4efeb42f3fa39634c924c6ecab24cdeca2ea644e30fb8b946c5f1eb98c1283aa945f3b7ded25f2d8a75fd71cac12833afbdbb73548a61dd94a22b2f5215b1db27d570e97ba8e6e2869921655ef82726592fb6c336f5f1a49c9e1502a65fb5151dcaa5379181e1585fa03e2ceef1cca999cd99ff6673e6924690edadfbedc9837498b3cf6372eaea3107d5648a28f6a87f6993cb40fd744f4a150449feeedbb0939b81231a8b3fd767ab7eff5972cf1a7919a3a83bed26664db28c8b6bfc816894bb6d6beffd05092c49f0cb808da3e12d97eec22b2d521cfc0c47ef55c4f6e3f573d06d477e170ade522875deba4b559becc7be00f0b222303f3e02dcd5f07ed47a1d7a5c130efa310cd47a10bf360e6657e06c33c0ca5e6a390eb6530ac6228331f856476d4a18a4130dbaff97a64ccbeeb039231fb349f53b5efbd878138686393ccf7818cd9bfd5daaf6f0107ed4365fb8d74a53390b3ee61df43ba32abb556ce3bdac9aea37226674d29fdd6b4b3283db3cf51caf2b2773e27d79a3d25f79cf4eaacd6fca6b56fbf8f74068dd43da2676d876d1711b4bffa7a8b085a29eb1ef66d7b1163f64390eddb318c5a397497451e6b27b6ff61b92b4b439a6f71c8765af943b61c9e13e987a7dd502737533fe9eeee4e8105df9698d88beb3fbb890d377a584a13f7799913dc59420e6bf2fceb8a41dbcfe96097a6fe58002e72ecc902a4e2b1bc96c8516210e33fd83f7d45c7fc6b5051397ed857f48f3ba970c8c3e250878d1cf65383919d8bee6de4d067339f55e069979b504ca7f9e43ee184623a4d2db3cb84c2a7c824242f90b4f09991cf7cd61598451e7f3148536492ac85f19f98524c420b2d4d579cb2cba7ecd24b76da4e336fba22bbf8ac27a7450e25174dd28718f39759f4500162f9255e55b23b11f24be4e95a3fe1d87a67350e7f83fe69619914f2c861010ac0fa2ede4b4b77e3150ed491436fca8e7978412412f672c3396b2d1e94a0d2c4b484d64158ac8779e081f71b863540f5dcdb8779c0c1a4c530676158c51e744f571836b1072a98c450ba0dc31c43517d14da3ebef7592b1de3eb25f8515122bb0612c8c106fa2181787ceaea73082eea7034a600f7f11d3948ac9229b5d4e577c45de51824a3d71e02bc2c710da4d537fd0f885bbf33dd24f716e3d55bfc41883807e3aa704ffe0fe346196b9a8392ca98162eead4af8fe867420bb551c4c07f03e346198b42dcd32e6da3c8e3bf857139b74fffe949e23e52616b44b123893cfed1480a8beb53fe3886dbd88bdb180a7dbd7c4274dd1f470b37eca7a7277f9232e9754a8c31c87c70c782e848efc84d73374d36b1ed3845e48686eb665cffb069e0911b85a2500824611207110a6b8ac8589b715be68ec3042476c05e2491d2332497888346dce80de1143a02f57b9c6d447051e795dc28e3d634e36f3fed4f4e2623e2e07cee05c38d1edee186718a88aa7fc619e777b9b218b42306adf2acfba99247befba28cad6cb2dcf856c61f1b0011f20108ee038bf88bdb0f10199b1f8292a88b7e7090fac89c54c62ed9670e88423f646cc65509d1845b69fd721c9c8d03c98d320b064ce2da1c999e3ce5f056c182e40913201597e6c8f424891a25d01daed3ea3ae5d65deb477fabdfbd75779d34470259b9d19c6a5f39decf6ce395e3edd0696d9ea55c51fadaaebd76a3af1c6f874e6b524bbb4b819b52caa77f03f7e8f89c73ce493ff6f4a89aa136ede89cb3937246c5182395b56ba594527a2da5946e1b1254c61869ddac8a524a6b8c91d6788c2f393b2be5fcea54553a372e0a183060c0cc31130c183060c08099748699632818304761cee0a24ed8b5235b172d99cd365b8ba88848a9e46aca71f2f1a4211670d07f840c38e81fb59a12e03e90dd1054d77943abef9e257b8040ff97f781fe4a5468f2a7993ce6b6afb41114775292060e42791deba35252126773582a57917163ed86317078c891c9e315a6274732b54adc1085c6ebd4c2930d275ca61b54d0a5eaac40083a850d4972e4fa53e74a0d5276e4fa968a5ceb2da2883bbf062436d01ca851134b84bcd06484059329a3291784b880549bd87ccc923282b833487408716768b8e0890f31302e54d9e1b6725c72018a1d2ff7e6b8e4c21535725c9aa184292a318733c69c79811873ea2f7d6e34b640e44972fb093339790f3d8b41396250cc114714b3f944b325f46d8c71c39ecd9ad6b2af8b965c99d0d3f7f1f229a5b321b87e1a36b636b926bb66b24cbe99db3af9b532cbcb5de6b84e06a5d8a8248df745392ad19400000001004315000028100c088402814828cd835db10f14800c7292427c5c369708b324c661144286180288018400038801305354e3007682e79eee7040c7e23542471cab3e8a5010746afc592d0001442be9be613fda755f3bff06fc67ae8bc9ca997de96f1d991bfee11f78851670b5b4b95668efef23aa28d84cff32f9e73389ff847f590a00db04c296af65c491abe3239626006d70d79e1b50b2a8e531e915c542949b08c52a423b61c2fda524c05831051a9755895e1a838004331485d7366eea40ea1053646b76a6b3398ffa7bdf548259fbb75d0a2641fe4b53720ccb00a8e2a12e7265874ac9fe1c9598a0014341e72b10ad74c411e5592742c7d0d6560d6e2bbf532d6e3b93e5cf47dc076b5e091e66f6ebc986754743fd6af4aef6ee3a306529b3e65cb17656e46bdba337a7172f212c7dc14a71782b98036879eeceedf35b87e932858369f19ae72d42f10e70a33e4b73084ebd9d2541774ed8808b5d2434c37bda30b660efdfadf39df20e4b9134759d5195464f7fb9e90642fa50bcfeadd576406b94d4941d98490e3b8a18b89e601e2ed493990b7f6bffedf0b768360bc28de26d84ef4c2c1b9172118272f62bf53f842898cdd30bf1538cacebbc17da9c752b2af19a22e18b48ae093c0f38d82df097090c7ee2c06ebb421126d1c4266c9b584e3c7f902d10fe7e96eaa9665ede7e0556184ef9038e40695d5a9bee647059f5c304ffb41a0a73d6cc0dab4cf8e8360a629cfb0b172ee198e0fd13b5ec739f7986cba0f06980554f3cc2a3e4ce8d29a624ccef6d7e09c0c5ebbbe055339800b6ce564edabd1fe63ccffb6a773d2d6812470681e7aa4a32e34cbc41a0e63582ace32718f8bf1771e47685e7db024b98c5a8beaf54ac4ac370b5782cf42ce8c0c190ae653f34ad15f5188a6168b383498461a09652f82a8a1aa1f530afbd18776ff8850cc83b11315bd5bb196e62e3475875ea6f3047d5822bc946de632dd8cd6fca0e287071e47bd136ad41b10b8496a6ae3876c5d8e381bd6dbb1a94ced56d323cf21353bf045b32e525b0e326964b11344d8aeaf6cd8ef23836171e31b7f7181a9ba0ec6525215513c42d561f3f0827d887c190d0652c7d110d751f2ed6c67f011590d1e39c94531a937ed345eba0b992ce21a48d4ebb9d0de364478d859e0dbda75473f819729f61af4905bd86cabb1f27206f3be97e06d9d1a73187a168b7bd811eadd8953b27b00c5eaee05d885db156a8ef6c4a801525026cbac229c472aef2aaafce5ff7a8e79abd1b6ac827e7e458f481e0b791cdb5c7f5f950f5398db7a4ac5ee6ecd3bf9a2e4992188fc8ba142ef93b5a0a7c7e357dea81219fc92fad06e6605d5d4d80d86ad2b506e218a887b4fa9197525f82253494a9a1008b27403dd97f83a2a960c9c57308bcec5825f0250c6b865ee6cc2648aa84018432a72efcd72da302166301ea4f56e9f2fc80f0006b6507f724242c13f630a8cb1277843665c572e9161bda2a4a65e24c5e3a7ad532b5a171a3e3d87cbe23531d81d99a4173d6b28ff6c42bf6eac3fb72bb9e3f0af4d2a42c1e84a9a0d1d271a7a0a2820c7211ea675bb18b356681e60a28be3fcb0dd198b81c2c7e2e1a9237deb891f2eedf971cade6de3593c824b140b528b206f9efcba4738f2be492128ee5401d147f2401103782899c198323182f9deffd9181ebed7962c5bd5e3f9f34fbf6646fcde6b006d3cb342c8618f122078e02c77d27119ff066b4918c31fd57e2130e7400fee29e9010d144ddb296c9d0665c9e3de67ccd0f513362b26ab5abbdcfc31ce12a2a91e98b3314671fc95f9df63b3690ea1759b18b9beb2b84fac899206d6a80ff66d73863c79ea7f39021fc9c8496fc360d121079a2fedbe07955b2751aa6e1516b55bd982b283d37eb7f959c43c9ce3d7b94f494eec30ab16d60d0efbc2cffa157921afe127cfe10a146fa8484968cfa0eefe665107151aad7b6bff957f9f0ec3779c898698d4fca929b73074ea4faf5c8a6a7171bd3263cf97a169e1908adeac7b3d95cfe1802fa74270a3034694de89423dc548ff858e8f22388b915badc1b04d8457c32b64b9051960a5d4ad684b31c2d8543afa5672e85b633537b399a97485d4468f74985ad28b5b624dbe2c011bc1599cb1b98061bd21eec7b63b66924c3254f187d00232fafeee16f3ca502a79ae6c4fbb6e25592463f7ee7eb145dbaa4d7d32ebe4b4548db2520e3682c79a7ee34470ecbdfb4b6755443935f664bb4907bf10c5275e485cd70559b01953e147c477f91bd24db739898e47a03d6e9afa1cd9355437f3a3d2b083c3a44addb3f8613544a052804c2e75674fdbcf836c4d3755fcedc7f2488e7a9e99fe1cc82de48ad6ac17a0a9a2ad38b03d2c57bceb38484b1678aa278d574415bd3e6d355d12f02dca12677f77775506d0f844e3b3a0f4c3cce3ad081b09c3e394db22955bbe392310cc33bc5e76903c2c46541748969f6655e1986febd04cf474b1ea758dec9030fcecc1dc1a3e4d967545d7a00ef220e1a127b326d585dba2f30da5da00b4181abc7c1e3f67a9a30b085434fcca8d848267ba21a7b1a5b7634663975ce777d0892c1cd96672a6b1a646c7ab01d863c832c9b47fc7478a0b3f07bd39e11d8da08cbb2787c4e2e6f903d2721e5ef59a2811fa7065e19d64e69e1f9a1440147a8ee0650083dc729a4b0d3609e47f7f829fa1a9b59b9b06fb672f996d43780981c3e3e300d247841f76494956d40f9529c791dfac074537bf78efd8e017a8e05b986019ea70b521a24024e68b525b16986d6d2f8379c909608178633e390fea3617618e8ce5b833088c111f6d03156e9f1f4d3059f58598669a8eb0aa278eb07425e9348a17472bbe5c27f5a8051a853dc0ccfd5c3f685f13ccd4c7efd7c0d1bd3f30cfcd2c234fc5f4a29d24b5f0de189f6d67d5a7f0a77c48e1b9ca785d1c02c3ac557cd2538f11ac84f54fdc5c9644c2dd0dcec2dd598292c602d2549c45282c581096f4b4a00d08cdf503b70b33e37b54fbdaf4b987b72da3501da27b5656979f7f0420c11b354d47d34f86cb3aebf5aa992819b0fae6e8298e599d5534b776bb1fb69b56639ddd2f2aefee859ef4c5b631a772e7e416d168dd080816f4fd409a194df7faed7765a51b58218501608f5029f9714501e090a281889343c139186a783736bc48c699aa58307a278acbb86e5b1f66a05c6510922d111a0f480a0693a2251a2d0b98b75edf55113c98962c939d21cd9dd11df61ad460643519705930224aa3114acfee91f2d9232e9c8889f12ac2aee97fe262a7299b7c18236e7650740e0ae8889418646be6239c3650c8de14c6d503763dfffb5a45c0222af22c67151eb9627e2686df42edb06e6ed1ccd30c81ab17f10b428b7dc6eb066b5548744dbc33f10c037b9857b166eee6ed0cd9098c744cbb8398241b38253d37584776b7a5f479db366551e4b586f720b7d00ead598bb921c4548f49d9368273500ad01c914a8456dd005a4346cdb2057ce80cec123fbe5bb3d48520c69b367b8e6d864ab81193fa1555ccc08780686a0370be40cf22acc428360e24f018b180e2a27e9598631272b0bff68a6b02531fb6da3a61530c5aa804575c7573c8709557022f7456c2b33629a26c076c98a98a8452242558c13416ad78b4adb2bd2b972a4d3358abf44f088dbf9111c7ec6fc9212c729bc88767724d99ccae0891bde99eae80c2589ee2b3a033d301d63b22c5e209172ea6b02edfd11af599309227ee974f38d9b77ce70a4bd642ef160ffd76e853d9c1fc7a27858ccacb653af36aa478d9a6f9cbf904d437de6771b70b761da17701c138f5f1a1d2dd0930c9e5c7a4e0356f1bd0e429b2144dcc345511955bb471514771f22a53bb5ca1a178b9229cec2760c5cfe549c60fc54b0ddb8f484553cf035eafe0c508b0837671ee314c11f1dbef267fe402024b97b32b40b954080a3e7323f2eb8e58cb71652bab0c1b246bb912190ee56422e3831b6f3a6698d4051b311192485e565aa53f2eb292848669909823d1852be4142869a19752359346daf96e7e49f85f2e152cadd4259339af1658d6e457bf0fd7cced16c8e686434a2fc5c0f89c62d589da28a96b452660a78d87aa8711faae79d2732592b2bd0b3a560cad54c9a9b086b9046972729f17d53d04f9d32a9fbe5d9d0d908c1782bba71f3f0f9749abda0edb1edce33b191de79aeeeb9ab4f6b7c7dbbf1932d9ccca879c11ede04d96dfcc4994ac73d4d8f5e5701ed1038133feef02f4c01a2c8d3d5b4e767a9b512c33c16dd7dd359f04802fa2e9903f2486ce933a53a9b84348997508e10fa63c50dc57d0accadc6004dd37791cffe308d2ec05ce42c60dc60b4484ece62c7a24c495346cc8ddd71984877f02bf4c338d4ef0a2d4ce2746bfc5a212aea38545c1937008cd03e20b4e81887a20b2d0a6a8a96870bdef54f5e943587d33c9eeca1511962ec300aabdd9167a2c59048797045a4b002a626c624e4da50a2635de6b619b2af32e3e0351635b254d4870607f183290cecd3271a8835433d7d10d129b194928d6a5c06bd2e94e589e4ca8ae13c03d9183a63394e3cb220787b8289aad9c6236d35b496023a27e85ed60a14c75328b3ddb69c7cd0ee4c4def6f1b7289089795a029bafe62f7ce585bd3cd1814cfd090cb0c560f7d370d91184594cd06fbea69afccbf1f1c20c31e15c1783c4b3c144da257695487eb793d0041d88b8f60186bfc9b607f2a2446999673216bd2cc7060ac49b079ca05bbe83f83a41dce6fce9afc7b24af4d55481f59de189fff0535159aad329a44a05626ebdbf1d94d18b2657037dec74412c9c000fa5ade20e3e01f49376b6fda09b8b5de67fdf22bc3e040e1efca4a25ebf80f3d8e03da89ea107709c74a49082e39f7944784c2a29479a83c742be426d4c95779174ed814c5b3a66b151ae1a52ddb3355aa2a22cdbff22ae7695c30090c2ffb9b46e33a0b1bd500d69169831b46cb5b9673d57c01c481fef575d16dd22ff5b558de252620cd732e68421f18fbd2c2e9a3624a981e56fb684f0e296392b0ef94ef77a13cc5b4a2eac92d805d51f3011019024b492496b40ea0a2a8b318473fb9a6221970200b4311c39cdffe6832770f85569c58da0be34673e2388156f074aa42edd75f3e468273306993682db5767d3711a0d14ba75655a4c64b9061bb831b6e5c2d0c58872fdab87baed90ef512c184250ebafeae305c60f020fb802c6a169db66651ab9d677a2c971c9b71531809c1c1d0bb6b59a74c33f30e2b32200b2328513dba98e30a73f4d20c3c18193dc02cb46e52684d3f209ae0d801de4b70167bc98f5ddf0885aa2e28ab142cfbc01c99be142caf3b3bd8e8b5c202df8b1ed4fe24aeaefd6b0420ce74816c33135f48233dc4a011ab8dc4cc13fdf762bbedf24257875e2e2d15818a38cb6617283417a8aa6c6a6c36642298cc7f1a17b65ce4902eb64bf247cf84abe02942ec4cbeed68e0b9cdecb995a32ec72683c4029fe4b2d82e946d458721ffa229c887196ddddcce7e20f42f24fb7f012c40c24526581348d93aa66c09d96d1e908df8643270af9e9fd8fd613e256b8b7ff340eef5bdc6597eeaf034621d3137ce4684aeb817bc76a051dcebf2691a296732082ccb6120336e69948ee703f4c50062ec8392a5adb464c004ec477fb56f457a5ae661068608d04ecbb556b577da687a7e67c73627c4c47aae74210fea689cbca5da2f031b5e06d625c1430ac87df6533504dc9f0c5370b383172d82d93511b9d759c7bf935d5230c213962a52a49bcf748044e59be91433e2ee556ff6685ab8fe3b938be2d57db7285684e1e0eae17fb4a2d6ad272da5b729a7c2517ab1e0f550c977ae955c16cb20bbbbbc5a26a2798f5e302ead4183265370dfbeb229a4ecf2398fcdac89e9634f4c60978681e5712a064bb8e2b07a43ccacf7ee08b4af294d8f986bcb304ff82a3204a0a487b72a8f45bd8aba3f8a2333137420ecc71c2d1692e24dee4c63ffef09b67e1dfbcb222422bebb4e1009cb8e2d1463a353529bcdd97bcebd6da2f11c86089e3f20c4a63341ce245ce4ab3de841b081865ded615e8354b45a77bbd8704905a06d50c1c17bf0bb072fa79fa07617bdb52f5d68ae777e033d8ae8be6829de3a20183ee72485f73b921cd56b5a6a3ba036a1e1c4c89355856c4d4b69133ada1997ee7915b0e6e73677a1b48bbefb015595566054de1ea727e2d6513f74c7d52107fd901691a4019422bf1809938bfcf6ec19ab951431acb030ab3dc52a071498643d027a1d41adfdb31dec49acefd200401d66f30435fd0a757f15e7340f89aeee55f573e065bbffc9b3d275ee4ed7862f610d47edc0997caa88ef533a590fc52f082a472957c27cdc09651811966a5ae676a1250a11f912080ede317449c7c84ddfe6659d5d5933c22814764fce43e42cae02fdf3340f4d0a601843d8cae7219a9acf4314d4a5cb93c2eddba4f9bbc9bbcc7effb373a88f34a5bf444435f11eb76f3934a4f404add9282378e3dc15b06c008f766fed68d1e15bcb27a976bd9fa54ea0201d986bb5317f40c31cade6f4b4c203aa967d2871214ee5765e88c8b4b6401faba2b4b2302c0e529385d90b4430c657b15531b57f4c8e3373b01c225065c016998af985014e5c5e8fe99893b300b96ed219b6b5468e4ef9a1f0b960456e299e138695be55514f1e6ae3bc8ef5f525b9884aed0674da427341e50163e1da6e72a2a2674d8678cd01634473defc80520b38ba14dca438d0617ae9642afba9ad3834305f7fd74cacc9ebafac2f4c74d3bd68ee6e827179f52d9725e6599d2f0d79b5668c53cc76a502e1223c729f20893b2cbc85ed5c02ace565c9c6e2d7161e9c96a6eb1ecdb01c9f549f260cd4884599906444059193ea5b27495be531a64c60a375d1caf782b9c6e87deee7a2be5754434dfe11dd10ad41374608285e23ed834a44e2442f4e804e885b556e7a41a3684600e6bd80bc9a21aba2f51024dd1f6491dde1fa6f198ccd8f5ce8fc56d8af9c6fc798adcb52e96572e90a051e1bf94dd36e4bf40d851920eb87be3ed26ac19d32effd0d51947f1956cbfeb13b0fea0e74630915d1f79bb786363b3637f9f3709f894cc5513391db01cce56e827f34738c26fbb06043b3cfc08152ba04e20bc4bafcb94bcc791e7560f054820f3226c58715957015472b5aeaa6bd0fe0a0be6b328e14e95a1ec28928d1d3dea3d85b07d9f2a685333acfd0f4e4f9800a911d2b83accca03ee80bade8909cafa71bc4a738b05d56839f7681b365070707c19a06900a71851ab10e5454f3ca17c793b41cb38e1a70bd96a2c38d9d84c3172032436bf3e81030d26d35c2b1de54350d7f18f24fc4c70898a8ffebb14d378a256defdfec1fbfba3e5bc54472d344fc1ef7b392fda337fb208aa4acba81da0b9e03f9d71871cc1142e40f09f57a2afe442b077d05dd98921afa5289630a4f699afb81ac776a99dcdbb919728241c8b28701b5eddb2aef8e245b88407bea83b0ea893442c61370021a03e5048ea818f2e90f81ed46c7cd0e25827071b00f4a01223fa40171e1642ac94c184e212486ce299b2988515b187ca3ad1c9f45d85bea3fd4705443952de219720fac7e540a77ca02d466980e21dd140d2927d38979029180f10de1c8fed5d368ccc6f401978475de5e12091c62d0149f64c615150fd58f30407cc2bb3923d8da06da6a8b5f52d1529eb9929b32843ea11c5c8baeec819c8afc5848763657f84f6dfa63fbf050b3fd82485e49c30e29d917c29f5946fff9e6b80897fce88e0688ca7e2b878ca1e44fb4b4905502d0458041ce4cd42f948099266302ece1ed26d686d49881806021ce9e148021c6b21d0293424136d047df2ab35930927f1f41c73f42e9bea61765b54af114dde4b3e26234ebf42bd1108696765729a8927443bb53311537c043102fa466c854a4a4955ae5800c7d479abab134b365e59e9c72e83c8c8ab35a728248464794c4858ad14339ce8d4cc57b142dda3497775dca2c1ba3412840d623bf28f6448b4c2ea5d1f283948cb54924b2d423df8761c4f5782c3b12487582925c3a10153ea7bd91708e9196f57115ee4bb4f19708bd23d391a472b981285e486766209210e2c518ca341884bc22cc84267e004cdfe15cac0d7a1062ced52d1d44e1117ca4230a6fb57bc33300f36e9906b476c724b6c13c72ffaa5528c0b5b45764c747b46715688ca847a7153213de367f2b0c7eba016e299455b69d31e82bade1a677fbc3b702fae29a5689e2c90351cd1ce808b12257a0a81e02d7aa7e65f88953bf44ab5bdb6dff66251830ca3f25bf540dbac8dc7b78cdd7e29378071b040de96448ca954ebfe545842dc40a712887f35eb0cd32fdb6489e6cfe715c0e903e8b212b7ef048abd9d66053fe02d60f5ae16d1233a2cd5519050a92992ce98aefb72c163e35ba664a259f6c17ff66fe19891cfcf0254ce9853a8f6884c068031b553d9eb990ec723dc06ceb9419689a14aef187d74ef71675614fb9d753af8feec9d97c89abab3ef8f450f55e13ac0e480edd2f0fc0e53e256809d011cf6b854a84eed9c432a33f348725593419df15eb381a2e730121a881abf7b29e600d6419a008340565bd7c866e6e10a1ccb6a9049ee9a94d1fa35c5c19720b6e25f54c61821879078a03ceeaedc6362bcd0898557b693f587a70971581fd0518dd6a83d2bf9cf1f05f2b30a5f0ba290f83849587a3b795c2d1e350b25e273b5953d8ae5c8858743b5a09d0a2e9d5f772ec8f1226703dd47ef160622d3fd2b5787f17963393184a243ee6fe0861e8d48cd1f97505d6701512ef41da07bb277bf79bb973027fefc9c8a34ce27aa50a99e207e54bb40970cf63c88c8104068a675d515910d24b777619dac0b09b022b7f8e6caf8ef2c2d7c91f476f89de58c90d4c611143a7f772ca2955eb543ff0d7ef5bec1d40cd2b6d4ef97926ae1b98d709ae9a819389e26445727323fc7664bdb1c8f5bad2ef90f1dc82ce6a4682b7a9effaf169adbcc3db015b357fbfa8f9e773061c9d42eb22cd795192f4da985833de501e775f14cd58af70cd2a2c1e71849602cf265dc8a5c654411f73d1dce6997c1c6a02633edfb26da42c6a7006728ab1068f80141fa8d5f9630084026b2524186b34ccf9e3fea705dde4606a797e1c3435a1fbfe8764e4e5ee211e55cd368926eca0437fe0040fe3bf12861dc21bc736891b23112631099456512cba94706e56f50e175c1153d36ed93c85ce8ba194161efb5f9269bdf86ffa35e626f65655e0e1bbd9becbf1853d6bed5685f3fe1b2a08c3be820f2853b5c9e83c66f28530d135641343e3b06498fde7e68de70837ca49b801d8a91e9c8164e23f964979e99766431b86ab2fb4785dac439876afc34491ae029c7548401ee818d7bdda9e00a795c303b679c9ff49ea7d00f5587c8faa59e6744926d643ad35d84e2f8a67ade9c476dcc8c19d56ad6ed1456ae4f0284815427c49f2277f59fb1faa29c6500f1baeefe9cd0df345e1a66bacd6adfec55cf2a2d2383816b48b6efa53ba673f121e915511ebf3ce246deea71578581a904a5ebe1692a8b71ea8fd9635ac82084625148c9fe6698191dd9556b745f8214b257c41a3962df35058ee57b6dac70ad887e76b6dbb35515cdb62c320d3b8f284cf94ba2e53c8f8a6cb4ce4a49b607125112ae54105d918f8b80670e8ac050a41562c3c73436c8a928bba6694c99dd5d1bad666879203eaadd31cb33292999a40d16d26befc6fdb6bc931622ea8fa0333843a397118a10892309441a83b82f84ae0fca6987d56972dd553229fe2ae1e48a80b6370d030bb131fbdfdc1f63437bca62fd35c4790ed5ddf0f1b3079231a9926c135072c58740cefedf2ad536922e3012d7482fc2ed5ae6a401c11aebcb0dd28a0149095ca1f27a8c13722c782698351ae6f7819686799733555a5b22029891d732a365be636474ae59cd31dad8c2972e42c6ab1a04b0a43a9bdcf1e6f1edc8420f10b7c2b189e148c60f05ca77d8ab184e0ae977fc8ebca2c4ccd8d7d03e8f46a4f7797ade07877c1459732a0898f62f1dc0476fbbe4421c6e7dafd02c2b577a4753979b583072ac9739b79ee952aaa965e31bc34a7ce2441f7605457739c0ecf54e8cb11c9604679b01faa0191869a98bd942d11ab993285655dbe54e2e920ed5038c202d18cb7a9baba3dbe66e2dd025ec5685e2738e3c10001ee0f0f548a71e4b47890280b675a028de6f66a8082cdf4a539cbdcf2959c1a2dc148efd55218fce24d410d401b64e5a43a2bb4bb8876c75828931a1b86da756dc2ecae9c4c4d22396129a76274c92f0df2e88753bef5b4ab8fa9a8ced53e2352c16b9b005ee3b5dc14855520f2f59fe210e0b82351c0517c1d8d16927c681b2c7bd1d42a6962093373ae9294fb7cf176cc3eefca7eb2ada239f4609bbae5bbab837ef2156d40c830203efcd2f0e289aab0a138ff68540dc0712551149b4586f631ba07d6f85004ea84b28c1cda635af7c3b231733798faee680fb909cf1c6f9322da48d17072fe433b64c60b256950312dd51b932087bea40ff0ae20ea468cad25d79fc0ed37b3b9305f7864b111ba58cc4ff7d23fbab72170baa458590fde830231d98caf2be60abacfa9150243bb86c0db1504281c9fb9679f33eb505ed5204a9fb7e5c8b56b3dd3788d328e2a9d15b445f9ff60a133f4c6c319fc1dbf886d6c98a2097041870447cdd7738b7c81424106fa275153a68206ee7f21d92da4153cd83c944f827cb786538db0334224640a096050075a01044200eb135ea712472cf3fbf96a67d9180f6ef247f0f89939e90b159fe1f3786adfdd6aeca0e092c224b8006b17751584ee068b5f5695e2966b684aef5b11aeb8a8fd2044275161210d9acfc8998ee926e7ca16cf38eee05303f39a2bca2f8e081954032bb78bcc3ab956a5b2060648fff8b5177eabbb704f1b5555b5de8b80ab10947cf52c1909c7784b8239e60d25455f35de3fd4ad6f6614d6fad5e596c59cf48c98787491785c7725a7fae719da7e6bcf43499db4b14a3120bb794bd99f31404a139f93b8e9ffe6e401b7e200b3e4c9f6d32310473021aeb814e8916c3ada7a5e82ce39246b052eb9219e1ff4d5a00e37140b96dd9d18fde32874334ae6ce2a22db0e31318acf98f351ab5b0e4637282483576f3906ac7c90a40d2a7fac82d52e208be812eb4e05fbc939496122560a7be667e82763b7d60d6150c7f09e10c14ac9c62cf551c45ce322e62fade950371aef2f37cebcb8e1ff09d302d90e9b85ea974e892d929f383ade43a8d7738129fb5388e388ce8a429783d6602f1c1c6cdb7128cb14afaac30283d87f5745aae4a74e5a72feb93da962033d6f4f49400fbe0ecd5bb40adce3f8fe41abec029d5eedae924d0da2df33912e07e09f40d9f998872bb06deca410f84f025f99f02af712e86d3e5e800f7a80da30889e99d62f5887d0410931c807f70ae12790ff941721df1fc85f92a6917c4653c41dc00c7af993400209ecc4d0e8e3c3d743aa198220e45935903411f05e4a033024f88724ea8178fba0eda71999c2c00f2bf73c888875bf17f96c824604cc1688c602e13361145d9ddf11cd5f1edb9e71f5ee2def31510c1578593b75c86c6585b6ae3f2e89d822507a1f7af736133c8d1ff6c9f89d3a09cd2e1ad8dd53a91b9970430699a8da912a6efc3c19d82fa8091e28d703c37d8d2293a3d6baea2445212e8cb1dde0ca857e13257ea888071729b78a170b6b6a805335edc1fe09946f59fd029ef046003dcdf9b02b2272d82721cbecd40d0a8ac8ae0b4e9f4c71c63076a3faa191aafbf096b33ea760bc74d5d78f0826b7b03657aab5b67d9f2636ccfcfcea5d9fe9b312e155a8d0971a78288f78b6a0bbd1384f40366383733f59657cd3151592a4d7a6132cd704c3f025224170cb3172fd66f49efce417cac2ea4f2882d651d3824f9a0320b493df7b410a38ad2722032a9921d06c655cc0c2b5bc8a6476b27e132c237d22d5880275f6a48444be5584281c0d76afacbd2820a766209cdadbb523838535cc5f7f69be0f34e59ebc9bb6ef9327a24e79b60b0105382b5b7ba673ffe1251c2995cbef1ee3d6efe8251ca5e5deafb2c9df5904a401033dbd0f3fb4d09a24b9d5f28b29ae396b4fd7100b6eb4d50e62d1af29f018930e0f5809082b0abd17f1eb8baaa0211f2bbf6cf1e2a51528b71bcac670d6df28e3618c8419dc63d4d5bda899e4bd4c004f13e7bc6f6b88e287de654a32417a8e273a90c588404653687716d675302d3f58513fb6b293e9a9d0c6c868a99a129e3627bcf25cb531d7a79d5aab4413871c8a9ea543d5bd16dd3b811b6886772a65c3bebc39d4e59378f1d63a2f67d48c6dea1f6cfa455dd8fbc38e939e2406d4e7130095f732b307d98aa190a4a32a92510592198e817211b43bf640b8b795b262a9a6274227d840f7605b33181316faf3b49fab71ea06b846f07f4a95baa2ea6e24a28c514dfa730b88da2c698641005672ee338672213a88f17441710a9858c9c64d6c7755689596291866eaf2d7c09c76433cadc46400fc522429928a004ad3f748042adfd9513c207c0208048295808ce7992216693e00b57b8c4bd24614389fb2c86feeb60dff532bfdedb74da93f268e4dbffbe3c0db41aa8ac39399b7d3b0b60d8879bebff4edf4cbc52e84ff592521a3dfc3b01e98d42e1cb57d1fd6de43e9f77534d6b2922a8ca937a0a6bcfa4c70be0000da13c8dabd6777bcdc073e0e08b95f3a3efec6cef025145dd1fa7493930c8561e121457a653ff46c225f1a56edc767b0e61e236c3529f19beba65e2362ccd2715117aab698829e1af7ca222bc91bc101aa9b0a5012ad6c9d4a35dbb130eeadaab51978c5cd5b04f0a4494fc432b1e485fe3c4b8c0d42060d5018f79b3642e4bb017fa604a00a25016e62f72ad335a8ca08516f516201b7d116571092a6413bfd03e3b1714d83eb6f2aceff06eea44745634c4d44826fbef2f7f372da0ee6bbc34cea1033ff82d7fa2a831f0067ed02f0f1a0d79cb26b4d0521da7259f234b25b8b5532c12659de38f719861703dc9b4cd3083324e0478259e42483a61d6a44e84fc3285bfbeb65c2c8e4960dd0feb02655f7418d81ccc99288abf0486318c8fa04c0d82cdb46adc20600e841e4168baa44f5bdfe615c66395e141f76d45e31599ccd9189afb234564a1a787c5e1395ec8cdf4a3a863cd134f55e49409e6f4446d3c18058fafd1295b2e19d0666b4fa2a7268932d307ef6a9cc86e1ad21da32942b1593c2c3462f9d1ffb36b2d88683ba6d7bc918b34cd5f1d412cddcc2f8228b34e1d96933c6c39bea970472655c53f977348e1412f7d0e124b478cecbd58f4a5063ce2059e9536ea47b0e43172c2a7c76a8e7bfb3d84327cd7ca671c957cb5c8b8d14530791061faa95277e8410eb3bcbc6f38daf0d97399e6467bddaa5c55dbd309a32e6fce3ad2e8940f2360dfc8f77b194d2381e55a9a4823a2ea3238041a4238e8bba966123f548a933c8501b10bc6d8639be1053a756c20e46310cbd5bb056ac50edf1ec389f8ec1c041074590c964a2122ade63a3c7857efae06971a23a26a0b18a4cd9c2e94cb146434a928b73a7aa6f71001ae4f61d0884ab43299117bb1626ba9b503f81a302380eb1c9275de3002749e05f112d29f5d476e25b9f97b905787cb7c70ea14f39909099a739c17f7b532216e5dda5a7156e2d907722b66c54ab23a69e0506039a33a18a3abaf859e19e1609d7b3115a4a4bcb6e690e459150b416a587202d30bb5395677059bfda741626babedf072474110c7b8a843a17a216ac57a9925142b179f89e537d0cd57f3739f9ffd50a6f4c02ac5d8443fddc2aaf53bd9f0fdb018c53db11a97405ea87b44b59c85014fdf0a398caf91c670cdb0805bcdf1e741ec4d36ab77e48531bd6afffbb96e6218f79d358a84e313c7bf4805660c38f76e0aeb106fee5197976f2f9cb0e6dc90e1c35fd09f9c68e5f8e3f45d8115ec6f8fff05f772c8dbb5c0d44f4d90ce03336d579bd68d22101ef72a9805e9c7b152bfaac0ea15c8f3ac21b1420c820d9dd580163fdd743b0ebe9a26bd0d6d2197296225e7b18f3e55d8d26538c5728edc98dd85567797aef9298e00f13c8e9bb80a2d956c944b42de90731553906f8f41be77af8ad36e7cc4a58f165b262e9b30466e1f817175d3a1d9dfc36ff68a0da3121ebb820ef72888c0331d0f06b1326d76979d477ad0438ee97710cc1c86a03a21ec778c4bb7b18fa9e7c854df32ed9658c0734da9507b8e628f4f3aed61101d928b65bdcc84cd9c70ed896190f58bfb1be0d489a4b52dc003987a0b4689642758041032aa394fa7b8e04b3011a01c11d020944b2cdab16776f0de19e3fe91e0df5af3b067f760e97245383f4d217e44a815cac4131dc5fedd83e89302d9d38c2997ed03f868d997f3a0083ba568c8ec8cd91082f34175f74c9c9b37df2627262079eed831048b345613f15c2ba1b20bbe40549874805d1635716205574248f2001195a9bd87dde611de01cccf96932a3f51475930903145ed5a5c481416fce8ae0eeda25e966034254c8624db7a5376772e735476cbb0ae36264e044f4ff53f3870f21a7199cd1764918a0c628b054e915e41fdf34d9aec399197827917b2bba39c0471ee85ad4c56d1aad9f2aabf35eecf0240817f197d0ca5844acee815619c6afc4df5c393e8c306f5f26aad7528f80321577e391950e62d8679be6e43120e186df31a8091719dd077c32d82a2f7a90a2ee14eeacd131aa6dec47637b1ea59f52ec76e63a9cc1200f666325d107dcb41239f72f0ced12982d2b6cea4f16bb6f4fbd6aed01f661c877a80610ee1007f5e1cbc83c9507725a9068bd3f8136bfaef15da0f27966aa17cf9afe610771f678c5f70f79d0bb5bfb4b693b9ffd0928c0297ed92f60f06563a4fe924757622554f32d673493135cf3a9ca668e7ec46e23ab4b01735857d18a6bf06981958d7ce7829fe0c12c34c646732fa1ce96141a65e5b99ec6ac4b8c131eb053b459b91ab9b09cd1a223bd789ae6ed3e1cf17e0b2c76b90d34f1cbcd5a002d8354ef18c01cc9dec8dce67e989119841dc514f427ec2d505453fe1d4a932f46bb1f8e7d9a65cb9fecc307362a5d7eafc3e4605e7b2364673ba95043a78cce173ac38c710b2620e06c5370120c15869299bc88b48eefe98278a83d35c46168fbdea497c34c613b31d4e9cdedd4628c4639bf2526fe1121a1277b03dff90605746b735eaeaef73fe08ef8e7e333bdc8e9c00c245840db48aa3beadf5538b3ae43f098870d05125cea03bd43f6cd4c055eb8547bc74ca32d6378bd0af58a846ac0965870a49fc74a7ca9f4369cfad9c21870220d76c42fd4eab9ac029dd336c0b6afec4f3a48c58551d04c6d15b9bf18fb9c2c2890ada1f046b88fec1391e17c60ff0bb9bedc271d6fac69610f17e8ea37fe74a176c82702f4cbb1c1ed44071421a6e296a1945363ceff1ebdb3943e72452c35ccf7765f378c4103cca698204c23884cb6048f4576c7cfd9de75667441d29740018de41d9e68004915b9a715dcb142480469f44b298bcad5d7f50a110472c98efa412de53ca818e04066d57415b8ca81013cdb59a006c157ea511efbdfcdc58d86cd3b2d4b96b209a53591cc17e3cb00762d5f62255618be056110092945a09310fe890d789b2c106b8b6c8abd6b54066246732f7e5575628795bf7d4e503358f93505bf1c30f136a43740e99322ce49bf9fd6ab4181a0f1fbb2755d8d993d3827107d6d6f8cdfd7691de9d8ee7f96212cc5df2af3bf437a2663719d788c39bb36a1d9a59a7b5d7ed4428581c248863bc71c33f3f8a9064a504f41af47904373c583e04b971b4996907e236289a21265b375a329fd217223815c2182639a4c54c03f038f01f2cf302b8c1df57710c4e41e58a8dbc444ee2cdc05aa4c168ff056099f7d1a9626c762e9992b459eb28c3f7db9ef9d4b63160422801b711f0413e0bb555a08336aaccb2aeedd111bb913ca118319b0061ca2bde5d6bb509adcceeaf11d2ed69fc6874cf7fd4021d8d7c8d7da0c3db868499997379cb22c41b8a7a408e7e5c1c5450835fa9e10d3cfd2fc9740245f260d4a0d2bd85cf0292cc27e7fe4858cddebd82137957308175dc04811a349e7f85f2c1ca58dfb9e04cc843b66042e0b40443f01f505360e79d0c0d0d7493ce4b4e7c2e00192cfd717b0b39e5ac2e940012072d8772106cfa90d9bc180a1c6dbb3ee876a19952000e51dc6450c02caa5ca0a11a12014e4239947749683af4f55352056abb144395d9df4d8bf67d4526925451039bdda0d1c744da5e4575145989108407320efdfe34a1165aa3c4608c0bd1a333bc68ea071363b64f8e228a9734727b43eb87df8410c0c1b05ea3eaddbcd7f53bd179817454c7ad158667143be6f7c025410386475aa646816fe4d30e6510abe49c585a5e9fc61e6262a17ce2b153c192ed05ac637a34db89f52a7180f9e0022be561ff29bd901111b5f22a98fd0ffb698270bdc19718833fa847c615f253be815c2570c5c9f87fb061cc63cc50741a52160eb2f6154dd41a74658a480420a1ddcd214acfa5f54f2dc0f108c4753a11d7a9b8641e7c9fe3744ed3d183a6b888fda6417d1f27c53cac96ec2cbf62c6268b240234e4283f07323b1a7617f726151f2e16c668a78cfc22507b1a164f81e2b0746cdce2d0db3c63f04f82456189b9469d6768dd409c370526c6d3fbcaf1af7d8dc7675b6bd63e05444eea6d5e41628db2035349dc171e3af02be77f81a6822d85c29bd5dea00b6d9e45f2afcd18f0622fd179c0f05209da3435174bb789ccebe4a627f11a95692eda3d858310b7a036d4a0eef435c74a5c9fa344a9cb37983b97343b4d2f50a5a42bb88854055d14828fd99e672694f309aa168d63b7a1e5b8441d5f799ae4fafb4c7945d8cca24d40999fd8981889073c7dc3bbca9b060a0ca2ed5c130920b3b0c03893bb8fbd3b5b9a79d92bd31cff9a8fe53deca91d0f3f5c3f7deb1221d58a894e0ff93eeabe670a146b2f18ac119a02b2c74edce75900eb87b2573e091034eb1c8daf9c7a131de8429320e6d3e9116e789e4a53fc619cea1e670b48305bcfb27d8dc05452e1f851c3978d076bcee70dfb8620318b1fe7c9fe3ac3305d737f7f51a738a500a392e7c8e0f2fd2dd7930e5392daaae1ff131cdc3800f1bbd40978907523751d460f1df51c0e8c8b51d9a0dab61b7f580489eeeac852ff6e8ffc6f468e8f9d780a6a650e9ebc3abe5d797e021a0f7597f2c6346252b7e8861070c1159adf9955993bd1eeb7d0ac155864f4094f9ac658dc85f2f32cd9eea110fb58512ceb393c8ae90aa9e31012d08ece5927312938ad0669c0a1230408bf6bafc395ff6d965c0aa9b0687a66639093cba3c5e8251e5f1fce2502da951447c43d5d1acf9985260f7a092b7a5b3e929375e635bd6a8829a1a1ceb4768a912f6249f6ec062a0ba9c0334b4b0017de97017fd2a7c2de60ae95f3be46460010ee4bce35e1f7ef15fbc0ba6970f8dc202fc1c3937fa6771c8185e65fa062b7e1b7f9a2ba3e7cb829abe5f5c3a527f60fecd62d271dddf1b7ea1c4ff19dc0dce809f26476b9f37b55b8f74012f2352683abb408053415a89e912a48b399f0b7df5a15cfb7436c94ccbe6d7ea3c94e2464e51a7e438a5ddba6f93ad9369884be0034d000a401ecd5b43a68ae644e7761f535b081cc420ec76b50165d94ae85a8e6da6892538117e41ed23cd75272cd98b6ac35925b03a17492c23875231abfc0f16f7b90c3b58f4f92d8b361d31696d704bf459abd1cbbc3aea66baab105f7b49b8bc79e7193aa07e696442f3a327c5d097f0bfb2f6cec225cd137807a8f87cba1b9fedcc816e1a0bdd6e2948f07e2b6fb0b71e3cb8886f37e0bea940119a8208ebb4d06106338d04081291cdd753b1eecdaa2270c16b2093c71d53aeff1494867d0c4bd4606785e24b7ac400301901f4209c54a911466b494b4fb183f347178c0747ff1dc6432d6b1093dbb36e292cae9e35fdae32ca9486c3c0b15441ccc27a90c062c03766fd07d77ae2ba283ea85f829e46c0231099d836da229458d5c700d3aa092d510b2b4ceba1ec11650b985ba1709604ca8804c3d3c18a4811fc433980e7d99df65515c5790f10410b8052080ef208b145ab7ea40214168461ea56d93d45a8426c30cc2699e812ec620d71cddbf31eb3974c35025e7acde5dc0ef5ac054a6e30841c805986cc1a42d1a501c0abb8e6934e1b56a40d70d0499de386a66287de65e84962c86645ecad5379ea2882449035d512649a6f6c88a91085de595f4c3b2ebab803d7323aa00c0a7358a47d83f2bb9094955494fe6853495c4e52133840988ab8a72b948578afcb2b209c126a344d56cfe56b2ae33b5b89f96c7d6aa35b788bd06ef573fb71a06075868e4744af71a4aa0b665a4fe79576219e41f2ddb8c77c498ad2167f11aca8c9376a0a199cffa877ba059bf4f461a1373a93c450293c3300103d08642af2b8c1c1ccfbe3fe4442194786d3ce3ca22015bc59259a5ff83908dcbaf623efd2c0a908191fff58aa355d48b44b1a82dce31b36a3abf6837882daf5047d4f5d546677f894b956242799e3a525b7ec3e825f4e003055567cbcee91b265e040d82581a7c19f7952547b41f157e5752f88bf60c5fe62ba56d0de6f45d130007c4de68ffc66af75ea5e89235a5f4b90a00647e79a3acbc9a0e33691e4cb1f18d0a7810442b49bfba1eb77450bc27fca89d6c3f2e631e3c2d040cca1f5579891fe1752f493555ccfb29e675fb7d5ada7e02c6d026d049a3534b342196b075e135ddc6078dcfdf4422e62400d5830233ab6b24105ab164512913578343620f3713d31a6f014b4850811dbeaf506122feb2041250a77720f52e746a6002ff074c9ee00829ad2ddcfcb8abe4b1d6d9832f9427673e9b8bc63de25ceab83be3aae9778918a1b82d6549683187c900bbe43571c4dc3673c480a3de7c9a8fff20bb320c84f2d20ae2bd98dc9cbd220330e27a78bcb1ba279b35e39ee18806cdfe7d7f6e3af5bb03401362a78d994227fd90ae65a5d63996280d857a8999b02e215da8d623fa12f3444ac98a94831d38b07e90f2cef0ec21ef7edb0e575a855ebb0a5aa777093bcf435601b82bca2b22949166a751e5ff79b046b76d730b000dcc8d75f56e7380e810bee5775d244a05f5b8c9568504f39dedff95b53ce24e68fa1e98af8cb77e5631e6dbff8f3deb62620b04ae1561aec71c8df9ce27bb7b7d64bc0b8de3c2d8525778fcfa4252e51ee6f1f366889365494a0853aac874dcde127c9941911b8606f46a9cd6a85dc027b7bc9cda337d5bfb04fa7bc193d2da402cb1e9c3f3d053b6301360a3806692be13812076fb9bb56f519ce815cca7aad43300992772fbabc34a7c2a30dcb375080de4403dc5a109d0ecc2f8de6f19c8b263398b839708952cd354ce68dcf2c6561110235908d65ef5eb404f77f97fb948b8c82108e41d4337ca53dfbe15f31db3ad487386435507d773e59f90a5e5a1a3651cd45b02773d8f71e4f8064efa3a902e815e1a0fd98446a1491f84d8df6c8e384115fa6d1ffa3265a184d3b98ccb21e885831ecddd4ec90663367c0620ab7810a0dcb19f101baeec58e171e4713603e69ef69c946a041c7cc1ecf088ea2956b55c8a9ff8b619d52cd08da70aed2f47a20fdafcb5d4f8912fdb914b328670ad64da9b0d335190d3399de7d611b9c6256b3bb128914c3ce18b34abefb09db252f2107fcd82efc9bc30190853c512156166a03f52a45922e9892f7c017e58bb3e8a7f1f538840317ab8bd931dd20cf69c64b4ab6af0cc35c56e786ead61cc8ccc8bb3c3c6bca3a0808ac03b8822f4747141704e0a783b94aaf7b16327a9787226d4f90786a832c5f2ef2e6b64111d9015073f4c8d67687a45db95651307ee1df2974ca5ace5481e1f1ea2bd6e4e41cd4036b4097fc8ca3467e030e785833f87654bb53570c28f61d52ec5aa93e37dc9f72ad8a2a30058319f8abeee5846d454267c231c982bd9a760a09dfb7824dd7ffec872384b01efb78653f9d84baa3e492c22a741d1b90fce50e79a877a28b80eb23061ef2c3b623cfcc0cb8a13c819cfe049b0b0d376bd0ddc1b8d2df6f249735a5754b6d16b42607981549d74e0538d751a716192777bd23357bf88fc3141d404bae76ddf7fbea845d6c0ab2472301c1a6d12274f3d662d91f3cb94222f8cc10e161063d204f11cc2152ae5a6116fc294cf47811e202a8296874577f8aa65c7d838c4cd9169052fe26a6382fa9f4ce52e92a659d41b6312bd1b50d2860b1c7dee8375c43ec40900223d9e35bdae127c9b459ed75dbe4f9caba443d2926514b6440a11362a04ee0cf73e407280e6d607f3e5c0646148228296f92815124cfd761bf584c90ee09ba17ae0d0cb94f414a65808a15360559c408fd0cc8bbfce46765eaaed9a4e726de66914211222d901d6fe45ce9b8162f1f60d9a90b31dd0d49972673afb202fed1ef043630776898c49ef67adab577e509a0a1a6f28f7e3d12288332ed022898c6716206176d8c9a61024a9e442adc7adb34ec8046447b1d0af89e0853c9491e871012940af7d30558190e150fba91bafea662a298bc726de678e109046cdf7ca2beaa64534234650af2c3b3f5e39580f8c8288adc95090e0a7bcfb26a7f1d3cc0c815e96e2a1c24bb699ab000e8a08753cbb53d45367116130238a4daea5d766deab0cf1b75376b3e3790f21a524a274bd517334da91689bf73e3cdda52854175b0e0d9058bc99101266105f0a24f29c8ac91420af246a264fb2ba2e0ca20e361414424f9a4529d1b34ddb9ce7af76f6c977df90edf25fe1517815c1e021de8c90025f64a97a0722d9afad4ab8766758d2f4461bfd50c9a91f8ceb27952a466a7f01bf4aebb3ee739ec2fd7e2d0f1eab3336d22b5a8dbdbe802362b14496f6a6c747ac0ae1dd13c1d084eb33d7fc1acfb77623477a5acb3db14f36572abe60141fbd4b56ac608bd45462f44d28fbf432647e2bb105443529eeacc5fec45b665f5009d400c76dd6d24a99a7a4ff2fff533bf9e931085aa92fc5c9ed7875032bb3d523bf8851b154cd57fcedfe464e908c1e984fafeff246af3f8082094a92b8d10302f001af04abaea3892e90d9085a04ce7c686dc64c9bae933ebadf1c556abf84f6d6b9fbeed692fa12c6e906264ffce27a9be730150c76ac24735756313f79fd5693f399bf50c823d5fdd8d7230d389afa31f829183f079f5e68822f1d0e891fc03b0bc384550475718205b5f5b1ca2d4b5c15acb571dd3d99de1e346147958693b1945054ede4800f78c357974c4168ce71a78703d63ec9996fdd4e911cc6cf43a941c14e66f2fbd3c0433497b45546e9e244fe17ba133022791eac05f9ae3d27fbbac14e401ef94321f6e0129fd0b936f4f125978873d5d6931e6fb576a4cba0c7834c7a451d8baaa5eb7149cf7d86c43fd55e3a9d311ea3b297f54193d741dfa7b5d024499735d23e4ed0a810018b7437735935ab0d0162850f01b1be88f6f6124892448377a29ce8e4149cace7186409e9cf99d90090b3d007d3a83ff4b652280772fb9f3f4eb0ac5888c06fe1d7745769d312fdb9ed0186a13b03b13d2e241a1e91ff2371de143e982ca0b4d99b74296e47b9671e3b7d90bf9858be611a5f1d433e0fbb5be5000c03405ca82d8034ad2afe97b6ab6421cb6877e2a8000308f393007a7bf13403087068176e16a16ad61a4b5cd0546a601961a263f922adfda6950131b301632e0ea696c1921c32e654b658285a2c267501907930620641a2a028dac050e0d103627a2a6a154304de401721c3443c231988cecf63b6b853ab5ad4c32b4a1086b4c8b1e013ba52f26c96c8254ac201f85eb73d53a56eda2e4b2caf05ca4c90a9ba417e111b6d17c84082370b7e0a0951594cdc1e211d33c11eefd09653f4028ce32b8697b8837bd56e216e73d71669328718c2499b453ee458745c462c386b8f3f129382e3a4c54217bb2156cdc131286d9b68bcc7af32731a8f03d4bf602a4fbf9e14869f0aac5dbd281de986bcd23c2e00a91599f302ff39f6947aab6a329011f584191a58637c7a44f105d6b39b41947686418dd33a36df60e621c91e2ea9e0558073f7a20385eb359ee016a9c697a17ecb78ca760da0b1330a7de30694c6518311058a8502e3862e507779d14149c4409ae8b10be32d70ba038201102ba80e295da21db101ad32a508796f5e0597a49c03c04f33f9c108268c861275bbb0e12a9d57425832dc42b682d64e3c9af3e157aa4408cc48d4f16a59a7f4860950172077d2b4693275be446499064f113846ef55aa755b06cac23d2179e3a951b528866f2872a4b5b599367e0c9625babf1919b3891836321e74c30a7701b2cc68608ba2ffbd986139883a47e937ab0972719d0813605bde34bd62e2106baafa345c03d6a07b8c8181ec883bdea7d6e5aac78414ae6402e608477a9f3d5d2f190f817d8be1a80f78d2a304e01ec631400b92f577d585967ac41f03511ffc78bb54a33cfc21317011a46c1b076f84cc4f06b42fae1fcfaa409ad5b93e5f6be0f0a60b02ea5024162856e3c263758b91287a95b1ff7d6ef443b6df104560a3fcd454f76fa30a5bbf6aec7afed8950e5e899ceb586b5f7e4f112f5abb49705059d4f2339a709d226c4e8ecf57e300d060b4e753e7571a0a71d7262c974dbd14d16f4995241fa9b9f8abc9305b81022f8747fd0ebfd7d49c6700535909afa36bcdee8cf1f8f5e757f4fe51c4d37b2d23a58abe1027bf70c445d4fe540143f0dac1bdd65477e96679efb045119353e2d8bbb87ebef4ccba05460030dec2f105e4ec8cbdb6237badf6c66c009d4d9c048aad6cf8274b5789c809dc8bf4c5b48141010977d55ed8a5c1c6b1cef254fe8837b1d0617638e48474d70cf38724d6d5e7442e4cb0185415aa02b463002d052bd4ee3f92b7641c1a33e609262611486e3caa3a7671e275e84e803b408c408f922470b1129c58a563941e8d4eb1784a614805c5a56e547b2637062a1cda4e737ccc41f1487874e0309c8c081dabffb52347eef0de26a73abb341f976f82ea82297612051a4f8240150ea5fa0b07c6521572b4cb827e4657c57e9e8e08362e68612514b75efc86b805af9cff34cf78d74f7f808d471506be09d0488297c168917044de93c68c2776e578ca6b1108d79429a8ff8c721a520192bfd560ceca52390b16d06c8b649aca0bd9e9f3cce24d2bf1fc6353aca13f95b1a555740685bf7fd9400615e76b6f64221419a31d5f762466068051630aa8fb144f2f15024c36d239a2efba2522a7d8ab84d563805cb19ddcd91c716b476c0f1538cbd034ad0fa73f29ea898652f712d060cbc2717a50dee8a4f2fbb86a350796e8676ae1da0737a83736090944627c91775baffeeed78a33f8478fa68e3cb496e129e41da07bd6fb2c41f17c7c24f803372c542a0ad7e46a7e0d0c753d95e60e8913ce694113eec95d280ad4b55488db6b71350fc6de4d477aee70885b8a22964602ac0351fd7aaae7c3a0f414239d150aecb50c07754bdb8c7e566470a58f38ae4f6b4eab52ea4ee2b6cdf970e2ee609179338d5ff506d46a52621fd44f5cb1550d507443dd1044e7f22bfade45b97690906d19f6788ce2a4383b64a791dbf395d0b1cf9076b1cda679908ee4a7ddc45a14b725101b386b17e493b0ccfdf647a01f5f115273c2eb9eb9aff8e20c7c2708091262211eddc41434516ff09dbc28c36fc11b19c6e44181070af03b30f8bf4fe41e69b27bc186871d360d27b5775f93b7fe8721b28ac5d814875eade81f8b656c69e00ed7eb1819534d1248ab61d52f84f1e004a72caf5c8df0846beaa4e8e599823d78eb383bdaf47f70ff92ba6b4fe16b352a57b370777ddc87ae43f2b9f7b3a8f5c39a96f3ef7bc82ba51620f89561aeeb936e806e0f3b426a4ef0626813dcc52aaafa76fc47a5c2b943ae8594d04366b1672b3486073d7e298e802078e9464a56fe77548afa6d78f996245e623568888b98e57b1a016f3f15d1cb17a2bef10cc2089fbe5a2203f6c505886104be9b8c6c5e7b3c3b18404d5ee37d254851d495a77ab348f0ff4755e0a38081f1fb738cb5864735903ab0523cfe065236f1e6a206dd86effeb3c58565744e24d26f813aad283c6dca20283303724143ef81dbd25b625c47fb7cb478cbdbf53d6391e4a6d6df4cea26900b91062025a850b70b0feb918ff7d43dcd06e9ac72b0e7bcb43f5db7e8be0200c2df9156ef91f7aae0f97fb8463080cadce9d4507be5cad2ab54adc68bc22e64fb3e3ae2ba58f99e8639fad36371b889e7f899d214da0418dbc3c4470b87552d8508a14b7f7201090f522b13a64b765e2c42ba472b5e0395681c8fa2b272207738c4439377e2832a87bb14b6fbe7d90342e9dc69a3d8051c6fdd602dd5d1f197f862a4023426643e8f0b3361c5ec2fb76cf0e47838fed41ff25114f917fe9d96bcbee1dcb3ec976a9e2e55e8ab01abb7afb39eba50a9506845e5ae168b13b2f55f0d9347482ed87540484d3856f17b81f7bf0f1edbc3eef5b7723b06311d84617dd769000aff6c2305767740a4a44260d4408d5ee0fe6d867ac9080b378cf41c80f1cd3aaf18fe8fcd5b15f203da2df112c103d3c4083f9f184b6ad1f22425b1f188cdccc215f8e0311a8fa202ecef048fa9f97471db630271fa81ced5d8f4788d350c0f1d85832c9e7611a63ba30e31db103e2140cc352ee720e4d6201c01a96173a37e3478a59d6a046d5afa24b3473f368af8bf0dac0ed40cc1f7ce3c1647ae998804bb353ac7f65881feb846f681650c856ae1a2c6cbe71190bbe14c0a948ae24765407b168ed6f25d85c22b7f10051d8aead42d4d915b70599c57662a8d5fba727034a91af6d705d432a5c688a0389ff69164787251c00f9217ef9fa4cf00c2536ceb1c039db86ca2ba39f1b63921b941e1d42c7e98f0e290db381b42d7ada32fb6f4b07127ddcc992e2f178a610d5acc487934e0578d07d1b0a5d9bffb75972851df09b982e8340f18705f0af40143c3db451d0821600952638b05900c965a2ad665938d625123f9ac3673cdedc791d7704c3f318a08aed37e99f7eb27bafc2bc49f93446b28ebf749c27dd644f8fe245a0d21ad06b16b3f185ccabd017d1bfee04c4ca16d92a3c2f8fefe16819161cbdbbbde145c0dfd72491f31d25c6b9fc661a5904589eb84a1c48aff52a360ddb3ce0dcc9cf64740d1ea822a08b2145aae2a0119063906e4ecc3706571d595ebb63ea13034012f21fddadc68769823642b863f9d33bc241523b221ad37dd29893b8c5161422e46ffdbf0e78800eadb9da845c5d5321bf1534213fd2430dee2aaa31910b88427e2c9a42eba7ebc52dab082a09142ae109f9f5bc392a22e4574a880323c0132228988b0dcd98faf8eb8698bb6160aaf3c5322c010bf6e1688bca65d5f791f5236bc930cf7abe3dd00096f3efbcbf8ffab1f34b365ec1dabd2b1f859c7c9f062b49ed5ec2009bf90f50ea4db1f983d5fec538dc358a2ce630a96d0040a8af12bbc73b971fafe33d98a6985f5def9b6c8c9cff80b847f6e144d0ccc5f0073f57bec3432e0bc4d7de3c05290edbdec0777bd31e7a83466405a3dec93b3ca3f9a7ced23c5961574568d370293ffe64c7bf559302ea6bd0fc16c7f59d372fca6ef20e24d26a65efbf96721e4889cb4e610520543158643f43b18598499627fa4acc8632bf9e5317994a99918f8c654d4bec62411b76f68680ade5500215d49acb8331cf63018d51fee0f665d01bc3cec895d05bb6cf8f0603014c2a1eca7afa0a2e282b7fdc63b094f293a1b6ca80026526290d98197b521e2b5175ad6723ec71cece2e6f650dbeac74610154c7c1fce1f0dcc713a6a426afe73692097042f0c1b9b7bc4c4e61bbefe2818a979ceb0404fe60a730e8b8df770815465b5d7ec234ef8aeec66d14ad2f25102170c8efacccff3a93946f7350143368afa0bc65de027db0db117978c073317d4838c9a5b140abfd68d9f1b136937a1edd86604f095f1cb094709e6b6ff66212ff29c0ac106d161bccb4aa66f383263bc66c924793909b3ec7e6fca29f9fcbbb7ebedd1cd0d5102f4146359f1cc362905d0faf32a863bcfc016927c1f6486b31193dd5ca7f3de37561ed4e18f14f39343c148c978b5be431c4349b511fd220e726eee022de4cdddff171d956914f188382e5c83b2317ca21266bc761aae7648b2d7a3243c29d96e3df7bcfcee559dea2f52f31654561fbfccab1390e4c2c6a436a66f9a453f8c2af2e647b577788ee386ae6984d68ebb3227edc559781751ea0320e1626b75aff587289ce04a6a1fe04acd230ac85f9ab58b9994a8732bc22c2e25434e69f88b34f68cd3e09a383c228647930c903f88fa2ca6b8fc7f5ae2cf46b99da9e6efd7c3855406ecd3ab83abdf8edcfda9283ccd95d17b4e500ede81967fcd7798c2dc9759894ed46ae3ac9c1dbf228ad8f15742c2b2efbfdb287e574822c51140eae7983d9958e40ca8f689de5361685c20eff44f0cf0923d8f5b6de6d28c2e0239e15dc55ecd392dc68f1063679df00b8178502d7943780674dcf5dcfcabbcbb2853615c4130b5706aec20b074d2a6058565c0b7a12cd0e6880fcc221f9d6c184ad336ae21d71f187bb0014d600f2f7ae93a764722d60ed8c96e12105a8acc09ca0daa53269ab0da10827c5d8ba322b2943953bad198cbd714bd93c06f0e017104a2c08a56cf5121755040e68aafc11ca5d2e8308d62a4d761ff257a5119a63a485624ca89162a01abf7f0227d8ca07dac6e54fc06b236e672345f07a03828daf27705a77964ba15db181912376b9765ddf9a2a0f62ec03df15083d9931fed94972de4bbaf6ca45018aaeb49502ae6ab41461c6b50e512be7bb36d590068a55045c1753e0c41d92d11e096329a5642b273ea91f7042794928ba2d92398d9365aca43b40c99ce0b2868983fdbb5e3e4091bc516848fb6fa85f6f2700a287d93874069b8600d101529681fa52890e537f331a79ac32b1930a41f18503666875a87be7b3ffb93266f78c182cebde965b2b114b67b21ee8bfdc3486d1cf380d17c52788ddb06dce4c298834dd14a032f791edf2b096f83022fc0d5420b69ebb9d739239f424090556cc8139082419ac90fc030f91dcfef2df8cefae62c01c9631f1a7706681e1139c7d25a2e6541cad2507ceb3c088487e8de6a0d60124f07f32d518c14e9f35c322793b89c74d60b6ac7988061044eff19ab982d0070f5134d2e1d5176be0e189470c26bb94e465eaa37f5564fdd6f2b75fa8449b964adbf95efda31a0786ddbb54e6337fe6a6a0a8cd8b5ad81cdc83b9e42899eda552da5c0fbe43b7bd40430ca4db196904acd59fc9dd6d2d9a1fcd896416c28677ba6b741f49e36cce89abb946c8b658402d3e71673f0deda41bc7fb6b6487bf446e944f04d7cdd1fe35d8c11f1136e2238274e338fdb982477072d596b83f0a4c56bc1a294ab6c403d4e2c93beb83bb2afa51d50f603704486579fca1a56c6823972cf7886c78bd09b99251d1dfe0684bbc1415c309ff09a348ea73477cd24f1fd2a87a78f2cb1003fde4e3b9786600eb4976e066c3f6418e25dc6ee42f9e587de0d233524e872570d07162edfa3770a0049c1c792098b8807e3f23b04569b2e5383648e10fb93b0c8d790e1a0b5bd85a7ac29d15fc5d77ed867f1310cc37fe6e37ca687a518c88dd5535345fb8b4719f20719615a0db182cb74f9576b3b8f1f8a439c04172a293f0c4eb34759cf7cb302e6ad0ad0527e05891b90c3b5122cf06957b37846e12038225f01bf6dfbe94e31b675c36c9b0c65c9db294c0154cad324a36b72413ee68af50c5e8f7076af3628b2230fd72bf44a721bf4cf9cddf65c027d642a18db7dddc0dbf1212ee4327657149c8b0189933b3a83a5da495d9fd6cb0a1c2f4520419ba8a26d79528d715f10335a0d4101d4f6da509a3c2e3cd32c0efef852114644575a7ed150c66813c0b7511e9463182517aa608fbdcab48d152bb9ddcb0494171f5253c86f8ff85cb1c905e4780910708422172cacc0962edd2f9d7b08e56756ef9d0965228d5d7c128c278b456c403c5756467cf3764a5987e0fd0693cf5cc8e75bca9ad130782410cab4d51691bf04f3b4130cb514f4de8b4e1acfb85ef18c3e689b2bbc07cbdd64ccb88fab44ba4cb9d7d7312ae0d4ebf8015fa4f9842c83268f2444bac6cb057717048eda2907d68174555cfc1c5bdd6069ec460da69962490f44e20041f43c23ac04964388e08d1c2db030734c10e6e84b17ad86bda100f678967dc6a9c8523469f1f362c7c1def807f5914d1397b254a21ca9d98dab989fadad6fb853412dfc3f63168e9e253ba61b39b2e3ce0165c5fe2de1730d6028030b144c3b3db810f773ce4f98dcb3ee5084a62ad2d076a12515d790197eee0cb0dadcd55cad4614d7d13468234b78b4d29625faab6768dc806c139011752dd36d096c57a4d9e4086915bb9d019673286ae37b02506283f13f2e272a31dad8dfb9eec4e2b48541ab683441fd5854d498757c5e0b0d2b3e31dd9b58a129671243444a72bb75e92fe7f32779320b042e8e1a908fea768a3c292e09320b415865054d17da8168015f0721de685faae1564ee66900744c59ed23d2a839c6cbf582341f8eb41120661b5363188a5ee9431a8bc29caac697344b6abe260a5d304be621a9a00cf171446d6d1de576bbb97864c7792b05161c7c34f455397eba9c509cac949bf71399bdb9ea97fb38277204bd22964ed90a0c0612060c56f7106af32da9f387ffe107d9d099771e509554c1fde9c36a4b4ecd4358bcebae2e29ed99f953e910b5891b7269cc9067f2c06a842afd18d157f86eac1be24a29c9c436ded017fa41a3a4adf75d5bb1cd61b35b2545070086dfb96b246bee7424b3323f379e3e398a527611ea627fa2423ee559034f58e01c67c1573971e42675fb637bbd0f9490d8d8b0a05275651c73d0f6ef35656b58fcfc8a09ba244e2a820769e1316ef82788093076d1e342e595f2b663217e4d2f3260cc6b1c74d844440bba0e4feb2798c03a0a0d045af4a16f65038739c54ee840df2fb9561d32cc8ff709213191d6631e313b95fff0de876c058e23f9d1eba5ffc141640f445c520680c96e8bf7431062921c5a5eb5f402efa7db7efb7998497e7c0caabbc6bfa51e7311ef277185fec4d8e91e0c8d8438e9c651be58019da1fdcbe97d1a046b9c0114488dd928618f71202672c33234fce51cb15f4a6b2733eedc8590044a72aa83fe8a3f79eb1e1bbbdbeb00bab7b2282e801957a693a4f4f0e5954cf88326ca59fb19c002656c12b5dd22e710cc14e72a947050735a09f168582d782d459c5424944948151263cf65b3ae5271bf377e11f235e82966524b1e9aeed22dc3ae3544ae660aae370792182f07d7767b4cc861193b79adf7c8716ae767b1760f958be5290b6fd1b48b0a12bc79be3a6e2330038bf7268d478f83cfefa3baef16f279a6717e616d586e693846fc49462ee5936632e0aa65b05834ea6fa78e6d4a9384bb905a1fe1b5d4fb6788a109113d9be875cdb7e33350e15d038d44b485c55f637f4cf50b8b6ac9769e400d78ff8f8a3ae6c7eba2a4be0763fc70e6350c6a1a2a64a18fb9c64cdfbd52428255502e0858de1a04ee3297136e9c5e588b50cda1cdac118452315f3282082e86b0c4be17073913718bb8346dd8756a47e59845d9901718d53a7b58ded58f442d2a6f1fb1d35b07fdb0cc2cddc5f0e64eebfa18b0b5e6ce5fe687cf1f030bf7c5146dd74c83b1ab7e104cf47ec0bf01947660ca532a778c02772a1cf4d23827d2b9dd3c79e0b9409d0d91cadfaca5056eca7204ef42ed44eb1b1e9443d81d17aee5f0fcc95723961d6d5f6389e86a1ca0b1ee7a30f463e39954207a5049280d2beffa264e30192325a59caeb9573eae34741cc635bdd2322b11cf113ad00461732dfa3458d5bf81200a66f9f79779c844e20845b8a8b7b67a0e64edafa20858c3567d3fe433a7954287fee03240d983a7cb93b46c5fc80ea253a622866a994c01d4bdfc3e235e551392b064b4a434e40d45950006c38b448ab40ae852f9b52c45604235dec6145f6a66bcd709c71396c903a196258591d6cd9bcb7b7bf70b0240106b47b5949f02490c1450002bbf9e312d0fcda6ce5b27e8a6a82192700054155ccf1a118a0d84c91603ba9075492bc4d380275e43651228582481a1a7ea22c35f20be435a52b664b1bbfaa8bbc86861e077f48c84fc8df7b8eee2f522c5b0e756df61474d3e13a95c6fc96e92aaf5da158307abecace3ca29e5b7066b2db049290491380a641f3bf5a87f12ac448a27990676571ffc4a4d4d1446a7bc8f25f5c5bd609ddd79ac0120dfd0520f4f3382e28dfeab834166f4bb27af544399c117df06450565394917c364a517a7a10c310d18f3bf7ebec3605b704ca42242be2532b00166d6a3534d74dbf16085d493c6852eff9a4b002f6098923ea8707857e1f08087b0e69cab39090569ab59df8e5f1035e4e4d21673831592b446a05eba947988535ba06b3ba45bccd54845d26d36a4a8acf5b6782e12a55d90e55fede0fe5f443b57e811114263c668e91806da972a6f6d3b8e2c66237699a1c5a1ca4396a91b1531d458adee2592247d21fa938709647b1b428d7ec9e783b807ae1f835a8327aefc9f4b359364f9d6fcbcb1c4870c0034c53b7dbd09452e449bd224f1854843f7d54000a7d288613225a6c66381050261fa72a2f9d7912240201ac735ebf77e5210e5befb703ca4a6300d7c0424639ed8d09e06c41ea3a21a87b3950392a2f783faac210726220b492b38f90b45b46e671223379a6e606cbe98bf66488c5223c665151290838b8850524ef971ab8d918c70948a62be09aadea955b105ae642224c6762c520cfc44a86db2908536e7ac4782fd7d2f4c4a151aee54982a1b4485cf6b84f88ccc5ad420dba073aa574da294dcc89232b951f5cbcd89abb9eee2a80c5a3ed2114c21e24537f47c7e52b0555d7db24b300e5acb4375ed269673149d42a5e1e64bd778792ebe96445ed33c946f00b0b1182dfe1aa888605d893c398d48892d0fe6016fa3de9665a7422503d10995676f1b4991112141d832422f23ce245c08198b451c7bf9d64b9989e4b5575dc3f70d5b95746a1b8fb26c7ca9490670908d724c3708996af3b9d664b044f7e4950210a2896d13e54a8c1f7d0e6e72c37b53195b11f30d1a620462c02c65470738455bddff7ffb1cd289338ee9cf3bffd169a7650f9ee481544605c7ce19063a87777f180eb77f908f230738a822bfc675d2a4ec8efe0d24fe7fb14a0ea168af7e41bdc822cd1cb72f73e212f3f3d8cffa62197a2795d2857d0aad8af5771079c68935f2727d1930466652cce0dd947aac90e430b2a3bfcce0326298cd480b9a03f2f721eeb4506f5df67403669ae6c7688576cb9dc4aaa0f7f05a11db6c48af522f74a69b506f740c4ff115f2cea0c5d2a93d8d591175445daab3c24e17e0da5b6dda585683494afb3c7423874a235a89de6ea4dacc0a3c48d6e06d83687faff2fcea016a2822cc25d578c75ac9f9b68ebb531307f8ba97f3645361c921369f25656f9b38e547bae0685105b34d0d0e8cd3879973c2ee6f1d99e63a669534d9fa7baadbc97ff89fa9f161ae23dab1cf8e388d355433c816fd73404dcc6901c10c6cef13b9b5bd7fbd03dfab0c3100e6e3dd88187d78b3922eaa803e0ecbe3e6c374cb85dac51f0233f075337912e82e1f884e4018ae22005352d4d3d159d81bd40a5ae914f07f26926a2af720f373be19c36239f2e9b50cbda9dfc7533208a04eae2cc68431bfa0418a0b976d3a204f71c2820c4ce2db4dfa5f66d2e966114c59d143841bc7e82ce9a2347ba002a6d5777fa5f8588185503bd70362e15a845d103230c240cddcb4d0edada2be960d095aff43f20d68f34271cc69cb4d40260c368066823d03b837e0f44c57a602ca1b70703dfdc05bf56f0ef9acd46bad10b58aaae821f91b114da682e1ad3556f4c28875c2e5a3bee0378c12624825c4cc305d20b162ccf76502e3450747f0795210099606813a90863cea75133814bae7767698a76c016faa3ab21b61c5498633d55466f2d990760c00fe48e7d64417e3a431358598fc88f0b78fa200165b40e5ebd40e35decaee6fc696ba546c929c72813384f43923a4138742a443c24c5dbaaf6184b6badb6dd32450eb05ae99032bc5b1fd2204ee4f1d149f836b084573b97cfbba9bdf45b42f81f25223bd427fa528e3718e6baca056bc083b6f89994c838f910eb9b2ef60e2c3f59f9f05b1c6442df0844cb906aa7aff0291659954c1dd510d9dc99bcb9576e21e297124d771adeab31478adee2e34f27e5352d8a43e8499e2f3b07c51babeb5ae7491b4183a66bd84a1b6b4d124e87456ea612a4da147ad49b5fde21ac34ce49c8ac1e364fccf0bb099a75af914e1f60166008fdef134e3999488461f9bb227825df4ad75ca08ec27ed200cd0419131ba6335bbeb9bd623b4d9ee96dcb4126f427e8a458567b7d36f13487dc140bb2587fca48162adc67cd0769bcc09d309aa6d09b23650adcfe97652e00d1e24f1d8d2105e0523ce3deba68e3eab113c5aa633637cf7b1ee413dc288de57f0588ed27cf8ba0732e5a90bcfef8419f1acf73f6318f7610ab07902dddbd5bf84a4068f5249e6d5f6fb9fce44c661759ea3ccc76c031e814453d05cb71461b84aeb028b6143ea3e0dd4231e614650d452a423b5a601db29685d05370e369f4939aaef07c8c1f73f17a51b5e82296cd0299904a098a7c97025eee55d14b29519e75f12f5dc09f4baf55bb8e58c4e061c80dcee40b8cbdcb662a596e9daea7bb60c8ac2a08053ea37f2584c6a1ef5e2e02133d8abe25848e94e61af5381192c627f54a121934a703ca941684582056b24a07f26597e77e2fbd1946fd6760593e9d316307dd13c1cc5cd5030680fd9fbbe537813459e0f28c39d16d1f823a43ee45b6a9ce15d5c0480fb04a5f9178aeb1adec2563e0008b56d2882464efbdb7945bca94640a5b08c60743081ce4f6734b7e06e248c2862e84f373dbd21591dbec59f971fca3e6421e61422e452bdd18390e23bba217535a0907ee2d6e8112ba4e646253fc3b3ed9a64c791225174c1d9138454e59698ea223ae742e713764a6302ea9b9f1a8874b32b211cb9187e32db9f52475d1e32ff6f1e12e1ab1cb3f1d2c6b05298505a41591c202ca5e7e2133b9118c9175771e7e88a6cb11e7684493021bc62746401af40634583445baccf58f5a6a8818298b28ee91cb754cce90c4cbb821af31847361c368148d5ac8cb183e2c09643e3afed286a28ff69b0d3c1ae25127c05ffb0858edab6133faed63a282cff63dfda33de649d93e123009f2d15e7a524640030e358c407b157c827cb4eff12d763ea48c407b29db47821afa4be0c3dd8ff6d1107dbc411c7f09619deab2b1cdd67991b91c5efbacd142b14bc7a13a2939be3d1c1e7bebf4598eff7bc45f375eba14563e51617fc3a38149f439c206907fe3dba321faf41f21295d59fdfca8e58b928ba568f4c5a42f1e6151f2d45ccd7c03b13457ab29af944fa43c41698d2bbfe5af66e6929116a52ba59371e5473594ba7858572f041bc6a335a6b02c1fc6a75fcaaf76257db61928bffa9939e77cb2f20060836d8761793a9ebb16747c7b355ef4d1e1235e2935afc36379dad778ec53738477a6cc873a2e657b2b106ff968ec816032cf1e83fdcc175aec6bea65bc50478c97144384f1629037642615f6a9172f05ca97f259be7c50e25c2925273f8787c36b216fa1bc76d2445de3f5136fc9674d91bf153971e5ef68b234f453895d20d05f03096e3c0ed1e7c627a58c5db279e5c735983a87bbf27b4a3bd12f0008f5122d574a19a5a419364390cef1252197622e3197984bac8bcc6426a5c8921ca9df94321da386e79814cbe15c5bf7896126a0946294821527d6ba5a514a674b4ab9c8cc94524add23bf5ff756c3a5cce73c654f2ffce60c1bf39f93e38db367bd724e2b95e0eeee320773777777c7648c4ba639991963c6d8c3306c323327ed650c0929e7a44fe56cda22e5e7be45d62cab5ce4dc82512e1bc7338b8f25e900c93927bb2acd2a9d53c75f2f74ab29c0376d01be2264bac7cde71727e63b1a0431df3cbbaa7508114782b5f94a31ba84ad52003fd8d465242cb818c3dacb485850017e81050d70c02209ab821dfac1b7018b28f216635800d104c3304c054b2ea840cb009ec06207af08e78a0757b2ca6abff21855bca06b34acd8c1698d1b97a051458aada2835395266b650bee06537448582cc9ace4dcb0e6aa9e7170552a555293ab4ada82b7204aa56a6eea6d6eea53a92b7eb8a92bb0dcd40d82e801a8e57e0123515f918070516fad407151cf483c705284aa904191aae474485600a1564a6b2e0dc0a5b40a1f5c6a45511534e01e84418333785812f2c1aa38d21281d0c419480c61791c39515153ac649538f2e5eae80834260c1555ee2cc09d54a471670db09ce69c734e71842b6bffc089271ac663871459dcf9727e8d72e7dbd51457eefc0771a494524a1b3421a59472dae008cf0656a42062fe9cd3872f9cd8d003305a70848b31e79c938389020c1c512461f5824d8b5a6b553d11860f9688a2972788d0030a0a96d4134d442726cb830f9d1051504634e1a29c9218628342d4219d407b22c479e1244b41940d0a317aa84318695014e107fa6429b341070c668582a21ac50e3c4c178448a25140c941c2ac86bcc5350a24807061082d5140e1c4851428457185095c2062298a1cb8f0c4c82ba2310304cfb03097ab141145006a14e1c40e4554013a29420758952280e0a40726b4748b992a135dacd0ca8526869e0041145104af6856b1b10d10b12b82cd0013e19db8a2497d31c41bc6a42c66d56312bb20c03e31bfc5206ef99be0faf340c4bf566bc31587ffba212f6d552c0c6dc41bbb1e3f319f51c1b9acdb4b09e2e8a834f6d3b3bfb8b69f2aa5a1bef03b893e33fd98e4d2db3310fcae54e6d3a25beeed1ef81e84f8e27acc47c45b3ee3840d75e8e09d7ea2973e19b1c5dfee1a18c6d3088ecb1db8ae354ad17ee35a6b0ff6b1ead724d8ad0df382284563217e7dea15c9324ae9ccbe30d2c7aa473f529b6ed9e37b5c62536c395060b19f397eb0fcac060cc0a0728512582831f9c497b10138f2ebc962fd5b7d5f911217507ef09dd8b7d773a77f8fdb2db8ee188350843aa5ff832ffdb02f94f383b0aaed60bfb9234e82d54b3df6d9e2a89b882f1a88a3f3d957d4a9e3e637bfe370b4f9126befda59c72cd6e834de19b99b2f1fabe37f968b3407da4d2ccc6524a3265a2db0db6524a3237880646485910e6a58ae09891a24a108260840440d8a3080218bb5d16a52032d60036ab0342f23f5604526c5d32a0c16e2ad9dc9c308e01300b0e38fc9bef10a41ba57b4303100f35e6830e29c80009efbb12b7edff82c9b8bbf79949977ce9106e30bcd205906c18285b1f4910e8e4dc3505046df12843484b0d20eb604218d20323a16383b7078ecc03140eb1aa051a8020b50d244af95ab594dd178de110eb361aad1b204be846c327a1a42b00ca94228c01d19315b380de756ab93d0a3b16d31cae8b1b52933efda36d4dddd1b7377d7399239b20747c75fd8ecee7677f7d8e5deb1bbb7d34c0d5863c0c72efe2ea6408169107b49b1ae07f65e986d15fb9ec6b288bd0cd2458be130c7d2c9132a08bbf87980dc18262d8679956a84cc74b78de3ce89329f64661bba7f5766cccc9699ebe4103ca1583ff5a6645469c1a114aa4255e8052e7e55a494b40dda066dc3c6c7e8d3261b9f37ea853acc1fdfa56b524a29a594d99c2fa59452babb3b7f3dd2203fe52ed863d8d4a2820df2cca47429a5942ea59492c1adde60e3b39452b2942e8fe0a72da69c5272ec32659729bbc8c984c904c90425cc39e53bc628bb4da13ad8f82e6990a997ecc8c86808a329514d4d72367199b2a949ce262e534e2967939499724a2e7236bd787c9fcc2e19e717b99c3c2544e614fb28eb9cdfe3d393b3004e6cbc731ac166e34dfbacca4c6699967dd56483dbf7f4f6d17e9edf13fc8d7a717e766adadcb6d7e6c7e9fde0bb3df5f8c6d82c03468d0d573d9be296ffc74e0c7bbb1f7fe727d303ebcf752bf2965d8fbdf97d27869d9f7db6413965fd2f321fa6d3b25ff96fb3004e3c09bddac70273d3cdb0d9036773c28a0f4337895fcb567e58c18dac0323a594527ea1119c989898ee7e791a2ffcf9617eb5aa55af52a9bed008cecf4f4c4c0ceb5931ac2fe6865dad98c8bc3c8dca0b8de0e0dca059794c66647e62626038bbe2602a0eb7aa41b5adf2d26112192691292dd5b5bf2249e4f5b76ebdf0486b1d0a853a9d78e774ea3adee93a7669cff18ee4b4df78476e9ba6f18ea66519bbb4fad2abecd29ef2cee9b59fbcc33ba9d75ef24ecef61ec63c18df68df9ff23076f59f3cca3c926ffab5774fb24b7be94d76699f3ac9937fca637679cbe7387bfacedf7e117f2939a97a4ec5a99ef30fc9e993d244f5aa6fe6552a99998ff9f92b7fc1fcacdf9e6b2108baf6b9af5e9124f2da47755f68bf7e6ec69389f12c8cb73a72398ee338958ae35e5eec498a8d6deab680edd95b42a53e0eef43c5e3e4ec943f9fb9c8a30c9b7d6cba217d4d03927d614552e443fa49d9a40cbdcff695808a7c2acdaa57de8af960ed7d8006dd47639b5f04491874432925a0529fcab645ee7ab40ffaee7fd2b447c27d32d05cfb1aa7d99e6e6603c8741880dbf27b1c8dc3636e75fbf3553d9fbea755a7af764e11ecb3eeadfdf6c278bbdf5e3e36ddd46f1b6fcdc9ab39e7f9957d65fd4217279f7947fbd3b7abbf507b1b54a47941454d57e39a93af79bd3d12fae10cb79381e6729f7aee1e502f12fa2128a27df745b4efad3f24f44329f39bfc90d0f65cd62bf3fdf621e13e294d645ee6e96f350e78ee7e707c4fcb78d55b13c717840da07a99afab42ca7ccdcfaffeaac121f3f337d5b7b7a341557fdfa00ae6653c1c3532ab97f998d43ccd3391f91baa9f7926aabff1d65f333fbfc6b3dc52fdca5f377ebe8ca7fa1e87f1c2005cd557a47bbea87ff14223ac74431074bbdf842eb32bf585ddd7bf3d5feb6dcfbae1d1784c561f0dda0a8c98811041508183283e3cf3d9adfe0d1e68d8fadb56fd45c3126ea3c947e66f883e43d48749908fcca67dbff4b46f85fafd80faf2bd5b81ded63efec9930dbe62bee3623cebad292718563e8b85af97952ee60019e2cd3ed60af5d23742af0c7eabd2152e98ecfcdeb6ea890436f617951824109b7cba3de6965797df0af5fac73e415d82d82d3ce5d842561ffbfa19e6dc7caed7bbc9427dac3275006d6a6aea72b125d46fc1a873642b5df9d987f5a994a1f7d1be12b4920f957eacf3d15fdb9b9f451d77730ef3fafb01fd45b0fa2d18e9b863a0e2df6c1d4485c7d073e707f57cf71c9fe3f6e750419eece9f69f7430337318743d36ddeed9f568f693b3fcf9b2b080db31b05658c0ed5f0037dd3032bbead1c468cda6c635d87111d6294fb27315e8b8f543a2e3d69f3eec4512996e8d4b1c79e29491a79550ac6ea1fc0ef2e137ec5898efdc39a0629f8fed6bc7c2fc2abd96e26e5e91ecf96a5e91ec63617ddd0b5d855b3f242adc1a65bb3c85a0af0cd87d8a7d2cd82eb6f86c5314b1b4165d6a72f02407368842ce03d2164b785ec7288f36c6529c174497df89cbafbafc85245801d9380496b1ec807451dc391e6ebf6d918b6ddcf95d3ba7b2e06d08ddb0044aee6cbadb77b92f8caf6ddf378c9fbd772c047953d3edf19edee16a1e17a1cfb77a45e8a3629016fb045b3fdbcc96ed2dd333bd6a55c3744cdb4ef54bc746f5a9bba6f9d67a6bae6bd3c63a76bcf1fd95c586a561fec81ff957917f26c67ce10ae60b2dbfea88e872eab35fb862b141842516a13e2e62ed86c74ad1ebc7589c915fc6d58ddc754f0bd51f6859776466e62fbef65d2337333773a41f63a4941e493243e7546c6a571ac4d260fc8c1081e185af71aea051609b99397baf34f8168b62ccb237d2491dbb3b7667f1e5b6fdb66ddb16330f89c77844e784418f02db4410613771fd91ba09de6116e294ed88066583ee99d751fa8829ae431147252d0baef30be79c7372546c3f7fa1ac517af4b420ba31f7eb12b26460e33b958d19bb825d91f259baf7732fb179bb7bccbbbbe3f01a77f71befac777799777787797777777777777777f71fe2eeeeee38eeeed57d453383a326d3b04a3794e54e5d4a05f3728325a3847583663523a324060c18d58b92ee74ea524a2cead4714a68ad7453a26595e6f84e89ccd1a111d939e4155b70f4cc112d34976a15ba3e31724c3774a62e10601fd7c23e397450d9857dcbef3a439d4bdd85bbfb7b8f9618f6ad79365b11b91ec52676e4e3dec2cf7077af2291d8f86347b99b73dd845fb6871bb95c356a3e8c6b5cd6cfcbc894f8f2acfad4c7eae476dc5ba6d6128bbe88568b78426dcfcf21022e53c746452ef126bef64cde8a356b27f1e6f9c75f9e14562391c7cd8845456e9dc8976826262277125b49a9a8b97051f21797c8d35ac49bf85a70616a2791a7978837d1ad75a2d84eb468a9f9c215eb0bbfc64931ed84da3acebea852b3fb81dd1b344966acbea4994fe67333623a1b7c4b1a75094530315b542fee728975a225525cc7c4c4e44e2ceaa4c4a553e294b86c182dd2a2a8480bed732dcec4a5c1a8466f914b6e8cbec68d436057fcb05d0bbba2141cdfd960f943d7d2ccccccfdee9fbb96226c8cfc6125aae9192628fe4a713aa7c38814bbfe1b31c8db3caefcdd3d41b1f4b18fcffda6715bf65aad5ddb3bebd495479388669986f5b66958779fcd8dfbc2eefbe91cbed147c3beb0d2d45b54ca9e1e75d2ba8ab179f577e93289bd4831c62aabd58a777a48b768582b76d9558d0d965ab1974fc32f03649ad6f508b2e21dd495cf383f1f9006654c0f36642c38b458f98eb1a0c4963ddbb24cc5230a214123a5947ed635f6fe713e730dd2efe94a64bdf31174315a44f7a675cbe03124b1ec924f3d1aafa65bf235cfa65bf2376fff56ec929b7b2cff90afd86028aba1c807fdc21a8a2ef5519ffea84f7fe3066b8cb49212b726c1aefab1eafb576badf463cb4ddb5b6bc79ae6f0dad12d6eb5f8c64fa0975ff4f945bf1dddf2c7be70bb61bdf38b4166a928bd1d382028b9e8fdfd2bedea9d8d4de6784dc5309a2465e87d28f6a5d0a04c815d724a4c0576c95700dfc8df648f14748c6cc8615c39a473c2958e01704de45100dfe4e01d156e5060f0a5c32ef9f3637c92d1afaf7d3603a25f310cab7269cae0d421a961c69578d4f9e062d1d6f9d8ae4f28ba3f82f5892311b5eb9e4f1fa134189f28b1db0c341c894e78a76ff7f18412b2dda35efb6c72bc63bbbc46c0adce7e339c86387d7dfab1566befe9749ac15f40521f0ca8cf4883324a2cf758f730af7ad99dbeb3dffd0cfe02bdd57d4d755b87717d7aa95e4e24e097eaebbe1b724e9f0eb77b1450b7bae77ff18274ab63c1ef0a7cd371dc6f282f88f5f8caedfef49da058ec27e8af15b8d53d19b7ebba0f756ef7ec5de7eabea79fd8fef89143eef6e985ffe40569b0fb976e736ee66562663e2b1353ebdfeebbfb5902d3bdeafbf156f7b103d260f72727acfcd87d4c2452fda97b98d3cbab4e1f0bc54259d4dbd3a34ef6843afdca5bdd9f76b0a7eec3d5ed7e86ced1713becbbeed9a6fb8ac4a2d9a726b82d08cb0daa61c615ad8b51b4eb9f7591c84776fd6b17857cd4eb12099273b7813962a3bf69596c162bef64cca33d6fd66b40b7e847af278506290fbb280a7c43a906d84561f016cd00dfd06ae90b7449763d2aa5f4638c315a22fea2f1894486b0f6535f14fa58402fac98b7cf3e2f1fe423559f7ad5c7024ad1c09280ea6154413ed9cbcbfc4b4d7d2f1f7b2b4e919bac1cc795b7e8c378ff42e7d00869907e7b400d6adf4f8354c6041de01d19ec0698c79f3e911778277bfa30748ea66d377adacb08d9909788f00eeae96780794e4f5f039cd33dfd0e700ef7f48b70cef6f441c02f1d6fd19fd1e1ccaefa272ff24dfdce7306eb731e65b0fee66d0cd6d7f1178a932e7df6fada47fbeb117dbff42fdfd0fae9b08bfe098adddc7ba1418abaf523c22e4a9ffd6fb59f7ad587e32dfa2f40f653f56365f5b38f95696fa495b4ac6a35ab0f7a8bfe69079b42e760b9d90734a5c1faf1eb740e4d143af97067add507ea9e7cb0b171b0f10ec7925f5cb71ca65b1e39de9827e31b7faec1d6b2d8adb9ca2ed724d75ff4954817684a833cc5c636dd200873a3f6608b5f37cb7ad8254176a11a1004e3c0cee96f4757ae87777a08107f116100ef58805d3c14e01bf9d2524ecb62b51b72d6f9f00360b1f236734efdf60360b1f5fde7e9bbed39a0d367bb49e9c7a2d91bd9329a51a6239dd3577e922c56de21424e4416fb285bf7eb9efbd67efbee7b0e48fbad3f963b7d23ade44ddb9b8f72ecc43a23421ab1c929de6ae951640fb51091d785c9859c49cb1253176ff563515af2566b51aa4a995151d2512735166ff5917614c588e3a4d745de92d2eb28a827442dd44344714888a94b149ae1486bf196901f18881c252d49e9e9e000e9a95bcc13194e7a9168860501f601bde5ffdef228e4adf68e784b7a44bc253d21de92de4f0d273d203838e9f5e4e0a4a7a383931e8eb72427bdff38e9adbc253d6bc349af7a4b7a2c80959dc14a8f0501f6a9de72d90918f216c8498f05243f18bcd51fe4b371ebb4590103e946302e237df1837cc55c19666e7c18dee98f30ec8a32d4db57cb627d75e58d4fead7803d7d09843dfd3e1616560d45379c6fa495e6d785d2f53fed6081a68438389d1373c4079106fd67f7d3e0ec6910c7877f83cd4bb6f0c6652d872318bff0bbf1f9dbbfb0ef3718afea200aa101668c31c6c8aef81e5bf16f7c8c4a4a428ef4e0064764ecd84c8012853ef56cda61981c815235246717135309619c77c5894f66b0f20810b656cac4c474e4c81115143664a623a4e61df9354b42a6c1e460436682b2bd98c15c8cf47041709d92ee74c56e27948a092818daaa6cb02133f15175e94920423a8bd44b1362528aeb1893224f04d231e945b506962337f222214474705216757a51ca89b261d5ae62d738fdc2f9be756c5ec13d874d32738c07f0c2c2740eb78a1dc6b0c63f295629b4610392152cb0e189248c80c40dabd665a4329eb8a7cb483cc8610d185bd1e83064b208c21658ace08c2cbef0342a30450926306083871900c194c4134af8b0050d2c43284388223ce1c5510f16a5140013765eb69203130428b2f5b2951c90a04866108159c961e86e97ad3461a3d7702d6104932266a0841437306a1fb41449741835a805549a8cb6a8428910d478c2a70a2a866842858c13302142900c94a0820aa32fcc6062061a407409c3084e4c21c4141d7079820344d0c0062e6010c590920fc188043734f1448726286109679cc14df082cb900cb890b16404dfe25a18074c8c8104222ba46c9101ced72c965042b542c4e4486594016385480757bb6c85080b256af31bb513467d74e5092b188a201714c1a8054760b1c610429e250442f0392aa3890a9a60804614a38612436432a4022f24242424b4c589932daf4587036891afc396e82de4d19b9c6c1c5fd873830d13bfc8c3374c126f94427fbb51250ebd0f76e304966f84e996cb1b3e08aff2eb7e649c445edf912de994dd4a3d61e3cf2fda25fcf894131b8db055ece5639827035d210addfeab55e6d56fbb014e56b5c7b4ac22f19034d03863256cf62b599379d4c3784828babbbdddbbbbe79c18f6cec4564694324eb0c619647421c50bc808828c1b968ca0ba8cb434c6cc65a4a5a4251a2c4959ea610c36c640c21867c85c461ae34ad218518cf182315430c6500e4968a265088b09c4c8811855c49881182e10e30731726023e632d20fb460f9c11596062eb8302c38228816fc608805b76b821117264b142c2bc0a2888b824205b7a302e5724610714f3f5c19228b10f7e53252184a9edc4e8d2b29c88282ab9d11c44d8101c44565f1c3f51b5cf1214b0f17ab82e8a68a78b8f40527b8d5881d6e0784934b2f23f960071dae652387db3135b95996a1bb8561828bf10087bbe180c99d575c5992e5869b4971c5862c4aee160329743b175c69cad2c69546b071ab1057d6c8d2846b2f23f5a0c915266459c2dddab8d2258b126e97c695247041421635ee16c6e730c3fa11ae5f4602030c30ae706a051ea51777f2004540480bbe04549f521a238db45aa01f20ef6d9a4cc005e6f1e71d5a7fae1a9c5f6570b0212bfdb4108109580003fcd2a94a3ab5cef97702fdb06b2ae18029ac341f5c71346b28c5408ad534987d2c1ae96fb4522c64d51f33d6844666c4e6a45fa433624f2316e7b4737e2c6c3ef6b1300c9b139bd954025cd5ac583435362be660cc38b2e2332a3a02408d0d8b66b5a259ad6c914dcdaf56384c4c61f31d0489c5528079f855bf21f4931f0e24f586b4101d6cb8ba14c0b1d915c22effd313db92597eac39b1297f4a39a5bf5c213e46619198babbab7588191860977c29dc775ab86f488331604f7f089117302f89bd1660579d31e98b47f128c3c17182e3afa885192bf94f6ad147b153e2508348d90c6c4c3aba72a59d81893c1790e11d0cb08b89020cde0879626bad4cb1c8a4e9c0daa0209ffea98951b3ac9ed0f276340fb0f22bc3aa579dc60acb3ef533d495f5ce2484628c1c86b591235e926e1561977c0ff08d740ebc61977c29db73de06ee68d088c300faeb87d6c73a1fddfd61970c13ab02bf56de927f02efcc977fc32f06230ff6f209b023f2642fbf00bc739379ae1df6d26f1579b0afc53749270800c3b00108615c6a0a51877fe8b44efc8142ff40c17da0905d9f73fa9c523be9d0d9d9c8ee0737d8fdf8f958f7c39b92310c8b18d6da09094a763f5cca1fddfdf0ee47164baf96c56675326d6cc3c1649bc7d91b564d567bad734194514a83505c4249c02ef923881995523fab948619581d1d22f3669d8feee228b294526efab1d7e3587772c262f3d3316fd8d42b6a566b96d55a9bb677cd6ad0715cd771b33d1edbaf6aa66d9f0e8ef6e9e0b827b3a4db9e28875d591b1362dbb8b94d8fe0abc5add9fecdbf524952cfa32e62b14b3e0ddf14619eac12bb5babf5c3191b1c21754bbe94ec352fab300d629c7bf18838c58b4b744b7e0b8cc06a8c825df2e3137ce351a278378c464652fb19fcc57df1894fbe51f7b410e9c355dcd0fa0d1e6558aee2b27bad350bc08d4bd5ca0b53f10bfb6cb8cda673e263fcc2dea625a57c7e9e99e117b317bf5bf2d3b055e9a773429d2b5f2fa49342e7c897cf2e798212df0ba5d58a5d2ef4db2b1f8877fcca1701bf70b8255fca9608e057c8d3b15f401d060dbf70bcc53b4da441f92f6ec97fe1c89ffad4bb55e7006159527ab9e1eaa66eb7425fec5babdd0a7db5f7a858edb3a206811a940f34a48508b04bbe8f1f2a4a1e15cb376a58b20d468679b19734d2ce86108d146157e5f100dfd49ae5f0e82e07a7c1fa59e61969100625360ee1a0842c8f06eb6799bcfd5e03d8557f93c9c1cae01749bdfda83fbd4f57bff690c2699dd6f568b2213788a37b97a74e2bc2afd3179d74ab7efd803882f635e1d6df28277383fd10e7662feeebc7a1531c7a20feb2df0a25843d7ddfea22a95d8f9f25a8afbb38d460fd9313566bc2adfa462c0961939e685eb5ded250d93357351dd8556313bea99cb7e4861208f970acec51570af771675f1c8252638dde12ee71781feea3a269bf753d32da0509ba5aac7555ad91f9b1b28f393ef9e2a2938e43cd796c0486ce89482292be8dfad3671f89bacf501fe8adfaa78cfb2efb581a4bd37ed3b22dd3b2f756cdbefa30b06ecdadb1e885093892b20f549f94b08dc958794cff64171bdb586b51d7b24beee8168f6ea598a7a5e29d137ce686f64acb3b280cfb0dbba134bf08f65549c106a5ddd1a0b49db303a6b31b3b20a306ab538e51c29678c7256c138505ddd3a3b03f7d2c20fb27d59f9e7dec07f954d4a7b0477d2c20d4a73ef5d150c30bea837ca27d98b7dfc37c8ca1de3eca4e89ac18a3576f4d4c27059dce99f1e8d3c6e8a96e276f47b7e6470f64d7041d4ba1c1d9e3adf9123b256193db61d32d8f6fe6a901dd9acf7f9a73887d0cf08e0cf602cce33f5fc810dea13fbb1e18a555767d213abcd3fd7c149887fbf93cac02338073b297101d1b73dee63983d86b1e6510fbccdb18c45e88bf5013fbfeaa576de67c9fdf29609f0ebba6ce9d18b6f2d6c4308c6215a3d869074b3f7c1bfa014d9961a60e8abc314ab13232d94894813b40558a6f60bac6dadbcf2cff7eb4f6406fe1780b356def4aaded1c2d126141bc96659a963d517dd243dc72a795ba67350832ab35cbaa740fc889069f68f5b34dab9fd1da5d295b966173238e1b639aa6a27ca06e7fab2817a7ad88b26939750bbaa7362ccca79efd25e3431f27a394f60edaa53c3ab90da6e63198ba55ced2e7b1e3045a6586629847867a67784786d5b5abae5d8f0dcbbebb8a79dbad35dda230dd52a5f8867efd2cbbe8cbd86035201de407e41dfbf45bcc7302e7dc20e0456774548b3a751c10c60246ad2bede8f73418843a901d0e82dd0ad86b0ff3aa1798afaa52ffb2bd9156da364e92b9f483d0d73c5ee2a688b2aac926d53e97a27dd65e0c49e4bffc9e35bc722fa2b6a8546d58743de910d100000020004315000020100c884302a1503420c8b2de1b14000e7398486654170aa491280762140541c6186000200018628c31c814155501adb64ad121e68267de05dc66414b0192b2c99904d78b62811c63441cefdd086fa45d23c4ea2dfddcce1af0e3e2b9ddea3d2e65bba93f07f1c59389cdc74e88304acf3892d9bd7ed743c5fea13601808dedfdb5ee3a724f371604e9c3c41cdd767795a0debb90827bb90a030e1cc1dfd6227666abe0f2476168b85d92c8105e546b2f625141bc561002aaaf419ad79bce52906ea36db067f465719d7696e225044a49a1944f2cdfe99b65d335ff143e31df13fd157505f6c8d55161dfe7a963941dcf6f1784367056b8ac3af7f5e79d56a67d2f31b99adab1b456bcbb4c903d55af6a1b08d975cc1839f970c4cb19b8540775c70c497c8614df17d3c1c6d92d3c4d6a393e768969844f72dd9378672fe1767d6bacf8ad3187b109d62936792a4714f90f447c46d1e2d714ab200cd582025ecea6c41c44b72991bca4827d5eec13d91c86d14333279be7f2495e5cfe611bd1395a911d89829d4138382b157cd759061644b49a4e62f79a67d563ed009d4439372611ab04b89027da8ae8fc1ff9e26894452a0dbbe52e816fa154a9015b680808e3231f1967445fa0b6cade0e21f5af7a2a63c6f04da34723774ec0661b00eae40fa42b09e00adc0c738033ff5aa9da41b66d1628c3473c368cb861967c284e6ed6536b5c83e56f0afa8ef4f7cddc1a78472bb7cafdc0cd1ea4be39889d426dfec678ad6e36fe4714fb0764e72713109a3682a42799ba8702b186ad25858f05f5a92721cae4265b49c34890713baeea52c19ed0afc09751e5e6ef9a776299d9a453d27c28b6d2355b92920b120a556c08a7573e95b04b50e1768a299818d10d1b0c6c9094a98d6413960a1f7d66434bbaebd38f3365d2a4e280a540453a1f4223920964ead75e64f80f9c31489363b51bec9705cc492215a5821e42ff28aa40794a95ec20868a655ee4de7e1ef6aa196f3308396955d43125fe9c24ee23ccea8dc5fb48a9b02aa67ae73fc284c2609569dd126f259e793a6f130c229054df76fe23a5da284618ad2a2dff2317080f55553d41afaeaa8f31e88530de31d809fa84afaa4060733b7d1bbf0812ed7d9a4f721a0b43615996bf1a0bcc6c2c9be85ea43187100ad1db7a5cd23cf6d3b7237ea15d8920f8b6e0e4e44545daeab9aaa6a6ed7c4376879ae63d2a103dd7c5635ee02e00a1ba53d33c3261721a8cbb66166c7dabed3e7250b2a2a6ef6d24b56610f6ce4092ec34e08ea0665aa101b9c74981c65fd001986baac1f9dbe5571fee8f6c82a53d14e384038a60c7307d62d8b99de4e9fd119b6f92533eb4f10b70844a04b294dccdb7e86271bc4248c5c9bdc46104c2ad0a53bc49089f8ed65274b951adbe23bca97a17d3c55b2a3bfe96cea8ff886e2bdee6f48d59ac02cb337148f8447e94a314117c400081ef43b57446fd8ef046e1073101741cf7fbaa0f1a426cf4d4f6d3ce32478e9123d9a85d65b97488fb2b10ff4fb208463a19fef524dc6d95a7f517e1247a350b3c63ca17cc9225685af1777215bb009538521557088e156155fde15749a2fb1fda51ca913828e380c705dd90b1e1dfc973a3131b1fb72a9273e09dd2385222a2e495d4d3a53572a27eaa1238cd2ff51cac5ffcc2c02dee07d88becb4ad30ba7c4c04939deefa2503d75407a767ec217e38393a0d2ecf49581f5c84d31163c62fd866c581093f60b2fae4815d615ccc74ee1cab7492e25400f5556ac244f267636c9c4c5a21172f42a8d6d8eec256c4133059d5c53e682798c6086212a1c7d55774db521a0de1cbf3f0492386efe7d1829b3be6d50b1989f68af2264c77d78fb6a38d6a9c27006900141c17f7879b60a74e64ee56fdce02cd8d5c25722d2792c9aa1029170c2cc372bced2357f48696905c5b53955c7a659029067ae3531fc7d7743cfc82d23c48c4f99892ea7d184ebd733a70c2ddc33752b2931059f67e41a0075b4a3d17bd2ff0d11279a121c0060dfc30b1a449f612e33d5811f7c63a03f81b633dad03f9c8c43144ba623cf0f60698c9ffc860781e4b6f04f7cdb33ef6831aa06f4f6824798609e339957358a4ed42f6d777928c205fa88959fe9dec7f8532db336203713f4f21d6f6122f9eb016717b46bb9d8860ae03f2d212f52006a300f31944876959f48a5ee16d91baab620d705407c31ceb3a6b42f00c255d2f3e828625d3895b49675f695e8b66fb98b5d05afd4ad7ffb9888231160f42447bf7eff30819e938f6a52fb9c04363bf97f4c5414a13b208bacdc17ead0456093b7fb2369a244f849654e9cfc340c471993d1e3ab3f4915eb311a22d0cece2fa919be8a2597a4427954bb9076a0ae69b0469c6f4ba1c2e318db7fe076d243429592c90a360e2dc889d999d7816b9a63b122e48508aa84dddbc4d8426aeeca2bee81e187d8e2ec0b9b82e9a2c9180968426a6bfdc06cee6d17abac1dde03a9d6af0e0874d72e753e993263b2599500d08d944ab5564051a10a0e536a7a935297c985d2d09317920b5ea574b1c6c8bec7e6d7fdb98a68581de0e38630036c1409bae8df108a9707885b5cf0841d69cd09abf9996b5e475633d494e1796c700dcbd74d64ce9220c66c32b3318a4b1d38094d572a390f65320c24d4888c4645a8f34dc7b6a50fee352779e8d90e9d5cdac20e0515835cb03a819cd61724debd0383ec328abe6512ca6ca1d684b5b019cce4d17ce46e18a5a67051498bf3c42745579427c8cbd19fca8535393bf3c0c30d98f04bb8a1c99dc07da1bd04d135b11285200767ed4373f87768a660c91e51fdb1a3351b43537b613c1fb9897b4daf87bf6fa10f414709dd2eb20176c1b52428f071c987b563edd726f7db9bee413acee6ab92da64de4e204dcc74dee9719701c95c6e4a7dcfd5af771184a209a9e80673226882b136a71e609ded70c7293ad46c8ff9c02da7c12cb3a4bc537060ac28867731a823c30cb62de804a186026e937c80e8d8880ba0be97ba24805564deccf2c3189b4708e543a4c873322aff11800904e9f33992cb4e7d1ab04dd12cd9fdbedcad5d25ba2a1880fd567ea77c9c6fb1f2bd2f8e183f6e3661f61095d5e898811624806b71b7404e5dc74b1721e353576697b85e24374b78019f0682b25c779f32b527ad3ab93c88f129b3e91629438eb288db08a33af8d489679378eec838c52b407733003a8d84b998d7aefb39b1c8ff18a370f083f6387460aa09c7450bc0f9ccffad59784491efb640622727de772c5c53b83bfeee59482dfd0fe0fbd8df278a45fe95bbd3494825c2edcab25571d2ff195b756811c65ebd0ee80dd600de274489d0478a5be74fd39a8710e7f8883209e926300270effe1fec05672780d41612633cb6420debb15c6145af01e1cf8c6086f233dff5925dc97cd2a89d2737e74b0da8c0486db67243089c587de1bee42ec1977d1d457f9b75e6d988f6918108c7903495e191c21938a52ca0c9a9206bc47c4eba798be72f9126bea561470f21dcf76cae091812455de57f9ae30636ed4780e78c80b3a0b51ac20e4ff375b4ccc4461e33a8f9757b5442becc0ae8e6b5b44f0baa99036063b7a01449fc12f37561d1b4abffaf89c7c334fdb47ec4c8583da031303907e0c0ebf2822dd5a76606d278a1290fb30e62c38198f6223336d8d446d4a84f0bbd96ea93fc0d692e291744ef4a5abe72ecf1c701ae35ea15f7ce98282df4617edc6792a00342b698b3cdc68cc68811bb8c9834dbe9e0e80d0cd163845b9deb2f766c63b035027ca22d3f1f1dcfadadb8f41baf53035988f851911e8388cdf2e14ecd1836bc77cb2d42ec19e2fb8b618f8c753a78ba803d726d770eaed0d2abec200ae69c04841c15acf60477b213035f72181ab0df77b1950886d7508753c4fdb715f84de16f81a75e871e4c8eef68aa3afcbca306f854f66fea2058670914c556f22e4a605436e3c7711a6f46d5689f0857025c46f40d7dcb1690d86eb0ed6ef3fbe5e0f2e675455277bfe33b09faea9cdbd144a8ecc79184ae29cf48108699f0b4546079e4ae536a8ba24518ebd7590fff3d5acab0ee3fd99e4785c854bbc5fe7da3f5e51385d2e4cc359dc6c2b5c6007cfbf530e4f6badedda96bac0a8dc5e65acc9060fcd1e884af99d102840b2889fc592780161a9fc48c9ec92d1135bebaeab1e128bb0e2f5a2754031f01f99813b925df2c51916e2e5916f54534ad849b34878346003e9e8ccf0862e789ad4622e0f787d25ddaa0d32b567dccc81cebf28d4d01ceb64e80ff753e06a17c926f695e315c8eeb067b0aac0b1c17e279a274126463c1405028fd83ae65490e83d07acb41b2bba5c77791d0e30cac1fce9593115b6c3ab017f630febcbdeb4ab1c8f6d07a11303b00a2588377ca35d5e3249d05b7df5b3a7f4e9480bca93a37c5f3fedb1c13033cc30977e65451a3fe467460782ea48f33c064d1c205bea5ffa8c8062a29a2e099410c688dfa9a8bc4f5a2351bf3bef231a131067799eb8701bc28dc269b4d1ed39974520347759ec502f5f64da015297d3d44a061e3980b1382529b252f07a8a5250cea15aa665fb39567afdb3d572caf7f4dcaf12c9544ae24cfd6e58c1665ac9e7e1c2ad8d443dbc5bb11c29cccaeee8ac42ead27cad770c705b238b0194f77d1224f4ff98a3f5be76679f43e25fa36fac564ba76f7031e90c2e784569c8108926ff075cb8cf2724ae60015922a80725d5ca5e1643a09baad146efb7067e9775a7280d3018a3669f97a2df154d33d91e2ff7915a4a843e9101efc20aaa1a6aea475f8218eb02e890ad1c1cb35d3128ec83d9fc7bd90fe5a986c6357f2f5c8ca05a42dbfa326ab7abd56140040ee4b61880aeb680b262f26d892d77bb8201cb17fd3ea5f8856001f3fbc730d37871d2ce69bb586c81023668967136e0855989f92d9fe7e00fc4115af2a153ff6fc50dda5ef69cb5ca4449242229cdd65bea42e6b98b1fe19b5fd97e2cca219806b17e256a29dd21abf2c5a85aceca816ff5a0c047b9a61ac37eafb0745fed28bddf11e121364a1cb3bbbc25dbde661380e0e1b560fe8ac69bab1dfe152fd34065008520c9b786783b260a71f5cc0c2e2ea9181258ac2ed1a304f87482e43e6bbe10be1f62f503d9bbd6555b413880ac444e5950c55824043303e24b9a14e88e01f039367aa38829dc22721d41e9087c55132be348e63d79760ed90aea7594db9092374ff8bdffc17dfe3f900f918b50be49a3baeca61c67aa5ee82a44e4a4b03eaa10d417c9352f79377dc556e52fdab60fb7b7f6633243665d9cbc2a5241b08105b2cb54003d221bae9b613dc03494c0766d500442ded0e59de875a6c587ee0a74f2aa900d62133981d7054a017527e1f0f2a06c24b0d09d98d9974d8d5509d26f0d3c5afae09ac6de5252536db18b420ccc31649a76401ba124e338af97d71bed34ac4c443d3a945ce163c4a5626061cdccea9b9bc5257d612abdf0c8eee23157458c013cb859286cad6913651d62ac3d81248287f84b32b7467f315b964d1334658a30c4f14179e5026ec2c30e555529436899953c9042b8a196a30443e8928434c31bb0efa6f29c2f8be7108532c9c2b2b46c512afe309045c5c359a7787ef4fdc5a47e10f4a8b7cb995cef769a4287ea4bcc0cbf885d16451964d9a120287346f660b332662cc7b009228c2e8ea9f60038f4fe8609930924b6b08bd84ec56ef9cfc564d605c0cc00e265e7cfe14cae009cb6834f16d93eccdeacdac6e7badadff84e6c80581f20f8e006e0920d64bed46d7fae47a365d89ad71888580282957c19cc55afc347edefecd2522ea26e9562f84e8a0efec7f898c7f05b82743f8330556be75c0a83a32f0a3606e18b3ff9f21b94ee15ae92f9909564b4a664fa72d8ae413223ee34f5d5b3235e659f265839a27af614ffa38a62d4b7908e526cd4e302122709f68f32f74c44a55ba2c2801b66cb199a2515823dcc7436d4ffd033d5e1fa0cf433b2288df9a147dc9467920a29652fcdb29c7d717dc576943ea90ae9b5a393d6b8586d1fc1477b670ff67fd09b5be4022b7abac859474bd8f8f3d572cabb9051ca547247b43489d339d63655bc6d135e4da61ebabc149f9e78da150e02c0babf5038f0984c13ac07120f20ee09c6ddd03f0793a6e622558c994e7350bb00e8c2b5289e6e87320ffcfb3a3651291984486dca9ec8c2026bfbcb4d17507c28e255828ff01373c36d96c97cedecc0f218558981e52cc73e11745d12c98d7911f1c725cce10339321080c68a01c3e2e169e025ac61e52c0dd4e40ed7c9ebe735ef9c229d8ea7602e75bb6746c2147b735a8f6dab5a5cce634f36a737250853531be9023fd4d6412b2ea58c16d055735928677d97ef181c51d170a405c87bdbd0303e102542a9d9cc2bcf71b7ad1510d99a6e46652c3b8814a911bd16ed4a7d54e68bf20e3139ada9727a4e9a9c38266f73f25e37616b53baa7d3700fa4b8be61852ea87ac2866267e524a5f6ee3bb7850cf10c827bafc0e323f1eb2172333df3fac7db189cf11534610db4d6878f9488975c1f807ca7f89490b55688ee625de50dd8f723baa37d137d2cb7308955aef02a312aab1c241566c843bf93971b4a0c204b0368881ca0f66b5b9315e03b1c21b1b9099cc267dbae4c880810c1b6b327dcf250596c7ee5b245b8f5413cc7ec90a515690fb5ed3d481a4ae6f921227349940c5eab5055d3ee976c2df0f28f139d11f79e009ac4356c279cf2cea91f97cb5259350bf1d01e415490060ea217f56038b5eb9720beac1f0a1580333275cc8321a48f3f56cf51a4cde698c6ee246ea9720e33741ce4896eea7e1064be8e5f1af395463b9f5f6c897e46a50beffc65d9de65f9a2089e92ab7563fe32447a76dfdc327447f73c7768904d29ea15a8fb875b887ea37cd48faedccec84b239330201baba091952963db90c6b647284ff145022c78827f368bcfa805afcbd21dad9bb5038dd18a525d890d66dadc241f6f5f9db575cb72d7aadf9226ab13f21ebb5db2531b4ecd5c5128f533a23b6a0f316bcb43b1c1c9cc7f9942b4ca940591cb9e30593dba7c433808c4f8be55c8ae40d9d65665e5e62aad402a16067347e61199a6ea79cc66469f814d222d5ff2bb7c9b8c57abe74cfc6b28ec2ff16e5f25f651950b8030be98a3471a2526937a7861824678cf2ce12598826f90418662e0bc08f16b98634d494152d84ac034164541dbe4fb9cadbe4fee6b7cc78068379dc47ea9c254c405103b6043ec3fead90926710f3308ff84f1136f67c325046fb54929860fef5f78814810def2b736ecf4905408dfa1edd3b5de549bf3f1a4386ed588914572373e39f97624c928c7d70ce2163b877e832e42e37d95662462f1a151f92456c6b1376575d94a073e27e88926e56164c9e080932201e22870aec4f0c82d17db623ebae21e5737c31a6b9d2e8f7100f88439071749e7fe15ae9019e9ae42a0f1fde6566a86c70c401fa9ff88bc6c56ce0d1291dd59ca6af157694989109ab1135f55a0bf4a48848a84f530fd807566601257b5c69e65a6a604c1629fd592047719a9ad3a62a03329ed2cc44008eded2255f5788fe8b5aaee082198d2b9a1adeabb68c2653b8f97e223ff0504209cfcc68b282f391956f3119447462097f8f0ba3f829baa8a2e753b3998e04b19eb69768d834492eb6ab304eebc55f81fbbcb106dc30f6c73a519118cc5c727402f623799cddace960f82405c571733987fd652151a3e2dc672a6c82c8cf00fb5b90d120ea5bc07bf90052ded24bc664dc2ab48b011b8342029f269b27c25ad618cacd1bedbb6b08d15389380628fcca383855077c9f05240b84a5fe97bb1953970691b0e8d2390119a1fb73ea4e2a7ee2fc69a47de3be80ed10cd7bfdbdb14595a4812c1b73cb5d5a5ba1c22541ff01ddcc21637b4c16039b5ded8fc5898f0fb2a61f8d2f8d4e7997da2c1a87d294411c4841c895063d1b18d2bc9b0dc7622c8eb38e4b6eaf2ef320c2212517cb0355b225730078d29efd51fa19501929e8404d46243906e2e2130820ee00bd1d849608dbca4c3a9e8af6c44e94aa48cf5654545e9ad7dec1694481feb72680fdbdbf95c7b5ada979c17bafb3627669d6b9fd619aabf60454228a10a99049276403b5ef266d8eb8c6d72d4ec508fa46480706267d42db00390a997cb11ce81dbfc0f933c6269fce244e40d07b56c8f0044ec12f8a0b04f841f5bd44e0d78ca9ee0f15fbfe1f46c4afc03960b83c37d2f39cb0d72e32b1f8f4bf484e0860a68f0d8b3c41ddf909ac4d5b3d7c4efc8b43203dcf66091b18d51d5571c1cc96ad2d143b0af68bfab3e5d4ee37684807983a730fc53308f6defe48bb53c323e088b6577647305e24fef966301e90a8069f6baaa0b8f8dfc62ca6e549205fa498f73f5a072a63fb44b9a65c2c9671d4e2449d69e6152e8a55413f93f1d45fbe3807240fa2aeb6f1dd3b012952a8cdea136be7f017723423763dd2e089475f1cc07836e2257cfe8d6d87ecb14bd347803ad37dc04bd4b2373e530869e3987d28e0b90da2b6e8d11e6cd13e2624a0435dc5918eed3963801269036d9865a6fcf642e7879d00c41e3acd8c1eb2aec691f6f09175953d90e4ea56c95e12cf98f2223f98da000b884322cb57388bde3d7d37f2fbdb1546cc2a629a8fb19cba1c6e8096f901986ef2c866c542a7d55a36a6bc989714cebf4e431d9d4e22ff30446d7fbc0309b5031b1c02f9d325d223f547373c4ca349e14e85d4a1b3088d1c495b2f512eb8cd15c2b4ea598736625782d600b2ae7656bd9342e3daa030e11f6b920538960f0433605e6d4c429c58e5b5ed7bfb49d1eeeb626c5adb2a3bd190add64b6f9dc3ae55e2967fb870b36e23b7c15a9ef35868843a7040a0d0fe2c8c274b532400074cd3e7589ca6efe4e1090bb5e41edef21799337a627531afbcdf552abeac42877bbb8dc9d4676f5168d0bfaad782f8cfd708ac2ead7ad138cb686279f1fdf58c2adee4230e4922ff48ab7bc062f5c6918f6a5c6de614613e9845d2f0077fa24f9d1216161a06adcaff4a07ec9fe0bf3a2c5fedf35b591b95d4d828f73c0e7f59cb747b99dd3433e5e7ae32e0ade2052abe4e2f48e1b05c76d2499cfcef01427b00d67698b8c733dc2d75cd9d3409a95111c306b748692c9fc74350d6799be551adaa09f1ad6dcda31f5e460f67e06d768e40982e7c212b64c78ce98542022fd9d591bd1baf2af3a3509b3535fe31ec1534b6aed8d163f98515298ab2701dc47f1f8e09304514bca92271f6bc8602f2344424b6b410bb69a5d25195bb6d069b038e72e7dffe79f1a0291759d5af51869fbba2e0cb6557f1cfae22d5c38aed8f33da45e3d6bcd4fcd23789dd5f9f932c35b64723ef8a8190638c965735fcb400bbad5954a73a8c234c889bb84260ab13d138fc0263bedbbc479fc2d424ead3a735ec5b0801198ddb80f317dfbe84185ef5f797d5d72b4f71128e641cab789ee105cfb0926a4e1a3f9baaf81ef7204ac1ab00b46fbc9842e6bdd997b8a37df849ed4f629028c36dab6c4a0e27780273135f619abf468d8ea3a25814a8018c095d7dfc0a0172efb7c644cbbb14db5f8333d0a7bbd70a52ad448f0384cd77a3f94c31ec258a0ce37115eeaa6b62fed5c8123453809a1c9fc806db38a1541d04aecbd593c6b1e741868764c5a2be5aa9cced303dc9beeb68e7fc96a24806f4d2f280266d6441fc0224b8013194bd13672fc08ace2cb7e9d8980e600b48298cd5a82536396eeb9763cedf26a5ed9196bd43d8256c3b3137ce8115dc16aac3b3da26bc2ab9bda444d3e8dca5723d26fe0cfff259dfce3ed4e52f89d622c00da53bec616d0ebab2a57679a4a8b308dbaa51107220787df9fc594871e687d0bb91b84a09f0f852e130c5298ceeab1d2296b741008acc500d2860ce0915269fd47af8f2426765090f88f0aa002935b708a26a24d69c34cd679875cf46442ae65fb0b6b7e0c85f7784c7bb4f5a60ab94e4a36b8ec67b913e3d663357bc76370accd64011443fa9075a9ca02e057292f0212b3ca46c4623f62b16dae1310cca836227de1f3f0ba40ebb4eb0a4ab6602343222920b151e9c4011810a15a07891df8552bf72e6f46af2dfd45d79c959d1c436dc6b9462fb146636125915027582c380ebf73ff2b8b15c4b21f5b99c20f88ddb81a26f132129d80aa81fc55bf1f29a6f0e4e5c65bf4a1d4a0fa451f7ef43b950a357809a10c1ed1501fb92e447ab44f63d4280ad6a45825d233d36c5c670900d0800ae3e0a84454517d6bc1f0b675e01689ffc156ec75ddfda8eb165d41ec411210803abe492e5762f10b9a44d2105d304dbab22281535e5ff570c6d6c398506803328abbc52fbf5767e510813d60c0bd1d8880f6a88b0fe38c8435d6314374378d2ea937b345e32dec1a0cfb0c64638ff8ec2e832bc99eadfc949ec1a97b43bb51da987e301e73ffda8b2ecfb60ff0470255263069a9afefd7c75e269c8d53f0dd46d6ccbb46069ba65888e6badaac8978a31f6724276962195df087fc6bc8469a4ae1790419e2309b486b830f7fe6c287e366db1c398976a79c60c23b7c94ed66e92f54bb61a1a0ebf6a041d011c6cab0994fd80df84d6118e080f072715ee03402bdc9398f078c494144629728edfbc61e26d6c7beea2568c0fccba7712839197799683e359db3710b91ed5f2cbc9e562fc4e1a2d9bf82e69c065b3b29ac139f03ad191fabdb544755e606c59807b6ce4ad4051decf223d840e4f63b7d0a1a32a79de8f01280c02a9217855d88b7bfdcb0f8416432b3539da890547adf85fc5cd367d9db1189e6c79a1bddb73b701b47c89d971c8749d7ddfc708959b6991af53cf421c9d88a5ff1a8c041cc7e94b926f561a859dd417c8d7ce169ccd495447322793499b97668088d899696344ad964cd94c471f80f97ea5642249afbae784d8003a07ee8f588253271f1eed3bd520722eb4fa2eea55059ea65e34572c60fa52489a4e31c029a0f034a1d449eb87d3284abd77858bf7910ea8d0cc0b7827a976b3908cda0a84d632c7ee4a5397c9856ee019f8f93fc0dbf3f374b2434789796b181d99859d3e78045f0898bbabeac292c9a545a931df70e40d3cc108ae2ea732bde581ec67f91cd860cf94218ed63941b1bbbdc4fd443a5b62dee7ebbf1f00a35d1737488a096ca649d118a1b4d3b9498adf1a3d0a72afaa62821639eb7643eccb5934e8354cde6328608204703abd6c8d5c2d26e460381bfacfdea6ca2abd188b4f1a98a5e8431f228e4e82658cb6f2909c49ae72832e8ebd09c1c2a0a588bf490349614ba270fdb94388ce49c8ccca1e2b500804140f54409267342c105bea3c6c787eead27322e8ca09703b7413cdcf6296ffb438c6ae1a6c4620cefe2dd0b16dd6d017ddce8457134e2f89d58c06608bbe299be9dd91f77c028813b6cd53f6debf885c5d45685a42d035744bf77cb128c4b0fb85749000dd0ca4671b26a9648fd3c8fbfafc1bfab8be9ebaee200227bc4810dd6aacd9fb6609ca331e54b5303b58838f39784477c80e04aeb1a1fd63e7fa6568a434d675854cfc190e922ff5583d0e4cf56d8a50700a5b1f67300b8f8fef2acf72005a950f12153f194cbaaea80d5385e9236b0fc53260aa582e69b4c3f9f5b0e6a47e28e780b556eb6774b1f75697f0c45228a60bd608a3285395b9f5c9770e8a5c11c8afbf79196a854a92a0f3e007ca8bf14964495ec65eebdfe97c592c509f57fab9624a345ee8168e76a430992fc7925a4275aac61493bf12f7ced7cd3a14aa7c8dc29266086ad7aa7ab69713dd9fa418fd0e5a43525fb1f68ee103df4f52a6d29277d51feeeea86fa830366bf0b8c6fa5571d881a7e82d4b7f487a654152f6d6029d504dcd60514232d84fc790a245899364d944207c8cfad8b9481c41508e11432bbb4052abc4912e8c4fa20d487d1964bec0be49224d60508e5afc2ac903e6389431276c6cf4656be7cd5b53049747e5bfa2b47d50cf5b4756c87dc9af30459dab09fa931fc9c6362339ad3c729ae13189ad538c8097f53267fa52eea1cd7e6b8dc4427c36849da699955b4abd18d3b10ec3623922d495487fd38e540871a69719a77935618f66795442194fede38075d3600e6df797f38ff491e753bd31af6c0f3cacea884c0b62d2e308534f9baa53cf4f3e5230a1dc6ab00acf66bdc6a44760ee75fee62a1767184c852534d5f02e11faca1429800d2da226c42b82e5fac89218067bee9365942ca8f9693285aaa98290a7ccd55451b4b16d0fc17a9f6376cacda42282939115732d20dfdb177005c20e7852a4b161d6e606ae2f88288556c41dd19c2656b546a0e1af15f5368f63290e3f7530684c80f0a0d5cca8c20d0c64a6723f8375283355aecd0230444f6f2a3a5b156c0707b2635d948ffe2859410fcb05738007aa0e41cd060ff20c26e70688999e52c7b1dba716ccce36dea3d70b3e32e43a5cf047de3b057cdc1870e24f15294408c659de16cbd937e9fd7e20de08df9f7b9efa7f44dd9472a8b6a1fb9a3ad6e63eb28fa6d7a82af61245a5d9cc21d594eb670bc70a733c7edf70a37de7d861b0943417285ad6b0f7c87899235a892bcf25a37fbc12012fe0d24d2c019271832ab12589d0d0de81914ef9d89d32619862bd7cbc405bd0881e34267976cb18c62d7f6fe6a72609ee8c08d197f801e1b472b1b870ca0515125e4bc0247be43bb959925b41055db1eaa204d6529dcb4368c5d004ccf7a58a350d93a81a91b4f866489865e0e490cef54ffbecafd5e6ed8d3bcacc32a2c7d08c9bc9f98ce0ebc6b93518c87e66046b0290723c5047bc773cd7751259e35ece5c880b04f85d4ce873736e648efe11bc1b823a07a0ff8c6cbf15387b4dfa0fd0cd4568450cf468d17d01dd01b417d705b3ceb5d86f4809e7e944382e532d99288ebe023480bdc17ba8673146075ff3031ec93ee9516c2a5800de32ec7604bd311ff959320b7dd88de83bc20d850d3425eda31286533a02cd628228c8e90348bf749ec40b5d1716c7e6d63e3a0be77621d86bc3b3a3d3ac1620065ef4e25130215a49ea8312c4681a2c548d8d9bd093366d3c923ceb86320b56ef84d29fb1691ea673a311a883e16bab6cbc5d5005e5311fff76d61b68bb4a32bddd3f9fba7c509e04fba8aee29d02ba40ffbd2c4266443877cba9dc18c1a6324baca6a6b54cc41b42d11647d8917a260fdb911d5872dab819f72ae6f3576c00e3169ba0b7a2dd06765bb67df0ada8a1eb412527444d27d3f13f384249ed547b85a70d8e6f00196d3e19b44dce1f5b152463de577952cb1238023a973ea392ed895683a8ff364ca5ac37c06fe436ec91c7e91363dc4b0fa194012ccf166557804f9c12774e1dcb6907d2f262a4b0dbacb21e3d984bb725b3e48298103c97ead4dc958e5925bef578d69df4cc37b97869977947d3f49ba071cacc65159dc11837e50daf12e5969b9a52ea613769a65137ab11bc0d15eccc7d7eb98c71173f5cd548f06eb0e8507ae04d7993b34407d389b0a046f24e192c012306b9ab5b4c9497985185430ba511aada683db869352a37e93948b2a7d75a2bc72588d54f13ec7b886a558258208e4005e7a0317a721a57fd6d2c4ac6bae4f1ecb93fd1dfd72debb8f7da4b986d26aa055d2d9e9a1b15c89c62097166f2cca5b3a133abcdd152d69d1f13ca0b4708c264c5d7a298aa5cce299e281ec9c95755b33a1c3d7a046d78c7eaa14df33458b642a6636cdfc0f925561f68c1cc7e868d2d31b1e5d318e419e28d73ec1a206cd694ce0cd4637956caeb778630bee52691252958def97a88f4c3aad9b29133b3502c73de0622b8cfd9e6539decdb3f356040796bd8c9de8ce0360969877b531636694a48b063b8f350a503e60104c598f2d42d2b6ffefed4f83e4086a7fa7690b095f867784e99130efc98a39f8cd322714603e072f41cc2b49570722375e631a8691cb32fac31c84d7a81b490326246e5f6ee53ff2cd0cc62ccee594191a781e3d5336d7e62414c70fdce8119c04507bc741436c56eed8131be3bf04142815e29f05287bf5d88dd0c1ff041428adf0500f7145225d5811a6a8be261118c32af7549e53f4b10727da65702dc41aef0918cbc8d75e20ce7e46c2fd7e7145e2efba17a3fd5e865964119a2785102c1a4fba30e0cb8ba128ef9c7a3c105fac94e51d1a8c47c90c093a298eec3b4afea3144832ea58b6392476b2121a8ffa50ca8d8bb0670db8b8bf39f59d71c67b6c1908f997201f05d1dd5320ef3fa889c07809a87005eacd497a6beb9e40754d45411cece865cba7ce6cab1d0f5c2bcc6dd14e7cc8d0fbcda8f446893948924e8e4ada01d87f81fe586edeab3fc61c06a3fe889ed179c01d18d5d18d2ca2ebf4de4266f1487235dcbec04c382e67b7b96ef263cbcd0f5b8f5eee165a5e307294f35ca0b6a470ecb238880379efcd3e57479b64b06c7436450b6dd38353709ed7addc9e61dca4a69349350ec90158c7056d52fdcf2165e2cd8ea06c8159dc20fb1aab5358f186f8496864aa2fb7f005b0e68e5ea7d58ad596be96ddb6ffa8d03e968b2c599ff49bff40ffe4a100dab2e0a9af88c8853470c0b0be4eb3e44d03decaf0c2b3e77f3586658099743074546596ddaa0f76fda9c4576f061cfcaba691d20d34551d89838c9f287169bdf7a4bf6bab4d845f295b1759ddf06cb72e0349af25df4e61f83407bf273295f84e712fdcfad67d4700ee6cfba8da7c724e0280c0e8b0bd5e9d94ea5ebe3e17a537ba9c0e50d67bb3fb4e4c16f50ea8b649a343cbe72b77dbd59ec588bf915790250202dd10f3b3f5a50972bfce46145a844fce93e7fc3a39bb8f5f264b404e0ce551ca7db9000ac3d471939e1d78d29affeb6fccac41e45d7d96559b1735cae8cf7c7e32787ac64f1ee0e073c0db24b015ab3b2a040c13fb4192420401a03bd87f85ab8ccbf80c0f825328c1db39c105b8d2c7ddbefa6b69cd34d5e75f828f543c76043dab30ea62387e6e257fb20e6dcc2e0c8590fd3bc6422653a582abae4dd1377c1cd6bf4a2fbf9833b99e91e1780bda61e32a47450ddf17b06d347aff92d1002e27f177b97751520827491b639036dbb483a0260741e109786e48b8c1938126b895de91ee94f073103aac2a3a58a092880cb739c1c63990bbb160442a3ea3c62822c92e1bbcf5ca26b114a958abc8eb6545beb3e93e13811d69f52c6a3098a336a024881eda852369d6f069c73edb6142c63e1d67607007b6d37ba494603064488c2daea01d2b542de8252cc39514caad8a98241538c42d959de569c1d2043992ca71ed59de90b91da4276a68a9517336254b041d202d4f04a74d3667d95d91e101d0cacdd3355fe86abbe8f112a05b31216225b114f63ebc9204d051d2d54657c80e661124a008d546542d2876804db8da86114099b19ad230811972a196bbc76e1bff4075832ac084ce91367c1114663bdd207c10dcd7173d7a546cb41df09517639272d6252f3816b5df0fca75b5c4f20c91f11d27b70b9d6685b97b46dea073b67f373cef11aee84a07dfcfa75c162efce3b33b576f50e490717440fc336493572651ed9e11b947e382ba64f94f246d31b51f82b02feaa8bc90c19b6e19edf9263c972dca1a4cce2958cc9eb47ac4e5b1d3955b8509952b50c7206e1c58b711a3b1b681f110d3e6d5afe66c8b57ec6d4bdb581cb1e2d6a07081b6d004bc7562e5ae4ebd8b034407c6818a6f6dccf49d99c77e7b2e19908c76bcf3ec12b3376af1385165842115ca7d4162644fc0db3354e80124b5c291206763fa8c50a3a19a0ff051e0d46afdc5e8ce608ab25032d760a1582320769b439a3f958fa294c79177a4f57c85992e6f3436e23cb9017e935732528fa7661829afa83372d51a7c63e1e946cf4c9e62260743436ea102941ae82cba04a9ea739b550998cc385506db268a9455c911e0a1099f755b167af95ca0b468a8913e7f6bd90809aa429c7d68c7104577883f1c22743ef09ec7395f5b533a8095be91b7c9ab6884769131081dfbf48ef8bbc4076e824f3ec51b460b1911a8cf3eb1dbf14b696738203d5ce2bba17f45fe1b4f14d02061486500a292c46becc7a688168df040c9ab1ee8fc6d4030c3e6f06e851cc54c881c14a82fea782b1315b22c7e3f0a1da2e5db0942dd642a7c7c9940b4f47485651d9a6fbc6cb86ed4f5f1d8d99ff922828c2ea50270ee3ea4c864cecdda00a894bdebdcce2c3901ed0dc601830aa276ea90198204146accfa749a74ac40d5b82a7b648d8c36d9abfa31146cdb284a60288bfcaababadf938f67b1bb223a1bfa81f0fbcbebd24daf4ba41751fdb6e4265c5a50b07ce69c4f2f3d96c35863d4445e188acf83e5cf76bc841596f86ae16f47e8f8cb1f57579c38b976e7a7386e8e6850cf778585e553a3945e61e54050923ad7eea7639ef52f26ce0d6766887c1f62202a1b850ca3c3b44a77cb04563b30ba57dbaf2e29ff450ebf5d60f83379c5af0e7e4ac01de828db26c4c2f5c11d7591706c756f2b6d1098b852de236e555494090d706fc11a3f4f9a2d115702c72bf211b3cbd8f052044e28f4f2f71c27711916715ad96cf035d1ed588efd2d17b20b02ced01a87272c05cfc99b9fdae190b3b92357cd5e4051d5b2bec459428e4cb0ede41e848a0a31aa809208bb531e032aa797e4824596da07f99972ff6d6c1b72c911655b01530221bb10c2b953e7a1c9bc808e751fafb34db23cb349ca12bb9f2833ab1ab5b1a51c2da99cf600917e6264060e10d2db35099904f932622ed48360ac334c7788c3528e668b152e9262d802cacf413df119443727ec3effea4468662fa6c6994d02159159f0220b73496906732ec3c4ca4c9bac873dc90c479ace8f52b71ccb7e549494666658251ccf8556c7adfcfdb9655ee704514a262c1076cd70929dce25c836573b069cc26986c3c855824339d761e4357d482f5640c956a733fe214b6c0357bc247fd8e9246eb9a256a20d5a10bf7b0deab4b241a92618c793f688a1f36b0c2160ea2b2d41f66678881af4dd91058ef52f662ad0a49d75da4073814c7c601c230ea59d524fb8f911e0a6546af7d6c7288c3da58aeac4e1abfb894811e212a2f9f541864d249c4332429e0c0667e463279474f277789105b5ba03273f0f319c7185205b18b4f073144a1ed081c9162ef18d71c652f74befe7313d130941952cf4312338f095163075c91785af6c8229f2c609c6909e6bbf117892f9794b67514f2c8254fdfa5786d5bf042b9922ce2ede45dfb6bcc6e440e2aeed12788c349eaadbd22cefc184c663b1b99ede3681cc52ae0d81cb51eaa92636f966ccca8c7177fb0a21faf331ec03e29eb4c3edcdd5bc2e7db0f29f2972668872cddeb0ddc7983c7f851cb6636bc52acf62d283689e1e66284e079ee6d3604f18f8125ff92b0dad007677a43ae102dc6c21b4cc31599e26d03c5b9ca1f1596a631cc2d92c13d014259da4ad2e027bdd2cf25b72dd0dab9e41995cef1085c2e8e1846f3154a4943ce33f92ba6d1a07ce238606c1c4d415fa78a046d7e0df504df6fd099d112f6c0c1f19b231d8c628f450668f1e31a7f2c61646b6c63c3fdc39cd49cd21853a22d40c66a6e5378e82de2ab0b477d1bf8d50f0081e4bf415caf82e04b895aa342b9e4c0cdec3ebefca5da545faa162628888333b7e32c0bdde0c1343f62ec2f9a2fc23a456eea48de8cb3a9a2a4085821f2c7f749c27d2144afc426878d64829245fc75edaefaa2dd0ffb94809272fcb776b2568c433069df6a5c64d440f06516539e2630cd50282cfbd9151695da13950349541d22b29fbf936778ca390a27727165319701ea0b8b8418f0b4184b4725cd3eedafeaea12984cca61a44b77dde4195dfc8a2b3a9ab1133bc251204e8e5a24da39f82f2c64ec3ba41a7e5ec7bf828440be64073bfd17448438419f0b6399282f2a2d4f335f9ed7d9f748b379c2faf344abcbd42e3a08c648a4205fdb037ea9dc48708675685c539e9c2b48b9dbd38ddb1d9033fc41311c35b9ade22a86dfb93415cada5646b6c67c3aa017ab5942c744be4a33edc089d7bc163c224b0452f3b7dd495a10eb1d480b7428d6dbdca88a504d368f6125ac15350d6440b60f3a0a10450858ca80f93b44da4c27a10973cd323ef86199932585250a6a3e3ab408c035814190e76cf93da062b5f087c8bfc22fb91edddf66ead5450e2ef9130068d78f485c86be9802553e8e34a70ad2545eca03885633881b85507c65bca2ab747b2992bd03624b6a5933bde7fab0482b16282171c76f6fd013b2c3daa3e7d5174bf8726d2c3f402cae5f240f5be729d8b024a95fb49ae6245f6f02dd49fa511b5de45ea6b4f0d8ff5d402193912b3f96999b4a7fcbed572147e0b02f1d3a78f1cfdd6300f93b9c4b18a64efc1b649cdc0cf873692ab249306c87e27d39c136c828b94163fbed501f392989ddd99c817503616ba9c453b3b8e4326516407572dece4e4c04dbcfe9bd76face522671f1318415ad5cd38fc7c1b1972199ab7e90fdd6bab8d63d3613af408f6acc76b054415c06050726e684ada91064409aa081d145761ec27d891df81e195b0e08e8640b68e126acc23247508b79e7e9cadc730a3f451abd483f01cb6e938758216c0f6b1d6e7b67d8a99acd8c1ef1dab92d2d14c977ecec03b872a74f7632a5e1e318749d923b9f8ddf0c0ecee5b9f0b1774b7b81e91b5fb1d59fcc13c0f16993cdb78a2457e657edd9541476670d447538be79fefe945f0fedfaf24b79b030ebb1a16536bd66b87b23a3f4d763b8291db1cdbe4ba366ccaeeb324d91b78a2f533bed512a63ce35b5b9320b643214a6f2c69c45535c7fd1a3bd0b3495a59e1ae8b2f85bf3a39f3efac8e3503fe01ace8c5fd565ff5cf207620c2a1899148d9ed0816bcdbb2ab8574fd54c84d97cd4442c0ee14e3dffa83e65df4b17607ef01dddcbcac52c88363913dcc2efa57b03a6637ec44a8c1e252214e728d915c0a7184b632a3e4f1a92b520c34488a45b57a27c2e98c991743e0fd8f916ca874364abaee5744c61f4024966ccc69482af7d817c4cdd00369285a7debf869fe646fd0903753b1440995a3bab952f91393f1401d6392fc643e213146ba6cc79940cdbdb35310d4d85382a2c1205e528bb24263e850170540fc1d071c4223b441f1eb8d783220681329d1c25b35480311bfad007d8e9b85425956c67b19e2bb4e62b0f6ec495595b37a96aa053d0b7dc54a2ae2223e1227e8fc3a16229e4f9a904103e2376898c56a6f7a032fb17cce48c298faaf103b433e7edb7f4222a671a47800d25d0fe2f39f7db4aa0119b7166a9cbcf1abe35869c52f801b803a759266018ae3c349ca05756310a64203f48905146a81f8a3d9cd0091a8fa7cf378525e350aef1ee3876289b166c10187b9126d8af1ce95b482fc95d47b29b11bf70efaebc56ae3378d2f9b3160907c76f80ed08d5ae32628efbe6f216cab582a0f693e8bbed4236c06aea5d886c3d4f7195033546dfc22d731aa95b038fdcedc79f827b4567e0de2d7f86c79e4fd0d491165bef6b031f83e2078847b52d21fa6fa6975f37cd0e50f3e25e893f704b6f06cba4e4846580f8e70590cc30660c596bd291935361fa23f00803277514e5f585709a71b88be0d5a2b051cc41a5135402416e307d5081959e85af76050b453227611f6d9ddd028dad8805a3c286405eb92f010a8654a7c03183c1bee9173a43bafc2b0cd34f7018360fbec1d0bd46f215fff365159de3047f461830b66b6527eea31baa317a4b27b24ab6013d434467cef156bd3416aea227b5386c11a18768f51f45ef9fb511cfb92dc127a24336c6045d3788951c6fb2c2ea14a73206b7c69d03a2991f563a9eec1fae7d42f793b61295862a7028bafee1b9d5546ff60d8350e56ba071b7bec964b30f4e0008ec1849bd088e1cb28b17366a110a6b39796408140386ffb8d4603830dd32cb4117f70da94ddce89ff8cc0fe4ae0b3355fb90b1c620fa6d85c3b8416e8cad051825ba064cf27979bed061b0132ada91b9f19259f83e5f419918b2f05695e690b64343c382988ebc69bffae31fa57d1b713111465030aacea73174d4f0873094cbc96817ef66cd4eb81c1eae442ebe8792b388a68062c039d16071cf244c4f191a07aeb5a30019c2c8d6d40facb5538438d0c749e5dbfe78487138767b40b47f499790075b8a5dff57c70bd67f03dc5f73a18871de36aecfd292bcb0a89b6c0e33ddbe35e6a541904c0b8eea67145f9cdb4fa0a79d7a0ce50d812bf579259679360cff1398fce1dc06c4599a00332959a472a319a46141cd07805c010c58555e054c56ea14b6087e11af74c0f6b99c82e26cf88199b95e03e0cfb2cbb193dd27233fff25e5bbfe64f9863c1118beb13239fdbe3500f77e4e02606e9c7d3191b6cfef270462df39dedf9430cd093d0f85ed3d0f22b457186870c036cdf239b5d177d05d79dd4a761af2ea46b3a50409e56da306422f4b0162347a7e79e9468c192c3ef773fe6412629dd9b6b0ebb48335deeaccf31a17bbc45df14f123bbb6deb3dbf854a3fb0037f6c88f7c3482bf8b4da1b802ff1b8322f64cf455f2d0b10f9ed120f1c93dac20d0838de107eb9bd1318a61f2dfd8936104efbac5f6ffb673562329227240b2ad50f65441ee15ec930dc74b087552f254753f9ecebe2d63bd77ce6ba9a6cababa926796bdfd5652976455dc1da7ad0ff873349ef3dd10a1a5e0b92b3a6014df06d80dfa692cc8407d163b5c0c9a8ace50d1bcf164636ba49b92b7d49931405be577114347cf1c4d85c2609126025ce2080783f01737879249de7aeaad6f33e091d54feb4c45d2830f88efa01fb32f0fcf67dc66ba98b2060acf504d0ea5df09eecc5a501ca7ec9901871d044145cceec8277a8728ea34483fc480f6cca223019c9c7261427a4b418e1d0ac40dfa170603193598cea1359b3291ce8085318a7cb67548aa1f1243db75719da8f17135064b984b9e5fa96ff056f638837e169bc103dc360a284c06d3e68e79a91ee5dc14ca97ba4242d3b7e09ce531fef4582ef2383131ff5803a36ba05e260984eab61be17d5607d49ce5f6db11c50e90df29def9b44e9e48227c5a6c8a1dd37b5cd59da7f40644fbfe795e5712064042e259063b3b834aa169f3cecdbc2c2fe16ed9d588942a664f6d17a9869f6532680f3b09fb420a875c225fff1fa2e26754b84fb4cc1ae54e4101457dce3d4b2c9177c78f5caba7b5498756bd6345b18f2d3b9a9a7e56289a368f4893b362ea98799b4a76a89cf3261cc1909ba5470d3e078872f1b7287a36c986d2113a29a50964d5c80bf87f3ca481cd6748a91c31e94e8ee8cfda615ab9249eff787bc615e014a11e75cae53f9f9573e8604bff5b880ef8499703463db5a71b093adf60981bfbfd00fbaa8c6690d0fc27b2aa75d58570bf3c1fd77912aba09dbff32274e73c575865d5bc73f9f1cdce8066f925ccd31049c777be01dad7452349408566f4c2810c13b95805792513d0236b4ba7e142e5c8c7dc26e0a628396c45861b614c5f8d627587adb6574d276e68b0f25bf0e7f10e439e80db2c8370813b4d2b4a03c6a5817767d5b328d1092ce45033748f570d0ca32b19d25fb6ac12c6f8b484a8e2ea509f4a11b7996c9e6d3abfe2f1d89ce3a2705f2a1adfeef2ec141f1f894bd5d5fb9b605bec011c4753b25c4f2d4c5d35cecd409ca6d290eaa52e416cb0d601918098a9a9dfea46cbe6e4ef61e67094b313f04448a5e0706d49ecccaf23d083dc8f4c8eaaffb8451746ce85851894960e7df687bd24babc959bb71084e93a0b575db7897628675b9139ab6a9c31bddd58c014a860a64103053ed333214a4e8f928459e521ba4bc1f1936e7e2c0ad3a4f35f5545288345ed1072a302aaa4bb422d041ae5518deaf10d869d939ae43d6bde03b25085483e13311288a27ab6e211079d9141ef89664ce6289cb2dc18097b444a5268fc230a81bbf4e01aedd925ce2d1e73a809f5c1bc6a33e91b28059632d1c7feac77df453a38b5357cdffa0d234d2a86ed0fc34d019e7ded9d87cd6dbd537b474d448af3cb74aa45ec1c6bd7c59a7078820f11e8bd9e8e8edeacb24372e4dde9451ae6649bf4abd605cd6730703437a2f36916deb13b8e8d183bb4d7c32da9720e9f1c23850663bda3d8c268471de84d892fbc28e8ee22e3369c196fbda6124cfab2c54e15440c4e27e4429bce9c4297287f8ebe939dea95324eeb981a14897bece61e35701393eb3ab659a3159ecb19e6d09dc0d2a630a58bdbbac1e0c536f2b6e604eea740054e425bf34f8895719a7be3a4117580571087f49088652af6450ec20fd209020693e31fe58b18eacda49b3b245dfb0ae0aeb0d1c0f036de53c8096582b813db096f3df7aa38da5803fe591c14166bee99118e227b2c81149322489a56a696ae3e550e23f88224c8db8ca0f048d246c9507ce33f901b859235a225e26bd0f35a74a6a7d85d95745ff6d45ea5aae51ba42f5fafea5d64f7201f905155e743d561cab3f0dc8d03398852b8e24a1e27558266a7a868de044c72d3d1d064775bc9de806a8eb7d2d735d70e37f34c33e4c1a08828f333130106f69c60f5648d4f4419bd6cccd57188417521dbd1ea4f0ae2257032749fe196667ffecbb3497ed10ad35873c44db037ff18123195fe916afebf28a5fb90d91c91c702b4c4f23e4e9fc6badbf1b678fe76ebc11333a6db4340e9da126dc84c2ca815ebeda2f7ecb7654df3d1958a7778ee2678bf64578ccb93cca228d770494f0d59ec89f1b2800756690429060430e77c0b88fd7c2214c559d44474b39fe269ae6fee2ef6a35d70b219cea7f04bcd11706e2cd1f56fa8ba8d399c0cce55b18a3e995882733ff0c63c5cf184f3a38a91a902b433dd3c2d3a0dc4c50e30d5f3f9bfd7f60519ffeea0ac96d4ab84c8b8f329161f4622656f01f7252006f24ca1f23d8ce243c4d070a30183f5e4f1779703a65a48da90553b6e410738c84db270eb129c82a62c26f812d9628a15f45a8427f6f0c14100e398c488633d2ac86151388697db61992fc4948da136040ecbc0eb76aa7aa07908b72cb2bcb719a54414c3755229bed338306bd4b5491fa29ee3a16525db5c1007033db451d5cf0da302052fbb766de86f3569af6e46ff0945858f9dd52f2a72b2966d7c54ca7131aeab8b67266b94d3871c513d52e3b532b00feac4bc93fc6399237d0ee6d69665b3af154bfa646a3a578b9f98f7d858893507adf1221b073f2e4c50b274ab280e1b26a169886e2bcd4893c15548f11c7cd830505306779061add04b1e5734bc67df84980acd74574cc205543f991f118d7284ccb4c4d9f54d1871a00c6268a48f9b59dd4ddd4bf8f861a3cbbcb5748660a8182c6cb3e1d6bdecb54f56c6933817ba12afd74b8e8ff631203fa294aa2091f40e4914355da6c1f0bac085388d17345766808ae5abfa59218950dd369c6e256870bfb5789f5e1d4a97340f9a962e4937aeeb0defd980e20598bdd68425518b018d37067d1c365bbc247730db31695240b2e2883c58a8edf1d9e37108b7c5f576fa2ac269b26883f541a7dffb25146bbae4fe3900301fcadcb8bc0a00b0fa316ff8a04a6c55209fb127da406f9674009c2e20db614114fc5743383c2122c52f27daa70ead2d5e00ed2a50de4b67d8542b08675fb39539adaee2338e8fe19846d9a18e6d9682122c8a0a622a5b835db000d3d8318a87a76d769d872a8ccf01072f5f71058770d1b1dd5cfc5a5af457e62cd01da88297319668c5a8645c102158c5e7dfad2932711789a44979ad7e7337a69b7dcc29c8b1279b4704172adcadf81ae682647fc684351ae5da0ecf6ee9d900cf8d7d29e7ceda7385b98b2c05f069991061bfb00b1c7dc668886954bffb0ec5a198982e4ec77869fc79da7d95b92cd901d8c36f6771a64ed81afc8fd0c0d8d5f79d4f919ecb4506badedaf8fda5e3a9de7f8dea577def88c1e0f1b0e14e08a47ff85c2a928f95663d6e2f5d1e9dcff9f001c1306db2243ab0c34ceb26432c877597602bb2e8bf463d1f9afa8e39de67b3b43f54e80bae59896dfc7569b043319cb53e379215b0c8c8b8a7c67f2e6698d72a343f303e715db24d77ad2acfe83d3fa1a65d1f94d719c8d4516b021ae0a488cbc52b862b54cc3b2a858be86a9437856a978eeecc851c8b0c0845cb597ce6b093dcebe0c05b375a5c823aa03e0449c9772e35bcc145c1bd7e095afdec8396017017895285b31782509314209e3c79ad3a9d80b0f7f54390d54ba0699d23e53fc0eb266fa7d777fa244a7dd9dfd7d9313f8cd3980076e5ab1e62c6aefd049aecb887ddf2323fe90df38b2bf76a36f305ee2b430ceb0b2879c63800ca9dca94a5b0dd6ff768d516224ee7d9fbe04d42ae16f8967182d55155f0125526c8cbb1f651ff2867c8f301621f65dc3334fe96b5ef49f9d913c71420533ac86d769173c2e9401ab74c243696de8db47068b7e0de56b63be10cab5a6f09f7740021fb9be99a60307a90676a65c5578f9963a4cc256829811fb2b45cd13085e33c2390f21f9cce78ace23cf2788527024e1041bdc1a430f6cdc57f36b617c1a45267990addfc14380ddb3fff321b0eb61bae24af2ad33de982b0901cf760ec0bdc59cf2a1859e9f0e4269c3e82c06c354ac7552230d26f955da5df27b1957e9570eb687b724da2ea8a377bd068ab26ca9cad6d50abd1d87be51c5d15186b4e0c898c7db513b0bdaf74df89b18fc88770e32e0263df00adfa8afab90f160e7f96c33e89d3533fbe0dfbf6e1d1e0799638472e75e01a2dadec7ff6d3dabd5fa79f3d5d3d74f1ae2ed72793031290757dbbc7136a782db59ff8c85370b2c08025dfb768a8d487797c1fb3b0568af71ac2cf2ce91822fcbebae6b7b154747d6cc2855262fc201294547a187f5db21858930fc157c57f9721204018aeef0bd79ec5d93271325891eb61f06fb70e6d4618abc0efceae62c20310a9063371e5cac44185c78c67254f531638d9c61ee5fa2a4f02dd8b8327c40b271ecc475f411375ed945f2bce50803d41f84bba76bb3e48fa814d610b83136a0589682a57d852f601a757fc627000fbc4d2e2e9035492d7aef38f07aa0b2ab0e8d444d6ca9f2c5b1f92253de07ffb0a17c7990a05665d1cd97f57c089001d3e627598132e8b9e963589234398950076b0876b316eec96c8148b8a2ff3fabccc76c488cdd72a928f6a53ed3a95296833ab8fec8b77be7f10bb1c14ee36c17ebf3108468039b7fdb468bf2f0c6982bfa45e09d88356659a47e95f2fb4952ad29dbc046ad40ea9aed96027fd6243fa4b0d4e2927b06ef2cb77bbf1ca0d66055146aadf8c967858499ee6c85ec3cddf1155c4970cdad5eaedf0afd1c9e7425871e5a1f0d03aed0f042a96b81bb19772dff69f012dbe5d5ef90d2c5052b493fd9c2d0f032d9ebfbc648d5c887cf90b1fd5c93647b4628a8da8d0bfabfc0cb568faf2926d741670a2bb384b7884da13df42a20b91ba8da822951014bda239c58d4e16a4e7d046c7082e741a1510b98c376c596d71227b03550f4cc767bf3c414bc2219c7e2a1cf049bd21cab406de78576d9be0c7aa08b2c24dbc34c752a6466671dd05bb9d0ee2a35b3d5b5828f3e0ce7b48de3f4021657c997e98db2004a823b5e7f98e5fa7d010d6422a023d7850f982512a0248837c6eff2322fb7b77b6862b712b3d094eb835559d72a14689b014ad943bcd3d978942bd1c5059ead3f763339184e10a9303b6b117e2de1eb3003d7064ebabfe52136cb6c999065ecee0380588c7743c848580967695f6c8e67a51a1286565e2a01fb69b104d74be196c30e4270505ef4491e8c8d0103116093c84414cd8697484bb6357465350c180a4eefc6a8399ef384bb39ab2e52f8ac410f13741d8c52f0d467a5462e4852c208ec49f65635abc2251f3a9d7975774e076aaf7971790b78aa394f1587b377075ef14d6ef3acd7c03a7b805f3151bb09847b4045c0a2921ce4e448fc1e0dc2c7833bc5cd4b76de9187654f65e78de35e0c3db36a464fff70f295b04c0fa2c4b03f660a5e875f1acafe4333cc07706290abc7fbae88ae1fa8cd454ee1150b6833e437fc7cf59c28dcf99d07123860aebf1e36f1d25f5c7f4dc3fc578f615dc25340ec59fc27b0c0a5d2b229a3bc7446e313534d9156ccf28a2dd7366ce439da125c124aa8cce12f62f49b57b190c0efedee7d9f49ec8f91013f863474e2df0cd8782d978db791f84b9027bc804916bea310002f7ec933a7f00d10af21d1176aef1a78249ff41ca4603b67ded5bb46ecb6c3e084b465e733cba989d90a92c839bedf72b51108d7bba586494b95c5d41906474ca12e87a9f88e102f0ec7d9ccb23027534bd71218b224a5fa1f21b21679bbaae9094339aa79ca68e9ce5e4cfe626d7cc98484f35db7ba5bc1409044b5e3f6888dce2e8709efd2283327ea95f037c4cfb2082e526e713fb8ebda8417eeab48e9d8c78fbfe74e0bc08129ddc3895533a2926798009eb2f19c884e2256983882467d876d1f6ac0bbf5027e24ef0dacc9967895c09a803e858799a4ad6e5a458b7cc3f73d68527f36ef3f2659d96c945ab4137241ae4280559092d502d739c30917b3263e7321b53bc2e15fe5fa9065ddc2b81d2bc11822fff8ff012c384fdbef667b7a3e8aa276126810f2237fa9a7b1c96c32b20937963729eb527ea326982b5017234ce330a12ebd1c93d05fc06decd5abc694d046e0a517950fe005ef86dc66238610be6716b67e54d9f427c845c9965a3146553794fc236b2b050d7aecc440a00c3d46c8a5149dbd902256a1b4b8073bf68521e6bc186c392b6864311d21bbbd72684415e21f0428891655e96eeae276a1958c8fa7ee031e2bba2d75ab525ae2d3100a20741823747d892c46835803c1dd38ef419474d9d0573d303239b10fd6c104891cb98554459d2ba41382241d86db4049638b1e9eef17edc3332e9038f51b15123f95134c575d2ac7e8921a48d38f7e5a9ad6d25c0793498c25347c80cc92f6de08be9c5092506dbc9a1c9a1e1646cbf7d21f9bba110741ecf26d9ede1aba247b7fb02fb8e80f773c6af5dd4807de848e57fa0fef3595cdf71010152e67c0b4988a28d431faf8a0ba01dd423e3e3d1030f29643fe17bb72f29a1dd80324a5f92ae414d907655e1d97f688b0140738afa5d1ea610b5a8d7348a508cfaeaf2bb8924e462b6516cf15a5f882b1df813803c4cbc0f1b821ff974364e3e312ee21c2a6d3fd0854d8e2e086979292a2dbf43d3ae08a016cfc384680f66cb64c97e8fef67917d2d3e34228ee539f47ce0595825361a264187504b2920c1182013784d06d418b89dafc1469d6f4fab5d8386e940ef11e46fe685cce87337929155f15006687de0d1b1bfd9f9487c4e77d623bbcb9c96da745ffe477dd362e7f6bbb7f37690c388529cab9ccbc577ef96cd0d32ec9981730cf47b2753fcc26407e27aa5b32a229ca3613c02806859097b75cc96c46655fbfa208aa902232821c2402e780cf933608b98f0f3c52f79b15ec196283f481d006bd43fce075e5618be101a717c810b2e073914c711549fe22c39bcf25f1d0b4c636ef92c2fc97651011b59f99c6a05157c7f7aab0fa1645cba9e7395dff61e13e6552bfbb2ef415f46d5ae71f0f7cfe65f3c5b39b5d34db04c5f166702b2fdce5f04c487ed3028accbf3da510c05cf104bcf5633ab4a44ea32df7814acbd72fefaa3f1da9fff62974d833c0b732ba563634168a75cbabd4b4785c762393ca75efeff7bf5150478509df5f8709fd330df110ca2198b5e4ce92fc5c613e4d41c21e79029de18c01ba130972557153d76b21c04b50d6e1a013158f5c47e8a1c77b0aa5ed18ecedc4a523a5d6b0aee7ea0a75572a0b54ad2cf96489577c86edf4e906b1913dea529cd7e9dda1310019c6dc51b4641a038ffd7924b80b9af6a12dc7f8ab09770612152004efca8a65395dd248c96aa4845452b884ae48ac74d7eca51b40e9bbca282e14a265938706d6b101dd7f5337d4b725c61e1a79e46a29303b78d512adfefeb0b1e7540df32f7e513b51def3dc7ce29176722ebd991ab5acf9d7617403c6985cef3601ee5496c7582ae4ec98593a5b746586fde02aac4a2065be599adbe20edb135e9d8ab13ac00add4fa50eb592d5630bfc4c2d325598bb97ee38956233d1eda5602601bdeeaaa8d2904764322021c3a64a144cdc2e8b76ca3b9825144e9ef8a5b9cb2ad281db08caad09dc51d19670b975128d5832d4a44ecab2dd4e392396eadfd322f9479c637e4fc10b55b2afc66e6de7ea30ddfb56bfed8d3e05e0a4d2751f49310c4419262269bc9a2ebf4f8bba0bb94d452fc60a2ed6bb0e578e4916ebbe0ff95ce265a115d4be44b6bf650b5a4eb94fa77341969b3c0ebcb07bb0c7821bc0709a93b4f2478454b741087a35cd07a13a685675ccc2eabc25d8ad3c7f5af234e7241f623b133afa9489f8453227b0a7a259d43721100714d2857f9615cb846ba363ef789bdee76bd438c40c7fea960a8bd55513033348699b7961cad63f6f42d66cc431e660e48bfc1adf43aa0dccd01e4b1ef20decfb4d5cd47021fdceea9e16328a0de9e33187ba04011bf12683b2ff85e8602730da0eeb96e5e1f2ce64112bcf9258ca1ec60093077f690daf1f0b4e95233a4d87c092d8bb758a856be895afdedce82e5148085f7e1aa71e279b8609cc1f89c8f2dfe7201868e754b57eca92a074b05ec878cd5db88ef975ce4906255b3199ffd16caf0fdd4c9cab70ae3872cd807b8bf4a364babb7acd6a989c89eeec35172fc47e398a85490a272b8feb983e69ba725f66a4d10556db21599d82805f6b186bec99ae06d8c068dcca64cd4d34b339b5e9076ab1a4fbd8d93d0a378cece535fb0b6fa581f66561d14b99b374f18c63063e1e7b7d1bb02ce395772621fda74625592a1509bfb7476f1089809039b7c2a26c2d64c320a5252f91e4414ba9061109f2860c2df52966398af4e4c210b6b269869702a909a19ba3482e066d50f8860673122de6304c1e9f974482078faffbbd3a24d040a2498cde2b5b943e20e430a95b7f307517543042edd7efaf93c99abbf5337fa85bcb7c53361c8bcf45bd1df499767c06e6b73ca5a7d4e06d6ccd0628eb48813e87d6a4cf519c1022b4dc4c5bb33bd6f5ca7d45509dffd2e6e76fcc88325810881ff9d11147fbc6a2a1b97fcfb9b5426003eae371b2992d95c0190ebc3bd6ef09e792f93e061a6ea994b32d401febadd90de2a5a6af4658c78c6298fb31bdcce8148b972d98b7cf0d3731e6d91f840062b4afac78bfb64b56e65b2de22231bbb313dfa49704fbf7cb077598514e25e43409fbc3b4e65db3b0c0ce5b835402e66bb09dd55a86ea57be1e582366d67ea58d365943c4cca29101ce70af911d6cc3cc204eb2fbcd07079a098c6fb99d632db6ed099b602002ae7000c4231c70832c87bf8b916facb0016104069e0297a228e4f24b1ffc9e37e8e604403ce491e4469cd0592bce9a5fcd2c1a960d2a96176952e6e6c7c53c950e2cc3efe17f4f8c0215f7f4c9d81c615e7c112cf37234325a9c6a041abee4f2e1483525ed7ec6f864c25985ac92e2b098f6ae42ee429a451305383627096bcf95018cb22cd9a1140ec78319de29c8b5211874042a1a2b6b2005f714d3c5688ad364ebf96c59216c32d325bd66b4149e8acf9817483c9f7264dee0ee6c17252fab5f1afb4e41f5d513ba4cd18c818c557174f6142668932111ae8886235d28355e8ffca886470becade505fa99472c03cdb64e9c76d20e2fcf77d002c69b653060cc13920b703afa67b36190193abfae2edea2b75ba65a8a94f147cb10c388915d2e620c813591476b40526bb0487d18e28d882d588be8c1b6c01b8c92b4423a80279b31e14408086d27f1795adaaee62273c4a2c09674948107482445230d40c2d51200613e4a7801e2d09158503d1c63e1913580a22056a8523239fd8b5eb7ad4d6688b65dd946c63c5e0343e9e207b744fe28390bebe69ab19bce1671db644f5c4d706294bfcf23b1045c0dae24a1b548f832d704c1171d668e046a29055765f64cd122c83349280207f713ec6d7e3362320df75136a5305a49103ba72b27f5820cc524a0783fcc92540a636b56512542300ffde127ca48755ca33eaeb4a3fcad21b18b0a6c2379d0b877c96e7020070fc623abe006cc2c593f76252b6698f12d8255385b3bfd9974e5664117d49c8de9b6cb9a59429c914a5072608a0075147ff084d17cc60fd434a95744317dfa1ba4da541305656914d0db60632d8fed8b42a74adb921786955adb4caab6ed3afb7386cf5c686d996964d76f5943d656b3626b253d844a20f1a8cb25bf64b6db5fa6d255772255752ca8f88a505d7552ec431eea87bee91b6ef65b41db17e7ba46e7941a26cc8532ecf3661d3d8909f7eeb51b2e1dfe84d0d4697c2cac299764c0505b9504389c5a729a62b2f08cce0cb7f8a89415f6a3042b9fd852745cd08fb5d7563172737642a9f6bacff1642080db28ff94db5213e710038c4184fa85f0485a4bb7aeaf54fda0c6020d611c6ebd3f3b95556bd12b3f14fe85437723e47b1bbbbbbbbd65a8f1c8b952ae254413535e54d0daa9973e7fa57ab34cd397343ae9a33e6c63f8a4b110a0b8ff598d8138cd8eb62c0b08e68e958869283e5862e0575e39c7136cd836f9443e7862e0525e78d508cc5f735cdc3d930778cd1ca78dd3b07c1e7cf8f0760c6cacfe353f3a8f5b6b1215715b1d61381244b57d8ec271b3b35c8c15b8a032d754d70f76fd67529068acfba633da64de9857c879f7a46664f0492d0a9725d2a2e71749a6efca3168a11ca56e5912d2dc50bf0e0cebe6106ee3c2a21def9448e14462b979fbb1d57b08f69d085441063fc1a638c532ed56044622b2c53c9e8a166fcb1f62012740130c813b99c6c1524a61b72951179b9cf6c56242bc29572d42ff71e0d36acd9d31d2bb0f46764ee699023a458f71d21c5584158314887f41212e359ffa21f9f6ebf75de11ffa3d677cff25e42fc488c7b7aa4f5befa55fcd949a0e76dacdcd3a220dd778414eb7ea394fb20acef28c6aac32207e97edba851358af1acefa8f531e867b46d528f04fc59efe560c31a3bef48f7f6e30a859e6fcdcf0bdfc5747ef835fb59c429cdb49f45fcd2af48ac5f18b38c9f64025a5e52cf97a5df7e475adfbd7722b4be9751f7bd84b0de9f553b8ff5ac2772cab1e91971cecac609e89eebd35823042e223e25d80b7024d4d0831bbff5b343aa1cbd19bdd67b566c5867b6630536fbf8f463adcd7dfb4e57146375a4cbfacc7b01b14fff957df721d2cd4ca81fae3e3ef55e402a53ddd667b1fbb1fafac9ee595ef79af44224ae5ab95c3dd0faa61835b0c165282aae5031755b9f3da07b1a56f6da15458f487f186fd6fd583deb930dfa0784fb2cf3340ef403fceb7b25b02dd66bdd1722c9d80de95fc9d0e76637a3f4b3c9f28a6419fd2c760ff0cb755e9178b9af886f5fe85e96d198d4d967c46fbf5c791ce8d73e1328fd5e3fb2ef05a4be7f28bb1fdc60483fd2be6d3912f4110cc443ce1e0dcaafe39c2cb93010f7fb833d5b4ae9359b93cae539e753c96c3ca8536c910a7318b558f0d6a128050a150af9cd11055888d983f8c523ba5ce9e5f613c1e011285879310822bedcfe1f18944188b90d24defa452706923f2c61bd58a575c569ea7664ea9aaa24314c5a2614eedc6e40ebfa73d26d8fdedefe8d0245d29a52b1796cee98bd6d904e4a4106ca420a6d308f301eea98655946a3dc3e6e7960b0ee7e10e0fa34ccdd12b1be8492a684ceb9a3259973ceb92599f354c164712749994e09d5a6821455ca93357162369973cec9056dd2e4882964d07ab0a658a1e7888642082396cc07ffe75da87ea54049ec3084154ed04045455e6102059dc354032b3141f650dcb007d4144e6ec84f5041526fc258a3a429a19452eaa50a2a6a157652a8e20e8d32e79c93ce4922abd0228a0a3ee78a2e0d0b090834349440872aaeb0e2c9ffbc79f39455b14605695dd6c75a3071bca0f64d1a1c59bd0cf5a6cc0dedcb293e9b72ce3748ace077ce39c12ede68916f787012f98d0d4b2cc8374a5254ddd0be1072e4c869aefad81aaed8a4e887941bebf0c840459fc6a0c76e16f16def039d75d7009f1d9dd545fc4a59f4fa31affc79e52743eeba0fa25e451ded2c078a28a5947215853806350f8dbff0bbfc610ed7c7618ccb40714d0458a8c793c043f139c64e36f3478e1cb24ce33ea7fb941d7cffaa6a610ed787c1ed8ed1234ecd28986fb33a76374f9613d162aea05b30a160cc2c2920e924e0d0691ea2d0c18e17477899410c1776a40e52bc10a5704297b0cc610799e509a5945236db9299a539e79c5bb42496ce6001536689cc218a3c38bab80e021531a490c50b7660708a414561270a298c608edededebc00792363e08a715737ba96ed0410f884c8df3c98b71a3dc6e81ee8910ad12a1f4941fbd51fadbe97907aa4fdeab35d100d29cb8b525b836050a305954be3b21a2d92ee2ae9fa1663e762a0d690b02110b96e8df8ae27567e3abc8ce66fd33b92c27cfa47d9d3ef25847efdfa1dc93efb65e1587741e6571d5614841dd6e06dfe6929a557ab11af3134e2d78b8df1ce90b261e50924ebd95aedd71e840e8df8cdbe703aa5596c31db7caef40b91aee6bd7bfdd4cbe873d461f4fba83639cce46fad785d57fb8d3fb0d9d3cf3edba4c746b0f68528d4a75e18847ff5fcbd7ec4d79efbedbbedbd82dbb7f7fc85aeeab18725dc50fe10d7d5e86fabee39efc8eb47f6abd5e7dacb8c662f1becbc7e5f7df4b28f9da669da735e1d12224529dfdcec7fd0cf68a5af7df54ca0affd466b5d7daf9708fedd1bf5733f02c7942cf15fd2cf7decf50be97f202265b4289b6a98628c5c966dcd5572488332f3a10648a2c776231e1b729c127c931cc75b59997dd7de40a615bc3be7ee3e65dcb05e4966862eab276a758f05451837c6b8c48a4be365f3e07169bcab2ba2e1fa0bba22d7054b66b817bc055dd10516fc8caec88219cf65ee8cf7e98a66f8bc8caec8a70032a264e0b83264bc1d7365442941726524a9f2fc262a05237ccca9f3863560d77d6d73bb28244144252d0d453279b258cde76a3f57d3c0b8e26a618401834c0e28305c30c01765044085c31ad7816ef8737de8ba7781e7ba175dae7fd142175baeef7822e9e9d28832521084d405cf972f7440a2a44649621142c4192584b83367694af6f0f1adab8b2b61b8cda52fe9db00ac10b9aa252e7d59b9b8e1d26f592323ae9ca9a109942e26903c68b182e32ba59492c55dea83c10d6ba4d962882a2855415cfaac05144f292d028719435c5ca5d1428d16488ae48f1a353c74c31a2b9872a91aa815dc61228b2f97feaa2ba23f7628163c0061a1e6d2d7ba22ea0202aa8b3ca410183c58e0e1e14a2d5f5ab42b9a63ae78e2ca9f49288f2b942e6582cea5575cb9d44529a55d0d3b6899e109a8289cc81d82684329a551892b5fca6a0410ad035cd9a4c7d2a89366050bc2dc71d59942698618a70bead059c167aaca823a5eac20038cd30c3b4e96629471f2b1d342cf1a19766e7062a798a69a62d82c515a524f3d45b0c022f364c57462a85a76d840e1ca24b1ecc459dac254e9ecdc5995e1ec78a18599daa044a960a856539c645254da0d4fe8d454f58185d9942121472853459960c14798da32a558a14700c324a1acc013471853e577902cb198a5762d599f79394a69e986f63fa62a9d3063c4065466c2c0943063260c336f02800233564099c90206eec1ff018518d3303ec3e6cd0842d0f17721fb50679e38d9accbfab8a82e33c1b441155b5f0077b03d337050c6763ec048605746dc60b2aea81e2c8dcb5067daa839a3050726b0f632141a261c0461e56528343074b0049a18b8a0a90216292555283478aebc1cc504889a467ec040524af9335e4687c085667cd149c6e7b4f919b9c5c9bfa393537b216850dadb5e062cd8beaf7e19fff28ff148b157ff8c7ff97794c5fd339a71e413a570623346082f8208f326d6de14368c4edcd5b2854bf3882f1166bc8c1732e37bcd8f21e435bf2016bccf736c8637c5f09a5ef367fc8bbecf7c19ffa2f463cc789fef288606868d5ba2d30caf4e4f460c3b592d5bc442710aa7f0001cc56418cd16da5aadebbb19a760a16efa81857aca9d78a8e7ed6f5fc86fb80d0b0d198e3ac00da35310cc73f226060aa3d395641836e5423e45471b100d19eb4d55ea80815efdc2a7e14dd2c730907ce9f235505ae2d132a9f565c78ac54ce632475d3e40fd3008e65da6c15a7da21030900bc52c0c237ac3fa421d6d40344f66fb42171f400b0a75c0408f7e215755d9f8452c0cd4ffa6898d71a83450a2ba336b20e221edca0fe10703a434c240f2a50c6a50d24062c3a0fb2fc45588104519a5121a141465f5a15f0d5783f25d4f49e23031c5263c24b770b95a8c04312221c85410128884800d150fc9205808749893161ee2d897332e3251472465494957f8d2cf3e99cd7eea713569529b94b4c4431dbf081ceefcfe0a033592fe72fb6392152b6e686fff2775a1a2a27092ee002e434901c3dd5afc2359eeeeeeee524af9bc926337aebb197d38fd6ea8a8a44b68b0692029212669a064e9ef7822e9f6c73b3db8ef8f639a47f7fd318a7d90109f044025e9c647bafd118a87b4efef383da85a055f6e57cf9eabb56ea1e5cbf52f32d1225abb4da5795471a1d677670083657deb8dcc4b89da87442974f3c85483a51f910f095bff82276c1899989a877c252c12b21ecd636e3884c7c8cee306394f3210fdc85402fd76b99828c779803ffd6a784149f0af3f6bade4b1f2c75c60bb3c86f5bdfc39e641c3fae5d743d362ff06d1e686b1ca8e226c18745b4f36fed956726cebb21cdf1144801e02906c226080201ed22efd1e3c945d4a298d94ee6890067957580b368fb075e9d3a78fa379bc44982fdf68befc5e6e24ffe534c8ebe16058f0fb06a9f7848dcf2d1ef2a74fdfe5424eb15d8bd78fecf267998f23ff1b82af20b1cb135c945f12ebb098041737ecf1ce64c3ef6e23b6b8758d06df07b38e0b6e5cc1b11cfbf0501d29b788237f4c6a9fd78fbeb7430f5caf21bb600561c35aabec8af43512af4767f9137511bffef93050af56b4bfc6cbe95397b3bbb3ec9d66efd9f7aaaf5a332dabd98a66b4468334fb5c0c445d48946905875da8d6af66f139ca961d65ec2867d3bebe84c423d947a4d8ecd7be5f46dad14b483752cc575fbfc8c45ffdfce339992753c97d822596b0239528a5948af912a6c91c33658b3995d426d9145a9d25b78261c527fa7cf4c1ee75d655cd42326c3ef5a6cf902bbbd3b4164d8a1224a14a73ce3971e0acc89aa024c86850a299d214154c4f64c8d8d089939da1d366632e5aa89374450c5f5889f23fadcb5074cad0792242894f09cbb97a5c574baa25852403fbf23753f431bf768add020ff9d7276020f95576fe0555ac43d9f935d34ba766f26abd9db8a71c2669d59572cb93ed0fa55383528bbbbbbb3bcd6a56b39a65533a15f13c72cb4c63a58cc997f225a5d3952fe593749a5912175bcfc8ec2ebf38c34b66f6cf04feea00bcd8500ea08b0debe54827ba942edb3f966ea4bb7b411a74b11c638f066316fbf10586e5675d6139cbc62a39dde8aa11b5029b1b81e460f969ac60f9392e2c3f8d26cbcf6961f95759587ece0acbbfb962b0fff1fb698d952fbf23f225443b32ebcbef6524e94bffa691cf77ed031d16654357c631d72ae9e9c95aaa6ecf9e3cd2aae8c3bf6ea25df050fc3a06a9c36dd9e4591303655318d6df2c75f0ac04d3091bcaa62a4a45a9eacd92a20fff4ec2427d03c3fc5b0505ddb8a18106afd70d69950c1937a455d90978c83f1b32a7e8237e5d259eccb2afc618a43583e5a0fb65d7bf12c2c84005eb3f4370ffa0c12f96a5571692672453ca9c65f2e7c7ccccccb17f91735e13e6471dfe8573ce497d4e77671f43bf3f32f3836c57aeeceb17cea79ff48d29fff44c4aeab37e6c3e98b579d0d9834ab13dc3fa4dfef931d07c39db063bb3e7ccb3f7ccdd9d4ee7a4b75fa553122e9862fde51070052a3fd9a046e99c93524a69651b73596599ad2bfbfa8594d2f7d64aa394e9277f8d95ae7243db1c1c1b3fb4769b2fa5d632217b7bf9f20db3eff5c35efa56725b99e1b2496da756b3596687317fdfd1b9fb0423d90581afc6401c65fdd8ddac3e0b8a3f4ebf6d153ffa8842d661433e30069b7d17f13c79eefc000085ed9e7b18a5dfd4697baf9e3b23f1fec8600525a8103e2019aca084822bb39a7943828e6ef6e4759ed39698c47dafd5b31e2976f45a716fd4fd5196d567c4fd113bac23f24ceb07540e04095a7536a66672c505b9da576ff34222770baa755bfde6199137669ccc3167556b500fb0d6ef2a653a72b7a05b3b22dfbc217eb72d7ba2ae73ca5b2f145d8146e1c6f899c07a9e3c4c3d3f645580e3b2428aa156d13452cb45a105153e3b1df87abe0adc215fec351b27a06a14a87d6b833de4a7860fb6bdea853528e0dae28324c5dee1c6d42b77a2a0246c2a777efce2d2276a10dc3afdab3744bbd37f2efd420adc213f57360f198ba2b4dca960cbe001f0fc2e1a6c28a5dc7e0078ff1978367078ee0ee53ad3f5a5eb9ffca8e5d29f1edc3bd32bc2527e7d27a7ef1efd1e4abf5b2cfa1db73dffdd322e7695b6d25418a8df29d392cfa5c914e91a4ad5604f6c2a3ce4b7eb58b9dc2da0bbf30e03f5bf1abae6f627e08654eaf6bf7ec40fe79ddb318e8cef5a2d8871e89ae843aa79b00b517bc5e9125df2f61933aef4e61b0094b131261719a582944be372940a4e57724f13cac6383ca4cddbf3126183e7e085800febe46f4a80beefe037f080707836dec3f130cffb0e827cde14d1ffcf87fce4c6c67fff46dfff3ced5efe7d363ea39feffb8838ac8170bcc77770bcf737bc0e1ec8037a22df9aa311c777248b3f8ef77e03ef7bd0bbf1409e8defc0fbe7c0037a98d7c17bde919f07df3da39fcf3e0eef083b6c83204a6c7c47b218d978d81fa9ff1db1f1c19ea877b8c1f13fdfbfc38d8dff0fedcbdfc8c6e378a3ff9fcfba977f22e0781b6f64e38d7ebeff1d58d8ef6f3c070ffbf083e6f7e1f81b9ff73bb0b040dfc16ff0e0051f4409d077f03fde911bfff33872bc87c3fb1c38be1b379e633f39fe7ba31bfff3396e7c471e8eef891c47920601781168e0e1d0e003f044fd9a36bca58ed9f8f794304140ccc62f75ec7f7a416cbcf446e0988d774f88c7fe6f784772fc8d07f28eb218e9f80ebe23254c121003faa518ebe0757c2fff7f8e1d2dc518d0bfdc3b92c528c7f7f2cff11cbbf1475efebd44d0f138de28c7df781ddf5116a3ff1cdf5107ff7f04f4369e63389ec8813c8ebd67c36387edc0638b7018d703485787d7081cc3f147fc1413c18d17018ee7588c85910948098eefc637af743061de5cf22607de065e00bc977c8efd7cf18af7925facf27dec30cfe398e6c5022eaf25468cbf315c3786651692317e2e7dffe4c243f6dbc7e743ebf3af2f74f97cf8e0f599532e7480eaae9fe2823a6e28a76e5be0c509b91bd2a513a40c2fdc71c3b914ce23b8c1cc7e1e3050f6d26b58f63b82b2677d2178b3ef6453b67d2bd9247d4269b02753f6cd2522ac9cefcde33d8e6d36bc23b6a28a229262287448a05012cb223f86b2c98697c1bf07802506eaa5a8a464632ff150d75ab2f1ff05a87e8a4f36bc230e63878ba6180a1d12306462598808804ad27d01f1f94929cdc3bf5794ba52f70ca5734d1c7fd31fa9629517e3c8407a75065a9c4e4ae716d65e8e6a52e786d6095ba700f3d849b54113343770b074095818bb41c1e21811c3096ec860b5cb514d7668e2060ea6d8ec7254132a514d5450a1d1ac71185882a8264b3026b65e8e6a920456452d2dddb0c5883d3fa0952c00781d830e9391d3b48ca39ccb67b2b495c7ae39f8f3355c96ebef18db0220ba6ece07ce4fad2e17e8deeede2e996bdb6e29a59452cae972d5eadeeedeedeeee1e4677daddddddddddddddddddddcc1e6b5633dbdd168c891cbf7ee2cb96d3a7f469a5f4e8eeee3eddbdcacccd63dbb81827c7e1abde9e3be7b43d5c10e7838dcfb1e9996105671f9d9eb4eecc2d2959b29bdc26b4d2404f4ae9eeeeb23a33334797524aca75c58172cb28375db2b816e703c7c6f7766666890597c5c697cccc2c8362581968dce5486d4a275a9b34b35c6b955a46679eace59e676a92524a3549bfd612cb0d4a2d8fbb9c4efb0b7c95ae71ee56f6d0430f31e41472dce568529335a3938ed46a46670f313030e2c96378d0608f1e2c7b7a68cca0b2517a936696de217aa259cbcdb362b78a110c8a42b109cf2acb326e3e07a475b32b5b4a6c7ca2bea2803b1bb7e23a6d55a90780411804ae7b0ccee7ba1ff2d20910b9b856d6b2140ef89e8bc613cfa6553775537f37b5f74c4bd497c8870ab7327cba46833e3e5dd17c9f0e8478b7ef91351109e103063491e8e3b2eb2a8081180f118765868c18b56948d597b2baaafd2a41f974b716c72f906881a10446125c1e2a3d75f2741191b461a590c38c242e2851a25e71dac2c275289f0f5d6acc8d5467dec42dc6a51b5f32c9a6282638dc5056915602bf3557b533ae1aff036a727eae5ae7ac9e03f31712b9fcee69316ace9e11d97dabf5acdf9cc7cf5baf46c36495a42b5c4cda925445ca690b978e49639a4774aae1b6969854030f456b5f0cd419e5be90b3cd43d3be6d83fe5af36885ace7063b20ddb79e763f58dffac2ee877faf1fff99c07d7d13581ff7b1731edfcd0bebbdb776f6e372fd5416c45663cb6f296b6b5ab665f57385f2fac88fb7b0fd527619374565839d7d3472552e06a795317e1f2748ea10db25730d1777f4b136f2701e91fb6958fbc795a53733478dc50c245faae988d4d1842de4fa823556b0ab973cf4bacc1139ac351937cdbb526a14b8f5d3a17b2217b2600e192f49b1fe10788abb27c81bdaebc3403e633608d1076d14f2164720982fe70bf22708f65a2f7b0c9ad81882526280c5ceefad2b821297ec09f2b6d2f471811c59f6072d4eb23069c70d665d7da275355ab027c8195d51f3990f78a559502de058210a777b9f79675cfeee4090cf711fe76d2bad66744abf1bc771ab8de32c6bd3a17ba1eeb3b55ad75f30eb16602f064d408860ac50b9fe12c808ee7c39878c97a41b9f8ee04a2963dd04bf61816a4900b458d762fde517065961c0c4fafbac33ae3ee7e0baea75f66f48d06dd939a0748d6ec6bba29ef7aec8468dfb0171ece8211bbcdb13750cbff5930de82be3eb0848323821c1020625b2a071136386ad7ef3647c2b2f94778be1c5cd0b8feecb7ecfc70ddacf6708775b9f0d3595c16deb3ce95b08384f3e6fab2f3cbad525b38e63441a6563fa723e9dd3887b992165432458fce49c1f90ee8847bb62e3e253c5f6f21b48bf34322f064454adc72552c788878a14173684b1248822b0a041bac10b2a52f0c49aa617a03883a51ef1a5890b4b5bd4489971e20e9427636a70a18a34f38212197c50228a175e52e044132c984c0933450a253985a5bb301126490e5cac5461d102945c420e1a178620c10ada784953c606364ddacc3047094c1d32588a50f183152956cc14d1650c92152469b2f06108252b5188711c783042c30209dc2041c39a3261d88b28787e386229890c45c43c0a9326f06899414e5211601070c50a2a2559e84c8142aa480f767218020571b248e14b12121f78c0f24445c78d12333411461b20f0a8417243145216195878d374c4164c501af00186285190c0f3660a05484c48be809344c40b4c5978d12189282827a0a0c9d243122e28beb800c60b4b9078e1e9d5449326a29ea2c890844422ce1b26a0f2cc80e4c9982e3d749b33499871a24c0a787e807204961f5334c8f004551518d0482e0ee7688a9492921b92ec70c5882fb248c1c1ce114f9c48228bb02c3081a50c1e20bcd040440d5257527053039425e4c82db379b0001c12acd0c59c1380791a824a082849ba8c31c2890c42fccc2084933a2e8019834706b1c110456c21e70b0c4b3c915a6201e29c3b1828488cfd183dba7497d2047fcbf9b894f2db06e0c532736c61e39fed7fdbd1e08423e55a96a282caf5e8cd0a8faef605c99ecfb4af861b1b1a91d7ff33af2bb259966599b31cab7d4fd8ec897ca57d6683953fe78330f61101d6317b0cdd98414d82c3e6134008cb178479ab77b780ecb320acfab357f6b5c197f6f433ff97f63103655fa5fac2cc5282534018b22ccb3249b92b9f5969a35936e79c349392f9d9a564965688bc0cfb6ab55a497777e9e2ea5dc732b3e5724193f53959f21429a59430068a43eee04f8d70ce39259d35f32624b394cccc524a29a5945232b313ac2ab6c15d00fed81579db62a27f5a16fb63fdceb2efe88f8ef891621c97fa6d2cfb5ef30ba284484c7298fc1c6e2cc7b4cf92e52542f6ab37ca7e95511965af7d47447e81a7ec439ee25864a21aeadb58babeb1bde56ba706e57b66ac7f3f295929656520fe4660398a853b37690496a35a48ba1a0f55285151b4cc1fb0a85158f82259e79c73ce6f86a72c2988422a4e9dd804e2ce29ef9c73ce282876aeac320aedb3d5afe25ca0bbbb2b9a9991797d6a9a94ac56967d8b2f708d4c6f0f071b5dabff5c1f1176f55eb4aa736a9aa6d1baad3c49572bc642c677df3801514c4e709e3ace5add7cf7b1ddd9fc699817ff6a6dfe8b962459b65e45f5301c193b4607a37750501838e4f72ef97e411359d34829074d3a77528e41ae17eefc1a3be6fc1a656c92940bc5e8c7675895b65d9f552297d218437214644727e8e4b084ba5952479ea15382254f986e08e2887af2e4facf1326782403eaeac78316cab6678ea8041ea25f2debf983feae42ba27ee7cae85826a341577c670fd2368d3f0100b2399f0e1fa00b4a13b9fd9cb9d5db24b3f01309003a8940278c0f5e79e3ba9f3263b20ad1f0a6c2baa553a23730deb276aae824be0a1eab12bd2ec4ac4bc91835d71e1c1f6e02786e2a9356ce2dc59410855f47294933437fca02dcc45d5103e709102869730f2045b7871030c29b0810c1236fc8025c825c50a2edc2c718309a27832473acd3373a20cf15b94133237e427285e739dd9506597a39c28f1840b0c6a2995a9e4b201e76e6c86c0c00e65bab860064e17282658f26632b1444e0d486aa05343d2172820020b1f9e9023656e804a933356a058b303179985c9d28a09262d38993f9f6813a529b436dbea7294132e576cccee85ae382465fff42bd2baac8fb54feca65d8e7202844cc1c7449b945ad5b41ab34863f4e862ea8dee4aaec7a406659426868ac2f247270957be7b174cb1fc52724bf68e6eb60c54b0fc910121307f80d4b1973cc39841068a3f35a4e5cf66d44bb03def60201b622cf3d768707a4b2943ee5a8e6777fc9658304ba794ba9c9e0e4456b2c75ab2f27988cf8df23959e98c69985d0ce4534379e7bd7bd8f8e7b3cc595096654fc199516a5d73d6ca94259d328b9369fc9a3d675ea0eda8044e974435e9d0d4000000404000e314000020100a07042281301c1ed2e55dee14000d7992466e5c9ccc635190c32808216388210410000801060898a9a1210e00686d76025bc4ea29c66fddb6a2625ef32650a17d51929d62e56f757534b5b9e7b69a46ae0504606dd7041902b0ed88c9166c7edae2f917205454e88abc5ac38df461653ceac3153de72f6d48708df4bdc8f5494b6e6f0e589b8d05e1a32f599c0eb4703af805f5e7ba19063c3213553b890b1e3413f8104878e29d927f86f3302866c12b308e9971a5f0e562c1f5372fe18aaf8e2e40d0dbf772add0bb868d736f6fa555237dfae0d3b0d09a62de1bf91eb8496d23c5ea087cc370f1123ee8c4dd3f680660bf4b8ff0ee53012625341a6c7d3a262ef00e23d8b42b83ae8125ec0359d869361d26e8998536ce15c471e4ef808d8917825f6f8af2787bd0dea78a4cc528c7fa1ccb668f297dba1a2587c1d45e900e0e1a3020ba5062eee10cb5761b9ebed3d6a6d0672b8cf10a10ad077cb63340cf968c0f51a2c04565806f62d25b8e8db508a6099e4a810b9d053c74d86a66cec8875fddde71ff2ec76a5123d2803790b430886eec3d83b57e1dd3db0386ad98029a74eef4ad1fd92abbf0e77a4fb6aa8ac22bc1126c21b4315717640458ab3492e4d0679644ed8d371a52efccc24715b1d5a908ab0ba4bd7c94ae6032833ea11ccf7efa2c004ba4fe30ee2a1138e6c6868bb86721ae3d088a38a0e8c49e63b24a275a614fa83877dba3a46d7bc2abe565ac528244b10bee5e192a90248b978777b897ca8af3bc37313b80edf8696418bf91832ddad7aa5055822c6eacdf814f3f9f9f701fc49ee5b94b70642832cb9b883f994f2a0050fd767cb1d6a7618dd35b7f49a74726bc5303fdda29631a435b091c33f32810c0cdf439f1d1c71e520e206f798ef2713ae4502fd133463345999c6d44b54c9753a4b943d2c1c56e8cd6e248e01d70bb887a2bb224da2517a133f668b32dddd59f4438ffe030bc036072a3eba9ab97fe5a621d31ff371be3ff8f3cda7b6446c797ae9ff1a3c0dd77c0202b91eb36f6048e8b42033d1e9ec14d211a7d430a44e1c9956731f50156ea6d7b70d1140bd850de7c9e4e5409e4519fcfad5aa90cf606e1bd68e2c8f49a2db2e94a3cd7ed0a1e52790bca95181efaab69a04bc593b91ce64548bd3343ebb108e882c57cf4be98d06fcdce6aba45422417e8d4c8a8cd9fd09dc95ac0e273bbf35c6a92830b3daf1e96bd7448a6a9691c5377bf6d35ab30331450c9926b19468c9792ef4b554f52349020eb109f6ea8c8540457cf80334706f511ab5419a891c01b27f28bac0e8878f851d49142885f64ffbe325bffc7080865f3c8d1ae5391de18526bce8b43d3422a994182d73656537c21ed39cf4a578c435568bd8dcd4d1d0d4b8aa0c8cab19efc2c352b5157125c28f771c5eb7b36f7ac89eb8ae6fd25f3b9b8feb4ce8c9861a7ca6a4a6121de7eb91ffc4aceb45df6e58e185c55316ff4898059a018caed30ba1dff6e5e5d2bc7489a09d323a2cee41a363990e621e5ae9236bf1e9d04c747c1cf713ba3a6c59d23ccee2e929b1fcefdb7445e8f12382c344a3bc2bb8fd904dc6bf3d66c6924d4c746884e0300298393c069081b51d59ed0efa673ae13ac788742757d91846fffe312d22b0b064a9269be70c4f592c0c6c0de52d8ced45ef73c43a5beb5b2ea119b026b36a1effb37f5a12692677ca2c5541421b230b03791102770890cdc7c70a662f1e82aaadd35591c2b36d7013a371e49e4de7d03423f2dae50a3b90e9179cef4ccac2c355af7b1e8bda115ff7f73a32137f52a4f59eb8c6910e1a1193ef2084d82c9d356319c934e1fdc96888d0be44f164cb03cc48e12cf2cb060b0a25a9e54b91e06353967ab779355891c3dc4d5630fd838d8540f72d9e2e0a637784e68821893b91e26c441476473e3c5608e067d75ecc04043e73b800a7dec75044d97c73f0e933ce1b83430b4a851104e11e1a6b2069e4a1c1a262103ca332bca7b0e252e9c66c4dfdf2ae04954229363bea1f88c183b70ecc34a2b2302d3ba0bb9a111c06ec5a2dca278802217fb0855a3ec8070b1176240771efdec29d0b4880d4371392a170cdf200faa9804599f96c90c7dc90260072255633517ff0fb5095a771c7c1dc51dc867956f830a24485d39f37050231e5fcb01e0449c1a2c49b1e4c41481a94a700c177649de02bde910e27fa12161399dfc84bcac462f9142f5b20ac5b29a50cfa442a04ba756843f75e50becbe095baebe4b075a1e2dedb473f07352a268f32e322013f4ac1caec9e9796843fbf014747798d3180c661dd459b583abc0c72ffa2403f583034288187c83ee4262581cfb45a1e6eff1c18333dc76a1b123518cfc9219879c90dc6413baf3b142cd965ecc06d11508dbb941cdb956c18dc67141a85ae572d5e9e7e78289497fb28733aa74b38115f72453178729f537c645adc677481290f448b568a5e7734bc7e30ed2fdb19473908e08ef89f0e4f7324e7f1c9dbb86166edac1bf0225e2ce3801a1ff61ed21c025793a38f267ec88b38328e908ff60cdcb51542c8d424ef440efdbd7eab13d3dd9c8ee930882250051dc5fdeeb70b2ac9eb2ef950bd21cbd697f544aa562c5bdc5e1dba3a89c20da006ab3577c6090257b5ab837564a2eb0faf6063c6d3c8dc238054fabd9e346ee26029deb5232d786cbcb997eb9f237288aab003a534f990912bad043603937329654630adb6c17aa52727e42b9e776e716128f077f3333990953b6d51d344adff581943dceb93a3455d0b577294bc41bec01d431489a681f505c165eef26738811023a4f2a564dd7112fdff8d491e168d15e8f3501af80b5d1e19542ba325cbacb755d2b8af9717eca17680e11b6e5bbbc04bd11a8ab82dda34442adbcf5f4268d1d0adccebda03c2d016e87eb329efce80ba8b5c80addcc018a646550acf33944ce4a8c0a3a99038ccccaa050f73980bb598976e5920d47792da8ba2a7cd5e94a0c0a583de184e8f67ebe25b5d8c4c9c1daa61cc4dd4a2529296f5dcf99226e21b98ab904fe9253dc4fe610150284f374145d57f6d9334f104b7a92c2783915f6d230b1f5a9a1bed31536ed668cea09d414b6979e37ad5864ea0e712b725889622f2d616fe61611e03ea358e44e46af0981ccf3b25a462220d52f354dedcecd5d3f03a2169f892820944e343bb2c9455ae24665a05401e39b6f7867f7a178a544c27a1c51888c447f7710021309b1bfd87fcac3a9ce0babc7d84fde08063f1a8fec58de1666fe375287476adf88e8d03a83309f524de2674618c0ed83842607ac8ddd1bdc5326ee942db97e00be6c4d95042884d9363ab6d3128274de8e879d587779b72e62bb96127844eaa1f1eabfd65292cdf32cd2ab58d76b040ed1b39d738a4f154fdd0ff34a2dc6a1cc05a078814b075386993addf53cb2284628838aead645c15605ada73443d9b002004d930980570187ca6d7f22dcdac215541e626cb6888e985c4e0487d8e2286a221a3dba8987177bbb57b52163203ce118a1ba0a546844fa000b36aace6391cc654bbc9427b45ab9a484d59b48a9a16ceb9f3a1f81479393486371a2e6703064575dce91a832a90fdd323954a60820eca2fa9b24497b94651915cdc36438809cec30630136b7514f7169a381f181c4f93c2dd854806273e69b96b74da636c1af04d7539f3d9206487aba6d63eb9d8ae9f70d8499cba1750f5d4e032e3b8593eb412a36e382715c64f066c874f6970150148bf9182abd3ad5ae846b1ed687ccda5cd9b96800ab09087052ed6927c1c444a5fbf287ace9521cf27cd561892629188c58425f26258a2ef57351e5cb1955a56500e640e0e2c6df48a5dcd24d071482bef17d1899fd9f5630b3c036568aec8d0f6169bab3b695ee320130083f9f82d6ef2201de83da92fff4a66424813cdb2031f3da18ae33a7dae28d83102a9a3f3ee06c46f1d44f83b7824e2201297183c742391ef22a5b2de7472c4a7d4c6f47b809f68723112eea94036ea46fa763d8dcde494fc82f2e0606f80e583749591a2012c1d5a04f4b26d545a89ef91098c5cc8c3ca2dc80be25d28405725a46c9d1aca405028b1073ef6d2f94ce8a7368451c9490afecad731e617e682989c002f0d1d848f63340ee072ceb5767fb370596f4c182cf6a836d63757370a8320ee74cddd8ad0cc46927e8f9e64fa6c1c4587df416f96d9798aae74089c3ec5f0d5075c18c3763dd516627cfbc9b2e8df870996cc7a99d3e5631b9c90b64589ed12f1cae303f8d52ca09da7c26865a5a6f66fff17bd45245a315f5df46e7aea209535e5e30643bbf9388dd477456aa2a00ad4951520f4d115801f0be5e62670a9ae6fbece34b9f6cf672ee60ee0ead44152a26a3fae43e9f4588daa9010d97c7e7b0bf3c0551b55029443d6c9c00135f0d7830a266522780fa1cb1b79ae7ea0e8b14f0b3592de045824b857558e5cff771bfc9ed31ffa6b159fdee0964a6b7a534b6b0b159793b1d0c9a9c9c24bce3e66eb8cfc4bce036ecec3fa88b40706299a6698f4bcda375b51ad53854a0fa537ef266b37e9f2a718818cb075aa6d7703b5cbd5458bb027c58d54ef05f187c1799177ba2f7ad38c5de65bb4ab96a161f6e46dba55fa8d2908fdecb5a622ec76821400a23fd771735cee9dbae0df327f24846f426b84857d027f7b4ce3b6d9994f29466127cf1f4eb852f1509791d416975cc5576f68b2eb0813cc6cf025f77fca11b365f6688aee19c7e856055fa5202cd01dd05447bd22088f42d0d06e808588bd35394526e023e74e1eaea32b282610c7bf4fa4fde324a374b4cde461b7709ce3560abd8592aee09afd0d3fb4efb25bd9ed5a9e2a1fbf9fdba4bef0af6d5f74db0c0dad119684f9471bb57e5bc0df284472af5bffdb98623d08c45fb29d7b905ec28e353409cd8fbfc3c5e4fede3a8f2af098c073ffe6156539dd7c65fcf1e12c3410a7b69a5a24bb20af60b6c707b49b1d4bbb89c50eaa91c077ebf3c5b5db1ddfeb78d4e993807f1a34f62e6d9a8f2e9a5307703304f2787700504a8f61b467cafe2e9c80e10e9e351242c40da681931aa1736100cb7196ee7802ed58efcdb7dd41c76a54f01c2d94b38880324dd9686a0e087aa8efc647adfb53b21cbe24ea0a625ee140d4762277ba9f4affdadb938622f6a288f3206ed7b1c76ca34e9a1bd000a2dd53a424b96558974dd1eb75991e051dcccbfa83e81a22bc40a3bbd472c7f623d0d60b2bac20c48e9aa52720def41c406505c0cd064784d4ad74339ecb926ae4736ac33d5bb5c0b0bf833f0eb4feed4409b5793b879ac4f9da3938101215fc84739c4a78e81adb26dcd612959e08f19fa68928b55d36a715156f08e084733ce8c686fef5281e8d9f97fd146aa81a5a45aee9a72c426c479f4820db4dfb9a3122447dd75a4c7f69679991247902e80793237fb42853bad956f94c7ae5f2edb4638fd7b510c6b962026e3567eb26543b35f9789aaa5002ae5f311cb1a5798d42ce1f1e9d7a4d77da7705bcced0fb37af384891a470d2a63b2886cafd7d0930148e77e1200c207264232e931cc4935afe50e61bc5f8d38c09d1d85ef1994803de4517fd0601e40dfbf91030bc49e8fb818036d03ea29bd0135d20b90ca8d39077286dc7f90851a79b598cd5d5dc711f95496864ba1418173c3f0eb74a8cc7e130896e7b99b03f705f4ff8b4fdeb26c31f59806cdcc4f09d3084044554d1b052c0691e9ba0c6c1b4bfef820ce8d3f4e81411cf9d89e47575a8247302fde9bd864c628585df5918f07b270d202a938c58d1c4f70591d6887ed0c4b07916c66c71019e86dfd08831d08593892a41db5499d17345dde2f39aacf439213882ae02dbef297dc7fbb94ccda52a80ad4d5ddccf2dc73997545b6c39b1f29a105e5e10cccc06d5ff79954632ac034cc395db74b5271e0f1184209474cb4155c88a8d409082df84124cb5ce45af10656ef70b8cd49a67c5ce923ad14983ac3ab530a710638c66434738e03299f25be424011d4e2dfa94a71b63270f9bc0db460325e402953f1517ab84eb0ab628451eb0a474d4bd8d755298d670e14699611b4ae1454a0485728536c6ee46aae4bdc678e7c2f59e23fed3a6c86f87874045d571135e438fc35bbe4a12504ac96ed4309d64ddc2d021b80eca9b2c676bf9de37164d61ed2ff9ba205fb23d285d59ad5d0632b8e0c45942c17430e20559ffa7d8d69a9a5a46ab4506d0ac0147fb1e53431788e8dbbb44e9df60394c6e47c624a28ed0c1da21f97549357b16d4c998457170f0e82628b4f1733696143322f196f7d3f978825f3a0b14478e1c94de9cd0d961e82478223a705421a3a5d47ed49a0e8a57025e6c765bbd8d2cb193acd09492e6042cde10aaa1b6024e226123908891b69ac0f24205934c1bcac72d011103744640462dac81c4ab7404de9170d629d1edd2a95801a962c4d7934f10c127abcd8c21c91217ecf666a99f4f8b9bc421d4a8832618a7a1b503557f67add8e4edb6f8155d174ae0848c8800d4e411d847ab6b084f4b49daffeb5f9c7af769a887245ea40b55bb2e3be2c643771686fc5f6ca27f4a5af6b7a091f7890d36c0ac8761e8bc047864dd09cc59abf21c638f29ee78088d75de7979b759d3800363d57fd7a01a939974a912d71d2834f8c9ca82b942d0fca5d849fa3e9cf23c12611a355fa22ff3397a44a9e86b1ca6d5281d6a67f4a7bd706a7939c17cfa753910e99b730ea713ae976c5701ecabcf3323d01c0a6fc1e85e60fc82fcd4d9b4779eb4464e9f33914289d3dc5521d1f331025d7f3d1ab5f88c2ee2ec72b274583d01fa3dadbf73d4fcbd3beb3e38fa7b962748761c07d104a4a62ac9fb2442fb691d83ada38153f65164de908146378ac870ed904ab8aa0f6f6608293dea14f68a10288766f70accaaa3d66ad4ec19ff266b4427a240bca7d17b27e74f9bbd272930f9ac40aa9ddf0ad088fe16fc3f41196c10d4563c53991a27453b4aea9d1eeb37d52fe06ac2328e6382daf5c60610638b0032159d5caec79adf47e861cb439d60c8231cf0ea05edc48382dc62a836c49c24b34a285cc5783613501101f630d5b545d679918955cec7aa40cafccf208044306029cbf03bbeb2c9b7dfe2aa3102a9dde11859c45a5daea4f2c6cfc506b9e63319cb90c4c90c58de303071196b7d363f9bc82e6c4c5882bc661b472fce6c836c3cb6952192a3fe74aa3f0e516aa24655c579e052b9b45dc74da903df117e411ce32b2c94cfcfb11249990ba9e4312fd84f8e114ba6c184ac91ea88b692d09c01401802ced0c6b2718d83c95ca4f38fd4f00c08f8b8e30f019c2799df2b953995fd32a314d6ae03395ddbc732c60c7d66f428297e5d802dec21a26d4e9881016d34ab9b28ed0012e3302c10a9902f2d70d0e6b4ff4ff8beaace306931d093f5cad0cd0a1657a5331484e71fda0bf5d5287b0424f25187a7b0514ecdf6699ec5f85147475e4993eadf79ffb8016c9e1ef16362041c063dd373590d14caf8fb191410e62c23bc4b6cb04f3105d4c70858b2a41cfa0128b3c5899822cb79d047b1687834dd053a242d1687d2854f8e9273f8ced39e82d10d9c0d10399ff4d7aaa75d8f08a38c108a80731d31b792108ac21e09396d5dcf1f9606bff035113687fcbc695ba3d19110d3e9fe9307600126e0e0000e166ce053633df90058e0337d882c84ce184cfc8b9b1c6385556258e1de4031c653609f20949136ec5d639b1da4d100bb5c48d4f42b17be11bd3559aa1146c16cd2e160d42354eb84c150c1839708c646b064e06e04d085e3261e23c9fd105ac363000bc60441416a299970701609e3b541b6e5045b107b3619c4f496a725b6112e0cd5c4d6ea1fd55f9585981df823acf7939d974c98097d9608abefff5d29fe1c88519b20c652780b632683313624f1f36ef5575cdf6dab54cf6afa1b1301d5c0f8c0bc2196142b04c115748494c20d2c702d84c80d51c4560d0aa5f7b1bb10deba8833a06540f547582209eb3643c356a914661d811667cf2aef048b29ddb45a09a8eb2e6e12968b9bcf40d8bae67d89df437d41a0d063d912dafd639fb7c393fbb0bbcaf1720c09821c9316f36a36d0f0a663bb546dd98e51dd4ed65cbf240064737662d252742b994fcef1bac11060e9b1c290b8570915c623ffd5506cbf02b1e8671323ee0d7b0764d906442a240c7e6bbc147dde0c391e2147dc9cc9a916006d545daa04109458fd3e39803a85ef6ecb8b98982f7d3cd52cb34b0aafea94c562ce26e04b53006a7ad2f0c1937eb7d065eef0fcad34ff6ae80dce7c0e72cf471d69565fe5eebe158a1e95d8d6160abc4782328e5e9ca8438aaf43843dd70690b44f02e5bc894cecdcf8c4dcaffd72dc6287285aba75e03adccd9ccfea2782c302f64be619a09af731410f72614b85407f9bc9f1ac5728f8a38c8fa30bc1f33bc05476c1d4355e235f9b198760f0174120c32e400ea5a9bae1044194e79f42bc9dc6282d2e8e503f4afff1d222d027d2e80386c9521a4737d9f19d5857926cd8f45f99b84e3d5ac10883664f674bfd5d3bed864f302e2e503f3b038ae0974c2707c42fef15a8ac56aaef21b2cbcfa5658b2aef3ba27c27df53e9742cefbc741f42f3c644318201bae7540184792af7e95e87f6b27a94631543330ffb8cc2a062a366a7ade77c166490ae2e0206073933d7ec2a9dbf4e15be9e5a5a9ccab5d2c6cccfdc984f89970ed49577a9669247fde50920b31aaea972d25a7849b893cf16a0ef41b7c8977a2aa18e7588bb5242327db9008d12f5a2a593e14616c0a634fe6731741c04ace10c3754acdc06faa11d3a61381fcfdca365e41eaa37f516550589e91fb1fa34a7f591fc42270d1f85d3e69f297d5a76795436ecf6e9a8968ec686b575e703e3ea8fe10164f7bf587dc96c6f50a4a71efc3c9e070b0e98ef6a8c512edc3071ebe8d16fd89781ae45e010cf24eee2958dc61fa5c30699af775235f552f849676978bfbee5c752242596185527380f1cd40e18c5bef5e599aa335ee04d6c77ddaec1fdc1217c5c127374b3b69c139fa19b83c7998edb182dda062e757e5be1a2b6cb6d36b44968cf1dca232a3658fd299216342724067762365cff57e14bc4d6470e5cc75ec7a09fbaa49be4dd76f3f9626dd92b3755a2d11eae9089a8733630ab481a9e3d461943bbf1bcb5dc750292c1b5ec0f6113bfc9baa8d258a6c03bd29536f62691fa4a200ca6e24767e9dd9b1ad5aca15a251c57f7d615d0ebc2a8943d256095a28835d16ad3d6e60f26411beadd4ce208558abdd529f4c7ef29ac36f8e0726e5050ab329d6b041ee84db56cd83b9b95191aeaeb2a3592edf681721d5c45f001295e8a89e9446e78ddbe23f5f15bfbfdf1df1bf63dbeeb431c906279563457126b2a7481c6b7ba0fb4f8d8e30ebeb88e82f2b350d47f1bd243cb4bbe416b786ef6d193922cd16c5548f5b3b2d5acb3245019201f383d3047974cbc8f3160fa7e107f0cd0177ea67a79ffffd0e25e42138a03e0924702976104cca260c79f78c17a53800b2ca0c6603f2841649a411ceb6adabd228ea97622a2c3ad195cf9e8c029d218e3f3731bd741c018807db42b59a44885b40772b0488cfb0f3712803bec5f1afee58f6237aa9904c4abfdd09d24c22889d924754512b6e435b4ec22753ac1fbcbc8692001bbf386268436ba12afc57710584f4420e4dbc04a2716c5adf49a14a1dbe201107b737c88a07b91b0ceabdcdd53676d5104c3203a71eb93ba402e26a8764bb4bf069d957c795c62751614a91dd2003fc8f5b0af86174049e2867867c0ac114f1e40ade705abcdfc8e4e1458719d1e199c2f184527313cb0da23ec01afa53a2006f37ccaa3d50acfd8e8416aa705d49e058b2b82da0d7bcb3e0420c824d8136306e6b0301e501f00987c21c1b9173ab946e931638c9d56a794cc0b3351da7a604ef8d4b9bc3e8c2a1b004cbd60f58f72b0163e43b16a9b00e6eef7b3c3fd2b886ace554ee41ed11e31fb3816d1ab1a07165855057baaf5aa13f38d629f88b5d0901eca002e4d80357814a437357e0468924dae70ac5293bc734790a18c7910041f99a8efd39f673198574bed10744bfbc0ea5471f8c1efffb4556db3fb618d91d041eeb057f1d436456205315eb75469365dcfe1fdc22009c15d8515306c4fa61db008c9ffd70aebe56504c6c38c8414f00ff9a0084ae8f928824609b259beda0bad48d33b408adc1a10a51175919fbcbbe057ce4041c7be2c0bcaf9d772ae05b48523a962cb06070210d94a0b2822f3fb030e21a08226702a2870a9cc637f8c2b26660cb699dec04f55ae4b8814a27825f01dd3e8134d082f07371799664842184afea0442f00927eb038ad4018e760c4f0b746e19d21ef70a8400d8fc89230e151207de4e0c7d5b32fee2f775c3063238dc205b52c208a860d296bbcc2d67d03eab7e588b25f271c87e37a6bea86e05026acee08d694655c62f6c043209a868c632602271383ea3e6952b08c0ce28ec010f2d62ea4de050004451e460cd4c4121cc09caf28ecffb41d74ff0bd3ee48ea25d71748504112df0bc35a1d6e9d9382c069e63c60d88289e837638596f57fa22da3e7ce906fb85202efef24356e0ad964f6b0be5b2452678af4e6fea45d28b4f8e138c77d1f4321ede96b3bd0f21223a1520d7b74b1ac60c4d1cdde05d054e47f8e01d2e44d0e8ce86ae1bcc030af4d554eafca9cb325fb2af676aa3d125db7b4c5571daf742bc7f80be3b8ca1474324332a4db35cbf6ccc7bfef3a1a7c51a38bd02f494230ff4baf7a6693f9aedb5bd1ea6f80d9ce8a17b35f51b079bff1e76291297ac81bd95aa39a708940fd4ec86f2afbb97b4dcb4baecb008dfeabf9ca52f1b4dda758fe388ac68f6589f2b6dad34554db2b74860ec5526bed67b95dbdf3e8ff87a953c324a24efa7870cf3d73025020270207bf7c4be9bc8a09e3130473def0563ea4353304c5d4c3383458a0100fddca114f74e378fa06145f5faec7c772e9fb9c1e78cef7cfff22e844b02ae7457b07691fa49cd106e03b1b42956ffb91929e3d0f00f2e2dd6ed5db63974e18ae3cd459d9268d4e20bc9edfa95124920783bb1d06c5d35c8191e6d455ff0a3a90d309c7c25c9af449d5ba745fa10609621a9817393973bf4b4ea75958faa39eb0715c35a2a3de6d6976a82a841ef45afdc1f24b06a6003e0b3a7da9e5c1b87f054aa09efbad578037dbdfdd7d2133abe925be59f9e7fd683be7362ca46e37923f00bc8768110ad85c387c76ecebd8875e97ec47421e6093631d09ba734fecceb8af3614fe20eb778d06cf6bf4ec1bc1f02dd391ce80fa96cd7877c0f501bdccfe8487ebc87788acc1445bd3204323f871f3fe0a28f130fdce254200b3f1a36d71a1b6147143f4a430517688f82f7f4e40fbe7bd29f864964b3017ffed1bf2f69766afc7aa372dea1c021aacb624dc06b12227e0cf1600802573ffa4e113e27fc16569bce7616da9da64681e4acf896d45eab051c55cb3de88c2cb8e9d6282e5dee3fd25c88caf75eaaed1ffe75a7682d4b3558aad1a1520d7dea7ec1c1b879e099c0e5a185628abdc28035ff34867a855011efba09fe7ec1e080aa2ffd5d9f194a16552e7c57a9605076d50b79975130283755b4f25df301368536e93dd48669b2aa2e80a990952cf42a7ac1366c946a5bdd02671a495eda21a8dd1bd54c67042028a4ffdd5ec2e3a2d943d0cc8cf2cda0d608090898c939a828457a5ca01774cb12a1963c265f8777caa62b39042c8176de6d63ca2903c0b6982f45375a44f85fd942077aaa7564584259b29ace640b53609d67e0306e757699d01b30ddc2cbb6323427db79cd07c9dd2fa0ec56820e00d1012a2953ebaa1e751ddd44e378c2ce97cc6281162e64a8be58d6c59ff8bb73e862a6be3165103c5c1a845825b93f1921ab432ab021d3e095307f8b836ae77ad62e8d090134a48f2b3edb08f891c2c8ac3ce18492006d6e84cb725f1164b5827fd6caace9b0150f1462d25939f0e075439df17b71f53bb5036e0ff77547a3ac59f3da65ebfb673b8662e88a2722511fbcca8e191896f5804562b1b7e383952858b71ade6407b42ff952f9d7cc09411e84b1f2ab9a3c634cfd258366146ef8a883208307b6091aa6de65c7f5607b780093bb429429694e34ee6fb8bf64b1ab45274a1bd1b5a11615b20a4b3c175cdec3a376f4c04bdd7213b9ebfd14192fa8cdcbd7a3ea0d67c706d650558684fbc0284ad0d5566a75b2b315ade236f36c82709b561e59ffa63f6808137d157fa0ae4754ad479947fd47510a4972bbc5523b73c47b8f505d24eb84e77856cade1702aef08b9d115b99f1246d271f1a2abcfc6c0af38b51a7779c500d74353352c98e825e3c710b8c5ec26940e8ed90de734da7abe28fd5b132874c107198c9decee9626a57083a30d822218f9b781c3395761b903be931b19132748c4372b1ccdc487d56629fd775baa481a7aed10005d5b1f63a023854295e80dbeee46a99df02216fb6a22142622d363292953843f5c5eaca138205bd5a4654c37bac8865ba2584b4b79ecbcf456b6132120425d71650c2324532b982a988e5361c95e114dbf0a8897a312296fbdbd10762e466e0c8f45623356ee903c45420ba12d390ab8780f76c14b08c64839bdf1f9caea41756170bc82022834ffff51cb1fda1e00942a8dce1ecabfb7bfb4785795e5c05f4f1d1a9a144e404683d85653b758200b984a151aa9339324d48b5c3dd1588bab30e335e9cc0bddc6f27f226ec17aa8e9b92cf9ce5999b46ed016f40124f8ae8aef2b85f93ba8cccefb7b1e7742967abc134e5774fff2477b997b570d74571037b490ccdd4d1110ff28401731b2ffb680d28f80a0606ad8aee68c7d3c60ae79a015d5a1aae5df92c74f45211a1fc8070411e78df07ed0e9c27f4e98f9833df9d906d7f2f150391639cef8a3994f0e968096395d9f00e1a2f4f358bbe7ed22d657ea8fd9da9c5edf21440480b606840ded9be0b0d5a4db98dd9d650381c2f1147fffda3d51e13c124e4dae72d5b59c9f4456148e026157f4516f95dc1261488878fabfe755a65c644f11b78018bbbc429fe1a79d861051fe5aa38fd7fec7e653e1728cf6ce847b8643c770853f19741fca90de277315a9a23ea1843d6c44aba2b46d67de4fa5ec1b037fe37d59586305b1835ec0414f4f1c867778154831f8311806b2b0d29923e96a77d19284fbf5518976084b19f54ffde40508fc8a4ea41f27d6817defe93125e9d3035ad687f8f460b5b9dd0616885a4eb540f02792f93b2cf547646315633c8427b9b80401b807da220a671fe0aa22da59bac88d90a7e8a513c9f809e80c84338faeb66b52ea111be9daea01168c49af7fd67691055f1ab15c384d0104715430f32ba7ce080f5bfa05509a95d0328738b1dfd9dc6771515c19a3f4db04f9a24911081e722198753a510133a3c05ce5e30ba983ea7585905940c8202938bc0c6835127306b394f6fcf1e5836b1d9d6eba112badd6f08db63c7a706932098e312f4f200695bad3751011e8b5dfe0053fae8ff2d5c354f62ddae0bfe2158813dfbd4029c2f5fceb959824e2c7ab18f513e7f293a023c162119761e2cc1520075b2f7be552faaa70c1bd6318f3bd6cb6fa64224671ed6acdcb2e996661373b44f065350d0a2e56fea12bc6cfe326ccc1b64513f117fa47e0ca8c583eb25bac76dd47801cafa753f195dd99408ea4dc582564b228fc505ad6cadb22bd22fb5ad412163039aaafebbf07b00c8798034aa81159635892c737653b082b9d2a723dcd4b5260f0d43c41df65bef89c507b2fc3764eaae98e0bf6000cb36f503c8a584d84b7d8c42eff3d05d8331a3126846b390f198d249139448f86f07e50dba15ca7ea3a86622f4408d191cf0dc4f854fd1b52c50c5128c41ee071e37f714eddd1450a64ff8fc6988dbc3b848c4a8684d02b12d87e0d0d3185344e053c89f974a4694c47d54d76cc352d74f86502ff871974f3bbfc27cfc3aa303161ee9a84880953b275a7a759cb7ec9155ede82be28c3f182dd9cdbdf315969d52b6eeefa3a27336c255951e4ebf8556a04b4322eb431a3afc0ccd49508551c24d43a7e1f3895aa0d8e9d72c15da0f8103dfa1f9fb1bedf88d1bc1d7d3f34bcda9f41e26d44b864cc0c2895525f362cd7257d11aae8680d33f56cc98adc548b47bba82430f7d01bd0a50ad9bc9d586eee2ef3620f95f3f37d7e8cac4ccdc17f7e91486dd5018ad3f2257dc475594eb5e8dce5c5408195d052b4d92fae966fafd851e458143ba19bc4e5d9cd3ccd3fc89894b62d96e0de96b8000b760de82d7733c8bfa25f4f5ae0373cf9f8eb2fea7903be204931727066744d0f933e2b24a5e48c262367379d49000b65c968560233a851a4208bf2f89a2d7e11a37478f588c26a1072a446c2d7f46e6700aed9cb9a358505b60d88963dced832ef99dd989eb43cb4a5a69b00b49e02e00a618c63349140041a62acdea08c18c214f9dce10243d69850e5eacefeeca4e4f87396b6aac652b748d72064faa23c275d668c018a685b44e12637cc7f90c2ad8f3236c70ade26fc4310d4435d7514bc708e1e54757325d7d8aca953c0b6a7b2eac1e91152480bd3d3943dd95f636483302483fa22c4e691279907af25fcc833e1688731da7a85a8bcf2c7090a236b755cbb7085f446214e6b36c02d1b9a228769ec69b85f69f8a525e90a7f9b94aeb73d7834b2cf0f84fcc801078361d228138ac043d59e54c240c269d16584950f60a08ff46ccbb1b128cce20305d8a334d2a4a65b3e6d6e646a90c0d4c4abd7f5516f0c0f5fbd7caf1435063799d972904554fff0f5c7aa9ea8127fae8be4b3c112bd8a34ffb2547310d00466f706e10f1cc4b050260d320d1bda3f8124149a0a96243261a6cf78196aab0f7b08b536c16eb65ae7c7f97ada7c938aedd41a0d52b06224b348f505606e53179a1dd9bc540fecff4032f7d7102ec0fe345bcd7229611654587ed28f09bbb5dc032aa1526347af6eae3d9aeac9835213132ea3e3e71b86100aab66b817c7cf7b921560b354514aab3ebed138d8180fc004557a97be9015ac00ed49c3437f9019daef2e95cdc99133519b845ddaec5a02cc0d6e994ad5b33d50d393f0fe505808140852e8a6af9ebfd1db2d8f074ad29180305f87083f9e3fb77ededa663ae9531ce44074bea3e3bdf23d635a0102a5df6415caf4e1d780e3f2f2c0c1ff3494a1102458aa9c58979b554c3a71471f4d0d80c408468633d02c7f645716aa5d1959f1aaa51fbd377584f0daa34f2c6415bae4c2ed42a748b78f5ebc08a905a8a6ea5d1d7d791f236dd456cf52c8d30bd136435afa94df4689094ba1663622d6f737c1ac5202b315143175a7b26ba1dcdbb276246d10659255848206d10a3d87664fb557821a1515b368efe5b2263500d8895464677d7864e4d51b0d3a26821d214f94fb027aad69b1b35159600de727f7846f7a2ff3993d9386b56fa38a8cda76d909d45686216d8535e544bb8d3e6e9597d12ea42db5481b8b925e322359f1717dd83a2d6cebe47a94ad52e3ad9d322c69487e8b444020eb8f3a96e1daddef17b5ae478711141b3120c994371518ac72f9dd302e1395c5ee75b641eb05ec81b84e74d0829c202616050fe320d6f31d53b0fc9969912cc9c205a17fbb0c502e1245f91bfa91d0b0a1b0b042a2049240c6f0356f88fdf56efd83f4b32155d66943f92a8f5d1383a159f3ee1482232f1da96e83c77deec7e7947fa771f9596029c118dde3f9f76b3fe12ff52c5adca917cd59a9b95577e3e132750644803baa609ed0cc25122a20c14531d5cae26ff8c9c0b2a0772401563d5218725924e8b27a081814dc80bbc88a414d2546cd768fc937e857224e3b7d00fb22d82c788bd8998b8f79877c225ee130bcd6fd231fe95bdb48c883332a4284ae83483b2f83299de1780da1abcf41c8884d21667371b046eb4e98109b23eaf2715fbc2d206ff444fa664609340c28131627d622484d4f2824d9eb0534f63706043f1f03f66969121c524c269ee5c3f1970a86f61cec1e69d561c6add3182a252d333924c06ed692e22988e9adc9253e19f8ccc2ac2416c1f0fc947435083d20bb44f3572388405a1335403245a03249bf73b5419100278f563b92674a81462ee0251e942f60671bcf733733064733606070cd9b69ce6f35b785c480c341841251c33e2379a75c6e4fda1d91964c53fb1a1b68bddccee1f266e2c5394385d9c4baf082a281d304863410c3ef16cdcd45f20a6479df3f1bac6024e42a10316e1e58f14fdf56c274fb99fc20f0c1129d9a8670534cb271cadfc0fef4a7ee4eb1fe46e50ff4730050d689249336a46572156d09922a23b5fc30d2f1469d9dd9d33080455665b330d9a9f71bc7a7eb21bb191aa3f3eefd0537754dcde2d0ec4a33fdc75cbefedac2190d502db251bdcdc9b73dcbf9e76a54fe4cbfb707691c92bb2681fd5ef0c22899335eff3d41b0c0463f25dbd0faadfc31258de222b7d70570bc73bf828aee036cb2ac783ad29076daeabfe694ae8812aaa522db506ce3da6debb5b78ddcf357cb72ac488b47b517edb7acc80f8cce616d4c4c25b125e6a21ee741d2ade25fe7837e475a32669b30400c560c3f0cc412a78052f5f82d1d1eb1bdf5eda234ab55f26c7ec586f93c95154039e4eb248f0d8e3b72e1cf5ba208d01a4305c929d8b6b420a9a64542a39442cbb2990856e9e8b61669bf196eb528f9cb8ceb1a7d17021dd34eb15b9541e290609c44e436b99faa512b6cf606f6225e6ffab94db941818f03106f200d426ded1512a1d6b8d814337e8c636ed341e813e5507de6fb8e7508c9e2f8290de405734b3af784298853d9b07cbf098f32f153c70db2a14464c4854aadc45641c744f322d0a4d02bf608d7469fc88e0585acd1b3691f2887cc02840f8217016e9cc87bc205c113a689cbc641b8ce797c32153de0ec7ad75a0e89f251fbd415fcebf7e88a39166ed834e141c34dc861e06c3447484f8f51fbe67cf46a80a6e73a4301504aa7872ab32139d9536a9c1f8e0c584121b2e200f30ea6739813f008904035976f26bbad8af4e090258cdc7aefdf712b207ad71de30c07d127bdc8dd9cf713ef009834628a1c57d510209122f0e2f41199e01a6543e58d6416e8c49f768ffe8223ec834de81bfab71db97c01922025bcb7e1cd3fea60e752d25b4879cbbbe5a6dfa00e32adbc043da5c62a6c1e810f7072d7b42877a81e354b6b4bf13e65ecc804e507b41eacfce632feab55774216b9bdd40445eaf151c457a924e5449daa02640dcff2699c13bf9a96901c0c84c82e1224976475619999179a253f823a06ca6b8fe11f9445d4c995a7e82bede49db3422cbe2bf9c7e81154f07767b193a41908f079432d409f8ccfc964a49d9fda188de07244aa9627807332a6b99bce9e95f700553fbabb053a09f11ab3c1d073c6ae4f4b2da197e6a1754d0381bd9a5d4d4fe45b3d555d4012089aeb442fcf05b978c65f8aeddc6d82a879cc2cd24a7d5aa45742f635be976874fcfb62aa4ede08b7a27b75a3b1768bca69e8fcb1683fb083e069a48e369840199025b737408d365c45645e40f6bf8a3f39d09c758743ba5dc4916431758d7b468d451686402d9a81a6a602c18911732069ab8b2f22d0988bf0ba9a33f728cf3112abff76aea06e2ec4b744bed12d1e50b099583c89aa5941c38c4203a54ff10903cec4f18aa84884402f82cdb473283f91bc5e60f7bd319db11ffc74c4bd3e31b6149be4d12309420e967814f4fb3f5daab019a58ecf89244bbdc20b131c2468e7dfa2a33f7436eff65a8ca751bd3dad736ff04ad0e9fd8ca6dcce3d46c9ac185d7cf8cfb397c4888f043f2cc48260a190bf1e5a6d75ecf5b3f5a31e5b67a34fde1297a8ea7a3a9644d79b98ba856e2d9a9f3e9f62a1f144b022f995242a243cea676e0c1e20553c7af32bc847d0a4376811d688a8effd19f15deef6473dad972884460fab3a1454f4bc82305e80261fb92752baf4971dd19b49de6082e32602183902ad2975d63885a2a40010114a8c999fcc934724e7ec68117872c18c60e60d9e3a15911537a47b5520ea6a1915d0f2b73583ec805bbff55a38422c85d2c1f70951cb793b76412a8390f1478c98e24ee1861bbe9a48907143972a0a85f48e6ce0bb729f4647429869ff33003f649638e700988613419a95e5f48f4e553e8b811e79001c0bbc73c2d291beef22c48a3ba271c604d55a5874fc1b98ebc42f029c04f3d6b6a7223bd2a50bcbb470c6c7541f50c69de850413ba77a7fcd6cf539371277d38b4ef6374aac44e46658e3aca566394ff7e2733e6b6656cb025b71bd694d236a0516e7b3dc12dcde00696df3eca092fbbe3123b9747c93eb179d925bf536ae37c009f6e021281fb2303a168d2115686ee366004201ed70e2405af6d00ee2b0c1065118684297e24119130ae6df79671a71e5e101264114c407e157f3a7e30bfe2a89b4ae619ca3e10de20c843316111df289d508400d1d550fcaf2501da33bb43adce25c7154c4a843c582c29b0dbb9a863c35a94651acb822edd59b1f8bd09ed5778880374cf56999150e204ad46f7f4ee903d6f548dbe00177afbaacb8255664bfcf4c9d12148bbe14fd65070bfde24b1f1434facc9fae1593faccf316e5d3f75693fe51620a249db1f6e191ef0eef924980e94fecbc6a32f9f66f3cf510d66d8b0e531876799eda5d40eca97e9858e2637d258805de1e43b69f0ada8d46a29eccf0da07e517624705d085cc35da3a92d6d489d04af97e2d748793a19fead36dc40124763b8469520b36e9c6d8fd9186d24e6acc52bb791c25e8be971989ba84408437b0a2f0577fd27ecfdb38af4e67f9144e27e6f9aff7f9e282f0b5188014976934a655a1e2307b2edc3d81e74a8fcfe617279e6bb0a3e8526856270efbf2a781b0dd96e3a1d471bc4519c60109e5d216250dbf9905e7537eaf9acf8f71afa86535e08e511179f3ba0024e2305921d855d9295dd3df55ea384f678a55da3779a00d31d262434f2f4b682a33d0c319472dbf56e9abebfedcffb06233e689f9d0f014f0e885bb767a2b8536fb5d85a92b924e01c2cfca852212bd0bddb1ae3528b3c4175a02c590e484bbc8467e500cf6051a0bcbb315f0902cca3f4942a33e2a026a522234fbe3ca064d539d617da5ff1f1a59f15ea18a386159ea1d4668c93d58f45a4185b57ac191adea4ccd4f4378516276c84ecc59395461e0b740e6fb4325384a04a50f48fcd15dd1f69e0244851dba66db4120e14a3b3089281b13433f57abe60137e0c9fc6c52043f9bd76b90086aeb4dbe7b850b750b6bb53ba8e1e71a052b7f08da5b816b91d9122a9abbf2da561d5f3e6209f26915f60c1190af367478b2fe33735775bace397878f302c3742ace2dcee927901cb09d1123cb7372f419ba7970809ea25c6979607d37d402e64485843c47cbf5c952185f33be943d0701a9d7a0a1b3a665bf9570d3d4c7d372f5bc9443714dec33ecc847a1da94dd54bfb9ca4be2c1f195122d0cc042de68739e9fcfe2d045770800829006da2e1041b09f8fb11f577f10297a6bf55584f48dc777ce34a415d1d01f0e264499a0880634f5b1aee639208017038c4765b6a0da523c217d4a6b3bc59fb99818dc5d73f576583fe6fd6300af76371115c07fe007808732198eab5e66190cfcebb22340e64d1bcb555bb2ad0305a2e6f97535d1b7bc2149895044d2332714a09289a698849876ef651b181bd3a42b7b20c7a4c72fb65a8b933458822c85b141234d1f591489a4a7ab9e3c0b4312257ac29eec498ced58894ed8b4e11fabfd5339dfd9e952de5e7de42234654438f3a2830ae8a3029db266f50420b654a228e1c4bbf38fe863bc6d98402760eda3f949441387086947b15b05aecd7a24c33bf2d24e57e5db58bf89c1820ba54cd73919c28fa28246ce977178f818903f31c585e8490f09c483fcb962dd9c4c7203472f7664b1e6892e3b12b7ee06cc9bb18e0b53ad2ece96bbb9eab356cb3dfcf8ac35aed3b0dad5ade14a34c80c53218ccffb769bae236dd8d1199c7ec7511a493615f3e6b4d68f9aea112b5f97e437714dc555f03b084070c744a9b8316e3f2c1d5615de61a7f219559cc7fe17d58206ed80ea9b57340be35960c2c50b25d6ac1c35f579fb2b506c91a8acf130b7db23626b4c2a3ef959e7d691d5c9eba7de5ba65bf4f0cac19165365ea57e921e6ac30fb1fa381667f2d526a38667cdc94155b1f994fdc6662b2a4f3e11b1a4a4e256e819e3afa069824df70a003e161ea426e868b7f49fff155ef02531b13d39907bc000dbc72806374a8ee4e6838baeb39f4aeab34645e838cbef0189c5f97c6f68305b59f2dc7f4e126141ee36b9eee6da581df7a7f840b92b9c171c6e11747f8f2ec31799debd884c75856865c5ef7f75cfd9eb31ec7af0df66a1857eaea47f80973c025c4e456a0845bb004e87370bd76dc530b8de7dd85c862bccd7e730aa94ee87f5c825e93faf2b1d9a4e1dda35079a6b6a763748735cfa19057d94b664c46438d3c5899520d9c6d3e17734840724376ec7809e4270fe686803ea53b143789f9f21fe6aada26aaa3e136c23167a7027a04a9daafc6e7b62a1b07d2bc08d12781e5f83f6cda491f5aa31c23dba13f6273a97b6f780955dcc43d8dc6d23279c337d3562bd250d61b168969b1ecd1f2f90add949a96345c541bcdf1ed967a3b381dcbdfbc336d8dd35f14aed206300f5eb50e65be2a77c1c38b791e6e0839452ba0805231b5df19166df0b99e2e5f8ed5857429e433864ddb549f1725e9110ab1e0737a62ab476d153bf3174d3d2505f1567d2b5b0ea20dfa332893dec5881655ebe236b199de5ab4f412f92d192b0e352a4c211b0f23c2a17a8300c947fb2404fd65db5fd68173b43c99077bfe45bed7c7736b3943017a314369fe560322ec9210c1ee710fb3f8bc597b6819a64858b49f503174eb37065ee96a684ab58dcb7ce4562c80d2c20c78ec256431fa245c30981911ffeb78d659312172e73d17f4397c0a83167f1ee526cd5d12d2d48ffde9d94803956597a386eac8d66c4389797f7f93c53f5d9f4c7c71dc2693aba15d5b95d0ad4816e4304f1c6439b59cadca720fa365ca897bd73a4e133653d93332a110ca1d68b58dc98d26561b362c11dbcec605de270e6889f95b4efa159b8b1edf8982c2661eb11c77a2d1a0380a85fe761d053c8a894028374fe60094cd18a869d87f9903b81824596ef0f920871bb9e1a60c7ee860beb741a1d36b189dadc644bd0a0f95cde7c45e51023580f81e4245cbfc28b23968da0937696ba007e8cf7e404173e6882d027af461ce72092301dc90e71123dc5c70d24299de0cf7b26d3b38a36c6adf0a165f0653bea90f8ceb27e02a43cd541ca43371cf6308bc1b9d8bcc0b2f7889aabeaf138a610a6833a8245fdffdd656418d0327f5c322a3425b6a5c2e1fe1a8189e90e3f02ebf9a77f348b03a6235eef5443e8942df8d3f63ea33afc37d2784167613abea4fb1465e8aaab51f71c51d35cd726a5d5117784c314695aebccf967bd185747154ce9557b457969f490deca1a805117365c47f75a3e4cab87bd1b00064ce7c2d975f9768a545bf77691152c4aa4bb6bfee0eddd98e790d7ba913738e99726cf2f09b8495e3531cded6d96d5119f5da971579f4dda5102c27e563d174d0f12a098139f7c469a135f4b790f350c4036fb67e6224cdcccfb2e9ff1a41f939cc68dc4c0b24070c92a7b8c42a2ab216107c94e621a2c74d3059e3409403ca2c737acbb0d29fefc69c9ff99e06a12ad9888928e4a2a353855d4e171f0b3816973812edbc6f7cceb6ec2a63628dcb2409d5fc385c40e9e01dd1ba6b10935222e416665957baa754260ded401f2c0e11b69cd174799a2c5090358413fdc14ddc0bac60219001fa97322f5b1bbad5a7e1caa8220fec2b222bcf1aefd143e52ed8b353152322891fd153c8d8b6bc8d7e45e49dc89f0df7de23110fcd8b99b28f4edd1497b5d679c769f0fa8bd3b8cb92a035d6788d1dc8ff7f72454812fa6219192a4818b7420e2361e0caf4493aa2bc1b751847d818a08e3f59b29940cbba99a4e6fce60252c70bed88724dee30da6ebd9c4795076d17fc94e8f61a62d300867ef4a76cfe433c1087e66a4a1bbb81d1ad209b579c442db285c11a1e89c66604012f0f6e7e142b5942a5b40909b38805d1b3c762327012a89444cfd78000201753625c86f108f5d180218827ccc1e6bdd402fa96e80a32bfb2b720b85ddb168384d38b36bdb31044fc9119dda0482bf2a575878d8989e3f4a1dc93b693c754cc5b27e065bdca5deb7c254f83b21fcbe680f0e817bd9a800c7c150603f59acbf7aa5c76a3c7f0053cc7889868dc4aa5d54fa216067671fefc11fa04511ab513d65f2db00605248b974250806022f163d1e3bf385a80ed5d2c60a8f2814662a1300adf85ca39dfbba1771ab2b3e534fee7e51129b90cf92fce697219cb7e20a06371a09d1f64e21f54c2537a3c5a0f3ed5398429db3d1591f8c7a66a4a2502bf4d0702a24db41e9df2deeda38fc0101d5eb3654f75c474afab54e8296b60087598967c1bb8a0db4056163b4403ce6dfb68e721f6db933e606d9effba251e7d056513117031906aa79307857c029ccd87c719b32a80afe7c8e2ecf5e2f60a729f28e230cd75a377a641bacbc2221f397c9fb62b9632806e7e33db7a5e5e3ef7d96ba2b3980dca335ff4a50cf36b51c8c90ab8208ae8359d18a71e7bb190ea7fb40594252ffc1c2b1d6b86840725eeaef5da16ec0cc337888ec628e9bf8f1f5c5b381bf2a267c11bf6c634f1be8115b8d6be52ca1618e5906942fbb6a682e4171d849af3c973d414a26ea3d87c23999bb80619bed6c4d5a2906b80fbe8a41af1127b2034ca403e109b7453c73ab467fc7e472f2f6aed293c96f3f1b32fd713b298e060781d8b564541be9c5c79d1475835006174b448490bd65fd0fb1ae60d0ae4633d5cd17a4d0d44d5492394478b9bc9c9650cf4698cf795f64fd40f035d1b72d30762f245c1c8be85f76981758001a1b160a56a812d5df257a297b7e12d084440a8f111bdfbd081a1e320a2e3f0a9f099d032304f77f58d13991b8c6b8ff822977b20c66910606412b7c5d5e8978b2d5b75f7295524db7679b4331c5827f0f81692cb710e20c7f3e20e754b34118defe53fbea9c3a0a65134387bf3cc9810a6ac7b3b3b15f1c8e88e1d068cbcba076324d732c9f6ecfdedf19214f41f85a78039f63da2447e1a9e35a0d8cbd2819cb6ac6b46ad11fe87aeb2641e9814386dde74ee5667180c26371843b569c1103c13b119397a269318f1502761a5ae0c3fc89299a914d3faae9fc95c38e1a5b7ce9083a4fa5bffb963b2770b900e90d587096a9d33981b179291c9af15036b1f9d385c6c85980cf9580c7b898534d88c16ecf5ea245ca0587959c2fc791376a38abb575a8b9b05cc155ce4572d474d35e323942ed289403210f45396309878a57b54065877f3aaa59758924373b47ee929b0830ab75c6fd1fd855e3a4321afbce4b84d15e2f71f01ec0c1610b53b7b3460988a6d9534da8c385188d57c88973db4d5eb8e2007b00f53ca35ecf0ad19cf7bdad3b2aa68cd03fe58737a6cfd2c8b370a70e9d4b433953ad1040def61a9caf1367f02698c694b840df28e078a0a4f581886121f860fbef28995036edc9e4b9cb8ea3f83811f9c8ec5a28252cb80d7e3cced9c82389e410c36002ecf25842cc523a58f7d046c2092c63006d8205537e3aeda22ecf2f4c479226cadd47aadd4985ebcc11e1129845d53fa3023800b358ce38257275ab3c8095ad61f6aefd20ce441560804247c8a7d73591cb1412b22952a29bd18485a0058b9742f6feccfb86de074f1d19f498a16b65ed6cba8210787ca0b3a9201cf8de5541bd599a62d519a33c32c0f7fbf329578322c6ecbde3b92d1be8241e2146d691d29e970832189746f968ac3bd79ce43a5c5558b3a42a743f3127a329c90389fcfc22d60777210f3ab6be73ef8cdfc5ee4b8a90f026b4d2b462446ab5dcf9aa05e37f1e24b47aecb77b63541228f78115283a615d40c8ac4a9d51dcfb567945cb12bd9ce47d1a0e05781d9d351ce863065d12f7096ba11d5133a0f119f930d5f15ed14fbc152a24f5e9b10ec10a1165e3b747c7ff5de5c21603d24676c3f9ffed4048ebd002e5f5427f5e40912f5799587348ca28512a2e4ab012dc66d7ab9221a55a8aa12c977ede77e96f7c0a01aa21c0c9c937e13d8e4466adccc35b4525ff01ac17669a98e31cecf9df6bc825b68b86a27c922104f28c0cbf1a6fd312577ba7f27aa1e1ed80621cfae46ec385706a295bde402cdcb8c0c6247b6f81b1d4cf222908218cf8fa275b4ce29dce03e956052bd1b3a4ae1061095015079d2fbb5c8cbc3be96041e4b60a5a019c8d71a2402301e86d0f5c67190bbd013ea90d94dc4e297211be06015864ba75001be8cfbe78bdc2f73a12279798fd56f9ee918e2f3e65b8cf84208160cd3c113446f2a6894c5136dc033353e9a87b38fd160392cf724a5b591ce8818824415d6bc50b40643d2f61541ecdff9e62e46085683614d9849c3aa6b02ead05f8b7c001b409d1da3ca7954f1acb8281bf3f53f62e7e2ea324247941a97063a2588578ede81f46ce3f59e7e44ce42ee6dad846c8216d000ba5c0a711828bad9fd60ed399fd703c8e9f2f1cf7380807fa462187080b71658cd17c653b152c22cc1bda870e98d68996194894d0867fc7f57a9abcd496cd36b19fe0dd1c54300a55d5451d5b67ea969735de4fd6fc3f06ad07a307ece0074b0d80bcbfafb30a8656a9965ab4c2d8f911430b11472ee5ef1b3a2c053e48db3e82f1d4139aff10d56d5a8d46de6f3e960a806d7202375a272ee99114935c15bbf286a875a28eff62b3f3bec83b765d03e5c8d01eaf1853a380226b842dd18c453ee0720c9a70b1b53a681200b232bea0d2d4db5a1ffe3c65ab15200c8d6bd963422bca72f4541397575b8d61c291b2e4ea95c3784e75c663ecbc073720efd1e8556112c3a9ab2871c408d1df32ed653cd58411034800b897666ab7dc16846defaa9026eae1811785025a33f9d3b33b6b0181335194a82b99a6bc4dfbe0fa3bc6788df9cf8e9c7d1f8098d14c5f365ce355561bb4e0820aa3cd2d786cc44688d226a715456ddbf4e483a555b1683af231b32662d7a1061ad6ef1bd4a8e9024522d9534eb88ae5863afc33461eb6f0696a74762e4b8fb742536ea0a1e01d1ebdf94165c2547d8342d67bd8ca87191f7f071ea412153557fbf0580a723b420121e101b24cedfe97b6d897b9be8de8779c482538a8f4cb047b5fcca13aff715880e1211e7119d2457d3484440eaf0830b6f845363f5e63fe4abd50b301bd0bf746eec90ea03a36ae540b6cc5c125732c9b7daa7878a72ffb84113aa157cae408c9e9928600db33d91108e465e146488c95636715048b86a9155a5dc4328a990c6cadd4d01bd30427de3b4deaf3ae5f659689b5240209b61523210d0576b4362804a554ba98c9f31b39bdc19e56e8cf1611006df99f7edc9ca8e94c54c40e235710a42bc200249d377c3b183f596c60fc03ddbdae6bb4af1480eae36c59c0d11b3d6e5a8e5ae7506ccbb7f884eb6b1e72d84f9695e96d5b481a5d9a4991ea5976db9a926527121e96ad9afd23210350286a5b32cecb68870ff1b9d56a2acf6d8a71c610234ffae297d84125b182a4809f7c6ca9b00821d46ec0a2d6a59a1a805b9aaf57b72544f40d54cfaf36ab7d55d295bef11044015d675abcb831a4046d00d29e109405c01527528f0f5bc821b0722875e8664976d7deaee2ba2b58d6b70f8320895593a5673944e3fbd7e4040b5811df184e069928ff23e309d149381e5b25440902429a8ce5ea394eec643549fc0512a8477ba48df6d564af9ada1fea8155507ce1e45d30be966853cc2b0806c5a76ec92d7e710ba1c0b9f855a59cc094699788e2a747a0971d2ed9a321fc63a22ff5dd6c29bbe21901344665628c55001f998806dab99d9efa692bdd340de9e19c814f4577ae7745bf441344d92320a4dcf8494061470d25e1e26612336677018e4e439c870022214ab11d9e71a9b1491ac1d0b376f0e30218c7e48d497af6c62cf4e7722e56030c11d26b1ca51434e4fe8003cba95407ce1c6438a6b2c99cd33bfde34b2682b3d4c2f8e60dd11e6881b8414182ec2bc9bbd06e579158f0ffcafef3610ecf0d59d4ada78161b2d5fc99548d3a236436b2e38d47f21fe34dd9d240ac85a9ec54d1c4890ced77124d27ae3555cf47cd5dfb1f0a4b83984cfe51d53a56f2a6210620ac6f9c9923950f70bc4c5738d2e4e9767a37a91714d969ad66b7bcf52c9012f15dc602ca95798c59159cba69cd29b6a4232cabeafc8c87be24dd1f02842204cc1332b8afa3f9e09e6cd160704e1ca7d1332b890a2151a94387b675564c52bf662bd6119952be8150c8c4a245ccb22e6db18a05fa121b2b577a94c71b08d7d021a5e64d54438cefc5d2ac4867c10868d68d6d0a4cb48a43084a06f19fdcde7472a84d23abe8bcdd37980eeba6b9ec6a356949159187d4b2b9d8a874312b3b9983514787b102add531e6a640e8b8fd240484b80f3d1ccc95b649b6c2750f4a6397d33c59367685e5cd2530310aa9bbec18ecab748f7545c5ed8c746b34b0102780954347e5650c6c1bfc23e66d7d9f438c32d4903e8326b927d26088b1317c2e3c1aa6db9f1673bab5fd7fbc9d45425b9e413f24b886105edbd1d23ae511b45384614a5ee7710e7b784205456d861425a6382390a0f73fe10770c4f3cf23f8206b410e9639784e632d79fe439db98e46193784ff8ba338d434ced3382bbd790a85ea122dbb1dfc9d474a566b455f2be3fd6d2f9bc6d3d6432eb437accbb4db6dd83271f07828e0857b9fdc64eb88cdf2faccb7dc00be0a17353eb1b0bb6c0d7695e6037abdfca41b88004fd3ad06f7f07ee9c8a1b602c7d306d4e9cb8f75fbbc24c9da340f406ef9b1647524a88c356a14e78072535bcabca2006086b852c903032639bc6a285982625f0b36d3440798101c8d4c531be35db8e9311c43509c378999a52c6415d666c69ca58f6ad912ccf5d91a80a9dbd3c92988222965ae047f8982a412fa9f5aab07407419dd5d0d4fe961da0b013b9fd9f08eea991e4fca2edcca85d4f43bbdf6c3fdbd478cdc2e7f9f9f177569d536f94b7f36dcae2b9a7e59164259bb533f59cc22f97604e83cc41da5c4ec16e15cc6940177352f08fb5345e4da6ac2e2f695bbe694587aed814e117d3737154e07f59bbae3080afc2ff6beac6988862d3700b57b5bce295d8d46816cda8808c4855c1da25c99a205d0a9cc344b69165b1fa50c2d32803cffb399f0b0e94806dedc32864bf1b10178c014815f553a6be84a2953e57de36fbdd9989fec704ec9c0895c4472f90b501d35e95092af866019481205e60e4cddfb82880e5448b9afe51e9d2dd4099be398fb7fda61ddae8610542c683fb0d3750e97e37c055e629b47e4d4e1f268a5700f133d81aec8acd014280bada48a6371d198b3a5920a1b5b2b88ebdb9d4e0f1b972045c21d34e1b542a1923c0a2102d3321ecafee4494e0960c4d798602ae3af5ed1c681fb8e85d4a26fb8119acf774214e61517eabc537fbec3ddf5613264e5ea3f8413ba8d24f8482b94c0109c662e50f42da86da41a2ac34e38bb7991bd6b0038180802e4f9b709feab5b9c444d09473d458e5ac30a6f9bb0cc4b00c24d32f79910ab8e9b36826b73102aa83a331f7d1c0ca8433602ebf935c217dfd29aca8f8e9ef1e3e9f5acf9bc7fa003cb1fe4548b54ace0a4b619b2c3f207c7428ab1803ca56613098d859c885a93dbb01d7a222607e27e71a15a34a7d1d1efe0655b818f044ddd4ec4c91ab49ab18d58a7970021f0c92e99c3a95705a797a99a8b536baa6f6d31d2a74c4c3db08217a00bf8026555a6f869285d79d8a7f8db9a67db608dc994a3d21e07bb7b333c2f423a5b31471a39506bc823b6310441d9f6448c9c7c8aae1bc391fff94419da3e5a6b4c5edd87df9c3fa25b8d4a7da86c44c2406099bbe6e80789c942450d325a5c147f1961ca74b7e688be7ff322616cf4706a9149c9fa114dc80d704df620c8a9b4ce483085fdf63d3154c533b645729c3783c6f4a95537a230c492068e61091298b3cc70e90431e26b516ac8ae634910e1c17f9ee734165f88f366a0552890a246f7abefbbe6438d93b8896be71db18e964ae0f49e9adfbc1e1b987f212148ee5e2ea746909d8f857a17580237b41957ddb2c0036b0db4741cebe30e42b5983f4ffb452ffa9797b00d55fd33f52b3100a274c909c30c60c0907a2ae864b145ca41031eed91fe779141baf7d871b6bf351d82c415f00c7c848f937b98eef20768782670cc962bc4f51bea2c23e3539c6377464acd12eeb6ebbc623713a3b4a22cdaf4c312dc9b3c90d4c1603d54f738e6f889b445d8001709ab1db64c24f057a4350e9de7772d559638ce3456a3852f8bd5f94d6cef422c1f2c40c6892cddff12edbd983d4475fa59bae4dc9b9b1ab9d6b6c3fed4046559700c194b81bd7ddfbb16e7ca2b620a2541c1a7e946a6b6c86036862804e4596db4e4fa6619def02764163512278680fbf40bd6f44485f771cac100d379773d58d2a4d2f21f2eafbd306f26ad52ef2a8abc0ba39fbb9b985f4d9415ce937181466a0a24070956e562bb9d00549fff52aeaa4f4c6cab434d017588775cd0737b551d7b7979ee32c12361a7512a60083907a5e6b97f061a2920a210a89b35750fcbe355fd58d7211e986633101849b9ebf53912cab3d50a61069fd3f58aa08d9f9c5ed69e3ba31563316d25d7ee6c62b7b629cd0fcac976e9bb0dcef4f69eda5992f81ecc1d90af0b5189bb99072377c2239560b8a9df3ac9f9b36f86fd2dc9e7c7b2f2ba82b671d29f11f15777b30544fadb41b1620f2787975a02f0e64d208d2bd3f9e54a00dcff19ba6fd77963227c654c7e358042a7ab72c24c1db6842ab300091f3cd7b37611b94d732b2bca6703fa096d23540b5b1a80f80cf3a2af3b8530e85e388093464a98c3e30fccd48a5fec468d683dea74504f645446f0ce029575e879d855acc68cba782af074fd4ea41169c71cc488d861d31ff20918374900346222eb083da3251ba1ae7cac6d26ca1fdb3d0ad3595f4acb0679855f6535f8d0d954e898eaed73f65b62367857daa729c5d315f223cc7502bc90fd1ef70f73df55cdc04875b5f8e387f2c1efa73f090e4320f31d8fb62833c5a052b2405ae5886314b98d6330309c621862634a6879816a73d67302b6a1a57f10c2f3e627b5f1790dc3f8b9f4025aeb03fdc30744dfdc8c979985b3a6096abd32cde191087125e03b9878f431e0be8e353a1804bbeebaa6723c9832fd53ae5ae10cecf0356a1c8d0ab70e720a280e69bbdfae01b3c7cea347ae04cafbac9e9b3cd707c8c099db3526c06803063b427eb46e4116df13d33c5e5b7df524dd1cc5bba20036f02bae5968a1d00223444030a4c06795c308c4a4e07ebde33e77b6cb6e745b30d681b967e9329debee0e531201ed67bba102646712e7e606ab87e4441a758046cea5487196e5741601cfe3abe995ee48e7f0323a400aabed1d0da27f5fa5fe013c84b437bef2de5de524a99648107790758079c16a78b2a85b0f3c8e5cf38ca2f7f06da5b083b77dbb87da305b88dcbc8a8ac0a5917f7e5df3e201db41657dbebffbe22a128d15db509dd44af71dfe2083df76a5b6de30664e7f56bedb5cd3dfe4dd4e2aa4389a8d7dfbdd6bf3312d14f645656b9fdff1117f7ab1cb0a4b24e54517295d359c1c5aa11f7b54bfdc27dad155685dcc57d0ed8c9ca70dffda4a437e6ef5125395ddf5330ff97c7215403221ceead444037f7f641b8f17762a9f735da9bce155815a2cfbd0c532028a80c51c392132f5078808b65220e15158cac0eb54aeb1b870c93710a0e51462459776b3dccca00be6bb50fde71eeaa268a289568ca2043e9044c7630aa72c3ab7a400a6a0b0bb3872311966a40410a3166ec127084c8709ac4c0e9616b72ffde264b708a6e1370cf599631683a24db15b20fa626094e042e2099b1d6daad5a6badb5731583765d7d5a6badfbd0a696035f83b6f427cec974f1fbad368b4319e816ad2fede27764cb0798810e43ab83e723c4ee2da7d4bed16f92506a69a594d25aeba6744b736da873debb8f6cee63d4086142d209a6086302154bdb96ac80e3c25695d4eee33d6729a4a0046f06b950a7547fc8fa4cb3b9c0dee5d68bb6e2eec6070469427f34a7fc6e361d757e90afd91e382be34a0a5338144ba8084848418924610ab25d6a319ef7939294d2df58bb8f783badd537a5d4d234de0c0ab95615f10cb5487e145a47657150b9f8a8ac2898fc69d3a10a0524f404184e609182e504242758151698105984329e0866a0c061db4184378345c90e3fc867cfd995dad67bceaed076f9addbe4cd2077771daba78d49c5785f46e57cb9daa8ffc97914ea518f42bda638b647a13e9c17d8478d2c3aa0bbf2c7fb9cf113cb0af6b8f77239f851a811bf833be8bfcec9f970dac8c911eb8362f7d543594a5a1232c7b536c77dfe8d02ad9cb9f74422211cc0078feda3e7a1bca172d2bcd74151169871460fbcf780fbcd1bcb567671bb973a3cfe39cf23aa763e14e83df765ab14c29c88f23c07776c5fb6bccf62d9da1985aae1799e8ee7fdac42a9f7428a73c0ef537af4b1cccfe5926c096d9abbce3fbbe7ef44cf9efd3f686d6fed2ebb73b873efbed6aecb9ca69e145df7572cf5f61e7ff77df5ca233beba0ddb443ecee9ede21768805a1fe160b945f1ed9de885fecaed3e9c65201a58f7d7f47cc93e59f12bd8ca78dd6f6cfdb7bd4c7b2b5bbf7442c96be87f6edf0f85d52dcf7eaec1bdebf5fe78bed63a980dd3d1ecb17bb0c3bdf41b737e269c3bfe5e9d04a74d93a7bceb064b1f9f1db2be2cf6287e9d74477ffc1d0eebec478d30f81288e0f8676ee511ed95dfe8ea81b4bdf2b6f042102dc1fd9734f8ae37ee7fd043b2f7fedf2571022b0d2c037f7aded818fdfc6dbe650acc59b41d7ea11989a78282929d19413b4ee50a95695c4de9d1aee96f2b2713470b809e71d1472973aa1f376da789f0a4a8de15ad55dea91ecd35a6bad8558d1a5cea1b5d69a47cd51a291e8d1aed11aad512154d786425dd34f18292d618b794c25944e3da1b98d1b794c24362567d2e1b123839214159817dcafafb5d6dcf64c2237ea0a88d8b4b6422f09b1bf94a209d5e05dc0021e67d3771e4f56a1eef36fba89498f2e94e8efc1e71e7feec6559d5f470ede1357f37356b31b577304d2fd4804cc1c8178d77bfcf9c16f9c235e79231ea70e71c5adca32a2f46ef14e4812d3d528436b0d7df1f07ff93fd1878e203527a774070999a6e1121065f99626d910c9a3d5c444294d559175a94ee5a42555268fd28406793c86643e688e011d7f4c0bea73a38e334c581d4ce872d264474d827ca1d168349a75ef8046a3d160f8da2062f48deb94db6a8e011d7fbc0478db797344db82bfd0b8cd5ad5082dcaf2a12f5e130a4aa275afa3e6ea893e74705059ee44e3acdd39a20c1502a29ee45bba7c411ae2369ad39ce65b10ee3dc80c528530a69c2b15d3e5c442640d12547a6cca7854a19a0f893e5e95cea882873a1fb0d3940db496506daacb4d95b99baacac6a9d1e5d090fa55001d0cd19a001c03cbd1cd2fde412229cbbfa85abaf9cd2938960e0d6dcc6d37af5cf0b056edd85a6bb5b539ebcf596da57a1363551fa86a65532b1b7777fbc6f278a0aa950ab55aadbb6d7776956c7a7baaa93d675962b14dc986440f499cc95e9c6c4f9b52957befbd4b565051955c41432ec10d97b3e72ccb122c66294e94ba74c512ccea50abb4ae5966594698a5304496a5166dbd211363062b495274dd73666506194cac1c69d174cf99953056b47c332b55665644d8df9eb32a5434616940228592cb4847820c461449153ac45c46e69922a6334ad018d1118aaa78b9280e3218417379db5745fa324a62e48a4384acc8e5e1af8a5e53f2a6e69a66a0bc70e49aa1612a7279de57c5a12e5d602eeffb2a1123b336c399970bcc2a83fbfef78f6c22463e22a4bc5c608c7c415489b9c05491087d45b1c2e4226284f322cb4d60ae490990f355b1e55290400a25971114938ba404407d55f41f8c2863e49a52e0f08393cbd349d1265f684c2e3752692da2d29f9545691554da747111f13756b481e332429b2081ebfaa82ce79264cb152e231e1043dbd048e4c2c0260531b88818018f704d4a00235b9926ae23faf572557105a4522a684f4cae3af2c0d92908168ea8d72cad793ffc0961387fb8ede2546a47ab5cf5f1f418d90955433c61cf900ff5f1ab52a97878787a7a7a7c7cc8300c7f7e7e58b0f0e6d461dcddddbda7c72728fcf9f1f171afeed5abbb7f2b5fcdfaf3e3eeeed5ddddab7b75afeeeeeeeeee5eddbdba7b75777777afeed5bdba577777afeed5bdba57f7ea5edd3f16fad361dc5bad5640aa162e5c00bd78f17a6f8aa238864463059ffbd00d5518a4220ad23060c4881123045285402a55a8dd9d060d1a34aead9486cf1f202090a885aa45a802c2d385d3161f510b17ef22c8d2f0c58b202272877beeeeeea5915dc7175f75afeed5ff5f14c571ac00dce1a001e80763c6a0313cc6ada0023003bb71108c1ad467850123460c13741d65c890419224eb63b166cca001127d90bf0d90c823d23a8cc78821838824594d44feac1b435313a9767cee2e43860c70877b24a88106f60542f0489205ee98f139050dc07aaf5e4a396c67ad7a33543342151d67801af82e8f78343e1d46d7a861e3d361b407000058f059e0b5565b1ed1416b7c356cd898b5d6fadd7bef68810ab444d7b1fc2cb0a0d50a400004f0b93b6500166f660e7fafa7503771b890677f8229b29543984f341fde5459f47ba2f0d74b6cc0e7a0748608c1ba298bfe8092f43bf0b40e4a27b5a3fa3014150f17180c96278b3a9329e44dee4293afd0e42838acc98f9a7a1e1084e6c3000e9aa8177ede6b308339f3260e03e283a99bacdc8180f766479f362e3562594c1e3e9f0f48843f04ba3836ae088802a9a031ac49112c870687866cfe0949f029d96afd7879ebfce416b4d431720702721890e7e2d36174e9b04d5f7c1fc5e10e03896aeac54e8a851a6db1c65edb1eea032a17a4d8710383f765091e304ca0dc69fbb73d136cefadf758079dc55830fbc2011833177c8863a685daaeb5ed3997466b6f81661b102bc10f3398d1326506850d67542d8011807d6dad6a5b6badfdbcf4b0b7b75b0b5af63685fdba98f12245972b33b60d2a427f1097372c8badb5d642e00a9b1fc8a0a04413319765b32d0d4cb605b7b5d65a1e2ab6657078c2d21d2c1026b3ade58264db143e0a13ac5b4f5b1888bb1ca7a5cc931f2d4c2b2d67aa84492cb4b489f93cfdac80e449cf9657b80294253c1a2835f9ac80258a2a4bad6705189cec24f18c8192d2f2a4224267470450b42a5401565973b6c2d3955814a31e578e909e662724151183cdb68c800ac7719c15d9374978928d9a8c683a0a941e28247179d223cbd1079cf4b0525466498f2ab42094f44821294d093db6182561420f2cb4190b5158e9b102d3cc032454e9a1a5287c41abc228ed527f8c1b748bb6ae93302a5d62c0f4cf9e332a60643ce99e3d6754ccb06054d4e87f2209a8c3708a538f2935fbafa9b899f23df941a414a51e5298286b4609fa1b018906f79cc59eecf2ff63574cc83ad4aab047512c07bde365c60934169344e33232aed0dc120d11f477264691d64acc2881b652b068d076cf59ec0d0d2ab11390446164333054d4b0e2031812642976d0b7948ef5edb5e38a7a083cfa57a4b4eead1ce9d7bab2550b92962d974b7ed15a90c8bea5f6eface307dfdefeaa7c071bceecb2b563fe1ded9ca356fd4e52b2cb9615cb1a45cf2abc2c6b183da8bf71c97fb9e0af2217d8afa8fbaa66289a7ab922dbbe46cbf1533ceaa840dba8af0dda69fb07e5f83a6b503a526ecf1e7c28da75fc1e47d125de5bbc567d774cb75b3b3e25e78341344d8ee20ff4898b34321ab52719ada98b15b4bb01dccb297b3bd60d1b59a35aa62a55d9b441ff0160740794a4a2149a8cae5f6270532af49e6002aecb7e1551dbc50aba3ed2a6235cd7e746d7b1ac62362d67354252b3983a2255a34b0be26a9a5fface1914a4edbbd47b622d82d1f769e6fe0eb97b08e5fe7e1db978701f73f17e13571b16b9747fc5cde954d11757746cdda0acfa198abea3f883067b80e01e95687f6a995021216be7914db4da7e22816117fefc9c08c32e0e7f16930cb9b8bbda461fdccf0d44bb70b9fd2a836e6fa305501b8b738a46b4bf6f969d214b0b33a8acb2cd3daed3fb184a5c6d5a4727f53535a6bec8ac20155d525965794f521cde7bdeac792c3fe86077bf4d173dd8368f8ea56ff781c49f925ee78d1d45a1b4fe3a16015344f54f3425b7c75f71fd0d2afd6a77c6983e904a47226030ad78abb58ea8ed270af5aa71857fe7552b20faf10864e755757b4fa5bf52fa459efa984c4ab45e478b7efd22740c2264d2666d7374e5fddc65def26800bab3d7a2c4609bfbec5b6d0aea8d1ae0711b29121f4850afc1efc421746fafc5557efdd3851257795cfda88ffa0df4d3478df48ba86812c87d8e48912829345ddcf66da8df60e77f679c95f58d1ba08ae8df54e26ad33c4f44f528a1e9caafebeac77dd42fc03ecfeba0358f3c63113dae7ed457fd4a35aeb6a7f4f5d3d7aa5f6d23eaf5afc447893b44c00051bd1e8910019380e94252040c109ed73e5f84877bfde1ab463faa2cee9fe7555ffa9112e1e845af373ea31efd6f8c3b5f448f2efbd28d94e019551c87f281a24828c93d4adc3eab258a46a2421388990a6b36f7f3a94c61082ecf8ccaecb27ed9dc6fff65af29c198ae3421e18c36f72ba751927beead134fec922e39b14b8a4604b235bba46b36d7c42e699bcd716d7e3a5192e3e85115a2322aa301ac292481356ad4a041b3b4942307498ae2cf8f8e4ecebb3651b2be57b10826b7a8b188116ac4930bcc7d9e31b210f5f55fe7f5a833fea847b2b2eadb2094bcf2c54214bc2ad3022bd22b94b4f6099daf104ab5a314d54a631b17c58a2e6952514c6f493c288eaac63e07f382fcf6194071786f3ffb0a98187c6fed27828077fe3eca1431d91215eab9625fe9cbb67eb4ad97d93607fc666390b66d6d4b8bbc310a25adee9cf407d3c6486563280ed302fb58a462a60dfb3489929ead688f8d3ea6d1db584e37442440c59a2362bf0405169c5ca8c713d079fb7a5ec0bd5d0179d44864b5414fd24b8f458cd027925ea8df19573bf8f572a5c6490980f5d7d4eb4f8d9f7ad4a7c62761db79c5b6938a6d8b448f4d1bd60a5dd2188d6d238dd531a6472221bc5e2e8d1a894840e9ebebe5d2634fd2ebf5727914ec803783c017a818b9ea1f71856f74fd20eb33463086852663a490418c511263f6449ec9e10972891c9a72600aeb9a5aaf67d4bd2426c98e729abb2426c9ae6e1a773767eec720d22fbe24263bbf2426c9eeba777edd2f8949aeb31f750ca85be0bac6fdf246d0b3f6c67dfe1af7c6102b070d1af7ea7b6fd4a8d1ba31c4dafe9406ae5af537b4bb6edbb75ddfdbdc1bf723508c8d7b8da449920b8a111463cb01b7a018338ef03c4a291d29c514079d94529fb5d66ae9acb5d64a29a553b4d6d25a6bad94529aad78d85acedacd5a6b6dadd6564c71688a81b51587b556bfd65a7b496b2dbec1db2e75ce568a73cf58abae14d56590a8d2c7b456d4fb9cf306aa06fd26a5d6526b29ad1445524aa9a6d4da9be7eb18dce1b8c3718763afbd1b9c6b3738ee70e824b79fdbfb06b67de72ab7d56b647b1b277beddde05cbbc1b1d7ed7577270be78b3783ca5a349d668a2f77b76ddb360e5f8e26f99005ee84dcc959f4e79eef50388efa255d12b2d0a95dbad3c59f76af7b3e750caee52cb89f1d03ee7a1b77fa28491fc438dbcf74733a42a716751aa24eee64371da12c74faeea7efbb7dcffc29fbbee918383939dd29a84a958b76d80ce99625f56b991b1a74dcd480044de726072414103ee47ce3061876fe9c6f78da59cc6c671c9eec8c030876fe560e5e86f4dc81e382366739ae862336670396cdd9a0c4e666376ca9810a8ebc51f30cf7c3be4928ec7b3f6c61df59d2153430792fc4c84c21d3b219b57e20cdae3448997de0f5b29d3d53c133d46070c0aa66681234c311a784b540481c60010509e90ad212dbb2b132c8b6d5019b5073c0a187292430d44ba749939cbfaf634cc0129a5031acf03169ca89e18b134f098cc106269d2a6452f4cd4ac830981743104b7009455d0c4d4eb825b21c83131dd8f2f8c304d92c8627273f9c182529e18712a6274b7e3429aa5204f362c20f136a33193eb0e4078c89862f84474d1586155186d8fa67519678c2e950ab42a638af598d8928706a90d2c40629566238d1a83d67525c8891468a0d240b5278505531d3ba33cfb7879a73ce7b875c107cd3af7f64eba074ee0952588ba3dbddb62be309adb3e70c863755681f353386d03c3ccc4881fe6ea061a4c13036c070820a309040bed1e0130d3ae584084767bc1cf900e648461e25bda0b4cb6f591454c7b9f33e300744695027b5a38259dae313feb05801b570e1e2c58b6305412f60c49041b266d0a86103002ffcf9eb59a4d37c727ad51cf6e44a5e3accab05ad00086000376edc20000ea19616d779a13e2f7f1d06bd5287404f7a2890e8e6b80e41206d732caaea8fe2708da4718a32a13f4a5677b7d65a6badb5d65a6bb3b515d7ca430577ef56ebc5b5561e2ab4bfb5d6da5ab3b5d65a8bc9b7d65e5aa9b5d65a7b456badb5d65a6b3d6bedb7b364684fafcb5e9775a8ebfa4368fffb41d0aef5a2eabdf782f7de7befe675f7d68c3bee5e226cadde7be79c2048543f08c869bdb7de5a6bad76c35d9e5d9e9823efbd97db26b74d8a290e71daa8b372b7dedfeebd3af587ca9c73cea04aaf7fd0aedb7b76ab7bb31f04590fdf6badddbe8fdb3008125dfbd9fba6cd41699dd40eea9b14476a47c5d393da51599e7b6f8f4f55f1f4f46c9e9d3d3fb5afcfadd5faf60189eefb7cb527fc6ab5f75a8b83c577efd517e8de163e55bc66399cbb0704614363f2e14ad5d6cefb7418c0c109b0b64934101f600eaa2a1929c551ca41699d8fc90829d0493d06a6902b391425264a2328cd5a5532528aa394da5165150f16cab55aad2664b2e867803a95f089762578c6d9743472a7692384c27b7cd8b051a9787eec1552850c096148085a488e1a9bb0874d0f143d60abd5f3c3a27ab9f3bacc429c17bc601ab88ac87fd808a9d56a405688650394f2daaa039ebbbb7b0577d8bb836ece49575d5544f6c694bd70baaefcd448b5f6de6de3a6e83ababbb5eeeeeeeebe7118679c73477d568cf3e79e73eebacef3be1a443be89c9808ccc9b19bee54965277cff33ecfc999f6fb9ca26a543b83b46a72dbe501411d46a374ddf56da523ce41a1505a6b9d21a21c3b7cdf0853a9d40e49546307dd2110dd2a1e90082889ae63a9bdd65a6badb5d65a6badb5d65a6bad7574f7fc5d1e8968c085abd6eed5bdbabb57f7eaaea3a3934aa5767676542a1511518f4f1895554e1e4a1d746010310407b90811471fde7f4e854dfa449f6a94299bc640a21ac3a2c1112f81c928c42177538de85315aa5b6a14c7a0569916d047a2f5cba68fc2941acb5386e90b3124697dfea49422a184e6508ae4068922d66ceab02f94525a4413344529a54eec1d4a2b0e4478e0043e74608511580e6cfaaaaeebba9f212165776fbbaeeb2a120f605ea0bd5cf9f1e440a2bce9edc3ed081cf6f6b38aed618448a20ad9cb8531fe376208a618bbac6184525396a61a0864455071c66e7f99d43cc984465f950f46cc0050c43d7387b8730aa625fbbebd976969df2150d8778811ec4b44d2bedf3af364df1fd27106cdbecf030d07f645d3b46f1a12f64dd3b46f115e5eba0a5da6cb2484d3ae2f5ebabc340dc6defd68632c44d3bb80440a2e4079c900b36d70e802b6865440a4400041800922ceb68fdbdcb80104961940f0b06d8e7d69afd76bcacd21892b650389364bc6daa06d6bb0586d34e55463ade5b66ff9d93f6ccb83990e98e101cbb64ff200c5b6df1a62b2edeb506261dbe721dbf67d70a01467db0fd203d3b6df8107b69df960c5b61fc20f4c2f2db0a23073b634c3b63320901cddb9b570a40993315a509064042c2cd828a4783c4ba66bdb33d8be3b3051e605ca832e75ebc60e4580a006aa103ec6586bad7fcc9a272d2c86e2e9c598374d80546113b226949a6072118e8953b452d3444d143557d46c69f1b22725b050856e62405816bbf23302a3950ce94aa8e689858ca9c86789a61f198d4acf12b05076022a3c163bb1e4041a27d4f8844e4e5025e1d44326cbbdf75e36489435c59459fac1060d0f48c491648e8a52aa906644eb423ba2acb9552119d9131dda0e19214cd03fa0e89222a326ca1346984ccd494e125d34193831d06210348180a6759862429b241d567852c44b87189ca461d241c624044cf88726b8a933a20967c491114959ebd044d1e606ebf006ca9dd8e2354a3fd630717a87244eac2a8c628a1f51584159739758ef1025ca089c76e80213c10e47454d453bc8a614a114bef036806025a9e0c3942f58b4dd7336850c8c351aef399b3233010833539a76a99f86294db08af4ef399b52c5192a55c2300446e0cffc16e4a19c4b3ff3d72f73e89f96b2c0df11756c624bac6298432bea5c50ce337bea7c39d3f89773884e447d8ef8bd8b3954ec6ce888e564431ff42270a744d47ba2fe1cd17b1d31e7679b0d72306d80ef2dd9d068a858ce1e76a9cb09c410bbd47ba6d99a875c3b3aa2426a9ee7c9947833a8cc479b7b8ffb12dc9c36f7a56a03c1dd9a6cee37cf0a4a72db6b73af83b2d8a5dd774baa4275ac5b52cd3f9f6e4dd306f7155ca14b2e4efe42716cb5fbdc7369e615b93493c5855c9c79c1b46eaa0836c7856073f768ab2579e8ddc7cf81fd5c57f46f5265713f5dd8c73d72e12d147719b11125b91f63dac77293825ff7a80ae1e7c27ba4b967818db82ed8c7d78fce09bd7db9955b93d1e67eab71b5cd4dee5dd034978f9ce2ce6883ef91b5770a4121d0f2a042add6745971ba3c178f0e9a73ce39e755b5bf01f9f4ed58040c10f2e9577b7f0392fc4b7e9109ae7ed8afbf01f9f48afef68fb8aab8ca9ff30884becd39e7d7599c5b67189651127c2ae2a2ca0261c4788d9594d0df971c6c73471c8c039f2ba238ba073f3f75af0d76b00d96dd1a8a83e7c1cf4e1487eac1cf6d288e9d073fd7288ed4839fc1cf4854686baa2c30a8829e9f3497d96036aa4239ccb1581592f1e0734719e87111e61e7c0c23638ce573628ee12d542897a12cf08fd0a08131967329682c679959a682b1cc91e3c68d5d724fe44ff0c7aae7ef1f71ad7a80d4bf2311303d4f64044289904fff882bc7385865818fc7b1c45a1c4b1dfe58862fc6f2398e5659e0932ec6926c31963fae46163fe1586a9fb1958f36f89e7f3c222e8395f01266c26828093ef9d365c5551e2fe043c6a7385815c2f8e9712dc44e1ad3b00c912345fcaa2cf0afc81d7134b0e48eb8a3a31cd59554361a734c2cf118d3250e017e55a1eda8b2c0bf9ffa9e3127bf6e4ca1679b0cb41da58e8e36f8d3458ad3c523e63594045f2566274a82bf23e636b94649f075c43c0525c1e76855686be26038d35e18a68b3608eb621b7cd8069f3baa421989b2c0cf6a9ad0fc52584667311b3cda60ce98c71fd4254397d1dc13f75431e69e9e36f89efd5a059817cc0d3e90fcd2d9bfecdeeb44164c3ae7c11e3963d206df836ec494fcde52f27b1dd43352ceb10450d71d73acb2c0ef9cd0b3ccb1a6a6a6a60d7eab0a3960b2c007a3d8e0e7b8a0e94ec494ec5e8b9692dda3c41c31487e308319043b2316748506fc493e08165901195b3f8b606e95df77fe551ea7cbe6d873a2714adbe8a82c1087f7f33d2cd6dfc0f74c4524603cbfe713ecc6361c5416f818fc2c967a83ba07fd3d8ce679b40dbe3375e07b97fc20cd20cd20cd60fef2c17798831a0cc1f73e1104c1ff3eaf29e1cda0922bbaad2ae4faf7a2269f2d5ed0dd779e534ed90f77d1a78f7a1df451e07ba223117d54163864dbdfe8304a823f4170aa9ad0df7bcfbd40eeb5c1df68756eb40dfe26ab186fb20dbe0b9a2e72a3ca025d1ca1ed57071feb2ab43df8215985eea3c632c49b2be262568d7eeb256cfa7acd765a43700cfc0625c329f404260620e00d42d8c107f3821bf49dd20c5c844d472edbdb0ea60dbf42039feca8c48c9a6962e9d08c00004010002316002020100a87c442911c87f24c14dd0314800d65823e665c401f88435192c34008628c21c4004280310418620c62caaa0ce82a27d81a1ac6c4d01061b5d9edcef91f453135597b57896b298b5c3fed1607cb8201197f8f5f0b436057a8d99f0bf9df4b0982c9d8a91fb0b66e869a4f43fa1ddd75ec69db3caf7c264881990dc6a65fcde8b6eb2fd58728b77d373a70d78b6ab8db30c1258e45eaa8e9bf1378e20dd0f39bce6dc57d9ee720f1fd0bf4ec72b18683abeb89f8ecbbde6857bfd033626cd43430c9911a89c73558d1ade1cc59ecade19f68984a28de704b00c86e1033c924462667a000997ad9e6656fff6e3aa9e4c3221c21951df47598f989bfb3a747f91fdfadc6fb8a6910d74f90fdc7cb2040a317413834047e19b9d105e45e54c75b7a7c8de76a4a3cb8b2b970206acbcca66c79930d6e481c8615bfce2dec4810865abf6c19f6a0c1c2a98c2f23c3bacbca2dcf7f44cf630c6ec94b5026011c8f8f599dfcac8e5c73b2d5dd7c505ab97fb19c9ee6409494fa22491750fde0fd9467f535c948f53a394e0a3fb5a51439a474a43ffe0da2f0fb6225beeae4d2bf425289b3d7d24d1411cd89049d38e1905cb5c1f58c5a7282a2aebb4b01a7f3cfcf1e91334257e1c78ba5ef2af4f6591ce6e3da3c315dd24bef1d6226f74ba6169fd7c5f7107c2e78bd0bcdf326af270dc269fa5692034440a399b139884ea4386b2e6f1818c921af102f9a4d4776d6e1dacb78121feb114e2da06156ece0b1294d364a6f9a945644790f06d10b189394897602912627164d109876a7d104b94a02d963b04c98adfe403829338635d40289c7bf7ec49b1885578e65310819420c4340b0223899f025f244a068b79d492266c9fcff60100068c9cf3b66322c9a0e59f6c641e7810e1f95b821c769ddc56ee1acf5984945cb94453feeafde9aceda418d5068c6ddd8431a9b2431330886538fb0b5f29e2cfb904739c92981f50ba5a8a09900e1cbf7ce45b53a3412d2199c79f3d73279ce7bf8c76555c28536b3115e28e1cf42d426884fdfa5657aa83f4506f8f2c20a335085c96c98e8c841e481cdc5f8e789bce4f5fed95e47bb40a8f0d98c2bb2805ee504f04ea7f02d6119965c5fda975c2f4f89a25a6b61b4201ea3aaa0a9a9f0ebb8dcf3e12b9c10b0b18ed82b3cbd7e99bd98d85ffcc22551f2a8ddb51e579d1c2839cee2b99994c7ff68af798c5550d55ebe53f2fd9c7cd7fafe95ef8b372883c2fd75f738a45ae9d2835979ec2e8472f86e2e9dc91b3027eb487aaf74b275c9bb45fd7fb93b914fc20c0163e2556e6820d3e87f737c6b4167f9950cd460687eaeefb159345275223f0d26ebc0348d4feccdb3c955e74251d4956a1198835f2549e842e1725db120c2984255cb18ae10a0ab8cacc0ecdedfc96e82e6954497942952d6861f9b4d9927fbbd06b62bae756af2d71b39b2891f5676abde8076e883d075b9e6df8bcb3856d6e558bfae510b77bbe76aba13ebbe1c8ea3c63af59f36c84d316917d238164dedec159226a108c8ba947c9c62a0c03014eb9c8d509ffa5bc05e41607c6c1dd535b1a1aefd55f6db9f96d7a3b4266d2eb39f69bc491c6705170635417c76f54703283816e6819c50faf07ce909da0355d728e3cee04d1a8a8918516c52d4e508ab22291c139e499378066fa2098da96ecea3b20d632bee696da3f856c7114bc00c7c795d6c50aea4a5f77c8e8668e51dd5269c2ef02b1c48dd6419f6cbbce964b8875173e27282c87f2e351353154d91a39bf7f803d6d3d51d912d98309669d2010b52e5839308a2069b02be7d3627223b48889c6cb50d6cfe56f7bba647e6faeee75aa747dae0c3b80d82a1b20897a22569a1aee7de6dec850fe285470d4650fd7ed5bff265cf56e3e0b7aa584af25fbca77bc576d8f8e320a50a595325a07b4a7cc9fe66bbf2e1dfc3683c6a8f769f2645cf49f1961276f04f5a9bc0cb9380747d1075107a28e7a5b6d071242cab1cb1e0ea9e3f70a6e4bbeba8fce40b75d97b52356f987ab24fa187d438aa92fc23803271ffe4d658dd7f9d4b4fdc4ccb8e39ef21b13ac9f116ea22bf08059a1029821fbea8ce91694f634fe3e20670d28b1805ac5bad5c52de942e18e92dd1950384b594cf9ee9db5fda8399a017dc3204bd8ca37c8f9393edebcd9fd887d35a00d06b25c7481116d85c65c45232f6495ad569fb53fd2efa112bea7534b0cb2d399b4caee03b8d601c6618d213f97632f991829a2d23a0e988a01184ada7b7d6a20ab748f24b75b7acc32c90d74eae950073858dab1ae2a47d95f83d02dd2e42ba19c89c073e8394857ff25a567ae5be5d255ebee0367125100a3d1895a5c4794c0679555eaf33c0f7fc85480836be9d8a913631f4c1fcd008e5d0d9df2ebc2d77959d0417b9eb31165b5bea1430194084028e88c6f2955dc9b9bf641c3a6a718d1c0ae442a5378d747440564a055d57a5e6b40dbd02471728212291f7bcaf2a6ccce8b9c4c47b03330427cdf29f9263bdc8cf8021c8cce00b28bdbf0af40bd2d25e6b0476e5eb662ee0ef846570cfd469589934a62d5cb8eb8ead95dd475c37147410608873b81452f58247c2bf07c80f241789faf967072df51961e9fc4b31927fa71ce272e5c8be516e761f8754f05d74b9bc8074ff31ac4eaf56e8985bdbd9640b994fef6feba9e81defd161185527321d3ea19f3cf19275ea7135a42da5955200b2a990c4d2e6625f8cb513ba220f1d67fd3fe90b28eda00bdba9fa161133374b3d69d9663794b9d60e423bb4f92222e3c011f1367d71055c4f9e49f007cd48ef0c6b59517c8d34f9cc2895bae29adca51953b4d75035c7e7b437a5619d2e369b310823f197b2411afae924ac4111d40eeab670594b05482e41417a181c89128e3595a6d09c0db69a6f9d5693a3fa789ae4c1265e64768fb4ba30d5f41b7e896c5857a57722bb24c2dc61bd42f36f78b5d972703c07644f72c2b0486cdbf9042177938bd4194fc2564851ce6342ad4d864df71fcc4d3c6755480c9a1ae1eff08b461d3404ab9a28d109975dd48eb47b23a73dc73228d20e0d6981777c23b0be501a1084d4f5cca8b54773e8c85fd612003940f499e88862c0e7e0b4bcf235a960fc5e925701b59e568474ba462a9ba301524dfe5bfea76bf83959878a77611885cb2265578cefea64cc9a2456ff9436bb136ffc38633df479f5325a5bd0587342436c0a3ac35da5f019d2f536810e36076dc04219cfb3ba8fd1fb3987d7c4782e7440bdb1b8eff106a67e52948bba04147c8cf4191cee1aec8d2df88cefc3ff8cbf5b353e4566453b35be6d199fbe7d073f90b35a7833bebb682133595a7c04631904f560f184f8b8240c30dd5a0e449e2db9cb5127c5a7ac0f1a70f57da79237af81cd81088e977d097e61138949481a1137b4de92edf28df8bb787c9102ce7befce19e382e5b761ad2d03d3b71b0887c05029fc4f7497ee6aef1cfb1ec7172feb4fa09eff82041ef92c32ec5de519defc68c2736e9c3edeee16bd2f794eebb42bf65dea99b110037f29017aafdcd7d91d036569bf32e00d8b7da8925ad6fe4eb49316fed23372c42983cae806b82a4f7cc58597a8f01fa84db9aefd1e48f975b892764ad8b1c3a7a9fcc9a27aece21e5883c40bbe52821d8c02b40981d6b65fefd7922ab78966632ebbfa852d3d724b27093a6b47824b0a6b0d88d2fadff1f5901abc0959139faf3fe39d1873be45e5fcb7ed134990172dedcad8e998158b2bbb5327e5a404d95953e1f51ecac2561767e18e45e2d0aae56a8c471d7aa7140f8086112591d9cce551e38f0ebd2fcee6ca0cf604986e4d1e98527302a132d103a27077a31d525c88986c67cf4a82ebf0bec430cc8f1ffe8f92a88c69672cc364ea2b5ae017ba9d74188f0c75acf22dea894fc5a1cdbcfd916491f296fa19c755201e98a3a190cc5ea987afaf44006da82152eac9ca23e503729f814944a78a604891d0a8d0729dcfafb6d58e98603c8bc8eed584fe24c37ad1b7c09658f982fb7cc585f4f8e7e637b3be7c20dc89702920252588efbbbb8bc3537f892a44958ce2719a15f1a5ee67e5b42068d8efbc16bebe6dc98000aeeb5cc297310fb464df60bbd49aa5265cc59c4134a009487c1c97aa94f53c318170df2f91110acbc96d6a289bf75376ea0ec600c3e52c5cab8c0743e878335034ec53ea79c790e617ed5ca5c6066885f1ec090f3255dee96b256f02e8f7d36fb9c1a476cdbfc23e3d68d2a31ab99fd207e6c60e5a74b6cadfcee3072e9a551c4118f3e28faf0be5bdebae8015ca5a829732ad95e599a9348ed881a992c356381a5b5f0df5aab843e029e0f24ef7e5b5861a0291b8d5a124feabd0d0c8591c19ccf10578d813cd4809e55b18f625f879221052f514ea5629ae02e7e80ff21f9e0f680cfd0aff1d1b821be69b73d9a34fc08cf43260813c0ff7a646541136e4394c5c584ee40feb07ec8f1def6592c9b624f73e47dd7542ead4b43b22b47c40ec1b8243ce508114229a823c2d9a8c8679a0c7133a05be73b83765153decb64c12d25895ede4ff315904d593edac9a0bfe41d5d958ca9c999c775e619e2af9d6acb34d2c7f521e11ebef4dcae296c28e304d14410664e6cc9ae8edd0bc5eb6d2c68114745428a0c29a69a5f0546b2d3d2caff559c304e074f7e5c6727ec59edd35216adbd139e32bb199d5837ed303550a2b5cb739ba2f977aeb92a304c20481c9b834e5a2bfc25bb7d9e547f640821ba1a82c5526abb8014898b0b5d051d9cb5f28a445e19b3a2dd950c01204f1c7669ae2131694420c44ed42cbfae04978fa5c57548acc773861715ab9c7f047d72420fa8adde633d1156d5497a5329dd6da7c2b340897cc030917c67c974e145fe28b04d0fa082f6270fcd7443a1dc948c9c297f66b40da218fa736c8e30d469189d5fc6675bfc5f9b5aeb027c3dfbe5df94c11f74226ba670c628ede39fc2e76321503e2a61a02915b098f6ed2584d053360e58a7a6a9c24cf8b7704ed642d943cbc97d07a992a1f5ecaebc20401e7a0203729716ba6b31ce7ebe75c618f998644fd9a890b581586d596240c7626a19eaf11c116e401875c37f5c7d880b10f92237f941e269710c77c07a5acc91de1e4728c5c4d89f07a235634e62f219f18efb3616102006a12c9f03cfadba5514d5a52ee8ef3e3bbde7c2c413a2146ce87e934659d4504f71b763f423ae176e6af2a606a6170f834f82346d632448cda60f28f874541cce70ef4136548a07498c113394e64a250902b398edb23d3a2aa588830149328f483ac398405be16f72fa02b0c214c2d2564c4f7338899174d7277ab2e2e81cb2aabb7624ba23bcdccb7adf73836718044eb753229d835c634dd9e04f1ed9c1623006d9359f2159fcffe3e4f5acbfe2e0f4a815a080ad0735a752a6b2d7b378c6ebbb439450d7d475eaba29ee3a90314475edc8248f814f88aa0701cfda12108a323942e5ffc5446ab97457776a384d1e7073b85d9e8717a91b9ddc1298f4221817d378a7f2f0ab05d3dfafdcacf15462448839c82a2020495d44204bc49a8fbff7f19000d8393c670b92f5e28f051a6fd336f00651d094e25b23325c330a803c32d013db104b79129954d725bc94b807d5cac913c61b84696ce5574615d9d5f6b5ee87ef037c3ae921a7477cfffb77e9e76986055f79479bf16e1c572bc58ae94842233149a8845a279ba6c67a8e6fd357c1cc47baa6257fbf55bea7c025873bdc1ab3374a3ec4df449837d3e841ce9a90055f78f5c05e9f5217e1437c09c05135d35e3da575ea1c2ff3f90c11cd0816a01ef9790c159b19dad415457589181ae8b42bc4c9235981e0d61ef29e3ddd9747826c5f97aecb0063e132857176e11030b302c1d3ffde49776f3082c3d30f3ebb62ffa322861e5a88b238c78d965621ce69d1dbfb1a5462893067f99452f2cebb646401be4550fca1e268fac4efdc31b1f9876d55bb6f6dbfdeefa8428cd0bf3a71e3ec12ca2d341395aff4e314650fe31dae67184ed130bf2417a7a1cd577cd71b3c796e75a0fd6ce479565d2f24cc1ce97aa276b2b9381644c5bbba4168c7f81147e60d5f0874ad8409424d7db856373147d036c6b2eba5c3a042d146cfacb30ec4663701fd2a437f2f8d155f3b8cac7947f0b226d3e25891cc7a5f2f7815e9ee68245c23ab9ad76683f27532dfef21efeb63b4288e29d8365011a4335e2385aebb80d558e598400ab5be7e43cd49d1be351aff492523477b50c6fcfedc8092456d50e2aa89245a932feef1c48415f849ec4259165bcb2e7e2b3ad2782b9998ad1a8f4eb0e1f2a959a2634d643e5ab4b0bf48136b810d205173c7799a3ce7b4319821926feb0c756d78f8486ffc99c46ee5756e4fdbbf15c894814c98a1d5346e95875166b22bfc010c74936f74dee4a177b3fe1402f60540d13c36700a8b44f7fab7e4106601b1f9e70a03c7b262ad83a9f9516a01e7c7f9b4ea9b7871970f8c35e35f08387770dc88e32bd6ec2ba924b91af8830fd36a33d0837be85db1113766167f79bbe241969656f848299f88218757d2509141648a25db98bab04bfe79e5543ffaa492f823fdf4adff6369b37bb93f6a607d73e534dea327536dbd957edbf298da5d7d9afedd156f54f96fe52eea7e407536053cf7129c1e982b8eab2538206b3e0ee40f81582cd970efd5644fad9cf72a46be60c6f537f10a6f688ff4a152227c333d81bda8244522ed828692b3362e1e1489da72b95e14c402478922307856c981ce5cca51772a8712f661d441d5126f9d7cc9b5d821395c7cccc1774633c06a7874c1227bbe284b8a0695582c685817749f7219364335e07068e9264512fb0ea7156be482e076aab1ff85b059a16a99732343d0c3f01b56b381724dbde96093f716025f098329b9dd7449f02d00a1cbaf7582f49e89a2c6347477834cc210947bc3bf93adf364c0e52b95a1c2fad7d8d46345a87b2d83e0b0c2ac7e6817bf6befb6f4552c4356f3ce9bab94e91c835c372da1abdb896fd86e1587567f86506b25ff1cc8137402724630d1a6e6795f0b0b5fd4c94b9a31a81a40913a5d5251b0a82f77c0dbf6f4375eed7e34d7499c9d65fc75fcdd5f839678c6918b015882cb57c4c74d030fd5e06c60661c23b3cb3e30aaee8bb3c66948f776a705da9db7dc6c89728a0716a7058c7ae127dee1c63d95b75324ab28f68ade867531222cbfbbbc7426fa6b245e29c0ce08c05cac466e8d6067f216604e72bc4d0319c93c69282a8325ee3973d5a56ff521dc0a62e33379ed36108e069c38247f2b42b3a1edae6fc9bb45f2648a3557e4280ff6b9209ab9c60821233e81312b5f372fe9de589d205a773c8043d33c16f8ef38462ed9c434624c213aacda13eaf674c20d75d712b4e992fbb2b3188ec9776a319147de8dae1b8140c1f7dad7d16869105dad409a0dd0ca53244bcccb90a397302fd208d6fc4decf8a9c147a7fa33800f5de467238164ea008916557b9a8f8a19c00bddf4aea3cb139f5f0743a83641b764917b8fa07d047d83609ebcbcc9ccdd4f3a4677b7e7acc37467afab81def59a09b8960694d199d0b62debb85613acab89ee5859b41e6f6eb891fce67b290289c0b33419841a70978da9e711a023a9da6941d5122660c84844ebb2b087c8eef95eb0e0ce5a8a1b9494f16e57d05c1e3a0fe13730f9c9fd6e026d1e4e5b68870ad0f832f5b8d42a691bc36db8f459f36c84bcbade7d19d89fecda504c6e64ca2ab9c710456130918899ea439ffdfd4728e2593fc80354cac56a517c6d0010ac764dd6818380ced161d6a89fee0ed9afe545dd749b6006ca89220c69f8f39daf7bde019eac750a129e1612de1c5b8b6da9e438898d667645789e12cfffb0dc5a1759c98fc5b02b387f833aa559310f062db5adc550a04de4ad05e7ebe46c7544d822dafdfb8782273c8a95c0a707babe9438f76fe5ab46335979328f0bf3cae9b4757b7f3ae364efcfd06a83122f0e81bd71a0cc22ed62e9614124125af12cefaef02cd343550b8860c38fb8ad0cd2d5f7029c1180c00007cec855a43d54abddb4ca207660846fcbf12cc9834c97b2318e2706fbb8e75c9efd4a124f2608bce7b5172e7dee2b8dd24d9cf1717a505051eb659b7ac3b0ec6990e77e3411ec89a86d7c106b21373d4f5ec6aa034e24f29f9b40a1575932636256fe1c2007a5a95db515d54f2351db807713e3ab3e81f29a723348b6e0a1cbd158d36a676f3c5da9f85ba3094f7bd70dbc2f824f4640bf6f4b210923f64c061ff99447daa9fab2d10cc8eac73d8cb2a398670bda1eee8234f747aa1650d2657da29ff8ddbb3ab44ca2bf9097bcfa1138391a68482f49b86cf19f345f81916a819ca3b504ecf853840ae4d56599edd4cfe61095c9bd03b69c75921c6f4009d04da38357c226212467928af5885c8aae60b3ee956e7f96046165fcc7196b2667d276980c4f8c51c143685fac6243829f00e7c90e63a59fd993261a1ded0b202e58c4c076be600272a364d229c1c9139b3426271fa5d889eb6522142d589a0420323c1e53559b27e161d9fe67d28ca80855b3debc04c6c906072584ff6c051f6c4e997c74838fb9d157e725d55ef61ab258aac8a18d1042a5cce74833b4e1151d3ecb39d9aa6db8a0dea13bda5854d8196b41c2b61cb0ab2c1d673d280615e84e2311557d97e542a09b359beabbfc494d45b810e82761c3c049487cfc648b7a9bc27c42e68fe89f2e23f3e28e4958e3083356b54fc04d1e5d70fbf034e0db313192aa688bf60defaa81a0889793e68daad33179b924af7ede6fb6f97d6a51b018e3af64dd9aff4879816b728e800f3acd2f2ef99feb4fa6f9860be97b95e9b9efed7ca5d0d3594ff73ae50f64bff6036a92be0c1097e08c24d1525bb1f1047e60946366840bc0c559c0c47716a2c79dfd095fbb35f54a57d0f2822777bc5a6e6783981ce89a55999814a31b83a05ef1f54f99910a78fdb2202088a369fecf5209531f46acb16648c03232b24b9e0245266e3d9d08268a59c394f58acc75b5a47fb5088b5f8b3d5a9602b4d6040a999a29864a860a4cdf84b6c3d26499c6ed6e2f71a74d1a7370a1057a65d25fa7bd34120cce69e954d4f7ed3b510d6c3f6e99fd4d24509bc9ab57929b742609acf035507574b0f619a431dba47ab9b9a61cb8b09f79c694c392ea1bc3271042e2c835aaf211dc2798c58ebbe15fc4b66be58859b631949c78cb0c22b42aba140d28a50dc5c55a8fa56705028dc1c044576a9546c45ecae16666dd4a4c8d28937d66d89d54a5fe386d07c18e924ddf712dd59f4563434b14bc406def999c7e9358ffdba647b9420f4e3191ca553327665ee7f68b0f6525774899f1fc840a49f5de96a5775990a1f9c7caca4e6c55e4af053c36b95a597f5c6a262c44ba364a551f21dc6d275ec05cf7a7b95d24ee44a02627283ed6e3e28202bb5c70d86bc83a7d8f32e2d15be65d53926eb1ac2031b0ff2c860f0ed23dce8ef2dbdcc3d588fade57de8514b067c257800fd300fd1e51f3ad58691b4d0bcbb549600970cdddda5acbbecdcc277e8f01bdf693869a4234b9a6cd216812172d705c8b69a73dc97c31ba0635f8d0811ba7b118b9aa855dc0584a02d2e5941ec1b749750255b3a9bd418ac5117c0c2f4e3b52f4092dc915ecf99af53d2aaddb94ba2d41b3bacf405d47bf7886fd3b5b0c5cc0582700453fb0a906e214cd35247840a12f344939f78e7ca5adc366d90088c01223f66be5110460cbe00f1e84a9128436c299f045500ecfee680d69fe14b27cd3418b273001b43cb65b4daac709bd4b4aea000e3ca8aaf95e8f60fae327734d716aa8d80930aec558bcc424bd2030cbfbd3707de433ba43c6122c014d63e052c08d0118f14980b576591afbc204ba19b80dc5d047fa7f7a3ff92e8df5da75460d85d2282bc0840f9b9f78f043fffcd317206558920c8f5295d520d88779f75436c0171eab692af86fa0ddc7744fe435522cca42fbfd081fea78fd7f6b984222219da97851bcec481d7845ce2f55f1c33bf6ed7517d949e698221c74a21d3728b3748a1f7ef0a3bb1cc917e656b37b2f55bf3061983a21d25889e4ec34a8784f6af12ae3d909eec0d58f730c2ce008d5d5f72eb9427eebd4423c0c8b61a725bc0f9a121b5b3a73c551f71bc72fa0cc90d2a21713052277e2eba3b5c253a8eda809aa671964a7426afdcad8e76005b37d918ab051f27dd13faf625cc0686923c385d7fc1408aec4fb0edd4a9db18c3d1b1023c818597fe145a0be2fc2d1e77be16de7bdd51e1ec88d2b0d859f3a9a1b85d51cbeb90c3961dfdba70952ba444ffaec9c233604976c382678fdadae4a0bae5b971fd85f5c6c6f38a1d56db282ebe3ef698c7e44b47212b48159a00c102e4165aca1e4ba0f781068753f56835cf8eeb97c578a92d0c020c2df5d9d29c532814b7e66c02d5d5ed9201c07843c4d8df519ccebcf0fa05b091b7b60a1884bebc103bae7a71251632517c153f982862cd855b904f70108efc6951b7cac2855c2bdf3a0658552a3f4336f473ca5bd12088fa3becbc8f05c1189d01012faafe0471c262f1af7382ed398134c41ea6a16958a786677efeddc8b77240862b30d07af6ade53dad1adb8d01fac102ae29db97e1d6357926311ee8a712f5b7f23d4353790a988357e13dcc119c5d9eae3d6696cf81ae24748401fa270dc3d6c5280c4403eec3d35125e8a8d3154f84a04d6751e00788a62af714ce12244a61ae16e8779fb231a014c71005fb58df9fb37cd0a916f49fae00ba77641461967b2b493babbf9a9d544d66dea97c3015f2cf04cc93c8dc239557d8503a3824878c788da8f7196781894b402fd8e2d89d30dee8a13eea62bc8bc843193e519dd70627b56a10a09372ca7a609d589c31e755900b0e11033a624200deacd23d58d5a261dcd289b5fec7714cc15907b986fffc9f48ffdc041b6707fe507a3b91d9cd15d74176e6963e2caaf777e0555c0f22c0747b275eadcc03560548278bb0d6ffdf9ed91624299f8f070246267dfc85eb161c05f6cbd9445c2fe0e17e2bf3425050ef35ba3cc0d74a55fe8d73b52feac3fe2106c18b0a8bbf02b207170cc541b61b829e8b958897ec7caab7dc79a17a886b5c2d0b27f69c29f458c6c64e24fc87ed1eeddee1b0ad699ae2fb6f79c664fbd7fa7bc9fe62077c1b5a20289650fb9fb9427790cb786720234980d00a435a097d1b7709e40f0e33b6180f2c56fd3eee3c7ab131772f57afc39e9d735edef9b9ee0d1ab9519fff1e7f6b24f685f8ed0ac01f199585590588babfcf077a6dd39c7b37ed85da08c9a4d42ec6112877cd25e793a398b763075bd44cd6aeb8a6d040612a5c7197da9221a1fad69d837c84b8d08fffecd18799f13383375fad267803dccdc461f53c2f255b9bfa28227f182224abdb06c128548006d3ccb0442d88ee898f13fa88fff7edbced3f26c8ccd568afdb6e481c9af5b21e4e11f79abe4da39c4ccb8961891f5492e5fbf0fb81f8df23f9fb3709714e4fe55b218cd035e6cd0371a5344e4ceba07f3404e20f6a0dfcfd232202345a7bc185cda2331b4e6f38f18db2b1ee94514234d9a4a412911a383a3149400793b7d64e4d511ceec5899d5b7d483185f47ffab1f1ccc61f70165c0f68e842e60eef4014fcb0bcaf6870bb9258804b4a2179b8f372818e90ea2cc5dd208031583ae89fe3e012c818ccc361b26e7a6a67643d47d7a06788f04383c665a7d71e424d22f206a7ddbe0e06169dd0e9c900ac2edb6fd67da36ace681ad3dedaa02b6f7306816e22891715ef946ca29b12a6a2f6a43b1684697740a0ca56261073dc15941cf8cefcd7760ed44d676eb9f6590d52a7a6ee80814fc43593a492d39cc9e6e80e9f85fba34751ab426703d33dc85ec262c751ca69326e6d4104192fd9280a1982f32af1bc0f43201a773374788be3f39d12ec031e11b7008733521a20f15f38e87b0be1ce2394f568bac2b3aef576a8b641267ac81f41506af7bdadb5a75ff18dd1c801b84128f733284e4ab2b7db5601eeb191b98ce5a23107cd0c7a01500f194df7c2627fc52a2b73fc2d955d66e14e6560e88447587054b8ba6dcea50fd3ecfd184388f7c6a960569cd2a4da0be53568e41a72a6e7645e1e6c435ff92804e925857e9f06622170510743db2afde1a329dd0953f27f5344afcde33181b6f010adc49c8710961b92dfa7cd2f55f2b0781808638e209c4c5cf5aaf94166fb1824bdb3c956444aa32379b79743b438972941aa811a527378863190c31bad24304fa9e4059e8afc284b980587683a8f14628b0711709aba9cc5af570870e22e45d3e84beddbcfc382d864324d9eb0409558bd437ca2219ade60228ba6b4b4ad13bc4de71568e492f8ee78f4b8ed1e2228bfb20e17920d8924446efa5e1a4f5c343ea31e9c0db8870fad37e4a1dc86f1618aac9a91a103d4f17bf8baf70a1ee61672b3faca04535b49093a155e38361cf78521dac54b70575ea75915667da5acf9e7ed2a453b015125aad9a8679137e696c4c947beaef0e6e84fab616ef04d8b0549e835aac8ebd9c76dd01dcf1024f2fe320a171f318be32efbda1c7582048bff3ec7196799b5b76d8f97df001e7cf9ab8bd33bd45bcfb73e6ec840bff3abb3979e4d2012ee291e3bca107030f2ad2043f0601ab1ff1be9c7654bca225b14730f6792d315542c73aead0c78bbe4433758363a00dbb3418007195bc1707b0bbb00861909a70cf1d5f3e51ae57bd428e793b071c1bb1240a7e3999ca9e9f57eec805de1c6d99dccf0a345e8c1e26780f32be0f849a3390619a89222be8219617044219a5e20f6c99c2024ace24db1f5b1c10a597fe6583de0d2657ad9024e0c14a2757f0ccda2329a077313a60aa4707da658e6abaed10fe94b078c625cac3c0e75b1be553179c424866f6e8a86e924f6c365abb22f4bd80d0b52d774ad757c231fe5e461f46312f310a37534873ba75162f6febf89aeb0ee1304bcd2f63284d9ed04417df1f9b5785b39b317c565096a7318abb0da0e264e77f2a28b41093569cea1a7b6001e557a9f540a3f26b094a110d0b94687924fd1dda3ab59a3c0138beb014a2ce2a39e3a88d69d98ac567cf394e31205bbfd3a7b406a928adcc6a604f19a30c1b06dc464d514f68029c2c7296a10ad178e9caa7e3202f2b58e3488a643e67b505017df4d11b81647b126653963c701e645cc112bf9015789b4ad71e6eb450e30a957ca0bc1cc935682503a6d51c79a933fc8c11ba37a1ee0941236093081394ad414e3bac384846cb7a72cf9b92e4e102b6fcaa288de03ca052c1aba40282f219f41b43b95d643d2cf0c2c5cfdb704b3208408f3fa3b50332e06d16ef4444bda02edb258ccf0cb8577824c6537389b8c4d0db14aec3299b84ba2165ff4bc4a6b98efe2ea6a38bc84b31f6b3194816b6bf93fa543a2711504cfc41b1c165641e77a718f310967289107bc231444d3c921540aee9b7ac8e3e9aca9b72ec18c266812a69834141bb9c70b4c99d911961e7ad05e7f28085839026f4f780f808fa168b9e236638584209aaecdb0eda555debbf4253825fb0bc3cc63502dc854cbf4341b9fcde7f2faf67070ea4b4b017ff10a8f45052e50d416b58a5303fc6c74556936682952093f31f119ae24bc07e7ddf3a6c2d591a85d96a0fee331cf5ab0ee6e9a30abbd45814d9790cca5fda88f586fa09568205a7ce078d04c46356dc96865a1a15c3cc279794593521988d615582e0c3940a9dc9f37927f0fcdd1aaae0960d36df722dfcfb02ee7ae0485231ae9af86801ce4a7e35f3d3c6b668218668eea9419d2581f1e52a3bab9aa42680e4b8ce2f06a98d7cd92b42ab46410e58d2443064c60e81200b38016aac53148acfc9ba6a9272c8fec5d3e852d0af0eacd018582a007be737edf271901d1ae642f903e319af0ac8eaab754e55de24a56b338ef2fea6a20af7e808ada3c78eff9ab3193f11a4a138078c66531b0053b691b7c939357bf3bd7373e9bb316934e6f00d13a0e488ff57a4a3f68da70e302ac956ab45028908d716a3b98bde9e9444f4a13241afdc42a457cfaf7e4f00be92e45b5864d6785102881d525fcef67c7d7348eb8a0da8e415f6f22cfa9e398cff8780d12af751a08ea5ffb8dfe8e747f2d6b883347f8fc3c7a29b2d9b66a59f3d3a8cb3649456bc206d5e301c822b7be430de4ae6a7ff214d937cef4718477e252fe6bab45aac5d1872ba20a0aa53f171158852e3e1959f2ad3bc7ba5b63cb3622a8f996dc66b5b71cac32dff3c363e1c8ec309d586e5e6e8144894325ea63836d56882ba1553a1c13e153ada13b49d0adc49accecaa10370d5bb43357c8bfb8045d6c4d105b339f76746d297d07ad8f177dad9f23596a6ec75b74f6fd692bc95a29fb3139bb200c550b553a8e371f7cd1b06b33f5e308729eee3f417dd08d3129c9bfab52d32af84e57d117aac2d839422a813d7f68471cd87d322d69c729aeab06aa3f56512d8e11d093bb84ac765670b94740e85e656168a3a6717d3aa9d2d818bcab86abc2f3869f0c563b12b048054d8369f16a08ead9d75ca920c769cc6a7315bbb4094ec817622497ff1865c86224f04f6646f899a13e8da9717133ee6c6bf830c3ab4fa90f328f55d8faf5f445620a9ec07261c74b05d34e11b4ba631f5cc14d5b1d5def056d978ac35a7500be44962c22d25fb878d333f6c13c3c9c5c811c220b83fe976fb2deaa8d980535cbdb565aadcc907ace4f6121fd6075cacbe7ced5bcac5c7cdf1b6f1230ad67771ff749bb994dd91c1f19eec37d33355ecf6ca51b49ca0baa9906de2c4f2dab6704f74d9e1965f9aac5ac4659a5792b1cf6ca60e818e8d23de1a43e95e88c41a995c90ecc0ec22a676548ca6ee6230a153217bda9dabc71c1ccdf6aa967b62d7a8753cb0dc78c835b3df663ce7d700be6d90b55f4037eee03ea2a1a910f2e511c1da3342727af92d5fd7ad83b86fb6d5119d2eb6c9358ac765528273b18d831c370f8c3e626966a13679469b41d4ae427b930049649565a17186a368ea679e37c0fd74c5f55eac3641ca1f2a0c125c37cdd22f12dd3639b7674cca3d0edcef440ee648690a69e96c9018d3c41f19ee6e6ef68dd1fa71c7fa7fd6a99cd04e8e66172e282bcf9245f4a6a8c0d5840b26c57bb6e243b95e9395c79be7bbb75c47571bb83f8fec0de3e0b37c33db2188838ab67a4d388893d58b061aba9f0721ec167f248cb02873e77d59752682733eb3436343aff1a76ae51487accb15b2c6220a157b3538bf8048c8b1834e9ed50a6415ef771dfeca20241815efb838331e59f63fbd2efc3dcf618755b0e8b6d4d0d6441c5dbfd969bc3adf3e1b8bfbf5fd4e212fefb093474ae278e7e9e46eee3231394815e0e962ddc696417a9503d8399310c459f1b1eda2485717544a50418b3174954d5b3c0c30284bd8ec86055be15949821fa22fdf7bf1db0f24ab324ff74b4c9e92b623f8f7ccf1759a534ed63a88a8595530909456e571d3bd3d7c6505b28203ed41b341a5ac67fc4fd82c184ad88bf903cc33adc8d0339008c1f2b8121d908195d2569e4a81f601a0d123f1b215905a717c9d23cb568716b0b7761acb2603fc95d4eb45543e14b4c295836cb48ec97b15f2411d5e1e285dd057e3636def3bc225ad757c23362aeceae3f7e819172297f8073457bf8c4996e52790c0ae5e361b6d563b74efb22c153de1cf75cc075856c86c40ce71bdc9a3211d19654fb457f06c64bd34d5e0cf30ce0b224a22328d74505ef2590199fa8e894d3b285f81384428932b30a644411ee61626db9ca111369c172c6fb3cfd09372b6c884a8e8cdf6c3c8b6c80800a9c42cfd4600bc0817079b61f72312d5cb32ab465a5dd8df1e6f13e8455eea31992ea86041188507e92cc6e7ac90383a25c88741d19fee86760804340439e724b4736e90879cc26e3117b1b96bc78a91e9ee562a0c48012c6f38f0950f8f2797ae61acd7cadbfbda4dd651b4fcf2ba87fab9b751353ad772027847e67d033c4aaaccc05daf4f8a736776bd890c8e123ef3905d055d072426127a717829ea04fd0b62204f25e12d48c57b13a8e7463309c83cc3c6d620413e95dae059ce24692a98291891b102fe314f1352e0fd91499aa48f2e8b444edcdaf736277db2d09f80c98adae794d534de325101097ba05d739bd7cd2899583b67977487a7a6f3e0f13e25682760dfba50295dd0fc82ad3095a76292056a66a8c6cfc802019a73819e0407164aa60b27603e3653a45c93407c691a982c9da0d40902a3d0f683523fa6cffe235e56b3f2f92d4c7f77860437d64e30a09f490a5d7c70f39db4b23c8c5a7f37ad5935b9913e2e755e8dc18477a03ffdb931bea03535e136922b1e514bb0bc97bcc948a79c063e274a61cdd7cf4dc9bc1431de207f08d7cf75c938148886c47e9e988c100232ada72d6928c3530ffd85eb6eb0aeadf4a9d7be23039a88d5eb8aa6707c88b0f5a9067ce15cc62905875cf42859b1ba74c2ddb36dad5c8622c229ddd1e4174f239031037e9a7a4e0a3947d359292c092387804039cad6321936c9a8cdc17d993634817d95c1a5e4bea3bb728e60da7da5ad46f1f1f5986542c84eb55328971250cbd649408bfe9896314693c84d021bc7da0666b257ca0b1cfa811478e5948dfd1703746c30cf117f848b40f01682bbf7f3fc7b5c5c16919a57aeea9e124a45418e148ed721ba7c582ca6d14d560a9c7c71ef32f8e4f9c9b7bc9fb99d9174c45bb238a879c75bbc79fc76704ceba7258af664177211ebfd66e11c8dfd2953b87e01181a17658ed3576d572ae5b42b7df366755637108d4b431dafba62aacddb46efa2bf82d4c48559c9347305823cd5b8324c56c923b13bca18b6e1ba1ad6347ae221035b9a83a5f27b9bc1ba2c65b8aca4d36d644d22381c4baaa8d0c462439652df63e96449b96923e70c15e43254aa89baa549e784beaab4e9061671b648d24efe7b3b5ea49d21ef40eb5e5059612b820e0b89730db20ac5825057eefb25b86cd2792eb3275ccce960f8b10b0bec0020dcc93610bcba5a0acb5e135c67f3978570fdd739a0fa6343b5a43a14d26e4ebbae0ad93553dc7a6695cade9f034fa3b15ebc838b587f78217897327d8124da372bad0143fc0f063d3a02f4548343df13c5240ad4f0e0a6ccf2875f2b7a18a4c90c333aade36b3596af339b287e90f6ec749941718019b0b6dc4ae7ac0b968741d6783ecafec30b8a87e042a6ea9f53630606a1a3c4d6a9bee5aaf1d4a979f41f68c40efb236b0fcb172ba10fde5289ddff7ed50b763c35e5075ecf6449414a15bd606d616024ddbab3454f940a64b958acd85684b40cda3b6c5245b38422d7a3a54a08083271120e65fcacf4b782415c2d21ff034011a120db5783589acc177dc67694864bed5713e4516db58264657a600d2bea9fecce391912439e7b2fc3c3161094e8639b46214edfac6aa178b49550007611456b0a17bee73c1b55cdb1ef155fb7b5d9ed605964c543d286719ca4438f2071480450bc0c1cd44bad920313ecd3f70f6f8d78f2a1c5b7bf2c4b23bffcc05828a5489ea0a4b66e8190eec9120e7381d824cefdf9792495bf7fe1a6ebeef23c6af070b56b5e54cde44b7e507115a8e4f8d1d4197fd2ab7b8795bf701831f1bf0df21b3beddd2f470765a529a23aa8c4a755cb3d898d39031065f6e2bdc9c60894f12d1b79e4f13d23e79502775abfd15d54a42c59c48306ef79fec4ba76b191f4f43733fca00514d6267367a057c42e5578bffff741ffcd0c79201cbc0ce3045baa9f4241fd14809d5f32bc178bc709b6c7949394efce4b93448408059bd4204ed5cd48608d7287e692e5e8488765302fa504ccd65269f541c01086142f4a715b6a1f2fb1bbac3366d91a6900b3750e681f015256201e1173a2e6dce48bb83c114cef2bfff8c564b3836dbb0b59148274c24a041edbbfc4ce336e9eb51391ab30afa1e62d47dc11db58aca8e872fa126d13eba3729681e5cbc4b10e5faf32a7e84b8362d155a7a16f27af5750e5d223e4a004870409f02d4255973875c533f4a78b0795e813334319a7a3a4f36880a86d46f99b76b1814803f3279343814d8f980e5513038ea0f0461d9ad718afa5dfe8554e34711a00621ea67414797fc1898a3979297a8bf04e502e119fcc73353deacb4c6e910ef8ae2826767fdac30b9f4fb26fe93cc1512a0c1c0f055335f1d1026ab425e80edbe137c42759755ccde3a703fa7f8fcffe0eb0f9219bb9d2d571f9219b23711231eb48d6421e3e6cd57e0b1fb99473c415df767618026d58a73cf1f90054c681c31988ba9d4a013e1a1cf8eb9015a32c62d117db16f3e3c7424b52d8f75bd54b99d9ffe024772c10125658e814bd67e8db2075b7f663cbeca7b8b96573eec67ecc241c2c5c7f3c1e837c2685b5e733cb21201712ed0d9be67702c5f56371444fb792f10d8df6cf3b28b55b950f98123055f97c039883102a48760b25efe6c70c94ec7a020b252fe3ef5e5ceed9877973f1d7d17ae1e301dcd44822c72128ebcf149f57163901081c0e5a47a23556d88ebf51fec757f38b87fe6f68cc34bd29bb36fdc77c19e01feb061c8437bba8ff1c1c9cb8fe77d6b0bf9dd933064f2804c4635e6c7f36afa1aad138523e0e8c15d5bdeabcd68ece9fe4c06a4c98df6918dfd657e030838eca2e080443832b0703d44e454e09d0acf0d0df27e43e3f9df0a003f05d7b49102d63849de00803d2527b285d1f4f9f87d2000647663846af838b513824ab2576ec9d8e7100f1745eb3ed4fb4796142245105818d008429ce040c2376fada931a490f225c7297c58f0076a00f88a2f8c422eab67fa75cbfc4ca40be363d91df1f92d49b7bef20114aab86d3fb4c91852e833d73e64c489e44fd2bbe810f1d534e20bd7cf9fb276d0a896f5f3ae506a84d5f2831ed0c9de277079d310440f9cc564430e97a541df9188fe49b9abd8a203561e77022b6dd1ff96ed6aa883aee6f3ee00e132fdbc8c4c4ed23b5e7a1f052a803b2f052106d87bcd8940e7e687cbef6e19a72005b30762d84e37c17fe121a8846dd9325ee8df5e60bd5f30c0d3225306ff6227f06d84218debe3ee16fee70f24a9d0097a4913ac309f619832ded87858522f90ae60a84e01f592455ca38ae13ffcedcf3f14b3868fed29e7c405264d143e6704477c6824aeb2cee72d7cb8a22f56c9922b4552777833fe331cd917635534929f51768dd055ba8ab053eaff83c8265dcae994cf52b99478b471e97ebafad6f13ee52f677925e28c1742cd36baf0e61d85658e080cf5c26b86363a5002a4d535da0407a29ac5b5f8b4d730632f76e0c8bdaaa4873602bf275606813f53a82552aa44eac4bfd1a17d4639dfd3b8189643f464803781640a224b54bb3f0cecc8acca6c7196be52cd47bba012201af5a42e40d19e6f014617aa3f6306d8673ffcf12ecfc3146676103c33d41775b420e199f9a5ccd9e69f56532ad56d2f09da9dea36f59206d65e1277618b9f978836342374875ff278439766893276c298271612655093bf8df19fa8f5bea42e94337b39792813be84f84f6d91a7c22f52a86eb9605871f3d1a975ea41f42895826568bc51c4233e059792c3e9daabd2439c0e343543bef3afec0dada24458e63e369c6e42d14784b4d3d0f1a801d9c1f4d8d9d0f1ef112d1e96f5a188f9be74c55f00b8cc31466bbc07405d72e5f0907bf6f05a29c7c60e0f497f7ab2342f9d14dd82bfd0a7ac63767b27d7cada2f29aa7c7afd3e4a0745bc14863c4e973e39679bb1d016d8fabe7fcc47665810663c078ba646cd126b2824b5f2448f194d765f22bf6116073980a984ee51966eca29ddebdeb045b9d09198af0f4b427180960e4429870cbff7054e9ac0118d663e7d352393243698f55b613d8e00965438fafb4e9f2756e80caf90243a48d2b064ad4d9c443c77e05024cf84a68bbbf69ef0241d7f04fa566cb719ec6c99005a9ee89032eaa23d93f105b0c1f4ef96d83d85998efe6918bec970e158f387015843fcbe7d9fea1e748ed5ca08c06868f6649363d86100074b6865f508af811c94247fd87462fca1b5c35763e21410c705c4b1e07cb081d632943e7c1e3d4f2edc22d698e85ac112592740e03c469a7fa8875be4d92dfdd008549ff60408f9866ec4c6e9128ba031c18285686c5ef6fe31f3ae5dba8b746b7d0ad7b2f7c629fa0312155759620ef37f4bc6c349c6b46087f91fa31a4fe51583f1138c7908a344b937d0c900f058aac9b2dcc12c4e90c093b5630f462fd1a8ba4cd5251a9d91f5982a24bb3f9e8b42a6f1d01401625535d7afd9938fd84ad2701a86c81ad463c49b869012f2c9655a7a22d8a786a2c1748dd295fc289ca0ab2fc0f80e16956048c51de8d5e1720a6b4c2ed0a824b55c7f1bdae0cf278d490f0abdb350c848b88992a9e456793c853bec5d0b3623d693f65e9d12d0af4fc2519e90b5e978d3c9ef0a28649c16f6609169ddcc044bc877e50e9102a04c0570080bc99533890e0c2fee72fc7bd9f1d2ab90d079dec7fb12b43a4a0579c7cd26be8cc968659dec653c3132d026391bd139d9f9efb71baeda2200c77539cacafd6dbc9d3ff142a6940b87212ed03900e936498010f77580b62b52e6e22a2b74dbdf09535fc7e1b2c33d454b61f7fbbe9254b46b58924427e0e36464f0985de1b153adb9ecaf06b007a8dc6c5ab86e7d76c266a428b10ca65faaa1127bfbbb8566f29a697fc3178a3a9938d202ae7480f78dc79fd8eea2d261a56c17d609baf4fd5195443db72a9902abd4f488354b660eb722ceee9cd58ad881485ede5314cf48955a82d44392d8b511dcd5d7a6726b4bcae7825808c704e8a880c892f607543711c43a360c747b486899a22a731940e582c34c6746e476873e5d6ff2463a1ad7a4d266b7bc4a63843701e25d4ba789ec91073fc655f2e08ecbb91f32aeb746a37e1eefa5347ec160912223fcedeee3175728a220d08b2c314cf54569da8cf3f39032f5eb6b275c849b066f0e0ca120c41da2907fdaef2ef627e0d12834cd2756422aff55bd4bb116f5f0dca276489db87550b1e38ed98bdafecd72869bfab0eaf7d114eef5e337bd7c10b9f2c69d6d764bc7906e421edb6ed9c9ff06f58e34bc004901784489a71e00ec1d90b72819d3b55f47922a8ccd7d4c9d4f7f36fa2a196cae1998c99a9d123743b57110d0e3fb0c744bf894287a627230b00a5cce0c0db8add0b690d1862101b07e219f1e4ea5eaf4ce0cc89f65f88f078c974926819cd36804291b8cf62b69056c365ddf717f0864b46f3c7ed7e614af9f295c9fc7fe0eb3e2101412cd38fd9ebf95a7750c7ad60683a26f876e69e33a03ee7887e4e2e6e54dd5d048244aba73607e410c7ec899cd2b7b50d51f75672e90c143c63f575e644b1d6913df6930e21529778b35ec01743d95c099c76f14ed0ee6ba80b127a25697f5fc885cf6f260d299884730fdbe5e7f4b51c270b9699b5dc5f4f8eedbc5fc85d33cd343d455c3daf0300a6dced162ca522b157b3d90c82354a9778ba9445d89ded62704278e52beef9f95e7ddd25aba3afc7e47f3ee878de91ee837acab605771f4f5b72c1afa40b76bb8635310d56a2bb07a99820bf686a34e5c8ccc230c8b4a9b91e46a096dd85e16ecc40e97e19f0959846e621a4b72e5dd38104012da037c10d8c2993a94960c2d60b3bc8d8a09de0ea1e7d2b40b26c2f1446e7bfe41aaaa1878e1da14fee86d9fe51b35c719e1de5215d78868229575f5fa3b849c6fea86a2a04f9acfe106ef670e0459d044fb510424b82d3fa3ed586a052cba5356949103e945cb4da21c0ccb16b6542c2c382ef5a2935a1e9fda1451ad5907f10486f4060afca2aa4aa0aff201a49b403454d7cb4d29802884986baa3ab96280878763b51e197ca4c659d704327dd8a966c10e969ce02af81411f5968e58490de59e730ef83dab89a3a123fec9cfc8af360e27a961345dbcba8f78e322cee41079ea15628b1c382e9f765e17aade169694353d0956d87b0387bf9494f6c3881d58ca9b9558f0bbb18082d4539b747675368823213d496807fcce060c3efaa8b5b5f6abd204ff9edff6c6a1c0584908cf483165a98865e785fd0a96556c27d708bda67b057929d6d4d6913e9d64e90838b92a86addd526a9fc0135d4c162f216c22c0779bf7b0e0086e014258185b8c2ca2ddbc29af6c7bb2f3f39fc5e77680c6e0604467256477245307b8367ea480bec0c23b86a35c937717f30d3dee87a46283e75f5f3f78c74071ea2764f53f66b893f123412be41b12f8efcbfab0f48dbbbdfbba5f899d0a27ba656ab3d4f16532372806f5197b9ee60dc89b69711f88997c8c745e08fc4d9eccef93a7cc31576ea9cd0670e2e017ac84a8b2aff23b3b240e54e27046cd469a25cd2128838e8bb54a218ab7a09e0aa409576d8de1d68c30228151b86ae33a215674cd059defcde2abd498c71fb1a9a2a1319776391cbe97163fa15232e47d7c6508756b25eb81563c12b17a3477eed186bba073571c1e766e54bc79ec58a23b7a7f8d611ff75b081659b59a4486ff4518f571a8123c6545d17b200b75618a7948a703b46f375837b33f3c810b53758ccb5a76b2859709bc23da25cac032c4153fe1f3e1643018b41e733f285adfd6c392ae62d444f98100b6d22b8c3240d21ace2d1f71870eaad62cc139208548d7739920055a703de7bb49818faac984b8874c9dad3e61bd2414f95ea476e43a4f2236a65511b430345e4eefca155816af2bc16229f41cef905677a5e786d64a790bd1b2ed61698b4f92a040fcd5a896a2de9349739d5b6ad2595e028ab0ea570b21ca1c754ce95a6dab084b4a70bf18f2c1953d698770708b1c42def9becdcca4c06f3357205460bfcd901a1a0979c4dab3bebed5bdf4bfb2b7dbc968adfa08879f3cbfc96a285521c4d8fc553eb31dd84afdf382b4f5a86dcb40db0adf644affa4387b996601d657647be5d384801ef5d841da65c3fc065cec94b333d5ad8a03b89db3ec1c4c21232bfa899cc079ff59df4fd78d7216386b88e462fa40c8ba7b4a30e61f0f0fc8cc4b73cca3fa4eda9a84de6444ec58e6e338ec1747fb15ec40afe8643d325e3fd6073017f0855ab0d994ff728fe242112aff087133da467a437f29c96d0f5a9c7d5f3e158a7c9384d10f4900f015dfb1096500586da61f10183b49188971c27e24aa620a564c2128c828653981fc5e9f034e52d9cfe6c6e222d50c0cde28d2206d19f723a42f88524e7b98b9832c45bc4194ee070df3d9081639f5b91a6811e9cd52025d2d259720de8c4529f311111d911e2c0a6bf4d5294e2841b819e5d11b043d4b0844f5d6d4708901197b5804f4756917588b02d97a18616f43e1f88658cfd8a863a01ec49bc3c8c833290876039da4b4f7d48d68bfa6140a6e4c22f6503d5b15a03bde980d07cf2cf6a4c6cff391abbd24d494e7201feac8c3c4668fcf9565a18622682be0884ad162589b06f95c288ed290569cc527e5425e31d2a5bec58b53cd7ef507840a4162e3be4184a3f496f75049f55a3491cf8b1a1ca017699fa910125cf93eeba2bddde17604152f9d368bd8cc334130f94bbc70f88b8ef9178332b48f8a4c38f60c21778c08efaafc4850e0b819e68b84106e6b1fb2c99cecf181dad6aadc3db7ee7a84efe5d0c9d42dfcd1696a2b7d0eab3ebb258768ed961395576d5e84c958ca2112623875b7d998185b5844901b6a1609297410753f91e9a94361cb1617ed19b9f8e272710a1ed0981102a04540872ce7765c9db290be76af87d0efb2b0aa928e85a54be50626b6181b9ba7526a7d45e4ae8aa828d91dd917ad32c319e5a0850abff1c4c8f2d690a0fa46d98c299e91131279ad55fefd96a6031b728589c8df4c3e097568eddf76c40a6cad256d3447942e4b0218958d2363b3c38ce5b6020df4ccfa1ce2fae3892b343aa84251d1ac480f4d218dc481b3d23c49036408269c428eb5c399b8696bc079662b0c143bc562840b41829860738d3ecaa3092aa46b772cbebcf497101da277be91c042174423a6a7538368083044c27453a7469c5b2ca7c35001de8b6ad60d2abc0b3015a1a2aea46b71af2f0509e61201830f9aad4919e75c0e9aebefbf58ebb7605e942c6b210cf9129b434b999f4074a66249975cab3c23e9dfb30db820d7e629bd8d14adfb0c32bb144d2d2fa066ba613c699c469b90ace8e6d38040815ea69e575b1bc4de766023fe3b2b842a1a7f77532539d992f880725cf03767168c21ce1f4698e0cf5888c255a297731c9756795c5cdea96f97e6f28a741e310dd0e841eeef5debeabc71081ae5cc119b4484b5ac841bf61cb3da27b553f1db4968ef64379c46149ae56159243910f9c30b14c9cd1e7196a4d5bf18950333e8c7622a82d9293bb4e615aed431b40d7cb30132fcc8b4fbc68b361599fdadd228fd701ca3f44a8538487150b9a543190867d0c3b91bceedfb0156f4b020500a02125aa8a7766662a41a32fcdd3bb21a58d94fb69470f37f7e43585b0bb5450c0c9da0b88e40df21e3a12e1b11f17e223ef98829854290c5eb9fe265f860c3ec79ebf78a6921dd743daebbaf151922babb4d43fb80164937be03651dad2692c996fb81bd8ef6cc7b697d9dc47b3282a07dccc95014ebd3749bc4fbdeef468de8a5e9653a27464b4fdade2cf8daa1acf0df840266549205902376a65f295018b5aab2637a5362076aff10cedfd0d788b503bd09413b83b476e06510b422d825c62c3870dfa33aa514e4e791f3b64e293f3451900e98c5807c9f844cd57607d89eebbe71a70b85197b206ee6c68f243809488281bd00ee03758334d8d1736c74e7de7c46c1227f22c4273ab16a1f4423211550f8e96b7265af7359478ac550937c86cd2ef4f3cc2cd6618451f9c5e8c01a879223118ff7e499711cdd1f0731b70fdd7b5739cd9897498f716738b038863a50b25f5c6150c27c5536615ebf828578a29d23adcf516f836e14772f93ee6bc694f69a845f91b3bd81333c97c907c8c885822518e06fd035ac09e05a7a3706d62aad3466c923578a5746c79041029f45f99f04d4fbd003bb6805de9a8576002867b3d4d4a6af0197734baadd2ea3e903aa492167acc9259f227f84116e45d529279031316f794cd529db374cb3e59917da750ead0f3b8e9b68de0436595ec1a214ff3d37dafcf1789c65998c049722c5a4d95db7065f97b69a7e5dd57ad1e6ab7f8af21d4d5f5dc042aee323187c7e4f1d82ce11472fbdb1e2f978027dbd16940dbdff59a1eca22147fc79cf57a163a8e877d8723423e27e6c6eb13fd7f68a5ecd9902e38d0b9e6866cb01c3bf9ab89bf3160ad2dff4e9bace58f929a8676e509a2bdaf6ff9fc27a8b78971447af602f70e669ac636e62d715b541017ae194964ae5c2dd7157a8572f2417c9b89af50bb9370e87986bdf96b52e2ad0469dd3db86bea32df576404da3f3c1f5a085f7be512b24e0045e11393be74f98d2660cd5c94589360f152af1cd8a46e4320d1e885204200994515879d601eaaac3fe8c518bbad5b893b481fa43261a3cf89e14b9e3b8a928055b8b53ceb6b5e86bbb20c76ae3d9cdd002078952ecd4b89acfc3465320d6c75a7cf815dde49c3cab279fe8624f8253f98cee7519998059f6d514bac27adba9fa7b99ea998a6ee41b3631b906c532d7be0fac9f2ed29c31c99e9f30edd132f8df2650e7aaa162d21e2c1e4e2e9ea81c6c085394f7b9d706adbf5d3f99a0147e9ac7e4070624bc6add5b9f21eea422ecc48ae550b27ff94322d174b4e4ece165ba3c02b75775a746ebd046b870be555d1b636acf23b9ba4a5d7fcc7c297fb6c17356de085ba43c28208d1aef0af1488cbf65337715646a7f23381f54024f8bb9bfe387c422362ce92af0e2e2de5ac1a84f75137cd7c66ea4052981ce51a173afa843b8e7dae610622f50c51756e567645d189fdf3a5fe0fafe1d2c56b11d531d62679f10c61df024814dfd95524789ccb24469ce1280760a9bd26fc0754a477b498fee0a81c53ff1cb26ecb5f33ddc867d0fd12a41c787a5c5919e0f25cbf221d67be6a12a4b05adf4dd869befa1ea453723a4dde1e3796f2aeb3418d33208b9e8923bbd6a925ae94504a98c48b7d6127a84cc4141a5161136bc54d0dc5069af5416d383a8d12783016990d706720707f85e8b4aa178a726328e9d5b003468caf3b8cce020dae4c7196cea937cd1170f3a4049db8906257e6808ea8e0cf16051474aa6d5db0df643121c991cbfa7c0291f5591b572f3e8fe36df0a72cb4b6d9e69db7f32a1b5fa21f30a99e7742c2ccb4a1c850e19cea7e11c394c178d5055d15c0b490cd15980b97082a1026438dfdf962f14b49edc5654f3ab2a972dbbd0125e324691b711cc37b9de1445ae644f02e4a618a70248b3232afbb332b58508b7068734f523b6cf7a49211e2be59f1cf3bb2ca8b77f891d76fd3fdd820ff9193a7a5bf067e39d55814119920b19a3a8fdf5434fcd901b8565257e60e404ee02617f3d3565bfcd90f0f16a3538d20c002a7ca78580f645b75514ea4bb5076de34a1a8e05657a89830f40db422bf921d38aa287489a3250d922ec8e620ab0414d48cafa09e28f54a24ba82ba30d37174ef53ab0249f3759cf608797cc14c1ff88be8ab0580b8639eb8fccbe8d4eb298cdd5c6bb4d6473024af389685110280d6b3a39d3395132b120482b223f1040bef91ba9a51f9fa287a49ba5a13fd591f6bd88d3743d68a7b9300a984e0790aba471a66ffec552c23ca2fa118d6a5b987910706cbdd69a486b7bef9da44c291e06fc063b06313186d8f7c3c418d42cc5c499c730f39eb731a9598a7df8b11e91490d8d09bc813071e63dec391613675ecff33c94f0610fbbd94c883d6ce6f5d82eb4338fc77e3e3fdf6d5e4e9d836a937312a15ce0d7796b42a75befe89cec797cd338f43c7e3d3c1ff2bc4b64eaacef1199d42cf57c90c8d43dbdc5d455624f55cf5550f3fc27edecdbce46a82f7fe622942acefc9bc6d7ff0c0afd7e2ace5c54caf23df84da38b09161969e8c811f5f36a967c9e3ea55f7f897ecd51a7599b4f4599a37f934e3427f4d3c9c70728eba7be8f8f9028b77ca65396a8a5c71f91871db25ece66f5f4fc4d6e053d8f413e7f9b4eb29757b336e98ea74e198c424bf5652293ecd52c057d159964a20cba62da216ae95148ac0a9fc7f06fb24d28cebc6f1a6515cff3c823ce3c51290b4379393983d223fd1ee9f37cd0579149cd6c845a79ceaf6d96ea07894c136ad6dae480ac07e5e5666dbe8fe5599b50558c21776380bd3883127bd8c744263533a5fa24f0584528de5698383ef85085c33139c9317c2cf561e26c89be12cfc77efe9134421ee7135c94d8628b34c418b05411479f8a33a5faf4617f9b57777a5ea278ac17b35ed4accdf7aceefc9b0775a78735e57856334bd2e64472f3363c6b722a7cc970b3a6356b73fe043cdea69607d4e452480bca44dff305439995eefa7759647fdf161b0c7b4e203ae1ad714ddabf67ffd30fdcb3b945ee98bbb9bbe7c82f94f6b21074a3adf0e94d2ef2e9799ed771e9ba07ddbdfb29eeaed5f99c1eceb1621bd778e6bc5c18267415f8caddf89c2012286bfce0d75b1d7716ecba06251465a2972ebf2392329162cfe3b96e0c24047ad51b912bff25b6d0f7babeeff55d650c14bfd7ab07cc049e87895866507a847d8f30d1a98e3cefe46316d86b01c76623dfc76c8f12b6e4238fa885069e11f672f45eeffa91d9c8f779ef1788e27e1df0142d6575326d3623231aedffc5535cd77b52dcaf0396a222287a9ec8ffe01b0aca2370ceb682f2211441d99c70b6d4bd7f27fe84e2d177bd7bcfe36ce9fbee3fb1136750bed777e26ca96302bffb9ec7506acddad6ace1a6d3cc9a35cb238fa0e5f1850b5fce3557de239226614888898a614191b34979141027e02c9146e825411b13fe98f902ce0e428408792e4fc1c9f2469d2ac8d00a3206196974e9fe66f7c7f31596a5e5237b240a595a0d4ac1acae7a66387966e5b1362734ab2bf975df045dcaf3bcc5988d62939a6058c3d8e7dff74d30ac611873a344886be8c8a51131024274a402b18542624262f2f2e87a8c6c7f934878a40271a344488c687e3c5fa50dbdfcbe3b12abc2fa0eecb67d31900868439a529425b3d6555859ddf7816f5b625465456330269ecb23ea9ec2604cbaeffbe6ac9d6d09cdf57d0814ab955e61dda615c6e4fbe073a254ad8dbec21ac6c21a86b1ef0b6b18c65c9fb4739c9ddd765fbbbb7bceecce53745dd775b3737767263289a6cfe95ee7eeecd2dd6b6766767707634176a89c6efb6e1d13cda75fdfc9cc36afbbdfbbe77ddff7cd2c14fa73b9ac9cd057adeefef96466ee84be3dcf33a27d9e47f43d337722d3917ddeed664fe8e3c3fc7d9e6ce3fbf9ece705d5cfab554be8d03c2be4791e1da5363e77f7aeebdc3bae1a92a9999e85c215d84c347b78320fbdea6ee544ea935851bcd9f9fc1f9d4fcff33c22666666cff33c8fdff3c0392de3d073cff33c9b91e7defff03acf3dac28d2ea63a2d9c373cf9bdecf6fafba572d71b7799eb7867d8ee7795ef53c4fc9ddf0bcce465d22129d7be7eedea921474ee75e97eb72eee5d49023a7f39c1a72e47877c7ebbcceddddbdf3ee4cfa72a7b6ad7aec2a3933cac509b5867b97f32ea7061b723af7ba5c97732fa7061b723acfa9c1861cefeef8634de66e29bdf33ed0f5a2151663201893ee8576b88e3aa52831295a563c55575655c5b2b4d0482c8915e4f323036b4ce94a46c124546df3925268e41ab906284868c7acc7078ba1c059ce63636267cd28a50965a5d34be2244e268331f15e36c4c34b7229f06f422e3f90ee8582e72098211e5d7dd14a5f3c916a1f4d79db73b7aa575de5790ece32b14e43d2e4c7608d85c5a4f301c164566214b22614d4cccd35726b4b6e493bb8de9a503cb69f62ed641b06eba86e2385a6d7f41a1e3c66104827336a424da85966464da8324ab3165454b7fcc5a5eda6bae53797f65475cb5e5cda54d52d63e0d2aea2bae52e2eedaaea96ad2e6d2baa5be6e2d2bea2bae52d2e6d2caa5bd6e2d2cea2bae52c2e6d2daa5bc6e2d2dea2bae52b2e6d2eacb8b4adaa5baebab4bba86eb98a4b1b03d52d535dda5e54b73c7569bfa96ed9cda5fd4575cb545cda6054b77c814b3b8cea96a7b8b4afaa5b96bab4c5a86e33b8b4c7a86e31b8b4c9a86e2fb8b4e154b74a2eed32aadb2497b619d56dd2a57d46756bc1a58d55ddda2eed0c54b74897361ad5edd1a5ad81ea16c9a59d46757be4d2de40755bc1a5cd81ea96824b5b8dead6c8a59d55ddc62eed35aa5bd8a5cd46c7e90ed4366ad835f937effa34d28fa113dbd857fe38f2a3714d5862608241022f5c89800b10b0f28016aa5071000b2ba830e5968294063060010a4800020e8082010a70020106608200a204000a00964a20610425114200e183271e74e08483264c36d060bc4b32c0e0022549922cb0211d2139520105468cbabbbbf316a28798b28d36ba8d968ab9bfd79d06f6647ef77d84950662281379defcbee979a02cc2b48e91684bb848ca2ff2dde9b74adfb93fb826ff06263523c9bc2542cf13c3252c9b4598d6305b9df0f6dd298e725ab594cdb2a54b9fddec9cbae1b9d7759f473f57d7d53bdfc117ece592b4a63d5c84f2e7cd8a48dd6354bee47c5a292c84d5a758aca7613c62b33b9f863c3ddf13fa589f9e1ff1c7072802a09f20a2202021219a50d08e1db51d42329904b21d43434386643c7810e131349b15cd78f4e831418f990f1f457cf480000223087cfcf861e40704ff14fc0f6b2bb02f8a47441b410448221089888e88220002040908519020b620408408b14048101a2d8926a4564b52a349208112096a43865c304402cfc31e17ea2194ef44ba6ebe5b90c890a20c8a883c4d2075e70445628a4c51640228a30b1815f912ca77235d47c59d6f04340a75a0c0df29303255010554472aa802c991aa232456201d5d6143c2c2025b164916689124690b2549b8b8408915061774910106185892811777c99bf17ea1c108c6061a84c16483ab264cc4e0a0c9184e3820a30327703ce8a08c271e98f1c1933340f8002b041032204208682889a0811194d22061840d94400207964a5003004b595000b04600a0b0112500710410458e0902e8c0004c6883000370e304026815e084370c5000385030c09c03a0400701078823010890430109f0c00214b0c58005ccd10006d491d2003a529062e796c207a6dcea50610adf5941051c0b2bc8e0001666a0e2001aaa50c9d242951a1ed082162b0fd802012b4e2e40c08608b870c395087079e14a1709bce0050609e0c004430e31306189e1cb9d4f9bb0e8806bda41061c981964e0818619c264a1414c0d59a0b4d4d0c3162d639cb690b1c1a9cc0d36f8c0e506335db8fce0a54b140e5e80c80187209e7210e2cbd3103a7c39b3830e4480d9010d0f6072617828424c1823a0c41cd103549a313da82133660265c820e1439935667c48e207331488faa1024044b1090208258408c2024308b1c49921da107186093444349143e34411b9278c28028a238c88224de50976e823604de6953db8b0af144770cb59344111232314547004c91192cd82a4244a2ec020832577d46003264d3870d281074f3e00210411944620a18425004009401401983000029c500003a07000042440010b604003a4a4709ba2c20a2c38804a95161e6005022e44e0ca0b12808129062c4d8d6b197a86a6a1b3740dada5b7b453dbd0373497eed25e1a87cea19ffa4bebd03b3498e6a1c3b49886ea1e7a4c93e932ed439be91f3aaa81e8205a881ea2cf34118da6735d441bd147749a58db400748e5f3db7e5df03ba5ff7bf01381aed755a8dc29ddbbc0fefe16865ba1fc39e9eb6fe1ed34d7fbee4b6cc1656f54ae07de1c67b3d96c369b4d4a29a59457fe7dd3a960a482d17c158c5430f2e20ca83be4f294196c5ccae35364bfdedfacb838658a3f089dc856faca96b31bec9fe24dca7ee3ae053333b333b3333333773a5871d74d766766eebae7ae73f7ced9d9b99b13092396396d8eff9c57d8b123478e159e2a030e381f04255127250fa919d58f35c5c645b174834428aba494a449299e73cea9a933da14c599a2443690352997b8a8c2284a92f644d82f9334d9a0d1cb967064514654196ba8c018e2f6b84cf585d4a53c332597f7f425fffb66dfd366cd639a3f452699d734be8d041ea9c87493f9df6cddc86307fe1229edecfb28b3e67dd3e8b2b34f6c81041e95442627de38e37f5d89b3251c55c3429b20fff54bf3ebf357f92f91a9aac55907dff77f4fc599d2eb674bae7fbdabc78631f95cbf444a291ceed266ee1903c5f073d92bb3e671d67cba220c2eb25c0f4a1e71185b9491483d4e0e430b2fcd9def69bdfc4a61dfd4afc6c5a57e98c8c4d474a52a8a94ad2b27597c05fb259e87f53ccf7be21253d087df34de786be61f7b1ea59db9381b413eeca1f407f7d6746e3fe801d9858aa83454fcd0c595623b95e924ae1cc2ef6f2bb6e02e1839a693cc4ef2b054124d029f3c37d9fd6e61d79bb027733a7d2394ba231df71ae7b3ace5f4cefbc029394059baba653d20112e92df31618532d1cda9cbf61dea896aa8eb346957234e727d4f100c4399ec1f8b6fe7248df62f9365792e97cb45eb64e2ca2a9db0b0b0b01a8b7e7d02c13094b9aa8bbe948934f4f2a97c1e6b2f264549ffc65b208c8a4d66ee36f5584fd3794a79c8befc59a59bef6f9c45c5f924aba4d4d02f99435686269c35d9535de22cf62c4536e2a409e34002512130e8a78707f6469c247b17dd41bbbf4929100c4399ec9f8a4de49589b3cdcb29ec2c4993bf43149508c127e992469c249b8986aae20a893723d7f5af9732834420d187b3c450bcc9c498787b176751795d4fad1117b9c4998b612eb1c9bc3723f7c65946f6d64d5cf9df7472dd1b67dd8c48ad6bc4d7ec90426d384141444e6611071c4f23953858a08ed448679d39b8913a9809e046da51255181a7917a5a4f1880a30b2a46262c3ed6185922c122d4441d4ae046ea22838e0dcc31d217951719a81a29f522aa0aa79156aa3590801a29ac8a306f9c461a0be3ccd59b3284c88d3484b2c269a43d555a5983971bda8cd4a74a2b6f0033d566a43f55daf6a2c50a6aa440555a2639068e54165b231316a6630c183a46352278995822c1c27696787a625433457653278bab910a0505350b0d6141868badb1a9b1b49c5274de2a7ffe94190265a2e99dc8d414b03343d588e5cb1a418944ca0b8437f082b3366b73fe1499769041c3184ea38bb44e62ea08ac91ce9601ea8ca7715a1e5b76179f349ff2146fde688db4e1ecf0343a9189026a6434b49863cdc85ea8c1658db4ab9de53034f084d548bdda5926b6620b17592396971458d3ca664b1dcf160b6c8d1dd8d9231ba6781afdfb0ec8a00b041f9c48af07c16f4e127611f9a078035d6e6f4d13c6840a757710743d88f4025dfcb2409dc4254e9d51c575f166b3048d3450c1e1264c8479b1dcef13dfd288e6cb3a21e850d0f1191599e01675443ca1cb433e095c354a8309e1711ba4c72d901fb7444111ec1087ecec7dfcf80181f511410f2033213c6a6e8786b89515b9dd51c4ad9091ea3688e5d1e74a96cc9a5ba0fb592512897c7aa4bafd71eb73ddf6b80def74cb93d434a9b36c01172555b754092f91ed16bc605a2592e6d6ddce25d52de0a20d24136fe2512d0e40f75707b5031813ff396b375b22bcd96c4be4b741a844d6a407b127e107defd810f08402108892053e2e1a30704ffc3462012050122a4469380c890a22213185160a40224478e6c481624495282c10519dc25e3061a30e1a089130f3a7802c207212889304209242c410140000410c504020ce0040314a08b1214aaad8b94038049c182ae262500cc6d0164a634a08c0af24b8187156a2b619ab48069720aacc9df166d6156a86efb884b59a86edb884b1d50dd76119752a96e3b776995eab6d15cda4275db445cfa80eab6cf5c6aa5baed212e854075db425cea4275db415c1a81eab681b8f44a75db5197be50ddf60f974aa0ba6d3397c250ddb60f973255b75de6d218aadb26732996eab6c75cda54dd760f9736aeba6da84b5b86eab6c55cda3354b71de6d2a6a1ba6d1e2eed2cd56d83b9b46ba86e7b874b5b4b75db3a5cda5baadbfe72693b55b7fd7469db50dd760e97f60dd56de3706973a96edbcba5dda5baed2e97b697eab6b95cda3854b77dc3a59d4375db365cda4fd56d3b5dda5faadbde7269eb50ddb6964b7b87eab66bb8b4c154b79de5d2e6a1ba6d1a2eed30d56dcf70698ba96e5b864b1baaba6ddca5dd4375cb772eed31d52dd7716993a96ef903977699ea96ed5cda3e54b74cc7a56da6bae53a97f60fd52dcf71694755b7bc75690351ddb2072eed20aa5b96e3d216a2bae5382eed21aa5ba673699fa96e79cea54d4475cb705cda68aa5b7ee3d2ce55b7ac75691751ddb21b97b611d52db771691f51dd72072eed34d52dcbb9b4d554b71ce7d29e4075cb6c5cda4854b7bcc6a5bda6bae5ac4b3b89ea96d5b8b42950dd32072eed0a54b7bc814b9b4d75cb695cda4a54b7ac814bdb02d52da371692f51dd72062eed36d52d635dda4c54b77cc6a5dd4475cb665cda4e54b75cc6a5fd4475cb702e6d28aa5b26e3d28ea2bae5312e6d29aa5b16e3d296aa6ef9ead29ea2bae5302eed0b54b70cc6a51d51964a18810a19618a4c0385301207ccc1085c94c025acac586a49c90acb8c0fe8a787ddfaf77137fbfddc7d7252c7493ccfef7152ecf93f4e82d5245a39097c7e588c87cebff99ddd9dde9ddf9dae3befbcd13b937c7ebe9c9c14fefc0ae3a4eee7f78909bfefc702f9d820a11db2211eb31e3e20f8c145f6878be48716c8060971917c98ddc145f2ab95d9211e5c24df6567b6870f2e82808b7e70513847e8a325046f70ef7c6e3e746df5d33365403f3d56640f40a1191158055cffd9e38621c82008be3b7844d63e6ce3e9b072b281067707ef6024215c936f346b42180909c968225da6f20682408420d8b91e04c5255cc27ea3b9c112ab1c6067c8807e7abeef6fb0ef6f3c975fc9f79c844e9077f0e922f2db0235e9a16fc810280c7f5ad18822b04cb907082491be9f3d74a875228f1c4ff4ef867bcfa7dff7cdceeb3a6f4eb71fd0f7c942300462d9114a248df6830c30743a5dd7d3764f2783a083a1ac7560083e4f36e19ca1ec3c91e6855606e8b5e7303dd91e967a267c61044366c92c999925b364e6efe9f1f1f9f9010262212166e6f7616666c92c9965b62b0b7213e4e60aefce095f96b649abc08856011f3d61da74226936224fe4d195bec2e16433f7a4311294ae4d6f9c6d2d1c15a564b9137410fcc0cfddfd7ae715d40ae378c3f7e5ba9e573d8f525707e5d2939dfce4d7e5acec48a4be0265cf798393389136f4ec2b27b0cec2ae14abb4b4aa566b85a083134b6ba2f181adf9665e4d2bf06fd3ca65acca772b086a69b95c1de875567ee12227a943c3d045dac0a38cc2418eb9f3a5d60eac500d23358e6bf3d34469219bbaa184e2ee88229c5ef0d1f7f367183c31506792c1488d9bb54e72a58b4c99a881099b6df9ba6ed7755d57ab7ce224d95ab62f5b29054b279836ff4a27e9ac2e327f5291c4c69dbce5e562d157f24a369cc6126d17e1f7b7bee24ec6401cce09c411e1fe65681cae03c12f8cf5f490c964412ebfd86f8f6060da1ce2a32b9236e9874a12063e4ac2b4f936499b4fc5bebaca5aea22f33bf1939fccc9237927903b5f5ec934241288c5664a4581bbb2ea4e09e7ce29dddcf99fd7754f9ba58c755d8fd2446aad247cd44eb491b469158b6959595ddd97e5d13949def93fd2ba6e8f9ab07b29a5c4698562ccb0e6b66d20b8288876828fca740f4c9bdf4e5dc79d6dc4937438a14c82651a4e5ac349f226739cd473e7576935919eb8487e895ae2f670e7d49a35d87d59394eaab0b55aab2b623271678e8be6b3010317c544ea37e600e74f2d31c29bcce5e60cf3ebb84eebce032ef4c8c3febeaf6777cb29a79c5e85334ff7e979288fe6f7ed5726692e0508ca99c691c031c8e5a90e7820ce9bb0839801e68d335371d87ce1431d5f48b065482e6808301b000347ca0d38fe812b26cd89ef14bc9812238e1c3b5e9cb1f3459d26a82b78b89ac30cac2b92703a6850307903079c115b561c78c2ebd47e38a18a34e83c3103163f40f91cb20f813a1abaaeebba2ba400e38501e99b31a8cc5c5dd7652a33767290800b194d703953070b0d0c31856f8121c7240386902cd8042142881c5f1c088c1a0f12c82185a03d5138b2b429734689ab37ee8120564c2068524b1a566feea06163ab8c91d11b2a36535084e0652a3650c83ca1cb546cd0b02923ed0ce94172d18137f241f9619b3754312e6f5c5bc891f2b6bc19837e3d2e538959e2d2cb5462d208d1c1853b45a46933831923d6c861f485c75185c5962f6e8ce12285865167bbec4ebb42cb04be2d5f842133a9c4784165460dd7130d5da6d222cc7d5da6d202897b7ba32e0ca3967d6c847e792a8e5518278b2f0edbcae16a035dd6b0628d71d28983c5957d5371a6be08c3e9727dd3f5bee9d20f7ceec1e3846f078931263227c021ecdb5dec56e13bb7fb5825e2c19e4c97074d2d806fe5bb9ee73df1264d37d9c47bffe941d3ad12abdd7f6114c19dc738893b30dbdd93bedb2332a4e63fad4c3e99dfc4e7ac83babcce05ba3b0cfcacf5afeb5ca0f884ef5cff2a3ca5bb4feb60cba9efbf8f69a44d63bf27ce963cef9bc6177fb5209bf0065e998f2542975113e1105c1c2da5a858d162bab245e3d0927ac24a85b3a54fc9c927ce48e0d1d634468d4c3d766ed6feb6992e428544514d59dd7e6e28cf93603a2bd75abdb50667e6de9a4e63cdb937994576612c293d89bcac89227a0a2594952c2325a3726fa454d59a36b989c4e3d8df663a89ac52a68bf4f3982ed233694796813374fb659544aa61f5d41c3797cdcdb1e6c471a9141d32edb3c7749996c2658143ceed3702967ca8040c1d28a95388460000002011400083160000200c0a070422911c04e248177d0714000f65783a64523215082391381848510c84530c432110c22086102619320ca2191b5000fe119b2f79ec20e98583a718e11691fa39be5f84663d1e7d5568c5c2e90c46c61fc91f537bfc407132d6e8571cb37ea078d81a85a8fe08d532b182b5998d69013d9c71789771c5122b9c17527f21b526f5b4e6b465ac4ddf395a537c3198b9296b86b57126b6c05b3df56f9fd74c84817f9900714e928259802658f5a4ff6f9541ad2b84f154e13037523a695e9f2754a5deec90a13f335a901a3be75bd0f54a724f810c69536d4d04212658b9171312f131e35024d4432e96ee8ad01704a843c4b94703ab55e0588fa1e8a38756627c2b9605bb7c5a310961b7cc6c6e78494891b7c06226f1df093469c07ccec0b16e634ce30f42f44c659e1ddcde70e4e3946f8b495d6ca37752f85236b222e838da1db0239b2390acde82ba8f431446d84acb558c7d2889d50fa64209075818a604537fd45d2ebd4fb748845fe54049309847ada679d79a6003ddfe933419ef93dae1aa41667381343252e3fb92ce76e1491e6b7bacc8b7393f999f6259c70412ffe03d4f3515225a586a51d6feedcf6c36189bee722c5839181998b5a1102b6e411e603f7f0e7af2cdada2827c62e90268448bf44887012665473272323d353ad65e207044bff3b76984da6a5584a625ec990dad613f477212189e01be8c37d06c80662b6d2ae4e82c990bd296c850da2f6ebd3ee6b3229660410843389ce78222091d201fcbce0ae0a4e77d2e330c15cbf9babef1e4c62485c2818e097c08ae0b90b40c5a02d552c262f557b55b37ad1f6289b77dcc81ec3d8c4dabfe0870de6b9757b0a7cf1ad492d8001ea9ce71494afe960758a8ec0a4d180334b21db9e049b1be4dac63e01bac7ad1c96e2154ca89d4d63d0775dad7ea88266ddd9921ff03235860c870cf35dc2553f666e9f5a1a359c544021f178fb55e4fb2af9a357fb5049bfd32d771df33cf334f0fed50f2e765404037058271620e6312754c01d375a736cb9e2d193ea3fb8e1776a82a5f2f9bc248828593022cb73661060810d2b1ed123fe001af3340a59303ba729ce3c9ca6ae97c74964e9d87fbcdeedaf805999ba5a38d6a3507d9a0d81f747e7a67b1cb4309e6bd7709f4b39176940d24ef7bb9c43cc8c240fcab1be31190c652caecbd84b3ef5f8c071c7f4338422e878481383f05dc987019d0232ac0856628df9a39c756dfa50b696367b4da19a9c14636c2d64af06ef86828383b3810c10601af19e6e9e9a52e632edd6502a897339fe73e4ff7f794598e517d9a8980d3bbf67959b26054563f2c0a90fd2e6caba6eeac97811db36c4df002c306c30c50868753b90adf445a62d87c71b5df90056e6506f3fa22b9642237c7920c04f2ad66a1dd70e87efc0e440b2b37748938e61686ebcf81f62ec716c6a449420785d09109fcab8211d1932523a47fb19207ff60e606f1f0ab329a71b13a23da45c5472f9a860dc1320e71daa154cae3e1ed0c26f0cb99c080e91e746fa3f99c4781d35c713a4b8270a16b712e3424e1e4ac969caf2951c96bac26d3189f5db3db9b95d41d4b0d9c465954e5a5a369035256e239b3153a57238a030dd19885b3501f60d45fa02b4cf21e2c4079808dbb9515fd47f4894987c633d1ad70c06862f42decc13071533f2c63a1c685854cfd38493f6bc9e5349b871eedb7e815f5e1520a3f31f6edce2280bc18f5922a8a170b152a5624664c55f1bd2a8c718590d154b03d03371f2f34837e1a926e954fb68cdeddc55ad52aea3d67062c13655f44d7978a1483347967030a30163b86a010ec9a4da939b3b4cf66d5ccd293de65caf3be3f1e2343a37fe7fdf05125815cac8b55ce2a431633010d481c5df059d2be3de0718ec276d215b6321612428f87c7c4617cf6b56222519974dfbee97734e52b1a3890401833e45f2f9fe06046cf8b81ddf2be892545fb65119d7887e95a257dc4ea2640d781c59ffa767c1e10be6fe4da8f33798c84612ffcfe3548d501d4bf576bbdefdbf43fe1f77dd4c718c8f755b895c6365ed1dbad8381a20db3ce8325f4787dae2bd8298b08eeeb50c4b25ad4e44e2d97f771f81680b6ff3c468f26eb627d0fba81bf34dff129a0facfccf1b71d8bf35acc5a75775c4a98692999208fb8f27e6ac4337016a171b90f9466e4f8e9ff72e6f9e3907eb2f29c5b817f8c01a5e11bfd238ffda9aaf282e86f70e87f6e79fb036d285b5403785e019e3e9f019ece2a6c0e59f8bb2016025be3ee1e29940560bead25b3b381d3919cdd91103a32f03a6a3546e8bcd9115f960cbfe89ac14a099df3f3e7f5f3a005f4808a3d26d2c1cdb5f0fe3a6122687a55a1293b2d72b80ba563dd0b9bbd481d32572cff070b09c5adb6e4aa242db23c49688e19cf0c895b090a37c160276410ed5723ad5afa835b9f3d1eb8a3df8691871fe4795b9968dbbb4decd698d8726e398ddb84634e415354c3b88d2d3459d23bf03de538685e1807535aaf341b2fb70919a90adfd36d82e1a88a089da0996d824e814511a080054bb6b2d4ac78215e90654433bbb1b1fe4ee9c2064ade943968e0d4cb630296560a2c4fca83eab3560828230277eac1d61224ac55eee676f298149e6772b53266bf0d6b47359bd004df6a2c534fccafec66bb18a65988d6ac84f566e2a40121162c11310c0cdfdd645f69d3c7701947a82116e12a8a94ffb363bf0e9b30fef63c3acdd4615e567fc8c6939fd8e3950f0fcb341080306317c8d97d6a716da352a5de4ff3794eaac4a0343a42fd5db26c349bcd80bd0124260d57952ddad545980fea828cc28f0265267960d8f89ae3bcde8151e1812e8c5510a2c4fd21aecd6e6dd6234482f83a5c1c0cd7ba0f6d7a506b8a4ce3a609b4628c9e8a2383943995df99fef146ce42a104db1061e4677dcda006328ee7bc2771d29ece5f8971c56300fdf1d3242868c845974b551ff2151a8cb280f0cc2075b8dc2d8a5806c370d115a20a9c546f3e9d998b7c90fe3306f558c6454d207ae51b0a514e579f05553c259a83217f068c3997434c6a307195a4ec17f5dcf04f137ce10297df7114f4bfbea3baf0b8f25042b84670a94d90bce6dafec1318c481d7d25e4b155181af2aab2b8ffb1f4551544d5fa5e16c8141d30cb5fb5a9dd00fab5f9bb37bc658009b62bdc7b0bfaf34b4a4e8fe239ead0968fab92a73050ab64d521b0e0a4656ec944bb35138a1a3e33f369f70980feb26c69a124c407824ebc035965d114ef6258d81175d3ba17756db5d69e5a0b427f039c7640f8541b8e12123d012837a8ad7e6955bc2bc56bc5826a4538bdbeb66114e104cdb134b3e0e15d7f58978b85f5c5d556515b54b7f52c67b338e3ae502e93c3257c0babe0b1ddd8e2bf86fe995403c4d8de3a876b92a8821afe47f812138cf3252ec9be34b3e0a6e07f48f6d1b881316c97b81dab215dacac75b80e40552c586dd1f2ef997adccf62932415d645de4ae27ee25beddad8a34e707de5948c2d559fd4b974a0644da4b64b54da45f6288aac52d9704c38cd364e5a46a25252cba012a1c8c4fae605165e241df31d11be60f7f0d71e3c981f2298dde1ae60495fb5b2165a7580d8f3b32f35a587e4034709081a38ce88be45f34b31dd85232b2b3059b10b22f9c2c50468882d0ae025615cc473d4a14a61076380000701b35e8285fa602dea80850502bef6ae6535645d258bae7d3e269941d8126a813bd24bac76d018d041a6b7258413a49f6b8a6c3611da3c7547a575a2825942539373cf188d96a5e0852e9db4acf01b52c2c29ced8f9f71bd360416c4fdfa9d4b3c152d0fb220e2b12f1bc376a197a4093fd558d2adc3e839fd6050f637276a83d7758df9a3b784cf2492ed6b2eea56d769ecf287db1c2e9a0f453c65c746985501fd6ce3498275c2bd57d2aa3ed12517af954593c6169b794c812c29515866aa7465b4569bdf04a80da439d6e9f6ba7a21edaf63a7130b0474ad4a822d850f8d1553549038f049aec7ad9245b456e8abf8c9eed2c716794a016348594e0fd48f3bbfcfe84bf82f65e1503cecb947d8cc1654278ffa7237b67d4aa97853d04bc9a736629e693d794f6e43711d02220c05c2dcd5fafa8640181540f2f49453ce9419b8dee6cfa512466834ee9e7bb937d3102a504ea62803561aa2084f4ce4ce52010c1a6ccca3b54f5015773f530ea1537f5060370584242c1d845e41a20c709e905e87bde3b6935e3b32c46a951ae533ec7a01a1e2873ab8550d5801471ed35795dced4aaa8c1c312a83251d4a84f276d6a94b9aae182e0b7ea72b184eddd286488663154d12e1697b806e8b8a90ea150c392164183e32afc05733ed8292420c87173ce394774ecd0b032405bdb7abe30529106f868e3a146836661cf7615241912fd2b9f5bfa5c1852cb3aaee8b87023f1555d2832d6db526a460982282923be9d598603f25cf6acb03a71b0d9387f1d655a223b3c47261a677d1808fff37cfb8ff39e7734d73ac7a073a90060cf4447920822c10f4e11f196de8277df9d4e20e761508747cf8d63e62461a431135d9fc4f2770f54674b64a7b003c8bab13812d367173c5d96d8395aab241f10efa96109f9d3cf674dc3474556c461dac57f00cdce6678bc99d842ceea7fb5dc89a35e9a0570ff5d9c91d7b64213f6dc672c1656100a7b3223516add60839287c3e6946b40535ae799aaf0df1a5d88dd611a8e4f5684458be52b6e15917d98e8cd1eccc47ba0cba9f1972d348dfb07c5fe0646e88685b68868bfbf3dc36b261c560ff497e5ddc71ba757a1d060dd0d3e9d8b3c9bbfbf354c460cb8c33d1571b47f97c1de8a959e53f3410a8836d7de7b6d3ddc6aee4d57c1df53fac4ba00de3bbd88ebdd9909f36636db9ec74b7f90abb9935e7296dc51834185b663a0cedf69ad03d0540a951c639bff9f224b25f876a4cb6a7964acab129a6853a2b54eb72897925b5844f589a897fafa40238d3708ab591f467fa2b952bc0e56f31b07efa71851e80e2b47ba2ad49a63265faf344b014756878b8f5fc3c91c0a09954687a2d7896c4eef4bd18951a43253d6cd1dc3ddc8a0c764afa8b65a00087fe415b70926a3a995b113ade89b8a59aaa42fbab28302538926a648caaafff58e306434092d04c233c7ebe0e789a0f1d6d9eae46dd8a6325f383d36e48ef4a6131a4fa204ccefaab8b87d7bb1c91ea08ae86229f364a39b68a58729e0ff2d352393412a547b192f4a14cb6668ae8f380e12d19325182a15add83bab2099e09f3e2dd5275f26c8bda0baa5a28b81721463728ef7cf2c90101d540b12c276948413f0474905d5e7206a8215c8d8e559865a082bbadf0d2bb8500fcba31f8d5139548bff03045de92c42236892de493e813caccb82980b031dfde3ae48ef6bc49c5c6332468f4b2105689c55132e645c9c88ea186d809a54b5742d11c32ae7fc6a0d3038ed887ab7be650817ca585c100af89aa50e25fdd3b7765e7cdde70ff32ed3c32330504e7cf6f983f369018d24fe3f7013cef17c845e5d8dacfa9ba812a72b5d9a0fbe3d9a5d47bcbf67b43d2065587e33508108bd4c53a00046b63ba709e6ecaa32afe5b6c87e03aec259f716a45406bfe56adc8f5e329f1a4b80701c4e9f6ac2a881d6dc126891634a0b77ddc18f214b347d6c692916b5dfbc8414e7c64399628e65162618b1e88169e013c8815d6ba21f9790854513cbe568f00ae14ec9bfa2442ceca8c6ad5c8824ace7f569bdcf5f2abe63745ab65149bc3fbe6c0b5785c116ef208ef017d02f5aff1636cecaa05e09e5bb522e0dbe0d1ed924dcbd121262bc9ad2a6a8748165ba15c542cbea0d5fe81d826c4d536879d1f5fe8584108012736c235bdf7927a704d5bb62d9d947a81058701ae58433890a51cf8e217fc312e5b169ded94efe6b6481aae83cd820cba68c406d27f90f8891cf5c13594748a56c67e26d5fde3d11f37910e98890daa9d4306f84d6c0e983429a0a2f5819c677b2e65b0c472a7778341b25f7f42443d38e0736f00be78c809c5e7c8ef3de915ad25268be88e178ae67bb5da915005260b9c24daaa28b84b517ca3a55d0cba7e0b3c546451c25141474f0aecfc3d10c0b37087c20f050ef77ea44268241aefcbbed82ed3d95871d01df3ac4ac58122415b720ca3115305c31c708ee8df707fa8422a20e721eb102814b232586ed9b606b307e9beb259e7f1aee62038e737fe2b99697c188aa42a7620bbe2fb6c04501a51b233698b5e5f515f191774ec0e9c028ccf5562ee5c4a4fa0f64fa85c186e9867beadd179e8124f63f7b85212459b236622de6454180ac475b59109057721a0826b8d51adaf8866fc028aff5616480418e4ed45694462b7eb5e963666ca921b3e5418354a3bd6ea488282b83b5826c9bdd8e2848176d789afd4f7e62b9fd17e2375203e3fd26366b70fca43bacac9b7d0560c57d5fb5fa7314162be7fb4ec70386974d8e037d22f7fa70e2a7df0b885d1e9a9233508e3012c0d230dae0d2baceaa3be857f4576969d40e57daf6240f54d9f37bdbab66bed2300e6574b711c8b703c6856961c039da44a855cddd5c8e8a7bffc5deddf1c7523400ecca6bfb749aa214f524530011cc91e4422f1e8584c75967d9ef5b8f416ef16af03942ada14299c3d4d70a59bcb40b460a92ad0b239513e7d48f4ebd974a4e5479d1eeb4178d41ee417c1d011242c4e17eacd8249955a4aa9f7540bc5b8e430fa8d8974bd850cd48171e1f5024996bebff4f338f0a024d13262ab3fe56807bfa9d4d5979a5f0b42ab3b04d4f19c474e80cf1fb2e8d9e612723babb57e66d6a326a0db6a6e18b48351d6fa394a71ca174aab190c94ae5d589f04c8f2d9a12b18f53150f2899e89ccb27ff91ddce3345afded292707144e392b581e4849ed43bfc051babf6463d175bc994434edaf9c6789fb9850028b8d74f431a033c8e6763268b4027f1c9108f6f218414ae1e1b1b762841fb748891b8adb421803f11c2bdb12c6a0d42e5d5de84396f6cf6d407092c3bf5c406b1bc1cecd31dd990da0f075eca171d3f0ada99d16145efc1e7da565301de1ed10a915d77e2ac5efe45430a240046b0145f58b75ccb4d98960109ad9263cfbdb598f08694c1011ac47e0fe1290b203faef9bab3fe1f9f82f6461ae1304f4bdaf6e6f949130f250fa0123b910dee0e62d0d3e0dc91a2cbae33d0efcf4c053d16d1233bc2091764ca7b85f29e8e14d2747d8564829f99310d28009c8836e39e3af0ce757ce1bf85c7238f822f29137dbcc37d3f0342207516ba79c607eb919e97a013257772e171eb84da9212a364dd1bf54d7d4e106c0c0be94eed395d5aa682a1f8b8b3421c6b59bfbf11b8bc8536d05bd80da44fd002548db3d605608e0bd664241cf19744d676dc5125effb00810ef332c47d0cb9484fd46715e40f9eb6817686a3084a3a40070ef204b109a11b326294815931e4c86c9ffaf6d0a314788d92c93b3bfca1a1e1733270a194cd274a336678e8833e0bc51b77e792cf4c0e9dc5cf643f2f5d03a93b9dc4025ef80f9443763b77f8ca09c5c5d2380f3f05d29c8c0df2d5a6e49ca33613865edc8527eaed125f0af8cd92d5c0556385ee6ee189796afb64d8190dc57d4f4b8b5f93dfe4d7c07231967daf15e21827c85cac6a977058356ecce0d1cd92f60b0700bac30df9b560702215826dd6d86f07270bdccfd475a912f6e0ec02a5935dfefb1138efd8a745008b223b1886fc8015d5718d48b860db05955b1074d92bafe5823d51344650853d86f4ff773c46aab645fae90714743de5361d050e21d11f9c4a5509ef60eabb162a204d1fb1243bfabd86b7ea3a1da566e56ae370b83acbed768aed29b3b18a45d1a87e23fcf0c550dbd663f581f34b0fd8c8c6e296c0ead83186c62840143cfb76bf7d3f2a70b7cf35b61311760ca9bd6311befacd0281ea17d8a0a6aedccf4d9255c4f529685987d37918fb2e5504d174c4ab5ed72a75d7e4a2d60677214b58f653f960525addcd7a4eb9603793e4305f5cbf7bf91e8b57e498a70834cfde331112142f6e9e51101fae817b11ae2584a8f8aa06213fb39b55027257e7c801c87fee64ba66701d1cef47e7840ece7d085265252be04958ecefe3dce6e3c29c0147d778536f985b43f85f163575d5e2b783386b5e0aea373ad7d5e83c5202e9562ef0a4de9107aa50f164eacba26e784292ea16198d270a14ed60506af0566f77b3cbb48a4f75689ec8861823376d0f7873af70016988a536dec84c6533fa55ef49e277c01b5982332113856c41fb8cba8b2817ea879a3d2f34aafcf73255dcac858771cd324fe60458d3e60f29dccdac5c9a0753a2f7a60238f6bd422853cb438690c929191a91a85529bf1992bf750c630517988ef7400ab85d6d35119be8259496369008aaa0a8af84db509b1c38abdc6d813bfba97c3f62237dc27d85030c719cce17a9fe97eea3e0a3824c159450c19dab45b7a648ebafc68328c6ac55149e703da4d0bad530f4ba28ce731296b5182553000642a9bac31709a7e39f3580e94fecafee734d05d04e2982173771a08f99ddd85506839e176ab380135759333bd4fdbb9ecccfcb4a15d5aca3ded4ee24cc6d3362e39ff3a6d688796644ebb9238a3e0b48dcbceb04d1bda2d2366d3964d99b4f4e4ed42e0554a73bb584008c9ec0a8610080903287e10718edbe0c30e7e045be3af47a372784dfba8f18ac8f5ab2491b254386530108451d5902513953d47bdc9bbed179cc8e0f0b93fef2a6ff01183a8691e15096efba1fd99295c12ef159145b4420cad3f90943d4b5aa76a425496a63f05041667c8d9a59e89d50b24ccd53d85d4c6fbc03fe4575584f00aef5b9ca2362312ef0a3858e5a32d9d23bc5971596cdf3864e1c5fcd43d2fdff24eb2b3b63fe861cc75f2240de001c5ca56e1321ca4e467f3c2197100ab2592dcdb213e71cb2a0d177842ff98c70ad309d398573abf47994866c8007b79d2fbc1dd24da88b7d24ce411dc6a516bf169c8103d6429ebe638fd4cd24905bae87a8c3d743dc87d753ec43e5d1e635f1d1f739faec7b04ff783b85fc763eca1e321f7aafb31f6e9f210fb75fb98fb743d847dba1fe2de3a1e631f1d8fb9a7ae8fb14797c7d8afeb63eea1e321ecd1f918f7eab21f232b13018c0ff4d0eb1bd5488fd614f64951d4babec83d3f222295dd63765f9518d14ec01105716d40ace3659687e27f6b6aea84a772aac0727bec47100faecf492ea65d926ed5d5d34ed6a6db3c7d1035a16591f08f09cedf0abad4fcaf5086b546781f4dbd3278d4fcde8f531596b3b992efc5a7113a7369a14bdb26a8f1080b1e13a7e803776389eb96edb7a8d40177bc3be0f28bf2a64bb690ae190fba85b10021f482bfbb1c7d1e955c6cd6ee17caeb2e8b397c6e45c76cf8528db8f74cbde4d551cb164c9c1eba3d480f7058fc597998bdcc36f5b5f1f04a179d2a70f1edae5dcf3dd3bea8c0868f66d3e7be57de0ac46f77715ef7cd07d4c5a3c988b398862534689d06408389a270b6369a66a5378745b9f2aa86fcb9c6db3b3eed580dc6552f875da3ed11740af332fffbe3fe7098a4f219cb45c93561d1fea806100b8dcc67ba65413e3b905b9899ffa7e3eb495d46ce782831787da586aa8c3b5cc5bf58b77ddff7d039818060df2198e9858cd961199b31124b978dcf4f11589bf4a3888301a14e342ca4bbd5e6b89611b5c353753fc7ae0c413d416477c31805bc64138fb9247c8502644c0224b99c80fdea37828e1253b892658b9591fe010fed1f42e8a28b7ac14301b45b7d7e246cf046cd92c6084827360b411402a22547a78ea63a80962b2fc60c69c3391d7c0b2429b534e48206b9f2581d805544da231ba2a4d9f702a23627c70210f08e0af8dc9214ae9063c5afa96249cd14f94fcbe6325049f256da42e24c9220fb7be600219ee5c06c7ee57f59463b657e9bd50cb1cfdab457ce9eb3cc12995a887d5980bc65c1ac51f99810909ce80ae88e04da59d6476b8a644bab221aa502734575203b12c05e791f6d33322dac0ac1140b981b5581ec8800fbe5f5e00dc869655544575a682e7405304702ed2deb83352045ab7513ad7201b9d04ba01d0b69b7bc8ed600292dd795e80a85e48056817e50a8bdf23a9a2624b6b86a82291422075a07da4321f6cacac19a23b3e5ba88a6a490dc2835d0e3802d6459650171444955fa3a7d1615d18eac89c0f4447185740ade65d4e17a8c4c2ff015ca101846e8a6819660be959e65af6038f59e7f1b01ac2ce956fdd8ea06471127a6a88b80edcdda7bbef0027f71ebb0925024c4dbaad36cba3b58df4f1dcb06cb06c2b15063d00a0e8403cb450380767aebe024c6ab4735241ed1e28059b191ef07077961cc4c64c9f79389b8103023b0e6fbcb212b08981735f3fd71909503990bac5c7e58c49623662246fe7f7964a50033b131f71f0e9942cca8a895eb0f87bc34664860c8f5cb455c123122b273fde5212b88988bdaf97e701095838c05a67cfe78648b11732256fe9f3cb2420823b135f71f839452c8acd8caf78781b830642432e4f5cf445e0a1811b373fde79095440c8b9af97e18888aa3cc45562ebf49b42937212762e4ff9747560a30131b73ffe19029c48c8a5ab9fe70c84b638604865cbf5cc4251123223bd75f1eb28288f9132767dd46b245882d72780e6efd77aad265eedb4b84e8dda55723b69d2280c62ef2fab0e90942f5fa2557039b7e24a8c62d71f158ec2d0274dcd2ab8f854e2040eb2ebc7258e83501b5de920b876d6f13a2e12cb89e58761221747ec9cbc34e4f11aae9975c2c58f42b813ab384abc566bf08d131165e5c2c7a81107a73e9d560a1af09a8774bae1c167b35b1349fe414cff74d81cc5ed8c9b94cd2f00a3a4efecc826e73f4b7dcd74007c30dc37521bb78fc429fa85e2f633221b82062d220578d080a74e9963b505627145cd330a94ac03ae50f81a5bb055c3cc7f0b5c399ad7d31c3518ea81363acd0ed1e6b43403afc3caae17c382a1f4ea7127f8c7c2a6de48e7f54e9e96341feebf8a60ea3573054867aa4f0838be382b17bbaa49258a856e19b386677426b161529f0c858dd04997d417a6d471caf11dc094e0e72d8f18dc4f5e67a3449ecfbf89cc04939b7397ae1565534992f018fa675bacaa3d3d2102954e6eeee8a6f6b21f9a4738aee0c796ce9bf98727e73ffc772758621db8d34bc8db42bbda0567ace869a44dc142b048c7ee9a8bb6834880fc80796165d6822176e2acc124224701275b491160458d4917ba6ff1137ef0cab2a2bc6d013b84e7e1e29c3163c961da8921edd5784d84a0f9efa0432db155379f1266fbadb50cb7e0e083f878aed2f9b14cc17c782585087ad4d33457711e1729f6084f1887d42fd4644d6a7ec756a363654d63c8ecd94676ce0e4bd1067169fa6fab643d27d224cdef44a908f2715c3ebbe35adc470a532f021433382ccf21f2968b384f46825ef81aaa80c2d3339b5efbf6b44ccb07a596eb14670e09adfe230569e9b5a8d16b1b8357d966c8ca6dfdf7baaab977e4397553c99d4c5650c0c6f1ba113e1723ec0853073d33113d9e97cae7e9b6e11d093bf854f3f6391702bb13ed261bd4bb968eb0a9b736cfc69b186dd11f2d60d349226e25112ec0d278f5bdcebfedc39492420eb69c221d67ae5c5bc2ec8de209df94549534b745f9531d56441e1926e3709cf2e87dd61356f6a6027539e119df563d19f63a28ba7af9e9ec79e3ecda97d00bb694adaa66a9f55ec31705632f84ca7c7d07dc6075e7754df867dafb4e8b095372e3c6db295cab859bda9df10201f79f6120107b8adc98be26969ffeb21611dfd7e7794a884ba5c9fc7fa3c75734a6104cfb910fe75c748e1fb1e59569a5267d9e96f054bb3cbab20b38882825bde1df1f4f62d6f61710444c18716487014c517a058f70fefe79e0be48034f5524de6989b7d50b7b65457bde92ff58026f60c18a9cd8c3a11390f64eaca5db8f721d5e137403cd7adb664bf5833941d4e73023ec694802400d29c5603c065d92ba5176ec2eceeca28c5c4265f84007eac27c14eb80a1d4acf4bca5e6cb240b16510cec5a468e64b4f7b7cbca46b7656195eb83658d7b25f7f179e6122c3fcf88ded36270086c9e67c47caf7c66c96e84799d51f25747716da79bb600eef7539d6c8fc9bcf4ea7c8d40c7a06b40d20390144f8f8f54b65f1306b07341e2b935b88592092318267b14509eebb573b5bb439a0cff63a25feae606a0096c4761b67a0cc28dc5d77043b944e5aa279045c217a39c17f93e0b6eb2481ca89c2e5c2b9794690fe9a8e821ed412200eb7684de10e8fc44de51706fdfd8a75b326ba1b32c53e083709700719baf45b5f30a653bfb002002cf8b21310db1773bc429442bee053a8a2dcf438768002021315fe01d43c7b50f26d4ada50a2e5d066ba12e27712f076df2f15685955586f194189b8c005c5a22e0eaf5a114677c1052c12b9c9d752666d3b99418d5ed2972214a32eb4991308974b6e11085db7873389a8598a6bb5d72bd447fee13dceeaa09a8a96a51326abb4d9e9c608217e9e9b8e2c6915c2445f4df18f6b43452faa6b3d77596e34caa3cf92ae04fbfc0227c91e9c087611612e5541b93943b1d3cac13819d66aa9b0130b8a7c55b2bced8f63134cb6076c2443a918f5dbd52f16b1958410250f56b4a0639b2e7ff484ebbf8f41d76058c20f76d70a1469d3165c51da10067bcf77c485ced737cb06d4f94d8eac408d2235c2ad2cdd3f4526fb7cf44d6a0090ed7bfca0319af4b2144ba13806a764a4e1fe907bb8193a4b4e1cfb13e0c5b85013683ddc08bac6748345c19d04a1d515e11d55e39d4b6f0b79e6077f73823bd2a506e076b73a60728409d622d6b775db016fbfb6fbe56ea58e550a825323d8b552dce3e70657add147d15b1fd00159a2967242fefa37d8022d17a0112e373a3201fc1dd32cca4edd3dd9dd8eb20037d12545596dc1818bbf09b676abcc273ca9b8a08d7761a8515add6582f9c7249f8a3145a461ec83d8ea4aec5adbb7035d8e66e8e619e20b379d7ae071d4838234b7362f981f389dc18afb8299f4ccd6b4c5f308149f2fcd89e888f64d6bd44adad62f3c7a5eac3ace4a7521248976edcb06a44083741105aff0f7c2a6fa71f3dea9287372a81f17e29991e3bfde777668a19ec16648c4fb21c21853aca3c045f3ede91acf102aaabcfff8c6a8ad62c1e612f9e741c102f8ebf1c02ad66fc5af60902877f279094e312954adc70c1ef7d12b855c2333d14c68732ab73a8c93e00c94565b1e755ccf4113c88e8d47c432f6006c326d8359a3093b6ebeb9512414233e72f400a1934174c2d82b1cbb4df7cc3315e84a12b50de71b60605ba6ff780859cd2fe063eb05afcb6e383537566752976787a58db6be0eb88d1884912e51950740c1bdc948cdc01bc7da5a585398132b9dbccc96ecad097c85656481f4042b28b8cbb2013d07064bc1199c3f74968034c15a14781f8086f0df43389122ab3ece51ae1b83874d59c99802d05b34d4fd06e9ad58cbf487a4e78d23d6ed0b4427e1ff0f47c2247cb90eca4688ccc5629b10dc830dc255a72dd65c0f40a508b24deb0e5008183dc1061ca6d06408b30208cc00e0bb5978aa5ef7adb862434e8f2d5fe71aa0a57063f4333408ec128244d7c05d253c78de38249c12bec676f1ed2aa71e350178565646338fbe1e155fe52679d282a68e05be44483e463701174012fcce3af8e56e49b4697ffa7df43feb06ee718a7d6e1615169634f3b109599fd70fe49dc9d55215585d637297b086ca92faebf359e77dea47703bbecb70a607f44332795f64e5c267f33db1e44420ec4703d661692d9b6e88d0e4f4ab55d9c0631885b1f44f36a2be002ffc01c89524ce544486aa82e15ac9884a7ef6ce2e5640d3bd334eac12905426b2b771418a99d924c55859504643e828a40d69de91d013a2d62c61fd5a958ee518aba792ffe79813305fab11fe67f9cd2250efaeddd98264b3064ab3db1873b13a0d124fb6a171b504f9b624cac3c6082ade878d6632a4f07950cd4ba95366c1bd42bf96ffd2d1b56b5483c140c0187a37edb84df314d538f61d0b4433a04b174b8390f5b641b25aa159e81835f8832ab19d3e679fc4914938ab897158bc2e2b309112ce6f69a542c36bf861df3c06ebdc296a5189fc2dc2eb5748110a7e749a4622e8018020d22aeac517a42912d56471d784d669a7c4386cf52d072fe5113700806d77b59cb2089786d9439212740acc868e6f7a02fe30c8f6ebe06bf52fa5328503819945d970a0f970e4355dbd9464a31f90a689e7cb3c7c3435ab31656d667077cc1060f53a6aae3a6d2a767cd050bd367b101b0041ad2fe2bb23f76944051e6df5a0c49a329167b4728f7ac7ab2f0386e825b3381c4ac68048d0410f03c65b004cd2b8395cc66472fd3513a05913f8e3ad944c8d45fc5ab1d12fc6b94c6ee8234cb56ea083fd6e7142793418a253a032874bc0a2efbd0753e6345a4b53d95403c4d40a9ac3c034d539e661ed2ff06688789e6ac1b8e76a4a3af3b940cde3c5fcc5f41526002e6975a8123c3647b0e1475a5390bbfa7c6899056bccb9ea0695e38366003dc56a62c658b1b4d990cd95554f7b33c472aed4437dc505eda3487b4e57dc61f3d7e9dfac66715275fbb41a68f965a002f3c221442f3864d53cf10a1bf5318344b1decb3999b39e1c06a8738a439429f5d83f966573582f050754ca212366ddb19e5784ab41ce278c187a92bb2a24b2bef50dfd582f2624fa81ec1206bc7fa2cebe5f5b1b66b1a3c424dc7228d77ed211341f90d6a7932a5c5f0b1330eec3d2f1ebdc1d78e9f3f69c31f0b268bc545794a4a76b19df37ef42d987c74a19752915a78aa64fc5c016a683ae0ca14d1a4e6582ba079f862e9df0d5635283e04e7c839350b4c1c60978050ae78f13b08fdf37e155b36fc2cf5c7e5d72eaecf2c7573e56ada22f4fa491fcf05ec4f820ceb571cb817193dbc07ca75871439caf688fc846a10be9cc03620a1525b233e2282f2598dc616370626d4b537b7e9d43de831acecff895768e953f037fe2432ac3b1bfdfd55d2d476ee491ec11d6b6c7b8e9e5276b0cc7df4758636ec743d2abeeb797a8b46682a7a4c9a1d8e9393c1185e84ed1686f9e385ce4c0ed0ff7cb518917906229432f61dd48563cf3e3b94cad4487eb08b1758e3660e914b6f351479e57199c33b1bfe4b56248e89240455c245eaae2554a54de941bb958890d4af51c8986951950fcd12254d4ba78b5ee41c400327ec2eb37701c591987d91333942a980f327a70055954f220f4b826cc79c099550309816de8e3c814557d16a1a73f0f8e8139a2135f69f187f25cd5bdc971a912ed28d0af229bd207792310f7bc3a9732f70c187d0cc55ce5545ca726d53fc00a9f3aec619bfba0ec4b4852776d589cd315b43e07c13311258379308c11b975a438e38cc50a814edb18ecec3f8f33119ec7c0bcce20074ea60cc3750b05683cea2f486ee98eb26d17515525c3ed37cbb10a12411dd1566cf6eb8f3681a0e351b388dd8303ac60f8931fb3ca71f561e695113b976156e7e9dc11311c9c118734e5b92341199d10957bf496ad371c10fa947cb48fe2d6436828a5581dca2c7668a4afe42c3c1bb23fcb258ae3ec47ebb44ef07a73a6f4f24cb9289648162ea6b51bd85329006461e921428c310cde6125d914906222753416601d453c686078cc6a5237b78736811659927c43a2b245e5374f0a0788eb5d63541644471a390e4e62b27812b3e2b84f2f05b049b358b0546aa1c30d68854227a2343ee3293d8deaa9019047d9f5d50b172545d6e8000cbc29a6d1cde162c1f4b91429e394314a4a3f54fd87744ee82304bcdd1d55e0310c830602c74fc92e094a8b27fdea2b286b8b09ddd78a89012d66c01c6a84545727629ebd5cd96c950c8548ed4fa73981c7039064185e4f28f72fb60e115b93835df6938d8040194dc447dd971a76f5d1a85ccbfb05b2d60a38a8fb47f22d95821d1b53d82c79402b872db5984a55352a181ab3a5e38e45e8091fb015db034184637304b5eac0b1e9c0386be3cad265ca6c67d25209915c6bb0dddc0893cdddad9027c4178527ba705b8abe9a95a4138a84a7487e95651db272e7b8dc344966e58530362580f8061088174a6ebafb67646227f9a89ad0f82ab479fd8afcf063536e726451460561b635465adc3835a05cf612ea1e97e9f91fbf8be34d6b264de119ea7d1dafa4b3a76062c1643e22ec7ea17bb374a24a893d0018b73c1a0d42aa9721b42912532ec8fca885b59014935543f0149716dc72f86014e2bb74badceaa228d5537bf72b538a27e52bed4351a8a06ea638797869c25b065924344010b811eec5cd9f60455e81943189e473542b34d9cb2ffb05c5097dc2cca887be639ed42a2f8634f496d784d2020eca218bf249298b9a82f3e69355ca54a44b0ad3f4cae5eab74e4900ff7c8261c38be5d2d3e7a44b79512daf3acd599e7779522c0087711be71959aaa4ef741648cf059c60800bdb9b96001bca50c8d385a9b02cd46485c3958f5bc850d3491d61927b524424114be8660ee055559ee32c4a6e488c37272409b062c52059cfec17f6356ecdc22eed08112cd85772c0e469c1683b673d84eff8c8a82db8c3faec2e5c6b62726044c6a8deb90dae917dde4d0b93311a13ee12bd904f179c601b49e826b0070dde35039fbfce2d4976b4018a876641e1f348c50ced53db4216c4895dbc05ffbbb54cc74222b11514a533676ed04b2b50315eb5fb75c139c84e5301a0aa9f21666ced5b425a0008fbfe21a3b60957fb1779e379e8d00ee2a85a8dbc45422ab71def9b92a992bc638932ee17a85f0f425f3ffdebeb9fd607501f3d35233f9e40f1c6fea8c56491babf5a2a0f8c08d2f54a98eaeff37dd8fc574a9a60212bb74ee8c4650a9e8b7e14d2040becdddf171b23c5ba7189aebb14ea0d7bdc5496e316b2c74a9dbc235d0706bd92a2e0ea0bdf48c5e33ea053a9e283e4c67f94722cc757b392ae2123124f03c88a52a8dab26b38cbac4347e1f70a5ff08e892f397159e57cbdd15d86cdb918dae75630d32c6724bf9c2af8563dae3b8325dd138534984194867173e7d9e8b906ac9e97667cefea387ae4a997dda43f1afb857c220128fdd3f12bbaaeb7fe0d1bad7ceb4b532f1456ccd5d7af3b8d66a74706cfebe986c183f3ee77fc7e3730f487a51cd8770d4ce115ef8ab2156baa07912d3ea1822d6ba0c5be7777bbff161ec792de29f2940e10ca0ca162708978450a12f97c1c5f5a631841d3e05991e4dedb4eec91a8aa641ced9f0d01ca8c4f991b117541c19fb4e8c141d9c30f37c0378f03f10a26adb849eeb21a16e2c6576954490c41ab7a6363461e7396a5439d208e1b099c1f9850383a402f010eb8a8fa566df863af97f8301e8359466eafb6df57c36a0e3ff90f9b214b6d4ff2879eda8058e7b6b3ed7c88c636c7e588b0a72948fe10a84f23923d37f1c172e21f138f3d23e34391fe85bf90bd22742bcb86a7d20767d161acc8db632593d707745b7e38be07e745ddcd3ebcc1563b587f208930f5bfa0e641ca8939052eb71e6fd74be343818e68a311b680a058c6bc4af003fe3a21d5082b94a5b6bf4edcd6eef6de7ca35cdbc4bd7f88da7bd1efcac9c223e6ebaf08d17d883cff270c85c95b6060c6e66cc99f99e2f92ae58f5a9e798a8e6f3eeafb0c6a06f9f86c7c009d53c6585e1e8e9de8edcd4efd4128a7f046077e353afe90489ff612808368f4e0200f6334b8f38309d2a4df7541515a9d65e727e8acbfb85b02942e15c2578bfbccf676820298cb6901b4b7e03b8322fc15ab49a73f19d7361d84ae9a9947637aea0dd511ad61c1040d2297b8b0a9ea71c7803adecd828267e2ea43451b878d47578444b3faf416521de3205af9788d1bf64bc580e0b9c16c165608bc544e9b16e6a13225b4d8ea58f2425772497ccb8f8a8871de6d405fd746fc0b15af0dd4bf8042b8b07bc8c5e1a656456bd1646676fe0c560a6e067c5413a9459a88919765fd2dd0f58b50a48e958381130d881243bb127fceabea4fa5a112aa0fc5ed6bbfd638da931efb6a48e439191f010489cd32b0b31e6b4553b5a41471a85a90ed1355afa5b41c2dbd525bf1ff945dbfc3b205467a2b602fb65ebf4c09d254b2eb2ea694e2f3b5b239550db193ea969d62659e1a015f258e648189217544a0af6422b02f0e5db2a1af4aaef5c0287f9cca3ae03ddb46d3f402c52f36a4ad3675affcfa6bfff69b7689f181aca4acbb683e19facc9fee7ceb50e32536e9db29495a41c93e668ad33101dbf7cca098506f49db7c2e4f928212cef2ac534c7bf489166ba002ba738997489e770c76dc963667b8e5524e33039abb17a6bb6980a6948faa82fd97bf5cb25cd1004f3525ccefd5cb046f2396e3557c24e83e7e1c664042d3762bbfc3fb39778568fc67363696be9c8a01b580b35cb6be6b46ab4ac055f09de5ceaad881403b310c8d3d7104356d3cb109e1e141c1f75de703225d15801fa85784251b785996ca76f9884c5d5602ecb3568499fa1ce9b54dc7ec49f8482d41755fc20d89175a1b06d362265af4b2c3d07ea82c5657c6da0b660b37a66ebe6536dcd66297cc53f8d3fa6bff62fdadcbb21be3c3e63654eaa9a0e2b8977b80bdbcfe23cdf57ab952d2cb61635e5e445ebe31c9efbd1b6ae534ce7ed0e5043b13d9b6d1a09e8e81080624ba036aa12e8657205816a703f9819b4295991c26757055b82fe96e34a8125773129a97aae8feecfc88f8292ae25cdefbe214013b2845fc8cebfcfdeea32ed63c334d3907afbb01306e789d8d7d99b24cbe15ff2bbfeddd6d6fb9a54c29c922086e0865082017ca6ae58c133178d272c44b5dedfbda311848f6b6b9e8125d97df43cf35227288f41bf8da1645475da04ffddbd8e28c81c7d54298955b468e2e548531dcee55c49121da6ac86cf9a967385538ddf13744fac97bfe86742f3f9def71ba0325b889def3a61722f15e14f6d7bd28947e9aad71b26eab3e1d3827f4f20bc2395f28fa49863cd024647660284412ea54daea36385220eaba3d65a06f9bb5a512eb8e0c2473d49caee99205c9648e92393eb329cf992e3f7533500ef3d93fc99d2e3a1dd4665ab7ac0134c61d1b48ca88707bf410c5ff52a97dac3505e99c6dcbc2ca58266d247f75570d1b48025d1cdf8080569427e59658e0b4180d9b3c67cf6666e7d9546b588b81c3375ad82fa6f1d7f193180c44a5c59101004c654db7f5b7b8591c1e1ef73baa9b099259fd97959033a328ac0fec77646f2628b9dc023e71109c059e71e743105272cf6d5828ec868db01899359b713f577ef2d04f959f9c59fc04abafc819ff8ebb7f60c7ee59875325671c0b3b36ecfaab9fbfe3286baab46f335a0c3ef9cb8eb25a8d9e4dae61ad86ac51000e173e15a6f1279bb66d75ab9ad69a0264cd08a4e8353e388a59de023ef97b9be13280f5ccdc09ee197425e48cff085c49cfef1cff10d8391d14f65ce7409390d073cf21098544fce47f822acb09f17777fbc08259cc624d5517c0bf87a0ea1a1ffd4f9a7d66c82c1f66b399aac539552db6142ca9e73d3df349a93837666656a3a767f5faeb703269d1574eae4f958e97f5c6d2413d9be9c857b779dce3038f0f9d5729c4853aaf65daa9e3083c422b5ba7aaaa565df3829c4e2693d99a52266b56e17d1e15b57893999987300a08d6b13f1208f6c9019fbc99d5203fe1f2fdf82e87cc52c352a7325953256d4ed77fae1ce5393e5bf7f975706135cdfd4315d871aaa6ca513d5389c4b0e3545def3b551368aaa66aaaa6aa67ce6da31bb349811030856f0b4b58774ee6fa6fe0f51bd747d77face17a3f7b8ab9953842278f23ece839d5bac123f449b0e9d0e8f4ecc63147b58f4f0c34f5079a5af4dda110d193422426ed4dfd2ea24762d24c1d9a82c43ce987c0c03c2914220a212ea19531df27c91975ab5b2d92625e5efbef9afadaf3e81aefb570f469d15bda57d1ad1730941ee2f8c94d3a2f6fd2417b17d29b86700ee9d954811717d2cbfc8d1f42fad18f42215ec2286a68caa17ef8fda4d01444e66fc8fc0dd390d29bbef4a6973931a149fb984f920313923ee685903e26441285f7484cdb9be8c39042d37c93f6a497425e3ee6634224a62d3c22c4e5edeb2073621ee687c43c4c28441442460ff342d810498fd7109851a803f3129a667844079963d2483fc4e54921920f63432c29dc2149ce2881483ff6c851bf7f7c1c2f735ec2284c397491ae2b187a1238fa17b0e56340978701edf367d291791d648ecc0fd1f1a5979f497b2dd4b9f144748451f49b1e3469323a748451d452e961625e8852e803cccbbc8ea7610c1da9949f489fe36352314ffa0ac07c8ed0a443223de7bcbc3ce7bc3c4ecb8032c7049ab4cff149726e80262d34e9c8bce97384486ebc298c22f4329f244706bc11de78ebf242dc08b9c7becc9b9e86314ca1f493cce871b8fce82b601f47f89cd3d2f29cd3f2387d03e49c12c8399a4f8b3e5068ab35764a04b64fa7564f7c7c644099d34f80a200d150ca74b956ab2d86543d9897ce051c81cfa305b4626f5d3d11d82993cbf694b15351ba46037275cd4be698f875790a50bf1cc6b039e9cb6f6e73e3d015767e3868e12849a861b87f90a7d9da7713460b6b9bfbed473b3f7485cd71a917b344429d16a77dd5f4cf470d400a3712a5e327be3182056d237cc32d1d1fdc299bc0ac27ecc3eaf7a4117e59f97cc8a7d35ba485f245ca481716d3cc9f22c847c822a4b803d37012f2347f9271e78f3d1ee0ce25eeec959c9993888ef7ccea03e4e0ceaa317d7af9f3a1b3d385d2756ee897433f9d6c61097bea17bdefee169658ed76ef3d0c98384211d6c8d9e9de7b9c762f7485e52b67a3be97ec83c7117647e97f5c61fb8e7f04071df7fb0d748267cbf9befff3c01e72fee6be7121ffe6fcdb3770bbf2f3b0449234fd149469112cc2f38aebea4427794c665b62666ecf9ba51668a9856935d6261565a0a1659a69bb49e9943c7b761bc8540bafe4824ffe2bbed144e7825132f0c99fae98891517ec6ae6e94dea69301918f5834f387ef2e7e71f16c73217923022d2a6df9f0212c55b704e7cbfc3944bc4515f58e78f8460bf173dbb80ac0bc552fae431d72808b67e5faddf8878bbd435dbc4a1022bafbf1372060792c69f03d9899c59b1941d587eb1ab45b0087694414138ea4706f19c6c92a1243a57ddfec0b130af3b719557349860a7044836ed47190433b9baf910c1ecc82eaf0bbb4edc6a8f90a6813a57ce0401ca1901c10601393b87a378b99968326bd7684f1f8a7f09641037461c91156ce415ec46a97ad4b585dd4b0bb6c4795de53927c79e0ca2f785447d4690489035da1741daf0bfdc201cf585bcf213dfd090a3ac3e1b561ca579c5e148a3c8c031af021c05ff6eca633013a4e8cf51f846879de0c5758e12057649200e9233fe0b0082c32e094479355d937aa6eb32744d498afe23e82251a23cf977d334a78b5f1cb4c353a4b08cb3308ccbb8feb39999081fcfeb28a5f46f13e19b10c81f8c92fce272fd475748189d1f84a36cc84d644b18fa7f3fd7bfaf8bdfe56217bbd8c5ae3943eda3075a3061c5cc54f479feb651f6fd4bd226f4fe37a4cdf6fe38a44d871a8938d8e1f99c96fa2210880d087be97b20101d18430f3f75600c9a46e4b26844e48d9bdaf61cd76d60e8a927fe10c029009e486f0b08d3b6c5dace748a42e16f5b0edb739b6df916b0879f5a207ecd012116fc8af9916bc2d5d1adbe725fad56950833f4959cf1245656fae48f659b59ec0e55729d2e99939d15faaa45f00b3b83e6939e554c2833ca9472a9346ba5ea993b9fa584e5ba159d1d3b76ece0e131c82f06bfcbb5a5a48445c2bebcab40def0c034cea335e5206f8b47e70bd8c20bec894b811debeb4ea9b0ae196b8a47977074165c7f1b8ead44e32ee4c95f148ec2d191f08523b331ba8baf3c9fc1556a25c562b158ab98d02530c0207a278fc11a8bd5181bb24530df43dc2b4080c2ef7243d85a46d78c9a6ac7f5ea4a0339e33f5facd335db0e5d511fcaa230a02ea067d02b940daaa24be40c738b4271d8dce9e9a427939e4b945cd8b65381da448df18d16ce17d3f8aa36c1286f62f60c8b15292f17eb89931d9e949c093a03c69b985de79bc9869c50b88217d765333bd2d89c6958b4202d0b4c8bf1c8ae6b53d0903447980212aebf26a5fb32b42854a05c9fd2555c2368506c21699e7869ab96e6735de3b9ae29b9fed40945ec481b2b8d6a257d2a83ca681579d343481a9736fc4e1c713d4b2fc1727dd450705f9e3f1fa2679791fd3c1a8b89c0c6f202f6cc0ae87ac26a273c2939e33d5de32a12f4895f66c1b2934509ffe84abc65ee0d83bdfa497743e928a95e754ff3901e86926667812618e562f009039589baf2267cc531ee420c867115f6829df00a8fa031a9318e8ba9982891418679475f854db0a34f1e7fcf022ba36bb66f959f8266cfa56ec50b7b498b211556b6d84b666490e1f341bf82a14bc123950b6d95ebc2b179683e1f737acc614e65fa18de041a8e9cc5570e7398c31cf672a2b19ea8a2ac9c256de83777c48b515e78043bb24f87a3c68489b4610e7d481cb7558d4ea64e288b52262d1ee0009f8fc91d61433ffa6ade2e015e48861df9d53b3cf3b7679f57cd91fa24e02c65748ac935808d4dad5cb7558e7d6e6cb0e1f3d1cf60e83678849f04dba55ac8307eb53845cef85356829ca1f1974a47da009133fea1efbbafe1aef13e0583c1d8a04f5a6451271e48574c542d32fbb89c30100d704f550d527ca3853a4c235f2e2951666c763161976f6695e9c574c2f5b7a3d077b2fbae3f1fdef77cbde62be8e52beaba14e8d21e47558daa6e89f278c979781a7e871c666147a157ddc27aa5c4dd2d5fc7fda4c6449e0ffbb0cf086c292dbaa2c819568b4e562219aba6344aa74ffc332c32cd8a56c67509a3726da0311a1b698c871dd887ad982f15d3b0158caa66f049759965be1f5f35c363aa9894ec302fac1599a73ca3adaf1665420f43c684529ea6640f71abb9ea15afa68cb957afd7063a00368103e0ed517d98c6a7aebc89ce039eccf181d1993741653e7c43af5032a81a3b88d1181176ac31719e214ffe57aecbe810b329a3311aa3311ae338cef27a7158633e6ef8814303aa1a5418d000a64ce88aaae6773978dc11b6bf7b80c7da75bec2af51aa0deb5fd018743fa9938f862b592e8d491b1ac81b5781f32b083fe0178d4925211b96569127ff3358577c281badeb7fe3a331baa24ca84aced02554e52df77196af441d27ac5ee97c10f87c841e02524640488e1ca51b5336653077984781bbc9f5ff42dcf6a4d23a6b5795c7311a9bb18eb1b792334e5a6445e91a1f2c77a4b11834a0eb515cca48633cd2980d3406d3112224021190c01026d2a9dee12cda0426c051e056c023810e9b389ccae7c3615b583956f61013581ad53c74e77a96399b5168e3fa0d6341d2f8944dd99465e954ef4cd994f5aa9d28d19e684e3426da121aa3313a2de09140a7d2a73e8d5ec6f5d74020b64b4326c8197f0f43d290402718748247cc810981d880b0b75f03df8f8fa76400039f8fee31f0ddb0018ffd4a8df5180e8b8df575bdc586e52b55aa8c5f2e98273dcfd7ab6b48307436d3d9dc5635caa0e4b6aad10d6c60871d38e03d619a1a30aa82c1277fd235382f83f5761ff018e4eb32391306182f47f912a220850f460002860e63c18e1bcff5a70cf3ce2fef48205865ac52ae7fcdb8ed5c4f8244d529d2865bd5e77edafbe58f866167bd4348328fd33e4c41609ef442609e04c3313f6d57c381a53b20cf40e9a798977921312f43fa98f015f348603e26e4d776dd95c819ff900d4b5fe6c0901e66474ad79048a153d0838298af098b79524cccf277463ce92812cc8f3a607e748143be9937240260ba2ff423bfbecfebfb422b612a1cc4b3dee1d8e78542a1d00dc58032679e2167a0c034565a9cf5c412d4a27720df18b0731a7422e649608967cb89d1d1d35f82b5e854a695299b58ee94855d8c5336d615533932cb9036f35b546034467ec2f577987b8cbbce578b77d553e627ff6db3b6549a29e01ac92214182599f674cd9436678c1a112b285122ac15661ad7a76cca2efdd219b6ca3629d3989cf1a755349e23ddad29e9896d9bb53446631cce57d7cc0f78fd810f7c3ebaff0008b63bd61583b5ae384bd7b077936a4cfab6d2a8988ff99898d077b2602983ca94981f3b8acc8f0de5c7aea2144a5f72653cc6619ef4386dfa422a2c87ac228135e6ef1cbf58d5ea9ab1c6ba46dac4aa8c8eded47aae2fb9ae299133313b8a77a43123357684e51fc7cf47f70cf62df2dd50c4ab31695345a2b88b578d711581c7af66d2356c480e43b6206da412d71b09cdab73951d6458fa9d5281b45102f341ec63054b96eb3b17e554a6a07ca5a451358a85c25ec51226d743273cb4f892332e73c6ba3a5dfe422a2c83da75f7771813541aa5b1ac8cdaeafa87bae60b8d05b70b79a3a940d2bca4cdca511e863cf97b95cdcfb0ee57aeaf1c267ac1fac52f7ef14b5ba2f5809a1239c32f7eb1e6d335a394dd2a5efe74898c56719d3eb94e9d30b91e8edb168ed6964ae1f8e27c98077bf849bcb1f58cbaaf28a3933ca476e58b573edf78299924470ea1bf0d39f1c8b2a7743e4ee3a07dd3d9abee884d5dfed20a6c897e0ed96db914a56346b340234643166854817aa92ca44003caf4b59ef4e7d26f4f874f87d0735fa2ff8e12620b815be8eb735ad564619c115bc28b007a72cf7a8d6ec198c67f0d46f50b5a72bb7e5ec0285e83595bc88d615a14e1ba37aed4a28858aa0a3da0d73369d3fd836eadd1335e836f7a0bd93ef056b7357dfe7068118ce7dc601c8644f54f0bd6b29dc8db31c5f2fd5ad2a1fcc896b562abd5f37d3bb2f48c3e9d1d20477d2f7afe0ffcbee58788de8abee5452fc4e8bf9739dd8e2c9665bfc586a6feef47a3377528e4fb914988e85d5ef42eef1f1250f67d53421381f502dbf2f6e76b2d282dba11972ca4729065f4489b225ad883f66ec4ebb612d2a6732cb7815aa444b032685821a2d05e88ef5de67743cb14e47b9717f2bd4b28fa51c8834c14dbe2359d2eda5e04f6cc82b3949cf1300d5b05599386b4b902ab5544af5a37c802a87bbaa7c56ab15a2c16abd25ab5aa51510bfd91f7e295a4b063b77ab688b69e9033cc05df74e7a0597d65d69f8f1fb88dbba3063c76ec96dc9e55351cdefc6ef88122081895180cc6400ea4c308931968c643b8fe332698cf476b74bb188fc1d1ed969cf1d98807505c219bceeb7ab7ba55c33d55cd62188bc1e2a1e26ddbea562577b3b85b0d04ee1e69b3d5c7e91fee14ec15109ab48089eb9d7cb990009231c38e3d6b713ff6ec093264d81b6652ecd82d192b36f41df5b6ba79ceef1f04fa869e65ac60719ac17ab7cab354dd52a92d354b5134ecd8d3f3b41edbefd0c28e3debe16184e597a965a5164b5857de915d2ef04fcb823bb0520b1400ddb17be413aa80a15185185c91c62c0cfd58ed8edde380f9a67e4a04cb2e25ac2bfc1ce0e0c777013812a8d25ab5aad11d3cbc17c460144bc127e7b055cd7a0106183e1f4e7c36f5fdbd9bda0146f5ef868f8bf09c3de72401bd4070923b9fc386d2270ffdd8be5ad8add08f1d9f79ce2a8a9e288aa11fcbac198fc18f492ff9e9663e853fa1fd58d3ed5b9aa2ea9e16bbc759b552cd6d9b556301847e66251dd81e703c27ed66f0669861003bccf218740bc851a29fc29ff0264e5d57a4fdd0431f6286c4aa67c794596805c85d9a6f6bd1bb87fc6c8b53c219084083c720b37eece4ae8659dda2fe85507ce11276ec1fc80e82acf1810c2e1612d53d7e6af10dab68705d1ae1fa11d28b9022b73c099574150d96b8feceac59f7a8ba877e17a56f6e5bd54416acc106cf0862b00bd6b317fc4967712cdee34e3c359b990bc04a7413492345b7a07b4a4cd8b17b1a4b8fae449485f60fcf6aba35a78d0d37ddd35724d713fab17ec7eeb99f0fde69d19f49cfd89028265d17bd121689eb3e32024b9b204775cb51cd6275688a95e1c28eacba11b116728a79b6b023a7e61dbbe7867eec773f1aae4c19836312d5e5b05946a4ecb64f11be100a1b2eb1b31f79f2174217b36ecdba35eb59cf7a26fa3c26020b3ac943898f3bc2f695339bc82bde829f90db4adab470b7d9b6711777fb99e26e1c645bdc9e4118d16b71631e39b33dc8861d79b56d630d77abd94a77fbcd13a174cdc8473090a3a436f211d2a6eff63ad28657726607470591286e224fdb6fa328fe7669a8847b98270b368a104a88f9de6f510899efbd10f4bfefb1bdd8b1778fd4d46db0de6e52272d6e4fc1f9dd90e476340c7b2ba8a5aefcb8c7e96a5ff44346159ca9db51cf3f5310d1b7bc10d1b788420f85881ec9e845db57b053d7c74fdb083485defbd07f4f2916ebdf813ca5c50dc84f9beb075310fadf5760bef740d8a62267b66ddbde51dfaac4f2d3c6ab16472e0bc4767ff8812ffdf938ed59c9630b8b74ac4ba2abf527581fecbb759ad77d921c1387eefe48bad1e6749bc71d6119a4b7d3bc0ddcee9cb7e3a8e6b579e336916cb1d6e77a61a0b0f46768da3c3485deb4bdbff726eefd33857ed382ccef7e0385ccef42d3f6dd8f9e0385f87ba12948f7a3376da1902eecbcff5ef4a370fb91fd9d963762cbe9de9a3621ecbf84435c46ef12f6f0537d99d37d3ff0252267ea87be203307c74ff5394e081cc562fb6b0f03dcfadf016e7d2f01b77e07ce204ff5bb8fd19033f537905e6945ced4dfea16f2acc7ad0f7e613bc525994db36cb381b828a52efaaa556693728a5344e80c01c2375ae801a619c2a81e7a60141bc127244b64194b649650a74d168d603c70fe188e3c2ecc8f31301004b8b29329996acd41b59eb5ced704a3ebac569133dd61bd22692a19ddcdfa457d7d95bd9a70f7578b3ea5c50a83e88458adfca38913153ed58c1a0b408d5533d86755cd60546da2731f39d344cef8aa09f729a4374ffdd1573d66a852a4c8eaac56a932bea957244d25430d2e083003d50463be6898af09868a7d26188c622b9a99d90ae62a92b9260a3ca078e01b2ddc767adbe19bfe5965dbb92f03f0d03656f8f020a170fdbb1b7e3118b4c6180c465533eacb06ea041a03e3c5d5a736a9aceb7c53a7a837a0c20b16cdae691e3ab52f477ea1c346702af472f118a42f35764375428dd526eaca058f5f3870119caa818a01f38bf9622bd8278619fa01105080d73140cbc1ab2b087835562adda82bd3fc15f00df73b3ca61ce8f37328ef568382aecc342cece8ab1b8fe3475f1d69aab3b3c353430e0ce9635ee6774a6fc4d672e5e72af015308defdcb1797aa7ee58122467585602f92567f097e12401466e8294338c3c46e9d3a173605ee60b327360428ee1c0696cbea84aa632d5ef4c5e0eda646575683ab0cf310e9236f20acb292642cef8f3b4c3fce46d04c16032495f3eda89e89dee22a88d2b4197675c85c388d9b1c48ef5a519616b65b1c871b26d8992a674a76738b1a88650ad27a7d888909f18c128ae019f425a830a86a4f1e7d3c8fb42cc4f5aa34104fde08cb0e394c9ac2cc112648481b094167de4d55abf90370a7d558a0bdef49955cc2753c9ec993c2e782eb80045cef877313b5b09247a882a9a54859a8a6735a4c08ebe72e2acda64861cca7c144a94ebaf49b9fe74caf59f54ae3f3fe153fc78f3256dba90289ec267be7cec8ab26c8b673eee4dc63aab41be92994f9f41981f6f9002cd8af9005680966fced9f2cd1781324703e54d329bdc80697ef46a0d3b726c7a9f17e220bb90354d24123128354dd3b417cfda29f31fc9b1561704cbdd915bab21f00d18d5293fadf8462c2dc17a5184920fec0e3855468b31366c6ae58a327250e81322fa165260b9cf851f3b3207f14de8fd17206d385104248ab330031802b286539eead405e2a798eb0bb30089b95cb1de36b07b408514bd7bb87fd08276c92460b1ead70e4f6a95e2d20784526d631ad157fac28c574cd3346db52af57da1a93c69979306ea29edd350ba74c36b1c8dc3d3869033fefefd4835c159f886959044a4ba2e08b6cec08e9d1a6bf87e882834f177434c1ceae488582b53bfe84dfcdef726ee5ec8f748a2e0f09174ff0185dcead5f51a1a8003878ef21c85833cf9ab80ac56da6ab5ea55af7ab581dceda4b6da9ac80a3aefade94f10887ae5bb12dfaa26411a825b928d598cae6bee2b5be48ceceeb691524ae914083ca4db946529a73085124be1eeeed259d0f168517a73523a5dca3927d542295896c297668b7336a1352de81514d4461b1bc7416183823627f51707390703776f7ab3062efca6014cf3af1467111dd53b6c481aef56725bbc020705695b6d1804050505f115244a6706a5256c12b7bb881a9d3a8ac2fae63d68b70abe9fa2605f73e3e88b9d080a92335e586e5f6d35c00112ae48238b531a965e99451a4069b45cceec20290976f4eef5cbec2c6ab123971718528c4ce9060e530e1d4e9d3a75da820b0f863b78bc000018c453000410c38c0c343d661800010840001a0a50538029e058a0aee1ff12cbd2a88ae5a17d3eaae631ee75faf4a6f7c3b4ed98eba5522db164395e776e9bd329f55992a5f652e9fea88a9d2df29c1e02b960f657540186cb3ba70004ab8424765cb67405c8c25cb1c11ded43a1c42500645141b1f5ca2cae2821801558d29559ccb2fcc006f998cd9e30843bafcc62b6e2e1413453b18d84f4765c39df0339e5a720fc14b33cc5101205c44fd2467bd92c2e1cbb899c2133909f805c40409bc370470682e18ed2757b8a3b843c39c75c3e72c683662d863c48693ea8da7cbe99a10d4c23830d4b48a147e6d3cd559b3229ccf09946c65260d40fed7b34ad292067e6ff8fc7a1b3bfc5b0a39c89dc125b2fdc125b2d51e41b8e314d174186c859bca6c05e8e6225e4c9bfc9f5af1a9dda8e97956bedda2c999bf358c6329ea99c30162bcdd34c38884e4da353abb5d6aac1180ce697f6fe42b6d0c21f39e392335d7bda5639308084f00d6f2199e594e6275866999fa858af07d6c42f734cdc3304ebfe1c964a1206b20556dc1948eee11bae82892ae48c5bd2466b438a5790a2f3c05d84ecc1c24d8265adbac00e445af487f5c81997c9aa4c26639946a7cffb5081b35ccc1823fdedfa04d1f0c0eda79e3592e3f617a1e198e3f673620c321cfb678edb438e5b84fb51738c392e573b346cff37c71c957eec815b84fe46bb508f8ee98eb6695be5667353db26a5734ef6baca6bfc748e5230bff3b6e91d0d694d84bc9fa0474790e4b24ff6c071bb73765c881d8aba6d200e9cba53dbd8351f5b05c769396e2b21ca7130fd83eb01e616e1e877dd2247e9e4be4e2e1c616e11e66ab8bd12db3f964a258fe3429a86c4a6bd168e20c96d0e9caef1164a19c3fc19a2da6fcf6d1bf5aa51285da8fbdf363727d7bdfde0c3f5bed2ed470edf9b55b0fdf6e78fde9bda08641bb7e547ee47a1f6ddc0859e0da9e8bb341cf9ebe7c3d6c295e511f9beef3322de5ac11ec4aebdee46b1866a35f1f620de16517d7912fdf72ddf712e2010f5ba70b3d62de4e2f238ce85b4d9e32a47f2c7df1ada14d87e17d3a86954f3b4f9385dc11be4cb4b696302222fcc0f09b8f56b38822417e6c7fa9b3743a12d7c6f9cb743a18f646248a4972191b649c281e36ffca8fd86e36571bcf613c717d1b690391ce1d6a27ded06285bb45f02678bf66540af45fb31a06dd13e098469d13e0c7843c660ff05c42167ecbb8039a468df04be3cd93b0a4b72c6fe078ee2b5e13712b945be1789be2e044405e5d4b45a1fc7ab374bfd31999365287466cdb7ca3c9d8990962307ad959b93a3b4bb2bad5b87638e4b7bc871399ee198e3ceafcf6d2d8eea9e8e39c2ea8190b675b4f98bd4ef2ced7e4ab939394a9fd66deba17427b7fde55c58027d4f9b97f26079b845ea87359cda15d80bb9c06e4f9dfbfe0a8a5db3859b87251c7fed37edfdb5d7e86b4184ec7f2ccb6d93deee4e6bad557bd7b4f75a04a2c2890bc356e3d1a8d0f7e9c51e4fe4008a99b1c68a7ed7021a36d40ae3fa8f1d3709a280ca7db9520b1410e176ecd51848d44b1bd2a54eff8926977ee743c8438bf4c31e5827240ac74fb46b76685e42d67440320c24cad61f590797527f7b433c7440d6701252a4cf3cb4fbcd93903552d2e71ea72cc5fab47eedf1a894751e929b03aaecd60f8542a15028140a8542a1901129bb45ea6f1f0ad5e7ed4bb11a7a9ee7799ef71d0e1ad0b045425fc48894dd51f4f53d6feb72e87efb31f4a328d4ea9cd5d6fa3538aabf3e10593726ecb6ddf0fd180a4729bba1914d41ec8f7e88fd91e887b4bc281c43ef3d8e87a311ed3d2058bedbcb9003badf3c50fb7e6cf543a1ef2ae87de759db6243ef51d0dfe285a31129bb5d38562e046ecff9d85aae7492c7e851b8270301511a82bdeaaeba542cb93917171c857211046b11fa11f56496140c73314dbfc0056b6182143016b77beaca0b1825d987909d0617c172cf546a5404172957a5b56a55a3dcd4298bc1cac10c542e18524f868911330315b74bd9e1e8c92ad30c54936a52a47a443c29508af5973255b03258ac8c1a56260d2bb386959fcb75f1662335048f8c10ecd8ad1d50b07c7e72c0aa3c907881b504005708828b284be041446bc62d2fe9a0c2cadbf24f856d9d524604c1375aad35a238a8540dd65639eb140d0800000008a3140000200c088703e2e18040a20782a83b14800b7c8c407462381608932887619451c6186310218400010118819991ea00be231d829503017ee523f858000fe934e6bd14408e7c2f48bddc293628b7668cfbd82a34b80ff58d0de48ee977fe6222a58955f1a59754c38eebc5b7c60c4662a7a14ad62fdf93d6308ca6c658645293f2e1525337a4beddceaa9adb35a60284b6dc3cd149aea25d23877de2a0634845399c9e97f975dc4b0745e765e4350209449ec12970fff12ca61edf472a8dec65c563683a5663114f67f615ea3374324360f9b59f8b8f8e925bc3c78bb47c48c70514cb1321624a297052b30ab69e8bf9920771daf3e3d61741ddc2d6721ec3530dd113343ddcdc17c4418420bbc44d145f2d1019cdca430c21da2ec409670f01d9bc8f5e1862ff62a1efcde85604ccf36a60e41eefb1c51bd54c743670b1d093a14bab127131ae1be6bfe2fbe49c2faeb40d62dc18686b29292347407b046573618310d36dbf6379cc9a889a3e08101d814272c68e62035168fbea7086647677a35f461cc0120f0aaa2516b38a08a94216a1af50e83a53f990341392ac1eeb63824c8f11cb85e3a110dd3b03e72638ff878994f9a18c49c83dbd9980321eb172f4b02603f81b42c38679fd8607d6870fe780c11b9d4f18fc5b767d9abc51d2150cb39f0e3c8242a02517254c14a400a37b0614c03a2fb04499aff770a17c9e0235fc2a6df0f0525d6e2803c56774c8da1946e0a8bfe47899b04b441d37e92841480725543b64421e69531b6530a15ff2762652e0cb33294d41af9495978a48187c25bdc248fb47135de44f3435d4c227b7496bfb3b49f8b91b530f7f94fa60080fa9f42be88c1634fda7345939f0c5e0d08937a205b297654355e34881e49438c8c72b0fed9ab6c76bbb98742a8f925367419bd2a3db73d43cf59b8e80988191b498d19aa73082fbe54b07f2f9e0e32917a77b9631facc2bb9a24b39108ec8df7f477e994587acb973b682fa487aecc635b9b891811f41140f41867221a81c41df8aa24bb1c86e2ba8055bfdcc9293845829ffba1d3fecc63b2256d91b01e1abb6f6483807e418ec476c25f1b2571906044e2e19d8f54dba583a52724682627cb320d59133c676da2aa6b3a56eb81983768bdcb47e34a4f07f9fc972a2cf1906dd924583587851246d84704f0e746604fb1ad19ea2f9db8a4bf2dd6689d9b0ad1320be5b037fe0e4bbc09d7a659b83cdf2c05c770c60ffe2f8509e77cdef3e6564aad574f657199f75f8f4d06bb80f0f7d322f778591aff05e6fa7cae2503f6b22a3a0e979cd644c86443a9e245a7946d7f13731c82a53c04771922436f8a7fb7e591329f7d456afe2dc3d73b92412e8c614fbde13a0a3ad0a82a6b2733b21132876a7effe14027633bb54b183c822787f1eff91a9628b3c1faf5ab44a14c909145a0ed886ea90d8e2d7e89577a32bd6c2b3dcd543749d839a898fc15cd9b29f1c933a0a48f5b354977e01ff0d5d021e76991e152b354721490af95754fba1039494ce715b34f82e2bf47ca3fafbf11f202f481d7dd457547616e1d373975cdc5a018ba09234bc86dc91d1da138f0752cdc0e5bf83d1397266496b774657556d41b2362e86ead366b7783911866bb7c7f441133891c063be15ca86d977bf421fdb963426a2d7bc8179ce6a77eaa924c3ccef1ca2dce60a6d93915a0ed72ef1efddd737d6e1ff3527a644940c341db1af6fa9ab93676ec97a9f2038332ab555336888815155d9dba9a1b8e03f3dc4e68fa81003aea8afb2fdb9608e48f8454736078d0debbc0be16a9e7101c7e6559e1e2f6b9793794426c564a0ac2612d2842ab453974678475b2391e0b8d9aaa26e1cd46f96de73e3a94bc92ae5d0f17d7e18528db4d444f2837f33d93a3f75e2e7796ed4b8031ee25d3c8f84bdc11a8298c821630fec94e76e46821cb1f975c3351414a4f9c48379ae87d2088ebe8b9116f9bc358cf770e9d8b61a4248a16d2909acad65c2b08a6c0dc60d53d09c59e838c4f0f1c716aab44e1dfd114f2294f033cb843edc6006664473d262991c1be3f261817066fab854d64570e23cdb817da47be1f9dac4394f8aa231d200dfacfd960e0f5cdcf96ae9efb0b07f703ca50b2d3b8b3d3cc0cdf194e84c676f3eca501150378d63684fcf4613bb32837a106310c9ef63e227e5c33872ca6ac421cb9e7c7d864352192a90a146e0314e5bd9f84ef527678a609848592d523c7d2c612ed23509920303599cd4a0ed794b0a5064d734c39e33bcebf80baa1be98636d1787e1b678d532253523036f182587722876f240745b41c385634f575ba32efc70fc162a1ef248ae23f403f5aa0a443145a76b9bdeaea3f92279f9c57af7c0d39d169f7a40b7159b1f0fb7108cee3fde500e851f6e57f394bcf7520c3da842c7755b8fa9b7d9b31eb787d7a2f5867d0b87433608c164c8ae5edf1c00de6db67c984ee2c6ff6c1a894f2230f96bc71ff709924c2d2ad0fd001e2c9ccdc735697168cb56063b188b193380ff0411ec4b4d77385895e7253b2371e3e4bb17667bdc9f226647bf9d0a59b1ea296860d9fe57fd70f696998460a8220749f2b08d28599825099efc44266468207b8df5eb5591dd4a00ec167e27ae536ae8e337931542554fac246b6f5120e0fc359051c998840edc109fdd81e56ce4ebbf9eacdfab1947f453bc034b3d2c27dc0928bd417a07cf5c79e225639a2f792a028de6885f75fccf8f71f70cc0b46c5f1d539a30d5e812f34afd09510aaff8fa4dddc0822549cab8e74126dea9a89aaeefb4f0307a083617586a0e2c508ddcd706162e22daf2ab62b13ce3d99d1fcd678e058821f5ac770d208c5078fefed67aabb894323331d3fbeb9b07ecba64aeea4e47918f6afd2256903897277bb1dc319c9cbc8e2ff6b700a2f99a7a9e10e4664525d6a821b690f3b41afca6d4b504aef3129a3e020a499760829b0086651e0fc8262e80ad8d7e8bd501481a2599666bc9a91f7e84f5184216793e54f10c1ac7e7214092632e603a6fa6c75c77fca21451731fcea82a5eacf26a0e2a06731e8f74cbdb7a77ba73a716ccdbd220cee1d266657f9aa96d9d1b9ab6b9a63ca7e56faacd8a19900d2edaec3fd32bab0fdc2280a4613f46d66ee7fe8523be24189fc9a1569d4d3db08e9d673e4eec35e862586773f2126ed00cfa240926df00a4e6471533fce91396e116474c3c0106f85291e72f4dc2f28163a115bac0c8f82dac4d72b96ef6141bc6c84a0271cc8ff009c38bb6affb12ae4df714c8d16bd880ff41bdb235e4f4f3679ed375198ca3c417d03bca9d68a9dcc8721a004479092519428c9942a80cf2d1fea4bf1359a0abcce9bc687105667e614333327cdc79f46d82a75f2b106c65700bc7c2fe13e1b3db829f677692fe3bb93ec59d188c96b38ab8cb27be0098ae03ba17e35966e73ff587cb7872717d8423254ed537054f98497aec21238c0916e15568d0a4bb2d348f4bebff37cd0254a121ba9dc099f059d1e26e829567f7ba94892b2e6bec56ed354a7c435f4dda696e12322fe789508ff8d59abae962ddfdc1f6d07a0a792b6c2498e492f0fc2a9c0e071981da593743964466e5aa8519997f355ff202c5b53f53c0df38af0b94cbf1f5f1c0a490c4e1e82d56c69188a612045c218c8ffbaa50dec70d26672b44ffe742e19a7f6fdd2663c58256965e953d367e1b1feec4362c335c1f6f5be3f2e2678df5accab67144e5f1d8c7316aa5637ef939915997b923018a2dafbf67e4c00f1ee5b0052d57454b90c204eea5b349de4f8658b1529760d362f51cbbac81f275aa24258a1f6119395a41b059d16923bb865a86be5d9b31bab77e9b0319eed1e88ee80cad6f9eccec4e0450aab8881e3b932d2cec9bab0c695fb0ddba3a238df61978543e1bd7e8555dbc85163f63d42f58e2762dcf7d05fc1e48984130eb09c6df7aa6f8547901942b079802dd79efc0763aa40d4a1290a9061effaa39b6b0db3d38ba62b4ed2e24677e4b5995d588bdaa417a52dba137a069e954c0bf9d893e5887a87478da10a3e5b2d238343c8975932ef3149c139ce0e52d704ed288279dd4108868e0c5fd4d408541643466f25bc4307535ed3bd21224e36b2f0a9c44563e81765c487668acf99733ca5eeafbd6ec2f03f4a4ab0da67e70c0404928832843367f7dd8dfa3e798cc300f067e646e4cb039be3f0b9ee84e2253a2689b4b233434dc537e5285d1385b58062363ae6ec809231eff1f258cf4839f6488b753c6b796ba50da9ee60ea084c936764dca09493d382871997036073667513e39f7cf84daa19e440b18cec99959a85441435bfd08fdf62e51b895b0c17d91247681ca79ede288f1590a41a93f991ad39882360c5ae27cdba6aaf167260429c5793cd5ccd9b1adef5016e64d981bbc6e58f84290e594de303dd5c45f7fe94c4ec6308e1ebc34decc3c5bc0fb7047d05e465b311ead1066bef6f532394d299dbb8d7171522e1b5cb450bfc9b4f0b8cf4afe402cf115c2c3d56f9f7dcb4428341ef1760e68a058af0e807bf42a18adef36a6c8dd3f63957416e08f4fba4f40351eaf5a009c1f3d50d7f9ed3e95fbae627b30ee21495855a4e512850cd9360bdd803bdf8449ddb9ec73db4f2c283f2ca602cb662438f6a1e227c3c135bcda7d698db6360d4bce879e81e189dcbdbd124c04d95ca03d5dc274f0f5011c68a5791f7a6c817d95d2bef506274f3b788c44a69464f2cb0000f3d7139b9ade9ef87659cf299f977d66c2ff1009b7178054ca3fa7db27ab62178c73cb38639ad5ac4b4f9c90c09897a5626750823fa3cc05a2537fd78f294db47a1f3a4a3f0df45231440ddcda4061a57807b421ec3c018ed87cd8fe48770cffb8825350f0ad8861e7a64cfcad27a32ea9370d26e0182db8f2db2c6582717a315adb60f48c00d2a966becb3e52383ca89c8012698d30286eae20cc8eea74f4011bb78e021da309366e49d047d1418eb580ae9b41bf260f1017d2f3f22b04061a0890d9da9683f7cf16a23336ad5010d61563857c890b1e267f11647ab93899b5f62151757564adcbc5202809efb6230cd1d19947b9fe6c38af442929805a357f3c9a3603cfbb996721101a13c5b2617512b416e7dec41999db32e8088502681933ed74ca29c75fe1f1352b4b94ff99731e1e4e79938ecda428228f29f160430a8aafdd90692c71b0bb976d944d1653f3c5dc8e567154bd8b756253e0e7580c0e6fed26b12003a7a8a13ac5ad76f45f67413fa26671ed93c0385c6df61b39bd6faaa109a0829e07143604f4801e5720458188e52959a5d7d6baca94f853d4c7065bb0bc0a789b60892ef01a8d6a6651be0a5803cbb28b5f3c3891b107ee99424b8d6069313d2ebbbc35e62c5805f0c60992c5e090ba1c32fd17e4d684ba47b851809d60113180c84adafaa24b7ec3bf08299051f3980117945db3ce2fd775d91574b1e4b3cb607a488eadcb387fc028e347cedd67e5163b6a34ab912383e3726ee01b85dd017e3ff17a06040f0357e474958ff9aa76a7c45c289b5ff245589b4f06287be8aaec2ca4b1c9c8f18a68c1954cb195a915f8b4cd8edde3fec5a9ec30fbb5496450144f8e2479b68e1e1ddc156405f45e28d0581eb1779d25c272096a1e856c190bc399c0e0c0d4d1bab1388b8fcc69e1997b1397ee0080afac909e7c045b2b181e6c6591e4ad92ca8fb6ca2e1602ba3d5881090048e7cf52791a5acf6ef22e49d18cca55ed2041ce1844555aeedc6334ab92b724d2f8962b5c264750a3c11f111af0fa4befeca44aa2c441726bdd51de875962ee9d673d212577e0494b893dc9f1f2076ea2b3af4555c2499f13d27d358884d030984c59edb302313af9b802246fc50a9664702315ed2c0bed99864461bae88b3e40d254a131a20a7e6ec4cb8081b6282a7be3a6e64c3ad1a0134be3d5dbed2c6932403b629b448fb656fc6562b68bd51bb069e162e09cd03dab434501b48d40481cdfcb9daabd62da73ce2a8a3bf20fc615f166713a7fc8be1ff082195134ae95c96247a4ba918f19fac2c26c4d5523ac3691aa5a5c132a133ad894579c03b3da7628cb296ffbc0f1c02b26d2fc7944e67915601c2d5184b79ab07f6119d595eea475d0968bb2046fa9fd0275a0c9cea1a1ca459abd0e309f723f2d4fcda9fcbf35c0287cd846c27b58bfb2df41090a7cdda70a508c473e33e733ede6fe8faaf627228bffe8085ed2f40a6936244ab85aef85c5bca5d02e0240350d4b564f65d6f27d3b9097fdd8260179d0eb1fbf33905a9dd9b693abe278436450cd299399907fe14032b97261eeffdbb20785798ad16774c7499abc7565588beeab1d9b62c6090d89c31a437633e82b1c861d126619c0d2537069f7f30edc2a2b3f89c9c0ef202035d7fda3d44ed9e65cb9b50b349766205ea63e24fc764c26ee49702dc836b427413b6eab33a95f77e0eba02375da3544ec7ec50997d46808267f42baa67ab44ed7d28aed67c781f8849c86f18abe4ef4c52612525d225ad2aa9335e7a7b6da33585bf1d6f4b592e853ea40d67ac1eb14af71ddc3b482026049b7146318c5b95051158bdcbe53a46329280273f235588625a9e726ff33c793ee859d082bd3151694f0f89028945fed400869570905306138e668650bff26a7f1b02a89654f0db86780258bce146720f3a14a80fc0cc503cfd3265ed272291cba4651cbdc0e4c3d54233b67a994ec94071e17b10fc9ad959c6863de13a3509103ece71197154f810b28aac71b810b982c5f69555cb0561bb3ea3b50ab5ddde324b7c4c19d2fb1972fa2a3b74e4a10354df1de5d49e35a79a8291ebf9b2fee7f6c67fa79058ee19ce729c060131d2af4fd861b510db865088016e153b3050a407f3d8754ac56616cd460a130f98c50babc8e9d575658cbed9d1d221d8b00651cc208058afa0b8310e85cc80a7ddb6eefaffc2e24f7a9bb7d886f1ab89ea8cd108b770f5b4ae139cacdff4a5753a2cb2a986ecd8d1a5672ae03184621fe4e08e210fdd2d3253ed57408c8d9f8a1727bf22ff4810deba87d44c8ebb40a3d7b1bb00640567909b401aeef254306c34412933e4a83fa0f614c494617c85cbd19061f9e8f1cc778453a8f749ef7c45c2ed2a362a8a9333c781fde05dcffc47a7280b957c8e75dec96b78878f9f2eafd40486538f0dc8a9e39944c785d1369c52172e5804b865177c45ed0e44dccb5bf2f1a5a6ab004e73e5fea79926bd0cea3a79e3a93618e933c9c954fa3a37395753930b1fafda91895b12c721f475c1efdab64105c874c130a5755b2daa8d82f4e39a095d9fa488902783718ef9ad1bb24e65ad1c63d9567cce61e87f6b5065a3e2929eb8d70e20aafa251934ecdde984a68e2f1955c91ea19b4e72a7d97c4eb0f85d5cf6bedbd8b12760395cc5b1f55fd90b9dc34f130ea2afad88ab917a9e66a61aaeffbb2946c79c6b23b161440637c1e1b19d7a79d489f52d347dad34711c3dcbc2a220054907b8b7999ef97cd1fc1b298a2a2864974c11208252cfa11882f9bb40d678d9d05956cf293512ee9c19b81fd6469576f48e8d1ef735fa2adda5059227711937d7cd7fd1b4f82fbc2b83b198759043ed751758359cd6da4fe4951974b66fa6156f5200164607de9b8bfb0fcbb561625f65e683200c49793afb5cd2f7ae0a9d5b3e1aea03873e66b1d68336534a935e6574c593d589b44017bd5c1442d51c1377a1cf7a020e84c220038eb037822945d2066bf8bf94383348cafd4ec43f15f965eba005dfa38c5f94d79dd0173418361c2652c4ca4014c6d0cda75a790a6c3b6c77e75d0c172c28e944d97def7b9bf023278373652ac0cd40851f94470874ec892d80e4205840504dd402b76863e2303983f840333d48bfc470146927868b43caa0f9fbe56af036f96627567684cf90fb8bc94437a27313e898aaf71de55d93720a664894be15e04e6b0692eaf21fa7ed279f8ecee91c9fd8f467f3010c54e58b8c3ee3cf83588622120379851b4cd506724796c55f7c137466dd480ac5c23d954a913415362dc572455ae454a2fa6092439b9c6a5632d84ad71aa96dc8574cd10d4143870757fda0eaa43bb958222f8d4f7e664e680ee7214a31420da84cb1fb486fae544dce469705c01619d9c14777395b892979c8276f4e656f3ff1923bf5f7da8e5dc75a76dd63ed1027b3b2512661992528744afbcb8384dc81d9c1addc6d13ca3b4ac70f33e04fb5c09c61d7fd5514c3109453fba7f7376747d22356e95a6c70e4c2d30e43d4f8e52825e83f163451592793fb1c708164ec42cd069b40ef372faab79aeb5d08e02aba14c8f89772c5c113ad6d4c635d718db58157d815a4a540b357f6686b29886a4aea35b1704d1423e1ea514af9eff46b03f7e40c146befa2e4a082743a62e493c56a59388c72c3b78637e7bbff6969afd01bf16b2fd8b8e0759dd5281b2d690b5445a2600ba3bb5515997af3c8d70a40faa3c1b6087b63274a8b953c88c22225637f931d6317e1d340abfe51dce3c8dd119ce2ef6c68a957288fa3e424ecdeaf16857b9189727cf047ea352b7e922e6735381b1a3e739024cfd994f4354e97e3df4227f08e61f1badbf04485f10658a42871c8f3df3f360f35c3990876a23d97f40af8fcad37b82ed38419ad85d44b05b3792b69bbf0a538118210d56c9d4333fa67820e086f4e56ad466e606c84f4cc9462702153efcefb9738e769f499ead904a0a266ec8e39eae699386d3d1a7e69c01345e61371e855938d850fdc6fedb294ae41bac012c82413f3f2f3488bda9195b8929b8c64d9e603e042d3824816f551d775c02bd3e042014622d81ea1455d3d8680b9020ef09b143345d436b4465d050acaa6bdd20dce09b342c0965c976d7e9c25811478f4935897280789c09e052abb292513246b7292ef97b1517837dbf7584d7826355e0c4c82ef4bd88cbedad2485170a98539c7c72774d0b2540bc64188c89bd4c05e44be5e66bfae8ca6d1844ac0aa6cfafcdb2c7ea527bb247fb12b663922516994b220407241a8c15df45c6b444b39f42ed0caa334e947ecea01e0e01b4999fc8495211cd2f03f5342e3dfdb1f314381cdca1b12f74ff7cb04bc79ed7b1a33347745c388eb07c760114d84ca408d1c2c6eeeb920ddd7f4b89be9c9c319e6a46769846ad9ba88646391849671d1224732c42b43c5fb2675a15156caf76d5d332685408b87f92245e70db3c999e57f8ee08e4cb6b836568e291631cb5a634c018363113cd8b3cfb6bdb6e542bc74b74e574cbcda6fea681b1b81da88f32a6412873c804b49388c3e136da31179c529214288ebf626180cbb29ada0c0e92697a3809ee35d5750a928a5a01ea0ac8e4f3cb615b002bca4909acedda0f333409b6a8ed4e3245f99bef2a4fc43a73bef2fb7e0e3d0e7347db10beec567b7f6d1a0d95bd9ca1bec8a6c67c091fb30685e80d6f9df290de3f41b8bbb3a4fec9566cea4745b2db16939930ce3bd515f85d5b054d88475c0bda4162217b89aeb02acd805495fae0b5827ca969cdcf76bd89480d51970bf68df2eea4a53d0febb1f76761c0d640586cc66e62c8f85144b571096a6c834dd44bbf2ecbc343ceee97e0570b77cbd8194313241a8d6f814684919f26ca4f9db682b84a6d591f1627ef86871d79e8a3d83d84f62c0c77325bb241a1b45e6580df458b80d45efcf3ea95b322aa279a250de6927100e51c66d354e259170e4afd76033d9977cdc7e34b2846d1e69aa3ba28c12c3b476e67b7b868fa73353a5cb2b228ed5ef9e33f85869e1186e487e5fe96b16a9b5a272eeee82fbc525cd913baa6052c51345e9e75a87570bb2189594c749b3f56d395d3c95392e2f4efd9452f95615b5ba1cb1786d18f655fb0ce96ea9525d003f817b37329f8c345bf4eddef37d1cf1bd719028622cfc2b325821db19f7ba70ca00ae07fb9e6ff0df889c884134f86796a680473bc76ad9a9b8b79ee7ce6b782d652615554de6fed04bc06d4c5f3bce8afa8171c83943ccd4938b296410aa9cd437b9fe052d0d9d2c078716da054ad7b430e9c20ed62cc48f3b0b12857949afb94e68e2d7779447ce82038a4fa8b21276704162160b5ae71a9a9836070e28496a2df502a8c404f5a13b6880185794ac46de8f1e1450c069cef43213e6d7d067b47545ed0a2bfaff20f11d798c13cb7c0ea1a29814602aca5d6a7d1116f97fb6bb8928afe32fc443b7e03448dcf4874939d2fb9dc54ec2be43f11509cc9bfc49e80cf4552cee392d321a1e4529a54b904ac7a88097663d64d949d90f9df9482f866cd027d9394816b029639427f392b781a70971c310ae20e3591e59c76dec0c768c1d3184d78891321861333118b865d15b14f08487316573211b30fe70bd8cf11715acd5278cf10a3bea32221d5269fefbda5878ebf5e45ddf2f580b1e0a1f19e3bceae34a3ca7159d3fbb125fee3b28405df5d8e0ae8d9c9cb25ea15711ee33faed09b2d18771b047053ee9db5f54c8451d475a20e5a17b14d88d1c8301264099a13358d0639bf96f600c542a812424348cb027f0497f9fe7b13e5732f99a389429bc1f11394787aa361f293dab8b93b52a80a819256b34183c7a99e35c1017c6de0eeb1da011d07809e703394b3ec37148ca8fea80e8692c19ee376cb7c6ed665c16753b526e43c32ef1f1bd40ace941cb2aaa1e66452427fea2ba8a75fab091612876a1e38d134474b6dc3ad6b9fd9b3f94809387112a9dd0ef897e794285fb66e4ac3eb393087579e873d8b645ca62407f0ab9d8095e7d9cbf75008d63c3906ddd2f69b194ad87279b308c445cc5a508f8a2c0227180d483053a945664be07935c3d10bb00bf16f8b34444fb3566a0bf04d0df57bae4bdaedb39497190f3556c51d19fd7353f41971cd0b7ecf145af628b364c841c6d99ded3d8eeaf3d12bedc1288585c112809dad72c3a1141ef622ca7cdcec4ad074305f961212c497d5e3da196ea4fa4b87e00ba79012d0914e225461a172ebf1c89cb49baccb27c31383893d463c2ebecbc5d4e4a2c3b54d0e38ac21b90c5e8a7dfd820d074d70f2dbc5bb1c3cf01c3d8153fcfe8e7768d801dc8904f5f2a77d0b8c91dea52209aec560413126372ae7adc81f0b6ae0d884be4298a59524ff80cadf0ed8b13804f9ee9a5376cc241d093b5d04bb43d01633c1c95082b975a7bd22f27878793d7bb7ab12a665cfc727bb4b30bceff3740683a3d17ab1a07db3e5aafece1ade5cbd1c6506e4cadcbf36a82c44c8714899b699bf1a88637b66f2c9a529b2c3875bf03b4d20e451bb4411dabaca8a03dc5cf031028da62da85bc971de37975f9f4d787cf24de9f236f7fa543f59c33b8da97a6c43227be219de69717263d78605fd8a262ef3bd56c1264c03834d1dff8cfd00fa49b9a18e46bb76633bb89227e609978cd67678572dcfab9405093fc8f92fa9fe8ea643ea110080bd1bb65c107c6d1516b5d8ec820abfb7948d8a91bccedd2219c6f6cb123ae369adf1cdaf44512d425acb64e3229acd232da5259af0681efec2a944ffefeb1cf80774e41f96e488f2f4e3d9e5252364cbefc358e8a3603e4eab29bb9362d37c3a0d0da615934e2d83c51fcd725a16454ca4389ea59efefb34277ab9ec678acd1c8bb2bd39db618a5816098fa94d3fd1207fd74b547ba1db55ae113048074599f588083968a4b4b85c0c84248c2454c3560c5910b455b2a3c58afd21f71767247e475082ab953b7e45f5524e9582465da05eebfbd6997e4f992b2f4f5a4db881c06c0a4d7d67bc1f89ea57781af84669ae280a0b005cb07592305274b13c07cd274cf89909791e90d7ba5677cbc703b3ac5b6a2bbc0458d9430b0f4e52040706b70b28e0a3d51edd8c334f4659e53ce3ea64c5818b52cf7a23b852634ae66282fed75974027c7a2fde03d72f33a0405017752da647fcc6586db16759d20ccd138705eb10887dc2b1bb9f8dde688f2e05b4cb06bf1f171dbcbd80c00711a3b064f5078878e0587d35072b00350cc416c71bffc577ba38cfe9e967af0126ee13f70d83e033a285c5d09334bca6c27ba71d4e8e328cd8a3824c3210daa9f7d9a57878468ee0bca12ef01190798b1a3ffc4228f214d449333111590d5e9085957caec71d2b76522de183abce98e283929bb0c3c32741a628e284cf4c42337dd292702d28e9a063b65193aa756b9b1eda37e107a249721fa66e0f566e236b042477cc24498bb8e115ecfca982a118f28991640a8502217a6d9af9a44964c5451f78eacb86ed401f0986db768170609ef253a239de19d036e78063c364888868eb4f10c2f1111fc102250502d7c51fe605aa6002b85e909bc48b02bcf7759d2e4d8c4208ae03b9c850bfd5234c496ca985aaeb6efd7a03c2916e8861f80379887ace64a8e5f198dbcc28c6d44d9c4ce7e529bc0ca89ee8dd376702f2b4a8b5c505884c3894d7888b7a620bd351be945398c0a85df348a5c5e1e617938bd8799b804ffcfcfb56b9466af445b4c140b745c255f69a6c79349a4c32a1cfd44aca486ff290fa160413f9fd7e16088e5304ff2428d209c36ddd3b0f651d636f423e24e3320371b8b03a12f390054ccade002aae2422e84fda2f007b3e7f929ceb911de67daabeded28e3995939401ab1ccfed6cb211e1fb8e9c187518c63524fef89127360f20a76c851bd7c98df9980922f9671015a120dd825ce4a4e670314d0d5923d733f64cbb2ae0954e47e2e5c9cdcb05f3f7a0d2b91111e5c1d641c654b3f12f543fbef36f58b32b80270d27e48eeb3d44c9987368972cd5938890eee583a4528daa243cb9d2ade01318176a1ec83400551d746c05257377d79dafe0e0d5e1dd9e0445983c947223a40ab65dcef9f373b469a651da47e74725e73d077ec8e6965439cee220736b156d504384abb47256734552ea69b7e3c8c6aefdfd39f684beedfd5addfe6a32c8563234d1c9b611a3e59682de7efc3f9cc9523a56e9d1beae5aacf5140103989c2fc295ad7a234caef29f09fb5e6c8108683702b27debefec2078b7bd8f30d63b3dbbe5a09ecc83aeafad2f8a7bca3eb97811049ac0b7062fe9bcfa42ee160a889461a9d8480ec0e816c7beda7fd032f960be7adeab3b9c8caec1322938b0c99fb87ac18e95726d3589a2bd914ee15614c8e2878ced75a91ccc2b267971f6206033d6c40842659c1870f6f464d0c4966ca4eafb8389cc5c979f83f208c3a8d5ea6a5ecf2902a3fdbdbe7d55b5e16bcd1e2d120c58a4eed2ff44c5a23af32a21eafe5274ae675bd202b1781b7b977bc458f31341cfd3a5fcdcfe4d16fcb1bbc71d36bb536bc0b41860ddba15cd57ac95a4ee5a80c2ac4628206b616561048263bf22c5ff297ba0589ea6596df46e90b8098d1606bbc0d8cb5c1374f38568380e479d9d93ec01835b218b3ed3b6017d4f146672bb16272407914d98677cbb03d85075738d915435a98ee133ada2bb344c77f03229762d1a06247fe9559683c493fbb80a63901fd4f30c9ced26ef9665f39a0cb7827a2303ac124d2cab1ad8efc8815588641a00990e4063113cc3ce6e48e056335808fff5bb61c61091b26e2409cc591941127f89df7548fd6e0a8fdbe87e72265b03bff47b848ce41d279cb386505bcb86e1512a82682e08f039accaaa3f1d821f8b8ea833e666c2bedb0bb1f41ce8b1f41b25704321c5dc7982e73cbee39979d9c8b07a7c1ad72f2455de5e6079621ff4397c95624d4c4e44f563a56fb85ce99d6693187bfcdbc7ef206e312f597f6ff9b4fd2ff8f234c3c873d66afc7ed2093f3fa336ca02f5d93830634cf50cec09e5dd3433f6de986aeab6a67dc425b6d72fd445846b305e31347b76ec7c9e7d26b0228e50bc1cadbb018cc32c211f40973cdf5a195e6c31f891c26d75cca0749b4b01b4d02309819702979098e58cca06f06ab16a7ed5b09ad5a57cb942e6bcc010428c38bce727881b00cfeeee52de91335e62b9b31c3c7e1ecf528d05502ba54c4e92d902da8bf41db79a83351565998c25dbedd2dd05c068fb2d08325c480095ba9da00320370fe0cdbbd9672169adeb1c5c013deb0c6f7824e796a75f927ba961c7da8c82de7a2a60552eb63cc2e7273ae33caa3e8c15def0aa967dab2c1235d47204ef60e8ac14ec39c36dc66272a09d368693d64e1a7d8548b501b9d64436f578cc0a91d7fa1ebcc0711a8a396a00f098dfc105b8fc4450ffc77fc1bcbfba6881b0130f04f78fa6199ca3e2ade1e464b2d54c3d9d36f3eb5f6c814e08db0ccc8a76b8fe0aeb85e22cc28c6b76c48ebc9e4c936c8cbfde80d50067932a70488eda1cc5418fdf0c1161aaa3389b47e3568e02efc6a8476a7a1c95edaf4cebc1693e46c57d739fe01def2e988f36c9a2d86089a8205a8f66a017ecd373c5fcf5c9a7677e5bb2564ef4187fd61ef230d5bedb92d1f3376296d6a1f738f8037c5425e256e2d54a054a277593a3698de56f2b439364c9a8ff736e74e993a741df893fd7fe589cb2097de9d4892cd0fcc27df14b77d7d6e2a4e32781d442a1e5c3ff5a487038e8bfe5c3aa06a8b44c53c4e3fea58e58c9d6d59e43f9c455e633b397bf3547d611b6e0fe3263b90fd73e503155d8135139d6ea9bceb09dfcbee6b68d518ef4833102308f05bdd9bf5e872d11da13a5cea7090c6215cac0eab1a07306d73731c952939fe242c1b2898b4ddc289d37ffe24a95ae4157389dc9d49c8b8f6244b2b55150a2b45e149a04005988b148c8820015d5117284e9fb3b9a927bfdbf90611f5345564eac866f1a22c833b2af3582bdbd6aaab9d683f4e45240ff7aa142329b53ecbe889501b987441c07c799f30585fe236fa0e10660b4c4bb9bc5daef4d047f0d4b9e69de3d5198d97343f303090520fd3832df14cf52cb583e3a6ae78a3e313981ecd011150c5f52546ab710b1d5064abd2d6e1a250b1e325e8dfd948e9b4635af7f821fb0f95e8ae8cdfdedee00b85f71430b41905ce800b2fd544a4f19afa98c9ba5019845343640308146e5ba8ddbe8db12775e516ccfaeef95d2ca8eb6b4b7c1fac90cb34a6f0fe87649fc06acc9d45139c4b2d0f4447a9589fca8468efd3465d36e01ae6c6a556df1417ce4da61366f3b4359e082c43f7832b46c64f52da8cd249d3c30163eb948199532daba5c35013f8ff5c0f246adba9cf79a03f0ef80038feb71211ee59bab93d725d11efff58b77a708bca225c6b40eb87bd468051d9028d183025c67c6b9b8e7c1907b8ed204326cc6ec953a385a8b13b532a145d74d78808b17360117c68bef7be55f3d8f9f1910d46be16b86c3f8d810235cee45e0945e111541407b8f3898c8ba21d73806765582bb4928b726323381f05acceeb205f0f65fe50fc70b016cdee488d459c4f6215b24f8e0f5e5dd2c0bab0a1b2adadddafbf6e10a9ff2ecb0478da5d73ee4691874bbf53af8dad139cfb2a97cc9f3b5be8edaf5602ae0f6b76fb911353420ad352d76693d5b827e4604f7d6ccc57556f35a9dd8a62b4676f062a3f9e7f764ca50b4bf98e15c5fed57208ec61e6aa52410365a32a65e31a3e93dede1b81ac0b921612618fcaf5137f0316924cb2ba91afbc3f088b3412f0ee0ea5c0f05c771a6c00f637c2ff4dae3abb303c073a4860960403e720c204e7f1fad39709caa27d337b3d8f572b435cdfee518661a1fab8e64c7aac1586b56135d92d04ee9f4d63bd516c0b8373841cfbc5d25c7e808eab1e4561e0a7a93ef7c731dabbdf6405a5f8b1bdd92a736942ca38c1eb349ee051910a27e10fa7b91ca5c36b8823aabef1560e81e719523f575bd954e8e7339e6bf5a9e8898e34a5044c255519bda83282a5114250c62d9ee4ddffa2f527888c3ac010c8901da01f4464842662a07192298eb8ceac5f06aacd9ec8c095d83b6fc4750ef763061710191f7f4c928bf0213922e17cfd6536e7b33fff955b81169749f1a24fb6bf3cfdf9b97156092585e526e78c3784ac03e78a6972122ec1f555c61ad2cff36ba604390421589e045a8d8b84c40507adf6880059aa38f437afa672929e0c3aab215180009ec6aac1beee8a69193f681eba3c8191780fbf1e20b8c2f1f62a7a115b98eb1e41499b8844d362555183c6e3eb8d203c692595ddf8712006d00f7be4fdc6b42c90b9d761a1a391f2804a517fbd31befa9c2c66238b965d8aaa705457bf331492926aa7fa412072f2a55d43b667c3572a716943480992cfbab67cba785ec4599643d24691e11e90ef8a5fe71226254ed1578e01342370d100a0b908d55a319bd39f03b5e4f8ef37e08f08132b861af9d7cfa2472173224eb4b1c38bccc3248538457c8053a530a8ae51adb598f00526cbfccc4c04a98af0306c82a11749d0aabbd1b6b792271985770eca1f4997a4ab0c6d8d5338515f50a40d8c8459d845a8b275a4ef9042e753d4f5db404563f4b071639572520742d9187634997d189dbfa0de42ef91b8763fbbb5b317d6ae28543b9d112125506f9e16be829ca297f0c1b3df5090a63763051609219350dfcf5fa94678abcd5be8ca8339671a17cd1c03ff374ae99f51bd1603a2fd9322b3e8e4cec10fa41f4cc756bc46f3a1ec5d0f301ed8ec67339f317579e66fb081581c28588ae07f415013c91c18fba3b17708d838dd92f789e061d1356d24ac02c0dd0d8d3ba44f89d5c8068e967ceb94889e3e9e87064450dbffd478324cf4270e13f38285755964f537853fc403042b298e68b8368f58259cd3b0ce9bb468b55bbcde7aa59f90b3b4629364c128dd11106a82541c474d47441defa9a7f9938c439b8a2997211d64c9642a607c27432e8c6ad1ddf089a30ec1f4509bc0c26b922cb9fd16c68cfa4cb6db18fe540352eaead0413a5469fbe9a65cda02c7ee85ee788a1fce28727b3a4e2eb0d320e1b568b040b8c4bb85aec536a096d12d0c2ad7adb391190e3a986aad53d1cc8640f6f42e1375e6a17673b6af547e90ec9d18f0c7e447f8109d111f3446b3c72ffbd4e54d4e95daf9d7b1e57a0a8dd50c5395789b2d50e58a0598d51e682997d6239a6235c1e3c1d0415cd0226df024a5d5a4c27010ab4488784b62d83eb2d66ff073183d34b028a101ff8c223eac5731199bdbb907c02cb845d3abd65008a26b44b5ac8195b12931140e5271483179949ecdbc3599abef333c0305bd4f7005d9bf6366428191c05f3399ce9027f82b5f5812e71a14ed8a77c4d0cd7a8b9084e4b95c997e3b4041a64a454ff9410ceba45f069ec5ac8f434dc2172e147c05c3c255a094cd68609be864c7187b95aa7c5ea772e295581975fdc8624c10bbb847b41986a1a18f6385930a229bda2ed9acf82e043662dbfb357c6bdc288f4f2f1dd9f77ca03ff6f0466b223fdd86e13ab702b56faa9a1d2124363f76b2e59dd73d62910cf27ca79b55bcd0c179e0a1eaaee09b3109ccfa525ba8aeb28c5c329b5aa16eb2b00aed95bf1f3d53ea74f7af1c0e152137d7690c7e59a8a7442e6505a20e556a8c6d0361215711ab69d2ecf02ca479a40cf4479b4d47c8e082d13e4a78a1fb250f3a00e2a7b03470a6e790f266847048d73c388ebbe0576a69a21867b50a56d3240b84eeb1050ce30f51df03facf240fc2737b75f20f8c1f0bfc00d985ab818a44c9c3b43c214af8684d774b88823520d9986bdc0030b48be3261e90744ad06447b62123fca6aea5c073ab635d7de7d15104668d5471c72af988a05676de3d14e2ff8b2dc947626ce4987912034bb469ec6d324f24d2e0ee99d784db08fe7cecf5b1a85aa0558531a752b115c0f2902828ced5ae075662a5715beb97eccaeccc5e2204c011cfcd0ff0a73b3f79512a78d65da5f2c448e41ef030c2b793a33b53233d8ca4caaed376b14f1439904c84c6a534eae9459c69948654fbe1094bcd09848c0bacbcc65289c9ad8b5acb7253c9e63d59047c13374ef98a28495f3dda9c917b0174726125df9f9242e258eb46ea183b467b38bd29773a06ae66edc46e5d3ebb7c30b5c5ba2d6980648505cb5769e37af64ecffc9c9fba4c3e1236ca722b7740ceb09f8f65017f45029694eb6ee9366a50715d36e507b1462eee151948956beb9ab25824611e58059e24bb288efb57bc0ae052fc7184c732962b75c3f599088e0b2145dee4b46cd260e50296eb3c4334b7da4757d30da6ee8a3dc04250ca2ec6158c4b39c02e002a30545b021a93569152362e60a4fce5e2b0adc835fb1fbc91e79c5d32e3bc4491944abefef218349fefe0615bb64ec6086ed398ab56074b98787878650a5d84ad8688c1a4815f5be54c546513d381a6e744de59086391621abc8062f4523f4a3ffe4e9355cbc8ba6455ca6044d64691c215b44bef2ef281d8a2074969fc411ce749b3f8de30346694764432f467d152053262610252f89f67f47204e3152dffa2b00d39b122377c1906cc63ad40f38e4bc1dc49a3606060517cb5453d0434545ea8e02870b859d2797991933fa02d40022fb9f4ec487b812a6b2c551656b6162d6ab1759e212cf2d42872a43e0e3ec372d24f37d0f7a0e6daf41a95c80bbff0e0bebe6488af7971bdee534414e3251f37d3ac799860e7f5fd4b5a093b152940a8b4bfd6a2994eeefb0eba935904531738fa657f40969208c7f7f2994a5ea02f7a8ec9d0dbc9c4cc21d7bdef28a753fb66440fd19f869495b0254b3fb5a76310280719d06aa424d6c656db36ca44013692b63648166333396415c843628f94abe19067717ddea9b9b8f4ec0f5173844da8ddb29f5b633229295c741d50b64d846a6919f798061e383158e3dcb2dc83e171a1a0db89c16000c92fb1e903789fbd75ee15ffdf1e465c35fff4364afbfaf0d82d4a5c1b64c31369c2a72b2f484b7b5c773234f066760f09a3b486519ec1804b14f5ff005528f40c6c140be2b27d7a87ad1cefee41d59701c540c5fe38cb3f408a28ae60fb1f489c352821e5f3eec3b983c7e84f070902cf36a5f0329dea20ce823e7d52cdd341faf293e4d3fca3b6b4f59a01d18d4fb3f0c8ecfbf3645782d48937c02f98d68dc1790220554f573186f890bc1748a4597574a351d09bbe7cbbb13eea38a36032b7520b900d31dfa05b628ef1c880c30eede5673e8ef87be4c7e1eb3e55b866e0a79dadd40aabd51e921593fb3eabad598bcd788bf04b2c9ab31c7e75d4e10c224a11e9cd4ba65f08e3cc21b01dc220f0f6f5ed04294f40b74bd946c45b5dcd841042204f87a0c9717aed7ab3d2a7e0cebbb3119690915dc9aca0012a7ef3130b7536e2e6ee58f192d5b0ac29fc0b596748b9540714395b971c789a720136ea2fa8be33155595b6d6d6772a90b580180f8ce6841253249b30222e85683a470d91e0ab8f4b70bc75d09e98134fd31aea8ec283a8f09de0a7ee68f366764003e7f76ae6ad0b9d7cd06599c9ef408b1dc97c52c82833c5317b09a78b3d65a375e56e4778f4b56e9b52f5b88efcba089e1a16d9a76bde1d1a2b4cbd5482a26a1aad7a7c7943776cf268f8881cfb7c09d80e120685fea9d962354b9b78278d0108992b8e7119a2e11882358e84b6a0ca60e7f372ea5a4288b6d51fb7484338e9e5e9c055cb4eb64f71eb6fa4a97ac46df0ef065bfd2fbc7191135d0314496d5d6f6d0d4ea9d15c51499160462b4659f6f67cb5066df22d47c1472e245c4bd146381a3aa6a735dc80d6eb96ee6631cd488ef3e049664085221c92cc74329a41edc4081a040d95204220ac4b61e7d42aa30e2a0e28860eaada6da05f6e0679e86e822c548782637334fabbe432b30e7dc3e7d8b0a66d3f8fb007fb6a188bf7533a02dd17b61429582066fa45ea122d13a8f2f60397ee7b184d750926b9fc28f8c4a6d27e452aa3b6a52f239f446ba9eb5507c1f3ab679afd9efd684f1845eed7a9da8cfdbba0bb96f3a2cac22efcad9e5dbf43cd628cc9c14b5ca529d572770bdd9507b3de01fc7ce78bd3b4d4fb9ca8ef177eb6d58ddd0812329467668e28bf966fb571cf5643c7faea3059afbc912ced37bbf97b964c2784b009f2928709a1825dcaf8ec062162887248ccd996342aec5b84102d5a6808ab3063cc6f35572a62e1d60575b5670401b140f2f797353a151969c240abcb8a20228c53ecca4065eb49f49c471e4955b3b000f70e0a4be99a45fd90938b70e66deacf1b407386deaf54dc40afcda5a6fc1ef220c125caa2b68bf22ebd66b1a2b164d048e9b91f043cd90b1eed4d2ef84b7a24dd553fc67acccf4008e53f6b294901957b12f5931b6ac2b113317a808dd0198c10ac51bce247a1bc793b8d6e96222823580bcf9d5e2f028cf6116b88784fa1477a281d1478ca9f35bcc636c3f7c5a281d85d147496f99f93eb35db15e8cc61b4d7efc7d2b79128fb569443dc1a64dc61fff640d6f6c766e0d12215657bfc6f62c4750b4505f78ac4e10a64a32fe686b7615b69c5c0ae92c0a22700f846c218276444d40cbb17ee03299ae07c477e25768117b896aad7714be3377a34a3d45c14dcb5d9f716d6a977369d902cbfce970841ffc4f5af51501f3884f3e731b1a35867322e79ccf47e886d3b51a4a280833144b7a5474a04d89b0964cd6901b48ca40eb973c2bf394752dc574425f982846bd873182f02d91024493f710e6c14c9b46c4a1c08594c76df400da0f2e01a8857bfb5a898582d00ae02214b6e6ef2c3454378e5c21489225b05db4ca9352e449d2f2eee4e5bdda8cc85296e8ac50286eae97a543630f61db0d222c49d757cc95473c494f063da26680a3b9513ee5830a644aad338cc6feaa84f8582bed672ae3304b0598e44f3afd3aeafce0814fcebc18e38b4355e87072329138114b99cbc3556467c8619dc2c96843a39cf5423fe3c5f823b705ca74b8e12b46a32ad5bb82ab18456b044bd7f221badef67c1bfa5b8b8486a96f32ee7604e8136b2d3b1463569c224fd5081938db3842338759a1e62d8975b51cb035efb896ecd57b988c9f98db4b8094598883b5774d6e1dee0ee66a529f4138a8b523d5f4f2ba775c60f15d6eae4df50db6d3903c251f32f6e456bfd982dc5d33e1a89a497b79b9dd5ab2b5bd0f546a63e5fd02c775124834fc825ca88a773ed052fb968884c1f2d86d71db0831c29fb86fc8f1f562babc4a55819fdc726bb5025497ff15f070fa2081c07cc1041d733fc712687c483b40499f62515e8b23b4cd6136430e1f8114dcf68937942d3cd88069bf34d093fd49edb71ae438b505b0db13f7fa85fc3c3f90a70a73c1eca04b893d396d5ce548a608b56aac3f461f3e1883c6b6145afade6c7d47486aff547ffa1e309464cd51cc8abe60b32dee670bf29f10c5d6c2f7b35403ccd563006149c698f491129f04805ab7acbd67fab2c9f2bbfe74ad21faa31db21bd92974f4ce58600d52c957c734a6dcfc42d1043c1063cac03d47808d022b21bcae03ecc905fab4299a5ea87db60ca89c75f3d0d2d6df536c884a9d4de24943b1010180183ff4cdecfdd7ff9241fd9a3f61ec02c3eec0649c7ef1927276019a35cc76d40bbae92d2ad134498f5c8291206df0f47f7da3b3add1c53e52f71b8b45a48358c0baf7b80207945d21a5a14b029f29c6c70cd2d0a7bdd7701ae00ec42ed4f9ca8876dbd0f5a4a714e3329225f7429d8bef3b3c99d5804b695a2a18d2241c265321802d0ca5994d49fd05fbc192997f3035d7f355d2f03040518916a39b8fff20832233f1f635301b10479b9428b107196bd671ad3c79b062bfbda63a66242763aea0c90d8f195331cf40e55788661425ecec129d767ab7dc62db50a9c6a84f3822163ddd55f8aaa6f9070b4fe71b9257f7fe4279840e06a57414ff1fd6f14506cb6ae73d3e82b04d2cf3a883b16f3c95d1a56046b6b242048c0990072ed398f2284a98ede53d156c3e4e8476ff4f68ec85cde5dca377c65af6f9b4c88d5821179841d8db743c4295d300d020c28541c4b5389179e5c20b3989843763fcc75f9d857f5e82e163c75dfe661eb532b4e5578532764f12ea9714994ca643d5d1029edc9baaf7000df0d511dac74852796846c1140f720ba2c0b81615470467bc1fbf81af2b421fa74f0a7b3097fa2f612a1c85999e5e965986774b936cebb08a1615d8f89af748212b572a633b99807a0de10d7eed93b476685f9203cf8e17dee0cb5b3badecc917645e8fe4fa6bfb31a59689760ed39378155441df9f182902d7939b78b6dc8a6cd193829dd2599a328ae56e931a69485f2420d909b73d9da4d84d927462421efa566b53b5228a0107d2fced97c73bee3e59fa9b712dd61f4a8197531e9224f95e5559bad5b270a3965b34fdf71ee4cb7b007dddc6e84e02a8610ddba6924b7a9ea6912e07d494c8523827b1894ba6bdb50e17f14c40cf92aa43dbd6a21fd9b01eb48157b87166b72d1c59ca7d6eb591d4bdb5a9bf96433a7e90c7bd05156dbb39fe5f73f3cea106fa4e084904765faae98450b1e28076b2fe166cc501fc13e348389cc00953170fb69d8d17ba463bd930a6b2fac7a720f214b0c0800f6303326f030a2d08d7d76b8d8702a916a057510362d2b2dd0484e9762b938f4b76836b77c4f7883706d9d1414ecff5c94e9cb8cf875985b3e26fa47e7ca633fcd83da2d6d97df527ce3ebc575aa9aef2890aa645f1ee506b4524da4930761a56a4536f3090473a97474df0f1ad17b5b879d385ba251ac5f9a5c64b7d929518719896832d579e0052db554ab831fff57550b9c2cbb03ab063933e05b1c0293f43044f9dbb623825ac23e12b1fc4e674f0098f1acfab472b1594b522515a416917106e990b8ce03c3c34091291c4e8a813ae3685f0ef1a98500f94308a1d756dae7cb2a5f6e658950c04e4c85a4be542a479914dc310bf9975cf4f322f5b52379eb11037ed306ebfa3655f630ce5fcc01e9f9c98166db4f5fe5e623db08419def7fa089d080841320d70aefef0bf2a4509736d4381f81925b79554291f956d85ec7962c30373e2240361958d5fedfd12f05eff5a5d06742e4678de72102b8c0549b00b2d21fe392bad65083ecc6012a327240bbb1ea6a11677274c30acb7e1e5af74a3b836b195388c735e1b1f97a0a6962a55d1d9f5c813896a7c0b1d1625af4bad9f9cd41c8c43d778dd373bf0f9e755d83c2a86a444a63c997ad0447c40f54632fd0670905deb60dba56a574d4649c51f7a314de94b19759f6c873753408ae49f71aa7b714329dc36bc202a6e976d140ff3529492b5c87246bd7fdf145c56e8408bde28f1f9d5e9feda39d0c5b952a073dff8627b7ea805f9d57b96121966ae616751879a27bc0cd9e7671d894aeb0148c3f6c6b94d53e09bc35b44753a9e4d775fb5eec89dd14b66cce6f65938355d55c0c5a3ed5d2d6ba02bf1defc8d29f330871c5200e9ff49c4ab5f0ff17159cc96ecfbca8520672cf8c917a4b5f3c632e862609f695b774ef219ff7bda407a08f15b0f75b81247dba1dc1dec5cb247d8dfebc17f17520556ada65aa06d490ad59fb8e6c49a7d9f7736fa4af0afe222686b141fa0158aea41ad1e8706f3fc1692bc32e2157c2a4e200350c06651d176e9f0fa304d0cc72a4931a550b6587f31c7c54ed61ce0e010efa047a58c50b2a57fe8b70e481b387e37da9976ac9850bf24c901ffce85072cf5865dac2a908f8b882047795b8bb78919c2607f8dc3c5a718887f70d08520dec343fb623efcb9f448c1550f07c1ba075b910c8f916b65450faaec150dc6c2d3cfa2b56776082c831e885cdcb5b69235d4497e65fab67bf4ff8839ed58004fdae901f09aa887e147bdfbf5d65c65b1999084ba0f27058139ea1e60c0d37cd68948194b7c0e8be9f585c64bc6c5100ce9b7a840c1b06714eb6f7f4e2cacf54326a33a49d6480b3742d5e3554f47ff171e187c51eb6aa0976ed496cdd87ed71aa3598c8c8691360e181bb2247e3dc863f5cad877b7a5eb97135b53dd7176d7dd3006d41744b58b861f889eb4468750ee73278ef2b21ca1d5950073c1e926da58250b7aa7d6478c4c784f0bed51d158f0ebe6fe26330b56c7d07eb6809de72265587175e8cb17e3ce22a05ba4500e543f3fce8e5685017928857d4793454fc5166c922f2cc327b8faa5825437b6d4addab460aee7116537f3cc418d47155f41b21132578edc403ea7f62d4e58567f007ff4c61ab1cb90d0cfaa09a8277a97e45a8b6e78b162a717221af6fb13d515431aaa4a5f1ae85296165a6ac3363d61740b3ab36e1edc34e8e73a022d724bdcd3a980ffab6e1de5e3e8e1ffa931f263d5af061e1e56a83d503791bfaf1c2711d1ee8280d94c371afa5baff85b174653d6c875dc2a9e609f4484b3cb16bf99bf630eea650ee31b31e9bac271579a3eca32efc7bf5eb044ea4589c080ec20ee8aadb75cb7bceb7cc6890a3647ab4a28236f08a7d7fd1d82f40b82a5c231143f6261e17307c6095423d57bbca23bcbc7c95d3a72d2c35b76f67af91ebff4e8dba568c277e13978078944ba48ed8b8e1758a17236f7c5dc809936a37e564f8c8d9d732019dc49802a5ac3cc039dc8c795acf1523141dce6eb6e9aa19fb4f72852806595ad795a88ecb557e5e7d3ec0b85d692981b1d577d4c1668b822efd5c3fadd2f4e82fa47e701e65100a11d776c292f27656edecd981e89245be302bfa8e5e81f18bdd1cba40a5ec19656b02e502fc18be709cc1699f1afc16ca9353829eadd98066242e4f88382bb879148e9da0dbe338fb7d083b6fbe66f3c816a3b20ff266889bec9a43932dc638867f85e655f1384c923de503f4c1af2afc68a0a1fbc2297da0d7ea3587929a9d2838c8e09a535aa4b76d6a054e267e3d9132bbcc60447606306dd0ced5c386721e0403edb3d8dc2b64d09f9a239d512b04e0d6b3814196502292a118021364eced07821573f4cf3da7d6ba94ac75a1087c6e7a78dcfe2f8b87741cf156de9d449a58e552df95b6cef5716428b37354f98f62023887376ab4824a55d27b8852181028d24bb517f0fcf60695aa465575b7d16adc11954f650496f52d24cdc67593ac11ca4291676f48fd23a342dd4b685da3332ab5f4991be8a6c6e89c9df6ca31467d49139b90cce8c4d4c06ea3b35ce854f143f1c03bb7596f7462b25f9c8262d49ad7dec663ab49a4ae0fb0991d0a35b6dccb1f2e7dd5be6ab4a33f302331fc2b2798cdde9b71596d2319478362bf842471b7ff025bed5e28ee6c509cf363e15bc4a846241b62a212c39e895aa38478592d1516ee7b5b95c1be73ec1f5a1285a9a09879cfb76eada1f960f23f59eafc89555a69a21babf1e5978eec61b5c6a626d0c22865e14d30c6b72ccfb049de909c0e5893bad84ba0b090495ebb2e3f0ab28a5ca4d2ca62b40030a16c9dffa9136916adea9c9d1ceae7038e2ad8d831a2734b87f0d7b2f6f4358785e9723027b308fb39385b8e4763e6e67fc9b5c8ab22928039684407cc98a5e7d37803e6f4c1acfed4bb1c37e5cc1963d3bf4c743c06633c68fc7dec89c9e05e61073b5a5d4e9398ddc8c7e0bddd5f35923c931b3d44372de55da5b9506a1ce657a24645f93b58010077e1688aa9cd85404b7c4c61971ca5ed1277364535c2de422f01e082a74240677c8e6289f66e51350561b86de8f2aa2441913567d00c7aefb18b124e53ebf057edda8d7f188b653e06ca313c8ad9d723b8fb32f1a27bedf5cbfb6e1186c367a54d0fd303d7bf0f4898164f49652ac71e0b38f0052b202d93218592a76a96372ce426b1b60e2959267c59fb08dacb26e24d24627e63b7bcf632f6d3d75a08efa32707fb9a2bced37b22e81c2d9d97434ce3a6a7b0ba434fcfd6017949e25e117db16365681a49d5cc4fd7363f520380e6a37518eed6759fa062b811c833dda6528674c0ab7c2be5159a62e8c2abede6270149c965c03a01456f581803ae4773547491a52c8b295504bf3492ffe5bb220a43e1cb6001fbc75948f49ce875b3e055c1fa2d496914d7f49e98e7a1678b2351aba528ff14a2252a6c753bffb0a044f76e813b84b0538fa1060144887e98976c9eebc5f89bd03a3b4e04b68088230889623d728f9096b1b29f97066974153456f15f5fe6aa040ad4df7ea73fe6d737acb29cd20e0b87b158d053836670a23b31c6fb27fc13df39f906dc7a7289fba17c1e3b5d0de847b97058c6799d409d78a93f441be76eb8d0719639cbe3bedabba07ed830c55704aa1054e6c08b7b26be44bf6345fd8bac2094d383bb1863e625c538050df18cdc375352f06e6665313d6789299d5692393fd1d468ffa8889a866fe5a6f9aab8288b89f68889896e146a7427c5037697a0eda944a3f4cdd0d98c308fa41d397ca52fbc7d653a02f5b2ea7f08e00831546719dd025a379c9fb87fa5f1eada8d64c1c3c8e43ff861a331588160a9cbf19027d095e9d4d98f8aa358f23ddd8b598aa89ae982d8431b853aaeb7ef0d859cc9d62c7e864e4f771efb18144d34e1df75abc740e2f84820a387f1042f21e3985d25cf354388f0b6632d949cb9caac901631b9318d1e92e7f5caa3842bb485ad398d724f584b910b4b985c743128953147c49ed9329acf4cecbc7ce2673590d9263be40a25f640c19d3df2d27d04cf07aa2b37eeb8a6cc08ca470b6385b85ba5be7a19702608ea502acddcd01486ffbfdfcd5de33045c3656954c9ba1be85f4f2060fc9faf57042bebbb7633e167f2eb34e47e293714a51a3341ad46252a6f6cd9ef476d3de991030cee72ddffcbc953b68367e287373fcdd7cbf2ac1b5a22d8847abe6ff29a7577d09f8bb8c0becb6fbb2220726fdf21c3deafb67ff65fe7ce1f4e3867c8a6a818eadc00965592df155e94bac654d4c3acc5cc779abc3dfac21c553dab8f72515a061bfde0dc546817b04189831efcb38affc2f17725eb6c234247ef9672a1e89c83791321e0852e196ae8094afa8fa1f5152949fa0f8bf1f9f465ca3a994d33f7b8c825872c8dd086d3b38f8d1f7874ed0166668a903049ff5ae76fd66343d5d093fbeea8e8036d7688ea6cac5bef200826943caed7f0811df30412c11fbca212782af7d19c8e913e45b6b7b46888e1997ba42e8592dc03d6e03f03078b42aedffd213bfcb1f592e4dc31725c33e68b7bf48057fea93548e7bc4f65debc9936efbbdd883e40e025bf7441c6e357b4669b008202f61ded44344c7d0c8b5e9c9068beb6537a4c2b2c3a7b49ecaed3414fc8d9a9609b38f623b0d14f1533e27264ffacff7aeea69e0339abde8a9b82e4564bcb9d90a9251a35217dce79afea1f3f4a311340915afa33a7d4a5bcf6d2feb0c2437cfe7d4a5f0d938dc078240d38a3d9b7fed5124ccac30d29f4b09ee7c0ce7ca317a3e1cc91623755f112d9fb510669083a3f20341fa0ea2ba4857485f7ebc7069755aa734ca69c14360906d9164d84c5fa62029db6416cf029f0e7862ad9d025cfb6d1f3f11bdda828310ce5ac863dadcb615b3b931a364b0d34d101d9134bababbbb8273b3e7f2b9d411f2702aa5b6208df89b9317e2d9541c42e2ee339f4988a49fd10310c3b3562775608f19145b66cb5c34046054878edecde7831cf2d8ba59f37467a525620f6c728434484dbbb32cca6cca8fafcda45078c2d3f2b3f27bba120fecf4dc575610d4229a0acc7f9498cca52a28105ceb7817f358f7db4582d9aaccddd98f5638ec5b1e45cbc7a86ba177178e9ac0d22d536df35e5d983e29fd24e654a1e196ccb60ea7c46efc720b94b39d0f86a0fe526a68b8cfb085d8c81f5f8dca0aa9efadc06858e3460e8e18cfd92f6dd29037017899a9b7cbe2a88f623383910d92d5c36579180ebdc884f95ca153a81e0e27eebfdb6315bf4bd2e9fe78202ef21cd02d1de1283fa8b8f07b76dd4012f09cf85d141978e4c8b0ca5c1ed57f5097f1e580b71a9ebd63bc907d847a4f233f60ec5aebfb7d059840d6d6ce2ecda2975ae2459ad4765098b69d0040c23db036a54ec11ff7cd04a06d50dfa6fe90dba93b3a37e47d1dc3feaa34047122dc329d769ecd06878ae8c1e912f0b9773e1fd2138ae19c70d3dcae23265eb67005e042d415aac143326cdb63c3e510632e5ad72a23fc46b8806810b02c1ae90c6054cd09b4521e61b7a606ce456d8ecea77d1064835b88ae6eeba25c81c943a21b365d98dcf830b070d590f74d5c20098ad43b984220bba0196bdfb4bc9beeaa1088ba4d307ce6675b8f1f3b96d9b940b82cab9f7f592673bcd4b6b4291ad1269c710d9b8b0abc45ec7ac7a85a2560a8f3494432a8bcec00a73fd92046ec9f35b22df7c065b2843bd1a0c3284c47b7c1d47437a70136e0f2040bfcb761f6f148eca114cc925b37fac8ec002a44d804f0c470fa8498ade2733158ab1b913c037c87cfb4b92292f790281b4609bdadee8b8c8fc23ebc390870bc157e6cf8e17303148b2a60591679d76f096378cba85a15f07bf357a085b825fae9737804adf64e537426242861c1eafc08e3eac8380ea3898d9d0a553f53374270a4be45a7fdc088d3f8923ff4f1779cdd4c2ee98926b855985b13d1fbcbfa42eacbfefcbdefcc464e88f56aefafd74314526e408b3b23a434c741706dbd60926e0db4f99b7d8b4b8b5e2e2e2757c9bef8567be60500096dd4ddd53b0be674f347f5d224f569a8cfeccaf9e80dc5125931b737873682cfc43a62704b91964ed8096c527255283c3fd0a6b8f6bcb963380a91e2b085e8dacb81e6577e54288f8be899b6b1f0c2a21672ff176dd1574d6bdc98ecc1848b122994e7a6edfc8d29d62d160c796fd3e5fe91772476be0d676724f5a27007862e0764ef792c8e8598a79ff4157d57e80756e57e29a5cd64ddc68ebd43255e6f8c3cdf60f548f9f98c719bd7d8cace6fb37df13903322e538eb19a8ce3e30a37e7341e7e8c511a27ef302814aff8ff40aa7f1e8d96f10cb4991815fa9ab3bcf7cfda0c03adb5e878ecd99f3f40d31812b34e8034a5bdb6dddee350734a9f6ca88648f63aea30722ba410a8cac1f7a58ba319b1c3b04887e23a85c2ac01397ccab62f1102c705ee10bb878d86b66198d5550233ff8f2ed7f3e22d48bd800cbb600a97fd1bc4adc162050330f7b1942b6f0b499d8e423d03e8faba442407dd8ee0872cdcbfc15e2733dbdbcfcf033160c6c9f6384915ddbc2284d5aa34f025ec1658b221e9efb94240b3ab170e633ad0eae39ee9ea6cc1898fc0ddc662319c322ef2d0cd714b8131420ea6c8cbb1c94a49cc877d88913a9a084567aec4fdc0138b601a8a7db0d8190964b867da451ad845da51ff99fa41493aa927000cd5132b0ab93bad88a3e68cb42430c0e3d5ec93bd91f43b260f983936f65cd1a9b4fb1a87ec8ba3b1ca85166cb9e1a4ed2a5d15690d94e798e1ed24f433dcae76d72e5537f6563046e38ce709ee8b2f600e89583feb492df6f42aa17bc3cebb99cf97832c72602813a5067296e434506ae063fd5fb0b731de2e367a8d130615c9ae86f884fc60e89ec8c8191740f861cbe56dcdf5c21256106951f651ecf6f1f34b57ff1171b763c1ad4ce936068752926c5a4845f048c35a9ed64adce76fb7a34ecb35d5a12c05987cb24718576a6f9b78268f6090c4e1a85c954b504bef34f75227f67b8b06801201887692945936b93851fae203fd54d1e11f7c24334c5c50e5f79cbc3d0dfe7a8be447031e4d00526ee6903409191faaf0e4cabe006547bb64060fb846a21a120d926fe4744941e8034d318e46087b91129173cd765d36917878797c0d15837fbda0fe2206d8ec71b265ddbe4bce9bbbe9387475ec2f2ef1302f060c48db264394fa80ef270c2c09da2d995d8a00a4a500051ecfd06d6ee59f16cf4c4308562021ba1091b63506e4d2496cb0f8274e49b96b4d120e815bd508efe975fc988638e3717a514a238e8b95ec5d6ccf0abeaaac310015763c49e49f7b1886b81f46e1534fbc28ca796b233e820b4fc0e6724bd8614055de6ec312dcd1760164ba2690ff3b61785755c603f7e8b15ccc2d7a5585124895786f69755437f6aa29c3eac0666c1699376c0b467a1e1ebf175c07b3ba2a2cd3f78910b9bb6a564d84c1e2782c73a5422c980b68d1e6dc016f0ef1156bcb41782453e4ca77b2ad3bc2bcc1596fd3ed4b0d6f16243c14186b4ca764df572edf2c3115afb12f730666ca0071549d07a2ca3ad2c20a1fbcccfdd1a6641edb2d294d819b292a5e40404a11af20b65ef638eefe150b9bf5bcc73317a6d60e410417724113a629a94f231d15aff1caf940f023b08456a3b4e3f780d08d93bdc58144dd3a3afc3df3f96adaa68d6a4a0005c1ccdf1163fceed06346eb3e622bf2d62388561442d825d597af6ae31726c156a8121ac9dd171d390e74603481852042909bf596f7187b76cf6666da36c899ba466965e802722751f6997754bc2f372a032a09985ad2428bbaaf6d81ee99c9bef3019c6582974926721629d4321dd289fa89383fca693a5d4bdc60555225f11566392ee259c6546bef9ac1e26b8241ad9846efcda391e160b99160b5157407f2e396e97bd163c9baf30a45c887cd6a4e1735a675374dcfd364c1ad5eb078d511a9bf493f7d54089d36915d74a6bbeda99c742e9f034b5e5340b4f5e791b6c987368b5ca6c019733258df6f9f3159d2a298a5c1f76e51f152558c1e5da90deaa4de403f20ee8f1ca479ad61394fc810817d97f9cf52eff06c2e037e3cf147f783ca5a20399350d48e50ed349958706f4bebe6b9db4175efa1016997b88b4b7f7628c6a42c62377d4ebe88c84f9401474afd9b490b760096ecd5d7fe9038a3eaebe08913395cad829669cfe05120df11339d3ffa978aed2e7ef211f05e2d26e420b6ca07f01322c7052a441b5aa24f1223c9a8def535b541e61b3f160ad3494afcd2f092de90a929eb9bab47a078009c9a53da0a2bd6527e73d000cc5431020f15bdd85ad5f5d2129ced3eb02d40804faa7fe885720d8dda80369d5edb5b5d45d553aaab4b34857914e13829bf64654c9261966fd63dbb691494363e6017c3f98d1b15e5edeece10d8040b4c6778c09a43c6e7e1fa7aaf3628aceed347072e5ff219fbbdb6eb9a59432a514520879087c087eea9ce0a6a445c1f6adb646981096deed8f665b8584a6f16f42d5c27611b2c216bab86d04f903a6f17fa24a61a908314125b1e812854419e1524b1eeca0422f5819fe42dc702e41d29420694f6cc892c6b54ad2685325699226699246a9a449daf4991e52b22e30d8d662adb6baaaab6d1549b5aeeacae3f16c9e0d06f33cdf30b7f1ab43678b1677f7f73c1b0cb66d2fe29a2f01a102583a37ae7a3e9dd753708dff9848645c86f4b819bddcb8eaf974de83de4396fd96224c11c66d2d13c6a50dd63a302947f877115edf3dabd94aa705defbafc0fb929c9070c9f361618844d28dccdec85a4bc39ab061c3fca3542ad7612b58d36030180834ea713344448406079124e9d30e188c460d56b163e4c8dd1d6bbfdad5adae358abcdbad180a75b1eb6a5723778cddeeeddddeddd55ae337e21a04704d02c09273e7849db9e1c80bda3a49b86646847b708c3f68731eaef3628c317a3778191ff24e172758c162dc7edfaaac51322b4c74efdf5418879947f7856cc5ed77cf732d2e75ad2e4d66e0df4bbe3086cbc46d3c149740385c86351249b09d4885091eb3f6cecfc8097b03267e2d73900ad3f803a15e71e71a7f990c060624ea71e3a00f0789d0502409d79c741c1cc956359e2063c7c8919bdb4837ec155dd1155d5b6f5bdc6273fb8e91232a2837d880ea27351d39778cd0aeebbaaeebba91c7e3f178b66ddb647c61258dab854bdbfb47572475ef1f5f481cece872c51797e8f58f57b024e152bf0cf3d35cb3b9a060d9c4262cae7b32f8ddbe245ce31f4534ae112e11e13ddce0bad7180cd40ea9ee1fe216a554a107a771b1ca42e5613c798d0ab1f5459683f20b232b028169fca7a822ba8ca476767676768cec189131992756d7bf8b1c63c766ee1be6888a27af79cd6bb4298d3436b7cf9b799363e40608f8602f1836e98d83a20c6d05d7f8b37f77715d8beb322e39b3d74d298d1ea5f1f361c2865e9bdfb2ce433d2c8049fe8ab02b768aeb2fb6c277380be622ca261e06cc654e664544b93e856bfc5532559b1ec60e5f1897d81f423737b55a4be9cd4d942b1959a462c7c8919b6541aaa591d28d6e3146598c41e246dbb62348dc464712f7bfa1530da54f5bfd12e0b569c252080a2023043861fb23c035fe096892049ac63f2626f46cdbb66dfd59c28a98b01bd3606ef464700ae4806b74b0b0bdd1205ce347e2916d6b7074c453b64ac739d8bde5e06f44b02d16f58a25c44a2592a12896bd8f8a0de5f57fc5183932f39c71048140111465deea6696f10517da8936ce628db19014f6891a0fae472aaec71d5c7fa70293dce5059760de7594f418a62937de755037a61b0f836ab2f12124ec0daedb8087507c018b715d72b1509c146b4770c913ad78ace2510947177089bebf6bd13b3c0b2ecd8f43c47c1881b81e6770ddb770ddade05db8ac068daf26f385f5da982fb432be6abfb0ba565416492d93c9643299cc23eaaed55c2a95ab93459290982c268bc9e88b40a2be5d8ba423227655aaa642f5e3944512334f8f3fd0c1ee641de8eab8fe11159b38a97a17772e1e995cef40d1e7274e0ff42010687aa0771b50bc71e32b358dff87f6c37ae383e223c2f5f7a468015ce3ae831376def0e6d33961411fde88e6ed3e9f8e54804471072deb9aace6aa2e14eabaeafdb82e8b3c445a27eae1b2b26871e102e3bafb8c2d01d11ea66c4597c4e80ed7fdc3d053d09c5630cdcca24e2eba2f9c604c19d7b84c76c5f0316ebb7a4b1458b82d8bb55a3b57aa4872ad56b550c85a97aa5659fc0212c51d8822155ce36f43f4825445528c4552e401d3f8fbcb5452ace213abf88395cb7cc7bd10f90b2e85eb1f12312b20f4285c7f1b9ec5f597ae488a3d341598c61f89d00d6c105f1012030b4078e0b0b0f2146b2e03c92c16f1e43b91343defef5dfc0ac699a0f7772bb8e4bdbf37a171b870a973a7fde876f7bc9bb255e34857f3983299ecce952c9298a5cb5ee9f23dd0099826922ec034fdcc85aac4f60c9a50b5e84700d3e8d802f37e25ca0f3d97305f38616044de4724eb47048e6630c10e07db656e13c618ae749ec700f7f1c3217ec4c1f3ce3870384cc1c1f3f1dbc46e33677ab673eff992f873df4cbf2989e7e337d3df8d0ea6d932a1feacc5c19f7b8f28b6e787c4f73cfdbcfe84e8bc203ee7118db866bec80b2b67cd01ba27830eb74e2bec0cf1bbc7803ff73fba796edbf462bf0621edcdccd03df743bae7be2453b64f12bffbb66f48f749fcbbfeda0bae9913fc4449b0f2c38f1f2b9d5e417e118b11c6cccc393723b0935fd8f62f5ac618ed17b20893524ae78c94ce58a3284e4ae383925239279d944e49279d91718a413f4797e3e278afdeff289fd2b05e19075d7a3f64cbfa23ca3869d41fffe3231cf4c3f81f3f5aa07f04618eebf30bdf47a5df0d78e76de639a2dfccfce49df7521d599df6ec4bb7377d79530e02731888d1859629877e620b2b35d394fe20b46ea279bcac38d8d14fc77d3892405ef711b5c79670a471fc8340f3f8b07c68cbba4262e66a24a46be63595758544fdbad63ce23b124dea4d6e5bddaa9452d64e344d94f2bb691e1df7e99eb0db13f673fd76338a10c491f02f1d9d73e33e54e4ad22b8a6ce561e0e085f5a1f99f191c6e9562f41eb86c25a1de9a6c56677773a2708052466abd5aa6e72dbea5665e5a4a7fb745252295b5cd33070358e5361239ae8ee09dbdd2f36ec58fdd04f9d0bf11c36b0f2b7207caba856d8a6545ee148ec0bf300c24a2965f7f1401f2ae26e75a249bd45d3cc20d038fd650b246efcb8ea2f34004dac5fd07b272f3fb8c2085b708107ea09d1017da148131f86289c564ed8b0b31076166ef4d30d0f3c73c2e9e674bae9d837ce830eeab43ac9205c43e794f5930506b0894dde924dfc1fef47e5368e9bdcdc56ab6debb62ae20b12b1e9745af9670389dce48992f4922378809972682780f083cbe4bd114d0a1203a05bb17d4d206f2b92dc89477151e1aaa8135127073f2cb6d5dddd5d02a6f130da861162300e8ee6e18fa3c7781fdedf112c4edb5fc138f1f4a526340ec7a5fa56d5ee9faead8a8d53a479f8cf4e32ff22dea73fedf1ccd37d8ee3681c1dccc37b1cf7f3f7e339734d7b4baea91f19e3c74353b85d889c71ce3a6b8c31566baddbb6515a2bf56a6dea0109bdc0355d802fd4c5ce90f7fe5c158d22c9fb66601a7fcf62b409a92159d56ab55a0d0912d0ac999bc66ddbe846bbd25ab7ba511a29cb91ec1163947d7a60437f5db7c1e23630b7992f63acb53d5c953b2cf921e435aeb919f5b8d9116385abc562514ae98e118ee3385624b1228d1cc755aed46bdc7024bf27d890778cd8e047dc66bee7312e51fdb07212259627386d8a5415ab2b602f07a5d36f918dcb5e047c87209114a35061d5eae08dcc11b13833839b629e394cc0e502b00da54c30e81fe2b83ce399bf654cb04d2bc1b4e536cd9af14516ad3355eb9c73ce39e79cb3d2a9044bb94b348dcf280cfafb84c2ce26521e45b3454534b138a8258c1dfdd01a2362138d11b949cbf5a781f58471e6a6985f718ca84d51c4b7e3e68d11b1a9ebbacf526b4c5f4f65c399e2b2d5ba6d33156933254f0e42e192d499a82e369c29192a6eb7613bd89952c2b2f763a6666a862849dc828242cd9443ecc1cb04c31022e86d94810fa8dbac3a6d0dd1ad6198a908fa60449115599755ad0dd56835b06e54b061b35256dcc609931a9592af48aaf1345054505166111316036b2ad11525b27c60c39992f9195fe39b9941e667fc4c7f43647ec6cc901a1ffa1a1f7adaece74b13c988362eac77e04c7f8dee97097d8d2f898d0f7d1200fc8cd7c144433403fa175e07538c6806d4d9108db62b581a2ff322206c979a9981c6c73c0664bec6338e1a49313ff318a8f1386afcccd7781c684c1c1f80c7c0cc0be0c3c1c6cf7c003e1ca60cb1f1338f03001e47674394d3e30a36e66bfcccf63a98a82bd208d1a1b0176d459a0304615de69dc6e733f38ee3dd0380884d315f030038be991a2aba7d3313a8bfbd0e37462aa22219dfa21bfccaf8220d9a074c970bf3531416b9309f13ad28aa60bef8648698bff14362fe068d2fe6852f89ccc739d113cd10b1292462538c884d34ba4fc83fb1a794dbd0bcc45a9c39e82e51110cae710114d7b7309b8856e825b8cf0d67ab8b619022184cd3c91b9b0a60cc142db2680e7adcf9c2ced4e748e31aff2e78c76bf1e435afc51d445664c52cd189e8839899a2551c74eaa22d185e60e387d479e0128dc6cac2c1808511f31d644b58a99adb8491b5a2d1bca4669309e54b644d9f59668a6be60ff38a0c08312ab028b10897933ba33839588b446898a9ae61a68a843cf3d08ce7be980f41b7f14d554ccb66b4ac4616685441e6eb2d66cc142d66be68b3fbccd46471892fbde16c4d29b11559363eb40c7470816052a4451a6f9cc8126388248e60d03fb23c92a612ce510c26aebfcf17d7b87baa65911669916524922218318c9d1d76967891365373ced93595a231900ed663f0325fccddd2255b9265ebd6db16b7d8deea768264b15eac178b158233078d98e233b789dff216d7fa28e30b1bca4e4996cb6da4152e6ddf754ad45056556ca122595226a7b82eafc89914b11536942c09939fef1e1472ff96b0de9a7ddff711c99688e5921549202859208b6e3af849bb9ab41acb8a8291d4bd7f1a003bb0d3e2d545f4642092011aa41467c9c0dac2b66ab74593ec275b9dcf7c06f35d0085b2e059afc2071cc00de34b1ee086f1d53188e8729b3006115bad2a31462b3706c125d6d7856507a713969382d6ba6ddbb67d88648049f1ca4bf67ac5dc30be5876854932ca8bf5928105856be2a64567b9fe339e39a145b9e2379e20595c23a3482b5255a0a638edc82bb8c6d5b1497f506cc8b4193edf3d0628066ca481c27e8e965198c65f52b92e81705d5eb9ee4956a758ed4a75aa53f3c5f9278339e7fc7c3e1f4ae9a4f3f3f97c4694d239e7ece1a4fe7c54bbd13c1ff77d2fc4396984b1c562b0d7bffe35e7dce6165f91f4953a6ccb84f29a5aaecf2ad79fce6df3bef9482a116167fdaad5da5048b6c00b03171b53602b08cbde6784f55fd5d5b6dabef0b7554c4d1516b799b05904977670295eff199bb348ea3e04044ba5ce28dcdc895ed8ed89839b152cf7d2003eb0fe7c398a2e5c6edb4c96db843175533eb5d84272d30da7943bc60d638b4b7de327aa41c77d463f380f88df6d9b1f3d2022bf51e55dc04d311505dbf160d914bf7faedc26fecbd5625d8f22d912c9c086b235a16cb096dbc46f7be2a02792810db727dbebfa6f5ad8fe30a656a9a852a55253958ae08d2c95c72a5315695cc776cb411f4f1c74c6e2e9e964aa3a6f015c5322029ddee7864bf1e30f31753363aa4a3855b2255b32bb4d617bf27d7860a76a968a3207a74a0a9646beb6205d30933298491acca4103369c42c0bd7bfb1c0a54d62c134fe52b8fef10bab85eb63cc18bcfcfb0726c9163321f55442515a45b43ad58598daa61853750256019b80d4af2879c0530906e36a3261c4759eaf364210aea726cc55515485a52fd9ba79d5dc6e5dffbe3245ac8a9815b1d754bda66aaaa6aad61d23071dec566db1cd0710a5b3810c0b103b302b56acc41839b2a7eb4fcf6284c42e0a892410308dff16d73fecb8e6b8c8c58e8989d93eb5562bf7484ecdea2aad9344d55250fe95db6a48786b8ee3aac771713aa83f346a95c2073a34a4c43123140242103233ac9db36eb14306084a2b5be48832bc1ff17bda281f3737a36ddb1a4581202f24923acfbbbf17b93d90cc2259d56a35e7768c7adcf8e01a121b4ab89b993bb2562a5b69531a69ec6ddbb656b54a35a9bb8d0eb791e2a43afb32bdcc39e7a451b66d71dba20cafb25d6bed6d1b218049120c491bdd91478475976b676727ba7622084a54241941a15ed2a6132e3d719b3058d2e4f6a11f782e993b4c9611ff18bf21dc9784fbeee3fe685c03055b7feb264dd6228df770e9c541ff3837340f5f010b1a87abbf936af73e2f22918424d2344e4ef390bdbc20c9f97c5efdf9ee4f0dc9e713424237d16914922f36d08a741922631ef5c8018670442dbad3f5e8d445b1d026940965512b5445a15c7f19455068c1429fd0551435a1729b761b896a169394db44978c0f36152342511445538d436920002736a42852acd5da900f360036a0a9bafa01846f7f32e5a05314d7f8e7bdbfd1c38b75d74db90dcb1bb24c004278661e4fcd43f3ec7864d7ff46b760352600950d23ab968a39d8b558cc16c164c5c513a594527631bbdd2dd7bbbb259df3935d8ff1c186a35b639ea73dd03be84b9283a9c240a02f097d2501fde73b8f6846f4cdf4c3b4e787783c0ff32561df9e7b1d4c3a7414f5c2151b6759708d47591436ac308a1a82dbc022699afc6bcc6d7a78b15dbb2145f96f35b7691a4579fd627ab0ed9a32a47bef4bd2d5ee874d53c21ed7e455589483ce84a6fa0b47280d8091c635f091c68d60c31fc51b273676fdab169817fb1702312708174ba5891bd22154081136e458ade2fa6701a3281445511445515477b2f1454a29fd7a924b112ee1b8fe466c9032923a402bc235fe9f13a4eccd49acc52d77cdbc702b553ce65dfcc51b07c1d2206ce855dc4626817a13ccfc2458c42e65e35227650ae34423e020ecd410d7047d4dd0b7e33c34f85e60e9875e60528ed320e0728ebf935a44a790d0a42291c697e8aecfbd39952291e44b348d37e1f3854e8450fd4287c29bb88d045fa2b71697a870a9fa1242446887a2bd096fb9b7ea87a2703b91edf5b75a9ed06f7b68ba66eb7113631e16e8c8c7a787a5dc9467e592dba8597fbe7ce504c4650f24b3fe39ce0c84d58a15e3220506e5b5a56585ae56d5bd7635eec9c27237fcee6bad5f3f97bc15144d226244af1a87da20d48496218108a126ec12fe7586374d7bd5ae48530433c7107694ebcf79b7f2e0fa3f5769d9f951fa021bb26c031cd000976ef00126f5e949f3f0f76853f801130c869a4707e1c67558f33084ebb18fad0ed6533fa127da4f6606b80083880cb65aad56abd5a8c7ca52e166a64c9bfb65737222a94a493b0f1555aef9175a96d69430c963c34858d029cf97e3a371b88f86e6e1fffcf2726898afd7e49253abf461060cfad3d0384780602b705919610818d7662c2b66f3dde3e68185a5b55a6ddbba3098f993827262f22122ab44b8f35c91b922658e48294084694d7a1b69dc00d37dc05988d0b972743dcb105ea24966334f3794b957ec8d1bb24cd6cfe7f3f9eae0e73381e8f92244081b322dbc61de22fd34f847e446caf20d43a0474185d828fecc32c4ebe9d787610a1b72145f50b9a22996fbeebbb9f9978076846bfc6d11d6238a5ef480f483b040c041e7bbcd7c60e10d13029e28fc206ed3d94c520cb20797e4fb1549001def36954b5bc771de8fcd0697526069304e7f29a856864b9e77cf15eb5d7bdd779fcfc7fbe1f916c944e172f6084bbb1f1a8d46a31df1bc1d0e8e1cece1e08d833e722010c4c16e193e88a1dc85a5091396955635143a1a7532274f9cf8cb10979c8e4236c0208dfafb236bbdf4a768042d9271ce398af3e5acdf10a7e98cb07ec31010d6e6c086f6ba7c8fef38fe7cc51084d840dfbdb0262463e380c1216c689c3e1de1022f5a57282143316d368aa25028140ab56d3b463d3a06338399ebe82736d4d0a76ec234fe12a3f333ccbbfba5773d3cb0a31b3f9e15e1d9ac8894348cb98a2d66d7218bb1d825bea2966d4606ef3ed7f87ff7c726f3b76ddbb61a5aafadc6c5a5261ac7f3fd963eccc370c586b1359f348ee7065c62e2243fbd22c953339aacc99d4892f1fe13758a246fd249999c359ba44bb6e42aca28cc87f2142a854aa15cb3fae578626722107ffe8caf03150eb5d08a40709a4e49711b260e63058b5a82e212f3c7631173f6d5da50282e81b9f10718d10cb771116f5785f58f556e186bddb6214245d87645527479a660ebfdcfe1a4c8c4458c1397300c5c8a33f8dcf0bdcb7db515bae185b0d8b88469fc7fa84e228a6bfc0a1bc6566c6d1f7a1f4ed38f058b6bf12d22601c04308f7e5983112e4d0528a0fbc25a3d5f6cc556addba8c7cd5cd950d2ac6256ad184abf9eb4165655a9ba9b9b1bbad55a6b7d52f7616dff4251b061e84a5291a8c4f5ef2118076c33df85e052ff4da4691ccf97a479f88d77439e7d5f6e92d4f79bfa85355f6e68641e709266c25f51dc2074872269014ce37fa35255954aa552a938ae0a19e260ff27369bcd763ce54fbc7054173f7913dae46a4339399184a4f6e068462c51a06c9f56713991e43f1a816008d6b39e71e9b3a104dbb7ebba6e3ebd61ab26f390e17ddfcfcb077d731e902888839e811d52a20474615b3509543525e9314cec31f48f4056a6e9ff421b2af7db047a04bd6d40e87b6c60d8ddb8efeeba0f924e61b1b5630efabb604abf0ecc2b895d389950e0f6e57432a14226985702533b9d4e261d1d2502a05513cc2b71c02c6482791d253cc6eb64820168827918dc98604c30cfbd6c900f0b9d05d3cc9eb0ef1a62d6a63b3d836189ddbe9909f408e6f7ac023341d0c2ed1cffe00e6f5a8f59382a41dfee5974d9f006c4041bf6cc51b3d96c369b51ea33cf65b67065d65167a08f500eeaddb6b1043b9271123b5713e7873bc21cd7a9cff67ecc2f6caddb3665a432da3ccd79d2d15698344b67d55552934fa78e0c82b147a3ffda5f47c4dddddd3d09e80bd8ca94c388c90f5ca629fd21c36230fcc0facf990830974b9fb95cea3a7dca9175ea0607a9128be408f5e00006232ceda0b0f23671d053ad1c2acb7c3a9d4ea73ef58952a7755268ec34b7711dfec5dfbdb8bbec642097fc9238ee03eb573b8f16d6efec9e5e3708d391449fa6c37d7d5a2455ee0b400dac90d98d1e5e2ccfaea36ed846c0208495c16934da9c3b68758c8e99274f99acc7b03559173f317a778a42987843d75b75606a24b5153bd7df690d6cd8ad4869b2586beb38a9487f09781e611fa0f72f82821b9c04fa680d0025712793ebfcc53b2b1e366458ea156b1efe138b834da4b0adfa9ed8119020ec1d9c808df81371555c9062080c3ad83c8a500029322292a06a8566383ed40aa5a4a452527630d26ad156abd5ad6e756bdb463d5a33a4b85caf1d2f586656645ec0b65497ab7dfb500f48e7e1b863c3762921c68a3cd142609c2456669f54deccfbf629926efa497ca2a2a208dd4a4214ed84b80385b5723da9f2ba5cd5e572b95c9c886fbb869cbc2e4e2754cb0a1396ceaa4aeac9e90482b20623c95a2e798de35dfffac562c1e5367d1b50b047e889f66f4fe9f6fdfddbf71ba91ff24e7df0648db06d65db28a5b6e3a55e05180a77fb3ed5ea606f2fbd1f5b1525c1bd0d6ea4af9123f2044b7d4ed70dc0a300bc8502c0c6a9410938416aa05d6c100c02c1a07f0d8d83a479f8105d584a382276da69d970c4c869e774629d4ea7d3e964b1405f1cc7c5da49b264151df9454a296badb5e6c076dfc1a049978508dafdcc5924e6863cabaf5a3b092781b5849429490e323b28d3e773e8b8b032791f6b50dc660726758d4b325c9a21272c7f58721d06256c18dbd5318fc13f0dfaa6312fd61cac5dc023c39b6133d948e30f33051b46d749a2b8a71c05b2dd30db33dff3f15c1679a28f8863acd185edbeb0b7442ef10a26512298c67fca941ef4e086edb272c376f911b1567bc2054ec80df4d6e73e569cc6fbebedaf5d4caccb89d30d252ad6ac58ff6e2bc27d72885061b91bf2dca813d7db65a579b812d207066740ad4820e42a0a39c42bd624ab5dd48adfd4502b4822a96b55d45c35b9721bae166bb1166b1e0fc735421c1c4284be6c00c1ccb4b1d056df4412dfb0870a0b739d524aa9bb870a6b61c842686665b15a739cac5c00b3b826a6c541eeebd4ed20ae7f6c988f9c9b90671fe010b007901841e33414be02140ac54385a5fc04834180328486122b024bc6daa4d06655615d094d11aa227473c38ab1582cd6b6c154890921726242c310a6e9f08cbd906ebd05724c08970470fd89c0000a283d19a6582a73847dfba9967e433ad50d79f6b2b6880d2152b013f0dcfe402e794c888cc562b198903977787c60e6a992826a321b89b551eff40cc1728c49705f9f37fa7f798aafe2adc899354a7b38cde69b1662778cb17687c57a37ac4dba35c6186387c5c65e71e9bbee8574b0729b9614a61ff6eae670e5d50e3329a3bf6f6d6795811d503db0d36bf0067430dbbd6ff5e7ffe5571539ab55575fb93c7592a97f90684929e58e9119dcc43dc3803e1eee330203f27ca4b0ec604ebfbe70f46166f678a011e89b3ba31d5be5975365fde837bf1d233b3827288b52564bd6a54aac61cda55d946bb53614fad128ca6ab5f61f0447a366f58b4b7c7d764faf1fc6a5fe1fa6b84634a10b76b3a351a86d121c3721063d58c294433c220c93e7bf54ca32d7d8c993274f8ff60cfdbef4abe7a39f1107dddfeebcad4bd8203b18b1b65a6b592c101073ceba4dea24c65837fff13f291d758a76c157b0204290e80ca100eff0175917589066120d1a39187683cfc042b854e3bae806e192288bdb42827cda415110075d6efd520bcc11fc4990ab7ad2c38b95715e95759356791031ec7c820dc1eba22dd81094f2fb85041171b121087acb240c0683c182ccb9c3888e8fd8100e7f99c383cc9e93ba8e3adbe9597be9d8a45cf274308d3febe8f1ea973c5dff26820d2e729a5ffdc9d51722ac97cb59a8e8b2e58637314358ce4205961bde64a982c9cd424595cb598ef0e2e2f6eb543f1e1ffad55bc4729dbda4384bac4a9f9acb7c65893de186bdf369653942ec86ed456e348c56a415aef7f0aa3199ae80df5aad0d85fe417074634508eb1e1020ec20783ae108c5d3cb4ece628425d8bc765eafd7ebf5dab6978582e338e68e7c24e9288119638c2e9c4c32af2383fb9890679f1f8c2304300ed83cdc13b14946c4261939ce711cc7fd370e17f27e8608f41f519bac884d9c2889cfc788941c9111c910292972fa3cd853dc225cffb000d73f2236f5dd3e326e9a216a1367454a723899bcef603ec7258ce805bb9e08072433433eefbdf7f97038d271a2d6e260f7f2e19182c5e16a975feed362a5b07cbd9f7201192118a3c56f00e8fd6788580121cef5070bc0a53700f3601b4a039530e8df34d063b8eeee340ee42ddce71f49344ce38f802b15641a0eee73d41d5686877624e420d708f1b8c5c2e3f1b0876745aac7e3f1783ea311087ebe1a699cd890675abc97306157b9eede00506fb9a410278512383f9847949b273a52ba05e5ca78fb31f67432b90c5ba4eb72201084020e1ab1e1c80d48224d7f441ee794d45ab972ed20b88542455253a9b5d6eac9c0846b9c874a7bd23a6e93059372228d8eeb6134185c0069d9c0862db3f12f12699630e908e7c3c3033bcaf3f5ab50a47893277de7dcaa7c00036193152690538324f4175360d05fcdc3fb0a4c03c5f5530db8d0b296a3aab85a2d6ba18e5454ff509d340a2593c96432d9a8879021a998d5687453c4061f3db8cb4b0b6d853a236c7f884bdea871280fd73fe4031b8eee0cb9949147233a1a8d46a3d1b66db5be55881c63c766668e0fc3e50771649a077fbfa00a1760a61c1820c41096609acf1f120117f1174435780cccd26336123bc03cfcdd3fac2132820d6faed74abf9b1b29c1ea25c618afb07d638c3146902cd65a6bad52f610620e7d90213970dcf80c001036e4fd33925e003f2f2b43d7fd8642a15088527a84945246dbfaadeb6eb08a31c65879d63ff817e19201a4c93ecc69f3d8a8a24b72e474bad1830ad606f0869f3f810e97fb7e90c83ad8fd9d534f06f91fbbddf2f35d07deeed37d1495a0c7f8bce78a9d119f8b9df48000e10bfaf682f0057d33de8f803ee8bdaf0718a0a75f1f06e663be1a693ceed99bc17ecc10fb319ff7cd44a0043dc609e483bee71aef0b6d002fa7c3fd70a28f8c7ad9ebb82f6c6c62fd7360439ef12039e06bf57ca1e8f6733f2bc27156c435d25899108ee71a219e837630a71466446415a6d66a63ce39a70e9348245598da9da304db452f3a78716fcf8b2ad61491b8754422e97dbc17aee99085ebefa8482272d2c18103a777a8748db805356534020000000033150000200c0a860322e17848260a728d0f14800c70884082583e1a48b32088611ca4903106210300060404400433ac14053a62ebe1d49c3cda53fe7eae98e3e643a94226bf60417b85a91e3e638bffe5089ea7e763537b32c3cd1b038c3ed906023efb9e63f336e064a8a5567cffe1dbc0c094a9331d30f3b69c1fa8766c68dcdec5dbf79c271ee0c74b7ffa91677432bea0e7760a7cc1827b9935fc8bf91b5072e98c86924426c89c405bcd9ec76dbe2abf8b798d697cbdc896c50bd10f35b60d3eeee2e3a9e6833d8c3fdc9099ab586de87e245e3dd53f5a77d96d350a46ee4a20ec638faca8d75b58722f4c9d5bf121a79728d4dbff51812d25abf793941e0c2a3e16ace0527081eb1399986398e835311a9d843c292e10d193638c719ef7cfd7f6db872fb15176b6af55a7c41259774b743e7789008dcd33fdb5aeee4c0821d8133f78bf84d086cce763fd2975d25249e98900256f18c87ec3ec65ba3796c66396f3d40cb3e4c9235fbd9c386e20e511a6494adf8484fec0ac303cc9fd5ce9de955f3b8c3d890d84fc9f49851918390692050b930aa0579e9ad95d4f67abac99a2156e8e93dccbeff8726d19dbe1f738d5e6ed7c81f89e00e560d99582d3511fd4eae2c29a878ccd80c50717ab9af4827868365075a7a67f4f981646cae036e7d550443e5b091d11a8dbb68935740a15ed5daab9b4b9c564bedf47b8c41e2b26eb9f4fab1ebcac8d42f858421a2789cb6abeafa8603cd6dc3ae1df90ee6c4ac2ee834dd2688f12d65da7c2fb57c0b5720d571f17e5b89b64333557a8403c519ee0153a81296d23cb115ec9cc8faeced45f44fabdbb023c37503c1bda0f244dd058a0871e98bbd4e82b4b63b49ad2739856ea36ca901473eb0b125b68361cadce9e8fb4c36654b25830f9d53498c9060d377291e29da82124d2f2f2b081a8f4863e004b0616448ec2caf20752c8ec48e23aab98bd5aa73d6e853ece07c8aa7c44562ff00118bb279768075bf267ac182846526963eace6824eb4f159bc13b95b78e24f09182615f1f6c8da9cedecf86c906d856644d1778143198c830b1d57beb955188d86a275864d4f5fa80a4c72e30164540087cc42ff9727c32262ea5fc500adfbdc04c1a29e92a9f226a78adad762c357c9c06f4635c001d00ce22e486d8041ce8b8063ddf6937531de8bfaac2e6631107123727a9dd72003ae25618b18b7d7895e442553a98a6bd0b626aaf43ebaf5713efdde821caccb1fc37d15039cdd5081133f990cdbd4572ba8199fae0fd85cb60836e247223e06cd98b1a2fa39f743322774f5ba60978abce004c9f467bb2bcd1b1d1f16bc0c0b1bfe4380594a60e8c292610bca3f87e4b333474b25b02f8c15541743895ff0d42318117dd915595f6cdc4236582b62383e04de142221d853474510a33e68c682aba033e40b58ebc76bbc6290c30773b02cf76fcd1178b3a2ee7f8e8f0fc7390ab6e209eaf8cda14e00a8d0df50fb9901c367b8d55d2671cb402de4f72c2e7e2287ffdb07044884a22902a1b17269804e76d75db1de3187ae9943411682352fa2fa673fb0b818702808f2048681c5785b1afda62f312e6b7b34085bd8e3327cd5a3516ea969af67a2efb5fa660a86b841d56073fecdc848b0ab4820cf1ba6a0518546fddc3aa69f5022edec05965ae0c3dc47e8a6e85fc73ac1b4e09da48ed3d53a56bc3688a032d9ee5c8a52c55e44998a3c187ff1d5957efcbe0dd644cfb9adfe76930432b7015d19ac16f64b416e9a0b4d35431c27fa157c4d6546b94469717208a9ef5e444089ea933e9cc3c016aa0d2d87cbb90bd340d5d291e694d283f019bfc4f428959d736f5b64ec3e26bd24ca3c5f47394d134b17a824e181534f7c4c7016c5975e862d77f7c17203f98155dc4bc3dde2706189ca8a0f30cdb6ff0b7ac52c187aacf776aca195613a013c29d387817a57895e7df921f24384c56e9bc980f61534848c2bf683912224128644ca8599eb24a5afe099b80a72846470d30e9667628615161a4e182ca3ecc012a5f463a792f424412cb371d5289c610963613d2c89bf147ab590b596ad168d09f959ef77dcd554a927e8557c038723f857f9a6fdf08cc80a557b738a86981da9b15998db868ef528d12ae19edf7e79192f43b0030a00dd35ae6422ac970c657fc6f05d16c62d285b56ae153ba5ebf61882126f6416070e6d6caafc044f1410cafcbec35560083280eb41ae14101b312a1f906d0803adeca8d56e3b55c8b7d59082f6f0967ca9c3013ee94d68236909f3592ba01c801f3066d9e8f53db3ee9917d641c7afabdcef143a35918ff1e0b3ee042966632845372cb10a3d3d7165f0781b38fc300e1a6855ff14a54d9e0b85da30c8e917554f58acb08ce62b3b4d0f0cc431fe514351b0dcfa6ee4a38048fa8e95ccc4ac6a6bf7187a708329cbbfb45a20400f766dc5fbe3f8bd6c01c11363d1d5403eb63a2e564ca500c7c5ab9e57b63b842a4ca541f88c27623994bd1223e82a53e4ffd467bf353255ec48c98d1304d65a0bc0bdafa55e8ddf9fa060cf497c2745543ad5855612761105814e8c8dfe28965282f1121502ac17f9e23fd242b5509870abb0cfc3cea02d28700aae84c53c47ee4bf9f48611b8c30af99f36881d16a91b2626e9fa5b2fe34126128a51b518ff14868931744b9cefdf7d89295be661474a494f2305e25a17568dc11611278160b9ea49ac7aa0c4f9d1ae59aebd032ee838a6fe11299727b97cb6f0f3891bbd69cb48535d2f68b8e28d7a7e27b8cf0b8d8e20ffa142478c06d8a0bc22ac0d7ba8b3afc491980c809b0eceec3fd899fc402108979470025ebe8a8a222f98194fb3e9316e16ef9effd147df3da0eba96289ae5ca9e362b9fedc74695958a965df4dad6b72fff8d05d4a4be04e5dcb923077c745526bae38d9d6774e4e7e63afd4922fb947b0572807c84f889a32f90fb771a682a9bdf5155a31e0986d469b0e69181d19624d0ae384985681c49ffcb2e141ea8440f30b0d206d9815d7ce97d04067f1001a7f9aa4cea198e2bc91f6310bbd35cb4658d06a1e560182dce36c20e3ce539d4aae733fbc4a2edb6a1cbf13e18d3c52332047fd2f87bb177025aaecd21a3d78b3f859ad953338f7d710c9944a348921805137c51cee1ebf3b7abd2bd2eff48bc6c2f9f3bdd0b32de2ab613313936e325cbe3749ffa7a6377a01532bf8303a282701f102eb21647f7cd7fe6703cf7f5a0f1fbb0a0ecce432b02d948eb1bb99f850eca8db8a04a2a42df4ae6d8640c26f51a6926fbbd67a5c6f408c0d2229665949e909f22b189f71e1b69207e6e162b7c085dc9b1f84c419878845a611d6c7e1500a61d132064056bb5329615241cd71aa62ee67df9700cf1ef5725fad2508f59f41c94cb7ab6362247b7d9b9914c94602e602c81e1e69b2746dfbcfa05eecd43af1277f83745bf2a2bcc8105fbea6e82656bc44a25427fafd91311c34049fbd38599b17536390b654c662572d6180f070a5e1a5eefbaee7b186f2a51d0f94eb86423f7049c09867a6ba0e8e831c963a0895b087d0a72382505fd857e22f100695c6b2db6d500b563e0d93810de15bc602be8ef3e3e953f6f5071a3cca42145469abf001a1d644e6470733ab6f9153268eb85fcedc950150ede8e01fb480db574c85a9a2f49e5df326c5bedc8ad6e28ef29d8fcf5f0188892809f680888a9dc93c51f3f66d98713b45e19ce33b05c4f11d7bb1fb015bdaf0629ffc8633b1a0fa3aa3800fa003a7f72e4a60588ec8743207b6f21cf9f96b0fe20cb33d3e5361989f0cfa05ee8ac497760cb21e4e253876ea6c690fc812946908b79e8a354dd2665f3415cfa23420fee8b62d1743447aab966c99df93050992cda4ba6125f713a111191a8220b177f575b71426f3c25aea18ea52b6e24be13f90de47ccec53fc53d328697ffa8601d6f804022c3cb68e97f047cc83abf819d3218d36ec4d9951ade708a04561c7eba07edc995ed404c7c1b7f174246a2509c5aaf325d3ab9e467377de354d7d1802a79804da159f2fbe2af88adc376df0046f15a7c6bd109475608da1dabd3043aaa2d9fd190f62e131fabe00eb1487c39431aff841da124546423ce668fe09ee5500fd5abaacf527d06e5dcc128e77c0f530ccaed2e9c9d4b0461c8cf5af3bbefff458dc6aa2eefefc4f69e522bff8463d0343815021966c9f5aee60e025d943f37baeca3e0421500081742a80c14d9ee95d07f88d88e62e88640803219da46a860f1d8aa905b12356aa842f2d8e4bd536e625d3488720018d8663186c8cad165e9f3e44f6b6ca5da5329850b9332056d0ecc5c1cc7eb691c14d2aa9344cae648988be775ed2a5a3767493f9ceebfb7e54268d5c133addbd8c83e93504f758d452df4d7387168061150bf8d1c2e562078c4ceb31eb453672d4e18c45a5c7d50b3d76f27351715f300aa0507b2293d88489abbce4edea2a30b1295927f983f4e9fce7b547a49b1f2dfa38a0bb207e1a3a12d89eac800d15deb523fcc44cedc16afbc04e160e26662b2da8f05d238d6b81fb8abbc5c40e5c7ab175242d54e20fa0f839d54b32ec3ba87ef63e407746998e6536fa169dfd074af8a30a42996c6bc6f155698dfcc3ae14b76c556f0c2e790ac3ed65101d3f746a62e45d12556afc0841c038a7f9226ac88bff4c9e13eaa2ced3719a7a6cdf72771d3d1420cf79af1945e6299988d9630305f06c1643bc4a42d090e97a460602988dd09d55a0f3338ddb4f6898290dc1bb69701dd35b1457e1a0170b56380b06e82a7e86aa2ad2dae523308089e49c7b499da12a5826b44556984b4ce04b44412848a638881b2275c58d00ccce7200eeb5771b9895f0ed4d841fda00b28ca8cfc8f9a3249ecdfc74398fcabc720b8d458b3557ed9fc641f213abf5a7856f49394d2cb8b1a3196f55fba01a9691fe8d5c96701cb0d89f20245c76fc4ca49b6467f2a233142aad5ea75b0b4599ee4a86bf48f546db9f59396f73a836c176ea6544b4a640d6c5cb5135c29dc7ca942ef01f1e9c93e1520c961a1333f1625e04057ffdd71386530417f1a5d7a7b6c91ca2c870f23eb8cce3d44f66492c44a8f353f836afba51fc3d64c372c2e8b473a721254bcf0bfceff3867966954f999a814c4a5d0b0b154b6a3aa5f83770e14de14c8e9c390d8410ff361d5f0838dfe306959254f62e48adc6112ae26527bb0062c12ba5efc99a6fa8fd341bca9730ca51a730e8086ddc4bfda344f91bda9685e9867f16964af46d2da38c4fa40aa814aa99d13749bf4ee6d155d113be71763d80333ccbe9ad85090b228552db7b5bc3851cca82e80705b740df45251a2b3321d7c5ddb0fc8e064c802ad6907067bfb6d3ea8bef3726c87bdbef9f5cca7f30d644a1f5919df5ca9f58d02dc53007b2c001b05008efd46bff4948e11197283f84526e333ea5949f592a79c9a487ee2deaf5aa02d976a25db0710717faf8b196f6df9939ea8f409defac02ec7e97fad3500286567a1fb4178d785b85619f23ef685ce551434af46516459e00fb1c5a1b88c1ed57300fec042a57f70f91aed1093ecc1f4af0d1e34f494adc503a0a40739769cc95808f2f1e88520ae5b3f5940995ba243a12576a917d1beee263657207e7ad94cd2b06b3068c011c60fb1ff9dfd2c07386d0aa3c7f461d382f9ebb705aa3db04f03b651ff004c518e63f7c65baeb517b0845d83523f57feb52cd31a0dc803ebcc521b34e3c58081033b77650efa62e9187d2291b314604b21df488e64f4990c8990a6f36a9367bc838d6719d2ac2d1a2d7d667b56511b37271a94e6ca3caac8e3a1d013a16037807ebcdfe18bfb9e0f6521cb87e4fe087283a3875e9e60b550a0ddaf9eb2b672bc3d3a708b915eb573e4eb36cd2b7774b21f8a3504794586673342f0e8b13d13e46855f2aae9493fb020bdb826bdef0cb42a5aba683fbe60c48146a1a77da9187a73b833550c8bb91060d970ac3d2ec5757b6353eac66c81f4a8e488fe6eb69e88086ca3633b5b3655a07c8dd2ce7cbbb26589b4b8f21d43d723f80f0c7cd8535217eae639934e30caa982bfab4a6c3b38fdf4e163110414168ae9a527a6605160885dc7199f8cc3d9afdf7a369f26742ea7df8486badc6bd765a2fccd717800d46c36962271b06b00dbcfe576984c58b5e7deebc5b0d24608a87799298632ef373118d225bed47cd647e298643587c0a430b01ca837c52e0788df4030c6b52b278bf8b5847f8498a9496aac1b54815cfb50c33e5f0581ddda77c7d95c38ef4d9ff0268aecdd02d7b164bdd7267b66e91f0cb5533ba3cd65840ae0303838d390668185f0f8b6235ce490134eaa7e76ee062c82999e666f30ad251cde26fa4aa5746ea2acbbc55ea1dd785d357099c6b0ee1686d9d4942aa96081d29bab3545acbbd2430500971ed86b1f0b2482530ed2ebf14f7bd4ad3ff94eca7831fb70062ce6731ed80454ba3bdf7475c4b919f13c491ccdf5669416d170e0c5793df76518e18c3772e91b5ef1c6095fd9d4bfe0d973b3666042df85b6e02f1973eceead3aa3502498508f7c082d764a1926122900a2c20f4366592563d1b55f972488987214d63853a6036339fc387248f9da2ef7214e7991c23a16b04431468d795e3c7b2da99257f678d231d8b89cc96a26a68c4b8d82a451fd8ad2c79546402bfa365c58f8bc31137fafdd03be7cef9c594a4b7f1ab17fbe233a665c1f071e5a3073c1cfea76b9b1252409bfb16ace86d006880d08f0a035f26e689f27a77e7430d41b77785b56d31c307d2c0b4b1a33d8ad0dcb042a2330947513140aae52d98ca629b717ece28ebc04fcd85c549ec66f63ed8dd952f1aeffc971f5469330250336e774f057afb15b224c07716bc2b2b33d1c490a67ac82f84147c54181cccd0fa76f5d3cac128c8dd781158ffb581ad87c8e0abda6771283d6995cc2e27a78bc28f9dcb6ab478a95f01047a55321a3ba8b0eda1db2d9e8eeef611a0e0501a83cd3b17567dd1888a1f0aa7b72c48fcdde05c13e5c909eed65b6fdaf0ffe305445d988476f4d518566aa03dde53ea7c45cd1d63cc700457b20e7999b1b04eec640c4e03c0250477b4c24b34513fbd7a58eae9ca9daa3edc905d52069886e01351a9d344404b52337532253dc27b3685bd71cc26f8626e9b1b1f8f0d51fcc83cabc8592099d3241cb7af063e03d71f688938becf2efc9160494a2ac78d5074e928382d6412719339a6e7b07234699d5147c1b8a985495bed6f49926844b2300a0c9f7aab8445de6796253f54205e446f2cd0113a8c3ebb7d3e57361f03cd71a21c2319efa7da6c0f3c417ae916fbacef331ca8196f8d104e594b55be7f9a9a11cea92feb65579f2faeb5d2d2895044ca2979969e3b65d790a0d0765aeeaf254e1370465677b6a2366602d1328664f23693de008ff39441030f1150733fadfeb6c38cff28519b02a145a4c6364d05a756b1e78670fbddedc947e13b6ae175fefd15a10564252275495f6b34c996bcfbb743644cbf89a69b252966f9f4047f5f21011a90f85bab824dd2974a5125f8bc6ad6b4a80090105e6f8342649fcd4da0d86ecd4984e72783f6d1e657e3da8b9cb43194c59fc429709e4e5023e8bb5c50e864d27a11a6d3742b5acadc4f23ae21456b9020ee694b7de5663a7a86670f34d5217f72564eae30bc40f510c2c60b081230adc5c2aacafd1e66f9568b5703f6446c504756ee69733fad92e9aa689823d0a23b97d46b99612182c95bafc9819ff1067cb41922db2dbd3ad5bfe33b48767a688aa33f393abf4933263989a7a564345d7c83d0548487b0e09649f112201c3ed470109dec0296820e1505b76575d44d4befff5dfd01c1fc49b010593470761108bde3a441c7c4fdaafb190b564170de9ab9df051e7bb0adcd9908e391dbad9f0ebf0477675ecdf311799e69b02ee8318bbd2a025c3c0edaac4a3592b79f62a4837314c11201a84f31e9e6d958e57866040a5f2bb06982cce859b06162e7a040a5b33f2be5623200756880a328c9a19ae924fb7c896f5496a60340abc3125eec47590fb92dd03ca44299e8716bea1d047d06acc421483b6e41fc46a4a745e158aca19797068758b833d51a5179d53d42138f6381735cbbb0c2b54426754a62afaa6fa98d0cb4625e0b03ca0a3d371cd2e6dd1ad6da6d2bdb297f5f13f597d5b7077ad97108d0e98ef8ad3321cb4370e8bf374dc67e3e00030171ee1601d2f95086414f8c70209dc1716a50219e35992df51d221d1fdc9a18a45e8b29ac81e5ca93d30d428216c45440b8cd926add5519b0054bb86a61b307c22323015401c2eb728da840ef047d4c2abf2996a60944aae607e0e052139c6d12df55f4e28505a16c0e7ac134af49afc298e4f7493270bfa502282bf2bd621c1aa9383e0a92d5858523b198cc46a14067c1e00d8de0b32ed1c531761786b9e130d373eb9fccc6eeb2eda5d8f75785b906bc1c05906e0097234487c6f9c1bce308eafa1615256edc6b6b87a2e70d81c86576634bba14ef1b2daf37a283a5f4cb18ae78e59b20362d53afe4710bcf560be1b0bd378dc7d95accdcd00d0c880634eeca564b4796895b914c7c506238ae3c395a68137a2195e000451995588909204a746379ac80f54b7755f9c430f7dac534b39ad28c28b99e8015638307e72450b8cb6d56c68b791582e86757a7cb90d014c783178b14b8bfe53fb1abf2a9111591961bd0131261c82275d1628a06024cd36e44e0e4fd5204894b6e17086a8c8ba36d0aeab3737556bc35642082d351adfa2270bc1faf0ba09d661ab6cf443caca1997093d787a97413cae68482221254ca6ad099580274db1646fc195b4b105cfed9fba2d3ccabff992b2e05a6aebb5d6ebc7ae40ddde56c86763007485ae72adbc1375be6925b889e3e02259bf24b1aa12b76f9ad65306490fd405938953c69b71f50d702e82e4c451a537200e3cc349f342daf3a4c3c7ccb0f15e616383124ba5de8ac5d60764c040ff56c415220aea6222300c018f7ca2ea3dc57d508c677b779fdfb326d77d64b7cc573d08f2d8d48e79cecd62f080f04b96580534a807432fe4e4f0433472e7030652a9a146b463f83bc36b46c41ffb48b1325c11a3538a845639d98c970e1445658a013a8d9a72ba36aedb034b621b89d757e460e32d771eb95782d6fc4a726c9accb93774b04d23430bc9e39b9c2181878fe1ceb632adbbf2df4fb39fc55a73fe78cf0a50a40791b2f94d84e756b7c29e6f7f8f0f4c44a87775423b21980066231bd3cb306d03a86ebfc70a38aeecec325b7f9e8c4ac1494ee261f2a283ad8a2970450d2cd5254dbefa371d98ba1b27bfa0284bfb1e4d069735b724225ad6d93912466c1a74f07cd9843d4c411fc05540c4777283635a8ba7322b10910fba436c84809e0c1cb773f53860351cace24da7f26f1aa05ae4c0a1a1cfca141c8d28c05a16ac2cb83404860d2702cccb54f37aa462a600e70546cd3e426f7ced4f257c8a47f406b1a0696ba3af516dd6e02e3d55df110ee1ad2539d3d21f7fdda85ead65d32d69791e0ab6b3be2b2a3f158a38b2d8a25ca8ceae350e29a573a3e1c28310a92bfd4cccaa5ca4602788c2936196e7b694c31001029e7e9131abc4e57be60c8d60d90dcb73f084ff7735d9b6b40e357f528f934cc700c8d873c4018b91b15293e280528bc1abbc95f361e5aa23a6df9f4c3ff3a5c6be857892e384b0889b5c844f5f0c63a698c04bff8571655ba39c0d6d98bb355d39b4eb75e43715665d93f7d840aac0539d367298834087915c53105f9282082bf20629b93072355d70ab1772d0069349560a1901db72e359a81848280cbeaaa41a6255212fc3c9d2c035f185fb6c3f0a95daac8bbc6b7baeb449199ca6e671f1116ff046fc4d2fe77d654cba12b157f2f217f4c9d24de8e021b95fc4bfea89bda26b27e2dff3956947cd72fe88c34e647c24f80a64f157eb3537a44f4560089e81ce39f4814c7c921a1fa0c5e85666555bdb78b272bde309a023bb70ec66ca3005144d6de55edea7ec7394d1b2eed9087eff331eb5bc5f92efde73c5b1449dfb5f8d822094a12624a6de71d2efba4699d16baf0571eeab785a885669f7a64c1b5cd34d43a2e27d12e5a726b993525c633796837224003c7b3602469c8e509304f21905f743b88340ed228bb1ec4ad54bbeb07e8216d08e31b295c69dc52ef205e8ebf038bed90be5f70c60bcda7782207f3db2650d2154d7d774ee622bc31ae36232a1563d1067b4eb0e46aac2fb174a39c0b066de4ad7ff88b6625f7d7db6823b3c919769223f5971942dd7d3c9ccfa912f38f6096ada99838387799883324dbd265f55e9f8b5d34c3cdc699464517ac47a02a9939a82aa997f3a37696f4fbd9555e4189f787f9f71d3d290864aac4a1cb046a33875f5b32e9096f6969c4948b49ef670d0c8add2dd394568bd98985bc772598d18c3eed9327befa440387134671d89c27a04348f8210988b37304870ae817268ea4b03bdab17d757423f12a239eab66631fbc9b8ab917fb0d2dc0b89ea17114f80e01006014f1608233a4fb1f11c9d1b76e4ec072518d98848fb2373b034060fe6b635dd7af23d1188d3873b11a5eefbc847ab0c8308b41eee2d3bcc5fb3cfffef4a800eeb7a48b65d6991fb630aa53788d49e3abe8faa94d78b2c4f9bbb2769d9501e8c5303be66cb20046b5d82acbe1496501670b2e05439b70e57ac25fb3f018d4d37cb45bf7c42f62aa5e1e221c6b9b28407e6e79f9cf6d1b358d8461b9ffa992b0d40fbb18c5de6aab2aa76e3808fac00e780342c661ad75270afe59adf06d299d15461ef5e081cd4e32aff98ba8f7e200124bb361f1b0116e66e6595819e6eafba9af907db765da91d61dda9a00156948626da81e037589f371aab04fdbe959b4f1fe0d267b311dc59689b8ced5e175a1906f194b21712770f3b31c4ef87a826ae9515df000e88dac119c99004266fc18303621595fb33b04b0b8f6306103924ff5d26540b087aa20df6d04adbb9c265cfb6d23e1de3c43204f48533b6d6a5e7df1827e8f8152c75f7bad60c0c4d3deb6b3de5392798ba377cf6824017190849b04e2e14d774ad42480797d80817db91e36a5f26841809fc418d6695c867d0464db2d4390f4260b4f1bbdde97802cae777bb192f8b093b3ebba2a865458d262b1a1ee4d826bed829bfb52369e4a13307990bffc22269b41963c938b646935bf28b90ab1cb32fb8f5ea03229c8ec4610733b4b09eb5997aecad42b68e119bff37536d9c6fc0e240892d488c8f4e26757f640d94d07fd7a4b49c7042f7aef009a8495af1b9aabaa32b69bfb611c4bb6f53958ee3812cf95c091b0f55220cd3c6d8539e3682de051b36c348243bb6f5636ccb51d3bb4ffdf525e36ca342d7c45c5e112ac40b02af57da520e2ff87c06fd575aa8bd9a2128b9902fe131d9c39a9c7fbf496b50aed58cea85b516ecd60996ff961d073b42bb01ea4b14b6b8608ed3901a7f29302bd825fb74f5054bd1660ecc654e76eaffa4cd88fa28caf6256ec32ceb2c60bc50c1544c0fad34d0a51effc2ed614630e777d126164013d729701fffa0cebd3f6ae55644dc6a0798e2a068fae33840a03f6468b5b22b60db75c6faf8c97e0f069fcbf8fdb60c9cc5879357f0188b68376da4d6a0cdeca36e729a63e0ce5f59de37e3017deb575791c57e9620fb2de96a7d8f21be0a7301939ec61819b8ae52abc17fac40ad022fb06304f71a40d20d7784408a4cfb10636de17817ff6fd862d7ac0bb7c2b640b5751078c4885f4fc28b803ce31b20267443e1251f6f248e0607299a9d912e73a18dda523911c36f840c7fd7064a245478505d30994d090c2291627f44552ce0bbc8a37008de2a018a38a4c55ec085301b5dd89d51ef0981523d72f9697d8158d3d030a48ca9aae08ac397545e443675925f75cf51cda139d3cf07e73397fb8dc520884214c292b43d343258314c471f4068682a463877f12c8581681ae56116198752e6735176004d5934c99e2f84f9072ee8d9d153a340fe80906c95d55a8c9cecc6d502255823e95d971ded6d2d6a1cea2f0496c37e609195b0d0e500bc15228be89f59c4d5599a4c5bc19e816d4f6067aff643c5edafa203832bb50cb18980704e560ad70f57546496b34f2d535c779a2a51596e8c7855c05c0e7cd9a8b916782abc2430131ffc773837f1e26bb650ebb846377daa39324f298956c08ff5cf0fbdf2a3307ce0213b375696e2be34ded5835a6a2d73825f79c92e74add5ab94393066d3821526a7c720e83f80a44abf231a3222f0dc7a4538d2f9141f7d5ca2be517827943108279dbb22385046c5ee71ddf7ea41e16b077016028f0a18f000f821cd83ed20afb1638be0296efb9865c816e6292d4416e165d8f4974c87aa9a1f9a49620494694ffb742a5ebe486c5777243355ccc4d942ee5aa512d80452427b384eb5f8dbfb2a53814d19ac1bb310b8e47e243e615d68d9bb18f33b6c59e6ea4cc0bc61a2a24672f23d9b1430d8953f7be0dba7805714cd2984c13f8a7f55932ecfb1ba008738515170f305854a408f2f25b2780a915575309959024221d8d7d3501a3538b604d2472a73282228eb7ab5f1f23ace15cd85aa28581173b847650731cad92b488f04a9cf1bddb329051e1c411aaca34467f5d1c6105c5cfc059d78f33ea865c8f3787b531c0603bb1c6374ef72adc8106690f86de4806481b7a199ffff55106eadf8e6a2349d3025e9c4d6bacad5b6c569f519f2e85771d601c0014c28c570c17659b9ea605010700789703e086fa669d91ca726bab52998ec221c9bc9bdb144304adff22d3738dd7328b4c19f76c16be3f76833fab29afaa5b0c0b15135d7c3a80421a150c48fa4f65792d9ecd9e14e7cbf07530f0122f58a1159e1bebabdc375861850d77449bbeb5ecdcad20f2b6b6619bb9e57520d187f8eee371a0f01c784d1491746686ce3415520922ff10b49cc4aeabb185a9f41c449129b99c51658acd5ee7418027c7feb40ba420ebbfa2e759895257576d9adae4119ca5949d7ca113a18a1e7aaa4a0f5574b0128fda51ac7f91453424e4550ec0b7f3643fc4f7ac1900803085384deb4e016f21bccc1007cebd66d52ecd217adfcc785d857f162877d41016f197b4e2f916689bc7d4b205625c4d348165d917dbb981816180bc59afeca4184c842973693b6568f36e477a801a8b4e6d6c81710167cffd5929afb761c2101acbf754f7a08583f33dde4978af1af3510046f0db6756684ebe3e1401d81c00e20f3185a863e216efba675453b202d28c62e3491d6eb63c7d37aa10035c85a7517795a330b154c7cb2f6083c136e9fbb25c36e6fb192d8fd5d55c7d99f40dcc6518a419cbe4e4bc143aa301705733a263402ace984fb039ceae69907c022f7219788edf9c91d30281ea6026149c39e2c208d6337e76289c62d7febb1dd5101338d03c489b6adc2a94708a556c6b3558e49ac548eb29cb428c0b584cdbb554f3473f478d86a071e67cb2857ac6331c1a99c89537623d4ade22a5b8bb3f58c066cdd5a78245b54d1b46c5508e9aa5ca480d6c0197c30ef4ec078d86c7c72b9b43f53201f6bcd62b5ab8d7b67b01078e005fb58ddf52c091c11fc63a04db4d4f5ba97598ba81cf668ca917e6bf1b021779ac9acc81b2ff42fb06b2cefd491adb7d616bac7d314212a8966e5c79f95bedf02304968fbb040c76d423533b96402fe7407535ae831ae5cc893342eaa58a7052658c43ccdf677c5b9a0a729ce66716d1e0e7138fd5713c02d3d3aaeaaf2430543c12610caceb5e667c3eefb43e9c4dde55220ecaf3df2d3e55fc660fdfd6d8f4a399394c1fad386e3a30945c406ddb95cce3faa541aa011b4fceddf4f4fa5eb8491ad0598cb7f35dab27f8f5d0179ee5c3ff96d970c92dbd67826be8b92a1012207fd80ccf0df4f7663abe11e21717fb20a130a4b7cc3f2a4ad0909836f3255c844d43e9eec2e91a5683962f89c0b8c5c7818e376b0dad205bdcce83f18f207c2e7fc4ea3f106ce02ae803ceefd8611c8b708b335f8c2fd637200cb678123037135e0f237e6f9f18b04e30947bc0f0ca60895407b3e65dbb7720ab08f8fa46332dfd0e26a4dece89b67229f4a44ce1228e404b179442133e9a6cf90af982dc87c8495ed2f55e69c3641533bb5c644f8dcb161f8373a87f8d90984853151252daf616c94e0576a0df0d7d8c8ac2c6df90eb70af87ba0ce497d35a1b0b9941beaa5f6f17d3866a3bf3eba92347c56e7195483a6b66dc4d504da7b010674f4197340b44bb4cdd871c20502fd1caea9b820fcd47c828afa01021027e538b49239b9a990ef86730c82a4a9372e956c04a92b2ad355c1b423d487c3cbc112a990e72f755b721057880a4690a8d1f92099757ba174d7d887f1d9db36756d051ededd04c9b5b5020f15eeda6e02d5bea38696fc277177cca7dafadfb0184ed207ad0f840e0d27bfa626e48ade790a78f6f0cd5a127e283a93ada77af832706bc1a66d87f73f7f70b26859093f05ca7baa3432cafd5a42981ace66c4bcec1404856bef94b15c0af397bada8e30fed61f41681050cf98c9bafc5f6b94d8e9adc8551a31608eb43ff9754dc6d389eb6c7eec194c6234735aaeb5ed3740c5712e0a2c4d550bbbd3820d8353c12a80089856d01d1f559bb8c3d85d141e571c7351aa84001f802004f06e06e0ee4f9418253194a80cae1f68f3ea80186a35893eac6c32be4dfe0731b4322014d8b666a58081ba67c209afea223cf0750746672e268094cb4b1464c4b47a6b3c00476b645250105717a8ed7b42809e35ba86b264e7fac5d704493bde4bcbea7f7852649929b2eb3f1633f1f9fbf8d7a208dbc9b3ab3dfb9b2449c00afcd03ba03660811f9b6bda0d92003dcef87b32e1856e5d1cabe9568beb8ca647d0d32f9e2b040f0c30ae8ba71c02914658d6b47e31d620e7e85d4c6e32acaa125dce72acaf3c3af1770bf1ec9a2c88cf20ab6be60c9a44b0a092432f54e4d31abd701d5515cad6f30f9a62f20a5b983f39fbc3aa7997b9e60fae514f7ca3a18312f396ea699b7362b25e2132c34c1657adbeed960afbb0aac991742f204aaccd7f80432ad058ac4062b68d5d16e8ff8953dc32adc059dc572baa1b7495a0cab58ea3eb14e0103ad282a56b91ed5d43d6e0f18f175c98e02eda980b864ce32368c60381a9912a4494a376d874de059734e878e1fe264c61451161c4d303c98339c530d2a5329245ee2f081964883cfe76601fecbd0e9cb22033e74cadb3dc5857a37c64b5e01c1d6f809f810563b38d000c7557613475297eafb8e2587192fb9cb048869ac64a48737d4971363c80a054806df784cc5ef30e083e9ac6eb8c1701b08495a832340270a4b604a9f2deedeadbf50a16f12aa03dfb2d8009028f3e9baf68732fc24a95b65feb3fd0c25e7b52b021a50c85c02830f7dd0729bfcb440fa7a471cd5ed864487bd068a0a766b5e15305934d2ab6caa449ebee6c51869a064dcdd418306763257289ca32e0a7be9a93e866f388cbd85fadb7d68f55e346b6f7fd5837b3a71ac6e245b39c1f1bf48b0937dcc0045d32a2c8f9ce0f4a29deccffb65d35af6994a24b743137efda26c028afc0482ca9034ef0005a8ba5ec7c450f486b84c65deab89d00acbcaffd3191026b01017b56bad2969c35f79fab7d7e6e555015ea9872557a551cf7636fa579cbaa67e1867991c93db45ec52ed559819a3701d6daf9c104dff2647451dcbdd51ce1f837a86dce8a7e6708abce62b85fd8d8130c8834c7446c571139b3df6a375b97a55556f7199c74787303703de9ceafc1880179a61a075f80761836b98ae5502c1dc9d860a244328d1a33229c3fd7b61fea92b8bac334cd36b971071f38aa87670dd178417e4ef29bab34e4a22685f57e1cb12c899605bef84494cb058b1458fd683b86517dfc6e142c603e48c6cdfe3813a65b8c8fec9fe86a0a80a20deeca116178e5ae71cbf4226aadb7098aa9a87265437d62583528de7ffb1d26c887e855de6befacfa6ad6ba55b26dd1dd27c238589144a2080d8a1dfb3979aa1c8e0e1691ad3911ba66b1ff705856e0d451f8720d2b05964fc6a11509ca76b3060107cadcb45fa3785c418348321caf7470dd5e52f756d89ef4642e241e06cc8626af2d0db5da0d76ba074c59a0f8496f45a1d55b61dc9abe52e250a34f6ec79cf353998e712c62e9e7782c24b68676813113269263bd5a36801f88c39dde6f7dfef6ea4c3972c4958fb0fe63b268dff39f7b3df2481ea4acf1bb5db76fba5c4981b7eab77db2c23de2b11e2ead7db601cd1b6f5e86b5e6c37418763555bc8458eff7e802b18335c72ce12fff68ee581e3e230af6a56bc0c9dc99921ebcbd1674bee1b902237f9ab70edb6b655e82cd7cba88b8e2849e2f15dd206721ad142984f65ef13f3f143e5d95c25e37c4672f3efd4393c0f26b5280dc330e74a704fd6421505f65a923a4b21c40668102f7b15dcd0f82938fad13c4747c591a3ee84725634186877219dbdebbbcb83b98118a4640fe93305b571e7e912112e63e1aab96867e438c612ff5b32b828b09dddc147db76cffe1dc8b6542d388948222c1956118a203456e37ba6178300fbf711de38c758531b004a227f1fdab53a826adf3e6329dbc6cc72f3ae57e566c502fce9aaaf7d8bd42dcbbcded253e6478429bf846db7c0185e590d391a1da5eadfcadfec21aabbbe9c8e97706c6eced6f8b1960f41e6086baa9c2f4385195b124df5825dab2e57afce2ce59628ef6df2f5c644de08071db5a1ffb3d061c3ba083c4c874bd9d040c87dce6d7039550afd7ba98da24f7fd96a07f44040639452d1e8407272a137c28233a650706cd554d37c5f44466dde0777c801ca7af1b3e29d38e2b32321cdf8f26d269a8c1dac3f5e95f0393d2fd0c1911bfcce84da0112d556df7b06748c14c66b1b2910840991a75184b669b0a83bbd65a4267d8cd65400e4adc7ec4c706a478ed4d5a7923e8bf68941a6f397b914aa2137daaf543c73f8415329a5277aa90f6a632d1bb41ba4a9da1bf741b9e640dea902c906f510af80843fb59f17dc8dee8f27c4b255c0338ae75918311eab7100518f536fc3f1927bb56e3b186a9526748c61f7cd768fa1ad1e4376c6dd8ae91391a8a7671ec8b446b47d8d92a27ae5aca8d20368870a731aa411a2ae493fd133ddfb2a2ddcee5a8b6ac3665a6fee0c64124f07339b24d4ae9ddcf0f46ec28c636ac7fa209fa4c8cfac5c4c0171df05e4d8c69b8516816b0df2b05862471f65a7612da344c479270a78cbbb54d6f496a2333024b818b0d21910658e6aad69ab2c816a8d9af76b2576b1447f613039a5757d131b2bfc37351642e3ae6a2b8b262d4160225f937190bc7bd8b774edd8eb2d12108597a1e5cb05213fdb0cf0e1458f16c74c71105ad80a14ed1680dad776e6213c2f7a65cfdca20cb7517802c7d30d25ced7df83a0dbce5212f427989db4edad7622bd731d9d74b62a318858e0586547395d772f5f7d0ab376bd6839b9c15be9c111181d0d5c3cd460a0d1273bbb818d07bb0ed2a9dba9cb59b0e839bc040bed2809aca1b069a83dfe6da1b1b800bce62747dd66a3d270991335d0a80f1fc555a6c52b458369db029071183296ed98990f888ae7240bf8ba8609111b01f64dd4c7f9df805b81a58abb8ef49be421820093b54efa715f42dafa6e71a205c7252caf80b72d2ae51c0c017d40218932150304b2bd548e4bb009aa5a968d182f9d4702f4141208695d230ae6f4c8f7cc28698d3b0672acf0df2c36e57500429b460cc89eec2846e14ccbb2c2d569121dbd8fac0f8f291c02e152e0f51889b02e88b8469ef16e37354f3f63fd038696aeb8ae5574334845ee23ab2ec48cd066aabfee7ba85ce307242abf794d2128608510bc60a4774da2c9074ca44623460ed6da1c958aa10a88deba50b1df4d783618d2a30186845edb4d44a24cf3aee719f0db34cba41ad30430db935c2f30d276f11e35b47b6315e82534d07f8b1696cfba72581e5fa3cba2e7befa8c8350d68315c7f758d87da0ca0bae484b910babc2f0153255da145dee6546d8431fe487998facc1e8a18b4b2017c0f8a993b08a4f853d645cfdd7f12294f6e65057717656971d2bdaf8846350e6a7b4db5565bb91a6f13eb8421f1bcdaba61f5da99fef77b9b8b6ab5dfdb0a1fcbd2624146e6c54efe99002a7d1ccef3a6a049aa79b3ac7a082c9a9f6702df0e8f1fd1c3e0907d13ca2d5c9943be4b5465b0a5922f69f1514bea4cee8368afdb09264d20a92b4b0d54a917b8554efaf87062f2e7c1441b8a6a44eea9fb61fa5d28b2dd1fd20e88281f1ff52d248786693efa499ebd7464b3738aced1f499222af7caebdc4e21c5893461621afffc7edb52f2f928747875a10593dc114836349b219122553d8acb0eccbb105349265538ff196a8cfe7293dfa81ba58ca7b7979ee3300d90c5393ac4a82c6276c57f930346deb7721b993b1bae09e47cd6272867e5b236920ac3efb9b9d6b41e29ec033a586071e5e53cb11e1a8293e1b49673624225597c49a63755c2f53f95e7c5d0857afb31ad163362c4f8535e2b2df837d64c0b6adaf017851baa167877f63733b6715993e3105d6b1a8f6202388fd5d6ce021ed6bd30f7c2145977e786dbbe968e032ee5929e65bb5f1f17ecbba8a587c29d69fe430780d30434db3f205e13022675a75dbb582c0ec8bbf00b37e157934cd16864af98080ce4789b24c40dde2d45692e51726f42e5f5c406deaf27b33c2e268dc7ae03f8d466f5a6043b814fe0a23cc85b7f6e69b6750e3b9352b34e78471f628ddee680be61a2cb8b371d324451181e54b00468eb1edd149feb6bd8b65621b6908b9d90dd1d76da5d212bb6afd6094a2398b2c54f41650082aa65511cbc89f8dd6b8ba81a187e288d75f120fc6581583d6502bb0b22bfa99cd1ee45bf31a3b9039587081cf28a91496152901d9fc965c954cc71dba5c4dafee67f7c0b2b62a1d7616999b27bcea58bcbbd55d7956ba41793854e4d2c59b51d6a9114142edcbe9a6e95cd0a1733b4c2ef80dfbe56c5e92d516edc68646f89ef271cd3667e0c3278c8f968e8020bbe7f51b65fe82cba0ba3104c48716d03d3975ff1046e6644b528c89f10624c1f99b4cc2936f268cb7defa05d49f15d5a82946c98a634d9004a315d50364ad980915a758b35ce3e91962e96199ede91d2cddd212f2f3b1efa465e0ed0626a5fea7652b4fd2aaec1183db649ee9504d5cc415a0f92aeac9a4afc1288341d8cf74a711984beb31a82fb605cbe77599fac0c08ab17929c6367ac54c9c547385518ce3a20ac03f700d97b38167f15e8011d92526a9d6391a57e297222d6a00a9be584d59ee91449bea91c52a80087942c66ef1ac5bbe7f38a3060b444552cc58a6b92fe4dc679542f84061ab27264ede6aafbfcbfc1d506da2b43970db032dafc7056419c003e7614b154482077ca1ddc54a0a446a8116a70f0c6c241ce2b43567bd8416fd29471544ae581740ce95a52983ec0963aa073755b73f0e5c12d796b05c6a7542d9e4e4d092fb8ee0dc89a8f5465a43e0a92c927bb32d16bd6055d2e2abe860eb4bbd652ef090dfbc52ec9fb3e86a069ea63fe3390ffba165177cb3768e7bc5e45d0b86b0aac27d6660426af993da77b80794d1532c1e20d8c52e89fdc370f8f1b087ab689df216285ad668f1a39985fdb8dae8e226e54ad723ac96f8fc4a731e0c4116c93fb97c2857ee985a8f60bfadbd82bf2b1d97387c0cfaba64beac91e72d525beff87935115581ab9afd1812f1e61b46d99ab2e9016caa2b6b11a6959d1212e80aadc5c1210bfca8c00d8ed767012d4cf8101a2b4654e10cac7342fee7fd869e8fc83ab7ae0caf55189511f266375b4aa66227e9f3b1f0fd37cf9ec2cd64d27e4c4eab78490d0cbd03ff96237872959b6b64e2893c80512470794b1855e63b1077d40bf835c93b11675d24ad6396a5327321c19543d11bec71cbb802aabfc55b9d09c7d83fca03ee3af414fda88a4eeaccbb3f4717e9aa7d07a0d19f38bfb3ef445c3f6a5d0c1d9d89a2caf7812fc36d1b1e10bc5a3a5435af6e2087c34e770c1d73fabc8f0fa908aa4e487a8d2f11887952008622ab8b8d9db8d981829c54e1a5de3eb3766d0f5955ab74aa2486067cc75f11b74d400329c23c07210bb1bbc39204f83c445de9875f9dcf94e0415271b5925eb32813035122555500f78f0c4a108d7e0a1b119c278920e1f3ba344c1fe250e56a577710377b4d08dbd7dc3491f4c3414bb9fc995fcbd34d7b408f36f3b10d8af513d3a85a62428f949586babd70c15b0630afe1db956d05ec8fd7ee4d4250df08ddf254e1c27ca192accafad9bf4c9301b62b7fab614d0667351334c92a6bf8d2db855b9d2031d371059e1569b4e3df408b4e5613642a6ed26e65c7aec3c2a86cb2533e29e80c08a3d03d0e653c927032393602a02797119d62c678870a7a13b6420bda1889804c73e930f65179fe8023f3fb1661e64d9e5479e247f7c123e9666c19e89b634c322d4d1b3fcc45c61c4b4574822967601096a83d870ac9ef98e82cec79c008de2e0b9c7afc95e86b226dfa81932ba175268f0d7e390951e40af0b057beeeb756f7983496ddf18228bef4b3a8549f943e88946ba49381da02aa1bd67d0d737194cf1dfbb93e36b5ed54887dbf908a353b65092afdda2d4021b575f5ea1d4f9cdd6e968a96ac3dd6a442343d90b1a28ba19d955bcfe338f40f59e53812f5be502e2a082e501c3a356200b47e7f0575bea4bdae77a9e385ea9c2b71817fb942971cd659b2c3b0f80b0342c7c3bba06adc8d75caa5d44209a8bfc55000053d43868041d71065ca61939017c00d16f9398704c052eba7e4869d72369334f29fc432587c5608ddb47bf5e6c08c3ce58bb1257b12973a89b3640110accf4f26a7fd0ae57ac5db02b7709a27f811117bb33669f1139e2043ac9d1286f288cae9696a75522e8f4177ff0b7456f6170892c7865a92ad49af6a85d11ad4bf6cee3d3e80c7388eb3666ebf4997812fe14e795f7515979f5f1ba3de1592c79288408862985bfe5c33a360dc963397a809ebdb21c20d9b681dec0590f8d98ed8d959ef9fc95de6adf19ba01d9049128f3f9f0e087f4c68d201c36b8aea07a3c7577aab068f79f64cd709551beb2165a277d2a2dbf89e653e512f0f4d905c6a5ec25242e220cf838f5382262481b6b298e32438221effd31cf0a49688e574e65e8c081fbf6a680fef754cd9135a16a4f932d23b9524dcb4831b9fc01e52c454a451759a82e776faea3a6f81cfb8373859bef442ed3dea358bafea3501b6b72a0b2886ab83a210b5378bd9563a7908d4d33622dc3e026d79e58f16a22bb7d46adc2a982cede2fcf5ce5ce7c5ab567c4b60d646a762345473296141bf0833e797eefe35713af32669b1cf9617f75c785300e2a092645bb62f23887c13089796a40954bae6426e1898b3c683bf623cc6ccc138445c5c52d1166cec802b0b6b51d52163e6d0c55989cda9f8d68270f9924a52e197cd38c0bba515d2a69a2002162dafbb5258a61581e9cda65163040cf55f7aff0117d6c2587ff5b3fa9660d53cd50b8880ee0ed3153ae91c591e6cc5d16243c1e06d45e827b377e988ad5d617af7f3f2686acf249ec0e5790615d0079dec7f9339106d3fc44463cac394108fc86c83fba3b85fa4c78aadf5b4d9ac8eb78d0c7291239e65a784091e77eaae8ba450a0a17daebee902daf1d1e460c992f8e5624583c8c651a130c14c188c585cdde36c00442dc29f50e5d3e0e88f6729336366920956986592ffc25e42d4fdd76fa9ef2b8475ec56471226869ee8be0e6bb0624db6c7808647cc9bd88740bfa19d9cd43c061ba4139afb3e22d814d546f9e82d338119bb9875a19294c034e881ab51a072e2888fe8f7a911a0f5dcd830bf4d6edec76b0ae66524519092b7ebda85eb38b432247f3874bfc0023f6c0876dd1476d29ea17c71804a813e80544fd0a3755dc2e37e8d951c8cf95d65192fc80bd21441814bfc249bc4d8802e361d36b86184da2697f3856c3dc4f0b86f1fcb8a33ba285d0a3acef6a23b7074aed1ed15a967d94339086ecdf896a7318f7fb32b864631b18d5761e2fdb6c79a1fb5c043d70de28d5f0e69dd533afac3b3d2d9cfbcdebb309b46388d649d0ed32d30d3dfc918eda088fa39f84c5694b88b6655ece8980b654ec3d47c0a0ec7b7797c0614011f7cf57f9c46cd8d2e90d9125404f92b9dbb36bd3d9f6a3abe9edd2a62e0e595a2fee7a2f67a344090120056b3023ae6a6991d7d20ffb0f38d673498f4cc5cf022c7565a716845f054fbf1573a6a733f54c324376112fc507c329feb837c31f671bd5ef970c28519b66b9fe09e83a5110bc14c031cdfbd4e39ff38a552342f369220e9cdd623f4143b3a4caa2b2a87c499f3fee9744d5d2cc85171825d988dc5bac0b26d8e7f43c25378d8827053bd88b5f06efa3854b530963439d108d92d87088a853e0a63b9743b495fa2d4ef797dd9f2cc3e6c1641d40f112b2d020c13da59676a122afbf6b6d50355ba901ed3384d743202178c557deca94dd20aa16223155b93e7a59eaa0416b6dc4ac8cacb3d39d1c28bb6b73638628266a42753149e3c30ab7f33b01daecd2bbf566f8aaf5a35892c3c9de83f20b90284115ad4f46b9913d9985f1e76757abd9e9c288cf1e45364a6d2623c0a04d031ed2017393f9f34923d5e79a5714ad7cb7404e3fa0a90ac881ee08f39967e6a5da7866d6b2075c293eebe7f4fcfc80c22599d12bc15f574955d7f49e75234d2dfc0536849a19d6f419eafd336789679cb96fb57ac9a6698539694b197593403daae72c162baad2a1988df8343b146402ae6e2a5f30e544cf5511fcf075ae834741acf68cd298ab3a07e7d8b53f040c677542af1221e261de84cd62d6c0956db0d92ef7830ccdc7928124ed20488644300a99f7f0cbf41513a84178b710afd5b47102ca794a3b267a01623308ae01d60f124d88c8af3695bbe8637250fe46f53ebf359ab6e501aaea643d3d597babc437b243ad1bed7c096d2b6e2f0308708c0dead206f7d6092974f0c23d10966b4dc501a03dfe0e842dd0d2418d35dfa0b7237ec43698110e8329a6b2777711535eb53dc2677383c901724df564a01939bdd9456b93aca7c0eb6117341533a9335a10e2d587c11d9916d7c4890c1537a439fbee851b0824b1f523bbff93b580126677f6ce02a9a5034fc9341b8fdc790f9ca2a24820ecffdd7f6036e4cb06bc0301a0f264d46e84621649ad65c7f24917f6dfead5d9385362a829d54c14829e16d559547f288d5a59081f4c9c6f511af5e94804f10d1fa4690ace573b82f10726297953db7c7d38523658c9d4546548acea36cc8d11238a88d8501462131b9d0010cbe488048b0f83d203107bad3d777c587608b6173c8c1d58dc88dcd2069ecd981f87cd9498196c40940ddb85601c467ddda3cd0ff014c7f779cdea0f039f28d37821ce4db6669195cf5f28741341cfdd84718b4d573dc633c42030ff1e7b8d11837ef70b52fa62d2b3c6a8df64e0cbddd91e5ca87173c32a531eb6a6215f9ac61d48bfda398750ff039ce903561f62ee75e1410b8c884f889bfd4ead3621b1dca902637cf3b4d54800eb58155c8869b7a5e1ac823c3ac40a191c894253979d0a7140ecde4f6c412ae707fdf858ca6c6de95db80205d1946460242d8887b9219c6eb1d67d94589dae015e2cf4f4709b5c0317b9513044a389110d22f70840aca7c8c6fbc81846e2a486b27304e1504033e9805bc41194f1b04a56cddaac691f9d612a6c95ab3d2b7dc4f25df31f5aa9349fae70ce2226f121556872a1c1c6333ce81a47de02dc5adf68e2973399991810d14dbdc2fbc6c022921383df5c03ad371fbd00b9bbb7e1ca6c63bb9205aef492813f654c2fe128c1e98c3c2843400218efcd34adce90f64614e752556d77eca1c9232ed2d7cadb928e330c1ed0f88ed9834ad62de3bd00eadc32e5b79aae44e1331b15ac08356eedf0e8e6132e820b28990b837246cb03f54e073feeda6a8ec4f9ecdbdae07921c6f0b06edb399f77895b33c843d434a86d538e0e8e37700c88110fd54dc2fc82c686866cd1c29ed427050751b2966acb056818da3e79b84c4e37b1779da3a101f812af231f792285c789f087941431225bfaa2512af3f4121791b987a83c5c46d2cea321ae16813056e4ffb6c9c6c346d79f5e9b9a7fa70368af5a7ce4f6b3feafa57d1e61684634e07221012e4a03787c7f8f3da6d3107bcf03eeaa47fa8d6b09b2e7549644bad5974b374dcc1da11221f81c22f9343cd58e43f229a3b188163606d4a0fe1826f6eb66d1b6d8a3ecb8e3c434d419af53681c842521ef7f29a3660489543b66d80a1370600e2ad5316f7d3278d376ed39d377a076e01b9e95d65da55c2cadd3a2b6a3ff7d40a3cb14545d08550b967e48da7a903fa632b90b5667ce5048ecf42957ab53b8b712f0dd68004351e2c5d89bbfc2261bbf76795d1388b034514ad4a335a4dfbc17b9f736232a470d5d6b9957d9f7abafc020523c74bdafa9b82f2d48554d56db16a04d0b26938d2d3d13e34cc3a1dcd9a0f138f7471973e050bbe26f6813ae1fed03ef91daea1cab3490a37d432f1af4dfa4304d1131ff4f30cacf53153142f348f7b51a2fc83e58279f0e8603393321d86b97ffa7cf21c8a1d198bb9a8ee3b51c65e4a4e0ab69b62f084410f38d9039920556751fe3391bf6560e2acb3151700311331b02fa54e44bfd4ba103afe621cf8fd1fa83d8c30184a15f6ad48fa9c29059867fbd5caf143a40282e1d819bf3c371bf31f62df1d80d9fbbc5cfb4a18db255c51b6d55a912bb0465a175c291ab13f838789ba549214caca259192ea38bffe43c84a87e4cd5d6498ae94ee3a0f99656d3a825b7172e9bb28150ccedecb77aca715c441b45772fe2ce4e7635ee4c8258274f3eaa94c482d097232a66b7611c8efbd80e5fa315218ab857ff5ae03ff33976c4ff92f1c4cebe43e993f7a5a9b8b2a132e1fda7dec957b3b9e98d36911829909a284ed6ef1240e02171b323e922212c78cf84ccd2453b092e928c9a04c22f7825300f5345c3dce8e5967856b084b851921a6257a68d933b101b9cd135fb12a159c190dd0a212960e72c8a0fe64bbe958025dd845d296a509a760702692575aad8f0bcdcd9eeb7c83c5557b134d999cf01ad47c7c1cd1ac7406af0a44d5fbdb9eda198aef9c41e77061506445e4813239e41dee6cadccaa221fc66f6ad87cb421821fbc9172d04793c0c2e044ec1be5d81e006e2016ce7339022b7d52b37b36e1e648a02f4400902e9d8ca229565d9d3ac04c1dd6a8d4368f302b789915aef24b76d1859947b9a551be34ef9b4386ecd5cba2712d3f4a9afb50bd2f2575a8d98e75b065c8e29328d89a1fc74f2aa6174ddb527eeed80e5fe83475d9a78fa525901e582a05e88f8ffb558438e32d68a341de6e95e6944d10ff97abf89cc5c4d4abb6a55898b09a9c46810b54548556ba7296aa31a80e5c4e2cec5dc58b0c8edfef3e41541b79bb844ca925901533c7c0ab303f9ca371879cb68ed6fb9b900476dfc175be1803f14848ebd88d6af69bfe28be8d0da3896e07d8b8d89f40f348b5ebf010698e92d44d4c2976962d9b576fe6f9bff1ba382a4a3da6a85c7f087df812800e3939c26b4c44de3a2bb4d0d5e5e6c5c09d76524318c2116037afd338985499b26049e7eab7853d6a773c3ebea01f73d010159351c9a303e11c1d5bb9970f18c4ff54d4b690a7107664d73770cf628b8606d13ebd6e4fe80549fd336e5c6808033a8e60d693f5dd3a339fb38a39654188a539d984cbee76662ed9d5d28a5f1a9a28120487f888d825f7c3541851a6220a2eb06c7380cb6733978ea5e41f0ce2abed93029a376c66fa7eeefa056d6f2fa00f025be678e5b4a25ecbbbef826495f01101205991592a7fb231f5e0726c00a4b618206d9a14843f4c30473b4e091d92f41f05ecc1269559fe17fa2bd7b881791513551312b058be92b229f7454c153776162f92579b10ca2b35ef37dc95e504b6d92a235462325f312a95953174a3c4bf8a9599ed4f44f49dafb0fbc49a3b2330b5db7588a792ec00d68677addcebf77680831cc74302c40f2b0268144b5f1970ab4839cf8d466ab3ab00547a45e1eb272519ce0a613866863b69f3e5d9f7b79eb9313dc04a09462c354c2845fad52e5406cc412b77a32c071caac2c8032840a4dac3fd01a6b4133c16e438ecf28812432b51ba02a939892bc84c087b54be99705e77a344021f2b70964c2dd445120323c85b4a2a16334c682fcb0869ac0503cced5b51fbc5abba6b528ab0bf139685f9b09f313c0e9db38cb3955d49eb5d72885d694d8ddd9e42531c6f11297e1f15ee92be370a967092a09eac04759681d0eae33e5043cdf7d2d4129f9c9fbb227270c4ad69db3b3e119002a3726783f273bc1abbcd469278ada4c7ff8acbc5a839aa52a33a8223b3a03bc80eda648a6584a220e504d435a9c014f2ec135faf78cbc7f488b532a868baa0f4536bd4323e7e27c1951e72c65d2b8563c311b676f7c2f7c6eeefa176085a6f08b62e03a23c131739e87bb9dac05c0448093a22dcb491b8389fe4c6c962ff8843ad0e76baa23a6ad6aaf29048e3174d3f71b5e1109852cce9b92a8c0b34a065d5b761f9baa13b335e95e8927483c95c7ae2baf97f59dd50d397c6714e0a5f1e3cfe4544057ede6ee94bd4e21b483ea50917d1aee469701008d0baade1b55e707eab23e929cce9f730ec14831c9be24dc7e071839714ea095568881caa5dadd42a370032a289fc0094731ba4946d479788ecfaaee55b4cd3466a5b4b2446b04a30d5a5503e8523d958afbd1ed1fc70f487a579d11d0816073daeaeddcf85cdb54b54f177e1bf3ddec7075ca8ef32f9735cf82658a145586bcda4a06ae26d61b84a59a0baec5ac897dc5663c81b3b54976e73c92d07f26fc98c78c733eabafb9559e843598ad76cbea68336c70786cdd7e7e0d680e7d9e73caaabc8b4f8d35dc60a19dff7373017d59b4106c569a2839c7b7b274308711c58e658dfc9ca9756cdff2c1716010df4eca49e2d1c2c7fa17ea110a979d7d046788ff86f57ee164fa2491787dd64a5e13a745eb60638c20017e013e04f3572fcd247b0d71abbea295dc36134b4c238b963a08b00e1a690a8374bb12be81ab11026a27aaeb533d117223a35d4ae0467a7dbbd0d5830d6917290a5870e6dc46f9d9398b5173b4dfecaef3bf7ec096ac4253961925d592ed75d9579b574a129bd1025492c08aa835ae96cbb461271215ad48cf5b208816e7cd0c847473feecf1d419cb6bba5d77fa4225a20288f5274846ae94f5987bdced38d756bd8c396fb245a9e2b4c1326cce16a120d8c30d3b086a2e8e6245a358ffdee715c32baff63fa01a32659414a0e24f2db0e2afaec89365f7c45e22b662f31240e7969723e008876479cada45ae650743cb4411d80eb74ade9202275304e624eb0fb12fa93f1586f671633907e4b713d4c05b5f2b1e70454916e45d71ac2cd380764527240489901ee3a00cea6088faa2c5c9a799ba93adc666e41ca3ab4839a53321a33195854748128a1596b4982f223b41f48d514b6a484eb9bfa92d5af769bed16671f625442b5b0f289d39e8449cbd8bf01226429c5f4407af4a07e75618135067374d6e9a2b37e064ed786e6c7dc20cd45bb73b95b794250689e8a557168277439e4bba35c842c1ede78a1f7944d74f4ff9ae151b6051612891b53a3d9f224672f8744d6d09f81d5308fb7ff59654588084f44158214eca054eedab94d6930b15f1452c727c5868f14e02c9d9945ac048439c393af89ab61a422ba67e4d8c07326c463a2c5712ed5caf34420296a3749ebc694fbff47f69753195e2489d98261da76dab7831f5e660aa1e21961104954140165593b5b0b6ec9525a337ac3d0722d0252cb0b1c9b958a0edff3471ef0d509ecb6ad68d5e602a17b00ea99fc3057236d18676cbb8bc5b6988a8d213d1d31634f94a952510fb1ee1b66ea3117cf65463fa42b44b96d303829acfb26b791b30780b87c1c7cbca3afcb97f18adf3176b79f003933d671d5cd48d57f049d8759b5475a5805373d53b003bd004790bb1a6403ac35a6fde7e9aa250ac2dcbb0f9872181ca2f6f1c11070a53a37cb88e2c4ceef08b0dcead10ed26f90dc3594b7d2b1089c4caad77fb6c505c9a141dabac72e3ca17234e5567c08f86138fd871a104dcc34b0bbae329470851487f16acba4b6da1f4f19e239a6d68dd7c7819706a2aa67e77a778db72d911a77801c443b404e6e7a1e91664bbfce3ea8562cc8ffce7700244308983df19e007043dd66d86cebf257cba8227f0993ae355c4c6a1e0dbd5552350495524e5bf594fa653073ca5a38b4ad6e20d5e1f4a4b44d54b95582d74da101c06625259ffc2020662b1738dde95a6c67301f8d887c32793101f74408a92a83c199492de55223dfca478067406586faf309c2ac2a15c450fb60265b27fb83df96ced792663d61f8eebfbf827e939bd0031499083c8e5274b13e6ace4991cf85dbd35621fe46219477bc996b6dd7163c85cd84c8f05ae9c7604e19a8b2cda641afe1a20db79a5b2d2c937c9f31686694670805cbd7f4251f99568fc1b9afbc6ca0fa401221a5e3bab4365240d75b84f64be0195a44da6d2e0ffb1cfa8416ddd994e15307f86225c777d8257ae54bde5e6c5ff8b89ef5e225f4b6c7f4c3bb50851cda62154d0081d34b91344ac33d72b0faeb2605e8bcb69a9135cafade1a1c540ac9e10193e95de6d58591a202918c7044bbf0bc59186736553289cb3397189df8a1b09dcab9378de24dd0434d46b2261e76f2173112026dde1483186ef7268294e8b91e649b36e83f3c92570b334e662233c272b9284a6c9a0da34bb670ab02f519863a3b50f874eb95648b740397870bcdce75b0d66e7d9ab763b04ef06cf5434c1b02c54c51e83a41d7cb7a9d1d3c516cff1fd371737211128e46a2a865fe1ed3aac76d689d9cf22711e879b8d76f1b889f61aa1df3b03dae0c35d49ce3027182ed32ff993444c8f63e4f4a8065c91ab8b0944e24e74cd1f1a244a05068b5a43b1497df6ebcc3a59956cd10b903fa5620b949dae2a184dd589154ac609f1aa9ef3fd0c3e687556e6c943a1975df244d8786240c59a2e490d50aa785bb0eb33545ad00aef11fc1db7b1a674874b5f89dda6e307a6eaac1cbe471c6dc279745dba6e8a982ad94f5e26ee00542ac96cded164bbc9b3539e4343606f84d19a41f76a3ad681a343eb32f7a67978a496b15f4914625ae662a173d536ee6f8a7ba9347d1131d7b96a3caa44533f5038ea67e9993a874bae31966bfbc794a1f35b9efc249a6076e639bee04c1ae6234f66cc53342b9c5983ec68e165797054adb636ae71c6ab6973b63997012747b504ee426a46230710528245f271b0b4b120e46e731cb9f978abf4be721391d0915c46a302ddf7b61c23fe34e0b7988840c8b06b22ae586443a2623be6a79cc08940bf004ef733a5b7a559fc8128986c71170c5e461334b812d87dc9ef3c46bc0bd667a144bc0dd7c26522db94ff204d942a10408f3107b8d3478f51018d0d7afad1116121361260f785beb5185b3a4a91fccd66e982ca89b438865f0d60913eeeb9df77b36e3e79738ea1517c888b6dd26d8fdecd1153dc527187c9a98d984552102752e695bc2c5ae18fe5ce73dc0f050e0d2db7c69fcc8c30b878821a3d9df2a4214869075ad75c1f6e5e0ba980e07f91e53ce10a5e8c18fba754a722f28a369765561456974c0dca108bb1f420f833acf526301b018564d33e1aede0335b000757192324e7df4f80e4c11e5b8d806e2040425b926c26f9be6b1e0ef5dfc70bd993339bd39033abca0237dbe6b2073d7327f314883b052f3831052c2626ed92561d50b1be74c5c423ea7df697540c6ed4e6f2737870ad91d6c80554a17ad37ab9727dbdb821662bfd23a2f8c3e8687e299c8a7125a75db559d9b4518a2b1003186fcd9838303260186ab2b0e44b35de5c8354a68ea69d174b7c33c10f3879709c5fee8c1dc22f6b0c07527011b0cbf6c4352b391f162e8c7424be55e855b27d3ff613db56e85525af830dd0233d1312a63e52be6f8946afc365f9e6903b23bee323535c3321f4124a404496318f6a1f94230d8452456d53ed43f322d04928d02ac565e5d5481699de8b7efa0ff5d9718a89e64d14f05716e3819b67ff4bc5548cd8d8ea9a94c313cd733c803f15c1bd8ae962af3a4d5c491f590f2b3b0ba26c925e48b1b9bcf8e7ca281091b0f5d9ad2f45b655a2e5ae9739edb51658c7a7cc788fda2c833646811f9fcb2792b89de42156a3c34c07a808879bf0abbd9b08343b8e08adee2a3795d5f24196e719dee7b220dca49eac557a741b2bf9512b46e665ae7061f0c9f4421f8ef5d9ffd215ccbd837fa15ac05195b6ee4699740a5d835912aa1d8ca58246b465e9462ba9de0f9fd555288f8e61863697560a366fb0d694f1a03c78ec79130a2bed12f4deb851f40d4eb27fd5c69b885484e8243138a5279c4547084ca1d9f1c6b56ca0d4e4e3c0b616485bd8fe6e5b8c237f8676ece24102ae885238456e04d8cf72437ec20acc47b707dd0d1c8338ddccce6a67f1e135eacb57e4515deac7cb2705b1352a16bbc9de10c2a059f1ac7a2156ae841cb41f6f0ed1af73cd166daba0c5d5fa8382a8fc877b746478b2564aae4ce2a998b097bc527b44b00ee4bbfa0a14c7b807adb4d31f070594c494fe1404537c644290abf3174fae852800e6502c6c04a0d00cdecb84e291c225fa40ddffd53f28bbf2bde3015acc0a03b4e6636ade4f4ed88909ec9f51b2c1028dc74fe40664a989f69b774ed56388b6cf2d7a3f5b657dc816b08766bc3c21724284400931a7a1d8fce0fb947cb0935985338ae90ba30e407b2bd5f5e85751f6be259a01b3fe64bfac0f2f96e92898496c51af5580638e45890a8b17957278a474adaf90835c9bbca65c39d6a5677425eebcbbf7d32c5eecc1c495440f1abaf550ab0347431c9b24ddf0f50ce24a2af3d964039cf782a7bb6ab822b85d6587576596251728953d92f6843d14c207528386942df47109f9d0a405a392e427f1f34b93d83490048db38bb81766e35cdccf2fb903cef71e4c9228559dd1aac0de7fd7658409169c468d382eeb512f87d7bd8e50015f74f207b1044e89644b87db3e0097a7ce2436cf90de5f043157bc942683d0f66c535623ff162b3ce598af3943f27d1114f9e67a466c5a08bea0d97c2cda582aee94e3f8a7f7c4802b7df4fa798b0da5b8378b03cb1927acd376467d1e78b860096683a713e7d3cd8416fda734ece30b6dd376644f1ce3f4dc0f77eba11b913ffcd52335d61891c368ce76e63454937007b63a96ac57e330687ddd2ae8a9fcaa6014849e70e9c0f981447e28d08eebac4c3b5838af4a321a535911f6c539b109705c06b051edcf5c4203a3c628891e741ec7285163099f07f471b47588adf898aba0b7189b80f525841d9f3e1093824b4372fbe738316a43342829b7b1e7374978610bba6d961b3ba4a74d5a504284693bc9d1ebb69854370d0b3a8771bc71dc02077982b8bb03338f600a3d2ebd98a57bf3d46ee7225c618f7ca9071c6a958740202610ea0282252df5d2c62a6651640c83fa8e37691165b359a786ec6858480678b62b8ab6f3431fe743cb023d9b1b8223acd86b169a164e2a62e3626b780cefe4a4088432df4a244be431ae422f1d586faa7bd221433e88866ce7aa7b42a71cb263301a120691d4b5ffcdfb6b8e3209762b3edff6286823aebc5451670792aaff5247b313378042c427aa37816efa2a06a0424f27254ac85ce13a04cc641403b8da44ae5ffabd82e7dcc195fc8ca23cb085482957119db777e14c787d28f82d83b243518e0dbe28ffa5eef745405e37b4973bb43c563124854b494ef58af000c2c182fd76f58a8743bd360478432d4b0ee97ce1c581aa660ff111e65f390cdee20420d8fa4d8d692076167e6b2ef772695fde4c3fd420b94ec04761bb129598ee707397da0518c054ce178a646ce0e9db289fc301f2b432acf1e1cc9ef5eb56448f598c72586fbf008c08e07fb047bb70de34e85f5dfa9706bdace478a0be5a82420becef94a4f1d94263de507bd21dac40648c4a681dbf628f8707d2d2c6dd401904ee01680ebe823304928cb0239193076fcb5efca1cdeb12fb1e109e8491e5207322adf4a044037f4a02818fe52abd813bb931c2509640afb1aa2cbbf218b08f98472092cf7fe0842444e10df19061e34523bfb51038ef29cf29ed18fac3f290d2f211e228a219e0ac384d3ee01cb628b6e210a684ec13b15ee16ff5c9e7c51e1d83657f30d74951381a2cf0f8e4bc458290ba4b340d7e659294937c05ab75c5ae3aa4a38f4a4a0fe0dd2497877a83702c83724a24de7152d459239ef472afe5ea9ef091b66012237412cca772d7b391d89aa8512c21ae54d3dd91f2bcb46691dd9d955ab171df60d861860137a5a5dfdd6fb4780b2ded6017d0b663bd29a4010cab8fd38eec114a37d01aff11406605486fb8ebd155f275015e2e3d893ad5220178f97addcfe06dad81826225888604530d0a16571cceb45635fb0c69f60ede6ff091074722a3d749cc99eaf08c522433b2a75c12532437de9053666968d66dbbfa4d54683e1635404e12b975997243d9012bf523ae51be174232da9065ed45c4886165434e87a136943bd4ccfb9c5e62aa2bb41ec270296fb4a2eb76f1091f79a2af8729b675caea7774babeef5a5b1dcbd7b88c31d83847edadc280a4e02942a1419c4f8511fff75e4ea13d3d40737ed88ba62cde622fab19725a98e018b5d51281eae636a7b547ea4941c26a8b7b5916fb648e274040c6ae13c35fdddd2f49874ddacda922a0ea56eaccaf1a2170c18847246c8feece050b4a1511da13d151f30e331880db300d0d58cef821c90d02df1e817e68b9bad148242f4e016169eedcf00ed03054e24275de95f013ff591ceafbc27a9beadda8c0f1adc4106a00e37b9f8c1d2334f097b9ef6602cfcb10f8c1347717a563c92f2ccc44654df86a0a25d84d364da7ec0d2008f677fdce7e454211244da0baedf597cd5a641a82bab1e959d71eee131a0b05682917d427db195b42fe63b504cd1fa98b8011218f17891852788d1763abc05c7980a2d88f1102a42db1d38804c9d72d7bf4f909c1ff1dd4cb3d2aa543927385e0c89624aaa6c6399ac10f597c568b01612dcc3a981d10989c4042141611b5fa3c7fa67b70b2e8e8016c41abe720ab3eef1ce57c2723de3a48133ab87f047f894f2cec8b5e4c5ad1d0dca54a8315f4e82f1f2d0d7c0c5f60f5c51ebd70bc013ff448b596848de3c2bbe96a42941b86466d643978dfc82667b19df25b491ac04907d66cb73498242f88c54871da6d1c592eb8b9d6d7b3f83276cc4df65ea541ce82d7b84cf2bd3e6a62a8631e3c9c48488183639399ff3e7a980ca4a0fa9f41b6ab69923725f33603a0d8bde144a4a5cd10b8ac21344be6d7045e58b680fa5fe684f3199361f5dec7ac2a331327f4fca6615ec591818d8a8af43a8c92436c72d8a884f11b9e414298e191192cfb6641ba2cf6f1a5f494e5207e14137e16e6d1f78a2c38e6d1cb44e36a214e0587323816448068b04e22538c1f68e712c42311904426712dc5c50e89908ca93707a60126b6e79cc09ece4992cab2288e226656ee3c83530971ea6196aab06bf41e4ba08ab1423559e22b009c4238335a44f64e6f68281d98762c296c8f5c0813904243140db2a3db11d191432cefd034dfd335ece71dde2303a9446d9339ac36e59e4a31af53722e19a8ea36dc0c34dee2912a276f1658ad823e42aab286e1273a11d804aaaa3c4be2dc36e8e5fc2378c64d1edd9f26d245bb1c0f7d9e3413eabdd20e0b171275eb208c94307a5320a9604b32af250a38ed1c1c7d103ab0051d1c0e781888440b77d1af5d99c32ae8ff3418677b3dc7ce24327f9a934f8c02843181090123229bf2c463f75bfba55dbad63689cba2df98a203017c8a03da1e8a6e5920da15a903d9abd27f458ea7769d7c31cc9d5666cf13012eb38c2e4c5d4817d6c9680af1660be02e4427ed4b600ce01cd600702076e890f040c95d081e7d3bf0c3b271a7f28ca15b4b4222a8027941dc6def2df79652a69402d206c606e40623d80c9ff1a2a4c1f519df2f6962824dedc334da87b3ff89c940c791b8153e3e05916bc120a89953cbb7a09e6680a26779fb32c0202da8a7960641508752097452ac766fa01f10380871b9efa47077e53d6fcd65480a19af7d3cf849c67becf96466762dd44df0c5869e665c0e5c79ef3ab9a28cf244ca64109d4376219bc005394a981692149200512e71fd59240d98013d246cf4b22ed64a47739f59f8f33ea3588b5d064856404f829dadc9f290460c262b7c6245d7d171978e8e8e8eebb8cee7222a78d286bbf58a80cd521bb2da9881804bfb47a24e6e57e089629ea8999aadc93387cc23e66a2a993ab3c8f567c9cc2559ab944f230a2b6a2f47d0abdbf990f1392f36a26f7911588410a719dff2334432b04922e1924abed8885a5ef4a3a9e049c97ae6e34d230adbaf434a6004bdba3db4a6bd4c617d786eeb5e0629e78712b0f839c958dd9ea823660be965c6b7bc10a7fa5dc04f31bc88f46223fad18fc09cd18b5e889337832451a4171b979ff12ea0444998ef67bccb8f482f3632fce8650047e0cbf72ee0cb07eee0a7183e0650aa402dbeaf3526634cac48592c2f56fba25d79d65c8245a14260ec86fe7850b7012d131b70bf1f31d109a0d440766a29419354e28f188f9458f16f0bed6f037de8d5953ab012a808c5668809569ca86e990c2543c9503294f6a22b64133551ddd665c4609c73b240f30769fae91af3266886283373ce39c70bf8a987840192127203c60f128689cd2143eee0c8144c4345e7a84cb3bd8c0178200b143b234d4088f18425cc9546bba7e3eaf63d5bf50dc8f340b16dd53d9de366b58a75cf0dc8f34031ae9331f2c701f246de0887e7755cdd34dab205700956b67a70fdb9d3a4681c5ce7182acc47f86ebbb7043e5066451ec23210827f304d739288fbd2f4da4cb60a010f9c59955158bf75369bcd4a386a6c6a7b3ee0669e3c7bc6672882952fbeb681de337366d4629dacaaaaca65bcc2ea936aa44875d59eca9acdcc524ad7bb58ba4206b7608204ec94f36385253b7dffa3a508d7a90ba7e0aa629a15d3f068095724565c7f1a46ac58955c7f8fe723c2ca97cbc31e3f1a94b0defb007def49972b7485ae303564479d02099575fd4d9508c35415c7f8fb083d28641a661a174161e57bccdc1dc182eefc5e76083de879f0fefbd16b94a88d22286c836255d2a2bf4d3925d80357afd65ac11e82a017879b99b99b6a929341d0db83f6cdddddac854421c0fecaea09b2bb3b6ba129d65b591eb6a42bc4a7461df1fe03736a4769d2885362eb0adc99a982179a68e11a4f7ceac0235e71a4492e61187f9974a9aaaabe5c66565555555555555555516aa393cd5062eceeeeeeeed6f89b58e107a8536c14628930c1211858d0dbcf612134b9623ce5fc5881bdd7e81c7c7f4e3188abf56f93f492c3143bf6583640840cecce2311f1ea71fa00baa28b2802907f38a658973bc198115eb8fee5e072ebd7e47ae86dec5b30476af1841e273be37802fdcafb57635f23d9db24d6a20848ee46e26b493d4a18d44702033b03c2bb01283361cc4c99b97182157bdcb6d0460947e720293839729c1c512c2547ac82a8e48e4c713299176b99ccca703c742c2cd3f8f4004e8f3aa43be372de6b37a42947ee69a0426a82650f6d3cacf2c2c94cb0672f9cf721ef43a00fd07f209f38506c1f4e0621c994370ab115e4389415e528479709e226ef1df40a446f973f0938b39d1ed6670f3be5212705ecc2b287b54acb98a60ad370d30939cae44892a3cf26784029bc4e89b1e29b92a6940c076d6a9694dfbd1ca24dede27ed324101c348c1ca261bc03454985acc17599c4f5e7da88ebae2a71a049204cb3bd8c42d6402661c428a1f0d6624c09639b9aa6699a8d871330409bb86bdc03304cb3b111b817390b1a5101e3c8710d23a76a46cf8a56b5f95a47032b8eae7f7f5add3628e69cf5980e12616549ca4d1bd5c0e66c369b513aa56bdba9b5568ed5e7176ddc7e1a2014d45bc11078c8347c2587ce128707d3c80bfad58e0ef49fa67d0fea3ad07fdd7b3c80fe034b2e60f0f1bdb7f2a1d7b4eaf2848f2336a15f791f1ece4bf7f7d2200f3cac84409046c312b603bd9f76d48034baf1e7750ffa1c30c7035d442f6cdb01345260020e6ffa060bbc600710217ba53886022c2b712dc9706432994c86c3712b51586245a68a8c47c8d76b072baca7dfe1322f9d16e395e08b7cbef385f8a10b560c7b8734596b297592cbf526055d602d8bc5816dd1c76d5bc48ae10da5290786f187b2e347cef9e3bd58dddddddddd1a7b5d8963dc9320b650ec77c55207c57a572c953a87a39690da154ba551693492a65269541a953a28d6eb4ab26989c545370fdac443c2748eaac48b0a2f287891058d2456641f70fc72a84f3f1de697c3b6b5ab3492168a5de176668b039bf5846b48eba458012feb3ad0c7f7476c3e90c197e9e3653e9f3a1a9858ffce8ea4cdc20633f3a862c16ed788d1bf09863bd6a5f88ffb78e83eac924fc9673e33b39dfea261fcfb5be7755ee7e7013257ecd8f6bd063e17ae30852f2440ab44f791b9a2ab1e7045dfe19058d9627948c308cb2c27e22a1f1f1f1f1f1ff7711f4a6d4891125aef689675234ddc7332c90bdd3a311cfaded8a0092638874ddff0da840a7ce246e65070a64acfbc9182cc27e8262716ab321addc4b46dfb949873f2e439e79c737a366a74873d86f4a9128bb2a3720c6c62e53fc7bc5eafd78e275c2e53b581654c8561fc64fa77b519b6b05f415ec781c03ae76c1b7c474cc704c3f7d0e50b567ee7c0ea70b95c2e970e4aeb1394520aaba1d2b44d6a018ef1f7c14d1501579ab6efda4198ca6d928d4d0678e81bfe1b49233961abc84710d989059886effb0e1ce3308e03d65ca06fd8d0bef1b0524d2bdda0d6ca951bd6b18e553b44126fc4f51ddf683d0449221c7e2ccb1c33478d7eece29a63099f1d2178bda28462b59b03e9a43ca5e372d2446b088b476584fbf9f9690ee4714c41946a744a3baf683d10685d292edab4c30b870215ae37ca9398be8567e1499c0aeb38a85e83ebaf5d61454fc16029580af6ad48b1e00fc8c30e8aedeed63fb27fec0f140bbaa2ad3d52a0fee43df7d607568914de37cc0391c026e714c7b1384f718caf9048adb8221e4ed95cf4aa6157a86c20e7ac54ba87e826ae607d0304a5e01c70e863150ce33f04ac75450f58a9fe7151e9d98fa760ab15acbbbb57a9558a4ba552a91df8467f123ce5291c351c637323831593b55ab162517660465e4f5a3c158562d91512984a07ba4e225defe2fa92eb9d27a58c59e9ee4ce34b347163b8ac8512ad4b3f20fa5623ddd717a7914bf295af6444f9bada532b5c7f2986bb46a3781595693a762cbc07bee21831d8e453ace46bc54dae285f2bf95ac9d7eab5922ff95ac917378bccd554ada68a065484693628388764b24295a039c6ef064a9ed56baa54413c0832e64260182f5e1edb9cc0e4ab5153c5327649596513922402c748270ee3bc85273df5b56af1fe0b710faa3e05c738e854348c7fa0e85c5c7f0f149b0572c370a0e85b340c2849c334283a0fdab7a002e63275c534dd73a01b218b24207f5fc95713962fa6e1a0742191c079b5d65a3f0f9c71988ee11bfd376a709027c31352c662b5645294c47660515cee84a65229562ae52c16d3905a002f4bbf45f9e4fab33c6c79d87ec475e2933e85c19a34119dd5800684218924830c2c2e1343abc2ca9f48b0288be52c96a649901315a534caf86476840f95580c0683c118c635d2d4fd5fea1fd9339773f68c695cab2995c23006a3c104eb75a100ae07be50d0f75ee841341861c546813c1fdc7befa37bd088abb31aefb9f701faee6342b0f48680e831ee4b9022bce7be08d0772fc4f51c071cc3c2728e7020112f35dd5f804f1df8e5d0af69df0d25d0c097991a5e72a0e2cbe6328515676ca0c252c043972aacc8aff9e9606f835270df2869b2a222b1a8158c4a4d0b6d947c73fb82f6b17b44b1941cb10aa2da49496696b254b2121c8114c0915c9f0234763e722b608f122c7dad6218e92cf447a91ab97188d82ad625aed1d5ae518ee338fae823a5212d1c368e23eb937294b526b19386173616a341c48aeca2410496b5d6da0edc073dfa4ec3a0513b49ac5fb1562c7058859dcee1afd1b7f01d18a094b8cb437f6f314d7771794a8c0a1c240a2bfe0522040926c6518bc562b1586cdb3e2ade88840ee69c7394b2f267a9d65a6b85511a6cdbc61bd76aed68c4b6246bb576349261e871746adbb66ddbf64d60bd84c3a07e7ad997b5f6e572d2398cd008b8b3c72f9670fd6b04b1628ffd55607b50cc61db8090638cb1c9a003db9f433f10728c31a64b5932bd2c2c10d26bb05d1c9345dff0b79e85f5cb333995ed970b4c59970b4c76066b2da53c76e0ece0d14ce03009ad262499210a2bfdc331eebed2beab2e97cbe572b96a0d39c6c56264345d78508494ac9e73cab64cf30dd1a6b053a206334918c169bf7de55eba7b0725a4d324edfad73f728cff04c230cc800d06d75f93c1047bfc306261457e694e58314442b550c21da3fc5ae7f49e98218e391acdf9df7279083db0e28ae17c71e4ee4d50a9ab80cbaf99948a85bd21f4c51c51ea9a0b344dd364386de29ee7f34fa93d3f0b81c9cbe7f423e485cf890bfb86bf0c0654775a9a0d8648c2ad9f6ea00d35e4b421e461406986366861e89a0c67db4036d05ad358638fc5ae7c2c76f43e3e432c7b48a5f4402bf60b5970a5863e10e775dad4b8bad53ac339f7858e8eead553c4e52d77e22bdf9931f7c9e33293089b5a8700d7df554ce357c63b274df64587d1a0c28aae13facb2eaacb50a699b22575244a0a6153cb078d04c380c050b6c9681e92249d837bef76fffcb5a3d572994f6b47abf59ab5c637411554bf1aad1608342b28b45102b9cb16bc6913d464f496d3371c023e30d23afdf07666a7ae93d137ea26b51a7434806fbce66888c6d1c98139559b54677c05418d3a3339335f135e33a3191d978e8e8e8e8e4e8dcc93f2ffebd7afd555841498b0a95500609af6de821558e50425d07859b15dcde3aa6258da4bbade76e530720414a0508da7feee9fbd916c38a6c64350b4a06c5718566cd503c18aed5251c0c3510f8ef177cd5c3eee72b98b028d637bed29f8737e3e33357da8cc586c4ad122d31fa4053327d1a3eaa9e5f9991f80aa27d18bdc1589fa7b5e791d4e830afb329faf769a3e3486478931c72933442d2d2f12b55811c9cef8185e943f35325e87c7a0b049fec8dbf2f2478c1faf63a377f99834b98c4a2ea492e85b5e9425ede98f07913f31d0ad21c00d3d2af46a446143ef695cb062c76231f9c3f2f67fa68c22653226757cfa0649362161a18fa7482c6154521cc6bf3562ad5432406fa9b10473c728188bc5c299b2ce82c5c62ed7eba78a131f1e1915d893e972b19cbd8df64cd65a0150afb02f3bf8a9e7edd7130b4a62e9e778ffe4e9974b1cf5cbc562695f353027477bef2b98537fe33ee783e11f0eccd940ff32419b8fbe8fe7fec5c67b1f9587dcbe971db4dfde4603e76bcf270ada54f0067c9960cd69eeb4abd52c579425ede258bb38d62e8eb58b631c6b17c75c1c3332d359348c7f17302e9a6ce18a6d00ca288cd194d18d6bb2d060cea94d6dd643f6e8a17953aea1693dfc9b2013baa78734795f396f7605fb89c350c07b7c13ecd8f53138c6ff658c9bf3a20f35c6e8e798264c2ae8f9cb53430d38703ccf66cfdc0d4f9a617e369bcdb6ad34da18a8b657cfd66a6d206f03792330ece5d3886f9de252ba09d7bf91f413b197741324987a4818d8900b6040032c532a75c9927a48538d8419d239980e81d5004b804bd3488ee6aa860a27c45aadd3adadd699d010b899678ca5bcb8675afbb57e53fa4cf3b9e8c0b287b7bf1b660d13895aad9da174d5755dd76a750e6460f7ce816a6534912c79691ed8ad195d8189bb89d40b266559135a2a9f222b554b65237beac669df01fe0007543d5a35fba902a98fc044e0d0f6105d9715d184b1a5ea3a15f75dabd59ab1999921f96db53c2fb451c251637313c4689b9b3948376b5ead6fc009c3d22bfe126c0f4bb84c831081dc9e2bcfea8bec73e3a107403058917d4413338f1e48600296916f5d70fdf3e1d90d0d7a3ac56efe36ee15146be07a6afd826cdbb681402216bb12fa40228fa5b3dc4a0d7d54d3346ddbb66d037d9625b4c20256cbad84be0ee46d9bd771356439c161ccb0d878c4939e9f202d6b2923d1ed92d87abb24768eba2476e4a387fe4305c463c58685ba4ad7c934130e5552878763b8ea412a18561c09c089ed7fd1a18ddcee1b49c10a366c94a6aebed8bc67bab9f4a582363f9a1246aca3c1081721d896151b562a51d8f852c31246f6c460ad82e5400a969955b0a947bb8ab83d706db3cd25af381a81110557e708a5a9abe09a15a18511d63ec2465bedd980c49088f580cd601b0c06b37198a60283e1a8117501d3509a864ab57886b08e5829d1d15028ed09b11a56a56106564a6dc60cd804d130c47ad81c48c52e20d4a4848dda3698f7844c715c5754adda0c2ce781225c6f2de8a80247e17ec181a4d62899ca63e9152b2af460b3fe8b1ce143e4ec2ae75447b35c34daf6038b6528160ac51282041344505c2c168bc5623729ce2d9526a289182580c39134351305d0a1936f7eaac05f7d05418d3a23e76c1a680bd8cb07f0e33e5ec563b399599624ab540a435913aad4101c1e33b8420aa8d38f298428a7232f3a740fae33abd5dad1c86b50bba669db65e7256150723d8c22bae8557cbabb3f3d42830e9bf564fb555f355eff9476b7bf49e7eb8ad7742758b00e7b85a26f996911bd7cc5341bd3d02b7a57182d87c2f22e5e1c9fba24f67b1dee45bcfe1436318df73c3b5e8d5c77306c42dff22ca496b724d13749868ccf01fd8c0fbd88b4f220d207e67c2ffa1cd0b71cb111bd8cf7d102ce781f22d0876d7087d0b7fc4de85bc09c2336325ef4392c3f03bc59791198635f460b89e54524fb73b290f83449dd8b3caea8bd0fa3db4998d10d1de83f1c159702865771186fc2add611fd0ae23e6da45ff7670ac3f8bbcecfebe7355ffef297bf5e2f4a619dbb38d15ad358e3e6315f5b2101d1b70438b4461a898063fc7de0186718ff2a5be0c1857dd19e6f09da6df01d2e235fbb3c62d7885d231d34287169db569dd8b68d37d6d1d9b0e083c372c79126eebad23182c5e101019a3044804d38339d23878930298e157c28ce26936dda56ab27f3dcc7758a389594942e9b996bb52ad5ab54b2566bb5eb54ba4a9afce42ad548baaa8e8690a1320abfbeccff022e13c40557ecd4a80512d515bb894de4281ca5e7f3930d1031ab0047b9f3c9ede7516b10ef4917061e848007490bd5e3aeb7bbcc640b516eb77f9352cd063318e18b91e3d8fac6711cc78dd2b46975d3ea07e27134053b63c269391648b6eeebcc04b94edb368eab756686eb487cbbd5753536375cf0388ee338862c47ecfc9186a156ad473dd28bd78139317401060f4e393fbe24a723f47ff40f923875dfbdf47b1ffa482ffd20b05bd50097ca94202b021359ebf3beeb041d232684cc9692d075d09282f3465b5f0c2bc060b7baeb5958b1a90ed977a3608f1d845220429060626cb55aad568be588bd92e79c94523ac1be9225537a75b80f0971ccd1684ed115ec775166bb5361a43f2158ff2aa511b3d9b8da09a2d2318262aac39fd020866d596c8918aa7e384cb1f28a55d37a36c36d7626ae5b212e45d899f67db9569487de1c116c8361d858adf2ab42c7cc35a3b3d96c369b699a3785d6fec31a0fd8a8e1ea2971bfe64282b1251afe5326d8fffbb55afbbf6d4e34959479aa092925ca9c5276777f1886f839e5fc98a1c4ec14fa1f9c173af6a52c0c36f528933e4c334720a314639453aeff94b210cf9c734e1114566c253bdf0e7d0abd46aa170c825ed10442dceebdf73ee47954649f293b1db8a78f4347677f3754903ddc260f13366945c85432954c25234919c704e118bf230f1ddcb1752453c9502e336532994ccaa48c521baa101566e6f97acd58c591a639271039ba48008462a76d28dc0588331ab94cd7754d0242ad10002c7c0d52781d417bdaae57932d3a47659acd077c75bb374fdfa82feff55ce7813ccff32a28b4d1d203d555c0652db450e57a2b9452daff9765e877f7d73c48e2ce27acbf46a2b4524d2b694a24a574d229c7719423cb15e5a85d51b21cb1e28f9e102bf68b254b96a2ab821b720c33b934338a5b02bfe24b77d0093b8ee3467f0325d0af51272f0d3e3703db301211ecf793d2eec8d6db4637ca1a1de0824eeeb4bb9bfea6c3f348d20abbc35d94d00ed4d11be86803450f78a0f73c1f40d77b1d1e690711ebbdc82e1bc01d38a858fade83409482a8b7c47a339ebd1e0741c3191b58fa6209071c331dd75f6d14b62389f5fa50e36a4fa5699e4a330c050c0683c16a361b25263caec1cd5c7b7e9cf8548945a9d5ebea0652a954dae488a86cf7ebadf5946cd2d4e329b1f28acf63b52bfef5ba4f88edeaa655971efbc2bd1097a3a105db2abe53f5e2513529b26a7d31b0948617581f47fa7d74efbd8f9707da8040ae46ecd82caa28d2b19b580f7f504f471949f97e19f1d281deca75001af66262d943ee786c93b4ef6feb1cfcc8a5dfa3722c2d4a6538ac97794a29a5da87615d00b022c452f0653e0b71bbd520cf65b48edb36baa2a0495ff30f87bebda2a4ed7a3f60130e2887f7aec97432dcff0c21081d8676fbab8f53a7a0a26f386b27d55af56a4541d106e0a35960c20bb60409cfc85a511e826046ca04a081384cacd8abd65e003f92c1b2700e467abb4e8ef19c458939e7a4829d1e7ee1c4b6cdd9715b2761484ab05c00f017b06d9536cbb65adb9b42a552ad60fec4c8ab88ab87a544a51a8d46230e65a92459a552188e46fc725273c3329834f95879d0b6f9b0ef3912b7c2bef73cac3c2805969910197299896aa70897993c3185eb29573292a61a2961ae699ad63f05abc4271a66e02a8e718d44a43ead907a95d349f002aa75fa315b4a749195ab52aaed4557a9422f690a7244abbff2dbb63dfd2ca001b9f31bec41fbf99ed7a058128d443fdfba4cd7812f3bd8173d0f2bcf028a56de87e86d079244dc8f6ef7deacd665e66b2ba4976949deaf3c0fa067017dd807fd0ae8c3c7ca7bcf27fe74a0afad9034ed7b04a3db81228fcb813e8c6ec3be9df4388ccb4d6e727b52c3c3fb95d0adedf3335bad34a67195f3381157f5ca55bd72550d35e0c06163a55ab9cb086aa55aa95e2a954ae594da50712e0315b8d979641e7329fef21ead824fac8fcbd09722f4a28c22633b5ab7c33457700ea984964e4bc75b5d41d933f668d1df0183892540d6006d8709f4df7b9236f5f03a4792040ad71fe481a27331db62e65968ee45928a846936ff828b2d3c0b6fe9788b894ec78a2988709cb7bcd571a18d128e9f6f8ac7de0aa594524a295da976f480d087422f0ac0d42d8771d7102e9f28a5945a92e85948f657487d0a919eb8fe4e5c06f837164d84437f569f4224543d8942274bb2608e039c70c13aadbc10276f85c4e30709b342e2615f447a11813f802ffd166c70073f853e04f62861502e43b94c119c63fa4801430ade5728740ea6f95e7419cf2079ac7c917d388ee338707379a8846392f40d241cd3e2987602dff07f3510f8868bdd9a7139c61b089b7634bfa783d7921a74d139ba7796b72f826edf986003692101a2eba8648eb87456b2110100000001131500001808060583e190583c2e9c27d51e14000c61804084643c1a09a4410cc350c820638c610600620000000c0c91a8005bc4b75540a5a7c72b1deac50145f8dc4928dd364c074088a269ee6dfe486a1253dfae4a91eb83683c7be2abe30ad51f973c7c268c732e8ff712c14d2b6159b51439e66fbb7210af987b982a00826bcbf7e28eb27efa429df022e047c4271939921063dd42feddf0f2719645a76fc4a962a073a7af70baa8efb54d55a27d93719c641f8c33029f90d5e58d35719c62d7755351f582d2e269d3d628a6a751ed31a34f8240329c070e9648c5802a045db863d9cf40445b0c278df7d0fdf26edd62eb90caf0a8a0a1d69d84882dfb62ffad8faa54d3307de15dd3a4cade71fc11a4c9fe03c21e02fac399b2997cc8a7581f30db8a441934184df0eba87bfd4c734b0a3500e2cabe6d7e2587073cea4c712c021a900e439abe8a36df876321bd5e1dd189f53fdb99d07b13dd5be66c12e3107a6e1fb13d2e9aaaa80a707b64848797408927c17d4278565c732853861a9b5652083c50acb269abb8d77f5325231858e3bc3604e0cc020993c41205628091b626e07eb718fa43c37cb4e2d484f935d82269a29d0c2698a6213032ec325c24380ceeee5160a8f8307a02a297966fc2f63df573a80452eec54da143bfcdeeaee51ec6f06c1c04c9b27c675ce3ce96b1300961209fab8aae6c6968d96a2ef24ed067633fb5349caf52c366b82f5361003c7d5dc4f209b46aec54ceae2bc361ea71d77f6779559c9b30548c205520b84d0c6c00b953d273ccface5a88ff49f5320dc4cf82f7e966b2d97d82ea59e90de3eb2284f69e12fd4aa8b8f3b63a290a242f139a2bb71e7fdaa2dde223820750fbce770f88ce7ffa4963bbdccd1923811cb1a3310872841489428b57cd37e8bca7095840ec583dc08bcfe2a9259390a06bf59c1972f6db1ef75c123888d24db519f82c9223ec9311750ca9039825b68a01cd4888bd54a844d70eb0c32e7366dc4dc32fa794fe4ffcb78259a2e16d2c1397a38ba90c9bf56a2f4060c24048bfb2304d1612f8b233594f77fc494f62a29c14623721828a1e4b5264090272e3efb2145450631bba11192cc5da390cab66c8041590d50a9bb19390378271977000321aa13ec11b9c6b5ef849f56990610c2891094cc57ed207da0b58ff2630cd3030a2343b72fbaf7863d5c02ef0fcce269c574fb398d5f37922212a71037e680942eaeabafaca5f8d22e00672ccf690b3efb177ede1c8e0241ea5f6cce84181921802f9e88ac7db43133771e6ffe87c5078b9880fab08ef7f586d6c305f763c9753bdc537bc200d22a1b3552a06463d1c1ecbc7b1418fef7470020eca9b44e47dd34f56179f4d3979cfc99ae87c3d50a586b4e45b9f38162737f84268c7f031aeef6deac37571ab87ffec269b6622c4b8ebe1bd9bcca9ecfc587f01d74ae4205fa715b832ff7a18ccd52caa79ffe0bf8ba31fa94da79c386099d32273c4b492d095d0dfad08c5dda8ec265996925e12f3dc56165fde30179e24c75ebb34ad4d869ea5e7d04d122e6278686dd34d01192f098e5f11178f25da24ebc534943b0c54da911116a0225c41a7bc2b1ddc80969369c512d042a0983f92fc084a8ba29eeb386d4fb08afa396330a5009b14ab80775aea993744276dcfe0824b6c90a3c105ed2385304f95525c3c7316f5e508b3e4d48265a737cc2b2427e2d809572cf6190871215ddb9b526e68599f27ca8c7e9acf43f30f9180aee798c64a33295cd17b24a643b62ea6ae59d78f71369b67de7a77c0fe88eeba008439a19e32ef7b88b2095c2187ed8a5bba01de81222a89bf6167a78184d1e358988615b41bf88485c56ab78871c2f25a76443eb9efef0bcbaf66041011f07b8b71797d5d82c0d326c4edb90a633f4dae21cfe522bce3b749ae2a19ea31fe08ea8cce9ca9d4c17157ee00b22931e61f68d277b4ef9a623f4cd7ec43c2958fa53a43b50fd4a3fc47bfe7a05a39e5be281b6f58110248ac2606f7c1e7848cb2b5a0e3ed9875d048c9e8e69af173ea71ff6910b7d4dcf9fadbf1661c5db3115cb9cb1aed85079706255abdc40c69d0d2810a2a1ab821f4dc5d2a141f3c4a74ffb7dc1fa3337a8e53db2777235f1bd902d7165f482f30ef08313bc4d8e827f8abf1df92fb57482ad4f85ccb67ff6254990853988f8e34c1ff7c7c2cc1a8553ceb6f714dced694df8c12b789fc51c671a3d56e358cc4ed05c3c08be80b4322d7fbb964c450acd41f24390420649b61876ca9e84b4dae0b44ec88662bcbd6627f1f9cb43fb4406e7a4231e6686635002426c5c5cbdc10157e2e0d03896c2b2a85d91c7ea3a2388270c6de417c82f0296b6ee7ad0a33c5175fe4bcf5c0488d85c42924c9f66caaa4b7cb5c3c486ce6c1e4f736f27c42c10810ea7e52b86ca09826317c1f4e791ffa7f970d753bde5b1d8890e2110aae3e960ae47bb62b05c7dce68304d4478e444d0b0021a16dc5c09e560d108b55f9a83fe4ca4263c25bfd1ba7a8cac88314099149e8b8a3302525ad21e6e171c4857023c0d22425e956613687fb84caf0e1085f04a5dcebd05aa14149bc9000f40ae7d0a979eac196b3ea77cc1e900472d196d9dc10322a43a4b63824b1a73cfcef9544ad41a9f541500cdd601ccdcb55239616fe2cf20805af10064c9a2c103eab785fb5afcaa0288287402fb8881a11ce68d4acd689fc170f0dd4df4605deb214bf82b78db0c5dab8a95077a0c43e074b61820de2d5b9a3d319331124705fb27d4dcb192e0403cc241667f512595d84bd36f1fffa60f0455f9ac022e3402552c38da214794ab8f1f925952569403a2769c7dcc4290de6d76a71702b2d5b8c26662793abadf79337f21efd7293cb1d57f27c43e1643278f7014493a6eadebec9eadca9c8c8337e69fa88b81601253b10fad222b24f717d93155181b51cca11ba3a945fb686b5e81fd95feb5aae1d18036c9d58c781f997df3afd81d4c32b8fd02498cbaaf172d0ee81b76bd4d4e8d6f2edfdabf747de81b5f0a0ee42841b7f50dd2e6ca5f682e69211372f3bd5ed3101ad0c3415cf89f4fa0b43f7049528721df18c30e6bee31e41b7dbd12ab574ed3128f7bf85a1e0603cc1611690fa946e93cd34c0464626e8f1875a506b2264317cb3a1d54fbadbd5b0b2117bb166dacf872c6f910da40765a58474ec680cd3a095990db68c06cce2be4490b31c7c2e5c63a1a61a95f9a026ffed3669fd2ff1cd5b14cd2c97b97c05d12208576bbb3aaab596342dd5653ba3892f73943305d99ed76676ab49765defd56c6444a20d36059d73a3467917a7462baaf8c7f5864bcc84a436553d58061691eb013920b0ff338f4af469f67cd8fc77dc77b15a3cc7abf038185113104ba82059b8b47076ee02b7c3a8a02af80e0917107c765d0a9a602cb280d28b8a1f1e37e678b1d6d1dffd1347b2433322eb500ac5c669a3f595cefd6e21c7fb2cec274ae8e60854636543912d940011857b03cb3c9e40071656d41a7ffa2b2c27ba5e45e73e406acb1722fd0611a45d56117ab5793c0b41d7b8e0cf58a768ba160db3ae9670ad342aac065a4e48b12a8648c3b2b0c52498e3aeff2091cb30f630f9f360f533113f92ddc8d77f4c7184a3950b9960661865dc046af7fd502e451a2c1ef5d02ee69f95a2810789004dd525e386936d41afd48aefc038aad78adb8fd03b3b28580a296c543deb10f79af3a1cb06670df1cd083434d9e1baaa7105aa1b1d3c737064b21ba962fbdea89fbb4af8d4d1ca8045700b6411cda7b616d1b7a5269eea20001de27a1d306c87eeef553e34df3cd071d078ea81ef12f9b34ada1905a9bef9e589e60554abb265bb1315d20c238760207929536f6e2ba2769cba4c786d75f9f3475e1b14ea60bb0ff131d7599c205b8dbfd92acb7325ccc4b069d0563f30ab50c54812c66f0a7b0eb7555c3105677d10c2d6fa795b06c9a2b6e73c23be86dbb3ba01fa702162eaeb905cba71a18041a138899b7efff68b82245aa071c00a3f2af2cf5a4f01fafb2a3b6ae0202394cf177e37d1c739a6998d2d3ec9e60706782ff3ff22d4de1f2133e0b22c6c04eb6085217a07002426f234f7207ca3bb5afcb0cfd66c61c8770aa7ccc0608c53c43e753cb300cbe0d3a1c2319b96fb9c510afea4040e9285c320bab877d9d0af1580c3498e6a16fb58566dbe542cd0fa7d945d8194518520194d2f26278ba18b76b31a4a74088c9c3c35060c85d9007a4707b6ee0bed053c580d2efcf5911213e2300b0b510058f2d040c9ddc2ce13f8e26063b40f862245ad3920a320fa5012ae625435b878fe65e367265e5e35bee89b3f612ba3fa1465a463c141c99e6da0250c96a9c2ff6ea8871bcdb4ae49448a0f033d9ed696bf24981cf9efe568edfda34912c0e3ffa3df8fffda3b699910c4d5c183d98d05bd8129e1f3d1e0fe7fc0d5c813375dcd1b51e0f4f8ef2ce5234a35051cc4c0c93ee922e7645c121ac28e2c7728129633860f383211aeb1c8311f3b9633dc0e506ec87ab243dc6acc4f05ed9f2da9423f54791deb92ee12e698f3857b4b0f7afb5e33307655cee87cf1c5757db9c25cce8c40aa0a45331790844606dc4d40a696465c4bf79c7d10dcab3f7b8425cf62826480cf5e108686b6f85d1f626e12a8107026d1d48d56b2407b22b34d4807efe83e83782bc1468dd24ca44f1aaa2856140929b19a24885d06161de4802df2f01c2f932fe726068cbf3dad0baf78b193bd59c0923acc2590b53ae4f915fc0a22d3657d085139dd3d52c45feb687c9a03392cf530bf92095889bc942763396398baf7a754b0e2539a16db4cc63adcf983900d2f5cf077192ea85ce7c3f94b202f32648055b102a69b500501ba4cf025ba411714cfe7fda756d812543b31f7920efd20968bc0911faa7c23a24ad8ee628eeee220337093e246d31362a87d746bdadba15ea2625f769d93753775056fa3cbdd5bc36b1d4198e8984b67a31d8727720d3f1351916ec303c58efe0a0e0bf235296b3c8fda15d69f8270263d26de3ce55556cb61a3c2829c4241695c6874c0e6700334c567df1a25fd379579364e3d563ce9375ea227f13f027e6332152580f80a6dcdce6bc34e17331ad311e9d76f43a1dd64e1bf8402b6066e5f9bc2ff61cc4e27e1469e01f9c3cba70112ee9a4fbaf73a47445e9913963d3c6846c16d3307af07dfb56d9d416324d3e933bc4644b67a61d4a1e4e9dc3d66a002207672bc3b66b8cdcb0e09af3d3b97ca754019f934b61541cbe73d7c109f3f9535cb97a5f75d5c086fc2b4ea0cbcea4bd2284b609d4a5718201e069000ddcec080ca97f8f7fee1dbd005cc8527250d8a4bc1179ac1d74aac425093c162aff0f22605059b7994783f3232f4dd96c5bb1fb3fd522d2da87bc2a28d94e5ae2ddb2a6c6004f2a51dd7c0c3e79640de48147ef7a0f70c3272916d86e3939c8d83e88328bd11127d56b487089a977093b4e2b676cad27f44dc3f4d28139a4d6d81f5a91342974a1ae1b8634396d64c634708e28e48d39df050ec23d228cdb2d45ba753eae3f81b3282838d9c1ebea26a5d07deaf56f2fdef6d014b4d7621d7c2797c1532378df8d1815ef922536e52b1305979a9a64bd3544a486f45c39afe07a8d4201407dc16d2407cc31b247babe960952c56986ee75c5c1ba142facd46615372e9e88a360f0165fbe01e8ea572300c86cbf3e8fd1499d999163cd8f620e21433a520b80fd80e1557214b7a644f09f897091a362adaba63c5071896bebd27e1c9268f425239540699e6807a2c23136c082aafc4c29502628f4bfdf396e852a62522538c0780d812d3fcff8991528c5ecc10800607df981879205463d8e9e2bcd776c3db3ea0bbfae2b431f324fa3d1636b51e554f219273ece699f8f8088bd9757390e4dcf481fd97414486aecc9ced42c6db6c2d68303366e8d51194e7c443f5a8d62783c4b7b21db259b9b52b777db591cca8e2bab424ef7abea063244517d78ac424b1466e8cabacdae2d665388a6f811e69abd342e1e9c55516ffb7cc5924670db1c26c9932a7316a88a4b515fd8e2ffbc378d2465811f892c80d743e5c6206b1c0c5b6cc23f0bc020d695d64582781fec69c308f352e89d3fc132cf19f0951766d7875d656172dfded480a15532c3c5c741836c39f99ab258fc55774a35042a3dc04b5c1d89fda1f0da289f1296ed453795248dd9542bb27281048bcd6aa8f192f41bb39c9ed3fcfcb65a3c28b4f09ea79940efb07de19203573248c986c7746c95a1574a9eec60078c0f6dbe5a4b7611390671d38d5f3181facbe02a09e7a3f2bf1c276aa60be6d1fba3124c272ca8c67701db7168dfe3f3f5f7faca407b43cfdca7d442b390eb595404e51726c8733da3fe70154f7a671bfa23d03c286b8aba37efb31977c4d3a4d6405463e2b504a896cfd76ba0f754f3e801bfe5a18633422fd50ba93c24302eda7f820584210c54ee037d37db88b24cc733511d1711e5530b02101f3fe70cc297d1f2977103e3cc33f7f50c7b830bfd2e485d5645ef17fa1e98d5dd430a7c3fcab0f546238c6c6003c2c48af161ceab17973e96f58e256782d8deee55172021c039455d71af78f6f4a9b93e73d8e665b94e993710bb710854c20aebdd021e6964d1909a875df30fc3755fa9b61e29443157998c09c1fa8546cf1202d8c01520d3e9a63a1c538de76203d87ad2f673fe4d0ad34d90d04fe7d4ccb14759e339d1e886cbe9c59c05f73c478dc5d6d05d822fd26e9b137b42a97756507811d77b89daebf9b18e7c6bcf0e0f08e1c4152bbe7860af7515db364fc86436f315ec87215318ad64aa9751d0ed9286bb5a9f1ba25b42cfdc8d62a58655d82f200e27269f6a43c8eed9a7483e24ab1c62b45ca509e9cb0b0f84819cd8c7556ed2b8ec83faaac3949d56c3a2a197c9f53970f2c6c37af0272c8839b2017316b4d38ace2151e9f3f47893dee1c6d61c31d24449c1bbe9a5d667f0f70ac9159b9171bf2e221524b470c24ea40bc16341e0fc172b6d3172488ff911e9b5875a0b2626029b8419d76aca1031f60e323054b5eb0e0c350642731f88030ad1faf64a6a4076f1f40e9ced772881da70437f16168fa5c3fe4c36cb3245a04e56b0d195c6b8760308052cf8931f62fe34ff28210bb876abad9210731bcb1e40f6e126a82ef504461f14788de7870662695b53b2b0f75b58e7c20f6ffdc1fe66e78fcbf6390f5c76d10b89b7fff00d43cc1e0ca9167c82522cb7a5e1c3b0b052235d5e96fc6c87f58310fd0873bd2e551b8a5e198cb2a27600f5057b94a474fda69a6dd8f10837b6ba578f561e94f135aa25d0b508a58bf7afd30cfdbdfa5544192f6c7adc0055db1bbc95499e227fd40b1ce63c443fa438ea2b72d7ba454c6f6120de5f48a79049f4a4426c5253981a4e0d382a4a965d3d0fb769ef5a5d6d3d6bdd28577a3499ae518c3f3dcfafb4ae3b2011dfda41d042bdc10b643f1b231d11659e6d8cc8ac395bcd948932e81da32772c416ad932f0db8c4ee1aec87cb988c880a31167c56777e7851648a451d7690089a01ae253995c2511792f4adf9ed67b40e60bc179c7b8f2bd51afc0c80f7631628cd6a126fa6c5d1c66d568db8d32f7f6e39da066f5c62b9c49389d1c9ce6a70c6a41293dafeb7d726cf24bf0d9240b0231d628690802d50238fb5d01a1958150c601a9821fcce1c9aa2593fc3f5ec53ec007c1cf1c7bf2fee13bf71a34e04a4ded34dee000cdcc9f7b51166e4a9a640c97ebd2d4b287525fc226a5e1959851825639227f7948b6e1cf3cdbea9398373f86c8cae16429426c462331cbbef3a338a57375479af28b6078e1aea62909b4dc30fc2bbc50843dec6f7f28942283bce03c0ea1e7992ee34982e713d0c6b11ffd5e5ca23296f27e97ad7714c8fa414dd3bae9c205fab2d077e6349da1e40f620ac725f145565b231df862fc9405c58b2d507a2b699935287b860ec7da0150b3bb93092925c232729ccc1251a0737b6a272b82a21a65cdee1f15974490e8eb826a6a9b57f0940895824659a0fd44fe73be6101b7ca86aa235dd3984a65b72cdb6d801499f1f4e14fbeb22827f4eaaa5327e2af6d472faf5ebd9c9d672d221c251d89fe619951cded6cec9788680e5ea9b617f5e667670adc80ebc230f4bb9b1aa1e26a73fa787c3699b244dffc88053cae09c51622d0954d96ca725a7f1f196d7e7c5af4da93afb134c6336dc4d471fe287701d580986d5e2f9e7ab6413380dba9aaa6b469e4f86bc82affec94353ef1344244873851ef8ff96aa537a6cda05c3f9dc0faadd387c0dfe1c07fc775a0f32dde5c4bdbec0c6e454a172de29f596ca138aa27f77549b24a193707289be392fb54524394f158abfccbf0920ae379963689ef1a3819932ece9c585de74d697bf0b5757cce238c27f5aa7c015500fc27b751339eac4655158f8029a87ee2dd524fb7cf48371d437d7507a664e835ea064c0183bf90ed0d504f11952aeb149d4405f6bb08594b491c4b891adc52251c800a6631b2f458bd3e2fffb06ad5b7ab5739deeaf65f9ca59d8fe8a1d5ce5c62a378036d148ccea23351231951cbb37e52f153997274782f33a1bff0120698706e508348484cd6ade31e378ee644040cf4b1e94a062cd992696a782938ac494395e597356e521cdee2aefe7b2915e2168411d38dd3ac38c72f4aec8651b5faa50c5d0ea5417b75fc5a042a38c5b3306c7ca817f50fadf12602d0cc1b904e747fe73ee15ca4f31d0ab20911ee0fbd66c972844050aadb1ed586fb23b6beeaeb80353f31dbe00c9f654189568ab15beb542b692d4c60d17a8c01b1a4df9440e41abcd118d3c27b627b78192eb976effc09f3f911fd4d55c4e0296fdd250d4dde80ded3991d61704414efc5de9a403852b6c4c42c6f015c8e75a6fdf09bc45070e70d189d42eda5b20aa431a3dd036e894e60523c20091c0696aa367fde0fe6e8011381c49b84a0a050c3c200f997b00248f1ee8dbb7c26d7c0a0928128f3aa103d40d548bb5bddd4b873a1a799e942d4e4d4fe9080804574149f75ec757915984aa798b75522da221fff0e37269123ced35d12b78ca6782db74e630458df7f4942fa7b910ebacb38ab4f45b572cb43322d9305d409c737b6929d0cd6fc84469134c3f432dc1f420e092a2b1e613a948f502a5165f781d7cb447d97c82a9ef0a94e57d827e051ead65655265a167b8eb4ba198fa2372913af11f12b88db454dee48893c4be33b40347ad01a57e2b2345dd483e1871a34e6c57d36af4b4dd15651891bfb71450902334c1fcf33e97c749e07cde87cd8adfe233f02b5ca7cf9746660fce1b5c0f09653979fec34b3bdbb86e56df7663cceb82c65b75bc31233df99d32ab520f4ac9154a587ea42f7fadc824479061fc095476e384c73722962c88c394968af26b1189abf3724bc4bfa296f4245741f68ecb71ec5325171fcaf44cb1fff56ba063234ad465741a2a11e6e5ea1818898bdb7d37517f6f16da61623641a4e26bd1d5588ab6a9c6129d5ca3a4259b943d295427dfa0b9baf551f6a42618c906118511675b49378daedf12abd77de1975a091e6a8ce98a170a3205b749710175d879859b457ec988bd89f2100eed0a9c02e95a0ce7bea68d5a18dc223b08d0fcbdc4eea3438e9cb310f72464992be3f5fd45ec6b3cbcc3a282cb0455f91d6e350169ea9045aae6e0b8c5dc190511845507f105caecd0092e6430c512dcdad69d622a6af8373511dc027a65af7e8f3d3f52f6ed97416f8717938837aad82dc000b797f739bdbfefc1e0c740a49b2e53df5339af86aba1bf116d34094ee24db37a0cb16eb06f6edbd451c7a5122d1688702a56c18352d5ea017838d9e8df9f33d8e51e9c80e7cd84253991de7f31b5990e44c210199b5066ec89b61d12af912333a253f76615b7eb899b29c8df7b591740f7c9162b20038a6342796fe99a66ec397519e602f352dad809548bb3a70403101c069c3cce76b40a202af446ef9145de16e0d33c646e9e36258f9a4ffdde85c3155603e59c6a07296a3b93e0003e552f96a6734f6e42742cf55cc1d425ca2de539ec2c4c9c7e123a77e40791534e0697e3d4482716dbb5963a051ee7e6e381d443ef62e132092387350e3cff79c22e028cd4dbd70b150cceaa2cf7449caa20c679576d15135eb22bed8a36f893c6c1848d96b89fada8850c29640b639fe6368975bfcf863c5d27b59422b181ab0ac18e04c57a1bdb2a98a9653d16f6e651853137c7a1b546088cf06530e1f0e17c0fa75bcb8f2f4ab6c29fc3dd81e5dea0a4492573e6c0a29f8c090ee7cb10eee41c28c7f79dfac954d95b8e7ba9302d7fa57f2698b0a6c496c77b483767e423778200c2fbb5615ea53b751e20daaf9964bd37bc787f61374cc20dd36482840401de24097d9610e2cebc2273eb99c866134a25ad804b24152d751a8596914c2c01c5dd76bd388121d2171205614445f8166625ff79ed11b425bb4f50de399f3fbc3011c78da96439c0a85db5ead0dbc568fad5763c127c3be6b2a8c2f0ca463acb8969fe8480f289acac064b8ce5c024abe6abe476391f258a051486d35ca14ed4988a94ad0285dfb60772d62a2611a811fd30002cc86a296752d1dbb7bb4c6a88cdd9a5c90e99d02d6cbfc97c64dbcba749028e38fa7fc33030f7f6e21ae7e680600cf4b2a765fcc4b740ab6229776e1561eaf196adb281bedc3f8d10efd1df336468af4f04438d94987b88993cbdf7f143143dc6636a7efdcc838e65213a1dd11adaaa4fe2810ea161a1d2cc154c3c5c28d8898a7b8b70344edcb82ba762bc9c8b35cde31d785c59a2122860b117b3078339018d3c176b6f07c8a5b2b41fbda86c63a48f74cafc3d0d99819debd46a724e17656abfb21d20355cd0572a5f85612ec6f2b58486c5ba80811a90b9c69ccc90cd754844a53e49a3f507ccd51bd2d8952de78ca474df3543913422312024012c670e880450cb97a18033a464d5356d57d2f51f2bfcda01e5368d8db7c89916c773d4341f75c51a447d420089b5e6d23bd5eff3f439e7471418c0d8b68deedaded2d4ba2dda0d0c995856196d7766ac0a1473f5cfd9ef411ae7ddffe3fb2e76633c5d17d9eef36a420a236e6ab7159dc573b5156b91d4ac6687978703fe02861ab9b808f7aac5c5bbdb137e334e4a046f370c4ff51088ace0bac5c232a250bdd29ac26e8d7db9fa65f93a12203996726986cd1c0a1458aa42b16e43ac1321a4a31a3964e5e0486aace2bdf936f2bda43402b080b083eb1200b0894a64820c37b312138815e59abd319d121456276f22973290f406c61c489fa920d75dc084cfd5c1aaf7660f238f0329f8132369431b5e48eb67c612a3e336cec069afd52994048045ac69c7065c410d6278171e99e096a04e2bd23213532b970656c5a06b75906b73b52f51c277d5d63e70c7a2e8ecaf58c89ddaeaad68e40855ddf76e04d3f1edbc88e4093d84b3cd0fe67e88b983fe444bbcd88ccef64c2930e1b7aaa5be2cc90122816d0cbf48f0fae630ff71d621fda69d62042e006ad96a3bbd0588a19e65d1c8712ac8b587909209bbf5f009fbcd2e0935628a4e999635aa1deac96b4abf7272905cca58102d8aa9a8f80943d735ac52faf6b816aa35e868306b9d1fa2b56249fd644a23f49c73f10cd6f089bffaa859ebd3a1694b8b21cb5b0ae9f9adc17c23db222d00e04afeb2b980db309fa90700bea810a590d23f809b03eff7d30962bda5fc942057595f79e2879df7eba0df55ca77453e84a7115b1dc9427e9c6dcf20c99dec66e6cc34962dfb81a60498a40b84aa7b3cc04b973cd63b323ed1a16121d826c572db5bf4e7cd8a8dc5748741eda69685280d8c3c416cc87a983181a29a292b201e32f40ac3aa6d035c82543e2955ba01d0f1cd355b3035a18b72bcaa9a3ef6544de4a3729542ab11aa9590ff1d2f1895159cd3d46c008c608b0c940abc6f6492ae342c7e8c19072e896e93516d749b646de09cc355385753472a71310e4e5627d4bcd9455855c3ce353cc0efeefc5f318af3f731d0d26f7dfa9f308f0fa942c003c2fa7217dde59b746926d44e33031d1ecff9574d0b9e7f2e13537b0d167e903fd5dbe050e1da40618e7382a709666bff057b39b5373a96c1d6aff5a10546234cf6eb08289cbe8606cf75eb41eeca09184bbbbe27c334ee08f0401505812346546cb03b08fb6affb5378624228be5211f1904987d4c6376b8191e58634fe8294ae97ac9091dbc67018bbe695492668c02dfc01819d98a25e3b26be8c11891250211e19d80764f69c64d241c49a7f5b5700efb0e0218dbeae2ab0d41c6959ec1f7eddafb5c19221e0e57944a892b6580b8de6eda32c49fae0e944e8d7adf8bd841afa058aa9c69b1a44988ca0aa1f2e2a4804334c581c96274917e99f3098ec0cc8ec29ab4709aac9ea68a7e9a5cace3f1725010ff310979cb3cbfd06e3de92119c9f3831fae082e3879909c50c02c71dfb2e83233e1b6f43c0cadb38f62cee202963846ceaf67fb202cb1e9674b19abb2ee12a57e757bd8707f150350b4a52988de0ff06ecbd83561cac68454511ee69cad9b752aaa851cd63787db35e6ea54122436a4c3564c2058640dafdb67a0202c522dc68d26233e1f0702e8150cf955c7fc1557cc1e90fe3bc52a5750d85ca24f9f83a0576994a75a300aec370eb29877b107c8e656df2e7b990534b0c1292b3c4f5037f08d9a7e265fabb8c0296534b59b1b364f8e6203173d67ac9805d1011661750192f3907cd633db59a5673125d4f7c323590187c9b0e0f043a307e83fb9b22722334912263c16177a9bb3dcdedfed2bcdf53c5d4c32c8522d75f76d74208fac5f80259d1300bb2730c86b93a029db926ea0f0ce83f45347923ba25ff2727ae66971c9c2941ad5dc4025428db6afc1e7b72d7befcc6db16976584a2c66ae1ad676f6245334bf4712074155800dc048cd340c0dfdce0585128d1d53e0fae1d68229c6d70542413b1f4e5a4b9815be942c537ebf901d98158dc970a00ef63e77de541172f7da53678bda02c0aecf2c121a40bb9a91bde2e84442177e397264971689c0240adbdeb4e83aa18eb0b9cf6b3986c8a39865e6949231710c6e720cd05a5d7dcba28e2ed5f934069ee0b70bbdde8c7fce7d2ea26825bd40b5b3a04d3b62c8708898637e613a22e4e351377c95e0851ea25d85b9276850852e80b2c69ace512cd2463493a0eb80b91f2532cbfd3f910c1b2357a468dba2e7dac6414ce295f36b5bce993ea757d450f78950c1040ae921e1838a881fa99ddb27b8de1647364cb323cc77febac0c4d9d400313027c21d205b02820e85a0942e9e4047d65b9597dc26e14b95e3ea1586740e113e218772e28c21cb8042bb68fad17caa1536f8c7f54d816a02ece6e7b0bd09d1c487f32e55d7c200e0d036b473f45ace576a1de4007b639f3fe2d7e8d09e63e6c04a0bb682cb80ca0918b71ff16ae4e94bd4b2aa600975ba444477c55798d321a177506d5861c9617458a73d153b67857c541f84aafe698cced7e09c6600205f03ee14646461c63527d70843c690844eb7178b591122f849cf1a5fec5bc0f07275d5d102a440e5912f2f75b8ac5c11e65328970e9fd410e55cbf4ee0850daa696581b943869be35e431a472951d7c145b5d6df832c61e5f1fb95428764f2f1f1b13582570f19f7f16b1c275a33a04b370ff5e202e7755483fa0db6bc41b142a431a7ce87cd09d41154022c7e36581e3cdcfb81cc9c20aa2f6a6e362c766f4aead5719f2c3fa95ef972bd1fe7a500acce6c360455cc1535692a8d34f030aabd67b52ce855d67e3457b2089e8d12f3468c05403f414f580b41a0e302c1b8894a695b939564858c5c7b7b7425e1f8eab981acd58be6d2094cc98668ceba21168e6b6bc94ff870de594f041490ac3cc09e5fc80c818c95563361e5fc42656ec689cf182e15e4ce3fd8dee70c89afde7c072f5dce544652145e04c2c9f1e31c02299390224b68c4b44c3a1bb5342cb491900d0983b70594c132176b9dcaa69271799715a01ccfd72b9e058d9c991578fa81aa50f541a55db386a327fa6af400548ce9c2fbf495b9ba520b5df6b4fcb5369862a0d4f43464379c3fad7a6802f75782c5bcc9863c5354536f0a4c090951511415cb22d7d20e8152576efd513260582c2a1d8754d61515fd25b0d4e9ed72380b9e2683e62a3a92c5efe570b8995fcc9d620c46f2c1578f3c7bb5ca4805b3fb7984e87ebd06062b5b5a68fa3ab60a0dae27c1b5851e337d0f9e01a1f2d2eee0d74e092ab282bd7ebfe2bdbf0d419a8e61c615fb8a819ec759d4c0d114f17306584c9ef46b16f7761a1f0ad8973714897e3ff8632595af32aa4839d6d7901e103a5f1ea6a5153602d2d416128e927fd978eec93a40d438e5bf6bfd535dd8a13673f5b880a9f5ca5734526a4118b2b53fe96f8779ee452b36d3b98b08cddc18e2ff0fa1366003ea20ad894b4bfc2d6d3c73f7d4ecf32850085c4b6a0d97e17ec7e2fbe12269bb3de3d8c8d0d135de8e9f97a5ba007f91399e1b30457beb9e1ed01d2c9dd9903ca645f022d28b1c29c4c80bf65b404c16531f3ef30cf5297c8cc81e1907bbf29c463fbd4b997fce4a5c21aea9c78e732ec67c3f551734bcd1388ddf7a5a7bb1c10878359805e605fb4fa3bb28aac12ebf267927fa7e776656d325f74ba29da5c2bf3e97413234efabcdb51d309c362bae4cb685612ba04ee50e7e9fac94df9445490117765325d9d9cc2536f9576f79e0b607495e3e5a75285a0adee504b1a78e65edca0862f2852d1fafa4888d098df513802120c26800c93d2d729a0722ac8b1d43bbdc9c61b8b0d61551c6b3ba6d9c76844f1da1399d459cad53f660a5b08f37bd7b5c60f60a85597d7f9bca4a7928ffe83e1faed5b40776eb974403f42477c91c664ab12a5b8625cd0605719f1cc82b9d18a2f100b279901ab9f66eca211f23d9c51155bb0d67bf434fb9a5e52bdb13c148a4b4f5068124bbb1fe18d3efb69612cc1b021d7e7859da69f8af25084406f289bee11e19bce8fcda2beaa94e02b552dc890cbd8068f04d6d759d916c1048bdef77a5fc3f3c1df687a8592b0246f0b476c820d7a01546fe5a2f0fe1d450eb551a492b65eba8840174351856bc4b4b1af8062263f8685cb81ecfcf3adc661ca2f34dc6089d3d173092c634266b9df1a8650e8912545984129363f4db3caebdc130a758209dc38777ad5e759d4039ac2e68a3149b1fedf082deb1b436284a6c557a6ea1b0a3ac7a10206e4d477efeccbfc3004ae888dc3eaff9ee62b8248c68e66b66701c0da40151b2c41fb02b3a19dd0c40b30199bb13db63e566fd6af3e3812f469ed23341e3c0972cc6e1ac0868ce0043cee79f89922b14d4b9d40a7b4c5ce184f5850d4a91de0e6b0497598062604245d60b27a37a27eb37faf6e801a04e89b12b080f74925705cc9107f29085bae3a8c5d368ac4e1a76bffd6169eb1f314100acfc4923303f72a1425e9643ffba82c3da63b90ed822eb405711f21ae1915f8816051ea837bd335bc10c6a3aee24e0fa4c1323cbfee3062e1b00516f60e50ea2758f725fef3a27ad16fbf95d7958cdc20b5e81a44aec8935f4d17116ab8f59a24c74a55746075848b991017651d3d1a6b9e6185e591c0bc206856988f2f522d132cf7428c2b45b678aaa38ca5d2e99a80303b95381b8d51450ee7d40c4f18cf6428a07aebaf22533ff86f8c43c192df3e659320c71826e4060e945c449d008113db777a856e9c89050adc8a96765a74fb13ff8853936d1d60d98d764d2d07c0dab6f795719c8283d048424295effe0711e12214489a970351b55644541beffaefc7da8c1a86fdde7deb735ca5fe3123ee03034be9bccd4ff3df460a9e8f31be0dfb49116a5c3dde10d9c955479994d3fbbdf7051aa94da6ab5c7391dcfd2903cdb350e40a2bde5710bf582eeef32128e3dbedd2b20204bccfdf0b57754169b31d72825dcfe0493f17206e6b06103c3091bcf693e0868183eb34f80f00763e06f04e2e60abf92f5f8103e288ab431266ec594e0d80c68dba450c6ecbdf7a0a84d4dcbb9bc5b21866364e0cbb6426993cfe5dc03a5e61a6d62805d8c2d8cc44f04b4e07fe2b97f0f608bf43d47b1678e0ba9f5095e5340d492a795a0d9de9c398a79a9caf105763ad6f0c56d492989fa088729fc1d62b2a31070f3a3e7c7926761884194ef95076370ec4ed8bb2abe0fffd4d1e8fdc7bbff8a912e552d42e44e91bc82fdf8878098f5eaf1bdd0d8e3f4684e13a778d0c5fc33ed7f048ca2f9a82e9460767949f6c0ee7fef146590ecc664b28e28c21e309a0b004974d44447fd1ff477ed9403e08f27864e4d354aafe3bd8152a89610276fb71342a507220493e94da9266d2e0ee186e0a492695111dd17793594b90709daecf592826fa480300293785fab87ad630c430163dd2871eeb1ca218d6d84d52d58e8ddd4a6d510444b90db32b562d4a5e76a84c281630cd80a3c41468757100ddde4d28bbcf1282038984171203c268c697741218ba0bcabdcd5f82fd377a1eac1e09f9524ff0d72a8d43e5265767cb79ee7b25946abde2ce090bd38f907ab823cbb3ae3255e9c1bd27c8f4173cfcd6ce1136e908828d1199cd6553dcbaa45cdbbddfae2ae13270a5e15b11dcfd28c9f040b76e1d189879138b807a116b00abbd1850f56db94a9b5cdfa1c294ac24811992e510c463a31d8dba010494d8b77700b186677e94fae402bb9f69ce396320c1412f65641314b73280580872468d9671b0c546ddb8b585ff76210e0e028a98132a098d1127b4bfd7b3488a129bf3111144fe1ad63e085f9e63c6b6022b35a557a34cbe8f8d82c58d6f015ad29d46d4eb607fcb4bc102e3cc726d153d3c0657d4171dfc39f3ad31962629769fb432aa010e43a5c30b4e71c0d8ba124355c5b2a111280037569a63eac424322c432758f7a007f0962720ecf5915ccfe1c01eaeaa75969ec2fe588e808da49ce8135f7d4c51d58ccf37a9b8538576afe6218bc020731ffbbbfd76160d546f570d58bb2a9131090dd2c31967d66a471c1ff64f939e38dc7b4df8150bf4be18b58721ad96a177f577c3b5eae7a398e30dc8297b476aca74ca8234b076a5afdf339381200b8279e92e98bdb4cf4c0aa48af634ed738210497e6d000eb99cbf1ae704071a6c431c9abc8997c23749070d53fe4fd53838acb06aaaa79aa46af9c564305718235a758add978bc65d315bc0d01e5a2511b4bb03c3715973a4666b9cea3cd9b783e86ac224443eb948c2baec8c99d18300410cc1713b92202ca86f88a2f877128a81abd3b08057c7c25ea57f2a1f8d9bb974ac05c7ab0aa100df66600ffbd3330ce099be1dcc11f846ba69ec08b0c96b6649ad5fd96e11634260ddfccbffc49665abc458943444d0b339c4c445e16e114a3b6ac5c498107ffca4cf541b30c684729c16adaa0dc2460b8aea248bf7e19843503b9fec3bf7f1c6284944f6fc63016e6890f07fe630427eb0cb471f191e238a43f194941738a0d19930e8da9a553d3c681673a832e013911cf85407f0c8dea55c91b47c01179f94cafa55f19480ca240c7b5b1f372b6e405bae9495d32e36b698dc2ecc60353d114f89ccf724414c2d28fe8cc36308a5e6d4116da7f59aed50d38ba103fad4bbdd6f183ebef044732439fe0963305ea5485022c199eb4241ebc6f89dfce44bcae8f927d67ee80467dd20e4ce5955bd51f62dddcb617d399c43ce46621f6e5dd0a94c8c1ad655b532a43bd8cfbfb783eeba32618e662ab00c0b80952688a45423558401a1bf07c8f67ccba199db609c3c1d31db6879fb919e477ed6e940020665062a84ccada77f96af76587e404ef4bf562ffeafc45a14dc8b18a4129dbdde07655c940c27cdbfac313d04e80b032574a434c66bf19f9017e715220ee28f478f748c72190e61638fd5e763b5fef74318115a0d85c9264f6708e002a50fb158144a4cfc23658848771d8fcebc522942405345dfe00f9b6e8c19f387b13470d6ee6907606300300008382d4686ef3de62517c93837f2f60fa9347d211f5b166fe4d7e531c05c57210b88b29e56c1405cd6c9b153e3f1bb5c5703329037b2b254be23223e68746dab50bc1f25ea87020f2d95c818f21b63f386f41c0fb0dd8254155b81dee18cad39426ca90e4a535cb9e76a27a089b2c3ae6cf104e69ab3a99e937f4ae18940efae603b8817676e4d600c46d4e427dccbfc714dd5589f65b645eb9ff71c70f9c0374304ab21d76e386d628081d98f0b3ba608ede102340af0e9b9ef8226a8a72730635b0921a25b3a0578a813cd9db37dfae130e929edbd48b44d6453c29f2bea4c53dc358e8ec9a1fab04808ac103f8cb8fd59aa9992f8c241449b5efd1852f7bf1c9eaa003074815f9bba43fbef249973c30fcd29e5d0de69a4f6b6ec6cc12950ebc85d7ace1d0ce29d7095a3ca01db64cf02123814f82fc5bcd5dec1eb06582886a34249bfca144872ce269aaf50ea4b7e71ece906d7ebafa2a2bf81646f4b66a203e1c8b44f7dc48f2b90f5e7f728b3ae5fb89b6b4bfe90c0d3fac21ce81545abfc3f0d7bbe37e209b71310c9f53bbf4236ca4acc586a8a70341397f12344cc97bcd25f6c3ceee685eb9a35c0fad93837ca52af8ea92d03221df9eed6ef563b23941f87a4fcdca2dbba87a8c2b9cbd05a106cbbca20e16f93d3c26415e84d970bc54ffe830c866ab4549a12c23ff84645817219f91fdc101048256ece05958c0ef86eb38eca2b55a28e397904a0f8e0b9f94d39d49c689367610fed215e50d17a051fc26f14b07743aba98a218a1434f2ef82cbc168d72bd658550cb8c2acd8f3fb02ef70a9367ab085d91a51e8e5c4f2424ab56f0f25382d4c11903956da35da763f89e4da7bf91a9cdfc7a54ba3cda529b7c04ad2bd23410288075ef88b13a9cc07e5c8ff4cdd79d476666c049753515aea4c54fbd2bbf28020b6935e6b3b93a106d310cf407818ef8aa6b31df4d6d190dc20094924513cf488e1610899310ae60cf9946737833a074822250cde9288cbacaba54b3e124c00da42ec163955197ddb58e9375c0907220c93d4113ee729e8d98f6a34ef8c6713609972666b4f84e10c7f575742e1f6f8d641d99524446eba86e9b3e9ccc180ff0ec3cb40c8f2d8ef8e520e180c289d3c4ef298d6f86e257cfecadd1e4638fd72f611339af20bcc7b98b2d71b55a6c2c468412487946907f476278c10500512a6bd8386e0ef261d9b9d3f4010487bc45823b1f36ea63f71a06bb1a772f14a09d9b8c40d250b6b8ebe87d0c7292b8890da226011b96addfd8a75a04621a851d368a0a1879e22436408d11e66e984338db2662e48130ed18ab9670d824c80b189bbb74fe25b90258a03ac816cd00a59566ed2e7149ddd341bed866deb076fa4d0ddc32c0952815a633eada34deda23925d3949eefd2c296d2b2b801d502933445214d79399fc2df95b7d6a311add180500d0eb98a965cdad919edcfb2b456c832560370607c0ea605330a6a25c63a700760279cc1f650df6bc8b7f85776dc6ecdce55b4bc62eeca940663ec638412300d0fea94ca33064cb8f4e022a5fc8ff9b1a71f15227ebfd770a511be21f2aed815b9d27814f88f35cd51a197ee29273714c2ac5ad8f75a898bb44cd8571aab8f69cb2af4db6676db7b2f530e362b1c3bd0fb67caa48cf5df5607e56f78083e7137aa97bd7da13e3824bd3c5e292c81d26f7d1078a29935e05f7503659aa56271c5262391d6c8e2a08fff86c22f6bab3f3c1efebbfe42cebd00433f555e517ed822fdbd34de4240b79b5c2dff9aac290c3857463180f21591ac197e218244125fde54dfe404420bae25f8d781e28c9ea74a8c2f746d428ceb70243577eb03f8321ff9abd41e8e6e7a8ba6b4a3bdee9168d2ccfa499303d53df271a15245f58e0ba28b94377ad046138e287479d9ff58721587043af7c89b03210cc1e8249f3dc5f45cec07861b08d7f8ae5bc094b0a52c2dff86cb1bcce9644477114ee9b257e4446ec63de1b488b155a8bd9955425f6be3699c5d2be7ee10a4ad426d2a693d7e0ffc0e38d2623cab55f28f05c5557c1da59896b38c07f89f141a4336c304cee5c289e9a05581b0ef813fa1cab7026978b74413d261b75f6114aa1d5124e8cea8cc4dacf091128675bad07d6f2b6b55ba182d57cb5eaecec5a39c6479873e0e37587fccb6d07bb0544437e2aa8f2e89a548e87d3329626438df0f8f8becba8e0c41f45a1e4fb5a5444eadab86d8156b6319654cd1feebb1289a09664828afeb4adf9a5839d01c85a238ee5be9a24569d7146f5c5a9678908c3c4941c72b6666e42a3e6f4db434198645b9686ecafe52a100316169ef4fed55e036ccdc099afcf298d73bea505df608abc60225504566aae2b83d2a221de7657579748efccb0a7c70ba4a6d0837cab4d58e46f9a48a07756b53a1a5ea0f7635516b907bb64881c5731e8fff60097fe4335b275e56df9d80d97a7739606a23efe4fa7fb2dcde63ea992acb3491851c1f94bcb67a42ef5f7844d293388b315223cf205409cb9680103af2b223dcded5b2fadbd0d339c75bf63b19042aa77869f1ce4d54932f4e9b7a864a1ad8fe889077cc0c885ab105d6b4ea87eadc70793f21aea5e5418915951d3e7f59783e9a48007b1dd3ef033c6140a6b41ec4c64f715c6343507d05b88110e024350867ce3f6ed080e90e6d7f9a480556a5a70c5d17ae4ffef9011f769c763cb0941087965d3ce4b4cecfa81dc37f6359e4dd370bbebdb1cc895dd53a3b36fec10320f4b16bb39f2204210ab0ed1d5fc01cd489023914de7aca27c8891dd700cf07bd28c9278511f3fc2b9da833aef11cfc46f4b3cfa147b2977b99930c98f359eab14c71b750b8efeef8265c868c0d15d5175e1f77dd22ec47efb08c44930ce860d12497ea7b9ee5b6354be91e6d0cd85ac4110cf0d84e60855c5cf5c3a60bf42c1034209c8508d516a49e360014f62be407adb5165fe7e6d215f9a21ca0f1957a92d3bf40bc6687b37e8b90347d3e854fc3d06146acc42bc6e512bbcc7b90fa3fb627d5e5a70a3048dad8ac721f5f3e11112cbdcee5c1afd6d1a31d0a81c91ac1d6a50eeefb966737e3ba4728275dd0a300573c37a22470f859ff5db3a31ba6fdf2e5522b143ed2283e5e8d29ae429c6b6b81b843118e67509bdb87739b1527c63491df3cd2916c69c5f7e09c7a7e6cca493eea08c77144706ab7e5f3e1aa8525d3cbcf2ee1111ceef895f16818b06901c588cb4f71680c411c0a6e7a811ee6e71b0f5096304e6b2469cb131c4ab174fbfdb82d0d9755612428bdb0f78f85fb7dc4565580a61ab107fd4cc0b9ac381a859a8dac21d182c00efc11d842834289f2c3f487b761447d55fc6732427612a66dcfc6af7321812de5277a3c681f7200016c0574a107f1c133dd68d1ce966ca0a5d99fe1ea1a77e61b0aecccfa1273a46036a1563639926abd89d323eac27de61ce714c9b840849937535767dbc79925dece58c574bf4244707e91aa2fb9f26c01bad21602bdc064682a30e3f5e5a48c978d2c0faccef90cb904fd1e7ff7b13b67adcd221e6fa6ba7aa63d05190598dcc8e0a1b60cf58ba335aeda1d983b6ebedf045d4e77d11c2270ebb158c2655ef7fce3cc45f39c0a83f3d0e4104d0c88b71cc45dc235aabfcc9cfa71c115a9161fa08a8f946c2d205c023740cf063e0041d98a91684f080c5fdb00cf4defd83cf92a813f93ea01e1e91e33d8fc60769c8274b254dca39fbc8c2f2aaea89d0225eecad34d1886bde1d9066959e853474a71ac6fbb44714026c3b5af802c9b977aeb83338d5479c9d7ec01c86bd357d04c80e4eeed0564ede4b2444a99d9121b8a823934c270906b48ba2d1b35e0057ec2608338c70db90b3c77e5548a002d88fca8b68d07136a647de9d2b94a0dd8f2323c60ff2185237ba07efd8d49b4bd809bcd0b22a864ab8a279cef7cbdb22e0ecacd8cddeb6fc8fe24d94f2788d91eae144874a53abca9e1c019351654663f5ecf40e1b256d13a3012fff19af4c119a5d0a3d256c87e05dff323f3d89af38b8b6975abc69d3a5cfd70a78bda5488d353a97bb20805262c3884eec00c098c9472a9c17661c273e05d409c1d7dd569a25d0f8e85859751609e6805a8079169517dbb8cf82671034c8ccdaf73f8107d191a524d23bf0853acc1ebc400305425371bddbc230e35675770b0c5c27e0d59e294db4032b0fac21c83bb971c4a57242b40c14d088f9b0b3f6fd422a951da18b66a38752273df0419a74579e1d18a82bb8d21628ae1dfc1744deef83163062281099fba4840177acb4f68e4bc97c249f4a98c1e778eb63309528785e6ab1bbf9f48f1f155b0fa44a76e764e2b678c4e3282e9d386ee6d5e844981fc0d068ce827e092c66d7016f28260cae6966b6f343a2721489a3113fc9cb5a7b18044a2b3c883c4a076c01cdc6853036d4eec04ad9737bd327a350df1fbda99a86da8c321057903c15f54c82eb040daf29d310666013fc8c473b3242f8643d1fea179e1a3539d4bbbeec7579da5f2d0b4a0057639d682b1cfb7fca089c02b9ff52a68242802b71292926a7c2206572a1903acb4f705704de9f6be532ceac4a4b30014691d0a94c12096d7d4659a86061fb91228c073ea4b0ac2364351573000dd3ae49964dbbd915341d3c548430916af268b05883b15a0cc851bb7e755a0325a0b12fbe7b2c725484e50ee3087ff80c2ab5730b91b5e5e2bea2d2823a40a68745e75d0810cc1a5e9bb5b35c1c13af83ed9a1dd43984659e4acb80bac93f55b2efd6721635a0b3713048288f2a61c5082af585a61c621046c37133df6877d84e79f9d1fac2490de14c798440701c6d41a00ea2996e1288467cf08a7825e88ae82358fe05293ae71f91ab4ec498c3a157c01910a31cc017e27af57f926f1b4a11273342924f7a0d08a48b707560adb1ce9ae81fe0cbca97900b771bb5619a88b133157fb585ebcf264f26e0246a29126c18cb7692456abdfb48c1a102aa54ebfd5ba3ad107faac1bbe07c8ac8c4fd217e29bf142ae7d386cb0ab4e560a9db9bbc25effbcbfb8f35df51ab5e76fb81790176a6b84331800015895b09e8d8caaf5a2fcdfc518a2bf8a31ab50ca30fd6a28ab11f96ffd8a1be471c34613e29ec673cbe802e17373373d5b069f4d8a8531066ce2687f0c32e0056c1c5fdebdf3d163b32da327c74d45f97d1cb31e73596d0f18a3a0622914df5d2716788b3831cdc3bc4459bb9943150ef090bfdd1742ac89b472388cf746ce7c6e6115e31964d4d22849c1e50edc4c42fe91cc4d7f2ef3f0f66898183514e2b07b72b73ef9a63313466878209f0b51901ed12442924d60512bd10562b500965b18e8487c73564df6a393e1ee64099c13b880d3004e31cd1d3bf0043a9d2bc52f6875d7bb22efb00e01bd10256817ee8c7d02935cdfb4925868c2e556ff0a0252c6f80b41e3ae221a845b2e0d07188a6b1f22f533a02f2f13bf2fb06b317577764c40f057808b3138e21f7b430cb79f800f16f899372296268643d6c8aa884beef196ac118b2355181c687341856628a9fbda1222b327c99420912bf62b838599195d1763c1f7be40aec21581be1a12b2d7e267811a8dc4e0cc3242973a15308c24732306a05da8320926255fec276050ae29782f8eb2aa510f1d55d30682edef929e6ccb5d0342f4411187407021b5b11b61a4922ef93e94ad1abda2fe548c4a81b79c3ff4dca1db0984345ee5a064d070d09c51b7a89a423e97e198c75d99d0363112df24cc35c051bd577e3e6f1c4dd0b8d66a5ced9ab0648c8dc6ee700d445c3c3e5f0368168ffcb0a13e21202bfd678a94891c7be25fbc7f8b9645fe645c8e2de4060a0e496f2e1627673064fcef19ce19e313c1fb3384740fe77dd6155804e46fac78b905d906ea28b7771ddfe2cfaba204eb48d65c1c33e2c93830940ae44e5abf50e0c50e67c7b6500dc981f7831cc7d421a9cad4119787c1bee501df5b3e419006a21ab5cfaec44c6b28bf082ac31865784d732ad407974a6b9cb3fc788702400bb233c8250dd636e4cfa559e73dfdff531f7d151aba75b13c93d007702759d4a0d5c7053d3c1f84a46dfeab5f1782e766fcf738eaeb2bce8edee1a08431aa0a2c5743ed412a0d68208398d503d0104080c86bc3cb4901448a1224f9d4a57e49cc5b06a2357ca97f13fc3067a72dbb559af7f347983854a28597e0640619c0faefe4e306aca40c6c836b92aa3935154a7d2387994c9eb371374eaa0f64c651ca76eed4d2683286ec2a6c648e9e4b1f69aa91fac2c083824a1381c583f369b8069c1df44e799f0ea0af8fafadcc2c0804db33a7fcb5e324d55f4271a63d70ba7ad9ddbc59e440316f1ea85ec74e62d1d5a9200d965145f1480d93791ab88bdc71cffb508d587e6636dbd7c447f5416f087196abf41e65823eb988cb9341a9c84549ce4856d4d35545fb1936c8003f2a637751f408daef9dca9bc63121197e57c1133520e770a5c19795d9019c9668a1546f7a318b4ce74a0c49e0f6363ea597e60c77db1c54e20c758c58ca1e30c27a22e4304be0207c5d18d246253521d122c008222248bdae69217f5bed647a6b6df7b43ed3740c8f2cb7d8239e0b0f2fd82253956b92ef29f123b034040c8c841b013f1cd23f3bb0b2e595d5862b560d52fc24342b656393e7fd5ec1220d0b97ace46011d61c31b2cbdc87626858552362dead4bb43feef46d346d8133c72f9f09786356bef5354ae1d1720be9e0e382cccb9215f514d52783d63749d5bcaf56d9287cd287230339627380ea20a0850b5cdc3c4cb413dbfb493f34c827670404e281f5d34b80e1cc129f2e0c99c6f3bcd475a38c10e261d22460f6c68e59c50c328ebc3e069d1bc1860c69d3bc3f7682eae08874ce7f8a7022e130158eb8488c5af85590e35a53dd5fdf54d716e3e7713a331151b25386de025b0eba5362f4b8297d66ad5e6f152e9808c7e921145ec445cc0712379bc324936161c6f5cc4cd0c353c12683aa6a424a502f3d78c42cad6a5f4b7db57d0c364e32b3e8d8cad4d01c6472a33f002257cfd7585af45a41084f932c2dfe8acb5b8822b79861729ee055ba89b96fb025d7a6de8bd9e6297dd89fd206e4fcc209c29ea187d8e496333d2789a8a6dc5e20ad045363805188fd2d43aaaf9aa99d066429916e81e1227977e065a6ae7f3b85ca5069a59dba92d96ab00fd17203a110f5b9892251fa731b8a8494c2818734315e364e8366f66f69170672ed93283a445207fc617244e11ce338ebd22d5d7bbc5b4138e2b9075055f91b5a28741a71c22d857e07865504197f63c5c58d9b4556aa6b742fd0109fef09250c4c4cbd037a2cf9a96dd8f731ac821c863a5130bf5e0f86f498f5d22554bf1552200f753ec72111150b412f80e2f55aacb764a9234525c2410545c445efff46ce2f2fba6d58c3fec874e694563b8350820d4af9fbbe6ba6d14c983b3b6716b8f26cf73457fc576ed54206e8eba3ba6b25b9cecf347d9a06edd2a3dae8ce97035fc246050206568ec815dede61d503cff6e9b7753604cc70bcf80404082eaed037f629d3fbbec371e7a5a077ca0d9b50c9d38ba11bb4ae6f28032af931d3e183e4421c39c91acf01a99d6236755b914b8655d29fb86c0e543569ffa995eefe52d2342bd951147cb1a4bcb4cd4d69d9d080aa7bd07b57e15a0e0ffd8f96dddb49381bd0ed88defc964af041207569e67777a449d6934dbbd359bbc45a4b8d218a8e9e6729fcb26169f74204145ab9e2e67f9ac7569aa9e70471d0c367925e9932c564828a2ea5c91f7aab2415285edd2d224671d34e54961a5b1200a25754824a3fb596b699cf108b538040bf2f00d43e8e158f36ce6a77079cf78978d94735332300a5c663e441ca07c7415f7582d52cc565fe08186c0939a0a53e596b62a424cc454683919280a218f8e21d8fca2e0a0b609bb035413167006be16a1cb9eae2f76893444efe8fa26e0bde54e54cf682a6f91a0d2faf7c4f31d9567972467452d2524982c6706b242d35989285902e7503c14fabe5aa442fef51a200eb495490e6a397dbfc4d594ab7fae388774a3a775a3da383e650521fb5936b40b0beb12c1b87bc088328785b80981f3510da3114697643df3d280fb6608b84ef69a7a5904d489334ef150a74ceae6ee6d704ee2e9baa7f4281fcb16f4bf315774f49ebca369678186912d871e9cd21f8dcf28eed11284eec6be42140e551dd3ec59e9344758468dde9e9ad00caef1f03e4827aec27e46586a51de2d26fc2e17c470ea67463130669f0c6d34224acc32458e2747edb44ed167f33fc2984ae8d0e75019673cce3130e6d4f549055ae941a0c6c464519221f73c728bf376bf0ee4e680da75e910f0f618b0a3c599f425f67acf2c31f6fdb95b38206ff8eab309ef755f3c2c31965131f290fa771851352125e7a795c08159c6dce4894d046aa1b6a2af7c19d8e8431c5ebf29997fcc22b7841d2039e5ea8c01195103574b2800ea16fd15388780eb1bfb2bb052062be6adf61884f043f871f9179681b40f2edfb9ae04d4f09fc1df56daf2a5c651f6c1655666822177b1f6c27b3a2bc5d5bb46476eac65e2be24e6095e162c138b6d46112c54c97c18cddd5069b836aadd18c1112eafc6ba8a044e07fec0b57f67cdcdd9cfa478890ddf61ac7b04c5abb47bb8525cdac4776185a100e74d6e95b92c1e8872adb07a329c9a7442f5ce4895dd1cfede15d6898a54b063d8d87274fe88b3149274b56f75f5f6bf5a6ca9999611bfb2e114742f96c52600b11a4a4491b09f046f5dd3a3e546f39d177f561aa35d884e49af9c0e2edf900849213edba22e252d5767ce0404f8bcc4f6c8d974214efd982463a94e769bc95ca00bdc88a5f62f5257e62f2f5f9f5d2faf8af85073b11a176cadae0c413e57cfdd23803405502679c8ce929c3fa88cdc3e0db896d470480b1cb1b4b47be284049fb79e04ed2d7396e927fd383716a55d6a9a1443fad25ae320a87ae51c06ff44a683636ef354d841ce451b79e8b5e896684c22ac6e54bbe6f73a01c8613cc80d52437bace8c0ff8b7576550ad2043223bf59fa7a000983d56c3a9eaa428b73e498832606a1cb8f3f7fc3825548527004fa224cd934c06a8d82ab3809418f8adaa2892395419acd0338386b6d1f99754625ce03630924dc74575cb37ea3b4151951fa9b6c1d3ae4bf689489fed48e86078b3827d37421ae1d146c4e9569bb0274419b72661c39b43376b9814ca79f2fa7b28ed9e04a3d498529413af3b51373c16d0ce9450d6b74137e12043045b530713d5106fabc45b8767b30c11ec4c51aa224aa6baaebd9950afe32c82ea597765fc020b567f681c7247275e748ef440dcc1c3463105d35b2ff94c83e1a73d2ce7d1fa0246bd20bbe58a97835d2830278bb9406767c80d8db5d849a0fa73d95e06636009b583e7a712e7627a64cfe5866efe2176890413af4637fa870f6340b501b0393a8c5e4a71c4e71f22a594f6eff9c74f26393e865cde5313fcb432bc99f000f1c1bc69b32aaa99c3fe0f1113f83ecd5a65915bc41db9799eb6b1b03d0fad3c6be77919ab232e9b6947d02ca6e3350f57b46f4d0068c0e319de44b7823b5cafc24385408f55a95057109fe411d2d77421af97c490198168677da6e59d8c469ec699bf93040b851a50d8f57923a2b36b25c5024b84f7225fd6a9c4c76f389dca07c64fc1987d8ced0694e106d58ebe39a001e471f1552b831b5f050da9dc19fb44171265e8f0e1696166579104b09bbd4ae41efde8ce8cf49f4f0a987f9120962c6123d25008387c6383b252b2d89435dc002017675f5efc51b486213c6608dc104da9ba66fb31cc044229fe9ac5b3db9efd0de219e511893b408d3798bb57215137641565d5ffd5095841b7a3ba6c4502fcea53910159284c2ff910612f2fdd2802d1441b242a0fab9d74a3fce6137ba649677933de48ab67d9ac2ccd62a31844db8db2016fe6753f2708e37237d8a9beb85c71e2d981327c33823a8d4207df0b0121a4c38badcc72f8f650ad8a3f1c964d61410a553c7fd5350e43063a438adfff5fc929b5e6e1d0215fb11cda94fd962a69645bfb0397f2dfd9c1a2267a56cf6c14234184b7365e5b880c9ee6fbd5f5e300502344afef7ff8add0203ca4c7e021f0901f5b79f2c99745496a16dffaf962d4bfe02aa3b4fbde7af311ada018384652168fea2579738ba3daec9a2a614fc1bc6bf633c5e4b5e9c4c29437885f927690cc55887aff87bfb58dfbe18f087a0d0789d4a454be9c37e733f6a39b1a14ddf0acc8c2d4c1db96b3a42511a01b3ab80dc2c50265493cbeab9534c8fd878902b7846b72cfb4434a63b67bc3ceba0ff42bb8c552572a560c04e9c8b76cbda952e23031faa0c39db5b158833d958451a9a6e320729f0b40c69dac259afac3ecfc852d05dc22c71425d543951a6f592337fa9c4d51b0306ecda6d23c7a6086fb5d96564dc0f717cac82b7679fda27bedb4d79c118f66cf64873e374023a55e29389186a0e1b8f64e5baa7f0894646129fe468ea9e0b39ca15be2343988e5a85344edd1fab58be7d8add79eb726a5d0544c836029d6374dbc85f93636cdd0fe783485e42d708c13344d208a9eb57a0a2bf368f9f1978efb3fd57501e5818debc2d3281d176a029379b0ef90b29adeeda8249654530ab16f489d43a6f8b04fca74d48d42d44752e2206c64e5185b3f8ef31667ab347b0f4908c8e963fe49d5cb246904ec6bdd574d016e0034701acc1c75c86c1c0435b9306473cf8a413794fb46840fa559adf12dcd7c3e09f86b7b17c912afeb705c395eddf457d125bc23d745674d3b7be5ba4ce3b9464b93095ca11bdc6a65e3e3470f2c834caf76ebb588c3fc654af43cfde26a0e0ff79626de3cd93f5f8f3ba5fc462c6a9928914ab0f2ba7ccd50d14d4e567e2e9b4e1e50f60c8151d11f962ec175609bab069b70f93b158618d416064138b4eae630bade7ca82bbbff0f54180b654ccde3528a950eb43bcd0cd30d5bc488fd5123ddb8b5dec0f395d73e67ea618a501f0a3d9a31d04332b92e9af355373c1913dd5a98013cf8f2637beff06462c9c5ccbec42e3237bdd7347374d9b3b16940be20ff8ca6119368087edb207bdcd6b00cd245d9447f9e92e19548e9fcf72ea2a8a6e1ecfce44af6864a9758b5eccae389e33e742f235ca10007ac79942f4cfd1e200320af1c6c6938516268d3823bb20f53b8a0282c6ef2d9a5dc3f0c9926685c3ec93d6a488a6de61b2b57271f7b05a997c20a87b080fdd8c8980c4e600c37845a4db55de43b023e646074816fb68e431660bdb72db70c661cee0888a9db65fe98b8a1d574b7950b5e9e51b24146007a2afb9a1a7c8352a10edd1fed170c93753848c0f70e708c21b552fbd9255ce646b2ea69e1fed9110a015633d987ca8fb6b99fec50402a5dc40d8a349a4800272867b9ae501fe9a94fcec2e7e86a209210d9bc2aab338720f9e28612ba1ecddd5cefb91c7dd5902f24937365028a879e11c17a227b2b38cbc6d2f79794ad52eab5d1a98ef13aaa3e22eab5db0c753e1ed856349e3a07ce6389722be9fb40077ecae38bc3b619617e61450d276646e5879c70c1d9ee90206960e470fe5da9fe925e8adb5672f3a7526665807f031d960c749d6cbc73a0ee040252e87ffaf36703e1bd29e1d540a824631f2418e7ffc8f7dd35c9327d0fe1373d08755ba1f290771fb65ea28bfa1d1ce24551743ea2f5f9e4f2aae934d870afae0dd1273bef0c2d6e85de10d9b59b601d7e3d0b1933de33ae204da73b335c366dc9b5188eeb059f7a5c6eb2228d41903c0859b0ead3d901868274fa4068e3c813d00033741ea73c915dc548822d584e368c0afb9c8fff7d4650ae2c2051dc60ee3eacb4e37afa2d870529cadb159d725835f05dcd2e56e16c2a14855a8ab285d8cc94af527e35605952cb29ed045ce53ce96d3012d2b87cb5dc9c5940688b2ca999417e43f13d350ccf33f13a8c24599a177032b13fb0a9828bef842959b645bb4be9843ce7bacfd24360f686807e329afd84902dcc15c93da620e0216276e80ad7e32891c526510d878fb53da51ef66f25e457e971c56158744e306d30ded17ba8cc9703f94bc2c663ca5456c99988df30cba8a9cee778d8051fa62589b34b0a5bfed80a7ac5e9f8b8067c0676581436a7046a87e95aa70532b8a9e64899a4a1d79d4598b914dad5df0276cbf5a0c0e6bf643dd2fb9ef53ea8e356417cbe71d05b1b81a51ae3ddb78995c1490f492ead7046b19c5fa0ce2c89175d9010c59bf2695a926bcf96ae79d347fbbb8319e9c2adb28752a6b9c1fcadad91d8d95b286b34326808aa6903dbd806fe6e7f1c1e899571b0bb4e22296cfd7412783b127b1c84d762e11ce0ff1d7a75752e198641454cba8d94192cda93586a6988c8ef74d97f6d083ff746376eaeb14ec5a1d6dda6ef4f261a08acc46032a2bf9b970e7aa8f6a6c4d7857d1fd2290477ee669400ed6f746a3e5572b849367d029632653ab6106db9fd2e639531b9e1098218a4f53473e2bb3d165b365b04f09cfcff0ca8b42ad7dbc66e93900b90020d984e76b5260a7658d0826120c8087850a135f7fe5fd8a30b2ae7b8c3d9fbcff4558b267097dc8eba576a2270ce990030638b75b7d462729830b5b57fa46638c6c00d6dcab8381c768a80131ec9b059b39beb66a77973a406c9339b06c4f376df92b49ef6904e741bbd04417a93b388909ab029f1c5db8a19525995b328138b99748ea71456e7a413241b33241d030ac8dd5d5c4014163707b1cd0e9bc5f1b25d7fbb7c3b7ccc80b57226f47da9cd3aa090ce9aed9b97c99f4b96b177130434f5f044b6c3c5a68bca0835bcf0b8df831fbb12c7e6b41f4dc96f61b6636cd2d67b4a5f804ff482464b9b244922654a29bf05cb05c2056384cf83cb4f3f94103246cb4b5d903f84b0582e44878a344992244992d5e52095e2a2bc4ea7d3898ad39f2845013eddcb896047740d85c169fcd3f79c565229a8405788ce7890f1adf0991b0aa3846bf6fa243ae6f35be130df666a2714bf82f37a2b5e892b89a6b1bfe4a7782856f0a753105bc4901fac7be61d03d608a5ba1d90130cc33014eade7befbda11008a6bcde542873280cc3300cebb1d1aaa27d62fed80fe5f90976a821b06359bcf7db7e58adddba17bb376443947da7c5d5c2d9b4f628ccab04d134bbd429ddb44dbb30f6bc1cba3f346ddab4bb5bebeead9b366ddaddadddebcffa4157b0caa7e3b615acf2e938ae082c8a6cbeb24c4921c6b53056f988e83be8de2c5f9cdb40a390f320366299ea609867bfee7eddb59b356a35ab59cd6a5ab679b125d42efd9ae6477d352d13d9bc5cd1ddb4e9fdffd13b2a84ebbaaed369752ff5bc9c413014baaeebba7c34cdd7ce78c576180dc57ea2e9780ff1835df5a0c0758566d14f7ea233a09675cd3753500582601af4e4613860f04070030e5f5ae6b305b5744c0aafe0eb743a9dacfd0f183a6763a6f9add6b71690795afe7c26d3667295b7bee5262c302569134d9224fdd60a0fa6be050c3de33770d3fb81ca0b5306372440cbf400402652355e04920973349fb80933796e3299a6699ae6bd366e4c9527582854ea89142567cf2a8a8a8b8a429521efba2e123c9dd05ff6b9f8d59b0f9a977edbe72821b0d85c847f9120830d5b506e830a19a03df4aa4fa1de7c93d237e99b660875a25028140a55832bad8ef58c45e061be011df33561cbd0ee017bae39d3ec206ce489f59145318e23a9ec1142ea9c929488d47154a94a6e855dacb550f073b57a900b374de747b221af72d2b1dddc60bfe1bad15123d040086b0e1e3a22d034ae23819e711e1ae673d7f9a85a6185518676e27ed241142fc2ebb9ab1fe4018badd27185d7573f198ce3388ee3385e570d1528a59229c584086aa754723a7215e148bc896badf59215c287b8f9f1136ec4061a7a16fb8b8ed263033e680002dbaf827e72afdb0e158197c475a7c6832ac0a107ff93826b16c130003d2a5da552a9542a595b23f4b182529369753b462514ef755d2c2ca15333b78897e4f2b067b25c696a0b1fa92762a75eb2104ff53cb8036aea181e5c3f2f91c254c634454d2693a99e40d44a92e5ebb85bb783cb5ade9ecea853601d554ca1d28131de386d0a3c23145b955facc0627ec9c2c6831d8e500a8ba1971a60f1caf0b2048b311c80d6af069a3d50433b096faeb986fb7da09d84f55bc15361d1eb3e22f067838733c24c099c4307f4491e29a295003f797af0d64b02f2b390b72b14c81b9ddc2852a6e83c89e61ee7799224499224795d35700f1126241126b2bbb3ceb22ccbb24c0a07ba6bc2e17b9b841d8e8cd20f94153e9ee79ea184a29b5ab2acd600411908d10297f375bde0fe8944958a2442d14d36b250c846e0ea50c500080eb836290cdb68e0b1ca5bfe1da41b6e735296d910bd6063ae80715374a4d48ea4b247888e3dd924b66489849fa91d59cdda56f762ec7939836028f494d2cb0bd15014fdf0421e0b13d833cbcb711f98a8cc510e904d896ad4ef420e908da734e2c9329090115594463c58f644e3687f9891bd241adb22ec108b72c933f2f7a8568764c707ed4841375c21e602cae1d9b1b292735cf2ca97b3925b720e4b9651bd3acda1147ace096b761790e6dcf6e9724e0ecf0e973ce3cb99915d3e1a38f728c725d3c026954fcce1f4c901d57da20dc78386f64da0472ea01ecd9872b30cd4061ad6cf0606b8645f0be8078519594dd33444f40c2dcb233a0b7a648950a435605d526849672e130df3f9f244d1636b60c78eb9453aa67e57eb6299acd0eebc35d99114beafd81213987e383f6c18586cf3e6871d473a8ee368473b86f5a654bec5c465cce639cebe8481c57e02e4ad00e28811977dd019f046017bc6403cb8669b5da39a96fd014a53f46819759a8d701f298fb68f86e71e61370f9af77bd22cc0f75e1f3548911162f5125493f07307de65027f7ed087b756268c18b65ae5ce977b2f4bafe15c86e3388ee39274ccbb736e39950e24e2bcc6008d002e947580451f3fa1180a49ce43d770dce751b4cce71b8ea4c1ef3e97a26368a87d5e96b4c440f9ef5d89810b748d972e43c3e5cf16f09a2d7fa6a169b416ab9de01a2e53eab8da0758995d1e1db76929cfeeffae95e3f8abf1d3e273d9e6bb5ce3931d3bfed4f87c3a6ed340b563ee83dc83e30a40d45a315b310b002af08cfdec9b409b66c8b699e301d05371aeab063686b5f6b2172e71e05e620232c4b2e7a74df3ee8e5d1d0e232b39fe23f41bc21a7a156ab889562d485ce9f02af40097452c671983720b9feeea64c0fc13b90e33500ee1e59f58f3f6ddf061be40349c7b98cf5912d8e66be19b45d1a783a11fccb24face177307c7819592982455178896c3c0c58233472411882e3382ee7cf4745c64ade01c8387ac99d5d724bd6998157be729917508f3619a097fc0179cba7e3e35df8cc92678058be1ef28887cbbef21a11b4cc679719f9472f2b36bfad805eb20c900a885f5436caadf4c8c572d957befa924701957000298c4acee7c301c85683114f96731875c7ccf8d1c67d7806b843140f057a84734b969157f2966f68596d2e777b6e9101bab7e5e215efa2c16081d24858ad3c2e832151ce9d8d037444e066078fea590574298c73ff29dd2772b350bc95c9dff01f7a8696a4a6e9c65155852af543dc756ef62cd2abddb19a200ca267e8fbd03768e5618817f40dc2a6f1ec45150d856ed131d46c9a6adaf19a9ac4445b49764c74a6a292784d6de2325d9324e19fa087a84dde888ac52f51533fd22fefada82615559b5cd7a97bc61d46afd174681ace344410f4d4343f6ed1338fe4838ca7919ec60424000441a01452f8f154d69e9aaaa8d1666c4ad3383d62ecf3c7d17fc450972601a24b744c915a83f0082a3c8d271dc6204174580149891105a110405c25741883a800054200319ec6244e2f40d2848d0ba66a661cb78e11bd70aaa083b516afb0788deb0842a967169ec01f09bc0061d82a40c2046038c2e03ab88ceb8c54e772d2785d1876eb652d86a9986853ead4bbbbbb3f4702ee8cfbc3cf0a8f7cd499d6ca82ec89946cb56a619c1287cef4c595d65aff71b390c2a2af2ed18d274ca9b121464bd42d9e26e76a85d918f4f0d0d3c3c3e8299c9e6ef5e0ac56ab9567c3f3562b4ddbc14385094f7cd05a6b075e7c20c1627e5a6b39841449962b2749cc23aa26282524e9799ee7d119aab3e309c93478244a0025144956b4472b27d414249df1d6553eab758d17293c57d4ac2a3ad3de2354499e4ca5195a928eab91349246d2485a95ab7255ae4ad34fd2248f409e48484574828c438a189d8c41c62145ac56abd5494de7399a3facc6d509c6d8349d3a72498ebc7704d8cb28f8ca66a8cea7d0353448cbd0d01d466ff452892c91259205631ae487d2905211a5911c499324c91a42a10c8436e083070d3d42a150284492a927caeb254ae45484f49ef968d7f38f86f9ac7d62163e97826635ab594dd334da1d734ba552e95dc1cab2fbddeef77341462095600123e89a175c4648d35c3d3c55ae3b991052a74898f530cc285f28c153e04678145fc251a46b4631cd9b8186f92c468f934422e517722691346d070f179c4a77777777f7aede1ca5949abc887690144c24f426ed0799fbf943b52ccbb22caf4b8b5ad6b2a2ce28b5274935ab939aaa4c52a9542a954aa572ee546aa351c4094a52a32fe2c4893412c1100b5f60b1969563a10a7cb5b004ae496a595b50026399c6f5ff6421dcd6a2ad90b5907a98cf57fb52a48ff42454288a42b196f553dfe2add042287eaafc944d7d2af5292f371312944ca3ebab9ed37c7d34bad68f8528b85d86e690f3c341f4aba74e0b267c7d622d3b500e38a168f30d34cc58ca06a7b0c32e7767013c8ee3986b78d5fa7d8afb5ec9c37cd674c01555cb0759080277e832b496652dcbb2ac652d65144192e5ca4912f388aa094a094692368796e18ed13e5c75d0198c1f80379017587452c454872ac791cb95640c2d43438004e1cffca030ef425ce603ed76bb9f9bf513310c046088816878ae76c7e7a6af78d4ef668a1b5409b502149193c934dda04c138599a6699aa679af8d1b53860e7ad5cda3c70668e8a6d775b917b829752170a61fcd1887563ce86ab55aad78d47aba529038d01ff61867173dd0a104477eb0d65a104c65daf54e5afeb30603b30985301b1d5c8a7a201f6d1c8805284001c228078866c5c84d9e032a48ce491afe7d3e2f290c0cf7f9690c8c41e1ccf12948be388d72806c4c588dfa5d28401023ee5df80ce47918c268bb3ee0365d7cb5b68f9447da47c39a2c86ad5adb9349a8ce94a73bdb7d9bdfb66ddbb6bcdda6792c14efed981c83f79d7b3d3f315a5a71ba7165813fbb3cc1a2ef34cd969f07fc7da287bfe5a7b67d94480fa639e557f48d2cfa86155e6891c2c165ada67d626bd9d5b0ec6adfaf5ce673876a012d4183bfa24318117eeba4a413cfb2e8e797bfdabe5c6ddfafb45c7e6bcbb9d5e556abdad0228b89f9b39853df2a0974bed9b42ca3f289f77e3e11e3eee33e31b75a1c07d6e898908d9b8ed9c1e3069cfaf9171f4c96144b88c565064b904abd7492f4141c71c4e98b68bef32e84e5092c9fd862884159348bfd84e513fb0cc72c7379cb2fb0e4cf083080ca27e3dcd2322d9fd8397896ccf26d94a394858585858525b3b8cc7099f1c98d9f252443c60aa8c683a18eb121dac183860771721e7427722ae2a907959832be33a2d66aabbd31cd9badffa7c09e6f9ae69fc98366c7d4d4fc0c5a86e6b57833090ad5738305169dc6cdd987606b6cd3b80adc0c30962fe87234b016b4125e1f17e13379f0632c0ec2cfbf45cba85208038b7ebeea513553b106d488f5390163d96607c9086db6f92b963021e2a6693eabd7da0e862bd3c00f7e06b984b7090f839d5074d62545665d4e9e60dfd9d1988096b33c03368388c27c773842e7953dcfbccec3bc83713ae974d2e9a4d349a7934e279d7daef499fdc8e4fb890f8f74b9bb63185823e482c4464130c46303363616134ada41d0dddd6ff0d07bf0114f8e0ffdeb4f131004c15a59250a957a2245c9d9b38aa2e2426b8cbff4b07bf66299a6699af61d0e2c7f56bbcc65b15bee99cacd8cf33a508f34500db31e7da77d8ecaa080b32f14ca26ca35bfd84d09bb37a29f348d4816ba41a15028146adb68183b1b60ac29d87996251d3a9aa63b555452809df4b913bf441be91bb507e572a6046dd206ba59f4f30ec1dd24539c43601d55879f5ace3e1a375aa641811e693466c83ce20c00b0e234d241013aa91110da8339caf2075a4223d9870348619ef6608eb6ac65d1f3c126fac66e6c422ba1c15f3dc10b25241fc10ea7ea4b4c4cd5a952a2a4c7799ed8799ee779de7b73aed06064b15aa723534c52be54e4c717c2627dba4fd77517cbaac0a2b35827d64a7edc7d3eb9eb3e9f87f38ae7173d29fd0cf9e17c92c56ab1582d91889e8e3a4f2ae564b59a8613f2319a46628d45cf9375b2ce2d735974161774c5e4c1a74d5c8687929e22ab7f1485d1314d2a53ca4404f53bf74fceea4c2c16cbc462b1582cd655a38edbaf149165fe2b58e5d371db0a56f9749c870516a909cb70b295560aadeeee6b93650765d9b5f9db319fafc96432994c9a76a2678f55e7b8accd19e833c34d7df4394ef843d163a1891e9f50f44e9c448e1a7ae17b87492c7a5ae81e9d494015de0cbc2d3cd149abf644777787e82a1402c19cdbfd5d6afb1158f4540a0473f6ae86e323cd5d9645279908d08d1e0b23984b8c48b14003dc581c0109967b7a1eb4f91b7d39b67d46ba8fcb9a566d1c908d38fbbcc44ce025f0767531d40bac7181dfc5d00fd21c4225a1b761437ed5cf895d951281205523b50245adb56bfb05fab073dc0812518c2320da1045463c9e37202ea8afcb36713a91669323aa22292eca9e7b3a7912272fc36ac7dd8ed3a8f0b8ae0b39bf3714047a825fd0a61c271dfcf9860ff866b7375eb361b96e9f13d1beee98eb52b400bb0ccb1758ee220446084ae8c6bca75396ed18adb5d65a8b596b2db6c1808a2a701676a1e88516eb70703178775805d8731294babf2021438c9aa6691a160aa5f22766cffb7080bb58a5a0ca543e1df7659fdb5d16168c3d2f6710bcda6adb6a846c885eb0710087459bedde2d9ceeacd2dddd38c0526ec011515102a8e85bd7759f8822c5eade7bfb2f765d1fe63baff3c511a81110059cb45062b4b9d0e2240fd2329f7750e94174538ecbbc7773c4eedbb13bf7ee6022d1cd329ed389349b1c5115497151f69c4e2b1b9b3055390cc36c9aa63ba92801b2d1d3eb7ef423d2ab4c0394427802cbf7c222a27f813c9d5ab4568e0a6b4dd3344dd334e94c2804821e78c19013312851a31c200ad0190269c4e3194808053838473c5a1645d67e8f553162cff1bd9c7212e6eeee5cb6a00fb492d0039eb9bc7508702f412215f61224ca5026ec25488ce193e4c665ff9c84611223b9ce45b6c8d8ba2772022c3ee9650042dba3cb2d1fa8613cbb69e24fc5cd2fecbedc315e2a7925f16710be8b5baed7855d6e5a1b1bebeeeeee9fb5d7755dd7957178c92e19072fcfc88fe401a4977170c92f198719d9cba4fd8e86e7195eb24b9ec1cb335e5cf2f5edf0f20cda61cfe4cd57758c0a26f6e5931be80554432b096dcf0f7cb8c16867809e04b9cc7814280c7bc44bf2c12dba00038a49924f3ec992f1019062b3eeee16ffaabb6d60791865fd70d68f1387fe1d8e6a2ba537887af402ce0f51005a851911dd116a02d0ea23882602167fa2a1070fd66a87b53f4c2c168bc5fa11b2f1e1a1564abfd5067cd46bafa555cb5b7655bb691976dd5aedadf6baf7da22863ce6ee8e5dcc8235b831fcffde7b5d49ca2ccbb2b274f7a157d7d5ba4a4f728328fa0676c3d6ec701922f80f2e0dbab0fb6291893c51c64cc6fa86a57d03cb9e9b66a84a7778749e0daf2357b0539e1efef59fcb4d5c64714583249779d702085307a1cfb235e2943c4cd96a95996e19966559869ab68347c912c4da16ceea455d6932f03ea30116166d1b823ddb8cd3575f7d5191c5b0ac0a1004310631884bd6087a4813d137b24c81f01f7c6479211c08acc9215d7f307a66253fdda125238b0f454616df0832726733686615460d819587fc900a9272313e2b327056c99fccb29245af594dcea8edf0b18a505dcb5a11f075752c2cdb2643fb8cc8f872808cbabc8525217564393b060c7c84f0b38a11c2cf1f28210dd2cfa23b40216475cc93a592e82caf94eabe3f39f102d327e7833db0582c168b755d66ad6fadbd027fbc2458ec966a478808870b85df753c5b48bbce092c86b4f0e66f5c81b3f01ec1622806ec490cfebd3871d3c239b55aad560b27f582eeae5d5b2ab5f4a2f4ba905094124a92a5cd46391b6b6da8c03603010720ec254a9284b69b408f74ae6cb3d8ad1728e0ed72047001fe2e5aa1a396ece0e43d95dba8a0ff1f23def702fc9f93f02181c56ed510a769bc898ea9a23405141d128ca309383bea055224a2244992f43728176bca759ef8576e93fa5c8434112962e3505e08bd2e6e09ced12a702a7c65d246d3b4ce33d6c960f34b16d8412fa105d56e0277dd6bad09ca186a6e7930ec0e077e50088c57f0bc9bb13cc3fdb04c02338e89c88ba05bad6e75abd53af2048f154eeb3ccfd3da8eb91e93acadd553700267d75ed9fd687099bf9db59496e06cb55aad160e86854129a553f0f6ff5448ad6507b81a241403096fadfd2ec77605c6e1f770db82f3dcaec09e4bdcc39bf252447e9ee779f6b8ae2c0aa6b5d65a6badb5ed3838f7629c7316e1d0999c5bb9955bb9955bb975b3ad954195123aa71c209c12e48887cb40424490608d78b454a9d4342dd664537466465e59242bdb4412d65e3bd6644ba59bada6597b5df6ba2856b14aaf6bdbecc57da41691eb889ea12814132a1e1b2459b52c8acedc286090c242c5c406255bea9824d7674976b4452c59b2da05f9fdecc97e3ee29456ddaa944e415114652d2a8bac9106515e439f582788405116c5836dc1684b2b9bea9826e7ca96e8ca96ac2dd9922dd9922dd91286995e13ce28986952cfaf188f42dd7b31db11d1fd4cf4f32c014785f0ff47f03c8ce1192108660e1411423734b4dc619685e84cf9284eb4ccbce9cb0b9ffda8042e3b5ce9900000000001c31500001808088442a17048342295b7b23b14000d537442825e3e1b4a849124c9d114a30c328621028801408000c150892c2ddcd8ab999bd4543d9452a28be475855e6441efdf869a9c7eed04c8b24feead4d784bb5e98b0eb34645472f2c0aa6a5cb1e45c9525fbb94b0cb7f78143c9c394150da8d0fb07dd83214b014cbdbc732b77ac29132d9d931009fcd1a086ecfd58179be1a213dc83a3c45775a5bed482df17138484987626691f016730dcdd1047c6aaf9a6b54421a328c5e79562cbae5dd98150d7d18fea05a2d2282bd9da99e3b53515262afbb684310daadc2e33b5bc08160d9c1027a6e280a71d70e120f70c43c48f97d58de2761878cdd226f85980c9a9e93cd6f7ac287d8fa75c023f002e713c5b76ffd48b5ffd85062a200daaaf1e0711042b3a8126bc2c5640cf13778af074eaa29f81fd4e241a49165a50e9f539d751e5c906d684d935cf592db0d35020ed627c712ad834431c04ac64a13f7a72aebb6809974d250527c7c41f7f427597b5cab489f7c2631f34e88cf3ae4f42baf87af76ece5576c5bf0b49233e4484a6fcbc4d814942b2a9c99f313cd00d97a5482901a68aba5dcd569425b9da6c8512bda8a04f531448d64143806f621a0b7ea653ebb21fd1296bf63551cb58412662de6bc64232558eab703222b9166339d28217a538498d8c55f451fd8d1af76ed151e5d86b2ff932ffe56c4c59b4e0610aa12840804debdf5af4577aec948eb8fa239b7f47fc6f92f4f9f5753b41d7a0a1d653f6c4625c01e609eb15af69727ed58b9a14b2cf2b0ef42e4cfc1312b79cc6a86359867f18b96bee4cca441a7ba31888c4c3ca6784cd22a999a54e6700f6238f43715d7c03c7c9345e2eda3e80047325f9ecb2c8e083dc48427a206966e39142e75cc1cc5a3263331e9ca51639ae5996b82cc04e58f19ea44f3245cccf0ed4bf25b31ba3103ad980316cb264fe8bcc08934ceac860f64eefba4d5969aa5c18c1d7948e8424d9199def6ab0d9a1152cc7d11fc038e70364293e7f79e80d20d7d2f823710d1549f325459250e8157debd11b931e82c9662e4fd850176a1b6be3b6c7d3bdd29ac108fd47ef07dbf639aa9fb076792061d28b6dd82aa88d417f2c7bfd63498e3a1a9818731ccbb2b967def42f8bdac8fdd6c19703c113ab6ce9e2e2236205166a3a77f4f01d4239b635650920adc89154b0d635a23c631fe10436de96ce08af2ca3065bfa1789a704e79d6c8cde9cd1a1923d65fa01e373bf629356c1448bb36329877ad885d023c5b4dcac57a10659764699d3e2f7c2c3b128553b6913ac4f039d903de3a342227c0212916db8893c904313ff3b5a92336f6b21242afb37af5c72bfe908db124646186a3fb597694b6930f12dff4a139fbeebd09a57638f42aa3d5c33258f8565a29fa0915866561aa8e2da28c3761ad2884407cef8e13bbf490ecd17d5fb1be6bb9366b8fcf79418540bb930dae190e431c90dc9d81a97ff9f5328331a95eef4b243f6efc1e13c8af4d453ac47c1cad32f35a98afbdb4f5303d54434b73a45991f9ea0be154d7fe48a9634fc5f5104fba3e8209aa723ade8f9ca96ca9c2bb4515f1128312160e910cb9249ee7b93b105d91834d27c25afd9ec80ca7d056b381a4309e6d30d258f92cf6059eefefa98d76324424840a08b839113193246ca59d296b6819e6765a3480dd053fa0bfa54a876a85bb1bbe512c7c105c9499d51b7c7bffb46680060d06dfc18a9dd4b735a6366b41a07c84124ea9415ba8dbfc6fd31553f857b0423e67d215f3b52a113bf8348f4c407199978f5ceb1a625dfbbd65e570d5485b6eaf5a58597b2103a2b9092ac094289327835c09a18acdb282964aad6e6e65be42ab39e767c9349b9fc89f96a4599b857c6ccb6f70d3b8f260017f8b9bc50ffaaaf705bec76082e2d52cf42ce46832193772ed946c0d51f87d935ec9517a2a1dd450760926bd0cf24167426b79cab2e456a44583a3a89de85bada3cb5f48f567504b26db24e66c26e00e01529e90cb19c29375688e776d1f7397e4739dbe1ca563ad4db46de9be29db682dc5068e5d8b1f1c944094d5fbfc52d08e9886a38b2983efb848a4ba6dd9e4ab1a3c6b5bbb713cc4bb07a21f13f378c9546447b40b9d5c3764295d85368a96637e3cab8bdab6fbe0f8bec7eda54bc205bc2d75953d535cf8a21d3b812a47eb8c76f51bfea362c45f6c87640d79d2bdbe392530fd0d22233d802a058b8040a129f1b7f229457e0ed2aee6a385afdf7cb0fe457e1d320bb0a90068c6b9f39cddd8cb0c7740ce68d61e094cd3358ed99fd5293a661d13250147381caf90ac58f5bb87ef6cbb67aab2e7156537593eab8f1db81a2d33f5d87d3d1046075ac7858f336c9e4f54b03065585d57298ea3d6a206b5db8de10eaf2ea6159684182c1bd447c407aa4024149f67dc69612c511fe0413d63cafbe347419a88e88922a901567780a0174a07ed577dd760886414ad95eab06d2f1b01adc55728ba22793c45c155e69bd6a40fdec8068107cb9e9e97518ffaec2545a5c3074c384f3bf7e14c80a691c69f272ff146ad861432a21a8cda43a420e1f26bd1357e29e1bd50630cda39d6c6d58ae035c4ad6120430a39c3d2d08b882463e094073fab43fb2905a94cf4a50e6eca31c4b0493857b59174a84afff3f07af2e9371857c2c53c523a93d180eb59cfc3e1b56f35a5ae0e377840be332dcf11f26041cd29ca979a20e84c27b2ed612a9d4bc3f00f5c4fdd6e8fd801bfa3c0ebf2f7e28c4f406a5f472558a880c2568dc266fe86f51c9b9e22e62df55e1b0ed003f5ab3533641e6f0d7842bd1b0776a6cdd7d63b21185e4f96ef84ccff8611ee89aca01daff09e941101c89de345514507acf9635494e88e928b08ee93bd14951b00416b84d0eb61b10c1d2f73087724c45d8cdb374b85bb35c2dc3fecd85a230860b1093419bfd64dbf293284571adfb27bf951c70ac945e9a5f6b54e7917e025f16b1204595ea3fedae44f196ee001af608028511be53e9f613e9c844dda4741ef94333cdbef91f0f16ba810baa132ae82c70597166c28dcfe3f0d9f3bc01f78f62ea20a0d6358d00e15e32783a88277903fd06f672cfbd3acecf5d7f29bab88ea85b3498e12827d984e489f360583fbdaaecfa6a6714aa7d21c8f23334f281ba678af6733400fe9d11e5e25d0d1ad1497716a3587a749076624f81178015bf47cf0106e6818b828ba65a2a287ab12398b605e17f4e97576db31c709d88e8a5585b6a1bb512e628e73731fa8d754677cf6ccd9e9950874337f880ad364826df075a46ee444ec74cea06b678132e273041644d8966a8f6368390a121b8528966239f2ec58e798a9fa2b0a8b5e04d9488fce37bce285e27b803237a5c45d382ffafbb3a0be967a2b126917e219cb090a06de48a5adfd84f623b681742e860197dabc1f004109972f51651c495bb32c0c4a9b93eb99a331cfe8cfdcd4df2eb753ba9c34715886ea2f07814b2a7e633e0bf1fd49e6585e0e07e68dfd1051ac0d928acc8a21dfc91331f8472792227d6d9102c800f8f1fa35dacf9cf3a57122b5ccfb86489c049f2c6d27908adbdc1d3aaa36f1d4157d311ff0003f7c2baa78e4f4864161eef5ca101c97eee9caebae37532cbc6b034f320ee1780e3c626cab2df674bc978ddeb801cf5232133ff18bd52044ccd9ff0912177a1cb610924c1ba15a2d31a35b428223c89d55a2227e2dbcc2afe5c4f835d8e658dd92403a8730d87b9f851d70f8a6668efb1aa091b3ae5b9cb75b99173432730ce5e2e6ed66c972bd3085200b8bcfc257aa77cc964f483df88c311b89b2d19606fa6dc3b7953ecfdca90afcb81924870dfba42edeabda6b7898530583e060c6f27164cb67b094a2e3f60838c84afd8e95a5af628822719b919b1f0eca7a68046ae16bc17940aba218da2401ef4ae03d0ccd018e2808d15a6b5a0718b24e6d4014e303f3826ced880eff2f206ebfbaabfaf8588c3c2e623f2f51bf1cea41e7e4c7a13974921a5f42b346b01759346773c6e704e313999fc3e198dabd2bfc8935e5307991f1253156dc2a2c9c516f3b0d8e8871bac88740b3f477356c2160cdfa29863121b5d6dcb917415dd70bf50691224a16809f09b104b0ffaa0e0652c28484274c198be2d0e36a948f873f36c03133caf074bab48916619934d17319b20367ace9ced6e2505ceee5aacaba9241ac2fa4d5a228ce9a7192fa2b7b2de3581f858b11ee84746dc640b9d31403ccbc34194c1d59d2360cd937da21bf0e4267503cdb2e8872c9554f209116b6c60c7d0b15f0e2c2f854088734cf646a874709f241d82ca9c0e6c1ec9d90be5d7cfba4761d64520719a94ead7fed8f17e085c0dd17115862d334067be0b9b8e4242daf953f16b8c9cf1108a940b2788d7138ce0e281b20a4353b231744df56a1cb8c97af32eece387a3340096528af1d160b6bc4d2a1354adc74e520ccf3cac1841c0662c122b12ae26ace04351ca9657dffd66dbc59bc0434e5e4ea63b1a0a49fc7bc3034b8c780fe46a50c7f8c90dd1794df8c3233b61750f470c31005a899268ac887146ad8c11e16df532592c70cab5459eb768ac26a80808ad4d0e3711c2acfdb21a80982b5ee83354b2846450aa51cf16c798327094c5ffa98a28266571992ee3929c06432fe51fa14ef291452e77c8c32e18de83a195d1cedcb151281454849890fb730ab7642ea139bcd3c9a329a11fc002aef36f923ecb0c664112d8a557dfda6eb513d98fb5b6e2254d1364a788197055c422ca8fc1fc917d038c170dd88d7a7bd2d9a1909e1dff0695f854635fc37cf9f03a066a6f8674b48ec80253b1b33eee4cdbc32e8cf5c7663b06942f0103495ef4181f79c00b83240b5d7fb635d31a19db5ad1533d78ad5eb7f5031e779ffbfd13b46aa49088b8004b6d7ae3a15b8644931ba55e535998fc83cc252b1d1ae62eb713e6f94c492a2d9fd6103a2b9d77e78fa7588ca6c6b4c91b26a3ec974954fcdbd4d362ec644b2bd68a7bd4ac95343f73d898f26ee3c1c358fa5bc574b24ba47094304be79cb4da72e345b8f33678a04129f6652e3971ff22047e77706ed21b38e44113a1f8a347582dbc64bc4dcdab25067118a38c438ed952a323a9f83a3c375d5c5d75544f0432c7d416fa6d0919403ca69756272566d0fe9052e013dbc2b5287add033ac768518eeeadcb7faf3ec4b9abeb7538e2b836f5530a2fe436a1314ba486c41bbebebc2fe6ac95e0f6d7e9ad1065c1793100f255eafbc923186230c96ba9f2afe0f8555935a54a542bc54c457755002bd6c969ae0006003a0f2b73782b98681d45941b3c5d1f512126f253e1a1a03f249e0a9b59d8c169ba8ce5caf66cb16c74fec5e74c46097c3baf86302acaf298b6434926e9d337b30e5247364e981e2250fc4d6f2a4e5af3a59ebc51bd6382e86f35831ad7ca7ba4b6a95c1cfe746325ab5569f2561fe53156622ebf91d08a3c377fb6425bd6b710613937c0436c4ec796cc1c23c032cb9fd4d8ceaf6122abc18169e34e098331872e81a7caddb273a6af965b56efa1bed756313a8f8ee8647f24909599c4a2196542a0f96685b840e6daf1848b4b1fd9393409d76229d402340a325f6b1ce00297cc4680b79fbdad7c8bbd341cae7c95b92c1024ec2eb6f4976f669099f0a4177828589554a1e6dc8d9f47b9164aff79661a1e11fdd1e310d2933b224bb08ff5a86250b04c7f6653a0ab6ac9b1e93b9fea3ed7b3ac9c76112fc240ca3b78319fc140efdf24770d3f4306d6a33b1a49bba76db61c478be52fa4cf948fc51a6a587b9a27288a5ce44d857c3f047db005c13235bb79019d1fc894db43914083c9c90a2cbe950491fc22a5fee2805ca40da169e83fc1e6b82f5e459abb1dd35e1d6600c3b4d00f973c77325b9405b270ff2f55ebf047aacd26df7c2139698ec5bebb31c9037c183f299d70e35e8340072f4256dfa56d93a14b9c851f40e9b94b89790533a4a808beae3c3b83d08d105656073183c34f863b8f48768bebe057e55cb5be67a04f0e2d7ea5a99725de18ccb1477a74fc87ccba2915a16a593d49cc52687254b5ada3b15f61f9cb721bf1cf4bad678c2cc2b343893f9f0cdfb6566b0a14623f601185b809f957855b7a6f7a6a6544aa9456d3e85da043b47521f0b60e7505b0c335a73b5fe20d9301c668a083dcc442d65dedcd77386ef481be2c844d4ae8cda706627c9598a6854c3c77a6e04647e320dd7e887a1b8466f188c363fc31f9fc94170fe55b210d6b80741c1fc746c954dd99d836399066470e0fd938428a7e1780e1f4be40426d1f529d7626584d6934be930bb74393fe6801716ea34919cd327c5849e2da71ee143b1b134cfbf12ba1cb60ad5a49a9d80e72c4de474537bb21d27e0612532e872e90de18a426b08ead20b64bb0086325754a02e74b95cb9a45dba963f10b630d5a15a6e4c09581100aa30b33093c4098fa8214362fb676e06ea4cff1310b4d694b05b760519e5570fb1e522ff088cd2aa1cb3731797f6df1503a4bc0a7857f9086747f6de797278dc203b5f463c6b8133217dde9d1fa50e6cb98ae2b6902e727512fa332c0735b6dcefb3e6144c3756e2c69835c79b29fc05a15140271d86d973cbbd5005eaee72d9724048ca0b05bf6839488fa1e5002d715a943d2820a65f1a58e2352b55fb99f9b5f4e492a12e4c3b0ba06648350b0f240e0ac455abecb750644ec9064f7ce55073192d2ece691d217c3507705d6c7c61524719e9ca3222f1b8475912e4ee159ceb3b798abe032330945a539458135c6ab713e67c7184f0260702683d2a8e4c0b13ec223d61b9bd01823603a25724e2d174eb60681b8bde11de521de241c8dff470f782bf55abf5128ee0d3902cb002c74c5cae10e76271d6d81fd0475ecf48e551628ac9485143393589e85878c1374c6f24e2247285330b599a56670381222b54e57d3c1f38eb00e8dbe5e7046f808477978bf0ada4a7bb7be62b1c9aae02bb7934731c3be8c964805f3287b46a2ee216e66d914b916b130d063616a6eb1fa44d004bdabbe70860859c9675f89fd5978a6a7d601a8a0c6c1fae93419903aa3839e24ed43ecd44a80df420364e7ebe333a295f95328ae6f9a3fcd908345ad595069bd72be9058b281f33e45bf519c5f1714fd39b82e473a66ae4098982c6b7cbbfb7b30d949e94624affc426e449b924d16cb8827a640bc76e18b170fa8cb6548eba488d5fcd4de90ebf8437427ecb2906e65b061d303a29e66dc3fb44902e69ab1836a86207e35841309926d3dcf3a3e6b5908c1f1521f4fb9c34bcdc203d796a8b0be8a385b92addd0a36b247beeb210c0eb8ebc2f48770fd299055864fcc5fed0f37d0b0c8992b6c29d2c3af021779503ed1aa89ed2c3095c43e2860e50491439c463b290a7138035f51df94be4576dfed226544362c6aba12f8b37837952208bb260300e83525abbcba683344af6f7c164c19a472ebe85f68c54264fa30114a9f12395e88ef9966dd6f0ab5d1d3bfea1e8f8e36196769a885f841a27980dd7f47c0ccadf58434f82ca748728cb91a525f466290c34993462d9a71e7a47f0e5bc3b2303be19588d96e1b89b8ce24a114da4334ece8466647034c093855ac8539f141cfd72e89a0de523cd72f2cc65bc1ce9997dcb7291c4424ac7c4e6c2e1a5982d36c6279fc3cf437dd149b5971db863aa414fcd673c84b159828a1e9fc66412c90a70036c181425d6697b84515b11df40700f9d857f1026f711c71ee06e94e86c476ce1cc6cd1b81cb8c69ff05a416933e06d6d3cd18761cee8060dac5cbdde9d9f067b4d622f39e8d3f4c221f343f8c1ecaf2c6d5b9287ce4dd85e43a99148aadbcba7ad20fcbca2908c27a0742b821aa2fa84ba5df63795b17ab7a7598b87fb9b728bac19576f6d9a940b44b964924d82e765fa33ad33924e0db10393f5c19985a36f3c0faa42717072f9e2d9a34e048004167c9dd0ed4f679cc12158d91466e08be8b694994c934acd82e7d452a9cc2b4408b084341a74443863cb6713d2d378627414eeac776fbb3cd793d76ab71abfefdfca86eda324276ce779afd6bb02eb8a6a8f232c0452273f73bad5729877460ebdf9a663ccc4f27e7f559375d252d37a0519b1fff036b77863480d83f0a2b529506d045422c94951b18b221a269be1d92846dc607d0da70589fcbe88f9785c6e60c62f37a940f889d7875266054b07a596cab30915957ea5f201e44ac5595279d2cc7e1565572481f395b24b2bb880e722e3d738a166a4f213a06ba7dd128e1580a5893eab2614b3fbf6d6db963071358cd20bb2547aadf04537d228fc6d1a72baaf4ec38c905c04a770f0b236433df01584455731321862ca75d60ee4b5fd7f5ac9ed4380ac7d113bfda8f65de0d5918109bcf810a3b401340879b4f4e9571b2f5c1c9fb1a71fec99ee75747f6b6efe9a9460c001ecdd2a5ea819ac85a6e5dd8886937de53d55d81ee982bb5d682b3c0e921d8ddc94d7122499950407d112d03d8c9310e6cb3f58e7d31a90e47a6d7a729fbc425871ab26da749446f36b70c8838088a34c3dbf02748996daf5b45adcf85e57a88049c85b9e71f2147ca5dc3a8d2e6a1f84b68bea956fa149ecbd97b822d50913f41f6902d4c58823d9e3ffd03a911d04ea493690bd0d4065028fddd9c3088edd487b5887f8588cbf8b70d88a160cb90aa62536b6334c5dc5001b3e4485dfd4b8de407b1537299bcf6c36492d7b03762e3122d59d2fa0a610e8d4067a0bcb816417b52b34ef41807b65fbe7545ad51f11a82b4a395f498bd87b90915b19d7e1ecba217de937d3f68f85b0e23ca03438a623811b25505499286c3d6bce49b3bb4fc701d5f45d9cbe229b17ec6b901214eea6c5bc2b28e8695a111e9c8e25360b9dd536b29193ee9683ec8101c3d02276b85d7bedc25022a0ee8a5feebe209e568e868b66ab75febe44352b82e8b6155517c89c4442f265a25c38466a0fcba093ca29c4779b4a8886083a39ce39c6d6c836476ca3d497a43c7fc9621e5eee377f5b295b9aa40c0592f460388ba129eb18683a861b447f8085f42df80a4e58f068ed7df32af9078671d953e839581a456cca4d034aa923db9bd42b0723c46198a237c0d18cd6a6481e08edab6fa438b4743cb2474486e4b8035ad6fcc4530c03068da1c04d62c472b823f2f11d7a5e6007c84b2a93c9699e6696c29ae5d0a4937b17d0f4344053f481183087c2bab8fdc5b87fa62873cd53811d911e598ef194408376707b8946030aaf60689f790ee014b8de67dee1ddccfd149e469a9644a4a996b2f8a7a8d8ac4437209bc8df37ecf054c9fdcf2eb5c7cf87d2e477a9a540286e6d821e898f2ff22d5bf63bdf879db340f9dab9ddcf984a0d53f1bdae520ce76cbd19d5efcdf1ed36dfc1259aa6c202494bc4e02f60db1e8cac542162ad04efc1b77b4db45a73604514e3519e65224ac4ca4fcc4156680bc0a7804ba455c8f673070a4c3fe00b02d5ebf47598a635a18099c18da48e3c5fea6421b6711e9d211b437ac2ad60ada11d3968a7e729f6850e60a06c13cf2db1d17cbb4ffe5905a41f877bf454a24909238447cb2ff6f60497aec953c884b35fa82c4496896c765fecfce8a2e94f8d4fa7160d356a1538a0d87e80538f9f0185c38342c8e0b5a7553432ef4185b06dbde434887f6b2f9dee6d0e8bc59a458d226ed979d86a342b2b331133b72d4e89dcc152da2a6952ca3f67ca0b678d34b77dfca91654d5b45e3177b9f2888c8760ad99e99bf2a21a05dec8a82e574b1cb8aec136f8d9c58e1d921cbed385fd5ca04cd98b20440415916e30f2d38c211a2d4bb96e82191f7085c495f65fc599f30628ed0426078bb8fc2a81eb485213d6b9b8e3ef5ebe8d3dd2d2575a11597e50e26f7d32a4c50a9fc762a95f55d07b189f4039af12e4f3afb5d1bf642568007b70d96e9e93433b306dbf826f8340fe257444366729197fca98c1422e64943d46fa4f36db1e819c3096b59e9b24ac4e0e4940943f6599fabeefebdc6d14eb9165edb05f330ac5b6c0e27d17fa953c96a2fe53908b8d88c4cf76a18a8fac1641b9172768f611a7d3c904c7d0dd0a0f7f732dcf78983d1f7debefca4b0695f1c3955a3ea6bd61561a01286eaa89249ce4329ddcdb6bc11835d5b09b4072d14d2b1f75addb4a908b39fc3ba179c6c23d89688d4a374e8fc4a44bd846400cd0e57fe0ac52c3da024e82b94c3cdb084685e028256418cd8d57430617c9c14884bf877dd871c74ae9498bcbfb9173d38722f84602a18575e2f4185f5bdf44c44ae305019471ea44061d52c08564f9259d3d73d328a636ebe6132ccb7e8d6b6841c1aa00c93f177c4a270b52e3579bacb8c37d4badaaabfaa7758afdc594a2d09cdc02f66d89f03c780e3a001b8847aaa2831d97c6cffdefaff8eecde42659dce336870af544a12a0b1d58af12e5886ea048a275e4a25cc01c98d8b66f2fa2b5c774aa18528259788466897d323c54ad109d97f05763c8e2e1c2ccb7bf7fc0ce200cf596c6b8e28ba55666e0eab2e3fdfb6d5ad00dbd1ea6773fc56cea76d806a02ee0d8cdb632039137e56347d69e18b46715a5f4809f6200ebeeb8dff6f6838acfeb260657f58ecc0e0c5e6a6884bba4126c68485ba31f37343ac04e89e863c893f129f3e92a14acb844976f6175c01472b24c56d270116c7a72306c070b99b18822656006d40253b1a7428fc5b990b717c568bd05cc7b11f1c13b9c2907ce224bd32ec89aa9c891999dd2526d9addf0734c78465186b42accea6778b5f06dbc507b27886c515172a13e991a915e7c7f95d181b30d20a864f7b7c3d8614c6dda8e1475be097025355c8a49d671d9b46723200eb0a9658b803676ffd2d575841afd2336ebfc1f53ef211d4043bcb34fe88c06aa0c446706b8b3b2283671eb71f9568e39e1215ff4372088d534564fd3322fd25554710dc387b47f44bc4fab8e1b6c707e9980d9ff268ea72f0e2afb2f0bb70090cd1b0c94b3d61031d64e7d23110b6a846b26cec0b5560eba1d02c03e54320f19aecf6aac4aac952585b8601800acb40271a67fe84c7c317b3214d8ab36dc2728a8135a780278e48de7475467bb39e9b7343ec8f8d08ae9532e8800400c6089778d57e0a12a7cacd0a7dc5b5f880e7854073ff2109118c9dc04445ac2f0e7ff78b4a559008c6ee1b841a88c8d906b00ee5acf97466ec723495241af1ecaa9fe5b87a7427bb9356bf05137f80345092d3fc339b623a826e6d2f28213c83dd1b95032fe22bc7f2687b2c88380ac3ec67ef491b7dc6013b1ed877371b72028ab0a506ee4d36250438335c1f7f3cef52435f7f7ec7495431a1644f5863e4d1a4250d60aa2b5536cfaf7de04c51abd4de05ab98d7869d64df4242174ccda7d22ac7322379e4d19305697244e5124495030241406573cd425cc4ee9bd4d57c033f277ffaae35fa1096f3d96e4eaf36dd302bbcb80f64ea5c4a7978dcb8de06b1824c9cef5a7c72d741f6609c0c572b2a65953f24f71cd42bfc7d29a019767b7b5885e1485bc31a8ae30148020032cf944c79cfd3b100d76ff7c99ad6641b161f3432ca1d70c5db91064f52f86f977e71b5b5f489167e5ec635081fe9584180a5dd21855e35b95e53ad4f8d6b372ab4a9a39a6abfa482a2d19256d5f63b837c4f3188bad3785f4514d00a699850f37fcf53708d2a0c06915286d87adf1f5bf8d355063c7d605860e73e537f15f4806dc6bc08d1093b77a6025beb459624ed64e539ed31e95e8ca5ca440c5c5193455a43012b7885cad713249cb47ce2846c0283a0c490e6880c57beaeecdd5103e99851790f4011afa5f325e235877a5a0bfa96d38f535810f688019782d41a36f358e4265466a0468721eecd40f8193352c4f6aa20432475984255634430b6663022534997844970e1ef01bc69f4f63f2814369d2f745cd6dbb6089657f6eec3d081850cd36827b73b8fc911951ad2b761d81dad57462aedb1102365ad864f5b7559b924e0c086b05d425cf2bf8d36d99cb56add289899f8a7153e27c6a266128fbb88abbb8ee24c4f8f455645177cb1c9fafb5a549f95cfe69970c3f9771e732adce75ec10b16acb8b716e0f22481889b92b846525942a72ba408a11c751b59aa81c7504123e09a4162c554dfc0911ba01c62e4434b542c78fbc35f576520ec9d2115e4e4d5a7369eb72326276a29a5856c96ce2a86635025b70f0ae0d84f92d5a8442bd4d8c797b71d9f2df80ec33f2f8f36823d38a39bf37b77ad434e09704aab409291dfda2a8c01775820ab32aa38020b453c68d7bf2b9dca0401d51182d56bae2b78bfb411ec771ef526ed0323de1777690c47c9a20566f74d9e86f03b33a4613e80c45f1e0c341fa127e0e68d36d3a2846c5b4e944a2da195f784658acea1e9134be42dbea2206f4555bf142020aa876930b272764283095da7fe21ff07c27489516d9dd280c12ab7184c3c55df743977c669580e6703b0f98bf269730b4036ffd27bb32df59e6c8f996f539c046f880a99f85b2602917da7059fe718875de643ffce75a9400f7363574b9cbd3223d7d718cb7d2ec3f3e9fd3582dc4180ea186ede1831c07fe295a4c5288239fbae18ed1d11deab78d40c1217e6bb663fb742dbfd620eb36950a025045a1296f1c8cc58d69f6e99aa882101be12048017edc87860a4a9e53dfab05ab783ae6ea58b237d364f0e1e9c5871484c94ec394d6cbf4da1d54ddf72c08ddfb9f4f0ff393c5ad830534777bb1d4f4cde55f3659a8837f459e5d729ae3184105352b3e69d8fe44131ce64e0cec3808685f7ac4fcd40684646025b97caefd5464f295e8f4e682a74202773e3b15dc9c2cd7eee918a94fc7c454ec9b789291769d0d32ead9070df8284ecf81f0cf91b56f2e79871bb100839c550e1cae97a346dd6c62afdf4edd7e810bd910e48f717c159f6765a5bd2f3d601cf63427009544f0fa6abed4c316d45f10e50afdd501d33afa9e105a6e4a01e5d6c9dcdf274e015b7f9f008a259974f18b9e4d54aab50c16ad33831590e00c96f9d6af6e3c016f14a652b44a327787dbe7d3ac986e84da957cb4aff994b940a922e81ba2eac0b8f4be962e3ba8d554dff58e8b897ec40d0c8f4a680cb11a228bf3105e32617b096bf67b319b64cac1d4c2f74445371329a21c6d403f65529de61419a800c9b0247fcd3cd8f96dbbdcafd730657e651519359cc2bb5b08d98f819158ca983629e2239cc82d13e46631162cfbe46262b1c7dada16f2c36d9b0c520ba9059e92a496226f9736c94c39d266c98530f51b2ae9cc0f3a633011e2d730a6a22563b272306dc398d5e52ac580310883bb690595d3957542b4ed3a711dd780585f5982df60fa42d3aece90db5fadd375f12e988d65ee80b90083614da7298a8bc39ff1d9d918a65f16ddfe890ee74db420f8964ac240c120e59d942b0eff6f9271b56b23cba943efd4d439fc41da041294b8f263f3ecfc14298cce3b6b22fc6365067143721287443c2b33ecc42ac551b30a3f5f00a75410a94698a6f9a87829e8de2d9c6b2564e118ada4c223d8f44b0cbf3f934942d02a4d4d0511a99c530618cf69b5c9359f826644addd9270d0675e06fc5d1ec8bc2e480762caf181a47ab0dc13a95462d5cfb93c3150bce59c9231b7ed5034e647ef9d4b21b960d0d6a898bc528551ce0fc3a027ffbc48bb6de3167f2a0a4e9b34498774b8f03c032f46591f1e5b8e8900d1bc41b404b1b756afce3c3136dfda82d4cc1a5cd7b319a2b314c33790d4b9ac47c22083743da1428b803910891909bc200536fc5ce2b45df325e0facb0864356634716975bbaa784408a06219900948d87d54e7208ae128e29792e4ea8fd560097330308a7e8ef08225629fd84ca6f0a92e96c2178e5184aba21dcf7669ea49a2722e93145ea34e90816ca4306fbc759641a882854e50d0a4173a06cb1d40bbb4af82e278933a5030d220bbb944100b3824a05507ad6dae71861c8d38cd42d68c62c7ec37be50611861950bf32661865fba32df5c787b951a86f8d775ca81cf594534503a4d36b76e495251a8855801b0d734579b0f8bf4725a16508503bd16f46afbbfd8a31fad25ee017ce43b32651569f5b26d3bd9e4db1354910b8cf51e40040709681115b9a05d8c582ada63aa48b8ad53f186f716852eddd94ca08a40aaceefb10a4515d9930277a5f10a19cadad1eb3e9f5930cbcb2879ce29c67a6e08fffc77968e454646ceac21dfa2704590027552259af8edfbf5c4bba74853c5abea7f7b512872d2c338a0bed9bd85de5a6b982f51d10903e204afdd090ac23e4391db273bfa630750ce748308c5428873b92858a481e771b90ace55c5de1c6ecd36def60e73e43491c9f4c787889a619d90a82298e3b0969a88a03ac0cedc5344acbfae1d3d1b2313084a2da8f87ba1d6f82dc2de50c66cb43c0291c5c8cc0e7ec135534e3e26ed040915622d22c39f7dcc0a26f137b6daf65acb96aa95ff2b50a6c7ffe7f2ab0954ed6e923f1809f872857f44e54c264ed7732d28376d9d4a1a055007fa10fb923b28d259eafc47a89e9756ed4357708067e0f6de7c969dd6200818def3bf5c421dab786992512a3939f467494737d48d0c0d9c79a78b7af3c2252418475ee41573d6fc47c9a1801ec50ca36862b1fe984b313fc083b0d0f9be92476e760416115bbd4bd87da197e1cd83874cda87c0797136c5e0a578e55d7e71d8aab97ffaf2286a834db791270e217c0d9fd5f706db36e8f24d481e821f17ef33dd99797e3674fa560b28a1f38af89d1312020f17f146a36c1d23dad75c23992c613a9124d3e5545cfbd3051b91e55db54b1b40bd43a3f8fd9493dd1e3d5f6e48ed5a29bf429a614671f9bdf410479363bf5e4a7ffeb86d3e013628fcf8baba271c94e1bf6e1f16da3d772b39d75304b746201a950052c08f9e7d04828e86847d186aa1335601ad0204e836bd51adb0345e22508484b6cd3cdc9c0950916e318c33b0e74e7f0de57678c8e712b1c49ba01e7238a15686ecc70963a38636c5631ec7df0b59b85d593f2817ecd8a432bf6cc6caf9a9729d7ec93af35ea781b68ae94b550133c35b7da0c8e0f8f4b0b2ea4eea7dba7d39568f2acbf999916ef77f3d9de4ed73c38969bd3675a10c04c9c8902210671f88711973785f216f81b6be9043ca3144faa6767232edb5f6bfa7963ca3d1c9f3d5d81b28ae4d5cef5e22275433f5b4ad917a7f211bd0cb08b0ca7663a2153329423139edd4443597871300b00019ab45225fcc210cff1104660cf48339124969758af975e8a5e7cda4d37e4603270c6985d5facb53334a215b520a61802926db529552da0df2c0a1d2463628b36857e1e1d94813e212d98c984013b66246fff8bb094a59fe4bab6ae159bdc900ad4268d2cc7465d74fa49cbe73cf8261180d1c5b71f0ed938ae74eeba71cdc19a4a5dc0028ec16553fba0bedba34897f73a25aac2a8b7c79fe2a7e287395812d434c3bdbab6b0a81441d6495ff76dfbb55319af7c93cb4b6e9257b095d2c008844dacb0825f6022fde172b29b9cafb5e2b7e622c789d22eb73eb78461043a173e2b933e28fa50ab224578da1dbd6fba8d219dcb0fc7d15a2c1acefdc32a07dae30f0177b15265ec84bf153da268cc814640642cf9224341849e9cdae095a95328ca43743242924f9c1c61e924c9b38e117ad34c2d78e90c5fef223119947ffae2460a98ffda68add68482ef2a462689a320894dc1ca21505b993ede407aa849cda1d073298c966dcbfd935170382c4d38eb7a72f533645919c6a71a48628a91a831da57ec9c9b76225a00a47dd99ff7b93046e2f6240cddbba497e997091b103c0e144aa447641422b238adde70758c94311ed098c55ea92b407569cb365a8563e40474d7fa959dab10cf06a34392bab28821b43e00614fed85356c3a1aaa55bcf61260f3bb43e93d97394845a885e55a0be27988c2c48ae0737fd175fb38598c3463c62018ea43c5272098b73249ef7c4befe1448e86384c893accd48514f76da6e391d2a91e7cf669eeed8971b22cf808d0e20213299cff0f6f5860071ef14a431ca3c91dcbd96acf168933efaceee2b411c3a05215e3f23725e70a63ca02945f908726579ca97a85d468d75945e883d9106a53dd93265564431b5747abe0e48d0cf96782189dd99e06ae73e4fd26982f595c6ecb4dbf3507304c1a5511a345be9049f10fe5390c22dd52d2aacef0235a87d1c5cd7a8da2825b12d2e9bc54b91b6dd1857f9c7963d8b58f6c18e05c073a3224ca1d117885691f9458d3f292e54dc6fbe542aa982b9746f1788e8e0a318e7b0e24c458a7d2389646df1fa468e8a4f0c275e5949e5535237c57a8ba7699316ceb1d407f199ac0893679398916ef827ee280f3b6e8c027bc8029ae130d35de8f4ea640802cbb44baf51c8c9ad262720902dd02424ff5abf0ae738b83fc0df9eb46d4e17ea60b3b887a273aab899a30a0827ca0f79e0b8bc65829edfe9119cc504a7c2a691d102e74efc41000a039c7ffd13d6267262f82b4c85cd8986f274dee642e56e0009e97e887ca37137e0213be7c5c6d16f771ecd40f15f69e95ecfa5234cfee5a426aae4cacba826f1fd7bff17633cd826251768fb6b06f0dd44f50c599497a60015dee1f1ba9c3c16d5e3b7cdbed23ad6d7bac65004cf4f9613977563f6aca206135003781de7617aa53590432a14a841c10fa17d3b7009dd31b0150058d569b0d735430ca428c4a00e98d7fcda98d9afad85c07966b9d0374b0c38453bbc5c36c331a3337a0bbf23730783a31f860fd166eeec27db2eb80834f5b84625e345207427fc3d84633141c661b4489054fe0969d61408c6162f6f513c8160516b1aea89ed26516407d5605e6ecf9d77044c1da1e63ba72d49aa19b49f1e4844c70e0e212ff9467ea48b4a5d0760521d03af1081b83fb61ff05c664034c70e4a230ef8236b00ae89c80e62a7051c911d088c2abd88ec8033522a68fb87db47dbb1d03ea16cf1c1c9273d99ee14c80ed27da91d1d341b0c78d00e1e36723b956a09d4ee7f2eaf586707aa9b7e44ba615d7763ddc85fb3dea804fda11ffe45b0703aae2efd40b27e5fd01f7096f3dd9575d2325397c3e0e09bfc5308ac41b21ed448b10a32823f2614ec147dd003f97857224a761bfd7c87fc01271dbefd6b8b63831746132883b6c432b878881d462f8c64b907fe23e234ae8611747aac8dbed0dad83849d648f99cd6b6ea21ce5483bfa8c6a4504021b72de308264694001579647cb42e6a66a07277a56b8ee3a4c50e6cd4a65961d14a67a7b84fe0c7313e5fa2c4c43d738380d8ae5e23938b361a3eeb4d770fe657e9a198e0c4a623c17e337d63e9961024365682ca5634ae910e8e0d2d495300ef162c670b78368f3027a87398e2d36f36948c8313008f4e062b85f7bdc560c9a66e1c91ca9de004f7b1cb38ac571f9a81c587204b47bda16e60b7d644c7fee79f66f2eab53edcd93b3bcfeae6db6dbbb63c21704fb048c8723129d2c40539d862e6f37db337df49d1412695eaf3ed515111b2a4aa0fec3dd429d127b449eb60a25a9100f1466ddf30d9c76611a89e3672b56fffc605839890635541cfa5362da2ea532a34eba9b10c9629fa14ef1bc0be4dada92d00906f811ae3028297e1fd156f84fe4f0303bc77217be53897629b1142cd96c9601f57e6725472c0b3716c2110e1b20824cdce5ec02640fe2bedafaad274dad4bf6aa8d662b45ac47cacd2d74ba53d8bfcf92957966010e825a1826df349107d95feec3cff04a335d96639134e7dba1606dde82c2ae0dd9b81d1651c37ff369601587a6c53fd5cc8c38adadfa2ba43c934c129e653658372f6ddb0df3e33544caf26268642839cec97119ea1bf82efad609ffc42b8dd46d474136a7986eae95973f7acc1acb8195a70d0b3596d931c24857839abe40c452e390bcf33e975a4e4255d487f5f173e56bc05db85fb98a7c8069d4bae97a950ad51fa6cdd788a20e4d2afa788191c2303977955ba1939e5c8594670690a369f956d10cd266b1409f0ef1b30592a01fa2a6b777e25149d24de86446102c11584e61e26f9d37b09f735eeaf68607831bbb16075211d896c5d27cdba5f99482edd822f44042ae570fa249e19f50563e056e41cb4f019935c04ce1f478ad260569b721afe497856c61af92923c2edf16028cf65477fce56724b13ffc3d30991e89b29f101831d715e00ef4a304bcfa1a5277a94de16cddf5eae3c5fd9ff562312777e04f4ed4ea5243179fe5f44fa3e64f26df2d1df59d4f73bf14b82f2cde5bb9c5109faf9eef0893137224a2066a6f9aea3358f664f383d1b8b8cf3856f80334d3958283f2d7bd74902b28f1c888b74948448ca1be95efef9a2ad0a18c57fc9759c6fb907c41c89d2672f12fc26b90b376562288e5549e95aa1ca447a245d842f19fcd5197fc771bef00cdb6c4a56854b006f6448cddc84be01382325e85930ceb74c852ffe206421747bc45ec856dee7e67c952a78c255b9e6a0f2bf3248e97935a65cabbeda869884bc533a94c7dfad72406aa24c37c80c23419fee28364b0837c7d2156c3a50b051e2d1d49cef66b9d7152509b126bbc7d7801b27c515311175deaa8384a0ec2e3e715aaaac39ed95d7de7ad128ff1273bee0d7cb3fcee70f3819dbdaa1339b41e995efaeeb5a6a65e7015e6ba1becf7bdff67973b606b5c936b6245d26d0af47fc746b53a9b4fb3b30ee36fe48970febe382db3d734ece3f7d43d0c59299686871cec6cf7e09401317d21087284f384c9d9ce30092db0c5fff2bed078e0343c35b3011fd138de43dd35567822f7a422476a558a381c231bed794f72028b43eafe664ae5394d4db411e5203c5da6a32658a444b4fc0ef4f3c6f661e73f1cb09048b1557c8fe6fd5885c8b7122b8ab494329495597b1e504df7e399e50ab21de2ff8e0f6b6c60d792816273432c029b431e8b17a111a7a3c1e759903671cb8e1ab0d924d294be502495e23b5efc941ca720e1e0bbf2f56352ef8262f0a62f6ed87d4629e4fe09893b676221de295afca56bc3247eef64e262c9377cceafec2ca688dd873c4be3db2abdc246a28c7cba2de78675d7361d76c840a651eecc0a2db9ab4e2244c53ed942c3e2a3ac6910a710b39cddca4ea2e5c52b2bc660c2568a3c7583060b5a38bf4c7f3ea190ba8dbfd33db917b13c1bb45217b54019f53085be7e1de821d500a90c64173c43782a49adf5f5181c80dbb7f41c1f9c9e13468140635d8cad9f0486bd0a10b1ff21bbdae377caa8d3e764b8b2439b38708578e672382de17b17a20b7a7fbae90e62080a143073a48098fe0e26727a84741ecfc5bb473b59c71fdb84f3caf7b6d1ccd13c68f599f8fe40efe26871f641fd3c2ebda29736131809387d833420d65c2360541096242876668f6344351d469ddd307640f6d2f58d48586c90cfc69340d7758d3ce9a0d9f2775e0835a6781b6806871a5ab7151f2190168919d21b95ef3ae8bdfb28251d50d6650cb079bc6e248c427e34a7366e71cf048584a90a9f7d185180076d3325f4f2c30c1be23a48385e12c2b3af8196e47a183e085eb1f02237317a52f875576d062d2f0e9b0603350312819bb6bf690ceb789319728b7c045ceac783437796f38b75bda27b9a3d581a34c3c5d6f41b982b017a991b3147c019656e02af822f1b05843ba721b4ab531ac04c383c3385c0a76160c84901a579db7bf4604a20da31ba8ef88886a123fdcf95048fc3a184234c59a17da25ede799bfaf9fa3b7e6687dcd87048d5e92ff39a229655c0d55aac3bcc07fa3684e2a357854d0e4bb529d7af08128fab5def92e858b01e2dfe27552b3cfd03c25cff80c77490782cb0d657141537ce0da170c5315a42671bad21b472d2c6ecebf0deca0596b2af5111695b398143c4c717b1bebb7ecdffdb65c62a81d5af918cf6f0d58cbd655da5c82effdb54960ff63364658aace409f922f2671e66358953347a58481570d3c0edd9a9e0a52174873424555dc29ddf8b9a5594e1751004d016ca8570be745feb7ec6b0a47cb2cc79e63af02d06865af1ffe14576f562e536f7437cb70010b23ffe718649584d0507b4f63714be9047529e808aafb75de0441980c5035a980530c3e38886fe823c110e0b10f54a8cccbae674f1126abe51666a91d97814a6970a32d39ad5f76d83a3319d1865bd14fa2fae908edff19564b2f6d5632d9de0e7c0cd10471a0196629a5d61e99b09c4664f07a8320faba24164460e1fb4e263a4d2c8cc356f51a08189f95e2589db59ce086e884e30f5dd3e3902ef04d632fc530cc4479f8f166a3b8d6634c17c6684b2b1ee3a6c5b7eea07082fa4c2199d5279de8567161f48145f7de3af54e94f47ebf4c066ad4a57abcac1730896e23cad79aa8b5f8b57e4aca258fe438d6495649024f0e308b376744b5c662a6d1ee95c2bfdfff2197d486988608a2aba9efd1733342e704ec0c42c80ca78f4b6a4572106ead8947bcc8c01735d465d4c4b77ed1974cff9f3e28a04137b0144b52a7efbcd81192855b8c5f3b9ad29f195de871c4926d4a1aea5c176ebb4abc54bcbaf0563bdcc26bba15a58f9adf699d4e5d53c500d6f55aaff687dc70b78e0e3f762e240385cdd1521f13bf5c2d2ebcce37baf8b5118e905d15180be43f3d831c7c91ba7674ead6eaef5a18be999e09bd51f94156683f40afe48e87b1d1a77b02247268374ceef84bd1cbb8313c75d3819655e66fc6f8d522b94a518cf068e4c9f76d72ecd5910c8354f7d71bb194007723d16be13bf81c37961c4f67cfe9b853ca7d350806a6f1c758c47573fac9da52d46d6675e361f698d66588260358a4d918f59edc01488f30e8ac6ed7b5af8951aaa062771fd4dea41deca000c2eade0a404df79f19a2427905b1cde9fc72b0ada361dd9147a168e2fa1aa46304affa74a4e6cb3a68d3b9db3d248189a350a6735677869ca4783bd1ac7663545ce792b1dca963bca87db8578b52405837412154a84929027719f8f84c62a2933f452f0ea85131a970369b24df26211f74cbcf37f263ac32a22e128d80981151c435e4a24bda86b105873e3d8e660a8cc23e1698e8a146a5005f2054e9db911faa763fcbbc0205c86ddd23e47e91a76895bdf3f63192ce712ecf12c6d714cba02ad6b7c3810066ceac7da83c1ca30b34386e61e18797161fc774163e909b6252152b557bf6bc036f319dd7537f88b4358a241754aade0d866bf689c6749151dd9ebef34216107da9ae61a0ddeca5d3eba7ae18e4c9653d14865a645973e5546bb530b430039486bf4b420373355953677a5f0500acc856c816a874d831f3ed858e9c1e7d3e2a00f06b475f363a053e6b846945b6b53e8f0de71eb37a10d49252acf174a529d4298db602619e057e041044331ad64caadc7b737898a93849bcd1ddd96e9f81bc6d207dca8e6f1f187a0437101c8d9175d6ad37057a3fe6a7346500126370d06b8c1ec92aa651ea3b7cd17ec37912f542132d448c3024f53e8d6d47ea321e98914b0a7c394be700125276e155e7256f3c532c0fd5d1a10ac14401137a776be45ab08127d4b805f9c83506636f4bd64732f9875ff0bf5a69e0fd42935c062cbbb816107e9ec3ec6bd5688e4a9b414ce28fb04b31f0be7b5fc48b80d194ed333673a6b9a938a8260dbda2567726e1664fdf581fa5c24a0ac561909f5f2f03d204133b2a38548f56e1d750368dbd4dc1cf3dbe246384de6122e22e2e022202fc7b060ab5494bdd6a67f48383b21941f18d376fb4099998f7139dd6aa271573919b47466c16d0cad8580d00cbfbe55fcbe13a0efef82ecf1bec2592070cd366d9f721db3d9b48315ec9205aa262e35f2868c4e33b21a0f1dd016ca436160d6690116086294f17ac4c9e3f402dc04c940d509be40d54e10893d8e96a77eccd6ffe7a6b268d4a1a22a34d1d939fd67f525cb21b8d4c60a09a22470112fedfcaf8deed7e963597e885c8b099843db0a8bcb386dda43c9f9961da5e68b1582d985830e6bb5fc285a07c92c27c4a4c537983cf5d6e10c1dec23d657b5d612ef17650efa05711ef6c6f124bf152e856edd78b2a0f1f0a43c88f71e1f15f40102d9bde3a49a798fc85eb214e8a0f72cbd3b256d3b5180a832cd500359f97edc354cdb90466611ac6418ecc6e40c4f40df5eb56f5052e000346f7505e3fce4d5d18ee27e30114a96b17d02b1dac569fb06f4cb33b85f8352438b93d9d4116ac376a3d92d93ea66c69c5440945f74a43ee38cbc3a5c2dc35f2632d6ec78ef6479916d47f768b0fdf3715e402be01bb07b85e62bb1d8b466868a89e6a83a8f1bfaa8a2775453530e4122c9f16df2ef24f77b7a986ec2975ddda3678406e06d0ba7c525d6610e773c83d623979fe9cd23b00d67f9ce87f1cf2dabe327792bd225d9b3ee225fe9de7427f6c3651910958ffd13cde55eb05d90af8af11211745872a595e0ad787b6837055ff53b5881ffba8833a332ae57b13721815a47540549e03a9d38b6b89aa6a0071439a390c3414399cc49d0a27e33259696df06ad09fecf329718eae36f58219823d8f816a0764efde7542999aed9ece46319b876ec8219c4bc8a79750b6e87d02623e293a63b038c50656abf90098de7d1667f0569a36a5cb19f7f2baa481ea8f53570bb0d744bf5ec6716f07c0a00ee32d835a428ef30e3071c9b278fc19c4089c1fd1abda374c939dab7ef38083315b8ad9676fc40765a22c727640fb24635b86da0e5b9ee8faeaa1811c5152154195d1808354ad9da2a5ef80348786b0c482c7aa44d81f39781ac2e9e87616504ab229033de9bbd63ae5ae105b9f282ac1e82a3251e03b2955191efed4060db9455710c618f92f4f57f512e5eb8aed02d74d71bcb11c0ec2e9c4e299a8ca72c600954829c32ea7f67f7bd1e1e1f9a9844d9614cd8f5b78da4bc455638707a299050ccdab95ad4d2a91bd9f81288f09225871a358af4ae09ddee54edb7801bd51ee01350924555abd312590b106755314e86b4c6e4daf14fef4d4cc60e7f21827bb45d5612456206a2bc5059010ab52ba3ab568fe9a8e1ff303c4ad6a6ab38de4887af7107b9cd2408d83e154295cf57da5500f0beea88d89854d180389837902504e11ecb1f53270de9d5811ac4224c074463702917194b2c822b8149a4293c1f02c82a688b49a1eb55594927b0d051c06893720d4749e07a417403918c18c2becad3010a9badc01605b18c1e5e37b22c4f508af01ab719701eabc0a7489c5bdd0ad4e9e55a01bdfd295ad85128f288092325df61963020247e7816491842902553f9e4b05668a367639fc7cef98cc6afd0164891bdea9c9c25d386c084dfd13651c7ea16022db893f873e5072e599b55d627f513aa95bd8b1bea372c32893199219199753993a484ef18e8af7930c893b91c5206f254dbd28514a14ff14064365eb1449bfd23165e47cc87593a6a84134292963c87a0bbc8f3e0c12a3ea649bf499b87ec60845c44adea44009bdb273fc21d236ab7e01e0ddc267def96c6474096a8afe1a49f55a2da00a0f30a3fee65047db0d4da64ab1153a01b7c9f7943c0b8e30df564b149b7685a617388d5e2fe1564ab3733c899ab642e91da185d424122d84bf410f2e9e79064e70497869ef50fb9b9d8f463114c403296c93cdcef97415ce4c0a0c5a635d388547f47043c623f3abff46f9c14ab9b5f1c3357198c456d2019a69f448e52f532d8ed2dc474a96522ca1656f0a770f6626abb5384c437ee3857b212b3b88aad59e6b565d8d47b6b79543ad7e0716d3cab2907f512b9069d5c7de3785e068ce7b312d1cdab4765348d658fa6f539a5d8a7306517c8d37113868461bdad4b1f32a7919ad25eec686b1f8f84cea836856a94a07456a51ab56fc96a91be026c15dc5d9c07521a50582f99244e8750f9b6d575e83373dfc4e2605ab5812c920b9a643133ebb282cea0334f71e5437d98da1eddc0f50f36ee7cc78966c6aed662be312c8b1ea311f8ecbd349051c66e0229b54b499a77402f6a3a3f4149e629eb977c58ef0c0ff87f14c8a904ba219f297141efddad5617102021c61a5053ebae4d9c9e40123ca730744ca68a357114b0661da17092f2491aae12c8b9c8aa72d3327723554fa5f75c7a5be608e7a5674ff534e9e82607355abfed7b234eda1a6d6ab9ad3c35814553acb070dc85d0ceb806dcb0f69f71ceb8ce3878d708cc6b848e8319275b90b83a1a72790c117f7ccca65503c5ca178121a89eb47cbf575a7b7388b6143e8d551cf57c085590ad40f9ef56f84945457140875b882166d4a9d22e92a5779fc880595cdb47265f5ed1241bed76eeda69e00eb5d61b272bf792ca393bf73cf5b3a51646851fd5af9f3937981de9abfc75a7aee959e9e2eaebabb5dcd0316e0a7b13ec0a24e67e94cac4375acfccc01cc7496e80738c5d8f5fdc40381d05b8bda1e770541f9630ba1907cce783756c9803efd43f977c8903f59cddec74cd972bea9de860aa5c18db6e4b47e591b265d91ec7d476950bb3fdfd64c8022746c7366a060b451c0b502c9a9e3df5d74035bccfc9d16058f2ef1ec2f5c15c3f966850826cd7aef05814aa51a7918285702938a996dd0c643647b384d4f9bbfb85f70209d4bc1cb9a7b4100c31d220203b88d597acc1d6060e7b986c1b111f9d22a211640b5b8c0e4bb40482e09242ad3c80d6435d2445decffc44d03d8053028147f33ceab88dcab9b78592cf697893df46af231629a8c8b6436090e95ef88b66167b75c7b6fe7ee52edfe56fe2c97e78aaf11c57d9dde7d9c52627399313d27427df2885488164dbbd231b56761df171e81648c14f158de379333e83f9b7e1501e67ae5bdc9330f4d46fe320cb49d2b055d2a18ebbc4dcb008b9e41f1a72d54027cba7687e4419b658e4049b5726eb240e060cf599b58bc06966d5941c8ba904ff337ae8fbfe85fa838065b99e0a049a0b38d3bc5086095ee0d5a298d364eeddb1cd93fc380ae6764d2e8503201393b6284ad90ab557367dae61bd08b604d2bcf81979fd4a643b68764d4c387022799fc7be21083eedc7134f643312578f9fb2d2e6fb1598eca608ff3cf9a49ffd41ed1e525077a9b4f889692d4310515a4cf2c3b2379fd533fb12cd74ed248703ebd74bd544da6b8bfb83f97f39236b916760f5df44423479df36bc6c53c5d4f03c054ac0a85d9076444e85026ef7c4888c483b2c46c010350563f5381bc58b5af76f2698b0f52702a805f1a3cb9a7c5e423186f93532c686d54d9f39c0122c357dc5b01cf2b88b2eb8bc7e18576a30d46308c46075267bf043ad3aa4606f8ecdb15f860c69d4133c03e42c1775ee5ce4c748640e859a20502e97df08009733f5f1e93a8a8a959bacf20cd4b46ce47768cfb268248e00873d8e7e0ec1380948c087419910717c2a385fbe93b5e206d8106729c2b7e6e74896a472c953f9a2f80c82f2f285d1725c272ea735aa949244fc9f7005d2a43d23faac8e788dbe840436f21df1a5c0e11e16159ffeeeb6ecd8850d21ea0187c41cf27aec5783b2c379a04cb65a6c209337ecfcc5433d6df6ee600156b2043b2536eaf00aceb28ccd3a6b86ac0f73e8c9f407950221f1f77768339590766c967c617fc651e0ba92e2dd006d0818e1cd3df05a29d5cb5a5e5da07c69a3617f4bd035874718f4e7b437e20ed2904258405d2d3b1addd8f0c3e92507970281cff5b1618db7ad3a6405a868fa739c2969ea9864d8f1081d203b6628d50f6ceb2c26422fd5920974cb92dc8153227eb4e482bf12802fc626fba616b9cb30cf3f087ebec37f8033ab4bce2cd1e0c5e5886cbdf6fbff038784f9179ac2800608f0175a8ff5745361ba60d3835273e0d1eee2d1437e2f7f8fff57be2baf823d78bf19be36b1a485b84031c8075097e19a71e8ae80882dd92b507b67152011f2d3c737bda76db5d1d316f01efaf9e0ed0fa11738f5e8808e08adeca6ef235aad17838e0bd7cbf4b15c53ec793286025f6fff9fe46ec95637e1e095e5dbb8f8a115ca14baa15e373c5816d386c00acc88dd1a3e472e4692b1960d082ad5e8a062a953ae6d220529e4ca67f17df9bc69cc2903db8e41ee9d7ae41d63d56bc0dfe076790456f18bb160b7fce44df852d73d6067791eae69d6e9b06c0d8739433d988f0fc769f31e2c298b9ad0db0dfc0aff0a22f6b3c008d09c906b081c7131a886c5941c2d9e79c7db5303ec6e504c7b7e3cf24d28bfec4aa12247af47f3d5171d5d9dac0fec0387de709201f235138832da48a3432ed961ea72a140420a48a820c8676a9449b62e2cad85f63f64e779ae341898cb722d6b5242a1cbc49b43c43022c895d864a772881ac87423db7a94fff7df2d763957156e1b0dc2431f6545b9603ae4ab2838e0a5d7e42780ed6121e4548ff02959e8ac6581eb102060fc1bf5738c7321d4e5477cc73ca51388e1603e00fd6580b4064561c004a4796ce7c0f0d561e416a1a48ba26a5542456b4f46a38490c4cc5dc4f826fef82c8eeab2aee892b78dc7de1363c86b019d5d4817f067eb7a8722575ded07e5397b727081a1c00e90388dc9ba09c21fd16b23ff72a1fdaddb012e174579ea4290d4709511fe0572de5df6f1beba6054d3e8dddd03342e817ca82384b9c487db5ca88a4e1b73fdf500dcde5d47a419419212a025ed51b6e64cb18310994d6c36a95b7b8e1cdcfa4a27d917ac8f10247e40a03f56497894bc86cb3345863c7ff0dacc3f602c0275e46e4c58d126a59e171544622cdf587776645ce89df8007a086d9f1b786b7c50040e4bceab847c2d9fac05bea40a6848f6ffebee3fd053e30aa6803d0e9136b22639d1bca08785ae8fda927a81959ea3b13c84b7081afe73e1215c97bfee0458580d59453c853ccdab3447149d260a9f93f960aca9e5949f7a2ca6f7aeec4c8769a2f4738d79c632bcc2ea737ef4482cffd457f0658d4ca8874a7140ff6e76d9dc05616ca4ce82bd05b7402c3e18103f7e21b1db179a121a823043777d7ac698a8fda28be778df475629d4e64572b4ca5061656040ba3ba79cc3299c14aabe35baa2b457232c12d150a4e9e0d3b7a4fefea3e3815fe300a090e6c6be04e8fa511f7d9a65112d3a48e35fb97a03077500ca39f10dc249dfaa7ce67edd05501135aaf30cd2935eb06de6f204149e60d41099dc619a236b7d20634209c318138f3216a69a1c9770e4c3bc0999b33f23c2be1ac6cc98e1f48b4da194ca9106f257c8449dcbbdc525b7023261ba145fc4e616b1f0094559b7942176c7824f3969be8c09eba3fe4310ff76dd5ef39b018990db75217b3ed7577815e1b96ec5c271f1bb8d6ff53d859ea0c980335217e24324d4ac1fd5581b6483f199990c6dff014f0a6c7b46ffd0fdc1d035ab33d595930dad53607e5c8dc585e72aa45b8863fd60f0e78af06e43efed81b58131b6b27d4b4fbc55899a3031d56ec65d89c91a1060a27c1604690d718705a8e83f9457e7f9e6c1d0803e0fe7bf2e049fe9f8fd2464b9b249152ca94646205860574053e45755a29469c4cbd47d662f9567a29a59ebd3806eb9ab8f7d251278aab64431b924e4c8200b14aac6889946559966559965f7ef9e5975f3ecd975f7ef9e5975fbe17923165d08636b440acf811c9164869436bc3907c7d98ef67aa4aaee4743a9d4e65792a4fe5a93c95211b96655896362c4b1af35f9665f9e597effd7f59e2adafa0c39e96b021b640ca29eee28fe1644bb2a17b5d156c68c37074981a86a10d6d68c397ab34030c2349154e766fce7064dba8497cfed7a84d4eca904206bb94fdc514a394d20bf3b277af4ab9d9a3fb18dbae05c7fcf0eb303fdcd590922dfe8b81b2cf2ac8bf0b5444d3ba4e52fb730139ae6c67cf9bab0a5384385d40eb77398b4c8395bc3ce62ddc2bf71572104eee63c67ac4324692363732aca6871e3ae9c4c483003129119d084729c7711cb771383f080cfcd1673961ba143e7fd6e74a702cda86ff681adc4731c5077a0ffc89b6d1393c98a61a8073f5351318cd976841b37eb40d9f4247ac29dfe3f09e3db9f3e03931beb66aa7b40d1ad2144c01838ebc851df3cefd4ee5b40d6fa552ad9c0b7b8bd56a1b1ca6651bf66d4a350d7fae33a59c06d399985eb7ba065ef87c4c42071eb23c4aa93dd8ac1437e23ab57d380ab930f470348249c3075238bda0280f3dec74b84dcbb0e63167f4f0416524b9234a29a594524a299d18e7fcf9fc87a80ae35528346766df20d8a30898a04b8f7895af4d05640a2a910f2158562511f742784c2d51e76f673b140d8ad22d681628ea0485eae137fcf862b22ccb2e1a97c025a2a64b494b391d3a0c8d6a5d0b0fdadfd741cb287d8c7eefc0ec077af8eb073ebdd8fe3862c6d829a0e60a35572857425128cce650da36f8b9cea6c53eadb97ef02b07ca3f1c4551144551144551144551d4bda19110c2d0462770220bd4a3380c3a800043eebf66cb081530c678bb19085317f1da22d9f5393add17395618c3b21a343964e4755dd73499ae1d95da1db9acd4e693bfbd817df695ce15ad533401840483115a26922a884832917600294b20330048e43967dc073d938934994c26934966fb81c1efee340a72fab6ab967620d6e1f9f953dad54c8d408de3691545892a0999836a728de3d829cf7d918c580a96923d675b1ea198353899550c804963219988ef68d2c4a2f965d883e1513c67005a64fa9d8f233e4670a6625471f538f2e0466c15c2e73bda862b691ade4614610a57620425aa2528811c57230e57e24a708cd738625ca372857d52366181a1cab1a9944629f574321319ec548c4aff1472a5c9b142ad344dd33c1d4f87b1bdae9661d85e375585154d581bb76d1cdeb86de3f0c66d1b87b7546adb36ef25b4790c1bd0cb5ace89dc14881e33f84fc76b0ba2584a3d218212726a624a8245b1568cf1171983583948a886babc94fcda637d755d0dc5ba0ed234b80e420a1264073a08d28320a828c49448ae3872ce5967d5461a83c5b410af61ced42fb848824344c6a1f8ca552a8ce17f956a6555f831ecf157ac93a12efecd64013e84593d0a93cf875059b6e322759d7380ab542a95b52fab8d8806843585aa6e0200838cdd8729ba6e7713864c43eee59c73d79b5a2f16dcebe14904217e3deddbddb79b826677d3a7d76317c83eb6f4de7befe6850c7eea67738cfd3f14b04891bd2f640a81ac83c5f5ae8b8b32e79cd66698bd40c8321b17727d50a60273e5f3b7995d4c61b6ecf0813cec1235c3de5a6b6d6685ec9915727337441081ee8af495d1227fdb9b9a1f993e58e307ac0f9c2b1afcf3214992bcf7254496aebeae797154a4722453cdf615b95ab739b8901ebc5f6b9cf93db6eceb532f5d7fbb52069adb83738b1c201ea20e39508b38ec8b21438e5c6ee370d4dc9426ea9b3d67164eaaf03172a2078d691199fbcbe15199938cfa9426fea02e8c658a1013dc6863e17ae374fc9024cbb4d30fee614964ee734b877bfe3fb8e7bf83a344d091e70fc2f3f9c10683e32ce0f9dcd22a2a313a1ff957de07d7e5ce07d739c863f437b017f58ac6ac742ddac7985ad72201ee57de022a1fa30bc2a3d279ae9ba20e688a3ca029ea96c3b4683fc4a7817f611886611a913a52977aea247d726fac25ed63b8df3aedb5ecbb3522d5544b602d655ced50cb6853ac9a6a69eb8a700fd6d2a804aa715243b4711c4712d7d295611a892d79d552b6d512564b9ab6615ab66d9bb665dbb665188661d80f2e9381190c06ff055367b2a9c5bc625ad1812ec568b46dde8bbbd490c18126071ca81986d4596bd79e329ece26e3b99bcdba2b32fdb985429a0efed3fbb7d66b1c845a6bad1d155e593aacdd42097b10dc6a6152eb6412932426afebbaae2773c64a53355902164d7247c3224f56aba80da60daec89ce93cd7f512260d876927d3f3f7c6a2499324258720ddbb45b65ae410414c1b4d360de736ad5bd98f16d96a915ce7d2c1c241692b8c1285c17a7466bcd036b6566bed5cabd4225b64a9d52a795a2d4f89eb783cad96c78343c7699082b5d68a22c639ff6b1fcd8de7a8a190e7e5bef7da720b916ba9c1307cc21fc6e00cb75dc015007cce8217e459679d2dfdf88710cdcf067bfc36d8e3164c9ba29aadc51275c1c0206a218af7be84481d23cc39efbc5bb4966d91e99555f22c45d0319e0c2928c20b9fff006cd04ff17ded9b86c5b6cec7111f5b37b51d884ba6a0b4b71c8ef97518688b4ceb4f6e87ecc33bf4e31bb82ba239e77d5eeeb82ead7c42a7d3e9e42cc34a0c337c5e064b0c510534452b20950c6a510cdd8f23d8b3fc87a5e333c8685106b98805f42023842812e3697c72376a10f9597e05d4b2a2f247f011ed8710cd009aa24f86719b8e180ed01a484706c845193445db16e33d5088ca5017acab9d9597e163f818cf926198eb1ccc029a2dd218191eb33c986374169dc7d1438dcd8d0f397ed001844aee782787ec743a9dd99d4ea7d3c99f19c3097905bf4a1325a81edab74c974c6d24c98925460c31805838cee3a1c901877b3dd4d8b877d33fe800c2bdc65ea094524a29a594d29e349c93e5edd7183f6bf8a60058e0a35a648a669195b7b1a295ce8710a2958f010ab1688a3416509f20758396c89770210c51a4f9114c9c208a348a8223986089b47a04a9092d91664f80d30529d2ee14486a8012691793205c4125d230145054220d2b021454a148cb84ec201469dac602ea2751842b91b66d2ca036c2881ba4441ab7b180ba0826544889b44eee84c0f3d5074d26478c1889b4012cc94f54bee24c1bfea4690871184c9c3397e7b36a25cb790b3b4f2912d3e355b5c49c73deaeb6e68c2fe68c279f4a075622a52ac4fd49dba8389346eec0ca8433e173fb2bee7d6c2892413b6ab9401a4259d1987ca3380c062fcb8e62bc2562ce99edc5061a3a7634b16ca29e8ec807da519de29eab3a1d8b4bf2d90e94d9280d69d8aa3046476d10af87e1741ad2b08661188634b4f6e596d955be18eff5ec23ce0ec018a6d9bdb53692318f5266cccffe721ce013350b8f34d4c54e549da84a1b06398274a152428ebb5add253587aa0b25b0c6d5683bc085942f56f77a09d5f03c29c158ad30cef93fc7531ca190e7652e2efe8f13f185141c0018e48f98c15ead1ca673accd716f6e3169f48a0aab1386e9c8844194e3c175e05f57dd884bbe21efb460ce894321defa8155b9bac77814dfb0cd5952664c06006cafac7316f690738693e9e2bff2e273af24968f72fe7c7c544953e54bc8988b9e9488d9b91467b9776d6dc14d0dc3bf303d475123a68bbf14244aa22a70161593b88f95847125a9703e82290916c5b6d65a6e7bae7beae2e07f18ee66c2b611ad1e6dc3a604d75eab65afaa3db40e773219c6183f6e1b3a7a4c7c84c76ed6a6a6ea7a11258aa2288aa11a353659d45ae76ceca2fa824c5f730fab9cd18b0cce32026ee4ebef20d41b5399c1df8ee3388ee3bda1910bafebbae6e4ba0f253f9e4fae992e2e8009865c43155ef3e347f6d8ffd87ad42175116f6ac81a92478fa68bff689251c85f230ab98507017cfdb4fb40ff7f5dcb0eff5d8fb300041924d1852d82a08552047687795c2928a145175f37a7838c530627596373e303d7d1e2aa21a37531e7acb356ecf3c7d35a7b85464411a191a99a53b5aa610d925347505a1508ebaa54dddd1da2636fdb5328582ba20926910f219a481729d191d9796780e763541ea4513e5a2ad1122d8d4a9a66b79e344e04db69d756b56dabda76752ad59c69fab967ebfcf643883815ee8710691d100da94b8b4dfecee78e862d990a25659fb3ced3d11235512a326847d9db133dd9d169644fa3d3a87b85655bd6cd3963b37fb9fb58afb88d82f4823aaaac7553d5c861ee4a4557aa95ea5af14156a9ee6d194f5cd7cde5836a03d7755d97733756e4f999f63df86fa0ff5cef85643006d1e4e01e8e1e40a522c66661f39bd5d92ecf59af8b5bde139ff4095bdec4a1987ecac950fc496a625fd2232715e0d3beb62dd01b8dba4755f491f8d51a02716f840251263455494dc345da8d843811235ae7237519cd1944883ef2d168f4987a4569d6a2c874a6711e001dd3316811fc64568b22bb1645ee0ffc7c9f6cfbcc19ef743a38e2e7b3849a2a52f173823cb96e063d3a4b02eb01d7389c0e2bc8af850cce164e0cdac59190728044132d22c960e8a3223645418aa2288a62ad9d1f4c1ba0c8f33b5a9669dfb1d66e3ee6143e602214f9b85e080f293a72fb7998f6825a76b83f5da5bad7407ee0c7ba2258868b4075f48218d4757e1d9b0ef795abe97c77b8ac6e71f30495fdd168341addfb121a6952e8a9892909a694528a67eba3df4adc05479c2871a2c497cf3452d20ca5826b65328daa9c24a4911494131393c9f484c94d3e254ac95af156cbd432511c984c485a2d8bb24b9a4c319551587346e5e20a5df8dc3e685354455d4ca696a9656ab54c36c8df72fdfcaed4d5c42f158d59b99e78a916148fe9b28a19e3a4542a954a792e219fd4674fd4c55b4e52d99469cea04adc85e2c0549a4a53d932b5544b98584c399b4ca4c96432994cd70a0c20b40199265babaad86d0cc3b02539866f080df15f7f6d13a9a1e44dc6f2f939038446413748327d709236ee79dfc74fe96dadc66168cc0f3537b4cb51ae7a24ee28cbb2eceeeed6b29a39a736b5d63410f7f5c7075bde344dd3b4a7716d730fc7d542d74a69571965c6d7b5d61e31abfdda3d8d5f208caf8b3a6a9cac3975ec1089f0002214d262e9506121d77b6f8dc145fe0ffcd0f4efc075bf7ecdbd5173df723740e045188d829e73ceee401503584b336248dc7b2fbeeebdf7d2eb567bafb5b8de8de534978c4c4a46ec88030799d2c8ac7d77c39165a426c284c9e19ef5c04c5d92df3bfa7e942cfe74b807f381e9f9f370ef0324989e5b92ed20006814a0a8708232423a31b15fe9052253831ee10371f83a1a2c0f6f71407f1ef26bd9c1437efd1ef2ebaebf1607f4d7b2c34f2490beeeecf7a41225914824128944ba3744ea187177afdd3d8634a626c9c964c4f675f12b810411a2dd6ab28cb465abbf6f4eeedf98e47104e2030022b93ef83a34c78300be3a031872f6f87176cf823a3e903e109faf3e8d8fa036b9974b2cd94734943503b5d4faf9d86cdf22feb40de4b5d85246c6fbe914db2abb2bc5ad467bb04b353fb00efbabcbba161bfc6204feebd1bd5a06711797d265d865d865d865d865f8a2a2827d9354f6aac3322ccbb22c4b6b5fca184ca04e27146b0a9395125594d493d309632ce5ca329f33442efc099281c4b4f8449c928373c8669c7d76b91b7d5a32636a6af83e594c27a793a8042b419d5a6082214af04dd2de93b34e18630cabb141dd40ca1778d049e183dab60ddbb0ee31fe1504e6fe911a615b66b047d5da17952f68d6da69a7c51d1b5bd3384204492484d664145d3f2f900f7e4377b70f5b6be0e694c1900acc21b7f75e5c20bd7365ec7018eb27db699526398d27c8f56ac2ca8a528a1208655fc103d58884095648018491342a41c2c1109c71f45e42b4c385765d2fb9862d642b10d7556bbd735a4f167d5517c624d684d32a8a1255123207d5e48ea3aa474a2bbd51a96846158db9c944594959b8062bf2a42e2fc83a8fba786800a50cf6489be8aa010e64e0a655f6e80a3d5aad3b8ee3385e17e785cbc0b6dee762528fc6e76f593e9a61b08690b135c3bec4f45cc084a906a37164afeb3611482881d3a3ab464db9412142134f89d290bbd3a0b134e744067b341aed20f7e0e19edf7882f60ba533d4d3c57638c820a6251d6cdbb6b57a6cdbb66d1dcffbcf4a6470b63e70b2b2fd56aba58282eadce4a03a76c86053065b01711c4d0e387aa8b1b9f121c70f9ece6a73ec8566ad9d765ed8cf8bf1cda670041654221f42d0a0c24a1465ef43081a56c84288487b2166167250240aa2ad6fb801c4e1f3cfe14f83835540a72b420efd10419d3316490f69daadea97698c942fb81ba150180a3b0c851348c04d08019309d38a9950088970088e1234eebd84b073a75a6f46a50b46f7de1fe4fc00ca144d9053349102711f3781918c93e8fa16283214597c6837eeeea57a363e3428a24b850fc0f8c0a9f201111d50aedbc950971c2e0d122a3e70b27a3055d5da9266e4de712ccb1d9f4ff9293f234ea271eebdf7ca9052d3552c91b14506272902df8164361473890c2394423bc4aa6d35ddddf1a9187bf083e149624badb5f45a0ce49f18a3753cdcc5ffab3b505fcdb99da3c0052600030d683b546050426b5c8d754790107c11da71af2b546305061a8b00df9c12c5dd2f56b7680c0de70c28c6d7a45a0330258bd9635bafebba2e989c6f5c1de8e3bb78f8879f86ee91420a84843b0a7d5c3a4ce91e48451cdbcf4e87fbad0b627b6e7bae1b421404f79d0c743e3f7d95ce67117e5af2803a201ca2f6da6f8f3d2b88edb5b7400bee2ca0fdd65151744ca7d0162d411a8496301948e4e11fedeffa9a6538e6873b1ede3474984ab32830bfe811cd4a352bc5eae80f2125d13d275e16de161e0ed6c562b1582c16c65e8e62db5a6a69cb58eb323273a63ffc7692572783657e166152978f0a191742768cfd6554f6de1a342a5582d184c5643585848275a94bd376bd2297ba346738b144c74fcba7a2fd8794431f7dca074d29b207f1cdaec8a539d3ff83bbb80fee6203039386ff8c06e60c77ee060ff7ae07bb74030cec9b9c0e334aa67d373bae86325513bb8175ad2a92c12ea14aa55229c707f740aa9b39c33327d5cea6811f43a1b2ac860c0e3452604c92d9c74c4336b96d5c6419b68d66ce601f27e348c6e29250f03fee36f206c69d4291ddc6fd9cdd3daebfd129cd094992645ed180a13a94a8c5c0d62776d0597d630c04cfd71d0e3232d78533a4858316929648e2e93c264a85802924896173860c0ea4e6311821b5bb975d204e51d92d2832385b94bed8da897da23f421f6d3320cd39ebac5a5649b4da11574b29a55893b06fd29ce990c6ef0fac94c126913e0f88b130580eb30a50c06c8a0893c6942839547cce240559cbb08d524924128944b2f6a563857befbc531445ea7934a48d628be258924183eca1b73c9bf8b1ff74596eac2124113853b7033ff5ebae676022b78c26641f0d046708a70cb7484b5ad2520cdd7075a077832dcb39430cb2add124947a61e2a16c5032039939ef17e2de776df45b88d77879b1c1061a3eb16c510740684d42b69f13294d454585eb171d667ef4c39cc8ff953cc0f96cb0fff8b3b7d1402dfdddca402dddd574495dfc4b20ccdba1bbea5e0b71af4527f93ff1092a7ca08fa6286f5996652903671cc7d32a8a1255123207d5641ce99c18ff77163295a9e99691e971cefcf56559d6cf910cf6785d374a669fcaa8840e7a64c968040008405000831500001800068442a16040302094cdc37a14000d577a3e805e401c48644916c46008a2903186190288018000019299425500c62fcfd202af25a3cede476926b63f2a54c0fc9206d818fc040159cf0a4f6aefc8f07baa91e60ed749d43d2b2075d1742bcd3bb80fa7945c6b03d62f00a582e2d7e383ff660afdfb19659cc6015385c8a50af437bcd7837524f7e494b6b04eac50e64b6d2bfa44c81c8133c6b6b6e73ced05c1a6c24ed55d67c4e793a6a61b9a093193f59769678b8a9688a82c81b1de893b294755e589a146de29e630e9526c64172833fec060d2124d7fa25cf39990a45895a744f0967917d7c338afacc4d92b9f99e2f1427963fb6d07bbcace34e5bdacc0d7fa2d28aa0865e6ecdeb93f5f49cd395c52ea42f19c6a8e88b23f8427b54f294d5953230599815eff254d31dc54b89aec8180f0f077c75465fd946cec4cf1462a94c23935156412b78c13bc3b0c5dceab9ada90ac8ab60db5aefa194ea07c7797fe8537843952fd2c2fcfa626275d37e31da9e4ccf61327d44dabe18340429de298001def786b431a7ce3484191777928e9314ced8158c3ea8e836b83a3ac51886c4e8d470523b04b12c0e8dc2eeecde12a9cc60f7b6ebff74d1b80f0527e7c2677df060728f3455f7a41ec225d68c8fd8579603fa9d283b0b1c37a7e5568a19c1b3586e2830b848d02e99c4dddaca53fc844f1a25075c611859fc4e19206d7511e6e3c024201e88d02ca61076ff5210056b04017c2c22a71ee401e494bd4f7f985fefd0eaa0e459f1b64a5c723c562ea632c58793adabfded5ef5542a57da5716045e64bec5801589356b54dd105eae52abd44ac0d454f65a70cfcdc7553f8844295d833232334965459bcb2bb59dc359b221cc1e6541b33ba8bdd2994ec0e1b34f1aef368c5baf83d472599f6467bc44adc24ae290a6d0b8a8ac76bf3d42a0fc9f668b18bc958f481124b044e07f00618073b1925e58c15c162a9b830bd28f0e61c41b2629abac63472c652f087b0676e3b2d85f830ffd62ac5e22d87846f368b9a357c2249ce95e10fb9080af3a98176a217ff4d3d00a6e4bbc6cb81877c78e0356ccfb560260c3eac23fa2d9664fd88a11e08fdedd7cb6ec92ccd8b522a1d41008cc3c232bb64545679de519890597285d53b2671ffdbcb0dea41897c74d49caf1341b38640217cdb816821984cd168191389176c94cfeb9e17e068949687149e541f57a3f69ca67466f159c142a3af050b1549b8978345f8029501125fd07cc395a18741557f54496a191439f69def98e4ebd420bd64219404b58f3c91af362336cffa5c9eb0e42640bec22829b772c9eede40fd4903d2869df7778f7ecedd5774f4b100e746776a2fdde95ca10a3feb74a75ed01bccbd4516c332926999679fa8951155178a92b9c692a0ff1e3bb012689f538ffd11e70539114f90a13b0da116f6e3c87c8860ea453c91c4518a98921d5c6162d4972b74900ae45fcd8753cc61c5370c9d9e11ded5ad755fe3d0732817759f78221afb637ec7c57e3993e30fd67becbf4ae2db726811d0ddede8ec02734a435f2b192e4c8217c0ec681c956644890b25453d4b6bb720b1302676c43213334d24ad2b627409b327d1bec1ee3f06fcf0cf2811089ca9eb4326473277dc27d2523161c5617e954bca0df6c2a9654d1c3c4ac6719087917a382dc680231256c87b822c5a9e22c8c20d0035e542af3649632d6a533983ce8842a5e13b6482689a6641792c004890c1f19842737664dcdc43b4dc79fe6452dad542b3c48a7ddbf4fd26ec1b3b4be258c89f982de888620b28d7aefb09c469da0dda58e9282b58092d48f7e06fb59753701b436c87777b513159b43ce6aa785751a5b7a13fda5703f485c159a418ef0c1cb98b569e23eb32ad5bd151c5a4f75409c3e966de62d24c66c405825a5caf780d4868827bbb2efe6ef83e3543fada09ee8acd91b92a9b0a426799ed9a2b40bab7a9abc3c5db38cf3fe312c2424237a6ed5cd106d07b71e64f297a4626c30f4afbe78e2325258c0087b639dc9683ef76edc4dde00a1a83b73fcea0e18651830b82d60940785535eb302f5506faa736f3df332b86579a9a462e8880934aefc18270b8aa317628cbd245e60eadf848b366b064eceb7d199d023bf3f16100a7b4247af47512ca48b29a84359047501d7014628363ab2d0c0942d7f851b8cfc5375d3a63dad817a3b8aea4733952284530a9b16fab7827aa40cb3a437d74f5925b64dc5c9ea6ebba9a5c47bc79474b1cbaac42e3d8e96c8eac84225f706d16e113eed66a1b265f84ee753c6521a063f4b09ca749bb03cf7caa3a76c7f69e8b1f1fcfb99dcedbb67f5d3ad68d2390b39759ea25be59ba325308a46b3023a49c08630957c34f3ae33cb446b0b5c9b5e9526978bf55862dcc9afef56b072f2ead393efa23f8971793aca9c6213419acf51fad0cb2b6c17993ac0a27d94827d9e38e3a8725b527595ca7014cc4496c734fe964eddba4eec1b5bc25595712997d68405793ecb08b2cbaaf88c396dc02201d1baad3daa4ceaf59775714fa3cbd06802c95878d0f3431633bf964fe213e9cf56e1cbea79aff2313b56781c3b8dbf7e13aaa0849bfba71b82643208a9f129918a03d868e86987b589aa90fcfec0b7c3c4e4bb58691cb1b64593e2d5d923d4ad3175c5cc0f5173beb928e59f8bb6840abb9f8eafc30ed483b8fdd9d245afff0c2ae7cefa90b6d35de87e1e1ee29d862cd3885499143fb27d970e85722c5c52cbb3ebf78ad6d0e58a9cc5f238cb86d06ddc69ee718b9286c15cb7108c70aba2b3e70a0a23568e62a0943c745060c106e314443933b9a5e18adcfb1ad909891b11eb136071dc8c5507267982866d613a0ad7388ab6c2bc329d5ed826cfc012a76f19c9a3988218e8294067e7c5dbed236ceeb30619a490a95906d44546fb7fd59222729df91a7a510eebbdd71ac0972b124012f970c39b4159582f8f0850e028d6fb234f1244a00d7d4bc171e21ce81ca925d2e2afbd23d4a56eb6a5023d7193fb1546da43da033abc5fb0f2f2bc3f54290fa6d20c8bf6047381407fad8c58c7a92af6d5b0514ae1e97e74670e750a1d0d976830681fcc6e292f87305515ba69d0a87b0f01dd8436d5a65b0d7dddd1c1a4353ac00f33e38446398d9f5744f1deaeeb4e2e164462740eb0d351137a8b3e5d63c9362a538e21928fed3076071d05c96d070ceac4705076eed0a1f266c64a22826c8cd4769cee50b3a53303fc4a5bbd4e210c0d2645487d0fcbd224d63d8a5eb6be5ea590c1893c18a1f5a3c2c68d287343f743bd6d904ea00c0804893ecf34395237e5372b59889ba0c9d1fa2e302d13c2e94a021aa63df3faa3e80bf1eba8f27120e25845ae8358c62998a84a232c5b43d11a4f275bf5aea2ec8c1bab9842ea2614ec2ee030530a52ba9101eab409698f939c7e1206d1aa3199288e860906bf12451fb6a486c9a6c6bbf9bd75fc25246bb6136bbcf4719ebd4212226e7b97ec531c84c31f66904e631171ed4d55c2d0380c682eb5f7b8a837f3b0ccc8dca8ee36381b7f5cc9267ddc4051203afcde2315f9d4f4612538025cee70a924a19ca6620035decde70fbf2ccede068b1ddb27b9edb09e66d03ed5aece4938ac49a8edee848260b224bfd6e7962d97ee60f805d230c8d1dd279911c49c01ba0f7a87b04075784ed76de05730e121c45a9043a483b9a235152f0964b3a2878527cb45ebce69eac7dbb2ad2021d8d3e9178189e9f73a0b671b28a2384421a7aaad69ed778b30e8e077e63a7173e756f25240fbe40ad1e69156ef56843d75efa0742a11efea63ae4d076295fbe6fa481a0417f63b7b1e5eed1b5628f40e3c78686b2a31587c1be4a591bfa28626150f583d0bde714e8ab8c753552a4f6ab55f77010a542cba9d000980deb78a603befa003f74ba29b677d53a72da7eff92310c0428693d5ee7fbe99b32f5d4b6fe01c78a5563afef4336d82e1e2214e2db9389226a958270abe5b7264cf60315f5925058e87bef5637502b2313265f7a7d268c1bb5ada9008fd6c01da67c69980ee4761022d52020a4e2eea3a905fc41783f12068291f85803b834847ab62adc49313ed6f52c87ae37eb8f5204fdb9699cbcd6887dba04511866690ac16199ab8cc8c7b0827dd10608367e664cd177b3758d2d1d3a2bb8e7ae8e62175da57d71b007a244438b459b49ebd2aa139882d373b52acb6852b1bf4fe480a6e351d3a6847ecc255e889ab30701322702ac1f31cbfaa16fdf60526665a88cd1ba9414600720906d97969b2ec9cc8dbea16bb005cdd17ffaa4b2eca181e279fabd82e3734013b7c862760ce382162675d95269bc90612924f1fab6e883ac02697a89a58d4e89f567a4373ebd3bd0bbd279d5d20bde63ff24dc10cb2fe235f7a5c3735f09c3529571ca80b6c9dd9b078fa726bf31555992765c38c5c6480a32da180196656575e9bc1044b9758bce811411fcf7d2f79b2632ba4bb46e4f9c1a949e19f07684770459bc3546a743fc4daed6874e254238b7ec78120514ad4e40858343c960ac18ba84ba168b793da5daa2748615689ed5e1f8d6b3a669b61bb2c0755e472892b60e97f16e0e08557544c43e12ebeff854cdf4a867343e8c32c570b8549879b5f3e323d5efce881b44d5298a23f8d1ad7e026c2df0c58fdbad2a1d1f57286163fd8faf0414fbd9f38be581b686316684b50c2a5fa6a54e2b41462f21a7d503f3aac04aac67c142060662c32aa1273d0dc0f8fb4499947ea15c2d629b125694007e3aabaaad95c1c475def01edc2243c1529e16f86c6bee1cbbcb233b38414f8f800c2ed772f81ea9a89a67405e8db86dce67ac1e266818a31a1dae67ae4f0053697d01f3190302d1de03d40a878cd722ffaaa693647f36581f2b4427c7070a17948e194be98e3eee1b62663f5c03944cd88462c01711e99d943610a93f2351147d0e02f2633a9074efd3295c7f0fb9b3c6c1994c911950e2c2e8170e98f0c85656dcbf80bcda19af36be7951e1d634b7c154a5861e3df779586ad4ac54c34c42e00323b66e1c3f6ce7ae6688a4b7aea13d433bbc017a036ec43ceb13e264e04141a93ddb719f9b3c41cce03eccdadfb9e8ba4ab95dfbd3712054ee8c846cab5f936aab94c202c0a2949f90c9bbb9937ddca230fbdfb10a35fd5b6082487f18eadaa173926a8324017ccf81574eaad92f8ddc70d4585b75e34e82c643d70dae5a300e26ab120bebb5a83c12917324849b9b8f1c5bdf154af4ac99435cb445eb02128417149b91c116081bda59aaf18140ef2bc55207ae028835fa038ca06210bbfb11ac43c50a7657c687a24508b74ed3a693f1a174261006d245692616a5fa3618ef21138a308bc0b946efdd1d8fda64d15e9256b637ad0ef58f0bd7e7a0982f7ef138555a04b57c695924fbc242f4c9acb15afa8416d5284f21424517312199d119dde35c73bd8625e7a54d7d266eeedbadf38b837c9fee88fda35690429069b43fea9282e84d47117a465160878ac87ac67df5bbfa8345a3f86fee172bfff0c0a2184e9914a09b02dc3d5e5f9aca70c70c4db170e68cfa030975008de8a28e2e9b124792d0606fcce338d5e11dc1121afcb516011f4167a9f56430654665c78ce470fa902e53ae49807a477eb9e6fb4e03beea5c03eaa5423744e0ac17d1abc548ce8989854726e764ac4b1c109c490064d77c6ab5d3f9302370a9143a13824f53e13288f9d5b1da91cef3031d3074afd2dbb3cf4a6d7e9c13bae16a0e108297d07e69e248354e6d527f76d9a617475cb14085ac564085c80276dc57d4b6a41031a3feab429dc45e61b3d19abc7582622174e7f81d6337aa97ca672a64d5562679c80d9dccfcb8abb6397cd7f8527c7fbeb5af40ae8e64b4a278b23dfcd0bbb6030ae95940ed9d30f21281fb21abed9ee79ef14c78dceda006d7b6100514d9da46ca952809d4d42f8ae722c9dcbec8f9365eaf22820ac3b907dd7ccff00b164bb74fc3fb8e26ce70e49d8fbd5289cbc4e3198515d2e80ec75eb1f728a6cee7a557ac117f0cd8f189c55134ffe12cd95da9976b9dc750c1b48cbb805f6e6a0e8e928d4cb407eb2da462aa9deb1c0ea86a0a5fbdf9528b5af05241d8519c745ebf80d00271df256a2969e7c6a0be9c8ee8b8bba52ae4f9b12b2c1f7e1f6c6cce1241beec981d945d15d3557a61078c11cf3f229e81f670ab09f7aad3bbc055fb5d2d3d16912d8ab7013d1db96cfcea00e5d10f5c5201aea9dd38d4823f563839eb0e60c862e46d7f228f75acde2270c01685e8994854fe83ee3fbfe42350f4bec63245bdddc83de2640a841670c1e67965d181850347ce1118bc8e69f630e7036f374b6f382e7a6f5d065098bc505d3bf725c4128a4ef7e2a06facb1878d8d2db970ba5d807040a4a4e7d5ebfaf993092dc170719ebfe63cea2f025a64dba471b110192343732696ddef6f38e5fa7e8eac7115758fb971745998cf4e0736073a719a537b3e16d89e999ee0f0f244052adff6fdf2cb6a84b37b71ced93c9915bcaa99f23b01f674cea1600da4f57ed62664d4f120e8da4a1843612b108688b5938086ef15b7e460a15bbc0978e60c7a087725c212cdbb0a062b5d93e5d12792641c4f3bbcc128c8e6ed5ccc0851778ba5861aa36a35bc8fbc4caf891a2fbba244a7d76994c7e7fd1f2cf449613c71b72f16ba0029fb0191e93b45261e64a74832ae3c1ffd1982e5ecb7157024bafd75c1e5812ddc30591b09fd2e72e95fcf45b060c5a2ce914234cb65d1acf974629f98f274ed0903602a73a6391f4f6bf702b8cbd9a18a4ac92b075260403941e4fd136500848f702375294b3b47ef6e78e0499b33e4deb9cb658714d2219cbb93f422d78fa87f17553eba3224871548bf275b646056b6514009fb8a6032fc0e9409750f177df7f303987bdd75cccbab3789b56c794ec7f85e6fb232c4de00a4cd6e03d8ea308b25dc3dee58fa5762708185c82bf88278b96d8e305c9453c5b830103dcee14fd87d1f76da413cb7a8cd30f2e878fa02eae90bac34967f7120a7379d0e0f528db0382a694bfeec64f772e546346ff0170137718ec7d2a33bb4acf155a03f18eac426612784d1ef466f4a258081482589ad54204e5997f3e92c2c1b08190ac78fd80aff472a37ba9731cf50f6c9f56afe1109ad1af84d10bf5ce63ff9c609860912d3b6c06ee193d855de9ef3b41049b757f5ab942cdc0df858e16139267780795e100e04503cf320a1fe06e3a451719a441e40cb9d0e78dad4095f62094a27b7b437232895bc338f5ba0b4938f4cdc406942722940c851e5cfdfc4b93691bd718fd4eaddb71d050fb1c37cce18dc3617782509c7175bd3625fd4b0d9e89606eb7fb2b00a0ed54839804260142eb72a4477fa1c331734e13798affb63729d209edbf4a50c4ca900a98bb4a0f358291ab785632966ba14b57b92ad73e04fcb49e963d07fa266dd8a050cb1d6a95eaa7c18a8c225502e5cf8d4bcccf453f5998aa177e5a5a53130ebfce7c7d7e76ee4c6668412a52a044d6fc987dcc133df96880185254081c738184688e7dfa69fade9376b03d5929143d3e480eb9d3d79c42865384e3f24eca2294d5a8dd6947442cd3ee8c2400cf18127261846273c3362956c65b11a2ad147e658006d611c68fd564d557e73e988ed819ad84c9b5454455adb63458d31bb7d121ecbde3e5e98476d89485bf05aea48ac27112c4c6e1dc68435c69467617ef027f76b7f65ea0cbb34b5c44ca0d8096aeae18832b541f515cb59bb64f6a08f7d8b69314824368fd2f081db48c7ef890c3b7799afa9d2c18201ab1b2202f2e42dc8f672e13f0c9a2be755776c3772181490b98ebe09baaca3d6f4b3a64e93c74803dd2084e34369709fb7f5949c739727af81c1707ff4cdb8dadfc8c00814ae121090c48a9af2bc882e73eb046c1e26b042c46dc3143ad20a78110a0704374546e3884b8640a5b06b57ae60e9600b574d4838281571522703b89a54526930c68a26c3c23f53946535c1d93cb7dc2e21bc772fdb4ab067aa14da4b2719be6416b92c707a27622c55e204b34085a743f77148d6a88972d6c7c3d7b4ba2600a1f59f2b959927ced9917331e3b8e5cf5fb76bf1b2cb3108bee4ff0d0a7d01a882d87e30140c61af2d3212c971f7ce678084e8eef547e0bc65ca54431a0534cff6a4826982847f2b6a8662669b9e48064c6a7e7ae0cc52ae6655518ba5765a7d2c57f4a7c3850dbdb2e5b8f657820f72dc215e34dd75d49c42454afa42b118ba87e195d562e56c346d57d4c2da3f5b094fd492da6b96b41737a2e632500f8d0f67f53414132b3bbf1f17b861de0dbad2b0f1299f402e538ac08b200b901d054222e08f4828b6e9062094cb11f3578de02b4a15db227bd9a111416762043725c2d7a533a518608a0a00ed3608a1cef5b5b0cada9dd7f4474236a6561362710bf3350565a1d7dcef49c17775e161c3a720fdadeb4f45696ab530aad3fd4e190227d0cab95f0ef8553b98f6875b514696f119c0a18c7083336aa63912d980b351313ecc3f66c27a4e61462ee23a0a7303be455d81a6b5140fafcc1a71acb192b30a80b3dbb29d737b67a2238e9c7d8fe553028ebc9726f6391c81a88f33a83dc9e372dae6cfd756ac34336d1cec50485f887843086f90d11b187d6fe9e68062a59a86e14f646e01156911e652cf54cce7ec15d98bcb68b0402c29ef3f8b2ae24669698192896d29aea2beaed1fff9c63aab186ebd93b4557db92ba813bdc8edddcbec07112583da2333f62e6bb075bc12c88f7c87366230b7ee84a3351ffe7952f8c03a0affd90a56745a28dd8f3cabd53a33b7d0e5029fc6af0a8f8168b1fd4364b1c5e2ab7fc0a94a2b4bcc7904e3bb3f58d139c2dc8c5e92a334222ec27a10a1cee06c18a2bdefbde33645c916d10ecef3e38994ec8a8494c2aabe934a70cda2b8f31e1649082252aebc457394d42cbfd0983ff21625ae9a7004aea66aa6c3b6b70817d1bffa9e810ea5599461276c1afc51694fb9357da37fd556fd96de313731a7e92ae2446715380694f9f8f3a652b8f5cda16db33442f575c54c7f42ef0da60bbc456c8a5323a8c410d10b8a134a49954a0c1a6d7cbebe91463756f0a526aa7b369438a8a6f9c8110a68433f6c35097176ffa01fb59786f85ef4b2694518afa5813668c5222faffad826b97ec92c8b0739989096e970b366a2b2fefde632f3e199cf492833be9a54411d9d78c536022ce502ac1deeabbd86a49682275b51ba0e797c18fe92708457230ce35cac66d4701dd7ffcdeb316fe4522f27a3e099653808749ad7d87c7518fa02fee83c10e1067057961f5a4725127e11a210ff99d0f9065629632f4fc0e82ca94107886a2f40a37731c45cf22c160962f3d59129142d642263f280a9571fd1127679786cfc51b9ff4b9f25f0d3da7b2294c84f3024376cc0932069de82f3141823447403e555fa6e04d6511272cf0d2228c98a2749be9ccd2c0292d060e4f2012278271f012e2c32b652360bf6e4701fe2b84adce4a3078dcafc8cb8474215346293afe42439bf02cc3d0da7d92979283d6c8f1370c68f286441858c61fb266776eac6f8dcf2c36755a16f7801bdbc9bac2d4492e6ebf76efe88df38f0d3b87e8c4a3999236902fe525b2db33e36e666635380697508fb3aea391b8978c6aa6585a3b3201beed8a582167e97a90ac9dbc75a6513902f9cc9c80216ab400eaf1e7433c306129641faec246b2826fb711a2b0f5a0d7da4bf0a249e5c8ebdec98ba026563e0b81ee30ba846e42d01be1374026089fa1e58a7f3900c1d04e11d15307900b4c784a3fda73cc3bd8ea1eb81bb8b232613c6fe6344627336b5431e11041e9b5dcfca3955c858101333642a04fb71b99172035d8070b5315a918c639043305f214c083388abd9900203e62c52c9c8c3382c276492b971746b4427865414beca5f1e2610ed5a27e9aa4b453083c5652ef161cc04f1d49c3b6ff5f40444af49ebc71e15de033589e68c5b982e1beab107b85793864a084eb38182c94d0ca268cb4d59c54d93be162f6fa4025baf51eca72dade4d00684ccb84fdee4d5d6ee3e7c85cdf13bc1ec699dfa0018a6e3bced9868757a34e860bb38475586ccb3177fda5b6fdc859b5600580b531706db503f2bf55a7416289fed1c5e877baa0f37871be7c09c0d0ef7b7ceb1301920bd49902f834f0ffabaa2611f08230fb4d2e7fe6e075c0a1765e753b899b6bb6a5c5a779754369f7e4ed93ba8bb5bd4cf7194b9580d8ddb60ce85da4e0bfb63faccb5d4778750f2eedb84bf80c3616f1f8542bea8fdbc22eb978e4a030819d8d705c0c4aaf12ba3f1abe4ea7316bb8a3f94d0e694fce11cf6c935530474e099db288d3fe924b72e99f64aefc04314e637a57454e930b43060d314e992b58148d3fea48cf94663b07f71ab7f1255924d261158c472bf0dcc1630a642afbd931ab7d19d340c9344aa8f4daa86be9bb031a1ba52f730573028c50dd95fe8e7447d39832e3cc2d5aa740196573a802b4b9b70313b173f0d503bad24f0fbd689e06a401fb7771ef79d80d88dc4bd36bd243a4dc198646261176094746ad89fa779a74dbfd518c23d95335cc6b5299e0d6467788452cd09106a3bf62e537faca88892f228851266b1c6343248853388634e9a733005a145c6d46ce45f1921a120864c79a9e5c4ff0a26603e681341c3bb25bbc16fcce7fd242a904b81271a8b07c4c75da1fc39925d9baaaa8575286035fe5d24571ae28c0af6abb6c96171e6bfd9c4ab18527bb2d018c6efac2764855d70044cc800b9ede4b6b7ec38ef28738a21933bcaa25d105dedc687e8b8189650eec4f5d1db1dd32ff0ecaaabcd16caf445bf47d88261c2f869394c525e10a758e30999ea6eae752dc4917c6d1deec71265482f4626aff6845f47be3527caceb76c1153b235776be5e6d2a4a4ae63c21000d750c548477260fe0891eb1b9e9f1bff3bd9de9ad952f1b4fc3cb47d12d2dd4da2e585fa095755e56e2c9b6aa40573bfbbc6f1a0a34871e358454c5c9faa2908d4b50bb10f403f1e381b35c9ebb39d00aaf58374b4917498563dd488e341b7c0aea43de8f160de4cb5c2a2883998f6668a48e9e21d96d04f8f07311f34efa84c37040e92591d9feb84c23f32a7d7ec04f35872b51a8438a9753ce82171e73e0000f2d7beb6f236f2ccac0f548b1b06b4a254df3508dbf3e37aad35604118eb601c0f4a2296ed132268a9b805be5a5851cb76970ee3385bcffde98f07bd7a968552abe772ed5dcbd45946dcc5f6cd302ed6b8570a31f7d356e323f12f77e24141f7fe9c76d60dbaac3683013e17af1318282172ea45f93eda84fb338432f4cc5d488ccfaac24c6eb676c8be18f9a2ddad0c7c02bd7f118d7d49c669fad6fae566fca49f9d9adb279d4b1e6333ff0610e1e253d632e83437d359ecec21d3de502f2fe217923327761663d93a7c80ca6c2ce5993b71088ad7652650605e8d982beb012c9159c317839d61d64a9be669f10e85d98d582c2c36af66b5bdcadf66ea4de334682d559be1555348dfe01e8ca584793797476d32eba446061bc900a050bbd3676c3974934f974a10d3dafe8630fec658cb812e00bf7b81586474b0e25f3309bb501781506e676da8086f2924888cbb7ffbbbb9df2333ae069acbc92f069e56e916ba901b6e9d82067a262d6700f085dc5a802dbe0e99697723cccc2e77526c26f15b34efd455aa20374acc9b6114c6a64e36809af56de7f30e72e3c1b27f92f1ffa46ab97bd003f0ea39ee3e75263c072aa9b567572814d68a0671fe698c82ec6003f6dee5943232214b76d49e39151f3069e13c8a378baf3b4d1d08e0fcd63e09b8c333703669bb65250270f60642dcc63b0eb78bec38955cac4db336834fdda5a419e9352c371372cec4f59928b60ee5fa87080c7458df60f82162acd52c531970f0e3a8394d1fd6ad860397afc96c67c400ca3f73f869f892af4b1a046ee5ab321e1f65b650a76e2ab4ef6ad459b23600150b76b800d6d88d3b36ef11dbb710024165580b33fbc125f073b4e6462a4d2b1a58f4ac0315a3b5709f7624e63a3dd1ba468739dc167c3887b3a9ddbc456e12853aaf91cfc9e2a2259cacf0c5794b6ed9f3962840f5418c6b772cf0724b6d6e3c3da2ac764d404d5e308313cd56ee1f455c5f79738b885cd5da77ad4a3e8e2b33995aef7c456d0a7f5792f19c840e0fd9b67810e2f52d7f503870003c3cf4d7508d50e2b6c55e5b93849ec62b24bc929aa822e139c9b57a6df12b4818a15622cf075f32e9eb4952e6bb9510c109e4608ff6931025cd02bd96d534175587fc4d3e281ec845f68dc2aa060e94465c30bac79c2f8bab7cd2b096e3b2ba66c8f9b18ea34813e2e172bd55d47ef937194cef571262da86eb9ab5b32d1a317e196499a093181a8ffea317296b928df806c3f6b39d64ad6fb8fc8a78b16b1da3275f280f95b13021ea4740c91bc8dad97ad2fbb7b6b2787745aa5a46106c7edae4f062cf1254e8435b535f477dc9f150e5488c20d88f0473199146c83405bc8b5507814d8811dd049c4430bdffba1dc7727fd5a25d5cc547b4b36d52a4b4cb2354dce4100ccad5b59eeb53617671a9c6bedb62c6ebd901743dd9061a73286ca38b830deffa0166562a5b61fccbba29db1056722ee328bc16b77912e85b3d807c41b0d4956d295c6698e070645823240216abce102d212b3ce13a24ba87c5ddd6ccbcf6238743943edcecfd462828d7c2ebd3be4af91e738c60686a334beae5266079160d4aaea3cf278132342a6909cec0090eac12b2eb41bace7b602b7f4e23a7eef8ced7ce0996b3b9891bb51ad6f799985d6850c0225452228c159eec8056261ef2ad00d85bd12ae2b9c5e2642bb2606f092c714ee3c9cf04ae1e4af59d0e0213975ff9c2de2281884701a08c2806e3e876851db50256794bbe278afce23a36d95b7474a3dc80a0f7b6f64ba8d3e82f15fe2ed04432f147e9180561ee837ffec21a1a13bf5e304d39bfbcc6b0c4aaa71b315a4a0f7cd437b090cc280ec7d860fc7e6ee35315ebb906138ec05457f98b36530933e1d391c424943dec3701995ac57221b8a2fcc90063d8a8d12402561abfe833083b300c6bef70d9d53d1b79eef8ad7a91b95e7f1d810071fc6dc24d44f18e345bd4882f30d4d186a09aa3cc945293c33cdd60448b93432aaf85651dade7d436ba4f0e77a8bd038eddbabe862f7818be49d9816b3316eb08e47aaa6ad756fcda54138663c37475ef6184ac38125863b4066babe67e3759b7523fd551df3073cdaa10e6aac83c075303947d746e0bbe7c0d73ff5844b7d15a45e834601395651ff71c1fc2da244af3131809795685e3d11297b38f7b5ccb9b5663cc2aeea5664959d8d65bf9daddb1b2ddcdd87b2895b241a80e22b326d3563c80e56a769087346bbb94a9fd96c989f158fbe28377ea9f6b55684b4fbabbd525399ee01a086e08ff5483f33ecd062dc32b54220315d99098901ca28b3403e0f89a07a893d67278a02bd865366f915f1dda5a7b2c71227c5314a1bc59e8dfb2aafcf87e07433d25c54e9b95a526067e95fc40b6a6fe4bdfeb78f4606c5ac4ce2d1becc716dc2c987fb919d7cdc25d395f2b73d54c4cb6fae1351b928086be2694bbb87e244bfbfe15362386db0016d7ab02864a3ca2aacce0e98015cbefeb3a773e7ffeacc296df5c579b3d0f07052a1b9f48aee5f12ebda73f79b95031bd48f223c4b638f8d4eee87fb1ff9cfb295f2977cf8f269f9f93109573ff27ce7e99b8bb31d79d9ed602181829515d135df8744601e8179f043a86fd6cc057b06fef9af34ba30168e46e553c5b3e0fcdf9921db8a1a419f6c7babd0edad46408b9b270e863a32cf896b3a1ac7f25992fdde4579bf7e95ee1cb161aeaff8af849c32ef86009005829537f0a521ca54ca16886c3fba55476b23068d7a24bff95c6660dacea458e1006fcc4197d6b8bbd20b77f6b14bdfa37c5c495a6c5b0374f8bab7622b56039fdab072030eda1ce03d6a1330e0d33e0046d4a70667c273a5c61af4f0b193b896c5fb99a68b26f0a7b442001ab48c9e5fc04464eeb386d3947db3e14a2c38c7a25186e75330c5a816c210b3c65b43a6001f358bc0c6d8406832c32ad5a3002fc53b65f49ba405240e31b314f5aa1fa4dc9ee366fa7e0c4b4c5680672a4b709da37d2c9448ac1b8a317428590dc47429ae841e25d718682497dadc2044cdc57540a0c67e6c0f96033ad7ed71b48bc524a129c0a4e0735a397cf0e51e5765f56279c2a72d0dd1d59247f8abc64ca5d0519a691b710c8d5516f27b1cc6930e99243c1971c65d27414a9c34579269eb13b7ebc4e999ee7cdc39dcd3ba037af9eda42ddbcd9d882d2e816f85b6e7bea388e452b75b7841dd859f25219d08f479dde74cec802e86c81624cc7229137d0979b3ee3342fb7f949b9ae9fe467489b7b756bed08764e7221da1abec729c513bd42693470f36f84c8205b9e793515d70b8618bd0398b6ec7599ecd8c4995e481770d848d81b6a1d1384646521155f28833fba10cef0e603ab91a2ee3e0e0116b3a7685f474d41122cc947b33199d6262ad28b06047715a68ef2c94b329b38ce8d9e428e894c0197cc66e05ef783eaece0221a2437bf60084749f82e3fccf9e779e129c49f8ec1624134fae6852f8bebb967691ab790385e6c3aa4a35b88b9fb1c6d167b26a43e6d10c3ead4a79a5eaf8fb68903bfc5165311637b894a16a9c34eb438170f69ca781d6885d6a09bbf8bf0dab88a38a34f75d0f427d33b3d2a796156bc3929b30efbc1c1e06e226cebf61795a52104f5f95d470534bd0bc28bd19457a79a6649c7625820554d2ab695f80ca0c708f0cfd0e7d59515b81bfd9b0758fbd2b9d7bc1b59e764466416c7ac1cfa87320eafb891d73ac579d984a3a6d41d82e671ffff9221b7c57edcf2187bb0b2db16e0e445722a1dca40c78154dbcf7536cb2527d87f4d3b56604b63640b6b3978bd10af4ce70d0608c4c66c8d6260c8c802e26c4df85291528d6a0c5097424aa31a680df5ec9a41070144f342d30c5d8a4148283cfe5fd74a4a5be354baba5e725078d7d563fb4939b36681cba48a2ff5ba201ae93347547f696b5820b66e436c0c2731d895458878eda0d6d6e440d60ae1dd3a5d34e824b9cfa96dcd69e8329237df73cc6d8be2becee34b5d7edc53c9503a44138031a9be24f935b8e3defe95a8abb6540499a91385d55545dee69321fc1272d08e8ff0b8fe0a17e653f0254aa1f7fa368c6d4d5de4f29dfa8ff4eb976df7b8f554a571b34aa371be258ac0bd21078f044ab5154c9aa10ed56668627ce492905a42feedbcf234443820730740fb1ca9993869643364dbf4b4c6ff4d92bee72e44fcbeccb7f731f85d23195fe8015f0b5816b8290fb37505751b8868c5365152005b97705289c65e7315b5b69f76193c4f6dbb69fec77be5f305bf426917c0249982589d14a620c0685b22191c4a6365d17b8f92b7d3ca72c35f42ce9af50f627b0029ade625b103523a367a696014f20ded1862fe0e33ccb19092868b48ebb4ad43969951db46390c6940d8c8e80d74367915a7780044ac04df259b3db4c7dbeba6e6f56dc61edc215b69b283639aa5981de21d14b8a62599a0e59538442442b2235b090a1c5989d4687fcc93b9eb0c22ce8207fb6a0389ba0870738319a125d6326332756fe54bfd33f9973c0c35e91490469c317536ad3d848c878711dc1e52952ee89b32f939596fadcbd27145407313520dbb32e13c5229e35f9b857cd3d4604a8bbe63cd4cfe9838774a5d3a72063812d1b66e9fbf1591ea449964d4fd451e92f5daa1a5fd6e6e48a21a4814247ee3ed4e763511169e06f9c197fe00ab271b234f27f993c0c8011d1401b3c3db4754ce7a3ec6be141f91efc5a2de8ddbba7804f99987ac9cc8da33607dc479de58405843f2ae6ebc8533efd97282c32de3de3e835afa38d634d1aa87d76a9ebb0801e421959959cc34efa54b3cca73927fcf653b56de764a20564f4feea9a7a7c2603fb351a5934b33c0a278a49cf94a7822a52b35c4d70899e6d1a0e7b384553f4416387808b62bf3766ce0eedf077fa364347b031024044b52034989abc811bf4126830bd443ef833e5d92f47b1ba082a6232e46cd3ed6dde994c71ab76827e18550cee24921d0f157683a711cd58ef8afd3b27bca1f97afdec1eeb2ee009d895ea9dcbbc99c3657c7328ddb9258c1a347edf58200739425ab30d9c1ae1ff84bf291e616f5b16198da5f74ef9c1aaf881ab447b549e7ab1486cbefe1ca097e79ef0b868d7a501c64c178a7756f7547286aa0dedad17b2bf1c4d8608588dea2b765f6074d57e54dc95030e1a8601650ac749c9395b254de1a79833ee153339322bf006b01e7a43a4b15441857e808593d775c7a85587b56937194434a089469f741a236258cb04a3d5dfea4079e9fcb2711a1dfe68c3bc22d150fb499aaf431056d65079029454728b086999864e2e7fd1f968f72d37ce77601a727dd182715de56e0b79fbc661e66c289b0ad74037a5e536958fc95eaf2c36ea6504917550966164b5ebe2e668ce265135ac4b5c949f9fccaddee62f3d9e5905a91abf536bcc029b51dbd38f8e01cdd3c414975086a2124e23ccbb19818680b2d896a750999a9b34b826e45b95977c74981cd0fa9a64bda3fcd5ca96042f914493b8c8172f4e6558594275025dbc90509b84c5580809d22cbc017b9f923bd1c71b845a928bd91ebe31a50af6e3a9f38d24086e0f3d00688c88cf8b4ad315b6202ee7cb25674e5823ee5f269c7c281bcb207ac90438a56ec79a5cdbce21861819b798c98d326da3c06644a4870ed890150fa72fc24067cc40d02d856ce689b315b63d1c92a1619fbd9022bee6a94e88c25209fe68446a40b229005f70a4e45b509bc78fcabf4b0995ccd9e46d9058ee6e0acf26349a9dc36324903bfc6001880736541f402c5d40350d0e331b822d84ecf43295e28bc7ccebd75d1542a6b137bee79bf053816251ce6ce89883b1918e6f879f1a51324801c53b3edfeb759a41730f928ce53d70eb3a01608931723075b9030503eb38297d38f3b20a444952e7c4054a0971ba4cf911ccc8f3abfa0dff23fd170e0cf0ddab25f5ce308178be9678a6f7aaee4b1ff45bbffd4e1fd85d9fe92cbebb576bf28851cff3924e5ebff27c1fd184c37d64fe767f71f492abaaf7fc96ac23cb479ad16c5bdb4019f4c84fdf17fd2ef546278f4c27f937a7c1bf053772a53be0e7886572a930ba9a9cc55be9190a61a23b51486c4e6c901dc17a6eb4e7626fa93a7051e22163f8d34ff8cb2f151fe5879fc8ec3f09fffd50510b52cdad8cad8f5d317614a36048f3391ce800c49bd09bb91e90f47091f96fd59c1a5a7dbf47ef884e14bcc756f59815555016fa8cc0dc3fdf9de32af5f64ee14ff57aee0a26cefd51abfea360c8984add837d82b450da5cb2cea355f7fe47b63fb196b8bfec78be2756ce9eec2cae5802662eca7f98303388efdb864fd1640f6273d59cf1f32e1d81fcdfeb30e66b9cd800f5a33eb1f75849a41fe574d2c5f0d4e0cfbbbd35186c238f2a7f064367c10594038be2e51cc942037a7c5f2b1a6866239920277ba1a65e7a60c4a23912883c430c41a09d8e62aa53795cea2cfb61624c836fb879a9574ac9ef68bb7fd00b5f3ca7f94766e9c9a7e225502fab91b99e0b8ed631c1ceb84ddb012b8e93836fbf77fbd56001b1f8b18b61a43872df64e6a94bb90c13e32541878b96ffcad4a8ea41924ef319c0a65e6e068b7317be246a2d1744682bed142da46dfcf04fc1656829a733f092bec40124f0027eea838a5409fb4e1fc1b8e1fc245973fa6c53fb9a9661b0c0f9e1ff7536a92488d09ffa3c1b5a1f0a4cc7fe88ab0960d04b17b4d8f79bde38f0b2b24f1ddf30a3fd75b853651b4e73da1c840a1f0fee536fbabb213292ae7b1ed40dad312024338167b60528609f15457ae7b6941e8ab01302c72f6db288ce77f7161eb35dcf89bc84d70d36ee6cdd0ebf1c6ed077bf5caba58ea497aff1d9b3bc4cc9802a7b4ccf2f125482d6e0d1c6c4cd9b43fcae01f82c0562a8fc3be3fc2e534e939fcf2aeaf4aff5b0cb7aaea70a5c1480de76e00c2b35b3a205851ff1265490d126f0df0614250de7dd3bee49b0b39e673f2e4a62cbd0dea0e1f0421cc345f63afc80dbc51d1901135342f71aa1d2d5862118c869d050726d2ee09fef3e1384078a916accdbdc7fac1bc9e4042fa26fb9fd80551a75c67bc8b28c6db6072d070f54dbbfcf7bc826fd172fb42ca356cb4c4a9761107e0214e95cc482d756a342d66b4b6618d976349b25b263d2ec79b53c7d439cb1bbf8a68d0bb0ad484246f111a908c2be6adf43360fc50e093c311deeaec42e0c5818aafccc6c815d3244d88999daa4257510c34b43eeebb2a608b674e2b3bc4c38ccf2659fd923c0ebda89cb2d767b7eb9dc727a4899a605b7f5722bb8882b280ae252dfe0a925dd002ea5db098bdc349b2d9a57d21210eb44c4f9961c7f89d136fb095f9e0cf685788fed0e2202cf27780eeac7aedecbd2568d63627683ace9f5b6c69d8391a6a2b61d18c967a9c050ebc93950dbff161e59cd6f843de895d14f302161659c0018c49e36cb7bd39bb81a8eeabbc06540c5933db06a557a904a3f9c56d9d0786e4118e1b4b53eca846ae0212f930d863b8738af580067a3ee5b6c6ef1a64c1c27215324817ae8ae9edd62d0af33f031de707c06431e6e2de6f00edd47958444e5e7e7de3da0349f4670a6aa1f38ed2300ac7aa606d111080b2695042cc0f434870bd3bf710cb5255fb557f71ac6957f04684ad49ac63ae19987e04fd0981f4930dfafa236c39610edfc18040e8fbd7afe72dfe70a04597c197fb41d998c8449dfef34e650562586b6d09a1cf9610559311b157de674834e0b051f0faa74b196d14074e5d78b5ac6fb2286efa45a9a1d1189ed4573fec3323dd514af5d0f5de4e4affc147d2af527a69fce7b5376a90a4d86678ca62e56f5cb250fe3796fe02ae90c4865677b9874c40ace6bc288daf987dea8c841964cc37dabac6b5885e52234433dd6b00525f3dfea2beebc068bff9f6fba915231bc603b87d7a227dece951b89e2c2057babef5c57559efa59b2f7677e183d53e718e978ca1df9137daf4359a884937b40596392364a48fa217255d2180817fea2d3eee3352533e66b8c561aac40a0fb33c0044280c7059dc11cd783222a481a0cc3cd85d985b13ac204b790a357a845fd1502e9ff07ad4c1b51885e1a2a374748c00af687576219f57b49e8521f7e46055b6d1ca53111570d217560686c50c58615b78c04c1e217d69cf5d5966d6a6fc20a0b5ad2d5c541750704a9a072628af962b36de467b563026438d740341e4d359759609402c1935ad60eaf6f99d06b02f8781af16b0cd381e06f58745309c882490170d5f546aa9221348173440a0a8f755f335ddfb2680a1b6975d95fee57ae0990c4714abcf53f2bf79bd03e8a8e8b09489dc474a958b10e62c9992caa0a5e96853d7f2c490eff718273224720119c453ae3cf13bb8b151dae622a1406ec6d2b00913c26423f6d3ad5f16ea1f1940363aaae7c989742b8530d7ebfc07c6cbee8dfb1d7911c91f1b18e570dec5182dde7846af6ffd200231b46629dc0b791cc674c0568c9e4ea6b8f86fe1ec81ef7ce5dfd505b78d36764fbd5d17cc2e357f95e38e885c71d3c954f17dd6209ca7d83975b9fbeed37dfc13966708922ff9e13ceed8baf7881c543790cb87f5d2f80643703c35c84351cec52905dffe9d645f08bede8eac7b3377119700dcbecfe8850b0d07b1a710a90190b66965916bace8ed1d34855886ae2e0b0ec88e0f50f61730a87d8a062fcd810156c26a3611373454756110286255659fe2515023ac282c454b70f80fe0629c2a5353b1802d35e33e619e4e4c06ff81420ba10bb08d31ba1ba20e252ee90ae239cbeed027d4af5f06cb7482ccf30bc254b19ebcacad8b580c44206ed0ececa6682e8f7ad65e77a43c663103b3dc23cfdcda54e48de000473fe9d6cecec9bf20dcd05e7b32b3ac8b71d522029809e537f61b796e185dc8d63e700f03c07e997dda89672a6e4f6eaf9058f0fb884ad6a6d3b8bef13f6fb76da64c2c90233b4455769bb06b6f3b7a91dfd753c986ff6157f6a7e653d96fd135e32b39aadab067499268eb8650fec8dc0261412928500763aaab80224dd009827262106a2c900a6273845a42bd3d07c5cf9f21138a82eb3b7b2be3b7c264ce752edaa35d423eb374da021dc2b617f189aaec1a368202bf297fbb6011ff5c0157e65cda8750b7e3adf2536720b8cb94419bca4a4ac02de87fc9cc95c1f64df8f02ea3a05e8fc19f85d63cfda3c9257231064f9979553bf202ed6582d1dcf75d8ab168ecaa3860cbc08f1f188a72fc24754cbd51fb5fac4f5bda78107b25d034480fa370074ce14c2f98e31a6340372b6a85b2dd7d1c10b65872871a8c89bb5b6d6291f1ee8c83118fcf4c6876d2cf246139e3c829f00c64132065c272dd26f5ac72cece4568586c93564d70375fc7d510ddb0e60f86a1f0adf11ff636dc17f622a87faa8226278d1085022421aaee77122a234588227dc00dbbe8c6066c38cee9bda5a9e93c8593b917ca05a114fc24e03e5775ec6095f9036aadd1e386bb00e4272617657d12658342e3426bed1b2278c556ded8d22ac052084371a8558bc01933caa1188ad95843ae00892f1479aca1f8e0c1f94654fe6a8e966fb04ad38c19ae7398c83f0b65d8d28d656215ab5ec576a3b6082e9125ca956472edcd6a12502db97b0bba51b225cbfc2e490961f3f3fed7880fa08b59aa3175cb616083a360c89279efbf5166a5c151d8d7993aa16adc259eaaef8c919bb1881ac1a2c0896bcaa74d5b72bb06706a6ecabaf198a65b58b72209d2378b9bea7a78b779289c2ec7254d75c3544a945e6d79cb32f42bb8a4f0b00434151163a3a4d593cbbc6426d369380a067151dc55c3c44113fe7b1e8da9612806087161ec3c75d206ea41feefa987d925e7de71b401fa6bbade669e311a6bbcef828393d468030486ad9d006611fa4aabdbb8abe9ba4aaeb9847216303cda8076fbd851cb33055574b202204a0c3c2c487b8dcd06b37c294674a88fc99b45c6469ab17d8585d2d106407b08eda019babdd79f360aab765d93f407d2f46c367854779e40c571bb6e430fe9930201960b2bfc186d20616637db5bc8be8be444fb7c952140884398ca66b1e00319a88c4f6b36451b2c899e79d3f4a8c5d5eafd4156c28b2ea970200342957ad083f86c10fb690b3b74464bbdfee0b301fbe685ddd420971c29401349a7a5e61a7472f3e2e6d676ef9ebbe86ee1cb50fde19a33ea892cc59b4222cad73022a4a917b128a7bd6b60622979bb85b2556ad77a382574afbcf15e4265c35577811ee9148a5989c3870370ef610b364f21914145a5122ddeb6f87950dd87e3c3ab69dc869e68481ae43b4fd0b36868e06a391770e823e6ba442b8b8453d80d2c7088bd6aa039971a91da348582c4e51fa7eaaa558a09d72d0cb232b291826038f626a44e4d0463751c787c021f6f0ad2dae04ca9cd1aa4d2466026c8622499ef7346d7fccbe7490f2d9df3442051dac959c7d784330b081fd3736317d2cb69ccfaa5f43e554e348a07c7a095eb4101278aae78b6991289f71e3a2357e21c2fc2e0e793a206011848c528fb79c64f53f219d9a6c5b81a1650908ffaa9dc7e9d7ac07c647aa10b15a8fd9c31be18ce4aca22f00499341521cf195c24a79cd18a2afb1a332650ab7802d8d1fe5baf5f42471019d50091b5ff0592954c789db462c19ac469a16ee40393b308b58e6f35104913ac56f5bf340e7a4d0dbae945c56cb7e0e1d9566febe127029447e204513d76f5fdc4a470be7917d9e972f0e2afd2430052b0a9f4a2dd4669f739f8edf1917bcea9c4ed0079fc420fc25f83879e54cfe90781411004cc33676ef018a598ccd600acbe051a3e1093ea39ee4d1fef0718bf9540164a5be16a1d48fb887b09f902676f91636cc4d9ee83a4ce38032c88dfa74628a7b1251732d4ccee2cd4ccb1ccdd36111bcee342406ea787c79ce397508e5fb2503af2b040a824356724e30a502179bb8c6a336c3371d4fc658935d4181f5c1a793c8f89eb10cf53ba5385894efc739781f1cc15a12f910dd0cb5fe0430a9ad4ad9e4569ac71aef71079484e34082b2df19e760f2a821145f0f7048d6f4146aa939984803a547d77255fac21e1c2ac6665f153400335f81a60630f396225f3e2c7465cfd14e6760b20e9d6edaf1bc6705f4cc8cf575e2c511dcfb48c8297d7e946c67bdbdffa73a0207c97c0ab0e262cb5a7c0b733a4bd8f326439cd44a81de72989a25a3d10853f3fbfdd1650b725039e2c57eac1650f9b10cc4473dc3a04ae8f4c4dfbb087ea1c1308b2e0fd02625aa1b514395d709b3aecae19c0c31c5d4c0283126e959efa474bac198aec8a1a6c53052b04857520e8bdbce80c7f34beab607e660bca8bb97ff423e8d1dc7537b1ffb2fe2a115d15c5bdd556cb94fe4475856c94c9e296ec990a240a0d331fd0536d0722cebe172aac5afaf47f25e366b9718e26bf79987f9202a9c829c20745c35d6c2e852c984ab202a6d556dcbc04de62c74ea6ab2212241bafdce3345136362a721c1c5c2019b6718b0a7e736e5acc00333d014d7ad6a56d040afde47d361f19c93947b37c97e24d47655da3327a9f594e46c9f43c58991718232130a546c03cc0c81ac3b12e2361222ec87ae6b40b951a126ee409e849cf57c5d66555399ebe38e0b95e8b2020b79363c5fbdf73e0ddf2d0f86165ed56acad1c83ffb6a1192ce5941e28d3270113c5100fa50a1ce683430c4301531c6e7b1de339a102f4b0e6b6db4f23b16b3fae68f4426b151783312d294e22f330dcedba593582e6af622e1fa298f97de5d2f9be1593b7786e33ecdc2a6ea96b036d7e882fd37e39681fef2b7c0ca90f464bff5e2a1933be6d8547859e972b94957afd0d0695ed206fe0b75fab9f04cc21ec242fb26c8c09024949feba9f5daf4012e25b6deeb4f25ef105f223b0c7d71fbfca6d43f5663f25c5ccf86c15670b0434c33bd77cf31563bbc19106981a6557d2e29088d67c468b07edd397aa99b1a6424687092c6ae79045722b4215280d7ac5f07cb1180fa0c91404b1ffd0c0dfcf0b41d1dfbdb1dc6e2575ad61f401f1f71827f541f9cac859a20b6e699450c1813eea20903b01bb8c29c003e2a4fee05091ca637f9e1fad0ed0227512a2a36bd7e63aa3f66b388bb52611d2e246c9cb591142f0373b06edf2c9fd78b7978f6783a1a7f090bf18bc5fad13bccfdc237bbf7cf2512431cc7c5430f313f0fd7d4884598b9cb2f8632099dfa4836a4a99296f0b8a347754e78c3e08ca9216a0423366b4e3067e76da5298f5aca1827f1d4bad6f03fa2db26c1c2349f32c0ba210bbcf835823c8c420880a0c8ab1b4824158d21b1cccb65b6167bd85c21dda6e3e50bdbccd0888b10144041e8674e3036d6a178b31d18ec327ee9a943954383479c93fc21a8fb543065b21654a118c13cc0f2c34c7889a633f4904931d5ae0d2405b973605be9cd9fadd91536d990f5974d7970239065addd0db7ac20f966b58c0cdc9f814d94e6ad31580f27424b7189e1d3b7976e03d52238ff767396e1c4f92966747657b04611fd9d63fe2e0811485ce948c095fa66ae95417786cb8a647c6074dde996e4f96d5200fa995f495de60bbd321bfd2ae379cda28fc82506666f15e7672fcf57298bd7c4b90f62d4ff8c2c8ba5ff6d285714264c6a6821324f29d794f9c40a74abb0bad2045c327a35cac25c12a6f60f64e035be2b0b92fa2ba60f9e53e183229f99d0b399168174bee85f673526349e43440e568724b72eb475515c35feecc644627f181723da4c27aea1a9d9eac2474b71bd45675dc744506bfab468cf8a0dca0b2b01c517c37ccef474b744b3baf5cc8658444a1c87c849f550b08a2612abaacbfee646a1bfb6a41759b1a0b44c0de52b38311ac897d613c277d5efcd100404515274294d4e93d9c1da388c9def1ba4b5fb66c18451f11eff5a5e4b25f62257a84f12aca9a08de493aadde18408532f7646c6bc75071a17773b2963e8863a8ad04f10f1cbb87670858c9773ef6195aadc4062e7f996f310e0f8a4d4aec1a157e4fba89a2646b5ecd292a75c1106a549dd58f3835089d5b00e074a822f49b00a10753b5bfff2b12d574d4e31daa9faf8a9c348e65b610a61d3f22769962ab6d4a853f17c532a59a29e36f93ad5c9db2ecae4ecb64e59a838b57e599d04719246a41ccf12cd3995bc7766229488946189c972b15ce6cc5924798dd989f05db20731dd2d2cd1f20a94c1063bb75b9e4832d7e84d6a1a4de7573e5673f217bab3320e470ad88db461ef4a5d85e6f00d782b8db003be0c420cccb532a782b8608a898f451c96fb7b92f3129d7a458547f8a928e373db2134f70a36f491a42164b162ccf162496645d1d8d9c4158ff59da588825aede81c172a59ac534ddf4a873793b168c1aecc059d8b5dabe17a2b865b1d32d0dd6ff646195ce9e5f07f684ff2394ce5f6e7f449b19574bf66df92abb02ace7520c1a4444789ee12abb63d8116024c62c7abb87e640e79ef8f18d96462fb8dd631a940e300c2ca9ade500ba0aae6152183d96bb6403537878613454272ed7867e19cf02678358373aecf4b66571b0f83f850b5a7c652e674ec8269e56348e02be54ccb12db18cd69b23767e7269993eeb8d8c5279645ca11ccccd3d2fd1da18d5afcb718d96750f6bc590184d1854c8ed27ae2798207ab7c2a3ae29907e1eff4235f7ebe8040cb990a7051891757bbc9593d08699c76d50ea016a7aaad68870448f34eefd45660204fa03d463e1c6409860edebcc3a27cb4b508ae45cf2d2acfec0d91f51c4fbee0c1bfa261c1c47d152ea3a7aff3a8f065a3e6b192892faf85a03efc5b5d6336941fdf590607ef8acec096c22f39fba11a00f6672fb08ddd888788025d740039f11758817a72c055ec1889daaadd3e73baf9df1625a0891e750604b302069619fc0036ed6c53ee25bacf4ca31e1fadd68c77ae542f70dab8826b00ed10106a541f99b5f54a5fbabebd0d991ffaa927fa78d560add28fe08fbd66145349c2e2591ee4aeb1dc256fd4ab7352f44310240b89fd3bfdb9d289fc9d437379c36058bf256ac3a63483b4e20bef9252c8484766c03d68ae5acc436ba65662a80b8ccb08de04fdb449cae5ce49c4319e60f5ce8fb4972ab858ad2e602af963f92054348b38249379e1ffabb2df5b9c220cb702f92a7062177efe5bcab725c5e53943dfba69f310f71d429d497d96ce300ff1bb5f551f305fb3492fca17de04273f2bac0194baeb838bb000d2556aebe7d40c31255ac6536af19b34a8a3a040718dc58f167d3d16551c87a017f87647a27562ef4830a5c0430b673508dd90c55260248731939ebc4bdd7abbfe6e5e081fe0009e79371a580ddf7e0717cb251225f42b267a87b675ddad92aaa3753463bfd230b8ca0421a22e61f57bc33b0d0fa1a2524643ea262cf51251f016a331f29ddb3d8749606f57fb6584b77cf6b90f742b7c7b4bd0c0161db3b173bc0ba93a8f554e5f09caef6ac7e5139112a92528ea04e0be8099047c3e640f55db57bd8969c0b7b5a99feefff4d60fb8fad07eb142c21c519129a669825994fcd0acec5602c9d0bd3b59470f8b43d8c0b730eb4b5dfdef619b2c01729bf2d596bc9125db0774e08a742d1a6cbc53f436bc485b1ba429198ba7cb428f9bb216e6efd17b20676218157afef3f81ed0734e471f72d90250c17a8dd75614ed910756f64d01f59be57060ab23c484d8f196327c48346d1929ad0cea5c8ef4e918a2584c625ad33ceff46f8952f4d7607562ffeeeee633de6d7a2fa421ef27a980da427cff4d45f5962c1a70d6b89b8ad58852aab47af230092d01cd60c98321b4aeddf0027da7273549306515d914fbc4ce5cd25c43ccb5ed24379381801557f19e1d7d2e14ee0e256d89ab0a422915727d16cde6dd128d9d03d11b51d5c69d7135534ca6aeed8e5b05881fadbeadafa458af811c91757f29e1cff2a0c5e12ee76c5f5ad9e80c4d7798fea8bee7b8a3dca2e66e4ae3980c203378dcd52172416d9855a0d0038099755298a1ae0f0b86acc3392c5eaf17c71bde76a3e32f3963e470ae263c00438661afe371977a22442d9b837b99251b354b08784bfbc3e21cfc5134a2c68a94bfc1b8027819581db89aa3763b775864d27c978fdc8746b1ea82581d063026a2ca293561a8b1c0decf1076a18aa4fcbe73837f959b7ca8216874b03103fe1a43ec22340878ea697d5d770bb87ecabf7d56bace48c11aff6a9b08309cb341b7539e3c707fde42f72c2166a044824360e24638c31065ad1b82692c0521a8871ed51ac032dcce313f6510e0a4160ce97a3deaa8e68eb900d87b7c2726ef86962376a7e36186fb9175607a6aacd97b7c406c367e85bf8f9a6355da3e167b538bec7bd541f191b1d2a0176dc2c4832138bd293b54c93dededf8410af2f72e0e37c4e033f3f8980617a9e2f4341798a5ab15a798d1660d4028dee75adee4d0af74649470a228571e9d94b594981a70a84916add37da6026c110e9bfda93072314f35a18f956a49698bb5fd8d12cb481e51ae5dbef7b5e53222c570be1f9955b4fc03d825b4061e195b5ffb07b9eeb3a750f40e848b817fdf24694282d0e17fd0fb860811cbc7565c19fb4592545b8fd971aaaa25aa548479b6a5babdaab57ac836201179f129a1333f085388eb3986fefd370dc56b88265e303ed6c0c0c53fdf443d9502d28835768ec33cb110f7d9dd9ad3f01c39d6585f8cf0b5d2aafd279c421edad415dc82ca599c8ac29caf5d6435e8cc7f9a52ed4cf5ec25372c543812469789f28fd8d8d96072da1262fc9b892ca149acd93dc58f18fdcfdf45728238554a64821c356a1ec56461efa9926f4a5e509b7715c341f4eb15237c60eb4c7e2b41340a0450b4d1c0173e7dec2bf4c0a7248206192cc37916e860be965b151587766cdd785fa005d0b20b2357bf7717ef8e240c619e8aa01c627b16de979b3d56cb8191983cdddac1893911d6b4dddee1591f6a01126d65a492b11b074415e2c07590dc3f015c1182b92323d2ef456a1abe24fdcbc12cc4f17b7734be358be389844cb19537b0527a42cc7a685c4bef8e4fa2991f0bebb45d38ba4f3f44cb51b3cead60c764fb02760c51dee1e32a3bb671f67585322e23e86173630c0413383e7335d77df0a96d0ad6a6161aa14a4d4815a3d7f6cb74c4337da781761fa92a77e06934966e735eee1f9340410151d5de5f0247908ac95e60d67ecd78b9e0794afda2c47ccf319ba1389eddd974eb73c23cc763b884de374cefb9060dfa5ffd031ecee0b1119600ce1d2d069986bb1f099c0b036b1962c54a5ab693fe44675bd83850079da9fab5f3a073af9cbc2154779793ab22e7225a272f7dc599386f61ea1a2c148142d37150ace6786b2ce67caf2fb90ff46b99a616fe544088d99d43549b818211980f5e374d0aadc7b38ba7162aea7e785548cbda4ae85fffdbf7afbbba4384c634bdf9f97d2f1f5bd540689501364980a0e47b9e9985154f91ff9407dc2437901b9ae648fa30021fc638ec2af60846bf3123027f2bd07e508da449c3a90701a4536e0781313defe21cb11482933251afbc50b9164c01b75f9327e7ba850d458f7c5c27632f825c9c4585885ba9f735b8ba78c2b56740d6abd9460069c5d02aa71814c5e4010424e079c48509fbd9d87254ec77dc26891177202d14e2a3955c91b46bf28b6354fcc4f99f5ea70983f81cd73b51d11e662407fa4dede007b5248697cfc3e000c01690dfe98597fe37b1b3714289b67ac7dc86f7b77db724b99929429b704f104a80477766dec707148a66463078f7b677776efbd3317a14c9d973017b219ac07180960383c2d2ae2869033e9d3592ae188e082f2c4154c18d8d431ddba278a3c9564aa2ae6d9e83bf2672af98ee9c7dab1c88b8a6e2fbae8e26c36b3b163cb8cc717fa640bed2189fab0042d82c160303aa444049986408623f758866c48b52dd2e7ad20b1e5615e248aa2488b6614082ba5052a5a24d222f145175d74d1451769a92864a2289b55516294a468ca501351f48fc5542a95ab602caed2297acc251689f090cc61be63c23277e46c478e335a98f9656eb1b9154571c8771e3063642fcb2de2d0c762624c8c4df1b38781cdd0bfc83136c4846886bea585c5863445c533994c9c899fcca0cc4cac391363be3391c4c498288aa29128c3c58484a702134a2975efee9eb5d65a6b952d1a5488ff7f57ffcc1f49a3aa2bc4fa081b0c8e87367c17a539b42d2f586bdbb61582a769e34c6c7928d03b27744ff70a3f9a2a5dc75f69cbdaa75572b6eb68784ab8ee5adf29ae11030c8c90439c40ee20ab136c249bcc1df9d32f2cb37665eb8f9b95c8de9de04116a315118ac9623c82c631a8729c4c867f51fc9ab5be93a5a4f87f7f1434e0ac22ee50074ef0f6f696e0cd04df91220a5246ad76fb82c2ad0341e4d7a13e35a48c897bba19a48f7529a791283d294ad143a186784513bc6bed6b04293d51fcc21c9b0a10701cc7b54c06050f1ebe834307997ee5e13bd68e76a45f47aa82ab64085f69c4b2d609a5b4d24a7311f1f0f0601ef9f1d42aab9492561a004a29a53cdd0326b96bd624ed56332cb72ddf0e494e8e0b735a9f0b3826332546b20ad1134e26eb3b6b36c8646fefd4913b3566f774cd09b87ae2ca2cfdaae47e7e5923fa407804d594a83c0de2314390134ab2224231598c870cea710cca525a60c4590b8ad6de60b797b5d676b693373b4d34786a08811ea0943efd1e57e62a3105d2fd218b92d2ffff27219aa064d908c857a8f29ee5d7e56971dc45e9b04baa586d569bcd66b3d96c369a1a96bc49cfa3fc87abc96469562b666a561af8f1bcf6214d9d37ddf6530d431d3434185ce9a8c1290f955aa1c306a3b00dcb632b3e8cc23658e8c3365f0aa750df89357540d64b524cc3bd3c13cde42c57ebdb8fde99424cb57dffcb9891dbade5184b7932cb32c7fc566b6db5542adab79a41a81431f43385101942fce1808f98ec47ce600508db8f47a94f4a653fa5f724b11050f020f4336f3a1f23ab905c1784c8f94ad22709e9c3e15aa4c6aa8ff69161a45cda409eb8d29ab5dd51a5846f79625aa4a2294dd38fb5f7ce94e40d759bb7a1a10a0299705da247f754fc61be4bcb98d84bc798a69fd7bcbd8cb1623725a48c892b8845ca903f73e63b3f676f4428d631a69096f144f20ce336d80de6dc57a5acfa7f251ffa2e3ea890ffdbed769bb79c6ab3b1c1c3906e45c62f5fab1175cd03305d92268d0680182e872b8f2d1fc4b1a4945f721314aad631a495ae8d58c669abd97258695d6925b55cb45aad56abd57a28c116a19f0c988e1065fe020c068b113d293214246b2294e46130a2144e5c180e3da59340c81e2409ba2f1216ac1949605316a1425c6bffe9ffd75abf4787bd300c433725d9bbeab24dee2a56fd731c676bc51c0854bbd51213ee31752c36b1660fdf913f9d65e1e8b85c978d2f9c0dcae1ce22011934f0be1328e528e59842a5505c9696c6a5a571694ca152282e4b634d0a75023f8f86e6d6d0d0ccb05e1ac8174b9c425dd673014f2770e9f34ee0d2d2d228e5f875266b39eec32fb3349868e84629471a6818979696c6a551ca51ca71695c1a53a8148acbd2d29842a5505c96c6142a85e2b234a650291497a531854aa1b82c8d5746fb2914ed5228da9530b3657574e9c7142a855a1a1dd3cc9f203dddfde481cd719eed4cde079e64ee0c4d0dea53a9e04085940d7e1256b9111752a9542a582c52ccdb54e23a2bab54e645dc572b10a8c32b160b9b3b02949cb9f3e2967164b1484d2c361b0b162c6e5aa06646d3e8c511a9765373a52865b1c614681fc78202064ee81e19cc005be31cede346264c1daf7b4c4832d913a427376496127b0002cdac58b0bebf333317df197c71cd6a0e8140175c32651f8805fc64bc930dfc6c349b5846486ee44648b22732d993f9a4a8a8850b9a24e24c9e96a32f5e80408fa977b893f867d8b13a09674448e845786791196bd10204aad8c50743465e94aa03b9924996ed6028896c68064dd88b172fc2ee9e53b646463264b676db368b5c33cc0dc607e01750e9839c6fcb38e6c4f87c25b1cc70da6208c08454abc9c4298aa128abd0aa003819df0c10acab6b309e369231dec4681f37cae91e0efb282b5a2289aa11677d947d93f1998cb229b359abd59a0102673b292e91424c868666cc980142081505a51e4ab2888c8100020821d0a0b63361894b450821844063004ff3311c36680cc05fc9279938138b339c414e3880afbb71efeaecec804016ef002db15baea44fdfd626423718ebe880401dd6010f309be7abe1c9dd417e98e3cc3b753adcb58f8fb64da69b4df6954c9c297d1ec98bff0f7b0ef8f89db4f371a0e2effc8162ffda7bed94d96030189030317c12872d2e32cc185923e50e294676982c5b0ac9a59a8d1c6292a584c1602afc4813c84c79132365bf66912ca51c132583f8a70e8f0e08b3ece15e62c29a3a17e46e8988dc81e92a625ef85a9029b661bc84f1c0b54982041b488211207b2d7bdb9eb20ccaae8a8d62d692373f4431029bfcf8bd10f48061c10d6eb8410c90c01811213f9e3539263ffea993b22c14a16acdd60c144262160a304240226c322aacf049999d5a8879451481320c31898e636d20d2d13c2676ca6ce2346de2f494dac4e9fcba2a13b0400465488d881f375800a302e48614252b416644b622455b84dc18628c727362c80d22642a03c06e298068cd56b843162a4a64b1f242873b933b4a96248cc8d2c48b24ae4cd08b1bdc0bc307395c9a1b865c9413183029306e23123e8c4938398c4e44318a995d530b3831dc0fc90c1fb8dd8a830b19ee69042c48fac105946b734749a221d55e80b99f3b4a12521049361843dc2f7794a42c2ec4242fb0580e6aeac8562a779425885a4bb557acc8d1e10f733f2b28ae3ff247822b747c0a8e2dfe562958560a8f6b4dc04b695ae155c5dc63ffa16354faf3f3d8621d8f2d4b87e31af3a79f748c8a6b4caeca99d18aca95b439dd87f45e36b7784c3127574aa10a787dc34287fb0aadb53fdc0659426e63990f4ecab55163864bdc76f7fb7d79369e9826a960f1be6e60b8af36aae1ee3e6407dbf4e1f50d0b22aec4ed3f6e83aca1dbb8c674406a8c104c62c07de34d164bc96d2ca7c441e99dd6ce1e8e54a526b9a2f55818cf6a59ed58c2ccb087013e4bdca3d216441b524a2965ad392d5aa7848b2eca66559424299a32d464766777766777164700c8159f26122560820387d8d0223ffeec0e47bcd793c58911a70991217f8b204fe495ad159f6007140c65b9c188177e2af5916badb5d65aeb10b533042830a29fbfa3180c29c84e72e068f2eb60554858d48f2d41669828aaf9e1e57a31a2f92166888c6d26489153134a170621b00922991b867cb4930e413c116c126412bf22221d0e2f364f052d58946ac871da8816645758883511c3d145e9080814457028156d40c85864051c369821c1d104ed28880788e0606244e11544a31caad150b8d9b25feb2c094c98e4aa88b1706d6cb872051e82d89e1283a231bb700205930683c18e44d1a202203da50363a6307eb860ee285aa49440cb0b5c50b95cee285a6090e40a102d4ad0aee78ea265091b19b4b828cd224c6389e90ac79de30548dcb152e852d0414787254ee1c76311e6be46c8d415e4ad706cf10a67e998d8aed0f1987ad8b9cab231438a9d5563b278b82f55b70a5f61a68e5f2d17a5dcd13da92c318feee964171e93b58345140fa878078bc96dec49a1e93d4154eb110cf4e8b0ffb77c3c010d645abf8ae90a02f36b4fffc71d6b8489232d0f0eadf4516b25eaf6705f570292a7016d93ba8bdce188dc12db2c16af6fa4cf8ce57eefb4923f3468cc90051357e220b7cbafcf7d5af54f25e276585610d79faf62ae9a2a06575cfd5692c94a12cdb062d34a369961ed1d8e533b9b7cb2c4e7cf4be6563672a1262e4dee23159a6489714c706b721fa9600308ee4cee2315845ad0eecd7da4028c862bd325044209181db81f0c421e6e97fbc8470b4224d73b7231c68710889323372a37dc0f071832a8618ae8c3f5721ff958c104b7e63ef211a44596cbe53ef201a3b9a37499511bb8a74295c245a3e570d16834174d872b878b46a3f9d72e1a2d878b46a3b9683abe3f4551dfd5c7db88aa48d009aeb9e3a2d1683453cb90728a0aca08e1c4613b2146feb8bd132de68477174d872b872b29c9f522486fe58438e10c1180c879e9fd2d9ba391ed235bc68cc9d45d8a31ae5f07a8073febb2b56b1b756e34da08a12bfc2b8e42152b57925cef2e9a0e570e575be92b9df4d2c33027c4e9300c3f10fc4cb7939886735c2fbdd58a31001f12bfa40b395c345a0e178d4673d174b872b868341a0d575351f46decc499aa2f9c2a3c2fec7a2fbd7be68781a9232fd05d5e49ac42a680219f913c94deddfdffff9d524a29a50fb8930419ffd34b7777772ce54bf9ff4effab1e67b2de75d6c479edeeeff56b777fa7a07cc09ffeffc6656c58ab52d15a2b5d514a4998f7b3dc8dbbbb4b4ce9af7000e4631266f84e030306954c316d3c95f3a8fceaee6e4b6baabf97af1cbeb057ba12bfbefca29452fa2ffbcaa189dc8ca59452eaf8e5b793c194524b29a59452ea81df077a4aaf97e9a8dbeeb7335fb9ee6a739a46536b28eabdc8eefbfa724f2f956259777ac78425ab9b6567284daba69452fa1ed8e0e1779f3add3dfd294f6d7116f5594ae9d3cad98e524aebed0429d64c1d8952eae269e5a03ecbd9f99da9ffd27f7de03bd269becc75758cc63cad0f3cc9dc194a29d8dd327786a60675bf199aff477dcdff7f8f4acd7c3b5d4decdda2391da331a594524a2b4d0d8a529a9ad286e2d777b516d72a3357ffdf4bf1fd972b255dbd5ab955df2b85faff5e2bebaee28a1072ba7b6581edb66ece4963ce3973e6f4e9d3e7df64efeeeeeec972ef6a55f2bc39a7e339fd954657ed7dce9f52cee67467bde69c73ce39a75fd895787e375783faffff9cf596ad7f73fa4c25c5e0e7513c29ab398eda315f393a865677ec4febe931f8d9dbe3563a660cc5e17dead0ee6581ec983eeddaf5ed9873bc9646e7bd3e98d8c3691f1242fbf4c6f3f0347926fbada6d723db9b2debbb9084d0860b870e04341696bda9b9412c83db08374f4b75c3803bab9532bae72439cb8194b21e012d63e21bd646a57d35dbf8367aeac84a95bca3bf338060a6cad10c3c7490bf07c9165b9e34501d2141fa37412808216a803283211b55e194ffffc3c712875454ca01c8145b8aa4859b2e2f9e40e7883f715552c5c95083235fc28f5a95e106a2039951f10521b38420e28b1c3822dbbe8d1995109bdd2391680890a932c00c63d783aa735a29ad1fc470054a7e61a32b5492ae8c30aa5c8162063e821a1331519d1626ae787de3b5c91b00305c4e04dcea9e1499c33cddd399c31cc7610018b935b738dc608bbb2cf0e3e66648cb6a750cae95396bf220777409c575b524667f28e7ab1a8ec3e15fcd9793c3129ce1309e3a26dce18a2f873d0f3768b2d85911086fa898a24409b2ad768616638badef38b6f8face636bb15d7140826bb1c53756646c599cfde1b0b5788696e369cd90c3ab2188ec0e5ead153f9ee1062270936db7188fb0a0851147a0c0d8e182b98f8ef03074bfdc4747720899dccf7d7464098e0bae29f7d1111a5ccce0080b2e5e7069c2e080e0aab0d4702dd20b1a2ee782704603c2881035301244d1f5dc47465210c28c14d9c8600829bd69fa899a4f2557396a6f3a4085bee3d66788ec58eeffff2d27f32f4ff3ffffffffddddbfcf1de3ffffffdf29a51eedee6e53edb8eeb6ffffefee9cbbc9762050e37777f76aa25e77ffd7dd0efa9ffeffdf72efee52e6ffbfbbbbfddd5be604de53072e78b2bbbbbbbbbbbbdb57afeeb2ad34cf39a7bbcf5ebd26276d87e7ffeac5a2cf9a33ecd56b26b7cb4e8b27bbddddfd3bb7dddddd4d83a3ddeeee4ebbdf7ac773ff5957a652777759a9bbbbf707fa40ebfca4ac5fdf7274e94afcd57274cc3fada6af6368fda1e72a1dc3d9aecafaf5e95793f7b4f6f7e0385a9fe3f073958e01673f06fe7e4f9ececffda9d71e88b912d3ff80f5ffb49a68db5775d8a1b5d60567bbdad3e451295d5c29c1126696ac3779ef792b5f1779deac6eb735752bef0329066fc870ac578ffc2c1a13ca4df8815352d938373ff89dba6350fa2c21acb5f7fe0dc2ca580b42ae500d342ee46082792f147102222345e6c8080c34b2966bf04f1d1f138d23188e589c2c13832c834f2090cc494b11f80211ca046c054e6ae311413c61e445952317828e8488744cf95b1c872d132d20c95c01321d8283231686402ff2a53c62416c2d31edac90447eccc18d122b1ce5aaca15ab00816a132b5635638523f9710a10e8392b5768e48a6d40a07a332b12829d5c71aad66a73ad15dffa43ae18d72752a6a88043814095e21a2247e4a7921fd38040bf82232235cc1459f98b45e6a60643029938a8d4ec5de88e1136400013170000180c0886c3218118071339cebb0f14000f4c783e5c5c2ea48bc3a1481003290a63200662180620c410630c610632a8ea08003bb571b1b5d28e6ab92538f456f188d0a93bc2db4e411b91dfb7b4856b84d6e480282c8c87b213b860ecba34d473f9b735bbfbba91cb070e27583551eb3da938d2af070a9dea78e31d45ae15bdbc4b472bb0e231cad3c4b1669cb35b5de25156c939cf179ee56638e10ccfecb6a85f71ca3d35163060397332c2b945e7be8b899d412132c255c1f44537de41fec2f8aa318cf66b4d8990abdc9bc6ec35b76dde7ac80fdc36a53e9d587abf2f40e01e3970815631636c60ab0a1156e1d4f90f3bb46b4f06b1e5cd616eefa50cb268764122a6fa3d35d117befc737f84ea8b99db2c2b047e2f1df8604004e03229edcb7c70a7f661750314339dbff564fcc0e9c9a593a0df6f6882278635bc7ad7f242e6bc7fc8b650b4fe4b03d8bbb5a6a20cca8cfb705ff2d320d58f8250d4e15356a630b331527f21d78f0b09784f078618b31f88b506c5d3532bf9d045cc023420f54490e05374bdc7cf38d30032a38b8a40b693497c3e92b0198836f00edbe47f10128bc16a040f0755a466aa3360164d6d76a313e9451b5ccb67e7a33897cb09c30f710a3d73ad16548444cb207e87903444ee736dbef78077cd2f9adc6e9d6d3ed530e1a06a5634c4d4df1e24d7ea482951f4d033d2e2eddd15e64dead564dc9fccfab1fb39bc2e9c18b095510f64e817100070a66a3277ae0f11241a121fcb9dae7e9388d17891a97f1a180b4c38bd1126224e5b5f1888cf60c1c7c3f6c8dc5c77bfd82b912b1b53194cbb4a049af1ed9f20d4ed3bb4663028c538739f5839151ced87d66d92105c67058f6ac9c9f2c29ff0bdaeac1800e4455c7948ca6556a6abf7ff36e1a195a095bbf4daa9614e0733785d569c6900a7456c9b1520e50b3485d0470d4c4ffc09715281b1227c1a850f98634100e43b1cb279f1ef91e2a0a7458833734d31443a01cf2af6409bd49ccda11d47271ae8d5ea0e2b1df7e0d5b9e358ec19838921dcbd474a9b967b9494b4fd6918deead420956a79bbc567fa0f0f1736d0a0c00ab61bdd61fb4dae7c1c1dd7fc32c05bbc67e5e4884425336fc30b1fd3be75c93ed4f1222ea65960f253ca2846d2c0f4646142dee13f2dd0a4587877bb31b64186d40d1983b70503c40c61f9fc363133d3bacfb6e5a6d6eb386ba0c6d09ed88f1daf1222abdd5a1fc352bcd6c50ff4dc9dd38c2c09b5f1fe02413f3673684382a1dd44ecf827e7fcc956669913b75a0ae217bc764f8efb0a243667170f49b01417109bedef089cab7c89c627a9f7a7cd11493dd61ad6b4764e46300cc5ac8eb08f3b448148dd44a212f5437073bf71efff21b519d91fcd1729f4fc7684d2824d965102782691e37a21667a4a99c44e0950d4c7229be3e1faf9d1031a03029070b454a7e32543bef3069c915bac9b164dfd320658d64a7573dd8875b1376feb28e972e1266fee6bc5c75bfb808279c340a64e7c16e01d88954b8a5e38e6411fe04adcb71e5b9b20d20001d2c3b3489378b067930d9d171d2166ce7b6059692dbc6b14fdcd90ab2ada6cbdb63c0177a94aa6ddeb62a3139d49bfbca036d955ca5d145d29616274e6074620e8250891af575cbf83f6842ecb19b97a1e8c4e684d010dde9685cccdc21916e103fb0570e37e309a892693f9af27a698227b21cf152c854629ca0b34cc9a11a5b82278cab805ef2a2fb4aef2a3de8f203ab31848683d4360d87393e574bdef9e349ee0a42f7c1e13f0e620d005ee4364af3269467a237b46bda1e525da1d3df2495a4cea457a4b00acf0597da411502a56c7e9d3cc79a3f1d3096b2ee52a95aee1640880977a17450e8546d5ea6f0808b0c8f95c8815b50ab034236e2203c299503373d5acb9164df38d7cf932b14842ef4986b174a9b2e4b87f125d2a8ffd96d5517aecdc05c5158177925257489e9d90bc2cd2d0a534717bd0b2e8f6d4444f5464642f883294c9468ce820cab0c1d66012be6bdc7e47b871e7ee9bd53748e9f69a75a1895a1ead7aaf550686e75ceb529576945f464141c587a4cb3204891a18e16122232c485208b71c93edd5ec52daa140c96dd4f0b30dc7845f615e34a5a515e7cdbca068b8b1767bd0a3711205ba86ee9d3466d51622022cf2c34f7df617bf6e2ff800f9fe85e708b8417cc4e8943b75ab91e2f0117867ceb8c38142b34a2ceb90167101b8de441a66b77fd6e96f6f826d3006654bd33989cc79ed8582d574a764fff390e2e84a2aaecc89409f8dd638dbc1c3b482b9ef0f0c0505acaa620c53473345c9b22df075a3130245c7c962263f3b1911645aacfab545a1874317034359eccc515a07d2021d340647c1d7cb00555ec111cf988773c93042087c75c7cc67b354c5d2b3325c5cc260cf05280f81744499cb1bbf2556b89e3866e94f2fdcd9a112cffc07d51feccca81b3640ba1224109303432c4625229f5e8d87c620118894ce78261509d979c5a7b1285229d5c3cef4e688978c40558fd2b6350d0c15359c7e58d328a8326c6eca1802fce969b51ac6fea73488359b3c192ff8a0ad9862a79f2cc9463e5957bc0008058878fb6f122f4dbf4b649f0e61cfa6520f9df547ed9cece0d4cdfc2ca233347ec2337e9d0bb503c31b3c221c7080c828dd2b5439409105a0ebf1bfce1bc31032d85921c6443319c7b75c39cbd2729c9d510ddd074fcf1c422cd6adf9c80a7c3f4b091a699d1e5bec8e3bfab5201c630048b68043c31f3b66df91beae21889687aed006a7d745e82c50943cdbdeac4f3ebbb56b81c14922723d8f1e163ab24604b350a78632168fc3e30a1ff41d0073f52684cb9f089405181267286c475c016b33f306eda46ac0481d4fb529ed3c348860a38e373818b30e32f97b8bb124a366264276c5c5dd345b9b1fbede1ee200dcac8e02e2fee8dc9537f0c9e715fd6f6554e15ff007cbcee52bc1cc1e088283179a5adc121dc5e240b593518c8defdc1a41a12ab8ca33f19833ad77a39d0d80c2326f993ad123838a40757650782cd4660d175a2ec5195c84a008d94d24a6c4280f6eaee278807d2de44401291366e1ffb067dce109852b637b10695bd1226258241652a93be4959341cb5131f29e57c7ff4410f8551044860963b1130428e467c38a12858bd45a9504565d01f6ba0c901a2b90acd357d4e0094e1bc5e08ee580141088ea9d41bfd321ee81d8b055e759ea417e1ef71aa9f3eaa2a9d730b028a003cb997062e0cce01c6842ca64c94693d1a10ef3d0ced97afc87991acf5cff9fc785f2a13632caa1976a054221de0d73272465f2ca3eaf7f2be160f23a6a61b8a24b5b6b2283ea1ea3bf40f20c75d8de09753543dc80730bb09e6df2515280c52e3a4d0861da1ccf871f04f18a15cd8b00ed03fa5da1a527bf617a5d1e071bcb33e5f66559a8dd31801770a34e0acd35cc1882befbfb885f41bac8ce8e1bb42b18c16b5d28ac308b12d90a1c20f01c405c8e8f5c38a8e3b09bb614d92bfa3cd07b5f55ee47073e6601423ae0d1cf349a2eb1a6c3bd4043e8b156d764571a3b1eba08519a686bc0ba4ec4af54ade220078b463b1cfa3f5051854869fce246e841b834ec0683c589fb5bec071f3642bb2188dae89042bb2cae7c6f76cd42d1054316ae824c36750f883dd77d3341c56f9837ffa0c86500de8a297ab5621bc4162ac042093f2349de0dbabe6e93cc8a00978113b173012111db42b857dd4c08cadcf8a9f89443f87e9a8e5f46a5a5ea26e805729e8b8fd2053a2b84de1f9794b99dbc9c076c166d61b321b68ac2ebae1343e839d7436e9b27873c26988b3b56eed102b978223ede406d382c081d5458164edaab6c6da1407a417eb380dee5721459c8e641d68a30319bd2ab71c5487b42b07d183e763c98001f6d913e2f1a2aa269bbf0a462c8c10ac7825ded2b39c74d3e2f344cb2922bc3f61506bff128bbbab4e6a70257b0a5b5cfe7ca82c838bcdd291a078233da2638400e2b1a1a1e592ca09c584dcda74a0fd30ed18dc5121838921208750de5ebb6442a13e42127b3881d997329bc0223bcdfa30a29430c59b430f5731578275dc7a8b4e50e2e77d0838cf293122a9a680197c2e03cb49b35d70cccfc043cb5876e4176adb22f4905d8bdc2cef495263851d456c36deeb236c50b70cf770b28380ec20c2f6b9f9e4108759127261bf535613e42e2a3767e140bbbfc703f919427277591623c6141a4f50583eefd812f158edd7841af0d01316d1bc3e8631a501883b7328caf40244e9f005bf83c6a7512a4f51ee94de344602d96f05140fd769a3c351ed80d9bd7030dce6b9c0e913988a4f0b2db1dcc8feed0dd28253b91e57d19330738ee82f9cc5890617a47ad0bd3d229c701749d200d2eb8063867707fb3466ae9a72e7bec7df4e2baf69bf5f6ea0de4072a8c3280e008afe7617cf388fded2bc9411892cf9532963c4d4f0a888f743a98f44ecb7fffba61941e9989f0002fc604a06a4c00562c8462ae47d433040f0d1c90891ce0491294c4c5c985bca61919ba3127adfa366db86b6ef2433397c862ede49572217db7d3b21596af8996ab62446dd79eee7239097707ae3610d7deb6435c9bff8e6d565eb652904d46badbc1f11e393ad78ecd64033bb1594921301dc629dc529fa815df6601c1eb1fcd4439dd9a409a59c8bfba4990940a014137357311a94a5e73ee3ff18abe813048a9e0d483926f9bd68e3d9e5490b35140b0bb5e31ceba77ff8396bca321f38b385b902f493c3a5b5bf7e9afcbce86fa1e7cc3e297270f6a68952e9fabd6377b0e946901ad59895ef6c34dc4aa56a899aedf3fdc0d14d616fb08a5ecc89d2b333764c38a07faa87460d064f557512717902b37029eba00d92a44844a117b8374d5153c65346b3e22ebdfd1c20bcdf030ae244c1770ddeea3a86995bebcc219107f897339b5269ec8e7cd46c53fc1b0521b36f3d7c94db3e2675aa9ff644b4d8ec76b75d84f9f4ac72cde4a7c4e034b2107a7081866484a7da76656423629593a7ca81c1e9481d0d41967e3cfe00b44451936e111ce5ac1c2c64bffe56c05688cbd1a1be7a025db666b0d717ceac7e7f6dd15347ba1ea26f8d3221e68764904a5d1ac3792eec48b8d652a0e3fa21a4eb727717638d83d3043b3e7f4f32560439dd21b809d36ec81af37ed0b55d1b89a757f790d1a397846d84d5b46696a3bd6a6d12bd68ff7851486b0db7e628759e7e297239afcd881d99ed3234e4a13de9a74441b28c7691985d35ef3d06ea8b388adcfb0ceec20831ada9eb4e3f7e7e6dd1af5c29b9897ae57dba4e4714a3a5d391bb49c7672602934d403e6b483f49099910ee98983ab6eb252ba4267ebe742cd6cbde53de7b04cce4cfbb227c4dfe72f2d82c7d65eae4a7e3ec8cbe9afd0f97d1a2f56a1130635012ae1222b38d216204882ca83aa80131625dff0abc2feef24b82846646a9ea9ab2af577da7a720dec7a8afc11a70798c9fcd702503e217f133a1557a6aeaad46f3f2ddab59050e300515f8e4c9bb06a4644579f066dff9407293003862807bcb2caa5d618349f7bd81299fdfde77c1043f7777e7fd5a0ced70cadf7cbce5588020a266fc1fd8f6c8ecd0f50d3d056eced0e95c5e6c00d8b4dd0448adacaf0e69b5c067607177c61748bb37c4ad6f02eb6560146352417555edb29d5d1616a799ee5c9fd5c092ef97f9bc92646a9ccae6bd7324de5812d5d5ab96a29b07aaf86a66ff0b7e4dee6fc8d26a1e92e2e317991507a1bd22201fd552177d1e7addfcac2d686330095d4be520e15e94cd0903b5b9b1bbfa03edd82dc1871c9d12e8ca1d6a4e6fd337b3a64db7fe896f2bd2a525899bbd62b6770816c21cf0389502280194cd9f91c39083da68306f8567e6f70adfe37e4097225d8a57b8edafce75be8cc88dfb0c4118ddc5df05c32d406edc8777dd0e459e4995d5d1a5020e38fcc2c3047f134023aed8328e7293dd1658bee72a3771b40f9036cf06c8c644b5e5334dea15f3e991bcf92ed441ed4081e5a1c1fb9396dc9da999c6caa5bf237ad0468633090dadcd9b6eb53a635d3d92e8f572c9cedf4076e34601040c3797fd1b619c115b48003698612dd274322a0ba5e6385c499cdcd04d7d96aa41bcc5d958f03677d18e9e0c858c7925b4147a189c9909f24b62f1855db48278587d726238e474971208fd2f23102564415f1621c31b5ae7020799b151f659769a7e71f01baaed61567404a65dd1c2ea7adc9550aeffff50292fc1161f0b104cb161ea6a704aad0f460b244c109e476304daa3c2b3898c466e574bb6b08a5308e64c2e194f3d050d85b81ab4219fb074758b2bfb847047d8dd29fa7ae882752bc52570e8990732144fc371222dc249cc9acbcd1613cdba85355700d5243166ae8c798de09341d44041bfc8e87e8087af7ba75aa7d51eafb78e09bd1740d58138b81f0242c2cb2db38fa7da17951fa94523bdada8a641129395ab908721a50721ef5482c106fae070630c3e84126f2e7026e2cac916608e2c9cde19bd584076d4e58ebaf2fa0e416a30058348322c48336798a719bb8ef477d4d5a8106d437baca5adcfb22ef9486b7ed95a21fd11f5de0d52d56ef777b0f86faff9bd024772878758fe0ecd4b4906ba855af06d2cf03f74d715a82999b355edca070660d5f4ffc81d5cab272f1f3f803edb52dc222d207bef40e0751e28314f23996faf2f444c7ae53d6193bb016f9082fe5f724f903710fef65f740aebd792c13a7a45a1fa03e6da6f334c5258f63d4cc66950ff56003518be09529c1f3f94197486ea0ff39e67c4cac99904fc4d0baab43c29e2546c9c013d50cae6f2c49f67a528cf309083eb0c44671c5fe34541f08090dfbbc6544a650d1c8db8d30eca03e0eae5f27e2cacd570311733551af20eb8701fb885d50e9838f154f1daae4482deaa00119cfd741fa0953135681e38c633b0c35c4b419830863958d5e895f8f14616d5c7565d4fb6404727bc2606092825728b4865a8bbc548f55954552e1aa0a4f03930a48f64f8bbf242355c8c5f7a288b81d4ca01020f1799afa9cbd4f76d8d52651e10956d0aa1720528924bcad9e97446a1dcc2ecccd12493477e6994fcd031647126bcba93b6d09f80ef115d1b8f5652778a10ac4639454dfabc77057ac09f3d69b3e2998a63d0b5baa4fd16cb1d8cfb8f9f8fc496ed431aa7a5748605d6f74eb7c71aa5eac94662cd0a61da51a3eb3240a173821c467965f81154a185713cc1d94427a9284467750a918345fd158c7e1b30910b84dc5b65d2f8053252b006cc75785abd70b4263d62a80233ab8922ae393216a9d8a5674c12ba44111b3ccddf2a7b02e22f6ca7e5ac943ad686f0a4cd76c5a826fe61fc45a676c129b8383021bc4396917a802602b4271f407ab4978046c92c1ff39692fc6bee0e29c46987074c60de4820260195e75091838e8dec05f427593b0dac948a1d76c265f0489d4f68ceea602d18ce71506212d51f864e60c1ce9f77eda39433b7bbf1a0b2f280cd9d524392b4ff0222fe8a62acdd6b36c2c2a64c07b946ad2567cc2ced2d0d9e1e3d6a56184c10712988631762b92f137d3fced2037807fe6d21ec72827813d073f828a6c3b5bc573dd7a60d265e64dfb7476ccc961827600a891e58027bb7b8f044dc299d4bb0435902ef03b31fe65845581c192be887c17cbaf7e9ca897c250127141ba4c5f76c0a3c422999b39b7b52a923d0870078d55058891277ca6b3504582dafc146418a77c22c0dd1cf99741164506a70169f1855135760b3494832766a53947b33bb40d7f656b8caa6138c4e628ed40169c036c4e3e2386ee31e0ae55852b5a769c78a6e2a9f7dbb6141765b01f0502955608a78a7098ae16e75b19590c20a47359c6a144545628fc390d1c8596b8eef54ebf11ec2ed84b0fcf34e784a65d72f7a592c16cc4b693e6e14f0868417130192a5cf2323aae6c51d7cfe710678f8c87cd61d4e2be5c98af5311809b45be29f67eb5e30d6c9c6a02c5b5b6f09395b5510454600f6b673a21b2a9c50f177cafc02a20c63e23d06e898f8fab8fe0a693c8d3eeb800d390efedeed045a871110b5cdd158c8f0a0b82adc973fbf98096d0ac01dd8183ac7572251fbdf2f2c71a8306ecccba9b430027e74ad1f5eb755152d5bfbfd4ca1aed3e11d7b10e117f51da6662015f828b08a8c16f1168356d79a7a3d2611fe5bc0f0876129fa873f06c5dd54c6776ce2060883d41e41ca63c08141eae13a884e2059ff6a73ad63e01c127a0da3a4587e5b54ba8ba97465b216b997b6dc1bba316196c69d9352b10bdd0f94684bb6e95670ccaf6d5002d915ec185c8a6def1dd1194dbb7cf828ab5f0ac445b23a6a9e87e407069a6a5a8b06eb13084c5ba02448556f6680497be2e7fcac45743a4c492b69bf053a5aea7e28ca77b1cbb7a63c40ff29d5230f1470f22c315df38e99a6556ae4e8b6e8c39c366a8a96fb8bb7a8a264ba12d7e3d0bd689b4d5c3e2267adf52fed6ac145b50640ea6ce06b3e63245a4fe4cdba64454b0e182a5e640d50f39cfbe1e064a5e0d24fb759b7741350c8eedf6a4f64bfa7007bcec918f2b203c8dd2c7f4285f9a37b3e49a604ae703eaff2c1c59de380583e815a07585faa489448890bca0092ca8ac6fd9f9b93a9ce647b864f8213447ae2d045cef5568e5fe7c0229e33a56bff2d42bb75d1fd3acd9cf60ea464fa8aeacbcac788d094219caa9bdaa04904b148401fe2f010c0b5698a438ce50c7861b0096fca4aa3f871702dfae180c8249f25abacb8655612d1449efb10dc98bc1665c2fe33ee7f92500c2ddc59418083a4343a996525c044ee8edc0be298bd13f28be8561fa401dd0ad150530afd1108238889e9f5fa64f25a71bdb08e8d108e82888683d8ff8baf82b4f1709109e927612d95719e402c2ba0b1b9fcd1fc5bd9fd9cdb18600a626bbce6dcd9653a84b08eec2191420524f6678dcba412d422656b898eeedea9d2f2748d57c88b655cc3c31ed054a4dace0a71d7b4fd51bae7752b81311d65d42b7ede5e3c477845f7a06bffbca4b41e4305ae1e4c428ab7341e03af9a0b6ce8ee438b39ce09edf48025528c338b8c807b737080003a0884764b972dbac5fd8a1d196b480f6d5f1d9356a206a25ef7dd5504b46973418090c0265c30072b3ee3344a6f18d3d19cab8df175db8b3890d88d12cf097ea8e2f1543c1a0c06946f556b3c23781df1af9ac3fe2dbf781e09c614a10697c1096444f7e0da43015471de4d2bad04eae4493ca8a56f6cb8a4cb78c10fa4b138451702ef10394d19d2319a05412bb045efbe89a76e72b7dd9a4c0de56367ed8b2fd1605c9e5a4b7b5291a8cc992d2e2810246c8f747b0de7f7992395cf66dc180ea9e23cc14f5a55945c28e822cf1b58e4c7240b78b22e4e0973cd5726ce60fe5d20eba9fb791a036c29aeb8dfb13e22ea42418b06fbd28566c9746891fa8b388e8791c48c000b868181b06d06376ab1824ab776fc08c60a26c537d49d1f65d2d4f6830af29ef5b1672d0ef57c33f3fe19588efa84b41b71ebcdc6c474af7db3907f989235fe93297d39a50c528769dca711ea614a4f773951a3d3f6e1040ee7df39d6e922ccde0e0a8ca9aa25e29e03e8601a4956f4eb518588b727f21bae53405946812e8c89a32e8abbf7452a6697e78132994a47d69f6901f05dca76e278121f5dc4ab2f9228fa2865b47e93564094e39546ba2dcfa9920b84e2c40ce523f8f5dcfd91b25729b4fdae63ea89c7b241e1c596999fcfc03575cbd39fb0695d55d8e5152a58a1597eb72981311e4b9dfa368b8ca33c78977b54d9d3fb7525162866409962bd7ea34e201131f8f6c21e9a518e98fa4668f1dbe156cca4771886439bb43d4567ddfb34cb9dc318f3731c24f82df80305d1be941461806a6670859c3fbd984d197d53f253b32045021f40091dda44c0175408d80b235f82b40d708bf5420b6e1612c43bbc614c394a8056e818b82a0fb0645e94fc71411c6067aba2cb208c3b420e1cad140f112112a978947b8202353855158fca35bb8a2c201fa1ad233f64e8891cf0cdcf6a73b12da81546f188eab38bc602850d241a538514f839d01ca624d5a7b05496136a5a4a80fbf105a3303ded484e83f2e380605eb4162826e800fba03e24ee8082a33e003748787b10d426d980a89f21af41144c7d85cdb6af8d15a60a5819d31658226128875c0aed86a401109c64a37565b310a4306ba89614ad0d895cc682a52dbc0663ee9845e66e46c5ee09542140406e70a9c80b40bc92905961153b742fd27cc0358f9d22044411da85bc8dc264052b8d13e3be0bb9fff5be8dac7006c4165f30f349692ce70d6723161e0a716c2bdd6c29cfeac2468d3c8e81bec420dbc1f82849155b98a6500cb1db90c2a13fb8237578424368653da4bcde9f95bbae556858a874b739ae2ad6631a0955ca9247614b59e083784a6d777e5f555f9b1a0490f623a95dc651ff8f81ad093c29d208a832dd5def508bc040bb41d2775fc1bb80365efcc7c14911094c1865c6b9ebb71b58c02552149d21db10dc93f09043d9186996c0af98f3ad3a06713c45bc3abab2590e318aee9e0db39a807566fab1a0e17d8a0062d935d08d59882462120599e6eb945e714a131af453fa70f40584ae71d703197676c62b09afc5bec59786a72db2657265298f89d7f3d5d029461480913ed70caf81d9f31cae1495513ba0b39451a8591dfa0ceadb989d6036971f24c2f75d36ace8b8f298413dc459b9a7c74ec1f372833b21cf0f88500d4d61d930d0de98472abf6859082f9beab109e7b9aa24f80f67e2d273ff3660ac2ac265a037409cf83bb723840be1dd83a47b5946a12a07a3128448876cd0d456554e4a2c6d211009aceb63e86c0137ce21cbccc84c23d59131265004aade2336d2fedc26a1c2a9cc5aa272fe0cf5f33d27a067eba590e0b719e646292547faab164bd0c24d5a85bbeeae1d4ad72155f40cd2c72248bb0a10bcc284379c751a96a5acb54b027bdadb032b2ca0a54aca352b6b0921913fa0e7a0618c5602ebd6ccae333feb8fdc343f2d42f3aba3f411d69d26c3c5004bf99b3bf535877cb58f101d43d93daa296a94bbc8820a61569671d65e61979eac9f2a86a2ddaeb501fab41dd543c742da0e4527f04000a1c48feb4d10bccc079c4b36344416ea0948dd4bd7f0fdbd682094910ff468616913c01b2b07850e81eb873128683e889d785589c3c0dafbe61b2661f1415db244c18cfac9e30e86774b2b19e0508f3d687b4ca86613442315c42f1244817a7eb07aebadb654b3433e886534dd3839a6da9a58dda0e68b37dce520c9ee66b8fcb8ce6361c8bdf81d950821ff46cc7b40f97ea5d537e578859378357420f722a3420676ad204a8d619948677d93085936cf314a8f5bf93fe690c4740af777268f6ec35f0427b45f3cfa6da2374ca57a03ccf6df6b1103388cddb623884acdc4de051515d958878757e1125044ef03c9ae121ed95b353b00efcad93c6dde70bf12a077e7e227f01e2b5ebc00d0e0bb59617434cd40503490e9ac80f32265cfd297efbe64712357d5027a021f05a6c62081a890012bdad8a8b123b1a38ff706c0caaa50290c5bab95294c4c5c1731831ce932ee11a59f9ef712a080343d08c527263286cbc0975a4965e23d37c4b519cc4a05873e0376443fbfdb0e5d645fab842e6dfd6950389cd7cafb99818b709ba10eab352f3946bdfbf381cfa0e644df698a535ebbb98124d42d12d2b86dc702eb21902186cc0ff88688cbe46f1be0263ca1762029b85414ded2ff7010dfad105920f77cab0d7f4cda2c2630fda6d469ec3b904dd1ac5de0e623cf6a8cb46c709016d0dac2e5bebf3c0e458bd6203578dd9ee112a57b4915149866d828525105ba01ceb9f21da4d9c828f28eb8e0f5f877eb362c0bda0c6d117727344c2367b10ee3951aac6dd98d2759328f0ca6a99e7ac7d20f361fca569d8982d4044a028dce1d28bcf18d548cbccd50900298914726dd6b47200331cb7cc8b519061206db8b39a0ff8b8e6a261f9134f23cdd44adfa5e30b2c7fff9da6e6c6bcf86996a6535df054f3b58029f557e624d0d08bb1a8ddc1f195a23f4ec51c69cd7ff81d4257ee3d52abd59dbf4e6233611d14d001dd26cd1b077ee3c5f24f278b34e8fe201b830da21be340fcfa2d17f39924e569830e31f6d2239f7a09e3b9ee2990148656787baab78b42418742346653ee38dae9da3e2d363052ff6d704c7f667852f25862069e583fadbb1690df6e4be619764b1ae7202e9b583683ddec99b2fa1395e3271676b68df627c67d35d2774a0cbd91f65a021fa06aa6aa0059e3d9407e79ec8fa2941acaa6cf0ff4af99226a0dec8ebf9f3cdd36b099eebc434b9b235a519367d2d220fc2b96e065d4a348fea9e6cd2523c3a56c2721aaf8f51bc270345bae13c2da86b3838b8e2c7d708473d1f2729958c95aa65143a597c9d2e4b74eb82a6ed184147de7dc465c2e2a8a84ff5a0003d1e1fdf17d1458932a442ad009a2719a2bb145b3baf82c39858b5ec5ce8674599fff3828a48a3ceab0df7e9d86ff04d6fa7cb6e6bc031c2aca0b7310d090d812372faad95c09b55f28162f13835933c3b46a998600e87588ede951b513b77a1f43af5ffb1eef6801f4b93aa00e362310a02ba26d2dced2754a19156d7d7c246cbc939a6aca78ace58983c035390836758af77463f8f9fc349cfcc27964549dac7778a658361d84137ffa7d46c4518caa2dfbe738f7629abf505936121feb49babd1ac44ce3275a63fcba3c4c6b0d3fa99a5baa69dea226ee5b6d4fc5a92af6a5e52e97b135e54dc89b7cbb690a93b5dfe92df775bcceec12e88bd322e63e7200d213a0a9f3c4e92d950d63051b65ed3f42132fba7ccb62d39d5800f28158c2eed121b3a17fa7d1326584537390aeaae48f5d97cf95d3f584fa274acfbbae2a5ecfaf0ba6748afcfbedefc419b62b55e2efb49dbaa3770d25ff99d2aa31c67ddc7d5ecd8f38f42369502c3874e2d7beddc255163b98374571302598979ad8b2ff1524934dcd8f226717a37680e0765d434671d730f546be0b3f91a17a78e6f5c7c707297950a768ab7014d39b0986a31bb9feb2d403567f2fe252cfb926c1d6a20eb6f6e74ff8c11c7a06dc871c0fbae4c48bf59aab81557ea515661f236a4e8dbb07b38f824ffd068b786666002b7fb9b477d457a063a059f9a0e0110363897dac74d98adc34b3fd1d8621b28f992117bf00979eb09749c50e2774db1efe390935726f1a32da030e7f717da7b12b3c375490a6741e9edb81045d994a0a677bb87afaa66c4446bf55d68a1a11fa55249e671dcf97cd664ae851cef4552332eb1c76c1af25d796f495ea10cd49ca740a95dcc4e6e3b49e899053d542bc8ffb8441d335228fa17ed3b5251a8fc3590ce1fbdbe02135e831b30becb6438614d5fda70e74e730777331f43efc9a63348eb8fd7662b0d97386d002d8e06cac2354ce136bb82b5619ccc9f85df17f630c783912085bd1e259c69657249d72835db4005ce694427d4f0d5be59491c8ec4cf0112acdbb5b8b60da1ebafdb377af7097684703747f45f63db5f62e0c5403b497349d457a7dfc1f1d72dca54b40d38fc69f86c24f35f13891fee5b466f6821b4a0472dee3333a8c5d5ca5d1f0c18ade7cdb6932d9c75eb56ba342911760349dbcaf84a98dff196a9ddafc2b8ad6d784da52b1461198fcb2e318f71580bd217b628e8a119fba34b2219504d3b0ae0d39a41da448a85f2474f35462498f85321aee754e204d2e05bbc1e0d4fb167c85dd27583ac18f7ef81268bd220bf2b682b4e41fab524c55a78048aafc06934f9c83d641afa8c4e42ce80445762e5b3db843cc681229fe5b7330b50797105598237cac3a4235c397d81e0b6d22f4cb7c9c9cb341c1e7b494b9cd48a263b27f1cf1945ef0b44f4fc8c95ebe4fa0e6dbcf663b1693d8cb636dc7d2c4ad5ebef3c35b861db3d257c945e2ae536ac32de15ecd5369b8f1a254ebc5f18df7026cd7913706734a377ccf79617bf81b85f0e36776db11cb956dba76101a033d42e33945ad70fb7f1c6be0b9af58444c7f1943c54b3d485ea095feec24b208885e10dc260a5050c889fb21b68280aa67910063523b8ef200ffb1397296039e22b5c9b46cf1f48a88ee9c9200de0e1b98b8733922c72f7dc615f62d6456927a7517836f64c98143990bba0905980acd21df42b0658eef1e6b7c8602fb0ae65f72397c0b0b47f8474aa43fb564808c64df422d25e81d93bea0e04b646d644ff8161af25227172ae54ae674649a25f30a5ff42a92536c7c678a1df5e1ecc35700fda37599f7ac4afe7c2b81062b6a375f4e224d3764e1cb93812caf44508c5b4a2eb3eff02245f3803acc018e2ea94da9d17afe89b067f96b5195943c3392b8816f3b08e9e1c0b7ae7669409062000491bd344303f805133b314417c91969a181a339cda45a721404d16ded7dec0ae7e9bd9cd9ea9810c70a2ca6267fd602c27e4119779102d1e3cf98c9188111f8f60b4a85c14be980a14f31873567713f6821f3c5d52c5c9779472fbc0cf6374a3a5bc44d91f8ca6c85e8d6d7afb5f9bf7d65302460a01790d50f644db96bb809cac62b42952e0d7917983166df5396d739d6e871045e369403c518413586d8b27c3d7f350b24a83100c70dc3859455671e3679a5c9c092e15cba6012882170131a7022fcc1b739cd1051c018e1975274a46664e82583d57798dcd4183ee2fa6080dcc7de6f987979db612c6ff4cf1d89b76100b7abafa91a42d19151886ce07ffc557a49f9dc49229a889725da0bd10d60dd5246977b581e74772a33774b06ab9dc8e941efe114ed7581c616b66f0ba3a4dc05ddf48aa372d0cbb53c1c44596bcb14637f5e1121a48b14b569e6b86bca70bd01fb4a3a7277eeec368450d309fbe98ca9ff87b2c237d25d5a4149de38a5be1bb17e7fe666a068ff156d7b5b0cad2fef355fc14fce04e2496317f82db4727209120c0f3a2fd8be93e0775cc3c6a6761b8b75e37f99d4be23496e5708b92267735723443da89f0f96ce450360b9d31d1dfddf48055efd76941f07f9413e86d71c5d1df2e1324cd89dfe84028ff0c4be4a36d4b16eeb364f7efc2af51be8d1d7eb080bbe41c20a01be827d098f00f0bd1c52add0b82dee12b137753a71baaf8c30fd14ab81f33402690723e747e894b0f4a3c1d3b3050ef9f669c3d1da11215de238dcdc12381d8c65b2eddca014bea6d73dedbf0c232ec5e8ef5e4e786cb44a6d4631a99322d9ffe0c3495c196a35df44d56506448f1f1739d5dca53b8fccb3819e7f17f7673368c8b8048ecd4e3a6daa1072d75ed32d8bebc5c49199163c3394d926e24feb7106fdcfcea91599fefdef18d524e90337a92d9ad1586545c1dae1c3df6e040dce7f55a9f488e0011a36fe9460f8528fbb3e177127de898afd0beb6927c13fbb4dfaa78617b8ea234574b7b905bdb0f974feacf00be10cc7e0cc0f803c0e1e94031d30b37793cf72027675505ce053c3d537ce5b74c9b55aa9a2fade9faefd027c2c60d293d13ef0d7728680a70fc8f419041c9470b558396ecd2ceb572221bb3a7598339d2abcf1001bb59edba032a8446954d5f42db8fb5485f68c626c60feeb555da8df251182fd708ea05b834582f7de84012ceb40dd15bddf0ad3f86fe4de17585fdc5d952832b995316fc396fbaea639da06c606029311fd9251797a4ae870d137d329d2ee8f33bc59fa6c755f87be7e3382409c479c7889bbbb6760040889297f1a065469ebd96313e988aea3372293bd89b626fdd375a25b1fceecae324cdcd6a708b53ec4574252eda425044b255c78d5e21a3a1c29daeb68605c8be2fa4dee0a026d1f80ee24e01bda2eded0d8e1c07c0a3ee8e80784dc22b846d7be67f81b618a4ce7e186beb9f5fa6c8daefe87c2fdf58691319f0850ba2df97e62411f732b3e714a85c46dda776c869ac65caf1a74d493f55c7b1d8ee15f0be33e784fe7174b34ed3beeafd92026445b84eb7979050c0b2d16733cab7a2e6202459d61f9053746283a111294e593fa454c66749a7254c150bf507565f0ebea91417d6d20187ec42f5fb7ccd77290f46294acbfc67564d0242569c3090c90deb09200ec87d86ae83b83830960f96b5248e930bf753a9d5c19f59a135b686b42df5bcbe7ee9a9ef299b086c72ac82829e8ebbf5620d777324a5f94cb1cd57afcdb4fa9e3c3c4a1432aa1a3d826d92a3671cec4262104b8d070bb7e7a515061383133f906604a072141fc965bf98de1ff341069658013977dff786461b3b13621f27d4b181adde0072d163b1572d8ea08d1529612230a3b9d39a8c5d83ffafc6e30576b7796377da74a31a985dae10b0c7b4dc9954b3f7ec3313325c60ac4920dc5d19d93e5798189f7575938d7a4f2635e635e7220fbedf9f0356e053f4bb4866636ddab29d13b2eb767d71fa6115cc85b492ef5d7452ec4399c670f00f9b453dfac690d1ec00080b69305949de57acc2a1326e66a0078191fa68ea255b76a1357456f5a125187b6831afda8209ca31716a06d782e4ad4f3988e0dd2202ac6e31c3916edb999be0a17fd97a38e4e61c7348bdae9dc7102de2b788bbcaa36ba7221d3bf5a2d1afef867a39a1f64d59218628dcf9f8048c942aea766a318d86c902d31226baf33cfeef09248a0a4998054edb0e98c3a98b87d8f3abeac04db5751e6d1cb6ec93d4d36d65553700c782fbe25bf44f9dbfea94ac227ce586521aba6ade6c4a9c9be4b4f467ecd151f997c7c6255b09abb95098f0fc4f56233168f9a833ecfe0c7faa7aabfbd7573ca46f6c23d2d11dc0c51c61b56557cfbc10501d05e19c860f34f810ed214e774dc3c2be45e1a44f2c7e9538a622f821861c4c92fdf5281a7d0377a7e139d3cb9584b921176745999a5aa9a9e465fddec800fbc3e54c417d6402f525e9e157cfcdb6e864f83c8e0e96dbe54efb2ee0434485c96aa3d5fa1420cf0ad78ecd2943af11bf5f72269e5a64c879bd9c4f005dd5465c47dc4d13c66428042f9dfcfff61865a926a5032501cc4853f90b9a23ac75a23a943e7d85c51330a2585b43077489602a60a3fa82bd0edf6f46811adb5ae829102279f4b526ea99bf0796b48bc5902521da50b95aa89dd91b9288d9e00dfd2b804f6cdc9b08394273464b033bb8b2013b6cb7e47f8807f129bde855d2b7242c147e66dba936f735c1123a79efc6c44c03a0470310fc0497e2e17f857cc340802095bb10fb857ff1057868c6239c054f1d058889b50cee6fdcca11aae53a6f454c2d15ab7a16039702a2e43539b60ca68e562c13d4ecb565d95fae5c29e3e669565dfaea37b7c5b4b84de44580c17af18278e7a6d9b564c406857746e4d42560c0a1102d2eb069cdc01d2ef5330a2bed9bff252b9e887d284d57c89b52b6633969511723e48d627ecdf26279c93d6cf263bbe7370aad25d10db31d38beecc824152bfe11d6a713da9df7eab0f1b4c452e8d0e8a320efaa6d49947fd82dc34b389601d0f8aca9db686f6c8ac376f4445b705330038ab7efe3b3a9714812b6b242b2d6a22eb23bfe6e3a613f33d4ce3f3be2ee00e02662aad313031e3f790969fa4276d7329de32355f77a9ca9b50061391b232cf0782c946aa684b99c7170e367e1a72a3284ac33751d8c95f28a4081fee4c86a0d97a094c73947a6e435ccc81e3ec3d0e3498ea5ae586069f8193e63aeed1282f523b0bd5f0c93c7fe16aeb05f70100d4789a3fb2b036ed7f7f602abb478e5d63bd3381b612b61ef7fc1bfb3589f88bdf40dcbcc6bc95aafba8ed05296e40080ba6b79d4664630a21b62934cebac5fc73a197b0eab7b3976cc8d5674d457b5109bd70c71089cdbed50f0490628bd5c47bb45effb36341cb17bb19b7ba3986e3966b0207411479311b02189672e33c4148e5bb06593f37659d196eaf9b2142ca8dd5bba539dc77131e50dc29426f873db21e1f0e15c8e35fa2eefea8f6dc979c0e09cd9d7272c8ae678b90411c97e9d6b004e12a37adf668e349f52189c83554c356ba386542ab7ab81651ca45e6afb8c3453819b252625e595c5e317f2aeca3133081de114e370c3322baa1fed60877745f37d21382fa7a0f95641d60570eaf0f9930cd14ae03840c1caa08d3a07b4cf0a9a0d34770daa393c75bd769a76580d35d2e68fddc7404d4b65c3dda54a7b7e3854c1fa3fb9aa0b7eb14f9979e8aa4d0f7c1a16b1d6cff434f2c52382ba795289d40f41c3c2f31b977e86fae8310e71fb58672871e92bad782850aa25dbed375eebc901dd0bd9e9273c087d2de24a51434bdcc92629f2ae19aa69d0bce0fbdae98c03ee5e261950b4afd1c7215b119783a68bad0fd1dee23391f8dcb35394899a352832d2754275e99746677801ee5c2cf3329fe89f3123193ce52efd31056cb003d2743615bf3e7515b3013cef3f388569f47bbd5a0b6862bd3530ec34707f4fa14360337feae21899e100355deb735777fad88089ba3b921627a53d82ab89795e033ed0ef0e879598a3163d4229eb86145e8dba7db6b9e4e05069928cebc7cc49d2b02f4b2793d0a6da10c5945366e2aede6a1639678e3ed7f2a4ec1da5b8c26a78124960b70b461f82419ab75ec0703ac0286f14549c844e937920c94347d20e4582e45057d2b3e5baa3a51c9a8fc05407ebc2c5d420ff8823ee160f294323bd0005052d25ac938e05f4ec0eed7d3b4c9e087c834c02433fbb084f2531c414bac8920b45ea75f52a61698ce6e747bd2e018a7d3c1cd1b42f96f3dece717295958d84b46d8d75a4952ea4a176ee9a87696e369ecc53d7465e4d3c759aed2957f5303b0db25675c0d4b889ccfc4f9150b5d96eb16b49f61794aa2a97dfb397fd3b6662766a209ac593ed08b00d88eb0131bc97179612d911ef00fa49e646b6152a13ef69f3fdb0d424df27496b44cbc3dedc3ccc7e25c96d8aa710bdf2bc45e85182e202c5b0d23dd65820dd6a65506376152d389a5e282c8b898527b317256bdaa3be98da98527c510afd369920d9b616058b2377b9e361af7dd85bca3d35331dc9d373fce60bff7e704678fa1e3737c79383e8c19f8760554dbf43148110a6068817e9c8ac81272e3fd2acf50bc1e0320018bdecf258d48852e9ecad58cc3faee4befc393bbfa76b18d66c07621dadcc78002ef3a9180594bc2267664547444fbbceaf8a019d7c22080086c4748b5a020d90209b3acc2686b1fe14c1b02518bf891fec37823f95658a15cd83ccc8a023c71c5e8fb9021d9a3cce4aa48622bf9793f56e2b3f7f9a6dd006e803ff2d534bddefcc3b24b60f90a508330be8390941d8cac27a1ff39bdddb2dca07253eb8ff74d3db78837cc02e3d3faa41e01012153f2b15df2423cb48332bd4c7625ed2436a61d91f1a0389906dd6a74a40193f4d051fa7a61472c5e709eef74f16f307e42fae827197d22412ad6fb9c9a40d09a9c7d49495b5ce2836ae9f82ff8dd452bd35b004e658a2818f1c32e2bbc345f80ebc54afd32aeb33708444fd8fc6c9b43f312991b83a8c4c7d1189bbc83fa131559bbcb69c8415099c3b2a14737596183e465433ee60189fc42c772a1175990792aaf00c7cad7ce604002ecadc5f73c650910570eaa49a7d602c6ab799a87a256888310fa8ae2ece0fbe026a68c2ac6fb40bdeec8a921ed3dcd3d9af03528a866778a11da18b06f8f85a2596f2170f572a6f939559cadd9e7ed33c225c55e4ba9aef80072a550f0d85931ac021f68703657f73e8925f81cd779fdf4184bb4cccdf667bf03cf4eeea24c54f08f4d158faa2574ddbb9edee98cea195ab7460685eec506f6df97d14d5e5989c054ef428c2b462661433cc2c7be41a546b09c3636792310c300da66e4776a4848b3a3ea6ffa0ac9896aa4d0f77bcfc15eff57bbe5ea37a0981d1d07131ef6c333740e199a41d0e12ff0c49f0f7117b31c49ac91ee9d33b161bba92904026b665d63083c07905ee95d9ffb49b1df8e4f7ee3b92280ed13a3084bd324e3dc161787a73ad8b36eea42d90f332cd30c8d10c34e65790d59095946f013a3f630b81ada24c075bc00b0837c9c54bb275ccf57a2ec947789d0b1c6595bb7f79399f1e9dc68d804a486c19be164a450b431381d82331abccbcd0cafa1934206e502f76478904c492be848b6559c3e8b2fe65f947c2edd8f245bd6115afd0974873134f6730b0cc74f359f06047671ffc500f65432ead4bea9f1fa6ebd86604267d1e5b5766e3d77d3c526e3cc2ec9c21425b53390a0398d49fb9a3775f4b65039932a8a6d3673ac46ebe94706b4c004eadf4bc158309a55493ab94997836fa9ad91e698ae1372c7228d282db805765cd2d761d81debd680de4b9ec23d23381fc5fe2f6017c49a453a361590a574c1ef05349642d9d65a687eb19753a73634726d6c6b9f10b21bd984ecbdb70c2d0cfd0bff0b3f6032f4832df2bc5c22ca9f792d6543552d8bb86a6d1131a33c3f7f1dc5196c49f4381bac5505fb655f2f419221d6ca13758d257b20ab394964a711b8081c64bf7894e7446113c6a978ec29d3b19ba2299ae26d748d797a244489f2a42d5a94679c731e80c7bd899e2623571368557cd441d7a0af8936284ed163294cbb32201e8e38a45cafdd20e92c8955927b49ee222d6f56eafdcc7643b416d073f373d3c40dd0cd913893dafe9ba01b2b1a47e92d858f5047a12877ad75b38158c2c0b65c2b55f5a9db49557d2604fb5a0f6bf58c72dfe3c9df25942b568fd1a071c05c8fd5a0716cafd86b3d35d2ab520684a650d028aa0b88c419fb7ada13674eafa74bc41994d7d37aca449c49793dfd8933a8d7d3261a87ca1571a519712d1b34f683c69ee819eef518111a23922b17afc75a72f5f22c0b8c091de2d124b25167d80e723da6b31d4da07924ceacbcebb118cf27933ca317752d4b94eba7075a264d9dc6c1f2fa0b49ae3256fd9514672ea1ebe7899fd3a07b814dc1374790eb6554d4ca95e8df0594ebb54efdef01f38b85dcc3fcf73017f2a7606eaafb7d0e2b75531d4e0d913acc6f52877977188c63a4c33730bf18e71ee6387fcac2dcd4bdb7e56f4bd5a5c373f9c815cceb67d2ced52357a9771db6a96ba54a3eae5aee928a4172d5826512963128855baaea4d295526a91c72404a8734e381e9ba2c48aaea3defaf35283b3aca3cefef3a6b934a317e7e7e689665493229294b4a4a2a259592ea4fa9a816957e4a3fa59f52515151517dc62357f54866414212a6eb8e783cefef2c4f2614399b954f9d23d95913922bad2555f55b140d9d904d91ab1572ddae1081c6a3b53423882bd792ab3aa426916bab12b1db85b91615e5fa7ad4bd5e13925bc0745dd7e10f3a212857a05c3b5bbf6942b9a6d8934c922b6d8bc6d1597ac1d28de56a465da36e3d5255b52cb4aa5ec80b3a50f793ebe6936b85c2e681a7a1d322570d0bcec684371e93a954043724106f411b904c6a1cdbd1651a7a26d1383a5756b5495a4faeda0c727df58255c97832dbc18c27d7dbbb3511bdfad3dd80a2578f72b723770b8a5e7dcadd9044af1e7537a1e8d5abdc2d49d7a8cf82e44a631255f543b2242c916e893311942b52bd8bab194955fdcbd58e90e4aafe48557d96594b91727de947ae341ea9aaef4ea59f5c9f25c915e72355f54036a8133a51fdcae596e091ab0d8b56d5d77a14fc65f5167fd603b98e20d713fe626496bb1d758daa823fee27d7734cc499ce75abe79a88ab529254d5734b74492c92a423b9bee3366ec95614bd7a0d73ade8d59f56ae2f25d52ecbb623d376546f326d474f6c59fc9492eaa611895ed57aa257bf618d277af52f4ab09fc693ebb72ce20ca713673eee4ce2ccc9ebb7a3380373fd8614678eb6d8a2d892e2ccb77121d7d7ed9f6694eb2bd251d5c9b51ee57a4d6e2cb7ef8d24b9aaaf3ff0465ed15b1d912d25e55aa170dfd29d6ccb1fd3552e54d235e051f0291726814217228141f0db91cc326bbbeef73c996d3bcaf5a5a25a2acaf5a62b03af1387dcb8c18a7d7048a6b883121fe80452de8e51146c7300948323792b8294b7225b446f834582608ebe59165b5f6c31814724c9f0ddf83b62a7a79094b767f77bfe6011a0e86dd656275a52b5bdef44125d230bf6834ef01849e2d99ce0c9db9dd0525a0e84f2f6147cdcc95f4e90a64dc1246f5f53a19337888b00e56d4950be4e04925c4123494418c915f6ed441cc915fd56d2a610ca17fe9a8a9dbc61970823a9da0e8d24c915114852b57d7b864eece40d7f3d4552de9cd0c91bc5441c49d57623db59833b20cadbbf9ec2c8897fd9edbf0e3601245792b51d36112457a9d3210b07b250be1d1a218a33a56f4694e4ed42793bcab552b5fd74b72b5bfcd9bc39d1ca1beea2b71d1a6999f0971519e5ed2da191a3bcbd6336ec033a81a49de8641a59a963293c91a604c237c2f0235ee396586e0a0bf3b557ed55833c1fe409ca54889ef6348e93d3d31750251a473d7d71faac7519c995fca4cf6ed02b2d336233204091b32430394b22ce9c4e9ff1c41994d36744e24ccae9b39e6c8938833a55397dc644e358393db5226657d82cba2df2b6c3247a43323d6dc995d6d276d094073d633a3dfd41af5a4e4f85e4cac5e929915cbd9c9ec2a0bba90d323d9624579c516986e5dd3791ec0ed5f18aded1cf34f4449a498da33b3d768421c5192c08f3912bec545382cf5fd0a5c08ea0b3cb039916b58830a1be0ef31ed8535848ead853c72e04e6d79b958a4f3d8775dd54bcb98e3d1ec39ec238a963c781f9f51cd6062455dbafa0bc3d75b7c36cd7eabace0ec643afa41b34be974c5199a6be09c10ef3ed02362c8f5a7336da6ba2f6c286e5baf066458457645b1692730086533cb06387390cbeb9708ac7f5eba9a7369b882fb072202758019295fa0f9d5b7295d5d20e4cd7791e1090d692ab52c9f3feaeab317c7c7c7cb22c3b3a7a719b554292484825a4125245aa48b59515c995d6aa3ed5a7b68a327d6947ae342359020a92463b3b3b9ef7779db519cb679291dc82e46a23922aca41d12afa188513b82932e5ac68b2ed6c44db5644e4026f45529564bbe58ce4aa32d18670465a129c1167945ddcd45fae4b0b22b532bd6674fa2d081555f4305d672dfea0138c720065fa43a3db82327da32e391bed84324464a5b62c1a47e76c2bda582ed7ddada86b703c5245b72a5a451fe401fda7f3c994ebc95453421aae458745a65b1632e5764a2520d8526dcd23997240dc4fa6af8913a971d04f2d7a55ea6b080624579155da7822fe361764faea851717b24a3b59666d0793e33f98fc957632fde9724c448f1ee5723fd1a34fb95c1397038a1e3dea7247a247af72b9a0e8d1af5c0e49d7a02f01c9d5b64554d16f4cb22136898ec8b9254a4672b51d19657a17772b922afa97bb191dc9959665d61e65faea2357db4ed6551f94ea93e94b48f42d5bd419dd5b2921657a969b237af4db8e5c955a454fe92dfe32fad3b6f375cf317277b3ae4157e80b10673ad31f20ae2a9254d1d3d3e4e8aea0d47b6735ee8aca1d61ce287af4970afb71464831227596957a95654f6c3ed4e5f45b12d1a33cd1a3af78db891efd8b12ecb693e9b738637a8933dc29bd8d33df29fe3828ba38f37156c8f4b4fedb8a32bd762457f49a915cb55c6a49996a4699debe3790e48a266a3e72055b156fe415bdd511d98a94a912ee5bba93f5c974e542251712a1842012940b83e0912cb3b6eba4cc3e9a5c5b729565d6766d65fad295b9f9891e7c0a17e1728d883a436edc913756a44adfb8ff88adaf93bec8f3f2bd04630b26f9a0501e42b22e5c845461f9cb4af7061f58a49964753a9e7afaab8958ffeef3ae234a72fd1556d46f22d57fad848672d77e51aa1d20a7eeb4aa9ea7a7d24a3fe34fd7a89f9c022a4ed56f18d65bba76bfeb80c9254e074cae18967047a1954f7450628e1f151376cb3d04b404871f9be51e025242f412af99bd64d90b98652fb21798bd642fb2972c7b41b199bd64d98b245a96d1f6608430d2a04993096343d4b3ac258c11c6a15894936453f41941932200810a2ec880154190239011723c2ace7017908e8ece0e58f15d5c75cb1700e42f86c68daf93c896596cd14cb27c7f7088849192892920921bf9834994c025566401990c49a20a199790b1892311494cf2452553c85f5ce26345969734e0c97288065ac8f2afc110b2bc375483a3dc4336384296af714196078207135ac8f20c18628249962f020a59de88a11b504107073ad8c10119788a14a1c7a788157e868a8021cba11f21211ea2560e9214191d21dd20cbc3241da441e7063b3b60034f1347e85122cb1e3282f4e30411509010114f963dc483a32c1f731667be4d28cbc34d28b7d014497913da8c907dc82dce40a20cb7242cb825c9cdd9c4d2155d37e4a36404435f68f101419e9fddec253ea8424a9e73ce39b119f97a2791628a198c60ce20075d0a2613544d6610021990010c43621c010c2be8cce0838ef95aa8eb1c1d637a65a52ac295f686456e4455bc8c19ac4cd7d10091e55b75bd74bb7c1591e5bdabaf0d64e95d38124b298cb6157d4cb4020c482527d80069044d8fb410c1bdc71ccfa41fcc16d0132da0f1424b0648f9eba22cdf56c877f2323159ee2119b4e8921944accd3da4441bb2b027b987944022a2b50f52061209d1d09841a38b4ee491349a9877727970b62f8aca646ed0d050e5c8724ead7236d8c466092bcd8e863703001e958d9a7925bb2eecba2edaa815b9494faa68eebc24362f99f3a4f39a5794534e39a5fc94726612ce89ea1848e3ec0bc503adbbe17c9c53e2ec0abfb0e7f40ff62cf19ac8c3cd715baa240f7c81b9b806b9d3ed9cd23f8c2c78c9d95ca39b86e250a877af22ea5a09439e9724f6933c197ef630e529a89f6e6f0afe687c3437b9beca7a6f78cbfd6ec03f68e496dfdbfbdde4fb12f7433ce18f473edddecf3ee5f56a29d7e68616f615e67a697fc8a0ee77bacb4b9c8dc51d3d18bcfde28e5e0bee6ba50d5fd421d75d43dd0f66ad391d50e59eeef77cd2ecfda1b37dca9b4b4067abf2cbdaffd0d9e21b5a5815fcd5bb1c723aea5b6eba2aaf9129d74f56b939b906c1320a63d086cb6b644dcca2075d60df6398eb05e622c22c05c71f8b4ff01dccaced3aea792cff6458fed1d44896bbf2973b391b95a7ee4bf4506f7977bf9cdcb1e49614fce5e494dbfb5d057f30ab1cd67acf9391913c9247aae0abca57aea9ace0c0aafcebb2ca6ba2e491f0baaed35df0e9d8e926fc7557777b597e6a39ca9b1302f5165c6fe7eea2ce72bf6794157bb8726d4565e5d637a75281e8ac828360d93e7241c03469d26447ccf51980b9e21fa8af5c9827b74326a75ce5167f5008eafc24f920f51c411e2323a12322a496fdd745349efd2793abfd47a3723fd34f6f6e07e4c9292af88b4056b9bd9f4cb6aff77b9675d7fa1aa972835c59e5cdd9a86020327f30a3700564720afe78d87b7abd28879c0dca4fb723109d2d0e7205d181264d9ab4b209ff90c9278f3b72b5b5aa1ec6e4faac56fc6df8078ddec997e7933c196f71d5aca933800891e8d1ba71487b6534cb7ace47c80361e7c060c4e090d135e2bf1b06e0411bf1dff38c4cf4228acbcd43015d63e60d442f7f32594787862a80479228a3a5101262e180d8409c8155682f62a199340a3212ba060c401b2cbc7681c007a00d5647d7f824ccf276864d58e8c3920f9093e1a14fcb962c0c90abb74adecba48c5d7d5d04d334e4e7f5a169c09ad2101861bc380c6491bbade8259d64cbba3b2667de0b68b210ca0c4050a28b88a8c602b2bc5ac5e50b0359decba65c49d69793eb9039148221b9331c02c18ea9e5fdc6e98ed3f22a6a8e38c8954ddaf12100ca2fb987424064fefa25244bce46bab80c41cadf3cda8288792ec10940c81f3542434b6e2e2e93682a89392ac87e14c800f2a674c43cbf247a51069616d1d60c269e3f716662d1aaf8a905518e474747aaa0e17137d6c5c54546a665c4564427c3eeeaa0582d5707c5822b6fce86e535918888517ec94d44e40845355607ca53de33af93cde97dc234283b02731345afe584cab18b7abd29775ead6be5a812cab5e6b0cb9b8118c4f591a2c750ee970198a27807cae5738d440902e445c6404ea6c03cccb31586951c3434f9c80704a6264d9a346175d7b0ad7427d09d4dcc9fe8c5cec7757aac00353f727af2751ff39d2f98fb28a78460e5698b0201d1a0d40e7a79fa2eebb2dc51a0959be5a02a0e3081d8586ee7959b659cda51b37ccd12a78290f312a778dcb4a8d103666b12b576928841d18b4838ed2d1807e3f0d8812c97df3c858720e103cb05a7e40e64a5a4cb7ba4eee272212d4fe11e2e7ff90b16d2dd05a724e6f17297964b2002f448f42e6db95c5a44e5b4fd2146b9a7907b68c808326d512671c6f4f82c1b621f4fab50c9f1b4886a91291639d22ce47829ff6c892691bce48f59447d81fd2890c4418c381267604bc21389bff664689e9d1e3b6dc9a352504e6f59a76d207996154c5530968251f00957fc7979074dde2890c9740a34b31c2dae004dc6f00784e9a6933b91442f4a1ce40a424893264d88323689b6162acbbfe4eddf34ca4e232f4faa745c789e6e9f1fc53f68b2f60dcfa049247a1113faf901029a447312116597372bf566c9899d3ebbe6d2b9d6d27579777a7bb43c75ec0ed1f2141662e4c6e5dd85a4de22790c4961173c892065f9d91afa409119904a1b9d5402b59800922bdaa29802490a84bd33a53ea4c4a91d9ffd494c7fa80f6542ca679c8da42d7903135b391e43527739057249e13b7bee1c123df9895dacc17e3979ee64996d55bce46c36708420fc60c8a5933ab21f6d115d7174b493450f529cf926912de2cc377f72fce6901c5b4b620f2ed48a38f3fdf801eaf191ab26b2f3f95da7adc6e1e3c215b82e9168651a85c6d157e44f6e91618b1a5d17863c9047082ef77161d85272e991a872b9cd921253a02a02daa2401f355a82f6f4c096cb5b6e4abe59ddb1a3388321c955cbe3b124aa4377e4cac5e3290fedd1828d3ab9b38b7be94855fccb9d4952159fba13e9ce23a98a7771646dee2110a4217ff3c8e5c2ee9690000422f3088910bacbeea624a62dba641ec5792404ce884b0c3a310afbc122b8127df041073b20db927be80936e427bcf044d14f4b99a3dcba054e2a3430d04498c92e92ba89acf8c88a184708aba50a3b02464c0a24403188e1f3a29c72ce396717a44ca459a994d1186126e79c534a1b39e9906c49447461d817ae2fcc78c10848ac0470de0c6d2e51d367ad22a3226dbbce5a795df68ca7dcd825239c48d7135910b66801d0132420b2001e9f2764d08382a427828082999d4048aa3a7b228a152c00053a3a80b0a311bb30ec8261041b2377145d10438c28788105387cc1b2e48ec20b4e14c10b51743d48b62e22cecc13cef4dba355d76d77215f4ac0130e6e1a84105a6b6d2dc1ec1f4d861d764cabb2cfd4d8ededd10768b3961ac34abf6e91d28fcd2eb863348d3078cdeb9a9e91adb9878e78e10a360bf9fbbc47433b524516062928967be8881443ae9f9c88a717b439693721bd539e2c90a3ac79e2c800cdd81ba50239c6d32cdf37058165898174938c6118e711391ecec72c6e51d7755d5729f7d01126e4cf7ee640eb188de330d5fe936b13b91ee59a45f42a508c9f628b5c638c3046182352aeef187f72358254df874690ea8d8f317e12212455f1f144141101e39d58bb76ec12512455da8910922b228e2e2b9e42286b4652a5d5973eb803a1acfdeb298ab276680429b3b68d2065edb0891fb98a2c4d3bdc01529ce922ed2db5778cc61323cd82968a5a9cf893ff41e24b9992513e428886ec59ae509f90c77e599e2f8a6ce7963458e9237bb06338a2feb514ada20ca5100a6aa01f9f9d3c44d1bd018a1ef4bab33cbe6b39cae52b7749a9682a97e5a8fb37be69c2450a1d54d20a5286c75f4be1c828432914ada0e46c22c65e2335ecf60d2df02704e8f04280ae8bb3b988446fb6cb8d30d83eca31c60bd2a3e84d9a459eb185099bfde0cc277a970a3b1f77ae9e222bdfff681010504f0aeb89de757474a4f21ea9428332dd30d91367a60cf2bcf4996ad0e9c1ce90680434d48321ac83f29c8941974b0cf58027cf5324712615e7e74ff23cecb1fd8ede8ec9d9348ef826287a2a1772f488521a74a9fc3aba7cf2853f382b6f79c461b9cba3cbcf4fea86e5a9b33ce5027de42a75d31df5eea86bdd6de95a30cf9d4279c68e3a73fe221267523e3f8be40a7578048d60512b7fb2a7855a9ff168ca783f0a75a1905431498a1e44f28e1e3475324fe2ef47ec9c1cdf728593c3ea4caa7eba46aa8fbd71aa69d668d30873f744c513eea993933ae79c73ce39e7fc49e5b84f8e3b0fb99a5a51a61742a4492f26d19bd717a06a7e9221cfa9863c4faedd0c64393e1edd0b8bae31df42996af205b2a767c87eb2470ae105b5679d73ca25c823a0b460e1b116b6445bc1c2a2b460338de62963906da52c3be1cf5a3c4dcfb2ad44b169858db95e42d1ab6e1983691b0796a79c22cfd951fc93373092a704c2fcaccf354543d14e9ae998e9167f59663793e9d7e46caa50d64a375561adb5e22f55aa37dd1f4c2653ad37d592092b99ea4b2b7d714a3b764dbb66d26ebda95ec3b2c725639e0c8f7a8f05746f298058de52106917666ddb36ce86fe6272ed3a6a1c58f40a8b42abe667e93acaf39ad46e56deb9a0def21edd5db09095776fc1428cd40b5139eacdeade2a1d16d2bdfbca85a0aef2d4102a47fd46e5a8577cb3f2ee3571720a6816cb4d5514eadd6f50ef5edf756fc1382bef8ea302391b1e2c3db98347b10465f815a10caf72a5206299577951854df140bdf3d7513092e208a7490194e18b6047c1285f4771267efecae2428a3312338a1e93c696604558ab8fe2104552055f449cf95a8a534ebba6dd5a51b8130c046257748d79b1d6c5965cac08b3e2c87e368af81167e8e7a4415235b9cfedf3725e6e1167b417f5b4788876bea983b5bac6445dc594325d339d6ebad8d7a9d33b0b01caa6db37a7c3def49a78ba3f98ac35996e4d266b712a6551ac111a8a351d25eaa06b74b6a65b5392d5546852ca8961589bd2de9673ce0bc34e4bd74412e38c104278b718e3c4d98cd7fdb2aef15d2288914a794929e3c4536230cee092f18a18931ec4b0c65f863b5ed7bc660e8573083b646a88fb983300ff86cf9be1af8d72f6989b828f390ebfe1a68688390e4f41dc23e638a47adc7018bfe1301e00690a6cf6d835b128893d429484a0241c654882dc43486802094b202189dc4354d8dc43541cc9dcfd66e64e4caf91abd4498c13ec611cef2a5c93c9958753a51838558a8153252144259309008f817164ee6537ca30e336fe9d9c7236275807b762e3a6e065bc5933ae77d57bc4b80c2c44c663c8c0292e47c815d0ac4b55ec72581e4ec19b19f70eefd5780c8ce3bdc671627c460a4b46885291540ade06be078dabaec238399a164fbc9be262dc1477ee9e7715c6b171ef3800788cd410337ad4788af3aeba9018329ec3eaa1bacc65b0100f5fe0467519188706d748553c1052156be29b65037f4d44031b816f1600b0e44ede31b2779b756760bf4e7a76f29314134e0d112386eade853c06eee10951e14b95097bb8a5ea6ba19cce1a0e17c6ad81fb74b38cba7d1d9e0809477213292122520224747294fbc18c029fe12c86848a868ec024cbe41e12fac94976b60d951ae21e873be01e079c72003e8c18f77e13e31ec63172729c141703a7e05537321ee331304e8ac3a92166dc7b8f19f7b0102337315ee342bccfc03d6a7cc6676021315e03374b069671151662e466c655172203f7505dc6656021dc55b8a5ea44939c0da732e3a64c4fa5a49868524c29de4a0af7d44a8a938153284f7137329e4aa1c898b1825354b65b141977064ea53cb57273192bf886c655dc4da5527a7087d67ec6950144e66a514ad69eb0acfc2b87f98ba7522e9ef297a79e4ab9dc9452397794afd0a4c0bcc09f8c8b14cff47217930aa7b8d368c12915942fc8cc283fa9bc26e664538a3bb9a9d4cab9a71cfee4326e6a050f41e3aaa738dc8306567dc6653c95827bccb88ccfc0324e375d2032a79c64dc96aad355b7a5ca05d2dda4499336649413cae995b34139eafe885ebc4518c1c28cf21f7e1cc2c37b82bf994d87af917106e5b18838739a97717892c15dd51c96891ec763c82f55dc077540c8e16f66eed7e1551d3e3b39bceac2132c13bdb73d577ac3ebba258883cc2026c7711cc75d1cfe70327778af77b7ccf418387572d5735826ece1d4094e0de13dc66fbcc7f8c963601c2327f826c65518e75275f21827b89fc3aa91f0367781d0264d9a30d921b3c680dbac184064def007b38681c8128e000eb759306eb35ea260bf1f5d84b3ec628fb9cdbae136ab46cedb196313b78ecd81892fa630e79cf2f04a29a5d426ca35ed1aca0f9a0c3921b0b6fde446cee6243e27cbfb3d4720c39fee372f67da6e6f4e8637c8b55ddeef46deb8fb6d599b3ae8350c51d77e733e85c59cf3f31e0d19334fe25544eb984d1e420861a4810d3112610bc96b0def4723c39b60609b551f5f83c87c437e850afb6d25d4077f75ce68640cbf9382fd3cf983468e9797c9e2cc87cab285a609e0ef11ec0735001c28cfc3b8d6dc8e79183fb9dfc9eb8366a4e4ec7508c04bb502086c9251ac853fd6da1b376e683a04e03afc6ace2687d7c4d5ccea5773363ba04ea893a6556b6db53f9c6c3c8a1eacb54a1e0cbb2857351b7c92c706361ee5ebd5daa4dcde949b6e54123d28f385630bc79947f8d3456022ef50842345189277f80e45207245cee11fcca72da0489273780e876289c66dd8c9c9c93cb9e289cc41871c0e374e07cc395cb3a75faf185669d0e9302c2c29296f8e8525e584c36e6861535236cbd9d4aae3f4eeb5c26a391da7eff0eb62ab9f6ee7541030ef70987738ccfd72f20edf2108017c00ef68accc8e9765f6b7efe674c01ff071bc26621be5ea75b8343434a75c3dca8534a7f9e9d809e6155fd7f59caf9ee535b2068919f52d25057f39574acad53511b25cabbf2e7b5d36d6b68c8a5a45464618923b77468216b2c88d043128b1b9912006241ba783dec5bbeb020a26906c81040a22499664fa08c5904c1fa13852842d327d11aec8f4ddcda27797d45de28c193366cc10d23366cc98819343e35c0aa72cea299f05a203e6ec33628d15eb5cb81cc31f8d8cc538eb23516b0591282a6971f6cab37036b57e72db9bd38e72533a520ee328efcc72181e5eca711e5e13b59ae73c95c2373cbc06e3f4701e8ee3c3733c87d5dc3d0f37957a7eb372dc54aaa62663213d9c87d7f4e003e4ee9b7b711eee759d2e9657cc741a4f0162937d06d681e3dd4df7b3f93fdd171708ccdd258763ec4edffd59fddf1d1e77f45e70b76121e8bbcb7b81c03c00fc65c771940b738c9d0a6773e10f275f3511757a146743af410e08cc28f745cab19b8284c728d357242208657a8c08addc435464d1e51ea2624946a293e9afe48911830346a9e6c3cdf11e2e0f7f716146b930972ecc382ef67b61fc8147cf72dc87332007f6e10c38bd876bcd5d3cecadf7874cb6f774c19a68aff77ae5250f0e31317e612ef0310c8ea84b4e08fa8a534160c791a88b44b65a8b5142501f6e0e0bbb9d5fdcce289defeddcc3cd61e1fbe5644a2477eeac71a86b184cb9306f712665666b32bd394a4da68bcba2579f72ba66ef1724460e01f51988d9877dc7fdd0ddbe539e723acca89bb2efe13039ce728be4c029fb1ce7e1ddfd307cc2457ac0298b83d8e1399c073cc4880e01780e3cc4c8ea489c656426b56387e7f01d9ec335952d09b98790f864c8518cba30290b36559f9383d8e102b800b00fd4777867980a2287d757ec03f51cde7905f3950e872ff8fb75b82e8e934f98b529b76731d9145b537016bddabde2d3399b0be6a77b17f7833987a37678773f9cbc3abd1f4ed621871b24e61c0e7383c4bc03e4ecb31baf34cfe24c3dcd2f997ce3f6ded0c2d2fcb3f906cd339a67375ee284a04d9a3469922bcea277e3cde9a0c137be9ad921e8c6953a5c49240057e670e51237b01ffcc99a83c9723dfd84bf99ed3526ecb79ddeb9721c67632d863f1ccc9b433dce543c3b16da75428d03e61bb096aea32c375a8efd861baedf7043938b93afb7d88b0178fa0933a5e4a4d4c81b302cbbc7c0313860f853adc51fcc57095bfffff3bedb5e3140aa2aabd61b99a80651db80af7129b4c4ca4f39fe753cfcb331efb8f2e1313e6058d403e601b754c9e0962ad5ed8cba9d61b4beae0ffbd34fa7afac5cc3b69595affe74235ff57e1727db5f29c71abb3f6e4ec10180364eaf91315f077361c6a48fcab1a75c4d6e30299ccd75dd0f02d95ee56ad7c500cc11c8f55f677a733627db25194bb92b1a2a25db265945454545e55f17d9fb5d08e4facb9aae1f379b7000a00decf67e3a646c0543a213ee681a07ecf0977df52cf8eb360065fc05fe3299bbc0aadfc62127848d9fbc466600dc0f66188745366ee3326c5c067fd606fe7ed0c83030004ee3aad74800dcce32ee97a9eed7e51af79347c8f0312ef793f8078d3c4fe3defd6e320da824d2b81dbdfe2582fd32ad844f5698c8f525ab72ad7f78390bcb3597bb84fde2d191f77cdd775c1d2673c1b227c76500c49e823fef84bfabe0afc38a60dc895e123d70080b49f9e61ec2c292ecb3454fa6711817dac9306e3fb3761921a9878c4044fa40266c66b6ec277af51867637116bd8a82ae016fed0a13ec2751903f591467ba43974395c34b14340ed36947bc9049103077f466ae4fb95ffde99033611df51626058939eaa864e070cfb396d6fbf066e5780fefc1c37dc0427c380fef010b3172e3c379b8901e9ee3cd8ab906b7a813756024459d24265107e64f0dd1c373bc470f38a6870f98077c1ef9e3917fc8641818dcd13b86f119340e23c62d0ccfbbaad398110307d59bb39171a1920b7188f1c3e06f66986b37f9f47a0de35a6eba761e9ec3aa16a786c8711e7e93e33c601c23f638f526c779380ff039700ecbe2efd69eee07f329e5d5d6cd743f1ab962d36ba4e9dea7dccf7b7342c0b88df9e9de70c983533b6246ddc56b24ccc5e1302e048231f7cbf2fd2f0e312e447299d4e8a35e666badf5516f2d13ad96256a1129c100ccf65048e8542f54ffc12024156340668b81402660abc2d60b201344ad97291c11b95ca2be1e5efa1ce5b0208c98b75cc1bce52ae532390ebb28d79f52ea4d3030f04793eb636230c69e973fc92393e30e19e1486e79e9da4ffe82c48cba8b766df3af18ee9cae35077d603e1df6f02ff3e19fcdf65f97ed3f2fdb5fae78b87dcd6da972711f6e0fb7e50f997cfaaf9d2ef409900bf330fd29817a0c63c8266c0893b040c35aa3721ffa68783519da099aca18ae0bbbae09afa0417a45a88529b33c23af2967f462cf75daae9479e9631e3bdc6e68c1a68248f1318fca9d3b7f13a776a0327654c660cf77ce1d67e4f624547ca09480b00d4dc02e7a51ecca4209dc381ad6de9c19c811a3f89a1cc8f130cec8432886ace5a5564d9c6530c3160d34b863769baeac35ccdd3967420dccc8b25d2a6345d60c4347168c11b200e7ea406bb96261d89583102c56ce3c0246b80520682c0d6e57abe6c90296456fb3b0db2c0d76bc6eb396d0b03967841ed0e68457072694110e41c37266a075a9bd920660074e3ae7829009373c10d4829d12a020091f104187e107f69a584e11248c0cdda00966e831ba90a022092d4ef043a63bc3fe6e83fc793468aa60227f2dd44986aaa8414f14296862086a1882c492b28972cf1b720f1535c9a6dc434548f688d6cf826d2e421e493e45d306441b0eb48ef920cfbcaeebca2ad69bede6dcf29cef0b4462b7c8764d6e14723371a66aa5f78138409c89327af2317a387048f476a8dd400b11fbc9e46db2c06e7126420ce9135ac764119569e24a9b8176552a22ee207f4d09c87798d422077104b4b09f0c16f693c9376b15bde806f2754920aa906692269d60e155b4b0f0f29b110b85748dbe0a182c3c8c314231681d53935b080c36fe9a71c618048b54d0b41c67e39c0c71ebe8d93d67f7ecd9b3bbc140318c6254ca8961584b2963f2bca83c867b46b694f328e8c7a6402b652f3dbbc41fbc32eca39f5d83bd59edf89af304cbf097fda2b77ebb27d72ef7c9c38c524c7f7439fba4d8857f1421ef8f2ec74b25d06fdae18d2da4e672230c9b768880f8fe341c44faa83888ec472d621ffdc1893fd87de1ce4060ee5f37b5e37afdf5fad227f6d19fcfae5d3aebb33b2b9e1b86951e5f7a8d2c5d98afc38abfaa5dfaed66af77be5ed330bd2d61fc75af8f2032777fe384886fec235ed334fc553c4bf7a15dc336cf4db5cd73977ec22032633e801c41af8f2012bb3ee23b5f1708fce4769c726ae21df1fdb8a3cb5fd32a4a7d9230768650681d330fa1fc25040b1f2f2bb0e53819e9a8699a8f2247c8b08cfcba20b88edd4706642ec281eb9d254e0eeb7ae471e1ebf04e213a595e0f8194980611ade116b90f9108a069dd0ddf57b0dd4162ec9eda15ec372584337a57b0d9a78410c2ac218470369411e9ef8285ffbaecf22f71e66edddd36ebeedeb2190498bd0f2184597e9ba8f932e7dc8106000fc06bb0514353386ae5aeb1d316bd993b0a3028c95df41aff784772fccb148260458e570840a0d1488185ef4d87488370caee6e8bd45300e5eeee9e32c6c4c4995496b7eeee9630b08d7d3492fc804681902a78db51d84290b2a09021514da7e4869c0228ab846b5860371067e2e171e20c4df4e05519e64f468706f302da8364d9342746310cf380c019bdc982655858f089d82b04bb5261ad15ab87174837418a335be0479ef9b94d21996cc43c4bf70d7f7f07b18d9d8795e422205b44f4e6514e60e790a833758032c59148e4c178628c31c6083725b496f029f2018fbd11208d0862fb4e6cc27e91076a10a7b2c76738882d0e49d1cad8e3cc1cce66346275a2146c7cfd23ce00cc1f95d8b586339e60df6e77967f453a1669640552d0c91057405a0106223a39620dbb189cf9ab3ee283cc8c1dc38c88de3c8d94c2d94a944c1d29298c3a3b3c30893c672a08cc47846fae07cb3b8c8343852776585d77712012419041100bc7e5382fc7717178533b4acfb961b99188bb474e47841c8f96d36b5a844f5d23f4dbdd3175c4eb031ede5410a5c797bea3744af107e3212704c70096a7ae414e01cd6a79730e60790ae31c216f4094c44abd7b0660ce5e23e32d3dbba597ba8b0341c03385100bc7053ea2a7904410cb883cce0b3ee286198258296ca474177c04968424969193b7b038c1ce97ae4c5db973c89d3bd12b510cd57d6641e6cc6cef446f422b8c66963ac212267e8aec767b7a9a379623715647ab112caba8e8cd883f1a18362961bf78abc3be747abf0c578046f6615fbabd56baf1f4f06218a5cfb0434b33faef26c30ad0c8df4df69e9f3a53c7b4448c31e66843b1c89361fbed1661f9d54165b97de441a1c1da4f163c87b07c0e89de1cd29de52831c218233c1dde53778dc0b35c24ce32f2d2b19c8bdc351695b7ca63562a7dbb5f4ede340cfb0f9db1e76478bfe7084c085f57de5c94a5d39b93e30d72e5151c0068e3462ebd466eb7a3b7650ee51c8eaf9147dd6fe6146c44f47ed0c8273c77a6ce144a7189fad947457cde99608b4e9e7df6dcc4990b70df80c8d8558185cfb2d935127e592ec272ecfea0c93106b119fb01224d9cc93e9fa3c6932b16dcd1cb6663a16b58a16dcc6b175ad135e6e98557942e3cca227a33ab6d141fe329463f9a4c6113585932eca92c8bf391888b900e3e4b92f2bc4f134079c6a03ce77c4667a6ac429e3a7205ad88aaf979052c8ade8482fda68ecffc9ccd3242cb9167b24e0dd041823e72c5806cde8839fff2010bff02027b09a5441b628071f61704cb7d7923ebb79d114e4a31ce112cfa2b23555146aa6472c7c3932a1739b0f0510a1ce4f8971cb0e2e5fce7498f860b27d44352d0c9b1832c2329f0e4af5b9c8e148a90bfb6425eb38b332f71669281c6cb08905808641e73ef319fa20530b862152e256cc8c109ae147477cbeeee8edd0db1abb1eb6aec9a92045a1c4084534a29a794524a6d421bb023b431e5001ada90d25a137607703d8bd08694529a8080958680ad602963ec18e337f3978ad0463fe6993b69638ccc119ff2d76519638e97dd0def17f3c92c718cf29ab223c45840712e8c5ed725e31111bb9a482831d8a4dbc69cb31fe1bcb00bfb81c5ae26f3921884524278c2a08497d863298310c3221614e3a6e85637567adfa3efcee240b32ba6db867ca984bf23f2d5860cc32efafe840328c5b671c1d8309e408c4e194f5e34db221c006cfa2a4b598c56c26a29533cc4c2d7c489d9b8a49098e7b5d2f6755b561bc7d4b87b6a95fc76a53c59205fb133407326af439a4ba73b2c964b1848d79047e44b7275bb22044e402206186c29f7901236d0ec25bbae086722f4e0fb82d73c84104208af39bd6c622f110ee03ac5b2972c6799e72c4d6cd2db7962d9cb8bab94c15206e11bb3557cce2cc9946491bf4e52a4a40a29e418e42b265f57138e902f254ae4ebc615745032f97bc9c1841e26846109567ceacc107476094755c8df96278aa80479526188880b4b90420c2588c00a4ab8c2da2fcbb009f644470be2764a5089f800cfb682522b49ab415675404b4f604e10ca86884c70cdcc4e91822ea080080f04996147676768880d44e814a5d44026cac490813de58e420c6c802164b5dc518ce104558ce1055f18c30c66f4d82c771463c88137033ba99079ee28c850c5fcc001e2cc67a3a60040a0ae6ba27e20c08413af28818040a402851f9ca025a60d489aa8ec0401c8058c249028a11205105c40052888a09288a0029311b2eeeef6011172f7690ac0a33f1b675266314fb0f0fd3883e7212b7a727fbe5c97854b50824496f88978868e872965747663d735a38c538832c2d2a905c20b4613b412b029ffcd39273c651f6d62fd9a98d1eb98bcaed933a31836e7ecee19e48ad3057d2161e1e375cd6be294c472c4a2db66d9b265777777675052011e368700982057a4b4616268c30b754ddc3171e144cd84104a3803f003fb6519a8a58456286163bc1a9b33b330c88e3dc3b28cca2ca318c33d6397638c1d73288c4dc4d87dec7336f6c67e659916331a23ce6a60d1314a6cbbc61170ce6641291cc9f663c71c081f20e535e735fb03ddfd5386724af99a78c1fce564f9a923c2a3c81d68b2bb5bcaeeeeee8e51cad9b108730c5d843093ff72329c17964062d89c58b7a9d492177627463367dfae715d18c5e6293ebc2e2f6bd8d735fb7a4d2c7537be2044b141264f39a544a26577c309610732ece779fd82311a6918bb21ceb07c733912c227c42cce5ca62ccec0381ba722ee5cca16e83296d1f79db3c212cce095e1a71c81d4eaadf5b262b54a292fe7155a8c51da07d5a880200806913065f6f929bb67e4bff92cc64b39e79c73ceb89aac289b905168cef63c19191a1aa12c7dc83e64d3eeabbb9f050dbeb24bce970cd3c83db3d2bf790c675225e72f0c772b20a96ca8a46d15753d8d3a4533224000008314002030140c8804a3d1682ccc13416e3e14000e839a4878569cc9b32c88614a19630c30400400404000406466da00c0c436764055e2e393cb7f7b1169696b44dc3d53a14306f060f1015863a2d2a8e5843b9ffb1ffa8beda4fb023d1822bb81e7dbad20d60725548b59eca7d708e201e3b7810fef2df099633a29698dbd2f1ced3defba012367169b549e4d97c89dfa747367248fa832b38c5672abb70631dd62fb7c83312f247bb3001a6313212385d857242d53ca162676cccbb2253d5c5e75268c23f738cc0ed896aff9c3a49f7b4211fea5dd17ebcc4092a25af46e284d62ad80824a16614b6585ce602bf3971b0c8d51f74d0ae44034f3aea9ecf41d62ad7d8108397e3277bb31d0a1a1c8771c6c2e2776520bd4328b64ca5ef0d7aa8ffc40782d4e095f26371739baa153e4cfb722c8e14744f4cdca76cbb26eb4068f060f03935dc6e692010fe6aeb8bd090278383d7c603c47eaefa506271e63afa1838ed54ae28f32a6b9064e12c10b0b4488bc7adead5c92720472bc2420b75c37d19f2ffee648bed2445cf523c8b70c463f768135a76089b243a87348f645980f14e377a9cea930fc076a81638f0d0d90086e1d54713a8721f80ec81b7ef4c39bda043b160e3243110d5424069a3480936c7a4d954cd512e0642e15543b42337a6cbdbd8b8d281116e2510fd134f9c9f57848ecf632a45b81b40d5be89fc85854397205ee5d25fad1ae49424ceda8258c431a9d380e047c84615b261da9fd3d61af153243bf0aaeacf3c6b18225e8c690dcbe4416ffce18c230257e1d8cb20e0c3e1fe18fcd421986c2399fa401b3eca1ef13d0293c667ddf4869e7858bd67ef8bded878b01c03731c2ff9be456fff7694ddff5f69e73e8a185cc91e73b8fe6a044ca8a7ca55efd7ea8f8961e72e36431c4611d3fada9655befdc3426b1c299cb0487195a16511d77fe3b83ac56a9502e95d8a00ccdb971c23c1dd65823ac470d3418a6fba0523b28c099062a9e98893b143d5a8e1e9b0f2478495e81b84ac1722cf92302aa9269b36de546705a4bd228249def296ff7fad39edfa4317049cde183030ff9e1a30389330ed683ca5bf18a1f1c5d1c51b32529375d164e4ff80208ecc4ac8f2b3bb7c4420fe3904d931f937293c371d5466e0aa0e34b00d6acfb4e0c58f7f476a28e13f9884e0cdee4b5eb55c5564bcfcb3edad5367a6a5797caf0956978b41005a2bba3275d275c5d210e7f919a800383ae15989db5bb8c2f32433a440bc8ecf88a61e53b75b7ed8a01c2e4df9c4062b1c2b6fc48f701d70a8a87e34aa2014adbc13e7245a93bb0c2a6f41108779272ec56c733252b48e88ecfc0c57e7b989db3a5ccef273b165d5394961537143bd85c1bef0447647df647a9ddb3eccdf51f021bd69a5c4814db14a2df1b3986e44abc4dd8c2e9efc10bad6e0edc875bbff776c47ef0070354dec4310362cd23194b7037e939e3c6dcfda97aec58aeadeccc3afdc97f380e9a284383367c04da44e6f14a2f6f6046bf80c9598f35331f1a0e5113ba8603c2f863028743239e6fb643fff67e8948545b549626777658a5a50cc544b4e1639e4888859c598a9279f210a81dcaa528ceb010399ad36a9dcb4dbe86e2dfb9b1ba3c9169a3ca4ff1c4d288165573338e200b8e6140be97975c0a4a01d11b881ba1b0688513c657481b947a58c256a855e657015c8437fe54329753b0f14ca5dc2466031d3003d348ac380c969c5bb6fb579cc23582874b87202068b76b906831396ed9352a33632cb81dccef939a2960823a5a8714fcf13ef3f4521445ad7fa4d496d3dc4efb1c7837a2f9ce1089147a7b683113975e80d235164f2c02992f69340182eee9aea434f4c5b3f53f804bc98b2c1e60c6d0c98471c064e711a9cfcb5111fe990de1f10265f67d28cd21a74a4a6384d49e53e43b191a7e781f1d301129f523d964b37957d8e146ac0e673fcd126e69718fd540016b8314dee79fbe432bc35daa3f3078388aad066ec691bd0709840ed1d930e67738a2b355b4cfda2a494a9cfd26c6463e17aafcb5815b5b48ac8445e24d5f1cfda0b9ef3777c0f24a2f58cab0e4e63fade0cb9d2cb593caa285d84c4125bd80a1c6aa230d2c06e34a2c78fd74dac4733a1287122223f3ce7351cdb88d925b0edf02711ad3fa38f264d2f039299df95d04dcc0b17dcd11f1149f079538689e70eee6257ba8ba85532a9afb879e765bf9c64522a7f5aec4cbd9d8bfb1689f41dea405ad318c868aa5391754a78f8d35b47db53e8ecf87fec02ea293550fef24dc6e0cfc11e93b502d626c3afb2e1600409277155fd28a69bfbf18f2a09f67cdf609f61f8a3c890673951edb4f23d78920cdb9e08b157b1c168f45ad2f8cd73931a232c2b62d5c4cc108516dce83a4bb3260006e8848136064b63b69c5e8fcb9e3afbd61d9fc4623bd2487b5ab41c337246d643af851320faeae845109fdc4600f216fe429290eddaf6aeb6a8648754188c8b3ecd379e96ded7132c80288aec874cd785721725ca353b4903ba297d656f76292b5fa5f4f9be561c4de639a6aa0054f89af41cb7b338048ac33e7d8ba371515f93c4badaaa7d9222ab3d6dd2906da792a2769d17164a3ee090c88c545a3694bceecf4ab1e484acc4d232c63fcee98c29cb492f40352662cc0147d07b2580a19392e91a0dbe45ca52a0252f0d1fe4c976749a875e91a9824a4ad32df1acb490a2958b2b571c5061bb57b32665108f383c4a7d463fe69469322de535b6436ec0d31348b52283e2ac868bebdecc72e517c662ea1420e2ea0be47f8df233a9dac41e771df965e986cd3557f8ccfc73defadacb0c835c53fdd2f0fd4b802e585a67f29d292d08f49912853080132ccac600496561df98a1fdb943f1a53bbf403c907e392a3125bcba002b1581853775d46ad8a84d89b9d0c527f885ff7a1bed4a09bbae225512e8eaf4bac07d6eaf3db807dfa8edbe84036738d189bbb8e0b83da99150ec914475556ce094223ddfa764366ea61d81ccf668c9a81564ad7c843654ef76b2ed5bd8407d61621d86023f2d32b1d5b38784d4179f1db676e9f6f96f97882a70cd33e84d51da044ce43897a29e8010191dd76e3020d94cd3bd912696a4b2cbf873a099050f5050e1ed2443331784cd4da9d0dd116b5681b20de4ce509416829d191ad8f178d8b6a168a1a68f7a0a9d509b59d6cd9d732b57451ba7d59caa22d1c723552f4246b63fd06a5267695481dfad90f4a1646f68917cb45692155f4558c59cb9e6f1612902f88593d046c10915ce832aa5a74a0cf22c141fd5a75c91e608260d02db438b5ae0c2d453b39ad74716da369e58239773c59fabd7cd27ba89d90a52ffa0c3b4624ae55a9d99aa145307dc6f5675e79e3558f1f8cb09086e9e61f976c3f7f9de8331061585d02b49e0961dc181c4d8e048c0529375f4f8395255be020b88ef7e248a757fbddd76ee806ed79c8533fb2f1f8b00f0b42b8e62e22726a128239fbe2fe73ffad1d0478714e044a519fdaf4e4706b801dc16332d2184bc824e9041b6a6734ce7585cf52fdeaaa9498aa3fa449102819f0005b45b9f6667f4fdc400bdeb3c8d4f96a8144484ac9b8192bc7c2446cc3f370c42559c58fd2304f901cbc2cccd89bd5c4db98ccf407e05db64ab4c2176dc67ff2738b667f9706aaf55578e3980512f3c94e1c83fdfc096ca7b00ada08c4b9a7f2981dd8c3f3f323baa278672bc14f3d8d8db265e2b4c21815a78f7d19a500fc55762e262930f4b3128e2a7327b23dfb944c190fd25da2a7a6c2f28809f1e7390bb4a77614e8d9dd4d11a9c4412a6b06f6829beb8d73898743c877264b60ec764d5fda11561eb330f0fa6fc9e29f3c61444838a18f3b7b598987bf87f83cf8a0c707d900fdb815b7b5302e2e0a0eeb5c011cfe26a6475f8608b5ece79af3ea01222d31b9b3853f20b4569878eb9b01778bb180136b8917c6130551a2ff655fc189b32c56875b63e8277465b8259b2dc8a724bfdcb9645eecdb04da3c7ff11aabfe6a5f52026c4cf1978ef96c9f31a56c230882b9a2feeca8b39a187e28e1294e2f79aae36e05dd3865255b32214d4ec03e3f435724c100194febe1452bdf276310313add860c512a98e9de30fcd174571a482cbf73c78e5c08b4f9c49db2bd84bae61967dc7b7e7e807d9ebcf9af37e5c1af22459ebc14c8b2108d54b7fc92f0e415b25d293d9c98c921088d0726366e4762d5c16b62a72d3e058764ec60809aa67c49937576038955367aac259476368557b563c9b418ccb7055523bb40ce828e8ce4ae77d8b8e9acaf4cca4f081361b3b084f4f935099791bfd4b1751eec0aa0d1a604816ccb54923ba5798186c0690090ad100ccab762315eb4d0ee2fa776a9d09933c891169770441c83ec869ed7745f9ddb91d665069cce12176d12dbcca8b1048224a5119d499cd0082e0b24f74a6d6cc4640ef820b6ab6836cd6d374099f74421d39336dd554ac6c59a6328d5c4ebfddf7e5a1aa4db59b44912b25d2b1637e8a185ac0fbbb455a2cc51c3d06059d4d3bc9b72b419c3527e85cfd0ea43c1963f023d279efb094fa4a962a75a8812a24bf50fd36234b848566b364e135b53b81e8ac88f11e3898cccc3ce692e2bad8a36dde9b7d61a6aee17a0ad9ee49284a283424f4d9130023ed4858813e0347fb41d54f96f7986dfbf09875b67ab3ed2a2c0b4e485391f37334b7280ca971cc8638e572d60e46b5fe4ba501c40d5b777741f316c6fd5c56704405ea6bc294616ff95d3ebfbed3fdcb256d56946b6c04e058d732bdcbbf14c4b2b5465581d70a26202dc5d50b49f321dbb18bdfa69a0c0de8227873ee9b67647f8a3a7bf381295f219414cf7021d7b633b7f95b04f43857ce6998beab7ed66e02ce435f378ca9afc2d9c97267c9289dc9ab53f92b4fe7b2b506ce9f49b073d8bde4c82496ea32c16c043674bd820f5acb061b56b0edb407cfc93423bd161eebcc7be83b4127e1fd4609651aef10343abe834f1f164a3c949275cbd854ab9e294e231946bf9d5bf170a3ee72466d9a6562d7656d0525d3209ec8d839fa8834a3af685010b97a062ff3ae0c1a80a111424f8828620829497fef4953551fe52ee21f884a3fd53dee6fa17644471f1c59f7f7e01f228baeba95416b67d24cc975394a85685ec21e576c7446fbe1a4a701dea87f7381a10a929fe6a751e80f5d7a679b56dcd61db6553bd133de15a585c1cfc32babc38e429df36b9cb1b3e93c10911a0ac7665edbb2de33cfa3b101312a0c8b11e14b129197ff0eb9f121a617c44a805c17b44943f5cbcf4c288a5aa32ee2a5080ff8b943be8d6e0a68ab835a78f68c279e43712e350c34c502ccadbb24419da5c3bf22bad29696e0f3854772d50f7968b9ca069a2728d3905fa00329552a684e4e9e5f82d55121c1604db0ee006f1e0de516ab1d70bc0ea68472480b58334b11f2ad7a5ccb5a4032ba260cb212eaef0be6ddf4c95e11c346772740989e9faadc8f8c11876f861e512b894d47a39921ab4c6460c6e8bebc09354fc804cf9b59bdad3cb94ce9085005eac5cf49533945096844f8a1113b7b4af69ee9e75f7d0099d6e75bbdd39c240ebbd0213f73a4df4cbee7052df8dc2cc845f49324955886d000e51c89c8bd9a78c043fd1e48941fa253a1d8fdf06e00d28860ba268e24d049d96a813972283575024338d4c151e95c2a4510653434596a7d1d305581dfb7be6c5115b9a93152c70f647244f735a9298faddff763b70bbfa4d5901bea34bef9f4219f634fa35a93533000336dd0d99116e4d3a23880084464052a2ec469d321ece80db6bab330ab185b32a876637306004978b49bb01081d3a58ec5c3b2f9b3b5db17a1a4d2e9c9236631b8624cd2862fa1c324217ef737e0e46cd79c08f67b5f39db24580b8716bfb096bc790fe1b02ac658c8a3c33cf064d2ccb50905963826c6850e3a4117db24ee9b2bcd77171dab1bb4aaf63ca9847a0e70cdfdf3baeebb801c617eb6e7dee919eeebb194b238fc8fb64705eaf05ca0e8fc4f56510939759682aa7d5277b968c89e172ec3aeb851a16f05bc67c4a6715cd10a8db04dc5deb3457c757a65c8a3c667c5e3ba3c81ceb5036cc17bae2a9324c055af9e7234664c3a306f5450f3162a074bc5048b6fd7663501951c48015fc300a7a97dd7ceb05a8045ad549414d086536d6ba4fb877585d07e99f7106a36e009c422fb77d27df07a1e93137268b1bc8a23be72272f76ffb3a32bac5248c7ff8fc7ad3d146e27950700e3c2c59aa1f5c4a0d083d68187521a83e36b473cd5005f19b35e6edc23ccf897a4c3fb93f859dfcd1f0f26cc45a40859488c8c4a11ed9aad3d6cac4c0c156f8332cd24c01b1bde76017e945da6bd1e13db405e8aa020319a69b4826017a36a4afa4a00d51b3705cd4f3022e88353c8a5d0dd1fff6dfe234ac3abf1e9156411e34def8a982a74b9911909931e5338cedc5342f31e5e251b9739911c2954798b5140edcdbc72c2db3d9802807395a921921326292c6bbef0c4572a97bb5d7cdd5049a2294788648820a1fc9bf143429fb3379fd88c2ca5be114100b2711ae057f598cf75df8ef1c38865325177b55648a1d15b7a5252d04c2edfb49079b9a3b4046b1e1f87ce526545a018a071aeee55747c87919e11237180b5ec6e02e41a2e5f77de1d43155514b9942ebbbcb2ed59a8105e89fafcd38858f8ae336a7afce90c14e8eaa874e40b64c03afca87c1cdedb4261c9ee486e88f09527e4c24feb0924caaa40831326cb457a85856eb55d282780f5b939baf9264cedbcc435326cbbc3b661ee33848592d6acd4d983c34e06a7b5bbdb4af61f1caf746cca12648d9da68786846bbd6e645615496d98242df15a44904dbc2e4721600338967605d57fa23233cd0d4af629f0ec9e6ab90fd4a7412817a33467402b8be0161a62288bb95c135cd23402a11918fd250f3d6d0904f1569af6a54cbe389600542e2fe0b3707eba68556a9c522e8fdfbb31b6c46212d765977a0286045fafb3918d38c38267b0e3a972d811264401cdf3586844982dd59af7e0058031992c77450b0250bd7e5764320797d48a0f3f36030e45c1a21e8be1cf44814d080a7b15e267236f4740a927d028e4ed0c97bfecee88272bd827341c703b1d4c857cca9fbd3d10a96b3e6f9fb1421e1eeec91d1cb30cca8506c120dc7a6c616e370138a02f2ded6940db5c1e92941c416c2f2af7d50ae5381fa970c8a0a44edc0fabaafba29f38c902a34f9f523050d944688ac0dc001df3ae96a435fa621cd81a601965f2985b798ad3243c70765eb68f7f67e1584400b5d9e2729315e714ac75b0a0b32c194a75a3e9c0f0ee1acbdaedd40214324409db721cbff86ca6887b90b800e7860b9ada5e3cc499096a954134f4e765f6a58b33abc4dfa1e0221b46fdcd08adfe3953393f16a8a2a117cc52bf1d0f428209ba78b10481c55803e95cd3ec79099771ed3507e7b5f6551fad4b49f0f7a32c71a052187ee35c347df512ebc40bb7ae94a2389137dc510b694233b731af2a00bd1507e07c441d9c2f219b02e923ed5e5b7a1bd0b544e226474274ec8f35a85130468320076bc9ce0c26dd033b154356d9bb33d46c556988a5ec27b97de18f4915751cd18aba8dee4a73eb172742819871c40f9495d1121f4becdffbdb6617d1abc3152254489d6236309efce375519506ab2fb31c2448b9b32d91efeaf93b80251915292cfbd573dd5ad75726989e843cf9e3934eab3bbd7adc7087be75d787647cd70a5b69ca3337b327dfc7ad5569e23663ca5ee844b7480054b31fe72b96387aca843c0b59334d599441dd664685b56bb9f4db46997cd731d2da3b0089ff13c11b09f98e135666da5306a248611337788444c59ac0aa5c614035ff50f8272cf339acba389309006f8c477867590bf080bddf6bfa523027ab143c68498b11728afac88f684ccd8e04806c91d9312fe8411b6a4937d8102715a0bc838a49f1d0e0b9e27c047a1cbda06fefe380392fa1fbfedc21a0651d93b20c81a1111a7ed0c44cbcb8247cb703e575646a5241a663350e5ee0191bb9167a60cb71321cd7211ea634b735db159bb5b420b343d4073a333091046c703e45a5e43fb48b98fbfba7761d74205c68f733cc25bd16db1a4d633a9cc89d0cbcf3058f4b58e231da5fe8de53672689e03de0ea79afc6538a62d36d729c33c58ae66712493a44c9799d4016ca6e249e2dded55ee119f8d43ad1be5920f725668c8f96465db3a1c9ae67468b8fa006363d6d2fee85ed9eef9a113896a08d35bcf3783d121589757eee278b94e71e4e94e41bac9c0e7bb844740e3abcb211ad2060947948086da401d702af6dbdbbb18bee1375ac4b2f088909309677193aa468fc3125f3d6170a1afd7fb1e551afbbfde8f61d0b71d00ac1fe932c08d62382c1f97af39417f7cea6981b125f2f3b5f7369060f67adf4dfabd5ef3da7d1eaffc64e3178c0df4958c132b673b7e24dcff797937f72567034de94f3318ba0f66c241df9003c2f09f9f71b71f7974fcfb6e2459dafe8f2135090fc1cc1468b449dfc2e5b67d926c0af2be9a478da0005d53f3fe8fa8356d2470d01185b0e45067293aa82fae2ce8445117af79631f84375d7b4f9f4e7855a9457d3181c3d0a6c13dab0a1a41c8aac32bf5c41864cb436c97e7c739d749b124941dd404c9af42f60f4da322fa05dc5aac283f9fa612567b80a664763787b9f1761fa06ba811147deac1207d0c6ef943c33d29e9a031bc144b10b32e30cef6b7d5c7ee4a1762825590e05f6b3afd1212f95458bbc1a545cd66ba2adc3b9a55a2aa3557770c610c6d051239da83d277001dbbf035b77c7ce6da840f04d43030a3f065eb5f74a0f70b78f2bdc7bc9785c5b1369c9115d790cbbd8cad3d8a23d1efc6db23b8faeeec31c15489bee096ec7381f8729e6886be1837658b80a135c4ee7ffa6d06c6fa304994bf8ba9c4e7edc8f50836ce1e1c3d386a1c6edfb9ee95e5b1bb52dafa58f7be9ce5b0e882195125a53c4e33e795eefb3352da1c20872bec804997f96659f111ad109435b95773eb88bea1c124c4516ee559e7c581d9b1143ec5ee10f32c519e3227882d82c4e74250d429c23b044616e0a70cdfb63b616562f6231c37bb53a4e4206c21ff4d9d1c431a65963fdd765f068daaa97d009778b37dbe92fb13bb0e3ebab4821769b56b7347a32d1f0631672ecdadb753719d6a17949fade60ec0f1d942bf35eb5fdef580bbda9218bdde66519d8fadae2c4f36ff389b5e8bc79e67846aa4faaad24854e95a55e654cc4c4da3720feec8dca98950ba6598e9ccacaa09a404d52945f55248e082d366abd210594afaf5101cbda6b4ea4abf6e3efbece722946f79c2de62772118514a3e5dbff9af6a22b5ddd7b152eec6709d74341278a99637a94e297d4cfb40c8e954064fc3810ab0ea6e5a2b8d77f6fafbadcbf05385f82396fd07a0441b857f752c696a469414dc1f63fc4589df6a018d5cb6a54bdb3c59219ffb3570172b02fdd65bddba677814fb1dd29ae243a7f060bcb25b7725286bb3745eb7dd95be95bd7c47c1aac839153f2e480b0b1ff021e8f4a4cf3b34e5978093a48691fc83150f2e875c0cecbb37f6381de797e0ef00dc8b883d25f9dc24a2a034e05e45682bdd7fb3c865a501f63e52af077a3ba2501270af23b49502945e25c95c44e2a72753a338155f4aa2825b35ff71efd112e499212e3b7a81d00693c768c07a13e736bff9b4e35dc5accc57a344bdbb776326d4fc8e870aba582bb7f1ce91ec7993d40247a9e4491a9ef95a5853dd4551a860f1c5b5611e2d6adbc2aa5c6d152e5a546a87f6a3e5a5e0221b658e30cfdcd11b9d873690b833c345182c771b0a14f357ec53a0d611649b93af066f6ee3a460943cdb21f3724219771f1977b5f3846750f6424112a885cb10b10f48ae93756d470ee3ed54ed81ce8cae6c3877db6641b0643689973367125ef406f696eb58c67dac6f1c1767d4eaa82d0f4d35236c998b3c0bbec8301ef4871eac90dd66739b2c73936dd6eec169479eff6d8632302955ef3e01e20193c49115aa31773c625a1eab0d69c01fdbddcf56b6f6a5a799d34d86438af30624bee30d6aa1498514d436a73927182302d2d4fa426634492cdff758548690817c85aedda916b44073f881d0e1ce6aab2e7aeda4cbf24cc324c61569186dad962ec6de7bd095ff7b0c8d52f1b64c9686f70c73a2e3c6e0e29c283811b93e76f4579878bf19a1a65cac5cbf1dfbd53ce1621dcac6b4bf1b5143a90661d14ea2287de3c97d1066a4d405e76c20e8d9ce6a622ac9ee42d232c60d2ea1f672a24414458366e6e12abcdd3918c01d7e70aaf05ae487994a5b84fb97becabc2e6a564d1c0638516c384cb27f148d497f208142b358366adeaaaf229e360b28779999395849d5fafcd6d89d96b05267ada1ed91f9bfac8985d396d38f464407d46017dcb4867d7c5d1ec491d235a0d1c65233840b9f8bdbd237097aae9ada2618c883db74dffb7b2f6d0adb19c76492332b6e8c80d8f3aa6c582595464cc0ec84dbab790bfb1de86cb54bbe24e0ad25b19ea57cac39504a65daa8791c17b2d3479dd373ea8e9f0b7ae0388da35b29953c9d46cf08c263d24e66a91195dc748a67ab3ddc1d1b565acd2a55109b199c553d040501ec9c3c101470bcf49e45f9b40088dd22a0a40c2895f8e28d58871779e145562689e9ba8893931faad1ef3b13fbe728d11f0dbdab3d898ca387ad000b817166914a4dc89800c81c1b526ffc2901db2bfc615a645ea6d5d49ef7728900978c9ea1a02ff31545255ee28100e4ec7053a2631e946ea050df4559fdda37ba1b8ede8ceb446ee7e24ef41a7d0c7caf81b65b67262f7842ac705fe36f803b11032c3f4eabd191de8bbddecc64624c49bb0c098b73095799d5c69b0394f3f884c4be4bad81d892de9e56b8562be2ef4d20ef440d028a9b13a11cd8fa6fb9661524895dd322739c762bc7c13ab66d7912566709ab1f522c406dc6e3b54549b86a7b29fea9bc4604bde5d1b4330817d0d7647be40bfd5030cc6601df002854190fd186ec7ceb90976503dc76238653577055a4ad1034198b32d30302fc9bb6560af0705596ca06b4b6107c5003c225bccd708edb6cfb9e84defdef90357990be679485cb9f112cbbad0c9513d166aa8184818749807b2665e0a08234a81b8d6ae0558c251e684d3c0897d532f09a40b1eedf699639a1558f6c75e3761350465114369edecdb9e04f2304527a68183230327280e61d2ca7b0619efa07e98b133fa0b860a735a04619e2002e9e9a71732bc51bde299beb151d4d5b692711a827bbddd1e43592bfe844ef243065056e7f40ab7760504c6adb9d899c2a601eb2e44dbd635c1b051a8ffbfb1dd8e9029c9d15a4fea5b74c905cd615ad9f8643a9af046d59dd90121092022c0aabacf2a7dbcc82250f451e008646d51f0c655a6c86796016fd266ff7b2ce86f13fe6154a4665c7333fb049d6f7f9198ebfc7936e74340d74c3e745e6149eb31988b046f38e522b2422a6bd154ae0fe6e8beb7aa4c816bd11436a59956eb134426ec501ea9e631aca105dc86c151c0aefac881e0009149a496091be97713360f935337768040b217d9c407828882dd48091779884a834ca2999c031ff13681a1884d3a90819ede08e4b07c8fc5747144c598106e02d7064fe5207613864ab49276eb27a370b197348bd556d9881174626102866a2f862d6d6c10004f2ca0887d7f17f17343074c401d78ac8fd3f47ab55cb19f757a18b1e33b324dc8894f0307fae4575108d37cd7a08aa9c157df624a116a225a1aebb0fa04b38009a9cecdb28d20df2629a4346f2b48fca22bb65573bd28652d02e4709b663d7923586ff586f131a1c22f29f5303db8e5828011dab99bfeab744e816123123b66bc96e9e64e758f805bb202dfda12395c902566c5f506626f0e2cb038a9c7676817dc72e1bf196942893112c3468e306cfe1c0ed432497c921c6b7db911b823b7ccf7becaf0d1dfa618accec50ac6fcbf48b2e01bd3d781a7a8d21bdbe54c612ed8c8e433ca4b7f8a5328d1dd9098ccc63801d171a0f131db61dc46878a0923693c19f599dbb418fc85c7c73b7e04e3ccf5786dce0e06e084541d9e1db27adddf10bade7a791511e0481bcbf048da90aa09bc7bd019eeb51748644e9e6a923a363e1bf5c6b537775d5e722058fe6402a725e61fcc89a6ff6e379864cafcac0c03a844438d9aab5a97792ef193d7d5023d706b9a5b96c865dd4873b350e3322886d3a512bab9f27c9fa91b3b870e26647d52626ba26b332c17a22be9d4add760e3375d028fd10e7a6df2c416119c56830b8e0fc91c6235d39a162a047cb692e56eddf63d7138b0e26aa3fc693d7562be780c432dd54fdd8e18a57146bda6c30623b846f82737d685b2f42141c03edea0f4924e55a45bbbb07031c9778047e62463849dc3a2d25f5666a2b502a1d3593ff07f04bed875ce1105562492876d59193e79ca4135c387d005cc5e758faf234c8128f740c35ddb4903e5cbd69150b9e5e145019b7448c24b12aa0b60c1c0461fd0db1ba51eb4a1b81aced55864b569fe754dc6418de827663bffe0b38aab8cb0b75ffba296d84bb6ee7a90d16ff3ec936fe547877db655672288790f5b9290ed4f9285947453ee85522da2e033a6f5ccd52c828803d458c84647e09ca9e66c564d46b10c85666900bc5149bc5c6468341b3f737987aa0b7dddd2804e9f5d1f0318d910a14dfc9202141cfd79a95aed2fbe82631584c8a44af2584d8ffb2a56c90fc9f1d97abd66fb02bbe384d339fb7baa271dd04cd23f7ffb3faaa7bc34843f0f4353f21d3748eb401ce0e795831e0db60024f47884def0f5cc6054fd99906ef4c46fb872ddf55d3043f4e6c23b3ad847f8232f7555efc0fe5232d7dc7c5b3dac37be54f9781e030b2d2cc1f41ca1674b116127a7ddc50febe8eb00f1d14298791c65381eba2fb49474523e2ec5307a31bc65171ce3f098087a030a79a70cb844e88d1213cfa58e54904d86d2e0222075148152a7d1a2efa27041789aa4f8eabfcb5a43f2f905a6b01200967a61d15f0ab11cc558d388fd40ed4206662ee52f41930ecf87a0680223f8ee0b1f197e21e1666d19f6f4d5b871c07a92ffb8b8e90e30c16213d6a8d2a4367b5d207fbcebec1842e5dd7ce59a9a3f330ace7e29428cb660a06b3436b169ec66b92bff32f7368608a25a3ed7f16ec4ae410111a226c0194e7aa3a98e7fcd3ac238f6f34f5fa5711c37b6081281de0ab688ee667448fdad44ee54da9cf6a0f6f94cd0ed114f019b5bf2f9e6ed21622f3699a4437136159275c437736875adc7654931be3bb41d2e753407be0984e923fca1b4b086a5912c24b104e922c7ab58fbc374a12d75be1bd2a48285b00365bc3692314369eb1d71b85c42f09d747ee0054c0d9eece12f11596e86443013058c81843033b96f2031e8c2c39611d1f6fb4d384109fed2869b4f5313da0b9800b41ec60907fc9894170486fcdeb5835960ee31fe63a0d21e3f8b1539e938f775b1fed43ca09b0d6f9056384ce40d992008ab0bc44696cdcb99d24ab7bc031b40ef7ad59c7bc93c47bbdfcee8f5643c0504dfa659d794fe8f8643a0bc2f3ac9bb99091af3b0ae2784e23489f71d22f42a09e46b4de865befa2a346de0bc882642231c1f76cbf6094c23002be31429d12222de7450de501cd8b2af9202750593bd38b6c35e2cd25fe67819bd523ca87e5c24b7e517b746a23016f645ec988393a89f1122b62fe4862bceb1dea888c825bd5960d4029831af2b9aa1075c647291690fba5f82dfaf332ed2540c9bf3471b8744ff79882d22b5ae7d318d70192b5a12c4460d46cf1af641a69975b7ff07d41ef2a65ff1e51f36512af357c16c414055e5b3eef7b5268ad64650e4fd8c19f4f2fa3a842d1f2cdf0a49005f5d0350141f9490a5e2061dd03eda013346af81468b1855f1b9718020d0d158973a41b38b270e3ced6b50c4ff42bb78b4a3361b121ccfef2472d4c32592a2a3f4155dc202a8e784b661a1a28d224714853636900f10c37a31deb824732a3d56aa2daf861ed337d7cc89e54b648a78666279d903d475f7d0520561a4a2e1c25ca1a11ee59543d90ee4b80aefbd9d776187edf7bc35b3df1efd2f0c8410d5bca2536c75bbf08f976efdbebdef84cbcdc40916b9d38f1a13f32ce1f679fddd7c24f5f926c1a2c0a5ff8f7a657eb0bd21f1a10a0adf82e62abd75d057b0960a08773cdd04168a40ea6b9c8cb1bce3f101b1fd1fffa4dfcb610905f8279b9d2ab87f2db75757ec60c93937bba28a78d31753e536f04f9e84d6c7411adf693c26ded1a4451d08afb978bbbb2bc12591f520a5d2bbf1aefba606285c479ebe5acecba1f008bc9b4afb3503739bf1e6bec461d55dfda827fb3195dab61702d48c505b88925e2cea0fd0bc86eb7bafd2f480562bfed37fbc92b2e2e3904b07100f8da40494087a968425c85bc743e011b137129fedd7752a66f1dcbbd975e6fb14a047ebad528168f98d9491fa140717bc20dbeeda0c0aa4ee2d0498b2e017e21fcc06c5a8dd63dd56c7d93ac939832189bb20e7816c0e0b3d93e7dd3cd51c79cc27397565fc31cdb4ee34ef9365c2812c341c70e4d312e0076d0154dcee2682a1ae2aa9db1881acd181954a2e1743661cb7a3f524a855c6f05e4629578c357612aad2b23bf8b8e9151b14a008d4cdf7d5574d330706ef158b04f941249c139d7b2aea6e5bfa16d649055a7706e8b883c0d64a3331d08a65e56dac6fd367ea257f84ae464b3fcef0555aacfddd6f6fe9dc5a2c28f2b0382069deaf7cae4c14dde2a4af2540967ab8fed78d2d377d70084c2266d135b61410e1463f212360c290d1c7c4792f721b046033d6ed7acf193405b973818af0ec7e026c80d0a28b9fdc09ea73bfb0d0fecdc347d193d107513115d520c0739fd34ae7525dd795d0a4d6a8bd189042303c3944dc2c3bb913d40a918722ad5f08777bfa45e90125afe3160a9cbc067918fff1847147324879610249f643f88086295a6d7ef1b1ba0c6999f4fe41f2ff9b88d54445b94f58b066d56d405b452b3b38c8f51fea981f4a21da56426c1cbd71cba4dcf362e432481e4bcd317b5bd0a67db67b0a559dcc252b459ea1847dced7c8c8b153e3abe034f70e2b29f708783ac9c8dc073240f49a7609662801c9f89c48d55772ba037be420b47a473329e21e033021ae4da13729695a7bb563f6c277ced9bc63e305ea3bc2b1f9c0e7227099230376bbad2091e51edec9e4dbf0d2854f8e75aaadf13a5adb51a95bc19cf53f1d13716084390d1e765f3d4b296079700bfd7647086e9e01d4e35223a303b9a10fc061962bb29667f31261e7d6d00ab8b044ca292b91ddedfbe6877d260096660e23c6b8c41e883763b636c71d787c019b3eee8665c401178af18a6403dcba1c8b6fdbeec3a0fee6b2878bc03f30a82ea62d2cd60c46524e445205c68cce4a49f145e2aea07be1e7e38e41ccf7e091cddc2ab0f708b9d210c8bfc2af7b4d9b7ab67205b53667c8e7f9274e2eaa3c5e4cff1b6d637b802f189ab81b1528f912e0f398a6e9b6dcfbf2cf968822d95a69b1bb98f6bec02f8b2d4dd4e5ea78dd4648d4e9835c2c5d6ea6e57a633033fef44eb478a056a485c7523348583bfc549673c39768c9e0c51649f6792be29a213655f54ee2df44610776c42223ebf6eccc4fa6eb7f122fab17d82b85941859e556ec947e5af5ed293382485a5dd2e8fe0e34edb3e6a0804e92f23a4bf9892102abd65310a2d65b1fb7147d5a29155deae468fb8e470296c6a9c55f04b2dc6d42ebf8d65e6ceafbb42cdb526f7b1af844b7185234b687b6fdb64a530c5d63b60b062db1a9b2445b6d424f563f784e0ec58c70ccfc6c6ce04c70d2d7e48767ce7ac6989679918446171e50791dcaa69a6125c580e5dcc4ca1bce6eda84dc3539c95f658c37075b16f6843b3f5d306cbeacd5ee5c14906f58afd327cde5c43d5cbf7530ac0d510b206ff85da670d5ccd1b4c40365287bd48fd8ea07d33241f7da4b68fb0b4a4c55f481f24118143c7a52c5ffb219cfdab489303321cd0dda1232eea3ad777538a4a7ceefe8b01e7e10681d51bbb283ced841ed0d0df633d40fb174de1397c9b193c0e638828e82e2c9a20f59329ca4287d61feddd39fc3e476e4d5800cf9fe1f2ec61ee4313409af24d344c38c57c74b3ca3c0d0dab0ae4e8b91c5266605797626ebad7ab3238d4a7411d554c2c233d6c96f0cd15fff9c548cb6d38a7633359294a4c2d203297e0fe8dbb2392385632e915ae5d230d9eaa57ae5ab014b4519fa4aaa953795f9385ff9459b05b7f88f98cce6821e3532f27edf388d9d98fceb5b92c3276c4cd6567375a29dabb52a75da242b7a314809d267959b263df1e6f373b9c77d8861c95569c9e9797aa02b7883e0027637e1051995b20aa1e33db0bfa6a0c679088da269cde95258d64874164f02fe2a716bc6805bb2b5ae2e85f77508f28d09e5a493fc7c4b4ff811d0b205399221532c678a4fa0b95df74ac3c736a31654306a9dcb4e9465a15adc26c57442449a8c83319efdecf6d74592421c0860b68aaf60728912ece1ab8daa507e32caa501484fed83c9a5689c2de2ec0af973caf23d907b403a64b6b1f3c21c2e12fb07afb69b89aa6b81718dd20eb03e086e3cd27a9b64ae9b033b693fc4e1592387b1aaf070269e2f716cc694246582a7a7056c2ff46985a397770620a0b33c81ca8c908f889cefde81ab7830d7162800443649c13961076ba66bf3ceb306c45cd5848f8b6bcb6495f7013fd3e84baad8350d369f53c105739851238a9f0c3bf7e03cde451595445093100e63c376aff60a216a5d51c43ec80bf1fce647237a7f22bf19c83199388be072c3982af0259066fe01afaff41a285f6d990bf365f5546d455ef7ee8aa0c71fc95033068d0fb35e36278a00701525151b92729f20716ebca2a2a91aa73b8b3d7cf1095874df4b74ecbbc19523818c603877fec492228aaabcb49cb0c5f8256267b76647002d288a0d23591f620067e987c241bcd08ce276a073e21b3acf61331edbec6bd129c2e7ea3df45be5808109dde59d1baa6456912390779193ef5177f0ff4e977552ad603758a1373dd6b5094a626b55de0f336a058e390abd183a49cca8a965afc770cd8279be614b1ab9d1e3cf458490030411c2e1f2f04edaf1ff1a33d3e08961988b2ce49c2b0636a076cec93e6b2c90520cdedac14c4a87443ac5cdb189a42223ee196d21483486df2a64820c35ebd7b680b1b7f6a3d5dbb5756a7ae7d79a82ff82ff440b4ca9afcc1ed44dab63bffc93a3ec0d87697d2290374b472749fc19a42ea1db1dabfc41cd085fe6d52a1a557e8ba08e9d01c7db50515c2a32e3c5891a7ddae9223edb98edaedaa01915330d2b84e2e27a2b90ab1098c149a81b60b522e094923e158d9fee0f9b099a281d6ab3e9445ef4f4fd062624736cc9e620d256743c62c0d387c348c2fb60453d74f1a8a6164cc68b81077cb0d29d4d2846ae974afff20a6eb3df9e464f66c47b4bea18301c2eac14adcd9bc56eb6a12c7b6bf45c0acffab7a7b1fe70d69f6ae5093143d7dd900ca021ae1c97700ffd1b16617b151e8fcb7ed40af480580c9cb4a4c92c69b383cb88edf652feebd84bcf52b30df8dc58f485d0e74a8b2fc908bb69f2271a9412c9077331f537765b857be7d6ff48e0601b03755eaf7e5d2434077215131d55aa3a361ced31dd9f7d055e6cd589a5a48a2d43b0121f94b6a8bcb8353526b8c16ad83f7501a2df9bb237f25fd05bd8449b295775fbb8b6abe34f0ea66038f385c2451ea912db50134c77dd904a41ab0c54c1173434742c690ed384ad073ddc05144870c08ce31fdfb5b86ac5fee2f9e49a276613da33d682a862fa272236ec96c36015446e356d7adf5fdc197d757b7d7258eac95d90481973785b6471ac802f726e17dc824a5860dfd60f98f253aa6bc8376c71bbf88e14fcff5f1b0f473a03229308410fec36fd004946a8b6808219e95c75fc36e9dea6cc242d4d2f076e3c17bb0e7602a8012afe9450778acec6ecbe39d865b8e73ae85f9f3c448e0d7d5ca2bba4fadaed67cba29b985e22a2442daad690380f751dadc931ac9285a6054fd05e01a8ed801b0db90749644673383fb808a8adbdda51000bb08c522fc5768e8566b4280b0408c36d9a6d12ef4bc0a31095babf53c64793a3b794eac375708c3769ca46786bcc2d90d8b9e2f8dfe18453cd24f1a495fab30be5130fa2e4a5b1d22256f43176c4a58028ff12eaeec070eb35abc8cbb5beea7a0d3e390864b13ccf18d74debecb0f12e4db6b1b2608da8bcf3c4a6c85eef8db244b691d5732cf20f0d8aab1f5b8aedbf4777b4f4801a491f40ac7f5735ad60c42689138cb2d648ca60fd67548933c869d5f640aa29fc533c928911e99d375fd8a7ebe28309376500c48970cd28c020c7f3a338fe889e1766b276c6d175e090263edb794ac371a1a22b9adda656a7d3e3712cf20dd1413999b0ac37f0ffd3227c40d136a78c74592ad3d91e89becd842ab08a3d0b16d0ea230c5994ac0bc829477fc6e8891778006c50533b83a68542d30c36aa914408f9190ee72b73379b1ee6cdb9d8db26cb50233137ab3cbaacd0736f5ac3995804fe4949bc0dad0e1108f96f39c07e1b63081908ebbf9576235bfddb489460bfb94217d09d176947e8d50dbf4dca0fff975254a3b275b297b6930b2d04d9115e6865208cf1097a0cd1c41df0f8ab22434398a976fe8872c37d4171202fdd969cd66959ff487001c41dc62dbabef24b40a14e733f824bd4bc401cf0961aee662ce2c08e7e71dde9da5e7fcb0464ecd7c7b652403d712bb9200dc6c4b9dc80308b91101febeeb9d0ee049af0670d0205307a09d386e1016ff3e0247e563addfe562bf8f1b589a605cc713459c887111c1a6bded18b0a33eb3db58dec051796312261028fd66af69e9dfb822439c9a0274162d61a1a4c72cf0b2208404114838055e53ff0fdb86856d3c6e4a28365056c9d28b19ae8fcdbad74e631bfe053aad406170f9692583f09452b3f298dc7cf2158b4429cedcf38619e620dd60723a056213103904f39505fe4b956ac0e7e4b4ce3735d2db55e2400d27d5201fd2bc24cf45d2bd8878a0838383450e6d2826565c180a2cfc76cce131ca61a05bbb11fbdcb8bbd67e40d668ad90fd0a11ac827a5d07cfa0555d2b59b8f2f2b4f90e833ff119da56c87108581c2d9b5a7a03c70c39e1005f18f72845be647e7cb63c6bdd8d58bced3ed7df99f355492a32ebe824ffe90b33e8bf8eea189c64038f7870ef9bd1aa9fee79a43dfb806d11e55e24610dd3e0a635a2d039fc55e449d1b62f22c1662f619891f0ab0ea2ff76653c17985fd1b25881be516a66449f1832ee84562b63bf104f8d327b1e56bab6d6e14ee347a64b5bdcb23cf1695d7c85ea181e875c570ab971cdf2c80a15fb49758caf03da703063f19abdb6ce6e4356fd1c131efc9b2cf1d3dedf968608391ced7b96ee6d071c6a8e38ae76cafc922c3dd99b7eb5c25da32c8892435d119e8533fc3bf65ebd02015b7013b82996ec98d18793a6c43625f0ff004762ab4df9c04e83b4768ba6df27a8b407f5149907819b5344f0e4a76c433ef88880293866ff353ff4f4b5f35789694ea52008808e815026fa225f0cd3636f65846fed129935f410b495045dedc4e2a706cdc292203e0e4188a27690bea5f86f22b7b5a857cee935cafb9dd50ab51b32c6ab96a104271a12afacbd795976718602098b257abaed5d77d1eef63650f2db3e2f815b83a359f31a74486571335467c4640d5257d731515bb0ded783e589fb8559e3d7f17f455115860d679930fd5984411c39c2df51e320acfb8c2b8249f0f80501558bc9d97e4edc268de6f98b60905f169ead6517061521999f68d1e38c251ebca319e222f8e48f084eacc6ce695f847925a83d2db6b75ac221d6e092e7338a703e66f5ec3a3a4930e1ec40a7805b167b1256af10622fcf44b11dd191f4f145ec0ac5fec7c99845beed924138ae664b56fe112ca3ff0a2212a043651ad8b579f32710de1f11856dfc12c6be0f817fc81a0e9e22ebc75806103faf3bc26ab1854291ba3ac0649a8aadb04452e18456af98617a3fd3538f315e060fd875bef2fd0f58f8c2bc0d134e14f71637cf880c955edad8e8b611258b9d0895cf2304e46380b28b1c598043e82dd57e44ad06bc617f78ad02b205c9a0d292e0ccb903a834989365267713e54690647ea678a0e30f8545f43420a700b965204ef96330855644eee547351a9153ddae1175c5c3a49615261002a89a3c7d28061d6870254bbfcf8c4d3f232c3b458bbdf452b4ee34f22b3848515cbb8621ae96977019660a2a566dd107b2e69d8f88b8b63a3a3db4c384833cb5dec81772ed77ad64ba5d2f574c2cd0f344976ed58deba32a0351fd15b151547da3ee939f239e01c7243e77da80e84b77ec27a9ade9e837aece030d51662288da86781348da2cf9e4d91fb1cf94d77fa9d82927fd506624718b8cb4168d64f1be9d785abca0fae1fe967e8bece4a59e416fe8fcb06e2a6bf560d9025878d4ec80b8a1a000f3460ca67d4d0f389276b674c70b4222c1c22c5bfbde3e51faf73e1d4e1457d17d911bd02e2e9d96571a739353a1a39d22247711eb86f688155a2726035b1db07adfebdec94af9755e8a48273d18c61d81e6f03afe27cf96adcada8b8e2422475af05eacefd52e17a3dda8c655a41d9b8300f1e6f94d59a743ec7ba5245af0517981f8d9e6f8baf8b86a0c82fbff35b84fc993861b390bdae49f3c4c73768f4106be0437f20d00e5b95a3cf611821aafbafa8c73e48c18a7012c4d20f6cbe87e71f5c6fab6e44556e79f75b643915068073f7a1d94604f7226ad60633ed37bd4ab16e4415a7b80d7903b448f9031760807a180d55a7f1854579b5272b11957aaf1612d02750c1b0ed4a59f6a0260da01bdc294e39416814845ccda753801cba9e02968325471d550cc2b2ef8c1fa0fc8700126355ab49b98e12c2b160ad383e59a00692599dc3a35e8b9b4467ad4f78591a0b8fae470077f55f1cc14fa24a682c61762b12d9f60de3c89110c2408f3a83c4a2a9c87d0f3f111a71d5a3c35fcd49da62b08414d6d34a28878cb2b1a625dae9d88dbb12b6385b1ce48e25584b561963cc230d98d1c2b6e31505279a1f0bf4dd9f44a5b50108abce5b4903110cb5afcd61c89c91f2ac4be423f7de443819a9b38cef2b501ad2a42123a943856ca3e66f327b4030242bd9639c4901443a99f54c2c08d768bd4bf755ebeca478b2aeae56c936ac081d81c97b3081a4a48d49978870f31f7f774a63f0102348cd06621a8465bc756d11f7edafaee277d33e7f2c35ac543f025e1db35138430a298f796cb30bf208294ef18e18ed8286233e477bd1e21438a8088e5b88fc664bdfefad96158f5f8db305babc207f361aa787711edcd0040de5d2b60d38652981e2f1346fcb1af0412113ce3b1340489010c7f373f1b4218e146858c017ebd9305f3524de2fcaeccdaa814c7dc88b7202fcdf6aa417745bc1ed88fe3e2bbbffdfeae08fc3196641dbc86d76238e96d608cc0444359d7de34765505d899cc0d538bf10ebcdeb8d945abe5a1ce710b676394190b80a76b7f6aa56ba74f2a7c86a6157ce8890a5dfbe0a62ae28ae7347f0bd44d3b67461b7d85a6739215ee65c9f304f1d64d34baed53a40b135f1080c599e30fd504f462631e69f743e766f7a8514ded78feabb6ca781789b2eb83ebe056286d212175c9e08c0a5f1991b14825c501f3e7b8b59e242a11768ce43902711722b383c7e61e150d4eb1dc3d7b99dd14b1565b2f98f16e59e3f6d3506d1ae3c1e4f6b310da49462744bf307a6b1d361ab45835316aa96ba83fe8e2e5d5e2d0b836b396ea62de9b5f83e1f76cc1fb7adc9c30983ee0fed148a50489cbd1435bb0d69d2d8ee98754690fdec4ad02506ebc30f255bb96c281e1dad74ed2a0ac3a477f597d961b2c7bd0627a42fc11d00d04e5b59c950ca94d00b64bc0945fb3dc5e58241b4c3c13b846b61424c6c86c751c55749fbc48a2545b6375a0b09f5ad8927359de381f0c4b1294a50d8cc73ba487915775640afe2c3cc45a7f060cb1ae44b2931ac78a2e5539b3ba79184d775a5fae5df3d433e32c312df49171bb3c7ff1206a515562446b7a5a0b399d22247ef327a5487927fccb78aee4d40fa26f7c0757bccb233d8e2af61d588da5a51f5a00f32ca59af193844e11787f86d1fc968412c1af469bc8cccbfd775580dd646523d2fb63ba43e608908e372216bac21f61bf3a359da80ccc9fb3689d5fb058f793d2bbde05e6f1339677b48a606868818db2ed04fea2c00fc730f03586e116eba4642c404df12f6a09879ecd5d620c7af27ddd8e5b72a3790c48239ab4155e147d0c26085b1068686cf17b89e8f62156670e25f1d1b0234a2c8c2dd532606c3f2b8940066deadf66f56a922b8c9cf60da212194af4316cd4536a0de98198bfc9388cc1b7c5cbdeda337e1ba003451175a7b390a11d9e4040894ad34eadf3117b6b3861d7ce0de1be0a2404a40f7de0cad44410e0f892868a392ec0090cfa482ffe87de1dba5402550fa24fb045ed2efbc9461e05b52ae48b35f65185464cf6b462e063f4f2c6063dffeb4848b50b52a0a14105f89f0aad3dac2c35466ca7af93e8723ffdf0271dfc73506cdfdd8320a28137221b7fcd608d32ac486c2909c1ac125b05ae3f11281019adde1c1329cb3df59849f502c88f1bf3b9dbe218cad2299ee2b5cdb14715068dd52809b001e98740673798fcbb4569e6b557a9f6daf4cd90b4b55f6e151cc2fd4b9646e97136b108fde318263696076ee49074466211ef7c49c13ae075e9d83845ead3cc005304d81fb57cdfe489f2594235f94478622c8bf8383ff6074a8daa64024811500fc192f8c1a925a5db63022e2821d52dc8c53e41c5134433693b7f67e0429f6d0a93422a684846bfe3e797c3dab31cbd0e6dbe76f6788711d335c3bdc070c8ad0cb4ab20c22102d82989e9baed187e4e21df4b23ad043d91383869311668ebba68721586a097fa504823f94abf8bee2c60787b4e58ed29486b2290f005ea5b32ab0df41b648a4b8a214457f8d006b68db587d26a474d55acfe7bc8bb9a795e2c101aa468001dccf1271148b7818fd7728108d3e94ab8d42ce7ea4e38e1e8429e985c08a5b5e2112f514f35ba2f6efcbc52b672a1a6a1d8bb31a3353bbd89267469059d30207dde74a498105c20be18992bc0304053b1c45aecb1e82d652fd88a57e6d875f16ef84f3e627ec84d1179fa9cf46e212ecb9728c4938b398fa82b1517b33f1940bb31e13ee69adc6d9b1ac1c4de8c40caeb788364dc5bdef3805cb6e2ceef695627b21b443c45613a8bb2f2ed5a0f2efbfc2aa0d428179a308318c8c7e5daabbcc30e7849bfcc11c8db56ea1583f0de3d322cba806c9249c5542b2c9877ede25c23475ab5727d3543e7cb7a2037b9356ac95ce4e7ba518385a5bb1a752e9abc41d73b3f36286c2f0599d3e9f23895ad4c5c4b442811bb430c470e634d0751a5c5eb0b4eba30f482f35b67acb748c7a7df179c043f661a2a1531e30fa6a7ce50f9c2162097b0b3d168abbec56b36d2889ab4a8af033097c9aa15182f3f3baf6508bb669e14dc0fc26055f4699522b318cb6fed27025105446dd3c9e62d3d796934d0fca083ef3e54123992cd5be88cb6aa4acb41ef6c20e394e220d368258ebcac7cde12b2a3231441db814d82110e9a078cd9c3afa8e7cb06bbecff84ddaba5e21d0a20f66938dbe31edf9d6f0b28b8bb04167eca3b2ffe703a230e8ddbd4bcbe576903cb061a907e2d01feb3220be336bf9640965e64a2d71ab29ed35b0bbd0db739a0c3a686f44b2d3c4538836f9bd32c4921b8867036bf9e0df731b46458c0b24100ab9daba55026c39d8ea78eab8951f7248d77b119191f91efa5d7b698de7e209089d1b452f538762a8b6936a7da646460e43d49d78424a3848790bb9c2b9bf641b1dfcdd9ab695301333bec634e610165af8860cff21e80f301cc0053cb26351fb4160aca6e99fc9c1717d635396a8052fa97029219c6570642c519ca55d40883f1a49b1b94e42d44da967bd7983474dae43a0d9c106ab6957f7bd7e98f919cd87e29f46b4394ae40724246f783dde38bf5b286fdaeca31981fc047567e7f6e353833e548ba1ee51ecb2cc6f575737568f203bbd412c8642d36a14c10347b3843afe9079b67adf8bfbd888633c531ce524aa8c423e4c106a287a733c2dc49892493e29a394ca38c289136c34fc730d6400d66e56f5befb615a3cf83910b1a35f704e7aa114a843f0bcd23fad81276504b8f31298046e11e91332dca33890239c82d924439f258e00e3f4e621b6ea4a645fa1c451a0383913cf7b9f070861a92b4b935b6a513803dd7e65ccb44ae88611f7af66ec68ce1afc575f9241afb39943550afd4e8cb67ca4e6c5cecb86de427b290579a207cc7d8252b27062dffab384ba338d4cd6fc2573f02d4a0421a51ed218b19f2f0fe3d81eb819f81b4c6b735a31edbc59ebe5eba4b081cd151ea943052f72e036b76b07a70455ea383f291b6904f1f9eab6c793b645c73635108abf378a9571fa6a505de763ec58f9195c4264ba895c09c3be0bee4644b65b029d48f3c48c16859f04251fd2bc24d5d83fede56fb05d8ea311abfb620e56b13fba59fef5f22c98189d3a94cbed22b0bf73396d9ed71a986d07bb75e56f6eb4955ac218b1243c205ddc5b6085da66fec5fbc41953b27b7b151e7317c3e6f9fa9006f0f2f89cb53092486577244abfa99065e705a39e4ae5e2f9182626c9c67fb0c3c17870e6a3a9514a789e90dfdf977865d22ce65218a910214de41a7894766e9d41b80aed92573c0c12e1da0fd1592a78bcf60f9f4fb0c5fa1cdfbc792f78f9714ce6cdd692c76e05684158b827c2fa26f03a9dcace322b61a76180d8e91063a8807731bf46b5a4f05db19373b88d85e5ca06893277c57bf2c1d781aadafe2256b599f2103d19a9ebc7c75c42aba47e25e31883f138f7e5b214a3bd32ac84c41ea1c60dd43cf2aa7402729e7f6cd68bbd47e26426a839c8aac6faef6552267d0d7894bf5e95618a6d7bdffe5c5ede31515e1b4ed325f5f1550f8886138ca405ef357bdc79bc0115462404d615762d78913c8f9292bc007c9f9abde4ff78a6cb6f0d2640ad4407602afd3825f50af05fa65db34e8c8ebe1460f776ec01e512e4b64f62b81b3367c1572b7489416368859071baafbce97d325940304d6f58029294e354f9e03f4d03a42e4cd0e30b88c61d9399fa25f076f9bf896f4733a986d1d9a63d17e26705f1a681a36bf5b9452383fa018bc48d01a3f9d8344204c989ad191c1b6ab65993d57ffca0e9e931f34883821825e8378a74e824e48ac94607602f5f2659d35d41682c275c861afa189b898101bec6e1470a82a16ace3c95a03e878d8b76c6dad9578668fea2d0952778403f082a683c5df519c0a2580eb9dde228e0284cf84c2936d3777395d49a13dc50d38bacacdf6cf2003d309196c92c17983a179777451abc874331d342e02c115ea9147a565968cd52749918105793517e9ca35af49a18626843b6f1a63fb087e3b4133f55cf2ff79ad6b113f40e04420aa1cdc447c6b3700b6041acbc2a17fa81712445a07f070db66f4edb4408a8e499fa7cd821908bab367cdbe5f235e3023c588d872f3f415ffe0c461d2faec735a339303c63e74f57088cb89775dee600eaf9a53e6c9608dc9a8467d8bb5b4eebd69c2ed440927c45337184dbc906963f627a13f13185898faf4443dd558ba30fdcdc4a6144333206c945d7db4d5d1460596c31b2c00e435d6326e95e239394fd8e9bf411cdadcf6f9899195b0898ae37cc25720ad74042788885fd66da309c6b13a0d73bc0678f0afc6b0a71fd7414e880da125f5158d23fb53567db4a42141a121e7b2326c50d3ab3ba34bcd2032ebd41237c056575d26c85c426a8ffb575054ea3173f1c6833fe8582a10a269bbaca3d082ca1a52e5553c871f0f82522deb356c416e88538dad8e1b4b912c176413573507db238d1a725533db557c2285d9304e2b7d19ff4c4d24fdb48cbd9b6f19d9194ce5c3424431c0fdd583ab25305ae6cf6b25811edf0f01f7224df67873b293930dade3e3672055224dd0f9ed455cfdaf041268c8f49a7beb51de0aff27365b215a241d71f41174257eeaafa0a68beab5a9ddab171a9db0721ac17aaa90242b6943c394feda96730f8f85312d12c27a7a88e8049486f162b3ce5b02111db0fe360ca416d27796f25d9d2e78ed1e5ebbc0a20b4083120865fe96daf9125256bcc530a291541fe87c72eab57e15c9643d2a61e4db5cebaca8f52f9a85a0c78a40ecafd1526a927f18039af82075cf1bc0bba98f7a00402c1b803f4c574f6d40db76cee91506d0da21402298b2bef6187aee3b85f7e153386580b82914a4b3c69cecdbf1a108c70174d933c9db0f54bdf8f546b514fafbf0512de6d20d780a002bda80a5726055bf8a28603219d862fd92910297e4ed0227a3437e42ae3f78e8e6e22345dcd87ea404d0e29f6818bc82dd1da4109e030465210fca758bf462a474af16fab51128c5cdd66808b9e038eed7cc7ef9956a00bb082b1c4685bd314aa0ba2492cbd7d10bea7099d18d1d6a377bbf1ea4db13656f600611c12a84cbbed41d571aeb9934036ed40536fcf813125b2ebd953e25bbd2a45cb7a24ee5f6622e8ab37465619bd178175df9b7c95ac64367378c3cd0140069f1a771f53c1aee04e1f055038c566b91b95c7ca22655c860f06904f68b7e18261c129e2dc1066f3675361e66e7d2ab46b72a4c2a377378da04199aff21e80ab70b35db6770582ba46656d2137222a01a683821b72e589c8aa7f49217a74c628dd2017a48bdf83b2f3462487b2606f2f47b1eadd7abaa23616f5adebf77a39d3d323d14938ee88ceaeae23e1b4c9b3e3ce1f472632f5b5f39d76c946a67980a135458b3ccb1c9509dad37b522981d514b41b4c131642b50067fcc118d524317d9e9bb442ce396a86e5b428b6a40b0e6e9e857065be7c103a77ddd2532889c1354383e1f9c160afe5590bf756109964587b7c9f3d92666eb9783551511848096b8d8fd30f17c9642c58cee5c0d6de55c522906e7c45d0939454bb44fbb47348db92fb76d51b2e1d7b32abbbea0d179d49ee3913f8165dd8456d2ba61a5000ca6596b3b9f3723523e0a7d82bfd26912cdcd8870dafa7bdf5b480290a8a735d157012a965415686d529745418d21602241402b778291d72f7fc183896d77ee248d3fb8b61648c9c9a8e19492e106ae93b0cfc4306970a53bdf9059f151b3001eea9ef41e1eb894adaaf54a13bc734fa0e6f6112685be9f080717db0122d99faa1fe97e05fc1c57e6cc110280d9ab0dbd8ca86243f9fbcd6dc56ad9e77625902dcbfd7b5a172cda669cae253cbb95c3c97c18ec3584f70c4491f6d34a2c55bca6d25d7c99801f94e7661c0a03320031466d9e9adba4e1981b7261dd844d109016712db57388c1d35d1b999928634f84d5ca611cac5e53d2e2039b2d2c38a0d3ca438a9502964a21ed1ea5ed8c044b3e022a4aa02858f29d365559f77471675ef0755b25c5bf04c2f9f3b1f39d920e1b498a3f92020833c2755565baf15e96b2b266a118d40b39653c63033d31ba1db30d33b5f2e9237b2156a46bbb2c74619f06619a53ea93bd56ff1fe58669fe7511c7a990ecc1a5ed2bc9e6d45f87e5196d40abc44772e37ff7f101988e8a9ebb9ad25949d694f124c02153cc6970290d864c9fc72aeff8e522298c4cd489ce25e2789c1921c1422806bb805c617c8981f9af5fe0e4e9b95e6e60fa69beb19c5fca08a0bea187eed957d3893e77b59a91fc97d7290f6c23b4e17520f9430e3a898c7259cf76caa23d06ccf16d36e0c7900dcf3f1c0c6916d425e20f7bba9b45a1d09dd87e58bb85a621ba8d74406a767ab59f97334fb7bcfe113e966f57ea87b90f6ee7bf4ab3660f2436c764f87e32bd6a4a5f978fc6e9ca350260a4c1d4d1dcbcc7c059ff8de670c2a5faf08f5cea1d9ad4f931ad45fceaab8ca38719bf8ae152e302a7e03c453bb3338d02c226c1776fbe8e696def33cc9a8c9000c6b680a5d20055aeb5f01948480f2206be62f668247ddf0c7424ca4916f324aeea057e551b0629edc70cbb75059d714fa3f5d707c4602e27bae0361062da7c6e503e62ff3c30b0d6ea39534d6c23d2f89dc49d6488392305f499865b2e861f20775641888c38bac092a1338f422c4e159c1e1473ff24bd214cd639a5fbf5823bbf3537745755101814a4cde63c0db6511d4390fce353cfa12700aeef529f39da47d3d78b77d7ffc08871e5061d166580596586a33022568e0a95cf7736f611b39b315357615d4a3f6f86211409cb0cc64ffb35760123cffa28be2fd724596afd020fd0606d159ef9d5720fefe5273afe00cc8b7ed5865a5d488980d67ef2092d5bf331f2fe24071b68d51254e57c1881dbef8b4bcddfb4553081196965fffc1b05b39562a191b41e6ad1551f9afb575c21efbe8616e516d9092005a6084a09459996d80416e9ceed1877dec58fb910045aa73407dda5e58104366d3712aa903d766c352b84e78676f30cbfd99547d47ca08c2c8728e5f2ae3df8a8312186375af03aa99dba2af73c21f87ad675dd8798a7c997a65a3ae958d01b217cc4b98bb08a3abbcb77237092036d9bc43092367d4d0aaa905cc39e28e11a72a5045123d211ca54d98e669240dff4883fa2de45daf38c752977fa811c1b55609c8309b3550a367079c1f6fc8ed12bbe2dc4c9553470a59d54d323420762f84022764669e2bc16e67d0bfbf723c270ade8cbae829256ae252aae31387d096eeb18989067ff40ecf6d9be0342960df95780ef81a84951b907fcdbd61bb4d88492c590411462e5e1639a5fa251c03212ab94e4778ebcd48ad5df206b2fb4fc4033833b9034bd6ead0673578d551691020256fac43fb95aa6ae497134ca08e7d3518057f3261387cbddbc1bbffe402c25564a7f2af46154124ac783318364a6f22f293e3a82528bf3c284babc3d064f142758ea9d291de32f62ce0008ade2de0a150a61c86b011430a144588b7ddee8ac29f9fc767a89615593c7cef9a3e02db71efb96210ffc816057bdfab5fd9edfed807ffb3cd84a99ed564ecd5acbf159a7662b9e83f401c9489b65f88d28c97b3be308c3119a80eb23877cf281eb11a6be5e765cefa15ac4bcc8dacf47d8e483877609393d19f95c9a51932adea06a1ae4cb3c0ca4867dcd8dc487acf0cc0296852ec641da9d7c90adc81ef02981c82e33da89718949f34877cbe0787bd80b8a88a08b0d6c8e100a911a79aabc524e257890db7cb927f4305ab2683ec9d378019880afa570ae15f6a52e8e170567c9a91092fbc294a7bf71f5278c5f99b46b78713fcf3b9810f421acdb2b014059e9cc5627e96660bb8ceb2dd172f412e4f6c614bbded915c71ce29d7d6eea3da7cd166caf4ce413a5f66002edf6b1d496bde3823c26117940b9bf5f4949d6ec4df19310a57bc43a6ca03b020a28f1bebdeb251d164edd02169a57247af1122ca37431883469aa901e50aee0b69745fa977c45a9477c1f45acba96be8bf42a68e4a48ac6ea275dc87d5647e2e4bb616ba6f4586aa3a8fb3deaa7b8f082cc90e104a1611654166541f14826d253082135ead870a659606b596b8adf85934b0b079d1e7a348209359f8d168b15d0ef918bb3dafe822f91a9131008bf9bc199f3a422af1388d5291f23219001a3f3d5c5e109fc8d4ad62a06c63db3ec3d1f1c59bd61ca52b8e4f8c4840570a2e9e26665b3d8541ce32b34a5b12d9c425857fa1bec75d78721537a4ef452ddc253b79c087a28c5bf338978dc89be8f76cd64a252ef0e7d46944b1d89efa1889ca5c81d67d660f50610fbe71ad304d29f313fdfd898071a4e0562cc3b3a65c72a4341a59bfd92fe192d481032e53482eff4d94565562c8f75638a1ba60594a8156699ae300377c18afbfb4f302ea6b3963704a0410b565f7c971d249255883432743e5001523f663eed6660591eaf966200fc61e1b87911d4c7522d50ec5ec51c15578cf50f497b113e1da18444d50dc7e723f0363c352ed6ca3406f959e0f064827e72f9c80f923804a3555826927e11609a0eb522669404843073b098ae0603a2041c38a2f4214289217cef2c63ae05beaa00c4b77f7620750c01f1003331775706336f448ad32d03974ea0ed155c22e2c0b50284ac48930d58be043c9628b8faf8661d782ea9437cf7dc50820019faa5d8c33e845ac65b064d007cdf0aef93ccf25126d3827b7c60497cbfaccd4530e981976044008879c184324b2281f396bea0b15df5aef0a80ab4a74398e3110515c98a8de0caba4a43eb33607c9a1bd0776134292c039741b8e986de6cb8a66aac1ae7bb9472fd97d61c6d8b84070b1ff7096d4fdc52e66d17ea857ec064a1b77821eaba5c7cf25dfe8dd9188c7a70f327a4386953898c50515c5e07b0c8d6e20e0c40e749b414ca0dc4d78f302122a0d60d41c0d7fca4c5f851b06e55b183f78e629b3fd93c1677a707fec77251ee896bc52d6e13432c95e54ac7eedab5a6d4f4bf009343e6a283a80128dc03b60d32c47e69ffbe15c3cf1539a46079ebd954b9b07ca34564f3051b25957b3fd9c146a43835ec85a59bdbece417978db00e2d86ecd767eb9db491a3f74740fa159f871790ca84094bfe32f747885cd831b693d2e63e75e963254a313fd01e86d5d29436397bf7d69a7825a8084a5d17d7fa6f130b642e0e61f86b346e15fcbdc868f4409d046959b16662eb78ad806784ba3bd0f467acc909bef00a7acd467eadebe651ced6543c8d98538731381fd0a23cf0ee97170830e471309294933439d001954d21c72ce443210703b0805e073ab3bba107a02a78b87e77fc3c2384222163c35a4c46582b2448b3c808c48c862f1a2b4ccec42968704a2a951d320da2c846537b0fa1b5d854da779109d7dff4dc555ae775322a750112438bc976a3628945153369e17c1264478f227c0020a773c6437c7999e6764911aa5d8527567ff4cbdf0143e23842f5ad3c06050cd6c4de29450a9f2e0c9d248992872fcc9ed18dff47fc32527d0b6fe889e000d54e71ce5cee2188dbf37fc98f2e3d34873d09982e4011564bac12adb29f0e5790b47d2812800808aeb89821365525dcbf8bab4ff7737a89f634a93bc80acda41e358e611a024f02399520cdcd11d4486c0908e134c2f3c7c18f93a5bda9d6c5e54118598f93131d9bf4631b0cc424b11f043741ed6204a8c51808115b9e4b4dee2d50a31608f1414c3fc4de83a5c7f1687cea2eba3b92782603bfa73a54bc78fdcc752537c60b0f5f1fbfb4e05140588636e9918dad3f48d75ce931a02f39d4fe0b39a7d0eaa3e224ef825cb7d94d25380e1fb87fc36c760f3f6e6b62e2d52d4d1682f8e6684f49df629902262fd646ba2a011e70d14f3ac26fd3767c10709ee101153500b44e422a69cf21b5381c6f4b15f724317092d9fd7af23e6e97258ee7220020fde3f01c465d26bd888663966848540372608437fcb966a8d309a7d75858d131e72f173b6b85f1a27c80a88328a1577b68d201f1a77bd0dc113b061d544978f06dfb4fe840c2d8981148d625c85dd069744b55b65908bc32a4211568bbb20af3525d106d0ac97a0ec3f7f27349087e89dc5ed7d33f3bbfb5711904b085b6cb3e3346e0c901a641874a6de568564285939a19e317c7b4aef66b744d7ab0163911b1e911d7bd2f5ccefd9fb12a298240ef6a837f32714e3709c6e08ca9216c981c9b1a582984dcf0059310c09c55cda92ef77a329a8e86fcf0f744767a6c4616726bab748c5a6fc32f1a05e45a1d84bcd20c2f0275849aa97ad4d3f0451d0ce73a04a45016f760d36643afb9eba6d021ecb6e53b912cbef11d1f590bac099b3e98e8fecf332bc009c7ce15185796d3d2f8acdcbff84a3b11cc89eec9296df8fed6a231a8f41651a673f14540c1190baf6382354de66ea56ab686d7361281573ff327442f7a085429844b800364a662ebf996a6a3b21769b9cfcbaf41806d7cadc138b57b44a2abdc60a731d9c54a6c8323fcf279c2fa13c5c8e8b97896cf3c54be90ed130ec753757511ae6917b772dafe94f521461d63cedba8242e1105f28a261632a30db863d7e29e7835f3b71168cc8405ae199b538d9e3a5d89d16fcb1a87dada4f29fbb52b717efa0930a636924b530aa4958d20941a66ef0564d55ac8f667807bee96e083e2d6bdeff0d73807fb2e08a6df6154fdc05ebf09dd2603a9a387f5d6f0d146676f5274409f10e064f8d88f54a6cfffe2e69b994d5d69757d57c921983d16a7d0806cbef21ebad0b1f139466ad8b0c0cb8a54e53c3080c616b026149cf39c3acc29e759d0fd6b54dd428ccd182614944a9b71adcdfbd3e8a95944f79b1337050feed6ce72dcd4fc6b36bac51a05083d62406d0d4e83041632a9e84d3d0ac4ff393059f7224bf0ad5a4cfcffba0ae9660ae3f350354522aa3394da4ce1383faa6723b8063c93262a593a590d76d00f38c149e69925b9ce9ab15c3b5e88f94a3980050ba82eea1d90ff8530787e72564125ad5d6c9a2347d4d1b1bf6fb712fb96bcf2c20116c762b69449118546829be48b8d980e1e04712d4c90136832f2fc03bb9ace910446bde292d37e0ba2e228b80ab527406c460004db2e108a23374d737147b1cbc22532b8cac84b1bfa9a55ad8cf29fb11e04b18f9834763279aacc000b88650c893678a5d1f4ffd844f7ae79e04a33a1db7b89e7a4cded60883703d4c430ba44c7990f59b5e0e1537afb6caadc2d649b18b19c4b236314192e3ab8c5c62f007341ce35a86d809756859fa14afa6184296f65a4c262b14b9bfef9795860986eee85d52d25ce6ad99cd48be425b91d3b6a18236b5a6b327532a26d2c2d8387a338169fb882cf145b7e8434bcb7d829f22f5e954caa9e86a1d7bf1240feced94f80e00eef078feb402f008ff05ccb20eb1a74bd61089d92b519064ff5c2176cf5be544a2bfa705ba62bafda1c7b1551cb4460bf0cc233e2570b2068cad2dbcf92b112521ee8eec2d9703da3b49fc33fab217ffbe97573271b867b7e6649fcfeab4d359ac0e8b3d37b2eb1bdf4fc38e5a8e7734bc6e282b34fd6d292528a9d92740468988f9a2be8e47a838d538a0cb08b914e8dacb50c9e996e91cd9e63aa1a8df0533a60289ac23c577340e6bb490676a1f1c23fc8ca6f918049f05425f7d0d240f1562f8e05ab891bff85ce6fe67b7f265e1903d2e44d3c9a030cf1b61d62ac6cb6ea29283319b65cd3d1ed99ee9b00fa0bcef7f83076494857a1aabb73d8c8dab2bc97452e2a10a1d158fec1bd1babf8a836dbc0924759b67a1168ddea7ad06b73e05390e8c92b79703e6def143f28365b62e3c1e0416281da2b8f3c9b3adcc2398b0a7a4a75d9617a8fa5a27a5e9123056b1adf2fee36342c98329970c01b0e9271b4012653d4355ee0552f0809c288fc352b8b71bb2b2adfb224fe3c3fee3f6c9c236781fa8f452c1a3da1aa50fd8072aec2af1fc479ead2505224c0e7cdb00cf9712e282d964a6202fb6732c77bc425620b1a36a5f60bdcab24b99a5a453c5882783a1fd8aeaab85865842dd03ee87b3b4b7713b105ea4618ac3563234e2c2d2a249f7bc63e75ab93663b324ebca3775ce4bd3c11e40754d45fa24be8fecf73240d0208a446324c7f5e86c2a00a735a9c8e21dacfa4acc9673f33bdab6cd97cae66492989a4cd1f0a2431e58098515a1068a1bb703539672337e9b7b25ec0747737630c6e2b259967efd4b77d44d2a92621a25865b3900657cab83bd399557bbe6711c0fb0acadeb930f7a42feefb9e21efded7a2329fb1a00fb0288e463824882efc21cbcf93f671aa687e990f23191ce25f9a4d0d5f7eee8292bcd4fc031a1b9cbb0774cd2b8a792bb8d81fb55485873b875183e5f91ebfe9f1de1d8da605fa615e3b372b6d5dda3e70451c252c39d4605fed1b0f3bcd993005a2c398c6d0efb2ffb421cc4424563dfb530c7aef1292627ee24226c6bdfd1ace879a94f379bce15e2bc50071bda35c0beed005b269478aa892aa8f605c5556668fa685f7212ba0523881d261005b245b6301cbb132a45b636bc5c8d50876738073908aef2e92dbe881853e0b9785630679571d900bce84b8fb6459efe8c6d6227a2f5be9b8a0e274e6a57b143f3e52a8a3a1b36916575a00c0a35e238e3ff4bedd51fc1a80c7fb01e11d04d4898ca07fa9d641695cbfc0b7bb94595b05fe9fec182ab259ed771f4027a3a892bef38142c92eff302e5b4a3ac9c1a95d339ccc253766ebb29b6595d32d1190e23cebc5338cf91b4f4dd9c92bcc677d392690519712713cac72f3df2161f4e22e4c153ec8dee26b4918bf30b507460a93cc3d6cad0c40eadf6808ba37e80d93e31904f568edde2130984a123d19d58b59f02915942a54364e8540560fa6d9aa95025d3adcad447d05a09b665f02d8c2e319ed1f66f8b2e2b11392574e8d83405cff9a54b74fd2da9ed6e0497a530078d8d7832c59e37c813f6f4da8da2cabe89ed55647de9f912af9cad9100f4f1321cb856191e57051196aa9b54c0061c834be101a4d700ec16528155c16388913860ded7c62500b6098be0589ae1ceae8de53123dae708cbd9c8a88e96472e009737a1ec6464fcc28fe1983d8abc58f5fdd9353065bdc79ff750beee71b2cd45fdd3251b223a95403726ce4635c5fd20764ebee9e2b7e725afa457513bddae2d8468a907ebe1cddf204c831422bcb07c36d046cc0512e1861adfe67af02477513763bc8bb4de4f2ae3e04a201c9af37c4b8bed3e8200297795510a0f166b4bf301b8020615120a8ea242ee1da6ab60bc6373cb32da51fb3ce051013a7e20c519cf821b7d1c36ca1a0f9854d52f799b0454b5da006bf3b83c0853995887f6443a7e545b4c29495ee0ba8bb50f403ca75b35f61bfc0948c9e033afba4edbeb576322d49035e4cb60d113b40370cc87a35328e1f26f8dc18cd70cfbbe0abf6a81f1b0ec1760e683c2bdfcfa11bd40c2eca814f4b4195819a985203b41fbc98377f1a11fe498e21485ef200af052d2d8b7c40c87c8784e0799bbbdeab5de79328f8803f8d942a24e83e190ea1a0912fc950220ec17daf0d5928d2e8e2de07f2e076f778b1ff6a955f2d1602aa5cc1dfd30c3b70d0a7f74d2826c6792a6e211535bf946a4f50c684ffa188600acf10f00886014d881610f3c6b3df2c8a5a265dd2c45a7ff7482790ad62542af58fb8b339b82fdc171b28269acb4108e886842f7121ae47cc9fc472f4536506478e182201dc3e246496513c05920a3cdf6a8c3b47d794420671e592b93cc258b73e9a5d6901607523af77118d2b7e2294e2d6ab989cc80754359177bff28ea4341483e3b57779c4b80f5a041ff07ce5fcd9bb9a2ae1b624f6aa544e11c5c55f7dd8aaf1321fd9aa92e7640038545b24f0240d7257de4f2f4b45a08cb26eac54fbe52e2a0267256c1be98f6e7a6eaa3eaa5794d21e19b3c6341bab8871dcbaa5ad1b32916f152f7d5baea0c0a9feb50745a268ddd70a3c1f73e4bd7ff1362d55147c2a3926f92a4815db9c9eb1610fd357702d3e74cfa28889a6f3f38caa7962f5670a3fecaf725d0048036cc1b83b6f84aaaf44d5e9cf6ca300d393b03c517c4c08aef9924e26e7d02e9386fcef14c4ae018c91982f1944a7e5127acb6681bf4401d975fc666314642efbb7793b047d45b3dace5cbae92cf46b1e97428653ec23c06f208f1a4ef13cf8aab69e3bbd257e4e27dba671f5e128a4b47c1e876d192209c353f721ce48a55374b98a697036105457ce1e8ff732d5d74b10d1e68235647a86ad785262ecbeac5342b20025229dc4e2735552f37da064f36a573e0913993afbb98938dd4c7473cf71b0384a630c3d4ec85d486b69525095815f4797375f97a045fdefb535c683e5ad08cfe3c47a0b75792b35b6ad427f71e0106e2229a3d83aa9f22ae155bd75f84151f5e24a0c2352dab48a3d577cf0bdeda6d7cb8712e48a1d3e25b677ea3742f15953e39ab5621f869ea1896f6536c472d79b2369e70f98ceff2065cec129d1b389417b2deb536bfb04dcd088d04189d9765182e11e4354930af9a80361d397c6cf92f6d7427f2bff27f8ba94accfaa5e84384e45954d02ddec3a6504ef07a1c45f4268660d2645b258d2734d885acde6e204a8412f7d7fe25a0c3ae57bcaa747e6c8aa9225a71fecde5da8cb98ae17192df28ae7a6db30ba2bb1fa92bc051a1995e8d1c3d98c474af51a6ef010fc9ec1956400d1b6908a5c5dcd5c408d9b3e20807497ca37247f17e1cfdcb7d8e44556b32a898eb0d2782bfbb90d68e41147ba2170536329f531930daaecd543012cc48752177aaec84110dad6809c969a0ab6968e323e658b64538ff43c5af121e4f66399092acf200a25d932ff59a43dcd2da420c5ee72d4f52ec56e1904afdd7a87efe2431635a7ebd7d81ec5cb836eff8d4b22634ebf11d1438f91bee07fb1c30031d8da24c10b1f6b66d48c638d48e67af9887f7e59985698c2c1bfe48ef0281115a153d84c6e21bcff24231662374f7202c00ac6bff57307432222bcde5d86c73597deb83cdfd73bf2f3961308d2f4eb625b46d16b88ab83264a2861f3291a4929636885286d79bf9f45395462169ff6bd53e898f54509b38cf24570c6dd89601a5028cbe528a85639bf8ff0a53995cdbf18bb8fb9d9c9abf96699cdb4e7b067f82b8e34fbb7f095c98ffca8afd10c29b1b217a6d91e8417c1f5fba6725bbe3895db33948763429a69526454262779520cf05ffd78a07fa8a8997174a8d7b2fc34d6b39c6cafed1a6032546b2f1de727b0385932851a133acbf694ec0fc4ec9565958f480b698c81431924924c8075e56a52d00327c80ec2e2193cabcc2810b7bbf0b46e5bf39b1ddf653195a5aefa3ee4081a218e582349bec13c5b46ad910a7d036f0d2c608d9ac8feab9b1ce781818404bfba61f81394d4367bc8bc61157d70ec7d878e63982905418ab0692e4c5f7b3ab76fd588231ed030e1003665fce7c9c2440c421d28381098730341048d10df3dabf079eaa304eace1e3fe012408a8f29a844371f2546350d8787b435ccd2d014aca1c78bc6cbad243829972abe2acdcea7b9a88b50a90f0c9204ca3a3f9b54305e15251d2f4e10ee00105140cae798342b731c20e6cc34bb3318e4204cdc37d1219c52bc53e32e6bf45c1d6ef7bbe8e72ef9c5aedf5f175380a7e0a7b76ee2daf2633ffb1fb5d61a2184904df6de7b932de50e8b09f50879093a76447829c34abad4df71a1b6bdfbee7c3ce553cb49a485c4d6ac23a5dd58e7d27295dfa695d2c26b52db287b55a0c24b4ba11dd5d3c70a1cc147820fcf43e0a5edcdf3f8a95d5611f2d05a92c2c753e9b1d4e381b492f4159e02b9b582f156cddd0ade4a83cd3945c05f9af5a7813e699f4b2d3ed3a8c33c092df3e47aa6b33aad33061fe11a186637994da6042b5ad57ec587a7dae4c7f311ae41a789aad475d94d66b2b48d89dcf86815c12f55871612d5e5f391119c3a0fe91647e95ca93918ef7602eebeb614c00ba73b8fa8575a3ec233e28e9eb1dae384946766867c0821bcbbce92df380d65b80bb84e8b340839c2853cf2e31ae03a2dd2904492a4ddaa77fd94ff68521ef41ed2a4bc89963d1569b187b4ec65d8652d8d8692acb29b0cfcd46828c9aa8ddb0c15a9cd4458c729d650e41ee03a2dd600c59d9556dae2df774cd354a7572c4a7e529cbeea58ad187dadf49556a230abd66318f68a5ea66f6573bc5bbfe396aa53f7fcd6b7ec2c036f33e8cc269c52b1d38b321057a71bcbb4c7caf4ad761bc1cccdac4cdfead22c3be9938267503b49bb89b2963ca8b53a6b8297e9da5bdb6dd2b6acab8defecc79cc8f7d24a3974dc7877658e77a5fc7437b66f46c7d5c48dd79f0faeb1a9e05171b7fee38a7dd837c5ddfa327d9fcdf16e05dee1906dd3759795e9cb402e7cce909c1ed7c791325c2347a8b8f559d7d5707349d769a1869a4bc475b6aa26b95f5a084228d3577e93e9cb3a7c63bfbec9f46415518a76abe227c8ca742389ff1c141fd2b2a712edc4ac4cdfea17fc68eea97832bb595606deca6e3355738d845a276d899f145c637ad73bd98dff7ae2a0be67a18c7d302f2d3ce941b6bdbcbc88ee494d569a0e8fa8eec6777b52f00c2992e12c2cc2dde9687821bd6071fb431851069a961868a8b91de35e2e5b4f0a9e01df96b48e67c4ce69125b13908267f061ded4076ea82dc136431863a4674ae5bb80e82b5031c59cbe7022909997dff42d93d12a2290c9ee00dc0cd856c6ab38d3fa2e0878ed0f190c048ce816f8800b8580b77e93b9eb2e743193e670e640518afde1e6707f78404c11ea6762a445448e4a55ee0cf9012f2f0a50c0010e308001c48861125304f8aa995c3145a0947efa1543692da0ee021953044ae9d4640ca515614a51b9d6cfdc3a2b40a51501b7e4e670b2a29fa1b9d2222287b3b9d4258199cbf67240f44dec6572e9756bfdd3b6573f5dde1a44ad94b224105d19d17d175e5a674d60fa344331c4c1b932af00557eb25d4d32c249dba619c82a98a6699ace9adc80fbc31f62f8128a6086c69a8991f605326603ee0f31fc1c55f0f1509d132287fb0333f363d4f813ac9ad42298a1b9cc7f98b9932581bc3cf19df5f6304d30e7348114dce95369c9b315cfa14e878756470d2d24c12666fa4c8c8c26b1bb5bd6701241f79ecbf4cce384702217c4cb229b9ac47d4575ce654ed932f574df6ff52ad05da7e6e9f5e445b7b0186eaebb035527a33a2250b00ffec13554d00f3815fa1938157a47b121bb56e85486acef3c2fa106d9a5e71f4e08be94b570e9c656b8945a0c844b7dcc39abae4d75cb38c508e1d48c641068157a4a9b5ec80f1f4da2d7c09079c005419dceb52e4ccfd1b44960bfee62fa7152f641698f26d14fed0c593cd38be890517aec331f41cb8e20fc657514015a0d5cc7ac8ecbea704f65ce79aa59f3d59a16a5d6034d7a344ec79a34dd12a71dd1cb534a27ba750ffa48e50fe7b4b07bdcd114fb08d5c9d8200edf11f56a1e47e34c6a524da2f4f5d9da55280d1910da40b67fcb6cd3d849e99be6d1679405f254e8619a690cfd43424fb18bf89029b9747b492e3d1cf2bc30d22dd4693dbd4e4d4e29f54c5804de5c3ae9bbb9f4959a4f85fe69d953a1879ae8a9d09b6893ce3a7f69f31f8fe65e367f63de8b59866c13510ca3306ad679012fe478417331152cb954dd668a1c7ba5300c135d27041704355f313bb56da6c8a5aa3bab88eb54a5aeb345c465ad4d245ae9167a4ba3a7d194de3d7af7281de2d2b7109c10f323ea1555a94af5e9b3e7f24e2f7a2ef0f47f2ef1f44e06b5258863d5dc210f4a2ec24316830484281a31b5a007d388424c13f2a185ea64e4dc290bb91eefd655ef66f77d7242c0fb4ec47bef04702e0e36e03e06dc17c47dcfe43e00dc67d94d64a4b216c6bdf36f9959f408e77c56e0684632f89c17979f2bc3e5e7905cbf1e5f9048111ed2e35ed60ed1c2903dcb86121d7041bc1787bcf7624e6deb89ba392e989979729fd84ddccccc3c396747fdda3dd78e63cd9d5cbb5caf2ebbb3a364a2995a109a967d4b4269c85ae7e160d527cc364e9c7a629ce959b4dbeca94367c85c8c8b111dc62b08974018df45f4e36b8c81a3edb586302699a6254d4c44da857d94c18b57d32d930a215674a4792e289f40d773c13e659f4ea6e863127dbe9160684ca0d893394db2ccc2e920ede3d1324ccbd8c7ebee49e9e3b6acb6a69ad8497ac7b6ce4e770f19dff10238d954dd69c954d9b7d397b6a72aa38c30d65c33b3331dc08b9664d32184104238279c304208219c7114a58c324231c421977a9d46a0915330890b823adc91a7e4cea55eaca9e91ecf051a792ad4df42ec64390423b46f48b432a091e7f26c0bb13513031d136d87ce90bd9f5f0cf509c873a999a7ac8881c5a50e874cf7e1034845f5782a14f55aeb057074700c768e611733a9ed15b9d4331f59e50ae31ecf856b322ac9dd5e1697fa16e3526f0875f7843c15eaa3e995ad4ebde7ac5665555cc08943aa1d911db2fe4549447ee4f832ed443b32329ae071340e9c5ef7112adfc9d82e0136c943f63ee7cbdee31ed5c99833cb442492dd92b8eeeebe1cf05b13d79500c68ddf5c892fa59452da1cf1d0be491619b2bbdd5996adb339e0379e9fe0f9f33a37d9e688b68a79685d57ce4d2a6a0c1940844e15709de8ba3bcb9672d46f73babb140bde75ccc4bc4f1a0ade567dfe5944c8cbbff7ce6326e6591ef1d2da1cf5f3b4d2dcad135a27de794c3c9dc77be76179ccc41db0a110133f644c34f15c98a0a1a1a18979114e27b92625e14cfa906dcee630ce750faa33f143b6b91dd73aba855d66bfbfc88405f8466bd287ccc5af34c93d3a19d3734316930bd1104e854f9dc91eb2cdd9189102c3f770ced7a811b1125ff39f4d7d1238566eb4a51c2578b78a79772716c8eb9889919f1a0a24b449b0c0051c439d92f23c6662a4e5414f599bc31d6aeeba24aa90a7d23a213fe57c2a6e9e873c0fcbc3b91dd30cec6906dcb35b9a5b022679c8a66f434c5f70823a0f4a5178eaee53c678ea4eccf39053ca3f1727ea79cc57ea939eb24e886278501e4578a74e9d1664a8b9eea4151ad75d67053920e16e435cf739499fece49e6bd2fbbddbb19c991a3a4146172f8b5b6badd5a2281af593e607e3ffcb06e09515c02d0c158089dd4401b01f0b00eb9e8ac766189db46bd7ae15acb0768b6aadd5568b1ebe52971b393639363936d5fa5551d70d9753b1b0bc1f2c34301ae5480d75cb54bd4a2dbb5375486aad20842548d1ee18a7b690d8fa130d2bfebaec46e34ea7d1f2cacaca8a5cc12c16cac2ac4c7737cbb402a5bc68c83f4b5978c67c979597646141b2524f69b362e9ee66e996eea9592696ee696261a1c162b195841f4e55732be6ee943912102b9f78c6f4e97d0a22247ab5a294ba8bd2aa02d1ead4c5c235e8998256f56a2e33d50d1942082194333a569e15a5ab57b8465f3e2a5e0d0bd790f45bf56a6efc3b535b5919aa31335fd75ba33159d0b2406dc3a151978f26a14f771faef07b7cb565e1191264a93de1834ea8ddd8e2d6361ad5b23c9c5b2baaaa2aeab22c2bcfd2eaa726312d7b1af5e0a4b3e724bd748ba7b2ac58c896524ae9a5692c5ca3521c1a0e8d998f43a301594633099128cb58b06fd395daadbee1d0ee75eb553b66a75544f5d2559d890987c6c2352a16295fcda558409c5285ac8644f594361dd36af66aa5babb4bcf61dd1485d123161234ce4718db96a8bfc768ab943951e6449913658d3ddd58cf3955c6c6be31927a49cd292fd337cef909e7fc46cd39678cf36c23f5b6a32cc6c738e3678c51d6cc2a227bb4a5f83e96d58f8da00fe89ad70a8e6a8abf2a05e37d9abb549c2ea5c5f864acaf4eb5eb53939f346a8a320b75cbe4b9982d8651ec5b758f700de9b196aae766ca96e267e5395f238561169bf198465f2fe1bcccaaf5ebba6c7579dd3a52bd562ad218638c54468871c80f92758a846e57d2d2ba3e4a2995e9a795b049e97ba04b3ab1293d10fb7cda0f175981507ea319258910c9a244dd234261212917a136acc88d9752f2b425b8527d2845dbce0a60f26c41d28eb0538f171149e9067aa4de4da9ea7c85c9b7950bb2156832993604a2eac330cdddf71e469908fc68d63d1a251bc61378720506af8c5eb172e14bb5ad5c4a29ccf215977abc62e5621486612b37567cc5153ca3c8159f06d9fc6024cea2cfce9a7557df9cf3692549cdf9de8cefdd94e731921bef1a47d5f3ea9ed11161dc79cc3d5807c6c94868b41b23b91047157b8a71be15aaa3cc8bc798df8fe71e71ce0dd25b9667de5aa93a1ef4899e950944d98f87d2fe71eb93ef69dddcc33ad43ad3e8439ac9611e47abedf989ca62769b17cbdb52dffae4272c8eeace3ead4c7b3a97d0273ff1e8e1ff04d79887559502c5a58fd6ca86a3baf3950a14179e9fe02778063cbd9b2c222823b9b1bbbb9b9f704ea5415ed47e40b8755ce6f279153f6ba55af5eaacc167d7ab95ce39674b47cd4967654a62d562947e7b8fdf7bd396e8e51f333b66c7dc4a4ab33bc64e7237c8dd3af190b6e74d6f9a3d379eb302d2f617fde8a7cdae6e9e33b38aa87f9885446631bb351fe33a59cc6e1311f101b9954af9de7befc9091ff7ab43ed7d4e69f110be5bfabaaff4ade273d17359992bcf4e2cbb2d5755256de97d1e5a7093794d6de93d9ecf5c8138cdd9afaab375c49c56e6e153aa533844d36d954de66d0dc5859fd4a51193dda69b792a1211752e8557c62be77465b453934ec2c046ea145267855aa5966559f3b22c4ad9baae43eb0cfa654153c8e51a78e3704056dddabebbbbbb9b7ebea76a62a25b9e8c333afa6eeaf3247237cf77dc86efd04dd38ae6e79942e014d28e7294f51ebfc7eff17bfc1ebfc7efb1c5a798628a233333b3075a5df3de0512cd996522d14f72d3c6d6ac7704d7e8b365091172e555ea7ba07cd7bc3f51762be75c1ecdf6b242bac86e22510d8c5ff6358f40d5428206008f26867d34a314bb89ee0d18769ba2074fec76131bb2b05f1ef72fcac8ad1446dadd3d3d0cfb2c0ff3207f7336cfe5a4b81c0bb3a869514a29a59452b6045fa78d4c4c9c764d9b9999395e1a2b3373f3cacacb8b356796894494d23b1a798675782db9754d4ecd9b2e5a727be7e565658544fa45229b1a7ac578ad57913a7422086fe6cc3291e82791acc9a2afec4be419f1f24eca29e4f24b615b040f4f1a89f3c96c2871a35b26750fd5e6a9d4e2c3acf79e2c83f51e175c43deb2ae495e58cfca64175ce3559627f3489c0b99f93db6cf96ac1765195e5bf2467221bd90d68bf4d1923837de4d69a5945276216f2417f23d89433fa7e71df3c82e7806851e2a2f4b4a0fac26cdad966559f559d985e42274bdd2ea5bfbc81b97853b6597142e0b7c4ce329a595d6bb801b0e87830387c3d970f0bb56b4acec42be3e8ae14ed3651738ac57d5d25092c9bccbd6e329ae5bdc8d8a419b2e08cb6e382afb8feca25ad985bca1288973a9eca24172e8864b2abcb9151b028563a577ef9d53cf7f5a7d6b111412bd6b464723e9c3bc2e59eec15ffd0b5eb7b80696754f697d5ef0e6c250bbb08ff7deb39856dfeb7e481a7a51c2bee3c2aef53d245ce39d21172d6d0936f6076fe235e1cd8defeeee8df6d5dfe8db625c7e2a2d9e73378cf3b9b1270fbf7ddc9cd9f4ae5b7fdf3e13b0e0af3f6d93168376649d1fbf02f35c9800d96d9e844cde7b87dc5262c72c24aafbdefc09d9130bb26d652008e5256937b62c24aa176f621f5bd0c776651141e1925b2fcbd2dcbdaecbc2de2bccf368d4533494c3d044cf34ebafdee83757bac5b554a77ee34dd2c248278293c4aacbebba2e6c9bbfbe4d7b7d5155d7b7fa78c77cbd32b3a8522b032fd49933cbaeeb882a0f7f695beb5c6923136f92dbf578fa94cbcac06bbdfad63a5993ae8b50b46915515fb2ecc6d242a2bab555ae4fd1c774fd621f978cef2fb846a56c7fc133e2a9bb14de5c9652cafe62023500d45063bdfb55dd4d0821105d920de19ca0fcfc24c3b76d094aadebb3db34a3e3c94f0f08a6df711ff5b7756f93a16ca94f29d8ef51946b50b24fa98d3c039ee7a7f7fedee127aef13e515611d79fa557e419f3c15fd78476bb7cafb1e3a59abbad3ded96364f69f5308fe12b16ea96e90ece73ad9555bdb37cbc0c12d2469e5155761423d7909ff8f23719bed4e9ab0c4f94ddf84579fa39e37defef4d37421b79c6342bb676706e75e51b0890cb80ebb4c8c9b93936b7eadc8a91ba05bbdb2a4dc675cfe5130f92daa354422a0ff3a44cb756aadf21733c87b4b2a5ea155ea67abdce5bdf7a2bd6b9f0cc966fe5d2062d8d3301a4096ed7a195ff3c5db9efce3585bdedb6322d66335b6a8b9d5af6b273a26c891e7bc4a2b3327dafd3697339aeaad44ed465c1486f455885444d621d76d25c0ecc8370e6e2ea08960d25982eb163b343a90d256c2c6103f3a866d95882f9d948b6a1848d259ecddbb96c6309e78212ddce8d9bcb8930220d455bc2c689c634547d137a31e13c2efa862fb4f1369488dbb38194cd8d87d82314dd0b8675228b6233fb44300eba732e29f7c08f34f75234e754606822cd3914cd0a7dece6965c07e5e3355919081d7fbad1561978a91c78e797e01ad596a8c74b59c953b6c46c97e01953daedd95cf825780684f444e3188e71391386a6a16827f555279a8b715611f2c6a47ab495c4c99cf37f11908f274368517b79efbd373fedb3598287801ab486eaaa63c69899e185e4b2484c2df2138ca45b26f64bc3ecf604126624d331f313dd62c53be62835772d4dfebd62f05570c9a4e4ed7412bed142cb489a04374612cf4822c0976f51f17d6e59b6da9c4b76cbdae2c7ca2c1a4a32ca6e38aa63f4932ca2343f59eaeebab3d8af63f05ab6749d9a0065f9090b09689f885cd578a8c51810c2d09d8f318220744bf1f4f58134cfabb35be8734b93af22c300e89e3f90e6aa568920ed5611743275a94d6d0bddea52543c11dc7f8c849f58b13abbc29c3a538b43f8c89c9375260fe123131fe1217c44c431d6737933097c8475f888cc3c5acde465f62eb3bfc73a7c8412429f01c9fd755a980188b49b8e2b0fb5f8c8333339de9544c8770e6691982c22a2140fe63d8b88eb9876317f72374277e11f64cd4d47d4fbaa3c41111101e1291bd23806f4f164d6eb890fb2d23cbcef482e8cebb458c3cdad5db17504bc59b74c0babd0ab96c6a734ca5611f49174a389365b251e4513b54afc8926d2d88a003d4c8bb4ec28dae7279ae7261ae8ceb2d131a1c3f46348737385c6cb1059bf5d43cdc23c07e3676e9cecadae2d783ee29bc23361159655c73ec7b0eb309d61d9371010184d4e5044175f8472628279387461d7f99e0c7b523c299e1493a7e5116c460708f41110100602496c4405c8032b9383b42dbb333a3010f611100c34b2c204948140d64d4037b138039d848e594f9126d831cc9a3c115e9e5899be26761bc10cc86eecf9c763b70cb33e0a320a320a320a22bb90145a369bd1615d24fa645d348964f33bae1545a2ec5366d15b728a2815616589b42dbb333a325196890ef344d63d5ae9ba1361229147748fe5c13cbf2eca3c22eb338540d84766a27fa6d004fa605384817272d2cacb8591797e896c36a14c2793c9149a40d3679a98dd5ea8cb5f5ae419565529bbc5d339e374c2940b90f0e1f20caed3420d3ad4e62a7b7daa7f3e9f4ff5cfa7faa7b4e3560e7e3e55755dd54c223f339b62ad5ebdcfe792f968db435ac9fa609f4ff5d0e7a1ea0a1da631cbfac7e43af60df4ab7a8acc747d3e17945f36f4ead7517e7255199cbe5d329a5899be21bb8d6086b37b32bb615745f908cfa86c35817aa9dde0a71df5e564a54d77b7a7adf3118fa7c23cd83dec394c57fca9be65af144eef1a7af560a7af0f81348b89d48f87eb2dcb6e15d3f3113ec247f888a7631fde7bef82d2c4e4105af09649e419cfc48462138a4d2836a1d8e430cf84faa595aa4965627299fca2aeea323953186326c7ce33a35ec913c72106f1873d9c31c6159f5cafb71bf35d87401fbe2c1b6334615a85b6b9fdde7befa395765cceb24358c157d91c0539f53ecfaa2aabaaec302fa3fec9ac2ca3fec9fea1b8faf0abe715f594f8f9565596c2aa8fdd463093d9cdb215351f84675074daedd94cc2a036ec6eabab99032dcbb2ce3956b52cceb12ccbb2a6c9aaa6eb569d769379599c1b13c9344cb3a65b293ae3115166b504c37b5d4d3a51e9289da6191dce4d229452eaa615ce393ae77fcad2fe7f68c54e3c16c824bb2cfaf19c602093cca2a28732d18927f33cfbc75e009fd089282546004e3240010820630056d3ec05100000c418a5c010a19c9884401f4f865d96a2368ab2b72506ebbdf8de93efddb27bce49ca7e9772644589f608c89b2494721bbda845f958db6e4cad572debfddad7dbc29e61575b95a5941565184b25d5c9d8e4902b1fe37c71aa26a7e88c804c37cd382335aa99736e9bb555dddab4d3dd2625575e29491a4717e9faf74edb6e2949a6c72f489051107931c403849275a0942d25948f75ec1631ebd5f58fe6c91c13b12a2b33ddf8884c131fe1237c848fbc19aca118aa93e15c7c6e92da96f5ad264739237411c6cb4ff67db20bba6137ecd449e6a4ddac539b8fed198a1180ca6e2f77fb6d945025cf360fe65c7913bbb1911bb21b34c23817e7cad0419f76e301dcde39171937b9732e0438ca9d7329c061dc3917037c74e75c4807c09d7351b900b4ab68cea99034e7540ca039a752008d009a0c6d009a732a34d66af6767b11800d80dd56006063d88d34b229763b8c13bb65d26e32f186401fdbf3a2a124c36ca52c2b13af7ca5a56a29ea4dd196f897d9271b79c6cbd1baea4839c2a9463574e74eafee46b4cd0df5a699eaa9d4e254e465afaa5274aa8f8054232b4a9647a6e88c80700d792aee163aac3c9e438b3d20bb356466666666b615f4bc5b551c5951bd149d1190917cd53b8f82c05797e90ac05752db463537ba2ce6cc3291e834f2a50504692a7a0fad5292409af7f2b2b24222fd2251c35190471fa722293a232055b5c518d55c8ad1ed2585741439650c1b2ab194524a91ddfef8c44a28e508e7d6f7deabec28c808c8950c318ddea35d5bd36c538a4e671195d018d12d0e833459641195641acf4b69a594a320ef103eca51104ea9ee24f940e33215792ad3776e74725e8cace0dce91b691a05c1d145ba089592e4522c95f0744c8329f25c5e5e565648a4ffbd225de4cac72925c98d1f05e11ad528488a0e458d6a2e9552ca51109e11290c16c01ce86f301a2826d7096b17a5924a2aa9a4dba36207a554bee9bb3e293e94e2c6243f7b554aacda9275aa4abb4d333ae4e994a7534e17a573cae953b7eb74bea24c594a299595a5205ba51d51af9f522291234fa594a1cffaeba297b624dfb4d69005514aa90455b55237b75a1425a594525217a6657f9ae89386726872aacd7fb4ea308fe935a5e0cb96e4add75f405c29b8c6f478b2e702efb1f3b624e9abb4e4ab86843feb67c5d54528da89963d15eb269a7b139b8f508a7aebd53ba7fa641151d15bab9452fe52534e33577f70d059d41fb7625d31106fad9ab5a664a1d40a83a2a09cd45b2214eba2fa030546b5aab3a5faaea1ae3e205cfbe4dbfbf17edc780ba556ebd937bde94daf288e5267c16a5d1e26fbfcb81b8c1f0c639232ba07868d012346c5f5c634b2392976cb60882c4bd3b585ee81a45d920042870ff7e528e124348ce4e86c6ec7ed0c41e3c25c8065a016641e22783e63f880a8f02613a010e80f211316989c7caa38f9c4a3bc8080bc6051018145cb20d231ace8101513a572cf855ff88557483b4c8456906d2f1df8cb4530be906d6e679b2d5b63314563d144da8aa6e2c19051c6944f18b2cded4c266c5e919d9d9d1d6793813354d72d20e09a5b724dca0c10226d0c847b308d119c1b9b259d835f6c08c1a02c6c707ffa30a9f74932a4c87381e767c43c827a99b21092f38a02dc8c68ffe04351649b33f2e8f38820c988b647b819efcfbe7c608d2fa09b1797ac5578850ad214fce31a3152396803ca03a47f16869bf1a89d3da2c27d771f9d6c7337324dd818c1373733f4630a79136fe0cd0d0d7838a10d372419cc822ce00c8921babce3bdd7ec5ebcb6995b430b49b08999e11ddcac04fe64c1c60b1b0e831736d188112336e69c73259b73ce25d9e68c349c18e6b9c8bf1bf15ce2d4a47849e106373827cab83b50b58103b5d908597643348d72908958d0e366a11930b89febb4888318ee969dfd40732bd6f39660222db9a19384910a2fe0bcd8438f1d3b9c010b254062e00fee0a10ee26a2e26ea41fdcedc5077773373db89b335273210fe690e40863f0811a7e78010c7007406c01270a353c74e2202466c60a19c4600d72c8c210a2c08798feca737140164cb8828a9c1a306108317d98e7e2b2480213867421061af0200e31fd249e4b0370e690072c6001061e57c4f46f3c9713242982199450410728d82066016668c10ac0608517841c89699a1ab0a1f298020b7d40430de620071b0401ea8006150f78140951c105e6023f5c4970411772a0c8208410562c8021b0e10311f480033a08d98153bc81055317d04007287ee7c590374494ebb61892852147ac232c794ec417fc0b23a0ebb470c313575eb7c50ad0206326c0096e3e8639b8a49e89a20f3588c3139840042531dd5ce4478c3ba02e60430b824c3d842e4c95138e0061f0890f52204245c1092c48a18ae9c4c4872d64b006eaf270dfdb62055fd09b2d64a0c5c5aedb420660b8db23139c1093c7f3aafb1e1a7e6be59efddea3a6a99d13629a64047ed93a17c47b6bbf273778af708a3312018f609a3bc5799eb2ceca591096005238e9a4df22c7c8fc4967e4182b8cd2cd2b34855ae184fc4acfb175ee21a122a5749a788a16ceaef4add14fd3ca95f255ad1ee35df50d58d6bd95a90bd051d43c45e79dfb085ce8357c6fea8f60e6be379d9a93faa43ea94f869714457d4ed4e690f023988980a31cab505db760539fa51342462744844e08f89c10af9d101d3fd996e2dfe361bad497af5193324608a7e93d7e87dd7756e92398b96da72907b67b4208fbd49b7a85da564d337bf6ebdbbbccfede2fbd57e122c699e57869638c18dba955e62d6db38aa8eeb42e68bdad0850b768ada89de27c73be4f32c6279af46467154c4f359e29cd2eb5f2360601949055eeef2eda8f217bef34de9ce83451ca73b6caf44b736fabcf2c3b3569a23e69f212c6e8966a3759750b94d24ef2512b8114627ea377b3275875eca2ce3cb4e009363195b7d0831076626a7b010b3cecc4d477e30220f888a953d59a13030e919c980a6f728cc4d4a8e343484c95556bfc041688a013536790214284c4545ab5c641a6f0e326a65278d0c3196a626abd830c68626af5052700e126a65a794092b3862038e811533124b44127a6665a0cb1424e4cf564810b3631f553b5e6bcb8998226a6829c165f6c01276687b3f9820b45980d40d440c36f48034d4d4c3da95ae32d7440849d988a52b5e69a015b75793603f85554b5e6eca0879d9a980a0346ca1e84a0849a981dcc6f8b2f906c2949dc9ce634cda9e15ffca4c1c7865372dbd81c86c1e54c935d420c48e6bc1b433127cb4f0069244f0a32f01132b4ce9c93aad7ab463dad3e0b4cd32f7b91ea75bd08774bd7e3294b630ed9e888ebf157a5286de6520d87e8f69f83da4ce5ce030d29e504a6cf1731cddca76def0ddfe3cc7d7de13403998d70b4e69c73e64a6d939fe4ccb52c3ca30ff366203318a4e4ee9b514d93e4a8a649324e31c2a74c2949ea08488ace2808cf98a0803e608f2689609a373759f328c84dd60f2699baba4b5578aa82b7e0f3d139345e562aad52578081c015229c627c36a1132f25949406a9c944f808e49c0b2f2584d7263dd122eb4ffc28a1d40236dc82d4c403d224f98034493eca4ea2fae9956c244f8aa86dccfda2ad502756b0818140b7307c40ac90f5b739ab2cc2806ff0049b98429a24af9c429ac472c736032b1c3bdd542ada6d42f17c5e2bebceb998fcc2ee5c16f26837dee46c5e5e565648a45f14e5e434e6076f6c9a34591a4a3297a3c3c2c833a669c7754d3ad922eb6f2ee746073c70f5c443ce0322815427c34db74e2554f284099d9311c94af5b07aa5dea2d349ba05b6924afe5d1a914664196495a253ed280864db5e344e1b699cf6c2088744312e83d4469450a7510d16190e918c6f1612c5b80cd228c8888a0b3b67cb7a07270bdd8b6e89d148b2ce190599e01458c029eefb2848fdd64fe1ad73ee1b05494972273bc99caa868a846d86847aca66b148b68944a225504de8609ac82df154f6f7eecea8e9188b2615b1e1226cd32d946d4e90c09f70daf8848cde15814bc838068cd38a1bb94811510c1263d1840e915bc233a285d0081769e281de3645951136f2399f8b3cebe122f7c5ccf29b78d9465a42e592385d5a6861861e1701b7623b3144acd396641bcab22454d5215b4a9b4dc88cb879cf72f78aac240fef46ba150908ea43740b5579c0e9e0a828bee421314417c5385320090dd850e2c69350272718418124346043891b57647c8da040121ab0a1c40dd2151941011b3148403c7743e2233ce4c8345d73e2234ca4d6a16e40dc6a52cc7242f0090f323e5b19275d46b790ba25f2890fea542dc39f40218b775d9dd4647cdf7b7ffc77f73ec4fbdf65bc9055ada4ec66f654445374d2da39391bda11093f587eb0fc60f9c192fd6081d60f4a29b590702b8ee507d532c7f2c3ad38961f593896898bba0d7199c66516c9c233e02bbe86442864a2e2d5f4147ca75d99f6fdb83c979fd8677dcfe9a39068cec3d0685c886252cd53ebf3232d0586283bc9e2c287404d1dfc74ab2dd17a59c712cf52ab65b12cb52508a939f9d637ba0846ca484bd1606432226522f8dca3bb65dcd8dda218f7bdf7bae70f961f2c3f587eb0fc6031695018429f8f941f2ba5b41b12d30eac91b2a1e828a69dd0a5168a62da9976604d4781c1f816822de4ce77145d73e79d9bd36e32b0c77bc6ce06c87e3c8f6e240cb66082348f0fbd6452d2504c3b4d82dbb46355d5b403806f5900be4d013cda8dfa27c6e33633d03d02b0ae55b2bf56e918768e2c8c771a31bb85328c3ee512dd3997d14f465a8ae61c0ccd39156a1d907b75cdbd6e62b7ac85dc4b64e35d6d431fd1bdac876828c940f29ecb5eff7c3cf71105d7b82edb51cc40bb73a3e019f1991619098470aebcf08c2078b9a568b32a605437a25ba205e214689715d22f12c5ea155622238ad0b8c7c76e248f15b1c52eadded2a8b3cdebaaaad8f5155fe306c4b672e38b6dd3366dd336f3d166a20e35e93d74abb6b91baa19b96feedc28764e1a060ce0a4653370c22e5dce74cc22e1727c480d2ae16e748b3ccc8e69999439ef6e9a7ea35ba08f2b35c7d3b4d24b4cb6d25f58ad3393929d243ad38d0eae11a8a42d98643dc9d4880000800001011315000030100c07c482e18838d2242da40f1480108ca24c6e5219e86192e49032c6184200c00000008000a0499800d2c3730312345a41b15206bdacb84e2b1f029f9d8e502d16e8f9e56813233a05d7e6f9c8d82ba6c3e017cb304a39141e336b391e3ddd9753d16ac99b135d53d35460e5c9d4d87b49be59f3cf10ed73be8c02e28ca0009158e6ca59f306c35e552500df3a93e1c977f46aa097b1a5348ae8a5e15e4a59949d7195efba0dd2cb502fe35239603ae269b8975ed2594ab2ef2d008884cd6708c21b7349537e83bd1c95ea4ef8508c587121c40d06bda614777b35ece57c29eb573b2c5e39897c65f0be5698e40cf11f4ba729757a4f707b57fe60cc5f42ac8155b70a1bcd4f752e784364612e9dbd2ee8d85b85346723e0c502221ecd1a6545dcc4740916040c75e432cc1fa2a228b470daca363049e2b5eda6fe879a78d3d6a3fbc1f772b2e3fb96440008a3a1e05798919dfc836ec0dbf9099c5f7304ccd142332e09710fbe421ee299b6b2a787e60fe0b62745cd66ded1553cf41f83ead56b0085dc86fccbe95a63f976d03e45f5507290051ea7a0d17d6f510b7137c179850bcf9744392e16f609f4f113e7141b2825be0f6e829c0e67d2815a1fb71f4c3ee57ef1363fec21af9ee9d7a7b6d93a30e144dd6a10435c921a13e479a70816f50b96d948fbfdd0cad29629c63fbb808a064ddbdf5f285252857c0103cf4bee02e3e05b67950c87a2b964cfebb9679fe16ae67807ac185d35eb265023b73ee520530cd95a3631b4bd85714d8561ca9b12607418649635443037306056badf3fc80a1d5e3c3c0078ba0e3d15fd830d039a2fcbbf9e7d065dc1c5f025fbb4045110b3b2e64faf077a995daa30a2f52860410493caf1dcf1a4b24c0f2fd148402567e9d823f9f392cb5db961b7ba388d1db9ca20289d2acb5e88b4ca0a881d2991ae4af7049156f359edf613591c5a28c7bec4d3b288a4d61a952cf63fda3c8104abe4893c2ceb4fc686df7cb84eca5422aee0c8fa1c05d50f2fceab26e40f8b6377951a2cb9e685760ffde5b4acf2fe30e3b506f89273b1dfdb8b2cfc03ce8bca3411943aba21d2045e22d41b7e5aa0722241431ca49a19f0a838fe78f4e4f0bf36fcacb4c416a46d7dfde6f65da9eeda75dceb65207ac21f8f8bfa61fe3b77e0a7493eb84190b88db1c52d340a04e0e25ac283a97f2c1b7da38d628323c35b96800c3baebe1380615ee94a0fc25f33e4b11332a53a01cb821c571da192c18775f599c7ac55dc161352378efe0869e2e10cffa43352cd755a583d4dd4188519a1f0495b647eed4bc186d94c371dfa188a1eb1a270d48c9c74efb4d43c21abfd81c3e981af146730ad2f8cb3bed16782e0f6608bc291bf6e8a58f35953fff4a149032b1aabd3688b405e0e5c3fa4bf3eb96b82f11fdef11189bc4e1331c4feef2b1ef1f467307b6fe095ae9b2755e5699579148032accc1eace3054df08fb56ec6b645ca7969382e45667f8d4372954896f0597ea72e32fe50145e8e18510798543664576976520555ccf44354df9154622a337427fa80c5e87a45350a18341ab2c459d9ddc171639e7d8f68c5d270a4a383210ea2eba3920708022f04a45507e3ce61341110aa9f30bb3707b0574b77bd27ac4c45ebd2c8b61a3a38b619e9b341faf3aaf399c3a9f212d899f9b7e2f534d9add4469b2d4397f9fcc2df99f8d799f5fac7bf69492a66143b80fb9616bd314cba11f48afed0edba3232e68e8d2654e0df4516a7563708b9ebbd10d82c95c8c6fb9498461f3d2788b6c8ad74f0991dece840e90c8ca46a2b7ff8d68d1d677ba7b2a66d72254b86cb1a32085e0569978c770c00683ea85c39c16c55ee0a3515d9205d1235f2e3ba75020a4da072d90618259b4d7a1e890e422efb3347f49c5e8e8239361b2477cd28fdb5f587d166b5266edd8212a32799f223b098268f14b9b7200cb1a85daa48ac8a3a71b9a75bcdd01f440feb3e3782f5ce66033418ff16bac6d312e97451f4747c996334c916b367156090431c4b8c2b2fb195f87f1e6cdc62e9c61122cecea36d525a24918ca0b7343756ba003ed99fafb9fe3cbefef7e92577c8e7a8c85d4733942deaee85588154a31fab1ab585f3c21115af0370eccc6c6fc6e146ebfb2b1f9a5e4737741cf39488af3744a43f4195bd5f81751919f4f66e505253d3e04db13c7ff0d63c163f94ba0517bbb3e38763a508fb4cadb14016e28a617072b3ae29b6a9bccb0f60f24370d93b3a0b6ee37ccbc89e3cafe9d451b4c7e7605930f74fbadc11f612e7d37f5a0db49dce6412738859d31f05f8209661263e7e54025df2030ecee406a058066334f82125c5802d9205d7354af750c9c109bfa4dc64e19751268b37bf527bc1906bfe9bc3d06bf3d8b14bf785554b3e46d68062de684c403f4adb71fe0bd69a27507af91a600a1ec38dccfae80295a8f3bfe4f707e300e7885c37ece307b775ce7f38d6a42e998411f4422ab2b2bd8c39ea86368432b41ef1e6c3b0aa2a6442b76a8afea7ff39ec1c3cb3f81e24c3ee05b46c55850828a1a8e269139d5fcf2d0ee87eadb8cbcaa3e9c67218c33bd048a66c2a3cb318ad97befab4cc05f10ee07f709c54c9f8782aafe31c65ebc5e590c4437cedec9a31d59afcec40f02ccd9f9e29125d747ed2cb669d3d5ba2414e19583b4854aaed797e51e6a543ab7fc63cb80897c30c4961ff42ca5df99d769fb69106937cf32018654bb3d24a3a8e2671fa130fa8d3ea44ee706f2f85d1319f93a5f075510c5d11793b9c88596802c48532cccc51abc5db62f942d97a18f20428fb7dd7fc9b44f85f3e026beae560246c11571579f0cb7da5dece975c8bd20fba98bd6cea45ab3e31a6abf5fd59a4f3fbae4108c0720d99b3e6b399e42d3ac95e2e52eff661b8905a17c150ba6e1f359edc0b2b2ef6e98ce0b7808329e33797f4562ba2cb85f3424afa7a1be43903d96a54700df5880870ccd76b970c9b06ae137ad74e4156fd40b53aae42cf87e9b7b1365d510b5a0b735d151e08ec28ab9c30378235f119eb2437b09e932d4e016ab76908d933da0aec442c204e436a8d48ff3521fa9a2bf3021ca717e0b019ec7fad46b3207bffa64cee6d83064633ebd431ab94adf8b14717dc2086faaf831bb0e6f25c05c811e53d1087f85c97bf250422572a9efe9fae2a2af9b709db20eec9f498f344422a77bb7f2fd0595e966f64609892e1880d675f0a0ba59006d55eb64600bdae4e503ae2a45ca9a196806256def0213130050c4d15e5a8823b9b5bc4509cef0f39c2e74cdfb5a953038f3bff437e456f8119ac619d45af52abfd48fbfc27497c1c2d73feb9c7edba0173ab8e2b47cd9665cda557b0dfacebbc4ea7032f2bf57f69694c91d64d787dfd0991956ee2be1a645e5f0b4b30148b3b01bc406b8551784a18c2efb3dc86af943fa3b40f78e046a6cecf5e0355a4ebfb90fa7b14244316d28f43c3b3ba143123281a61f822a484f79769dcbd1bd6c76e1ac8f4b5d8e2d439528d707f395c1ecc1a7715a6b431a0f6fd89b8aa0285801ac875a99989f3e2e7630c6914e8b082b4233a3636039949dc5c6cb574d3c5847f4590c821897d207a116f7e4f5c14846aa8ff8f186e47bd9a49c3d44c43515eb3f34ddbfa99bf462ed95f17a3496673bd525367fa8b70bf479ebe4b8847c4af3c799001a4304c0eb826607120e46d61bc52f1275161e2cc84fe91f48bb50ee3dee807373d20fa3a6c5a5a4b755fcf8f031d34c5af19905c962426b0f99072ac3fcaffd9b390335e242adac4fe9f60981daa5f3921fb0c8761169d05782e3343b4ab290f4289ea918a6f512f9b020e804f3a64b13b4c64db384924f591d52b773d28ac046a4b81df9d24d3ca3a23cb7499db77b4e339174cbfc628b6b46ece7eda2b026adaae926031f03d30dd64b475fa820c29cebf8f4c75bb0d94a73b0c96f8c40d15247f7491a7be9162c0aade681b0f2675951e43f1e496cca6e8ce236e1eeb535a58fc1075a399e692e36eea60eed8880765871c2b78697a233f7aa17a975df36dcb7c5bab1e905893c32a41dad72b8f09152d65e20bab56584448164c2478015161904c0191d7cced300c98b438b6f5c857c2207e066a3f5fc04fa07aff49c18e77e59248211845faaccea9263f58edfefaa4b511f98d2ac3e502315d39d0d6d67f72ccbca371c88e5f429ca63ec39548e20325d98951df6eae992fa9adc8037347c20c2aecf5dfd0f06a1f653a3fa82e318e7760eef521a67816050212cc15852623b4964d531e1318c4d4411d2468aedea76da63ed7f4a1f7dcd03028917654f9edc46e39a778ebae52991488043cfff9b716e5ae7b0a0218a41fc1d4329bc5f32af06dd2ce15ec3f1c3e6f541139986693891042874d6ad25bf9525e41d2273b1006e84514238141b1074775a74b98abdc71490c0c96f0ce7e8a938a355502dc7c29f206ee7461b7c847a87e4b5b77d77d88d1e0828f312522104725f0f311b662f0c176668966fd7c82d3ac63cb53f82902e16d3a3195e8fe41337e651e58b285ba66ad358dc4ed77a68e2ce34a06b09875abb4be97c3ef01b0e5536b8648f90d6d0081614c4328a988772313eb8ff5612170f15480b0fd826f0723aa141902173dde1128721aa7cf33453a5cfbc6ed941cd8f0b5c5d7410d76ee17a8d5112bd03bef2bb716f59bf27374d171192df29fdc65ae70874c5df4adeb7fa87f625f569c996b84e04faee6c017b8e0d927b7bf127c728aa2a6060755cb5d0e930e4350dc0fc21408da19b7130075f2a5419b86dcebdd1b1382d89b4a943bd46f0640e8d17ab7d0168b277a3d3aaa453fc3aa47c7e31a92de240718a50670e3fb01824386c019a4a04684f448b01de0901da054a557027f3851d17924a53b73edc52ad55493505e017320f83e6e57eb514b2a72cdf470d0e8ee173875194acd0ed91d65770e2172c6312a4cd7d15b20a3eab600bd928077d55aaf086caca49a0dd68a6d5b2d564aa0c38dbdb28815c3402e313f96ac8f40316b28e9d428aad7c7e44807800269b2435f3da5ec446610ae5eb39051838018fb9a7e8ec0a74bb6381171fd99de482c8e8bb5e3edb65d8f157c01e2f2965cd70c164611664a6d01d43afd9b4a1b5469c90645ea739e132281ceb3308508b039ed6e2db4f9e7e97bbd36599010c313f36c18a1bd3518489fe8ae1e28b16e980a8f786260ea37dc95c889fb59f58230482a16d738cd50b009efe79ab0b5fc2212502000e8bad67b3fcdd3926a04ada27444ae69dbc4debeff9758405f25504dc685f2a69b28b6e0050b62e6667c0c114a18acd5e0d830f3493f35ea05fccb27b7cd8332be79d87868df6fe6d6ac5f255f3a69107ccb28143ec2f2213025fb087a74412df4024e4c2fe0901f01148d6d84d96a9d4b03fd8654db33bdb15d77236ebd135b254aa86f529fc3372977d447afaf24377da1134b8a58d8a6a52c69b20f7c2c2182fba4414587e05a7cd21cd26518a018a9f7ea2a78d789abdad06c7b9bcb2a845863b23bf39b82d4ffaf616022fc3ed961f46d62ff0a575f32a915ed9f7705c22b5227ced444d5d1758c7c52f870cb6e65dee78d959aa5aa40d87bb33abf9cbdf601aad9a8336b7e922e0c3dfad325ce257842ccba8f26dab31312ea462abb91594b73595ca7bca129d9958710a7ac3f3fd121a9cb53f69c913c4876fb3f2fe92f17addbe494252198f2fdf09767feb85353ebccb79f67ad39910fc6fbe93e0c7cb73ee5500a3c81db5f208430f95512820f053ac814f2cab2cf7aae262a89db970da58d807d0d5cf5a287cabc1d4b7f3769383c4cddb6a314b69ecc2be9f35d7d305a4bd94b887dfdd121abaa897616f7e5a537461ef11b979c2823349b10db0361c86c0d0ac92ea4489b2ccc7c1522dd42463179151fbeb184ad8263283acebecc87c8f58833c1ede47913be93583a57755fd16edc611a4075f16d029b7af9e4af2550022b33236145d0ecd5aaddd409a5097626aad88a2133bf1f3ef6272979fda28c3ceb9a14919e78d9028b79e444bf07b3f615309a7d4cac2406ca7daacb996461a54f06f959d153cc60c25e46d3d09170276baf4b39d37d9a18f092b8c1ab2f99cfe9dae28c4534d36eb1b953354bc992ef2c4b501ad0512c372a0b89d3382340043118f43e502913c247a3cf02982b2ad82d1876d31edcd3fa09f9905b283119a088f0ac4ba4a5b5fe53bfefc108693d132be8234385feebff6ed6bda88ef6d1a4a4710fb9a6798240d3e33f1b385c20a221ecd9edae3e407547d2181987e22587dc4e1f6a8a4d7cef68dcaf04b0b697fd8a1068bbe667c56d10e9141ee5974215e6a08c1083546377ba5f7228f6b5121e54b7862f9af677897cd92ba8de74677a39f26b6cc83a8479e39f644258a1f808fb8ba7aad54dc90eeaaf9cc9213cd13a6c09f443e83c19bc43e82c197443e83c191c331d30524d2bf03efb7937f4afea8216701096a422c5f4cd105e286bf982bfaf0a454f1755f80653392c82371c7ba7c163418f4616ca4fd7c8d2b5e0b8d5cfab4e83d27389b3651acb6766d21b20530166f91033bf316e71779152568b555c6c4a4d0a6aa75c9cd7dcc8bde3a8c09949d0b95c2849b6c13ed9a560c7f62e04456389952d5576bd5e11ed6609a8bd8f3ebf647e19f1fce29182be444f0dec69fcfa249a98338194d9f2d5f14aa70d6df21b9d74d01a3b1e11c71368282949ac53352cd82d2a43dd679e8694edd19b5b1b77940b9c9d0bb321b8ecc01a3768b365d814848465def84783350d6ec3a1073279a687e3a01a63e6933206489a3bfb9ec7326d28dbe684ada197e82d452a984ae58ca7eae62510f0508735743adafe18d4077144cfd6957f9176ff49d8023fcdfc2b28b14cede2c456cb06787f55ec16d74c3876cac91c13bab853545e13781d1fa4130e689905739b0becc649365f083e5cbe9bd255bc3ed4b005b17ff569d6ba7dada8bd8cc6ba005737e80f5df14c4a282d7757648a3b07e40af85c732cf4b3ab5b4a2ee2d5c46c74e06bddb50dfcf5be7de0133dc7e565b21d68e8e23560f59ceed05acec5735a5950adc4ecdfabb0b2b1d1f468aed0427ce672d3e0a5c6ae31c1329ca09e4e4e6b0c50ca2135a1f30e2d5083b96c20d74d77755e20cdb04b62fdc48ae20cd2bf7307ed21f7bdf0e9602ded2cc6899dcf376b526c40e159f60ad2109f435256876f564766bb38ac6dc0446e6fc5cf83e2ff6918286461c95aa67e7dabf5ba979ddfd96338af4e739c29a2be051a7b05991e25049c9c7d155318e9c421fcec1fac42d5f971767e8f6cc39fcbe5b00620136ef80f94511af7751eb228d2e00202856f4d2913df71c2abf2b02cbabaebbe4108a4da91f1ac506d9728768ff47c0a59a735c1afab2b85b4d6ffeb4d96eb6de8349c4848a83ee7a0eeda83c12f9a0e51a6d5955295552e0688c3e5655502162c54bcb685f156777a7f095f5b0ed9a5aba2e4966ec49b6ed9329c7dd1bd33adefc20ebb6d174d9ed86126aca5162e8861ea7f21b43a53cd64c12935286c1a6d3a0edf584b278e91165c2af27c4d5cfe13247cef088fa19ebb9b50ed04c225fddc2bafa4012e7a1e30530cd95ca51d52f6513d54ee1838a5069839b2625d84043f5649f3a6af7d8def5442e3f22a6f41c1d776ce8f259e206ae69d5327c537abd30eb971eb7479f3e754f42b0b31c2710e382856b6af1c9987e3caa24a75a08d8af8799ad2882e0931abde72cd90bf8f0d4eddb138e6ca4c0de55121e1da4eae8bb616ae1ad94dc3a00de1989e995d837d5d67b839b6a0bc13384460bd7c06b0a3eaa00030fa81d8d27b4d2b617068aa1291a557f7750b6e626459caec50c25ba8b9c96f5beecc4a30bd570029621e0bb26f52245b513efc320b1ede1ac634f2ae668b9a175cde54ebbe1209ddffe70ff52d1f9cb14290b645f21799ade1c7a018eebf2e330562a6726949a215d2a532bbf5b918b52ab648cce52337f403998e82438cd2040e92dc85f363d977e8dcf2c958b263bee7dd0fe6b3cd9728c423e79388aa498be4665a7256f2bb8323143ff55532a6e9073900daea1255a6ec75a12a3a072d8bb05b311dfccb10859eda8be5868e18340c3c3846dc6cce73215a131b95602d3c3a1a7fcdd0d9129a8a396657908bff311b4d940e36e603b18eae4733e61430aff35ce431e5000456d0da32073dbd3a5c5b9a402b9a515d99291b1843edc6cc49c9e8e6cd232b8242361dd65002f0941254297863bd19a8cf32e2035559444a3dd0838f8c6585f31eb0f67fd5cc9c0f7bdc0f264bda06ffa52e00c5345309fbc5065e26b3fe190a74f106886807dca3963c0d84da793e31d630c16cdbf49b53495f996dd68e5e5d11f2027b73ae3dc8cdd33b191786b9dd4b84e4471eb4fcae60b347a0ad9ff1ba45e3e02ba8301a445724e772d51e7d5459d2538650ae414561f0a6d1f8e5eaf03ef2bad5ab0d8566e45287f81fcd9fc78c065a27a8a05000224e2dea7515e42cd053402c2fa2ed74762cc48e02b2568f24ac15ab297f4a0f5fbb2580507678b903f571e2315b450626fe4f28795c2143739e7c61a54cdc714a9a82d5f4187ff3154612a522ca7bbcd2649d92723d1141d2ab115ea2f4492ac6210e05100d510c05a18507f983ffa91c8bbd63e898d70e87d5f7f97f90c44a345339f319d56df9611eb4e7e915c893a88af4295817fe6db3c8d33f4c327dacc2c08b8ec1b9cbd3c8ed079cf6388aa815d269dc144770194a4ac0f91a2eeb59ae1caad7033151ce527bc4ac6a28834283ed82dd8fcbcc656121bbcb6e1b5aeb92188ca9adb400ca769b23485c65545ed95a55bb81561d316c1eb9f6cc5315e935defe7ae12dc33fa1495d6c01cd52bfd77c78fc681b67613be429ce6d53116922bc3d0234328b792563a74b2a614fb2421f43f3c5ffa356963199ef295415cbdf9a2811d60e93c105ed23dd070420e4b6e667409a3184532b622d27ac28498080e418835a30b5479b8fb0de499b1fc80e3f42e4b54d0bf3fd1851ec1fe92ead42d50c6ab54e781de310568ed41399df2d478643c5aa11249371596d77a86b31124ac6c944dd0a9145cd2b67ec0cfdf8e3b69a7bfdcc66512ddb7e657df1683888331d44e65ab17fddafaf5cfbb3e0362cce8bc66dfbcab67eba0536e88d5a0abdb266d2347b029cfc273afb498cf8954bd3f210acbedaf9a21ebdf72103b52a7b7102504d52dd0d20cf7944082bca52a74ff4b55907c48927b79e1e5f38d70b9de48bf0181ec28ac1b95139a3cd13dc57faaacd3c18eb45598612ae8e36153699b1b528ac8c5665b3e397c84137afbf5b479dc22d6ae84770f1b67c6c3262596178cb709cc26667f1d2caac1608772b6930cd23c3e800e084f019ddbb0d8de12532b1bc08406077a32bc451f22406e59fb055cf7dc0a16861d9dc680db19d93ac1ac0d1c74272821a1a6a53cad80c6c8e223f45b2f1e09ea79bc24b2ba4b56c8a7ea8213e341884445b15c6bfcf7e8166684a94f80b0ebdb59dae8faa5222aa6812877da3c7f4790375901c5ed0d1b152f42422e581ee58ca20c0ffddcb60c7b3795d5c989e6c647983237cddfca4fbd6f5c94fe79ac2633d15c057018713766cc4e3dc64048fe79894a30b3c0221f92d95477994c32ab724a9e1c66fa68e73433a2a89e1d08c712d56da68ff1512b5e5a36dd0c2414dbb39750751c7ab3b59902dfdde7664544d0fdb8d02d002d4917b4c39a0ff0301b600f2e0d501ec6111a7be9a7ec61bfbd5af0b8a9e9e28ac8c3d508d174a21b74f80f24708a9ce52aa104caa2e4fa38827c09908589d607e2928d8716b9675f6ff2efa00eeb1ce04719a4e7d834dd37edc8709f84aecdfe374250a82d3b488273a633f390a38a0c51f1e7d5d515b04d8095d866b8ef06e96691cd690a6825ae92dcfdda05cd5354d49f2a01c6ea20e0f28dd50b4c118fb1cf2957e00608d7ea0839ba8c27fef304fb29f36ca40695c98defae48e8ae7467566a2233fab24ad5df834bae363d6bce1b4639b3abe7e984a9a687dcc63a7987ac4d0506a516f41b2cd84bbe7c66d942f650e936242f191d79ba72cab6c7e970524c73d63ee116fad4d8b1f8658c3c48871bbbaec31d1e4059be678d3f4c8b40ef9d0e3e17776068636b7a39dbec899ced2a8773a28e91210b236b4f2be6c5368a730c016eb8cf649561b694aa72bf5f58ae1c63c798027938e3dab525819e7f44c609e1c5fe0a32f6069ce9982c973e5224f921f25388760d4ca0d8ce0386266351ca0e3c4222db7e72ea55638ad22c74a57d53ce6ba3a5f5e1a46005932785d0851ea1a6f1e537d145eaa609d0ca03530981532fd0a04a6b4309b85281156c6e700e536682fb7daa26e40533394de5fb501527aa918671ce1e3a1227b975064bf41ee59a31bcdbc37082012d470e5ebf79d9586f6a2274acf5bf8b24ce15e78395740a66f87024500d82048beeb7e720f354cbcf8941be0cc2c609d510e0ad3157120ca590ebaa437218e8dc088c4a431911caf014226ed4ee2ae1836329a9c0905cf736a96e72532009a9e612dea2f3a501a9c2064d6e1ed02464a7382bea98ad208a8193a2360aa30fadb820fc416fcff7f4782dca64ce1ea177968d1c20d0276ee573dd98f8e2528b313efb26a0c05f7df49b4229ce9dca97766166abbc567ca1ff8c73a75c54dcc3f231ca8eb99049fedb3a21a9d00ca4dc0fac401105520cf6c3364a5e223e46f7343e8e27f8f8016607185a54d8e957af3a3732c018026fb0522dbd01913cef0f0c9cd6e0a53fb63e2417420d97210f664d205e212860b38e7c8d58a8bda31226d781812307822ed8546bdb7870333d9c2383a7d624b704f3ebac798e364dd5cfed960d770fd34088628fef15362ed32bfe6dbf53d62052300c9ab35b1d73fd6aa19888d212f6aa1012eef5624e31c69c387c6be3154fe218c5903586961eeaa296f170b295e23317a1503d4adfcf20348f2317c32469765476976644e05e2a9b63be363aeda872c73205c90b7a8d312dd8fa2439ad0c4c04c77239dfbbb5fa6f311327c6d241dbbd428bc707c72e41f77ad2907c2351fd02f47029f6eba31e737d182f8f46fee73aa2f7db0e6d130745d3dcc2576e6c8bd9c37eff853a285e36d41ec7dc7f7964311f80cebcb5266db0a48a9bf2e7632aecdc86e6a04124e890d03647c9b029fb3cf4a5fcffd2e4fd379a34bcc5e2cc52f392ea8a7620acd8f4c548ed52e5d9bbf4ab4794117c60c38a30022fe932861f62a3cc432d0cea07f8c5e2524a84d37a232e870a81cc3522f29df0b94de6c83547a34f7182069419fcc6e8c5b0718dba8d8e1eecba729f4b29b58d198854d8db401cfea8905fb30883efab5863cd17430d61c3807cf4e03cd75f5cc39705436e1139a0509401349ef7e2a3560a585d8e0fde8733fc16dd98163e834cf2b4e34f151dad2f09e25fcff4439469ae678e730f2c6402762e4d184804b07c88d7df017e47957423064aef54ce6a30d2577917cca79c116997f237c82e34c1c91f152cb25e6cd8dc38fed27922ef985ac604065c5ae5bd2dbbb0513ae2b6c80f001d71ab882d24e294f55abd4b4c4fd31c8960b97cf4226d1531baa897cc01584aabbb7a85c5ec55703922db3fdd7f5dae9480501d8b66ddf6c81bb8e81be69387c1c85d61221685b82db91822d8e8532b2c77bb4bad02760bca09a9ea341e8699b22c8d1986bf1813ee90c1029613c5bc3462e42a47102a7ebe14f4100c7815f4aa70290e683a88d9f4c1040ce706487ffdfa86210373d926256ccb3cc506d44b9bfaf77d0a81ec20f87c744691588ee7ef1c42f3bd44c755d4661369b6c45f7c2cf8812bca8e69aa0d7d3f817efe793e07bf904109af190f093bfffeaba66b6f0f3b51867ed1af86f649b7eec5fd7861e1acb9660b422d91bdad796afeb441837f9d7182c8b670c4b546031591220706ca905003592156d8afa63f8c1dc1fac676ba257bd55bd3212643bb95a1162f9143c9c436be3701ab6d8bc496e0fbb9dc94828c5885e8d045aeb3884cd08a1ef822224387d02a8960d33eb872668ff53e340d99ba243ebf8db5726dfa52f3b9521d1451daeaa2cef858c1a27b5c092c2f22ef74091d58ec1ffa1968b316d5b597cf909e5a5c9b1d9eab2aaae491ad87cbeabbabe42eeaef7a48a3762abe8f13d63867405ae6ff25d6f6ef0dd729be01391a8b52f16cdacd4a5d24e9f798a5db48eae76435583b5d7e44bee70b68eaa78631fb0cdf66e21e510721bf7918d8b85c944c4746b6b4688cda0da913201f1302df90623809ec4d2e64fd50d71124f4a04e420da47b44a02ed2e1d723c0f9c7a960426cbe15662b15219f88ef463b5359f0394580d1ad666442bcc4c69d3fad2939eae3bd6ec245157118d53c6c845caac80d328412355e1c33bb8f66e4b7dfb549773cb76a260f36505222af4d58cb58b3ac47295096a29d644526b538c819a148cf6464c5d3d54e2209e5b4b688f62a8fb3a0b3922e1d3b945a5eedb3369d76d731f536107d0402f9d5f60d11ae067bd0a6df04ed9f8f8d216cd290a7b23f43e2d6524f4d17e94f7bedf803c2497fa202ddfd76b2271e9ef3b791ba4a014330465f6d9be68b70560a3c4a5c7a19d45f8c2782d61a5cdfd738eb4fa202ef37737d0c1ec1ac51afbe203940c978aba6dec1832918074ac7289bec5573ab937697f42af6cf25065fc532d983f61034dcdc45b5543cf1345f472090e212ba49f2e82ffc54f442d2629f02eef88b44c48bf18702dd69fbc61621fea404615f888584f6f007afda443d564245029d55c8ec31f9409fad5a27c2c54e8666bf571209f3f532becabe16b7ca0fb34f48ef9c36ab7d5ca3a1ef4eb5abdbf41da1351d1b39b7d3f16807995a501eda3bf6b110a5bec5739615df0078663d3e53a73efec50a1519f015b315be005f9ae2474be305a4bb1d2eef89c83c4280d5b7aa87eff4c36459684c37a1bd4a66659a5da343dd9cd9dda9507b917c3b11ed9c4411d299675e9b27134570a92b9b68ebac8c3fa0f8f166dc68193da21f3780464fd6267b634982ca6da1513fe03021b4c6eb1237235489af974a600430d3706a45c3b0e34199961d209e5442c85ac62802b516d9734571ac34c5d6afc40db8a7b88f156c329647d4d0ea01ad1d4b166cdbc04fb8de59e43e4f25577c05b6fbd28cefcaef16dab5645fe08ac572f7068ad2359fc9c3bb51886b640782344e7921bad8f9922001cf0a751fe15f7caa441948b870e2ce9fd6d6c803ff7892bffabb0c0f48854287916cbb0ae71890aceb0d73cf0b1a03af6ce96363e9ec46959a53869cb954d2fc5d068a90359cfd7fdc86c278b1d574657e0ca4685661fa81d58744301358e60c3a228626c4ac8894569892d2a8f1c71cde57a94b2a8a88cb9a2c06822539e1aad35d062096f816e3384b92b5f5433af902a2bfd7f97b02c7733c8f8f8af1e5f8d773326fc20d775ce34e9047c4915a725607157aff08f514d1184ce6928abb6b0d39fb6b569d1391fb68c83ecab34a7ebb76438db59d2ff6e567a48af888f60c27b70c4067b20f75bc7a07b5cbd1655a768de92ee5b2f5476bdd815a9736158c7c757bf4618d1d18d2efc32fda7f3d083354ccef84b7a4d1c457e9c5e9ff01fc0c2e7cab690277c5cc5e72d4ba03bae321472a89d2c54ae3cda7195a51b6168718c23ee689d4cef1d765eae266bf5426386a6af8486e9ed0b79bd66577de2b69bcf3a6b7ba12fd672773a6b6986d7fed0724e3862ce34c2ff2239903a2498ebe2e652b172a2e8a6314608ab7d5ea9137fa3223efbe7c04a4f23f0cd36a6f0529952c25951c458a83ba0b9de9f4b178258286bca029108e013362bf2312ecaa5b12a5a5c3b6a1f1f774d3dd4e54072f2f65d0e5945ff792e05173e191624b230da7a20aaaa514f8e0df5c213766980d38ed5102568916a877417dd5041c950fc5c88ee898473a10a0a342f74fa4e832326caa2a8f16a200dabd671098a36a9091d5f269ea23c23cd26702cfeab76dd86335730682f54d146dfde1c2ae92cd4863e4301edc51afa9e8d7190e5fbca1580053e714542b7248f632153d4954d3aa1c597c923b4252aa841bc45d124dc4c8d54bb48e89f3d48c649d31a1a988146fa72f4cbd7253f081336d624b14fc2b62b9cde8696bf36d480e1cf62a30424946c06aa51d93d0953aaaf543db15766020e4888014e6aed9eb87084cf80596cd3aeaaa910baf60ff55cb086c1a1a5ee91961627cc45889c3990fa842c6c08c76dcb2b9115bf0dd4c34f420ef6d927f971df43817d7dfaa2a75679756ab9a990e22f7054d1915b6ace483c12ae09b4e09964cb7724e92c928c988ceb063b1c6da6ca599e3aa1c064a6f00d6c3f39d6837e5b787400ed8fae4067552115681e3ed505d4c7fec01b0cc4aac186c962d010ba1a5c972e7c57430a228a4487497f6759152bcac87570e4644657bb559898d272fb04c9cd314c8700ad6c4917290cb58d34ba989896b5164291dba324f5af2339d7d9b825f4748446e6680f0db4e3a7d83f3175ee6a077c94801272c3452e7c679b2bc9e28a87560ed884f349675409aec70d5c53fec3f980bba6dc8e681d8d05b8c42ccae51a204e7b7cd8cf38542abe43fcd733cbc172a0473edf11aebf7be106b8c0f9e5bf52f14ff80f83a164a677c2cfb016ac30ae28eb4fc8a7a5b2401a50ac882b223f300e0b22f5fed4d99b887805e581814265d7e730bf1e57f41d3865bf842b4ae80632e004b1b8a21bde42c776efe64be3ac68d5aa043283e1390b21aa759d57d89e817e7454f95ed76bebbad9426114963eb162c92344b3041bf729bdbdcacac07e714d16b775d8839cb432bd9541e6873ee7236e47ee27bf6dd0c43cd01b40703b0b03bb243323aa34df40d213a0c3fa8caf5fbb6d3d04bec6e5ed2f1b2754e5be961b5e98c658fdea053561f7358a5367fc9f73f93161d0d49807b20100dca7da6ddde64a9e0f15e92b523f687a8745b8f11ece51d37dbd11a094008ef235c8326c7bf09e262759ce755f7936878ed6b82fa57367a53e243977509a0602b59b14786bd0f2ee2b1c909cd7bbf1f597e9fd55a8d5b6d87f07b8602006c55dc2cb3c3c03c1ada255117dadf5064f43401ece3c8c2eb69684aaf34914793ee5dbe7bf3a5875349daa6264b55f9e3f88ccfe567b68d3220942e3e3d54327fbc9329de1bde43c4f4fda2f5045f51ae7528ea79fc7be871c32a01da368e929bf31b7756ca174b7203fffbdc1cc0fa5eb7ff71f066530c5b8154af1960e66db0514d0cc0734bc5e7ff0d94ce19b97f4441d793e9eb496f480c4b29d7d2e4efb862c5ef4d877e6795e77cc39e6314a42e160ef51d3f16e90f75a9648c8a4e075135e78eb9de38db2fbff5cd203ffd4ae2304fd3777117fd4154d618579dfd2955f5c88beae3f5c26b892f6bdfd811c974c7210b4dc83260a5d4fea4566b5d6371b1fc2fea5a15c801a16fdf275e17014ba65113c77d79f7ca0ec170507da136006220a24dbc23949bd644c8a1b7d26fd40c507a0a328d8454b55596046ed3305bfc22f81ed4bc3cd88fe8b0c00265f7d2d83979bba4f33be987f2af6e6d2201521a06d3e805e1c7147237b309d9eb7ac0e9e93f0b833146d6798f3c8f2c5ec742b43a2413de78b9051f8aa22b1608f247d979663670a3e2ca54d187ece2734413d79c79e2e74bdaa9dfedfe2b9304bf46d5d3830a99edb9f9ef76a086cb06816d66abbe79bf711dff5bdb72d2fd4dd7dc2de0fe88b06dcbfb614d035904d50cc3ad799f7ddde0a75c7e081c8165c29b608d816840a5ff49e66aeb68a6f482b429358a8e00ead8364a78a441074e3183a9da92466674210cf93093c7ae62a175530abe7337c0cc21b152b199ff471071dbc1fe31d150089ff7338206fd9954711fcdfaeffdb37242fa757fbb192430e1559069b8f39dcab3945eb75b5cafc46c88fdb865366efe5fa516581bdf7301817f3f55e68c47ffa60a4ab336aa57e114bfb83d2e6fbddc5a1d9dc9e67f16a2fa66886cfb6a1b5ebb5ae8abd8a1e6824b08b3a98f9e9f8f2c2c20c8264f0a24334cf3380909082e4e9df7df4f387f4137cad1aefa28da7f78bcfe3964005225450bc522464aa646cb295ec863c1b06645cf590de5b344612639d96b73c30250e6ad691eb214b07b5859f253456c9fe757bc9f38b6d63a7d5341774dffc1d004359e88987ece05989ee9ec2b33dbd732a7ad35a267fecec16de07d321e16241ded0ba67d34b99a11bcafc577cb49ecc3d241f57eff58ee8059e57afeecfd766232a2c18cb06cf22d5323ad3708c77bc7fcabaeaf94a2ab3ef4f58d7626dd513931f69379479b74f081543ffbed38db4a61bca6c9c1cab30e5e6c07833f8067b3c92e216c23318d7cf677662da646b1ec91e9459d7367c03a59ca7f5abf317cdb67840fbb78ae39ea6920d49aa93449568a431686c9c8028ce29489ef977c7b90fd78fc58f09b7403f4c0430075998a41b7aa7d18dd335c3ca0a47d74f109bb9524aab6a57cc019ccc563bdbdc5d00ca097cda449f2e92f0459271939484aee83fd1d51f6a7519fc03945818aaf835a1ab726faed994b6b223a8341ef1d09085513872a2055b86d2eb9d20e986cc9a2724309838967271942bc78c68c6fcdb55953fd9da2e6c97d3791d3c1942967fd82424b6f3fd4a8db88c4f948f385fcc69934d1a195091a518b0c7e8fb35c60ced3fcc545edc9929c1a8ca165f59cfffd509ca85ee81d6aa3ecfda056b69b9defd0a19795dfd83c0498831763c29c8316912a55e45495cfd1d2118a2b6efc117b744ee1f29711a1c754660e570429c1829a5f8869344634a9d6b05b6c9644b61aa8e94985ea5ef59ef5a67b54f60a4c450b850a1b22391df37626ba5c8e2c0f2e9ffa14055513b47266fcbc83b94153b366864662646f9068d32575fdd73bf699ae90a7b20723672180492b2ea3525861ca0e6014cf98a8c9040a470aece911cf3192737d042ec851c9665b7f8bcd830040162c594b354234f1a1604ddf8c3105712f4703310f4bf5efed90af739c85e4bb8f55328f4cef5f9fc3bd2c11b6a751bdc96705af171f228c473e2bed244103ebc02682c633b3188389cf8b8896f0c847b2e3e460dc3aa4ca80f52812517fd9375231178dc73c78a44ba8873b038d030154c9faaecebd50f1da10f1eb7f69729554025e88dfe9c1cbd137ca9e1ea4aba164863ae4b34dce136292abb78c072ad94a57dc5beed0dd8d6401f7b527722b7175316165f47b75c0b072f16ccd768e90c8c45278e3a91000192abcffb4d21e8189852f8a3f949282b618cb34ad5253d7342799692c3daa5ad070bc006508fe1af4b74ae7bdeb856141f93e514cabc3c834c5ca1b8755e0b7d5ce1c6ad6b07df4c2a0e8982fe91c5c2a67643c3c3dd2549a573bc14c6b22f87631dc01d4d3a049bb68de86f5a04339d5a7c9b8ccd68c7013629a2f850cecfeecdda5f4ea36449785c0c2a5bf95b437e873a5ee7fe6eba6436eca1ae50c1b03f47d49325d2dc40efe8592cddb7b3e1b45e3026aed7aaf5e48da524b0ecc9ae23bdaf29edb767f5a26a331bbff04ddb492f8a64e2a83836d9ce136910aa436c85b94161d95e43e1658323f45ee2229960d7e7dbcdb3c42ca206850f93c62a62295a7c638900b107c37de0811c8840042eb0a412ebf9ddcd37589a3303a31c373e45d79aea6dc1f39aa54dea88066f3fc6dd96fdbfb359b780441d6cc55042f562ca2bfae51fc854271595351e4b8f33ff5676e362a6125ae6948933698b9b1a720353fa6efb4b1b62b3edf9da12240a9a401b47de63744d0c05f070c83f0246c98b92ba58facce6bdc873f1e23817988da1232887cb26115f65fdf03f32a551faae98d1beb2bcff64390b57d82b671887820715b043cf87728889ea8040e0cbc17f8e1f03d6c2eac5d8c1de7ef8d98e645d383be6c835f03bb300d58f102d629c47a85f8777999ce2c34da9fbeefd3659993b93fca6d8013323d4b37ef0934e7a53bed3251e78b36af1fc4d48fe3b09f6747c1cb5d60336e998aa2fc593a0a9041593b79d419f394d8eaeb4cc6981c2c7d80660134120b7091decfa710bc3ba99cb92b8f0a090e39aedfbdfd6ddef42ac24c5027b50a1c4a8c2720a8e51ef90518832ed4de913b6375c3306b80a7c065e1844f8faecb5ea5f55ff1e08977741f0e9e2fde7be3c0108e5afa93a3c70ad72163d4ea97027c3ff2aea2f120837f41f616b48473b79df8cdd0eb8892adc2f1b17f37980e326e1ddd21085693bde25b9a3ddedc0c0551af368b0b88f98893468708738500c1b15f5ace015796b38cba948e7f533bf719c3ae414f95c39a3841e5430f93524c3e38f2996fbe93ade8dee9fefe89b8e1e2576d135137f33e5d669ee9a56b9c61e05e97e61da3db18ae7bdf239fa96c8b4e114b97f02f430d02f87ff370f51fb3890ce9ffc9a58242d990a93e9584d2e98e2d9a473ea70b91fe43818552c6c2cc5c1a2b02ea354b27cf2f990ab36b0da8b51076e7c3b1639c7e81852c255b705b96df329941dc49ab8fd475f2549125ed27d70f306edd9a4eff8b79109506d9ba3709bea94fd03fa4b7924dfe3399aa09bc7342eae1109cbb5bbe4002ce11e2b38fad73f2abc6c86a7c521a1ee8cea929789d39ef76624e300ccbf422325fe99b69efb38c3fd420881c02eb3e4d43d3ccd6814721fbfdcd914a02f2de106320e7ada640e9668a54b5e32480f1a9da13411272aafcf202d6f3c96578c111cd4acc894319b27b94ae244d70ac21740f12432251071ffde208ba19e4986e01066f70ea7f67d8c8cc78c34f0378884362379fd124ce5d979152fc22b2cf4aa630d5bec3020204574dc975f7a1df3fbd243b0e934c6e535231434304ac4a291f5a2f4e725b0648b40ba8d9843cbd87c4f471980dcd35b18bf4e09c9e21852be7de289303183e7575f38444f058ecc4cc6a491cbb3bc0c2b875da9c8c05d66ddb09e4c2d8b5cf6efb1dd3dfef0768ebed33a9c4bc832b2239d0f10062cda84041b8882da16a23d1237cd4f70288638cd85330e97aaa90800b84f05eda706f012cc442f3dc3beaf8088b1f3145ab54c3f9a9558b23bd2f1ea4883bb64e8ee5f38cd25f566ff570988b7fedcf25c69701b1f48c7d96c2518754996f0fee2ea6f9971363fcf3cb7378add722801b5fb731e0a197e04203720dff274eb5ae75a8b91be936d5c2e0d1d78acc6c16dca9174097a85ec3108a03f1034f1aa45e0022651d678d0cd18a04a84d43d068ee2566f452325662d274c2e67900a85ecc0476f1f052f9fb2913a393f3f2c0a6118939084c9b9936134881acf77de67f3cc4b41210d4c984aaa7c0b5384c8ed97d9e61be5ad2df0e889c072f84ce64a5b875e32a7ee0403d843dd2f56613555f9919d3078cbad61f059770655b5644dfe3c05bbaab56b21c2a20bd15dc85fa56e6517bd343097f6bef4bf8e710adeeef020051eeeba7c10983d8e82d474774b052cc0484504a1a831a1a9888c3f7128251b95363f4b4c07d5a7e89ee555e1bf2b1c4e9c9b030715e849369e8c3956d9c654779ac06f07c1ec3879fc76a401a7f8aead108521dea63a252fc0a453387c2b2e8a5d9c267c538ace8fb66dfa9b21c6dcfce0f9cad69f2f56c2e15c35ada0937078fa86d689bf132f599c3ca34e4256875ce3745cc8bc7434581f9e66683e999369f5c75930980e367d99dc0340184c6771f4d0e5a3f9c7fa2d382716d2298c3e6029208c50b3e73b32dd4a0af8dc71ae9e85fa03c8ec81c56cf369eeb60faf7f9c04f8a053511dc943332018372729fd368840b925e73777a7f177018ae09ca095ac19eb84cc52153fb4a61384cc11059f62a2728a827c5ce390b280cce72ced14df6eb3bf2edd9892b42a384dab92a9e47f84ada74a2588d73a0e0d645885a81a08881bc6da7b89c48a16f042e18b07c12069ac97be7bd49740a5e61e918843d7ccdb41b41073670b798a61e7ec5126b60bf443b768dec77cea7f0ee89f921f4e20807f58037d0a9bacda27c10c385889bac0a0838a6ee245f69be64b956a368963d4ee034bae244579a5023b7f34a1c9eb63416204ea38a52d240a0d89d6e9ecfe38661209181a88109daf73e3e0d1107921c9f235e0c34f12db0134e090bb0b7c3f579e3e05caf931f31d3ce2b905ecb39131737f3facf5b26f4fe7e6b8c04c84a014864cac690f9189fcfd25db6f85b133717b483263b4d36e59f34b3a3d9103922c5cea5349db183e881c3ba97d0e5091b27a9eea32c62ff8bde0d526c633fd08dfe2a581d9f764ea896c77acdf4e0790d942b9aa8993ddb8e923e2d6f5c4109361aa00579472ddada7bb82390c0b8eb651ff5b1bd2604fdfe5acb6c4767ed8e057c01f34ae6772e8e8b23fab3cfc661474624fe477f4960cfeb884fa353983725b2b2b4e94af1a2c939f8f24ab8ee7ff36adcaf33b46eaeb29427c57c49ee3431a027b635433ee893538a2054db5641063858146a0f7f1ef039f70c0ecff47e31ffc53da337a302aec793ec52a2c510cbd57f2521645fb87a4fde6ec2af2958d13d462747a9a5a86fa9fa0b99fef00f829820fb3a38f2a23c4e38a468be9683ea87429b9abadc38c4427cbeff6b5ce6db791fb633f888a2ce1501360d121a3529f1e5e54070a837c9ca44efdf4667d6a7f2f235001345ca372c6eae26857ebe89973aff7b17edaa29d05af280ef3bc3bcd378f90d5cf7ada6955dc5ea75070af06b4b788d39f9b05668e3413db5eb15073d03f8afbf43871f6e0214f9b525d374b9f72c3bdeb6266c88c5c92779b2a27397014158985ccaa84069a064347df1c1846fac4d170318f5be1e5eb56cc61985bf5243c3885e1cc1449ab69f31c9c261a61dd8a2f0559c7bcf9fad0cb5ec185b3c944aeba2a9dd3b8cd83d838d3ac641599a72c89034ed58d113348ab64adb0d26554cfdd40986c7bf7e1f8ba2db85d7d5d3cdc49ac9e2f989ed13136a3f01a7ae460786347a082a347a9454141c718000c458a4c5febaa45a8ee4bc9eac82f31602a47c8c13d94be9e9cd3e741c71a6e2a90687082ff2ab3fbb5cfb09d95ed954fc2b02dbfe41ea90b06cac6a69dc218ce6c6193eabe4af365c0271ebde7746d47474c385541a698baff630a7e91322a6e425241a5686d6f0a21333fe0a7e87e1dcae29fac9545859b7e91c23ad042df0ffec48b03290a4f78f080e59e3011f13c1325dcb1af514eb19cf4159741b4befe620486377f5f8b0994d19991199a327825d5ffa319f852522c45e21683e32bae8e1304b46964562f0944755d64b45b8e8ada1ae86993fc95d9aa179bef28e74c30e2983628a85a36f4796315f514894bc0fa33971c25bc3fdef25ce4c605d72fce41993991b62f35b74d2c6c9d91c3463a35b3f384a57b6468f05c63e06b711cb34ce621d7e989ed212026c83a9d71d8fe6a211d7205f428ec50ae048e60651cb8b776b75a160b2ec371b34fca664348b5151b1b52a8fcb352f4dd2c264aa13c0f973c62a28d39e031ca875c1f0413cb27369a495baf622b519082946dd111f3256a5a4b316768a9d8da1b9e6606e279436b4db6781f676e2e51f0035944b83b796c4f4150cbd94664161873cfe8a8be4d6443f0aa7e048a08ce2f736e23df47550245c63c91bf0c590b3832c9acab6dae5ee7bf3f210175e4c9461f75c4ab93d425fc63387697c7d70ee5d9a38abbe986a676bed2fe4d2750fec5607418ebd0cd82e36d93108b9a8e55c6ae0fe34dc6bda482e31799fc2b095e332279b7dae068c8af9b01069cc3d1bcd928c1e3c815fe98e4077aefb810e66aa40c471f68375e60f8a496ba81edb5692b8575d7abc8c0b5a955dbe6ed69c7781343a891a59671f48287f466ec02e3bfdf9527290d00b46bdd9f84dbf3b703e55b97b9f72bde3b1dae0f419fa40c0468fb727e090600ed503a0162b711f23daab2d8027c75801e12355686594cb943441b088dce43c582f53177a4f119e97c02e9a3e6155204199c80832fef00b046fafc8b1bf4f56088ee6077f6e73981ad5a235adc22d79ca70b5bb6c3918956e8d27aa39cfa1876680302a58584627516896c36a2666db867f12074276f985ba1267a696603ab7aa25b2920b204c621ae740d77a143b0a95a6d264aacc87014a0610c1e92a695daedc44192b7c893b4c16aacbbb9e12c9c3f3e722d617f70f4a5af6df88003aa8f037645b70c9ad9802e788223153dbc3b115ef5ebc6eb1f2536bc8c9fc190fd565150ef4b2f46b79c4ff7aa256d8943c626631a738fa1eb6e7327a281b7a4bbb53fc340ffd8ab47298b52547a04aaee5d1106c81a9e9fb1b8ffc16d8a40d0bc83650e42485daeccdf108f363a983322a55c7a5133483af8609d56860e1ef5c78fb75e05636a90a3641366dfa081d836a88e440416cef8875504a3c5147ce98cbe05528a1e8e229b611e3bb1a28341e47a196931ae1fbdbba9a92ceca542caf4db7ad4a7dc99a58ab8aa0d24bc1429162bccdeb9cb30530b9e5cd3ad4d1618cb29fe3ac0726c71ffd4b19cbf61e1c8e3d0867340e6ba57340502207589c7dc237a0409bf1b1fc6520b372e4e6965bd5def18342a8e8c907d2abffe08e5860ba01de9a2edfed52cf2432975a3eff07bf3679b34e872138993a4e5310a2b1fe5bd48bdcc481a8bb4143389bd73a7e7816290b33b9b609301ea29380fe44ce498a671954ee342e55ddaddf8d2cb15c4a3ed82ba5c5165854dac4f7fc82f82c37cd77022438a517fd01628f515e4c872ae25d8af1d07310ae848c36651d834fe4d1fb8f68fdcd2acc2bb2fdc9bead38713e9668b520900f531cdfd272ccbbb1b72e6e677aa66bd538c4f82eb3a1d5d349febd312dc577458ff8d397c3d4883e21c8f6a30cc0918db0f457900cd49523b067973d599de240ec2cc72c0b7ecf83c1ec4e1daeae01773b839fbfa7a38d521d75e18d08799eb645917a6aa95e548e0d19e0fc516b1f962da368b9dc33585f4c6243334d721d31ec8e8066cc924152fb52297aa3099da70d27aea79f482559c47d273d07673e0be0178d90800bd57e979095688ce5380d063713cbdbcc91afd044aa169e49483034fa0b83effb162071b9575b18da5aa792310210cacd5f06b5431d8392813aaeff41b4b52c0d1b8a0fea18b84e0ef542aee8dcb2272744eb6d44849e0a1724120f39c9ce3f5e92ce72f78cd9ded2eb0368dd331e215a619e55ba41ba651779ad324bd55b3eec020df8b3c5bb073854edc765d2cb7b8626506cdec7ceaa61338df51e137d69575a91e9d3f9a3a1bec997cea751080ca195b19483ebe8ed1ecfc2c7af3ac0b33693f105a12def795cfe64f0adaf2c2a8cc04194d6c88351fe077f0d10c8af5cbe57d912203632bdbce89cba418dfe6a2876b287bc5fa8dbb21ea4bc167b19c92973eca612694972d2f9321ab8b50269c3ebef7b3310204942ab828a2087744b445c042eb69383b451454232fca11d333426ee9d234af604529e7899048f6a2490ed8a78faae832d20ce3f3b31cd1c08eb816c8654822aa6a7e53bae05db4ce2894667a07189ece585c684b0d66ea7f3ee24a565012eb132af3686c9cd777fc9deae96c5347e292e239509e9a0943ee7e2a677d0bede172fa9ecc2f940e8038c7e04583c1887021f6a8910b9bd40bc557f6c729dc6df6b170075f0e2df1a62225ee0ea55fcad3aefe7c68a56f73408fc718f0d5a28aa3ddb8252e50fbd6986788d8015e365dedb90db8873317fc472f6530aac84d869974a0cc69be77959a3529836ab2cd5ad13be0b7b99949ccdbc320cc3b07df37f784c5e57f4a1fe5f38e3758cde0743e07c7e419d97a26c9f2d0503eb98aba575e723ab0c22f97c7320c950f9f2ca8af1208814f391d1beb29463fa68e3e5fbfd035b745477ec012c51cc8269d638689392a2ba7e658bc84c5bc8d0a0841843e79795bd323fbf68259b0fdda0c5c952736c6f6ac133f5ae4d5472c9e3893ff81473ba53904506a34640e3f6b5cf32719923eb8200607aacbb821d97fc6bc2abe0956773d1f6c6713ae40cc0a806360e838d5bd9d515ad6424a6ff3fd04618fe36bbe06ff8ea461fa7589abaff81ee8d4507eb1abbaeb771043d2989acebad62c6be310eba069e57f0269b5dae895e26498b4b14bae39fab4625f31739611f7b6024a43316c223fb158db6b13b87b21166b7d5e6f7606c61a433d7d64a173c696a39ee79f5b3b777e20ee67e9f01fd73e2ce587bf0f6d52c77e4ec22b69481134d07dbd952217d3e835dd220d595cfa7c24768dd74c8a79e63391d055e1aa9e8ef04d0291fc594d8cbaa596df39fceb4bed1ea6a474f4550e15e377f9c21a6eb31a97c682377ecaa5882fee86de1b854dca73b0d9233923796d3364fc3c743ff62d94201cf0f30c5cd2370a7454d73489db1c13c76c5c0ba8d18984cc1515e005d13aa83f23a670fb62650a576f4c9c298357085dd8d321660a689aaef300024440ed6206be6c034dd1b63f2bfd5e192e592d1793308e2d64096bc57736e9b4433424fcea1120f7b0f90cc1c30d507e6215a81913301e22eb1cea93af7fee4621a287a00c2588208ec024d5196ad82f34a8317457292fda110b7fa235a7525e758365f56738fd180d5e1b48a784203e0554f30521a834e837f2bbf44a7db6b275be2e2d185d9dc7ed7cde7478ea523ec1b987edacea7de36a9728a8642729adaa35c093f22ea7aee4427e7afaefdbc27487d06fb836ca7c7944ee6d0041cfbfc9634ab6e2ade2c13a823cf00d603569a3d0c8d8b251688860e9e225e300ee3b5699d0fc69afd6e6a95292304ac4152311359429853824dc5703824eb29309d5781aba626ed73337dbe189629248a99f28482f4157be885429c89292ba5ab7b718c098b47bbd57928c8c0a1261602ea3e866d3113354b00127b2d4d123dba66bbc728f7902440a3d89e9c4a0ce39b2aadf6df50dca410d5ef42e3c19fba01650c2b1c3be5c5ada3aacaa78f06c4f06d6b4bb887818dba24ef35e48df618b74d70cd5f32216b07d68eb88c621a148fca0df027b9234fd6a8dfdd5c31ad44d622353730af211761c518058c379ee52fe5e48250e885ae5d70175d768f9b13e40e4067bd75632c2ac3dded4587d9575b98bca7506061b4d270827ac7fd859cb75b3ace21890ba35a4d0a69e4738beb255d10192f64bc13ca2042393fba8398b28c59ef80245036699da8fb95228e29f682fa549c4637b8f2276250e923faa944e10f947d7a4a821be89943fb9f1911fdc38b430a3f3077a4bbf5a8617e34f2299886a9441466cb2af85765f404c837861ddacaca14c32e31e5e5bdcaefa9186fd774bba26863fb2b8becf7253ab7ba019541520c81b154fc9fadbda940f61cf42169cb27ce500d9f0edb6f3dd8217e0af71b662e4426d2b3b0d7f37e935a94d17b8a4186ed544d6879ed22edabf946bc3a5f4535807f7670c007d52bd4f466468d947138ed1a847187adeec84108a1ece2b01e184840a2a24b07fe60cb0de83dc76a4cf99e3f4fa5b4a34b340fe9312bf305363bb8d97ed4973302585c773d97e4374d0e0d5fbf208d716a77d44d31497f5e80893fc2d044d48f91821264968f2d9f6f19a2a3be8421f4acaf6459b455e5d76610e443ca66f9fcc659b4304133d5414a8bb875452984ebbc5e703328864bea78478a5ed3897a296b0037d90d151db3f79c19c64f14adfe8539a5463e2548236085075002cfdc6a543719dcab52f9c71a67015aa0a0a295e5838965a109e79b2975158e2567c0cfd11e51fa9d3ae9aadf2e1f9bfc76a0d4968ae2ca1a2f90fcea9689578b8db443086fc17ac09e411eb0c25aca4ea9c58fbe81ae7c62763d02026f1c53048fae4135e7c500b5ebee3e599e29a735abcf5e8ae43be4878be066f9c37f96c727c65f7d525ddd273555e0abdaad4a84dde0f3c27ef099b872421b1dd1dc53879270dadb699adf06ad37c533aba059963a73dba4ac9517ee9e526a47282ce14e9de4fb2195fcdbafd5cd7be8fc008c198ea2f2c02536cbfa0c7d9a80280ac6fdf6743a28956477bdd874a1ab2ddc4a6b850ae75d5eb9a10a5a891562f62eb6d888b38cfe879a45efce135cf1397d004fc36a1a1809255c85c55140a610900de2a9898dc490df6e01c189d5dcf7338e2851455dbab25d94fe88def9aabef3334ee4a1abef1bd011b49c733da7bf1cb1111038889c82039cacea16ce858002eeed57ab682055cb78a514846c29a8387c863e49e31bc7c0aa4e1b83e52e1e40de5e3eb52fa43d61756022e82b26091c2c5171746ff28b227f119080392384a55764e35f50f1518384cdde3844d90da4b99eb4541679e6d063eebd9b7d75885fa6d73442a94be876ff3c8c45e67a70e9947993a756a445589a46a3e06bad3434a89519f71d3ea63c8694c583420b4d498e899637102b137e0e30f6c2ee779584a9655a31bbfb3838ed5f0184bcc8e1d74282245bf4eeca888ed708ecd35316a74bb29979996000f90a6e2e68d6bc75d689453be5b9d13ee6d87bc647f52fe98c51c1950dbbc015e70be8b4f80bcc82da7d5bd0dd9d29f4726a793bd6735c9e56c7f3b233e490325c5ee23a66441abc2bf3968f4e712f115a154576090055a53250d52f0d16536cedeb34e389112a25b1a0cdd0cde0eb101a37dec22546157704f411a7ed00175555aead7f0da932532adf7e8512a3dd3f5bd911eec74a1a2acf8fc699c43cbe7c54490b88d3ec4f4cfd08759d58c27b380d05f28b6d215afdc7f79a745dbe3553145e300bb017dd2f0a1d8bca99b2a939229c68cae867de88d8a17dc0d26ffd6440fb183516b384fcfdbacf27e2d0e6fd05822c886f872764ede37ac1005405f918b590dcc916089fbdbfe3266f7d0e8c453fb74308a736ca14e46e04e1645ada74309ea90cdf9e45fcc2b6b80fc9e420dc8cb90ab4f4f83655345fee478cd8b020f500be19eaa8ee3e741fadc57a06f81caa08204d5f98356eb94bfe786eec711683f89a047d04a6ea3217566f3f25efc9ffc39362e0dd5e37260139f13dceb699153cb33a16bb246ae99c2cc2ff6223b309ce204384bb946a06ff82c4ecdcf5b5ab0e8cef268af51d8d4b9a1a46565785c5095071e48fafa3875e2c297a01b04b6b8e2bb56a7bde31d60462e1e4e28e4dd360b762b694e17c96ea150339b417c6dc70166bca55cc2639a71105366537b56d93a81d1594215b46fd0d13c12b099813f5a176849660b686f5464995050581da69763eae0871cee2dd0576b62808af46b46120d2d572d049c2cc2cb90cad13860adc57c5160bf3c1265ec28f1741a5631ade49c354cb05fb8bcc2bda74e625c93a4e5a35d52f48de12b4475bd4da1e824207d520942d1a684f4ed9e6ae958faac307fcc16013c9075bdc351d7daab10d728efef4dd1675b94c4d0aab920afcf7b86461da940a8856be0485a6dc2ea3d33e246d8003948d2f0a5d439b7a8727988d3471fe89616c69bdd9ed831eb19ed9a95be1d2d77d6970ced3557cc0ccb5a0def14171f84d2e50cbd4d6c0f36782089041fbe7af430408d1579ee94a443aed3cc782a96dd1e8e6c6460b261026f4d41bba4f93a14a18af6ffe9830f2cfc341330626685c17b10c592e7e4df47027db918bfbfebbbfacccce51177392acc77ff964e1698a88166408d18600a6220f3b47a97665e2d451a2e6a65eefb6826fe9fe88d7585177357aa4cc9e27d7791bd1763f26ca6db1fb0d1b837a3304ab5965ecb647f706d71f6272977bcb7ceb8e2354db9ed5bdde25f2ae531848fd707f8f0ba7adf7f099c7a454dee7f856ea1c31b06d606ff97d6e2454cd366cd78bf04c6f22c8b29e440f9017c2d9181253d76ad9017c0c7c9f233f404c97081e913b8310e937c9eafa57d53b85d07447a81866fb17855c8ab2b8781466df59733d46a4cdb4472d77cc675bd2f074d9dc80d7b06319f14f4462c48cb6ae27dc625ea8f2e8ec99e9fa95c14a7b0619f82a1da97092b2b1527b77aaa7bf222358e4012f0cf65def2a460ce3213e77513c405587614418f68e66e824874803311df3f999ab7f404f03c9230cbb6773e8c8c4cac9ca0c603ad1c453633f902161170f784ba0f3313e311d89620cfd1fe5c73967012b81de8d1860266bc739139895e911f38ad04664f7ced96d4394630d4d28d23e40a6acfad442ef3044ea219504bf1380b1202b044e85027ba2f150b832165e90958ca59940ccd552aa7a092cc85eedf8077c908482494faa30d0da37ba05d8f12d69a0e0d1da25a451dd4720f0d25ac863a3d486be908a1d5a17e35a8aa0c89a0903af060da1efa8ec99c4065d726a22766620feebe9e9e74d7fb2ff917a279ab3e45ba2f5906f8d55d518fc00370f112a370edbf3f8713fae71fb2b2621786c335d14a49f338e75b99d6e514616244ec244a66d9e25dc3794f4b5bb52f92e42a309af3aab04ee66987a8391e746df02c286aa1005ffc7c1371e1cafc120eff56494869567b6502166b0293b089f3066603b042679cf92fffae2ac317fe16bf4b87841b23a1767558bc9ccc70c8d050ec6ddded14b9683fd28a783198366175befd99302c25a4e886b5f2de63122df975a704e1bfbf5b97696f6905cdd1b2b2035814663c59039b23ad60a8788b6816a7891e68bf12f2e299deb4b401d151425bbb06b4005d4f8c6d187399adf053163131fbd744851aa9deb41bf1b199cb9db9051d13350d9f75daf35e52bcd8a79fe505fafc960f09e54f554b3c2c55f68eeee845e9c28506c543c7fdbd95211e55300f1aa41c2f45dfbf337b2167c36313e879aa8ba21ea14e38da60284fb37e68eb58fd5b57a2ac205976344fb91e0bcf15d446bb32d85f4f70dbb6df52428289a5172134c28f8cadebe84984a4a6c82017f34a780611531e3e1a491fea603c54cac59924069ef6cfb800d201266c45eccd40e93adca972449c8a6672337b2c254f6e1e1adb857845b4d3322c6376406da41e0c174a002a13a5f0738123ea8218a1ca670d87f1658d0ac263764c48e23c3065d564619e05a68632052688c552a6f15e77cfc9f0652cd214f9c0044463460fd4b562031d842da2e40f58584614e896d0cedec8a69f4021aab53b942b259b39e8c42ee3782165f4dc43acb1332fc580fa39df89b55ea0f931238a557c5b6d88ec93291ef0eb721ac7d7bb33c74443644606699822e74b32c1de3fdf2530cf44cf1d12cdf76460be0cf8877a50c075648b7303eb9d911e959511b026ef40f213b1cf5f56fb3bdc44b66a49e4d627ce35e7e52704db1a19fac9350fdaf64c6acfde2c9b0633e8ae8b6be2ff36b27ac43cac1cb2515220e5a87738972f325824fd22e6b7f8885c69e3042b7191d61b004364d89ed3ea65a1ae340944628a3e6f90c4aa194bb33730354d7711b16ac8cd7fc94c1b6589b151e3e0d00d25346654c9103b9de31166288828e105e0ee7b56dd7121542ec7c0345e9014309f9e5f86dcf932b7892805d856171551ab8840559f3e7f0d24c63d900163cce1f65a5873bdcc6546902a1957a68bc1407b7e52e90cf120ca87e05d41831339834858ef80db09fac0f7ac672761bc048554d8f1f9d4a03020d27b1af27e3b2b2f981af778ed674edc8165745239177d9613f72d6e5d65875ad5085121fa920b6769a6824485b8a73352f602ebb4ba36c452beb37c52f0f6a8d9fef3778f531d8ca712100bd19d36bf71ba14dcf2c63060af9c3d73e58dd67da15029d97a6cbbc746a84e8600913b1320f4c86dcbf278dde947f9052c4a865af96426c0ab3629ea190de96cddf59552e86e151a200c5ce043535fe10adaee7a537a9cb3ebfeefcd0befee356719664f43f6fce44de17865fa44b430739caea90d49129b841e6b9840faaf7bf319c6b0ae631c28764c719196f3454a2619ff5db129616ccd6ea684491e83e2ecaf26d1a0c00203de21af9cef4509b79961b0c3836889ffaaa7eba7fe8588d691276461612240477e115add24f036438bbfa9d2aea987000cde69bb6a72fb2dadf4aa66ebe3892cd88c34840f1e11f6d92a55d90306dc44d5f2fa5810f5f76c848d2d07ad793b66137a1a9026e338aa0c29d87e1efa095773fc58f4324c506bcad8c3401bffab14a606f67dc5bcebe14af28a5d94c2cc2a112a4ff156a2a901394fed2889d0b1f2474792900dc0ce619cb9fc681d01065484a8e21402476a1cbb48ba9e7ff611d969f839b9259aad21b3cf08f6522a2a72fe6e246a9c41bb2c6a20f28341712ac448b9ff69a352bf0331921932c4be73e90d063f543644a96f76724abb6fc1c6ccb2a141a03b506fcb8ac4cf929ed51c084ef662903b9704100540b55a488356dc7f082e1f0975556658e008b1b15f165c7619778e5c9d8b582468fbedf8b4473b4b4f175aa128ac47f7ed8b81530b81123820f09c5524d56b03ac7826fa3df532f89b110c4fd818382b1dc74dfb5421dc351e03231a3ae21aa500a68583a769dc4c29e6254e13616fbb41c9315f02c13eaece9710cef714357ae4ae8ea14a27adb6332847ac19a906a97fe12f91d367911a4c470d6c7ab1e4778b3d915a93454a7e4e59bedee0e5e5a14dfff5a3cb6208798fe22ae54a128867ac81f9a4f452808111459881a02789f266b838cc1fe7be3ce8569d2d8385fa19449c9884342249dc2d6985199a74dfeded4ba3ad0724308d5bded47e74ddf8cb78c1d4ef631c1fb143cc168d1df724e697bb7da3b8bd3afd3dceaa3cb29d1c2aeaaea024ae9b9f529628010f8afc4130f8e3287688b8d9f2a823af8a18cdb4819bff816ed0fa95048cb5c6ea13fe848b468883c41a09f17e37cd1d018437d1df080f507c0c9822cec49734568e78bdd684bef6b8df10cde6d803aa8e45593e8bec39a1e80127a239975046f1b19c6c6702a0e8070eae103cfbd5515faca38f097102d22b09525c7a8aff0054f77eebf5fce9ba00a226cff44384d256d2cbf646760b0a421ecc25aa96d1647649435ce747df8fe1933272f44139f2d2f37cc721e013015885add011d0208d0795c3607bba3fe1127e3a603539c272d62708d52d2f37d880e3726b0ac55b7406c1aca5038d450eaffcb31c88b71e91104bfe90190e03c50dc485131f160bcf75811115f3f57a3c12c12fbcad9a25685004f81b3e4e422a6101282afc7c3028b86197dd7dea1a61b5cf1575e243dca003a50930cbc517e7d8538606233c32ba37f7d8928aeeb5d7320c237255054409c105c2f75c3c60a36d7cb7a1632b3353cfdab53d43d73773e9c36c5efc847e0a819f2a340fc9e49907797d535e31c8a651ba480af015c98600346e04a2a97aaddcc2aa47af70d8f828b86f11e1cd4712dc4c46edaada701d62dd9924d7bccdef6d304be2a85656e12e175b76a6f353d8f4c6b0a941f2351f619c5e5740e5d9aa1dccf99a2b68c5d50f3ba8d167840e3faaf3b1dc4d0ff979d8e2b090ec916845229d18725b06f597b2f2359fd06593c9057f1e8a8cc475c0e4a3fe745919b721ccca99b888e444423c3a1494559e9345a2a901ed7096db378b5127447a31c518acb7fccb20ea53b613575a3b078b9b5eaf24b045f4ab110d996eeda9ec15d1b7bf89f4d548347849549ef480ef0ce0bf7ccab20411531220a20d3d77d876e105e02cebf2f129e906106912fa1be7f020c99e30d35fcba4a8b5ad342a228531d257ee47b67bc45398437b6826913abd58048399c490e033b07a917075800359e6f8949060e180a35b7d82574152a1e9e7998391f6ddb5b157003f17ad50c40d580ae3fd5a320b30da6a9d5213ecae2fe8215f7d0a26acb85f0c772d5603438a9d0edc7cf420c67bdac978d75ae132a08e518c77315800db2fa4c52871450a2f44eb94d70eb3eba47c7a28e910077db28a2ce404a29a9130c61bdd24cfa06ab6df2d688d7bf5a5a8859098313a4f057165e8dfb73fb9abe802cc8690a9141a6e5dffb2f508720ba006915f471ec2acdce5aaac040438f094b0ac947786e4360e5135cd229fe811520863d45128bccb41413d17d32f97689a1189964a009e0caedd78e264a2341b0481e5ac9414665501bc386e657c79b371a736205b770a67ef25174176893a0c9f2709e14363252a92ec2e10918a8bdda5dd8db433e0241a3cf1062f064b534a8c2668dd5b7dd4b2c1878a9f9c510b55d2c990f819d43e438d8e03c75ad39ddab498ca308bada6d51537826ca755870444b49bda83c51b4edf6283850d3465a46b7a5918f296c0b5040934dd76874f376a83ac3bb74860ba07ac7a00b267edf2638dbb85cf293a281fe73d058af830aef9d87c0170fa790c7bec95eee2595f64471993171aba06dc0180a89a2e29ddb6674d1054186e82d20d4f8164e164b078ed49772b78080cd5b955ae49f7bcdae20e45320a4be59874e7f591a37b46303563e99274777271316c9006d44737d20811ad68ff462d7cab94318d33e936fa4cb07d1a5c3d490c72e7e411e18f0647400decf95bc540b27702313aaa60c21c28c608930ebf40d629b7608a4fdd962fe78017f0fb0bd367ff2b258af13bc4d1e0b7d625c90d0213cfeaa9331ca72a1bc70c910deb150c0f5574d10324b6c5b09156eca40582bec81027ca271e4b21d1af2a4585b337042a3ca8b8cc7da9d808051db1ee8aa1c938894e54e2d9e2563d4a59d467e2a8a357293884617148c947c58a7464ccc57470228e7deef8e70146530069aa49fa23975f9055aa6b735a27ce4bdb0783afa24a4adfa493e1543ce6a567aff2226ff3b6541860ca091171a33b7ca9f4df459e8903ff845a9fa4d87243810d57d7ffada6bb8f24d247cbb36db877df7bda28ead8721b3ddfe147185140a8e9980631625bcfd8e55893d103a32e0adbc6877e28a3aac50bc0e86c65378cd44e0d240f4b78566d92f83eb0992e984cbc4f286aaacca4d6dfae22dfbc0f543425fbc903478dbab3343fdff9a94336f154c06127f43db2c87d3b0aa52e3b20639132b56bf01d871ef98df05966afe3cb60c99d0b4c785c53480e5c6d5bd3ed563525cab0e6ef924a158f2eff7a27323fe8def7763762a41d9b92c8f5eece23cb596efb5683a44bd490cabeed49e87ffac64e245a3e310e50547fa21a2922e67ea2dcbb9df44828a9af319771338945b16816bc0cc70a2d8ebc166d4ede75ed2028af56841e943da9e4d0d5dbc7520bae4c0de828773fb53cfa4ac80d920e1ef9db2216fbe7dfd15777833e24c35e9f8a8d13bf9e11e8427e5d2c791662e4c930a6f22f54e68538cb310bf2f85de14b76f7d2072a4af3fb17c5f4d2184ab904ffaf6353615e06ecf0c4c83efa8fbf4bcc6e40328abaf1403c7885a5dab800f2083f4e7a0d415bcb8101e82050a2f3329c82a3ea96e98888330d5e9dad3926189c03e8cea2f5283ef6a17c8dd2e40c8b328a12981b867596143b095abb6203141e85c623d48a67ca8107ddb7b3278d4aa0d9e2618f7d9edcfebc594d5c8045e8e49668895f1b1f54feb519a6d3d2cccc4e8238bdc354c92db4078995de9c5ce02d49f608516c7c4b4537a2986db55369f12b72b4a5114139829fcbf10f08b777b494fbe7b5fc6c8c11f4758cec291b9905d25ed3863514fc80470f0f82f129bfe88c28fcec4333686526f389f26cea3a525fe887cea7cd5d4a70d44d076711067639138539097b5af5161f67cde416e75ce085285474e485d1d59e2d003bd3c778a78b023c7b1387097dfdbcfd6625f16e435748c521ea2a4f452de0dcc18bde63533bb837fd213265c38f953ff8fdee911abbbfdaef2df8f5de6bd9f76f56fd72f1f2398b9aecac4e32e2f79541ffdef3105fd5b296705b925af93376a68972bd882ee81e3f4ffbf60c1aeca6743664f0ee5133fb38472a6c39f6317835e28ace65e7474e99465bc0c235819ab61ae6445fffd0159f2bf11da187ed9c9cc87fe10b67319fa6bfdf630602860985ad4784a18c9a36ff3f52a61ae28b21c9feb6a81e05085eee3d8c6cb9cf893636e5d1fc44664b55f1005f35b4eb9ec3ab93c4a6c01926c85899d17a437b7c7bd745fa2d36775c80597d43845884747f52720bbd4d9ab2129b120fb5d222908af7c17c68453bef0544646bc9b52492b6d7851837ddb1982d42c6a8a0a735b8a6ad9ee4e346bec0143619dfc1194860ad9861a8d5a477558952781b84481085e6be1765160240e26137f9fc3ab7fa7f745cbd8e9f97561953a9c02f9fc2d6a3c264e2096479106d956a69088c54d11655246cd93e12d4b810c33d930d9524926309874200a913b1c2755119f3461b39fdafd86d726887a8b0218c84cd78b716a55e10ff5764990d0870a58df4a8ac99ce847e9d9b5a61d1eace785f2280f460481a9501aff644c28660c685ed057d65f7465504273d4eaa5b3864439f23b1cad7489e5dff0cd567244eb0e49c23141047e6336dd1046bef4ff17e949168a21df1453a62a2101b179e2fa1acbd5474548fab837d4704d8328ac181b4b37f4e491b9d6c6821578fab7807c8d78642eb09535ddf778dbf7e3c1a8174a7fd3c86f90547da5004f371dc794a1f6cbae88effca0a6dc590d4c3f4b31c245e40e4d401aeb20609b41528bb8af929ba5bc4003972594b65571548e264a9af1f6eeb5c8722654d6d81b4a61aca5af2c42d5db597b8126a1276dc860342662f8228c1a0cd2f13c0709c6b8ec68e46f894ef28c775ee049d4daa253d8c78c2c2f77adaa869f68bf5c2b83826c181ae59b73954f131f4c3651d7ed0bb09d51f5893565574741a1c9e64394510d9c233b5128a06a76382daca3e18b778f8be8b2febfe94ed782f5baf445c41acb8a73a65ea98d8820823beac0a50afd1252a8641fcb8800c2e0694e185069929b9f8366450920591506b440b95ff6d931b818f6c8539c125a3032e493343c194fd5a506e7de9717fe8b43888d657d63bdfcee3bd19c3d021238c803899fa60d24e33b5c8263c434c44336a63a5b11713e9d748be5db1de927c7603757e127e912abd8fd42d3f9b6ddcb4ad2327462d1964cca8bbaa28ebc296a5de7746bdf516e82bf3065dc0c165457d3845258a6d819350495b2d3e3c303961eb8ff2460d9794845e5494f731c49940134a64fd5dd0a92958eb91ca13814d0c4ed78ec0004a581231438b66aa117291228abe2f585ccbf634e63516db435671f803ac3157005de9908284cf932fe373d18a8f0e0277312d5c806b4ab5f665153399fa7e1278f3d5a8eea451ed8c5d7d85fd4da9d70af5762b763caf15a1c0e7dae15779c285ceda55081391b4e35e224862593d219ec2d1835022a713958b709ccebbef3bd89e9d6111c6fe3a2e5c8d04e9485227396fe34fbacc317cb738451562f292a12ae42b106f7cccc1369990b95e5a84dad998e1c953177a40076759502d224128c2b9ea43c984ed1dfc09b6693dc2b4f1b8e399cb3dc1ceac3dbfad642a883023cea85913966618ae1648a35d4f4b292833e63449e42401fde88ccfb66100d462c9cee7ff211da2c09d26e453b499919936ee3493627ad430b2d9667016a6e94a65cc4c46a7d90235cf4a585bd552abcc841925b3b8b30b46e3cb7649c738f38228efd0747e7ebac029992b97c52654b26fd0cccae9e896c936025c1ccb9c4005ad5213ad1afcb13e97a60681bc50c0519bcf70a1c1dd77590a2b86788459a47f16a97909f78dc73770ae5de15a8364bcbc3e35b84a64e5e26d857daf71dbdfb5a55985579027e7a793593e393a33e22aa6959641305eb1227f43937b592886c52abd4eb294dfd22475b98e3a5b431ac678a2bb10f9967a02625250431087e5d13e4333f6c00add16799dd0f2943a1a68b032e7804d4ba4cdca1c2df58d927e122987c62091c633e33f5b133dda892b25ce8bfbfbb7520e77b4b6205a5cb0e79342f928f65420329477b4eb85c1d876368726573bd84d7d16c08351f793f935eb6fcc615d6d4472e7f6285f9d1727c6ef889301f3839c179a7da1159cf1ad7d3d4d576215e8152ec6fba631113dc69c03dcb95e9f8a06ea97f596dc9ce39658803a35eeda7880deda2eca4d81560dc0b80f943842fa54e81d78b2eb8285ee472368c3908e6c29a822421d6e434c8dac773a62e8237d5a99d2dff0fb1a805a08bc23bf9c737d53199a02e7f9ab6728433720fdefef05a79659f9798e8436fc634998a6bf77a0921268dec01a29e0ad821600066705cda322b0942b6a5fde571a61e0678d80ebd0908230757f6142129ac318509f59d04041249c505055e7d62698c7006d610f7572f6cb1a025124cff694152481f4a062a7435eb76759c4c8c60b0906bb8230e1addc5c45fa645e1b0543e1711ffbbec4468b207ac1ab1a20b54ff0e79a9412044469ed2fb5e1179d92e24be3dca770398f794f6f5ede03d79a7108771b1d886fa7a997b41cfddf52237610ebe1c029a8f89bb211554a488387298a3c21fb0d40c96909558920b2d0339e9ba249019ae390ffeb99b7cdab6d33a392de967400f7f024888ecbf1115b3033c948c52663a79e840bcb3cfbb1d20d631fd4ff50db0f3a745bf8a98c6edf330c72eae6f61b93ac97b93d6f55359ddaf76d3eda3906ae0e6ce2465a0818cb55ef155389602bc8e4757075e18b7269a264b321c00ef58f274f599a77127041754133c5891c58ca66c9e671e7f465a4bf7c027dd1f34182d9fb153816570f6f40e602cb2250039e5999424c738698471cde073df46a8173569c6db0076323ee137b5164db77c1a7acc560d77c9177401520fafa9413bac9e23154b274c6023399fcb301cf901099bfe0dda78f8fc8db75765d3a857e4bfc5cb79295cb13a7a8c654250f9d6cdbc7a326bc416eca002cbceb30f4529d9dc36d7ca90788174e5ff26af9a45764c0a9655f8d8dc8458c4b2af0a92d75f33a511554ad465cb3ecdfbd45eb2a5e91a2b74f51cd9983bf92bc2d32b3d4e034bab0479304e559e908305fa7add04b986404372cb39033d9a164695ddcabc884f72108b6d30239d4f8434e53527a7aa8a0c6536b86029bffb9228473df97462d41de9d5838d02f364d2240f2ff5046d4c611860c8bffecc35ba2550a2c447d14185bc09ae28bd59f2cd1969ae4d8ae010feab22a71f5dc4d3cdc5d424ef1393799ed5ba1f23e33cc93cece99bea6fb93f950b377abee6c80505f0cfd23acbaf5117fd54e5634e5bfa0a1f1208eee8dcd096706ac748005d7c64ae940dc7d72fcb849f142ca3fe936e72c84d4d521aea97dcbba3a74a099a8a8cffe0f45b52b09391413883eb161da7c38efe86989974d059c9f842a7b144f0e168349fc571ec2553d549f0de50ff478fe5ea0a24a0f106700e8f56ce22daeed89574087f7fa6b634673eb54980022c68aed03209c423a4cb53a81baec9e4b44f91bdae3006fcf61c9d661e4d9b342cb5a614a10a2d8fefd473c3ad56da07179083be44aca65bd15d999173aa933c1daa50258991f1cab2efa04cbaaa273c5584b6113f6016b8bdf79b8ce3e62fd28d540fcee28bdc640725b7ca1448d8fcb7571e30e91f5a6ba0b23fdded28858400f370178722f5fb70538ccf202e6beb26d81293227c3b651650ba9d8f2f3d61acade1fea2463b38971bae63298a6cb2ef4e84d9c8f21b2680d495cf2dae338cfcebcb3150ca238e2fa34173d5c6409bacf91eae00dc8c4a906e06f86a41ba571961e79634d0ddf4887f9f96d291e3da9aeac649266762213a347c88db941d3519249f661915bc24e82fcb0faabb0bb5ac30f83ca7f1e826e9828e7cc1bf480e710d66cdaf124e1bf8a214556ee67518131e4e7bd54527d50c3e1535cfc449e8f5a45768845093c60e9b9628c233c92bfc01747eb181a64d165776d0b22ee13418fbb1a172986b3a20a24dbe1165a637ad3e990f32a50ca8818493c062e1eb4c40a562ace5e5657cbe31424ec248815330ea675cc0a291ccdca40fcb5831a5b7fe5f2af6a52bad90ec2113d19569fdcc3ab1f045427462610610cc211b83e8cc62a3274dda7c07faecfe5a94a41686afca89513f265207470495e741b9aeae82690ea82c3c57d854766f0b825037652e87902eb676a0cff77cce229bbf0f5f9fed23aad95b55c13677ded6cf1be087137880e06bd0cf71b8ed39ea289a2329a98f48bc4c44d4c54061da9f21dbcb5776ae3bb7a4b7c0baae9ec94ece7ec8a7a8b80a19afea7da117b641964c94b9667717175754ac80d26002f3736e1482db3fc840a5da348cffe13308c22a43f4a11dcb9d0800af0b7c20d4640ec0b6cc2342af6490cf3017a6e518a198f1f2290b11ec50db7512961467c6fa9ec01e841a5b84fd1ae0abfa5e6992eff181899e142a1662e529f7a4b96c2aa121b97540aba5ef9cdd14346ad3c166c7bd18946a2fd8a2e6feea7e5238a2821dc0059b6078120b2f8cc6dfb65de819224593a4dd40cfa811a210f8073836ae4e1da694e72e342718e7dd355256323c11ba386bacc59ca502e401e3257f9c2e060ae047dcc4ab0325a6088708a6433a7fc00e2f0beb063b7578b381001a8a711a98a05dd2b591ecb05b464a073482db1fa11b49d2c68cf71825668a3ad87e2521673128cb306a815548d5e1ecbe66c0f74e426c55e1ecb0e12b48ad5e5b1a44b4280f10aea59d290e27059595e92088cd523fa2db62275624fff44773993fcd116cbde923274c58b0ab45e32c1546c034a158e6a5b30145ea503da7996d0e7ad34be5c6d5bb8cb595a4b27a6ce13003b19ce0bd01fe258834645ce122ae22511c5161d628bdcf0f801e33eb7bbde4ff37afda35e0ad72ffe8f269670e1bee17d834a7ffce22d3bc8de64cbbda54c29a5cd0683068306346421ef166a21168a21c68f6b70842ab696953f9439628c514a295329a47260be0ec373c498715877c55239b8fa67a91cecbf37dbdc5870dc8cb9c17f3e5755d908abfdb6b586bca687e8526ef69c150041507e45a66d69c2f9f29fdc04bed56ab558469eb59b80f06b3748e56b3fd3600ac71c2a9a48434b46488db33538f252fbe79459651a354e3885a8475388adc110f08f5262526ea80f3b15b4dfde533b50bf7d9cdae19f6ac76c55ffd9aafefd981fff07aa92406307744a6e668750ca47fde6eebb6973325bb1ea550c72a8e1004328575709872f0870021cb2f0828315e011c5ea2ae1d0831516ae6931238cc023acfc35e933c3a44fac4a9f137b29a7c4a4f499c9a86931238cc02b50c6cb74333191b24c37f33134326464cfbf71291c8ce2994c866518f3fa67c2180e4de09fd96233d8a20eafd96e2fc60c931ebb3119dbdd1d6bd9b1bbbdbb1ba63bef86114497c8ed5162324ab92b252633e93353aec6a1c2f82ea5e4dc93acb56024c7c86566d8cc30cf231789612d774a96f24377f795bbcdf5203d62188661f10a0cc364c4aec062160cc33029b12f24e65fb29c207ac430b98aa9ebc36b5ac76b5631468c433df699e3ac0ef73634d98732aa8e4dfe7ecaeb788b07c4f3693048bbc03630b02768ed058bfc30293b66e6f828c6e9be7df8f00192c2e19f0f12d02984da3239ce2eb2931455c8b0218a183728e151d49095e090430d798897542e7ac9e0f0030350a81728dde0440d99b5a2640316a6a2c5450e95f9aad790c3912d9d53dd38eb423ba523575653829c4471648601c81083f8d188961aa7a89186276a0cdaa1a3e1ec2a73d5abc94436654a1c894804612938e245415eb34a35b4acdcf080238c948ce0e086071021a186b0ea55cd902a90f88113c8c30fb6a042b3ba493ff052032b66c8c28a1c9470c08245d27ca6a25543a6a255b51857a8ff8186f3851c5c23d001ae1c1274d21a657cda3851a671c08fdfa790a08cfa55fd313f7bd487ab1b9c4a617ef6d9e4388e7bcfe9e7487051ae598eece79c9aa6693eab99fdcc661735962dd89666052e622b9b73c3c9d628616b74cd987b394aedd63e7b02c2809a00cdd7be0423ba757e3f4d7ae6633f7f9a842a28a002592cf505ffe2a5fac854f91a90f50522a06e7ed38b64585307f303bbc5c2d23ef38f88e6a9fce5664212babdf64a4680e021b2ad2781f918ca53f9d7333f95fcf9cbc23e55f62c60d9639f4a3ef6cb6221fbf9f3fbc1c01030f0e243abc5ca3e955c96f6bdd7f8d70196401419b1921c3c3d0a68c8454c1e1134ec22958bee927f0c8df3d3386110f971510a09aac373baaee1efd81917a7d59d3776c7766e5eed0760c188d3eddedcedd47d77fb6777f7c605c70884b8bbb179cec8cc3122f18845cfc89c25c6e8ede8e87883ab78459432fa17af702eb6a5a9dba0968d3916a4ec97de8e8ed7fc40c71b5cc5ff188966dcd238f1080c74a87119290284225b106088224e45b21079d2220376a40b1aaca06c60ca860021635ad18e6e51036ab5c56be3820a27451732c0be90a2b58ae08ea4b80a2353617e4f5061607e12a930325ca9300f238503a62b402af51bced4144d4d7d4c7d11414da5beb86a4aa9e5434dfdae004449b16d3475b3a9dbc7eda79724eaf67448ddbedbbc58aadb838db3495f0c31c56e4e0c153930e20b220b787531c4c58bae4ccd9ea8d9cf8c0b126c7183c5f12e1543610b2432cb22801a54fff954c593106d26af0ac39c161796640386618cdd4036d920a59472092c5a920829a1c54b1750aca0b224d960050d590d65862c0d01ac494fad17528d3f6fc4f5828b11473380410e929c205a22882d3ecf2cae1ae4e83a0d72185feaac68e8344eccbe307e3a4cb5205269542f6848690c61894ee188af56ab55e428c9155c38f1e2cac11169440a58b0558c5695115de934ceb2fc38c3801ad2744982290b23598a6accc2881a93862003e84ee6933927457129129465d1b8e0500336b9f81024776c119471118286a804e362c411d762cb0e2dba48cae504397486147772692207def1d4e4353bb9b84068c7109c3a224e4a337c914a32801758d440802050545da519ba0ce0896e759566d0a244b5ba4a3334e598814969062230f0efcf565d6f6babaea7daefbad5c398e83ed7908584d846ccaf8c671e388732f3f22fe77c42f40b79a96e128c2fe4275c2ca5eaf093da8c04887d3c8277016d905543a061ece91ccec2d33898098e3cb1836e6d79c2b21fa76c19f6d987e9c4784171c207c21996a19ef63bbd2bd49199b7f21ac6da6582262ac60082d228652c21b1262645998c22d98c61034f4e46f2d46234d1260a45050d5d028409456d44201ddd8004885ed24c9c4a07b93fb953739566299aaf30169723b99117c98d932104c4d0122a538e9870a9182ba80161f63c0df2c8fefb917d3c7aaef037ab071acefa537ff007e9d8c91a769e4a61fe8e6facc5afa381b6a22520e2487b47b96b8ff25ef02f3a2f1470a0d03930dfbfc5878109b30f39f662e488607edbfcd9f3ce87931f11a5edccac82f13ffcb587e1af3dc752f3b28f44f40b7a16cc47157fdd4cd7f46b2ba09d1419541745426713db3eaf4725102f3e225ea1eb6d6d6173767936085a4c4822b3f79af92808ec6f0efe52330cc3b22fdcefc06f7ce9c110eb8ed8bf2c22d4af07a3baa7ea9fb5bf393d100790e62b4b284ab08c208a96111c69ea8fd9dfb93144897bf8de434b69410d57df030dbb97122d980d70659a8ef10f7908480fb53044c92eaf0024862f08d78486eb14841fc837d72de58361c762a93868832cd4eaba2a46432ca12449c9fd8341dad81bfe06ec092ff8172f3bba55e5d780bde1da5e07ba4a4f05fff2e5cb97da5f03168c2ab8cb4f676f646dd6a921585986d2b0d3b0659f61588c40acd1b1280463be61e9004850595789071c146009edba4a3cdca0c30250578987293c18d5f07b8ba416282dedb3e4ea4a1e1ed7d5de4041c36deae17352da750f32ce32b8cfcfcf21013a122833aaf23659a0c7d688cf41a8dd3132a7a47b60d82cb4649bf99918638c3ed1fda36ec4b634616caaf2b7ce3e9084adc19f01fa518bd2b2d758d3b44c7bceb0d8621b581c32c5e2f45377b1a07c192f624af582f2851a477bf911091071282e699cf9dd854ccbf862c47c5e44bf229814d71f7b0b68b8efad103d1d373c14741a94361290e0cc1cf584f9974dcd999cc9005b835f3ec83632b7c1179996b49961a856a2cdec51dacc50dacc309436330cb54ccb0ff3a9df1ec59307745d4f4f4f4f4f4f4f99cc27e38bf18594c27ca1cdc77ddb3741d000314954326d8d661b315a557e7cb23596ee8dcb9f93d2ae7bf94bd953f9924a83724a95ccbb9bcdcfbc179c911a1c82ae8dec896d645f346a2eb6067ff1c9de7c91696fe44b25745a098c14c6bd029aa0303fe3e5c72316274eb1a07c39e38b465acc17dad0afd5cd2902a500e8ba19f12bcc179960d080c6f7efcf8be44fda715e94050909090909098983268a6addfc4c3ec641937e554013348c46ad2a3f1a21b9965e4c325b63a590b115e4394258f2a390e74496fca8240e7d2c8a4d362858edc7dffd5412908f3d0b8e7d404d7a16c85f7eaafd88b25f96fc653dfb11ed9837a605195e0bfa91f7145846c0c2753ab51ba10723f480668b369a9d95820842d0d09f78dcc96b4ad8010dbb656f1844a914e60ed8c5485cb4af255751d1f217c3021abad04e7b933b6571269dd76aa99b406f2667a55ec8012b21d085804cda096d8dd49c9476dd3fd8af55bffa1583d7c407e235d1998aa6a061bfac6c4e347a6d0dfe4e0ba5c2688a1a7f33f21c9a45a3ae24ac3cc799bc26fe9c9476dd3f08ae564c948a100410cfe9d7cbc90926323de938adb2803abfea406aa30353e3529eb3d8a1a01da0159b6c036324f6263e17f109ce4a7ddc44ddc87368c450a1fe5da917a35517fbe411f5efcf3e9992c0b252bf291eee1909fb908b7060518a28d3aa5cb492de6bf7b51d0150824d6e1ba7fa63f4f7e132fe7cb84ac21094fbc17ddcc17d5c887dfc2020e5730a07c7d40a42eac6defc622a05d48ed3e9612e770648ccc004b57db8da334002864bf5a76385d7c2b362df2f5f074f8fd4549ae6c3473e906725bc447e10b94d44aa0c2212878e704b57ba90daccbc165a537056290456aafc1b8db33ea8f25dd8c1098b949ec2812282c68a83bd0c8e2ca502f6330d764464fe3958056eb509c12a69c815133190f27584a046d91648849478108251015d25212521185816ba94e2b81e68ff2a0931a9d8af6f18c6428da3d2fe3114e771d8dca67c2e224a3db37e98c5bd4c0ac7fc28edbec33e1b50b56a50feb2745637b06f6713e1075a7fa0d8739dcf2d240d2a69500a3528352bf46bc8462b603a66a6d0551212aad86fbcc92859888d3c466a50be00aa501551ea97c53dcae3e9d1625640e3b1044d793dbc463ee7f98842c36daa12ca12757e412410277655f9233f062168b84ffb1d7d7808fb9529283666a6d99b1eb21f7d4e4add6d36a45bb338dcddbf0f40b32bd95a93d2676262626abd8c3c92e80ae1fcffff9f3c74f0c0e44f791a696664907037604c1d9fe051860e51c60892cd33e3d91926a349a49991e1646a68e641c9b0e2bb86a780523495d93c681f3a7662f849229c4f413334b403ddb523c4483bce42317ef3056f194e345c97cf8ecbe572b9a490cf8da741973b0d6e41c3e9e2a01df6666f76d9fc4960760d13dbb922ac18f4536d1f4f8ca7458f025ac40202e35371d1def4c3c0dc97d0033ae39391c105c5d88a3e1e0eaa28d58e50fbed53ede0df9e5f48155277baeba672506fcbc2c9c582f196a5793cd4200a6c834bb027f433d1fcb888461ba59a4341d3aa54f854fecc04658287ca5f68233343433a8310ff1ef9df4f93fd7afce3f7f32384a948912d32d4a7715a1c0edebdc0daa06117b64610ae2964ebc2deecd3b08d0bec09fbfb855bc57ef1eb582816317fa78f7eaacf1f3e5ba54a75ff1117ebae52e5a8ca67cfbe3b85a3b32cee0fecb97e347aae8ee8578e4a49daf863588f9f3f9583ab0f4c642a476318b61206dd1b8975330deeeeeeee763b4de7d90467409b06411bcf46468ee338ce9b7783a1eae158f2632592df0f0858d46b38994a01e3662a076bac699a37350fb5715b2a7aa738b5198cf0054fe3540ecea3810395ca81550e47f584ea0ed55d9f7dbdbe70a91c5db9bd49e5f0caed8d4771c0487130606052746fd893c1d1e58895c66c31a8989898182d26262666c6c46431588c8c311ed3311c7302bfd8c50cf38446514336e2a1d496cd07206088edb3623cab8028a80ba7a7713819266e18b8f2689c6f4229527f884151a4d07c94204f9e2821c5b69cb9a0092b4840b97b70c5513061b27df49db3bbce93a06d65a3fb1d25879928534cf041fb2c15666ef6d2ddfbab06757a1ba73b7e389d7a7737b66f9ba0057dbd48e04e9d3a75ead4977a0f9c301a5a52d42038a345431eda6716d72747c4a7c9556471c2a589cb15c58997902926f880fa2c158ef254c3a74bd35788c0fbeb4a297d77e3faee7e3dfb294a09ba27ed966977386b0e58e065e7c60c1d68b82e1d3a74789d0e28ee2e82b8bbbbbb5f5ca675ce3f7ae156d9dd940b3c4629dbc4141d9d0f596989a61a3e85120528dddddd1d73772cce06fdf7c6bb2c8d954d83fbdd206f3bb3733132d6e43b8e8a7083b92ba0fc73ce39a70735f161cb8a4667db2fbf95ced3689075a46c273c8912585c477614bfbb45a8abe4a40b126c9c34dc3e3831738f06f97d70f5f1e17e0f1f3e5cd0d91b7eae09ede183db6edab4695d274772024ce5e70f003f9290cd86ab2c450a17b91e9888a0438cbcb8ffc18ccf04e59e8d836dd7e5f4fef7864a7bd8a250d73d46667e0c8b8286ab1d5f89c2737431f624185058517612d0fdd5f2036b4728818222e2729520690853e4c95a8aa281aeb866239818824a08945c69024915282aa65eb3cfde8c42775775f7bb068ba06b43164e51fc553d9fe09947d2753c14c5a1788009e7c46c2b3498f1a8c094ca39ee72a171f6092447955f5d7a340eadccad2a4f20d95243bea18519ba204de1691c6e41e5dff53929f51b0d12cd5fc5b430c405f2573ea2418dd3534087a2108edc5d623724e6ee2ee5638ca57030f67247e28e64ce22a8ff7f838d6152a83f867dc488e66373ce1857f06a7a31755d47b4f1f4c47f148ac79c3c3c5e3d0db644794124cfc67ddb1666af6def1e797ad9164476332fc398962512ebe1c2d7e8f9e8ae9bf3eb71a3c5850665d6c37d9cab2138d3a0fc3ace5eca28d4ff553bfcb3cf9a48fbe8691a57d983cb85246bec065b92b610996982020a8dd31f3d09e5e6666460cd38a9410d6d666823115aad5641336040436e794f31826469fe6ab55aedcdaaae68cc0f5ce980ab07e90c82814fc4cb781a3df6b71f44dd403f05ada599a56e0a0dbb89441123468e8a1c0d79e9ffd93ec8d6e0efe7c0720ed0a2096d203e9e0f8fc70edbe8a0da3bd9cf148e2835ef9be1ec695a8a086ac842362d90866090bd41816d70604fe86f4d0b7a544316a2c12d579cdc9091274f505f3c61c26408131f5e0d2ecc0be8d72a3289155ee136c5cdc1beae03f766569bc69993c77baffb81c61ccf1e11f68bbd7fcd7a57b520e857285f549957a50d7612342b92e4430d509200a19ad0cb01326308fd979ca67d7326314b46d33c63b5d7467be34e360b1115435328b122d4519efc3d07e6b51ffddb6bbfed0dba7dabd0bf793d1af427a18924a954654b65a52a5dbad544b0df9e7a305ebb521e6aa2e69ca86ddb8c3a339a935277327ad0c948a7ce18427b66764e7376dd3f08ae56298f480af56d3427a55df7afad3414aa7bd25ce9289bb398b795ea0d45f57602c6f64e1fc6c873603c877eeb35309e4e08528db37d1e6e40088c944783609bf6dded2814aa67f6bd4429c95dbaa687e74c963b35e8de46d597696ffadd488605fdfcdb8c21df0f9056cb63f3c72bbc6373de6b74f0146b65bef6bc537fec07c16ac45e9b3888b26d93d8172e5663cc767fdf3518d03ae3ea5cd1073dcca3c10e2af47ba401bf0f08743ffcb8bfa908ec77e353edf874b8c2d54cbc22290906f47f65a48c0da5734257980ebf12164b4cc2201ec64fa741ef874c413ea603f641bc4af9d9476fbf5583197ff9f2e54b10af1c0601f9e964afe3ada47f343a67fe8d95ce8e4605c90674ca84fcdd395b4d7ff71678b6c68ceacf23dc205477ff95e76c1f2b995f94b287c7c7f341a1fd27a8d28b51a5b74b489654e96d7553bb37b2ab52feacf263ca5ddce3c6dcf3afb6c68ccaafb33524144e705f0cdbb75e83fa580814a2a4fee8f7d98c6be6bf59669dab95484a438ab817b2f5fc0889939b3b78da41465da52737d84149294992ec411ba4f7424370b9719669869716297a9c148df3ae55f73abc867f7d76097c2574a7174e15fc4b5d50872ff9cb2964ca2ed5ddddf1812f35fc69d5fdb80abae8d75daa1493d1578809932f5f5adedddddd9ff6a8466d956e8f8d5a4dfbeeb92f1eca300c23e6a373c2501a44560d45436b9e0685a0daf7a980a23e5c0939aa3fb42851da2729d79e5909b51feb2fd4deb5cdb25578f36db291826a2d8b14b8fa2f14285d52529ea4a43cd12289249ee8d2c4d2d258c9501aee2bba0e349c759bb33f206ba571c23929dd710ffc81f21361cfafcad1771f6c20e857a41454f9cde840c30eabc293199c407a6bcca8b1f6f311b5e75c7d50fa7df40616e7c7829da385ac038a66a95dcd7c41ff8e42b9621f0cf10b7d364b8dcf9a4fa4b1eb86b74383d0b75016640213c8c8ec1eb19732945232b38c531e716c7759d37380809a00654f81eca380fcaa3032fae7de70f4ecb47f2b30b30068a0fb11e8df0f05546a0876529c862a55765f3c7834b83c1adce769707757fe569b06b7f31aafd9d75e40bfbf705d2b2846825acccc2c9955df2da9115d59798286da5f1bb1f7d0f323a4e74748ef7e1c04ef0a614dec8b086145212cd5673df1e5f7133beff66e2a5c5b2af69bc4e54a9dbfbf836b2583515ad92589b667ec53fdf601a558d83ef5a90f889b5fa722807d60830cce5feda7170aa9a1f6a86deaeaeeee0b3f2108e67ae033f13fb29fff237b08ec6826557e33a9f2db3ef3683a677b17ba66f6d042c37dcd6c57270e7a784a32425d2514e4b0bcdb02ca7533b804e599066bd720af409edf1f00196cc006a7084f34039bd3c2fad81a5cf931b038d10651962455dea6ba5d2a7f0536c747f658d095e734c19e2bf77eac2d53d897419ca05ca5122ace2dd719f639b22f7bc9adfcdc23f27cba867b40df091535d4910197989d6de1bdd2c44e287f051a87824ddc6ecb8f908406a8fda1571b209f90f168b0f7b5e2b1e113da3d1a0dead8b08d04ec09fd08c09e5731a0a83a27a5fc3d8f5461bfac9edec67e56ece3b9c1b59253583e494a8202a5698b1042114350ba326504fdbbbbaca40b13264aaa50a7d6feb033298defef1f90d7ac8a05195f7ecbda9517d2ee419d9d16dd8dceb4caa2a32d550175a13852523718fe905570a4a4822e5e18cc0b6630fe19ce9959b675f78f20723d7cecb7e6b01f52ca7010ab7f22848c0f50647c80a2a4944489a5244bfe5c8f80c2748416a10a0ae84f038b653f9ffd1f3e8ba5fafbecfba781c552fb53450985727f74f78695800285092682824aa8abb484117fc1822d4f9858efa44b19dd37c77f7fd0cdd05ed6c90cea1ae999f891e5ade195df8ddce539f15f04959f1da9b22fb514d82f5569d506d45daa61a8ee60e4853f7b8b880921a0404dfa81e2cf0f9bc90b1afafcecbde51ee439254041819af4641f1f0828eb57f64c2a16a26abf9f263dd8c7e79ef8fdfc3451f1c49fc0b2a2b601c58f5bcf3df60179150bfef1e30784bdefa77e59d293f1531fd0fc38bf75a075e2b2f1901050931eedb1073202d23e36f21a1ed201ea63232ed8a7da4f4581f9d8f764af7d3f4df6b517c2eaaf67fea878522f84c57d13150f50931ed473a5c04f10b3b09f8159d803a154fbc1d0335ffb7e7a780dff0496e5e3e535ec427db84da9cfc96bb2af5b5e93cd07dabe16c21ea5f1872d5419fb80fce7a7daeccb1e7b1632ec81e4671f0b1890d7ecd74b610fa528e0ef4abc865b3ee42da45ef29ceea55e1687def21a969605fd1a7aab72f7521f35c84b6dd420ff26a49b0a4d71bd76f77f47c78d0697bf30e2a8fa57c6f622e8462d647e75ec34b87fa5f2f7f2224992224746a4808179b98290b06dc9d6d86609d6060a3bbf79a8a75e5f714531c462c2a47154dc6fddfe432ec291eacd9be12f64241aff16c2c9698855a4c4941a32d2875cc4b193cd0940d3efa618bf947ecca7da3ee637a0dba8440ff6243154340300000aa314000020100c064422b150389e29d2247b14000a73864c805234944643591224318c428818420c308400600c101a1ada2600cfb45151019851a3f4ca9642e3cbc9e9e230c410bddca5922151eb6290133dc8040710390dfa9d5f2ee64468b80d7bbbf9b50c6a5f8db9db7bc1bcdb5b99a8ab1417d21efb8839dd7eef530afce31d0b0d48aba7fd31c98afc201dd4ad87cf68586ae87da0b73c0051f036bce1c9f10bb9d9ca75d0a548cfc2f04b21e143bb30cbabc158702965b9984b789d054b0fe099a6802f25f61e62abbcaea765bbdc3e6cbcc26b135de1d173f2bf57e8fc0fd30dfe28c902297d465cd2c6071cc1711a58b54da2af8dcd35eff98c8983a40eba74339db4b835795e46ed6de5bf7680a20161c46f356cd46ec6ace0e307005ee094ef35939c959e05e7502ed346a00d948eb664b84ea0fd76602d2c4df7c0c0e85432409a2e4ff07d3efac79862deae4ae6633d0f8980bedf9e1d6d4f3f185b9bec6e75b0a20ac2292149b94301ff592d1152560019f0896466a9bc403f9a3a599624420d5414ebcbb4642be8297680a4394efa251dbb909bfb856a465519e302c1d58c73c26f1cd072508acb8e4f6c0de5976b654bc022c0bf059154ec50115f6a43a7fe5d5c351cc885a1c8a568492fc6688f56678ff62d926b0cd78a9db13e0437b320f81ae1533d5d9f233600ba074ebb18800db48727f031e718641a090c8c3051827e9e649f29567b897d1d03dbb5b1bda355624c9becb19a793a07af76844b36b903f3eed7d13bc65189837eb28f5a6ff06a5ae00af533206d9a0b10e636db6ea0df0585da3706480490c8821838ff5b65cac4af862f75ab69fb17df951268f7ace8eca935978cab224883c18b96d60c48f77c51cbd60b0d162becee62040fe7e8f281813cd569aee986fa4a2abdcd66322ea8891ed04b10f5ace5e7bdad198ddafd2634dac9fcbd12c25e01de377a1280ad60b6d78717668c492518025b6363f5666e28537bc547ce8f0b61814684452c48ad1b77e60a60f81578d9710730185fcd868486b2977a5b38bab058db322207ff6c23a064ce0472356f9fb72e5d0769ce2d49b3690636f2adb9e9937e03fbeef0207049a13003c28153d0762e5eb25e380af784f8966daf63e9870d52d2787c02fac858b4c47d6105379ae144801d963e187d1cddfca6730e8bdc4a816e28752552286f7d182c57429cfdc376ef3d673a9e8e43080a275dba9512541f6c2c8bdb9bc08e030479e366609660917d9dc516f60c1694faba7be3b49eed38f89322139d6bbf14204b46ed3c8c0477000be3d3e3a8529c1983019e5b87b7362baee849a4e7bc9e5798c2979f3909288113db26d78ad91258c30585b7fd390efa1a9ae0ca5af938e648e1a06021a961ea51a796e5c29a0eda16a72c8b298aad7af5badfb3dba5fd94f5da8ee00ea751e8675a6180e552e03d9f01cd087876a7bcaa3266fc40f652ff305dc5cb87b22b7f6f32c7d0a69ed5d56baf6924935c72733ec42e7a5342072a5e0c7977645060151b4ebf484ef608807c17baae0cce493f20bd65f20f3d00cd5857f5584a05863760897937d0b04f8ea5d85cf263fe26341e0d0896fcd69d58dbb6ff00514d4cb0ad7cdeaa005bde134efe0862e7ae15dfab73e63d81905206e6363ba1a3475e15bc721bc90e92568481d88b641266488435d6d3dde216eed4fdf199359e04c5ae0dbdf5c3a50de72f2f452cba382b003b584abaab53659757b51f6ccebe345a9ee57ac148f806c0f7a4b386e32a765651a45d14b7405708a8d8c7114db2b1e13cca7e9ed21d465256c6c1a6d0143bbdb3600287fac95b9d13b4cc504ab3e4e5d97d5fd028ae8a92557592f2012afe7990db1b9ee1bca96ede4d3c4bbdec8c979ce08569112729833c93d108d91b7e0212ff9f2e484f03d297edf234fbb4f1833a5628b9a1add0ce938bf5b50b1399b8341c17ef00520c6a10bcdb878826bac303a286e00be168961dcc83115f5d1eff3521c85569ea590cb4da5eff5c2ccff80546487f15e8d6dedf2a81c60aa8e103466dc75bf52c691f731dbbeb9044ffe12da857b36d23007136e7b24f1d3db28db579c0470ca200692ac2a3bbb79abf16aa53d97c3d4b2dcff097bf68563d9dd21be546e641da3c60689db8417fa5fc6aead8d4484fea1c55ab3a2b24b851752fcd4e74ce7473d036ef03a3df503c2947de0983e82648e7c9685b37f8d246ec786157689df0362f91b6887737efb7f4acea4707cae198add6e9e176aae46c956fd416bdf44e8d4ef0c1415bd8e305e8c3b52603186061dac74f078d86f0cefad81b6524dc9e89cde71bcf73ad0db24c805349958a17922452adefce8cdddaa0eb1f553b006e6d8825a41760241c8f45e6805cf5aebb45000187fc99f2c91879aedafd7a8eaeab9db19ae57a65fb9ace508b8253a279d96fdd3dfdcc9ddfa85e0a7fb57112417d9e741625f337ce2a6569362e8f87e159952ccf799783c830d5199443e66c30e0fc95acb1b431a30ae451a56c94e98039899d9f2ea24598cc7b3f6d363a5b6248425be3c213165574a24b8c867a3dc4b43643410a826568a0e1891131b22f42006136368ad666e5d429a28e46473f157e98374559d29223b4a5314c4072e1a8b0080c1c1073a484f09504e8f30264ab5c5c1edc05d8e2f9fbcd4b86be5b6774dbf3bf3c10c51705cde0ccfe45f19c056288801e5768da31fb4d112fb4a0a827164d33526bad5c4a38d966731f36d792f3636c50267a092c5f52150b665896f1941f2d2a6aea15033805ea2465fafdfa94d2450d4acfb45e6c91bc48c2807b50da164cca7d848e8211656ab39d15febff3678c214ae11201b4beb9ae8b5f075b4e17a0b08f1ecef2dc53624743e20eaf33da156f216532f64a4dfda7e2f98be5241c96426e9a4dfc500dce2f202e276d59ed82002528555407d9a8b216d7db0e4c79621cc76579e6cc7ac2e8ddbdf2c1aaf8f263f0002b0410a50cdda8eaee3fe413c1d5ff6c8b55666e6de9947c21b952d650f112abb16af715c9b3525a59415724ac4fd808fdef64de05d91f43a10a36da60d2e847e3694f82686c174a00c84de0207f9ba02d20b1e73dd60fd645372245041c0be35f37a46cc77b83240f882950a6912e1be9de86b355c99d87d880cbeea3426c06ec937927c65f4edf5ed52dc224a3d280714ecb67490569c92db668bb78c7ce42e41e16f28089611362e5ae459d1f105d11947dee239fcc91350de0e42946e0f202308a80445749decebaa4a7c13f634acf318b3b0a74327ef2f7890a40162969c29ed09152804966498ada0e7cc6c2d3c6345647c6f8ec41093c7e30b0022ae3111e80efeae238fd5eb426c3c2cf35f81fcf370fb93155754fe8763d7d32880ce330beefeacc904feb219491e1845e96a950e2523a9e6f5229aa90132d071b8b1e9cba1e29d56fdaca15c0b940731a31176ffcf6f9c3ace50877b5f3e2eead764a2b447442af776799df1092c83f7bf9b561783321e18ff9c82fa043b7067a06a1a7cbeb3a534bf9424a8cd89ebfd375ddab26c0a932800dd0000d53d4ccafc649d8ebcce4a54fad78fbed1f4616ca5b16100def77b8107b14ab05fcfac65f23d81abd3e9a2ce180e3c10bf60352d6b1b460857c52c3210baee9715b94b39ecd3c97e95f5e3dd2d7babb1e6c4eec7fed7c6fa55d5c8b5d615314ef9e36c6c34427e5a7e8fafbc99343030489ba20af84c7c3fae2cff247a234afa1f9592ded8203578b1f80eff5c3a07be6d3c0a94131fb4c10571c8379d0d422eb743a993848abd36accd3ed0629e262279b3950f20061cf3d99d8afb7c0918cf1a045cbb793b1608205c52ab32cb6a89361319f3bbd6b1fb330595552ae19954b7fca5433bc9e413ef398e41ac00e08c220f8b58eea709e4b90f8829b4287a2c770dedff1278a6ec97d1900e3c3e84e35db91841e11c3693f44e867f51c2188968a1a79d24aa8e41ea4ec0b9e6c9080922e1b75d8d3f00dd21cb468cc23204180659cfe07812fa7b171800367e00fae60590120ffba117dbaff94556f5f7dbdf5fd126e3cb1fef00c8893c4f60138f6863fc4278f089e247add297f86dcf4aa5fb0156196639901e183074eda75efe1c40b5a87f289f2e6a21c6213a8083369a1f835b74d6c8741eff024e7f1852c0ed554881327236c7b04e18d495a8e99cb22289207518d8d36e1b0f98522f4b376f0b30cdb1bb326f77ebd949bf354d052a1e52dabb3d0846d2f12ec85e44b32afdc50b8ef43e4661ee4f8189009517b98033f8fba3e58155fa77605fef0a0a04d5ae9224236d0c5228c695a48a67eb09d0c5a998bd281da0115c50d438f19331b42e51210506418e64064d11d10700c5bf87aed1e270e2b65052e98ddb6caa101c20b1a9f57c880435a6cf0a3ffea5c83694f2bdf6caf32e183a2b344ed92d9a54fbbc2d605a78edbc3bfa02b57da010fd9725b69f3863d0a28fa9f17ae66acfe5240d072e48bef1426f375c6d6875d0ce3c044eec0daf61dcab54aa04cd44f97fba40d4d88f30ccd08f26d24db57050c640687a9a199ccb1c2fe058325a4b9b43b3860c6abb49a6f85d4f6751f25fde8eef2241c31844c4bc36a2fa1f3e5867929f37684c1d14abf247ff53b1edc8507c0ff76464b68db3c12c3b5889fcfec2a47d0a35185a9615f8c8be63c95a7aff06f8f3318e5a2141746d8d41363251c386f09f4daa7a391f2e4c1a82583f4cbc73e9d5de5271786e73b2e277bb63d4a27633c902c7810eca6c2db134463b2ef38b21749c708e2d949157d97a645b792db50f23e0969064bba67dcb2ceb7d5aae4dbd60aa3097d979d361341146a7d343b42e51dbbebaa4eadbc21ce0f2815097cb0508c9e3ed6d8fb692d466bfc1edf1b2758e11f00acb397041d9f910aa401c476738145d8e2da15821c87acc3d95589fd293beca5bb9fcd1eea4cbec0db7de335e5fb5249b89a1688d9c40dd884bda315a1e55bfcc5bfb9370a17476765596d25dda2f889b8bc66868d209fc8638e415f0cada750ea232c6a793aa64e38c0d49a7412fe9948f31f867a0e98c026ba719eecd328b73c1f954f0b63085971cc1823be1ef9148c41c38777fa21b1ed374064aac6778a8a9e3dab4755928af5025237ff98b89661366bd702e2f70be7d67a4608828d86154271f9349b02751e0030a4711abdb4799d80bc9b34527baa6a58de8a1bff5e7fcbb71c505560c6e70bcf5c58642045794b7e85fccf924caf469f2e83dbd4dce90588ead3606c12afd46c1b6587ac8aecef66136370eaac6fbf9142d344448c9fa7f29a44320d8f3655847c06feef6d65a2a26bdc25cb2081eb7f98bb3f9feab89c6bee2c457c315e5d4b0c80c5e94b94ce295a31990d6a18b9b4fa550c82f1490a437ce3c90f3ddaca51e892411f7a4eb3648cd332b2f81a68b7a60a87879997d748887d5dd3a6a6578a98e8bc3eeb78b9e40544a4dfbbe2903ec7bc879f51b00e33e5b59defa5adc3aa39e668aadfc08b42daa5209dab4b9dba5d98c6a3f12e00a3c5b455d1506e110050a15f135e06790fb49cc5259a9eb616e600c4d27a279d6ec272f4b73b5a4f8165c2350523a1e0aa69ffff57e54147216c7ee780a0072513c430a29a1ec5ca7cf4ebb8e4595162380a0f77861316828ca47374cd61e3393b36e40f7c9e5111ac710ccf0bd6b0815061820adee301768752f0a759cb219343416fabc042357fd143dda81774a865dba41904349eda712121c5ded7ef5fcd131952c3d016775cb5b61593625aba23d041568d31cc7d4132f8fd644770a4a5fc9deb28d073f225a8ee7534701ba3d240c7a6605cbfd8155b27fc6799a4e1239e29cf110db55ce5e20b38c33b3adb49987dac8a5b877f7d067cbf721d7073879347270a528733971e87ef318d3386de7a77a87a212648f2fd6778de2988508bd9f4f2d99ef9a3f461229aa1d3aeb46581ec0f2ffe2ceb08878dd9c599a5b25fd13a57e698c332135f3707b5b9d64a0da08eae159bc9d605b683f6802bcfef7fab771cad584cae63fdbf9521db0e066432d8e7f17685e5f6fe92abe10fdde2151d0d2321c2a8148d10ff4138f63fb9b1c862c5f2afa6221472d14db06f9770028c9007c426e18658c24f6f4cbd06fbd1a5182c920c6cc4a2a2631fa4ddabd21e786ccb3215e87f24dc2c3159c693afca6416cb3168fb200029b728a23549635c8a8943b69ea89a113f57a448ac548c1dfbc747c8b75d888451a660a47e1c9278fbc5dbab6e843918d788c66ec634af895925d9522e9a060463197d5d80613841827bcc22d714c8643ddd12991da40d766314511d420743b59187815e1b06e63caacb6f673a944b781ae9d95cce0a684611d70e86428c421fa6134e00efab882b4e6e468b2018f6d59be986a198225ad01d20ae21a42d6006f5cd7ae06f67edd443201c274e99e0099bbc47c022ba01c6d8969872a5183c58397558e008ada6ee4ea3e4b80d9285eb390111fbd2a773d5e487d08a0748b5848240edae13de2db1dd3f0a7d01d8a962217a92003db2046e706ad27962f9f8fbc141aef1caaad7de40778b8b757bca3c4d340befdd50aed43b7ac2e1613bb337982884b47f75ba9ea8fdcb1968f939b2ab90f8ddedbbe17d3f345dca2921695425eba9d61b48702f17395e32d24263299ea9a35de8c49fd6796ce5342f1a2d26300d90dc789e3679f4109e7d0fa9963be5cb048786ff5559c5596e040290f1eb6ad1f4df3f93a01dbcf4855514919c2cfb174cc4f03a1aa3dc2a1dede485b16ac3a9749b9420761dd2d70ceaf04f92daff4be6f03834cc0eff37b38177a171804000d5573e2b4ce5998fb296070879f9f4571e61c2ed78598559c5b217c3c7866ce52e5998655c679f43ecfbcd055ac48a81af2ba7d151d295eeb933caa58c9f508c9f86ed675ba20b5cc9e7352208f939a103ca2f164e658dd01fcca7524e5e963ec9ae2517be1f69ba3ccbe8df1f65e565197ff9552f1428b0ee1445f01177f28af03ca6f3434c120f04154990a0f91f1090e9a323f0bae498b91dca3f14eeca78f210d96303343ef4235037418a9f7fdd72cccfe850a6e4c47ca23e4eeb9b6cee1f83647781cce9277b4f41dc6b7793e2b27c4c8c186688da8d4ee1f81f44245a10577440406ed496edfb96ca23c636f75489334a81ea58c438270d60dc8b61b5fa2f0dc756fe9593e623bfcb8ccd5516c906f9672c51cd31cc452606ac662ac1fe2d65c18798f40895d1016b98bad17745099d8645c16016153c11673d1cc2d05d083b08061e66a5a25ca6c07bf782200aa82f36d6e282f4d6bb036938e819df0247060f27a08e80b0fb048c7aea39ef25874af96b7cca606731d2315ef4ffae78280016124b092bf0e00c6d94c98ffc9a9ee11b02bfa403c2a9896375a501464eefe342d519541cb33d807b0ac8036d5f6ccf85f09cd8f79ade7570b7bce9641edd35654c38c3cec3b67022c40152d6d00e8d340025f95bd64b0132ab2925c7929cc692b5fec458a2fdc3817b24876958cfcac8cd4d3afcf79de99652ae9719763e3c4ca6947711581a25062f8bab47dfc0b20c171db507f67df9a22f28ac5ef24552535891fe7fbea4ef15242b2c4ef31df3494dcd720c088bd2cca466198a44f03c2f4dcd9a782b3434cb044e5aaa0f7512ef3dd32d9537e098b55dd33c18de4f24f73f7af927bba3c7915e1fc93a38a5b9f9e993c1c9a17b257b86bf3077a547bdc40fc9474384b0b50d912523add5ecb54ab1fc1e48b7154a381f5203b700616d3a34796103d0c49eaa2864ec9e4b7203bb0a3a100bba733d18e1155619b09619ce756db14e6384d23c2b4764a401285b2cf1bfb32888a1077d0de9f047a9cad26f6fdda22c65b947c521f247367586ba46ce3a5c1ca6091c677e56a5e0b9af919179a6cf9366722dc779ad4458d5adf40f6f0671a3f78d54a2631a6abaa489f9603a82f4b31bf70738f1e64bace59ceae66640f46b6e3f25dc051177594cddb84063883d6c6e3ab2aa3e2f5bddb894a16b25c95970a630e6f2fe42b5c1f11901273876310693ca6e19ed77602a3842f1b2069c01bcb13b16ed80d0342bf3de0b05662dcd10da1f5092a38c5894639a0db6a0e62058b00c53abd56811f7cecf3927fbaac1804853a478ee0d1b52121110e52ab8f2ba79771c864de8a3526f5430ba4ee8decdb81d60bdea0181b56d91a6ffbbb4bf0442f1926b3e8e1e15e71005e8f1a20e27e35ea76cc162497604dfd9d0ed3b542ba8ead33dcd7b830e3ce1b12fd1f0353f1f45eea6d62a423502b9b364ffa6b92dc05bfd3ab1e0deaa79a2e42ecffc9d57647f1f3e01ff4a3a7499f8d863ec7a0593a0ea4d94efdfc5fbc38c996df201f174f0b32ff6e8af22446eb9c2002d4a7b30ac8c6c5d77052bba7ca078af639a39f8a470870e57bacdf51018363cff4233633e5490930d98ae9471750e915d0a456e7f60a3f6c646933333c5eec11aa345457c8517bbd13acadd4bc2773c03ec7652e80425c68e8ab97a357ee35312ed0474bdb5a1539cb22d8e10a87c70eefd8b9f26994e8b3a14fadf39450459e4ad2136e58c5bdd44a861db1d8892c10e1523774f8321dca50264f6fb5fc4578418546975e68332dc42d884e5965be52bc45272020dde40fa65a0f67add422dd70d25d3ed54a14c5618b7ad30beaeaf6d54b9cc6631ba176a3e7ae4c6d4f70a8e92f2b40493da63b7c37a98861d90f29a462a30f5e2c4a7ab9699b0d104b1aa8279e87831e51ee3bfafc1d3358cb9ea7e3694269954ec3e8705d42703d664722059c47c1bf837894ed15e247e23dd745e3d8397cb728204482bdb5c614de4692adef7110af2958dde7144e0d5fa696fed12354895d931765794e2e4c16eb89b5b2265444bd152914f62cea7c9330dcb37f9a0e32aa0a9ff651562924fee39bc24eef1e5189f7bf3efb3fa6ff27c0009890f2db33c298a22c0cf419e576a058afefc0a8fb3f9078cf344c58f8b063a683f833d2d2fbb057f0982b88a87d2b3155cc32223d1893dda8a207f46777e33bae1f58b6973325fb613fe57e8001bff08f219cdb20a9314de5bbea6225b1e781aaf796cef47c3e826c414ca71f0f85da08b7fdce7fcd7613823103f6a17f4a38a87e144163fd8aa5bfb6230ee684210bd70f3867ee4154505b74f00c62aba397d81e42bb492dbbe697de556dd1d33df7de63ad51e02ef888121854a850f93d9a222629591e19ffe309bdb1b9b9fd3eb25dc1df0e8491c19cd6ff40f2b2da332896c368eaaf581c83e8bffbe8416c86c6a6c34de30966865e927895d4b46b931f826cc11b94828737435dafa4f9558dd97b6fb0dbdeb7b71397c106de0b04edc022cf3dafde623e9f5481a6b7502697268fd49fbaa4fdce873991b553d36616614ad0a0ed37805522e4af6a952c397cb54294f4480fd3a06655c15d88f1f8c2612bc696f874a128f4ff25468d726ece0a80468e08a2bb16f9ec681365690b7461db8ffb4445adddfe973b19bad28fef28d812069e3c9a07c36698ac665c9a4f77c57fb7670f9279a8b6fb030739b53fadd4622d9323fe0254f06bb74c23982b0e2525db8b8d0a370cbb062570a2aa64c15210ba0bf5a19052dcb86ec6cd2936e927a013a45fb6914a3318c59041ef1d5ac6aa08b39c0d5bfb5cbc28ac0e7da844b0ccf03db957900f1952c60ccb413f53d801c15bec5d7678fc9f496bbf36cd20cd8068dba111307d93428b1ce410b3e2cdfdf5493d43a0b3a6881b0ee411a0b16e3a4e65350cdbbec972903ef25d18c8470b3b594044766593d887b211aebff1cfe9e2f022a56ec4fd6573a04938c9cc554569f3e8e8d391a8defc44bb3098a63dcc9595f43d73da9e0f41554fc9d7ddc23f1ca6bdfc60cd411ba7d8bc2c4ad05beb66e6eac530df71d59287b7ab247e52d74d27a61ce98a4aed40ade9eaafdc282a8e967e24043f299b5ef2705b5ca5c1b34707c75976d2b0a18b785b3388f8b6ca340a7d3d8a5f7ca1e40e7a370d48066eb8a0a36ec4fd854aabe6bdc8f7431bf22cf31fdc79192a4003ef0bf40c2c3f4bea46609293d7b0e3eb8065a5d3cef62c4dcf053f12c1a857e65bd9458605bbaf99a93b9d987accd003841a32cb60351735979967cfade3c2a8a69aea7e9a0788b2e779272ce4e359d2e5359086f79aa56417b722f375b3477af4d2fa2df811a15ca84e2a2bb0445a452e70df980a8746d658a442415ade9985ee34159d30fbe95817cd58b9b27c87a077b011e5e8b68602533556d20e4d9d057a46a697d79882911c99949fb1d659f521dc3263bcf4453dab3ff94c7d8b12bd81d17e22a144ddfa6b250d6efd11fc906b511fb5541083bff7c71929575ecd4d830a8eebf03a136ece40351c6b89c2ad14dd6413031c7ec8c5407604f4c3821b032b280914ee9be88a57ca953ba77e3c83884e912425ad2d8a15a73b8307a72e696634bfc6b74c8da6498bc9153e8aa15383694d045f325b0765c1ab48ee88558366e18d46010a3bfd5d7595f9944e2e0f39b2e02a2190069f3396bc04d66ea8ee1aa719047a175048150cc4ed6b8745d147f1b6dd266e896c5ea1e93b357087837864f3e88fdc98d4ece64b14a19736483e664f945cb0e38eaf0cb50af122620833064ff7fb307b6f06a494eb6056b4ab3ab84dd8698672deb25c390b0171d19ee6623e4f47b0a9e64b8e36fb3b1abc2210fdba6f3c94138f66720a85be5e025eeacfcb80d75eaa9918bbebd914f998b9c3ef581b465445cec8541b96ec4d9299156730a0bca221fb38421ad31a90bdee4b4a215fe8171f531900830a7209a245b3a6b8d02854410b06289263718fc6d08a492ee5b6a506985ed8138b7e00000c6f4b7ded35e6fcea4f614b8916161a588355a063061c242c0a5cac779cf927a3f88ded44efd55f142eb8be316649e3b7fdb029a23d638abb0f68358877423c6caed110e57a76a051c287f51b87000acad0344270991de63991ab3ade4738ecdf6bbf48eac914086397b7032f61f483d83f535ec19a4e4a5eb3bf6dcd1efc4ac50de291e9a8d2d3f99f6b812b855ef641ad9ac86a9ac6336929de869c9ca0b6e2bbccd1204dbcdbc8dfa470f4742d783a92513f4a0cfd22731ef3b0afd14fbf05b5329be949ee4e3fd5d76c59b5804127cc1ef2c7ddeba106b33858f2f62305dc5b75951c395f3bf0f1cd4d54251db70a39fc6b631065f70d83454f6b5517ea49055b491cb0ca561b16d0ad241057f02007426e8148d9d4669cc47f38e1948816e8457152d3b59a74b315772f5a11ae842ecd978b150c20f336f6226bf0367513ac98201ba2465b9e4745740f3e46a920a75cc052b69d0d41a42c46695c76210d748f57e889dd77c0706ccb7d629a946a12c7c21d560b273618333411114ac4e933bae43c063e86672463710b8b57b155f96b2a8fe0b7614e0f6cc8bc9d76a268328a94b5afdfd134d42c35e6e35c506cf7fecd518e311063c929cee93f701844925b80503fd58513058e7308ba981b98fe5e23ded26918d81137923b5dda76430e5eb6e7cbf53161a160770f28601873fc0c73dd7b843142ca56ea388d8673a8ce160f4908c60ef0b49d2489f225c84f3c208c0a8e719e201801c19205156fbcf6926a8d60cf69d1bd28f65f80893a0535b4023c25d713ce9be17e4c839505320c18c2835237fdb6cc5e124c766e659a17637c6dad1bac49ad6919c8b7a1318c687513f876386da7e77a99c001be4499642d9922ebd3a302cbaee4cf7f5a9bd322e5c5ac58ab0fd250d4ce4987bb213ab5c3e75f07fe0d540b6ebaa8b0f92bc6d84770def2ce2c1c905e4e545118fd15383b8c7ace311869db2e6d3ea488509ac157328547c8cd2e50c88fccc0340c00948899be0306ee576999e31c0607ce173cea4853fb765f444a0d753e47f63d7ea6be648c1bfcc60308abe7d862c68a1a90a87bec1b8b15ebe16128d346b6dfb03a1a7ba90477a3d81a3bf434a4790a5137e1c7ed64304d75e026467be2423121e955a87dfe82fedce59aa263baa83a1da5f83c2dcb51292e5fad1cf24a93472c58160964f139e3242db3f75ffe4eda4825c1bde6ebd7aa2b503bbaad18072ef1aee2932cb7c7d854b2f4499ecac1a921e40c8ffb8e6fff2450d2e3430eb9018f8c69f2dc707513cf522d5734d2acb91f150a9ea542e5daed3449809f8e76723154e3d0c76ee4a656d07df3bb452bfd872a270db53e5439706fb6ff2dd88c435bb113ca57f2ffe70d9fdcfdc41340ad89803bbaec959dfe9a32d8138f176793b6040cd4c54aea0a34525f18efc6523faa6b3ec7e4b39eb491441f6ca53e69613d3418002d92f9ece907b50f1a8e3fe1c77368d05887293770bc692b02640d9e6f36d47c00217f4d199fadf75066f2fac4bd3a836de016d9b669cbb31c41d05a5c8a00b9d69dd8d1c94ac1092b891b7aaaf62c2e7d22766841a3bebdf390fa669791f24559dedff72c32fcc9c97bb9b8b13445a2d4f76c6971daa55c2284c41851629b88fb113f138a6a5ff521b34a845eed5b2904e8f5ee2a2fffa07007ad637fa7519ca5a315b536c909aced28a720d6f2ad62ea4c7b48399d27a32a20bce288e8ea3228ce97967043e7e1e06295159ab85d7d805e01e86f312834bbdffa02a5ff2601a7b2459ea9f030eff49df6d3962580917863f2c89e32c66d68b940c424f894113aeebb6d3e857c71540ae5c9a0dd96c491c43295946ad467902f196103d54a33523529cbabb8b82c04a875546749a7a975320d0c201ee704dcb30e91890573fe6348a0d0f37f79badebef3cd1306fc4dbb7db1744aa045eceb66fa66bb2e171efacb4e1f0758fc77b6aadc819b1a7d94d389600384b3eb4946870b5f9680c28e6734d8111ab4dcab7e56511d375aec6001fa7dcea48c3236dbbb80836ab9b6b5b75f4ec4eebe3d2e8d64c5ead9e6c0e6d98c89f911de90ff118bb6e2039f0dbb55bc820fbf9b436071ae80ae64edf5d8cb85fdb7b7a0e21f02d24df941da8c5010b5a27db34681e704391d3b4d771d7ccb471a303a258955cf4cca0146459c903d21854a91373d06101419ee3b52976496710448db0ed5f4b557f670ed2cf5a763b790e18ee88a8e2aa86e03a07d564a394ca4d8c98bcb2f2c48b9903d9344c4432a9dca485a15277155bd38a0aa3dd34f3b5ec24580b8cea5c45b2469ab8ba6cfefe3e7e639082aec95ca0ecd616ab9774b83a099c0632b4fdc2a23210486dd1b6889c4825e3285e0672f88f93a3481ed4e0545b85fc4ca31a2c584a2b4b0fc27dafdc337ef604c5dccebf69acfd0763c6d1b26c665c0616dee4dee5d2d7b80cd332cf84586382824072d7c3a9a71cf02f3406b7f11cc2004822701108c4636aebf80d2f07e55b38331b4e496fc05eb00ae9370d33720da213a1dde48dc65c94eab29da2268a1eee83c5d6801fbf24152fec6033c4fc55bd14b56223d5c48da0e78559c6f6bb31bd2fed400bfd6da3311e96839a62a3527a9e1f616124751451bf8e77561693f0da1f0bd30dc005aadeec77d4070778f469ea4ba277d38c871a2b8312f4100bdc2dd7831bff46ad639741fb1eeb69bd2130c3a20afc0ea4867f04c80d112909834799749b25333a238a434fe1b9a947110d260bcbd01e80b69dfd408101180aa984e0a5f99f2f6e240e3e8584ab53766170d13100b7c95960d0cd37ba3c85cf48055414c57ff8f94df64caa0d624d36eac6d059f11ef76cff51755531ae9dc235fe0b3a55e3a852e73481159dfb1471ef6ea06f97cdbf859045ff4dd7a89c2014b4d4925b96179739f0724fcb445bc3296afdb13024f9eb54be0712671d94acbddd88a4d27850b90c1ac76a4c255a2aa611ca2d16c58a383f73f86c62b61ef2be35864f9bcaf1a08b9b89a7605b93e6edd011875e7ca6587ef6cd2305199a5c4030c6341e559ff7d4cc87a87085e69dc70c230ca46327e718189dcdee089f7f72581b61e314c3b376c3072d8e75de464420a86f7d64d8245916e3d71fa7b1021f1bb1815baf4f4ceb1eb87a8dc136f17a8130228f559f4637a94295e9d951f1e3ac48c1a9cdd9c26bd407b6ca7efb78206285b7b76eaf6518d2decee7d6895b3d28e6e2873a896b0bdb5b18aa822e68aa9d91f1f5a70c489d5e3b7dd6815adb6482a3e8861cfc9610c1569f967607e0b4685861e6cab162d4ccc78072c72fc86e6325a66168442461eb5dabe01979f07bfaf80db00b0109274506f0476588f7c150d3c6a377c2aff2e08a7b316efc89ddde2b8bbdf26ed0876f478fe224aaf9ff74e094834deb59bcd3bea1e64c7bffd439d85ba11a930c5d53843701821a772254eca30a85cd43052341e72d19c7ce1a6fb91ca23fd3001ab526c1b9c0ed518857d18bbc1e2caa0b0b3a35e6a7853ef283f2ae9a2572d1ceca57b3169313aab34cd6a8d920c2625458cac4d57df04e48bfc16f8b974e178909535e26b965ae2ca251c881a995c6fb6206cee30a49dfb6e91ef822780527430c5ade57c0572e37f43d6a86d6a62211061c1b27cfd824320963cea0bfdc0e6123ef780afe27f4c0b5a3472cae09a9d1bfd5855ca6c6b0e214f2a2dd0104b027b518356adfb12dbfda7772f26ce6f9c98f0e9d8ef19fa4ff34677a3d233c41c0fa424bfa7e34261c39156d7b7328100db7fd1f3242db62172e3371b2735ca7d4e67d2f3b98e04a0fd74b9fc3f555e3ccbd3d024bb482758fd9acf44c8d88bf73105031e162bdb9ef7c2f9c08ae7f771c32bd945a0550e17c00f8c66835e9d7970f9850eafd31107efc955143254bcc9a67ba36013176080185504228c705d0a4e6c7c8f2c1792c79163206efa5deab2ab97b2986c4d8248e0b1368ef585981b11045edb837d014d0110c64d9eb5d79cde7192ad70d86c1460063f80abbd69c944ec1ac1758e2bd239bc49429300054f4bb0368d0cb30213b36d14c4386892fe4d10f19d30e075074f12a507714a853bbadf4f633ee90dfe85fd7939185afc14ce7621cc87e178ac6b9622e61fc09d29554bb5186f23447d8a35e9d36f64b2a0390381677a4dabc577b6dfcd942772eec29d51e1ff351e4cb792a234694da0a8fa4804d0892f4ef24cfadcb93c767484cb52b912a7d4eb8417e19406fa99414cdb410836a53841fe26ef0fc68933af2a73170c7fed35108f01157df71dd1156ccaf6f7540613e8af39196dda838705d60f1ed1a1bd8ad7178cdfe6e9ddbafc2e61650aaec18fcec6193ef860ba31bc6af99761f5dcde3972e45ac3efb17952a1d7be1792b06dc11928f60b54d856538f41ddb6d57e24f53c19983b8518c97e321720cbacda5702f6cb194e83d0a5a3d2342d262767bb78535b96134196546d064c927bb91b50e7e708f01948ba39158744333d441b68cbcb14416788596ce5a2307638d3b4ee925298dfac9d96475727a8e26a7b950ca53242e88bef7dc34be4461c703953cc3c2fece071e8d8bd5a74ede4b271735394725c28f45a3671dfc136fbbd19b37e834663a272b8421fbfc15fbcef3d18a2cc8bb4e9d9e8cad0f9cc75450148377a698bb949a43fa5067270e6c3f55a5f79da08b0c4a9d0fe4445f82b37497837ead2dece261244d4535e765c6f9ba336fdecbd48c75966d0ebd207289dd62fbd4f0e531fa24bfc4791d8ed5174367a2e16a43840c6aad41e3b93e09691f9923283d1115a2b451efe8a527e8f89b1401dde5161eb0a87f676894ba5145f7bc8b2a2a08e69b940d3b9ddafa9659ff272874f1562a2619bd04f93fde11c9648779c592dea291be88ae8da90c6cba989d911d0ab05250118e56e56395f634c2e4d45bd78d936dbd70100252e56966554caa6e51021d605bd76edffd8f61fcd03606f2318f9a408d03a2605117e2591a326f317dff9872b30104391a0a4ad3f54cfa769f4974168cba0f82ba17041a8135633708a68b665e357e0ad0cd7b1caf45e84ab0f1736336d08a7808109210fc5ad9814c1796bd82db351a3e704b5f123fe9f8f9d30d5685d16f01ea9ad21ca79c214d0bccc97cd9556e2e8d94295bee1131524afcd01346b482f17e3be3be5a9d02c7d4dd9b9fbfd6edd86f65da6905c3f45425b8582ae89049297d46363b7f0a544f80f14905fb306bc7fee6ac69ae40e1b24d9811f9661cec821e7df5ef5110f88d312ac5339a50a1c4e35251d94e0befb8967fa2b906744b832845ece13c1f8e630e1c281789b60ef09e9c5fcdef4e543f042d3c058b5a066772b240b5d1506d45adb3e8293d7b247ef76b1372fcb1ae35a16e24884204d62882f78d7bff054301027a5c6bf0cede50987f0b8e7b1fd76fcf72a8055e76bc52bc814310eb2c9f999e1aedb3766178cb05e81ca38dec64576cc80228e00f1422688ae1e7f56c4f6718692f1d7309f99cb2215b997012bed94b2f08d6a9f4b47e77452d50f50557b6e63d4f524439d35f7a054332857595f77b1ef290b42d4c31c1d2d039c69592b8c671bf57275e5bd72fdb56129954bd5fffedbd64402d9cf0e23060656f70b0d0a31e8ffaed2aa6c2a1482662c8f46b11d682a1835811d0095f85b0f3d30bac7b6784c122056d0058ef4406852339d8141a44eb7a01e4b50240b0b16812758d7e2ebf621afd8508bf8f427f4deb467574e1e9faea1cfb38ad45f19932eea0d97cfe312ba4295a37efdd62152ac47677754d0fd71ca9f355274246f366a1e88cbca7970d74e65d9b7ab5c1aa2ee4e950486a4f71ef0f992546bd326236bd1ef11a692f364788936bbd5a039b8e11df8b082a80737d102d88a92b79a8a151c155a0ca04d2baecdc0102699bb10e6b6d978714ad7d07e092e3a5768598071c76e04e187e285c6fc08caf8563864e91b4cfc884e532966049efb50323ebc8984d8a1170f37ff312af579f545ead37cc8eef25a52796100ada781da94c7b4d5a0a8bfdc1d6f7d0abebf4af09c70a1f9e22c4953a05fcfde3b16e7394e2a0ceca462ced744272ebf47d16d6063e87f730a673312fe1f10412eeb2a74f33410c6302bb4c1b86c2ff362fec2ba113538167cef340bf120a35ca65f74bb98ccc92f6e60efaaadd78fd5ac41432769266e7d7591269e4da2aec889a4a51cfb69ed5f66dab4d38ce39d8b380f7d09d17aaf2d36f0b264225e733581848528bd415474cf066a03503ce3e72bdacd10bb94a5ca304b455c1f0317c3fdb9ef75d7857cc4797b1b37cb05a32d05b4a75bf579ff595025390933fba4df0c9c4e6f3e9aaa423a7233167d7d7037cdab0f6a872c4cca02e35669bb252485dc0fc066d5d13b038ea9a4eab91cc5cd1db21615d00ff7f742a6b8a0df1712a3a74eeb38da4dea4a9104f95f3fe8291e355ac9f4355d4426fa57ac340ec7860043d027ce62a152d54d94e5ed143590344f664f1c0dbdc7b9ad532c277d76fabd94ff85b7f5feecfc3ff9fbcc84c294b073903ed3d098c2cdff1b0f2ee17f474af20bbca5084ddfe2301f0b7152df30e6ed3d7f2bd1c49bb320050c40f7c4edf9666fa385b458bf0a6a55b34d45f03fef9f72c2dfba39890428084c51a675c2507dbd760ac82d69119bda9fb7a35d321ee3bf12c589ec01ed324e05f8fb22f0271660972e363313a355f469b380e495de7dd510fc099ad40ebb169dc1a2112be88a0693cf86dbf47e9b81d2444dd845ebcd236e35e9833c08ea364c4c96456e44108264cba85fed342afc882eec2a273e9b83c65c97a8bba1f51ee2f4aef6f07a96c79933ca373ad08592b8f3f8fae7dc427b363bd8974e287cfc41c8aa62f666bb993d92da350fc1a0284524364fec375f98b9a757959ec0934a34bcedac2181d2ce390f79635b6fe0d3a2f65e471f65e1a99a702a5572b3ed3bb71cccea078c5aa020ca489d505e833c853dd155989f9dbd5619f621c579412d7641ebee51c2c548886a8a9ad18a9b4d4eb102e780effe4f8c28ee094a08a60fe4b35be16eb9c17dddfa30c24e98124429bdc06a4ed71919ffecdec856cba0ab2130739d9ae3267be008f4189a38a1d5370496e39c27d8ba01e975b55e9cc7518654c1867193d074a24b9416df456504780acafaf9a033ead10aa18bbc673d4a562199d32c08f0932fec0c81b941d8dbca840abe1babc68698ca2456953b45abbf823aa18a85a35e66eb7307c9cd4f29c29c4ca55f7f9588a885b963415adb22d0f033fb980398171b15afd2c52a8aab933c2805e32837eef01dba94012a18901e9ab0bdcca10eec7da348bd220fdafd8f35ff27f4a41deb57d04cf8b7fc12b4492f401b96724808ac44f263c40bdd650e945862a2ee90f556bfdfc540c4d43e49581460b48ec146ee9676156feda2a23390a03ec5afc990409e48bde24d00e1167e04f8a2c204211599d378c41cf0dcab8364ea75885520ab190cff3b324c7deaf16b367c17862338a1a4955f87da0a1b5da4ec1cb545d060458dd60fce281012f13e719dbc4dac4ca7f052881123ad6d4136d22e2a4225d85bb8333e9d1d124eb6b15870f57f63664961bb2ec86cc7967940f8c92d04191f2f9ea3ec4f963038bb4c36245e089815874517aa53cb20c050d6cbe57380a65d74b3ed83778602f3e53190c7b21819cb1f2168aaf869a5c57a997d9d7cb2b4df98b2cdba73d1d7742bcecb5beb234b00b6a79415ac596378e61a5953c801c87f467669b355b31bd347aadd7f4f1984ddf9d1de95bab69f2393dc4526db9d8feb911a9dfa805b462cdd825a8eb15864bed323e516fa2581880094463fca5e5f43467cbf4102874c0f228bcd3009dd05c77860c34767e7b038b35034bd705967ea781efa816e9aa97c7e93b4bc933ae9d418ceae0cf2cf42e9ca82b4a8b87045d11dd2c244d9eac00ad4897b9b83cbffaf46f91ee00092e0e6cc7cb533ff384374e05609e9192176f7665f938007fefa9750ecc4ec186d6fbb355a974dda7d9d97d1e9d7ae666b5020951f2d56f9885b9cdffb2f1b59d39743aca9ca6cf1988369e5aa6a0f065b1b7b9a1a81e4f0b77c88a87d709f94af9f15ee23b1c25a28cfc944f4b3dbab1f336883d86380bceef246126f0228e6ea8aa1be83992b91d59e2188a3c0ff1ea6a68b0b12480bd52720e6f2e681cae1ad9b98fcd03eb5d2eeac5888d50a71aee9f0387e09b1467ac24b69ff0364f3ee7e531d0f846cf37a4e36d98e1a7b608feaadce873cb6ef24852cb88043934c3bcf28c6488edee100de2c38af1f8b795f207a57fc5be0f8f81bb0326b8c3f738bed181126f103f20dc8c0f4a7a796fe89858e1da184e7676a2a38f639eddfb9b628e8cca1eb313b10946cd78b4c102aeef53e503119cd142093924846a51e32adf82e51019d4b27598c28b9fad71e743d7d2356dc984a544a7e32a79f4664a7a367933fcc25e818369f672734d7083dc68c3ce667afc8f179fc3876d49948142ce28a279a32a48241ee59ef957c14ddb92d327130f14c315945690c21021db1b571411cd8ae6ae61b042c046020301e89080f673ee0eaf721152d4386ec1de5f08ff8893f0b6bf3a665050703231bbbb9e516f057b56040e1e68e139d38c7c00321b648ee97ea8cd62c2263cef0f4da533140f399631fe3b8b081252414d8a7af9ee09989d1845f4c719c0f031a18f96ec086c1b0383b143e7336a910ca8183b112cca18f2f0e35da8d8382f89ef22a47070cf204c7a981b4288f697d4be99e7e6658652ea6ce4d0f91b2827e0ef18fa6531fb66ed5991218f0fae7fc27967abef1868c4aba354227d4cd408b1fa01921f6650983ea133ebe354c19e694450ae93f9b2ca7297bb4e736d8fc3b50868eaef9bd86ee2ef58ccee62917978b3d4d00dda33a215dfba9328c029b31f5f4e8df522ad3cc211e7e0a988c803ffbc812ea5f0173a2a4f907742e408498191b5a6c767cb377870df4755281d5a3ff99ecac9841baf88b09b45ed6ce5c976e4ef7c7f56c162b9098620b922a20c464d1cbe20d34e637f8624deb2269184e9bcd345b88c40dfa5918a5e4798206cb82739e0b1c4e9cb4106039e3b1017129288eb15a09aa50cc0375c12e31fe941cb6918121a2a1fa188ee45caa997066e256c02c333b3edaaac90b8199ce11c06dc62f18a3a51042957146f2cdeb179c8171f73f41a2694d6e65a79c41a2333e3686486137b1906099395164c3d845c06a30d2d3ea12eff1a6da440f7dd34ff895753bccf3130122cfd22873a4daeeb90732cb568ef8771f321d1c6086049765efe875f10bb7839d43b7dc974a4e3ea6b063d171a9128e4e983633dd20f04e2cd64584654b45e938d7ea7f08e527e2bf0f0a5b462db45d89adb7fc61c553ace880d2ca49fd869164402117ac28dc87c5868bab71fc203b84f8210798e72de57ea7de9585ee7f910f4e9ad053bde203cf43640496f3c73443fe4a8915d2196053ac175500e940f8e8dd487e84b5bd9e107b8ab4ad30ef8d69632cdf039e433032622b0c835fefafa45d4f0c41b2233e474107d20b50485da81339fbd20911d59cc7d9dd4bc2e0b47f3b1b3ad42374c0ad08d40626c076a1ab66491377d3627a17b984ac04d13aeab1bd4e43040060903d391c4fef60a458438d7c2fe63ae70b38fb8840c2329f2fa43aa03e562df0e1629abe281f63cc7c2d8a5ac7b075a3c2f162aeb086d9e54b0c5ef6134a5b4db468dc77fc1103a92570c44e648ed4131cc630c4f03e4b2f9b7511420cb4c00a0689964a070dfde5cf9a82357cd17fd6f574e4a26db6d8d8a78142fd45b5575a21447925d7a6256415202a0ccec04bac5a174a843b202522cbaf25dd125310a691bf6c04f83ae6c306b34e697b8337761eb6eff4347c62e9d035e1aa30be9b033ba311bf85cb1494fb70c6f23fe780f72db9c6c8b4f8c8093c516fb6ccb982db2eef75239e5579868dd55643c2ebe773d84b4c3b53feecd86b8ae70ed562cd9e7b4339fda497f2dd35cc8c30014654864a1f5c7568bb31f1c20ed38c947d63a1b34706d01dca23543b96eecd5038aec014d893afdb0179a73e5d7ce0287213013b71d6a2b2d3d3329482c9903bfb397f17d6b511895c0311840c6a055b445ea38c1154184fc64d8596a1db590d56b5b888fb9ddff83c083977a57560821c66414ec6de11f15a98a0b3d853df49d1c8a56026226e7e1e9bb3c3b716dfb864773c06cbd39c5009d5abaf5509955651b9f246d50f64f422887de398f92aa79f5428d4be9006bca81856210b7781ae9bc5ac9cf2de3a22b4197e57a2fe3619569283b606b446cf0422d314058f148917e9dad43265a326e590a0451a8a35dd9443269d858a0666f34150da644c64d8e4745211d013009fe4f04dfecfd7447e695f12454ef5b7c9f3350ff8ed0761ad73cb4871e2d22e6e749ceedd5321ce6012cb316ebaa05c9dbf9d5234a75315ed5df280c1ca916e121cdc236871361097716fa3b35a660fd5729bedbd139ce34db8ab29c177fc656fcff5af6d21c7c4995cbe4e99c75a567332bd842c339971b63faca21959943f7d2ce2e374286bb8d06a5582151850c71fcb441b50bbd256f34a23fa2283909e6f34559605293d39015f52c82df23ed39f8c37e6c15c94554f3a5e7d4c593e806aea1ebbcdd266584dd9148645c521261dd70a108b051d936a9207bb082cad684bcf30d9f36355c13169c3c38a279e2e257dce65d7f8c60ea11daedbbec5ef894adf4044260f15a2a9e4a725805d866121f171f384e666ac0169d0e0d5afa616e58f48c693263559aabfe6ab7dcd9632b481c40770b702346b6148b74b6324cad32b362398b7dafbdbc8633364186bdc20d0881ad338f73b1644a663a7f3c290a1f93f7e0adfeaa1ffb3efcc3c20006b3a4b31cd1f5c3c01db6d2ad1f418e6e78a400cc1e7b2cca06f8a391b1dd1d9bd35de692a06888d1dfab601c37808991d79a6cc5e87bf936bfc090865ec7afd4dd335e745523f8803abb9623d54a3a666d00d9b0353910b30f8afcb836ff7c5ec5247425984460b62f64caa234755d85970bed17782fc7c089a19a544a880b1eebc14c363ee50a9114844eb83cbc19fa662c39d58ef1bd82f1ac7ec5b29feaa1ccd3fcf197647048c8c9791f38d39c58d454cd7b694fe84eb67c3357336af946ea23b48f154c5512c21b227e63bcfeaaa04ae87e6027a380a5b706a22cf853a51cee12fe72e7ca7ec50de09676fd36926998d16d33f539dc1fb59e43a824411497b2ceecd1aef0615a597ccf57709ed27e7ae885e49a9ae992c9b5aa05165db4b1315bb997b4906519bddf1c8976ecfa6af7c9b7895272c2c0972203eb4d96247568634aaa85fa93e304e375341dad0e19d94eba0e1774f4095f3fd82a187049ed8a52ab1ad9422dbf3d9b6a70ff0dc527b19dce49b7ec49a0b0ccdee5d529a4062de19ee1bbd980e6adf3122d599344ee2371b4d7f15435a527b09d4ea3a1f8ac5d5b2df9a01390486a5df421a7405f806e4de1de8f46cc9e137a1b0b7c83ac53e4205ce2e7206cc2bdf39b2164c3734dadcbf2b669fc5b15bdcf4ddba31871963fe457857ddbb8ff884d7b0399ef0c604df356decc4cd68717bc29fb78fc66a11b367c1efdbca11f4bae259a1da674f5be6580650ed7b5455aa49f3ff325f9b370acd31bd359165fdbeaa13f31a64340ae631efcad27eda700bb479aada4654d2a88d7884547ed4fdb5849e2e5974fd7a768d6a740140efb3b52115675ed730c5f8110a6ddb6b884370eff78261cf9ff8ea048b47e2765d21126777f38f549c67b10e06cd870b4475aa9394c50913435a7bbde803d26413ba908cec5550b3f0e1d341e7bc88c15eb715925e66b3840b8d2dfa65045699c60b7c4265fcfe59e7868e6958174d90177620f6e7429744d95f4310320332dde683bc5576d9917c72a4441db07827895c9a80f83b5c9bcdddf1529cad3d7b6d385da6ced6ca54c41058c45fd624ca45acea8d4e8d397a9a743ec6b38943659431c2204d7d180684136a4a3d61b446400d9de162ad632f6cd01b48ee56e0e3b8043fc1a37f38115268ec2e3712c7a263e27853b6bcf28006b4b2f05d8e945242de1f9ac69dc96b5ecb6a9b6cce2cb9e61f4647f9065079f8eeb26b1842f4f26ff31aec8c9d601e2f3d42346b2e39ea550ac438a2292fc4b852f1ae43c67b25e30f101f8baf9b6004e0604e3dd88f067c0fc3f2f39d960f1f20ed173674409b6597102a9f6e14363f963d7ba694e21e574b397d501c89d7cdc1f17017300a9605e662759916c8c513243f786bdc6c5204578db07ca09f7a6e7ddb5418a5838a4d07a3f3b98d9a127cb75865edced017030ccf23633533455c63ca68b6dc2b046797c117199f4e8bcb78bf24c970e1d95f25bb29436478e14b1d6f353603f5a1c09302dc040ec7051fd5d2b67b6cd6a2ce3404f7c8cbb61b1a4a4fb27722638ac0de2f52f20839cd40b3de6c194cfda7bd0927c9e03beaf13d8912f0ebd7323831102f814646ae0df83f72b5f92ca8b0a7d021975bba41e1a6d6aed817e976c5c7f1409fff3f569fd91be85c415e1233be46844f648ade9e60a445b7c6d9819d9272ba4547a88299e87fc0ca23f61050bfabc553cab042091b71d813459328534bdea20cf55de19499be78a1febd20ca5220d90ba80724205c2c79ed0648b31e4cb357f3083fa2d40baba705261d07e24f0bd49c01862379b867cab68c5e68189aca39acaa01de8a864375e2b4d643b1dd73f92a55d94232e36b7525cd921f989896137314a742c402658590ca1f0a0e8233745b5e90ce628aa07c5a839a1ea6cf5dcc0191129022a06384e9852b5d289094baad6e35af4bc7a79237e26b34095e11491c9dae86468baaeb2026433efa38bb1f884db536bfb337e3fb9c42bbf53653fd3fabb9a3a1192f0ddfb08c1dc13283062428c3a3acd7921d1bfe0b6f3680bbd727feea3a06b1d00fbfd81df8670de150805510ccee254adaddb9eeec820375158e95d349fcdb57d77e37e4bf8f220cc7789e8532f33a24195e72af28cb4dfcdc7f96ae906317410faa957a77335271f67a11f06c64853ae19f0eeffd284e11a3f514a12ba681028b22825913816cdf8eb59b488ef06bcb118444a79a668ec6d396171eb9ef03adc121b9cd3436c92c4334e4d811fa59e2882eee1264f48c86a20db05fe693b61a38a0f410cef60bee734978f2bf38972c021f04e14b240ac9fde60399aa406a1245f39b5ebdf993fb3bb137f2c3941327e7b91b54d9ed6b1c59c95eb0d8dbb473b1442af4afa8689b7c958dc4579ecb2cf36253635fac682f28801f37312373147c8e7779b52d9f63bbb70ba58372cbe43411137285a3e783f150ed9b68ad4ecca9123cdb5c1e59551637ef484616d76ddc85151c5a912a0bbfe7e7c98e98b0293f86c5b4709fd1db455d6afd9aaf89c8b1fee09ccfea4daa25df9816a3a06ce1f80a24bfd1eb9f039112771467575622a342819afa2460a1b0d6f80d6ec42ca711d76cefea5fedef7727f85ccc09486a58b542f52e823ac2f34922bcb3135cae97bf69cda06853935ad638d55046894c0dad57c8f44807ea144a074e2fea4a0b8c8cc2dd3ebaf9f4fb863c1de4cb0dd7203adfab18cda6e65c0da14d9b9d0e1b0e6b7e483c19aae9ebdc9caced6937cebd1e2e512479c062a11acf774e7bb8a379535eb9505f4b5e16e2ada1ce92a2e8927067448e958180bc76652dcd4975ed48bb37d425d0811d8f41b25fa6ea00c45dddd20db14b7cf3c0d10b38a6ffcfa429bde32419a6bb69fbcb70fe5f800ed529241314479b428dd0549fafdf3a55ddce521ec03939955a18cb8cda2f3550b4f3d9b53d8e8a9c22150335973beb48fd8d26a367290cabee0094be097d3410a44fb28c9a21b164bad8ebfc8045bd09eec244d3ca8e49cf60f0d8a9e8d05811d07b2cffd7533e5e0e8f2c4631802dd9cdcee2736a142c7198337cb6e919eaf5b8337efc1449a1266d3369992436fb8ab8225c76594dd5e5ebdb0b5962bd9ef4f9e3718ecc1cdeb9f53b494b5497188efd2aadd2dd8fb192bc5bf14b1de22dc4341ad54312fb0eed0f902fce205d55055fefa45cdff123d7e2bade04c8853db7f4195c8c10804eb691d704b96dc6cb93259a23ae23e1c5f1a76ae9fa9de69996040c94646b9c9579f414b935d84d6bc0f70ff037780dbf987c23faa0535b898b4642d5145ae1b472ed5b9f57ed04ad3bdbceb2665a8a3fe6bd527d34913685aa5640361f52e00364de62be7c500b1adcaa92310b880306f5c376d7ae82f1b050342f28a2b54e28e491142604a43c98ab360ff070e6f457e51a37de4537e097b0e3ea2ac501a63f8cf97f3d6db198f673c10e29d21c688c2898b4488903c6f5ac3c4737b1d5004d137a86bb15c0fcd090ba5e42219d026f8d8f2848d31d0f90dac423cb75ba7ecd3700d6065c7b81d237c277d8062459df83d1eab50ba865b15c117983f8e9c40212d6de1e76b189b0ee108691d763d20229c0051247c30dddbdb3a14e4d69e09f914384fd5550b55de90a502db8f81df3d0bf33e8148e0a265373f93b1af792de3b69363f11912d170b07665bc849aba574dafeaed60a471255597ea544f6d5172aa43d3333d9f1bb68f9d8eedad3b741a2bd21f0ce6ab06e6c947b91a090b85c764231a898e7c315a9e1768b9eca83827b92aae43a771b7d1d66c8e844d36540d67adb50e19a89c9184ce7c7ecf955e7caf1f454d75044957d54d498daeeb0dcaa3ab0a5e6f103f6027b0c8e21e30b7279f06c19cc071b98746b8d2c0e149461372b430b0d3286262156154ed6916f0c8a4820dc8562399e971d4a12e89690dab4c8d28b30be170f9c8a534cd91d4277492fa45996083b9333e9078508c3ccb690c3fd423d7fe2bf594c8489e44fc929831bc199a219406885ed5f00b362aa15cc7604a17a38e85dc3dfd092c68038516f208fc452fb4fa88c9176d2af8557dd242c7682faa8da1e730168afdfcce77760de5780615726b025590d92da3051193d013699a5203571153e4be4ef16717c6367b61fba8014a301210526258d14ed6b73d60a365c5338bc60486c92a44ce103f55260c9896a069dcbfeb0e3834e41e494cc4870481e025d732e05faf0936884af1e69632bc16adc7ab70a7f955f7f82adccdf3e84e4249cb3559a1ea8dab4f732a3ead954279720de66a152dd7e6ac718381f84c28b42e64625a040b6de681fa543084d732d64a774653e33588cc9c8e92788725bc928bf4a90d122c4fda2046def513f6aed96d24c363b31deeaa2cd0bbc2167315301aea8a320778ac59a6a9a866a0638f6b2c8192d2d19a5d957bf8cf51036553ac474634416e14bd66324d9e6db380c7b057ba5813acc65b48ce8abcbff74ad0e233938cfcab854af10e0873a8710a5924ba4bcd07b5f1b90a7f8608608215062251e48cdd1f3eddcbb7280ee1bbb873418a12688109dd342dca4a07739e5999988e8883d13f5fc8d3b1dd2203092a449ba500cb1e25a554558d81b0393fc46d260452ee645fdd18eb3c7b0c68dbb87034c38feb61d85b762e9f87362208afec3748291114f64d3fe7a06b7608a0668c95249a704ce32d88c3886c76b025e4e3b11aafc2c40fabe81eeaa142cbfc79506bf292848d26c5e3b8c034e9af8980fe60761cba49c8d53c8c5f3d691a35178c40929a58c0d32889ad674f36d3234154e44f33907290c90e67076c4e8ca7e7dd1250c9e2e1eb010840bd276c6ee25e3da6eae7d8e1910a4ac7a42841ac1545b3d5c144488e3277f99fc201f129bd3aae73bd3c85c32a327f013e3b6ce40ade0819eb831147800b5745047a04b2cb07ea5e461e95d7dae88c499aed0488a1e563fab5da784f92fb4751da51349df5320a9b459125efa30e5ebe0efa55e7152583ab3dfee44685da5a8cc04cb91cb817cf3ee65e22762dbb152cf4dac949c56d4857616d74877b790f203f576995f85e31eb8c94910113758fb0bf671002fff176e06c4a3e2a58bcadb903932b727ab31e3482a386a774d6af6b778b552e07c6d9660d3b416e1c9134f9441b6e1b43a30ccf40a611b868808bb9c5447720081ed9a43df1485b5182e9071175e05cd65352936e2eb53ed2267e83b7e964d6eabeeec399c6432f30104b1e09bfee48ca514cb383164318ef063c8b881b35921c0135a310ca4f22284b9d0aeae16b1c9ee16094eb5e5e827442296f7c533e65235b1e511b31dda7646a4fd2cc1d1b67aa716c32bd896979f4d1fac53426d34d45a756ca25c1b518fda847a511fc3c9ecb3a9b42e2eadacc210eb8599e19f4f7b71e05d21e576a73ab0fdb4b829ea4a3853ccbcaa897b277cb0bca209963dd77517e430be48aaf020228cbc70d6c42e926bc850bd313ba0f424619ec67d990cb5442a7a206aabad19580e64ae12a219e0ca366872c991e41b408d628ef858c208d6796989061538f736ea05dd600ef095cb8007e170176a6e3edb78b7df27f077cfaf778e219d27712610e2151542d873817cf377b25d266fd765de3b05891f83808c194bad871ff5d45514c4fa0db8cc5d87d5c6402e4c2c163e2709475783a8056e3182549847f899c41c6ff5f3d442a536488b12f76e84bfcd1ec95405c08a73c7183189d17a1f125915473b3a9998480d7256d0298de110854bdc8a498258f9a03fba0c802ca2ba1e8e3501c871c4a4a950314006d923ab12a39c5178bc049f02283dd1035382e900d8adc81581cfbe1b4dfb75853c010a30c3257eae070c0979180961061806d0918cf31643ec2d77a29679caaef3ea9854ea33fd34426e8abde615240e4cc01a3e8d4800837f290f31def003304643b8642447915c5a66adc13263b727f2a8b82eb516d0a4f4d16cc305648d9cdaba7e3a5a1d3e9a96e5bad58275cd3bf81d1f91f8c35bc1813e8a94531dfb3aef671bc5624212697c1d25ead2da6e586968fcbf5b9d7fb3337a9cee9400a5732ab2e353e42438e4a44e818b7c48891aad87199c76e57b38213e1739a0d46ee5987504810d96eb5a42a589e717cf832e2a675aa776471aa3e4d6625c12affdb37eeb0711babcceef5a72e38f4848e6b650e7eb20dbe6197bd18eb2def3e16d0ceeb0bdca7cefe194f6884e907172b2f1eac18ac62970b06f62d56a2e169cf025c13ca1c27dbbd109cb2f0862b9394a981ea112c46d054a8ac48587dd59b92c145da9d122203ee412871598332254ce4300794d219981f13db341aef8c36167da1fb862583088ed70d89e03c38e4e65fb44ebd12046ba4e5df539b5c887801f22c47e611b477d61c55b2ddd94557ec9fc865137c2b0fa1959d6e2ad0cfe4213932858a6cc4941509f2f20193f7a940768f59e400f4231657471762e4217a1253a47bb7ba45e0859c082553995305ea5937d36047e1040e5be54c21c578315b553fb39729932c57ec87abb44a538dd2e9a14229a96f0c866eba8a520e0c84ed6cfa1e57e8f81a8db4a70b4bdaa495dfa1c976e8b5c92f2e59ed30d0bcf266809abc7857e795951c06d80deec776d4067d1553fbb6a4c696e46ef9b54b54bde4e9bf90bb68a952c89d99cc7cfcb00b050be0c9a476993c2c49e4ae5a54505ac4c3104e6fb995cdaa591658c4ce02b5921d121247224a14591598328279848a05daefc1a5290e0741df15efeca455b86bd5e615f233006b94086960c088b3c70bd6f972c89f3bc2e79fb93368a3e7579bb074880d0b51cba2a4658cf83c6a6fdd6d3fd54974297738b2d58be18c9e120174661d656a45fc2ef974def5c93a7b2db5e24481fb46771bdb1b8c1e1d858b84bbd984ac13cab19dd8846c14c643a83721093c112dacbaf87a74ab723909423cbff584dc07fbad16f981dd60d81178bd76d23566bbf766e77518cdd350a0199ebb6bc32dfc695e379843f0dd301d3d046e35a51fd7ed9ba4fe1e9b9bb5689899ebff137120af01a2d1dc68e08bf4e179c9418883ab82112a553cd506e339a1b48782c8891071796755dc713eea0c20a3855a69a2cd55aeb93ef5d442b139f8e69dd1f2dc78a4ceee2b0c9cf0df3ae1e9bb61ec21ffaa567fcb8d50dc174e343eb0ca3718312bf16888edd414a3ddb1d644087ed395d10767031ed792e0cd591a55028828a257d4abc7656ca2fe3ea0dc6ac609176ceb92fd629c28ee0179723ab8d174c821cda48a91a6c317e178626e53f16fb20b2742b8dd73800df074756eadda83af3009abcc19eff36b80488a527ae8bf5719a12c3b0bd4e5a98b5dfc04ccc31c23df32888ec1fc197d26f2e484c5519114dee59529425b481906e0cf3239858a986c0d9e93cbf28773a4e1f133444ca12b9b934ba6515239551f4dca89652285c2993d0f4360547b30f20e64548a4ebf2ca44dc0b481faeb59ea5a6111907b4ed2d1fe84148189c8b1a8d84a4cee667e06b1e2d2ff677de30e70923ef554f175e9011a373be6e99d8a8299c13db923e3f2f234d8477eacd8ac47a9c56b97478431c0f7993065177a1a1522cfb1c88c1e47b9a0d8b4eea8b9a75d35432957c5fc4f9a5b15d6b68d0af483c50d3e97809f782f9bdfc025c575ad7759546656dd39357d050de280852c6a4d3f57e037866f9838ae595f637d4bb5fed90a38fee1c4fc12baf6db24e83f6b11756a203904db334b6df046451ff267de3bf2138b61bdc5269b538a7e9895e59411a84bf147ae9e98cfd0cd221f1c40e9fa7383372a6f3ca5f88d43eba34290879dc7a9f69cfe3cc2459b819b61c627243bf58aa5c6a7267ac78cf042f46853d9b06c963057574fc01a8db60a3dd886596705cd280d543274e3b8f8e96623c1ac5c866ee533667f6497c312ad9ea725ab6f53478579fd871235a96181e1193637de84e80dbfc105e7572cee58b0188d7f1f6ef51f24e8dbcacc0232833af1324339273ae3eec10f8b0cde8cdeffc02c572ec49010786319d463ef2513f320146103ba3b82745c308eba9a0ea58266fa7dc08955740b5c605360b57c5f66d484a679b773ec9080c49501be08c87ebe00cd3cc310ec0ae14caa4340134e3a5eef9b4c21c36e17e94fcf1adce9e476981795bd72a191e668c416d2f6eeb6e59652a62465070740072e07dc0bd93a300572e1e675c7820a9d5bdeadd42b485ba43cdd82ee47b89784eea7d7fdf723755048f7938988119095cc0947cf74aae15538971cd6420eeb7b2794d3ef9813d40cf8a98b8a5cd9d6a71df5baec791c28a43eed7674617361f251c3c6b2a4c54e9a2e29b0ea59df48848afc5bb693c3dac9c9a9072ff221284f5072e64bba27a8b09d5af4204a1d095585448c88a8fed5bd9cadbe71f8ea42229a9733ecb416815aac34208f1f0e7b5195eaf10761fd2afc593deb71c8fa9fd56af5abb0c8ccaf1e874054cf0a8918adc21f11bf2a0c419553b0e3708ad11ef49d195d56a864e2985505c6de6254ff2510cb8d64b26e92a6d3ac67b319d5e32d79227dface5c25c03b64c6913bf325173c36d2152cc1489f1476c8dc60e44e3f09f43da99346bb81bda5b33ff6960fec2d43e099bd1f7b4be88386df8e077c3b663e410acc7ad58f8dd43497a8dd36afbf11bc67f2d175a9cf7e273bcff3b13d15f2fd043b157a4beef7b8e46e2cb9bf91c03413ad7f0a5d216f2473cea80b55d4471794b885d39e9528da09a8ad74522389c136a42e22f0d8484923914ab57aeba386af1f8d444b809b16cea816bbdffe8065142bc98f51921f230f4722d60799628c688236fb2912b29e1516f99945b4223faa67fdcccf204da4a22b27122ba4edc17cfcab1f659415385ce118831d366b4d4b93c98fbcc621817d24d67e8eb65a92a4cff6d652912d14965a1acea4a31a064f30004699fd14c8811df772468374cf853f463ff73b4ecefc7e2a1cef0d2507ba30806176286228b8be9cd95a6e6ad16e16c98643e05196152061f6adb5d6edbfdc9398f80226db2ddb9f5062748fcd91fdb9c5beb4d6328151629dca23fb938afd293f13e48e0d9f6a9db485912dd26802bfe8b3dec88c035fd47bfa9ef7ac9008ebbdf0e7fbd41399f93ef53faa13f2ffb4de7b16f8d33debbb1939e03a0626a2f91fef67be051a01e99ef53cbc87267cf92b9933a3d77d2034effdf673d6fe3fadeffe8608f09ee681784ff3fe3f461e02e9bef53fded3fc8fd116026985f77f68ae7d1a5ab017befc573ff3ddccea675e4030eba9ea59e05773813a2ad44c1fc7182c6746f4f3fee52110eebdd4e3f881c493c91cd61cf8833a288158f6a7e028ba9864b2679e91ad2b145d4b29e58b0a9e7276695a7eb100a7e020a5e38c1aea9e9f4535e35c629ab59e13706ebeca27305db8508a23539dce01ff7ff53466cc7819353443381c314e38ba38d77fe128aac21a8e327f854953fa1196118eef5f138e622b1c63b5a69921d6100e41f07e27794f083812e64f461613bb7c275d1b7a0e0040d9b4ec34da2686aebb4d7bb282c060b87bf794ee02edee6edadd9476373872b9a7cf321f8539d9d32d09dc6b4b8f05842be12f5dadeeb59dbadcab7d4aeb04ed579a6f485d2d23309db2c55a3f2d787e8e9672a72f0d3fe70d2cc051eb53aef56f0872ad4a3674c9f5ab7cc09b7190476f8a1a92100293e96fb8a3a8354a84926ca5b243aade106292e9d35aab8e1836685143982a5c706156eb0fb9d62f5799ab0cb629d36f117ed46a24268628a2706109125866b516e54ac549ae55860f4383951c198431e7c40cb6e97aa93db208da9466004388f67042b24c5a70a62a044393a002212a65c9dcbe6cf9c2a54eab4403112f6c36c460c06022d7748928c05e9659b278829100e36499258ba83c62f10ba727b4e5cab20516368f3fa5dca19fa3ed14789c436456b42642f6bceabb4f2993974c2514322d273c00859fe0cca950f6e7a3e33ef5db4b0fb73c9ceaa1bba2543887b660224666aa4fed806b1e9f0b7fa8c2c0e31ca20d557082a13a4818ad4d010593964c8fc8f4471911f4e7049a4095fe03ba47cab7639280c9c2e9697ecef5ad222929bb97dd6f985ce9095276e9495b949e38653adbc79c20384cf2a0603b09da4cbe6829207bf27c7f14b05fcfc969d1715accd101d71f71b2879fd3a23f8665ff6d0478944e3eba7e8c752e830a5dfea20c4a64f7d9b783c69716dbdb3e2549292500b2a5d6565ba96f1b121dc8a38b07198490ed1e065078c4221358059afb45e802dcefcfe19fe2c8602f13ebedaf17bba1a45f0fbad1c740fba04438ff948729d057e1e62977eaf75824fbb70d652cf4b721d1fd5a6b7783a0088f3733d92a53a6d054c184a60a2636d890840d33ccf032a74ed1841f1434814e2174ce06cc16a5218ec5feb5041e63fff37380346cfe30014ea5607c4808f12121440baa0d50903aca1160a2d86dabb556bbd99e5270dd68583efd1b06aee1ab7fe60e63e10d392738f64474cace19043583dc45e089007beae7e7108147093f80cc94edbad40c21070f1083ad0dc4116d282be18710f865503850ae6c99504a41c19f9b5639a7a4f425f09dcb90c8becde958770cbb2b05430d47fc426db7dd22d28be12f29ed6ed99422e1eea8975d38b4c56e2a84a951151b266fc3e4cbbe9b531a7ad98244f75e4b3d69690949949f63ca29a7cc3165eb88f6e30d30bfeed4dda5b4a981c17db395baa49c51c3454e96b5c67a6d6d12d34b73299de15adea52cdcd195a7faa8089f8a8ae0addcdd6ba5b5d64a3b9c929293f24ab939b53555069d73f21081ce10bd6d72a6f794524a29a5f2f502e1480d1b192175e10eb9dcefdee1f8fa1173987c569eb456bbdd71ec57e5afcb0e4af9d4e5e3ebe6da79524a29274d4a19a502a594524aa9d7b5524a29a5d4fb542b3cf37d18a86cac5c18a75836683c0ef42eee928b044770aca19452997f83b97524a594524aed6d5fdde01aacd68c67696ad4dc8a5975061c5399db6a64cc70d9bc6478121c0130c3456dbaecdfdd6c90fd3b9c9ef18d5073879edc49659f8181cb868deb06a76ce4fe8e86c7b97eec1feb3bed9ae9775d336db029a5e1b5b9a95123fb77e1cdcdab064e8b8667737f0700ef29695455cd8df355708ac320a536b36bbe8865595d4d4777772ef07c1fa59452ca9aeab5e54949b3497a299da192b2384aa9ace102bb7baae54eb5dbbdabcdd6ceabb4aabcefb374deacc32465e7eea56ef348c9b1ee8c47371a8f4a4a6dabd64cf95eb3943b94565aa90c8f4aea140a6af4dae5dde6a975ba3ba6b9bb53bfb91100986aab9d9133f65f5f0f6c29ad332d1a302d9a992ff6267405405691810c6a6bdd2a4e8d960694564ab3b0f645ed97d60be31b3b43ab9db9c27ea9f7d28e56cb62b1baae7bd985b24c9932b6be36d059bd6e7476543796565ba68cad3602b8e1d9dc8875ee9303ae034a847670894c892385060e0f2c0d1c0f78aaad0183f3e2e9a1d5bfbe2c0daf96563b64da4a3ff09922c5cde3a4fb767476a7d56e38346eb27c7a656d819c84d940a062cefaf007c3968c97326a70c277587f4d173c7ffc57e80a4000bcdb354d19c8c820834f47fd1a35d4abb5bfd91a2d0dea8b34d4bab442e3d3e12ab0228c7e58b45e18c33cd8a7637b1b1b78392d977f5eac4c242c66789b6c6021a12934a9e0a821f349cd04d54766470644f4be173f1daa176ddcc0deeabf1e7d801956d779988ad7f94af50d994fbcce0415c8c88070a9af0d7456af1b9d1dd58d8ea7a323bb4957d66e98306f34ce104e269b4835cfa46945c804a1c9ad5e304436b9e4709c5b643602b8e1d9dc8875310e3a0eb80e3af0a4f4b9dd003c297d068063436a1107081a383cb034703ce0a9b6c609e7c5e3d1ec49ad25266ff5822ac5faea9161b9483497c93e1df46545b2cb200cd9b639adb488a58f9037fa93903bf5034f4a1f1f4f4a9f248c5d5eeb8dcfeb66a63978824e0eb23f75f798f489c91d9f14088cf1c54e0bb3c316960d3c44d1f4d0d492e202950f543a1fb2b84b5d23aa218fddd460f21cfb293799281fb8c8aca7cd63e38a79f5d28725eeeb28f900743be83a294de48e0c2e410f2f5c2994789062edd74f8725c00e284852da61092d1b614daf88be3a8871b5e8a04408997e875d2efa2e7a058728a40ce145174e66f4c5e6a9405cb152e562af66091e4516f20eb976453a28c1c9f4ef3645173599fe96938229327d6a37a5211e32a55fb9e4e420e50465327ddafda083031513e4e042a6ef395ea26891691352e0f18a3a50d8cc8cc04d578c1607585b68a0c4e0021e9a8122f4c28a5e160f4c544d2c612a4e3e033411b5520af29c545328e94690f44141810ba9273c2859b8c07550bab80618c1500a4a18306c475c1420254c51624862002786a2387161a916258a0b062041541422036ca145a1c2845e2e3480134b51987819c53aa6650b316cb8803924b028304cc1ad2cb33cf9a08114d826cb2c4f48884cf08c2cb33c49914197272d32e0e2290ae604af90d4a8823f2736ca60d6908d21f08a080d76c038a9c613be4c3570c03335510b5e6599258c164c61c0a8410553174416b08d013606e69e9c00df285b4809e307518c510d1bb097651631546a1c65119374a41613b3c5d6a493392924302bcbaf5f18065f292fe82370bf510a5aa048ee14787bfbeaf7d519039d4722790b715a746f5197c5c4609fc205c4eda2058a5db885f108c214b1618c714be90616dcf09447fcb48ad32d98eb965d0577376f5c33601fa9c733a6e011a7bebf9b9e6cd93e02cdfea927f8738e965212a9beb08884a285312420a168610c5af6fb94e3387ffad465a8c54240e58e87f52be55e8242dc3bd9bd48909ffa1da9972ab8a42f4122cf41dfee0d456858e7f841ca0f600b12794f411cdde37d7f2ce6b21c6070151ef2289b7498b8269d2b0afcae16a58bc0c3257379cffd9bb70db4a0dc3102cb5047eec8afdd5feacd5d0098b08ef4997912f1a72111fa5eb885dfe22482df3f4ad5a9c019e5b04afb81c4b1c3eae3f7503aacfaff784f7f23a13ff5fd2922aaf0e77bff2dcc6971ae5ef58f55ac577d10d6ab56ff839f151209b2fa51fd785618fb9574588ed81830f4ab53a039a32c14a1e14f051c169ee0b0eafd98d7f6347c6d21fd1ffc1ed2573da534a4d1b0c8cf1c72587dffafbe9c85627b30df7b2b68ad8f630c7d7f2449e87b9fc4ffa3ef3d10ffef5b416daaf0b5d5d716fec0db130caec0090536cd61f53f1003e5fa9c18dc42f5c330b8fe6c9a4935e9db42da6227bfaefb0de43e9532d21f391b7881c7f76a10264196c9aa26ecca4d690946269d4128773f16c99386eb8144e40b8018439b11790551153902055ea2663fdeab422233cb0e3800cd8a7020050c41b38e6a0ffae5ac88e442862a42332fec0f9433d79125a425ba24c70b4573b2d2626f791d61e9deed515e774322ef91bcc76ba4f99130f34c016d246107da88c2374273e98ffb7602c3a979c6761abdc8a19a67742427538b1a3b6a49f38ccd25b7182ec678ffd5c3bff63bd27b91910374a11f8563913cbfa1644079826d942f28c3d85244cb0e1a41e28129cae40df49745cd33bfc7b778911fcdcde57228177605d1bc47ce80f2903bbd8ed80277c2118b39798f87c31ffc1f0e5ff3677e5e53f541583346e16bb258af7a396b16e84e0ee5b0ef3d509643d603112322ac377afdf03e0172a6fa9aa74335e0091f58019e54cdab7e944d56d0680eebd5ff1801c1ef7dff83c339e4b0a079e4b0315ff89a0b50bdf740beaf098918f9f41088eabdf766dec88c45f35f8df747e6ccfb1f9a703239ac5f334ce187745802e4cc0487f51fa9be6936318da999504d5fcdffb0bcc7615007d15ef3ab79ef83d4d484aff935ac67853fdf7be16b862f04785ff341bcaf097f8c80cc7ccdffbcfc695eb23e48cd4cf872ef83cc3ccd4cf8f29ff19ee669bcd6d3d474d00254bea505ba934371636067f2a5169de64beee454d4475d94db432ceed44950ee1464f5a3fad53b943b2d60155220a73477f2aa38aacd3ea7e9984b290f94339af43ad2d1dc21e9eebed7e5925e28a5f5012dbabbb7839fc3eea639e48efc98ecc529bb3bec965da48d7877347436c7032692e6a18f3f2665b247ce205ad417292515593e0a0e90208490a70e52ac40210cd5202ba58aec3fa5587fea604576b17e92303ec78657c8b54c762bddddaa6e7882dca92fbde46a240716f8a3c97348183dfac0989412e63547f697b0fa29b0eb8fecdd7fc20b914db7392f40261ab4e840c68b306ea8412cb14d7aa82f7ece5b31b48527bc58b550c33cc1b48277d1c2e54038c3ad6d58704ba48262b663b3d25a690d16f097a59210458c21c4942d4244b13428e91c2658760068be27440bb93eed5ae9bf8e00aa1845193d512962d43f2f9411982deef9a51941e132bb7928eddcfd7a97a500168a64f76e760a159986f386e3ddc2117b8bbea82c042656b64d22348f540a6229cf20bce45492d29424733ad7c4a9e3155869bd7a3dfabfb3877bf94f2499c8ad9e5ee656cfd4864cee06b2c78625348c3e0d65c3c601f08c2040691ecf80a4995640fa804e7d053a54c20f1e4bc6abc210155aa443c20a04812f7d2f2e2a32a514082fd1a73fc42954ade17e377b7bf9e9f0d1dbc66ba7bd96c6451e71be933623df9f136886938684472fdfd4bd9f0af1a4f590835d54ffd6d0fefd8e227de41d7bc98ffdc40b7b68389f72bd3fadf4fd09a57f7669f55d5cb66071519953eea7eed3200273299003abc0f38fa84dbe3f6fdfa121fcf23bf768173cb7344f33d5ecbd6f5fcb3ce21291efbd6f8ff09422af0b04d8887b276dfbbbddedd29f9f2c5f51facc21b973ffbe0264cf8442c29898b46891573ef8401441d0c686c5baf77edf7b7f9cb4fcd7730d6dddb5928142fa90c3a40fcd15cc60aeb5d65a9fbb628bc0435ee7dd6ae55ef0e762c04745cde3ea82bd86a5fe0643f64c2aa496fa4c4c5ab4c82b1f7c208a20686353b93c674deed4af453e44471f9252e4ceec41faf4d76642dea85f8b724861ca9d8aa536538bf53beca5166b95d4932e0bba1916a64c64cf0974932dcd5b30ff205b876cbb06dc2b8041a579f05bd6db6f26b2c785ba903ddee430e943b34dd9af35acfe3e0b9c605ab48f417b05db22b037794f7dfb2e54e59d496a81d2619b17712f7031e0f9d43c76c4f387a25412b875381572c73a90f441923e7e8473c081b43890088236360e2404044e026f368923913bf6534dc224789c4dfdf3de24202bdb5a3b9de40e7d9aef4f02a3e030fbf762ecae1702ead30f529f86488064b3995772672d18c038bfc8f6bbc8f683d0a709914c27c9817d25773613a2e0d65a2640b98588b2fdb63fc14481ddc99b869ab2c5d247faf474923bf6b3ece91a562061f69998b468b922af7cf0812882a08d0d8b85b36dfb6058fb36083c7ad9be0365fbd6eb99a00cae0041d320041843d90801f6c068f0846590400c836fa8d0f0430f5e7e1012bbf80106b10abc7a0116633420c236592a159d40dc01d764a954c484175434d001b3b2542ae2c1865091932745405ac4d8a0c953161867a944d4e5044426d8801605080606930649b863a286126c97304289e8034c4440d8d082b72c958878f0614eff6eab57473a6520696459abc9f293e5947f6c88dcc98084f573b1828c269cbdae7379333a9547af87adfd6ca5ab16f67ce5ad4a2ddeb6b0042379ba2a75f9f43a4ecea7a33e6bce1c8b43591c48a704e1d69aa0a6bc413d29592d55cd274ef73c2a6578d2a3299b1befbe365b43c16d9b7f73f391306987636978423a413940381d9d8e3f59432303261e0600e87e8f36a98c192e9b9b215907fe8694fef0b1e6914a4a185dc9743f980274c515474041c152a58244169dd36ab7f196b0b91893f993c78e7443cafbde5bc311d370e6de5bfc28b7f42479073ef83043972fb490c169e61ea81285cdeeee2d031e316e9c7657f3c8dcb31ebabd79db7bd2f3878c6a356d4e9f41d3c1f1a64079f8903d43648f321b903d3c96e691251a1275df605765e50196d0b0f9dc93710ee540bda039e49ec354c90c85f69caf21dcca5269862a799c41b98416271641997beefdab7fb7c999021d227de66637ba6ddb6fdbc681258077ca56cda0a01fd913812119909e0464cf1087bd181ce571b3d611ab40f9b5825c0a747a9dfb5bc2b7433e51f70d689ed8090d6891c70c2b37067fc63a416207d528d149efe92b5f94116a7532bbbabb7177775f8735a6d9eb6eefeeeef65abcdeddded6058da4694de48efc9512980cd49353d214ea204a29add45b4a995c1aa294e21a9e2f7f8eb329cba7b44b8bf273b4982b78caaf1183e5d734a5d49b524a699d492df250f711e0299b5221f49fe60ddb2f3b245264e645ba6750e041b55aedffbf56abd5fe3f6989e9ffbf56abfdff77d004a189f4b964ba073b3d413575116e72393d54510bcdf0ffff1f4c172e5b269625115ca97708171dfd44ba40ddd3b55aade8a8a8a88b7e740d045dab0975a935d56ab55aad56abd56a35ef367501438518649eaaa8d56ab55aad56ab79d01fe9ec745aed76b9546767f267e77d95e33e15bd57b5f26da3ab5837f32cd9e4a2d39680986a28788f283a2c0578662061f55960fd16f22ad21b8a0cc8f6eb513beccda709824b9ffbf26717f9134b6c224d2bcdc3bdfc7ea6a79b9ac9752fc62ed72ff912153ca548ce225a4fa12cb97f9c4eb2fcc9448230b1cc1bfd92e674c57c856aaadb50ba85baa4165241518193502fa95a28053912d63d0b94123697963a550bf92a945d03f2fd2976affa7a7c4e85aacf87ab64119e3fd4505aeceea1bb86b6e22aea1bb078ae610bf50bf5ea1b81fa1337fc277b0f9617f39e6d06b56a0cb0102247510b5ce00596284f3851c4154e30e960adb5b6061f5cf08219c22ca104083ac9cb096e1212a37ac55092263b34f1a4cb17274e6c5189b842cabdc208870eb2b8e00b185b64698111f5083741e1c15eb1c24cd312375ce1845382c3115a94184af08014461d02045c962748ee155090d45a6b2d81184b0606ebe58a1a85972c668a349822040690c00287114c11a6c9163329a7796e9e33c9262182cad01412601ebae01b9e10a203415d82a3329f3d8284e65176c90e45a61ae571d226d05c32859c8825398fd34af6a67214953d004d8628ba72e5ca0c2cccfc633c4e9072e4055f4039e1441033ff19348b3cc9aa8e58248bad73e0459dd8d6850a76d8c24b91951cb4f8a18bebc08154134a6e70128515485e70e1160890baf9f385807bbbe97dbf79de77537f5f08d86c98fa1b522e05e688b5d31008f75dd87e432e1c63a1c3a6ffcf7dfbc3fd06e4be0d8170bf85f8b3c02c937f8ce8ffd84ffd6cdfbd7cff5e08b09f7a20f653a10864fb2e7c8771e06bfe1b995d30f5f7132067ae90080e2be46cfbf153b65333fbdbd726a6a47207676fc0097247be6784e7c75a942f71748fe01987dc915fbfc0217da8b4b96a0007e562381a70824c862079b6cfb593390c662061dcadc9a59e2c3dc81c09997ad0352a1a19302053ee3db04648a63f45ee7b0399faf07cbfbf03784e4d231407acc608ee4d11ab570f87f4a13e3bd596872cb616ac68e10bfd23a4ca6502b422b43801921034e952a72c81258621ea0b2e822f5c1430d45a6b350192db4215a0285a40e22f7c0ece52e9a8288f1fbb5e0800093cbefccf1175ac064af866a97434248e81b72c958e6a68131c31b9329924b11c1df132c6568778ca5d964a4378916189b5d6da301f688d59d244eb8b314b527004e83b526bad958b0e1c145c8078a116610598302ab8428c099284f1c3064518474a66b8ae219686b052a543681e2ee575aa6f05f290b0fb52ca5b94650f7658d3af3209bb72c9089228e3910273ae091cf852bc2fbf1ed4f3f6f8debb59db63ae902b5117b61ad65a74a28eccfed441c47aa7bf43e6eda6783856ddbece3cae3ccf48f6c231a65219c92a8cf11bc9d88570bf92592564f51cf72bafae563be4abbe7d16a8d330fb1514b9d48b62f35831d63cdc5bee6e7fef9c77daaeed169dfd252592f288979440ca7666bd68cac9f62f879f7e3a2c70819953bf43666ebbb5077f5c0a9c92b2147024a9a3af7a5538aa8c641a8e3ade774672178eb1affbcf48fe7aacc6ef57a191bc0a475927a4be4a0a517d55a55eb5a382ae56ef90d95efbd95a6b3710079939ef9d3766a1aab413cf5a67752ab3ba2783a58023b516a50bc7f2c764217c9db34e20e89c73fad359ebac4dab774e3178fc1ca7230e32b5d6d818f27ee02bc834ba3fdf2bad94d254caa6524f53a930265bede05d1f62caa72395024900755cf04542cd1ee851fb77bbee479c5a4cfdbdf47e4e419939b0befcb617f5177d9a690c31269c20bc796013d162313451327b05f929229d88528299117d2f7c059929303935cde67b2ee6a6eb240a542a0bdccaf2bbf995febf101aa02fa8b46df844b5643403000010042315000028100c87442271402498e8c22a7b14000b778e3e76582c1a089324c7511404418c318618400820001162184254441c0020516c50695ce0c5a843790fb716cc6ea340f88e8727bec67ff44a591a7d4a03d016515bb9882701a944cf604088a9ac816dfba7aebf6559b1951f11acd87833f99578132e8b05894b0396bc3c14fda0d81c251ae4becb11b87d6df5b3b22abcb0321eda997ccf0553aecfa2271e5203fbbb049c307d2ddd77ffdd1754039b8b1d2194851b34e639d94b16d7181c34417a142328fc0043766f574ed165c011b932275e5aa5044c2139dae091585a8e578a2d1336986dcef41d8a343a2909289e66c6fb733806b46ba64a4123c90e2d87cd49fc6e03bb9a0322f89e04b7144b6a4664b0e235b373cc9dbcc5d5e9d5fdb4c8ed074022da12347a37f75f2637d809ff5aaa49c1207e4dc0ff36febd6f733da9323a466254a02390fdc1ab8de241832d2227f81dc8894000d566a6afda11e08d31ac4a34960b097c22b653a056ec1c9659af2a2c92d5f952168d6d5986da6a861728ed695f7c6c98bcca5dc585b20d0518e6d7556507c6ccb4a8aa2567ab12d6b5f718f3e062835b4ed068940d137ff25650e8471bd865f927fa139ddf988d7bf7af073e58f322439d70bf6c7bf81e675361d6008a9efe03c9fedd952df8c548de5ae9927cff1c0ede0e57e01cc7b5c0299081af12e7d99a239d46af049179cd0789f2245cb38d45bf2015786f07f8e1a444d1c025635f92dbaa09a50a1de1fdeaf02ea3ad1850150a7045f6e050e9a2af0c47432503e80f843ffd477f8bce44b7a47a9ec4daced89ff4d5e0b1d45d5fc0c678f68eacf4b061d677700538d4a1cf10b87e09d69bf802f9217aecc4edf23d0ace0ceaaac108501a41eb2d5ddc178b53990499e3bd7b804cf315ddc373618138c396eb1b57f2049a2483ff4f90f0322dd830fd256ff00c58a483c6fca47dc0dd3bae6e76f484a42bfe1f7a8d396f725d1c9a65527795a846f3d77abd5516e4b1c1648c87d555170d21316494f28c21cc8b32eba08697c5b3e01b72b4be9a80c61682a1861b4266e0a026a09947b0c78eed58bd7b674232d34f3ee7f09b099ec69e57efc7cd1c6a0907d1d0b3299df18240ac9ed79905926e52d70c2b08e8326c3dfcc503b8f21d7e589eb1260be009d1fce33223a67972f8dac80c55953eb04bfdd6b53088b008f77a3471df79b12c164b189474cf3efd82833d3db6ed2baccfd79e45b364011f2ad740de9a8407745e2a8d7de6218527b48a82ad9e5979aadf0ad542059db4e4eb07f06d3b5a0f0311f719d8e85d7f1080d21523f8b68c310950d4300d1814d8d7b32127e42d4b5553eac0874ad205acbfd234958e4a54458423f57cba213eea0326806bfd7a5852a4fbbad310b100e89ac16834a27c0019f7406e91b94b91acd056b1e086f0326a5e1fb51a64bbeaa56bafaed72b597588ecc825c9f9f1d18b473276ebdea571e43284a417ffad8d58c788d207cdded3c885732d27e8ba41f2c5a5d03f1765913064f5e9dbd73d28da823dbdf12dc756b1106e6793d369c239adfb7dd33f786536e4189798ec9f9ca3cc61a638e4a5ca04083d6548ef7bb3e1bab03d208abb117d6662c2e16ed826661bd35e3aae3426342d13bb8e7c569d7d719931ec6d173374fb16bcecf9b05870168fe1508c6eda0ae5867260ed3cbeaa26c4815302c657c4915a5af1328cdcde240804e073031cba83425810c6b8013a379c53b30b17e3527a427b35937213b184d4132e9948f5438601f71afc250e2c874f691eafb9a1a88252063870888bc49ccd9e60c85ba3651afc0b875d9e0f69f5910d01be54d96a5bc92d9dbe7c20450de810987c49b1ec4a39c71e988f3981762514d65a19446c0ed02a648abf4b43e7910c4ee677dba24382c020ccfe9f8c90c81c12fb4c9a675a66fe31cda40caf4f4698734d3d8d1041ab89e910b5c700634d049f665aeb12d6fe1c771995dd38518b11a01f0fa0a3ebd4437b8733e2628aff07aca3fa00d3b69c9fbcd178bae094903a04265bbc15b8b67701065c920096c17a21aa166da90b79884decf2d5da173f54201b7919997b71bb9ab38089fdfebe4cf5c88ad97802c2ca559d966c49b1caa2065e3bd18cc909659a7da867a78ab4566445521db5e200f5698186f40151831a1404ba072a1cdf1ba4319e93458fa4db89c9679a2b4bbd895ba381cf36372b3dc9bb3500e6dd863033007b6874ab93f0e2d795e650d0d768e9eb827b654bc44a5cd6b404ad7d646d3ca8917eb37868c8174fff3eb4372d147d9d1ff188e24667fa9ee0968a7366c10e2c4cbef1adc26085982e28947bbb1c907cbf8363e5a3c4a5daddcf20f8e96edd4c5060ce4b4d5102f4dbe2cfdc6b523f559a4b7b4df7592db24bb0fe1038d4813adcaa8b42055120979520b5ca66ce2dfb229f4be442cd08941a1591ad89622a79db854716fe4a94c5faf8e129cf94de03152c15338c9c68a0790bde558927e4fb6f28b26fd68c55a61a1a8906bd6302deedc17b2b996b196186e54a13cd3d7c2c407a9e284ec8dc8add9b6fd1049892eaa0451f25be43898ef8d567697653862cc6bc1628fa5672906520457d2bc90a4df8c8ba0d041aad13904562a33b797b1bf06b63a33bb5d9602cab57fa57b4c9c729ec3691d09be1f09415dad8cf364190135a7898d270a88c1c200671b8e1c767971b892a02dca774301a69c277232c08c7739d1a0ea04b05e44f67a84c08d1900afa40c3b704c9b44bbef45b57eec3fe374b339c86451ce7300f0d58c0c92cfc22850e9c33d3806099e4dea1b02589b7d8a2713799084703ca7f4e5ac476d70fdc7a6979f264d810747871fca9237808392b5bb4ca721f4c99a7a82070c65e7794c4f35bc4bd1aa66fe42e76a6de91544f5e6a63d7d77c9e190d0f5c00c91a5bfe856dd3770c5e8b44cc5a6b145eb348b578e9e2c74c6b9abf4e4c67c473c8e91b57f595d54aa527c8cf69020f5c195dc4f3cb351a8ff6c5aa761bc46aa706c7a7d915363791a760476223edf30a6ce021b82aa8a7c3aa20603d009d37640a3d91e0e26b0c0eac4d5165ac679aa2884cec34761f38dbdd1dd2ec38dc3a31b4fb88812546426777cd3f8d24dd4840b301bd1f0f7945cdc8efbe6fbaf30fcb3f6033def57b0520255f1126e4605fb55d2544a1d3df0f77c64eef6a49dc46d89373c6989547b44d06925186815edd9cfb0197be2352f67b36f602d480af3c620ed5a206320a36b1529ce2d9b5038061bf04e5de27b0eda846f6623c4a221fd76652cd83572c9f2391b4600e92d9e3729e0c005af50d79013f851d7c98144ec7d9733a329861b046ae76e4d228129d8d46fcfeeea1580586971509264008285f2bf81c6dff8e9b3efba76dfd97bfa8fa2400e1b00a77a75e2278d42852a52d3037e8897d437e1afad513ba13b24821b0f604640821f003706f93e6f1936c0802995ec54d54ed25b18e5a9e4877c72b7e3f9b2e61f8041f3cdbdb019f7f89a0e1af3fbbf76140ce2bd03b89e16b36e0d52b1704d020a129bb7339b01ac4398c614162c0be8b55792b8cba87f93bb602ef2ae0f499b9191132c82edaf336c43a81e142947d037e217cbd06c9256fb496e75d4cb0a48cedd2cd3ce05691a418996e99ef4734b59626ff43a8677616ff544f830985dc9ff8e4668a5ccda95efe497fce8b890172f6ed0d254119ae31f69affe67fe8251055c84bcc7c1cefdfc6a007dc9049518ae28c4e559c733f96acb5e5ce305cff268f0e234be81045a5e9ec4530f2ebd060c813ccc892bf88d395782fcbbea4ecf2f9e95f91d090f47b2c9d1ca48058de4fdcf60ce8ade0916b2cfe757f6feb9d2bbd9f2f66990ff89d46eb16f31827665765909e4c5d2dc21d2706cc273b9e69fca00db21273ed7c06effd3a3de8ebe8506f5c5626f40927f7b3061172ea62c176c449fcbd5c9f41e30c4f8818017b9ef54531cf731415c7e875f283e601d9d3234f4fec46018ab325e6e9fb0dd8bd58f741a7f7832f8bdb81eff1b8e30bb2d955ac7c7643ea6d1a99779963d6a4d811629cc1975b20f9af9eac32c67eb9b67ee3e18d48ba7c6d8cf7ffdfeee7fba579caf0ccaa756587dd14e6aa8e49e8d79062aefa82e723228a2aac0da806056f60346e1502c376fbc55e1c7223245e9af5b09312f819981dacfbc1105996e88f27b6d2a260f2b6ab12d9b3386f80d78b0951874f8cf63133dc63bb2ebbcd76fc2e8805d8592c5685ca52edbd920df6a4b53718ed2d791f9005e00d1ef679edcd3ebf1719f808bc9c700ec06ace9efbc31d32fe3d033560c3a88cef583e0e2ca13b574c13fb9b297b9d74effd5a4640313abc947bcb48235e330b49da7720cf9fcccd159616af63ab41f5bd0478a8a602d9bc9345c76a1f2c768d0070bc2df3b9762e401c97e8bb2f1d1c6d19058897f729c16fc1cd33a788d110cef8c3e94e29b425e7496b49b33c89321d1774aed8e672925c966d7903d63a11b64323fd284267a03a1d5fa3925e58e785e51b5fd4f6fdad90eb72e7815b31d30f266b8c2f81da0d6983ab8c9e22618eadae426de7031deda7ca17804ef99e46544911d6a769f6ac7b23e441bc96319da1c8323726704782029267afd29635a373c2f97ff12136392efd0528bd44f635503d2b6a7aa3dcb7de011973d9547c7339209d46e40af776701ef86499c7628ba36146d1e12433b552fe630ac42bbe30669a6e871ef3d47e93023ee883ff5300c865707eec9ee9a041f818cd4188046798c741828b83c06ba351ac3a22b6c5d6e905d38ae6e37c40f0eab05871c69e0fcd2a190eb4311cc53219b458caef1b33cf7a71a8e80fba422cc9bf201ee431f7a0b6e77f411ca25b0cb22cdec8c9042bf84d26ef4de0256ec37278ac8722e894c203f5feb8ca2797a02f9d3845afbc130b3d9ec75f427cdd27f7d0449b07dd2a95f73c79ce9038fb03d2af94f4745114b63693ed184d4443adc1c26e7d5f5dc574b4ad1ef626146834229e5c9ed63185b7ee020c950d1ca715589b0a95cb61a2637b8bda10120a0335f616e821e4c2882b6a2bd8fa25bfa88924d14d7e2292e54eb4f7233ace3da17fa6f32ecdf3bf3a4794438f3b9f832e73723d0d393d5596eb48501bfcd3280e11c7b70a73b08927a43c4f28ae722771f07780a46e16bab5c3c937e23d8b55397514cb3a5cce89459f55b72b4088b91caab967ce8fb007747b3f38a3377c599d1fbfda1d4a7ae65002face8fdaca2b083553e87de3f5896e02805156e0d71ee5944fcc450d3938016013a8d0d709d97fa9948ef9207cf2e620eb3f2bedb7529e3901a75719cc88517f5102c4614d6253d2bd9d7f3ef1a96687742503a0360a71dc85094c76be8cda0590c17f0f5856b6c8e9c04d9816f8fa53b6c8394a6c2933e093dfc453042707d7f22f6aa79bc4e0d6fe2cdb17eef233ebdeb8570bbf30a952a69d90df002c1a0480005cb8a6a12713e7de42142ff5848b3fb7ca268e3e2a3b68876b6393064d894b7326f428824b0042c324be77ff4145704f90978a4a6277695ee7ac18805e2ed13220491286fd1039bf11f3b1610a83beb79f175b014af4ffe380c305f36abd6dad40e8e3339f4190bad78145bff7d0ab424c4e3724da2d3e20512c82eeb3075a5f26fed40f12974b1644aafa62b1e97558fc072255533367b0746defebbaf63cd091f31e5b1f0a80e5c22c4c34e1ad68eb0da9b6e09e9df2e4b0e440f8f10812b210395bc14e20474f06d54d54ad78ff27565432b1ac53dd1d64e3d7e9ab7f50875a3c330e759e76a60d351619070e8a1437715316f07157f0333351c899deb20820ea568cb675b71c669325247b479216461feabc23f2797848c42651ab3f4976d9de701e71d5df03180524ae6cb38a5c900f8924638d9271e1d4aee733217a2220062ef1ac5a6bbc00a09b7bcef4cb41146fd734fe0021f35c9287fadb76cde9ecbf00a4f8639982f1e20e837f12e970b55d1111850b10aa575306cc6c88937e41ec789a0f81da85df593a2c7ee0d7185a37efc0d726ef8a8daaa73a9f1b88eda2da7a2624a503349499692a1686c99990affad100801a63f31e2500cb32ed3edd8d85746625b5d94d4225971d6647cdbe4bd87d8bee7d788c2e16218e7a432810dcd67bc6a09266c149f3522282231aa885afc0dc742dbf2a0a645f40e10621d709016b6dc03aa38218ff47f8449dac78300e3abdc899cc161122be8f82e7d86395571c8db99ddfd8a92c2efcd3c0e9c084420cc8b2aa7d4846800d08002259b3ac371590cf50b80d50abae4dadc004c6fc387daf60d0f73e51a4ebbdebd725381e06c13d8afaad461d4bdac6dfb347e95fed32dd84707d07f32ca6244b938a2df10461f6158af9b71d3a2c966fd4e73dea272950b851a9846c02d36ca02d0b4c621e92e8d7300e05c198977b57e34aa1f504a2cca1f7609b776c55828c90c35a604d1f1af9e1e7815fd1dc88852026cd817d3d94a7aae6155ff30f6903703fc50f9ff9eb9f32fe84aae19c40179be7c0e0d927fcceee2312394cab7500696461cd20543469c71922e4c15f3a2840d5407946cb9c13cca6667b9bba34ef5563a2fd26b26adcee9eaad40c506deb068c87c28a25ce4ac7193fb1981c7e03c56ccd12bf8caafe96371002092766ba901f13c105ddae20b71281e304e62c78ef5ff360869eb60b84e979baf76ded16721e89990fef9757c959cf270fdc9007a92d0fe5860f744b21dede2b55f9f9facbed30acb4f27b4623add5a6a1bd44b4074fd531a3e8219129ecc41d81e185dc3b0467fb2b3193cbf141a8f30baccbd51f155ca065344ce171ace7d4a80585a11a6c073a9e3282a338de6fd909d7a9acd2c9685806d11f6b7a7ec843690d08de4758ca4c016eba7dc9475158dd36f00990189bd5b07a54f0256b2b59f1f41a361447127df7aa29af93fbbb1ca757b2b221c4ff0b4c464656ba560250a491a1fddf9344815e6eb19820539aeb0d3aa57ad05424a6be231b5624c67f5a3d28fc18442dd08512d909714dc8874a1c284a204882677679e184128b933d9e96c3a196bc83fc902ed313405ad257de8eaf0c1ef734314afa34d22b70319cdc419cebc698275ad5a7e0f7d0e3ea6634d65714e8183f24c12e8eed247cc5246843acba50287daac8dca394037d93e7e675890364fade86dcf4d2f603b7ed025608e698181ade8fe74a183a460f203a03301d1b6d687b5cd9af18f1266299f29bbebd3d393958679948eff17f5d158dd1457c15827d625e69fb0d0994f255bec67998c9ed902f3154110514b6f2984cf68f5cb7832b6808238148056ba51412fb86afb38d65140d111bf3e1a0d6b5febb1cf09dee7ff98f06b893b65b05a6871d696b1708848668c8621a0858a0aea2316c3a20e1e9346114f45f2c7ab3ba6529b167b7dcbb1f478316de045103127f2830ecd763d92e2372dc5be9d1daba5e0b5dbec18763e8256adcd88c32cf1623a6f54e8bcb99bad1a52ad75c164fdde84c114f6257022b386c038193941422130a3cfdfeb95c416c53b25ebe54777de417e7a79865af4a207329b3f84f366d0a115a3919490b917ef14941df2c6f27cd04f0aa8106e628e92c76b386abf9a35580c325f239808d13633d2359c95f935634f16862110ff3dbb64eda2e78e8b3408b41df9a142ab8e066798910c42a2e2c86f778a7c4c39fe0536876d398fb901f780516ee6f9ef91c001a22391747873aa6dd654e70d66690494da4be7e5a218b911f7c3464ffff6ab5c1ab906105991e9bedc147b01a25e2358f3e3eaa9f7e2cc1d9d06870495f6b00a236a19e17dc205baece553bc2f94b87286bdb113a4d907e11fb802b7fe0dc3748c6ec3ad468e4b3ed691b59714e2f8d78834f7b986706e245d9c5cb9c345d7bb1f6a1137232585459feff0a33b540bbe0f55bb801b70a63ee3423c03db16171fb19821ea326dfe2b6b058de401699069f75d3126a97a81111305bd5b336deb48c95a6c1d60130176523c1a6c1cc658912e047c54912e0da4c0514ba39f9e0cc0d06cb97dd6c367b37d6e4b20fd160b7ab8bf4bdd8fd4ac9920bc6742307d7814a0d64e44f9b0270d492111e8cfc43606b7f509b96ef2e9b1afea5e5b380a4cdbac54b35c5d77e0a53649601884b4e9dcc7265c8e498f944bd43268364c9c57306939b6bc52edec8054d740555c151c6b366a55014353356c4151efe858e441b2afb29f095e4aeeca0a9ac9c91e50b5616c75e515fb0bf67b528f3938124b02d10729b82cb0f88bec6836f3e3548a278eaaf5e6adce52bb018bc2404dcdbe27e4ffbebb16e9d44cbeeddea399ee4662674a28a2ed795576d3dcabc62044de2618792823058d130f0f1509dba8dc43108731970f7dbd05fa5ff17b93b6ce01e5141f63c36b34d11cc29939564804b9cf98fa249f296e16bbef9e1a791500b98c12d3713c4ac9a4cc2366519616a1fa155cd1146e33d8d35c111406c1e900cdfeda1e2bda1602fdb3479910d1254cce02482bdac45fe2188feecdf23492ab460f7765237debf4fa8f7440004671866716f439c3939aee079ae57790828fa349bb9d263a6fc53de1aa65f7c8343b6522fc59a19dea1efc54fd92e99485c3eaa8bc392d5adbe0d2c742cc64d08d007bdd0274dfbd7e4e16846dd8fbc017e984929526eda1fe97c23e71d8381d45648df37bf40dc991d9685a022fcb2430f73a8d1b755e18dc7a335c21f25552c127023ff180623d74fb8dd498c7c0c53986b17384ca4e0b1a67b96217030aa7a24d6c39dc41cb2103491bc06e0cbf638e0967e4d8961d5c5371bf354eb9a6a7529db08ae3ecd5bf60a94215cac55d92a107263f92e2aa3d2f82b120e70737471560f7b132f5d6195b82ceb476ec9a9f86afcdde12742402a5c9b227e582e934e83f8e04cc31d5072c195b491a00ec454738a82b297e36e1b334539516d6f86356708a0ad91bd17a3e2861af30ca145f18c7c98b646ad40de9478993f9918c256e14240ec424ff2200c2c2e9ee77c057e3cedbc9139e2b92032df6e4764cfc00cb65aae672077e2949452beb6341536ef657f79690eaac86aa564a4ee53279d7d0d1bed754bcbc7a245f24a7af98b0d3441b6a1916bf360ebf583cb3968289a564e3bee2055ff209388f81058b852e52243c1c49d7bb9553d1a7b649ce25e6c4a9c335932c39808f37026ea32410be16d7f918bf9d65221268f8996c39bfde4374b02342db7ac237feef2f9ce33994f69f633361f40cd70a9e6550e6c6c6336706df0950c26c55525a9f44bab34ea4a8afd1217c9e9d685badc00a47e5b009e6b15417f3c4591815b1640ce00f2774ba163c94449cef009505adc4ba48b53c434ba1431f1f818916286484b6ccdeb4f76c9259676a760d0f2e9c4695fecdbcd208b0e41e48ed125ea7a28d9be7c7e9565f5e8c921f2bce7c1fd8b03702d2831c039864015159fe7ea8654fde8f5fbce48815bf8955762b616da05f0e0887f2bb9f543611ccf635d94c3a751da38183f71316d079c35b84d7a9e628466c05a04bdc88d3979fdc3fd67c08e578541e6bade0e3161a7a8670a9d294c18f38dff319506a02f9bc8ad80b10d6cce1fb2e68f083b03d83cc02ed8640bd439808fa0e902e9b1bdb51c9db84a41534b246d4e5c3ca981264787129b1164a8d6456cd57d4187f155311b785b7f2de477dd1147a6c114e445221a6ce380101048e1501d44f5898136505f6841ce181730c0e68bda980f9804f9de6be6d8c04235a470124c35c3275b6b78017d61b3f6b8d436161f09091c9ae7db61feec1a27c02bbef8b141dfb41c8e1e268841a225e1fdc6237f6fc61461c18aa4161d06920ffe6744c87bb25d75a6308343d378e13eb44ee71f45f81b16a12a7f16725efc8cb585028e814547180d708f0a2c98d102e0f5a93cd99ac08949ecfc28accfe672a8b9dc0b44fcbad8fd1d461c76a4785d57f3b04ad5f994c4f8a3f60829484df216ec4399961eedee8111bb59b041e9232cb2e5993bd508f2dd3f02caedecf428c0189316ba87f4fa5819c0a9da6a8396dcf9874c9bc4455af3a5263274cea2697faf1f10784c703a3a8079ccc0f26eba12497080e1e73aeb9a8f995a63cfe5a93ead4e1d7ed9921c0c21b78af7ed9d9d516ac8d00726dc9d5c7922829ff2654d64ac3df22dc3e9f27f78b38f3f6a80d63e1ddfeeb59c42768c893168edc5435f85e6a135ca7173c5eb892df138fe7099c7c8829fe128ef49ab75ebc582d3fec530e87b688670d2b3f51a59b437289555cd744da04f10a7100f8080d8d13915d5029a6771b63da6340bc2c2b6cf1e7d87b1df146480e60fd6c53be531c02d7f31a4c50820e5319c61b4931c81b57f89064d8a1f5351c85386f431286892426ea9e95c099215f68c23817d38315e580e39936975036569855f2024f0f339652b4c51e85c75740ae3d9fcb882437dcec022489ba24b4e6993678fd4c85cb6493e69b4ac192fd4f77afdd3e09c51749d9b93a75d90c5ece0c6bd9eaa3a37a5612c74ba301f3eff94add6417bd2204c220f90dfd1c927d606604f87ca2dea73556214ddea13d917414d96099315a11c3d302b2b70961aa432ee50dc165bbba49cf4481907e71258e3e5a0734d19c2f008206abe48c8ba99067c19fadaae9a0899c96abd2ba3ab69162c91a215d5da5881e614f751c69a74c5d8ec0541a44321a03bf1bd64ee391915cd5038d361e37ab2792ac553080363067d2aca54e2722fc544d63423332d8bf308cc08e3d08c33f425ce8e346d51f7e7d94c3cc1d1b7fa20bc3b0b457824f69f89454ab1e1384c73e0e64fd7801919cef697dd5c24df6385aa71062d7e3a04952949e71af3804bd0b3d400cd8cf99a4d4460f3a05c4942d15477e4143f86439ee2be46286be9d90229b1d7881036e0aa80270a7e47164d5b8fea73ffa9d7657d06ce2b364414c833e08604ae54943f49c1c4f7c89eb0bad3a643f4a7bbbd4814726d02b7bc29f6731ed9445a2060d0938178914b0beae8f7e099838356247ea574a3f9f003858424155aa5ec5f318ac715bd218531d2626e1eae94eb99eeb1660916db862ed52f8fbcb132f1c00e3c1376729e78b6e1d22f022392c56cb67974b5fb413a1cb33ca5dad651c35be0ac24951fbaf1c6a8b0e93eb9714428b36af1a3c5f6995523ff86ca18ada0e1b6cff976b0cbbdae3162c284d0474c76219d3142c86f1a0f83351ba91fc487d863d747aaf3b0da2d72cec230043712e2913822629c2d91c62a5338c173fd7228d4769866bf789bc1e85307bc81fa78b8c26c24921b415ef83f2ab4875353c289c387a9e613003ceca0ce96edc0430c8f7db88a81a27067ae909a2b2cd2c8b292459df237653802698c8097552afb80ca8ce6c782812248c4bba259aed93063395176eba28cc17072f5e74c42e4ea9081ee104b169026353b9b976470f4c72e6fddd8f1e26616b5677e805d3d2ac71d51f895544efb86f0793ff0c8b699ea4626fbb2336039e2fc34ca11fbf1aea1ff22461fd60bf7d86bcd6f8f9ae30059de7583b8205e240f05a6f43b61d1a23545c3d531801e60f5c0794345072ea829a7f5084003caa1404b90c9ed84876b9c9a7499308a3e0241a4715f779a33cd5f302756b22df7357fb1a26bab7bf02d2aeea1db427a784fe1a9d878806a85b1fa13fb44416ebdd04746a4245ac7b06423ad9b21e193d5bb0ebd73db5fe8db522014398110173f5bb90341e0d9d38ac4f0990d553be5215d6da88cc15fb5145562bd38466a40dc320aa757493a26e4bd8cc12c5200f4c601ec99795c9210c916bb8941452bfca5eab46cfa7f1f174f4044db3d25c38b3349c5675e004c4d29afccbaf0a363e9610678b55dff82947071db794d94d186aedb80f6ae695c2194f3c7cae24d635670899d996977f0b4e3d4ef54190f2e9eabecb611d8e7836551dbc35009415cbba97e50b5a864094a55b5f20bb49b14d7e15f64cdb496bd219f8267b205aa024299fc8a5df6a7f3f7e94a12bb25854e64b6e281aa943854dc3c31a41a6450c3e1207acf8af9259f792fa99350769d58b6df6dbd1522e7596b6677b66a3f76be6f030e06acecf5f68d8a40c61d20a2bb01c22d8006f467573cc7b600f9bf859aadcf1efbaf2efe1590c3541f316428d05647046be359a52d6328fecd3f17c93f8f6847b2314e552497b4d47dfa1d5c91966a806d1636ae7df95be10bb5dc3d0c5b3aa1157770cd26017947593dd2910fbee83996c68d2ae693c959c7a732c8f3d5e9298123b66665c4cc6e24cf14022179dca80aa8292124653762758480566c448f9079840b2df1d0b4a2b50f644264db1291326804cd95baa7bd0cfa24e649777d366b895cafd16a72b0208812025fa3752c8e5bc6818f5c8ebda7fdd367d7bcf3558e3c7e05de9430f1e5672e579c507279ade88a4b255c3e593f410732bdacd11f0d6ee8464b71c0023ef79ea2a7a406dd5e1be32e97c074e302f73b5d99661b0c36efeb5c721d8297b8b55f92ffe75640d633ccd3a44a2c29f639a6361e462db691cf6b32444d6fbb6c88dc21d63b8db2cda2f012b7b46bbe2b253f4a63e8d0f5c2f637fad48f901167ef8aed89c56b4e7bd5f515c605b809ff0f41fa93b1eb003b85f02ae24deb775aff054ae1a8ef034aded829c7a1f7ccb718d58ff522da9f9393dbd1f130bb1dd5cdb6ee61ac3822826f9f61a678d6f207f3edf9538b5b9014848674b5071b07307b715b5b6f93c871ff56b835457f63366df690e1f806609675b9b6db0af3571b0f04420ca7bff53cb0fb062a0c609fc715ebcad55fcd9497e4e898693c690d7153509f252df84b7e9df9533c8d022876f93c39e017aaf07be45c268241c50b613a830b550dd77e7c9180ee43bdaa5916cd223c1566e96044b96e8053556bcdbe2a5c3b903eea33055eb817d7c36aae87d795f168247f29f19c195617b2e40cd6179ec4bbc577f86cd74d46fc1dea01a4f31f0cf07a7851a87fe99d472bf65330d376ea7cd3a0fe1071380d19a87dfe20e16e7399a10ef84f1560b71b9edc08d4e2d22a6f78a89e383b1edec4140b84191317eeb39055ebe31782fec44a591466b45583cec81642b3a89a6c32881be04c743bd5483b7d9757e0cbc73c3eea1d1155f35bef6af62a5a15b48e58589cf7502dc6432c0da755dbb264a596e9ff0ea95e14e0b0562b6367b27442107acd36a6b2ada732efbb8346349a3cc2b148f8e5894cddd2dd0fa54087e800e8bcb067228008870660f41e9614fc98335cbaf334c659e3fc72b442c32f9f9e23840b860f11fa5bdc2bc99beeecb108f33be8fc359cfb807a56b5b661fa08b1cfd2ad182b3eb3d0f32cf68dc0ba23bff5e92fbcb72b133c1497be6a76886014ef1fdd09dcdd1d58094a7ca599d2c0fd99e351d9695d3dc6462e97fce7b823665d7c94140b893c51efc054de99e2fbd28fdd14b80515a91c98254199a9724b94c61a4d07c3cb19c8ebabe8e3d1fe79488b4652dfe9c0a491f67094c6b0602ac27d3e8e59a6bae0f71147c1d6da1bdbf6cb046d5f7d33d07d225e9cde1d3c43c479ec8428192e2563bee28ff769ab87badaea5a9cb2478527cca698fae8bbf59ac49fb63b13e712d1bc2591f2ab0abdaa9d3e11d44521deb07cd5705d453de9339dc37128e7ed3a52a8e8f8ae270ff56b3e9aa27b596aad85546b9f393cd7e05cf82d89f46848855f0d46a375b08c35fa8b37023f32bb39202bc853543d2b26be7e00dc077438d16d4adb5ca5d8cc13ebc0edabedeaab6fb9229a9cb80e6a4ca9af6df21142f93cd4773821d122a916530cc504f05a0e789dc6b5c4d45c0c3c587944c4178e3685b2c496e4f523d2499a8ae5741501b48646f4bc853c7d6ea48356c717311763a3b16e1e8119f78e78835681cfcc4a1d88308e58659ced19cdcaf467c6383ed4f522cd1292b6d920e4a3e8890df8d0a0beb3729cb54ff02580747172ed7e1a816d35123e32e336c26cb58e608705a78c6346d54f105dd93b8849f1a13da4733d8a46a65b54d2af3399994de7fdd3a6f05446c6a8ddc0e9908c15dc15cacfe11061ac56d0501bd066dd121a212dbc5dc880b641977c325fdfc57cc020f8ca1555e45de688208b5d3533425e706c52bed8dc4a47d5dd7c4bdab9348f25d3cc78f00d0dd9dcc4eba2c731b3f2a7f822858930eb8f8a5b24c8ae664f3b736fa65a9d7cb44e9d7f287492555acfd877544a9b8e83dfd1c2c53a7eb1f48fdb7adf90333a803b247492f5212cb69552b7c4e185fe58c45a12eeb2975309a4cebbad6fdcbe1b25d57aefe23ac25cf7464591e8abb495b4a31bb4ba73d06e290a70055cbda55a452ad41dd15add8b1ce9f8b1158bbf5a5d183bd5280393ccd0e3a42d1779d5113d01cb1539dad3aa061b9e30093babc42a2127fe57d97063f7798610b747f02c495b55f1f4a03a38c706466cdaf789eebf82cca093071bea8499e16fa2c9b57c964415419fa240267b33a50031f358b83de58360e209e0bfb43fc69979a47a799f8a5ba91165129a9f4f59e2d30d61fd6787640ae1cead847455f7d5bc35eb7f29ca7441ad3964ea300e5ef3ebba2bac00ad87d1886c8cc178bf4a13493b29332a54fd01f60405551afc63ec6f9fdff2b4a75c95d80d8d12210192192c6ba568b2d93069b8a8956c10b867d5e442e179426a2b88b213bba8cc037687aa499e0aece384522a29388718309f40d5f82942e2a0f337296f3328f75551eb46ae97225411cba07b7e4892d3331b9a570f154ee6cd99293d4e7d8525187915f47af3c6b395a6270a009b0b258fe00cb0dad6f668d1b71a335a551ec3530321c3ab8a04085574af56c120880866cb76a6587993ef5350a9642e810d2f4f32cd927575943b6834ea1785424080958a12a918d49d2a6be5c1a84d987a5fb3aaf54d8c51aa439b29aeb7d901c9d0107f42bfd1833a87713aaa22570a4f5f96103419c0771f667c33e5c4d444c38406c5562f7b2c145ef83ed86bf8913f5f070f3e0d047c5fd9106249524af2ce9f384926023a33fdf978a4c6df9a03533b524166c5c83334bf89bf4937ff87a76981b750070583c7919014c5835284a422a9cb317cc2fd629746718f3726df44b1c9198542d805a578327e6f1fd548ec43063922866ab83303c1ff9275319f10729824c1fc63a4a9d9b0c89040c238079202a7d0ffb2b69250761152e280c439a2248a70ea2cf3a5a03139a7509e1e3f7f59b602039686a616b4f5f9205e13084a0715fc243b0b8f36239c78bcb3f5fa7867569fc3fdf250e8246dfd16d9601105480788348641dbda7250e6dd392e8bace96ae0ec21c21ed4497eea5da02408dc13a9481db8e0f166cf55f9f01bdea053be32c85d1fa2fe860ee6aa0b9eebb58d8812cff4b624c8a3c1dd43d41e7dae38e94ff6df8298a7fc060102b0fc378415461f26c79721b8faa27f2bffc059f603501228034c3430c865ca3def301c5462462777aaaecb279418d7a7b7d688cc9574cc3ca50094ce3e4393100c51ba8d026eb1888cc988c6d6cf36d056b4e181798d92b630d43b25cf3f02195aa0d4883828a997c9616601e8cceecbff89af12881a496fce5ca5c218c76cd7511add428eba094f587f0fd928198e559c1583e3cff159b1f98af8d2851ee7191ed3bcbabf45348451c26d16910c2932fed577670a07b4308c53ea14ccda7d415d5498c8ace6a6460bad15ac5dcf1967edd2f14610e57630a089742f8a9b13e549ede8ec60dcc72d5360c1dcb25d3ebca23e3467b8830cb08ebfdc9d125fa27c2e588d08f20d2a06632d94224626f56c524e9368bac3a26b52c9a6855d47d72bf04ec0044f52131a431468949f7251b3589fc7549a89b931e9df73ca42375802ee658763eeb567e0698187ebe5f7c15843b7ef6c2f9b375341ef43cf77afd621ba74be86555d996fe834d8c11c1c753d0789ba37669a0996e68b59e35ddf31edf2b04c571cf2433c5727a0b32b1d159f77c60e29e556bb81bdfa3b6b3346f88a0d55a532364d5fecba74da018e715d91c9128acae6558a70269fc85e1d904b20b0aef87fb5b1566f1123053c9dbe3db0d4933a239d53170007ee0119558b90cf63d961f5c15c6992ef22c95b022134317106c7d0c56a1036ac8e167b40d2a44a4c62cdadd5d3c77b74a513b7401f98c682b8b020215be21cd5111ef0ae699946c75f7bd5577ae152761ad8ba03fc9f2f097e265a379b954e2fca6575a2e60391e2e84fd160447724e743ba2571b85126a1c76fe514a1c3de9a781b2da681954eb25662ac8715f2e5069ee3752e78185ef019f9cdd6da7c7dc8a6723ec04ff8f543f441d2661d9a808dd914b8cf7530e1d6de2d74c6a9de31cc5036250388ee29851f0e85112066f01a04fe1ee405592049484b0793105390ab6a5dc7168210d89269914eca8fbfea500c077f28a69ce1a366a38fad2093d0cb276f721ffe4c59c1ba6126fa8ee071af515b3de22bc96b8dcf6a4ade847a01d7e4135292718a2d2e0add0384d7a79d3e56cfd25428d885e55ffae1f5556d0ee2f5587346c220e8003bf1a7916dc3ca915a4c8e71b2bc18b5edb5e934e8625bd7c7c29189d842c36baca0a7c06b4c1ba8f1a3579306f4caf559f016df8a5c5ae96a902a7c040f91e3c5fb9848df1702bf09e365c663061b02fd199f3d162d24164533affc4c8f6f8bd8bdf3b6c901e2178e43a27301a1c5902a1eaf1fb4f85e50cb5a2c85b4c02d20a4a5bb47b118072765f140e32963e40f5557b9222666ce8641b8bba8e5c592efdf3d38c801c5aaeba71183ee74c05d48de3da28b21bf531eac910008b6a7c3baba9e60560f036c32c16e6bfd7deb9d16896f5369d2579dea22aa2186a3869be52b3f636f34ce97c0de6d9601f8bc195c59288260b8228852f382aee59d7b668a1b763ddc3134f99113ba7afaeeefaf674025afb1db183dce84c915782a9228ca94834e4cc1f265b5fedb66504aa60d1cd82d548a830e8dea02aca52ec47fed7cd5d296e693c9f7ecfc67a80cb721aa7419db0ecdc2c08d6ec1401428972bdccc593043a5aac9bf824b70ca074d7f63aacf9ba6e72c9a248f78753b509971f0aaf4e79f386e7c1811e8699d46217d87a31d101becc98f8f8c757e510dcf7826f05b43f969dc401b814051845c36cff8c00fd1331ef31efb95bfa324c0cca391282cf75258585e3346cd91b21fe5da95ab2caf814a6784396b7469f4acbcb3603d5af5bcfb15c84f3bf4c6754d404feae786d2f176fe7783effc714a0f7910cba6f00bf6bc4ca2da359ed3734c5f28aa257b84e3a0776281ce2d7902a65c96457c311c89041abf41fc61ecf7647f0712bed908daa0021b0700b1b0c68bd720bef443c118f0baf120fe7c5fa213b5d23c017cff4692b9dd95df857295628c29cdad5c08cba7ce5ba53514834d74a4b660f9f1fbccca1e83e10e89ec0578c0959668fb436e51189053dc331d42a1607c679e4090c6017192103872cfb02f300d47343d7ea10117fea905532dd6b61630d189c501325e06b64d53602cad5aa31e1fbc82c2c8682fa16dc798b0c73216b402a849b564a524e27e620e0855102f3b91be8434700030511c12e84a21d75dd77f95f2f05e1de40da2578d4875106cc53a0864cd573bdac96f65b36950b00ab1cb04bb2e6edeb1f6c4ba90ee0cf09bc347dd955379566a24c742f3ce626edf6fb38ef185be73ece603ca1d3466676a39d692c74f04436c495d269b866c09281724f914bfcf6d0d5be93159e8abc18a72206403c0b50e5f271d7d66a047584f1039157516e222941ec506620025c6981f4a6585424d87751a7eb762dce3a2ea1207608e229a3c72abdfeb845a2660b28ad6393c294f5bdd3ba0527022580a06847c71c7d98f16454a88799e90a43006d69ddcbafdc6a5eca74524bff1002a2ca910682fcf5d991e3173ef3fe1fdbbdde64fe6b2a70ceacfccfde4aae81e146ae88426669d7a754ef29fb52315b25c48e2d84d65d9bc3109bf3c852af1a87189891c9e3260989ce8920dec1fcc835c959d088fa1b5483dec5a5fb397cd273d77942f7389a656c00fec3284ca0fddedb3ad337e8476c8b0eddcef591187079ba00a7a14e1405ffce9f50580e6aae652b7f12c1fc4d514c239bf2a95559663cc0fc85be6c58b023bac754404064b778205e52d894c70d6b31377ad734e5081d885060aca23e4dccd3403c9d535b8557279fed82c690aa12818c3edbb64742ad8f092b6046be6148ccaf2e0363c7d85330eee4afa7237802a6820221863e51e3fd6f9f5c3989db6ebebad5017e3490e1b5a9cba19b40dc91b49f9e914a4ee728e6a3213f33e1c94be3eaa61781603e32ba41ad8a4c5afd5cb9a9f3579e4eccb60e4f8a7739b1432a81a63fc3b5258f0e791d65c7cc97c94bbece688256fe0bfcca66596bc717d75338d89925da126fc4b43e28b0c02d6999af0c197f7ad3d15c4738aba0092ae1952f60891813147fc45c8589f74aecbba9a0827c72bf14fc06253b1971f276c75eb4c1536cc634eb220177d8035cca3cab29519b34cb2d55100f7498bc1f79da8533100e7cb7e9a87b35b5099955e5b47300d6a5fbc880aa020b7096a66bfd34ec19ac5467fdb43552b501ff4a4de5548a9385aa40b3edbcddd0c6fe3702c6137d40cc2dc28974692ea53048e60ba53e777e7ef3f4ab010c57b996431925994d498b6d43c15960162296a1ccd0a4499506644b98dec60f25e7e3ddf029ff067f1b499d4537ee4627537e3b3adc02a3f46cb0588341f116ab5d428cfcd860aa4c1e0d8ab668e0e01471d9597e7e0c7674e242dff7bf02a161d79303d0267d6ffe279dae4e8d0a9be9d9e6c057c8678b79b8afa40e9ea24387e2a217f6c2c4a1e94933567a43242d3a9856c3eb5a175d445abc9a8d09a7b5c586b22d8d0f535a88b6c64b46b4c2f7206ae474fe843962056d41c58a70fa86dbc83c875a6ec6f9cd9a879084ed19a3999aff795a996c9c084b75b33e88f5f374fa92e1e03193c6e45a02ffac065d5ae1bd7d62232c4dca862914b2aeb724f14f498f11c528cdb68b16bc46482c5e5b3d13634d3ec8e67c3e552b4664fbc3cfc123082dab5e560c1aff0aebcb9f4b6ec8dcf5b1b231baa59c32b5578ccc54b109e43e7160ea7207805dd334c63cf758e04362c69d093c1b68c6ac2de3bd707cfcd8da8066765ea5bdea941139c0db092dfffea54808cef8a232694177ab17d7f5c97289389347b83cb33dc72ef157b298766295c4111f8ff25f8f1b38ba00af6074eaee86b17e192db2932c3165eddaa1ee46d355232ee844456497ba8e103a5f6e611e7fe72f900798b31747a88eb6800d09bbf09d34bad628dc7a1b00e1f81ad874619b5f1a8852aa0aef05fbb5b5990e672ab6332d7a0fa638c14a0a0ee024549459dad99a125d15af537c977802974e4944d1000633b8fb48cff0945154ee69047c5c1050e0aac8a581f89c3447aa458d114fb42239cfbd132abdffb87b08e1e15f3354e4944f12f4e85037394897ca3d0a512183ffca8cbf1092e98d3abcff28f118a3a72a0c4f6ee83db674a0647e513684846c39db1c6d4f061eb3b6a147be006d31a3eae30bd86082595a0f136d6993e0cc071c81c9b9112528383107648ce3aaddb6e7be075ba1f4012c601a514368008dd85b2ea506d8719b805112227ff171b2a6c4aeb290d42437939b2442592cdfe67a48ea5227388026a0b21283a8f870281d2fe97973738efb8c499aaf3ded77fb2819a82efade8eba95330e93e2405fb3b11cb012bbbe3a2197220eb55d9de7d63af674dbc1064eb63ea6facc21cb214a1fdf9d8e96f05c7946005ff67294a825168fc654335ba99bb381fcc4216b76da9ecf19989e7097df11dd7e6a4915717d7f8b2d924c35506e02318ee603c74061c9fcc813ca58c1af09d21c4ba754f020bc4609b728edcf2d7c2e4a3248dd5405719c9e98df80bbb63c40c8e8bb99c233688a6dda36e873189e228c9574d37099dbe2dbb8f318b86af32aae615e67e46d290b256fd26a398d4fca71691f8ca390b9c7af221f079b2e02e1072bea6b05be4bcf656704ff2a980bef27498ebccfe51e289a86fb44a365419be647ebd08c180e2d256aadab69c3080a499f9030dd9b96f0779117d964c0c8d0936c88f132cfeee15365592e46daa6f1f5c884264af51f876c169010a69dae6fbc3382f048de9bf61338b73f4ab5f02d2ca32f84f91c45a7ef25a34a9d4daf98d36a26a1592cfc366999369f75d1fda2262695fff49a071a14afa7bbbe72385e9be60a9b21df9e09f435e88c09b615185c564375cb2d1433dda29d0a9cd5eca59376dbe4ee6b4f467e2296a18aa4f81ac02213296990b283a1d36c579e8dfb8f846e4330d139c598fd94cfa777f3081f2bfca1cda029e63da1b946f213f9da70cc6e29afe479444673a73ba945a1802fd87f7f299165abd1499c79da2684f26c901677ea1e453cf7a39e774b128905eee31cc996dbcc17c040c9359a9f1bac8dd063436c783b225e722f0312bf93730a1f5cfe16de425ed030b6065e85f8fdd6d7734ec1981d52205fffe8daf6d5224b8137bc05981ea3109d4fca1be0c810e99307cfb8a4e131f1ab357b785ae0425e8868d71724b79f5a71cfe61b8cfdd9327de5a1431b1bc77fdc804339982b96e026d4ce8ad1f53cc98001121e2f5225b4fb84a22469deab4fd2780d8e76b3703d467a465634aa08f79f01e34000bcf3f011b009c28b42c75a45111ca824441c147a89a7cdde1b242cac3e6443f8c2dbe8a20151f4962d6f62364420d65fff06d5f034d2da4b2746818b286b09ea7bed83fc13b256318e407c81384a7063382ca1f8bf6bc4e48517fe08c6297b06d0cbd6019414690a29fd30cd9c4342854e4b67f347c861beedf4b02b3d424cc0ac0a4b78410952cf11b4f2166f90f053cbf38fd104af7161ee364fefd5211423bbab5449cc5e7f035f2a2b1bbb313e110d0ee4d1b6b58d44c1c3de90c0fd0beb54ad1dc064b6b787c8ecce420137a3ed3417039de9765813397e3cd8bdb4d0ff0a2b7d9a6ca0031f1950fd96f9012f35f4973175c656443217d9fc8dabcbb458d9f112ec68a7987a40ca812b17fc5bd67f6ca70d89df2fd88d6cbe9f44f2f924f355860541ae6f936a94a6fc65b636c0516b10c5029573b44d9a529926d1ee84abaf68daacb8d4af046de4cb1747fb7a8b9d23052118b534a81f5bf6078bac85b7666cdd3e3f5294c198a43cf0e9edc3279d288bbafca0caa7ba44c50d432ffa00869c0d3e1a859c73bef7c9142888e02a6188e5aef0f762b117949480a72aef49fd642f2a7a2bcccd4a20a0080b249aa1608392fdcb81c6249d32d21e83c2d04c65f5542243e052756976bf7243471efcbace1a614f4ea7ed4de64a7ccf7a5900212a51db03b34be2f41b563ddd989fd079a732d01569dbf802727ab65aec2fcac2df7a1b7cfd05749930a77644d4d55c136fe5aa47a2dee5d9004a373c0136c9e2385c666fd415dc1a4e4d3f0061d313db364f6294f60f2f0ee974bb3662bf87ed336634c4531f8b3d051a9fce19790eb924b833ebe8c045ad312ee7825df5b41d45516708d2f9ed2831f2ca1739cdccffa17a318e66b94011c975c1721d8b63593596450b23d0e9b6cfcbb9ea1c1285abb561b1cfbb96417c8b4f922f6ab7f2b0ebd44b9c3ea59178d252b384387f44bbe22e05b00ca713dc5e67367f98fb8cea641c7e803d7493737022d1ac1da6b41f48839342eabb19687401211ce6f77d45871e878f9d2c18b1b837d4611640dba82e3fcb827ea1bbc432541546c2bda81a01879bb2fcff748711895c0ce8d47338c150faec01c85fd8f7b8707f37707474b9fc378479f3f5b93e593102acce44de8a84fb2c62c350716904f1ebe596ff6874ce5cc800a16f6af99dde74494af689128fa7b4b0ea2d2b986504cdc4f64ee8a74462ac3b51824b59751aa3191bbb0e70af3a16a865604df4356e8b3157aa03b55f192b45f72d95fc552c96e033a827c6f5937da44d6b16c78c5d43824603f495ce7d309ac420e9061dab768eafa78c0f7bc4cf3e57ef391bfdbf7e74aaeabaa204e8152e0061a6c2a71be0e8aefa0fc6aade9e994bb5439b7ba8de53456d61a84d1d59c867e50ea969df1cebd011d801e9a3139ed3bc2d0524f99c2234461e22545a408d539650b381defaa4f9a35106aaf89c038acce3623a0e9d0eeb3d3471246e03720a60b6c748f3368de922502319eb716bd260d74cd03a364c97f76bcb97c70018dfe9e26f6982703eb3e3ce831deb0a2dacc92b5d8576e358da850fb49e084a202fdf5d97f57dd4d145e48068c85a0fa46ab1836e560827aa32802c61544700fb0e0a97206ee0dfbd650645e99c0a686fc7b5f2d9fd95f693ff61dd34ff208cd4f3c26eed4a6267dbf574c3f60e4aa680e741271bdc522d21eaa5ac46fdce781b6c9a380766e3ec3372c75f2c57014a42735d20ebdc007bc41dcbcc3a808ddbdd24f99af727c1e42b24d9d9505b3973164e6068ffdd8d172f8b1204a558a34d38a743e5cb88797a53bc4de440feec468754caf0e2c341679e6840dcb677103d87f343db996a5996a20e60af6355c6392af3b5c90ab0fb180c9a20960d0e07efe1df80c242382306ef787514f4c186bdb9a514f76cb587dd556e793f36878c9c6e725db870ec5e7c5d06244cc3e4e6d1c64bde84779756cddd44f66391dd7077618d51985ca45cb8010681b75d7112f4e423a217bbc403c3e4432225afb5356ab59f57109fb3ebdcc919dba08b8e073123a789de7669b91a50dbdbc5b866b23c783198f4ba3b555c71f2ec457c5974f358a687724f111532c3d9ecf3c947ba5c1476720ff0fcea5ee031a0f282ef3e319450b873705f0a12d108442166e4494f4d82f2d89c3288c7b7ac5177037682bf9d0e0f404071f1f2dd1848fc8df11f88a1f5be4b4fc098161b2233d17c92acb861e5e78b83d2add5c58dfe591193fcf52413ef7bc7fc3102feb4c87d8f0ccdf64177626125f357470ee2766f9f806e8ca4bd79e2311136ccc045bad10ab2d691de1cc6399433e4b1f77b2eb47f3f39d32a98f2c96a93b0303c96fd8a2d8ac0a37825f07da91a8d6a7a270f0d43717402620713050032c60267abfd294e53a0a9150eb65445455e32e6ed4dbbae7858be4d8841e28ae254101843e3f887e369e7668ac383c38924ea08a1eea05051ac7d754e87324c60e805bc12766e826a6c7082d65a9e4be20c7ebb4511f6a642345129e55156d5d57442846aa5c83387d82cbcd64664cb737a171cb1b6ce97b174e37166aaded1ef2358695be1c94ccdb91495f6692e1114ea21bc920e6380fd997057788767c30cfbef53b81a9f2289eca0a4804b048f7150b844cc93e49c3911e6257f9a3ac2ffbd669a9064ff28556c04215c11ee35d110c7b555b0ddddf12078f2ec44d6d95e3d0686098a6848f3c6a78b55845443ba6b16ddfeef16f8c6015328ed8d5c29ec088ecca5dea9d0cd9b68fa4200671e553c2955620e651ed6fb4efef1846a70878639ca22622116f5fb8b7617b348dd54b60fe3901027444abc18337eec0936a3a880b01a74cd97ee2be11d8972df3af7b2f2d384b22fc6ff64264f698a3d0ead5aa4e63d913c93f13bedb0ba8a5f7af021e9db01fc76c5e4fe944ab6b7964baeebdb6dd3c056e20b70615296a5061126ee1c6f4947ce69e08c4b99c4aeaed95e91b99aa0336c2ead865cd1e507aba16d2f88fc695a47ddf946fe0c19f511602d98ffe48b51ffd11f3353dcd139bedd76969ce674cc201d681c2ebb7fc5ca21e4bc53864de4ef0f96c8c1513cd01e26982aea0bec34c8791f0677bad5ef617643321e164506ee4c16cea4a2070bf64b42002c34866ab19360ddc3557576f9add31d6feff031b49eb6e490922dca732e7a368e6b131910092f574b5573760ec0cf788a16a40dcb9bcb91e2e1bf455e3e310563d0fc8997bf67b76f03b109e46e862bc27da116018ca32887896bda74a05ea5c111daee99100b11665670fa740cddd8278ca3f9eaa110385b60f11db22479dc7c6cc85421681278dd2200b23cbfa8fe618d275137688d335111b2823082cb66c37f76104be175c918f9fdcd86cfc34cd8065524ddc8e741195f7a9785b8b791d996dde34e1ca109887ee18def52ecfb4df4b759483442f4d0112a357e35321dd1f325e5e30eb3c97d8230d1e84c5ac2295f54f12608c78391ae7a69f18c647cafbc20832684d3c06f12e8443291b8072c4c99e1b8cfc1720bd5e19beaff324ae5f874cd0af84ce694d00dd84bf894122bf6a53199d2ea8057db37e14e9a057be7a7dc82a36a8b50bb9243e9c61b9843cb8867c50ef273781088640da142595f80997db8b485275eae9ca772ded5f9fd685ff701d2ed3314de89634274ffb921639ae2b3b2e6dffd395ba0d77c0722060bd2d94ca323b937e2b8056ac6dcf2afa5ff00be75fb102e9e7c947066001e80c7a519c3503a727a3df72ca339f8db338a7a6e2b974d68b5e4a2f75cd283571ed90916b2c619b09e3c9f4102e74fc9b479171f05676c35ee8b2dcac462c8c223fa371d7b3c1fdbe4b04d20ec20075bf13ce68a7d1fe73526ea8cd829f32d79e0b1eea0ec7b7afa64fc135f9c8cc002d2e2a90351102231ec9a2962fb96d8d8f4891e2246ff9130197047cad5adca757c74437d21bc9c805a837a4b62636b5149e15c02e26ebf6ac42383ca48cb489a5c08820deb1bf9a309e0111b3d42ea3cdf09b581346ea12c69a80cf47e7b427fe0d5c641ed1e23538b315cd23d267931875064a8f537965db436f47269a60d6b6e1464596d9179e3c82ef4851c9738c34062613ded7d4cb8298c60c9f7a96f4b109bd75dbb9e2620a1a9e8954c3c68034ff67fedb3adcea225a5d96a5e03dbc81934f53406b997f454af585772711a7b3cc9d3535f66c80d2c12cc3e3d1813975321fde4493058b784769d137e9ce2a4a66e511f2c327e93334e40cc3ea1fc6f03c2aea330ceb0dc3e340073948f5d991cbdb0d2715dde35a11949f013bbf3d4d90749db3b2849907eb584edf1cbd951787be304de7989053b9e384ef79278f749267ab4c62c946a260eb9e66fa223992b44e564ec5c45edc0355c3c0370a9524e4429ed68c90cc30d123bf40994bd14c25a754510940cf2ee9c14630de2b52efb7a3b8c7781f2ec77c2193a8a0941e37eca682b2fd337c74a4bb12a0f1477758d9759f3f07424488568e1ae9c706c6b08ba1b8b868a9146b9667f85e41b9b7664fb433d04d67ff32bcc966df0d2044ffe35ef26bc05ce25917c1b492822e9d4de0064696d9df6bd8b280e1dfb7610715349ed3ff83da7639edb2896ddb0ac3be364a6369e6449a0ec7fa322a11b6d66a83c205378391d746bf7e12bbb1c7aa988fe8c08be9a0d793ef08a8f3ba56f32589d7a2303d665c4568616a7e477a2975a1fecc8ae785e61ef148056da1dcbaae4f2bdb96d37bbe87894292dde0eec39c426a342190168a17698ca7ad319cee9ee5f26a0c174174588ba1b61959206ed371367f505759d6481572db2376a285d09ad2f92378797e10881072dc8463f4a2e00d85778c46642a0895f65b071b1803995420fbc871ad2a698552a936d99e7ee844b306c450cb021fd073532159225a4ce29179c47c506b9429cb28dca138eed324291084cbabc2c4b3c724d1977d463dcfdd439435132eff08401140358b5e7abcf00decccd5df4012ac2530a2990c6455664eb910c589bd951c91a8c30c7eeddd785993d835d1000f87fa1f046c26fe7a034b14f9beb1b1e89d68662092e629c149e423a359f7659696f27457496e3e2289c1d84321e371dcad42e5ea4cef279ab217b78dd2df8eaa6586f08b01a9ac77b200206e079f6ce107464f3568d586e9375f2d383a182132f99ac15ed8c2d15b75cc4e6c8c3148e6e3699c12251a83eea859cbb988ae03ddadcbce8b49d04372a319a446eefa6ee2da51c6342519363918aa982b18bc5700a4a5f8a5c1a77f38bdfc67fdb089df5380de99ad73fd168234569e22957c80e214b52f698cc912a0fa817c4ac45cf732251e4ac8180c015ddf2728f271a0bb63b40ede29c23487e5dd5d7f3b75836693ac86ce070aa6def697a6b13062f5e6d6a0822a5143a14b28e60ad60ac30236ef71e96dcde405d68b3071941b79c0f70cae1905a78e7ef9c73c4c167743621afff5112adb2488ab866e35af5acbd6bb9e0fd2f8174feb0e3e3dca055ba9429705d6c668d8ed95c88561c50b84e8fe5c69720d7eed3a83237963f461e8627a0b1ff92d492842afb7a14eb436686ce71e43df5b7fbe7c4948ceefd6dda4509c836d46d619f25690c2b8cc1f2a69a20456607c8da030ae6f9508d85508c22eebec9e79505504022674a2a9ffa6bb1e54724326aa91d41883c53648b077be2e9e5864a4d5b5bf29bbb283db8a055020c877aa42b08a957206b8b547f34b5b692aeed043340a3332b229d6824575088f84851072afbb648f8a0ed3ab031f3134107ca614880eab57acb8ff718a2d23b6b9b0354f76a1479fe00fc676a4659bbb04e03bebc62c60ad9f56b6d4b5e4c959e430947d35a1f75638c200c71644cb4485941e2756dc00f9df4ea80f8ab3f86af5a7eba9481116bca9b7d24b74cebae16955fd8ec94c1d3a2d957684188824674aada8da4f87a5d10683a8860a50e1e9834c6ff5544dae0ab7be4280a713ace8cf28b405f8ec4269767a74649e12ef07b5a19050d218c530d6c29ea1b18d2133cdab7f0fa43661851b6da737116e2dbc401d208b2453be61488c657218efc64e520466f1c21892710ebad3dd9b8983ae22c92ab7004ecfbd06933ad5d31d3094b0131825b10499aac357cf4908b374efd10c81b5fc939b6c5a3107a2ad3b5f4084ba4cdc24d13e43c57e2ede44e60a3bab70e71f709c4c0a8dabd805adc12c73a9b01e9ba9f4aebbfb478677b6f6460bb135297dce487435f47bea5e4532e3182be4d2ddd3f2f06440a93005e4abd6009eaf521242c6fdcd1f2eebb3d5dc853f591835907b414ad9b16287f084e8fb174dc7a696d70fcf195d4a511c921dc79e00659595b6550edff40083121a4c8ab8ab7875be3813e1c34e63877092b656882cc976f995a34cf117cc30e30844707e4164eb91bdff4c166e262b7dc128b2e87620fe26d3fca32a9bad41a95d1df3ce2881bf832416b5d6692a128c3dfa0a1b31136f669b4dee3ecd1a7363749172cffe0787cb6870a47e700f2259d43515406836181ad5776a8ff3cf5915910f586ad919cf875cfc3d35a3f814e21c9f4d921956a29a1ecbcb9033b54a817eb0725fb3931db55a027a8fadd840dd7e0e0c691a67e4c1adb61efacca5ce07ea28bfcfe5112d0e6c896e5687b236ae1f0c949f0c89ed968f07fe49297b2680fe27428de7411d3932f50a040d2dd4bd89d172d49ff3fbf993857eb30d0e19763662ee4f6add3b37e273ce65ca70b2693b88e508b53031ac7e5290d114abdd77432c2f8a7636ea85a2061337365374d623ce9812dea8d0fafc9a660aed715a386562846ed94a55f3868e0a151c186032f68fe65d038118f1b94e1f8fc3ce80f73af3ea65834d8556f459e9929086e65b19a44cd97081fd46071e82c841a3dcf2d76c1b23160f54ab5cd0912bfa3a23af989069580d7429db033ccbd7d5a3f4fb66f258b8dfabf16d52cbf992472b16cb8a193456e3c322d5f736984f7daa2fd5b0e63d3c191796954326321b8e94766e9644a5f79b3ca394bc1801a8abbf45241e6a3b0c36dc59030af7e385591bff1a54e6b622f888d034051a56c7c3d650ae8431f405021ab8949c8e750bfcfed5b3f1bf58e174e9e43f295198121a2fafe3eef746207baa44d77e3eac97d47a901e7cdb769e9144942a282cb7682351a744af2b8ed865d21ac51a3c331b63ea5ea00b35610ca36a66e9cfaa87dcb546d6e31684bf197221d16141a81455d64e628a8677efd0479cc0c47ba845def81d7e79d86864652099ac6b02ea28c40d10aa366aec23a5326b71b5e1fd66d78b813324008538efe2fff289e51c461a7cb218a7c80f1ba0869f89334564c112251219d7d849c944d57614ae5bb442268e24c9bc069058122b911e703b2c24c3e24dd65bc8bb350eaa8aadfeada52920d779f13e11b2687d73ab80044965e09268789a6c090969da3b0cada66c38bbf1995368660b35a83d7ae06a7b843ce2bece287ff51a02abdc6b378b9d65199ef0a72d20219495fad061224d241165a544a7d7df22322786e74f59199b682bb014a98c170b1a39e52e9ee645184637613838b0bcee7f792d0e03dbf492390f1790c107a2174864ccc009e34995b029074e0da5cb58f52282adbb03e9028c0abd48f6d5b7c9f01f98617ada1e93d0d45a79a2718f3630cb1e3c51846d0612e8c08560b304fcf4031ae96694572056b24a07159d088bb37ab4d38d0835da51aa8c37e30f5a145d4c1f95f6dc3df41cdc7f89ef4d0f2b5a280998d1ba9eb8412d2862063671b8617458bcf0b2f0f1ec2812f7f2761e7dfffffffd4ff6265bee2d654a29052f0909092809ce0c050a43f9ccf8d1c44ddcf4352971539307e1f0516742ac3d6a5dbd42724b7dd9fc3ca8fbeffba17383d983d887bd51c70d75eab85023759a5d17e2f0e1e0416ce54aa7ea1eb041aa30871d390e0a6a3f053d67ffcb2891992425e1cde6264dd3b4ef4971d4cb90a3529b73e0d8337e4ca0107165e241dd771772538bad43863772541f018ddcc568d62eb1ee9ba29a9aa2a2fa888df6a14bd045f40aa494b2e3af518110203cedf9c9987f64f899305e3d5445e1ad90c4a9cb4c9849163281ea611f1c877084a96cd42d1ac2b6d57449ed1f4965186973936ef5373b912d6cd01622691af600e23853bc71998a780884890e15deb8501cf3e9130927c0a30f5b1c72802465044a9850b932f11828bc02ff0e063434a82b266aefa0f6e43250672797b75f9ed05f000b51a52376c09efe3eea3e2266ef9fb94e0cade383c7beb277cfe33a23d5afff0e9d11eb80e13430e71b9c4c46dc83ad48791ba31fbd1a43e37c37bffbe272409de73136a845b01d436aa2d322d890b29d76f2203e8a2151a49c6e9edff9ca2a223b5fa444f3f0ecfc0fcfb42cdbf99dffd1debefa1d2794f27213c2d884decb6f0731d3afbff7dc04695e32135be11edc85d9c94a759b1f3d1e48ddc426ec02d6bc0b1b74816df917e9d80eac2316557301998f79ffde52cb473794783c3ff2110f0fe223a46ec23d3ac63aba466a529d06dc15c720d6b907af8e7ef758cb239a221ec4aabdfd349ff0003ecf67df4478be48892cdc164130ccbec33103b59f871ef96ad7d91d3ee1e19fc7860f79c2a29eff4109d80b75e67b106aa05977f5fbde2a88664f5bf43e87178a586887e71b7cc2f319f8c4033c3c3c3cdfe11310f0b0f33c08ad6a084f58d4423b3fb3aa31e11111c3802fe048a3e24153537c446b67db59366512de8a65124edf18b1947e32cc69f2be7e75de56bf9cfd59fb6ff8851e73ee5e1385c73e4516575cb982a972303844fce910c77149781c87f38437e79cf3bd07daf371e1ae8be33ec5fdc671e17844acdc770dc4f5d4719d3490882b8d3571dded5f778f66d6b1dddd9e725f9d205efbbd7638f650a9171cd7dd3dbbbbbbbb7fdcdd6def6e6fdeedac05dc7577777757ce4ca3a9996974cb34ba750bd26dbec875edb7c1d1aca7af48a5964d2a25d5b2d9867b1bee6db8b7118458d6d3e7ba66f681d9febb1b11397f58477f90ae1b4d6faba3b5acb8f087cae933ebfef17136862e071151e1bbe1e9f413e9d40bb4ce6696cd9612bc5977c90a2c5450c192153c5802133db0024a18fe194b4e9bee54ae7a93744529cfa49487aee88af2d015a53c5c4ab2945366736bee91fdbae473727e952bf0ef6b85ea95ab0ca0ca5f06d23ced3dee91bd7c0d7cb1454dd334eda56a487b5074e2699ffd1845f65ef5e4d4fe47b714c3355442fa7f34ab8064ffeb929f8121eb604de1f5e414eb90bf2579628b5286485e5213545ac1e447e218c21be9d10976000589082780810410d60b2a595260858923a27cb1031e1891a9209531690172d5a985b15a9af2059309aad49e9e7c8a55952750a8f2fbc91be9aaab02085594f09c78fc19674870ce3a42c2ca61d3ce5e526609ca30c489976551781e645dfefead0d2a00b7fc671886ef0faa3f0c3cfe1838d411c22f9f439db9350b695a74cf62e08d2c030c91610daf9f25a5f8f9fea19c3635ad8a25740828a92a8c84d08670da88c888d0429b9060c6b42a6210845400115332294700e19222796b992081028a60f2a2601a9c24555125081a58f0e4ada50ff3c34fffb444e07575ab40614104d4173e8881020ea0b4a0700694127c48c38725218c98c263eed147abf6be1d3e2cd981ded7a2949ffd942c9d78f2b746e1c9ae6357bbe31eeb7d2357395d7ede1a9ef410c90c8e81100294cabf2f50d58f2ac74ea344a5cb4a6e97fe3a92fde55355551f1d5413eb9c90a830421dc594142a3fd4714775679f3ae006f81085038fdd3d03def2e7a4e598f66662726a402ca5c494b4af557b47b5796ef1cbbbcccbbbee2f594a29a53fbbcbe94bf8944b48ba03954ae876ce5156ded1d7dd7d6ed7ed673ea1a2f639e62d89f1111bcd1a780cfeb64422146a9af1f33da97ec8321f7461fc90c4053318021b48b0f1c4162ef025234820fc208d0dc30a2c54502e62204608360c2a94e820a2a80111413461c51629e613543cc992bc20aac9921c3861841c2009c9d45da2e2045418415997ec52aeaffb0fbbfbe24ccdc9a5e694bed3478b3b7d939967ef99d30f86393316acf4f9b548a9d47c6a99bb53f7fc05e27f546366667a84d37eaa25993d70f70b7082f0f8a1b668f16056ee53cdd9c185bd9d7c7f22d520c1db976afcd775b787fc662224b23e89e92c8085e6b3d00c8f3aa1f93a4160aa3f4cf5704c529f7c6086d45beeee04b1723034cbb22ca39452174cf1831a34955fa3495514c10a57f9b31774107e90aafc13092a5e9040c2a0326f7142e5a5f27753073989caef7d4a4cb85229156b4e9516540e42f570fc9a9fd54032955fb008c112a1a5e2a3eed2882bdd3d0c222485a12eb8a89d85d3c3f1abac22bcad445cc765ea2534163ff6c5aafc3204d9170aebe2e7df262a767fc0b053f97128eaa0258201c870aa2cb20462142af38e0dc76d5a29a1b0af7d16703b65f33c4de129970bed7aa8bd7358973fcbe51ea52c5072994b1135449f2975dc2ce28e9fce615ffcfe1c730846731e86d7bf54c695daaa20371e185eff4ef94d4260d2fd532e9722597cab8ff53378fde1f91cfe04d90d77f8ec87496818d2a2ff0c59a101dc86212d36ebb4dca1c8779ae8209ea45dca12abeeee51aaf7cb65225c8a649101240da4e3d3891cd471b354c7411d774bf528ef70e4a3f61f4a0668a0558281d2376178232321212121f506161529215f7e92da034c93d0f65c4759ddacdab1fa4383194461243662a7f6b3d20a414a93d52285c6af528e924003a1f954cb32b044a7a713b51f072ee30ac99be1c849d38974007054e0c9dfd1416c44b776ecf0f161b1562b24a4f1e767859eb61a74eb679b81f7c3492218346852e43b25fa026fa49e5786a7d33a5078d5078f1778238fca38108166566c70813ea7d2c7f3993eddd215e73b28579cd3bb5d91f967bef2ce8afcddb6f85795c70fc2aabf6ae367086e7f59e342559875f9b30e73577f1fa52ed5ff874850007649698b231dc5a4388247f5e75e985e411d3b987ded7bdf60e99ccbcc54db750791cc5dba31f306aeb7e6fc49837431b8658d3f9472f85e1adeaf385948f0ba21b4940fb2094b5a1c5551a3cb4c428225253021e1042dda50c284c2092d2fe20c1b6981b0c61426a2a8c0093880811a501c21460649218f5220b865ddb4c06b4e22c47df645a9df3e891038c45beea4d39fd2e94f7d12a1a26d2bcab62442dbe72d29bc19c6accbe927e4de7b19702a9e0c9d0af94984f8a5b7fc930811f156f69fb7fc95b0818b94b0617e1616cd90c32cd4b1613eff0c89784b4847fefc2a3cf0c75b2ea512549f413f713390992a85711b55d5811ca8937d12213ff256160e31ea286fd14f228484236909a698d00a29c14f7f8557c286feedc322ef3bea578876a863c3f6fd423a94071dbd6a8067ba4c7e5405a5a19199c42d7370e3c3dfeff6d53bdfbcaf9d97cf6a480fd3d81e9cc43ae4b7e49dffd13796ec8093665b37b887f6f2c66fa0b7e28d1b52c78d1bcf205df1c68760b7e28d1b3f321255bebcf1db3be8db167e6f7f23e4a31691963012d3be364a299ddbb67d2f1fe6c79eeafe3d4339ccaf6b1f78836907eccaf2c6cbf0e5f7dc06eebce83fc6e0f871ab39defd7380384016c89f55bef1db86cfe0b8559877d5d08d23620dbf55423c90c5194c2085cf71770394350c290cd34ef4f1ce55439de893fd8f097ec4e1286dce29a17ce328979a1af33b6683c6872aa79cd27307bddef847b51d1e77779e2b4c13e4df9161864fa337f0805ba90c2e77c04feb181cc51df0d33cb06b71d5373031adfe7b8e763facba626228bf116e9449fc49c2d37e14abfc61256cd00c0bc5c43d6e60daca5032dcc03d90b00ef9854c4c5ac73c2a21abffe8af7e5534d0ff543330c8460cf5c37a16615ee4466b78e34679686407362ada818d36b063207701398a8bfc22483c1b703ceb7f3497c4f484373253124331ed0b2ccaf13afcac67a1acbb01f67c08fe6f20f845907096653e335343f33b7f464ce13371fc80be1fbfc7ce8fac9aa5006edbf2df0177758caeeaffb5aa8b200aa0d370870682edd0ff5441e8f3f71f1ba578c0aeeef473be2807eb7960d1ff582c168bc562e560e5c0f139fc7b5efe4bf0250f0c4ec334790dfcf9687a402f07b8dee209e98a86b09d704c5257211bb528657e5d270cc7233caa7f4ec838e11716edd0a227026f6428661e3e70f0f8f1791f8e276fe48e7117495ff33c1c373734a43720f736e098a3662111d780e357679e061cbfce844c0c9594c450ab4ff4f91199f5e327036f6c26947a1eeba9b34050a6004419b2775d53aa5c2c90b048da97d6473eb4230dcf816c6c5f3eb89192edc147ac43be6cb922d3d03de297c2470e76c7806ce5a4265a9453fee769cf494ef695bdfc1e9c6f633ceba16a39384cbf37fb1f9e038e3d95be0d387e5b48c4ffa37b3ea9276435a7a38537a5140f62b54f95b3d2df2143d1fd354d63f99016ddb5a11d2dca9faeb9bb873f5be53bd287513d3a3b365fd26cd3380c9a492dd39848c76ab93e4052feffac06daf9d5cbf769209d97dbd39ac7f9554991b23ae44f1b2d6782f46dc0ec73b80de4ca03eee2e01c58ad9353d37eaa86e6c3681c27b32c530dd1988c66dc38e0c8aa33f593079cbfaa4dc3c18356dd62a9fd9864f5dca986769e53694f44fe88e3959f06e7573c5b0f76621d47583943783684445a944f1f07dc791e50e7370e6c8b9df8e504ae727670f1564fe5ea6f562b1cd8487e28b32ccbb44cd3f833d6f8358d5552ee93012a0fa932540efd351b671bed1d84edaa866cfe47f37378e4a7fa3bc80fa312e2cf6f03f2fb88dfc762411d83693f323bf1b8789a114e72a285fc1ba83dceaf6a933a60afc0de01fba88d5a94eb922fd286ff9ee7a438e1f4c0e3183bedcb5f7e0fd8f32cb474c594aa42dda5154851b9addb01717e05faeb8039dc64555936e7bbf365b2cf62f3733ef54c56cee7fce855999c9f116bced36cdbca79991cd8cd4b1b4e4543f60cdafcaa82646ff33f5a03190a47d1ba09a640afad0292fab9deca09c7ef8bc0d7e12f4a22d4f33cf43c0b656fd3036adf420c0ad13e87172a7fcf73cf3bf8c4033d3d3d3dcf604f58d442e0ab6af8079f9be0290d84f3f2198a9ced2585e12a6f8f6d75f07b9f037e20b860e76d215d1787e31766fc37515a942f6d42761272528bf23d203cd6d802aa1afe8bacec9798bf87bfba813776ac911a481ef991d956edc11ab0e61d1c8754c93d0d38f654999f01c7afca844e440c038e34f5a563dc3b0c3f5a943fa481fc191c7f5b4d49234be5a74758425653d230a332cb9a00af0784e28d0dc55b3f2dca90478b92478bf25755030bf5bc149ddea1c435cf6c0cdef632b353daa66c383938211b754e185bc22276c596ca2a205d659ea1b8ff088e58aafeebb4c9cc99f7fe6ba06d669b993321cf99f7dfb6779006fc544333cfcd8032328fa45dc667405957b56d1f64fef632a091e9acc463a175550ca9f79e9b41e6b7e75a45c3cccb84d1a5cafccc732fdd107dc9fe12a4f9560991f9992a622ca937ea56f1a24b65150d313133e10e560dd53cf7a3e5fcf6b481669e478b3099df3126a93ed4f0c69f6a0426138e49aacc1bf991097db4e8dcecb6f7a09c9cf047ba8536e07c4ef8ab67214ed6e0502465e35024bbe4c436b0e655aa20335ff332a08f167f1a0816c3ccd73ce772e7737e2392b3b393f3ae1ada5435c83af3379f6364e66b5e82453aaf63130a89f91c5ea8db1725115a3d0fab3066cbf92de765c0271ec8c9c9c9f94d27272cc2791d24b26e7f13fe34d04c081b3949a68aa126dcf1f38337728c97c87cccc77ccdc7bc3fd79c7fdf8facbaad827e7ce647afdbd374d00f6ff96fbf3d6f0f1c5887ff168e5e8bdfe69f8dcd8dccff6822fe3fef8f03ccfbab54bfc950c65f158587f3dc736c5f32ef3ddf0703859301b932946d731970ebb675db16ea6c32bf2dfe688ec96ca11099f0090f398ff31b119c2f52629bf99c9c997094f96d7b9c4d666395ccacab4200ceefb66270de655ee61b88261cb91ad95edac8af79ce8dd8fcf7d90e329ffd28f3313fee506dfe03479bcf6a6ade553170ddb6c604a9091db0dec27919d026ac0147991f699d792eeb6a40f93423d79b99979151e2c1e3e74746e6c7af9bcc8f5fdddcabf9ec6dfe47df803a78bd9101475a657edbfe876b5566bf81317f038e3bd49ab789a9b951d1c01ced6ac0ad34b44e70e498ffe13bd418702b0ee88123ad5be8fd0f9fdac3c4469a3a3214aa316d3101de7a8f92670403f2bf6eb8aa21bbad9543926d1a94825b16b7a5a0042f539c52cffb3ef932e54ab7e422b74899e5eb0ca5d3944e9eb73a54cd19c6d055a98e1fe52d8b7d71d9987642e08d1b535454038d2f53b234d0f86969a07163aa3d76571a287b62f251c4a819aa8de8981326df82249bd857ffec0bcac95bfd947adef7fd8fe2d6a5c5dea2dadbd868a1eef3e8a0d4c684d5d1bf5bd4133ce9d44057f665d4405b7770f124d4cf23f7a02dca5bfd0fe54bf2984c244a3deffbfe9d6a3fb7eafe76344de8b180fc37c5bf0522bc19760eb620024f470759b587c1544d8ba241be16eac0d57584f0ccc0a548b8ca306aebe2a481b693500dd42e7582c8ea2fab87230f955f9e6c946852a71195e792cad3a8b2ec52f925970ef22950b349f5291ea4925d5cc988698937d59e46ccde5289246d4a9bbcd5b4c9839e9a9a68136daa4dab872a25dad48637f2539353652b4e3c51a88164f7d41bdf206da5b3ca999fa90a4a5b825b964ef6fe498424a89365ae436937dfb351aaf245529d3fb27cd449b5ec4a9d2f756ae8976f43bf0c8b9490df9f8536f06f61913f7fd315ae5ff66c9dce699cfefaa66dbaa6bb1ba669beb3de3ad55c77adea97e6df51dba7368bbf797e67e6fb69ea841dc30947efe36791b986959861f8a90bc78f0bc74f85a398312b51de58d2ea8423ddcf09470f271cbffd2f1cff261cc51fa7ba5f53d4e2fe0ca8e44f1ee4635b1b138e9e172ac184235585e3b79f0a9fb670e45179763c6969387e9b71d4e7ad56d5aed439e182b4a7bf7150aa53bfaa2156b7b4dfc06596377abd55b603c1f9737dc415c5d868a4557214b7bb9ee4634be14029a17400bc99a4c2913a73a92c95a5b2549651aa75777777a7f8658adbb66da3f9946af324ea4d5a8c62448b1eb6931671a078631f31a9de40485bab9e38e19653e0ad15509c547f19c340befa56d92d10e13943e1b6527fee2e4005b8adce5e554f5587ee45d60eaac2b4aa838caa7b8191b158e5cd6181e7deb5db17112b551db2ca441cabb0172ad3e0c52a7f17846395b35851c6165354e134c594de6f75ccf046f1f3544e58562d761005a255baf2c21bc5da3cc43a859452765048291bc8a594325c4e825b393993383314fe2c41b946b8ed9b167838bb5c6a531651a0c8236994e549090a6fe24ca2b858699212a597f491962c549438899b7489aaeb5477fcf0f30e6d28a9d4556a719f1966c7cfba606ab4f0ba37088e1a2dbcfda902c2e14ae9d239ced65b9bfcb232548bfb315ab89549b2499728272b4d4871245fb2450b1315279dd4b12e579ca634c1463012d491cd42061c33bc6d91856386275b5cf6177e0e351970db6266f9d2259581d7ff5503b9bae4cf26540cbefa28a954964aa354aa4fbc9c107851bc7eaef25bdc178cab873eab7e1fe22a5fd65042cda50b78231542142a8b5027242317eafabd1ed491a6f60f03e1858bc39d91b4e2806cdd17d755128208f56b71eb2a095184fac1248cdba83bd7c5ebe290430242d65d1a820f940d982d57aa4a8bd1db252d4cf503de2e699952f7bdee929626aa6a5ffb75a3b1e2cfebeeee761590cca0d2dedd2e8174b8b29a823e5a641e73abd7f3b36d7bf6766f21799bb144b62a866c6edbf6ccdffdd9d63c5ae4267125b81567055e566f3450fbd75715e466e4d4151ce3e12d5ecac3a5cf9e3b3f6564c183673b319596c9679095131b4827487728d6fd4f12fa78a27d87eff3f2c9d127a43d4df7ff4085b4e7ae8f635d387a14d6c7d18f90f6fce00e407b6625d57d1819fde009bdb000e077615be0ffe11352c2c31f2db6774b2e8389b68294272ddf500401aaf2b3b80ca4ca3e95df3d26f73625b8e94ae4b2ac331f16173ed78c460b3d18161b48cc5695b3a7bf0dd45ef7aa81565e85611fd5a3f9eaaeb81f9f25d6293baa1ae232eeb79c4c35a48519a53506ae0dd31da65823c193a31f5cc8074d48891c64edd8910f42b481bcbbb329a56caedcdd9bfdc0c1ecacb265f6655916ee77077252ba37e7a3d56ce53ebbfdb33a5d35b47582dad66db3f74bcf54190fa6bed4ee70eb56372584558b528aedc3ca2ab7fb6ae7491b48ae9cd23d7bd726336bd9d7dd8d18522ed7ace1f1eec32491695cf71b854152a5675a8aeb568479f985d9a1c2bcbc84635195a9aeadeac027319c16e92fa970d795fa1457e9ceaa2031af814f62429a6eb1af74b986cfcc27959abb160f975da35a66c8eb9a5f7d672699596acb9ae653669a9639e179443eb9be2b3aa774399dd022ad780c6e2baa72c8b60ef0949ad4b215674a07b0579c9916b2104443f2533b32cd69449f9fde8d61607efb1770577c81d9647d79f9ed25942d6ee1762ad949e66457aebb751aa4924abd279ec6592853d02e8986fce7d3ba99f4a9fbacee4e93bdee2fdbff684d0b97abd3cee2f187da04b9669dacfb72594e4a29cd6896895e5716b981e68622abefa3ccda4b3976ab59e972911b5a24227be0655cb783ebc6d5cb8f3430d91371a7f09f488b383fc8324ddb3939aacd15a57ce75f51be0682caef330bbb06da90dae0fab90685c00ced48c36306c2758802631ca1e145e5f746fab4051043489a4ab324e5fbf134ead9ccb299c2104f4d68e1d2930b6a963dcdb3b2503c42cc5b9b83079e5677e989c9138fd65d7a427a3afaa8189c94babf340426754324fdb520ad90a1c4b63e4aeb05174d57f895eacb65471db70b0b7564231e3275e4265a38195577271b388d01060bc05063290c2a6218218695165c811a03690c294b6364c182022c3ec0f224d9f8f934279c0f599665d90a7c985d202105d2873356f0124402b6d8c1144b68d962898dd9832ed030a2ebe20c1904f1a403277cc185ca954bc8c1199feb8b20787c51459defb3088d104fa4c106133c28411421c9832526b2a480f036005ec0a0cef9d40ba73abd061a797ecbc593359c40a50d17b0e08a286e708457c45bfced130b31d3acbaf081a6caa75e0aaafcaf8b23bcb6041e1f7fd44a0e9614a1c9833cf6ac5071842c82948c045e84a869e58a10bd058a9c568850e7e4a57286940851bab54d50283c2a5f166fa55b5b47b16a44b8d2add57858e16202056c69e298f8f85341044870e2815753b70a12889043081e4ddd2a4868238527783275ab4015b1c5f3ea56814a4205243c9bba55a09c48c251168e36d0ee4eb99276f777f713ac245169beb06e953482f018143985952080becaf9ca853ab27cc61d3ebc1b9b65b700403a2f6123b46052fd084b5a3061c907598c60698b2b517680c552d3117c588ad20265898b2e4b3f687a028436765f9303759f7a0e7e021bae00c2084f0841064ba060022107180801064f28d9c11231777767ef27ea589cb999b9a04e46537706132a68a209f729f5f424babb3bbf3b3716777777ee31a4bbbbbb73636131199e497777777632ba63edeeeece3f72952419eeeeeecefd947999bbbbbbb337167777e777e726a3c570f666777777eedaa18e907ef9cd8e458ed14c6e021f00d14c58b25041d1b4250b2c47685a38220b348ed020d1a8e623e6880a0c8ef8b842fd8a91f6d405c9080b946c09131b40c1b263c6c90766ecb822fbcacfcf2b9c94317184169c2406d44684932ba0b04829a744c2fc058371449447c42f852e66e0c591ef8a966dcb931b68c142fd4877a4f3b94182cb123e57322fbb728575e8a93924e12da8c00041451954904c0ef2138cb043243d91f4184c2f4da62481090b1289448ef15333832e68f073659d382e74c0649db0f0a05e83c838b1a2081e481c898fb16259414412ab7d67e993f3baf63cc2922112e62b417e0ae9e124dc9ff3eeb7ba5b802b929e01d7aa96cf2a24bebe2a863252eaee5ab7ad92322cafc1254a149410c75d837c4512672409ed165cb4408a10e74a9a100613a11e609a8a580444f08249a8879ea4c98458194a423d30b310dc72309d8163513582a4ab94a10e5d8d64e1760db8658dac04a9f6732fa04fb73e160aab56fd4b0f1cabe3a543d104de56191aa13c84b755d0b852fd99634cb1260fe21897e618972eefda208e3df9a0b168f4732c8d6d6d9555352cd30f269efc6d823128a02835d2902a20502b14e1414dfe4c6e4a8e9a5889518ca981baef29b6f34fe6a7b1ca1c638a516951c95127c18561e49852ed576a208d4a03f9c7a05a037d939c83f3e52526a67350a3a99c0de7600ac7c14ec74155652d1ccbd262c782b0313354313cf1782f61b8dd8aea493918199b1c1e8e3d79100cdc77dd4f57a7027df625bf5f876b7b541874e8f87170fbf96129030c04e851a7eca01fdeea1ce4aafb9299191a9a2536526c6c6e6e8e7096c0c1c9c901627583d5cece8e6a28e5cf4d9e4c535982fcf3532ee5d6e01f0487b891831b2c160b05265010455185292a743e5a3ca8475d1d66703e9d8f6a48ea00e2ef9896da9307937442878e9f9f12b0a003163a1654433eb1206c10c7a0bcf5145bc22e618376ebb65a50d2826a8895ac88f0465612eb3a72ec8963593a8895c4941cc5b6d46625310f3aaafd635d4d04c1108e5d1d57c92b22a80b520d718c4b8b354835432a1c532f3ff32d16c531a8a6e71897ee59462584fbee635441e677e1287f863a466648b7452da8a35ab64ab1a8065a185aecef5440becad0a6053eba3ae3820bfbdaea23e48dab34e4070c36c4a0fa09a87d71c7a55e542f324625c47fbe2743ca4a90b8f6d105c7ffb5b8a4c509f3b79e9c224afdbae0bc1b5329ed53dfa9972afa23f7dbcf7129493f05d2163b74da1d1a91df8554be67dbcb37229fa6a47cfa0deaa0d5961ae552dd214db19462b917eea6b6712a9898999aa6a01ab685648716611f0e4131fce392bf2135ec36e5e8403118a98eeb86e873373743eccbbb2fc78a1ac87f6a6fa4a808c9b64313c996524a0f2606a42faa0e4c894016c80631605b41439c01433c08b62d1cc6f0a0dc45a08c064e4c7184ca7fa31ae2a5eeb9a8a3e361705ab75a655a7c299e9d8eeb7878523ed85628a26763aafece5907ad76b4c52692d57f2553d9fdbf00814603c1182e641686345fccafbb71e3c68b239dd4e958ac1c2b48da71e0d869121bec720c29c263ff1cacc5c3e15540629cbc71a1c623ab9a3d677cb4c41f899452ce0e0520bc8eb1f68cc4466ccc190d278aaaa199f14b0ec7917f59cb40e92ffd0325bb8208542891dee7d1789e2b498c2580a18329a260d22cc836c0860b90886289255af083904b41a35377498b1234b8c815aca0026ffcea2fec0bf6420cef3f807dc10600c3fbbbb02f980b42efef635f301f3fdebfc7be603d06f0feaf7dc15e3ede5f00fb8209e005f4f283f6050b5a97ff8ef707da170c685dfe2cbc7f00f6050bc0bafc7fde7fc7be603bd6e5bfc20bd682cffbb3b02f180b29bc3f00f6050380389ff5f375ec0ba6635dfee1fbafb02fd80aebf2fff777ed0be65a973fcffbfbec0be6b32effd5fbabb02f980aebf2cf79ff14f6054b615dfedffbb7f6056bedbab49779ed51d8170c8575f97bef9f635fb01cebf27f797f1cfb82e158977ff7feac7dc158ebfa1bfb82dd58973f7dff705fb0705dfed9fb83fb8281ebf2eff7ff7dc19e58e02bf016086770fc0c7af9821101e97dc18864f8ecf705230af2f4f705232ac0a77e7bc188847cf7dcfb67fb821119e05f7e5f30a219de7b98178c88e6b77dc1880ef0365ff3fea97dc18868f8ef6f5e30a2219ff338efdfed0b4654c3af5e07468480e7f99df77fd9178c2801ffdff3fe30fb8211d9f0e183efefed0b4694e3597fe3fd63f6052352c08b8fc2fbcbec0b46b4804fe15bef3fb32f181103dee755787f9a7dc18888fc0aef7aff9a7dc1881af03fafe3fd6df6052372c0b3f00078ff9b7dc1881ef03bbe0518118f07fa00bc3fcebe604437fceb05f0fe39fb821141e07d7c8ff7d7d9178c28023f8077e1fd57fb821149e07ffc0befbfb32f18519117fafafe3cfb82114de0617802bc7fcfbe604414f8187ee861bf2e7ea20a843f2800f6ac8b7f0220cfbaf88b803bebe29700180150675dfc100073d6c57f0388b32efe078037ebe2770068b32efe068035ebe22702d2ac8b9f01e0ccbaf81700caac8b5f0160ccbaf86d0061d6c59f00f0655dfc080055ebe2af011c0272ebe2a7014cad8bff00e0b62efe19406d5dfc0600b375f10b010bf041405f17bf0c60af8b1f08180319957fe885ca0f0396ca4f8001547ea1312a7f75a1f2ffb852f95f18801895df851e95df471895bfc7abf2bfc0a8fc021040e5e701eeba824220a7ca1f0070d7b5036c21a8f2b3e045e5070050e5ffe9a2f2eb00775d2b80bb2e17b8ebf2015500f953f841e56fb150f9452e2a3f0ae0ae2b07b8ebc2118e9eeb06b8eb0ac15d1708be0f2a7f0fc8cfa345e5df59e9e46051f971c0ef8aca7f9342e5b7b1a2f2d7b4765d33618cb7c4ff52a5f2ab72ecba381c1b48a9a8fcda8dca9f4dc1df2b0558d1c8525b485ba95c79090d2a756bff04fae5e98c2c6a4edda53396a8bce1d45709e9a91c7e8ff3e4350b96089113cb51f2a4d440dafbacfe924a3765e164e5e94af54d4b6d0f37264a3def7b9ffe3e4aa78731f4fcaf4b675ca9feefc4240a977538aa746a71eba26d51393b24f8be2d6a6e514d9452598ea234715c9840d13d1941c9625f502f46e0d07fa1b28b67f4ed6f514c4c4c4c4c01a3daa884cdf66441ec10d1080000004100c3140020200c0a084422a16028186ac2b07d14000b869e4876589889c32088519431061942080284106008010081a99a1a00f9eefc6488e4606f630c03b257007b312e2ae872714fe80b28e7b11eb8ee7de9fb51e6850079288c27a492b5b8cc4e0ca9bb0b089bf9989a40cb37aedd12c2b831f3c51c25944241c49080b87349c3b3196f2756f4dcb3d198e2ca92cdcb0142ec2e6d9a85122e32f3b3add43d7208e66a346218d43b459036438066a326c6bac0197ec1a6520c2e8177586b9871c38a360c139b33ce1da8864f61120b5b3b2150ee3873c08193f2949d54853ac1095ba41d9b08498ec8f5c1727ac9b53ed393922d0d19372d94e093d1a003614dee8426b5a2ee7a151f27bbd18d3abe4f18e3775fdab7e6c3dc5ab68d610427098dfca8290f6bf87df1fcb8c19f3f5470c50ab5092b3b91e26fa60887da360a52be693d1415a9a9b4578876e59f20d6152da1bb68e17b847b02ea233e1e05fc33147ad4899561697016d0ae5421736d6450c4788038dbb671df1df7d0d45864706ea12ba9637766a89a6a626c072680ae5847f7d2207541c40690e54b32c3cc0b56d824ac5852bb0c6dd0736b673ff1903c942b182afb33ac6d1d7227518eaec7d4f2b6ab2111680e17dbaf76c521d58dc44ed52898414bc34162d8b886d5c17be1d1913a10845f76c69d02de0d37eaddc0b966968e51ece602eb2b6e5dbff1c89d1626cbc02416219ac459e80dff86eeb4ea4f6f02732c4450bb31ad8aa620a833d6f18fc5c2978f15c36c5d7352b7a285ca6c824933d01bdbc28bafe835b5eaee12535a7d930c75ec6812c69bad96de61e4e0e1b876a6dc03d3df6eca4951ba959ebc6004dbdd9e79529d42d151f3ea4da13185da3ededf38b31a153b2c55a8484415f44dea024194b51e77933876df34bd09b06f0266e5f9cd888db8d8d18c699f7cef8b5f12a243ab83e1628118d96012cbac3b7782f5f40b66e9ce58a3252305acb9042a757bac77fcb6d75c5614eebb15e9259538483d592525bd64ca04f641689c43cfe2d1bf972a108a94a555e3fce690c34696ead7ea767bcd61f08ca4236318919832d3828f02b1e4949dfab3a0afaff772198230a1883356505b8c45802ffe1a54d5ec1362a726f07c98c54585572940f8c54fec247823cea4e16379e0e25f19ac40c7eb86c431d1572332914274e5def29ca91e70cbfd20513ca6683ad34c2ab64ada6bc3620a8784f67158cb47fc9a3f3aecc7bfdb47d4d2c5644e5225f7222dedf70bae09f1c2fc1432f051c83cc8c3dfad0f45f5387988768efa311aa88f10c9fc5a2ef726851c20bc7d2e4405d39d057c3428967017d04d98284bb7992f1d85ca071555b65112092d52c7015e4ea5d53aa95f27498b5e20bc9be0d88f82633bbe908aab84ec82d91f496ca4ab16bcd68b6f144e1c46158a7a2d738b6dd9b98489e7b655454444b1f9b044b46977e7d1ad5f477e067e20dd9a6c3d0e364303e33c65a092e9b6f6ebec860a55f0f9de0ce7ad3c54d0f9513bbc754574b23e9f157b04780733720161060a77eef886c4380d5a3f33540ecc2dec2015f41035ce00ceef0460bacb043f6b0f7c27b84403513f0761dab0b0231a8b42dc3889983274a0b525c4c89a73b6982dc600d5be0f354aee607f9493b4f784887eae02474533726db297d12ea77290102158c9c490613faf2a861e75309ed024bbe9b9c708a79da204ef695ff0df6a74b70c0871ffd65672ac0b7eb68920e9c031a3f461bb613aba7b1a2fa8b41d178002e5b3ccedca14dd865f281f9078b7f50a41029688ea389303ba059932d58a0663e663b275a8e13b1df3f734a14bb94ba7c33799d75beaca92a1d490897e38b2cfd64b4c0b788475362577926fe0921033a0949b9a22bd037894db162657dae80072abbe851d93bfc3e781b07cbc2a50271165bfc27848db09f3f223c43227d07a412d214578360a672b0f9b31c2d5ff4f74c88baa2ab6f141d1521525f4e08e9bbfa201c89bbcdaf1495af381bf3069f145271671a8191b17422b12292a9a961087402df67bf614660199c9896d6f5775e7c567213d4c8ae730cc42221055ff0f402c902a7e6c875859e566414a9f56b5a1745a81122f0dc94265205b401c0ad2b8ecbe818f4854ef8ab42a0b53f3cdb4a84f755b75126cad72242d20e5c6337928e939902c24af9872da09704a499f320f751f0b2fbd832427214c3cc2118de8bc28425fe1f2d1690077c6a9a7f59ca0a2bf3172667840627f53dfea699579ff59f7928f3cb946c22cea9afbb0032008baa6b79ff8a00c3667ccbd3fa1c8282c180202ae064f858e3156109c5c79c3778102f78806289ae434d4485e0b5f18a4f82bfb40c60191411f01d0631d3dc190ece090fae56035c442ead1f6edd0803ee7b953be3077b134dd02c65c163b7cfabe11b0569d68b37dcfe6a7e7699d667d91793561df202c12728d18db0161e2bcf0e4dbdc8ad74542cd6c3f0811f2b1a6f2a40ff9c8073ef5299ff98cf1b1b468aa088745c1f8ce38da69915dd4134eefef453338ede853eef7f2941f48609b454c5cfbef3eaf2ea21db2db879d8f3c39f2b4c2cde497c9b1e84f28535a747aad42ebb249aa31c0cf213141734a510a31e002355e1d03902fae08c22ec0859df5a90c8073145ce05762c85fc8c7cde1aa96b76eb26fd81eb773abd2523acb6dfce923ec8f9bd96a727931cdb5b724e6266825226795d48c2d19d543270c2ce777f91524644dc32433de2f6153f60fcde82e95c01c379056fd61f34ca02cffa4a67381aa0f09d244b816e08168f404fc930f2c1f9783abf0d22a948bdeb9b8376189f24e6331993837c1b232eb140589a9429fa5e4928e627a964c2c97ef85d6d8a3dba18156d06b42cf0345ee8e120062bbe6888c552adce5bd291efc0618875532201727df082ca2faa11dd46262c9a2070ee5de89189b5fa9a6d55bdad20d79369f620b1da05ccb366b3a37aa27dedf55a4b4c6b25305015b29b0323438fa08b07666eff1ce21d398e0e83e00cd09196ccd0ee46de74a5f1cb01059ac03a3c9a4a082b65a3c8988b9eda1108ec9403b9c5de265d8efcf13a387866484fac43407a92385077f9b643d9a386149b17b7a477750ba42c7c2a9a77b3e4b79e61569902ed7d4173cdfe2b54a31dd6b819805667954e5a4751965ac08bf9e713af8aa85f2d6f8ac1b78bb0b1ba07cd5bf08527f1a4d294733337e618f0bb259f96bd7f2ee4a32a4e4295146287d4664c82e39a09588b403a7178b9aa8b91e14ba3511707660c2c703e306c29d199f0d9d953e5ff625c53fc03eda24dc81d0b30d537178b1908e52b171b9009f3652a26dafc8a5cad5ef8a7f1be640c8037b92294ce3a51dee1eba66188313b5ce45d8c357697b607e24e153a4d91788afda8fcbc09c134498c4e589928bec3770c5a6ecdfdb99bc73cdf0a911f4ecb0e75e5338b93557f2f16b1987ac160e414943238aafd7bfd936b1792adb65449ad6ac6bac2bd8fd289a0211dd0b4ad78ce3258a55d24560973b48cf55e5051b32432411b9d0d4b0e67e4ed9f9937aff6861c7d2d0352edd2cdd760ccabce0e70198442eca8df812948d8481bc978264c5aa9f26f5c01f5aac7d9cc563c09d4e1b70bce7c3b1dd66e1c26163b609890aa0f800ee322bc22f85875be551597deb6eb7094ec0a4eeb1945136be237bd1e009d463c8ee43488352c73cdd96773a7dac0f8bea55cba42d0794b64a73d2e980816cfbaed781c6aa06b51f659dae1c81ed85d36e153b57da9885a525ee9120489b23c276bea0e895b697f72c31ed88575475858a9e42afa2afa1d7d053e8d442676106e7c8ce4888eeb66149ed97d5def5d62b09c077714ab6dfacad816f1a1af166b6b2014583d5bd93f5339524035472d1d75871a9e68b6a83a67598284b1a2d176ccd7d9f5456268e12e4a6adc6789792ca3b01f29e3dc857202a600d6d55de5c07273a86788e8ee1edf582cb9fbde07caa546e9005ac7f1c9138edd6cde523194bb7fe258c6fd7f4a6ea0d409ddf62d6a53ff0b4c264b89dd520ebb6dcb16594959b863d38ae118b060b7cf4c1e62949e437cfc78e46c6ef89393f728459fa8ae08e4acbe62651f2c31c513b49db553df2185d9f12e23d6127341507a0a3dfe6e74889c072681955c5cbd2e4b0ea8e0430ba57e159d157ed6a156f3ea0d2edbbb2ad3181b4dcdbaddc3870acb39f0cd9c57024c4870ce01f883ca9b2315b980860476fd4dd4cdc5284bec02e60e95ac48fbd56ba5e71c16b9364bab8ff688f16d61625e28b77db4f7f17612f7b76e3798f95c03e7fdb8a4cad466a36e2f0a3f52cd2251e51432f6a69521846afa678f18f0b8e9b6923b4bb1188d79885401e82fa8090cd7d53d2a6144687172a51e6572f10cd5d1b0a13c8b9e2be11aed72f650471983eba2f1535dc0b3d3841947673bebc42caf1a57723072c3f0a6fb4e8ca8ead49941efa7f452b5128c1d8a4bd58be2174a2349c0b0d4811bc5c51b1898b932ec9d5e91f43e6be20130cdd2a1a675084e75c10e0ab6b8c2c1f6320bed5bc0ca2ae320472303e345f7d0639511a2df7f264cbe7d245bcbc99f16ba304817cb57daeaf0d8508a4e8f431f7b351465902aa68fa5c8c919d158e6a1410bcc3cc8ff50773182a89cf92e5dad4bd7ef09b1b875d11bd1dcff16f2c3b5907dc0918b1a86e341d3cbd05ee0ada485d2cae7e3a288b879e77c1db3cd04210bb2c88f55864b6304f44879f79473446bfcbdb62ecf68020e12d51b7e2398502e8f3f006454534f913778b33cfb280ff6af11da4a0190a74ff92c27e8a93da8379e5c5c9a0b9c617aa27d7590946cef564bffffd3df3daf8689e29810456a6243810e2f2421cf3c708223711eb42710fbdad89b38cf2ebdc78dc3d188c833fe8b4626611c9c373a4b3c08bbc0b51e2bc13a76047a8f26bee0332f72d3889a34d1969809c242d351106c2b97b1b23cc816693fbff5e52b49ddbe2abc5793a96f369318ac083a04b383fa7148e83e71a0fe972a368d910649f01642683b900a7d4abb50013c72ac97b46d3611471f6a87d3ed7b7204c68729557d883469f62a96e911e89752c798a0f2853ea596b982b4ae8dd6d92cf90ad3cfc796d05965b52a91f2e65a1167079043ea34ee9ddd40a19d7e7dfdef008e5a3b0745bbe6439af15b14b07872aed34d68bad17eb2c3f4fe27223222870c5f48a7f0066cbf9136387d53d7f6ce32b8afe50e4fad9a09c812ab3f0770e1e01fd465b212956ad9325abdcf3278a81633b8fdef3841db66daa5d6eb4a26a418697355f3cc448bbe0bb88c6d37b2c31f0aeae963eb307395c065d7321c459dc167b20b9882f47e5c56b8b84f6a8659c993b13b5a5c0bf7cf641ebdfe3a0fafbbc07bc76636ea1c0579078bb17eec81cf79402e009d68279e7506d4d13dc0556c98dfb0ccf3c855cf16ac55626658f47055e77125a488234a347f862ac785f936de0c2b22459cf21cb8b26d8da80ab62aebbaeffa78a291f15562c46bcf813fd75ec18f7a7db6044e4f70b4eb3707de20844f64408e98b385adb9a131800987ecda89bcecaa57ce810c9e6aad1575fc8296bab0e82e36b5ce272f8a36288a8b36603e951befa3c4578390ba6dedc086f83a2fd7181c8c3b3f17384b050b49a0ee78f606c83280616e6a0e7d01e8ed0d48312662f6a6933e2ff3bf89b2d7fb194ee0f1c374ab69334e65ef795d9d483ae21a57115084892259cfaa7a995e7ce72d8869667ca217b9399047bee81d797f5f5b4d657372620d8ea2f08460e0c1f57c4c78c182b517e6ac1fca82f6f5e736feae807622129a7f861df57a09c9b5bcd35a866bf7ba81f2080f8db1456d397d0ece0d0cd29825a5c344ca7ae9436abd65e2f0c290580ffde2ac9a7339faef3a930fa94703e1df9b91f4708eb086f1e44fdef492ea567e4f360596f88547a110caf8be7614b347c9f11a1b503794bb29ba52cf13e4094075ab0609e0922a7a35540baf0fc774517278eb801e7616336123d375bc427dca20a6673344a030dad468aae6260323a6ba75065b192d897c8049da355bae2c6e72a98c6d6a637c26009113c63a9390fd61cec4f583d2141a9654b2f176a6c257885d3a3d0044db333eb8f8a5f60f680fdce7e72e702ac750ce9b221047c73de797910218ca882e3a21c5b78fdbf7254d489a291d089a001e171d6e1fbc2897b33f193e3463ccbfef423bbc8cc2156d37e6fc46577a1132a1bc2147c55d8b320fb3c9093a92af11a55370945e2168345c6173c748868676e4f359c901e68214bb43c883d94cd7e793cabf9469c024c5ce585c0085f6734adc0eac894f07303377bf4a1fb731db83346691a8e100eaae3ff91a7862f5805ec70a94f268f6c4b4b942e933ecbf6406988f7acb525320cbb83f08dd27df781403de7095d192e9833f77f49ef347b4e57d79862a600c790a5ee528edb0dcd28be1b930e9aa98a96e3527adf0afbcaf029dd8d9909650ffff17a6ed426861c53d0901ca0f56fd995fc04008a7eb5a290c5e235a4de9f5cc5a7767743eaebc0b36cec8ccb52c71ef68625c43253dfd6cd2a12170cca252f22b3ea541cb23bddf0db0065a3fbf3527d97e009a4d3f4693b3e5afeca161e0b8dca863691ac7364ff9bdbef4820134278bdb1287da0da96987f3028e000bd93145b071a3582fb980d2d11b57b5a7f063523dc6dc418188916a990f023b01ec20d1ab4d1a31d2be8c791276c027eebaebfc6e8c83154e4e34618e63e71bf851bd8091b8e20f6aacbf9031069ea5ba6e9fb3574ab74a3c760d72340d2004040516f60e1c4fe96b7b61dc0a665013c2259e69954130e24a600814d502fccf0656d7d697d818afd17ab08558deeb858a242f58851649c3644b12144d55cd3cbec6a5cf4a6098aefcdbcd0bb6df5252a9a5e5faf3e9695d7cebf410327438924e63f3670631bdd0e432434e0959037c2f8a085447e563b3bc141bfc14b3d95f66cc0cf1ac0f1d7658426e743742504d482462496d63d8c567a5ca3473b1ae488ac243d002540ca44d1c8817fd53b41231731fbd8f1c36eca96727aa78b6c256dc5182638b420e7787dbc626d2b03493a9d27ff280718d0f376bbf4ac6e576101885938487dd9a3be01d7b92e1559aa9e2c2d53f02f91cbfa691a0009618a2297326c819b2c350636d6938ef01404a53c90b4a13d05a548a402c87d8b4d4aeed19f0405989cadf35f52538fb08f31e29f30a1f2e17a226628b4c57a0fcece4bb0caca823db2ea24306f25a54cb41831502f5d94c510dfb8c1313ba0063b85282bc10edbb50401ddc3b3a3b78799412f20d3af55ff7e300c06d37a8469944c8c79f4187411f24dae4ea3736ce0ce41049476a877264d28e853add467063c518011a45e89baa3d09ebb847059b9a0c68148071253fd7a0844b3bc830f27b3a937e3ac187cd8e8f3d9b3fc559d6105d540dacfd4c69bdce8180a8ef7211e3c2731cf0a6ea0d29f3df8ce2089551465a32a1fec8e9724caf9f6b5960f9729b56d51c26c0e3e64321589bd428e8c7338b346e4ac22bb360fcb9b89cca0be226ba870e6c32146304991433a06a222bba8e49882772dfe9541997fcfaff30468faadef75533e3845f7cdc7970e458855567e68bbd289b5349ab79cd19567fc0baa93894b2d18c4188e445c66d1d323de802cb1a11a251acd0d9498e2dd446fc4d0c3032b15ff8c1301fa474c37f7a646c9fb12883b3450af86a2132bc6de7f53fb7c01f90797ee618ec40642e1386c2a33ae710d2ed616c613b77393be485e45a6bd065a55ba4b0bd7febacafa65477fafc0855ce0cb18124666cae0b747b40243f07f6c4b6b26e82563d7528a60fb4158d90d82cb7f13fa94e5c4c7a7f3fbf7ee5ca1bb43f4aefae641446f00a160fe3a54671802e122e632010f52208b5529271b60780c328eaa1e11dcba426f9abef358139aadad7193bcbaf2216e9a8679489d75c6ccb5766e7355a5144c388eeb661d3a1b138623075a7ee66800709e73bbcb430d2ba48830cd610c225f002e4bba40621c78b67dbce47bb925eb7d9258d548bb593c4a2cb1d0d1034e53d4e79f0979b90b795defe507eaf8a6c6f9347a97a86c1fa5035042ac1abacba4341db92d34b8b80cd509ad49feb9c9bd6e4bab7db0086288d704be611d42ec8b1db752cb0b84fcb012f0080f68cbd8b8fd6c008c7aaab58195b592725b2bdf0faa4fec9a63ba0bd26d171deac847696d21ebfab550aca17c8c3b5f64982c980c5cb230a0ffa18bd6e545e63dbe763b1f8a748a9676e61565b1e0870538a29d9a8bfa545879e246441969c4b8935e6614b1bdbf9b2d45e388413cfaea829489c4b3c8b83462c5c2e2b6d4d35aa9e8bc5baa7436fa5e8a9e88637e4022c06f06bc5106e48834a5f8b07400c5ebbec14d4817d86add15679174dc482a01463ad6387765bc3b23d5dac8b73578e6f88714638316d26c6c540c8eee972d4a22acd04483ed7d9ece3c62fb5b26596004fda624c29ea860bb85ebc04677dd4b37b3e9befb1c8bad691081b349b2695c2d6ccf483824651b259604bebfebaef1b5710226c97dcf9e0803fcec037709fd757545eef2ebc770698043b3bb7fb08b120876bb88e4cd6d678dafb77e31f606a0dec0b4d71635500deb1650f55eca1baac3961b0a85cb556d80466369c2952ab1d9af45676986df38c404ab0304d4950f0e7469758ea3f4ecae494704e07f55ee1c0e5f74ed884d1a6020efddf5ada633448315490f69801958faffd25bc17e1d8e00702d1909e01b6e929a79626b5e0f25d62b3b4a41ecaace592cd78b07d17c818d903e64d50ff820dcf75528e8773b7f77c27c2feb6fd4937be255664ed8e79cdc1e4d50de3ad3a456356b6b550d66c17bf9a01a5cc836b08dd355efd7914c136a56b960754f56021268a710b282c072a260f5cc2c506b3d223465acaf051036f1962ca6ecd3b769c40233ea1388c8e27e6fbff44390389a7af60c7c71f252f993f11aab8b1e74818753eff1c0966c55a6fcf94ac237d3469258e753b08f6de14361d6ce50e58d27634ed840f71496cea0793b80a128414c4fbbfdde27ffa2897c94d63edf2fff9d097c4cb3bddeb5ef7bccff66824fd3b6d7fbe6ff34d9f83038ed2b5c8e81d8156c1687d78e18db2f055087f08043287082b4b061b5bd211d224a1d4eedd93f867b88c25fff88dccf87bdc74cc690d08fa162d9b86ab650cd8a6ae295561a750aa2a13070de131b7a55913ec3dff0f4188bf5748954bea5c7e4eacf81bc17a6a184ac632bea9420901a2d108d1a380d6cbfae33d0342e108d1928512e9f7469a0695c20180df06dcf58d73d1080327a3e3291d77ed418a963466fabe6b6d758370e63f6fe3dec28ad829ebac279bd8c6d838de95e91f98e020ecee5719a5246ba97b8f7572dae58fd0b6993affcdd6a43e983f20c54533237d132dc12ee4f8c8838502e70080346b24d697d433ef0b55d11624f2e4cb651eab2c1fc2896ef6ec0010ba55a8e820383439e3c5f42c6a43dd4362c87a3cf1e50bd6bcb3e9194e6f164c1642129d684a497584ad71ba09d1dd0635a7260ee724078c2b558bc5be82d2b4fbd86175717a993dd06fd12db08085ed7467c0bcd872cdadab301ff6e27b9101f2a6ff4d8ba8704312e2095f504569e87822476261e61e809778629cdb5dc55219a2946ea6374db0376b3f2904cc5dd2b501d07ab80087841334518dfc75f985c4a834ba4dd6e863e4345e3ed98341e5fa42f858b3294dcb80bad954b8aa8c0fe13c8c8f704239f5d4df293ea6c28240240bc637b9070d9bc2d7d02e32cd697d1d8521d3d2e34ce46e7003c6ab88e7a6af2a4021ee0c984c62ed3b927ffbfb26e8c8d6971193d2f1c5c01adc17e631cb359c73015735a3eae6f2c519198ad9f42f9a1217a964898cf6f7ce9c45534497db944d5e99358580c2d5b566e2cec050a3c48bbb12c1a8ca3e9235e13d1444a80031b9d362b287a3143e6c86eeff4eebf207160a949dfbf273bb6a794cc701077326da9c3e2fbc208d63348daea79e08a8a040b10d38cc7da4ac492b6e893325bc6b0d534dcc3a4a6188c6eb580b53f505fdd798893acffd0b1deab8767c53cda342641ebf82986382ab531eeb875fac03c1e8f4418d170eeaa7df3247727f04c7c3dfb3598a3c33e50ded0bfeeda9c0b0f87a0bf7d06ef03c474ba2048c0a2353b7c85b00ea7937bfc48d442c7b85f3e65037fcf2415c7d38d447983fde0323c115b45020b2800c2f1b14df26f9f93c250f0fee7c367c9fa13984509933d653f685a040d3ebbd8f0f91e6ab89c003b579254c758270fb2e7984c0d1c0239059a8e74dfadef16ef2864d250b6d7e33c902b11491d77ca0ae35b33e0a07762ad06037a1244103429a3c19c023c42c5c0412101076d6988d04ae24d6129fc7301cb7021fda98d6733f9d6d968d4ef1c53554ed63959b5c0dbbc4f4430a9a1a288bfd6a98319824ea338414b42bebb84a2a42dedba3793234f828336d83c8c991d386084a60598a4ef671d412e5343367a5daadbf539272c0c67f323e6aab78d833b378144ccce6264d4ba0f5f65343588ad626f51f6360087e93cc8e82986456f20173ab4fe75cfe6ee70c9178ed24c21561a7415c89cecbf6e3d16a51063a45aef0cf534dc7ce32ac8de356cc528a5aa0fb6ee16542842adb549669c141a50ab2d4008777827f1cb8a4c106e3e4a37eac07689cc40192e910d71d5d96b911abb75033b6b91a8ad824ce7c6331af35805076d3fb0aeb20da0432deaa61779b3fa0d5eada633e1ab410bc4e8ac05a809e4e4b90f3005ac1fc6e0d34e9154ebb6bfa300022b28ed9be72e3105bc3640b19595810076f3aab0314817979526feb6eebf7868aca4ad49b1649a85f228a1a7804f22551fe9da5510095888600f7d6abc7303420398f1682242ce20f2b7dfbffd5eb6c215bafa7ba553f71866b0eb4e47d257a1810166960450917f769c6582443126c0241185f7372e1cdb77ee061c6c2ac43a0344b65f6387e83084712137e20fc2a233360ddb18b0cfd10acbcd5ad41080985d9b5cab7965c2ab27a3f0529d9dd6d07c1d6bf0d0be707b5d69c683b6eeb6e6a9e8515e42a6efb75a62fab2361f235fde9080fc7d07895a7d65edf77d9f1fe52ce12c9de1a0570ad7716088da90b9fe7a8527999325dc9bfaa9078197efa95af252bd39ef924e96d1ca8e0fe7cff1d12270d396d09d1b160e9560181973cc70561c65eb6cf8ffe3ad236ee7061c4f02cc90089e10906300fe4c173cca890436a8ae6899cb0eeaa6c99a0fab25716e367ea814df9f2ab2ca5abadf652d70cc591416564165e9860da457d370fbe2f69d219ba14f6d74e2c4cb42892c0853e1dbb028cb49694f4f633eebfc65a14fd4374d5a34733e288e3ab314e922e33104f9bce6d137edf119de8ad5fe4bfcc22b3dbe2d78f515b9f098a768d2c032bb5041026579e46e422dd6640d27d802f2b92bc125b9df5b2bb9fa36a640290f1d4caf2fac484cc06236dd14edc48ae1c028f7a0513cb8c233a0b153021607eaca4c94290d816884008f728fa85c6a321b595b8b4fee7701465e0a887b34ce401ba93d93866cd9ba41c12c99b1ad32d7919df403ee2cd9e4d40491a4c55eefaf5108299b0ccba5c24e16eff6cd88c545eb8166c8374c73588d8104aef40806354900dbbf26c25ab866665f424995a0fd5cc1b83ea7ed4b9c24426875f90e66e8763a71a01e15c60261a70648579dc3bc55228bc8c31903350a34c1fb31e389824bdde9e6fd45e876931f54e988aadb434e8553a6fec51d1d14df848f5b39525bbffeb45ff408293a6fe090607702248804fb3b8400f2ea2ca89af7211fcae41bf2676c57a254770fc9db0cfdb4551fd382cc2628738f898aca16996fbcc76380bfa17438fc9bbe21123c81d5e0fef80c11398cf91c94905d6a8a2a1ded801294f22383fff60e2556c549845dd1848b96539a212f87941a02d6e15c16f6ebf063f91ba840c4372152220b171057ca18ac6e01805915087965ec6c621196193a9a1e285012e516de7da1591166c516f4d79e720d1fb2578fcf25941304843cec79647009dfafdcd3be4d29b1b2ea47c4b8181d8a641f01297f052c66c56f9dc7a0ae8a8547dd9efbf6ad1c9f356986143b7ed6504582b7010423805e114f7142bf1351a616184518425104a67591dc9a5b04de73d42d29021b34230f542f38442d10a1fd4b8b9c080290bb801f7a4689d90cd6d851aebd95457c39e807a13caf6ded826a85a815ddbec8100fc9228e3ee8588126510eaf84bad0015083c719c3956636e2d921b4f2df56f48b029de0b48ac5b236228fe083e031fe0f925b77bd26c6a6053d0077be8c6658728823a3c2b925ad82a628f658fa5f44b3ef8b478b8d51c85152c9e2587ac7f9a7be4b101a953900cbe45b246b0e34cb082187843a752793cb002710253fb2f7aa45e8da27edcb3ddb313f7b094c9f54055d2b61f501351a5ab2aadb0b61cc80ef314ff4ab783a0ae16ec626265eadf8c5d71f89a7b2a936209dd8a3e5779903480b159f6ab0451580983fd2e747f12d1c00943483d09296da2690cd5bc545f152fbcc022861901a4da55b5c74bf25bb09feea946bb3bf94c7b7a96c5e554963638e40e088649163bd41b05988490131af951b80ac287f9aec86ca7a8faaaf0e88ee6ae090972ab5d8b3134aed521416ff4fd5d64871494439f1009b53c67e7f9181dbd68d047b05e64c0b5a89446eb7471a00abc6c6db9c0cd4f8c10b8d1fe93c5da0d2f0c9a59ce4f5bacb0a6840fa2a669ce1425d6b7f3577b6fdbdf667a98581e89de94c9cac8139eda2ef1d769421fc202d869e6edfbe74a0629158034f404437731a2144f4e03293122851c5941a96f9da3a57e59aaada82cf5ae4e13266b0db0b2704ce674a03cc99b0829bd35d88577db9ffa83b2d461955140624d8cee3723c44ec857eafce821e9d5585f6c414d0f90103cd1aac26e5b0b08c69d0068e5b59df96efb50fe27f9ea3aaf8ef4366f8c884d573b9e7dc819239dafc88a3911cd3294966490a404cfea21b803953fa5398b60796bbd86a070dbf95b2b32b75d43485c8c0b8e7cc67cc4d6ba6cc4ff5989701e00d5968a4856bcac825b8b51e9533d53f583990c3ebdbc70f0404a5c05fc604ab73b245eefc092023d94a49998255c4c165313985e2651f1d8cd9789b77cd9ec772ff2e047c46aa9819c5ab461cb052f1e04f5e8764b08dc882b70d2c90241527f53de8520f1b451df0a5de2b1ac3fc70d58d9de121a887ed0be9f4181363c6ed3d346a863cc3faec6b19e476d29e134b7485430c7bbec1949173d0dc1500c2c8df96c029a073ffbc2e9654b9785beb439d203f0b96abd44a63c551a581acc088cf3d18d8e010e72c18a0a8a238a865b74fd47940afeb524338775c8ad9f0bc41c15d5fc473d6331dc94462db9443c20eada804fa2dc046ab03c1d8a7472e72574f924b621099fcd72407464f46100c1aaf40ef39ae23eb92ce237d2ec071ae441c2c7f43e8cf9dc4cdfa1b16336c57a53d474cffb718e75941df08670953fbeb05dddf38fcc6432f2dff5ac80f736077746014b75f77f1188a117bc5c42a69d59b33f76761e6bd636ac5467b723eaddae97917767a9b4764afd5ae239f9d65e9a5ce982e6357564dc40fae15b92764b568aca946ec6685957f99140b098d067c8149877d329fed61511c444c684c67664ff362fa85b76b99fa97cd155e3e94e0ebcf8b22805e28cbdd8b3c8da2d47106e2cda75a6fae759f71e6b6c33dbae16a6f3c947123311dfa6717883eb2e38f24867825917cc6aab32c8a65881e22c628a0d51d2f6aa66897b70e4afa400389ad59c31c530f7153e5a69a6fe296117d8d9d60775020f4234d1be5f5fb11ad42fd944ada0be201e1c1f9d32d42c4c9c496f5d3e10afc540f02913590433038fff6f909f74ef61af49719e4e273a0cfed51127490d9c8831cf2e251ae621c9b3cc53e8192f969047d187e9225b439058ef584b3ec937d948644022d099179b862fcacdbf88cb4c385baec8d5470ae8a43e8b2d04f843cb829c759f153ff2f2962ce4b48d0ca6f8c3187436daaac1f8e763b3acb93c5d36b28ed82571a1dc23e18d28a75fbbd163c5ae51e9ab74736fede2b11c86ea792d4b8efef8d806ed0723ba9b9471a527a34ab574044a22ae4e5e23d36a213f221ae8f0f7c3993b5c3999c2b7b859e0386e4065195d9a1816ad0905950254be89e7b597604c60b385e1d40832e8b90d5782d6bd600de17050476f1492aaad58c33d5c34686b9fc297aef57d8d7a29affcd6801e8539980ab61dfc8cd6474e18ac0123c6794459210dc763d8d939564974fdc4e1e48de9e6a72059717bfdf76939bc52c2ce104d519e4be91691e8377f29ef45c7d4ffe8edd2d9673cb86eb25619bbc9e40df2d2dd678427283b4e69b4c43ac9c8905b8ba26113031ff381999cd07eef14b27e39cdb7c614bb39a7e1e2a7e831f4af16da5dd432424bf35aad0a28da8de7039738c735a39c71f0d3a02a754b3501563311d701d5224692fb40fd43466b81d53748a6f55ae58cd1165ae2016523d31a5a7242e8ed5a11f162ae0ebd0f94940eee4a909620d4154121c507b01d38a9093cbfc3d1324407c5eb5927f4b349ace513f906fa2af708d88f9dff4ce2e78e4fbd4a9d7ec3e2510e63eaa1227e220f6b9ecf112188bd95d213b5e19e6d9fdf6be208c62a989a31dce9c06cfe66e2db644597fca6763d424ee4896f7d69772295ce5413d14525c0b9929e7f8c39b3c742f8d2bc5796080dce4187661fbe67215c35a0a610fb03da8374b0ee051102b9a3b72ec66798750f3c7bd6c874da0eeb750085235baf4a645800c479a2347ac2db015a27e236485496027de882f1a8b8a32150bcc60280231d6522e1d20651d591f0d4cc1c0ce23bb0194a414f4186120d5bc6de6d8140c1e2a8b297624fe124c18056b02c346988291be19e089615a37e2a1b21b1ca01e6c1694345f49196f3dde3785cfd9876f8bd8b5566bf0dc185cd26a5b1faaa41d8e248cf76aa3ab737bd5d1d83182d7456b747cbead6c4494aaaf93848c4d7a80695d5ef46ce766a58fc5ab40b44f5ed5d46d83a280a243f1a93bd0938acb7c0a5b2d1e26770c65bfd2e2a149c30e4fed0ae649fc5fbe306a77fb243e2b01a399639eaa23922e23ea13990daa8922522c6c3e94ac880d8707606971fccdd7aff6bc30fec947b141df86c838c9c2392b68d30ac6d8d3bb8e0a86b319d0d2502ba6832efcc8a5600cd1586d31bcba10ee66080482abd4fb46ea4d3678279c018a7399db99f81233c39e5f0723cd8897ccf467c89260c326b9c41e77136af26a3b972cc61874bf8c4fa6cf02c11df424022a0f00776400c49c1b0ff8c630361b9e3067239549e250dad5be14361bc20242bc0c7886190eddaf7e3e3a9d63ce6734457035d02ca859beb04cd0841361c4b39a754a9d33376287d90647e625951b1eac1c5e64b520509b9dac34e5fd657322142fa119fe1e7eaa9dac1a44e9daf93cfee98e6398c1f4366f82c4899f97c3d4f1b8b627244bcf13c62399a1387a8bdb82c350258edcb5509b7db00ef35082bc9c1cebfcba4d5aa3ef6c79442b4ba809915b16bd346708c16a02a95b220dea6abd819ef265d0e83cef9ecfca8e5b6a6467c9b167d18524e2bbd37ae05fb700aeb5a7f74f5d9bda2f1d686b3a54a254926db7b17427f85de99e442425fd723a0d5f8359d604533f0bbf99a0762767fd89941ddd922539469150aa4753110acd9bd52c35672de04d291c1dd17a0c4d01086ac0afd947be46c289eb8480c0f9ce12f16b9ee07b50d135fb404270aab9db50cb3a73bbbc1df7f4b29db6b432dcb6e3c1b1d261f091e5eb83ad5fa6703565567b9143a2d0fcb79a1835801ca29764144a769da946381d69d642d555e26c064ece57ecd1d6c11f049a8215fe35545e453868bfb9158f693c03f737840bda1e72d66fbbababfc4a3b0280634c47279a531fed08030e50186f01b0d37590781ac41eedf8c50ed160954606e26334f8bb34f8afb3e953390b213b55e6c436f557667f7e87d0e53f09d0a51a2efe167df0b362f9ecf0b4587864b594739c805c61428054fc40127b4a89661979808036c7a8794548fcf7ba76c9d6dea1990fcc159177ce34ce0fa9ec2b6598cfbb2c8325a2c49321714be67ace643539e70efa3998992c2f235c4de5c6e6be17dc873345f5ab9f75d6891de7dea3e3c7d89dd2d13d6d03ddf6ee1fd6763cb8a4014623ca256af7e7f9dcaecaa487e82cf163191d5d54322ac0673119351ca4380ea6d909dcdc5e6953246b0bcdae7a38a2ccb5ecba7521fc310656e6359d155cd6d976689036dad860a40a57f2be2c6e1928871182acb859667c3edc337d3a1a25ffb5f5f0a732c4a2f0adeded62abe871816273726c26d89226a3fe4c612ba633c329a9f491ca92faacfbe3d5a5d399a7e0dbc03af97d0408725fe74458e2a2db05d05c96b03e33d064ee358ba03e3df399962640acb927cfdeffe993716d7e125269755ab1bf500ae9624dd1c881bd8b74bf0b0c49959460af1adc7da2206d70dd8dfdac74415e3fd1011d9dae8b89ff0e04ff1344b303aad860aa2d248b78749548d467b78509e4f92c3e61a2480a36486c41fc9c3491cf10418d6fc9e82c97ea2e9819bd63c79b0614c82a4c1ff79746ceb4b65fea2baa6f7686a7b9389dd0ec2647332a50de73ac11c459aea451b949579cef6fe9af50ff37c36fc8f61ab484d6907c34fb994e3f918e54264e03064761fa1e317abd33d2b74684a310fa876e97630a6667f9e23ea211e4b1c6a494d5a74aee9a7bba607d657d74f96b735e3b0f5e21f920bbffe78866833c079e538ed7f96624d4bf98b94a9c9b549321ebf313e745555bb4d53b4e7cb48fee313b72e64b6acd240d2277fa2e695b538e76ce6cfbcddd61ffec232977ccbabe80df1c229ce2189856afee5741cd37dc6b6df01599f1ae6fb789f14e9ea2b3871271f96141b69cf7aa061dcc0d2b46eb76eb46e71980f9f0d53484a1fe71f77dbc9a09476abec4e3ca089196f10850298cb63502ae7878718503bb50bac7ce8586a7ce6e712e63f225a52cb6e6012da9a3aa43b4c30ad819c30d789abcb9177a902bc9a40c9c079ce4db71c2dc429f3196468a3a7f13570ac5b7e7d63cb1992d602c7822ce274d23c17de3656245b06c6e4733f265ed5f361a9431d276f45f8dfa79953be544377398733a8b3e8f2904452a6b159cc54082a3907786326d1eb864b0bc618e5ba79ea8df84e37a42ca9aaad10ee11249b1a759817247da7351d3c9c7b640560c619f23b30ff08e68b9b18ae2d94053f5e9309478f00a222c973ec9279ab53c7bdc16eecb89f53e3aa9cb38444403ef52d35c69be5a828417190d2fc315e30299b6991193736754659db25f16763ed5e8c37b0c0ceff456c5570a2a578741565b825d17486694306f2b6848069c7f3c19ffae0ae87664bb0bc9c22c23257741b33c5b8186fa8a03125861777e034ddb2e8b2424f73cc9725b118dcfb0065ab64f47061b7d7f45323b8d55aaf60e193cce5c104249b33513480b0f65bb87803a4131f839917c738295de37cfa3b1548e584f4198c055ecf23b2c837321d9c861d1ec439d0a0b9b85d8a268251248f1c329dccbc1c2f0272abc01f145e784d1ac05c1461688a5e2ca8a14ae494fbd187f847c62446fa52a20c97be9415c4beaa69a7b8d17f145fceb25db941fa401173bf618cfa47366b00249b193202eab9f1e80339d2159859333634f1c1a667265a6653b75356c8cb6f4400a6b884e60ec1dafb7aaa79f09320b3053e8d3559b0d68e7cc4d785febb8c0cf02eb979aac9e07f12566fcc2a9cc8423c1bb77f95c4af60bb1fe945222d1207a64a44c07bf8561c7122faf80dc0c12d1dcd9d99beb7b2cf80dce237424df2f13e63f1671430d224003877c21cc7b4e25e5501c36fa1d11056b5b866a958f3b9e20b43f03d5047c11547958962f6e96447e5d1308d720fa774ff67314f8cf7c973667e5c673fa08f6960d3f243d74f777ad2036253e2d492ade5322851df4407180a00189368b1b858417c7207a728befefdae6bed13226e41506232d28e1bfceeefa4949b4dadb720cc85424259ad5e858d8f267c43c23c660fdfe4566745b6addb15be8c03240ccf353dcf0fabf7b7947200e9a52dd02fec5a454a152f00b10e24aa89810ea6707ee057d41c883a5893dc933a704e1134cfdb2768f3131234582a2a0975357c0e1a5c058a6114e0ae5b06ae7c1267ec5da3da86ff8ac861ccc7791ae7cd5fba1fea287c2137456a51030fd60f62db750358c84bb708195afb69116ed09ae13f963bccda18a2dbc52403ee6fd48f4f3403619a30305de273ee783dcf033d69b5d2daa58fb56832d3f28ac9d869357489602e0e52dc5804bc5dc684abd43efd682e71759858a0020c05c8b5188538817cba910d721867af7dde666e9a1b6209a54fb5d8c3f4656a96c96ae3830ef2a2c41b8da17e75e60a8745f52bc5934eeff30685508be9ac185c7d9c4979de4b33cfb266993eb579f21eaa0018725473368a422f0272d8f090c677c8099493c16915ab8f45e7f88370afa20bc714c21b6d028e51b34b3607ebbb00005c5d4157a7b1f4908a9487937e2de75b33805eeb6817b144d4c3b9626f313cacff3f7971a439a41df490b29e3ecb84461b3b8fed352aef0880cb1b16cafd3d618d5e63fa4f09e7cab2f5399cdabadaee92e29e144bb0b62416b958cc0ac4dfa72dfcac18c97cbb75069d0f38149f81a7be1a98a713ab792b4eaacdbc7d6ecfd19d6f722386246f1e08d84b97fe53724865afd5408f2248b721480a9663fa88a55418b77df3e1cf26d4f9cc126fbc937992084745797e5a44d326d393dae0e221bb09a19c4aa23cf8a30a8d30b54e4fdf678cb82df834773af527fdeaa13df84fa2308fd1196985623f755911e1e0853ea2d9abd7d469d82a8cb63836592715f5d8520755b9832430a508fb476aca2d9da8c1bb0c30fa3981b39e7834a456e13de0f19d37c91a241125f35a34077f4b328638098294d7303092435529df441595886c160ff2f558b5e0c342b514f32736a6079c11eaec23e986f50ec9ac4d70f91a71c5587758089e17ca857412b5832f899641d6aedf3209cba44b3082a7ed574b3a5dfbf5369ba002554fdcdffc5b1f1507e686fe3d06d6271f780781a386f472400fdd5abbe9ba9747e9322c562b18333406326806f2dd31636407a19246d2f219e56435c7a72bd52d4ce3aef8002f82e000e5ba7694a17744ace5c107913036adfe8237d697354714d5519b848ef6e39b13a9886f333fc674d44ca5f130d57c2798dd83a30c5f3336d995cfeb58a4af7570a735fea9d66e846693ea2c75a102b63a0ae7b953c51cadb05fcabdf84d4520b692a74b840d10b099f327fd283559775c30cdb82fa93f2762f95ab04584ed72f7d829971a3cb955de0a06046020828b9d32d6de7130ba5068031eb9f055ecb91fee8c58eed8e9f9cb88356450c620ae8eda543c53666c267d839389c32b7caf1e9dff661cd3b842b6e8b64af819de752954e643369b669861a0d29bc5d8242a9caa64d9ffe1bea94687fb2169b6d3a82219d95652f8e78f95ac2b41a57b2c9a5512e7322b526640345b9200ee8f54ea0a91278ab849e943ebb390e30b95f1c6ab3f0c3a9eb7df16b3d6d570e1f99c7e10ec65fb2edf08a97cfe6acfdf911ce92127d0eb97d7050100cbc2a853b91281f56da2a38b8ea14f4f9fc3439ede7d2c1dfec4cc9e5320c4ef15aa351b02bdca1831248d2042bff9656cd2dcd4e619fd11a66586a88d9fc3447f437094efaba76577e1eab4e17c4a56860c9f989925b8d6e052f294a2c8e4a0d4bb535b82aaebd60e5f55279a1d314ad4b18d9b10387bc3694eba406d60f2085258c387575991f709dfba278ec8db674d2e9ea12fc2bd0c30d742977bfbee9920c24e452f4d45169ad7996779d2b2a956a3caa932b94452f3894a59da1c15c3bcf77ec6353ca6e3381eb121492cabe9156b8586d8b5582b33bc53b03c8c6821626f0185873fbc58bbdfb31072a9e4f410fe1dd8d542f735eadd3981eaf29d6ac3dd1323010c1b94e258d27c215c088933f81352bac5decdbafeb3abb243100f18c609e140d776682e93b57efc5db13c1df64417fe89c6b7704b08fb51eeaaf66830c823e02938845456ec538a1c0ebf8f91e6fb31596c57c49140c6370d7c153563b69f935d05ac705b60ffac7108d45f33ba436f4beb6f436563d80341fcfc3cac5e266cf8d564b9a1d1c897947115b09968a23d4e30b707d0f195c3060d6b71d4b367bfb7656258a767185f9f7f69d5bd825384d7132cb5b87fbfe28bffae397fe5c4ef46051e00dd07a9b72cd06f573dacc0b426b42981049a287dd7bd0b1d41988cc027699e6ab550e8fcb445759a09890773e4fc8541236f1bdeedcc7932b8944e19235aa3c65956fbcc78ec85c6b0fafc92d61fab74eb0b2d2ddce333f4289e91791a55070cb537a64b55f53cd558af5dcce24ae30b68b73e6429842836f4b35f9eec1f0df48beeb6fdf5ff79508e830683c8007c230a51dcbce0ce2c22291080850ae5a9a1349436b0ee3ecfea689bd1b3c16993fafe59a850a2c034f02a9a71f66873529b74ca318c8834986125f6795bff498e8a91e726fff3ef0aa3ef3b5fd028d23ccbf3e07a125f8537812b694e828edfd95878b0606db73339a4979422b5d64f42a01a68e1b8a16641203f01443b33fbac2a062a9f0b65270cb3e106c84f502b823cbaec2dc26ed0a8b698afb39c685ecea60e51c35794af2092ef085c1df74ccc3cfe188c4466b7a37e0f1d310e1b438e10b2c7eac248594d3a8adf9c1a68796375ce682d452d32f7091dbdad105a5581c8364013d542e0b3a0e528987c3c8d1d8fdb4693f216eb4ffd5db84e4be09f79b95f1d6bf87b529fbeb3d1327ee4560823ff7fa6c4b1202ba1e4e4794ec472e7bac40a610c451814a77b2d950146816617410804133272a09902bdc75aca7378202e100fe28eedcf19d1d13477206a85dec5cb72b95bea22189ce04608a39f02a6b45dfd3e68b8532076d7e7f6a90de6fbb242999b890612b057398dc0271a9d0be9c0ef2c88129d0fdfaecaa383f197bd731ba37ea5738ced3abe820f9e804b1b588368dbed309e1a62c0a5a3c71af07cc2039b7f183fe40351d6d82a0785e085ad31593ef885a53358b990c4cc2c650462a05a3e963a63ff2b5decd164022e07046205611a485f3704ad821078410afa13af1205963767094a23233c585473f1002b79e8c1f22d12f241c48078826c36a492b0438a81c414541668aabc1c3066eb36da4a77bf7234336dddc5402a03bf0fe3503de1faacbbedc358ce719212712d5dae67c294508a4cf7092648e738be41a9c4a48eda2e4f386c187c851255390630029e21a92caad7d54c9cf048138355a38408d1397e6eb4e35e259c95e271b815d682e7f2afe741052d1b70c0876809277e067c62211a0f3a2921b2312e4bcf4f7aa44d0b57ec3e1c8fdad372e13a94aa9366747c52554bf7427f72c586b8191145480a7cbafa2c47862783a41a0fb2ccb1f0036d0e9faf5e5631a35668beab75c36fd5d6e827f05a6a1e5c714f3c493870194d35993218a55790d5af757520d484c97bd9640bd7422bb1d42cb2bbace5c6f5fda69840d95b4d4e097e657fcded22a9d297fd92507d8c0ec7cd9371b704133acd1db8bc6c3e1ab79f15e985a12349ed035bd02ea14fb539fe51233565156a9bd6df98626cedfbc934b9257554472cb75e6b35c986a20b89d41e4039d0f2615345015fd335187337d48d43a2b32094087f2466356aa54b0099104f0a95f92591cae96be5761dacc8c28909ea7b0296ee4dd651d9557177c6fbac2b549f9904303f652d8e808b85051b3078e68c524dcb64f4b61805f697948f24076667af59af26696e0e4cb59581497f9828fe61a48e547c60f782a4fc67e84fc9ac9784d42beb0881345060d544fe5fc3cb0d2846e732b3240caffcc60ea17429cfc9277e6515170afc4b9ac4b4f9c93f81b8e556af197bd5bb16186b690bc9f1cba7d2a683ea5deab15d10ba4d09c66fbea91a03c2242a4e1a0733c2e029695a8fd10b18ae74ef255c72a1a9ee9fd161d3677f3bc4a2ce9afb6233e0b9f9aa8b98325776be92498eebf9b2e4e443bca3af48c4c57ec280a68872e52edc9e76caffbc2d55b7033161617880cebb31241eeac80211643066b0cc04e1724e48dbb60d545db168a55e778f902971ec6de93db1eb56600532ac31f28fe4133ee902d2a88c2947907d036080d4da0d35ec811ea84148a98645f7ff9716672dae14c0c0561d895b5c17f13ca97eb0120987c4c9dc08d0e10bc86194f71e7ff8b5df8b82253d08de99f58bde72b765908d4ba5cf493dc15783cc46e435e4bd14a02de3bb1425861674c903a3e884e8d703294f68ed54e7e3ea95038b2cde679e91d7b25c33007a41acaf75ea2f0dd5f75ff8393fdfde6bbe300d66a95618ee036f975ac47e8c9f4313544e0f3d2a4287b82b1473368304d21d1914f5a92e2a94a3382fb9d29008950c7f70a5106f36c910d7d2acda31404a656d92f8186f27fea35910a43e22fb2377254bef888ad473091d7b51150ac99efba4b1b6c0c7889c86c27c9cead524481344710a20e5beb252cc380479677690bd9d633141a8dcb3b9285304f43d390b62e37018900e3b512871303f60e8d9cd1fb6c054b902417934e01f3660b0cc8886ceeba4d13cd7b6bc7951553ae520068b110bc1cce3711aeb01750c8c1f31de6ac7280320135f0fb5197c40f603a46648e7325d45e3df7e21cfda9d63226d3d5cc2d810556150fcd89d32747e1913d0237eafa57ab7646a15e1d0f7e928f19cdabaf10c089226bf661f41da524553c29379b763949f8585561392d604de93a0194701a7ad4824779aab316b452c3d61245832b28f67b7116d684d5ee495a49b4676028abb3cd18a0d1a44946aa0764ab0d592f2967c8090f4c7b3ea737598e7771a59d6fb5527eede2bbccab8231304b8eece0870966648aae87450c12a457ca021e76a7c0419551e9a6da4b6cb07fa53cebfab1d381b577207849e829fc85b26aef139d3f02ff6a55276b53ff6826125340c15fddf869757b7585e72b217e43af610c81729876da5020a81615e65d4b392e02228d2d498c301d7be3350919efc6283a51ec580136abd7373844676835c2acb575b4de25ea6cbc245bb31f394a93e39cb53c4cb9312431f58c4b12cf24b3e399844f02935c1b5cf0747ef74256084628427e5dacd6a29898b1d746b20bdb7e6cbd32a00d5f02139d3b679195c22f74a63dae4774b4def34752af12978848b33aa92f47632375db472f05732adfbb2ae4520e6246081dc2c79275daee00d32d8bb1176d7ddff20700b2ce913e8df552e4c8610ccaf03bcc734c04bc3888264fddad1985a9cf389d56df72e3335e08b265773dbb273742697d6ca04f3c1e7411aebe8d56b428ef06e3324026ef17147e11dc17f68635cde19596806996c501f4b60b3f6fcdf898db9086ccbcc8e37d87040534d3ce3276956c96184a04f2026327c26ac9b083ad4fa37749affce8c434f65de20c83ef62926750628674c9c2d8d32fc49e3bb0461f0486580582636ca890fa84f202e097926584d4e496a7f3da8f5a34dfa565df0236b5a8aaa117f773d2dc3899d9382e9bf5cf07c429431fc1392ff3460ea28353cf8b53ae210911b72b0f70ae623fcfda213b4d5ec7de833dd1b9c8af60948a422b7a9c1ced2a3151c3a4ecf657f91ecf41bf5a825611c50f691d1ad49444dc6a8496de21b2568062f6dc6f7dc9662eb9d3302d316282b22483012d595be867f40f69feb582b32339b2b97590a509722cee918e409e8daa367d5851d12e23264d3f6d073d81c25bca2c2f94993046b571b3a636ca93cee0db21a27a90836831d103b22f772a06ff5b61e4e074f00c0cfb8fb15f108585960cff591eb750f91365622f60a6788b460b253117e2a5055228272f06c436e470d56ba961789dbd2ace13c127e3ab9e600728ed4acc51c0e04ac2dce67312a7cc8903b5c0eb3da16b12a7f1dc40d53f6242491a940f0990cf035cf4113c12edeaa9533426627fa8207a78af9751f09e4c9c6fd8bb039bff2382a027b890b7ca3dae0ed1755c202088e88e1ce8384a66e6a9a4b46261e0de6f02b91e7e38a373aad6ec7dc9b08cd31b0bca184963eccfdc0f5f321c9a6760b933a73cc00cd59c16ef1b35506899fe830f02f00a2894948c36f934d6a7ce046558d0fc992182c9ef8322cf96d38da0e2cb9561306a7b8c48ac0f55a54d48aca0ef32a8dfbde94b278398bc645e2379dd76ac6981b2a4dcbb994c313d167d6468a27a8aec462031529d543d7be62aac314d036c2dc252b905344a8e278ee4ee181f3097f7edc64d289b148e67b3e3593ba59eb2adb7ed728d464a9cd06de9a410c2d2fc9bf31dd4897ebc9ead42ae4a8d201cbb50d207a7429acfa30347616bca4f497715a2523bbe2f1cc1ec0631885ee1352fd4e5885a511f85674a423598de4df2edc6b9e956f1ed77426b83825d444e461ec128b58d25176648b07f82e6269aade0b346da6781fde324a19c029e543fdc5382f8557046ec60be8e9fce64b36d20f9180f1ffb07bd2878f522628e6fe996ebd7cae35a713813d0b2a6e49b4b0d2fada5f9a6645342ac876b2aca5ea064fd13d9652b007a365370ff13f0bbbe7dd010fd7b294d091ef0de48e30193faf6d0c55e54d3b9adc1310ca826e64261755e4d5034e56a1f0d1aa13fe38c5af61105430fb29a09188e6bd23ab2b66819a5c20155f7d1fa011de8d6240e76808a8888ceac6e5bd67035e9711a26a117d67c5c14762f3f94c1e0ded36adadf680b3a5b28325331c9ffde477699d0f03dfb813176b8c4e7627959d1d877e474a738993f46137ba1a297b2534e75e4f908256ceb87792aff2a1f11ffe99ec0eff0e2aa0e4262715de4b79833d3eaf5226abc5846bd6cf061bfd9583b216cf248abaf1fd6070913a3f707ebb26ab86cb0b130871b2f616e8f5141378eaee594765b8cf649f80af3fab7be17aeeb753aa64ef8ec49cd32fc20dd5d1dd96c27d3cdbb581712da6fce8f987986f0deb441f3ee751339d439cfefff96560b11842f861d5354ef28079106adf7eb8088560e4a6b22074a849a588d5c75042203972e32b2da77bac9585fb23d7db17d42a57bc60b7d08054d953e64554de39a04b9c24d7945ef22d7cad9ddb5856b03aa400feed5aabf09d1bd60d06f089516383c311f7f78ac4c6acdb68c419e039a6150bec2e09046c2e4995f5bce65dd36209c3f4e2cc8054292f9f009e5f2288da554c560d8d024430d22d8b762a16d92cc457243442adf25d219a0fc89b78a293fdefeccc77ebd918629a947aceb601de8258fd35ac83b5fe228a0f328dad21b3e75efaade1081ec3b5a89e615f2489d72261356f43faeb0c0e02484623fae1d293cf55210752c0ddc40265ec0bf90613c142577b0c4e5faac573d715287bd2c21454401ceecb45722f1c144530374ea460de1e6fe0c3c3f2b3c9af1ecae2f2cbc3f5ecc10060a080a26bbeb23e1aed0ddea806df98cfb8fca05e9257e1139cbe7210e427d6af98b5ff0494bd4edffa01ce8d848efc1e34498b8a9e38e8c0d05e87fdecd368ef87d9845d2b0b34706cbd67c2331d22548aa410e88f2a7596d4e2df9d59d165b2bf4fa973386d8a6a7d15144cccc38a436554e0399a74a854e375d2faae9c987d99cb436e7da3ba0bba64821e390098571d8c2fa65af64681e570432bcee2003ca1c0b2d0115e87648948fd30b6ec6edc1c05bceb6d4154fca13da8b4df9208be4c1f33933efb2556f88715ff7facd00044defd8cb25a65c1abbeeb4656146fab35f054ce56ec50f1ba0c512c52aa02e5688c5069e12fd97d802895d459cdfa4c06c71552f75c1fef78f1b2e5911ec819a004ce2ad3c5548b49d52e09e9dba0907351bc4ba62911eff30bd56a95358cd3fa08f3e9201e85069855657eaf5834d5d52544248e08d387d6f75c58d4c02e2c021044fdacbe06eb5750c4fa1d18631af2d6ed49d79098774d4f6ce2a6e44d3d27709e05331b8de89c57a76cc1c0336b35a70cc4ccf58047d204dc7a456bfba0041eaa8e35992ece03f2982f97fd0c5d640d1c550c4f8b8ca071dab771364b32407a967741b9ad744972005361f29fad3d36a36e7b7f476bb8b6a6db48e02beba9fd4b2415b71216ce091ec825515da0251456ca44f4a2cfbc00edd6507a2f44890ddfa91d96c234117f87014388b171ada3bbec39e8109a96cb0a1bbd6c9e2bb6223b64762e0be0961b7e1805e82993ff9dd181f5d13e5ecf52d67a763cea9859603f27b97bc54ce62abdd9d1e18a107147be07c8b53ef2488c208ba23abd504c51ee8796b24ccda856bcdc24cd2a82524bf032d74b502d14588dd3b4ff3b7e1bba334393ed6984406714eb0a67192dbee2ba5783f6b2c20ccc7f4d0f6651059c548f99e65287da537d0a7ef056d5be81031ccc2229290053dd106232a517d40013143ed9c40a191dd8dcacdbcd7a85c0ff0342ec32f8e2f65a8ad45ae53bbe4500cb9ff783cee8bef7060d1c202354082fc8ef0e8fda0b09f29144210ab08386d30d85872c603442a19fcea13d58b25af1abc43e1440c2c1671eaee9c9b8fdfcfe78e896a0d3a08917826db2d815eaf9751caee6230466f25fe00ec3f7aa2ea033698f68b830e702c170068b51c3b80270ed68831eafe352a5bc4d5f0608808bf2300d4517f620976234e846852c629bf5c1f0e836280f836d336e0e674de2d8e953ca58ec744fa4ce0f6166a6519d8881c37d3ad4babda1f1f06dc81746a0ba281d85ff7815c1d35d417fc7a2997f8120d1df0ef67dd5ad22ad6668aec5ad5a2d240254a74faf79d9f90ddec61d0f426bb1828868af387edf13a3e87e0409092e6564f80370591b80a078a2479aa6024a7223417141dfe94ac6b0ba87632773762db9676db70b390f0a2df2f63501c39195c3ac463f1aaeb0e3c05111217505fe3d4077b33904d06fdf348aabef16d160fe25bec9db8b6501ae4cd50fc9d038904b932fba76e68eac89a9e675226da5bf35e16426a86ba2398cdb5df39730c6697d5b0062cc12f256bd78e83b295be22181ec09280621f256113204f8e34c49acb713f850b5649eeb55d9580aca660db1ce28743ca196f7b26afc5b7b6b6a67ed140e4713c37b3197010166d05a53d27f5ad16b86491753d3e2f391a48359c400a1fb9a7403735323392e539aaca2e5cebb545a5a32017433245e5de1248a1d6955e09edd3114a9a459482f356280aa2bb98fae329aa57f85ab969fc55c11798291d3cf59b994dc555557b5795c9b32ca1b9442d99c19210aeec001daa39d94893d6a1e29a831f34a613c8da73600255999931d4c7390e64ad457f9b602e980400572e39cd1b88e5c9f052fd930db7b13e5016718384b370cf7edd755ea75a73c736436a19d03215fca359f663c7af0f16818115b9033cecb7072ea4560f21de6d44a0ec1abd6d9f3af81404a78d6bb666b5912105d921fc65febcc9f272db2d30002b616d477eb18e714866b6e41890aee1f3b4061dfe4b3d23905a67a98a882833acf6261ae426d0b4344795e1748248bc3e89ad48af708e13caba08cdee3d3b94dbdface923b309005973861868e7c9295c34521e0906ad854e2a1419a4e5b10278da3345fe65ee728c81a61dd348e2e3604680285d2402085b52009a98e1d4e61f75e17eef53aaf407bff9bed5b07b891a7030d7eec01a3c3289d749a6adec6f78b930b702fbd3a8bb0c081cb2e11cefa88c0c0c3e7bf036aaa59cfe626990dfd3e85ecff37a0786e25060b91933a266451ca90d03c73b174c7f00641e2999a7034344cee08fa7d44043dc7db3676a00a5dd586c4e6fddaaef302db3694e511aaf3302ab443525587ead793bf474c7d3b6e4a3192351e83275319fa6cd042f962cf82aadfded240c0aa2dd9da2a41d60c8ae75441575a7d1e638a797aa512c20ec2acd380c3e77d321660ef8eacfa32a4514a28fb601e8f87f357eb7d82cd167c45c4969a3af2a0b6055d046d866c5d9ad8920eb90e64d7a2d4734713c0915f12444d9782e768aadebabe43373fc139fbd605c4dcc64ed934c2e1130b2ee25bba24fcdb1d1f5559a55543bec4c60fa68ca079ddc53e9dd7e4f447052dcefc61ac20f8c0da7de6dffd62328740522d9e5e7e8cfb119f86009c0a0c72dec3a757ca64c64495d9d16a1550a3d74bfac7aab8221bfb6163d45b0a53009fba81f259d09fcff4a9ee3f30b4303afd87a23789bf1a63ecaae08578d09190ba5f68de5efe8c920a922c40373c139ad601506b2f4bc60e2129b78826b17ac5d954de1ac14f899a603bcfa2ca18742b3d84a66e23da145b4a3c42ff5c773a62226c8d6a8caeb50a208908222b2f601ef3c37599a48fd505bab6b90436c5cb2189641dc542603de80c1bee938e68a0c28b48e6857c5daa05ce25c4c84b589b3137b280c1df8adb5f4417a497947f05217dc888f684f6873793d12caf19dbed38cc967e408b900d239694a982ec62b7abccaefeed39feeab13aff90550e70e6e5b97c2f664e8b09d49df95b3729ac67ae5086f03261c99ce9893e7b7c1972822bb50a06395a4319405ec18a632b53ba958dc67ede821bb0ab7d7b36afc78a9722eb3cf92ce6619701f55333e845b22969d4a896b8fc739ff61ab78b66242f3041400e8045eabfbc66ef5c4082b2c0990b31073c1332480aad092714d30d082c5ca6a74b9128c413c873726cd010ca3ad4dccd442fb8551afc2fae2ddb82a5622677245814dd6c37342af69c895da809f94c4db3ebe4232ee2198ff218b17b8fb9cfb36747aafddcc32a02d91ce5baac5fec92107d7f2a891baa738867a0987a92f8c2407c8f54d74a05e5310a2da05643be465f374e90f8324638d86e7aad04f8e78e58532eb0b1baa849183849482f33c2660a9de2f5e50b245b417ba2ea706a8ce83c55543fecfaa8816301d98f187670088c9d9566cacc2941a490b470867085ee2161786d1177d07f673e2c0a8651d868a4ba2b976e0f2f8dd06f2281c2291b6a92844ac498f929687965d36d896adb294ce9c643d0435c05979d56d159ada4a441f6101b69b8bdbc114102f63bac7ab7ae99d62f3237d4fc4fefa46e8e44b0f64c847cde1ccd209f135b8c391c4a441bd2c2813888f62b903e46e6d6ea1f835818cbef94196323d420f5a89ba871b54982115415735db870d14297cf51d844e6c059e8fe85d6edeb533217611da6b19487b3aa91d41a006447654a4eac0a0f286982eaa3f11d1ef4c4309ab532bdd7202a4fe76543a2c481d450055fceb279621e445a4324b4a30cb73bdc817d6e160dcd84ce914226b992d106e291267e4824eee77c0a9d465bcc8caddcacc50b1b2642c8448e5a8a0f826ee8300e2e0890ba7c84500c22a0380a81c759852983bc24683ab87be4814ef38e2ed55a3e00400c3b505dd96238d178af20e18b40a622bf6974d7a3a95c01157dff989f8d2e2c9e75312064cbb8963ef7f34ecc400730d482c3e4a9aea1ba95ac8dfd0a264c43694b03542e04e9034f85736c5a14a6741115453c244c33d87d9829f102fd9f2db3546e166b3fdb1ac0d4e7f49e0e7cdc3e97e9b0a9d2b968ebc04edb20bfba1da7b56e33d8a51345864119e91be84653069dd51201cf312abf895271e2a37311dfb3a9d16df93f669992c6dc4b208a62254e84a5b65377632bf89ff7083db0ff0c332e9064eaa61b39512645774d0e229333b48aa845b4f4eb8f93b8e69b360db8639100db2b50ea1d4b0c76b8b33c4b620cb528162665dbb716581c7759d6c9d2cd8d631b594a474a9e21bc65c048c9f6716cd4b9aaae4472329f49a7b9bf8c5b7dabb606cf6e47930f0df472f604a2a62e03118d07ddc31746b9aed06d79387de62e286343f00bb5fd56bb02373d25c62eb8b9cd082689b50bcd40aae1b9782406b789695b073c271d4ee38b94de5c7d178b8ffeff91d46eea483089603f37804bf83962e656543c2324689a71d63423f88fc2dca29e319045b90c6050f19b74da2b9845723bbf2924208d8b65874a13aab6805db757a398497e9a31ce5f011d3076e49c6a271ae7dd147418b061602753ca51e6a2f7f4e366c2ff4b992719d174bf3c21dc1b286800a6724b51b1097d1912d3ca829da55ea9850e2fc19aab11bd571fb743fed9285790b98402741110da9e3899321f0647c243d5cc2c7605286a4475108446b0d46c2aa985409b083117aaec0fad22d080401735358cd4554decc2d09f7640b8ca7a719db6b129f72d298b6381d24f5ec83e4e9e861300fb2d6c00f34fd4d78b619383106c3aa5093274bebdfc230b8255bf44c49c6952e1414594f66af4361cf24e1734a3e36553297e296496af7d8db57c5af27243b959d51f20c7eb4654a0ea2593852adb900b5c90c17d03aa8bd8e6b9954ed47653882157d694853eea42c8cf59535e1a81f7c0567c45441d5a9b4fdd7bcc2ffee32106a88bf1921d66970313ee34652c7b2db0c41fdeae14d3c0b93832d497bb572bc004cbccbbbe704d10f2c7018fbc2aa4b7ff151e6eebd78d87c010c88c11c2e799e9273ecebcd3b2b4d7eb3be350bc15a8ee8d648cc49115a99c775ad63349caca8e261316b716a94b99dcc9b00a72dcb9cd8448e470cf5d90e9c5a6883390eaa4bdd84baa353b949145c98e6ec8b979ae700ebb7c70b0a2f9a86cd3d94bc6188fe4719afcd7394afae850b8b8a57c1ed6ae883a520084b317667408b69296bf68a92c51e0b00910f11c1a066361ab7cc40d01d83cdcfbad8efa6400c7b2b7df9cb84b6049808a74d860d18fa8f347274977067aac57790114c6ab32bc74e8039b06ef158cc5ab529e8b57b9147575f9885846d0b365ebd0e54b3d60171f0bfe7ffc2445f5c610b8d00cbce00e62b43e14dc55d2a32d63f795746c0d9c84a09d19b0720b6522e490447cb42b4619c3fc12d125e0484836180364b16ef6dea3403c74d9f92d93028102134dbfecc0f17c46a4d6317c5cfa69ff395aa84bef9d4ca8e4a81fe5b9e387e8663083d098f69e666294620842b804e0b10d7e5f0fdb2c30e7b19c5d7ce9b0bd54f5f5c4ef25fd8e83d22dd6201cf5008a0957ef1610e8868eff4b34382ffd76a5ad167718a0970451fba13a108728a21e040e8ddb9159e2a4d66990f6de00e9f4a49da729bc994f32fd21ad4379c602b13edc5ece29cd88c161fb53e7b5bf221fbfd1544b408cdfb9b69738c0f444c38af947f04eef7224ae440e85ce81132ed20fd6a08b7e7c7a22d5d731145bc1af3cba061f15d7ae04e76aa435bbf6d5a20cd051450cb00d054926f86e832992c800f82a449879454bf11d111e40907e146d6827956a0d0b635c054e844b43b8b8155af0a47b7c1b92f9c177f588afa6a15e7f2c318bea4268bbc11af70604ec9be9f6165d827ad68d513cfdeb919beebfa6f2b92d8692d4abd2c7e1c109e6c2513504cbbb6cadb2dd4f45504b77f8fa26581d6a7f5d18250f8289d705dc1d8bc2d46c8c8b56a3b6ec5ba60bfe37b8cfdab5e744706f4fadc4814ebcca050dce2a784d8fcc6c994d4854f977394212aaa46f915d9825b331f921ec956e6e5a679d0b0e4a4a8e3b80ba385d93016fcb835f415f4ae21fa8685c8df21ccd8c4ad0d20dc4cebad442240f415d6839c597d10f8117d059e0533017288bd86258f90a03710924b1558970333af678dce4bf782cddc68e6c849612a8cf84d7ee199579676266a383fa729b69c1bb3fcc99e42506f55293193accfea1ca602199655b13b20cea5849144a48da0d2bb7bee180f0043134c7496603a65a4863ee49c0d77b724096229b309eb6101274202e2accda05f0c0c3b034b533330c6ce3b3149bec663e2ff0ae78e2264739ed3f79bd4c06cfc0f54cd25f655cc5b857b92be8cc846f037fc398a656843de93789529a672d354ef5053ca722c71a628119cdbc89539adbc011256f4ef4013751bf94622331b18755b188e32079e0059158dbf2fca29fa918ef5096a93e27ea1f9e7b9586fb0db0e4ce103fa71927c5a30523a4a1b557ba611d5181049f87b5d3578efeb15ed62555c45c95e739dc48d5d89b1a19346eee9649720ce20be71ddf7cecec471e3790bac553678cbb848f0a2321d57063ac65bad11fd0fea13d44d12222989482291bd690760084e07b0073203ca3f72503621eac4f840c0f5af379d7e867b4ecfa8437fe6d613874d1a6b4a8fcc7d55fa56383125ac63d7755dd5d0dbaf32f63663d6630880bbbaf247949a2e65159675adb56fb19bdc7f89497bcdbe0848763d92f65fe7eeb57addae6bd332eb177fd8d192f0b2d30b76e207f8e362e211f4b1711fe311d1043bc62b95abdcd33c8d5ee2499df89c0d2c184a1d4b7b9e3427b566fea491a86661463b9256423ac16234e0e803a683e455310fd8ea0f9fa828ca96ef590587e2cfeaa3ac2af0a5a2c71b04499ae9ef859d197961cbaf681bb1b634e92f866dfa6d03024aa53e6f67db7fbfb36ddb7e1b4a42b76cda4c992933fdd7ed4c675baddb5002bcaa3c0b226902acb7d62f86bdb5d6643299be6867d96fdbdffc75fb9a724f19f8b587d956b4b79c846e0dfb2cdffc25d998cdd56399fe35bf7e90846e5d61e79c55aa6acecf3dbab027dc39d20eb955b9cf97347b8e30aebbb95ba77c2eb54a1527f6c42e480487e4c79f28a0860c410d77ce96b342183d9797c72eacdcf4da2aab8fd10cb3f7fbea150e81e14f5da137037d78402f7e0761849ed72a6bf4aa2a75304429c03ef62d60df02b744ca92eb97d4c72e0da50e108c5eaa8a1504160a61bb7d485eeae89fba62c04203e0eda6674c8c7388e34044fa56ab351d0825c4e8b3aa755befd65b5e1c41ce96357abfb3054bfd59f875cb4737d473c884518694f51656cbb2f4071f47f4e1d5e73edcc1e8b6657dc51b96bb68647d9dd6b2acafea4c22ddc15495e538ea43fdc1b774a53f77aaa30a28a594d2ea734faf023a84d0e974a702858218ba6c8f12dfa330c07a9475fa8c925616ad547644e05aa5cec49565d518e3ccb9d785510cc32686490cc3302c6298631886c11a42955583449905b99910d72a8d6adad4344d46d7340de20bc3988d0eaf0b5bb7d6420cb3f6664259a669dbb64d6bc7971046cf9ac3abf9b6c19979c41056964bd5d0b48728c8cf77fc32b05d6f189b4c27df3dddcc8c27b42324ee1cc8d309e108899b833cf06b788c31c618b5bbfc19a7749f4b61be54b992f4c481982fb0d003949a77ce2b39135ed9baeb6c6c6c6c6ca2436d03521fbb00906a3acddc1e39a7ac8935355e032fed83e1749a99e1381a9a1a35f0c6aa689de130e73457484d07d40175b1734a4353a3464d4dd779363637372854aa67e762685574deb821a35f35375046ef6cf00dbe12dab0216dd88836bcda6442379910148ee3407983729c6843dec09104ae40638ef9835be24ef5ecd41c570e1682bd317f292171dbab23f3349d6d07e6c163c29b96f15c1e8b5d3c3cd5e27158a37d45fb5e871107077338703e5b08b5ce9183f32204f403c210421041870ecfe33a211d6ec70e1e3bdbcece8eb6b3b3b3b363632313ba2184c3a3f615ddb89109898f234772dfc91ca1fc5c177de7e0703964f41c392aed33a7391c73721cd29cf5a633a11c5cce0de17a16e48a0075441dae83e66428cc9d5474284f803d4f4767c70e1e3b3f42266421beaa954a553435654c792a958226ed2bd2e1e9e87411da910989bb0708f2b83c78ec509e29a3f3c0aa7d4b3c2f13e256277ed43a3b78ecf08c20a343c8b343661d3dc6e831422b7ff59bd0dda7363f222866f3d8b163270bc22313a23c3221d72828f8bb0e631129401581e107459e11a4ec4164fbc748d4790a0001c884049009c11eefa9da5734c2087284e8b0070a85d4beb1a3fe260081262c8c6e44c6996c77aa69a414d248e98c926a0de91473ce49941373a0110906d260a7f657043f3772a31d03f6f73d938804c03be0f8dfc78813638c313a86151cb2ed1923b7a5ac01f5e855abf5b562dc75305715dd441ec444d8092184dc7dea5cdcaa28a5d4a97b2c62d239e5c3af43f2ab6ac99773da9b1e2f289d93cea9ef3c83fec420c5bf0ef94f2d44df7277cb5d4f49abdc3306ab307f5214a8be728931a4958ba4f690fc1bebc72b095b0f777c5a7754e2db7591d4aef4d07c9737d88ffe0d135809dd951ea25aeaa1f83ec3d2972caa940942861bb24c1720e1e1080e2e3e40022f5d0081cb126362161d30e388279acc3082262418244a62e0a5035998a84103369c71045a31a241135f9e30592209337e904598264884e942c90c2906121b4c0cd185164590994195320a10850c252652c2fcd0c5bc922305195e6c20081f34d1032ae6480f61c0600b285ad0031371cb912d3e948004484835f8820c19908104298d1ea028230c2c494954073598628a256a80d2039931908821a3054300010aa32f35d030530922c8a032c4132c64446024c34042811684e940131fc22c9d012684230f0021cb18198ac082e6e0c8ac02c9092ef0618b3159a0e10130a81847ca78312687107421811552fcc0831eca50d9e28b333e3066098914400105151a7ca1e18b1c03893efa000f9618d3449829611cb1028e61860e70b86203165ba8902408c3064e0091a481249070010e8a8408c1126472c032441857c0e8c10f860801164258018510f308119668a207625809410c6e9853e091a9a50b078a30438a1f68918418f40bdc12850cb4b84203661c81c313934a1a5794a0063878f24412497c8104822993c609c68ce0cb1667502fb48031c313204ce0050751ba4092c2165d6cd081862852ac50a5235420819409242d30b1850a25c48069a265a6801a01c41622e822461844d01b1c992f80687c6982e54910aabc400772043f88c00654b4c00a0e5ba2e002890c63c268228827be58c2872d907c51c20834c290c18a3368a05e60900ca2f040822bccc0e1055a403252762042074fdca0c50cb309241698e2041fd042891b82b0c2060f38e38805629630a3075e680d669214e3e3012caa4841175e84d1046a11812aaca46183204ee00507ba1c296201106980b105193a5cc981d200491454ac30da010f1ae08013740631d00004305ca0000733a2805e661648341bcc20450b30a688810697b802314a3ce921cc0d42d02d47240f31474c3027619eecf81188f8e323c6075a01e365c7773137a72c29fa7895e84379b0e3fb951c36ddc1beb82cd378043525c09f2bf952f46ef08071fc3ff635f237778d370229c6ecbbebe6ed7e6642366f6176f3a7fca5f6e96f7296bf157676cadd679928b5b38f9910f69f27d5f8a4d3d1c912f87327950cb8c6bf67416abec607c90aa3973d8ef74eff383e6234faab1be37e467f7e0c247f6ee898e1682875362db5335dbddf6c31a569ab54e9d93769ff883ab08a8d118b91d43f5ec7bf7127db7abfb9827dc79bea3f586503f9d20fff127d28fd1ca3edc41dc7cc97c2c09f4cf912944792ab9faa554b4a86061a68f0bfe63412e44646bea05de92fc85a7de7db9e31188707f8835a64f6e3ba6ac5b8ebfe33b8af8d999023f1439628367d0c6a195221f14396a44d6b75749d4201eae931e14dcb2e10166310474675fb58f153138cdb6b6fb529b0efeddefb4375fb6aefb5d785b3bd32cc6a1b5c98fe946127d3fd7ab7ec3bc3aa1635acfd479fa86947f7de7befbc990d2e2c135a68616484e52f67635fa3cf497f7557bc4df0f49346e3199a65cf68d9333371e6bf222af42b38a33fece929fb36e5df387f38f6fd4dcb593ee2a9093108adb5461b5fa6ea4e297dabb2acaa48ce105007faa81fdfc6c6042f6c19718e990026ed6cdbf3e3c76967d3b2aba4b28ab01859b08108b344f73697aac9356832cc33d955057d4929a592beeb9ee8590f923a99f0965d8b51ea4facfcf564dde34fa24f7d8933b5397fecd9137f8252330aa5d78362a27814291d8a01dad388cbf9fe010155203cf9032552f4a9a46c229bc826724acf8532f341d18b3ef2639229e22cd0d81f8dae2a897434f6855536d4017fd5dbc7feabd087c7587f75d39aceb47fb00aa55a89dcf46da5844aecf38954cece0edeb4eca6a20d49db6e94e6bb1b98053f2adf649bef724d9e791aeeb5c76ff115b072fac32793ddeae55996657fbb1aefbad310d6e81aba66dbe38f3f61968d31bc7dbf313621faf8e3a4fdf2a7fef7fb7b47bad8b24a4846f5dd49f4e2e32ff873244792187c17945c3fd951cc4cbc5d2cccb9aeeba29452eb9a3e57a67f5dd7755d9665ed58182db263557fe5b96bbe95b66103feeac4138a65f1a665106e1d1d1cdda6bf0eebecf8f6b2177677f6ad738b9d1ccfc39b96edd8186d88db9b18d9d37f75c67f382fc1f4f4b993def8b7b75b166d599f3fddb608ecb2bfa2287b28fb216b6b96bdbdaeebd22eec56edf433f1badfeb2f7bfb417263d7ea0f76b96e3fbcdf4bf06d6b6233b7aca75996595d62972e996bf9da7a5d6da30b2875826203287655a16f3f888691b5828454a7acb08e38dbb9ed9d9bde5d7f443b1bff7d7b73c5827d63ec462f76545bfbd6d3fc153931e9aa318d556ce6b4693965d921eb33df9b56e464574af5e6dc78fde7f4f70259a0ce71883afe34436aed3b86d94c04bb14814a50c9a1d276a0ee081503fcb90f108d1d7d9cd817e4cf49fe489de851fa0d903f3fe857ab8ad3afc3315be2aad6f710faf5c3080c922a92dadf0ad8dbafd25fead2f067ef5bce74fe746cacba2e4d94b3aba34d8ba436d54377a691fd4d5dde4e4eb5d65afb35887dec83e2951fab3999f6d95c4e4311100c981e860c98be060762d24b1c88e9fd6bc41bccde94ddca4bdb2d7fddf79f8e1dbf7e50bc377b98ddec7abfd7fb755defba48ce1eb2bad3385a89dc4355d71b3d9ca26558014365432b631ced6e432b6178b095c43d4497ecfa18e68e25895b49c5f2f5156696c6dfc470ccc61ec3bece8de9fa7e6928a7d4fa44a20fce1ce74ddbb7b6be045e637c35a6ab43d7f9f0671ff5634d4718c40509680fa5cecf20cb940122e5f31fe265caec21a222ae89fca1c0102475744aeac82aedf7dc00266d7a85942c530648a6c542f7a3eba856bde97b0f8aa345c5b3735b6b71b6cdc9d976d3b2ebcd222cfa0e8a78d82da59f43297efa3350fe70dc9f3ecb50d9cf3c0472d24b5099462960db6666def4309cf457f73dfdf60d98d1a687d9111666fea497c02a75502b68da3b10fca8161c087e07f2612d053564c8fed5307a1d04a2d5e8ddaff9734ef4b0d4a9aaf937ce237eecf40001459d1f55918df10808298c5fa94fe833dfbfca775da55f5c8ae042c49e1f87442e457079b267915b5d8e31613552814dbfd60af557814df557813d047fd2eb3fa81dd312de2118e052041727732b997beaa8efe5520a5ba38f125a2bfdfdf6b1d0a36f037d6af4a27dfa1df4713d7d6bb3fc18f6f13be8436eecafdc411e0c67571fa1577dfc0cea602c75aabf740779aaf9357fdcd657578da315ee64dbcddbf53fe2d88ef9176dd75f7d0a03ecfb8ab8225225e697ce96f988efcf8fe60f196387434d9dcda638e83bfc0972273b48fed4a50fe370ff00d4891f97e24ffd751b092edd80392a9f1f595d58e8357f3dbbdebb2fb72fcebe39fbeeecfbd04b80dee36a9b4d99c6efd94353c61868918d3108ea55911d2058d29e32fbaa7ddc5cfb8b3dcdfe16524a7736f6f52bac6aec87b2afb6b705c06f59c11e33219f655b5dcf8454ffed6c0f8abe594b29a5d4dddd35f6d907492dfba699fe7636fdc135fee0bfd4c24cc80ef601d285ca9a73caf8517a9c310a71c2aededddd7166c09f57e9cf4a0404747a82458716649f69ee37cbde5ffe9c2a9abfd4dea6eb6ffbfb35b9060dd6327ab5ab65d909706b7a9e4cb46e5a6541e4cf24d5964f935465ca94a95ba45160d93ef6f7d29b7d633e5950fd97fa56d8b362d8c2ae6a55f267554d19b140daf32bfbf153a832feb9422985a8953f98a4e5e200891fb69450e290b976717dd79f7cfa36cbd7d72cf74df6dadb2b13d22eedf2781dd92ef616dbaedd58f6f5c8d5b2b77f3d561fbb6c9642d1ce78e2ae1f5f72ee9c007ec88203cd2ba41894b6f555cf18eceed42184103e9c4257fe9ec89db8932ddd0996f9d39a724a6e4ba93f4b3ef6d8755ddcf5f2edcc84a4f4cafa2a3e5137777443767029824b94524cd70594caf17672e4ad79a6653ae5ae6fe5c5393b2998049403276e3bef964d6ffaed31beb2148ab6696b307ad7d34a7bc8331fee9f3fafbd30fa571577974f63956d0352749154b1d839abdcaeb1733bcb72db78b1b86fb2bfd7da6bb32cfbbe70df6cafefb7d033a1cb923f6fb8bb7c1a7386e05029e38b0a0afd59299d4bd38bd8bcdc9f385d010da3870202fee6290575fc973adc45cb6e129654df924f89e694ef50cca5c3132cf214e914f1e33b3440922d9fce4dbf4ef74ca88a2f33d1dd3152ea35fac49f918a20ec0ef4240584b7c3e3e04c20993157aa16dc450a47f33635ffe10db91f1f38ffbd0f8eff727c6efce7f9d8f0f15f6a93f01fd01f798f12508ff2d13dd41f4dbe79541ec0771967d764283e5fc3fee4018c1166cb975c0daacb10cbb6e1aedb6578c5e608cc4a972115b562dc75ff51ee141809fcd5db6558a52607e049c841de4716f2353200fe270b3d4e4efd08f9c6f7641c2f808cfa2e432936978f709fa4ee1e6f6fe4111e47ee795416001553173813a2b12e244319244779030000a1548690077a3d2cea863702576f97e10b6480058d11f8abf8d264eebb0ca3e09ee66d6cb8e7381bee761926e54cc1dfecb20178e872016cba7499009c179adbe51fdb5e81bfd9e5126ac5b8ebbedf9e974a755efc6420df651fbb264339c0d3fc7c8d03bc09f9e7ed4f36e10f90a3bc0700d2d5f0b0cb24d828e3f4f183628c31c6184f32292949fb1a244934c4f8f8a2143d2f38d9bb401e2d5227cb95ec4e64a70279b4d871e6e3cc7f914b0277f9a72607d4edb20f764597078071d1e59eec5f5023f3fc4fde8f93771e95773c8eacf35d16c0b6c947509fa46e1e6f3d5e2e43086b32843b43b8c3c3eab143271f8190c7480c465be7adbc34b9a6e66dd4bc083535b3cb01202133f1307100f149f857c2dfec3200382df876394526ea24e16feadbe51e9c14396e974718d3651e202575e37cd0c3e8e1b88142039b508f7a9ae7dea9a03ebebd910971a8f7501c0ad3649bdce51d9312feaa08b7cb3c1e6254f6c9f931972eefb071464dd6f135b2f73f39e8bbacb3ad4d969b8b3128bba703d3641b32b5cbdeded2c58bd29718268e893a34206335c1dfdc71bbac236b419745e87208d6043cb7cb395b086a72085f23e7fc4f2ec0e3e41c7f23e74765111e47d60f9409f05dceb1b90cc5000678287f88483fc238e9e8e82893f025641f06c84c7ebe8607f2a3a5c02772f44bd857a91c513942bdcd8b40f3dc5b2f13b2d129146d08211a9506f60821e7e402641873e89c6d641f99840ca30e01725cea94701712f28ff7914b781bf9df06d5657d9552b7cbb9ea80bf0a80dbe5d7b2a58b8f4c4206ca2ec665b07bc40f923f36cca872254bd4898f83237b97e879c9aed4651c1b33a2cb37503de8b95db6b19fcb507c7c7e7072cf002e0e6a7b54ced91598f3b95d46d964a75293bd4af42a19e06f76f96673198acfd7644fca5e253b8d8fa692e2fec6e6f43701f93354e213aff245208e4c2327b3e35f2f351379141fcb1f66d4a926f2285be2e003d296a7a29ea8821166694ce1a5ac17766528d80f134e889ec49e524a31aa6d76c01fc678d04257b042ca0b51ca082c44ba1c5ea864a4e3f0822c2ebc07c2d09903936de32f5982e1143938b1bfbba39414fa70337607b168f8ef5f1915c4fef5715f9f659402f0df4761ba05540bdbbfb5305b80c6850cae040474420a2c044d89492bafcca4262fa015b000da3ffe05f9037f85e853450cfa1416b629d1c7faf8275c81572ad00f79cd8b5ed575bd705d4a1ba752de77152e2d0002712a4878bbf4bd9db0c5f8180f49f71ee194c14058941fa720825dd522123dba2fe56cc72943e528c658f557d5917429ef9d4424104fa6e094c147181416bacf0b6b8555b6a29765458b69d9a11069d179a5624aa6a495722c4e2eb6edb2b0edb3b7d9b6592793c5f055ad4bd334ad5a18ce9f3fc9b4ecca6a666536bb19ceb62ccbb2ccd2d6c3fa4b6dfe24ea443762c7d732a49457bbced2d5aa1615d2487fbe67fec6dbf64b6dfb0169f64d883f2e7cd5277bfb37b20d1c8ee66d7297617d5b6766ac9a1a341cde5c309994f0df87d643ed743a65990e7aabeb8e968e8e96e2d1921b19c9997884d5ac565c6b05dab5d628d68575524a5f51ae2cde188f8ee2516675448a4947b5bad157603086611886bab1e930a3a5a4384d3e20a57af294d5ac2e549fbfddc88d6a8862845305555512f6769c28874a49a717c9d94352d7eb2e830d4af287685403e6a287f990b2f43fbc292a7fc6915ffefcd31e3b7a07218ebf6f3f3b8e6cca1e7573e2a287bab9c16167ef4a5fc6ec48b323102612c986a92a33cd859d6938af945856e997bc6a8555b6cd43f2e7e7568c16b6ac9a1f7af531a62f3d87c86da94091c4c0202c9fbe3771a320729bc0ba419c49b5a6c41f0752ab13d1a3bec5b7446f8a11d047dc4044ef6807ccd5ffb0172f4b4a5e941cc90b4e5735aa732324952b55934ac2a95143662643af8c3f85d4a0017620f3514ea267e56ac99c713a207a2c78730758e6d0e03ed4d0e2f5442fce1d60a951190b90e7caf6db4490092bd4f0823fa8e4829c3ef4ff5fce6a42f4cac0df4bcf8464cc9965e01863ec2612d6d34bb8fe8b615bab3fab8a12bc8f5c9f046fe83dbef70b277afed8855595aed14b5082f711ff24d84bf0aff9bd878c1173c1f2adafe40c5275c35bd66412d630849694f2f3f0756537d72a3a05014e10f0e747f15f70ab7a3742637f750355f94a4a5dba402db54a596b4de29bbe53aa5128e8214b13d144d1f34ff544cfdf03d890f9c5b0e5c3f0dd0f03177861cbff70f67cf9f2cadff5f5ad4f6eebb3b6f51f8e6519b176d543d6e70f495165af28f0bd37a386dcecefc38dfd25effd7bfd7529662de6ee1935c4fffa4b0f5dae3fd410b92f6d7da67fd56b7d51b9ed3f5fc2e8535541719b3b16e176d17477f23bc659ab1860df9dd481690499b3aa26c8137fa681e15bb9304cd74b88dcf5bfd63a2bc9559dc6950a70bc4c948e3ccf842b4c9ec0401bfb947b54b06f1b23d0864040de8ed6dfff07bb482995e613f80baf9eb63f99b2c72eec8d0a78e5aa441e992d5fd62c5a556cd2c2209b69ff75d8572630aa7ed1ae4bb0ab2a1c24ed6f2b2f1d117affabfaea11df56ad2c9d84eeaad2a82173573f77a551d517ed4a9aa8c636f08728eac80f6242068e91df754bd004a5c90ae2334e8d023ff6d2eaa21731fb1447c88d5e9cd782f46de5740aa13f67177db069adfe7ca3866c77ecad22387b08c782546afa714e3b5fc87ca1ca55747ab155f96bfcd7c33b495984bac936b9abc10eb05d7f5516d837edb1e7d7d05f0f0e68467fdda95613ceaec5a84bd9337f3ec6b5fde7799ef6f171601830b6d01e422bb6a6e1145ad52c4dd31e4aed09007f807e401ffe9aa601c91f1f03ea646000fde748408e84bbee3d0f2905b4c3401e1b4db0fc48136d0c7270c54a1949fb53fa7120622cd5d002fff5d6d78f5fef95b1871b7ec4aca1f9f3ba3c436168be1cf26c5af353520790528efef75fb73b1b9a69b4faad0aecbbb24c58cbaec5ae8a54c99f52dbb6ec2d8b94dbb66d407b4b6d58fef89498923f15f0b2457eb0e2aed3df7b29280668cb16ec5db4681460ff20e9ef4a385e680cf9c79f6f59b7aa1c8582fc0f921615e3c4b6d9d08a182d56651109817b88481691f38a9842d42e54a99e05384c7221b53dd79e9f702935addf58ef4f5d000442c48958fda0777d1b46ee6e79162fc1dd5d471b46d4a9ae286d1245208417e12cf01e368cac1feac3a969fa23c2b099da1ff6433a1b811afb548a2815c4faaaf5148498fe52d0339dec9fb2b7699e55d70ad999a960952953a68b3a7115020ba10f9a65fb4b27b6bf10b7f24892fa4aac4f808c53d704500d210fa5b9fa2b53c15f3e66c4dad588b52f25c3cb7677f9f43d53c13315dc359e720bf74be812eb2d4705630f3314b09dc1c03d0462ca309c9e72798994164e6ffad44e459f4ca36af4a2ebfa033b03957ddf042e34157d3ea20b81cc3c0ca6e79e9e7ee6e90ba9fe7a9aaf8710d2ba29b5374c600ceb88ecac8361060629dbc3c0bd897bd3b3c069d36f9a85199d653bef299bae7d135054a72e30f884a01c3a60cc5941c41bebadeabcbc04140ab24c19e9310cd6706e8771155777568fd07b58d1670583af84e0b437e2eed6ebbaae58aff40266072f607630da514341b1b0952923b7f5371b71abadb9bd4e6d0c2c25be5bbf7080ba14e7e1bf1dbeac2afb002a239611e99e87c059b763d1726256915f6613e93edfca34c3cc1a328dc8c801998618dba4628819620b104cb144c548ee6049054488913421bc4288a5a32962f4306f589268c0a008b7d86cbde3b0fde368e5555565966559395525bbeaa165d5b7189df5a77f16a4c26e5996cc558e87392bc3ac5b68699f910f87cb84dc5dad2bf3b72324a4da15f2f8756596f541715a9635bfaa2a2d334f4fc86642e49e9047e6af0add29f3778570853c75b31bb66ddb766ddbb6d56db3b66aa373935bdc7ceba12589515828a79c724a09a3124cacc0ee417624ac2884b0a3049a907ad47a208f9d99901f417c4ba9a1f65279d4244621843da7860a42bfb9e1a441023838314e4a679269c54208218410429f16662d66ede4ec09fd5a95fb5b1e71a2ac2aab56abaa2a286755559555ab5511e14c5ab9af555b4eab5955ab56abf20a7ea5616559b55e17d600cfbb989d93e60f0bd19cd13c2177ed866ddbd44429eba729ee13ce39a7432ef037b53cb21ea594525ed100cf23d275d67e73cf39bdf2ceb2e6acaa5a41f841b128494cbab88b5d183666f81ca574469c1c58777777d71046f85083b156021b67430821c4d9fe9002a6d40fd8e3eda43e1d5c08db2bae77c7d66cb14ce796dbdbe9e142a8a263621633995278f372204ffd4c77367794dbca9b6977c7dfdeacbdf6f7b34c639a96f9be7342c8536145afc82b433420a89431b32102a4e2a8f44e164435656648002000000043140000200c08868442c168381c1266557714800b7e8a4280661fc99328885118a48c31c6184200000000006064a6888300b99eb317ce9b79d38f19cad04833b1c8ff42131b0f32e2999964f16c2d046d4001a38a3cc705b6129d10be10723156099b1938d7682629f39bb180e7a4e2d2c460f8679ab9eb21c7e75aa9be2a3f29444e4abc12c4357b7388ca019d6f0536016a4a6b6a2df0c952d5a04727c83bca2fd4a46791d9583fc0bef459748f5aad60cbd08f630ecd1bf3e78deb71fdb9b88a488d7e56a2c31190e808912d857b89b2e5e7d88d13b607671d0055a047d0112ab65471546478f726fce304b44115771db376c2d161300de24a17c947635f8a08372eea69f7d63874235ba36f11928c8102e2d83a0b319f9605352a11ff330506663565ea2b0683e34b8480c03cc22410f2d752dffdc6a6e75f2e6f0acaa709710f641e7ac302d9b58d64e7809009f169525f499a0da11d9b2ebb1ed9804287635a3f1c7fd481be2d9f546e5f1eeed2beb031d6df1e17c534c4397884520f796cefa41de72489ac8634ded1b5de383636fb96fdb0e943039b398741ec865e9bab63873014c78a6c603fdca883ac74969aa6a9d9aa8ecc840eb18fc64f4cf1ca82469952bc2518cb80b12c5570c69b39e85843c18d4e585596eed365c90fe498579799d9993620c0be9121b5367b38a0d0c3cb5acd341f42a2ac1ce50681c68b60529cea113c53de7244aa31abf5f90f9768e2fee773a0046135783a1854059838adfb0205d481ef69461b784496b4b469c571a4a847451729075da4a38519b77ef07792f65f062481d79fcd0e6703ef3f37c09551b96d0539db6e832cb1a875d2e681078783515811b70ad77d8d1c89cf7c22937c662279d179915282dfd73d2a3b7cf2202943bbb2cb2d4b13f2c5c28ea5780ec033a514246f39863c5c889e1318a98d2dafadfde32a76da48dc84f0bcc13cb4493feb4847a22f2efba30b6cc1a396d9d191460f314011d98a13f76eeff5602776c6f393fe2e448e64b5a75daf31342dc435ad5cf831aedcc2d644f924464787187b896bf375023fc83fde3f1ac645db2f41ffbf09793fb3cfa13b42e9ab0613846b824c7fe87e11b8dc976e4e808d1f310cb5cc9e4bd099dc2dd6c06940dc3c1135fe64fd42cc3d414af1711f4c34796904ed35fbdcfa61bfc93bfea10bfce4db3894c6441230c26656b60c249f3234bae73084f2544aa2db933c51a9e337513258dfa1885f5b5bed36ffbbc3a1a7e7016dcbddc085219ad490efb794af754e34e9ad505975b89d5fac7fdd887ab1b4f8c858c755db5901678ca35840a0b4119e2298d90d5393773172fbb46fd5a961e0d688d0cec930db2eca6a999b6e071aff0beb04c9ee8c0c95f3c12e13583607e022c73030038396d0e61a889e38bd82727b4a2abf82ac1534fa47d426f855a50ec8e4e2f12a1be4f82ce814035c0d9b00139bb218e4da797e182b160f42a3f7fb8c20078fba474de297aace375ceb374e32a84ac996179336d731afd90a967f98c835f1e143de1950dd86014171af2ede66eca02362cc1ea2846a090c39b9403360a76b24283074e9a305f78815c42882e18fe63cd3603647af0bcc5c1e49ce8af8cf5e9cc29fb524a9fb6e77d5ad42601d58caeee6a8a032ce33af7fc2af9e3ff3aad83fbeec2a253ae6dd00c5a444f39b125891f9f81be0596e0ca29a5e9e95435912a4390fc43289bf5c651cc768ebcac84453f2e569ce56dca979aa0c914f794878f3a62793b09037c8f0658015a81bdbd83e4578e37efbf969f1f71b770750dbb8f8b92c23d1226c15ce474955c8a92c7717c31513180820ecd1ec0d0ab7877d414dea391fa0aa6571ddb028d2725bdbc5958877aa48b31983b30f7d51d3057e84db622004103688962f0acebc063ea55b806c152345e113a8fd096f542a52b1960f9c9f573a08aa1d73c2656778a9c46df9ef4924c5241a6f9575a5929fa0c09dce942cc689dd8712d33a3dcecd4a6294e70a0b718872d5d055c893ace9e74008cc0ed83dfb78020b32bec9ef40f9312bc424b0cd0772891755d5a5f789cfa31d18a39210624270c0857d85b2d561c35eced9e04186a19499dca5c2f7cee1b4ce2c1aa34269bb43f8872143c18010635beec9acb090f30051de30754d3f0e70bda9b70e090dbf10d02a1c7f87089890d07b41056c2e479760010c25e9d9e62725b9cbd0dce946b56b63a577e44c0c64f7206fdc814cea47594d266ab37e84946bf68585542299070162c63e4509677e0c98a657df302f302e024c32be17f36483ff47a3c53f933550398108b945cc74b75abaa3cbf72c5a99a5a29c1d57a49246667e07d462b05820099f7d848fa7df70dfb4ef5a8f4a5a3dfdeeb72041b424d620f94a2146e79f187527959348c3c09d41d7521253eb3ccdf8b1a7fd8197393eb51e5d3ac04c6f35a66a584b3a33edb06bb365e1d271761049e28a04105ba24588ee70c2501b55507d45dd9361ed1cd26738746092115dbc9e52783e22590543ef18ab2b15ba1038bb0da8329f99b7f505a6ca8c99f0774f1ed00ad4a120a05295abd4408bab8c22a04956d845c58de8fcb3e42d46657d10a96026dee86c581157c78ce6fe1af30ccc2c4209d449ca8ed025b0b2a8828a945d3b900da61609c544e00af4a0bc2fd827862831347c7983c0b6acb92d0a1a6badf0ed93b7fb35a9a54c916bac9767a5bb71088229472fef590d51dcf300154363d3e6f33a833838d8c0c5e05866571441ba315915654d5a51374998c18d2ded47066e692b6ec8aa9c6226f6b9effe8709b402ef81f9251552bc7f7d59498d17df6c8642fa5422ef28569e8909afc4484b1ee3c83149ffc643cf156f24e1662a998da5dbd83b63a15ff86e8dae5e0785f67c39c0daf205cbcbdab1ee3ad37ae23eb915083bcb36e4ab4add7f87fbd8b71946f600a6d4c15037a06bbf43c00b6813888eaf5af34d9372e6578394ba6a64ea6bef3f9acabd656a7ca6f238775e2895965412c414f7b75fc8790ab7a9f3ed5a2c8945523b866653396dcec6bced98392eedef3e3cd05bdec2b655577d1c431e6061be6cf25fa43591aed0a4db74db8fce72deeb19d48a7d12eaf49db8f5f983d23369a8fa23a3231fd638dc21f2d2fe3ec882b6a660085d3bf9810e5573212b061a03d0dd510882336cf1c57474cb50d0b29e912cf67edf09817affeba1cf1349cd885e5bebea78c52b8fabdb94173621213cd04802a45466a12d5c880f21365115fa914a46d68ecbe500aa537b818d82ba52567b1693ff9af1e5e152645a3131b42bbe5bb9eddba2dbcb67c62df50caa35210c1946c439ba983a79b2a947d5481b646ac4e25ffbdf552f94a9a67d78d9012e7c2489e89d861a81362ce9832a7315f1c17cc2154816d4c606d58538f178d0f528d3f70c47c9654b586895304d42c6d77a800d2e0734b0b9d184b89328d207056a4aa52828b35f72b626fe6e626331b166665148dcea3e85f6721e9206d083212db6773841ca4fb34a442cae70e4927d3053187a3761842005ece952c91b224f74399dc3895b2e7cc32079b63a73d256b987a4001df2606a269115481a06b8286947efe218a7940cf896e017c2c8eca100f805dbe6afb6962205fbc03ed798c61f8a42f0d423bf2145f8c70f32b3bae9e46735e195a4327cfd05712b6221138d9cf86a76bae042b4a5960e389bede0d80d5341f6c129fc9318b13308a012c77fc6ad0f0d95853e0a77b262c970e43631ba11465658b176e0e6450d70a08754bbd8b4c17396aa1f0d25ec1fa5d591a37d72fd9eca151a8d4b8801c78ac45912942d8c9e5a4b46f030f055fde15f343d7d1e6fe103e639254b342ecba69e5048ab0d605b88f7d32df24ef3869de4cb0268a0e4fc9b544e651846934d8703235f9d604e4cdfd15e6b4552e15f44265cf4229449ca9430523fd125da087ebbacfce07959863acb9a9f946c4f5b91106167cb1f4aed74661a4d46c48d5da407058b6b02e64568fe1cc45433f51a7a74615a83ca4ff58e4f070796cb4ce4c553b88a59205c1517d1c72e607e47e09a4d009ad335a5bb846d843e41ea5c4f0cb9f1c36de3dad3c67b9fc335a37e9a711222997e0d20c6e13b19f04a08718b8bb8c77da05e25088d777661c588beebaa10ebbf6e49807b008215a6aee5031f8613a160f99f6310140c9b29794b6b8ce91b8d4cff4ade7a970193267470b55853777f6fdd953d74ecff7d8a001f26bca7761041c83f35ce36697f865811ac6b5aca776b035307a75432d9a3b72a17fafe854d44aba7fd5243203faea55ad071e492b27403a554d725bcf3aaa2905dcb9d1bef3cf64685d80fce310de97b92be5bc2c3d55a51d4973fd60e5e9c3600f6cae970c2f58830511fd5ceb40ba50a0e270286e6067a65d21e7638e193afe5b3a99b59f42a9546245ae2dc99773b291b7d85fc537bdc3ccb8c9ce9825ad4f8a18c2eccf386f476d9702e623ba28083251ef712fa083ed3598b4c90182d71612d14465182f8b0fd49048a27a5e091747e47682cd8e6197fe0366e25378ff345d531e34ea3b761aa39b545cab93d7d040c2a1e254e1d9e3a68906140dc237eca1aeba020c6ab7ead9295ba8509164571b5ffb10c1fb6e3aa333140f870f647125b07c5d17a18e801c8aa3d6044ebe3718f2c41daed1568968ca540a3d78733678246244a2b841949669e0d2751322adda0e6a0ab14785bbccd4151e89dc61111695fbd254b1d5a33b146c9742f811e2e30ae5e63b370ac12a2f51aea517b17c23adfd0b20c0bf6911b6dfc23b3709d2f3a59c59f1b6dbf40920d05432013844032d413c07543425033e30ee4551583b62f611913e2e1de56c4cf1f6ed9f5aef7bfe7bbdfff3d3b25de134d3e1bf7e79df8433831ca605975b997e295c38692004043d0c0fda08e9269abd52aad7ae03256eb66053fee125cfabb04131bc56aa00ebe350d23629807ab4e9e93e5afcb42fcb72f5c0c545e2935ef17d650ddca3b1719cc9118fcfd62dfac7664cdfb0dfcf43403b69de86320102014c4fb0391134d6463c8045df4c8f118411a308a2fb4fcb97190a35d6a83c199195ee22dfa342ba317817db3e4c6595828065c4c700e9e3d37fcfc888d7ad85a30108e776347a70386a9281160f82c1faaecabd40d6c02a81b2345c122dc7644cadbc3cf8a23114216312da2e0a3a3274f0d942a73e553cef868a0dab8a4cb1795d54ad5aeea151b603f65af270c2ce2dfba6725056b667f2e2745661415e6a5a26b69037f9527bf9e5da708e688c5be8a6cece7e94ae555095ea2dad49c0f30628ff1c6edc840b1c5a4b3f857b8a573e35de19717efc83796a945825b099d376eac2cb9dcf76a4c687396ad4fe18d260db60a976ab88ef6080b33941433723fb3d94971571a61804115efae603ae575b619e005e72f04722f589b30c64777dcf4d79763fe9c06500464a26aedefd2075f0c007e64fd8b3200c634b369cd22a3dc916e7f2ee4791474a33106c0c8fca1b4d70fa81e42ff989e520362f7b0ea08bc9a0ac1f420e0ed93f06b2a99efaee2893e45452fdb27d1c8df09ae6daf40936a894bd4880d933b9648ddc14084b5a4b3c3845c1b9381b831329ef1445e1b13bf46df20888263197b88666f2c0443e08aa31ef3289e3764efa6ffd91ccfb9abb5e4ceac0a71ff0637368a71e6d315c7260f435dead76b200ee3db34d02c05a8c01a231d4833b4800748787a364938383374a19c602ebffe0e4c8d497e682708440d0c114aa444f93c83e03b2a3ddb3d387319482fc62a35bb93242726aea90882c53aebf01fe8191d93280eb6ca556aa07b20e088b78a880c24bafede68da0b3f9da7e5e91b32f19b32d839d2036f1373512b90e7d20384f1300c8d23835382d70ab7a1b49b048f96c62fce14e5caba34df71d8591580454c4931acc9e1019b6f512848ba03fac040fa15eb0fb372369828e71b5e5763dc6921b32904060ae63f7c2032d783465e2c1ce4d013c10d5c4ca996033c374527560dc0981bf81a2688abda9421d62e30c371a99871544cd46fbb822c2c444b5f10a8096e92f74d12bc56c28eec9fa581c4e97062e0de451bd807edfd68f5b234f880a90b46841b08fc2cc4924204e8eeb1015df476961d99cc607b1cb1271f2c55f1c3d22208306cf99f3bbbdf8c29cf04e3c57cb047346c9273645e07e726be99d0f7206bca2a0ba926f227573628e295b2dbb725d939932429412b5d9868c73579eb1f24e3da71b8a47baa6cff968723b0c330ec95019cf7c1268c658d2975af238653650ca84f80dc5c86969ce1fce802c5f84e63158ce087ac4053b31d11374fccdbcfc6b0a4693293693908683faf26ee7f000ba79551fdcb208adb2be718f16ea802b1845462cadc7be00c8905a4cbdf8b07f2a8b900e0b9807660e760b25fbaf890b772cca97150b3b518616ccb0d02361d86341226fc53a51787348aa1d75771a7de437cca05c38f75608b73c71f1112d81e90b457a3b61544d7a928310091871ba15ce31815084dd0e590bd1d192b1a29bc187623768576eac95178635e9ebe757c92518a368fe143d9bb6920278dc3360568a352359977ccd59112072c3a91857464c4952a885f30ad5cae12a4100173cb1600b552a63dc0883f5422e26cd4ac6bd044d1e63b1ca9c6d1471c60bc40040771e74fb11a4b23f2d4988069c9bd276e7773b437f4f69fdeefae14a5a9924e28a063d97b42fd843e81ae8c34557a988ec6a210719cf8ffdb5a9f9e918d6694e64fccdb915fcf98b62af8b40b79c6cbc2bdaaa6e4fb1c8a957c0efc09c61ba19093b07a1516a96e858fba65a05e7cf16a70f117cb6487704a865c6bf6edd606cb5eb6344be7f72a2ccfe9fae24ec93b1b3e5810146af75e0653b343b2a8897fd398041c9eb9f2f537a96e27446ce9efe98e1bd72439299cfc46d5da6bd520aecb4bbae01212b0c7672a600ea6295f4db58a5b9c363d3ff7349a0317f5986a70e9bc52f0edfadc2a0f61c0596d3c50413f50f56c4e4c51849ef403496a1f22c474d0812a73b586921840095c093351bfd29d4bdaaa840c94052670729b7b40064a28609ce26f3362c4b603d6360be79ec1b67847b69510db70378f9230d845b106f5550753ec23b87c8591766494d8fb0552a5e4a437bc62cea06ad937d72aed82a790a9d03a589ced49829fa30dab9a35e96e6ad6fa1e9f8f9f021fc7ccb921ea6ee43700092038f24a1e337dba370d90b869ff2ae9d307f92d1fb7be35ba88efb60f0bc7b32986fae188ae5c990c747092ac447850645950ff40acf7b93f4210d0090f33b9e946821a1d5c3fa50f20d2e443d8933ba42b6be7d9b8a6d3858467c05e47570f207ffe1546bb581f7fb3e790d838adca144639bbed26a8e629ba878ced081b9aca610b25a2f001626ebc0eef8823620ef356405cb6ef2dda04dcbb9968dfde6a8d82d50ae1b6d153c28bd3d4580ee532e802c3ff26f42013bad61da5c54ab3ba5a6d42ca5e482813c52473c6913d35f3e376ec87015947394d749c4b9c952ec50a00d13668b62656a7cf703b2a5ed0e628dc196e80e35b317e8d1b07edf7cc1f17f6403319c6115b3a28e01c6757dd4509495c6d60b61d83fe3e921ba351caf987b34bbdc5eddadc457f8dc06de9f2a19f8971bb7517f2459166947dcc8d516e5897956f5bb0b02d13686d46bc44459cd770a20d7e7c120ef074212e6a1b6d41d62af94aeb428f4f4659960c88ecabe4ce91cc9744b8caa596e6808e89c9264577dedc235dfc2e66b8ded6c14aac8e166e0a37ecfd4b9b83b12a52256a4322b04359070c7b87ec62bbf0153ae810ff32777f3e6fc552af48fe6da06b8ab2ec8370322dcd5bfced48497122a8462e0d97c7d401267cc8fa43df07e3c35bd7d7db9afe734bae24029ee0f27a69cc7dd5b41dd0904c73dd33898f49ce93ce0985b73cc1db77e66f112ac2db6c3cca9b49dbeb188fbf2c66ce01665839d984c87793e28c1199f2ce136b82f3af6e4de777e1e3600ee06ef1b56497220ecd0edf2ee279fc5bf24ec9dc835c4d55adbac878ad7485e442dc44776bb797ad79ff97aa0b763a72cd57f766af9ff69ebff227ef453661417b9d33c53f39f7265c8db667a99ce3c5bfb46e3df1fc0bf70b88cf2fdb59950ecd9eb1b7d0043be8a7d956d175e6116aed345f9ed2ca638f9d27bf2558aa7d8a7b840ad65f87d4d5c0481553dc9f81ba16ed72fbd7d053a7b5897a6f46d1f94e27a675be71ebd5635f1962c2a6027a97c44fc68488a1c14dc378bd1cc3d1b43757f4ae40b2c9bb5853f0a0efacb75b13c8aa0400672655c46f05012db3faeebfd2e088db1b738af8d0bf1fffeb628fc38a694b0fcb91cc544b7c32a4f60e024dc5540bbfb81024ef48f48392ad571e17da4eb69201c47cf5c37b87df77f9865eabdcb2d44c70049b4faf25d220b5eb80ec617041750e855f4e6687628bcfbb9e2d741d68b61ec99b0101206dbaac3821073092c0e1e00ddc3457048335214471d16b07da708ccd965efd74ae15c5135d172c4d36f9b1be0c47b9698abfe904614cf3a451c92d1ae2b0d5a405c8a86f2ffc54b82689b2b0bc7f06df474055da040295a87235304419a86fc42f93c77d8fa26f1913df8d8885a5ccda66f2a322958d80fea2a472f6a333c8ab66761b5e7d776527224c0185361e0ff97d92a8c89641190a0d6e2bf100e1d733154fefc33f8e0ceb84d06c8d5388c831a512508c03593a29fc360c5332222cb47d3f76395a54c96585b46014d66816d6302c31f03888f08e6fef60e99c347083d686c53e66014b2d7f3aa6a40faa7066cb0941e9fb0fc1e45105d6661cff1df877487dd0405b62e07650c704de170a2c4350780848148270b78d4ee5dbaccfb8a3239655fc7b1f97c5e4d79314af7156063ed6abd8eb567db3d7bc64e0efecb94ee6bd6a8da21c8824d6a8199b6c3d3043b27e8322ccf665126cf77e56be0f99b3e618cc69211fe20144a515b5f5aa9f992b7ffb08b36fd95e7aa3948024d7d424042529062b4fa592370b355b3a743591f9916b06aab3c03760093de1c6d4aa12e17cbded4f4ad9969d1eac0f06d09fb04e4c3868323b3d3b247a144d795a936f5a9fd5ef8e0cdce71d4b68891fe4ae046f192f3a241aaaf4ac6a8c16624679701a439ccd1c58a24fb31045d3f84914bc5aed122851dc2ec9874e6d3c0f0ce4a1a4bc05a9b532161dffb13fe440406735406507259db663d2d1fbed42a564a445eacf62a7cbebe791c0723e718177c0eba5d032e1e7a681ef1293f6f9f9f9fb9e74bbbc24eb88a70576d1a05913d5606564a3214d94198050946bb09dfb8657a872c2274d67b2b9446c74a6e9932d4f91a1ae45108d83d450ee37037e0413f360a6660bfb34fbc11f74b4cb2c08007cb5f64975889cdd83df3af1c046ca98eeee5a6d61757272902b513c50c2660b4522956a22c7ca859b1f2f19563ebcca604d34ca5a279fe6fb14338d2cebaa445b95c36a16132f750a5b38c7119fa504d877dc61f228076e56deb965cd3c1e0a119211cd4046c72f6467375d0697a549ca60617b29d60f5f5492e6d24b1dfc7659ac44e24f69f49758507994ee1cd5c3203c2ef441026c3e04a4e54c4bd04c8b18c8f294d41142f20a1372e27e07c48897ec7b87c69ad28608c46eab274141075611c9d38140c4c60f4567a4a086028eb46c3780ae886344e649a076edea083c1ea3f66a7a9bdb8e21aaeba4947bd3cbc2dde0764b28a744d622873cda3f88b65a454288633935a1addb590eda51d04548d0cfe976f2a8bab00c66f16775034b13ed9e9aa509a3ab4524c5fb58b305782cd345a4eaebd31076fb6fdace4916229def1c7cb8029da8eb939d63f4fad2000152b351edf71249f0b2d17eaa263f137a89ad82c5a94a9a388441bbf20f4f2a40694d54b500853cfb16d1982e2c94ba1e7b2e1c0365cf71c696b4d6c848b5e3240fb7a071f52a9ed934c56d2479fe0abd077eacd60bd4dbf16d451b6842411c9fdd3374184ea5215e4ad16c20da9cff2a005f3036617eeb33b50718bbccb46648ba5e2f6a16914d6f9ad2867f612b81d50cb9e5d63acc04891900a0e311ca91a9ea5d606838622777f96688a41a97c7fd095d36030ea05c5840a13ac48c9a6d45dcea7a1af0349f8981ac4b6e17c616e70d19f8a5e73454c56f498c8f2a29552c826c0066228a5008ad43bcf2395da2980ab23dcd8b49732ffbc7773004e1466c8b189040c3e7f24bcdf8ab8452df50699f1457bd4988ce941aa1e09d2cc8d30c99d8cf6ac6554f2a53f00842131021c14ba6ad314ddd5c912f12d7173401e16f04c0580875b3e2f45851d03f7296ca22ac7a4aefe6e919b5ae5c49f7c0d394b66b17f73ef2ca732b269e4c17324fad68ce4e6d4cf5339f92c9ec33a61afc76a573073b9c661845a32b661e746474c17fa574f194da3a76733f944acb529b7d0255ca7ae62d01b9b7405cf08e6d87f48277b60830e4fc70f893a247a080211ebe3f12e8e3465f4970f8a25adfd4531368b847d81a59200693ab4bf6bba2157ea81f2fa4a4aa8b672282035ff49e7511867a59b150da0cdd51e9ff4f52d4efbfd24b85086ef4994d6f0a495c1493bf36e8bc3a1a818f0cfdee61b623c248884acbfdf6c4500c074121a98e1682b0f7a1b366a72e5ba45101bbe0175e32e8b134bc5ed847435a7d06ce14023d7dcd0bbf2cb716b88404a286476b8419e888ee6beb0df853519b89ca7ff6c0366936caf064b1c5f1b2f8c09457d92ae1a8146142001bc60dfc05023f9127aba0f7a2b8dfe5e64ee53f29c31e3893a12ada442423e190911514cd040f2493563837a0aba541012651739564d2cc57b86a75661aac4a202eda38991f8e126cf74099a4222ed67d22b3e8a06baaac3b294d91379deb6fb5ec77c179b72631cd62460902ac8f34eaff4c40c199c0f6e75e68638724bded50f8aecd1183f4ff6d92455a4009857d2b41778faea65b53a570489eecf07d94b68013c3b296a59ccc39d12e420e02668a4873157e32de3645bfcd77663916e80bb8c92e8751f4a03a071f14efa11c01e42332838c8bd8d3c3aa7f10fa705f2ed537867f7101c6f82257a0b7552da28b4473ce54408706adc18fbbf7049ca5b4b511f4d1bd43438c1d6abb963db66cc378caad73431b1e2de595eda73bcaf5e2ff872fa6313c2bf673621b85ea366e315ca38520d318445b05b7c4585f40dd4beda6ff7847d50b6cc0b575d391bf8f083c291d288568bbccc0da89a001d5038900a4ca35f3978b4dfd4e064cc0945b2532c3e799ce52e36b46ee4cbd6f36b1a1a6da315d56a3b8948e87b6340333117ba62e80db55389517e5eff846210f3b77159c687b3f68bceb817181695fd23fe7470d719566c0c62e5cd69141c97c4f538d56420bda604900f48525179c7d4cd514206515d5722697c14c80674af95f37f6acffa2317ac376533e787db1009c49bb48f6acee3ac2370b2780630aa56862cec984b12d12abff05637521266f7da6ff97781e1c869f7298e320c31c30b296c064aeb5356b6d7d5ffec855bf7eea41e4bf1936b5de845e2975dd16a0dbfd44d16e8354ec76341f35ed6d7f795e4739b9eb7c8a8864d390286deedb7ebf8f97fa790713599f9890a2034044a77dbed0aa84b375589e644650632983e7a4e5d035c56ff29f2ce79181ef32bb67c888c23d85c9c360328cf5126c309aaa97f041f04bdd4c3be3efce04eba510afd55f7e9c2293300cbcf32d1d082dfbb7953b114517b3d2d16fb6f3a4b31295a96fef3606c1468a376fe36ec12cd93771112feb1a81588e040faced0ce8f08f3b3931211b40556d5e4b279831a0c0db6d3f612cb82e252c0487c6a115aa42983a06b41c2e8d05c44b5943163e80b2cfe5e70fbba3aa8633cdf268bc435cc422be60673819c46d75897712e1bf83ae2fe7c282eabc82e3a3588ff984eb3ee7afd448e789758a6f6776c4a27eb335c529d164741b4cd6a2a4c669fb64b7be6a7b83684be167ce376914fbeccbcc322577810241b0aae424b64580d86e1632be5d05d3a6b7ddecf61649b06b3ca4e44b0126fd6d1b87882acc47b88a7f95748efa7480c80c0a2f11a03d19d5e34b9d4aa29e482164df30021f1e272f7972b44aadaf7b9297af02f96a4eaf303a743829c675c4b71d777f6f0f4632914e31edef7a3226fc32af38816dd7e971f5c4a32170517f4941d766176a1014161807efc3a8a23e5e42a1d6eb8b1714835eed4de404eeca1349e3f077e09da66f80edfa9d8b82b15acc897ca200ec1d68948387bfbdc01e44b4e13a768dbb7e3102b7aaf6369f5f280a2d45e14bc35638d994c44c7c71b0006ab9097a1db7ce419150debfe9798ba93364c2dcfb0f909f71855f232360e6be38bc597790cda887e00278f5792fb53cc61773040782e728d0be49021ff68ba4b69f574b9d7d4c6184564d08850dc2788a90d14755538412278b9fc8b340a11ca64ab3edb14d95701c206ae1ee36d5d621e744d4394a99eb0002bc498d67e81faed6dc91c69f8f5089a68c8b01551edd80acf0437a7e2b6936387179b38e1fcc1d4ea94515abe0d3fded7b171ba5a72fea1fe1a1201947383f525cd41639ef787c5bcd22bff0982949d6ea7c152a990b94ba60c4fa0ea054102d1ebcae1d0da2af52b94424e229e2a69ccef43a11ce71ce7f8b19e05eeb1e03438afff407d122c93d430d8d15a5dc3c8d269fe104ffa09d0c7d6a1640ffd7aadcba9e5897d966f91efd580ee2a3757ea53955a5509b3d65bae22210e0c0bf9520f11295a53a4f573197218f5cb167b5cbc71b8ea2a3c3e3103dea21c81f6c0237150b7b75db481321fa39c116886ef957f7b328ae5f74bbddca7b6f5344fd09b1db1c69f820d503f49e6a7cb8810ea6ad87ff290511670a4738b6a0203b9eecdb116d4d80646f747c8d97ba311c0764581fdf98ac28c76210d4593d81b3d23be4a37ddbddee67e5470bacff2761551f00ef5d47aca184cbcecf6296137e0e37df8b38bb9187a6345336572a1cc34096771ae6a8698a68e5d18ae3d965cb178f347f606939b260e2acede0644bbee10189ef89abe5b0d7fca0d4020ee4dc8338d09b4d6e17ed2aa611683e6f5420f1da711cc5f5c9c86423e28253eda9832dd8db6233bd6e4e7c468f6cd7c1c03f8d53889e816f44629373553a1cdab5fdc48851c0d0b5c778784fa7e5c85a3e7e72d91815f6ae51423bb985ba596b1dd28ea32d9a9d344300bf54e75bd76bcc1d3762b57bd9ea6b90afc445764abd8fa4f3adeac6a892ccc91b7ae8b56ef599b0df8bb4e384470be7ca10f866194b55b90d12451406af1d447b14c8762f36b13e5ed937500a9463462e16ee2be628df16d1ff7855a8274010fc8e577c65a7e8cd6f2b66a4a2c848b5b6ef99ca7967ad81ebbb46ac16fffb7b235b008b1f89e20e396955e050c60086021833c3fce2d4e36b95a4d8faa574d76c6fd147a1e04702d3da269938fbc92185de559ee53dd0db0fb96eac950f01b39454317cf454fbc75ebd1d7190f5bdb394bf997386fe177aabb6f60b4d9a5b99d464f8c8b10fadd7fd029483e1562dd22da7874694d392103f92dd7ddbd4d89e804e6133495d48b0a240c97b9978362fcdb18ceeb8f39c64d4bfe4c58e6f7c7b69d73ca406102966e160743cd8be15649d6408e4aef42162eac6fffc0de44425cf5debe7de5534a3154e50e3a6a789d965242217c8b464480a4ac41050e96404913441f9b13611192773423fafdbaf6885252aa3b019bf35f325d3a5ee30295fa524e52ceb100b5df4bdc087e6ee439b2b2186581e0c7049abbd701e89fe00bda5c7c2795d30026b24a464b5e654bdb507e9c9c482a6654e759c998c8206b71f0a9627f59b0344f532792b55cb50f4f796c2b345b33940be328a27e1bccd1298d3ea569848652542a314acd926cc951e4229d1ddc4b2f728c58248f6258b153986ab68417fb008fd6d3a58e3a8d47249d5b055cac118afd30adba1a9e04107d04b5534c5cb77565ae04958ad52a709af8af0cff5ee8b715ce97c08f821627b17537d6008684f31de2a6c09c05655ed87d315a36394669f10dfb07d09f1008fd87721af0aaec924d82c8d246d20ef3f158aea12687d5c5f4d6cc1e4ecfab57b42e610cf870a9433781468f94fe50171b35da3fa1cf93e5a3ab3e8faebddfb1d566becaa841e0980581981fa32c9f8e6db4dd169d66052cb9d4925373727953a7fb8f19b14d0bbe703c93588e3ff35054398b27302b087d03fae6d92bcd29596840ce942a8edab1fcf4be58f3e3db8b52d91b243a8620390ae971908242bf7fbd5360faeb19c70baca3e96f3a8497acc08cf6df4992888edc6c67244a065169c118df4dcc6be1d44068c39e26693fb64f8df61f56c6c079e551f4ba93fe60842be5f61e015a21e43884f6caee37f962d3540c8d0bba43112d012f6d567f98d9fccdf602d123a249270ce2f59eae36b2a1f6bfcfbca9d9f7f44b13f70612366125fd13472b1a63708cd7477e3eea693d7e4eab06f3b971e2e519b2220189c406680668f9e4be10558ff819b58bc65fdc7587de86440f1623c3bc5baee3efed42207283b67a2e2f0f4f705de34ffdcff4fc5903d9aa358c3af4ded11743fbe071db7bd98bb9ce40f9d18300be2af0bc2341437e4b240728bfc42d66fea9e9ca77024c2bb671dd142047885293192ff78f48fa582763f3428cab6d6fe9770e90833b1480c914f88d0d77ed73aa3cabd85e101a9d2e8f109ef134893b4c840c15c06298c97d590831b28be4cf20710f89d3bbb012ac1459616d50b2b4c221b7f363283ddaecc9690e66a419c52fd5e84c228681300844ba7925655bf98d010006feb986361864ac1cbedc63a4139ad3a031f8181a0981e6a182dc7ab6cff79496b8aa4aaecb2b209f2ade21197413dbe7c7fb9a5eff83807657af64416300935704677b44408a6415d523fd027dcdee8a19bf969c0cebb8a776348c7bb627022a84d873bda054c5a23c1ecf3224ab2719fbb9740e6fda9626cf229d4ee323809d66c30e1fc9a3bb683c0494ef7f95fb2b060258a7218056d589be600bd8fe28a151581751915c782674e6ffb623294023b30bfe1d5f9ed3ea15c0d94fe2527148a4b1fc5458522480363b82d0aa9334a239eaebffa5eee83c0175c09fadf69180ebbda91cfb6d3c67effd3a7db74d6f53fac42699e8ed4024b1e85e3ec528ce53c772d9e483b249c64757696a3a389ab7562028a671ec60ec8329305ec4a2456d9eed294f0146aece6a59b79713c3db73ea49bcf0722ff33eb034147ffc5a175387e5032a4451d9947ed8652fc01f44e7f967de58c7c94f525712e92286d57397a9b19f63419089c836b68ae9e0004c2eda55dd4c82c4859d3ece3e6ade01a78b614ac3fa4ce12fefb52a0f552221b57a08184f021f71456ce7cb3371d6d94cb69e04f2ade483c7091360807caeff8e204a482e4181d2011410c78ebbeff126703844f5ad32e4aeca8b4eb4e3f305b8106bda8bc873773b81e7941168834604a42571596ea245852fab2bb293819247f52353bd9ab2450510f710eb540cfee3b50952eac8f0ccd3ded4089d4e2603691e8658832932946beb7c4a02d4db161cb8752858a2ef236c78f807a5cebc38b05435b6b3c5616304469a9c9fd245612bdd066308232e09a94485708497472ef2498e0e875d6707a68e35ab7f4a22633cd4b8f69f1128ffdca5c0624375e6e8003c0191e48d08f0cb659b0d08f7ab0950aa1e20c897c561a85630a3e2b18f8d37bb1f2a756ff8c927198d2d24584099fbbdaabfaac20274306087bc629269af20666dd7f3524c1bdfb8a1e49541d1df30b53459ce64e6cff92050837fd4fd93cab47c80e3b431b941267eb4cec6720534528d3628a6360f53144610fc4aed0fe1f931a7ecc9a39c2cb7ca603651d14c1c2aca9bf0c61069486d708ae2882f931f39ce619a5e70cc87e6368cf38ed97131c1145c8492ddef5676bd56a0cf659716638c7e7e8df1f1ea5047a45f8e5bb1b6045085504f13f518d410c7892e1a36909c9034fbaf63db1e0896337418c11c686d71d142bf4b445ceea2daaa91fc95fa69610f6a1950f02ac5db4582b9e472fc78f5eb896880b4a74e762342b0145927d6b5f9a6e43c6683226958b02e0fbbec4f0f3c96353da961fcfd1c39f9c368c2b0cc4797cca794037f9bc06da7db7bac34d203a9c06788649db16d1bff2077ecc6220bca84de9b2c183159f0ee2b5280ba525bfff3df986157965284d1890b3287ddbc664736a5ca7eb25e2afee50a940fb7e3a882586f6677914fa48ed865154753c7c524d63b785d374d4f53bac436b9c1760f55723be6d3f9d46604cdf32bf76160427b338587d8c0f46e06d367530f2ab4bf0b2e69b446f177bc75da7185d47f5dcf6ddee7350275e65fe0d8470bc5623a3ad6a0d0902bc21b06dd8e2a3abf905cd410de32925bc716a3d86267c4c04115a21a0d20dbaa7d3e96df04d8c7598f0e8fa15d2b742657e1b6fcd4fe14d2fc39f9aa6219ded46e4d3fd876e02e4aa7e41f148cb7181b6168123b44401b1188c7ebe7271d44ecf7c42c8b6eb529970e9557c202b4a553411367ddc656f85a06cb8214a4b20f7e934128af6dba4fcb8c23dd2a5bb15385262aee30602d13390e5f7af58d0bdb01366b3675cdde503164b9a75975b1d96addf1bf02bf2be712c259b7f3c498e77cf011663fe9e65bc98eed0a458490d2e621fe1cd87008a190b09c2f50e68e5167de078331734608aa5a3efe994d0b832370f99bf3e3a67a894707f98a2faec0dd8cd48a24d98f059a23774f793bd33bb9f79972a0059bb340a6489185a0db6c74e76dfc0e08e0621e56143b0e0f1a6c2298c1d76a3114510528f2e08d901b68d07772067170a05718fde10d2476743bc06d8e34a317ab2f4bfa927a1507e1ea18ac89de1e33d2c3f6da054d2c3ffe0291dda8851f1019d864128ced7bada9239d9f0afcd9b753e2c442eca4bd223bdcc490b42dee88b6f63edf4c94a4505bf8da54c080402746b217832c831e3d587e0256be3a82a3a9c2906f22298e1e395d5cb4131c5ba91657135918464e1e18386f3cac20591d5f9b8d1f0e89904fd163f3fcb631a1cd77bc082e6599a3f2a4f4c8e26954c7600a3c504fc05f7d167290b1774faaf86c05394b553805b7c4d70865c09230a43aafecfb1272fd4284419521b5319b03a598629a005e26c8fae3a9eeea510c3d761b0f53cfe1b4061d42431f48c474b70475b4abff4b99820163596fb38a4d8af197ba6832b606c1c939608cf1db118e3cea5670e4d1e0fb2471cdae58a626f4038a684686c68ae64a9f2bd74759f0f6f91ae0add030864421f0afc8def56f58f3131ebb02e99bd18327ceb0c3e7ca22c08296a5318ba31a0868a3e80bd4ef9ef8f5a63f2951efc71bce656b1f891b766f0adf619698aff31d5d11f02ce4e93022296c7abba33da3e83aecd24d791d24642ce0f88fb6e8c8286ffb887d22452b4fc262d5a6e915c72cd94c424cc98771194ba74587d8984f42dd0f5d2cc1a7e4b32d7ab0893de63ba3a20e54b266352b800dc2de80fbdf33598a68cb54ab9f38722c78ae0b425ea6ff031fd51e7fd0b27dab233ebe41e1b892f606ceabe49ba1cbc6edc9d2fb98f7b57e78297d3d6e086af4466bedacb4ca09776a12ec2b6949265a49bd4b6ddce37d9bb20aaf44b7e1284f9c4f5276ff8aacb3453fc2d2ba51c9a8e0c50e4fdc278ea5d839140e527de30726e8089e3c0c5c9f7d4b3887ecc5618b53da00b078a5e2bcb0c50884356eeb5594a1c595c8f74fcce6632446fab8dbd306c6d2aa59f99a01a35126919bcae6cd7a825a2cda0b3c2e542f41155747998f13e54c38f75d9e281205c4796e2ed31a08154c99653bafaf9d7502c69dbd0d3c3a740f3ddcd3b3e5f2786ce0c42f10d8e951c2d6e255c02157a94093cf4c4619b6651c44f3046cd0a2bd31ce0bd40f8cb2151dab3e13ff7acf1d2c3b82198abfbb861422461d3066cafbfe77cc489a52d3981f62a5c766ff6c2e29f3349c48c1c0ce748e2255e85d70c4161cad2c8acd3528889158ca05248b5e30d933badb774cc585c0a187a4b5424c9b15a322e0c5a6320ddd445eab8881fc7e34a7d751bf20a0a4f8fa6c05b55ac0e7eba2cfea298f5b3939383c24ead1a2c83bb5346958a5fce57c0e299b4fa4fa5601c06b96cba86185dd0bc115e215c7c7c9fc1d78d242f5cba099283619e7cf8aff8ee5f82ddcbbca6d33b869528fa4e3e598ca5d14b6251ae4ee0dfdab080d825abd6d08b91c28cc34cad010a3e6867c87c0cd14d00f2546d75e027765f88ac9e3dbde2858920ec6c6575ea103006f19955c3ac3cb5a8d41d33b8475bf17f05853d1b8c09a1b25784a66307fe7289388ab84bc438a46262f1aece39e3ca57bb1b2abf550d063334a1546812ea9d6c8a205e0e45b6ed2f6e115819a419c9578b1f2d1afe888c4b79b666937ec56d2b3144bd26adf100e41172bdaa1eedb2df12ad8006a66659574c006c344702e24b54fe09a3fd7d2a8a87ee3c55161467c80e26554455d2a0f0e4a4910c4bdecca2485707658734a6fd64483de1a901caa2984be1d108d66a9b5d04f6c2326b6cf8511ffd7a049959e3383604068a3e375f950850e356f5d2573e5f77a4ba2c04d04ea1b20eda36b88ea044f3706abbd37840b5f3787ef14094179129b54c283393fac80db3fd317a2b8f553f6459a7419d8b158589f04c5c70260255a1425be6a2de5dacd88961fd5ce8f49f278627b4831eeb3a6d735688b7a34124f935e03c60714db3ae3fcfdad8c8dc6ba4ac3cb206fbb7c4cd9310bfc0786f1b5e815b5360c49ee7e8d26f933823f05675343d7b9d53e90602b2aac9034a94c55c2e3210a6a9b6344e6d2ee78dc77e31fe38ce639f862654488cf0bb548eb32fc4be9631583c6440edc3327843cd80c96d27cca7cce4094cb60e3a701f845b02e9c91fd189dd9ea29c9e1e832d15084b59fb9bb9b213a02b70cd81c4328748b9a8893cd0bb1f845845ee25b9c1854f0166512cad266bf874687e298b8f42785c2ea1014d25e3b6565a9116941be22b8cf919327970bd956cdcd3dfd226c80e573079116ca1b223adca1264ab3962ddb96d0693942c0f33dedb2c9a662b9e3d0577c2f5b220892cf439be7c91b9fc89c270bd4f781bda9c1b97a8d5e650afa681abd0bbbd8c4c49641c0912a1a558a51243ff8a13fd7a1e7d0090ecca7eca19726b082de1cbf65a747b14a77889e1e998d769fa068f6341dfc433f85a41a086898f67007a9579ba3c29b5a899892221078faae6fcea923cf067a7d4484c1e2a412fd7ca898cb1eac519c3e00cbd8721b4ebb99dee40857a36c4db9ca470f830d13b5893788356ad0da70be61b0cee21197c6e74555fb5dfda90320a4284ab13daf28b1517552f50773421aaea469b2233b54bb2e7a78f526cfcc56c4d6040394b9ff8fdd1640d3b2bdfa797e66c22d2b29a155a2c25037ca0961dde875ee5f547602c66c609e8f6e53138cf986d80c78d0a5e8117ac743617797dd99970920daf81ab550f6e0a4f1caa0fbe1ac3f52733169a8c3a4bb8d684958a8c5029be4e821443a8f4145a04993ac4e20948642a2f35b6bd54d477f704a8ff3c7417b142b2b2e8591a6c0cec5c2de996ccb2c042d81e137e5b8c945e4cc536e678b11cd5c32be80e86d2f1ef04c897dca657ab54e4e4defdc425742c0dfef9383cb34c07b4ee36c5bdbeea8b84b0d25f58a3593b61d9a80eac846d89e50d9518ceec09ebfe11ac102547149125790c512d72ad759a36de382e7843f62758ea980317358daccb191184678632b5b5f1bac28e31ba1ac35605bdecbd9940ef1c7f252e73736057c43dc3cf543f284a4252f5fec770561443c5da8fe24e2481dca7fd0d38770cdc8299ea63a3066033626d8ad96b5393541a5b873aab6b5d53f8e911d02469ffa36e8c19df658716d0bf2500f3513811b7613eeb49488d02bb490858e2e017b17c4156be46083bb2b4e77d57cd1a716d0c249cc14ee368cc830c5698020ba66d958a59d0c1ace285f2072852158d12a856e9f31df085ba114c9a721e81447a0e2b93744e94117352b29283f8b541a1bd92f38221b339b3cefe0855819315b104d4cce7cc5881ba176991c26f5b3fb845416b30e7a3b2bdc139da18904c0161c42ee339cddaed9e88933bbf4c101925da4cad0ff333ee312e0decd57242d5f2e6655aa4b6afbe36b2ac9914e7bec2dbe0f8cc107113b5576f3c8a4ff7431110e59b26352e81c378118fbd9f70c1da569b62c64c8c1fe47da2deb45d10192a234d5089fc44406ad98596d915e87864573f2ff3f8484888c8fc5bda034b998a2b71450891b70c2257aff1a81f5ccc61aed5099702ec7b60f12985228763492c18322534ab3afb11105febb0a3f394a5b1e19540ec401127a76b16707273e39e80888231e373ec35a71c711626beb21d2bb07e413926454ad3d4cd8dc9381fff122a73fdb05d54b0b02e4aacf22321e2ff19a7e6bb9015f6293708a953d7c16b245a55e17c946cf08476fe4a0899f6dab3c14f7a6b284cea90375b9f3b7724dc781498297a398cbe274eebb29077002e863af2cba0c82e31562ac05ad5dc2c86331251ed000a1c830984e3c777df04c6dc178ad935e7683a4ad43294d01f6edb9e1797fa15c9191f88f6185992dec6ba7ff961be0c6400014790b17d50850406bcb019b0d0eb628f40a3b4366d68d7fb4d0cc4aa706bfc3c8f4030915b645af3957f1b469189de2cecb86f5236e225db0696937b7d3d56216548358530a994fa7fdf2276ecbebdcc42493b4fcd2fa5c71d9d6f166aa0b225b37e8031f67da4fc222164e2ba52deba42aba3566fe4a6105214376d70d1751f284ca131d213cd879792fd7ff1f2e9b1aa9f896b8924ef7a8e45dcd8fd97b9e92032850cbc3ff76d330dc40b45d46bb3543bf69f051c598e303b568a0e1e53a2c5542e8ca32f4336011e36a9805ea5fd446744a4e5ea5f55bb7a773899e43ea13aaedc9b53bc1a1073c3fa01dd01da8830228726146c8de594f386a4c920009602807bce027bbab820c95335269406bf82e703fac04638089b38fb446ea734d1d178fde7f1c4e940d2b52a8e68145445cc38fd55968e9fa3d8feb9b676d080750fa7b698947971088f12aad99ddcf41f1a5c93ab9ac679edfe8850c6ea425ac39c72ce2b5b814bb3adfb2f347c3e54fe9adccb4411f083338eddfde64ba2012d45a5058ff1255163dd71e4fa4ae4da46faaba14297ea9efd2e6baa41a1edb9508e3b67e3bc6e8975c0a29a2fb28fba630cad14773154d2b1abba50cbf7ea2108d8e0a8ed1593cb19c506dcb42ee260114e6bdf8821146933cf7f5e3272b13dafda40c0169a98218d85eb79672bb1b2e1cd0853262e944ebd01d21602514a05e342248d4b08e22eb43f8546b4dc430cf8a8450393ecb1a31b9d0dd8a2a61da570f94897f5beba7a462c9f5367805e043f235782e7e537c70eb4531f3d3c3f1a39be4fdaed6ead26b1ed761e539c2230655b14eebc7541b234a14370994e7d6c78af4d41ba467807ce2218c4d82fc1087a332d35d99b1176ef3696835e2e40cb4c6b7ebe60edb414cc331e8be095a3ded7e6bf81c5d0dcedda76d04c2aa7a1a0688db4fa6aa98f3c45d61210d974c0046fcb5d11904094c6700b73d1c48cc20eef16ca8dbbc0181e88d532d18ce1a2f74b5296c1c58ce32491535290fe453d41413d9449d0cc5fcaa79b88d8423569cccfbafa3f502d44b056b689911612580699422ccc95022fd7ab5919c285284bfecbff3a04e50b7614d971b542b4c4dff36a5de5de251090899c8a99b8b2ae10121dc2224a5ae9e0e84338545802c060681e0ce5893465ee1d2f38a883f85865d4b43c2a240dde6857ed476803c60dbf578d8dd1fd2f32172a9d02b3f94c95ae5f2cdf2b065452615b8d343d91a915516b930730a58147428dfa48064e4a99fe91d550bdd03812a92333e4b3a78649d1f69b484fcca9a5371c6367682e864194a4ca01d90eb79ceb9a35e34e9a58adbc528268d2e1580fc197a89b6b03086588fd187cc073898f437bbc669cb128e7b7cdfff8544cf517f2b833cbe1233a9aedc78a7b9f446d3530d1decceb6e3c1e8f5d6419cf025d289d75badd0f3e18987558f50b526cafbaf35a6d913aea65b16db180a0cde4c0ba6b463730267efd591483f515730fdd8c224950870f1049d3a0e0f1a4c4d2efc3f125466c1b318c394d0f134d919c289fb21801438fb85ee4eac5a561d20cddb2c176733a4b502370d1ea802202948f44349da347a7280f466c96c5242756b710a85d2e88f0251ef70031e3e85342a0a960badb1a693dedda6da76e02d2c0993235a9367a14e38902903663f6b3bc7033108de9c170f68418c40a3f3b9c90254f7f4372858715776d3905f7e2cc4db9dc83f2c9242f4d73e5cca68273ea8a5e9048cfb50091944f7987974b0d8d9a89fa6c8e81456c4f5e1240e889f36a26f526b753ff549a7b483c486407d719eee4855cf8e3d6da9b7c4ad92e2cac7612ef1ff41f5264711a8a797d6d424921319638aa1652a77a4c109a607182f9a0b22b2baff5bde75c20b990697cd60068bedf5463181ca2f820fba50599e12eaa09f97cea7f7768f1526c4dd39c5158167182c1fe9b82373865a29ae35e1d76956ba68ee21428da18121c268ddc9d38a2364d695a13250d139ac47f5619fb8afcf04fda0ad034cd5971e1d06038e18f431e4c07c3953f792d40e26c10cdfa523be712bbb263cf089c353df708a60d1e13ca5ad964ddc07e979b15b208471676a0bccce2238b2d5e6710a175d31eec4688a80c66056ff03fcd10fc64244551556fc2059a7c5058d4124fd39a2cb493a13309f1e49d3200f6e0436e0fca00fab147443b7fde8158bff75a24eb7c0acfb4cd047acbab1735b61a0eb6d61fd81f9e606a0cbf94a624f30649adacf1c742fafc048c25c8e1c08543b105bd7f576b6d38834673d34abd69007f76c311c4e902bf80464f914ae5acea4a4fdf20c1a67a41e6153e3c87ce422ad85c3595663c108bbac3323f791d275387bcfab21666c357078436d9a9f9ed2208320f0cb6322c32125ea1673579a3eaa76a8f0e726f9bf2c0bea7abf25aeef491fe22e674ecbce9a7831453771a1614cb67187d419a1ecbf8ffb5c108b085d29867d7e9846d4eb6653d4d99dffe46352533ea85e793fd39386e312ce8fb5cfda468903db37e52c3f3281d889acd0f2df8afcd19bc29b4d8aec5f156941432d679804700c38d9c07941fd17d5b43139f192effe95247eba61647b77caac4fa21584ef124b0bc24dbcac1adb18bbbe264dabaf339650dfd09f5c0f647915c15be98b165a8007e345274b0ae5a72883141e56722762750415c47d6f36ce0b0da24ceb7274ca6e1be5ce260322b2a698ba737bf7050fbebabf344a09f1cbdce722e7f566af567dccb030fcd51c9f667ce744f900b22ff84fbd3e87dac73e0035517eb2668a14726758cbd9710c944b9d51502442be1db150591dbe1b078e3d7dc020030b32feeb27c281600c928b3a36fb04ed2d077d4dab56e97e9c2707a14553b158d1692640ee8345c3fb2fea77d25e4a10ff8c2cf10df133e888d6e9f23f14d0aaa2bb7731cd578bc5bf541232736022dd9d0c7530b13059465556cdd0e5a4fcbf2bb92021e21ce9f4da86dc3a93f3eaca39dec791e11a7e6ca4f37594f36b1619221e90b7df84ddc509b920a610b61095788677c95f09b4867f988e7e3b10405f19ec6f21aa120c26cba98f05faa090a50d14288d5c6542fedc914db46f093dd0df6c61bdcfc5dea94ec72e647af7951e8e884701024296417074d71daf1f269bb7f6f077f76a3bd82f272c6849719cf20ef8b0bf9bbf56f7ce92ca2c17f0a217082387668bcfb0cf272312155d8a28a45d3fc9edd1e733fdfe1168a96657cce44b4f891be357f75dc98f826b4d4590925efaac589ded1edde8a25c4021928b612cbfd7c1bf46a7ac8f8813818112eee90017cd8a2d46436b6ff39e169a8869f69773f653ecc2032f57f0725745c9b986ee452a7f064284628f32599d3a88c429bd34edd4a489b5334f1f4dcfea84badfdf5311ed0cfb48d2bf4a9535b3c4a5b648e8085896783845bcd0f53bb3eee625082e383883a4d0ea9b3912c088eebde91def124e4cc76f808787156a62fd041cccd82c79c2d1ba2401661d22787125542e19655782b635b1a6f99cf2503d7f5fda5ea6e2a73b6bd5d291fd5e916418aa11fa78c2c68cb6036805224e562df0ac5ea32d3972450f5bddde9f68b7087328f846fb8b6f81b2ffc41fa3e1ff6e3e52a2ba4fc56eb8904b832a4dd51a31799e4aed56acde29f080e65f6388dafc04e0929ef018234fe9183c41b0d41694070ee547e18e77758a574b98518e1b5fc037d11a307ffc2af06c03dd84d68cafd7129c1dc855b0d829fc163d15bfa82fb13a929e3223e52b0a8b46e29e0a57618064d62d5bb301258ff190132728490fbb4aa5a45e741eead75352ad2bce7dcce531e20b9e5cd2c3390f1d2517139fff5d6b422e383ce9457571c8a1732fc160e02aa97816230adae105acac57345bb50959dc3f1635194c467068c4c05d4aee649594727181f8d8492e73862f5cd477f5e1823532ea548c301e85d372a72c968620546494e902e25d7922ba2029b7177cb8296b58e8dfcd16662e0d878c5b33c769df460822a6dc6e9a63612c2d439aee9bcb48bd332f99d1df7314a01f25e35cde0d85e89150e2039b0ad69fda9642c5095cc09f7d8ed98bd01caaac4bdbdb18e4c8deb0ad1b632198053546057cacdeee19b503e455d424c111852c65b1cd87dc726b9c5e6218ce5340d446150fd3e2317479120f978ee9bf60420033c040dc3d667e92885c6ddf33763c4dd15164c7803158194ce2194e88e94be3548225ddc1bf29625cc0eaf498d97ea822cf1dd7e31e67ba4d51a94dc327d85c4cfbf17340b8d99b73248d3c3cdc82442b338271a0fa01897b4489cc5a2defc5b8bcc00842c9cb252a60a03588e1294016b3da55fe866df3509cc94dccf0a410ce99e40afa883971bef29944c619217975196ac4a78166343d899bc0e76f87842695320178999c0ebd8a241f39fefafc583f2255973ce4c27776c36dd1bd7d78d1105686950561e9dca5d172ef96908c6ad7ec6f563fe314eead35309ccc54f983a0b06aa39f68ff588a982c3e1b23b03d4a7732a8324e2ee50ff43f98b3158373e9b470794c9b9bc1704340c05ed490fd03050e0a1f91a2d4831d4db04ae16db5b0117f6e5d81a463f52230ff8bf52e6797281089b4015a381fcdf019783c291b55965fee711f1437089a28d338722e070e8e3e71909b1196ace829e45fad7365dd8270f4d4e6a327725a1635b33b8c4a6734da08322cd7397cc6749342883c7ff136f0932286e41a5120fb12c2d1d18b23500c608bda0029e41bc0d6a038452a12d34641c28c6d42193ba12bebea464eb1fc5a00ba6df921f415ada821f2c65d87a254dda1f4a0fb3c9448e3e8fc4fa2e8f39ad8d20a91f7bb65f7c4ef62417feb761913fd68860b20978da8e4133a3ceb95e2388ad1a5bd10388a795d9ae8ed3cb979763f42b912a411cbaf22842607bd27417fb7a200e9f61133d1b4402183267f99bc0369f42580d9e90819d762e5d5b5ad0182cc1acd4f243f5fa1de20bcb921d5845667c453ad3649be0316e54d17adc98bea1bd4fc46a303c2ad18d1a81f721512be64fbadd6ae367c52d6c91f663cbc41ff79aef786ca552ba820e01280617a83059db9430f2cf0e9550dbc890f0af1309cead5e0f209b0a329b5f315a0c8df0408780d40f1c876dd6d7d973ad67818a0734da102ac34aea624e3bd6a54815e895cfe6f32a9f460d07b186c59cbe7b0ffa7b91aad31ba977733b4f2fc3bdb758fcb9c31eda20f69c346368bf1713100dad1932d0cbea5cd8ec141e68b5dd5e8c5d1205eb830dc4a78fabc0b80ab1698ce5fbc7e96abbb2a629b74db6488ff4559050c79b54da564e5305e21b10f799cf54b5e347b432ac60021ba63e53d0ada9e384dc2cac71afc203e2f180773c5a510030765143a7319a2bcd86513238227c10ab23ad11fa8f5628e27a555d548309017f61a685ba17ea7f5add012607a1e9ba3ce8f4999a6f12526628f7ae8ce0e709867e7c550d026ba9728a9d71a31cc110cc202d9dd4a61f091cb7852730fcb24b491e079198a4913b26c2b0f32deba055cbaba8b184b8f4f5a90900e8942e464ae1e00b52ac29f3e40b7704d9d074ed8dc368e08d46954a53ce64e0f3d99daeecf4af88acbfccb9a7441958494d18cd0e3f3f2bb704815b1c595937852a7a26c058665297d195f41b1cf3fa17a3e7f66213741450116e043025b6a56c1fb837c641b00cfc259b17f47b367be1fb6949582a0a0f8631f2bb1fa63f3b6f089b3fae8acf289451ec8bc2f7c832b5c29e415efe905d3aa3527b5761b4473b480e00e244d990100e3e88632491ee5d7bbdfcd69adc481a15098e42cf36694f5efe0882b005c5a41903f0f7f905296c1d3787e00282f164c2aaab966a788770263f095adfb748fc416d63043e45fe3aebf159352364de4c8e6275039b1d6a2e124280a03f5e6d26529d855f7aec10f8ce40afa49054606028dc465c9af853b3145dd61d875a0958a521a18a55f6d286e60d160b83f2cdc27b4235e650714ad9c7d00e0c347e8071a1927b880596e745354b28e82ffacfffc3a59a006e236586cbc74f1fe1d3cbece560e7ed8fd1fbf98f0313d3c1c0d9d34115e38d07e831a8f87f01b695cfa39ec8c3ca4908de6abad71b9e3b9c9c24e05358589708d413934ab1bac654ed9e05c96f3ee89b8070c022d6d61a6f7c55592e8c7565323c1bb0fc3e30781b485090d0757decc9ac2b3d09a1894aa213b74d18b588cf2f935528e8053a94f940fed7a03042a109eb702513fd9b57d467c1a27f27d9586d09c337e34fff214cd8cdc6449dc220d581ae25e2990d8e407a66026338b64a1842d57c292d466e305ecbb87580584136b28b3b8b95f573e723498e2a4b4313e0fc3754fc9b31bdbe7e1237f30aba8b6c72b66f3cd4bcbe2e01ed602c88bf20da00410fee28c37def869f5d06563cb232bd8d245f06db57deed11d1f59849f6b2ec8cb075e4b9c76c48b8ed47a1818884d306f2734aa8389c5cd28fa0dde97c13cec3c18cfad30cccb11ed9e213c79b95124ff1297b308cde9ab4ca097a0fad72e480b95d06784e572752ec1d31e0297326dad5725a8c0de32ccb4ba5d6f2af6f0e0aad26e0df52a25eb01b054c8e62e68081bb606633821f73d84c2d02df1dbbe98a22d453113448873f34e875d329e502a743acdd0e6f3f492f5874dab25d3c9a13b9237ffcaafbed1e071443c3b9eaee983586663964538018b2e12053a147584fb5fdbf5e51bea540c912f75cc332acb2884c1a3cd192b5026abe19e01724d8c9429b6450c14f4dbe59556c33d4e324345c14af86cf84c17bc26d1971752687f1f535065cdca38b7ca3a9b9ff6986b4f4335f0d1bdcaf6bba96482bb56384b727f5ea82b01ab96f86ce556012c03f06e4fac0e551a417dd43e9488869d55929df97404c29da98ac4c1d4952b0b25294a3ad89faad5438026399620ce36103497885a595b3bd4a0d526a04480dddcb233f07464ccd0b1e362a01365516deecde5ee9e28b329e2179504515b1930b6107a437a3d65a866f206708c879d88682c74b673f2f1dd99d24908c68604ffd81056a82a2b315b8abdc828a735b3e5a6e3dfe66e1917a628017a0f2856fe3002574b3c5d46d5f5b48a971a9063f1ae592d4f456f7411544c103d578b3d82be3a40c90fabead4c326b2e359ef86d07bcb7fa31ffa43b6bc96dc750aa05c4e7b3b4a4448457d806f9c8df1a5b0f53833425ae384e48bf565ebb45d119414456350dc8bf033dcc31663b2e0fdf523d8406bafa2010b2002b82823f15af74a3ad7c4c3e87fa4e03b63ba54465d5af2ee74988cbb32ee29365ff2083e21d85da37efc84024e6b51b541f8103a3f4eab92172f527d12360c74691acd3e77f1106849b51ff7f19a932900b531201875b719acc448b6b792741020ab055262581e78213a028d13c3d901123aa2c8ab098271374096ce0cd3ce108ee55f5e145c1f2a60157851359b7e5308ef576f08e3e9227233e868220ccfdf6ede96b6344f3541a141d1044791d8f08c30773a50df496cd3c4ef93e014870475091b88e36373e984e89994c5641430ba57bd7553582bc42ab21b88e179354b733c2e6ccac454b283ef2f350e02b0cd887fcb8bd9e8cdc70ccbe8024598fc03ead9a6019e866a41590211ea6a1efedbb79433e6020d83d6f690624e7ed401d6e90384a1e85d993cea9f83c199e16e462be0f383150186cb789dbe08f7999985d028b0b328708fb49bac9309f99266a1977b450abf80e5e59990f0690ebe02916cb5b2817982e40bb403afa0cba3a58f81ec7827f61484fdcf27d1169e597f2252c2188ddb984c8f4f0e8514f1fd90aff02e878401efe45b92dfb6ad4a317454776067fba0ed215a01e9238790280f33bc782272746de898dcdd85436a30814318ea9410618f35cc4877c7cad245548eee207d8225919594a024b8afba397e6d689bf4c15e87501e923e810d234799b415bc869a13fe4b1fa4deb99234ac7f561894783a90e447654df6faf1d98a9877f61a148aa1b2ba37d2624babcc86cd63497393681e70c67bcc959407ccc0600dc1f20f8770953a4f87a539206941ca30f24cb7e9d6062f8ebac08d840688818dc5ca9f98054a25af61310817e05765198eeb76e7c86487bca056f582fd1a39671f70657f1f59ba5622000e5443f6a3c442eb4315b6787451321f0e5efca5d19bdf9d0897b2e71d4c2a7095c2a13bd7591e1f55e7614d9deda69170ed7d1111f2c6216d41e8ed050bee96c7cfdac1318086c2915b955bec2821441269a2ed0cb5b114a82a416a5e61e2a3aac6a16af8a4854c242cde70c27ac553f4e939288e5e85c7a1ff319e5ad040750a69ecd917cc87418fea409359f757f46a28160fa2b457e99fdfdfa8ea7070adfac3eb5edd733c55e929ac8e364470da2ce336b8db6f55f3276d9da172c8a1f397bf59640307c2679060b7a183a6c1f4f1a5ecd19bc74c82cb7883ac9baad7a4c11cae903186766c33632bd780681f34bc6991c0233310b9e8ef70f6a946bd1186ad330b1668bebdd19cf5861fb06f4078f5fdc8df7d4893f208ed8be7a0050a5fd52f76337581ad61b9a967105e5cea8336efb52cdb3127e0d3152d4d1df52a94cf12a23076da06c5f63c9e725a5c23fdbced24fc4c8af680a56196dac59d8f2095124c0ee825b54ffc3348b5587e075a6fd6aad72b19a40aee821deb17be888fb4c0b3eedc467dc76481e01a506422bc1f2d977a98160923d3a75300934132e2184b80ba5d93b93fa5fac96db9eb4e43057bed1654203c2f3f2baf095fd335e970772e52e69418d363974d82829674ba0a3c064fa407695fcf82f1e691b6297df41d5312b8e67adbf4b2404e9b66e747cd3aa25abb9243111ee1f82fe560dbb4bbce29d9689f5f6da7e59f96dc046a7f7d85633b7210e684a767bfadc5ccd200f5649d0985229296971d5acad8fffdc2c1afe5b8627a8437e16f754dcda395d1f49ab7189988e3bd9fd26618659a50ac43b1bae60fc304e0c02ae1868cf7834bdaee9a5c7fd0cc6096eea06d17e85ec997dab35352eb77af98236451ca72018a5aab42ae11b02fe99ed0bab03222c82022e1bc0b2b0267f7572e3f8c4f6038e82642b023feafb046d7fd3c116be8fd7da587881c0ffc5ee8796613ddf4f82df91398587a629961ffd65da28963ed2eb25fe33962bb4b86b97849f434d415a21b473e6f0c9257ece9bd99ccc9cbc2c04da63a093a1cd6840617407ee5ad5a84dd4296d09ed2c52ac376e4de4303a4e3bc4aed34aa1aab836386f7a6658c3494b9f2dced9d9a96186b89c889d20a985266bb8aeed13de92a03e903cf33d54597003e49fb427172f988ce4aefff334f84f213eb76a2ca398b8c1135fa2d70f74f5e52a695f9d974c3dd69f8c473f5094dad7fc92e092cb212374182639e71cf99ad2fd4c9b97dacfe3e367ac6c5438de6169c7cd4dec5551bfb1e06be18cfa45b146b08bd3f47a6f105e54496f5301cc358aebb03d6ea5f7919a293cc41fa6c4305a75379eeee9080c2b402cfdeded5802e1c7d0e3dae484279350e1fadb6206e12b8c2be0041666ccfa3a927bc0267371cc849cacefc73b5ad89295708113ec15cf83efc0e76ee14d252ce68b2072b25b8814c2533c9b387e344dbaa3aed98fa6e886061ba3afaa42c566ea84e61d7ee0a9e1c3dc5eb74a5d818ac0356675715d48b9492ea2f7f18be5317227d7e0bd8163eb2cd7cf018379712ba3e23d47afb61c270c7c4cd25321da3669df270526dcff1a489fe1db9f313f8abf0e3dec5e7ebf5b01693499b011fa95eee93e3b471506597d4f4ff37e0d2bc9f1dcfe9b259baacc350f4d6ed4bf7b891f6d5500441bb3aa3a9fe7c8ba49faece7be1489c463664797ce8e279a4464162c22706888345828fe810774e4f6b38885810a1146e84e845bdac08a3eb5f35fb9916c73b0b1ef4e3e4f4948d3272169977558048fd795f11c6519b8b63e2d05d354d24fed29f7be3fe302cda5e24c7a52ea7d27b4f7988375d48b66d4dd0fa5da3efc27b562ac95d895ce51ffa7715566af1cd69f7336572ba4a7c5280a15f3373635aae65f5201b6b676c86dc124d85f164dc759da2d5fa4efbbbc5dd1c4f91413854a15876e3f748d2715f98068581421b25f8ae29ad78c69c4416895bdca8c46e03aca97be88e2ae480449c2640df963708162b07b6200297c07c29f051de67d817d3988db1a879ac6167ddadc78b4e61b831095e4e309a7082784d6afff3ea16ae3f35cfd7ff1288067ebfcb284b4f07c61e6feb52750c79a069a27398f4759838e6117290eb37fdce596cce00814bdf6fbdcce3af8466de3fb9da66b9d2cf9e09bc2983c0071f28ce3c67513f8ce561ac395ae40a1d7740c6545c667f94ab2301b361dd6925445b4c558d02a2b7503d6b185a5026001f7ea6fcde53a88e6f9be701b5280b5fa57a98abbc6578cbbbbfe9183ffa71d3de546698ff0a3dd8c85e19de7ec210443d5e84c0f774fb699c25ee8c20210c51c28f001037289f6d27f312f5f45fea8006b110f44c100fed60034a299e4b9b35f216d905418041a35b26140e196fd72a06c77f61cfce704164598b54f27b9959723aba4b8b2205a086141877b223f1cdbaf25f172565ff9b7cf077cad9163b10a1b68809ffa3fde074fe796546bdd39fd8138c5c8ebb503d69595cd968995113450f87beac4c6fe2b66251029a43adc74ccb5d5fe21993315e3434ed13f2d8e81ed7dd60e76fe52f347feb704f036470c720c28b965fc656808c2393c0b6a1b517977d54d17dadf34befb4fa25ea6c7cc0a12a4cc00aae7a174b443e483ea686f414049286f627a3aca5589e935fee235c3518f8f0c7c20d2319e8667dabdac051178d4a4cbfe77ae67cd2ab45aee7dd200ea90920efd30717f8bc367b01ffaa0a6bd3c0d8b8bf8550dd81ecd80ab3d1f4a248d2a527386223317471fca78cf6b619ce7e36f052882ec1dcd68b212727de8dbf39bc9c3ed0226a910bbc6ffe5097b28a229220a6382841d653707fbe69e03f6bbf280dc353d887b88a093c403629fbebf695022c720887bfa65772233ba09f782c8942a90cb1dfbd635c59390297111e4e646334a669c5e573f2d1ea120eceadc5da012b584acd9237927a702ea2f97d172d4f8fd0f900e6a1874800bed1ddfd771d644e99ee54c58c5e32b500b8787e6fde59eca28b8c114d14f834c74a1f8546fc3d3bc745ab9b423b369353d0b73a2b9c9c1ba3839b3b91a557fa7173fd8ee029698c59f0de3bfdd4fe0f70714aad4d743b6657f1ef7fe7f1e794d2b33d068a89a04d8051c858f90b14f647c5b1214e25ee8b68ebc1ca8edb6e386dd18ce9b45fae10e1111317114aebf4051acc57b53fb8812c68a8d00deb63f130f05896aaa38bbcf6f563aae9004a3eacf21874f74a4120aee8380ad2e459c28a3ada04ca520391d832e2d83e5de943b110679f3a096407dd3de0ddf802b0d98d3c1d82ddfbff4e7f3dfaf23a888e3b917ec717028395ce7372a8f05382201ba57d1fdc37126be791e2f22feb0777d4663a940561a2c457d575fa57cd5596c99abb3825d187dcc7e42cce4e7f2f644b6636cefb479f7f9012b7f0622ce5fc033c7fe846f076808a11918afb3e4355d223abb820c741f03375303b94613a16f926beb660ff832f46db3677982ac8967af136b65a8f5dad46a506485e3cf24ba69791961704161eed3413c376975940a190d2152e5b7f3cc7660bd0667adb8063a90d72da36ea8017647547bf07ae857f5b36d55e23656493ce74b4059a409a71b054a8bed97acc3966334cac1f98706240204f14b433e3d261a7b1d08a6d73309bc9fae4a3451991395ba6e565816f8ce4e752c7072d440a41fe121295398de1760865b178e10515e3cc3608139eb711df2fc9543a2287791342a4ee66ce97d4967d1b200f549fdb3a43479195541896cb4bf5aee709e8116c93d40eb0ff3b53519bdd9818bdecf69e7ce0013a4115715ea341b746a4c0260d3faedca6b0b89a3a55c7080054764d4e7147c5193e900b7400735e040c24e0f2023266b9f33d4d9d4a037b742a07ed223ff4640d512125c2484caf71e5439097ec2555377a3780e788f266d9058c33919017843aec43710e98f204fceafa42f6c1d528df1e2ce2084958060c6f078a4db164b9a4eb7c3e2ca2bb35ffdf49b0df7740f21f0c80e5ec59367c2d524524d09f32529eb4d3af8dc0f08e65b2277c3f2fabe23f3d347d8e3598a110d1c66860b2147e1e851a07270c4b052460c32cf4a3381f13e79b39ffe91962da126af94c9bff80196f0fef0a525eb4ec9f2b63b76bc2ebd3df1e4a3467fc88c12cdb62a24ff01b80eed8303564a02463c0989b52f669f70c37045823d470b8602fad1a40681e7b23effc6241df80b61be2369bf1580f260a414b5c87343b26e8c16fd510187904bf8fad3f5b1bc2ce905416e0aee0f64988f6269250882cf9dc832ef83b4cd21e035f7ed89c11d351c9a2971f5517c515e88eefa5aa76d65b90c5752550bf9bdfd0e3ba634129c3c5af487f11fcd480d82db932caf0fe43defa070a5a4a099ee2ee033054002cf5a4cfa7c97ee8eb9afddfc0dcbefe3a8f56a9ca3027669060524e79a6ba13c3eedc87cfb051346b8146fda85329ff6765a983fe848ddeae3048aa8911f322580e5a7dc36fec224d47f15a324e43fd4a091c691c28f79828c20461c14040ad48a9059305816a503f2460d49daa6f7c11696a91b2ace1fdec5ca0e4acd0c517debf1827a4a560c79d233ee01188823eb83f6e31fbf2120e805054e012fb5b9acd453c1ec3e0a9eb42c2fd3a71e37b3d6882464efbdb7dc524a99520a8b082f0924096ce3f2fc31b04de9b7ff0e70f90bc03f7adcd45c8699a91835a697edb1593aed47abe99f085a208c03472317d2f3921b3f15395a4d0f84505115284d8458b2fabc6b6a22c4922ba4be4b57eada51f1539ef76f32d5486986d5ee5372499fe3ee84d25a4da67fcf4947619af8a4e824eb2d7f01763cc4ee6b14dcf859eb8b17b232277cd1aca2254a04ab387b6444a21b185525ba0437c227c2aa91c58151d3464ebb1fb7286732a83097871899263e864512f5e3160fdd4d24953f3b69647b0bb0ca83a898c528dcf848fa870f3407c6f1c18403e3c88f5f01b6a11fff48ffd070ae8f6f3da83a0263e81f9aa5ed237299fdb88b25da48025e82bdf8f448fc4863afe0466ec59f338051a7d5712fc608551bd3f931c79d71fef5eccd39d342340c596760589504a2f8474ffb4892823dda477c2c7ef4e6523c299aeaab3577592d05553d3c444444695c807dc48f11034c13ffe32624619a780315d5488f7bf157c840cd3ec5d33f7ada477c9389bbe809e34699e44d5a4e44a41425da673dd9fb50b9381ecdcacfdeb9202de9921d4c7630e91d4baabfe60e37e8313a6c814629c76fe6523691e88d3e3f66dac7052ea55fdac1a4b27b2ef6f3b9f4b5b8757d7dc7924a5feba6ef14c228e3c31bede773c568dd7a2f97872e9699a664bf24977eff88c1ab24fbd5113733837b300693bbf7fd70778037da1c6d54fe90cc5c223272965984069fe5535aab49723ef25316f56b2b577e3de54a2b526c2f91d85bfaeda5cbcbef2aa5ce887bf2b7aea7bb0148922c27b9674e015c6c270de49efc1b3ba8d98fbe81b6e81e67d93dadc76db8bff131ff5118d5cb5fcc46476d2fb76deb71373bbfeb46b40d712eb9d0d8f60ff9b1c42a0a51f1a9cdbb17fbfd42ec42edc267c906e055fff0cbb4bb18e5d1f81ee338d3f4e7a1d806e2a061fe75d94fba8feb2fdb3ea4c52105a5683cc331fe57af9cec45469960a49561e662988d8e9a636818e39c6aa8cf3d03483ffafed6ba5652259d6a7079ee8bc0fce874aac1e5b9e781f9d1f3fdb970dbece95443e9b9e789f9d1dbc02b2641949efb20627ed45c90530da577f922257bdabe74d28ac4d8d3668b909494eabf3c4ffd17eb43457b1f97afaf591e5289b91d262ed6870a8fcb97de06ae2fcf3e80eb5dbef4fe3563b8d8afdf6342e8676fe4eb217e3d3414961196e632073d7a7818bd26f486a2853806b7213dbfce0c6e537a664e7d8c35f22fcf8d9cd47594daf5144a6bcdf8923aee8ede2c7bbea2b615292addec575df8650d5cc76dfae9477b3ad5b03df745467f03b3ff6e341eb7f93ed3b4ec6f80c0cfe93182047e0faeba2114037c1d0dcb201c753f2bee7f5640dc8395079eed39bbd9c02b1db8d91c1f007c5e610e2d1595dda3d67fba64cca5131a1fa065646ea497c43ecbaeebea2e4a4d1ea40db1c3184e5b2adbf90c2fef27949ea394de5c8a7d89d48d3a4dcbb22cf34dcbbe3b2dc3fec22c4b8f269899f9e740154a6b894f4eea4e3e7a9ed1e85fac0fcc8fdee7e549ffb3d26a77f25277727f97fa31d607e6ebfbbc7ce98847edec8e1849a24e08388126a1ee94591e785e1ee679b081573cd8007f87ec6de095cbc3581f9f9f950e1456cd66f918cb2b98b7a71d983f65d6065ec1d8d4cac57ed7e7c08924759dbe5f3ebdd4f1aa76bc2219711b6ae3cf41c85e45738a452a85d16b4af786c20a2b806c5a86d16b426f247c8c1bcbc8fc78771037373032333d6a6a328c5e53baf715db651b8625faa70ca334cba80ccc81af33037c1ef833f0bd0ca3b445c506ee132efccdaf0c5719d79ff20cd72c62422b92a71d86fea477f9d38ecb9f6ce855e94f455625fb3fab51fd6a3fd2e8e75e2fb3a4d27f7e8c310c7b86b0ca0863f04415517c981bcb9847be6919f642ae2d5bb6b461c31f39055c9ba9d248230e3448c37d1b3532a1c243df1d601bac2bf935eea8fd66bebfac0bed3c11f981757ba0173e7f462e7cc242725e14cb8000c9b0ebc7bdc1000244757343afd93df03c39af99197a4d197fdc3b8ad643d492c633d767d9c32c756fe0f82ccb328f8bd13c26bdc6dce8bb23d92fb5731996f83f6ff4fdf57af8a774a07f8fc949cdcda8f99db94392bab687a8eb2b0ba1761bb98ca2d55c9e7fa9a82a7bff1e32c398dd8b3fc81fe87dc557493f320e7c5a03d9356b3e1b172e818728855dfd7ab8d1e7c69883da3f82bf74bbaedf5ca575596cfb23a8d35205f81a1ae754524ba7bb41a51fd4b1419dc1a57db40f7f26ea217aa21d9d19dca6a18ef6e1ef704bce0d4ced238afafdf7a0dec0f3c1ee3bbb8da8c76d3ec67283c9543dc6de41c9ad37c4a836fe31b84d9b4c2c1d45d4af9a58cbb2c630da5996cdcf4e32649f39d76599f6cc651af69d61df18f69de6f33dc1e73bbf7f7e6f9bd6652719605b1ffc9da35b859164c4fe90c48e59ea4efba56e64c991be1b6354fc517c2ec6974c13396b993ac22b47fa909b3b8e2285a8332ea4d18778e10ffe23bd8928d643ac228a262e57a106d1355dae420da1abcd8d8aad52b799736a327e47db9f034f50a532cb94aa3019a6653d1cd146a4116544ac1e5f613a355373a660ed69222d510888a2101951374ac9d0b40c4208bfd4d58e348241240bf58854fffa7e97eeeb9503b9209ac6715cf771cc6d9ab669ad75d3ab75f7f5fb302f0e3ecc8bc3f51a65ce24e3dee6d20b8eefdb2503b45f920b3fd2adc298e6d53db7e95cbfd60da7c5410608c60584fa994c8f6ddd551847f56bf412aa9af6d95fdda7b19643ea6acfdca5659ed1ab65dd977d0ea98b437c987539a4e86557517825a8661442088f5c11218cdf18c42086c53859e8daaea750c5fdf526a822fd75913a18ca6d5e8d4bd858857d9c5807e328f818db4a837a59ca2b2c5169d462a4f3e1351f9e88f80cfca2664f214c72a1fde80ce0d7f06f866118b6759122b9f39b5252f4895009245ae7cba9e5f2155f984194032713b58c101a11bdce06f5bbb9fe566aaabbbb7b8ada2374990bf2566ebc1ed7ad855951112c9229698b8c7c84ddd9a0fa5ba9fe1f17b5cdf7503c0f591f640955a1d5242474bf2b0b64614ea06ab2202a42b9110b9a72b5645e7c980b6efcefcab2a36981a80883fa4d4dcb8d3f599355194ed68dbf234ac52edfc089d01d627141f108dd3ca8a87ff9d2c0f7cfcb57d608e2c6e7314585cf438a28acd13dd078e693555a1746eea018d48f85fa892a04b1b4206c412bb55fc0838aca97af44410dac9abcd48dac0285a75c58c19310b0d0a47a603e6149994058e124f017ac2c454d60c284279a587914ae7f8de222faa9824514222d2d289cb8c2440635c0019117b3ce14c040e3410aaa002209fa53646967a235c512ba5e6e4d31c6c52eb7a638632ee1964401cae2074638e2889567e00b368a5a555650831c1011456bb68c52469413aabcdc12a2410b51849c702688105b422a9861e880460f5cc084222ba2285d6e0941112a020241ce979fb4d5e553f9358b269c70a5fc198f16492a09130d88e81a0c31c485156674b9e58328acc009723425891478a1c5d009b24c2088b450e2074b10f14bb2c052ad27435c78b9f5a404330373085f620330890c942e7c53ca035888f0f324063e40620c278e085263b25670834b0bf9de9c5860190209126230c61a5b8c20011663e0e00acb77b0022e8eb82e27818b9607d0b8dae5561223b8dfa7a4179ab713ef543a33ec2469263ced7ce3369f0a08dc72bf4dc53852de7a250a625c1cb77a97ddee76e8eb4c033f36a1ea406666da1d8bb40bcb5ef38dcab95ddedc15aa5cb4bf6ee6d2c138ea9ad736394d9bdc77525cdea53341d4f59adc3431aa76dd8cb445bddc26fbeb395bddbbae87a155e15ff1da6a37ca344d7bcda52bfda8ab245bca3ea3ddd7d787783f1dae666d0ff1cacf58e8d22b73c9a28114d757dcc69d57d362db42125d8fb7ba0d13d10008d7b3d0d80b26975b5d10e072ab0b2b3709f44117f785cb2d1f44b9def6d98cc63b2e8344bd5e931886595ae5c605e1614acba8f32737445eec35312a256dc184228e0b82618df110ef11243dbc9ef934db360c8b379bd0b351f6b48cfad55c49ad8431044693fbe3728b4807d7c3b2e36661e53211164358586935717d5c6ef580755b5f64b9dcd222a8a585932bc513222b54b4b0b4a6bc6cda18350ca1fbc2e556184eee4d182c30b4c46ced3736a216308a89a2a0445554a22b626eefb8deed002304444caec96db8d583347a6006902cba3352ccffa2890b80cbad2f987891c665e172cb0b2d2ebb4d0a5b771fc52e04eec428655a7344cd6e6efa0271ef86c76fb0ed65b820482ec65650d3e5bacb7a7c3b172b3d89e3b867ae318c7bf7b8cff127759fcc2565309051b1efdf3ccfbd1e34602f93511257847d003e54faa998d83d17b82018666a1c9c69078b5aff8b97f437489f034725faa4cced4d7f4f8f7b2cc3dd998c2646cd300c4686de7284edb84d66638744cd7ec4da9e3ef6c17041280b580f0cc7eef180e168c85e875b3d381a6e68b820a4ef3b391ab2b7372f7041483fbb9fcb6e43b296723464efbd4cfb7976db60ed788897c3be2dcf65a6c1be2fb533f0509da7dcc51e062c286b815ddc90ecdb520cc37e623c37dc10eceed434e99e59f36c2b526e3c2da37e3757cec76c534a7fa326f784f808a1769895916f4fa0d27bfd8672f98bcb2d2eaab804b8182764be96795e4d0dd6a3e6eb713d0ec37e731b18c69118751bd2f76f15a62717a473903ad2b7979e392f35fd18a71f439b922aa97e8d89e962ca9db9dce24204976296ed377aca29a0ca50a737eb4edcf315261405d1ec4906ece963f6c4bd3d8d9eef0e90f41a471fa3db69f4a3cf3a24a30eb39799863ed67d29ecfb3199d49d76c6bd1bdde584c56245b1cababe64308acda069d42dd63031f9268ce2abc3c51346f1fd523a5c848069f83601aed61aa715f5b071d7a02f5fab8fd9cfbb18d0165d5c9acbad212d9752a1e532110d9e98d6b032a58563ebcea75926c72c05d2217194fcee8eb8279f0764c02b81189151b8f275a070bfed7e3c04733f1ef28e6ef176908cfe00714fbee7d5d4f4a87949d57817e769cdcdefb6c0b443e2cdecc634da0f89b7ed28fbfeaf9b1bb245f7346d76231b8d44b20f8485961c0dfdec5e4c74d3cc8ccc0ccccf984c2d34c60d696cbbb98921062031b8e4c47013b99b1e82ddccc29045fd642ec66dabca588692b80db786547025bf9becf4e830ce842ac85e3ee16adaa6a3c3c3f333f04851fb4bcfdc901dcbe39eff484ec7bdc805e9b1359765432c3704dee6283b8e4c4c83bd10ee694cf7c120e9993d86eddcfee6b9d9f76b5927432404e532d11466dc7a99688a1f5cc62244e6621b0c523037a4da9feb0f611827db8128f9dd3b5095044ec93458866118cfed1bae7342faa74c872475373bd37ddb4bf7f5f880dcbc97bac9d1d951f18ab254cc758ee55e8d769ecb9739a2cadcdeb62d320efb371df9b8a75ddb75514a63865858a8c609d13ef3ba947bf27574a0b6b4a9aede6064324ee9fd4d2c73b7d7816930f5291629a5305968a42f94d2178a75497cba6b56a963a6d9dc2ba27e48646ea5dab6e1c802d4dcce713a9c2c09e2b849c905e976db4cdc93929503ca57596e531b4afb111d90b88d3b71c20549c283ea0f01b7d97a6e30e2dbb68dbe63b8197e6ee7b8cde8e5c7e03693dbb01386b59452a68a6c6580e8ca211fb7e116104eae7c20a8dcaf9bf8fac9958fb5c7dbf2c1930bc3e5561845578b1c91fad4a9b3cbb847b226a6c9b2ecb70e89877141bacb76ae7fc605f1a75dbc3cd63b24a9cb29ba318e0fc72a258c922fdb7e321c1723ff8b49e29efcce89ea2f547207cc40cb1642b707781b0890107045a5b2986480b52a314e015a6700310d544df93e3ff0184e3061ade2fbfc302d15f83e3fec006a22c54a5a2afe3f9c90e0240aab68a9f4ff00bba7bbbbbb9bbb25d3305b33d0284263e85ebe8246153097afa041e52a216a30714a64326e702ff6304dfc1e8269e23ccd06729b18372b56b86a004f3aca57a144acb287b8f163931bb5dc6fbb3d04e3cc797ba02ad54050c580f9f282ed610c685517d1a8f8b451f1dbfbacd5a1c3e57e0de4d240d9fd98a853b8299864ab6a1c151f4866858b8a1df5e9b86dc3eed9fbd11437451d5a82151d2c97c8029b3aba74a3971df71adc5c84b809aabc99fe3143fb881fdd541fa6bc51c9ce10493656fbf9e5712fba1ced304d7c6e8afaf2a4d7a24296444a4d6a924f44462f474f6464a52881f997973d2fef43455a986abfd14bfb1d692ec8e8e50b67bf929c82c0ca932f6af6f1055a7c0d08e3909e5f875f98e8729c139e7bf0fb53504260c6174330e2076aace07f12f5a331a298c62f147d9900d195f642dcaca85ccfa50845bdfea3345c598681a88078afeb3dcb32bfae8797e501cbb21f825c9d0f7e31c62c8c9b7b1d8ca3b668cd6235fb88b3df79c8fc877b79f7d34b86a88078331ffc660c337b2f8e645cc805d9a1b708f99f7b7549ee9675356754aa79ffdcee7a80dde44b72e35f5434fefe1d30a8dcddcfedab76221dff41a02a56b447f85b33619c7e93cc9bd6e034cc30fda076c15ad498f821c0aa9fe123ee39048c98a0f6efc06afc68e0be76b5fbe8b23a308d3c03890b8d647152effc9ca2a09f73e67c966b8822212834212673ce391909ac1b4ca9c22ac210583810ac882d253cb04407a49452b2e042621221a594920821823099fc1586c604a65d6e2da16289152d084153de4c1ce932839bab73d30e4302872e5fc07ae372134b5b7ad069b55a2d1aa79cf26504f5e316141d776fb54c5e8eec3c881a39a1b5d3cbe436476f416186f0d84eafe8b4af1ea259d0dec1851f04a1402743bd03cd6196805e58e1f5c743bd1399a81f0f0545c9d181aaeb31acbbb9baa11eeaa1dee954efd01d541fdf990981cc936ec26468c883a8388b70b0019310a310810842601d6c00160d018628832068af92f04fd22ff767ff588beb115a71dd9db280b852807e35ad8ca3dcb4c5c4ee43d0428b085fe8dbbf75ed4c4878c1002ffc0a9a8fb84b957697339c5e466e1eb033840bffc3b94270e749c5d2156239c2de11a8a233720eaa2a1ed94280050b96200e64a1290e409287c1e9bb3c2149bbcb091c1a01bd2f6aa47fb4b310ee13d158a224d1f2b11653d5125f9878423e8d523fd6f24510be0c909a9afbb1961b8ce4403a618cd02e1731b61e333230148608cce5089cc9d832f68b0e3e2ebaf0a111f814c6ce2463cbd84d90b15fa8162ddc6be92088824f9b35a596244ed4efdf29a5f0af7f9d2450e55df65dac549ac4b3e2a5303d519bd0a2458b162d579a802549171742f8b109beac8d10cd43a935fd27a07f6054a856415a523fd306eaaa53b7673810b921f4d239a590decd795d7f79b2ebe109cd34a99fc908f5335d77db6148d4bf9f77eb90c4620713a66a6194f34a82d218e5bc28966914ab584629866159a66d1bc78d46a49ac154227db58d1bf568b4916238eeb71189546ba9e4e2f2f2020313c3059111a2a670828a0387c9044d2693a9965c60626e4478c36fdce81ba5928bcbcb0b0c4ccc8d1b26538e6b4aea5293ea1b3f986e4c381c070c4c4ccc8d1b3870984c3972e8d0b163c78d1c384c394c39749cfa9443c74966470a9d5d6106002cb4e0a15ce0d1a3c7d643cbb01e3d7a6c3aea0623733ac9ec484185ffaeb3768515666600c0020b2db4e07928940b2ef020f1e0c163c483070f1e3c78c8ec4861c78e1454f8ef3a0bbdad9d2315989dd9f9bfeb989979054e86a8020b2d78330480112c1851ddb6d082e7a1502ef0e841e303a3970f1f53fa88d07db40f1f3e5868c1f35028175c7081078f1eb2478f165af03c940b3c7ad0a0e49cd2615c30419927d5ad0b1c91be3d54b0525fa83406a18931c2b8bd20534475eb23150001c0d030d0d0d0f464a1a57604d0c44e53ea2f4e48b576f0f3217c1d05b043085d4c103d14fbb8ac89c7b46cda0183eaf282faf1d0ced0d0d05016cda1472882ee7403bc4cd47ccf347acdb75150cc8d989f4153b02a49146c23ffc6cbcf1903f3da283ee98b8c1e3e09be125237e1dec9dfad40d4dcf120889a2e7467cfefc4a8cdf1475f04fe8b55427af823ab840a0fc9d257c2308524ea07d52fbd074155a985588539d1f532ae1a9182b05041198c93cd3bdfb340d5280860f0c0abf028a8b7c0b55c9aa983e3a70e5425390255386c433171769b1ed3311c754d0451f349dd7cd9589ce5ded472a73371d4f4a02677ce6c0605050505ddb933fa2015044d79a9228a4934499fe32f5d5771b1429a329af34b9dd441fd3cc8a3b8cd97bae236e1361f5fa9122528ca6a742364481097c6c3863e83e80d44314ae97f24034c21dcdda1b7684d027ff83b3d146015cc04d826fe02d440b1d70fb91a78355f8b3fa80b80377e0ff6a633b88ce8232957bcaccfcfea212a7632399dcc41a5514606be3ff48f1f87a40fe66b0f5f4a7dcd1d0c5631f7847f869771e79c139226e9739c3422b19063c1e17090a036fc18db4ec76243afea9b60ec72523b5055faf93f02aa71554f9973d6e0ab6a5b0b44cdce594f1c08aabcca8c325f9b92cd06a276e55560155877ea8477be5b619c22a88a6fe241c5825671a7c6927d24a53404898afcacba055156b8379f347fd4cd975bd4cfabdc6e5d2b6ef3e1b8f3e7d756dcf9f3bd8a3fb7c324cec7c13393bad684c65544612da6ba4d216610f793b935f08a096ac70b2adff95feac6eb239f986f7c24442e50a2b8aa003db46125b2da38c2fdda89e6644b116df3c16c3d4666701b6825063789fbc9780aaa4ca6f89aa9b6a03244c123d0623fffea4e6e79307bf213cff51462d863cf2b2a4fa8ee04edce1188e215c686ecc4a81db12098213333d727b5bb9b075a4e0c53d2bf28d54107a8468d393ab80d5f2918041c85d99c2c4e90a81bbdd839295e161887e03e10830b4c8c1f18218740c500aa720835a057d890c17db97c850d297774f90a1b4a18418b9bec4c321d17449d7115fd7adcf8f165fe8377dac89e64f624c3bb83cf9d94ba0d845235339e4926422168d7f5542c503108e96bbfbd4eab590db400d6d095fa555335fdbbfdbc5a83c6f0bb9b7b98377b0cc3be31cf7e0713f54b5d8ca35c71ef9cf5f961c57d8e675d0f06395035ceea78a0726bda689d00d1d9d318994da5eb73520b600da5628c99fde0cbd3c8fa6ccdd1906d4fe9e8475d6454fc4c067a3f9f9b3d5b0fc69a5e4a0b0002e6e3a108bbcc651513ae818529a7f90f4fcb8fefe3a7d89dda9e6a80ef5f24beb44aac1225fed002271afa29e9a1dd81a8f927cdbb93664f0c900f5fd3ac0f0bfe0ff195a4a43d69f37f569b3d6996071ef9dbfc9fd5cf8acad0cb27fd977a5e916c0e0e2719fae989483ffdb6bc92160d2a27227de9f7a5f644447bfad4e2405fb35709159ef8a45772d2de2a89f674fd4923d9d365315b44c6f7374285f6c045d7536b011f08e143fbc3e8e147ab0344cd6738e1977d0ff05e492ef673aa21f28c3ebeb4cd8a3edba44ada096cdb411035e7d7a021834ef4e5a9066a79e49f78e25fb6ab448e75bf168aa27e9095e33a6a8450b975f97e70680a54f52a0668c40e75997250bfd8795abc15523cb1c216bb16b819cc6cb16301005bec00a095a07e94852d7633a4245ad862b74266a57e3176b6f542282b958b6e527f1b680713ea4763a782f6248a4381414d1cd58437c1638bdd8e2b3b29177d618b9d8c1604510d3482fa511f5bec4edd35907b4fdc6b92da62a7e3ceae9d74fdc45103a0976d2088f214aeb4295cc805811c6f95d413d032cd4308614321681042c834d43d18a78410324fe9ef90f414fecd5950598a00ca08a10cf54233cac0fae95fe1cd1ea39cd7d636878e085c18c39ecc21810bbf3df93206870bbf2b506fec16a31c07cc3108eb978fd3598860ea7672351216da404848a1ad0d40b91f674983d7b8bddd0b060927eef5f17a0ac4bd9c105da6a93a228b4d76a3e988a10bb3d48f7d84509531704be2800563a8e1a40652ca78c14a422c57c600ca957fd9082f74d03ae204373ebd62239ab1e2c65cf9b4827165cb881604910f85145bdbcc98429314dcf8728bfad53bd345577e943b50a144171f8001129240c51cc2054f5c90c78d50dc184d26d642064a6c37625f98da848171c42cc2093542965611683c2122cb101ae04887208a39d064060d40d1c0086628424803538c98818829401b116f6ad305e594725e39c38b39e7dc1202477114da84a3e496275cba90e58c222967248104356bc2fd6a3555982b50d0407d31a668c1779b1391f9e3c49dcf949a482e9f753a5c10051fcb16edf7e180848beecbe700affc972e076c2bba97d5b1a4c2fbc5e81c14a8327dcc8dff2a0e1badd501deecbf1b1c94dea875c441b9f061daa81f5774e18f9ec3c238d9c3e7cc701b9787cf157164b88d6ba5aebe465f7244b08ff2230dd84986f8d8c7c7e1e5a37cb12719220ef24b2f5febad748a5648e9e5cba7f44b5db51f0feea8e3a12f673fbad9af9ab6a2cb5a6f10420cc67252380a72562e8c10890a3f76f386b6606e6ae5b2501ac08c4a9d97e7cb37995e4e8c820f63fc669c1e1a4aa9fe1fe58860d76d756bea72300d7cd9e948d598dca66e9c05f5fbd44d0e8cd2f6d0d9f5cf201bb186eec052fd53eeeeee5f5cf525821604868a6a6aa3eae0bfa30815a3d79411fa476b819fab83ef284265efafd4abc0a1bf01f601ff45d32e3f64557740882ea264546a5ffe6b630cbb54aa948c6114fc43328e0a17c20ba1055282cbead800023f16b2018a0f3fe38244185a2be300c13832e3867037da8c4a85973929d9cbeb7229d910fa57f7f98df2e3d55bb48b034c03bfb92119957a5d08c4ae99465a23eec5ef537c5e65ef2ca86e84280650b2930cf179e2cf3dfd4cc3256a0ee318b98171e2c36f00ff507259f500154ca6528961b43e4c036b9ca480b88d3b61038cbae3dfe3957d270b1620687606b59f4f1e1f5a254a564aa215b2e255bf9351bb655ba8e3a2b2ad1d79a87340c6500ef291c02d5baeb4523cb2582b0821dcb265e55bb6a8608d1ca4c86732ae14fe359aebe118e0459ac96032c84083e4af792785452507ffa692833fbb3d11e9ebfdec3fdd16883aa51b5f23c9e719165c22e5b4532d7d7ada81d60451713eb5a79db9a24fbf57d4e12ba1d683a808df2f7b0351d1e1f717f16739e40eab10c10c6a53aa5258f2990196158b48cb8af6546415fbfbfbe10f90f084751b0a1ad30cd1a8db44d88d80160eb2dc1c97afb0c1ba4360528426975b4320e372d1e5161945b74504a13b4b77be469acf3ebda2fed12dad19a36234da229ee7d8bb5dd2abeca36522c40156d803f52a7b13f6d967ba41035a1d889ad9d78c7105d9a11f29fc48bf5f89126a7b6ac66022fafe45a875ab258916fad7f350eb4385c7bfffb2ed478022d03750901decb52c5a9f5e65dc8e0645a3cfd9688b5809a201f58abe6619a278a0f56122c40156f4817a757db44b7a757d0d1995fef5f1a137478fa31ddabbd5a27fd9d30eed55967daf32eb43c5065e3151424549665b6360581a0b44c167ff22bd62615da06e50e7e5161144440c0115911842689d9999bd2111124a184550462a0b8d67be54b4ff10de80c6348a20d283a296106d04418408c804d41aa24882c0d426178470c6d0d51982e8679ec0c48d975b432cb9dfa7588fb385c6333836f84acbae8ecbb0e6d0f12e36bbbd020f6a578710be91d9f5ecb8c745468ada4a670f59da9caf75bde209ffe32e43adf3558a21b7a062d6870a8ff6d9fb68f2a177d2c8e415e43c2baa7dbfd8d14752b677ae48af36ebf3c34ab3b36b2b3d05a2e0639d110aa9b568d4af592c0a37eb2c6d0438b6ff622ebffc41ff9b5c4b9bbd69cde2308dffe7c275fe991856997ef20fb9b10d86b33d7f896db4cc740056298027c09effd55120870ab00f7f78861ad79f70dbfb180ad75f07721bd75b88eb708b3567d4ecd93d6e48f6dab5c50ede03f00eaeeb34ca3921432e4ec80e8d456e988d8614512087f6e17f791a5a9e70fd75988debef5bb2e06b00ce0895c2fdeca400d115f7b2930254571ceb466b290bea47a9e6970d349ee12e8fa3e27677e20a4854f8adc58f85e4e7b88c3d76c73d2e6af721349ef99ca734b3ec295da59b7094f7138ef215a8807d785b7fbe5c109bebdbe569e116f5f3a12952aef721efc26da277e143dd41f01f541e5a87fee14a149181eebef19477468eb837c56de077fcfe243a40d5cc525d4d5a0a520a1da6aab8d7c409fecf8516f62a767de7f714f7fa79056d80ab695700aa2d5d8ad1ec2b01b48a95c8821b072251e5f54fa42083fab5909523f0fd752000a7e00d3318eef90d91bed31eb9611a2f2280d70057974d419415586ab75a0868470e2a7f771087304608234c615829478e48c1a85f4f99d21e1dbe13582ea0ae7b8eeb5fe93a659c78994bdcd59c91011e3a08104ce3ef4c7383f3fd9b4c371815f5bbbb3bfe8fec2b0dcd538c43baf33dc639ed29cae799ab537c25d7f34b5b43ff7c1e2554a2e5e1bf5e49ffbc94cc1d58d47e36991c06acb5e646a0ea9a454a8c1cb9809309b08a7610377e43a14d8b2660e4889306e2099742f1208a7d84d11c88da99445ad48f8b8cb8cd478f40c06dba280235bfe61bc7385ff64def97fd67d967178bf1bd0dc6a4c5987dcc3629a1d45ed3ec69085fcdd69c51a9f63f37a319ed7a80f7b25d8415282cb8b204145ba4b18a9e8a25d0e0ddfa87774b54e9efb90725848e43fc1901bca07aeec1a4b5a834ae9574410c15d1000000004314000020100a86c421b1602c1e95cbc2de0114000a8ba0447e529849a32008529842c610600c2080803100032033325b05e52e2b6ac05478bf273b1cc876a547901d81ba146452eef7bc0a948c6ed2dea62f4c9784d52eed030910924114fa59e0de1db03f7be46813a14b0483308478a33da0abdd88f57483bd0929767d894aa9d6a74997a1d1efdf20adb8322ff4b9f2db32957ea26f2727881446ec4a0366981f409e52a16cba27c834a97f45c2e8d2266ddfe35961756aafff73427e714d0be498bc34156c2712b34a8c19376272f61ccbb04846d1069abe353cffe41950d37bd97b971f906e73df893077e4af3278a08a15d69543ee8a40d25557e39c1447ae6f27d6fa8623ded381c5db8e2645ed5362123465a0da19a66d735cd0901b33250d21d3a40c601e869e3a9b7e400274800cf624a71aa248b5af2ddda3104e8262d332a7d4534f1d695510b5435dfecd623eec499ca60a19a64b673854e7e8b8351a8c1ecb49f3ec57b9cfcf6218b3142dc652067ee3018ee3f99e4bef8a6bd3149fd698085d9b26191563177429c4204ba735ae485996d66c534f02d8bea5a5f99ebf4df263bed1a7ea3db6ddcb779e5035886f68f9ad01e7e6a411591c11a285e9d386e9b95fe3849b3b131296689b60c7047fd6af67300e35afd4afdc8b1af0cc57d479aaa5bcc3b0495a6ebb1a4dee9fbba915a5e6b9a7b7a83e7ca942115f6a4c7636452c6cce9b2d3121d0873852869c1acea97138132297234ad9f71a7036ed93dce4a3d06876107bdddea8a2497b7a103032e60360b535ed44e2f434a3f286c8db3040a7724415e7855431fd9d2550691537de0b6b9ac00cf6060fe1dd1914837aff900d09e14cbf9b34ce17ad80f44f4cc1c7bfecd97eb4ccf1e734863287b6749e0a597b3217d375eea163f35075453223b0ad0463ef194305c5e3ae9d5d9bfb431a0b34fc277c567413af7ad0516f20f7526b81b41c14f0285746e9244f91818bdf417f1fd299aaa46dce45ec861de8b6ecc22c1f9bb604676a3429910131b10bb7fb15b3b27f806bcdd4dc9918ab7e5c3bcc653d35625686ca8a00dae6407f0e3abf8444079703b0dc69b0aebec2138ed0e46f218f23ed8fe9337ccc1d3174d3f22d25120b373ebfb55aaa7927d9e457a984be67937bd4400b158c16a7582a3285187737220644d1674744542e2491a3f12e3e2c208b0c3e6a31cdfdb8db67d6d421b0db3c3561a3deaa9b3300382a6375739025324c9f99e14007fa8255f8a775a6cd7b7ba1ed1430fd3e025ffae9914960d95dc21732ccbe6af91a7d969d7422103823d92b876a54989366723d29155b1b652a4d0713868417e99da2230a84b62b9ffa95df646bf920c6f5a5a209df264518f62e82fd04b877ec21c699d05a8fedd529a529a45777e211905de71d67dad532308ec29c450f9704cfef7205cc1d5b01fabdb8235f93c6b229c1b0ecd0316a9a37c2b468962deb93a00266bd779b973fb622e9455b014f10e126fde906222f62ed50787f916944f8b3c326ebb16f97c21ef00c3a881b683c196137cd1dd2181a9b61d00cade4d67256ab6c36811520dc8e8f598eac6b96bfa24807d0a526715456ad9dd5392e45d278fa52db44729ca53d27f8c746fdd628e7680b1ac639c0b4479ea1832dddffe9310f7cafcde26b1ce83ac0aba9fefde4f20bdd4a697e5ad76b4658292129e9aa3cf3a3c5e64808cd35d65d1ff1831043dfbf4e30da8f62e853e320e2ebaf6b4074bdadb306c5de1c6450baf472f59d1f579acf9cb60c940737e52f9529d9d54980e634f15b3732c56dc00204014a399d294e26a748e514f939650c25c9e4833f71bd3294c0602053a530d90abefd540f85f5e707211f476e865f51315c05ff6706376ac6b493cfbca1cd613bb8704c1c043003fc100f0b0c98d6ebde89a300ac9ff3cb4d9e179da4e307e3564725bfa5470c94d164049b5828ff385689b94f3f892c0f8a4de70594968634ea62f95b603392e10f934458131cc2829fb71b91d5ab7cc5ba8fdb090bcd6462d6d6b7112c209022d00c703b61ca3f70769d25dd7ec93c91aa1a3aa08b1fc2618dcf4bfcc7614dd6968549b6da939444e589d17260dca0d9defb984bd573771752bbdcbdeb245fa129d25aabf4e755a6d2ffe4a6070ead45120df5eb2ecee3b1116a37fd61d0bde355392efaed4f917cc8029f80aca4a44bab6f04824e7de31648a6a7f1bf33665d0fc8547a8d0cd6d5ce61e82974da717122f615cef89cda9cd04100a3f4fa2fc88e870b2d10d7a4ae535e15adaf48b6941a754789547fa6a793c16fcf49acc54866c396dd637c756f06d458caaf97b08192b89a957564ace6fff982c7a17a2e31c0e4393eaa2db87b007be308595948fcc286d4990731ef073d9cb7a3785dc08ee79f883b352a2f98d000978449cf4f78fd59966e09315f00af3fc7f9b408bbfd74fc03ae091c8e1ac83859f9efa1d1f78f1e10db9accba489de6a94231165a627439d5e81455eb98cfd404f86fe605e103c650133029087cbd2aef653dce4d82f41264787f5bc94d02006231e10dfb31802e9d52fb3d96277c0add8219480b9ec5f6b7a21d674f51b46d88d0354a802d758d6d430bdc4d9050da6b49b7f4b30ac0b552c13985651d3339aa0c309281050b4ac8cfea394236cc0da609e7e904b2159195e69959fe560b265d7682d212ed3065409136028c1381a0a6296e0b1c7c812f55d46b07b0fea6a3c346c3c451c03b24b260f8fef63aa97325c0246fd5ef1209533ef63d32cfcb5606d063cbed33632929786041d91eb23c1b6ce4f8538f013c0cd045ac3a21e793ff965ec171bd0a0537e42b9642b34c221238dac2a9bb72073ef45cf5f82a757abd14608ea9922b491ad78ba3bb9fc7405c6077e5c40193d65d9d5ff7e750ee19d2e361655c4e5dcdc4e5f09357e400891556e5ecb61c11823acb329a7ae7e864e5c6c8c23d75f74b9b5ab47844fd31d2aa0307b2dbee95a1d4c53cd2df7de0159c3283ed866c9232018ee686577dd0adadac3724742074a9a5f37a41fab171400a989cfd0c878270414f62927f78d20875e2028ce5acd0a66db899a666ba5aa361de96b9da3f26c5baa4cecb276a4e5b79978f005b3c25b44f3cb2edaca9b53fb08fc9e1084eab2d037ceca42956fec090a18a154383bed00d6a7d03ccde11317107e09c2351e99af5eea103af304365ec0f94b65a30f7d228c5bf72a36afd4c24c1efc99419f3a0c0fe5db33dd2358f60f78a87c52402324e1dac9722d94b5dc62f7543d5a09e03dc74cb3ddabe0228c297a720f54a740a663202a68d0e04d1367602598a391c92ff047c8d34f4446f95dc3bb60e0e5b86a49ce615ff5df72bb576a04f11d13b706aac6f23f4c81e540d31e5c0cbed861ed42e1b2a948a2111fe46a8535d1f168f9de235ca0c1807d8cc2dd870b0705520a0fc511a2fe5d442972e5d88a1ff98e7965ac31ca22d3ad1ab59b99b12703389017d6c1ccfe2df1abfa3da2c94e9e106b9bd9b64d112e9a703b389c8b3c9170ffd7ba022d5255ba58b040b37b066a79a934e97b8c14e99cc02c64d5de8051d715edc14114f4821039c4a7103750fab7d994471a32b9934018ed0c73b1637cbdbfa5ac8276e26179f5a8826018534ef1b93aaf04b00ea485c9d93accbeb24b6854fa6703077bfafdc655c67cc7565c94a39ce94922c5d64e5ba933bbdc1727df3818fda7d1cca32445f04abcf1be64a10f3d70a47026c02201fa35cec8c5692b88ea2ebcb178a51568d406e51b3a418c592a246fad460028ac0519be451405a592bdd065125d37818f459c1679adefb20963759cda88b6f52afdc628c9f1bdda3471d5b02344d492da4a48a83befa10ef1b8944782701b3c16360662ebbdaa6564130847ac848941251c5b41301c42a43d12e0c6f3defb328aaf8287fc051846758c866c5420f50325ce3a81b8c038780f6f81f11b83250b1ed750f0d2732f332abab1f854f780c34ec4af3db42b048ad3377828785e680d43e4da611d579e97de4b8b2c7c7f8e4caefea89e321b5fe868c617e68dc3ad178bacdac9c04a71a9f4f6e0005d1755752d04bb84a239b5ff2cd50865596899ca1cf3e5fe2238ad0d87e60f9316e150c8d873b08f7a08cc86576b2c79d5acc09b8adb4009c6528a54041815ad12a0042d1a7f5e3dda474554576152339e9ad1faf866494b9dadb37ced17c7c4d0ed7c8ada71d3202246697637015ce7c71d3bd6f1325abf119eaf2fef79e2c15c9fa7325a1a638fbd5028136684fc7e76092aa31c3f3550255fc22c9f1c89817236b743bfb573262098a462b22a4596de23e096f79956d744e9026aecdd18fe05af37ca753c6136534ab3de739f19054798923a4bedc1984f5e92e18a090ade04e7c8e8d41171e32d38e41514000bf47d3b57a52a07405eda8a9ae0bb5f2f329467fb89c10164176e2df92ac84c578c384f9bed282e0b07e3e5a46505e2d0f8e6ef0afda3d054e7e86908b1be913253285f1115b4e9931aa0f7c11823936d2cac2d05857e0b4bc0f558f2523a93f02dca963fb21a3eac080c54cda404946b72f727cc8fc6990d624b86f2d92ebc50d73eff95e6f3d6b9774a943e9c42f027669b6198a80fac4bcbb12b6df2fa333fa408dcbaef4016c3860b18274903728e23079b04d026968e5a3a07282190b052f0fcfc130e0d433a8eb485c318bf20e6d88ab6205521991bbe3adb22fe3c67eb88676c5fad8b9b3eb4a4fd405bdeade12df9fe364edc2114449d2620257ae4c46d534e2a41e5d09707e814995c550c7038d47c7249db13c408c308f782bf85f55d97f897e37a61e813f28e73824720d7517e9a17cd5320f8edb31ed5980ce787d3bc4c490b1067caf6c20448176731f37f323cc8a1457c04f7f26043a3f9d1b8d814e3c62b7c454b36d158da504addd16639b109602714fa48cbd1059970e4b7a2d4cd4e07ea37dfdf7373e1a18fc6a9d5b31497adb38cdf641a8837ae31fa397d79a303731f4ead154cc48aca45f0bffcd6d64684dd7dbaf5c7b87b6a04aaf049400d48c1a297bdf2621252653aa9e6638a24d39c06fbcf75ec2f87d72b15614142d422db44cfeeb8a15c73890a5b597664220c451cb0524579543bff334149951337c918623c4bd5a4b4f2327843ce48cfd78e24b716f18e2dea98361256ef990714f5db2f767dc5343ffb88ebe8f7861d07c9bbcdb843b66bc696174c421a27bb6e98b1b114fb515bec98854ac57d9040de57e57130816135731b67295d3923796e16aad075132da0947464dd314b4b2646d4e2ff48089b4fea90f0461d6b4cbfd8100e64523a02773ce0a3fab64e6955b2dc76ed4eb52e7231cb328c714bbe4ffc9caec215593343167eca95d80de326b113b0f1352add7b31d634103b7100469be7264a03e31a9e18a44eb0432510b6ebc53bad80323f531a8108c7accc67da2c573fce609ee4bd78cce03f17c6e24a31f37f2594b5d1ba0d4b573b1a4341635da765363f2840c748850c44c5abe535e0cafafa284cdd83facf9ea77ab4312dcfbe7079430c314c669efc11fa9730d3cafdb5a700bf5c1dc58443b76d2f1ef700f9935a57321f382e44e6b92c3b700ccfa43e6b9c4caafe48b19672062a126e26f3092168983a888cceb61799fdcf46b207075d13fdce31ac66a0905b6bc7fe3626d19a51b461b3a6887be4c55ef37f25a431daaedbdba49a0b14e9bc0ce4314c2dde4a2f7e8db506d6655a851ee2f2c350a78a5046b25dbfc326643802370ece24a4e445d7deb158c71a9bcbb02e6e180c00fb9eb3859c676d9bfb5e6415e93505454adaed082eb2810f364a619b37a69daad3431e0cc185d5fd28294b4e01ceda81d819f527f032771e97324cc8c94387aa6b67617ad4cfacf611eca215866d6355b14a6013cb2dea0c203d685bb19a6ee84517863e21c9c4ffbe2eada1ddad0430cffc8b49a6f118ebc3cf73bf846dca495129d3be32f45be73d2b126c500fd6e4fac65e5f9c7ae21d922970e43fdb2c32d507c99e60b2d67a5efcc1125302bf2dfc6217123bfe65005d9055ca9659c0fe162ac480015502b28d1fa26fa605e6a1c409096c70e0027cd9d214c8d5c82b8ebcb06cc80c05ad7e8e18cef5974e9f07032f889f8656e7a8187146f73911058b549f4d673f378e07be6dcf456db0f6168fd51fb2916d6081703634833e860f601737315c6ba830b14a3212b7e30d3b7d9b7dd7ab340037b2a9a60715e175acd103c6067dce1cb6e65127357410a9f6bc4dab2980c3bb30a911623d193d1be1162243e4447ad47455db0e3eb7e036f1ee08bc825ff2f43deed1791a4c9484525e3f4feeb73cf85a3cab289544c588f452e74beb10ab51bde1d8cdf162cbe246fd0a4958dd75713cccb3ccf6027f71144df0263c46fd652f25a15c81fec0739798a593dcdddd56db573a0aebc1556b45da8f826de5bcbf40b3760f6c8ae86c870c034fd72dc27333da0c62e04b858c1b0bc2e04896a7edb1bc9716f065f681e97724d7b653f8952b3ef9dab0fcdc95709064aa66041c19153ddb10183132ef5700c1068ec7669da674b56f3ee2111fb33e8d02ee44f8fa49353011cb0ecb865e52d0116480b9673d063f9ca93d33cc429259b33dc6ceac1d09e8bd113e80957871b327b9da37c9f1a6eb120b46ff416836669400c587eb62c3762c35744c22494c6c97c0447ca67b6e60c7ce7aa7444046e40849b290bc8b37208c395251a26e843977eb2fdf64a9cff1aad991be60d5a17d1f74248813c77863f37420065dc4886ff338bd69cdb46346e2d5107b014f6ab990e7169760cb9b9aa42a19f6428ec8fc640a8978b1564427dfae96f63602dd2646a14efb2b1bc191d364bb0c8ef68f1301de8e2edd98260a2a98034a2606dc383fb36e208524e19d799c18a913ab05ddce6e89915e29a26df4be867b87379d22af9b0b60d54a7799782ca38a1f390f5da577087def7a70b9b501729ca66a08e7770fa695aa0e0789415d7e6dc901ca6b75d769a52a86bb42d8de711fb3b83c4931f07638bccbc113c2b5de1126a45d0ef455427a22d79c5c22876cec885b88e80e40f6dbe3cb852057e0610bee421d5b02ff0f956a1a027ce331d581190187118a7988e594c16429df372c76704bd81951bcbc5e109fc56336b71d4caf960808092b06d3bf7301b4839954998e16f5924996e79cb5290c81b96a34d6e067f894cadafcbd2e2ca672cf96352e6064ab72cd3c7be6aaf35a9896b76ce81ec1afa927a30c2562bf7982aae4fde3ee893ae1b137d9c01cf19621788ceda0073592ea93b9dbcd4eb9f8697bd6716c6b3a9cb9efe994f1924f8306c34680f71042b0804f4dc0f600721efdea709803520bb08bea44d79e0aae25534d2e58ab3e564ed356b5a7c4bae03fb3e8683e0e507b37f7e9f1008ff0384017ea1ff45f2d46b725c10ac1b457e8c0dbc245d3b630eeaa26e7177c92c0d3b02c7a364e3ff33bb0db938f51de7e8e5933ad8ccb64613246d12899651599b2d35dda96e99a179bb4b15acb1a3508d1f7b556408691c5f169123abd9c66237443d96f9d4d148bf5c199cf283b5db45b0e7183e884c43865c7f3567d2f7e937198ef87a6266697e3daee88a68e2d374eb7b4636acc77b9e7a8f3cdb7a42fb43b1d531b2011d8aab383c5ed3def1059c01245a681efb10486e94570191376bdc20d663188519153dd063dfab66bbd551373c0672a3d9487d029634cabc5876413b4c7785c51e8ae70dc11f050e3b1a64d02a683094124bf966628b8e068390a815f7f79358729a59ce44697a9c11d2a43a5cf1572287d3835614391608cbefedccfcc730b17c489ce03c5d9954f2f7a24a11236a346feb1d3f3250204fa0eed4e8e8f45bc8e8ba9b10aaf9cb8c086137a75589328d3657bcd94055b85de9971b430508f1f824e7b8fd1e969caa6acc22aa23fb2e904044239d1779a0bccc0f6525acb21e760b624ffe5a645388865b7c5db599d6096723f1e0a11a8109a734ee1f21e84058bce70a939426bee69a1026111c802593595c890746b195c18cd42acf43986405f82389520df7eb85605b81c3d5b4516d771f22a6a89824fb651eba0a60b624c77ccd50a1249b6ad692183f25917c96e447cb60122b5b911c774692130347d8deddf74d9281a088b929047ffd07fddc94f6f59c8a249a7d0137f038bc0c7ddb825a6351636ab377a54217c148ea145fc2545f779b4181b8403fa22a92389685c9a8542682534c26bf4a1847962bfddd31fabba703c94619ad48e4c982d5e71643cef7e1259a7109d9e5a7d281a0ebc4347120a4244192985f3a5ca245e0f8ae86700ed946f00a02599e9bdd1d5dd3be72c471b0f3074a15461616ad8f8048508354b727220b2959104d84b80185b159302858c7a139d2b17d0a32c9594f4207ade5b51ca0e30eb67400cc8e85b50a5f28feef9b5be983bb277e40c09fa40520957205cbd7f3e993383b518d2eac89c107aa03299086ab82c94002590122d423526b08d0e6fdae4b4b2c7ed2b83da3428fcd8984030eb5bfa2a093a9203b6954ea25cc151d73c182564d38022c89a43f236e86995f82b923dc5ebdb0402826c969d42fca782b95fe01ed3379a50239446922317e67563af0033351bf28416815746cebc787ba436d66ba23a3d0308a2346ee384b94bb48ba865127928b9d220b48c97efdca93fae75e1433df6f9802bcd50becb760302e69177285054448c61ee5f76b9d570f9066220534a11d86deeb35f7ee18b9d82a82e06721c1dff1fe039cf0faad120edb8aeddaae051777bf11aa57be06d74615d0772cd1783234d8fdadb3743057f6422e6ad6125ed2292834d149219f63e05f7cf258f0c8f5e5148409116ab83d7f731cf02a553f81887b3903eb4fab00aeebeca8cd29366ecb3c91580ea15adb83aa02e02e07184df61ef5f15985e1ac6db9d976616ac85673fb471c2eab814a2d23c4f83549c1ce7c0d8dfbe67789fa2b0b09ddbb01ec673e709059306244e9db32a7cd0f4f9f2cd4658c68a1fdd8e6010e1d026bce66ab451045e18f861c0735c3a60d6f2bb220111e90223f5125166e66282b72db65c4f4f581eaaa7f2b79fa23e0a33bfb27f561346031fb0812a2a1c6155af99e406a80c33baaff903441c69d96f0a3904c56c7e35ea3901fe440d13c6716121fa25d7e49448a88157eba6f650d50e02ad89d0e8dc02ab765488e049a1e701afb1061de9b4390aa12428020f21bd9a0a23f1b73bcd8de32a4d076c4ed6d0edc60c52fbc1cb0c4cc7850f1d10755faed489edc0b925868d0981540afbe5ba5487bc28d6ded347b0d0a0137d4732e5cf996161685018e3c7d2b900330f2667e9a82bbd074b4ce64bb85e6f2f3e28785e6b0e2b99a4785c3bf403eca880bc787965b5079e63f5025e4c4b3cb3ca4d7dd53b4c30c0322b1370ce06fcf188aa477bdda064c09cd63ccca775558d45c9d127542f3b63134b80f82a53b75091b826dd0d446feaf9e97eafbdff7b7eabd33366b5310103c652141d439f577892f5d0eb154eecc3ade4eb8ad9c26eb314d8ea205e12d17077b752e21292bd69a9e3a5ba9b2a786956328eac0d35432dcab5b009d03d35f7a34fe39c42fa9e49d5763a734e8b0d3f9539d1bd0c3288bd6c26c4d6a7c202286ccf43145d921d206c7206234557603067703d32c5257bef912083ccfbaac09bb3846417adb8dd823a047e19bb001633d6591ff6565caea25db2121e10ab7a7b25ce6b28b05b821eb41b5d1ad819fe036fa53e8817df628b4b7681810fa8dd9f2eeb6197ee37f12dabe44791c2063ce607c874e79683fd441243d54144fd2a40475b772154dbb2be2330df1fff6db04ffb82c39c8bce50ccead992c56c6f09dc36197221b7fef7ea2bea65b7206237d32430578188a4ca203f7b1ba94b012d16bcb1485d754912f53749c8d760aecc70fd7f8a35b346a6efb530aca2d1a7bfafc3404170650429b07f09f72140ae078798680edd8071c8995d0cb9796a691907975b6ba8168d7e9973c287397dfa401e8ad47bade0eeab76fa47a102e707c147d960aa870f99f494c4143e571ccbdf32f79cf6134187b3170f5618ce44d5be290d31d9a19738319a00e66d451987c1acb5bf2445fb02b5771193aecdcb086e1281e6c15c8c13c7f8b9bddf936d8ba73c41335b3807f493a4e581e8b7f8b066c6405e0562d0f9737014be10faf2b3f36dd0fac95ff0022083e00425cb96bef9b6477dca946fe1466c367662aac4e83c2708b9ebc283e4de28d92316d62d335ea005fd531c96dc34d10e36af8e8b3d8b6a7912a30377c8ef8d0b7fa914b95ade0855ef8457a313ad35bac31ad48059abda2ffb4895598d1ebc2bf805627f193a4b2bc61f2280fb75aa655b0e427a14a0e79abd5ff2344c24478885eedfffd461216c5627c268089e8b5a16a0e5a41027543e0fa31480c212ec46cda9dd4797edad82c9fbf385825214d9331362824742a45970dfe90b3a21d9ea124ec478f86011689493cfec428f9e78477c42340c207ccfd9088861f9897815185850117b8fa94e9ca4b8684746816948d47485dd40708bba1c218e0da74801c05b190e0412c20eded8216d4871d6a4b869e65a1ae2462f1ff983a71b757c8c42a8dd375130c6a32121d22bda395dceadca9d2bbbf0677efb43fa0ded84bb0f40aba920317f0436b35f96c0d76ac9be17bb87886d4c745cfd416c4e1b10aa370ee30174a760ea796a2d265af60eae5f6a6245bf28a8c3be279d4a1781e7e1893158f133ebf1d0d7460817f465765a0e545c8d61b0d2547cc023e62ad2ee741798cdaa218bd753b6595c6076c8d1f0da89589ec7b07f3671d098a0479b70040fbf3437cbbb81b60433434f2795328a0e15f58aa42a61654e29332cfe10d6f25efc1b5d40c0520b94344d9e463a501b9393e6cec1fef15a55807dc181bd0b75faf9d0324c9c216ff41813fd617de51c93583ec0123982bf6c1749db84152357d2ea545087d48b89a033f4f54a8372d4ab56ce3b1ac450d81f69053ef372d379a1c7a0540ac7a24114711e08f85ead3870bd92d92db746df7cd7ba24bc6ac19eb8e1a08caffdeca19502f4c90337077113f211db1055bc0dde8fbd8d5be02aed29fc06962e91aac9dd3d8858374f40dc06db90f9a9e588e6f6fd90e20b9063e57183cb544e726ec5a94a02839308859f2cc3a609639647c80e81b0ce86376bb8b1085080f705295010f1d3e3912634f6b603d158acba7abf7a9f815e919988e16aa9020e927da69bd4adeea9afc705d5735e81e5adbf47643e88f9629a46b3971299bedbf2e05d1c0ec7d4e7c3219b256500df450d9042c2b2db7fbcaca9fbf282514d673b03514b03c706504d281c1fb9af02419aae94e1dae558341596867ad56a2e0d3a98169499b61e9c095be1ca01b09be153adc014935b2ad29b40ccb45f52c2aa089d9288f5409038acb2094078045267b96bc6596e498ff730a34f6a4fa6e2c3828de795c649a2866029e009382fec8a0d92e90da0cda6c2b84992ff75dc7be6b8e5f39be7c1ad5c4fd4ac5704bde5a2a0ed77edb3cc47779770ff44ac4f7be53e739bd0799a420f46217d1e6a9fcf876111c796708b2a508b37088aaa3975ca087a05ae7c259fcec9d83c3153d1f8f5eea9f17a8d6412950c45c04e91c8738793e8e21832d7a2a2b52755452dd17b53b1520d6868a7119f94b56ec3bf9ec27754e1f8ec30ee56eca4bdc4009a60f05d3618ebec78d266e4da293bbec28b05999fa9cbc8abf8c2a95634d1996c1745d8654e0580d41d48765eef94679790861f22f428872c64180283038dc0c741573e28686907140df7d5e299e6c5b8a2ef05ac1ffd1950ec858bf4780ccca2bdf06b42c20c51df415976a08fdb1dedb0fd7d021e3e1c4b2dcc5d5b5d77a24e671260a4237b29981e0a5c43558a1b56e636f97ff5169966a2ef2282a1ee075b6e00431a936e130e9a820a8d9ae34191240e7102eb753c8263f83afcfe1624b4065d3cdebf60c476c1b852155f6f8fcc3b2bafc64d9382d1cbd11d6e59c36f1272adc52ce743aa3c3d9c96b99be2f071e2704b32291bd74a80c2ca9ea9a26e25475cd658f864678efffe1ff456d9276370dc58315333e6096c1f3ffc30a1c4159a64c8591a4b997c24c3a32ce7c1bdfe84eaec3a07d0b7b6fbb8e374864cb49bfc3ade10d9babc5fafe88279ba5ddb805325d88d7bda0e4f229cf694e2a2187f894df0fe1465bfa997d8e10c66a35ccac58dedf0d3a0010b24e6a2c12867e83edcad13cf7663ce119bb8d48c0c977e3319fce73a6d3fb6e9b10a7fd9893e3d5d236c9cb03b0b0ed3680404075212903fbb664189ab5b9d3c5489349dd64a81dba502dffb2f9ffe2e171b36f98eabe52934f7d58d4a893da075e9cfb61d7f80d53668f764bbdbb2a4b0822df2df6beb583810601d36bc0c180e3683e3cbee52cb4ded0e4587c4e86d9237709c9e2c93c93e133136c4e3188bf25b8665368e489bd87c0e407faf38ed0f8f526d25d073aee60fd01071defb843bc933eaa99d4c1a5bff5a650ec5143ecd050a360f9e75cddb7f711fbba8ffbd2df4e509f0d2614d0ef85602262ee633725de6d102101ef6d8080c0fcbea500ea1fee0f981b53ffd6f77b735b2a5522b212d201f8a7fbd79081ce748a4f95779db0aef77eedc3afe6fba12fe1a6414c2f0ee5133726827bd1dd2b788f759cddf5b215878a2cb3aad2d420a6574352d733d389c02d19788e4bb9958bde5cb86dfcad33c24d195d56728b15614ea4a4553e290606bc8f0103ff3eef8b7dabbf1cdeb0db1273f37de761261bd966393628017534dccc4f3204588bfbc37760dc4a263944fc2b35a787acc4f6c6e912c458a08ce238ca2e104b6f8d7e7d43dc03bf26e3ace8ea7170e18a55256cd694ab3f32a3d838351ec47add1443284f26f0f13656efdeb73ebb211cb726b28c5f1c6519193212b8dbc8042873525d136da06596a3f4cfed931766ee502e6a1968b5ad5fae3e23f41aa4eb59ddbdaf57b75606eac5d2d8cc14adc5be57b75738d49248e2e611e8e5d88034b2aff775df9f7d36f132dc2cd385089ac4e61c331d30d995144211ff08eb37b85f8aba618c6d3102971f07c0dda6646de24e3f92fa323a029611f0b4f9a5ccd6e14c1429e4e10948eeae99f1b40e460a17e29cad00a11d88f1a4fe7055e0131a7b2091cebd4d2cf1e0c08264fe128cfa2f95a2910b37d4ac2c86ea313e45e02bd49226c3ca7c0e8e3573b788deb087f94337b62c134b12a3291de3d35848974f950ec4d77822c8d0fbacfb3f814104fae5c3c46bdf0907617a07deb27bafb0cf0e82f2a103c0daa6897e9e017d988b103842dd3c258b4b5e7a99f77ce3da4985507132212e56558983ea53e23c52ddb4fb149daf24cdee054df3e3f3863e40450f2ff1d892306f934d98e029fa929fbc799010883e7f5968d932bae83613f008043a3abee220b67315e0bb8c6a89941de6d4b90e1664d88cbbf4c9a78eabe9ee1809fcd8b87cd61e8caa50b663e6b308921fe509f29bde6deeabf577cff906883ec57eddca4d29d5bc4ac010ac5ce2a14ece0fb834e5e18b7b26ac6bd475119cf9f0421625071817b146c5a0e751b952fac022192f78050370ea198513055291067c37b37dc3b51042815482f41dd007a5b7c80fff57c941e1d7b1f01f0b196257e536541f3a29a0723e718a19a188aabe6a20d630a466cac365d1f95be9484035d100b48b29e141afa16df78d8e3f0f1c9e534489be19d2ee6389811e86207e601fe5afa1824d730b7665c0ba55958d68f7af6a7eab9ed802cbc32163a2418fef7276d2eed8210729d0829d63b1e5a5222f55dd2b392a8da58b34754f3606cc2b723a5a3ece8f6389baf21c95d91d4743e1666643ccc15969fd5141714b30a9a73d647f7dd4b4b6ea2380b9b2a33cfe202e2ce94f615782dfe4f4a61c0868be12d6debaf37318f32d3c59812542576e32ce58b4aab773f2d24ea282acd03fed7e727bb407b2da611f8c1f59ab4ac8cb515a1cd96a39871e5bf0cd7237665f2b6e7e3a805839e3bbf2aac6808e8b0434eea516d7255366e13754cd3cb6439b6dd03a5d1f62aec269ac1cf670d4bfcbc297d4418e823e8d63f2a256a142a31c327f3e6ee40368f465e07255484f8068a1a46f5401c78a17b8a4c0c39402de3cbd71cb294f91c5a3d578fbed0207a363d35a8bf7fd5ebee5f7f3f5737adcd4c7d390e04a24b87137b36a74dd91ec62d197570a677cb4bf4b626056b51ac28632302761c27f6e8f4814ba7f88ff15fabd97bb8a4f9872cacc1e970f12b118f235aabd43fa8d5a5fcd509abb03d46c26b300ad24488c9291aa43a086e0180947840f0f5775e8c9b4e5af33e4897857875e22c35de80b0d249c0faa929f73ab4541fffa518549d436de8caf339b1f3a6456b35eb199cb6a05c82fa9e96b09a68f930e635e204ee9038e280094a783348feba6158fd8b41e3f8c66ea32e071e066c0b9d048caeccf5be097367484985fc5a843d5b0f001cec072df05745d47957a68a1121b0a7f94ff3d732f865b7789400641ff9a545f2cff2a750601a287c880f6b7276af38c4c7582acf5f41461df3fd5d2295e864e97a1533bd725654f94291737eeab7629ba4750f9118e8b131fd0682a253097fd78fe4267b9662cd7acbeebc82318abb7886688a835b18fc85b4ec91ab0207a4afa13f6ad192c09808fa5ceda217b17b0c8d5e7e20ccc7088ded78678f66300a2a982ea80f0534290694b16ca53e9b8e389480e7c2e2d733dc9e8a2378b7a3157a0bae8233885003ad7ebbd501fc96aa7cfdc08fe688c06dd261dac840704b43542b9e5389422846d5d27d1950c6a40e800f03b07900fd9c6564cd312480bc880d428ba8fe4812475a41c3f301b4af8f19ac43d371687a11cda8fdc87d4868f43c9991e94a9b53c51fd67b82d559c24451933eb22e9dede2e0946d9c61cebf2bfe09d94eee6f6e410c595d2e770fab529b2a2f9607b9b2280e320d7d6b5ca1cd6dcf9850aa300c5714f4dfcb6320332552bb45667b9aaad4118faad946cb3bfa1c3daee34b99756c7eb681d116e418fc697e0eda2d872b2962701caba7942467c097f3bba2068860181e3f935d04292c19816a4d46bb1dbeccede72b1b00474b1de160731dbb3029763efaf1dc8c5c6a2ea43e15118896686563705eb7c364d9d800912f1447dbe0a5ffd5fd92234eeb1e312132d7f1c7cbc80065252137e7f842598d870d800fe2c540285449058c09ed2f1b7f5171e8ad80d18000caf9840ed78eef4e07914efc0b3829fac53f21ce40d17bbd8c2ffc9ace978909d5dc244d55fe03bdc9e1844696b4f4d801ae426b0ce8a86ad3e16ad7fb324039be10bd8162d933b09ae8d9520be283a500dc9353fe8898b70bde56d449fc091389ae4cbe96d2c5ca8aa791f838d40dcce19b56ef6c92d88d79b0c9e7ae87de26d47cb540487b80ec513c7793d904038891068f0cf1698819376fa8b352ce56adbec09293568bdb4e099a58c716ae617b69c78c731a7038166a43fca05c2eaef19caa4c425053f957a47826175372a125220fdd58ab6f0d02b12da8b56926e04ec4a8edfe9fed0321aadbdd501a94019c2bb96fdea3ba2645d1197841b2add2fc5d5c837b3334714ebfdd60ea9b6d021fe7fd468cf58edd8c6ed1a90222c9874f3de69a26b74d322bbc8942abdd1fa622934526a0746b69b2483032bc7a789fb33bc94d826ae63769222b50a0a67be7f804ed819eb556fb35bd260cb2857a50cef32164bc6c414a78a1504bf3bd08059109cf57e9611f55934e1179387266f1ec47477506e326f7dab99261d568f659379fbee0cf38ae81c0cf988e250466cd033a70de8dcfbefa0c58c2ef707448cf1aef0b7be9415b08e1df101fcbe2b49d1ba5e1c22db2983ed9aae7a6502af143a479cad1c3221750fe03ebc24057c111f856b36dcc3b01f127bc283c69a54ea4b423767d06d7a535f4c51d648eaaf655343005c03e4713733f39715467c129436c627b526306527dc8d965421ee4921310441ebcf07dcee60d92a87e0f3c11f1d436681e176f8e81a56f78b20e07608a114653800c8241194c14217bedb270d0a85e61eb993a29576cf77cdaa2c79a4c9b5026e1172d0a30a9c57bd3236a770190846d0be519b60d058300a18481c07cc0d342691179e2ca010aead2ea8dabbb103a2a14b3fc8aea0f9944f75cc2bc48cecbcd0d254f89fd473f2f19ba1c40cd0e2d26a1b6d98fc92e3d585aab68d2b38ff988f7a16c9064f9bc968137ed1c73452c009a228b8ac0d224352ca052617734cd24c610cb1492250854adcf81469a4701f8d0d02efc3e944dff76e86efeedb3d8c8e9124b42fe6c81a946841abc3490341ba4ddebc39dde83466e3918398f393d66f256664bd89cb8b57eb423e425035bcbb8486a8715445c80fcd6c8dbd335465fd4530abb41f6105525ab9d83cfe30324fece74f59123eee3fef4f25fb25a9189124b55256fabe9365ef435e16b48bb78e1b75fa6a0ee1e4c383514446b4d72e95c2e36555a3cad7001210e4fe7a67c36cd58cde12a657b1402ead77dcc32db34c1dd34a3628c9b518e5c2695c437d9d3e60792960a7ed673411feaa3cd07209dde7e6c0156283eef6dda6bb9aad4c57dd05c1792c6b607825ab0b47e4a9e0c267748328477920056abde478941f12b0a8a38fe9bb5f695b84b82e80f24a74f13e96b1a8e0b255022170b2eafe70d3ce53f65c9afc4fb8348b90598a9617b66591634b525657e3e24b08710c06c5969bfc6ce0d24ade764b4c2d857ef0db3e50b5196f1c5f1a827ceb5c7cfbce58ab28d37ab1dc9ef3a0c8ecf252b806c684fd4f75b18279bf812e51e4350b4069c9e2ae22dd8f181cad06258a8c4543d88f35bcb540c95e13347d560a0ab67a5a1c135ccc23c490c7fa3c3e934020ab6b3652fb1c6b5c819c514b582ad5a66c4194ee2a5f4edde7d824fb48e8371ca629667b84219cc30b0fff6759aac367349d83ef960ab6865acb24a6a7cc7eca1e8452012f01dd20d2b467ad84f033c7881c262fbdf4e60c071c112a9962102c8002d3aee0bf2378ca56f129da8bbc9c049330010936b92dc63e9f5a21b998630eb5882e2b8bd01517c0daaea8af9aa2b2e54dfb53ad7852c95c3b32a3a46cfb7cae9fd5340afb0171f63ae53744da451796bc30f3aba41f2bb99bcca0099fad28ab7a813f54677c639b4bc962b5a9b77b24e0852a29e4a0b720a926bae75202b9f2a44d811e7c823b77d8219fab97015e10d8e549aec085aa7927df32b558c02fc4db9c5c7b81f5f3d9a29663c3cdaac81f0f1c167405ef2e8e2abba60a463ddf80d1337c55d133038429ab6217a81908f5b9b9b23517b964a37fe090ef1efec62ea9bf2a14fc7e18ef3165dedd63d3f1bb2c64b925b6bbf51fadd04de5836e74ceb5cd57e2cc8a741b6d6e24145e159d1a852235366816b938492f085d98bedfa8a955d58c7cd73d9ae548a7e5ce6d0c8b7291548280e3263408800231299049872da1e42116a7bfb7afe14097301e2d0926116728eef9db938d209d888921b8aaa12993f6570e728081aeb50bda2c6ffb5fe9e9d98e33bc7df9d952a43e140d6a3b06e76220b769733d9b81bc6c2c7b74e81c33fa1b31e0dede5df22b7c189e1848f704dc7051eb83334187b2112a43bc0628f802356719b0186d1caf84238b2af6cf719e61a27f640b3ecb06d33611f929f6145050c43ef8718cb099ee9ce4ce008bdfaeac68b59ebf36024393e5cf679ed5271f8d53539eb40c316ede5009962324cb1fd7a8beefc1ed507d97174cd7e7cc5a839f133dc90d0fb171a8200c3fb463651dd033dab012b34415ed13a3afcfc25ddaa462d1420c6a86410be35776359938bf3ba99cd195eaaef4709754cd6000c7f0e0ab62f49a92117f2ba9c603ea143f24ddf45069b263db0fdfa2f09697ecdcb2da448f9d53e0c029e068e539b8c2dfaf76d382f9ea8d95304f57c5f0171224e85262052032ea7c2f1a0083bc4822480eb55e2e09b504a5a8bff361e3378c38fe8c20151cc774a8af9558cfcde866f858e6459fd3608b1e13db70ad36cce5298769b27a8bbece2c99dc99f91089a506e36e42d6baa71d396735f3cb2abb0b3d6250b83c0528c2b412ba00be3c95ce0c83e50ef944f05dcb454bbf7c60ab8ecc2ae452d0beb89693385bda25e7f87e19a0cade78ebc2ccc1416076092a42edc1b52ad8f1bfeea5ffc8f91a245cfba7bc607184bdfee0033361d118fe7371b061395de9c712bcc649b4a95dbec8a29ed3339f83d5418484730916d243f7a3237476e588dc8a5f6c72e2d4aa88b29159d5fef08291ef07444d588221a63af7992fac83ca35409e09c5bc23a72ad641221eaaa098c90cf6383dd0219c6fa8a6efc24cead13fe4999642619c61f7858b484264fa17ae8da2ad05e86f1a50b537f1fc47ed14579342f1db00b1b85d2cb9cb5b53590a0878cd7423866961ad5b776c6828fb819d78f5a2ff62792a53e8ce6d2ecc94a3a1cfa635b8bf9a5a3fb9e61888299662ae648047151c46e303264c517b5447c3a095479edcb64c65b76cc7c5d98b6d191797d9e9605b5b4606f379761fc669ecb196aa76c9165a8e80e2c021b36605729d9243c2b6f0419fb9ee1a905cf82adee5bf298d297156f1e6d943dc70a3fc40c0e07c59e9a9866f6b3119c7549b05bfc0c1bd3e652f4751b8d56cdd52060976b4db19fa827e895efb7698ecabbd038c7456e29de81e1e061f65075f4c8244b8d4c004943b266402deab8b2921e55c63c5fd751782cd0201c78070b68a5ae6a2b21d9fcfe3ec6ed896f4f3386c4365fefde1b6de95fd9c185238b206ef6e10ea6dbeb4e1f9ec4686d6c5270dbcdef08ed73bd33053e2f84df5ce6bbe5d4678c07df817f9e0f9a9baf629483209dfda20577bc5192c09c89238e8c98437e22a4b46692f003028a86f8fbd06f251d6ffc0e9207daa01de51c1563843888744a73d8b61a505fc576d26265e4c5b5d232b2308676189173f20d26127276e98d40b9a3ede0050b2d7c381b7c157555bb16cb36a9498630a6aea33564bb99bee57596f0a92de5f3da3f8801801161375ac220c96acd41537540fc6397098681da7fc45d7b1cb940959f229320d70ac517ead4c59077e46e9abc8acb386008f2474e8adfc9162cce5f7375c3e001e84f69498b4c7b67b64e62996e033e9ab04d7b439a04e8ede2510431b08729ece639c07ec3c9e5d7dc4ec82668e08e1b7f5d6489bd065e8fba125f505301951b0a985c7f66cff44cb49c7b62346c0301fad1a61c6db6f5b09ef16ecabb60a83a24398412f43843ca833f1f363f847155d5daa59c17728f8146b315d12ca8c238eed165b0fb01141b9bd65f0e6730a32b3b6aef82aeb4be9f14b993e7041b327fe9f6142ac7fd3654c271005873a6a41d4a404bfbe05b77c3d94abb1003e7a9daa5f6e52bbdba3eadc26aaa4fa43be755a6634d5cbbc6bcc87668b4245d8076af5defee1593d2e71e0ae0b269b18ce6051a6758669b4eb5a6276d280d7f870245c3b185c92166d43d6f026050714332d109fac8ffd3ea3ca511740b6d1d0e4d47ca048761a79946aaf5177c8335c3a622133500d192f412973a8160e464548a00e3261c8ab390fb2474ea18dd716bd9b062261e7e8f6e99249642e9aa618289a3fd9f6d1b925067b0580ef27587ef3fb9f23db0bd91b3c166d1be5e962b9320261cdb07a8f9df29fc698078a46b9c200ad9cfa94077537d8b1aba332f3c361bd0f8fed83762cec4838dfb2d861f48f1dc41636994641975336f0a5e667964951c40aa070a4812bf1fdbb01d8d0b73b37c3886837a06522a61d8f396e4509eeb0d238bfacf05ee7afec6b713a22be268a8944d7f0f0a44e3480e922bc0dadf40caa44542c5a2759e4331a975ab10f9094f1b56bf23cbf8d15386ff9d0c5c47c6e0cae4ffe5046c4da0ed542ebd3f8869fc872b1b71a866add2f050d7eab7d293eca5a86b072db2db7283091c218eb969220fd5a3f3d18253a23c0852fba7520593d00fbb7b03a783bbfacfea0b50c41d4549a5c3582f0299f0d5bfd0f8724f06fee71eaacc90724271b09b482a3ac4ab3f14b5c4b356a0b87bb83c55bb812130ac77fff131eed246bbb5575c355c241787232eb2c85c09079d01d20f1dc3f04f58df90becabe2ae8e4dcbb450b3e207d64be969a4fd136a2f8a051240f38a6f65210a14e3ce9eb575fb0774b838a8341fe90959a29a80a892f5e86a819bcc41120162f2248a13da26ef90785f240bd398039063e7d748fd124885cd07ba3536280ba47baff810a84a828e146b5219bfd08dd867ac61d67a3a85ae181f3be78e15d4eb74737bf7f79c168cd836de2c8bfb2e21d4fcb049bfcc594607c425de3ac4bb1459e07dc1e28f1e02e547007825fa1328034e7c2e18d03be8b713b4f21a24cd132e14ed7cce02537fcfe7696eb7b95b8ae96c0b6a8e003c9948517fb617be3ea21f5678336078c62c68b460a88541e235890a90b7282ebeac89c44b700d3f1513da84e1c9b8fa5819f5e6dc916acca2723db81fb1557659c8ccbe2b9e35b997347c4b5dd168d0ef4113a60c1e1216114d7d60585ad20f651c76abaf908d6da96c20017f26f6702ae133d2cc70bc65c43bf1e65f697d2e916007cc0c68de275055c71b0b4a35dfd21fb7d64633a04db23f49d20bc194fa4f72c4a5e08be701d0f325a0b1340e3ace5c979606571cfe042cffa80ca1eb922d362d1b968f8750f1b95d200c45e9ddf396b9f5563d7b47a1f1fe7db27d31bb6f415b9de9f32950ff0b443e35bb8d974d1fbe2029657c4334db586e8c440021b1119a8c87a3430e6e8d05978a21ffbb56347c176834fb1eec0da0a6807743e814e575f3a1173d6e11409af62e7ed7d160ea76499b3849dd551ba9ebab0a1e4f7e89da279e443c112569c9ef0848e9b88ff4b72ffef58c9eebbf0073fa80e4f38892c6fddf1e9ed68a44ec631e06fbc12cc8106d7ce3c89172f5fc37e65608550fbee699a7e788cb95e0fae5c8a36ac4f47a6207fd557fdaf3cf465ddf79da157652a67562f66683668990200c75138a4a210e439aa8a249e804423807e69890ac91c33febcbb36a947dd85a2106f22361e9d93bdf7a259a9c8f9b4e0818e432ebf4ff1290b31e282237ccf5cb17f42b8cc57b9e2d73db46c8d8175dcac384283f3d841c802af8ab43051b9c9ffac2148e8da667ca6a2b10ba1ff67ee4062bfc5fa66ae5d7a542dc197bd3bac25055683d719bbec07689aaa7099c3c00558745e7c1cfa938e05ceba3d5ee9cf2e0b7048750045011b9133d8d63ab2fcc076c41fa26bce3caabfcb5949af058951d9ac53c22c838d68a4221c28b3180d38f1c8b46f3cd4d9f3eac2b941dc718d40916f8311380703518ed721c1f042d7d18268f6e2239166001ad003339fbea7c3fe9c9a203a50e3433c8fe633879918975a8cc8a5774411bd959f69d573b791a2360bdb8c1ec23f7d5e0427b7e6780199c81530dc8d21c12f14a024f03e220a49b4204c88012c48397306736c16394d090c096fc0d75f5f1347e128077abdc0002016900d5fd6ff70e360b6ffcc1f2bf3c03b6d5e1496cc58e8ad0d6e162847c1eb282b5909620187e6800a636038096b4d4cd9f097b8d2903e531bf674e9fb159e34b1b1050521639f9d50f083fa5128c1ea11cff78f022f2b9c6729a1732e93258cab6f88502f6d7a222ca9ff41cb81703726a7f250193ce455ca70f3f918388562e19ae35e374d6aebd4763d226caa9bb28915577eafecde1ba5f28b47caeff0fa4ac42608066a6ecf646ea4231001d0386743d6462769f81f71967deba1117282c90958d42bc335215a451f3fda094e5c6a927a10c10312188944cf17a4706c05ed4e344c37d3f3e0b50e6f3abf3138f3b5e2401c84e10de31f09754988793241dbc580e656837604d156e3d5abd96dbd549e9d31c04b4ec33de7418904545294910ed2f60c70d3aaf74325f38e853b9a4beb41ee442ba49525fee31c2d4e4f2acd9913a7d584a13e6d793818b80202ed4571a626e7bc3e4e9fdcd3f44521049f63bad551b6c733f37545abb4dc07668a2f51e99f35d4338de4638588c64d0a17619c96f6920884441bf7d563c744681108fa96223862ae7bdc4dbf46eb1c4adaa31a40ec489ebed66921e3d51de1a31dc6d9aab594dcf94eedee1ec71ca4196edc8a7674ec33129bd56a616339bb502113e16c4e888b5ea4aba1c5520051dba1b438f691deacf598c3c9151c28df5961fb637feea239dd576582a441787b5f364c864fca9c4aa1679fef747ae3f488fc032921a30be9ec244585a2564eb7065fc6150d1b621b4026013e5abf5d057b53190f08bf10723373487a637355cecb13dfb6e29313157f248c62d3dc2308daf3f254f06f3f70238e671e7d9440d80e6a8da5ab67db447d51c519121fa412fa23d011afff5f8c5c0be0fab2b2da751d0d16adaa32cad97e7b753a7ba0111ce340114b38145c66af14b10f34d600a5782e15790f72b7abe4b214d040f843e9472679fdc9df40679c7da2177a6b9cbd087dac25433e9e7e549df68eda3221fea3f30d081914b7c9a204986c846db6ee2941661e60874f8b752afa147b6440c53965c1aa75d3dd457c9afd7dc687829e85c384efce6a6b0988789320372eddad3e957c20b7c03ea4e777219d0b636442f2477f060dd6385946d2df75bb47cf4f7afaeecf1e57b74ed179e9aa025a29e435fe1e7f7b7c3e8aad1e88c6d608bbb49bf0c07457f9820d8c9efde01ef6e8e72a8441f6f4b98e02c9a527ba270bb0f922788b11bfdf93fae5645dac0a6352bf39ef36729244a0245acf3ebedaa4089bef9a624ab56d18f03e602f773d8e6280ba3635f55db76e6a00fe2bf95e564bd954f1403dd3be0cd9ec81f185298d9ca704de1ea97f7694a973b1f5899bd67f12efe210fdc0a670cd4689cd43ed8e56383b01b84074205f22f47b8933f5954018ac8d98e61c6573372978f177938c1e446a80284e0c28d23103adfaff4b27d24329d1d685ad791b957dbfb0fdce9d208adeb927d9874aef367c0004c13ae0a86fc3fa18497c5fd8ef2d92efc176feb21ddddb02510e9888070ae8a517ddbc7742bee4b3a1a03a03caffdea17fb3c886de783adbd0750e388d207babb1e7de82bd80ce0bed9e949fae977dabbfe6614a4e881d0a51289672a5ead9a75dd32238660e11b59c81e48df6a45407582d593f8b3f34f79fe26aa040c5ce6849287c31384326c94edbb2744472929b3412b4b084b996b987afcb18c24b8ae4e0550b5c0eda1110111a011ea270c18852e70fbc38b29722e43fb0db79bd7736b1f0fc519e3ce6da2acb6f297bf610f9a7bdc60bc318ca762af290043af03e799962b1018f497b132476b87515dbebb7eb14cb1c28e587c58cbce3d33d66e9c90ed6b768795c83542308246582d4333971824364a40ec7c3990e73bc0b9f5d4ae59145dec0809fadc3e0160475703aeca8a9088530bb7c95d4aff4b6ed6c9d421240b7b815248c823f03397c85e2a41c29a94eb3eae0232027c3d82c9265dc480afa612fd78159eff068e81da3acd5a3aecc341431e9d86a610f2bb8e056707cb3b9f044aea4178e78bc7f0d062b51a77b41e6932f133d11075b4861ec78b9c2ed8994e2921597a07a488468ce35fa15ee4a5115a5197f62a66329a7aed8962d0e4fca1e4e3e7f92286fb70cc29f96fe414f43975e9f1379323f2cdabd545c5e6b6391afd1f2b30ea39c5affb62ee9f89ef15277f7dfa2ad35921f0b3d2b7b87df6922f8dc7c4524ed7bf955a554bd5ab27b7e761078daed1dc56bff2b50643c44ee6a54dfb705469fcc90078438e330365e89996268fa47d9792841c7b09f9df2ec14074af02cb26b708c85943cd94364167e06231e4ba6c31e46213787ccb67e6fe47cc5e3b6bdae95d6741660898ca966bfdc8b434b673385ee702dc321c93e04563cf5cf29e95e190411f7f1519b0a3ce6339759d0753b56028f702dd83be8c7db0893ab19dd503967060607b7425838271edb2cd2dc74dc530760483186771ffd0c9bec7bb086c4f420bed030b5424c1f781f3f9582156f54cd54a8eea0371bf2a39fbb647a9be623314c706390d2f1cf636b883c543c08ac7ba16aa77ad9a4667b93cbd15769a0cea2c7e92d600cce287f8b73c11497ae1f04b54a482e9a7573cf022c468a2a8b5b02a714cff14ac4c7bbf127c0fcfd47f23f367226806faaf7682b73b178e13429154edb5e544c88fe63f4305ff4baf5e7b95d0e53c4885053be32053ae00db3f4f052d4a30b05486a1dba7c1ae2aab3bf215078dc9a632442f09d8b08e9b7f5106eb72db85f72d7c493624505abd09c32e6cd49689cd0273510ff736057bb1d80471be62c7fc1507c11ffe57ee1147eb8d3e2cc2dfb8a3b6006d9fdf8bf67270535d3ea01fbc055c7c3640ffdce3a9cf878b0b057517d7fa73ce7f752a731676979663b6321f93e6c32cb615ef3c3b2892e16a83b1dc250f8902d28ff9163647a1b2531d843be84368ddd9ae942aa1e1a912462172cca85e91c173703a90ac2d0a65266a1828639a47313bc239eabe79412b44e96743a004299cc418c7a733d5c1d5940475d0898c96274632f5811cdcefdf03ec5b1b852b89a350eee2b0eba0ba749e872bcee48b8991781ed4cc5cdc4c5c7942ff8429f3cb818307b3e9e359cd3dadcc8dbcb3e0de0dc05b0bb814d065ceda06f2d07149510131107202279bdc7e3bd2677d51211f5865da3c003ba4948e5160db9404d879ef3d19f6b420c1613f10a2dd068d0424b18b7dcc36535aebf215aba4ec8246fb4c833dce17c83a06d4a1d00960bb1c51af5d1c57e5fe237a8d665197b2e42c956f8a1b262871ca2e791d1a93918ac3450284f2b143197a36e303a9bf624a6d445384457a4cd8bcbecc86e83af04a31bc05723f1e6cc7728360f2905e2586fe02952dc6489e33859abb869df56b6d6a46ed518a7bc9d221e58ee918444c0168e74ba8ea96415cd1390a56837a2b41a6a975af0c830bfca70a4f25c644a5c83016fc3b945f40b67c40d4328fba9aa4e6b26acfb27bc3c9ebcd8efa820d133cfb260101ea5b83ae634200bec90366eab172bb63cf01838b26d2004aee5829c1fcc1269863bf9ac7836d1f74f9e9ec631a9513d2012752c610043966be300618ed5aaae82b05e2ab33c1e0297fec247169bce5b62ffac3614721f4818abd7943eb6e6064fe2eddaf09c2f31572e26ae93bb008b7ae3518346548de1db3676bacd119f3c2d2c9d35e3794bc0d95d788b785627f69534b48c82b073d39ec9621821f0221cfb998d3fd1329e0586fa1909553da42c83af706365a35db5cffaad4e830bb5c71f77ce9920a4c7029a406f6bc022fd1a3faf7784e6987b8927d4e5e382254cb38320fc2b8f2a7491b29a5f33eca1e84fc073936b6b53356a808934396c738ba00034b8786e6a8868512d614efe9b33c8682ae3e56efc4832a1b4cdc178b0f865e3eba0e0721ce80209ee56f076ea7b622c39981a0243e5cd7e378d8832637f13891a76ab7fe9d8a5774e5bae530dc96bb60eb81ca340177e51a562a3657b6d51286eaf050dffa9845889ec3a9bed78fae9c0dca40e52b31e04cd752aa97c6779f0990afc40e679fa3d10ede239c3203bf17464b0366172fcc7647c72ac7097f79a822194c0e52fec351e9664096ab892be59ef697786a5d9e1d91c768037d13b4a289767bd53f241c499a13f13baed4b7a09f44ae5b8f2d4c74f1e259f9fcfb987e33772e1f0424e9d0470486df547e10617e8a08f1fdc641a83eb4aedbff2a2f9f4aadf9f6d1503719b862958c42b4f1218674b47929b136aaf84cff9de88cd10954e2ef9481715f941bc38a8db262635971e359a3b1acdd6856d148d63696151bcdaa1bc39a8d67e546b0cac659531b07b152091549c06cac0213b78e07aef383d4f5e0753e409d1e5cd783d6f9c07572d0ba1fbc0e7cc05be707af7bf8ecd479e30e1231514c69cada36dbfd902c8f19a6143d8bea66a014fd10a01debdd63e222e0f2b33930c137ba7be763440d00c7b83d756c89cc02a6060450c696804245d50ea43794cf10b03db03f21ea3c7a1b122e464cadf9ff1400fdbcdf1c9e4f7f043b4da142a898c56af9454af79d857782f7636e58b4c8b5d41536c325002a5be2f4f864bfccf4ca293b152b5c1a72cc1344e64996d167ff1cd4d774134e2176a01ea4f9f678f3e5ccbd83e3343782d9f1c87dd193828aca06ad874e712f65d9629f929ca9d8fbb16ef6b4d4cf2b12e84e91ba20281cc94adfe7db2bbd21509e6e482e004853fbe03f5a0e422173e95133eaca3d979fa0336f0477d478651a9a9011f48aa8b053e1a00a1cb6cade011b03225cee9cc0227675e31d3e16e0fa102c2568f577d0a1613cc4643c24d0417a7e0b52f1d038a361f0722c10271326eebcde6236144bd1f5518c3dea46eedc3869e90942de91ca9bc2ed7ff2428c6e79380a3b1abfeae5dc9a358887f90cb10188e164e4148d8b97594a01b85f6815e2a483f19577335e4d91bf6f784e9e0ed0d97dad7bcd7f0ea53afb6be6717f8e79b6e86161245a8be2811a339dfcac83db3d8e4720baff9e0d5936b79c75713ce2c68b5ef389cfe8fd9d683dc112fbfeb2fa5415c74e265e4e9fee8663093eb4b48bd4f681800a6d6191d17351c52af7ffc8d2164001a9c4b20d9be4781ccfcb0a8ef2a54725d3b9e00568bc4a818cd38dd5005abf2ddc3ea2b79378aa0f48424ad9e0e7a09c8064d2a20c111afa95d31ba7113aaccc9067e6c8549d640dd307d79c53727e6e1ba9b854a3204901ec76db04eee47e17540c092c4eb500ad60e228b8a0c6d5c8c0ee9b59526b2128e1c33253624181c06b51f0a09fad74efdba1c2121eea0239cc40e9130028bedc45ec61d975ec288fd0e7d2eb5af9274a0d6f91227d9b1ccab9d0154845b639b524ee5b5a91b2eaedfba29c82af83a616b9d31e6d8efc9dfa4d2513e8ded4da8b17248e2e08687ba6189f3a96ad847a26de7f3659b89c77fb972868e1fb547e080edb9c42edbbec1f422f7d46eab45d1ab5713b516ad95a22875906ee8c2857806c4ee33823fefcd92df0cb8658ebd950de6b58be2a1cf4fe9aa827f06622307924c1bb4b1b3b59e7b8d5ddfec7322387820884cfd860174813567db4bd4027a91a49a7801504782f37806426f0e19f74a4f59c2004627c1df0ee635b2fa6b20f3a82dd761ebad1272e58cb1d82f7965c320a0306b3d767ece37077d5cbba293078d32f357f0eb0b78ed9cdcd921b5346ed56fbc43e18918e8c772875ac17d3b30658a5c90c0621b22d2e4ae82b8648c146bcf836673f5eea9ba5896051416d84268f7c3a5f941d615f3107d763a26d914c1b6f04e59fd8b3e88967ad9f94fd6f455cb8b571ef473f5ac9a1e44b760e4f1ff15ad2ade6ee0104a53a98af813119d4aac13624fd6a466195bf6505f6941f25d7730bcc2e08bd0c15343665c2fb2fbcefedeb848994b6b0a927819873583a27c61a18cf353aadd06d2426825469a1b4c5fa3851e66d82aaa6783efd75b88738e2ca7156e209f8d75355572d5a65dcc617122f112493ed94f263033ca4e908ae38046c3d8f2bcce0ff1ae2c1b26db62f4db4e2dfe08cfde841dfd2ded1a96b6c15ba2ddd00ec5f49d6ae60496bb8b36806469ed07a2391d2d692bf3bafe08aaa1b2a5053eddd499dcdc9b323ce93997db5123135a8bde95285883f3e3d0c5ed3856a52fb79ef0cdd06914d52fc9c1c00bfc16a9e9248b2ee7f85ef7a1c1775a02010043139f828239b722178474a97876c431302dd573bc85f357eedbe6d71a89c2d07ff155c62688582d18cd591e351b3faa04b17b142f16ade4a93bc6c1f01c2b542baa8d92b59e11a88d34d0b6f47a7665e9174f7bce57e62ef90f7c939f2a87266f01b400788defaffd5aa46631ef391bcfa234ed8179a9a4b8a74d19bfbfb87a122abee14fc047e65700e2a3c0c3c3185edcbe20c65318278bc1b90824ab1de9a32e1f805afb2c00c0a156c5fed2dc98601534e145903518c896071d02e65a9f7e9453e39d1914a78d11dc2ff8390272e0225a32f75dfc239f938ca5ca29e568e99ab18a301071436ed07f672e29ea893fc1aa78368964a99b69a4820fa1ecd2b5e983c4b1685dce83d01b301c3a146ba672a763dcaacc96bc7be4ee0d54dbb35bb0c4a23f5be655dbc8e61ab15f9cce82e750673df208d78ac87fe3a149802951309f5e7b247ac1eae45d263e8905bba61a51ab771d43c2d23ffc00bb0a4fe9a8b39083b31dae12da68c408b61a00328687fa847cd8afb8eacd465fbf054acb2c674c2c244ad50b4af5afc9c1f666eb836545297a7060bfa7da8bb58300e76e4d31e5224361e4b5e45ea3b3ea172586f46a95901462ee15ba77bbcaa867aebb39b656523f6ddeaa9b6a9dcff8c12433380fa617996c1774ee499986c7e6b141e37f1d095f2e102cbdc4b06b655d5e03de7990250d3f478879ed20eaf74d9285be921c1f3472befd87120eb9a968e5c6c3bb772ec329a369376795351a89aa0d294f16eebf4bb50418448a7156dc385a5d5f5f8abdbea74f13ab2681ad49d4a7bb4d4d406c0f2fc3f0993b498cefd1991b1f75c0858f96c2e49d0124aa0e2ddbfd5b0c5995db19e23d02a222db6978cd045304c266c623fb5e4311df671f70dbacc03fa16ba58007701f6374fce0ca1d8772065779e287442a30ee2bad4e088c503d85d2a4e71d2d666d170dfeaa851a38188c399344ff04fc168f902e9bb9237e159d3b48b5c5f609f147826967f05526b550f06d5c2cdb200126a350ea6b54c84bb185876399602e85fe9a3124f04dedc454e2e8ffdac819505c6d02ac0949ef4f739ddc36733a6f7520846d4dd4aa8e618977a2343b2253d0f7e617bddc79f12b0404b6f6ff839bfcb00498ba49afc0b3f7c4001da0e7556418c0bb4d5cb3771c88573a6a4c8457abfeccec09215eea152c4831c1a024f20897660fad3ea0d2f678e9dd897f73fe8ce398babf8a87a00650a148de1e07dd59ca1433c15ce95cc18e65dd55a26f0776e51225ab8584abf80752f44ee6e67c046a10e37360e196fede0fe1038b5d2b6d1243d8a5a6a5b8168deeb0204172cd553ff26861d5187dd0b1848a192f7efc1e73453ba348e7f788f76449696fba56f674bf9d59818f58251325a4c5f10aa2812544c2fc806a14b370b9c446abf86adc2c98dd83ece888a78a8ec7407895cdd33d8cea1b9cae92e7f9f4e8fec81232064bb7ad8c37f6258d6dfd0a760ea4f4a695d734fb841b760789b1ad3c8e7934e5b36cca5bdd53dfacd927a3abad36fd7122722d0c614e4d282b711281a1ea444275157265c6b7714f6276876c5d34c8ff3ee5243f800eef3a1132cd46067b39caffaea48409536fdf4b09acc148472185d6ce77904be2a7f25e24f500527b43beb0f0efa1a4bfacc3c92bfc63a8b3f9c06759b2fca2297b65984dfd4ea47c62db8a08395a99193686375e2f4ab81257828e1069e95f4fa12261ae6dfe55896bf1c4321eb401a6945c98e234b312fddbc527e367ec353fa9facefaa4af46d8d4eb4376dcb97dbb74f90efdac7656938555eb49b47ee78eb81456501ca11d6df07c29f19acf71c75d9868d3f6a346642aee4d1701963eefec5ca446370d11d7eccdc098220779e359418cde4527a0115c1b0b9d3d22800da87bca60184d04a21ca40015b01a21813115420377200e3284805600befbbf0506e61c9408ecac7873d75c36d222463fed21a0935694e159c31293b6adac5e28375b6e8d8f8ddfdd317467251da698b8429c019584e7e1e3c7b62b590d1ef9396658ea5ce3080697b2d0352da18366454938e8e7b6967489d75e70628bf7e02cc134956693a4e575156549ba2d2607108bb34fe78186fe4723941d11132a799e7b6a6e3042dbd6070a80ee9d048e7ddaf19ac4bccc37984909e4801772b7cd1491def5bbbe905e4424bd8e6bcc19a2d7e7cedb793d75efdf173b0b17ab4944fd7cd7143fb786b67a3d1cf298177c0cb21e82c95fd0ed039786c5240eb9f2b504e5262eac612f9872fd781eab41004a72efe87ea9dd45fdc17085569afdae8fa4fdd1cecb5e8685b544831171aa89cdfe478ecf517f6e464fde1987cb019fa3ef4e83f6a9909f7f879723085aea16a374a2f0ffac47c5980711b12f8676fea2e752ae33252f626df3419e7e358a62054335d447329bc43860836af0f8b7154d2c5dc0ad05d2af46092d0959208cdb6d5bd24554fb94bc2a9dc4960d70bdd673d6e03d6d1d4964735fec078158822b7cfe44e99ff5e8249854b11a047c18971a49cce6b061069b02de621dd49060e9d8ef2749dfbc1a3d10ae775dc7d9ace45612950fff995d29b26de8c6bf1196d4bb52e9126201d4878155131f45d15c2d58207387d6fa28ab1772a5aed866f4bb46bc1f16894589191d423379b27b37a5ab4f389a49a72f728264c92eefd8c04afa85e8d1ceca4eebd7a1664b48ba68ae99cf01ad4b861cc533b83bf6d4d679bf2e113030fb2be0079832fcd115a8324bd1a7fc6a9b45723520371f3595b21c95c067040465a69e7387bf96265d710d6cdb4e089e35add86284b09d46b6f3a5d4f7c7aca86ec6913dac00b17b00975ad8b34c07a2deba83bd630542f280b22d768e9fcf7c2a4a3a8b86da35da3e3836a0b71281fb687de0e6abb54440b77b599e58f4eb163433985b5543dc9dd784d428a667a5787a3f0a11c931011e137c607dc3fa9f04ad95f6279ba63957cd576add37bb27cc52c0c127e25f7ad67ea4db2bd43fa52ac3582e159d726c0d432201ddee8e36eee44a53ffac797a95d683a9b42488f2c1896a773af7aed21c287b678045a99f16f724b3dcbbed1ea075726b40069a31a8bccf178e12cdb11dc3aa47f494ec00015095e3b0c586b79c46f0ad7ce1dc362f518d8ec4c628270417c565b6d3f996acb7fbfad6f81739681280f7d3f2e1ab93fad83c74e070dc4e099c6db654e9a0f7811ffbac96e853990481c833092b788cc624b0ecc0557a529b771573f664216a4462a5af7e7fe9f904ea42112e75f4fbab958a2439ae0b624141d1eb5a4e5cee7a38934fc4b9483c8a1adbe2bb51933a21adc42b1b0245cb42825fb5c6000574f7d0f86d41695d05aec3f6308fbd3b3de47f17e23446f2914cb83c462437a373c8522be3422a96532bb254e3fb80dc74cfa5f5af7075db85e8868f85b72e5a9c114e8bcc5af3d9680992312a0cb90fef5e29c0faa58fc72c973c56e8e24169171399cee3359587e7ca71a225d0932131587174f4419ad995d433e24abb8b156eeb38de9515448ca6a820aa9beca337b53cd666b6503e5b01b08925dae3d91ed9f878895ec6097885c2e795acb11913d93a80ad2ac4e2fa2a3ca209197db4887a4909664feddd79f97454ed22c4a02d9ce0181c4d466acb828b794773819e80f5837f6fb957202ab6410559a32a97643e40b927981b7578af8f4799f19178353ed0a3b41067743e46ce76ce3befb6bee86c7d80f32595c76e7ea33d4ec87d8b19c6fa9b1a2d3f69858db9490e2400ccb71d7fa66cff7c1e669711abb1bdfde74c14fac9d04a126caf9bb5ab5a84110d5ae16007d46b15fcdb46c0046a1cd50048dbed5effe502b5858fce71fb8d55686e6e59ae21f0477f687e6f33a4df7e6805a1e4176049bc7f297544ea8aa4915b5a6730e8b2c3b2d200ff0b2054baa6d26cb46cf87ddae15aaab8cadd5c1e2d835adc7c0fcd81e42a6a72698d10d889395e4d6deba38a0bc77ff9442122033e0e247bfdb225b825f2e1891dc57b958e57a83b61083da7d1829d235e5983cdb253ae86b32bc4998c9b00a664e471163d80cd352c8066528ff34c1943a4a07322bc8176b3a9946988d3f494fe5769b9d97ebb447a4b5f60ca80073ddb6e324b8fc73c959131f1b5823bfbb85c27c4ec7a25e4f846b7e09afc532386c77ef36a5ec108e9a999c0c768acb0b653be3451f989dc2b83e0dff812bb86fcdd4050be19bf70b5ea9553e10b134f642f1b6ef2fc1ef0aae8dd16782ccec29588fb37b4fcc3c58b6ca06a948dcd88198ded0ad67cb45410e06554f9856e51880f1911bf3abe0c4c27663c7f8480754587990f23e01ff25920c8996177d652a2b8900a8c28d61f7ec89caadbd843d1ba7792b878a7dd119ecf37845ec9267988c0f3947af2ff6e118355ec3aa62bf6878c5bb41015b3491e361c151fe2bd4ba6162b93872f4cbacc439507509a418f1fd05a9aa2e77d5fecab00554874638061349471f2a0b9bf4058dadf5fdc8aa236e62641a90c2e5ee315c377f9f52d83811a97721bda5ea6a326d397cdbd17be3a81e4371ab8e59dcadbbc9ac94da1c50e4b605d5431338ce34ed9aefe851cf15f8e029c702dc1ba355f5deb0068dba91eb2c3054b42ded2ac2ba15bdb3baa42259ee1cc50844f020022deb1c72c3e7233dae06c19eb4dc0623c3b9fc9b05e6c4cb1f4cdaa33bfd033fd46904275c5bb873064f6cee7a422bc8569699f39adb506341c6f0fee328f35d9a966e9320e4ecdecb3045ad2ae246714b103951e55031a610bd89be241bd8921cec4307d29da4e6e03e89087a28d7af8a104ec1c0795db59ed657c459ad73a005ef9759977a213b95ccf20959895148d969c988825a75e0da30e990573797d1a16adbc6372ba1ea149dd10078a1cf817db91b32639e9b7e4e0d3d8080818c1dc44ac37572aa5308ebbbb9f804c85136290c71bbb7c17123bd4e8c8922294f4a664ab15241ca9dbc1fb0e06850c7d4208f48d1b3b3baef8bc2a6cab91ee60a7a8e9424968532d1af40e6c872afcc7ab75fc08e27784f13dd4f729502566a138a723137cf026ccf275cbd4c05bd7f5ec14e24ea7fc0679e5acaa1d7b01a783325b9b1c5cdc12e30045a1c4a8b5328376b252d93c700544bf93c224d4a29661e074e05b80c997ccc3f869b27287a575ff300205abf720dda05442179b15cc62f4c1e7099b664b095743ac5d4e0953298ff7526950c1a3c728750fb93a77abf94e66defd6d214ae0bdb7a0fd7085bfb850bee5407f3c9dc1a973cd8a0607edc5e042939c59c49009bd84e2e5886427c7b26864e1e51e53b7a2be111be3855370a067c22f7a65af10c5c7307db899944755676ea0fc52a3511c8c302bf6c2342369bef5b265b11fec35b850233673cd70a0491b91a777a3ef3d634db61532158695964da4958c9b01b66e08b0dd44eb26c744535939c9865445c80b2f6421efe5d75299afd016c8bc60aa1783bfc0a356ac17477b2a85da4622d3cbbd496feb5089a7ec7b81db171f97277dc24ba4fd3fc464d603c1f49ec032d08e742accd7542671d5914c163af8208d1aabc614d264623ee8ca4c44359921a77f9ba92928d607815b8c6461f983db426d1d0616b5b333ae1dcd392977ecf181d5258d5550d4b6b39bfdf14596b19bb7b6d77283fcae385eb5f1e2363cd66987f2774e6a3daa64230328d1a8ad6a8accc6095110dc05d4a52b4cf7d8d6aa7e849c51ba043e0a823f57295f66caf769555c3e24df49850f388912941b94648012d5be687e576d3f5bb586c56654f748b48b26195e3f52f18088fb0beb82affb87d7aa0df53fa49ca086edaa16b4614b543d3d6652bfec05f654725d0b9124c03d278efbee4e6ecb80875e511a58ecdfd7128ce61744963c6e8f07ac783cea320dadf749066dbcc391fac9a9bdb651ff26838c9747b7cd4876ee717610ee7865ffb4f6cc853bbb5f6db5fc7f0b89d4af15500f2db06518de6939a10af925da60cd3b235f128bd1aab5e070d1b7643cc7e2b885be673d3c39ef359c6bac70c3104a3b5f03f3121537c78fd7a8aa6a4cb3fa77af704301b0c87f2fa5224f87711772e62e2e9747e52b7edbed1d8849e03facdde91592090ba9216032cb8aa12f76621d24bcbe42f40247e91562ede15ca60e0e73cf36e34eeec7d0b972db486382914e00c06b540a96a4a1a15754213f8e9aeafbf78ae17fca807ffbad584ce691ddd116db74608a126b4b2bb7b07280925093009878f64c89faf29e986c70870a36f874d293c75f83515bdc9e1e9000e7f0570780e85c363130e2fc4e4f0480270f82543874761c9e189821c8270d8a1cf811c5e861f87aff201d209494a9492f0806489c861cf7d1c7af097971e58f038fcfce8613db487df083f720880f31c3ea6913f5fbe3efc76aee3d0bbcee12597095485c69c1c5ecbd20978890471e4a60568a5c75a784e6e5280bec94d50b4d2634f7e23372140b372d301b4d2632a7c959b0aa0b9dc64a4951e23facd4d457a2be0262ce040501e04010f3ac08914e0468c7e24173d96b50d4977412731403bb9f4177b082edc85ddc48501e80fc8052231fd0de0db85105cb811222e0429e0420b88b5a0939c72dc8fc845d82100fdedc75010daa1a9e0a024a7adbf1d990206a03f146e08f73bbef7d69f0917da424f7242417fae8b1082fe727e11427892d30efded0bc004fd091d85c75c3872895c2341416e420b408f692a5c0b26c472dc480b381ed482b621c9e94f720aa23f13de447fb10fe024402181059d9400edd4d2dffd072c18394c53b92c10799213131602a03f120ec402d01116989c080b1f0480c883b0a0bf20076ae1421040c2139de484a33fd881682af73bf2c308d049582204c87fe0273f9ee404a43f58d6c2d07f682a9789fe7edc25b0030101e92fe84234150e48c8939c86f4d7fa124d05ffd0df8d7fa0a9e01f1f007d48c8979c04168280e80ff600682af7c87d0284c89320fa0b3a094f8290f0242798fe700ee4c9cd8d3c810179921311fd053913fd91f0007cc80186aca0930ca09db0feeec7e33e3495bbc29127399db082fe863c4853e1562012e463051efae37e64051e4a8e9cc80afa23f2a027ff29c010157492938dfe4ef85ed74712fd057d08921f1f9a0a7ee9cfc77b682af8f524a720fd21c99ef4d0542ea7bf1e370992070505fd04fde027e9a1bfd579f4e0f1242724fa0b7a929f23f990158c9c707d5c252a10d19f910f5181c89027399da03f9b2b51c187fe587fa9e0e3f524a723fa23f213f437e44a5e82510929e8240268274d7ff73a9acadd4d295c9e148ca460444b21058d3ba2a96429e8efc88da8f022994ab69b8a4a20d29fbe0e4de5f2e828c11629c2a3a960ad3f9eebd054b036a2bf9aa97075ae692ad7d61bd1543823468a1829f224271d3afabbb73a749ee454f567e4b5c8ed4bd054b2dd9402bd3c97a3c21dd11f7d099a0a77a4842739a9f4a73a47c4a33fee5a53c1db8624271efd24a7a9bf239ffa2be1f442b3c90004800293000c2d394149122426e4111ecb247c67a00b65213f9247780999841bc9402f92859c481ee14332095af2205ff0411948c3ff64215a02215ff041f2085a2ac917bc0879e72164efb00c0290ec13634efe23effc83ecdd47ee79650f64ccc97be49df3c8de79320074ce5566cc894e72ba863bb47422efe826a2eb648f4877398ebcdd9553cfc9d97172f7d46fe48c95b7e39cfa2a6757e50ecba6a5969466cab4dc225fd066bb021ab648b36bce48a0c4022936cd330b0d5034d833db1d408006061269861b2b0390fa059b1095741312923f14683bec0bbab7d6c3251f30952f68067fd08c9671eade9b5f73f6744d3f037fd04c14970b6321f9032bb53686242fc8577dde00a65f50845d1152cceaba6378010afc052dc52520848290148989813c3546f8bdb0a504a955fe1092af0d52f943deec801ffb87760ff5845b9b457bcacc9eca1e94e5a0fa2053b21d81b9a98439828881bfd4a68f6bb6fc96af6ce71e10d1ec18e26e9ac0b65dca6ddb9036ddb659bfd42715e035e814358928d6180a5f767d9124b33f986606f8bb512aa828a5690618459f484a67a500d296b3d62921851b9452eb5c00471d0586cfb2419ecf428966d494d97996edc44bc9a4e4de235fe9710f7a1ceeec42d2831ee7b81e3d1ef34e8f2cdbe9d123fb0ef723eea8c175e7316731c6b8f3e57ce736eeec1c764a72ce390046edcf4a972d25e731ea2931c61863ddf9dc3bfaab42b9d89d9093f3c5ed8212235f59b7f32c6f3b99ae54c897dca94b70c8ce65a6eb17f9c2227f2a14cf79e83800bcebe438941cbeea3bba3e411f8946be7ee0b2736c789e9d9d9d9d9d9d9dd73452e0fdd5331b03816f7cdffa3bfeb9f60ede3bf9dfdd3bfad3baaa4103f757d15435f2e78cfc992ad04e908a334e789eebb8771c5dec7b2ef00936fa3b9975a83594af9defe84a867cc119a94a3fc121fa3baf3c348ffe5c00d03af487f74a477f7773ab1c38f42757aae3ad755dca75eb82bf8894f445fe7c53693fc91ff8e40509b67c85923fdff2144afee0b83c15237f762e4fa326508fcb53a50924cbdcdcb8f987f78d9b9bdfc854e97a87fe5cad7f5309c7639764e7b0a34ad04747850257285d01b0843f59e6c975f91e19caec3b5996c1b98efe2ece3dfd619ce728f345de8bb1cbf5bf5e30d817b423ec7068fde5dcba32dc391fc5c91fbd915a608837b2120c9407d7a78f93576518625797b8fdd5a5a56f9a994a53c96acda30bfea81255923f4b6ab63c851b045ac86c18bb376960798bc42375aec02f36ba2ecd6a96d5d71398db10ca026178d8c00221d8df6f012b78883ca899b7c0123d7c07353c3019ac70c8384f63e424a464245314d04d0c7e8b2d180c16020c0683c160416021c0603098bc71ef4ddd7befbd5ca4f04e209b9818f8a548908bb1fcf9512395d3470a31126675030c03fd91baf7a6eebdf75eeea6eebdf7b2388ec25b44ead01d1e3e71fe7407f2f011a2037de25d96c3ab584b1583e7689c18771004304c1783d3255f31062790168313281583f7d4c01d776f90345832cd73624ccdb4ffba344e182c082c04181c026130d85dd96b56579140aceaa81d63d448afb592dea803d35257e75e1daf6b5ecccad5f8aaf47256522ee3a0bea01fb0204499e783abf38ce7d2ecf5c5f3ea51af65b97368b7f66a2909fba0c72bfbd537bbbeb4529adddfab8704cdd4eba5c15ef5be226dddea7a65daccd125a95aa5b5d2d77dbd347d656e9787069db2fe7eb384d43f1d7c09947d2645ed6618a31986d938a29860a8992a023c85fd9285a065032d6e9cc0dfcd1004db4b93e1533ed205914bc041261ba1b9c88aa399881accd13c643765d764d37da6f458762d27ddf058a6951ebbba6a164733097bc7061996c803f4d1b265cb1c76803ef2ad2a7006caf121ff08c1e1c6bc82ec1c8ee61176d0c01fcd22d01c420e8e66187ef2389a4168858066203b8dcf179b067f540747f30f56991d1ccd1f442e5aced1ece30648981182b504d30d24da28022bd910a1b45a228a85c40d2a2598f0129d1250ab2d565880e34246b505aa025b5354b7050515d09ad0705bc4e021c504d4b685064b978bb6a58d1e889a404a82071fca1041c46529892474205ac24c1250e84094849a24ae50524a02044a444c984922cc0f444d5c72d0783f2c1de3964b2703d2019e293c2df98a3aa49981926ad75a5b2e18b561176994f100e9062f2c69d6e841039cddd0a305b8ab800722c02c0cf808036b4df4e0a00a2270b621183442e0031a5bd88059649090907e40a38c1eec5cdab08b36c6ecd71768a4410234d668c9c10e5128a17936c4062184104208218410420821841042324284f1a201df15f830836dc07c8044163d5650851558db100a8926a640c28331f0dd100a09227ac4e06c43282480f0629352ca29a58c5766526ee84329fda69c73d25aa994724a29ad94126fb9240a4a4965a694ca2ba794320535958b0a0c2184104269ed9c41a6a5f605a370a296ffece79cf39bb79452fa694b27a573ce7fd99cb37ed63ae7dc2a47d3e06c2aa7def47b0d01ebfee69c733e421ff8cd39a79caf5965a5130758d21aebbdf495c4a5524e6ae9cd6c5d73e9a51ad2bbe6d24b335bcfd09bd9bac6d6ec525bb333d5da9aada1d7d635975e7ae60cbd6b2ebd34b3f50cbd99ad6b6e5cc9ae94935abc532f6c5a6d16630d5b461abbd45a6d4699905e88823489b42012e88b16a01fb01e286f8f84e5095165d2c2c46491b0543da318242c99ec329753a9a65f28e87649ee6f778284d9ddeea2180245a6881441905ad3bd1913d2182631910b8d484abc540ba1cfbc4d9a8b71b4914b47648184d2768408761602117e80f6c7ed6a64d7236e30220c1641881140ec29718c1016f4579669b892704a08e12319f8c988a495b5d6c2664f7cace2880d5ce18123a8382266add2b6d65a6b6d50d06b7f2da62c76e02f36e5590113103d6bf0878384d9456c20db6a8004f3bb94527a420c3050031a41d040882e4a88c97410812f6c43c51a5bdbf2fc8837ec2f4811f8655b11ec0f8eb19ab59dfd6177aca5d6c62d2dd8918a6db394d9568b6d7fb1eb2f180cb67d90d01222226eb0ed9f403962db4779c1896d2f0306ae40d262859219db42282268c0a4650c9722b874b9b22d84ca0017f6622f62b6b50fb2d65a6b7b64e1c0bd9d076012a679f1210363260566071ba6cbf562881a0629c352460e148bc572831fe6089e6a96a40bc826504f7488206213305db238819b8c008d7429fd8075288049d8186a18e1011835baa8a106163d30c0aa0dc1a8d1850f23f0b6211835c078f980ef8660d4308303141217c8d9100c1b5b94b0fd6bc5bb6950a2440d0b54755cc76198109109a2cc182595627e3b929b3eca5e77b6b4cdf96d9bd56e75d65a6bfdab6e72665de04fa7428922034483f47a990934ed0f50505faa8e1ff0847042a8a5c45077f698c2b4f6846b179a98ce16a4b2473e35c67ce268ac8184a54b9d99cd7296d15c245f2ca4745c8a4af0009882aa81e16397c472306315a0062ffa090cb56f179217f38040ad0c7fec06c47d7e3e19c357e5bed12f587be27927962e775838252ff504f89387eae2cb9697f67572437461c134a286e002239a2070902a03268d96c833bb21b9ab974a5d0e490b16c102a1845862df6cb92447d8f2d5a60ea14fe5eeb32cd24aebebddb093ef5e9044c70f986e4be40fd556432d44f312263045a26b75419f3a035c796409f3f5d556faeb512d1443227bea5363e827b00b0ef194c46d2b19ae0e6838d82e1b0eb5d65a71b85d34e104c5e102693629a5843e74d2092f6574c176e50f84b0a0bf30b51267905286b1d18927d0937618a38f59529b669a3e92f747f38b503bc618e352f67b6917a3d0de69aa539a462c942e118d80116ac9eca187b14d6608a554c9cec84a4ce84911282fd4280c0485444949f7d99388b6db0c6348287dead2141b78098cc92529ef0b6212c6e6375967ada78f59c4e244c6a6ebb387c296b4826c7d1ae36a4d2a8416586ed8794eece78de636bfcd6f9e91fc7699394f49dc5edc72c3edc566f6e2535e6ccb5ebcd985a49682cd9eec3113ddec37cb32884642b1411e2fc2a889ea679452a289346c90e766cf3aedc5ec475ed41e91ea29c098eadd8faa38191d6557fdc8a9283beabaa77495edddab7057dd4a0cc660ec1ec6b6d82591303c8049dc148624f644a90bc978b3176b517ee23951a9b25ffb5de9a3ecde8bda48fbf58c52d9bbd76d4bcdab5c5a50c6068e422505c1a691524a29ad144a144a29a5dacca44501a5748b0d0689b4a1b673d8c01149860914af1ad883da73729f7ad17d4a577182af72e474a43a3db2bf87faa83ef5953e9a3b5be0d5aba84e6f57ba4ad59e13d5e9bd4d17a9b4b73dd1d7a752afaa2b94fad41ebc7609460536f8f0840e19f822765f349f7dce5bed44b347fb4b0d342640230c24ccd02296a9741558ff647595a96151474e45a9cf1fd17b2d2a0663993e4a69cf89fdbd077591fd7d51fdfc07d33ebb14622c3b9c324e95071f4351f6d4bbc77db3077fe4b4fd28f5ec474e9d2ea2bf3fca9efacc1ed41ea73df84d17ddd31f51ed412d03d2ecd17428616ff336ed39493dbb51ea993efa117dea463706b5a6ec4252bbd7525a5cb249d4ad84edda29942812804bb5ca5a291492b5d6babdd65a5fb3a7ea084d69eb6b985a19207f3eefcbf142945a6bbd078740b873c021f465e8195bd40287c82a1026f100a39658041c120f213c03a11816ece18bc0a86311d0876660533172cc025f458cb1650c228b0cb6bc05e08b7e0661c6968f715f1d97a00fb5400db67c84102ecdb02712d22c6385495a3a2595b27e61938254920542e3820637a8ae6c61c5997a450d2ee98cae0733d6e4d0829a43adb5561dd81c542c11a8ba484d81820c18d134031bd460072796a05e10517be0806a731b4205f1441a323d5833704825692b488091c314293893431850c82eaeb85c9c01020b986146cd813e08a61fa99b1d90b698316306f26c6e674ebeb07cb9cac03c32e6e00d4d087da2a69312d9aefc81504a2965bdf9fbb561841d84a2505c00cdea05a00b019248427290fcf9a07c8970f856ecf0ae7d781da1c3bf051e067c012f177e2800f6c307d97148857cc18770f822120eff04e8f02c08393c94270c48c0a144913f5f130b4f1d3621e0d961910f3924f2a0c320ff6152618b017e806f874d2b3c75f83515e0d9e157a484c34732f2e723a2e5927cc11b397cfc42fe7c418a1c3611bd0bb596912f49867cd517409f7a9d31f017a3caecfa28a64c7d952f1813c9c817c021364731d58ab59672d9edb35b2dc3feee69d7823e57c7a5ae49a6a5dcdb674357dbfbec6aef664deceff1afc6f28573fce14f71ed7b3b2538f8114b37021438fb1797602a95c588c56adae52e6ec121705b6db16427e4ec387f566f5b8ae3ba221ccfa1ab38d9c3fd45d9df1457a577ca989a65bc21fb794d4a8fe178130e3d0395426892147243adec35529ccd53cde56c9e69e4eb862ad51b7942654185c6d96dfbc23d51a8ce091597d516ccc4d26283e50610ada51b1e709472925c9ccd1509c71a39d4786974bcec50a1a3cb0e343f93cd6832005086e70b1e647a8cf120ea25a6078b0f9ca05c7e9cf1e16c9e6640d802630a418b085846e06ca64004e16c9e68e4ebe69b10cee6f9245f37f7d10dd93cfb06c4470f10204080bc80dcb46ed8701b10203e3e5aea0201726f06044896d90a8290114408418810988f8f8f90880195a6bfc9ad9c314b6391af8a5bae1db18c9005c3583d527d646aed2cbb37cb62a09bde52aca97c6dd9cd0f80adadfa223457f4aac8d55b6a7596c5b8713b460d73b4e02f46c52f7ef922ab8f59764fafbecf3ebba1d68e5f84dd907d2a73406b47fd4dd9574f69ed98e9f845fe7cb41b8a5fa895765a0a63a6fa64d0da3bfad1fd4531bbe6c8f214d8bef1cb06a486fa4a757d9623d1ce6e65c36e5edd85eae805880f187f3a9773bd76762ecb2df9aacf9104cefe71bb56224bb2f80241807b491623803e707f5b48de7b513856ca6eefe918357beaeb925e8a51f255731481618cd5323beacfb5a18f1af88b513baa4645b5a40757789c00771b42618145191f5c808a170a7085c203344d6460c134051630b0580a8389ef2d9376564a2b9d954a2979a49411afe6953f334a29a994f272369093569b5ff313c279b3219c509b32c29b26ab66361a279a29291a0821a438986dc468a6d2362a3d234633319aa9b48d4acfa06a6cb322118295ceee55ede479e6b287e59bbb2648d7b8eebd37621a35b95811850ffb834f104a0c0a9ca298d00006d03cc1c36cf292e68a2536231ac8ac5146cd0d67ac985cae5043857ca0a905300853060c282618b7032ce056adbde280167b75ba5a750087bdbaaa4bb282647457acb1bb735d920e7eb9820a1d5a3069a82b7088612079e1e588e8851559d02ff78c0d60993744696ddc0d285dc08b316b54c181304e40c5ec54625b0e6cb16d6a5b6badad628b12363de5a1034f154d6c7b2d151cb0d65a6be9611535dcab04864958e67401cac53e09319d18a14622c91eb8bf8ba948c1929323a27898c1131531d062861717164a2a8049188f1164a0870bae1b82d98193193b90c247961d6851811d98000736c2e031c271411457ccac59139b37aab7d393a79e8c41d86403c71c5faf18c5e002671b424df18507434031850a5c504a0821a432d628bb9871ce99d93a29a5349b76d639699c73427875d8a69c137eca0c3999e79748e78c311ecacb28c116e99c93b26084c1e61ad8a54c770a241ec86092228d1cc6589a820725319ea600a20230589ac2081ec6809ac2e90632a26a193268c0e4400d17186f08260d1df6771cd2c08018692cb1031ce016b918bb18a59c52c6edf5028128683e79f5f888446e76fd5dd3734a2112ba604bf92412612182208fef16391a6f2bc7c2b3a8c50d053b5c601965193c378c0c782106195e908f686478216628398a9297d4a7f6b844b36060cfc33875f001dfc727e910e2834f332249b821d004726965308d724e55d376d919c9d8762dc7a739b9cc1c9880f69cb71b45b24408004a48d769bba9018ea773de9c118b04c9d79c954a092f9c3d70aad9828a405953546ed5d4da2a9b3ec218dbb2d67cec7a043cb6ba2b48fe84005fa99ccaf52134c15be60440583369a780ba014e6d0825451a3e8690e28c1460ec6e432829a2aeb665f4a9d4a65d0c8120dc5259769ba57eb56b7a48ee2f6e6fbb67543f9f42d5d333aaa74fa16a7b6f964d2b76862967187b6b96e1cc663c5b4afc7876566bfd3785a7d6ecf6fe8b99f6ae1e82f2f54de1d936d6db5cab151ba70e5bab556374b58838216a2bf5dda44024983e9e9eba4610a3f6b25bed65ba08ce9e59290f4f4f4f7018f18293524a338dab9e93ca182319b576a952d62e55c71438be4a69350c744f3d05b6e52c82ca1b1b3480e1c3e0cb426b0d1c2fa7f0ec18e3149e3dcf13a714f16903f7e9be60eb42afb843b463522960e9b63293598aabf976d92929678c12069b3adff13cf2e7b6648fdc1c2e93590d60f9ec35f37cc600d77f98eeda35a148481084792a9b64b2ce6d730432ae7602d011bee6ab6c4277f6fbabb1968f99eeb867e4991ab73c805fd76d60082505d37e9a3fd58b33a4e8210db659e3c504c6673e4872c1fefec396367cd0805b5b6489c2cb52144cecef4544e103de36848a62a9e5a262a622a5f44a09e79c73ce39e79494d26cd23969add44e29e5945266f2be6094c6ef7b5dae9b35b0f8e037ac5f26ad36bba9596bb5f225ef8f311827ca7fb5555fabdef5663745b53937eebe6ed00666760c7233b17bea267bfaddd45aebeb9ba7347f5987ba5258bbd93247a98b7694d65af5a5db96c6255f50c5adba24f05072f3aa99bfc9755be0c8d9dca8ad16a594bb9956df0843d549c9cd0be16d3229dc340a21b4787230c0f1355575f637e7cce8cdaebdf207de4a7180a5a473ceade3b0d8b009f8e5527265e008e19cab2cd35524105b21b1c6524b2b0dd4d635965a5a69a0b6ae5943abad960c5bd7d0325450c69a32ce9401633c53c6cc4119136a4d171c37395a5bb5569bdda036752e417e7435501d2c9ab05bb2cbe2a214a4c496ff766cf81d48246e8920c821104875a82ec378263b60e7248ba57494d9338613714b4c8a4848a94deb5210c5002865b48debd2f2a203c5a170bb255b077b71af1712a15be7352d15bb244d97e7aa150eee82b9588129dcb0eebee068c375e1c2850b17c8850b9c40383155c76d5a54266f78c117632c9960192424a41b9aa0816b820ce73406eb092b5450a4e0c6179dc4b277ec8fdbdd6119bb3bedba64815b74832203504f8800a7f9b89db556e044164e423441868b04504d54e00699a14698113c098162424c1c038a1928818118bc98c0024b21934503496819620359d81c3c80a4451f3a5cd26c7afabb04984d8f97b0c1a63c6c8051118c0ecfa64d6b36e5e2b4e95d9fafcd8383314a9c804c53139b5eea005320586bd3245ab029941248b82e165603aee86a0527581981034427040e2f749cb1c9a085458e0dba2daea441a3b855dc242db57ad84a80a30dac04ce96ae0d17746d58e1eac1b526cbb6869a6e0d3170769093a56bc30cbb83141b2758ad41828b46b5668bba0136d4746bba986bd4c099a00d1b562658b3858574c5f502098acc0b1acae03594e8aee83ac688d41536c4d8aea051c65e69b9726c08e5010f4499800607f07737f528de7e105949795c3b50603829fe04d20e537fb2e93fd134edddbfdea5bdab6f2c51460aae6042aae2a4e9abedb38bb9632e45027be8efdd6c96dd669aa76a29b019b5411e3c81644c27661ef9caced26480716c18e80e627d09910bbf68d3de3dbd8c3ff29c5c6de419d9cf6b8fba48fb165347927b11eb9cb6124be922ed5d113ed71dffeaa26df39cb05e5fc47ad5de2dd2eeddec292df0b32cfbcd32d6b58d9b167792ce98bd5eead888754d7b29dd2435fe91bdda357d548fb5778db6b3b41f79f746dab973fa086bef6a8f88c5fa1136d2479c3ed2ced2de2d621deb2a4ef7ea22acd266cabbe7aef69cb058f89c3eda8eb7eddebd11fe9177b551f7edddb7145665a20c65f664d7f20bac55f62ecb328c6941b3278b58e42b68674b4c536a4d1be4d956abcbaf3a1b1b9bd56ae5c47b77239823078e635d25e7385ec57b8e5b8949d8c91f79efa0777ca39cab728e737ed4ddf3debdc87b77a98b72367c2bab17b5be7afceac6b1ae62f31bafd2bd752b31a9d25558c7afb2baca4a0c77c72fea8e2f8f6daed255726ef32adebb5b896115cc717c231c57e9a39ce3c8398e1f79cf7118935d124f7b91ebaa17e9b46ef491cd6f9ca5bbb7eea55e74f3d58bd4c70c7a4ca27dbcbf70cb6faae7dc087f471fe91c3f47e7f847aeab72b2c77de730e6658fd39e13d7736ea4f31d9de7e8fc4875d7a63d4d3b715d7503b8b4a7dd4aec06d0d19e86bde39cbbeed2559c8a5cf77415a873e81ced11b9726238349e3d32277b9a2b7b5afcedbf6718cb89da8b5bd7dd888573d63b9cb37e74e369ddcdbb1be1b08ef38e759c1fad7e93d24e6ebeba016eb497ba95d50d80a359bfd15560dd9c1e91cdbda2ee30c624de7eebb2973a8cd9642f05e4053d4ef51f8c2a923d267adb2cc53ebf90a1e46c639927ba70810e9e32ed31a1b7b75a4ad534c6b2a2c9951a2222e882572f3902cf675789dcf544f2e7a2205ff0dbf69b67fe22929ddbf6cd6e5151db3fd8e6dab66ddb52598bb0bd7d9e955d13c8357bb61c047decef9c73cb36752d9522ca02a77e9ba4e007a1b8772b9b1cb77803db1cdf86e3baaee362ace3ce3a8c6d94734d208eebba23d6b9c318c775b7d968c7499b89595fddc8c6e62b7de4347fb4ba11be8d66d91cff88f5d5eaac17adcefad445f8361792b24b01c66e646f7e35e75cadceba951b87bf916d329c3dacbca93a4e952f9e3d54c70af0fcf743bfbbc10e4ac2a8e9a106259a6a30c40e492d08030653982fa830636fb03a2d68c286304a6394400aab0318558c1b5610b5c54c0d586ae982dbc2cb952bb6060f2805f50086085090051a25184115b11578e0863ddf72cdc3a0b2508305582e13e6e2ea722faf27a8a079844e912ff839e18c9762ec72fd305850107d3a3229a5b4a5c33329a57386286f1adbd4b822f88b4bccc7bcbe809171e67e3a1066308319dc6aadb5d65a2d7de40e63174e7f3344cd3066b395da0f8aa182c6d7b64f368535b395521d635652334869b3c43441676064bcbef818971809effa8179a0b4caa0517391b09274c5a5a02818547c8a5d2297c804d1ecbab4e76193d8658628a6e8c40c63b643910f0a92d0ce9066cf25f055efc248544c970be309e565cf29e1ebc99e8f51863d9fb62836388120661d679bbc719f6bab609324ffa26cd5b56c73b86995feb46df3450922e7375025e0b259cff1b2332a809be7bce626dc59df62d62eb3bd0e13e09bef759800cfdb6b9afeac703902d31b8ad175d80920eaefe611a05b4a8edbfbcb62e521eddc6db04d86d0475bb1ec6a65594aa46c36e3d8617baa57aced3677dc37eedd6137b45dcbdf0c43da59f66a18ae24d25c71336c284aa4ac0eb7262db4812f6c7889a4bfbb39dd1d4b24782eaf20d02449ebddeaac434fc926a5dedac36f96bd4dc45ad4f4070314a41d03dd10b0f138373404ac705e8e81f5ce1b92c27dbbd552585f5d062dcb2d7f43aac3a8bf21d576a1b9cdb0a36c2599d35f448236f90171d35f44da753b772119f12a07cd9774c1107713d5211c426f1f5065775f6596a6b79a9eb03a2b4b4969ebc5572fde3ea5691886b6738f7a6875d6ed3f2b48dbea08d06df5d097b6d552bac32ee7782a47a4cdda3547a42de5e639cfa199b09e73d90ddd3ca789eada6dd6f2eab06372f39c9c9c7d31d055f68658bf39eb25c002c505991d332e764d6e76d4526c0452dde0ec7532de2a8abfc16e88fbea36774d589f8da68756d71a2b472fb3dee5cff5c9b0216641c882c75c406d94bbc9ac1bfd459b3f6ce1d6c9707299953f2b4838ee23d2bc4b37c9defde6f84ede6e471638daa7e2eebac76fac5fad752931d0ddfa77e3f0f6563f40eeb8d29fdcab6f5cfea06c2e8a2a43f1b27795cd0b5bbbbd97a1fc91e190b5ba71564b47206e9ae48b9bdbdc856412ee5df6ecf190ea9e3debabcf72df70b657e5d50ae7eeaa5577782e7fac7faa73d7b2c7d24338f7549e6a75f89caf3cd5f16d6eb377e3ddedb79c7c739cdc3ac769f9e639593bce8da6a9f4d0cd3d8ebbea387b9c1e627d75789ce377d95bbd3bf7cd266fc7695d95bfb8556f1d276fbfb1d19f95bd1d6e57e5ef861eb2b9b7fa567a8875acfad665acca71af6e337e97ed6d32ebb01b6261fd5959e91828d7e5edb06312c28e31c429735b1d01b9777400efba430b1c0fe7032c7c96e385663774b3e373e40e33738bdcfe5a0f889b76f837e32ea5303563fc1253293d3f9d9de97ba189e92facdcec4ed8ae6961da94ac54a7dd085d707c2a03c2f12c098eacc304584a03b27fc39de9b8458b7c55fa6d76f84d38eeb5c7b93d0ece715c38872e1d97628775131c1db1e4fc669c692109378e2cc9903d395a96e1e814570bfa581d976aa10ea894ec98a972182a44230000000000d315002018100c09450271300e26b2aae90e14000e7796406c5099cc634990c4300a82206300208600630820840064942aa20301946a70aa9e4126bc9c963159da9b7e6a1782514880c1f32f774369bf5052c700b13e82cb399fa52af277b9f0d0be18b0876bd0d1747de2522fd6b50b1a412694da9fa8f606ba690ea60c289d1859eb9757a711b4702dc182bd32a8bf5bd29f58d408607197163c02efa19be661da82597e4de90c15f52dd204b4dccbb155ba44abc55220889d5250d440e75fd6a27da565ef7305e2b31502c2c19f7d8e10781857526cbfaac8d603e3898e6577258a12a014bf51ec1e95ca69561c00a6ddc5a608be431d301860c8ed0e9787ed2406c2825bd58d10a623630f58985a1801676ad2893ee0aa3da594a1d5b4b63cb02e826708cd6cc5497ba94dd1aca2a9dd5dc3dd3ebba452329d7322174473a262d4a6f510c7818802106581ca7f830da512e18d059778e5591a15aaba37ea057c195b8ab37314dfd9e7993adb4ab593cd51fa3c57d402a5b839d5d9a2492cc4404247883acc4420601484f3c3e32509d7f4d2c15b8db31be32fde779d62291ad12f7c08e24d5c84601ac8688684c6819f30fa0b6392a7619a5db3e8078d97710c0c3f517aaa1510eb405bf551329e288bc2ff9056fa88ca11fb7dab724506fdd8fe764cae53dbd5447e6898da82e3324e87191b76b3fc09ad65d42f271fab29f0b484c439502f24c003fc647a0bcd03911591df42bd02406a38b8924d50c05a00f190840ea00711de30518268952e84556ec3413eb6469482923289a966e568a7dc7aeeefdf159baad3f4b8d5e50bde370db8674310eb77e59379d9a708bb8de482ce0fe90e0eb41e9f366bb18a15b55730320d591aada7180f4708bae3668f6e0678307549de09f455d8c0b6cf12b9aef5a36b5c8e461425e7cbc1261836083b22a328e9ccd70fe11aa5da44b57014ebf535d503372bfe085f122aa26f168e462e048cae005da3d801e6ecdc0fb443e894dad8b204ee41b52f491bf611459364f61598c5ed6f56646f12232159dd37a3f51e093754c77ff125fb62f8a9a21c86073ed636a8306528554bca2a25db1278d603e83e8a7aec0f352028a6792710d15705a2807129821033548d75ec52cbbf0c7ccb466dd056e40db05d28c9066c9710da27c56ab21b26747771cb5fd6ec1d4afd5824a310322a27c516079ad0322ba7f33d30d6d017b8c47e0c635085a7904eef619e2333c063995a1f648d4af8bfed8937aadd61cfc061820cffc6434bb763c34a9469f74464d9b11014c0d82b88f6c3275a18af3fa2b053eccbc81f34f059cf05e5fa10286f6b4eb64fc53d442c55ac87a72a648b153e835fb66d132b61ad1adae757066402db534052afde3751c88106a10cadcb854350d5eb2d0a31d335feffcc303e46f324740124ff816f40f4aa2d945578ddda388c22a4bde6fe2942a09285cfac04877883264e0de93c8f505097a28be9c0ff28e7fc4ac6c8de4b23292e46474a3888090fa88f0a431e962ca8fc4829dff3d90755f0dba504acb0ff256e4643d7c8a090b63591f5d81e4bfd6b04b0041be29c93317113bbcfbb55815384933a3291b2f08297ed41297e88123c8732329ddbfc545915e56a7550fe97e658ced39b28d4099f935b00b0f5e443b20b0a2cc3f68fb1b4e3f42936b35be4836c0877ab9486a0f5081f347c59d72f0940ec17b1deb8107098a7392149972c8dacab1655b33e7f99a6adb094374b432c0d9298a45e82d9906443b380d9063ac1eb9a80363b5814adcbca7232f47d5cc19b98fc726f8ae8f807244683456a59b43994f645e2bd28e0f4ad7926517f646f4998c70d332c7a56300922c1a5e3797e0729fb9d1f8aff46695713a835c773c1451123e07a2a04b04f943c88c9ee0b687c1d6aeef18e71e4a3338505bf8109201099ad46bbf7c2837dda08a6ab02508bf0b3d5a1ae930a8ef2c208a23340ed3ad630e46967a73cb17c45e148f5c1c9a9cf4065f9ec912ac3f9ee6d11830f61eef026e2365957a02f820415dafe6ae30738c188b31204a109a36d95b03b2215fab322183f36f5934ba754137d1b0ef3c4afa1758f90fde37819d434b84c74011bf0d6f5883406a5742946e507d3c0e5bf204f09860bd9d2f2ce7326f982be1383b0d8438443745c9eaf514c7ac95db1d521151327b6c8d50063ba8a5882fc7372186824a45a886b788000e2db420d801a31c8fa1d76bdf45f84ed82478a347920e89bf93e1e4fd84ae03e90aa43c32a7c4da37295fdb19269b69b50c0fd179dfbb1f403f33e297b3bb1df44318c470ba591bb154592d76eef54e5b91e54aca063f1505188fefac26c045bd6d53a82b32c5d48e6995950a0a5161dc71ae261c9772400637b1f6bd1d3a8c2c58516d98523e787c62e072c7f421e206552147ba2a8286f120fc768f8504ddd869b109e1929ce61a2c7315011398dc6b07cf5f9f80647806d0d56fc90fcbd6967940dee1e67a841c703847d26dfc27babc58244805092230346d4b6c81c9086625d49577f793a64fda86db5fabc144d5e47de5513b60eeccdee0159c5786939a7224193acaebdcdb915b3ee50f2c71720b3158c7fd940343018f99931b24577086451b9856323104308868701b0ea87945cba099cb6e789a1fe861cb7a2336cef279581d2e13c1b889714b908074e2028857e04be0ba074e77f7edfc0d4022476e3c2034199af049d206ea9da807521d3741495685d4d77ce4dea8ce1854cfa64592bbce8da72af921d075f4fae73a15beb57742f29773af7c84e298ce4496ff7ad524ad47b96d3d46057b4db5d3de2bdcfae76123ad6456fe4feff92161ec38e7d4374d572448732fdc518acc302e148ce9b98951f47d092036369e59f3264b60ee3423cdba8bd1c846425ba95cbeea80b7e3e296b0badd524bb8dc4152fc7fa8e9f95434e31c54367177a2960930e2259e490e9b3b03298787912c0303d3b43585bd119e2686ab6899081d3b6bfcf5bd4d23a10d760879f7d574848956e50e411c831b2e5e698828b9b6171471dbbcc1f9f03ab5c84d9d5f7760b13797d82e5755b71f7017e7d60118f914b1926e8ef11c59286b602ac20fadb597cd132fc4c40c4594d3b7acc7e809402db5066463e7e5d48c3d8bc678e8519807a0a8bce6ad127a1e24d452d4ca096b373390265b2954b8ccc8d4b974fc361668f8b47580d2ea00c879dc83e700c917592d8b91167bb59981a29817f69b9ee6a806ff97ca8c821180d09468c0106221275b05042773577f7eb8fef0f3fbf7d489b68645de51e027a1a9b1c9ccf2616f613e654ecc0082bc844467a52a42f2c00c1ca99479ca6fc297dc4a235140cf204ed843676cac14cc7e770000d6fdc65404f03142fc37d715e945950341ad1c755fbbbff3702e311cb9450f23aef20dcedde5e52e6f02e4bd2fbe7fb0c6882ae633e0626e0f7838fee265aba10dae4817d1eb425c0d77b1a57846c2cb6c15bc93833a7cc250ee94debe58db9a8c0a6d83a014bac2555eef64801b548eb46f7ba60d2993688d86fa79cabecaa0721be4eb4f521df625cf7fc864c188afe2baafcd7e99e3e17730515795485e99253cb35f7b10075c878086ea5b58931bc33e6260535fcf1cea904697353ee7a66969854768685b721c4c67e97f950891cf6631f34016c8004ffa45ff2561350747fec1604d219e3b26e26de4a9882b55494af9706cad4a88f73e1f9574cfcb85db1e183137ccafa14d378701222c9be12f621639bc9480cdea0707a13208a91ac6b208c9d1f20981a3163c3da617b87db3a526af0625acd3331a73e0960c6110ac8fa81d80baa82b6b5480ca1353523f79f5f314ea0a8334e2814371860230a1ed33d3a98efb10b4a7211e67aa1c5b9908ba1ca54c57c877c42d66992ca5e601bb3ad8c34c9d8305b6554552cf3de2f6f15a1ade069c88f83355cf4a839a04d83c11e395888b6275f71518ff1a0679768233cf483ddb2bb3d3e326e6166defd884c6c16b208ed2eeb989469529213ce01b111826905af023fb7fd6146df1277b309dc28e102203045ce2080d9cd81677fe30b1731997effb4fe988f0b34f96c8920c117e18485cd32eaaa74c1c1f84dbeea2cf5096d66ab9cfde0e65cb24c82554e9165476e9d4b935570cb0adf7fe7c15951bc03c26e12295d8da204220424782647902575b6560e172535669f034f5664e8d9389e9d93f58bfeb290c4b5d39084f924bdb2456a75b7dd6a568be9531f0a69d372011842c20567a6f1ac496c63ae4f9b48bb1d285a412afc67284a350d5bfe18eb049f43268b998e6980155e8f231c49a5bd4e8d4e8aea4b2ea83d252c156b08c973bffc8b4498bc9ab33bd5b0fdd317e160b031bc5753b6950367b082867da2d11a5d34c5355dd642993c54b5feacc3b1448cc72f0ad4df1159ea12335115e7bafb71bb0d76af44c9bedc2070fcbbfb36fcb88ab86684929e1053925736ad2e88011c731b293e0fa73c202fab60adec36dae4cbf0252d6c46ea76cbf8d2f59122ba5c01057595955ae2d9acc87ab821c423460fb5be1034fe9aeec9561adc80d95387d82b0e924c6ac4af58f31a20541537ea762b2fab57422b684ca95204188d823d2f7c9c900e0ea445863343847e43520938bab887d81538e8eb936bc4aae9b8a9be5f18cec1ad2cf1a767b2030d5f1d85bdcfce8bb6d21806c9e7f0b9f77b86be6f633d91ae2ece2e826ac4c4e31b875e25e476b2ea89894b6805d349bb99d41c1108cc84af010bea728dc5768a9dc8a3d8f977299e0f76b3ee3bb3d4bd727c569fbd855e410b93475dab51d61e42a40753011e3190d58b53e4f93b6d64fc384e2ecd106f16fc0afcdfdd70849d953a037b60e9eafaed1768446fb468287d11f4bb42601f8e3e41841ac58826c6189acda3fd0a70c9d7792f368791418c8e39e4e26eefadf0ed092784ceef4799be02370b075032c3179aa66558db0a2397d5c8a87b50ac49661d149e32ebeda5b0edc419afa4c63ba19e6f71eb3a1c2d2b41d5a4e357eca4c3974bf00fd300ff66722210ebaa53fc0bbb239ebc3b778e603c36337ef5deba04ca0c9d388a917907ef7539abd1cc32f9cc4f364449ba01e3b7c11dec29590ead6254c078bc35cc368b88a9074775575c4b084718b99af999e57599e1c1f619a740200aa6caadff73508544da8729054cda08f6c93ec723ef55e7a737fc8d35c10d6d8ba7930755c01014d1a930faf638b151c41a4d93a982645264c9c6d1a5dbe08b4d937bb900e7acb4ed2560731fe6bda0f946cadcbf4708fc2e0a2b097b0f259ccbe97460416baf5dae28bce08d04050bfa6cf886cd577e3604a42af3c3507587519e0ba5dc98eae3c1e5e95925a5de75320d65ddf7163de8d203d00d12cb197c4e1093638564893641620fb3bffdefc88119cb59b7a4790a5cfaa07e76f1d71716da62bd8c250e082ea9470df3d462259532917fc00b5fa8d9f9eefc917de2483cdf2fb5f6a34c0fcc3bd0030b7fb0661486fb452f6c508376b55ea3c0512aabe3cd9e37676dad4f1119aa4cb12574eaddb5ab31a4f0caa7bb268493cbdaa9e4ccca2e1082565e55b6a3d7cb33282a6a14e64b95a7c4272c5a6e43b1213e360e6ed236d447082d97eafa04a58645371a6990a78a2fda40f12ad972e1e5d6aa9f0cd3498b93096ac25c89594dd6f262e006f185e3a0e811ce53433dc0cdfb887b3856044e7f3e105b0f046f564fb1c9cd8820c381dc287e714e0cf0e14289fa7db38944ac40bb9a15b285aff73643e5a83edceb5cbeda46b44503638bd7fdced406e75a00f1012f6742c4395dbb78d0b62073c117525475de6c41a9979a659ff6062790c6cc20101e43f59026320631cc26855fdd56bcfb43692f9e85e9390b9e10d720b74c523304a049f6d5a25595cbf820c52a41c5b683af0081a627181712e3597b6d002a123d6a054bfa532eaddaa1f9c2fa43297d1db09da529ba77277c7fec848d095121bcc1fe0ea2e4d71b7804deeb1194f65b3a3defbdeb6ba0e8d7be27454f985105883d9f19c009c25ed2f558c8552055d4fc4e7beb8673e5feb4354df06238859f31b5cd5ca2c1985e9d7dfd6ea5e4cc78b32783196a30052813c453d402707c9dd481d22d66a6c454cd65959d106b3961c1fc04838219b66f3a9c0d745895f849a2d68e8bdd2768ab90099289e4ff875b174dd9d0aab3844220aed91f4ce8c8165a5cdf54cdd40ff0b4b683708b18ea4264ec849a159cf2500a62320c49be9d0908afc423d8ccf40f6f16927c7c9e029ca1e27ca8963c20a8f15eb27cdc542102bde92dc18bcab89fd3cd6689f698741cb659681d73beef9a44d50cabcd6ebdb92a88f164b6352d93b05d236848089ee5f1a07598f33279907e2c1b9fc55bb73df30945321dad79a141916b23296d07b9d2170dddccf9fa146534333a9985739dd620fb3bb3c88c2822f7bf4133e9fcb6cb960605fcc06cde5e5b94186d045bdccd248845f7298358e49832b4a3ce2c0238747aca0e883ae39af6f4963ab029ef3d78814e6dff8220f5ba41be765470fecd3209ba44955d00eccd9fb924ac175967c264c6a445f8fc5ef76651d571fc7e4ff731f0a564b408835144d87b883d7aa3f24750404c06d78c9f065b57a7033331883a26fa1d3de69aa65f453f6f732b623b23a21d6cf1fd9a35ed77b144ccc2cb0ae39a7b744f8eb4856303818e5c82d2018bf22a3cf078e359753930dea267f48e4e9d3db1d5002706c724e494e462ad471f7eccc734b7dd02a384c4f402b662ff33c35be93c06889897d57657e7977dfce32a0f6d02ce3adc77b34af9f22263ab404f88d1d9573e6a1f1b1607927e81fd79a4d1e8ddbf3a2c8e1a92f8141a22c1a22554bc88ba5be93af5a54ab608d1fd8cf2ef04404b5f8aff50c82779c3e0e68150535ce4e04bd97aa28541bee0e214e14a204708356bc113cda25fee0b1e50b9c00645de6cf6ae8c113225a3274a6303b34aa7408b8e5c5e35c5cc80f10f24cdaa6c87f18b4774405a24e301b712408287d9e48a72daa726d863790fb46dc3543c8b7cb7a3a1394b70afe84867141a6594d2d36040908abb65d6eb539929de81e27217e49450411fba87c8a175df0beb3f81c64559f45532bae17626adfa837056872bc8f51628726817274d0c17b6703aa0c559397133aed1a7b12bb1d6029112b79cf5a26529069098aef22f0331c814159d4bae0cc91db603c5bb0e3481b479f951c67a06f075937d19a4e2d4cfc7fc2e604f59c383a88f1775fbae93a4c22c529a4581a0ceec498a782cd6bc6991f4c08133f7b14a866a7b13861ca448d738ab9a8e60a2015dbc2db192097bb1d87df887f85cfc2d462cb6e1c54ca4090374bb12e91d331c83da119cc96c8dabdd859546c3c69be55a6dd44924ddc6941e219f2880595749d9d70f9ead23a6838d09a5c48cfb800aefa1d9978105d344d13eab180a0e578018e103145a6445950fa86728cdc7c59ad19a7030f34b25f27f7fa0651f8b667db49140dc1596c6fb969a6fd2b99d1ca04e3b380172b77aa7262d428127937d0d8dee9f40ca82450a11a197bf7c4b5db0b1bac56f7f28d629cde4694893d7ae88b29a01bd2a2944a8afd05fbc0adcd3c32e58047433ac6449c48f360bd922d28f180b8c88629b92a95bb77501769136a98b3f2a12eeee8e53804cd74351a6b2264c2444a240b25c9330580d820ef0cbd726f6e1749f6faf279e37d1663976312a4b485f1e18abe117d2ecdf162a1d116b18975bc27b6e806df24cbc0618574485beab41b8dabcfa9e0530fe93d20147ea837038e13072a496be7c23ef60a074574888d979b6a690a4cdd5b0f67921f20177ad9b782d86ac95c2b4acd297fd34d84e81be44750f0503ae406e6d909e9d0f46a9009484942124af377600b4a3037f68948f14240406a38f501aa1257f4936d3a0736288938b80a2110c6a2ad1ffe29445959a62ccfa95f719235e4cd94c83a863f75098cfee97cf6c7d5b0dad3759b35db5ed8128cd0322919e2fab0b7d08ecc302708b99df12232d1c824344fe3670a0c21534f89e0bdd2f7740dc2ec794de2728657cf141e0456cbe33026be29b8e544f6a4e655bc6506cf9e9540d80a3b92bfc78729e5523c8f06d4a942d72fb1bf7cd3451a01c0904e7980ee45956d23cfae32144941d336cd397e37d509e6124216742ec8548210b9a6c9cece18671639c6d704f63bb6565f7690f7678721a690af9fc2987d0548595fe30dcecabf6192d83c78f8189260caee6bb691d9e5e1c388a1a4089baf06861450ecbcfb02efdf7cbf0a8ceca30eb394388959f2f2375cf46470a9dd6671e306563d697e89c7b427bfa7897273292062565a4b0a3f85fe76a015cf2ed6e4e33417aec98284e41dd54f517c69324cd5892b9cf478a8440b876e37d2b6bdf2d6833e91cc56071aff6dd82038f0a88bc643f7a64bc074518f8e200719813b7a096f4e435f632ac612c6657a4ebe74d23aadc5b5134dd160a474a1a0034352b1daedddd909917d152ceb277cfa11a74973f15c2803abc6d71fe45cf1a879adc8824246f99a8c3e00db7b29c5e1b3058b7878fa9db805fe1da0f2aab3e50f687b5aac7023f69c779d41110cdfb54beaad3db9b7e139be161eb7b381debd203c96d3b71dd5820e229067e67bc44cee6f5416fe2043f70a46a9ce7a88a4a41b037f501374cb9968144aa8606ab69096c65d3b6a6d6d9f9bc845e2d09011a0961b64011f35a737b46b4679b68599013b56e54b5e277eaa384b819ffdebce902a64b8d002c094124e91e1f17d4b2bc8c20d23510b6c9817e45ba782a94284683fd4dc18e474dbb636981adead3251354106dfa25c1ce77da0c0130ad39f1977d592629e1125846d6a56336a105d8fb58d1ceb641ae013772cd3ecaf0b48acbc4bd3ff9b70565709f5989960397a587c4812e8cee5d01e27ece34f5b16bc86c37312ef8cd7307aef4e6b6b66ba1fed527dfd5ae2d9c77f3ae61c6378422f422e9ccc85541904d391dc4fb7a0153baf24700fb94965adf575e1596c694a3d3a381c6d2db755f630c490017e9a4ddbc505b0bae695a6d42dd2a492782cb59c5d5bf5922af9b5f3202120c53b3eea8c9f2021b0dcc3c943e1ddd0e843a7d9a8ee0ced8dc87a668f6deebfa164db991e1b032fb462585933b6751032b651960d0f2d026eaf07565ffa40cb8b25ed15fe84544923eb111e29d2efaffdbabfee193a5dcbcc5c30def70bd7f585d37cadf6f2a8897b0a5ace33f8302b64b284f547a59ea976592065a23280b35f2780231becc3198b035913e200e6e78f38a3ef9ae646877463bb09c326537937639be1320652dbbc72cf2b645055171bc9601cbdcbaa70eadbf64c54fde5f78c42f17d03351f529b2f3cc55b1bb9466889013c6074210694ba8c3944ddfa8722929e668ab163625f7cf03d3a61078fa779879d71879d9f35c1829c26e55e83adf9cb255ff4bb0ff7fa237899ddbeb2b71fdf93fe59de5f6418793464477730cf1faeff90781cd1ae17df7ed625dc71e3b4256547fd8586a819b0f26dc7f49adbe7f09fd7260259d5845b50c43071a2b2346410b054df91ca0b1ef371adba99a9d556be71a95ad49980d26185a8c6ae7808a999a34bb9375b423557648d6ec92d1a68e8aeb3152257fd3573477ef62471562ccc4474707c056d612e2f1863fffd44a0685990876b1a7c1a6c68fe27a1127102413b432700ea794187c6f042718ff6f6c0d5a532514fb5c83aeae80856d64f0d5c169e4119e56cff1e2f878855bf37df1a5fc22cc0c6c98a933efb111054a7538bc1c32976eaff63040876a34e60eb67e442f4c126442abdbc764ca1673e9a8a45a766e22c30224a2c41bc9a86b10d6d741837914eadb275ada129bf185b0b9c46eb35afaa91f133d5428d1fc0d251ea7e8e1e9db869301e22078810d9a459a8974cb822724f588298a4b0b25c69fd6888c80b94df1086714c726af358b756f1fc6360b469571aea4556fd16e8a2760a2507d92a05d2eb7f6e35e9ff1ded52175d7b163de694a05307c59ab70071fc791c81f0b8ff979e164e3d0e1bd3fae6d44677e4024273174119f23bc87abf1189d5a34ce780d754415e295301f711fdb51c80dac45cbb17f40095220a97a113c50aea2e979e044aa17161b2ae9289f408cea251fc0a36f84174c70dac9d7d4aadc4c3ed722e7c2ab3362e7e02751cc9f7145af7821fa032d5b3aba9e7fc3fa4e358501eda77ef6138ae9ff0e0d1cf1bfa184a350a85b5fe1e75293357819acdd3afd62137e1ff59077f0301d32eb45ce0f98d46a4d46727b091a64f9a798093b97b92eab9c249b00ad3674e842c58fa9329f1378297a8a75f1f41961ba3d9ebaa2ac65354d92af723edb1140eeb2b557117f04bff12fee3807f9545998edb4cd24ae37ffddda6a15eb750be48630bf0147a7c0f44ed909d96bddf04658fe009600344284124d14327f0724732cd16d26d9c4271653faf0646318bd4c9198fd8a7014341a0a8bb02aca93268aac4b99da82c7e5587e2cd51c45214cb7229cf9b43ebd20c72bfb14f73978d1a42c23e4a19434d1052cfadd44c3b45122ae519d2023d8bc19f61fed2f1cae851b94ee122aed9c09884b283524967ef9e0f80fda203827de0562e198c2e1f0936a1d0dc14c53e4a64e2de08e5cd384e32caf568e4954579c32a2fc83b6aad4adaa702b0e8d64ff2ba18973ee6d49a35f3c805393b71a1c8a3429d2ffdb623b166801409c82f00374482053462dd309db084a50b73f5ee42de462c1d4faa12d3fac9ea167dcc4b7803e2315bcca7a75154f5fe1802291b5eeb94647c580b297d485e8cf17d47b74dc55632fe149cc098dafa4a8c577c0d713db689610726ef5bb95f3e4ab1efff63516dd143f51ae6766f91c826df31f9a80e75b5ee97bea1e04d80677ea5ab55e08fe736d5854746185d1adc0ad50f3867058a3439d6d38618d85018251831d37007818056263c73993f21dad787ed20e203e3673dff800071902fdcc2089529557c86a5b842e7ef5c7f84022a1149122a8e17a059c551802f07cc64bfb93b69b116c247f26b3e6bc5107af75af33383b87313d3ebe6753b6d0682f12a4ad0b79b4e23a8760a8bf7d03fb4cc6e65c954fd578471313115ce7e2d22898892ea363828f9f1a5980509bc78ce5d32e048a0d86533c881edb05847e2e922fb12283e738f69c17d79229f848e923062247ab94b8d17ed6012d258695917cbcdd64a1913aace0b10a61c6c947798f42ec81d84f2860390d48ae9bcc269998f2c79e66ec5bea917a849283c3c705851b90043dc9c784b8e5762c99b03c4696258c194991e64ea43ae20dc996f1f86f9db8e670e56054d126a679c15eb911fc048700299b6ef609c9719e946381850d8129079a058ceb6252aa2322b2dc797415e196663f7cd40c5edb42583769dd8a547a4a6cf0a1d7f169796506bb6cc9eb1e6ab4badeb91d4335e6a9f680cdc4060b9e2fbdb87fe950ccb19928ca1742f99aacbb63c2c0a64d7698f654745d34155ccfa44c18c3a841390b6d38c97c0c2cd0510582ecc6bc3ad17b26ca34a2fb215b1a6e112ed79508be134e09ecf97a84ea5fd9eea2c610e4aa977da1cd9011207630af99bc0ebfb13da475e51a8b92bd80ca80017c1adb0b53d66d009cf97e8598139cc072c423441a75501f6f45ad4c1afdc6b7c18ede322a5adecca571632a7ca23e259d0b3aa7f207305f23a17e45d4a20deb6e684c9dde60ed83b6e121ce158c704ac6ee642644befb05667a4b5fc4c01dd37e4d476adfb6ebaa138e93648f17f90c963a989aae13e793d29e1488050d44ad528692c5ef8444193c4687d984ea17efedf49cd452264ff6916c5c33a5306323adc1f4859fc30df9c4a09dff6eae7240a7ed4d6885fcb63ee56e975eb90915dbe883501308aa36b0eaefed2da7d5f5e7f10e37c544df6f643a7611c9947346b59d71cc60c46a1d5d6c41d450dbb410cbf79f17e202c43788d89b275d838352962450fad12b2348404315c347c994688b95544b9f85be0cb3ebea3d961b99681a5b9bd13c329aa23d0a6d2ca80551323394e1fc76ef27787d0eb4b89606161cdb68e5f538a41c7528bd9b525624db2efa1dd18be7f14e7e858cab45b2306e726789d1776b30347fe90d023495b923b74d674739702c9b9901cbcb9a4e7d3fbde930d6ef6c1775597df630baaf859171dc51d1d93fad28e8a452ff234801a9ed7d2cc2b1684453bb99527263b9a8c11d654ebaa5c4d098099e49332a29dfb6113293932dc50d822bd19af295c1fa8265262dfa0a5973e750e33ecd037f8c76538ad373ad9f63b9e40e4dff4b85e67f79660e27ed1e45d10d710ff4b92e0e0a887bc72c915e5fdbe6a5f2648ac95f163a8edd061bad1be3234b27308c611b91043d99acb0f64ef6f6ad04d56bbc4e779248775e1bc128fe0118e33d3d6a44c0efa759e7d857a77b3436f6f03d455a29286c20e6d9162cab9a5a0d24d1c31fc7db8964be9f4fb6d7435a0f2d165ba0f50010af81e0527a6170e738ac0d3f3c1ffc77b2cd750627a768cd1200c86597fc8d7671a41f1fe151ea7437534874612c25cbe5a29bf7192c5670b807de735659a91990d10938e0cb80e9a3ec6d5f53401f3670b9f3c2cc31ed0e6cc1311a0eea6989f92c9e8ce89ae97073a0e84194827076ed2e7e2e540485e5c5cd3c68ba16aab9b28346116a97cf101c815257cb0012250658c798a256a8e8144d3eb0da89423721cb0a25132217968207a076f8e0d40dc0607358a35963e6e74ca502187012cd8405efe5070064d9f403f79cf56f66a0c0225a7c7a1fa97d0ef6563bb6a42564e43539fc60006a717829a05547a3b5af02c43cfbd40f196ccd5c9e4f037042c46439e805dbeffaa7ad0b5d3018f2f3dc72ec8521e1c5fb974b90503d5c76b1a80404695f710028f69e1f87d34deda7b7b28058a70ad53a5f74eb429c44a52f046500f5fc9eba780256c6961d14835dfaab413b21fde04a2800dfe89096bbc878648bb6880680d9047479687fceb201b1d57c0fba429aa967c96bef8e6f0ad7136670656078e3ee3fbb4d65cb0af1d4f2a0a1b85fe8e0862267f748390d8d45eb1d16e0fa3631fbe0933de0894d3c9697e5ada267cb8c050bf80906ee0cf5fafe4517cb801a1951b17088ec2512afa0f4be5ace3ae61c343c627f78e354bb97cd0629d1a6e924571008a63440fad7d5f69cb6378a2f3f456d2ec4f617f5e8ba8504dd783b650c988e5b49585048602970a1b5642a00089405d71ca4f7b40f617bbf36185784fe04ec4d9b5a83ec0fc96e1c76868e8ffae0e7532d6b7402e5864dc77eadbe9275e403bbea8ada205f2550c50880e9b0342851c5c53007b7d8520847fa489c60b3541aa4c35a7856af6496392486cb14bf83a271a3b693f742bf102c2635b03c601cd23efa33646f5fd9b46fa5e44204727ccbb221934309c111ff8758719693b6ba2e89d12a3ab6dbc7b243f4bf6c8cbbb5d257d00e40f3e1fa92a9b8e9e46493256de71d1c9163922ab0b2a7d0a9f5cc9a8ae335d000918099ca029229a66de2aa651815c8428bfa1b94782f799057549f606fb8ad3d58cf1a37065da603094eea4653bc593ba402fbd7b20a3366c246981378dd291aa7b44442e78bfc2084ffdf38ee82b8d612c7f020babeac14ce5e3ba1fb707dc997652417564188382db5c25be645a6d41b16e817488c1a5120fd866885048788d075226599c81c1df626c59c5add1e5fc1962baf239237f6430c0fcbf97ca33111ab99144d798e18e664d5f8e852eb48d85396620b0f19cbfd12e0d867aec51d53cb01a81382e184fe12b8e90f7ba568dde8721f7abfc30ff322cf097b48b8eb1ebfd004fa5aa9600184ba35118a8cad1620626be68c7bb9592970a2785759d6e86b80a0d39ba9ae6823d4c810a286bc913df00452d023c6e0eb2f04453fd514b413683505c662c005bfdd9be192be185add7af4524807145492000d2ba8426b0bfd8f5de09834e0ea1f36cc59e79388f0c9b695fc273858ae101d3bfd2464bb53854f9a82418dc01f374dbdfbc5655b938c3da8dd6a0a0ef05a0bdf496a7d24a919181709c5ea58313e4f5aa1c1cdfcc38d146b4d784bc92e95c47a132b7023b613795646873fdbce42803e05d0cd01a9456a3144b18020e76e185d232c6edac45aa67b135c050526101ef051fbfca73b21c0a02cc5a9516dd0e04ea10ba00e3fa2e674c251450122b9f63a24cd1f262344f9350647719dd8fa4c24eccbaef7c4768a043cae22a5bf7a659198f14ad7cb7533818cac48bb6fab60a25723aae79572e14d3ce7bb56f96c38ccd7074a86c5743ee6ce79036e66c7dcf7e119d5cb789e85bb10dcab84b35900e4d40d66c1c34c4f2f821968b3923fd314bdeb55be17aca04245380daf4d6624866311133b40e4993951ab5630f9940e8ae0502f8d62678ed5278773c3faf6fdf7721aa02af6bd7a7f8cf2f71adf29087aa8b6b77715765826b9f7cfa73934d1c16c50e8f9101de132a073a7b3fdb97ba216314bef4a53bb8dd17bb72050d5e4a7951a176a57d6a9b4eb16bf4aa854210b7496ab3a461c29ca6bed739e81f59e071b53447c40be7ac99bb6d166de1f99e073f392a193bdaa7eba1ef3f7f5bbe1c9e92e063a8a816e8ea3f3ff2e70ae67c4dedde7c332d6b01fa00b3e8c7b168791d82b8be9a15d6118cee92786ac1743914515100db77d168a298b3034ea20e4a4d5d024a470048598a83695829585f56d995eaf536ee0dd0089fb9c28184563dc83f1436837b83d7cc3729c3e9e10f26fab415d501835712bc23eda7a28c49a63a5d07d202aa2f6fdb1da32dc38bd24110eb63c8102e11d5ed1280b7ec3f741b7da61e7eddd1b044a973750132aee7b96c2d839e0d3d41d506bc4e2cac0d001170cfab6e2aa593b166b19b9140a4f472f02a51d0b38e31165294dc7a274ea029eec584048b2332d551be042a60c59cc91149f59b46162de580a2dd2e2e7d225f60a215f7b96b89968390c1496c075d1015fd598842b8612607d07212a77294fcb0a3ff122eff95e06a5a208bfd4a6a91622d34518b43f5c869335d82009033422fa0383c9a47c21a2f00a80dd96aa3545e1928fc0e47935e2305da3e61e48ca4d281fbb197c0b91c43cc1696ad70d51197847dad972cf9238f10ae36552ea649d176f99f987554654a6b24eeb74515a2e909a2718594f4a3b47b385aadc00ea8c6ea49e2c2f67233f66e14014592f92cb2851836052b393df3df7690ff668a34144b2fe60917fd8ac04d177c3669d12cff0be796aec9e94ccac0f0e024803def499f42c8edcca491055984141164ad60c442a9e344b62ed9d559095745ba141602fad45d1b0562d185e6bb8421ea34106620010d574da18ccfae55d55f6a596afff2b474b8ad57793be1d888fe579e4eb6047f7356e68ee30c442403bba346bcb94d66620b8d24ab0382e818fc5de51b503c6f8485959aef311a511dccb861f546a9f074dc0ed2028b02a44805efd094051c4a1e01d221b7bbac524a60cac58667888073bf6c4803e037cacbd4736bb1759db6fe3ba8d48298e8adee76750e04a2a4cc2c3bb2292f3122468a9b4774e4e91d088fb524ebfd01d29e094cde2009fc7ad0ea755dc1048f53dedb49bcb3d8a128f61c8f6ee56d8ec2355bc5af5e0672a9a0f41349dc3a8abea87c0d9deb8693180736adcdd35e07e75c98941db24d6fcf50bfa9a76055313fd48a8b6f5e2ff3312b9c492c18ce7a02f6cae990e7705512441fd1ce32c511127be3b5c6041b76d3bdb196affeb68a85dd6ae813cfc7ffdd8488ca98227914a2bfd21edd4e80e091bc8c3258540f3a9055edc0321476f940732778d9108ed69971c0c79a603cc46a5530199d638aacf3edd41c8d3714e6d4489f31aaabf52fa0a0d64743e87ee2e5d8f9b1b56365dda61731c39f528f477c2d232d62c25ea7bca7eff94333e9cc22a9c127b9d5e46fda01fe421fe41d7fa742c5a847bd351e9681830a2cfc31ef7dfda2d8583bfa70189164754ed51e284893471c2c27277a98016d5a330930fa3247ceddd90474f273a09f331eb38d09bd3152b1c44f5fba780c90be1682f4315836691597fb9f43e8b3b35240b80bee139034eaf42672b3b19014954e1f04ce9552d915dff0a9492a37f6f5337d4df34fe112d808bdf25ebc349c6f39ecc1cb74af5d09c193d11b3c798f07254258fa60231e6994b609c0a8688d707ed82bbc1f2c86ccfe380785bab3864d9de6eecb703f2119491ac75ece3b445323b0eb24c81b6890d5212664a8eebf31639d2250ba96994685805762541f83e458e8f92d603c08ca8c17ed410f4807b06a68ca6243052dba3d3e6a6e4d7ac1160f9e83a6c4a9653e718fd8a0d5d0200db4f5695ed3ce9fe5d74f104b509e917a9f537191e36ed33b7b42100bf2eea794d8289967b95e7e37d79be102ad82ae718160f1afa88c76ae2b6a617f7e93bc7db88e16793d2ae0b400860a8fc6eda1952c21931799da4d7475828ac4e29daef9c261d69c4e04aecb4340959db8705445ec0069dec6130f1d18a097102dab338325abc82800d14818e9924d351f44f95773d04f1646dbffc889a88bcd28467d6eff739443b8823d9a4cfee693a96fdc15da5a0c17566ff6dd7400ef44e48088d52ffca79ce68e2e23d73458f65bf9467956c74bd504377b207b4e605bbda5c8e6750d7b5d7dff79339e0895e314a3b7bf063d8aed54dbac394b6efdaf477768559e5241082529a7a1208e2fd5ba55d85e992ce90d1c5e44a2b47a97ee4887b4ca778d408fe721d0f9354bd53cf17c969f398a76e721a2f92e0b68e4fb10891dcf060102b484532149295345eefbd4759c0db7d8cf3dc88c6fc34e8193e93abba1622f89840f2d21f72ba4ca447e0b6f73222a32e56b5193ae4f2d2771120d0228072d7218ce77ee8197fc01397ed084346eac458ede2413e411fbc95b91e78da772091de8592d8b4356d43e81d1aa8651e463c219a120e154abab04ae4568b463f104b57296a9bfb39100d49c28cf1c719806fe0d79ee3d5e32619b9fb41c510fe83ec729f218884e7bd181eea68f415fa688c4bb37316878ac5c4c0d666a5d8135a3d6c827a00e2b9433325ceb6d7c0696d8feb1c950fb150ed54a0dda88a563a84df2b5e37ea0b678cab460c84411f1538d0dd65a3ec5de4cf0c3ca8b487da1445c6e1a02b97982a719828c486b34c59ec0c16f140e44813e2c38e1da7f54dcc7c878281ab1492167021ffe40a9b5c56715f051bf525becc89bd97e543a5120f916aed56d69019d8c1d703d1a19ae38f1791c4da632f9d0632d000ebae327488bf46391d0abc3c1e98131e95823c083dae1a30860761062cd2d3cb9c60463cbcb67953f019077f52419e385f410119636220194d6d1c48cdbb04d933a1e591ee8f3df70d33a92841a57383610298606a421e121aec7e35f1222585328614fadf7674414e635b36459bac721c5660a70d9293f4fd64d9ab6265e7a4de49c205353c8f20327dfc910d531231da5a562a7e28ae1192545238bfad2e616d6892532dbc09034984b5905956b2f2794bbeedfc3678764ec104f8507feffc79df90c00d614914a394954f45575f67fe4d6a2f823bd476d5ce8d252b55175f698d725bada9424d08b47413abf077ec37c03dcb1da1303b8d97e9f1a1c227a51101f6d75921294074fd37370a0d65541fb9fa4977de1d542b98d94742d08211b97a483ff63e4976a36f51ddd197a4e865ec7c3bece84d88fb3659873e5a2cb75a18288204276614bf7b516fefc2300761dbf29007e1dd84db6a51d5d02dd5ffe26010f2ccf569eef88e331d4d6e9b1b6d3be695215ab6540b5335691721decb8bc1301c0e4eb547d008dfb916c49debf5e3d5c77a5b97cf756459c5bcde33af75a1c9f5b432ee3a79e77d36bc140971d256e6a211d5fa17644a06cbd00e7ab791aeb804920d8410b5b79b4e90cb72a6b29aca3cef5576e268f812d75bc973f604e2b6b4e5327194ce84fb7b284d560589a67898df7d06f950f1300de90fd34dc1d247abc374610ae63c971482350d986ce88f111571a4165661b91800b72be620aad9fefc82310034053811a08f0f0aed56a4d8f9206f11514d1f0ac16db842515c04fc15be54b047ff9dcad7be144dc765ff566908f0044293ae69f991733cbe38652dc66fcc9413af71f4924e36add19a907756c38b3b5b801a561953994a3befbc082d13941a26ccd8e97b8fbe9d9edc7f1e827b0ae786657d97e9fd106d8f91e6897ce945c81932437b85ad516698b6b1447bd8a5298cb87cbe8616e69017a2314f53ba2af6c6ecc00fcf9a0da605a1dd220f483d14593ff533bb2e92cee4746b4a833330c9cd3bc648982e176d41d0e965ec1318ea6809e1c64c63417f87983714d25950d26e0e56fdbb8550baade8448fa485cb2d804b12016be1d9af962fc6f715af9cd141fc0b58f3912f599ee1f8de42053688b0274cfdc207c413296a3a768088e1f4e0bf6e45a89133932e978dbf5e3a42f71781a845be8b484f40114be285a63da57b6e9815bfb9062dd707f8e1716f7b527550b807bf6285b2707e9df9de14134906eaa0e7409bf4043f20671926abfc3d6b417d748df1cc1be5c688fcc91349a224196e9421aaeea1bc67845c58843e1a92e37fc903ef76e52f1b59018f1e4b1178ca28170a622bad08664350191cf3f90500244dd754327407f8ed1b3629dc3e8c7a2ef525899a8ce551972cb290ce4b0006b9d45e44375039b0c194d1ae29381500e3e8c51d3fa971bf48daf18c8e8b9d0763b8f141961e80aa2f1ca4ea20fafba97909c669fa4fa9db27cece60092e3ac5c7349985d925baf86db82c86295973d183cea0611eb57b4f9170d6a4a8f066230dbbe15ef97d14f22308496b62b16423af6c4e3d32d97539c01735a25548d0ddb49119a6989196bc81f372e2ede51187d0f1d1c7789f744de4a87de6d0112206268057e7fb982681acdeb6511bf2da70ec3a391f1542228c3a23b9025c158b83e00f03da1bb9e3ec6c2fe0989c519a9e9e21b4f0d8e07d2367d1d5aedafb38e87be4f808da21ff13417f8be908181af67ab3b51c8c121e8174e13af04fe85b93d4651f541f6db745b3718883726a25cf9a0d9283d1e1e8d598d121859e8b509da3e64aa798ad086e29028806c2de4438d3775a060943d0af375bab9284e3c3a131d981c8cc3785faeae24622e5f87b06fc83119f3f728400fc7d790e70572dfe909d11013218ec3e5ba52884bed9803797f11496292f73d795ee0206ed23225b5af1a9e8c722cb081cbc97a68a450d455e382fd2755aff05da5bab498c90abba44b3f03fe9257a4cbbee1291429d986f105d3d8aa736bdc624444740e3c744576994fbdbc7a1bf949ba99eb113cb3d90ecada91d6b758fbf07fe79c56ced06962a3d51181d8e47ff0a66bea5d4fa7f3d4d9a7681b99b497e57af3c437def6360a44f3ab9c8b7d3ba0f21d73eb093336846324a120e47f6537f532a8e7a328f53a9a8be269318f31ceaa25304a0c4db6e0ceda2d2dbc504cd174ba6f864510e628557f13643afd593c2e382339ce3c6fa24c00221250cf1a9e441a35af53ea6de4d014e37a7cf5484ac45156453a4c5565e74369115fd505e2ff7fe00a296712612d3e9714a6a38dc4bef3c308f0a62f5095588d2957f362fe5f440d820d94040e628174b28450f781771ab234b03a282a0b93b325fb5ab4456a32e071ed83b539efc35413e5734fb527a73e4e094407fb8e1dfe2cb5d7e6e1e4335291f5fce22afd1661185211a5fb0f6497f331f7ae3b061313dc274763de4ed1e7b9feee9adc1d319fb2874ac162d99cb4ca56852017cdff765021a388689ce8ac35b771b5acedc6f12e8d377a3fb10c126e1277a503af594d6976c6d010158ab9d8023ad011742b7e035bf9c29d113912b514ac01eef3d90a27845a4094ccf63c8cce7c3abd5aea13aa45a18bdc4aeb6fb72e489b2285cb736f556e712a6e1088f977bd27c953385a4f1db7cb1a9dfe14774f3b4dde20bae242d388c90b4ea63fd515330ada29a4b0968873d14cd98d0cc88d20a67f0444dd8e9486b0a957cad909885705deb791089b40e5e8dc4f21d830e9aac746c093d2f1923db53ee725f22da3ed90e0121ccd0a42e169586e0fca06c3e4e9fe7dea2c232496c625f6011b3b6bf8e21d2bb61aaf28f7fa3afc03b7e15e5bc40f858d723d1367e65871d8b25b8b917d8009084e69032c0a618e7b5b218928b01027b4cc8786dd2f4d6a846cd8e22f585d985e0b8300710396beeaad4cf252a27576f1459bbc3e4eb7c5f48cc44c1d5c1adc721c538c18a432293a310e9eaea5a1d0736bef4bb64c6dec56fcc2a0d75ea141722fd2f8f9ef1e15b70ba4d678fdb167356613e4e264181fef776b60a605a39629ba7c8675c456fcb211203b34ea72deba70129d399bc749c0411c7722cffaf43359c113454c07c5dbfe846660e374bdf84f022919ac66f9b73c3defb6db5849235548dbd857cea9e3005a31a13ec81c7a08e14398ee23f54beff73d8a8eaa0d7a658ea1142b219033070b373bfab879f5e5ee9a9dbdee9060d68f5e04742a65365c23685db4d5ada6785ccf70c96c185eaa177e407236e27bb4d29b011a76be2f323601103524a6678d4f88df32e5855b3fbe59f0b24ec285e85576fc6538a7e9cc75534e70816766729c05198fddb6e9d6c248d4cbb5492f10f8df502029027823f808dbe6b42df07953648d789633607a5f1d9eb5e97c54abb1c8f74f1fc14279eedf9fa96a2090083751e866af3c9ee394fbc464bb5a5922e65722ab1523502c0e88077f7700861148da0410fabbaf00ada3c88eec1de7667cf5be321f77838ba587be1414e9ff540ee4b1829d38d06930369fe3b3cb206157aacdbc26e446bc21a14d49034627bb476c9b620091431ea590dda99280725277e81532655e7f1e910470eb26b33373e3ea08d0c76b4424ecb0d79d78734df5934b548574b5944310697556b7bac23071ad838482192c44f7cf829c1a449d4d4661ca3a6862350ba1078e63619c5198378cc83fc1df7168f3d4b775a923c1287dccb4b8dd6280c5294ba3e59dc04adb14f461c1e5b7de9ea9aecd4550b85b681b66c6b637d8a607142f2d69ed1c25d6ae0c5525b48a63a13ad597303b451be63ba66eedc75ccccd40765fd9fa853a81e63e83292c2de8c6d6f415d8e6bb7d6c4bc070eb9a456a2cb5a6f59c532aab890a2f9dba868a1125817231eaff7e59268376eb51a2dc920d182d176897d5847b49c217f0322e22c0aa6ce63d67110bd3944a982125e1216505da7bd61cf036a548197034a7cc58612ea387a6a9dc9fbe14908908f40c06775da13e384ac2ad72e404435b387fe52237082e8e708d87f29def0e6f44f89e9eb85f3560d5661139281699a8f970408881320c1402bff78c3569c9484e13398030a464d8d764f6f70d137c341d5fd111397a9cc0deb4fff2a253a6148fe01ee9676ff1ad3db52c073537e72b869c4d247ee53461987b433d50c176b1b26bf032b8384944290d5fd8f6c7e9c1e90b91b1c15bda0eaec5dd6aa08b9ec32852c60ad47c4a7c846d6954e88da3586bcc26f1271e90888266f54b54e3bfe31c02a88a50aecdca378cd81c02189c8d46436ebb4cc9695347d33536bacb80d6666b0cef3f3a3a16a4b631d197ba1212aa92164d61aaf3bfafa3bf7e691dc2363f121db81e95c49c8f84ba8e26f54ebb543bc7fcc78bfd3e83d550b30b7e55f90b1864aea21c4babebeb3a09013c37a02b193d15697104f8bc56fe431f655eff81170712f0f269812600215c68cc1ea446548186c3c86c43504cbec79a8a53aece6c9d683f5de3c5fd588ae52096e3d9c1efab578fa0aa902257546d73420bf6b84954d7b8d9997e9f204279dca44742bdbe9e2ec542e69ea41927bea276dc091dc6409ce3dbcc514944961ca08e5be73918f6431acbedbbe3ee1443345a5142eac0cd457fa51671150092f3f9137f83866abe5e8a28079b36e8cf042c122d723f56d7808ecf26b1e2c3ac53a12c3247b13a13d5c0790baaa883e8e696b799b23ba58ead308890676b35c466106442e3201418618589c805b7fc2fc2a6b023d8471dcd6c083c3627c90964ef5313771e414cf48cf4afe6b6508a99202bc95eae717769e52ed24452c267b6a789329e351aade4756027b14949a248aedc23aebc17afea089924e913c6830cceff3a670460ba0fd0d1cc6b96e0cb33ea64ceb5b3ade67303547b7330c0d9ceeb6b2f71e6d60cdb2081982483567da1a1a7f0a413b4c6e720035550eaf902f34594addac78826b09b7196952eb72d924782296790d6734e0e3c29b414224564ecf307fbc8466b70ff638238977e6b2b1bd0b60dd0f1949adbaedce51d778e3a92296f96cbc047007c457de78093d0c6072d4e61430cc89167fc073d2dec81923acec6e5a896ece6307b7c4a62c542b4995f3e16a81c6fcc70b58c596c3e1879fed05c1e3639ae61504c48ecaea18e2f255ff09ce0568f1ad9ed298022b27980fa9da7b5d2a84e4be56dbc6f3813bb443892bfb698da902a9d7b3f85a86b9e6f34172e6be038704ad825e8636cf341e9a5b1c34d53b7636be62e2cc3168fdcf99c6d84544fc280918134a5a6b35fc3b817da4dd28711ccba44864cc4f74445278c841be91d4f8f8a6594a5104199e97575938dfe086bfa4616b742409f06f7df7da00ca54b986fbd20bed4bc881050d7b5c62a9633a778d15ff959b2832aa5c5565a55c5d456193ff6befde5f7be58d0054210fd9579ca64ab835cb1784ef6028df3a65c236c56ab5e960e1d8b1c7f2503f5cc5ac4b25e58ad55b452917a9f62d98e94d1fd58e2eb2a52f9269c14826cfd2e983657f83c1536b25cffe5e5c753aaf6a6ceea7c94302949ed7fdaee5feacc2f5d4a5659dd673d9fb45b948e8c36a65b1aa1f2b90c94a973938bc185a87d8563f9a9b3beceef98d3b4013b31f4fd9c92c6cb61bc65617aaecd4f5ad3dbd49bf93520a77cd506e41c28226aa6dc16f4c25bacd16bc889161b9ec39446b1e88e9d65b1dec8d575c568511d748d1b2e3e977b3fc91f2fc1190f0473601628284d2814dd681197b9a5244f379ef286722203997978cf5f830391ad1acaca6b910b28a3a894f807d02b30bdbc8a2bfa649b1a0b10956c055311facdd3d5ade6339834c085543ca553d7008103f43b58cc96a4211f35f0de33033d0e73d8c490e83334d4e7c8b0a8dd8bf686f4cd26e79d191a6675ed85f72c52b4a86ebda19cd6ed01692fa9263ae453462e331961b2a862ddb0b79a3341cc727fa27d4202a0bc98cbbe698848b58a0ea195ebcbcd2b58df7e628b69615ccde5aaa14f8eb9869769614c64e55355e7a64fccd48cedfa2076831a0c0420d736ad59ed31a65e55e15255729e2eacf88ec62f0cb69476ecec16a814f705452c5ad6902f72f8e3559a838fafb4acf35d5edb502b9e5f2c5c1517b616a1eb76c0f9d6240b76bdc5ebb0ea3b40145eae000fa9d42412fd3788d9e7817185b930a6eef4895c61c37fe7cc2e3f8c71e5575cd44662e08381f314e3251e35a24a680b97af984818d3eb8871967ff84c0409c89a1c70511bc3455379204aa6f2764eef76652335ad9a6d1632d782d3b955081dc72f9e2e0a8bdc2a42c95954d9f7935d0598f104aac431b09d73b58cac47e2a36e4e207fab3773390cd83e50fd37c0bcfb587ac99b6f30375e980a840260b203b79a7afa81823cf02287609d4fcfa146e6ac642b4158149f7a4cca0557a69d3ff5f733edf3e06849a0845742e0e11432d494b6bd65f3689b2a67d531ab7c5e82fb70ad2340e30f2c49a264496d0759224323f63a1895a43fa3c44c83073d943648fd414b3f74f10e46f770adb19f5470b7da00abf5ced32b191e3decac62d7a97463ca5244b40f915955df7fb20f662431676038156331062ee94e1347c5ca0f181a65049218917bc12405e33cd2fe3ee1f468e0726b0c409af029bf214d61dc0c0cdc26955765397c77a12336224854e61959e735b0be7b501e4271f0f19b2d6b570a8cfed4093062293ec7c2c18e22c7cadfb4e2fd62f5179b32e60a376cab08319b6a348108d2a9deabbfc07b9526d75a32ad05085d9c3a9b9f47e6e0410948793a11c96bfad2820c6dbf540a60620bc0efc338dc9522be3e8574c422f7b0f4bc128fcd30dc95fda6a4a73a5c2887620e5192a54339703d79b369117d603c9e1a83d924215c7aa3eb12bed2a3bab202ec14067168507376f9fa2dc4cd435fe57559a934d0d50e8574f5b811ea881ab579de04b4d46a55539326847741eb13dc4b400b5cdc55367a0dbd46060ace696a280f638c7956480fda1a8bd91dc95607f2bc00c2247b9a5eaf478eca8d1d8bbb312f9de172b5b6f120ff914c48eb7de349a497f4461a02f9b5e5eb43457bd2240ba523ca04570121b817d007aeeba11c17e756ddf3364bff5da359806c705dbdf8cee8b7e48dd417426de632d27fd140a53aeaa62293c5dccc2d8b6f4a9ac9b0734216294d209a58a788fa18c75ebfdee7a92268f108b12f4c1b83c9d5be8fa4e346877075b41d51a7c6c5e9c548b83740995a87fca255ee89ace12a6493c9486eb7dccc9b02d67f53b846bb05afc56b1a064d86080258d6175492516995a19a634c37707721209125d6362cdd600adfea90bad40b0eb3ec7f8d9eae2488f5a86915a29d3447e7597478530a2f086ceb2d4f582cd676467804fe98e280c381dcb2932889578ce6a8990d57710ad256a6c8398ee412649c14fc7fdd1a0f3a848d482d2e3b770e00d5eed8f26a12f044b8e57578687d4c93bfb88df125fc104de081b3a5b801e26e2edfb4da4e3257fd7d10515a2ef164ff78c627ba5380f704c3bc0c093d9b32cf024487e491f4d2beb110b8aeb8ce70db4006c240088f4d1a60e414a84d851501418b21eb542bee74d24fd3a6b7524b19491ca8724ecee9ba9b96b3f26d3e4776ffb93148c45d493a789d83de6bebee24461de41e017039d1980b67eca5c8489f14a4a75d2221bdb6d479b6bc9814e5b312d2aa485700190a83e0df213fafff6e158e50cb05c570f29026ad700ab9508df1c1c10abd505952ca0e6c0c6bfe4ae3b9ad7d5110f11325650a41cc050c28e90ce815c0ef7fb4b1e327a5cc2fe24afdf46e4db41517350372b77381c69b8d00a98b4ccc451814feefa516035f0b2a91bde09db77ca8057d4266b2951775955dd0541cb34d74a4db39d35de5f9291f4655c29a7babac2dacdad8cd37033b9cae554f05da38a321b205ec0a0805b85edf40966b9acf362ebb585c58bf467e4d5025f30dc1d52b997acaf80358711f41c4ee3da5c7df582e4d87029229471c5d06ac69cb5f138558ad1a91b2c7e5d5308856642827eb4799233ac8a58048dd2ee3a254a5a13250328a35ad75c505aa6ed342d53d0ae11b2e91b32f97aab90b0318a6be6742987eae3fda663b44812b8c924db6c539a63e74c1573b22b4b52dbb1d3a6e64c2a07248e0af5c7f446470615049e9f6cfadb2989eca66c4bd6877cdc4286f4d0eee92ec82a8185af5203ee8368730dbb0b9257afeca0a34aeed888672ca74b2900ff8204b8cad939d07df4c215732b11d4fddbf0fcecd2f41bc3028674bad903e4b0e2e362dbfbcbe471771de895363937a63cb5086678e3594e7c09cc29ae4bfaf2137e086d5d4c28a20aff0e24777f5c5aa0587a5a3e82fc009a9a873a1f3a06fba77772716228f1c7c5abd2a1cf38de455ae8bc2c5b08e9fd2e469c4ed41bc27de3caa3f82ce00d8f2d76089ba66d4f00d13d0c5c57287aa6b9fa1f758f8b76caa09b662964fbd719488ef500197caff04c751384a5a83e4efc7693bc727862c04231f9d1ae15b38e70cc710ce6d4521bf6e4e7b89c0b369aeb0c8c6afe240b22d814b5738936b6495f33b5f5cd4327e264a1acc9f7d2080038694af34dfeb4a69146e8b872917c6b5ad755e4338b3a191fd6ab53f465e571d18f5e8cc22f4633afb92d01a8408247e5449f3a41eb66c959bbb9ef416a0a790503f534801a95e41dcf8284b2ed1d91f2a4bf174d264a33ac7d82b188006c8510b0e394fe60b84f352c8f67029bdd15829bb65413f0a650ce13170c7a52d61ce26cb36679ddcecbfd34ca9a934bc5a801ffaa8b62f78a2add22ce17015ad01b06cfbd1c5c1c00ee4b7129ed0a142394784535ebb24f2028d9632d3743c63429e5aa5ec2f0bf5939632a569cc31faec9c0f962678c64615f7eede107911a7feec98884f94160e2527541c728e620f708b647d54d96e3c4e55e85807783df46bf7b5a9640f71c8ca1b7f35d369817625ec824efb6f64aaeb98a11f3d5197ceaf3f2129720536761d3ef4e0aa6e9cd6201b5393e55ea6570849cef792461ea65303edd41e202d279555107e2a8a81e135be8acef324c421d19335d1f63f7b612623b46a182a1d38e9f8e0475800e010f586ced1dc8dbb49751023ba70c27e4a7ac8c6cfc045b65fe54d7842b9eec6768d024670413c49eda57d780e3a745bf8fed7490fe974737a943cdbb9a1c7e309fc31148f1bd0aab135e5adf6e856af3383e1d7113491751638caf37f2ea9de3917e680c77fd255c9d938a0080bc9560bd889ffdecaaaffe432e4bc8adf53b0f99015756ce4c5e435094c5742e751526a59c212e9042967502a53cac0e541ac50fef424e7b19bdfde79c4d13d53e467892c91edf86c69446a5940ce242a0bdb726ca17945544e3979aa8591a090c27534cffe9a5aae4bf50b39ce66468bdfc7601e2ef9d47ea32f63e3a91c22fa4960332565401c977c98674d675c281ad91842aade990dd7325360aba6a77b60ccdf76beea285c15a22233906ce039b524d730af213b3c5139355e8572ec045d2392c05f0a1c82440b3df97b515d912de448646f8bc63a710dd7c05481eae14e120a25ce9490f7000d134fa9cf3e5904c7203137e5c6b7999d073950166a931c06454014f521c3c5280395cdf99786d0877f51f800b92774853c0f30059c8423771ea84e06bfba1610257ca8c989aa7ecd5e73def82b538d2986bacb6b0f458c067934cd29ad551ea422742c3e12924a7fbcf1165beaaa039cb5fbf55eb05c819ce95f3f4ec4b11d2c3655b856b53e106607f9e9c8cdefdcc88cece54b01c5f81b46146cd146b7826c7d9ad93fb9c186cb46bb7e258e5e83a905348171b0b0824e7aa121c53384844e542dbca334b7310436c0fe4d1365a2301e78f79c900881e124fe20130319dbce3d4c68b73290677495eedba5caa53f8ce246a400412f5f1f4be8b6f13f6e575c1571d5ff6c274a8064591eec224ca81146ad772d3603b10db186d22c6839597d89e6436fb28c4d8677010e7458a65651f928567d4dad0d28e1c4728f056dcdf30cea688d929f439986247e173c685394b07bf4b8d26e916874af3e0a6e650a39e2a3fe4a9816016d5aef84e3cd99ce6c1e93d7d56238f53ad78dc0f4c386a5c21d45b243902607a9cf730e4183518bd2d968ac6ca82b2fb67dfb2f46bde8478e5c10a5cd7167221e392f8478ffac9787408f35c64a3009e904186b1179b94d571a5e01d790dc684eec09828914f9c05facc660b003d1b98b9301d722f6198d040377f0b3e8000081676ccc0add35383e5b2adf3d3f8a461109e678e97697666712eac072090eb94511f3f97e905186cd32eaae0e6f196db5c1123437884480b2ccdbb95694bdc0feaf1f2391f020c9457b02d1939c83b386759c47316d2cdbe8c765f2e25df05995f8a3eae348d3c5609642417015d966aa991974ea66ff3176d08d00849d88808a21028a8b6ea396daa24d99330cd1d3f390db7ca46c0b810be0420ac4957a0e14a453225320501ca580345cb71b3b567b3e487cd764cf441fec6246e89b129004182b374ea4df53bdd15f4227dc88ae00c8216c184d75ea8aa4a5d604b0c4403ef80f42c7152bff9ba9a22d30e34487bf0033c21a29d6407154ad64e87e13cd4e2c0c6d0ee0d59421f678252840cc19723ab54803f1adb66eb9aa56465c079887d09101e62b23c4e513242dba9994dbeb241ca16fa8888617b6cac2258d507a4bbd8e428dbb8ec71d341c186257cc8c0a657392a239c9e2c15771d14e83fb8818757704d07e07887e106b37587cdf9dc269a007a31d5fab398ccd4a09549ab9718156a892aa82a26327347da40a065ea5838f4b208fcaa462f29f718d981253f769071ded21064702f49697ecee70965466d56f6c4e961b2317f379f657ef561a6d86b05535726e79cb89a6582ba228f29402913164dea1580003ea5c17e0bcf44a26d21dc189f1b5996351ebe9a9ba9eb08675d167208e1f7b8f3c655b05a67468ea6c7d8612ba0b7a7cdbcecf735568394b404c0266f480d1800e7935342272d346405ed2077d4b16529302cf50be2c4150a112bf770068914ed6ee2cb73b4ce68c80e087a31dcf01f53857ee3f04bd3d6385bb3fe4eb47aa682a9633f299ab45504fa30bba25a20181ea50365fee81889443650d29450a0329046b6fd2852c97fd42a8d6288a74733fb5daa8a5734901a1e8b0e40602a430d721efe6d486786ce9b85da93d80e8c0c12dcc87f72017ed466d1482344eebdb72444ee2da54c3205c10a8a091d0a1308cba1b64dc68eb0d714614bf5ab5e0e1d6dc5835a870e09fab0e97dfbee9de3d9e45bc132489ce3d1114e7ff1e30f3cbf6f228fe7348ed55471ba8b0716decca75e101c250c8f1d613e9bf0c40b7a03968518443cc142842221b0603efca00584161fb21bb020818926c876c08204ce5dd4576ee07e61b1015bdcaf971280d00de1d323134b99ea51a7582855d0475d3ae9bb4164e7c60e2ca3b1ffe43ff91f6a471dbd02d4e69c6d4347af002f4ee3a04038effb86fee6e104b1aa94ac815299e4df8c73f6c0b1c8e284216459c214ed20adcaa6ac3d928512848a7670430dbe60507c5005113ae860adb5292f70b6b8b1e8a2c5931f9e40825112580f561c618c0c0c1d72d87a10460cb8f8c1890d37f01026c9078717d20b0b24271886611804a6c082071f2051f485123e8412b0c801ab825a11461068b0c10b0f7c40a58b2864c000dbc1042fa31f54f811f358688ac30eb04ad3a04783fb25c50e1842083d5ea14165ce89655224ad70bfa4d062d24aa552c954a158cf81af570babfc8395d3b66d474cc22affe2b61991b84b8da37fdb5880f13b8f368ebe24b0fd7a15d5c0fd7a49c14f8750bd94e2c704710047588afb2545ab251936e84816fc19c5129cec203d4631466683fb15450fa2c892443d5284a31d18010544c85206abb528acb8200b31b4a0610c1aa81811a910e560ce395357c06c81c208cbb75108a9748840c83be79499084dc909657b944c53652050d1875e06fbe1959e11986300810ae718700f7c7989a832c5aec1fbf4522b36abf2e71bd65885e3c5994e5e3a70b53419a3d795a42cda0ca0d71357b61cbd9ef882014df11b29425ec54aabd5e1e4e81568e9538161bb10c202a0e8af4087e025136ec0b1044b107e94525a81a7115172f4e6681cf355c0b3051c6dfa663ee7cd1c3f5234d5e444707cf8cd99b95e20220752be1062092928c0747882f900290618866158bca1e70d3ef002888d0745d002872776488253ce2909a0c3133e5a580cf7cb892710c087971361d897135f946007a9c54910aa1356387105899a52428c51ba7faa7eea2e31eca252cf11720501fdc4169824a4a32d46af22a221215710d08fb7c024211d6d317a15110d09b982807e602b499118601812a407cf0ecef72a4be30d6d9f2224c51525080ad0931f9fd90a03e64b9217a42e475cb66831caf2ba526485a8cad0142129ae284150809ec81fe9235b6130982f495e90ba1ce1c8c5bf2d5a8cb2bcae442b18be4cac2273641cf20f36a055a9e7c0c7b056a95494cec7eed481339940972b68d950f6370ea861d80fb3a8ab2ab61fd288f147e3801826bf3bdfc02adbdd0dbd3b5651a9e774e350bbe9dd6982edf78657409fc6d1bf42c2c6306cfc9294f26569963efb5aea52e931997d2c956ec81c52874ddff44b69a5c280b319638c47266e2fc678638c5147e3d0c2c647c2aeaad8f89d819f4ffdc78170673103b2f1e96331fbf9547ed693bd7c2a367751cc30ece6ecbd2ccbaebb32170aea9bbe34c677ea39100ad1385429f78edd1da571c0d9ded0c334170cdfc6dbf48dce417333f5af1b626424f12fb61552cae8d0217c6c4305dc10e78831c6d88ee35f3f0d42ad34424f7637f41a6608a3c396d808c4f16626d82f74e853d8c611e3f412c4be144208a97cf83146195d89fa594a8fa671cc19259533f60d7a851b8d634e2d621fb10845504d1822125eb1ddf276479af50eeef9a7083d6b658c56222cd5186354417728638cd325ab0eee170f5e30f5dec6bdf8589884e49f8dbb5f292a65b15008ba7ed502d4bef49ce784fb2ecbb86f4c9534617141b8cb7de699ae474d5ce9b94c268bf52007f227d8ff86e14ffcc77390fc5d2e21fef96b5e10ff6acd1238ceb3d38b306dfd80f1561218a4a4a38c3e7dfaddf46b2398443d4aa9c948c42068235cbab9c91026d246f46256544158f82ecd4d3ba8f33bde28638c32668865308319cc604e49cc331235ffba6191c7de4e187032e45f3b0cfe3915eb5ce94df533cee6f937717f1edba1e4246e9e38afbc99480a639e39a9fd6da3b54b395b7677cbee38e38c33ce39e7752fa2e085ad31d41b05a41217f221d991e5ae78033f85969d0f1f7ef11c5984096a7002777f1912496929ff2004821204e4aef81e04545d5268201272f9073f432ad65d10097ae9241c5da631e2cca49765524a8a69190644624d85b9749ffdc5a750662944c77cc8d938e263790458becbc611fd739904991cdc638cd15d42f7ee6e82c148c559d3e590869e02f78b065ce0eaf0ab77a418ca17f2414b4a8fbdbc13a09fbd054a8ffd122a42b02ffd92ece92fb9b01597d09ba16083758c29814ce800c40f2bfb2aa9bfcf9f71f698b3747bbc9218af0a089b2110108540f1e6aa58603304a28fbdd35f82fd5c42450866fa55fc25f4aee21582bde9b1a75fba4bec53ec210a4eb858a5a75fa262601727de380b99a784092c3a4a428845456585092c42c207894505aa9480503c080bbd4277bd826b627705e75dc1f916c03e7b0bcca793e54a661006146fbc95c4bfde02817a2b02b56861f8ace935cb814c4bb877b7673de7a440d8ecda60118a63d21b8391a3fe61de0e367f37b20da689db8e4c857d8ac2ed471388336c8ada36d555f686e794aae9bbe3f4ad058861961dd91eb44ac76d9af7e8b0e96df60d91fdd1f7cc945d29318d086dc77322c690a27cdf7c4079537e63a39277020725580d840314d6b6040e9660d5504103ab9e208955e32809563f4ed4a971031a585dc50962c0eae7893a359a3062d598020c568d2935b0fa87449d1a47f8b0da280545ac0a861358fd45a2ce0c0e5ab07a0c560f01074fb03a0b568b210410c2b0fae11735b01a0e5181c2ea87425147c715376cc16aec0a56aad503ab1f16451d069c008a17ac6e2e4760351080c06ae824071eb4b01640469820b0ba817004563f4c8a3adb1090b8c2ea8760a2ce0c2bac2d095b7c60f5fb4fd4b1f185d50cd0a18b1eb0bab9d081d5efaea8d34f6869620b963ff1a18b18b01a5e8185cb15ac7e278a3afdc4d018276075562507ac7e7f459d28041a7c7e585dc760758d82d5375a2005ab511083d5ef495127e78814b0fa1d4cd4a1b185d5363becf06383430c58fd3128ea94acb04e5a94f8c26acd05464060592b395ec1dd6ad5d062e598c5b672d412434551abd58223b072ec82f918b5688062c4cad1cb5cc2a8d5e202042bc72f9468a8d54a4207568e61729c50d46ab5845859fa401a865a3e43706165f964fad06ab55e50042b4b2825318c5a2d22a22cc1a8d5ba8207569652a018b2610b2c7260653905cb51ab25e50656965588306ab55e70042b4b2b520747add6105958595e916206ac2cb35001d46a4d798295a5162cad566b4a1656965c8060d46a4d9982956517295cadd6942fac2cbd4cd751ab65840f2bcb2f9507ad56ab0824585986d14ad06ab582d0032b4f9f1db45aad2d64b0f27c5284abd532e28795271428865a2d2a62b0f28c82671449ad16951e58794ac15d049ce794c8c59b121105064ab8683084137e68a1e086ee07a024474a10a3862dc2d0a2450e48c440e1435f09e20b134e98f8011440604f4a0003ac8a124cb181e27e31618299c54998cc09866118564312a4644e5c590d4a603e3870e2653a6902f37182c5886c87ac86221f319ca8c009941a56e083854fd0124e843003ccc70a4c8ae924cb747202d30ab61ab0d87c98e0848b520d5e309f273024d42838273d30dd60d2a20626947cbe2825ed207d8c40392182fa184d2758780d48d2490d309f32680d5a322735d48004adc2e704196a092c2b4a90c29ad86ea0e2414703550fba329ea072123334c1dd2ae6e177f7f5bbdb737aedebed89790ecb486c68da69d358d0fe64e266688257a8efb1df3dc779317772777eccf7982e1288ebd7fa266f65bfbe49061f9a0fee63bed63aa36e35dee4c1168ed15a78f3f29199af41e36df733347e06024d5adb68fccccc8c47bf763450dbf7a3be7e4dea6b6f3dba4a205dcc57cd43691705adcd3694d679784b79a798467d95b79bdc6bfdf579220daf717b9ef5aa97a1501268bcd2ea6bf5b91b33540e50a8dafde9f439a6c66bd7decb4570e5acbdb948cd6ff6e65ae365319f9d22865dd73dcab35ce5b6cf9eabd63eea3b7b5731319d8dd96e8fc6797b24367077572894e5663c279379ab1e8d536f3fe6372f23b181eb5d71cfd53ae3ae667cf6b5a3a152a95434ee6a46ad3277d575d90ad5dce937191999e7644ed9766580486c60ae7bae7b8ecb2bd423b1814fbfea90d8c0a9bbdab2df32eeb355f7dc67dff6ae50b747e355ea7b621ef5a998477d4ccca3503116d5bfdd1e8d4fd77e67bf7b6bbfb3dde59ef372132b57546ee308198d1da9ccb22c9b32fbeac9995189bdc96b20d208c43e661018f612a9c2cd07166594df110806047b1963bcd9b1863bf8c1f027180c1f8b3ee6bb40b38b4120d35b09e978e3f21e8138462410c326d4593ff328eef0b67137f372924c71a642666e8d6c7bcdeb18176e5ea279a8d7bc7e2de6ceb83083aa713bde7030cb31cca83f83665e04647ec6631e90eeb7afd0ab368a4a6fa3c8bfd69b9b208998fee6ad7cdc9e52c43d343e2b7de5beeb7adbb29ff1ead665decc0cdd4cf79907b9ef381fdd73d9e28c898ffa5a7df8dbc60477db37ae5f2fc775377fb769db6b703b3dfc158faec77ee32311c2c6a1799ce7318ec5dc9c3df7ad3dfc2c4391163e126b66840946b1e038f38c408ccab8ef47fd8c77243e5cf9b83ddc779fdd1eedb7245d9793601822f5aebb5948d73d4fecbc0c5bd87ef5320cb82d77336cd9af50832dcbd16c07ea65f5f2aba2f5ecb79b5da8f1db6f31a713fccdd3eefc2ce2d376a7e6f59c2e1288b35fa14ede0af5d99fbe5e197c74cf3deafad85efb2cbb4822ceec0fce6e0ffc7ed8c21a677b647eab3f63860b333366cc98e1d1cf4af565bed2e7b22cbb19e2da5e861477ab9ff92cfb1a5e6f40b6ea75f576bf09e12ae4bcecfb67b84a5da8b1c9788d6be94b5fc38b1b10fadc975ca871b99bc84526b2373d8f73dcc3af35e67b8e445ce37af5b2ee6b78b546eddf8a6054cc968f64db8eed396f957d97f1787685d4d8be765ec6715cee3ea37efbeaad3ad40af5fd32df7d7dce5b718ffa98cfbcd5e9ed675f65bcd4b6552ff5325e4dd5cc6ddb738ff2561beafb538f7a6b7ffb1ae3699ff2627ee5cda43c2d06e5c9004f57c8ea57ddd7f899cfdd1552e36736eb75bff2666a78339f79dd5b2feb4d488deee6263337dbb4ed884724e2ec22716c4309ac09eb0fdf48f64fb1d62a4ae501bff4b5e4d54e48295b21f6d27853aa9f6d6ff2b8bb7d7ccdeb29bde94f57156f4cda735ef6dc9b5cb0b7238d3726edf6946af7b5a4752e9cdebee6753727c10f79e2f6d27ee769dfdd476d092e7d73df516e2e9c6ec79b8ebb99892dddedf4ad952a8f92e7037ec97a27ea82fd936f3c4a3f6b12acbdbda5ef2fd19c04e7fe23910eb14bb0212a0ff826887de6955694529e689ade95b4a7268ee39ef332cd4df0f63909debc9ef9be65bf651a7dd373f44d4f4ddac5b6db33bf6eb908cef47b66dbb671a026d99163c0d8e72218bb997e73df83bde9b96bfa8e01675fbf1d7bb941a0095e75a6ef4ccf5d53fbb7dd9b99e04bc4e9a58e3d5d7afb21967510f7b6a374794cf8990ff8f3963c8857a65ff9b8d8c49e2d51b7a75f79401ff4e13b2e79f9c31a863f4d25ada4693717f91efaf135edb5dbfed5eea10fff74fa7af2b20a9fe8d7a89dbc06d2bdfd9277bab9082e55d5e312f7f2e310acbdfdb8eda8df7d8c77ba9989bd72f3e19876d7f431a51ae371f5e2ca83be0ff854f3aac903a27dcd9007fd69fa7ab3e91e91a5928f1e4cf001302feeeedeb50df6ad7910620d279401e2f852cacffec88633d99836bf62a68961d83542b33b03f63360d894917a0c43a876dd104a2803c4fef1b13fb2612cd29f5e9c7f8d6417890772130c679833cc4772c2f3ce00ffc826af1107c3c33ef6d682ec913e9f05bf0d53c8472046e23fbd8629e0e8829a24a043f718a59c13c3324a4bfe512ad15dde4ca394d11d4aad524a391ffacc4d5a18c2f70f2787841f3ddec0813b50d4b699c1ca145c7ab9054a165cfad209c3557c8927865b32188768290e15c5a1a11987e250f63568b08da314fffca97fdefed92d72cb9d9fe116eca85780d86112eec691a11658bef4f6a48704627a73fba77dd98d4798946a8306b604553318d2b6adca703fd5fc53f506e5b7bb175092a8e76834bd83fb5337b04fffc3c154985723088bfdbc99f6883a4d55f87495746f6f4b2e36f76b02bd820c1070fc20bd02f522bea3e0c5f2f817ff42b1f187449d8e415e9166c8e67e0d7905c1b4927743a757a08ec10d48f6f2d634c1e62638cb6872608564d96d9b1e4651d5793bb17ae9e75f5954c1a67f6c2ad53719cd943e9f4aa58770276e3b7947339db49d9d5ec171e95f88c173e2973e01ad43e34de96d13a552a9542addf0aff4d0abf793a7496347ed665aa2115e161e9bea4308e3f6a3093679d2bf4ea202de6067bc7400d4ada3d34d5c83de0f65613f3d21de6261df5e66821b89c4f3573ea00b4f29c4b2b039e52502c3bc8e37f1a64b8c3addf166d88addb171b401ac804f98e8934e13db13bf33ee221d8630c49006dcb73d24b2850ef767f92b1f262caf912b300ece5d06ceb1210bacabc0426323b00cdc6d44766f2c50ed8533cd6b074838ab6854dac9f60a2aff3aa8de48c10e58c01becc45db443165f149c35ec7d053eb1f0e59d510bc0c58d1e0a40040bbfb5da36392bc231c26d488e4038027928f0f78490d2c60f16c3cfaa9fa803595a8df30a8e39d8c679fecca9ddf9439b5a193f3e1d22a9a492528993c373b2a7b452fa254c353b7fe68fcd8ab227f03d258000d0c5ca79058531ec7c41f8f13dc720a04f02277e4ae5396129009ed8f70fca1f2fc31ffb36b039fec420cff1279e13dfdf15853c67e58de1ff60f8ffe339fefd8a51081a57d81efdaf69349988afa5accd9b70b08fbb0847881a7c7181e784dde9d18f43a343759fc63fcf47bc4a1370de91b2fd5f08ebb9ecbcaf9ac2e66f35bf1ff03b6e780eec07ecdf63becb2fdaf9f58d63c9e2c252088c8b0984e5f4a1819d3f77b600f0c4629fa7f7640a24dc2f2c493970bfb02881bd28ea74f424cff9e239d8536aad4af59f7dc99330c6f82c60eed1344deef14449e341b192c6e873ba43b1be333d27fbb983f30c4df24ee6e520b2133774d8c05624e227bd817d9c77200b6cb6d8230f2a9511a4607f9a96299bf96d039bba0afe190faa3f4d0a435e09c8a6704bf1830d70c0f862849f1d0ca8c7173b3a3a0b3684fd69686cbadbc6a87245a11f8233b0425f7441cc2dc1660c0828eac496c4801a03c2802612306582c568c0fed15f13a971fc7847d88c8393031ba24540571c1afa420bf64f55e9621176e872211f7215fcbd1b6c76210b7d0862e853a80c611f5a41c83f77a1298dc387a20f6c8e4371c8e3908d2245684a169b5bb168b6aa0f95f9363c0bfbb611b28408c75fc5c07a44fc359fc8c23b44deffc1c691cd2aa3e789371907e70b2bd83f878a46472aeae0dcffc1661cac81f7c17616341ae8151a0f11e239f05a213635a968a9c0b8b0bf121ff9363c8b3e0621ccd8c4300cc3ee4ce22a804912755a9c183653087443f5b1e16790abe02fbde97215fceb0d6c76232ec95aac1575e43bd21637b253c8735e5f68f11c0f8a32c5b93061734cc2fed5b760376a1cfe52e6f862e1169cdd08c98de4c55aa61cd86c53d95114b66dca46f3a1225f95020c6cee97e5c2661ba5b0d94ee1fd1042082184dd72f6ecd9b33b1e51c28521e7c3a3961747d83f55e408f491574629a38c52ce38b18a6118065d49112fc93dd247b08beb7ceba936212da24256db7047b0340cce30c8837e9e508d0642894285f5f716ce306805bfbf0a2f84b03fcf8e0bfbebf0e207b3dc85c0b9afc8ff6c3a1fd82d7ed34714c926a97a00e65b7ed33c55fcf80d069c80f19c24f8e0238e6790b874c2400d40b5f2c40a352712c28d31d0b2e2397d8597271870f2c573561870f225eaa0be7bd95ff2eb8eac8b78a20e8e6f363552d8fc7f6505406c38be6f3e6a188c79c4255fb00e143086cd4712c2fd42e27271bf9088f0c72094e765e9674b64e1e72560b07fe45183b1db8d63debc2409e725449888bfe21005fc3a0d540034c2a25aa9c23305431d104ac110429d4fde07f0d44461db891b965094420bb500c718a54c410a9e7640eba85a075509f46bb0bc9988bf70bcb4461296c61b252c8da276d47126e8c0e5d55852f033c452d2647c91c31616930d08b6a0f809623181b003b56d4cc0840c8e581546814511ab8d78a084114b053c60e16209c065049722569d5ddc40882156c54cb04412ab662ae04110ab9b8002c688d542b0c16788d55f04e1082256ad5af4025084a41b92584a04d022a208442c260bf029c20fabb1f0c20623d6f7050a767f1bcfa1c1fed45ff3af2d27e5552202564361042d7e586de3d1871a1920060f492c252a5811c6118b09aab5c5ae8448251e049630462c29fd8bb025bc42861118575094167c253d7a83a10130a4b67130411404ce1667095f46081d32a1b60d2d515a8247248636efe0ece8f01f9e03b1a79023855ec133d3f7a75cb31ff4e4767568b7fdc6e10374f88d27a015d0381e4feb04ec65af5083fbb71da58f1efd92e7a3e1675007bc3ba723acebf09b1d1a50b025d4b6f96edadd6472ffee99be898ffb73e933897dfaac61449f4253e9a6fc939a855f189ba9dfc08fa988fdaa1a47b4c266faddf0bfb468e2a07ae907ce340e7fb8b1007deb4ef9d7051715f42256b547d7a9ef697ed3ad00c8650c9c1d6741f8b0858ba3219c298e9716a17295ab5ce54fe3153aec57173dc0ac975b64caed11f6039d8a4aa148e44352e89314abe1353affef31f9ec43ef51a9f9f69c9a87b0a606974a5a95534c2e29bd42728a7f9e9442fec1cb43c2d2974a39353fdf8f681d2ba7749caa79a5506e304afc9b9fc4bf195f06c1d02b34d6817d53f3b34b566a3ea7bce6b367993e64e3fd08147eba3fbd816d024f14bae0599ace05db76d8a8f16abeb71d36fed53cf4e4973c16e04b1ef03188829721aeb936fed53c8fd7ac6116b96e1c352fb51a221f721b5658d3ffc0ade636163ff38691c34ed6c6dbf879e239415127c99c70e298b88753382821b5ee39350fe1eae1b683e6874005603fdf850c748ee9e767ea7db618d5f0516ff2627ff0318f0686ff1d84355e8e2f74d212c6e3317daac18d855a9a621a1212f2a12a442f37f22d6ec5b3b8162f9a9e93b10fe2dfec998209492121cc83b8cbc67536de8643b75274c58750f81a358ff6d8781920aef9209e93e10fcfa1475a2ad745f1cf6a5306c9201b33b0335ef5331f5f0a094921cfc15ec7fbf9b268d69f2fab78ce7605cfcf320b9e443d1febac149242728a1c62c1b124a2c9a7f1d987e8cb8b04d2fbc33f1b354f1040838d5d3cc7c6cf8f4851e73f3718e9aa79d37ccf931b0268b05906f504f16ffe11887ff4c8284151c75d320837f42af3a14729b1e9e62518fb98e4dffcf7e217bf99d9e7f6dcf322cfadf837df5d13859b29ae71570d2f435ce3b18d4786b11bc348b1f0572ff333de87b46cf19c159793ed52cfe334980fcda743f2ae543ff3b9c1dc0008d702f73e047f760b1c1288e5cdda97bed478c653d1f088f89fe1c9789e0c30c6cb5ae643783eca93211b1267d723eafc9ddca659f8df377de502c8416d1b79b2fe4de95311b083cd90c8debe90c8b30f3de939ab7879c4b76f79649915a845eb582f30169180319965df798d136fb0a7168b5f33af6b11cdf4321eec9bf8292fc683561a75ca2ea47a94274f39822296619909c7bfcce413630cb55608f405679969ca2eaf2c528be422bb74af2b451c07adbd48208fcc73b02dba544aab86f2a015ffb0c77995ca62367c605ffbcc7f8eecc582fc27eac43cf60ec573a2788efcec841d798e7dd4634018f3208c611fe36547d4b60c83b3f7417a82b39f5070f676fbd104a3ecad5de7446cf0ca08c4a74722717c231d8ea887017591407cba19da7bc3bf18fcc39e03fe61db860027367b286ce5348c728d655f3b9e7c3c27d3bab6297af705ffb0a71a3d71dfafa32f3843220989b85849ca6d74c57330ac888655cc84758fa5fc9b10a848d4517552c47060c0bef4190da1b044cbaaba5ff58924f19cf8f57dd4afb5d65ac3e0fa4d1fd6d7d115dc5e70bfb2d8822bdce6170c3f460d7a595ec1b008e248875863187d2638bb32a9be464fa9571657f0fc1dcf51f1788e7ffd1e5555359aaa5458efe15fedbe81945ef93d6afdb6a9b707b6b0252e300327607051c51554848912813862055bbad8628b11c48041104198c11170f02148881daaf051c1ccc28814203184215cc9d283186300318f3065052a3f4f4822cc183208c2420339ace04b0f2508eaa10a96021370f92268e04cb1e822bfd287d269d432460361c4a8ff0c4db089b5d05af0bcab161cf3386e8241cf72e79c73ce3c21c5f36146fbaee4cb246cc00afb3766d89c73ce09348e7e991c6c8c3d5b7ad1b7146d79d11d5e5b68c1bd4516dc2d01937c93d79b04a8cc62fc58a2b494655966929b04fc8bab52896634e062bcaa69b6b5afdad7faa79b93606fab45f0f6f6330ff59d1773aa7faa9f699bb6755e6e125304f7ccd3e87e86c6cf68cf3df184c6411a35be964a5f4fbf51ede6ed2bd7695fbdda6d0fe16b5f3da871a7aafd8909e65ef37c701f03bfbb99d6705caddc37d6b6ef3cce9ba1098ef99819dcc77c6f5a0ff68dbf4298bfc678272fd73fc9a03a542a95abed6eae1f83656ca5b1b57e198665d8845de68427e88261199c451815a51a9e0076d12ab53f60aa2382e1cdf32b0438ede38cf7d4335ed75d8d4b693210aa64361a3366d7fd065f06de4c24055393d31ece7ad2b4874422707af8dc77deeaf4f5bb6fd7b4d5e9725fbf3e470477b0a630f7f0747bb6ef52b8bb4452d86e3eb6db2a1a57ce9832a914d4b40e7615c22e057f42a85d6ec26e42082184282f13c1288a632c8e89f91a73baa70ff51c17f3a76fcad9989f93a6f0bc99480ae56522a98efb69396ea6344efbe9715caac3f3bbc97199480a6b29f88021449a0834006207a926020d80a08208462919341428385ec16928500e10a1409161a0a86cae58e9bfa3809e9ed669321675b279a1fbc8c5a44cf6a22e774f73ce79bbdae1a8a2a15aea53aa97b1aa4f69dfbda6c99c7ed6ee352436b47a35cd7efdd879b9ebba17509db742fde93b4a354d5ba16efdd39fbe3ef7272fbff0029e9afdaebb446cb8db23a379446cba4bc4065b1999542ad5a53aad6adfa53aadaafe55afa2e9ba17e87ff5476783e21ef539aa5da5ba99ce90b9a993bdf99ffb19af370834e11ede6c83b99b89d8745df7bd751de7e5176c1e431a0c6930f7f6db7354d86bff50a9d4ccc39f79eba1663e26e6a2ec678feaba1770ccc7c8e7bc8c7acdcb2f74977be8698ff24e27cfb166d3a3bd041a732fd8f080386b3df51df7d6a3b14d2662038548f53b48e0e265b383042ea4a0368bcddff78551a1e70fdba1cc44d052e7b7077fe51f83707c611eaf3202e1f6a3f8ddb862db8e9ed3ddfdca7ee9d0fd219c4d6210c4ad1939b09926486e2d10a778800a683ca1d7dc10ac651b9a54d6f0b77f98b3f67f088637737f02623f88d6533ffec7496562a6bdfd55894ff1e5576dc710863fc385e1cb7cad70d6c80186cd45f0f63602333ef5aab740e055f5d4b75f3dece373430061ee51588668e1f9337cc4fcecde7e05f290831ce42007b99f0fb98ff172fd917aed2377737cb1f36bb511e87ebef6a7b7945abbeaae8fd3d56e1e82e773f5b31e10a7b2fd989be38be5b8db937aedf6a09e7b1eafdef4b2bd443e9c7a5444cd78f8dccd7d258d7b2462998733785cc6cb4cf0b4d23f0e73af453c2390ebdbe7aef4efe625986adbb6c3f44022de2260aff48ffb7ab59be11f893be66b0fad7fde839dd087faa64fc2404c587beb0dc1311fb71da6b6c11c4d4e61eedb5f7a2af5b6dbe9db3d4f4c7d90edff69a0642490d46dffe03545c0f4d56463eccb08944c9ec5e202171ce1fa36428ff3f210cc7d47934c8cea3feaccd030c9a86e7eccd1b83350375b999b8ab9f99f279e3c2410c73ce765d467eff6ebd7efcd879579ce47cabe7c6e0886da43eff4315ef78e4f5e465d5a737dedf49c37c487c675cf133b2f33c1f56a57fe87b7979b29fee4264343b0840800220b128edf48208e3e64acb0f99f86d34082111536f70bfe8e0e1e8feeaf84a3ce6df1bbd83d957aebedae92be4d58a62bb59b8fc4a01804c4bb441e2250e4e19b51a21882168c833b8a214809426afb90d5316f9f55a800ee4d5b3ee2700b6c6bc184bbede7c642f7f4e186e439d86f2fb71d5b103679361fe79c318495dc4ff9dbb7a4bf3ddc1e6e011500f1b67ddc766c4d7694baae7b16fcbbcdabcf794db0c435cb3cacfa54a27e663fc76664b1b4c78f209e331fbe0e16f59aeb344b7a2688e49f8ccf04671e12962859706309a20b5e006e2c41bc009f1e7af9886f9edc76188165e0550bf1edb310dfcaac04fb5b8ffbdebc0976ef8863eec22d600a5a15ac3d4fdcfc88ac127fde8629cc9743fe491f700b9882fcb943b5b63d932acdbe09ae52cb3e635a9db89a30186b0eff6edc10e0868773d338fc336f003005ff8a6d3c20748f374e4f320cfb52c55a0bf1b3cf10630fe3bde11f8df76b1c3c7c45b388aa695aadb53ed5a6cc5efb1a3dcd93d9c758327daeaf51fab546198e64b8745be832307d235d06ceb2c46e8271082c3070cdd77cb09f0f1f43081bba3c1b9e05855e76c8c6095df1ca30f11109b1d80c5d2f03c42e1d58f80cf879d67cfff7b781d3e61bba54345909be242fd8ff864dd9e4584db12f9b2d24427e5e6343a737a85654060e4e5216ec9f2388902e3aea9bde2524e47209b9a440178ecbe58a49415651d8243c858868ad120c12f2cf8d8ca04ba607d005849424c465250616167e4c7a127bbc7afc78c0d10fd5878af419b5ee1e416c606310608f30ba60ff1f3f640f56f3cfa6781e8025684a1ff578ede8c83255a881cd36017de34f593b8dc38da4c80115acc900230e6ca62d486db05118f44d5f4d1e863ffefdfc98624d0aac114fbc811f05fb13ec57608741a28e6d1fb48ee91d628161d185ad7ec1332c77c9a8a5fa968c116cc1a4cc08368ca01bd9435711ccb3e159548a24b1f1163902049b3ba9086c9e8f3aa55799262cd18bdd8e37f9db51a4099a8b0a55183e54a3a13bfe2561338d5b6cf7079f8c2a5d38fb910c024202fdd01f22ea47447e9421911ff99117ecef5ddc0b9574c88f2891fcf123223ff2a3272da5ab8bfa72c7e3c934efb8c7d71be1fc38f39ab08ab2ec2ae97893a3500c6ac28a40334dd878e54b62c1ae2c8a3744576cde21a23f06e5080494654747961865099b77e27b32409c77faeb5ec2365204f2276ca6389a3472c7be4082a14a10215d62908b0ceb4f630516c628d115831ac74c1376826142e3f0998414dd592e5bf18a85374b2224dc464141f3c8bf56bffc7bfcc05a3d5430ae42eb09d6679eb0f0711cccab83b0bfc4c971251e6d61f3e73f5bd5874abf0dcf2abde69f7b3c5e0f256ca6168a221838c00323f6b1deff82fc117cb0bf0dcf03b4dc20826a7ea38ab7fba879e2d314451f30700073ec042d4ac148c2fe5acb070a1582dda14f6c862df8b303ed1476b6eabbe969bd41a2e9be406fbb7fd65f94f0cc9dbb53bbb0721a1164084c0f2ed8ff07929730ad658b43a65716a424239b61bcc2e608b47df7a7ec43d14571910a84bd077424ec434343eefae2d50822253dc6c1acb77e1cc883a0f52050bc29e2b697ab8bcd146b911221e43f2fa129561c0a7c1b9e657a77a1a12c363798f8039bfd487beeb3bfb68fe1155f18c78289ade8f0667be1960c07c38144b6e1e6258937fe9a67823ff1860b9b29a65a12f58c09306058e9a29ce8f57062b7c4de1277b06048699982fec91dd8577545f6937039d0904b4a15a3e8452b6c7697bba45004fac1591205cd90416404042a8c3081135b8001f4431345c020c51006fb13f9b2a323862265d84cb514582f5d5aa6a0f4b420db02a42d43bcbcb0ff0b54a3e932c43f57c11f853036d3a8c5669ad48497216fad228c9708ec9b35b10d88ee8e2a15fc197498e7f3b90afe363c8b4a868fe3dfd71e4e7ffefae2dcc0f95c857e1eafd16b6bbd0461ff94a4f24694c1c1e6ef7e9fc5e68ff6f7e9b8b9af7cd8480b0fca947ec1fe5a9047f129290bbff2d830f66a1cfe364a80b9a20e46146fdca3640f92ed4921a2a82387a4101196539e0c2baf0c722914848786a43c9248f4775446b082fd69bea688a894ad7585452d11d10c0000003314000020140c094422c168241a536565fb14000c93a248745418894990c32084900100100208000400000088c8dccc00bcbdf5763e6c71bb01c0cee3087158de58af47fafc668d52d7008b50c11dcace6ef541765362c9b20775709e16b79d1e2c8ca5fd113d585aec72495f95a9b562d016689e6e6d922c58f60627a7e5170064bc88a92bc017595dde71fa0805c6b5fb5338e888b1ce8242a363b4dae59a0cfe25656837fa81860b6dd383116b0544ae81af24ce2a5bafdc4a8308f5741483cc46319365a504c6be0e5bc65d12d3daf2fef471af7f1d91f59de9ef45639e56ab34d38417e9494cb508995c9744f9449a6a3909af86e09a94982a0690e6e8c28aecbde3bebd5e8a9f54cf5e83dd01c61ec3403c0ffb3dd6b1f750f5ee416ece557ddd8b94243f0ce583c9acad7be96f3249ed9cde7e4707c222cec723d0bb89738586c6904206add0bd82ba833c64027d57388382da5eaa8340c150adb0b3b07b53699df40684ea7d299eabbe986c4f7d87a0c0d05cfd008b8dfd5d85f6025c6f6ceec522e21b48633100332bdbe1040cc59c693db8a589a7dde0c756affd0bc1a6fe293560497f05b6f2870427302c2298b9c9dff58a90c1563f85691b21146af1fb6b6c2f7efd8b5ffc321fdbef62171035ff6cc51c694ac1af619b8a96c0c9d84000fe920376504d4acee79413ba024f8d9cb34fbcf2da288c33154ff8e28d18176376dd4c91a0c3e4969c85ceb9476e2574164263d7395f3a9fa3a7686eb5a79cada1dfdb82fffc84143d670e47677262eaff857ff6532badcede4f8f3ebc0f8aff899d6f4b46d11c8a819d0b96ed2a7898ad8b98a6f6965b06fe988f04efaa17a1520d020ef7cd69d983ee35621a4ae0d0f997742e366d3ec9c6179193ee51c54aff24ad0479472076105a47773dce41488748fb927472b8eeb82ceb988796236ab76dd152ce500cf95dd060a41556d6e03ff9323729cca2f563c671790b4c4335e868ba18d520c042d23214509e5718dd5e9a6a6b566be52c1852624b4e9a721df7cf094106ed7919aff9f1f071f06bc886188a6388081bdeec4f752ebeb2879cff93dc511e1fc92ad38a3511a483f971918cde9ce732846bc7cfb927631b868a5571f61539dbb0e13f71470ae4ccf9b0769b06edf3311b561bd0f337c9982c39a77680f6fd7483b10eaf55a387369f519d6ea5769b0fa9a5b6b0216d737e565404e89a7a8625a9343e25f753b87941f2bf64f38148b0bc512cafd94440e136ff4c6901e8a8ee9e1fa149503e02fb40d9b1476046497a64fea740bf5c9bffb48fa9756d1e32328ccf4af0be8cae66c24fe16e3ec865fc28df801d155298633e82815a526e2f779ffa687a0ee25a9f2f15c9ac3c0e7a65266f3467a6292e638f1ed0745895ba109b088a6074749acffad589c30ac95b854add954e3dd31e384c874ce359f09ea159a19feac963e71c660c392a1873510eea586f5504ccbb0b53fa2c2ab43d3cfd85a7aaeeab5785cf7715c6534b1c23af9b221e53910aa53b475a07810bb32476b1e6001b5817cb5c9b17c719a6736118962623323c10e32a486a24fb9cffd444c3397fca3a52cd70f0bea66e38cd39b1fbb6e22acfabcc9ba169e7e45f97be0e9711d0337f89ef6340cd72ab1e21e29e81a0feeda5064feb16dfb9bd6b128c405ac79fa01c6955df03f79cfea36f52f7079ee5b4d1ec9d50f149f1c0f6dd86658f832d60e088d234e3860a66423b3b9be9cb60d3d3a2451371c8bcbd32bde333731b619d906a8d341f009362dab908ec4980607b93d3a94001305c7d0bd5822e959bbcd2868fb30ff3b0dc88b74dc559a8f328fec37a1f39bbd06da88a34b31fb030b1e5cffe26e22af74b5d1e45a689c9811d4c58aec15de935c61d40463f52c8bf9b1330fd0eac0cdcb096a69c0766b745a810a546f79e91cb3ec8fcdebc8985e2f7bd05cfd34ffa1b62dd312df30fdaebddefe3d495d032dfc4496398498b61ae80bc23e89e1fcb58aee1052ad20d5aa1cbd0993abb70fb21fbb735605ade496bc58b80d1963aa41803105e44a49e782b48602fb8a26697874799b3c4a71bcd2988d8187643241c341a6166f07156f5b41303f713d488e69abe29b2d413bf940df1e7f56c14a7959dacb56df8c9b85dfd5e4b14cee8cf8a565d3f9fa11d3bb9457a3a782f12227d3ecec7b87b706c9135bad7415c47a48bfc682326992b439349301585ac1023033cbaf14586a7dffa9d1d17bdb975cd7517aa8c37410cde23c208f28783a0972997a22f00fea8051609f5ad58e1d8b47ad8ddfe1c64ecd3a6a119e75e2a1004b24f15a613991bf90411eb3461a34ee642dd4a4b9ed255e4ba05c64ae9c8368c2ab8c2c39bc6c44bca8aade4cce4235c2391de27b35db5d113c27251a382e4336fe64804d8ad5b13f161233d29a034d2257cea0ea8664e0d4b7662530a2d4a582a7de90239e8486faf5dd8453ef9911ba36eaad8631a5131319769c4b0473e57bb92252b6490c1cac908bb23adc8a9e830e91abf3a24576d7ebe5d8213d8ff942ac1c5c074a675942782b2ddaa1cd08605b3952af210c2069706d119893499d79bcdf9018dc59d72754d0e398e86f3015909e70d13423543ef2782ac923817c9059df621323f33ea39e7e5b3c4c1f614dceb990ca6ba30722ad6a7e183dff41f72ada08cb49426c0531f8c37a211b13d1b5ce424212267ab333a4fd7c9819b40bcda9d15516624df0a46ad4ce98e0e5eb5c8dc636fd0d2d58ca86c3ed73cae0d307d72b8d703922c848148d41040c6e4e7a1f48192f34f5ae45f79215c30df061682a07c3fe089f2b3b6754cf4635c5d0cc6c70501098278e8de5d29c8f0c6381827bdca12bbf22d84217eff3f7404ba81ae8afdcb818c64d9bcdcadd521281e284adbf2cfd9904696189b8e11a370e9c2fcdec7b08287d4a26ebb8f0b349121f2b9165ab0602a2a0ddd4bea3ba918c5381042bbba75d0cab849d66b1851677f2d80ec9ddb9d3ea4980451ca5baf77e003fb8a0177d2a4505e439f5cafd53ff5dd2073e1150bbf84366d79bde689588fee9ac52ce67a67446aadf09bc379cb106d1ad60b902956fbcdf3537e9309dab6be41b135e86034955f0a108bc753fdb584fbe2dc2fda70029cada1a8dea300b986ab35f26a03ca6853829c84cc864ca023c3d26752c1a2db0ad89a52ad9e3932a3f0a7bcfb5faf5c7b9a7772b708dbc86b2f6a66e626975a836d85f676f12e4c2227ed68311f29d812191224f0517526739bbd30cbef7de5570093dded20bfa76daef648e194abccde1b8f0eeb6ca48371f62f25929023190d0981f7dfa946767405ac0cd840bef0dff841cbfec4fbee1913b65405b751e6c103957595c9b2024437de8685632aefd073825c6127d4bfabebb3fd24dd3337302a9e1d7e48a7968fefa6b015bea15f37216868eccb46c37faa5b790bcad875b6c98d3dbd9fea891a711a50f77f2399c0d73ec528490bc1894b0eef3582d5f9f12c76f80e10ace64b4fb189b09d1f3f8b397d0ba0dcdad2f84c257ebe2313d3b7e9b9d2e98cb80ab06d8a60738f2ac258a52747b5fd0050167f5efb745223e512fa089e6d2736205c34939f8592a478e94feeddae146de36c96159713b85f8fe6eb75611f3a376884071362c27414d16bce21c536c7b2d54e2cb5d5c94401091f497d088d88202bf9409590b3f67545145e7816932e7e7afe262efa42c874d4c136b94fd46ec2d565ca8acea621ed3843e4d59bc831c4d1d554254fcd417ea6d0224f7ae40fc02d4fa587f37bfc605eccd990f8d1f80e95a4f83a15f4d466f92c87b1372befcf7ff9bc278038f2aa00aef575bd28045660ed57fa98d93bada5a14562397179cbbb048769f7bf888d8a8b7fc6266551d8c396b35b82a09c8514edb8854076b8b7c82f29a46b59812da87560ea2b934f9cb062b0390be579df51869a11aed68f06cf40fefb0d1e9db875a9edf413178213c8e717a8967780e5fad8be9c27926ad3438e85bf8d98780fbdb35937a0b571d0b755f010c483c97a16fa67730cff49e55b38bd615560da418c0c73fde0cd06657b1b78e2b86ac45efe18ac892bfe01d0b2829039f75b80f66c172ed913235c221dd7b2ce73546a9adbad89667b466603168f529acb08d2b6b12bef714af6437797072a58277e402ea2c9eb7a64c4ae5912053ecde75f5497957eb98f90a0fde91251e4dcc12f089d4366610ceb8178baa6ed38ee129f83955949ff37ea7dae43456ae2d875a9b26a37ee2f69a4c97c3fd42873c5ab026d9dac78af3337a77ea0b9a094913b0ebb9c840379795e061cd88b5ad0229745c40b9cd824967801d4b75f53b1c6574b57fddee2d9209c9646391f643c939b48fc4c2ed03753fae15da873183239cc943d60dd7e61e1446f4b66b653b7cff29f481b0398b82c434e919aab04f2fd21f67c097f71fc3651b5cf772545614f3860ef8251b76da66e435a68c1a913b511d39a9c2f141d4c9f44dade3c4f0cfd2c4bba2443248d45bf242836440dace00c92c106c5597cede299364e5248cda8a02c2179dfe03365ece914bb80090b7e3367a80c1b9452014cf7dc5a1171cc0af17df33f618557aeb01ef14a7d529cf190da28fddd1270d7f1bc4773cfe665b1f1d9020c4a35e32c55df1d934b98c8879ac9d51943632a67b0b84c77791f813833f906deabee4894c1793655dda5fdb72ff2778aa0828ffad5c6b2d03eab0210fc18f385bd319d0b8a4df5d6af1907a2030e497c9e104110740d0423410c5c126983222aee559ca093b5063894843abf799b46d943b2018431edf113a6e6b9d47c30aab91e2760ef7be455040c9596e9637a9d061dc1bef7ac06a4bf5c0c05155a5bc5532863557ba890bdd350f3b81406a042de67f8b320cfd50d4a1f6e1c478ec2ddfe7e48f3e1f222d4ca2313b09b39b4cc57256056d8e760bee7cab961b9f4ca7fcb20148cd7dc0e39a87e6169ccfab6b10537702ecd7e60c503edaf671d5796319db236c3b9432b92b621053912bf51fae699800d6045c8a5c0569c5664c6959a02cd172dc55e5e0a7c29fcdb450d10658528b28e9089972695584dee4c89f1602616bc765c57aae40662de3f6a216e8218678c9c6f90718cbfb40625b2f377c262e862a71af1afb431405ffee10f17d790b14c686fde64bca4455eb755a360353a81c1c3f3700b7c40bcea213a0a2aadad071fe16a37ad5e8aa28295b4aeaac4891f26fb2d1f2266da1f73181df6ad8cd76c2d89512e12cd2a498dfb0539f8146072f58376138006177472f901a3a5e885b5da22c7798e0f82b50fc3ecf53486e84f3a499d3444211220ddf027e64418f8b1d603227ab351e564a486f436cfc6e5f4ca98c73670dacea3042df1a217343a6d97d8693a6b115b9a7810af3b4432b8b167804a005135895d1bbace946ba8bbc199f6b0dc2c333ecd2e054db3b4bccb5f0a380a776c05ca1dfd8bcf55984a9785581c2bfd0ea79666325038ad436b5a627dac2281defd6a352ea7bf1848033b59653e9986eeb4b173e72edaf015fe94d1406bed8af9b3185a865c34005460c67463b42ba4143181da0d584219a0fb6d0c2b44d3a469deb7e3e45793663c837ab29514723eed0c88d734ed1f3960a04536a3b023b5021db3f3b05acc76b3194242a157414c37920258153cc9aa3cb1a9209224ae19f7d222015d37313c76662a8ded9bbfcdd564ded0c693d2b7f637ec601481ab1bd8a30158782528c3ee190db110d5244089ea11d5b34e3fb196a644ec97acf61598ff7e57dbae3ad27c79be08f85e0b4add6e2d845863c3a4e5e361ce03f3f60b32d08d97d19efb6f12aa4b6608aa2bde3353591ea0e855429ce829d50d9fe7dd02c5d4544472976b9db3b89073241d899236e1c7f021f2a31f5b1bb927d6097b502c62ddbe9f438f32302f572774ecdcf25a5e62bb7f72762781c8e28f32d056642de8fe2168be17e77b96c26bb44da5088487794177ec8fd1e3fb03ae797705db034ddaa6c421e090be3f82f805f5a721520e54922cfc4584c2da675761f0b26c800dce8528ef89ab60d8e6c962edc2e8ad3b455051ac350795f55b49e896243569540e38620f58ae9318c82513425a4e5a0b00c880c8df865bdcdabec578c65d31a7766013a319adcd5e08a7c393744c04124ec55506e093e8a10bc81a1022c500660c2b6e11372a852aaa75eec54f694ca101136df74a591fd3076d63eb7068186711e3fa62100f8cd583044dff7717b4382a46fa60ec84ebd6de0e5ab58759a5dae8e6dd82be47991b72e33195b76a49ce5549be04329ce0a5edb4f4a441f481a1fb6630befcddb44646bc7ceeb49e0c1051c04fbf9d1afa108e789b22ab61284549c6d3b43fc8abdb64d5ebdfd64b1e2239513ffbe136deea5e41cb046ce5bcceb09d949d60cb224562673e000e60f28f86ff0f64a4eddcce9b1a63e58a0d2dcb24f89df13202f5baadf62964d6fa3a6bd092b9b516efc9c2361d403355beb7a7e7606420f968f991fb279cf536cdab4310324fe01685f5cddf0882e10a6b5d463668a61ab986bf8d5cd9876a11f6f290dea7f2980ce94485ab250dabe997c02a473e399000cfabe4ae5eff783f6d281e4f57e909983c250cd3d1722b0d6c915d326b4ad57744ab6fa07adb81b578de5fb8d3cbaefaa4525a8e84a9900f2ee7a4ac2f2fea36137964de3ef2a524a30aea830f4680ac29618ec860567873e82c30bb54cda869e676758b27a360bfc99bba472b505dacae2a0c2b882413f8d737fc882b57f46e09950adec77578cbfc8c4a9facc280644d60b5d49be8ffe70479d610f50422f813aff62050c56b53f3dd860dc6ee6d37aca382b673f09aacb9a195ff80ccf6fabf93b6ea79212a0dc37c4c7db5cf95978d429977b152adf80ca9956d07cf80fd6fd3a69762ae4fd39d382e540e837d5d019ce8299178db971b7dbadf2b5a39fa342607eee133fd1ed9dd0414efe3c47acadee50ba6205f69ef82524c4cbe793cd73bfc6628b010a9344d626f85076b62e41afa88b7811101f6bc02d89171c79145ed83bc87328ae8886ef772a31fa4270d487c97f6290dce582056b4e3da0b60e666a9f9251ae843591c79cf7f4d519e76baf6b7171a90326ded473e6465785bb40eaec41834773adfc90ce8ae00d76ab1da3f16433b84799c26d1b9090e65ec19bc7dfae3d403b1a8f3592b02196102399580887b4117cf8a324fcc894e4fa4adbb83737a66e5157d0e130254fc2c0d673bc48b34fe46af4cfcd35f8ea6f8981a7afc32f3c592dd2a37cb879a89a1b5a54d112b29fa26e5ebc95d10bf443a691e3c1d91040fb3e5477f8a8559acd64c14d970bb17bf02b04184d426a068df17a5e31605307bdd85f1542510732b20ff8dcf39427563d9bd147c5b2e0acb2e8535a6ffeb11680671d62126e5baf9784993ad0f50d23f98aa56755585898e16d2623230f584acee1b1ce551b3e32e007a2124c4afca4970c48f646725aa770f7976c07d0a817a2d7d778fc4f5261374483b5cb6eb46ce340b68cbed4ad9ad300a86d5ae59da4132340a3514911f7deb56f4fcbfc88c940eae3893ddac04d0990c616f49d262b7bee75c2269121d9ff9bed49af63703d6238d4263f59163e2fdac8cf598e628f80b320517ed7ef93036e27b3526daa65530063bb707cb7eb5a018f28151b090f053804486272ac002764ca34e2a907dd091755b4823136a525b5c78e90f95b171cf8890524394912bcf068447ad868f0d4444d1474e4e3bcae03968dbd503c16797d0542aafcbdfc5201e26465560c2bdcebd33d0eff34536670327786342855c6c64e7d224eb00091a5fe8f9631c4f575754657f51eb2a4ef2ee780a0c2ffb13400af9484d3b86642649d00740a26fd0c0ad8d9c26f56f9b83bafa44f4fb7e0f6d93bd4b7d034f95636ca01566e60fd584c4fd6676afb592e8cc86f6c016c4b6d2c31ebb4d99a524dd063a7791de64f796854799a825ebeb537c10c91b49023c77594625d2d36d3e06365977e2863f29f8f1e6254879550f54a9b90a64650716bebadc514d06e3384380c9003b5290e42989d4f28ccb4bd733a0e5dd88e08edaf1aabb02aa09ad3ac24835b8043bc7c580bb9d061971e4fb334402ac542b17b54a641c47696988f3ebcf9c33980bb39c73d005b3b78619454ff35e1ca763443958441a1153820de26035086c0c012e787e797f40351738703850a22f1cc198a37ecb3a07e2b310ae52b57db03ee03fb27602d6530dcc1955b696b2ff0c27646af7e21fdcc14589c2f3caadfc98b273c9574b1931991549cff4dc5b657a51419e2b19135b07caba82a574c092313188015574fe605c3e05a275603f3ad7a0d50955e3e29df7ad8d91a28372297fa11a1f45249fd7e173d467f7fed9aa699621c1509875e2096c5ba815507c32d33a99ed598f5a14830fb4d4ab9fc1392cf97043e6ee82adc5a8eaa91af973b7dd19381a2fa81957b4f921144d9ddd6bd61cc4f18f432e932fff65d4088f85827cb1c5e2d34ba0267f52593aba9deb026229772971d928ca843aa407f027137dff4b13eba0ebedd147e23ba8a02c03eb65a3dada1bb84205450a7a9aa25d92ef5854d54e783fc2fc445dbd04c1fcb8bc73c85579c12bb271be3861fe027c39fe5b1cf080a4d79cc7c5eac2e896aca823fd8eb09e6b0704c1a086b54d9f463540e0191e000b74442d695a1799a4e3b955ebabca6b3034eca7b6c2b3bec138022a5b25c8011c6f5646c81c3fa844b9891597dc6539987ee13ba184238f0f2857348218eb79455fbdd88e500d5ddd53a9ba62c881504abe4cae3303daf32d9113bdd196a02077b24c919c2015beaab82960ec3b37578aa4de809a62bf3e8f7c63ba898bf0c9f3cc26914bfa0479830785cd17578ddf70306b4422bdc151047fa90386e8089386adb24b6b8d15572c7fbf01026c5af2de7eb0c2b5adb36c25b9c74dcdbb061b131e38e0bef894f90c3a36634e02851212fbbbf8ec840a06893e00d5fecd986cb7f6fd24c5c473fe7f5f66fe582c52e2b7f23935f19bd81dd0961016839db5f21991a58d70f893517121404f8a5622d4c0a074c7bf6f150d3b373626a8c88f27d5308e6d48b7594147a1f16f88f3c8f173a5c8e4390190d6cbeadac1e8cacf980becd5e9ba39d3568cd8381cecfab96dfa91b10b7b58bc89da82659afc7990b1e3e97f1e035e92449c97c5f6e7acbde920b652f89f785207e0b56b92c8db69d80064817bf5ba94a32227b959755ed526e7e05e98581bf23b9e3a8368b03508ca034e49005c802cd4490aeffa99db98a33bb15fbe8f836ef5752b14eb7078a1c43225c3d2fff9882b6895c4a3bab235804e6cde26d6bc41bcc6bf0cd72d33aabf709645b3829428d9a39512b1e76570af0822f8d8f878203b8346174a61638943c54c4a2ead1b40e4320211ab1d5bf0a0868346d582dac8986ca3b9011243c7f85a851a72cefc6d019c5a82893f5b84222c512f5763c73473ff3577a9274791eb64f101b1953e0c22ee1e30b918d815690c3836e779d011d1bce269ba653c4985b5b3e2ef479d2418b081064647d19b84aae48b889e39c943316fbfcf47ae349b2417dcc27eefc2be900cdf9719d693be3695664a53771fef8654bdcea05cc41004c378fa12a2cddf50ac98f43265e3e29328cd8a2222dedd8cb2d0a96563ba029b66468c7b8a56c1f02579af90519a0d2ba936922a254094ca8edd7ca4a7ea9f0807a074ad8dd9aa03098d469fb5df074d6da54fb92968572c024cb923006c87a22fd81fa59c499a3d0e773b4e68bebcc2455756380fe895e78b014f0545d3af69778e40ae15ddd4532fd3460808262ac9d30ea1994c422785cca3e629e9867ecc1855d80d799056ec73326366399e8656c693811c8ce653f1c07756c8ef1097d3b9496f1196e0a00eb7924743b2b8152a4953d11e42ad9abfd39499f4be64a833dd70daddab9d88e0ea1d46c50d83da768497574e74563eca8bf5777be0ac635f584cd65b9e9cdd064778df888e18d70f92a1574a904ba7209a61ec8e9ea2db350b2b764bbb78114e8c4c40d7828399a097ceda9615b2177c239981cc333a1eb5e75b14eee591eb486f87e41559658fbc9f3a83840a72f79dc19c5f30544c80212c36cd7c633c6064d527e3144907f87083da6c76fef47c49d85837bf7872fb5a3fb68ffce50649e11ff3632f2130de24fcd2029101c40a517b8de2ad59ac9dc7b5e85b514e8b47b281ee310278a5a4085633c5b16905ddea50fdbc8009913260e8065655320de44257f6bb86c6424acbbac0fe8839895d4fafaac62234d33125b83082864c40749d805fe81e70d4e9f6b67c1574e82d0ae40a8a829adfbe0100cf122ab347a56239a0052a5d1c1734141c1667fe9ec8817d2f6d7c62db5e3b1726eb44de3624e9d25907093d8080c56b1dc81858b6a36d8fe49cbba0291713b03cf99ee70030e00f3468eb2a1231d51f18abea950ded7b3a59c28714476b38e7f8507281315cced5d2130ed5ce20b5bd82004b3836f98b6e3172d971ffc5ea0b3276e6ca3bf135c9dcf49da0fa7336b68ba399708c3bb89836b104fb69aab8a9e3c431f21453c013b37a21d25ed2f3aade04b71e1133b36184bafe1d4c119642d280d81677c5867ac4d418fe2358ba8296ee4a8f0f2cfc9e9226823c2a5b36b1558fa19723d5f3723dd3cb2a57ac4cf185e93a7d91bfc4d4833c9b0cef64222965c9577134b3f5399c2e4bf5a6d3b74143bb20a04530371fa8612cc16e2c26a279553eb061504b860e838d85807a4fe685fb0b8ebf112014bee891d7786eed29ae0d6ce127cda968be7faab74a86761d727fbbbfe483630b54e1771a59fcfe7076762c00f27475f9d9bccd1456e65f64c9f7952f3b8cf5a61025961ab9c2f28f9322e95daf5de131c27f026755bee9f136230595c0e9302a85d1115ac6a8e785b4db2cc06b5e55282b81c720ccd3a5c6a4aa2a7c3661de3428b94782e36cf5e2dfee4b58777f38496da8ffa05483c22cc126d4c74af752cb35d22981a3147767685e515267b275320877ab5d69c66c8240274233c04771b59d4a9faf952ffd8b48a894e59087d8609285a738dd3faa752c2ac53a195dccddc5e6d4c9089507e2a2bcce59310c2b7ca15aad2e35b2f302936a0207ccf1da58143e4705601ee50c6919e430d6b039d4d79805614ee1db5ac9f2e5e0efc603a3e9b17fe90b60f11a781038b1eba91949c04bd49e4ac62d60a8fd374d287c649abe7780482399d05147a29113b7fe23bd5d3f9723fcd6adf25d5771480b111e7cdc95e4f538d7d6b66a95fd994256aa795bdd59e7f3d59990a36392c19baa6b0f77280f13c45eb0d73dcf1da213e1883256b7c71a00e8480605c0241f5e8065ce15200203d55bd87f360ad5b640e84aa34120614a0a5e456fa942aadab667848337d5cc9a117f10897d8cff7164300889796776de4267586dc7f647be27308af6aaa74147b31955c9ed5d6d528db089511ee643ee422b8c68ba8daa06c463f175a3639439fea3f1eb5a9422d6da4430b93bc9ccfd78c1868216c745cc6a865a148185d86a13040cf8f4029e99fe8511e69d52d974ced5d8737f24b5410529c3de2ef4221231098eb8fd4f42dc92ab85b027a300803647f805bd1838a707658a76f8955a7300dcd55539970dac5466345b9b697397dfe73dd8a9c33b6ddc8d7c5a0e74c6964fd7bfca9ecf1da92efeae0fc0c31f741c1ee1771a9ffd78f0c66d009e1e0e7260029fad0b242cb3417ddb607f20b204b8b8396f25249e18c6839e4e9a76d36fecbc7f813ade0ac4b68074a615c0c2d47d98bf12b1824e6187dd0a27bef1b0ba43e257624aed64c7ebb66f6539246cde441526fbcea52afa6485049cdb7901db46aabb57e6862af9bc93c51a4e104384a9e8f41c5b49dd40afbdda07daf023f8fd1dcc294bbbb709b8a42dfb07e46a6696e7f6cfcbff343aa54e471e2ebbac8a2144f74fc6b1e3cc56a71f2f34c48193d6c9fdb8d6b1f21c27ca74adfb502a81c0916ac79861090cf068b4a77cc07dafd7b65d18973d3b414b658d644a66ceeb914b1502de40dbc9e8d4fec7f214c11a8bc0c940fb79fb2b3bec90e0bd644d0b0510df7e7c26e759e8e867d657bdddc42a5b3b713154b64b94e0037a05f18e46afc587760a6c5bdd26b50d74253749ca59afbaf37c90bb74a37bf2ea46b37a9b0418f7bdead514d04fef50eb1159b99dc9e881869e071350f4fc21ab915a0da775ae5f61d4c7e2c5b3bd94cd5d39678b511b3c546af275cbf2691c692c7d48fc04ea632842c16549e632d3f907199d84f9caaad40bca46b809f3482870ffbea262fdac543f19d0fb176238dd863018a7a4ba2bb6b025eda03a8561e7b3f54ef0520ab683e32ed13c4e085d00845bc5580747a032c29db7e65d5e65dee425cbfa1a170810b5d1b0bd6b21ec90bb9f60c6b2e1653dc07df8b1205419eb7d174dc09d8b0a76111db1d50996385d3605e85885d6464ce1a0136eab729452b5adebae5addf0e1aa1a8bd61388ebf57a69f3a1d59fd4a2305cef3d814beb1dfc705656c003a0fba8b0ccb9e49e5bc2ce10dd2c0289b9509bc925e431229628ac0f26e2a95f59aaa7e188a2ab64b8a4114a8212c8caa7032220c07f5ea13a4e4870f92f2f35083443bacc68ee1c94b5f9f0ce784b5b2b6673be54a913ef889be364e1e2313464cab6738f7a797714894c3f48a1374212714a6ba2cef2251871ddae1abc1196146178b10a6eeb7fcd5a0186cd9475960133ec2e0e235c485ccf1672f6b4d0c9869979a50bd02574c77e36da2eb2c85cce22f3a4cd6eb00d1191c93b3c1c0af0be5965158e153c873ff8086b5a05a2d06a3a59502a2b98b7f7f12025e72fe85cc511f0396fef2053f9875a4752e429c7a11097edb0c56e0b0cf8eeca88ca796bb13311fc6cdf3a198697e5aabe7192e1f666cc86c08cfdaec702a506d8c46e03ee9f3513c9a8002f3786cb5b4fa83234bf2671c32b65745007c99c02a8827da804deaabc33ff29c39a25aaf6e7ce24510e7c0522cf222ecf793d018e19b4aa639e930b9df07879c1b9891306daf1eacd6b0eb9164df44d6e2e033de5e70173815c310626679f2b20bba7f03d0f1830856d970acc922a04f4147456881ca0116703379429663df745db1ec3c4bf370390bb00a9d8df5317f1f0dbf458629d0ae7ebd3c1632f39fde2ac412eda147d296acbf6f681de73b78c47ccd037090f51511208eb6d026e499af8196f6467ab17c0ede3c3f50b8e01f1d626d49e354c5e4d8ff9ee839061b92079a77b9d6f0372be558dc652c0f9e6a788591f64aa93abb59cbc014459c423250e06835f90e624b73f5f5d1a1e84c37852edb3c26c1f4abd664981f2d5852c9e377039bf01de7918687c8d901eb3a1ce1984db8f968303ee066b6a912c51c046fa7832df2b660ab588bba9737dd33d6c15a9bb5da75246c86520a8a0490148e078ce25f25b674cc05fdd1514ba073408252f414eb4d3c791845aec4424770b5a4513cac9d416a67be8e075b3dc5925ce50d663e6108c4eba29144adc2b08eba0becd5a3d2f5e36683e7aac4f453150863669c5072472bd230db33d06bcbe0e6a8eb602257c4f10cfe03e3f712c238125c587ab72bcab0cba1f21a2ece27431d3eb12c760eeddca04f41bc741179c3f211619fccd0ae50379275b4cbfc4ba6570262bdd8ba3face03a6e65d2fc6bd9c1fc4856a279de8a0c5e2ea58304b7af1b95a5ba6c2098a0debe67315acf99def2bd16adf079cc9532fe3f50be04123445ad2cf72e855eb36ee3ee3af5c958ea6d4436f397bf106727bb8dacaa0a0a044cb31f456a3eaa7e2c96800a3c59b6c3255ee8326545d956c9119c2a0a697168e06acf621abc8f4b81b49d40f25a1df010bbb1c423a37e0425cad5b2012ca5d4e3a0a33809535c4a730221ab583f478be52edc5f740adda94558c02a05cb0b56c88690e729bc549b94abcd6c2c8625ad95f31bcb22ecbcc88543bec00ab75aa7dcb1060bbb0577317bd8cdfd0a967d2654543e5eaa9f33aae3e901b2e4f1a97f7d374918f86ed083bd42c5a4b996d2739b7b038bdb46bcacaaf79bec7578ab39d64ad25f73f65773e859e2256f225d23fd74ee4ba350e12455b79330890dca9b7f42e8415bcf418991255b2df27434257b5f79831b7f2c19d930405c1f06b5e75a503e0e68398b1b0023e21f1923b34a75a1abc787cab4f2f71cef7d63915d4f5603d508159e12379ec711291f68b16399504dd2b1467a97397febe16770c0f2be84e1070bd7fe1e8e1e5ed91ad8d01ff3d9fda9380a4549d1ff03ee8e7199adaa900de48ba7e9716dbc5037dfe3dfcdf8287e58d41ba0b0974b342d201c991870db7aa1025987f13d1684998c2349877e37d0870fe0afc7187a0cfd23a91313c4e80ca78d029708da936e8b639735f06ff3dfa3dd4c0b88b836295347dbfe18db44f88f48083edcb1bf8d9b6e631c8c024199ec4a742276a570b12d7f6d9817a641605708c51d556f44f2410425b799f17c9d0e5598c89c75c86465e1a7c2fa137e45e7eead8a23058afcbe34ae1faa1797524ea3d5ba8cff0d807ddd6186280c5d452a60ba9286dafaac4d5462a6ce0accb9c7f2d9a2dff6f8e655d24213e46593ae40cbf59ba930203b0494d8590ceb027611ec73cb4af2da26f59d3158d51b921011e0513376b951babe06657128980117b3236b8a07e1b6339518c4bcf802621f2935e2541ea1510604ed5568a79db93029ed547322b7f491d814cc97b3dd98e957eb595f210c2a6291a01afd7f7322ca4547445fdbf605986ebdf5c1737dac4e0a070ba15efcddb901c24df73ee1cabaec7fdabbea8dbb7a21962ba70d042eb7eaec4d3d6a4b2c4ee8f17a12b7ae6057ae1d8b7f5bc74eec9501c25193300e1281f59df0099b98d44595c0d89e54c7ca284127fd416fabe89988564e4b669135d83f9ffc5c8b83049e2f0e8bbc813640e5953558df94f3dc627e1da26a1230f6caa37681bf48c951748b61e686c7fe2737a89680c6356ea4ab9fe392bcebd71d6439764467b3cb33758bdb38ed7e5dcd9d5ec9826a81febe0f5160696ee01bd105f2d693e5b3607a3e60b370fc8213065ff51080ab42c1bde746d3be6cf51ff385a9cc6b6a5ebc25eb4f82265ad6debfa04af85cc0433e6bd81dc9b841c618844604312de794c2c35a40b00d44f295f7fefc42d6245c853c9700dfccabaa12921e732e3bdc3316ae6d2288b5229ab0994ae45208d8106fc81be67429b16e51b58c2526a201e87b0c3b592b449df3c577d71f8a04539b6db1bfadd365e8e1ea1f857b310a7269f8ffca013ce0040e0a94402d721d2dcb7144842230d8ae5ba6096a0ef0e385442a06cc3a4fc189cb29ba7c73f01bcbe4578f2220fa8e9d8eaf2b3b30e44bd345fec1f4465cd4174d36df8286691f7de610c68036a1da277f4f4b6f0dbb9af096e28143741fab33a66dd42986d0325d7db58f8f3f1aec37532b5fe98f4f6712b05132edbd7a267ed2b61497fc5326fba562c135c5e3a7cf6e69b5c79d986fdeb5b5cc4dbd2f2feb682ffaf7b3db72c769a910c38a84479df4e6f44c7d965313fdfec9d38de5ab865afc6bc2f54d61391c793408189158dfa73e1326506638c269a3432c8a6a5e419617a7703406c8ecfd28090fa106b6fcd4aa0b694e2fbd71660f3c158f1ed1a71dc6308ce5e20e554460b5b6aa556be16f32fe045605dad9f9284a2bed96c0b38a5d4e3dbfe65669253d5ab09fe7c3f11499a8fa8946ecd4a614920d903daf0240cc858b286627860772bca0fe65cebf983a77b7e30b505f9f441a956f3a6dcdcff57d8185c2a02b625ac154d9a0c6bff61ae24d1e922c4356b5ee11a261034ab120f1c0d57b0e0ff17637de91264cbe05dd5bfba08aa52305499d3d066024c992e30ead93c16a2518dfa4021fb0642e0840e5b278d7b83130246640a831e05218332971a8f3a54f534eb50d421b7d53b055a6bd8278b46dfe7e5815cdeb6246eed85dd5fd7f696b988dd8e956345175dd20d87a952fa740653813bf5d6b61fe75d4f22cf02fe8b6f174f40e3fc6f5bffb2c390a69b8d8d4c2b57eceb9ff0cd485ef96ba1806728d714ecfaea3ae799b20a9005f3097fc71a5a35e225b8ac8732a79ccf701472f36e3f4e4eea47516d88cc64c1392908e19247c44fb364024b8d423a8f38c2fe59c47dfa238253a0e6d79301d9d776320b921936acfba6ca962596d9dd78b0988a802556666f5433b3e2f6eac21af4ca7913798aca6e28fc208aa14527d3073a77d12624deb7b20815ab75e1813c3519c1c5c37520a20b6aca1725d068671cb5ad166759d49905853a92e6c2490f2178feb5e8e7a215abdd4c4bffc239804416b105be934b40e1541934858416ea4cdddfa126f4038608496fe05cc14880c9686f4cd2e5c720282f44893c8b1ce3d65a78dc57b40bdaaaa452873b9cfdf65f872bc031a2c0c70191469a362e29b856639a90f17f131393ffeaed7f7d5e60bc82c8f7b1aee3fb798511eabb05e370cace1a987e43fda50243f5f5e7af26244a28e05f3d530fe25feb942c82d3d846b453a21f02f8003ea688a09eb4cda85f5db4a84b92a203adb2b91fcc1e838beeda0a61bd634bb4d7f3e07d81e70ae5ec0bc7e19f46d14da93fc3aac6270c213b42de1dfcc2214826946a151df09f67e61465d77b315040663a254059eaa2b2f7442217898c44e916ff6930ae8632d576d72680681391edc4aa1070d28a6984ffdb07fae5fe720a84e655682fccca14b3b95fe45e3534d2dfc9a8c33af0f85e9efbeea970d7ea6cd67615b3cbd1ae6fa268b3e944a1b257542308ecb256693482c425a72058f851080a90de600d140c17db9529c5f1ebf25624bcc4fdf21632702463ad80557089eb12bb31f885231372294c6b89be502b9fb67970b0e1342eec0f2e79a978e3ece3da45e3710375d4574a7d37b7ea180012f55c028287d3f196292b8f15cc730148c01b945c159079253081b0469f3f173969d10373e8fa3e1551be375b6c7130257dd0f0c64454faae33038fc283da2728131ddf19092ed4cca205bf64b58efde89a5f2588c80813b57c5eb62935436ab33317d14326d6d1a8ea568fdc2b6ed08ac46ac01a7c6947b5bf12d025d82b0d09a51d51b3706b8029b2db32204e8c14c5419f7277aa22177da15b9548ef6a1a1021c546c0a7ac5a55624793ba578bd21dc25a704f71dfbb7e00f0bd3a4d66f2052810cc522e9e6e2fd1fba9b82b60aee239697fb49c3c5d70552d7f5d19bea8bfabc0fc2b0ddfc9af698f200d9eb9c36c24743ffa456f09b23e9e5ed53aad1d7fd0580d173ec03e6ffc819e846c1b48e11ab6f5affda2359252d08c1d6e85e3b1ad4d54b987a3972609006169090f3a2ecd76e36025e1a63e586f9e7e3ac7056dee318a69c14d43dc3e8d10b3979b0a1ea2d5d295e1158f018553ae51bfdc0dce2773b4b5b40dccc626ecfa4315d5ceff2a04fc9bc5cd17155260dbbfb6aa4d8464d7290cc72a8b6dcbedff33af42ced74343d79ea8b0ccceb708278046f390b0e4de0174542c8b348f49e974dcc7fd668a3b60584681de095c4bb2459a0b4137e64a3c14254d453902b02a538db34632bfe1b01ce2aa901669e666a5a729a3418750525523195c1a880397813006ad911821c16b8a8036775d650b3b4171eeab7e2bb31cab766b05f649c881a2ed1e7c75c14f31b14128c4612a88809e212672cebd6e33722be749fc0802a2327d7cc5754ca6c4ae7da09a891c1f0fe58f9b454bd4e0a51af5e2ecef75f772b497423c4c649c12251070f9ca16cfa0738aa38968f569de57e21d23ca41e19f2575b819719b570ba228fd43bdef991de75303c8ba5293209598e9ff6b0f526ef6fa43060f12746dc9a07c8b2a5280506d2d499218a00488ce0e065ad8863dfed034bec077bfafc3161ae11163f774c9ec139cb2d5645518a76590f1bce60bbdac2d1cc4fda17e58ddb79968b07490841ff343cedf3ac1a30457350b99fdbc68e947c76eb6f11f1a6e0a5b5ae848e1bffe2dd4089d334657116ca14ffe2eb60d124ad10c009a9bb07005b3bf789ff688a22326909cefa80538a43198460683a9e4471b1a53bbd8866e349b387703335543677d9a4a54b02491062ca06643ad4a2f7f24b43dff7cf10b6143ad67cb1b94057efa53d0176317d56de1f6e281d8f69de842ac03dabc5548a7c980f8c8a21f6b3078814fee14aefba6045c5be1901993d17487fc98217755fbb946c6c411329b65a23f1beaa30c486814c43435bb9c359369b3f51b18f1a93f5dda68888037f42830fad7cd6950c6a76caa3eb0aa1553ec0154a844d5500273429f0f5099cf157084e086401591b370bbb965798bbedcf959deb54a07e91ed9a85943f7859369dedd6d94f3d6544386eebbd81189de3d5d7e804ecb2743fc9e2b1f55d390ecbf8923ef407b8891b187cad86a4859bbad945a5bd79d6a2c3dc5ea744dfea26af63501160e57cdb707b757c2b6f7aacad8fa76e36279837d4b118865a31125bf98e4772b2bbb74a397d1cd0ff53edfd81498facdab178efc1abe1d446f8d81074f6ed8e0e4011c36de9f15ea607049fe08e1a3d5e9edc7474ad2407c1d239ff4b0bc3678446e9122070ce4adeac8f87b5959189db3099b04c8eae02728c87591119273e30f7a02d5666093552ff32f35887b66daf533ab82c2988d4c1c6a5beea8a25a66d08982e842b471793713aa60b48e69c0a2a0e8e3d844e287e928afad1e0182897b98cd191355c60525231682082aec10d9edbf30243d076d89a3a9b10b9852f603b6d3bf65bddfc6dc7a9759f11715cca376b9d9d5e6fcc3b32da6b6e8e06ee65eca0102b82ff39f059c6891caab193a428729acd9d4bfc23b7c215c7358ca0f72994cad2a3636f244bd555399c8fc738cd689127fc465ae80fb0c14a23cffe05e490e4b2a671236d64b7f8bff6dc556664665174097238b61ba621725dfd58a6fa1c5b75df1d7ae3a10174c558603399f5c3ae3c0f5bf15a307d5c0cda1fee964db22b8f89768254c97efc8142d324820a856b1a00ab6aa4cea9bf90a75c5fd2f4e896c198a65b3b502722d5f5f333c066deeaf55da4814831026585a4bc27922c3f4b2b3c3ebad9fee018d5c454a7f491b09093edc15283e58d3f1f864030d00374f745f38ddfe4c28dca9943c9f5b9c3c368f8cfefd411a186a12862e4cc28f79b594c44b30f5b3dc42bfda773ee74147176acf1a2b1589a03243cda07a9508a02c9fa7d1b3b9b79c96b5c9f2d3f5ca7f88896a7f1f652eb43708d58a65b5b9db09456f17639dda832f0996f46c15450a8c404dad293f53a5b51b5201d72fd818bb8cd000d4da8c724eedbe4c84fa14f136676a679252d945d2c7e3f3349f7a94f9beea5afb334d341079e415b691620f70f04e0dd33a974800f6a81b68fec66b060fb7b80f2a6be16d0c484d78c2c88a129cb2caa3d7324d82d42a70328bf8262d72271a79dbdca2c1827292b4bf4c19cac9dd90b150d1179c4299c13a65226bf94e2a25cb5e0a44f2739f49c932539721a425806efac7923b20e85931eb52ebe109ff57261b7e026e0ed79eb54fba47504a94089da386ee0975c206cd5335497ded0352ee7b17aabefd6c059277c127397212d0a2619d6a3ac15409bf529a1bd7708ac51218b7ba7a4385c83bef7c2e2c74c0d823e220c930507d243a2b9a5c2bb944ce17ea5a0bac841d96af901769472de5ceb2dcea0230b7cdb19d76207f06815eaf8a6e9cb98ff004b23bd05db6ccebb87bcce47052c18104589be143e2523e7c3231874ab8ebe862ef4aa39405b87d512e4a113588aa315e72a3ca3ff692951a38e7532738c4f7de9f903bcf4b49ec12115caa2bbc765a706b32d9c3a7fda899315ac053a1b9f0882519ae659be9325bcbdcb0a5e8f781b88442d7cf0515fd7350887d2243e28e51352adac496b8d3f80a11d5de5f029b6c847d5929c985d20ba849ec6b29ff50af08b7f8936806281d2142383a45c1193efeb21f025b3581d5c3e2c2a025cb32e862812469bbe785cc8f4c9f5f33e0bf19827380f193fa5b4149fd2cd0c3da989d7130f4090fdb16813f460681c915ddec339f0ba91b75e50556fec47a8f3ff98d20132a371b23747458c783c76b3cbb991d5b0d65124b21711f927a5ad4ec04092a709b53c5057dc5d2996b50ec75a134e08ea11372f79ff577607c973cc4f8ae6a659d700b81d517a2e4c8ae86ae58e270cfd8730007945a36e2a961a9ad62e910a2f49302f72e37b5da2b96509ed24e34108def9699c60d764a048f4b15bd8c6dc5929832bbc255281f0d1b565b3437d8d5f79c38daa64e202f1e2486b6a225d84b6fc8cd10c6a1cfda57615c56b56493c513528e1db1f698336880c37dc6f28f003734293ec044363692ae938aacb95063b6e836df1a150ae99e4b620500ffc6f02d3c2c5ab76eca4e4f5f49be4b62b9d8429f7b119dbbe8f5eaf32378c6c974d08dfc816a3adebea48ef26c87f6a5a31ef4baa4ad2c5711bd842fc4f35b5b6bef928bc034772e29d7d12fd3b3b61cc39288ce02fa2aac3f5384d7795d09e161981bdd706ac5975169f5564fcde8730c8e9e333aac2f6b34c82a265896aa1f0cffa2c3922661c287dc70d38775a6102b0362580cf630bead344a7151c89a78b38b32e14e69e7e9225651d4d5e029c1e3ca3dcf644d57ba33a68bfeaa1a0774624230c57310576a5763e20461afe83d0aa7633b40abe05035e1227f91f23e20b2d2fb35738ee96a9b25cc1f2b4d5fe9e0b721c03c2658362cced80d794c73fe4987831793fe54fd9e8ceec69cc7f42d1ce401f9ff3ffc46a6b4a3def35dde3169f11afe2f511bd129bd3b98cb50a044d759978ccf24a5b2c36735f4a8d1ee949d3a7d2b2e6fa6e04c773cd9a9095188c777ba2faf365212be1a127917c8890e51b967bffb5d795ea2530742b83ebcaef03f0583b5a4b25dacaa5b0ec576bc8c8d130cb625a00fbdb9280863228a6175d163175dc7bfdad5c8e0f0d3bbda73b69623b29362c63783b428f3d7922a5199dde691332522cc5aef067f2f08f5a50081e761c4f2913036f95efd24994adbcbcfcc7b67f2e954c773e824d3d95f8aca04cf5e52bc671387778f56ceb445f671dd88f421e7c434b4977ab40ee5f5608f9b7ea08b23f2d870dc6266c3605194e09a9d6b9501d488008e1395ded04f2c8d0d744e23bfa87052621fedd6fbaaaca5ae1b386dcd2261468c7f76b2c289ea6e72743e3fb43f8019dbdf0b4504878d7b69528f44718ae4cc75d8038a4c2327acdeb3c6a6c59245c59c82f2120b46149093f23a21709d6c33e8c9df6fd25c110e7e4e248f7e96b1f914a6a53c431b0aee78db8ee06874dd6367473594005f6165249a87e8d5393cc1e1ea229a97170b82a5690513ded5b63712d0ce5d205d0024198f17a228d8f22bcec62a047a6fcbda1963d5d21832ed074457f62a30bd8f21aa1aad4284515117ff9607538eb51d51cc531d0fcf88ca9900bd28a07ef11551a114a2e691d76822e62a6c6274c8a57a33513f4f08d815fa6d6c4e69cb8c0fab17a8f8ddfe12c19a92aa13223213437ab2c1a8d60f4445a4017f2939598dd3a66ec29b695e89d79a5856594134095eca45f19823022a4c667b5791d28359c317c523090091f4f931db7c78421370ea8a7db22efe62cf1d571faad191899379ede566f02ca7d0c66215a9af4e8d8eaee682e4107545233283eb5fce62ce0149a554abaaf182ce649a4127df77911efb59e15b5ae5a98f481bb0ef1c99a95952def60ed376b73996903c459aaccae7f91011a30d6f7012136000dab754e0069367732339d2facc095341c57c88862ad0834fe7ac044dadd64adac246ff99569a120d11ade2f87666c8f801278075d0789038a7f70966c77d3e2eca2ddfb93524ba5b7b7fcfe082e6f3d6886b3b42137225509d7239e61520e98c0231562b6c1a48bfaa595b97eae369d9fb867b9d2b518b5ad89d95010aa1603afb5131a64f2c77524ef052659fb2d28398a995494ced22d049a22e76ea742391895acdd52ad57392c0b5295ea0f3188329614e748262de426f468b782a8be5fb653de30e49a986083863d93a004bce83179b28551d2d637f9ac90c28eeb637138b582491f55ebae4caf8fb76fc4614bfa141f62bb84b3e2ebef9aa8cd8b3479500e4b8c90ee94c49e8568d48f70a97f810b3f92a302e475bd530d5287bed51551d208922e93ae7dff3826546786d01ed0187a239ec9b8ad563622c4d849a7e5f74b7e1f2d1d13eecc1f5eab5ec6931d34ae1cf0649b4cf3086e85c48e6af65d3a2c97ce4b90c21c1048dbd9f76d47f3d77303a7d4d4228ed7329207655185cbd133a401dd27d6dd8936dae049bc6fb4a43a661700d94cd8ff9fd2a72a5a1037d5388662543abbf6855c2bcce3ff48a120208fa26491d12899d0c65882f715ee6e93f28bed2679a5aa7559b3ff172a82a96b1282f642d40fe5ed612e91680c93aad62000baf15bde39069cea3150173aef8acdd9c97784c6adcf93b5dfff574021eea110f85e88b446ac170a5293dd211ab2b12ed2aaec3114f309c2b4c13e883d91327ff45e8421ea22af943ddb9c214dc95a94a7624dc40faa378d1ec3c755e25c30329de3398ebe0327ee892ceff16b5adee16afc3806f8b6bd25739f23907521c06e90320bee22d3f754551f31555653323a9220070efa5242b183fb3365a7d8fdfbf8a95a3138cc71673b2432bb2b54ff07c12656c1bc10066a6a0120fd437e91ded602f30e13510dc192d657d4e6244189caeba892edda033d490732f8fd562c1f85dbe9310cd7df7b12cec8c21cdd4c9995de536055cabe1913b4d1d991e154b977a19512cdd7427b68c9d53bb59be4fca63a8b4d4fe9ea2714ca07cebbe733bf3550b1a9f62105ed08e7e1b329fb0a9c4cb7ff26a9470a29cbfb283543aef326aae261555569bc0efac348f9677f67df59455ac5755720b9d611d1b571db4b1086d59b8ca443fd1eda4197616bc8657e180ac710c3d8f21ba56cbecdbdfc4336755fc215f552fd1693e37cced71a8f242d3328456d0ad64f2ced4c33dcb08fe1dfb71fac591a99c151c8fc9017b175a21a04aea05ce380dcf14aab1ecf42e4487a57329b73f176c9b87ec17108fecd0480ede99343ca5caad7826f11d8903cf63b10a1b5c2b917ce04001eee1a7fe8aea78e1c32d0cee443b16e6d785111ea8813960469687e1eddc4d8b979be86295df22e6918045cf3e533e9f93a100ac582e3bab559e8bec866405f9d55369ed8768448232a148336d1253f6d3debffa81da1069eb1de59a8d955f8e00ea8168ea8658c16fd9ed04892e7af2f523cefff25de209e56e9c3b4c448e7e32afb5718778d306a9bcf61e6677aadfd604f15d433a567671d63f43019e94204a550f4b356273e5133f0aa468623bd8944236aab1c5e19c449aeee9c620bd057218a9c6cab1e1bf80d0e8a6ebe48a0eb35204d2e951bb9c752c71acc3259d5567c8f82babdeff387965e59caf39c86c53ef1f400480067edb79b70f388417f09ee989d306f35f8297908629f13459d2094d4c45f252fe6eb9212cb8d77960191d71191c03fdd7aad5d5aa7afa696e89c99d120179732aa8a3e6ac933abfae0606fa0e078f761c1f09f6b0cc64f0f8e167545bb22232e773fd268bf9695837f8ff3fc90e0741b4fa71a50cff68d9e460e851089ca1cf66640038782fd8c80738ec6dc1855f74d0cccabb4d84e5f2af83a98a44f2075759b5c23745d0e33b730cebb73ab9ed8c8c6e0bdeb4996982b13694d66d6bd341074e5b7e56a1466e559807ba23c1a2e2373b6540f3facc01aba690805205a8f11bfc74d4b2701688baabf495d5b87938f0baa45fbac3736f024880386b85009edba18285e07a8b46d7355d246a1bf846934a464a611e3a230512fff853999127e3ef347f88b0c563627502fc3de9b11a4a80e01e14fa6f1673c824eefc0b7d3f1aa1a8549365a63a95ce8bf166b8c8ad282a1d9a5b06f0132059517569a5a8a2f7b534f822c7315536b0a88a930a3137892a6a06c86d2522e013a4eac9832fa08ac24e462417e40a005208eb86b691d58f4c8bc82b1b75fc6d07b48f56854db1fe061ea5617dc1cdf3417179056abf928eef12563a60360d563c9daf969cb9737a525cd4d974592f16594a4375480c2eb41978b41e03fb48a88c0f2daecb9376ef900d4d47a7dbf7d1e3f7e917f889a3b2b4710e595d386b1e1a0680de56021a9487e3f9c613075d839febf48c5c3744ec44fe6552b11a6fd6fc485290145bd831a9497570557013b7067486df6ac1862cdca39fef15d500b7e28c2595923735bcf4e3ab95509bd45e52a4bc3b9ffc38d25d3e27854a3ca8e4e26a4866eed9c6e3604fba0db65a6c91029707e0067163fb52f72abf86deda90c7de18237fd17660ba92fc427806ed598d4a3359729750abf70645f8d3cdc5634d60eb338bc2281bd3710fbccab1247cd3eb7963c9c46820da15cf66e1fd5cefd9ff7f562f4a72aaa15abda7be8dfda8435662052e36ce1d1f4fef6c1111650267f682402ef3f9b97737c5af86db8c0c246ac0fc99c43995eb8cb5b4353079463af2a90b865c2041a111916ce0830b195f0a00874912f3b771f39631836bd29057b5ad4dc71ab517c396cad82e9d31d86a691e82afabab71340dfdab0b2677ae437ce823723902a3015b00edd6639b1d36f669c67934554ed04e7beacdb6372fcccea641ca77779ebebdd308ef4c764ab61f71b27caf467fdcadb2d36bee49f103c4df75571b4257c2cea459c15a2bd52f2c2bd7df629ae20c9ab853f25890be9dae831087d2161291cccc48d6bfd4143d19bad2922a20ac0316f29b277dac55017002327b050ba836131257ab0db76aad90d2a17183901b325c6cab9861d6b593aa447dd3ca07ad9e4658af4c51d782308b1f83e892b04c749ecfae959d68f12150cf309f90e8247eaa7234b68025fa40728422af00ce7d27ae78c646ddb0083eff09f72450b0cafac998427f618cd1715ff8c18ce3205cc47652c2c993568a40345f5eb72779b0004fd86eb2c1764525afe3d44d1e5ef3add97eb3ace00e9347afae4cd5f9511c33f807362e6f855098d3aa38bd3d26128dbd8df44bd80fd95ebc643f328a62e1a2f2421642a0c95a7eac4e85ebc41002fa5cfd2f7b40de7aac2c749dc7b65400625748c463add68c337ea116fe396e13ee1ab6ca65108bc8427dc1ee73983942f75538651245b4b6ec931413bb4c13a6bd514943fd65dbd27171183f6aa2127c8449369d30b6f87c8142f7be3fbcf1ead38ddf0c6157b0df3f852c1172663c8de5823db9b351429a6b176687428203e0315bfde28dec6596b15ed03be9c8b32fa4616dc8424a332aa680f9b53a1502df5ddb13bee822c83ae4fcc2f332e1d3a57fd18a5892b6d5b8639bb5f1813560d19240c3b4810faa1d8bcabeae02916d83b83474920a261d51bb09a8b871359647d173a61cecc81336c525edb5dc713e8d37046da3dc58687a93811c13bc4c0ebaedc5868ae89f85b59da4b02d751af3e7986556a75119e41753d10ba14a1116a127c62bb841a668642b763eaf92c03386436e1be91e3d10e6f83106a446e96a338e2ea698738bf6b8b34349e56c0dbd9d4994f4633ba2962f0cafa978140ad480dd24c8a521004c373f3797faeb90e1e9ca4b3e4b5c470a39ceff250c59248714e0d0d6e8381986fce4c510c3008725e6c1e6b04fa9dfcf572e5f1a120721472dc512c74d2ae082a4942fcb8dca9d6b3ee1764a0f3c4c212a8e30260f3d098575b04fae84a67f97e5fe89ea784a0279fe26f784848a2e4212b492bd6e24bd4cd5c14d0cc2a3616202fadbc1622e94bdd5d7c85f9b88c9a0e8ad273f0591c67ed80e626bb1e9135e137a0a49ecf77ff6cd310973c6500ff9bad5b5787b15e49179987fa88f077fd12e32e9c04cc217b587fbec7ec833d02a131e705868ae52eaa64d83aab95dd497c681b0d2c7e502d371e776cb27038fa7b094286daafbadb96429dea74f4d8e8f8e3df30e72dc6120509f172383d77d235c20373565d566be43eb966f8121fe23cfa3824e1ced9bb1091631be68f79f7a0670446479b462817c02eb3c32172d057557dc3172b12dd868099eebafcea2e6e738d213108a4faa0a7c30d39f5e9552e42477fc0704b9314b14cfdfdbfd6854d00c2d4b08cf33c52caea7c264433c68c41c6e80c51911c70e93f9c6d338f50d19965bbbb6e6a37167c0d70f2669d5d2feb413f7245f90ab387378d8bee0dc4a55fcb5760f235d0687b51b9e2a66cdb9a2b76520dadc3b58b101da6092bdefd940ede63791edcdd93bc71e82ba79c579e631e0760cba65f32417d977cd339660b4ad3698cba07bf385b0235fe192739f05167bc26f23b33cb891db00ab20dda7aae49d8eafb080829705033f324db6eeed74e327b98c736e8d91ee9c98ada6c686ac3e406771b287264a3d0e53095b835c723a4dade439d8e51682676ff8860b94499e1407dc1d523e8640b7751b2a0fd376cc50730cdb65551bd5f64dec28f7179538337346787c68e0ee50a240d563758714b06ec483e2486885d943d65ed65292434b69ad965271caf1f97d62380345602075bc3a41419cfebd0d88a681c4342b9b7753a3634fc19d561ec449598621227c032591e40ca818edcc5dfb3aa86450c4416c3c92a20f48bfd1421a9b208f56ca8cf8e58278c6077a3f10ba37413eb63783aaa089b217e755692f1b0d1e6d7bc4455153b60d3e8bb420968181183967b4b942fe0db86b1de6a7c1ac63dc9c4227a5ce1001950b6bd1c65cc8ad1e67e3d664a06bdbcf820e3b473cb09567a9d6f93bd24be0880165ecfbe206fcc5fa3e2affa5b682337a7c16c377e9c65500a7119f621220c68d46d55e57975a25b5ed45184d7c6e1cd95432db77667cf31cc57f6f2600494c1fe51be80184222db904ed2861a59e36fb1ace1ae02c068250ef9f4e51c2c235fb2f94b3b00f7f1802f962578723dcede3ef035980bccb6d38133c7936b2e3eb49ce18c9f2c0965ea153260e59136ab627c154b84c9403d45cc58e882e1cddc92add480a26ce86b8372848c3ac8aaa2e1c320220b52a8eb08eae20ae68aac994e2a88824a5eb791afe1447d443447c15852a16dac0f102f6ec6cc8832924983f4070cd22551e7ebee86646707b7e3b1d7fb08b816a7f77a68d9e28ff43d3264efe0497057676198446de33f15baecce729ccf3cbc77415a5d64af8d3a0dfac6d0c042ec1c811d7ec4e973049dc6a0eb9e0b04c91ad08fc7e0f4c08df76e33986c8da0c7a97eabb891fd996ff3f02e104b5dbdf9b7831c0326b8c48956b200d8b95ea7fb30d3f345a0447c39a3a5db56a664420fbd6e4896346f4888653f7d72e813cf8174b385feb65679c62f0f95d0fd3f88c4601165cc71f47d43f3b801a4ead5876e08903b2f523ac97733e25e5f5e74b757406165397a0045ee3b3eccf8513ad704a08c732c921aa775c7e36c469d20e97947026abd1778493790367dae22b9d70e04cc6ccb76b5faca3e5d6844e0bc50b7c2c910c53cc872cc5c010874379875a83cf0abfc92e2c4a57b644fa0ab02ee43c7e8cc328c8ef1cdc04bba8a29c0ead76d08963d5d089c0dc31aa4968d634f6dc803b7f7ca42fe10656ecbfef6f7f98faf7024a6d5f5049d3d16a97e23f366243806c58119d2b20188d0a9a209512ecde8fb4d6a1cc3b3c12ea4980a19eb3ccb7b53ad52209856cb5ccf01b73e420ec7e213f24e47bd9198f4509f9548ed496250749f49dad347e4043f6dce0b9735826d4a554fc043be7dd4d722b61aa64c7ecb3fca0eb59da5ebec9664b5c3dc4755d2647e4d41aaa9aebe9753804e38b5028096f964fed9a5c86c68c642a3b04a10df45d79cdc1a4641170e84b07d7067b07efd713c11c3c08bf401cb185ac46b4d4f50d69c5426f180f5ea342d7cc38e214d112c21a5b2affcaab8970480308cd3289c468b83a4f5b8ed822e2c2bdadb072aa5e8e3c1f399ca90d1de3f4cd9a00d474ac42e05295c43e51cf4320db89f78a8a59caef7f688d9a20f42d20065d9a19d3db3c9555da4680ae3562a7e2b612b7d7df47d5e447ba40e166d365a9a4b61cadbf99f16c3b75793b43751df1fd5547fe2fe44ee3824e85a54f30d0fc0f0fbaabd656a87a197625e1724737c18017109960a68f042148cf554615361fb46909140dd9ba5e0165279211b909a8d0eae444f9a099751d0cd60cdfe4b604c26a05850d247587165af630eb2688a9bb0e86a23aa7370408c4fe739bae2f1a63ac329eb81d076a8ea3f57c124d6355b44f35a2875cf390cf4f62a8bd1ddc14b825e4bb18a4fa236a949cd991efbd6651885f9b0caccf96c8e504be8cd53c722ab890870816744bd8ba37b25b59503a92ea64c13b296168c9d25de7104601d726e6559e9eb466d1777e1f79945b63eabf6ea511694d22d915b4313b9fdcb34ad9c2d9d5d450fcccbf82d1431bd991f9dfc05cd95d4fd877473e8b5614859ece1d79584ee30ded1e5676c76802679b69fd6cf9c9413feeeec8fff29c5b3dda9972977bd7c096cfc83ea76475790f04a3de4657ae229b7c225facc13ff83a6599aac01e25a8697d487febba0df9bff4339440462996045cff0245aa5c7d69b0dd04af41d0e238f92be64bfb4624970907077d2029330b864ea99315d9811858d58ab58a404bbf5485161a1612bc47e6a0676e451fbd209cfd024146d456f39139b50cb5f7df726be05da8b039bb246307542316fdea80fd80ceea02d0657ce2028021626f9abe05757bc020cd009a7a764ae70e82a917ad45cd24a193cb048c8d14be9445b63b7dd5f2fc084f309d1bd9b19d093e7b09b5cc927894594ab1a683e0d2ff510e7c414e30036c95d308c5a04f88036606ade109e013e48019612b30097e425c282368b5db048b031f201798095b0193f00be24099410b7002fe0638206686e358edf16bec1afd8d4ee3b7f16df4373a8dddc66ee3dfd869f48dbe46af1adb0dfa763665178128689b75b0dde187220af485a14dd085f09939e78cc17a9c3c7e66ce21635a4e93d39722d798395b0f13e3e7c89d330d967372fa9cb863c6d1324f18be47ee9861b60c13e677e2983246cb71d2fc19b8c6ccd162e6e4287d2e73206724d8f2a17f52f89a38c6ccd1629e18fee1e0486e091b4853770f65f1f97be0ce8c9375aa895121d573ef05cd9e76df3799ba14a82dfc5053b97d38009eacdad67af1c8c53e1d92883a5ffad380b420cbf229f56115f427e85bc3d2c87f7d1f293b507bbccd5667587ee23b807c1d60933f0325954c18f2ef11e725acc54a522370da8206f7435630a88d778e2b60aab653263f866d7211eb82031e018b8231098cdc8962bf5d82a539c7ddaf7494f2972a24d1c04eb3012101a0f3043e2959d42764987ee2f5d1e11afa4ed1dece78d48118c83b8991810f822692371e713fe66b6b2912e3e04a4fadeb90544590d3e7d18581f773e1e56f61641acc0573de12d6af6a0d78a59f4037767d25e33606496cdad5a83d215993fc27270dd6d22ba7927499afe0f3aa77af935be6fa7680965757c7cbc57c42cee0ae6c7833cc01d6b72eaaae5180aa3e852b02c973a85c017094b6d0f05bea797a0247fefa4cc50a5dce370471b0d9f6d465b6d002af78089e6aaba1dd5c56279b79c0357350f8a2eee06d2084140c4b1d805eb670f6d3bc43f1e54d8b391898aae102146e2d10e5e1cea833c895fff409fab2b184d9802e5cee2483544d2aa06975b483180a0f4fcb2928ee5ab0c1c775182f8ba15a882bed8c18f54483fac31f9bfd65d67c7d3c56f49194a88e742f9a92bb641c829a6608558975106ddbb6dda87a00ac68a70d12e5e061d2ee0674031d836b29db95eaf35676312dae63eab2f5d48c9ab1840e06969e395d80ab766927e3475ee314249585a80749d980c51c2e0f1d74d63b9e6835859f47ede59bb2c80814173d427d94d84741945cbb4f7d1a2a3bfd01fa4b512d40e1e36dd8c0c05554378ca76f78865f39458902a6f3071bb5fdbe7cd5f86e2511f5b77b2efe85eff72f5f65ac020091516dd31002f052b539222fa2f84127c6ad675d7b505b1621173952d648942805f969d7e4a3f8bd9cdf338b5f42f5f39a80e50345f3dc5504707b78ba7328379374be3c4344101f7b24e78ca78f6002977546776606c0e46db31b84757f95e10959184830e28ce5ab43250401e3b022f7340dda7db83bbd4d4e81456f6f82d1240da1cb35d077cc185d141b1c7ceb204581407cc6a52c813b618a04c7f806caa8df3d09b04a1d1ba57154867fe95318446e12aafb1b0d77cdc0236af234f7724a65454ab80c144f3775c92cc15006975936124b1c7cd40cd6c4ee3013195452dfa1341cb50228cfae44bd87812e15a0e514f5ca09eaef397dbcb84a35220d686f59b634be8810cc306c03170223c95054b99b8f33c1b14b20233cb3df430a868cb390c1ec34d3644fbd6bdfaa555697d7cb5cb24726dee2f5ada3c4da530ee15a693ed31aea1bf3a5e937adcfb1d68ee301ef9e76773c0674bad3d45a00adafc360214523581fecdf8464a40481cb22d541abd2e40b8ef0c6b2c64f2bd60ac3953522a148321ec7ff786a5cbdda9b39a791e09dce1fdcefbc08bd787c5aaaa79ca9602cd6e0f78b959163bef69198ac99e8cd7f9a8db0ac46df5df67960829408e2fd72ab370d786214cd223374d57cddaa898df01f7dcab64767004b9bc907a697cf090f10447c46b41506910d18ba78b4920dc3924dceff96b412bf23688150348a0d51cffd1d413b1aca1f142394e3afcb46b02a8682fdc88b15ac753d5b6f2163a9e5b1c492861478723700fab7aef7f9c3c7859627491a888feef4943067df6c42040a9ba8c93acdbde4bd03921b6278d39fa69e13dad6ecba0b7464c6b70ec34b93451b05f4c4600098e8b600b4681109a2c7340ebed12e62b301a936349fb7dbf7b0e4e7cd1ba284a71797a4dec830c731b37cb65adfc25e8fe8b27221b9debbc7084b026a1d9f53b0cdfa5fbc066d5d2d97311b27c8ae715085a4cd42080cee17c742163be37a9c00495978f9124df0075a2d8d77b3b575c96568a64a454c20c733bdaa3108d771c809e8d4a577d566f6e071f2e68ce086978f01af5eb88f80c990bd1154f98c607d6944bf6ca5984a8f4298491569d55942a62734836f07b17303723ceb98880cd87f3e0a82094cab9e73f7973ce217cff33510839860ea318856af9d58f16ad101c2a22d722e456f77c5b5dd27c5e22230a384496832e095297502587130b11645065f821443d336a74f310b4add2b779c18afe515f513abb14f1aef373d4f20532f612bce97183c56da0fddb77ece6313092d8fa1fc45bed5fdef6f0dd3b68b82024aaf760625dcff38a9a49c8c74d0cf8e1e574ec4e614a12a01905863b599398275b16f12e3d997c5049550196a893bb4a2ec5f5b6eff2bdea83b986d1e7a94145cc256979b5f956bcd9767498fa281c368248c8ec512a762d76aaef4ce388c4527d7c7b7fef2f5ca4de219be1f66189ec17409a0818efec1e3b1dd77c15a05bc63d0031041439487a46bd48e9d05a352734f3ba923d262d0af8a69ba2b4c1cc58055932742516311aba55c8b8196837e8622e1fabcf89002496e234019ed7deb3440a910209f8917e2ed152aaa86ed67618de87795fbfa3cc32e15aef20c1c46cd599cff0b030dabd2daef1df37ad186a75e2ce2addce2ae876876c3c0b823b30515f434243ce88baa3b9b881a669ab4a75630a774227a03a866ecd04f178be1122d2e99b5e00d5e0d343620347ad070e341209ea49d52914ce47111c809b802aacb43b88bfbb9a568211df44629f642ab2401623ba348d3ca60ed8e619005e1b9290b08e04b2ac7213aa7440a30e903847d6eecd39f7580eda3ee9dce0ec220c05fb2c51dd34725acc8ce054226c6426e942f7f53f24efc8b1a4605fb4e6b86cb4d6adcaa8bf53a68512b1814773b77557d8f6f32caa4370198910a00f99e9382967342e214d981edbdd03d83b91513fdf576152a2e7e70500c63f1ee95962dfded85fa3047526fd03398c5abcf3a3e1f02dcee7dd60d1d2d0884dd6631de69037414374dc5667e1180790e46449e10b637610e78e4600cfcfd6c7e1207300b0e1dd01c7a1923269269c866f8b6f075f3d5ac56904516f9ee9c5937a2002e66a0ff7c9c4c18bc9950c9a489974581e781d2779628435592d6f4b6b998259e910b67df459514a19f9445601155232449e94d723a6f9b92ab9d6727430c99c6282bc79944a43f2aa476efabe79332e9baff489d26676a4ef05f07964008361b60cfb10114efd31a910886d93d72ec3605762f722b55f26eb894e91db206d060ee4ea8e9238b974c465cea1c14a6fb06543629ee1165a34ce39bb1ebb617e96d80219105c3d35e3ddd246e2357a1c893e4f660cea2398632d567c28883d2e87d99baba04af7bf04542c24b2058ce767cc05232b48ab9d61eece5868b05533401dc2ec8bd7682de66ab711e89848bad04f56732803b2c3fd76080f299e7224e05b0a9fad8fc250c608b29be452ed8d8b6306556acf9f389a1270836a04413609a1d1ab6e1dd5d9d235057235390fad6faf8e21fa6fa9fabaff3fe86ae8e16ede74fbbaa32f73ad664d9c495ac98eea0e279ae266b9be1be102fd47c6f91570a91938ee7d3b926e76de3f3d7ac2ace80d4cb2d12a735769c2113368f28b44ffce9649faedaa6b98b7469a2fd3b5664608d66d6154ce85e4330bbcf3abf9d513c40d3d9da9801482019abb7fcef4e749ca616b0978a982d3e9c866bc8dd77f93f510422bbf4a5d47502761436d0d6e951822e396c3ea2f8e02b8c2b14d00bbae9f9cfb97c9d4492166458be0e3ca2e31a663b048bafc4cab50015039f67ffc3ebab48fd1ad68fc7106b4f36dd6f69e6b75264fc11c5b0c791de3ce77f9ba2b7239feaf4a87f7afc0bcced94842ff29d82192cf7daf49dcb93c2028b56ca886177fd293591807e18384558ddb900316b04ec3d623754250071fb8b6af2a4d87d18fedfdffb807cd408cc80f380030762e57a05d375b465a73f5fc798c68f54b4e809a4cc519618f7af1a468e126ba73d1a07906addcbfac2296f0d03de079189249d13c7377b9968a38ee2e0a2f6413a0c8df57327b2ba920f7595cafdb8fa79b58ec9a0ab4f5604d95ad1f697ff02e33c5f76e615fe588546fe0645ba6d1af5b6ca803184912f778b0db503c8e9b44ab8f98089b7294ef0ac01a60a4f1187a34fe4262909f561fde3d3ed1e6a5283c15b9964b198444d106e50998092d80a547d492e12f41a0c023fdc80ee111c946dc629081a3cda10a3b1e85c424ad107a4f6dcb99cd9811e6b225721990f41add00ea8b35b85387e09132f7e05e3a0ac49c9362a2a56b63d10f7c511b4c20250e9cde6d876114608e5d05eef5fef43caa203487dc81f6b805f97c80a0569e57b159e399600614a1ecb84c013930e49a7f4a9294f5c0b51e682cdb43676ce46f299b344ff2a8ec0b8dea68df35a3b10d5a5498a561a9f73f8679c7ad9fbf213321144d11ce971fdb9001581a8274a7003bb88259a7079903779b33dfc77dd5e2c4e247448261498158c4a6e2cb858a29cffdf2449b5f66584447d9a0381680f490accacac57bcf6c0ea0815357ef47bf7427a59d0de069675a8c7772d4ca9b6f6489b1efec5849c33ab7fc125cb50656e7ebecf740ba9ce542581c42a27bb853517d283e0160e445096a44577905f4b75056f4f86ee24e71e7a26fcd67309053f7a27cfd25d5e25cb7e152b2593e52db08390b96e867ab683cb6bdd64de1fe0f3d226486d5260e21c98a3c1fdecc460aa4589c9c7e2fe5c773c307d0a126c0ac11a4eb59e36214f7d9cf588b5da94fb963e3ac5e1690bfb9e794fa207e2a37bb1c92da3e0c611e02c73c9800c8abb6e3e96e9914e449d4ef6a1f531cb9c04b8bb0254dc6b99b33726e85d243dbe6afe96bddbb7364db8f90ddc2c55c56b7a8787cec8f99c2fb3016637cce6cd02d4c8edc45dab90e92470757516ab626ba967a81fd753c543e85630b70d7af61653abef4c880877201e7686d60c24773bc15c9a8fd5b4a2539bf3570ed1794069d31a044eaf39408a99bed0502aa6de4356809527399936eb60edc68b1be4921f5bbbd45c5ed17540886310de573e9024bcd290724386bf95602391dbf5c2a3b3c232d9d38a67422c80dd2a46f04b2baacd4b89c52986a90a5bb3a5e41740331f57e28f4acf81b60769c1e4302319c427dd1856f10704a8457ea09a50d7dad41ea1b7cbfbd428f3c7c2baffe07804800bcf8aa33785bcc42c8c910bb16217f466c237eeb8c9650d606240dd641329c2c4a641807a5cf4af5c070b261e4e3b3db17af687e2f946db01cef665837df1cb5ae982815b0e072ccc5eb6ea4820a553460be7344177a439c41d4eff30d84d8c69b360cf1dcc3c571b4b37b685ad6af7e7f30a7cdd4bedbac884bbd3b2d6eb4dc4d68779abbd387eba064596bba0c1765171b336d0e6c69a4be90223d0bb6f287b517b76b7e1ab65690b6e9cb6c2a71722ee3be095a78b3d4187e205c97e13b2f9212549ad7ff06a72ff5d0c7755feefe737097489ec6006b38a3414c8a8993f9f10bf5a5a0e9904edfc24584a06992e6de2c6738370cce0ee463df57aa4b77a59aff5ac9ed54fe137e5c6bd996ee8e6546481d5baf16fce1b74e3bdb6f7ee656f0aba21de6b1c017d88b85367f14f656a5b0bffda996dd180b98fd1d16854290a47847a04939bc1f9f6081828da7351104faf120eb2338274de14f873d7a7a969857b31957f1e323c82184b50b6abafc0b446889e2712db8579f42dbc752eec51e7a1bec5de6a4b7a27f678dceb3128d7b4a897e49e75b84352cf4e3d9374aba3be893def7c9f20fddde25ec7a05edd92f6b385b3eee562c585c2df2cdf2f41fed0d2abe7c2e2fab2e297e15907cbc50aa3f4e3d27d89c21f593eae1bf0acf657c5ab7a710dc14a736771e5cdaf90c060a5ce37dc5c518c66dec5952957538a577ba599cfd2cc4bb43206654af16aacd442b19a798b2bb9a8a614efed95373ea3999768259a942dc5bbb1727b60cd0e45375756db89b7f24a54fcbff2e8e8028d9f433f905edb8b0363fd5fffb90dddfe47466656dcf036f171a95ec15a377913e0e325eb8a5517b4dfeb54330b3c9e039aa3aa855b3052aa9a74ea14ae59b46ba470d6de23dbb6e9045638eb56919daa4b16edde55cadd2669b5a2c429a0621a8c1a841fc2100400529608e28a8c5c5e1ea20781e27fafd7eef55e12c6bc4fe8b1caae37b3b6d612a2d636217b6fb977e508e4071a08d3d5c93063a6f70428304134ade323c3ab90c4aa726154ac90fd26ee31c4ca02051e68c07c56a746a353a650a1d2f05a5792fd581347f922b613726c3134193e653493647590c28e0c9f2309f6abadec35b9d845c49f179b712d57aab7c34b21c37755ccc8d0c464f8ed03351226c3a334f003a10e0a199e7b7951c67824938ee24ffc9155bef803039213421d9ce10f6764bf0afbf1726e86af49d8afaa60049d3c8112447342863745f9a123c3bbd6b0e172d4ab65b75981ab11486402f6e8d33bd12cdbddc0cad938f1c795e1332e70b82a71e28fd59125fe1870f3848f8ee943391ec77aa932f48c92c68606f6822a00e00a226fb644596baae596ba6a3031352bc4d4acd082878367430cac5981082d980183e3f52b9b34934930482f47469c0d334a22986143110e36dc60030c830866942237ff2cacd79ea4b36389b2560abb59aa5a666a1f1d4c6c73de4c2980f6726d75777777b79431a3b3bb71f79d73c6ee8ec51e514a306c7c3f4208514db8bdadd37bbc72856d430c55518ecfa109413e44987ca802473ccaf111c9a7a5813a56ee5e72779883dcbdeb7e1022773f80e1451047b0c1858f4f8cdb5879dba8e46dbb0d236f3ea4206f3e4d70d00417b090b5c336d0c828ed912965824fa64cb041a66d84e00a0ebc9a1fb478811442190abde4243cc9f2564a964b4862038d2ce5490a1940b104a38d04d5b26125890c18174c36583093e784a922724ae8000e9450865d2204f2473a401cea92e59328813ab03f293e225ff211952f0db046fe88c421007cc93560f2d540470d24a5b5ad96ecb70e2c0cac819747f2104e2c7b0b14d8efc740a687e99b4803b38940e4696d8f1e666eb6daa3ad4ce7040206eac82f85dcba17038170b1c7bc95f1e6c09a590f03759460a58c929bff4e799e7042ab65ed5773e2ec0e869929868135b1f4ec26f172b64d579c2c5cd77ca90d3b7f8900b9d820cc566126550b2c0e7d13719ba065467b1ece0c4f3ce95c99613fd86bb5b6d592b03c3529365894bf24b0cab550a7b521ad8a7603ad8a5625571f6d48aba255f1628311484720df92675865fed9dbfb0f8349b0b6d24674a8854025a5437428d3a436a24374482bc106fb86cea6d995f436195ac928d7734a49a59452ca7e46339a6536349b369d4d2af31349da858c8c12d205ec66dfd992ba9c4497a3f6baeb4f292b97cd3eec322a3749adc8ee6e39a7fcbc72ba9e645795bcd3f2ba1c7541a6eb8926a59cb3bd98156d104688124883d50f5e6dfd633769ab924e94ecd47c581626d8278cd504ec8985524694230e803a992764e8c29ae8cd63aa0242424242a236dc0013e20398902a3f5202a56f909090909022ac616541ac0c3c071c5720f08aa214a1a13caf0cb1c168a9a252b56aba9d97e23830fd8a515830b231a2318ab245571e08a2427a91e50d07884068769a8e3d22cd545f1401348f4304d234d3b2c841ab2a14d4920cbc52d5aa66da81fda051a402eacca01ca240b1816ed92dbb65b76c198dae1a72c2e0c0e0ab6f61366258179113904498bf885d432ebd7bde943833d6dd46466b7777d3ae5bb7d464679dcdaa6514d367df289d31993541d5ea49fcd25efc8095313c0476ce395bad5ae984dddcc056fbe6dd314653de24d7a5bc4d4e526ec21a9ae54de3b2ca69336f25aecabc99b8d2c699386eeb60e84f53a96ea7086be067d10661a6076b20aedac4301bcdfe699aa6497a654728259bb3c8890decc0892644232072e287a8893432972191134300b52a154750031809694058102106900d8608030968074700418a15238080046486116140e9170c324018525a5fb4b42108815404243c1a08f10321bc60d2da322412628bb90358cb22592003322db0801416f0895181dd32240a228d9717b6cb902888a3208c0e932bb89665190f8ca094d23190fa05c748aa3efd823ffd82325158ae06444dc0c0082b55e4cb5b020bae341124234413506cab89272e2840c05a9adc618433a0384a810704bbca70e88c19c83439a307af32ce08e3c76e190e9d518433d238425249ea17f4f9017232001b3ca12f1f9200449524606087164970923d20609905329a65b406233489126589295714418a200769e4e00a1499cd3ab0840c5c800552e4600b1870f144e3828b2856605944404de45386444045e4cf7e8600a21184d08f1292f82162090330f1092288688827800c1044510928853434308411c4f8c072190ea521254a1a53764c61b30c87d2c8c11a6914e5c0b41ae3bd980426d7971a6918e1215c202221a55f5068a84a919101c038a23979280d339a20c1450f9080381a52034a9e191201c144fe9e63d6c46b85268d6a9a0788d08630541a011199107caa0a8aa05682b42b8698568a321a1021855045be604dd2c18f5012183f0308824f52108418c0109eb4981cb1321c4ae3072220903a0ed4564ece6896d11d32b02c19121921450b234600c508275e51ac29432223909899c2d60c898c18228527b6942191113e438a48aa7d038980e0402bc321352c906986444c9068b083ec8b21542a08c328096900d10408d90b8260d37082524a29f5a10645449c0f42d0807641240411911055e45586444240c9c0061be76bd958637422e67863582d43a21f1f3c614b39466984221aa29f2d887e84b2cd90e82708099d26c020065460618231b6b002762101318020c6154a88220650aae813642ea0598d28d410418449b135c321353a60a5e529cc73d639e9a42d3bc3f0cacf4b7b764398bb7be291a452ca86f204310a6a6db568b4c9df12aa840f980fa9048da22961e3db4a53ebc369b610c6186b8510c28cd65a82b07ea74bf7eb2157ac69a734f6a8a7771a654a9f4d082b841aaeb7f488187494db89510c3a3a12231e5589c10e9c32d4ca964a14231e9dec91ccc596b5167f47e8e930ebd262eded6157e4845b495aadc3c0e9dd5bdd3bddfe74b256d5a24552743b9db6abeec7ad4edf4eaadbedf6ba52e75028570a0f3992ed37fc1dc991db56aa956d657bc2495a79d5b276b3276b397bb2f69e77ef301175d90531ad5e254e8bea36a53aac3dfad445fd645d4e27a96ab5be242d7b249fbe42a14ef4747a94cac4fae9aeceba4356ad2399a6ae32e1242d4a8f504a69abd59242c3913c7f4f4669e960043a20410ebe324116ade4562283f84bc2e5c943f6194f5e6997b48361e2af475e6d6e938bf2ae3e6f5744c5624d6b97b4ecbcfac7d2e4ed3798b5c7169c211e8b1aebdca7655d6a3bcad5e567afaaf638777ade263a224a86441e18ca5ff421f2405046d939ef1019a1c6d98b8a1135c48b11e3af872c53af29db4b7872fd112526539b5a08cc8d75e0c94b622e9d967209efe4d4c07ef028d325ddf23e7d9276a1e5f44794f0b0b9b0d8b05fcd137a347449cb9123fb459fe8d2e28297b476a54a9c167c8408fb4558e4431bdb108158ad830748d954aaa1d6fa392b2cbd5edbd0b0255c85fd603089e3daaee5489caae10a68e7b473d8b51d265fa68a2319b0c6749369337da7ab15ebe1b767fae5c242261cd668d8e9d4116ce9dbe72b761160bedeb56123f334ccbb4c97788a02c0189379790ee7c897e93058637a16b604435ac24876d305c2f4cd74984dcf3293e9f14a1384d2643242c34ddba0098394601f83ba54a511cf8305b5621739d6b05f0705b9b8b05f0cb22252d12e98b029c3a69214b2aec0d22089bf28f412d4d2500029cd32186986a70eb209547b2624871cd8c6a15a39270b8311c2881f10a3917cc9d2e3c53da55f42edc94fb902cba47fe44b66b87ddab30200f892bf425a6e47ca1848338c0e2437f87a81a82fc5580f733d84b53edeac529afd19968f6cd8cf47218993235ff252ca8db2b0618d5a48ee0c657767a8a83d9823cb1af68b463627e7cb89460be897bcec97b4f25808b6d7b0972b38326219adc07eb625676715daa8264cc861613f2e77e9f51c9c0a308a9beab36f56577d536587dc94df917d6b3abdda7b755557a6306c0f6733645f222f12ed11ef40b3499b37562b1c93a53a0baa57f2f3f26ed9252b6a3ad4bcc34b86404fd62e85c0ace1782a6fbab2934175d3a5c49bfdbc29752d85e54d513b2755df698be52546a2ba09236149bc446615ebf5dd11c95818ce4b16d4ea73b58a744523356997a7ab29f134e16fd219e349c618a3f693fcbc277b59f1d7d3b7f6a68baacd5a5d1586556ada94f3b0a39485e55feaf5a6b7ee57b36bda670c167f3d64fb1bf47e4a3255f19055acc3c669b1f0973afdeaadab24abf08704667b61961d0c31b3e01d2646328964d7aeb14e57afa7f67e3c6493bce9daab6eaa3e753b6b37c99bba260cafd99fbe25d2528c7a4569d9e3915ccfdd8f875c67d681874c7db2e9d9e9ac37ddd2dd81568c645ec21bbd7a02deb8c2de6897da391b141081c01ca3ea281c2916d1135572e9b36bd7ab7a765195e5d46ae138b1a42a4b6618c95ccd194a574d24594eaedf2267fa2667e3c0588643eb829c2e0fbb19703cdedc48bd85e5b55e53ffc63c0ed527fe9278a8cf241eea15856754c9d093f56c62d7eaf328d5b3ba425d7595eaa2eab74e6567611b346c868ba48ec2486ebc9378291c6f1029ddc02d38585866df49eb1b3559e6e3a90b72fa9ca8393f3360513f1d09d667f774d6955d90d33728a5f4b2d56a7559575d5befa26ae16869c1d1ab54b7565917ee7476d865a5a350cf6cc8cdc27acbadc471b93cb1d81676d9e17ea96f6f8c2423523a0a6543669d85bf245e5f55cd70afaeaa73bd5f0a73a89f90d4a3bad6faac7ad945827ae7c6daed4e579851f7f452a705d990b598a9e6d26737a41a3520a7744bae971cf339ee4b75f984e4093d221460828a10a0e4d96f400e8e6ef96122216501e3d1e4c05e2cab8f40caf4ce6d6b1df6e7e4e453a491461a69a43021763ba158261c2d2d2d1c374c2cac154a754ae570ddd01423aba5595690f59de6b8b3dc387545b673f61c8d34d24823a5f6f4598e7e3b6d1cc77d5ea69c7d8a3e753f2179bbbd9f907cb2dc763f7a14b641c352ccb19c4b92f3519c2427af72b8961ba7e75a386e64f6593764ce701a2267e04ef614638ca79310976ef58d863de72454876c9556d1234eddbea45870b4b80ea5cb057fb505e3b8815930cbf330ea2f3939a7d3e92424c7c60606a3a1f13c1898974c5329fcb5562f2f17b645a55eae4afd2585ba769b3a9d8464d555f84b92934f9fa7f77e51084d5d6b734e54488ea739a79c534ea6393d14010911410e0c511221c892e505dd7769d71064e8eeb6e96e9a39a5940d9bedcdf92d838778d2b477f9c93cbbbba59415ce43082184b0b1b0f15edf05c3cc9d638edddd52ca150864a073ce49e3e1acad496e42fc13b249a79c3383c910692279341952da40e69473ce09e19c734ee9cd39672c452a71b43e73ce6932ad86a8539bb46693d60c0b4d8cacd6ac0d3a6bd6c69c342b514a33adce4cab6d64339b5ae50e4b39d59229a514cf9969b50d9ad579941dd92c7bbc966571ceda4696c11e95873933b9711c47b336b6d66446a306bd5a67d775259ab55192198d1995117758946a7d9c8f5aa4996cc3e462b29964367358b0df4c6c3dda68464a6fd9c41efdee121482d58ce4c4d2cc5a3768d846ce49b312a534d36a96d1c09bec309842f7ade3b49c1cac65da2cc5eea62cd8a314a7a6695d106d562a618fd852cbb21964ce88c879ad0b5232c98de3b8ada78cad96a6698f734ec945d3a4997c74c969c51efdd3a90b92fd3425ee6460e3b78823ac291d962e21ac29cd5caa9ac45940df007bf47510d0b2a1c8b4997c5c6c6cd94b86bff0a646afff132b371b6736246a398116db0c7e3a289c0c32ece0940c5b9e6d6db0f863b9521619ce3bb3ec5ad66d935ca9656545412c323c4b140875e0155d90599a32058532540520c3774d562e4c6929b2df64e9b490210bbc01c4494b0cfb554d27c7aaed08800c9fc30cfbd5b354605d707060c07593e1cb0a554c3fc86153e558c0bef999f4c7cca6f853653287f98e0bbb212fece1af872cf3ff5b22730a7fcc85d94b017f3d5906c73ce6dec3dc2f49fe51b81f0ff99f401267c624fe4e6f18dfcb7b7859f2c539173604fb4da01374c49e03c809bdaec7ae4b629a14a357fad52f2161a7933b86cdfe4da01a76dec265574300ee32e2c2f333e6891828238a50cc85f7c476e4cb85b9850b63aedb933f28d4ba9f975db838e251cb40c3e2a359dd8fa5fab4271348ca513cfab8fcc5a389c50368fe68527f60ca03a894dffa7ad2480b6d5c402816007c172e8cb57061acb5b0df4b3e19a2d003d703a45f58e2b90f757ae4fcfd55582925cc95dc3832347d03899c90c102bcf92a111368e43e0b5e041998729321511257f2869af09008102726c199675c02c4c185fd9a8ceda6331d8d3c3d2aed75dffee263589c21911256e4cdf428c4952ec5e50a4bcf4deed18af6e6e9277b6dd0b0d9b9974ea58e08fd40760de17014eac9aaabcd60061f108aad2e8cd13c69c8d917d608eaf4c82854de2e045ff35ba954aa37a7944da1de57ec65b5e74a61183aa7acf4913f4aacf0a489932c63f3a97b031068dc1b7ca4dc1b7cac189aae2954faa6bbe89b2c0bdbbdd59948891f64d8d1c0e43a3460fbaa734176dee83edf4e248eca9a7092770343c982f1178b2e5ff47da13cb5d0679b08590e91e74e9f2ebbec27eec6a1f66646e9bbcacc0a2091124ff2cc3f4646454748502091123e793e5e699c199b2c325857a816167633c8dc425c5724fa904df1ca7663924b8cafbf7081f5fa2f096c521c457fd13730cf2efa665af1a34a1256a41c8a55da9b309b88058c859cf626dea13312fbeef371a86fece72395be41f53773f7ee1bdc9a333d93c25dee54a8bd69cf5dfb93b53826a16ebcd2836c833a3023319dfbec21cfdce1ac339dbe9ba1c3a58b8496cec52f2ea1444edd3324f45c9472b3675be4b8c89db647a510d93e01a3bc3d0bb97604b0c66422c385c0a13cdfa44a864419a0424786444d8272ed23230b54f90132f1404a224a1bcdd9423e453f5434d013560bf58d8b0623edcd33c9f3f0eb22f2bc227f2ff98b4938cc17cd204b398b57fac5a47f7a3b71d95dd4549a79bead50c9f33d7718f9f8f8f8008990b022e94a9e9ffcc9f3891a59e44f2a416f2a6531a96fbe5894e75d70664279beae31b90d76a54b848abec97a32ddaced8264575dd9d1771d91e893296e9f7825265161a54fdf449f3c332b4d46dfc8f94eea9b2c0679beaf40ae0b925123f8ea8250a23272868d1660cac1a8e298c48124141fa9c2da2e86ce3ac4256425b0665e754b5ff0f0d0de844935f47970a804c10ba1580f2a2d84388a4d91447b16a970451f1f2aa21441e30fa7ba5b1a484231d8d1eff4eac258a4a26f287629311b294f3aa393f6e6a3933cfb531e8711c2f089b5d1eb0914d4c9269d51e66b03e3d1c06ce8945067c6676159edc5576d6641676c1b9d53ceee081f4307598cd0dded75c37477b794db0fdb766d64f2e7f23e578d5b6c9b9492b694b3bb2184d0e64e09d31ebc9452ce9b29e74d7777378b1933c6d8ddd9c60454d671db35a5a8a9b4954cdbc695b614544d2ab1a026163060177a3108c8b22cbb1a8dc0d4b030418ffef480d2cd4c3b64f938e98dd09b593725b69c34d36ac984ca3a6ecbc1d40d39caa6a8a9b4954cdbc699784add90996ab5d412947153c1958eb449b5504a0f4367162fa66cd8700ef98a93cd9291c5524bd544e965e9565abb212518fb5431a52c5a76ba32bdeede012b7f704a6b0651b4a1812a489841132bb17eeddb1f7253a2223090e5a7a4d99338ad28899092270df294b80cfbb5e2df3712a7c2e25b0bdb928d484404144ae1b4b48b4c7f8fa8064e64d99c19064174812c88886022cf4b0ba02053fa6eb528a5525079decce844885ad9204c865289f8eef21b0a36b0dde3eb86c21636c3b300e35ea49cf234f9949d7e3a9d8ef4cd119a4ef58f85b3faaabbb0bdee50da0c7f47724881adffea4dff2250ed2b9111488c3f59266529e31131b4296fb0a87d72761c72b0a1872f720f4639fb7a28ca59b7d3ed451fedddd50195d39d7d3be12fbba6e57acd27d767328ad4eb5d40e3a4b425fd2acd9c83c499b1aaa484848d4eee18361e0730723f8d1f2107e1d45bd256354dabb5d67af85a6bad75d62adf46d0d7d80a81e54037c9357badf3d5f45a7acd6a56b39a55ad6ab5e5663a91984b47b0116eb29eca6aba34d55a6bbdec82546bbaa9be845bedd563262c4ccdc0d0b22c05b046fb27a59c00f6d00e1b6a34b0466b6523ed69dfe917d92f067511500766ed3d05d499d71ead0415c52fa25133c9da95aca19135326ab536d33ad6ab430c30974e24e61aa98841b046bbe90856e62f0611a9efbeae7e4fee21f55ddf93af4bf3b2a6bd6a1046c3483a886eb141984f46d3112c15ed49813a11eab4f27c4ba9711e28fe54b15f0775901179be89140ee4393b0479ce22604d0e1bd8f8af6310ac99e768e267add606750e1227fecc39e747137fe6eb5733fc593a23eea22b869d8f41918ac681735a213527991af66bb5e47560fb72f6105bced6b8cb69ca696fe65285cdcc46515f7e1ac9043ca49f33c2181ff19c734a29613361d30eafd596f059649b854b1a47083d7d292332893fdae96dc0a16ff2b6c939bb66edb65cd23b3932c86e4913994c91357cdf896ac27e1d254e429327a641c80de050922349bcf6280d0f4f90c6dfe4c951f69671a5ef745f54910cc7d64aaf9f37498b7cf759fa2cdadd8dbf1b3fd21569ccca6296eab3342e229f1599d73eb34f9361f5794de2c8c5db1fcf0ca8f75177a1f010ab952c863cb95fe5b56f99bc0adba061255ed2a60c23493deb159e384bb57cd62d9bd5b1e3e4ba23ab2fb9ee2c4efcc943daada4edbb7fa4af927e92f6e83b3db26b181b84b19fcc9f39334a5bbe4f46c8cb1b833cfdb431c3fe30899bd5b2b5c4818e4a803929aab0cedbb9ca93ce3927b637d0c70b0ff207f3923f1a14963841a66f7d8c4c899cb8608923583c60bf7a030d00654a89342094e9bb05b1408a52831f2b404145d91414f06056cbe5d01c019b1865589eb9c670c6457c10d30ea14f64d84e296c1499cfcf1623955fcd0da5644d395bc258fb2666b03dd93489ad5619bbb9da77e609a314aadf44ba34e37433510961686c5e28945f6cf4924a29a59cb2b1946163d19523c8404198ad8b36f1944a7db04e75ab92f1b46948d8fa79170cac2aa652e7696197a7700bf3a45218d2ae95da5c6e4fac757b622e41628ed7aab575f26a0efc822d8cb52e8c9d7e52dd0f16a9345cbd7e49a011068a98f205ebdc65bdf6cde95bbc2c1dfe7aa06caad4bd9cfa25cedf72ed0ac75d375c5c386e6017015a7f790d2ecf812bd07297bfe00a4c61a4e52eaf80ebade85dbe4e77b956be4e6fb956be526fddd6679363927853a943a39cc22cf5f67eb08b7c8268a4bed35beaaa3ebb20aa14fe6656d9afaeebf4d5a395eb3adde52f6f5dd7e9ade7b8ebba4e775dc75baeeb8461e051866df9098f462f9f393e1fab481c1d9fad4f97d5a7eab3e5fafc093a72bcdc54aae59eee725bf7e3c9dde95d27bb225a0ad7f6ba4fd995ce42dde20f1a65fb6d83028bf2e9f5d6bbbc27d6faea56e2b854980626aeb7bc75971b69a9cee3c2aeee3d312117ccd3825ddd7c4f2c5691afd9c29607106c8ebffc84f3205ff3e799c288cb5d7739cf144674bc75285f2d98670a232d3f01f3b4dc8579a630e27a0be639825d304f118f10f99ad7818f84fec12328a70bb6f2650f632d2acde578e9c9b09c041659d4d5eae95b6cb53cde8a0c893cf0247f3143220f00e59e58cbbcebb6bcf59e584fcce5f6c4b6e65cb727d6727b622e37c65a2db885e3c9f4ee96be23bfea1a1291588dc3044c78518426a18c13e209e50d7cae0fd7cac9adcbe43241800f251f175a38fc76f9eac462219cbc850b633344171197eb30bb9eb9767cde35249b3962279c4a29a594524a4c23941c3972e4b8cc711d394eaf0e281ddf6989c216f69b4a344eec32c05c73d8ed38cd611784c7bb570c8cca9c1e7917c9eb3043188cb91f4da6df646ee797fb45a21f2b59c7656afa08befab5f6511fa150a878b4d91c7641fe83dbd1d65a9965be513222520c71f3ae87e311ac690e8af63428da13584393b2271914f40ad499aad3a45bbb6dcf41c57eda2aa35264bd7bf8f3be09e4e32426665d0c32cb7ca35b0e1bd8d3e351f7f2ed41b01f4d0282afbecd5b2d2929a4d0accbdc06aa3505e1514ac66ea35c03f50d8c3906b79356a2bd0934a5f44d6645df08411deffd7905d489691c9f4050a7f51f38fe1d078e7f15c7eb61c4a142f2d527cfe5e3f92ddc85ebf2811f50c3ce33761969c1c7835c88cb078e22860be02f3cbf2796b1eb0139a74236f807feeab1900bc3bdab09c19a7eccd5ae006279e1c2f018ee0b177235ef76197605e8580c587bf2c2d5a0c070352903fbd52a4faa6d5581817d92dbc763de9f494420548dd803ea7c22017500a09d51b54308849e71d8d5b07397911682e0d9c27b62d06524ff85bf8079048067c62ecf054304c0231b30108a452658098af5c4a6d88f266dde8579fb71e58f1f3e6e43711bca1be7eb5a46284ffda4f336b95f16eee30279ccd5b97763a645126702c9d71911084da26a4420da13ed45b4e88cdcdf00c0c2ed27b0a60fe43614edf575f2044aea6b4f2290ee40ecd11a4d6a0ec09a06c085f9476fa081daeb9e026b1abbbce7bb30f3a556f40afd88a9942dec179de0098499b03782e0a4f0afa270085bf986cbbf13f28df714a813f3be975957e15f0bb30efb887cf559ef22fac6c7bdb7cdfb50e7c76ffed9dc7d857f35775d8f7f9d4f873918763504e02e1862f69ecfb34d198a65ecc289793e0f2c0c1c14c5f25d784fcce64ed81eec5bbe3cf18735520014eba19e119be2df7e7d7c8b3f5a602294f3a54b10e113f37161daa38771fda211c80d5e017f35f7c03117079c041c913834fda277a187c1f4f42908d15f8c8f54c05fabf56da3dc0b7f31bfa4e7c93cc7635744c765300c33af8bc47bcc3bb286e63cbcdb93775c9867ee47e3c275d510801674f02314e371e13db06640149b42e29c980b329f919efcc743963bbc1999dfefb4f43c997fe6c2bce3fe97b95f4fbebfdf2287a5bc0f791e314efa464a1e972a7c02f9b8845d7eda5ce2efc72790c4d389777aefe27bcf3b4cde07cde58ecbd3ae08bd5764e63318c21a19f997779a5f7632d47ce6927aafe3d79534a7f7bcd72576edb8bccce975edf8cce90e3c44e6339f91c1de77a4773f99a3e0d57ca729cdf13d8ca4e6331809ecde775ae62e91d9bbbc5f0d7ec1fe7747e4de7bec86c03054012f91d9c7e93dfcd97c3ff01299799cfae0c1437a7f7d7b5def255f3352e6de5f3ce469cca5f45e9799c11f95afe9c48977893f27f2530999c71c097aa737862686493e8f6fb18361067f3d7966077ee11d352c9acfdc14bcef348ffbd5fc7afdf5172eec155ecf778a9ac3ae480d7efd15f37b1849cc656264be2369ee4e7ba7a7f9eb13eaecf8ebf599d35cd8deccebf51e3dfef1f83ff31d77c29a99d7ef7d7b5d24b07b19995318fe7ac8b0abf099fbd93c739afb29c934df71d83731f7b1037f4bf28ebf5e7321ac79e18f27bf7ce04f490c0ff975d8373f6e73087562eec3067f3ce41daff98f0bdbabc19f92fcf2813f9ebc037f3c4ef39ac75c086b6af0b724bff0c7e333df9134f757a1e630c37ae01d62e621e36124f432f732f432ff8efbc55c739afbf19067bccf5c9ad7dc1d34f7df71fb93b907bb22afcfdcbb1f0fd9fbeb4258e37de6e55d99ef38cc01a13ba8846d979435eb149140000000000315000020100a064462a140249808bbae7614000e7a9c466a509c0bc44112c328ca20640c308410020800c6001821a21901b02068fa44c7b603af965f4e0776b3e92439e6ee0df3f9043d0ba2916888a315e6157695466e2f4a16c7177c6a1cc7c508d3950d20e02481be892c2660f0d4ef419fdcc044cbfececdc2511a38f95a2efe2825a2e2ed5e42266650b9a123184c883a5985dc84eabce2305f065d9498a27bbbecd7322f50b349a2c92f2e591998dae67ebbb9fb5a98498346369818f17daa06af4ea3b9e2e3ee3d1b2f9240adec3664146f8bd6d5695ba63485d14ca530f552cb4c6fd15505d5be01c3bc03cfcb9d94e9788e729dc460dc8fa174560f28a237f4f44b96f716055e376589a1544f00059fc8abca1c349aba8ee5ec02610197c6f217aa1735a350b00aaec080e719a366ddabdaa7ae547d03a1419b5dbbe2c0c01dbe09070e1549ecf5f3cb5f819cfee76ae6d199e2757e38286671c5e0f6022810b3f32a86e6c3fc6a4e144ec95162ec4bb6bf2f85ef10518b454c17488d565d4221ff5f65c52cacfc016970e7b3140ee3e25f4865c7613e5397cdeb5c4db0ada37f9bc309934cb518f52ed3ff0146e557ae35776bd7e3deb7018a63c34eb7b4c1ac7d263d249e85fd60c762948d33bbcb8ce8946607312a51685b29f83b344c73b300da18ef91478956b4fd6377205d8c0a72dfca52cdc7fe47a5e80415542a9c802c4f94d679a9716dc78ae3f102c1653b2adea0e183061f3752ed685a1d88e2bc25dcdd565f0f2a1b81964c5adaeb4266dbe492c2269614ed8c80b0fae7642654bd006fefae302f749c2c96a2d873b9cc1786fc2e482c6326fd0c2e36e18618dda6b4aca0597a408a3f78815d2e9a00590a481de70484cb6f8d6ba4d0023d6b0c22a14d5876ee92f73c7b703c28d6ba62c4a9beeee1ec4a3e06d529de1c31e19c342dd879ccda2ff965a389b5c5ca79d834cb5fff56df25967095f1ff54a70d53b8983f5dd55de7cadaa146e8916d286eb4833f1d1a123bf24e39e5db4936262573fc28fad5369a46bc26dec02a0621ee02b1e13f7fa5896ecf3609c4c8ca5fa93695324f7e2d138916cf3f7d57d070ff0a99d71ada9e80ac8b9cb366cc399dbf0b8ceab1f55c7befb385a686eec46363e992967f1ea8416963410bf4f09ca5601112f1a0fa208e779d3f869a4493b048be70835bd1f6d6480cdbf0f75a27dfd58dc3f32ada23a9bd1c5b1ef15fa442cf400bedf203dd468bcb41c911a33837d941f71a418a2a96d3daa7e235fd29e71ed169f77381e86b1b2a5cd05fdc0896966360e1c621ea85e291ed2810410e98916b25f054327e2d7a5ed50d5fe8f5f3b5a93e52d6a6ae004b79c272918756ecef181daeb60355d748f975a7bad227bcb252f700e5cfaf9ecdb6d44b17144c155e2ef25f6eefd6fa166ab5fbec9900b17b4a9ac4313f0ef70c1dbe26a7469db161806c76f41e4f67550a101151da22ceac33fdfacc80fa9db3da808ad6479a05af102851e1e1b840c572ebee8f06eae4a6fc0eb4ac65f7c93144d98fec669b216d1b140b1f974ab36eac82fd0e1247b03bf2492b7237e6b7412b64f566d79c3ea4ddcd0e41013ee3a51d10af92f9a2771245d1d39a4c4a1b8858dbd38402f77427f1fdaeec5575d6dd6c5fca8f9a092f760863dd6e2b4af47e5f8e6050396de8972cd01d24d2bf9aaf82f4b1f9b9df5f217a21f4a22244b7f4f0745a3d5250e36ba70c5a592832e39960c15793debebce9dbd577826d60755aad603239865e8e4cf58851cc09ba5c8e6a2581ae77dfc27739f94d0cefd8e5c96bc4e10c3b253c4881138c0f4baf9f441e5c16a46130a90125618ecbb923494a6c27ad25e0d7c683706c3b9fb186370fb4c813e580ab3da85243d3b67d57b34da8f1b473b214806209dd225ecb78840b1c15cc7bffc78cdaaa108af8ed90e48e9fd1c7e6184bd1d328bc8153ca03bdbf3c2de2c50b60b5d06ec36080295bdf9c1c01fba71ffc84c06f67102f109780e0aa37f88b7c4e105db150b328c4fb0daaad6fad8368cc0b38a96dec46ec059bafcf0c56faf5d683a41226754a5ea094c6e05dd889b59bbd0a39aa8f870af1af6c19575a83f98d013097e00f1dd8c1745a6588e4b5c8fe8cda2b5d1e092a7923c62308bb7b14e8c8de31908216d89caf7a5524a030100143944549212aef0b9a0dfbbd7503f78003bde88f82d2ab8b55c555989d7efbf6b3ffbeeb98e8cb23644c0b5b9bcd2baddf06f1798d07b484cc6a6ea7f38099f162393b6867c91dc844cf7ab68e200dda96fa22b835aee20a135a349fc91522e4939b0a2248fff9b982f7720d0c4a1ba5a004eafa3c4f48776cb6027ad64715d879259c02660d2cc768cc4157d78e33a7c460b270cc8e5f372459b094dd6f9e36dd99101d1a3ad0370806813ea517d860dbd89995a2ef3aabafcaebcb0b56e293ced9d4aeddeec9d84856c52779acc58e39ee0d223debf7141e440ea059713e20bccb8e292bc0f0b51252ec61ca8663581f1280f81c245ec1cc7977418b4216fc57e90596fd21f8ea9c76d72921bf110a570a7d5aeeca8678de1425c72a6fefc3c7d526a557aec32801de6effab5d326c49950e16a56915182b2bb77ae37a2995ba27d7a5e7dc4cebf07804ca590e512e6f0497cbc8bddf992f8351c5013befde93cf3ce1ec75530b77946a453ba6882e26f13fd280c6d2c2a9b941e8ece17a4150f12d0a7861796e4461283eb77ceccfff0c3e4119dedc9785e19bb5b232c3f750967d825c20509f3090bd2b8d5592d298de1bcaba35a86998f366f484e85c9f790aa64e1161b65e314c551255ee1cc975f91cce014173bf4f6393e67b681cfee8571c3c82fbe7287665489203ede7879c856ac0ff738e169c68c47ae597811fc1a97fdc31c8ecbe470604d8c944003875809ad1f07001d117d4bf41857a92e9257b229b5f0e3318f1ec45b2ac903f3a4572d2136d37d2e0ba93bed7949f719b95d5fc55e45163092bd1fb729e78a9157299862fccb460d12b24c9edd78512a725aaafaeac63dec0cb282bd0e7fac500d7a9d9357058482800c6f5de20d0034bcb860b7e178165ecd39d90e1765bb39e3f82694a29ea30589469ee19a8a3af6d06a1edcdb574b8238b7d1b60a1ee3b0b02a37db4bd5f068d36cb2bc070cba265c377010af6c8669addee3d1d16a836e666a2a1e439307d036be7ed505033db9dbb60918a99360b296529bf9fff472ff87dd20283145cb3452e47d540833cb244291429029c3e71855ee3cbce409e16553e1baed26a875957b7270910a90ec1e021015e6b8836af1e01bcf6db986d23800d2c0b5edd2f9467b2e5fee8fbfc4393f15b763e8d2d9b0d1c5d9d9223cbdf06ca6dfaba08dfae1b9bda5d35eef451dd920383a6190570c17d03d64a1362ade067b8e975165d3825983264cca8a17eaba7dddc8a3b0b63bf1cd0cfd4e28f2b275a0ca6650d1f999e4bd822715c4148cbec4da862377a0679ecc77bb38b5ca3082c4446d5af019ad54a74526c3de0b0d1d637f3ea900bd0f1e776e66b57f97a80a3eff39d57c45393bd6a2ced250544e518cf086299b6b5f296d4130c9d9e80b9ec55a27cbc8680cf4eb0b55512489908ad637368b41bcf4ca700ee22c84696a5b73ab419913e9b3b64d6ec5603fa793f7fb4d24cbc5ada6f707b029f8e87f8f574cd1590b0880296d27446cbd45a38f532e4abb51621b40aefe864adc4ca0be1ec84581f2b0aaaa036e86ca1876bba5a30556e50981cc483375721f0149ca674291607e98ef668094e200ac068fa3bad6e6d046d1ea357ff37f743fbd16408c3e68d238162ad19d0b4273742a2c842520815cc3954bb9b2e0eee5ec8ff8a2eb86463dff758d25182754e764cbac00124b950667135b4e9a5f1b66eccf693dc8e3cc8ba6709a8ff8c5668af6bd15ad455dfb8b1cdcd295c4ca9937db9b1215cc07faf0660a4d0e9ab56fc481a6482e17492508167ca0041b812cd62b4eb015061120f2f775a1fca969af74d37da81a5bae7b8a318a6260329924495bc617cab2942392823ef4bfecb5de493a6162049225133400d3c10c815a0824a8b937de7fe7e836878d9a13bc5cce7a15dd2228e04148aae1b38382cfd7fe21a922fbf24e79515d01fedc6d677c81caf82c76976e8a55cdc40054dec6a240019cb5180393b207e357076f05cde25057d3fffb7181a273dc280cbc4260b7cc1356b76e249b759197ef93f1e3638f7488af8b46adf11bcc19887e8fddf322673de1c7bec2eedf12f31b9ad0a3003836452c572b3202562c8e82cde5071ce422396c10ebb4a6168742ac850a430f8affab0182c4130484d95e7d199a629c8c8cd73062c2661c4d143bd218c32e2cfe99f07923d6adced813c0afb41d836ef6d6e6acc09d375a63a1607f0340feaee97def24ed69acacfecde6dedae6eaed93b15677143ae87da89da0792582d9437a7c23be25ffdcaab5985ae65e26fdc262683c3c0fb892519ac27549a32d5271919e4676313224ac2755b6132e280956ccf6c6d6a6ebf2072cde802a3b5b0008372c4b6edd349408e74106f5b222d6136f5d6add4cab9350698107c1e026f8ffba6c4e75f070fa84cdc2ddb1bfcefe156932bddcda48abb79370f3b92079d35c9c4fa50d24a344705b227ff5a50d2e83c26088526e5f36745e30d1200a407a0147b889d7f05cf5825fcfb53c4c60e3388327a471fe42f91dc4441349dbe205e76e9c993feffc43864c591212b019558eac49692fb46949e6242d63bc8cd57b5e14d0170c27c569abd1cf025bf65a62b86f5a6340b4f03e265fe14ea937e51715f4314ab830239220c504c15615a643da015781eee3cea4a943c7f57b05a409245b93a1985ba856c0b50ec4779fb3e55425d4fa3defd0c5bddac73977a50543c5913b672ee039fc54e3dea3524caf3b7373dd9a4aabb657a603293b800b6e87d7b38dfabb00eeff5f6b28af5907621c89e5d82b6401403aef75a7de21a7538cd39dbb3c69b81cd452e8bb1e510025d04e7358296edad4e258137a2146c36a58731a9a9bfffaa915b4cf3cd06329012428317524330812978d47acfdc3359eb2400a5898668ce2807413fc3ee2570359c260d4c487debdd38bf9f07174f7206f49e23dbf6fd5a8490f8bb90ebb97af23ba7373ca85e8fe1ef1c3ea5b5df1b44952b850b67d9f68b83fbfc760b40357cd3eec28f634b25ab5c358176170cbb1c00bf74d4bd3f7f3e1ddee2417c77bcb0267d55db500e398c3cf6a05407ef0d03c9b04243cae235c4d319a76cb26e007aa40bf2122abe7e70c1a1d3c308a2c523a7fb4d1a351664e9106cc2674255f7df56e8256ce2dfb03e8079dd127b5c9c36502a9562f163dc76840d594785978433128b9b3eb835c2992650d156763670139fcc2768e9c2cc7056c7cdc09d8928f7b26ce7904024cd3a34c558df59368c563f7c917235182931c448d523f278dda44f0a3712a8a5ddb87809d2d72478bf5d1b466ae39f83c648959e191173d04e6f42705d6a281a6bfaba156598f58034359d6746261e1439e3865130eb07452cf218b39cc5334857ceb5bbd33c2e35e7090149de3bfa9c5340b9b646e817ed0c5bcd0f36a3cf1650b2490ffe9ac2ff05cacd54208e80ad08e9dec17358093dc7eed1192173e62b593286525b865a646b09266633336c06bcc7ca48504094d935cbb6290e1436ef075fa26db2902265f3d46b92937d2c7e1474cc8a4b5771279cc7a595153baf967ea9a8b50c84b2eb41e30e1dc1d4d99da4a5a8ad4c1caaebcd144ccb6b3846a04079b56e73e02e8b15d7d334d8f40a4aceade42e3333d32de4a2310b14f1a3b91cc6007b42f46b25a11f4839db46db88075cf5c01dae1af370580c601577ba06bdca77e43b2059a15269ab2c48f70d7d137361cdfaa5fa53c8e6292006722b63822fa0ca3b6be7dadf4b1d3600c70a77fbd24867202940b735c04813dbee21bb1b94d696eff9d7b9bf0168938580eabd7b2ad8911de8949511bd92071db1d0dd4c80f95b09e78f637f06d112a11ec9fae82a42150d667b55a4c03d8d61cca31ec1899993ae5a66bde19ed685e210fbdadfabde97ff5e01991a81661a227ba94641bf9da21095867aa1579a468f3fc187dc2c7023a7074548ac090f68cd1926d27aaad2ba709d2ecaf13d015787526ca3e474016e9aae3c5950c2d581805a1202cf5ff54e16a601d422065c4baba8ded193d825f3e9ed84230d7643e5b94505a732336ca7756ad47549f7cd06185dbf17312c0a285cc36d290c8e545dd9f63d9a7ee87b7f3d761b781cdb58abae61ddc99c5202d804353ba22c53cfb79066e2b4efa603fa5edce43bb5f4beafd3f0469f996ba161a78c893b2c28f5da804f84c0fd615941028714f3133c6692220fef1436ce0fce5d98a6aa38c16cc18a850f2680326aee68ba3f8d9d53b6cbd69167b98b7bd35e992d88e27813980f32218a3a66a0ecbcbc959db9661bb004c98596bfb91a61358d87a099b3aed0c4551a5cb42041149f101aa2e471818f793feef44f1174d7555b69179b7571af375ab28ac8f8f1a33e31c41335a8a18d8cfee8373c7845d5cdd3975e7350c6224ccebd87c3e70a81ddcc184c8ad6114159be29ce518285bdeb5808fde507751b31807335727d4fe4cd95cdfc384f6a4d002ec60278dd209405be92d4259a7e38229f3d50980c40e8e9141d44e2592c092d11d63f0360fc83232b6c074b7fafa265ea498d337ae6ff9349807e688668b5399d690292931c86fa51e33ca3202a9a77d68a9cb326945c967376a97c3d3938ddeb0952a492eb3b16652d2d473af01a4b0027858bcf837a424f989081634bbf7a11b2aac11f86eb03d31526ffac2b82dce9352e8b5ba1f26aa6d477b641a59ae62d7af011feb251191a627382a4c3e2ae2d8c05c1279439ec1793e4081db183ff46569500a9157f3970f642a37dc79bef4ad142533d43a0a24d75ebf7fca1d8ea65b1438dac006a74e6d7a8b238c64e000e846e63f7bd08eeb1f1d3e4ed812c710205c106fbf6a7e2d29d03ee7cbfbbbf11415fa5430fcddc99a95bb947153dfb373db0c0723c299d7cb3673fc7db6e4ce7a3d0076f7044b6c39667bf435dc5cc346d94bcbb05960045cb5ecd32d12a29dc4f984ab8c199ab97e51f77203b22bec7795071792321d3603af129574be29994e96186e7df2f5c57c9cf9d4cafa34e47054261e2bcc6069f094e5c1e1b1e2cde17e780ba90d113b305d8d9bb5913f7f3e489c0ba1d9868f3b816b835bf242ae9be4818099c2c8e6dc6b17e31235949ca12b9242b1a05323da125b2816710255280f0cfa6b768463bc4017b82305bb6815095324ccf5750c2d829552d0c38527c00874bbb6d6a6a4ddc8a65392d3bfb1eb6418be3c7ef0b464bb3d42bd982cefba7cbef003e4cb4c0e1ee01cdda7a0298854012a826b4c9b61cd1d4d0351a0415a8d810ac275c3e365563d8004ee64455b13e044e1c8951f8b3d8f37b0fd057da759ecfbac0a724e6abe63d01c662df91d42b8d1ca2bebc0b9b601fbc0194f49a7ad2fe5fe1a9136b0abc104bf2a2056b15ac89bfa2ad91e0ea53b116dadc4b4467d3b6bfbeca01e9172618f2654c615f4c61523f7e0a7ef9ac5b0430cec126d63c7af3ef0e0173d0c333437380175f68f096ede2f42b81672d3fe4156ee26a6c8dd4f241eae5b2f2a2f7cd8e544cde8813cf45fb96031970ce7632bd0820f2bc77deb00477a490eb47e2701d83456b2a08c4cf3158c455c8e217301ad11101fca9c80a1ae0da80ce68928b70d70a6caf878bdad5736d36a9793d0c8f605101aa4818caeb61806dc6ccae7bfef71affe90c02583e6873a1e1ea05319952a6561f8631750ba03c55f83698dce94ae5a8c7cadc299fac95d54e738e22b0e88ce40a330619c44a720c1ba2a844a07d6655dbe62e5f40fac450ec50d9f22404c3b624275373288065db41ee54921d27e4be57e1c0d8bb01471d7149a452a8d0d5a731ad11eaa1c37652203c88d2bb84f393f3f59898e48518f0ef98d9d6e260fcc29323efacd3cd5c17d137939c20b20040f1328dd98e33579f201d04339ff4017c95d243df3aef5e566f25224311cc6cb073d92f584e4ed94d0265b53a1e0208a6a4c996a3b8fea42134c42a6bbe74b4545c31142fc9ff13a08b0c0535486eb5928b4681b92482015c14ee9ff7d10791b55cb8725a024ae8c38d0f449205d38a198195d0fe63bd72f6f408b626126c93dc5353752e1a3c5c591e9efcd33efc937b4f128f48f9228457932695c3cd7f27004fab7508d0b2d3d539684e268f4f5906eb96337fb7aed9a89eb2c1537f7471053b9bc4a0bfcbe488d6f75fea79d30dd1793b00480d8e8c3da3e32acb1269a1c0f7930e89043dff22ce348f45a3d783b239c8e22967a544f998fc0b06275fdd92a0ea1a06e1f21bcdb68dd1f2f782f8db3df79af89214f2aaf20ac040f0f7cd3389357ed953df2767015479284956ff6900536feb77524a738ff418aea4c04cab2bd0d7ee14d356ebbc9ec07f2a7dd0a7e1ab7a65bc64d1bb2b0863835b08420669ea0407c0e3d37ce99d460e0030475e0ba4a470a07903d82981787ed991c565652e4c4ed6c156852f305a749e46c241e848fcde89608f68b823d08013dfb81342acf7ddba874dcc144c10d8257d24a3bcc8d2a936d7978bf89f6efc4db972e6321b9060a8a59c671348d3d9a2fb6b1a6a7da31c5a58bf38e01245e297108d0db23e060e19538eaeafdaaf8cee62f1acde682e041baad57d55b2f4f10773af3bc098c0772e45f4e15f8f4aa3a7714cc5c6b3ab22fb5bbaa1b16c11549421803cbd486009e5bc2734f3059c39479b6e7a9cee54d42fa56b67af70513dc55fd823c2b29111ac96247c4b531478a82d7102555114ad92185ac0b1cced4b084bcb20c5cb8f27bf85738d7d99ec2da8f5596cb5f5c5d250148adbc8634a17e68fef426b25f9797a85c2c6d9e175e96258af56656bff9e820110769060218a383f7f02a9cb56a5200b0b11893dac17a4d84dd2de42143ed0807201cc328d97c1645d4a0c6ea9ab7b8f7e9c09d3f13b00ea9c812a860af5fa1641b171e032aff3c8755b956a38a8f074a79a3d3571a1dcf10450f997c4c3a46c4485dfc52ab59b1216b5428e5322824b24012066cf2c857f044744156537ee79ed3fc9a2f94a8b18b1e160bab61e43df306368d30594f25867e4b220ea4640e11a64fad3fc3f94b537fd1dfc1ce268d1ebc5be5762a03de9a10058c137f913ace1121e1d11de1c1139693aff947e1fe9d734244b0459dfa2efc19e1fdae752d6c53c2fbb945cee06b882210c5db15c132d2f1f619bab4a734b56319aaaa1ff10bc0821d6634c969b0b29fa06432f2422d1dfd82edb74e482df624d0721a88b846d28d9296402eab19d0ad6f0a9ddedba7221dad00c84c33f1d16715f9842b007c8dd7231cf75310cabd2ce5d3dfda69daa7ffa79ca9f23c1a64eb1b66c070b6f1c7b9a909d4cb830c9582c6169dc100b188f1fbae69450c80a319533d4f2efa2e1803250bfbc6ffa61216af8dda157763ea727ef9b7a5173e8a884f39ed250ffb64153316130021725882b3752a37169df64b16c88ffa1b9cf1b784302eff90f006f02beb80e0bbd760fca8a2cd6a235d85d9dae54e384484f1220ae12851b8514e69d9e6bf1a475a8adca139b8fd7443aeec2dfab20ff7c1aee889e572817ded39fdc9229e66cddd4fa8cff1c7bdc5e58c43f37f9b6b7ccc79831451c53b3e7a17a810a42d1b8322da0bd8df1aa3e12ef8f305b1dbf8fc5a4c54c7b360b3de04785e97f1e9202b361949b3c8aefb3f1da0ed894a45e254bf20d0fe716ad321ef782fd02bdbebf3f25b27b1a66fcaae62683f6c8cb951222c03274dfa0736ed5a7e117b321e3fe16a034c40517aa4386d4e1898d8b725f298a99cc4eac79074bc99c1ec31a638c52eeb8ac6f48ccfb245831c612e81b733585c6c0cca2be6507d9f05e52e7087c64e004a065c845a7d724e786a5f7528abd56808b91b04f644d54aa09e1e5970ccbc44a36616af429b902b2c0e3e461a6cd492c69f0367446c9da40c3b09370b00f9c72048bae54d2b5300c5753c87389a2b65f81d636b5f9836751b7e34be400bc29df146bf35e8f78be6ef5219699d05886a315acd0c828cc63de998ca30c6fcdb285d05322c03e7d7f7a2a33ac2d7f53d2f063ab9a360511e721d47aec7e6ecd3ca3ffe28ed76bc7ddb89e0a64d3be9073b22654564acd9f9505e75c2728533a9671a127113cc9256b1557a26b7173d614d5144f6f66157bc2ec287672b10b1d3122f1f028a79bf6d4e74c7d426d2dca4e086de05401b0a9c8ad7f15202132b1761682ec6ab4a0264ad49e5c74146d40d4b92880173d9576243f578c641d63289eeeb22eb9e12eea32552d3ec026e0e7d89035155b8d5e47d7b607eb2fb2bfca7fea2c81ec52f1182cb1421d057a9079a420ea274a93c7b6fafdd1d7dcc886e4c8c3479515faf485a07082d5780992f524a3a674ff01523ac6010c453978eeb06417df9c72f486cfe88e826ff24ba2738c39d218b395ee884b772e14aef9bd615bee5cc1e9e8cfa7b4b627367733e755c44ed69e2321107fb97c68b39bbd40e54bced37b16655271c9a6d575e433156ab80f9e2be2d1d1f55ad959d87dd4bbb1c33140088f927382363dfa681710517d850a1171589da3b5df4b691404f733070420c7e9bce730cedbec68f032d352d868a815ed7ac43ee5b26e0189f62aa67989423d8c0bb8240398fef46469b9d016e3642f6a976ebacc63a2b6de541638d8ee5ee16777f78a7b62ceee5e71277752faf85a78c82f9b38a0274678964e9f056eb843e9bd5b06c50c8236c71f19ee0dccb07b2cd311affb8b83b2e4bd9a8ca6385a1494726986aaa51c2959e791f1720263a2e3e1fa9b26be238ebcd524fef1443a5874a3bf36369b7dca90f3969d70b869a6bd68374844880e5fb849704073d16c0877b35539f94e6cde74b351828d87eb4ad8dcda85cb84bdf3d8623fc6f8ec2a623c2df5025c666ef5c637f70b8ea471bad36d909d54676cfe99e56e500bd3c984463082ce1c58dc80aa7e577ec9ca3f9c73a0582f13ab5a86cef34fadd02fe0935667515a2a17bd6146f0fe878faf163c0172ff17f46eecc87192d23e961fb4b711da473a2166ffb21d49cb647a42bcb09d98cad42f628f4bddd12d09fc8731322b9f45c7700ca2897761e81f98d03823e4344bae104143574ca3ecef34f0d048f48ccf5889e0898df0527f9032b0a4d62c094f23fe38c78c9d0b9ff6a31c6a73cbb06f09e16d81b28e34703d869cd234532a4f90a91968560edf633de1ef7edfdc02157632debf0c71108713b30e143dac30d5ba72a55027b9721b7b04818d46dbacd8c6c9b2c53e3ab73f1fb2232118f5e5e35353bcf59647de5e41347aa9da68356a6df0ea20a50f236bbafc3eeb0421e2832e6de699a4287569517aab185b5dfa1502a5ddf6324e3428c90e97cc5c69f8ada10252c49671b277a116af7666f6c649570e6933f58211d8d7f50b91fbcdc36b0b84c89f42a7e47d68d612920c454053d4b48bea5f94481fe43476c61add25f8ea9ac634726360dba16e49f002fa64b70db2232dff0e020c940c441e659b9eaca5478fbe3345b2afc961b1418f01f84c61c24fff478abc556c8cf9182e7421ed7d5ba3e353770f60fe5d15c4839f671ed2c816194d64a588a24871a59e6a168a314b9d714db9310d6f99573a27c7a17be654ac317ecc9fd6ef11cf828a71c7b4e7f62d3398a759ea00f9dd82d94928da72cb5fab68da11c2d21e64d23f96d1834e0d0ce8f97aea3f24cd735903bbeae0cbc36d66e3ea96e7f028d066361c306aa914119015c316ab6617c0f932d881a518cc22c708cdb77157b96dea6e8935dd7243c271045fbee044ff88336d1059092067ea51342678ba9ad0c285de1165632fda90d50e1b7209c69d3c275404d3ba2177f6eb63e3fd5daa5fee0a7bc8ee9a1a54ba4d7eb2358a2048f8019c16bcd7578bbfa48488b59b8b87a188a0ced4358bcec8d86599d973899c02c7e16357dcee2d54f7aeeedef295685a3d2aa2bdd8dbb4eb3293755c3f02b6f76166dfa9d94157874a8c48243785c590303d3334a8841abb29f287841b2fa7cbc9ba280de3883246a91ddedd47c67b9d013424a055c0c24f28cfe6cdcaeccd56c5c744b812cc1ca50a6c27086ca610830def270da47468cbfb4c4d1f4260f208d36324787cdbf27a666009f760f4d36de1d9466dfec6052f80508e3fd17981a349b40e06ef05400250df235f6a9134a257937875bc11bd55f52dea1ccd927c51489ed4e8948ca5b86a8315e913a95b2492e725a029d69a13cb646b044006c93233672c9a586a803109b6d0d208cbf8def49d2897b03ed20428c4e2b803fa0cfa37d435d31aecb57737e76e4bb76679e4c7435d2302f77eac817650f735f069730d6cf2cc64c052ece401cd22eb4e24f2f122a6f0c16f56b95802d516a68a017cfe9d50d00fe396885d529006ccb32864d1a8b3041c149d3514a1800609f430caa7e3775e45f629b8a8b882a0a627b9a791ddd3376b499bc5edd20c2f73b3963876665434767afa375e1535699096bd9b63b31e43a846fccc5a99446c9259ae26cd2ab6d046f1b40f136ad4c9085c20323959c775c575ff12a1a7f3ea338f991e65822458955ac38f9bba68e34235e02db4c68dc73a70ccf4cff33636b02f34ac21025084bf42048332e1641a4c6b4b11caf4187808d510174c997261fdd06a5a8a0443051edcfa0428f94c32db3e7f89fb140aaaec66e2d2af45d4f7ef224d488cc488d17a16615d986c76682840f6b08bc44e66c60e8b0c75e4710ac75354783c554631a8a3e0607e090157e3a476069d920ce3440351e175b960f5d542362d11cc6f10be071d1b4ea4de1bc554402dd9c9af70e7265479ddee7aa94c8b97b7c424e666ce5235b519c478fb450819519c2f1f1054351eaf23edb19092dc5b96b674fe8ea22622481730f3d955183b5b66d663753c19d3182b72cb8344e63ddf0d4da719d3cbe513d6f13ca766982648ac48b669072157753abd61ff11ccaca0922c0fb28790db39378143cde2983d44479fb9c2fe50e87e83f11078ddd623f0694bd13708784bbfbfc46b46c17e0b5fe87c210bf3034dc3d1a9439ce9004019c138be7d6f8ec5bc010b4aa7cf01ecadcde2477964810d87c52c609a25bcc1001c0af10525f9654138dbdaf25b24a58a22219bcb2640f26cc4a507aa8024ab04de3a07f34032307e1b8d11224080724be7bf4cf855ae2a95e5a6701ad534149e920bff64a31043b415cbfa7470091a8105091065a4af8c7dcbe489b2de24858aaa9245d8b287309ef17f86b1e570cdcfb01c7ec82a2f61767d1c94e47c5f0bb2c7510063b63298a1e8457e5ac23ba3726d85015ae83ecbd60b1415e9c94dc46db990325e022cca6de063ea9215a053389d7b49b35276a49325269d0f94e96862821ca4c655977251fcd7fdf6ba895842c782c2c89addc2f89a5026bdbb9f48e23d942273621210fc2d5046a07c156120e6b04926d83b593e53469c61cb736e6259f95fc6576fc78722a05a1382c7be2df1fbc8bbf7f7237d0c775af540046d53ec7247c0de200c70150f7e7fd5127390442da085bf0367af3ee2f89142a561ea05d4775c4463d821d92ddcf3bdbe60cc776d97339e25dee77bbed116f4da22da6a26e30bdfaf36318b528263d71a2d07f1db31e18421c5d6a1f02c6ae4c4ee723489cee042e21ceae0c3b1da6acf9b2d3298ddb0335d2f75bd9593006f22131c6fcd30f57411c00f4fb95a6665edf27979c6e911387be4322767c88844b431f1120b5fcc595fcff81e5c92a3d1f8a1a64df3e82722c2530a8f817d481d231590ffacd4420607df6ca37fad9196846ea5b51d62f8a9637c40ad852b5eabc1aaabe12a23988161c0ff30bb25851089d8641f11efd7e8e7146030800a750badb7e4ae18910b9c796c1039d656c806fb38b0a3477da4940519c800c473b1dabf5a9957cf236f97eee1fdc002700779783379cb577c7cb3b030cb9e56dc00fb7e7c265317d7e96533ba78c01b4544c1e7171b9758e2a465950559ac6e902574571b553e8c0033933e7750bab6e785ad66290e0699cecd744f86cc1e3a28a2a3f6e6abb557cec7613cc49c33ff13a82b127e2865005563a44dce0a2a114d523f24f03f4b372ca2c40f5203f5858a9d3bc6e97b31600ec94898bd3bbc39d76dc8ee513aa7588ee3b152790822963a341285685c9c8cd095020c74ff3d1378ff9ec6e52d80947f723b438012d01590c2d897dfd5cb778ee793dc5ca7d7e6e44da4c0d9eb2f5a5d6f376081cff9ba45175677dab13255a6c0498c3320b53353ad4c9a4e18972ab2831e9ad7b4608657b1add140a8aafa3d4c923c04558e1e30e362219faa771a5592e01c68b0aa4149cd86873a8805a38f69008f1747e6ca3b6589d5ca524ae4ab40971520ad293c96e01ef592188f2ab977f674cd1917d30e911411ef7aeddd3732fe53c5bc49b72d90cbc09f3fd116e11438e061500c0abf121c5926f3b7f209d86f4dea6553c5692fa0b903074b9829b1ba0d1261ce7a7bd9fbcfe69521f1208d3d313130b21bb95cd5965dbbf549d39079973a237cc393218359cac66a14eb71c414d47587a4d8ee6930bdad911a3a2e72beba01293ae3781f4fa442d440edaf36a75999aa8373e565d65488e42e2f536031caf9e90a05aff63a621e4ae4e7c41aa42561db13cc50b353bc08d8b1625d33e46e6325b3da2058a3b98eee5e0566518a793842f2665cac31f32e523728a45c62cd19012c11b8877d84a0a6cdb0e74dafb450ae330a2317d174bfccfeae03fd09aa4e264f31df64d28dda21578ca331bf8738682faea06b7d45fc36bad03f6d4f0dbfd44d0697933e5577d1ba6e4537a7e6b7a89979c155b01bd8dce5867e287c4c988ea7d748e11df60c9c40e5bca48794f546268fa8ed0b068b197badd674c75db7d335694736869e557a6591859039cf1bcdb35a2f3239c29c3818457d8308a623260e56370861c5d1f91b7cffb07648ed4b3b5d51c3115e4771725986c33512f16735a5d6da85a040cacb2e84147c8af0e3c800fc722864991ad49259432d75e0d729a9587a681ef98d242b4db20bd95df1f3c079d4c98c05958f809cb3fe9d9e487c68edece4c489b6f2aa1887976fade781c44236e1d71de5cf59a64bc8f483384264f9ca1697dc5454c027811d29ae28618af915b62b2ac280d8ae5705d879103afbf99e0a86bf24f0ce7798d61d7efe5ec7a26cc95d0264e6f24300c491c89cbb52b144d873072fa34270c1aa25d3d7b4e2c4520587d9ed06126198fbe09fc6d32ff3f786ad29a4094c015270f10fb78cd4c4646cf851f903162e8608b69dad535a02040e933b1676c64d675c64f21e70428cbe12c06be37838bca025caf060850b217c46efc0f86c9a8478af759f71cd7ec9d5b51060d755c63e8e1761fc1feeff4ef3c93108d3666900ca89856d0c8170045850dda988b1122a50e50e5dd94cf39a98d28dc133457a230414d86c91824a4423498512fa1e9dbfb1dd1467eafcee2078e5189c4c2c131d3c7046eb1777f574ca7660a84a895625edcd856bf7adc61de7ee5806d28a399d54310f33a8acfd6ffcaa719fe13949f2b2af71f2df36043920a3abe327558193ae4022f196e26dd89ba84ca78d7b29e2487bed123cf01f32e9b392731cd0af8bc7735e481f670ee52c263362a687f60ec00dcf561020bc3fccb073de519e08e5c297242d6bf7f9ee3fa434ed0269f7ebab64e0a69c72e693e48204ff1f3e55ad59cacaa88f7cbd226fe11796217ea9eeceb06205cce67c2d12bb05ca7c6eb97d46c743d4a6bb44e4b891c5c32144610dff67612ead7ba95aa5e9f25d5b32b3c55197abb85bae026bf2a252ac28b79eecfe6096b08acf263def8fae9e39902b6412e5bcb3d5026d78d6c28a9823fea6f3b4c30f3b862c6c9ff50686b06c23d6f72f17a17d3735a0a602976856b086f53ca34353ae9e4bb0cc4e4a153e318ff55ca27c7219f7ac44db6f2906d88f3fdc382f4711c6f40dcf25a4e4dac4d6f6b1c809546c234352bd805bd5cb222e031824e07913aadccfb5737630d89c8c78d0ff87abdca010fa12ef0bfb431563d8f582bcb6c3a809af0d6f8a492e84056787288dc7f5f1c3e50b0ed1847cb7ae2ac003027e04d88047720076c46f32e11259137838f68bfc98c55637617a6f6b4aa570c0f182852f01be59242f525a1eb54f922e38695a99fef75a40c7f1140b6eb9665d30c3dff2a948882ac700c83669d8c2cfea21fda7fc2582829ebe923a810a8627b7cc7962eacb7048f2051344e2e656e357d4992d095e60ea0a52e7b4039e535bece44a7b42830b45468752db46c0ffc7250a71b8c26581bc3c89f9f4ede2b8843847a8e64e504352f117f026a5561340765a7901a71221d02bb3fd4c64a65c6200c408ae71e751b924bb92d5482375264e8ef531ae536cffc09c4d2fb3bdd1a2d727e8aa5c428ff47f69eeeb22b65820d1980ea8acf7b479e20747cb207c2a3b64ee49982346200461b8280b5bd1b0f9510214348582ad93b821f6dd69451c41356c323e9b75ea2b891071e1a858beb05e6e7658101b743013801297888ff787758c0adf91a5c3b4767ae292d5673c75a418c07ad272457b4f4740e103e9778bd15bd741511526fe62e28f6e0965b50a829bda3d69a6d4bdf318987a8fa66c76cd228d2e540dd5c4741a095d5b02a417fb22d7ca4292f544243fea08c42567772c28485b514a16c2077a4b9c81df7a8c57497e01cc5291fe29e05f2a640a03262920b5f2870432dde660c4d99f10a2f94b640c972c8c5cf27d4053062884958f496638de088513398203964fe12b51a08ead32600d9e02e4f50b177073b25152e53c876add683812f6ba6cc44c87807939f048baa221d200735c02acdd02c58579a01e5e3bef97306c4b79bc58eab3cb12b513791822ef92b84211318c1566f553f41fd7108b495d87a9eac0817ab9a34f3fd7f1bf94f14ee0a834d0c01340af85086367af9b47d4f0b0c8a784edf9dd8de2e697a7363d4d925402b43ad4ab08a619f6317e666d504fe06a2622f3fe449cb6cff387e49f59c641d7aae56cd5025246d896958951e4ff1ac80e83f35623d37ed0c517612be47d96f1005b21e4b680a6d6dd17492587add0c634f0e67488e10c5edb30abf2eb7015daa3fbccb94d8d81973174ff86760dd78b47bfc3a957977c3a7b39ce558e2353183a50bf9eb72802f3de1c06a7504608a4cdc8f8bedc3291ec6152cbb71603d0155684e29a02d218925086c97ea100e5c280458e9193dd949230f5d4d081fac95e9d0d62a7916e8e271dca11e41485e6aead38da1b65766d3d312fdceeb28c6fcda1142a1f7025697f436fe71919bc47b9e6e91723b6096b4833510431143cabbbc579500ac15ac664ab0d6cf3b43ca2a8d4c086d50b9ac8ba65b5caa0300aa23851c8498471038afa8eed0f78acc1dcae0ff851e530ae22cd32580d46c1d26a3e09deb6ec72aef402e643f63fe0e6054d0c8f413c9ba1a209ce7cac41a742244785f58f30f40edc3180cd98d8136d3e816aa4209d2d46d9edaf44736f1bee359fc8ad2f47913fa4c76dbe689f5d301211b528c0e8b364a790039c228828df3eb460a982b5093f1f47e5f4090a0dd1150440a2f26b63562c8da0f0dfaf186c8b7f7868189726584eb56f0171e1d4556d209b84360e97fd7240caf04885e2746215c7a09b157a0cc8cee307bd4db08ddb649dc1e8f27e3b81bf5d42865ff07fe31f1f4230c11f4d1bd065f1f9f2de940594cebae04412500906897d400312b36f1145f372e23175646693bfede6891f9816c10c2cc122219fa35877b28bf9b92db5f4d77f1639cd12fe69dab78f3b7c52b83b6131daddbf204978b220001590833aa0744408b3b1092c12aec207b35fb49b5dd9eab616093d709a4280510b3bd5b3eb02d8b5d5d75507a33d981cee236ded3df00a67e0bb2b56512b5e0e8b848a81e34547675a0bc88bde54bacd38062981339358f5d3b43e02a5e6bc004813b2c5baedf4449b2f7ccaa56c40889d1656f214b62d79feb3638b936315857dc31aeb6f794a93765dbe470179e4f1e17f0f452540dff1538b0409bdfa08197c51a92418c91c86c097f50b3b4981e293893b82a8fcd4c1e3a693c057f480f40ebbb8e0e5bbe72e07cf8d70d1966672560c79b9362312ac623b859f7c7e6fc3c680808d344c82946e1390c3f94d234451a936954db84095cad206d7a781a89c8fd6b49dba45fc32e09d5705717a8d1970f22cf3b772f4e87bcf483af6f25200a0b6e6bb250ccff9fc4c03aba70351910fd5b42dd293e999c0d3d514a698b27fbd689a62411a68d10255931f0bf940fbb62746ff45ee238a300d02fb11e2b85266122237119c0c4b37f18021f015eb2d6fbd6e58cd3de1ad5d8156c4692fd01132389a3df001b6200eee64b43dadb077fc8b0f8ce3d714cc26a764f8b7a3d8c30ea04bef18ab8f6189687f6e589ecab22b9f0349a61ff695555571a8de1eb2cc07ee3729e393f83c4171030d7321b65e80ea3cf71a1c7740b20400ba51c1ad3b3f122a4f83cbb1021d1846ca5c059477d89feb81d55dc74d389b4b7abd76d56cae32a9506c1198a8fe2a168ce27069d16a0105b19b226404ca39010dfa5da48e4b2ee27545c288d96ed643118a6b0916e459889d14a2105bd6ee75c65dc7c80b072f989e913ee159625eb230b2b30bdcf153092654f06693475ff7bb51d5906b3f9ecb74cc67f46047f98baa8b44a7542ddf776988762a6d66abfbc8dbeff6c3314eaeb9ac9d12971d92a689d58e8fdb0f93b395008433ffc876fa4ab638b874e8d404867da41955b068b59f990f265bfce2466899584d147bb16b96aa568e3ff2efec3ca73a8d27db14142d66577e4a0cf79dd634281bdbc9199e303b374ec928beae8d162c9c81ee96ddd9e5ac6ab35f88c46fb0753e7658b17253ad62039c6f843b0dad17eccc6b7bdbe6e7b8e5ed9a717b9c8c673e9370d21903f4921b85e982afe49396e5bc35686eb499d99cedb4becbfab9442baa14d200f6e8e7977a6db458b86eb143a55772a9a13856371a73b8fc846622ddd61d4cb4fb18d4546665692c91697b9719f22e9ee7d08119f76dd3267b8b9337e836e31894a07bc41ff9a84739a00f8cf91b51504ce4d6e538a214566a8ff2dfd355433fb7f1732c358a4409d01441dca68362e22a257ba5d723f7cd04669c09b47633c8b25ba49d3bb5f0b8f233ebb875999759aa1908368a33d068415394fa2e3481119c00506dd26e8b4e1c6d3177e4c3e75e14193bf933887d798a02219676bd71429bc1d10e176765f71cadd8e0fa549daab12193139a263aba7f24beb642d7b1002c13a759c30840978c4ba097c62331d61b281db82f2eeb29b92c0992cab28bfa9be1d52ce87ec06ef848f6943b6d2b7f872d19753adfbbbe95037d2d4d057872be6993884a612d24eac7fd854ea7e87548e05b595085942e0281cde4194c39d88d7f681dab247acf6d412885346f4707ccf2c5dcdf7bedf5dd002c03001d3bb957538db3ea7fbc793ba2cd37482bbbc3466aaf1344226fa3799515777dc0225e1fbb54e22d921ec33654102ac1e8a2db9b7bb4f745c317ea8bb296889d75e19692f86b76ee90bb266d89a2c09fb02520a1c581378226878b1474f50660f78c3eeaf3c260a4b3f30c2c23f38a1ae8a8ac7ca9222b417a796a021582890c817ef97ab63fbe5466255a0c3f1b684f8fccc7e6eb3c47a435fb8d1cc817421557bd5331a2862134aa7dabdf5e72c4f595aaba36d8447ba617722ec28f9484738ce3f3ff8c3543c9df0120c37f9d303181550530b6d36cd7ba0b719dc0eb47ad0c4c9f2cbfc1aef7b96e80d215f4426b34f6b2ffe33bc2a1ec878d5cedbca4060e06db58c129fb3798ca7ee07dee4914667374f93813afff3f772b6249bd649b781d2941f049832e3771fda8c5fe1d0c891c991778f63a7747cb88b3e05b8b884828885440f2cb7ab021d330bc4d4d0d96ba6e470bf7318e6e6157e1b3addeb2eab7e6b2299743fad1cfcf03fdf026213ce48fac7f91693d229e64f103702f3b1b62a033a274b08c765d8c3791dd4db8f04022f28f57ef4cd9bc71616db93d1d07d7207d3cfa3c83a873491095ba3acbe5da1a05d3cc29f254508ceb6476a4a1bdceeff6ae9f9f31450afa97f31667e1004329f9a9666ede9e806caa4ca1efb2351f7a1af6b378ba37507111c56c2e4d76b5aedcf944b9b6bb6fb793aeb088513836d475a20fc2ef361a1280e1079d5747027a5efc5d623941d4fd8d3579cb17dc42f13e538f5645608cf85ee5895c195325e247e5824e31ec5f83fd6d5b868036bcbf4f2c24be4100cde8178eaa66a034a357c9a1920bc1d70b238ed62e33cf0e37f42a49b8b2f9752433711d94a3e6ecf9dcea9b7c8d4ddb7a7c0058ae04bc61bfbf7a05bc7acfc1823d559be4dd06428cae8cd392eacb5896f2a6a4100b3012a8ae9f4f400cd1c88a02c68eb916021891d882afe5e623dc27fe1abd55d1c30f901e40019d65bc9325c10ada4dfddf4b59dc19731f2a0aae1385ac302c8f5f65aa73bf7a4582881b3d27b467d367ca2530b40864f471b57d13809a7dbeee4461033bc99819a926a084b735c70369f9e61dd347c97a931fa5167c3d51700d7bd79ad25681cf152ab9668dc982309076927a1f85e08e6f551a3f89c10add3602bb2f5e19a12321a0f204f7bb8d8ac5a3be4eabaf01cee1f687a29b7fe33e84436926005e4dc311ab8a44e581cef9c88638d5fb11274d8b1ef1e6e9064f409ac0b992d31e99d324031e09a1cd0f82855921d2d2881f0f5a4207748d10a403a04d465c008856251c91b0f3af112b6afba0332f621c6d25934a273234057948019dad33947af6d962e226857644bba37e0c03151cd3aa38293aa3ace9e2a9bdd16469e5634a4fd987f30612ae45d6a067edf7e51e56f10016a4752208096722e8fe6dcac78f34a975250869359c87ca8eca7d230b01e659769afe11d4fcbe4c964269734cd7da3598e3fa6f42303b19c450f983d1b973ecf774aff043864df2a2d2b31d160b93824443e4907bd8ca5c3f07c7912101510bf13b734a58d86887ea95b5b9baa27c38c487151b07d3381db4c56fe65b49abc9cc76db119fca588c8ece62a6aa28b00273867918bffb8796bcf3f0884287d8d7830e4c3662ac45c1823f34c4e5bfe6a98184e378fa9153b1665be9e9f0fbc610e34754aaf5c86a9f03798e2487d0c61a53413e0dc849a0080dce9ec665a04b63152adf34737d9d3e6d4c582d593dfe9c2d3ace9634555f339d3ee17ae4e295224c6f1643bd99d04eb33ac7416d041e9a496491c241ea668a806534e925a33f199a5cbf83392f4deffa37239ca8e07c7f171358415640ea4683fb80cfde05c6f30f3e8f9d2f15b8c3a0e0ca3b73f95bda3705858bcb4947686fc51c2fae87bee5726642c8b1a8154990961250b6cee87f9eb1a32b3657cb5ceff8048d9bfdd0a502ca5271c0c56e3b237a782496ba620809eb15efa34e0afe524a1a0b56db7c58d066974df6c1dd24a23b4a0a48bff6a10592abc339644316129611fe9c49c0f751c44f88195fff0353d69731c0a444e4aa0f7ee350e1fa18f12e575978e25beee04c2b042a0ea206ef51fbf0cc707e40a904a83e2a19c8904d3d8bea774934f138f720bd88871ced7fe8a1811a68d8df742a608849aab7fd90b95eb8a6970698430a3c720e05a2fd3b174cb6345ccbff282d7da3356d364ea437f859c959b9d10639221c6133c94dd357d45080d9645b1e804ac5fc24e751e624dd233eafd9a4bd46e45faac314e108ec77b940bca00be9caad4671107c91883dc79078ed9d242214bd5696484d8786fa7bb4b303263b8953a8686a2c1f07f9e306d844a4afe6c245fac954f8d667a09b1026cd8d67af985fbc8f969efa19f0b666fca97553a335a06e12df3b583f21b8583a9a79e8372e1a40c805c70fa402573beb132faae42ca492d80fc1257952c24ff524025716a9dd5461c89af73c9bbcec7ecdb7b990a85489c9d9960c7bccd8e745b880cc709e7687027cbf02702dab7260000df6df86ca3314693964a7147de667560bb3db2656ccb2cd1b7493220a9488305617330ccad252db6eb094b581c2a69c06cd773c3c611a33ce5bfbda061378a657d1f6c31a2bd1f6092ee403156ffbb3334cd49a67e47a5ac9b8b751f2592ebe512c3da705d99840d246dae7bce7d8154c2f35f9483d0e0939d1b4ced99b6a47afbd99a0d3c4a6036e7af1de05b4f4d2d1b32cb7c45d198aad21d3fc484e2c0307b89b8628dee366ba2e96b0c2a1f580a38255c17192792aba80badf7e978e30e42b346e8cc93474df35e2d0319199c0200e2f0c168ad9803aa83408ffd9c458802d226956c41913c17490fc5003e00e67925de798b0cda8d5eed7431f7535d0f1d0f052c5841f13396998c49a48a37dd00a4dd03a4d29561f9b311f436fa1e5740ec6ba106f1631d0e652278cac462e6afe78082a2d18d0109b926633c410153e54eb9beb1a1ad23cf6f1e577ac8f1b3546bea0c6d0d01cdb98cde4e356ca1cc2d0d0f897978c6d1a91fd319ed55d914169d32c343406945bf228ba2ffe2c0c7ca5f888b19f9742435946d01731c45944dc6d2c665625f0d6587ad2de39716aa244fccb73369412bcad4ccec3237ad9d0aa63009eee0c9b5a0f334eb31d73e415be6455d70917d28b6dd632fa973a1a9c63df2d45ecf2c4a921ffbd9b4235e441a568c8abe79927889bcf7e7ee417b2f23d3c98eaf770ea9cae755ab006cfada004af056026f401e18ab5b5937f0034641c92b417f59c627ccf2539f2bf5c4064767ab39ed6c01dcdf8594085856064481b430f8b2cc1c3d167ec61f22cbba8890d5f17baf63bcbdc505776797c635953dfb126624cc7a9ddffd784963de0f4f3b300ae5728085a8e8f2c2ef9618598eeb1b8daf5b31e6eb67eaa46f1521e250257b1e3188758b78a21f7f1144943b7e4aee978bfb1dc28a95ea03b6321a0a0e6b5f53cd1d10527d4176cf93525085e97427478cb5ee6abb5d6238462df3a2041b9aec01d99f20219a8f00b011409ca22a7909f239b1da1580b6edf8571af32ef8874c0a3780302b83c41f7ed57e30c5828bcf4bd04b8d9b293a31cbdf05516803134eecbc0df37d697382baaf8c66f9cb06621c23da3ccd14edd41428af45302d0a0ca353fd16f30f8f318c0fce43a6bdfee2c330f8ff0a80b91f3273e37b6484baf67a1a3945a394b944f3d165931ea5a4858c560800af2eedd82e9c3812977377c6c6339bad9351e3877cb5864743b44befb2a1a98708016247f8174b1413d82efe76f887630f660ac3039f4101458cd25b5c6a05e7bf31024c78d36f3ca53b5c91f672a964956960c775e80228c81e73171e5ca34c2cfb15d98f78b270a93b82191a0ac5482d882884c4eab21ee7f5a3f3158fcf6df191a93ce10bab165b5cd33eef7b3675ff2b2262ac5f2fc9dfaa9f5846e0a1c8eb23ffda8e459860426f1ee2c49a5f4d14b62d80d48d6400e6a42fef3c77862148924258fdb7fa4b0be1dffcf25cc8ba475c7d3a78f051c20350c4be802608ca1d4fe8afa390bf45e03bb94846786e42e03ccc7b7f842cca21545df417eba1e7469273ae38c4e2117f81f772d1acb24c4acf0c707a600654b21d96f9ee1cd82577d650c46b2fc243fc8a92e9c4377f25c8256b981afc17281a2d977578fd6e7e5ad2d5567b2464996508dea7544578541efe250c95fddbf958a373b80c57eb1d04fcb13b14cfb3b5b8bdf76e83713d1a4c320406af41fff1ee23e906deaa6c0041f1d9adf5fb1bb56237f607866b7345c6557bc119774f7dddd676aa0b1efa4a5ba8f10d7b6741c67311991d239e2318db93651af27e587d3f5604f5a0675d24b71e931b531c7245fe27d248d5d5ae8a9a64d62b341b039f90ad395a99f7f014a3daf22f6b0d24c1a38686a055dcf94b2d8572cf6d382444cd31ea8af32c1bb011a98b8b69df8cd243511310e481bfdffdf59dc9b4013ce32b72a29497f527c0be9b2393813e7b55cc0f5a1d3f9037950fbc53af8b0c185c411f5f880e0deaa51287a719fa18b82bfec6be3c1af461ac16f981cfe7ca86c60f8110e3ea286fc0da5dcf294058f73e5e3620cf552eb074a766e2b054493d12341c299afac1e4037213af44a8eb785b2b4bcf3e081c49b9685d3e7e0c0b7d9f4bb50861e4e97a83216cd1ead54f12f894667136d05abcaf09dbab318ff0904bc0368e3805ac82d7df57b57a76ad048f8a5c11c11c23048cb810c0515f63d8e3b960a64fc4d09f8a491301f0eab4cfcc505a86df794c892c095af8148d84b48d4635bf7405dd5ae9f35fba1de27fc18209f8b924e0d9be53e172ae94aca3bb26dc07f650c12614c479b1163dda2d08625c1881272be2a36c6e63b6412a67d85d9452e5a126c1f46d699b1b1753ea684cdc30a4777a4e520ff0610cfc484ff24f4d8c29219f33f660737182befa6e623963890ff53ca1e3689e9a0509311ac7ad383a17f95a6343234573f5c62970c9c3fb948fea27f995fffc4e162b55896ed0526e9fe392c077da2082c68fef00e433168ae3ae8fb6109908f0ac9b6fcd409d415e45375f0e6213e16533d626911fb7b5360c10e328c04423a2ab6c106f94ae59e35bea3903e235a29f4f10cd642ba33b09bc7a88e4903ab6157cac5b255e161c43f252ea6d26453128a18f4cfdf3b68e8e7cd61abba085f7c9d99c20f4b9116992f3eb36331f599f6845c4a8825e3d8002c33164799075bc1f9f3373ff49771179ab89fc7aa56cc60af0d474390761114c38d71870fed3fb9462bd63c736966c78b45263d7d26e17981df2e1baaba9dda2b24d2bd5591fcf2892f9984d128084fca1475467d2d1da996848948c52f8e7de949b9e03cc46612ed03d1dae1c704d17998771ce7af4ef8fd1188882497323dae7136732c6332217bea2bf2481ea3b4e8a7cc0596333c5a5a274e3f9e29096d3ab72b3fa231d8415b2d65cf362ea20bf43e3141e62f7c3312b119d79d365a93cde83494ef914afe180b7178864592e3fb6dfbeec3fac5b8bf680ab6edf411335a55e939597d0692c0bee89402384896516361ed06470a3e325e9d9a4279a1cfaf0652067a2d413f0471c4220c5cf8e8291fe8369f6ec633c9f7d9477b07aa6a7a10bd1da89565df506f25718716080a2a123678bd00e1557fce34d72793f8d1885c05f00ced1cea309cc8f0c69e8003675230a0ff32a552f8270cf5dc81afbb35ecb5274655790030677e8dc96474a0ba38e6661b573a873f4b0d7d4f75b9cca52cf29005222cc8211e194710899691afbc33017e9d5948c1cad5592f100ef1c603d7aab6c80e486f191795922c5cd3ba61dfe254adb74e76fff95c03f6d2e423a9c62298941ba8c1a2a42a1411005f574783983b6fb1ec8758318f35588fa83e8dcb112ad1558838ee0693c06bcbb1a7ee5461f882c292bc6f415ef068a64a889c1802f195fb3db1526494436142a5d3d894e606c4c33917721928001a5ec743fd55714cd366a71774b0df8211fde296c86eb9d174b1347cd51ed7fa73309e72edd4a93e3502cf31b1bd00a71e6a0af65dc8e4030e7d4a6ee469a0c67a9bcb2e24873e972ddbea021d65ee11a67cd296a4e365a0fd13e1ded90f219181ad20ea7d3ee2b6e773fee709439beefd52efff063776bf24e57f1cb9e92edb54a8bf904b46f70efacf844c4415ecc7413bf5711a41c1e12f9044b6a882f900facd184f0abae86dfd84de4169f4c508162492d16d858ffee2df7f7c4bc6ab0b45874c700c4636e706a283db902128d610e55e1dd3c41c694bdc988cdbb592f6445495c64cff52e3e37235c3de85204f6775c82a0810f39b0968993e4b7b70480754cccf08ce92770d60062cd4fd68c0dda4472beaf89fb2cbae928892146d4643b8fa367f503ccbc0301a83c190aca98f5c878fac41bd25c9149e0cb4c2b6247dcf99f859d307ed7bd2af9f3988b1079b751967558c42ef424eeeee43e5439a00d16aa98f9a727c699f033a7cb2618be02738c043186eea545597050865c060f5b0a154e494974daaaf0daa8ac4c2cfe1dda1074565c41412902e8546d9e752d4c352a0b4b5d1f4ac3292b687153ad9fcc93b2c3035532c26a96b2a7e69c5f982dbfdc2655cb3cd1f889a2a08bbf883980fc41b454b33572fdbd6d9ef24cb080a03f8bb92a150f9a53c12f4b393051e0516cf233cb9583abe0d26385acbd5bc1e9c67755112a739b9534f4c00c9a55c6aef0621824767528b11e3c066c9adb185efe676fb347c2a860ebe8e58af54d300a9b304d17b38fa486ba36bb7b61cdd655091451bf55d2143e1ec897cb62a5d4a3456361824e428517f5af97a77f69e580dfe6b82842fb89d0c49bd3c5f36922ea7c890c55de4faf2e7c02282c159d5734bdc4c45a84f292c721f2f36461b9d5ef6c107663cf30426d4d1f3160d3f86e101dc7f1642b7b092e4c2ad91c7b8408935282197bf974c975d201e95b79634e5c33864eb958273f781cbc5c6a11fccbd9a306e048c6d425338965f9728ef992a969720747325af16b48884f3a87aaf8d438ac9bd906e97b82954ace7e2ba378db35179f949bb09854e7705fa1fda630ce122e880b457c68670172050ea4ca02f2be8743135c77d9e740bd26194ea78885476dd6ee42125b30eea87102aeb10c3841073436a7d1402c69206f4f0802f9baa8bd67f39d0c27de9db3a5089818a9d2fddb2c348a2232dbf7daab43bf5cfe4d2f73f32a2ed5c5fd29e4a36a25c8eb6d07421c6de2a7f485b98f9baa861050cd7ccbb541368f73668e93208312138a528bb2336d5671a429747517c712e452e0cac4c18d9503b5718c8d97d6eb3a5b8e5923ba106039bf4dde3ebf2a01879ee3b668d9e11ca3851ae06bbcc74802c2393c0c7996907342b4ef20606cb52a39cf591b3fe72d67a34fb3f681de528ed701f8a40e0359db72be58f12c337f8bc7135ad3f3f15385a6148d2255d7a1e5af3c5387d494c6b97772bc9a7b974c46576719db46d5e8ba12e6c15fb3e4294428170d9e4866331eca07f2872ae69ecccc33456ac6855200a7173fb0aa4fa828066652ac1827ea4810e6d5daa94aa30e134cb9c841e6d85d961c2d86c38019dac91487936f77e5658c3234b54addab6502b8870e91df3b38a00b3e41417f55f49b9a956ebc265b5722dd684eeadb3ba279d0222b78964d9e685846ea4a80ef7d10f575c8ce21b51a29e81aed1a935341ad84cf4ea799281e035fb2f6e81ea599950509d224b8ff372d1997cef86eae563bb0a3d887a737045930675553f9200e48c9dac89d21c1a154bbbf54cb9703f29899032d6516e9dcaaca79c75d2dc761816fbb6875ab6c22fb79b9917451dd6bf9ebf0ca8ed822489056a3befa110cd8f5c95225395cbf0157bead8683939f48131e5e76ee3528a20d8323ae619288b8d77dea8b9964b1c1b92d2c49c459614ad50190616339b8281391a5b6bee82f2f8d098c9bbbcd9947caf711366e345c126f6a2ed9852eea45175ce0c0c07d089e70b7d8ccd3fba09f3363311ed55904aeeddef3f00dc3352bd18e24c433ec658dbd02f3a013893885adf7b96b4e1d899bcc91e0806790dd4978d8c59db5d075f40e5744f576255bd7816d8217cfb58c35e4a16f4b1018d528fb3468b5f4163969c78f45a0d2d5a32a281fe9c492870eea5cbc3d9d5f151380e46a383add0c5cf1ea679fd026ee68f42dbbc53d973cdcd530cb381aaa910daee7822e423564a6a757f0160745033b92854ed4133523be8d1683d369b6d980fc590606b3ec3a3b201e6fa64b4b1e02d3d2097291e0f54b4a059519a7b1a4347a3cb4e288f8125d357dae726638b95d4136e5222ed1cfd3fd5c62329f48a0fea5a1553a2b14cba21f55dc969ad86f1d28246d2945c719acf5c590412df332ee4e4fa1dbf6075c46b058f1cd5d873c67333c12c91662062fe879d6aa0e4fe330ef1ed06c92e7a9ed6f74d8d704b79fd37f9343e76962267ce9b014d51604557c3cf429fb43690f4891801fbb738a2901c86a64fbbb08825c7986052786786dd5d414c32861f2ae4ec2e0d0438c6a146764632a3dd25e4e3791f9b3d1e35ae7f4ad6cd17f0e004475781549a9c971954390f3ef0b7d310ded069e6896381ee5dd8183f9d69adce7f222380d918fd70435e5088df77150ac73d820c7d353b6a9f9a8d2a53793063242643a17385555e0eb9163b147fc9be7e208fbed7406b155c4336afc7dcc7a671a89b7daebb6a8574a95e3af8d73b7ddd688df10d0c284a0afe6a64299ffca6beda704ccbd12b24b6176eb888cecf2219c7b0c04b495b334cbb7fb2d82648229856f71419bc62f494d51b6dc9937caa690394fe598f3182d11fbb527e12b1a8017aa004f64ad4dd2f9721d88a2493abf35f94b65d025107d0d1c7a466a08e90ceac13eabee18337a8869507fd1146680ae5c66162aaf64134957c7592c485eec09a15fb31a56a6ce48c54daaf542b2878383b7687b2e63a7f411eb805d1700bfc56d072c9a651448073615590c70eaacdfe158067512cc79e6e3261eb13d55663b82b65b18282c8508dadc1b36776b196890e47cda38bd521ef61fbcaf201f432218df35bbdca3be2280dca04fbc575b5fec3bfb4e45505e6f4e03dc5a2295f2cfdd929619c3a80a92d3ca9e799cdcc6ddc2bba412c43c568aefe0909857824b6176f8728627b898e99b1683b124c65c82bed4cf8e5f177a87ad263861a0ace1efa56d171ec5c5bab5a7d70b4b1e609e70733ff1a72eaf1516202ebbb2517c1ca2a5c44f9f7e72282127882a977cf64faec89a235592698c73bf6dd6afda36cc6f5a9f31220518e956b3d3ced3f35157854c4925006d22bb394e17ac656609acf1f69b0e8c6ca12d63b580cf1336f733e34ce992a713ecfa3184e506c80be221e500c383112008750e509a883d70e0875aefb2029db9689a9048ab9bd9a1cf5955682669f85e164ece85ea1b3296e62edd4f22654fb26bb4758339b66f242faf49621dbb644b5a6399ca344099d9fa48e17aa0bbabc6f9f2c6dd1147dbfc777f53df961eed49ddf126583585efe9023743f14232b1347a183dd76f3a45c5b0afd89896bb12d5b702ebd31061572c10f894cde200b654171027b610c193ebd95e82565b5538bc00f69769f409b40709f969a6530d984e5ea22e0f689912b09cd6f796954e15e4e91fe09a862fb2d35fc38a34dbaa978511e74d0a26011b121c07ff2dc1172a23ddbb6303233f2ab7cd7749f54ff2723673d173225d4daaa092af0b4158830397061b2b27565e1ea7fe2dd456994f32f5690afee26390ebdf8dd67776d0b53b4634bf81e2fe734580efaf1b8e96d5dfcfc51862e12273270167a2c6a8ddf808f4f8459eeb8c0dabf70f39e347a38a943e073375aa435a8b6e69bfbee85320a82952e32d3839f56d31d647bde2c52422dbbcafd0d416c3a80956b1a946dee704085f4266b0a1ba43d043a1a1f9a5a305c15351d9981a263f758ddd46dd4f5f7dad545b35ba6d52a844a7eed36a439734fa8ac5fbd02c2071e99211c00030b60ca0084d1bdee9c330ad85c00f4001e6d6bf884261f632ffa08f661bf35db96969a889051237bcbbd777309f508dd0914239d623b3a15fde41487a563d4bbbd77637b775defcdfd60c3180cb3d664fa51287aaf77d7bb1b932fd5c5342a7805bf53d74d267b8750f94ad783e8dbe5556f5dfeba3eba4eba56377bbb6b92e3e17615c3ac35997e14eabadbbbed9aecee8750c117c7a651c138f6e7d5d464abf295df2136bc826d64fb9b7cddb03b664366d1adf683e817ee21fa867b8c7ebdbb3e62f2752ac2a347f96b4423a625d2e57997bd2eefca7e5d5e67afeb9862ec2a81bdbe1bdac8df65c3dc1f3f44895e5f595c9c9edecaf920f27e9663ef2af8266fdfede554e075f1a86511fd3159723ea8264ab668717c1aec42e52d4ec3f2abb46039b6d1295a5bb438cdca555ae0d8a92156b00a8ee91475717f69bcbe2a6f7ae9d977baa961ee53b2c6a12a571c62217682435b42e17bbded1db9fbb7b82c5fb9f82ad7050f5c02eacaf18750b98b3777cab1727c1a95bb68f17b9a16bf2dee7f4fc3f216bf1f82a5850b7c67963ec48902c22e30feca695c541bfe62081bf00b5c6f8bdfe4ebe2aa1cdf95c764adebb29925d75d931c0faa99f9af7c0896ab5c72a71cffca698e574ec382af72161617c72c180fe102636c3b557f9323e7ddff342dce72f1f1102d70c4bfc9337366aea8dcc7c8d0468ec72ca52da9948f3e28d38629603fd891ac795506512a67c823396229bbf664a98a41a9a44962cbc21695d4c28ecc17f9932f4b620a841ab139383ed6c7e463c24c39312726873227f644ccc7fed4253144512cc2d86861478290c8217246fd15521b65117246edc6b2882145f4758f75aa5fdc920c6c1879ec44a15e8c883076a6e2651147f0a1961563376e1cfab8f9aa17e56a5cafdd5267bef4adeb32311cf3b22ade262a66091c8da1666248bba34b84b13145fb6e188e9457cf7c8142cea0aff5f2c93ee8a504ebbf7e4171f9cc970b27d72b93e0e8d4fcb513031b4a9e70e664b90509836921ca5c4a228c4a7ece0de4190653155450c8533221cfcf9c1a8f1d003aa6145812c8224c66b060c8510b39c6cb0d48184c6a000231d65c3df345093e3972b561244f8ee461e1c99949266a5e20b64c0c3420a6e6656a0a24301561e506e6bc0c19b173c74513368463a7a475b16da2304f368526b5276b9e4dbdac96b4256d29a93c6273e1505a7d35166874935c6f0f36543860202f8bc82132070859e3001ea6c6b14d727cfc04b2a625130bb547faf03411190a9b086661d60ed9b2e843968caa92216710892a18a88e3d2e35b0d1464b53c5228df1891d72bc8b0c1adabc0559289040598749fbd8a64c122986c35196d8ba381eb24ce32dae064663a634d6fbe2a519d85035b34d548c14065bc91c311f1a04ad5eabd7b5ee9e3cf29440a84b72d7b48f8d3eefe8e3a3ca99528b3e78a6009d74e80f5d45ff4c54979460c3b884dcc74153f3c3290575c91591bb7265b3edb4ab8b4c14bdbcb1f796bb2524d8f0cafdf71160e3b2648dfa0dcf5ba169337368d533a07553c919d9eb89e4199fc81816976057765d5886165556bd33131533511876591aa31ad81e206a7834cc77611bf3a5071c9fbdb65374eef0d2325ce24be8b3ba648c7b56ef4dce64c81821cdbae488645765a2228d5844cd5bf333da8ae1409bf8bbd7b78b75915c37ec93899cf1913e1fd2d19641d2bff9e678c832094f2cd4209d7b64428166e9922e0ac644d1e310e110f349c0cca523368c3d618c0d1c34350ee01181eddee9b7399a30a589053943e659ba71a6b267573681bc11e95abce88626f0d68899043e720ba8f524d2eb4938147dfb453a463a7612965c0244b71fdd2f8b6eb2f5b66fdc76356d6241a289f96419a536537b943342df5ef1862d19437be56af4e9294743db4626194389ac6a9a96b56b59bd1addb6ed35e837bc4d99b357ad46f6d0bdc9968c512d2a35496f1039ecd3c890af44af9b8659c7cea4f36e44f6b0d570e863b368bc62be2293f9729d0b5dd355f944d5dce1512ed1c0d277cc0e13e67b3daa5e1527cc37fb56c819327296e87eefac6bd866e4bbe876e02b26422126f23562f6f0c9be07760f63b7b7b8b83d729c8f2d6f585a2163843eaff8a25e28f039e964cddb7028a42787dbad87b887369abb6fe7ba6fddf6cad5e87e3d05e85444ce88b9eacc977a9f1cba538a89a2efeef49928ea44a697c3514262c319c47ddbeef6942be6cbfcf614a0f912f3f6530ae40c99b7538ec66671b766d775af31dfede4add3e6c6d5d8cedd9bec63eee40c9f522063580fdd30e58a6c552443e89e2c57b161ac6a6dde2bc6236f8fa21bfec81b0ebd87a4b6d96fdebf7ffde1d0a6e6efdeb4d8fbbc57aec6e71d7be7c8193163de2947c3ebc9db75514dd4f579fbd25b6fec920dacf53a7f5d47c06579de64e27d2ef1de24f0bc7b21fbd0354dfbbeef35e6bfdf84cf1ef7cea6660e6fa11a44262e59f34298bc4acea00fa9f6cc85661a96216364af9d3bcb4e391a19932caf092b31f19c3d7b942167c89cb964a793f220afbd86ccb2d06916bac936335f58868c41e911edba76dd38b1df647ac3f3c8b15e77562c63a63b4ed98436fb864172bce24d8eb74920634c26b9df37979439a031a714b0886152461f9b2c420e298249e3585da04523489c884a62f013951811224f6c3373054cd9c694b3bc917202bf028d2db438b5162da24c8b162c2c518685656525caacaca8a844191595d329ca9c4e2929512625050525caa0a0984c51c6643a3989322727a55294299548a42843228d4623108c32202812451991e8fb3e6ba38cb59e17653cafeba24cd7715c94e1b8d8b26db165ca685a9645992c0b85a24c28145b30ecbaa2cc75595694b1ac5aa34cad94764799ee39a3cc9cb145467e5ede486909c104e8a70a287c789e48b2736489247472884821b26c92c515414b9848f12325ce1563d12bd30341a91461bce28a44b04215991e063d55ec9e2aadd78609c33353071a4329c5e982166d3062c3f853310cc37eb09f8e91e590962c8324905c226be426251356e630027b2387c8481f1313132fb52ceb9a40b5704c471965bcf53246a5ca22d7371614f3d496b1ce6add1c88b0b5946d620e43582343b055080707e41a56a1cf4c17d4bf19b1218dd9b558b3cc14c7999219111acd71c26c745249295529820d9f290a063da57f31bd2813e7fc8dd6f5a17b93fbdad48c61193246fdbc8dcd46422ddaaa181e949cd5a2966559169667a439d0faf29a942b298388af51e6ccce224f6b725f0338808359b81034777a16d19158c43c859846e44924cf2b7c4cd49c3c988e649922c655cb25661892a3e4287e01e3666640cec9040b47004a120435ec4451038b0832d87440822c18c18a220b491822054cb010638cb2bb37dad87c99b13b7637a594524a29a5ddb17b069452ee1b1762f63eceabf21095efbd76ef09bd61e9cd25a0fb09c342144d0e4bf701239f4e3b03418ce9ef3d39dd996949890a9ec8f5f4c5fbe4f4c43be9520b96d2574a573979a9f4caed78711baed9303f14141b504c9fe92b5d7b71633295dc0fd4647aca0d6f72cab5de5ea484348b5cc0604fdebdc9f4dad47cc232640cd3eb0d5db2e9338d82e3448d6ebadf090e61e412e9c689d2bed1b649ee878d3b0fa1dc9de3be594b0303857af1827a1e087ae1e87b41a905bd172f6e9c29cf761a0d8c9b0dd7d36b2fb237fcf0c5855c476fefa581a59f3032f7d0bd4b031bfa80912b07235399b78d865b16343747727cc46e2002d01460dc4004202964f93b6d3802f7892c49c581a3ac54ca48230b8a3e8d52cef328776f87ca4f1aa651c19ee6554e3bc7d1c44e698f9daa9a17d6ea795ead9ee9a4e4795da779ef3c4eeb3c1c59f4d1e93c3a55ff712a1de90453b92715fbbaee386155a72a27e26ab5a2d368441ad9fa5315590e3c5591e5b8d355c141a3824fafb59eab1d47e34315444db3548612c98aa84a011d38ca4e4e4a99157db5d6d1886447b556558761d69a4c3f0ab579efea3f6b2b0571d0cdf36a15e1eddfbfaf6a15f7b0b5b31da992ba3a1a8d46231044a12794aabe4ff483eaeea24f54323d364c4a8aa9d4892cc5a12a77e0c88a4ea3118ac99e946c6647d64a1c22eb6d9b8a7b941908c2714284aef34cf5dc8e2ef33653ceb28c4412812392c7ed40b9a97298060577f7c07b60e76d998769baaeeb700ff01e281a91482452d7913acfb3342654d7ed309d8b3b4c184b795e77af13bd870dcda277dde8ddb59ee79148249287c3eff624d2f72e7e64459fe9a298ce75dbbbebdd5e2e9ecb36d3fd4183824d9c0da5d96a48f32b83165f70a2ce3ee3911b87d9bdec72cf3e10147d190e4dd144b1567bab918636b0db87ad4ba4087e66a6b86061b32cfb68a3413c5b20e5a1e5ded9ad9769efd7d6b2eeee5dcbb2cc46f4ce3dd3a8956937d432dc63c4d1daa36c949548e006825a9659dc0dea43c85d7b86411f344cbdacaf69a73c3051df1eb8043c466c27e7dd4d33ddb3a311062d16711d531c87439baa51aa510f8737dcbd1ab0dcdb02325b9f5a9665f778e4d6de97bbb5a91aa59a46b9db542eb4a959c371cba1909ce1117978641b7a808b92c06176a2b089e298f0de81af4cd64e940ef41e078410e00d6d3278d1fbd8d75bee3a3777cab2efa60b66a2ce70e33851deb6813eb64d2385b4921dcd9ef49d466f9525adb7eed4022d32053cef74020fe2eddfd6ed7d8fe0d69d4de313f813f8ed21963f7c02b18d981dcc0e3ec3e8f7ed8636fd6dddf67e05718fd2777d6cb97bdfd062afd495e8bb114923913a52e77d218fd49fd733f4ee3b9d2fa47fdf356aff99b87bdb4874b2ef814dddb9ab8936d2a5fdafffbdf187c1cdebbc5028cb361105414a3abde1e85696652f1da4b7fb4e0f7e7be9f6f840cabdbba29344371c611f5bceb230fbbe7df47636d93b78698f0ed35b1f9ba5f7e8bd631f9b8fad1d00848d9cc1143370828f2d5b40ce608a194c71b0061a8eac659444414ae9290ebb6f9556db3d76c39470889146f560b5f5ab187b2aaf44aa28f444d64fbb77dabee3f495ef60b94a47e9874f1b5ec1342cf766da0bb7c74feb28d52a3e59ed9eecbf6b9dc9844f169f729cbe729a130d8eace1d0541fee2152a9448f128552cff3a84769ad59adb56ef68638b2cd40100c5119040f5ef35431df907f1cf81e7d2822d2e9f41da313dea182a3cf36adb7793872d7fd2405e524238128267b52b299c892ac5da17693f1047e74d2cabfbb912ecde923f0e65059b122ec43a5cdaddb56aeca4f9765bb3954f0cabd4bc382e35576e52aa759c12a98e684bdae533e545127c7f88855953c8f69a284e0bb2190fc715c08a4e32cb5f6d64e6d3be9edb449a7a5531c8a9a36f77a8ee34eda28e57ef8fe59ee5e73f6961702c99cd55eefa9c3373e0d73d7b8ca719d394cb9136cd35c49b471b7d72c672d77bb71da6739daf566efbacce4c9effb6e770bea903d72a14dc665dfd7894c9dac36fc914db7131c3de68ee3344dcbce5dd2b37b83c4ddeb6e3df07e3814619bf6ba73b7bb373ecc7157f36c9ac33e7e009196069ab76d17512cdbcff4774578b30dfe7b87b189a216f7681bd2bc61edde64f086417253d228c3dad4186b1c961e47f4deadb2ebd63fd87ff8068edea3f5bebd36959c0fdb1b9fb4f749c3372cb5d76ebbcff2287e05efe11ee06ddf90721ee79d50d268e4f5d6dbd6ed7d1bf5d6bd511c1beb9e7dc320b96d08247b07ad873b7a20f9fb4c77789b280f7cf70f6313e5dd7bf779d47adf4bd2edfb3cba7db4f33c9499eebede28d5b6cdebee9dd2eddaefdeb0946a1dd5a6b6d13e958f2d1f6fc1d0df39cd0b92696d8be93bea7d97dcbd5b9a17cf8536f3f346948eecebedb52e37ca9d62fa10f743fda9fb0e949fbe43e529b7f76e48b377eaf0a7f23d05d7efd486dde3f70bb4debd4b6b101fbc537cea4ecfbdd60e9f72a0fc741a144ca375df431a3dd605c9b5b35564b75b7ac38aed462da5d45afa7978d451da7d1ea51ca59bd5a4773311a5d7d2c7a3ece88f6ed6729f9974fbe928df7142d9918225f8a8a23693bb386b6d7c7d77b96bf6ca0e7ff5745b7fba33fd598cbbaddeb54fedc41dfcc87e23909bd67ea6439b69efccc2bba1c69dba7fb728f7f41a84e68463a3fcbbddcd91627f7a6bd7c65d8dcbc20c64edf494d39c3c1a149c929e6ac319b50182591a24bf344fa8d0dcd5b0de369bfd13b5bd5eee9e69db7ec8b09da82d7236d43b098d28c64a1ae91193747bf60377efd96bd753876f70d8c391defb7743eef16ddf1eaeb7eaf71f3ed4537cb2a7f7bedd933df72db3f806777a79db876da8e5e11ea25bdca3f4ed3393bb9496b651a4a40a8259b6d18df39e7d0343d9768fc361dd6a287ba8de1f39d4358cc966fa0478b8628ab9eef7ae7613b5a139f49885425b88f36e2fc7891eefdd74b14e79f8a10dcd75bbc6dd1ee063ce32108719c8e049f76e77431eb9b321eea6100e79944e4a38fc91edbf874c3814dd8b273547ebb32c3bf8ed8a0ede1ba21fd9e3eed9789b6d34ecb7cbfdb8c16d59e761198e1385c30cd02c7328c3a1cf4c798ae3478e8f41fcb0a4f949f1d988c9d7f7e9d58ae5f0d73729babeebf2baaeeb3c7c5dc44d527a123d985db71dd2932befdde34a7ea661bccbdb6818ee339d92ef6e4da77870d8466c628a4159ca08b4e19015b6626ca27866628c266dd22ba48dd094c5b044aed6afc6a185758e8480340c860384a988cde9db68982cd8503ee1c08ee1207285fd66c523ca707986308f4ecd03e9d4bc69e60cb1c252175fb0615cd2d6112bc051a2042272e844d949a58ff53a64be504bbb8f9462be08315fb29989f326a6200b64976098b526535c92b5deb488fd0822c2480f84423f3a4513c0c5a01f5186cbf4fa44a04e94b1995e2a1165ae402f8970090399864c1fca3164fa5076215329852ca74842a65c963ac814479fa892a9f5b09deb126fd7bc3f36943a2af43b3586c416fafb043b846297f499424829268afee8a09a3cc844a9a53a211d580b63132575e4a9951b1882944c21043948304308da27b70fd044054d54c7051b4aa06eaeaf4929e62402a353856c222ccd3e5186abc2a2204e27664e9461c9fdd93d6530719d3913d55fc9819539081334dcb507d98e8368b72692b9c444293175e6763bae260f620b1aacfcb952d83851f28a896a30581994fb73620924a1882d7d202020a03ec6e44661dbe78a4109a494b25b36edee96e10e748724ace1880db15c84d6311912369446480dc417cb23c8f4024654c7c49656c2368e4e755eb9810d634c0d13638d189638606b20a22e53080af632c1cae7d0215afc0e98e4013be325cfcf2000888619000160dca0ba005a1ee3383cf5500eb18e43df7ed8f8882d3387088a066c3873a65c71df68e623ca649f8fc9e1f34088ac8cb758394bca63343d4610dfc5637f8fb1616450a772b827ed3a3cae64dc93864f3964dce53a72b80e39dc25870bb1e1321e5777795c692ff029870e77b90e1deee2722101b80e38764ac33a5caec375c0425077390521b3f65006659f993208c705c6f8c696f95f20266a3e07193776aa050e51319d9a2c388c91658c1cca1d142a0587bf099770682d883fdce1cc0396c31b96475c1061b55010190efb584e177ca8b0c72bb30a071c7050a954383cae04704f9dbaa7c6a71ca994000420800bb1e1a947ec12464b4b0b0cd461a00ee34202f096c7d50df7249fc3e32ac63d497cca11e332aee386e7808500e0375c0616c2040d007ec385d8f0183711a0c88c1d260a35800be3dae8d4fc0d57755b6e8c8bc3cd38dcb852ddb88a71e3ea861b572d37ae60dcb8ba6ecc03a83153b7621bc6c400f4c53200ae0dd7c5ec7a9eb042cf135638810f0c0cc330152a8cb1d1c34f8c12248001a358ec819d748a9e3040a6101335491e2801b69a31cadcc0fb94353632c6943f0d037e8a5aca020cf96a7b289bc8f31207d200db470fe5111964c5555d49ae069781c4969969c17af77bbd46c05bd7c8106c057ebb427440b5fa3ec4aec003a1848a9f6c3373c5272c6f39c87ca9a71cdbed4fa1930e4ff4791e0d730a611ddbedb7db875227f450e684b045c2d67b8b74f7547fb3e2eea9e209d07057756abec34150d8e3805cc38a09eb71b53d443d5b6df71e9aac0d441932e4c981f842447cc9260b268e9c6123a708220c378fc8b3a661e28a1447b2c995a27bade65db9d3a91bc496f9eb4a2457267165114964a2e63c42c3b29133e4084a105b72e8ca5c8361d95a12a2c2528cc3c6445d2558f9309b1a0c8a80c4bbf6ffdc4a7c7a1082247890a80286945236866158cba6dd2d553ba07aa28ffccf44c5989999989923e4e4d0443125f24420030e7549b17a58d775cd5f3c72c7eb560f375986cfd20b368c3e34354772297354a2842a72d330810d314a4513ba20a2020c83a80917801f20428250980daaa0e9a805d49452411c74c5c1c1c189a886b1d13895cab91a89c086126789d9b4e79c162a478e20c6e80b4b1c598279491c216cf8bf982d67cf77b71665a62414d8a9c4199ee059459410d8b9842a46a0b3924300421474565189108ec0596975a3777ae0034728b2babaf0269f6e5839cc40c630264a7e07497a70566d25923f471ffa5b3fc1d573f55cb5d65a6bad97cfce5cd26dcd25b5a7f6486176b7a58a735e2eb55eb556975a65b89c40c7d2c9eda3840db71c755a4746ebb44ef5913b5902c9242a974deec82676e4ce04ca5d8449c4c2049a4016106850ae3ad3886d64a241330434880659249e39ada83ca8a1cd933ba886a7791ed03ccd9306ec48c67ea8851db17ab6755380381ab3bbad6e7aeb5eef3bdb6a2b05a84522c8735a279d2b03d9c2575b97b6e0a433516dd5478aa38c98b47a685c92650e8fb8e4013c2a0f2be877af29b6cc6b328a177cc0a7872592f8acb4ee001337f05969549ec00849f05969b5e7a70547569ae5042c663064a55d5bcf112772561ab60149c1b3d2b0adde134d0d129940e4089e55454d948cd911988004243b44622044d5348a61d8abc51e0a65c65e6f45f7fb41cb189edb7ca83ececc8a6d990b43f7369bd1639ac5a4155c8dcad19076648a17ddce46928c5d912790b442c6980f61184603bbee0eac0402ca92abd41a4111180cc13ccc091802e8ad6953656b94a996dd588f6d974e1486d5502814ba7693af4b2e4e1476b2b01d65d942a0efeef3406fccd7e79b9614b8ac895dd69453f6b02c7cbaf1d97362cbb22c8c7aa19a2fd3b22ccb0aaf8ba27f81cd2dcfda018cca4a9bd2534a69a5b23695b9be6fadb5ce1ad82badb4d25a2b0cb6a2d9a78956276dd95d67d3ee39273eddb8c2be2c8cfe4d9b36a530daaa1f9bca6682165f8419a5216d02413fe9a7920833833a456fd109058c760eae4b42b752a0dc9f411d6d6d7a051b5e38b92b9389eaba24b6583d9dea3fd7ead3934319106c587d8e4c597daa143f5950cb8699ab89335f84c064bd62a6ba02a9c0ca26dd6448ee954ca9414d727f0275aa59a2b0a16c02947b7234b02c9bcc972c70e68bfcb5a467db208727d8303619126402992ff4dd6f988a598093a392152891c3d81395a8e08a091357f3a1b5d1b9c646c300d17303096c189bf467a6cc01d23038ab6e15489181f851d3ef1f551d42a8923a3c35353535353535353a74e8d0515353535353a343870e1d3a746056a5d9d1a91361d69af00e150cc334b15335db6aad12c73376fb7d1688873db1a7fba14caa4e81a3930eb2a87ce5a39b43e58461262ae4a715dee4ec212b6485db0f1277214da35aadb5fe264b59bf6119f2862ed946c3ad6eb20cccd95e10dd90268baec53967ca34cddb9626839fe91f7b4513a5eb94bf5e1a581819c60c7dc0f0ace63616154a555cb0bc45fccc2469dcb56ea41c05ff403ab7e3bb218cfc7ddff77ddc51fe5d7b7139eb9e4e180573971edf1e46b724fadda2f42b2cd7acedbb28f8a44bce87ef28f8548f727bd23dd57b2761584a4a4acaa9621a1bfe22936e714893519e82439a9c72edc5a9742747a3f4931394d3afd3c9c9bbaee34eb89393128e13757f724d076fc82393aec9cd0613a613755fdcb89ae97b4f9484618c4e718fd12deeb18272c38a7dc0f856e88a0b96d7d3b75061c1a1cc2a57b1d7ac8ab5a00f16ab60dc8df644a09d74eb0257fd66e572c36962fc86cbdf80c3553808ea383c48001ee3372b19f7242fe337ab1c6e8e1bae3acd0d575d5ea5ba0c1c0400573d880dbfe13738a860c4b8a1c58a2013c523771afb25777cb082dc30bfcafb53672a315fb61e1934711ae6f44e61d189325c6619819d79f495539ffebd61b0563daade84ca4c54131657465ae982275dd19da09b8e8e4e5ca5c4d549461d2327df3c651fddf4947bcab08ed14d271d2b4ff9ca532eef094bee58197c7a2ec98e53ee12ecfc699fb9a46156c209c40903e28a470d5e7918814ee4e36af430fed8187de561ecc98d250f228c5e4294913bb12507730711e6e43d97903170d00521c288c087272b57f248cec8c953ae3c5d693252fae476581c9c21fd8e28ebbf574c599749b4f46918d23b943ff2d3a7979033641216b7b85e4c5967b12e77a24c8bd8622d911b473c7ba6ce9da73b713ad54fb9132574d3a87f72a576a513dd133b05fad0c82e87b49cd149e4feaa74e38a74e36a74e30abc713564a56558eec49639244485c5b0c4012277e2e6dd78d343a2c51761c5e9e6e9d69945bc775c983af3257a98c5a2a9105b0a39c345c628437c41437ce9236223117b07b17d109f105f342a2219e48cedfd1e4394e1de2d3a0bd974c58b1332cb3b0849e40c1a19830511a6a65344fa501841471379896cc402b1a53fd7106180c89cb9634413816147c4549f67e6d24397f4eb82b7aee8d45ef2ecec441996fce5fe7c22a50925a223cad01314f9294293d026624b9feea89cbb31b69cde82e5ca23220c7d424c519f4e5135649ac54579764dff9158fcfc5891a3613ab9d65ba649148c541a5deb596777727a826e42a49b944824d98488dc44a0373a6dc22b92441699454091682659913c512672356acfd979a73b0d439774aa0a3983662163ace02574872ed9c9134f21f7357be71222aaffdd898488f291319634cc8c22a65a362137cd625291db9b40b1a53f9f0841c1ca1e9eef4b1a66a3594cda853c0aa91ae47da88fcc51395d79651228a66b335140666a1ee7e7e4fa285d1ca4db0316728604628cd9303444be9025164d64938804223662cb3c7861c8ef456c51cdd4fc8c99491a8bd8d2e76e8f21b6f4b7db6490319e1051fdec3615b1a910532e72464bf1e284dcef20c4543f0ba62b4c468022a67710db07b19188a8be75fb8888eaeb6822d3c8199d8405d146ce6822b7409f202ff1851cce1d34c4598688eab7b8f3e72ec9730d3175c41772bf81763ad56f2372bf89c8fd9d9db91345c5595983145738d13384123d4284a1064e044d9c23e008e28c789f997693b10a9ad812438018bb042b63da0c7194fbbac194410b42ad71b307c7449d64287778b7a7e9fe5dfef3b0e9662531695d550c8aa14924cf1c2c3bc2863268c917ecc4456822163f57f830a9a24891bec4b00c8aab89716856c8162a08c68499420499a4496654c3c8d5270e0cbc3083b4287a767777239948827690c8254c41f2874221c2483004fd04fdfc502c836415f45dfb72466155da54042919423e620a9f385f26206f83e509d8d82c7d105bfa920731c684913b9bcd0f28acf56a447bc368414131413287f1c746187d76421782854e8f248b7c801c95d820284b4e869e5d8876ec4242cf4e7368c7ae23f4ec9403bb761dd835eda1ec210d9be46dc8277cc427b2fc4c1256eed022cb5f3631280605d13c658eb56a1017689d97143a4a7c8ee8d66182c57efdc77cc18c881a4684636a9a0830b84294a1292da74882fc81d40167a36144efc7663981053fba10d149affff9a9a9694084912d883f3a37b042981042bae8f5a7799ad1c1d3902e7ae44e13e718611007618206bce83a48d8060e0262535c31a1cdcc17d90f0390e56d8833a40a628c3e6647a4cbbf8832f4f2a4fec804da9823d8981d6acc6067cd34733eb4c8da8fb78ef4a4adb15d5e9e6e5ce217b1e593f235629638a4f9b352fbd4dedd6f363314ea50167746091595914e8e99b19161a973d56031ac424dd4d502454d1d6f762fc8c15982176ee0830023da6d4c549f6a60c3c86363c665c26857990608f20307a771e41ef33e54f9d2b02f582c54354723b47d08eeb153563643eb4395352c6b59166ca4481c59e28989ead9d34f744ff360938707db393251488e44196ed607f1aa77337faad66bc534df411ce47b909b5588cad67462727227b6f4e3ec79e4889c3187e496526b91687411e95e0983251c4464799774633ad5a3eb7913d38c46d6da8b623ef06a7434127d640a32ba27bf5b9ff634e02df80f07b1074728d14d28d3e88ab0195baae4ce13d4fd79c57ce18932a1dcda73b6b68d63aa8285827c820aa89f9bb9e9c3710f4598c9d3a966429e3b1665b673aaccf950a5f05899b54f80f61139033322cf6f9916ac7422893cbf5db3b6d8309e05bfef8237766f573e617907af63748b858c22f81dbc8eef2016c2040de9e085c44e7d3ac07fffb01012963dab4943ca9f3cb17c42c3fa137d9f083cf7378c45babd90d2c15ba4dbd3906e71e920b60d630fdea29cc803ef8db090efa35b17f54b570eb10dde3b0de85d748969be8fb010fb9177d169bc8b70ec14f8efa11c228b8097c6298777f034de413c318dfd085f744ff3403ad51360405c7d380810f866f5b8b28f40a25be3ddcad8192957ce876885acb5d44f9e7a2ae4fe09a70f0ff3dcb7abcd356459a3bb7c8dce872a6fdbb34b6dd2d0b013b7cb5f903b3b4d828096fcf8c81596f1e4892d54d81096488e4c54b73c92fb579ddb4ce9014e963b71623151f44d66d0bc42c76727f3c1ce8e8f4f94b93f55e820622193cc9c91800a9c30740089945276cba6ddddd285ba58392af14952440335c6ce52e4f0b109108ddd48f639e79c73ce89a53c92e7e90d6dae4c7ffdba82f0ba2f735e71e412ec2573a80ce51902a28930f597e71ab2c441c835e41313d8d02501d488f6992977e6cbd430dd7246392a392f68864fb28fd91158ab4a9e248c01a358b52eed9a9846bb8957d42bb6a0601cb1e13699ac0d7d62d544c584aaec32511d635355a1abc246faaa186ddb3ab3b6b7296742b034dfd0acd6758955666aab1709565e073c2d833e7264a29640f54347e20c2901349b0911466aa18166048a2d68b0611fc97d7aa49768249d2476f7916f8fab1cddb7ebe8be5d88761d9c90ed9926638c38fc68ecec9eb28796cb30131ba23cd61128a04082fe749289a2bd83a491ec20a1d612b1859a7e620b7d88084b7f58320dbd4c2189f4ed2c456ca1a71963622d1c62cd23c40ca080a20a3aa0a2044248a1831c244890f8f4b060618dd0914148924c89058e13990faccca14492f9c0ce1c4a2448649034431259be590645999bfb210f6820f73128260a934155d8cbe201425225164d8276ac8462a2ba39196465108c9e257a7a7a7a321250613be7f280165f348f5944eacc588247a684953953c26648d896417c8999a8b89a1151fdda84c7090b6c189b0c6131c1ac41c87a6b96481aeb03e9543f74b1192d83886aab890ad5c407045fa062b0d288c61796437070e490a6e8a8740d97b4450b158d0000000083140000180c0a874342b170409ce7e2201f14000d8ba64a7e4c18c9a32087510819440c21860000000019001860b48d00628607bdae1afb40ffb997e327352707c5c08a31b0c6489061496de9c085263ce1ee420974353c2c846dddaa2970138d3b18366d0fbc58a44e6f2755c2a99ec67717316a3968f5c2933e9d4a07a9509afff7b4d8c0072a1b06556ee68ca99b16357f77514715f4bfcec3981594865e7c74ef684e03124c027f2215aada7ad1c71c1d48158e77b03cd4fc2c5f47fca94f3a3b503a6f068dc3a14d770f61384a75e19e8350a5c96202734b3c1e23cd2563cc4858b4615c368ac40e99074db6073aff19db91e526668a4a7072c223bd6307be64872dc40879a83d1ef899ce4bfb6b618c07a9be7434516b19268ca6a26f768c7541a9fac9b1395b16992975874c8297f399d93b2bc8546075c5dbb88b3094877b48c6ce5ebea85d175ac86f32b60086657cb4dcd95ba2c0381608813623b9345baa6bd30eb626d18c83cbb42ec939fb0fc90d535306a2a58205c5c511a1a5091ca9ab75e852704458f038fae6d9bf35f610fee3ae4ea846008f79f9c09d96d92200c10fc09486385854f58036b3fb8e650b2e1ed5cad70fd2614b82dbc82c225195a5c037425d75298ec532e34b3dac180fb07c17d37d9907ced04282a239fb43ab9e2727a1fd3026154f51b048ac9ef95c035f76782d4c597402d3a9d849ae540749b0f83a42a8d6d90c57e6d61464600f2a1f95574651e19dcef569e2995595c1efee95463d23adb4e1dc57d1a2de6e3917041a4677841e0d66b28ba49bc5175b51c8543c4b9f85fe166ed878dea8ab12655e8557bcb1afac9ea702558d69e64262721add1b9c861405efbf33ff7f7cd13d4cfeb2c795ac646914ad58a8ccfb8d15c581c7a7d40f073cfec2318cba85327ba13f730c068da5b202a9aaedfd3268591242487227c417d30b10c7591f0ac52c27b329bf3c217d124c148ae91b67433e3bc51c1ed8744d2289ab68817f53249a9e0e9ac40a71fd9266f51df2eee8a13697d6c8a226179a17e5640b9319b345329d930945838988a6d2b1c567ec232cec72f6ac0c7b9341589517e5ae624c635207b53de01dee30683cff6824f9fd8cb44cc91d345bed990a0c8dc0dd2545aece2162ac058f5990a5906c64d92d397ac8303eb0409117a34282b1c09f12035caa5027c31cfcc875681038f0e955ea9954fa93db312722d52529df8292fbf3ffac215e7c5615f635306ccabe11c97c65045162946e63c9057a3898b4e1b6782efa7c93a4ec95be695438ab73b740398d623f8d223a59820819336974526c021c28877a57bd7797f39353d1fff4350d8e1cae2164946f6acf09304d23b83869f0d0486503b7be90e812aecb82af5ca668363cd0a569900275cfce2ab009d49336b63c6a101e24932b70b82e239e16bfb2795cf7261e54dc7b53e49cced8d0e171a252640fcef3768e04be57755ddf9627e0143dcf5d536e1254271380209a0b18a602e8cf3f9c4d1efe12272acd42c954ed60825dca15a191e53d4a3a7385ba96ff26766a173d0794cc660df0fe26156fc029fab5ccb1262bedae6bde670e071cc74896c7f38fac9d5682547ace9172d764fed0504e834d9629ca27d0201d5c920e42c882c6485eba7d9224c6940e44220959dabb4a007a6eafea42f4b7b83cbf27bfc8705919388248198133531ffadcdcbcd56f9abc1822647196122029a7be49bc44c70f27d12df41546118e97af53939bf11e1cebe8340b1782d65e3b5875633abf152357bd10787073e6740d6ec3974ff5b4e4dc5fbab4a08ad7b963ee6b44f8f9e2fab6e2a120ac1ee66b8079d50d8bbeecea329d7f8f4cb4abcc816d77d9a3a407f0c786f636303394212d41cb90aab2a242cbebac4f6fb8b68f862c64f8995485fb4d4c566c09c6c928cbf6f4f4f775522e4f0671122003f418dfadeb5849d0ce0d775d16b852b500ceea511325f59d408aac02c3eaa75fdcd034ee001821539ffc9d73c79918ed6f981176616bd19494521bdc5834977e4466b16a8493e390eb3dfc251ff5ba78d2f1fed70467b114f50dfeb7969c8561238d03f4af733406d58a33b385cdba9062060e76790c65d4e4a652e92536c0249c3bbdf6cf9bcfbeb8a2317257cf0f0bf72bf651548189d29d586198623adbdb8329db4b4102da44fc92c9101fa8d40734f338817a3873031052d18e4e31cc6ed614822e4ee1fd7330e85259e1f6bbc3a49d534e4ab8b95882641385884e24e4cbf0f57a1551935c6c313910e4d24d957e54cd17522035c54238519f022732cf265b1fdbba166561e8f75912cc26d2389e762fc476b5eba6aaefb2cc6d87fb7742ab16807a8024882462a0b81f5f003e853a8af3760165530ca366954ac30601bb138321b6091c7ab1771b82736818a41113157ac72e446cdc877a21884d9e049dcf0a1c8ec227d75518a4baf78bfe9c60c8a51da32312b2bd00247b101c3a0c83b8677373f1b5cb4c527dce9df333139d690971ba4d263c570d21d7e14e22f70ad95a12d3710215d0c4ee0bcd3f475c2aa0550934d93feafd5052ab294d3885f34e0a33c1aff9f8442fcde8b8288da1144f2dc59cbd148f0ec47199e49684cc99fbf0f9d34cb47e86d0b42124188a2a9608fc1412ea4dfdcaad5a170a62428036542499f762a7368ea7b4ef9929636000e27ab13cde83b4c686b35f60d700d9b92b8c81684a068730b64dc00007587f7651d9316341b6707be0d78ca87c031bc46f60ff0a6a3feb8fb1b15d0a8b3024a0c20cfa818ffd458f5f386dd84e71df6b8561f86bfa9162384394a0fa5191dad7fa402ceb7eaee813d7e708a166012100651a13c761f4fa95355414d5b00e99116730ed2ec688d398b195c8691212905c3604e4b3fc171aa9098f86281bb1f2fcc8b79bbeb33a876a292bd1615ffe92f6875e6bd4e92e30350bdb859a6a6c30ed5ba14932b74540e29e3393735ca1805634b22e24f749396948c614e402f7221eb8341db72904d642b8e90f9d81b4c19e7dc8c6b9044f37755eaf65836cb796b7d5b2f7a57e79e95bbf458694503e43010ecb7e15194e2e5e8abc69d410e9bdeb47da050e3cfebed7bb28d6a0eda9dab852211e3f1c8aa61d4a6b87ecc2c0cc3d96200e086cb06a057355030262593a3aa3aaf06dcc05c091e4115da068d87211e456e48e8670f61537cffda54792aaa078bdb8a58f804948875811c155f0c5c6bf021162b14b78f017ac709d942374e81675084201990bc04711fa700eae9bb4139622beb02511e0368077aeed34718113eebaf255c0cd9e84897a0216f8f0d80439c42ce08b641eb4609550c1a8dc839c583a72b46c259c364135cbf95519ba2e6c07bb1126cdebd02c29e35c413bc09f3d2ab7192bd49dd8322d8c41e4246273c63db828c8c4a871590115d0c47233742654423fc0565dd3f745f59ad2800020eba82f74049a69fbd2ae31f4719b8744594a360c7053e621819262fee971119ecaee6417c5a2e40c984f8ba0511ce55283841a48ffdadde6034f69a0481da5356d607128adf1239e86c8060ae2ff24a230a3cf6869e0c7a1dacf47a5d7b523542d17349c9f5512b4ed8d9273d23684e6c953651c35a4aec9ad9d232fb29ec33f26213e242950131f49b21870cf5d13e943f498db245856e3e20631ef9e438027d07f35b8f216871591b2498410ff4cc5c2a49fd6cf44928ecd20a970d1716e4e060066dbe4465c5475512cac110eaa9ccaee36bcce727f7571b18b702ffcbf630e2d839008d363dbbb8c04113077513cfb21d616b9e8a57975615e217b90194a05f6e20959125dcc43562ac889ef8f15d87f61d35acbce8484a008f1b3addbec08bafcf7c5252c390ea0102a4d8ad9286f1c33b23890c77628a1f1ede59e88e41df705e8c7800435e2a33026f0c481eb8fe318112365407d4361c47c2fbc6afc9ff2a0eab5312528a3a090eb894341c9e9a56c496620f617703bd1dcd92d05b2eafc65caabc42ce362a121fd3c8fbe59c3263abf8dd979c0a25ae772e1bfb55a153566093f4dede7ecceeb347b07d90ffa5c990a1226ef0398666faea318efe3bed2be149e85db476684276718c4247e04f7970af61adecefbf5d971c639af891e5e079eb98e8e3eb27a8d1f540e37fb815a27205661236db8425d2c749e1a7fb1edad2cd9a9ce07ef05633e0be4c8018196f2f738e1f1db99e8a3f21655858e9309016c50007f9f38593bb32b81286d4ee4771a64bbc1b59e259b467a845383acd5d51a285d68e63e56ad0c58c1819459aca1af798c53cf05bf7bbea429fb01759ecf44521394c9f69b1c1edab754c8f752eb80942976c1f2ab15ba9f956d347d036d9fe6b1674dadfdf48c127bb2807d227612c209d8c370eb07c5297abfb93d671c7969004f132f4c01a378483b45fbe74bc9dede740bbc3a04be43c19e2f6baa03f662661e28360803f26592a234abb6c8852f19dbb10db288c75f89ced5494a66da9eb9e44d4bfde85244d64702f1182a9b867d22b0cd8690b37ecc1ea0532650ffcc3a03556e49cb0ebd03d5851b10fa199244231dff624088c4a9f6d8f622b14646a672e4c6fba9ea28bb27e6734922b49398f15d37ec9b6ef7f94916abb4df63e5c802d0ef67289a5d157aab46832c5f281bebba26b1228b94baf9bf8f8240c3088c86c6f089da104c7106f78a3d13aa6918e5811cc74508c82ee0b472d6e55421d64ac22350535c4465ee37cb3d1d062ad3bd5e960ccfd89905b62684f9f063c239536c8f370964f866e7715ad2dde7f03729dfb203a4849d3320dfe406bada3363f2fe0e9de3d9a1928d06932471682d598db0abd0e28bff96ffa41b966c8b162e335c1ffafe241bedbdcaceee3f695c9bfe9381f35cac15b0c38a578a0da2760fbf93f4eabd2d1ed969caa04709f57dc274de1b35120e30cc68825660a31e2a5134f749b2c25fa4273d21a51c7a8aec8987a9780c1a4c69440a37745bf360220bd646fd06a710c3f9be977b793ed9a10a89372cfcbca3175001505b4f2dfdb4dd6c00fdfc623299202b95e1492935e4eef5241c75919cbe1d62ef7d49dcd22beda0da22c26db1a98c3250207254f40e2ca469788abe28e60541c6219357e7cb6058521b352756f68d28c883f70310fd94e01178ca2925848cc952f7b55fe3f5b2e00592b4a3e900032d46d1bbd40262c05a78ba3619e26aed24bc4b681ff97e0515e909e26fbb8270a4c9d97829df39d22f1036834d31a7b06a9a398f6018cca5a04df981a30ebc332ee016527a101bf9f537ac8ef50cb5bdf83d409fb1a96d72608da24b9993687560c33879029266a53b397bd6621856e510280ae19da8dffb1da775a51857979aee9c1b2812f7287873e8fe6b8fb3f95dbb15d233a1f3ed0a818ff671c3a395ffd9f954674800c3af45f2d94b8443dcc1f3104766083b71082aeef22f40e8abab5208af1f79ebcc19fb841b0f3c0ebe5ca636a3edf111e79404ff15cdb62c9cfc5a3d39d76d5f8297a13fc11d8da2e40ddacdb6f4ec0b52bcf098d0b544405b1b243131c23c0d48e9fc7e7c5febaa2a2875a8e5c421045d6dadf5b904944468f5a0fa93a71b5c41dad3fe19fda92723bb4dbd86e4f7f3429e66fb326470daa4d047c3eb23c1abdeb3bf91a16b67e0fe3ec023f76fc99c329c2ba05d75812b313250beb0c05a049c04dd74f9222db0bc29c14a2fddf76a60012114f913498285289cf7f96149c1e66bf8ec66201a80ba7b479d478ac6fe18aeaeb96a692bf36547c78ba32e97f59eb52fdcdc7f1cbfcd9677cb896fac05b718cdd3492336468dac9da2705b63d08ebb5cc8a9e52983358621c5c3ab6701d80e7480fb10966b6a3624d1a1bf94f7862477df7abf62af5965f984398216d8f4930e3c6160c0b9c9bbb771c5306be56a5a10b07973207dbb42afdca03c045241077a37151104085067f980f54cc70544b16187d45231a718018fc8131182f3c429908e426e7b8ead2439d1d4761b4d516dc89a71b6cee25ca89b3083944b19268bb4b51a2c3d49c020d9b1d1592297553a38cca8644e2231983fc526bd7f9a15cb36888f5f08a6a8e21df4c959b1f6b6784d8dbf7479821c47c27917dd804b79cfc96986ec1df61b8bd04d7637ab6b39469a773acce47ac4d34f072c54466c978692a1e3c85a7975f90fbba33cc38b257638f1069cca3b47ca15406fba6af7e8ed127de7f3074331f232fdb18f12a86e29e7f86ed692c710c6ff74e07ee390268572264eb0df42e504801827821136c2c20b0cd670e9e92b5fb730ecf6c6abe183253916875f1c37c40f035befa1050afda8adb3fc28458aa113810f2922229e229f08c299d4a8a8ce0ce1866d1a0dcfe7bb27f21acf24c43033d295ea8fa097b94c83f3816eb19045e6b1b39ea906d251993d53d55480db661563b1ec6b0cb36d03e55a016cdb89292da34e08e179e2eb28818d95ef5b881cd035c3dc559934b9d8bafe4bde69b865cbd9be2ad4ca7fb234274d95a2b7325618d106e54d8b4ee736132f0e0854727c15be2794b37c0414a54d89e60cda5c7189f213a28025646c555f2640759771a6526538db1c2a41c3f95e6e231ec59e6e0c64a3f9d590bd703af29e7546f8c8a4d680e8bc4a756e0557bd719aa0a885a4583d9b1653f6e01fc9e65b225c12333a3709809e431f8327cca9efb862253c64ca2683773eb78eaacfc1c07bbf07cb0b987f0bd82f2ae3ed7ccd3493b4151d7748fb640b8998478008edc8ea9c746ffa54703f235349a9f040e6866b1989113d064d0bafea15a88625ea7d09c923a8940b74944c73bbbdc9ca18a3ce4ca53102436e24a8bdbcbf7e2b9ebe3a9db201bacfee7a7fc532af8e73a1d7f5917f63b52bf9c36cb5da2c5f4c8d90218b390ad98579f7f661c2afc818015eefd707c9386629e8f4147ceef50e4a4a9de77a574980947bd891146c0f88fb6636c1025c3491ad48395fc1104b4f819124354c26347a5b03230cf0c0eaf54269bfbfbc7cf3ec23480a6a9909c1727db3c0392993c332c9efef8565624840dfcdfef80681c5d803009cd2abc50e0d33a5c120ef1b93ae73756945ecc203967f25598a90c845c2049f5fb8da3bb952187946c820faaa7bdd84f24bcf7d6b3cb630d2302aaf334651025875b762363f3f0d896c0fa43bca885c1725411b32619c47927d7cbecd6e16e4bc216bb0c6e8fd85fcbd9786abfa4fad9f0803ec11dada9a971a319c17e5f4266ac96251ee9a30beb28ce8d6cdfbf7c25596a48ed12112499580306b3425989eb52ac3439b96916467af337b6d6831de854af6e81884c80e187b9975ae6ad9cb9779fb310ffe17c9b2efdca7a835cc3532883e36c444b9909910108a65e033abbb7b050431f5ce27049108b97f4a3d8b5efe5e2fdaaf340429b8e4c548468f1bb312b12832c1b8dae39db1a438b51bb4ef492594664aee7e694c278b8a7b77de51fabd9fd938265dd22289ad49c5d340939f9e950a7e0d14473c7448eb6bc8ad2131223cdce37689592259ed4e6dd0e32e8a6344f88928ff66a1f5136c9c4b980693be0de0af7fa5cb0919523d55078a17eb8efe8f6b5b1965d35f5ef237eb8e46e2336cd437c57c892393259f241705b7bee0dca7b7a80cd073ae8aaea5d8a6dc89dde5109be94a2ed11b35b4d8cda6f8d61c055492e92517aaaec534ed527c0fefb482c8a2288de0330d6ea5094ad2838aede9c554859fa0c22623d18fd120166e49ecf970e63a1357ef70a7c830a8ca64cba4009d94639b29e6c95e3925f522bcac6b91b4d5ca75ed383f4dfb5063cb3bef9ca551454c044d29f618100a7ec1a78ab22582ee6472829230fbfde79cd54fbe284d893b5e5e2742b60f43b91528f91a1da137d64a4a9585be30b30e8f77eb1be799d8097a8990c6ec04c9d6f7f1f99e8678cc4f21a26f519aa3c3a16091fb9470f882a95957ef828c85c6415925cdb80b4b08b706e25dfacac1748d2cf3d77f96db445be5aacfd4ca5e755606e2601f042c45787794452f91d7a91bb4f4c5e42861d542b75ec6a10017436a247dcaaffaf751cc0389bbe19a40991c3c33ae166f0617d0ee1a013c49d5c4159f1f068f1456acbf894413f8330b027bc5845d93c84a5666e2943cd39b0f4dca5e87e38cbc53aa5e904d6ef70bb21f0b6b2b3244161b990d808a66826d04eb60f50da8d071d7f47e4a5c3fd2d9f7b4e1e0d8c0bf8a96dd7bf4b0d6c10ec1fd0aa18f524d97939b2749e4be3edd4a603afbd8be4312467102d1c5ef0f2107d514bfe681f5d5b64702bf0d4aa00643d1e13b30512ab8e61400949639ce12063e6dd402666e3ec437a24aae3e864835d4fc6fb38542625f60d5ab26bda6d1806e4b70f85b872819906c3a43f5a23c084962958adfdc1eb9a84ac70d4ad690306ac0c33ca56a76d1bad5bae88feec72256ce13578550e1a6b895ad964073ea0c2d571aced296e48c92e1fb358af3f810656a0da77c47a681eabe1c36069b4c7b0299b0faef33ff828eb1761f7f75e2a9cfe921d882ee73d262050d383335e924e0588ec6265f1b380b7b3957ef0c9ba0af2a51729a0d16484c9263d7c2a8e960707416ace6a1f31450c8263c3531beb2ceade9f05737180cc2723685368ae1302cd054111ad9e82bfb0ac0054c1946e81c720c8f83345d749d29562debdc520d595dff094aecaa3b71307017e3665c50f5044747a4116feeb6af777ac391d60735d04739d6b6ffe42fe970f01aedf0d308d965cd4bcae1083d6b1fe7428e8fe6e6003702571e299da69044f30f6547cc7565be556c517e9680ad87fbd339b48bdd93afa66873ca2f0e3355801d64d7659a050b7704fe37acbb43a237bafa8f573facad95cd93aeb74e850ef383f866db75ea8672014e23d2a1f217e984d2e8c1ccf85dfcd9837ad3143d3931867fd56d91f118d5888c04267a79cc408890d8739bafd490bc3021d5738497ebb59952fb28d18627692b51125a36858dd7f121ba7b8e2533fc70e9959c0188057b24c853c5597cbc484fcc741d16d30d35a69abf55471ec44cef6a7c28e04134105488fa66a503d20253310828d89aedd00137d1c24a6b311603104696dfce1ab0d69729d676acc8613b8c2e718e601debcec66092ee4727784e94355b6701d42de6e0605d90a983c6635a74dd9027bc5f57b969863efc1f6328fbbb1c8f2f1237382bdf13c01b1a68729fddb928b73a23e579b9d60d9f6f6a13348218f7bd20819e9a9293ff7c2489e4a69f98f77b12eea61bb57df466960334794f41589fc96261f28e7cb3c807808f18adf09c4fd3e6dde7500590712400b0d3cdf905a24b1c5bcf9a63134aeb1827d71debd7cc6dab84187c7e3c379847de41a796567144b00893d94b39df68efb733746b0f8028fa83640f158ed8b40bda609cb7f53436cd55f9499a6daf7662cdcad645e721b0813e3f4bdcb57fbeee427ae10ad2e9ac1e852588cc261603e8b984f5e4e94f3e97f9d8b4f6bb44d2b0ff7e9f93468a8612a24f0da13b94874f1a0096eb23763961a99116ce80cd3cd1ffcefc8ca8b33100cdca2f4b0091a4c05800a4a60914debae28d5707451154a325447d4cdfd6eebb9488225ec69cdc962f93b7e1f952ef5c6ae8f8326df8e362d6c1ea2efffd7579681734c23b637824883943b588a757eef5de1181081c07495c7c3ac01092c0baf4d648a54adf7ae347ff9c6359c213b49a81a795f64a14400b5a8fbdca5333b80122195d96709f8c9e3042c2063c8587e3ce9fcd1c3ad0527144b2d99c95cb1966b8c2648c9c11c1a30ad7c5bc46dd168aca9d4527466b2862991613f10fc96b8b225b8bf5a0c941e0a7a47ac3b19fa0f02b888ae93c6afb0729b52c1a3bb038a8daa25b73695d8ca4a960331a65267c0c13ccfa0f234134ae8696bc7846e37c744859718411a7658fecebf6c371d1ba114dc6d7e19e92e2bc772bbcf076fefa78ed5bf916c7431490e0c49801d2eeacf3d8e9f6bbbd2673c7836c4db574eaa25fa0626b82085ebeb8721e98dada40716b49bc47c77ceb46a40c6ed8e575e75c3f96c3fc186e328050d687e57fea9586bdefb1f29b32fba775fd5f7b2bff3f5f109d243b5f45516ea67de051c45719003d14b7940c4f5ae016faeaa00e7d9cf900309370f48f76973a6d41817cee190c4377c18e37639673936e865ca289b498a64f1457e8ad064151e87ddbea0268786fb15624ff1b5027fcedb9a1c7919856653a2fcd76f5286965c6b5c284691e94edbc98fd19cb81d92b1f11f9202464084cd3a645814e0d0568396e02ca72e64709c0fe891678b2a280d78ec435b5e65cf80faf27b67b31ac960098bc9f1539f5ddd76829adc8c84f529230d97a601ff8831dadf23a927826b169b4fa450678ae6876a81b05168381c21ead4a65a8475b657e12fed4eb040ce8e4358621e61cbfd79762478f948c4c98d90867d244b10dd3dd917c844f111f683a39922a2ed0c5665b1f40c17c21c4f5e34d4ec1202892fd68cdc390336fc7635f067121eeff5894d696bb22615b9ba04b08aaae208e70056b5cfb3c7f037176951f0b42719a1871ae12635ec3faa2740cdf1022a6c7597d0d09f243a19b2320c4e4d94d6e1bde4af0e310ec4796b178af415b80ba4780f045db65a3b8484f65556d88be28624466a675d6ed55844afc335a9b6a35c14d5218257b5bdb2bb28f481e5055307a4792da78ebfa5e5bb1b8aa77c55aeb27c515ce57739dd690ed3b77348150467808aeb64dc2252d8a8cd83222b599a173363ae9f40c1a48ec84e93c0009f2acad20fbf9295d03cc597e28ccb27022f861b8e0d895b28d597ead89ad120a269cfcf71567f984c1e29071bd6e4a46f00bf793a16770f899f2c5080287495df92945972b825897c96237b2d42beffe64621e9068ea3d83d6b75930d57d40ea0fc88dd22e5d0571ad8c181ebc05d0ffd8c7aaea29eadd323c57b405ca2c5045ff53aa3b12870b42ad5af5c69376ed4c128213ae66dbd9ec3d4444fad85a7075513bd444e0f8a7250dc0a3741f2b4af687ca3251e9acea3a5687e4748f00a06e4e490e088e40ce20b732a3e7ebeafec9a6711db1fcec9333660171aab313aabd25696dbdc6443e820a5f1ae43a3a9f411b321e0ce47ed072aed688ba36cc6052fc231427974a93e83d91d25ae8d9322abfbec95a875df97fcf56bc679ac7f062584d3f244d6e28bfaaecdd78c8674e88b55c2c97730906c3ed27d1cb97a1566b9f0f00ebdaec9019df914719de311e1a98010012b04db445539417487928dda744d5a72daa1986921f625d0282e94fb8e671d8bcb76380a8d475df23d3d60e7bc83e2361d860be83427592e15864c454eafee81397d5a601ec49a5fb5e79ba18722bdfd556f7978c0afc7bd15d0b01b2c0bea72af2383dafdb9f2729b2d976b71f28e8ba86b8c6e0bac7febf26b6e2550aa2810f2efb39781981ce990dcae355caef5f80f62824cf324f901c8011b404c708997a1ae19864e3f11e050959ec6b15aca471b17fd62a46ea7625f4e1b01cbe02b3a511a185960a715306f3b6658e3fb2fec74a1da54ae2a8132977bcf40759617e3094457ad059f36a2446e1f4745ca015cec3ad6f1af4c7c899d258af398b07c484b9040e249e0ec07d0b7cc1a4a405824a1e440cec3814da7af763aa0c42854161e3979b5d74de5a4449886ff8c36e22859072351901993ca87422fe7ffe4193164b185346dd82b89a2f7ccf60237c3bc52241cf475fa2c073fd639869f07a89406f75bf97f1d6a2726f1f6e065e382f700c4b13977b02e26542bf9608668310175ed9f69ef3004ab41a3994319a9fceb397b3eded87c3942df923a102e913e92d9ade92d6e39c7a95b3de92eb6192d5d3e2a9e81df30a9b807a51a4ee4e89afef2438bd146341b5b0c21b863b821b0a6ef4c36d104ea08f9d294e93059400bc9e9fa5387ec31f9f1b81a21e331fa0b96054e9c554f867dc40223af5cba662018930334467196fa3ff599e0dab1522c9beacf43387b0cc8b34f033627e81439d3f8fa5ee3729c3f57ff6e937d0952150ef75c728b3e6d67bd9843482cf48f9aa1d004c24977b56aa024f7518ec7d283e83ba8f7e511f9c0f50baf1368d791f805f52e6b8822f98d9bf91bee8832ec104233cc007700b6cd8d8852a9efcc9ff5bc8fef8d4041207a7795af176472fb0da6aa9a85f8502b70b41c2fb70ea286a1424e1c84537da386753c3c2a96666c521defd8be2082768e90f1109e677c4c836819cc88d2ae85cf5431a0872ecba05c421d0c3ab473c0e2c0f7c63a9fc55839a70b0b93e8e51c25432ef1032f8eac30e43e3aeb7df872e8a87feb378637f7104746ba3b77e1a6b3304ce5aa88ba42d8532bf064a911589b8eb8436b988a4bcf4174a2066e714d105a6cc8ece993df3a6d91551d858603c853e88fe1ad59cb64540e0ff0cf53da6258c87e5862b8d8edd13fc1e4713fd16f2aba3bbd356af62574d3c0139fc55559a6066d908551a34bbc576e5cb688cbff6acd00cf49cbe1adb5c4397335d40b0071e247c903eacc0e4a68ca3afb62e4c4a650d775fd5e4a4dab5ee27883ddaab2a1c0b5dd7d1998270e37ffed63f220eb1c6d9915a78c5cd2b3954c3bf0bfae030874e8fa17b5bb59c141046e4c724c2e20daef4c82e1306484923990bf7185a4bb8c2ec5595accc2e99605b865ba8dd15e0891b57da8264a71ab3fc267e1a32d2054d1817993d6b596656c65eb635a8cd0c2bd255b381dd6ca1d73753f20b59178cd1bda4d6a612fa15fa6f62419f5ca5947a5f666d32d790e8d60cd064373654ad147a47f401cc37d800311dbbd2ae7dcfddd1f2f8d95de384d6efdefc55e3dfff87a111195be01a1b59166d8016ac40695e8b50e30e34f1ab02338901ae5f101f011bea97f90386dffbef87a6de33b64b6a6db42cdb134d1505cea1aba117bff7927b6d32c4d5720c8182f699c1d3cd073a68e6ceeac122c96d1eff180ece1303b0ed8c254501da78a1c2f1abebf8e9124fe81bfb08c84469c200b715eef0d7ffc7871ef4ead83eaeb961d9602769c104f6d37284f4a7a5a9cf13596bb34fde37151e8df0f21970a3be913f52fcf9fffed0943e4fc59275d2291a87cbf3e71738b359d5b7230754b68a4ce85709ebcdc98f4e6f52e66a02f01daaf1d512a416a375982d138696206c89f31568c8fad663078d804bd53f657de6c7287effff7de84aa063fbb8e646cb808da45d12384e6b84d0adef87febcf70c9891195d08d4e6bf58d1a21ae983a01ff8a0c4b1a59970aa892722f4976139dd51304fd15b291e05178d4a63ac3655845f23bcce9e1ed9eec8026ec74da1fc3cc12fdf59df342160e1829fe90286226758fdf284e4d6e286b1201e2161c1a7534bfee7885062c1960d390de077d0ac3d5895d8b43af33c4287b34e5fa7841ba73722972d566db4d9fd28276ae28c3bef3236fcb4c6c7466057fcbb73ab9b2ff250df546101e259bef6b91b9bf6fe354b45660c5b05c36bf9e78c7a9c7269cd1ffc7648b285d729240b1c183bfe36c9dd348def7b44bceaff1f1b43ba1e94878722fd1744e24097a2bd67a760ecb8f31b1d506085028f63562b716581ccce300ed36f9b87d78498bce9cc63ad17c58cc6da32bda4a63132ea3cec0de5534c770c4facdccfb73f97245a2700929129aa3e774656b18ce47f44f5ab4a89ca086265493e1f45abdce1cb727cbdfe9dcf90da5484788a7b330c3d97d01c7bb8d4e051b6a87159079599b4f04b15e7f08ca4bc7cb2128d018c2ef5ddf4517ae5f35f05bfee049eff138a9bb8a717997c62ceb77d91cb9b1f517c0a5aee084af9f7e22b586e210597d33a5d392217f97e95cbf30337dba09ff5555631668a87ece94740ed49f475b82647209a400fba51baa9e12efa475ad5a456359be11f2f9e7180a61dc9943d5ca236b5f9b4cbf7fae8be445cb1d189c310ae8275e6b24696d1ba5a9b2c12ea22bb10d80438bc79af361c4066492b3d4ee12ae3b1d03dad55f78803a395e30573ccaa678c54cc6aa92cceb5d90d5a90d4063f7794f3d111c8a413178bbe4bdec5937e668268f2b3dc8fd5065313795b6a25167e3aec9de7c9bd1d1b10b817bc2c34c375fc71f479d3051bf6b562e013f9b0f99c2f67a2278e4cb75a7d2be0c2075fc8b5f33857a54ff423922f4acd89f8ce79e3ba4fdceed7719ab91fc361b647b79dd671175dac08b2e50f0968619bac5659c591e35c8f6d3e9a935b8ab8d5d82e0f57bdf9fef91b9fd6c0ed88a20571c619c9e5eaeb955db03e94eb2b1a435876d38f8f767c4d0366ffe8963e8154ab042fc94f4001a5397150b12e169d154930ca42980c41945b31025369fc40b839c275517cf4268e84104cbb83a5e85478d22181537209e56d0d37fe4af4d162ae371aaf6f63991f8233d77dd2a9d2d66c9391cf7f2af6f972b82237780303ff0acd31be0bd5eb1f37711868d430f000d4a338330d917ddbc8f059abdb0581005e13fb645f1af29088ddb3457d2259898c1fc54c83b94bf2faeec7ccb34f40df3511c88549703c0b361a7b0c3261dadd19f960e093f01abc235983152a9e14ca00e06d9cd19220170d90b8fad7e87b68a6b64611dce2ecf05d54ad871dd4684cb57330e5c0a8b0350e1610fbc593125a338fe97949ab427fb3ae97f33d08e12e4d3b74302481691c06fdd3ef1ea631b3cd7ad9ea1dc2689081e4f609959359d9c5c4ce268ec23f967cb2ef53af6f9d04029f05f7fda2d4a22646cc26cdafe5c0892012fa0a6753407fd671c1a59d73890f6481300c04121e5ab354448bb34d9870c1dc3d69c75abe124010becf4b456b444d0921ce64463ab12e933c971a930ccfa1678c86b9f7ed2eec857214f463b43989008a5c165b0c24cdfeb7e1860990b7135fb8319a7ccfd9a1104ff3ad6b5d1aa3ad51a734781d1e33dfa5cdd0bdbee9b26999a3f776fac94cd39ae19914e0aaa0744eb422e9b98d84ad5fc7b47da148c88926c916331a1d51c616352cd4111ba3f3d77949347b844432210af0d53efeb1ffa78d30b3820a08ec9913c171207c56a86a4e3ff364a4e8774fcb1c30c85fcab65f4ee540469e1e85b4f03a167940cb6099cbcd566e6197dd6f7110bf087ba164479c5fc203fd6c4661836b4dec8808a7597d8ccd43dc086d3c0fc87885546b21b1c58df4b1409267f82b4c196d93924b4bc5885fcd17d97b2b751791fe64fa21c1044c9b905737769917efcaf510a2b257a2ed5d197f536a009bebfd82c5a3c754fa5f365daf2a075875d92c9df63dad3f2c8dd977803a46c7363eb45dffeeedd59bd2fab8dea7a949aec59f3fcdb58610d1ea35957e249b3ffcf39491e4cf50b9fcb75815cfa3a6d7b6eebfc61e8b226b054f1347bff07d3c681fda6709ebb1f54b5a2eaa087c7a48ae7bacdd8a6012b8e866ad8e25b5d271d11a369462582a686938b79162ca33b8581242c40f8e623d274b6b030808daddf556787808c28148457a3f4195d5bdd4c60d8ab9d2add4fb49c1d5ee8630813ddd8d4ccac2bcb5d479db2f8d0756acac1e4b84db705d3fc54d0f78c16d343ea84d8e4f6dbfe64bd6ef6982dc2814e19dea1e8b442784e86bccf37118343ae302e95a26005381d43b4846e5873e1c815c18f456270f1c5ea4fb9601d01bffe4718745561397f3e132f14df213d42bae99ed8b13c4bea4fdbe026ab82c345d19429aaae2c00f78dafa8a9799486c4faf4f487c91b1f4f0de324b9f580989d0631f4f74cf6d63f9dd727a94a94db30029a06770f11be353ff5e71d3635d47592fdfb1bed6d1cb940eebca73c01c0ae17d7b9b803c7f9ed8b1e333aa6deb53a72b804843a31d10fb74375d378843ede6186da44ee83be5e8de78db31e58a1180f0f7957d4e21e9c7e5ef046f6e2bb291205ca674ea22915aa36ce9faf73a856b63e010be1d8e9f5924f6668d2f144c3f3f35614dc808101c0793877b3f53a7f8b96c29d2c7281f45450c27a3b6f62ff30bc51d3667f1aaccd18179dabeff0746117c47247a905a4b564c4bd5d1e5cfd2b9667fe657498026ac77dfc22df02398351d82f4982f7741a6fc9fc790bd3116b210c020d7941f7404a4733e950453dd04a8e9bbe48f3c2eb3ed7def4be2f172fc69eb551431ab0e9b530c4eefa7b5d5e42f7f26c7973f3eee7dd5c65becfe7387d9b2ee3f6fa907d19c2df3ec01401debfecb1d266eec8283ab30401d17d462a667df3e920ffe9af30e2259ed8967a65921988c96850e4786da3f083449086d50c02b9593441bb72ba7c1b66455dfeecaa1c79f021e3ec84c1b580d928a2e3901fcc05c2f43eca28fbc12c3c8a33a0ab94ea3e53f52e270c024494b9010c2fc945c5e11b3641c7112420be99459fdc2cc9fdb7336bd5e13882d6c2954819a04a05861710c4eef55992a978acbef0e040a0408c836dbdbe4061a366c36fc6068e8bfd9c7ec889af00e72a81109b0482ccf257b660ee7b5d20f85fa8abc3333ad29e1a70f8d2221f6989fed0a4951e3d663374e388ce0dff6fe171507e53cf8a8fd3c85db761ed251fb599d7d7515a657a0e2400f20497fe7f51fbd8ff9b1b8c67c145738ca58c57b2cf38506a243370a3c71fa9d5637a337855a8b78cf610613c94c419447526ffe84d9226c102d2f29daba57a780f1831d10264baac003bf984b3f47f18e37c37cd455781d7b3a6de687af9dcf18ba8086f1228f9c49dd73818793ff97715ba3dc67693fde399a8c6f0ba498ba420cf2420135214cfdd89011f710fdd80af0f288f4061b62dd24175967fc9045203f01e7ef298092ee97d64b8db07fbc335acde38ea0e201f83185a3efa0d87aece6dc907365070ee5dc5e0e7c5034e9fea5a804ef7eece687d6f088e7adee2275b2b888bcf0d510b3ca98d550fcfb7811306d8c9bacdbe6109c66355965bcf819a678996009a8e8a10b41176a1e368bbef54ff0a128b2e8c2d4a52b31243704101d71beac519ac3f10aead0e9ec6a5e4550fad8c54151f35e5e4b5bba53fcb20abc57c413a2607db266d6b5be8511dd1ee54bf7c83313acfa2c606305f0c701fafd50b58188ffbe11c71f50875c5e9201f520aa7f0b6a9dada402fbf6dc3548b15317fed91cbea69c8fa3a1f426e206c5bbb3f7506002824bbc2b834f28bbbc6689fedb14d6e14ecafa532d10b8f328a1cecb28402affe93b5664f5302a76bd085d124d656b6ccab8b85d1ba21c287d68a1284777de096be4ca8f89e98e4ed65404f5293f966d179300708f97c7c2ab961d5e1202afb389445add2318ae66b554b8d91332a782e4e49e6a473fb79e8466b34e16d8f3e4864a31e53b98840a65cb50c01c8030c7952966618d8a530cfbeb29764056f2c168efc00774512338169e582347617ba91bebdf60ac71b8371066e1b3f5573d3c5df5641f25b57fcd4b572f8a5a9c9b5fcc57ba58778653173d5fdf71aa87e8a8e7e8a4baa0002246c176efbc41d425ba12db094b8e64c706865931268c3330fad6effc93ae9e662d2b99ce5b51c1fa265005f25f15346528ba902fd30a0e3066b24608d677a850a14373b904e1c38412ac7fe332266b245e166301a26db75baff4a675aacfea15b9c64cb9add13b2ceb5b588cb3e7732a8546d53321002a384013319da24ae808d02b761033a6ee1fc57d430c54b4a0f8689c344e9ee9e5a383a832c54ae5e65dab3a16fc56f200970aef5687587c055e35a41d4af49dca9425950c7b03fa04eb8a665c34c1802e257ef3df5b002ee01a709584ce6e7c230ddade4691b50622da9d0f65cb4bcaba29b902a2da60eae7a467a9e71ce51632795416d279872e267b26bbe98396b9ea6760459fe23eb1af443f024f4b47fa5a0b4ec2766ba9e5ac8701ab033b536335917aa21024947d324c04057eb812753f8b77fcb0b0d490cbdd5c487ff0c1b916fb1620e4d6353873bc7775b755626f827352dd3dfcca7057d05e3db356f8519708239e63ed51035742498451878dc444eccd3ab5775b6450cda8742de5f380548f5e769fdab294ab3b4356fd91fbf0a8bc10c2e7ad3e2e55c92156d046af0571d9da3b28d460074e35478c0df8d7902e12012f8c61454b8399232538206deefedf20b0ef564a4eb504bc379ff4fbf80e38d5fd03f37a8cfc3b853f7546c879aaa6d21c99c9962555dddca49cb2715cc86f28fc868ee023dfc724bc89f075d7af1d81ee88bf4fada419e2e6c016fcc5073369c186f4427417e150e2879c86112c13f61bcb9a97368832af2a9e06f182ad3556bd93b434f03e8bc507dd231d7d56de8a0de4474318f9b7a613ddb4357ee4b37be0333d0f2c8d747ec185dfe7f69b9084d5b6b53910b01a74caedcddf79bffd3f035cb1d900a38739d7f45b29e9f7418fa07353f7a3ff07025d3fbdba2621b6c7fa0569e0a74292fa6d792af2b25f804176651387b73b181ef324aae94168a8f4f81d318f06f9ffd617de22821bd28d1b9017c6e7bdf0ececfbf18fdfd7bcffaf2bbadb522714c3d67e7aa12bd20299c20507abc7e2867ca6b39d0c253ab94ad8ccc02688fc7a887f802fe5f5a8c284a3be640362fa8af2c55a9ab38e923c4246603c39521a751d04930b043ad947b5022617dd64ffd8982c3dc153abce2937d5c544994cd69a2d54302e69e97a99e9f42ee2003dee33c67545c6b4e57b6284fff0344c7dea9bad1f014b335d7d39e2a240b6183e17dc9a0db7c17ba5cdfce15eb1f0733d059251e390353211db06071e909907af6ffec9e52e02eba2def6e40e340cdd5cf4dbdb1aa9c3c257cb22930936376b16ef0507963a54570e8f02c7e0525e83430889f33ecfb024ac44cca9937a9bb746a8ccf279e5d7f748d8558a774aa7e3f2803f86b0715d49345fb36724d06de20f8b0606a18451c662bd35601dce441b86ef1907022ae11a7c87341f62d063e5dfd6be5dd1225101f5412d340003248945c9fb9df7fa265e84679e600a1abb15c0dfbf45c050331f43675d8ba296ff00530754fe991a46137c216298df5706588bfa80fb779ba20a3f1f94c14f5832e6ee1afe190a1708c773796878f9cfd4b5a6f6ef531a31ce784f5d531c9ae1cee7c6b611d17f328e69953199c48cf902f5a206865b5ebff55090c66710084e8f0372f80c51419a77d12b388c00cc840428809a6b83050a2a660e3e5367badc8572db4ee333beeedb0139d72e103c9d9a03ed7bbdca9d9a06f9a17d4eb714cee7ed62df778772e8a81896454a1cc8f58c34e3fb74a60b19691bbfa238691c624279862ce434b8ac9e786734e2fcdd8acfc085860cf992eef37b5def6085accdf6f284a824984cfa1600ea710114949735afee0951e9fde04f09761c5a8a6e9064ab8f69bbeebecc5ceb070af858e9837c0747e4511542e21cdfc99556051ac94fa44ec01cb2e14b5641e5e33a229dc858246dce5339f74ec46d44a5e1dc8b45cb5b51e075c6b40d395126c5883bb87a4c62cb13c2b7d9a25a47afd0de4122c6d15cb4578539fa51a43f1cf6721c770f8fa4e41db134df9fd1af59a4b74cadc5c3420aadf2e02024780ddd1e320a1af632b002aac3635e75000feaf41b5758cf62eba81783bb7a3dae55af842964ef46d1747390d3f1c80e774e42f53fc760e7da7f097fc231942e06a91deaa8b8d18316e7d610a1aa27a73a58cd04381e30222c033c3205769b4be4de8545371a9fc4b2626b4b165fa08a7d0262ef024a1724e06077f1b54c6c4ee5dd9dc6f3e6a22b17df717326f689cd014fbf1e14800f14e1d4b04225288265d303ad3a167951599b43ae2d0b0a111cbebefd654926a4774eec0d3b97288167f6bb27e0b96a0f82faa8b2e13d0d4b8301b16aada9478cb8539d3da5797ecd60206f6295dac05a809b266ee39965116d346fc8aa4e2ea0964d18336412a14d1fefc763590d972acfd70e39900602942324b7ffb2142a1abc461dd50717125d06b953373f88bb64c6f72c4d5ba14a740d68733a11c9a22f386979ceeed2653c5d5b13b61b8fb3c67560a0a187b443e4fe5aadf7dd9dac47390c4437569894e779df2b5a7f57d6a4ba449ffd8ac9438e11fd3c88bd327378b4dc410fd3c2358455f1a9bec3241dae84b3ad5b6e847c370b47fe2d82feb88387887595ed99bbc1ce21dea7b189e98eee403315b48fdc1dbbeae94f72c9cce4d8a6bcf420c57bcc13265fdc9ab4954f52aedab343de063298f3ae6d2cdfb5ddba3ea6e27dfbc07cd807f2f2b817e6cea1f9be30dc53ed779730973c903925c69df96ee75ad45c9e01bebddd27b72995eaf50f70be3c6eaa85dfaa490ec1aed418531475c64231c2eb5fbb9b070da55a27191703502c632eff3fb6e8fdea0fbd0866568105b609b9806587af021b0e1f2f827354369587d78b5e7a7db95e2146887f4d4ce1022c670f269a2abead3b17199fbaf0ceed703e06d6e56891d6ab642782e7708917fc252d0aa663a8c3e63d8b5deb91f1b548e56c0aa7192e82826544aba0bc698e10cb4e9d1c0eaf9bbdea40ceef248bf896f25b40c7fa8b762d7572d197f4ee686e018bbd064f29f2dbffa32ed90726d183e05cfd02a84767336a1fd7c23663815093f2ead7620cb68f0760f0c2d736c9fa79322dd66f5068770fd7eaff4da3a96c887ab32f2d00454efd616e464a4f3518491fc0c24d2dbe0acca9aed5fdec2becd6910dde915dd61956685374929a46573a2dc0beeb81cf90f799a1adcd1324f547d5650978a904bc17270f8dfe584f6d3e8c67a959eb2ab7b952bab14511e45922a05547d128d1ec686145c53c3ddeea28a36bf219e18a95800f6231f833e113c0c832e21bd480e6a906eae3cfa060f8831e3856be25caacc7f8e24f9d68a18cc001d85722fa9463ac83eb58945d778c474bc1713df6a0b7a00877ca660ce3842b31f2540288ecd9f263d6d4c5d7739a968edb4aa81f7b945079434c09050ccfb2052492239d0e509590c731dc1ed1596780c94cbce128954f3ed4b5f2f16a280d1c5a0ed3ef01dd9ca46cd0d9930076c4a36f95d15e4734f7473e9918935b63e9529d79562f4fd9876127d95bb6c3400fa97d2b756856e6ca37a645c25da54aa1d785afad3c78f5763e4af2e1b038c02e3e62dfa549d230206f6db499367703bd96645701b1b82f2dfbb5fedad839168767f3ccde49841f8d901be51c2369ffc9b86a7b57b58ea47aae7996c80ac16beb51ec75a8fbe390a5f1d566c03947540a3ab66f7c0578ab3c5cb3d1b599cdc572d6e425665c1122b3cb52f82073c679d6f8ba987c3c56c3aa3d9258e10eb988f595fadaf7a8fb714486cc032fb53824922ec3d72f13613dec139e19c86297f5b1b80066a3e7c6b3d875ce6bdd0a5e4f59512ae4fb5a830971e8ac84609f2ebb0a9ac0c1dfd7d7e475497d42c11a7040ecb5b9e4f9087bcdf643fadce4ed61e6c17aca59ea785bd7f4f6f9dc3eb675bda3269cbffc212d62b0920a4a947815ba31b22a7068032609208024fd1420b86fe928dcfc91cdd7b306f70a6c75397da793aa2eb240ac0499aaba8ed640acf6ca08ba70110fda1c68839b2796014ca340555d0ea0bff51a555d06b2453cecfd1c3fe040457be16ebc0d967fcd158437846a4e39a6d094294b018a2e3ac7d59e105ce86035f05c938f245ee1d730298cdbd17c55a4213fa39ea93efaaf8e0212750ebd525b97b5eb24dbaee862cc7de73d9020c85bc78cacd74e6aaf500ccbb657a9aeeee9819824ef74f6558fb850570dba49f38a33510ed58d40eb5ed181a347e8815abf4e7caf5707b9257554d49f0f950c76b047664e448687285da13d0eb8850b5fde767208872ab4b66770be68a5594929f497c64a65d2658f007b70c17ad8e28ca3949400a8b369b57b595bd78a5a56e12c58fe22ab7b8a15bfbc2cb33c4fc03beb67cf206bd86809d09b7d98e669c3eb26ba485f8d5f794d0046fc360aa4bfab02a50c129b7b390b56414eea376526659e01b9f1b923965c25b1404c98bec2b654576aa70b30214b4c6070acb71ff7e8dbf145b0a912a829940c6ce1cb2e8da003060d50118ba6de5946039661342c445000c91f4bdaa7a343befae0498e685e8c4be658eea3c939322d3177452eb0c1c2b39a13045d07f336216b33435c79aba815469009191840ffb406c6fb583434b3643d5d921c4fc5408de8e16430590a4e6681532cc1690ca642ddfc79104b053e859b4645a9f9a1fe4b27c7f07532d8588b512e0124326405eecd1c5377b22619c6e24f29877f6f36a0fcac1a7a3f8eca614067a55ef421497d32506443d5b1052f479eb164e908172796206286dd576049671a6ace25607663c262a0a2c06cc0246b4a1853f26e53f00c5ee4e3cbf2940560545c9ffdfb9c60f2daa22d0b2ac7977676e6ce159411b00147a51a42c7f7b4c9e12cb0109921cac212b9ccabb2e7b10e17f570e5f2b2d95a9e511a246461eea60dd847b70645d1eb8536d01bc0816dfbe3317f74785ced5409624fbd81c53c49520c4f0ac13555498f97c38c1eeea51ebd20fb2c126875911478662a22565d50071a8b85e560781b0b50a49783212c8c65af3650693129bafbab400a3790e71d65a16d62a00cb3e64cc0b36f22d665a666f73e28f8accc080cb490b026795f3ac4a49995f6f364a2c1c8e4d2ab97c1d2faf12f4ab92d8e6b6e35e2512f70c67ea236a05c55a67ce2e34ba708f324a21ef50609567d910cf2d0079b6418a758138f755a1e848d198b9c1a763f244436aa7305272fc5a708df17fd982ea707dc08045b9a2cbbf2a8a9f3adad3bae3046e42ac0654b468366e2e88943cf33a363f29e51c17639f5cfecd9916623415abfc58928428978cfcdffac16600477796885a2e3eb75ede17cbd1ee4d2923df5be3e94dea46e47261ff987827c74050368e6acd15aeaf17b8301f60905ecbf50274d27dcfd40cec0fd189d9ec6fbc1c61d593ca8701bc32de304eea365189ad683195fb42b7c62562c4391b33eb960df11aacd957d11955671a741af1fcd1834ba832506110a51453387c7d68f049905550120684db6093fc2e376ab92726e944272f92c54ed9f108de09ee8b8fc8762bb926c04e459b476d88fb4b9304216b5c2f738def7589368849250026f14ba30e2073c2b83d8f75f702318a42ee8aff18fc6306c6f73e39f63671bdba214045c8c508936db83d8ef349b7b12aff222a08295618f1222b40a2f30b3626fb3930ec2c8445f902d689761d7b71bf445006e3c723c1a40a505198e6285807898478a5d12763015ba061bea3341ab38faf0fabc9b8b1232c2ac4c5a37da047491907e910ff3d82c66e3320283ade7b87a0fe48aca078952b4af222fa48e8a59577c7a9d49e0a814ea0b82d1db792e2a218c9a7dd92f69d556eac2a221d430443c53dfb9e766a07821edd4bb66400be005511986dc2ded50aa9fa4f5a4c466ed5ab0ae34a944f40a6c06d4862b848df4b893deabd4920a8f9a0dd99345a665923bf33790b35ce07b64b2e8f3f6d2aba5f7e75345fec4630164643cdc5f41fdbfeef62384947023cc67375febb2cc75e5c83c21424a5fe24a15b511f98f2981306628ee197baf77d7830c298e7df2744913a80056b9d040aff9af96896fdaa437b7bb82f64e0ce61aa06c4b6634c180a6b0da2d68caf2c1e633ee9cf704655f48721eaf962494d7cae0e7fe1cb00eb4d298c873bc6d761568e661fee4fa06638fc86d5cf25a607ed1d53a40109cfad398325e70afdc48ce9bbb6f093890f3967cc2f6d9b111b4689651dc209879d00e4e68538da47a9f067d0a11f1a0ea353cb93a4d182e363d673b0d3a59ef13ec08ab6c4898f8496a8a09f49e9cb728284b1844df4629c47d09c90991d20069dedf75f889fba4704c0963e27c7f9a4f6a7d06162dc6ac10cbc07f4fd0e0200f34cf26bc24d782d0a026e0e30e8445e9390da239ff4f00486f162c45b86da762ba40fa36896bd03b190a50a06b04d0a05ecc379014f4937e6c98429938084b45ef3bd2efe03d19879148692429ee40dc9bb4e476511231e930bf054e5474032daef52d61adde609f9a84973890783277862188dbb69a8613969f551f6228e2714fdc8df000ec92a988d1882d865c8ccf1ec69b034d2cef704ec510890e845d099d999060f0e96b5a10e88d556060745c338533eb7d0b838116e555818cf009735b56cbaa26ee2cf2b4a897de93cbdb0d1453af75f5abd20e2619e15369dee064b555ea1113a1e28c6e516ef465823c781c9b073600539376c9db1a829b1b0e4db98fea241a1d81857194f9f0e6e52a1b9b09c49f46c8b08623865ac8042a58eb62ad996032f86fa38c95a5951aaa39674f83f82cdae16468429e2c3282c63ddac98c38666b076d704dcb4bb72bbdaed64356a8c56000b5453fc80ad84021dea26fbc9483b0bbb0f993408918de67402877a453224672508dd36972c00a78adb2004df56ecef3139d80ea9c2c4099563738dc152b7eede3413f938d53a7c22acd1db359070d4795498c8cb2330a5ae21e56ec9d6d66dc590ff49c0441879826cdf5d3f5d89c8e8710f178e135bc1ac8cb24de7fd23d350c2eda84b01a6214a746efcf0dae462686219c3805ff66494ec4d69cfeb7e608d87619f9f3d5ccbf019e5d228c6a1d9a15d902b60dd4a6d72ebd7a0c0eb6710e5ab013f0613faa090afa930898c25cc09528b44030d2af60de0c8834a51370f849cfded966dbaa61bf04d1b1d4fe485f1122b3e6252513bddbbc5a3b5264c759a49941f7d7e214586ca401cc9d4d4dd1bfaaf32350fc6486bb0d22d0e8851afa22dcd0dba8f3d0aa60190169b0980216f34252187a5bad08b7b19e2a2f8e59233f69cdbe925a2e8bbfa635071575e30fffd6d2ad0dfc864ee86d9bb14513cc8202aaad7f82120d525b00626a906b7d852c41a6df1c17bf1073e109232e30f3db957d7e7566b7de694d0c673754298e8765a9d97976f44cb0773e0566740a1e0489d405219a1ba19fc5cc9f8abef8b7423862d2779b8e9abb19b109dec7b5079a253609afbbaba7879a03da8612221f0c8a2c4c3d204cc7ab3a8f1965374388a9f7a94c1f2cf022b3fb5cff8c0a35d7ff0a51d2f902a295714621d819aa7fa60c1ed787dea6ccb3961541a26769039be9e9ee6b7c0f1469ed8030f9d64f63094c4ef0502b20f1fa9c513e65e66829b1e7936b18e9eb9f7c180c80b025c96d49c22feae016a16650a5b099f2c0ce4db4bf5b86c97467cd37345403060825cd333909978d93e57a066ad6899acd09c5c517565202812342cda186889f80391cd41a0799d657388749462d9ce25138161b505fee4938ba17770d04c3b689eecd51159dc0c02d0962a71e14e0426f04eef5ff5b22d4d1cb5546b1a58b26c0e2c2b5bfdbe0992c51cbd7767600fbad66e6c5dd182681fe9c613d68f31fc00bb00b39c681e411b2396d125b852c2e0adc29c04541354499feedd46329229b3ffd412ebc37646075fae66368eba2e237ba646c61e11b8e14e1fcf9abb1495bb614d1d45390ae4414ccc2c991e6b0a1c6fc20eb4e2c3dce8db1998ceeb607321183e4ddab3ec49bd2e94de4965f43aa0de3b6eb7632f8ec3d8ccfeaa33a502f7a015d0b79681ca9caaba5ad6d182d27101bf14b5b0786cca9a3ba025ef9e5ff4df7598d0462ed92cd46a0bab22793148cca27b85b1ccb470b05261f0c3a39c4406de6fef7f6386116ff5b0b5b56b752fc8ef18194ec4d799fcd0c0c6f61ba22ebb374a01783dee533df1095cb6e91d775bf1442c8ad7ac447768f39eafd2058ab8e91e2604e0bf82e4405b386e92bff7bbc11f1dcfeccb2ba3470ee5fb8b9ef2f550dec104b991c325075686ae4284589c69a07ff948f9d9e4ca544022a7f6279ccb2ed352ad4bae9e6e65e9bf34e6de1941209e93bd3507acfdab285d961d473b7b16d9d76fa0a5adb04373962582c83098551d512a6baddfd23ea4181e401647b799c38dbb9604072d617edb9601cd7bfb6dc912f96f8f19de6a01e4f61806d986737a7983be290e3b417a45dbabc81dd355f38084812ee0e2fb66159fa67aa63efbbf157044ea181062b9a85d29d26de6301ede0d1c096a9ac16141850e834bc6905c6ce17e12c0096a28514463fc576be070ac037da5e30454d24369620b5dbd3b4ed6829d3060bd02b5a9fbe10b18e49eb926d1f2f6cbc714cf49c2a0046c6da30713d62f44dd7d71e53bd98a6a86e1f446c325bcbe1290d598476aa1a3426b62a7e248559bfa573d03268f9d2a8fda8138efdf7b7276ec25a51ed1567265414af8631dca963e38631e93df9e6a5be373a672760ac6cc6d5f30662dd7de7dc7a75784fc02bb9fb157bc3b76d9027bdd5e195905163149d795bbe36538c00287f67406191a462c6db3b3d62740d181fb6a7697ddce33c50bbe574df0c624085791db6a8fc3a482f651fb613f562eae59d23f3dab0dd2cca8ceae4cdfead67e6bd9b05a2c82b832e1bfd75c1cad825e7d2550b274276740889b18e5819529a98047cf3e73cced1232151afda058c6cfe5bdbcd6a230c3ec0a63b332769a30124806b1ab73b7945091b308a3c8c7c452a6ee2526d2d1d043518282cd1dece5b1a778d978ae3a1eab2b96352fb124704ff7a6e20f3da9a1a6123f4e984d33e9517949eb17da46825c5a83e4215446dae239a015512a7851632a3a202f0ea8f8b186f4356c6bfbdd05a87e0e67e78f713334998990ddedf2000d18093088372202e96f22ce482ac68c11d239c5076952be9548dfe642824905b24ceb58d49995ae0214b655630b44473c0db8b6f4f15160d936cb6179b43ddf380acaef00875f0de106c747a3c88d419fba00135e3dd579a71346f4ce33cc2d7a9dc1f1c88d2d585d74a98a63945003fc6f9ff471db7ca582098327f2217c099843bf4ad2f82e12542fd4b2900289a3aadf1e81c745db4f50aea27a196057d68c0e7d450f4ff72a460a512ca60a06bfbb4ebfd1d844c5a9c1c5180177d86d40efd6ffdb47310cd96230babd22ba62e5fcb879e39193a1abfafbab906f6b0c14fe2ed9f2f15e76bd84d2e078da2b61cb13023e941725d6ca63446eb370ef99098d3ebc9c6b2e5605a3aa24434ba202be22bfc9c10ab01f110e0c7dec7ee0673a087703cda24e68b33df6592c62b3aa55013a49306423b269b8db14ea2ed051c839ac3c5b57bd01d717cc04aadee10dd53e30040728e723185b9bc9c9b813fca7b9d8f0e06b665d1add0390f369e31f0034e6b7f93746407abddd81e54e05c8167e6ee2c21a5751680d6d64ce0925647a50ae00c9434c80bc34224273bd40722b3680fe26ed73a990f20bdfadd20612340a0f8dec82262bdd910175c53c457f4534a14351a4134c213965c8c5fbe9e776fc1abb9c9072af9616d2e934928cc6b4d46ce86f6bfeeeaf059e3c6c67b726f3ec960a74dea364ef2e607e276bc10512b6add49da43e47de84f6a1686cae93442a740109a251e70463d79bff20f6a8eb31238b7ad0fcb0f425a1bcbe6a83e1afd11173e365ab8b9191c1b70eb3fb979fe8a4f0c959993c44e68789a89f52b2bd3cf4d5a19bf85575a9c97f5f66adcdd24416185ee936c340738f68e3b4cf3b06ffa69a74a4d62b966b18387311fb786d6361b53a2d4ecb7e759011afa0b6ee86103548f48017d5d3028df992e21bd264b033edbb0a1f2f70f6323eca4a85fc15e5fac1d3d047fc5e762490255ebd8c0683976a6f2e6451325d6e08bbb8340a3cb871b26693c6796e268d926e5d54fa1a8ed277989e1fd86b892e152a106b2d6417e4566540040ab1ed099818015dcee788d7ffa55610d63a31507e66397adddcc35d9f9a82ba9ba4b5b1e0731d63fb1126b521fa7d758c329226f029ef6df9ea5ef787b25ffd3843cebec7b7111714e06501f4740d5ca2e61a24ea7f7b42d9ea8b1b38a8e001d706326a6015e3dd6f77604c0a19c532661406c4905a5cd5d616c483c7d1363dcbc505463f97652e08ba17326a1e807e3055e7b2d1ec775d54f668799a9523cdf8d2590f9bfeea4de6c2cf8c3a17334da1891d57a9c42d8185e425343f41a0ba3b98ab9a4d003e5d0a4f0109c5f04c6dc48a289cd85078539ef429297428f5061c65325528335a7b20c867f0ff38dc455b583bf1f4d83815e2a96eb34c966af1677e36d9bd6dc5ffa9314df9a1c9e5963ff85f431f4734ce22d3a8be55e9ac810016573ac31dee82810be687d8c0d45d439ff32c7eee9c34a55f6f20d116701b08a3d48aa2b99feb410a90abcfb328ee655b6f6f2de5335e95069c10613c8bdd392d08e77f629cf6d068b19e4146e5d443b48153285d633f9d1f1484c2dc75e62c4923b74f392afe401f215d81d285dc9aa5b8bfb6f43eb2633613a4539e1e5dccab933bd410f11c14853c60d2f73537a9821d230d7ea0c52f75ec64ce11d51cd4f19a5509c462d18f153d5a56a8f9d867827d80eceb02e7d439177a5d3071049762228f7d6d6af60f1ed7b4829a2d053e1e683cb2ba12ab57227f894ead70204618ebe08d246c52d11cb70f15e698302ef7b87ce31c5aad0a9090aad6589160caaceb93e8299f27e5715459967f98e577a20052c2bc96f5e5a4df606b05dbe961d90a68a71a55c31d8903d489d7078f8a9c683ed70d4352430478fc095c57ef58fb322560a1501ad71b809046a763b8c70a43cb983ff2a7a1415c6b07e991cbbc1a7445e0798aa6859735428ef049363016f4d988105cd61e3c9908c4676badc587b6bd1a26105057fdbd1e699b9a9b1f2b12c526c2ee279ca7dacaa990049e7ad63f0c53a9914b010164382c2f9687fef7b7af337077beb9d640a1c9d9cade1a972b1ab129efcb9fc912a52078d03f98cf330c7afb64cadfab2b93477788b52f3184fdb6bb6f712f86982c7c1eb2803a4362f3cd218e2a7ee80c7633ddb64b087092351ae700b38b5465a057e2e8efdddfd47a2e367af903a313d9a8df4dfe203169e7c0df1f881c4ad6ffe63d2a1610ab2b147b47bb9af58d3deac4771d64a9eb6e89e0b2cf20e683958653a18e49dcd69c16b36cd39034700d28eae67b15f05356c3f3d701ba69e71bbd9ce66395f1915f92039c0135790dcd492719bde78cfaecde9c6a93803e4116c52c67bae250e605796c7b9cb141cdbb8c85aea434e8388f9a84357182de00297eb62e88917fe1b4b5bab71fd839918ef48d6022a5cecbb706b92b56e1c9fbe49b9405a88a2584340c594bdc492908ba41e7479c479df6d3f6b75ff88a4b86ea6976868d66378587596ce93faa25c66a837795c27511c4cb3f6fde6091614f4cd567bab274c4993448de70f80044f008c76ce7174d4f85625fb4dea6f5b45a28eee96122f2d3fcc4ab02663687036bc3d9608e9ccbdb0773dade8cf4e911884d9f1572870cb913caa319ab42c45804a468414f3d40113d1bb04950bbe93bf4ad809274c76ca502b3c0e5db2172b3e172e239b5d163c60f578dd934100b62fbf009bc3d78bb31b4673d7213a46da687271ecac2d04d388653094dad14c81c147f4a49ee060f38b5173b4128b3474eb3a81bfb1f5846c48801ac068f0e3225a38184c1cba33f91a0a09c61160974ed849622312589a5c7da85de78be4768e1363ed1fe5218a26ba0905f6dd7fc7b111f050e9408adf80bd00f8deafae2bac60f19ea04b664fdfd9a24b9ffeadb0ce78db4a043b8f05a8f178adb10ba2232e30bd5d7cd80999be2cdb89ae1b18450a5a40a13373c2f232e3774c9166dca8eeff625504c8d4d5458d2da0db043a5cb190829cf5d090b3a5262a181075bd071610f1a3febc70b38e6858714508a25c712b8ca430709e191e5605c79c82abe3f5dcd156b99dfd7c53c0da886e979373e141cf8977ef2fd280df6c977a83838d08558e78546c3d0a93c57338aeac138c06c26172fc4fe4b38497eec5f834caa65fe4d5145b3048fec4f812c0f66b37ea11d201dd0029783b900fb21c0327cdd166a1e1c307c84364d012ee39fe04059112dde1ddf05454a7871238e45e69645dd649bdc921f060a2de7b68a8d7015350333450a3e5cd57187e5228cc9b7de5ca5d428bd61c9fe64abcf1b43bc9e335a76f3885a0ad906476904b1dac781fa9db05a3d1391be2daaad449cabdc483a79350e909847990eca042c538c4c83b74ea1063a47112b6af25ecc3add7cc6dfa563adbbadfc63e619d9b063a8098a819cdc45194f70bfbdf7901696fc0daf5e407784c158506d370564b1a814a4a7182e2509ea139beac8e44beaccfbde739b6cb3ecc6019af8ac6d115095cb56f039bc2202868f644755abc9c21e60cf48b503e853d535f417c9171757d716ebfc30520cb4648437f9ca3963b04c7da77e5fbf4f7b63ebe14bd113afee73dad00557547482ba7a5e0c46efd5af86e44ddc5332bb1403684b537f1ad9d7da06d00ce803b1934548378d1d06cec777b0befe9257e14d327260ff3201fafdc7444f5b15c546e9d55363a75302ef6b184358c678c7f6afea592d017abff6a67ae1df8083e75667a423cf2033b83678f2051d98edd63f56d3c5953351871486e5bca5df552b7f888f53e2d087ef1457f5813ee8529386587a762adf2c802f0767cda402916ed9586f5f8bceee5f433adfe7ac1119f656aa0ccc4cb046a18348c61471f7986b2e84af3353c60215037d5b1386b6cd95c5ab37d215353bdd321fda85c6637626f86294838f21b3bcd6bab439a592784fb83247345c51894b8fc83f39b5db053107132ee40090799cdc41900f577d627062243fb0f6ac2fdd021a828b48402c46ecf090dd94978fe11bde4d40d0f00405340280df5cde43f1ed2a025657a744e71c22d25e04bc201ddd20beb8eaf32b30f690d6fa9a1a02cc626704e8b32138ddbda631c9e9620d70a3a3e83280dfb1487bcb16c3ce81a810e1611dbe675f6555d123ae87217a27095f18b47b8cb58dd44e551eb4b54623c4282a69b88d54fc6e04e0a13d51dc9461a938f931f7fde18031bef785aa16e3278e13cf3dcb712a447432570cd78707ac98661033c6fb22fd44e6adce7fe30a1e308020506c5c73d25e0fe75814dd831155cd7dde542a6a4f1287dbf9e1ea79ea3dea1e78fc8d4f20c79ba0747d187d5a132024535fe86334aa388f762eca0e4ce498d978576f0307419e74c45998ae3e73ddefb84de251dd37bcfebb579b95ce8664d7056260f5bca0e3768d01b607c11321a2cf2187c2ee4f318c7ccf4dcde900b3c659727747d2ec528f3c9c13e76208f4020778d0a3c0c51e16dbe653346ec71d8cee71630ed69b4097b9f78cbabd0bb05581b8956dc853cb9a3707edc49227656060c34fe3f60b994f6e487e1b1047f105487e8898b30f3ea1cc2bc8e78922f2ae82126b7d7af5596316c4180f1e0a1bedcda9be7e82dec06e8db6f148030b832239c6b5c629afa53225ef50b4f02cd8bc965270fc814b67f08b76dccac8d8f2650da286d6845e603a608a455455ce66a02919faa01612c9f7535ba7fef713309fad078f2e157740116d02f17f14be0f4677fc5931c5d9de49b251811fa03ddcc4c5165136e41bae56a1d3ffe83bfc800a263dc6082fe2ecfe15ef5353567a824dc3703a6afa96dd0fa395758603a064dcfc72d8c4149eded1841efe314a01e9914faec47084272cade2bcefb0ef7b4d30ea927be12b1551d2849b4664d955a381db40757e530d7b4a3f6f86d33073ba4333bdb907fa2a3a63568b217bcd641b8fe6ced657055b31fb9f037f706094d1df567f60f39850a936d0ca4c81aa4532e987c72d30f9e59ba57406f7dcd1b84017affe2f9af56ceeb8fd45a3d9bbc98545a65bbe48712be9fe960c63a25ab6a6999b54bbac29e8f1f6315dc302541a060a3715bb2f91a949cb510e48ea8bcf4cc1c21768bd3d2a12d40d01489c910140c869bb9897594601820ed3f3feccd57b7b3c503c0d930f1182b1b1a38aefe13ac206cf910035ee7e4df6755cd09454b5b642d3a21a09040d6a0c42cb6721cd91a8c894b148c232ac224a41f697940ecb4aa220f73b001efddeacbb642d4f56053e67b2e4c560e7377047809fb85ac622c794c212b85f435ad6c4884e132f22c474768b73fa5ca69d763c78ae74192ab88f7c8f67f8df8ae381ced2769d67e23f6ed00d86473c003609de6d07a3d884a32f9ccf8684652eabb3dc08e0b99f7e7f5b31b83d2aadc707f536eb9e97f682e46509262337d1e5e17c627f8ded0148b15a6764708b00601e4615de3027212e4321abfa73c622d85317c88e5d9584614f4cf23680892c1c506c11a0908e7e6b793ca49191ac00038a7775e6ef0cd5f3e3c7314ebb16ea6698dba5e947cc808b48b300d7462956f6a3aa1a49db126d2a612b3022592ca24638010569d2e69d43843621e8ab09f4cbbb66b8734fe2d8df62807f20e17b21502f9052a101e44c87e5263a40021faf533bfbe313974b7661dc2598055c55c0c83a660f9b1417aeafd372fed6a202344e15e4c8e87fb0cca3869165ef0f36ad7170f57c09cfe824b671be17166e360dd040317fa65b6bbba50083b3d782d8eb48692d646700f431793e29d38ae8df0238a4f5625113e79b98e672130b4b8a0196464627e1edfda6146ec714f906083b54bfdecccd65223ccbd07fd86870cb4656acb541007021a7bea23027c6be2f6e0d4f91d98766f042fef26998b50f52a2674205d22396a59eaf2b8c71649a8e056189c0deebcc5f405355333ae3419941c74c0561774b0b14007ba9079ff9f40c4df4d788a094bac77f5fadb24aab7074d76622e47f28370887aea4c6d1dc87d523b365252d9efb86fc16fa321900616046ad41515e26c6f49d3dd3f560ccf85aefc5c48a04320019bb596fb3c901c766bfc86757f4725176382b301b2d360d9d120c16180ec60b07436b371757f4e824d53132653417600e15775de6f1c8e6f36dd5f1e21f71d0f50dd116a059edb803cb789d03c7b431c0b003ee483bcaaeb971b072382b703b2d761d9d331c1d67a3577078b18789a7b940f17a643429b7192d3c649b89951286f1275db9475d55cd21a6796a68ecb0fb5776e0e1eaf9f2a76d808360ef6b3c51f76bf1d768c7e56df7d677018c76ff10aaec414d58fd882dda02c230ea249ae1e0d1b886cf1cd93d5318c4d7607b577164c8b95a819e4487e99da2763e6a6d55f4159f66f186092d80f93a8dd4e9d8022f075cc01b56d424518bf05fed964fd8423cae7dc25478968f5ae8448bf6134b1d89731a69c3ba730d505987a8fae1ee1759272f6c5fd112b33a4ebca4e122ff67475f659e562a66c84ef9a6de37436a4acd1aeb5725f8c6831416cabcf8c4ca3aaf2814fb5a7a10e6f94a77789d01d2b71fc9396b3b6d38003be261f7290be1ca2c1018f432c0951a0f1f2a9e1208558e4563227be3c332da12d26bdac7ce02edc29c34da7344600448b04c3ba059dddacf0be424eab0ef2cab9e4800eddd247571cb18ff6d07d1d4a2c01363d6a8d19872d748e29cf9f26b3800310769dda6ac68319c5263ab0711c9a0fbba4d271334baa9739e4ce4450e38b4517d572498585b54613a9b5ff94ddc35c1ce11d13f3eb60332962022318de3141c39d000b03d84039d9c00ba60b676d997d99223eaeb3fda3f2ff36f3e0df25c58e4976536b8b3771073a59215f4aba9c2e3e1713bf6a659c9a06ae6220794de25fde6555341e00aadbc806e442260faac721d9bacdd710e887402d99dde28284ac60dc583f0d36f1fb2aa43b8dba23581ddcda33e26dc5ae09ad356da98940681fe519bcec25aef6132e54087f437ab9d941695d9c92adf9d8d904e15246bf2d9cca2146a29b7738f71bbbaf0f9a44aa8564d0e717afefe421fae29a841dd9b1b7f6baf1c1e688d7ed23f47c0c8ce5189acdef3422ce7c58b01177494da04dd31ce7ad3ccb9f78ee1e125d2db4414f5d15c7f09ef036ef9f2e94a0f80c402f0264d44fd9226a56f229ca6c576e2ff71cb86441f1c689b06b8ceb0dd7caf85b82e3a9efbafacf34591dd73d689fec463a1f11f2a85349c7294bc99a6585c1032db728cc08691d99dc5888f081601243ef02484e938af4ed38bbd6bf0d349e425800a2e424b602088d67c8a9970b158dadbbd2779026fe1e877e036eeef79ed82f258ad63cfe5006174ec9da4fe9d22c0883be069b9d20eb127308d31a363b7844aa5c3c3e405bfa6ac2dc5ffa74be0c58ed62f1650208b0cde362cb9708578904628c80315bb0d521f79dcbafd177527cc690c702d9a16a193d0b655f8c3ab92bb22843650dc74167205404713f6ea64fa2d0b70e8a0098af23d6ede4dbe26fd38a02189654ed8c523fb3d12bcd3665345a071c6159594a84044726ca62012d9547fd9c5be115c85b1b8984ce0713415773c0a51b8e135aa4dfa95568959eddaa3266dacbd5fd106935e285a894a9d7d0a9e5ac28d63aa3a4ab7470b29b6e1cadb0a3111127f96ded162420edb795c13991dcbd3971ada597a0a4f0e895dfe518776e1e9b61939fddb0123ba5d75501ba1983b5711894ad4a4ed17edcf5fa9a442930c2630f23d80068ef6645b7724e9c3b0f1318a0ae8bc3a7c02672281edc9b16d630fd4b1d84de422a783b7ffcd758d0b04c684b4854a09b2f0a39470f2555c858ad088f6d57cd03a9e676896510c15cbb44f2aed2ac5138c3522b54cba4dd5a53bd5a02f34d40d61f254723b05557b0e291faae9aa6fc056b6473601f8a882a261567979df3b08421dffb10ca6296e84fea9f1c5bd3ec6d011bbb6f4924a73f39c3ad1cdb011847ae3e9b9842aa654f4edcdff8a63e17280597e2b2aa5ffc7a0d8ba7b45c68dff41ecc6fd99c4a75f56b616d9109c7b86978b11ac9d8c1a4e4ae280b9712024aabab8b22f5f56304ea6ab78e6a3b029d5c0a2e61234463fe89506b44a4af04fa3874c86f6ebd0ca96fabb25ad8fa0311906e00fdc65c0785d9e9a3bd053c9952e5a34ffcc5d298a35cec3cb9562123a026e8f1e4e0c3839cb042afd09d35ecfb25c61f332521359aa7f6c9240f9cf03e82d731f9f5f487c6352aac0314d3021adc555f5d30522a9b0ef1e28426524ca8ab663d160dba674e3ce9ae2b07ef3299aa251505685066cfd96aac86c2e88aebf742986220d1c260a817bd5a040af1300a49a1878ac3a36ee8c6b98ea1cfd6ec45363dc2c3881006697befbdf79629a514f205ec05b305bcc1aa6f321d9658d2df45ec244bd23699d3b4134d6c46b5ed88924d4868a64454341372f992679b6c33da8e6c421b0c969c6626d995bf139e127a45f589e44e9cc9694e482152cb9d546772a6ea3f7da6cc6936b02bff15c3f3292bb72935e47b20a7acfa2f973306ed4f6304a095181512d28c9413261f274c4cfe32605e5c5a586241b11382fc6867fca9e850f00d7f15d19fd819234b125144900aaa3f92ea7f1a8d6a5852044be2b02bff203e1dc6ae8010fa41142f96e462497f1fee7994a652ff2c9a5ab650a5a9e536096911c36215344755152ad86847a5763763a2ad7e63d0d94d6b9f20744b4edcbd930e688082c61c6b7287059e1d9511d485c9c3d3625848335f3e561f17cc916e8ed067128428c8d177baf9afb95bdce11102ed6f74706c1e4f3c7ade77ba59c0d25800696767fc4b7e17d072a1b8ff8e1dde9722eed0817a17e6a7fc875ae1e32aef8cb747d5c3538b5bed10d4b7f1503c3d288ebb33de7fe20b5c5346158d0951a211954f51e93fb15869a7917d5040594dfae7657ff81e3e2bfc920c59dd0a47f73c4a6b18ee0afcf04330f47ed206cbc349b2bc479c26fd6f9af45edaf116bad5dedddd9ca404a9cafcd73e511f9c73776fef2697d58ac024454535a31e5a8c2c94b6265ca9d53c218618328218b80bde82c80b3943414008f1d9284dd6090e2d6029bd89113257152aa8cf76581097299c4d66a276c9486c1f765de735c88a60f275953b13a9b00d3336628193daeda4b6f3a6b03577cae4c632c54293debec6a063f7919055a8a0fdfb251b19ed380dbf7896aacc7369ce1d168e2a3f4fb7542a03d134bc03ad856e6dd211231fbe823f5ad2911ad42621a63a7b5ddcca335fb10de81ed5ad658afff58d41474fa401dd2f3d5a0c18f5ccdcf4fd295dd0929b18caacc9229f752b759310e8696fbeff6e44108340552b8c0c60dfe6994273543e4785a69df1dfc6f042cef33cefdbd7f721d8034e15f0555a54a15248814853535393d89432a2787ae2a94997265331bf339f128e5fa94923b1318d59bd99a8de43781f48d44bda08e56d14f6964975eeb899c29c4fb8ac03dda4a127d5b9981e4dce9f58932a1650fe79b58ca4d2f78b240ecdefdffa8790eacfea968f9e4769ec4b560a9e47e79093ba4944c84ea89b34645439e6349e47692af54fd24a52c7d6f4cf3f000fa9738917069dd58529764cf56b117b8ee4bc8c2edfd3f2348a501dd7e1f710ec979f2c3465748a1a9f54c00a1d17957548175dbe4c81638f60046d7997f7173ba6ba89fdfcf21268f99751022ebfbeea98eacbdbb467e4e56d34cdcb4f16d2ab493a6be46efc948b4aa37e98e73c75ddc19973ce39e79c5d4bd7c9a5630a99f3873961384ea3e226a7a2f2a8ef49993eb5e5e72e94da32ba5646fe11631c63ffc6719a14d88523c37666e280f3e7fc9df96541b7295a4165a6d71c0d7474c7409949e8349acd8ececef8cb0826b0d32c74eb7bcfa18367a88e584644cd41d5391acdc66667fcc313db6c0daa04c28279192fe3431aa2ea05044710550fa8f1345ef532f2a8f134543cfe47f8df9d5919550b68797e7e525fe8ba81ae726056fe960752b728288bbd33a597e2400a1be0cad230ff29fa80c9e543661a7f5ffe357e5ffd32aa1ef05fe379fcd7a8f13d22fcd7f8ff1f7b667c8dadf1e2f3f81fc71ed5ff8b63cf911cd5ffd813f335c67df1c85166c840cb55a25e8aa6c02e28aa964b5bf958f8de4029632c4fd1b2352c5ff2104e78e28c0354dd405751dfa807bba0a7ca309f82498daa1552fff22aa4c66d52060ccc7bfff240eaf730e2e732f234b9b38526b75a001c3bd37f125d402cc460e0892181681d4ebaffd00474541ae2be4610f71523ee4bf579b5db978e163398a63fe1cab8b8870c031428309cbeffb3719ae7fe24daf8f046da7b11d2041b279430734300374455f8ac07f21280a80a6f7c8e00fec6877fe3c6b36ea0f040588fc2e7b01e85f1c71199ff71c2b364c61cd6a3f0288c3fc86701b9210001bc0922eb4f106f3c29a2f0366666666cbc09e30ff26dfc8f137ee68198f0404af89cd597f0fe2500e04d187f98f000f81f25fcea81bcc22e4124c09b200ee04f10713c2916e00b20aa38a44d0735e941429b6c9b55ffada85ba51fcdba45f4bd1f756bcaa6d256444b9739cc5d4602ba7de92815168a0afb44856dd2fb243b653dc6e6e019ec0d7f0fdfbfa3fcb04b363be34db6a66b939d014717ab9e8630b963d89533d9b08e01f1a7a880d5324505cc886398f7d33086a1612a1eafc2f97124e75ba972def3bcb1c7cb540dc0717df58d2e5f398f8b391e4beea1fa566bb8bdcb33a5eca9dcc8403be33f846e23ce78d3e4d65b1647449894c44ec0036cc9107c9061a526fe61d09295941aa502d7fd2a003c9abc05ac96bc05ac763e36af79881562613db4ccc51b610d1bb94993fecb83eacff15619a5c29c356c14f79d08564f754c0bb5ec09a526bd95fa951c1c42a78f4749c29559d7d1a36b7be609db85fe685ee84f6ca157fe9c98819df1f7440cec0d1783765defa679c2eff9fef43de02f9367e4ebf7449d1ebdf2f0f4dff784a7ff9e47f8fde9797c7f3a7d189efa1576037a5c5512b45c261e4ea77b50605b0758d27fd4b133fe9b8b72bd35e91f9c1c96252519aaaeba494900a102cb8e81205210c3d49834e121d03b2684fbc42488ea34c94c63e11a93a6a1cf29292a2a2caf32aafa577e5f3d2e9f32aabae579a47ccbcaab7c4fcba7742ce3ae8cb4855d46d95c79069ffdb949b7fc9be55bbee507cb188295f108f840640da482a3a3de1f48ff27d3e4c3ac44600625163908d5e2096419d3f1855ef17b3bbe62cec72783944f797e1ce620670939978ce4a4b20e8bc5c2c961d96091a806a3bc4e932c43b8bea27aa139ae7d7aa9c7acf2ebec740ba6f2c340e303d68c80a23207618450e5e7e1b6f6a1f2f3ac80b29af4b1355bb97befbd6edc1718841a89fdabfb7e1b4dd37127f6e895b7d3640fd761b58d6e7d651f652eb8011353122d60814cc935a51a55e2d7f62f5f4197669064ca508ffc31095ab23c2f06ceccecceeeeeccccececec3f4d9ef8c1120c8911c90d03bcd9d9bddb1b8b203e3423f18a27962cf919829f109205121a9ccc40d4440a2366109a2205480cad00c80a211560b14b8ea2348164288a228de44807283baa7852e4480bb890a17a90c44fcd071b92340144d4440e4ba408c202206a53d8c086fe6a30248aa1708a2234253f0005315bf2e467c8cf2c92439325419014418208dd6700ad0ea9adf833ede73add15ad6eec93d965504f3407da64044db5251d74380ac2c2892896242931028a2555bc000914330025d54cb08276e2892f7a7bb777bbb7677bf7328e6ea5e65094a41cfcd0474562dbdbbbbddbbdddddbbbbdbbb35318a6c3e0b850c507a77b4df6cbfa3cd26de6c37dddac6f279e38dc51bb6d971c3db363b37f34df3f6f6762729a9010fa1fc2bc3738c7065ca19e379a9909190883890ff78fe333dd2c53db72ef315f820f8a7ef091fd503fe49f56d2dda6256dd8af1c7798977b12b7f1e5487e24cdc97ce44c55951b36e0d6d6b386762695a881d52ab25252d13063000498ae28c192b2bfec38d2de33e3128d7909a74ee3bd4f729323561df09c249b757211cc1ef1b4bf0bdd1d5a40df8a50b649b19edefe19272cf7395bf837ade7bef5ef7fffda2bb54f7dee55a66eeef7b15b67e63f879cfdf89464eefd234a7e79ebacb5bd79237c30a8ca458b2e1081b64d58b8a8a8a3847c7b89bba514ea44612edbe8845ff6920224affd91a21b666bb695f9b118d8b84d0b29b98748be35105ee69547d5fe2201d107eb79db8686b9886add815c91dbb2b716d0c42b92fb9569980231379230d328fe6b1c744b4d3149a327e9616626139da1a2eb6e5c5b638116cebabc1c8b652dedf89587f626b54dedfa1e01cf4fdbd880dc261dd8773e4185547a2820a040f41aa7f87d151fa07953573691167fc27a69e13617e135f9e672d24d4b3ad49a9eecf21a12b5f6e34baf2e55caa48ec846f30f9ca7ffaf00d26a698524c89c608ad168b3565b2297317b896dbb4c9362396d191c21431e651a2ea19899db0f44c8414a1991251d14c28e64b9ecd52336488f0cec4d433522966f2e11bfe2c4c3ea713cf58624eb3c9b4d81c9b11cb268bc5e60c605e5e3ad641ddf4662e2d2cbf4b61be9a49aaff36c36e22d84d86b186a5d964be82718ecd886ff8a302375f10a8d731d833099529e6e8ecd6a07e64e2d6a854ffee616bb83fd6e4b83bd3429a746ff6a91ca549e6906833b1c307f2f2e7ffbe0fc71fdd7f3fc0f776290a98042cf749d79f9f213fddf7ec13efc1b11b7f80db0528dbe709a862f04fcf237cd4d8e385370c68d7bebc574ee7ec8c3f4369928beaf705dd4616e99afdd5e0ce35aeb112d7d6a64316d25ce3a52e7f546ee4d919ff79946a22a209e7740bf8fe5493ffdc6ca265ea26f5a38afbd2b5286e544057766d0d379ebe24ba8d3adea6d3f188a3d3e9743a4de634e93839364dbab7747af8f42ec8118de3d435a2a0dd77834968d7349bad112b5d9f5f14fc83782f7f478d3a76e6fb8276638a8e59501f62b6851cc303cafd4682ef32ddeacacd61836ff89f3e9c4d22c0726d8db73cd82e7c7d5d8532154b20d57b70c7b9abea6f8373acf646006ad7502453314dcae040b9ed8659d8db5077aed2d5bc28540a503420f1135b33674a093e12c40e218bdfebe8967faab7a6605229a430bbcbc36c9ee3f2309ff3f2a95f9787791e2e0f33aa1ae665bc7c6a54f5ef4b064c932c1fb67c384fa78d85d296959516951696efb422d2d08517683d3d7f8f2728941304ec8c3f8b07d81b2fe28dab6b580f964e53fc0441c50e3f4d3c7952cbf4459d7329e5f5c8d3e4e4f131392e683fe9abb94caf81e5d91a5ae7b7b035f3a7d75d6f403dbf471e2ca83fe934fb9aaedaa3aa7ef5b301e5c61f996c3184a157feac49a2a29e3957f967673ac811184d5b88f301d1b32e6a1943018202e463c856bed334bfb8891d08317bbd66b32e6a23f07fb6860b4f10083f3c8da2e72b70f4888a7ad69dc0cee76ce65238773559d433577fd9b36de49f9db9b1a9cd3c31361c20f8295ed0a288ac269bec221a6d224d21f307e6d3640a3893b6046d9395dea4f96a095a4ed884398d7bde37c392aa3fe581bc548d5219fba76ca31a34977a3661d2644d9cb48954fd5fcc1535bbe8710a9593c6cfbf094d19bf50b7d8f368bb029f859a94cda029e38d43a5c0db269b42e537e9a22f35e94bdd2a276c0a75ab74da1c72a739ad5b4bb37103fda269a949f70eb717e107da2f739a09e3718eb359396130d50ae1cf9f4d544e581b9934186dc2605ddd7fc07ca1c6d904035afa12adbad3684bb425da52f5e762b4745a1735e9bf421335d9335a1bd168b4179a2bb139788cbde17f7a7f37da1a5e62094eb21d25cace84e015d33b5117b05998000a190cdaed395bc35da38c9c9e51356c666666661e4b162ac1064110fcd0719af410f652056511fc0ec3adb9707442b25b5d99b9bb9b6178a1f3b156734078cae9953f07e27c238b6cb21b6348b7626b38eecb0e22e18ca3d3834611fabdf7fdd327f4f91ec461f38bc27c4f0ce2bdbc07c520decb27c8bf7c82d01b042867eafcdd0294ab98ebe58de2aee602c6948ff499d0d92dc5e41ca8baefeebe49cb5630123ca33d763847dbe0c2f6dd871cc74d1f581141dcdcedc4af9ab3dddd45207377779fcd9b37770af72278639962eab123b2d0a47f221d83065a0c4124690a307c50aa0205330cc1233aeb3e0f5fdd75980ff90816b63531b1ad99df0b09e14043aa7b91128e6d0dd7fd37c28c72dd976a1b550ff01e7c1ede83e1e63d0f301c55db6824e5f7857af067b5cd27e6b0263b51b571ddf6df7be1d8037aafdac69c6f546d1f760f82dda8da461cd49f3ce63029e8fcd261dd7ffd4593ee305fc5be316837313549035af64c24a2a5c3981cd6ad6d8288a0ea5dfd55a40d87910e837143ecca1f89fe61a2a9899734a9c32322adaf4e25082ac776c67f08e5d1c685e49afdc1a07bb7fbe60d04b76d034fa80de4f0b481fc1bd8830a4f1f828f7a1ee0a3c653f827149fb6499511dd9ef3d8fbf80b41af1b59a4cb0b9237293e1cdf0a9acc24740393d0fe44564fd9944da139d4db9753c6c44253c6513e1aa8ff2e69d26bfe7dcfa32379edfb5ab7befdbe5df9f721287aad919a5ce2481f7f1c92d71ca95bb56e95dbac2ee99697be4b886aea085aa66ec881fa6fdd7ea8032c00aaccac270d9b51032d1bd6b186354109429747fe1f304292c5308ed6675d9e688114a5f881996b35a41d983908a9492d46c3a0297ada2f29cecfdd5d13d0fd263a8201121c363b6e6ca80eb45c9a0dcb85c4ee76b1a9269ba363aac95e124ed0316c32202de1e8baaeeb7e7b9bf6bc6e75dec6799bd76ddce62c1da5efaf29d5f28774ccccbfd3e4bfd840cb55e57fb18167078784176c8d8778f8197a9be69a060e9479773218364d34238872111045b3a259110c4533a2d98ca8685624039a01cd8488848a8c8478a1fc30d18edab9e4ff264926654eef6f83ecd6d25411ba35cd02e367cf903fb5710cf364a2fbada496293545f4f62be02a2a189ffcd80e0aca485d32d2f6cc48ed791cdb5533d2116db78924c4b4a36ef5126666e6187b50d8083f0943b48f5033d0466ada8f44747fc4f184d6401032d2cea800a41af1cfd95e3efe08c1cbe5aba01951cf84d0b2675dd4b396b5d00d347eb2240041f702e1ab66f469aa49268e8a08b978d3e4eeee6e775721039224e1323bb7cf8deb3ce5846e935bf3e6ed9f8668ca555325fc50c20f5984ac9202ea620141f73dcf474f8905eaa72eebbd238e4e4d87524a757056cca9f5eb34b7e1e8f8ceea0f4b70bbbb2c8fba76b89c481d22bf9c39915f8baaf9208a154504a55c43d4c7225e607676677766676676afb150e369a106456c8a2390581f77a03d7a23120b78109e7f1e8f3c9367a7c9de259eff7f1e5fda6181679b3b7ec33bcdd3c26c6b1ff3a9d41441d496b400fa82871f9808a5bea281f2c840b3f907887fd88128a514e88789fc004d77ff719afe2939c63ecc3eb13f516f7e6143bb45a98bb5a36f5650a9dcbbf8a09df84d6e2e624c933d95e09fbf7371b04df7418fdece30b703fdcbf4b82bc474ebd4a44d7b0cc29529d746b7b6da58afd5bf2fd336627ab5a586a0278f8996d45bd24fb57ca1ceb9a47f7b759630d4fe90674bddfee6474656b7df19cd48a86eaebad18c92d4cd6773fb6fefd2adf9dbafcc06841b76288285926b89134860f1ecb25ed014093950fe0ee830ab22072fe020ddddcccdcceb62c540ad20e2c4122d6214394110314c6f6b31e0d06464440f458ab868a2429644142a9210516406126858f213daa0ee7b1c6b1e19c6318eb14f73cd6db1e6d9692a22abc74393a7d960fe556c51cb57826e1ee7799dd771dbb6b9bb4fe6cda793208313473b14b5348184431bbe4e23d34bee73415dac19ebc00721eeeeccce1b4f66f776253da91d014612417c3cd07dcf4ba57e64f0191181388c37784ec42b8a9408519188a00454f480c81731081a628914454a569820091a9e7c5794a0464407198d99d99d7dbabb7378c40a21b57caf1ee1dbf438cfebbc8edbb66d7edfdc260f68b948373898210521995008a1b933cfc9734e9f93594da8b8412d7fb21b75ed535a9951f76f7cd53a9aec6e1860e4d3344ecbe9d636418488466d76f473bd719a6daf69a71a8711ef594f4bc5a880f21351e0088d2882848e5e30272087a39a0d6666f73ccf73f6e9ee9b3405915aa650e09344b4248908a8d5b56c752d5b2dce61b444cc0aa35aa66642c4c2f6be267a33bdfbbbd605922ddc87de6cc9bd8f364d36c77936dd363b96f3fe9bee5f990e4258eb13ed0889d6b414122d6c9e328aa0f375b68679bb14de4057b98b421c3d7030b033fe2a4ae8f6b3396cf20183073eb035cba1c0564bcaf3a8bcd3dffa79bf4223639b9a7cc8f89e948c6779fe1e984f7d8f8c7f7916984f7d0ecc987a1e735ed8c5260533aef7b7fc0b035bd39e4baa49199514d1d5e46260c579a2a48d20d06d3261b174f7245c19274c4b5b33756bbde7b8aedbbca02ed70a3a4d2ccc1d1a45481a8dc6756291d3eccbc325a7f17cc543cb223cedd74bbdb494fa9c7bdd9d4be19e6b7323f3cfcec0bc1bb613ed0889464b21d174b6c6bddfddb1fb1c705c5fa57ce5cb5b4a1982da8ddce6b51729c272eef771db6cd431f55b3be543433ea55c4019b56c847bda743f25e81c3d1fb706749f3584ced5a4ab28a1deced20f1ffefe3b3c5b73aafe18d89aad66becbd4251c4d93d35b4d3f2a45a69629d269fee43852622d656a7f7f9abca8142e3745b9746846020000d3140000180c06058321915840281c2d7a7c14000d77984c724c98c9c37112e3484a29638821860000000000002a008188010df3fbc11416fc68e1939ba6d428385c039439c70c73e9987a22a438b8b27cbd3f0ec0bd2f1f22d8870c8ec036211322c125d046ffcdb2a9682ecfd7848c359941eb62eef31ea41a0e9b0f22ecc16e6be837be6b49fb4794791d7be959424e05a7ff7975cca5eda5be88d77d379a1029b74aa3b986c2e6ab6052ce5e6d389b260c3852d523674af5e37e735140f685ce331425c46ef50458db95b84efe0fd76345e183d6e036bb9725c2e9d85b0a114569fb336e135508a236340e3d4f9a84c68fbdd4043d39cba62339f6697f30b53d7440adc6af45b42a9ef1c7c420053c20e4b87035ae92f842a1980ca84a01b4146da423fa5704e52259f53c57affb6d941f5ca24f58482a051301dc8b753579501af73808271fa9c0c101de25bb1341a86e21ba0df56907a5f7602ee0ca6f61158c2e1171b889bbbf67d5decbf929e574fd363e6f34f6f033bbe9d0ce6ae59df543f4b5ad0f5cd38eacd8882e9400b8ca96134338d0060ed4598b28d11be4b90407759965c2031640a104adb086765c590900c830007eaff2eb4dc9aeebf581a4dffdbfdee4d2df10eac3c7f2dfd6ff44e8faa60729746b02a1964910da4b533abb72d90939ff7afb5f288cbc1bb2c8744846e69967ea7750d08d87093ea4586b234ac576fb484b9a2b67f5000dc66bcd8d11629fbb0868d2861964711ed1c7088495f57397de8d4a309629a1d60c37c9111f46aaa07df2f60a789a99d601eb52b2b87eaf928d464531cc7e616f056b63c4425681df837349e18ffe0665ae9fb253da2fd7f7ebedaa7053793adc4433f30d94d30558bcc756befd89445c16753f59b64fa10fed62d23c4cbcca728eb1fe505c37a1dc8238ce0b6547026e71310fe90e73d0c730e421eabe4ca58f290e85bfc7207c840ef50cf28491560f6d9d8b4b19799f6d4d1cbf5296b7227dec1b4af47bf42b52f3b52852821db91d977c65dbb011e82fbb65e80d1b6b753668d8185d961abc42463504faf64a8ccd40d40da7a643e0f953cf77738fae3b8450dc3f88744e504222eaa0c036d13661f55d427d44c2b46cbcc2279e9fe2d9e92494a6bbe651ccd1d5af1906c83f25a542fbbecf013867219334dfd11a35417be63b4c2bf85e68ec4c21eacfdefc7902456f12be23e185e177779c3f78d9a0803cfbd8dcace043d3c748d10c6cd1fd9f34b0f55003326deb343fe8dae37e632b0803713f5b0473dcfe09f2d421053924c2eb654f1ef0897079a1909bec637fee543fec201de7c8caa3ee2046af66d309015204a001c4ea0f83865337b95722c98f149e227d09154853184e3657e2f15662ebeb3477047081690e22c62b91c12207ffbd4acc6a948974686815598c5a787fb28dac43ee0d361bbb0d3e945ac7c283e46ad40634900dc1350ff6f9fac9c285b9595ad7f4c281831772578369256fdbae12c7c01f0a86554d72faead2dc2d584589a82fd6b3739ae140685a093398e39ab6da2d3aef3bdac73a219bce352b3ed8a71a64741e8d500f011dd18ea3b2a211737d0d6b9ceeec07f7f58ab2a8bfd17484cf7484d9f9edc399df64d1d8329e6ee816adedde4596aa0ed2ce129ee8ddda18fd757f64023078535d1c109bf4eace3aba2b11e824656104e1bbbc0ad1c7206f3255041dcac6317b8cb230a81ad5ad58c196afa96b160506dc04acec05d3350029c34483d9b8990c9d32aa309adc08f7b491adcf3e47a45ad764f6024d1ec84dc78dfcf17038cd800167c74bd155f586ee9a626db3ec90c8a89cc5695601388dc52059cdb936c6c1281642042e301eb352ddb5d6a7af88ca9bd6fe37567816108c9eab58f80525ddec093759e7e9ed9d5f14954a5b9ff4cb93ecea763485445cd3ea8ca0ae5853ba7ef3fef741627d1fde17d3ebdcbf5f48bf031a2b2f27bd360a4b536e4efe4ddae0ee84e3b314c11f98ae123c429195f4fdede52e9e6a7f7c0d867ae158eeda51c704bb242a5548f92743812c2124edcae58c59b47cb3a6eb33ae1aa8f309153c7bfdc3c07f5f9129f16ecca4e9616d0ae86298611aaf0939b63e3e16cc5811e971dd290654c5506ea473c3c5a1a21434f1e1dd52a42951a9923228637f30edce85fb6e42209967c60848484b5e8db2a00c53ab31863cece850edf8ca16109583c72b0dab416c0f9bda585e091ca3829c40c0b9432203828fc4b3c3db08ff4093bc61e8b02a22a75de6e7e51fe8a4ebc88b6217ca056c90ba61ac70fa9372bfad57a9b937d3aa3fd8088df73cc272f4bd6b96fc5aaa1dbe4a61720dc781225d90b673814afa0ce53140d51ef58cdf15e7533dac44f8d8388fa25a89b94f235a44935f5e75ab342908252fe5c5c0ce5700a8009cb8061de7a99d0d6a56df6dc767e725ef29978d1e62294b940a6fe088b1b9f29f3097127957996fdc654a89a6e4bfbcd04593f2ff565b9e794030d3d9d95ed54703e7a0e4762f4a05f10174f4889fe5126645622b1e311eeef268d62ed3555e1c38529359b29cde014619720c59c0d2e8f7a17493a140ac916335708ba24eaaddf103ad728f2e7a10b77b5c9a737b76026b17acfe11e6f6779852dbf661d56762db623cbf2b8050ffa974d53dad7aaf9566b919b7774c0efb0212a41dfa65e84c27bd2b5ca9ae31ad02a34c7a00db57b5b2d81f113350a10b5fbe747f8a51f74e02ab8b3a6238e47a8b877c9c63a66219e6b0e440e35ef9379467501042493ab185098993d052fb57bc502c01e9f2110c4618c72c4678947ffaf2022cc0d86cc64634f68bbefd1b0fe8a74ebadeb1013db6b19a730a24f0409a85c80e5759d0f8d225288e0430afb41c6f48c8d9bcc1d6acee1673388346128589a3eb01e6be135d13eb4c042ad5b1fee5fc7b8407ad6a8ac11778a785105e0da8ccf8b86155908791f15f11c93e4dfc2c9617e4a0b246a3cdaf7d7c8e31800d588090eaaabc54490705670e4f726ad1caacb41120cf8062cbf3e00433aa2855a9cd4c72aaaaf9d85c6f015d7001194346ce6a9411a74fc147068890c2715d6fcd06e5d36cdb157f6e206062edce0499fc2468dad53d73bce1016f06a5d534cb4b9b227ef86445db74de10271c7a88a014c344e6911240ee78b4c1621e1b1f7a87964034a6f5bb9a7b5e8d3a7931a1f53a748209e099b771964db42dfa653315290639f3503b06347def8d35d579c9e0a6fbb0978615f728d1eeae36e6da27f945cc05c8b29d2b0752b68c04880232cef1f964e66818f6d1a2a044030d23928af467772af42de8023e2f503a37bc2972e2ebbe8cbabb05f130a2f4db22b6f4452ba201ea3c16d9737a898de8413056b292d1e93e18b393624f1b6af4982db65dc955ed442d92fb2d4c44295480a50f4a6763c960f656ab6d82737c5b4764317905846e2967fd1fa144fe84e828ef904740b2d3509a15568fce0733469a0af51749040467c9d8abdf3ec86678da489a86c51ccdf20d9bba9c9a10a21493acefb89f4124a01ae9b5c36f2a21321b192b18c7910a134bbcb8a326d3a6ce1a65a4385aaf1b0b5c1a8130b925c92fdf42c98eacce4d8930dfd0459bac17a15c2275d1f0e214bb9edd2b674fb403bc41598286f41ec868fb086ebf84341617d1c820cd5301caa7eaa34906278e4d4f4011aff783948690480b6e30b670a58955b24a82f8e8a940a2cb59dd548066e16a04ba71cb36f78394bfcd1453f49415dc2855ecfdb4f42d28849ed44c9f51e23a53a25ee003a6d933cd0781ef91d7573db0f63ccf87cf0ca26be8495eb1e06d104eea5a87fab87cd974c1e626a745ef4685de7261b4496e5a49462d3b67568ca821d8f2f65c9577f6fd594ef10a414bcfaab2d96d556a4f8fffd00cf0b3fe662de8b9d178203e0c6d861d95f4c70e8913a75b38f60ab00e3abb0aaf7b5de3629a8d448297982a21e20a019fac1db5e10a33ba3c00cc301a40af6cc506deaccb982b981ffb64f97a769b91b4de11acc8ffd8694e505899da04900f87f65d37986004c1222a81ef06be634aef422a700bf783c7b3500b2398d3ebd6024a70cd67e3ed21f1c2c27668981d293d9b0ad3c9b59fa1a2b38b32c5e18ce0e5b9ea9491807c5caf9b7405f5e6a292ab53334be0f03f8d750f7f82848de80519b34628e62fbdd9585c772fc459802705df60fe0831dc399ac70db73c6a3e542e320c9fcbb80dc4a3e29a010ba6b5bf5f4cebccc06ac54f1c33407e39a45507e2cfb3bd5dc2e451e36d7e1b5950cc3640840e89bc45c0174c59fe31a22486cf2b62dec2fe1a9ac65ee04c82ae9c3946d6ddac1a8053ec01a19a5cfab8afca6f3e0a7f9bfdc03c568a5f12d166e503659993e619d3b145f11c7254b8497961848cc62c47714d43cf7f7b84e643dd1c2c363b73383393b10324bad722fc410b60c6d38b44f009ac425500636acf2d180b34acb4c72b3b0a31f2be2eada2c785284742f21b81938ca1a52f7e3dd27412434d316947f9c2457ba69b9c5ac75cbb81ced1dbd0fa701a19c76d3942fa5e381f2c0c4f274cec4458c4987c3d8903458e47314903657956fa29af88a22cc49cc08ac33a9678c5f318d4074689d12b56c90daa79cb65e40025946822e6103e18c8e9b8910e7a59fd788c31fc30d51a9734eab0f25e9090e6a26eecbe8da317d7d8a8b99a60e2dbf698ef4bb406d391976a69f7478027dd3d5db0ca93dfcddee1b8892a4ec8eb8ec66fcfee2593efa570ee13fa7d26b7d7b6145899bb7c0ee822460ab2aeda0b219cbe3d678f6e3de043e3d76d1fd1d233497dabeaf31cc47d48591677c3033e7b0fde8047fcfd1d12415b3dee8d6f06199ec55c04904dee665234f66f59ebf7ba840220fe5cbab3637f4ffa9e8a9c59da675b25001136619807f7a5acd1319ff2ce814bcbb01c3928bbc425c40caa166eafb78278b116879c98756018b8bc8a94922f4a8eeddcc4c5c9c3de741deb995dcd50da11232bf78e242916cba97ea1fcb7ef479d55209e6c48913ad83c8f110446f7a1166c44bf180f1bbaaa104158ebbad2ea2a4236f44e658f9821884ff8f90cfee783d4a161c9a0d12386d3e27fd98a27448748ec9612ba99a66258300558863ae49d1ee342b9be15b06d4a4de1246d8adebb57ab312861647ed5ba9034fd49c4971346cddb1b47501dca38fd799ac04c0cf62a765cf339815d62915197eba18fc5959dba18e731419e55eb081613cb29db10f4769ed8c796a4fa5a2f6df7708aa7ad6b831efadc91b9013ad3c4c976ac2c3894096a117aba338b63d1c61ab4e049606b054989c751eb89c4bbff00a5aff4339b6c29e421e330014253f3358bc34926ada2b54bd483e12a9800e9297e91bff59abe75cf90fa2c53779cb012fd061b25e5ce26370ea529c42a5ee0bb88961a61f4d3dfeefee4c03480c6870bcc18e42830b5bf7028eaca7d9f6c3d50378d47c0f7b354ddd9a260e9ea118e411b644082e9a92994e94e665bca2d0670db440672c70b0027a8ac42ac6437f400cd99dccb6c74089f382f314dc486a2f5e3af36915360642600f87070e3bba4c06c6840b2179d1a1003ee9842fecaabe753511835db8df110998418100b370cb6921e37949d9771b3111c2dc74a86fe276d68619a752f332201ecbf315138f377eef90c7761d78c6e268ac2b2b9a9299ca316065f6a1b75defab79ff4aaa3d1722a406b0fae6686b6ba8ec1a621f58644ac702182bf5d9b274b863c83c7c608df188a437eb6823b2049135837851a590c1c728e5b745788eb0f4b5808975b31701f4941b40ec6e8133b80ee02a69e14e7bfc1149fdfd10a62a70fed82cce1e707e32ac6a11f59ba9ded4e25796024b1c729b0e9eb1a9e5f28f7e29ea2a7f2c37474df742470a44ddf75e180414b8a10290cfde0d97237c67395e942d233be269c6410554e2dcc5ab313af66b608c2aeb861556b383ae4629ce308778595f389b974b24f5dfb9cb8ac9019650f80ed15f94c67dd048a858f6ebbfd8551b393bbfd275495eaf6c4229bdc9bc885bad1a13312a8c6e73cfb003b18d924c02af490f4e6c86d3b8cc83b8f493a2f89a22380a5d9dea0e47a68d950b697ea7bb8f1a69878b6d870f14b99c446cc67265c2c78152dd674e4ad9ecb4c76b62b77c0d0f58655eb1b1a0144150a7926bad4a49c39b6ef8af0218c05affa96b0e31ef895f9ea0a684c072c18cdb7c3a6d833230eb9a91712fee75167242de473aa6e5b35e6782982ab068a5984aa944c7e9c85bb1ed8cbb05e5d140e0736fe3b4b774fb72428d714a7dadcc9b5779e9b7ac2c22d0e35471af7d2a3ec91bc49b5b58ed3c85e415407df96cf8fb67634b8b35901f299d421f8d7da1041f09580b2babb23fb6e8c93b16c1ce6eae2c60720211843db7a5f857c7b1ac0a4a00515a138934bbf88774314ade4b2beb1ed3f14dbbe19792a026dadd2c3451881689e228cd57800950e378647520f372b9d0b866d953312e1b8e9248cc12951b4cfe3e32940a3911efe1773dc191f220a154fef99848803cb8784cb8d8c882c8bc7c15244251553d13167e196446b554053df7da43d06042e5ccb7a30b12a6e9eaa6a988c2f6748dadea5c6ee8313657fe6ec84d5567cce4b24ccd760fe080f4f465aad8147d8fe1a317803c6d2aaa841f9e8e85983d9dd9ef13ea14b104248559a6d4a790ec178f57fbbeb14601983daeaef49c06b9658d34599b596b548d7d161482392eec030769aea81d1efc9b2a77fe0ce54394775e9b9fd4aafbd44db4cc79e8787c862e9e8b3c794e9200521abc41c4952d3ce651949685340ffa65219bfdb6d9801c26f58c9eb53353e5d4d085720e2d445b17d90551572648b6941544171101571e88216b74b077384a465568801c5e6ff331bdb352f2e97a7539c446949560dd1516b092caa3603a946218a40b8d9fe36957196de6869564abf3f47aa19e833ef78e90ab46e1590a113ee67c415576651f3e91e76481e1919c35b12d2a56755b8e5a44127162cc2abddb09e09052529cc6cdeb3e58cc03cd0e14fab33d0afa33a93e170c6a0466fa51114a1f5f3768c1f23e4815cec692d8662a0bcf136a623067a60f1c9093d6ef8cec51d4b3f65217b9a9b6f8a5ae6598004943279803464c95fcad3a3a000fc1f9fbf002f3d26873b4406d6224c261085d7fc4c1ba9088031e5b0e5f1f483d7a1a4ea80da9083a8d0bd1e397ac591886f855b2de7c375f0703b5398e0b0a3440b19f3cbfae6e09f492f4328067205035224b6a4fbc44233d78f18cb43a13970949f5834c4f40b1495b8e548efa78bfaf29955bdf5746e76aca1ac9f4b15e4184ecff0a35fede4c1649c6993bb28136b88929f0dc17260419ded7ec09d8d1e19b4037e48f57d2de6ca730eef147de7ee11336b3594356a2ab2657f2b1e720e69663d3fe36882c5ce9daa39a988880b0d1ad0fb73f660e15f6ee0e6cabbf6624669964f2d1207bbca2bedc8997697472588cfb9bf14f993adec19cd118909c29f31416200e89b843e74d79d0df5c610ac3c5f6ee48889c7e1fb01490cb1a8256ff117f837ed28fc761e81049eea7c45f6d130b29c52a065645100c4b000bd424249490a1d37b6443dd88601288d22f39b894501d4c1c8b64495c2df3d39d7efb21540f646cd9be060fc7c389e023752955d64bf53cf5da8b7fdf5552194bde3925aec7d23d1b46b814bd0ab50e82da3e777a1d6b278b71ae994a0ab2e140e14b0659979a56c2d45149dc04231f9b1dfd1942fc36a95864d4fd4da580e187c3b36e400fa8a70f193fdf727ffad0d95248bc1e2ce03ec11d5d8d3e1e32f331c047cbcf737da00bc35460330e473ef7166fbfc75dbcf387be533b00e9615d86a430fba7663af55690463d2f715a8715333b1ef6aa2e0170c4d2e3e912df3221e861128efbc10eea160079bd593ec5bf4af22eb648c8b45bee1b2da6796d50512177a8bf1025f1a4da4a144a5d8341bc40d4d8837327f36fed53eb1eb9e690396539f699cf9ac483cecec692175d619371b974e3ae5de58e2dc082219fcf1f033664986f15bfdf4941b48686c549143012e42f6123f4d8be8c19c510f3b506a1b68c1eb5437dba20277c11d94bd94a671b2f0f071c5b43c3c1dc2005007022e4c1b5c45564005f5bbf67b8a09eb06ef25b36b38945730f1d903fa8445295c71b9a706212cd02cc04c9a7ba73025dfcab49faa1776fd64cc2419501071d20d37c7b001b5b0a4b21955be26d966eb4a731ad37a0b9c8cddc0cc27def34a06a00cc8edc2d982c4eed931cc894cbb3f4cff3933b7151b71dd7f132a195ab05f9e420f3f6ee5a6bd2a189231887b9bd3b46f3a7b8864df31537c50ca7500f13692fd427ddb1453dbf872dc35c36a7f88bb69668d8672b9b48c3bef9e99e9a5e1e4d2101ae32bd079e144039325070725f0609aef3c552d03e5fa17041e3825db33711064a59eb06c2f9b7e36834bc715a4dde151641832f11efee1219db1419c1000fd6f221b4ba9f31cbad579905c6ea7dbf142c9da8950065a69819f99dc4862146bd2ce2d48c2a83d5ce0b1ba64d7baac7fc7a87254fd1ee0f762e0aa608338393eec2424f6fc169a6a6969a6a682f07a08006a03c797c0ec2392813cf6e75fda81bf6c3c93e844b61747a1c5d72b3bcc9982ef8af861e5299fca2ad589ec227ca8b1030b63a8e83e4bfdecc7abcd1864be4b3b45267731dcbe4e8d9752413689f2e1c50f009f438fb9ceb0e39296c816c124d44caa09bd2161db0f8911a094c1b487471575d552dbe1272e996a0660d2daa49fb03dff9b1a1252ecaa70971217b4533a0e7e59d8f07871c69f8ffc3399cd04af434440a8c30ffade43a287eb3117bc9116626f4c1005652d28f5468ffbf4f4a3f17290e27b06c1a0f4a37760122d4c283be28dcb9febd4b063c1a5343f134177e152e99bfda3fa150d25c15b6a18c69b8a46c953026731f4721853fceac236415266e898b105db0a3121b4d682d90f44770eee7901096b539863155e3e28b8fe235e5d474b4b0529f0611f060379a3e4f37d8e0eb397c932a01ed678d9018242fe6eb4b5d36be482b957c0d11e7ac0cd842261417289430d12c5d081227d207facc291cf02d22a75087ec0d9cbce192600c32fc62c5ed331a8fc5e463dba0d4a0711a1545b4a50acb31a43f95991d9b746d162c099f7fd8f1221224a8c416fb84a589056def4002369655ae7708909b982b4e7487b6d6089d9d0a9f7bf113468af5364ff749831a6c407cf782f2f99927150d93ca91b8587ef3223f2693fcba2074ac93fcdcadb7e89ac564c4d16a83975526e813790aef8851ac4b6adff1e1c41f84ba7bdfafa026da3e291802810610d78c34329825710724dd9a5367515d5813ed59b5c8959392ed4c462537da136ee3695e2495a737e5ebb0508d569ef820045d693719f549346aa410975f73a1b2f062bdb21da90df7b420a55a0b5948b63133ca6bc586d5c4117d8f1877f3f13832b0ed040127ab0873a05d20fc06e857fd5d43400a8e6623e5253e0a8ef4d85087bde4fd177122448e6abcf6803832ea731aa1c95fdc574f60328eee7304754f625f27681a37264897c84df8cdcdff3eccaeb95051646187ef0b716d64b5043189928a3710ff9e2763b91841ce42b10489414382b319a65ceb0a66571213ca6d2f546df4fe7d8668188389035e5b435d5d719a83d8c44079dfabd196f61fc60c26fddf345c7214cb6cdc80050a7a1212e9cf3032be97285421af45af006c4a28bf674e487d13653d141eaec1b729fc085faf2d6c6f3dd8769078bbe3aa86fb8b4258f6a344a2cec17070dfc698413a5db57ab9ed6ae9850e6b8e460b6d6c08853d287950af928d296fe4bdc7ef793f811a326f74a23eee7166fdb83971e174f140f2d243c9f98a33cb8edbc18faf98fe2637196898be92a3c94aed3de3b5a30d233ff5b4a22600a5b91174c649e5e956cf66becf2f9b741132ee7f8391ca5ef43d3f45f96f64a00b50b9e087589e5c15c2f42d57e0a95e1ccfb449a032b6f75a196323eaddcc37f24cb75a1060dffbec358a00b0fcecea97d04d09a50a578f14c92c71ae60ea816c4b8daa0e43a61c9ecb19c2b557b2637445416e91b1ac0d7c6bedf4cf8298e1d57dbbeb25a25e3321c2af5803a4d1a14e3921e4dd681ce948d9ac27b82a43f6f23119b0de4ba31108cf02ec93c53038a7163f2539588f0262eaee92e66ed030cf299fa03dd74a3f0571c66b5e76f95ba204de9d3b955354f53bc7509dad7f8e7169de94c534c0cbc3bca43e853482439b71d5c67a01bd0d036d65d76e5fe1854d0e923985cc151abed7e4ae614cb4f20aa988924f0b0bd7ec597629640001583632bd388419db9e27947ba6e93427fc3082de2dd24a2546cf3b7024f9eed1b42df7a56b588c888e88816a1dcd43df2b0793856693bcf97abd227ed703653ece68694f8d2c07495ec490c722d02331b960d59c9c0fc7ae2b55c4da7ed976918924dbef442795c2cc922f031c995bdc79173a291c0e13663f964288efb98d839289a615f8ca700101a22c7ba52934bec4f54fac46b11f955469bc14bed644e40184d12a353945c624a4c04f2f8ec36ba18b1024f4b01698c1e5f644983216ce2e3af9a85e2206a5c683c013c1e9c06ef95eff5ae4180e3c9c923eaeb40e7b57180702cefb6d368de9b81f2f6cea761bc7a4f55fa60eacb19229e5026e68e0892a7dff4183db1ba46ce0bcc19e0fb994accd11e87915984c1a508e2c3487fcf240e721b0cf35b1439a51757118b1c1481c0014e1c9d78d7303623d9ee86291ff9589d9a82c7e2d28b14955a7e526b096a8b96df6bd71e7dfdbe6a0968bd9d283bc7b347c39854eff2d18407e77e6d4365230ae1fe5e3e35ed5f49ee1e0b8465004dc2d0a3a559615b511ecb0c0d88487908ad1b29f9969cbe2935093c030dfebaca2454ee37322224fde714d23e4262e08f87f0e063a0bc9fb98fc9e2aae10812e2202da38311851983a9d9c901408159b6ddd435b87e4d29698496557762d9e16bef2b71260ea3d507a08db74187c1e8270dcda32bd8a543a47b1705df594dc0d1cff4e0e3146a0fc3b0778d912e4c8e34b56ce63e880558e2fe6263a4f5a80e963e5b0ddabd64c5bb73a6cdfac1bc260447d243aeada03a64d8dd5f094a2636bf62421f8c25d20b4b26d913508c9591420143211f55929e5b539882047029dd47d7fecd7809fc434b1c3fb8a4a940e9115d2081023f38bc76faf1dcfa48b46b1e20e6915c18ebf4328ca5f54858fc2f4816df280569903e81e6f68db31796c12d24223487aa2a178297a14e4ea390fe483bb8660f24e962dcf05687402390042d30a2c35818fa9de9316b3c79627400688daccb7d23d96e6fff42d7f63dc560675861cc35f5260f6236c922dad351e69ccc0756f8ad67b6e323a13faed0408200a0fbc0dc3780b22e7677cd3b232237aac64f862f33f64084ae221348546aa298c789a0d17c1caf968d3a262a08ee9bdd7653747dcdedddc3dfbd79be29c625f919f786811dd8ea280a060b0631b69941e50b0085f1dedd87ba954b097f5cf7304b2cf63160351c78fa4ad3396b4e58de021136df7c042e51440bf92556677cd630be115e14070e272fa0ae6a6f9fec24bca37cda4a40ddc37c9c204abfa6af193787b6718eaff64c0ebe362171dceaaddc6cdb3b88d92613cecb7c832ab7ce503aee2a0a64ded8c213b91ef35556b84f542792f9b5321002197392f180ee9a78cd21cd98333c305eb1f53372745721af6deb742a1aa622e7dc1964e377dbb9d319ce33e94d11a5d211964bfccaa969003e1d533537ea2e52d46f98bf8917f57247a4fea49c91f6711361f04bcbb320dcc97ccc81c84eccf956111de122cf40fed5e855841a1b4546af842fcf0a4d1645c3fb9505e887ccaa61389e4825dbb23ba77335633c895b41279e46279e02b18e96f566753825a7fe98c2c62fb9527edde51e43ae85263a1ba44096ee8135f2030c7efaf90720e8a7cf44a58953d3d6903d7390dd5dabd20ee242877b680de21fb206a75bf68834759d4a87d31dc2719b513ef806da4519b6271411bfe9afc5b8f7b1b6a0cb0ff02895ef908066ef2609a9730be939a87ce91cbb273e7c442f724593e24b06a9ed26d1ab4a009e67cb218ca5798f35c26ca5b71a2b065c7f52070d5f5f6ce7389f3654b49e888bc081df70334bf20e2c7b2276c07dfc2dd78e0fe6f260f2205c60f882f14180ff33400f5b9badac39d18f13ae12cb7654028ba0d88209d560d02dece6ca161f31249b7282b149b84d973de88b45044d236c23861fd6bc3884989f8a667dd7226a65b7419a1be57b9f50d40c73006ea32745945deaa4a7cd2cbbcddfe101ca46c72129a295db4c91f21895fd63dd4bb9cdaabecd500475633b252144fc64b93ccd6815bbfa47e73833511ac69fd38559a9a08fe6bf67e6197f2fffe35d51b0dca43059e8e54d206b7ff5fed050e71462428f233764f9cd883067ff7477984140b0acdcabc8ed97b6c001a6bb506571f5989e750145cd7182f8217b1e786469987e171b8dfb6007d39873a0c2088b278a1957d20d06073cf723b09c01008c52f118d5886749f0625dd612e5681f8ffe209a0124e6d0df07a9aca39029feb3de5840e3e61754e319a7628628ecc7312b19ab64cba12aa665c25348be574315432a751907eee057ccb1655b97718795713db1a76ae05bbeccb77395c9318e8fb539bc6790098a7190775ebfeec78ad4fca06954db4a18275fda419023f85bfd0a2fa705d335333ade35d661170fc0898a8f0759d3b2bd097a2080119db3d99493a626e3d0c5e23e797225824442b5935c28e2223020639764006eef088eb8f57a9d129859025f2e1d5cf16ecb8a6bc6141866192d813765ec3c215f2cad6c0de3cf190d94da301551af1847db2e0796aad32049ac830c25a10fe15fabe4fc74af39f9285fc19d6be8a76e55b190609581c8d070d0f708b8230bd269ea6c1f2d7e9681009511c0c9d4394a90b6548963b35399633bbb9b054a6b36c44f28cbb1860b1fcf65998b991c981b528b27147e7000001ef66a784360cf301a1bea9274bd7ca70baa9ecd245bf84fc825de6e579c629aee8f7ec0e867b30f742cdc2e45a9edc8c890b5075a8bb4e7c2df6c7e4a4159c989d941d59451bb67695a00dc60474134656936efaeaff697739af4a57f9272a9a6aeb2507b4b536be4643ec2189681bde910fe99dca4479c6681937a77e4f1432261a064efdde8819d950b5b00a4bcb1a4eb5b1a696ea43aca006ae917eb0ff5922430eb1f772f6b97ca30a578b4ec97585ba188025fa12ada180e563e3387a2e2d875e6db425555f31b79dccb1475a24fed96d52316aaf6a5cd932f85cb107c7f9824835859b396ce9302b104951c9c736befb0704ce8f5947894f4bd204065d4faa47f212dedf21149a602d261954d7cc52a896e81d7b578b381f9c0bd7694ccc7bbe1806537cd04354c002680976308d4f637af2d4d988beee962611a905c8319e3d360445f3741e7977eda96c0678465a7e08f367be9924f75bfbdafcf078b89221532a0bf145e6b5b9454498d4b35c2f993a346b39bfe603c57969a17083a49d724b09b6e2b92adf050c6e40aa8f90d38b5bfe7a3385764c05096cec3adb24e6e29fed5199b2966911bb70dfd6801ba3288ad9728f00ebc8aa431ee24fcde9f0457780e88a57a7872734befd65c282c5385c13cf1b7e20dea9f92ea843e015f2553c27a8697e0de286f011d7de2e5f185bba452553ee65bf820a04309bd75dcfd79eae5366060f09a9836a0723c4e9beaafd9f59ef4c2adcafaf8d0446cb7f84699a7efff1d32411d807e771e2e36b7156613f36246b20cc94ab67013d613b6b38cc7799445b435f1f8c0ad3e8d2a051575de7f44e10f00f320e664aeff8d9fc5f4ef2eac3b64a6db536b18d5e135d0dcd30746fd57fbbfd3c5c26fd1062e76e9594cb2dcc424cc8145025b79eff727ddfc86b24e3bce3161eb5a3471a1a60a12333c7c49496ea072ebee09659f78f7ad3dcc29bb7dabd0b1a4233f623519f32b6604c9feb7391181b2f6d304024dab983b833dccafd795e83f1817a87d00618d12008456ff77f440214ba82fc88143e5ff403c07a82a3fb39ddc2544d7d45ed2ffc267034b3a60291be53480a266152a8a30c16789d4f90217a19f7e5b4fcbbed992bc6b064bf494888e01b2b91d04d362478b4f6a653f4b7bba916655cbbebc8bac47745b9a16e34e4c709b8b05ecc39eadb585c847a02bcc593d964e63c423e414ead3113cada04b6fd6db9fec86f951f3a7b51193ffd63c8f81dc27106535c05c26c0efa52303114f43ac43a16f757a8a9e67f4d85f1f5cddbc190dc4f58f6f6333e0fc847ae275addf512e75c638f9bbef4461a0be4eece9566d315e9aca6265c8ae288fdfcf474c3e4fe3023cf1d4fb04e1222aabb1920cc118b7f489da1a1994649d644482b00764d04064ba7d23f054957b666d8012eae22e413485bc2a8d3ee75fe0a8bb80582f50ddd3f5d6751d44c63f76344f6d220aa133df4de18d86b5df2fe00c6a2fdd0233b1849b5a644dd3fd3b3d137f1a4597402c6faa9fac072a9f9c55106cfa8f4a36d3be334585445be77da1e8c072b20d8da1d464ec5053cd0b562f183cc8d8f1a1363aac40acef5dac70985f2842507870bf9dda91dced1a5c2c9a74eb0be67ae46e4ef49945208933da97b2a177ba5525859524f4c394295cf25fde937e1b4c02441d128a4345dfc4eab765004af4a97e88343dfd3e93521815972bacb25ca5b7226feaa98986cb2a1d4fa6634f04232adfc92cebb9f66b7bd5373c4a37c323f3301fd88708c52a01201ea30e6194ff2109128b318dae1af48bf420f4afa8e5b18236acd8717fbb265a7a72bfe1c631906c4b794e707b5ba2f94d243709a599da6e28724bf5a080b193315f9bb3f268f3f0a2980aadeceb715d091d83b5f048556b8c65adebea09ce19c6a526c00f44f18cd92a7ddb288bde3c681a513c099031b9af5da8f94388e36d31097f1dd3c128b3a88d941841c5afeb9cd295752766d3e85353ca02e3fada6f6c785d63f715bbc51cf480b4861a3feb90280b8b1276aab953290e8c30654f6fd3d11a6dcd1891dc51e6a51e5859a49c7e1fff56aa0fe80d9eb4d97cfca6490ba583f388702a3a41b23787d1b4d6aa81546e6eff9cb013a3fcbcb115e3fe7e068d8b21c420dd364283e4f1a36bc68e9139476546dfda5982cf3aa138181aaeb04f7d2b2c49276e90ed4d438214bd8d471df05f61c706ceae72ce548023919a98f7fa3169d0d467f982154a0f714c1f7eb547a58e98b57f43c4c5f33f6ca381024499232988d1b58b565ab2435e6cb9c35f25b1209669968f2f587d4a73aad5eb9144dcce87c224f6e78cc906b9525cb50775048c6a36263452d3af46260b8f72a15036431a1e6830fec2f8393935609f21f119798baa429fc4a201fd789dbc597fdc1691e8114849d2451cf3772b9178fe2712b59c9745ea4b8cb103924d3b7db400e3d9ca1bfb912daa478008c21c2345ef9aface9f66000388bfadf97ac2bdd523d7da6f48f88e828bd30a5bf9e5751a096e5de821a194d30a48c430c34da648eaa5bcd34ea197d40854be0e927de87d5e3a93a8519f5b56e7a978271d207eca08f90e0197bff84adb1db5c48c1c899540f2066795462ab2d86a01870eebea1f67cf280b03ba5ba14b0ef7cc42ee7083aa1f373386abc9160c50262d10f93556daca5a180bd1213564d6bac95973d0c9519c0d8559b38a2b334645a554f2d563069e7b72e3d3bb89a89ddda15b31c30c07c373e39b5e674863b72ee4e1fdb42265febc6c16a9df5f2f8819fbf7666f967007effc78408f46fe50f619187349984d3f59c7ed3b46f27bce1d9711ce83e43a6f657d05a47f3f5f4ca39da20a6a947ebeae524270ef6fa44fa952dce8f527eb6bc8818319e73b05a063723d673108e2820b30285d8f83eb689e2eccf6ebcf2ddd63e313bcfb3e9497f814993a251420e79efef3004cd65f44cd16ee16c4777dd44abd9eb8301342b3d53ff223973471d2ec5d2720810eb5e1da51ff9d583e1deac8d97aa84da47e315f31942480d10b8e3f7aecbd0b160a11084df7b12259a0d99ddb6e606f1439551202b33c5bec2016815ed70de6b3009901855c7a3e90c515a8662bdf4827a25ee665ca178c151ab0ef90f464e42b9cfc00fe404e2629087cdb0b57210d77238fbba36f7d53bf5d302580c34805f77a32ffaaa06df248fcd36edf08567e5c99286b0ada10138bb8db9ec1e7917e5303eac1d3b7165aac99d97095718f43d1e1e21f961c8604360639657878cb8d2a988cc6fe14b4838471e93d9b5f4000d6bd16096b047656f0a3c4a6fca24b4ecfc37a1e300fa3b13b437eb3db4112ae99913a82eb91ef2dcebc719aaefc0e0301a1d18c76b31ac25d20d8837c504df01834f6a7a03d248e4bef6deb4e409a82fdbf2cc780073f4c748503d9a881cec4005eac9951d46c53b792d3c6c732168496899510370765aaa9ab611210a35bd7bfe0938d4a685ed62e1ac8a09346973a91a5a8c939eb7243388edb0db00673a351b1733beaef82776b4b567812666fe0114ee0617e2340b0d4f0d4358080c7a09a961f25cfdcc539ef61621ad90036cc9e15c009aeb6b252452f3e5d3f5d3094ef5c23e793a22fe130e3898f7632c0278ad9cf005ac99510a95d48a03afdc33be9ff03cc32c40af01b2832ea1f51d181c14b186f5d155afefd093e31f94be008be92bc005260751aa4d83009b20357749053ec65d5aaf98f595c1f185807ea0ef0ae10572e683284cf7f4dbd88b4def0249eb4f946a578153bd4866ff0ffd085d7d6768c37c65732b9355e67356034f17a9079541f243c462b031951cae285944be967cb6148781a62b03fa70a7d4dbc7a1a755c2b4d1e90b0d47d97c14c3272af5edfa3a6fa87f3c0a80879883c2a4cdc96c406b3e461c7281a6c26a1ea040428e70d2e74caa11eebbac4639f8decc0edcb82ce7b68c590a9b4dda57744bde3d7cdc9e3c274ec5b73db9642d10e3f47cccb4614017154daaa39991191e2f27352180cb10faf3cceab4dcfb10e5234038d9f61c4e06106ec690af1cec6921170f0c623e4e04337a7be0ef7a0ee1230da2734211c5da6a171237cee84686c0ce14fc6553531cacd0e40bf13ab6a12841f6833d39481fde961702522b84588f44be52b874fe68e5fbb461d716d7a9b49a923f02208ab0f55920afcede5c53f3ee39e083c9e01b997d9a6e0f04021e8678dc8f6a3648f8783e7734c6cdc9b8d7dd10a4e79435b3fe402733bdbd137db27667a7266538da8747be52d6c9909721f9b9a13bbeae1c7b014423a14f18913403b0b1bbd2ec02f1485641a9286ebafd37018471432318e0871b29d78683042d07c6bac0a083c06014dee087606b92c2e9219759d7bf85673c7a398e72682dcf681f29cb410db429081be670285e91eb4ac28c70d5a9504eb9a502f6382b9f6f77c250808b97d1f5071b1015d55002acf2f9f3a09681050c58f9b70deefb7addfc0d6b02057f60426e21f6236cedf3d9f54eba4a743f5e29d1139ea8ab6681c02bc728848c03e290bbca49dd959b82ad7defebb7c9d789696dc215215cd533684f108c8d24b2016cf0f39e0636645258475393cad28f784371b83c5c3f7772a4a9f7dab0d241694cafde3a086230b668b27391220a6af86bd93c4264d9a1b676c320626ab14187f51caf9a374a9961ad5064400834365d01f6f43405128d12353200506d6d3c3bcbc184c7defe8346c67f45a8fb83b1b679cec59a613f762c992583b577be8082fca01b3b230b4546301e02e3b389326ca9eac9abcec968451540b68171a2ec2b6751f8218e2063df99b88ef45c76447dc1c6a6bdc886ee0fb7322578d10acb78ed89f2a9a06890b80ad54e0b48a6dc8ac41c04c35019f06a57bda24a7866e461ccf5055832ca556880bd87a418065eabbd111f1f6006dce20aa55efcda4387ba4ab633d31679eed833ea693f82c6c6fb7a9b826fea1b3d3d1655b442cc4fc08eed39567688d5a10178a766d115b21a1f2e59dd32e0f7c6a0d7c4f06de1659aa683b09962e31a863dc582b2946a1de2fbf5c5aa4d01df379e4a7b78ada380cdd52ada2fd737e043546c941d1407e156953a217cf7f7711aee380bf4a8c6bdd176efec9010a614074131beec2b52718696f623212a6c01d18ed0e23c6b8bbd3fd63e531999baf804e971e1de1e4dbb439446c59f9da1b097a2a95ee30bd0b2c7bde9a7d03c46d8e6ab01d7a59e5267704fe8d4668b5c82fac7192d91a60d547b123dc8a8255ab43672412f15b0f1db95f0479fc2297017f4336fcbd9faf54bc5495a22de5b0d359c6c33e872ce0fac226d0a1fd042d0c6448282955b92cbefe9844d7cca12b4a19167461109b20552387d25d3a7ade56ebb79441d50497b923651be1551c5eac20100e88492a54bbcf211861b0e41204c5336671b5123d2317e45489b45abc79fe55e0b5b9972d21f0199994d979e8111caf33ae07d13a15853f88aee26a0460522a3f9615954e35aa7a3d9fd064951b960a9a15914e2965286d56639043f5d4dd29a364dd73414d0643a9550dbdc940e351ede8c5bb304db3158c28dec2445cb016896227985d7588fb225afad8707771f0d78967d2eb09f6efe21c8c648cc8867914ce68e5590d396c74bfdfd20fe8aa53cffa8b14b3091d466139a97c82b6caefc0ff078818a18f8ec208c20c84fb214b2fae3a80d2ca189b181d6f2a9850b5d79920069086930a0298df90a71ab052d52fb2507164f3c1b7518c71fbaf4ed5e12d4dfdbee5b0199f4b7d0cf1e237352891439c9aab3852ddd268f52ce00464f03b6443aa40e4fef5838f2f5e90f3dc05d52d8a9e2d7d279615e5eb321260fd19105023763005ca06728d2bbb5620abdd05a5cf0cc8c0c24d8ff86d5ad0223b3b243bb50ca3fab25bcdc39760c04d8f2a0bf814f19c68119b5c8f0fdaa0bf7aa75274cfc30b1672c1810a7c42a0f9ecb7c8db58786ee6a34b91f792ae2f7a19085890aa653f182c844819aeb445b387341bfeb21129731307fafed2e5177b3664611e9b805e242207a2090498f8d3b41f7b4f03083e21dcb35713fc0759fa9ff6f67319c2f6377a7a95895e2fa699737cc390bf02d15be435e2ef4eb4678aec76e69264b880090eb241c04488c94ee9beaaa43e3f6c40d6a8d637a048477170818d598394c88540d07c155a3b1baed30fd878edf0828862e5dfc9147aebb178beaedc8e3919e2b33e5493cfb79f8c39267c8a8ed757a6bbdf93bd0d2ba6e643d076fe1fbb5746bdbe755cb2a665cdfad65fc150f7058cb38e7190095fa859f9d51abddc858cd2c86330b585d53f80d717af937454e00f735ecadfc0ceff89c2a0d9e196ce794d25e8d72a55f18bdde7fc8ce1943b08721bf63789929805d48a3ab52276c320006f6ac1e0db86b8703ba61986ee8950a2ed1be38a44defb2db55393de7aa1486a1e02cfacec5d1465a63007fffc92c5af01fab2c09451eee72fdea689806842475a2a518a982df3aa8fe691cab893add33330d7e8a17e1f3223a4b0c414303b7415d90fcad51693565eb4b3fe26812a25befeef5f5b73fbdfe182f12bd73c77061949c82517d30cc1e22a49dc6198c4211af38838ea5b622e5515568b297eb1eeb2639e09582b1a3704b2d636335d85e916e08a53b1f8f175155a098cc6330e6307c7466f8e790833be31ad2bda23d935b7fa5f68d74062a8f1a18c9fb7b0f80392ad1f78cb5b40f61a7220fb79caf4b80eee42b0f6c17df375e0b4fc9a7100af0c9c976cd33a37189c9ae39d853e4e9603537be8c69a6eeff1522f4238208c0beb20ff3d474a47196b0433ff0bbe60ec47e1157bda2b753de0dd8e0784761f146a80949dd0bbf526b87879ad9320635b3bd9df280018b3dc1c65f7c848dde78b2eb20e7981a9ae7ff7a91f2a8f5ba347680408afa6b659749bb26c9c48f72665d097445d2e7e4dff201c0ff010f48fdc207837713eea25af7f158f73eb610e53462024c2c9fbe75ccea90d13bc7f1e448c4b36cfdea86c11641f7e1922d00f2f9e1d4864c91d40607c97ac8e2d8031ebc7f5ba288f5e1337dfcfeaf0d3d5a12019c0fe4c76371811ca54069801aba595d32d7538ae73707f3612655ff26c88d4cb4d8831d5afc0833563d4ac2039d2ea97363434801717a8769013c11ac0ed6ae54b034d4eb059503c60106a7e21fc60c36b599fc90ef24603d84dafd0c4176e38c3ce392f7fc0060960cda47953c2990e57ae671ee8378368294ee13b3d59439897668c106385d9decae81d59278fad64d85ca62f08228ceecdb38bdb70f3f1197f809e9a9a30a6234447e6526f07bb7d535471cc348e7012623b308df1ac4816a19b529cc81bbba2c438872b0da2afca4d3496a304c56ad403a6070ffbad1d02dca4c3b05d90f54f1d82f20c09a1e05c7bb094bbe282e06ff6fb91bd5801229eaba3c1d71676d787b026f485785e9c17993d7ee3a27d53736e86c814a754cd144ffe2283c1359bdbb09422b45c6d29f592cb46da5285927d6546b4554da13cc65ee1fa22740161bdfedea00c7466b2643f0c3005eaa968856b49ad193fdd639bfa7d1e3674c91c92b9aac2bb01bb26b0a6225e6da9ee4f4ba6dd4d75d593ce761abf0998d6bd6cd2d9d54eaced69b7423d572862cb204970875912faaf2350f53e0a0d36e159c77a6f91603a4902b2519dd0d93b259571604dbf3d55765335dc752fc94b23599b08b050c2ae0b5448f0f97dba61425e89fe7d4f692c3e57d0838fca8777e9b514e9af1ea5b4e804608a616539000d469c7d6b33ae34f0f729c360f204f912944639c82ad312c4f31eedbfee0e00b7834297eed56e23388fe37b328d8ae927b4a8efe216611d8d97d8b835619f899c9581c2e427ec6915b2d2a4ebcfeeb0bfe9f9801f4c0275d10144548d8bd19c13e712d93349e3141c881a715d76259441ce4a2195ef70f99707f86991fe35b0a36561d9b11ca3fc497f68c613581ac83b8cdcc3dd9d1bc6eeffe13dddf0f6b95c135c8fbae10b46ba6fd8b91b427cbf79dce92b382b5142dc4469d28a65ec97e83913bea81ead74abf065ad254eb6d3bebeef60a89f5a25cf5d00bbd09ad583fdd17e7a6f186f8179df9d91919469b5c82e9045c8dcc59aca244253ace5f99963aa04ec1b91588041aa28566a89a220a3da54eeaeb5f889d87c1d75796bd00f5437b901c80da7cceefa3254802e8e2d62050984cf78fad896c8178049d84be4b4e1d6a1960795bec6df3e9be32b2c7ae6d80041627b398600d9eb6b7d3a25f718d40b5f18f5384d27782b4de90bc418b5c232b1614e4520b9fa6b47f5700806530b95a170921e1a53c4fdcba30f9aad59ac8b28710208d5860a529e1a1ae1208dac52ccc0dacdba22230d71b63b32c857fb1ebfe939d5fad572ae0828836a8d9fbfee7b880cd3a4278e5a3463b394849e731c6ddc8387ab43e443f6beac6971730dc49f700632d089cdc7e00deb0593caf0ec76d05df7b192f73f23184d42b4f7ecff851adc419d75c077eeac863014de8a58f9fb325ca546421fbad6c62aeebb8959f51e7a1ac9d29b9910ada085c85d5f1837e1b57ae24b4b93f5df9997cc73e04aa36d6a07e0d550ae270cdb3be37da01e4af63c3931343b912cb7debbabadb7b522d5541c335ef0a5d0c712d1e5d38de53f40df5585322467df7845f810c68c76dda9da9fb5a6b7d92fd5b00e9019dd88f5579c552ff95aa491df6dd2fc09cad9ee085f17ec652a4a385ee91732c0557620bde0b8b1a71d7e6103a8e90330d7f82aa9872d9202a630e76ae9c1737d1b658b124a124bb19e866afe9ccc25ee99b0e00a8214fc37ddd4600b27354bb58b332c9d6d78e690052955f4abb8cd7492714c59e1f1a848db44fc601834a812196c18189c36c1fa60299c464e1b246264be61436c4dbe08be8f782c1d1383b32b84e6fdcb922d348c2f6273c4c8ee0524989d1646388fabdbdc56fda910ed365a5cc8694d6bb314956ae4b39dbf999381cd7623de15b9becbede367f99c1db1d373769d30db38909b162e4339603e18e8fbb08d1b416463454ba419d9045a350749ce859abc5cfa94364b688a6939f88b325fb96301319cdaf405354b9cd62f8dd2c2fb9b90189a60bf9ab11f3108cdb9bf0fb5d7537f67aeead166028662ca07aac57fb86704e0d83217d64bd7fad12acf24dfecd197e25ac6bf9cbf0cc65c9bf148ec0cf7fbfd71dd6ab89358a7510a4f014879568fbc7aa6c6391c19f026879578348a59c7d35786fccac19f0bcc5a7d790080459e0b63d50606a551bce726cbcae2c01949aa3d35d47a5aa461d5301fd0b5069c03439c8304e5e76258283ffaa5b01f32505105f740db868ff561dbb0a45b2e2b72362250481d05083b10862da728fb926bb0b8ddc35de8cf87d4169562febd1a524e9b533ad75b41e59e1c8a7c1cba1c9fdcd16eada51cd5d86769b9073a9c442e7acff625a7dd10ade5c05fd17f1079c86334459d97ef4ba29007a5b4a64d804ce84b38bdcd8e02c61d1f793d50c60c7578cdcef582ae4dcca74625ab6eba6a2828937c2f9e6ea9a56ada503ae4d900b0d4ff84f7b01c51972891285f8676c659227ae3861b0efac63ca07668524c3264ca2d3ae502a0a342f60856bdc840d4a0d81f4018378b36c0cf7805f6b52405f25a29b75417622f25eff1ea2337f286acbae0bfe368d0c4580b941eb97328ad4623d743de60613f6cc48f248905479e7467abc63b1d0d232c3cbdd3cc0b05a7d93b49cb47e1bc20b05e4be2c807df9dcc11ce60e8f85c6d8b2cad1e9fd424b5e65078c778c41de4972bb1136dd8acd57fcc7f5f62d57585eb39d43d807705ddf6e0b25bbbf0ad35e417c713aaa90d1e75a3e9e411b583137f019b9453bf00d948ec7e9b88bf6e193e0dd3f8286bec8f32ef8ac2c8588858bab1c984295b7a44a0f43be0a3bdd44cca25f2c6e344304047e94ca94bef7d4567f71e1cf7660284223276374c01ac173b543217e095f77ed05cacff9b88752b540c300f6ab1612f8c8009e470f8e2b7f3853244fe9342640b5705949f58279d57d5a41e2b73ed2942981cbd13e6aaedcb0cb56dfdac427700bfabe36698f757af72b8ad9ba5a25eed143c1bfddaf0f0a1ad613d3857212e6a152a0bd13934a7f9fd567a5230516468f2deb78fac82a90909ce81073f2ec935291c3f09b3279609283f490fc758819e09d92de5f3ebce545a35d564e576f67f45158da1d4646f8701bca2063db25cb02a087817da464a2a48102e3877e02aeea535fd4da1651a1dd565618dbda9c8de4c4fd77c41818a9050688b2578ccfd1b4e23c17de61ac40ed2d61167afcbae548a807fb67c010eb26b9fbb4ce3791f228e70e06b48e8bb44086dc5f4072352bdcd1456582f206bb3c078d09787ab047ef547eb688f07e30c7dc30870156bbe07a2cb6f716758274632606f0089d4ecf3d73658cb392a0528a80f19779e538d600323ecab97a0e33e9a25d1817902306e131759c315b6857453287c0c46930b4e80f0a7fe4ee082359b21a222a1bc1d4566762e9dec8f5dae24eec8ce4ae9b51d492a20e4f923aeec1b74660d4b5afa370eeadd288e63943c6c25806f60a77137546ffba9091b0ccaf2093b6ea353abbb5cd03c56ca06b08a4743232cebe01817d8f75aba377972b0c7386814b35c940b5b1243e75dbe67d8f434ec204223092f4630adc1ebce4f276c2604c0b9785106138d63df3fe69681d790d1a054d1c18d4ecc2583cf7fcb087d5311404e5a8a51613f932174ff93e1bce5580b80abc9a025281091d46340a90c63a0ae926344f531487a6dcd78a6df4dd7fb8b419a6c9d2ca3031aa8c28b5d30ccba9a0ec5922617dcc1ebb501475a21a6bc70491b98de1303dedf668a235f05dc25451a34654439ef38be72d3c3d1e6cea9a2f3a7aa3040a48afb45665745254483e64dd3bf0f21a021ef8af767beef6fd2dade7b6fb9b794324919670867084508159ce241391f8a15cce82573d99e4721215b0e69f32116492f872d7b82b1e7130e23ec1d8a6c5761cfa71cc4d0c721fdf555917376396f38e47c05a91b08220404bba6b0ebcd3b8edbf88d0d39a72b67a753994e4d3913131393eaad16325f2b538dd5e9baf47495313131c9549ccd76739bdf820809827f88030df156557df97d9021df97f3f6e921425c3349fa97ced70f5299aa4e22e71f80ccd720383f3ecda87134b665dbbfdb6c1accd7f82017e69036af43dedc5811799099f7b75a8c968b5aa53a3950c5189732ba36d197ffcca9413a362f833ada88be74727490ea2269527551261a5d8e32bac4b54a91677454ce5fd6589783973dc3ecf944a508ce133991d3245a8489ced3292f60a638207b782bcc2115e044b3ba847e7e5aadff71ccb97e2ee70d290781726f8abb6a1512fa11125acaf4b9a319cf01e3e75a2232d7653ae21163cc43a61b7f0d32027feaefbcc7737e9f66e1b0ff8d7bead2e777d8b1483211bfc683c4af9f45b2c75d78f44e63f14642f0e78526267470ba56561a0511b267ed7ee62df339dd6920d3b6e72cf2965bcd04ffc45fe441d8b1952157ad80f1ea3ce6398e35dc98c70935720005f53eb814972e5251f2a42f4f33c98125792b47d3189d51fd64cf9f547bcbee40d2d122cd9921cb38214f5697e9aa22fe39ef794e0aeef0f01dcd2ae2f99de7016f686e6e6e685c2c0ae1b5f3532ce2f91d6dc4d22c9adf791e2328453ccf7a239da74639cfa3270d196408c9d344a6bb88e76368232834cf13e38f5e34ba88f53bbfa3ffe8455af03b3f027ded3c110bf45797b3a6ce4011eb6368a30de60b5797ebdc6258f05acfea22f5cfbfe6d14444a014fdf3b09ec86b9e8fa17d54d78e26b2f33c12d8d19345b2a69e3734f3e666ded0cc247b3e157948223188fc5bc062c578124a510ccda32d2089b0b4479f8764d17c8c9faf1d9245a3591aec3ceb79f07c0ccdd2af2745f67cfa379466521a1a4a3b3a6f665ee88d66d2190d79c81d92488c67e9fcce4b20e7799ec863901a5717cdb348223abfa369e88d2e799e88cec77831e7795e7422a6b5e753932e36bdd5a0185fb67462b030d68941d2a51f37dd79fa19c88393a44b3436714c2239cffa1d92f544747ee7a994148ed40d95da8941ea3c0f99f3536469a0f33bcf43e777348f9c67fda4d134a665c89c8369ce5325a7b11c927271973f5905cce2d0db796fb5bc2585e3230da494c65458d08fd14af3294c1b3594066b01be699ea563ee3987687e262fd190b5c8f4a15f436dd414260dfa744697350434d3a7359cc77ffab331975c75d618095c69a8a555afb5d65a6bad4cc250e7ea129fc5037cf1411edf8f19c4efb94ed0ddedc67a02196f501a9235dc55b1cba02293d60aa91a214170e74136220265e6dd841944542f3083beba6acab905de4e65a02eac204e2f5e359ab56386e6c397919973cefcf44b9a65e67c99cf794e994c43ffc7ff0f22c4c8c78cd498a5b254760e09aa770c31761e78cf3d11d5ab5eb45b728e4934876ab63f03e690b7c73999f0a5cd73439e7bbe549ab5237c9f2a529470c4fc11e44021777b4fc1a713739cc8fd383a753a6e6f15f520f248407ec99c95166a6cde62e17f244b0310d4b3ba42fdbdf72c1edf7bffe9210ca82ec7f97ecfe25ef5472f4fb32e0f56f7e37bd5177dafc29d2e12fffb4f1b893a08a82f77b923a77dc31d44e5ac95dcd37d1fecc8f287d57d24abd33c42cdc21f3eab7bf18f5e1e8b8766618d9fd5e9a2f0456d04a57ba30ed447af8f7ef0b3af2e77f4e81de09da20ed6dcf66a16fd72d6e8d482fecfa169abd17e708cb9734f054a5d8f53e720f27c23a55b7da54c1f865cce5a8f1e07b0f9b2c70e4bb78dced555675ceefb9cc39f9a6c2197bf417f7fa10c727e19199907694d4d4d4dcd1fed1a7286863cdaf4ee194d004a23d778aba7ccf8f14f31973d1867f0bd05eaef896a06d2336d8fbbfcfd26230579bed338e7654ed81caa2d6ff5a81c9e400298600c24597cd5ff84b5a6227790020075eba706f9f8eabcfdfcfcd4e3fc580522c6d179297871dc79a794cd49085b4af0e18a06e8a65fedfb73d0cd2f69be317dfc9843d5fd68535dd20c4c1acd8714752a66d55bf365a871a0f11de87bef6b70e06e0f480edc8d835f4562ee31891f879c791539f3204896cf7a500764913a640e39a74b66becdd3901eccb77970d2d8d0d0d0dc7d43f33536244d8d98f34a8be2ab4abcc3f99ffe911cc99ed68c1a42b46cab8c29b91cc739c739de382e019c3f7b621ea3b573a649ce9ded4fbb4c707eaffb3c4f5928b6dd976ad26cc81cf222ef3feff1732c0dc0ff5e02a09680a785b86f85dce99f96c692e7972d1c5626cb0586a6249854d75a16955cfefc30115fd4f993a2b69ad0aa7c9a55b40d0ed9355c7df82a92a5c1eac3950e593c444a021977ad1f8c1bd4e58e0d64dc5de7e9ec2debdb3748c351fcbeea12c8b824cf5de6397acbdb75531aa30375da03efe9db0781fcd8ded34969800f9640c6fd7df71fdda08f93d2a8ef7df7def4967f4c545fe341aaef6ab8cbe61a845ff6c7834106152239bd14402e5d6c5ba06a332c539c644f9230c59468d294182f37292e5136da6ccf396d92284e2f66d25470d3443c6923793e408a0c14e61bc9656b0aa1e5219583214186ccdb10212121a1214184dc820819626b90213ecac965bb73e9600a5187c900ce9eee098b11d410eae004f9870f4c6f4a18e7dc026343cd98261f64c4f063e70e358c7bbed39eb40c310224ea8fa48f15b9be9d35deca795e1921c8f4e73741f10ceafe665fe5eaa2df91a3eb31d32c3cc9db3be77c3badb5f6ae6ec77d3727be42ba7d6fc79153dc2f338932c05bb5ce5ae7acf34e3be79c13055b6bcdd95b638db7eaf8f3738d07e15725725d9b75d639c588961662a081d6724d87f1e8f3bb3927ee640c81a95bd1b39221b79eb4e2c7176cc894882cc3c8c4fe018de145a64bb116688c2679e09772d9836589d326632b4c1a2cd86c537559186c069b59d8ccc26616366b22d3a99bb764907053ed404377bd12b99cb01ed56dfb615b9876a5f6a9f745f7056e194d7269c19e2419e791abd5a095e6a654535c4d9ce26ae11457fba6b8da9411d989da2e51b9be6572a0259b85b1a5551f32dd5cbc55bb484d9fca79315dd56a6e0a964beb54dbdcd4ae5c6d3b3950978a85ab511bb689d2a8514c1b1d501af5837e385057a5e610f7775251a718b7e428efc2843113a5b3aa5845f705fedc4cc06d39240e26666afad8bc55bf036ae37a3169d4af5bdc755740c5ae17cce865d7e7b22b4db25daaab3ebdddacd3cd3addacd3cd3add5ce64cd68969774c9cf8476fad2e52a95e0cc53ff2de282c0a8f9ea8c2c96892cb7a67170bd4add52099b7b65ddf3a554bab41aa9fd9da76a95b0dfabeb6987e698ce524298c731ec77f0ec95bb5e438981279979cffd1e66033651e3919b5b134673427cb7a756ddcb57132991179cee6d75dd65b9d554e565df53137e33e094e46c1e92d3b9bb1e8ab9e65ad18beea45ad7a2222c521cbfb30b47615eaf9b29a45f59c3ef44b9f85abaff9c51aab41add68f63ceadd6ff38ca623333dae803afef3fbae5ce2e964b232f945f6bcba49591d689b4b4a66d6dbd55579daa4cada58f8d49bb3e0ce39cc7f16b9d7948642a65f3960c156c5cadf39514f58605164eb3d96c369b952e639a61ecb719bdcde8cd6b22d74a4295aa37f0e7f392e99e52f5bb881b8cb01a3366cc181ef665b5d1075eb53e91db29de72a95d7acd69d5e518e73c8e4bbee42191ad936df296bf0c156c939d551a387b26b561bf14aa957e65a25f659b665b6bd3a60f54ad2e511a54575d0a3975ea692157cfa272d6d65a39ae723adb8c33ce18678ec6808ceb679cbdf5b80616ca00d32c0d6f418328eae1ada794524a73b05f605c6606549c39cb71d776ff5383ba9f5151c85f98c277b2eb2182a00782df78f366f8148681873bfa8f45b6df3d7d20de83e39ceb541ffe286c485211a50e7e08f93c1c9233dcf579b88b6cfd430e7c70e01fd698607ad8aebbbb5f5b0f9bb5e500ce1e5b6f489caf64f717e4549d4af5e148a9be8eeb4221e28d215ef27df1c3f70fe242fcc12eab9e95f3ea698c6e0cb627f1f126c47f08927f5ea998e03ce87ddd6c776fb5c01dfcea5578ab5ea5cb957ebd77e28dcee66b74996b3eab9e136fa85636dd156f745e87f3385ff3e5940b7a5651ceeb60b104ccec959375f6911cc9eff90d828f7d71c89f19def2bf194c1f7f2297e55b3b20eef27a83780b4847d627aa371e791dd7dae5c774f95b5bf30c360fda58a82120f84bb9fb297aff1b74a321b025d9932948494aa0f55fcadc7758b2f7436ebee36ede717e14ed88f3f6e7fc71fb569348320e79430e7120f0e983460e3491863890ccd33772a0fcf4296cf5d4ea00bfe671805fa3774de99f679ee68866c65b2b585efd78ab355d572586de83159c02998c86d050197d42a750249a4495c0ea59b0bdcf14e73c8e38eff842c89e0d91db904614667443da10551b4cf66c8e9c1a3284088aef518daf9cc0492bb520644a0477bb373724ce0be15485c1781b57c8be3343e2663dd7e49d913aab1625a34dac69a9537aef0d0a83cb65655df5bfbdb07bcaaa7f854f5f2b4bf3d5caeb05b32390ea8bfeca3aad766ddf03b5c5813820de739ef5dccee37c0f9d1f9fc82f4b039ccf791ee3b334119d1f3f47138152a4f3a376223b8fa367d5e58ebd7a276985cda119384f593c5fe218ef896f693528869ea00ec9b279d61fbd7648968d6669b0f3395fb4f3396f63a38b749ea58d705ee78dc6dff9a3978d4c4d6263e3394c55a66b4f4a28bd0c8dcd8ddd25072a2f9102aed24d427fd6d97c5961369a01f4d26a9095c9b0954d1ffa443e3ece4f7107d2f8384f6b8ca624b0d826270762fdd4a035879f0c84223082e390d7e62f17072aadcc81eca67fa11c683e1d9164d3bf3507cae9726f5436fd3b75c5781012387b3ac2894d9f43f2200b6637ca81e653d4d4a67f6d35887bd1a7b1b19c549303952ec6c9814abb64e640e58dd1689c9403b176143d7120aeb669cd61534e0b962807e28ad8f471988ca903eaf6bf4b3568d4383fab0b07e779d02f548680e16818cee3e80fb09e48901fb50f0dc57ece8f5f4e2928464a694eb39ae7894c7ffc9c37c27919231aab2efaf9f3e3905df2ac2e1afd95ca1c9279fa76c981689efe172b6f2c77311b2edea22fc5066fac065d8cc7f1ffc67c767963565f30a60fd78593f2168da64f38313b2b12c86772c76d2ca7ef359ce791f3e3f3c0799636ba800c45886961d444a014e16896e76896eb1d398ff3b24f72c891ac49d5451f87f4c0c8b6c9ca2a8c3e7943f6a79756832617382449a18b2d7ca952993e14ca8322df9a7e21e72faf8d78634647fed5e3c8bffaa36d146e9ab7214bba6d7e454e9fa2dbd4c8bc2569c8b267cb4cd7add9ba4f9f1317d0da20186dd583dd8ab55a55195285d5a4ca549ba6d42ab5484db2b2dea9de82adda5161d5b54556ddfc7d7b4356a4ebb72679ab223d0e79539d36fd90bc01c91268979706e4d1c7974683705d6115e6f75eec15565dd32515c67947362e002720931927f1cf880f6230dea6cc271bc46cfbf84bbaa452894856eae9862a9b520c367dea54836848e0cd061836c5917a9a12934da1af12718c2fd972308740a03bffe775b853ad38ac9736fe6d2d7e2297799aa791c9e48aecd103f45820f87d0ffa3528cda6bfc34707f48178902a03fa440da00f7e5ec5f11b8421db3e91ab2cd8f38efe434bb69a49d2bf66de897c86ac71ab500d2b43de0c6a58fde32d2a02ede77afda9d57fc22f403c5b38f006c1687b886badb5d65a23300218a72a3e052cc24c728f1d38640ce8272b70a9a21e357aece851eb9173ce3d7614d57614f5b876470f216fd11d0ed48383a639a3d4a9d42541869111b8121a62d304304c774ab3830e5ee825a4160cc8c129a54e67b0369b0d2ac80bb974a6ed4c381f26a4b0810a909cb0c194131352174b4b92a49e9cb04198272b389cb04117b35188bbe7930964bbcc2f83821fff01402dcfecf954430e4872def3a9862700ec90ed9e4f3530d16252c30930b89271f67caa610a0cb8c8377b3ed5f005064932b7e753939809983e882376d9da4118f1f3d4e4896df77c0a22cb2effc72211c2fe8d6e416f357e684de6533f326a432693c96432994c269b426cfb348a6ec102de2aeab8dc17725c48e61a2e871c076ad61742d1eebd31bac51cba975cedcff3eea55b68b227f7094b8a9555d9cf8fec3ec634aaa3356a1b41d4dfafb26bf316a63525b9fcd9f6e7caa2b2f7fe6595714f3c8846d9264ed31ad6b449466bd40ba5516b5fac179096a907f8c1efc41cf8efddab2c32f7fed88696cb9ffd8910d0811ffc4f977401f8131d007e1962f2febda4ebf89e7b1c9fd6e57d0ed08d3f141fff10f086d8032f28d6f01f070aeb1377d9fd5383ec4bacb24f844c65a0906f8da38597546dcfd21a9555998ccb94d04daac3b4265bf27e6e8cb36c2cab7d8c7f7e644b41e66d6aea66696dde682d28e7f5bd87dfc3182fc59498c61d5a1bdf5bf6b7a53177d55fc232d90f77d5bfe1f903ab3f4e5e1559a65ee89615d4cae742d16899e63d7eec698ae57b0c7edf7bdf73ef69968efd7d9a45e49f8f92ec3dfe3cefaff7f83d7ddfbb98c5d95a17f97e496b58bc55033ffa6546a35e6acd05067df095a0bbdc4235c87b8abb77a1246a63ca31c65dcedc385eed49d3870a2565406dcca7424d55897d1afad21cca40d51cc7dd0feac05df62decde3fda97e671a636a6aeb6193d6748dc7f1f57bf7a5939be520412fc05e5fe07f7ce9996dabea44f92cc913c4f644ee7b195efbd77ca5bd6ae7e7a6f6b49dd9747ae7e5457fd624e306bbdc7d883e9a0df7d9df2d6b4b86e6135551bfeb2da7c78ec8703d9c718df171f3f381590c59fa28efb62102bd47c78cb86399bb6e9be242bc7fdeeaf76240c2359de6dbc7b64c873a685a9fe7b5f6dd8615ee891d5b38fbfa55c4e29cf61db83d5a095d6512191579fdfbfac369b03ddb78e64ab5230aca914b539aca43fdcc81ca298f3481c7acb72da6132b070da5e68f394a907f7bfefc41cf7f183dfd1ac412b30c4a2f844fe7da28ec9e56e100c6d9e72a981a3fdbd0881fbf8a9a8e33ed6e2026e0e6ecbbca72120fef7a07843f51e693748c57b498f043db2a45946836086035446fc4b8a1f79ffc7c6ef91e5b83d2aaab4e7912009641499e417c9efc03359b7b8cb3ede3e6a107e85d5e642f6245d4596b97924b8b915595f1ea9da5ecbc95671b54d1ffb9f44c67fdf6e9b44436de88420b5648bcd1f35e847a806e159fe1ab3dfb5843cfbfd2f91ab6ddb47807d960eeef1c330fe74b5551bd374d9c738e7d1be85652772e96050cecb3e2659dfe3cb912cee3bf10698b3bdc061298b124eb25011c5cbcea72a4fb6ad71e40f3773577d1aae65dbe8f597dc559f09cb72d3e8447ad9f57b68c81ea334be8d1d40c5ecea91de86c1e61006495ec4811c68d33fda251583e9944c88c3ede202e866e5c07fff6a0a06a4625e3dd645f9655e461be53f7aad7e54d74c4bd39ee20d16d644afd5e7bf1ac80cf3020a609b95c36efc7663cdd241a996dabe02fb2939932b301e2b8703e87b9a95833bdaa0b8017dfdd08dddc8f4194012d89edebada6394467d0b033d00571ce6489e54679ee4451ce6b0fb778b035d2ae5405cbcd6a25d5a752ad77f3a356d2dda6ad1a9d61cb25ce89649a5f6dc6293e026f0290d0acbcd974c706ebeefb857fdd7618efbef31c73ddd9c7deebf27a737ad0762fc16bff79da8c33ed656b3ec7bbf7aef891c7b7777f0c3813e6ff5f777d4a05c5d36e5b4edfb7bda68511a57e61be040f9ef9713887dff670ef9ecfb42431910cda1f0a7456dcca8d1337cd34c99e11bffcccbc8e819a51fa6192b34cd4aa1cdc29739343708923e4a72f8f8c507c3f0c110fc50b374ec30fc4007a859e0afb417053e7e9508be07fe07824f37087a9e66853f37793189c36421fde3adabbbc8dc7f24ad79ab7b16dd5ed73dc61df54269d06f927151497775e8fa56037463fae007a0d8179f7b20d6f34992bd0faa4f926c27deb9e3c8f34466d9b7f9a317cedb7c11cedb682328f68d6c6eb4d1cd8fac1cb583a37df7557220d5dff1ef5359cddf2f2993cd25aa2e990761dae821c481c4eeef1b7d39b9d818ecfb3fe690b53113640e797f7f86f418a5e1e37ed09c5b5cc5c53dd277d7819c7843fc2b36e0886e8fa43ba434fa3e6a1c94f4874d5f6a5fbf403cb12f9d4d1fea4630893fe78f5e2c5c84f339361ae7b12e1a6ff4f8472f1cfd63247fd8903e4a32cf13f95fadeabadd83fa4afefbde5ba129b92626eae0bec43177900f381fdeb24fa5541e328194feec1e634d044a91c703130175d6ef1d49ceeab2d406f63ecffbc00982a27e0f5561a87aac33febe7b173ff171f7de73f841a29f5951f75e0b3f58ce19f73d66e9a2efb1ce2208740c8bfbf74816a73350e4fde769efe70b7b9df6e93345d007d0079606dd7bcff2c7f8e3f19e03651d8a1070cdcae16fdf6e513adaac1d451cf4b01ab841a78f156ff8f4b15fc5397dacb621fd942c9313cda93ab5e122581da6ab5aa71ea65c72b53974041735c5944b677272a6ebe4f489495cc935683aae39bcb7de516881426f81d3a77ed9ed59bfbc78bbb73440434f674b52f04aee3607e806627549b707f641a863c64c4ac3f334b65ef747bbd3737bdace21ea85d38ec95032379dd2b0356ec67536fc219716466f30ff0a951f67cd894bf7062edddb126c093687a610484df5a32a54857258ccdf22b92d525d04a424d8f4a9e1835f86f75683426d911cd4585bd86d5b98087259a796a6e6d017d446ddc22d714b4a21207912ae23389dd93974c31e11e492dee88dda006361b0593dfc341310cc5d7299bc75932c29792b367d02fe2ab29b2ddffe73d2f007a56a10385dfe17cc8266fbe3f8dd89053092bbf7bfa26692f42f03fcfd02a0904b260678efbda73a039656010510720e4a5597006c752a80ab0a352b87dde1db1dea92c89ef2d6fd21d2c5b8ebfee7449dbc75df0024ade2aefbb8bbe0ad063d2875bf8252fbeeaa2b92b7eed7f70fc37a54c369094b407f70b5e78d1a5bcc9e9e16a5e0ea468d2db2f59608d62099caa4b6cba0613a08e298f3fd0390867bcea8135c89392ed8ab8a63ce39e7cc60cf05503de7a474ce39ab1017b470410b75bb2e8d4400674f896f168c07e125eef2b762ac1824a4224536bd4a5769d3db2eeb33b164cf2b7b3ed9a43678410bb509492e31d4f6c7500e549b1c33d5251f6e870ab515e32d5f926d937bc923b67a1e554a4df8be7e5fbfafa0934cbf76b5ab5df7714fff821af205dfbbaeebba0f042b58a93bfeeebdeefbeec16f00bb7bf0ebc00ffcbefff48c06e85abf0026f4743c20d9b2c17724501b7c47e26583efcf3de824d39f18e76c671096c9d9b30024e4fb17d490edf7e0b76a1087f3c61bfc48b2bcdec23fb14c8fb7bee79eee398740a0377fd101fee0ddf4afce7101cde10f3e48410a6a0ed00dea06685b0013aaeee1ee131c0c91448230823852041058182145f45b1533850eb31d5e68f2058a2ec9085937ed0e6f29ed700205296870d2430f598410a22b2106ef488f274640a2c5114d767842c2b64f63bac0965841142f4628cd89050c2b4788e08624685c3a101851041fb1e285d203591246872637dca0e48a0ea966457ea56cff61c8fe5697970b058630010f5d58a01dd1a41ba126e5dd0bc05050124b0285a8147422d46c58cbec06a428aec49a88a10ba196053c62830d2928a288305844d0a183d576a0a1476a0f15a69890984a32c6c68da94de198e4a815ac0842052b5d48490aa31685b3b956259a8070fbe2851794623a7814b518564990a00b1451b4c46ee0c0f0e891da0bb7c9044249102980e1e94b1556c4d490d85a922a27a93e4e8044851121d030821b56501be132a9553bc50aaec4906a21c4f0851630d65afb46f28eb1ba8ce45aa9d0ca83521213145844b0a289175abe702e7b1b8a5411831329a418a946b4508195b4446103432e47ccc930048e0d159640291155c44a186e4acbecbb4942a0a549971f6eb089208c161cbe7b24532d33d0e4249e444b0ba1529416116c8ae06265e566518497ceb3057ab86551c11547c2e8418a1364594060c20aa618020bd74511537858977e6b0a9e84cd051b0951bc38c20ba78222b6747ea4c90b51b531379cb083162338304520e1719574627b62427241072e382e94ace005081f76f832858a6fe96e96215172052d0460a2102326054530e52bf32506206e43d41053b205e74b59e856d17a1223c4174d285061845b1125a86ef55202272a2588218c089c1663b02b390b3cf4c0c50909214449ca62e64802bef80085890995159c705fa400b9903282929426b65ca14316599210a960295964b952801e9414e1f4830a9880e15464a1225ac942823c44eb10173c48d990c20f27c8e2258b920c9309446df1c4c6b43404150e6a0c9e4018148288d5848872e3ae80020372d34a1434ae64950081ec3df244834c0aa72b2a4ca9370c111ea1800e26e410a50a132454b1026aca4a890424a258c941845b9410705da0986aee110a85e403b27e641a51220cd314314f5e64a9022ac67147fede7baf9523271494e0e10729da123a380aa0eebd7763d764cdf4f1b7b73c87ae8bf92c3f846003942861603b7054101106c621635cab942423584871e10a264b8480438117d78fd401200166892c4e8cc0040e5c88d862ccd3c7c6841a5875a18b2b218922060726aaf8a2045db829a0f08e14e96207134819610a14332998e8c00c332c524ed084165d4411757d3a81029715580821ea85239c1411b4d06a21e20a771d8718931980b08202a530382888a8c2390d242c9488e24452d416dc13449400ac4cb630c97828e10712e08965b6f260d10483ad8a2a49ccc09d40866dddda975f212289c68a063688a0092648c022b6026e0b11307ca9fb8c0bf188148d5b6a654631d101d97be413620431b0c005942c60a858640939772b26e894acb5d6e71347381183a2e9052a489c280178a402575491c2298523312e4d2c11876841c458487001092e464040e3981822d6b9d2bdf37ebe3fdeff5b45b02f09dfbdf7823268c073885e24c0ccb09e5c266b7d66a1457d7757cade840acfe7e47499afb676de5c75b02a7cc102172938114105596c4fe0287984791de167937a6489ceda24e53273bf4302b660e2842b5d84601ab344ad6b22e2e7a8290c122eac70c10a09342580105725c83e5f2da8d5cc5aa11a84adb5b26de8c49624820f25f060c5cb72496cfbd4c3b65fc381eeb6ba0432330bb9c4e37629e0cc1864e1436b86002c11802f0090426b842727d70bd99312002926188491710c00a892710b4764156a7882b9a2a4208a36050094c8aa3d9f68494cd17ab8e04bb6d9f38956c3055eb2b7e7138d89b62484ecaab0f29f3dd9b7df696387d2a0efd5bebfbfcf397d7be9e307d874cef93bd4460694067d9ae9fc0ce8d379c3891c4fdd8e727eabb575fe4cbc13a3d571f7bd960e28dee8eecd1cd97117efe018db6d0f95ecf70904573dac7a08c1cfc3d539bfe00ff7feb8add53bceddbde3bcd65abdd66a2bb5ee6ea79d6228aa9c521a1c9deeee95d269c15a6badd6ef9c40f54bbc7184506a963cdddd67786b3e56d27577da8eebf0c59ef5be0a86d37edf773f50bc4f2c8ded8fc505d8aa050c7113f3fbf9de5d3a5b5dc6a1f50f745eede52e77b9ce76b8ce983fc36e5a71f8f8b10801bb3d2ff41e04c3190ee4aeba4419e41aa48090da30402b4a559d70b57abb7aa562ae4106982e7f4fa62b69585d6b9986331ca8c39d9d1ef550208e16dfde67163fa420b3fdc71f9670cec7ec72e5cb9e60268df98c12c1fd73eab4e79411255d3869f20313a957d41662d3a84d8308c116df3a90d0161f146f882a104cdae18be2e73065faa26a47fc4fbcb152893a0376871ac89cdaa01e91f87e9635fbbb32667fdf13104aec0f0b94fd3d166f7ce3f6be136f7806c0f80a958da5367e4ebc8127d00092c00cf083086a96d96c5b5cf36dafa8b7432b0a12c25851e40606edd2d0848f4000c60e2e3c4d75310b02091fb6503a6bcab3f594a504b1fbc41bdd986d1f639ff2230863892b6ea0e104501c314495afc3d16996945cfeb7ae053b3ac4b6fd6c9f7c90b22dce6073dce7a80d04051412dca0786284941767c4e6fec781b8afc1bd02e6e68e0ccddd75dba78722db5a2156d7ca0c3be9e8e704166d267c2a98855114f1ba9802b338018371fac29410ab12c6065cdc02a103a8942df6553d0b11d90800000023150000201008054462a160349846caae7614000c7f9e487c54968ac324c861148490310410420801000000034668688a036d8f710c200871e6e8a3c2fd99197feb07902cce524cafefd92f2272bcd65401e29fd44a851cbb690287d35105a34ced90c269de87d3e0be909d91bb5fa76f679e3117fbba73089e70420eb9c6e748c104ff861eb8ca2b4f51f3746c329ef600837f76a8b554fa6763110b7f4471eb75b4a8843c73b2372d6fdd865942867896a2d7345abc89abcce20d52a29b6128bcd81db8c86442338ec234cbcb83b6365398fedf854fbe56c2e36f1919cbee65ed49651a84b2d2021950d80245c84933fb059f494e33b854c2b17733857119ffdc11fbc0a82805171c16ef79e67f9e508bcab21dab9bd39fdd34e89117ceffcda36a55d60a51af47ead2570ff91d6970548457d049f538d49fe984f55a7448217630bbba23ee863dafa605f916929aa8c9556831477fd2d67fdf87a78a645e24d71f83fecb1ac1c4fba479b8a441b2ac63d25686ba86877030a0368225201cc865e5de05230a1a5068326f85ae1db86da83a1b84dd5ac66478224ce7c46b31354232fc493dd4a20283fbc2611d6b827ceac5992aaec1f014a6f3c4fac1a279c44aa76864b811808fe53ba7669060cb5a591fdaa5d1593f25a4afaa50e077acc90d1386c54e71e81d4c865a2e3e2766196e6a177c2e6d2aaf5f70402d7349561510db41f2151cf10e2a10b00f33e25c212184dd76d121bf4b8884e12590f16df0aefe8a6304f006d9693b9f6a73f5e80ae38a013717e144eefb77d3705dc29d984dc27a6cec0ee48796056bfceaedec36043ca5fb045d17d472061b98c4feb21138944c98a089c2cbababfa11c4827a16999e6a3b28b1b1342e0f87680392c503abef768825b451e818765757622b81ab5e217f49e4da8db92182f14121fd66bca5ac8726f3ef89b8b271097bb930e24d9eef729921c195378342661f36e92d849eecd130e7c7bc327653beaeae6f6845db752730f65a72a78fc49768ce0112f6225a100578128f489e79d1885b9f7bb00c1b0dd565cc633936e97440197f426c243ffb76c482e9826d733c0e3646f34fc6c67222cd93bfca368aac23def846c5728ec3b129774bec3e2e4d0b649c49368dda9644eb1b9b48bab135c1de477c18ee7221620335ab8a53350ca6867735764d98a5c238056f043fb133de1817074fa4834fa1297161212ad602aa122bd622b67531cce05f4db869de9249d103eff160a216b67be296351a73c72c2a1db5fd7291fd89b5a4b3db780b28a22dd354c8dd48c5db792cd964413b400e6d521bedb08fa8aaa006b988ed2eeb0ce3d13c48f88270cdf57794d4a4a5b0d35288332432c4e6de9dd37e9323f52637ea01d43b4b4eb213b224211288d915d5192c82341d15eb23c94591665a3b6007d41f901e3af918fd4be2e548e833b5c30ab5d456b8b90d58a1b11e01e170cbf870024d1e774975734acc1670c4f50496653161b7488c5c799244005f420b4e0585e7466a0e51aa980f59e468eb3f42eb36006b50aa93726482f5569b95312cd5489087d340e3b00d339839f8f88fdad053e7ea13d8c9031b388dc5256f34874541a37b04672d2944331b4eb190e0f665ffe24aba897b774ab1170dd37eb49c12b83ebee61887d905bca2fee42a7b5dd869d9725bc5f8cb96d3af5258c4e73e9759806f80bfeb254a4e61cac8551876fba88335ab9cac5c2ff0bf3d0910cb132763f313fe432b2d06c76b958cc9398e9a4694c911cb32c6168567e2874c415115d534da8e3d836bf9cfd92f7521fbe09297a3dea4465612352a76cbabc51d4e78925eda8a98a86291416b539ad401209a7864744a5a3013003c65e2ff738b6528d7b8c404ff0637ab0bb45f3b8a9e4cc9f0593981256370007c416025a8ca3f3a329754d015ea4ddc946922488b0ad28efa94a8f453a8f6657241b86640952350a862d412d01c35369833306f0889643f44a46a468659483a5d84ef7f2aa297eb72a8aa46c5f7b63215e395ed2948e3d05cd5e3f2a5ef6bc28208d2186b29fe9fd4dc77494f40476dfa33314401025e02da5111fe31baf7155acc08219680ddb1a54409f1b2510cc6ee9d202e3322841bf706824106fd43652eb3dcb47c204d3ec8b905d7b1b2f2031b13439eb7f887acf40d21a70fb149fa59c93cdf295a897643186806b32be00f7cf31ce2bc369c9d4f35356bb187f51c289e4b6474b5e2062c6114f8d95e69919c89b352f09514d282bc828404c2ca8e753cc7b705dc7b2471c693b62e9420a6b981402c1aba62eaf8b115d1f53d468bfafb6d517d1d9d6a2501e571d509a3eff881e11de5b7463775a0002d7093b55b24ca71acdc3be4b8f474a6fa64bd24b98a5aaf99027aec3e0ef6c4b7833c81ab30b7edea79ecc071c2ea37038870a228971b9311b9ea2ee7910f26f5bcf29655e4b85e89031b5f81381fb279dcaf80242a0bee71db5506125d5285062f242725ef1e2c30c78abdd8e7ee8b2d374a91e0243d59c7acd54f46d2be44c0b7b27cdf1ac684158ab40c58e6df6a2a3ead8469e3163be4178ecfbb53a6a43b7a4c895246d9109f0e0e58dbb7e596217ab5804742e86c292728964f7de04dacde186db7f09d2522751f7e021596fb0d4f8da8e5df75449f170178618fb34b60a24c43586d6217183e275d9325f509aa248e94c9cdfd6c1c2bd2cd3ed692ff0da7f923146fdb2b39ed7a835aa9d174a672adec0d8936cd7222935e0cf19db4465f0c99efc30418fe5b15f8eaee5f9021154af5e8e330ee0c2983fb1c0d811c7a2bf6f744ba0d54b9108a13630dac02bab1af867a87a5d53402da985c12b9dc7c25b8eb96024a864b3988bd2f87b917d19737f8f2a2ef98a492d7085fcb34a90e9e09657061d901522b85e4c391ed0c8f083c7774841bf96ef6b9fbd4aa248e42c3b4cc206d5d55040124989029dfa364c8432141044e462f9f74329e06031bc263f792c4d88203bb0841ddbe2c6815fe09d01c2ddc6de133771c4a536bb97abc1efe29c7b970dbeb30e7e6d6a9d2a88b8419afa7c9d33be8092e32fbe897cb11a2308360a465724d24b35cb3e7cc167193fd0383b9144214092eb5964e8ab220d5c4385d6a15620befc840c3f1b6035aba29d32d11e33a14a7dff61bb931429c3931f29a994b444999a4e25a0114ae58f5e406f947acf1e494796846c1c816dda64d6729874de08856120e43a2db6120af832ead6bc970323e358fa5358b5cd50e8f194f9e7af149fa7be620ed466a74607c66621292f0adfe88aa038abad0086538bc9038ac66c41fd1fa31be8901988b219a5bbe18615a36fd6940097221161d7a7175c87f99b85e48026aa096c8454404da8972d8bacc0ca388c5d64e5ebfc9d16b448c68be0e1d2ba9ba2e3080a23f41623edfe3af551659af70b9524380efdce306a16f46e3c409195f195e23ed018fada946f30f6e871461c0b732d16f356898f072022ead6b864ec4b721944d809c6ad3728e469e0f375b4ebe0d1ac2e1f8b82f02de4f023fb37ca2466ebb0a0c5c7da2603bb893e566dfd6dfdc1d79dc6d2f4e07e197703dc5501e476e68ce57bf2a323faf2f08a6f86933d638ade6fd8b8b7e6e78b81f78169ed0ce8a3578a6676e518006674c169481a8b30be9c541519ae1972961e2bd8b729810dcafab18b580cccde253f6bf5386fc86c44e95071b47f632f19fda19f2e805858b8973bb426539dabc414195394169b693549c9c2074ac903f0245e0da0ccbe553bf07821208bd1f823940bb08e175d42a68ab2e4faa8588291332694c31cd210ee6e3a96ddd2c4d5ab7384009e6ad5a6c93ac577593037626fa88e7cf92672d52d324c5d6c96088c37a6f5fb5bf00b9543cbcced90e4f84904da2de0d46f60ed4415fcd54b8fdcd0435a8d16d5d4010808fafaf9cccbb657014bdfd651e5adc7c5cd75d514c1ef36529c6844ae9b31ccf9a7c4b6efb3670e11f2b53307f0923963de024dd8fb8180deead008069c27b10d299a84d9ed1be6d545e560681688a0bfa8a030a1995f838ad76724519024bb1c4a5f9af344f037cc6f48859c9c2f44d5925e65f0d48aadede6812dd5f3b77e6f90d6a38c5fd0cf474da55c7b768a6b0673454eb32731f17f4f8140ca2846a640c6d2855876d4fcf9b4df27197b167e251837b7e175aeb37d945980bcbcfbb3ab07b350ee533fa234d0c4bb22ba140fd9458b1fb63029c5ea1f7a37416250e553d6b7eac8f53d4c79154134c91088c5c19ea7276df25e519326bcbcff9c10e93a2a7ae5d11b3d7a2bfed0ab03cbd130a10391f87b1e8562519ef4f5a46be5e5f2ec1af93ecd8ec786104230bf4db371927ab3b0323c7cc853adbdd7bdc025f08887230ad5144f855e8afa121cf0a919b6ed61a1ca4d66ee6ad03a9374ae0b46a0d7932b700191a815394efcebea5e5ab7b783845ed7a72fd88c9d95d35b9fecb0080d36a5f92c8102a6182c0380aa1d61f3d956818174caf9f764c8d22b1e5039bf27844b9d4ae4d8a808e08a984a384dd3c99ab9a21b4bb9ca29dbd2fb3aefaf0ed3e4117221cb8d9a42c72da1640e6a6667c0195d92b54d14b802c961e4f31e7b3138245b85f9872d36624cc29f254d617616ffb5dc348850184f162305622343c7b1061ca69db8baaba312471aa376df5d78327dc650704987df93577c0fe832e32dd2a6cd5b60208433173a7d41bfc98947a727c0c726d2d70278b9899ca3be51271d4a9eea132d2b7be91693bf8d17347ca2a34ce481958b9c06589e7329b3192160634a420ae91a14d62b01c01622994da47ac829b4159762d5a45c456d9f5984fe08070a2136323d20831b3f76c492176975158148989f1064b25d2e6c660a7f8d6fc1c8d2cf8986483a2963671cf3b628752e265acbd42669eecbb6217dc5acc344920aeae4ebcaf63252835efca55c6054d883699aab499087d42c14f46c96f0f94825e0519e47aa38d7816db244346fd4cff28e9ddf5fcdd81cb525e7457deb5f4de4af15bf410d113111ac6b87b493ea43948c2422d4417143680a5f56073cec1b177d12aef3381a84079785f35c8b02da768ef2673233a18baf719a00f6b6049e897a377604f01b510a3d668df8e7ee6952464396a451223ca0429eaf7efa3d25e267ca04e83dcf350563cac94046e59a8e3679fab9f16b02813ae0d4e98d5f65743389611621f6051afdec4f697f6fae3367c7fdce313fa19100c6d596c33937d06ad2a875b2a60d3bcc90433ee06e44162ac5ac41c02f6f96e2ca1e12958893104793125b10c0d891577ff0c18c6c4a21573dc159cb788c67d8862f73604cb5d50e75421a14a4147d62f6e2f0f92bf7051aa4721a58e208e31c49037979472d1557514b7483534a21550498bcc95d88d3f813d5127d82d786263e77939904e550d76f72e8b74aab3607942d9eed3e7317b1e98e5ab5cc178e1f1d01757f49bc3c20cb1ebc546d66004f303a981333ab505889b7320a029cc63fc3a337750a876c65bac26e82976778493a943deec4bc73c1ebec2c284e57a6ac0cddfa6c3c5ea55ac1c7dfcce9b7a5780e535be8331b323dd7286d8ee090ba4c6c9cde7d2996a38a0698cfe9813f3cab6610d4f974c964e41d85233a6c8b8c05b673fe67eb04fc31f19fb36f503d51f3679933c137fa0d0290590c18b32620155b1023c388808b9de48df91d1dd87780b6c70426da691d7834550a2016158e3256354f58a082b0afa78671a0423808744059d32990555fa91b6b6cb80be5d9a7b599c764450ac90a4608ab145f80308809adf3dbec8c2d6146286d9c7dcbaf1b07da8e11384f603eba4859326d156ff6ece92da8c6e406bd3456bfb315eeb386146708298679951248c8caa31dc0370559407c32e899673b52922a7dce31d52d7d35f0291768461d326722c9074c9b64618b4f26f1c57f17bc0a5607e0294850ce26dad78e7820a866f2973e5852f79bf3cc5d1449a39beba67408b5a42c50c91d054e8ac9df40b01e2d20e212a97d4259f0a88808cd0defa879ef11c3e4ec28e9acdf3667fdb86658a08cd11da9e81610f86ec02125e81c733a6b3491dbc0eae111b6050e594da4dc28310bc0875902ec4e1b692ad73e984bbe83a601910115b6cb3a4ac1dcd080d3951b941d55914e9293b33aa02730b2c232694da072e341105a699575cf523ab14044927cc8c714c0e0c26da6352e627c76670cb35b876cdb04c24ab7584d07cf6041830cd0578f380df3d9e0e0586d2fa8a1c029703d6429317e6cf0dd08ebba8cf243c9646fb3b6969c97a233816686b72088732ab2044209b1550a309dce7722289f3bf8aef8a248de09c7fbacc20e7fb775ec535b86bc58565426e5df5ecefd09d29564aa41a5f707f28be0d1531fa17c41e87dbe76a74b2ce9627eb190a5a8a62f6bc2c3aedb778378f18b5593477a45942b6da568eb2615c47f417cd0a954b3bcd884f680e96754dd20e0b0577dbdf039682875c0c6ebe801c5821a776197d26f9f5337b4a9c217155afe6708ac80d55f9c155915b68ab8730983025824f3d712fb8d787780d6b4f7219c21b77e2e5e32579e63026066d29e68d3baf8e919e54e1800edbcd8e104662f69437f217d768c58e7d09e35a09c23748251392646e1b56183cedf2b3a44ed73d74c160e6f473f2f002757b0d4a79527641cf89fac7b4202e9c9b4ef1f1e0cfc59b3ce9d87cb3fddb6c8be1ee52c5b2166d063fa64b8913abe39e4e27288cece83d183dd9fc8a1c6150dc0045f2eef76a206b60c154580e39f4c5ae5bed93c282a60795905a2aab3c9fad55e4960a30db96ab82d4d91c3f93a36168d8b5c703c2abfc37c69a455de463d2c31596cdbd768bab16d060810665c9df288da236319d763910b5cbc549f4a88e04ba39041d55be33d1490bec296e9bd74f3d27f90f8c8a7e595693367a8ab7cd19bafa03a9e0b1b1072df9014ff2d91874516160e8035439da747e4e3a1de180509e3660d077dba87dfc185a2a0d8d4b01d84ffc279123ee7fd619cd553baeb6348341f391c6431515367cbfba8a4f9abfe1d345a283880dd26cc29bfb4e76e2fa68c3eca4518f1d4594a1e6d2edd7c8245ca90735dfac80dbacf99f58d063a23f884913f47516a157106a122cc9de5d63460ecf0f6565380e9610da6117378590ac4ae726d276a69beaf2fde81b8b0c2326492769a6fa57af0a62ab5105bdbe3a765b8dfdde93f5f89c762a933463b412497cb0c4659c673050e12bbea44ddc5e50432b690c37801dba76c973f096484723726ea2c1d3e1730f2ce7a06631a4b0f7083a5261888fc691d3843f29f631781f6d4e475490e8111fa08a3c28963a52ced91484441c16a5a5c1e1abd0a7254b621fc7c7c847e975947de3318d52667add960d7c1a659e347eddcf6d36a3c27edc22a853d734311198959d471b20d6ac00148c48828c90ea6cd7142b83a520e522fb7f72c89722581cc1de63af0b058ff6dcb86ee09f0237fffd486cdbd1e4ee818f93c1f8c99b44632beb11f998a9d16e79930cba43d691729bee0379dbaa8058d4dbcf45eb7500e267dd3e88bc696bbfb1e2feb6c60a022a1d7826ed24ea77de0038578e82809238578e88b5a93720dca22235a9134919e0ea949a0f3db03283b7b0bd468f07b143f56f1e0073ea7fdba5d85088ba210db497ab80fd7c68dbe409c4c1853467d0acbb5cc21a442d49cfd634d1118a251884becd7c27f63b002b979b1939cd9ca0937248ca431020190e2fe7b3d10090ec1a88b3117c7a1b0ea28bb3a391fd641c980ca5d0fe5c4c90ad02a7915a9758d28d42538e3fccbe117adc740e3acad8caeba6a4a6d3414a39850c749b4d2703bc6b244b5d830c4ac647e4b6ad74d7a785acc28ae0d5d85e1e90d589e64755ba6b9c6ede53ab4a89b84b358cb82a794bc2f8faed871e0a7685e059ecf1618de400afa4526b43ed5de41d767c6b827cca2792d3112f5b5481cf86527919ff69b064935feede3e023882b2361c2548e8a9c66ba34e0975bbdf2a5285366762239fc725335b4cbc2412d1018e336c0a484834e7598d1eb147cd7c46257178b34012aa80f1a9c306c6d63d4ab613357f47090fd42844e596a824340b3680489457bf366085cae375733d30b61e4c64f4ec6d833d1050e120badd0259df9f1154de9865955b733738c8996aaa1cbe091966e68cbf13be8d9ca71ce17606a9738bffebd651c38ba6b23410425d1bb2b8eb91db957a96409c33729636345d9281c1b320651f8427e4a8a97282cdc9d57a2d5ad34e1e579622e9e48504aced3c1bb9c804e5d513cceebf69c67b6e6efb63c9ab0bde412b46a6e884a53f98cc2d817215302c7f5e804bbb9d7434f551f287c419635faec5497de2bb7fd319265ea31cf8bcac5f4b9fc52d5c4c60dbac2cc244045cad802b64d0310881ae4b811c7d70e70a167a31275e12185fb901f18dd254b79863a352ed85dc4a1dada9c7143b189710bf845c32f5685f872cc34921775abfb74f17a32f85fa7ad99a78e0d9f502dc5b479043d531d84060c454ee33697f3fb87785225091e6460b48997a89bde974e202e57caf7a6e4d84b555de206508655deaecb02956bc52a50b9dbd102b73a2818ce8d5b24fe28e77c10969539505d5c5a9571139882a2d2b9697496914335120c26fc917c3ccbdb1d4fa08a19f9755be20e44409fd7fa6a699198aae6314c2be68c8d17bfcd156043347c335804541a288e0ed573177f9fe336755b2394de9bd9a6046ad8fffc825de8b6507774001fa222dc46ca404ee0f9ee05b032bd900183d587158c4aa81c80c5be47099911e36dd6e1ff21e6cb36c258895fd616744426461f9c441e03bc8920a1df2034eff5de2a8f6b554c61a437f4cdb552a04d6f62b2672f23dfec82c71e57c5c2ac5d60812d353b92df92b41877bc289423a6485b3cfdad755210248ab7324ecffae6f0a30feb9b26d0a4f1749dbe10464de05c20fe8e58861585010b50c6ef69d84438265a80005aa960ea610d425c433f4fe86dafa281860e27b5921346eef35596eed0a3372324e98a3620e684096b49b32cfddddd03423b14ec50847c12480153070b4923fedebe2e9e74e29af29fab189b643ddd67b3af9915286c13e69bd5c8da852425db90ef02af3eff628d3513b8b90203de9c28b7e4a2f191b4bfafc65efa0db26fe78dc60ed5a95403f28f231fb05006b75ceac5f1cdde6d47c73058480bb8dd6ea5d0527854994cb35d99842b634249b01e9360aad971fb54123f267a2cb78c90bc9394f516543d0fe79d5bcb447dee6d13ceee72470dff088ec66e67981b40b50bd90f499452480d9be1220c53d80eae6d5b1c362f4bb8e3efcfecedb5fd621671e7c32dadc987abc3a51eeeff0b86c8097eedc06210d4177a959c6aabaf0ade1332c7abc33e267d1f9cdf0af150d87347b4804e15fee3bde26bb4760f58f5efd6733b47b7e21b781886eda52f2d20914c871bc9aed6842218a47ecaad0932cdc6f4a71a44166db01f873b5db97ec511448ae13d7a18bea9c14ba4a004400d9b9f4bcd59110ed1b8ce6c0ecd195dab4ec9fa98da84adc0c37dcd0ed9cf2f82625d90449a78d34d09bc7346f579e981ba7d21c29aa748f7815a5aa8c7ff6a16fd90ea4169237690982119dffdc63bc501fa4095650e8f6590e6c34fdded79eabf797beaa983ad183515369235cae4312ca01e3920db2a510c17c298fee689afb94f7f54fd79f05a8a46f8ff3364549f1a21af4224c9bad5faee050c4fbcccb16b4c832243f7a493e8a71c5c26e910bfe08dd322572a85ea26b5efa2d630fcabc8b54bbe817a72fc6981e0ba285f55524ba2113cb19a009b68905cfbcd6757fb75f569f14f297cb6ead4c7402c301262282a644081a97b35e0305febc42eb70e132c9c7e2c6e9fe1db2865f796e8c4fab8062c16a3e8ac69a2749359f68c465a1a42dd3de2de2af20e473c0d85f6df729b69cda455f6784f4eeda12e1f8008b436405e5877b2d2b2cc2f71e1822049cd117660f86032783d892b040bc52111dee68b8fd05950adb710b8dacf4b0f3a732622a22d18eb841f0df15a70365c4242142dd0670cf257db043cd878cfb6898d3a49bc27fe859db052d47840f8e4f406bd7ecc599a93533928910dbcd45f871475cf839fc643b470fc8b1c89805e226b100ac2fa986710e1720266d7148d2a55bdc0e70f8a2f10c19320f05a9ece04d13631599749bd954b9813ab11960385a9e55e04090c57b4a4a0e4318aed26a947aeee94e360a72ed4eecee06e7b04b24722d5c4808e647bc6e8e1dbeb3d5c5b7a4d842c4b7c2e0ec7ebe99137fb0c238238fd34aee8b21c45a280055da9204c670a5df10901c8fb228b38ec71427dabc1e54c8b2601ca0d9e4fb6198b08385011c97e4f74d6f9811b17237cf0d2db135a188c99ad81736fbcfffccfefe6771f2a60e98ee426292b92543abb636b1a2a8244106f2ad7721fcd19ca66171c6ed70322bf162a705ce8eb7a95a2d0494881ce5907cc328df0a155cfc453c0057f405c10240ed393e898e8e507e2e443f663fb4508a9679e70984d6dc598c4f1d603b1e5e8605d70a05849059e6dd6caeedcd5dbb051008a81fac4513f74891331e5bb94150bd0dc55a87e6d5f33f7740e051604109564b8b49c4b9c518b726aa45f460c9aa33efc2335ac8573edeb3ddceab85a4a604684ea15248d4ac273359b83f45032c7ebfc7d0d568557d261ac2ff01a42f0f3467583837a6011a62634323b59b107957daf7f68fe3fe947fa2ce34e591dd3491890c1ee75aebb9ba3d90c1674814bf8a5af169e4bf4e00f1e732a78c9b0cbe05bd01b8a704d76777bee7c267219ecc7b5affe90b02bc7e09dac7f4d1975c9a8e7f6e66351112cd80bf16e44ba13011d2a0f5d011badb03789366574cc8f0e60d29ad93cc40f58360eaaf619adb6df42c4d4e0e6639b429647c9f0c4672a5ddcf7c7204dbb1b0d568e08ca0dee4b5acf3ad746a0a13f6f1600d64216c34e69a920616891de81e515d884b80f49f9f44aca97859e79b42d3535a1f2007e83cb70d247be91eb3aab89ca9b357b0ee84f90c9fe3717480185bfb7da6c27256c1fef6607b6346257df31eb705155d27bd341647421e26667dc98482ecaa88ec4c50c84451a0e4952df50c7c540a09bb490ed13b0fd6686bc1e92833c1806c67007f1fba87f10c49a20604eb996cf479a8543bb003111baf87b8c4316620f360d492dc26f11c4101cc274653dc155cb045f9f9bb90f17b9bdc54aa84ede78f9837e4816ba654c213634e5c55b8e5a0538baa4a51584f98b4b14186a70563ae4965a812a6d290fe2d6b02b933d012e6e06d53a259777a86a5c8d40c496c8b6851db7a7be7505d74193d4e86cfde7b5b4b147634eacbd96f0ecf8373e702119357b6dbe10e43a51887a52d75007cf1ac203c162f802f77465d6ff9257339231577b7e4388390b6a2bcd42aa2a7b27d1462df3dffd00f92cb372ee8592cde9fc4db6ab044308a4709dd38d85bf319b090fb53011ddea6dd4d703322f8014f7dfd7c9e42de6a98490dc36919be84b09625ff99593a81607a21ff99d80ac5de1086828d5e10a45d500f5de27d91c041e03dd348c7adeb04aa11efa968eebae1012c79cea5ea6de996c4f8b2038dd579f4afc71873c4fd9dc4302854a26e5557b5e2cbc0047f9249f269fdfae83388af2e5909f79b1b2df13b2f104f998009dd206140519f8267f284c80fb535634f289f81a81d49e7c2713afdbbc5ecee769c2e26919a5142cee8669879c467d6fee0089960d84af82489f0878742b61a9ecf9de3201609bf453f482a6171d10d7516f0e4c93aa75d629435b71a352f47e9f08e2d6c29838e9e23ffcae87cd3b70886581210558242de111134bb7584a2ab3f9d168f18af167059eb2a2af2a461f300c7518b33c56159d0d978a51a1a096389fda3df65dfaf59488c862d2be5762e1a34bbd652ef43a7355b50fa7e47f5b306c6c6816d98fe1b0f0c6f2e12f981850268419ed92ae5ef29308c7377ebb7d1c9ccc2cac28edd3cebed585c3fdffaad14f085b43e78ec5b1274e910dd72e11720a054e4c117d8c4954d120703aab5f42ec2c8fa5ae455e170f61d2e59e288d21721822ba9a6d0684f015e36a60cdf80ec50d28b6dde4d572dcc6263cdf015e40d50374952f8f8adcb41e8760b9de7213825123db2978483f9d22c1106894c9e850c4759a8dd4d592cf8e3d2b964b1ae1a2caf9571701cc2eac65e1130bea9d9dabec0c4498f4300c721491b3aaf95f3d54cd2a2342750c8beb5c35c289d96e61ecdf84d482237a4c233eb4c9bdc5005b92afd41fe9d2bbf6fafbf3b38cce7250f592fbc52c90adfedd5fc4a2ad5d734c3858a0a06d553a0de4f8586b8655321dd980652a9bfb8f1586fa61d3332d3948e1b5738ec7a2a73542aeb36efd8ce806025c2a29fc21db88138ab40109526f1514ff1ab0d35d9f323265f4bb09d59769acaa6288da21b3f188e0c62f4c7307ab466a6daa1518cf375a9b037de6743700142c23d9f1f11a01a78ed735104ce10a45f78ded08cee6d4e0cfe7d5d8af32e258b43c82de6ec22cb43aaf3ec33ba4b19752d4f8e5c04245623e415e17b55149b63f5db00889d8a451e158ba3e867290d6816f33ea5f10d54bbfdce0a6cef939db5c694646f85b0752aa6428a2d05d2ed8395e3d3d476692809a7b044f0d4fc417fa741c5f837c609934722c0bdf518599a7509ca75b4ab4539c6cafe484a9e9610bcaee2d9c17fb872aa0c23d26b1fce5c043a0d174a5c90c33e3e50fcbc34438f15fe7c3b95b637922d2cd4448680ba54a3407d3827765301f7a00b8b15280a3a4fe5327a6579c31b81c737b192c0d0eed19486bbdf532d4adc63d10e6e79683d98583213522c0c08c1528b88f51dc9529eaa5fc2e1959a28385a5d6a48d25e891d8b033f378695c0eb15523f02267cdd728b3fd08bb42fa3d8f07df9cb5aefceca2cdd1a106ec25185b75891e00761a78160dddbe03e88d7597fe0613a6e3486c341343f789d68f7f2e372aa7688e9bae12136183f6f7a92bdeb67e881bcc38582ae26fac4f8a9329fd751e93331d5fec6c7ac725098341daaf34b37480f8e9cec1f59c9095d9fd1354461578aaccf2843249973c4c9ddc9bafb33ce3e0c4d098bd079ea8861a7f15a019aebe7c62b0d4e242679592eafc949b84f04d7e16b89b3da40c83d607c218d2c374e74023a7f44bea6810e14126926710e5929b84f8cac7fd6b59fe2c936915d7f633cab9d400fe0cb3d2a1b57a5b34e332395453172e9e05708d5e5b5bcc39c1321df7f071236380fde011dd26270500aa519b2731c398a384696c81d06a3022a6293b5f7587d5ef3112ecd748bb950237f4937be3b3eb206aff085485e5dba38446925ef4ba835a196b0cc0126f1aabd4b4c07823a12ce845452d334582f6bfcb6a1ba5ba612b9175990eef9606d6f47ae4661e97868a89b4c845f1bf950d4f98fbb51b1ce3305a5f893dffb315c4cf95900a0c2567a19913708405c0042e8dff254dfa600fd76c4a242dbdfd08cc06eee27fc3a2f10048996755b18b67ff419c1fdc04abe3c3341c06922e83da7997058857f7e79cc50b16018f309056fb7118caf53fa5061bffd8bfb35e9dc2ee93e73f235c1ed48742350619c3e99fe321c4f96731288234f801a076e7ad65a7944519f70dd3d4314b5a5c41c1113889da04f23db4c87915e0124e066ff9ece35104f7217cd2ae131abd9d335ee583b9abd66b0b56719e0bfc242c98ce6cb8ec78bbea43f6a8667b20ec84037fc787dfadc9c0d986f8d9c4d4339d0ed4bf86fe7e543297569c08a71e928705bee168d2412a016dad6c2b5345a51df60f9288080b07b844ffd9cd41998a9c7c7ee05d5e44d0807880acab4b39cfaa44157fac4a0e6ed29938a01fc586b3cb3a32de53117aaf55b650441a8b4bc2eb179fcc87e1f50105c177cacd33b9751a96315a4869ea779257f4cc9a4865b53ae60249db0242ac9d83e408940675e22347357426d14a74b68d1a18c788e30f35c0706a322bda97f2069b571e51f28e3c3c59588d3dd24a8de4c11af3a939e9a0e60248eb9b323fd064f08e88cec5647d2b14dbf99473c914cf2952982388d60b3dec2124b78d2119210d326fae7e2e4988ee40ea7f138925e3e3ae884849fa290f00b62965ae31db3c2bf13d05daf792a7f51302da1e2719613bee873331678720367c6ef152b7b34243a406848074f16ec6a3eb40a7588a6c8e1f4de399b899eb807402fcda1fff38b1580eed0f5fc0b47da9d526e8a4031939f4801d10a3ae242a67e66c24116065849233e116d74c9d8033354908aae13a73cf137c6ec0b40fe464836345c17628dd7f586bdb45a4d6c2c86e67286234e548e46628595d2e87ea12ede97cf2c652e54d99da85b20c150309211c38717f31e3517a0ed4f294d9055bd3459e755e2bd1bbc1cc462fe1198a287a27165ba3c6c10a59050f91b319454f80e72f39cde84183979a6102333f9c403b698f9d3fc01c2449bc8a46d3a469210553b227898ae1036e5ce814b4cc73c8a0d6b412a79d769b31f7a1fc869570f75c4212e5dbb6be6b4dee99c5b4b656376f925d079fcb70605cb936096d0beb93639e115ee4810b271ca59cd55edd4737e761eaa7ed90a1118621542011abbd9e36ff4a9964eee76ce62b6b17f7b1dff4eec31a7bbcb40c497ec175a81dce25e7008932facbd713030ce1f75030ddf17db37a56af37c0ff28ca8c1503f526384ee4a2e04fb1081efa6fa34d1586de26c6d6f43a99b08e0737523f9d47a0bbe20070cb23cf04eff3294f8c88df955c18ea2cc91b263a9fc7026c568a586b4c1ae78e6482ee154d1d10c95170db63f19dae95cf08871d959dc56f2837cfa66a9c8b1d61f012480822d831165960c4ff9b9681c566472bc60f5fa520199de14d2bdedb624cca0a9c8d24ea21c26832b9353a48729affc205c5fe039b9b1ef52f305038bd97bd4b13cd7b3a247be40148927f1ed4c194408965c0927b7a2966d17a4a178459b16c01ebfc4fd4ae043cf7754bba6a131c080c9a2151799a1870da1b79da09a2583f4b3147255ee66c6e23ff9454b20ea6726b97f6614c139a376a49cb8fee32ed2441c0b4154da16ad885eeb4e2631b5da6c40d44ad475baeac7f2ace1e7901f2c465957f8fd929f2df134c6ec3b0b7e953e5d0ca45a1a2a43480033b8811c3bee2f2b29f62ba5f36f4c293299c9bedf24fde4b11b4ea9e83001976ddf4b760a07f4097bebe0a562f666018eecc31bf67823dce1c02d7ac28096283a0d6342a8f4a237a3e154bc52d98c381082ebe1fc17aa6169ebe3af05d0aa35b2cfb4efbc6a88c006471847dd72bc4c3057498b1c79f5da2db6386586ea2451bcd500983385aa7233440fb126f352068b06e1b50b477579e7e81743a56f2398a65494fbfe15409f4bdb829b69e255c26102675c3ddb8c3d1cf0805ce6f86251602252c366eb4d3397767b4a0a2279118b4a1e9b34336dd679666ae3ad9f98ce959b3ee4180904ee9a40c511b808025b18f71c55d43457b8340358e3e8aeaf2a28093633020d404780d89b28eb12bb999098cd4091f2cc2dca0bbc39e5bb07be190c7bb2889264dba7bd013601dca77ed76debcb6039a9be329c2257d709fa004095c8666ba67aafc0e63f8e0f0efea3718ce2a1c7255f20f8e4bbb7459f480e4b1c9e7e910f99625da242c64180a8a3c153519882b1b836ba19244e1170eb94c5b3145507bbef996412b10a206c648b716e1fe9c085d9f7e660f2e21b1d1fb58ecdf8721cc9bb318067f9468a91efaeed88462584c340ccfbd9608ff46fe2ce7f6b39030bb6ab2f1ed2dd3fb61794d48131a17e09b664753e3f60bfe441597d0125773e75ebcde6f526b98c0e0ec3d59a406d51da3d1222ddb3940f674c98bece6fc8d38531f23f876e598b65307b66eb3fc1d23f21eaf406b6467dedc07dfd10ff36d0849b4262dbb95a172c39251b2c00ba2d109e0e603eb0addaa1a21dcbec670d05917ebb2ac95195d35d0008fffbbc0047fdf8cec334e9df575d3ce6cda5ead503da56e489d90255e0e872d8b0db0635adec800fbcef58138c39c353144012007337fc63f38dfe4e82723ed0b09287ea2ba6bedbe05ddd4257429aa3304fd764c3b47282fe00bdcadf3f37b730193c343da06c80b9015536be084d3e341ce2b225e037c9a0bea2ddb76ef97d57cec9d7f2601802571fcf5b4143aa35183cab80c6b7ce62fa25c557e61009e72ce9fa5898c6578572fbbeb6591cdf5de9bbbd48ce89f1d0389d5ae22d465b6759d17258453577aeaafb9c6750bc155a29f144b6cb68d014c39ec1e4099d201726271e95ef2e811eb047bb971c1688fa4e8d6eae1350c50dd60c3e296c1a2287e4aa14e3de4c5de840284a9638806f3d0206871856b14f8bd48747bf1ebb7cd5283b09c94208b37a71c4cd38144230744ff9d15054e5484f795c05c7d25774bcc89fee821d095070db7592ddf18a84aded3b59169696daf60c997a2a8ad2847cf72bbdbd0232f73882f8ccabe44aa102d2fc61efda093fd21e7b57180796032d3c35e0d684fa1b1e0bf83fe84eab8d3f865ca56b54128c8328f77cc936bcb65cef8ae279fa62085d34877578e0c5837b374dd106fbfa35f955c40bb5a5f87ac93d3c1ede77b8ed85368e9c14ada827a898b2b900ccb1c7876884e3d3f5186c5f31ddb8d2e9393e277034bff8a0f91dccdb00047d80aa1feacccf1e1749e5940c5c99f85eb4ac1c0256abbfb4264d07a77bb1f7f3d7ec6a6883b937fdee1f027cbaeb4220d814e06b66373768c580f988796132ff93b7e9f2f318133d286e78773f058d0a8d5b46fab4ce94720adc581fde2927fe0ce443577c50a7aedf8fe75e21d98eeed93567833bf8c878b5b088131128a7456b593c21c7f0b8c80dd0012cd65dbbcf6d3f132e097081f1cb04c9385e1444cdd836e2f019702fc856a3ed1ad0188af8637f830320670f0b331342fead9091f1edc33c5128bd259d9a8ba89b95afd984e6411f7a2ff19440657edf17c8fd071a119901de9faccd44b07bc9197b5e8d72bf587a583cbcfc096054f0f78f0f43686ff9e7e95457fded4ae03359cf0db5a98844e7a5b563096f92f0c96c463209a51cde59c5ad4e3180628b7a2912e50362801433629dea3d3a9e41438301fecdb9150bed31b03751d5861f604f33697378c396867988f925953a2994b93cad955f42f8f07048a81f58d47f3ed931cdccd80ae8ad54d063ea0a0c5d3d19edfc72d777276cb652d90b307f2d1021edf9212542e54b1dd7c3d2efd90f81831d8801b68850b3471536298481492ed68d2940a140f8a2b4796cf91d151eef277e2eb0302c64212eba6fa5c0b38a1570f309a2f79e4372d09dff4ca193339f9686c635a7cac4929764d1fbd1a1d09b29416b72a7d3bd0e82567842730562cdc7e6ea759d79eed85b0ef9591761af20ca076700e276985e25fb12ec662f0db86c6e801504857202d6b50facb149a6f445449ce14f62480ae455eafac6bd218873b10daaf77fedf387a71751418bd7a9df80501829ebf41b4edbac835a7a602b1cb334798d0bc7f30eff00acd3502fbf153a91bd66e37a372ed3e58ba073d2a06dd1fb539cffa98ba07cfeee901e1ec28e121069922a5152793c5cf9fc180804a0e726a8a308167989cc9654b3805762c194a693acf66c3c0e34e7dbad11850f1bb6fe1d408364c4cb10f4f3760b686adabb460bf486844bd2e67eb69a10eeed5599f1bfe41e11a59110451a1e914d6dd4e0832ccada086a36bf620eecec50993f63be23304cf04a0cbe725a35afd39abc971d049b65e0c4fb18f285d382256260eccfe056b839b8fdd70b2237f7b060b32932aecfa2600452425b2009bcff687be3814dfee877b012bafcd10b851a9e44fc1fb135408e9b1f9f3a910bd0c1dd88c9496b45fad4dfdd97bc51e86265d863cbc328b8ed8c18e511264f894d4c668d178b5d86811e6bb726677296265f5e494fa9a15fe058628c06f87eaf3bf88e0c2036eac63e0c91ef34f50b0595bbf4072f7224f83664695867ae1bb678015bab4035e2e109b949ecc6d66a341839dc7a25d8fc84bd3c739b90a1be9e3ff519571d624952e46bafff3ef676debc25ecaf377055694cacbfe9acfa7703c946da7a0383ea2eea88cef330c855f7dd8a107b31e45619a4a9c5b15cdadfdd01a5891c289b70372b6837a44517e56066bfaa205928739260e66cd3fa8e6925b1b1fbce097d3e0aa33eab0b7c5ea4c07e422449081da0cf1771b30515bc63cdbe82635e3025713ffc0f56d6d1900748c3244887d7c68d9b94da5cea781599621673046ff43f8ecbb14e53ea300921b16e5b03deec222193f52b3b325dd9ad631c6e933cb147d83cbb355ced395242260f66e87059cb03568922dd0c4d4b20ddd90f3594e823af705800bc4b4ca4b46ed4544e9f3ec5dd01fcf74e28426042237b53c373fb7ab2ba08d7784b2ee8dd6548c3a4f1234ae6b8e3d630b52e61ab4f8b031c349f124caea74ad91ba16e1ce341bda6abde7b1ddddcbad2762666762cca329da72292876967ee170366736cda2a40e9e3c2b3cb523d29a7c4bdab1b8e130d5b493ec3d7dea6a920dbbeb0e51a5c55a6605b7125c8d0ce45db87ed89582803e338efff9c748e30ba310384fcfe1af1f7268c5fc5f7d3cc280d6c903cfeed9d66110a02af41a2661128815f02498b1d48b0d8a9eea79a54ddea152b552b4e566889b5003f6069e273e49ae9437ae5d59ec71ec0cb865a135693202bc8c646a88256a0cf712a8b1d3bd57345b148cd4e53171af122dcda5d0af1529621a0edb20baad2accbde7b45ed1f02433195802c0af09bd866e6fa8fdf9e2ad2690dac35c5dda13f24f37e2b91a3b890bb53814b40e32a963771978f5264235dc7f63fa82be5645ec084dfd211f57c5693ddd32ef309ce0526e2d226a56f498962c4b7bbc054e8170d8f8855dcff4ac4245d64811a2e580dd662575bb33a2d72973736a41bf55830ad71148335787eec433525e068093e8cfb2bafc5b9691c3ce2397dec4b1402682a8103b420be13475ad71ba9f8a9aed8d94f7f7f5061dcf987eb2d3c592253378fc14d0a3aa0d10ca2cbc59fc1345ede6b5e8b9aec74194974712a33a46c853cdb52d61c6343c784ac5e6f77be5263de5ee219e9bc670346edf8677756635c386ab22913393c9fc2ee7916b130897a55e2b9d322a1185212556c16b92e45ca748e0eb0b0422e27503822524a7c9d23db635a49ddca2b07864f2ab00c0cc0c97e212e2d35db65102fb97fbfbf135a6cd391078f7fb81c85cf2b7f7c9e36b0d39161ce7f4b5ec9a63392126d2f3b1085a10500c2cc860c8b24ab5c14b996467aa3c1a45cb8f48e3d9935ec51df6973fbbeae3ff0bd2bd1f2d42386d183c2ae4d966796a6773e4da07b73b34881c627ecac67a7bf3ed229ed927582558d1c75fbe91588ab00b2c160de0a456df45981f73dc98e95be68899d8d13c7acf6017f02802fcb034e168560d1404c5ff9eec40adcd935180b9c33ffce7eadbf6e571d741dfd3c0e92403a109ff6ec9b7f70535c6df2c1e60537fb3fafe6c99ca6c8b0acd6c2b6756b410630d3b060b3a58d0937a9b042b6daace8bc39a0f87d122c38209d96553ca6c745d74c6ea889b7dfc20508033b81c9aa083a0c93874038905878fbd84463427651a32acda86d16cd58f92e2bdd0d97a46866ebd28cf428accd2463049144cff229dbf3368a6867c3c2b90efd2dd5199fa10f547bbbe1e50e0951c1bfd086d5947976d04c2fe4977fe644319cfea2112622176327f4e129714d5dbe33cf8bcb95237a7e510e1668fb7f5c51023ae3db2b8ba49ddf9f0eca1efec402cda3c2d054fd682187693578281022468b3a6a604adfcb66b6a718344fd0d5a1ae03173449ab78a1cc829980e0f6dc5d91f8a07d1ea32c31b1ad785205e776638523f788c314347c11957bbbd80b374ef397e5d3a31a105daf920493b9bb3beb701ac738bf906b4fd03ccdbe4b09f923e5551f7241f43381cb5a27602af570624c14db3774dbf9747fd800249c192e67e9e63aac9cac9e48057fdf155a577fc35bf9134317099b64b85a8a5744ba9b440872ef8e6d7abf35acbd04861c2d59b53496632119b0007a89312cfb97cff6d4f57b2fe35793677261abe12b459edeb996f74c30650a0792119ef9700adf973c00b3537aaafe3c9b448707c100b30a24d3f012d414f36cc291b6af2ff94cdb0f76cb6ea6b129f466b702ccad0fd6d8b99835ed8e6cb3b481426c2bb11e57e117fe590091c4229924c34ef030c1144dacab32ef4fa807afda534eafe958be8892b6e843f0deeba39d2f711851a4aa693feea33fc437744459e105712a2160bc5eb054c35c35b424fe6c8760c4bc8f925ff452b7913b4e416749ee48386d36e3e6e9af29d9feafe3ccf9cf42194b2d24774e9da182a59e14268bc9eb81cc2dc0cfc232d5362afd0da1862d12b0264a62c0a9ccce61648967759e0359ca7f0ddc99e25682de13876c551f23cf4336f5d88716008f9526af3f14a99e1514872ca14569d290c9d9f36f655040820b1255fa0e97b3f80e17417959aac383f8ff197638a47624a058f704e1439c13fdab94e900836fa3911a13328a2347507b0cb4ff63c686a122e23b8ba0ee8cc21966aa22db1b92d58c913aa876ca8a9dd60853a4dcfb760ccc9e50e710b4339eb01bdd9344f2a30cefa95317b017965bf447100b703a07451085657c8df483679788121d675c2820ae1070248b46284036925edb7a06132ce2a943e111b585123be604d8ecc0b1777af93a540bc5f9e1e7cdc5799c65d7423fc518a862fdc698c5be32bac20fbb1d0f2dc41d011d034319fe02c2154e064cbd204fc0860cfed60aae55a8ba9230780f31f8a9631c9acf94ee20730242f7b695fca20b002086a4e04a300166947cb6d7812f754e5a83d5c76faff07a0072b7500c7b125e2e2ef15f6bf2498f4b7812d2e83149ea24a50185e09ffe5078f9da944a60a391365c0ffa96e6055388fdcda03eba851ac03e5d736651ade4aa54529d0612cbadc5c4351d28a5b7dcdd890d0dcaeb5ad2d8b048e1cc8a4466c149b577aaed0a357792bb1c26419fc750c681e2b5024b1392ddbbc84b1c501fa5c622ca68a4ecbd62740e5f96c65387846bee10b14382e177af167c12bbd6756a15e64826bcd3df531406022af9e179ac496343dbedd3cb7532cd23c6f3f429a5ed1d0400f42eafddcd34a6776372416486b5009cba5ff45a70c3104aa7eb6a54d66ac272bb83c786e4e3364e1e786f57083013d89721fa7e3a192e1b8633c40cdde621615498ff3c5f1793b704a27bc6f36580e6a2a5c1799ecf3b2fb1c6a516ac4a12c45c7ef87f19bfc750cfffea3b64c34e9d7fa75c8b7219b70d92c6cab6c13311850d18eefceae8df35d00642f3a7f79a8de06605c93fc23a9ac45a419e4308a89382675c9e79aa7833d9f52f895b26b0309938a7af24520e061c984d3276a136b5d094532d36d452537325942e7e7ff4c6ceaafa25ffebdcfe1b5b0cd7e1fa084ab3d18713cc8295edb83c64abe890725728f5459c01f9d46595013c41fa752db2c6aa6653bdcd0552384ccf118ab95d9d232c06df5ef249132161791026c1500853755faf0fa6caaf099d90526e7859863de08dcca5a5139b1ee568ae9d9e7f0093971d883122b9900b382b612094d05ab9746b332212b5aa40d02003f66694b1a77f52af97420a43f2df22bb29a4111a4912bac8fc8bbc4251de925f96561df87e38875e6b9fe69c1053c7c3019993f1ee0ee11504cc0f19810b0a43ab4fc2b76e71bd1fac498cec8a12509e856d6011e9881304cb23cbae4f84b5aab03de24141a7fea7da0389e61e37497a878addc42b5c8dfff061727bf557c580472b3351ace57e162b1d731f1125c5ffef82e93bf7bf6b7b4de5491f39cf1de74aae13d6e1f1fe30235a49080046aef913925db858efa3012f9244bac90106393713e26cb871b5f27171c1dea719074323faa6a5d900409e28500b0f057a3b576d045196118a634446f23802d29acb8dba93922543e846f905a3e5b1470d30c9d95b808c913a6ae0178d0cf0d8481e2cc478250ca4b44e333e3d6c0dfd7bb8cdbf49be5833198708041afa67e2bab4ab2779fe9c34c4b5f5f3be759a5eb9d9ba8d50671bb81231317858daf82ded9663245d1dfcb4164ce8d738f02ac146cc7d008c1fdb7f54c0f4803a0dbe5f8c3e605f2c547b89fe3339864ed1b2da0bd991ced317c40376c5f2a354e4627881315db417eb20a85c08d1bd5c4c6955273084307a62b9e42af0f55262e54c5981a6e110df34e8e1fa0b9904628adecf83e4fbb2866f491c85f8106aa1030aa96146296543ec21e02945003fba134e46f6e25f393dd0a6612aa102cc58965e9550e48c389c1c04a326470cebedb427e442f8b848df82a8c5d55eed0d1446c6e5d6e0ccdfa2d219019ad3d400fde350d690cf04d083844adefe5069c7066b0ea24854ef3f5853328d7bb2ea735b370eccec5f0f777a467c98f040c423fc4c3df237ee8b1e9cee6c859c860c0297667809ffc0b73af9815b01384834fcb56d3e782ce11ac9124345a3d34fc22ff7e0c3149d66f7bc8feb9743bb54405ea88902011cfd4ed07ee19c6b8e6de6dcb08e2e86427e5e675dff052652af14d7af936f032bbbe508c54fd4dfbd16921e7b1c1471e96f3a521b911e32a5888b5a4083be97a3ab843a1dacc19e60f161fd84c10fe94c9952829da6979a83ff25faea14df6f6d5c876f3103a8a93deb51a3834c9da185355a8b189585f7c71ca082295ba29e326e60b9d08ec5386deca533a03b903541380cdf616135e348c6b09a5cd4a074d7c2e3d794e44a0c4ab8537f3f53b12ad2c2a996c5ec0a1b6d9a25d920a782bbf2120262a71f816a66ffdfedf5e5dbb868d37517607e880d697720a0119077b19df4e9e8709a177bd25508b00c6c79d4b1c1ca7f607aa7b18e6f93e40c8ac9d8705bd9deec9626cd4aa06491416430f1e204177b62d1bd18e9fefa0da4d6e032f785851dcfdd3e2a2058b1811aaa976c30a067d9accbe4504abb7c2a39492889fe518dc529cfb481320dc05a785cdac3fd225936716b149620ce252d079b0f14a947bd7efa17868935b6483516f7653fe108e5c1da91db5a58a3aaf920ecfacdaec9cb997d80860e966fbc4c2cdc52f41fd3dcf8bfd70fc4a28f99128b1b5e0d412c91fd59a9deea1d9b5170e92e1ba12064847d72f9ed9a58874ce906252c6679851b735cdd5f3f17e35e0ec6117e83b9718e85bcfb608428bf03df02e2950a07e80844403f21b8b0e6ce349c5ca2c260aaa780949050d2d9fb90f890e0d33b4a8263b0f3ff72d06ad34072f3567c85a6e301d5b374d9a78a94e5a3523735e3f9c2db0734aa7c7c5787879687b485f1fce35966c742b896aee8f0361d98ff221b58f0746a0bb4ff1443b1f21eb26e1503187f52903a842a278d3cccffe3328876cada9acb5f109f1679265c39ff58a2f5f63162117f63556389d00b7ddb9cfe0346c62344ac0c9f130294d0178425920cf8c5623e09bd387d8f1d1bc4a7df18f8f38f20680ce2734505fccf2d7e13a0fa68ae5f7f949346bce6896c992cff605197740913534fc38ab50d679c92bdd04e6682ffb8581c3de476b13bed9e72cc7807e6ae6a0f0fca5cd9a03086c1a5971991a7e0a074c128727a4fb8e63240df8d4e87ba2077b50ca0c1de5ca6b4a09fd2d16022aad1342b0dfcdf706d13d433db3f592bb467f911fdd09969d1fcb4fbe4ac156a4227dfba8999642bbb7239cc6bc02d4e1cc5ffa47642171b9807bc2e62027befda4cf5d0b994e36b110580f40ae0b8505bac989738219bc3deefb4fb85037482687f8f196ceed78ef556907987d952b042016046c57e36e47e9d5e4c71d5fb7bd2327809e4663d75a402c9b6d89857d2d07375273e3142dbfbd1c4c658fc64e2436ad5d8a714d9a626b8c6a26c3ca5cd8b7bc75162e5ea63a1644e4365ed6b16107b8462e7186586b0b2c43f526f0656c544b70f5e59e809462b1e00853cae8bb57e39c55abe0e2435c53bf68c0dd39e3bcf6da3250f4ad1d47f1e9813b22b109c9f2ca6b06b362f8a0c11774cd90321561ea5633ae94828698a5b87a338a0a1ee58aa9e3759a68ebce835ab5bffab1cb564a704c220e8f451d02ca511d3a61071e59d7a638c6eba218fd186a9abe7144e21dc862d71cc14fbe19898710ec7321917cb26df10994c2d4980eae0c9c512cfaa4068fed52d0c57c9dc3fe75b51f333210839a37ff90e8508bbe215d7fd50cc4c90daa00e10194fb660fb38b9a85be80afd5232edba10ab7c98dd8e5ca4eaa6fb7828b529711682b92e5c980bc877a83b9d7f0b848181110e370bee7ad434463f90c954705032d56c0b86305b83f61642daec190941c8b687f46d70c0c0cb4d627c0af930844189d3df40c1ac2c5e0f19e598bea0d6405cbb41e35fd850f26bec7aae8873c883ba0fe69c268839681796ad11c090e891f6cedb944fb4118092d8b4397dce87fb4755b1ac74217d12597496c41370c4653df24c3df308c2c9605efcaa3e8fb55250eef97ba85bac046d6aa82d249fdd348bae7b1f6e658b8072a2aae3dc22920e419e656810cf8f80398bd4dbabc4df89b4b46328524ca43edc03677156dc05a215d2c504db8b28e876a1797ae0b57de85f634151a8bde6002948ae1f540fe4d5f53186fd979992d4bd95c2fffdaa0d02596e17b439ab392ae0f50e6bec0af1ca9668890801d5dd1c9fa69c06ef9fb04b9b0260e8279bf93f1fb0de27d60b0c0d07329f986aa78e6660a8d0785903e7bd71fa74fa1ad87a952a22ca0c215d035817ef038624b5445a326d84ca96a7486058add15801596906b1d78381b9092f504db0008628d32fbca6471359d445a248c0019ff3b8f6157b7b45c14c76ef673a927ac5e425c0a2cb71cabda5b2f323aa037543ffe1c84c1833ac61c016bbcda50b219bca8b2d210914e2e6aaf5483c943fd4e7c68228b26bf751cb466667a66529cc4c19812a8306a25776f5ceb24a601baca327cbaf470a61955474f3d9ae0aa8fedef83fd62d1d1e843a835c3b993a00f09faeadf015cb28d01b01fe5ca49864b667ba0cf0ceea8439d39cb2a9ce71f7b3a5a9b2774141bfd68baacae775d48ba40cfdeb1d1018f77ec090a44ca5f4672f8a1b6110421edbf5014dac6469e980d3e207f43e25353c1a7d4d010974e145a7cb8a5e05d7d79c7f4eeaacd410dab582adff9b9ef8ffadda3682651dbd8ee69d60464070908bec020c622cc00cee15aed981698ca7d413b83b78fc1a2e6c85bc11787374342b243093d26301476c94e671d7008c7f076dfc7d5ea5d765cc4e82b0fc85ffc8c6637909142f4f3fc943170002ee6e4ffb8a3807970aad74a2aa0faa7a3bdfe4c925757497aee9bd3c1ed174e3aa9ef62d6c8df963d0272545e3a19aca824d7ebb9e22d1818f67e98d5dc3e1b3c45fbbaf8a5e053db3fa77af51d975a22ab70321bfc40af2e3828542f4236adb4755552c9437ce84d39332588d33eae8fe5119eccca99d74962a3c9f09ee67eea15f24e58fdeb5536db348f335c67ddcf19dfe848cb1bf5f2be87f5641032816376f9dd3a983822463898a9ac4fa1c88294747715251561bed2933c08be3c006f05a7b3fce71c179e9fc1bb1de53392ba96d0080179c058c441b9e370714526fe5a01dd1ceb43fdbd75efa6324d799955a4cf9441f50c25e456c6436f95fb183851782552a4e3ba51d2597225b8f2b84dbd01ab4bebb18a49712ea84e86297c4be4e394a3d88646bc8da23d09373a2534fdec05540253bb9435ce0f9c1ee444de9557f880d3bc81ae16dee47085dec4022057b0d3cba15569f542939f58609cdacadf9d5055a9b123be4fdde7985a8a4eee0d37032769527587fa1e09cc7122c8323d1c7ca23a98dd63e970031d8545288d6224c9cc034e60731a9212a89fc6704e67f4ff3638366168abe7c5300fa1dc6b95f56e079cc9b97595750031d8d346244a5619031e924c5eaa8ab82200032737621f4e5684fa19c40de1ac18cc6d416ca42dc59e52b07e1a69f3dca3ce63ba55a4c1a3cc761148f83808c62b840b9252ec3fbb2060b9e7c75f6d94891722056d24771bdc8806d3c5124153b2e07ccbb16b02987c0e0ad70a29b48ddba6a3201ed15f4c055ce2b9e3feb5a7ff082215587c9d891c9c02c2eae1c5efd8625c6535ec57be13465f5d4b5acff1945f0a7a11b0e41546b1e8f3a3ae85fff4ec1c89c2dd44398d04e7689464ce2c631929b4652c9e7645684a0857d6c2cbbe2363496c88a5d05050fc76d488ba7f953959cccb5ce8e062c203df001a542cd5e3ec4fe97eb15619a9149022c9ad71b9de36a3a5d257a0d3ccca684666a703ded560df69a53ba546dbade63093831c306d04bf0ab91ef00f96e22edc0e9745ee374693ea38e7c9a66f766d395be678036af3520d65e817f05c7a9e4b5ee15decfdd2c40e6a75789c112a2cd02da7e7aaa27b57b50626a8f989630b47550d39efbdf17d08da5e066039e2be80c51a0221853d0d840fea4e5d0a818de468b455d1a99b98b69ba89c118ff0bdcb250fbfaef760e3eb3098b92512e0cbf2cd32052281727ce17a1d55824fe953029190dab087eb179c5981c1e785a2400bcacfb5fd63025983d3841b2123e21b529bcae8f9162068db42e1280053dae8de583b3b713f2f78738df67188b7a01f40f0918fa1e51ddf85757ce251e903bb996d87ae4c845a420e6333e0a3c292521190d1318d4840446166d1241f4a837b47179ea554e144991857037225cbcb44e782a9c08d58f166da0e7dddd3b05ff2f7cb5ca53e445a3e6c06a1e3e03c7912619a8418606b4b5a6d8df274ce2aad313d5ac4305024352e9219046a0ec8ff68f6d7ce075490b9bd41fc9940f8a73fadf6577a4742f08d0524f72500d944e950ec1a7b45d2bdd46df4bedae251dbfd53c97a4d3c746de80214c46675522ca77fcbb13500597ad629d5625f9c2ea4c38d1334225b00ec20b9127dc4a15d65f129f4f95668768b51b02341df16c8430c163878ea13ed24b683b993732cc35b987c78e2bd25f1fc6ee4e152bd489baebe997a247076d380c092acecb79c91213a29ab370776cd2c3b3871204cd156e2ce3ff091fd31b65cfb824f14f400f6d9bea7894b8e2744e60b68cc0c05084c024e1cf64867a132f7429c9411fd0c9e225f4828bd9f523bdf3f5a8c21b09dbb8f4770bde3a488928ebdf0ff3d2c300bf6f4eccc94c5b1e4551ef25d144cdf78fbab3fbf37f01160ecaf91b153e6a9322575c082c4eefcfcb41f606eacbc87e9ad7022a0916ca782ba8a2bf4f408d135a1605c85ba1e211a78747ffbd1ba7c36589bb7cd801166efcf55a8e2e9e24bc6cbcfbf1ede191a777fb4a6a67a39bb92498b8d06b287882c859d668a7757716572334aa19f4624fbd7dfb3cd42a34f6f12da60c850a21a2e9998bf4256b961200e57621dff71ff89860ab8f1388b889e6836fd22f120d9f42e08f4999454c0523038e056404d989a3dbee88cb59a57efd7c5bd3827bc85a0bc8c02953ed0d7dcaa108c115a48ebe00c19ac6a0b7daac1b1468d6d8252e93f061bc381523fbea0f248d4de1945c704fd01510d54aceebfe791ff1a44852613dbeddecf2e7fdff1e981cfad3c615f65ec413546c787497f2dadcb2022a6a2aa463bdef07ce1f303b06c8413357261f8d662a71d344737504ba69b8be1ea8252e6838ca8936dcd7041dfd6a646d1cc0b12436f3c89a7feaf8f57fcd34f860017798b1cfb22395d2f2836dd02988ac37178f82e5c543a98b8982e59a0729168c866526ce53173da0b9300e6c17ce85a74032f052a82142b290911a0edb93bade04baa6e061678107143823fbfdbf3c06c0dd0de671ab6567cc3ee3a657e7ecf6d10acfe4ecb89f9698307623643468e0ecb86d9d9b18db9ebd3272d674b43d42784367f2454b3759ca6bfdb30a9001d8b0ec48ed1378d40a33524c3a81de9f331833c8a3e9cee970f651dbfce88b26ed8f6a4240fa2907529e11a44d4b35483310d25e3c006f2d7d51432acc216d43a4de48db275262f925ac1669a7e6e9317fac48f5a8c60620767062e78bc4d93c3fbd5dd47a332512d2fda7447f76a7badc77f862f290ee4b89804280f591a6badc290d3e128c46b681e69d71c3ed2a3b6cc4c530e0479309d6287b692e08529de31d830126afb4a4652a8aeb3303d3547d00b93b661edc1b226d6d79a7761fd1e43264a090a0d8e9cca3454ff74b8257714e299ed3c6f5b6648b9c26bc78ff09121b9a485282e4c5c2b240129ac0819c8532b0b9cca4472c180836f7285d09386581375779cb546d4c8ac6043b3255ab1035c1d6e07647f453130bbe2aaf04e5b7bf49d0cd6474c25a75c67901a23870ae77c32e61af3ffea207f8749100649c3cc054c36691d4127bfc7ad18e1f018ed75f0609001dd83e41d6e2ac66964c248eccb2802c378c9252146c8674ac23b81fc13b0089add0152a1141a6472370df94ae57e54ab1c3a26c55f24a1dd0ccd360e794f0a63987a08d50ffb84a76d3689ac1211ea5d8917dedd6abf81476dd0ac1c7017aee6abc9ee1a41e6f5edd0b89b9d99983857dc32914abc1e20c29c2c2882c21923c947c980e43393500716ba97ec56ce33fd4d01240988636baaf5aca649f87fe606606fecb888b6a7c62dc99688774d648982ce1cbaaa3282467050963b31d95c29f55d427d4166b142f767a695ee5be116bfc9455f405c12a1c3e7dbb14564f94c73dc0a7af0aba2b89c172b2fe5f9c059c0a51fa792481ba1fb6f97faed51fa1e1857eafa818290875f34d876e2a17e5adcc7bebc7b01b941b9934c2e4942e9064d836f976444ebff2dd6c52f44fd9132f4a4a0ab659f052f5b80e6696d217568dea33b7a90302d011384961f7809b0238ed7e26a28492676e4368ee5548a3f5be6b7c3f4342ade03db48e82bb247dc95b52638fc38802881d0c2691f2801d0be3a66700ca06e22070d3987ff4d44db8f952832f0a74e43f77b7874bb68fa67435fffb3a5d98b034ae7766999e8c9563366a70d86110deff01dc7cfae0391be8ebad2fe2d816a06daa82ad16587e43c91dcad74b672541420d12c50f82f737de005ad7235436f404e87ae5b3ac732a92a34bfa3c20f267fd4c7ab07947232044ed716b52a0eee6bbd8388d7e4d15c904a4ac17bc8a7c57032a9e8e8a5c30ceba4a078e335cf0db5a938e3233d9e16a503d741755da53cb2b848c86c25199e1245000f93043ed0b8ca80200a4d1cd64118869789d5e90f2b393c38faf9492f91051c29563e737b8d7c5c704dd199696ecbdf796524a299394015b080f081b083dddfbbb0e92e54cac171d082fc24500c43d3192e533573280171d8acfb0e33fc3cc2ba48f17e79700bc38bdd079718ab17b78f8e26c5abd38b570f0e2740200fef30889f313080d369831481685caef5a062fcea0a9e47b518a91645422baa2362f4ad98e17e5171e456408b2077fcd8b52a900dbc50e7436cd8b9f6366bba86dff1cc9aa4168760028e60680a22e0104c59bad251901c5cc0050d40b004700c51b8d480450cc0a00455dc4a5116dfa2180e2cdce50208062fe0014b50730a84d3f01a078b3f3880050cc4440516f10146f68363a0028660380a22e402b1b6dfa4240f106cf7c4031f780a226c06bb6e9077961261628661e50d41d30316dfa406694857f80621e00286a01f88cfe8ecf70cb0728e60080a2d631c2ad4dbf87d175ba30baa20f0050cc1c80a25e81a2ca69d30fc7bc012866ad0128ea1c5054c1367d1c50bcb92ebaa26f3300c51b15088a2afd81a2a6ff44f90614b3e6018a7a0798b46d40f16657998cb26c0d28dea87480a24ae70045adaa59e300e9cd162d28de6c51dbe055ba1615499d99a40227a67136b3e19bd31a5112b09766d4d42475269426457369ad198cc2742a8f5dc49c9868100d923ad9680924d86ba63edf5c37cb3564a1ecca2d2525a9c314862ce6e4464652c777b7e1177e022761240c0b1386c32d5c05136121ec72fa7c6f4e6540c96257264c8a3109690ae5ebba3f5ca32b044605a9336363665032398620757cdfcf375791ac601a93449c2d933a54db5c446c2fbccc10238707fbf9ae9f6f4d4657f445215949636df91d8d4d8fa40eb67c20b2c73f67b1ba7b752315f46e7bce0eda5fb6a9267b2d49007b326dad71b66912d4a63ff67c516362e747142005d8b283098a40f6fc1f76fec654c294404ca94bd3d6db9f7ef69c2a5a7a983d147776a84a2582ccf6f7917252ea5cabe420875486568656665b9e200fb1b0b267ce13a6e7d3393fb9bb3d6d0e91aef9405461026da74892ec49bd6c31f7b03939e80955ab5beab9d30f7e53eae1299cc4113ba16def4bf92738cb47bf50d65aa5fa705321fa725aedc559dbb8ce4bc9e899ba6bd2e66cd0dcc081812a878e1a9b1d3c6efec3ff9bcba0cbc02b92b327160f2d0e4e475f3467ad73cc3407e3ae38a741e7f3714c74e57405e6a17d24586ca645cec5b99c27c8593e6f61b287522ec63ddd7baf067f2f0777f5f7de7bc3bf37c8fdbff7de7bf3f7b22ef8f7de7bbfbf97e7dafcbdf7de9abfb783cbe3efbdf7eef87b815cd5df7befc5e0effd7175fcbdf7de1c7fef002ecddf7befb5f1f70ae0e2f87befbd37fede9d5be3efbdf76e7faf8ffbf3cabd7706e0de7befd5b95368e6affe7befbd3deebdf75eeeeffd1000f7de8b736feaefbdf73e8de7c1cd206783202c9e0e80fc188000767c0440a7070034c0d10087831b2b1dc20d34c8c1c9c0c6df70cfdd703540efdbb8edb79b8d9bb1e96ab66db3d96ab64df3e0766cdb66b3d56c9b8c6ac360db3ea523874c25c340e6d1641be3138d8d0e870e372e8d8d17a7c376d452b9361db455c964797399ccc7a7f18e3e6ee08ca6b5f6cbe59a1dd49f6f0ee394cdeedd14f7b6e7eddf896526f9d898eca1201c398bd26a85d62b58b687f3de572ad2a702ad5eac55b6f7b548f684ef7d6d39ab6697e76d6086f4a9473c2f5234b677f35e7dbd9e5e605e514ecec3a30ae953953a78915ad1247b3e2467d5714c1ac791e98af37c11d2a73e0179911a01933d35ef3d1d725695c968d191f754c87974bcf7148af4b1403f5ea452b6b703ca59d6356b79ef609cc7e6bd772fa48f3d7ad1c1d81e064bceb2af57d3cbcbeb69741e1c4e481fab248017fd0925d993e3e52c3b8eb011c953bdf7ae83f4b14f3b2f3a0fdbb3f19e9579900f156d2fbff7538cf4b940d3879d63c2c89e1b31675d974be68272cdb6477385f4b94701f0debbafd7547a2dbd9ab647dffb7984f4b94ad387d5797126b1bd1aeffd2472d61dc76934bebc991e2fce29dbbb4fb23000785186b1bdcf80f4c140f3bddf80f36cefbd0ab207bb64ae984882b3b0cbfb22d2071f4d1ff6a5922702d9de6b04e7d1defb10644f7def43e749bd062f6eb0bd773c7ae08b747b9f237db0128eec71161ee9cabee7fd943ef869fab0ef79af81e78197b4ab8bb2b8eaca711d4d1fce0acf1165715cd5ae97d2f4e15e1d286dbbc964a36c94d5a7e9c30101a94fdb7e9551d6368e553656d9586540d3677bfa01e4a2acedf572bd5c2fd7d1f4d9940670f4a2accdf57abd94a6cf762400a56d35996c948db2a7e9b301edd8a76ddfca284b1b472b1bad6cb432a0e9a33df900725196f67ab95eae97eb68fa684a01387a5196e67abd5e4ad3473bd2511a292bcb64a36c948ddbfe7d9a3e1a508ffbb4ed5f1965e571bcb2f1cac62b039a3ef90900402ecacaaf97ebe57ab98ea64f56e2e0e84559d9e57abdb2ebb5ed63a5e9938fa6064a948573d65886c76d1fe7e39e9ea64f069a3e641508c8b7889ff653d9531995ad40fb3494d98083715634c801713200410ec659d9f6736e523c38ee75f3dc6bdbc7f9bc97714037321e321907b4ed6750d3e9189f6a461de3f8b4ed833b389beda554b3bd746c2fa56dffc360c3b1b9b6230c36178ecde56daeed68dbff1c9a4ab6016120c321f3641bd0b67f6323e7f1c9c6e88d797cdaf679dcc034da4ba96ba954faa5b4edefb8976aae23cda5b934d7d1b66f53c3ce649906d4b564b22cd380b6fd1a239dc7a73c8ee3530d9ed68b872fa5acc197d2b6cf693a2a9d4cbeb3ebc8b52d78b4eda738a11c3e95641968fa6c2328aa545a63d9ce40db2ae98f7b926de3f4e1be481ff66d4bc5c5b4903a761bb77d95f7816f1930a78aae9b6cbb93f3881369c79c47ecfcf3ef590478fb53698e7329ecaa8baeecbb5c1f3817fbb8274ee6a22c0e8cafec87d996737151dbbab898d4b13ba78a1637d9b6bfc99c07cc06c5c168ce5a4b0ec90d50b995742e666dd6aae7643e2ac3e2dc323f559a0c78019c1054903deeeeeebec3f3c0531f0a1e62145cd91c6c990505aecde974f373ceba757fcf885377b73216dbf5f3a79d6ea79b1e50fb1944e1c62b32c116e6b6e005a48cba165fb88eb65402e8aa3fc5acd0b10279c57568e31ab4f15331d2474a1fdbe3a761644ff7acc9346663c7130a8cea098bb429f519ff6cd2a09851e0e1d2fbe0c88f15ea7419e5219612fcd1cd8fee681af7daa6713bb6d7669ba79b1fcd5aab7e0cf7dfdc600acae7e119a9ef3b3c112a131393b7349d4c934903b9209d134dcc06e3c73b4c745535d734cdb70f3450771ee6fc6108c4cbc60fa429c706cd01e92efe1adffcaa5d8105bd2b2075f05340fac05545592af80abf93e8318fd9e0094e210cbc22149c4473c83d83f7834c1fb9e3e1bcdbf4a9efb258de728c93e1f08a5cb07a78856cb3baedfa2777cd5da76d910034dcf950f594898eae83c81eb977360d695efc1b3830f091db878ebec2ab1b9a46e5ab95d672784634217494d19ebe9812e9c8b4f1774f71784552600b73cb8062eabbd75ee519d1de035b981ef3108b1e63fad1ea400decb4ea7d0b75e74722b3f3dfe764073e7d8e7e3a609a82f0f45e58464270b8f3a1ca5b9476ef19a1413ce4412226991327041584ae38cd30464a2e0b8235d1592daae17970f347e319c9e01c0245ff4964348de88bf7690b48c82b72535c900e7ff8af52693de60ca1ef4feeb989bf7b7102b16b7846f2fbcf18394f77f49af144c8294febf09b4393a8a3e338e6ef5e14f2c022fe4da26f0ee550c18f82d4c1eeae4e88b350a02bac04b524674d58ca1fc0182d4e214b97a40e7efad151882f31fc9f23c7cc0c550167d7b450b73f1299edf9b387ce231ae1c04ef4d745b6f7231c38893238877c0a4d21222e7bceb30905ffa43c6a26a78c02a5ed15f1dec116e607f953ef9e7f4e7d2ccced81297846dd0764fbc40eb60bf18cbc4f9c401c89418c266c638c9fc39db79c07c85d1a7822e4f7bf224773d65a2ce4be14e877812d878aa64b7404e188068f70e0053cc4cfc2dc1b98c28f17f0a3e03cdb63cca47ddcf6e579c5c6184856d24baa9f4c94557de5df650d631ce2e778ecd3af7e8d4f888c64eefc3b94e54fbec20f66e3a8240fb33106daf88336fe1f4fb4e87f57a8fee4f8bd22146c61ee0c6ab0fb68cd15c6390b37701247ac42bbfefd797fbed350d09eef5836fd1c22cd45a9e09df781ddf9a5f529377c737cd022654d222faa26bd9484ecc9811e217dbce88acf5c70e127e8338a44dff31630ffda22f3535e91f917949bc23aafc8b49bca7bc11e1e52b08e30412959142657f591b4a45de98823750059813ee2ffbb3ae82fe93fc41dcc41e8191235729ea35a93f66d39cc75643ed2f695fbfaee84ece9be7e37df03c5e9b2bd790b98bf7945e63b9483f1996c86690c6afa741a8bf5a0459fedd8b3524f531f7df21585499a7a5f39d59aaae87f28f34b1ff19887f55998dbbd7828ba93c3809c4774a75dab4bf6c8fa4960c6a830bbfe0f18b4e84eeee43c1e73e9d291a8bb23d125aa44b160f19c4daf7858fdb9499f3cac150884e915c8c34a6352a7be10fa087d16a62355094495c89eedb9dfb6bf9fc881e274d9e6b0e8ef3207e361fd9c1e747d975587c252a9087675905e79ba3f63333663dda657a897c7b111298cc2fcc859da8d5ce25abffead4857a44ea558bc68fad023a48ffa957af926d592a64a49489dfaa2e7b0eb733f5c5aa43198f388f4efd72fb2c78f50ff90c8587fa7a1a23ddf7d3ea5e01cba9da8556eae503757bd4e596d8a7a719e1e3416be4ad39f4f9f648fa493562ed5f99e9e8775856a77f6d01271a0ed3b149c3c48ee0fd164687c04c9058f50f07ead427f86eab306ab874c3879438b9656cb3af3429cc77e0c170ce11b2104e7a9b1e007b66efb41926d2b0d61841c9f5c51f76ad4ae4f6badb2d65a6b7561df2c575cd9a21ce5df0fc179ee8fa0a239abaefc6ab0fe21839e2d0fa5644a638271cf33342e4a29e5e74c8f3e2769473f107ce30fa2895cad0e4a991227845215826c0d04d96208fb88fc4e0c617bd769da431b5fe34f903df9ad9e2f93f26eec39ffbe8d1a9fd42627f3a53e51a5f70557989f0a415436dc092dd0b267befdd944f638cf7dfb53c8ce2b2205c50f6c79c54e20e731c1431baa54f2e7bb6690ec9992fbb7765224e9c3bea863b59c55f3d321849e20d878686d9289f4f22d9d394fed0312a5f3d39f4f73e6e867bf15ac7d77495fcd7befbdf7de9ad4791ff8bef7de7b6ff579e9bda9fb61ce5a7b185e9bc569698ba1d427482badb4f2f39772b6b4f33895f1192dd55a6babadb5d61c1974adb5d65aadad44b22db35811dbf6a5d7df62be9fdcd509cb96599cae6cf7a6b8ed59634f1d53f64c4daeecdb6cc73c45db97dbbf8ad98413ee0ff10bde90e9743138b9e5146999c50a2b5b66b1e26873dea9bce8a6a524d1a7a391d9bc907c2041640f1a6364687fe44abcb1e9933da93742d40ccac3a54d43038af5b52bd0ae11db63173127262c5b6b50a4443bca630a4316734aa540d199f6eb8924249895dd75a0e8aeed5406942cf6b461528c4948dbc6e1d89819942c67242b98c6a42b9bb625dad93b5b4be36850dba62f725bbe4f9e3ee8ac51482964382b1572456b8c8c8a85d64d4f0149f6bd56a98e7bd22dbd9a4445b28238e0c5da43035eac4294f0623d8204aff1fed40cc942c1c88bf50506bc589b2ce0c51ac3086ea30ac99a2e115ea42950c08b748b222f521684e0ba08c99a30105ea422f8e0456a020f5ea45912f02285512892359d10f0229d81c88b94ca7e91f630c4535e4896b70ef0a28b618017dd8c02bc485f1022e38464f9cbe745d7d2f3a2574180173d05415ef42725193209c7599208be3a68d0f225b883657b9c33d775dc10cfa2de19c43f846e1e601ad504a7f6947e62b735aa499f6e339d765ad5d1e049aba6b1d91857156caad56854a1a6654da3d99a06567b6f9d9fa837e6b4ac69793e0627c6396bda764268a9bdd652fa73ce3927a53f2db5d75a6bafb5d7da69a7b5d65ad05f033bfb48926ed68871d2d68a55e8c40e23a163bad79b820e4ed061462bd44de3e10d2d7a6aa973bf86ff2a95be5ef40929489d8b8287f77384d0a2def763f7fe910d50d6101530207d24307ddcbf7f5fcf21b13dafd8f367128b9b4ff82183963d74df9f462fd0dfee6f1c0625dd91308d9fa6e0f7526b41fc9c6704532a653b9b42e5e94634d28b1bdb8dcfc627e5782754eeb49c2ad5dc4013385054a924b881db089a90672c386b8cb2868c4e20fd46e0e40f710a66106824db390f96c9f9358953923d9e13b22725f3a91428cefaf2b8fa929d95ef7747cd987bb31b38db665af5219ded189d51564542ca39d248cee37bfe48c791ce2315e6e1b45291ea8bce26fe5918a82807b3e7ff8041d797f36cf4079a1fe22c1af071e813f5329b3c9c4b37b468fa1cfd56a8938629da602df270cea4ce3c729f85b96945aa583aea3cb282a92c903d5eeabdedbd979f98023d707b2a6e4f917eeefb5cf7fdc61487c1b2ed3737fe56f02d526a86ec997b3e3d63b26a8caee6cb6098d5c99e55863d5bf8452057f34db0e767d9136a4f2e629dedf99c5791a4cefc9c299a22c5f6fcf91628569f8a64aeb9fde63c582e6da24e1e4eca654fba14c659f3e9cc79f03f8eca662676f3e992cfa7239d383634b469be3365cf033ac58abf89e59b41334916c6de2966e447328ac8cac67fb7ed3e12996d04ff055b98437cfb8ed0df6610c8c29c51b2a788b3985a8ae9a455fe10a775d3bf20dd860ce930eec08b69e8af02de2dd01e73ccaef4936e7ff6f0d07bbafdfc193567d307c8f4d1e56c247828e5061bbf9633b246eee654fd9c01458d6303c59f3efa3529545f8e5c6dafa596bd3d069f137b7b1c05d8dbdfe8607b379201c59c02b78de6dbecdbf87e6c3ccd097b1349d81b68e3e5a64988d8b06103c4913a1b48f372d31f9a772109119ab79686e6b7ef7aa0b5294d0992880d319c2158c1eefb8979cb9ff4ab88b3e55b210090b187b0fce9729e2b7fb65c30611b412a09d9b549ea95c8a46472a8294b6b194957a9d4cb4c29864bcf820553f5c019811f28394ad1b4ebcb3ae794b5f370669a5b3fda39f6c22581edfa72f7d8f291d81739b03d10891cb37fb0f162fdfca1f31cf13ef450a652a9542a053ee8396947322b985f4ad943aca037f39904afbef74368fdf29e013d1089f6168362b69e0732bf713232325aa60192c8e55effc63da765b4d6325afb8ef33eb1f380842593c88dbff1338f648ed95ab6f748e698a5ed3da62fa33f2d23da2da3c1f7d0f33c24f6c5d4b740f70f1dc0f172d71a8fe3fb99791792903003fe2469251909b9806078a145e4c7850f8c59420561948186983144665e49122233a0129abf910291d8f7b81f66de7e343640570e22336093999f81ed0cce7c3333df05e8ca312801a9e3afe399408b322684fd99b742ea27765063066ca222a264e66b804d32112599aee42b513203bab055d1e1081b6658220a23221f904e2f314a9a9eaa4843082292aee42ba9f14a667e03945503d47425df41155dc997719926ae8a2a3bdd25655df79a4384ae4fc2f431926082ac596bf7604a1d9f2931498d8273ed39b779f9dccd6bda8df69b767301674d28bac23f299eb3e6757c8e573d063c387edea0791b357ece6821431210c20824384f9680b3fee7a7e03c746aee19d1344d48065050380370c240700a7da0e6f1353cbea6be6351b4555b66c1026873b5dbf1dd3cfdb4ffeffbfafdf0f6ef979ffbee771ff7ded77dead3fa6bd4781a9ac7f1dd507d187c8e4ff53abe1cef9f8eaff9fc6d3eb96f7e884f580db6d9f1e1afde0778dffc64a2fff8e70ed0a6061473ed6abe9b9f3b87082d4ea809f5a263d9f8455762e3175d48083fb7e39b9b47cddb7cf58cf0f89aa73cbee639ef7688c0e36b7e88efa8f95a987bc7cfa8300e14f443fcc6774dfd0bc8953f940cc5d9b2e1f1edf8b2873b3ebb6d3e0fb4afc1afe39b613cc49fe3f39687f8559f0379881f83cf5d9f077988ffc6e79fdbf89cc88b3ed79fcb7cfec2ef7d0ef32b8e743fc792e44a1e8efff9927b53f61975721eed77fdaeee5aed27b5cd1e11623577affed683ec5aa767a4babbdb26772ffee4b328143c6d99a5cb95dde5685b6b6f68d1d803c1e737a3b0bfcf3c0cc63b34e7bc71536e5cbf9a9c358c71ee7276d0339d87136a688a21595a9ab131c638632fc8e59e833b7586fb09e53cf9797c267bccf846b0a0c433aa89640322d84c318de5f01d408420a58a27050900e931e29e160eb0852440f2e0dfbc6eeff0fb9187dc73dcbddeb4b7f7b6efb64f4db1b2e4bd8cf6a7d3fbd4adb53a6ded3ded53e3ce4fff62b132b494df6508b33508abe831d163a2c75a942ed5d73b897414a2ae1e3836236da21e1803c18c93e331ee7307e278453658d5caa55efcce73ca4459381ed3590d6d882a1ca03f81220d0a6f809906f428edab0ef41507e617f3c679de7beab74d6fdb96da5e664b6daa6ddb3ec8b66ddbb66ddb96e319d9ba6ddb64b6ef3aaf03c189e319d9c0143cc45ffe21ce851dfdb66f6e0dcc86e99c4c9db75c4dbed7a14a148baf9cbe90ee47a9481ff8c8431c16491dfcda4789fcc96555360633141415a39449f6d0ad514da323dd9af653fad071fac0afbd967a24323bf5be395013b2a54880edfd8e8cf7da93f1bcd17b21cec3bde7b3bd2780f43e88ece9def33ccf7bcff3641ef48c78329ee7698fcd3c967951bfcc8d5764060cad56eb094d4113aebce5091213bef6de7b2f045c509a26fbb95694ac3c011440464b3c26d65a6b9178f295041365021261804c482208ef689a1a3f4b96905ba8c0b0d87105587111490912ca4c7ea680090a98c8518a1f7cedbdf7de8b63df7befd52266b6efbd59b4e82c29a8416ef1824836114608cacb154ecc96f0e0f262975c5faacca62934686826f304370dc99e5cb9f7de19165f49a5a526ed01332f610d1dc0884571c117504d88dc1df67dfd65df961833049530c43873d7f5a2a8cac507345cd5015c185da24a45174552b80294305151f282285230a94c38456152b493f1c516638ccf10a22b99f3cf0d32dae414443023308808dab6018c600c125f9c44b0022074706d3238e9321be221bee00756748318980f485ca1a105dc1623c238d9a10902a8254304c929c080c26310e957d1146ce402261915d43003bef6de7baf962186f6bdf706cd24b0d8333a202bc5ce40492042a889097624c3740415453a218b714eb0b04e8860ad566b0a26da320a588bc849511dfaf071feef903bd18c4411bb4e6890c517638c3186a2096a639cc31014add2345adf5087cea801430e5880d1058a9f31c65011c20816dc07ec300baaa207275c15474f3efc4802821611484cbc10b1c5cf84c2618c1fba128ee0a18624ae1841144ae6932e320419618c711090af649091a021adea7e5250c49210c8926a80a24395a11b4034f9f071fea160cce42e859f31c61896e42b393239d905c062a110205c3c18e1258b2b58680f5d8af0ba94c0a5559a46eba5314362965c308c31660213b431eea1cb82461951b41f262e6ac03180382f78428b2d404c61e50b26921859c0822c323198145d2c90c08c20ca920ce30e328da32516482d58985c18635ce5c3c7f9b7415aba5cb10d6d0da0220811784d00e921a78d68cc9596eb0b580e38074b74022a122a87555e2b4843a9e80730309528f785289632e00a59138ca5d8bb64ee501c7c1e91341fe7c3c7f9af42450bed89b5d63e31f2957c6598465225fd183ee009d34e102fb90aa127202a85dd42d3b8269a2685144d4dbeb811205e55a986a46ee9873a8009d7bdf732f1d68e945454996d8cb355420b0d8c1d722ca850c2894b8a6108638c9d6839c00917187ff2f4848a1374618124c61833f9f0713ea84b0a0aa32219c688fa82a50c5c44654c92a6699af653e42b7964e50a16a5127e9670184230f1e104569c0cc1840c430a1745d65abb84155fc92b198b56522dbd91259ac29d2ad689fe9a74efbd5a64f0b2ef3dc2044a206901c58c9f228c83982c9a946c0892df5a6bc388f94acaa08a84316bb98a4009e12064c87eb44ad3688d6fd0966d015ddc34848238e8d1c245d40ba2a2c002862e36fc28a1699aa66521e42b4964f482212519c9624ceac249ebe2cb931fe20e5cc64c7162cc099e98627471e24a54f5408c28ad20664c5c60a96734a518d074efbdef23048d9a664ad012941d6ed0678c3176f94a0a11d9225b18fd1845c8b0a488a84b1337bc649210d22a4da3f505bf20995165a8082943d8862dc61a59b640810e5f77982e8b2f166ab55a31608c31aeb131c618bbb6dc2283d0c6d8b593c060a225017df83817e3ba25cb0d395ca37ad444ca3d62ce643269c8702706891d8b2fc618638c316e32c2cac6d80a4d0ba4705ca0c829622fbc6028081fc4bc8892b840c92243030e5aa4f03065054a44f105d7d02445152f0a0d5cb23c63a4186717bcc08698983fc6788c2669204dbc61fb846b63998d31187a581b20c62593f029484c1c146f26c5698b202fb27851a362c0d7de7bef55c0102d4dd3d2c3089a3811c2e8c7059806241f2a52102e269911cc7849914c235dc96cbb9c819dcc2636bc144394b404132a4ba4ac00cb11627cc1642597a525268c317e828bf6908d1248100514315aa0d81002a3218c5a60b92c1947284a10dba161009391d5b20570400206298a20818bc98aa19264c91353d3981fbe98155130b6502e387cf838ff4d59c420858849c489549c1882660b4b2d529c5ab70a30568c2a3b425b6a88a2822f4870c49319943c29f1a24a9221588b0a0e60ca408a61280bce0b4d0372460f49d0e0c44a165e10c153367e5db497e8a00417b2041e8ceebd178acc86dc321446b68778b652f45333a8035e18b5ec4d4fb49c8a1f2daec75c98e84ae6265aa569b4963286a6699a56e42b7964e50a16a5a5052cd19414dbf7feb8039a8062b2538788f94a0e21cb4340e921662a225a4f842bf42efb4ef184114245f98bcc842f505a0b0b70d0863e7c9c7f210fdf7bef76b7eb5234dd1054a150b282a12a6ff1c518638ca950a2b531c63570d1fd6895a6d11a1301652230553af8c08f1645428c71c4c513938c222b5eb884a317141c143f0049e1d2c36c630c055f7b535130ba925bbb4b2d8021480a1aed892c964cd932cbe2880722a2789112810a2334ae931ff287f7091a829aa2e81283c18910d5034baf2d34887105891db00c398c51daa116162be2e1c3c7f9bf181812a30727c0b852051522b7a6b12f0e44eec5185b0d4fa182102c696202511469e143154fb4cc10021aa6e4f0650fedc841e34806335e512ef8c20823820033b524b19480a21ec000d3da320b8356d1524516a9a0d1e28b855aad56138c31c63936c618e32d474c1be36cc7259a949d291cb64f348d8a29464f90f8ac598c313ec3e52b299489f403ce3052bd6be609eed2e2a29950303ea93c542e4442331d232ccab862044c284144858b0e2e4e8a1aa880e2046bb55a4fae6482b2e2c485c9101eea92a4699a06f395444a1a999c620f1843e62bb9c52049617297178a6820818c66354dd3b4fb9ab7354dd3b42366be922d971091d16d00122f8ac3fdd162888240f518638c957c2597624dbe9256ab2110415aa569b4c68106dc84039525fa6b0c3a1830851394fd7b31de72451a1bdf8dc128c4c4ec96518a14a37ad444886dcb134948f91d7c826af1c594a9d56a51c118638c319eb22d9bc288da188b2562d8b62d4cd0821ae38b26a204e1189ad208639bc64499819e41b110143f685439da4952e4840f3f28e170839527a6174c70d102a858abd58a6225153324410521021fa298587c31c61863df18638cb36c1ac18f56691a4d0375103e4041b1a40b204d9f08f239676cadcdf9adb5d6da28a85c42d4ace51222ca259061a47d9a267fce5a105cd62a1a560933d8943a672e64bc76cef96d9ca7dbf91f27eb336625a0d17a2c72b6399909d56ab5a4dc2bb534d1b4ef6c37b9768d2c6440fd7815a3195e4489bd60c51437c81dc408e386fb2f7b780e60c6921b6078418b491573563486071b3235b2e4a22b99996427185ba9513c11e48442b9f77eb7afdf7b6b2d4307269e68594195344a40e46229fb76a1b20315306b5dc539bfdbb8fe9481914559ed7b1cbff2c5108d0e3f186f50687124b3c86634bc38bf7d7db981bf2ffe8ca1f8e2858d9f461546c9c66fe3aca0c5a864cc184a7b9aa1a90100000000c3160000380c0a064442599ea6499cf5f614800e6596526c50369d86b224485214c510a3000000000000208800829073b4a3001789589a955a9b67b75d52f2f90cb9b4157bcdd2c16ce3e00a990a31292226c739bbbd9835c20adcc6afa81012339a8037382fdd96c7f08b065c974661e27fbe4b6b2600cee951ed6d1c1c96205aba8556c83643ff8511e10c604d7a368661f77c56de01b4617dc87331da1eb9a09829d58134a28a237f74e4ca32aae8855cf3505a7cdce072f6b98838a5d6a375f2bcd63d2c995f60756cdabdf3d30f62ae806482f2e47fd2d0745d633cb442a43114e0ec4bcc81e0860d4f474b978ff8c71f480d3364e88b3bd2e3bab5e32faf69da18b2cec5c44bcde9d49c5e95099b68a5a701e4e6baa1272bbd14fd1e7692dd4b3bc99b8fba5a9c3c8ef5ec7a01abc045be1013800ec5369816f763a72e882d5cfc32bef807ff526d70d39601b99b926465357582a9a4acccd80c1d7c0992d1a68bfeae692239d12300edae46f6ab7ca0bb8d1ee94cc9925dc131abc92cd9dec37e20944b2766e17a123882e69f99e7e34aec1c67275835854084012c2b051d2f3360ef867c98be957e8668364aea0a8a4054494ac64b56fa0f73e6a633ffda7d13a6344c142b028d257aab535d8cb8d4842da4457587a87159ef481344ed96963c519c67e13addafd15397b633a8a08a34b8f0ee2193806ba69aa9f7974550bfd34c867623b14251abaf7165845690ee8d4aafecc1a9c3d4cd2b5efef7c82a8e9adb37d6935613b7d97c1ec4c8d7f0a486aca200fb12e3a03bdf243d0cdf6b57e274dfbed096f8dcbef9150e58292f0d7dbc28fd5854239db3400c10d241b4e16e47881bf28b7815201a36e38c706f89ee09557e7df2edca497860a1da903fe008c478d59a620c59a6ba01f05cdb7e18c0433643bd3feed737260631c9e07d006b5bf63808adbc7b45b7ef99aa0e5083a693e85183120e430db11e3e40907ea4618c467097b8074336ebf41d69d1874b8927312a54df0b10ad126090f2f62175a70ecad31d6ac2c30535e3e16a8ddc8948978012eaa875417b41318f703dd749607b67573e026a9e06665b282c4fcf8e299fcdc5c45993af3108d9f7046db141719d84240fcfdd6f09f3a1a9efe7603bb0744354e9c20019d4e9f5e7bbd596b9fc885e9e5e36f9fc8a9ab77be6c6a20d05a692df0b1253154b6dd6d245696b2afc72accb89cbd07d6ff1f4797a35be9f69ef5debc61b848a4c37341738aa729631219d35f0b839edb3b0d2e07523ea99bcfbd208cffd0ea2b9bbc9596451aa0dfebd42dc888495b4cf1db9a9ad6a0e38963ac28bc74e88861bd68a7ff8fdefaa4de013b5af3d5f2a02ba7e43255b2022065fa05515dbfce106f54db4f28bb7552e39881a4cd65865cf8fb0c5a1b38338633248e159842ba32e12268214f8a898b87fe3865ee5ce60ae80503f560080caf3abfc94ba346cc56d73435b2a66abcc7a44d1a1cead361b9838097d26b0ae0d8c8740f7ee85655c34356d631faccad21663422484ed4a4f5fde07582a2273f61178228dcaaca68055963f8e756ca37296d4b64cd06f6f05d172a7ed8de872a3081d11de94aa91798c980f1db1d6cada53246d0cfb194a6f62a0241bc0ed903f193288c7ca587c734b5be99d57619649cbe0f4c3333ece7b34b58c9b4e27f03f5b974ab95e9c89218d10b1ec4939bd4884953396d851d368ddfb7f13f340bf227dfd1741bb8fe5af4f3ff34e5bc49884ab6eabc5254af84399184029c3e5f463426b2c7c695e5542f3876a1597d79e0ffdff15a0a423cfd07b6eaa2756eb4bff2e7696b6fcd01092b9f5ecfa9e43cfed87ea1b0cacaf0b63910f719b5b5424e60ef026281698ffadf90c95bd336d7509676ee0250887152e543fdf4d0ce9b2835c2d8cd087e5b6e6f6c4aec81e1da1d356a58ede46d3f906226a0e856db6ae22c73f686e3f4bef09d476619aa291edf112a6db9eee92f22dd96cbfd36e35c315f161f0b46d324b0f879bcf98adfd8eafdeedccf22c164249ad8ac917983e181f9f3915ee441bfb6ad680c9b45468589bec364fc56c0eba51a864602bb0cc7161784c4224ae9089b7914eac4ac63d78e58190f1d462b80638e0bda7f4b5021af785c2d7805526776e6f60c979ce3d52ab4432dd815e35e4a0c4f94a25c16741d6911b6896fa3168042e74e8193560fbee3803a5716ef90d40c94fa423e994f9704d4563e9c484af9c5410bd89c4d94e3b1fb3f4e0493d562533e9b8a33f7032a42b646c56afb7b85d5e98267d4435a07e53b1f84a77321bca95925b94017437c005b39a486aa3415ab3194553288c478e017678604c213751d05da19359bc4f7ace368bbda50b60392e5b505e63b35aa39bd0d7fb811f2ee6a0c232cabdff2f178969e5c7fb3bcc63d0a5266cc2af47b925b1fb997088f34e21bfdd7ad8fbe7c0d518a52d68a54158b8e57d8d853c9d7b41062a71f60a10af8796db6cf4f0a7be6c8f36d4c199cdead3c01f747b2f2b830947dd087a8940e63b820f4ce65f5fc8b2e2d0bee4bdf30ab550cee9425a937136018405d5ff245d7ad8c077f4018cddfffab03b49e78750b570a49f50eafc38f9a12d526bcc88b46059a4c234ad28fdc13291b2e6cc106f6b4f5aaab4a50201a6842fb2bb6ded57dd6ee06b5567a8dcec04917816a71c1be608e44bc836ebe3958ce016c3f9857777952765a778f18874585ff4b64e6cd430e319939db0887f30c11ff5528158b08e1792ea4cca196046a792fddd925973b6012e7c3441355007fdabc21890579fc706e18737901ff960b62c22d05b65ccaba1d3d969ead8a4af0cb4bf12d6815562c66d6f3e13f2c54fb4b6ed0eb74c3e5a099abf3f3833b79d176563c9530bb040f2cc04db2c351e6f998d0e69b4396c79639d498a5b2dd351e306d8dc62280b9547fb6615e3cd399f5be9f2f5b9f7dacaa9699a7068a0361a48466a4c4cb17476da2f5f47ea44a089e4849c94e3d0d3597d7afce5193179f4ebbbb45296fb3e1e059b747c7340866b8e310673e1d5fb4ba63b2911115dbfdc595574b2fe99dd5e26680acdceb8e799a95c836ab0d95ad4b2b908c03427d96985045c49a4cab93d0f609765b4210d4aac2933e935c8d6fdefbff8a8f753c03b457ea60173cf748bafc448e1b4ebc7fd64d839dd7e7d5143dd05c1b32ee9e004b6c6aa99d00dab977667a1bbfb1ea856257b7c49ebf00824f1aaaabdf5c31433ff30f503f9635521c3bb9f506bac5431512b0520d378e0aaf4d90fd8022f72d806b13fb283189e59191a3e6c091c75543cd6cc87466b42842c45c1c1e8d0e71e93536a3fdb4d1b8b998dba6df603ce243cf117eeb6817d587d830e262b6721cd541856c8a0347fd4edc940436c308b33634fb4e99ac15d2d5f6931fd3c1c26026f0389838850355c373e04e41188ef2f9f49cbb6951ebca41ed52f8cccb902750158c937424795facc0867281b3268eea29f3f3addad0ebbc8840512141a9eeead73452003ab6759f4d68225221076ec90ec1668c69650907f7fd8ee3af136ebf9e2b6681b7dc42191c1b33dc6e669eaff2a3ed0897a3808ae34541d35f771594ed5b8ee6fb618a21cd6c3ea4006d6783b9f9a58fe76802bc45df94f7f5b16767e193a3a9af43cd6f0968d75e8a554bc605cb00399ff6365158bfead1b489b280ebcd5ed20869684e1de3128354aea070461f9c7c2c9634ce70001e97bce1f355eaf9948ac0330701751cbe76efb18859098b1b79ed39d974a016a58dde34f0e0c39ddf12b8ecbf8d7b40d7697e1a5424b94d7f062f46e184889e7d4be6b0fcf064bceb37c45909a679d3826a0cb8936ac8b26a0e45bfb0a4d22689f3ba237fdc72e41bfa32b6346ee399f6e9bc1350b6a9ab827f80fd3cb6f2004a13f6e02d567ced5c13344306bbdc43686c24447436d390603ebdac40a0a44c8f375e1f30a5d02be287f97b02fddc2aaf64b879c398ed31eac6f900ba8ab2528816cc480fb4799602d3fdd8caad6684898ecd63211cbee13733b51ce5fa9c21b97bcbf4ab59b7497cc855e666d904deab169136a81c1b34a455218a8a74388eaa106eb05050d23cd599c0b1b91e4e39464527a120f8fe91a612f693794c90321131a6bd42e4f0c08955e7f4d9a2db9112b83faa8317cd39fac2cb94910b282f74cb23dce4143925841abad3ca5f1dfc098e2165c3b5abd46d07339e8b1737cd4f7ab84d3250058e04982db947a6231d2ba7698b342020aac7fae284ddbffd43d9e816a87a3de6dcd0aff6ce0db0546392b5fa8b0e9542b6e5fd3c944ef5eb794f6aaa5a3589b13d059de1d2c71b6ac6cf0c0c5d72449d795f81883f62dd32c97bd8ee704a7d4367a014b589bed95bab6110b91a8cf39d23635d994c7c8780437ffbd4de259f678358f3e0e2738adeb753e3396dafd4ae5a3b16f2f30894027dff081cbe640300bf93240ec925b0bf86a6efac326311762adb8167f316cc358293a39821bfe952bbd81b4b6c2dbb51619cd0d6106261c7323a41ca0dd5667c1d9c7f535caab2da27f06787de384f4ecfba96b6fdf15f4ab0e08eac7fa3f6cc713b323c7361bac2e96280bec301cea58518c880e4db1cb61e9ab1488abf04ca7c0920c8aa3bd7984ce1587e6660f2b0dfa42bb0c5fb48eb78037d22bf0aece3dbd3f15c8e073605e04e427f4de09dea961ea93b2a98966c2607436d0a554619bc09bd9de262669ced06e1a2b0cc061ee782dd2e0f851c74df6467246127020c73703a1ea980fef963cbb9048867fd464892f49cec9a1f5ff783117af870030c73c4c37f5d99daae862c3cfa322734c74e760c8ee0c65b4ea7fa5e74934166754317c63ea0746c6d434b585eebf15dc4697ed53f178dbdc65a672853f4a6ac12e7745b94e53429f3bfae444d989a450304f4a46ebc9c491fe7c812dd6c941342b3196dc54fdcc9385e2939da9fd842a90cdd0fbd9348eece2503f9592ab468a8f864f6d41ef735e0380ac00e84e11d9ffc7ccbb16b35a83b6cf030a042873c97dea4a22394a1ea657ccff9d20b2515e133c75741df6091256d2c206b8510ac14ede483a066513e26213128eb84d4a4ca4d9442134063bdfeb22e64e774ed8f77b9be1d70e9bf37454037eeb53ad91c6bc1df58342348ce0ded737d76df5a3976edf231b2df75e38dd26e397f2634bd9acec8cad7dfdb84fe4ba971430111f13619fcc9344e55fcd7619dcfb4b427a1da24e10cab86da1785560eb19d8fee95ea9766f3e71c0b87c4b20ecc1f8e572973cb560d5d3920b951670218f17694b82b30506aa73890abcc8b7300384bf6b258932d1f9205c1494e44d981b7922db02a1742397cd3d8f66379bca28a990a2f9e387fb25e16daebe96fed5a79e729851c9eec0ddb79f4b673b6a9f4ad2239a17ffb39897185b4c266d39778f7bfd4d4ca694d5c2c3b4fc2dad44465aea4297525e633446c6a57e5f781983ee1021776ae690926950c4d6095ab7620b78ebc894d4f8a1339f109a79956ea64caa05acfddfd52c5b2af1488ecdcb0b9982297219c97846e9c14f7c6b2d561059da05febffc313935ab09b6e3d3e6fa69bfd06cb36ca4add2df7e66cd8d5bcb0a6f1801d39b5eae9b1bb218558193518f763a38c698a702df231f8ead8bc9d6ac55cb495488b18386c6ae39b58433ab9114de31ff5d1f4b7a727aa9979e19c75de1cd68f2e01e3e4f3f3fcc104e5361fb654c0c2c0aae4c202f308f370da17e580750c075e1c2cbcaf86101a7eeb99380aca3a15c0465b9375b20b912bf46c4ce9dc691f34cb057d28f458be7b3b25956b8b0669d234d2497ed1122ec3cb84aca600a4111ddd0d13073647b901ffa5becb4a8e354435a900668c127176ca3d40301cfbef411a268e7218f7cf23e50af1e0e4e3a2b2c323d3a4312265cae7a124d426a09dfc6099eb50a25099703c7da69b261dea18cbb6455e2a6cb76d283ddaab5328afa244588b52ad98df7ae3200e1558b00b1cc95fe3fd5ea8b94ac8b1f98ddc17581c780394bd45db415e705914c22efecce660f107bdb2ddbe618168781ddd0142890026c3ce6f55278c0c5911d3e6f9a371e5332f3c5d8c707217a9529d742266b51f8cf069f3471b78feb66cd8cd56ad1e78a873e44ebacae533e0ebbdd7e118d785a67286133ca6023264953a19ad6a215bb961b7b1350058e43a35e6b22619893a16e45c8e0575ecc3cdc1aff031900e37c9b8fca8b1265fe15bddfdeaca365ace8cf540189f30de1ac62cf4688007a52a0ca3199eb76b6180ec718053d6cf00b116c20b9203de1ad8cec04d0b8dffd63b28aa32f945bf6703b0140272cf50939a40f93d342d2cf143c3c1d38d573d0599cf963fafafbe1672d7587ab6cd9b7ee641f038dd12cb9b93f94cf7541290d1ddb0258159ec7105697facfea65202212d3f4c6549731712c6186ddd32888562aae5a3aabc151fdb64ca73b84b9180b1a753e9da5ae2eec31adc1440d814ac76b75d0510f7251a633234d0801f812dfb00b73bf1608c6471e0a127edb5fd6cc403d0c30cccb13f2a7918a6428428e11f40c90b3bd7121d717a5032e5791c714fa966e258c99c8c529489ff5606aa729cbd7f865836680a8edcd0ff887766e65ebaf81f215009b466ca1295afd3626468d7bddff5af49e8840da54e7901691308b91e6619afbac60f621595c6c7ac3ec7ddb00343c1e4824653b9c6aab38b30c052236b0a39910517957c391bc801fbbd8505b9294fc0c9682c53537112b056537dbf7bf2e6d752d349a679f0a021585863183dc88d5f02faed84cfeeda1fcbbe2899e2cb38098b5d815d408bb03d3b8b5a6052841f0eac59b9914e783ad42ca8577caed35c3eb485be09b41c43d08fe53acc92b763a1fed1f8a453de2556860c3b521adf769252364068ed6b730789fa7a0a66fdc475a61e1a93c0b8046e4b6bd11aa54726faa50ad02f00936eea76063a81c2a22e2350dea6d6d595fa30916d7f1e80ab7fe82c21336cbc289e3c5e08a6c3f2e0d7426ab58e2b6b953040a60bd8376710b639f5408dcbcdd1ecdb3501a3564ff3beee3a5d7ba0a6758bca2dc81231e0233217306e6283071a93875903b49955ecead296480b233d18fd9e90dc1c06dc621c1e1e37c8f6d7bea717f5a48cebeec09a7cf974ad3eebdf259f9731ffcfc732855afe4217b9190d7473185ec11bcb2e56a42cf4d57932b7a5fbe4fe0900e4e1c0afd7ddd3886e4564d801d9bc023ac63181ee9f913a0c6e013c317474340e8fce98d6e10837a197e636f782fed760c1d21bcbc473f8a18e12243a15aa9bc69124080c97095f74544a121e55fcf38c4de25e97d7f9ac047f3927910d770dcf00d0df614e5d3aa0537dc4b695525805eb702025228c0cadd5f7bec55e0aa4b6b64d4ab14c6e41ed9771f07b6fa135764ab2585988bcee7ff00f6d4451ff7f4ea4578244f5a848d496cd4ee1dc9d14d4b6109be34551b7d781d92058c43b8f700ce53611df569fcc1f615479b6b31dac4a62899897dbd3d066095a32aefaea928bbd9ba5e367406dd8359b9ed0c1a8c15ace934c229b0e8f0281671b316184261549211124506650e851c03036b1ea8c858c428de10ae205115a1cee0a593d4e37ef14eef1582caf7a8a96c52291772ba28a51b5df6ed897527aa45ee514a6641fd3afeb29a390247d9ff9a3b79599ec9b38301b50ca505f8e5bc9db5a69397e36a663db6524bfe555e9ee726bffce6352a8877ee90a17ed44da4f4028892ddb5b9ac9073635a79c7a04a62ba8d3a196654e07ee37fecd2d94a4bcc10c81923b420d8bb30aa0cab28f384d2e4433214219d123c72474c1e8cf8203d9ae303a22a5d0c7c8a29cccd9e357e8711dce9d01628d59a5f1019a24c518c02865ae754996d5877c66ee5b9b8128314485706ce39a8a59f62198088ff674c9db5304feadefddc6a53ff5753855e1743124bae4215dc1df5786896e80330cd8205ba3921a1f7800b16049dd546ba937b7b1b06e0d92f4e496c2e5cfe16eb2de57032cdaa0c92840d04e98c5c58a05821d4d29b6370000bc76c7bc9a303d4aa336b6798b0dd11480d6916f8c164502c38a598bec0a4560a6b7ed4dd5fe37343951320dced3e2af9c44665ab358d9dd4466d9abc90e06b32119e3ef818a82536be931c2c1bee502b4ec8d0293c78c5e78707d370b2495f52c60149a5de65c05897e1db3aa52fae888a47bea337539644803957c5ecc7969473270fe7ca7022678b75e6447e7753b296166e8c0c0288aa5dcbae9718ef1003f5b850bc0e09af26ace3b98d6c94e5e6c3b31724f87091d8f9ff2d1892afdcf6f28f44b0a4fb1cb96e8f9671c840c20a00eabf249c1b2e4719f03d3ff9216616e617eee4eeea27dad466666b181fbd87a26a0b9acfb943b803a80ca30125506721cabfe288e8defa16688228a8e977273afbeb419d400ce206614c5052b257976b522809d31aad04771a44ef1235c3eb4022135ba7393fb944ee74f767f899b392605a93a7b2c1d6ed32ab85699afa22194e6c840b680acd09170a72357f7716cd9ea73dfe565a6146de9384834c24d60a176df7ff0e7b1fd2a2d7272a7bbb47936f108cf377e0c157eb8ae1a27278d613ae701dca901e1a567bbf152845744d0c5df4e370013e3dff3c91aa8d91088d25a3adff19d341e0423d33117bacd8ac2d3b7c5ec8576c8e6008227ca1bc9c645bfb190970d69b54b11993041dfefeaaba69ef6f988e71f4512502626b07201d364c84d56c90fc3f619a9b24b00f2d19eef175fb6c7c9db3703019e000c10c5ea0be93c3699fc5b94a283ba89e13f2b5a8afb2a3af5853d5070ffe843a1e9caabd8f2e3509da9316711ce0d398dcc19c3ad271ad5cc3475b5c11107f739ef604550391d957d662fe4a50e34726a73fbe47120a1e247b545e8def59e39976046985750e79abf9b4c5477cd508286e1011c309539850ba6c9520bc109b265b6302a0b170a0bc35f4f59ac0244cd82370abafd888d4ec14f56e502d53ef24c03f30793c010daaada864dc5aa204bd4a30b7b243ff1152533a945bc4836f89cf813e10fef31c07b5b7d0dacd43ccbea61880c8bc35c5f0b4f5e59630a8f1aeb822febd9320285119d72f15ffbaeb11a4324331e2ce0a9347af1e9101209f680e00fabaa0b4645a4e04ceab5e373e54acaff45d57717d929c69cc0c14fa55abbbe0312b563e829e464aaf3d6635ca1cd3b2d2de4a39e79efe3f55b847fd947c36a13447afd162213f1edc32e61caed08ba90a20b5e6da074b74a2621a0eb29e6541db16ab48534b772cad16738898bdfd3e842b890a6369c79b399f730a6507b4087d1c5eaffa76078fa59623b9aa813db321c290032deab6718561743f2eeb1853ed0315344a00ab4a423c8cecd8d146b1535ed25c0a9ac2d15cc31142e7ed4cb4151a6dee7a89c36cdc3dda901a771b5d23654f2fb767d2819d72d20c37795e493fbef4f9add9c6aaaf9103a6c179633a0c10d7b176b265ad039a53e0e4cc37057a2aec74f6061e2b3ec963f18aa9b0c74327c9c80a1afbf5cc133c2e890ade8ec574fe1001752d77b49e83ae1982e88f0516961b742e0d5044a4aa62db5eee43b47da06be9839efbb397d0bdd8a174e4ddd364e5a42d54b15dab354199c7058f06817686f30a907385fbb0ae55d72e44564ae994bf3d9782d1483d2180633772d4bc2d742488b5eaaa7fba0027c3460ad5b487be964988395d633cc33a7f3f94eeefb22db89413618f0502b875abe51a563b8950aefb3f57c4bd270ef316d762b7d7ab329e93a19a5dfd506ec63d200ae5a63d6e02d985611481c64ba2613238deddfe28f1eb0b2956934395b06c5a61c1bdfeb857736a3fefab01756d581a4cd30b136f763f6cdf2569456f4e04439f20fe90c1485031132a9552fcad82a3899445923a5edee0307867e96ec2e7541d3b5897b0de141b01703a312e0c2a543d9e50df7434fde4857117dd54a436845d57a7ead81f89e54ed113903277db3bdc2a233deda93ad255f118748b2ff4c9b8e190aeec224a0b0ec9c8e3aca01beca1f3435584fcb9dc421c808410f17601c3c4622cc40e481dcbedd3a18f464794159791bfd98168fcf5e7c9a2fe2a88cd955f853d0a690e4b53095c1b83fe1f72d918431b218f9f94f900bc624bf65f6e2a5180f95bc259802aabbf352c83a2a2cf586b3d4cd2a5282cbc2c96aa5f402954d7db7224c611a442429c39d33b0b6c4f57f077afb388b46d666d8a9290cddf9df890856b65c71ef967e03d316ba7301edeb98276a745b202e45e1eecc6ca12e68804626431a4de55328eae00dc317887a8d28a234beb74a7cd19650fd06da3ae4d006c0e850f09eec6d2d5549e46f0180a21e6ce0c8d997e327787723caf2e3e346b23a9d309f0f16e370ff47e43580429d0888ba247ea44a034f1a7a9588982170130c0c03edc250f928f669734fb7c1e90bebab943662ee26c2344357632e7aacd0cfa5d47c512edbdfb70cdd173aac1e70427c81f74970889e79110b91d80c3d6440f49bae8b98afa20a27ca8fefa46baa837ff42a94f952f15342798e8ff3f9fc773899dc29a00336144d71bf7854ba10142ee4060303af38e77a3e5d3b0832ee792228e2c707b03edb572382678c336979426834a5d1b55298f91296e9cdec3e6cefecd6c0f43d9308b54ab9c5719fc0d9062eca721844d4f6eb6fea7e959d720a06d48100c4620a3274615178b1b4a4d7b53d713f0139b51a02cb46c1488b587051cbcd70cad1674047382e9234828ff8b460d5e15e194498abe6e51143f6516eb11859e6c8e8e8dbee3c976ec28e408d81c9a5d390a75e5a5e2b06fbfee77d4d380ece5015ff9e0d4b9154d3160f627fe2bd847fd1298ec42eefb6d029e91cd7f2060f08270a56b6c04bcac807ea68e3537b2c4d0f1d4ae41d0370089554c840b586e59cadc9594dfe893119d0acaf1bfc1f65b83392ccdf8f1b847644c04b4d6ad7fd5d4ce17989dac28253b6e2f3232883f2d8ccc30581a68a5c21c1b10bb1c93a8936a55fbea790fb8aa7a1b8a5f31c1e39e040d2c5b457b67c3bf7e4870f4677f4a19c58fdd3a6c82da9929b4ad5484d34d8219db0c9a4cbf5a606232c40a137fb50e0c2c85488b1430c5b39f72674c12276e356a270cdfbec9fa705fa874653a611ed8e245c7ccf69f9d1454faa1c3dd1d6a94397de4c79d2f0902f3a5262a16274edffcc87b631b3948cd4cc2947542cae2104d86ac5f896115c782a00ee4a89177da304ea6ee50ba0aad21c80c5c34f787ca23e1003fba884d2625b3a4bee767a0f10b2747ca10dc81777d797312079718ec227476d6550449152b3daa840d252f6f5b10e82f25bc9c17ed61e1bce605eb46ce8758abe9f0dd3911b66b212f1390d0506d2c11857bab27525b5272a5a4b95a0357ae5f0d2c4a8350b2e8042d740519fbc09de395c010ee6b4e22755e694ad5df71b09b033b765aa3b22d527eecec48cfb47e39097770a09141e36e45d12736344e32ad630361134448d3b126e990337d485f2279f0fca461c0fad128f530fc15f8b923ce006407785fdfe2a06d5f4194e016d6f3c57cd5ac661ec10a9a6a8f7ed9f69272d136376b182fdf60abc24f497116f4d572a1b636f9eb7e026ef184484e35a07eab254173a83fbe147312c6106a646d9ece9d448e440045e1def6f90b74466721029b409240a849e98ae9646342e3ad809641e74ff6c92eab02023255043d1f0e0e67168acb766272c1506bc14e2164b4ca7101ca09d33b6c3361ce6c2592526bd50990ee93235853096f573040e6daa11fe543f02558e453fee17af8c669890778e7b2c887b3ca9af3f419347050bdd07088063703ba12c100239ed2e9d56c1ee7d00a832a0b5713e5c0f2f45fd227757aafdd15938fde3bc5b417880b7e49c89eeb35a46a68d94468f7249077eb55d1b9a39db78d86de774aed3e3e7b574e61363daffb5bbfcc7dbb1f049b3aa9e1949dd566bf9d31c9ebfecf8b1c2fd5a66253f62d554c874cddf04a4e879f30f0428b6b9990b36d68f1314dbf3d1070c1ea71745330e60fbeb19ce7f9583de72b7cbb76d79b00991072505162a4c4eb6d70444ca030b88416de653057f9f1c6e1df800e13ef3d456c6ce9eaf825faaad51d7031f2a06f51d23f475e89a6621ed9c2d6a9c38998ac10d1fe344e90a106e41843d1176883a62d35dd119102fc7428eb9baccfe4a786dc0364c5920501a97e176d7316969f876f6739c4cbfab26e1251cf021cb1dc48bfaebc7c2a1661e27221c05315d1f41220f8c2835dd4bcc4b78567bea10c8ba4090021bc650db5232ac295337e7d40d43896e5d733f5fd8d95117c707a8d5c662681f4f3bb9bfc143d06a2d248108fef9506536d4cd3980881ca12035c8604f2f32161027ce85c4f7507f0873e2e7ae53bef9467828504d4e3675b22909502c79bc87394d48cb7bb209d60dfa89234ebd8eb3772631f80f01c85790db234ef58808313f398ae307c6f045a3f1ebab74bc9d09339e7770b569e744937bc2763cc4d6636d3bc682573ef2b996d96fd699dc7cda1c7c6ee590c6366666636cca774c5156e6813420e5816906a7a41701fa0dca1419b42d543b2695d649ff95f67ba61807f370200635939b47dd3c23f4ce54b1e5c2e155e9496418e240f31c7b2462efbb7579e897432e4a1664e357374a246216ab4426f97827616306dff2c7153692b3a8f433e40dd47ac317836e98ab48158b0daf241273c5b1998eff9c2728ba6575a8de0d4e5506ed77fa35c0cb61e4f899c3888eb247b615ef28ad104820a97474f8d5b2c430c2560f68b9e27b8411fe0fb85496d3c5b508c7828d3c3a536412607372ee4ff630671c31047b250640e72ed825d012aacabc7950998774a54156f78dafe42781fb9a8ba666fb8c4ae8a4f6de0e43508321dbb0e0a243669528246c8cfe34f41c9e1f11295c46ed444e1825b8a076b0ef8376b6d321ae0bae95d83ee51f95336304fe008fd93f82b58b36cbd5f822dff0c78d63cf1eb2d40e9d4aa7f365aa688f6072bb28f2643fa25816012b3d328a1f24e638e4c016f43e31856744d88586d60ab2c6072f897fdc64f9f3bb1850bf400f4a378dc6bc46833dc661b1e586a0a869c826b54d5dfb1d7c2c9f2a21bdc44792ae0dbfd8ac8095f69b919d4f58060a2e88f988ab14871c0cd63f0efd42403d717cdac51f26443a69e1933386744ec296d79562831dddbcfa541b5726ce8eb1b64cf3ad9b35cce735e90ee36865fd75c97e4abe6aec350fd9e043835ab4b026857d392d8b09cb41d5a4cc9a35346f52abd1d989a9bb0d62829e6cc4ae43ad77095de51a73fdb46afae55203c86bc182cf1e1f22981e93851ee4e88e1b9a7ca2ca8d1faf6a9576bf6547b6e63d40f188b1c52c48ac51d7c215ba3fc77c5070790c41a409a2541979493c9320b851a44767df89a11912e661a85acc95f226283ae522b6ae63592fb868b6b74a622d80e80e96d4d9663eb78ed2a40b2d824a4acd9540db9a81c3831b0a06aaef679994d5f2e10c4d71264b7d41e3d9c67035789034f91c479d5410df09ac25deab0238987124a67770e26ce4a54e42352334fb10c9ccf3a7d0b00c34f3a2e75fcf1e00e52678fc3210c6228fb8e510a0318075a6c0082fa8b8ce72ed2a54fd8904734f199c77ec18d217a34d1a225c2e8c682a60599f0aa0af2649974306992da04e251559a4e7382f1fd3d8a4ac6370e46c20abaf6099d2d84016e9f2e7ad6b5cff332fbf7abeed81798cfefdf44f2cc700e6f62ccd5a2006922ff8461dd0d892630f3709aae03f3b36daa95e53b4b196ceb21ad33f81ef200c2e57b83664e44279bc9f4fdfeb5e6fc92f408298ebfc144551ef4304019ba7b583111f9c30ec66082de8bc081b90ac28d273857f285e61aa311ee13b676c4961a28d3f102b41be004d188ebbd6ff37feafa90bec272ceb2e1ec33a0099770c744416d9e5341c1ccfc1a588b6a8ed54fa65e78466ec6995df8db07a0d1e44a801adf1a85fb14b19d30befa0cd0bda14357ce81536c29445604f3775831e43504717de0ae52972832c8820d74611b1a2bf0ea6483dcad463f2d0adb56d6a45b6c4281e32c715e9709edbfa7089629dc2dcf70b4949632ef32dd77f1245a60c9c48b161fad4c855ede1c7ac0604324da651c362a776bde28fabcdbd30c5108855420f776d40b10c9d5dae25c1ba3889f8cdcd54dac626df8064bdf56e765519d82faf2bd9124f804a58b2fb0fec80bda3bc0ec798848dae2621a1339a1bc2802a628f5259cf00ac225f6ab086b6786278532562970502f380d49b3954da170581d96b3bd1f79d34afe3886eb49d9ff2287f1b5f94691089d46fa9587799e8718ee1789515ea918f42f8b11bbed6a10451ebda1d12be87cc40b3582971c9596df7827b1a32fd45f3d479967ddc34d3370f8e12b0c43f5e6d49a87b2596c20a6f47a4612bee31ac43da2f96ec073ac1da3bc56b731fd774d3f822008ed3969df670b48d7223108c3451d193ff1dfc9de0cb000642a8f188b5550118ea17c95b21f68507e705d6d125a078929fbccef65f63d16e3516e1cbc4e80aa894dd00c2afd388199ab9de1d1e7352d889c8b6d3a637453d0ed844ee3a01ba52fa16a147783217a2029cbe4680d14fa0b5ed0d8058073c18ae9851a603d9fd02b8912ccee92526e75f0c42d89309de25c7a3dcf6c3801de6550e908c58537a9e41864310661c61e94672375efcee09389dcdc5f66717c86c744ee8d50940f54c85f2fc9a8ee2824d22b362c507ca4e9b7dbaeb0c80864c58a0d3358310b769153eb580d47913127db0287d75c1e84dda7f1e8adb3c457e010231e23be631a2b806724ca20ed9581920fd857b32ecaeb0a1006774e1816b983bbb29cd0351c6d1373aa10e8923ae9fc94ed108a52fabc4b0c5f1544c59c2e0d4447e50e5db7d8d07024d204d597e0e7ff9a4fc7a9e5b64c171939c21005819fd344ed80529addbcd97083213b8783a0d35328a51954c085bd1fb7416e21e4ec2218a2423634bdcd969cf5a593beb36ce4cb7b0354c6c42d0e4a870332fb0a4b6da29f5fc4bb5ff2a6c355ba6825addfeb60bc0c287e97e6c951cb19be1371a419e5bac0b9bfc3f28690afc62aefd0e9f18b04dfad528291efee35fb8b4c66fb9bf954b9118f2ce1e1276385855ae0a2267e9f8e665b2c6cee23a5d7b4b9a7d82409c1b1cd2fb1af8f0ca03442e0761c8f4e3ea25e86a46174ee1ebbe84613534f50e4e1ad2b01645d9122082cf84d589198c717c228fff447c95be7b5e558a85e52a2e94c55eea20ead7fb64e565d32b50b7c110bf4b8505bc2f1e07d76b363472db05391359fb902cb97dc265c6cd52727704e6134297bcd346f58d4218dda55f9da213796d347867a569c5105a40ec6f7ccf046aee230a361082874e115264bc25a270cfde7a198052a3c24a6e8e4f40cdfa66e9cc0abc9410fe492b4cf60af66437d5897896d8e5592e86cfc651ba058f8c87d90d4cbf6270f1e46aeeb1c4a3e77847b169b27c339a87b91d66507156f3e87a6331ad5e4e22bc89e3b6416739dff4813680a8d0fd9bf9ff9b52191dd985754f271d4cd9f21becb512408d8531304d380c80da54ab02291326d27c6defc6aa9ed1cbdc51c05cce30238fe112e2f3cc326877d6aeb472b3bea01b9909edf4fc2c16a54d9bde746590652bc643185dc07f3f15347bb2acda8dfe1cae8b9c914d4a3c8e767840c7ffbf0381df9c55ede8ab9298aa18428d5feb46410f388b846ab63da3c946309471f5b0a982686a5988502d6e8f1dc74c08e7ff1bd320bb46e1780776109c2208eb1417dffb95a487597740497726180bbda7dbb831979ea8a51b44d70800022a8b4223fc942327e7c5754739388a7f76d4c397805dd72887c8738756ad7ee74939376a8d49d7cacf858bf0a08a5aa64ca0caf348114b309066c67a6868255465d31554efb2bc42748dd9e69484573a032d9a0c880a90e3e12ad2dcef8ad970d8b04e3eb8bd48e347a658a892c73dca1c9748488ad029173fb7d58b753ba7dc33005f4e8d3e5f3e9e442da81be733bebc9733b95d55ece240f71e891c79a64bb23a8647f0778a845858ff85ea61aa4a926cd5bbbb9d924e76017843c0e35186f0aeb8ae12098c4caf06b2a5331d83006b47d39f6bb84f5add049e7b46c744ead670ffd58a2ccf22a618671783c387bb810662f1957d4e079e2de68f1c421a6ee779019008a2e39814b144a6578d579e121819799201ae4679499b01213c686037a6c28c35d5a1b686f1a623c89191a19358ec71bef62f6a04c4fb52b9e1399aeca00d993a5677e3d460200cc2372ef0dfb911543e44165453f1f23f6b787dd77772c9734a80443aee6a300da711e271c9d70960df3ba5f5817321da3d434d6c1313365f709340946ebd6b458a061b6eb73eb91459b00ffdc300bcbca89a16068d22d3e910624543c395fa9b28416518f4acb060ecf8cda51427c5f15b8a63f1c0262cee1e8a7ed95d7264b5f43170ada9ef062fa6a3f3bbe428ac9b42bab5bb8c6fdff66310611422fb262f6c5e1c9bea9a2b3a45c6b1dd8ebaab36ccca1a99d75f82fe1d1bce7c1c283ccc3db84842ccaa34245d895d7f67fb379cfd6613226ee557a368cd37974f8eed68e8be29321ec737d5b524c1e73a25f64f1589679b2ad1318d6dd2d825d27e5abf1dfb89b8587bc288d5015315f5a54e28041e73749d522a92db017d75e1475979b91da947d821b21723f3db9295671fae647e0309611ebea3620bb31d7f0aebd4655df43ac39515daa521dc14f926a59a5177e338b6f2a38a4459581af11b73f58b9cb2e7b05797343ed813bab7d56b4576d41f3bde6e27f6b9ebcbad079f650b66dda0518f4b2c86db180d81e8b5eaac61da76509846def8b79d8b64b12a4e735c16af521cec3ad27b15cf44e82c46012ead88bf4485c5b60fa94110f14b54f12c21c3ad3e7114782a589e79025562d2ef3a5d33cdaf40ced8c094d900824663e18ae84263c07840536c220a17d5c43a6e85fd2cc1462bf1bc690f48c273bb01b4505a8da50464523e594c34734edd07e31e8f93163955c7ca056a1f223d174272c59725bf2a6ca33084abbb765355a19f9839c3d6d87f7ff2acc55a79552b52211d1acc5017429875516336307e3fa8fbbe2cee7a817f2c1aae411eeef09ac0a4ef27b4ffa4cf3a58ddf9037fe984af5d78ada657a779e3eb3ee20aa910e1ab38681b03e1ec76e7613af7ef9ba47350265158fb494687f2cc55bb6a2d67e0b53a334bf585243e13af5c2452c5e0d2eb6aea38cd91c4275ac567f8ac729d47c61335cdb6bbc4317e9679436e5bba709654e49d96763063ffc58282a4fe1883e4a7046913bd508344e2e4a2bf6f6b62f6ab44c099d8948988d3c214179389f9bf2d43a42c5ac20ebba0d56865a292f1ff3c93d178df2ad6b311021af1c2d871aeaf2ea40b1768c0ff3cab3da038b08a45e1019ff77699096470c044a48d727bcb7182193401574558fe58b61b56c7ba3585a3f4400c4720206ab3b0570e881637a0ecb05885458c5cfd7929e13ca5a14951b18982e92945e1579a6ae36884547c38e0ce353195ec03e374e07f65dbde85b2e8f174a0603a579e2132496c52466d1125b30e68afe2d96b546135cfedb8adf98e8e882f2d5245939ca446df3985394ef080dc324ab9eb061d30873734f572e922d3abb2faa370f4fa27d59b1362fe09a9494d1c1f015120e0219a610c8a582b160178c142eda3d49e2f3e44eda428ffdb546b7af3b13aae2e80822c3752c041a3932aa0bf2e94492939a6cf95961328a6450beae94aa1bf0b5effb754c98cc1cf492edca4859c5f4b26fea5cabc9692c8dab6308091691426542c378737db809e28da8cc34a699b75427a76e2f2e6493c1958a35fb75665b9efa57297b107468c987c12031b34fd6b47084b59f553e9833bd42c957faa1125fd1981e644fb2e738d30dad10c473949dcbfe1d3855c3f0a32a2268b990c7443ce0c3817ffe1d0df8c74428ef154f0f904af5799954bcf60d85137fccf076e31124610f80cfc1131cf42225945f469c878573509c0702920cbd0e1ee56ea69a7d490580e0aee677ef78eb05020282e97c7b2548856e825c67f0c35fb6185c23da3777acc48636401519f28c93c93b875e8c09ca28d092315189624c1deebe190746df0fe88082551b308c6303a3417ed682c9f1716b94adc72b80787f0697a4062e6f891b0701a7a1ea5e5bd66c9baeac354de33ac65e0d995e98d91fc98d79c350e29659dd93c7c1ffaa83c0dd5e70312da0137d228abc1f074fdc606caea84071a0d1cb0869d705137135746e68c05260471ee501b31bdb490e6cb7d6a170a87274cf30003d1262642c2372fde55b048486d2dcacaecf8cb280fcb530a3074bfba8b8e823ba41600428cf91605641879aa3d1622b5be95b98751166a27011f6debb0803dda2305dc5c3120986da95839ed014d2fbbbc92466991ab207ffea54f17231cb2fac40d9682c2e1df2f48417e11feb2679f20465b474202cba751a60afe8651da7f84d118e50b4d38f275aecdf2ef7fd89022e3968074dbd00d14e23ac3c533a82c1daeec2ad0a729c0ab65c5c0375c0234fa9d0cfe4b4a89c8e3e20cc522b18c73c56d62638b19cbc7f3a0b5d03b108fd1b912e0c5458b14f3cb6bc49cf6158a035a77cd38af323618f5c08311d77298ea4324f08266a6c561c0a0188136c4f47b16ea3603648432f45764eec0b090b0ba6fe03bdb057e1474e6cb369fa78a2ee484a13aa2bcb88452d7977b4fdca0d28829ed07f09d3177fba494240d11bf0433cbaded6ace02fd2d0e7303f0634a00ed92a6377e48b14a0483d560bb94ab55a4adaf5a34e2338483cb14440e9f8c9b172d52d59f31aee3f7b73f1f714048fe511e496c8550e06a700ade3b983a0b426d5cf4f6e29746893c8717946c88f5249005a271637ead003df1b2cd41f41b08dae54c00d2d4d8f42a3b100aed136485b260844d9927126265f7a1f05d301499df38d4a003d27a22e4ab0f382b559f66a87624ded8aa84e7e623730f26da39f20075f6231852f8f1004b1cc032395bfc362aa9c067209ff305ef02d2c6644579a9664781a903c2a45621d8ed70839ab84f3e9a952293fa5e82915dabf83f07de1ce2652e0b5506cfb20f1d0648ea33180f477c69e451a7b58856312409bea0f6e2274e65dae8420d8bdc060adceb745251edc9fa068ae23006276eb161b7098a5432fc9d81e81b0ca498b24820e5b53704462a4a655c0146540ca16009db6b9c5af9b52d23b05752d548596c60834878fe92e070fbb5daac7ada19a6564d4fcde160b013f20ab5786d29ccb5d05ec4d1a10368c2ca362b935d5b2aeb19ca10120f34403efbf78b6f425070ecfe16ddbb993dcb5519adc999da7da9a7e3dde8c2cb9dea2fe843377c538dac473e6c06f812ec5314376ce44fd69b872ce849ae27273c392a5965a03674da7580a229b73263d4b7f48bbff652cbb78b6e69cf9e0ccc71363af5a23a084c6effd28e59ed35dd98ecca00e2c3f866a7a692665d3f89899d95e8ec7657a7955f4498dc06e62a4687655cd99c119b468e804b0307ac311e44aa3b007e680098e1f1f24d4c8dd9fafb3676a45212d7986a5e2cd3310c09ec7daaccac3590c8a3677ce9c10e20801d47294dc0d74da03b6fc0bf6bc22e6cf576d1ce6d25c9cff9c2369dcbc99732c72dfbeb7fe361fbfe4b2c4a11f8fc51ff74f4e4cb51c428c0133020a005bc4e94807c27f921a0c8e82b8154fb2df29c56aa6ced8abfa6439b8d02d55d3fb5b4f381eba5f3f536573c7060849301f96ab71dd6cb24f59ee5103ecb2c426803595d3ede6979f9161a9d7c2aee61463857b7f79da891926eda4b73b87d794c9c6be9f449ff19141cf65b29d4e93b39c77cd4358dbc4cf6b4d517cc52b61382f91ab660195aa7a87a4a28926b3237ac437c7b9502c91e17bcde2a847e4d19b0a63f603da66dbd57ac7c11c74ae130db409f89e336cc4d86bfcb63bb3f062b255c54cd7d6356656dbb3c77997c32b36b126343eebcf0ebe2762ddcbfa9ed03166a55144d630970207dbacdc3d072172b9feac02046e8ee44ad24d3caccd7fe2491cf998c16061c78819e45952a040e1d1a17e56e8661cdd292a7b6ca1c27a475d1e0850512388f29063d46ac41f2347ad28ca1f4129104685b2703c07dbe18553a8225655971bf1fa2185b414fd12ab568ea40af9831639ac47532a31c62e9f2c967eeb4290c44de9ceb868fac83a15e4b8e5125163c4bcf6fb7ef57554d65dac7da1c15a03a4a981c476086c201919aadb3931f35609cafd067ca20fbf98879713a0c87fcb299d710060c274cd3da7f0a4f16611cfd6873c429e504474b25c65cee202c2779de260b7c42d202609125f4a9b6ffff35b97f2c3c21fc08ad1523dbdf64bbf65a937ae8729371c039b59a97c0ece0c438c2efecfcfaa941f96e0802a464ab1f4fa931d03ce0c07040e0c03f33da93132116f6ecc5dfb9fdf9a94272ce8802a9414324f47e6c14617fea724e5cad009c310fa03073f5e46c3d218a9c7cd5f5c94adf2d12f26023c70f70131e2c2be3e2a3b8f73a62123ff1f9871f9e7be742747d5f8825d5c29868c6a5745ba28a55d7aba30fe2caab02f4ab7638107e4cd629aca00a87abe0b5b81a86ee00b7f5d577a38b2581b1ef34ab46c47e3c62a4fef2cc02977549bb691b55619ea0d80c6ec46814a159aae992d400ad34ca3f5d719ce9b97f61a0186be9ac02700494bf4e0acb11ab2cb4d833b76060475e49600c3a30df85d221107f8c3ab0e485e02f41907a1be6cc627e90974060c54c7928dc3b5b07c040823864549c52d100acd95263c0f78405389802256be0f66d36d0a78a608d909b4236a5f59ff1382fbd2b7fd5c5bb6d1586dd9399ec46b415f6330b2bd9b83c2ee55dc045759223f394a1974dcca9bf72ce36ab44f7f0671f894c47b836c4819b6fc47916d9d20de9a727d8342682d80d22e2ec2ef56afef612ccd31eaff59cb6c451c5c2985c50e836b65d1e22e05513bcf83be4f9d9cb44fa54859d38007174068f305513f2e00d43cab5abfb108c16e39c41f6cd19d2ac91970867433db8e17be369ee72671a052ae556f8466aae55ae132d5b939b7c2848a6c884fc50cba5ff01a7e942355f825d8340bf000b202c2be17de0cf0bebac8b3f6dedd69c0640a7a8118a823210440739526302cb9c47706f50dce50934dcf4e5cff93c5e8b9043c6d9d9c18ee15e8431b4f12753f2557882fa29fb4e80d72d8db86877e4e17bb135f62fbb3fcf9539b0307ba32d1fdb14d561a464dde926e626261c9c63608303157b68143136213dbb413fb2d347e396f2f048c2be045b059c60dbb255171dce29e764bf8e961d12c4efd4d83365eeee69ca83635d7bdf185ca86af01fe972df4ee0ebf7fe2c84a98cd2d52994131ffbd34b39d8e5beb60312312743946e10dbfbd44c0aec1412fe265fd0a65743c52366c4989bdde2dba576777ce939bd132a6128cba211076a45c070b5f918942b7d5e0b9cfec2695eb6f8ef4cb36f98ffc4faef6a661a64787d9a9f2299d0f4003d375a29d527259a539292337adf7e389415ba9f73135e8416c589ce0477dd9bc5bfa92d3808fb5bcef1284ee3082c53efd4b3bfd2feeb99817637b8857f14a80dab7840ed30ab4584c087887806940d1e3d8e86201e9e97112cc9c7c110ccfda590bd825742733f437b9888f068a70fc23efbdb950930ab81f9992c341c47b73638827e0ee4cece8e3a1ad1a63414e0e854143102ea69dfd75ca1741496ef2bc9408541e1ad6f6e58b93217a3ca8541dbf4585e282b4b277e7154b9b805c43b33bee0468a650914f324feffca65063107d770b5f3e87fc931550b2918af665cc91d180b2f51910b969b2ac50562c16996c9fa0a160c22a19ad734759747afe6cce98b9ce9807b07601fd8fb05c51f4c55f46f2fc31bff122e712e51f4d5e25cf58b52d07e6a9e51cf1c1c28803d4a330bbc883a08d3840fbedbad55a1f0e4a89c25f42cdc8cf3a4a862eda5c0cdea2ba741e00c31f218c94231c64d475ff24038b85a09dbab0692342cb30685a5618a3eb5fa322e613b896aa3b90c9a57ac0ed2adcf4ac64a71132223222e5904a8cb391f1e1f297da3287cc276a054a4fa0cb2e24a1166f2be2ead1d03a55b84e49dd283c387f91c0528166dacc5231263173c48c6ddadc01f0e8aaa79dd00a2ac9c05ba432c2057ca72b9d51fda11038fbaf546d558ef17465bd32fa4dc1484e63006ae48b113c60c6a5f0a440af934349506a7b57e6c002493214713ef762b9b0c4dbe15f63115aaef3af893abb55591063996f41fce58167b74a303b0d5df7780d12d558ddd0ea7696b8bcb509b78e1bd8fa9302a5ba3943fa28d9ed46234e8c621174829e22c835e3fd34515e5e55d2b65a4075235543d58028c4c74a64f28491cb38ee45617fee85984c42776829f537c0be85b234974f6a3e8e7d613c0015b817eabf2ba2fdb93262bcd16f443c0ede0078550b362e849f31c4d7a3fe6420b6182177634c1dd57f3aa998a01651bfe33b0b81fc7a18c48515870c1a1ae88b4158b41b5244f89dd9b5159237a8123be905a36e8b40e5a1705ce35fb74df9f8919e1132b2fcef2458f05171082a0327818affad2fa20d0bce082b0305728a008c03a5990a1ba9b6bcea0792889c1d62c2890f4042330bc71a81c19be930b9faae1356287928f2351867c811ec40c82fcfe44ab8e5f94901edab3889cdeea6c9aeecfd5506af9e849d2f79cc765952fd6cbe79d9588ae3bb33b1ad6df653e0e9086d6a3dcb84fb6f2dc9a8637996684518f43e2672995b6424c0936a95b3e3dde2669353de7a2d140923018a452efc8e2f4c1fb4b6bfbea0150c701788c07600cc1442f73586dda14054a97bc2fa5b881d9014d8aa4971fa487da281e617020c0b68d4e2c48bb381965b63c5e0a695d5c58d0671cc496e430c787104e6fba2fe6f29d34f3b1fde236579f52ff44ce57f7149d8bdb7ed3f7870428ada5055c921dbb3b466adb907ec6a1b6a990aab0d7ac04e6e6ce6df49eabdaf7ca43b7b1913ca94e8dd1b9401205aa90c4b36822b391329320c9539478c1e071d77e8d011071c3becd8a10e1c39e668393038d7adef08be63c71d39748443c71d3be8808372e0d6a1fc3bccf22a388987f307072ede4a5f8e4df8e2cf5ee527baad4a855f9b59b98f7a82d4cf1756ae2955f16756096d056c75e1f012c1cb93e7d6e271044171d4e2a96d09c04545d23084a3152c267480532930ccaeac78766da09b0aa9159733ed4c092e7bc4e6c2054a1d9f2aca981eee39afa134596875af74774bb8d4ce720b594e5a73d6ac07eeca4a08adcd9a61915b49bb949519663cf0165b85b26ad61963ccd6d451d69d31cb8cbbb1325a2bb366bae456d22e656586190fbcc556a1ac9a75c618b33575947567cc32e36eac8cd6caac992eb95525a83c1a7048b33a1bcc50f975c53ea2710484f4fac26b5b69d5943d2a3f105ecc467fb9e913c3669e39254a7be09664257a951e954720ca3c00de277ae9b976411645e567df59ff5acd045eda356aacd8969bedb64b6c9a756dc5b4ee968bb56cd1ac552bd6fa719451d959f12542f0dae8d7a73b4ae59b87b22701e66a075f90242c2ec653ae791a9d224235fa72ca738273ee7261339b12c2afd6d63092bc9806aee44e00356d86b3772f6569b2e05219310f0872115a38928b10d4dae0e17ef053494dc4c5886c94901ec8213a50ba90a0b39afb1aca722edb1c801b9daa513fce47ab708f90c2aed1380f51b362a19c408cef9e9874b45376036ec1a2f11288c07ebde8948b57a4d2de8c5c019e18db290e1cd28e50123eb0fc2364b962b8745071da645ccc002b69a070c48e080d49601f1cefeff5fac933fcef1073cbb7b33b9a77ed0a83d1eaa8b6316622d4bde0cb1f03153adb0b1f4cf6cfc55d3e9c019112e55b38ac7e79ad21a95f930bcb651c0bbb24528c474aeb49eb00b2ec22fa981d676968a07b14c55cb54728d31e6d130142b838df9ffe0773354ea5816e40c96f5bddb6d0eacab6daa465ec3e911d378ef8d33a746ba2439badbf72dc0dfd020e980ef23496df2a0345b899921f73fe8cd7604be6751d89ece9a2f97bc57929c985633c7c3203f1b5fa81a056f8b952d0cfa80fb73c93a50e626335b61c70c40fc813ac5c1b1b8e68552e05e2e974b36c32add18447b2d2e177b1d14f05f3ed31042e8eb8dd186027b4ac3e2e4edf0d7bb2b2b84f45a5b51d9d1b0f0511bdecb33a88fca40ccf9bd601d2772319555e43858ae9794786a41c85f1ace26db60e4a73da45eca6d70ec50188855603818ee005100c3cef92308b8db5b70f11eb1e0f0ca0dc758992a783c8119affe8b87871040649c5902be2e2e4c860ff47b3f0e1e63bd38d9c40720139bcde1ded593f2bff48333edd8895abc437d7825be87b1976c0d15a813d4f22055293035db3e895038c1c31e143361404714eb59e27aa7813d3d2085f61e18c174c2260689f317ab3d912e5f0dda6e9bbd8985d3401a4059e4e5ba0f496c36008773ef3e4d3e2d298947882372b6b5cba7ee2a2709ee1b1a3672fb4a5a1bb124d4240fc64afbaaca3f0365acc1f8b03ffb723ddf4431bf3e7430b97092c2f7dc31876c101f114c3abc90f4d2f6252ce98149ecc5ed8acd140defa71dd636ca1455be13cb5e9cababc4def79878e231e33ff1d7fa33cdf18befab12f3191839a49dc568e4f3883ebf7b90d9b0b1d63a8b95c5b5b20afb6fa3b0cec9e160773cad9030412343bfb00b5ef33206a03e5d03b661e7ed88613431b2040eed0aefc126997e7336ee124fcdc86cd858e31d45caeadd590575bfd5d0b764fcb8839e56c0c02099a9dcdc16e83f6c40b35061946a6290149643b4578388b4ecfcba63701696bd947ea762ee6861bde1a765ad8f5272463887f756cb8b3e67dd97a5715df29a0e0c5d339a223f3d9d26af0b3b6bdfc5cf5be095eba5a84dd27928140ca026cfdb1065040138038fcc890b0cfb159dff8d76385cef2e880b7091d06da2810da3b9d68e30f4be18b8deb236b5d16918c458422d83c68bd878e9410a2fe3a4a76ca4709e7c62febdd8608748864c5e6a8c87f49e25193061881e7701527d99d4083633f1749b4a6d86baa84ce8bb79a48577b58b8f866b283c566230a3840b26a7150ace4181b8320e06c07bfc1b181cc8439aa33ab0cb9a890238d60a96bab9e0a1d157a152a09f17e4ea331a96ed1e031046450025809b16a26ec3c780a4eb9485aee49549e7a9d2bc505cd06de08b3dd0ee7d9a474bbead9791b69b68b64d0a23dde3b17d9a16bacf56ba96d857b561310c53ac43dae331958f2b2476ba0e0428ce6f3417c19b8258a512175b58fe9c75f79909bbd4ecbf0033479461f63dd19fe943dc395a0d6e5ca99c2b98f5ce3ce4f9f3a60da3ac0696bc84f04634c159501c5515f4eb2b7ec8b0e3091a739a0b8259673959de6cced29d11c561575e34588dba84c7a76665f90decdbc1f9d8d841705ff4a688e0d231ad4ecd6a1e8466744b1b4240a1c2f1fc4cb86e19a0ee2943d448a0a297ea7b27a9e96da16edb608246a4d5d3c1fc8a7a5349aa46163423eb0e15fa8554454d60846a3cf767a340fcd2f0b35b456c44282894150461685fea1cef0ea0f316fdadb6373b7e882e835b7025a236544b84e753d6a8c1abf1a60940dbf970be16f8cf7b5a67139d8adec08bf3dc1d4afdcce654b21a3ddc8fc4a9741cf9c29322507b176991554ef53a71ba7c6068f1acad74da87a6a47856174631ed7e5a20bb122055ba38eaf43fd69856bbe98d2fba8cb8cf45e649a08c3f767101cc014c46aceb07561c4c04a67a4017995aba4c3790325af2b52cddb4fd990aed8464981ccbe9c4483ffc9f121c579047ae82c9282ab67f83394ca0b2b013c5d010af4dc355770ce61750acc7240ae50e5c6eed0e64552951712ddec19e28f9907ee30612477136af386f61118d7dfb570de7c4c681f1a17cbcbe442e5640ae7627934cce10ecae6a60ee50db66f3adb8ae077af16e826774a726fff1d310353034603bbd91abffc38f9013491ad3faddd27ebb42e0a815ab25104e6c8c69b1841e3436badaf84d45b4a84c494f20daea8dca3b05a62389b43522d3ea7e8c72edbeceeee454bf596369d4f280845d13751c939e77c216eb5eb2cdcbae49c732e06d55b3a241a8fc8f7504cfeeb160114632a525e623a322358a5206f51e99218d7dbbfd8b1ddb54dab893df7fe5ddbb45a4b654282836539f671ec9680792cbb1a42d13ccf6ac2076868beef8e919022393c2e4f366b46f1e60d14026e7c26b97d77f7a757bda5c121d108e2e9f84074adebb60994b4ee09aead75dbaf623173aa4ac22c2feb68df5f4d0a526fa9101152fe208959b2b4c64d388e3c5e3d40215b8df242415b3846476f06a7d06050573713ac8cdad0ca2006f3ffbf4b918434501865e6bddb3e0b93c403bb9510dd21c32b47a7a9882964f4a5e4a4fa78d7366def7ffd9b2ddf61fcd4bebfceffff1fa0cd9cdb2521c396bd01f5c13313beaa6214a198f8ca5131817ccfeeee6e347c71eebcb603b1a123693161a59c734671aab7f409fd0f28d1dc1bfc0f29c3e4c7bc20cbf250396041e15ddbb4bd8bf07b767777a42c249c7b4fe7eebe33a1213a24472867e3c50b628e0b0a510dbe6727e672391c77777777f7202e45a2f1c4b907714076e7f9406f79efd96b3877770722aab7d4a839001db5f6271c9c3bace52ac6d58f7a25963688745f6cd88d301d399ad1e5ee633f50398ee4cca880445afa1191437d91c15ddbb4bd995eb6e9459a59bbd62517311185a42a2c9f2a1f8f9755c60739b2e433f4734b5c9beb2ae97a9a58aca666347d718506a31f2490e5a91f8447166fd9658097845112381fedd004dd4d582da26b83dd12d7e6ba0e5cd15a6b2049f5962a974de7f30408d42b70cf2f7067edc0427304deb54ddbfb573282918f530b41bc1c434b30a6b2dcfcfeffffcc1d1edc7fd631710861884168bdce05efdaa6edbdc232a237e3e07b76b5c5dddddddd3d884b959ac4e02f75bab2345592daad2e40b28ebc5ddbb49deeffbc5c89b95c4e664d9734904b66d48b5fce90231f4515d8e8124b2fbb62964400843a939503ab36b304cd8a22b49195861d58402c79027ee1220691e97892e1f3b58b8699392504b24d5b62ef481ccdf07bee6469ebdaa22accc2ad8fdd1a6e11b78c5bc72de456d24ddc8133eeee24c434ce4ee3c01a27d6383425232e30d6955b3ac4c6c7552583a9b5d33484daf9704319c673e7fdb825aecd759943ddcb4fadb5f6edd45b0ac734451e10bea09c73ce334cf5964a5165759dcc889dd0ec5ae5114f1844e697ecc17a1159660c3073d0d3c00a9c94183c3830ef4e366ab1b5c23291c31eafdfb3bbbb3ff5732765815dd05299624083d05411244c4d5490cce869986293dfffffff6f2cc5b890915b41d972c29b8246997fe55aa429168b3cc5a0a25091a88854646a560928eb55aa9135dbd1b0f1003272411f71244e73ec4312791ec1c4258466bc51878ff7eceeee4c285e9c7bf03dbbbbbbd18c13e7ce33519fef7a4bdb15b7c4b5b9ee9531c32c1c81abec98e80549015271e532637be0947307823005757757712084ef7d72090af311c3062a2689e297fdff3fb9ded20c9c7573ce43e0213bdffb493e7c21592e930b38764ca86b6b63e085e6d18326b2851d764b5c9beb12d9620f98bec1f596b659a78265310192e20aa9eae7ad1a3e65bc8899c96514a2ac788ebef0aa6924516e4c315b286dc9744f392ec664f411926819ffabbef5c4c9b80e69261ed30a0cd06ddf3f5725d55baa5c660e554dd7b9e00c9390fd40babbf3dc6cb5536f291ceb132b1aad81447cc35313fefff7b9998318d0dcfef37c81102dc6863a44468071d9d440aeb04a61ec040f32c566e728c4696cd8d5530ca291330386870ab6e20945e5e55f07f724393c1e8ec35ff332a5ab088bd34d915a109d56bf3361c38eac6b6bc788ebbfecdf2d716d25399bb43d77f7a41a1a9c3b2cab81758ddc32153b7ef944249d6822a1313d323306486fa6f4815f1519083da22dd39d791585553c4392a8de5263e6903cd60280ea322cd3911bea04800a0bf2518304588f1d3771115186020d4ec0e44a70d960690153ae40116080686c5ac134d9fc40be2c19309bd1110ad205f463e1844b8b1b0818f05a19723c423da990fd789249326aad354b53bda5ce27d4034b34e701f8aeed0666d2bdf5e9a6640a366af6fbffefad37c6a06cd8cd1ab6407ae4e55cf9cdb8d0ca11c118cd84181ab934c1a69c463f6c58cb2b513d97ee3f7548f4dd5f49885c386106754b9cedf45a1ea9c771a8b523f366b311ddc731eb04a3f9822175aa01cf02459c197ebb756678d7366d6fd7efd95b9d5b92ea2d55b61d5a96bb16c248840550aa0b860dd205fe2970fe42585860435081e637b10e25730f28c011fc6cd7a312523e7777f7b8c697c117ad91c5c1f596b62f3976b76b9bb61d8ed16affff4f51aab774d9747e90f2f4921b37d3188b6ac75a66c2ac20502df4cceccc3499c68c18728c6e896b735d1d31b3fcffbf2a12a45e51ad183b6ac4dc58a135c3bc514fa6920afc98a4bcb4442075df33d5e399a6ac66b4d65af7bcde13f49ea1f710bdc7e83d47ef417a4f32c984738f73ebeefe434abda554595d1d7e88ed3a54c15fc10a6cddf663fdcb56eb0bf4c05ddbb4bd31ac00b0ccf994002061c7468526a08f538c98b8c5c56d75feff0fa2516f699127731014e4debc0ea9e248584700f4065207e44a41e8e05ddbb4bde1155c7777e5abded2e0507fa0246a1d858348486444c72b16d1b2820aa8a753cc8a698d94a8962bbbb6697bc7231d4c0c77aa663a1440129dd24e13834ec693526f29555617089e18887717ab42761d08817db4708a95814b24b0495334e9da7819feb9b2a45c87a477fb1e4e617f20dd3cd98e3094268aac64ec70295dd860b1462c60a5bb3b8f8010402eaa601848979ca1e342e28576f4d3f56c555fee9085d46dfea924274bc6ffff1ed3d38e16ce3de21bbbdefbff07aecc2fa432e92b6c967da0146559d98b09d22763cf2f6719e6d3028d4c0c7725aa9bb66b9b5693edfd2b091203014530203a3e2b462ec213575f31173cd08d207aabb0686c5878666830069deeeeb323142b091316954284104aa68965450015cdf32034eeee4094989669c8e9be6bdf1febc50a6ea74eb3ac36dca25f1a172e71906a5e1362553f532b869e47096a6473584efcff2fd930e2fe338fe5a9649885d906a7d74bc3221ca524c1403183a973f4a29725fbffb96877241ca872ea0f1ff9c99261bd8481129f2d0f832e25a70b9c17e371a5015de6b480493acbd199cbe55ed4232e352221750c03ba25aecd75571ebc382ebe50311383d34c8704616c0af0a0e9d803babb2fed1071eebed4a38cdbf7d7f9ff7fb9ded256657bff40adb536a2516f6991274808841191bb3bef3dbbbb7b8ee77a4b5bf6cbab60a092fb3c1c5945474bae1b37b61e05ebdc1ded162c2a63d3966dd7a089caa45c6f01adbb7b902cf596767d0822b683e30c7e84e4eb5d5b12a77b5cdfa3891584172873f88efc766dd3f6ce3f150709a2a88c651485081d9c98c705ef02f72fc40264bde00b3c7ce01da11a3122d6236b66246548887ae755ed150b295750e7b925aecd7575bcff7f9f32c33107e36628e377241bf13462e7844c0ac2c5b8c2ed8861924437a42899c2ffff41f70e46a83becb2cb215459c3eeb8c6cc96505fce395329d55bba6c3a9fd00da8a239126954acec11ab2073a28627a6451126299e8f4ccc8acc8e64d218f62ca2a43453d48f180e50345b9ed25b2533072be5762e38c32939e79c6984d45b4a84c494a2cada40d38562b66b9bb6b78f75e69fce9945a2e085988ddde9ce5b89ab556ec5d7dbb54ddb7b85317410b582cc9325684515c49a31a26cd95d31c3da646d7a01bbb65d5e6979b1c97b4871746df091c8c26e896b737d85b58e987a4b77704c53f413238fbb5e79afd65ab740546fa9f1884c9eb4a074770756d07ece39db20a9b794294595d505828dd8575044f8ffaf9273ce5f39f596bec121d178f4f08564c36e9e96d4647c75199e81f550656042dac84e988830861eeba64caf67be20d9a35733f6a3455cabd81234bbb6697b8f2d6742d7bfde0ebe829bc54ce8738189e853b3719622f524d51d0a115b2a502d18797e85d602ebad0fa452503174f0f8111183215b412648cc1fb690d1e77f001b2e7d252f7cceaba98feeeebe96242aa6ded21ddc012cceee6e8d3578f0d414ba2619a880089d1c3b7ec2c246a4d0a79b212c95f79edddd1deb897307aaaf6b6389818ac26f23e9aea991109adc340d64793430674eef6c802e6bccffbf12972a091571ff4a9c056a9bb36fd7366d6f1a361e324052d21328b97b81ba7e5804edc080250cd103244aa80495a36a840a6631035385d09d64ace4ae6351d82e8851c70fa8488015b7c4b5b9ee53f0c52d716d6ed4f94e09470c39edfc8f58002f5b6eba444cc6bbb6697b67e07b76777727a025cebdc689c84aa70ed912aa3ac4a54ba1e7cf4ce5bde02a0b6c05a99899a13fc2c8604442a849e83e29022c5feecacbab97e37d6c6624651b881cddf3d1901808804a1e42b2b0cc6617785cbf614909b7bef7ecad9635b5866bd820789221634a450c142c1b303f6a52b462ffff19dec761e2d803b61d8ca2be357d6a0d7b5390f2a8342d9e46c5009d00331a041c41c3401cca12b9a6031480070d8890bc7888d02c1286c6c180480c0086024100180c0602018140202c8a817096ca62b805e646dbf3bd2e64f64fe4f004eb23ff0e699e3247d24b954b5088a40ecaa685d8258c2a3eb4ecfe165df5168aaf83b3641af522ff11f7da40c0a2cca02c46d2efcdcc6a1175a1daa9d70e2a750166303407f0b645b3fc83a82b1e4899184fb508d9357cefb368f6496662150a6f7e785018b411225e0e15f5890e2d8d344d1149d7f438da024305fadde9c440f6f31737f3568755bb2fe44eb98682b9ed86ba66f98ab4db8a862750ed262b4417862278d552ef5a1ee7874ac9ff53c3143d4951a8845e4981874b338fdb6644167f70da9070c9695afbc2886b3fb9fd8c545bb6e2da3c96ac914c53d3127a343d6fafc05c2dd69c4ce918a410957a367bd3c9241d7c1218cba1ccb4637b47115544336634360960ff0568b26be93a44a1a2d9f59b24d4d66695674084fdbd875a244b6e018a06c2095e2dd4ab8dc170c6fe37ba6bdbdbc1e8b152458909ab6d0d8a7ecbca1261aef5c8f04b1c3068a2b35b45a74db7b089e3dd78d2b48c6259262ccc5d1dad46da316394643eedd95a6410cd1e4fcd54fca74e1f6da5b8bb3250970d8d5cf4a4a195d4643556a2188b7bfd5559311193eef6871797c02bc2de8bc8834292b0731e924411129b9ca537a6ceae2e270dec2c56a22b96e463f562dd90156539a401cfda7ebb33e130c2b32ef4653f2413e0940f5b53b2c237b31677e5fd1a5ba367da9a8f52f3ba211cd0a86acd14aa4534574928ada454c5c91726a7a4cca5c9e68a194a25bdd2e1ff64f5ce58c21b4eaffe332f7dd0630929ead5abf96f88b98f4712bb4d25861070fa396f6c3f228aa769d1bef21e9e5f3ddee813d442ae61f6e8103da1331e1fa9e78d1736369bc1bb1251fb2176cbdf28b32e55ade7e471266c81a4dd06282c44d1aff58c1627dfb68302d90a51f44d311893b313a8307cd6fb1475788acc3457c7b4fd399f0880683d5c650b11cd9d249aff68132935cc4ed966f320996adad48ae4546194780947df9a4e180080b6741118468028346c2867ff5c8cb30a14e029c09e75d282ea573c268928293a1f81872649162790292cfc5167a458b89fc6f0fd6686b2a058e8390076939b60b212624324df61daca31cfee89ab31cb4570f2e01b2296c28f8a721385c653b853610477395dfa84c8bd4a47210579b988cb39a3a2c755a18cc1bd73f346275a053857a265e82b441021e8be4a6224d4d03359ca241f3d7c14887a47646ca2c411139ff02fd8d3318ad02125e321b6237dee5811d423c8a9a8510786e2f6c731a10a01da3d9a5796898a7ca49222908098242196da2adf276c85713d91c840af479be33dd44a5eb0e00c6ea0f66ace750ee1db88d1ed6f050d177a8d4d6c6088a44ce2b2a490949a94b4b2a527de01514f2f3a3301a46b8f2609de770961ca6bc649fd8aa25cdac6883f60893904bfeddb91fe918bdfef655f3c8e517069c457ef5e66a650f89c7757ddf4bd252eb8bdd1c0613bdade3b21caf239f0030c93d7aa99a04305b4a17589908f2b2fac28b7981b3ae9e762258d3f881e1aec599b58884cf5cc63bdb190a6736247b98d5cb9fcd2610614e180a3298dde507fbebd8deb27dc403ec12cd41cf3fd70695f9192f71dfbf654235c6e90353490315fd6c832bde9802d0853ba985356e9db8af0566a27858c95138b2db3035d7c7a3a75dba3b647d4c995ce53d2c5b4d91dc8ada94cac2660ae2d76e22ba90317ed99b94c64fd6e32287beb800bfca12f1d2a2218ad7d1db5ca5d3b15a28269a39f7cad6b19a4b66f7e239af7f89607a8a796e0afd971daf7767d82898e207218b3bc828092d7b227d770933e0ce683636435391513bab68dad1389cd709cfd3c40e78d02454f3c51050c97d335cb8a9278364abbbcaba81e076ad8261218b934eccc8c43dff240fab4aabaa8d5c6efdba7c461f7be65bb39cdccadab8549a5b52571d0cb81fd05257f52bc54670ca95a3f890155712e5ed711a3a30a6ddb7ff721dc7d60c33917ccde9916c22a0b4b04d0af2cf4d33c4e6e10b9e3dce44cc35e553ab56df458700e79afb0220d95858da2acac25d9fec14943b4a5a1fff0bfb26a4dd03fd1d0b18b36fe593955a56e6c0b044fb29e7ae1b62415fe0edb3738f03ddadf16285f195300a2f2ee76deb793c71105df2539ba939f5340d31ede2c94a4d025862142884f01f8b598b61adddd5408ab29283531086f384921340b5dd1eb61b37b68394340723ded2dae6516f96f14f7a417ab1907ef8f3d8d002807e59119c18490349de164614cf2a4d018c482df8a54fadff007d1eb27bd59e53fb0f0af55089995afded158869ab33264e0d9ec7bf7a2abfb5b2d0686615895ea0b03f339048da25177b97eb715f87d1b76e542097067eb609b821735cd01863e577b6046e6f6ab46eeb5e81bd192f6d9586dbe510289c53f0e68887b0360b42f22b057fc969c9d4526900a413ef5d1d03f08bfb46d36078b080c9db4de95ca92f557d53820708327b4cadc8b2892f67e0abd2f158e8c14f38877a6bc6b9c4f3276af85a56859bc1a55a67fd2bec14f8b438d341d5082006a530ba240c0df3f9c5422ddddca3933d61c22138dde9184ceb36a9cbf6fb9b5fef5e3ad28aea8c716ac000560b91113db931cc3057892624067762b3a6a9b0941a5a9c4c7ef8dc2f56ac24df912b4161ccd44b5ed0e896a88f89219c826ce8f87bde318ea29d098ca286bce340d0a3ea2b03a4dc786543814d0d7e91bbd61729a3651746d1fa26c0c61c4f34605d342b5c3ac9f66ac3c78bad3d11a88b7ddb2cd19c17b8dce701d600e729e31978ed283e17bd13975471a3cc41380f61b06e6398572c969e0a97c8f0e0e1ffc1e75de3e8ad321dc86edf9aa0ae222941c5ad99472e7b497fce170223b142e1d9d710f84883ec8f038cf50403ac8bfa5be213df902c8c309038fd2b8b108378a2f35bfbd9111e646f33569271d6b03fb15ccd2e646434a6bd7d12267fb3cff5d27d2e98334a71d985bcbabddebd1423a96cd10e7887b26343f81de4cabc0c072afa62e8c7cb05c6aeed6bd1769bf89179a93f1a6cc33976e5b49095f86a79dc57f7cd358d583071d03968b122cb8d09a05fc47adec2af778011f7c542ec21fc2ac4299c316b9b112b064e15331e6cac305901a167eefdd1defcaf6816b685ba73f8b3cbecee1f82bdd2b89654323073de92f0279361ddc40b851462f2bef68bf7c6c788e0b05565c089e13c681f12679ab7ef9ba9ff896d673ef47529ac26095eec0fe4123407ab6faa661484aebaa842b7201eb6dfb528c06d760a637fbae62f1d3bc14d90c54b814df5806b6921652d24ab8e6143eada637b0cd72fa85511925f5d25b5019bc983960a35c72aef5d1235a162eea205db3afa039ad0d2e604bf6e5f0aa5b5d8b602d54635bd41d408a472636a64855314e8282d9b4bbf573350423b6d42693728633f2df5fdea4fc962764d5f80192fe48a89bfd148273cb239add4821e82f9643abd542ec7632e379c8cea7bebd05e38fb9e072b7da4c52bf436734d31fba1ec750e77db919b597124bdfa5214b2c8ecdf37ee72fc8b79da76f87306ec947a989a549238b1e6af86b9577b39aa4d7f14d3acf0d74b922082611b0eba19c2f31d3580b2505c2c15283ef06b9132264df40f716c2c541561bac5bf141f24d724920545cceede2df3f42b39d5aa37946d4b5ed98f05e1fb0e30bee5a504e93f4498f0e111d342b496ad2f4e1f4ff849c982949182dbad8a5fa4c9801369e0f9fc5680685ac05030ad4c4241faf9eb0a0e17b0b25f92004ccf3f3f5ac6bc5d61ab9e36c80a5b3397a18d538253934ee2c38bc13353534c1106bfafb9dd6d6cb96c74f050444df427c6c0ae8fd0b2952172f5f981c4cd6d23cbd4789c704e0d6f09bc12e080065c7516174ac9d4a35b5035767f959234c16fa345d631204cd16fc04323b557bc95c8ccc5953e3abab2b23c449f7f2660da91a9d322a49ce4fb65751590f6623eef1398865d64680c9156e7910a949b7f4048c7010441292de7129ce5036b030541da3d701c3fce1c711ef2e44b0e8046bca4094dea630ed38264db66adaafdbbaa81a47cc44616ce544e1419ac089e82c1be936dd76769eece46f515713c1f02649320b810a4062230def881095b3f4937fe3b0e8c6dbe3ca7818253db8ed10c6d2eedaeeb1e1ab8f3be1ff8f77209a1a6e5c21860d572e8f0300173fc6c2a2347e456ba045efc66b1abf12b2d76760aba0ec363e19c1a04e44733a3ea7bc8ad605d8e9725d0d49fc0c25d494e0344c50b616f398b342edb8a1894229c75ecd67eb20a2d7687cae4c330d13435ee91c21c74aa81054cfd8170ac3306e3fb097327717c6a0cbdc5de3d921fd7ef7a56c2e839d01a4b883fe558446cf79df45115ae624eb16c1960813dd326f3cbf8594aa969d497a53f2030e1964eae09908068ffb047e7ffa76a9d4564c424e87b4d7e412f2dad17699342f204022683428ec9295c3ca27e0ddb0c2f6e11701e9cd20969fd2f6c41a10902704f0ac8769bd1a50d1832c23d4aa888bf3c5d6bcda86761f92709fcb0c60c26f20e1ab9a0955c7a446dc5a28e9e1e371b81126b7c9588b349d0642927c3c733ce462d4b41fa86eddb5f655e5ae883ce7799b4156466c33b15f4e0f4cdd142eae599fabe121b1cd09c5fbf759726074cb015a22dc7dd33f7e1dd1ee44b9b9999cf6b7afe8b95e1331cbc12822a14a6b76411b37f65ffbff06f45ad9a19d4f7b3dc8c2ab945aed68f4d6a80bdddb98040e8fabf9ea2e33939ed1f67f68f7711d1ba6b4090d8e1ad131584f88aa1b87b0d1794ae4e9eeffae272335d065c65885e150a41a0983350131a91f648dd8ed9750e39c62b72e532def6ea17e0bffd88aaa70451cede72200c471d3a5002c5e0f6fa24180d1471824492dbdde688bfa41fb4029e138da56dfeb755a3dc949d459cbbc5a31c0aaebfade577cb36c49acf1af887f6679dee08e0e36bfa2d64938bd418cebe8c1067b011ea30f7dbd88d884d65e340493895c03c835bc0ba48e1c402839721a7e20a414691b12ef4ca1ba04fa31f71ea6a357967a29919bc7e7fe5edb61ba0eb613ccec12d7779d4cf61a6380d3dec324e84529b72deeb6bf2ae9b31323744956ab86e8d7bc0a41493c245c0ca0ad88cfea98bf6a97582645ff908de9a238ceb9c1415b68eadeb2f8ab10624f72c6559612ba7fc1323dfeb15bea4a857a0f56ec1353ced24deb1172eefe871e56575a0bc12c3d50b90bca175f125b9a3da0bf442cd46a68e06a86a547ffe5c17cfa11b977d968e4a02fbd41d07ff9e4d54d866965af5736f497b826c02f6d9d3e1e9cbd13fab1286ad5c4965502d99cf32622d97a200ac8f446cd0a477a938c0c13c9703a4dd57eecbcbc742fa1944608a93744ce7051996ee05a4239cfda769080fa6744df4ff541f1d08e784b07876778caeb692bb9e788673d9b17bf49fc5dac918d70377f1c6c587b8ba233cc12320a303b55b31d2b34a115e96a5eafc5da000152a60c3294c4817b3077df6cf4f3b60db39983e05f13e7c66e084105d287db7ba5328224be105f81cf482361c6d34632366b58484e8d25ec257da93ff08871708b6dd9ea121730964a1b8ca3e88d1063efb192853e840942130a0669a653da7d2df75522648aa574bd3a29257594a111c53b7421b60b088916063356ccf5d84fd6432eebe295c3552803800da55593b9f378fc8ffe76e2371bd072d3193c91b24adf9ec7b751630309762c578eec13a747e353128e64daa4a423933ef1e90a451973330c923cdfee5d7712d0ac9426173e69ed3e21c4b2cbc82d5fda3292b2d9a5799380030ab75cc9f823bcabdfd466e66a4f8ef611c1c7583d93470ed5c1d64217769222423cf278a34bffe5e1c513f0fcd84146f85880f415c520cab65967690184994116c5216fc10793b5c5c415896083570e317e7d7ddeb3719e333f36ca82805985976c9e4b50f355f9f194840ac79abd232f7d7d32f9a6efbedbc36b661bb782ecabbfd9ce877b745b38e77ce3e681d601763490bacf0a99d8c177aee097ed7eec233aea98077c7ac2b979e385d474805fab5aa88bcd8a964ecd4957841b07361c04408e03909bdb6cf698070725ba56209131b194cb54404694c68f6c36a071ecc559dc54e5b87c7c05264aa022c965107a3ae4cb2f0c72bd56eb113534f7590d4dcfb928264ebfa28f548becd638e42fdd4cd72429abde6d3bf20c95220a5c6a481da5ea48ed54da96b1e8577c332d98bc5a6b6d73267ca80bce40cd021d4447ae98300aa46b93c2d31a2d2246d8c45411993f7cf9215b7624817d8779a3c2db8328d10db2204bbc787500fdbc5ebc9bcd71e28038a7da15324eedd453fb6a54e921c908e3694405019695788ecca1f3b46b20bf381b859732ddd868edd1a7237ade96a05a5cf12e093438f1ef7f3b33b5cc7436835a6db765cbb14643b682b0ff9dcd4e4ef8dbf1af4097881b93880b6456dad962ab116944774b732b3f1c45a0520ab8514a0e5700cf36510c31584b061f1836b699c521ffdce1e99c0e89b5dcfea76c532f34f0f92d811440128a9bdfe03e2f4d24683d7fe8f183977ea8f2d944bf544358e0918041d55223dc07b43685381e118c6a3ba1a4fa713d1c2a4a3a97839c994f20c3013ebdddb59b65bb0011f6051f586c24eaf547bac67197cbfb47e939d5e9b7dcde3c5d4ea20b1f7c060741c76b732e4bda7ff60d96ed4821e2b971b86bba909b6939b71f8608eb662e62914c0d4b538c147a086beee2d3dafe979001300568cf821027573870356c330c6e036badeb53df3d357b97f1c7f9d7d370119e77913b12bcd79dd62c0785216292327e3a6880af7b6d7807929cd3342eba9283427020456e980d1d643f21d73522a0cb0ad4482931688409d813baeeb6ee34f654c2cf8cbe81eab8dfbae134ec60deb1b3ead5e5eecfc8cf8c804c49a988d5bffa77054d3b6fbe58bd941948de3e200e1fc316a70edbb85925d469c5e2897465d7c3e5c010646c36e09f1593e3f51735adc6bee6f9fa557169481a8695dbadd30c6f2dee99e6513c54376ede961d573c1f3cb16db9bb8185c3b908e91bb54be0225aa6d51efe24857de5891a7709bc9eee680c756461af9753bbfb475daf342e6ebcc6fb748536c58fd5b7dae3d2d8abdae2af7f8a116bdad5cb00d4a8215a349bd917ff1d450cae6d3b975f40630270d820fb983a30d602c66dad4f0c1cad0ec3e58a3315bfe59bba5018e46b956bbba8c77281aa25360bc431f499e549e8f928ba59527ac5cdcf39c07d3042e86e39d6a6ae8ef0f70a08d1fde3f7ec1bf6f66b9dad0cf8ae90428b8444168a90c0580156220318e5bf2e8b5e70e2bc6ece9cb04fa0bbfae26f607b804aa5736168509658c609c86a0cce70ae5daa08b14feab81e48c9bb3c59c1b0f62ddf690d91db364ea3286cf219e29f0f005579897d1bd9a8a1c97a41b800825c44be6c736fe3bd7047d0a2bf3124d921b7254bfb9d5993a440c0954d4c6ec53301b96e1735344e1c425a189ef90c7293dca0312772189f5c57ca07e950dd954a766d5779a191922e19966174075facb6308c5726174b9510075770f7915f3b06f658ce2a5c7b60d86ebd88574fc55cc1c02b4ac3b4320748eeea6132dca3dc6f5ac179fe71d6bec523be767cd55a9f31f6289966041c98313d957871d67fd236e24cb549ee258f7fe3171f1b09ce4b8f4d696fea15fcd087c75248bc919c76e974643797a90056c9b6398a340bacebab26a790fac76ceec942170938318fd9cc51d85817315db8580f5e34d1a00c1af6d05a5cf14e76f8e84477425ec910a3dac1e6c098c1f147c127e95b3f4bad2e01dec8c35931dce2c7bee53598b6bde7973071a0a6955d9cb9972566a80cec26f0e8ed81e7951a4efbb575ad6610a864e58422045f40d1f252564ec548b5546695e831bfa1fde8b6c5f919eeb6c8ac9e52753d0a6c678609984a35f7b19cad9d965d343a2b71f34dc84040834cc3d4e2fcce21788c995a6662684ed2a4be0e04f9acac09651a0754727b7dbd694d2a53536b13af58c89bc8f73397012d16edaf370a3bdcf4a5328e898a1626611c9f10af07b53c1deda04033e1b81101daadf8ff6df92ee534e5c8c3bbaa20b44253fabea55b28d22d2391346911816d0d8cc248a2140fbfcd8f2d0fe273d0e462acfff6244408d2c5b54e63afe35b07bf388cf2d7daa7fdc18785549b578d659486d0fb1a18d1809526af40485a1a19d2139346285d54edaf80860de4d4ccaf17529a48a69c4e4122edc0994dcfb1a90fc88ee511332d5337d4508933a67a95d0dd4a23250ba18c0c1235783de853b9011daf25daaafb7eb80b34e1f5a26cc4d3512b453fa11825a5bebc5a20d0910fe038ad381bcfdd14243566610fb1b5a3352cfa6b5be72c1704e45c9c956ee598be33456ae20458f125abc95b84b80240f89842a3138b5ccc9822bf3179799844872390fb597743cd1aa9d2b44d4759fd48e2d162ed7fb41c0bc62122f892364cd6b72927fc6061d4cf26958e1ce168a1919b6d894173dc8d85412268b0d379eba4528ce085e30955786f12d57962fe451c2d523d51cb9baca878322bb7e297b4bd87e43b7f6801cc12245a7bb8d7cfd9ac8ccc44795035eed38ad0ed080afb4c3c5485a52ee4f5e620ba11240addda1868e97c3bdcd8a83282330f2597b97030d425ff6092396afb002591b82fd07892c47c68bf3f62e4081783b7a4d67486693a735b34f2eee3b1746714ed4125aceacc82d19c9b343f54535b23619509c2cd0420c1cb025183376bac82afa30eea09ab0c9ed51a644b4ae5e5a863a63f7654adb046b295240b0e88616e53cf40aa602bb033d908a5444e5a8b78adc19930591c01946db369fc3f6850c874119197ed6d45624fb2a56890498be906d1ce405ab12ff4ac82ce1e23002c7a366128a2f758c59bb3d6bd306e7f4e8efbbd3d244b555c0a5192564390d69a9711fafb7b379ee72889f1f74cf58806bdfde655bc93d6b07831bf75cb4c71033198f2e8058f188a297a486a32835104968cf14f3d755d9bdecec0f94035c8679618a245f22d81a0461ad0e024054dbe3016f1fcf2a879ac891fd5106608ffbdcf3d11f45ccee091dda2cb13f2aa44f20f1ab83914b7b0aa2ba97b88d928a4b8cc0290f25af77e643422aae968415e4bce91a313487745c8d3c0505cef3be10c1f036a336c9eecdb3d4a6cc3d0e51cc8d0cd274f0e7242fe5f3139b383ff3f9515d9c97c000128f1522679070c725ee9fc00736a3c7441915bbe9c3c6ea7bc38e42b1d2d6f17717519c1b81961ffe69773e700549e494b90ff1e010340a9d813f2eb6df8887acda12fb90000e0e505db744670a3208f4c0e7e920f7ce35834657f4ab8c0184cab5bf9f0232a88ac0051e5798174988806eeea46858b5ed68cae539ea970199c98b3207671c4c270452761cfdc2c7119139629d19215776be4531642195195a6abfe50b50abe36bd26ac4e9b72536890598f4ccea5b5bb026c21ba3eef3f14875f10b37d783f7120bfae425dce01f2323a04515a6c9ee957f91dea4811d11b7f188ff5a272d89bc507bc2eee213e03917cd2c8c8fc27cf6ac5fc6c89dd8b629ece1f6a754feb15d595bf71bd6efc3947040427ae02fdada3d6579900ad5d668c16804ea9309ec56a54bd70502cd7a8a787833923604a3565d7b5fe2ff4e17e53cae04ec8f7a783b4fff7744826a42f38d87fc31c88239e828ea71d96cec115c0fd62a611daf325c5b310ee38c6d306358bfd6c1c6943b37aa6463083c843acf5a56c29e8ad8a2b92972d33d2ad507858986e49f9d4b578d2d02bfd5bdf320bb32fca19adcfdf3a1ceb49f3b1066b5af0165e8d449fe64a3e206270fbea7495ee99a4abc3eed2d591e4067a1a5a47655eadf13388bdf7305abf9385585130b1136a61b853b6e18118905c18629862ef04ce1f9139aeec31c2b763aacea6371067789a8f58c305fef29f4f6f8cdc789e5d7755120169e858363d8ea82ed17da2381a03ba9a4d94a8ec3bad452f278bfffb40a2879205aef144deaaebe4bcf2ca13d15911cc682f0a0cbe43c023f742dad5ea478ab83d98aeb6ec983b57c0011f22db7a8cb99f2782e7d055ec5ee8288f62d240627c95521277bfe3d2e121ceb296baed42a2fbc8819e343492a39730a110977e7d1d8054f6fad40ed6dac8c31eddda1205b087243335b323b969591237811282f7e83e6639672f9ad9fc553c37d93d946de542851b058b3020664141533e76557d75ca8fc5b0ef810ec596079e81d1460f3091bbda7a7c1efa3aed6003185ca144617f87e3a7ede9f743e6e977786f6fe53b4fea9a3619261d783f946a13c3fb9114856aa06f18b8c3be73ed7e2866370ab06f7979a58c16f7af20ed76d2d6f91b0af738cc5264d6f2c6a786aafc1c01d598bb8fa84f6a7e454d0348b8bcd41f3ae1f7b028337faf664209272fc7ec0611a8172dcc269acd9f607e26acfa24ff16d8e772dfda4283a63a73a372ef55226ad58d19144a526ecbc8419646485e042106076b482d87c9648963d2368ade1b834caa97552b417043cb900136df1c242e3f7eb56d79ebaf56bdeb6e235090f971905b7f2e182548929e025697e2edb295f3bc57b63a16f9efa707c277dccbe9ba94087596c46f533dbbd05ce3a6d605f37f1d3358776ffa50d7228d4a5237d2ed02d77a834fcfa7fc44c1102aad4e244a6cf26724aeb15dda5981cf8177623f249b8b763ba4edad621d119c4b017ada842f58708e25a503f6a3b75858eda21f429f7aa0d80f9444ec0bf5ab0cac03d0c682caa3257748598db2963fb767ee8393d7c5f631bbd4b858b236b4ce4599c576b9d8801cc9dff2af3ee5d67be05e4a5137c263b04d64f6278490f802c202f70230305157835e2d6174702ea87ecc213b267e7070ca091e77e6726d5951d6937555e6f6ff3bb8c59c9f73ce990712a59949a5071e4b9b07a42e674ae95cb0544f6722bdc59c1e8e471d4986c04cced04526e48825672ccb4430a78fffff4d2ebe953f97b541d6065a98a7aaaaaaaaed8ffaaaae1106d0e6eb05aa295befc88f891210a6745865536c5cac54244229692549abb2964c2477944a301972b960cdb411c2216c8a563645f5c99868533389a46555d814b635eae3ff3f972e83e0eaad3f9a6be0040fae9a96872786232aa3a3af1ac618bfb428cd7c717a8084bad60e4d702bca7ab2ae555b582d0d8d20451897f91ad2605eee91f9d329019cf1d8da8367b0bbbb3dd1bec88a61e179c191fa6c01ecf88211c312e300ab0cc74156db5b51d693751dfbd1fdf021d5c2939c2140d61b74621372a222a25122e1c2ebe3c6a6a6f6bbbbbb3ba010629cfea829943526f115326b5dd30865d5b2a2ac27ebfab076002a143a70eb122f898b369b6dc5995c318b5043c9169d5bd489546fac0a9bc2b2972003ab13461ea28c32ae13c8140d63580153dddd352bca7ab2aeed29b5b505c4465c3f13292ea09e8fe3865b7777d48aa42e2b63570dae271ab8da08a9c4058e4b77b7cb6229182d3696dc9278dceec32e5ab66c5ddbffbb2af84ed830fd9284c0d29a5e52841d2fe5ad47940f175dd45392f4c678ac7954ddeef64c8110774337f6ffb18e28cd44263d60298b584b9c333fb843b537e79d4bce39b6d6387d0504f3ce30012e3039f4aa0ce994450301de8ab29eac2b0f2de608012128bbaaa1a94645950c4de4d443b49112e0032a9d4bb76b8ac061bb9935c3929715653d5957fc12d6c7ffff9e77e57fa744f0007d88ab592308930ddf970d163234323864f87f14c39c7d5a5c162e276fd99aa41bcc38b6c0a2cd669b494da72041e0180faebbdb4ddf0c052676400b30785cb07462109da8ce14c12dafeeee0f3d1dc61b5a93b6ff33862494663e19ad368861eb1f72b1f2e7bc588c802220b960ed9011290a6a1933b8009821769ab090d8de7f96ccb53bac509ab9d5e56187d82c67360d4d76dddd6d18aa4c69a6fabf10d562fbff4c4294660e3308a662ce6fc953b2f7df4ca621b6a47a6b8d6cb8f16289dd97354f0e8ec063d0e45804b3a2ac27ebca7b9b73ce594594661e91496587aca5ad8396eea58fffff3860702bbf0e1b2d8b8cd40c59fa4b793897125d379272c920998f1b215217f15694f5645d77217cb6a6b6e4a5bbbbc99029cd549f32fd60e175bfacf8733ea91411e3f0ff8150261ac4feff0dc00986d588592e07dd750c09142f70090d21239a351853b06c77f7900fa5993f6088a160568f6aae45edbe6aa4436966cff7fb6004bc0ac618639c5bbabbd95a46a1f63be3ee6e2b94666ee10e325d286ce35815368565310c4ecdb1350cb41a5be3bbb229dffd4a5ab56555d81496c5ed77523d9f6d5d328258b2c26b7ef9ffe70280e9f6ec51eeb8c4136d58fdffcbb91473d3b7b19aff1fcb86d24c5d4f032cdf8f76769e865c923bd2610fb2fb6079fbf8ff0f2534b4f2b7b8d6ddad944c69a69abee4803cb37703c09b84ec171b390caf16c22ba89996a797946606cf30ee8131c637cabe59368ead71748dd36b1c5fe3fc1a0728ecf7ee09fc727158f7d41dc7b52a97aed89d7b61cf20dd7ad2cbba36f310b6a42d8ec8e7f032e7bf55f3ff2be9509ad9f3fd3c5002fe3f6f841a5b6245239c747c332335f5cffdff3d6c28cdd4f57cbf103d805db37a8b31c61877dbf296addd880132ba8e242ec618d718a234b378442695226a2c557c9382e2c17b51067892b62bca7ab2aebc921b43160c94d01325b613b2947104caf7bb3141614609163bac5e7e3ace760ad8fbea1b3b4598c7aab0292c5b03005e77378ec40b39dc4995245b7c97430a9cab1897c5fdeeee6ea916dd4a37c61d6731631fbe106be707a29e9a33bb73e6f1ed8992b1f4f1ff9f461289e4089b9e8eb6d7474b12a511bba99c730e16519a794426952182cb1aa7deeec52da705590b8104494f46ab7bf06efd3d4f91c32c901b784f8b218e9a8c68a05c0cd13a8f3b7eb83a154c62329634f4248f43ad087684305ce398f0f471146488cd022bc8f811923b2292c3e3a846850efbff6f3184d24ce1f0438be2ff322b9ab44769113c76e1fcffc16a5cdc92654a33d5d95bb25c4f36e89eeabc227470569fab730855da6cb69a99596c912872dd66deff77e8c043aaeb5f1e6753532f898a2bc8c66206f9b1e85249810848d68b209e196228fa884ecc540437f0d2d5e9e888712372bb3efeff5f97338e8cad29221a6c36ba860d163d97a5006ecc38ba526c94f08731cf3d41f410b6d8a4694811efc61e308dfc5a862472445a384ee494d0f755c345219b825d5cd50659dc11917839a71042af8e28cd4482b84afe38ae942b3760e5baf45dced852300f0613cd6870bb181508993671ec97ec7e79250930206408955717d111e70c4eb930f2faffaa224a338f1eaa9039dc345ce668055f1ebeb12a6c0acb0a91f4b4d7dad16f7a8325af407a5891347700cdaaa189d1825a6e93156528cdc4b52f4e4f0816406d8117071a8c31c638aa09001a7528aba5458f251c48bd4444aa5154342d3ad478a4fd7f18d44be97be9eec6f86d0b3f2576ba96c8ae545c8105d970c09df8cd7a5cb09afbff9584509a5994f464eca0648577aaaaaaaa8a337bdf5a95daff1f86446966324cb9862d51c46cac984e45ac57b3402522449e488f9501820792373d2db723c1125a472d406ee648ea5815368565956adb4ef0eed4d0b8015b21c319b60454b26abfbbbb7b92509af96414d16385c2b6dd3e3b2990a2ce8ab29eac6b1490b21cd54562e66c81a7d301f3824caba8c914d21b3143c0d6d4955113d412a8e753c4cb811398b2b46010f278f05801416163fe08fe3fcf645194c143bedc691221bbe15b427edd30b6d2afd8c7477d39c77004df6e47621cb16952ca51559574238a2498d24cf56f4dafa4f9012a996b915d581536856571cbaab029ecdb4c5d6663d1c7ffff1cb61c22872e6723e4520c1d442f1518bc69acdc7835e49d36ec9e2716d030a88fffff01ef8fcecc06d23d4368853c3e4470158cbb0257e002a6c88b5b8fedc724e34176cd7a39d7c7ffffa82572e5ffdbffff3bf5509ae9fb013308a7a0caff12e0e4c379f14ceec9399b90455ecbaab029acfae69cb38f10a59943b5b81e51902c083e49959a8bae2ca6254b6e68d316f5e043974b956a50ef58153685655b75c74077edbcf08562c44c52d4901f27b058b28bc2b12a6c0acbe217dd993986b86555d814961debd66505807a594f742bca7ab29a6bdb8404d4ddad43820bb025b29b2043390da51563657adf740b57c3d5fad121ca41e4f6c562654a33d5decdff5fc48d62ce3fbefdbf4c12a5994a0f64966f115343195239bcd8755dbabbdd54f9b7c45bb0375bc21155228eea85ffffff15302436214a3387c52332790f6cca9fe4869f7ae07e1cd0bcf58aff8c4ca78fffffc5b0b295ffdd4035030fd44c6f85f24d81f5758e7530b662d724fd09d6201fe3a2635a35e6fc254df00e05feae0257316163238af8308a0103ceab86fa529aa97eb744db59dbc7ff7f61cea80957336e37398ad408eaa7e12e9733054d3e2762f070a167c609d70425263c7182f39bf5b8bcb5d4f8432cd5b5efb74f27889baf1baf28ebc9bace786b075e60415c42e38e19352a88cbb3bb73a8cb8b0b7c90a674c4909161a49b8080b93881bf9b09d9ef37c36abf33eeeefe4262115fc995ac8acc07b79393d14cfd55d653dec0dadb060e54b5fdff1fb72c0df81e9596924f3227118d12274a4b48079f8527231f1c28ca48109934f460d0c1579ffbff91921ae9a9918c8d64d5485b8dd4d548628d54968998ec54555555754bdda563099408c20092540449662868464cc786d5ddff3f0a08a5994220a28a5694af92165e50f514b946388854a72ea6c80cfa04b595ba6ef75b53fb9d7177b71630a599eadbeeee96b7cfee99931cc298d8e8b101b4aa6deb1a65a4ca5bce2df43ae59c734e12a599ca10394b9baee7fbff16530a08885b1c331bb639e79c5f21946616059020a8946ddee6c40079131a68040d0371248cd31863001400070c6a94b4787808311687c5c1a0480c0484026130180c040040a140182c0a82d068aeaad17800a9362d9b755087dcf8d252e1468564365bc5a23186ea284aae53a43daa469d13895e5178dc5b2b30f6db8c5b8ee015ec4a8f461befdb5090b46549080152a5f5c6c1719314fdc262e01b2f7cb846499bac1e5a5c8b5520cd8497002e3e611b62c8d6356057eee490bdaea48a573a2d93e28830caef4f278d631235b561e51fce0ed32674e53f5140a552cb7c0d081c6388e0e53a5effafcadb1e9bb7b2e6da0865e6d8d3fa48fdd8523785e51f71ea1a27128cee1c5d7b313a04ba1da2b55f9be41aedc5ca165f290751cf0590cd0d4fda27e79761ae35b87b26687011cf31c28ad9d213cb6344da3e3f74b2b3537c3c235bd069f7683ed20d21d4b088ed678cb5fa2a8b5490f1b7bf61818323e03ed030f223019ad1775bb4d2eb1c7b0de8168040063925f1d163b92332dc60a11e8fa243ab93c61fa4c3ddd46864a2d2308e8fc72fba05207a5cff261d3ce57fd7f153a8add024690786bf3c69bd9e960280f148bfdd347b2c4e8917a4c69317fbdbe47b65fe1897ca90aaf0343c7295c6066ae25db25a775eb1efc34f746a1c8bcbd876ca1a2cda61554b1aa040360a9311f60f9eb859eb6db7cc115a2a1a8a6941cbebcaf6f168f51d1ad31f04589a44a940b87979d0107e60ec29246a8ccc420d8fcb4e3ea5c9ad027bd880c3948e6b7159b4a8a37f4cd55e4911a95427b5d31f4d2e256e27bced380dd8d246cc8829b585e8f429a07f12dd81c90e4aef2cc53877cd856996c1478ea4231f03dbb9cde6d8de7297ec59b50b45e032049ebd53d24e41279dbfbc974d67b9938564044581bd86a8ef7d6cdc08a29870510420372809173a9fafcedcec4568d34eab4f895b5024e18176a716b453bba8d17c4aa98641e0ade052f9272f7b879a028af2df79c3a056ba73b0dcc0ab1dbfbb3ecf2a45e574a9214208b332241ef642a9b3a700c8f059c4882a07b51c53c0c4c948530ddf491f68f199e39d885c90506d27e3097393314eaf300cd5dc2bdd5d2f3e57a48999a80f83cbf9c362786b75587cc2c110b6df4957d4e698db840b57f3990871489c67d1bb9709db69cb1d53706044b9c4beb1b1adb6a704c44f90b01ba8672f30afb5ce0a199edd47bcb8e111e93344e453b4d2244f262a824b6193cf528a7639103ac8b8f2a9bf48c2343523120f50b2cd953e8adc09dcbbc14975bd51999a584ada2ca8feb61edad30207495f2dceb01a900e462e6039dc910c907c662c6d15f58cd2e8df6e596b650c42f533dd0d81d1c710855ed25db4128e89420b34545bcd5aa3e8d1c07cf9370547599d25c9fc3535068d70d49bf3178596ab1957e640d3c1c9ec30ab08cf814acf3bb05ca64ff945703c097977487372036f25de21d993cf004ee36e30c75fe07c8e237a9a01dbb35788df885ddc18fa956f48bfe02d9850367135038276ad7ac5cfdd5aeaa97facc69751b681d13c3fcf0f0452f8018b861cc8eb837bdb995d8d04681627cc7ad38588b3024e671d9ad1941ac2b52ff4a94ff9ec9119c77e26f4f16b2da84947bae7c04807e6d7896a4eb000169b8967d635e87bccbb421fdf28d726084833494e7f3dd1f6aa5243fb3ac63ed839d08a4bcdc162b3595e9d5ebf4459d602799f8bfbd5586690b47ed354eab043c80b429f3b4ca1c0e42edb66179c066fac66bde8536217815d0c77fee1a07f688191d7f3b54a0584cb0b21db23e415fe7ad635084a5e405de7c966d880a6746f69be38a57145cbc3f38f131b5b21e5bdf0498a9e2bb907d5aa73183bbd5e33089b4311958b675a65fc285b577710993c27a5231644a4e96ae90a487ee4b5f25548fd8b6d66f546e5ebf31b5b22d90630e8e9505e9479a09a0b589aeb9267946fb14fe12e4b5bf927e8662b339ca794bcebe7924a432b6b215078fc811dd261095648c9f765445061abd52791a68bd1ae7496b0272b2185476bc1989a6dba82cd1e6595ba632c3c2539e2cc4490fddc1983701b68a2790f7ff8a7b6f3504497669a34a6b5df26ac7103b1be2d273be43d06cfe8503da2511ac3b9093abf2e5a23c034eb8629158e83605bf704cea275cba29d285a1868e5d6848115adca25851956892766d702a8f8df05f238a80c2a402072804596d9116cd5da5f2fe3f834001ac6bb2609735f829a9729c75aace0d836b8065dbf5c8df4e036076bdbc0eec5596eb839aa9f283ab945c837d4e89aec18423f40e74d8cf50c31ff70db8457a528c77a3e540551713c65e776e3272224a12720a9b9e434ddd663f81bf7a6ee289d5fc5c00297698a96aba2e380fea4cb7fcbfc438db3b037c9112df4f081eff2c5bf86c1c8ca5e279d4970ce10ac5b53260a9c2fefd849d37021d84db480268086fe18e2e5b029c72a3852341224da2635397b4231b8fbd5efb58bf18e9920bae9463a4980e06a20cf274249c6005bbcfe7ce8dd18c24732cdb4ac1bf83d11b657c55bf551d7b85cc81352d7a7c53e89bb842e069f8b2c124a6af601f9b69bcef5e6740a0ce981c6c7714b376ac1ed6ca411b2609a0d4efddf50162a9a18c4213803c0ed22e26c04dce7b9032a2229a2c083b04df26a7f4c657e471792b80fb7e08dcdd5298ea718e1805344b41e197f95e6edea21c20a06b24c5f28922d3d784a3db550c565354db5df30631d0935751bcf76da87e0e9a011f121f4da51412404c9d533ea8f1b47c2a766ba97b8751079d3abc46d9e1afb396038767c27d5737cd76cfd19027c2517ace2a75d1f2d7da2387c4a568d9c5904311c9fef21808ab53b5830728ccff0c1a15829d66e8dc39a93d514b76b89e25e9d555cb043cb9d3a0e67a77c8ef637ae9e59c1be788c702cc609d62950454a5d9c578b09ceda25e6bf646822edea84c8e59816c400a69df0178f8bda50a373bfb87b442a100764cf27fa86762ddb6f1c5aa225543fb481039a155063cef8bb3ff2e592becc16f12b8f93d10ca7bd85a644beaf8ce26b7b20a3ca57a6780188e2f69f9d7eab8449aa11e447e81c35a2a2c7771cdb03c1d4f793c81db60088efa7525a972757d5d2eb1776feba731f8830be46903f5f1411464cfc60e10d96c79d2503bd6befe426afa55f50d91c298ecb41f2cc0f06dd7fb4a868b05a8a9ef77b074e8fba84274b104ce035f24e70b17b13a5dddc4b3ae4afb24ae106e84657b1ff6c49fa936154f1752f996f6ea52be089cb271a71c6f783c5997e91a0552fac57f96413a7df75af1f4f8a66abe2e4135ccbc3d8d8d6fca963f9f533e50307e01cc56d5bdf4feacc7a481144a30d3c7c55c6ab2a5c9ac38d13b0cb04ecc556f816d52db834b498546e7824764d532fc61e67023e4d178d2707147b0092326e06550ccb01985b2a541513973be2ddf77c2c98099f8990cf5b973b5286c9544566989fb38bc5247f2d5a1236d6beb0cb0f494e67b19d4dac0e73700df4781b55eaba76e47bf70066d446295b25417f50d0814e4b3530c7024fddb0944d737fced13c0d7468f2a1cae92ba079f3a212f1c0875d95c9f86399f8bc530c36c8a3da191668369fd1b569cb210f73b09820cf233bbe24d37d370caad446009b2e668b8ebf147e6fee3cac7025d0a2ead12c4e9e4d048658313f79ad5a630264c542096ffffcafc920a94d3ded10ef4a19a576f6e80444ec71712de5894aaf9d467b4a712365766e2347beb00c4b98017a2fd4955a3ab7285639dd392b77110c9c1c1b2d12b20a6db882c00473798ffe2d7b3ab67acdf9581ac9484a5000817f0b57a48b9ece8473f75d62ed4be91653391c90280e4be7b125992693464a0a244222174232851f3db684db69d822b1b8c75f36af99cd6babc646e9796a2a2e1551f9862c5df57abbcc8b6873a900b24ce7abea3c9078941bc4807f073d624a9514c8b2146fb8ed92221633ea1b5444cd927035792ae8e2c22a206cac941f7da4616aa0e32cb533bcfc704b421a5a676a2e93b0505c95b550d4c544e00267dbb6f72c08576e2350e1f469f3e98483749111862081de8772d4b56e7a49e96a234abe8eeea3e116b5c24746bdaef6b7d3493275a86ddaff53e254618fb4a19fb07b06e30ae735850e508df75c9f19de0ef29821309f3215956c124129bf0e4098b807229ce8086074b272accd3281655a57a501733a1da0399981da2ec635447792f9e548724a19f09c3fdbb2b78e747385b38d78a995c203d80254b4994420fdd4e01a32d812921ecc8b9c7d183ddad7d23d1f49477977a961f6ed52ee658fc49db2bead3b00d4445d8cb97b6af667936aac950647d04f7dec399d5bb2afa1d386b5c29a41583892242fac073acee0c7740470225faea9d56a87c6215b60c2c7ca9734afe6bf501ef2b16a25b8c64276475862d9a795aa5e5e334442f9a253d1aa5a930b88a83970585559b7ee75ca8a2fe119d85d7b8249c9ca40a079b1b873568e1b5551ca752b629be3e06ff7eb0faa4b490e11f169d15fc97c4dfa13f10fa031ae24e8080137e5b3690ed6ab8a7ecf87c7577fc2d8ad055c8214e103cc8920ec43fadb5e332b4e05261adaa0a2413b37b1ff24c2b81ef63b9bdad754cd1737d28904bb5670779d624f5bc1068cd0801e6001b8f0306d27a5957f15f60d1f3b443ec1b2d9802710178009518133e01a4fa23257e2302ff1ddff9750f6fc024a837c6af43b46a17aecf7bcc0a5d980bf7e91c36b631cab928e7652a3e5395289179e82399b02c978398c4e4796c2efa5a6cf4fd704ede56334970e33d447d6146bdbcdfeef36d319c0d40d3cadfe267a4bc688acbc30c9fc52689aaf22b132504da6328d3d259c692c8614c6f114c2136c651b2849ed57681cbce5d7ec868975d13f3b22e2bcb18c369a150158f43c588f848518a1c3503f525491444e881a8696f16b519af71ccdd9780c76e973e452fa293057a143030a0b4e6bd895823cf05a6dc82cb945740fa2e2e85dd61fcea1f0fa746c15674086a9839964f7382b9a0ffe83fa03816808fe035a21d6a7ca3675d7b1bb7c16eadd24b159d2d42ac8cfdc552389d1980bfda9ecf64ea08426a51851b7d24f05511f813af01fb2d15ec806d423e72ed88249a22b5c3428e0e51b9d1d6b3b180430513c2b90157403a533edc59300a243854217afd93138c291a9d91c861a66597f1c0a75708ce831bfe516e8a23f9eead92a0086d518d7da90b5e096652efffb956a443fa022a07dfd5aca652255b4bbfa4d6e7bb38778a0ecf9441718c9fd6e352c12b38112bb9575bfd5bafbfcc2bee0b8d36cbdaf4d8a279fb2f2c4688d7900602553a9d939afb7bded4c3c37a5d2fb7bd02ea964bd9a69a5c263234759936adf5f51f07cd2cdaeb75dd5ff76b4902adfc34dfa2ba87d1eb5bf0bb7d3aa9ea8308dc0156b5ee68c85c67cb39352aa13391e126a2308ca6a4d75e5110b0e9ae17cb0c50de55f41dc61f0cd5ca6e79715841d7bc10692cd9881858bc51c94e9229bf1992361e2e2bf02015ba3a9b1cb2f04f2ec93a44956c4af931d28f597f0c6ca20278ea4d5888d53971a147aea2cfa9aba84a0e82fed663cc3f65ee777e3e125eddc757ae872a6b7dc2560d07201882badc1fd2affe4b7775ef80d45ff2feb7cb12a9121ddd54807c1587bea92c8ec3bb40d154828071b6e417fbd5511957577aacf68db03863d4776bac2cafffeb84b7b9182131aabddc536355432bcf0f696a9aa126619489e1c2f837e56090a568740e2d036e1ad58ddc669f3eaeb25d781b0ca4a2309e5ffb034be64faccff6797b8a4fc845ba4f183033f1ab983220670ffc2231999ae83ffadb834c048dbb4d7fa5ccc3bd941084927cabb0c7ae5e10f7fdcd441232723b42a53c91c716cfd60bd1371d858f58b717353649911cd818916db570b2c071169ebb7653c9c590d438783eaab595ea2702f0ce7b618fb342fd2e44324ab75a30a4e6d5d41dd8d926328e96f99d871e4a368dbdd0b747bb8532b48be47f39a153c69b843532a8e93d7af5d643312d8e5b5a0c4a25f42219acb58f2a70185476e6e08384c5c6f49b77819579789c11ad80cc72568b6c9e9ca2dce874dabd6bba4de1b94886a49fec7cc5493534bee914bb968949d4e9831174104147cb09ecb22bc02aa12f5f38d0b5f26f0053046901c43f244c279943ba89b11e1f1c79b935d56d06f6bef29bb9aceaebb31884f5044cf3a013a91e663af156b02a26eb6f83c8cfabb0ba9646523a610d6fc98009973a394195fe11da460de87f866fe5573402d801d4f263ff9965a7280e28bbac1fb3a91532b116666f1014580a361bcd554368c3ca907f8255487d14c049ee329f36d1c965f0fb871c65390ce44bb2842a5678922df7aadef656b933226b0e5f49f1a87934e662483344f5b90192273be59a78d50521104002e0bb4d70665d566e48f7448cc15fea67bc89905dd64d560c9edc3772d7fd0fe79f04e1e16e153b4c198788d4958a48c5bf6907e77553abddebc4d936111042d296b4a8cc2094514829e441437056cd6627d8e24d3402595c750e0d6bdaccf61142b9eb40d792fc1263427c75c4804ff7a085386eb563553020d5a2d91f2b938c451d0e1e46a5e477f6fdf6230c4eafbddeb1e129692601de45a6c59a2902133e5f6a230745579e1ee33275b7949954beb877d6213b8f9e936bb6029697b62096eca3b90903a67767f7171721fad61db7398a629fc90e9e847224950390feb0d01424edb4a4e35b638e838aa595cb525d25225e5b021ec60f55019655ea536c72983be55d13bd4e96587c7ed40f3b4f505f0768d27f3233e3826a779b6da96ea128905ab30ae2dd9a9274f0d2b6d99e1d25bba5b08dce4414451e17b3fa4c6859ba8c4afc647dbedc69b6fc8b76d45f0224eba4fd5c40dba0b542bf719df330757f504b21a1aad7f1d401e2a5f83d2c6d2def10155855e5956be4409a483234b7c34f32756ffc36f090c50992fe760a384fe8b8b759e16c0e65b8ce2469aad7cc75aa3126b186eb7be7f494dac0d612e66872435f5ae50ab6971f21e6e8e22a4029135a61b7984c9f5f7c4e18a0410c3badf31e95fac7cfa3d154312c3a4682813c11462febbe9dab5402b434a4f05e49f052ff85a0d4f45bb7192106f45466f5b20c3c70847587331ac70b6d0f4bb56230fa6e66c50038cfb4624fac635162f6fb87cc1cec3726c00722b670a1efea68938df478446285c70505ffceb73aa508ecd914b96c4918556a269d38f495a8251b2b0be5adb91bfec46f849b060967363139e2d45f127b22b0f8439cea55ae51766bb3b92cfca3f4180bc8a1ef7f548bd86c4cc348b8544cb3db6ee5cffaf1929356d9288cb80407e847082711ea1d233184ae64a78a6a46ae59a4510ca760ab19d7d4e0ca3059ec005c0e864e5589b654150b015d2d314b519eafcc0b80c768df4e54836a95ea3ba878b035b0a05ac8826c5306e3659bd8126f5a261dae5b3851472b3cb8e118dab83603a556232584de2ab5d5cfac6d967120e469e0a249c2a84e7c2aa22391db067a3a275dc2a092b81d30f0fdcbc34faaf08bda5adca3346ec6454a80d366e899c2f7cadb8f4033ef6801f4ce7505fb9f5e9297932d4b73ff34b69074d344473edea2d1c4925f5c2b53c8436839466313c99b431c4a191275219dcca464842fd4a8352f4bc28ca6816e5564428a218d1396eb5f4fb77fd978bb38af36fb6e95a205e34cd60cfdc31d8d3139427e3707d7c278e09dc9b8a779e465269b1a008776d0858f259f86cb188578370b958c4bb8b76a169daeffc32533e6dd1c2de30d379e0bfb66a448b0f3060859cf1e061ee028af35bf19db4166d67846564c600ee1b32ed8ce2f2804d5646aad46f6f8777af521c4dd6a0bb77abcdb88c74ed3e9aa987517d220108b1a922ebe9bdd0598967c5d22003d678dfb92172a40a02c641e9346e75e2312cd96e7ac7691062d74ed5b2011007f14b9d6efae4e95b3ac039efac873f07191ce29a3a77aac664ae8246c66268b102f78c60330563d7a56c026214a8af6f2dab6207bcfa4f7edba740107d51fc2eb52afa264c2ddfe1827d1a1d7748cb4445b2f45b4bf953239bf7e60864399f74f5d24c1561c1176b8b564bfe086fe44fe158da0ec3a66ebcda0345bf73b5dc84a4698bc1c3b5bf5181f49cf3c818972d1d5b58802a4b7314b83be9d99ec89bb4015c386d96e87e99b3ced7eee25b9a7a22986e0843d77aef9caca912b5d0c88f55061380ea1529cdf84a222eff2e5864596c8cd9124646384f0cff8ce257aa2eee2dea3c3845c968e7b1c794963ab7e0908141a0d262886a99bb5fb9cc2ecd67c5574ffb4e7cef3e257c8aacc503f343ca9f02380b6e2726d982d1591818417dfa0ecca45fde0ed31a94b84e858415e52e22f5b9766a6daa8ec656da88c25c5c79700a6b9a107647fbfc45bd95232a2bdf60db1fb6bdf309bdb0ccccad1f11efb5dc1711d7cc3edc0caf0ca1909cc8283cf2a0042aec2a386cf7460c95d20944ab34213b702d777f31df7d266c3b12e63de1627802154a13eca949db37729d8d5ea9638b3e2706bcfdc5f20f2f822940ccc657083040464a9f93aba30924406880913b6f50cc7c28ca331d8d1d02f0e1def8a485517c0419fc11c39e23914fad2699e57923472d7145fd0f06afc16b379d8bb8a69cd0273254d470cf70030ce3fa02f1baa7213f2c34953515ac2e0ec98348f36fca03d91e8697cfd74614cfccd74c7e4798cb3d28bfc961136e2ac71ea2aebacb81bbb0829a0c07f672be14b67c03d8d9f31f0e2f079bc71de86b8b96a0d04e057fda6d35a7bdb49db820fd89817a7a9a28a5521eaa2d59858b96cb65a380b589ad04836f715661cd76a7eb5fa6c9f6d0a2d59634a960fc11538d24812af0cd6afc0d4b093f1801b6d001c24ce443e21590c524d303000805b45bdbb0e03447da1360ac21ad213a6027bc06c3e10587b4e26967b33564b96b530a58e6a5a8051ca179fbb5547e2e57a0d43287cd018565b6b75ee05ae07b8016948de2c4ca919a920991e025149b093a8c2fdc9ff78c7cc9406c25da988d7193b2bbe45cd379fed3a6ca7c322b05e4bbe017f1f2fdd3b2dff9d641e99a3d566d6134550196467e4326a20f8d1b090b8009c3633d80e776b2179d52854d461e1a8929d1e5096dc8743cdd1cfe7ca31ae14ad046ca127e58a3097e81c1dc164bf8e17d4829cd8de665a551a0b1de6c4d5e094ea71ee568863068de987841de2327e4b70d7b87d846fc1e05d1939bca72c93146344659f71332aa2166e1ff3417077cb28429b10d1c22da1a2ffe7c673ce6ce8fa1e66f22b1e28fbe63a915a507b095a8aab9bd16244cd369d39451dbb5db4145a583f48c2d2a7365424c4e77ad4999163905a029b4ae74f9a8720f310a7d4012a44aec6af7f92c71f53f5e9a9d92bb8329157068338468af607b2e87c5e3a455459dc62ecd7a00fc3a18cfc04b5e46c352bd863720b26a9369ca080274574e2766041555b8cc21515907e700c78a89e0f619a757e999b034773ba04951e3f7b70ddb668d91c8c0698815e16abb03d03ca9813aabf069f6ea2a1583eb4ef5288d43257e704ae86f80404db7822f605e894c5997382d6adf78ad1d86fec29589e76e887142ca7caf53df09fd1390b84365b0ba89bebaa1aca0fc5510538954961b137296bcfa152db73535223a74a4ebbf9d25eb30c726e450229ec2bf5a7d06026856c6281c0a62e534a486ea8f80fd2ccf5356a8e50f54fd2677db304d5220fbfcd29548d41b91a9971e84594ee5bef6577bec7127915eb0d24ac0c82b0d207e565d5b130d4bf2f1b50230b381934c79ef5cea9f8ec62c7344b17c91b3fbbf0f85753f70ebdd44d7629623304549ba870cb87bac1b9343d114855e38c4d9ada3d145541990aeb857eab77e2f70e400ff1a8bb12a429b3647749339e20a044d26bd685974d10be43e38266dc96e9c543670040e9443eda9b180d4a8a7d95f7d05ead92a4ac3d23723de7658e57e3d5693a945dac2d5962852c65fe9eb597ea9b06b3395f5d1132bc756c03a1b5da16d1e87705053bd9ce85a9d73412ee9aab365298c5cc7b0dc456282424934ed9746e084c088c62ce9467c5b0b06338b6dd9215b763372b481fafbabba955234d57fb24d9e93bd9e06afca8855a6b057f998b3e58f3d5902dd95cca4b81591a7bd3c8ce56b2915d27dcd51679cf75d43925efb841a040bf357f0d0cc86abcafe2456937483f7d5b58ddd0dac538fa3fe2342ae65669f760a288f9f523bbfd1e24dbc76b196aa82164a287a63a2970b881454a346aaa0dec14f963cc01bf266e801828d44584e73d3b94320fcaa79691c947539aca8a24bf6d9c9c693876e5f9cf7cc807051bb4d4c21b53bd5da722bf7f58a36b964d03786e4f165e04faf96b68a74e0f09a628f297cd9c348275c32d1dfe014aedbd76714faef4d670835d13d71bc14a868a5249d5c94c8f9a698afdca73b3a0b8808c4ed165f9a5552a9774963112457136bc5be16f2c70510dacccbe8a8dae3b917518f6af4a772d573e18b947a8af60a601823eb85ca0d83d429d7ef7cd186b6f555203a9729c067e422178ac293c12158962c6c03842f021ac12960562090d1930e50943f6b202ede345de177ed4ed3b36f485cc931ca5eb7bb0efe1be5bfa857a41381c089f7c31ab085328e55aaff6455cd76bdf74cec0ad2a706c47222ff2aaa7de08e034f88fdb6c9265b4a29a59452060f064f05e8056fe9929f4ff23cb951a8526506cdb77ea32d50a8e2350d30dfd61da62ebc4e6eb2a432f6d8715dc1376b49e5eba796c7d66bcfadaed88e55d08d22ac42d349a0c736271980c342bbea6cad5334dfac3fef37eb37fdeb60db21ea53fca9befb767e4c807dfa1011ccc62113037aede8fa0875db05e091c8f49f3a6680e9c8fa10127c18e2c310128c48301f307d82286c1c8eeed8b4b3761405c2911d7958a2322a53b59487274e4960c4a06f735d8ad7a4d2086b243e3b0ce86bff94e8db98f08baaa331e85f578200d37ba309f37712d276eb49d5f1f873c276eb2e36055d40a03abee3766fbe0c76bbddf62bc6a027d0d7fee3f9f5f99e6f9f3fde68c2f6ebb5ea288c18291ee79194c18cbf30e6d66ef7495777dd5eaf1e23e98e3f4a736b0783578192086b6b558cf17d0d773a9fafa3752c924915063d12104186e973249201a62318d62740ffdb19323d86b5adb5adddee2b1d79b0c9a0153fcd39270913ac3e4511767392f0ed38518281528abf5efdc784f9b583bd734ad5ed18e38e247debdfce6ece4942f50e6e9500d46f55013c6ab09b9384e954ed2f65e1ef18c3c4d7516b521b7c2c4c9f63d57427a4d2d26eb77bd2a25d8f419fc4fea3a4a9ff589faf02d3579faf441f8fa41d2140abbd38574defaedbbba1edbb51706e551d7a77ea2675e10d476ce709c9b945e2276047d269cfdcc20ea356af7834c13a75183a9f9f801d61d09fec30ee6e97f4934713b05787f143fdb6dbed7e97f809e01146dded766fc71feab8dd6ef7e16eb7fb3a9223d8ed76afa34ffed011c9d365afab4f479d12fd3b924c33fec77a0c134f3da9baf730ee6eb75b7bdd8f1d91ee6e8e2aa04e794cb79a3e7d822e9474da6eb77b3a6a65ea79a14a7053880b7bc2f0525532bc33be513c69664aa03ca7f9d9c0565a6b6dc38dbe23377e7829a648c1a1e6879427301a3b8ae8e0338315192bb12d3562778ee7799e1785a40a4d1db4a2744520ea4bc8961874e4889385871a58a21c3132b342738351394dd92f1b5821f6c2b2318354a13903121c7632c49adb9c1ee004e3032d8d0b61d6c4a0e5c0522bd346cc6c5d34ba72be72846c25192a6709c207f69ef09495f6d219e79c73c6b203c9e76c85735416d09c78a05f727659da861cb6160491fa9a210c980db46e121b1ee440eed54a6b1cd3ca87d5102bac2dc46bba57ceb060396d3569af1abb26298a95f31496016d870796730e2ffbb53515f62009db4c59e51ea2c072ce5987a5b185c5c985fc14e2c29e708642e4d01e58df7703dfd05c36ec9448648e95225934cc98c1e2a4c79490106c8cf1d8820108a719dcbc91e2c3cd072288e3a508950f1fd28cdca0851b865c2a62419a3cc881dca93cc881bccae9172cb2b04748539c1c3abc6e13d61286858700a283e389d5cd063872ce19890ecfcb996a4e7d4d894d8d4d954d9d4da5e170ca0ab03a6269c8c25b6bad776455a1b9c585e5c50eb01c84f7de7bef1d984ae692cab173e50712ec39799003b9df9cd6749855c656396e6c9db5d65aeb2f3055689299e10c7ca179d72d87f94e799ee7a1d1aa42334ad797d818129ab29c6f50ac0de5fb0a2cecd13da692d868c0f2c2ce9a929c73b6a17b6435e51db308980f6b15e2c29e30d4509e3170669f51f3a4425cd813864fb58a191f39e79c438be79c330e1daad0d48ae2bdc0d1e520543583f2eaaaf185c52c3b612a32990a4f210085302d64de10b1b1a6254d142968b059ce535e235a588295c52a889919179048299b52662fa4d0bc6c28d953daa3d20526c4ca856bb5ad9688588098f51045446dcdeac992303435ed2b2aecb1c156b69293af88e11757c6c23651c07ec0e94aeb41447b29e1f182f274b5d65aefc0aad004436676811d5a0ec218638cb1a8d010c5a13144091324374c512f4faed8b8e0799e6725aa0a4d1d3e866029c9ca19b0b2b51583b132ca0e0d8d0894a3acaf7cc656b87a54b3a979430e0f7220c7e15b67adb5d63e7455a1f9855ff820860b71614f185a5d1e39e73cc40acd9d33946faf365f61cf5c43c32c076160a69cb9b141a8a992b3508554716ab86b1ae7d9b5eb8aead2f1f365ea862e555e806839d124376429bb6d74641bb6daf03ccff3920ca942134b49d6169705926091e2f9408b0c8e140e4da684d1209f3d0ce41d75f5ef08f28497f0eff2b8bf8bb3847ff4e6e23cba5f0924eb493dbe9d82483dbe470bbe5081e98d88befd13fd8ea4ad033109e7b89194f1382fe15714a3fc48bc263cca8f4437218e4b23584186fbac215c17dde623d82b562775fc7a093149c9fe2091257cc745d1667331898fff884a1d8ce4895157bfc7af9b709b97487ee867a965f7624fdfc7c7250fdcdd472499dec74571e90317dd821d9081c293f8b8530a177d042b8a4f7ee45e41f71e9164fa1eff7c4423a2bbb8820c0f5c1c771eb8e8e2e89404b799dec5a524db93e0760a1fbf8e134d8ce4f5126f93d1236adf587cf2230fc62437e711939464bc55a2494936075d474c02475dd55510c484369f7f9de66c5e08a4aede4692c9366d22dee24cb28ee9cbc84cb8aad3e6b3bba7064d1ffa219c4fde7e7efed56fd4d5cf9f4f1029467decd99132fe3ce72ae2cff3a8ab3bfee9781ec9251df1c98f76becc32bd9e5d0b923ff1b3fcd2f2dffc6c37193b62f6273f5a41860374c61de83ba3d3ac21507ff2a31d9f479febaaf6efbbe988f3288b641593643d2e25a5907dfb1e5d909d8e3094ac2efca414b26bd7a30bb2ef11468cf0a92e7c3a82a54bffadade9eacf1a34f7d6596bd1a2e0a6aec1f036ab8a15412b705668c807ea4655450e22fa6e5a67d7d1c93fd6ab1d9a12e2b04854837c070d4109f5a894e2b5ef3197dd8eb80d4d09adcd37ef8f7e2ac8a3cd75f5ef6d86b7f91fcfed5655648cb348a9125dfbc93e9f29b7b5bbd8a31e993e8be4d267d72299fdf6e59b8bebd86d48b7ce4db36f6dc2fc3cdee8cf1984abcfb086b5d65a6b69a5420ce5a0eabed65df53beae8db71522f59ca1e849f6596acf7448d5d5749ecd5f55d7a6facd61393741583fe2dd9e6f644281156f0a044b0ad306b089e7b62f5db6f9deff883649dcaa84cbbd6b16fd4d5ab49fa4e3576edd397e8d2d31208aea75e7dfbd6d37c5bd259cf2fd0e9acdb3c46f53ccae0698ceab6915cca696f73bc455db535ebea6b9cd3da27282655a78e41a48ce9d674c4baaac017d709d66cc23c81aedda7a01e93aae7d18278d7a01f3cce5183f926d0f4eb79c612b02f62d4c7a3b52246ca4bd8b5679164fa3c7f89f41c8fba6ab361512242e8ddee0f21f6bb2f98cb9ec5189e5f18d975da2df644a5f95a544af176d4d5af172ca12255c7e30573d9b32761d7d5cfe3985d571ffb1ec9ea7be9eb579c382425ac0ebea83d385bebf883547dfcc17e6fd97707209ce59b45cf27b8f1c6f72798a95ff10af200f8595ea97aadb7f92dbd90bcf5ebdfce0ffd10da2add493afbd775f5c9eda0ef7182255ca4ebb691b479f5adab6ff36f484a9874c78b048a4950d8595b5b5bc339bb4dc4f7e623ec55242fb9f4365b92aeeaea83180841ffaa67723bde23597fbb57a3fc0824ef7f1ee547d701e0b8346b08365f9a3584ea37af3e82ad22769b98dd139564bc9d3f95c4a9777cd30066429bd5818b5e502e2d67470146418e0b6fd43eb2d38d58bfe3dd7fefbd3731d6628c2fa698e28bf1a423a65c18638c31c634bfd9b1d65a6b6dc5855f3dc6feea2754b7e35093903ecf4f33326d8ad0a8b1153c61da396647d2da91720de120fc7e9657a27e3a53a5b71cbe09e4d488d953aeb20a98a75c4fd1beb4a2e4c96dc5aca472f6d689e8eeff05e5fae9942ad13525a0a74e9d9e5ed15987b2c2595ad1a4a6547ebaf59b751c96b78ec2ab8a59768179eb406fb73c9559a4442d28012ae5afd73bd67a6bf5112a9d32595c914e9945601d95f653b7930575ccc23781b8688b4a43389d1a992c54a04e4f8dcca2e92c54a05366d1747a5576ed9e725d3de59a2c5498b3684af93b2a5d9172cda239d4249ccfc34565b2983f47af348474050a55b24c21aa02852a5c66d07cb2443f4b32459e0ca7e0286e4d787f966488fc0b7808cdfd2213e47159645ad0f2659f40b4524b2bad14db4aebc5bbde6a2badd4d24a2bfd284833ddd4a3975e5ae9a596567aa9a5955a5a69a5d8565a2fdef5aee096c5695500e66c0ac0dc5cc19caf259c787bcbb9bd53800230972911270073db04604e8f71a19edb24a802fded2498b3360198f35a94a08e718d4004604ed7b1253c2200735e084ebc70020463521f70d3e38131617a3ae0c5c381314e466c80c4cf72cc11129ea701132898f8598eb132918131347830b07381bdd366a72ab7b0402de1a54405c05c1633a5870245ec1056e5cd981a54da1ccd29b4ab5e7c5759c504ae18279f04c05cae62b04a44404c90db096272801e04c09cb63c7378906e6b6e1e3601cc691f311f17602ed7305478aa4ac881396db5741e400298cb340c92f0280c91efc3f4b079de083a57228491d2a9724003be2b068039af0518c209ab588039afc502324f199e2a05b0b02bb6f7c5236d2ac09ca76d08604e7bde170f84045c30595870002330a72f98ad112c30402d401198cb3e477c88866e7845000d064810cf95e709008c140fa90390d33784131e01c008e6740827bc126d0827243da7c9f4785ed61f8039ed0198cb148c44f103e6b415a2cab6b967f34e8039af0af1e46301e8f916e96b1325c09cae42e0f020096a16b807869e9e1c2484d8f1d8353b79841d03c32f60b71d9d9fe5172a3a399d45ca93c57305f2fc2cbf64f1dc2e7804ac9a5305b6d9b6ed67f98588cdfba263c4fe3263a785ae56cd56a9c837a3e52b15f866b47c47941961c190a0ae6739fc4892033956a094399a5368d35ba5955a5a6da5957e14a4996eead14b2fadf4524b2bbdb4e8467b80436442ec57af303ac28e9b2cf06ba2a220be7a5151d50f2222fdb3f4d2f57a0f81391d6a855a679de990171bb6b641606e5b2f572ee8bda900c0dca640800ca06616f20bdad620fbd9f8de3aad12a2ebd7165e6ab8c06f9de2aa21604ed32d04e6b4cf522c2dbff53a03055dd41643d54bf3be14b616f583efbbddbecf368bf22cca0e7af0ad9847da5180df9a2fff5c151de4b107abe63ec102b7efd58fbdb5ceb3487b9e45791669c7b328cfa2ec9e0952bf76b7534509d0451e730394313f67d0fde1d303e6b405261b1cb85c59d2a6c6d8d9d19c42db00604eff6774805b058180b9ed731655d0057d17d6d6eab9972fb5950073b69c776f60b75b09f8a9d7122d7c6ac8155ef580b94d02cce9902be41971afc29cb61f0f5fd501c19caea012f08ade28a8048401cccda2ecf7bb4734053df75e679db5cf599447bbb5beaab3287b9d457a1665a7b328fb9c457ab4d9abb61f90efa330dcc03c6e16dd3cfecf52ccc757c73f4bb12a1a0474819f7a16e70b600e8435e1ed672906f533df9eba531f6bbe17d605eda12092756c2faeb859441d378ba6634ad388cd781223e769ff2cc3da8461664d62c29cc48499691213d6252c882c61c2a4a6be84b130f5258c888d2f6147a4bedc301e5e07a91b0bb69f651891c79561476a7801ea92c5a52bec8bd70416c407e6a50bd7ee82a509acece2e6757e965dca3ce946f889cb962d624358b0167bbc25eda98aa5a23df8597249c24506babf608489ddb834e9b02a3a5c747e965c5830c285446e7b5c452969e28252a48b930b45ea7a9003b933c1ee41976aa77af47ba9950b632ebca1f1264d7339a27180727707b23f4b2e3c9e74231c85b9e8a0c1858a06d63f4b2e505a3603669415fba8dc5256966a4358f0254be811e40895314ca444d16052394790148c703831c61ed2788c4bb0a7c74d47f88e55762ec1d6bcf7b30423b36686accc6d8354e0b2f9da7bed9b28cbc6a986383acb9e565c7aefed962599bf77a82b9ca11df3cecfb22cdff6b32cbb7096212a5f52004291b5660c884a0a463e346839928291d84d6bbf9e97b35d6d133ded83745d7b76d6a09bf6fc529c8fe3dcc7e636dbbdf4ba09b789267c489be3fc2ee96a7d1f138e73138e53e1a3a5ebe95f2d5baec7b7b82392f7775c4724975ec74391a42a489453412848823ce15e0e020c10609ff6db7bb494bdcd7b2ee882e9716e13afcf6bc9d0b7dbdc8adfc5b93b6e0cd96755412fd5d9b75e7dee7105ed19037a9c56c80a51eab75e2919ec2d3390d82d631f080a7806ec50ef06fa8e488fbe0956a082db77443aadd075901e55318b7e459be79b45ed37f18a3de3d4592c5b763e2470bf7c73c6b85c732ac0569a53bbd3715352ae613d39c5f0b55bc7dbbf4058fdbb4048ddfaa66ef6d55c830098945d19fb414a199b1c46787864d4a2e6b8409416465504d60f31305c3655a9e6e3ef258a23809fa5da1335264ee4c08173f3195182e7629c091d520f4ee40e7676b5811fa4f8f974ac93f0504c5b7b6830a76a3787aac6d69c1d95cba91116e1b4d3ce9aae579a9a1a358d0cca2b2dcceb428b2a02088e0808341f3888aecc1e7eccc131258e952c376c1c695d706940e0f8a8d1dc1ac104fc00132210e44035688407a469a5657d0e923c693425f4668892064395b42a1fa8421ca449ed90e694b5c624ce12375c663a1041c31054c2d42096c3161c80e8c1ca13ae1bf8a0c4890d9868e98065c30d34fc10e222368478089220497c34b1dad2c1c3d4912828729ca4c8d975a53d6944e4240edacf6aadb571cede5a3b9f9c5b2b6e1dbd1de28c11051152a15cf587195fa3ccf8ea1fbe5dbf275010c484d6ad6b3047b30e9b3c59648c9da4d41bafabc0f4d7317d4ae10c29e3383db9b3d0b6beda6aadcef4aa6489b2d8fc6d60cedb1ef69c8e6412f6ebf9d314c479dcb388fabcde2c7a018b152b40568cea0aac2535d850264c0d607b6ac43d6dbd600398dd0b6bcedce00104b5e3e7aa488d16d09c9419b3c58685001421bcdcdc20062e3548dd70e81143181c9c68b88216150000881b6ac7d5e981c90e438c64e192b59f7a44e07186eccc17133332ec1aba0612235fa4685185d94e24ce3491e18c5a94263a84d84d3ce8931f3eb2667003856ac8a6915d20a64717acb118ca7cd93376806ca95135264a8d72ef78ec10e04401b91a0325e4c99a138979099b51840d5f566a1e600992034c4790afb1393c3e48116707355b7478128395b41461b45a984104d85a0c7276a000f2c4860f1d48ba1479128707cfd65690355a3b9098ed008747070d086288ac356072680305ad040a2e4dc2d8a80147899c227cde802468c264cc4a0e6590b81971f6a19064ca922142e03809d2c684561a1498304b98e4c06687b766876d6681c34406316084f8f2658699587821082a24438ad090a5e644106b80f08222c30d333748c3234cd3c30b674d5ac072068d0e9117998eb4af1b67dea8e932a22b4195cbd75a271065b26d88737c31c645583dbe3d38b28a7111548f2fc618bbc9222a52c4eebe41b3d68d9bc73f4b37664f863e2767a218c29c513833f33c22ced0c0d24d0d1c4432e833448c8800c10043d566ce72d04424c428c4b90715a0c9bd2900110539d33ad3218a5e7b56c313d190eb40672c9cdd78d28d6adc13fe555ab3ac01332b239a5aa39bf4106bc8f29a34529b524aa9d2b54e73e02caa3e8baa4fb1cdee6910ce928dd9d7323f59cc59e267c926cbe38a588326c566061b29363b9ed8f48022b2c126091b18b2d7b7066dc6962ad9ecd03f4b363d2e9ee19b75d61e280be41ac1b71cbe9f659b27f98631c6e2cc5d2bb6016b436593f859b621a36de46c9d1fa4fdd6ebdb919cc1dfa68fa8ca66d1c5b4379e9f659a1920ee6799a64a47fc59a639b293a6eb71651a227c843f4b35509ee7d93e355b267e966ab04010d4d9517306809fa51a2c5fcf8d8afeb334737adc8d8a297e966633f4dc48902041a2c7a73413c34d16277e96663e3cce6ff3fbdebe1d4915be7a6abe59777e6e21b3f138141f02ba6e10451901114519a1f1a25243d3c44a0d8d112b35ff59a2817af0675916a70c08b5322a6a6550d4ca70a05686835a190d6a65576a287e966536ca769ad2595429d2dded763b8cabcd741a00dfb7f43f7cbb31ea67a46b2bb53adaf588ddd65a9f1819ed8c88661035116146040d22a7b5126564b839738ce600cda13866bec8ccc0b9beefbdf7cd073fcb3354fefe2ccffcc0e5242fc1676a88ba6ece5c455937e31918a2dc9c6921cacd191e4e6e7269268d99312b381c1aae88331ceeececccec86eb41650ee4d8882dc847960324ab01e776ef55632b23d3579aeebd60ca64b995f172a30c9781722b73a5ac24f3fafcb3249bf2a41b8140d839555427edb573ce592b8cfabafab5c5bdf5ad935557bf7eb55043656988208208a3216ae08166082238d00c71e3bf9fe5103b3321ca6895917143e68ccc1632568e944132c496d9c5f7de2f7fc9b4fede92cc87bf40d59691d1e17702949ba8c4eb9a2a6a1022c50810000000c3170000200c0608244194244110835cf8011400095a924e543228a10444a130140c8581280a621808821004621004a3108603599e4379006f08f625a52f948835d9a91cf4e87e805b4d6f4df601d52d4ec33bcf3d2d3cb2ef4fa9b91f13e453a7286cfd7e8fdac537da566343a7491b1cc373e4b609d88932d64caf92684f9c1034e1d0a249b244afb01cd0faaf5e890543d89466a24a107bf452882f2f7655c21e63184f5a1211b5b7854fde71975188f7dfe82e7626de93b73ab7205a3e88db850b9ed2700fe052e8227d43892d0f9e0a890df5a8292dfcdd9c319a368becad0b221fe3d33c420a543c767b20ddfe5c764e092255a42feed35312f4bf3144d892cb770951a74d32648585e0da50e8ab43760ca2e7ce409b4da4706f4b8b06731862c939f45b5a5aa71b3e8867c6f5ac641db00cd6ce4e1b222e12dfebf302f45ee3e2d9ac0cc6ad6d7d4ab823b4b06a5fdef9ad22c8adee66d72d36d8ad786c782661414b245898c148db51440d011450f010ee8398131faff942ec5208f7e5ef2d1ccc21a262a20cb37a500841a3031097ad9f31483a2882124a7d18101198160045036a53e505710e7a3168e594c5dd7f64d1398afcdb0fdc23f5ba786357702997c9c5ddcd6d5dcffdded81ddeca7bbaf9bbbd6df7bfdf1bbb83b7724f377f376eeb7ef77b63eef0566e626a3f0e16c337fbaf1ffa39f18cee60f6c5246bbd2b22f01f85bfecebee5079eafebd571fff9aad298321a14848d670ec65890022d8cf7d4f62be8c0b3618661945fbb2a405c71d2c938fe25d95ba286e9d4f2331374906c68f5be2daa789e8528d054e053941107c14d5c678e05c3ead5a18ec07b3ec040230766313faa8069b20c3fa51d5e9eb27931cdba7796860e2f58cbbe8ecf560470f7310e3cdeb508a3d87de9a87aeca0e102834ab3e11b9296e0a3a9b298010e095f65f4ba53c2c2cf8600b69d2458dc159b07a96aba364a935308e1d0268d2e6f9bf189eb43cb4d61926a1c0073c3823cb6b7d376abd199cb3532de9876240c4c7401d9f8193c9b93ddd927f3807637c0cb07eb8e2639ddfd99c5bd22df986b29663626a20a30ec9ce7826e278953010f7f2300f5556f619473fcf97638470f9d64532c1b2e142876991e660667e5105037cfacab5670b835c418e009bd1fea3aadbc60b0118995b0b90fcd06d804e1eaa2005c4baa5e0ec0a7ea697e289f063f44252ae61e92d5069a44c3f3c0f2c192f8fa8edb0c10b20be72a73b5ef8c765af2c9941fc0a8db7d2d321d8214fe2c548ba653ec3cf7c25dba3ce1155eb54748f790bec9e87d2d11f41e83414c1a35d1a17c99e47ac3bac0a1b3757a0258a3aad9b1f0551b16ddf8498b0eb2715daee53d45e4772fb3dd9fee4368de2ea00fd45bf955bd2b4dca24bbd71975b113df686187fad43635358bf0fe976cb36f3cf86a3de28fc03cc35f141da38c9e6450a1f4081578f3f04301d68b7d5a2800960bb15471668714417bdb2039d7b2d2789f11ef588a2381ec7f122d7eebb1c3157087cf1e884ef48f14b7a032a4e607fb04706330273e0dabb033e68fa6725ebf0962426a4d04df6f55eab0db04f1c406dfefe849aba0c61ea22ffb307c79d75940ece2f8cea004b9826b80a72533d1a795a3244c3fcfe326120233d650a87a3b4900d8ee18e7b59a8f7ad35e513acafcdf96cc1a5283cea440c46a326f85bc4d489b05d0de1db35b54b76e4b31bc76b159c3f7ff51e1660e9e326cfea4e88e5e376b2152df47b7386967e694e57f1775a680f416f8bb63f83ae6219b423a1f5739e91e0f645fb4b84a2fba1039459fea0e70a618044bd52f66be2a7c6b2e2f8b9adf6b2a3fe8a3f2f3a7ed93d59eb3fa9eb137a246f69f18415f05ff76397fecb955367a248a54519099e6bbd81a0b21fa5270b0b85ff6e7d993e6f75b7f67aabd8f9ed41485f237278ade530d445bff18c75b85ff7fc2f9de27be68f78e665fae71601be0dccdb7ee91117f18fc46ee142690239f18177ad42eb53847210a930bff3a0d56d72547cd9fc03a30dbfb49dabf82fc7bed842ea0f92e9d0f90d41b320c2e329d4690cf682e8ae47866d63c0c00bcb07237ebe1a216ed20cd2e9570d3efa86ff968e2f962fa923e2b15671157ab70c8fdbaf07bb229e33c2d132922d035f529dfe292dfb8956c26c632bbc66fcb21e435e7409d3d27da04ed2aa043ab300a267fedcf7a96ee874bdf6ab1125ef22a33c8a36cdfaee5bc0305c94604e52f2a4da592a6a59c1f4ca2c583f0c87459c07c344b4a48de1dcfd77d0f08c464f42ae4e62002637cf83a0eccf104d644ec545c9582047d19b027738d00f2ed5510b93c27be604146f3d95e207f8dca8eed6cee43786779a57831fd86de207a99c683182ee11bb6e1acff97e521abdf913497f063ca2e616dddb6a2bfac013dc1a982ee576bf4565af01f4cefe7412c19ad9dd912fe737913110040c4de2d85ab80db42ccab34779d582a09e8522a70104c8d88d12751c020224d481dc7651f0bec65e745638835c539c06a90165d6def00526e1a641277fe3d17aad37c3229f345c2deee09107fd449ff066d17201a95e194cfcbed970359ecbd949f8a39a83fcebfc10b75d046603bbf8b83f6dade6e002116f63d82f71f9c3784abc1c3f2a252faeff43631d7818bfc486e057c117587713b4b5b11c6989e10ae4f565520ef49d5811721a5e2dc8033c90f31299b78b83721a3a39dff6dd94a441374635b66b3ca41fa23fc105447415c0e561e45bc2755ea714402b7e2e1bb4dd55a6866781b6dcf21d705221bc764621fdc95844111d660191010ae80eb3170c3a47aefae9de817d421010892f9af0af0086fe30884891fce2f9f14f4f8cea0edc00bc96bf4a3e32704131b6aba03055e1135c25687890a19cca4b8b63f20e7842048daa4534863b80e3d39a73c03d12f49e8f265262a256f36651730e8c4872ff782a1200097d92203e24e1156ff35937922443dfac89d4b6ec80164959c4373830417aaf5db1ad5df4b2561695b89b5dae157857c1f0b69635107800919e869959546152853edc074579282773d03043e8f9ae5d1e5f4163700e5441bb6fe4c9de9a663dd70d03e7b0915db4a6fa5c582c71db6b0a0948c4ab3b4bdf01d249a5cb5b38dec3da6f88c9e2186f95c3ad0425ffece3e04e380fcc166865285e67d20f4c6e4c4addf7c05fc1061f13841a2982ea494a8354d27827790d5589d111516ae393bd6087192577c8d57dc9969cb9825debdfdb12fe70b5134ea01b85b7f14ac0bdacc11adfefd5baa661de989898fc06e6592c00e29700e0b32ed9bde950fc166dda832ad7ba4331239a281e25a61337fd5feb61900e036470920aca9e2d67c2aad8cf4727f4e613dd3f02c7f802c19318df719d543fe6d3517ac181a6a347b4ebb2f9507367149ff3895d96740aedadbdbd2f44066c564a8036f731457f571b4c0fc706b476c29b772ab2aba1e8f62f9d43a716fc497b602f17cb4708555721f80ca5a46a001f17dde0fdb01c7b771e1f02d3cb73b833f601f8d5d108c43fc9479017dcf36f242a7c4ff8639b13585c9cff49e3d24fab2e47253d7f39cc9a57ad2546d5c53fc6f9516a2b14f1c31f832dee4196f1edc98d6402c949e3a1e7cee8bde2880bce3a582f209ff609c7f1e285ba2c60c6886b82d9b8558c6120451aeb7bc254adc7afa8ea87ac48a52f2b949173130f1eb32d208a10671872194d3cfd8d79fec66015f1ac3f384426c6396eb9eef3144e459c539b68e9fe79d8f0295c504e78d58a5e0377d513000b0d28dc92b67c765a906168544ce77bcdc3b5ccf06758c27c1641103c5b86f0f5483424d44cf614894a71e02801eb2fa757bbd5c0a661d40047c8752ad9087c3aa2e42ea5990d41a63efe3f40e15f44b2258e3adca0c7beb74b35873a70395eebb7b138ceef7e8c02f9e26536f1c4ee7234bf51034ce338f65c04fdc1c57f08f0a72a884b225e09833430f5d2565566edbf0f28f8d7a16097e31711f9859e7c9815c63f17e6f5e4c8b3ba1ffa74e64f602ce27fd408967b8d11264c8b0f283fbcaf3a4751981e45d2ede514808974f1599df6516e71ad2c8a0ede32a0350d1abdd6d238d537594124f384f6dc7bad8172ea026a376b5d4ce47b144f6b861249c80af9949c9807850ac769d6c7d57bb00960185c899fb79acd3dcd896756d5842fbd2937c437d3413d517f06d79df13d9d0a82a310577f76115cb7ce8f183a0488c29acfbb2270c5dbb873d63e651fc08a0a2ea50b9300430fa204f4d527c93bc13a78f8b181254304aec9919c15a1b27cf16e80fb954c301857b01e7f438effe7bd7d9f1d9b77dc9d3fe6ff58269d59e5df21f3bcf57f2cdbc4cc43bba61feaec9b6e5e360ecd3baec94f689ca7ff694bae5b1042127e91897e3842438bfb517b16cb48c9194b7d7785cd6354bc336d879323a2355751bf1d66eff21d7393752a040f2103d5635c1a8ae0c790ac8de30878b64ef22a5bbdc5fe652e9668de6c7744b258d21e2e7e9bcd199effd4858c2956fb182175e66c579809dc0b0abeac765d1b637818b6f4f32510c672220788b7a25b4e2bdd2e430f69d893881d4ca51d274e36514a3550436939f2a9c0bd90ec3c53fc63664a4c3038714a5ef0667cbf5b318b15ca28eca3c3c5cf206da3273f211cbf2e9f8dbf5bfc651ef5021145594a72cda05965ba0d5800692a8b220f104db55839af75c0ceaf16f4d499025f029762a8276271c3413a21ced80f784aed850c286ed166c69744c0bec04b0088202dd3f3cbe6a7ddab11bd9e4919eb08510d48d32638a3c97d01eccf7aff0d902d7935616a35392fd9ff1ff6c3d0b05bc362c63d466f0f087015abe01b838d07bb5ccda1a6c653a6d3d912098b8414c63a9bc263260a889259724a895f4623008181bee3bb060e97fb40e9a1c45f92876d28281e855352949800f2f41410638338aed668bff597401d05a4b7132d88b4494adea600b8e511fa8103bc62143fffc39ba50b69a32f1811fd4f05c3fb3f45e312e8aa374494acbdd5ebed202d3e5ad841e35568e081091c1ecca26a4fe73c74c644301117a3faf662b3dd8dd49055d05b1691958eef1a7cb3e95455d8712745743d274070b67654a0f242ba1e3c5b7d94333aeb1886256290e8b0383326fac8cf4d4f6855316046979c9c705c4f6d8f85dcae983952f8a5a37466220985a8db6c9c79c81308fb1603f8afa5f631d01bb6b1ed0910498fe369f44cfad48fa7338dbecfff4aacf5b4af05bb3ab2bd779c46c139175c39b00d03844580f37bbd0c3974170a42ff3a77781003b754ffcd2c21e82f7461f0522396e0d3592ed83ab75a7ddabd88ed66f08e5b48c6124963897a829c8792771e13b8ae9eb53f7d2d3b05188705678a5f4a432cb55a7674f5cf23d34994b377aea71cb9c5b570cdb2c60fd22103c79908875410eda70aa732f0b9f997feb18761c70c9362f0d8ba5294b580f534d3925f35b0e7d3d9a1250d7f05830894ef2e45d06db64355b1fe17b0a388429ad61e864c93b72a1ee94bb5c48c02941a578ef17a81c0c965375f333dce1d7af1b58a1899265dfd8d866268ed80ddb500f320475d38a06459d4879be976e8fda7f657846a8e822293dedb4e89a93c7a965e48e21b58df6d4f019480120112204db01082eadea8d3587279845f21e9fca1ff6ce0425adda94afe106f2b3089ef95e088eff329b3d69b1e68ae5c78836af78e2af38f7bf3cebbffc7ec138bb4cba69fb5fc3354438a394d721b5b2bb9218d98409ca79adeb7a8ad271abdc95e036a34de06410d5187e480ef7719a17902fdcc970e27903b58d10171efdb31067d98f72605021ca9ba6fe8316d59588e410edc4e21a5fd58687113823b94f49b6f8e67d06391640dde45ece52890794aeef96927d9c6f826c584b880d8b25c0702b888558a8896dbad6135035c70c2826bdce0f8aaee34beba7df23a229628c9487c9b814fbb34384bc14e0f9d1a8b25519c376017ea0522201a9002ec2f0ba8b1d98903c7ce8387106e0485fc0bf9a25dc0c3028ee35e65d53e7a0348892393e599761292b3b4589d231998ce01d7d70813711dd4e8543bdd9c631aa84d51462dd4c85dece81a6baf4791c0f0c74fd7673827b6e8068f4313b96f4006b7061fbd7e7bba679b3c6cf1a3984d9d318b2faeadc4db92dbda621a0f8fec3b8887fb4332ab5dc64aac7d0e9521cd3a3370c6867b3cc5846a21a1649a76734af2ba22a2852ce15b0ab53b6022d3f6f5c2c5d52f6d20299302e737ab6aa4f788b785c19fdf6284ab9bdec3d55ca22c9039e83a809b2cae9ca098013dbf489fc3b7e8a3fd68ad92a2a47ba26e478d49f9c55c0427a9e2bc970e8c80465b30ae794be41c338289ab6102a4d108059e03500fc88a65b5307f4efff528134fc3bf3ed0b3f6dda14faa9a5218e194d6d2beeef229795c8534313b9be8a29e56f3d0363cef8814a31a13b873615f56cc4c4ca0cca8013ea56a1632e52de396aa9dab565b15538221aeabdd3094e22f9554fb6d84e3e2d39fbefd30adc835b8d0b9b7b96ac0ae194b4e2612a466f1078bcc59e50bf17330882382284735daf404e55a5e710cb2f92e8e21269efacbfc9171798ed1a39ad5bc23a59613ede5be283750d64b3eb62cc2b49e8201a62a2a3f255668d4f75585913144c832becdccf64a1dba7494d94716e6f695e73185f0529457e7c967493cfa6fb365c50df115c33aef0eee52c07ffe50384a208a9662347cce083e28c48bd4ba36a9f185f4ef91a3bd85fbf97b6e1c96b10f9f59ce03468035899bd61f9753503a4d74105935ea8c2cbd206ddb97d5a1fc1f4d4558041f427a0c8219aef47a1e05109dceb79e3eccf4090d4520f599ed31346247c5aee8e09fcfdf8b4d84cbce98bf32def5a5c2c455c672ce30c1f31f2d3fdc21e5be3bd85555052d991f125e4509826ab9ff190ed51c7b959d636456f20111a569fa29075d44c58df552227a5bc2815abbca36f535b5ef380d14ac95826688542774e5b7bdd7f8675e6a0e4e9ba85368164a4f508023811c835df08c85fdf908c4f5f5c099ea6225c7a1380914a33c65c5287e392993afc3eab4a91baf82c4947ce631d09648998f534f2d2780d4f4e8b2464cdabdc7a5ad5995735a44b080ab6b82ddab0f4f36466665929a9ff34565ff06159becd0f696d7ac246c750e36d7a6f7854b9df58ca295dad97a2066af1ca4c706b341b8cd5d90c5c5dd3f85042707b66e47405c19ec9a37a7e9fce015207a761c932f11cc6aad441341f29dd6b6833d490d4c6437cd36947fabf40cf55ca5888498d774033adab5d92e766807896948cb1dd4029d3278370a24e8e28c8884117195254238d531f6ddf04d634f8239745707938c581eb95658582266563928be82482a1f22c86c4994a14c3c12a01d70d827703e090b0caabe13f34cee6e1bf6ce3747ed3835589e7b1a0e4d0207e3bf03baee1a4f88b1cd9b9f229ba0f47be70e85258a6759d36da31e27c1f017480295217f2a5f6af7b026246696c99a7f8bf49122ceaed3c258514ee00fba085f6a2bee10d69f2574c27be352b5389b1f7e1232c055d8fc5ecba40e36785dba784f59696f39dfaeb18fe6e738f2896b3849a3122cf36292fb9ffa108ee0a140b0a5ed177c06939de4ef1db3b6708707d16b094ef7ec3059a454d8d443da37d1ab0fee2bf4c0cd2c31cc6a667840df26d690dc65c78e14d956605ba29beef803b87e2bd550e101b0706cacf77832b56674d5bc429d5b9fea85a919e12f74d64ab2851f54821b9f84789b187dafcd813a4d73f9bb7a869ae048d031eacb48bee13485b910d88268bf068d753ed9b9bf62d2d2bbe9229186e82b3a24a3aa10cdf4045484ba4fd0b0c96119535c5835fbe17d821fa3e76e016d5a67755f9cf9d98010b50c95ebda505f2754c3ee2d7b38bc398dfa81e9d4b0dbb3a38c0cf2659db4ac786a216fabb604639ca7833e7d39011c742a12c7dee8cc14a3faf8b43d2a29a69c6bc3e1eeba9ac3469e4dc672b360dab155c84db6df08ef16b263f2ef264bc56092583431252e1bcd0c7e4b8b689535d6cfebadd0eb04998ab505d93e3c2713d4f74ba7fa12f429b674c3f3fd2b11369df79667840c09d0c53259edb1b9e99ed7c9da418b9ce3346b03b80d8d5ed68d36745c12339eb03bfa0f9f47581dcc67393091525429b08842a16d53c57211e606cfc9d2c64923932bb2560885f8ed8149b09ffc2837ac7f654ea49ea2a03fc457fa3c98e78cb4113763aa6cf85a6559f4842269fa96b19026a33e0a93f7fc4f42405eaae74f2f9b3de7582af42db3ad747c5ee6a72b28e36ad50bdb5ce98d2f9043b6e42de9954e15c8f4f1686ee2652273b9ec7527b800e4b2279dc242d4c653b7b8934d6bad3cb56fedfe5ff560f2328160d4ea4f30704026f3974125939392d595cc7624476ae9f66ee1997cf0d3e395e67d5baa43af7dbf596bb3380341314081a3d82a0726006ccc1f4c5ab85f70585d7eb402f2a13535776807fde8cec59141882cb347633c198cd31e6a60664c4e749f18443fcfcdbedd0e52c4d1276440c47d8ab9dfba245bce3681f83f552db95d4e9e95883d007032b2638ac1cc972e6a796f4852c5f3b69b7eaa6ebb26ca62b54bb181533fd6ee5ad331cdb711227589ad63b43254284f79fe478acdef813cd26b0f86b3b093325f2412e1bf68589c401080d833fb97113e741d0e427dda0af9721742e2ee89badd512d9effdb9cf8bbccc1db77103974f07ac4512ff07e39473de93d8593be55cdf78c88fc91575aca8e387dd5c46f152ea3fd14ca040e65e1d7e48e74716ec3a4df6ea7604b5dba0eabf15017cf221eb846a7e9545953906e3d868f366017f08f76d53dbdc550363c6ac6f57e19cb34d19acaa6e8adf510967a1ecfcfc00bfa2667a78103d3be1fccef7d0a61a66ebe4294c7563633f99eb50c38c4dee1f1fb9558e67478e072efbc257a454a716cb1fb7bb1b9905c2c55a9ce7e0f0110fd853793a1c8082feed4e65462e3b9e49eec511e0da82171b0baec5ec8073600c5abec0d3e1d482a71f73c42cfafa8f1dd0d63fa3ed483dc1b8a87698eee95e6b9323dbdb1f2bbde05f48d0d9c7e4e596e30da07422f458b3cdb8827b41d9c9d3089bd1cf1e9dcfa429c6dd5c2f8fe5f20d151761a73267e07ae3df15aa6ec951b0f65d69db94139fb9c76ac6ca00db0893dc880b8fe81e8e1f900787f90596aa97dd72acdcb00ef67438046e38096398c53349fb95a6919efac8d03d14c41b183205d5568cf86f7e36ad2ae17ebdd3abe6ddb00ab775047d3cc8807c21cff016025ff9f145ea3b2352e975cddd8bae00f08a0c123ec9cf2f31ac75f45d30ffcf9b5d65d7e7e338ff5f400e80b71ba45eda3f60be08d71c484c8268b26ebeef92ffb3baeccbbdbe0355bd5fab1220f29c08eaa40c96a8aeb53fcdf4ac84585dc372e95eb1e6060ab8c6730b4ec04d05690966679167e79862304a8fb717f4d05432a9ab6082f7d35e8646cdb3eb69a31bba7868870b7871ed44826d4fe400f1c5c43537f80173a49a1088f8abdbf171f16e41368d3dfbb8c7b1cce0a85232440e33dbae5f61fd7ddd17ebaafef2e5e06617880c0054e000b2030fbb5ba4a02073aca13eab276c1e874c376e2a2b76dc7d4923d6905b65245297165d41a55e95c30e623c0b2d8815b5c9986bcd801706f6b9261fa9b0d26c1ccdb8e283639600a9d283cc8e4bbc4b9564ef7df332bc4f9905797a26e05e5cd7af38fd655260c32ff83a26ef1746433d23dc61259ec835af1322767f06703f2e6548d858321e4ac4939f8c2c77bba97c91677b3607b231d0c774fcaeb9394dfdf96c9a899341421c90f4e14758c8a9a048d125aff20669fed7b0d474bd44caf74b52a336a671c493db06c7c92a8c1f379fbe2a8382bfac44d244fec0e84cc0d61a7c30798093b78c538158017f884aa3347092aa17ea04a0e3151fc40fa48543b01e00b85d8a71f6aefba7a299a49827fbe147f9ade3a0f052cec21a0b5de196599f4fda1f050e6633fbf267be3c63d997e12c00f9c84e322d22c6b94a226a31dff4823267a748cc81eb9ed25589685e524f629c5c69ea8a3fde99e60f68bc92739b5c6e76c6dc1adb3bbd7ecab4897e753241a8098f1c2b97dba8bdb0adca96f9ea5e608509c4d44dfcb60eb73f40254aa577c1bcec7eb270f9d07b4e5dde04b9cfb41df49120dac2efeddf431725c44bcabc887a98bc5d5bfb7e873e442bb1dee089a00b955970bcec608d2851637fa5d0c11c88b5727c11fd2becd04cbd493c666b77eef24949390b5df72ce0fadc30eccd3027f67a2363fecbd4285becabbba57688e361fc1822ab6d1046d67ec5c44ee785a1eeac309296fcfe39b33c275e7e502372bea67d7e4b8899a573198e0194ff835b19bdfc91ed42687dff87fcce6997338d735b1c019194e72f9efc8aa4a2141f45371790d2a6a4c9b5b9dfddd693f556cf28ebf758ea235268d712fd9a9f1ee0e7efbc51f7ea49e15ff3cc3a138c00ddd0559e6c9d93f649937516b4d630667a2fdc345c1bb1c1d218e5bb96f924271bfc2c359e6089f136c68330eec2d46c3afdea2ef18aaf9c35f5b12281635f88c8a6ba24b62dba60682027f826b3117365b3ac7b37da680a707a9f955f98fa417fdb1589e36a471c4b7c7f66f9cf73a619885618466a4db06782bacf095a564ee030959ea4a0c4e18f861e0a61c657c2afa8ee3a97b98e67bcca8bff16d76769cfddc16d37d163f74691e65e79b790ba4d3624cd1f3afa601b50cd72a52067077d31a24145638b9269ffae4ff9564d2388d3f63f917a95d3407850b3cc464737060a4bc6bd79937ce2498fc21a0f56963bcc95b34e578621b9246604a6eab683367bde78ecb4edb56aff1e3f11b71cc3d5bc75279babf9bf726c96ee469eb290793d075066e2142fe4d03c09f9e4da606077404f91b0382baebe1513a7c9e78fbdc9fe4d53bdd50ba2e3d8e2ad7039e61d23928247b29ed788c7fbbbf2748197c4dd173c5576c6443d630ba44f702429924ff2751666fe2d34e266eb3234fe3e9714c66aa2bfc16cd54bf02b827a6f16e41a67bb87c8a87ffe9233faaf8c79274eb1ba74fe85fbeb8c2619975e415e60df508bfe7e8c8f4cc26e34f0367aa1070505f414fd9897f828378f7993f380e0f7b2d672dd2fc5df4cf200607f63d5a4b0caf05a001a9932a53b00a8370802fa03830a95e4ce2578f304746103c5d9b605f0d6bc60793165b214dc65e507c31dee160af1f207ca541d98cc67776368152f50ca6fb84ab326283d00f220a93e7c931e615feff41bdc56f73a73be4ee12531407f25887fbe693b0a4b6aab279ee25858e139838c1ab0404cd9407597d45c833aefaa2771760946c16f1e3879a9b4f29dd8c95d8e713f11a3a49406bbd7d6d828e0bfc98bd62cf1d1bf8e36c4725fe19941dc9937e89e32f0cdba3b8946c7da54063260ed9df879c827c92a529796c412ab0c889999c50729d28f042e0112978e7811e2a5c42fffec9c68668d577d89fb78229fdd5d97238cb33259b33c700f8ca52a25209ec3e10c742618e219105eb9bb6735cf6f1fddbab1bfd0c8b05c6e9484ce5599a819779a6b81c386730a87e39ff12023df3427bb02522f80456bb8e2c7bb6d948b8810d8a80acba3a34ccfeff4e31bd1c2671b0e555abbe6b498deb0a0d7d07ea096fef8ce84e4986eb8b7004141642c85faae28193616c2fe7b76b9de48db86600b8981c5f6ef747df083382c2f47aef577cb4346547b7f43ac0f41a7372332f2f3234289daea64c95c769769895c7340c38596cc9f5e31bdb5526d9bb24917b5ce6d354c4186632a9d6299e0c8618b5a2fe36eec5e37f2801fd6d84e7ca462385a1ac58f486fc1c9d1832ebbbadc41a3fd0f82503eccf798388548c348210cf69f4dabcb6f3e70c332acdf7a5b54a022e98a81fadca535bc7440f4a6e2aa361d68e3cfc733f679cfb2120f07f63cdadf67f5bf748a71d19d664e555f76a3c7e4614c97555f232439625ab73c0d8feab4f534fa91354acc90dccfa886b3e71e3454a0ad183c0a486c219122dad0c7488d17c88f88f53d65ceab9834eaf8166a982539b69b8bb82bf0c3b30e9a2e61ca91202752277e207319a35691a4f347bf1d6fc56190a3e43cb59e447c41e2aaa2054d3fffcff323a42789e3f6218a4c4162bd1e574121b69294acb375c5da3b70b8b010bd8a629ae64054ed83d63802813bc8af9782146efca9565d7d32ef466cce972964afc1b6e1190708292ed48ba12085844f6b3a9d5a31b0b2641271378b5e5d216568db0e19c735932d15ddf7ec63e91a59de4e3797dcc628ddbbffa20af29563e64e78313e4f2656c6f57ac414730df464ff451e603e5bd2d2b8bc6ba62eb3b2e1e710f20faf2a0c232f4f4c2053dafdb14bd6e4fac6b212e81d23f510a4755e8dab7e8f543303a1494be1ed505b366f28eb0a93c476f02605e0ca082c928a91057112c11d02a602c7a37623cbd4d599da03434f1884fba8701b9323c642f0dcf983e39b5f682e014eca3ab06d1734aeb415a714dca15188dd88b473b5b06c985cc481f4e96ffc4d54f1774d75ffa9a7d58fa7bc53d5bc7fc4e465a9d8e105900ad074a46ad711521a3d4d5bf278acea9a887ef789d962b17d91dc082783d0314f67e4952dc5e0cd507af0d98cc92ad91f6e2d1b14b395c70f22494713ae3cb38ed9e6028e859bb379fddde512295d8220cd7d16968dc3d7db1e81f6575a7a63988839cca6ad3857f1198b2054c4a775f756d2c3fd60b922ab2b34fd3065cb487ca5b0f19a0ec198a45fb2b4b9efaf8dc82a260a741c148f22acb2aa7b6ef0909eed5f7292bdba20195ed81014e2582511b88c7c30b7a0334216555d712149fa73c7cf034a6363c3fe1e18687ccc22fa64160ea2165933a4a7a09033a2a4f71945ac18e70aa68be25493f37e19d9e2adbda64a9b3db6314c47461ef63c69d024d5d1c9bf5ed32a350ef6787b722bd483e131a1eee097f49508e45fc519b2c0780bc95f0caab77379de21097aeab9e2cfc5720f47fca642370e17de94b0830632b1ad3a28c98c76776a019d3708d0a6cf276777330385716cc014e04894fdf4c0b52cee7d30bda21a1dd22d4756847447b57975ad120205f30ccc1900a5a0b9b439e46428b168c2c05350ee1c4061e7c4de9284aaca9b0e2ad5f19fa3314c26ee93a79b560a91645ed7a6774a2af802865dcd6eb6ed4621f96ede841c6434803764c3bcd27cbf92ff7ea5b76d77a40246c274cd83f37d7f3ed70481a387e1fd6deb790004dea14dcb062f3f5975943ea801e12887f364a76a8a0ece689b2c1d589ad60fbf6b1e3105bcf3b111cbfa39f6b01af73e4cc51f2162631e79202452c805423938ff5c1685e26ba5e0882f6d9e1eff0c465a5f571f3a181a20dcaacb49078dfdb9bc9aaf63d25d46c9cc683c352e40d1e19a929bccdc4a6b5125d2a7929477d57756cbdc1e9a3e72655b5029aede61c395a29f566ee33bbe66b0217b04c2597e4cd0218b436abbbe6d024238d08e4cecda778d6e3e50a5754689d3bb4aa8668f1bfa0a101dcec9edbeb730c6dbc1e83264ab96b6ee75f7ca748c876f72e3bb75f053c879497bde09092dd653237a79515b4d856563482a13e969ccc9d37a8627d7227fa78a7f8a17939bf92574aede9e7658a80dae2439228f95b2e3e2d26e29583da6b80d3cdd3d23f025729a2322dcea557d531583ba9112dc0e061bda12a9dc07b420d6f7d9ed44e0f2eb8eef8fe34a96180e4ff7a3d51a365a2cdf8add5a7569f0e01a2398c1413d3bce43134b0a43db1dc09133ca6b7b4813b7bbe553aee80265f375a0e8b0219bc710255e9c52199b9de6547aa4da874aea2d5ed1552e3cd13102ec625861fd9c0d25c9b7908440c582613b4a061d8b19611b0b25eb7f1623a2584ee9f5a64fb9165047756f7edfdefb841b41844546f918e694e2c46b278f30801e370da56434239909ede42d6f5b61276759949c9f9ba347ac972de480de83d49d55b2c10749f41da528f1750508b263a956a5d3d3b35417881bd9044a97dbca8c956d3719e38f34a9767082a2eb3a299381ee90cb65485f76c76848bf3f47ba156fb9f9f2f0c869f163b54f84583fc84e74c1df5f0e5c708afaf324d24dc20ab3f8d0516f30df92f869c4a4100e318abba7540d5ca3bac2424cca56c053f0a5837810712f9462fa8ae765a5139f4005d0b460f318aabff72a651fd6b4700946804265eac12461b7703386c04fc3e4904925df87d8d7e35e9bebd192d8fc1c04854d81f9b94d4c3d2196e4498f85067fb1f97fe7030262991fbefd912909e6041cb7def18c7e8ae85aece40418ccee42cb1f1843327d60f1ff419316584a2a67771480e89334cbd1a6b33fafe419f10d55dc34c597003f2ba75043be6a725f83aed41ca91c8d709fe780145f4201a76a54bda0cbd22030350e89a3116da16a6a6ea7b763eee767206d057dd10216c39bc1a51dba4d007b23dbf2cd6325c8ad3aa82d6cae6a5287806447dc143273f500998b85400cc27b350c27c262e0e38f0a50033e5e4a9cc95587d6098fb1d2bcc104df3f1f5e8989c8dae1a48540532045e742987591e2bad48df05036d30f35ef3aee01c10d983dbeaa944ce5f3406a141ed59d5fcb1561397129c48323a965dcabd89127ee444b01ecc83aef5a2466dd2fdc4b59a5ca3abe50477f42bd881bb9abef562a7761f9eab54c04f6af33eeef4bf240d158b0488c4c19376ddad59c4c01e8d59bb022824539e7a00c67a8ebc97a3aa9f582c3ddfede0fb47db07f297a6340f0a8e9651bf416fd3ccabfc12f69ffa81ab0cb04817cb566ea7c6f2e98109d278cc6552492bbc8b6aa67b885e9f38694f970f7504cc35091f20a97ec324b8e912aa3af3d03701c0137826aac74c548dd55a05c75323a0f950efd6d29717d2ee7414725c5da0660791248fee222cd0b0c02dfb61597e0ee9e51b809586e01c1390c60564554f1b9d0f1ac86a74fa59834d0ccbf386a0cc6cf644fd97b4e795990e53a5cca75f7a86dff1ef33b8deb8be9290a7da49805921d3ad50db89d1a7b3ad1c7ae03e2ce9642f69993c144cd8e5965c9ada5c5360098dcb008d84bfb33e10002b73616e34cfc076ec826d8cc02879b42f6fc94e501723797dbb816627ad5c48f7e352794feda0cf77fc1c65e4dd6e4010efa061c09d56e7ed6e8e114676b50a14abbad14cf2a664127b9199d42c543e5ef4692b9ff5821da9f9b6891bc74880d07a0953d504ea3b5d27fcf6d062d1ecd58f495a60458a4061ee440dfb8713b34cb5065eb18392851c69c52420a5b0615ec80c0ad1e54b7297504273aae6a4c434b2b83ebca82f80870862959315e11292a5a8414c99d6b1bdbc7ae66ac0468a39ac90342357159307b1580b2883b6ff98b4e0caf6f8816f94e94a0390493629de113ee80cc56670866aba0ff70c43057b0921eaaa3a313cd090d8862b60ac688c16f2731051c1844eaa168335b6e884fbe093f1ddc0c707b714d750aa4909a91523a8cd9504a2e3a20c0bbffb753ba4212cbd3c3e0e0ebdb6a6be818a149e114c5fbaa9831ed830d80196a00c4be9ab8d4e2f3c75266288936cfd0b27fe1adfcf500f4d2cd736165e80b765598297a57f28ae75e54480c96d3b4a39206f9f900f993909c28697b553601a150d33fd921d36425483618e00d07b953ca7a5eec7b9e0cbf187b6be811a159d0d30bf94e3e03f209d3066dabc90a71c92ab37bf6c8b1726ebf32adaa58b8a9ec1ae9d3b0d5df3a504f2df55f72c2c4c7d24405b55f81430a339b74e40e4ba5adb599ac60b1934a785ddd2b7a8140896571ad23c2038464c8f087d4d3c81902a14b282695f3027ca72add8388c5d21b8257243d666eee44ddb1b36afb76c05361bbba9087ec58f3a9f5a993fe467d2b8fd674a66cf05264c09a52ed99342145c9615b3b6e2eb85a6e2ef96fbff37f0286fe2189325627e8d9338f4805d089edf52626d7be864964406fbd39ac2ba5e3125592a7a338d4a5808e9b3961de474701222ed554ad18bea31b4286b9d2f2f2a19e34f0f71ce6136cfa5849f05032660014660e830cd012dc1445ffe19ff4c158de1216496446ded1793c296578baebe6c4d2e07faf117cb0a52250589914f2da356311186b53bb6bc2a36f2e43cdbec8114489f9e1e128f0eaeed7b59a531fd45e91f423b7a26e3960ce64cdff14e48898f806366b1ffb6a00468e6095034103464d86b589ff2bca59d92467f245fdfc69b034df08ef5f56445abd9f50cbdc19e80f0e55c6dcfc6d19ac5bb598e5183ec69d7767f5666599eb295c1ac3bdf2e735d86f094955746592928aad4b2ef59cf815107248a3cb00d62141aaae8f9c3a84322e25f1802030ad5114f6b4c7f20ae4d70e1ca57b2725e2ea060e5a49fca82bad1a209e6508bbfe56607cd1ea35ceba58d02c45c036ab4ae8e5710400b398d01e149323e741ce94282775c1cbe664cd0cf78bc3d3e3038041707c220e96dc40f08e2196ce00e3a9c734bb965461c169cfc91795d7063c9ad56944c24484b530c129166c027bda4edbdf7de7b4b29a59401be0976083808ac9353cd9e9740ed11037f37087ed23e38a1f688859f341d4faa3d62e2ef1663e2276d76729eb1573e727cdea8f6b0f7d159a07a778e3c69201557b7b97570cbac0320ffb02ecb3f9975200bde9083fcf31d1dd6330e1c30182c76e3062c0683e1c071a29a33396e1c7ae7ac4c26dd9df31da24a61e10db7cf5d2e3dabcc759ac970bb7c5cb7d9e7f52a16b9ceba158b62076db893797ec5a29d83532c729da8c6ec9c7356ba52d9f890509c89e26c0bc5ccfa4c0c75e48c0306c3913fc5a29c43aa830bc3ccba8ed0d20c7e9073ce3860301c19fc3399e40330b3fe41fef9160efe65d669fe60b00ff67ddf7798e5e0cbac73907f7e7078457b9bb778f0d3e79c33ec200c070c8623e74c2679107a99750fb2d65cb805688bec9e58c4fd070cc5a22d003828166dffb1c71d2091615907aa1067d63bc0f63f99836fc9b1bacdb1caace7c85ae726a918ece02a1c6b0f1c27ed66c57cceb3a393734a4feb653528ca681f168002a954e32880cdadb3f278904e4ac18f7aad95ea8626996c1bda27cf99e78c757bbef29c2e9d3d653cf94746ea107aed613faeb85015ce5d69f5e34f0d975e6350e0ac330093a513b0b4e795bccc4f9a5417327016c648bffa9cb3e452250a971780a85d239aea140e58a26d57e2eec46927416c192597a62d658ce145470f863e51b1b0ac3d4b2c2eb858cec04e9b0cdc0e9d6a082f54e28b022c431688aa3d4b1cc850b5b09a325e61853eb488c81197d031b353f278d153e61003570e3678814eb0a8180d3e586cf070830b8e4d887360f297847e224727c50f7705076b3ad8ba0000f8464606101a1ee810e703271d51661b0c415c0d3bbe1c84b804a0fb22002ecc00c6f0d89e00c14c8f2a7c64f183734300170c6d6200c16414603bc30059d608c1298814224e866d032dcb01b61f10e079293242842d09214c8c5066081509e0b020c28502362f16805fc0806d8c226518d9c106475c20817bd28028231a1cb0617980c743095d906c4440e00813c444800909909980190aa0a9c01516d0e2026d30f045065ea0013cc606c8e0001a1de021ce094e1e8842c2705443920d870ff48002e60202292525588204d298149e4832130215a8508a60e362052f580869ee61043d8841821ed4e8818cae5645ca55f2a20564e28416319b3e5c4ac3e446dcb3d402a7052d3770e173d2c483a1e9b3c1c9d3f224e5c40828259e744f4091224a29650553c0a062c60b3eac11e504860f86186e90c1d352456a06303424514315ae89ce4a1457bc2a6cd8e2062fb0747b963f8081c30f64e4f0031a3a401967a9c5cd9ee50f37e8b2dc273b6c5378d8828593a187eb458b962a5f36a53ed8227eb8466ca94870b967800869a64fc6596e11b3c970d72d68367d1844b9e58a2e21cd5bd4d02e34080a04e542b7d01fa80f540bed81f24077a059a80e34078a03c5426fa036d02bd40aad81d24067a055a80c34060a038da22f502a740a9542a35028f40985a24ee81375a24db4097581b64099969828d5483002165610810a21484a0169891210a0f0812447a4074ee8000736a0810c60e00216a800052620810898000124253cc001460d20e18891220c588002882460c80842442842c001689b284808062800902102fcf0d103041e03104000847604cd747ce001908c7ae1e1059c75f686da4a3fc51e33d35d457a2a7a818728b168993f188b0ba071e88efa5b430a640b412eecb20a75c80debcc8bf16e3224aa219e43ddab8cdcce11118990606fc799c443ee3eda6e0f762156a1ee6e88bdd4aa30d64becee463bd61280d4623dafee7acc5927903a91e81eaaefe69c75d634f0efbd07f1ad9a5cdad75e9188266dfd148be6d0b5b4d2004e2a83fd5662a9b2377c70ac3db66bbf7dd364bd1e527f74496ae935d3e6c7062a6e6c90e2829b2b6b5ca141b7512d464bc616639581b5026705576220b45d79c10ee32fe3eaf1c5f89663b86779858b2cae5841668a1d5dae33ee4721acd4cba8ac041ab88ce5952c54289c999a2b51b212ae4071569e5869e25aa8426f996ddb368ee3b819a2700933581967e08267909a82c50c59f00c3e34c1a2099e5d51420d6f3a2c35c0296ba001951916698466694a19d29431b86056451a5f182a2aba1b64f8029732bc6046c5ce9e659518ca2a4d68b629a680e14dd40da228226c6226862e3786219a988941871007331886336270010733314811c312294881d099281bb80045d40c9e405146a9894243e687bc67f608c65946899965d4112fa0a1d2c5940b9a28f1829b5bbef0c54c89d59e651497282d4d4b44e5f0b4448e3dcb176cb0c73dcb17c0a863c488f91123342ba2a4c2460b9b4549c58a8dca1927a0d4134ebe259c7861ba22382fdb0f984a96a74bc586272a559ea85079a2d2c2940e0d318a31a24c61c113a9295c40494db1028a14b76739e54c9d22834ba3a9062e70cad2a40627dc7456baf8c270b20418181833c41a6160d0c50c42d4104319058fb809d700d54df9d24319a58c32ca9319988e8627700aa6e012b426103540e9f095529e3c990921658d2dee594ea161fb01bc1dbdb7c746ea78fa88fb778bf591fd7634bf4ca4de9b9b7ea9a3f489d9974a67523321b66a032f332f5e84bc04f113a5890da0b0186f9cbc3650d438e902a58aa72e50cc38e952425162df3d4b284868f9d12234fb014a540950ac64114b285252663ef4f024ea095409e504ca05a129a2c062b6eb02ca666bc289a7c56dc249699b70c255819b70e2546736a431830e0a0264bc18a18316694c896206275f6ca5131840cd6ed061fcf62c9d14b1c96719597b964e76d8e438db611cf72c9dc0d093c6c66620b15a40fdbcaec92c90fdb474d746210b641f8b19e14ec2a43560d2b8739ac802d96fd6dace02cd1891796d2fa5df178469f12908f668fede7655f6c5fd7473e380f6a5145cf66bcfd2ccd49c7a0b1313a918fd3c08f3415f8c731fdd237a3c841eeb9008fdd535b479fbbcdeb269265228cc4b5da1d8fcdcb121b7f4a1ae22117a1bda9c635b6246dbe79ea209760d18555aa06d5a69b440f3320b546f81de8c732bb92cd06c02aa8fc58c6c2761d236dd8049dbbee96981e683da4c9a1bdce68ad0951fa1d1f5cbf0b57736c30c66348c76cff22906fff9f62c9f58507d289fb4944e47ccaadcfb11cc0ed33483a17c9262877b964f4ccc62289fc438cd6098c9308bfa89aa325b69207419bef85219b93d4ba72f9bfc65253871f9716ab2f19e65d31a9bbcd0396e0665e4b8321568a229a149cd78abbce9a87432b8b965d3174db328a3d093262eb4000b16512e3811830b61a4b890830d38f62c5b88b3557b962dc8c00550dc38712a5b58d33473ead9b36ce189eded59b6204605b3a69f0a52f108f7edf786650b58c0883922617ba76bdd9ca25d1dadeb1ed3bad7365a775288a375277f4cd188a3795bb6dbbc853b087ebab644fbdee51aed4e8d7cba0947eb6a4e4b340e09f77a63f2aa71c47326db66d26efc4ae90de396b137af88771dee1b99549f54ad97c9ba79e0ec8d966ec62ca60a764ece324a28c7594c0fd2a9a9da23e73c94a3534aee47b0d336932fede9efdc3724d6078d7a3da6c91e982647f1ae1ead8647df05e05b4d0ec1c7b714883dd59eb524ec1bf73a1ed9f37c251609373ee5a2c6bf34d9b3d2a2ee71e9284bef82e915be4a14427fe469f122c523eef44bdbbb7af48ada8b21ceb2c1106fa1b5cff67787d9de7e3c6108c1675d27733959759ab7d71efb23aac7bb73a86bbd63fd870d7f58efc7eed9e48fa8f0944671e948a1ed79da1bb577f26e6f0c0a8414dab85672bae101c27888814f4feb022e3dbe97c9a4290b747b7ac6118ef72d098f1d9e4cc2638f5f9d14da5c7832a9b2b26bcee83b5148f8a35193747b07cf8945c21dbe262d816ebd3cb6f79516f51d8302093599c2d2f60e7e78db1d0b1b1f9cb4623c04dc9cbe63d01d9b5e72d17341c20b12511b5c81734271c76f1229081e6311c4182b31d97e1f625dfb8e7f2f88cfc4fbbde045503f714a4cbe5fcdf43d7ca89b9eb8dfc7eca1ba8334226bb311fc2f7bb9c9aac39f342e370942c3bf796efa096b16ee2d65f2d11a46100e73da16f62ca90ebfa1b3377416c71c42c281e3c61c42ba71c3c61c42b261c3670e21f9f8c4e610522c069b434830d86b0e21bd5eae39abef9943483d3d3c73088967ce26d2ce8ece1c42d299b339849493d39a4348ad166b0e21b190c639ab5fcd21a4d54a358790542a710e218962388790c2212410fce610d2f7797308c9f3ba39abdfcecd21248edbe610d2b6e1398484e76c22dd399b48d6d6398454e7acbeced91c42a273ceeab7d85b3d972c135a2f1990f6501adbb40c23a53c224b50963065182c5041584a1388d977cff2082c6ae89a103b6dca54bb9174ed490b9f73257c235a6dfb146b58d76ad3027137028fb7df1b8ddffe4d7d17f5953252bde36e24fe1ee37f376a1d1ffcb273f0463adf3e6a1ae57d3c4b8fbab675bac6b9f97eefc11b71bf1775cd5e4aa5299a9a94d178d55bbac6b4bdf51d4dbfe0e7e85a4bd754ba268affde690bd4a48cba83e7748dbbea2c4db35820fb51ff7ea56baa4fd76a9f91dab4405246dd435d0375add3a3127b0bc46481acb54016ce54944bc8cd97f11d1a8e66d9e074a3cb0da74734347c995a4bb4764d5c3f46a130b2ae9b6166ad79c86d7aa2d56eba6bb69bc8d24cf72b3709427b95814dc50e956fc38656a25fda75b777b0c87b2b9374b7be4cae003ba973925a391232b7f7bbc57b393956ef02e77e8864f4c76ea4e32f5d938addc675bc6643d79ad0383429fc987efdfb0d55dfe1519de7b121aa87573d3c19d3aebb32a94335c904c9e8f51b37fa5f52484636fefaf5d44a2f5d7bdd86a66a5e474b82ec7c09dd54c78680e739781eddfaf89dbc84b28680d7d1b24dc5a2159c39be79e99abd05b24216c88e87d16c82a6af9b60e33cda8c9306804f1accd69e4e833df65786caf1d89b6c5091083d08c66207ab88a4c9462cf69812130e0efb8d14f05eda266042f2d2359fbf0ecbb5251aec20169134bdcea483c360afacc4c4e730cde4f31bbfa19b9e72fcf598911c87fa39ec93168bdd464c3fe5386c72f0bbab26b98b26e8e72cd1a658046faa49d53d4d2f8e5a05bb49d93eaa43b62dfe836cc402d97b909158207ba06c010b642fcb2758207b00acb0c90e72931507fa29c7f57f72932034a51c9a05ad270dcc643da23ac96eee5527596ac58a15fa653fe5c75eb7b0db5328ebe3c6ed6fafcae48d5cbbf1a77c92aad9b406fb537eedf5a77c1baf0cf5bacf6119ea751bbf91a15e875dcc47cf50af4f0bf43c693e36b2a7c9240bd32a6c9bfe95a5ae5e1264537dd47d4e6daac6fa88b9b946d0a8b0ed7ab049109acf6d1c6bf0b0dff807e5a39570fce1b43e9e9a04a1e1b88f37e79c739ae08c09ae6cf086b73e9458a0d1fed833688791a46194582ce46e4f937649907dfd84e3361e821aa9eefa271c879df44e52355b3fe1f8eb9f263d9d6477d52a6cbbd35b7068166e5c93dde8d22a6ce44403b393898d87607da48fb6c07eb7bc8ef1abbe2ad3066f9e531b9659989985d7412a1a79e94e24616a4fb1c8c84b57a65d7596782a2c0a905ee602b3eb7dd4d8f53f3a8ed8f561ddc048bab6cb045e76bd8fcc882abb5ec79d4dc0596957e3f515895dbf6202d273f182a67a7963a5a0ae141a2c55c6568513d309f1c6abf20d21a682437c117e613262d75fcca22ab3fa0267acc222224ccb4d0e1167e858d929228c104f11687a8a28c38505cccb8912c08ad8f58f95e04c47c4aebf4f09c2a835f4e9421b3f6a0f72b442c75a6537ca6c602465bb04f366d7eba8a51729bbe6791e26b8d689ea14774e547b6253f43951c5b1e553b1e8a7a27ef7916635f9b32b185234c1449b4cfbf5a0a89174fdbcdee6f8eb53467afb23fbf0a7f6f8d1640e9d446853fd7ad594295f8b5a8d4d93aaacca6ed8c011e28073239f60238c18cce7f3d1590255460fcb6ebcfdfa2b1bf5f0b83a179a9e3c02cf199d9c1d6e47ebe49ccc1a5b5b4b68e4a1125778a563d31f51067ee10d35fd7c3aceb3455e38e293f786db8eb3cb41555e8461776b10942028425a64e0ac207532762fb08b19651735e6ec83336fc410420f82b5522b82dd5593b2a2dae96b6fc539a76d0a620d4ae9bd58b62ad65a8bf1ec02a68b178a8f29bddd5c24e8e244e57400679d73d24fd102f1660d1067765dc2da0fcc998228c38c2f3679d7ec3341a02008306a04a125082c4148d9358816bc33d000c128206e00820b07486a054a0a65a24db5246befbdae15949cc0711cd759dbdd7bb9241aa8b2eedafbce765df729165924dd08f75a6befbd5cc6c70aa8b28a801f171299cc474703fbfa24f1193b34ac74a3eb32a11f96c88e60c422b11a489254abb4494a558d098261245dbbf688e1df8df127ad8393e3f6bb37009cf4d931ee7773dc274d567bc4badfdd019de4b163deeff6bc4f9a071fa1f6887dbffbfb3e691c042a9fd5b1988f5c958d7cf46bf57195c4354e98365a693289cbba88f6bc975e3af2d49c12a441900983cc1764d69464d4b852261921c818b15d5546a689edaa32b1c85a7b2f1932656243ec26992ccdaff1043ece4beea990797baa91867c46363ed212da66e38b30db10d96a4fd28d978cd9b0bda4c3be22cc36334c2e3d41c6cbd681e76da6db6791abc95a4c84f94d54afb8648526175a60fad1bcd54b6a9bb47bda1e829c18a3904481c1519b4e61242b6c1c45a144d1a8bb46a98413a5182e3c6e18bbde314a3258ca27a22e1c7a4b409b435caaf0eb36a702d44981602057870c757e18bd93a110581098f1de2704a8d36a08f5aeeff8e0b66d0fa8174f42bda897b6973fef987ba7667b79d6183cc1b4b977f4c87e567104a23d750a74177520f8caf6ae6c9f936fde41b3b9c788dc73bf9af41e3b5704e3e9ba91bcf79c80b3b95b27dcecf017f69b7b6ef34a2ce285178570dfb99777deca4721197e7c4e0cf6b95d1deb5d8ec1fefa3c7830c788848f3d7c4cc7605a84a5adf31891d7592cfbed3ef73cefafac7357d6794f2655f7ce938f5a9fdc773419de7b8efef169e523eff9cb3fc2107bfa7b9753a0db1efcee0782ffe07c48df93b60dbaf9bc10b87692eb66701ba3c3fb262ea03b772b825095ddcfa9ee0a38c1dfed6e9be5acb55673f4cecae3c7be97ead4dfe625d4356773da30f15d749b4353cabbb5dafbf42ac5f976d786f0dde25ff6203123f93d29f528f5b890e46e3f02026a8feef63aacb5a30b88917e7a5d9559fb201fc6b9ef9c33341c131a384ab0eec2a9156a0f4ad636f7a9497b255c469a5465f5e1deb24e95e12b49f2a1da5565415323793457034ea2f10b51982f15e3cd23d41e56d7eef3642b1079199520203c3d39d11059fb638739d4138dcb5569d78dae5fb68530bef435c90f5a65ceea83881875aaac5231922ed797129cf48571962880736febb69dfb100410cd213a87e8a6dc11d7e31289454b689ceb537be053fced604eeede7ab77db1f16344ba6fd779eb5b26bb93db5597ecbed3d444191b0c37b1a8f52e8ff7597d3b9d7346ce59158b6c45c0779a5c0a7f445184a5cdba4fed71bbdf1355f137c75acff9d4f94efe740e5e47c75a8f11112fd2a0e60c00d9dd9e2727b3deca222c6dd6988f56faaa7c24ea4d35a867956ddbc34dc7865c2626bbbb734328d3eee8c6224c279898c02e2fa17190964c384c4c3ba9b5bfdba4707f4a7687b424c84edab687e43d692b6281dd1dc792209b8a0958d2c16972bbdd0e7ae208447b4e1de417525184edf76ee19cd15f1e73ce48d52e1a3267f44ce8924eed986e410f0c2d78ee734f8fbcf7265dfc39758380b43a317e155e0cedb55693dcf157994719e3eade571f3fc5d57857f7aeaeaa0b37f86111b8d77349b8d6a515b55c942870a3ea3ad5491d7cef05bf5d95799431aa1e923faaab4ab27baaf4e78c3eecf2b418d3d1b600ac32da755dd7755cd775f73ecf3b97bd9fcd6df73c6fdbb67b9bee964cf0cb28fce08cc24fd0970dcacf4f10f7feb85c5d5c231365302106136b9a687ae1327166cb6a8f0e0926c4f8a8341b54c558c97ba918708a609c251352f62ca7b26c01ec598e19635b4003dd2d0aaa629c5546492a72b4e6a02de3fded829a18f161468c6a8f4b373ebd32268c7d5f05382b7ee7bd83733749adb5f66a926a926e22916f7376ee3bc7b845b4cb0a1861eb98b36a64e69187919c6fc8a9a6ebc6f122b993562a543fef18368b9a33f6f72c91107382375b68cff20447ec316bf6077b964ba0d92092da63e277dd3924f748a2ba3c7af7529d1e46fa2934d74c09d41e36ebd833828cab7707df913e36fe23d341f270ed1177e1a827d7a9ee6a65ad95816098b9306fdbc3fbb56dde0eebc422efa0e775a0d779777361b661ae9b2a1106d9a031e3fdc765cfda5a67fd06054f2541bd7d77c73a3cdd778e431d34c448ca36d639c639cf39fe8f90475fb14887874727e11dde8a444810274e1c347bdcc93af9ee9cf0adf0ac1c7ecc2178fb2ed424f80d1cab6cb4e1528bda34c0ef344f3a3339dd6cfab3a9fdbe8368d22c99710eea2f1f71ef4e43f2d3a4d0feeaf45d587d8c3e58b2fa31cfbcaa3a1eea805f69f23b47bac60dea2fcf4d392d748500ed838c18c77b9ff60ad9b9432b1689a08eeb6777dbb98fe3b88dd3dd9220e3eebafcd34d9ab78d9261789ac9ef902e0972ebbd7462d5f689d0ed4de669f267671f8ed3a40edde8ddbe713f8fef62c662d1d6d11fe4ea0ebf1fd60785a25142412818e7c711bad1e5e2b237c5bbe81673901023495baff5ad30d41d9875aa6cc35e4ee2dadb7de80873733ae9120912274e9ced537bdc5d6b5556c7aeca683767219971aca2111c0d1262acf73e394c8ff8d1d212850c3f5c497eb424e19b8483b4586a6d9b5b83b4586a2bbddba7a236b80255d9674feba3155ec79539906afbed765b47df6da758f2d177269b66d2ee0da476bb1dbb23d0de6f47e03f91ac7583a326936ad781dbbdf86a122fd536ba6d14cb26f1bb7c64cf64df7c91d07724adb249bc7145c8baadcef656e049efdba6491a3541bd6992d3db266ef6dda59bce57c786d0df22f4f74828140572bf697b49d6712764fb15b7eeb2f4d86d611e3539d708e93eb1c803c13cf7ddc07cafddc11db72ee67095bd1359ba21494aaa6412ed3e7d74c9ac43a15020780d39d71cdd6fa7dfde515c414a528dbbe3cf7b2b4f0b744cce351b7f03bb7fc7502810aac9ef9eb7e1cd6df7debbb94d53287407be4ce892aa8e2640b3c34d4f8fb388b1b241d8b34cc24d125fb66ccf3209a89dc4d4067778fa338758dc75f66c82b067013a0ea60ff0cbf5f54862309705c1d0f33c2fcc47dfec3c2f0c5fa75f62f751f8af087da7c9babf8727aa96ce2cacb53f569aee8fb4567bfa2824bd935693176f4b35262b6cbc052c30e24c9318b65c41850aa2a8ae6c19d326aa0d531a4be8a06123031b19b059019b2deebd3b76c0dacc0e1a54e082cb1316fc0046091a3a2a90ec1a356bdc4cb1a9114cdc7174d924467aed9a3454054e382976c884146c9a9cac0973860b35d600b1c11cf6bc55765411da820b7c31be343466b0823245b0f1024a67868d102d3653556ce0650d2d35f0618935d6e852c0e6068e0d0f52ba30b808830ba61d3e44c1268d931d336cb1c69a1748b005182da0d831650b279aec88d2dab3dcc2cc1650ec90b203ca0e2818632c05638ca1f0ec596a41841634dc90051a38642186942cd66481e60325c66ffa510b5b4ab1e73f5862ac65137bfe0331e5127b7e0e81dc86b76ddbb66ddbb66d4bb3831b1a7cd12587285eca8889aa200c4e64740146142d5aa03853c375bcb8811733dabc81c1541764ca266219258506db0a153da8c1e50657b0a07b028b3328166840b14135c801c6932e6caca81203369d1358783143100d9ac61a039d2d60d8d1640cf72cd350b1c3290d133b9ed29c200d1120ad61677de0d1de90ce3bbbe9cd29ce1f0f4ca0fa273218b6d0aef5549f80c6483fc27d9d3540cc780e11374e614f7b2bb52a72697f01ebd7b4b36799064b53cf9e651a2718c400c60e4e51bcf083161460d1c5c3020cd4fd7f8ebb26ac7c3c3ce1eeb550601175b1a8d2744518ab2b6c3083156058b105973328b5e18a356964a046898506563c61c598d91560e4809ced79f2677b9003888ceea827b3d783f4117f58a07a12ef793a8118a13bea4998b38a4fde15c8790653b7da24655a9190c3364281502cdd28f3e06eb25b6d72b4fa225183825bbac5943161a140e814dd515fdba841ad78a18939ab27690ebb0a608d917e09bd00d61845a05e689b393465b95aeb69166b7b90581f9f40f6554d0f8ea9c3fee620538725daf653db32794d6698f16346694596b20a2382c8b0e2cb0b3228abb0a18a2a33801304a78a261ce26af18558bdb43359497a7f846f871c71f7fee17f07bf4ce3eced1fdd2038456b6b772ea9ba6ad326d58da92882e0e7ed4f18aa549fafaa9cc71849a14d647d048931f250a9c2f0f334488cff541f736aae3e7e3eac218c9ff3a178f04eaad811f1e08d446da4a2713658c322234da29126279553a8418dc6ab1d0cc02ff6f6895590666fc74b58c80d0fce1ac2ea24f74d2cb27d92f6e2b7af32d4694b35b216c24ad76aab33991584fa5941507de299c32e5bf1f75ec81d4caa966e5cee5ec5a2ee134f1d23b22f96520565ec1558ef9e3cca18aba55badf5081fbfca2024c4a6eb84c04e889b29352bbaea446e953b0be4ddb31b05d7de7412d70ec573a73a488b91fcc1719947191dd771b6be8a4482bcb12a166b6419b13ebe356aaa5b44c273b1d811d77b1ee3deddf66425969411eb3a571a5f93325a5d47d75a5fbd9673d57b726c7b4f6cd3b123e3ed1fc07a8f566a29f5dc7ed2d46cf19c5256ea79ec48cec79bd0eac95259c9953b0be4fde6696f6cb2a302873dbb14c447815ca8d2b5255a4d8aae9668abe9810ef62cd164d968ca6c3176c47ebc093d67bdb33e4656cc84d65937caf99863d43a4bd728ad4524dc44234daaaf94d493747347ec5937a1e7741cb7d7723e6a23d6afaeb5ced25624121ad9f9dc463cd7e9b119dfb36e643f3e288b31545a29f55ce52adaa4c0abb292ea3b42c4779abc9be3b873bb23855c737a625e42396f87ef9680d968751dae735920bc6d22110fae08e20a9ee7c87890314e1a8f96aadfd14a5246aaafae94f3d675b492eaab9332234d4e393ad6b5748c7352e9d8f758a78d8c629f3ec2fa65fdc61e30de7ebc655d95c757d15b8dbac611d9952ae9824b5e650d31c5384193b7674945952e69446931861a4c6a58d03101a6c9146fa6704393b2076b56aa9f349b4948816eac5370c0a435717772128456cf9da8727702c598fdf6bd1a71ffea3d13ea3d5da3b4dad43d8c1df13414a5c58e78ba064569debb1b7d6288892cd07d988dcc32e211a11ad4867b585f754d2a76a49ebb513da76b52f635ababeef4b440429b6bca75db0dd27a410c8149030f52bc55cede493b9513fd6afd1ac0e518be9320340feb23f49e56a29fb42526daa7d8804933526feb9644c5720488c65a29a6aa684489c93df7cdbaf0d138cd74bfbd8e31fa983edaa69598e0dfd18ed955335d3d2d90c5126693e3cd6ca9519aa7c4a4bbf70028136a5094d6bd09a57577a13b372f53a7a5ee39cd8426556b914d934b8e92e0578d023ebd127c7a229b56825f7f330a98da59af6a098d8302be1a85fa7a2676c9d6aa86d01938e0f77df105f7867b33a788b271e61451db942cdb942c47490cd034b5efed99333a4abe8d82019aa6b635f3e628c9ed42aa33b366571a7669146e17524c5b8893c14c83022e87a926db9ea51456ca28b49465c204855146b1840b416bca3371ce9c31069c3f9df5517f4fba40fa39c1b97acd3529a31004b591ea56d7a858f538f220e3fed34d55d7a48c787acef3daceeb29fdbd11fdbda7f7b491eb56d7ec5dda8805e24e754dc802713cba46a46bb740dc7534f855a86b52de6be1bf7bda687515f7d5e9a90e754d8905aaba46413d2d10ada7f5352923faaa6b4c54d72cf0da78d6d428c4faa44d375ceb9346395ab8cac9352923f02d5da334f0abb3b252f8ef635692320a35cd6295c2f368b3d29a7eb1403cc818b5524d8a8449c3df3e699f56c237d2544f53c0250553fb0fa0344c9b3fdc6ac9560e88a02dd86cb185150f82f7de7befbda0787aef1559e238de0b8aa2a8fa15c14f111441711445d678a20a8ee3388ee338b258add63bebe3f5d6c156265da35095b56eebf82f5d65e32852718e5a3cce2c16164f1031c6d8a51297c2f054960f2af1b67e652bacc9d541bccae291ead4b5319e26c05658a54ae2529565b8ecfb9db28c15d74ed8c3b3dae8576519a8bd7a584271c6bedf61a9be8a81ab71c43ac6d23150c7b491cf61f778cca408ae34fec6fa8db10eae56ac1b815ad4e409fb7e458ae756392a955e81fa28fcea44555cfd86e1d5a46ba7876747b55aa956ab202edebc11bf3a61b36e3beb03f6f1e098b15ea9ce3acea1e8da57f599335bfaa56577257189b48442cd06bf7a3de7ad1c4d8e2f55a71abf164bcce40946ad7c04a65de3a793b8c4d545708a4531f1ac079cf4a8542cb7953d4d32a56844000080048315002028140c88c40181482c4dc32c647e14800c8b904c6244154a22418ee32088814806a1184388318600630840082169ca46001418201158a2d577ecb846043cf14c7c438620918a066b84dc99b810adb5b4fd522608dab7562a9c3434482543684e2ae184f7720053e0fa25bbb099c630e86ea9e253d24e22cf2a5520fb06205a3b3072bea38bdff101383d761ce609962d3c15cb319fbe29163cfd34a72b841244ec1567e48281e58e78dedd6962e25c31f5d174f9984e107ef44b6d9597dfa579430bb81e119fd5e5ca611fb0048bdd20c01136cd6520cd1d5d2f7680965d00fc0dfb2ea7be4641e0fde1537a128c00e5a801cf37a823355a3366cfdfa1373c326ca6440f74b9ecdb7a7fa4cff0adf64c808f8d8e820dea28595f6a786a5019bdef8f85b0dd0b91d8ad6f2c15b117104d2e9800f1e4f54331d4ee7fb973f5dc16bb608988c721082dcb6c09157725a4d5ada288a1613cfad6864e2b49e5e6d61884974da39bb45d670f293140fde30e14e353c9c228dc34b30adb9e86469172b7108f28f01d92d6ad27832cf6c4bd1e7f026f380318cfa1f1ea6857111a25e84f96a5eb799640d1836f89bda1c3b99c4b4a188072fd52e4225eb2eebb54dba0bb4e5771a738717151e011e3e7822503212650da0f504e75b55b6d0672bf9b9e38684aa5d5780923fc4ffda11e942e141755b0d4c3db57c73aff42cbf65bddf4d9ea6226e14a93d5401862af123730a1d581ab5ab4540e6fa0a46e2ba4cf3e1ae5568aef82369a1505e04df7939b6f3a3a9ddcf5bba07370867aabb44bf228e799f37739456c8c5472c455441d03e73192f4679c9155d22dbad5bdc11690208bc3a31a55c2672d0bda8157957f8dbb8e178c961c6e803e4b1fa72f35a52243dfba9e6142873785c9643631bd9acd931d0598658d2f025e1ae4e36e6c6bf4afe3e3c0b4654e3361da24632834b6c04764095429bbad47d91ab1e92b163266d15577fb439948d46f0e6b55dce9a6c32dcde79c6521aed209409fe2bcdefc98b4cbdbc5b23c4cdadc6d1c3b8faa7ba3e387c6b1bf7f1193d675f9479417aca3d35c84145139815c5943950309f8b5767069cf5a6c828a2cfe29f5dec48261ed07d416bbb18931b4a70c3b98aa20924623461b92225dc71330e809ec9e420a6cc45abab3d36c9055b31d17ce2e59a1ec4f3fef3fdcddfbe8e784dc7a03318a3bc16f6965cebcabadc0f45734ba6c0a7828239a31d0d5e29b2c83ca48cbdf03a5c1c0dcc573cb47f073baec4a8579203466d78788264cdb333e353061ef40b0976bcf502fc2a95a18cd877b695c574000df50501315e9905e2a0e0d0eea9d868795231005a79b337d7e4c7bfc50de8315579b2ef2cf93c9feea000cf22632f0a3bdd2f7e7db25ac11a9f2b9520e7561eb6794217968bd43d754cae53266c9ba7a84cbe3e823e2d4ef9df0afa1d6b7fc9dc719a6933bc89a3ea6075dd69131473f3a15c54f8a59726ac4cd86ab6833b4c77f4a57ddd59ccacd97f8e81f52dae0a6feb685684bd4f798dd99eb0b492d364b22304da8f2fd6a6f342a3ee8cf2ce8959f6078cc9615537dae85888671579d11596cd552a32ee40982e86110cdbbd534333e5b4b0d4dd821d83fdb99434342e0d6a4220a5d991cd6ed3f1bd32355552cf0455d48161ec5eca4394e0d91c76b41c0f5e86cc5cc808471854f70a0e83bbc80176579824aaa1c05a121d56bbc80abfd80d42829f246270492f334d6590c0213fc29e1630bb7ae9d2169dca6a4e62624281c0c7cf88ab8d0c95b4e12ddcf76474c59a4cd54918fd262a38a67a4ff30278d39a4cc396b0773f2845a70d8dc884a7a4e94ab1f1699e044458b466b8f7926b6762e5cd44647bc7977d9600407386f4764cdd8d3fc5a6141246a6c1916c75713d117a8088d5c0911d5589e13a9f905d9691728878f3716430500992e97c55ecf3aaf48426eadf3816bd7015f66d469fc836fa6dbc8bc9763f9b34929ee790370359082575303bedae2ef7100ea15307c9124af2b487f4c36988dce6dc4c1110ff6cae36a44dfab582f39bae77ed0bffda5875a43d70b39df6e266c190b6664732cd8a59dd5cf99af8d22c50550ded7e01e467aec7174e46f0eb511706ec5bbc1dda545b963ae2be154d4867522a3ff6c4bde7ef707051ab4777b96d2e3796cc529c578f57007023492e112defce4105e17836e5dd9faf2392c9e152b364d24f29196bb3eadb04e26c8b120eb458e02d5570e745c8989a860cf2bae2d7c527fcd78fffa2a0ae4a0cbcc3e5dd689b4b15e4395bc90a990fe72c06c49d8d57a74a838c16f50a422c023201350c8e2eac4c65ee0b6ea579a611859be6da66b3a8ebe99366857c2cac83d6303b83a1beb989b578e79c505a0896315688a114a406c372fd4a36d40ad32c24d29f665b90db211a8b7311484049be543d6035c27f10754b1bfe2ef3dcc57923dab2819ce3c2de0002208ccce3a89c81f3ee8d88645bc2c3bfaefddb1c286269d6aaba2966de2f305a97b90c64bb67ac0e0933cc4cdd861d27f8c54df2e4d775d8d5ab7e48b825ac5aed491819c0a74168230109b7220a1ce231a59dc2c77149997806544932a2f59d4eeaeb15bbb1d4f064949f863e4ee640babec0d969ed3c9f51a1721015759d104e9b6f83bdd3f2f4eb557ccb8e9ed8afa8e211a48defde0c42e55bc44ad102611e5104370eca4a2b28bd1216debc0a0bb659fe6a8d4b40f2813c9aea27cf7c006386f049395bd50c77a0a83fcafbfc79600953a9626dd3ddf0e30ae36e7827ce8aa93aec9a146e04ce289177cb2acd8d38aa80d2e7da2f6e6bc688c46ff53b5494260bc9ac10ae3b9ad4bbdc0c2ee156e737dbead3861741e58f12b03402c1bda38ac4b9ae58b312b468cf7e03e7a3d0769724fd7a24c2b6c37026158e80ff0fcb65a31cb1031f471dce4f2719bd4cb56773b013326b18cc40e1b982a374ecf29673c75364da7445a747e6e2bdf2428c8e7137bc5ee923c60526eaac1d7d89e77c983a9469a43299272fa4662f8786957720f988e1e49071002f79c4536547ab25f50cd969ff643cb502b64b0a7e70668926d1b86d0193416498134febbeb97d571d89e79fcaf044908a129f82e9b0e8911ec39bb08061abe4e224f8487ff0394b22f2f46de9619bcb45042bdcd3396b0be0d337dfd1433444775e6c17be52892cd9d65428db381c5879bbcd9699cc0f16190c1ecdf217d3761136ca413878bb2a874f2c5a5ede8c4c1940aaa66946eac4789163c02dfa94e3245aad9b124897c8a9098e444e66e1aa93990f1437d62b2d95c62fbaca8615e7c0ee5ac76887f2eb9865b3dd9b837adf70c69bc516efa27db985e04bfc04944d5f1d81d6b270ad73cd80b2a72c4f96c243ad7c57014fced287e3055560118a88f8c4f07c266528686030f458f58dad06d2e6e5040b411213eaccd3a820bf7d82fb109b8af28b7b86361445f0488940b6f7ca48fb0fe93c716b6c3eb253888830e42681674514552f80242fb5d08dd0752374e9eae6ac68387d7296c62ad4340909c900f0c25bc84b6fa74884b502787256d75a6a74d780ea423fe456ae079f0da730ab43b0970d0e55514f9acadb6596ce46841effc8a0494421cd83d84da3d50952ddb4e9f3dd2cd4f7d13def6a6960b3948dfad36577137c589cf2240a95f60928676ac26b6f03c1a0771839728595c2bcd42e0c4b0d205f38d120e534a69e4dc4df04eab0a3160a6b81b598f620b8313bd4c660ca0480f4a5313b02c324a169b45a5bbf506fbd36b269bccfca182c9edd56139f1bb574c15569ffee7097b54de6cd526308db0392cdb9dcbe6586a013d4d54b0d800c1143cda812d4014206724322e23089c2cbb3dae362557b0d5fbe0db21a4b8cd069a6bb435313c514b6cf1bc984758b9054a5b741be6a67da1e3f13d3b2657633b216297ee20db866a7ca34ad6c9a011286b180d5e89d450854d21e6e26f06008ed6b486bd635e50f6a71a04467871806996965195405b05586ca45337cc5245210597b0770d6c9fb087f0841c896650604d4a5be54db55b682d726e0045e34888c6cb3f44ed21b78e5b7583dfabcf1ebc46138f6b59a30f816ce2ec9288f7d129591f422e1264018696828b2e5498d2738403ed8f280b071c74dafeb0ab27a5bc22b70c1214301cd0abe059225c572581aebe581c7b71ecf2cc7481f0acbdcd3e8ca0f02c829f2a9312c5bbf4573783cdee6df8aa512db5e418c11b9840b975859a9ac3bb962c74f92abac648af97556b435159b6f83a4cd98651fcf45633b749aaefe26ad15ba565d3b922c927538524f2e0686e6be7e3879f6a88436a4b798bdebaf461c335563335d7ec4d4ef810b524d4c883cddd8c1656fe480be8f63bb03569ddddfaf0c2880dc1d17530d9a832a5bef9ff729aa5cbe59c75372846a79ba3102d47cba719215c25652ee3ac264fc1b496ae668d85cb7083d4ddd77c79280f4f5cbc19c5c1dd39b1f92d3acb8d83d865927e873aea288941e04f51946ccce313c62eee9cfc26130ee18bfcc5a02f4ea19eb3c0f2f4f740366abb1fc199d0a603c90fef13c3b3ede3d4422b714dbc150ca278f50a2f7132e0b6c3d68dabcb3af5e2bd93ddd8c013ccb24e3e36cb483ab1f5fad65ae8a24a135aeb4516cc29349de02b2334fc42e92ad9e106674ce3d4d0287d80293b2897382b954f8f040e67279e4c1f116b6b5b777b51e2a0bc80438dd2406c2da00cb04dbaa2c3e9ea9cb7315022fe5bb03025fc85e4b853e5fd49f7ae0f83f83addf427630dafd03c5ab391734f255510e166c3adec2325989a51810d715e031979de12e289ec574c04536aa56cac1a1bbab7de94b918738cf103b427c5751e95da33b2a760d41148c411674cf6a0542954a44307ebd4bdc65a653af4f80165e60df92850dec7a84588959b929f99fc9432ea48df5a593fce625d3e2ef433243ece4230cc3d015d578b41f183e8d07f1e999aa09e8beaf6827df7cd003e430b11a8a89b2097b84662b77b1a24840537f1906c183a34f7e997689597db11e924fbe94c22e443fafcdf2050040fad4d9d8ff043643a136fadb908f8edede1bd265b7cfbd621eb9676d934917726cbad248a53a33caa5bcbede8cc2901136bcd575940e08b076b0ce328b516f9d496a21ec416c93249275e8db92d267eddf462c26b36caff620ec9ca86b48fdb624a6fa65c2b86b59345be98ef171ddc0927b6c6e009c42d0a32b06721b798e82b8ae916435f93fd95bcee28a8b64cbf8602d11f48bb5bf78f10e331701629ec2117bf278912667d8c628fbde47f0ded3068d6a5c4c575e7b581e920ab8341bd7c0d6c424059a490321185c70336757bdfe1df9c4ff85f4e2d9cc6dcd82c54375667da9f20bac3464386d65da88e5a709231f7115be4eec5059ae911adb158b5084448aa5fe3426e4a2e492af50ab050a146e7b89ded71c1d5938fe3fef170b84c08ddf2648905bd214df6dd94398980d2c6ef7ca0e8f35a3b4d2c78dd6b95fa31a7d9fabb35f215dfadcdef395905b1389aa782d163e49626fcbb8b8187ad981b3800d331f2a384198b98d4c6e095db5e76c31e0949667014c98efdc882d184551cc1af8f608d2c18aab8063491f0aa27206ddc796aa0891218c583e67588164e6ab23f3c18160c143ff67638d85bdfca873ea2b7a95262648cdb8a3b2cf64c0db22fb8c848d455c6f575d2e9af63795b44b10eb773e293757b14c4ed552517f9baacfe780932df19c18251201ef67d5a56666e4fe7e06c3d622fcf2c6331fbbe5790353ad622191c3145436e43e8b33b8c45c09db93f80b77b23ec31f25f6148c466f41e4d270b04d4c0beba7f6a7788f79c9e7f1b4ebcb06634dbdb20ca283ca8a8596b28053e56bdd4723943562e542c2c88d73689e50b096d78c74f04390e3eb10f54097a91ec29928a9207902b73b037408594195ae0b9658f3cac217002e5ab71e5b448a32175e4cd164e355f11ccd26441964dbc3db7eccfb27bbb65679789a10ec109edbc60a2e8793c842d7b0c0a2219ec550c8d9d04381a431a41e1d4e5c7f9f9f192be4b2f188a223bf0f9f109396eaf57f0c55a5e063b34114cc9df22d8ae2ddb49e0c360079a10bcbe59624c96bb6202a50bf6428c4363d516ca8b33e750614ca58e1bb72717060220fa2d2cf3a2d4e72de9173a9eab61f8f464a1e56edc1e1d0280a2f7594edd1abe3c6ee2c8ed41938d4feb4d50574d49b1168e2bff7d74d76e790016faba103c30900278d58d5ec2327bd980dca03c7211585f13d78f06df3a7f54beac95a8fed34d49db5a080ef5d4242236ef2208d0fa9e731b29c10e500972d776aa751db54ed50a79e232b253bc4652656eb74386e08c5931e016adbb3d46d735d1172eeec6ce23b15a4de1c318861f5621cefd514f798118b52766f7245f93bf269f7a6eb501837f38134c470a4fc591c54d0fcaad7984f767351bafcf222cc1916d1dec2bfa0f188b2e62586309ee71268d6e4a2c8307f44485419bd5e3e36a4737425d4ffa2078ec0366bc60bfa4e0d5179b05de949651af3ff17f593a07442d2f407353f0dea9154f620deb7927b5854cacb40566bf67c592d5896012f2b8395ee4cee2f65a723ed0c776a90c2c24ca457be678511ec67cd7a19410112c472848eac9d020e5bf6c0d88b2606806722dafcb323325703efb9b44ce6045132c3a5cf93b355d1d4762dd8cfb590df85e192b8d675d8e54b99446e915ab480321634036277003cbe49fe2606f5366955787a23ab085a59306b1f3d3aff61b5ea80a2095ba25936e8b6822253b0155ae797262ebbbf49253568035cf625925c07087d8494088f983d8a3b5ce31749d8e42ea0a01b4892c48a6224a17904ca21798c4ccb9f12b3cc39b9d8f756701c0d66aba6c60043a012b81f6bfe850ed993211a5df900b6a8f473d762b778680b7a049ff91ab97d520cf4924d5b01d6bb42c4466d4d2c63725f83ade648f3bea9aab74f96b58812ba31876f8d054f32d07ceb63c4127955087ed1b53b5f6b4d753d274d1790d3795b994a860002f97f369ce6042a8c434111caf0ec191b8b171e505abe32883419ca136ed99d77e3429cab897d5b2a46f77dddcf15e81e4c292fb8130e094a1b13158b4d315fac1cb56784f8bfa8cc4bac21793adfeaf43e3b72f3b458d8d81066fd9d636d490f4b733ef160cadc8d890592727e5fa6a393977b0c57696511bcb776ebd7f976f322db442186ce6fdded6097697a686535d09cd98c0f6a95f6885d761fc7f1f105d377f85584261f750591f1f94249139367836d1387dd25ec235c1d700ecfe4fadf44e911faf1df6bc5e12eae2961050a609f99fa4c3f66239bb980a2a492b5a64eae164324b5d7761b49aea69c8adb37d832e7032d0a041d402201e718e29fbfe3eb633185995e1e848da250b7686500c132733b40c41605077dece7c5fcebf10c1b83976f9dc912cba624a08b64cecf20df211a3490bed2f093edde5fc6d7e4957d9c74f09dc88626a6136bc3cc55f607909a1e9c5af38d4d9ef16ed6d92e2600ee55d130872db418fcbbe23a8d37bd4bac0e688f2d669858b4f5c258a5af97b26e5440b13f7ce517a9eedb4d6ad897403979644596a1d306f02a277e1c9c76d89e9353c1d7045ab90ab6197a0647a433a6c21218795b57bd0d2427962d057c1b013c2b03772ed100242fe40818444c4398293ffd87422fa2c9f83548d9169e9e7b578569a05c89b245e22f59f4c55758e942fee57c42db33d874993d496263fdd146162674343e5852e65136b23b98a46ab0c7a907e3c8d175e76fadf384bc60993bdd784fe919f585f6d105c39b299b80f39cf4a4b44decc421371c1db23d7cc5ba70043f73b4501a47e6e43e9cdd6853c182e69d57b657a370a80ce30ec4d81dba877bf005bade09d84f4e4ce24c3d47d180b4a1551b4eadab3ca8c0bcd111501c5ef9ffceb915adf368f364c0f4abc48e0e32325eda3e139b904a2b01293a88c8bf8da8b50b2bfe4da64433c66b50a7ba47d56882b81ebb733b8a4aa5d16ae8de623485ada78d5c87b2e001c783b8b84cb4b0c2b8964e985f04e0218c4e8da8fd5576ad25735fe70371e065101982f061e9197b75a5fb87bcf7871479166c1eb420f96985aec42e9f56c01acb10d7c091a188caaa7758449fef068c420ab9fa7299618899fc4d3a0dcd00b8d7537f400839e8e28408d55f9a99fe6d0050a5de6dcba337544c108e2ae71e883e3aee780b812f88edddf472073c377c5452969952a537e5de6372da1c2689c18fe038a472ab5e742ad61c7d4606b30d98d7ed0843d7ad4690f489d901fc333a893a3e8fa676dfb51494a94665d6e2f3f213b8c04f516704a216dd47c6cf2162085dacf9c06376fe60f9e688d35e4c97c8d20386185cc48f556f1cd395c7f3a492cc2e136959a4f05cb0be84708ac56e1aba75129f1456d874b74f1788db8c8d1da72183a5b24519d0264eb7a8ea863d96b2603c76e592c25a71cc0d22b7d0c142d047a867e43d4fe21b39216dd2a2d4ca4c8cba9f5a6bffb1799bcfbe3e6e5e41dab005d285e6a744d39e0425250b4528244b80eda2ddc4d2686dcdf4120d9027b14bb70ea2e03c32a68d71cb586feb421fb806ff089b90a9eb5a809b96ad9aa8ece3166c7f415c2dad714fa14c6f344155b567ebfeba835b82bbb06578a17959ec13189e44807354fd6eac811dc674ac748c28b3b6b20eec3a97d42d948f8456814512f440eb16344d79c5dacc02f9e5859afe90e051e8cfaca03218c6695845968181991f5869fd9d57fe7ecd53f5cb2c7141dd5ce9d9646954306d07efea29fce502535de8953d5ed681b1872241eb7589ca5c79f0d42ceb08794c56b7ddb869f75fcc8a28245ce3198d4875b4739b02ad28384c65b8c2740e43914d591d6eb064ce622f95feb007592082472c02a5b44ac2da580f5a4ca73485803f4e814ce40b65b71586231de1829694535980c02ba85566b9e54bfc34a81277f0bbef96e4df60546382f8a1dad379549136133da853646684e36bd9993cb6692668313700ebdedd683a65babf356e9436bcc67e513221dcafe34a092d113bb55223644eca266129da8990c3140bae2af9f6a452e28b04298d988139225646683112c64be939c2f7e5335eb328e265744103723aa3f30c0c4e1e1c929a6c96290177cd4e06d2b44a671c0d8b45357cd1134d57d81acd39bd0ebf62f3765038bf621448d10b0bdbd858b1073cab64a6c1bf7c39ed10ec1ad36c946bb09c71a66fae7a9fb5a013aa2f45e4c18d3a3e76d9ca9c381eac3325ec67f2eaadff6c01ce2fc0ee08744a34d447fd0a52467a8382d2ec745f8bc75cc57ccf53196000aa4f6da565cd8faa726d0f6dee6264bbe46400bdfd2f6ec23f1972ecdafe860d76f397bd135d3a74349767d5d7155dba54c409c15e6e3c71212225a1b0f2039acbaf8883a7d6bc0e09903a2b2bf518ea391e897e4426c454dc570946fa7440bb3ccb62e9225eed0ba25b35508f137627d46114fe3afb1091d85f7e5c1a2d50ea3d4993aeaeee101d7289e74b8b40716756b27ae4c9aa5e3519d059e303878a9cf7054222af30afdbe743ad99f53058152c24586b06133f836c6e16c0cadcb9ef41fe50ad84f7829f216e08a0aa25a3828c992d92da3c72a1eac348f9a136935711fc83913dbef91e4121f4037749868819045d4c97e9c8df1b348e8ad724dc0f160f7e9ac50b7546b45fe6d72cd91b88b1180b80e7e87b261c17cb4c3fd172dbf078f71cf1cd60114342dae02810f2c390f9cb920451438b811c93b68fb0d8dc2878833930d27172ab53ed1f6176e1bb20513727b5ae557f3adc57edf1b7800238aa988699de524570809d18397ba7ce4b30944a91490846d550d0ae8a762cdce2df65f7915191bd2f275245026867150a18a51223585513afafcf13481921fb3f61dddc35b4e5454d6d11762f2306e4c7e0838f05542207a1254bba376137115c24bb7a4399ee50e2f7dcc668fb888ae82f37e2d594ed567387abdaf284d7ae0e4e1c56fd75d8f5b24eadd3a94f107b02f02d37c226f679348cf3d3c0d7a42491d21d3f98171e75e0c208a47ab4b4a32050c3317757a4cca29fd0d8c7c672e94eb02c85696f8d985d79c8b21f624c31febab3153aabe275b1729248435e6438b9f7a8e2e424d5754d69b44fc73afa6b1d23a7f19617c1b5a7130a902a267740a5f7e5da973969ca48afa4516e34ce2e1ad9b4f52a6ef197030bf27663a34d673fa6ced37fc82a044af5f214149c2dcf99b10834866512b16db42ea2f93ed44376f88b0844583791ca04057545e66cbad13d2384b5ee738c47546b64c9c765ac6cbb626e52401da95f315a172a284a8e4eca5aaab700d9fbe90101144068ca09940837a1a5ab9f3f494801776bf5a9750230c98be899d98b6d8587f7e5e2915a161287170c9689b7da15d99a01a9a3eee6422deaefdc265cd65504531114fd30d800225efd3311195d0975b448cbf4928931ff70f1fc1fbfffb33f8937e2c85c0a241868329d434182959e123b420dc5004580d120fcd3c8eda29a1e98ce03e780881d06124c559fe0ba64058d82ebb831732dca707e54ee41bedf0d2f02823877d015d998818a3a63cc845f6afc6c82023ed95d8b90925c6f7a18edd906da0a5cab62c85ae9c04c209225948b3c4bcc5c53ebbd872fb3bf281e5b00721f9dd2344f0c0b5a344f0916d02e4ed0ce40a38e6af79f156083b35e1116223d5eadc98ccc9b3816b88257e6187a0372709f26f9f2256fe744b7a49885e41b434e0264b441aa1a98f0e4d915d89856d1af9179298a7654851da3b642d9cc4131c9a52efba9e1683e772a793e4d2edea95b20eeb2883d212fa42b4795be85e1580f71ee2eff8458e3ff2a1b49fcc1a0b4da76e04ea6ca9b90507104d5bcbcf62318b2877c62c24cc11eda5c1dc9c1179412a4054b4f2028193a67096d2095256e9589791fbe1edd128ecb805beb82a37639c6b0c243b351f93b0fb0a892061eeaace2fc0256c84ef0032e3a8951d27d1550897b07a21f5e2ed31e671fa198c76d5bf12ce1ff6f109c79cc48f8015af107f77f2b862a9a3a12e48e4a6b4bcb74968be534688958bf6cbf2f694aba2c0e50068d2dbc9978acaf21e33c2534a48ed044735b1a57fb75a2abc68a317f0beb8e799e3aecccc5198f7b39cfc1f330c66583ffa7c3f66122d40c11cdbe53818a97856daa051e6e2b03d221f9fec210822bc8705fe26e20c0433a41ea1082d8dcd79e0adb1b623c78257aeeb6c79abdfa428b436ed940c64f0e40ce61e20dcf14895f1c0cdd80a7ee22a09d3fa91316219b1ac3725c7559b18873be6c730d65e7e2ac1c2ea6c228920531adcd85e66daa411384fc76f780ed06837b331607c8d0d1e18d6363e6e5075eeba2212e985b6af168ecd439794c183d38cfa6b4142e04a877886f80a578642a1a55ee1573d5ffd61d682ab2cc57dbfeb234915dcd13bd5ed6a2d50a8022a2eabfb118135086a627c27016b1ca17475ec31fab5c73188e67bd9c1b540984bd4a70e46a62917a4500f0b5d058c995c74d5ff2676f897d837e0cfc11fa8a408061feac5a8724dce74cc41c91eab62a48e2be25195d66a7f841ab135a56a5bc9e64ce161c3c156cd9bf707055bde6cb889c28afab349a93832303c08b6f82b7a7572d80a0c0efb6edf9123a3c5a9513b53b13eebc8bfa5da07b2a5a72f7391849e472820bae446d0808d5bbe4613d4d8b1c98adc4e6206d90840ee460170a9cd28ebf41cc126b54227adda5dd26adba8fd874dde316852a6f27d7441a2a3221fe46ebd5f780f21d77abe0916a086e4968c964efa937f2f2486e014c3094dfaf186054babc7864af938623ed3c0be3602dd20e37b11bf5ec588c1e1e82707d9bdc922baab90d8ba78c96e0e45556a40425d639e3e4550ef3c0698e541046c47b85917b521ebc18c8398516c0da2ad35f0ffda6fb9abaf0b8b6f5ff2636e5b5086537a6f512a2137c5b209bb94f7b092102067e52426d02d87622c3a86d81fdcaa9b571fae25c5f50aa7f2111859b9bb6b200f838fe36486b935eaf20611f27381665a97afa43920ce3013b62f0160dbb52e64dc9bd31675567b4c8b97419fbcc1bbd80e342847de462911897583dc57898ddf4fe3f9d2fe6fb75187b1021ac35c2c10e4dcb3a5cc2b15911e1812b921d79b3e9d1f39d5833c9de929d0d06ac6c9b71bb0caea6ba90cec9f5b3977d83fcd0412289c800703161cf40b7c89740f7fe1f03e226d97a30474f851d402a88cbad3e16de4079f22e0baef28003cd11a8a82b8f489fd9df0c9c713fbc348202e48f3e24bfd4e8094701159a97f35d378c4f926f535a11c251c7372b0bc6b527fded5c4f3de11d6a120bc44f0525858d99ee036aa3062ef140ab6355000098c37c14e167713f485c28ed1be2e35df98fccc84805f15b74c262beb35c9c148656086a540e2b027f491b6e08ba409b070ca0386940c1cace44f2b4e4a81e4d38b404506adc094402b6beb329c24e578844e0b0913398bfa3741f64e371abf3bc30b737e6cdf1da88eae298f859b5d5937d55cd680bda55811f9f24731b4997168de5e896c1dc83032712044ce90294a54a5d703d40ba73523021214e29292fe4217c53ef313c286c0861ad0b424b76606c183cbfb0af1cfe945b0d117e58ad30bde837887171dd11801ec082574f8331e29ca3bd752582cf4e6559644af3808580304f0c2fd5343b69c9807705fc98db600d52c9cee43af5de176495ac7ee9abb7886f31a1ec5ee60321c4096bd7fa513d82d4de573ad6d91fb1dc8a57ca4d24509d20997618879a585f0a06ee639ca66ffa8a78e5fabed09cfc2042f5ab71e2960df79936d1346a4a1631ce44993bcc6fb53bd2efd5770853b081dfa6944879d822abc8984a6bf1d8b4b190663a001dfbb4dbd2379ec5c21a0b1309713c0a63ce8e0db91079c46525d0f27434e3be2dd52b9dbac8d9dbc5a0dd613d5a3fbf8bd279679fb019ba519fc7704766bc44d997eb98efce58bf02a2481eb83ddd23259b14a9a92bcfa0af23e4739264df77238e2c25a0a26c3fb564b2a6aafdbb514917559c7376c07c62c5aa3da013b9a001b7f19b0db3e6d8fc0727cfcd26be6929f721f204e40dbddfa2ffa45797b08f870f6a3f0ca2738507d98be8a80c2ffe0b8a07cfd80dabbb48b9b9ff9b7eb8ef113973307e8e2c5a50f261097d54c0e435f6418148c733281cc31bfc9ea53484ead400d4462927cc812c5bf2aa664bee315ee6b409900cc7e71baa640079768b7aeed6f41f22efed0792493dba054f7e43088ee9332c1887af7d4e2f5edb9511294f70c4a1f4ff82e3b5fdd0bb3666d92fb93b65590c7b068cfa378dfe5e653f8be329e0f86d60775bbe4fb665c6a20be4d0c995f0e1fa060d1328802fb0846baaaa88fc736bc6d73986c94f9234ec521ddf2fd9fc32aa851b38adcb575cca8b61bede1e81bc531ef2f194972bd712e8a3b807bda5175799b2f9693261316525a824f99b7b0bb95483213ad8c153ed0da04c353399c26f23cf90aaa2c0da4db07c1272c4db047acb8e39636a9dc0d61e5d2bb3b4ce8321146e823a6692c3609fc0b23ad060024c7c8301d99a05f7c418fd2202aeb1724ad969fa5ac66761b1a4e0dc0bdca8d5133f2a5275c4f6fa6362f428a18149a8e551fd49a90263665d82c88363c201e451f79906f5047ecdd1409f959c288f19a5170cd15a8265ae0e43a8c27f52811da31f5a4292ae01acb9e990e333976597e3324061ae3c258069a8bc1696b102014b27dc607222621c7c2c37d3a0185c555903dfcd69c12cf7768ca6643a59887417ff0cd9bf90fe8d3cdf14ae074e56cec4eabc51e723c51a35008124d0a4234a4240003701b3ea2d9639847f2b468a3324650f5a537071f70f05c3ade0bb071beb12c6cb7ca73b24bf4d5e6f4910a8225e62eafe155730cede643cd362247d42b5a200e23f7b6fe46492f911b01f910c05456c0b210c0e697e4a4ad432094599e1268a7088cc5ba9a6ef48b039e418ae512d86e96e86e7e50608d3bda774984e2faa22e2703fb2d1991c2a48c4da7b80dc28d722d83c3369a57ebd8a96c5d88deb65e40812872d43cdbc2707d0f70c67063f06c878010e11b7bb58f863cf545b81818dcb14d6171edb7e4a2f48ebc81d9d1113d95ac78be7aa964b53b0630e680307c42bc2c1fefe16b8e0e748685d9719368dd1b7ae53774e14bc11cb22e6152ceff88ec343e56462344d79785e60bad0a081ff058caac14814e8596b977c7f924260b502170e58d0a3c387b50861e4c615735f69da69301e48159cc60fb238ee2b378e51c2537781bc32d492a0f57aed8e12f296e20da5a001e9094b0e312dec8d0bcba0a60a0efe6044ad3a94553266559d86c1a3a8e4b451fc065aa24995ae40c5ee381ed82a580d983d865d83b9997bdd02c570f0a9879d1158ec059c0010569831e78eb3c482a77f2c1c8fcf227f0d7128a0ac460fa1c634e4e1d84cea337ae915392ca23d252d320cb611511d0c9febd06795c54e744f2c00227959a67029f340f8e8bc51837478f2c4aa5503a03774e03926419530cc3c372fb8249a7a2e5370b22cef2110712c2ba151dd6279a91a8386cbb435bd9392f22c508304b79fc0ee10b5497b4a28594bb697f01c4caedb62fc3f3be271b1c092dab0a4b8a3d9ef890bae7284a0a562b115c5ae8d86bb508878059ab170ac245ac291c1406a79c1edc7d233d20298fba9837868a42848540f6ebd8a06b04a1e91b07f4900a619d8012c4d1145edad88f1c07d49214dc5b75b516aff81fb237d2849890b5b3a711bc7c661e9635d44cb550ea8b883289ae737bcdc871e76dce438d2c415080d4eb8841c9ea3d72ba0d5a493f81574e256bffa7ae6848ac0e75aa0e0248ff4a28af4b49396290600a29a8dc88f4f47ebe2cfe06a2e2049a02f4e45dc4bb1801dc005347cb83ee469e32bd301f2144978a5a9018a0b6494e7cb6bc4918437cc82fdbde1139989cf7856ffa11e400901b009f45d150d020f5e74c15a2fd1a4f830e650225c31604b74afe17d662a568173590ba710edf45edd4769a5f42a709901a0d9132789c77a19069ae3f5e19aa37ab47cb5ee3a3047a6c36059a88e5012621737dd004639218ebb134c45bcf09da211e6dd592972bf3f44894be9ce4607014e4536dfb343898762436cc712947905cd7e8e725151bad273cc7e134bb53544855bd903e19b4e200cfbe4527594d5733937b02e171e311b2e2cdb5bc0989af370095f9cd03221dd0bbbc9933ac862f377dda023ebbe4d1e940875814da93074d84437018cad2abc1a484a26a187d5c126c2fdfe460b46c89976b02857e086aea2e61fba5eed0e4c4c0f1e843524aad3723f5d55180701bb94b87229e9753fee6d56b03e8966697e69b605b941574ecf0a733941d86861c16cf935a2a514f88ef40a870088789e811a43462a81e5c85208021086f6ca5fda9837051ecf0a337cb68ea3c136762b654279c8c54e590041f968e371b802038e36d8c5df3570141671b5cfeadbaffd7fb269b428db56d31174064b119508b971e7917ce6fb5497195a05ce5ac8975bdc266732b280638fe83968a65c7e88e62e97e0a9a17fa728824ca35084c55d88da80d7872caa71d091774707b2a8d3e93a2292db0151f5734402f0008db4a08b7c2d8be43859c006a62f0e7fb6537f6ac8fc43d09b88f122d7c5432d06460b30c2001e340fbb4a0f323c02b8b412a447181a116844e1e24e11887971cfba6638ed6d1bb13062e85f8623e6f6936415eea6fd264d9a8e3551712ef325d48560567a96c6ffe962d00f5a059d7bf33da7fe2279eeebde8433b00ad5f810d7fb625e6b8ff205ecc732434406f51a5b86a62a33b3c35a974df0d0e128f47e5d49c0d2b856718bc9a30451d148c5f51e77425fd6a1c37b0d797cd6cc029a8ddedc020518f7c2c102a34a8b416dd85aa7bfeeea400ec3eb47405c0d611547925780f6a67cf6ec26464b70d8927a20d1078cdc01909d1be1d52a77707355b61ade20b1177861d8ccd01c435d3910b85906c78e6879c02288d5921ee560d7906f18223ac797160110207082dbf5ba5faa0203332d3eac7534ef46162a25742a440b13a882838b091e2ef1eaa0ec1c6286eb15f18c57b346dcb058d93a085ca04d7b24460d148395efeb08993bb5a67c800752d4f2067a00798f67453a921e5672101ac6f0b3dcc15e6cbd97f3dbfefbe76e5e2768d2272ce7782ed67188bb5158f769771b323e4fe838e566a508e3f8bdc84d1475b449da6266a665c098e195ed38c7d54408c954e59b78ae1c0f2528d779380f6a502cac503f89c02f5d1f46a8c56867e5526b0e604dbc1a2195c980d61831ff9831b8647e20130c5f3c900259e15d1da5695fc89aa2a0b1f3302c3adb87f068f868465af72d2c264a28dea23538cbfdacae66038d525c9e6f5b4b1dcae87ae93635308431adb0f887b8494c650b89f5b33d25ce5f5604dcd87cfc4448ec077ce6a152d0c954489c8be4909575b0052fd516c5305cdd9e01d9294878a4e01ed1cc185dcd43f318c79cbce8d09f47e57e1da7fb1741035de0dd0e2f4fe8dcc184da5b4977dcb84f94bf6e3c5c1ad2850e413d075c1f59b376cb0bf9c3ba1aad0fb4870945c70a4f376f67e24b04a640d0c4504fe5f13a292a32e54df1e396046768c641766cd5bff9ba508fec52e54ae1b05a46090004a69995b01d1a754d3c2e4a5b686f413b5a92e2b62130f37f1dff12d29e9861366a1d379a08bcafe3b7665457c56508e642bce2c202256dcf200cd7488f3348fddfd88529b0ab754fa9dc12a5b545355fbfbc65dd206635f5f44009a1a6a4bfb99b0d5990f33dd67207c2f14b220012cebec72616ae02f60420ca6a6b861e9613d4413977f618590e4f5849a82a09657ecb51477076b1826a6861c21755b9e25111417c13aff1d109f3611102f514487b92700d19115c9d0a24593dea658c53a061cdebcc2f93445565d83a1eb2d8fb8e5a300a98af15b30618237416ea8f41902f6f9b496d31e8d6c24cd8f5e9e305e0141dba80c835802e8fd4a86ce0517b2b90ead1103ddf455a75e664aa3c13046eb53eae20d1f0ec2171e531245e571c25da123dc77e1b06063bc2d890c870fb227839556505a418331498820de7f84d0a7eadfc689f63095fcd0a9b96d80e20a96e04d79f109f59daa0dc831b4f31667a84feca68d2c9bcd0ec2df902f0232e05dfd8f80668f0d8863105171586d83e878d3ae9e87562e2e0be0df4a7540bb1f62d22b28975dcb143384c9ffb7051a7377fa848816a1a6165216f299ac9f0eb3c13379a9a65a37c29a08f7b5ca60e703388040ab2e0f9f9edecac72f4450fa95024c13532a6b7679e1444e62fff8a9f4382d198aa1c0e4e7d0913fd01dcaaeacec8411fe98e9772d2690ea211e8733b68e596295fe0bd30851e067f3d5df139d10e04f95182923dbc7a04d6c17de6a5f6c18103cb4ba19d0a5262f85faba3e9aca6cb5fd9b4d3ffb29ab2b45afad0a6d0124b57629d0c0b1e2b71e859fe745e9254dc898a282beed28c409adc68705812561e10ff93b62177f3a71620b2aebec38c32ef21cc0a76591b5d1a22674d002a87203ea46e237119404ed6ce8ae1b39b961bb33f6eea42d498ace063f1a1f2bc32a123d865c1ba36d0234e472b9a5f7bc7d37d40cd10b08742de7d0923ddad89ea3a503b838009acc9561881044293aae5cbbd4a19190f23c064e97eed720669da61f7c0752ac2a2cc7886e6ab17453299409a888059330ee742b6322734b89791f550bb40bb6cd9998ad51508bf2f47e660dc2b3f922d45e58b98c0528ede4515d416b711c7f4a12d30532aab07aed285075441aca0b029060f93b363fdd34e704ff392c5d88ebbdd9c93f34a06842252d65b63b1ec5ae10c3b6d76c35bd25596fe83515d2423c979cb01c199d2c657ffa60acd52b6dbbb5b5cd6a560155c79efee534d6b158c0a41811e292878cb2f01e257b200730a05c943054e2ae1726ab063ea6780f3838782f41d8cae302566cfe669a47ee88af71320e551e06332a6bd73038e08f24f55b0a01425b1a2ef917f3217846ef50b2dfc6ebfbd9f105c66568c5e5c7551da47065e5d659cd92415b739257a668c958701491ec3bb4266a9061dfbe8be448852f25d525debec0316cba2cb325d1fe09dadcbed33122953fed9b0fed4bf6319f810f45f6b1f58a5ab2dee38b6e777161af5b8ea60008d75154d7d7354ecbbb6b7d4de39877797def1affd8b7ed4d9f0fbf43e43c7bfb116b76ac33932fc27d4107fbc987e42fb8597d8c4bf8cb26af6418f2102cb245a9792760bbdecab359e43905034e646a4affada4f844e4536d3c411e9623ab415aee61f215922b004d98c18e71b74ec2cd92d58433287efbb9700ad523cf24aece6b30d8965c4aef6cc41972859d0be6473f5ed05f476295ee252b5ce5fceb6c932d3e2bf695ba16716b8507a87db37545359747b77426a969d7f10f2ca4d06fbc73bd752949be25b6a56f1829087827b2d715ae272b90d5bc20adf6475fe1aaec9cd74790df01e540f8fd3e93ed9441a09eaeb52c73dff7b71b3849b84ff893a0391c9f0085702b11f16aaba8ff0e3604fb50835b140af2a742b352179c89bfc0d4e013a98bc0d816f7d9c93f37b40b68d3b12835b3d1a759f50c8fece6258b5b11e2bf0bd0f9cf160c5d162b51755ee79d26218120c03909aee1633c3757a3eb91cb3a401a387ff8b24c18f6d31f6c92abff1b7969bbc4ad2d5b7d45c2cea1cfa1e622935c00539f6475204b12173b017887401e4be0ae67061c874d90b05495e68ea178adfcd1328ff7c08f01d61e4c389f1efbb1b462ff8e205bfe74f3c75362fdb5626e9f389455ae4caf39b00088fed13b1c3d43644eeb04f070d57e6b620a6c7cfebb6016c0897f4bd7568dc50cf105fbc9311391ed6bc3f9a93467a151c353986e030228e5d69068b9111dec876a91f4afc5c1c13ad3b90537f38bd235e915eb0b85168199f58b4c6474504bc562771f0833b41a632658b5bee28f371ca848f1636b73fd8dbe0fa1bcd66814b7843ed042d6743ebdd707dcdcd39bcb330774a616614f698a01f2617d236e2c8891d4860373f1917d3d4de40dbaa2076d69394033d8dfdb6caf37d1f53a030955cec1be6fc131cbe153cae0df6cc8646e5cf289d96c4e7f07bf035d10702e39742cb724f55299ab3509009c42934188929030682a837e984135e84bb8b08a481a948e63016477d93a377adc2a804cb3278fac40387bd6677205f9b3221b2ae8cbbd43ea3965b58c78be4f09c71ebaffc76e524aff609021074ef9b09a274b7ba62d601d05a50c31869fb23315d6c5d195aeee1171e15d20454eb4da390970222290fe81b0c9c795ab15a48da09ec80edf7067dcd1e488677b3546db280fac43a7d1cf00af8e7ba02538e711329d1623d925bff89b63829990a1e878c38994d687d46700e2417f18d087ea7ea9698c432e3101b16a0a4377a356ff10838e9c358a38ffae21e36865b199a215b9b2332bd7c920603e27367724c6c2df1292a9b13160282cfdda2518838b1098ab036b4f3b0b1a2fedb939fb6f3e4e5f01317da779f0e780538334fca2ea1bac5821f8385ec1f2ec32b19140c1c6b02860fdde082e5e446c2c08060bda3223c2e8b8d5d2648744dc435d2287c97e31d4ecc088fc2ce16bf4c05a8acd1d59071494793b80ee41d44432de6b8480b664df153a8020e6c140d182561b8dff0edae34acd750c18336bf9edbabff981c2ab4ef9b67d6e16ec5975b93575221e1a8054c811da5dda424dcb9a37c873d6d48c7b3c885fb395892390fb84e3a38fa142fe24f0ac0d434ab14c25072d2de9cad4943718fe1b228592bdd69964c789abf7390c69c1842ae08ec325b6422017d5d23bc69484b70815219f3077b966253dcf87cb17250b4ef00c621b25e1f5cd123c30f04a99516a831e3ade53cb3f224cefcb900d5207e26797d4a44844451c0d9b067485f68ac6fcc03db623dc99bd6395cde143f0d2a3744eeb1597435ff1ad5bd2b50e8a5ed591b170b35415414ce271129aabfe8fa9558876ee508f92e94eabcd2d755986d5793dbe36ef83b1117a7264cc4d741aa6135894c5f5cf751d4965fd55e3b2e17060d33f45a91583d9f08278e4adb71e0e26e864e4e079a064d3583d96871cb60053f611c0284eea9bbaae7202df7cb3bb10e8565aa827c05b307209c890f73dcb4ea156dce923d578fa16fd5db779597454264772701fe9e9f858758750102f7da75791a8a1294e206e0658efd6c26e8965652d4892b7514c70ac83f0b998d7024ea34d515ab93f85c82ee17e43d01f5b7c48cb13b687d1ca54b1640141200800a2f56911a8b8aa82853069ddaf66012cc3f6c1f8a340bff67ecccf45bfd6a9f031f6f37f87d6d963e7f2e93c557fd3f7b3b28f4a672c4ea00829584abfacc4efc1c1ff78574e5b02a8bf9ff229bf1e50bcdde0603e3cafdddb374f19a5dbf4cdc7ec994745951d71ef4f39946dedf04b483c4e8d9e39da357bfef40ee0914dafe5369b2ebef0cf18d4535cf0ee296ee3bfc6bbe9040f71cc361bb368b68e1f3b38a5d0f35b357d1f3e7a54792d9b1af5a84f94d3616e5b9c577d42072adf36e96d8ce1f56151f7845991e93cd2a5f023c42e254cad1be990a36396d0200a21116a7afbf10c308dcb202fe115a264f12084b31b32e1988e892556aa14b68c83d657cb9fd74d80fac6266c19b17aeccd579c48551421065f59f90b0eed6e51a8d381e3ebd2a5fac1e93edcc52ba959fe687dd0bf15a62d271691236bfa5614a2d4bd80a91900b91bce59b227ef8b8fbc2bb3c221b1c9d4afe1926d7fcb90a5193671d2c0bc7f0f9fade4a8c742d8e9a8252056f937a771d53cc75ae83824c404fdefb0dd6dd4ba93acb1c6fcce3b7e0770705d6cbf30c9cdd9a02a6158afa4d92043ac6a2b05dae97856fd0008e417d6345036829d8cd37be6322a20bca1cff5ae6fd08c525c8fda31a151fb1661080cdea5858a99f3a5e25552b194d025048441370bfd12bd187aea4f08d8d340512e61a7823723b48770c7fda02cd45101b1c276799180bc375a6910383f93b60e62789c3407e587322ff0258d8c25b5ca3800a59d5d61655c919dc3ec1d2cc3de6da90a483b23c0587dd8060f586c72d02525b67f6d3857eae8e80ff881660026376734314003ea52e3a3654ea6b3c8b0877266d6239421926fbd2d53dd87ab40df0c19e466c623534acfcdd593eb5f72af43b400712ab7799aadb6f6da7e95c97310aa43d9451097f077dd6cb601b6a4724410864696511d90ae181b71b23af5bb7a2d0129da6d43ab643a93748c6768b5f5e91128106a363e5e020342a7661e8455dacf528d5b876b59a711597cd26110a0175b8daecfc4c646b395342debe32b4028e4567b4d7533b4a5bd22a7eb48187b1257b53e49356e85058dbe0f02a1d4fd1508319bf588ad3e4bc77a04565a3e27353784a3469f0752ed1bc76b49bae667e9d6edc955c53ddca6e9bae21e56dd0f4128f38ce76875ebe3238044eb5668d0e0f730a5b9e1bc2ea5d57e226dba3dbbaedd866cb4ae57aec32633d5fd150cb1ddb84aa5b77d4a686f0a071abf1ea6b5b74e579274ed0fcf408150d359f55be735298df6b3274069c3edd1752e7d732bad8f8f808110b3d94fe1aae62789d6edc95522bdede3293020746ab6eef674ad7219d6738b9e31a7cfe01564f314eda535a6bd02c2d161d4a8d18df93344becfbec845f89fd4a3acb91f32e5f7ebdc5e2709f29f0cadf0bc7dfc0759f5707a7bf03fd90a0cd1dfdef8db5bcfff255bd090fee84dd827c9da6ed737f704e010c4e42ec41f7b77e82f320b1ea2d33fc92a70487f7ba7fff4be1f8028cdbe30b103431fbaa0ab7fbd88c6004fb9fd4af5e0c1be917cc85d73fc4163f909542ba244883507167566c96021699e0754e8d9fc0f5edac2c2d4046b4a192a2681e1430b18d11d2454965df7dbebe52e9c90fa5e0de7efa61f5576fc316a36a17166d84f674080348781eae1d840772156751734d28d90cfd8bdc2cc791f874dfd7afcb572f7bfa39b94fefa9aacbeb2e6d8b11fed667f56b07329463e306c5efff263ac4fe08deb47c963970032bb1160c1d422119b9ad2497ed8a37e040fb983ff5af2b1fb7f80bfabed6dc251e13015dd984f99769bbaed1ec83c941d7e880834c29eee585be12f8bab6978e8f5ee0ea216f27e9daff5079901da399756d327c192f6a48365d869880322e18c572370fe3a0f724bf22fb7abc157fefada15473cf55fca1653a56a0464150784821d6fba4b0b0cad77b38815423bde72eaa24b5eb38a67eb1549061309d134405e7b9fd1d8a27af697beebc6dd580c624a21d7acc42a5624a22ce972f16a4a7c9c401b73501a611e07f285f42747c157ae801b8a2de289924794f86779ce4725a62d91aead5948dccbdd752219682119b45bba2d0c6854b04919639c40074ab1907f894662c258b4c6268f2ce49acc42c9cd23a5c674591dcb8bf0476481d205f8dcc8e8d0f3c89f0c2b5fd1619be27f8accff0745c3f9525a6865b10885b359a4d42f1ad2ad821a1a64818cd3109047398d50be4a96e37b6f5e9262853ee67371d1f8fbfa4e4d0ea4c31cfe6bc85dee47fc7439fa2b78ce2803172d9c5b5962665b162b28422cb943cf1b5b9e78b5baef3a517a9a7dfb372b6a7b8685c5ef8fbfbb21e8000d7be14c738ccb66a631ef7584aaaf4860d0740bfe0fc21dde115d4374e8d5da5d58e96d319179a91168d93c79f1d621bae6d1b792bd9f90812053ca4ed4a90502cc2536cb80008f171fddf736df8a7a62986899c8fd7cad17028b0ba10d08dab614602261ae2b98f31d3f4c47d68de2abc3eb6a4656437eca6b205bea11d53e8142ae95be95b3da8cd18ef76ddec7cb851b7622d506a87aee324bf452277d932e4b7f795e41d434ef7058459d3d0eb7ec64ee8d4954ea0c4ac23a448a20d5794dc2c380d9bb3cd28561104a0bffa92c15436b516a7d459e265472d9540c1c849657fea4b25db5f08d377f8b0a1dda891a8f582d5a585bac33aef7026b17b73e43d8e1f540d990ebb9fdaa4399a9aa65fd4b406bef88025aa7a191dd2554c88ab39a93b696307d3656fa01474cdaa63fa00e04ef19ca1d428e60e2daaafec19b7b505fef43dc6731a6c9e3b8bde6953f40b7678c6970b825e62efd77987ac940706b21f5bc8b4e69a19b717a4bfc659f88d2579cf97781dbb9134bb82dd5ff48752606c331234c1a71bf3adb953b59c563fc752e0fb1e3982f83d01845e654fca040e700e69b193ec82fe3e38eb87f456078e88d5390f0b20cdee94b3ec55c343ff114e57efe2fc35ef73a7d62848ff7dd405f6c6b769349df166b12aea1338054674c358903cf8d8b48bf737394b7f744544d2feac34c37e72c9f5a59bc2d557d23962623bc62fd3efb72b6140e3abf81fb865ca7368ed6d46a7a85f224ee5e9f6884aa0d9164302b3f80510360bf169168ec1a5d8b38bcf19e32d84fcea3be09d1bfc7d701b3fb9ed1d0fd27d9286928501bfca543ef61ed20a1d4bb7631c925b9ac320c5830d2cd81df5f8e8e0bedbcee622a6ffd305a70de82a53b876859b3abebc5c901de69fea666d7e609a0891b7ff40f467483b87bd967f0c6cdab30795e5d715d559c9fb8fd95b789651ab5318a1b92cdd0db88b63736c3f12e009631799c125d08ea60d12ea03e806a438a3557d2fecc8dd28524555f863638676a8df56ec46e602e7122d517ab4cc876155f1fd07a70f50f71cf09a230f5c8864f3f8cd2325a822734953e5bd85aa3ed48d4772516d543e691a7c759ffbbc39d0375e4972e4a8173d7edb990a66e54fc1212888ba79c1581d7bd47e255084917dbf56f8d26058f929534ffb48ac8c558bfa9a8b9db2722c52df3085e1ac2a87660af55c4d5685d8c849c8634ea0cffda4d91ee1674e2018cab89a554a6f8a7d974ecb45ac30513631651af6660f9f45c7b1919bdcbe29fe62980ea659c28e58ef0f6440d2a59b764c30901cbf4afa9d72b9ed69d275310f02fecc99548619ba50de5d1252ceae54035be7437774dbeb7799901171b54ad0d6540098b1667e450fff2ab2e125998ee843e44e9a6ccbaf69aa42a7108ca0ad3db02fd1ce0ee376ed3d0300b7fcb421f11af3330032b4d9a7f22415f3cfc5761776e880566d7ebb32956d0d9a33534d1c3e326b9faa744da12c1a491fcaa50fb5271250a65ea70eb7a5d67523797dc0ac05b7593602a46634c29781b6325e36949c508e8af3e76d84f534a897ab4ec3c124abaa0e367cdf1d06b97780efac5528e477e88ba1b87ff8cc8901babf44e0b19d6f2f0e551212d12a7c995638ed8f86457e555586b1d89ded3506731853815a27fe195ab9dd25788de93121aeed1eb4bf8172ee91990d8b7c9b3dcc48e6ae6456b68386e3c91761d6bd0d43371515b4134bd8a59886633ffac12576c5f3a09d7424de3ffbbbf4793efc90446aaf3684ce09a50e73430aab60a5e6b588c99da6fbe825c7c9ff45449df600b20bf77ee9d039497d61e2d8ab6ed6ba045828635d4907ec5c7f580701c3049b80284817bcca4506eb12cc7b54e97e483c21ebacd67e2ca1b565e119d49c6e84813ffe9da21faddc3c4099a151cbc04f76f22472703e6ec03f218c3e5722c66d3e0988b2f49108a13f32f5445de7e68b10373eba433ddda86816c6bf2acdd40bc07d9cc31f4fb93e4f2c4c0c41d57daaa55b40b8eda685bfa3be43ef755d875e4150870f48268eeffa84e9f725ac38360fe6c036d711cd0d67cbf85522a2c3788fa84d802e485ecf7b241858c48097f055432227d19ad9b1d8a0046ff16f668c50a9961e4d69fe24f2eb0f0d8a215c99e104c785c4f26970e14a788c8ae84f3b3cf111f016610b17805e6bfc7509dbe5111a3f69f7281235e1e91ec8acd47d273ceb0b05740cde61c2c8120f0f110808bd24ac59d11dc3821aca83849cbf868118bf0d7d3f98633f4a407cc4ed7a43d3ead57bdaff4eb2e5bfeb932fba6af2f7bdd0bd4c60deb887a738fcc0dca647b4959d1ec76ed97f1e0b72edd5a63924e0119a1e0bda7706e1122d0d72c3b7e0802876cfca8714a0dd5fde04bdc655a8b8a984e063bb256ea33c6caf8017a2d3b6193a868f6494b506c944c51740c6e1fbc69be9c859daf3f16d2584e374f35fe6b8521828f6023f939c68842198291ec47d82d13c9355a837cb49d75475a6af0c81b1bdeb81c42ddd4b186ccea18a89ee699bf8c0bf77c626501dadd9e59c4ed5aa4d9b03b8e89121bc67dd8dd84ba0f3c18014b75d6a7d5f0eb0981546063bceb4fce36e1d4a869a4d35e10d9cf3b03a7ffce7e8dd94c45f83688e1fe1a4f8f0b3712865e2ebf17064cdc3dec5709d3a1a1b2b2426f4846fe4c19e7791b9b3116a2cdc3cd84cafc528a3bdd167a63b372f9721a46aef15663c7e7615d6023ec6f3a368c1c24661a128d0fb5f5ef0a34fb7a68339d0ad5a78bd3a1fcf0561291ada4fd1269709e02076abe9eb848fffce711b73ddd557f01aab18e773dd45825174035165107bdaba788abae04bd3b2bd56fe1b4107deff3e2e1eea6bfbbfac25e1a277c02d4eaa3f9788a02750468e6b09a77083a6a047e7945c50f979a82f21c49b4c537359682549599251ce618b011554411cfb1b244d6980da2a69a45ef3d1c0a708003e96e4de7e4796bc52ab1ea4a2104a50955d5cb989469db0f2d83230a7024c2be5108e72a04fdeefeddf883ebd6abbd52f757d6d7f25e51b7bf181ed348a838d86c4a54d208a2944326018cbb01fa3b254459404c31930e92f708f42ca7254892a7b48a3d650cda9c609b016bd8103ecf350f35795247f6966aa65ff1929d68ec07e65df15ee9a609331e46676e78508e2bf29a6564abb910a462d88c01fb43d329d436d964efbda59432c9e20370049f04f603021aca40426d32bede257ec8f48ab60a81aa4157d2ccdd0d10cb4ceff566b5e6b9905716cad83dc0e0d21ad9839858a2bf436640a637cf6a0d93600bf996dbeb02ac4405742d234975e5402412c50464504480cc5a6b2d50ad592f7119888307d50e90fb8e186480ec430681206dc82fa0404005f88024401e12db5af08548ab2e0d13bae60908b556fd839229dfe8960a7c7001103ac0554bca21df9c3dafcec16bb797dd25d28a446b06b6edec1b570f6cb01561db85a264ebe11066b6b62052a135b97a259feab4d43c2500fec1ed5e85cc64ece02c6b00aaf7822ea2d60a921c3292946f690ae2fa976908fae1af59e2065204c1592e69e41bf8a0830efa0c04414b53d15e10ec85e400f2e74852d8735fb200638c31c618037170dbf75a7b814a24510014cc8081174a5a59df2f94958562c837bfcdca0ae2b6c13718d61e5435e811fdb7a1efa5ea1544b523093b8ec837f06df50ac2da0dd5a94e6bf7f42fcdda06e1738c3fecded841f7f97dd8bf8afdd6b63e0bafab9318804c6f05d885dc640d35087f4023e4a96e8bea3178aadb92915dc8f549be799341ac576f1200f9067ead20da0b05d666da4276a8d6acd76acd0a69c9e550adb5bbde0cb97a45412cd19f33fdc412fd3fd95620529f8c2485c9183e02a86660cba50c456c2e324f7568bc7ee8a90e0dd5d3f184f74563165169108d8038d3695175104559a64e3d3104aad72b8ba73d05b22003183ef5b61d54b7ee8d2558fcf55bab5bc763071b209ff644d7eb4ff5c1edd55adbc482f6f5c8ca245f5a85aaf20c8492db6fa05fcf17935c2298e905bfc51f13f4afd3a00dd7e96f28d17fc90bbe4978d0cafdb70bbec1bf8086d000742f19e47311155ffb915f4692aa640c1f416b0637f0bb56514abdec81d8b5efaed59a50967cabd5a8b5f65e8bb3d50bf16624297b9d00e2aca621f25497060a83270106d5da750e252e3b10870aa2faad59c1187b4c53d1df1ec473ab1848ba3456df34aae3f27a3a5692b41949aa5a37d1dfe51ef770a5b49a91a4aec7f01152d891a4c09a81e79e974b39c8a3217646926a135da29f66fa095d095d39096146bfa4f0252a84995013dc2b70184c82de0a21279e8cb434835e07fefab58d2ff83cd208ff256f69895c8b73a5dd80fedeea1863bf98620dbe1066d62a5fb71a84e2e4b6d6f6f5be77f6445f3fb982f06eb55ab93a7decb5d6ea4454441a7433dc5a9b0999c94f240a29c9ed336befe7e16bab9610bf21e857129156db7d868b16d2ebce84fd6df6f5ccd6d75ab5745a37bc445aa5f840d2e5caaa2b57c78b935c560a4ecef4c89a5241770296d41a158ebc11d3e58c1126a9ac5c162e86317cabdd2ed06d696eadc5350bb0a4990293142142c40319c4636a6510ac54e30585cb26c34c149d39c296d284174a2d28a6aeea6f6e53a273e46f6559eae810512acb058cd1a93107690e4ec69c11c2847861533170d812dc0d9382b3615c706594b892c2bc4018be5e589a7d61cd10bfccc890993ab2b9954b1232ee4165c303abb284bd345d1b52eeac031b9351c360e0c8b026187276883aaef7f585f565c65a7bf157d8979a6fe6799ef7816036c090c2300c65229810b01e198c0aac0a98979f9f9f9f9cc1bcc0d0808dc1d0a04183860a464adb86e9086b12755f3f92bea270412878aafb52c266cd1bdb13dc8604dc068f0fdc26076e03f5c2060449f925c3502e99626392e304cb41222748154521ded49299941997b032615c1efeb4441b95af1f5f510f546b12f8baf1851bfb1b18f65427078d9c3272ba7cfbac922410c3e8cc419a830b81ad6a8a4d08d5234629cf17374ecc4c098788e001cdd5e71b449f398b111b3e18dd8782e0504dd0af510f35eaa1c120d9c7212888839d7d08b3f73c030db924914762cba5ab0a98fc817cab0501790909faf1d5f38826623fbdb42bab6bd745064806441b946c6b926f05b8304010e95714ba2e23d6b69567344457ab37f26c9c2ffade888271f6edb55b7c5104dec8fb69916948445addaf83f5da10883626b97d66abb61f41a5add65a35bcf55aed07272c6a42d040c66b3d14eb060b55cee6d14d74535a67ae0d9493ba99727572907b01038f4a8e474e890c3b27d8f9e5ac9c2470b016c02a1255c74a8f330e948f25a7184e30e70372755e9c7abaebca19811c97ad3337766e39c99cb95c97b37339b293f8e4a29c5f7250289e3a6387c971a08d0b4d6294f92145eca90d1593932cd725b40e387dd4545184349533399aa74d2873684ecac6022f098a4e812125e5f4713a97b301b90cb9761246bfb8fa044aa795a8988db38d20c06a03a60db927670b66fa85b3079133b73586926918b4502f37627a085503e6dc71622585c8751634e700725761de50aede42d784625f504c60319090ece82221e754e46c3a676ec9d94072d4ca996b1c58ce3267063406addd99cb79d13bfd8467860a678e3e69ab14ec60da0585734c379d39386067aeb3c6ce386797e91044a95c600024272dcc7d9d09c869c9d19d9cce33078637540addd3317427fdd24b754c8f8c335752acb042a72e1b3bba8a9e51e3e53c72fe6893739c233820c849bb7214a4f172774e30c7845ea15927f5b2878d99d30590294cce496cce49ab206970d234f77e3afe63932729cca163e3d52442209783a2d12ed66439c3a8983387651627eacc39e1ce38556270985c4c9933c2c3f19ee73645de9b31c2db21a7458d156c4128141b9053a4ae9433945983f554b726ca8f4adaaf9a286974e50d3b1998e2844c580dd6a8e60c53995b03e4c7a7ba354ed5b6ad55e55936954d69aadcbb01351580dd76c0c2097df29708e3ae569e7a74f0a07a49f5d587a27c78fe8d627d6dcf6f50ad559f40b68e1b9344d7f189ebd80357670f63a9b57660bdbaadb492ade5d75dbcddd7fb3a514731c1370dc4175f4cded103f286ffda296289fef60c3654d043105c41677fbdd28a0278b4c88ee8e08c5b688a02ee9ab01cd1d9d938c106d49c393638f8032fbabaec50129ba366840d97bcdd7a20fb74c794f5796a58d1c082038569c9c834e5851bcc0404000e2822c606cc489a1f7242aaa75b421213d3d10c0b4e06a61647f7de3434dc5c11588d45dd71fa121287ea6a6c097735c2d0b0b9710fda3181799fa73ba62a7ff35274022956a8844a035a98e244513903c74992375e5ebba5b1dd52938d4d8804a703e378e06c06e2ca1a720e8fe07078876b4ab271ed70562f80a73bdc1010bced374afd5a15d501df5ffdf12561bb9ba4fd2c6e5737698ea041a3956fb91a5df022b0d0a0dbc988b3938164cb1af2435503638cf1ed70ea94f1c0b5f8763392703632bb195ffee7e96ec694a4322cd8c6d8c6ec94bcc031afafcea12d50e37e754aeb0fdfda1fa291ad1be991d65a6dd0c7ba881abe25e9102e5bbb530af3e2d39d52162b0fa8c96262430718205be10a6d90feb651f29eee94aadceeeeeeeeeea63a6a8d3e25bbd80a6206d415a8167d6fbd679f375a073fafe14802246bed4d4713f5ad8bdfccd2ec539b01032e7a3cdd291d79513692189293c3d184b54e7a60146cf28215db7bdb12b5c57e6ba7b576f3a8607baddd293d398db0d65a6bed968c9fee9470947894722b28c9f091f7fcc5bb24342f7bba4b129382dbb2dc005b0ecaa15d1294b74f77494efe56ba90e46fa5ed04a932861f729ecca35c799524c3b694d4428d18d51b130757a9848c102fb61956d23ce14155fa50a19c03048a470a37cc183196cc3c315e64b1c3244e0a6aca2e664a295faeb0983daeecb460735ac1dc09f92ac17684a3ac8241030e0ca43978ca3a5f43d8985c593274e52e0b10296617931f53259714be4c305fd0b10389a9dc428a619a90472aac44a16b4c2b29cc912d245009d3c47603898985c8181fb67387c9e6a849c99152a9678f39858e0dca4d0b68ca27634aac2e495e306f58915162a351c47c8342c906aadc72be98612be1858b72471d17e0b84893a38c090396c9c295f20428659e25a610236282bc4082798e50da71812bb5b838ba72078a9c2f6bcca918cc2c30b61830d8784429a5aa4c24165018d2a3470c39b0d43099762d605c19b3f5009b6a23e74c29b6339b6831974c797281c891b284a812cc092f9c6cb83d364cab3d493ef4849993c5ab44b265961163eee11255a58472528a49a2470acc0fb127734dce84a1474639a6a785ad8598e9e4cd132e3364a47809b3624679526651c551c13403a424c3c336c20d332acf525925cf0b5b0e3b5de2984e6a82982959f8f294432c5e7278651aa932674c955ea24a273e969e909c34c696cc2263472ae0090266f2e82acf6cd99ec6bcf0a2bb6233e1aa6c5255de99ba1365d2f16112792a879c65f02cd5c073545ae1319bc06c4d5d65922daf315abc9463ae985e57260955361c53e59e28b3ca8789e7a954e1b4b9b8b364cbdd392aade03901ccacd2d5c25679648cb98217dc9512cd559baa335368a24c2c1f2d9e6c36ce387696ca37768ecc1c1e9b0e302a5d495b25d718938917b3ce95d2cd559b2a38536ba24c2b3ecaaea71a67589d251b8c3a475478cc12c04c2e5d2590ad126c8c69c38ba974a5c85549a76aca1495a812061f604fa69bd34c23b654fe103b3212ed9e5bdae798835aabe5bf0736509d12580d3a005aa7510fd5ab530fd53fccc822ec065f39f8aa0297b556bbc90e94be1d010d61bd7a394443d0c7b7471b4c82bcbae184e71774a72d4f773ad63c039eee743071acf7a7bb1d475ebc333be219fe661eed5e0ad0f71cf44b43d06f4f71ab8ba8200e7aef44fdea462060f1f445d4149e57cfbda741f6e2f0edba672f066b2de8b1cc2fedfb482b0b41ecd73dff2ee897e679d05f32c85aaa3abbbf5eabfcf5ddd31a11cf9a7641152b8a3eeb4645df5b3ca2c0d6abd75eff76704c7167753c71ab4822530fedf4b675f2b9f7f50718d93a55cad741bfde3444e8177c9987b4a29f6fda4d067afd79f8b6980e281db86ff7c6beddf37afa2c76fcf8023cdded40fa158d45b0bd968d24ba7be620f8854dde46bf79ee5303123978947a18fda3c93c9016f41f088e34702cd16e5d846d1c1a5ddc0dfa6d44e1b9d7f5236ab7fe91e2877b3cd1ee919e75fa91e8d0e4adc353a71f60e4a29f6feaa1dbc11c93173d0791a72f6281c23d7d1c632ff3d0739079d143bff9f82d8721a9211465b4998fa1e8216de6e38c06bdcc43da8d05d8e1cdfb79a3fb335f711f03cd380061fc83431f1f692038a290b948fed06e78863d4f45d1087e74a3eb9ee823f369998ba3e8230d4d84a4e83ea2288e331765b4cf7de8480b7a198dbacf38862842b0d6c21926c70e2e7bc1040791a7cfe28b3ace53fc2376a03416df23099ae74d54bdfd03699edfebb74a3159d46f9d08457bb56c70407d88a7bb11b27ee714e694f51d3aa8e8dbe79ed7cfbb794ec7122568d1a2858bf7c8d9075ceea7ee7d14d3a0ef403d50f77639afbf4ec35aefb8c147269bb94fb563079ecf3ae4b16d588915fd9f7f7091653ec296ff5c7683cc5ff1861ddc121b464a650ecedce83ea52e8e764421238dfa3b45ff8cbcb5254bb47b200d6560fd3c046927bc15fdb3b65cd7ed05afcfb07b8e6d4561dd5e9a11ee6641b463ef89e0f5d89b4c1396af1e3279bb3b897cf5d0c51fd0fb1b4d84dd32df50d44fdde87e7bd1cf37e9e2471a759346fd94bc591abd61577122bf08d543ff42af5eff0b7d457fe8962422896827784abb854e43af2e86e058f4f32250eae1665358f2d63145f5108734a3fefa3d82e486131f1149547d453f2eeabf41441a74fdc3f5757077425d10cc65592b55dcbf95290ef04d0e0de0c38d6cade592df62aa00a7d4baf776f616c4758f8487e997a2c5ea15df4a5e3a14f68d1eb0f803807e1d743c9e188bdaa81a358aea449804bd2c22ad208aaedf0bfe54500687d935cdb94d5d1f3edd35698979156a674349d3111b53029023a804cc983162e8146d800093160000180c08060422912446a250dba90f1480076ba22a604026a74a0261280a83180662188461000040300060100041188ac11854fc696ae111e10cd10d4adfbc73855d6c5157cacdaeffab8fd83d5225acdcdc68de077071832af5d2cdfabc90ca8e2f7f8c1279d154a6e33d9d7558cb590c132fc61a6a10901aa598ce0cc1f20c0ccb2640a9b6728ea42ba70bcbbf03fe651d285140cc105c091dacb07029941d5b2f1e33e25c8b669a1dfc76c6e6ac9840555cf00274f7292556e0b781ee185bca54e5e5559c2475ee2120161b6c648dd381deb760b75ee8d7b9eb6ad3e9a0d46f6f4b2f1cdee79429846ae5f5beaf9532df5bc74d7d3181fd89326ed2c0238d99ba2300cf3b1c8729d8563f61c925b8630918259a2b756a1069717ea2177a486599dad36d5b4743f8d45b02eccf814f269d4916990b8615c0150c1805a6a9cbe9367557b336dc615b3773ee07ec408d282987cdd98a249f89508a3bed15e2d030f1b7c65196289326d671f83f4c878ac08855dd3d15145450e449dcc2e46af93e83280e881ac1020d2cc3a45c96ef1714c1c9b4ce3e988238eb9141308294b8486afc40e39761217f810a6ce77e0eb6bd62d73bb0bb5e9de13343551cfaf0293203fc8ed9a3d3179c0fceae403a7d1ed6aba382889dd9c365da81c119667005bb2a6264678abb08f9c4f86c8377f47c0c10759f5adbf434f2d7a12ac4ba24b2c88528832468a6dd6d7603127a32bc643541a8053100f150193110540072110aa43d4d604e40eb86f280a677056eea8d98a8091b66bf68ac3d5bbfce958c2bc68ddf448399cb0e2736b27cbf2c090e7c3447f81609b8fa5236dd012b3b2e7092ec10984d1d100d3e4cbdfacc0a81f6b55b82fa622ad9fc8283971daacc47ac8a602cd2167804472ce35b200b78f860d56d07c8bf43cc5c36226dfe2e8603a3e007e1fd3ddf6f00b8a51595b6d6bcc8f6586c39f7f950014c6acf1d7ee5dfc5b21e7639f2faca85c490d85232a757185e1379443f4766b451b3978dcf28afe121259f5a428cfb9b8a05fd9dfa241b6f91df05bff4a848e24d692ed71484f1d701dbb6240c88174a71a434aad0b97aa508af2a69839902773466c15aa40a7e8ca38ec26fb4e9a88d3ef3543582d0950342440f1d07de537c36772a18692039a61e08724eca09b2e20a6bfe040f4c0cd8cc82f0e68cb5b8cb10f300857a0de483f3e358fafb7ca02f03c68657034be02aaf97dc25cbe11021142143908d6ff1517bbb0380726303058f17ea7a30baba110dafee98c9a78d0289b6ab0c425e5b131539ea8010898a0ccfda467de2acc708de1b9305bed8fee4859cc9b998872d7c3d40427dc96ccc69cd5f37ea15ab0c19ba41203c47439b7dca07b3e5849fd63221580870aa7f1b82d297dd3be103b97117fe3305da99aaa26500d855c84a1bd93cf9264cf7434dea47152942bc4684482632cc0d2a8da1d03804eb8638036b6985d590f6dc058877b64e9487a434499188dbbc8fcb1a8e226da167e70e075fbdf7c048916f998a9f18a96f32da0bf692e218396ae83dc27fa11a79077bb774e01c0526fdeb10ac2d3c9d01d230d23de224ab256f81d95cae2704eb805268241aef58b49834cfce937034b68750c284ef428d3655ebf60466ff44253edeae876ef04a7308533c65f3a2191604fe675815ef8ad254ae12403751020103a396798a16f409de6c177c113fb874b652893761f5aa8c06d4372431fc9c64b4394024a02263f7e842c4a28b36ec22ea43c877f561526c6d4223e0ccaaf6eab4b6d5a12e11af82674ebcdb3e5889b5ee4eb65b828ceb40c77c219825f6613dcff4ea2a0e0d16d1664db8be1aac149300db70f56bd3b7d8406a156b11107e30d626d10ad5fbb75bcca7bcd41f140fb3421d85e5103ea54945bd62d5749a7a8423c7360205160497a5d01cf00bbbb96cf0a03812aefa0931a6d6917321ea4591dd0b0511ecbff0c3d2f7b4c230ffb2ffff626608b94c6fa52a698bdb39feb55787a42fef2ae9f537adb7d501c308a5bdb9b989a9fe6b57f3b49ae23be0e1cf1cb01ddfce3921218a2dc91280dbd7b89357640a411a0b9f52a181364e7790298afa9213bde4ea2c53f71d4bec974d3e234dc72a791404ec71b1136e8c7613bdad0a6905f138d70b201d85633374c3f9731ef882e7a96f0939c5238d25c881cd8050ea74cf1a34c6df452c976e59fd4e40d99066c1ae90d6dd1352bc401759f0e42a8abf4adf5b6a0631ad27b030c6507a22a05c8971705026832d817aac4ea137775eebf5199d576358929b989bd6673f3287903d8509ff64299b3ef273ef634a9e55c20e7dc0bc7199779071513d208746ea4342d61b51297f052a79c589f141f6b48fb5885a62609d4de4aba808de60b2bea5497b2599df07bd949890766321d1fd058489cf8c6007b19694f57d25fcdb1a1742cb12875d87a381db63700d6f236b9dc7a2cee5c5e7f93ff13bb92852ce48c39ae53f3c1440ce67f81a7744082950d5d7e2a51a26fc946437189e0e40de978a6ab75ee422d02036efbb1b301b35b071867907547f39288f674ea7a324062ae8cd21a2f510d52a46d6ffa945b3991c109be2ec2d87bf52471c8f25b4c44964ac3864e66c12b6cc4b21198f8ddf31b33da55434e883a41ac67fa30a872049cd9cd3d8845b4de12aa4f25ff08c414f9e142d4bf7ccb32ec6b4830a392ee26f58b33cfd46426017271918797bed8d8f4bdd09569ce95cd8224c843345b67e4d1bc6643d39e1813bfeb1d249249c56e445d599ba67895a07c43fa7164723078dd1d15c1e9a6bdb2759666c06d0a48b9cd36ebcc7aaf844dbe2783cbcbaf3826f36b7bd63331829a9e5a261044adf67f1cc81a01331cc06ee82b106540203e234cc3e20d36c6c69d5ac98c930b87f633efcf8945b08d4a0c9a8a43c37d30eb00a4dbd7b61a925a5ac77bd835c4cd7e3ed79bf85bafc44ec9d609af201db1c6bccc60ce906ad489d9e9674a526cab6d1c23321b4c097054f62f65244e6c0c7b559d85a45a8030ea72505a4fdb5ad856177eaa9005d99a8b42a9885af4d202eb0bd029488a5019b0f31abac32b9376389d784f8d4375dec91a61cba3fda995a65e3d32adacb5ad33e1819f843c288e2cbc0dda463c69b0653cd530da60a1c59792b1ecf899bfa7a9d8fedbca79893e047a31e925855e70ef875be3d1eb4294eefcc6d1b38b092d854eb75036bc24bb5475a066ae517b0c869eb91caa8a24442f68899ac572c3a81c16eb4921d276afb4ce383f741f8086f2210e3f8797928702898b743a53c5b4d59d8141c420e221db033f651634ecf23cd438eddd1b3d9517f1ad3301b7d514b68d7876e6fb230092a1b5eab1f8c9dc942364eee66e1732b188514d13dfde661ae15713916075a818e245c694e46fbad8a73e80f074caee4ec23398a30f83b0e76731f2524a8e1893fbbb38cee05a0f159ff844817bb5e22801c6eb222bdd7b528476a6c1920008cdabace58c39f5035be4f5afcd1a294a801a6f74d42b20aea1440aad492cfe492a60c503f4eff54473b9a1bc1aededc5249cdc72c7d5bfa1440ab67ca8f334ea48c93f7616a9d4b9514357a2e55b32c4f63e698d22d754b10bfb81c97966f138222445ae6959923db6693ccd474dfa64767cdc863f20f2cd1682b1a82f03e652a9c5f080e660ff75e4549610143e1e35dfa75d5bdb1c1bd982873057734dbb6530894b52e6c9912c8b9d45182d89d03208974d0b8749a1099cd4a3c3317a5c8bed30eebaedb7dac9ef639f070642bd6013df7b5cd1e3b71685bb1297cc5853610912173779da50f3f5dc400d1b30f55208ef98e7e401fc5044421fefff76913d8779e11e93bfa38059a96cb755ef7878214bfa9d04526be9866ec0d1c136fdad2da0d20b60e4d5c5d73f35dd8684354afb2b4a44994f63846f3a0d3b5222caa64010772638ce33f271a7f03b649bd8ae339b5a2c18fa4f87398839c87ec7cb41dcda1fece1a80ef23c340593706486b07b1e18d80f827ceda83351477e8ed76d2375135df7626abda085130034f22880e054d6f84f18528d81c5adb32cd85275d11758c30ae049c7225ee1e0311d04db57dd4af396edd1bbd36be9ed649f12c82e1065393afe5f314c8db69cc2b4f8811ca4e63115843018ebdd64a6879c86fd4db45b5e452dd8c3b58490081cd7b08c9d02482c9c20c3d9bcdd15723bdef419732b5c417dbb7f9f63d471a287a80b8563e2c19692e596e5038abe631affae8b8866e02085530f33dc65ef6031ba69c318ee631cbc0515c723d82113835ef1d998c264b4909698caf265a53630897a2a495c5c716d5d8c542e4233ad5d542eb18eb04f0d00791e082b988b574bc3f128f9704ead41cd77a9426844103a98167d44d97ace544a52243e87c04e2d94d18cb89f0754e6b9a69b19b7c7bf4c58b3a37589bae0e8c8ac3e927a4b25190d030b0bed72c0ba734409e3b68097504ae3b1f8a48ae31e323b0fe4e2a4d7027d0ac60acda63a2df71d58b61c418ba08b0ae987e774c204c8ec405126d35e30b300a838fb01444b75f7fda0e2838a3c749c6b9c8cf04dd644420a278bd85a41d38b81376fd08300f263e09622509dde9e1d751835efe0d7d56559986d160d432021dd8df83f3e41e32a9058c54e60994f8cb24978289123316b9679a738c056994a4ca0b0aef3fac7013f7057a4bcedc14765d0ef7dc85013dec130b174e3c13e266cfe592d74496f1decd8598c8db4763abcf863c878c6cf804f4642f306171163a8ee22ac2d1ccbc1474467f20f508bdd7098f732c60c8f41b303fc6113cc74afdb0d8a8af79ca06ded9c1497f6b439bef2e08d0d36a6a03fc0888bd6574017c5c9bb845aa2723878d0857f7ad68bb4a9695c7ad8f94695d6d7e4a38e520ac37b7c7c1862419144a37df5c014bf1a6af88d38b2293b0b2792c52a82f7c90081a0dc47cb1760521b1e52259aa8452a46de052d92140987b1349d1c58dd979e0254d7f54ce0c772c3dc9f5364f3fdb2c89de47b390fe3c268438b06a516647b3aba8e9959401ed982bb16b901f496afa453e5d6b32bf9171c93f48cbb3a2acb7c85c2ff7989c71b011db0e9b6d61b62acf96b3f08619e84fb1a0a5cc13ce9aac1bbddef4f8ce4f285c1b975271cb9c422f93cd869019817d34a5eaa920faf2d4b24df84e4a0bfa8670911c6f3a2c42d6d46c198a021dbbde9d046e1451c5dd60c5b5bd27344f4a80799f54c7526c7f4b2746ce44bd45cbeeac757c26fb9660a3587353c0aad0633aee0e4964d08e25def8072bfe54b420b050d282a0c3aa32fb2b721e96d09bd1f9c48d66cf325de169cda579b32f3ce64c525c773d0f79d54b7e17e0b17eeb4ab505d72114f250d61c5645b96e7f612524deeeab54c6a0bd71bd661864fb08baa6e2a078df09d9c683f13249f2655f4d018a83bdf4562e57874e1e34323d47a49e67cfd546deda6ff61d1130b1da5694c65723f416081d3b6d89f2a7cfb4b0adcb46f6e4fff19877ae73cad32226ed0458479ac746d41a3c22b45f1dd622856eb457ea1e4a0d283276fa9d91131b4e4e02072a17cf9c2b6e5d4953de16e98e34052b61c3edc5efdd4a22989aef84692c3eec2171efac1a43d46c4804b506a4cc3f20efd2e1a8383cd313bdecb2840899b0c49d74f753eacd82fc3f1cb1ee71cc385a84837be940b9a5b16da816af903ffcece73d13f6e993c40d7e9b9190d917046adddec151a39315bc2f9550c75f0c34d67d42321da1b751fcdac4c4de99b907358a19584069f280ed63ae55f3dc88eb41bc1a75abc9490c5a8227dbd6a79ee2d481c4fdc1989d3c4f751a0ae5e14b9dbf4ed15de08ef136c73e517c36a28ff34f6b5e3a4c940e6f5c07990eaab578b23c8faf347eb4acc01177534c20596a8792fa5661ee71b96d0dc71419a2fa94b71f0641058859fc6273452ecaaae827f53be886484806f7d5764fe0c38ced1bec1763a8c6390b2563ab10bd05a245b66c9af386e6ca65d23ca45d8f8ace2fd12423e62e9152fee9079d7cae11ee0c46404c63f16ba36d3269c5da10f215e23e5cc3bb1bc26bedc6c97e77903caa6f4933c07629f00943aa6f11a79c443bef83a0bb521de7439a2e061cc09ba5d8739a15a5196e7d58c9a45f178c59dd9162efa08e0837dd0d3ffdb3f8dc0755158a8ebd9e7d482e1221b461966a1536855eb9333e1abc4a5ad08e5771fbab8389c10e5d13fe08f5502abc93735d579031df138cfd4655067855640cd072c7ac4b62673cfed9288feaa01a539c6e1c2d0783946eae08666b6efcf5ec235a83213855303ca62777f8a70dbd9588bd7b2c55f4702e113a1442f600ebf58410a41a685c4d8a99dcf81693aeb1d7fe9647aac1cc74fcd4f9d3a40047c4d99f562a720041283d6325943605fd7c171ddfa2bc8c82cb737beeb172c02b4ceb2bc618e63a86bd1c3d95cfc93ace95110ba10286d1830410fd85efc91f18a9cad9363b419e3a28f62fbedd09c648f5bd30095a7ac99ec7fe4e9ff83502a40a6581eedcf45a2d591bb0bfdba27f6b2f27486ce5a095102841bca9e1c09043f23b71d2aaec20dff05c63c222536acb6efa65c672062b23fb3f3f334108f6d36e2ec5fe0df601ebc87ec3a22a4944b6e0f34256bd081cb00673e0c6fbb9f47ef25965bb915629560cad0a42028f607b5905aff98c05a7e2ae8f57249a5040da96205f343ce035a89809c780b81e47aa17243d11083460aef2f99e399fca13aca616b53b2f895e37aa65efbf75a30277b8834fc5e873149fd7c666d2a6fa281806736265093ef5ee44c3ac18a198bd0e7b582d253388ec7a630ec1ee924b60721f0b48eec1851c2826900b68815eda050274b4f6dcc7c6dfd4f1e0cea735a12bddbab9a9b3d977907889782200a117f75b1b8778b816075e543571dbe5c96d11384bce3f971772bab81c616dbee9f29a78acfa3c5848b5837bad7bf192660a403dc88ac997c4e941c812dd4889402a349e02ee3f56ad1108e8c824c58f2b8ec01582ec8239e720f0ad16f10b5e14249364631e181e626ab5b04dfba6caec86a3f05f5027171c62acf2e1c2246e4487d39655f218faf1519a4b6aac9eeb5a2b1de13c2a8591c234a89fe2e04891ede138eb07296704451920370205497dab2db1055167210c6345eee3aef8045d2997921ef2a240d9fa8540b8c183c1ca36f44d5e8dee48a79a20a5a314609e767159808b47a4c2e2c0389ac983be28ada68a5be3db009d2e233058a0e9eb887203061f5b0b1a567ae91bebb30cd7a3dcc9b86782b838fc2509ad9ad6cec539bacb0970f19ee0d66d95ff0a3e7de0ac74037b8f9e73046e59f95bdb146499a176687bbc6f582dcfa49013d47a66a0a1a393c10cc2efe68854a1e66d3a25c4cf8854409dac16c0d82a44de006faf8133b9c1bf2ac77aacc6809707416b037a94ace98895a81e7f3b815a2d03bf08f6be3cb2a5799fe1d46fea7c61dbf9f74fd86549e24c686199fef9275c49ecae94726cc59238b2ada8beca99b882ed9c6b0b6ae9829ff8401b8d28edc4d3996bb17f209fb07f446e0821b00f1dd3b00c78c214c09d2aa3d769ee8539a846b1dce63d83e93ff6ef37b4e932b9fbdf5c5c807d02bb9f9e26ce61c44a3184f2754d61a5e791cf609813e68d498541ccac3e5a4fdc134e8fd5062fc075cecfead1b846be30f65e15a95619fdd85a11fff33eb5866150176209bb004aa0070190cb867409e6b01e969569b10aa9d9846f32209423de08368ec038fdd46d29217c11b408c08b003499c526c21eb776ae72370830e2c7ca05178141f819de12234413218bdf0fb2ede2e903ee0610af440143f41b30411f18e7609abf9dcdbec32dfaeed8cced654efe54bb2e828a2330709f3d3816703eab66bd880b27ac724df5108de342f9d13936c40a84de311a120854373bc648049c15579f3dbaf3e13ebcd62e703e6de78f8816e64f1a9712e2fd08ca699f1a6a17899f9a438b78ef5b01c1672e762ef253aa0e43f7332c07ade707610e2808fd8b66c29c115f81fa6a47418e0effaef627bf0e43fc33b5250594d6bb759fdde53eab960702882158e43f747456e07faedc73417faeedeadde2fcc039822196112f840888310501c1a7b97370d11fc372d02e458c7c2ca89bdd92d667b0bd25e8020d2ef19e789ff5ad0f4231021f041b44244255841e842322c5113f0df3cf9a2d0dcad266854014e4f35e0e63f629ddce20d4053a8ebb6875e9afbafbb2959bb2deb13039ee79d52811bb11e088c0207c76e05820f8d49aa54400fd7f5cdb2e9e3e076b2c849fa4db59c43bc4388269884d107f10e940203e0283fdd96c592128a09a7411a6407022d409c102e1134327b4f8437351237e1055bb5e7e6a49ebd6880b7d29979b870bdf02cbe7c78d22744238431c8b3081d08cf823d485c00f016c0486c8cf789d15621f89a344ac4e88a0cf4f7b4b4704a04f3e436f17a84f96ab4680475c422884f808210e61265c248dcfbf8b17741c250cc048264bd21dc6c2874edbf6574b3446a74892fd915f8731fa99de9e0262d16d5c68ffb88f352df89f8a70319da245d6c7f706a31118bacf263a16909f55e383501881f808b598fd17ec2673f70e2de957be63c06e932b281f8c5383c010e88a37ed6c8422e21191e35f3721fce4c2816a7fbeb462207420441719e14054a1502c84b70d32a2c5c347e39e42d4e9074dc999136707f904ba154658f14aff68b140cbb5ef2bfcd06e2915d1e2ff09b6abe2f919b7092116205e208e20cc204c1b01d4f7c96afb84a0c2f4415a3739ea936d6d1174b1baabd20bfbc7eb680c4a1f49bb5b5fe573afc98b70401446e023b622a0405040ec8350cf8816a34fcc5608840294d4900db0df68a55fbafc8c65cc02f5e43cc54d5b118213f14e0446d18706ce0a854fad43477c10aa362268fe73e0e221c48df093f823b841019416a6b9e1c4533e99561501200816970f953a6a9d3e15d92e923f2bd70da13804e0d715c924b9f94598223623a6b7be0844f976408d98a1dd828db8618c9cdfd743e1db1d73004ead119cc5fad16eac880ac4dd0807083128be19027a4b71258e1ff68759f0d66c994b3d18a323dcd18cd3fd406a67b04d11f9a6ba33f81fe1004676014597d65c88155df8aa582d9ccbe104f904bbc208e5106e448a44b460fad41c6a08f17db5444ceec813217e562e078218818f48d60f8a7db20ea351f273e5ba1157fc73551fef001839445f18f8bcd0e4a3d14d5431848ef013f80fd7883081ce1ad144b06810c67adc093bca4985829345bda9710f90e7d9e0b721cb61c9668aeb3366c6c2656071dfc0de396942d496aa8534524d91816a37785ea7b69e1632d42c2a8082f6c12f6023922e74ba70508c6c3d8dad4b0feabbd3855e720de3e7c033df67e219269e088187828f76292525dba9f2f02273c4fa3e72acaeb1f17d5d06ac51f942519e752883cc8c104a31ca6dbfb0d0ad27056cce2c74281dbabf04b164849eea78bb0d563a40e03af63efddf22790ec5ae19baeae5f51c9ac1cae8a9668937d4fa622593724a7cb20ba44965d7a2e73f0a75174dc61806c13c60756e02f90537bc085b4b5bc2f02329b9850037f6e4f22f9af210dde652fa91af1d5f35a972d2c2f29b3ff152ca6208cd670a662f7f9ce18c40877aab9f5a23f04a4b4e3013263b42d0be41490b6735c105bb62f59e221a3f7835e5a12cf6781d742643e8c94c4581d6ed1df6022d46aa8a570c44372f61d8473c759e464480cca582c34cab1a7341215aa45f418e9bd52486a3e347a6ead63944e7dac11010cc17783a52b2d843d0c56cc17d75cbf045e3773eb550c54a4d7b3ce7ca5f0c3b308e821abed32e312b104f1977cb2ae372e25ac8bb2bab65c1bfb128b14497321398e3de11c120044641a31b42fef43dff86cfe76fd9cebd7f39cb4d455496019d4b289f5da96e04d061397a11243a1cef3080f5e1a9c1e15da744691101c4795341f017cbe057837d3978085c2387a53d0c06528895e1e428fbea0f59518a7c0d26fb2674c41453445fe7e7beff06ea43a92e791cf61584c5adecaae6922ff22125a0eefe3fd6b102809473f59ee10b63178a7b177b358d86db064f65b867ca6e8bb5002a921841ead9742607aa4d03f7a8aa58b66c18066cb0e22572294f6ee02d45289e277b0ec81e36d3d36863c9566473e18689a202f15a576003f8ac00f240d1b0fdb6bcd0857a6e7b86eaa8d277b99e50c9399fd48a1cdaa10b63c57506a039eef84e4e922c267376159c66abaaffdbb186b6d4f691e88e01096f081af7add35a6ab5d5bd259549e9672d48f7b1c8be26f6de0cd6fd3eba1220dac1b416752d3a4b46ac7713fa55b3ee3f300c2df0f08eb5992ed682098e77128e86de69978032b80a0f26b909b04c3b546eef6e727836a12daea981ff85d0f6d3e385c7668be1d2e422a859ec0e921e7dd6bccf144ec4fa805fdd037905708732b7f5560810661d6678496bbdc706201ecd62c2b1a02302605dad60517727a20679aadc708d1023db52dac037851174654d5aee99c8c1c633e150c39a0cf06aa4dc5e2cb630f4d492616b288f3ba90cb38dbae6ccbdf9e038dee09d196ee63df81b309f644277cac67154cf54da4eb71fcd3c1f5789e73a8f9eb08d579e2b5bef842f0330ccaf29662ffa74787ce4fd8f1e29dc46133088960ec5cc62528f4dd0109f5720d5fb88d13a3415c1be9241085cc1bbb6c5e7e13cbcc1d5e340e91037b99f62001dc4288ca577e6586e5fc4861e3290fbc9baf51d78ef7f46720e16bd840c451e99ddcf172f27a7b35c6fef2e3c82535c9aa6f9d92384ecd130a49f6454c16060525529f68ee21c439ea9b1193f8a5cf7af1d0a09f4516a905b138283c05ec1c03aa4ed05d274155bbf5d5b7fad5b1ad1218788d6646543b7cf5d2b85cd366c53ce0e4fd7287047c7b2bf1d2a79e956f0af1d99ae73c92dbdee061f71e4f661646b1c8003c4cb356b5f25524ea1fe5ea07196b40c2221dd2abc4158059b9122be16b618c64d05a763106bc07882ddd768ce7bc0650ae0baacdb227a7514bffb8336b7783c048603927abc8201cc87214e24a7b0cffba678726b8d4dbbd590124811b1427c05fc205d37730a9914140ddf0cbf8573b05753da8b48dff27b6f7c7dd5679db2f1dddae9c7af267c218c62fb9a7729c846e2cf29a0f11140ecd658b5ac6e36b8ae8490ddb84a07214e22824bc1da031cb9fe4549ea348434b81c43c153a70ce1cbd08a8bab1c8cfe4b0c052d17ea21f209e1118525c287ae01a8dda41e658d16e8f4c015ba3fe94002a376311e901a18d15a199ab6e16c874089284775ce7594970a56836ca23ce68963c9fec58e96590a81b41b37f17486065e0e3f472549d33683d2ed59d6f968e08e311ed075b19590760400b20c23aca3d19ce1aeb9e844a68602b4515855e5f1b24ecb1c2d9aba5dae071fe50b4863e3e9723be9fcdcb60da082c68f3d7758b48333eff20fa89bc0aa46db3fe58df6a19f7d1d46ed781522c7cc0abfeed35736572dbb640fdb980e604b4ae5c6aedd02051adae4d77c9e3ee6985cd7542c50bed2aa89658e9f3522d7f47baa55e9f13ef23cd98b79447f27f1192ef038aa2bd2cbb70ff4c05e27dd8c645dea92bd070675cda7d7ad8bc0c2e3ce6193428815ebd698c6700de565f4ce8adb9812373582755924d124f5a8dcb9d81b2f44eb2acbb6d73c2b272bf310bb9e67acbdc84f8a6c260a85344ae80e3850c9a0cd28d2225f0bee6bb3023adf19fe1c224c16d3ad0c238b5472fe0cd50963c0140e592e9a25ae7489ac89c109492c885595f80b538264b2b04b96e74b57b9fade342c1c9b6b18c9149665edd7698c8e446493459060e618d80a9b8d6619a0b3c8b2d621f75c598de46004895960b53f09fa9d8cfc9d3d110f0deb8ec5521d51953ef6f5be2b1a2dcda9a5c4cd3452bf3f13190916eb4a5e1d104f1506bdc8e8cf770ae7a2bc2d6ac5b79eacbf4c6c05c45bae4f447058d4e1fc6e79769f0624ce03b8d267841ac2d2fa3bc7c7c62e1a634660ca15eacf306932c5462a6005e08aaacdb4fa24818b911629ce0294f3d5026c1f53a640ce2ecf177011235d0b119c3f957e07f1b41189a265c89d11c904ea69bf9c3ca62ad86a17d9ca1adac34d2da70756712e90dad7a4a66fd6bebd694088b53e77b6ac51a9396af2356a77c5e67a6c53abec0a6f8a0526332dd61942a4cad5bf7a9a8ab88aa5e5fdd9bec59f9a216d90162e1d64b5742ecff9ec71695a1ce4067978eecdfbe9e02a47137370bf21b931963b21002dcd74eb6d227419154b8ef69a70eaf013eeda25eae5e2137cb7e56337b32615bea5c5745d20da9013f264ee084af59f841b34cd65228fd7226611f2827be14ed1b0f5c84c56f3af448be1e6facb0a9dbfe1dd1c8160d56824dc12f5177861c7496cf06868e4106d7e14eedad125f216b6712818fe4ce48606fcb79d6f31a56606384d57d5429394dcde3da5c62259d35262b5c5e6f89c7694e03dff1adbd75687d829a46809679488135536786406d6dc269d4c0734f04f1478fbb1cf39facdc42bf87cb10450acd1c9fed1f5a10e56be65eeb4ccb19f4036de83023047dcc2de521a38ab690c6499c113c0751a8b09c73539c16030e9689d52bdbd0cd8c4e96cef17b8b7fbfed1f6bcbf61f9384aa415394febcc05b1522051710e4647fc027e8be625a2133c691e48a309e6f03fd81af657d13a0b243f5a37715b31d9af8d0e45d98122c0d1cc3f5371bcf25ab655a3ba0aafe770f0ea8d463f18220a522b0827f52685695ffb9d470335e896d8501313ed174b78bf98b3ca6bf0a0f1bd34a814c4153ecbc4db6f4835aa1302b2e41f15cf1d5604b730cc687f502f73dd15a84d490b298c8e9d77cf0d3e78199f63084760959e1ec7fe0158ce978e22e99714840f1f425ca2e3fadcd58b268eba294b89f5a6e799b71dc4a42b47376527678ec25558a98ce88fa1d0db7341bfcfcbb94e1c520e5c608e6417a4ac1dd03d6c6143097460de87e9c5a3d880b770a294140ccd9b4fd4ab73b3b4b31833a4350974b438378614420676ed08f09d0db01b8360f6d51a721ceb74d91bbadccd14c122612c3388942f7272515262179a08aa4d9ce0353c46ea7aa09c4609b7d4704106941a5687148bba795e1ffb2cf3e922ac1f3fcc448131cf3f9cb21b157d88fd6bdb633b8e216e4b3f3e6680d689f11124a8fdf78506f78682978c367354e234dc8dba6ac475e7ee6fb3c9878e62f9bf09bed28b7899423c99758fa49ef322b0851fbe24ebfd2314095c9ef755895b25439a5f7db90a99521d1e7947db30efe84c51b5983329e62f99dfac60327fea0790031d69e1f3fcbbd2b0598b9c6f2d318f26476e15627e26b0d6b27ad027a50a832a892f1abb7cf21d4bf9a6fcfa05a62fd4da6aad5ded61ddddf405196a55fc552a782d2ed840a065d0a925a1b626cc83f3d737e9d09f6af0f678609f301efd750755af7efdf383003f0d10df0322547aaa1cd2c0c19598951da7d35d1abeb3ad4b720f1dac250075b6fa5010573fb8efd79ce826e9c97cd73d78f088f4a13efca13751095d35d816235ac5ec0a324277032bc9034422e354cfb62c12218546c9896316b456f2473f0647aeb29aed0463389d1d98c92518d3081c49116005ed6d9011d45049c448fd8bcb6fdcdf94545df8683984a5c762654b391d629b68ab236b62d1c3a00e42eb673a2ffb48b0b36bba70dd2b1789431130b0bf3837e302d1dcc45c5bab0aac1204fa193ba45410380b4d3a958292b819245d14f8bac8c1917fc8f55059c341d6c367a511eee873a983b4bf2a3ed17923ad32d6439de64465637772e31287f89281863798f56d40659be0800f7dd3d79b10b9e5de726f296592329909670ac40937dba261d3d9a871dbdaf463fa7ed51fb5404a80e39c9a0a95e63eca79fa33cb856439389ee6e070a19c108643c7d400c7c775e792b0bf5973a1d152ed32d7856e48ef175e172d154887a8a492baaaeb615a6e1ced3beb51c93796f6c1b723576553ae0acd48f92dc65866abef77a16743997db9c71fe21be771f4bcd13734a8c72633aeca0bfff74fcb3876b1ab5cf66ef7d5a6a676f797d3b2ee3babf1d55ed85d3b2ae1b2749c032fb0fcec72bdcc433c39dd75e5b58069f4fa4e00ef9c57ca4efeb679dfcdb0e3244fd7fd94fa765dd8fda5434a1d97e4f518d49cbe2e7aafa79267be9cdfcddf5b379299aba352959f8bdecbdc79b7bbf7c7bb3fdfb230b54a2ec27200e923c92453503b842d6b59d66cec1fb54ab6b72114fb5b28af8b339425a994f2503a36896dfaf82505cc7621ce7b99658a6b997d0eb69549d9f7bd135bd68e58b3b3d0b6fc62cb9a14135b695f7de9f75866297dc251dc7648f7f73f5d44bfb189b8dddd9dda9724fa729571cfbd7beeee491c4f8b85116be6951bf1d453a5d0b55472e4fae34de2deea3185238a084ae26e085a0d8b02fd79eccfc3f982d18e76958523a02240ae6ee0b6dbc6e3658c87de997d12e028ad8aa82b1c7fb6cb8ff8228791fc9c1cdf2d6d8cf3321fc14ec04fea66521f078efbdee3f81aeaf891d2211e5248cf04627300ed6b0f6bdf56ac4039394d71266772da9a356ace9c3143864cd69831565bb64c59b102e5e43465324da64953523ac104139628519204638c43115ca445d2470810fc187e8b35d00fe06b6323aecd0487a00892c867cf2417381bdfb81096443e42a08b509268680ab94c336b9a914478d31d379bfe5ce342f8a9cfa6ef4c2e347bfa3e85be4349229c4d71a8f3de4b99d6f94ee31d7aa6af8b5d8ed7d1b2c739f04bb13e0f7d25cf9440ead7d7d1b3e994da5f28a54ff534ce773ae7b117a4c726df0f0e7e9806f1fbe3e8cf458cb5f7327bb77ab5de2d7313d7b6619023c0515a1d7121efe90dcceb91eb73817af4a94dffa547579edea6672e6e3a08c8082af777e40757bc53eb48c2c65ff147edc45f7bb0be17e4a005506e22225025bb3e09bb86586afcd3d34d7ef6fd9824badbb669201dc0ad7abf69ece9b1674cb26baddb05e201dc9eabffd551c9c63e5b126ddb5699cf86c02f7fc7f8af27a1c0b93d97f52bcd37942ee2f00ea15dbcafe0ed019c7b0e000fe0bb726f38d2edddafc3b3da1b5ec18fc318e5a143d208080bb83dbd1fb5c2dddb755dd775f75eaeebbadbddaeab33ee76dde5e4b66db7ebae54aab5c9acca29a59cdf757a84edae0b9dd039b76ddb6ed7dd6dab72e3b83be6a36e0451f472c582e50ea516fb47abb848ab1938366a6b9b61cbbbc3964584d9f793b90817e2efb3fab571feac9e3a838da9576aeb66b9ed726fa7784526c6e9c938c40fe7f85c39477ef0f1ec9bde6f3bdfd41fd6f9808800a5e8e6429ede42a4ba9dcc36738a0daff4f164432892f77263f19b1a96419e6fead92b16f3f14dbdf33c3f32d2f7d5c551a9aed9536fb0373dd6bdbd72527e309481cfc4beeb651bf77c5617b1a16ce328f97472d1a56fe4a31c7a6175d1f33104785dfcf14d1d04fbc13ff473f2910d83f4641b4e282b59407f11007065cb9c645db4e19c62c322cffbedc73905cc36248239f8a65602802418c8373509f9c88623d44c70912e01ba027a930c3030b5d28e137000bea9a1b8487f837c64c314c40db0074c216d0a7df4779aae80738f730aeef931978e8436f87c88b988ef219eef878f259f7ca423c88faf271ff5841ce8f80048073f40be00007d2b74908bf806e1e7f3f2277dbcc701f8bc2ccb49de6fa1ccfb9c2d807ce4e120200fbe39c585f2910df1feac96b522cad838d90bab6be3a16f4e11ca453ca33cc4f7379fe81be5232f9c4f2ed6a2a6eca9736c1ce483b2c7a27c64c3f9f461cff3ba7cefbd2e6eb337ea0d0e85e1f01c311d3ab2f9c18ed9ec0339a55c5b28a54f372a39256d3f43d9f6397be72967cb8ca4fbcfc52bb95bef379d7400e586dd0db65724833d36996d5b6d682483edf5f3e873ba0bc79fb16773494625db86b231ec579bc1a65af6499ffab216b5c496fbb5a996b5a82eb675b18636c97e8eac1151266733813fafdbbfbafe74004309e0323b8ab69d8816ec9752ddf5939c86b2ed9fb3e9d109e1092ed207c12631919ef084e65f7e1550ca70e3a8d4512ff67ece106807d0e5d2b15d86e30cd39ce459eff364cedbdfb8017e4cfadc07f5cbf5f77efaf3eccbbc05491f294baf69d57cdf7d1bbfc077bf7428632a298fddb8db79f8cbae1778e30607862327474c878e6cb6a3c7eb10003b1f978106df75218efbc73df9e8761f11b9bbf0473632dbb46953e41e4fdd7803f1e3348f8f1fdfa6710f8fb8810619ec0020d4dfd3c36d3db6d29e1e9fb2a7a703977db9c61e93a4fc15e692e75d15419c01222a0832fb67cb5a10426c22b0f68f2d6b4358ed4aa368a896a5965a6aa9a569aca5340dd572217a75110896ba58b508404080a3acb9bb13b9aa56abeac90ad3f660cb9a1058423c6d71cb5a106bb610521bef4f6be317de91b01b2fbfc78774bc0b71372fed4bbb727264fa755dd7510976ddf7e1f8d98121930fa46946f052ad3ddf8ef2ea7b6b434b6d38564aada59b7dca86e65f615b6ae948d5d8d1777e3a522dcefbd1c30f36a433431a8e124be7836c33e7b7e1927b414bd350ab471c618e5c84bea568a6106badd61e73502dfb99fee4be28165a5d2b1ca19ddde7e40871507a63c9a537cc09c710c78d90a6a94fd65a6badb539a4692690ede96fda7e1185e91b389a7bfbb582e04534cd8759a25813699a2c5114459aa6880e2da13cf563348d28ce5c9caf43bff32c916662a2199a86a6a15a340d0ed7314505c22116fb99b9bb3b9d651ce642561508876a95ea17f5b19444cf66cf9768b6dcb20675b5e57355f6ac01d1b4e78fdcf7c409b767524e09640338fedeef42236c4774a17dbf3a827ae4be43c23df732042592a64a6f3b241989fc2d23a13fff0b6b0d61341fc90956fbd3e624fa3017a23f5f3cef3bcffb8e8aca0a4b92d9f275bacb5926dd7b45bad0b3dd7f437c6fdbb99fb9c8e52e0ef7b9396673dbe6c2a03520f76e2b13ee6f112ebca18ccb479c6f6ba3ecdf2a5137d0e770b8dadcdf1a7dfb03d5b6bfe16cddd6c1703a9c9b0a62b910dd32270f99569b0bc7efd6fb7e7383c97dfb37b2915ce4de2bb77411fbfef417dbf901818892254d52609af214e5bb3ece61f317f5753776df9fc97dceb7ff26960bd56c64d67ea8dd5ce4825f918d7a9d925ad7b47a5599f2016acb5a0f637aa8b2ab13285c9b366dd66c7f2272bb162ceb102c1dcdf61f97760f4ddbff89cd7623f2e73be1b6943e54c909b7bbcd3db513c9f61e72db943f7fc2c07bb276ae7cabba03399807529a10a6cdc659898d4327af36fbca073dded21ff57b68199e5f0ffddfa34708f5df8308fde043207abc0cc77ad41e3ab1f04b1554b024152ba2bcb2658a45318abdcc0890463a51ae0bb1904a4ec223c849d8564145159f638d2063abf3bb15d8aff81c8b4cc2ec672f33093b7e470826ff949c646dc8491667e160430d5938d54083163748f7e123d320a50454a4f80c4ea6ea471650ba0ffbf6addea26ac76730339a9492006168b31f4880b39f99843034991f10022d480d58440218275537f0f8d9f3d060709e879ee160d72f6daecd0eed248dc81dbfe3f10e4d250c4d4a0250e1f13ba8ecf8998f2410e677682a3c2210829492003cc21b763c952aa49404a062444a49801da14ccaec67dfc6c63cf4ec77e85908267361b513fb1d58da198cfd6a3f87b222b2cd76fd93d1dbf997b62b63133871bd077a6cfb733a11c196d7f0678c35dda2d1b0c676db77854fb0abc853a0d16834fb3a44dc477d223323b28d8d671a8cb5386cec0a9fe4d8f604d73de882a33c3e831732cc204399186488e18ba6189ac080a10986305e80e105332ebce082184c2e30e5246cf318519cc9a3d88c8216d044692127657c06c7340bd3d34c775dd179aceb8e6969a413429946ce42b664d0622f298fb3e0b49c9471194bb1d7797b060296684b46b12f721dac6b2ccc4ecbd8a66085366da05161b6c1861950d8d84a23823342a005822d47432a85ad355c05521f58430d5f81d4133562e06aa43c100336ce022925363068810b3048c3054c69bc604d9417acb1f90527a8b1066317e4a46c711aaecf2ecd819b972e6e4d778d73dfe04c1758db829c84b385c1065c9fed962bbc925b7057c06ca43490df6e99915258dad98575dd32e7f08aa43c210b7252b63929631b831524e5c9af66056aa8b00215ac01c31bbdf04650548086ddca001b18f0362e205d44c3db54000d2d9a05fe7b54e0c31ea1a43fb472923d232759cc0205ce48d3820969cc8852821968982620e98ffc92fe40930217249082325ef8644b76fcec6558864309ec0867a1741f2e970be1327292252327590c0304c838d314813328888104148c21c303a4fbc82fddc71862cce00031cc48698099306818210c306a6000185fd8b0802fca4c5140192f46a0c48b2ea824a08b13dc808013d49c0e20290fe5a99900872492f2982087241370a18301b8d8a20a922dc890e0089912ec60a4045af050002db2782a9245560f44b2b0f001098b2b7e18225d0cafb0c24261399a5600414410578488b212d3d583ec635ac410f6b1cb155abdb4b17f33898b5c4ee262953792b8583f3f969e8b888bf57318640338b3c84778661181e509b847daa6cdb67f84cc45f0cc9a581c1185c511565c215584155255606131a20a24b0b2646b8ff86a7051918f6eb25c4d8184540d381f7531b3f1e3e029e4141629a6a28022892c502431e6092590b84f28e18418a025c0515e0de990479ccc540d60ddae2b464b2e62df158eaeb7a1554eca3fdfa56b189cbc25090fc2e423bb05cc124a80c94776892f390967259af8c2449516aaaa26bce4249ca996e8c00b972e3929632e4cfc74e9c2252765cc0490172ef9e8a60b5513df9d01a832c02472640ae926101da101260d47c9c5ae9ffde64e2154f9e8c64b133909e72a2e1d34f185899c9431123924529efa92a80322457d44fad4072285a414698844f2d42e57fecc3dde2b8998c049782e919332ee126609305bbc7860b5258c962aca23e6d69f5aac94f8e2123de8eb111b1209a201ac5b9c4a88c945ece770cc8f13ce2472120693434cc37c3a74acc8330637ae7141b3658dcbcf96352e519b880bd95dff48123a54d5d068b42b46b54af2c831170b242379e4bec20bc923f7d863d39f4ae423bac19619ebf81cfa4a8c0b9badc196352a339b4b95edd4a963225ba2327d22d3c79aa34bf9a955c66fb5efa598c662635aca5e17f3c774900f4486985319091124f21056b224b1fc9d452227d9c7e1a8c2c63fb34c2c5336768242f1053d05fd008ee2ae37378f6f6ebec8a16c8c839e408bb5d537373fd68d83c3e69ddf7600a9ee1c7ed207f64875db10c7fe9c19c97503f637b42ce7717cce37a166ef6c596b628a7d5d283fd012201d123de7cfd13623c1be1f2fd6370bcee320995bae8b593e9f8b29d68735ed410178e3c3cdd7b7f928e79b89251f49e558943dc2da27827c005f145db48fc371ee6f1e9191e0178dc8491c11172a221fe530c4633eabed7e72f71756176995d207052570d3ef2410fad3888cc4ed22425991fcf4732829a51308293eab7d06f181fa4aec5fb1cf3199b18ee9ab6ca372127e1b32718d4bdb85e9148fafe424fc396492dffe242227616bb3ae547c56fb967428f6ddc7f2db70d6a8a030cdfab0e6f6cc45ece330874cb6d436912d59bbfe91fa236c41b3b7ffbe9f511909fd2f1c71759ac5949b9d572af519e552aa45946a7b39bd7d150a5581ae50976075ae20065886a1dab2f6456b6f59fb5266d620a0a67489d6aacaec9b2d6b5557bb56455535a5a5caf6a3a5cd05cbd98ec82389ec960db1db7fe3426b61dbfbab412fa007023501facf5bb70fc93c8c19e1b7fafb5c8cb9582b8db65ddf4ecd8b43eefbdd9eb761e15e8a73595db57b8abda7f4066dfaa6b0c7ed95e81eb9f7be53a2bbf33617c445a0312067eff6e4f442ee6efaeb026a27773f99edab9da4b0bde7f413babdedfd7571ebac68b4cde94ba3ed4ddffd4387ae91bd4c8e65e3fe93443226f37dcf876d39cebacd761b4b1fefaaae9bfede76a48f2d22bb33dc913e1ee4a27fa7f78f2b70bcdd7cfaf631ddec36b739e76c739e73dd7bd76dd37a0145b5767d92e1d844d4a25a55d48698aa597112291a9aa6a6a5a996c416d5a25a5ab82ca022c0ed81b4803a404180e38c7dcee7bc0e3438723cfdb94676adec1817ea1e470eec6b3ef26ecd431cf6f6efbdcf7d3afefe876327e771fc38db76ecd9361cbde7381d1d9d7abf3ed2fd1a5a3dd6d9cb8c64ff5bda9e92ef998ea635176948cbb8e8e1c08123680d98f3f5bb2e27279cdbd373e7a836775716def8aa618fb7afd356eb6c998ddc8761acc70aa4051c41a70ac79f8df3e07f2106bf778c3d1fe5d70b17d1ac713cd6399f8b1f0dc7d9867d125a5354ec211374100c5f5f445f300b1ba2f3301b8ebfeda8e4f53daf8eb36d4358ce17b98e7d986b79ff3dd6361f61dc853223dc778fc47df74bfb8af9f3b7bfaf7adcc11ac77ff5084966d55c04847deda7759ac0b685ed1b8e4db6cd099bc070be623ba630e2502a0e6c00c759b3db47abaaa8a4a4a29e9eaa5029540a6ddada62a3a585a64c991a16d6555515959454d4d3531597e252bc696b8b8d96169a32d686b34c6de642937b202be0c855e1aa38f7e442e0d3e7a05ce8f5f4392b2e14c549f9d08ea7cf6d71aeca85acb8312e247bfadc1587e5423a4fffdeb7d6eb3acf52ab54b74c532c2b058d8bb4aaa96bea194f5b9a65b2525ca48fa3ed14eba46d156d9fb485d2d68ab65156ca4e511e5ab35476ca46d9a91b3b65a5ac0e930b8df639269db1fb6dcb458ec907d07ef73a9e4917724cb4b9e51c937352c66c66e88666d35243e96f6c249113a5592e44b35cb45496ca5a55b9500efbf629968b54774fb35cc866bde895d534cb458a44b13ab9eda5575859b6b3d862706ab9d06d92443852aaf8539453f995a37136be459ba8942af48946512a498463775c0ca0ff5d402d0c3261a009238c23aa6a5848dd1a16524e566a5838cd1c2cb91ba08b332b5844050d415f5a3b6b5830edda021a3a0c7c7a16f5c349a3dffd5e6e8519acac8dadadf2256baed7ebf57aab9dd03b34b73b739ab5da61ae2d9c5b538d9a352019e7a91fc6983d4edafdda69b1c3a8daf527533e723dc2c0dd645ba7ae5f7fb5cb0b5fa112359cf6a68a4fd87604f3169e3102c7993545d6aeb0b287a851a5bb3e91aa242ed465b1eb2b39c1ae3fcd58b9c806f4e6a472201880f42f1d22522489fcc798f8b3a590696602a93f694276f8ba726d210ec71f3353881751858cb1ebbbf628e953a79a1f57388aff0a69369c520ebd201a45996d8cb070415580726fdc1a1c7e21d32b1c63e36fe12882e1f853db4cb5a16a63d5e6ca6ad74b27d977e9fb8552896e1cd2bba51ac923ad607369924736491ee9ffb968b9ac8dc071aa715aad6d31edfa738d0fb9118dc9df3fc7d992726a8f5bd6b0ac6c9d1080b286e5b41d8b861a16d38e6d55b165cbda14517b0cb2eb1455f608ee3973af428bc27adc6546eccfa5cf6b54646d599b226b0aaa8d5fdf77b511388a9bca5a154f43d4883e08b4d61a7e77cbedefb63d2ce643f7b77fdfd95617b9589fe621419840b9e70701c185ec66b939e75f0bfe136c848282762af5f7e2a12cc0192c1d6389a574f7395f4ae91ece2c5f414fe058eb9cd405c614b425352cab3b9d56bb71f7ebe494f73a4d9973765d54b54229a59e67a9acb516e3acefe3388efbbe8d8bfc755dd7e56ccbb83e8c3176b9ae18af2fe79c5fafda9519afd70b046b5756b5ab346ee7f2170bae685bd6a4b032b4652d0aad8d5ff2af5700ac4541668f5f83c114ef9cd86e345f7e10bb85a00dafd89f3a0853d31bd970c779fc03c179fc7d0c326100e957bda38348008e4182b87b6d02120314e6fbc25550068dac7966bbd33403f40538cea63d2ad15d5fbefb9979668c33f30c972a141403388a206c2db0cf19fe7d5bb775e307acd8b4eb2cedbe7694d6bdc56d928edaabc5dabc7da79bdea8fb4d2fe0d5c58a28cd493a7bb56cfa553bf1dd81a57da5690046f73b2da3f7a3bcda307a611add67ba51b8f04b9ba512b828befaf241d8cc797e5c4cb3ebff0405b9d2f446f7cafd2d518c19b3062881ac00679248a604bc4f7feefbfe600dc7d8f62dc4740efdfc70027c62b713dac6cc9e396c10e6b37eb1988d7d92886e0973ebb9c8cc61d7a7da89ef273c7607969ee4d8f49d706ddab4b195e6a68f42a561559b072cbdcc24cc9fef5b14dc753da514767fdbb6bad5eae0cc1d080b1cc59f2049c4fdac2ff6d46a7d73f73bf7fcd86ff6b9cce51acaea2f6da4397fec21449440e68f3baa3f28615b76bfbe33f1eeca9a5f5e6e47fa6c9bbd57ec09b29bb538a410bfe36b6ff7b7c7d4e3aaacbb6a99fdedeb6452dff7116cd372dbdfd76df58ef4d9dccbbc50d43d4175c666dfcf07619228ffec7e736baf75ab5d2e5babb4dea7e7acc6661e7e0745d49834dbfb3eff700204bd2f3ba0d2c097f9e8fa3bf7d51f77daead82ff2a3ee6dd697bb1bf7f6feacefdfe9edafcecfe9fbdee7eebdef5d7bf937ddbdebfa786edbf6485ce8bf415142ba9ff3ff1803e6f979168b6dddcfffe12eb75dfc713636abb7ded8ec9f009df4d8575e7fa5c91abdbee7c7a9f72f50cb94bcfe755f19ca12a3d7cf4c41ad02f85830205dcc21942546e0cfec7f5d1a757afcc2d07bcf3dbf9e87c1ba3b5d77d01aef7bbff7f3ffb6cafdccfe557a2d0a2b1bdcb20605d5c6fe79cc4519c39b8fdf96b1ed5560100b402547ba1eba9c471658ee602969bd2ed211047dfb21e667d69d0f7fceeb2e0491793fb7bd3f2ee49bf7d4eb3acfebbcce9b92a86e32fc7333b1ef9f93b9f187d508feedc96b7f8939d7f7957c63efbbcf7fe622fe4b7b7ad37f8c01f1df4fd7a357de5e7e9288e32a955523db738fb47d0d47285fb5b908c65daef5b1add4529713baeb7363de4e5d36fca4cffc4ffa383ed38d9956b3d2799f60da9452f167df1e637b661b561ab0dca9d1f98db5c89da87242ca2e722149eba54377da5cebf4af19c9d29ebae62217fdc56c51316b36a55fca88d932375be9f41eae710321dd02cb2ac64a90f9b9e3ce29a55dd7751ded3a988b414f200a75dbcf5ad84be8c7c5faf25f624cccd39cbbfecc56ead405ba58ab0c226b566a86dca8fe111772d0b6b1c3ecf1ab5f3f4912dce5234abd7c4429ce479466bc6d5c7e24b97328733d931cc402902eed51696357e7d1a58d75936f7be11c832949fd0ffb7da2b6bdd6c07cb1a75fdac5bb74a1944efaa4c7eec0d2ddf32f165de817b098569a26e8f2055017d8bc617bfa056bd33bdee77ebc746f5eaf745456570da7d432f9db1f3901de97db6545c227a3127d3752e48677055fdadcc9c0f8e5e3a01ec0b1eeca84993d6bd8b2b685cdde9ed2bff47195d6c68fe3ea9edea7f46fa6d8d3f9257e9c70ecc01275590abed2ddafc79c4fc9ad808293d9667faf74f78dc7292022bd2ac80c084686f3f6f38391e184b58c04c80d7f0952011846963ff63a1f46e7eb62ffc2b139e76c6dce16678cb1cd365b6bede36cbd4c11e369cb9a99293355b6179a1a8b93858333b6cab8cbd4d660cb5a97a68d7f83dd54fb22b5ede32f4fdb7e96b2edbbd850d176065bd69ab0b263574e4ca8d9221a34b52f5b1bcb28282d5adbd2aaad9da9b2367efba5ca6ae3cf531bbfc501bb954f63fc1e95876cfb3106f595181157a28a30c28b741f477491e222290f16aa2c4d4817916042d21f534b24b145521e25b4685142bac8c316aa2a2e5c7838420a4b961f9000337dca9503ebd20587892e436cce63ea60e4a4d585f3765b2d613739385ebcb876c8593e243e15745e1a61397d4ae743269da598c69ec467b502965cef3e6424dff9259e5f7e25745c3ada6aba16595db0776b5d39195655758343e501972e60c48409e3250c145658803dac26d0e36f70aa5cd92a1f59d88d0d9580b09d93f3312ddd0358cc9f90d3ab0be775b434b25ac26e7270c488717db9e9dec5e423d71739d6d13257a8048412d32ac87eba4c014b46b247802c64922ded9856c092512cacee817d9a91dcf390b9f3c7ea7477e96c9996ee8195696984a54b31abac2ed74b23aced0e02421de18804172b4c1f49a295489ffa405bee85015d01ceb0deb6cc0f98dde0389820128459920990463a0a582241152e545c3eef522527611d7212b631adf3ee057bd5e75f72093dfeffc3303ab8870ee33ae4e0841039e0f0441038388d0142d21f3fb2d30d5040f90d4e258a0f7e4c8192fe90e2ff6325488944f645fe2309b0c7cf5c421835324f20043541628045b2843051be00a1b5d63d5ee6231d5991bf0e424a22f4837fa8306af43f54086a663eaa40987f0da5ff5f66134230a343203e94edd0e37b7c91b761a4a3230b7bfcebab305162efc29291ce13a11f40219d90244aec75429912ae8d91ec9ba064239d5f3292329d708afc61d404fe1e8e75bb7b38e7f436f0fc9f17631fbb41412e607777f79d9e0f8c92b57b827e071673ecee2478232c71f1e8494a915b6badb5d6a7136d322961c0c5265068d4cc336e45e4c80ee0085e38ceb6f759793e9a735a2f66f3519d765aaf42d1683423b46a5a66b4d00819414b8d04729565b1f5e1c393d9291380df0c7b5b5a4ea0d6534c8b494b4a9bfb094d2c52f4979edda6d068b422d068010d19d0a04234021a3b481fb94751ab055a6a481eb9399e3d33cff65c25a536d3b96d8865e7b6e196e88564382bcee30e05e55330169ee246bc9f4ebe23d2cf0a8fd70eb97ebc9e8fd9a69d52f9c80b4f00facc50f4846ba7f62b1fe3ad61e546bc87e2a27b3e6545a1fa6ccc7d77737ee5629a315b5e6d5933c3873464368f2d6b66d036fe3e97669a3fb5008d3389ed3fb148b712f233ac7462dc6fe68f227948e83fa19b89fd8c94df4ece1bbf90fb201d402617b0ff5bda198e998100fec044cff3685704841446d8534f2bd1ed791b80ed26b0ddbdd5f94bb3c6a6d9b26730d93362c860db4f73c6a6d1923cd2676357d46bcf252490d7e77aeb0a7d0ae509a758a1e16e755535c6cc1ebfed55533e45737733cdd2c52d33aa064a1771b76409a766842556b5ed242c51c3850e5506e8fdfc51a281ca5ce8563e46cb6ace3d4e2d2b9f34b5340a75e70f77958e4a3292b5f6b367ea0e2561560922c58726564f0f0dcdd0dc02bb7704c31915f533f18e985f31900235e5d12268115e28a5cfe7539268066d012671d15fa96a2ef4e69c33045d7a4a398ffb7bd46ef2cd4d697b3fe73767c6a15bb9e86fe4542e84b587dcc87dbb4f8d0ee5504d5c68eec7e1940b4df7749369bd30888b6eed2cd2b6ce992409c544927c01bd1fe5d591efb116c5fc9ee7fd8b5380dedf1dd145ff3078c10f9ccd84c6ebc16658a0f75d6ce66fa3820459017aef85452e42d9f6c799883dabe9ecf909fa71d1843ddf5a1be4a2f778fa0407aa021ce7cf2817921a251a6b59b027d6533799f9d4389c9eae7b84fdcf1e61890b49179241c41fe95947326c596accd4d04c810ad22148871a1a5a2d055653413904e11054058a4a5a535881f3524bc194329acaa8613f399dc97232d85032d46c4a51b0b5291952bbfed46345e228a594ba4615b6529d61a5563018e953ca29ba65ad0c2c9bb3e252ce329c8ef02d6b655839ad428e81e5639469e26063bad96f62ac2579e49a2bc616c814932279e4185434d8755a33341a2d8b917c9b8f26077bf470b4ef36dcdcbe2f06bccfc43ecd48740d9540a1fa371bf1df68341acde650060b4b8951b5b777a92d6b669a6c186cb4dca37fe6be0ea003c1796c102d37b2db7eec8d4017b228a8b2ed1ff1a16a44b7fd98b51f34b3f63d23b9e1f6b022efffb9906ff14f6efb757ff5eb827800ef57ed142b5502c980f49164fd5bad24b25512552a89a84b22aff5c8927c77a79bc317c6188763936f672028c0b933d52f7757f8737bf5c35f6c02f1ffbeef8b4d21b319def63b0912e19a91e8c63fbb8ee7f7481f7fa035c0ed69917b7abc3edb9fd317e62edfb66cdba6e461918f1ede6aa5a5096c4d1318f6a7be54270a58eecc2fe809b41873e198c2fe0b8e31eb2485cd8d2bece984dbdcb67163fd5a819e00e757f965297db52bce34f92e8dd66ddbb6edb73265f6b66dffdb6f1fb4d5f6c664fc1932b15f5fd8c9acf4058fbbde538ee3386e72f3bfc97d94523ddf6afad16f7ebb8eb0c96d8ee3b86ddb40342ca5da7e2b18d097f6f69b06b29a77537d7bc0f3fd3fd8fc7009969503e36ad39f4d341a7403385429f79de6ae7451d226b00f89d79cbeb052466b8b6d6cbfea4274e24e02d938fab8bae4b63d92dc8ad89f219322f3392ebc2bec51896e2e8d335bd6d638eded83b6aca531b5a50bc9dfe8f66c48916c3849369e646cab4d60347db1820d5650c8c64e2551ec2deea4101d1248fd106c01942e521ffa55fa50243982520a906e7a933e4b9b7e5b248fac926324962423cbc82fce482934c217670c7153341acd8b9114b265b6954a81c1a80206141851604c491ec964fecc74d2bf014ba01580b2e6c5d31ec52dfa9549840f41ad54216c101b101cd4fda1f3c1eb013f7d3ce41d5c2478550175b891c30d0e384eb01b7050c919418e29311b74d4a043834cca6c861d32f088a147d3c3a05f085d0000d34e940c5ad060b2b0c1a4896d78daf0c1c68fad9e357cd4e0200640d8fcc0a0833402f002a035412ef0a005422c18521364051fa880080d215a209c21803403302304344529d865189141803322a0e0688c2162209921124611300af085913247bc40d285014e90544b6282037081802d124046490914a0c502b26040d6085834e00a0758f1002c12aa80001511984202574ba49840142540418131263c5101272c802f6085811032308051004c4068224403441bf88003414e1872228482071d085202f240009e74f0819f14808080835d1f87c067d7c722e881f243051fbbfe0f5e816749dcb40d360b1ab49041941d2600b810bea061f8a61e31f09061c70c3329321a746ad061436c4a8e11e450c17103cc0907879b1c6ee800567991c06577701ebeb99f640fd9872f88cab77fc0501e107606918fb60f62012cb28209f105d1bedeb007a80d38deda15185bd6b8300387a53976fd118888ef471275df105d6c15c5ba58b3ebf704a92f42ad9dc069d75aaf50fbf381da502fa4587ae5036aa3678b3d3f364a04da026908c406387f02bd001cc51e203640a02d10280d50ea88202a178b67a9486c53d7fb6c46a2405be07c117ce886d579b65742895a6dcb176c59db62cdc69e91eaa661934fa422901ae0267d828c00fdcca7e59b5abebb059979b5658d8c947de9508fbbf291e8a2ddf26d81f948144ba02575d8b2a605995d14debac45767be5214a108680d90fb1da02cc051dc3bd37ead61b5e18e0b855a8cd9b2a6c5963db5d8b2966566772085dc90407a7e2491c51bef0f943e1f13f9888614480d900958133954312e3a5d66db66a9171e55559f8f6c28f6c400b4f38bf82504b353c36860258af1e144cf131c8cf9812200510449217415640a222a40a86200584556185d21021643b2886451002d8e94c00064926c8180cb8512132ca036c2091cd00509d38b08dc324bbe28010c13c2b080190c88318ed104051b387302192894a1948227685230230469a09cb182160d8d1654c0b48217d434b14086164871410d6ba6bc804a1a4e30c8814d9518eca0c6d31a3e6c41b111441b56661b2268512c18d18254942c4c532e28f1c216189868a28aa18b0c5533809162458313358cb1218a295723a0820ad60d573865e1a0450e6474e0a24a8d045dec508607309eccf430860f677e28030a0d106982d012420556d40cd10222d65c49238a4d116a18b175c46c438a86a5852c4c48bc30d594840c4a48d152c396294b5061c2a9891ca8aa70d9a1cb93171faaa0be0401c64a1822aca2c418e184d41359c64c41a144145ba460e28a6a8a2e5454550106cbca0a27ae1883451459575950a1055609ae2093b585165c90e9e1221fd1508c02e93bad76e36ee7e12fbb5ee08d1b1c188e9cd90e1e3d5e8700d8c940830d441e1f3f7a7c3800f2d3410080823c101a0af201911010043080108ab6110144381a8244a448018c1c416280a42407404002942860010c18a1010e78000910888004964ca0040a9850010b5c000319189934d1c00638708213143aa0e481271f480104211001141556589ab4c9c26c6146994cd385f9c2846136cd18a60c73862965d2306b9836cc29730493cabc613a4d1c660e538759659260ee3079984fb387e9c3fc61424d206610538869650e3189985766d42c621a21e71153cae5c40719fb0b03f2024a3046a9ad3e04969f9535b140b3e79c73ca39017caf5b05a4eca854ecd8e992562a9a110000001a5315000020140c088542a1509806622ee61e14800d86963e6644950844511aa3389261209a310600838c013023403052c200e2bc81b72899f9e7cd6fd94238a6202ef7316b79e56720c2df59f15d4193a3422d7f5c7fd6e72626066d5eae68c65d70846f165ad570db2644f984d2952ba1f4e0e586ca8c371cdb51c4f6f77d77b6616085a60f624cdc9e0dc6c06f929dc35e5b3213203a3748268a061ebb5924a00487d941f763060fc7d3ba613e0a555fbdfda1f2bd8633d15304cf0398122568d56bd3afce8293915f1dd891b9ec8eb639b13be4a9e945db66fa17a9b3bf4a9e6e04f2513a4d8b368716b6dc3fe600652f29387dbfab43bdd8c698d5a0cb29b303139af69d500d30ed69d5a0f3cc21a78306b43c8ee9eb42301d35d3f111b422b84340c03e52ce0800c03c5d1aadd1103ca840326ad89d14edae928aeddf06655fd8054580bf7fab038a354b85f296a9918481b5f28945d9dffa1c53f85bee953d5863a4601803ee49643661d45e041ff98531af7f5613b878f8d5d52e46a3e2865da20efa1102ca37fa4a4e02cec7d743f9475a8dcaf0e14e6fc3f4db09727d561b4b742c5a77bbacda1dc07866b5a3a32988de12b71c0b9b48dea7830b802e65f00dfc029ad1f82f5f7feda24371e01287d1db568c0255e39d00983baff1e7269ddd2618c5bb79c63a748679a82debd2c32c79b9ac3f2f755277b8fc2ef4a11311a5c8c0e2a0560a138217524d607c503ee1a4d9efd70ebc87c96655eb7040837e8ab04919e28a6c623b96b0b54313a53227d26357a8ceeaf5450a9699dc13a7d5bc691205c0716e5b6d42ba580d86ab6232670c5c8d1a06b48a0d346af5be24a4a5440b3e93278e1f1e152bdd4b198efd6f8cf45f53ad1aa69852b31c8d4881c38146c0b028b21603bf50a8f0cab564026c09f369ab3b91f7c962e517675f7c23f9f3c44b7c1574b2e6799a58d462330eab8c25dc34d6a9b2698575f9c379eccea95d9b3ee5c14cc0d3cdc078604a30c0aa075d0437c5c5d3c50504ef991ea190c5ee833435e538c176c606662cd193aacf527ee6cf4fe6a2852ff3d025d218a75801f149a5484cc8d703f25ccad9a19947fc4b56dc33cc3a60a2d88f42a0375cb49e7f4a18c5f6ddcde3c3b479fb9832bbde149554f6f0d7f1ebe1f3a32f3d722c90bfbfc9f25d95ee9fae61af2f68cf847731a078558e5f9858d84fc4628356dab389a8d38cb6d26c8fcf6311a43a8de227c46dba0d34b1daec67cb564618ecf124c93eff025b4955a2d3f738915c805796a65e3a6e0a7674ea6a89bcadd5a89b3be58fcd3d69de8f59370814fb7ea02cf7f1b00694e9b31fd00fa807b07d10fa4e9f0447df7e93033f2e0c3c36365993e1da49fba9173ab4eec947c54e6f0f2c184d855e9725ebf48be60afa19053011a43a0353fabd99c4b43676c5610a55ea1bfa35ba5325a750f315f2f13d06b113cc67a18a0d547a5e85b02a76b01b1da7c35eb0871af840d7b91f2c60b1ad80e5351a6a526f49115c3726f0ede861559fc900d65b5c675bd0e548220760d68d41e127c26a11e1aebe2c9628fb2735676dcd6e423d1303d46a2bcee761964ca712c3ef1b58f8b12b74fe0bbec74da5bfeef9416f90c34d028ddbef4c31a6a5a39e36fc311c9eebc68dc756398c1eac625070c1acfa8dfbd737ca4d600064b03ade029a51040f6d7efb1ad94241d662dca5776f80f9518c19b154c8b064b1b87fba8981f0bb3ba40fae8dd4c0c74c2c4c2baccd0d9c97446dc773b4d53cc9a60d72383a78acc78d4e598702bccc80dbe41e740e60ade3c209b57cfcee2a097d661a57f9788353118e2e6944f81a68a750c34635025b81047c3433d011b8ff9a7c262bc1f383761486ba3ad7cee4ffbac6ce04e405e454e9695045dcf28706c5fbfca4e6948cf41cb353b9d15b983130a1099f708e693f8e1add347df153023559984cee54ec537866262c8088731f39283370ef6c9cc245d2e4962e3f09646518c53bc3b61188f5c044e45e91260fcf9b7bcf6a06df0c35902601bbbcba0a0da24986afbd612de7f7720a8f1cd5145cc91358ddb0bef95df19f6dbeb02135836a1f405dcf40b85aa04e6ed39e907429dec5e1cdea3472e0b7ce4938b47012a8d0755857b8e80ad7632944e3f322ab2a7fb2d56160a9f3e1358f8584c399bdd8b103afc04ef958704f4eb73bc1ff53b89a2782dcf13efebe0ca17bf3957df2466148761880605472c82f24f3dc662575c9cd8dca3e65f68a713321d67177de77e55a965644712ee600d17a760e724c5da0da5d41a5a799449b9370c1281ff496e14dde1f5069be1799405be2554b72d4bbb836a9e5b06d31288b464ebc5a6c76569269ff06e52a409b6dca59a37fc7a102e8d9c359d447614a880409e8c5fbc5bc7c3c46536103e650ea0e0856a5aac4a5e1147c4fa46e9d7eec862e76ba00664cd79aa1944130162196065f914d019bcd1b55a00d5cc12efc0b9f1fbcbf48790ecd4c5ac4ebe89ad469c4bfa4479794b8114f1cd04db45ac61aece26bd43c51e1156b4c3c499faecec5349a97c9304edb9dfb44140dce5b07cbdfa8abe5fa7869ff93e38e09b24467a9970d43c77e62aa7d2020c6e613183d3ef7a630ef56446851267735e272af9fee95ec17c39b3e589b41ae20461847f342c8d22c4b3c28d6d1d723fc7d3c8d9ea04365266ca2f6dfaeeba9662e91c82d820bc157e222f70abe265dd3ffbb236990c8fe485e66860d81286a402ab310950e700f60b1f4ac262a068b292b3e3cd558bdf128a0643590b7aee983c538408edc7dccb1a8ca5791f9ba5212e63b6a3bf20e51151184497ada94a07f3c1c2b4d0aaa2422b4217cc9e1cf4eaa66a8bce14cd267bd6e60d13fc343f221852206855b9f71d7428936b37c0411d29eb12fe61da96cc93b5c4bfee701c875e6e79f4629f42ed817c38abfdeb87d6be6d82af3a342e3ed8b8b341776b23c5edc42fc1e9db4de12ce3d93c9159b9f6b6465e2de74a3d496662d0290d8d11efbc0a94a7da4b84d63838671389ae4aee356740782152d9565383ea3a22288649ef2b7045c9c5db760e1b05e9e112b6e4b50e0e9fdfa2cb9e79d7204a42778af7b0fbc061e16aa4ff9ec28dd39a248feb2d4dea6e84cb2b5c6d4ce19a453c1dc51d0f40c3065f7913f7323b0e79122243e8f6e481cc5058fbcaad7960870327cf722ff0947a260c8e5f71c7f72670f7883d64ec1a2fc45c88a2199f84e7c5f49be80d1c1392259b7580268f38fd5c41b06d0202454ba5e79d5f6a98bb412b6639ff57020da4b30d7a13a7b6d0d86685a55a629e10c940a8d2f58ba06403abafdb4e916c697dec40ad9b6c2c336a1676e88c0f00c65e445ba53614c3064658fe9c261781e36afccd7884808c97604bf4d485be8198d19e4ba3134092864bcaeb80f29cea2973c17e3d7873cdbfe54dd48ad7d311002e1c9365e0cd7bf4ed9d94620f6528c4c2cf3ffdc6dc82efc1a9a1cedcdfc230ca473f5fd7e83ff62834d36791115cba1e96a503af9d223eeca1c8ecc9f830348963098ab221fadf84c87c2a765a45570d4eb50d7f830a65ba0157e842a23a8f9abd0c9ff73348735d3ec253cac949a5eb40bb5ff23568191d0b6c02e2c8925eb976758de3e6fa4d73c2b409207bdcd096c1f76a6e06b30217eb22772b8ad39bcc819f97f91124240384ed84733141a4b54d5b96759bc4e90b3312c9b7771e8f535c8986d931a0a9b365b101920956af64c19f449ebcd678bcc7efc5c73a92197f5fa5629227d883c4dced4b2fbeb1ae49de71f6d6ff052c815d537f8b087b7c6b0cdd914b88cc104a10355ac69f383d3e3d0456c1cb22d3772a750b3c1626011eb3e36191baf8de2c459599cefecf5b8602917f15c8eb3596847b2f1f21b58b882995023a5e7cac2767dce1a8f9f16a5e8d95b8445b4e949ba84932f0b90cd15320fe3d237dfde415e6ab17d9f3a3afce9cca17b5ae3a2e706c0faecee3750f125cc104d5e95a16e6e481da1c7991cb9127801e43c3e0ee0280ed0e1f276d93da76783df2d360f54962d0ca421812e4269b2fe3b43f86debc6bbda8179326201011e62e6fc5fcf48ff268e83ec4cb3b1f44a6e0e4080bb7c3f1bea8720e7620f45f87cf35dd3e05e80f357f87f70db8b095b917b38df685a4bcf59a4686a3847828a571d019550116edcb2812f7e9a04f0d6267380542503804048a6ffd2b3b8f38c05db4ae9f462cc0da1a963ba847b0df8a0ec775f7817b3a7a24b86c7e57a0a4a10f19d9509415089557846623d1ddf938e1d72242743114aeb0e4c23afe0d7e56638747dea688a4431ae834284bda82f6cd161c620f6601ddff296d6c65c4a754e09f5ca02692d57705c944924b46aef351ee4bc2ca11bfae85e06c1dc4c59de534875e42a14c499a5a0a55f213adf2d4da62c1ecd55e0dafe9756133e86b3a038b7ecd0db0f32de7e3af94eeaa0d57653adf62e131b085c757585a7e0ba0be4a25a8a23df3de50d8dad786cef7142b2bdfb24d4b1fc205f8a450ed9e858d3f8240ae1972f3e906080f852a926bf25315031950d0f1f66720499f819ff31da02143f676a5318a04470038a9f3288bbadff3e00e028cbc9d1077b201bbe547be96ff810736205ce889171f2749ad182003d0ec8c8ee2a82b395a41b3e8c90b48a937605a0d90a3b8da2b575fc5496e2a24e04a4c2c8465d34c99ee11cd1c7d09b3b97dc65837547222c25eb5f8a9b87095da22870a2b1475c9306f7134a6a23e3893a42f69249cbdd3bbf97a0cd4bda7b64a8366971b6c215494d6fb841a4116a5b0f9c7c68cea28f1c973ff276566544fef557c389b13846d89d572094f8786e6d19858c4538697eed2dd0be18d2a14d581137ac04a21fef59a7697c6b37abdfd733a1c7f5c9aaa69d9e1e69b6b494ed95eb4f1a577683e94b9bb1631cb101284c2c4c9bc394824e1c3354a8215b9f512147e5bfdb71c723a7bdc60361c0aa41c676d00a2b7db66e93eaedc344839167dcbae76bb076d3d1beb383d8b5406233dcf0439af87f7e86bd73d42bd63bd86d47c2c4d8c7eb223f86c400b902ec0d55e3bb744eb2fbf8da782a49dced8137292f34623b034ed6c9da3588b1ec938cdd0b894407e1f811d5ad5d61b84ce5f9bdb8007cfb3520d857f9765f62d8ddda5f0973a9ac2cd0839190a434e5a62c7f67ac52560c47e2a2edbe56f6fa0660d8652691841966f69d88856ac048b93d1538e7ec7012eaf9d3af9cb716a1c13c9e20caf1c152ca5465a1be6df36b7b05d738c009f4dd60d720526d772375b058457cee3825413b021663aeb17fcc26b7759bd0f5e1f1022d7623bc47ef50c86ea07c5453cc44fb9452deb8c11ee8c535b52901513b031101c28efa7dd0fe62b3d53bb53f5a6a8a5ed680413c2e722bea9e935c6919fdbda6d5ed4bb8f9b891f8f045b60e77ad31dce4fd096011ec46a95f1ac1b7ffcf39184ddd4eb7bd82e49af45c054f568bc5f22626c512e397ddc93e023e7379d357ceb73a6447e5bea952f206553409643bc7bf357ff60860de76e6716306127e580df9e25ce2524115b0681bb4344bbeb76f49f7591f842b1ed698e26b480a78f6f0c5eee593ff2c5a8114018755abcfc5bbd4f11b3bbc5590882f8cb82c1e00f614db9e6b7773ffe1cb84d0141a6fcb85cd7101dddf7c211de38c05756ebd0b378884e28de1ee3101cf398010e5242a1f2d58fc81bdb937e76c28689e0c743ed976bf23de71ecdd6f501adf74ba9f0e4f00849b98371b3e330e49506bc13a37c5520a5bd2c3b78c3c9ff1ece4dbb7c87c99747627de3941dd0703a1c4c19c42503ecf6edabe189d8f2ba864fa9f052585fbd82fb9d863217421de006d2200b4377880232a199ba26e7c39627cb2fd2d1e16c81f96a5b044878a8319ec215b2182df011612e3bd1e3283997fd82725181bad0e48d7867d3ebf3312aaffc0fc9b8d48f61afbb590b197aec69df6c0968b90ccd11e45a560ec4aec522bd5440cd43d3542b37aac71db94355e8cea6583edeb465684b99178d30e2de6de19a45224584c49cd531e2d81d3bb95fa97569d2a56c39e38c9e89e46ce130e6de1867ffb2e5803f9e8805734a705a699666bcc0ade326b6236cbbb056289950494bdd34f0d2f6ec26f88ad67fcfe028954557a8a939c42484bfde452b644e63fd2dd404e6e172088810431525f89f7026e8f6bea92a27af34032955d78060083fd40e44bdd507c011c4e68eecf9a13ff40031b102d60a7abee8bba18a57076e3a3c9b070b03a6ca59684ef810ade6638bde1bb863bedc0a1da6a8278429f41e138a6766ae122f2ff014864d3d6ca0e17293d5baf400209a633227e9e824737576cace05089c6daba68a0600d23d4d72150bcedd66a158e2265a85445830b5532a67e9f000436edf6ec90a8d2a3554a1426c38ffc750418dcdcb5db40c1241bab2a1181c2b5cc243f4740e146aba55d3856f2a44a050928486596fa3f0a0ed9b058b242e1a54eab6b910102148cc87f67d0d0ed55ab050444d2bcae8e142a58c948f07100176f5bdb5a8522250e2aead060c1744689df83c0c0369b9d351c5ae2b0b212092344638cbedfe67840e0551151c5ee111b76faca9262327e697e398f59fe54fe1c3e196f39bf24df2cef2cff0c9f14bf9ca7bcf0c709e9d4a03d30f960487ac69389d2e20bb9cb21c9f288f2346fc273096c34f946438d861c0d3f183e26cc20b47168e390034347c38f84180a371c6e18e260f8d8f0815046a18d430d861c0d7f53031fbb670c01afa0760822d2aae28824b125904b23b04874faa18979ddf2aa5a31b7b392c7c9f1d406517e9ed0ca538ed43bd82b53a4e23010c6a8ed15ac7b5abdd874b0f7fa61cf9a1d267dc9025c633c5bc5855a93cb13c5bfbed84e9eb51c0ebb85fcb41ba980c40457629d764d09904b9800ddd7060ec6456c11384b3c06f4d4da0a22b942d551fabc8ebb6e6d0e7accd4168b6449114bfcab358eecdb0c0ab0a07af0e4c840a755152d8af1cc9fa9fafbe5040d191a1d04ee13664c132867aa8f079898dcfdc1db1e0f60d73aa542b75e860d72dc2df1020cd8652a6ec310cb6f143ee63b848df5ab40b254ffad4f3f2a33bfe7d88a3251630d93be51cb333c6ddf6edcc6a862c3e450da8ac972a306e23b74e8275117fad9d89b00420337c66ad01104f15bbb5824a4c4c608089730b4b0c9228075365139fcd0b9bedb38704fe1c7c28c4e80c7965d3751e6746038fc9409cbf32ee2f0d3fc911bc6da33ed04c7155800a800929c3763ea3f2deed7fc97fdd3f61686b14126a995f074949e622156fca4c88333ae414d1fc8e6b0ef9b1cafa978458d0174dadb79805743ad61ae0c068c5d1e7ed40f1767232ed7067f004ea14575b20ca0f04898a73b789e1301394b4b8b91989f38d36f6bf33725890bae0ee3994de5f87c60b6b68fc5df2999055468af7e00003c1a99682e2bf05b6ebb6815f67f27ad51976159dadeb8de690cf2635a9f8ea67d5ce848369a1941e00e2f815c8bc6199effc3c70b000b79917fb1a6107ee7e2489cf11d8446fa1ce223eb29698b484d47468e3f4a828ef49aa9277dbde84b6f0fe436f6d95bffaf40d592a58887b1c746a660df8a694d0ac050a9d01e1b38cc73e80b7ddf7aceac7c0139de9883ffbd9ed2ed57bcd4b91e6f24b0aaf15a6dc124b271a91371c862575ab3fe10f4b963211fbe877e7f6f09ee3d72fc000ee43370d138c5291ed3cbe4c73a4c3acb9c75145916cc3fa9ae775443c177584949c0c7940090525dda2343e937ddda34467563d703d0e30d8ee3a0b80e8af320380c80d360dc0dc671a0b8078a7b001c0cc06d70dc06e274509c07c539001c06e16e304e03e33a50dc03e2a807556c9ee940dead9fbb2b051206fc950220a85b2067c91b5b9d3e5fd100384de83a9aab7509608f2a5b54479e5d0aa28d47495720adc03482d00844151c5da0b402290aa6100c45306ac1a805a4149032055cf4c2921dab2f2af9fb202f833649ceaa9749ff7cc89351331927b5c5e4bf3df264a899d079cd12a97f8fb655fd42c9ff4ff9996849e4a8ba90f4e7b3fcac9a9338525924f9eb915f56ed449dab2c90fcf4c88b5d6b52c7b58b257e3ce0c5d42ed969d565a9bf0f7860684aeeacbea8ecef87bc0c342438575f26fdf7515e468d091cd42d93fff6cc2ba306d20a26e0a4b298fcb7679e0c35933aaf5920f5ef313fa686099deb2e4bfcf2c41b5b534287b5cb657f1fe1c3a42dd1a1ea52b9ff0f79b36892e4a87291fcdfa7bc4cb51371525948faef395f46cd491dd72c90f8f5cc1f5b63a2ce5597b5b487f05f3957a2e2bc3a19115fb4094434904e5513d1fcc07e9720f58bce8c56f56f9a127a3291a103a03fa19da6a481d1b667639227cb94274dcc3f9200ff85a5f316e5e2547fc8d7a281cadb2300401732b8b42a4f28d77d30731258b5b647e1639700835fd4683b59d99a50a28e5a8506e2133753073b8654689ed0dddd208f95f159f51caf8abda5cbad49180528bb7ff87bbe4df882a563ce084310b3b3e8b85d559ae817785064dfb9bee6ccc6f8b3965aac4f4fc5ffacc6b04bf82d5949d24ddc836a211d4a8bc5d6aefb50f9e3c058a910a429a5a5ebee014e60014fd62ca0e52b2657c051464d83270715eff06f62ed35be36f0d5b534eea3217368f4729b88ab505f70d821e26754b37f5e46241b30bceed67a401bacd48bbb2eab814d5601040e0123b3b23009e84f17a6931a59688cc6b20992d08210e88561646c34968f540c471894321444c60e53ff66f4caee184ed262684ae6ecb0bb45065b056c77c16eba925a13b11b582562521fbf94873d619eeab70531e24714acbe94356bb91915c0fac77c542a93b488724726e8d6fd9e1a49216a7631e54a89d4da83b200cc283bd4d5731180441606e3d7cc53ed285a6580eb22dc7c814bb801b0fd45c3a95f1d881aeb23c85cbb818bdc1267304b300fa1931a04c97265ced83100e11f14e58db4695f7c1c8f9154906181106d9835d501370c59e9948660ad847152050f176cf790761b770943a707586b658461134187b090bc5d141d0b490e01861f715c3c5723190abfe31685d8a2f60e098b82359419927ef08cfa9f1257c6a0c43e8a1e375b7a460c2084c5c8c69dc9315dc12a80a46e5eafe083b67a826015c0ad9d26a66fbdbc2035ae9cfb0c37387c1bf329c9827c7fe557029b6add91d76d70298e123ac84fcb22ea6ba6504c237bb872d875024238bcaffdc7da628e79d15d5b93620315093de0b9da45ab349c77125e0025d3e14192ffdddbd78c992ea16c449f177c70db36dc6ba90540e44ad7eaec08310b4eed30a3df91ac1d72625c5f80f1e1c68b700c63bc1472d7fac01e7b1e1e1d5cab15ea14c89bb6cd3f14a7e2074df41270dad480aecb3004e0041681fd598297d441085ee3104b634c22c2b123744afdcc0a9ad4e782f5e7edf042f138c6300dbcac674bcb1c1aea0445cdeaf7af129f5d9a11807c3999068be878336933957d889cd239c8a5d84869ac317676cb639f552d1ce6872a78a7c307e1282e4992e07d906961041e389fb11d767dc59235451f269a33781a175ca40d697112c4019f772636dbc157e396be82e5d36fd8ce34036fc3d0e34f1824c5206f6c0f7ad4623cff513d1ae8b997598678ee300ce48f30125de34e5ec7ffe71ad0a71b18c0b9a297fe0db5c3cd66c66b940823ca88e66194138a1c93d979f5c5497187c71a826d3789886a1e6723ba6f82a1c11cef5893ca3373868fe4625ca454c482d179f2d961b4724a0d372e84e8e47f24c2c08c32569dc1d69dc6e9f000d4939d93d25b814ed3b709af4f6e2132bbf7ee55157c27c9fe51f9bc8efea51a8bb93aec27ab903a9c277db20b8dde60a96d149e539fade01961f450c9521889251468649401d99e3538308dcd721a4092ff426d1dc4e52de7a05a902bb29c8e6cb4c6b400021a4be749c5117954894d4bc38d041c2e025eb89df769703c125d2fb449d3b9f825e20e0aa4cf309d77cbdef8d99d7d19fc8be3c44b942beab9e2dacc55fe5dcaa3cbe4402a6a29edeb54433a59c542172be559018c2b2cb972441f3078cf0f478c4b3ea98573cc54b9d39c7a69c7eb702ecd5ba52deaa59da39c4e6db914b92693c743facf9cab8481815aac13f7d9bd8cd655aaccf55654a1fa188a5167a1dd5c7da4214970dd09aeb67dbd7e6de7b9cc72a491c6d0e443f655c03fb3c9d27585162f326ca2bea75cba0676aaa1f7ec5661c3f898862cba4d0d6390992b98d475930ad4219128f516753fdec5e9f9a3261f88c3d61bf3ad11795fa5fd8d13bbed798f3ae5c2ab572aade07c861c7199fe5de3e246d6bcd7685c0c16cbee624bf8358efe934a0443d68be4c9be174e730b76c0261e92439a23dd8562f1e627c3a72067ace8fcc744fa54ffcf29a98ac765225a52e5c64f165bd3171e2256103ea07815e661cafc66621aafb037eb88be171d14db7b3fbf322f2ee8ccfc69e40cbb637fa6716fa5601922da82231017411fd955f291ff5b60f9e6aca056464fbc8ec546f582eca333af1de4f8be44004f5f49e37d8629824a304d5736822ee25d045c4a955c42cc154e267ae73830f73fb4400ca8662a96ccac90561a3651a6c19723c0b279ec9a6b10c600ffcf6f08802846d2358ec19624f369fe6c05a4f5c5fc70f1737911e444edfa7d1b5c79630f852ee8593381c1572ce2a01bfcca1b7d0d2760d39e25463f917a216217f95b7480f8c35d1ea78fcf2399c6e8cc74486bd29a4ec7aab838a5ddd2da8336f85dcdca54ef3e71ad737f8dfb02eb7cd92a0bd07e861bf766d8a1f898cfba50b5f9da3215224b78b2073b94e35e81557b6a420bec86ac754f18d25a279c6753a20e9cd8619cec2ed7c5e40f3fd0d91deb6d5b695c30839cef5afe5694ee893bd8c98ee16837e97ff8619d76678fae59038a343171f6e48881a14ded0777b8f31d467ddf88c7396e3c28b5a0c0b1130bdd357d4f57543cd76bce087367ddb90aac059bb9f7ad5b7b7864e05dcc0912e5e001fbb32cdae097e6f7dcb8f8ee8abc40d111d336e43d78600ceb1654c6ee7a2cf58a117111ee599ca301f8e51d390694c6852b1258436e3b04ae4dc61b19948414e7769919d74d76466c0c5f085272b4aa891b5615a2158fe04e2c0bcf9947c9d22d1e7c08a194ed6516285f5b22743f1b3219755b0ef53d2de56c62207b9865319c97aa71205eb1a538f1dcc31bf7d1acd549d4316199187d44f553d8f4ca4b7b37148ab57383e182e2fb1df4660fc5acf0218b81df436baee404be7a864e0456bec5e71e16de4a6da1e46a3db9692ae2cf9b3eef3be15c99c5d270273c2822b3fa32a769a55b1bcfe708df6e2bbf6b0da0711953c2b8f0c994d21a2b6a0141ecbdb3461eed3f8ec0d40fc4cd5f41728ed510676822062f80bd7b6b3303fc0b6abd4c540ebe99cbf3cae1c2406285d4d2d8e196fe5e32471e96ad92874b4617179ffb70175fc3faab89ba677b890e7b54eecd7b940de69829815257d0d18828705ecee8d1e1ada10e3c4ca96662d1987e879c69c5fa8ea3006da4a3acc9ad13b02cf6c9d79cb094ebcfd47826f4afcdbc443e6cba6e952acd52dcb85b5600fed6f06139ad32680b4552d272c4125d6f87e8d6a10aa2aeaaf64b83f21fbd4bf11b7135ae9e7160db71e7c092d171641ddd2210aeb44428167e1b1f474942481d646991391424788d606f8a12e0544bb11edf5e53413b556bda8acf173b43bf0a80d59a65678c5435a356746fe56990bdab94a57142e3d472623cfc1d71cbf21da931ac49dc89c53c667928155a945770d529bf1335a7869bc80588461ff00e7a4b7be008851b841f29c2050a0aed7bf5d9c8fafcc42baa72df290ad1460150a57c55699ea612977c7200c375657df1acdef3a79437858f541ac3d2dc8702ede5f19fab9913ab0983f77e0f4c5c0a7842fe316c6094f303cc84707f018ddb5fab080a201762fe80d824b7be5e314a8c0d071e20ea23f470162765fb29875637c24725d919eb3c9748025432e9d100f2ff89c44757c2511ec3fa40c4f2fd3f78bb6640696eddff515e7e79e9d2d2877505dc676e6d8f20375f7c126739b5d634082f53d68a29b1929f526bf701604dca66981f86a23af3e80e264f2750cb38731807453791178c54456fca431418662feddc54784cc29a18e5942485f609b4250c7a439553b91b4ac79397712b8c711e8dce38a6243495c741de7f4ee93b3022dd89e03c0ea25463854c1c6c11c6be59a07833e5b21d671838420c4a23d66dec9149024d0425e86718e431fa799261669ae56685a03c2b8c21199162637f1effbd81bc538df7cb13e204bd2470b042f2371b542231ff1db1437efbb1a7fa53dcb25a1213c96ce28db42568cca10984c75a1a8a2c27176572da05cf340fff011c729c307ce33bfdbde6d7b315393024c2282bc5ddfc46814a12d41760ec5f96df39c397d54adac182132eb666aa8766ae9f5f680128105f99410ec7f50859c95f61c5269a63cde2bdd02361958a9f1ba3bbdbe5197113579560252aff0a57119a638af448cdc2ea2fb021e9dd586c6b519b73d974044fc3d1619f30f3e28219e3efa78f54990ab470b95bb035c8e01a31421766157e5544f5c5d615890fa801adda41379d19b1c5a3cfcbe92128644abd19ba41779d93590e6492c8e906e7454805da0cd2679ebeaff1f941a278e3e34cd2cb76918dd238faf48b943d4eec898381394a41bc3328518124d8b3a954089d52c9088ae045065fd54058d9bb60516b11a76bc3c24389a0901f80747210278c631e381384edd8308b1c7f866b30852a49bcb74411cf8fb2c1901729206b55b077c3ea573a6ff8d26e6c808942ccb88c0222670bf09b3df601cd76e344a20d53feb9f016cd34d9394412dabbd1bd7fecc750dc6aef2a40230633318f76019b0e4c89b19a17d3c63b6c73b3ef5532f67942bb4a7f4a16c16a0d60c412b311501d0d51f3a5a0aa8d692539b87eceaded56ac132e2acf2d9738ec4944a45a44c40a1eabf38f1149be81277190664186be65eb12f61b027c3d3a0c842819830d212ab7635d58c976c14784e414aae792c9d283302a792809b2c02e5db13afd385c2e6625d9f79c07d58f6093bb4653d3d0c172a51c94a49c0756a9b7f8533499bbf3384a925b153d06169c6e02367f8d4ae0facbc659ffd89c3121efbee219445f61dd6eb9a057e199a973627288034013206dafa58b194eaf76090d801219e77cd01df6a1504d5f57ea58d351fdc20be8a9ad5ed4f2ec78320c47a754ee8b0ec4617a3935ac5139d188a575c3fc01f52334350e14d65891dfdd2615658da107bb3b5ef1bd177828c96c3d9df2cafd10487eca304507ef4ef022b157d4e2830eaab088f6e5151082f7f43b0dd0a983acd8d50862058db0c3fcc3fd5863bd0c7578144eb4e42431c2c4d6f435ce6f795adf34e919c367bae02b5241a32e451c8db62e7a1bf275780b85e7e0b8996a0127d920398a6ba60531d7ce9cab62e3d12c634f9cfb015cf027364827718d40891abec56e83e4ab53bcdd1da577583d8b2ead4380bba0ac41e8b817b310254a56957e14255320257693c97fa87266b1aaca70d561cb397bfda00dee61f0488c7e01295375aec4fa7483532aef4c6d1750f8b9e2f56d1816fb3aa83ec428485c02f2170249b52d0c24bd5854c8e3a46a92ba5410b709952e55c3673f58c7d166d5bc0bd547b7a17347ae9cae38e121b5c4f182a955e286be5ffec09f1032a063c7d48784518df844fbf46cda52aa51b1591514f4ebc0e1260219c372d5cde8c922ef99c5e5f5517c62d73d0591626287b34cd1ccaa6d35159c0ffa71b16e8eb13bc702168e33ba90185c946dde7a7a08c46f79d731d7a6a0ed0c1201094fba0f53faa6155be8053aa1b1a7dd85cf350332a20084b86c4482af597e17e3b3920fa2cce942185c9721636dec466f6f93660b7464c04f861d9aeea848617792ccaa7c5d520381bb1d360d38b2794b1ec9d9aaa44094ca90593e9ef3d7f15a0601477cb852a8294bcd4545727e98fa5d138ecf05f86c6f8723e886985c09fa9d6491975fa00577529f7b638f6d086ad051e3d952f215771cb4abab01758fa1711ee5313270165c8bcfdeb63c8317068d9268b0f7f6f22108a16bf38f02697b873309489b038c6c40280bd28bbaca0486a5adfc90dd0017ae736ab3bb0bdd306b8003c5d413fa2809168bc451b6b61c310af53f64b4d784bb43c532ee440d5409dd25c0303b4402ed7b67b94231a0a1d86afbf5398a48a2c024ce33238e93e27673f3526e87da6bcf9a16e991ad0d13c81611f4d5650d77366a17de0462de76d02b82db9357e23171c269c65dc92b215864b5b4e91ae6dc23e0bc3643a90103b06dc0c450083bf1767b2875fa0c7c3e264b91e3a5c0bd58727282493c2f87f4af126172e39992b8c331ed13e5048e8fb5eaa3efb74032fdd44e007273274d3662ab306bf8bebdff987815ab0156a6b8ffa0da1c7b79b86ab5192fd30972b1c2032eb2db38e0809c44c76538fe910e1cd1a4e785ac2f5150a0752d584b2bc658c8a01b524d339a4bb970bb5b6ed43e82e986a1fc048f9e2a491cd9bf2c78b08ef486aa02e3917217c8b671c7b45f8c8ba700299ed127c3d0fd3f12e8bffb7c03647876fa96552241c9eed3782df6315a43252a4508f12aa200cc080c7e3bb8ee8b8810b8def132f395fecee287250f6e7bef415ff10119afcbfa5ecd1be4add1ab234fa30b8fe5350c13d8c17908e6728bae1ba4fc1e1c072b8c94f42faf58efbbee59de4348271fac73e1dfe7d33ee46b7558f5c4d20bdfbcee3e82cb9f1618256d501a2e0e9a81b8d8f0d23c04dd23fb6990c884b9e026590f985b7b1d31d6cad366394c811a88fc52544147dafcf8a57bc068a26949fc0c26256b9fbc7c3f503fb9630a2dad9f2802495eb3b898cdc6aaf95c1c70bf3630edd9352a5faafdd8b59c78aa4de6a33af874ed960854ddad1495940564679810673f13cae7f9cf014664823e5d40ffd8fd6cf0f053f6d4fdb8a938c9b6784c72659ae660422036e822910a608c50087de16aa0243f3dc44511681a42bb82d9d608ec7b59f56da555af749f0f1a524d28e4610ecc15817b9f4da8370a5f98e3ae3911b0fb12bb3fb1ceb70323214537a74f0516aa8726468636e5302645dbec7b1fbec1f0006efc71af65f4c54d84bcf7b33f71ce6e233ee13c743f169279595000270ca94757f4f6a3f2f23f636b40bd317fecec2243fbad6db8ffb3dbf1a50eaba69872cfe5c2e5eeb6c29d2637faaf37aed8639fd19f8bdc51f9b1341b98ea34baeab3ea9689dbb02572dcfefea6efe9eba3ef0eee9d9c569472deca19cd46b1040753a4967e43b4e22243ace19a2c03e5d295f28df8435253d1f85abfd4dee5736a31ab10e155d39544596d82845fdf3aff5fd01e9a4ab2d3409ee730406192df3f389f53caed958614f1bc1e69361012689030b0ee149b52d508ffd7c21905d1a9050709f6efb9c53884318428c4858d1e84bfd64d10f1d6a601f320ef75dc27ef429e329a90884e58fba1f772fc0f5dd7c210f3bbdc3ef860851841fb59f2a26d249150129dffdcc5ba1fefeb7fa19dbc64b08bd8e4410b456ddc15b59862bfec4086dcafdf66f97f538585d9ade8b4735f8d084c9407525491555cc01a798c5cfd8d6915b653ba1421e095f9f36d36d9d54314e842dfd3e4845af1670a8b444320281f2100b47dcaa3cd6e88f414716585a23bcabe91afdc83aa9fbb4d781f7cf4a93931f424cf7ad41d3f7e9f84dc064ce7c3166bee18272e8d234196161b5f3700aa67c2cfc2473bf94adbbaca9a9a5e6d2768fa521fb6359db929bbe74eff0906b27e5654c0aa82ce381dfde34df49cb993be982fd633df33106db0ea409144e9d8af5099a657d6b3e7048111ef0a8856b7028255e375a118f55aa4c75ac2b912aa09fc79e8ffc4b9ec686b2b7c5022ba457fb392bab81e9ddf9cf7919a07dbda1f41c7ee671f4473deafdcfb01f24ec3d74992d38883508a31784d8eb87d995275d791bf8975626935584fb06f55c3fee2769115e970228f6b7f4d1c2c6428dcdee9083a82026346f49d6f21927895cdea9b7d85d8e79b9e044d38d72e1c925f6e1fbd26958299c4a6c2c84205cbd03a12a57526383052cc0c24c90f62dbacbcad10c44de686572c99702552f8b1b37a9bee72d7f2e7e20aecdd73046c95c818e66b66e6142a8523679822434c4221076fb208746202dc2f8abe131d096881c366668de033d150164ad7ba27ba1a3ae5eaaff0b994323413ab7198536fcbedf2ff627a7cac37bc1dbf624eae3f8b7e8a8805fd163144ff5b9356c87e379eec00102d365a4fe0fbfa650f0708340a39020d484505342dddb0f04658d637f106642c9b55fc6f26933468a51049b8ad3e59b05efe56c047357d553e9f428c4b44dac044f4485e5c85f42a394f96532c795071021e297290f51724e578b741882ca0d4832bbb48dc05ff6f542601d9414462538b97e3df592c901a4e754b7e4a4a76ffce0dfefcff0d54264302a83fff43d7ebade7d0930f5fb038945503c360d5bc206ff5ee18369bc7aed8c57d61fd12f04fe29c8a97c14bf6b434223105a7694cc71d795c315f3e37c936a20cfcc42600d05e0d0b936a2059ad9eab76815c6a938bba286fad6544e463b660065cf476d600ff0fe641cf3e1ecab36ab16e30892ee8ad8c18a724b8759a7b718ce9ae94728b2dbdad7198cc3ad36fbd4eeb8a1855e14d989888b6d65b34be223d6a152d3757723621886ba44e380f2ed0082086126310996e82ec742d3d52045bea78dbd8dc37c5303e583f18db09f8e075586237f08860662393fadc0fbc06afc49a57ad50a7fe9e7e9163566ff93850b988f75a1294bc1ac150be1f449883bc9590124193dd51410463aa68afe6c1b29f4509c660f86e75dffdaacb14f93188543f695f0ac49d11380853c84e2edf88bd83ed99dbf9012f91cc251a6856a240eabc5755dedbb71e30b8330b80b41a75f5c40bbf3929b7e99a8ed341cbe01bc1f824b8c0701e3c00795581cfc9bfd4b5f7de1ce533f9e60106009a1748f5e1798be5b3184dfd696dbd4249aa32e6846cb5817da8280d221e03288b93eadeafd768f4b0d2055ef2a32369e6f71eff7d8db951a88c2c2cec294842de1a62ac0a7c47ecc6f3c1f9eb1337935dab2fbb8e63637cfe067084ef586d862e2e9a48d1875f9b2df6bafa846d10810d6ed6422d8e3f3115f8168597f6f0d7d87bdbc378da3db6a32d2d162502a0f9eb7940ddcf532ab6182f57b7bb62317ec7cdb6ec463d6c802747482951a55bb7842247aa2e847af215ea81e93afb1095cd315b839e4073a97f717f9cf251374fc192ac190390c66451f1769f2b895a63fe6092ef8f8d9ec09a793857ac85684e0df92bfcb6a8fe11b69577b23b0addf2a6cb3806c7c643397de7228e16ff1b4fd8f3722d5450027b652fc7c48804c71ed239b773c48b72594db00576172d345b50f287abc1284ab52c28b818b1906429594439344c6a4e5585a229b40c51565751d52e659851fa1ab908d237e649808be24ea99b0405e8ababe1ca765307343531db4187335b096c689d668d582edac7047878825840ed90a00f8ef6681dd759f34462992265498c09e99f4f779829895e02041b45d43b525bcafaf8e600b33fa5b4f8012059284992b1bc86bbbea350597a498abdf3effd8d31ec6852fed4bde085665bef81ba98b8c9777450c473bc033efc8b7ce275868d1ab9517abbd105b9fc2504db4476eb44203a62aa451ff06f8c38697b7aebc416cf000bf6c17772f27122ab280afed2a2a81705c7fa12754d087973f7011c960e17fa3cf4df062a10882a923b035edc3893ba9d2a77126bf1ceab18b383c53e3f0f81b0caca25b0ec797312a8d57c1e02c096979b40d9e7e625a06c2b6884f990776698c2a391b8cdc50feb8773050fe4c8112f919d25b08647e972010000d2fe751f230b254e1c2e7162f552154ee96b0376523227ae1e8f3602405e3d0d0769043b35c76ec6ca95d9603ba2f8214038b98df3d3e65502f5f3105616d003b5d22e35a91563fd0b2630fbe67a14cc1c130240859c88d04e194c0db43c3cf40cb408ac76ee7e8a761c38c3e90272c712d1254a4f63d9dbb663c7e4b6b7c6ddcb6f9b45779f73fb6b748f1469e55c5970d2fe586e601b75ade37bebdae9fcde5cff7ed381d00f5c40d1876f5b79051c8c040aca7324ca7f83646348f48c1467e15e19cc18e4470b2d4c73acf9d72df9e3c8a329b951ae0da3d18da13229b40197f94e5aac6a58577c7be682b66955bec4f2a0c8aafa07ddf5efcdaec4f35b793f17395d791780630cbf6fc5fa5f1e5d15bc7baacac304111f49b7140c2733d98166e027945feae464ab690e085f60a729981d8975e68c2cdd5fec1ce27e964d8f7b5d8a0a9c23eea98c323b36287297a4bf55a67a6133a7ca4dfdb90d42c8b54f4a11f9e76e4ab3858a3828a9bddcdaa6552b7b64c2571f0464898c05b6f6a6b747b4b5d30c156e5abf1f956f6e26914dd8bb0f42cd8eee6e9c5f2529d9e66e27a61d76e4e0ed4a0196af29ba99ea099453bc7f5529d9676ed2d80f9f270feffd5505c99fbb99627f78de6cf8f75728257fd66d9ab2878c7c52597a1a983d52152027aabe702fde2ee6f65f1539d9e5b7a5da9dabb705fe7c1489e497bf9568f7bc9e1d78f3a12493bffc4652fb734d6fd84d8111480a44b634bf8ba2c214061c08c5c742db378beef95f8636321fff326c5b249c0efa1d682aff0dd9557bfac0739484e920afce4f1c01147ed3661e81413e6fc4c584a48ac7a54e9d3986cc87a81ae2edde442ea4632ce4d0a6929f5856a6af0f56eddbcd9ae7b8a668129fcd2d23a8c9bb8da47d4d16ae987099d1db582c719f7b87d02c20cce0ee19113ca715f61e08b0510174da6ff7d18f7956db67fb09d7987d98aad837189535117a8637c0f15d67009477cb2d6ae2c22e01c5d8d892456885dd30340a6e327eb032138d28c4fe50594e6c164419638a1d74c7afd4132b53b7772d8aeea61ce16159c97867544ace78921f2c1b4168eaf6506cd9514622a98eed4cd1ed3ad55269e2382448742a1c7689484db4c011bafad42dc73d5d64f93b03097a0f9ae5886745283616a789d2f1e5e0d88852acdfbb920581066f3d28336ba02dd0887a79f7ef3b2b055f9bada3d5541f4fc7cb708a3a03c112c19c3d868c525e4f9063946c7740195b7ca0a9e2ae213f4d720ea413b9a2e3abaae397ab33b06eaace27b8c3dadd840cbf5ba6d0dd6f19d8038ca627b818e3fb9d4951c7da80ed3bcfbc046910776a87389f367dfcf3b24c0c1312f8973796161ee298349cd2b5175cbab35f89372a179fcf2ddb5b798ec6f9f4f6f389c69bfe99a1394020321916afa277a4bbdf2486bd5f17d1babf8ebd59f4f2f8bb3bb7719ea973d7edf2d2871e6c796df39fa54cb17aa50e6a6872d4eb9eb8e8e8be4a6a24cb590ab1c5e517c7b18625a022387c174d22b6618d2f582ba289852224c9fc69cc3207ea084305cf5fc1301672e2a809331fa7ffefa04523a67b6fc43bd5b5319c4ec73d10cf44d74efacaf7939a755aa0a683a1aa5db6388174242194fb1bbc69602a23241a81cfe574e5245c556dbda03eac64ece5a5b19461225e3006aed1ea401a5137c07a50dde03604889e7880917cd7da84df57e9e70b41bb5e2007180489fa8bc11e4e8b5a407ed72ae35b15c0df7a0d3ae4a532504696e61ba6f9bda0166b2b8d7fa49ffdde1eb2414418e1df07ccba396dca45d2cbdcfd72ad66c54a74f9c87d2d8fa006e1ced177a8645d7b171f1ca95789a8413de4536d70eaa16e1c24cb1066947de1f78a3bc61c60d43a7a259c3fac2c88ab1acd05b89d7fca604c872103ecd34120ade48c48ec79b0f934c07e47b167163ea3fd0e07587cac6b01923b6ab899ad380eef4221f5b25d736e590f5e6754b8b526b3f3ef2b0f3607c3ff3e8ce465b32826e98132d27039d605b9dd9879f12692667763020c2f10976797c03cd1d17181f0966b1c28e3ecc02f21e5ed3c5e06af70544eb89ad87c4528a41142a17f64ebf53c37b596fe249c24c05a82089e627cfd0833878b6f0e42fa30154bad0e8e60d86d917d300a5813967eede2371672ac81cecfedb7fb665c905b4b82749747712bae563e28afd0464039f17d232d581f42e2d11d6fbb86ecd97e88c260eed466455c4509de45dff9b147036af7b13f2224bc02d95d399279ac5e4be329a76bbef6cacf5135988aad925d772a87af5a5edb0b4afd1250ad4a816ddfb33502d620cdf8af3cd12a99bac594440b70b449a5b9cc554a2d346a41f6a66573fddd506da59e98bcda9f3fdfa4f2e0f296c427f320db8f664ea695a14c39e5fc6ac557e06d6082f62a185e6b46028ca4cd3f5bfead0113ad9f5c5481ded52605c2253d698e7ea006260b63377ee59c46c62e8f88c628c09bbe306fe2d2976946b51eb0c6ff710e08db721f1385101ac163a52149970892eea45666c2b78e941ee62e6ec7d9a66828620fe053b607fb5bb1634a5f4a4890028f14b8b4a835ab988ccf2159ce73eea956810dcc221f6c88cc43f70a8724c6c748123940cc95ab39ad8d70e47aed04d303f3aa07d87e83528fa008618157ef03ed4dda648927cadc3ffcc0407f0b8d66c80a6b158115659586a5ecd8b68814d246a9fc4674578da4299a27eb1618fdb5bd4fa8d188b84116d4e4df7fad24b449f54d696d5344f4a3230b29e5db91af1d6f2c6249146b1f09444db30add7f8e88ff56644e834ca313fb7cb25e394af3bce32102f9b362d73aaa16b9cde0d4357fb3e5161b0b4ddb7c351321cd904626be85561da98739397c20339ec68289b5e58b83e0467a0ce8274e6832eb6e43650224bd2974c867ffcdad9440dca8c9fddbdc8b6fa701206ae776e55908691fd9a2842dd136482f139e1afbb4272de27e0b43df896a91e0fe088a4b2c2bf2d33f11c30c68a19e196cd3ca97331f742249d85e8a35c6fd685f28fa3e66afd842b8e28865035e071ccb12f62dc7100ef6952c032e1178f8db0958fd2b20fdce1b5ad8c04d65410646bef32a6b28709b5d8166e302a6e8e97742e158b353e26b0e9adbd6c951dcb4fb6155f24c93f5eccc17bf9f20b8751ada81f2a1d1d2489ecc3df5e8bb7c288fe91be75c22d6a4b3a33e58de84f6bc2b01a637ce05cab51484ed0a166bb966cc23ee56431200c1366c6f18f4fe64a382aeb357c7c9647c9340881f6ad95b6fb66b2d3e33e6aa1cb041ae66024b0e03ddb2fb17ee287be38977d06c267ec9025bdfcf9f347bb9f1490f2e492c788910cbf486a1b5e87588f4b4d6c31d4f140be49b8d0c689adb3adee6a82e89e9ef1b96b3f00a4b3a81853186140aa4cc599f61882a55ab5cb8a818acdb15a6e6037f85eb0e411a85ab26da0f994c16cacddbd562dd5d9c11b64e4d297bc70cf39c32c39e5b514f30442637573a2d5d5bc45367c74168e68a45e830e72b165b66288af8e19d8d2465a255c7d966a3ae693f92f20269ca9588f4ee5130c91f8cdb4820d022723fdf40b916b2d1c06cb2c9e5708e35c726644dfa2b90fe627befbb83b30a5a59cb119d0f6c663d7b69dd5b4bc410ce5050685387610f70f983f45e5d798b0bc6845c6998d7888412bf77967103b6e399099a41feb3166a887ae81b1b4e649341c9c9e51e6d6108f3bf4ad754598ff0821673ab777f87f861a09fa27096be0ee0b098377719fc331bce8bbfe02ce9e2b24f767a56402ab456f37e0eb21200575135286288306fc9c9dd4a10ef4572a7341cbeabf61d6d5ddaad70eaee1a23ddab6ef09b9c4d1d61807439282c37c798894d692030d16e8e98b9e18e1e7a28934b626b4d105e22494ce31642600badea37e18b34866762aba2c8f9dc4fe641e99c38045b426d6e40069e08378cdeb32d0abdaebe8851edf018661d4da4f875ba70ca42fe75b48cb0edb58e8952f04d181e5ab76413902e26fd1a0e93382b2e87da7a5aa1402b94ff02cc9d2a13d9b56b65feca5f5089f74598e42a5c91869c25c432482fa14f218b60dabb5f6bdfdec9cd2df10ad2d750570728fb69e244ef6734612630215ea29ae0c0c02fade927e1fd177ef2892b95fe9392f13550ffbe0900c9a6f7603e2cb13a77f70ff1fed2b4f4efc2396cd00dcc344809d8ac9f9b0517ef6b9839430a1ee307687a72e588fe8a926da4aff893636ca2f8ce337c7d8e30e7650868e440edf1e1f1a0efa9810626673372228e1350ab8179ea03b9dfa94e9995b3a3b6121418b48af77a4a2c087fdb014601fe736ae80cc26181978f466b221967a2ef7351d60c7878c2353c8141a334c6ce5521b8efc5a15a0b31e6152ebffb9dd5c3ccd35a5cc4d39979a1db6c296a171b5b4e62a97000ddc05b6f0a9e93590eaf8d09468900a2ba254a9dc21c8579009c427b485e96406b5ec6fe0d6ddfb165eb5714aa64036b1d99db667b8e66cc196c64827d6d967c693c8bbc9015506b93b05b317b76ec0eed64889fe618dff9aecbda004915fe88aaea7d9d06b4332245e660571f4fafe4da9e84d32261fb3216bf3c2355cfb18396844186eb8f55827beec0530812aed470a68ab3fb9442c9de9ef26b3a405bca2ad5e97e4c352b7c45cb32e890c498bf870804eb68013a0b3f8ee810182e4aad47d1d65213d3ce905b966726392ce69cf3955198bada521cdaebd77d538b3659c6ea428ad96d7918ee5b3d5d50289add16e33378f28653fda087a527ea08f33e8a1b7241a3e6770f32f0d9b78acab098f8eb1529553e88daa6d68619337a1651ec27659ee9683f36db19086fa73be70e04548dc10235a9a29c18c0fa48d6c04dc134dede492089619a1824587f1a9526397483f13dabae8f2b2172496b66b8c5d860d940216313742f3323a9e3c2b03e59dc7ececc679c49407b056d6c3806b9c8d0123913b6510314e2de36953533ae63e76a5d125dea4da9c5ea42e9f3a9e25599d958b216c2e035c13f04b2615aec119dcc812a6b17b1ee4a09340acb1846521fd056a366c9c7479b49c20731f886a56c21e0796d5ee19c0b6fa4547fd89d653c56e0cb5f3847c15b29eb1b9863982d94f20be6507823e57ac3e92ce3b10a5f7ec1398200a1fb9555ac267625f9868d5301a25969ae2a8d7bc0d19fe4fd8730eb7923e30c06e8fdacf345d2bfda7adfa2cc5652b8abd4ebef29f3190c3dc36f85248876fa2a3387d544ff00f64df30534458aa0381028baed1fda57a5b329ca2a628a30e834c6f7e09af9178fa2eaf2fc49348dceed4f9417717142be3019b94ea5a9feb4b2fd082e1b099ff8350ccbb653b8370b4f9ea4ee77cc01a4c9f4894453645944cd7019e4a09f647024e843e4a0a06f1b639470944c3e9b5f40e28d49858f86dbebc5db762bea9cddafd721e09b8762adbc1eb3f8c0a026636e1a943874b406804ade017f5fdf223a380321c5c98618afb3364209ac28d130f3471e4628473d2a3b23d6329bb11e2da10068d1d6b8374bb4f740919bd7f8cfd9a5de82236dd38332acc8e4440060f8be477c7209a745a4665b8bef4d7629a18813d7bd24ccbfdfed9021c0227a7fd1ac755f644eb46bc9d18c8ee4da56d2abe4595594fa68b54c09502fd59694cbae8dd33929c59fdf546020954bc63472b26f28b3e321f306c91256be8c02a7cdc99e6b43d350fba9d24df29fc8a93030f93776590a357e49ae0d03c40b5b300e499e90a2022cb8743b9e1af3834b633c8a8a6320f34c5d9ca0f298c6a17738ced89c2b4a1f826a3aaa76fa93303a979e3a04250ae7b211cebd2d262fb4533c9796e56d465e1a4f4db56c5027ecfec255186b21e31b5991f615164b2682d3706374d6caa680423159fea37b475770ec849f0534c9a516922989aeb2e61bd965ded4210a2b28e7fb21effe49ce119ac426e181f848bdf3fe6435bcdc9e114b5a6b0576adc87231ba064798107f311f292bde1e62a0f6f79c33bc7f61820d90d4ad01180a4a7096845f8ac9c2dd09c941843688cf3168216ea6e8bd5203853f6f6b5ab978950258a90b2bcb637ec844f9a96e8a0dc4ef08e4327e8e4a2ad493e1560b2da6645792b08d316c40bcc6c2f442727679eefd8fad4c19adb18e07f8bd74537f06eb9530330c0b992a91e0d95d6e62b3acb7be3bfa50ea9d83ad1d00a0b594a813ff505bd01f55381d386c0978bc589cb4028ecd7519d91144ca24b8b7e699c1975c5d5193d697d0240a382051943c2444c1a58f5867f364cb8927cb55b475c0b445f5a91821b175456bad3a4617d4e09ef4ef756179c06611eb4a49cdc0be82efeaaf5cdac56d3fa1507e285155d40212bb8af207b8bfde03c4956795f187a121cef8ae1750865d4e1914bca7710927441933b80c68ed16cd388ec6c8a132573a1e7abba1ad17e9f8e0b9a93c9d0db11e406c7983c42e394f500bf20bed9cfd781c9d57c2c3798e3b52722cbf8e603cd82c3b7692b38a02f42ad838a2ff4930ca63b8fe6cf37a56d9a48cf5878d23ef04178bab4855283bde449035a147bb4d108017f1aa777a72272aa7c389fc5a8db2170fd820991d8c5070834a17edf818828da398614b6aafc9629e4bab6c1547801a826dccdb79f78ccb38b8eec2872c5bc7d6a605831bb2c67a8c8052a65a19eb049a63606a0c1c2b67d82685dbfa6a9b3ab76dacf611c516c62fcfc8de84825393a6fb9d42ee38d3fc3c53da8557769b5a98c6528c5a50146c61927cea5089e9c4d596b529e74ddd3d9d13cee41bb744db68b753894486c6e897c2f5392e1baf303290dd72a530b8192e81c25c66cce8dbb0ba02196aa855bab08ab92774f8cd8262c3ef04f0658f30bf56142999d0f75997a18ace4045b5d1da4716ec64a3b3725e6f252df4134b2e405b41a06d669ed010ad204fb250861bddffe08f5486b81a01d95c5e5dbb01022cb05094c981e73a5c9cb5e9e5d03df8d04cb8129731b93d2f8f9916c2303010f75a17ba8f54f05a5508380159ff21084cda8d5a55e31ea9784b666c4306e82a2115d19f9ed4979b3774acdabfe5bfaff6874fb5c24e1053b42fd5892a9bffe38901c8ba110319cfeb39a03f769b67aca52710c7e88fd75738e1aaf37ed04b2b295326cadaaa6dd7346e530ef88484b1bfa769f50f672b3b82feb7d11e946dbe8c050cecb6ae9a441109ea7a17d7ca98694e4dd149d1e292123e28b31055f320b0f4dfee8d3e6e2520ff74245e1bfe344a8572c5b441172adc12a8f33b393bbeed8c0f7e2624b7bcb57b7da8a1f53fa5c8b599b7778bd85cb1e8b90cd987dea1170cc900c5e80db6450acc99fa4c8dabb159ceb1140a9d2aac75468400494e733781294e93b38273324cd3b9260fc7053b0ba0c69d78bcd230467a9a4ddc5d8c06fba4da7e2e4983aa63498dd69c04a5feae7a93f49c8d25bf83205a2cc0f6fd176d32656387f33c83ce4eb96275f532358b9e45bf6a2acfedf0147f17a310f8549884c3bfd80eb110ec8ce29cf41272220fe960ab2c59964e20a9d4d2186b84b560c40167412c0758c51503fd0ba4d3ba864308742c75b05dde782ef0432ac37deb30add13dac0e6021705649e82d2cb8e30b23143e04c643738ac69cdda9cd97f97cbfa1baae2b076fa78c3feccd32962bf2e9339893301b94f30fcb31e8564afb067320608bf2fc177624ceb4a1612a5ded969beec3a10e00b84db5e8180579da0abd40dcace57de8705d80ba468a365ccd0c8c29397fc10a58101a0b71c4524f8b8e3e85d6b720f08507542e71b29501daea58601a2f8c9ec9971cd07b38a18f3f2bc68ff3b6c7532d9de6c7f0a9a69637f427f2bc787eb8ff8e40bdcc9bf18ffad53c3610eba57a53abff388e44db0da5db1367e80b51fa709a30323c59ea2e0c4bb7c9b4ab335648d49149bd827e9d13fc7e7c977aa5d38dda79c7b9cb600b73a115989527e80f9759ce975fc544bf5e00454763bdbe29c47f2cc7d97aea1368fc44c3fc5d9115372a9e429188985911900c62fb737308e290cec5dd26a37a1d835414d620f17167cd15dfaf2c91c911c26ad604b79195bf96023745a32cff21320bd862cd4b8c382d92e8d1bd75e120e27905ee7e1748507fcd0fbd8cc395c46c641b4d881e1f4a7380a7abf9d64528ae1a0bd256c41baab928948172a5ea1c50862454782b70148575c771211488a495cc77e969c74b4fafe09711c6d7093ce993e1f190e4bc9645352354517c34bb8ca173ac6b7f6e91e56d16a6ed899020cdf524af9e93dd333b09b48764117ce6eceafa4a4a13702538e667f8b04e99ada0b28902161f7edd4f0aa5d13be4582d4553e409425091f71ea261820277a1f3b392e5e7bf6857c3aa5ea07f07211f31203572012654e67223fa74f351475492bfca950119b4a456c0d9a1938a56181b6ece68e5cb76509a6ff4ed0a797d5b55536190baab4be3855014104c153e9e00853e9596f5ba6e5fb6ba70a6c279c878609faa35744aeffcbcf3e230a0f945db6c042ca2fec4ba59e8eec387f50a2dbf815c10a229a659ec44b63b3f866979d17c97ab4d34f0e0819ae8f627bc5a03216b7c1738513aa8905c8763ea82fbf15d4a5b2e543a30a913880f81702e8531d9f9e3ba5a2aba1cc21a1c1201f9d6d3984d6be271c24567791a708e638ec311843eaa32c93b89971d0d0b948d414899597b7808d7360cd5cb10eac20be53dbfa3ccf25984240e3accb26ef25a55a3d4e40f3f83b978032d24a33a07c78b3973eb5ef8f7dd4c63c8c2fcad8cead4589323cdd8ad1a4ad21b9d087f2154d954c959ecf3377c2e3665e9adda15310fc12d38cc20ab519f7ae365737c9b6ff33512a8f82efc44c9b171fa73f85b7fb8241ad0a4d545ddd6c606cc18e70006e4e0d534815d66d7911161ba83add966935550e28e1d90841a64e494143b21c5ce32e664a6487df95e2aa585fc49fb8cbf32bc2be86957dab37855bd4c99c45799a1d39835a02f47f4bacb97aaaf3b6f19a82816636a2f80bea9e4942e18087dbe52b1ec92a8663ac03fecb21747e7b0d2da2cd2e9bb80cb5840c0c27960a577b4cda60e26dd948b112d9ae621d81e2a56f2ee0aae1a270146179a6593246baad2a5fe5e65d097c66e90eef4d04a0c2d4ca9f9863fcc54ac54d9065758b8609d958a5c65b7c49de60847170dce5e6edd6590943189853c27ea5d049dbb21ec523d46b5e0d14a8f528ad5c750ce35580c3a61b4a6e6ff68a6326b9677178fa67e84c60b15998e339492af73ad20005e7b0ae34c7e1146d7ecaf4874fa4ce97dc541b26aac593349b32020a8a6ba57cf188cf3607170fb101f86b4310221b0c20fa290d96e9c42111a286e64490c3dc45f2e8dbe1546fbede92aef6a51fa8480fa5b21785f59571792ad4ca1d7d6b3a5117b5d20c728eaf627ddaa20034a08e10b6538096375847427270c646ea1a797ba6880a0dd36e5d00490904022f9643f0b8fffb53ccc01546726428cfde3313d66d98468914c75230fbd51e112d38cc50a9c27e6da079282c651f9eacf760e907890bdd26f1838a9ff1915e20fd357008b0a166934f8bc4f83d8a71adb96ec23c6c25d95812a28d8924e8981bad767ae1e8e426b1af0dcb24f7306a4617d25598e3188525caef981c4dada077696cb01c2d3edaa301844ab3270a22addf3e2a8b59927e4faefe39db21ea7c8973ffe32ccfa1a245895c513d8f329c6a5d25126eb5e215f53554dfe601e5032be3b7725907d4c5b9c3f96995f5970c6a2e353535626c7e3d8a60b4f402efd6183a6cfee9139c5724dfe2bd5ea8e9c70c3f52b2e91a23bdea04675ff7651c06dcbc35215e797ab1df2a2ca2fd6f0c9aeed0700e01f5127578e807c3cc1d86d41f79f355b0124e0af71bef97f0b3bcbd17cb0078548b656eee0daa5cff37c2298827e7bd3b03050798b2517c069ca36c644bc8816d6c0875cab47d22fe0549d0bf73fbcfc44bd25020e502b0ddd32022b065a4b9f7daf4964d86fd3d8584856001e6c480cbb400da434149dc4b71f6b0d234497f840b36ff8c1da4638dad478c276773ce83ec65074ffc67ff750c22b449b4c40c040cb4966e9b7e56456f3cff643a34a5a135f976773473fdc3e159be69b6b87604e4b04385f9abe759f4b7a5859ce79531880c78018b2277113bec70c9fe48693c53402fd4c1f8cb8c4a371be0c46cb074312b2a2a1f601608bc56d09eb47c9010a0a0cb428865d521ff17b757f6c9cd25a9cfb45d0cd751bb4676869d73aced65105a1606d94c9a023731cf4c01e9dcfabb27a059678697ffd48937d81dad0bfa98590f977e248b39d17aa2d9fe2edabf51a2283f8583e17bdb0241992fd89a9007f0a923ba675320a45daf41b7f0b00490a107115362aa16f1570b9acefbf06645a41a3c868774c7249ae2b77375c94e93c4e9e2a29d8c43a60af2c1f9c3dfaa6a234810105db3795ede906dfc19b7e9eda26225e4eed4ce43e4a4e9d41a71556f507e78b55c018e6a6f6997e3051bda142d4b84c530181b93920c8e258c4991ecbcc8a06eea8408184b88def4fa906f59d2eb096532ea2ebac20f4cb79efae1814086516486f35de3459bdeeb8d9f12d5e95a08141638128c063bf2b52d044773427ef5dee7360270b4a507bc36d37c8881f5a86a99ef3abf51594c9bf079f391b59464c96fc2319644a5be30a1c009ef9c205b86ac903c21c11092daba944714d2d997e18b2e3502a7ab56661501c4c7cd210678f42b6ede3005168d7b55e3c5e70f8770243f9e1be5d489b090f30d9ec24a31eba25be0524fbe5b710306395bb930f7bd3ed4ffe0e2091be6495f4a40ed063bb2bd5ee21193836273069e9a82744d37c9d31b8d10d8b9eb4a87d6c8fa47b579519c85ff500f592df69984d18d40ecf2f3f593aae4493f84c69a6f3b6f09b4dd9bd81d3ea079234cf6ee08281cb5de7c6f1894c5d35757d598535a83aacf5352f447abbb3ed109c1d3601122ef7f6645bee1426f1039aebefb95737363a73999fde4655c093872dbfded9053c4752d364edc0a1be8668eb8278004bc7fada6e1f286512219da67f59ed3ee4562b4c3ebeed8c9522d32db4374feeb79dd4f9256ab82104d13267d0d5d05ad4de6c21ee569f310158116189063624cf8f687d8da80d2ecfcfb5390b568c8c941bd30b7d7d2ff1899dd792138601cda5046576ce52b82a112745d6948cde41b28493571dfa3b80b0ee792468bb009e9c9ea63c6397242dce0cc71666c25deb59e1b4f54ce16c610670b4343bdc5acf74c36b32b5a06f3e6cee020e8493935cadda985761b567cd3b394ea7a1a9c19cc3aa64fcf817e4a96a7e7fb7c81f6860d66213cf187bbc0dcacb429deaafdda5757a41d02918a122103cdaf0aa6558747fa4c32569e9ae490913828e10be0e6956c7e1317ce5e46823f9df6f275cd7eddde90f2ecc1ad638928e4f89d38beb5d7d661d44c3c099e22d5af1cacb7ceb3584d095a579600af5e8dcbe0aa166024377debdf49cc82cf03e2b786fea659f3e58c55917ee649b530caa93a3dc78abca9d0addce4d17bf5e74f34719e58249863107751ab8e964acc9749b568e811bc71c35d67faa6e904397d57165c09491ffb2bc69f7394c9923e83cd39337bdf7982a9ddb7adc1603da7e9b98b91a98d0f960386fe0dee54f01f3e8ff3af17690af8728ecbf7ad2baff247d9c9cedb8e07e04c7663cebdfe8f47d200e119d7a1b43d2e482ea8d9425f27fa32746a3a5cdf86fdb034d182e5ed8d6de535a8a16f27f361ffc852287fc1f8ea312737d35a0dac8ffbdd4b044ca5b84f3299c900854576290dbc266c830baa9966ae14b4f81260163ca8e9d0020bae9b32ee93aa93fbbb7a628e23782bc002c1846b87ccee32199a208c6bd33bc004c92a42a56640fafb6ddd2f34567dc5d606f117c5a6895aaa5708cc2909a761bf988c6e033be00accc897f2f0000c5a326d0771ec4008c649b4f25501305f7e2e6312c142ee4b47615bbd649479bc2be7d8572f091acf1358309109d61e47651738a4ff4d5d619cf0e6ae30989833ef2377ef907159caf89663eff8703c112fe00f10e93fcfe834addce21061a032aee988c762ecf6cc2a1014b9bdda2f7739425e0bc25a0818b2860b16ea7377aef064ad52e85f7ea3398ab808374d3e4efd9028028085ab7be4002b38a09266691bd868718505c36c11e13478ddc35c7b5691b09300c92ba25368fbe11030a2bb832adc916840d5069d92514c3cf50ca1b6083100c88e92b7cbf84051a7877033a754c4391a4d0316dc0f41308a79af4606db8bfa7aa8b00ee274b2b149cae04722bb7e0c701a088bff2d44399191901c69a394b2988f32b7e0e20fd1d0fa8c3772ea557c39c9e8fb553327e8bda430fa2aa3be8334156dbdddf01ad0ea21eb0b9a107e84070f1be01080394058be145811efe5a5d1502fd37c9082b369c40dccae3244282c08241d092872f204ae3aaf7b21fec48530f7b981f29875cf7d4a0ad91ed091ccd8266c4e45b93acfc37d34e81965d356ed50aa22bc7de55b26f49642248bdb744605deb38162d30fc2a0b24502df0c95d031fb3455f60964987088fc992d80bcc52f55c66421d3603ff9eb1555ee0e9ca4117ebff8adea3c2959c1ced5f0cb049613168fedb8aeead139b57284a1e5a62b56fa88ccdc54ca34fe7675d0bafb6831fac4f96869a717b688fe82f71f4117b846d1fd80eb692cff378cd599ddd4a3445fb898502a00abca687187461f2d34d8fc08ab5449785e395947e2ea5d6a817860afba6cfbf0723d100163adac3282cbbddde96d95cfeff4e85da9b4b6965bccdc1ce203c10f64a5fe6dc33a09439cbc5eafaf7d104c26d36912fbe55a7eb02aa0f260e9dd0f763d44753836033309bff29aab095be0fc70d944f494f170621abf4184f908d78fd945d44df28171fe43d50bbfc9cbfe7a7b45478e3d8c0712c9e6f8e509a5610cda471e6dbc1ebda75aa44ba0821262b16f9fe71f2a616940556b7d116ec7c0bbcb560be6c24add594b559094e0234e9302a6cfe8e38954615a3195ea7cdea8b36929506b793e50df0d3b98a89a6d823d0ea8123815e8f297250d33ac85ce0df2e55f01c338c547450abd85542382cec31a165241a29098ddae78129196488981e1b5e9995df3699f264e3470feab7656598ca52ae1ea71c6cd1c3f60491026bc4dc2bab9bd929fa5bfd00c1c893f6b7b4f04bcdcd808a619776144c89e308fd88681cfb309bd2dd7203da1ddeb6c08abdc051ad34e3adfc86539bee35d5a423ae301396736da34189d96982adbad2b031ece7ce3939af8dc4de689fd2aeb2e8a9ac6a2230034d6bacac920588eaad65a4ec5eb0e39891bec00a59b7cb957a0a49cfd0e2cb21fa43bf2ed23174592a41d33667ef5ddef028e86f899cbcd5b78873cfa6cf27c1a918cde36ff40d0ddf646c9f7d339e1a0ac0040ec096e5a64adad5b347fe40038bfcdf95d9a99d003dd8eb5185e0d9a7b31dd4decc53af4d2856649e62ea74e2f2ef373aee9d7cc15889473d724d809b2bbd45f7ae7a179ff682f29aafee556925d1c3080bb65f3db3388195d04958d674fef3b5528284231c95991735aa5d1b64f9300c8980c749d1cab0dee9f89b621299be67cc407da1e058d21e7df217ac41e2a559de995930b10342bcac95d02c7c2f981011cf505592aa2f9f4bcd1cb3028d1b2a82a79215daef167014ca99949638b3ca5903dc073ea50f486c695a35b43b98b6600a7cea88aa6ead88248013b7a48320c1bb1fbaadf40177dbfa50d2f32ac8f04bb85c2942e50f9a6a0e43d208616f32c26b98bed6a34ed8da24071facf8e199ca173602a6c233a40268bf9c9b4db9ac16d0580789f42cbd13331945f54bfb092aa2279e4f032e92cfabd04805a670ba89eb29349e015f36d34d3c9aff267f90f45db44489d070f39fc787de66dda5e6c32f371451af3c6a68417f6de7a4ff622ab3367dc64acf039266559628ea6a73935560b439d2750418678b18588647ec1c7a3cc4307c32f55ebf73480f7b5c43fb56d8c49871374d85a4f38c0fa2df8234b5056efb854814551030ed6a3a0c581bee38d40832fccd155c40f303b5048c0ca7d3e988fb81d36345d58afe29c46e29194d64174fa891b4bb45f88b4f249bce8df5e3f3b0b70b13abdff33aa42b5203fbcd31b4fd40c2ba096db2770a1216e814f9125e91b7f27c3c1b2fc7f3bc27de05dfcdcae5bd40eff33c98e7b52cf87a78e0e7b140cfc987e3adbe0bbcd5eafbc00ff49c7c9f17e4bbf16cbc17f8799e07f3887c37ae9507be40cff38aa8f703c90bca6a0396b7f26c3cf087676303c3f922e402af08e87d5feb73bd1756308463c5f33eeff33c2fc85d9ef30fc8786abca8e1d44b0f6778e185870c1174a96328b1458c303c8a47030ed5c3041eaa4ac09f7aa04287271e9c454b0f61d43855a229587ab8a00456ea9021273dfc107252751c5124868e91229e1baf89181e0a9accd6ecd084a6c0c7991c1704cd88f880c2100203d121241bf000b40606339a8301f5b1e33cf000e333560c4ec132bec17d5386b72c77ca8c6a7b8bbb23f98b9b1e87a1741eebaea5ac65e626832daa5c362e1b50c7ab89cb66452427ca84a69e974febe66504e6ecf0c09c960cd4ad74562298a6cc0d552d1d9fcb0604d22162a444d50d979c1204d261c2472484b505f45a50185015054b9258e6036f402c3f27a802c10948bc30c163c1440ca698f081415641398f470a6b832faa5a2d0c9ccc54b0e30885551513005005c4a64b4e8f9c1e2250a920f7d2376e5441d936556632842e9b950e4b0a54a105135ea08e16116fc71213ccf0c106c905ccbcde18808e0f873545743901affc17264ee0c1f2b9a172a3410b041089cbc90952f450e504235eb0201c32a3436259e18a2a9cb38643191d253b3c2e43564f5c409a9870e372d2ba79e958152d555911b9a1e246d58d6b4907ea65458812951b1b2b3950251429aa7c80404d6e5a301e3aad1b1ca59e1084a8ba7959b980c642156b15b2bc9696d60deb490b8994239cd3e6c8cb4aebc6054427c9c608d864e3a3c7100d825880e4b5c195270d4cb8798dae253a4b8a969c5c39a02b080bb66a6293031ea1535c36ae1b50887505349ae2b184ac7858160cd9bcc89513a5273f5e3716d8149980d48443f4f2018d80465a465421d10126b136605d6063041cb223c98ac80955a390b7aaad82c0156b849e10046005be4b28e1051a269630028815c89040a5a56a4fce4200e1030fb86c8172c2d2811598d1121f0d322842412c1cb0660d1198c181940c7a820071f110012e8610428b1207302215e4e0b4aea0220149103104103ff4c0830e5b7c8e088d38dc1005b5660e13d03e58430d05c8b028c30bb626e5c98d8b88186028b2c9409a2288803969e2a307cecdcb35440802a000e1cb2c4d1d2c5151da21002a0060270c26552ca1841164ba70296af2a30738012f4ac0454a942636ae56132924c0091f6a10000b231460871d5ec8d224e5c9911c4f8e551cdf1ba01aaac6770668c627062b0c4f031f06be0bd87c9163816f029f043e2abe26564b7c526018cf8887c18b086b880e90cfc75781d743e4c1daf9442f04757c38ac9bcfe6f5fa5c2ed6077a2bcf6bb9ce8e9590951555a00b5520961612eab9da302114a28ac5ca7169a00113c01e92803e728038a2b5421588c5c6829b213fca54d978013f585d80b35b392f2a2fa3d6cdeac98f1bd61655af28aa7a8060824dd14a073672c0a862ada962e504b94055ceeeb1a2cae6878ecff58425c49ae14c053840067002d842d50e9e1d3cab2051e8f5435c73026b8397910bca6ac70aca0b88aa155312a1d64d0b89aa154e2b0808849364e5813920d00d15d6062e2fad20ad9b56989c1e393d6c7ed858e0f2b242c109ad202b264e60655195411810476519100161393b5a22e8ad825648a0538e8fd6e7eae212e26a6255a0c36be1ac5860ce6ab5fa56aed56b657333045cb9b6b8767638dd88ae96cb5bb940225008f45e4056424cb0c1807544950e244c105ba09057d209201827f4c8a8af498119194833012f2090c569838a0106a5230ea214e1bb861a4247c21d2fd7970fb234ade9c20214c0e085211b0630e50630302081072800014b0c21346a50c3b95fd0b90d12a8e1c0171670c001c8941002081f7890a5a90a150c2ef061011553905942891248901119822f063ac0f080185cd59a149cc00d10bef8b040c4c003b0588002100045132f04400559085eba64695a9240175844a00a1bac6c4003127880031460851040b080421912a8c1c0170ab0820a27cc547db9a424eaa829830c3020e0802912f0441131b8f0a52c0410be7459527a02fb117524d0050474c02106335f86d0c11215a527301d3aa097418604bad0028b2912f0441345c8100033603a588af204564494e46747047d4d196478400b0860e1802912d0441132c4100017cc8c210303020742e31c7260b9b243470786c0d0020b1e7419f2c10516765449d8ac59a5e043014b8e2f8ed711a0115f11df109e922fc96ac81b7182561baca805187c433c21ae202b20de0fd08767810d8f9d9d5508eec8d111ea04c9018233e446b471bd5aaeafd562b1569e0771bf09739870779dc73769755f9b73425f62d2de9388bbe7ca31e32d0f73b884394d618ecf0ff5a1f44babafa5dad26de9935daeb9de485a2dc57103878d10870cf719b55dfb371dfda151a0509f2850e8b5b6a7e13c11e214e13ea3354cb5a57b4703338ee397252bad2043eeac273dac23ee8e818738465ce7f1e6dfbbe684f20641100457abefdbc0431b316cb8b876eb2f29ddf852fdb8a43f3e4fe613ebd046091b1bbcbcbf2bd5a1873654e5fdd0868a0d1135690d539a712dd7ade9db6ecd371b50e731df48dce3849eb4a6b639c1dd2f70b719e185e6b5596b7fe61f77f771f7235e194e92502934e79344e2c489919322274d9c307142e4648913254e92381972e2c4c8c8a8c8a88911132322a325464a8c92180d193929322a2a2a6a52c4a488a868499192a2244543454e9a1835296ad2a4099326444d963451d2244993a1264e9818312962d284091326444c963051c224099321264e888c888a889a10312122225a42a4842809d110919325464b8a963459c26409d192254b942c49b26468891325464a8a943451c244099192254a942849a2644889932446498a923449c2240951922549942449926428899321a3a1a2a126434c868886960c29194a323434441ba21a7a7717e2a10b059d47dc798536aef6199360dc5d03f0cb0d90cf8d0f0994043a02a54037403723504a2975f70cdcdd88bb17717790c7354461ae9c1908c29606b27077201eb69698cd28ec066836a3b05d7b93d29bd9cfbed96ca674d7def4995158f9a6ad355da34489c2a3ff46ee8aebe1095b3b2a0a74e408dd95962f45da5b732d2777582bc8dda9872d1da7daee9346a9b67fdbfb64d2e19cf151c83ac37d1cbb70779787ac07b072f01f0a050a4de243ff34eb149dfdc54d335ae9c574f6e393ab59774f18ec62bb735966b47cd3ac240cee3e86e01cac9355bafff8e4b735bbef974b9bfc30b42c0270f72e1e8273b8cd82977bf9b88c6b66c5d1a4a52c45ee2ee4ee50dcdd030fc1289d474de6ea641c0a2a2d0edafa62d2dd7b90b9923966b3471847913966a424c9eb7ae4ee3cdccd7a6eb296bfc9cf51296d6bb349b76dbb8f45933976b39df82a6ddcb47192ed5ad3d61cb5db399cd2cdb2317eda5f65dfdfdaea8bc9bbe4ee629871ce4a9ff1862a7fe7ce9c3192fea9fa584a6bd6a9bb9431951ac6d9e97e95ecee501eae80e83cd2acb933a65577dfe1ee3a3cc7dd71dcfdc693c1ddb778f899e177fb16e0ee14a6cb7b621aad61ba4f4cf196e93c0e8d49c62441faf78e26b4448911f94e68a513274a9a90e42709c26172a49db76d6dbbbcb5b57d16c2b65cc951a84a89a02d4ee871f82644a340a1fe7a1955e0e1477d5b33a7e96cd7d98e879e09dccd1a840f0fbd27dcbd87871e0f1e25bfbed6dd75dc5963bcadf358629c10f953a1e7c191bb5be0a107e4eef74d0a853e8d96e6896f9afe506d7d28d597d7d29fc2b8cfb25cd56977b771ff4a77ffe1a107ea3c6e5cade5ee9e679cf3d35b69f9379ffb33bdd8eebaefe3decce12cddb6e64d6dd7ee5d7119d768fd5aee3ec443a77277d1439fc1dd75d8ace59fc274b72d597395d479247f4aa6ab5988cc5a88c4a6598576b9669a35dd9db502ddfde3c0cc17073840151b1f6890f8410004c63875c08aa89a0488d0c831957c784060e4050fdd6b8cc3061134992a006163d4f35380245ef000b2c2b8cae924231c843983c20faf0a00a98a02c7d15455c57c05c48c0d38384467bcfc4b013473c6a3291085600d2b72de3e622c1ac63525c5a25e071e134355d5b3955a3d521db4284b0a4b6b4bb5a817fb5c3ddb8bd9ec10426506779c1d3478d4eb99c1a3cef3ad78563c5b8a45bd954dec6bf56c2f06ae89b1c01e2a7c7bb1af870a6f35021c213492080defcc19907ed4e3317306ec49420c07522b2ac6d174c159519c55cf151c5f8959992f332798e07df403bd038020084a7dd4061c33f55156cf5e51d62ae6d1970be49162f5881913b3e9916a51d69415eba32fa957cf981808ae562b70058220b85a510ff43ceaac2270dcf3bc559817b5b1a1ceca1ba4ada98fb6280be411f32326f5f578cce31163c58bbdc4ac3cda23664cccd52305d28fb65a3d62563129a71ea3ae7365471538424000234408e9f5c011a265b5e3078f7a3d3e780a30b3a26652203a62d13154ad332dea3a5bfc8845cb90a9aa02573cad9e174f1488b3c307779ccfd3f1c0a945573cad568be2b8ce961665f5ac7870583a4e2e123ebaead2a2df9702092dea1d7d2e176db97a52c869b5563c600a24b0a87704521c9c1565f18c2173c43a5af5a4907304d2291f4bc989453d58d1564f0aded18e35472cb0a70aef49c13bfa7aaaf04a687d200e38ab2216d107429042c1a1be2ad2e1f9705639383cded1475f3d551ff5e88bc78f7272a88deb06a4371ffdcc8034877a3c24d850efb3d1a17e94c343a6aaaa8a27050e8e56f486c7cc19ef684553e0e008a4ae23440b487568d4ea0887474787dee0d033ded10df5e88bc74c0ec5f17848b8a19e8d4749c0a15f4ec8a323848a8bb6a45c3d43ec3edaea1962b7a21cbccce0d033d48c0e4d811edd504fa7a76a453deaf59859d19b9e2a3329d0231dbad2f940878784125614a7a76a4575b4e844ade877c363c373c63bb2a1383c6652e0e00887e27c3c3a2b1d25215a40aa433f58d11cfae23163d385cc914e0f0994841b4a020eebc686278524c470106b51ef88888d508caf89b57aa486d87d74889d102d20fd68d48a7af4e5b4a274f5b5a4c0214a23fca84789ca086d70848000867aaf55d19831257c74454bf02848c72411e5a22d3ac6cc197a14654359b48417bda13e26057ac4ea1953428bdef49ca1472b6ad353c2ab87455d3d25b43ccaea29d3f26e06aa8858c3c31a1b5060460df0f33ed002de1c4f78ab700e1318f17e2001fe00636172629f8ff7792b2f470e325e46af550370d05cc941220e35719cc1c6cf8e385a8863863872880388389088e309c7f158211c73b88ee741ab1d8671a461f580ab1c560e1c5a787050c08343031e1c6378dee781ac9507470e7000010712703c010715703000fc5a28a0f15eafd70f9082a0d11b676220f8860dde8a7e3a5756d4a3204501e7fbc21ef405d27ae0f84794055116a0e7795e16edad413dd08d39dc308197e6042dc4da30b3a24f629ea6046956ab96c33cf6a238613eeaf2c0d8176bf57c445d84ad9694778515868c7f06d820063aac0d11ecf8d183c562adbc1ed08d1871d88f188b4533f0271e63d1230ef3d80cfee36de4f06a0388b00d247eb4f1046d638a232c26aaaaaa8e38720aea286d10c3017df5e908332616c67b85f9562c23282cb0e5020816b96898bd22dac24c122b6a26057ad4ea49e33908e6803daf2f8ad6ebd57ab53c25cf080a96b0c7aac56ab58c5a2ed7b76ad196165e822c3e1c56192008b672a07c3facb0022c232deab2f96c40b0f5d2c971b9e84b47e7f4540163383d2c0f02691530e6eab90163208e0dbde159c16c28ebd371b128c8638487d2d0c5fa7c86582c106c5110a42d90b66e22f0b2f93e9beffba80d0fd0f7b32a8aad98b810ebfbc0d647592da0cf670512f9a409d18055d8785ecf8fefb55af5f8b4284be7f54d59794e73404f07a43d3c90b27ae440f3796872c0f93e96fbc4b4cbf5ad58ac6fc5ea01f2201608aebef0c2c603592005592c10044116c862816a8a7c7c7c5e2478c3f5234c8f21b1154841230e6319b91c06d2211f209f17359263c40b968d0dcb8605d2cf676504054b0fb0e56ab568185713578b7a8cc562fde09902335005c3ca87e903af7c14a42c5087e5e2a161fcf359c57af8be8f8705027d31acbcd56a459b4cf97c5661c80611abd54b07908d19b13044b195b7c3615e0f140f5a515087c3be1ea75032107ab18fbedef83e8ac3e209c3a11378432c4a8d7846565febd3f97ac2901a617d4394d230fcc162b1a6f8a0184531f2fdb0582c168b0d13c4582c8ae5e5c35a7d3e465f8fd1e7c3a25f0fb562c4a250b084445f93152513db1ff5629f7b01c6c7a24ebf8f05ae562003beeff3becffb28a53f28b85a7dabefbb22c4f1becf410aead06a79200be4a2f5b558dff7b1be6fd5fabeaff57d9f1cacef6bb1582c568b25c4cae359ad56463cf40182e2b55a2d6aa4b55ab5807c82a8cfe7e3d35ac901ba3e10044110044190822008822005bfeffb7ad0ac84f0224aa91b3c0c7d4386b0f156dfe7f91a3455aed60742f1a0d52a8afb185d11be62af1e9607b97a7a8c7c3ee12aa4d4c8ea034d80b302f220162bc87d5854c7a31e0f088a7a7c3f2cca3a0ac3f8c45814e88302bebcd52a67f5d1950b9ee785a18a85d92b4fe7079c149c112312f33428382386f3e540f97e563a4a203562a4275c03430812690152d0e7c7eaeb6179d0e7638445874e80650804b1d547575f48519066e5a373586fe01039200c12c359812b6781617c629ed7628134e61ae2412bfa83e54d88b8cf7745e831d0d56a40f8d12ff662391112e147411e9607b128cecb49c00409a220011a17f298072420c27f5ce90b12033d88f5d9bc1810b25e37397ef4830436c45674489832622b8a839383b3001d1c34e1ab47478e8e520ece0e1d0a087758118a6115e18e4845c863678a1e3c1250410f292ca8208ad0870508087ff870203f5e41807c3150489055ec3544089121de054430b8c0631fc580877a3d3c457a3e234532300245e8c5400d32008f68f0f239f2c5c01f9f55ec85e4c7db0089c73ea00dbc20a06f0c3a40e8c5c098d0f8443824648030c9902b49e22d51f2112d71225c31216aa20993a22646454e8c604e9ec0a03c8902454a140ea4f8140e9a884d398a211d252129255151aa42c54a95252b1d2c79573ac07285094b13539626a72c9f16a7272d504f51505ba2b86c61225c75e1e241172f1e7ce0e5cb07207c01034208606421cc647546ab24ad24bfacbdad76b3b9bd85b152619630a570e6c5e19bc36272598cce5b9f7bead44d51e9765422ecbc114418330209634a20814c0955644ca83ac18432279829838299145000400a6700f0a9706605155858a105165c6821002ebc10802560782106186488410032cc20001a66a8810625c2d5006af06c1800016cf86e20000e37ac72c041871c7c071d0ab0c3c743017ae0c1871e7ef0c181f82108203c2182580d210411437811441851847784112b248ef0d89704125e6ca544125fcc975022897015f3623945433e6f091d252442228e083feac57c3e9f1f5f8f9107093124844e15108cb55820cb83be1e222342cf0b42e7eb212a22043d26dcf38cf08ef090f092f09af098f868921a38fe799fe7b570c6f3bcef5b83873572f82e80e31f0e0f26741a6081173b40b0461b62190b66f011f3346a8c50b3001e70887e48a3c61b3e9e6d0905c230ce819847b178e1feada07c3e1e1aa02120cf89ce84de43c641f0cbf11ea0c762008ee779dff7b97b40e0e0b80750f0267f8ad69f9bae5660b028baa3d1f2f77dfd39f7d98792368737adf4feebf6d3a8edda5cae32d1716b6bd299942828331cce358afbdba6da34edd6f42f7e1cd6f47525e9b574eb334c0d07d9e8c6970a1fd1719731ee7141d7d2b7e56a562ed8897e356bd7d2d75697ffb63149f712cdf46934ffd45ffa19d73eff6d97b7d27b526d29eeb78529456569a263f925d574a4589b95026dfd369b44c7dcecf7493ed5cfe88e46f743d1b17cad9fc439476dd73e8dfe6c4bf1d64774aee27c68ddb5a49a8efaf1a63a579980f2dff6dbf0a6fbcc99f547ffded1e8b52399716de3283a262de56a9ea4ddb9e668bd96ee7b6292acd434cf1afd5b147d5c6d223f07f5ba7e26ef128ed2e57f1395128e7a1c46dae6596b9f7471d3be2746aafd13ceffc1c54da6a5629a158965dd1d8b874dd870f7809cb9e97a7b7d52bc29fd1237a13005d3665398a64c99e264cad0142153804cf9e1394c7f32f0a1302a447f32a01428030acb610a9401f5a1140644c17cf912931c8c117290c58f4f95c1a8b62deac98baf0c06d3175b2dfb8c492d2b7feb33ef7bca7027ce5e8b334ffd7947deb7e5c7bd6cbfde16473bb5145969a6596b325b5050d0eb7acbc9ec364f9c4c26cb057d142ca25c41f1a67f96b4527a4f4a0d308002a8a1608a7c09a354b9e3bb7b29ba7b29d9a6fa1b46c1e2ee3f40bb97f259dd70d3d5ca0d06236dfefbb6fc657d2bdaeabf5f85fc1cd49317375d6c757e2e545152e4df90b4bb7ff1d06805771f8f9268ad96a5fc8cb73e738e7eaef4a7bcd527ffbd16484bd5cf694c5e4c526d6f9bfe131393fe9bae56e8f8e3f3b72d82d574dfcff944a2e3c6f8893e3131d1ad7f572cb4525d6f95eef24f298d74eba7d1bfedfcdaca68f9a59dbab6dec86be9d37de4e6bf45651c6eb4a3c6fdb61953fd53f5d26ba9ae375ac3389bb8aaadac56dfa465593fef5e4af6b65b6f24cee69c2cd737495892bbfff01006e44e6174574af1a6bb975aade1c4012ec3597cca82aeadfb9e1817f4a6547e5cc6e1642b94c18510c5c3221e34ce2f02b55dbb332fa6657d93e24df5b634baef5bd2d66aa7a6e5ef9abd69af8bbb971e36190a8baa0c2d094109bdf5b6a9d66fee6ea5fa71b9ea13dba9cf4ebb3e6de7fa379d475a509322dc71145f8a420e6348795cbd34474f283a8fe49231c9b82488fc1293413f65779db2f94b99aea65965baca6ee4ae34d99319d77010ce864cc6b853d89798a46fd2ea8dac9fef49cbcfbfef5398596ffe7dad69da9a7e5bcdc972f56fb2fd5a4b917f2365fbc45f6272bfa6b2b5cf3999695aa97d7fea65b76d7532a9ec01c0ddab42a14c0aee1e0965aaaacca040c68cbb37a68cbb7782bb47668c092578644a70f748f0c6d8b48a0cb183851934eeee1d8800cb147fd99866452a2de692df342bd2b5369bb3ecfb534a2f55b7be5bb6ae26762a5fead6276d62ec84c34d17db8d999ebcd59a666c6b6bfeb6b72eb66b37e662a72e4692ca15f74fb5bc9fbff64fa5696f4836cbf43647fdae1b6a6b8b25ffc6a7187bb76cd356d9e5df1b63c93826ad73364abfddf7c44736abdf5671f6b3537ef32cff4642d9b8fcd36ebf2531d46ee7ac49e5a74c8ca4f55f1c2e6f7d322b6933deda5ad14fdeafd5b2ecf24f6152dba4ddb67fad79b3e096707942e94dd6bc2f46dae553d7cf513557de9aab3c0df74cfa7f6f8bc361a41bf951a625ef89917664cd24c67d92dde6c94415b55febd8be8fdb55a728ad9fb4e55dcad99bcef8b6cf580e57b7a6d5a3ddb6a6dd5ba05aee1e0b74f756eedee7ee9ebbb7668e14b83b0ae658b366cd9a356bd6ac51e3811d41d07490f3317a18a2e6cb1743fec5131e8a5c98809167c1030748d8a20a0f9c8a2b2e807326e70c6f22072a649600c37d882132f8788115ba0e4faab0010d32ee0250535ac00010b0e22c2469428a32f3e0279c004a04d504463e8213aa31608059c0b59a2b72222079c271162c6dc1ba800baffd60860d178dfa4c86a812c86069c13fe04009ba0000f9866f21a10d1548f0a83be5a4e87abcb8c2af2ce14060e072e15598406181230120e1484e85788c0039073750a0044172e44f9caa8457c4c086177571802a3868428d139da06404272035e0496c38a091a901f27184391e20440a667c032a5e90522543e93f1a4041e29e1eae0102e698a3042430c28d5c1eab2f4178c07ba86c81238384294ea704e141024202fc020fc439c2a8220a1fd2c2075cfe00250fc281344e24b1011138102a1ec482a478c07d3c008c27b528a15b30fb3e1d01c2f00a74c24c816abe701e5d5c4089129070f8ce0f3e2230fb32858b2a8469962815e021990330a143180df88e146e74745140e83a70a0330001c305ae630510358cbcc0798e1a45e028536081aa1c243b6f728348154e0e618e38be38c36f1ca0c119392d3e54ddf400f5883aaa729b33150880074b44f8eb0d165a0841115ff82ba705193d607155b94810a2f000244bd0b8a83ee019c00808d0b85c5ef870ca41cd94960e26151376e4d0b49c3cd933709929ac0d14e172058f31ce3a018513725ab8d0b0848c24d1c1ce195560184dc810430b4f54813588a1c38e1826d0805a2e0f4e4a48e26068010d60304064ca8a0238802047192e61ac6c6040991fb43853b5a26db9917a5a4357421828e9e18703f44b811a2c3ab88d876f0237a87066800c0f9f106c48e0cc000c345f095ec430c48c32fcf3a2230401d040c1ec6392c20f09b373f6f5f8f184c36ecd14cf04407851c314aaf23090e3816c2799e24d41b48117b10d26bc1ebc0f5c5314a8f2ce7c30479014270c79627e7cd08d71a5cafbd265ca122c47428f8a042cf000a80683b784840278f174c6cce3712ae10c1a95175ed8442a031c68000f9e636004cc8d4995ab910304264dc8aa7c0c2a940082891639ff620b0c0930a2829167214512d59305d4a9d800174e78651879134d883184a7a5ca87180241075128e0e43a3479000910350b9fe1234de004151f67e18887324cdcc08497711d893064051e7c042b535ea43ce1e33a056084b89d271c572400739041430e5e63c283924106239fedc0438d15de08fd83333c2a2a6aa2f02d67beac41abf0c29d44708df0050b16f02b5130a9c1880788bc8a94595e8304261ce9450501243471c63910cdc05de08a0e7fd2a584264c200081177d41c68925e220c389ced470e4869b1c3c096e07270b8ce1858f2600f1443411c2375880181d3cd57082ff6c808010c4f18305ae01154e5c51039a13dc4836c1cc65c108efe9c00d0fa080c790d3a4d66e882e0bbfe00b03dc2813a5880f81010423527c013d481844620fe8d1c0812c4981104769ba0f2d1ae04511111db78096002f661b08f10a76c4c143842058701e13e08085a33796f84e1020284981dd719105256bbc1a21f0d0040490b141d7c37700600425eca0a1e33a7230233785180db88e021c608610379e3c670d288268c30584e76c500230644fe538ba015356d834f11b2ca6b2448004a5df14b111b1c11983dba83087084a700002fe82c30711e05c89c25f622680a68808d6b88b0d170604504214eeda6df1441ab013b8eb75844d50ad89b776805541f24410de82f58862c464c7591bc8c0136b5838c1596592fc80033480b384b0c0608ae6c241319676590c2b1c1c404e052b601839a8a50d204168910107431a84a4b921f45505766e5d2c5184af08a0040514e078e02b9a15b80700b1c65742277c51f2a307ffd630d930841948f8370136b42461060eff8650b23519f1c23f3217541942c60dfe79e172850f4e49f8c7448b36c41cac7f3dbce814c1f1807b2610634a097e28710f034a413ca00136f7a6085341014258e25e0f443d7007d8c1bd332b40a14651927b62b8ac50822139ee7d31c104213ca8dca3e20606d248d9b9b7e407d7132ad8dce3d14ca0f161cabdb08b0a42ca18c33d9782c50c104bdc49f00309317a38701f230d921305d871ff029b2957f0e29ec5049608634607ee54b08145911cda706fe20164f0e8c47d0825286e7c2b771d685ef8a2729fa1c72b19e1e1ce02540c60b2acdccbf85072021408e13e4297d3070514e1be73e4b0dd10c51d37f40517ae22dc6b54907152821ddc674558808b5c18f70f4a108ad0e4343194c6b9a66fe6ee4e1e1e4912439f949f4f9bad5d4c525ae94fd51bd594d58618fe73f34aa0e1f6e4062ddc2b4107a327554adcbc12361005ec880b508fcc4f1a2713f821c22303001b8ce038c0cd2333471646432870c6ab72c1a9484a4f149e09517e349931208d77828f344cc8a489c22bc34345c4030ad47866ac0d4bd07031f25090438d1230aca01e00cea049d6fcf0f25688319184522b9e0b47c218e240c9140f06285e42217441e3d1b0c3692c41270bef865a55900eb8303c1ed8b00244c5088c3c22e60863030ee8f0c273228d131239a060f0ac20c11b4882e03cf022a0059a1f27ba2a0f8c149ce1e3010f67786e6c21e288ce89303eb10a2b1ad470459a6fc9076832388006a2f840a02167c4026fdcbe17901051c4043aac7c1170322bc2834e5901f142448f122546ab290578c1a305ca6c8506541a9aa372063cc930c2e0052726583d51682e50e28334ac36c4f048a09aa2777fe562abf543d9f2ac17e3ecd32aedd66cb35d2b75f34fe12af96bfad61c7571d3eec6a4aed5f76fe4b6529fdb45eda87076fa421f23ee9ee3ee373e3d7c42164280c14f664139c2dd3d0f244001267e80f1450ceefe79c93d1df1458f352570f78f081f8a70e231451645eeee0dc101047a7a9082e2e6ee1e07327cc902830a3a50e1ee1e0356642ad0810544b8b9fb0780223d0af0810cb4d8c2dd3d032841731d2a84f0e1eeab3646108213483880002370f70f8b120765b070848513b8fbaa8217bc50630036504101776fdd40c31b9e05602998e2ee1e196dc430668e017ca0c8dd411c662e02dcb6080386fb97f8067d89afbbbb77640677271281f727376871b331ce3a8f34a12ff115ba96e6ee42a8c119552fafaaca84aa9b2af7aa2affaa7c55e52a54390b2cb8dfb88dbb9f715fa1ca6daaaa4ca8aa62a1cabdaa6a85aa133c03203cf0bcd048933baedda52f6bb6e5b66c5db1d86def9208d6acd75251da99b95c4cd79b53d4932ca71f57ef266b0e87916030f24b4c4e2959724a91e5cf51559c14894d5a36ebc65b4655715415475a7d6dde542f7b5d6952942c39a1e477a2aa387ca3703d61f23b69184c8ac4e69194f273399bb786e174d541c9e2218f936ff273c624ddf86a4a6b96526de9dfa2e893992c63d9acfc9bb6d7d668fed2b4e791cea3de16674ddc6fbd73f79e7c6bec846b776997f1aee5ad4c66cd9fcb62565cc64de5ae3ae9f7829b16e0ee57dc1decc06d75531b8662d179dcd7e2dc9271282809f9608ce813a3f38b14287a579dfe6b32bdab39adab89742377cd699ba47535c92efb66b3afabc2dd3ff010031a4c7bd2928c49462541b8766dd09b95d4d766b5beedeaa4f36856b382e0e105398ce37864bf09b4eb671bddb8898e9a9ab59a27695692deb6d551dbb5e53de9e74abf0bccfca9376555df9a374ce7f1a6ebeda6eb8dc81bee3be39ba618ef9bae370a7b9d7fea33752f7f2abffea7ff4c85d4160783e9fb5278c3605a9fbb6ea8276f35ebd1c556e7e702e5ee4b56623c5eb9b4df34ab130e43fdc54d51ee4ea99090d0ef9ab7a69d5a88bc3b1d94cb5517b4ffbea5e1b008414c868476dbe69a2bffa6ebed9e30d8ce38973bb5ec7135d7de5633de1a067b9cddf7cce1101e9cee4a7fd7ada9bb2be94479380448e7b1bcbfa9fe89bb87e0a1102afcb7fe2bcbbfad0c87734d467e4e0b913f25b4847c1a49d6222325342743b4a2225a7d2323263f4454abfdd00f91b526444e6aff4542e4d6671612c283bbc7dc5d5f6c37f9a692c6b926779fc241fed24ee1ec54774d72f72858e8f772f7206b0441836ac8c756a39a624a58b264397a52aaa214d5b4b47454a569e9290a8a4629452165c182654bd393d21295a5a826a5a4251a85a4d4c151162c31a5a724a5a8d89312d3962625232a515b94909a94b66851828a5282226d7edcd9e4c424b6f4381b8514b5e57136aa7c11ac59f3dfaff226cd6acbc5766dde504e4c47417ab8fb17da9465292a86b484c5c92906e40cf72f146989ca12929213545094074a514d59908044e08af23779e69fb2dbe26cce012102481021901cdcfdc78782f94295a2625c969e9c1e67a37ed7242af74dd97d53f6bfdfcce1307997cc4ada8b6f252f6e622a6d16772f2a2d2e6d16dbb5f9cb9c653f5496fc5359f297f59fbec44cb61af534dcd964ab51eedee4dd9dc9ef1dedeaf095ba5b6c35ca76edb515f7d9dd85ca2f31f965ddd5dd898c6a7b8bbb8fb6baff342b17775f72b1dd56e39cbb2b49e2eee5b5523f427717bab8c9ddc7a0c761285f4d0940081b511039c8c5b54309a50deec2401537ac983272af0cbe19c0121470971b3c2c8d300a59e36b44e0ac1a58285aa2c600f7a810d70ea008ff704f96e860e7e3ac1a560d58a20113677d6044d20898a8fb8f0b090b1b487197e2428b2d6a80e15e03c8c0e044cb8cbb801c81450f736471d0660133c81630e5ae14b280018438d6784b0b4e8d92c51a7757fd36151ef817022b63970a38714781115560a6a4c1a24dba18038a35ee728205c90394299c65860f330fcd8f7b44f83ca9e056e12b262d7878a1fac1bf29381d1c805be32dddc203a6ec74be9240129a55d593af9c9ca6907440046fe13083064e90c08b7f5128b102ce41c45d28d0204415961ddcb546083954913373ff2288395ef8a183b7841ce940070f4c38d0b559b3be0856ef13ef2a160ec29dedaea66ae62e9ccb4107a378eee2c12b59a2e7f21d1ecb024f87f7520216f96a06f002d7f77ab1c095e7b98f6ff4cf3d2d20079ebb9eb07c47cb73cff3582ca20fe773cff3569f15cf73799fe7ad5a227cdee7b93e0b9e3cafe5b9fcf374c6d5d76af9dc500ffc3e10060ff4bcefc66be3f36c9ce581dfea3d2fcce779df6bcb27e4f3be16f87921f83caff5795a3c1f9eb7fa5e0d60ad5c3a3c0b3caf82d7cad3c1fbbcd6e779df4ae67de08d0dd197e34979792c23ab289eebfbc024ab9beff37e7634f1460093e05059397d0efa178407ae7c40d6e7ad9c45833786e79f8761e89e7ba0f7796a78af0f89e77dacef5b79de124fc87b7939dff77d2d24efc8f7819f37b41a7180bc34f07476827c03f0581f100ff4569e7f4e1fbdf140ff6ccbe9cc7361e53c0df07c0a16dfca6b79a0cbd3f156367cdf0bb6f28c56def781f4cbb1f1f1589ee71a02936030e47d37add7e7f23c98f77d1b58b53c9b0f5c4d793ddfe979ab20cf06e7f35e2eef9bf25df05df01159f9cabd1d5eebfb3c1d305c811f90effbbc9607d63c1b231e0eebf3589e8e2221df920bc7e6f368af1cd7e769f15e9eb7fa3cd0b3e211f99c7c433e9ccff5b1bc95f7791fcee702bd156be50543421f3a3a3d425146868bb212b8285be3e26c878bb31f2ece885c9c39b9389bb938d3b9380b808bb302b83863c2c5191a1767127071c60117676a5c9ca5c0c56a818bb5888b55898b758a8bf58a8bb58b8b9574b16a176b0a2ed6195cac44b8589970b1a2213244489070274890ef0499e23b41b804a9b9fbcb46c78d8e17d0452f392e7af9e1a297222e7a0172d10bcc452f4a2e7a6972d18b072e7aa9b9e885ca452f29b8e8e50517bd10c0452f45b8e8050acfd90152e53b4074be03a405df013283ef00e9c1778024e1ee3a383b3b7038e3210e34788803101ee280000f7170000e5e7888431a0f7108818739b88739ec789843110f7320f230072477b7e0a54347c7cd6b473cc377c414f8ce8e10dfd929e23b3b3fbeb353e43b3b567c67678befecd07c67e7face4e09beb3d382efece0e03b3b41f8cece12beb32385efec2cc077762010eee84143141ed2e0000f69c88087348ce1210d6b7848031c1ed6c0f2b0061e1ed650c4c31a843cace1098e0d8f9d1c23dfc9a9e23b394fbe93637d2727fb4e8e19dfc91980efe420b1c3fdc78d0e1e54f4e10a226a4972510b948b5a4c17b59871518b005cd4a2838b5a9a70518b025cd4420117b594e1a296375c7ceae1e213918b4f4a2e3e7171f1e9baf884828b4f33b8f834848b4f50b8f874858b4f5db8f8f4858b4f1e70f129042e42b180fca88085325c64210e175bd871b105212eb630e4ee366278d3bac9e942878b5dfc70b18b222e7641e46217555ceca28b8b5d8071b10b9b8b5d8871b18b115cece28c8b5d04c0c52e04e062173ab8d8c5102e76f1848b5d38c0dd71c257053b3b3a628e4e8886150fd180f2100dd24334b68768a0e0211a347888c60e1ea2818487683ce1211a5a788806181ea231020fd158e3611a403c4c63030fd328f2308d240fd370f2308d99876988f1300d321ea6c1828769d8e0611a41789846123737e08e1cf10411b87842095c3c01052e9671b95886878b658ab85826c8c532442e963172b10c928b659e5c2c535d2c835d2ca373b14c1917cbb4e0621902b858c687968f17a8f0f0050778f8c2161ebe90c6c317d670771d3d6e76585e7c8765f31d96f61d16007c872583efb076f01d16112f177a78e802110f5df0f1d085200f5d60e212b7b8e2e216d5c52d762e6e11838b5bd8e0e21641b8b845133a3737ad1c7104352e8e00878b633e17c7ec70718c0f17c7f0b83806c8c5314d5c1c93e4e2982617c740b938c68b8b63662e8e315d1c73bae3d8bc76a060e03b5090f80e1426be0325e63b503af01d285b7c070a18df81f2ee9ec3c383c4a07818b3e261ac8b87b1301ec600e061ac079b1cb101402e3680898b0d90e26203aab8d8002d2e36008cbbbf5eee363a44295070510a175c9462002e4a510017a510c245299670518a2a5c94620b77efe13f2a403dac00918715e8c0c30ad05e2b8400063a81266a8490a8d2dc3059c08f9a963339f8f0717777cd016483bbfb8e009039e3ee3e840511d2ac59f317ffd7644a5e15544c910029bc6789300ad77934cd271100841705029e78e2092928b2701b28c078d0dbbc83b874a1a3edce92b22c3d2939c994aac49eb24441c9a2b06c8951514a82c1727a0645df56a5ee792369f974dcd12815a48d9bcad7fdfda7ba6bd2efba93cadfb8a98673c58271d4a6fa7d3152598f5c8c15039c711f67abf9960bd25e020c50827b5036cd7a84136fb048276208aa4eff547070e215549af646864d04e167d0d6b5f6fba4d9bc77accab479e8ee3226d494f8dec0040c486552f91b731162d49a56690d676ca7eaed69f4379eda3a67fe6dfcd9d17cca5c6b146baae968bb16db2ea6e34dd75b8c8eb7df980bc6517a772b1314b08912403ce58b60931841120a4802091f7f7ce88f0fd57d936f20092cf507210f930091c000121170172a4205891328d535a764c9d2eb5a0ddb5e23f1b27da6478441614fd69c3ec201eef4c17ca1528228982ff4733bbce9085ccd1141c4d027f74d992c4a141a8587de376532234e30a274f73781a8b6541bf1b9eb46fd9a6a7be2923eade633661bffbea675679a95ea53dfbfaff18da4f9c45ee8a8f5b96baeb95c4582a4eafe888e9a8a036d8b10f1fa4244263384156f8c33caef04429c719caeba7de456a41b1d6d9646f1aeb67c1cce527de44d5a8dca475493d8bc5f969696718d6a4bafc566ad7c3deafcfb7135d71cdddd8ad35b6c43667dadaf7d7dca64667d0dd31ac774e44869beadd1bf6d5cc6356d561a366db47c6d29dd991796c3597a71d67d6eb7ebc5b7f699ea2bdd6133f7a5ae369dc7cf35f7390783e9f0b087325f62a4f16963a67f23a9e829e69f70ed2ee174d5c1606f9e2566c2e9dac5490b1e8c0c50001378a9c10ca7ae9fb7b7410188dc33093b5c2067964a36ab754f5599469df1262b95aa6449794f9a3f77a464c9eea5663f3f148802f9f8d4f006944867d6b2acf4568ac9f29bb45963b849f754308eca5fe62cb52cfbcca2df66bceb52fef23e958d9b1e67a374180bc6510b88000e2f57c2d96a22c51e57c93f0af34fbba5376d0d0349e58abb91f78fe898df29a9ee9a34669cb33b7fee5a264a55cdaa318e665cabb4fc769c5d3ba3aa4c33fd3a6ce6cfe54e6a566cbf466d75df27f3e7e8ae4ed726e56878d35dae96b4b5bf4fc3367f8eeeaa3992d534fff6b7a829c6f2cbdfd18d6f4977369374fcb2e234dd35d1ec74972ed6f59fee16a47f7a2a4e4e9fcf5d719f9d76d54ae9706c9a066848a26599818c7a8ae12242d10c4453ae8305dcbd04016cffa41040e841210313ee3a94e18cbb8fe6b87ba90de8ac5cfa2b33fab7dd4b5d1dae7a26bb78762373fd6bf5a92dad371d2d77eea57e4aef5e4a1fd15d5e53dbadb79bdda4c5e18bc937f3974bbfab25b1d631dcb4fb2b7af75770d391f085ecb69b6f32a7e285efbe08f83315aa2fef520070eeeec2085c9861bc27ce9d52189bf46f51b18d9bf25f5d968d9b5e6fb94b1b37edfbb7e2f23bf5f0705a00c2dd6b184f27ca9701c0177a9f4f28d3ac485a7f2ecb98cbe1b3f37d2e2fa80a095fc28211cf8a15b058817a73783f4c48e107ef042e0498c0a4822f881745dc9dc943326276e009cfa8f11d15ceb91d6766d079a491e0eebbbf62cbb12b4e001881cee3eea58478f67ddcc50e819cced92d02a0072e4fed1545e1a6b5091d200510dc69d50be241e122582d82d594fe94dd41543b482827a3da55a6fbfb39056688c0e9aa23c778688647ccc657f7170663b2b979f2b4f1cdb3c43819add63ee746f2a97eeabe8c6a07bd2dd71b12aedd258d9d6edb76c93867a5ac24954529eae97fe3a9d2c432b36a5bca64af710ee7dc3d339695b9eaea2edb1cd5cb76b2d28410689bd54964b25c95e92a339fbc95a495517e69a768eefec3dde570f72cee1dc0ddbdf2e9cebc5d4ba38672756b9cddbb97ca670e67ab49fee75afeda8bf09f6bdae284486d7125249570848434db0b220c770aa871b754ee4454b80709c15d47c8033d9c2f4410a3830d170fc7784182061437e93c925fe26bf3f642afc7aec434fd4487cda751d9b57a6b6c45ffb53b87fb6b83e89fd7ee8b49fa64b773b820bacbfb3ecd616cd28bddc930c3dd87689428b403236cd179cc7fef99938c433058fefd391725ca58335fbb7b30fc7801f40260d2ea3e71ee9e0b345a4b0884225819afcd591d9a703747a5b82a76402cb14b9231fdfc53621c257d28addc36eb38e04e3ca4327f9f544b5419bc08f65a9c2e8cddb6a6d54de1ee473cd4cd4033aee9a0cf3937743aa478380543fe6b71e114964c472ae114f8fbcce130199e599c30c0f699dbe76ddbf0c41285d2b1fc6c4f3164a5b5b367cf41cb3769f53ea53b8c4dc5487321ec5b19f43947a376583fb35208676148c9994217a1612029108549a114262b479ba5e9253da4fc325752db9202510e804c327320cc298cb66b6fba9a9a0295f7c435aaf3088389a180bb0f7928c6875dcde69fa278973785c9caf277ae1bca842abf0c736ae8d717e7f4677a6d7e27aaca14f526ad72b15daaca346afa5275eff6b5414f5e0ca4f7f91b4f51dbddbba0fc4e6599abee88eaa7af51f356fb7c5e5b6d957ea678c360b32ff4fe943e546f186cf685d69668d55495a96add5fa02cbabf663dc53ccd585baaef53d9d6274e464fbc3be98977b4b644476db505ba4b74d457874baa3759f359526d6fa5c553555345e5bf96e969d44772b8dffb75ae9a4f3513ba757db33e0e88c99b395ca5aa7f8b2a4d7cd39f6f514723544ffebd9fd64375bdb6f6e514ce395c7d5d6f495f947136a3d54ed1fd1a898e6fd2acae5f2be9d36cddfbc891fc37f235dd996625ed2d57b30defdc2e93b4ee23f7c926bf56ab3463bac9cfe19b5f9f41789f95de5cc5ed5e0af61b5f4a85755174bcf8a4b66bdfb4371d9de959141df5dd42c75d29ce34cb5bc35f31b9ab398a3f1f79dd6f7b8ad15074ac7457d376ada6f5efec5a3a9b7d9efd0001f9cc806274fcfcb7b2fed677898e3a6c6a9bab4c3aff14a6dbeeaae9cecce1acde96026d5d73f4c97e4dcbaf541fd9f5b681663f3ef7cd71465f9ffb48173a0e01dd2c74dcf5c949abb634f7a4b65d8bc39b3e8de24df5e53df1d3ec0bd5968299cdbee89d79b3bc2dd75d7eb6fa934cb392b4bc95a4e3c5b9f3fc530c05ca1848cf28ae7ede3a77d25be9aeff64263f3f8eb45be36babb6a4362013e34d6b65d097e6597b7de65fa23b3357a52eb68bb354fd2e9f9d4cf3a4f2e79f5a9276d569e37b2b92d67fb7ed72234f268ca3a06a56b25d9cbb986645d2911bdf74ae5e28dbb55a5b268ba39de5ebb069c6366e32cd4a6586048ed27d9502c0c26cc954107931ed6ec9556762ec443ba1f643e5306eca65d16fe2271363a7fcf72e99183b955fe6aafba7ff4ca5bcf82848489b18e7645756c4dd7375e3ab7154b9a4dfc64c249d5faa6e285db352b984a3cad7b5cf4eba66a55a96adef92be18a966a5bb74d3d584cab896e5499b9d70bf9732a6a243305f5c6b96f54b0a547ea61bd3fc5219ebb014894da120770ff2108c096688decf61301f086c80c001770aabbb96753f8e0251204f05af052077cf04ad71eeca721aea6302fb86dcdd8b8720d8b8eb208d735748ef70b833a944dafd95fdfa9f742e577550faa9fcb2fc1975cd5220f2b9d0f281cafad98c6ddca4f56fcc0587f7ad3727d94fe92a1ba01ce10708f88008779fe2432fb696eed8aec4347acf1a0dbab8c9abc20f2c70f29e3526e3505090c5e9aafbf1d9ed1cee65da8e5264dde3a62af5e36a9396959fe57118aac4b88a69c6ca9fb24ffe53e885ee6836363637e5d32ff46f5136363637509cb68c5a9b39a08c6bdb6aac6b19db9c8b518fc9582bd578974b5c6652a432d6ed6f2abfbc273e82f2a7989acb923f97abb9cb8ce27ddb676c46cb5bebeb2850c654e858e9eb59fe5d8bcd3e9f24599fa65fe3dba6ba52a0197eda54df34fb5d7176eba75a7fb6e19cab74bf8de24d4d5b6bb4a4ed72d5fac98d2fcdbfab49ffb6819e3c4b9c73b6ea28ad5fdad22c4b8bdb9937db896ba7d5f47537b2daaebdd7da3e46475aded7146f2a85a93eb22dbd91f6a6a3f9776df757ac94bf2b69cddc9984e361d400a27451d89dc27c288551dbb54f140c857d110a1acb2fff2f7d1add55dcd66798b2d2181defeea5e8678cd3b66b6fae5dbec44d4bb67a0475a604a81c42dda066545bdd5f0a446d9546f1be96525a3e982f3487180aa0868271f75a70f758f054f0ce3ccde1ee545b2cda568fe8135ba595b6746f044f51dc7d2c5f0c1d6d954677556756baf589bb3f656d5b5baaff12d37490b6559ab6260cb6b53565da5669b2500b07dcb4b5b4f8a6a395da2e696dd8a4ee4ee5a11610f49f5adb1bf99beefababe99a34fee3fedf33965f5fdda97b4326182d5d21264ccb852a730ac1494131a77ff1a7d6262ca389c530e7ed3678e3e313189c185061e308ef93535eb7971497514e3306ed76ca92dd04c8ad109857c2e359cb1a69feb0e67b159ebef9a1f775e253a6e6c6afa38bb6979ad548c8e7a679cfbbc7b29aacb8cc9cf949626bee593ee72c5d99cb35d6bd66a1836654f310f7b5aa555006480bb931e4a796ac279c8e484dbd8d8dc8c363636373f423a484893b80cbab6e284b01d474de2524808a6737bdf7cc0e82f1487b73e916c6c6c6e64b251976f9a1569772b13c6519576ea5dce2c31ce44da412643132770318be2b5a23796c0506584a2260f9dc8b0883263de00983061019fa6ffbc946f9af68aee9bcadfb5cc6df9122369fd2479425dc9c07dec000519e7acb4e4610740b8fbb8a3d1a7d15b499a3f47f7ad36d729fa1723996645723262020535da4ab754c551bc69fe32637aed896995eaf095da965eaceb3fd191fc9cae26f925ddedfc399c73b467575cc6548c9868dd435633f7595b6ac4040a8a96bfebb559fde5a88fecaf426949e34be1a96be9ad24d575d712df74b5b275b6b5adbf34b10fcdfd4be128131d7127ce5255dca8b5ae340ad31ad02b7ca4175bfab7d9e7dbc6b5bb14dbf8d29aa53fa50f7d6d562a749c295972cea8b67436a3bbde36c59a96678ea263f9f773b97aa3e7d6b586e96c369b7dc61b8a8e5b63933e0d47f579db369bcd9b3e8d9aa6d5515bb31b5f8aa9feee8bc99abd7fdb74f6faa4afa3354b5f9f957c1a9dfd507d79978060b0289f19fddc6ed37adbfaf36f6bdec8fdb51ac6694b6dd74a9135efb77953fdb6fb536f5a930cda379b35a9d661d3ac54db5b141df17d129bf46d95b45bdb6b71f9f797a6190b578765b8fa5bb65fcb642fc3e5a9c5ec828725b744312110438628a614f3843940613f35a5bf335e1f10718ebb2ba1484a13e72a798af95246fe9490f65ef8bce4bc38e2fe49e02ab96f8b532a31d2d23be17e5b3a56303318ac66fe43d1516b4bf749a3d79eb65cb1e05dee44a8e498b3b129af54cd6fbb18cbb63636f8a62b6f2d1f77dad0efa269362a574ab1aeafabcddbb4b5963bf5b6f6da6de96c47abd1ad31d216b6eadd54fddb94121dcb92ea4a6b56a73f8916d1389395de1387c364d54d615aa51b5f3a96bb343fef4c2b423569f9fbcdba2b2d2fd171091de9a8848e48744c4261356c4d13933f4f5e7c295069653e375d6f96becd9b522448487bf1c617e39020a1556fa01d8dfe6d9bf55a9bb555b35631cd8a83aad5cea37de66e3bf749a65962a42f31924e2aa3f69bf6d625632afbccdd25a827d2e67094d2b5f586849b4cf3a4929431d25d2aa38ca84431d94eda27956fef273d796bdef7cf7aa352da1667b1ecfc53ff7497c6a0cf3224d76314121a4537a0982ee1ad31be91b4ac345a4fa09d69c713ef6805dae7111d3d8831c1604d929cf5f3b64d929c545b1caed666651d957c316eaba9d051ef74c6f93fd0549569e3a6376975e7f26fe4894dd36ea81d15cee52795d7e20e76a619d37d13aedc0ff5e6f9a4fba62e11e8c2c4c58d25d3ac485495699c5155a6d99b38e7cf69aaca649ab111cbd3165aa919baba6bb6d18bafc6fd97678ddedf516aa3f8a6fbdc6ee39deddff47d1cddddfae689f74f05fdc5d4acb67e50fedcb9f357f26be69969d2121285a2e2b4b4dfcbc64d3bd37cb25d5b2ad55d7395ab63e56f6db16cdca471bf97ccbcc5767f5b4dfb2ee58dedaa99d336a9c4b84a979bae56dea455bc9fcbc64db17a64bbf6fe94adb27153d393ce4f83884e1470c2c2c90ad1e9004e41884e40388d426140b4e695e194e41fbeaec99f326d4def6b6b5632eb59da29bba54cfa7878728011b35bf29e98fee2268c9f9c3c3756529e54053c046207aba52786942859a2ab4fe512d59757ebc72200bcdf5e5bde4ad3b67cf3dcf771b7caaec56176a65965bfebd49bffa4ddf8caf67d9ceca7acedb3dd52a4952acb2ad32736cfdc99497dcfb26233777e8949d3aca4aee5ef1b79e2299cade50b097959f0c690103b7811820086b20c93c8c8156478f192c6dd573a579c33775f5d40e5f396086854a102549859d02447142d2531a85a491c54dd88415e8460c498c921012bb45c85850e0cee5e1099fb1702980f0423d18a189d472128f2a764e5c3609f3129cb69a95c10ee06d5f29458850cf7efcb0b5e9a0fbc78f075f9b8b8fbce7a678854ae70779dc71c2e7285ea8b4d133b5524291263d9d6cc4195b996b76ea8df780a069371d992a4757512937444241744a4a224aaca34eeee9333faaff3efccfc5398de4a81b0366374acd5b08931d2182445d61cb575a5328e3b73df273fd37aa3d5762d05caddaac36128bc2feec4587e632ea369ebbe4f75b6625e5ff3ac690d54c33be3dbd36af8b18c6535ebcfaee17d1fb7c97a95c68a4dbcabfaa7ccd7b8bfed29bccdbdad492b7ddad20446f3d4a6b9edcfb63e7a8ae21cce4e4e331a4433a64f6633255dbb945b572c331a4461fb7158b775f97febb67fd3edcc52b7b3d570c6a4d604a81a233f7931b9b48fdc99121d69f7a4f71655ab54a540f43fd7be56f5eea528d0d7ea54141def163afef8e830962326282bb8a97cbc9f0beefc8b9b366ec24ddf943f97db62bb387779d24ea5d04b551a853d65797a52a2484b55b260d1e57d9ba938e1b5c0840c77a7957a669830e1f92032a1721f77884ca08ca5a5e9884473e0fcb9dc8fb8484445d21a221094b84844dd475bcee0640cdee2c5c50d606711387c8002359ec64712fb16a21206f82c6a466b67eee24e5d6ad3d6fd49356f2a25b39a6f052a3feed41723e576aff5934acf830ae28fa954774dc2b51b8583192949a2c3d72693ddf6cbf096555d92ffb6aaf5e364b693f6a59192244a5eaa9a34a94a922fd584891299927ad3b29baeb7276f95edd732bc652ffb8bb7a6e1f0d6e1f2b36cd7de94e96afbafc9f096ed9bcdbeae6299b632d9d5e19bae3799b6d9acaff799bbf677ddd56ed3ac3625667d9dc4acab28442053e7f149f9629ee81367b2e2e80cccd47dd99722b39b9cfe9d619f7341bb52b6db7667cc24139150e12fdb6d9b71988a93c9b6ae35b3de8cf74fe1cedfd5f6e697f7d45b5b538aac264de6791f8ffbb883e0e29137968c4a928c4341578733eda6ebcd027b3582149aaba44cf7d71b722f26664085bb5746ce4a337a8f84a399eb538ca340206ac085fb78b1d5a7495ebb6ded4247ba2bdd57d4c0080d78a074a741d5b559adc1cc5dd4c0c8dd450d76dc8dc62441e44f9966c569318359064614c8dd5b2e66e043cc20c7c81cee0e44a94a0ba39534e3702e178d84e114a6716f7ef95f9ad8caae8fcb8fcb1fa5fb262e195f9bee9e99aa32514d475cfea8f14b4caf05c2f94530cd9a7ba99adba273a76cc4fbc7a7bcf8c876edc65c46fd1b4f9176df6ab3365a77b4ba77ddd5f2e223a47147ea237f73a73e127480714675a54a546250b9f33449aaa740e5c5e443d1b1e24ead2bdd99db92f76f2533a6650efa916dfd3459c5b92d74fcd9da874add9a736790a634466177898ee5ffc65c70d3ee5626fd1b73d1612cd509476dc9475b9f4cb92d4f4875d7a4df98cbb54fe2902cc4214cb88f60be50994c1c8254fe99b740fd99a5b4d5a9441282852b45e97ded587e06434eee9b95866daef7494da1e89804a6ab619db18e3ead029d5a5bd95012ba35c6d1bd8792e0bda3d53069f7e36edbe659fe9959f5adb3fb393ca3b7da5d7310de417a2c2d3d62620c4ad9f2a76cfeb2b4d45a4b8fc44cb3e69f52a29d9afe8d02d5dc89b38ddec8aa44c7dc897395af3d0e9354dbfa64cdbafc396cea2fcf7b8e26c63d8fab3629dd436bf8cc659c4d8c73380cde26363176c251da76b1f9473bd33ca9ec6e0c1f4969fbb471d3c64db66b77386ffd49394bdeb8e97e2ecbc64d5a5355a6b7dd7a2bd24f552b1b37e9c7494a493b53eb37f33b55bb7375422abf2c632355652233fe146e5756243a8e74e3a6b734729ce9f09dcd92d00da89e0599f54baa93222b8db630eaba504d9d5edf6cd60ac651e597a749be49de2d4f92a73e731aa8fcfc3977d7f1c8f880eb74eeaee4ee11f1395ac3f4f5e7b28cd9ae2d317995caa5fcef4413738c728af889ffe29c9576db9af5d4a2c3587ed7a412e32a5787ef953769758b8e5155266d2bcf0ea82ad3c576d7a76d71164b69bea50283ed70ed2e5dc0bde8b1637f3ee428815781cf480aa23802538457c3cd8a1e2b7820031e2b42308128f643957fe57629bffc9c549a59ca2f6d75aa59497c69e1ee321955c56da1aa4cf9a576b72ad1f1a7ea0dcc175a67b66b67d91ac95ffba4fb53dbde13d37d62a09d59b37488e20db4a3d15d6ff868fc9a95f23be951876f9ace76eeccb42ab35d4b9ee5e719fd4a9f6649a819f95cca9ffd6c9631ae6adbadfdbe35d7d336bbeddc97b2202a85cec61f97aaf9e54ccbca1ff3dbcac70235a34033aa2fcdba7194ded7c2664034887e99594c858e3b7aed98f1e7988c3f3324549569e6437f664832a632f3a1fabeeeefd03834164d69bbefefcc7a2bb5edda7246e2fbd987eadca969add5309899ee2f0c96df566f6522ef4ed36b75a59d9896b6e66ee489d3959ae6ebea4d3fd151df9ad374ac396ffd379bbdd5fc407a06863e91d9ae7dd9971985697d32d18262f59e3f3e54e34e325bb2ccb8ee68b4ea6ebaceccf2d65b26f363a6a1a1da121d1f97bb7de4d6ac54f3436121fba3675787674d3e74d4d966697496df29e3a81998d9ec4b352dce6a3ae6af2d95745baa976efabef92595324f1ad561d3dcd12ad53847a544c719989a95806810ad59e9cb8ce6ff817dcd4f6756a29c9492645e9eb244412d59998d60661a067bb2d6f2ef2ff9e9583e59f3e7ba2d05ca785b0da5c337a09a9f966fd6fc3b303318cc342bd2eccbce2c7f77ebcedcba62a1637e5cc6545b186c46afc59f31131d731547b59dfdf88c3f3e7af75230d8cc9a399ceeb30dfa4c77401bdf5aed4b4ccb16e86737dbbd946c36f536efcfda666b3fd75c5a3033aafab76dd26ad0c537577137bd3381b22df76b8bc3e4c89cfb795abdb7ea7cae74a16399abed33c5b56b7be84ff9a70fbe14a8b65471b61587c3e4d32ea6e99e1e5abe6956bdff6efda4cd5b7fa6f9c4359d0f35eb8d3e79f3e77ea7ebd3cf47767fdb9a92cf65898e527467d22c494bbdbb313ae2ecc524d5fbd69c1d6fba6ea88d9b8eb2ad4e171fe9cf98093749ddf386244562f36ec14d547054cd4ab52ce58d416ddc74dbb94fdae95b7350b66b97be1e95f5c834ed0d496ba41da2c13ae38d6b29d57f061a7a4655d6569f0175869433a09861821faa2d50f93ef43735a30a3372a035bf19db8c29666c60061133723405d259e3dca5b4fc0d822940d082ebf0a59a4661b319bd5689cb1254931215a5a4b17e2e57631778088271acf9a16a7ed96b58195a5051861265cc8037fda1d7d26b6906e60f0fcb3075191c543347a3902187b364cc408600dc69143214400d05f3e5068b6fc903bed50616a020021068a08a3044f02b7a946002d896d21381980fc75c838b18b450830b2118101ae2bd207073772c4b3bb2da1e8bf6606e029dc7a0a08b4d0fc5f02f314e3ffed24e6d2757e3815b7805b4d8c0e3e113f0882ef00037c3cbc019303ace4330a090dd6ae66460fc70778f7a4b55996a98aa32d1c7d9a8f167b773b8af9bce481a4493cc7ce88c9cd16dbfd27476cae66d5a5aa5e1a7291dc58eea789652a4cd34ac292e631ae776e6d6d5047a9cdd77fc793d9b51bc4fbcf301ba38bf083b6d6f7f6aa1e3c5f4d637cb5b6bdef7b7a53a6c858eb9936e7c81a4347dda8d7cf25a283afee84cc378d3abebf8a3f5a1e553d91ad5554777399cf73531ee326b4a12d434a33b13a87c2dbb78f69a6afb43e5890bad741fb9b8f431cd1cdde55a5e4cbea65abf794ffaa479e6708e3e4ddbfb9f3f476b96ce1e87a16654ffec72cd3887fb283aeeaa14b6fdbeb6cea066411e64e91245c7d9d08ce27dab69d68bf5dfc8faf966a1e3cc4a549526252cb2a82625a62a4a50b2a62c4b51485b9ea2a09ab220c99e94929ab6e44e5ac3d706e52fefd9656b5babe1a02f6bdeb4d297aab88b2d6d22eb7daaad3573b94a475dbea9c3572ae85a4c06557a234f4df56b9ccb676e97abce3f55566d2b694dda99a3fa27e862fadabced97b2a60fd5f6b3aed476b1997fea75f84681b48949bc71ced16bbdc49870f937dd19dfb43eb125ad5971b492f74fb376aded5a9386ab369a712d2a4b138d82dac274920f458bd01109926cda7d4f3a54feced479d7abcbf2c5f01d61e9cc34add48c664c672f55f7ec46e29cd24780717fadea9bae99a4444d4e5ab3f4c95f4cd4e4bc9138f72ba92caa9800cf6c637363535fa5a7d5239d475aa5790165bc56e8d20c6e0850e1ae67d44966bb7647d6d296b792b227ef89efe729d997b25bdf24711859696526c639d9ef3771969517d3eac5b4f24f99aee6f2b6adeeff7f5773b2fd78bfb63299aef965f8ea376935ff35cfa96b65fbb5ace697e9fecacacff96b5fcaca8b699f6fba6e2dcbd5cf52a495d2329969da1b89c3a4ec5a9c6c67e672350246221024022fba7ba9f2a730131721e0228b17c1227151e5eeb66bafc597c2fe9e19c685c94554adbe49f16ee2a2888b0cdc9dee5e6a579aeb9b483a8f19870bb798dac26e11e5f4a6eb4db6efe79aa354e31c85edd7b98a93d9aebd67ce651caeac32fd26794fd97e9dc5e97ea58d33677c60c226c783591a16a248410a6e3e8454d0c3bae361a51ed6261e56260f2b081e56ec612de36125808795080feb023cac1c0022a651e4621a486980e0621a615c4c63bbfb4db86347f8c4ccc327c278f804091e3e0183874f14c0c3278cf0f0890478f8c21a1e3e8185874f7ce1e1136578f884093c3c802706c1710de1808b43d47071c81a1789ec7091088f8b4490b84824c945224f2e1209c14522d8452227b848c4051789e4e02211215c249200178960e1229108ecd0218e61c6c5316470718c1c5c1c430817d30071710c03b83846152e8e81c5cb25fee02efef072f1071e2efed0e3e20f485cfca1c8c51facb8f8c316177fa8fd70baf80309eeae73a4021dae1c20e2ceccc51d9c8b3b542eee14c0c51d225cdca9c2c51d0ab8b8f301177748e0e20e1c2ef270177954e0220f1e17798c2ef280b9c8e38a8b3c40709107ce451e23b8c86306177900e1220f285ce491051031bce262287331a472771d56887cc7ca91ef5861f21d2b5c7cc74ae93b56c4b8bb8ef08b91875fa878f8258bbbf31095d81e2a01000f95b8c143258cf05009273c54e20a0f959880874a6cc04325d2f0500939dcfd95138a3aca7051c7085cdce1b9b843c7c51d405cdca1818b3b9ab8bb053f441cb68b38ace0220e3bb88803142ee2e0007767f9d849dabe93b4f39d24169272707642f0c07742a8be1302ce7742d0f94e0825f84e082af84e0835f84e083cf84e0840f84e0848f84e0850dcd8bc5ca22836b9808b4dca70b189085c6c22878b45372e16edb85854c4c5a220178b602e165d71b10804178b6e2e16e55c2c1ac1c5a2165c2c22808b453fb858a4848b450a70b188022e167dc0c522365c34f27604a8c4a804f06da5999a744c213333321009000000931200304024180bc70312c16c9e86ab0314800372a67290521d8aa32849415219c20c0100000000000020981a02a5295a29c7c8d19282f33e01009b2b0265b1c6599152c7f19b177053c43555c0be14b1bf9c5fad8f1a6dea9b6020874aa802915f6811ad2cc131fe698eb2978a280d50a1ef92c4c70a46efe9525d1ac4e81034e235d5337003df3edf50b9ecdfb7fc52a17fd7f4086af45247e6af2f529cfe8e3149cd0db26bd903b6e488f4226b19e01250a3e9a2110a17132954b2729741f1642cb47251420a7add4522169a8e46a998080f4d3c70dbf53a0f36dd9ed1c8f0df14b9ebe397d2791b889d13924dd5ccfa3023e766edd6e5f676fa397900b4def30b070fc2477525eed178d3873c083c285cff25a8309d66ea8a70a0cda27360f908165e7a25aea728e39205ebc3182a9f66d740cdc774053a8fc169e04bd9730ba7ae045646414bb46fa4aab1c482844d99f544e36a4259f867339763fe05898bb9a20a5658329e25a8d15c75f9d01add8f8653879714a8aad6362c8b67c86edf38147d9b817573d83271a1192d830a836cba0e6fdba0230b64a236790111a66f81a5c10025160bf3b1c71baafe84642c27f24d5aa5b18e4a0d42349f848a78a8c5202d01ccbbc8193300d990b5dc5ef3a30dc7d2f8c94a8fb15806e435a5310fe768b2f226898bc334e1510b7a2d8832e01c3ad6a8577600183ffc3dc1aea0c6f80a6ea843ac6c2739af045a022eb631c4714cee200558fa4f71291f4ddc0f7c327e2b8899b4e1cdb3329b898df6cd3ab645eba7a92d95ec51ede37df57e99b801ed5c31978614f484bdf085cf2f9379c6af1120197c6cb5b66bd50fa4cc28e8bc48e48d19411a1545469298215a4902f6e8280b71a16f6ca743e3034371caff99d6ba142902ea7ea1086f52c049b0fc08ee310b25951c59f3b14f485ccc16fa5ff90fd808deeb3a1a08e59eac455db4ab051a1e400c887887a0bfb39a36a4e01da402a3c3a68f6a2efb681b4cecb44ec43a9ebffccc0595e83e47958328886dd0ee15aacd5d04cdba3deaab3a039a5dc52f0f519ce93515b2dc2513e911cc68f85a50fbc8fbb01215320a1f629f5a82146128b840010e72d8235bf803c66df8c2769a9b6728b807c3c830ccbce0954bc0b7a6c81a5479db1e6b6a1c1ab2054f8ddc9786ef7c608c6aac64feca2dc8299441eac3ec4006dee5b87a887605520c18f44abb9208536d5ff3a004775f8087e46a35398e9c9bd99239b8dd985493b305d7bc1dfc36a84680bb83712ea93ac6e77dc19b02843dc5658d2a48c3656cdee3e633a8652e69e51d218c104c913ba5229253f3b5f86fe348a62ac219d79ee8eb07221073e3671eb8a0e38b5b1be86b644f52ea8aede9db96da275c18687ce2625a8eaca81e37b2c1ea06d007a0eb32feb6e9ee7fa8ca87d8a12286ba76c42793dcb7842e72b0161d36b22fad1f79c893a5cfee9a3e5bdf39de13c96632e5a4dfa92d310fe400b42884e1bf8bc7d66877da31a00477e4e039009220603780f1dde98ee7f890819d0022e88a8ae4203cc01a21c1e19541288e058e01e7a016e78c7dd60600bce0e888096c3a436ff7ebe513b3f3a7cb90bd6b244751329e56b5e45f5930781b959a41239a2796118cb91708a260dafb8158d5bc416e3d8ad1a2e8eb9a4695851d5583db437d32eea0098e4efff1c8538d7b75b7b179ec8909901f5c4bd627463240404c14ac09ebb49dfa20f840094e90038886fcde1a7fcc3dc8ba721a727db6f1d62f32803a81673d13991381179cc736790a9155f57f35e2266486d9f7b1bca38de118a5c8eb9098f3c9de038e6af2da766307d48efae1b6e13f86d6ab2585d86dc3276cc781c28cf08a2ec7501620d10b0e2bd1bda1f7c9ec93531806e46d096a4521a3ef7fb00b084a6549150e5f2463db5db0e6da1a1c2d439b35f1c7b7062be2c5a844adeace61be787c05ebca890a291224cf00fbb807edcb6cb25f99ee38d82d40af621a3611f1685c7b2af18bb111591b4158ef6f0f334cb1e205439a8a88f00483b1421695df54f7fe4cb310dbc651faf56b3c6089113f87bc71e8011b0eb24cfeaa13e71c87319ac45469861e8ef0c66dd44eba1cdf368ef2a4a7fb53fee63260d5f839034786a9388b3d635b10174966d94df2d14686954b5e877c1bc53e2f96db90f8712979933cd632179ffc90b229d0bea9c5472297da974a00976f8de68b1da90c550fa7f98ae401e0ad26dfc0612ffaa83cd97de3432c98f8e8840dacedcd49d146b2de82944d8bb8ba11a581bc28573335f946148b0fd5aa7bb9162d183911dadefa20fdbb894b5578203e7524ca6d1869e0296931f0cce558f1431c54de2ce131f31149e4445db510120612a2a2ff227d3811547ca8f1aa21936d55b39b3ce73b42347802869f2287c36e9bd5e58c0b13e5473b2f08361a2e82357501170d42d7b3ad97a92ccde36342c70b4b442b8d351931650afa7340eb4088a34907604de457bc0bd4e77e585d152591cf9b366dc3dd46ba6b64777e2fdfc3e35e71e1b7cecf0730156c9c5c9ab70412c47c1be40be0da9e5dd53f4e357538d3d62570ada641da09a5f071f27c4aa9ee8f295d61b1aa2025a69a62468270ceb18b6def77924bdd6e97ee68d29cddea60a01cf9f529e77fa3498499ccc9dc7059a0bfa99d54fbb93fd9316266891df4f2429432624cb5530787f41792c433c1f2100fa8165b49d4ae8fe60fde9ed641140538a16078310cd2bfc96f5447273741d92b0eba157fccc94a8c22483acc34d222f5df2324e2dea7fb0367e354e8d76565969d2cb84dc91aee3a58d28ecdba617dddd6fe34f64deb4455192ec92b02fc8d757f90caed2538567840a37ab042fd0f91d221e0c22ee41025aa123f5a0a6703855edf03e4ec821f2a06ad04872b03046f0edc776d0035040448dcc7f29277cbb9ad186731b0ef6556859b9da7b5ae7651af672ec568a241597883a16f9a553d031a5426d87534edd71fc0d8c1de4be2c5630cb4781a1f40c770a345bc2e9d3cd23cc154028cf0f34efb0e84beebae9ff904d60ef88098bb49138caf8d30e15e2e8cbf035939a9ca1c1607bb793ad8efb3221f86c5a0e80f85e9ce1b5b36f69acfcb5890cee7b7043de4cd954f378b5c218a1a5cbd28585f7f7b527d303f92c92a5e2b7ca3496ff9cd2fa7fe91b3db65acdcc4df634e483fd35507818e0848bf0c69dde68d580e176f59aa23de20f1021f2eede580327e2963e955e0b57ee1b1bdf42cd74bba8149927cc17d43a69e12d0ae8ae63b550780397835ddaa317434d1eb604918909ad781231636d1140c1b3cfa67530fe761ef9b2a98ea0cde1c51f1769845824feccf0f9fd54f12871cfd878f0780fbf1d60f4ef606df7e0d4e16a36d6439c62a20a8a5cd7014a828e69af6a1800089a0671460b23438acd3796f99864be1b682eb30f5d50e90922a99a35049934a92238c8dce91cff51de3dfd934b783d8ccd7be13bd319551841047369a7d41671cedac2ff1c6da4b0f8922d4a394d442de5fa35c64cc6f8fcd322245a92cfe6a7b5b7fb10e81ef4e587994876fc98b3a2fb7c02863ec020dcd82ecde9650599cf0ff767e152b40d0b1cfd91b5007911aa8834467ab8048eae88771918c100245fb8d2c3a0e110169673a9b96c3fde2ffb930d2019db13224023e8a27f168e14d59166c8183710ead7229bc7a3e6b3f780111488e81897b0aae6c6116883ffc1192c84e6890a92148352b2c5d35466abe150e5bae7c34ccf91726ca13cb2e3f1e1c13af06f3aa7260736b08ef9fec83988549592c14a872ec98e69e05c11ef3e9564a6d90516ad899bd304b88d8b75a480ccd2e1c7a1cfaddc05a3f5ae3427d6079b01ffe349e67495e128abcf630ba66324532bacd578adb9cd99086dc15994f4d1f79a4bd85eb9359e6b0df118198f55d99d841e54f7fca270b7f48e927acf9a7daf36a5cac2ea0974045d4811f97e21a61c4d30177074876aad26316a95eaa476beaad9678bb64a326752da93c346c878c071edbd15f39636dc7da9621a8a6ca71973297c94afa2e5580bb27f5a3e5794f6be7c5dfa2a1f71477a0c5b8da0461d4183de6800c3724a4f023fbdfd1c70b9b7acee58d28cc2ec9c81996e13ad4e09c771ed94503fbe24b97f30215c7f1cc25315cc01b6d1e7bb2b28b8c6994561c4ba5fa605b35f358a0518b14159140c06934cfe69cbf0b86730630812fa559818e81608a55a02af318528ae8fe3d5c405708c9329bd78c36b00e3a2b45b31c4982513dedd629875a026822fc2e54697ac53b636ddb016519463e1924ba9640b02c1e42eace837c8b3892a7c0200d97d54de3ea9cf1c38d6e8b5695142abdafca574dce53086fdaaeb4bbf67690fe105df6319a1aa8d3acacf51c58a8b279faa6e7688613f822b87717733da453eb9ca6b52861d13699bc35d3a4de762515c1f0098218d6b8c82793f899343cde6823fa06f12a2bafe42185f8897a7b8e0f944cd0e510f3486504eb821cebbc22068640a3160d34c41f0976cbb3e710bf957012a322cf32e4e8ce574d1e4a2a404484d2f3ab355d144a703781422113c92238adfef0f48c356e9017455a77464921212c1cf496a528c66333d3c7804435da3d4b6fd8dc197fdb3b2f43908700d5f619ed33ae395a9925361f82a7df1bd1e8b154139c61cd3e8651d57b2cc48ea71a1411f29084c65ca89fff7661d0d2ad61a6de140e82448ca7997c066fec0eaa7b58387d7108a8c1bfafbf54e8bd1299e2608764891abf95f6eb6f7d5c31bff1a49c216b7ce8aa00773547cb592c57ed96ef8320ea846810ca8a5ef45e64ce028663af4fb2586f22cd354a86750cd9bee1b345ecb213e36ca183b3b538b928a54cddf5484742e46e920ccc42438580f71cb8cc9410e884c1e95191796b0ff55f07024941630d6ed2450a90c5cb8d3dbfc41b8e38126148635e3460901c2e9d2e3dcf22f3029c1b01a6fa8305524dbc8b9f52c3a87ceaeb3ed09a74221ecbd19fcc6e4c21d92855e936a902aa6a724cc817c08e5668ac0c7c10c2bc4278d8e57ab0c28094ba3ac20bb5692f4b7fb35c30aad25a952ebac0fd084cdc29a499d1b74dc2472f23089ea343465a12094566a9ae347fd5f38a78b31b62ad89ead323a884983d1bcd97328fc3d08081662bcbf0c021e7594624140058de19c854f9fc248aa069123e25218884fa4905dc1018f523c8e05c9ccc241f143a17b214d4a7099d7cd4b381c603b9cc94895d58970422c182626dc44197544388cd6b92a9b0612f683084a53b114c91094b2e5dedb992f2bf4de0005bf6deb0f0bdc143b9757f720778c692b474cb985d1022d2d5e7c9b639911bec47134fb36a3160449ff29823dec41d34c035476cc4406363d480de3e12220242b653421a15a5ed521f3d89e95da810e47e87a356a9c0837f19d72c092b2912b33a7bbfef0c6064828675706d9994ab3ae7dc235d9cafb852356300e951c8b662b1719382a78dd900856fb9d6b6a59557f38f7516ad15465e469e3ebb1707c97bfb060e48e71b39e2f5173985b27242d4c12a00d755a50f7336bd665bc125e8a756faede236086949c3d5ec911ea6a0b6dfd16e4fb2e4050686c38764a35275a0506f65a920254c173243675610d5b5e36404ec005e93e43a3482972e500fc9ffe124a0133690f08182e830069ca1310c66bf2dd407e8160034ec5098caab0c84a1297dd45d59d388093e9710b6fef01ec03556c745ebb103c72a805f058bad4de22772743a34a6d4c4d3b8a1116c7d4c06229ff4a5fb9d7e28dae5b4915c2268c0b9e8632a5bbe78913f569325ad9b329b6410a3cac52b8927548bdc64d00652796ede21570f3f2fc5c0cee8c0a2c2a3f90b051a11d7812b1d30b1bf8d544e381978b903f008cdbf3a0d13008bd1d80b0bc40cca00ee27d2fdf56a677b1bb9e757483e09a2df3de737c18286dd7813efba4d9525309b54d313ca9fc01779acf153291250225212a284eb69e5b521a11fa2ac38458338725ba40ba2dd9d7b7ecaf0efedeed42c03007458ca80f6185db70bf1d59b0faf906fd07a821fdddd4189a1cd360cf76fe4d8a46823d16726e2715b68c6c74f826cbec7b893f2ea5f48abf73109c2dd111cedb1816510885154d17d0935d62bde262898d45c5c1265a7bca14ac19d5d1a5ea251592828a246d17f9d90cb99ab4626480cc614a8812004f88ebe8849a830f6c29d754bfa2c732f14f3557f4060c2a4308b93536304d19626656af1622784cf0e78ee96bef16c465465c3d315e9055dfd49497c12f6228da394f56d95bc0f0644260eabdc14bf0a7ea4142b713113541880880405656484c378b00ea9bce23bfe17c4116ac23c0d8be3ae81138d83a533d45f311d0a10f8df7813dd3ddedae798d7243deb938ff57541e3625036effd654d855f8e459b31b83bcd6b08a6f3946899e113c9bd1f119318063906d6e2f0b3ae2bc9246e436073a20b3061e223cba9c51d8d7f7ef76e02e01e14faed7d77e2cc5652496d850520e96f86ccd3df7a03a946416e15e72de9fd83dc605516721de3767af2f9e518067105f4f87bb4572a7bf328fd390f1ed2b3ee51894deddc090188a1bcc2f363b2bb2f3d307254c0d8243056c789c395dcb1562c8b4addb53942970d4da5fae223045644c5fc6dd31697d648f048362059b5da8dfc6f652754ada18af960e30de9ca989bbd83c97d301256b37c92ee23bec863d9a7f9b07e28fc754c189a50bada349e56f95e326d75066dde76b855e16f792ed8c0178aa992cbbf7d0b14494d7e85ee60e9d05615d92c0e4b16f6ec8d9afdf610bf311c0a31f23db028c46296de47355db2653b57562f35a8e905c19c9e126a43a0e07adf810a5d66a12c9623ebec70a1d69a5ece3edab920b6360099a9df2f2088a1dbd2c8e0dcc9d0fd5e5949ad024d0d82c402a506ab8fc4d25290c5f20548818bf6683d12761d566adc07b26a6231f39ec1c5b1e26af7d594b17313101fa188fe718b009677dae0c8d53ae3e04142da5f6d3bd4076c54f3775c792d073cd84da7d7025903c5b908cac3456dc8c4a7c60a16af90159fd6ea02f0744b2bc702f1ea05646683a67648c7981da39354f4d258abc3aaee0abb458e39352c0e449282c57033d189305ab766fe04f79c35e02dba19dfb56fc3e6a75b3315c59430baa303324c0ccd8317482ca5842d23251bcbff6fe5b585b8762c5b906cbd60b16e0ca0ad2a837b7fdd86047b63e1b239fe2267bd4b61eddd6bd0da6d5c830a82d1035d1a30d9fe73cac1120e86f1fe8948764b9e73985de4b542c8ba75b98b275ca4878ca9025d8a3b40299849f41b7f01dd3f456c11fc919721b9c06c0dde4b6d9a22ad7abd2da1e99729bb383bef075e74ee91e41f76695a467f1596ca92900b6d3064edd5d3f33a7805935c02d98ea99efc922966d0d2d7bd6bf87fda18937316d5e5b7c73ef4978c34e4ad41b96fd4beba2507296ead3a778bfef7e1b4e1be6dc856dc3d9102304dfe139a2fa8680e5de887d3cac6418ab65f51f03b3e7c47f57320e3ea2a16d5b660270189cd275fea9d6386a7d5bf491c161bc28ec2f3663446fd0e4601e832257b976a08b631a4df8c9c4e6278c44038ab781e02ab1a43a91bfc2e6760464cea889a51f1970bbc07588a9908a7af5807963306ad4a57cbe6864d5d85e2598b9c8e5223e1ca1a1522f338edd78842ebc824699e8697f1f708252b028dfc4c7165e8a56b0f31da73ab71eb160569f8a5b71d8c101e79754d5d26230d80ab5d7a005ecdfdcca1c203b7f977dac8744901efc6069cb10674d2884baf10111157f76a10c3f623bff044a0d7f271b4d4e12c3590628806a43f3c2a88a87f84e9949369ccdbaf68a879740cf6f38e18b8e5247558f734a9ac52ae94d6fa159bcf5a3d193898c4349298146b8ade3cee785f7691027815cfa0690f7751e856517e1ad27ecb6fc44c4f48ccb1e6fe45b00b556f1f8170afddc15f31bca3cf78a23d8569ec74f8b2022f0700f7a62328a11945163121b79decdc5156ddb05e50e01c3aef189b61d1157386d4049098b5b94f04cb4046038145a6ac3fc1d144bf9877d9da82955461304ef72d9cc75ed5d81013f92461907c8979e11cb2f301250e0d1a05dbd317312b6711f344571ec461a3f7455af61413600390b751107c90c1f1affb88c68d3481071dec063cbca549223b6d34a1631fe1d2ee644cde5af17a06352bfe0fde4d7b2da0e3daf5ee2fa07f196c15974897bff81d61e435d489b27d2af986be6e297564e520c167617d323e94d1c6de1e859962a4b32074a63d8c8046fba8e3eccbde89c8c65a8fce93abf3db8bf2dd82a68f38744cd98c663a6c1e643b47b8ced4e8382f4f9232ef24801e6f0be047252cda4abb5d78bbba4145b2c6dd810fba1ebdd891ac38ecb7441ef62625bc5c86ef723965af821210f2ac7783e20ccff44fc0d60b258be4f3078499040b033918504eccfd647ca4f410a1c7eddc080e3421f4711933928d5af62f489dc09087393bdff1431ae54943b3d88a8882e9b1292ccbc506384b963915fc1610a1ecd41d36504b7cb8a14cd5ddbcedc487fc7600ee88249eea728ac6b8b78fe187aa05e8ed8216f9d107452a1cc0f05c0483074c5ff949301f9fe3c3942b6b80cd55ae5e1c7e18401809a5ce6b1ff47737540aadb96f106f7691e931709ebda44839852ef403659d1583f5390e5cf83280e0be6ee837d6b7566c919c95696ad77aeb91301587bab76b564f3088cea47caa69794445f5c2f74e4d1a034c3661a32ec8270d2d45b7d9bccc53204e57eb8874b932d0c4933535106e0e10593c95e13bbf42342209fe73ada9948470098aedf8ed810e607adfa7a7b37a25a17ec5dacf3fa4525d3f1a029b7ac08b64068cbcded6d7266ee2a550e8df04a1561e3ea2b1d9c0e7f1782f3838bb49441119ed74bfa7702e54a88354999ddd77af9325e073465fd0628a627dc0159a7391da9c322a6b15d802af107069d5ef217338767259adb17310c4cdaf9913d82d395dc7e827fcd0d27c493887247a9cc9a157c373f8ad9d76adfb503c03e44a795f499b823f7ff69b9c479c23a7f11f776436915cf735b96f07b2d63a52d7bc834f581db62c36a43346d7d4218025550935872da447019bc06232b34c1f710005988010cdec2eea65df145025e2c6b55c50b77a467b91901ad36056b203372be10fc682d64d7bc7fef30cfc0c0f9d20dbc14aef366739e3f9677c6e3c00c371de4e70dfff9369a230c530db6293c4fdfabd16895bfd64b44f703e9eefd42f8d3f165140316b529244787d0f11e321e4d840af54b0e2de66df5ed6eeff61b9825894d7dab9e9ef31b2a5b3afdbbd81e9ea7517154725317107ae2b530838061a34f0c546a1325cda3658f00fd7858e0c3a476796434d16f057d1188cc3dcc9b0341b253a19a2e8965e3f06f61ca9d3e8c9ee6c084ff5180536f3052eb38543076843e08fee0d3f62bb2d7bd3baeb27528bda8f39c927b2b2bfffcb9df83c96302ed5e82c4342e42cd9f734b8318aa69be2e9e201d47d78779840c179c8ec37a76d750e09dfe7093674021b4f55b708cff85a11388254d88830d4e6d1e8f63ac43b2610f483ad4bf95309d47e3583825bd10104a1ba3b5ce830e8c5808930ea274284c0941304ab6509c64e90f9aa8d8382d3c3bdc88ea2fd9486e38c93772665d353d2426e32e69778abbe50a342174d4b25ec58bfe550f375ca786e6c8f3d5661a1339ad41c227f8ca18f476bc457257d6ad6b6a9fcc564c6dd50aab81b2962ff5e3d034e1447059d00c4fa5d4936ca004aedec2fa03259317e05daa1e5d04b1f77063a4b314a937c0d04426cd991dc05f68dc37f99f151c6cd4ff7fab42ada690df2332724dc168ce9c5d33b6ef201b358b764b37c51f6ffaf884695caca94f556087d26e82fff1ba2434af893b9052aea6fd1d37f9cc490268535e6064f07b7682dc8f709b5bbab8867e940df8fadd940a8865de41ed839a63290e35dd577dc2a89ac58824e8cb9ce37a64243fe5447b68ec3a56a96202232e77196bee9f3a8db17f7b3854dcb871440b43855bce9d6e1fdc9485f59b2b33f8a8e1f8a8706aba83fc199317b8fbacb1f8b278c6a92558ab7b3c005a71c22fcdc766d71416c50e7e5905a02b4b90ed6350f22cd012007738df16b0d473c31b4676dc1f4a837d15993193be17cded6e673922f043bd2b455ce4807ee8e2ad64cbc45693182239433a83d44a8648120c66247c7a530c23b4c478600878b14c74686193f5382e921ed7c1d5b97d1bda96c1e2e852b5be654df1ff2a3ea0a84efee9c70b20909697a2e2a6ebb2200de5e82e8600b5b39261e9ac22b41706a02b0d371c344ed7e665bcf55dbfba1a78df805f1431059b499fcc9bbe0d835470bcc224458a89bdaefb2592531535f31b61ae10904f533be9890e0995d93590fbb4cf5dad08d3c16cf2a8c5b3eaf51b19e3b66331f55a2321e1158f985955991b794ce182d52a4fc450bf54ef735eb7c7d84f256979b6cb24b527877cc01ed758ae28850e3c514fbd9848f15135ae7feb59470336d008348c7b7f293611f6d3c439060297ae29016f12085057487388e8dc333b500d59a0cff3f2f3cf5ebcd07ab7414cabdf15406dd99e22c629cea505742622f121a21d679a40b559143edd23041c6866d33df1a1460b79853ee318666455ca8abe60c2a606b3a13f3be46d15d59ccbe4db48fbcd19ba517b3e9dec272fa6b200154117274da09a43d9ccc93730626ef9a6a40b89449660c03f8285bd03f16652884116e02b876ed62e183f5789a580763efd60fa8feb4aa6ada391b93c868089b4658c8a795fca8e4df7c20a5ec6bce3e63953df8a0a5b2593690d0f061fb9b0e8a13d4626ba5ce5f5a2a5a120c4e9f601762068c31295ac0c2206e6090f3758f163171fef3f1842c8e48ad21118ed83fca30a53388987fd77bfbf0461ca7be92fe4c77ddd27d3e381a87a8b3f93258be15e43481f43975df687af40b743d6c5e87766cec57a0d946a6f46fe9118f6cdeb68fd1650bc74948325fdb5de23901345b6d7958747c262e79249b88b3c423d5eabf767a3fcd6ed80060c1759707d24323f41fab51405edac29ed4ee103bf90c494c6ea381954a2f0c268f69aa394808472e0f5c64bccdecc7b87e8fc34a6cb81ea685140ace3d0eb36cb8f4692786da468aa84572b06655b1d5d488f4c35c958def19a31f7a3aea1fe5e3376f8238b79656b54a668808c7f043e42d4209f85a9d95029702e5ddc9f5ec38e4b09f8baa002809855e6c21c15883c8da6b95acbb99023ed0276975052022109844d216872252b3bf3a2dbac0b2d46deb08fad4fbde0d980c740147fa22b8dc88c8ac26ea98bae55e6215caad98a84646105982c15b879c83c5b6b6a8faaa4010f0e11244c8125e10aa0d6aa80d2b0c5bed83b554f813bf95ed2e54e6fd845ac6106b32c1921e06274280897936a262bf86f8634b023982f166a00a54fb4c3a23609327e2c02c00021fc19350fed96e111fa48912fb2a250b2f0f6c850fd698ef14c7ee9e764451e50ffdf2e17cf86cb1d4bfd56929639387e1459e3f3e4dcf0c2e0f7af233b0c90ce49f0a3d8b26b8ae43c4e2ddc4e59e3f9f27c759afc68c58956d3172c0967a3413a231430834807f85f734459b8552b33b45096803bcad2a1e04079fff6984667d0581ba0221032500c173da12f621606b564b00e5f5f57fa64cf0ed0c350b1357aacff45c35925f29476bb652b8fb606104c07245fa575a5fd00801a03361673721af9f2a0031cc4510a6488b910d985fe560062a65f8833277ecd0a9baeddec616cc5dd8334fd1778dcf4f9b66e71e69c96510f3cf0ee848dbd73d327092640187220e451df2da4c531a1022848296cedf69fcd50f6bab042bab36c68ddd0843d2612ee7c92fb517ac3b1ab37fb99c57d4bcc02d743d985380921cd4d8b0a78063026c720af59e05192c973d36463a5561db939423df2fc5999e89e863538df06fdd8a42fba346be291ba10b16b35a14ca539db0b4a0317a9527aafc05c147bf80f0f39387bd40b950c6b94e84216867f98e2c59e5b53e8c42141a0eb32016e1cb866a25451a0e33444f390a87babfbbc1784f54092a41685c0e78eb9d8413eacc21ffda28365bab4dc0023aa64e725a35d1698995aab2f268dc0f870650701717151bd860b4f962273e50936f6f2bc733a8091e4583d93da75b194b724b78146057eacac9c35f93df546c7e14bf3dde6464f85859d046faa98a437e8a136e10d0df5b95365939fe61038ca788038162c12053a60223e8cec033d986c11e02b17a56e5ed2d9cd7e6d0b45fefefe86a21af0a9f0e50e7afc8ecbafbf25c53f88264ceb4650790abc7b6a5f7cfdc8ed53643e16586f4125ca3cf7af1c88a9acc19e2951c78d72f2af47020c5b600cd8fac92f8a22cf9a270caadc88d1663a63e3289f304f3dffc26f1ee79af36ee4d6d5a5f05fe6d75ff65473d26386727715ca204da7eecc2453a25101afc33901258cea2a825223368c13db01a4135105899ee2a4a0c0b41b70cf2e4cc974c380401f49c30ea7b270aa0d922db7c72ef27ffd4c8bf2a10c9958422f7cbc2a7b94d0439d6a17157284c1e6725a338d38c1ffa4f6ceaba03c1774dbe7a3e0bc283c9b2e44c94ca1d16f1b7ed85cb1abb280b6bd82efb3020671b682e071e8cff8f38afdc68ed8470712fea2b908eab5433159f53314f28869f8751afb970bee9bb769db23d8f3b06a392e7bf5050adcf841c8ac1f702fe0ffc97e3a8ea77879e991765c2a20d19628dc69f6782c1d23ccd5f75ce1c8d81b4694894d56f30613ede0cb37262ffd109043945b9e6facc2238a5cc47f61ffa5ccd73988fa83629c6cac00cc7fb35728253405745c91a11380e476bd01618540e8443c3301ce825ee418ddcef67f09d70bc24f44b826f41db1c6698cfd4b8a046bea4450f0891565ec3b7efc550d01cbc8f300cd2dd9ce388b43a3fe94b0e85816c4b92f8c33f2b762a8521d962dece5df34e99a3ae686aea1f168d201c65c5cd273962ef517ad83c8cf6ea259c75b28299f3d9e9088847dd365240d0c0734b6bd91231d00b3f5776475ce9265a86ca4c13d747597ccc9dd0da897b14a3c5e46227d697a7ec1597d018b325e8fc93e14d1a2de9f4ff22066d7ebb8318713e3f4fd977f9ffe94b8c5305c8a2014fa309fa3f7e410d48b954e88fcff301ae85e1ba3e855458789d3b197495d069dcbe936324c46a5cf12507e2bebfcb98329c3f8f941bd2d8878f47438c00d5f879db370569e0f13740d3e1d798fde52a9a633af5e5168ffc88013dd2af1d397cc8408672a1ada8905a9d0d8f43412eff5a893fdb6a653d768199ff98020dda889ee9081c043db59e09e789622ac08b99c87d03407fa4bb6de3a7579a5d756014a710d591b516df34501135fa3195bcc6d6b198c86e44f54ba4738af34003c85ea49be5f70bc3f1c95296b6e049b8b88b7650b11665de106ceb6fb48ba77e81f07e0bd69a1a30f4d12278900db6d4cbed0a950addbfed611966407a91e0b7461c88332bb0225c2905ea7d2552b2727ac332268ad8038afd2d9685fa15bc6257f25c9423e3aa1c4b4b05db0f7b122599f2d4aa430957accbbe8a243246c78082da2211fa9073155e6e3e1bbd688058941d131c0e71cca84b24d41a9ce4476a2e290b02bb835e86f4cebe786a56429d71619dee7a0c04930af14e4bc4bf45dbb8b19e0a057e0d17469b566f450afb6dad06ad08cde0dd414c67b49bdd490925af05e1d5c08ca5d518957ce39354cfe2975a2803b6e949bd61ab16cd77db6a76c1579dac5e7a0c17165f7641277bf11b86ed5705bb66f1d53b2f40fbce1f4b3e55f8b0817c7125e4618c93b9469e8609fa82ae220e50c32b4322f0ace8bc800167498234a4633da9a717111f984f0719b405b6fe8a3ea66b181591baf4e6dd4187ee0555fddb0100484252ea8c8711728073c74dd47b45748edd9c0cb6ba028f79cab38d5c97d478745e73ee64b9a52c52ab1657a56c75cd312a9df548e5fb084b7db3585e0f0756415cae17b10c3060eb91889d66d84eb365c658c16d856991a33b2d26cae66a0e1367528297d40c93e77ec10425463c878289141df2661ad374005698e2544870302e0655a32f45007fa69cb3499964240c02658fe3735d4907a8cbfd17daa80e3afd991cad35748cd248ed4a973d3c74e716215833df7f4d130283269a48c9e662669c56e964be558c0d2d7bdddbd4734880e341acc2a2a2fc26f1bff619414ece0b6c247799d31bc6ad8cd7af42013d99eaf4cf7341580c909502559ebeed4463233df5606c6e8e169c3edf2a5410cbb0d13b5ebf02ddb823d7abf05e932e93dbee65c6aebef06db71442b8c1c4b0f1ac6098d32d017a05d3cdd837f7ffb335020fe2db8d0fd4073af82a3e40213b5421f9700fa50f747603a8e5fb7f82da1ed61cdf3d6a57bf1efe4e01f40ced79ba5426ce7ab5bd84aa783ff5623453afbf19028615c9610b09e4813b39bc662dde8d5f5f504cf7cf2b459a7f30c2ac81272904cd1ebe600ab92c0bd12b2883eb7164b4d505b2f27838b1d66398d9a10eeb9bd212736d555abae41bb441885f7a070a6ec6b68a951b37bc7f63eada6ffe696e460ced8d05e2bd6ec8a8186409e63b762c2f236e9e9c2b717e319d33a5c6c172d0e36b2baf0c677b868039bef68558d0ea381006215d09174a586def6f309a5d7d209f3ffe1685938043bcc2ca972ec7d4a1e418e706da36a1dbafdd4cbbc0b187b936af694f44962c38d8ffb3a8386dd50b44ac7dc2c7298cbf2219d94cd18019df32477eeb8f7b62dfe99f268b8616e7e7577db0c83b93f2771025280e86ecdd9ac94e940e99141778a53deeef584b99a7eda0e0def498a4bb9670fe149a97305e9c804055025720ca0821082141bec4589030148c093200d5ccd98e49409ce910b29b1821af64a1d473c42e17fa713576cb7a620ee32b3fdcfe3c3bb38c93090c77370547a5e330f368bcbe8d46e54918085506bd7c6ec03db423a7d60fe0db740796d211ecb51d640aaf1da43a753c7ba4d14666da9bdccee1b4379881776473bd994f762fcb4f211d0af5a3599f657408536ffafe15f666b3a4db544744e70f22fd63f446d3a375a77782aa2fae9c93db612bbf508e0212dc1025fd5b93f5865bdfb7fc48b7193399ce21dc97e1b3e839f39cb72d824337b1c926643e87ce835b1cff22dceb4a87874dc790df12b5bbd334f5a471b3ed70c9d44fc673156b727256c3ee0b961977936f068878fde313fb0e1e54bce3085ce62ab3cb4037bb3d57f51def027acc4c8ec5a2863d1fcededb5b38b2d94c322176edb135fbbc966f13fe2aa3e4eb4497df8684f75affc4765eb386969828de234775d3d9f203c60f81829f41cd66a1f1e523f53c702a5fe2e4d9ca33d022fd2bc09d2a517772cf978f3edb8b107ce37a00cd5fa31b67e7bc7a6a6fc1cf48fed7470b5d70d4c68fe4dde08dd4533bbfbc28bd725c3176663e1319e90792078e6b7b6672cf569f8bcd5603749053dec3b0c60ba9861f38cef523974018f38c52f7d7c3e2fae39151f5eedc5efc1b78916ff651cff13cce3da58b657774e2408ee20a74431bcd75ada8c51236e86e0c89f600d62fc1c0d81e6b983b8147fb5592c3401f0ec6a17be3969ba705785e6890c735dda9791b9d3115ebdbb77e13f13e5cd81345aed5d5d9a75ddf41ee8e17c48f9ef3c7e98c8ea57e24983283b868b6d44683ca8bc3bb347f4f6964887dbaf1aad183f2038ea4f6972ef2db371a470c8f40700ba284ed93dc75b7541c299694cdc976beab9b422a9b147a1cdeb716a26bead34ffaa7655379532637ce0aa6ef5905f9a5b229947a10c60d5efe6b51c0a5913cd40376036200da732f84f50952d1b507adbbfa489f58d49275e084cc165a62d3e3f7753a1dd2baab16536116cf8d9a73be3957498c471f407656b3e80a730a3ce280b2fe5f88242cf636e176dab073e0fae4e3e0eff8cc41b097b8225706a2ed68b355626c1c26f2f16bee2dd8f55080fdbfcab60d43d0a5683984e2d05eb88a773ec27d18bdaf3606f1d6eb9bfaf4ed973b40ce05236283cc90e50c98f0f94ce62675f0bef5d522441e03c0633a3e59aa681778b8c14672e7714886313a55ffd32dd99f9b9e7155d99a052b48b7441117581af151929d5c380ae0fa916596c716889514e6925ca2c2d739df4d4d8186d4daefef2d5add409eb980ff670166d286ffbcedff087ef85a2971f3bbf96ba315f9d50bac0c7fee089107e0cfa54abcfd8bd2092baff6ed93b621204b8edf9f3b39adde28cfca3bdcf40b2d06de1b1efe726a4d878171acd11f96c5f4d46ab9da20ec2040fc42a6d3d8ed1a7fe9821dedf2929e3c10f5590510699a2328a046d545c71d1b8aa9a953c046a8bca0115c3daf4707caaaede9c552515ecfb40e7690a7bcd10d70b435545248b87b957a74d8c4f1320c7bfdba0453ee320ad832b2a9b3d9da7215b584ad709469a89ad272663efb4b54c9b1ede8cd8977e7d9e3f581caac677e4189f441ea59f96bea003f8f7a5b22838e38786d7fab8b2a40c8ea29801637f7915ee6731535eee47acf4a88646274d3280edbb8e27706b9c92550e848662ec0daff0b1c5b274765223d376061f2328c817b6bc51c1115e809ed41e1edcd1e63c2c2a14dade148688a15b881ce83df9b4ab7d0149a3c8e2305f02fa4f8ef2e1b5492a8f97a0f82728a0c7bbf0cbfa8dcb4882658b950fda246fd78f77bbe7f1e626492f60ab6da1a02192bd4c814121cdf169af1247bcb0e4eb57280993ffad34213398eef69e547ce6a5fbb643fc658b618eabf3898b37d7a729168068c786049b9ababbbd4d964eb22adc3db0c78c514eb6360402687ac02ad42644b14d07da89f1d07f101f3a42ef5f5e02025ee41e4bbf0031ef283323d2257b3ef8eb6ab03c2eac79a2387126d5b9f4b1c8448131c169cbf3d9f814e5881991d6981750d7dbb5df57ed15da96d5b333a8a1f44d56b0b4325556c44f56111a95e193b7c713f21de7bf791cd82f09e0118b0d22132ff9a6ab406a27c82afc57678c33f41a36c019c952e4a8e0696a769bc0416667b7a839d7501864fa622639e645c764a1b9609f371cb2e18e59fbcbfe1f94b2c1dd66e62038a4188247a2d3d999fc99414b307c83d8121a80364597fb125187484e676fd793e69f9b9f93b480353b8335d7f7d8d3af8319e5ec694568e83799b2ffa553f2b8dd2ba1606a53bbab07a16b2d99431355320e81004f18c73d851504a19764c0fb9e00d860ef5ba38051f6cf9c5e3a9155b5e5fd240463cec544eeaa23f5a3b033faf9c05f2efe42f78ca17c3d63ee769c74b0dbcc8cbb10b199d4b250dcb15e1a6aa0f0772da15690f08097ef239b7492d8a1f698debb94e03cdb3c28369afa037149f8ef4bbba748bf3c47542a97cc6bee1f9182dc959e4a1d1f6cad492c8ea5a8509a0360984b01ccdd6650f8e56328c6b3ffc0c0da123e321fa79e017fd1ed75d84c446df576aa241e70dfaf73dcf8708e62bfb84ae18661daad9d9689e9c2aaf5c341b8a861072cd961f8024576615767c78f70bc63139d4f19f86e7adc0ec0c2339821441b74b9af4de5c1a93056140e5c3bac990e692a75b941b36a33404a069ef2a30db953041beed4c08f4da8046696574d7e16ec20792e87c885034ebc1c272bf7f70b5b3dbf0b6f4aec9b742f9ff569765300c9489192f01a9236798e51abeac7c5cc7aaccf4cfd142ccfdfb37ee800330ab03fe8e5df92b2c2ebf768a463040f8d234759f75f0f96b6555e161be384229cd65450961bcbc5f3ba0196283b1a2b7bc33312d396ef2466b515fdd3ae713bc7a5ea1a7b3f7e8657112109210fec788e5fd705799f8fa0b286c401ac754392d14e3eada14edf87ec881d5fc1e90e3b097a272a56001773c1b111003232aa31d44491e80d1424dc182998d79c3387b1d98e63fb804d8ac59a41b97261b2ca373ca784ab9186e9ac0cb6cffef6e283384d810e68afa646a1d528ded0da549e686940755a125b2f6488ef2a3a1d16628a31ba48a9d2788c519956598e695a983fc583011f136f64794719e7e11407e40d0c7362048550f8f2c49e4130373a2016ebda8eade3804f73c874fcd4d53a686ac7e2545c803340477034d120ef7b369b245221e924194d7f587bf62db6767f45df9613ff3363510db929f8aad83befc91e50335bb13dc8c3bc3baed84e10eed5e8d20c8d099ea33e7a79819e237ea46cb6c090cb120e8c62a59a9bafc45c69843d3f0e7cd6e22779455f2fef10f2a367abc72631e57084d20956a8217c0e0a97792105d830b85038883b0ed2d4886650afa0582e16b677c4267ba46bc3571ed7491a2ccb28621892af552c4425ad933d443e878ceaa7d1b70e16e0ddb0c78c10c63602d804ca208e3b348a987e44d36aae5f02c0a4a505ee5ca9d8c8bd5c631ba0ef37f4383aac774b6031d0fc0baac33b83e95b1854fdd261e0c45cf297ad9c931e4c04100a25b4289dc5959fd48ccbd4f426e0f8f7abbe16d32399f0a1c6325d3b6cda2ce53c73bb7f641542b0ef8bd7cbcb39c4c81831c987d7ab380b40e91813c83c561f098c6fcf7f0e97614476c763f0950a7448324e155e76d4c6f4b685583befd23575fb8684434e26c0edc04eedbfe6a8bf2e9a3b1307f29230005559742689b1aa1d6414d5b422e0c86332a9c5a857c6f1a8c5b911c85018d6b36ec6b5c83aa75f9a90c6c7c025e88d7081adceca07ab1613cb4611869e1d622f3b33d0a5d166fc4c3b4f7b42ec46b76c1e34305359f33268d43b3db5ff2800889d8f43b90380b22f19c07c7c38f199d859f41e470d4501c5e29c51dc9153b76964a2cf7c054d360e472260a363f5dc859ef68eddd7e9ec5c1cb127396a517be0b18370ee509558817a622035347efdb1935ea02cb9e654e1c1ecb08eafa78e2287c60c9f4a946be43f7d14adf8c303315983a86d7f4e4c1588a48064eb030cc05c2b66eaa3af6aa51b8f32e92f2e6b5fc55a2ead9fa72138e2c547cc18ab96ddf1794fd0bfe13306123fe54476b906d5423cd05f0dd72b90841afaa149861801cd2cfc0895d1bf2d0a2e65453a2d2ced8682e78e3d8a76255da354846227be9eb18a98b346ad7266fad0b70c9a1f7cca00484c79cbc383ae39c3c4aa1ea7992ae0e40b0c94718b95171c0c9c00273eaa24f81aa11a341e6210048bcaccb07b8c73b735ee8dbd0796706df803e2a5bb8b825991cc2dd4da543c110b6ddce16dcd2b81411f4f1a3b5f5dd1e5f7e8613e14dccdb32c215230d72a949b41e5eed74c1e2f330bc812cdb81211a5bc16b02d97a547bb3d5dc3b1521f1c308cc071144d6d6195c460c0080c54f561fdf70a5607f8a7090edab11e2dbdc60dad6d8ba940bd975438dbc1b6c0b595d1538ebae52b3860f569ea786b75cb7e4067754b2479d1ccbf9886dc2da6cfa6080d14efa3dd4a952d6fef83643ec807b383a9d65540e7f0252f8456e1095527ce440565152fdc2bae1bf1da201a4d2905021e33ac0692e300ce5acdc4cd316cf9296506fc0c3d1d9d1d0c9f936d9c0bbe7515309ce20411ef4ab77dfad988c38d96c74b1f0efab33fcabf7eba317c929b71704171e13a108714b4f45e09cc02406f961697747667d5db00adf870a115ad4366c96bd72bd009f6a1a194d205efe8adabda68d96a526d1d242856f28d6ba70b9fb7142f2a15ca1201ba572d6f61da6836c2071535accc9ffbbff37b71e5ee5e5edee8c941ec8482ce04f4c7fdafab9978fd0763d32888e9803641e18e78dafc0f89791dd08f4764140ddd6cf2855cd408c6dbbff117ecd2e82c05444805e57f703ac8222720321cbb4743efe56a76ccecfc226e4b287f75a0e58209f974a5da6a4e5d0eac8c74957dac09960ebb102b2b05ed6738adb4c24c14b24ecc2da436df960103bdc5d2d39e5d032fe162d205b7761cd49e966b83118f74bbf010cef8286790db3396ee24ade17720f2e2670b2083e1a069941b48de58a1872ab0116929b5bf1fcc9cbdfcb1d61f22a0634d91f48c056184f9c99a92d47c840469d32dca7c0bae9572c9d082604c761f0af30c1a45689de4dd4482653162324454e0d226407e1b8ec08d57ea9abe7eb3af3d5768c1967e091af01da1edb98c8ee581a6a2d3434328b5aecb9c66bff89b60d988ff9fbc9488e514e828fa6fcf1cf219f3d49ccf2805c09be8fe3a3da368f5319d4d16725733f812ee8b187621449b8a1ddacd7039d180022692aa95ada864c78994f97fc7220eb1ee1c762dc9e4910859c5d5fe7e133bab771740a063f9f71ac03d32c138b13d2872d569b58393b6cc5734201ca4a6820739df66ff041944444f4bee59ac051a33610f49f9ec1e857b61eea2ef39eb73425aaa73a69ff871be0d795f9efa9d52b7a8d40dd1cb2609f1e3b718c531f416de2d142ebede5edeedf53586e907aef3a54b333579c6b677ee1f6ea111aa616ac05d6892c9234c4f348de55abe4633f1ffd9fe1b55b59599d2f0eadef785cb0d419779b2e652d1ed6bdef3a9d57e2f4b98672ad88a3583a936e38580fc2dcd0ef8311f79ebf607c8d611d9554674dad6c27e3c05d8d318a1ce1f73188d9d327b10fce1a709c2368b6e1049d0bed51e2913dbc2de7d348a777449a5256cd1158d40ffbdbacd222073591f572df5f1ef1239254b17e50f0b7b0e88fef73a091f732733cc95d69d319241a70422e1a6525239ec872f0bf670b7337f5f785c8efad9636a666cc0046902eae8eb0e95d6e40f2c023d5a405726a77d1a7ad3ee9d6344ab4b48c2bd441c1b83410bcbf7da3a89fe3a26bdb079c9199a4067c9616c411af9cd97309b7122ef1e1fc7590268bda4837bff7b4e4d9a403b0cf78bd09ea63d5ae74df5954ea57d6d403cde7415d33cf365f921354f7243645b9de900480f177f983df3e6949b79668679552d1870c5968ab79bf751b1337c6eae8089ba8262367c4867d8ebcbfc3dc470f673408da133b67ea51bb93ea11abccd5f9e7735312454f604c2a692578ad619e8ba324dc5e849a3c8ab93c8466f0ff22caf67bb8b03f743af0e5830747c67be40c9c28ea584d52f69a869dc0dc14516a9a2b679244b5b70c1f186443f3257b6d146be78958decf68aa1b9d2de88bc908746c2d65a31a02dfa4ce02af64e38a295d83ecc49834e2f22df173c107213cd41f95e3e0453a6d536599b52f11941ef547b181e6136390ea8e8d4824321dac7fe143211af79e4903846767ee2f2d6a78433fb2af5ae29c8c930d2f16616d569d7824dbec08bb7108e9c621d364af3dd3f56bc7afaa03ecc232c0371532dc033fdda996a5d51069875623798dc94b4273ce6192e3a60bedbb3c0c7f2d487656edde1a2cad5a8ff7d34b27dfc579c8de7448bd2621ee1e47ac6d82d6b8eb90576477c209541c4f6067e7a0aafc1ac90035032d82dafe55f29264b4863ca5ccfd383357acc6b9a4c69792b4e14e30aa08f03854509e9040e5b1fc12e42ac6fa66c32324352195138f0880d86dd83d12b0852c75b5249b91bc339a5ed86f98330d064e11b449be44439a0529b556b76ad7c3405388971cbb083eeadd1b07b67c9fc660e852260e7c6bb686a2c095cd023a630a5bcf38a51cc86ac7920d3adbaf9c99a44b61033fb25e53366c67f1856aa6bd5c574c1b55f43f0df311df44b9e567a0350bc32fd8699f1ec5d2fc03600a2dce51917278f94f71e429fa273662ab5fc250af96b6854d99075458e225c1cc0d2fd5435e2126fca7aa6ba7ebf8e1a74f628ef71b98487bc11d4a3810492a14f09a113e6d191630d1eb4d44ba4d8380844e851e4881f208d21176c3d91509148958c6b5187b140afe3a8ce1380ad66c40f17b1b82a876c7d71cccf2b04b588de6fda296e84a71bad0c228d08ddd778a89bf075ed3326795343d7e0c046479c779d8013d217e559709f2d51a02024be9d861ef1bb072e973c62274c02aa6b6a49502537e90913c0e17c504fd6e6a586209b0452e6fb48ba97ff8cb162aade0f0d8542de017ad79d37979ca42e03c8ae5bc556faf2510661216cd6338e474481656d039c04d48eab98a09f7ab2c479718bbb6624236832defbe44cc122f5c36c1a178c1245b09c7bbe06ac468f18b085fd9fe21ab917d72c92f31e4a5be48bd2490750084eb4ed06a9a9d07ec6bcb4e34a903f013e7f429f25f71451659edd2f975ad0de32e05ae3364bc0979a6aafcba2692a36c79ea44041ec40d0059d5cf73466e174610de40335c9ad48167a0f7512d97a2b6cb335ee992d83b639c01d9a8fb01a9cb9598629172829f8989f70a365bddbb97d44aa990c5947a9ac07e671eefe3c8682017850d75f460afda209e387084ad8e11ed5cac5ec3eea25bd24443ae1869b030d6f41a6ff573048a19f45c463c7d122ec16bd7e32631af79e16359464da9380e800373dd4e5e844a5634bfa129e015663540ddfd8b4da3c5b9ca7f01131e151dba39a208cc56adad9cc70182205ceb56b9046ace1e2d6a244d548cfac5aece3a0077990b9915d3778b7f2441380f9509fcd89f0af3dfe54d44d05a31198716265637d75b4c5088be49930b08333469253f64dc15ccb9b995e15433d0087eb869b9e8d4dedd2bde5d1bb4eecea9b20c740f8c190f076dfafea718a3667afd9d8d9e2b2ce668ff6d346685a307d44584684982ba84cc3e8a213e005922b7777c50d8d3720fcc5649d9219d065e98d212ed5e989d10f96a7aa5921a5ca3f362c30c89d805e81f96922686377e4bcc5435b82ca75f3587758440af27687a408a0b6a15625424a9ed21c1ef58c7162d7a703bf5e36c061111adfee4c099351537b5d2a355cf4be00cb17832a03893de4543931d1f6d3ebcef84ef61f5f609ff7fb9f85d2793a787df83604b88b2ff7c6ad2f6598abd4d39596271b930005e23f602d042e4fdfbcef9174fe0c2b061f35472db3e97f10ab09a1f4dc3565231b48d39e51e002e5cd644a08e18db7a3be901b6f52571dfea13e6c7cfe179b52f8ef6423e3919905bd5e04daf08827c9bd13f6e1488cd0a04cfcd850443d5389c4ba251a3c06365e48cdc1ea5c2af27d262eab393745d1592c211b8dac952a930c3a2e24707537033da6f8d6c2e8fb07f3b0b0e6caf8aea09c8a105a8b99c2575ad3a1a4d7667e7344c1e6bc1d247c65f8e9770fe0c7a9951b645167c9cd1604abce2fcfb9b30dc15cd9993d5ece2203dc7a0a8666ce3dfe87c2ac8a6fa67a684e012f0a9bcc5ff25cb334f4fa9a76ad3514ff5114664557a32bc55643851f21ef644b0992d4f28e533b3ca43f8758cb88ea7f989d96dd91b965ef639ba60f14b892ab6de99bfba5c437dee44a6b5c485be7cc82d4a8ca08bb0de5c7987122a566589bc661e62792fdfc168c0fcbdacee2add9789f2e5ebc0ae92d0a235ecc7873ce1b40bcd74d1c3b6d5598aa0ed5b5f5007e293e395f2c2921a6e7f446a836155e4cafd075b2f3cfc60ea07893ef8eb40b9d59309b0601e3df57c2909340ce8089e9ed2325deffa7b310cab43ece4e4d0d27c773c10075228ab59e7f8182965abd0dcb6b652050b2d365e7b1d05f649b19ce7b62f47ff95a31d052ad4ee397b2cca64e292c6cb37dacb1aeb0f547ef44c998b4b1d7980441e01b7446e164fc643aee74afe9a6c5a8e69a0a34f1829750167641f1749da69f44809109a2a4c5d0312929049f38f9929fb7191ad69eb2da3e357757973d86362bc6c9511a347ce88106bce57e35c4dfe9a33d5d76a1a6d7cb74766356456b7a15a66b7d2e483647cb594768c48402704e09206985cd644a3e61a51bdf1c1f451a55910932e37e1d11e7e3d60929d96a29f93c7c382870d29deaf4666f9c6498becb1dca7a0f03a63998377b82d587aead568928700b483b71483f53a2543c1eed3b9b4bafaf2d45e10ff99da3943aa77ee5c2e1a84a6f0578654ed576171308d00096ab25c93f244ba3104662f94298bcb6a7fc1bbd7f3bcac219b574146ef64bcf0cd1feac4b74bc276102781f62ca04eb2c6d085012e0d06a2c2412ab1be32698f304d73b0a533c64920d8b33530b65e16fce14b4d615f1bfb236fab226c9c90b9448490db19bfe5d529963885ff0938a175e112d72c6c4327cef3f44702cdd7f83ba63ddea8565b001d6a23fe51eef3471f828f5568faed064ab3e2390c86882b5a6ee8782f0ec6c37d98acf968e5bd613da46c36bbcf9f9f0707590a19c28a509b27a8bfbdfb730032a64bbba14471ebea2c398a506612b785922597ee76139034cee2ff3e74a4d1eeb471cdd7f43068bad806a26c8d86412362793c7823e1e500fc4495399b0011a6988eb76f3be8047a849951eb253ab9bc2767db88e5cad1100b1fe331b68968198a2e033211de0c804009f95c409a4e13210a30cf12d725bae62b6f6ca513b8e7d9ca8eb0cb9b646bb178847fbd01b44b4fe1e6b15b0ab7c2962874d5fdf70a455f03d2e4454163e89b20e6a1d8033870e1e177cc6d856457c3624dd76227bf6b5d4f0c2243dadbc11235dd58a95a272903af1ee6671b636d8f47e90bc36d5c6e070d9067e7d81d504f566d040c3f193aee5b48195fc5910ecc4926d1ebb121c2d451d3e99a2386a69104bb5c15171ddad5caf8e09d7a051b33c1db342cc4ec3d81e59ff6f19983a44ca609a48d86a053d635ea49fd90b0bbe55be786c28205cbdaee73e6ed957f8e93b8f2a9209555609d3346a1b044750221bf76b3d1c10504ab8aabb28c0aeb89fbacce4dbc40afc27e0b3b9e86a3913cbcc9bdd343045e0ce24e72c6f52b6852683fd9a61533e5994c107ca65a0d81d4ee5322c0f7168e4c2b32eba8a7fd783eec9ef68d7f20950595988bf1f857bbd3e184aca1ee2e7f5f71fd30a1075e59ef1103345a8835806dfc6a8a246dd79b7551c26a9b16a7628dc65ea8c930abfc7a7cf04f1e475664e1373cfe6ca0396d4c750d114081f22d33d7981eb536e60ed2d3ea5fa72cd046c5fb110fddfb14466f0d8c35b2658eb69742505e7d1d4161f1d4c1b9af6e373fc984baa35f81392bbfb56c201ae31e2b6fe2a22680802d51d9ef98e7ea830eefa07667879bc93921d4bf4f117fe0d328d1586ad150b58685eaaf61e704a2fc6ec854d19ac27a9d236d88a1fc310c23255187c88a5e2f7684a02098fa671d68a592e2096466c5b87191efc3163193123feeaaac57b4fbb7d78352b01f5ddf29563946a45c325c74c70e2af45167619af91d10088f0699695decdea4b41d43be14e0b0fc95c150e122d56dcb90ced5efa1ec926bcb5eb55287c855f215bf7dd0159a7cfffab8b8f897ecef49764928f3792c5e100c8a3fa3044361276a2b987f57624a509b2a119c12a678d25791101d182af43f1d44749055116496fd0ad78598cfd78bb185d0a5b02fa302f3559a5f952b9ca6e639da088792470e04ce9d76c431d94f0633b7c9893c3a72e01289b8a7573e60cec814bd2e2a553eb1728a9f629cc9324f93f7e440a11a39a437bf3ed1ed4ae684904cdc4fa3546e583adcd55d48a8d0ad228e4eca534dfa0cfe35dddc7b817f9a01d9da79ea45cc49915a2935d6226b7e0b99417c55e29c070eca6c394f3994026fdffe5382a05ef7e348dfa260c790b9549d5ee560c7a83c1ef7f413a46885df2a15f14d81d83d4fa51c709d5ddd62a34b6a8d531e04c48920e525e98875cf188e8c800876a3186d081472c3e3c5180eb3f8b1dfe1b2bd18f271262211601f7b0a7ed0620c5dfdfcb981ba7a33b8b10af6995bf36b19889b9938a460659e2454ab63e1e0d423ad0d984d4d3c0874aba21623d301d12f606fc3296c427dd4aa1bd6dce71c0f8b31b1c2be774382b8db3f518ffa883b97da0dadd6dfee0a647ffaf1e89515ca8a6adeee729e35a3a3b43cbd4826397b4b7b627e41ca18eede322eada538090e4b924104dfa67909d1a4d4941ac4448d911e21c6068c8d094fe3359bc8a26ed66962bf618c6c93f9177d5f93527789b89ba3d68a9e1b467d3616e26af40dcf7e8e71e6fd1b88aa1340ebea1c0e8ed4400f13904be8e90cb4af01bb7be6b8843da9f878948cd705f2db20ff131ed1cfa4695d6352b78a2d9bee47e45f19a30cbfeeb561853cbb0ccd307a5c95c9824001f9e74ca4cbe5ea9448f3ad32cba1087603c3627ec1c11ce2d2a8692240d650735dd67199fcf92bfac80b38d535d4c40063632bb63ce185a3c5aa992b7a28b761f0683010d3a3c058a07d8dfcdf7e9714c9c639cfb4de8a8ee7bf4efff8c5fa8ded4d8d5bf9e00efe6edc2ffc87b886a071b6e65465192361c76ef37897f7eeb2d13fc3ed6fb02bf2b9b7dc973d4a5239cef90bf5e60fbf5d6fe601963d3d39fc92451d5fccfe61d8873bb2ec8e386d2752f7d3d64f3f01b90f6a8b13ec9fdef7842f7d7efeabb2e6dc7a2279860fb434b71fb32eb73f0f199ed35e4832a03f1409b38eb0b76df9f885aa7d741f777b24feac604b4dee56aa9412461c5784182c78129ade4459596463f7f53eac7e8eb8b15c2747a3dd1a848c6a5ce7974a54d6ded7b739ada83925ab0a1c7cf2cd2a1871513c77fc80f8ac1c8b12ee425bbbeaad522e8670902a42a597f04db17ce3394e0a1423ec869dc9de9f790da539d84cdf51c4b98c5803a02c6141d1b42c2fd896e4cdc9b9fc2854f5d67da69304f70bc3c4dbafa5354a0b896c60de031a0fceb8d8c1c2bebb7ebf1feb0d549dcaac1ed75ab7e4e6ca0842ba63a95fb17ec222dc836f37171981b6b15f6680a67bbead684b46ab654d35843f036b0a51c24a73d0ad34104b473c59cd7f6083cf94079024b5f18d50b9515dcfb63b4440189659718bd1e288348ecc7df7d80a9e8f65a8611049fd9d8ce67e831283a524fa8893c9d0d907c05fb8ea777c015a1b707008dc17fd1c2646fe9e85df960eb1e8c00e6dec6603ad15190860e1f1cf1f61a332f2df442b7a48e59fb5914ac307fcccd938ab4eceafd708bf0fde6d8017ac1d2e00cdc3c240978173f357d0f80847edc43d1498c1368e8251fe4ad885606a0078415e17dd3dd3ffd23d1385c5a02fea1688941bd1dd7e547001ae785bed2b7d02b117b4b665ce3306a37af2017009b41e56ea7b23e8a7c0f8ec0766a690f0d8dfb105156ef8042413af70ae21d1e75bbc6cf8df1017a144d736241c745774935344ee98b7c964c2e522ef4d2f71f7560704a505b14fb90e5b1fabe63b43a17c3c242dd49c46135d9cc8e1e118d401b64410fdb89d04b851870846e68db8351733ae52d52bac06fdb52efc13c8ff37187a755dabfc3018f6efc4fa1fd06aaf544f0f2333083af3dc6f335a957824187d3988ba57e605e43f68deca71724add64be8cfb852099ef7382343ffc9fd367e881f3b0aaf60f7c4d7d5c7b38f687be5027a7d675b827e4aab8856986bf77858fb039a83dc9cc4b10d281a01b026aa81cfd5ba674039c9cc6301ea3a7f32a4f28bfb059bc530d5ffaf4192a0a9eb0fd1137380a195ee1f3ffe308843862a6bf97e4a071f00791d7e7ad63f83ec2b22e3ddf41437fe96f1f32068481d3108e6b47849641eb7dc8e969a596fa374e1919517129d9d0d6d78056508c39e0df6b9eeb2982c2d98033193aeea3ebb47d7ca0663caddb4dcbd63fa8f6fe4e64427bf2ffdafdf4b89bc2625f4e9fb31e01e894321a337e3cd977aa1dc8fc5fe3fba2d504dff188d77e898ab92cf566377ff837fb106b8bf986c903053ec44f263acd65661423d30c33821061f32e594110ff80588f33315b06f6bb1893c25fc0a031cd0cbd3370f532c5572e06dd70ce7f3e9a1f0595c6ec10f5de3b2de433dd9c99e5cf1c6ee3762f30dca011f14be2629f56322724fb5f885e3785914a1bcbd017bef734471916ea0fc99cf8fe21fd6120ba7fcc1466ed1d7d570ae0e4e5dbc7602331de15d9ecdc821d65d79da065a8744cd47f37eec88287f9a1f3e8db1fcc7c88913afafdc66298b6f126fd1bee2fc3b0735baaaba2a324d607ba179b396e830e238d8d884e8d7bc018e1d731170dd447bca53a2b5a7bbaa8fbcee62bfaac97eaa96156d67395cd5140e54c2d2a2af27a7e2441758528d65e5ec7de319fcdab11ed2500de72962e81ea3d297683045dfcd54856393162bd9fd2a25313003e10d822011f3d30df0994a752c692c6233f60b2c8b3c0529bfcc878685bdfd1aeb6028971a0b16b86dfd40f6f34943cb19d1230e2ee8be4b346748377b4dab8de3a2456c22e06e0c0c72a54207fb0896fd02538d305e53d20b0ec8b7c8d506cfbace3c43a778f9e60b076ee3f6769cb070ddb077bce84044b24d69a8bdfd91738f48b62d1cdac43f20f7f56ec55794515eed0367dbac7d45f2afb47c04491455d41c5be1b78c410bdf11d4ad2a53b4c854f9b111babb072697727aa0ce0fb907f1d500f8436b57fae4511fb63eb9f84bb327cbdc939476cc577c11e6b4fb6c02f5c122e541003e2feef34b763424b3f66b9600dccd931e38d2475b0edb929f1288515b644abc3327e2136944d835814498caf7553c3f724d4c102922a772db3536562766d0b06b8453ad78d139d426ea5f882d11d24bdd728e1432ed77c77f3fd55b740c29187dd6f2a12d94a1a9f096f5cdbd00d754f24a23efa621338ff70c9aca84e4c8673e6c20c630d3e315c223fdf15ec03d1968a67b7593d1fd6676c5b586a40352270eef173badbc307a6be314255c84414134650469a960f0978dd09b711ad5d1dfedadfe916503e9c7d2b31b170012a7192916e54d541ac5ca57a4571c5aecdb0894084d0b95fd4673c630f7b5d55681174526928b8a9159fecd90c6d8e50c5f2285c1a10de52e5a3b8d273e075bdf8eeaceb75da6ad8120a90e252d9880271d9b61469d08c8fa02b4ce64a3379c1bbfe1fba817488ae9373e425e0f1974a9147efa9ead2d4105662eda3737edea4c9a63d17a8e567aac50897a0ecd72906c28dfc2e41a5df5dd61c17d7f6a60604fad402c8cab492d26f551585c095ce39c17e0fc598a3140f34aaeb6e486b2ac5d458a2f1cd1c54b503d34623dee4b93c9dc02fcfbab72f621cb0e90256ad537da4a4afdb38ef218922723d1551b8bd581027ac79c5578695975b096d0200d48b0ff1aa6548badd57fadbc6b60648a4f8f4ac2699d98343e7dd3d0632c2a0cf7a6b3813a0e21e8eccab9cda6a91dc71c3c42f3c2f564d9a998b107b93211ba01ef7abe7bd8e991bb15daa16745427db628ce4cb393599bde748c1731260609985c0e1b3dfa512a42f051a7510dc3e26a387ecdf236569ea6cb1b469a72336489fa5e9576c3d93fbb9d7e4b44216865aa75afd9c27c3fa497910acb90d1e36d3e958fad04fc2a4f33e25148ae183579c210fa8bed9aed5661943f52dbb362e25b036aee90ea2a23918228e466e645d878670c81e4b1f2669c1cacb0585afb9db3b64b7ca2f948a48d8204fbfdb2994e1e87a7d2a8a7bc49e553f844b86cefb2a414972f2a95b6b7dd650b18298de4122a258414464a5df39e162e4cd4d4de5aa5340605813ebe403367d7f157a93793f595f53aca8e2a4d7ee4074012a02cb5323a417d8eeb494eb0cc17033de1d08d65c4a4f9ddde4cbf28698699cc94163a910f1de124935da8a45019f05898fd4fc183863573b1f0d67572e29f8b97d6f2472f8b711b7cf173ad7f50d3a810e506a2ff93e270281a5ef40dde744ca6ca4b71e811c76d801457935455bdcd5f855c3d29d2a7d3b9d78b5c48b88df16362af28d795643c440b4be67229f7ba80c4bb4881cd168195b3a196bf2e5531c60d60dc6793fcf3866d691cf8cae131be330ac3c01830c027ccb88d1527d6425fc37f48b27e8afc958e277c4113910103c7d274b61f22b4a04f7b0c975385979fb794c20dc9b2ca5f8cd90be81aafc8448fe77ab128f429740b51918408ce4b4f3c05423e52a0347bf44ef670812a7a9c1a9bb93ad9854f1a5af49d0bff294229004042f513808a35fdc15d07533ec9f551ab32623d2dbfbe12029110a141e179e4d2efbbbd6e4212fa114b78ee6ad47d68534d195204d625040354bcfc573e98073d8bdf549a6d3485c382716bcfe1ac369898258ab299ab2c1d1ec2f3d79482903038841b46663e68ca4d6a4789f0ba25598530bdafd0783c2bbcff336a54a995f8f67d092546acc1150fcdc49b036bda364c1042cd0a88a19b9aa890001178a8b63edc7b773707e26ffca4bebd34c8cde6362a4afdf31eefb46bd79db3f49ade0b7a5a9e134ec2c5d0104d3848607b04818f2d42c7f07749c4d571d550c5023442af41bbb78512eab19f8f7674a126fd20467509033cd228564d178596f90d0c55260a20e153a6f5c6da7e1cdcdbc5a192200bfb1715311b7ce8f379c802673459710d3d2682b1ace45be05d605fed6552f7f77a6de7f6eeab7da6e7ce8f78a69d67a3fc478bfe9d7fece3df9f8a13e95e0cd73cbd49b3e371230cde67bf52a34799f978baf0b5ab12e5ffe67c2f027a8cb8d59e610e749a61eafd76f165cfc1649ef71f48647b7061e1669de833b89d8b5cf95e3384ec121a1b741b13b7430ed13e5307ac34fa1fdde82ed4f34bb3164292f40a57dba8d8a34fb76816e746a2c1b85197dc3081273fa7d23c6d296ab2218b76353f59388064cca506d4d95e486ebadab684e182f53a84d851e0facac28a7863c485c039e862ef22a152e74c17b250a9a10db26196755c0938a193ffbcc80e62d93468ea1998481dc5062a3d89ec69a2ebd7e3cc9d739145bad5a421896eb7db228eba4d5869885a212a382dec9184fb2bb12f43d4a175414e6eaf22f5c77ddb3488e539a920284462ead356142bcf3041cddcbeb22cf6a8f9c5261f769f22b5cee8f77b3a0580b44a8f0a72ffdf1251abc5ed4926ffc98851e150de81ff441238c21a8bae46611d933c3fbb94fc198502fc0d639b45bb04137fee531b1cf9ea4898b52fe3ac9f0ef9004831cd34490ba5b957070f302c8fcb117076f67ae27d846de2ebf9bd1ac7aba319d39f3b362c774a666225f58652f7dbede7de62e5d5d0858dbd5c90be6aa5dda51889584019af8a9ffdf3023f686ce85acf977a6e2cae426bfbc516c432f6cfe1bcaae638808e992e1bb47b3fcab9b00c75a8173c74f589730f38f4d6087b5440f413f12ca5612e095125ac4b300e424008c16f6fe99898d129bf596bd25b17060ffb061b3b00d5c43454bb21f063c7b03d062cbcd6be4ea4a86b8deab28c7bfeb87be73c8a8959890216864a6e34a58ee9ce02d5999ffc9decef9cfffefba7afaf3d92b490efd4a83c3483591a2748b66228cbdd1e7420fd46f1d26b0d8dbd83601e15a5d76087b89fddd684d211da4fc42a611ddac22dcb3cf6d6fea51dfc20f0cd3c3eba248ea9967fd84c248ef6b434b16e0b50447329e1ed4ad799b1a0e1e89dd434cecae57d6949670520c67c9398ec2220a77efa2e1893420bfd9afb9d50b2d8e5173236941285a45670292538054ee4fdc9effbad56206d54a78ff9d12916ea0f1a44f8169e209a0a3ee0fa71fa1153ab5ac683770a1d48e59da4ff59a8feb9c364f7a99d25aa57cbfa45b76a010cede3ec6219965f0550bc1443f8c6010a8298339343a0da30712d740cbc81d24fd937674451a1993bbd75aea251f0b43e76a4333aff96ac2b34df28ec2a9fcba1d5a87884ee61645558b3074812f4f53b0884ec568f5d8517cd01cade1e903f784c6e78869bce9e2093253f6407452ec3ecd9657efd68191d648124c2392f0597022c91ff866a946a2a1fe2cf37d61b99ec177a85efc6cda315b1b3050bd70186123a8d1695e5d927ac39733d84024910da51c09a72aaf082471980db826fa885d6aafad98aa269a65cab6b0b2f992940c0fc6fc1fb6ba1e1d79ca2bb15c0580bff044d6076722dcf7f8cf5fba79411e6319ac2686fa8d19298074af70b8bf8a241076ce88b093cdc27699b66127a3031be25b6d82f0543a5006033d02d5678a3870635f651351448ad649e90092cbbca12fa80262b42a9c2903454e30d56a1aa586d20f2494347a5738cbb5aecca0d6b226a7be8a595337738b70ffbf523f47c815732b0c02682e417c3bd3f3d5984cc04daee30c98b5d497234c12f598c79040054874b3ea8e01d91b50080a498c2025cb49d590dd207a6ccc7fe26321814095f28518458d7016925b4b39413882ea1fb1b2580e58fa7e69bd549e1b0a1648440ede71cca2d68f0fba44283f498c3c5acbbd885a187888050677f87728a62493270134ee7ab158ea1da10e82f243908e25e8908885a2746b8e448d3a02c9c3d0026f36780c81cf052efd83b1c9ffff815fad11688a308ce38e52c632eb9e4cb59c26e22e8a01d8cba3148c1f7af3ba17597cd95a3c9b78865fdff3ad553d340782be52f929d83f6f4d6044ae82731e51ddc9ef43bab1e4ae9a22bdae4e98c7bd3de47efaf2dfb54719408e404da99e5c834b5f3b8183fa553fefccb5f2bfaca3a4e5338a7810b4fc1d0f97a13403c7599a607bc7bd121beb627c83fd37283487df756ea7d38b8db9fe57ba7f9ebcc6cab3ecc7d70127a0f0e80a111b4309ee7a6118085cd548e8b797bfe2c4570a9ebdbfc2c44cc8852f45d3f7a7e6778b553f42a24c6c299b5fd959a111cb9c97b73c23a13dd7e22b980c645e40cdbe23d0ed56dbc18b95d03ae0e698162182c9f6ba881a4849681c3ada9fb6c906e7eecfa39e3d43780852e42121622f84235255fb3f7db690db4c3d1fb8d86e8b8c4eed38e05864fac37d926c0a29c4aaee6f316e37bdedaf8eb1fd3d957b9d0a24197a3539bc9bc76bb314bcff9e84db94bfded0c195e28254e6042e6a563e8bd12793134a919d48d012fce325c9ba590aaef758e70bd43757a60dc65a6a9138987008bc14718be687ba42bdb10654a00bc4a644f65e00a61238e892a70ee5d56d89b1345789a6f7e5000c82e5f9763385e62e1cb0864e1a2e89a7be3073adf92c4e8854a1b336c8c5414a768f3ab4a9eba29eeaefc1f221ef954297e597ba3615d3e3792a332ac892a0899fb259039fba984484cd435c1d8bb01d4bd3e63581dc277440eb28be7f1966315312ed1500e9b07a39ba5e6ad63ffc146f1fcda7aecb8645d2a29a7a4128243041bc1bef1618de2f9746160f47c28f6852e466e2558ec0f27607e9ace220347b6ee85d443c8865c1c782c88f2cee8556f6d37b7a1de249d3a3c52ad60b4c7fc83fb3124a6c7da2a1ecc2e9a1f0a17a5568287e0404c60c9b108cb381325606fc88043352579b5e3c11e84478e8ee72d9cd989e4ff6e3aa1234f7d01b6cdc03fc7c7e1ce17bee16878301c8d2de0f64de9bedddfa953e85570aabc00df6c5e8844c4ae92b82b2001c16a60d582f960e73514e19a1d7d97fb1cc82ebeb0acac2c1960c8144a571076c28caaed6cbf89f803a96254ee3588fb6c5169025046de87a04460be98b2f22da176a460464229239549091ff904654dac96fee466eccb16247b4bf75b0e4fd1feac1a67548d055705e75f82921562f76c5d3fe9823c76702c33a8b0dde91b4e9de9541882b6dccb1d4bc1fc8bca7d7bbf5e930f94caca5a7d455be1ff3a05b3d3b61d6c5736b9ee8451623d443bf977f558f425bd6b9ffd58cabef15e5f6e491df483d4e1fa493d5415ddfe79e1de7b0a0030038ce77a30822d93ff8605625319f6d363f81d237836a2ea2eef526c53c92d7a43100f0184195fe42e0636c0d9e7dcba9f69d905094cf23510a63003a30d874f7aa670566d89ecfadfd4622987d5e4ba5223828cbb662ec7c2fbc881f427c354261d028688879378dd18a404fd82784e63b983968f3a8af2d76ac10c66f8c8cf336bcb4292ae1bcf565d0ac5760f324bf0a78084515c034b32c8d71fa53f670d0cd479c43f16aabce9febb19edab9b60eed8de41cd5989a2ffbb5bbf1e32936f805e0e3845abeadb68c05ab6b8205c860b73f76572c45da3cccf247d89249ba60d3c72cde0ab3ff9ee1b025b3948adbc6e02179905eb6365be80ee3954ef3a69bdebee464ad0f1a49584dbc88c496ce703b18436259bee9eeba3596a13ffbdc222103788ab1d322749016a8879f4840f52841f018f87f09efa5dcecd0e34932d73fb92ba4b9580261d82c63eca0c56b0f1a6d25d01b70f661fc0f7d7ddc84f14d0addddb46d8cda3aaf5c2a47152135280cdc9bc45dcaccd52714e209f848bf84d1a43c37b8fdf9f834334f65e4ffd1f6f18bd3a0479d008bd179c9ef18c8baca0a2dd1e4d79d85858304dd3b61aa7d5a69b3910780cb355f8d01f33e13f4335a95a21a6729857bf1b2397d9e2ad270739354cf8c06a3137d6fb74b872ec25ed45534881cd5818e044ebf5b540210913abd90a0b29c28b69d1856f01e01eaea889ac3f67e058ea8d83d5395e3ca98a89da33eec58ef9ae016956c3c913a647632e87bc54810966d85442c0050325cc681b9122a2fc5b842860491fec9eb277a0dd3ad7958d2ecf91bca76bc0374bea8a1caef412040258e846f2ae86aae6edf2c96c7f6df29b9bbf1fe39249cc791304b4b8a886adcf68af96bf853c6df5a1c3d48289ea36041113896880178dcfaf39f10422de08a79af3272a95621dbe26231e5e5e9101d632291231d127fcc4481f6238640038bd525ba5dc0e18b57661569bee11712711cd0bc4a70394f55207e7464c7caad5888e680baffcb2810c7d1e95314e322b2dea7e024132565c788b293162ed4b586cf327b7c1f3684161d21186f0e3b87f160517884e9f2c9340a8f485ffef92129024c15cfc82226102e74560bd567fe2559b679526acf95f6b8a75a0601b81a91dc6382f59f912bb40211609d5d8cc201b177e7695dd2a8b5bc5fa7c19cd92c024107dce6a004d031f217d68d86fe4685c850abc2fd0f34a6b6bcc654317b0b125be78b863494ddbf6519b245f927a4673869f7213c1458717c6fda6b884862e74b6523de7af15634197513fa2b4706da848ab6bf8280de1fcf7dca7d7b127075bea38de190a33d7812ad6bb09f05dd500f75fa9a1d3eb76a31262f690d359d82e437d4b752c4c904872144c847f0c7cec02ceef18bbcffea4f7b79a966c6b566bd0d5278d48ba69a2e8e286422d8df8647a78755e743e06bbc19cec962033237b3134de52fbdb470be8c6f2de7fbcb0619fd679b4cffd9c6f830bf0f2fbe19fbedf0d8f9ce85187fe26d90b3af33de3c6b7d269c1a6b474088596834cedd819c29566442d925481809a5c6b4177062179634d4c22ae52cf659f28ce0b52d79ead2b242e74c2d7e4e30ed7839639a4222cd41b90e166592ca0659449e6a6634cdd459b24487757dd2c21c77f6df3ec3bf3ec2e2d387b0f9f7115e3e834e4b58fb3143e564a689acb3926e42062ad3d4a4e6b0a455dd81427059aeb8977ce9f16e3f1b51cca924d96924abacd385d081cc1435d724ac695957a0094ad3d1b2ab3ee3d0bace40117453a2998db18a357bca834bb394230b9b63192b760725a0399956ba348d452cd889640fe592d9a7794a91810db18c25bb831c109c4c539ac94ad6e92454a033859a6b0c2b5ad725d004d954b4540293ccf7109555739550b61be7fe4f4eba0919a84c53939ac3925675070a4137194d6c8e9558b333a880e69434a791acb24e17424750e3bc1aae00be0f86ccf0699a5264b349ac63c9ba5aa0074dcd764f39ded9f7248184fbc73575917b750977d619b7d44d6eaa8722a0a8ad3148bbdcdf5cafebdcab4bb8b3ceb8a56e7253dde1ca2a742c21ee650c6ecc1c6e9299b89629b83393887f64ade69b7fd83bc9e214912771c7ffc63f1eafe0086b5bc28f082e5ec50dff10d7e8bc8fdbfd092eb178074f585b126e05b0b615f7fe437ca3f33aeefb27e147a3e5a5f873c6c4fbb8ed5ff089897770cb7fe10743dee166c6ecd51490eddb390e4ace73c4fc1f6b8b8cf9827d49277cf18a93cdd959fde0010f925ded112bd606cf3044294d4948489649e5bb3486bd5ab11fa6877828302ed88ef0f3ea1012a9c89bf504ec3ac41e20554768931d9f4d430457f5ee328c897c4a044650281a3c60d1a0effd447f59460569a605c6fde96aa58ba462391e6281c55872fa8c1e5ea89deb10c3b21e8a41a09d52a1cb95c9bbc2b30fef0a0cde320669cee13566186bed2ec1385ac7208d6cdfebe27d0fee09dfa9e73bd6594a84a343f41b6369736d6285a7da9cb5c97bd1a77b56ddfeea0293658c6a7ab8a822d0d928237b5376fcb37fbec6101e2be50f2ce0dc4e9a390a62ec6793e8a3ddb5a52f6a04e5a24611d3526c86af495d23553a16564e4c47e0896825eff448b00616d7d47323d4cd928b92ca942754a2e3fa3e0025dc855e2cf29b51aba72f549d44c1f737bb9c2c5594a073c1673a9dc41777b3bea2e5b7e01f8cffc4dc2344dd65b5ee655a95a741f750c53c74b722e582528b03d3637f78f320a84c0eea6dfabc1b095776570d3546aa9f695138ee05aaac3ef8427320ea2d225e279fd407b68ba4e017de3b4957a877b1080c2f051a1c6ba5551048cb481dc419bc348900023f1a70d2ce4fdf84b8eb9df6510e60c22b079c4043120119812f49dc52926d915c2b2169114b646ed29e0609211eccead0076a416c002b2fa01770a7fa0615ac3aaa63748516f17f0adb09130a980a3838aeca18bc5dd77954a53e9a51be0a3df0aebace697fbfda8fe68b65ccbacddefdcf601da65de797beb5423e9a2f5d12d2757eed2c530fbcf9ffcc5b2bd4986cf0458d243576d4f8d11da57ddc9ae961c6872e70edd264ac65ecb3df0c2b8d308d6fbcb75b9155cc26b355893443a58b31a7f3a75599fb99e50db65579976c55da23a4afb6a85a6aab12098d1b62d2194d74b7b3a60b86c12a366798babdd9ea9756b42a9192eec3eeed06fbf0bdddcca042c50c0194e18332c69421a68c31baa3cfac4b57e1f06dfed9ec3ebf024ae424d10f61cf6bcd6a7f6cd17b20d2acf6a7525b43a544d622fdb5b224a5f740a42246943c8c2fd1bf50cefdbf507873ad94087bb652229c2dcad67befa3f7655f53de2532fb2db942352c3dfae3ca9268a88665139c9344951261fc9277c9d1e37fa1cfe10fbd4747f86d32fac2e13b9917dba39cfba29cfba2f09de0fc4993626c33d89add274a193fce0edd3fb22f2cef926cbd24fc7368ca6f72add03c4ac2e13bc9b92fc24119cb218cbf7e964393063d96b5a30c1acdbfd1bf59223bab2e9b4c5e5aa593ca3e4868565d299b31a234be343dc2bcd336627889a1274615e3bb6f6ee8cdf5fde6c669955aa14fe9055e3aea2cc16c86e52c4d01d304992e3bc4a0bd048004448aa040aed140fb73fbecca9f245bf993e623e54fba7d76c5f09dc4f06dd70a11a28ab7cfb7cfaed8c2dfbf13bf471eebf44be7579cc5940747acb2455569be4d6687f287def7dd3ebb3c9974abfc921e83eefaa4ee3d5ca64386b8cfac0bc98f85e0a77456892b4539ee1ebcb9f3786d4c4d95272b8d6294b31c83f2e806e247aad62659fb82b1f0537ce34cdaa4200d13001105036cd077809d04e80691d66b2608d513021d700446741b33ad0292259e4075d37ce145172a480117345b74d3a0a09b468b6e9a2c684e1047b5b30faa61d9048661f6fe1518be478ac49c556cce07fae8eba32fdc17b93efa8a2f843ffa8a1fcd9686b3f3a3af88ef7f1fcdbef4b42693f53f2b3f5ca9a4b53cca2c27bef199f7387bb1f7bf5dcad670ae4275f39344f8a32fffe86b562a44530023badba34cb24799cc479af4e768d21f2c148045cda4b14963b02b76982efa933dca247b9489962068a2e0497f729228d664927a3497feb119efe370a6b59fb53cdad9ec2988f112ae56a852a248672beb37f9615b338dc63e866996f28abd334cbdb791c6eced66675428769dad46422e2197f8c8eb0fe524518cb7af9428563b9b579542799486278d75391daed6c3980a7761ecda8c3f0fbdc7577ed867f6976492c7db673af384132350a17193fe5cfae596645bf4f466d86799edfdb2bdfdf43cfbc13e10663328619e857d36cb608fedfd037cf46fb5b7cf343f9616e67d1f8865f47eb0fc2118bb59fc38f9d10cfb8bfb0afb68fe6886658fd29e1863bee7655b675eb0712237be11e360ef8fc49cd50d4bdc8a0600432278234b1a5d9233b11fb8af3d941450a7a8544a7c94782a37292acf7e88c5ba4679f643eeee754a023c3729cc0727c0a287133a28f199bdd7c3014a7a9c086c7ad64b05783c691f61643c651713f9f06841135dfaa7ad364de41e22a0e32b25f169f38148691b1080b9e1e5026a1db580bcc7739336089e0d088874cb1b0e1675b4f083046614e008160d267cd122c7e647005f0837365b70c084b0e504590a5bba1b8709299070d1dd3925a460730c2055595c701b264ac0305aa5b78ba6b100cd966e1a22ba692ad0365e9eb0f1d28566886e1a217ed050a0bb939e38f9e40df67f73ec9344fff7f533dfc6cb0f9a0948404b10516880c8d29386668a8d07c8687ce377cbc9dbcdc603583acaa4cc03f3fe9267f1916e1b0ff858628d25ccb0b7bf36cb2a78b3ab70ae7f731a5fc2a73d4fcaf08d5dc2609b2e46d41061d3c547171edd3518982140960b588002361d38e24193a569f5d2257abf9f1fbe6dca58b6d5d2283163eae59957ad27417bffcaaadafa184bcf28ff0d53fe244182eeeed136493c914406922022891cba553e74f4721f7af272157695d2276f3e7fda6e9a1fba697ce8a6e981c70e56a620510211708056e5e5d1f11586f114a1cd87cdef217600432e3cd02aad34276f2e7f89cef8e89623061b24b2c81fd84356c59cd4d0028d378de7d96c4cba6964d348a16e9a8ea6a3194233e48e3b66ea98a923d2c0984b4bf3a4774b867e5a4d805a4b908a94b098a167ae68a1674a3053848117bef131b06383012246f4002f790a158d80626344ca8801747b9e04a2c99beb3d2a976455f23c095495b22dc22e4f0281718110ba3d49b34f4fb3c0025eb28d05ac74871ead66d95f1a14e463b3050536450c4002a12e79fe937830c5f773efb323f452eab1d9d2753b2be64be6d36832f648f7eb7ea8f32ca15099ff4ecf7e2aec2e7894e577954e11558e8e5feb39ee954a8cd155465c55c4553a523ac73b478a449dd0cbe5e4142982e9928d5d70becce7774790384dc63c2f85ca4f63b1304dfeac1ccb661da6c9d80a77f73fef6bb6ae4be938919cbcc5146c885341b912254e45c789b84d4a8755f865f4e6bfd9a7b9ccb79b95fd7579b514c85df06871b95a8bc32ae5833c5d94165152e7337bffa3defdafca5c65be5f6e89bbe091266319fcfad96796055bd1db6398df57cda75e71a6f826674c93d42b8d5641b779ba3068e9954b8f1dc3e2cc7b8fca8c3b9afce96832469331a79e57fad3d616ce49222966b2348bf58a81b8a6052e4d0071c40608158008a1fb87357e28e3872b9c855fe52c95b3f04c1126f460b32442f704faa186279512c5ae739bbd028e8b704e12e516ce0ee57e5617bec92b8f28ac064c0f45b8c70e363c84a184fba2595d93c6aa92cd606bd29f1a356c32571750c436991dca49a218b1e3ccfa5f52fce8ebfe0cf2585f56a98dde9c52c96b515e2d0dfa4993622871d7ca68fede869dfefc5969cc257e3a6325ced4c7424984729f955f9f954b998a27e6d743cfe3a4313086278da9306ad298e39b9c7bdcf288dd7966754c3df0b63c1e4df993946d912d9af68856e9a43fd916dd97df24dba21e3c39393aee13c3ed630a9a7b1f533cadbee7c99aac7da030df8af3dc3e671eac4489cfacebc4af16e623063ea414c9968c295048531540492fbb5628683e4ed65ef36ff25ff3ff8218bb80b0007145cfc66e21bec91a715f73046de8367b9c2fa34b5caa0a72f9b5b90b65337b7f26a3332afb0f4fcfd6bc3ace0e29d5bf62af90bd7f004ab4642f0dc2b6a85ef0677aa085a204ca0844402a105298a94112e166670e9b8f88951e423e5cf727bfc62ac015dc2cf2c4be9ea8c8128bb50a4960135e0943c77110c98300c346038a40e3072c68f01044b541b865279834e90493725fe494e86e3bc1242c617682303b416c27886d722f2cdd17d809da092675c4b15902c35953fed03c66a15736d9d780b08cfd9d5958aef6ce6095c232f8d1d8a4b10a56f0b35d9a15fcfc6110c39e36c12a39992bbdd50bc696a82761dfbf0d276b19276b394676565d33a3991146ba5608e36ae9fd59959e26f1cce893447866942b7efc1403fd3dc232cba099d1acd449f8836b5836c1ffa13cb2b1d6edd259b541322664ab980bbafb15b127976e577aad385f56d0339551efcb2df1886f3878cabf1ff83689cb5582367806eddfe82be2c7587e61ac52da0eb1cbc91b8bd5e1ce67f3bd866593297f3c0f149af2c706d9972daa4a3c623550f090000f20a850d12828b589ca2b7cdb6781800089b406fa570b622c73ef3b3a0e8379cc347604c9ec2f52473149c1d2f8c6088038df558332e078d5ba4d37a0d1dd9efde48dc562b16ef0a1bbc3b7b13e4b0f577973f7096e40e1da283ef8f4ec105170ba6f368946abfc759e1c0cd66082e2a5bb3114af4d5088f4943f4d4f74e81e8a0003e2928d659ccfa7343dd8bca691297de9e6a1bb7fd4ecd0d77e4a44aaa5d8a3b61b58270cf6d59a5e4768495ce01b33786b05212347072963420729734337120bdd311060862071e4749038987490388ae8207184d141e2f0410721a342072103d441c8c43a0899b08390e1d241c8c0e0841d4e50e60520657c20c34577f78905091c7577cfac208709a94b371bdd3c4052f57c7af38f0d5658ca03e887470f8f1d1e383c5ae0d1c3061e4348613ad28126073caa697c230e903146471adfd83e42cf65cd50778d931a665e5034c50d13d11bbdfa51d3240662d8877fe65f7bef1213518d690807d350adbbdb5947aaeebd9965ac1e7a354c3f21b92664e66bf8a1060538eb6f569641eb2a9f954aba8469f78c0b78504dbc709171d5c01586fdfbb96a7ecfa4a08689104f7525b9869ce50ad2a48d2667b8ca95a8f09b9a2ca0490e98fafd0f66330ccbfbb6080826466c214573400b031020f4c5fd25a3d09b42551a87358a889f1e59729b91c85064f57364c97d566e6429dab01cf258adcf8f859eb13caa2e5bf4483533f0aed29323a69878a2e8eec7e050d1ec322c18acc8c89584b4e4098cb56488204c3c4033409a0ed30c3998173cfa015b70b48ed841d2d5b06cd2b9aa4a243afe8519e59df4bafa1bcd4f73339b42c5ffc20cebaecd3229d4d1e80cacbdbceb7c663d3a69d30c5cba632a7c1bcac39cbca96cf689abd2ac4a33ef936c110c06833d71721f6662195d0a7ef56f13c66306043128306104129c2146890148e8ee26a10914ec8c5087aaf66303b2813811471620345657c1e5fc280304c48d12ccd8c93b2fdb4ece4e096d4aa2834e12268915d9da0bbbb71b976e8cdf839992f81026c9dda624af243da624deddb0ff599210baedac5258994ea3c3f49b9064e179d24b7723d9d2f829121dbcee4672d4b09acc7e4876ba1b89b70c74846f83c9904577c3bc744faaa5730d93618a0c418d6132a01acb4042f791326d3a32e648982360ba1b049a235b1a85361df1da6d9ef2a77b660440aebdd787139311312623b51e130c5a4c4654353324311999b2d35d93a4bb064977cd901a196a33b12504a2bbe6484e4ebebf54adecfb3a10ae9874dec03762d8fd0f859a15e8fc2fe4e972f2f682f7782a276f2fe0584179f4658ee356ba2f3362ac718236e56409ab94535a2ff43c82d276d718e9ae2952b30202681c60abcd1a0659acf91567f4d3167552d65da3d35d9353b3020d269c283d2606b18c68648a44daffb332ec1566938f930f85860634ab15cc8c11868a0a26a0d04256c159a6339f71c244a4892e6284fa1a3338009165a6015f835313bbbbeb98d4c033dffb98f45a33249850748861425d81da407763eaff85d883504add5d429b502d136ac7934b30130a05d3cd0f6ec62ce9ae5975d7a84c37b91a22606682689a134c336e74175d9051230210244c3144c9d7621a23189248a1ba6b8644dbb5b3b6810986ee5ead5635a91d7f9cab5ae1948f849348dd3528a1992a6880e8aeb999b688c55a329b19d51f2c6b4add9dff8ec3e057de7cfe632c7576925c480db1751454d44262626ac1089bc9c3e8d6c00c2a7423a04d0ed44d5cb7cfaef7645509bb8432b64df21d3c985800405b9af464ba323d2a6a12667a41138da9b1a4cdb4615ac1d5b44a6158d2ee2f59cfb348b95ef08756a9490535babb67f4e8a9a4d1bfbfa4bae04fbc602c85fa2b3f7c14b1ff1205f151b4c9646c7efebee5319625cecfb628d779a3fe5ece8f3178c516cdb7d9a5478a8149f395804ca09da5d32a55455a7c57e56e3949e431e7bf791ae1b8acc7209757e93d8d4fef7fab188823c6a0f739ad3732398b81385219c5f247ca6287531e9555d0ca3c59cb56455b1eebcdcce538532131100bf186c082863b31b299e66c8b5ec816853619cd493130e85a21a4a934b11dca180c9a8fb3b32e71e52451adff592d8a14799c55aa92bcae73f993e2ce31add2d9cc76dd0d0a70f7f1e9915906b9ca553e3d3d375a4bfa5c89bb7b029cc5727f8f7e372bb3b5eb3ac7995610574b1f29cc7452d00afd25eab5be7f27b44ae50761dba6005c117f263118fbd05501f0e96e619bcc0eb9db6432cb20a41e21f868757748e7675b27fda9c940fba4522793fef43099806820aec29bdd6b62e8ae81a1bb7fd4bcd05de342778d90a7f73e36fd48c3f4434c37f1e79c248aa177a9b4510ff765fb6149636e3d70da5b4d8637e36237a31eca6aff71e7f829feeb441eefcd4c1db9ab1ce5d1654d76c14fc96375cd9f7549c69e87e9129df2e6821936c4d4800e1edd261e6faab181a9264b4fe08c3156b0032d32d0404031470a4c8ce916c8d1ad563830d8473ffaaaff199966b484d79a663ad34c4e77e70fdd3523c2aca09ddd6861f3e7fcd8ed592cd887733636ab343592a96d30750ddd5d73c95af2a62680a97fd8dc5183ee2cbfbf77c880ba03053bcab4b3e67dcb627df8654a76987ae98232d0ae6677a9d2d5ec2e09213da961d94408e9c9acffe5c79e2761303a96ba8215fc8109dd1736a78c81ffb0fc55603110c3e694b1fa3110c33205adc84147cfc7a00b06ebaef1ee1a166a56e8eea0dab291e34877c7db67174c8e0c0bc118f63c09837d36db94a1dddd3d58404607dd99e2ccd01ca9834c945e7a2f16a320ac200e3a6ce2e002840d1c62e048011c5c781873ef32818e0247149b37c6d8bce145775fa11856c359c3d94d33821ace6e9a1674370f1a30fab3d9bede4801cba1ee4ed9b80fbc9ca8b3cad1dbea671247a08bb638d2dd5fa957a91b5984a159018f14ca0d2c1550c2c68d26ce7a18cc0d1368957ef1af6ca34c1b61b8bd6d08c10adf066b0347168bd5060bed4a3c7c1becb3d9bfef41998edf835c0fbebbdb59e13bc9580ed9d7910dcb97cd608b8d31366c4051f36a69fda1f09de424910f8eecbb2b499756ab95151c9c9b95457a85de98cc15276b38e270382124331c41e22c6751e956ce7a59d491c103a5c47469cad5fd259b3d59ff734ffeede6674f36e95c7a3e458e20d1d1c1e97156b543808e907c88bf52e851ea819fe5ac9f69ec7e92a8a893429318fc2bab367cdb12a2169290db5cde689cefd8560cda5a845d46b3bc59f7d9cd6db6f869357c2753fe446c33fea84ccac775df0d8cb9ca2679ccf5b1771fcdb8eb3ae74911711e1fe244fc7f0643b912ff6886793ca98f6694cc93329812cfef05b2e658d65a37a875772833fe25ba74418cbb01aa5b0d31dd1dd5006352234babd175c720d74b8d02d8000536f8bae36ae63db66e031ad22813d3e09246678bd2d8498384ee1abca03b66fc93c57a4d178bf59a140d2bd028020d20344ae8e28c069cd1a4fb263fe31be954761ec6fe2f36430733aa98d113432fa9a8e8f3ecbd32ae28434b370dc6a08107688044031766d0c50c8e98419319b4c860838c1b9021c4adb34a79a3cd64182143003220a33b7615c459cf6bc94028063fe81203a518dcc480070cbec0e00a0ca674c72e7f52b53486de4dd6ce57f1bd4bd5f762fc9bac281fe244fc314b7ae0edda99981b88d932eb1864c6d0c018750c14b410c38a5183182fbc00062ff0d21df14f1cc69818861017d8e18211b800e602a216906941981674a005575ad0d3dd75b250de640dd358579562e881a10318303062981c84f1120601617aba3bce2cadd24a6fb95222167cc10213b0a0b6c3821f2f1bab5bb522be76b602225680c30a4e5f50f1c5952fba2f72ba6705595dbd600c96a5175478a14377ec028e2e9ee822d645933854a0c4ec3a0f63f86bf95a9f5915ac5240c7ac52958214c890821e5c8ce1820a131755b828c0166d6c91832db66c81650b225bc8ce579d12c79dafba148e2b8f187f55e2b2ce572ce944fc73222e9335cf37e9995679f31bce411b82b3cffb9acb0367df85f86bd9ad2c625a05673eb3d251d04201102da2d0226b21d3c294451d597c208b2759d49c004c77c7d0fb259cc398bd559c8dff379bbf0fcf5c33eb5dbe16e75d8797c47ce5b7ba3f3b410a587081851558502c6cae40e38a1eae306245195680b1225b81002b7e7477e4e1f9190dbd5ca3516f5639b35765894c5001135013d06002ef8eddfc2bdf9385b55502232588a18a31aa6041153854714345185460a142670a1a4ce1c4143e4c219b42680aefee88333ff7a95ac6d94b7bcf6619b4c4abc4602dbfac93996669bd18abc39fcc94ba32066f61959daf705f3b5fddce579dd792628a9b36492184149f143048f123768f71dff92a1a01918008cc1d603e00468299218a39a24041146114a88eab0378c6f6f318fcef91f3ac32b647cec23f2d51f6308d753ff826bcd91bfbf953fe6cfd60896716090a16406105144140f103858f66c58ece269db4f3afe5fc18cb59c10bce1cd3a0fb572abd557a9b128669e8d303c3f46fb2ee80d893372afbe9c957adef7da55e75cd87fd05bf6b9f10d3fd04982770e82cc312f704932748e858cbb8af2d27c2b49ce812e67c4ee951aec526277e447c932b6d89c0daacf23c1164114127829d10a4417b8f2ed12b65f83d09e4c362bd90e8809e040a4100be60f1654b47fcc5a6892f9ac02156fb8519d6ddafb6891540c00508bc74c77ac1f94ca0c104154cd4989031410213ed65092f4a5e927c208d0f68f9c0079078604cab5498e68f41f198315805b4a177f706b4a12b794c752c5606bbbf494c5561eebdd92f61fbb5fb3356c37f672ebde2e497e481214b9cb1c40596b86189205dbce8027639d279f2afdb7a1fcb9faef3997d7545d1debff2d11aae76fe2cfe0533385bc90e88a0036007541c0883035dbafb63b055942914be3435511c686103606c4089fe9f3ea361ac2a2951a6af28d17a43031dd000150d0809230908242193084006ecc88017549b32a083acfd05bfdb79540ae5bef355adf3d52ba793208dc66e12d3e9f3bddbf92ae20b7e5d18f358e990213163ebd9d69021ce6252e42a426a418917fce487b9c4c1e5082e52b81c718981cb09486cd11d59ab18e66432f749ceea609dafa2c73a8a298cc2b1eb280da5f7352c6b9efc6b67d585c40e1226f4116558dd1161aad1115f3e893b02cb6c1d71a46593ca28988401336618d0a11d031d064830c2099311b9eeba6b8196c4dc1bb113bb9fbf7cc2b7791e8ddd3f9a5616be932348409f77d223fb271790e2025cbabb94ce055edf4dae7fabf6d2a5d8ed316ec51e8a05e6b0c0062cd000a13659a0c723b6b30815148183a9889dee8ea197a3e1db6220063d0f193264487c1bdeb2c496275b86b6f46c4161cb08dd6d439b88a882082b2622a274f4bc1bde0cc6727d1abb1410caa873d94f2bd3f1554cfd12c595c5b214f6e10ee55d2a49c7575d95b2cebba4eea795012539110742194d2b23e2c7ac550133ba3b7a1e755281fc49157040a6b7bf6f93444b7c5e8f65edc3f8de252cd62b8336acc13e9a8730a3bb7b882fdd1d6d6b88af3b0e41430f4142377e1a0dc42d21c07816220bceaca09d499c10b58f662148c0996fa280151d3f9a294081ee6e1f97ab6a58d62630c50488304de0278044026848c0879b1b9f59a44abbae8bf597b494400b125a685a9e680940104f04d10501640a0208103e00c20820baee9066b686e4eeac95cf6c87e4441ce9a379fe95ade21092d26a6725f45272e93c1fcd3e5d75edcc57b1be4d667c63abf3e0befadf2c931f3cf003961f8e7ca0c387287ce0a28afe61eb01f52066043d2ca0075b0f4d786883071af000040f3c3cf0d8e14b775d90afdcbb944e902ba6ba6c6b18fb68065d915669b7fa68f66b69961964b9c294e5872c48225046048488404f0472202006021a80c01104801ea0830708f180dc035ed0a14c77f833bd506241beeab08a85a77ca45890af62a7b37a75917a38d3eea3af2af35c255375afce67b6eb522f9451e7acd057b2ced67095f6368a3ffad12057d77d20ad6159eb7c15f363ef64a5511ca40314930e26981c40c6015238408b036c1dbb178bf5ea3c097aec5e9d7bec96c48c1fc4b8c562bd3a49143f9a5755d6b06ce283fa68f6ac8df9e0994f0f6c7ab6015da84c9132c5a3cdda56038e7832c5612a53eedb09622953fc6baf06c4d0dd3e2c960fcdb1f4574f4fcefe789e9455068460c262069621b034e978bd550c6dfe5aced622e9b46901255840071640846901411d73727254393a4ec493b2cea1f82aa6507eb3b7eb72c0410e3030e570450e52e4f0c59483027208731082d3e32efc04f957235f455fc5940ecac8573e3dee4284c1c2b7d909a63adcd70ee5b996c1d674bd600ad0a2805a6d29c08454f6280de513871e74475c0b073034f6c2414b96d3438943cd16e1e009a0a39b4902b848008d558ab39e5b9b31f5982901347cb5a62b7774479f57cfcca88811f04a92e98a90e98a4d38453833852818e47ac8f5e44ce88ea99cbca1a848c12b9a8b5da7137f62597339fe3ac7d9a3b43a3df4268df14c1aabd4840b010e02381bae8437565de7333be94a4ed312104b499608005e017a31af62f628cd56e9ade1eca53da67e671ec154764186c274f304bace57b1abf4365b5d5ccdacdb1a8e564bf3f568ae14b472ff684c0b6fe9ee9609d3206bcb8483442aafcdb92ff2f161b15e3d336b7b72f6a767d6b258af6b80394c564670adcc4c565c307d68983e2e114b5a938138d5a13c530fbd6ae3f43c8aa357be4f2bb321a6379c307f55be124cd60a4b3bcada376d2dff4d16258dcebaae5aff9877e473bf47f64f303662b1eeb5f72e995557c6f6a392536452296224f7b39aea923beea0a9b2a68a88dfb5428d89c796377c10be0dd642cd1d4a4b92d400d15df3c38f0661e8dafbd3d6f8d05dd3c30e5e6c65ba25ee8b90b051f1c4649bb1d5335376305549e3892a5d5a70531559054a15a52a475568f09945b9a9ca0f13f582461163a62dd8ea59fbd5d430d558505b8195dfb54238578a69f227633a24677d5a6b6684636052f8d1179e19e17fa1fa776674ff0393aafcae15c26096d70ad95975cd02b10afacc118fe9e98158e2686de12fddd486bb8c2f99abc4fd3aaa4229e912c694ca149594291e5b7707532ff2fbc38a98eef82d2b56b0745bc9e9c6d40a09dd31ffed6693be32f10b135ddf97eef881b64c77fc9bc5368b68bb3e591ababbadc7a46a46fd124ff5ab4e6e6522a6556a8b3730b1bb69e9be4589d35d372f4c4789ab96b63c2f318fc86687ad4b77bc56565b29980a63d6b6d45502cdfe7e458c803e3e3e9e47633e3d30d80dacf4a32fd4d0a8fd5073d57e9c685bd0be8ef16fde7558ba2a762c56a5d403679947e2c752f68a5e77adc7229176518765eb32066747713c6fa6c40cca2c8607e3c33732679065c6a60859c812203b8a5385bdcffee73659c436c7f94b3c761e3f36b33e640828cbc9592d0c56e9adf321d1b152ec8cd817f914c786ba5b4e40da709249240c9d19dd0aba06743bf16b39e71a8de29ae4a924949187d54eb759e2d0c3f8c30a23a33baa42ef334c0758d7ed081083001f2a6c5031e244c501548ca880709a42c51423a604650c4ec7d2f3d31e3683c1baff507edfa11c5bdc4fd0dfdacb5791a8eb62a68ee3ccfa077a0dfbeb24650a293e48497280340e20e60058ba63175699aa602765561b4351e966b5b14e8ad2077673b66e98e30631372871bac1deb0a372168eaba1d410ca08e9069b28248852eb686b38e950ea800206142f1eb5b9cd2ea3352cbd2416eb0514fd890e9ec8e0c9104f983c01a234859255a2e1c5c6ab03afdaeb3f2976b453d54fcd28956a531dea97ecad73cf935ffd512c963c253520099624c209490d24213a7bb6aac0d47cd9b5286fb9bc6fc318365c4002363cc08604d87073b281c7f48c705fa472564a07657474e5c87674c4480d232e464418796d8b7c151fcb5c88a1f799568afb7a8b70d10aa7a21188a42092111960684888a125a7a11f273f383961c3c91627312721505183d7ddf1710d37a337cfb6e2fb9fe36a7f2af5d5575bc39e9337efbce54358d7c80e61e5bfe1cef3680dbfadf2ab0d61d662f9d5d0f1da2c9333294b723dd11d5d374dd4e86e277d6a72812651dcfef82aa670b514e52f17916b88c56a6599cc52962a42659abb89f86d762d9838c164034c8c60626322c4440421129c847c6867392b7c9b1773b5d22848bbf26775f92aa630c558a23cf452ab47422d096249cf92108272109446d0114114089205bd10040290088066402afc74f19325623b31c5adee7ff26b47ee3185f2bfd253b44a510e942a4219396bbaaf52a8228c3262dde8cb5771465d55a58ca7d6c9fbdd953815be56deff501efd985a55b47e68b14e34a841030db918daecf8bb1139cbd62b71ab866596f7bd9f451a086080384e06f0a2bb23954e26c56c2dd24feaf2a1f2be8f8f8f0fae96e2f91f88e55d5229cc47f64f7c70765298cfbc4aca9c947451f275b712a39e32dded3d61bae74bf76cf57c7dffb6ea53cf4e0f093c5cdc2ccf96ce8fa94cc9c99b94293c94a784ee8ee04d4d965bac2d5897d259a507b91cdfbc268db1765077b6582674f70c635a3370d19156e90c5c66f8669801b553a63b565a74dad9d9a911edd0b0e3dd3149991693248916ac94e48bf3948486a64bd5d6561215e2949f93b78f666cbf8be408121264104386214e3230408624477870440547b074a78c3e85a967bb1667248d93112f46964e466a30c2a373f29693b7979111124ca7969344119f8ad08a149d8ac4a0b3860e17295fcd54ad3772aa38e53020474999138e08706e3845701cbf07ded96a76dfca5ac6740ac524e203a2778a1f495849715a6d49e95cd00ae1292deef5d57ab5b39bf29b74b56c631e58eb4995864a081592eae644040d22491099272241447a9c8684b1be9ad56dc67578d29faec3f6fb4963d77a0e7f2ebd4306302675c40e29a0532ac829d5a82650b7136aa85340734a2020a0506256f7f91483173160200629a7184e80410630100183100c51062f2c717a819e5e18800b57b8705d4841081742721d23b61983acbf85a00d6bb8d847f387b3074e6ab3ad97d230665b48727239dc8c938fe15abc8a13b90a2cb880852a58c8e1c402664185130b21ac208315905881ae50e4a44299930a635410e2a482014e2af038a510c529052c93c67c858d7c15696c0524023911ff4101d9225fbd8a948c806041ae1f589416d18ce2e0dc6f347f96651464f44279ea076584fb4a8432024afda08cdcf3242b0534692b56c1ce278d5589420e28c8503889713ac18b13ae9c4e507242905301d028c00f0590a7020831010c139030a1869309dda99f1f6cc46d264aa11ca3dc71a655fa9eb5316ff9cabbb04a15add2e92aa992b44a63b5140fa088d3001230801f804e10344e415e700ad24310a5ee1ea14f41989c4a80a3041594a0815309b8127c4e25fc3865713a8de0a4c3c97512c134839309042713ccc46363039b246c8a4e36454e2490712241cb4fac208dfdf8ca5771e20c5a8bcb11488a28d6f26330dbef6b407c15511e4595c293c67eae5d79b77258b514c368d2d2669593c66a93c662fe389aabfedad9941d15c0152701e4208029027861041d9c465062040498fa34c2d0083f4e22e440042544304284a153087474a7a238113f72224e44b39e1371229451ea0865e4310acac8a3e749998ee7c9d4518ac869d6431911a18c5247ae4a619413392b7c2711678ac336e34c6f3e3db3525b085d8a42c062429f42e86208a8b645a7008411becd6f96a8f74e70005800401a27004cd1dd51fa0400d909003e27206b9c8050e004c4e7042484c6ff85299d94a7308892d19b20975f2b3f96547f84a71f379c7ee89c4088e3044218107c388110e50402cac719271f5dba5993fae79dabba99d1745d8bc293c2c2b7b158387c2791669b6387c3b775298c0adf96947b1f47f9b1e7a1ea635b3bf9e858ebd4434c0bf34f3db8749f7ae45ee8538f26ddddaf530f7ae251a61b9f787ce9eea6a0bde1c4034b6ec9fec9a9a6cca9a689534ded54f34204fa19cdf2963fe9447381eeb6a14f34359c66e838cdbc4089cef2874439eb0f8919bcd663759d0f8956362476b74e9f664e38351ba7fec0a96ba7ee4ebdc21d34b8838a076de8aa2cfbfcd3edcb3d8a551f9db922ce14cb1a823f77cc3b64b0238eeeaee0fd3c7365f9df5f3bc0d881a5630ae51fe8f3df8e9d2057cb8e3ac2d4d1a58e1a4e1d293a78e8a8f9c11a3fc8c00ff00f52c8f5e947657f577f319da3ce3134470b73f890e38b1c5de488d2bdaab64a582d0b95b1658a9489a1cc0f3260c848323b644088e38b3872dd9d42a95878e56e957c1559dd6757b63aabc37d6af51705cbd622dd4c2f18bb51ef6b705c01c703e0288203d5ddb9cbfdacd2dfc06f746fbcdee87963006f88e0031df860091fbcdca8c30d319dc28e33e523b98eff04f92a56231df0f619676bebff0ab9c1a5adc56eb11b51badd50a10d32ba636afe12f5da48a20d0474c7d412f550f331283fcf37f5faf8b8aa86650f8ae881941eacc00619dd5fcbcec6b371840767f0c0071eecece08c1d04b183243a2843075a3a666b6f8d783aee2b6c66fcb10ef7b5bee761a69fe57de5e4e4e8d895ecda9f495ca3d1da4b9b5d95a53f6d4a9a7f2d873e3d19d3a1d0a7681665099b486428d2440724748fe99883ae65ca010362a5d6e69bbdb31cece4e0c71a62566b6869adf175afd1e4263fdfd648a12785753878a34b9cbfd461896be1e02885c201ea961913a67b4c97a431b93eeaee380635e6479c4937b0a23baf79a8e413d7fba0756a4600002028931000003020140bc62332b16c3ee9fd14800162b856b05ea1cae33cc821648c21c400000000000000461b004c9b09795e5624098c79f82d8f62a2db4da8cb9481beb753c7d4fbcc0011a86a0442ea728843db6e9ea28405b06369186c3adf84313ee780fc84c70dd954eafb8e16a8e4389d4f1da75f9f31a087b47002345f0c1bbfd168222388e873103723ea63ca1e609a996a569696e0a3f60d3a08c7bed33fe313dbb6cab83436bbd4b8b9952d20984220b5d43340e31c519134d91a32b30f0eb627444280abb4106955136c0a1596c7216f454370f684804fcbee4ac7a7682ffe0d3458cc1405c2943dbd27b3325f10f50d2f5aaea27f2d3b72e4adc5bd847ac9a6dfdc7c27041afe45d39257f942171e1a335331236d26797a7863c63e830af8a3e51cb410fa0ac629fd6f4a50cbcc48f437a1c08bf086cf3f58163f9cb40e3945e635adbc8350628b3b7b34966a4b2e01bf64ec1854e4a8e051e4bfe512fcdcced905a14b317ac6a40f5b2cbc00f80c190bd944b6bb630ba7f03118c8a4273cbd22cc8f9e6087bddb30ebf7a6b6ffc12d590f83dab58de83b9a3782789ca57a4e0fcc97bf2ede6fe54c018879a7dbac20827cd0cd8d97e935d4be20f409bf7581c2daa8bb29a1107bf20d7880db2d0f844e075c715f4eb36a621ebe4123aa00c065e400bfb096963198a776e239c4eb1efe551a5c82b0586a3f708b58a917a50281ed99a5f7e1e5e2939348ff6fafd01272f01f80fb315c175e3f219e0aa4f88ee3094e8e263e282c9b577ecb4e8a2d9d0496310523ed58a01061e5acee370cf5a07ae2c32029e430d5fa0cccd63b5089984902d232b511ff0eaf841fa90869876aab058e62c0870d821609caac5541eabbb8e42da37086971958920080bab497b46cb2b4b68a49260ff7573c5c9d89804227f2851aecad918ffea473d6ccc8985ab2d3797b4b868f9e5d6af03906a6027d77b8d71126b606831de9d2036ef4ddb4d2f4ffb2f3f5b5226bc027741a26d284f4251ada6b49e69f9378b523f9c12ad2b5288de3218940d0866c2fdf16cc6fae6b6c14deb20bab4735188e10b5dd66fba11123e901c016571bc6568980c9d96d06a1d3181a3a6ccff54eb129946118158fd231f2becaa3123e968f6fdf47ba0de7d2268d9c0903346c1cfa6df49ba212a7a520e919f5ba354cdf68a17b40caccfa6e7e030248d47b152b4c69a91594906cfc4e562844088dc11cdc1e242e82275d6da4b42adad609c6b36451a54abf7dcaf966c0c7a723f476e66e78f61e497f9bc700caf7dba1933ad0f604b6da4287284346d1e129fabafdbdd33bbb7a329a50bd8a029ca7472185f82b83e1e5e16d4a754b7fa3b3ce5f9761c0c7563518d204319a113d57f10c8c30d5714727695f60e7b8e66bf57a61b0b7b0f366c1791d5fbf3ee4fff9cb26c000aff73799c37f20ff7f192b7afd4edf03f814d57e358a5c53422421669ca69ce5550840b8475b1044c1d1c204a61b61af3ea82cf487e90bb4684b045599e9afb1bd551b2f6f1571255d2bea727d2cdeb2bc96045e717d3c866a2afe57b57e43f018e35c37a231220d8c2e3b74a2fd2bae8cc5cdf5f295a3ed21bbdb415af746739cd5a5afc47932751450118c85348455d352f8d61138536c4f6eac0829a3d7c85ae1dce77e8477a2180176e6dff21007ec543ba808a8ee9014fcc8953ae3228ded0297b856cb8babf4bccbcc238e5646c06c88061f154331648b9e51a5db10e04805b189393d592bf228a6764f3fc123a1f6bcb6a5c7a0b6aa078491fd3a65b78381de1687be99254ec0937347f9568980e70652b0fef6901549db3442fda73af177c3e07d5a6beee297f16a4fd0f942a58447b84fd2f8c1d8f721c126c6815bc626cb88eb2d44e92f2cb828aeb9b5f82120e6f7c5ac12ca49461ae18b69806e75305cddd443ebc832826b65fcbbc911366466fd5b8621399cadf3f5e59c04d0bb89475b7ef43ff753e0867516c47ccd4881d1921591c9c102a82371eec375745867e51916fa99dc2ef666257c8d665e05d9098a59788388babe2adf32103ec6661d728f40c7aecc52defd20a2a640107d9963c0abfe1497f9ddebf50b0fb74a79d9f683d5b094760ca50883e0b9f6ac473e7b17535ffd1b6f0e1991841f89a8253278c4953d68994ffff131bc4d17f5f3db01e74df94e0bbb7a21b7821b5d8ab51ce288be1a8cb9a6b6943d252bdc6535a151e6693030f5faecccc008e18042b78f14b4b082db325c21f58a5c85e18248ea611059641e32f41414727278122948112a198d05d14091e53d46074dc24c7ff3b3e3ef8246c8067eb55505655ce1ed4c27ba980a17d52fb6f41352802a9bb3c69248706bbc8f96cc7b5fa03c1686a9b24f82ca13a9491cb727baa70f123f5fe141e90cedd2b2e3c112cf6c86699d24c829ab3ccbe3a4d93b891e8bb57e3dab70076e508882aba4b2e0a0235922f89926e5a59bd352b65343e8c3e2682fab57b36cc73b18141ad8d69ac1149820456831eabc3dd96f787b163b4c5c1e7c5c4e4219c14760a74eddce611a3a7be33fd005236b1242c368becff57eaee707e31740bd999bc1afeabf6508294894d57b3eb7aac9f5222ab1b1b314731cbc2b38a914c266d9ac507850da4109eae721ae79ee1b2c222c20306ab08e04d7af322ee1382f3520da815a522ba98b7a3b82eb643363bfbbb2d4492da5980923f37153be92be0074007448856a67883d0044b52c135dd7ec6804f2777ab7eb848773adafab7f2eb8b143ea30cc60c772ed3d6c97f38ac89cecf23fc41b975080550e7b8bcfb0937643968804a77d67a1757e6d004bf122554b31cfae2e3e7afcd5226e5487be980deeb679523c47f5b715ff96c69ec96f56c5cf357b06ba36c2afc30df38c1f57417ec03ed40913d6c490e4cc3f70e21b20913007c888aa63a7b39bd732ca1be9c8482b151b7c2ccd78c1db6c7483d6c10f7bff1dfe091db70b4b1903695e0f56dcbadf44e072d3dd6262732ab6d0f75264f3d6c7e05533f3988b9599cbe3c4638ff120ee6d0859ad23d1295689043680d7892691fd6444ccea62717e8e11849571c493b2dab75e7b62c3cab656430ec5b6bdbc1363b7a5cefa14ce5a4abc73a2ba451b333158e906ce1129bd9bcdd1e5b524a8d35d43c6f44c633564bd7a2ec710cbe008e89f9baaf3cdd27b83306d68ff1f85598f4139212a1daf97a94d0c12b4d0a4fdfffdcb86cb3a4dfdc78911fdf2d661057422739c62781c2d0985d66a70e40df538c2566ad29af2c75c90aab6aa4f1b2244e2bd1ac5f9f17f857f34fa692e8a921e8bd5762c74db758e23555ffcd8c17acb49e3f6fa41d3ed2bc42b8b2711fc59d0f4b787416f30f18b05db9edd3faad4db22f21e400818c6ac4ff389c9acbf67242b0da4652ac9968d101d96e2a158fcfb819c7d6a0a44607448150a16d1b5a7c3d4f53b09f2174d7f1978512d3f7b1bbb8d3d73c28d627108b76cc98403cf6e52374c0b976c54001eb770d821c59586c4c3829a9bdc765c410316401df09282195f8e2cfa066a3bd912201e8423121ce11b38fcd9853d39991269b63d2d0920cbc629603b68639c8175808f3244162b5fbce135e046104264f16a336f290bf9b339e6ea99f0e9176d0c3eeb11635cab78bb81d04db82ccf3ceef2fc97ddefb3b8ea30bcff557f003c8a464687bac1ed9e4d251cdea62dfd71a2151bca4a6bad751afd2e36fb60d4f8f69409acb329b5e58a8418242130bcc76cd4ef2eca071dd23d1c053a50a6594057e1567f4ada5be2ada1f1e206c39f7b7f80402e3da83c594d87ccce9f0fb74a39f900aaf5d8c2db75db186d4a3f6a4394f80193d7139710b50a59bf463d213963afcdb5058605e454f6891ba1d6c6a3e1d1046b47b83537a0c44f3405e81cada1bd7dace161a3ed676abcfc717ce3ea444b70c194899ccc8d3854d2d2f9445f1b2d4b0aa98da0b0c6236c8a88d1e7b0d38222057aa45e223f3927064629209da4cea3e7c5c1478817588b20202c5d1bed513a0af75aab15e24d40c8ade1cc8c066517a460d5c65d137eedfca6f9a86449a200ec12cd4ca441a724e24eed47e21c414093faae6a9c8b6ad50eb7f297d646637a810cf7f92c0d3f2cf7e8a0df0b1aa7bf03aed13bae12fe6a58bf1947ece4c780918b3b7a926125b1610b56ffa57dca835baf1b3f54c82f33aebdb9f1f0c9840c83e52b87304bda75842a3f11007bef835e8c4fa3358910e54d7c1208fc2c750bdad7e36d0bb3d2a8d60a5defedfee6fa28ccf95d430085705e03f890b5b2aa871387b1e1ec19123a6fdb1e0d3c319625fb7829b804d957a0fbb5f7f926de6ac6ba994a8e857e5e8cadc3885a4a0f57d32e040511fc3dbd86a160765cc251aa9188b267a5225cf23b20ab391cf41a126d70b0867016a3122e3f971308aa40eb913be0750d3522f03e6f0642f503202a4706f973392abeb9f161b5da47a2d82eb47ba57f4110ff5fe78366feeec71fc9fb21195d8ff39228cf55f4c0c2fafc778e1ed5e6151ca79d71ef52ae0a87f77015615658d9f4915d35a5f28d2778bf43ced6c6415981bdaae586ad182137c92b1b65ddfc9cc0ca2fcce039fa81e6e5c9adaa7dee49f4996d696204042871355126cf3d6c6cbda28c33d91fc311d9b870b6ebacca7a96d6d9467e0d4b366a03c535c1b76c11418917969af3d5040807b4588f90868a4b018feeaf743cccf0e72001013396fd42102340639c8353a9381b9a2797224dc589ab87e6d184386814651341e8aa616742e8972eb20194156d2c6a0001100648761083c26fd712a3c8e0a9167a70c6b8da4bb00f1b7ec03d352d2a3ef1399cd5cf3e9d24f970f773aab39edd1e9f6f572203d272b2a361977c81856a0291e106a298399c6b6c342f1d661690a3fd7a4bb6d46c180a99ef183c254330c2e1b0398110e7f797ff868dc323c632afd0924f195c86965285315e907e92c7603535db1ef2a7ebbe6b31266df92478a7d9547246af57067757511f6340dc8e2819414add8970566ef7b231e9a860fece979579836775f3f27af5b0a106eed61c579fe37cf4e40fe09e5d1b3b9dc9dd8a344b3baf93b51b6622b4b94309f6710c0fa7a756a2aa4d90102e4cb31b21b89e5a24a8bc4a5b73bec3a56bdfb82101f80263a25b70f83068dd8d1e64cc98e63b3aeeccb78d6c9e3878b62a9c41abda9f32e3164453e971e6acdf7f29f55818e7dc5cf8d5c1a7bdb1896fba395692a30dee4dfdc509a42c658e854c1bdba8dddd1aec59e43b8a2c0a6d0fb8865c98d269cd04b978eefcf844f76d99251a999e2df85daa8352343c13bb49a0d681ea4c513829e8131c939ffa81a34aec3aae07773adadb9660b79ee1f063b8783e5f4a833a405deb1f5a7991f87d0bd131d8f8168600ddbd0058c3eb0017b83c1b05588996f8ca7ce0562878a9a8266d889a03b5cf0f2fb63be78735f9544ab4cec7ac59c16dda5e488b185b62bd528e9e19ffd4a52e5530df56d0f0a407be88f4de93a16986c0ed4e3e6433a8158e71c20d23c0bbfc107c79526e4557e05e681754b0571f8e8a5f7b03bdcad40d29fffbd6ea56a614b41cea3942dd73d6ba7c347ea9471caa6ebf7d7ab348fcb822b808929cf9dad5741f9556a6c73af196d4bf904222325a45a9e906976e93fe647b8d8adf09e5861e510a821b54adc469d9d3eac678229742a0312da848336eb6db59955c445d3f376f6874057af80d7dec8bcd18ccf140fd6b0831148c775656fd9fdea9c539f62adbfb21f3bd978e3926f4e64fdfc806779260b650e6d6cd0a0d534449e428a18620c98e070876f9a3daa5e5c5c8363ef1b6f4bacd049ae85b09707c1a5eccb2b26e5deb424523ca53d307b01855b4b62f416e2513eb84ef45f6a4f2f4d6d03edbbba4b05b8501561907c58cf8b106d6e2ef3b4bc1605a2ab601c36be51116a617b2c2eeed06e44027bc7b1f4cb023e3aa5de92803782256b75c5a0c7e9e30ae6c0812ece56e00b160d1a47562fbfd22db64204ea2657f713ff995cfec26972b056dd41671e17bd693c81feafbad81f73022d5f5e955f13a1de1a6b2f4fc4b975d0b1b21b4a213e4c67850abd75569df51a3c516d11577f2ba23d320b1b2e852469f02d762ef1684d514a8de7c7c7c4068f2475c52d2058964a6fe272491712c254e183cc293667605b9afe4c7151d6b79d3c4eb2f493e2fcb1afe4753e212fea6daf32293597b00035c4a0d08268ed71fb9deb84b5e5dceb2680026cedff5902994a259c44373cf7b15ec29e0893994772278f74280f5068023a0ee7b7b03393f0ef95f6acf13b6f4f3d3543124c867e5ea070a4fd85fdb7ff604b8ed13bc6a747abb9843f55de90478b66a21861d86efae0a8e53d0fb17fa9d055afe7a9e2c8c3f007c874fb6814077fc863f66f4141a48600ff7236b7602666a599ada2d22e6e0a968c803153acc98959906c20e6aab31be32554f4719a89b1a2680d12e9dbec0255699f3ea87214c999ce0c86fb1a23d7dd6d40c225bd449265bf500f6d6a01d7b50883eb7e4d32e0e657b50e39e36e1118274435dbbd6b30ce624509cd7894cb910836478f7fb2a15611ca792178d57f78984459496e97894409337b6fba4fa1d807f21a1d930801ec10608091e3fd4768f5f4b513906c11c750b15e72d4e6c55ecc9f87ce9f4100a29ed52fc29d936356e72a82f24966ea33213db9ed55439f90e7fc720c516a68e6a740d0c08cbc83f5aca4259cba5b2adce4b1fb689ebfab5ac149ca9957a6c801dd93b64fc75b4fa8f9ac3930145710c63f3e78ca0fbffd058d447b941815fc38ae182c1ae539b253bdf1d3b43829bce332157d12743c76e2a30826cb9de44a8415097f876b6822c22d094d35618045444bc515aa0ca28f3f14c24f0fdc1e2d3e0f6d1410f37c88e1057c35d679908e8f50e40c91e350472d468d34590ebd05a11b88587b8da6c8a2be46370a9bef2b2d42cb30e87904b5f6e345d335336bdac3f37781f8abfe29f85b9a4cb8d450a78cdda1be4a18b3f31908f2ce85805a0365dc7677793ab8d68b8c7af6438afbd211ff9109f0d322ed630f462f2f954b63d2408c0b2847113a23af6d434d0e746ff24299f9eeb1647e1fa4da63849f01379673dcec6875d470d284a24f9db9ff890a47b1fe0b55755fa998a6b32b88102dbc84f4c5796e7fd2334b6f15335baced92ff0a4cf253a6676c71983cf893eaabd3e93cfefadf56fa4da19a0bedcc46fc5b479fa7180307071475cc03d73cb686f2de4c9fcfb87d14d1cc2bf4d99fcca7b2a3127d1d0738579b8651cc32e3778afd3c698c10c4c1bf2d64a1e41fd4445b1cd10ad427cfd91d0630578aeab84ab548d00ad4a03d85d04edc9f4e8def432ad47ec3ef7ac9d20a44623a4aa3b87cc3a07b14fb0c07d313d02d1bfc704e01999139813ef1586549aabc0c1f984d3cf7df11b3e19ce06f67e36d4093110303fbf0f4668d8dce7a512ad94bc7f6008c98c3b6c036a0c7cb68d983a3c39a7e0d0d63c8a0ee75c70da24dd1d3484904804ad6e1755c92148c51b8d9e90cb9289cfad2180275a015408d83bc7ce12207bc48a61d1b9519839e081390850d51319855e220c5df296c52f1fdb01e25db2d048866b58de962590ce337cf77f986eac751857f1392a64f79707a3ad42bf6f1186414c7514cc5a5e2394c4ce8ecafa598f4f0740b7e06c982da5f7f6c866e4f12b07db104ff3f264504643826048cf83355b0323765b9330293837056746fa9cfbfc423e7eb7e96d0b784e53679e557bd2e24199f122a1c849de09a72aac58c58a18d1f44e116fa914c129b325f1c2e01cd00a4462d68f2d5765cd794064c37e278b90f351057fc2beec202c946bab29efd3693ca8fc6904c81a8ef85de40e3c3811ac6442ded8051ec73b2c8660982b8b271145b8d68477764362962880474e9765358c39295a8fbbfaa0c74cc2a2081888d02b6f094f9d72a9f722fb1ed0731a00ae9d41937ce9a420b850066b515d6a96e209c03433857fce0c51bed1a1cc8e8aadb4a60c999b8a894e7e351f5d470c74a5ce15c1617dacf4cd5ad97d738365df496fcabcf37998b52604ac87304a0ad52b5ed19b720b66216f59c48e8ecf3dbe906b1b271826f2c5872c55778ba6cd9a6ea1a42fab8ab515d39f6c23ad107179594ed09078d4ba3c8c7e104adc9881fce03190c68cad30b398d88c24f4f801f46252b6f12343084f844ada05d13e1b33c220904e913a2dc63d3dee26f15c4cf27533a8fa7f8e30d3da3950f93229f4da06748b773c07c24bd0d59a0ea502741418a980389a52ae296a3380219457e9493b46400291732e3fe7ca259a25e8c58aa173ef66abf170eeb4bf1f2e591b4952182315a9860a117c97c3ea7fce33a1a9334d1b7d7862fefdff14f68c0f1606f2c51524bfec7d4297fcb2d3100d1a7aedae7e05333a16448d3a7f0b4829c60b330e672dcb38c356804b8790c478ef74f61fb96e3c90cd01c19f0ae0a6094b7c3089c6e1cc396573d8c0783d561b072a6a3bac71d8a391e69be35442737055691335886d5bf2b264b7771892920140ab9c1ba4d7fd81c6f561e8e1344662c1769566d87101806eb9e1b9e5eb21a7b92c2e5ddc85d98b758e8935a37dc86dfb6ec9f460f80feb6ec7c2c5b929fd6faa2d7d692377f3b8e4bb33c898942c2c23e3a332f2796e88e22f720af86f8650e7710ecaccdc5879bad1d5e46c41ff96ede80bc0b69e64d3dd167915d149ae8e7c3bf8cb5fb0911f2794ce0bc68237a881231990eb324cbddb9b575f86cda0678d39c0aa054a20b2521396f363198fd1acffcff81585cc255115c2fbff2e3bc218afc2b4da254ae2d337c4e1faefb532ee53d8065161495441ac587cfd391717979bfc274924a39e4dcd2554ba1533a888da1cb52a47ea8e082b4a18b86e48cfe3acc54d2f4c64c82d22429eba88b1e9e663304b95df3e22509666551bf971dd3cb5fc054a82b2e0212600e549b476e726010037c6615cab92849bd247046008e9dca88207ddc5cc36310cc88bb284d0836a66cd231340f36f3ff6fce1e5bbd74991ae4364442d04635e6a9d8fcfa52a4425ae7c82df238a8be7e63217ffd6ac3104c988e2894caf1a12450da86b29599c4fb17097e4f9a8e7ee167d164d1990ad117a08469aedaabac3c919c301b5babc1fef4e135382f3849deb3aba67a045319c5b2d61d8427f138d741b8179bd8f6d36e73e4baabfef963e208ff419e65143c7a028394e227c53502eec93591522dae8726ecc0d5baa77e73f5ac39707c27fb1004ae16bf10fc565d31d4eb381c6cbeaea0e4f3b99ab9f6e30cb455a017996c0fa7ae1eace7dd644f8f6ed2e9d9171461403977559dea507539d8157e52a698a82dc88ff53678c3d0af010a441bb0107dfbdf19ba403412bb3a41bfb7468b6258a77f2d1e18434b97e09385bb74e90b03abf7a9a029d780ba2cf0efa68700a99343152dfa6adad5123f70c3d9eb4c85e3ecff798e54045b3dfe0fffe428bf31c611ab08257d3a75b296d2da6d7b94c2af28ebe1fa78b4cfa6a24762cee53b29b85cf10f3c42b401846fa1d800e6e549afc70e9884237f520da7a68a0bbf765872b57f26bf29425e10c0770dd192a94944d50d6a0654bd62e3513bcfa1648e339abcda083f8a522e3ddb0b4113c5b8e955f267a5065b64eed0c24c983cedf3a36e101afa0ddec9e7a2c607abab235b13f794d2bbe88e585dcd959693a93cb0118f8392a649b26f16ef1f93232a1fd95c522c740393310ec318d5a37dc382fc3ad1fe3fdb64cf44a71053f0ee0cb60b57efb47a683eec6ef4abff5fd41d8b055abc79364e2b960376d26ac7300ee4ea583dbfad6f2784362e8a9489aef24c4ab262b63df667dda2ae6d9c3eed0ff5a445d4f031369dabc861db4a74b0c5124f082e864e3531d483c780c009c2a66de1d0be999ad2deaa746500c2ba2e4c797ed4f57376ab2d2ba017af1ccdc1ff343105e4450dc9172bcaf03966a065669982f443f3cc572154758637eb7b02f3c396249699b59a461a74df339b3f967b1269d1f5551e78c8a40bcea004cd0fd216664868867f29524eb75efd9bb71e0f08f9f21314803697c583e9384ff5da01b7692606cb6c51356ab399e3a41130e782422102cfc5a095c3a918b06b1e2869730590f408d5d478367f5721e368d54e75d727594a778ac4a3e188a44305f0c611cf1c7ba90b0f284f52a245ac0e5667b3bfe9bfa32d077124189fca04c8fb7fecdb48c99d96d497c1fff7945c48c2a13a9c4ff0885a25d5fb843e7f80e21b7234335141d008ea78c3df60959c8467398beb19c997128ed67b122def88facf5c52f86f7aa1c65ef017ee387344a35c6e2bafccd256f35d5ca195cc43e88deec202bce1fcde419fd59d3abf12067be1d67d06c07adc87eff05ef3ebed3fa5b9621f0f3cba6b19d26009952968f7596f313dcdcc0ca6a423578720a1d430582ac2908a7bd295c8992353bb14a092dbddc4a2b9c6264a4dfcbf26f0e8fa4bd8d64e97081c7d1477365f97f79f950df70e9aae1224462120cb029c635b8cfb39b3653f13f795e3f2094937cfeffca4ccc8c09b8334ffaa1ae8750024ad9fb89fdded472fbc6ab425f20e96dd2aea6acb4f2d15830889a0531cf9dde2bcd713eacc09648bb7609be257521d59f2532de6198ee98cdecefde9a1751916c76494ad36020b95c6b8e0a83680eb4f44297ce15fdb21c6be70a170f6b3813f63e1eb0ddf1b239e80e95c1fc49f25672cfc0d90f849fdde9c3bf090e6da84e30e999500ee7337e691d71eff4df09e30c3bb222a55c1850df266e1f74c2af02c69bfc06c2f46d8656ab10151600a57737588e18e3ddaf228643cbcbe77487e3b9b5f14d4c8464e7e980d406efb926d465f5cd51d1c1dbbf12fc3d8cd4e43cc8eb91bb477679b47d7288e8f0c3ecbc2e52df50d882682b8911f6c5a05b27bae01988015d59ce3c3e032ba4ef2d7c2d9514318021404a9cb6475c559344fb1450b148bd8de464b2ac2e2b89cbb4b7ef079424a5b4705817ec876363262181dda41d8001a071411987a54eee566b1608ba445bad5ea61eb6fcfbb219dbc2c5ddb90a2c502cc9370288ac84e3e6d54ed60c690f1198778c213f9466fe8dfd7037a13744da90bca11633cb1e4c23776b90383b5ec52abac49558aa2e7c74d1bdbfc58e39531fb0c312705d4ead7e6f1ecf709a7173a8ab4e97cfe5ebf2644cd4738a9dba58f948316fc4dfa301186144c8a801ca7f889ef6091c811d108ddb5721b4684acad063fbf0a28c1a1b467ead6d45d7077af719219078843f3885a8e711b4be17123ace7a5f845b8fcb4da74ae5c847ca4dd3e49b65eb28877f1c89731902bef392605724ae61300a5f573f53a74f6bd9ee47ba098e2656df384a4a1a1d9b04df1d000a89ab229448d7bc6e62f9a399e30c89476593f5116b67484c6396dbfa9c863342f2af43cb0ed016852c07a1a6e94290fd82a901d2f25d0940a4df13a90a82d156a0c6db95e7ac70e622b829da16f6aa1e3d6d50d491d735a308de22af118d610934a3aa71189c5c3579f7d256755cc6379cabc02e5941225aa76a406fd3bfff7040381c01ba0fdd52395cc6567860ae2c47b31d62e9637471072611c886201253897644fbafbeee42b7512381d3bcb76d63bb465cf8b52c0bb3138ec68f3da34ef533edee7fd38877fe1dab45308da756d0a0d4dcf636d6cd5c09c61114a4cc28548121e9775b72e9fbc6ea6baf2ebf2e11a650ace454382e9ee75185a79e4e1e8cccb83f9987b3ffd946391d1724dee56532b60fc5e9c304dcffc8fd6d7c2638e87b8e0c89f227f28962fa9aba2ec7daeb5fc9a309d00ab4e8e0c4ab70bef20077f5d47794cef872f463a70f1c2cd99f50c6a176febcc741c9c1751e9892c73bf40be3b5471fb7d01fcb22397aae5dc2eb5f86bfb5d1ae5c85a384c362d1f9e58ad5840321e911bee8c449bd489bd07ff9c7442defde6ab9827fe8b20c4b105750d5be9fef585193b761faffb2a82ce4b535f8fe30c77b2ebf178dde7f0e484a4be4231e00a31dd514806505c1c46b3e6882fc31305073cf71b490a1e6eca614fee30c70485a97d470e1711e7759fedae6a25efc99d7a2c7dffe2fc7ffcd17be07d5ed178b2611152c82c69181fc751cf77d3b7fe8a93c7a9c04df6d7f1dd3d3e7fb2da6077bc637cf9b7c880e21e1cca517f0817da785997eb97c99bc08adccfa5610b78653c20a12888404470bfc896d4d03d2d9cf6396434126dd326a97733998f11e82ba88c456a1a897bf512aad9fca3500dcb2528128101a395e63b5bc6ffd24c069b8f5efc7de3710f5f458f48e279e9daf8011b60936c982df8733c5c275fec22222a7101f5c22c985ad1b890ba73a82fbaa697952833745d871d710b49bc5730a4189c90c14dbdcc1a0a49c3535a6cba9d394480ab004d2eed7acac25ec33c0eb3cecd59e98d8db11a1d84c15b03779ec0bcaabfbe04939211e48fc40244dd0499c3e075753e6159e0df8b6cdcdf595fde2531b193e435fe0fea9aec993d7f0b6d492c656904fc509f847516510e3109bef7f93e5c441845250ab4cb3b3d2cafb7c0d1ddc6990f33f94abd402c1755ea57a2996e1b774e5ab144b454742140c7243f8fbcaac21a2308baaf947f5971ded9372e0203b26b53c379d6fcc30e86de854320554b32e889bac7396b40561e7276de5c79d3c871f33878f984af500d76cc73229b39f2f6604cd5035d96dc396174d9d854461042fd80edd7ba511eb84f5bce64f05efebe22d3d274f4947b5a12a2002174ca5ccdcfbfff1064f612a49116e17d06b2332b310899e8e04c2ebc55e15523d411f7bc3249eab2d3d0ebb311dd86f9fcc5fe81ea109f8bdd57aa0030de1cfb89eb916cf9bd81e786e29bf627709d335a20bdfcb332a7bac7b5bed134b90e9e094ab1c2c654c7898a5ead3c352b313095b55ec91cde6aec6ba0d4643a65266cb22668dd9b8cd8bb333c8765ecad3a86bca291deeca48a15d7b24ebfa96954f699d41d1b624b03f55322c605b0d3f8f3066b79e53d2c43315e5cd14b0d8411a5378a7afc745c5974799a74e13c5500e2831a0e7353d91b0fb64a2e4f7cc3ca6d29f06f489827243b0299d19665a3fbc1e1a4e3922a7b83177e5cf012601c6c4bc460676ef8dbcc47ce367e4dcb2efd596f0ba98d688e198fdcf488c94f6fef27d368a419684b3aa1024f7c7c0d884aeae60f66996b998fa8b29dd71e46d7a2c6944426dcba89e9447d30afe444f69924c9cbf9986577d0b9929710928da1cff9a8b85cefdb79c1b21bb12c513119bf9694884c8eaefba81dd4893c93e0d97bb8b70ab0843e0d36a24d17747a7e7dc26db9bb61316f94113af354b21e46b608e7d6a57b3aaadb3402f68b8151cc740aa0eb10ee8da1e3003bfb004cf0132ed0289fe784d7c8af65ebce7d86ce1e12d438219b85389e7c67d727c9be6683a12871975e3785ed7ea43f3275a3b78b08c8ff8bd2cf4c2d3dbec2f39544dc726493ab3ef2536f313e6a77bb6d623d8e8e1b925035b53a66b429ef77111b22d3f9db082c9e24d5953a28d818bd47ff27b602ff680bf42f98461e12166a841f4e1227f83a97d0ba85f057257243dfec59ff6e8a16238188228f8d416be52ed655cb0f5b8d7ac508023a981cf238d385a66eb102647e6e2185bae0c4568c1efb09af0cea464cc2673eb0dd5263e473529a6b66e643a68bcbd5a15a0d817ca9a10997debfbc8bcd4bd0ccece7fed8b3d5ef0492dfe676c7bfbea2b52e792204566c96c39154b4a62f2c031cd0761a21ac84a8a9c694d53251b544315675a40e9b407f4807b8dcb229be9a54fdb4eb0a8e58ef6e83f64e60c5397ff2e62448ca933009c111b85c53b247456a8e0cfeb56f9f0f31db62cfddcb24cf35a54951a7724a5dea6139df116a6102239d2d6b2734e0b9762b3e0d11cbdb7ecdf3ddc8262504ac39e0fc33de223abea3e3bffff553220fd7c449afe7c0d88a5218d28b0ae7c597da4638503d427903917faaf9df0df0b526bbef8ca7427706644f8fa3e83610206378234a5605d68ab44f7549f7bc04bd3786f33948b60d25225c619da3fad7b76b38cde5bb24ffbc6f36eee4d57117037851707b10fd5b2345c786340c2156fb785fd1a24277bfb9a82f52be0c448104281cdf1dd4fc44bbc0ea535b918cebccba708f78637e2fc23e67849ca2da7055977fa38c8fbf2420b3d68df73d47f10afa87dcbe4315d8fca16bc62ec365f7ef8584d43be3cbadba65bbd11889596c90d8765e5f632487329acfd2192b74c4bbce73869f68da7e364b1d87cdeccc48547ee376fd39bfed6791e9df7fb7618b71342c74d4cf9706f9a4cc4c7daf4c59e5159eabde73f4db0c164ad5b5986d614bf8263ac728375e2a722c1db8ea82cb74aa312b5d85b66ea1fdf6bf2a6c8e781303f51d0d89995364e86d46b70f72baff39b3e822933376bfd511ff4fbd877ded65a629cb433e8cb1b313333bc0336ea17069d8c460c9dd54fbe16ecb198563e4aca3f98ed055befe295a58bfe05018819cb973a327ddc44c0536c1a8aa511ca8694549dcce404661bdbd14f915df2c6ebe782e73ef988a31b96a025608d021882b68244c841ef86217ed97146e3d59e84dbc61290cb312d4c20271f55f2a8931a4b1491113401ab6cbbb94e8a0151282eaf34eb423b31bff23745a752e1aed2fc57568ce222b8efec217ab499146b3741eb9433107137326b8c5d3411ce467fcb4fbad9971f5cab0334025f33a6d5eac4baf8caa953fd20418f3a08296ed1e9c69ad84f9f726c98465cfc0c440a3ea6b57fc0f8daf160dc557219709cab043432a9dc01de9f8bf4f551a1ab22d802d66793c887da0c079b3a2daf731cbaeb58cb648c6e350b3118bcb80b5be4fd7f2dee182271e7935c0466aad2d31a12f339c0d52029b5108d0702b9ee9aad2c1d0cda345408f90cdd2d60ae9bccceff4f921a8a323d3d5ac6af26e61db8cf7e8a0d8f00c907cedd730ed13a3182ed2871c1c9a2e49d40f5454eb101e9cd94b7a805120bd0e948d34bacac14f96d8e3dc6a262f3278cf3fdcb0e460618db29ce2df78e39e83d9c7773b3ee3f8e24f4e985e78ba3e307972d9fc277b0687365208ea4c1d38285bf1b1ebd6c386055c20145d8e6060d297c67962d049aca38828fcfe5bc8786c74cc5c2c21c0424839984708b7170cb78577aed3690e62041bd03748448f749d169cac92db3e24de44a5bf5f108c379599d42cd898235c907357437c2367167ca841ca4652ef32556f590475586821270b2cbded67fc0786905064d14c580608bce0255d33f21d2949fcf1de07eeb63ac3ecf8b9e8d632fe5baa3997d7c2233a9c37bce1c3052990fe6ec4f1a84fb037fb17a2f0ff6e90efdb52eaf07a0aedb8f3facda4d59fc12611e01a90f71f3657abdc33b0f7d3d02e772f32cc8037ee3935d6b32935830d69c034a1877bb73da3844a5e4a9f5fc6cc12692ba6eecae7c89bccdb462dc7c81edb0a65a97ab965777f8dd6bbed9d734cb36d2493d64012589bd6f529b157c893c866343f17bc87021110dac1ccdc560f257483b5a9f42ce5645f4b773fa84462d7227c85334834764c2e65d0c410a134b5c82e0aa4b35ebcd80987d907ed47ddc5fc9a3552e80bd0ab51a1201e2468e1455f3e7b1ca9b63c6f2dc1641065dfbfbda817b65e6553d74a42479739426c495dd81ad0ece43abd657f564f1ad5360222c8da00d1da0abd66c88176dd4e9ccfa113630606d7817883765665dd308e3ffb5a44a99f0561c2842e3b4e0cefb64b6b01a23f18e5f6b55c04d5b2202091eb47bf66bf19093e0392c6b0c16868cb8e698554ea7683c516a9e6ca7848de0018b77e31d86dd3f06256d0dac0312ab5bdcda836ab8e7cf663a01a2a1a2fd0cb7d5c5f1a8e462519e58642d1f4ceeb9afb76f59f7635fb051e116f555b1378a4432a0633ecf57368b993ffd94e14407e35f9711aa62fef293e824035ddfc3cd5354e21fc9576326ea79121ddd05e12a268064e07d0e023828f16fdb72920c5749765a32afe788067d0a16f8d9c09ae624b065d6cef8e79bcc44c02675fe54964a8236fce226ff020aa951bd64826571ea289017e424a53997be347341abfd865baab5c76fd44475f885329fc7457d2cd24c4bef6163c0b0d294905ca9f3569945a2bf191f72519a05948d7a60937c73628493b0afcb56e30bc0cb43a7eaf02f564dcc00b87a6f18d3372cf3d795b5082e9151e0854d067ecb439a02b17b352ec0374c31177da92308e8a294a00f2b70876d962f6fa30472e909aa6ca540627c651e453e8a3dc8be31fc86b78a76d527596768d9dc328ab584ba9c3a838b71683ccf914184f02c9b86595b556edc67e27d003ece8525105a4497b75b2afa1729b6b3cc5fbe8f03bc7adf08bea68d4f1d1f0691b3dccbc1dc52b44e9247326ac61ad3034e66d3cf1f648d0e1cb3cd89df5fa1dd0d1703be6c78093da98bad0c6f1a5632415cadb8ee7e146804d37f48136a81efe221432bde0a79a0b524c56db635c5dfe6220524a5e2028cd055397a26f85545c7eca12b78ca10faa0b2d88717032d7e816bfea16f0f16b589770f19b8fc850cd2e4e84f8717dfe2433fd774ff40c53f428eb7b89e4d52010334c1f9d27944070c42c64b59251c2eb6117f574bab20ae84404836b346d8391b25bf4236dad98b1b63a7e68ec0aef40502d4f8fc7261d7f63444b7622a10816899e8b8c770db00027133d1cf56716172b3f639b59a701b37af34dc76a7de4776ca77cf504ced0257c27a57e77f274532f4b217177aa9cf28b6bb5523adaea03985391a34f67f06edb10f13e83e7a38279b893db6647c8845a4c0259883577a83e4d3e1c945f044f3d1cf1e687369c3ad036ddddca3b6eeb42dab8ee7b9b81ac8f13750324d9583a1b8b5322b47cd4a040cc5d9f823fc517cc2e3e405aea619c281d02727987a7b134a15de2ff0b560c1d0791daf024011b7340df5da612c44e5eed676debec01f2080390883290a1ca257e103f15a8288c2db9e230f0b004600f6fcbc0b1755ceb073cafe3745497d4f8867d2d109856a73e8d16ed037e07fdeee6e3ab7c67e6a59713e8197ba7a7e8282b82e7a0f9d5ddb34e82c20a3bca7d42a3386c233825b5ecae0800d821066169f955c3effc34f0badefaca5cb16723644d00e4c3e3c564ee266c9c53a66a9d9c05dc2106b15f0e4876d42e342641401e4b8730f323aefc626b4af118df949e027c187f312f8240545fe6f7f14f15fb70388da8805f16d27abfae51cdc10071cbb678b26f6f4299ac1fc26a500c0e9c5827c737070880462100695918d3560ef30a3a41df5f9b433da349de06762e0507e14ddbbd0962c245dcc2b9a060bddd3f41aea6824e2a160b4ce4983e04ff88a1e524c56677d71305ebbea4387e46b28dcffbc20fc7db41a85ecb305fd5f204320f0182fe34bc02ff9100ffbac7e0a6a969b621b1486b9787d4e4ad0543bda6c5e43debc84408268df2b1828d14d0bcfcdab1bf52051ae32df0baef37ea77a0e311b0dc817146643c1b5eeffbe85ad49c757291895b08b65ddb39dae54bb1e0639fdc948440e1a792e7d12cc48bdc7f5bca4cc98f8ebf778de000e92bc5e805a709cd9cae0f9830be3597d545561d3ec418e3a8122188d250cccc578600b39b542ea3e1059c2b563486c897842a89b5196a1c35c480847eaea307fc1ea0ec38d904cb0224d2cb8f5d53afd32b917a4c7fea376030e6da56750540dcf6cb23d760149f7c16344a42f7607e097a3cd985e2b35fd77afe22e04fdc5b0f1c2e483e6b7a05b675c9f6035e29723934d60f050c43d381d328247a17829cf025431b8e7c803561508ebb35091b790b72fa5539927a21ad090e2df510662b897307a424cd380cd252f3f231326bcef276adb13f3d52e461ecfefa94ee89fb3473afbb62b0969f73ffb99d67b21444b644e207839278c6598a96dd5fbc1a185e1abb6395ff4927d14b707a2f1d3faf58f85ddf6ecf5329d8561f814c51de8f6c1f19e07f32bf9323ac5fe6f5bace5b476c4ae403085110bd2ad0585b891208a40b54c1fcb84d33d8cc3d9c47cdce5ae1595c4f80007cf4b1df3b644a123076d9adfe65f2d6a1b22393e3d01733a7185b04cc5f8b6204973269affa3494a963efb2dd603e7950d6056610685079e5d95db507a5c935cd306f02398d1564103613cfafc2a0ecdf7f793f0c21113d2686b6362a6e40f22773b24009ab6e91ab26964612cda4a36bd20cc1e9615cd0f73422a2148ab3116537ecb468e4371b3b65c2042d5b8778946d00c8ed0f8ec2bf70e329b66bf0fd1679d88e35d1c72361e3a30495efc0ee9712edfc27f0b6d6fe539bdecd1d2ed3f40e74792e74ef74ee3c8704ca4347af6e0f44d7a622aa6c1bba98f4d14643754156300cb84fff44f40b36835090dd16e719fc99e694b982988d8f24e9c3a8dcc088d95a7862d863c426fa48724bb0b90f8f78096b59735d7ffd708754e825fe405d3a71c2dc42eebd6099e514dccbdc75ac613c194ac9f0602280a83f98a7563bdb7ac498ea6d024d28719dc3ba132f4a5087a1b8d5d0dfb10d837a17150d1877b87eb3689fb6bd60d373111ddfc6a434983b6a5c0533ad4195359510df316f64046c7117e19b31685e6c60d4d875ce1f216280b00a546b19307ad0e381d007783e58b793a3b5b0e6406c992d0801d0df6c99ea6d6d771d9256ef949b507887a923bde54b2eef110861d33c1558870321d30100af179b872abb3c207d311b7759c32ad6d06daeef3280264afd14814569eb10fa9a18a25b78ef0e2aabfe2660403075a0c9a1c6fe3cf9fe82d8dad96ffd3f407cebc7ed4704c8092e5a8d95cc2e438cc606ac1e092d6ef72758c2d60017803caf0ad413bebd45eda701de08717c768da7b440b433d42d04dd0f6f973df16506a246b2032cf24e01e0826a0262da609b87914d4368bb16ab0c35c16c8cfe3a3cc738ef4e3a56a810c8c62cdc40bb121da1aae6c911907e75f42cd5e0a756212135650e0ead81f63ac5f8c521e522d86f0ce45eb8485f9281bb138b93430395f5e5e7db556b46dabfd0b15a9a47f75d65264f5123ab95422c8e5f8ccfbb55d481f8532eeacedc4f45d86da88a31ae93a0230cd3e45ea2e91624eaa5bc3b63d74f868be2fdedd83c1fdcd24f5c9407e7eecf780c5bc74701b792c788a146dd1107348c8f4cb69a39a93081361854d99546261afa9f2e7cdcea7e3e361063ec8f54e47bfb5cb382690b5036d20e8127437e17053ae7dd9ef5f302e3ac9dadcc197e37a346b3845d95e50e2f023fb184c9948a2bd441d02d840b3baa551082bc50f6c2f5591eb2f94ccf04e2e92aa970d2a53ec382f09c3841f15452f331062e3a5041d89eaca6464d24171c394f3f568962cb119a292da9d6d0ebc0836bc6a791260feedd878947863fc2f30bdb908a479091a50f70cb363740add9b19a26056101634e84226c971caab804dda3fc9475774245ba63453bfc01d3a1ea4771003fbac56a7d9ed25c1032ad0a72d71490e9c0f1eb888c04ca2446af89f6debaa211f1cba467c66f9b6a7f4f541587414fa11df2593eaec07e4ff0702e3716b723e172a41a4e58738019e2c0c22bb8b0daa92370a6c2533899dcda7685b4878e452d22c3a679a60e4e8be9e9c57eacd51d914a3dcd28aacc2b79b2e19173d3bfbc47347ad9f79b704e82b4bb1790546763ebcc0e79965aa6b207b86922d1b24279c28ba44742bee3892b74bad562fef0477547190f8af031c33a1a2a32dc4de3cbd3ba7fa0141ec0d55fe0ddc5f23d423488e13811d9b7b03356a9ee70d1e919252d542f4534ad0836817c53a76ed9dc4d45980654952305b73a36ee7964e7f94c7f33c22ae2e9d385505ea0b89fde8015c7a687840029af9eda6b109a4890a5a8ee18842210ba13602811fbaed726eea2d95cdd7834bc9df1db190db964d058b1f985ceb10b50f94fe1a7e65747bbd457b9dff8f80eb00539a7336d2b681619eedf33a09e5f4f96ed3fe12c6e93a7e259386865e6bb8d0778ede5c08c95939e6958adc40eafd8189cfffb2c65f99f4c9344bd7b29e470f32c874fd102b3dccd6bcca3e9c191ba38e3d2c91a0801a2032907f7c2c920085ba8a71b7b9939a0961dc9f796c0187cdbd07919eee538f47a6bddc982cd49c4ffd129e76933de8e158f44e1353c704c26e42891897f58cc8b2349a67859289c30e9852c974c4030d398932ff5a1cda80abaabba6ce93ef20d8d8392d4a0a3e6c7121c9cc24190ab68dcc762df4015eef827acccf11f554ceb6594ac7c2cb6e51ec7c03c3e163b942a750bfc7f4f1539c33073c142f0b1be9a69965399411dd3f6c4df9f5d9912eb3ed09e1191e3093dc1496e88ecd03654e65bc1ecb14ed14a60ebbc913cef32bff7f8f063f43a242e4b3402afca766719d56fd5325b3f1788d49b7fa3742d5e3d1b0c8c7a1ad9ef0100035f7d10a50ae442e4d2d9c6c8417fdd3cb3919b9a2bed815238e33b1161a69aec9ca393a875fd823e8ce9221a276e2b6c13b3427167c99f768b31db70f8f56648071e73e257eaed4756bcf9ef34286b3661a23f93f41eaff6e00b6070257eb736ef34aca3e06002ff8ebfe27ef0f3d65411087707822f40139e3223cc1cad7af9dd21afc0a6632e0e87e838fc3c112a695e1634eccf67dea9e761fcb4c24f0a7ffdf576b1b1c1d5c6734a50b3621a1768330275714d8ee24e91dc05f7e6871fbf2a20b1a7346fbcffb614e251bfd8fef687dfff77d06dea4d1e09ef2fcdbeebe6ffd56f4f9c84ea71e97255f819a5ce34d406435f24d75a1e1f2454410768a5a780d6cda24647a5f968b418c5739aea413e21c8739680824e1cb4f2e23feb5c30abe397e0e0da979fe79918f4bbecee5ebde3df7ec169ff1001f6c8a8410eb5c146d2caa3d36e11c7ae20a651ff4c49999c0c76e19991ef4ebb247fe84970837c9fef1752cf4da64df791adee734ccd1703b1967cda82c63dac5979609062423bac67a1707e7dee077330c40e557b5dfedcc785a3621cc2fd423cce8928a314575b0e3c4765335e778be730f55decab94424099b482cfc29def59c8a7dd88d6799a77390c2fa3af9a6d7d60461a26be36525d32ea93333af46bcd989f50878685f61081e87d42ef12d8c8572eac67ec459d29fdcb1c19ce4429163f726b4d86de1cea274d0084dad4b33d7b1c09541fc568b5444593207912ee3023feffecf97234473aba21b7232e6a497f003be931e5542ab8932dbb9450515ce2daee75b64cdc541981cc18baf1dfeedb6d3c76b00d84f9aaefab307b02334e24f24124432ba8ca8d32b6a51e62bcdaf707689bf170571f2e647c8e020d5a7b0584127a37f91bd0577dee6cd8ce19ca30d65a629937811977d423b849c5be4b3871194d13d1c0030bffd4091944b0a488022c9de8898e1aef743643b1f9913d2c2ab610e470fc6bb314b7a80763ed6ee8f8a585721fb1405f6d0c6472c96c81ed766bd466729178dbd1808002445f9ada8057f9a205ff6d03c2abc99b34f9afec32d14342f6343a02656981d58fb747a3b75b15ad7eb40ddf5d366e548869d231f900e85fd774feafe173e23977d2211692c3a9b67112808758cb1c5a6003548a0d1dfca9781e5a9086e9c53be47ae49a18d2bd0ca12306c2ace63d73dc5b9c2948992d06b900df6206930ba312049a632877b351eb4d9846f5de4c543aea061be8bc207885324a38547e7f3d59349d1ec99162d72b78372230daf2a88bd5458272240a729c737d4da7e4779e26221f1b77df5a7cec0b8b205dbff86f71732eab9423b990f2900a7f1d7420bcc7ad82fed3c1b131fac61c6aff72897c9d01cbc8e3e298a00e480e129cc344a236a38bc6e2616df6abae7c1523bc294e4853441792d57728aa18e234c195082b140f8b73d751f18e209a04b2d246df6e50e78c19e752146d54174a780414bfcd8ac2722d1b642df67df3126720a5e47f9f3749f790db51967dd570d05a50559f8f2308532720ed24d2da0840cdf964b575daf006cb5ed43f0f4d53c03f0962c7ee926d6dc18308d79b6956489fa64f7ecf84e123eeecd35f91fe55b3d8a62828db98ac44a27d72186deeee284d268d951fb1a5413bba5d9885737b54b19fb039a29b2e493bd6177cb8b8b6cffb5d130b4c9653f1ee3046de38b05db5966be41298d0179713bd666bdc720a4892d6656f8abf3d8b0f072d070649f09080f687f63c1ed34b7384c3e6b0bf6c18807109f1cf2fa67f3bef9d16c1ea1c6bff3498f6492b1267170f56c789b957ae4561f3d123af3600beafe857d945e7c8433463dc1e965b03ae85109ce253d331dfa4e3332bbf5d443c29d1936e7fd37c0bf41226c40c0d4c3f8d923f16cb9c57db5f1ebdcefcade110f8b40406d8e4f63d89b86ef0a199d8e21b224d3394322833c95ce1c12c20c08dfe018b4c1e5dd42c29f953a1f6734af19240f4632d01bd12c897ab7af67a58e7f75430a8a4fe6ecab10b4e8bf556e4c82f1bbfbf875fb5986293f516c9fecc4cec5bc439ebfd7e16eb935f111e5eb20012fd5b9f0f9033421c1b6836560065d44084758f3bebf9a3db94e3922fd9a1e4d3fe7f334225864bb23f7b9a8597bc0e627669a8e7a748c09b83ee7b26b630eebf43485b984f6fd7865ce6359f7623d119bf6e645d34e58e2fc7dfc1c1d4baf8c543a57ead500ce6d6a38657585975d34cdd9bfea4ea6b2b46243545f914f8f08d8c1e1e15d3b0a6884813e0947ce2a3a53c628b9fe87e509a0150f32cbe9d2e8b056c2429538326e4bfb499ddc79dbc203f1fff4492d53b02eeb9320ef3195dd7994e1f8c1f293c23a76a3fb13fce83dab58ec091e667b16cc1c557abfba1adbc852abdb1960476099d3b01adadcb883c1023492aae49404338730b75e4834e12c3a3573219da09d93a296ae4f6b7f5b127dcd245cf2549c714a24ba6f411373e1ed0be7516296514a96c6ee3c3ef0a4de11b38ba7c6cf9af282cc9c45b69803e45252a35c5c4cc950bdb4b1764a371a103a0454c7d43a1f60a2ae90b246f9023a2b642382bed9b0c17342974c85778f0fc67fe577bf8d1f944fb70d7fdbc589547c5ca4221772a83e7636c87e29b9445d1186e9b8ad585f1df53b2c92f788251689fe36e5564806ee450c36f1280720d6147c027f2fcc715ebc7ddacd1a016730b03f637d519b31a17d691d0470eae8bd36f944f21317e1bd2cf1c27a8b00bd7b9040b88341dcab28c085564b7a37b6f9e9faa9416db9d1e45f25056c49b8f81520f0382ba1ff8b564f2b0163221e13b54bbdb745c8081cbf9d5a6d94961862696e973f84a009a309e5b6c4dde339dca1df35a2d7d09273e32b59fab9863c03685cbd98454817f395cb899b8e4a0650990d3bd7585807853f12c26e50e1d04168efe08843b49fe8331c15fcb0b7df197be691182aab05bd0de73f9b45fe874654213e93079b68b5515a7db956066df092ecbdb50856aa976e3434e7e0c6f93b478202574555744ad7a67412f8205e6fb1fa7001d2b8a78fdfd01455303b797b450d895829a4d5a2ba62b02a1699a8853e8ceff64576084917b0b9bd90a708d8c22a469a245c03c9c4e8b4d608535eec1c0a8d28c9d379f8908c7a87c2e3792c55a697ceaa1530f66e05aacb55abd2c5e8c4ece658bcbc22a63e6378c3b129887dca929ae39155d9d2a9085ecd049f5514f8eaee2a50215fd10ad34070b4698b316dc88a65f651acaa023288aaf4644f456c886a896ad93a369334ca22e6370f1ed929d48417e0aad3612bc022e0ffb52a21d1fde6602e1f59da088ee4558519551150a59fb4baa4c05bc67222bea465a8cda8e81f897d27dd35dc091c96972e69f0e0744932bfa36816796d83262378ba47ceb4e25915c68eb21d1d56840d6fccc3c681035d0a16d31e1581e10ac338f0db408aa5b29fd4b0ad1b31536c5a0995a976bb165d6ac0f90be033ba95716b36a7482315a9cc79e97827b1abc28dd232c2156f70c4d1a3f1e7b18b5ed02ebffaf7073bb015020725a9e26fd291d43a3a18f2800f2e61b1f38e9b76f9f062a093674dc951eea14732d2d2ac93fe0ebbf79f5882a7aca7ba57e0290a1ff0a15c5a1cacaa78d6b2a56bae3b79a1becf7f837d8e4cf9ab559e08fd3c8ec1f34e48ff4376525defefbf46a85f2325c913adedc433e2e7a4078bc5e2fe9d90b6f62f781a914127744444b7ba0bd67e38b03f38eb4c50fd659e75f6c0983368ffece99a2392fc42e23e8f3b173d7922ef3c1eace06bb8748c0aa13adfc19b2953e196aab2b7834dfdd04f0520c03550bcf6df4ff5bdfb7ce30adbb27adfa0ccd0e1d6895745a21682d5fbe0ad39f5689ececa7d1bdfc8c1b1adb9286a6f0e9793671841244b76e723e94216e9a4ee6f8d2f42843eadcddf36912504bde40e683a38cbf970af2d4183f1c78f49d92b364324dc35b0c75c8cc00bcd02b8f818ec91e1f89df735f933e4ff81fd7c2cdbafdbdfefcb6d2467b0b5910aaa84a051780cbddf3d5fd52910d31be47256e5be39e40fbac5965af40d199210a9f1b7e81ce6c47a4f3b6427ded880db6007a2bedcf66b1ba6a7710dfcd079f5176a00fccc25b12c2a66c371a271710c3dc70cef254c0c341daccc062dc7800570be1c12b082bd63d4c1f2ad7cdb1f08b5a30e1b8973ff18040cbf1320f0d0e95b564fcc94dd68d97a455e464e69c1062b85679623266e3183c94e06eabfc4332d634e727a0038e59109ba347ddee28c068d74134992420d2caacc2c1bb8cf0d8f14dcf8c930d851b08ef59fd13e3ca3c2466cd912a0091d2bceae98f102f065a8566b5068b2b1f5da2edc7406d58ef240f780b45448d432d8c780d68f6d3e0b11a2c07fd6859804c8e28ad5342c666102510082c025e0238991920be52b21a3356aca954bd6eb9e39318701395325c5930271206a7b6871de2a5c37037e45e07ad5c55624f14416063c160012a0817da1134829299e3e370e3181a17c6054ffc56ccf902c36a8dae8d5c0fb6e9ce87d395963012805995e43275268ea440accf2617620e7f14573de637b27ecfd117cc1e1541bc859cbab0158238c5b54da9561aaba7d1875a62264b7650de83b32e588c3f0d0716acb3a1ce6e6cae2a080bbbd4b3e5b3609234c41de6681ccf7f04eef61c9030cb22f65473feb7fc878a5f7fd83475dd2f4b3ed77815ac595867cdcf9a9060b71672024ae3609cadd62d5cdc24483325c58e1ad90f42f012adeb74eacdc1e8021c7470fbf122618bad4c88876ecabe808d531a85de449a8271581be4de728f73f02db9adc53e64d674b90ad61994a4dc4eb16d5e3eb8c20e997247413a366156a7a4edafe662c3c3c0801fca05799c4f878301ab0e9c9fa6cd40b3e092b26788189c625e59e2f69273501502c1a886cb454180812a93f269addf13657a67e282b59e06c27a0618c129497386c99379edd48c6b8a8a8ffbe982ed66f201184e1fa0d8141168211ef4568c4c4720404c893fffe02f92879edc8ceca3bcc7fb6bd62cc4368fd2aeeee7f88f248694e8e7afc4a5c0f5bf8d61625ed227a1b1a0b9e9358b1dcf92f2138fd483127ea5046888b389201555cee98439f08df19745a69e9792057a21b1f4e75e447569916d1301505644f0a8510e970fcf3427cf22ce6f28471d88cd6bce768ca7f4d0d449316b9581221ba501aa5d9fb58fe4d84bb068c8f5f20af2e6fe3c0a3046199a5ec2ef5d6486d7355a76cb5f8790b3415c0931ca7b32ca065e36174280a6ce2ddc919951a7464ac6a4db61ff61de1f8e6c89eb23ded61bf7ddcd32a4fc7db45d0d9891684cb414f759961ad5a41ad3bb14186261fced6feda0479b05bd99a78d639a3066df1f5b08dbeb0c9c27da8f7744e3d98b9d4082b17b10a5f0593119e0cc63c3cb48e253636ee70b3a84faf0876ef0b387670e641b5fd2577fe838c920e2e9b9cb98ac698c832c9fd54f5fef3fff77c06c41cd73346751d4a7c70fe5a4e41a05cbf9bf8fa4edebe16a52c4c11b2416d30537691bfeac03b28c85341cff57c7fdb21bb1858d14aea4e4a0ebd69f1df88770e2dcfa40450ecf8fa3951eebbfec871d043295c0173ce751af4e0650e9842a69f58b0a1a0a1e795cace27e05a821cf4dcef531d31d0ad20f14c75352f6c4e1af3d57ad52fd4f57d52992e2ca6bedf1a7d7a8e97ce59fccfc40976264c844f881b0cfa9c107f351ef2968e53f8c84ec5db6e40adce48a63ea09bcdced80cdd57427f643e15e8f862bb02adf726031fa2653ddfa1a30f9af08abff25da4b45bb8a122dd3cde29cdbe1f6b0c24b32a94fe483420c91e8c130fffcef401fe8f9ef0451036638f6650a337da5bf11d1237f8216be2b09f3c233672c1f87a57ee27fbccd3e828b72172c5f2872dc487665538c96e1dd72ff394598f69e5896dd3b81946ccbd295032d9815f83a0d026cab3c541a1594bdd3e7818b743047817e7dc11d50b0d01751be0525324fe270d7e917acb042f3a35ccdcf27b9497a9a4218908c3ba264e88b02cd43e6b8938f3c13f03b02047125f5f327d0c6e2125eef895aa3d7e66013556a4c56cf3494f20a5a6160048de5ff8e33f605367c062c23f17ce7f489e6d517ece617e1883cac7730f69baba2760b71484a2723a5cf6aedbe68a33ddc3ef7791279d16b785e094d6ffbedb998f54fc060699a373c7dedaeccbaff5c696ee854b6556e04505bfa761079b2c0cad0ab2cafbac49774a7050348adce7584e07df446ee95aa46ef26a6138641b099895f97c90120d3320d098259e62c2ece5025322272071f92a95161fccba3b73d18f0485d3ac91bec90df3b30dbfa6410bf50aa7e74364bc4f71797cfbc681886eaa0621159c0707262a705c8f42cbbd165fe83d4aa3ef8686dc3a603e7c4d192587fa809a7c19cedf30cb51ee58875b508918bc411dc98ff163c9d7ab2f12403f440f876fc5d14ae2cb624a2e7f11c15fa9f49105af3694bc88fe1b3e49997df81e58fb997d339fbbad324e626a583282279cdb5daf409bbeccbc080f91cfb4c576722fed3bf574d918f7846d857245fc73457e6532a1cf991f0c9a41429c3cd33696396a092f4f5aa84ee710d89e9020cc064c670ec4186b427f2c1e6cb6555d4822578236e48d70ac0ac04ef7bdd330ace409a38843ea2e4ace31979df7eba9fc74c35c149c7c6a88b357b92c1b75d59d512013741b45969c54bfefb89f7cff1c35d858f0f1c2a2519b46e33937f56263f6b9ea349760dadf7993966e557cde75b29ee0cfba9d3d7bdc41aa9cf9541695808b3c7833d3aab16352fd8b749e9bd5c457edbac0f92d4cf71a8d96b47682a78edaa0d467ebb9f355e6ba5e65f9c7ae668e30b29dd089ded68f6b2df10fbbe472617596fdda6c8e00e664348a25d8ae7cc4af4c7fb7ff7368f3b1ec0cce33201ad74a300c39067802f3a7669db71d875bc3afe73d429f74eb2cde3d2029fc82e867610dcb487ad1df03d3a876e38c496bed99c4bfb9eb321ee7ca7c8590839b66fc3a4ec78c335bd79153afc23b0a0978f052beb25d714aa11caacf44d80d0b8b97741b5bb84406b7a69c8d57acb06f0f064f9aecc4de8a2c2b95f1d8b8b508e9da3ef637028582f5baa7411be43cd8b143887693c4d2b0c7ca28b3efbf27bcbdcf19be83a27921ad519a6e411e9970957d04374d9d60f8f65774d1a760a9c1eef61ae07a425e66ca735c7cd0ba663982e23600c8f8e287586cd41f1a886d5c21b03a283976332da9781a3ff87885cd539b0077701406a6d62e6515da9e2a048491f05c48a49f0d0436c6a10b36708bcfe0e2df91f851d7343b05ead9dcceefab81dc74432b84687ffcade5b3a5d3ba8744fa58d2fdcb4a366191ad292ae840b9a71855db2c1c3fc2a88ca0cffbcf11cc12ff71192b37b5ac15cb02a1b8247516c52ec9e7e1a0bb82aea480619518057c8ac85799c60c7ac8fd8ec3eb611a467c273ecd9108a56d6029db0420107618de084edc93d09c83b6232f5434949898ae9f826433eb3fbbed52b1509bb48cc084c5acad143b0d62c03953bb0f0a17b7e5f7e7c63e538cb505172b98fff2e166ceb5fcc525a9866879c87dae3be5ab65e3d8d5779da23cabe64ccdeec47d382475412552e0541d460bb19a65a2356f27acc394d441341416ffbf8572018183ac46cd1280022115bb1d51b776c61e005559738821c67226b73beccbdd4b6ef9eaa10df43f76d1d4489c59eac32c2c6977ef2157f84ff7a1d719fb681090cac6702e9d914d36aa8d6b5f0cd2e6378bd83d943bbe8376575b3cd78a7ff63b4424e9a1f7ae415048ecb6202aeb020011108fbebde7cf001c03300ca0135a56044f35a84502ad4e68082de90e6006ef0f5e8f0d1e6480d4025696375cc8dc4e9fed3799e21edd5138d627152ccf01e411dca1f8a83deac5df4ae736aedeb315b8cff43add3ebc97408300ef9c59d20277f77a5b023b79f6979c1f13f8090f613de7b6869cf0366d9cc7fa621b1ea57a83fd090ef76c3daea76c43dea3c9f91b78f84da99882f6db30dc984856055eabcc486a2a92919bf9c9e261a2ae020f53d35c8397e8b5d7fc5d3534f5aa68ce4de91dc068d8fee3898c95bf568b4eb06445d9e806805570ddf189d08211827e90559cb7d4d2dd2b9ed79a2363cc42c151f3077a339b3e2b5512316f6f3e4a30921af1d37ef4c42e1b9888b700fba6ebd4c7483dcbd6ff67fd50fecce49f1158149a069dbf459618efb2d401fa8109bc8a305dae68341ecd47146d2345df8f70dade6e8ac94f78d7b746e660a1f93fc6bd68b288970c507fec3cf080a66f8b7e45ce19bb579a6cd4ecbf97976770074c45be6f7b3c9fd32caff7bca21d921ea418cf19fecfd45d2ec28f8dd8bf4a4485e4e16f07635cc1ff84a0a0baf69aff2f6df0e27aaa28e13add852b72f69979171b47ecc62669807c24689ef34caa5e960c56b802be3338cd6f81b781918f17d670d4ed66358fcc0bf4341f8ac9327f340e67e400886ef9ba03330546d586b71068bcd17241d7270886caecdd8db48b953c1a2a9d4e25bc696684801413a57993883018f478c4838160f4b193bbb62b401cc4f9b35e8388aace39f82be8a9cd704033a7c68c657bb1034802ec60969e1c3f11963c37473c68a6eff74dbddb4e5bcd8bcd8b00f8b0f0e4b8feacbcf7b51bc5ab13675e636dfaacd39606b38f1c24cae8765a027b26dd44da7ef872c20bd0d36e8559f372c6dce3ad666c805258f92336b79cbd96340710e6b1916d0f391804c9846b8860eace1a39cde73784533ccddc1be5700c608f21165eff24fcafe7069f08fdaa371fa84508bc1ce1d89c1c2beeed807e77603e7716dd0cc9824d07c00c829d82eb0da413666f2e1b0eca2ec4ae1a36c2dc6672f0b2ef442e5c0b18ffaa917fdc17d56ceb3512cca352d659dbf9b8629d292cc1a7a630c2648b0998e1b3c3b9bc169a521a614138d89f579f4e7c2714a4f57f57e38730707ef9516f753130d44403af3a277cf413dc3f762aeadb0c918fb1896acfb4c189cec9c36b4671d8803c5be4f1cc12d1c6983e95d8f10509c1f9a61b491ae689195987e856931eb384db3e9688029d3229f7fdb2f27e092a098805cb6e1a2323a63ff6c58f370fbcaac70a1daaadde1c5bc1eb3feb0fd6e68e44fa0280a9897cda9798235bc188622bddeaa401af18f60e2e9525250db8c7e56dc54cf00f4abdbb9a71e00cec93505a1285fdbbc5187567f5acfd81e5cf8173532db56da124a29938b7a60aff8fed7f4bdff67148cb38c6ce416e21c36d0398a1455cd037f537fcae49fa79de829905732728bb1ce510cefc1cd6cb389fb3e35627ad3767e89c03bd2ab8da14c69f08d76e7ce7bb97d941dfdef5061746b857d9993f835f9e96075ef911d65d05cd3cd09419c0f2efb7d9f05ee94528b1cf6006f30158e70a751bac1fc0e9c60c03c231ca8f8f24e438d3a3f3e2b39e6795a452b6d870c0b1f114ed9f5c61c267c4a377600b301b50cd29d29c585b386f9f7439b375e6876d44814710c1e2961aea3e2d23f6bee6077d02b6494e67003cde03953666a98f259340f20c7bbda9d183eca7e0eccba974474b59f00fda4dc586bdf7c3f330fa1a60464adcf296a057e58d090a406253483762ffc07996fb9ac58672030d46deea411067d60afa0aa30082949d64497def516a58d0e490c5cbc86f11d3042938f47f85cbc7ab6fbdffb418fef709f5e52a25cd0ebc5552b1ee1fbc81d0dc764b3f87d06b02e49043395e7ce3fd95393038f3334b41dc55e0ccd7cbcd4d9af5932f58ca0c3ef9d34a670956596bfc06fa066b0a1f2514c4d2f8c228a17c7ae2001c967b200d1ad2dd1f96cffa2edd21836bb2d4a7effba7c99557e14e589f79d6679eca9682f1ad1d2a502b85e6a682f3baaf030bc79814dd5cfb23a65a6cf76895f992fbd935f4d3832a668799d9c55ff087c8f07cb4faa8446f164ba5868164d647f95818287bc120077f3704d6a92257ab6947f809c13bf407ea1f26423f41dd980630610e391b6463c8076c1474e267688f1dd068b5a8563bf7b465d39d8ec1ff8f3a04e0ffdb4fe1612ade3cf00abd10010af1570a6c690eefbfaf256ee7fe32d5c6489f9796bdc46ef0d5cbe7728e204a234d273060f61c74b0219cbe5f3d8da244412230276db2585e4839d71f58c2d0ae270c02b9503a1ddd54aded0afb711f866c0f46a4e62f184104eafa95e47872f3b482b3d35beb1f62fb1a83d35440b05395d0bed173b63fbe4b554f8ae7dedfaf9b0c4a415520446e8a6d93b55ec9c418a45dcc9ac5850b2105d813b8cb335e6419e2b2e1b70cb20c928cafe61c73da6d28ac82316c43db0cb004c52a833b51e6fac2a23c4f88ec53fbe0a4ad71e6e6729aad5070fdc393ed6058b627b4b42f407c07ecf72ab91c237b6345136849661a57ae89b3ca933c68dcb8c5bd0a549ed900c49c0086bd60c3ab7f5379ff5df1148f98e64ae1ad1c24cf0e6fae5ffd9eb852a718df05ee56dac13c675092d7c664d98641c83d45c39c913f9b063670b5dcc9c5adda2103bca43e3b2e36db3d3034056e672c5fd5325e193acd69dc82c58b366769484d6fc2efefa31733418de6b12c725d15277a975623540f84d409405441ceb02a3f84108e8b17712871e22c16243300b42462384f391027f3e03955f4cfd2dcdbad39464a647a90755dcca10644858434f2a12fba3855200a6d8ddee54fe960e70195f3b20f5107e4a1be91eb88f996167dc6e232031b7bcbc85aea537d5907c2c2ac0fb13037b96baae283f6e3577dec72e23adf2de724ac59f52d44ecddc1b6fdac900cfa7528c8371e88296364d2a02c585638f1c759d942493072717e875bd3accd7c5b431045a9ea9900b9db2f06d2a04bda0088f73817ed04b7be29370439d2da35708e2898bc5d1e8434a8b4b012d971087269393e6fd0945ba1ebcd4c687c8ca50eed0767707f7c8b979ec26d2eb1f05620381cc40c537248f49b2785f133cb86d397b8257640dffc276e9462cfd1dd4233f7a95cf01293460543bbb6342ae6c798b95c94838a0bf01ea961453bb899edb63f59e6aaccaadcd2bc98bc9fb30166786921e809f45be7fdded8f031efaf70caa77b06b6882868ae0474c4ffdf190f3b364e3ac4a6fd9f9c1bc2274bd7232c10e004bc03247390412130923c92e5c3dbbd13cd8f8d4598ea616448e8dd4f8195027c241ad34a23ce720e740fd702af0cab783832304b91f2c2ddd14d68cb07c56eb1384768cdf40fc68b55a8eda7e4c05d89475419402b1c3faa212fcb3dcaf9705f55717b88629d5bc7dc7ec3b4b82a734fb62eae974ea7ec1e939372d3fd6843bf3ae60c6fddcc7953a769f7c28766dd1a9039caa2b6fbc75d40b75d87c5c1fb91bbdb8db5000978ce03f7c78aea767600cdc74ea6ae8bb8899979a6b513ef5add17b2c4aef417bf8ef80527fb0cccfd8173f562c66603f99857a2d572bf5b38b7615900ff334b8c9f717c05a30a041b31bfacb9008957f44679bdf2e8de7a12c28739e0114fd40ba21db041860f5686f40a2817b86984f6095d4c63e513550fe0610ea3be5880c43d8c48740ec34b0389a0aa9507f10c7c5640a1e85c852ee202a3dc9546ea9531e90b25c14e3e0b16709497e9ecf5888ca573b30f9f4e5a4f4405fd47fd3a6cfe3410ce724d1baf3117a5b6c8ccee50aa282b8e1b745dfa940e07fc8a8af4d2107f3d808309822774a502a8c774d0ae71b19a077bd704211756babcda608e0d080da536d642428221ed66d949b4d390b44eecb73a7ddb30c66a11f7717f70800fbd11bda5db75cffd68c001d2e7b14fcbae6475142fb33ed76a699ae0c5c2ae54f8c2b25a125d1936e9d707b0c24dfbd62579750d0d1d3c0a92c991892c88caf91ee918e458fb27e1e2fe6b462c873d84e37983fb810cd76204e8d328759a1327456b38336c22e0f34b468807ca5fc79946337fafcb87b06ae8dd93f44bd37771d3eb805d997e9e66cffad20ec9390d31c7d9335c652fb9c195d8f7708b7d3c0f394f828e25f5a653f6ef00d3eac410f65523a9448c30b9f7c8a7752a078ea248be98036769a119fc97909180385d6dd0b431add4d463816ffbc5b72cc680d2b859491499cc680474ad490b7e030ad92e20bfa2003d6f2e5614304cbd4acff73a3565a6afc5e832f9c654a53c645eb08a7ef13a635d5402fc780ac0dc541f1c593a3ce01e5b09cf93d664215400d3fa3f153c44f47e50ef988c73b4abde12e46d3b7b9197b6353204f19d91a309444a528c9937361dbf0f4df64a1e2fbd65ee327cdf5a9bec94996d30700aa5ffb25d664569f736d85cedff8d52c01f623a3f08b6160a3c6ae77734a1a098aee24e2741c28e010788f0042dec0653dadf42e945ae4ad1a18a5b44eb0335deaab18c19d04060dc417ce632aec07f8c665d8c7f40cb0398b2ad685483051c50fd7c580003130af0f687528f83cad622f55ee82d20de0f0121d0eef55d3cf194d91c074fce47e1e9395e4741021b2218996ac9ff71d463a0f083d3a013d61fcc7eb3efb5f915caf4e7af380fa968448f2f00841d904ef2422db4794771c33aae3105f6c9c4176480313f6083cc9357d424af6e74cc213b8186314a3c6020ad52a825ce16027342e446f59e58c7055633d468e1c6d4d578af479390d9c4bb7707ff4cefe279125a3613fed160f8dcff7aa44776fcc6d3323e38842910ea3497af7e54884712f4fecdc356f63752ecb27aa6be4a6ec6380a2e659be18d4f68d4d9fed9e5a8789413c52171b4512be72c62b9d7ecffce452a63ce3dbb6ffe7274b4ac0732cd900e281cdcd95b5410f126a3f6b0bf1fac1661da073b5d55c5423b6f855ff562ce88c0e48b523dcae35f47ec573b5f4d9a168bd469eb9c5eacf9f6b05743ffc6d643082cccf52cc3a94a793a844fe40da8a768c240b82f78310b1a03c5bbf230ffe3646378690d4687e4f30fc06f5310a1027e570be311b8669987c9257ef5eb7e7bc6850fe0295315275e6a37aafa8b1e2e5f93dfb46dd10b43f4bbf9141b116275f01556668f6c3000d3456f49cec0d7fe65a1e113d5893f0848b0da91b3f1208608d0452362081c5dce062d3e7c303b0b40b26c67c1a64304e8e56e1b921f7557650bad38e59faa5c9d741ae8e1fbf504c067f8b1a4071169c77a23e610dee5d87e52e3f7f2cdc9889b928ef06e4e2a78a1785ce1c3d4fae09febdec70c1fde4bc45c1530a4d106cf83b7c7b31d8b7e1f318520ffab2d78b3a68d7f0d28721c373606be86b8ed81b8e7b0dc0b3d5e51bd3b9a10f1947e31ce1514c95753893f7dff997e8f1087993118763012ee3fbca81edb1d72c413a856f65eb13d7613b2be67efd60bee9022b52cbef3bfcfa3539c987d7232770f142df7bfc557b977dfc157cc3be421948cbd6c91fbff204404172481d9d8837f127e7b7da2eda72fb9fbc224b3f841aa948e2d07989b3035c12451be793239f192bd7718137cf4a065c5e3603687393704326dd4abce59986f9c74c59aa6524f6fb490549e8e9e9dec42894d4e5d7ec5de75a538d320461be86979a201264f33f251c39ed65ffa74c57f7bdc803f0fd7b09250c61be7796b41c5e17231fdd706fc5adab8eaca494cc5f06b205c105ea8fe923273db5bbdfea62c3babffe72e5f49b7939be7a9910c55c8e32dc7987ceaad2c40001d5d458728e6a3d676a4aef296d7c3c255ed79a7e56ac50e9c0a376210be388a8676e121a7bb7da61d5ef0c6fab88afed2bf02e33854c43e8f14f1b7811021777bef2cd3f5d965979040b6e09d9fe5501c1612892933f30d23d529de17ff9d4b4718b645eae623f96833ed5452c8ed039a50779bcc665439e7db8f59fbd1325b36fa741d0079c431c1c1db25530e8cba3a7ce0e1bf48776260e1425014cf9a86ae30fe6c5a3fd0144817d8066da3b393514d49d025afca0c356f3e2bebbf8599632b4df74e8e8c52350edc41cd72687ef939269764f6c45a45a3fdd73483778f22053a1d9fd82fcf549d308a201d8dd126347e405a63851cf5554dd6459b412b3e0abd19f9fc9bb42614f1ef7d328e919991d3dcbc8c62bf7971ac9c82ee101a7eaec4e40398b264f35109cab8514d18ec1add6e04f127ecbdb0e8f34014ea340b18302538d95b8a95566678bdfd03213b0138676c67693367012f0b520bb3113645b62502929a944445cb53b08d1915a850e0b18a2d05679cc5c2c80e6274b638d80bee3f1c67572ac9d4b3e6c6ea95606d4c3bb83ba1e4945c240f5a1913ec683e8e9cb4209e3108ebe46ad5b055274bba1752fc606c2bac2b0c6128ca910499571d3a0b6e4800e42404b5d8ce49128d14f5d402f7a25bf298bd6ded4f8cc1d17bbae658bb05a8b69d3fabc7ccf20e173e5b5fe41d3b55dee8ddccb15e65b40126fe786f84eb4b036acfb74311f884548179b0d88dd246306ee42df5ea5913dbac269594b8fe1a0d8f0c4a39cc402846ce941393a7e4e45b0e2173dc1495cbea2913c46467068f06516dafbc78653be054e8d772793582e80e5573e00339041e4788185530b4fa7747d1b236c25581ab3462a235f4c7ada43f5c032e1d63651a3c81bb45f3c7fdf2311e56fd6f2b2f5eba59daf453d338ef5024141ea92b94ae2e79043088880a099a45209e52dd812415c90debe3f1eaa2a3ee8accfd405b0c06c7057ac396f2f92381b338893405fd2b4be98a37a1a9d89c5df54c54e3e049c2b1f8a42af8a58f0cbc272d887e89816b21fbaf5898b8e2dddc58f0974c68f3248ed9f7bd30b566b478d5a96f127eee13c13b787673953e0713a76005fcaf35ea7d3da343da225496a3634f65c6b6a4c8b8a393c9425af20fed69df27f6650ceb5040cff7d997c3d7e722792722472af730b8f55791ee78de29414a1deeea4462be62f9022771d1c61d30739f6db1bd0ef78f0aba2db2131d4714f7f1760a5193b1ea823aba146ebbd1f88d43f90471e5278526966f79bf03a676a11839f4a83cd80eee6c2604723eeb1b4d4b95538c6fa0067993d4bf8d0e6168c414112698bd7b3a35ec98144f245a99aa827d9121c92745ed7ae8b61475f5dcf69bd21ca4bc90c0038b53d5d2bcac6dc8225a182c671c7a3efec9b7e1387aa14f56bc9561feb09a804797f08a42dee6dbb652e90878330701cab614b1efecc9a69204ab859be2826aacd9a27d579634ab888333cfd319354c7f58c6856b583c536a5f09638506b864146241246f2dcc884cb61fe0463229d78f6f0af3857d09c022a59f30b4beeaecccc0bff4f6663a0e48d7dedcc8ead42ec383557f91d86f1e08b3d42fe10605b22e0c7280c69c4ae670eb61c3cc5e7f6f15c5f9f03a07a71ae2511c7cbe54675926f6b96c06b1f8aed70724122b720203d6b18c6af7442ac29f87d33b666743521c1bf3fd36b5d0ff730aea22e5d664280116832f8e16fd4096f24ff6624571cce426066098d5af78d06da04050bca5b4a060faa42e0bd156557f1600ad9978f52c3cd8e4a879910e7c320b971e61b755a2b930f2f150d9f548377769808a5afee0b2051a677b8b0d4d0daec9bbb78cdbc4d623bee1e224585077c7eeb458aceb118ce1bd49e43c2c578c11e2d0c6421f57380d496442893077cc7f0db3b5421d784c86c45f4ade46ff8a008467e4681126f6e4c912778e0d10f9b7dc4bbc4bbe4a0674b1dd0fc83705171cbd12a9f6467806d10a03b7c887c943237333891c99b03d6eeb0466d608ddc9ba7792cfcdf5062f06be7b6191a6572e1a8195aa1bea7abb550969534f05b369a4e882898b79accf58443d5e62c476898c2dcb768f4f348d6cb36b9aacef65658d2aa0a1297b734990108d0ff144c06ea1e9d3a7a79ed58fa3e1745da88a00b4adf3da41ed247e8d61dd98dff68352a157fae7efa20c175eec2344b088a00e030cd14225b4a4c4fee992c1fa7c64647977ae93e2474945178c9765a649f8f8549305e0196068661061032a37093f304c80e11d44eff503e3473bb1ced4d820253f109972ea4794bd0c6bc76410c1be9429d62d360b8ca2b525bb573c591988ca65452ba3b249a03c7d5199ebcc3ba3f79f0306841bdccc34623b5ec71737d06ae1ad642ec13ee393f4741a33a667dab704be3c037fd20a512b11862a897a33813738693e7920a2484f0294ec43eeda8812b5af0b4418387c53144cdc4d9198b803e933dbf23f6355e9d372589108e12f4e6c3c32155469f5eb601fe8537a67dbff3b3a24155ec66c103aa2979cd852421ecd6da2468c03729fe06b587d949835d7a8d5020d62144657cbe1e8db1162206f1790d898a8946f5535820074afc2ae6d3e81c7c7de63ab55ce460c56c2fd3bd29a366f3979e4c6c1910e9d9c9e4931240f6e8873a63c786aea91d678cd96e2d2400d72dab983c2da1170bdeda68bd359dc2f098479a449a62ac3799fdfc188afd96f8cb74f4edc6ee227c0152dae700c436082842c265fdbe48dd5d43f0e99e8b0ac4c6ac640ff3b931a5db2705a3a1f4ba6efb1a15c649eac8230930abae799eb8e2044df54f474a6165c47953d5e9a0dbdec4aba69671f15c776902794dc8557fa7513a33751b3dfb4499342edea0e97d422d196afac73e35e03dc38e2652961dc4dd1d46273574ca5c4b3d00f5b4c71ff7471e4626673f8cb59a27b9c6c8292c5606f7333a539b7eeca3a7ef2a938220315bfa5bb8f5b882723fb7ccfc19250b8391d431f4d1778dadfa3666e65db2bc5deae4a2e02e28f07aad2764d272efe0a6fdc3c0a3cf3808810eeffb207bbac00b5c0870a07283065e6fbdffd7f7fae1ef12cc9fc1eabbef49f286c28cb2cbb3025e866de0448b8454b7e744648750ca065e95579cc1ba156891bd3cd3e8059d2b861f9485e25c186263956337ce10619aaf48aec5e20a5a43524d1971b6200718c18f9a73b25e56ef73f3fceeaea66a0d3c22260f4886714feea12b51e23995dbdde924e184f8d5544a613e2bf43b1ee263a594f70ca88b33059a1d04df485e573b6f37bce6f62adae609afba7c489b67436e5cf91b6936cfe350441439e074e6a7acb27fcf33bb7bece54650d601d3f3f7fe6637504e5ea989001eeede4d6bb988ae749aebab31a933df7bcf6fe32f450b11b76813c2785ca84399329697a06aba3a4d5c69ce27d3985ed318e51908dec231aa343afca754caa305b714f8df450381e2e9ef5d8a11329228775d7cfa59c5b065f36fb4cbad2c0e7282e0db0891ff35367f512b39308b5d25f4804487e40dd9a00cfd71d9c3bccd5597287ec39405dead1d50d6904ee96629b0a3756f30af27d9ecaa8c937f99a1d70391834e10317d8e00e6cc09b4a253eca8fe42e68e1098d4ec9eca411e015aff630791ba73035858b2d043246f0139fe535fb1baf51180d553939dcc56ff930e39c2bcf6abe5ed7cb15b4c6a13fc95b0475ce69896fe20c6ad987d89e5562804f1abb452f2d9dcd16b5b7a87eaf54411ee2c48058d08073a67b21a935840adaf02496c1ca2c3b618c2432f4ae1bbd3e66b47a516281cba014abd6f58cdb590238beb88544b8c21c8b6b6a0cbccb34715fc85cda581604ac8822a1ed680ba9a5f922850f12b2a6e51ec2da7d557e14d729322db62739129624d114ea15c16027bd9248cd706d73b984cc59be405b25677b91f60d61c3aab7867078390c6a0c7165e6cf1cae47f9a68046ec85d10748fe4cacc3662f60397e856042c68f391de94d02cf0b62b2af4eff67bcef61dbfe0b62f061dfaf74ac383ac6713b4c1657abcdf52467fc4bb1b8bfdc25af84f6286864e1f695fc433d2d40d7adf5fe5f55572304c16a20eac4aa45ed8dc1410f65464b82d20b8587e0eb023324cc7709cd39bfef1f9458ce0a4127fb441ae3a7dcadb5c41e834e2c50b49297bab7df75aa39a17ae37d7441915c82783ad0d8fed51ff672f2c54e77b0da6200ed46cd4bf377248a505066426a17eac38ccafbbd40603a88e4a48bc596858dca7631d4aaa02fcc964f60c46a72e9a9f649e90926a4738292fd77f27696de0eece6ea6e89075843613fd5c5d2a413795c6b646eb9ad866303c9e953a89712ec529a41abd9d105cb0e77fd951a7257d5f668546204b2f128799dc7e662c73138deda8e5dc53358a67044e256092a5445f23be2e7c9dfd856439861cdbfc25c1993d861cc0aa05a2bd1e1a924407d85fbdac9d6eab266aa4082a751bcab26887d146e5ed381fae7f7cea4eef8c619138d470dc2c6faff92a762bc1d3465f041e1ff32e1611b303b2f4e49ebdb04744f8c96793e69ae0d27a915a4d966e7977d33af21b425132ad6743f6657d4cd6a786a7b902bfa01c038af536dbb3b7f0e5dd210b29b3b0d3364d57446d131de5510c0fad9987c8d6e0e1d81ed2a46128d778eca411b49539eb548024a13e7477d9a6f1a6cc3dd879f3cb2c89211594b0645fab966b05188b2d34a5319682b1dfe544a9453dbf4d31f6cdf9c4c2ecc27ffadba746cc892f7d2d2080ed858629abce0ef50d4771b8570b79ac764a3ba03b81436a25f4ff4a9b8bc928855c63fed5cd8679a68268751cddfd823cb78f65d74373b2a70334760bee2748c3d55a0a683e00f7f263924afb67dad80156710d28527310609baccd156f6c99629ebd3006aa8559f63448908188386caf629a05306aad3a0fdfc5135858413a3b296a1f1a75a70e1873618bb23f639d267a00c0363046d1d0f6391499d4d8f03503c4debc0e6225a40f20747ce70d8f2b00ce6cb04bec57233433ac958a570759f7c43842bd0c8ba9fa4e798d373331108f074f319f2b5f2771cea7907e9b5a8d4469b9f8966c2b803b47f080fcb5318abe4a0050d08941f0fbf5e0a20ca4cf4731f7263a1a8b7ed32281303242694f007e9846c5fb368421272e06a4af0da5c452f21f9c10acff627e0f106cf1328030aee69789010b87f1db4796e57f69118c9e062d80ad3f06d65c1b6729f6eef17017521956af10e77d6cd26985e5c00ddd29db6cafbb6669199dafb158af4e34b1a46736994323c3e2c09ae7f9340f955494e2758e5e1098967b15cbd9f46058f3ada060ee40d7191ff0930371c6c8d9fa95d593f07f1c5fe1612cb11d00d4b26d343b5fc63548d41007f961f1434dcbb0b6b9562e67deb7b13e40cfe5f2df99c26f7ea7882cf71bbd092c9022231e52feca39781e50e03c8e08e760ff9d9a8efd41f82637e7f93dcf41ffaa7276dc09a91f4ff23c0fe2c1ed4bb5b387ec18809fe5908b283064db48a392f60e03b7eea7f0e12a6dcb5c38689a8b24fcb7eea8407b8aa97afd455cc1a4b9ddfd30dde064cf35ccfef77e8034d494847b305d9598337baf0a386c909e182e67f75bc9f57c58398201a794c4817d3837b580fd4101767ab197e8484e8875ced2d2373bfc30c1a1081cfb74b6dc68046d9cd784d688894cc8d5113b9d1196afa6cb8a28df82361c53300a003000a001600d000202a00800316e91e0f0a564ffd00da939301c9295966a752d0822ff881f14a664ac5b74fdd6f1ad272e38b9576c0b4bcb3f4fa1715eb7f21ef2e4bd77cc0ec89d302fde0a587e1ff9cd07a11de95afdb1b9acdfccce99f743c7765aaad2061437e72fec1559fbf84997b9d05a31708f52d674c775fc479f78485597be3d64d87668f771ea4f2ea9ed6e36783b110b3134f1e12c4bee6e186aaddd9509c5ae859f7affc40c4161df2678c50a5f8a3b43b5586aaea1200dff9e224c42442a9edd96b1302e7ea5f1284ba70357eb185c25963fa94823fc17609e66266a5707ae96df9025570d34c88cc0fcaf6abaef588bded6f29d3f22e03b579db8e1aa0bb317896db3c237893a0323d9c7d69d6f232e807bff04590be0a8fbd74486dd8be2468966ef68ae1117ae4003cff53facbea2eb97aed4c0dcf57b225ed0c3356be957983021d41c14bba73a785a8ca7ab3fe8f0c3889fb2c7a1c96cddced5e6040f2bedcfe41e98442a4683cd01550f49939b4048b432009d36ae8b4997b2bc783546bbc569d8ce64c761937b151fac08ca1a091da6e21a3ea69940c891facb6d6e7ecde2b55a439a56290e2efe33ad89a10dfc97197486f74e900861d0caa6e747a47f9224d33b9d6492d87f4bc42ffd9759247add2f39080e72e8e01ec567dbf83b708d59a351ebec73433a1a19b79e3f3662f3b8ba729afc4a57007e80f044bc4349a880616e71f1c16002b6eb08f9f01a61793b8c133e1f72f1195f30a8a7db4c037cdd850fa1f5014edbb0331863d1692d65bb4039d29d812373d4896f70420bc6a3744cb43d0aa2d5f4f643997ad4fd98cf81081545c2cbfbe90635dae8e75eef2b695d77578390b350fa1fa4b64f226b4be7c54b066db735e4bb027b6e95900091be946d33e0f37ce0337a01e0b001e202d80c8e6bd3d47d89f7585f0b668d5fcdb66a48c0ec63a76ed0766d576f695e1aa12725a40ba549b1bca02a5a9db5038407ecbfa2f05aa8e62f37bbec4ba2c60b43b29d5c3fed2c8ed617cd6165afb60f3696f04baa98647eed8efbb8687523deb0abbb48a85fc20047d12f629d84826dae0a30c7bbcb3bf3787d186d86d9c518718dfcb49cba91be9ce48fda10fec5a78d40037fc7078a23c59e32c8f5cdea85e02e24d989370ff2070ca087a1617fc81867bf855c986b26163deca5bc745f4a25295a061db6d4819d8047cd5545dc66e67ecc24af55fd00deca200ff46dd0c43aa9383ca05e924dff743af420182621c34a3b465cb7b5557d3cef8caa1a8827b1795c1267ada3f2f37a0ec884daccdeb1ee61d61edeb3677d2ebe59f502e99ce9ae652883786c1fe657887824aed13fa852c1e0ee5c4706d583a0d884b1b2ee26a030eb44e9863b5375823f4c12b980dae77dd7c448a0228aea726f4e5a8e11759554f8e6f72e7592acd47a1620dc3883d4af230ca975ca87f03ea13a7569f4aa63687eac28d6dcf83966a546487797c452aaf7d9915a649d01f690bafd8d8558566bad9abfed313e293023d1490207ce971d6d85742566568e1f08a802d70f4f2070acd5e2e8f691b955fce22b59fe94d49bf9817a29c58c74b91a16c5ee50ce7bcff5dd5be05bf250698626f290b9d943fe319d563bdfc712fab57ea2aac38ad57236ccfedc378eae9046b09527d02b5aa5ce8ea38b6b3586e6efa2d7224ab0de5b2f36cdc05d3bf5e6f9ad6921d1671918b8653033828fea71a9bdd92a4175f42c9f634055cc4a89d950e6809350dfe8940b137b3c832672ad4e5664f9ce7213e3848e3f7d5ee88be2e9fc17aed09feda48a3a3a1dc94c9ca45ba0e500f9dbe231e90bec78f91b89336eaf70a90adcca493b67b44c37f8fd6a7f21afd06d6164c8e8af28c726460fd46ef795727b8fb030e5230ba72312dd9abf5ffa5099c1d3d156e1ff43ee649857417fd628c53ee78aa6b8f7fe23fba21da1bebaeaf183803f4dbc7e4cbd9ac0f34a9fc1aa37ea20bf8e78348beadc665d08a469d3d40ed5c307a17140c418ece6fcfb70aa1e43feec6a49762c3504c7769f27679e5fc682a5ecc6749acc043fda3674956f67f1eedaf65b29da8bc899db6d48decb44278c3c0fe17de1b663f4dec396d5d5d1fd352ffdd5426bd2cfd4fe38a026c32314c11deaad8548ab284a6c20abc53952dff633f99fc6163e15778f72314984d5417106034b0a671ceca2ce9a2dba12559014c2039c19c399cc55a4849ab99c565b14b74c0564d2c49f04b910054af2c500516ec8f22538f1456e06a3f88e7ad5f3675bd422fefc03405d594171ed4f9684958f092a8d16c987c84c3862b900a46b92444dfcc108ea44e249a6568dd0b4567ea70f375a5d98c25f4b9ed900bd76eccaebd9c376ea35bd0e073ffb2b7260509f3fbdaa26dfc1c1ca92c0b6f581078d86ada9f1a539a5f36e7f587534fd73078eef37bcc1baa69253fc724d6336c7e261369ba076b2930f708615e32e6e52ee8258a0390d242506cb011c85766f1111b00eeb07a6900b9c6b44f1eed594386cc0301d223a919cec928f18de709dc7906cc6cd4ddda0bafc40e6147381413d96932e97f607c9067754bf0ba9578bb21363e445626ded6c67766f33deae67cdcdc97571deb4eaf1901deeb8f8460ce4e1830b6bd58035c1869862e5e3a55ae10387e61541eaea8d4d6b861e3d4d4b8aadaff30ced160074544f941648e41b72c165d3160538113e7d031de33d89c4aac68c714c13b32c5ac1a8673028090762cc6bb893853f5e2c5dfa13e9ecdd6cf990fad7067c60194b585a11a5e68a767bc8e2c0f0da692d2703e6bf1044a329210dc9335291db43d619a9f94589665dfaf5b59adfefe88004575dc67276a00cd40574ce6c608f0b963d53801030f0323bbef84767988951bf0075d5ae995f86c8affe0bc9898e33bf4496d10e00528e30d669095d0c0bb68ce281ff04fb968bdb2263e8458ed215dc3bb682c916b70531fc9c1e0c157859f4f8bfe18d65ca7676299d2a06a3aeb1e9829a67c904902eca0183f5aaacb1a14ee40898651aab968ef6b3a3a94a6b3e86b8ba60318c08721993225d72840d7e651f5f014d87d6d96e3817a3f9cf899a8a6f40fb39287c8802825df1d0e0cee488399646f1f78a266c8226a73111a6d60b32de2cbf0cba142a640496f90a72b44df20bb41a179ad6011af9bfad62f4f5681104eb31393280558fed38752617d6d43eb2b7a02eb3f50261f4262225a1c49b4bf6ff3f6ebd6abf3457862c8369ed1506f1715d2a901c633af4cf378f757747ed57ddf2c17c445b910d7f6cbf789cb609754c21beedc871aa5ded75ab19f994949d93d06b880788353d908854c21f7607480384b0878fe0d2d4bccfb9ac9d7f65d318f71d4524aa5adc74b49306d200cea4952d60af73b817151bb5119effb0c3bf9429b77c11b19087e89165a951b743e7a9688a7c5a04d813d414c90c78dbdc0425c0bfe9f1293052ae88df1b9a60bab5f7b883ba0c312e234eb026fc0c9869898d982a3ffb2a98da8be4b5308e94e1cf72938a5a7ca0034cf14833731a4959cd18aabb95177cf4c8a092609044b4dd5ccbd49760b6aac03edb8379d53283e0e47e5719b7596db74f6d946d72a6b2b523ad5162aab117132d50ba338c69be3ef4a1f62f50702c18eb62971b8fe5a746beec7b0582c8c127ae69b07f7e6a1f8f4621fb8c1b43b0d157d47f948c1a7b1250c776649ccc9b3310f26110ace85c76a04db80604b6dd06e40000bb691e6a3890966dc50301df01ef9b2c3d2fc4f419f7d72d711bfb9d68963a972859b7972e1a0db3e392b576ca6e23147a232284ecd9494a75bd0e3cdccf63bfc7bec32404e22524557ac751b2dc6aa33cc3929397ec75a8d290c2e0a82527eac5b62c43e3b384ce3eb5dfebeaf86b55fd457161df2004d4c8419a4b3d24becc1f17aa2e288db63b55a96b3416d4a3b2bfc9a6c6bb8c7c1f1cc0a94273161888d07a91227387c33d240b17fb27c8a8071ade1f11b4073e6e869efe27347e52aef54cd3d482767a30b846f6863c0ce6d6c026d835300db594635392134032552511f85b82150d57ab3ceb49c803916248c1ac1cff59c1cc29504c1017d1d7b6789eb8858c545c2f43f8493a4bfd3d9ee9894a5d6cf8e5400f8f97a69414e680891cb32823e8113adb154ad77f02ec3174456121aeb04d15046018c376791155f2e45f02f1c3aedcdb5dc9d3582a3487ccd9a4cc71ed0e22b41079b1b70cc380e5f47cd0d2e627368287346d0efc433084183be92fef49e0cfea93d7ad341f119dd2feec3d19156250b7a31133e812511f34dd00019c5205934c22527f2ada2e0f99d875e3a90a0ca489fa42ccbd732aa3c99939183dc541223fd1839c6601ef004f51495ce73e86b17cd991086d7969f2b2768c1bd5d72c79476d491067443438ec60548737cf538081a99ca9338353b5600db9d4a3ec8b9d0c568965908e8d44f3467aaf654f592c9b10ed32b65e690172fe34828afe285e994f115291396530f30c82e8c283dd8a8f1b60427a928fa3a756c19a676a519c079f0a573d58551edc3dcd2fe69c78cb735dab07decb3b2781e6c41feb573e1f823ee2c13dae7e46444e892cc49ab1808c3867bbd6ca0746be316138a0b7ce661a87d183b083b75b922006caa161c5c08dabc0da06a64a4edc96c4ebd47545f378e40831468b4dc659a272ea6ad15b7e891c090933ef3371d9166b7dd71b0c4281671ae24bce535ddfdb13e43d64d500b1c1ca476a362e189d34ac6ba856c5e6832fd003e6783fed439026c0d2eed3e0df85fed9bc6a4b7f1647f30047706e58dfeadae31d0ba81d5db7c2354bdb3dd4f4dc8c6448a9c3a054a93268f4e1010f08a3ae782dc87c35491ce8f784e11da89c83a80c5d90e3aa1a20cd9e38d46ecdefebd25838864d442d26409117168fc07a14d71813ca0313502a8f3f9935d3c0017e56a77edbd19147296020709ba08fc083f94c955b36539bb7bacb187167b80792442496a923d747b00fdbfa5bb9d3b7bd5e38b1e4ef45092071a792891072e8fa20f96ba8cfb69f2ed636eede3227367a7585b8bc7173c4cc0c3c42368cb8ead345bc02da557cf3d585e7ecf2b9deaec73d19e8414940321241588fa5026fa438788866a0734a6776672d5cc0cec3d5f2edb3b9d65747cc99cd0b1778e4d3303cdf2f27099c3c0325f1f9615e9cc7f1cf378e6ce5c46c7d7352f121daf79915c0900faff7a479cff577247d6d21d64eeb863c97fbd77d0ff9ae560fdbf1c2fff55ced4ffefe424fd57b2cb11b297ecd0c20eabff5bb5a3ea2b931dbf7f3b68a6ba3a12f0f55647ae0e10eac8311bc5af0fd37155e938a2038239103047d57fed73fcc431234e135f75712c90030f39ccc831460edbff5f5d1c69c471260eb2da0b871a38bafce01082838237aa78c3ea1fef468c7778c7bbba07b41456f91e73d58d2c37a6dcd0a00d30da30a18d0dd810830d16d8386283c87f25733f9dc6bc5c6692e293dcdae7eb3db4e7f25549dccfdcedd945eb14cfc0fd3b6919cc6d1228cf3d074d1d058e01e05c8143548d7047b27e6252ef9c797127896bc2916b94fff5b5c61035b27e4113d79d1a55bfa3064e0d9dbe4b6a9e9bea91a601e783b9591a61ea2b0daa3480bebefa0536bdd9fa7f73555fdb74d1a6375c7e466f92fe0d7d34e2fc1f41e38aa28146d2ffde261a05fcffe3805863cc773820d667d470c6ec8c0ecc78f335783985555377a798986165860a5f6fb51a53c5ba9c1913b8d17243839b10dc7c196dbe5a736f6e69cfd645310f962f6b5df456a332b294b15406080878a30e297d66afd2982f9b1b78e0c185b26420800c27c858818c236db4da00d1864a1b2063dc31069c31c08c011c2303366cd818c18604362f31ecf8af3e6c8444b7aed1a8e005c2f4595eb39f48b1d8cd325dbd63b1255deb144669b02471faea7031a64aa7348dc26ad944352eaf2e9b99eb74e5dbda915b2b064e0c08b4cad0eaa245b4c6cd9aab355cd64cad317280ac034c1da0270c337e08a5d5ec3c1b199dd0173eb9e9a22f17ce5d1d1d69595e1cacd67307c7cb474b751f3b0e97b94ba3741b0ac63b5dcf3e8cf92e5896b7e3feffc9ef8401465613ba4d30ac4a30a66660b8bed8fae2ea79367b5fd88efb1117ed5f50f3dc6ad0d06825d550a971a901e285d6bf17545e3cfdd71d2f78febf6661bdce9b84acaaac5e9652175b5f499ca37c971878bbb8aab60baa97eb76d105fdca05b9378f7281f55c503d142e92ec6c01e7ff2bd98d6c81f5ff556a8baaef37975b24556bb7e0f94f03e7d360a569e1abb532998c56b4ab15e9b053afdf1e59d68265794f4ee6232da6ba163c5968fda6ac3d77308b25b2b05f75a6dbe4bc2c807c182361610725710e8b3075ebe0a51a0baaaf583cfdff6f2c8ca071534ddca55434366041834343bfd64ef2bb737ad3717685d68cee4a7c8597285d7e7245ef8a0bac00e3bf623ca356dc6085b642c87f1d476b2d76aa028c2aa8fe2bdff49298ac42c97fede4ace451aaf8af5055a854a17a4685182a6cfaacba29d89822ccff578ec9dcf53ed2f593da296c53e85ce04c0a3752c4f0bf779a16852e8a09b0f2c052022b0b16396ba2e3d010144d401100282e140a3cd1e68584fa130738a184134027ac13449a98a309ad87a242c76ac926e8993767ae3843c3192c678aec1860ebffe9489b68ac7724744442ea2b65800898d062020526624cb8aec6b8c2ba0ae2aab6441f4b44b1b384124be09608a2841925a0fe5f08f338fea12f9779713566855e38a11ae47a9a29591ab34a3d738f98a7338f635fb7424196ee68fa1c7137a374bbecf962a9ab53827b26a9f1d8318f6325252a78592c762b9ada4637895c1240ae7e717ba769b1d8cd8c16334264202103124596a4658931797d348b7ba6be74ece9cc1b553b62ea88a32388bcf93b79df298059000facdeec58dd600582d50e01b42040553d3a72d52ceed72816bbbf608ef69e7b3717ad7c739d5dd4c6a8b975b9b9cfb74d23dc30228d115346d022ba28224c114f8a08abc5fd5aa1201f1b2f771b840b72535fe0b983e70e565cb38bee1eecd22eaf06f5264fdc7f9ad4b8a9e30ec4ba4c56193265a6ca2c512a83001158b59b3b445461222c113a4368e9f41056bf330497ff1f62082021dcfc5fed08c1e5ab105688255508325aff64ccfc3f991ac824fd7fbdc11c19d74e105a40bc1404d54e1049fe7f4c9cffdfe7183463c8e43154ff558f791ae31a03e4ff81c8faaf647680a07a2034c6393176ece0d4f5c962b11b8ec4411c259391b458ec46d27cd8a4c562371f36f300fe872d7e70e107a31f787e681047b94cdce4030b3e3cf940c364852153751800f4c0460f34f470f64079d88287137818daa18d1da8f87ffbca26ad1a197d3a20ee75cc77dd8773b02cc9cb31df1466764cf28e9976180213074c1260b28041327193ee0bdff982bf4ca043153ae8a0c3eddf87cd0cc47a27073239ec7278e500e49f6ed3d2a0e9c5031cf6c081091c64c041041cc627cf5cf0cce932effddae80d40dc3075c3941b10b0818d0d3fecd8e042b52f17f6ed8eebb9027db8675a8bb3e1470d65d400a686df7fb5380a47f14d69808306313450d150c00c59cce065062019f2e842063132ec6428ba3f5d2673ce52580d9e395cde7e06cf1cdd669510552d544955415545a90a12039a188c88414a0c406f7d96c2acb61416f3d11faa712e667bc71a0643171892bce0e685245ed02f8c6fed6e53174c178ab4a0a6053228b430a585a11682b0f086ef1d16645de2e8f244972532f89d2e5e9ecb175cb47009dae14264cb165bacfebb111f36f316ba821d2b58b1020b2b7cb002102d2c6861d2e2da518105159a54e84923052f290420052b296880821d2850f15f2d7f5d9792de0d0507042080140420446507950f54552a8969d5874d9c3b61eb8434279c7042d25f18660a809a9d009c09802e000fec98b08709624cb0b5f2d2ad29edf9eef26ed39789bb8b9ab8290b145978960c4a18a3041e4a482aa1032c6760c1fa7ccdab71b9db5876825004b30461c121536d4c113175c314d554d15712e782d707abbaeec3666ca6c4fab0992dc53025b0d8ee08a8052c03840262f0ff3158b5b6779c0f9b198731dfc9e898e49499e7c691f9fe2ec73829a0ffff73ebf4f2ffffeafd8c72fe2b812931b199f55f7914f36be4668e316d5f03663007c41a87cd608ea4e1cc6f64c6e1cccd7e4da86242583335b3c091254c35739991b29cd546963b4b922c40be92b8842d96c212aa4a48fa2f81ab81c5eaff93b0f0d059504d904bb0289cdafaaf98df5e96d77769309c9af2f23f65a78404734031802c84c0df3fd055cbf2fa3adddba4d966525a7c2b498579a9258ffb792475c05712632cb949e7738b93eabf9e40d59cc2d96cb3dba1994d093a9cb093397b972a77c7fc5696e7ae93df25e07038d6bb5bfef45f494c7b374eaff4ccac6d57b45c09fab9c9a56e9b94c4e5ee7aebb6e6b34a86bf2a0ed35bf378b7dc456d29fd4bf235092c5bca3b73bf7047b17f9df274e69b735c37d04c6bd59da69ae9f17d6c7c29f8824a389803758eaa1dd998e8cd5294ef5e3bc7529787250fe5d37f2d79f6521496e5dd7217d54394ad5abacd282015eb4d827944c209ffff34db8c9ae5ed32fc0bde623159bf49b25b51afdf244ceea3dc940be839d19ba147ebf1f0e4e0e9c0a3c20bdac5f9d1e2acb975596e3df21ca9716ef4a9758647a51d98ffdf25c16ce01db00e47109259ffbdeb8bb38f0fb526dff5ab336de4944e8ace486e8d9c0d39107249ee19d789f05eb943f787edc262b11ce0ce0871070871617022e08258d9c38a15cc0677f98399fcfa6ea71877fe7cb7d77b758cf57e6985b27ae3283466cdf276e0e554679f4ad22324e6714b7d6abf3c9ea53e40ec4387d47dea3649833a1fa94f235aa1ec0f85b2b7d7793a5b91b242046a0d9497af3f6cfab02e77a8a1ff7f4b75de65cc7f18a94a5905032a5c5099a24205c99433a6bc306584294323c019a1cc085446d879d2aa50169fdcf45d12fbf0ad665c4d9de92eeb4b2994d5653316b354f0e9828ac52c151d27b7a9bb519e76788222a58fffeaa27c5639d6c0ddb30fc9d7b30c93fb88c453b7c44c25e65b174ab1752914f0947a86e224c67f9d39dd9c8e38f544c9238a9830cacff24b61bb5cdb6d4ad238b6349334da8d707c7323bc8d71eb12de8cc29baca98da61a6aa7dceabddb556fbd7937172c390e9663c799efdba33d9316c7bb39730a6b29cc7fb1d88dbcb857e66bbe9ae8e8e42269a43e374fe291678ee3b2be92215398df6da6a9af4c400fdc5a0ad37f15818cc63f8ea5b69226119644789a8900544500f2a1cd46c35732e36c08d4d8d4ac086b586a4098ded3b684c412d5925e02fa587f0529bd51a2416904a520509480c2a5c248de84e39d6db216eb274b3cd13d59e0ff13f8f0c9014ece70428493149c3439095ea0595eba7b79c78a6b1e6dcf2151589fd919ee86b41e6859425aa6edfc7f0c86ebbb4cba4a7a4ad2811202560821b83e98e3bbc95613344daa824d9af03071f353d7c7c40bf63149fa0f320182e4e6bf6a1cb5790ec9cb77a4a719920e3dd23afaf2ff7db7cdbecb232323378cc2184d31d2998151cf1da43498d39bc463e79bc4313258f6d059389332a3397797785912b524b6040310b4fe6b4f4fcfad5663022129048101d91ab21e42991559051f50f1726d4ac30f46f80082a233455bc2a2a8a29ea2204a7aceb775bbb414d6d343af92590c8f308615cb12c66e1506f3000b0f82a107503c3820c913611215ea8be2dcc5598a73b90ee074504407be0e8088d80889b2422217be9eba7bea3ae6d61acd3808830314420ea6381832b4c5d0008644181a82440d922d2192a0ffeffdfe28ce71939e3b6871bb8d1b427da8b5f487da20ae772138a110d6bf9097ff1a0a3d09b978fc066585415e8292aed9cd73cf80f8d81a076f2800c180747e041e39e2083f82a4ee51771b977c9bd7d21ded0ceb0b35090cced7cef386e9de83fac25008614d962ecd926eb4898912ed469930d594e8528d22318102657644991835d1924899109293a7334fe711ebffe48d5575b43fd2ff89f3b5bf30df3e170deafb1366b77f7a0fc4bbf087672f853e702ae953f53ff3b17df5e1f97f655d20c7e42c7c51e5a8694467aa8486afa7af7c53a1dbebff9f977bcd850574bd50cd9e4b59d1d4f515d152c4a988920dead8a08c7003321b3411e183c812447e4490febfe3123635654a595efa439bec58e6a89a0db223ee6714dde39dfb0e29c09030e110010c5132a4811e37c21e227aaa843d409ef6b3b4514a8fa6d01f3ac555ab18766948efa057140c2d814285148130833032a0fa7f4a474b61c172f3607ad311030f3058e002362e18407881ed8208849021c4082150421c1823b4404d688196d002a6d0820bc20ab0082be8153c5500840224420ac6841448a180011e2e7882b3232a31ea437ff02e97b49b3956edaba9a976a4c9ba8a58ababb4c955b3e3d854962e9a7b367f2f17ed14c6b7edb69fe58f8ed6065118b5bb7cf99e1569dc03ea7c7de1046e3e9cc08bc98d7c38416f827e811f7c28419cff0f253042825e28c14cdc0ac5abffff99c8e57f168abf2ada44a09ba813c609432d8c9b8464be29b4ffe3a74eb7c390e73fa82fad4ae1ced6ffbf041fee68853b56e14ed5d71d9beb77be2902381170f155262b9ada463257eeecb9b343f0e667101ca0f326d429a383756ea18e90ce030fe8f1c098f0812af505d38d30cb64e469a781588fa10354a103b6d0010dc206daf87f007cd8401a0d50d1400b0d9cd04053d8001006900819a8aa2f1bc451b8586c577335bd6c94beba111285d50e8391e5a6d66673d55e40ac5db41b099a3d77769be33cdea541dd1788024cb840090b38850b1c102a7044a80009a102b250019d8741d9bdd3342ae4f599b6dac2203b0c32250c127ac0411092da010e81680981140199204c008e300123c204aa9ec952582e4c20294c80e7bfd69e3b7b8880508840901001044200688500480300600800a010003e0784718055b52f26fa439f5c354b71101dedab89c95a8bf1aed697cbc4bcfa72f5186c9be7a53897ef0fe3dd2ef3bd9bddd0003d20f8d080364203aa080d20131ad0141a208605c829404c580094f0c71e5f7b13fd9d662c76b33e6b4baac4c992fa863f7ae18f26e18f22e10f0ac28f23fc1dc2ef127e511f73fa78f34fbc3e7afaf83957735298639bb3644e057320e0e3007c70a99dfed0266b852c85551826b70e669f6024bfbd9e3b3bb54da40bc62d138c52db4403fcfae868fb2cce56128d8305d3671ca93849ffb5cab1f535cb81f5726cf9c7c921c611a7963b0e20e29012c70f38848083eaabe5b1d8367376b769af3c0783e5b9437a63cd1b27bce17a230337b2dc38c18d1f371668c34c1bbb366e6cf4c1061998f34c831948ea4b06e99847dfa8738977b4dab9c6baa7cb3b1aad5b6fbbcd5186b1e4a658ec46c7974c26bb15f1749eba4ae62e9bcc5d768ec98b7b38d90b4ed6c3a98263fbafc00ebcc1f935b4fed7a046746d8daaa5dfaf71fb7ff2aad1871a6dfe5f8dad46086af0fc63a9edfb5d60532c7623c96bd338401a574f92b358ec66e2591ab4341a78a3554d7dcd29bc4d9b0de228fabbc03755e11ba537ae8e0619684c8186feafb6fb2cedddc45b771c44c3e88c38ff729dd1cff0c08c2d1c745d9ece52179739ea3203cb0cfb66e8287193e5c6ea9fcc6e7a5fbbedbb7db91b9b797d3d2bb90152fb2ed19441a68c5e19495f06fd100173fc63c90878820010c868830c2c3254f851a23c9d6d647c1b356d826883dbdc360d8c71660c2fff97e6ce265a6f6cccb0d1c286890d0562a0214612627431686234a0e546cb072d520b8916903575ac19c01a14d620bd92d1aed63f60aa313149bad198c48c90826ccff66585e80732a1207d79eec5f7cb0ad122eaa2353c009230f608638e30be84f114c61130f800c30a306000e30a1844d27c31c517515f846a9a08d574351a7841871761bc7812666d3d45027bd9209b750951a35dcdba68474261f4655f41364b47fb52a231eba25d88c2846c76b7836c19ef603d93678d846cf48706d11f6ac44f3b443ff880be5cb1d86ee376e7b1d8cd5294d69ffa53492c952f90e29cee76bd33e6b9cb37a96f173c74a1d445045d24c005125cbc10858b0bb808c2c56fb1660b14b6b8a59993c68e304d99344f698ed21cd1420c2d7cd0c2a605d0ff636dad92ab666db6bc9472a099b9ab66e9685f4a945a1b106b6a97ac925da23fd4a6041b5279575f5fcfcc409d0e7613f3ca7387f9d541d96ea95033e39ec9bbdad2213558624ebbb6487a5792e29c35c546f4977b1d4b658143165ab258ca22812c7e6041c4ffaed669cca7fbf4a9ebb3d95c351af3a1584ce98cc592ffaf4634163c51d0c4f90fd160fda321533b1a9d06628dc656fb4e86e68a2bf20a2ef55783ed25aae48a5e7805fdaf405c2c760bada8590142156b54f1a58a5d154e55204085175464a18257ad893b8ee3f245a3ae198b59badb2e5a5f354bb3c1dc1dc912fb7254bfb7a87e4d199410122a781eeba6d8fa29acc229aa483c4592ff1bd5bb146ebe02b18eead794428aaaaf522491590a200fd35b875184717f19fbee5254bf375914bfbf611421d60b2b0b8bcc7f25b1a8b096604960a9d0a8ee0beaad6732ecbb4b396866992c16d365287e2114c127e0fcbf9ec07aa2ea770f183ef1abb42792c462b7279cb8aa79e704d557276c5f9d7055276e1356df9bf8fdd7739b4d2cf926787a3e03a7d228ddd2992b7e86ea4cd21903a0b906e08275ee66802524135b4c50e193d1e8c8040357695ca1f9aff6cabcfae08a678937d5363d29cbdc97a05aa20325e850828750092c4a24a94a5e58eff2528e8178079c254146125e92302109a1248a98c93223e6ab6dc2516b668a191090d8fa4ade1aad7d4b9133247a40a206246648547044968fe9887dc4ee88080ad04601c014e0cafed19ee9ad1b89d2f96cb2978bdff2cacaf21ef528dde5264e675911f6e59b6ca4a302231d473a8e244d26e36637bb912226dfbfdfd9713afb703afba4f879a4b38fa7b38fcb64b7225cfece5b910e3b9134dc35228ede4658fdcc88a96a499a35e2a9067194b9978c20229b6231d9ef37eb9792b422cc22ac14a153268d32539479a10c07968ea31d6db794c911264f9eb86ab632a92e6a7b103fb14f98d01ffac455b3380546d998e4ec5846c724671199711ce31fc744e8f4c221dcfcff0f613544d5104f43f07c0d85d8aa24e6098146882a2184709181f35fc9585532543adc69bf3d324f644232f4fa82082308aaaf63994d7de61ec4d3fff374ee4100d97a0c1add49eabdf518aaaf24dfbbdd1d637f0c2d331070f0145e02e2ea4320aa2a1053ff0fc4d3ff3b01e17a3170423157525ec4f4fe5f2726898ad991117120945496f7680a939af6dbdc3680cac60f667ea8e187da0faeaf967c59ebf281071f62f001c90707c2b8e1d4e9e5e472da2676da26760aa31406d6431ba49b73301896d23cb8e101061ea2f4b183103b60d9e1680720601000060d982b606c602cf8d2e6cbd5971cbe00bf98ff3e3e58aa0c5edfe5586ac3603152df1d4ddf5ab1b9a5b636cbb3c328df74dcd1be00d5ae83153a78d161b799e84b9b394891430e403958e0058d971fbc287929000702843854f5dbbb4cb72da56467bee948626b39c661c80d5aff7fc3ee06211be8b0c1cd5b5c2c26bb15c5629d7e407fbfd0869c0d3a358c514398b0862e350c551286f90f47031b210d6668508186dfff101a1a98018b19bacc50e5eb8839efd25e5ecdcb4d333020835628830ea10c31c850f4d5be8236d0d4550d5195a5ca15c318313011432e860d609803862560c0c1c0c0e5bb499020e5ed3d9ece96eece1cd69bc4658e5f1d0c162c83e50b48bc90e505272f087121cbdc3bbacf2b5bc9c6c18bebb962734bd9ede482052dc4d1c20d2d3461610e16c2b050020b1bb000a44b01c22e2774f1e1d2e675366229ac1bb13dd3b4a7a5e696c2fd2e792468660da3946faa2487b90b898b932d7a6c59638b9a2d02d8e264853a56c0aabbcc7167b2244fdf6a07ee1586b4bcd1c2464b172d4fb4e8a870c70f2a2c852a8090421cf54561fade9ee9a2f6f573d52cced158497176ec7987b9e5e97ca9de3b5a95c2e6b9353fcd8e83b707afc6e6760a96e535352eaf997f578724ebd8dc4eae221d7632b7d491ec6a1cbcb25b51efb25bd10e67f6dd1b22ca587267e7616ce24e5c96389eeb3e5cea868832df53434439c84d8d8590e4b31c22cafdf4613e44943970731edf4344d9d4badffe0d11e5ce7326ee57f01051c65a9bbc21a2dc4fb31c22ca389eeb9c24ef10513e8788f2ef72a010923c44944ddc71a5b9f91051c662ea8688f22e0fe1424872278788868832ae3c7d4344b93ca5323944944fdeeb4344b963de105136310f87f5ee976796b7e338fe01b7c6e1a86be27c9bd49793e5c63cde71e5d56133981bc27197eb2c15cc54a16c2c86cdcb75960ae5beb393fa52286ba990d804ce64b7a2a87e6f51fd9abf6dca8af4ce26c6923bc692bb4c96a4f3d89535aee47025caeff71be10764a3b165d84ab41b567a048d812fce9b66e6408ea536b6b493c1d2de0b84b2b15854bf375f50dfdc2fb0d3f166caf73571184be636aadfdbedb8c7cb308c77b01d895d514633e35c39a375ebdac4c489765b6272b444a32330cd6e4c966a4ab4b6d4ed91af26fa8a945c94c1b2272aceff88cb5fd6e9cc7fbb97f7776a5add3d58eadd336d6c46ab99e92f47f5cb6fcfccc09c33a770bf3a9d9b4499f9a8a7a82424504102d557acf78c840c721699cb07f57d41599b92a5e2a21c2be5a7cfaeef6d7deda1f9ef55fd7ab6b35f1dce057baedef3f8cdfa7f1e99caa3faffcab3ff95b7e4bf8a3c9dff17776f7ed7b41b773d580d9e0143f90a041494548d90783ae736ff515a7905527eb1ce5076bb475f2e2b927890498864183289fcff6a84448325cedcecd9c5dba58f1ebba575ea2ad99ec72051e7842e8c4ed44d904b53cddb67d602b1ee3adf7acdbb73622ace776adfa9c5dbe526b93f360c6b8275e1bec059e19e7042ac6461e58c951e30bfa8505a6969de71d439868456116a0050b52a7d8855e254d1a14a09558a50f182ca1154aa7cddbcebebb4badb8db8974ce8c94d6cc79e477d72ccad796e71ca11e21415c42948532818018dbeb8d4970c8eb080f894c49395a71f296048a9bf0e8542599cf93be98e4999f91e8fe0deed37ab525e4e7a38b989e2459420a230450921ca04e2ad0af12680db78b340bc01694aa2c98ad85484290b97386c6e1c2e868496a54f4aed3cfbf8dc6a4b3e3e4386d40d3429edb9ee97ab48879d38362fee4c404498238255b9f9a637dfdd4c04aaff1ad4358940e4ff83b960cebcb8d3992d8eed8bcd494d4e4dccd79e9981dbc49ad43bb779335aef14a6789b1788758d4b2d49b5966fba1467a9ccd20baa0a952a2e1fc7becd77afbdb4c4f3d55a7a2989315752bafaffaaf4fbda332731b72d51d2f9af50b2a090f99f9308a50765498502646b2d7d323d21f364ea959e24119fd0cab1b99da2f4e54eacb6e8848b139f131e7b2f2ea948eb342f2fd27e220db869409292acfe6b52af2cf72f842842582184104200a1091c4da2109bb8f05f5ffa02b18bdad7d4f5b96a96d298bd348a4da6262f2672884cb4b699b7be3491c91626529814bda2f4e5389d7d4858482820e99018f8af51faf2bc39c612a5af7991c423258eaa8eecefb652946874c68804233a93f3ff412fcea818ed2b88627ee998631607afa5b05b734a1d072f0ef39b9bd987aa32ee1e904a153ae35982f55f73bf4becff9913972cd9b6253a48342a82c0e6ff65b2de6f7924db42d68228db1fc08ade145151e4138b9a8afed25e9677ecf82a794154b24509d0ffd77d448c85896931e6daa2075b3c30c1830d92b4e1bb031fc40e70073a446210392112e54054428ea8894804fbdfbfda2d7596c26a59ee18a9effed5b2dc3f3af67bc4d3481c407971688c212e434890e481240b24412444840e206445ebf5e532854ea10cc4a03541565f839a7a262dcf6210d5ff2cc8f6ff391168ebdf5e8ead080444f55fe91581aa1c89e3089afffad219783919e4d7d467b9a5ee91a96d1e713a52b134ce2d8995cb57a0ad1689b03e6056db0ceaeb824dfdd77e05935784b96ab97754cf9c8ae31a2394ceb3d11c5db573acdbe2cfd6bf5c74f663f5ffe20f95167f6cfd3cf2e3f249f37a5d26a20f113e4fff7afb344f8b3e406ff3f9e7fbf562f28a4074a1a93c4d45579877f5a0acc65044174f2d6f9f1981639a7bf75f0d887591208a9c453610379043dca0890db46c30f424d67993a0f1af168b592a3e35d31f4a49736bead371cf14897041248b480436248c2154ffb5a7a7e3a82e45af7939e517d75766aab9781687040d59a027eb2b25b3a53ebb6dc92cf61cd1404b832fa20651a20656340842dff8ffba4dfac2e11c6e9bb8a89c897d9857a1b1dcfb578362d8bca645caa04d062f881910612007063a88184c61b0c3a047c4c0820bacf8ff0f5ebca0cb05572ea0a2103942d87411b2a3512c79dc3bf6c2bd3ca4f2285d8ea2243633def1bdbbd8d7bb49a3b51bb14214b0c08c68410dffb5dc9b52d102a50af0a8c0870a441029d8a35a8b710772dccf600efb76a74714740a9c8814bc441e3e78c21079b2441eaa0a65b1addcfbd7cbbd6d531737757d306aeecd34c19c09d64ca0459c60e8ffcbd24742594b652483b8b7f53612253842022ba20440a2688688a5b099cf2b9d16659769751cc7308e182a218655621882b8a3c70e13e24e0ce2ce0a3b48c41d0d2248f32486e1da35597d8ee890fa1a39d6510e411f22044188105481800251e78da86346d4b1a2ce4dd4f9213e50467cc0870754b0b81fae64d4b40a65a94f858ac52c15da7daaef42a13ebbd3dd7de810f10110c4079644076a70a0141db0406ca08fff11caf672ef1f2df7fe755c2779bfa54c762bba9c49cfcc527ab965b7a2cb316e6b8e4b1e6f9b38736f2e2b2a37c7e6353bc7220329880cc082b911e31dcd7626932d90c5f3e20256e20253ffe20274b6801515b8caa2025bea2d881931c896204d82182002c1128178f9aab798801e62024d245042024e0944202220c78c8840504420c97f0fd5992cd28f68de4bf580350e10e200de01444403f830e08c015844034ad100971a05882940271640452c80e7ff672ffe58f3238cf843ff18c57f437c23c4078acf81f83a5f3766d273fd9dc192674aea2b85f671c11c3ce6383107cb9c2a73329813f2a1c587152af061850f217b68fdbf6e6c528bd03eda6c2dbfb406617b04d1830c3d5808f540410f233d84e441471e0408f3a8210fa63c20c0830d1e5ff050c19cc23d3ddba419caeab214ce45a96327f5b9e34568b0dc5ab395668bcb5693ad5702da4840990470a9346629df774c71c70d77ac7007d21d3f42397bc8b9928345ce939c0be4e8d8f1851d63fe6bd05218ed99f5d06de619ad3db3a7278a6f60b6ed7293a0295360a4632c265ba2635291ec725c47b00ed7ffd77be940d32fc7744c753a9efee9006e4dc93a879939707324fd575a350eb135a8349545d458aa19000000500053100000181c24140dc8a462c1644cde3e14000051b47468dd9836d1649d54c81863600600004000400002775171a3e24156cadb10d96309df5fbd43f80c71507817fd707ca2c8e3c1d2c485cc87081f139026bb817ed313d887db583c563a9ebaeb5bb7465f92774d263f8d759f1c612a3d75c6e395969eef524e684d403039fded06032b9b8b89b1ad7039aab78d2d2f47692ba1e789b1137e6601a9be07bc8d895542b0971e36218b2f75be69489b84c1fe475eb70f9ee2f68d428f3f249d366b89df4583a6d4774b7559d03c9bdb48ed737f74ed6c625826a0006c7c21caf0724b86ad3fb229fceec5e1ccf3fd0df78cdd3e6eee6eedee483f8216b7e4a2dd6eeaaed2f7bd3bebe526a482e5357980d1cfe321c504e645716361f4761349d1818a174b657cc657a067877a3280ac2c82cf37b81a2e08cc74e7f20c4ebb55bda8aa05e39fb1f2864b60b424dfe96a000b7f94d84597095048a0101dd28cf37f4742b1717e4d0aa7bb14e47820446962155d27e3b9561af6014400add1ce74c2806852823a07782bd282522c52989188714c5fb60f17be64700c3be4e71ad3e92bd352738e569f5248fde93fbd02fbb45553ea760903b68a5da9b11740df2c9d7b33225a60b18279bc82351f7f7f974a1683920d4c981b42fe32395ec054b2949f6a39a3ace33cd21b2e356352a0a25343403a9037cc39166fedfce56c18b2b50eb9f6b8dbda5265a0e0bf4ce92e6aa0aa908736a8a57602b8a15f037d8171cc42a87db3094f7166539737a90b43a84344dc96d1377cfbc4f181761ebf30d4837fed1d28f2f0b81a23b59bce23fb8fa34a3fc048d61b171cf93ca840a4c69395ac7b4fad4e17b519e9ef94c1f3936f56fdff8441122b00ac6e16696e10909e7aa894156852d1bb91404fde7f1cd93c394617050641433236c309b9e31659f93dbaf9c143e3626036d248dc84a010620012796412a8d6661c6ca4a8a81a74b82e95e32a80f3d7694369ece556fe2148be8bcb1f3e2d4ee2f78501e83e229e331eae567489bfc48ead1b6133be1b837cc62c0e0de3a38a284ae8509a241e0ea0ca3d65b2d287c6e38d0ff6c5cfcba3375cd7cfc2f82f6f26596c900524ef851710d66d278b03d4903f76b00ddaa26ef7fcb507a889d598e915baa8ed2bd0fc63e68aa2cc46d96b8fb92625caa608a42be71154f9808222a06d62f4941b4907235e5e0cb6fc428297fa84e3914fcb8aa21f35eb1f4e3efa48d33287e4b1c525426070d5ecbf09e71ddd2051dd77b7b0d7dedda1b2cbcbb55ab504970ea21c04635b7f6d536c203f3d8a4cbead514548e382222dfd9723479271b35cf7887374495ba6a099ee386472ff770698215588c601b4dba6a8c981967ffbda66cc348bb3639bb1bc38bc1bdd7048808057c1bf480403ad0644329cec5701f92c861dc4ceae7755e8b3596465cfcc913fdfda9e5c348a921d980833cb0aabf0d0af2d233ac23c7f743e86033314c91709ba6756b364ed92bdc9d52003e54953eb85354500b251666f971fad0521fd20812e405fccd99035add92a61782ae43bb93141232aad6cfd8ad71087158ccae296b54447278c839e8536f0e86a55e2ad13e7c86df20524abe12cdccd9d45b144ef69afb4d6b1e0d50b99ddbd7187b808395f77aeb60e6f042c8fd21e501147273969bc6b4abc81744d90005d96c48a4b57bf18b91fe7c1d7a5258fa78b2879d15b9c6491b336d8b5b549573ee5c65930f4049f751bb77edb9bbf836980e34317c2314a1abcec9b11beb4209ee15943d8bff61b0b6ade42d640bd7ebe44ad29394855fc3fe6b19ac91b4d55002d62887bfe83fc7f431fbc3b5354f67e420a455fae7b4f572cd23e2d8a22cdce13765a36c309f4356977becf04e0cd9ebe9644c939131b62502b0676e4b20201db11e5fa8758c84a2f739c6ac1da4462c11ea5d729b9e3a3109166e6da97a247816fd0dfbc9a49a4f8996cb12f007c272c1dfe870ed836a4bf793e00ec2728fc7f1ed814d35f9384dbb6fcad0cb8eb2adfcc713b22b5b6f167a81ec187402bdb1ba080fe264942221a2b9067714f6e71dc0067b42e36b36ca7fb45cccb6739f75c0773b45bfcc395d0435eb8f8a125d7f1cdd1897982fb7c2b5a18919b3ee6e490276fcfee9631ed40c5ce0d822c663d996d823da258e0405d234af66b570e482f394e9590dc7a45afaff02e5bb4531429ab89aff67d69a376a83b935a9ca5b8157b7549994e1a09b8ab34bc5f63f2414f08829a599f4578deee8e044d68354970f442b13b9614a4ae3b7781411e13ad77fd496a91b72490e754019a7c78aa39782a073d3cb5efefa9d2f2d5905dc7873499e343c3e61aed628795593bbb4facec798bc7a4496508809e61e024b2b314f4fb35136312fad3a05e615c1b9eb706361f10d2bd919d7f1ba457288068e3db68386d44569b480dea4d8cb86702440cef39b136f09491398c313d2d8696d268582cadc5ad2df883eaec5d9a6c72eecac5fa2358745988923db4f7d585aec6ecafd99015b41fd0c2e393d81f081665b89158d5f39410969ae340685babfbfc2049d2fae3a3e76fcad774217616dc9d659dd46ea19b43661991db2d885eeca836e411f7ff34c034102160019910e831b48f54bc834c59e19962e952f6fc48077fcedcd2695dd280a687bfd30200ee1aa37c8448a0c56592691e48d459834139723e0c74c8bcb420a655a3e8d01f27b54ca76e627b8df283d809da70153c5483cb63e9801cad5057d7d1e846b512f6efcf1fd9b8a00210dd8cfb2af26287610d0e7096d6229e759c87545c77429723e4b9b1cdba6d30f74b67e46d8d73ecb0640e483c4007b1cca60ce7618a8bcfd7ca907090b16dd427fcfc114f471bfa1d20c8faa9c1d37bc9d01bc9e746a58ea6304698e5c5cc9faaefdb5e0af3de64831f63bf00451cc1bc4b68fcabfe1c62e029ccf3f9d82edafed7b461a2adfd28594cdc9a18e47af01d18fc6c6154cbf9acecec1d4d94be7769cc7f00cb771f49cf6463ce00169763628784172b58858c64f2ae55561ac55372d9c8ed559df71f0d0449495c81f12b77fb3391c31cc647d091c59c437387d3e0c54b4a1d3cc93572d6f4b942e41c83f67f8ef69f30fbf3216acf155facbed553df092374dd21211adf1331561c033774120c487b4f8880993e186ceb209eb0f2ac68b47612e1b83851d7c0ce61f90e669b2e3e364659c236871ff0ff5ac45d51904d0bb8515b40d6cd2c2f9acd54917957ac0dfbe845c9e9c915a753c5c33ce3b6ca9297faf3d6c8f896c91c1a58492b36934b3ad9d0e29898e4353a958e67a98c8c5a5d29c5db1f9f28ad797380010600a83d13176b3800a36f1776b94916e4d9b2b86448587a40c896b1e266c4648e2ba99176ba86e42b251df4d19ac48921d7283c834d02be558bf76b9c06ea22fcfaf6a8f7a3540c46f73a7c2d19dbde919c49c1f6f5ffb217fa421fe838393009cda0d358f2bc242293f1c0268eb2cc6a534196bdcee5c5358662e5ab1db400c9441768d050bd24ecbaa0f426f437e03b94ace7124ac2d667106dc9df2e05923249cd50e949efa52ce557ad99edef7ddc48831be8926dbb9d63299e09a350d4acdcf7034745fb19310180b52485c68306ef97d896f010ddc39012ed162bc5c07e5b47d2fa307974227a5cd3ea77b1351e0913563034fea7429e3f0aafe13a349e4ea1412db71df8200fd5fb4db617c34b842bc1b500a60c53153893bc8c74039ba79115da275b0d949c9f4c90521b9337972eaccc7b2c007aa5416e163665b51d3b22c405e61bbeb2465196277331caef2092e6f155e8b4ca1a8fcab8415f3d73096f305cc4502bbab3503cd0e90acebbffee6f1b5d5cb12c8c37cabe37e2ed497a4c9ca3475bb2a4c285638979b04adc41ea3405475cbfd9afb140bd7f899c855547b425dee813824694dde1038c6f22ab98cf4ae5923ec5709428eb27eaa863dbe40fc4ff665edfad82effbb1e811a7fd2141a9c46849f63063689aae5ade2d51bcdda66e335856cce2e66b1385d372393463290cc4e9a9490bf7843ab38953d2ff9437eb9d27690c0cc955b9ba451ca57a628ccf47709ae496133c905cd751494ee9a4e68ac14618c51c11cb1e6e0b83a90547542073e137bffb261c59008a99f9ed693070adebacb8409c5c4bdbd3d27303f4477e9e2f4a1cd4671b03836165a42d5a18b7855600ce7183eababb78327e1b097d06df400a421d9cb6afc5d5c9766e943f4f2c867d4761d840f4b4e09d6cbd0ee7ff11a93d81a7b4103dbcb8639c4e2bbc198667a3af4413f0fecf1b029d757b60d9da83476a2ae7d4a688b5c1b249e3b0ac94f3b97d71b690398ee64a46bda2edcb2981d1dcd227cf429693721c9efa560e9fea303ae39671d1df9132ad776aabecfb7866319c38cc495ae9568c30100ec09e02cc67353e868ae452f3f8683fb73a630ab79ae08dabb7ff4f65b683e4423ba5fa1abd67126c0346e2c80c77f0f634ac16539f8a994cce7ea77e7f3d21cf518b871277fe1923105b6bb9191e50595aa81c0604eb3c57bc109927363ee99f2c4db9ddb7af2e2bb166aeacd4857962b18ec4e1af6c5398b7e2c97edcd1853dd1798e86900a7406967194318f950c7115b2277443e2daa6d1c028af35fb91d7268857122687b0fe6a8b21c962fb1e371d6406b390313748dffac8394ef2be8e7a8a5409de1790880aba4d90b33f9974800c05cda41e21d43ac572d5d9dc1d3d301064d20acf204e6d44d8a6217b63a8c7b095cfb5088f12e2821d6d61719d13a82374022551b8f6bcc56c1b502b84eb9fa0deb0814eedc76308e83c3d2e493c2cbe96d7ebde5269f457f3511e7efe6aba1db8e6b1a106ef1f64c5845d9d7cf099e5872bfae2c9fb752a057057997ca3a0a203e12308d67fbfd4ae34dd9bd03c9fbc1184e3e866f7101569c4357808242985f5d793e9ad5cf91b69be5817c2f2d4c8f01757861d62f4bbef7bdd043f8f8fe9ee1fa8477ac2d2da62ee0cad16e9aa10ea8a989c909c7c5e48dfd7d5e500721d07a527f4f860ea3c92b3a65223646357bde4d1d111ac009c065ff50e68d6974e32227193e0c0dedad1e35853ef3761b1e029babd9cca9af399e0061643c11a65c42af84f2f8e3f38aa69d045a7f38cb18302b5817eabe5248a8b8a0d5d8a3950abe3ff237c4de42d16d2c614fafe6f3007bdca9ec0d2e57a4e82870a06bb56bbf3c1329535beb2c1773e0f347607daf93c2771108fe77073d8abf04379c17bdd89f3fa896df8890853ead950a3b40b1d200d72ae57b999796a75e3aea310c8a78e7533ce3b9467b9b0ccdef0c506464d5d1c46b7ea7a4d48d721375d5eb1b055dcd6c676562305f499efe83791985f600f54dc91ea511b0a93baa7e73b856ed206e6321a3df0386b1367e058292818868e4bea19f844bd6f6eaf38896e568190de16a487086bf3ac279e482b0913d5a2b4c7d0641bc48ce918d1ba6bb1c7e9c0d58a0eabad985efa2cfe7b04bb23f5d800d0de0ffa4c6c5e5061c192d4673fb5dcbee650739aecc817c64792f6ed9a97705d75d475b0a908aade2948910662f85acba260d617191717bd2f8326d92fb1728e93198d130b6006c25fda320d32351f912f832869a9a6c31af5d04a038160b194a0480f692195dd948f07b848ff42b3c378898d22b7e33d4f8e8f29a083ba70a5ba7be9372ae7acf753e42f5ab88762d25e0810f847d7b84e5f73506562bb5c6d815c74b84de897e8989dfef4330a7c0d06ab5a52fa8fad16913d2df9cea779553a35c2e7f41c6177108fb31fb5bf953128530674d1d37c8ad88b7c60a051af84d8437a9491fc8ca0311e78646af93fd18521f3e609387b117d4c0207c35d0efcdea697cc0ef4c96bc7cd639c9fd21619209f11cf635a92e17fe39df11cd2a0f68d87eacd8967e5a0feda6e7a7b18ebeebbd82e5521f98aa9f50763b981c3551b22762ae161805a1223a55c5e919f2f36b4272c0bc229fe64781a91a46e0e96256754f077e090855b316b7c336060cdea31c33433a5b1c6ca7fb66a2ed8ab44a8c6e5196458403d36aa07d1c7f0d678c632fa7993b20b0880d58e611b801154ded240fe3e649f264bfb04bf377d89d5da43e14b07e113b3770fbe69a3ffcc863133f826537c62f555f0ce22ffc9d84326de3592ff116399453711b6978da7dfa4105a5c2e7518740990d91f297002b88718ec311988a157922a7407476925ff325bffea886fe94e54bf5a993d0d9ea1c02c81682ee1d388a08579d75de603b53f57e78d5d53bf0c5927ad7891c9921482b5bf6892c995e6810109197b42db6f3e2e72f8563c989a865370f050b332209c40aa0b273d0c923bc440dd7c1708ddb98e1f1a3174e25ca082a96607728e86c97b666696c4e776430f37f5a754ea6f5a73648f2462bebaa5167c23ba80065d244cdb18b10fef334d91d1969d8ca27721b25e90b1233e8b44b8e4894912bb698b6d680d5f77dd81c4c02065586147f1be5384c36824d550cce5194cbf1c42d3925fd0cd2e816ea209b06bccbfa55dac3e78ca5a4be0e3f33181e3c6fd9300d9031608c73927e06285bb8075bd946a51785dd4a9c6d5d7e7e32768070797707b9a70d45d5d2c74f1f708d0a69eb50c231a501c6702639cca7f5c09da976f8d914230ab5c5ff788fc1e4a39481a49d737408d115a534c344c763d94b459879174a05bc8240b439153b372f0d516f89da1a804df2b65a78611da9d1ff922afccab36b82f6eb30e6f850998fd335afb9d29e4ece7709b55c7f7bf8f5413a0cd236e3edd0187dbcdc9455eb35bf0bc69d785d5141e92c219ca33d09d64b4c14ed0d58d9f02233dd4ced9a379993c0c8541c35c79c1af4e6c60982dd8cb55899a787534a69c72c00822bd0df36734805a65419fa87c7103fad03264e11307d06e614c1a34aa0884ad300dd5e5308000caa68e812df133ca6f14a8abaa185ede3ebb59041f6c566af611c46d5fb7d2b24b1e0b92d9ac577007b8489e6f41927a38fbd5b8690328c73b8a4e65b65c3c01c205eabdc3207c167e07b08b88a2b7b26b01fd1725cff7774df0920f5b76275d8fa2e0d9272494260db19a2304c01aa9ecbf699a21e7c3f6532cbd6ce926fbd4ba2c3a58be347304dc97f99783cd174f42e53eb8a9e2fee9dd2a995ba554d7d4e8ea475725390888cbb95119d9012b2eeb8e64f749d9783c902ea548d2bb17160b0e9c34ed05e1af04ae9403d7cba9588b0f8eb7684796e4b04883fb5580f6142338d970303248f4af43fcefeaa420f86b4630fcda9d6bef478c15dfc0fb2e733f16cc0848d3660bffc3443543c2c15ddd13e7202260bf07e6070f035cf4de1bc80a33ac174f870f8c009c64a57c4d4e34a3a62f5af16289c8a69550c1bbc7ece2631cac9a2001bc1400549b4138a051ce3c0f654e360fd2c0dabcd50b0b7da3bdc421fd7434b0f43cacc242138f5486a040a41b465cdee75ee1b27733260234e164e529d10e187ab413793dbc35b3a1979ecaf13528bc6e65e358dcb53c725de6e3d370aa58e04f6993298b87adb167187715659b2e85f755dd0648a3f3f5f009cffd81647764e134f8f32cbafdd79b00764ec24b02dc02c582b23fad89c39ac54d531bece98929bbfbce8c08f4adfc8ebc0911c5988cb0df10d8feb99ae89fa8f77e0fad3a8228d2299db807a695632a047f8457efb1e535990aeac15be2d6573cdaf0f0cea54c7f0baf0d5280815c605470119add45f0ba2cfe6af5c18ac63c75377891f458381eb3a14cb4ba9ccc397c67584e41a7ec17ee2207d48dfff7060125a1006fb1a2096e20e94d75eaaa0771c567ce85aec684b405ce200cf429c702508b899c74eecdc95ee08005d0fe2feee3b15b07728535421f9ca401a27336aec80bfceb6872f72865b07b0f343909ee7457d4a96142dceeb161a727d23811c0b71b986bcd54d17977f1996eb6b293b896232303aa8200c3f277cc5a79a465e127647e49134bd2b47b7c6fd1e2ff863dcd29d77363deb15f098ba98d8ab34060ee7b3ee1e16edb09f83953dc9d3202763e673a0653aae4a5006e39edc963045ecdbab1495c2e44b36dcab62694f35b99f3552ad5d3af077dc0f040ad48206eaaaaf22020dce7f33153a31f1f1e2cd3d6a85973b15f320ea047616cf67d2007e6d0e8b924fb660fef00f2451bcedaf860e5389474abdd8f06e40c1a7ffdeb8dc6c189c1fb6c74ee7a0c726b4f86cbc39ff1cdb88584be247c17e4bee8a1baeb82fff42c1fccc3efc857047e721870338954cc167473ecec22a7552e3b16b7d7da5b82189fdff58b3598b892907ffb496f919a471590b04106454b22e490a7027e449ae3379193e4670891575e9dc661796a7063ff789883ffe7b9962bb92f4ed55520a14acdfe49ee9c563fcb1cbc006097f2a2da17edc7a04e07d17137f3e483d29f0ea420143c9c43ed173f52a292aa941c611f9f579e0282501e701c5fdee386bfa7e5b12ed140bd15be54913c94d358d95405402762f0c4eab6e2f2c21baba3bb722887ef0ad7eb5157ff07b865ee2525f27263101adcfd8e7c9369304c8c2bfb4de777bff0387e31361c5e28a65ebd86ab835e89b22c67afab7c76e7be5fa8cc787e40348607c3e0b3cc394e1453d098fb14c9e8973f5501d72077cb3aa1f82178b461a087430fc62f06163ff6411eabd8d7dd19f4c6ba6c274b1b1b016edad5c87f6fd16ed7267d70777ef19b19d8d40ad560d5e1739eab8cae4792a7b5d89812ad88e7c475a8459d69262be10ec1f91c3af1d67fe77a6fbf7f0d4ebe6ef0bd166de7dee03761812e2b1858fb944d7cd5a22edb8fa5ff83fa1be9c5ba8b8e549cec2505023d195758713388d22c7035dcd4354d7aa33767aebb2a2c587b7f42f70e337791afd9547af8fc8c4bbb3f80d2f36a96502ed3e965fdcb566fea2c8a2253690b9f5a3801996887af6e44c10340469a7e4149407de51ee2e9eab83fc854b5612c13d0140c2e4d01afa309a353d007e0442283e07ad6fbbdf2507d9cf056ab1de56c919c71823a43ad718a1e45221dc2ebc43873db969d036e0950df683d9d3273c08647089cabac97e551e043fc87ee82edca133daf03c00070603a4fa91280d6c0366f347795597334fb68ea882d87ee1f87f4d1a9f638429c3a75637d78262143b10903ac4123bb1e8e36a56473c15d490fa19066d17e9c45aac5c838cf4c8ec5ca20208553c672184ab065802d4c959d3c778ab4c5d1bd93f5fab5fb0e5cd2d12dd21cffa1c1bee77e29327577669c64f005ef8fd06d8c3a44e0f032b233c7fa3fecc6bf2ecaaf87948e82476a97ff2ed5a830af9df585ce74a097dbf04e306ddda7926c2217eea6c8daaa92a33f95799daace88acc0b9aebf0f85cde627d9a58c003821ceaaa52245c59670bf8de4190600af0283af4d86cfe59a8c7f90edddfbd9ae15ea04021f3c0b8bf9259f6cb9a454847708755e370094511e715aea178c5d3ce2fb3afeb3456f891cebce1ea3e768a49afc4a7f6828d8036513cd1bbb5d07a327af24af4c7d8daa816a3c1a9be94ed60f70235f30ae3f3df0e469eddcce81bd2c8473c1f8d3ef02ee93f93367e53ecd005cf440cabf0203c08b06cc135c0e892ea47e571af10615223522013ea483b35137b6c8eb492810c6fc6d2c2dede45c22ffde58a3902cc5be61cd95100c3ac9ccebce100a3ec1c315640abbddae20eecdcb04ffbc9c58b7be1c60a40ddb15cd640b1b048b6cb462bb1c0b055d29a27d1391f7edb4264bcf52c7c9a9d4ee00e8da32a0b6876e82b11f41430552363e3eae4c4435218d95a09deb2f576df0efd71b34410df5a81ab656d6508814cb4702e1b0ede6fd08c03d1f1499ad31e046632a0472d03297d86444c3c6bfda8a4b8bdb748c683edd71551b1e28135637e064f00dd2720206e471813d9908fc5303d37916a54fe4509790419baebc00d33afa6aa037eee719b95f8eafe38f0f1267393fe60c9c8a1ed911a1443522edef65e21a9f4d90068a878b7855c1d50fad3ad9881bfc14ca70c4602352e27fc991ece95b7be797939d6f2e79e94c41bb70c2cc7e7433d907dd7ef882f38ceec0a43e648b072b19efafb84e60be3f5ee478c235385ee3fa59a1d6a324781a1b39fc67c9d1a956163e20c2fb873e057ca0703f6e1dde9acb60bcd2668b9b4a21763feac09557918ffc4f4eea0a4f0d9cc44eed83429381337c8712718eb9a927ce6cc0293bf836cae45d535a45159196d4839700f6cc604f3d2d8c584c0155e30cda8c8c01717fa0c7e5d9984c4c14856f7767a6f730538e669de833de781c1b271fb9a232d15700145b955f363550b57452a63da8dcbe91e46a1216106cbd184e90eee6ff0d15acc2b25ec79a74aa4f71d6b3a5005fedac263db7ec10f5071ab64bca6b59eeab8e7e035c4ee68396e79c28f6cd911798ed0d31fe99f342178078322a49077089b0b03864874150a5c689190c20ff20d2022679d1fa1c6d34f62e26ce115cdf2599e9cee7c1793f4dff71a43a40a56effee4d863233d7a6241d1fa82146042cca02ea20d2d1602c6eae8f158c5a0a60be1360dcfee05a38f682a99749ef3ddbacad74a9d813a1248a4bfca18e199e164b58a4e919862a287aa91a63fc07f7a07e88d0bee25109f496f98955ca29a89738fb5b3c33a96f1d3ad6b2ee027dc4170a339cc9b6e0713b9bd628f098fbbfbcb1a3ddb9436628998e592f72548ca331cc564ef923f4d834cccecf4595071a8c235c1fde16ed8e6823b9824be2b7f030fbe256b0dc35f76eabea2e804fee81c82dc47e262610a7697e2a5a4bce754320d4d44c30859d1f49b848b0403ac81841b9c660718ca144d3a039da6e17c39375be90011f2099cefaa288f46623856d77f6587688b8e38a1a8f5c204ae9c2d88ad622e89ba77061484eb283625d18aee09a88d852db82dec238b5803ba6a9309297e2a37ec457b29273b2be5218752f5f77c2b86e755a05613055ea2625b407018b5d088328b92e49408263f8bc8fe4ff2ac70b06d4006baf4c7afb1f389453574bd72162b12cc8e7f173226d165af8735e024371b730f4674135335e63f0b25d131294b529d9db250a9fb84b16c7373a116b8c16efc1ef63525e89a9063e09d8547781d7a24126d23bf138049d621daed9bf5b70e522760cf5816f23b2031adadd6ed6378beb1d596f3f7b6c509eb57dec36c6f78decc1c7b4c1eec68941ecf57ea3d5881ceb14220d00d948b310348ffdc03557fb6184df31324ff5504c56f22f8c056410f922c32bc1990d1ada45aea152e8a52aa58d591da4c0562c8aee15182408f5172f8f5a35675a6776610ea051930b52b39d65da2d341b02fbcd7e84508cfd7e0dcbb5b4054b936d41c91948b89c00194ac8f23d087ecdb4a508ac1265422edfdaae7bd768cc67fd19fe75b43f70a8bbd913895cd59899e4f020a1c64ef2ac2cbe46064637873425782790c2e5ced53bbe8e83ac5f56f15de66ece8a748f15402bb7d32bd70246106f97f728e36baeba596034846168b81921bf21f90e3ade509bf411c9576281979e61851f85e5afbb1b5f591b0269582223dd51b073ae5106852a4dfac27e953fbb4fb873668aa015113c7613d56bc3524fcf02918f95fbba16661198676028f3a0229a68883a6ac6c8d8c77e878f73fbf84f54c5ec37bfb9f25ff0aa00f76f9a96217d21a23a3d627edeff01e39000f644e6bfffd25fd1cee1f1bdc3de6bfd0010708781f28d2bb777de718c22a6c5e4c6189a11719d2f24a18b55fbd02b3db45270d4488aec686b5f6a7afdc2d132832f6b947cb6250a0e82204d31e3933ea780b8e90b4238a3ceb483b0ffe4760b0abb85931f74f3211c33cf486ad7c7b8cd71d6662479c8487b6b92bcbd9c81b3236b497911f132d8566d0a07de0f8e6cb0ee0c80bbce90dd211bd0439d123506de95391bdf26379c641d8e577281d7719aea805e5a0661576ab69740fdb5b5f578eb5ffa614b586c7bbacd7269afa70ee2abeb92ba1587c5c923aac7b87512589eb92d1bb1404c9d1bd2b4c20da610242f4043a7628c21827249f6ad51ec799c2018f0a6c3c0b501008f14ee6942152f843569b1ed03d866d0945e3b9fb819e4438006513695915a3035e1158dda51a6393f7be1ad08ef88673315be260c55a88e24a89dda96c308afa221e0a10d08d933006272088972d2dda687f27a873311c30a3de6573ae3561e996e4b0b688e29e6f40b32f9481d70fc4074c975633cfc71a966f0eae175e2e74e3026fe4c9bdb1ad0734061de6d7e0c52af17648faff0b7b861f19a8c50e6fee04514f4e4d2095157f5366ab71a00495ac353a5ac6f6b0b0c56baf80080356e16786042c5e72dd5e29da871dec73e6a1f68148c7117a84bf6cd00116143fc865b4d431edd449b5a2963e9748e6d88908f7909318cd48fbaa201dc64b87d518596ec00372cd3638f7fc326b623a1922db1a59d77be8148428281aeb063b60dc8e0a91df3f2a49d2304575a5f6d9c2cb8e7baaecbf6f5961d3117436a829a43620b859a8ac4de1f2e79f72e30d08122fd0ae2e3447e3ce626d4c71f1a7a7c126a4f55ad6fd380ba9e99cca42a759bae5304d26f4cf1b53d88cb112269b547d035d482990125688a3082401a8f1ce8e3d20ebc5517888c4d180d44c5108ab013f55106fe1c8eeb4f4ad70964ae6dcae3b82c73fcbddefe80dd4280ee3818bd4ae4bde751b8a3a0747d921577ad0f7936019f23378bf850a6501e50b19344e7734cbc462e0f492c2d36343c13785988e617429b96166108c12920791a3ef18b7f5e252631831a9bb7664391a998455aa7d742fa6b49fc52c7c759d63e36152ca18c6ab846148dcb351b07606333ad7668a6ed69f1d6acc9a6ecfaa8515845469a426d64dc7483d4d90b1e35e14386036d680bca3632e9403f385c2b463dca9799a3e57cc31fe40b633744bf5f7cb818c5af7a8f27c9a4d88b7daea99ba1db01bba02002d2bec3075796991db30ec1dc2f98929c0ef031b7446206c9454ad111226f19614f391eccad26ca805f039f6d3a4d712528a00408045172bf502b5a5c90488c4f2c6356061f01ef33fc04763c086600e37b65f581bd24a27c9b39a7f0c71b9cea5430e36e091998b19afed0741a66bc5c06089689e8111aefcece76e8a5c3ae27d1913ded3d60f17c989d019146871c37bfe619287d227453baae9b2020f46910b821c276fe3266707a64679050650a22e2133aa7a0f16b34345144c4ae87134dacd0e1ce3abfeab8a55a7f9827b2d0892a369d4051bb0c3cbac10d04f254f0215cd1cb4438293c497cd186130cf701ab42e94ff165ffc43310fcdcbbbe5fc60a25a8546e4274199d30d213708a60f739f2cad37ee467e370a3d517bd96ff405cfe44406081334a00ac618c80a681892d6c77852a57ea8ea3a0184b8891f25277d80e941b4fad9b3959fd37e1b4af560bc46c08c868fad56c0d58baf73e6466d959e7fa4047aac032ef09550d0c748b045fd1799dd0d5a3274c272c7291af54c621c1d35379f8b17b5ee8ccfbbe94e88ce136c3d990b9c0e2e7b2372080532e836a6340f730e95dfe9d74f031fde53835a19943bce7b52baeba50b8a2111fa65be1e97b5b46c3c0f2d16105a191dbb0ee22cd5820c28e8020bdc2cc92b0021f5bbb78e8d5b1045b43c482107b6cdf2d0dbf8f9ba124e761136e84a1ce9b0094d484fa620957fee615abcf8441348e477fcc64bb493316b0984de66e4d773e620a22dc8919621606c78ffe63b4d3db468688a05d2c5060305e203ce78059c49118577d4548c462680702fb76910eaff70e27419cdfc7b1054d1da93677efd4ca53a0becfea6f2d33880c4c117e2d057e322a7608f7ae3323eff09622bbe1430ae4eb25f090470ed5684ad9d119235ebcdb3e3c2724f2acb589d57fd55feb38c51f5ec2343e1305a75e0660c875c17f820675af3a382e2c3e47e5347f4172610855131b863296a1f0b887fea519a57bc76aa6df23d7fa723d3a749679d5f599c76d130c9f97a66f8d83313ee7c0083fdf5caa5fd459a72ccd671c3d54cdc681cc82f6982ae84989e663caa45ae7346adeb36bb7abcc2736b763c7d827a97c2f701992f11b90791307ea793daf7b20d0b57aee07b39270aa754d980a0b600946fda80db8432f6dd1b420ac08242ca0196960d12c2a00719c1ae439b94d43082d2624046a2fcdb36a93826956b827e1c2e6ee8aef4a5c5c2d5442252e5fded5a2fdb1715943b656dc2e84643bbd1d7e85a66d55d6678c1314461a71ec7635e8f94acf22c15f903c2fe3df71203d07a2bcb2b58f76d9b74f5ee302abd2a0cac12ae0abb0ad118db49ee5632a6e3afae38cb07831e5fd6243aba101d532e58c70c5f5c4e6f9a30a7600e75254ffd463fe55f947ca6d2af283cb5f3c4e7cf1afff93c707c4d037723a2be99b4bc39e9940d1247c9f48752772e23344cba813cc76b9ef7dadf50b7f51e76744be74741017857c9357cd9c09910f34ac55caa1b5a768163a6ebe8b289e315c090769dff8c983ec2d66e65a8b3131cc81812d8336c5170671867990015d7d66d12ef26c17c48d40d686fdd8bc8c7f07e87d4dbc7583a7c3fc85ad396adedb961bce0d497c2384fc8432ef0ae40df9b45d5b09e811a1aa5152035b26d4f396c54cfa6661389b37ec2a48711c33dc258a1f53ae0281633a98083bb118a7508d114fd003156cfab92284225f7c9f2c46db167386f730d7ed1e99508baa14c300e337013a6633fea98b4a52602153186d869acc0b44461b8face84c3be8e1856d51b71f38908bb1e57b09aabadc53ea2445fdca47913840bfcaf2d2854a0f6a18adcfdf0167d4ccf450e4a891e3485f6c58837e983a25d310392a5ba70acf99ad481f1f830a3b256ccbaee8b8227a35e8a58b28dc0d1da29a6be70ff16734d580b26606c1bdf3afbc7d2bc21ffa79928e43bbfe1ed7fb481db9d1b1cf91c7d7abda83ff750db30fc7e8bec7cbfb369cb36fa021e943b6b47ca28c9c56765e9f7c61e5d5110d898b05918bc778c726a64ccf68a60a4d446e104a32af659fe3eab134fbb3193f83b3a9fd39ccb32f2e2dea2da23cf9abbdc8f15f224983506056f87469511bff2f01b18f25c9228f152fc2310529a28c5553eb71a7a6801aab79a472f5800c4608be08b59f9e7152e3687309383a2d174abc57ba9e7267c834e657d741e73709fd77f76c0289d568a7adce14331bfad9a0f33a4ca976804efe23db5ced0182e968224ce30c924bcd082e995de57faf2573d4fda0ed66eb3ae0d759865d4b7741dedd3c69981fa17dcf3b8ba773bfbf75cd2445f642225fce3203d24f965ddda233fa41d66710b6f154cd4958f3a32a819881fc2ff1ca757d3386d408db447a20b68774b0820074fb97481611ec3bf3e264b01481fd107025c770081994c532457386e1dde683397b8f28d8307af81e240eacf4ca8a513044dee4ab9ae80e89c23cddde6ad871345553c3cf5a80cb29106d71839d1085a4b710fbdc5bc82c37f033d2be65661c56f33cb905bf0c12b4bd18c8e6f786430357e35daa5693099d67aa69c036416c37519b933c37ffd02a5f63e7090771abcd90f7d9e01bb9a3ec919a7cfa5fe38c82a80a59f5ad1ada62613959a2c1f3a7a0b7dcc2e5a2a32fee6e3a8f58eacd2d840b624199f7d1c640bacbf639708e3c9025d19c9bfc6794b5c0bd33aea9a67d79897e8c0e48f2854e44a3f0f6a9928c3ae400e01afc26acbd75282f76e5024b7af66fbd3097f6081cc020d62773e03438bf0d1dcff01f272f36ce1de013cd8e10b1279a375dcfc95bdb1fc8361cbe102636390cea7808793be4b2a13744110a504731e6dd06f0b740d556ef5891368763ffa4126389fcc256ab8cb9fe69d47493a615559a3cfbb059f7eb8e1d77859acee4b6c48a401b60123d4ef0296a888fb67afacb9cc5da7f09a912beca4a62b023f10b3b64bf9e28138d9c01f87c3757cc8b3cfbaac6358feb11cf8fcea8515b6268c34f672a3e83de3ddef7f2c5b5488546d26108b28e01074f50f180133bf2ab757ce0aaed3793727f2e987fca522f29e8ca35ae335544a7b9cde7b8013cb9992d660560b5e3a603f48907773a405e70f56685b9c36504e30181c096a0386a98a03aec70705033154efa3aace2c4f39474751e3d34b084f692fe2b0069179f0446d012fa9ad591608cd8da48a7d9c3eb06721fdd00e020618ca20c2e9ac66c59777c38088cd9ede70eec1ecf8ceda63d73edc792cd4414360d684bf57241b5d2dc6b81b5ee4956a6313fdbd41ad6d5e8edd070a21e755d6528af5865961676dd9f5940749f36c41fb8fd8e51b83e8af26d88358526b2ca4e1a2e1bdb7f9d361e6b33dc095d18ed43be423d466d004be044083623d22633eec7af79711f9bf9b8b18b47c4924fa9aed721ce2663a7dfa4bb13f9138e28f91c9d05cd88c698a00e34a80d0cbc402a7abd1f00457f2807404e5fea8e51103140ae88a2fa49d76bd4f72d6152104376652bbda6fa30dbab2c25a0e3417f61c985d7c90af74313fd1da67ce86adcee4955ff4fc502d24b0bc33cbce06ce002b7e5b367d9de5ad44f6b676cf27db35901071670afe22d54c9b1233db73836c4e6ac1cac0090b5c3a7f4b51db9de5d1734c631f49c18ded45dc2652548a659f19baa99a63d62f5cd9608b8661cf7fc88ec0ade0d13568d8cc4091e07c7d9d8544b4b521e616ef141187ddcb9f4caaec7be8d90cb66ec8ac2f78a19c48f7d18b55d596b7e6aeec7c3ec1222fad3d5bea16033b6ea9ff30f94e97d661e922ed23bfb9557fb1742bc36dca6b202f9218b2ff870b64c7aff4acd74513fcb8b1d456c917adcc57a88b77c978093edbdf8a5d4cbca0319f731c8b61253a77077ac2d575cc29c65290174ab6bf04860b8168737dfc9102903df24368f1f7b2e178eb3a0867537fbf301dd75b00070e5715cbbbef5f1164c30a0acaf78ea75b958af893f4cf76def228bc6ab77bb89d7977d26dd07a957c35321ebeeeb8e8b784947a4c5c44c85ee3dfbbcf8cd429f2cdc161c5203aab4b572b63f2e40759197311856661a94e1cc9cd9aca266af0489cfcbdd653a6ca84cd1b70175bd6ce932840f5f9dfba39dcca3b15b8bcc9d7a077cf38b4e43c2d0579de4186a7db488367c2afd8cc8732d7b3dde96a334335804c0bba48fd0465286160129e4481274a79aa46b54e93c2e6b557fb2d2e72de5f0f92079de6b46cbe80af70ddc05dbf944d01ef405129b75cfae13b113425d8444715edfb667ef8228415d7cecb2402405401583d9a714aaa3b8afb9b9b1626e82f85bd8d23c1677f9be212935ca19d341b726495f50d178a17db767ee7b105b922361938e6ef2420cf5572ab2cde3a05894170bb10df9a35a2e5a0d9d5a9078f169825924259a9ddd8cf0b7284105c4ac8453aea54056c6ace84413998ee6af9e2d8cdfe06af335164e90275613a357765f1c55c718d037941820d837b766264d093bbfdc7b703e589a9db324df79612fcef727e912acd2fbc12c395e98c7d8b1278d5a3facfb2093ba0a2cda2da673c300c8747da11574389142f859a588005ddb716964efe42cab10f97dd4a04a3260a5a6026825e1129294e92e7f63388d2923e31d8fc74a34a0a42857e41f811d3c74131ab73ceeba63417c3b902d4b962a476d8c8323527f6af03dd7aa2add82d9e5d21d4bd3b63f8d5508cc8ccd55c07a3e10328ba0c51bcbb616b001141ad6ccff3f3a52ae6bd1fd4ca26c6d2c219c7bf9e79d7a2e3c7ba9257c7b5092002ecd22082564eb9dc786681fe513752b2064882ce7dd52c19c32984ee445399c00e09bd31682a5f0d7b8268c65436ba0d4356018998a8dc55b108c85c25e42587866757b4341222cb7008dfdcfb23e80fe0352dff5687b3b98ef8289650de50556b045ccd304befccdb98564b82a096291f8cdf2760984f3a5290a44e3871e8295d4ce30812799d74142d12bd245dcf315f4b211384f454e489e87a80855f5edc06f7ba2ebd1219103f1ae4c0ece8e9e7b86b196566358b05cc4df733a2ca3e5cab2fdc14807f1aee61f8988252b09f975d591c82c0db757b294e16594f050824badd4fdc72bda7cc0988fd65817435a9cfc5ecf0ae843a427087ab7c2fe99ff5d4f65861a8bb8355a059593c638fecbf1e3a826ecba88b6706a738c63869960964139c3d0270f6aeb4a99ebbb0167d39f4efcbc8d84c7b0935899900a22b627eb81ea21dabe8162c59ef159e27d7df1fc13d46305e063c08e38fa1a2f902cf4a1ef9a9283f950a2b9ce2ef5120a77f313e7e5b123c64f0262a11e2327d243d216cc9c58fb1ef7b3994793308c3bd16c10a0d18170e663db168a09583b91ff6e79fed89629b3d856c6602382e5409d99925aa9c119ed429896044003f6012d99094afd538de684beba6b7652791a8a5cf3cc39ca1b042183b72a4339e9ae4c3196da559cc8660297bf7c499e329fb91e7279aa905c9257458f8b6d393ccb510c8b509b941841e1961a04bd5ae7bdad1b7132039f8d7582d268021d3a9ed91be2b17950d7a099dfe963834521e13ec9a009ef037c908b8fd40e854dd14a69eb2352ff34b3fc44cdd4cfdc9b2068c69794998649b60252d9ec53ce26c30323a7be0a1d9d2e8dcc9241d66c4f8baa1878a66b4c3d20318f7cb8119a5a146e839291b1a2dfb1c458b63f01f802ebb396276b7631605d285d631b0245bbb3efd7c7e23feb5c8456d6cee8430299591b9e3b0aafeae5fb0349ee5408ea192cbb605ca9957d1edeb73c077b7f08c421c4156c966017978faa5301bfeb8174e71731e1e08101ae94f23449880823d054c3666ee2df0d44641641d218e3c297868bb7b60d9d0a92abf6f012d403850546b74f4f85c1a0b4216084a12aee858dcb42edffbac874d5913fc4c19c893c06c9afb179fea443106df3a19bee90a03da1acb91ce8bb69102d4fa1c5c32eb3bbc478b459ab40428ea0d9c4381b988e037b5714621a2c733015a3240eb88844075a1807ab8be0318244ee29076f71d9f8a70c88e30f36c992efc24cf97666adf3d19bea51ee0ec446856ea36020bab08b7a543c33ac54794be993443b9eb60dfd9e55a112f64bd2ea993a220a46dca03c0d79634f6c63396940b1e7b052747d1651306971e7ef68338af2c5dddbcb20bab86bba3c2b43348c31284d9b759c7a62251a47203ade31ce59a9ad379f21f9b8279d35140f3b8c1b02a0fb61d1c10f7f5f8cf8fd72dbf29fe5c51026a557d536d2eeb105b53aea8897aa7a6f0670429f948c44e550a0d914072b73a8014b2010a6188e915f83981895bd3f5a0a3493aa1dc054fbd7f9d990dbefee196519f2ca6883d1118b85ebf42c4c50b655a7201d13516671a134d50284bff0ad0bdb09a642f3c149d889eb587d73424b1a32debfac2e237cc88176630518141aa95eff800710bbe87ba9ddfbb24defd95f2b706d96acb173bdb27c42d9b5a0198b2eabbc80641676ba36470a070db368460d3923af702771e00ec74270081b3a0bd4e043147b9479bab7ffc6c287bb0f5995a3a23f49393ee0dc99d4f9c6368b10a22322cc73741c13e90ad22260bb6e01ca9849e002338e225d1603c0f31949bc406f8a9f5594225739d39227158c362c3708b0ae5132b2224e2d300ee728f9917ced6901cac10590fedea57360968d08e0134e50abe98d3a12acfd393e93a526b6d6cdd88673aabfe7bdec8abd88bd6d07db79c2025e19661fbf91cfaf830f763b38f52a7448f1398926105ba8e4df2ec3e8b5089a60e6be3b649181c949eb2f9852670ad6ab8a9b538aa4b69d0ef48b3b10b06dbc8723b837ccb1d522a7ae506a04b72f50cfa0d8029744da6d3633f95df991d2dfe04842c66a06639cd166f741b5d9d5c794fe3761022f13ccda325af6e7a574a012bc766bd3f88ff20248afee366c2787572fd475d9f2a9ece7994603213016e52f93b13429d82d26d13b2bc0b584a4b19a5a664cc0bc5772d40f77cb956666e67125ffa396f8927a77bd2512bfec6ce210515b81ed8f56b4be8b677895b7e98d3ce2eb7959aceeb05926b0b2cf7c47c32c93cdd464445b4983eaab69ced1c1e33e60aebf28cec6e2f957aa635516e881ee6ef78862e828859161a6f2cedba7422d1f6b35d7c0e6be66e29510698b73d202c52dd1e043800fc32ef58e5b08312f240765450dec88fec10d5131b04d83cad60f921ebd85b7379cc879a4f33ff23ccedbc7787005f55e0cf19c39af55315289af8ae296630e85ffb7b3df5583ef8616a39011bf9e3008e02148d589c904ab567674b2c46ab30be054f9ae23201323e58848f789ee48d6d5f335941c3bc54de838887327dbd702d2bf7fa861dc1421bf8e76bbb4adf1207a43a155ed98cfbcee1cd6cebaf351d124c1bc1179d3eadcfde0f22a88c8989aa9db91cb79d54171d796877822c3bc2e1562a2443edb6ab0a2a7f37a14e76b028a6590d4eb80c30ccfb5bc114b4c4153b94e122fe565db7be43655d8b88053aec5eb9e2f65bdb00574971e4b59cfbe40db65204821fc04df783278f6e99e77e3888ea5591bbce12810546d759d278f5c90ff46e33d3f2ca3651533e0122c5e4135590d486ba75d4c6c8013cbeae0786b06c4aac200f828c8a6961c6cd8b538a82717996fe49da94f8233ad294faf9c3b24ac6737ac755b44be07c2fc96f6b688663dde191507238f2bceac46760f726fae51697c06e7ed9b5ce2cdb499388067a40388f59f7d87e37cb9053921ca5a26ac03b1f533367da375c4a86d21d7249a66257a9f6bfe3ddc0c35af0d945d7863fef070007f71c151e1e22bdfd4494841a7f405a87fe6214276c71bac5a6f959e7439650973e4072467a063cd51174a4373ee278e1eedc3b0525b8ba74abbe0a51bd950ee7a0b7f58503537e2931561179fd81f6620d96d05a1ce12a9588bd09bcbd0adba6a3b836432dd3950c29c582df42872e21225f9ac6c24cc0cc81add0518f518b0745207957b9fd8d4f974dbf1367bdfe6a757b33d6a5507c9ae0bd8483e4a5333d164d88fb4bba5d5280b4fed5edaeefcb198ff614ce7a3cb765dfd6a339b1d1a97f9a3e030d8c540eb64322bdfd77ab8493c5b1804716a94e973faa764e88fc59f9557ff259c8cdcebc62c6630904b0baab372ed174ebc92128aa5f1a316defeeb9768d8953f195a8a08e29185c56dd5624f975ba1c500d9e21e82ba46343579b241998baecd1d9d840bd48f094573a6064612bb4cf730c76199051b14fa2d882af6c2bccfc70d068deb1c24dc1fc5ced0c4f967b5b58408d1e0475d7cfec7395c6db77ef08abb88f7bf2aba975dd7f733362a3b61a1dd84d0af2fc069d688b404d460a4661767b7c6e6ba056ab141ffd59e5a39bb96a6adb350989016f8c6d3dbcabffc3958cd035aeedafbb0f1e6976eaf42cbd8110a3dd8b6871779a9b4d39618158b0876567b3306c12a1027ef9a5c4cf74f486c6e4d4f808d4656625e7c05754a54b499ff679b9a9e37d376f67b15f10001fe2faf3fd9f89a8df44ac7bfa64a7901fefc5a4232201eaf8d61ffd33814e7012e51a7bb1847a35849f522a00889dfb618038d4a35bca21f6a1292a921e0e7c6b87b77a73d00585df2a559aa3061a851f40c4d2d9af5e398a792f09bdd8b72dc03b4f648cd2b31ddc8610fda382040e8a8262ef3100d158888fbb2aca235482c1fd05fbf5f15ed8ee0e39bd643f3fd0963e77669a72f86f04157134a56a59404fccb4f288cdb5dd6182523db42524102b46662d011f34240237a017dfa56f857e732c8071e6ed4d9abf67ecee7a78162ad46393da94945bb9e91291b15d63871848a79122f652cd1311b5fb1d6e0d80b47c27e9179e7fc00651a8a4573a71ec348fa120d90f27041cfac1a3c3df5ca7fadd77b0c1f64f6bc62af40f5e47eabe93e4cbe0e25442b0043e3f55b12fbbef210827b03518f8401cf9f7d2090fe9c889bacf0c3b35bdcdda4e22a0c098a72fe06fada48220109f57d30a56a498c6b5060629f5c0859d98a5a6735067cca06c44e9351d531a26362006264bfc8c1bceec9111b157d582abcef55cb9be5241628dd22bbb92931ab09409f9d5e04f90250f9b4f16c648781d4abdc988716255429a068798c64497d20b22d0e380afe29ba2ffe570c9f2509c434964869e4800366b89bbd3950233276fb561e940276338d5f485953b494c32509e14b7b584002c889fc6cc68a92f262498fe9ec3288d2eea7a4288377af78e6f29a8e2f68501a57d0d9cdb246eaf32240cea76f93145b24a11289e0a143346f4f09285e8cb6d64799a83b307f8ff50d83c2de70e4d73ec80fa8bd6f689e53e57a6f6e5dad847d0c0a1168eaa546215fc45ecc8662427a15e44c356809791542719226eb21977f46c680c0bdef68f167b67af47b7d8bc8128e0d5b1a28e854d252f5b20b081af2a86369a710518a754092d1a3330205341c31279a96fe04a60c9abe2b97d9b953978cc7a12f30d2a0226f8898f7807285da2268f78cab075cba6b367af136caf5024d717a5cbd15f99e441c3afeed3c6f92130c2960ba487250a1538e7e1aeff17ae4451a27d51bc6943a6b1f56f41b27a56c8914944ea48cab098496f35ea1b8d44aa81615db4328fd9aafd9488c5fee59d2046401312dd60b3efebfd18f8f156168025c9a1bd64bd79303716913f754b8f8ed156f617c0bb6c28e83998f2414b0a0daee0f4ee3b0ca936616c638f3022ca543508ab108d4bbd342cc4845def43cb89beea0106eb8d748b6cf4c95c017e4c4a3ac25d17df8f525dcf903650e8eddf931554b6de7544e8f751ed159c2e2f5b82ac46240f60867cf508df4a693813f89ca9d0dc54851e27491527c16f83e5249e4b3f22c2433080ef379b5bcfdd5cbf44648dd9559b52a95dbf395aaec5ab17a56f213c2c69c2bed246f161dc1cda431d606573ddd67de005b2c9dd71c9d1a8f2da9bb7d928d76431b95f3e60fffc6c8a52f4c534489db616f207aef8ace4b05e8267287cc63357e603e2c377b98e2470a7f23c7fe7e86e80df2c4768e64ea4952c696606c15cb24cbc32a69866c524166c55d0f81e3e46fca39bd4e5651eb01c90935ab000ffad5d6735e85005b80a4cd24214a5d6018ea4b858a2e745c7552d999ee40dee0df7ef9a01208c0094b1794871dfb90ae984ab469038802991a76687e68800a764ff3123b3f0da7a4fca4540b379c45a779a0aa9f935336a453f87ec801d8b00063867ba8be5487ba668bc881a6a704154756625499248912dd347e642bfc949f7e801b158a3444cd9f06473cdc06faa139a002c3551667f22136dde5ea14fd273509d0ea69e2a14712b6f151357c87d1c558c75586f548c7b871d780a425c14ef869e8816993695663e226573700d9006aa4f4535aa75505f2a144e2ed4134376485125184b1f73a9da58a34b12226c12265a0ee0b4ccf682c1b3779af32bae8be28c10822e4a027948ac60f2b20d974c32afcafe314563a939ad2d1a6bdd1553685e0ea359defa12224e5eac09504edc2f99e3290860633f9e4b63bd8f6e6aadc1ef4cba681aaf996ec242c3519e4a2fd64d78c9c8de488e96853f347dbe9ccd45899765898c7b2e59ad29ce60d2b43c5309fb2a70446e1c0e13ce58bd58ec20a69911d7655e984ae43f120684b0f702d870c6a92c349d949e9b39fde5c9b62978d4eb8a43f6bd41a996b60af63218ae4403cf764210cbef154efdcf6df34debd58f1b66ea750079f0a97b9368e0a360d92df70e09365714acf2114971e912dd5777d1ccbf2d2a83d5c038001846bb18837b74ce525150e30bc0b079a353eb1b27183372b1ac0be01fa3e7cabd34f92318d3fb5d33e6e8936787da645c29c41fb3cc03a235a85dc4bcfd6b4e98073ba2d51f14a70b65f5e62bc007e76d90b3eb086e91b6bde38fdbe70fde2dde1272cc665b4677ff6f5b6da432aa221ae4217aa11be315f9391895f8c17ffacef7630d64537896d79abe4731db3dc2af978b478f43bc7bae44e06b61f9a528035598837062f7807e51108822fce16e1727566768a157565b7369c6151113804459f7495c46648bcebab6d8e187149d98a2e3360a0ecbfc0b607ac48160418bbcc1864f2845f26712844c931945e73fd3c819ddb145163bc851ce598770d4fc1f1f298d2f32d76709df7142bf3f29c5697e7c421b0baa043de67baa9e14043062b53ac425091b395a975447678fd136746f08f592427478487c1e99e52e9c75c2d362938bb478333b6a3a60d518f8f15222cc17690396145d0d6f8cff859aeb94371b12cbc0dbafe8e7be138020143c1444d0211f3aea1f861ef1922d8a15380ba9b46e141255c15e9e4aa08238d9039812855e3ac7bc5e9bb84dbd3016c94430de1a0d53ca5ce8c135db3fffe2a53e44e1b0f29b629bb4f52fea7c0ad3dcb59a72b569a43bfa804e05d07c20b7813f1902fd2b07983cf9a13fa8655fcfd937344779f21d62651b891d95ec9520a409d2eac6d3d22466c8be96b65512de6fa4f6bc0b50b6e6c48394bfbc4362d3334812f328ab4fb6b372949f6a89a23f8b2cf6a1e5447f9e9a8854f462853215981056e5ac11ad9384ee58cc6e3b0c79b72c800288a01ec4a0172092cba8cdf5df0787ebbb0830296ceb513f491f2cee7e01c5744800d66a7436f01106966c5d9ae21142efa1c065c260d18fafb302f3d46fd7a010c6c546318021e1ea4167b89c43689bb7ecd0e6f6cab5fc5fdc489233b6ca24a210eca212d9245d1edb0b80df7ea805d6564a3ba0271283dc611e72cabadc61848cbbedacfc66a08d84716c35080f97988d217223aca933289717ac1cb605a80f7e692225504f8951b3bb4bd4cb2a7f62459bf2b7c976f4044fcce3a76ac1f7d4bdc5bb0b6c5c2976fc84b5e1047cc41ba48093ccd7b6b23b43ab8812d90dad273891877f558444037165d04f67b00027340f337e0ffd68836ef72be029b6b089f8ac86f46f9403b40cc267b7edc5e2ddb7815bb72bc220bb09cf91bd00828a0c3cb79d11b50e9dfed861d15e38b6341957f32f5f19222a18435d9d02bd3eea26b622a74bea261164a8130d977000d9f7b855c4ac05f6d50d43b79336d5bf7ebccbc5fc42f9d5049035f92e095fef308da00045dd39c8ff63005e488b29f6f7683210412896e631445f1d7fced33075cd402215a67d31767fb5c0eb2edf1df30dfdf6b73c85b3ce93cab4ca9be8c67d9214073e821d9ba578f059ea87c4f921e4fb7e69110ecad840ea011e9bef87ad8de6eea178256ba846b0916e1eb12b724e04014598780899cad7fadd7505c3e55d10919c0e0613af22f526e42ffe9b8d149ed9b1b003587d2f46038100cb3f93b4f2eb618df9f49af6e4f322183db85644a1bd13f333c94d7b4a05745cbdd8ca45a613c6f6708a0d7d0ed603b03f98e95f33a923d2909804c77dbce2aad0e329603fb034ae7ecca9e006104d4650b3cd5f81886f219344af5d823712042a726a88b301d5784d40c67f20f8b1b2a8e4c93dfd5496581505204cb7fabc772f393bb4c25117b5f322247d585cad46044c9c3069904cf25f91af792840dc898a0e8c83df7039bb17c433d929a5919a80b974c4b1823d9140094c82cdc17a800ab6c1c85127f9b7b9accab494194f216763c21c1e1297dacf22fc8f2f8154a9acbb2f662d032964aad0c98de9320da00a936efcba3c934657f2903ba410718864d78d13fc9014307a74d05cdd6d77ca055831f94905073b51dcf0b571360728311f78ea3cdd3ac35dcbe453e28906f9dea726dc6181ef81eb513c993ac531138935a3c10856c9418accfb0314997413689337e22407cd0a4a188778d25a5b557e141cfd5cbd13f5d9dd114be4df070bb01dd30377ef16675defaa5b2634d0f9f97987d9a33c5167e3cf8226c9c2f57baa730d3ea8b3be75ff9c7f51929643a770c87150365b7a15bdad94f72a526ead36c52e26fff75dbb967b9eaa1161746e80c62192cec76a7d5538b65f15af7580513134284d11eaebc2c83f319e5475980b605d152f8b5c0a34be43317ef664f4f00841135a93f1336bc9240fe752d4564ab1d83bdb21aa396d925df00975963088900745b080a8f6ac7217839cc4c8bd65e9e862160a12dc36bed1a7e0191399839c92099c85cc943a8474c0e4f0bf8ea04a10b36bb9e65460cd9306dd48258cd62805136a6dd0b5cbb9def29852689e3b7aaccb20cc32d14225f67be7ec94a1b739ea941455cf04b96931dd1d410387b557f9949b18da4ca7531d311c75b5551b744f20181513e250034d67b528ef99023d58a2431a8e0ac195c3b38c6731b279eab0bda61e37c29974c14ef036c25629c674eededc587df5bbd40529f3ef9b98b7f889ff056904943b07b805479bb1c6714dc8fa83c87a16091107cc1f4a3cb187f15c074e071d96b3f5fac79af477aa3b8b1a8691cfce9784a0bd73eb8bbf9d8b881e44fcf9e8a86f1167a97bc54d2a7f7b447398e33be97fd2ece3f8ced7c835f2aa344dd2a74f6ec88b2b6e177875c74562ab6567182bfa4abeac052b6afd7ab7bdd2fc8d364a87afb6efefd2d7eb26227de664942bb6b6f0191c4df8ed93d3e5d5c1932b08f6234e3a62e1ed49ff07ab498e3417b7920e17eaddf159a7417e6ff63cb6f39eff3d4ff5ca89a21120611c5677c2c0efa2b78ed6b35a444797dcaae8539c45a2c83c843dcfc35f833f10091418bced14e3eb7fe4c7d2baec7ade52b2ea1ed93f351bfe02d4389f51ffede91f5c33f66eb2693d0e98bb59581da7cbe951747105682d232e78f46f578303436c2c6c078afcab31957af13d60c4c31155cc97894273366230e0bedf8963a423d48313e250b80270d828ffa5cc9b50a708a4be5bc2f0318b80d5fb5de2d8425d5de2dd5b90eb5127a8c2c9956388391387954b1047aa056b6c94b13bffced9075ab059ee96ab4614bdf341e80abd4efc7d122f28787ca53ccec0011deaaa704ccd2c4215347cc34da525b4f937188dbdd137df599754d246648e0bc791d0cb215ed9e88f70246779b7db2985270a09812a0c40d4fb92522b8b2155ef3f5fd4678bbd58767fb7d7a5a7b39bbbc7be735d04f61887bdda5492d3a9d645ad176b47cea41a26b120bf9e2c9f79c5d0faa7a164d383852d3fb7ae5171d8eb4f77898f1c82d1a244a3e2aedf7932d4588f267d9b10b85fa06dcc4473a8ddf1614b88445a2aca1cf7e9e9706bd5aeb9b000a0434fc835404421a97a938dd017a82c1826410b590f457b284bc1fe4de550c692b20a31223dcaf1447f70528630b14a19b85d4fb48458f75ca34b478435fb83e13edd79c1eec1de17313c867bf4e00b61b56f633540552c6f0b9ed45230eeccc4921719c470768c45e48c209bc6fb6bd4c38afad91fdbe308fdb24a5df4b28d739902a4a7094286fc968438657e99b1d7b621f0c7affddaf1c1938f18db5ab59907114e60c06a24b861be315bd0d15f5292d0d9ef43215a895f00bdb1caef75b614839221d5445966ac0d030d9a4233b4156d8f0e83aa7860ac7967e167b21bbd7586e4965ac9e6a4e650b0d9aedb944d9862afffc270b5c6792c84761ff155047291402ebfb7d26b906b65c371e07a4a065cca6f8bb7f1d4183244c0c606bdc9ce633cded1cceb6347b3670433a942f2c18a877c536f775072677e25ba9cb2dfe0642d7cf8a9db7d628a69e15d4c15a28e034c8a3f734046b3d09c57e364b0ec4b2ad7bc36dda91f0ae51b0545a1a8efc67d5c13936358bfa6971c14239db16d21aef2944785371bf53c47669fa39a30ab98865b0b007c6eb1095dbedc267a820ba9e56cc3b9ef24f7a440ea970e0899b57ea5258c43b2b4dc02ae620ff65f0c48cf0c044bd330fe86e80089976599c3d91aca0a6a08f5f33df86c8e10abd7ecc1850b3e7fb7946f2dc763d6fb362db58a970cb7dd82e9aa6b81f0fc2f873a204bd35b6d1fb8bd43cb79cce8c6590e1c19e14154b2becb426cb685a6b0b98ef9e56167374979120fc4493a4275863c52bc41033175cf4e94aaa6944722114712cf0f6a571e31cd8144866aa2602879659a307b675f0e5793877b32b6d6db7a2db3058b1471cd270fd99ac88cfc09996f18dda4f9bd73d08cc72d39d8e54bbef4509a2f758cff232611f0474e336a6c42ef9779de2adf6c8361048a39cff98ac3eb37ffddfff2e68d8f1387678d839be716c4af8abc66012702f504edd87b227dfcd4dad71c1edc236beb3308d4a237c990697e194a0aed0f8ec71c140e90540bada5e1c19629d76126b2c858ab6370914598e68c71b026865df9d6043d2c591a2fafa927212b69666cf539a47b3906747d9feac5fc6e91621454b08c0fdb43ed0c0899268e16597986216fc83c79e1b266cad42b32d324a0fbfcd501ec044b6fd181f3e7142969996d0b7f93e6149955e0b9309fbc3f0a4d70a1ae6389c6688453b4c4f2a85e85bd0130ffc169b8583d694d565e58330d125b22d0d961c8638919991084f6d9e96fad1cd844977596160083fe7814ea6d4456389982b24a0ce6a39e5df2c53d1f7162c93d8335bad25b36898ead329848e9b6c5325d4a8583bb3ff00495d4f138f7733816b208edbcabf7a5543fa1764a27995129494895d02de29a10f12db1a7c950de8d31c2a86149c1e0396430a1658ca220a6755333f9178b21af295fcc8f5474e081d83e47975d77374b325f68d8e276672783ef168238e7683c8222e1aa601108ac7edf415980faa1e9f9820dba28d4403e2d78767564a3231241206ca6d12496f30314253b19a1a477e314a16dc8c0223b60ed823606d2a0638b19178a8ae690bdae60c403c76e46d8c97b1e010a485c9f062f0cc4b88deaeacde714e84306296eb837140a8785f9dc6acbb879de001f2517801d7e0ece131774fbb692932c2c92be824928adf23c24a68e7240bad554aa12a44fd5d4efed2d96b4766b4902bb57ec0afe0fab1a2ee770b191efe87395fee284ed376ca7aab68ab2370a6b52e49e10614dea151465a99fd761f89f31392da2d55ee5675918b0c1b0493a83970e6238965149d3bf6d3c16bc093863db6e293f31678f18073938584531608ed6e5a1b11c3b00228af7def4593494e9b00bdb3390c955554a6874267852b4b3d5eb5547fea55f2f77f868bae4ff4b505913147da4f4aa125540f128f9cc9b2e557583e0b1511cd3d8d1a96ad4b6c5d90629780f618e6503356159ea1121702eacddf6094079bef8e1c792cf95fa2822cc46909bc4e6c2c70d4c0b1075e4d9aeaca18d2422c1bc5033c84a2f2911dd956b7298c26f1f17f41b0ec0ffdfa1b8dbde474d647b59ea60903f00c33b44a6d190f388bea577c344c753b47766327b9f7bcdb80bbdfd5b309ec5ae66917998478a3c116f60c389e00b380f9b6a80ba3ab5982be8ccef39e30c396517050890d877c72f816e541d00a7d7c070bdda59408ffd23875ec2a0ab036e8bb7090b7c7e08e83d32924d33d4ead57010e4024df5fe4b02961ca44117c246cb442071c95f664ce7692e4be280d625adc9d3ff73b846a6bd0c8f73ae0a417ee7204433b5f92bda4c93902e46d6349945a86ce54c2b3b96f3ece4d505d971c0d73bae610f82c6f3d7d61a3fb468b8386299edf0f5c7ff3bd3766bcbbc8ab09195a66ec34c41c251ebe3460aa3c1eda404d33d5e910ca065b363b8e5de961ba3ba00d74dd0d5943f23b1c55d2a45e657e9c63833c2ac3e5e80591770503957c9e2ecf8dea6bd3d2c56515a273ec8994cfea9b2a9cc8c27b764d3d230c9af37f03d5ab0a57fec6cf4913418d66a8a92629d34183be83f700749106a22c193416030072c9cd52656c8a15dce2bd12ad638d1d9148861aa9df8aa1b57996af1bd945e52379a333d1702b3ee9bd5e73e993ea99ca998aef496b4b1d2297d329490ad0773e89f5ab38c9f31ebd7d136ddc87f4183374e182d6dc633f9f28de847ba364213c905f323dc221ee8f060e99fb33be1d767afdaf25b084b012850a0c6117e2ad7dc803806a5d2a983bbd3b2a23c0199cca25af2b66dd9f4780f617aed3e8fd8f1b9d73ac8f59415db5e97f14c204f710ca44e42139bd39eb3971e13e9de3f48772220b2f1cc517abe155643f8ddce3bf437dbd5184655cd8f737047e88301ce1587d069dd7f0521e476f29a9856def84c282c3f87103e0a51b9dc997cda9e24890a496869e1c444626470ddef2dadc6a5a2bada4ad2b7d2cfaa7d539c6c738ccf82df2b1627c28e9d729e49ab071459e1fdc2cff09cf47bb8a77c2d7375ba2ca98aac738f18a55b372b122eb19dc42d29aa356fe18e0ece19ad052083ead5f1a17e996a40ecad1a68e683fc9b419b27d8c00439a1448d8482e1029e6302b525070b7b67b4e7aaf3cc6b9ce703c04671c52c98689b35ffeba2aefbb6d6279cd0b6dcc88b9180d2a8e0a663e451ce733850a38dbb278ba4fe9482b2508d9eb164fd37ef25964e9ea7fbc8446b6c4346d51eb234b08cc5fb4e57d49f737b9b6119e051c1b0ba3d6c19c40ce64b68ac04fc9f8a97ef972ebaa0ccf017399af2e0815d518b8ecb4d19ed7db30e99dd62064b136f2d96e66edfc55fa20f1cb3cb70a12868ee1e5c17722654c15e74da7641728005b2a138e9f4b930668ab5163d05081f18290e766d24a4e34609d8b235a4d420dd1b54bb58d90e3b8f4682250b8f4f66c1ddd8dad6cd992f6bf1854a8bfc3a72207c95dcdaccbd2a971d28ff0cf690387235f7203a1ed4febc7e8a69e4e73b58bb264b7c010139df84c80f6c8b63dd277d0ecbcfd8ff93d66d66583d29f778b81aed1c11092868a1bc72e4634889b65040830362cd2773fd2efc38bc9457c8c75bbd110a079130f38d0057fba390e750dbdcaa18ab8fcc679664cfb0345eeda3b2f90f2655e8592b95426e1a91c2a00b1e91e1478d618c3a75343489e00789b311aafd4989291a0f95b05b6c642e42eceb6be82e3df95e1b1725db9c3dc5d4206686cf390f1875bcca454b5118277196222cdf04c5d8cb1c8a23f35844aa329ac10753d02dda2ec5f2b0b6283c4c91125f2b64c9ccc000ed29f756128551caf52368aeca6465afa203550640fad21c79714a3d0704a13e2bec7a89efb63c57664343a3192d43caa2f04e49ee2022e85bce5bd810358fbf90487e8d4011227c199a9c483066e4fb317dd8af46c6187e55b70762e63bdae226802d20f3ba3f6055e197465aefa6537acd2c0dc78c0aebbdb2d4e8b34ff00070e12ffca9748dfc6764482b1f0937080e4111de8b9a400e03590c3ba718e1fb7568d627b16bb52603751f80af05a79024ffeadcb24879fa013d7210ec6b5985e63ece346c5e7ce9713fc40bba189d7cff44e5e228a01952785593b31469b3269f483e48a30f1d0ef2ca75aa2fc2b4ccf56fbc90df8ea4cde65494e49aa01748521a6763926ac71b1ec8c26f66b06fbda6e8b43e43bb8368588bc61ed09c5efa72b309ba37076c0a0a4e1b04ae2fa4c2140eebbf19953639284b67cfe6ee3e0ef1c82f154431071650620dfef846d2bad030e6624b8392fb2e55cb192c43d2f0e373f7c694d1416a3350ad63f58858e5935823efb44ec484c5db24c452080a90cb24c7bc9ec20851b4c1ab90edee04e973809be5f748cef2f0758cf95ba89a71ba13d27f13f2f1db1885a56447fb79e260c56b8131905e9cc36ca676df6b4f7ed31b0f3f7413da720b83161994d5137459b0a6d6f2193ef3717cd14bd349f8c9c873fd594e7c03543139071053086089904502e0e9a41eb1f7f5daea68212ea0d6e9e42e04c0542ec969c7631ba49f3e443aa5c7ea96c40c60bc2b175abbed4e0ceca35945210f22d773b15009d9f5a616dd92946eda518b4ea9094c22157bbe71d4b0371c88e8e9dc0a79fcd14e4ca484f1eb7521c0aee2053d83f0b47864252ee1e983dc92bf798490fb7f2149d5733ce3db3fea3c905ceda983833cc07f319e20eadc69351407965adeb381ba45d80d414d21fdef32d062233d4b1cea905ce29676e99cc79dcc002e70d380e60f388d51acad0c5f778107c23e500d47371c9ca5e596ecd715ec4baf0d630a23a4153af80891a4e3b4cea2342969a125457135710796961fbec09a93075171ca2a98ce2391f02d5c4bbecb530930aa5671ff732d6d330d42eb82dba70d7bd5799b888026d53c5ab0a5d63c97ebe2ee2ac6a7bf3d85c8bb84d481306364d7401f76ed5e040500b462780616bfeb441ede9055bab0e410d2f676e68d346a4e5297b8d3ed0d239ab155728d5e67fe5d722154bc1cdc60f8597d7799987c0b1021a4c82c9f826b7a7e0586079f36d3c184be6796956aeeeafc66a0e99fedf0b6fb5de52c42de6fdc1e6d5c013a43ed71be613ff6fcfbb2164dd16d0c0765cfa9319d7fd0382792d3eaa2f2fe778e949d62a8a1c9aecdfdee82baaffa125b5522a0ed833d06b20aaed71f446628125747db601d03c7314140f8aa2005e64314f522ac6d7c82e36f2a6265467827e2935ed017e610229c13b575f42b2866658a6c36374b975135a37e9fbe7db4404ebf810ef7066f7c62ac1cd8c8ff3c15805370bf3510f2fbc87b34b4c557b11db1804422f332fccbecf0c39fe8571a2be6f35692121d960c8d8bd8b76e2b2430c9990b4f818fdd60b00337ca18d4138dabc61a40d575ef55510215882ab47bcaa44d5a993a16da446173d044a06e9511c83c2dcb63fe08db0127759b4cdb011cf1cc5d68f902cad88424948ab067009ac9bc3ebb62151e3b9a5ef92c99243f1d795d8407f7de18354da2b8c9b7349cda0487e7118927ff53b2dcc54a776222d502092cf93c12ca50910cae16bc8d57bd42b489d87865961a7f769bd325c4a068c36be9505e65500e453d827ec9b6effe16901479d78b74a816df89abc9ca93ce477c3af117fb5975bb11deaf0fec06cef16b86b68ca3f13f7a60b1e4929178d35f5e645def10791c560c8f064e3b8c3bc01ca74bd809ea5b74dc685b42cd0bc8b3994778cd912511cd0850069afa8d23162dc8609c82743ffcec06969408df0452437deb35614db518556999ffdaa311586cf7173c55ab77db58570168c273b829072819ba2c2ae355484aa6fbcdf5a553bcaaf183d194fd8c6ce51df58e0e7746272561ab3478b01145c5dd6a3746551e69a5cb75361dbd184a6fe3b65f92bbba6988cacf130407e37c99c6d57fc276eff14c40b3045862e63e63b5b9fe81f583f58d03d02ea1ba19c849d429aa79787a56ce6e7a86322535aff634a644d359889f0475f8e6b79800471304cbab32f0f3ebb733b325f5edb8da95df78ef6ceed92377486a88ec81b0c37257ca3cd9fc769f23088c3ba4cd3605f77ba308e97f7fa6766dd4603c7738c356e1d7b36f56d41f3c25a083e72dfd969a852fc190891a74214349fb69562ffb68b36aa231915512658c3ac9f2a2c1377712b50cbcbfe52403268c1f401a565a0641c7bb1ced2b6fdc09e4cc722ad83a687eb995598f8af59720d3fa01bc85b4833563f096a0caa683741f4cbfde885dd89fb7b20aa2d7024987bd188e5416825301d86123bc0ef39135c7a3f0e28dad8de98f4e02f0240554d25b5ca6bd76bb6225fa5a08e49244dc9988be5d1965fbef9e94495a6747298d7f33b9b8a84e2a4c9ef6af4b802acac18526987619e09ce86e900b64e83d96ddc3ff6cd375ffdc58c9f346cfe26d2f7b48563c37796df6593b274ffa3dc35a4dba545f20ecd6b2e4874bc55bcda23ef12f39c2d1e7ae8015193df44460618157465b60f6c1c2c0fa5046920504bdc10ed654508c4bee9e00bbd325f6d5deed02c32a53f3296e5654372cee007721f13b916e43657b06bfa66ea1eec0e2afdbe0707a064bb731f5e5802ce3900d8c0603d1eb5ca11bebcafa0bdfd3ce04ddae776707f916b27e8224557f806e17745ae9df26b413d83013ca511e96027fec11412de148d4b673ceb0c5df0d8812c13890d2e3cb10ebd460f9c620e1a354d58a36fa9dd6218ed939b02cb23cc04b087a7d4aa6d601d36f2e6e1a03e5f497c969e1744af136b51761eb3423f91c20b35b9f02bfe6d0fc2af37f68aa7a494d86118295b40236dddfa892dae337cdd2bf1cb1e085deee0d256d723d979fc74fbb7bfd8eb2a2eb4364ce95c63f5b742fb20ff7992cef6f2a22defb1f747959718a0269faea870ab64408df838c4c3edc618e18af691445f64fc382f84bee2f8b46b6285669de8a5178fcbeae44cde5affd52197f54c8ccfcc8468a53f1d66024a870b6c71664584f600e83029839cb8284bb774019a173665ed29f11cebaa0b387c074d6803c6e52bf083a5d2a0715f7f2d370baff7b35de4f753582daf8c247962b1c85ffad6c891ad7d2d0e22daea491500a4cd5a0cb525ac656598dc4c18f8e27eb90f719f8c3f6e7844d2a477767f7b869ff1045f0e6e938810d02a1bc4103d7d8cc204e075e65c47881b10398a570b50961b4cfdac2769c6ac3d388ed4cfacfe9587e5c4e209549684760b9f7d78afd8fcf98ec27b63885ffd7bd74a329919a57a104109562df538d05bdc067cb4ba46ea178ecef47babf30677fbf34d273537726702d37a0f97fae6d17443908af94a4ea457002e89d9d1888a254bba1eb5b364f4c80da30050484b15bb7935a06056143f32895225ac77119d25b735c1cf6d71a71f101a0e0856443170c834b344c18ddf5323e305d9db55f7ec5939c711334dce1d64f44787aac03a04cdbb0156729b40b64ee7e3e570a709b175cc5b8a7078bdf6257a4d434fc332df57ae191e7239899fd77cd598ec0fdf31460d4b49885a68c97a1933aede95cca5614d5e34c4cbd26c372d82f883ae3cea8a31789941f696edfbd6c7525db9858e0f82de4d019ab06c2c7d89a52db13867b6723966029b6dccc12ecdba90843093845bfd5b4a5d859788fd1d7ce6e28cbe9a5b40a8c3d508cccf6361512f47878637af8a7810fe61f306dbcfbf6bb88ea8d7f16d2ed48133c8600660207f4525fa236fd107983127afc36dc24bec5649912fe65fec13941415b07ec3ad859b05a695e7b2791caef5e49d0f508bcfe4783cc251d8e1af023c236c10456058439025a342962b3ea7e763610cdfc6b3a7c96a2b945cf1ff2cd2c835485bff97672439f2a9fcedfced9f106c32b09b59bc60703f6470087f62dac55e77ef457b53cf326127491e571f026c2f8cde2d3604c52e2a45832eb7647a5e2039d0d1f509834ec6e9d60e26ec5f37a2f7053fa29f1de51e47d130e5169de4fd461cfb4b76b8f8595c36b7bfaa07a0896a5b6f466a79f6c5b4974750c7762a8c2213ec2176ecf59ab0cc2effa63b113caf753d405f610b415435aaa3da48d75b2da2bc2d1dc3dc3c7e9a63e3cd6375da722ac5a73c4dbb05ae8fb602e85c67ae8d393b3ef70b5f8eda7eb93ae4aa0f824d540de5e91a2fbc4d25bd07d721e5e629084f71a04f1d67416b7d7185c53fe39dd436ceef9d01241b4cca952c3cb46bc2e88744d153f34c0b591fece10640a87211a2785892114c0f1daa26e722b7ee39cdcfc1c147f76efa76a07a855f3c3f0955ff9cd65fce8e24e9c973db5887632ae7afec037a50e17b02a799f2bff9685c3f5ffeee702e99c4dfc984bb58f51d1658103acee5873bf82cc3bd516e2e85dfd7d3d755988223f79699b9eb3125c3fa95ff5fed1500ed2b8b0cad571dde47fd5feac1b9f776d5c9414ed8d26ec04b2651e1e1f0b10e48119f9d59ce38dac16b6b3a80fed6fee2cc7e474400abc0e5875da4d4c40277101ff9cb3d6564ca8f6f6b5d4dbc93eb17f586283a6c2c33f036bbeae61e8008c62e7fadd92d151a50697c1f23c697d7a8ef38a1809ce5a69f39ba69f017272e7d34e2ad7b7620fa1baaa9e764079928bfcecd5c4af617d4ce317d562ea232a23b1b19d479d083cd57e87f55053c4120317557b4ccda8e3b19f815b119226dfd7865bd680644aaf2cf33a47da526a0e81c78c20910fcb669efe452401c53b57356afd1229afccbb99c9331148439c93c643d72b861838efc8adf50006e88cc8be415b64739d55786d83f641c97b685426640deb180c454e1372228c6fc6167e80e01777b975a22e3c48356b74ccbb399994a6f8e4fc32bd91d26d8f0e78c91d4c853c6b6ff35c18ed93a3b40b71789d0b045299b29f37828daf43d3d1ae705526f0c3d3b42083e847471f66de3cb018c3f50489aed65ea2dda7f8e2511eb6aa12388fe80b68d897db7277644888d8f7e84e39ff78e03bed918b727ad35269335e68555d822eab7c7b38639a4139645f8205fe88349326c8faf2e7737b74c5d60de2aebffbccbcbacbb58df7a5a74cdcbb5ef90aaf1eaafd862cc67f42dab73855011c043c78873f3af0216ce1b2b8032b5c23b0a43e3160f9f0e6e3e8cdc07457c6fa3628dd72b5a150cf3fead105bbe9b841bd72c9d801227a29e7fcb7288f12289c730bc2a1ee4a6878e56c9f4bdf2516239026b88d4a5ab0817411aed08b12dfadbc76e53ddbea7b615b9d87a4cfba4f9ce62f594aff1a30721dc374c2299f390fd4e3e9108bdc4281f85f068b8a832fa9bd64e712544b2315b42d81c3e335f8e5759ca5865a1b45ea466a2a7efa82d7f4d421960fa6c53b11215839e20d65ac47468cfb7fb1f333b25292d54f7842290e8ab22c8363d3212f0b0a165237294ab91c6f58bfc88300d1b0baecea2cf5babc3b6ef0f973a234ec80a7a2f5b559b7d91c99f82e45252e7a7b63f69cb0d278269bc523e16ef2d7dec10883f6a2220b1c849dc731d13abb920d59fa4bfdbb18d8a9abe71e2a31f3ee7175388785d1e44a69fee27a820e5e7785031a05333878183a4168480256406890125fed87ca77a1fab4ef6583b4cbecf1e7b2ff2b604e3860bb679a11e2ddec7f993abf2905e2ffd5ecd9b5711f0ee042f22240af2101b5e29e62985b1a2ac0c51c7cef44b62476410e3976b326db1fae13c4ab4b5f5fa6bc1e20d14d2c83943386dfc4040db1bec83fdf3e7ba7e1840ba74738355ef57a8aaa2712822247c9e3aff77bf59425458445e4a0a92d6992a7d0c22b97564f83ee6ca33931389186f759faa395b644086654bb9affa5301604f708e5f0af2441b269131eaa518572a2272d148d9ad32f56b5ace8dc96093c4def4d2a91c33998e0b18e09cdb1c2a228946655f69277224fbffe10881dc344261664ab005d0224308ad77b84c5e9e7ee7b71cc40cabc7a201086572bdbdb6d7a5b60fd90e4daf25778c7da75408336e93e00dd5f206a2e2de0c24284fc1b0a5ffebb36b766c8298ce231601677bd04476a86efe144fe6e580f904020ac9d228061f22136a093a343c3cd442a54428f0e345849345af104f6c0a83cb44f1bf76dda9ec758a4623a120612097c74aead060778dd39629b6c4d772116b48bbc5c7ed4986eec15465201aff25ec63332beaefbf9235e2162e9cccd5c9ad9a08e58c96d4075488d5e383086d58f1c2dc002ca94e09339fb901c3fd6cb747486cb37fe1f20041f9c6b2ee6cc746d28590a2bcd01fe04a3a801f081d6d00769255e584d7af5b1a043e4d700b7560d405557c3af67f1838427c01648847cb29d05c1693d5ea04f4ec3bffcd8fa938cd6de857a49193dea3a1050ecf5a0bb94213abce7934f31bf644900e9465cf865868edffa4ef92bdba5a16dfd48a997cc6c4b2b6c4d616b4d074c74e166dec166c9a4af99ed5692aa419485cd3d7953e18698e139ec7307b74d8b84c9f94d86fac73a5dcf407a2b6456f4a7a111001d3a48b06a881e15f171e6f7eaf519c813a9264a86dc2a7d7d45c702101366752bf26ac066cd33a337c65c76c93f4e1ad7fc9bb0f0ca43a83ed7cf35fe9ad932d7bbfd79340c3fd8d61f84b8ad4c2cb605086ed891c5fc3da0381183866a179fc955b0cf88f1460e620b492de69d53a151c8d44e35c3d65bdc527f1855f13b07d45bc49a48362a2d64512432c362492671ab74b91337fa6590b739483e3a3484a2c8eeffca75b0461628471c25da07ccd4db3909b85e5a20df09d85ac01fb545625dc9cbdf78806796b5a38e21b812851dbbecd92e3b3594c4bd8f39e59085cc642e6b5a1b2356ae15f4a00ff9cba9e7c3ec742e760e0e4520d9c3c014b677cf5aac74c1c9500b94b02a98a106d0e8357ecc2f2ab363ae0d8c270c9a543bb257f33469b02384bf1a4843890ab329943bb10c43aae35e5d358f97d5a2a8f2ab8c36b86dba276f9fa4e607b04afdcc308850fff9c3eb46bde66026c08c89dedc7b6d96e91bf5fb3eb550182b39d5c89ac7554bb8fda0037d29f89f9392a2fb35c35b50efac2064f9f540fa8b78307c3d7db0a0d292c602f23f873220bbc5a34c2d3b6dad603b50b0934c05a6db27e46c0f85ce7493d98bb7ac56b24c54e94675d5517a5c73616e178eb40d5833d1f021fa8baa4e86160f1bdc8ce0d0ca102dc2e36008b27493dc0436c97d6e2976212f229713a2d33ccbd13921ce0decc6adc61bd398c989b4b37208cca4d57c9e524bb6976d7042811595439f4d58a85d98a36dad3f4112aa44b13601d13e0e97de50d4922c7d6f3508147c93e620cccd4225c750a539c3e482707112e5f8a79a89980a3ac6f993f7926f7ea959970a7c94d8a3b11e52658019ca09c0e7d8a0aadc2f322cff6707a65bae011430323053e7d3807a01f0cf0a1dfe6b2641a0d3e2e63111e29805f95cc3475ef3115dde93d3b0933b2de91a73d8df686730cebc7942549476e81a42bbad9c89a9e21a23c975f09d64bbf2f92fa5db19f2945f723c5e6d825ddbbd6ad9b96dfd7d510f3092755dfc7b759d08f8c37aeb1ab8bd445af960d8296961397e063418a41c36275670e65e10332b7a43088218bd836d5d3b702575a052f31d340034f64a2941f261e537a311c2c56ef4fd539915c0068d7f1ad0145acb88af7daf1c6ff510b76a405644c84babd7931bf1c09855705f2985beab880d6a30bc9e29317e3321726d4e10220cc70747369c4cf71a2fb6fe4c4c8efae276959a4ab33cb909a1ab307e6639cc65641a55badf6eb734199213c440289a37a1d936d0ec9c870e7514c6eb1cc3130ac659382816f6dbfdcda1bacb3b0799a61feae3be4ee21dded12048e4d5766a3ad9237d2aa62cc636a761a28868d1be495206466d1a99266bf9ba226ece9e8484b8c5676f1e1cc2986284aebb60c94b19c531931e2d0c23f09a471755ea49d3d53c4e3e4125db8cfdd7a8a09ee1ef9a7b61db2fe122cdcdfa9b750dedc7c2f329b574ff42d0934dd58db76f6796fe59b7312545fad99b929f4e29f4adf3f5c68827b446a87e28398789b9c98125baecbfbfac1b74a0103bae63d9ada8bd72c8291c22432db0935301e7cc2cecde1ca47b27e80f8677238210fc86a624c34042b68e1589c71df730c42a3bdfe2ac27d7ea7d15ab1249d07c6829bd2a9bfe710f3df6a8621675d990677b2f3381fe1bb132cf352a36b557b608bbb0bc13adaa04eb7c196393fc09f5339afbdc647e8b6de66672fcf9a9983191de3ba96133dc3bc2cdfe9c73e3e8c8cf133f7f46e7c3f2adb80197dc272ec44f95176580b6eabf159b6cf45776244f3e96c8c64825a6eadbd29e3851ee3ae106dfb0ea304b973cd4a136ccbd70dec7a5a6234fba70b1ed1b5a676b78fa5e187d8ffdcdbf9ef083fbf5f0d1e07028fc955efee2d7d1fb0f94716cada0a610c98e68ccf903a4ef5ac467173e8e0771d39e1a2267898171d47365f2c2000e6d93930dcade2c56d3cbfc620cdc2fa9fd29b960c2aca0295fb176b1618cc8352a9b6f160f80d29dc29a3c1a5138d39c97c36c9f0b59a1a5769ca450cbc24067dd65000898b6ff3dc41b19bb9a17548f2c9cfe2b30e4c8b2a1eda017e22f884e5697aa8d89640f0ce10dabb4132c001baf860f070dd2581e1b286c89fa8eb84563483ce08372c6cf1310218027c28e2272e927f46be9c444dbf78e27846f97bece201152380c2bf774aaf6d50f68721f1044f3e7837d864233c4db90b40163171986b574b2b258070b6e8b1284763613d792c257a12f5ccba391b6e26d06e7c5ca7009ec4837cc0f98192a9875cde1ac1d229e59a765260e8fa4807629311d01c4fb0316ba857fe05f70ebf8e0f260177d9168c8c03ba732f4214178f0f8df92a3f0fa73962e6ed2525dcb49768f51dbb442768824163d6fc7ffb059a75f8b8ca49eaab4a2aa3e03bf66f4ffd91307d75c6f1b09b53b29f2f2773c4641e4323296414a83d773913d15f593cc07c0c1bc4abe486aec3a48c1de23164f2e229ecc48a24cf20581ec64dccef38491511f79c852ac2d5457bf003e89662a48cb5dd23871aefe21f155fc9ed8bf6fffb6c9e613f7289c68b3dca1b0ba294ff6b0b1aebfbb05fdd8a65424cbcab8e11736776ca3b3aabd27044f949b970509b732cdfd4c9419e22f18c266172026148d51f6cba006608e035fa1b5cd74ad4666e463c87ffd0d58c173d02c2c9da43bd751415925df6cc2ba6f68d1894cd38e44d079e7f596d3a42d135b5f700188dbefb8e25dd83441e75d385006d239978968ee3c0d183bf9a60efee98fb78d1a50347d084674944f78781216ce77ea4f52a0cf0aa6c264507f34cfc54517b4e07a13197e3c6438a96d76571c93f0e040591e4d1ffed0f1c2807d2138269246da0cfde522f38edf7b370e03fe1885db5d3539aeb0444a6176f4f24f9e4c482aae8fc4546870b12f1b9e418abb48c41e71528a4474f881496cfa32d968522ac9acfbf35d9104338a2b2ac0387d6f44677dcd5d3453f318d89ae0abf4c88a724eb73a803aad84b3dbb4a355ddd1eca51e3968df81ac779318bfa61585f3c38c30c026a08e033c06955f1e4b743b38466b6b7200f8c9252de85ca491888fb5d8195e7d11d8596e4b583a4e63b576443f446b9f46d8f5bb4949c756164730496240a54f85e416a5552c9a93f38b5929706e2903f52604077f9623bc7927081cb9722a66b81389462b8acd7781e10a9880b41a3882060036acc5a371ee26f7e29f71857d73a257ae7b90c09ededd1044da2dbb2576052ab6a51dc44f00a6982a7b38a061c59ffd588498bdcba05853faa5d50cf4d03960c9344be7fdf68b44b56f65328e90972c10f748a35251b4812bc1b904d68e9d055a6d913860a1e2ab4a0e87cdf0bb89c67893cb8203784e2771183a3da68a319a39e15347b13af0b8d0392dbce9dcb6903a4f25b359131cd9e956c935b0494966438932bbbcaed34b374730e0050b5ca3f1dd82e8db25ae72db57d744c1741f18b7377e17c6e9186b6c71a9d46313fcfaa0026b0fb62b601f708e860742e567df188f44c1597ad8ea2fb0060346cebbcd0387c1f17b4711abb03f3ae1afaf0f59df867a4fb5767efd9f8cfa9259dd29f5bbc90cd7873cc076ec1f6c3540bfeb9d723929c4aeefc02f265d40f2ab9c35692d6cb3ad954cc7021cdc2cf875084e3dc548db3a0c774dbeb2315f3a9aa3221c33923fbad00b692bb984f67a437dcc4802d6e93a801442f5a13234f487b20bc40c5edb0d280878305bfb8370dbd5b170adfbc6392bc396106b3920bec0d3a63e2c2033c9fc41cd79282087d46019bd0bb17bee52c833d998db6b18100a551887b080b3ed9442ba30af4382a5406abd472328602b9f5bfdb65ddc37b6eb419bea9d9d3756f8d384820af18ffa02e32de964e0a5d3b1b75fd048da067390b5fdffed94e5a53099495c3d5d728d05cff30658ab80eb752a323b4b3d1f06677e858183d0a433c031451d9401a9afbb0bfa563ecf11cd2922513b52f79f0852a07daa5fe6941863a300160bbe07cfc5ea23d438fad2e4aef262ff687dfc376e850290e472ff55ee8107d4e8466d68c8654c9b9fa35e1fbf31e1865c5d1a5ed887d13b32076d49b83099286c420ab69043b9db3ed1810d97d372869ccb53d4e0458170aa6376c4126be983e4f3211e049619299c475e2852ac42daf960112153a46dab256f426463c17629a436362b00088a953ce04566d900a2a0cb62634d9bc22a05c84791fe1af05493bfe59243d8024ca91d7b0be5440343dca336a71fe205e02b3ca39b5efa0979f162addf292e995229142f627437e5882d92fb9d541538fdf9cf9f5ca790272e12f691da14ff1c3b5a63d44f8e3bc9c693e68c0cde53ebcb17b9e30fe44f4866f60e23632bdc692ee9cd6a8e4e0a00db836e89acc0e44aee9197261569cbb3766c6c619d376df36fec7a77f083e6343de3121c4276efed0c43340559604083e7e68d21b07f1349483918cb0e8c651e1711406e492e567cbc09e3b8ff7eb25de7f14cd2e20d1aa2ed42eccf34610a64d2fe3fe11b723a8e36e3a95036bbbd5b8ca76bf44764f657add728d678a598299e53ca7736ab1c1a39fca0b72c3f40fd74c6739f5caabfa60afa45f463d5ed7fe4b88fd92bb5a411de657efa3312b001f2edff252677969e19f3b19fc41eaf9951efff7144160968b7334f93241b6074ca902f16d780a143c294ecf0017b86d03a9bca96822c93b9dd085038196fb82e81bb4393c175cb2a559c92545c48d346b5974816a67c3017688439f9c1c6d1263b7481eb83ac581a88005559d73ccf6f68382cc7800ebfb65fb879b4b0334235195ad3e7c9c3c7f45bec6d044c54b3cd50e8512ca2bf71c10888baf14f4223d7455ee945b431e23b01ae22af99b58422731fe1cc4dbfe75a36da9b44c0cd1082e941580fcc7b6df20cea445ec9d5c8ff0f318f03c0506fd330d5db6cfbba23c73d296a4e49ed8b9226b631b7e5d8fed080cf5139a1f8842d25c35c5a5c23e34329fee4e64a12d79ad01697ae68596979b1016bd13d6cd40803c147a5224d2cbffda67902751a154ea2dc10ebc20df068d429472e697b60b67ac023d8ce6723f457c78e93ef87be2421df03fcb841f8d2ad5a5bb9e2ccf9d3032537fc9db16e1b27df119aa30713ea5962850213164d32c4175e934c56c5a00613488375c4e39ae1176606bf79e1733750fcd8aff65983642ac60d1271a9c4365af7d48b59bdc1e062eabf4904e181646d49eaca52d071d65c4bc436d00a7b94237404953b8b444933c3c5ee9b4d0e18de4813b507a58ae86a037aa94e81f4e02b6b5e01972ee68d6a711c85dca653a5799247a10471d5b0fb48dffd0f3caf5c90201262df96240f0848c02f5ce82dea42eacaf96882c58dcb4999c35753b733d6009ac80e9e49f00cbe633b7f4249e947bfd5618130e150d292b12e36c6b3b3fe8a0b8159cb5a2f160e3ea9ec271daf9d3ce3f82055384b3bfa081b78486cb6846601341db24867505cebc9a508214e07167bcf6877ea901102ff99b0a21f58c92aab856ee4e5bd579a34b026cdc24d09807177580afc0f5d5c210ed795707c6101d119c5e7ca334b4b3d7e7cf664464994f7d44e74ebd8d1d6e0166e75cf61df8a3bfeb605b059bccc8b0ca65a20a6cd62f9c9017e62a24bbc887753fab15f5198b1318c4318b57ff4f6ef39f8c622fd3491829350fd765e3268684d40510eaf26bf68b3e1da64e26e60dc1f402dac64f6e3517ef51b37073c321db4fb956c14adcd5f5620d565dd8e7ec916dd14ba60cb51ce861c55b7d31892a79a8e0c42ca9c32e0bb82a239ec55ed3113aaecf5172492f65d26c135b977a4f5c3bb396c4a2c33355918da88d80b852c39614db94a9a3b95d4d7b16c813911f5710c38fafb709966baa9ab6b2da64b8e83ca4dffb33ef12e818405686cbf32597c04e114191fea64c5b398c0901a17d0d540cdb23df83ce0d94cb8d2c1f3a24df6af2d18776114d16cd48a60bb674fafc53bab6ba2f75e1325f3148ac83c0c91d02d02bf81f86fc01ce554e7126966a937cc7597ce63f86ec46cecedc21f1e08d3f7992d834505bd0f1f9ef2c2e03b063feac80bb57da9b4650ba5eff7759df73f074a0a5f3b54630b080448845e4a90df898c4ff53d3c02b91e5dfa4d67acf9f589cfba25d377407b79b49cf7c787da3caa93f42cba758a78a42797f387394a118f87d9efccf2c19be11653275633fa849eba096c8886c845fe5f922a2001add80ac2d6bf306b55a8b15db4d0c1b1c39ff25ee7b8407aef21772e783e3bff3f20be2f7441c6e1bf1dc012cae1873f57389863dd240c335372605a187f05f0b51dd69678d452714e151eeb2dce75c330186ea3e0c9eaa87c632218457c4cd1cf2316e70717d81cf5df97421f6d3a41cff1916b89dc4f50668c665ff0e873254b417eef95a88066b2b0a1f1a2801890b5a78e117d3ae1450981454ae09c7c8b8fbfd1c8f92f839bbfa2f89d816ac57d12c97a677d8dbdacb261310099b5c319b00c49ca4d73afae45c12e30dc4d9dd39f0e5c5c7aecb3df1b9db88a07577d01ef7cd9ba172eb0bbe82cc97b1dfafc8d216984c7e24c3bd6ff2eaa7f3003b4abb3b689b43c81d423a1d80468ce64115487d9fb35098cfc4fc6547664a582bfe94a28a0b97c97a839b7f49f4fa3aba2e6adf8e38de90e46a7ae1f7a791cbdb318777264646f27cce7f8fe9c0c73bbef402bfc7234238dee234bb1d1119828359a5665cc715b511f9aad8d3810a925fff520615a6f687d68e20a7bf56cade375f389b700adc6ded373abc4a979fd23f54663213c91026245d1d814a9bd63888e3c78d0a44d00f6fcd0837f651e3cb3760ba021e151cf9825bb0608a637bc47663e06bf29bc3cdcfcd8b0f1ddef13f684cb859cd9af580b17b0c4485e82202d43e92cf8ad3116ac168562507a57c0d5789e525dc108160f8f20c43bae08fdae24594b8351f0705162d86ab3ae44d511eb11052db378c42b1df8c22ba92315d217cbfb95188d58bccdd13d62deeab55def673caae5271cbe55f020fb7993320054d2b4d27ac59334efd384de0c953f08be8d05d437a831aeaeadb1cfd02d49371000a8af56253f53877b1b353163a020c3f84a68218cbb6c23150b6bdd57da061720e3b70d26efa31884a5b627aec0fed84cbeae4ef97cde04cb5a207a96b6dd9c7fdc06e54ffaa9f737306dc943173f3d601c58fbf0f6d49152e4a6f346b67487bf6665c3104efa6ef4830ac353a9ae0bd9bc3f38e96cb60dccc99ef8efa64d43418736e5a54304b9f54eaef8c625cd8f5d46dca98fa81178cbd12eb52a2b74f4c9993bcaca369af876fdf36f64c717b0fb0364f27f3fefec4d9e44fa666209d5e21f24bb1bea1ff16d4d776fb35f9b731d8a5a981f0cd0a413ca41fb8f77479faa48d542889368251969951ba302a8883b511d3b5e37dbf8d713e579e4dc836781d3b9ef11f707b708e7839720fbb0b96d48b57fae034fdc875bc5f6682fee2cb87cda41c214b60ee573e9240071bd34b6817729c7ece5122ed824131b1c5b3f25a879c3aaed700addccbba69b3cc1c830462733d7e2f489d511766038c2a30b982c46676153b1d7d6e2470c8b7e90748f9fec97379f5b4e37f9bd3444f7e9565246f3ebf72e2cc45166ec2b4afa3b94fbe0edbae7e6cc19c5eb13112f864a28da29760e7831779b4af8c9f0e44d6dbec2368c3d1e3fb6a7cb31e3c3246fca7a6671080f355fa489f2b7a1e9c9e9e9ef17b909b3b7573e3c089bfcfe43395f5e35ceb1bd5e99a1c7226db1edb4ab89e450c49a29ce64707b2edf45123baa59ca9f9f95988bc289e3b8f549617321f055105a6d94f6faaf2164517b99c001dc9a1504aee55acfacfe4848951e81af6adb30bcf3d80aadaf1f17337df4aba7560f0787fcbf823c9bf9bb8b761f16df481d6a36e574c28a5786c7acc41ad994eb74584188f57290d01c1db457e4f49ffdf56acec90fb95737722fdc70cbf6e286b37c985f63e04bc1786f2793a929fe4ba9b7344cd1f47a61bfe4b8419884a42084c2bc6adac46ffe216ea2cc2b487ecec9c9caa2c4cb35b5dbc3b29882886452736b6536e9e973ef4d4bfce1ea3229f9442034d148be8b1d00099b505b74cec877a6d39082da9a35b96982d5d2d894388b42d4ecd0cc66bb03daddef08ecdfe4fe53eda98d70ae0a236c2038ff39e4bbef85a79fd1a75dc4aec1527484d31abc09829951d01876d9c777abce7dba14e04df89b3da386516e674b95bbedc8a48b6276476dcdce623da8fffa36dc95bb6d22b621f017d544404265c8a9d81912a6ace036db7d5ec43347005beb8097a434662f5f56aef1a6c717a9d98fd0d4ff958a8bb2ec7517b715901d4a9e22c66b150451682f3f1f52743eed71290ad60b41daccec84abfad4971c5a0a91b2d39ffdd199cc32f16161ba7978f447360257ed3fa6f01fb61836dcf9ddefebaebf003890d54173a07a2dd1d9d28d1a8fe2fbb1936e63687ed46a6cceb1610cc57006e48b58db5ca9d1e6df1259098702b692f7bc04b1e357f78920405a181f95f726e017849b17939a7ec6f494f288fd003ac2f430612e4fe0fa86cdf358228fc0c9cef4cd07759a54721c673c14fc220aa51a3ef9943422c88e7919580f75b6eb4dad912cda9781cc3f549caecb61c387d2cbacbc842c13a8a6a3cfa8f16c86cbecd3fe9a238992301a8c42024690b88ab85da58a1d5ac5861a7d7bfe786f3b8c190b202c3893c2a1f8d53606984964fa073d6731a241e7729d37bf301b063674fde91b5007dabe42e897041081184c4026feec0313873514d6a218d6df6c6f09356ac950f237a65bbf48c47d73a038f210a1f15ef1214f4accc5fdbc8bf1449c390697b12a9e3d9b99db6621a356ea273d833057ac2c58ae0ded3678c378eba5e4885b4266441fe9f82e3c119ad0118bb940082701f7dc057ebd9385a42cf58cda71d1266ddfae9a1d2e185274c7cc8c006ab160a9cc5d8a77e263bd8d98703daa52ec1080cf71251f70cd91efb74ed4c439721d8d7b0504ce0e221f2c98f6bd60e3d5a3f002f91c7588b5d20aa8d9f7f6fe25680c3563279d903ac8a27f69de517bd162a07ea64dc775940d1594c7fb642f8e258c62eb9ab176a8760c1511e67df24267084f1165c137aca9150b5adb093275d9a5978904f79eb638219568df090c4167dd67cabadc2a432625d5032648b2d7a225dd36a031612326cd45cad626255d2e6b66dcaa4204f8521b54ff25a91d29e5b64bf1400fe25f98fdf1476e1275ca024f811947886ba212108f63403151e4f5e6484c3230868390c45833821890c36432197a253c51918d26e4a3af8659abe29b807034a2fea248ee37db7dc064ba3295e4b626021fa79a16f124e16affa3be43d057ff8042da38d59258e50db158bc553707ddef8fd270a0d8fb431992203e768a174c81b58f96c9a61cf8eab72544ba42bfb0be70b8e93c0ef131315b12d0893d3982dfef0df5e80ec8c231546eb1c066a830840c7237097f307b3bafc85cc1a4fc92491f601af9eb9c3ed07d767b92c98ec53ee9f0f0e15698c05d985d06d3c022ff0a8a8f17a9b14747da009c1838901b2ca8aa4938baa8c8b037e6644150d4410a0b5491bc3300c268688858a0aa6e8608e02b668392d8b1f5b631b8d9a8da5db4aae6ceb002fa27907dfba4d782bbe000f8aecdeb4339254de1dbac0bbbdfc5687fd24eb0f9e0cf40b27b08d139806494279d00c8aad3a5c9c401e9c402128d5e4fc4099aaea6bf5f12112f31eb922faac502f1a3834831084a8a2b63011e232e19c70e288609ffa2071299274d2d438695438693a3871429c38cb89af13f62389ed54d01f585c1c0d93054ffa0b4f883ad6c409fbe184c120a1301038065c86c704d3b448304d2440a1003b610938d69a9ba1288f50441c8250c3f2801ffcb0871611c5a2a1c415419024141e705ce1c58b66103d7898cf0c555b68261045753279608200ca8ce763c5264eac70e3c40a2a7cde43c50e1ef645d5858d2124e1a48a227cf1a3d0cb5dd9802811e599a128204a745205c70d921bd5733fb40849b2c4668a0cb02469faf0c614202a64bf9811816250088045057a51e5630a4754a1e9640a3948523592240d1f2449e3461b7b58430f92468d3c744213094a4c07e573324514275340713285025078509101314e9e473a799474f242d2c91b4992c60e92a4a983544d219d48b106a90627526c7122451927527c21492c28410a20e210070d1d2449330749d2c8210e1faa23d2c0419224cd1b4033f422499a34dc20aaa82d4e30c0058d1b346d90240d1b2449b3068d1a502a7081345688b2271710802445218828d488020c2751f4800349664c9219731285e8240a21ede1c0c49e1c1440f9745072447182b206499242a00f553f1d29c78989154e50c43841f1e2048a1440bcc1861a7690431a6b38031a50cc2a34d5cf48e53d749e40f14ea0d88024492b404149018a67164922d1605f860a8528fa441c9e08c2133778c206663c918227a82772fc139a930a2441b20f060a16d5dce20b97203980f00372949828c2119a3224a20f6a98d0c1640e6e300943124ca660c203144c000092244d5fd8cf7f811213fa509dd9f2269c1309404992649c44401392f41272c14904825085a659759470128129aa1308b4a00a4d473e238ee8c867347d94884e1eb0054962142b8ed455f93839e18124893e584c4e12dbd9545888a88f2864ff379bca332b556931252b40312314847c3c68e6658a4fd5794bb180a80f16270db0815485a62433e68ad057f652568846d40903129172c2800e9c28208d0cfc60499258208303b420018628590423dc2841a3840c2709f080a4714333831304a821499f190d19d080a20331384180002449bac401ec19064822499a31942000094728421124c90c498a410c66408624955146a8c7013a1d901a450a94cf7bda09013c484a1620090e5042ba42152e70841f42c8010ea42152910e50e064001ac9ce0fb91b09400492d448363c78542702c81180499c04000e2a50785c8a0a7d4c47b4b91fdaf122430101557054bf48d501f9a83aa0e901c5740010872405917a9c00a0049274292af4c412de529f138d0f4e341e49a2b6902aeb99eff2a12133f43c78d4ce0cc9d65a6badb9bbbbbbbb33c618638c31d6ddddddddcdccccccccbc7af5ead5ab57af5ebd7a758c31c618638c104208218410bef7de7befbde79c73ce39e75c6badb5d65a6beeeeeeeeee8c31c618638c757777777733333333afb5d65a6badc531c618638c31420821841042f8de7befbdf79e73ce39e79c73adb5d65a6badb9bbbbbbbb33c618638c31d6ddddddddcdcccccccc8b237cae396be62266451a01269a2049d20cfd15b5633f44a8d01b99f9a105c5224379fe878609a1e78844d4e7a3c1424b45b1549a2b4892c60a92a4a98267cad0cf4c21148b2469a820499a29485290a459d92a2515a0cfca8746a2d1ed4c8a220a7528caf4f18caaa9fa0a0b4aec9024cd1992a4818224699e20e9a084e40449d2304192344b508224699220491a244892e60846308134b2e2b2d1426ad1051016b969e9a2a5456ea410225a74c1c5c60b1f5cf8f08c2cc5051cf58879d10a0ce5e901472bffe9c07c241049b44092248d0f7a603731a3ea3d33121c2a764892541201a9e40c48a8a00a4d3374535513a49141621f0c142c449ff9e9c4744231a3cf3f220d49b222029a91e4197926b505cca7230a51d407ca147a84171a2f44204992a429a221f2224992678aa68a23b4901a8105fba11e709445fd2226f0e69c113ad0c1082f6c872ab2f220a8cdb8a84494a772375a841792f474fe506929623f3e66423386f2c82402119224c95c217ff8f8214af2a32e3e2b2a2d459ece1f9588f2b8d8a7c2dd08a50a77a31df552d40d21516929b2b92124a1078d2a44b8808ba8b414516929f2e94ccf10974a543dcc10106856a3ea7308151068f2e0b1015552891f2428c40089219214620cb09988008c20499209241d847843920a1137f693746e10e2708424491e8f6322a11fc283c7065411c223499214253ae288e30d499274c43102a90b38dad0a1b079535d5143d515b523fa1836723c8223d83c723772d781636510660091248d073a20499e5048564d0f0ef0a7f2418940332120a24f871a8281900f04310641481a0ae808440fa27080243d118427cc084403a44a93058fd04bd20c208af007454892540249072056159a38a209ba62468485864715fa4e0b0a473441281e8f0f1e3c74fc21057e8843871f5c241d6fbc21bd91224992157cc8826bbd850034259274828d1b3d9024c944d2c1072aa4246b4dcdd3b2c20ae7064842e181d2c5152b6e0c91dc409124e93d9d3b61664c1b9a9024e943a40d38d440d1b186019ad0860aa436bc90daf000cc075aa1f242c48a0fc582d286244928f6d339c286212410c5c61924141e5c8409483ad84832a4191b3b24c91dca870d014892f459d983225078d88e1c244972d1b18726ec218924edd88310499276a07cdd438a24ed40d1b1870668828a1d6bb081c223f4301d6ac5435923079224893e6b8024141e6b7821556baccaae610022920e3dbc21e9d0c31f241d7a1084a4430f71d4cf4865e6e38362599124cd8e25499a2ba4c98a07cdbc4892a60a49d240f11e3ac3e854df22499a0d5492a4d140cc7bfe41332f92a4a16214b3a93a92a4d93185243d6846f4a099299a97925334b5d0a1468a068a0c4892a491423445530b22208a054451422449937257bef248fb91a11f7725f443923418780f9d2fa11f9fd04824aa1f0251212d5c8288dec5332b25e4ff25886752ca1344f42e2a2a2e10ba40e842c4b10b9166765242dcada8a8c0662bd0b1bb15cd05242e64a8501049d24481b222491a2844d547923416a88024aac20043365b7916214244414441840869b6e242e483345b09030ce96ee5598408110511051122c4dd8a0b910fe26e050cd94c4524a4998a2848339517d24ce58334530143ba5311e24e4514c49dca0b71a7f241dca984e101d2ac59b39595951517222b2e4462ecc747b3955017cd56429417cd563c2ecd563ccd56c2f00071b712860888bb9521ee565656565c88acb81089b11f1fee56425db85b09515eb85bf1b81009715cdcad784222aac5dd4a457d346bd6ac994ab366cd9a356bd6ac59457db85381f1741e883b9510457954dca9a888aa0fcd6771a7220a81e1e24ec55a1fee54e8c8c59d8a67c4853b15241d2ddca97c3a5cb8534932b970a7f281e9543320d00c89a059339715222e2a445cdca910a99f51e8c5dd8a8a16cd549aadb8ac107171b74204c810772acd5456dca9ac346ba6e26e45f421d0b7b85301b284396041b21398c3169224e99803cf410159a0a0f0f80284c24556111ff6635eb412a2427280220e3fe320461cd6e4c0a18283186cb3111c5400872924a99a28554c33ffe30d492469d38353cd2d50aa8992451a37e022312fea4892460211903e8c4e15f3a24eb3d187d1a9dc504992c4bc38c2e79ab3221f1fffa1649e45a5ba1f1ae2a1286abf873b2af4617ca8cf045513e4c28621fc70598321d63004697a149967594305663649dcadd84fd2510951a23aafa53aa1ca7efed38179eae97c0d5194e77244309f0f813af55b5ee4121a0199992c3fe3230d6974a1230d4310511e978fe9bcd84f0704f6d339928646431c68d041094494a7aac27e3a47485082890a2beca7736487fd748e5c6ac60382cfcad70972b1ff79501792a46180660167c8e20c28d2190a80c22326c60c1f141e9beac87cd006049a3c78446ead435519a620bda8806086783a33468aa84e0b7d117826cc0b7911757eb8d64766ad0f02d77a725c5c6b4ae6a599cc6c6126335b1693992db165660b6c99d9f25a66b6b896992dad65668bb7cc6c612d335bba6566cb6a99d9125966b64096992d8f65668b6399d9d25866b638cbcc16c632b3a55966b630cbcc9628335ba0cc6c7932b3c5c9cc9626335b5c66b63099d9d232b3856566cb929946c8e0802a34a181051d687840071a5248d218a820d98f1955a339a4fa8e8e31144092c4700669b262d8c124aa3a42445f8961b2341b8188e488e34554910f513294108a7aa97218a21092247dba683602c30a2429471c3e3e44e0a83e3464109294431081908e544a8865f91025aa428fc443b9f0e0f13c4413a5d90845542728e66d17782049d28b2824ae39eb242ce43f140b17c2f080debe67f36174aaea61266853553d9a8d389b23758ab6108298da114d198f6756fb9bcd666dd6a68baccdda7091ea5b3c1e1fb5ea70f1af22aa3a9ed07790c0cc1f1f335d3e2b228a85a5d9880a7d7079b11d205c641569c6a92687534d4e911e3da0cba2191177a3b754eda1630a389024984f67c6e3f141b550a224a5240a0a40a0128ad8c2195638a20a4d1faa138514e83843ea3863c8342945015285263aaa2469650a1d5090c3ed702a8903137540c1495568ba42f4e98c603a54f4e9c074a81531a34f35d7c44850b8d0c113b220bda07c3592410e9327c427a048f6613e2820aa330249059c8d740227882449ea694d8c44fee8a2e5c5e58b12a9e48c922a343da542a2aaadf8743ca18f59430f00804d384392a42fde43911ce984ac98f9238f279f9615309427871a9294230f9294030f928e2688710749929078286a088b085a26912042beaa7c803a2f9d992454a80865472e40aa17899ece1f445cb208514078f02080ed504578f0d86c389b0e686e4055d58335379bf6139a1155dc3df8916c1c3333f3e2089f6bce9ab5c86233b3983fb2783a29f5928252cd2c8aa05401820d920f81cab084244d2865a0a1a38c468624c870021949282af428a03ac880128a8e17c02149d214eabca0063a5e9044aa4414cba4e3053b2617a4f1a1444f47d7053990241d2ef8a2ba940be01896f850a11f238d313e44cd9719832349938e31c650c0141fdb411103109224e910430b301f2a242302205d7c18a11e3d7af4e8228b2c92503f363233546d92cc98169ca0058f0570b0e0062c60010ba658011e56f082158460053b2469a258a62355473402cd78aa98993228339f593b9f09f2783a321fd3114d199499cf7c99a8a876a06840031ad08087a240339ece8ce7fe87faa8600d1590a1024b89503ed6043c787c353943be2001ca4b0a38a1230569e8484111244a3483f29c2f5270002fe808630961804047180f987184247d159b8dcb0c0f663a90a410497ea023892889053e9d19125d41a1cc7c6638a2102523aa461765a68a992f3ef6333955f8c8a272a95ca8f8fc40a9c2435174478f1e2f59802811109922320298bef8e20b2aaa0051a21d4190b071a49a2324399024c98a1085c40b898241b29084466c48f3c7080cd38fd18f0020ea822846644575081d151a3c78d8f6565e2e4ee765bbf282992f5d94b8415af66e2fd6eae8fd67bf0d92e3747ce3a48fba4b091b9e2ffa6ebb3e1f7df72d1494ac414edb8eb60b19fab58e3afbe98000aa213216a35b2e3277ee3984ce756cb7b9da1546cb6ea64136aeac513bafc7dbde9a25689077756dbc286d4a2b7d7b06591fba7a6ba3fed331ea7ca5c40c3246e896ede6aa776dff6590933ebba6d768db65bf22192475d335b3e5a8bbf442ca7930f3659a60a6689a426f210b89406848469fad85cf698d77353a06c990c51bdfd106a97b3dc52097d7ee56effae6ebdf711e83f11b516d292f4152c0901fd37999a6f788e8a89aa669822c4636a39230c4e55c8bafdd5b33d36b9bf2b2b539eec7791ca2904ccfddc0743c9e779da4040cf241cadcf47adb85d0310a5d48c917647d4799473a632fbab8398fdfae1620912991e843a2aa138a2f255e90eddafa59bf1bc736db7bbec3f248a8d09069e2caf3968ad9346fa2a40b925dbfdd26b79f9cc7d64e6b7d7c3ad41039d97f420917e4b3f6b167df5e6f8c31dc826cef3d76ee55e8d6c6398a619e1117d304f150a205d92ab5f1d5d78feb43879cc7475a8602b52c48b7de366ef4beea4d9f711e77362130aa9ea67783122cc8cb6ea9f37a70c549a95322c8cd239d04255790cbdb9db596ddc62eab97f3787137e86ec4dcf3a2c40a72b6af715a5b5fb3ed68398f8fd409f2364dd3e46e344d9ed9097d354df6f347eaa4d3e4af648c922a48f8d5c6d870d6f88c4de63c7671a1e999b57247de33ed23098daa6316239b1e255490f1ba696f2fd666b3ed6f0ab2b276bfa953c6d7be8342a6490af2d2bb608d6f756bebc209af88484854b96331b231414914e4ebafb459c7d67dcbb4e40c16978d913176b4a785c2bc7632abed1032af469f10695bf79cb9eb6ea55de204595d43b69e9b9fb6d6604913a4dfc996564ae9b3bcde723762825cf37fbdb858ec5fffbe53b20439e17458bfbfceebbeee4809d22d8495ff45b7d6b976dc664912bee37af146e670f1bd8ff3d8dd03c574181224c7492b638f526699d796e4b708bd0c25a44f507204d99885d727bd9479d53a61e747094a8c2027bbed59c7f9f3fe6a91c8344d53cce8e3588c6c684911e45bfd1fd9b6ae0d3ad8bc8408d2b9e172d4dac7b859ee583204e9b8b1061f5dd5edba0d398f65fec342ef1212b930bf90a862254290d7d5fa2bae7819df662fe731bca251ac60485431561204c9ec91ef751c2be5c83c66f379cfe31910559b6da3949714da4629b1bf0408727d5df4daf92cbdb1236d404a7e20fb56a66d5fa41432ffd91e28f181bc77ce06a9e3c990d1c8af07f25f84cdb117df9a3c5db49ff71f253c90f72d7d1effc5d0260629d981ac4fd9eb59613773bbfc79cfa69b16253a90be7c460a99df3d2f6e939303c9d6d25ae9bd1cdd2e4a398f1d8744150ea4c3e8d0b6bab8365a5be3bc4dd5698e253790ce46c673c567c8ec98721ebb8ff9c6cd6fa9daf98cde074a6c2029f5eacbb1b3175a873124aacc90bf9cd6d6e0bbccbdd8d44351748b921a48e75864af51fad1b1edd53490aed93aed5ccb456b9b35b72e99818ccdadb9536e0ed7bc8bf3986d363023fad6b50c24bb9fd45b5cafad5d6c82d854120339db71f7e2777456e8cd79dc2a2530906fc61b9fc2f916b56b3dcee38ab2ce2d24aa5c4919d25a16abab75fd5defee9221636d7d2d6d2cd2551fbf921748c7b5f65ab0a3b3b3d92e71819cf6db3facf6ff17f7978c21ef7b5debfdcb1c63daae084ac490b741d89aba836f396cc779ec992198177d3a1b3b41cda1174551cc65b005eeb11dadbe2a33ea9cf318368f36a2980b250b2a8bcb276d934d7addfc7436ee461be798d18709598163754eafecf69d3777cee3e6a202e91c8cccdd9eb35ddb6a5d2990acadcfe82cf79b963dc679dc5c98a128e6b22cc2907efd51fbaca3fdda99398fed6f9c5d8b3392521629dbd6377ab3d4f9b073c83455143a16231b9824325af85c7de83ad6c9e064ec3e44d59691357e7bee2de60b23a32e3616231b2f9044760eeb7af4d535db659b91640fe16af5c5791bf2f5888548c6e5ffdc8496357bec17e77105b9923ca17b6cebf5ca666dcf79bc61dc42f2fdc256237deb9cd1c89cc7ad0a3024f7a3b76f8490b9b6064110bae7acdab5ea4706d9a4a4f78c7f67846ed95bb582623a8c7e248c77bdbf8c3efe5be9c7c8e6f7da2ef66f6aafb7158f7431b2b5b05d643c672fea7e566ae733874cd36331b2b9472473ccbafb4e069945c6603e9d2371a140b63867b7566db4b42ba48c29d71df93d59c3aebf5cfcd79a3916239b1270e4336ef7b95557a3d72d384d1ecfd769fa108c74b6eb55f6eb32e89e3ae7b1ed6c1e34237a1f1fd334f3998cc5c8465ee97445ff45ddd1e66c9df3b889626e065e72858f3257e383d3195bcd5609acacf7fa7adc7ad2ebd3b2247605e6335ba6e9612a10b5e1c76264632b7b6c113ad8cd1d8b8cdb6f33cbef4e4ae36ce6cb79fc222425f4a29569fa109069b2df0151759aaad08b40d3cea9178744a0122550099fd97b778deef176fd50f1eba78b8f8a831588e231253f7b93a17b945d74479d6331b2d97cc19c37165fec059941e8fe9c57637451e775b1a61fd98c3b8b914ddd480b1985cfc2a60e42fb28e7f14c4804ab1af2e1550d4d8f2c46367e02c79039e6e6cd7163e6a037c3d8683b1bf95deaed1c13c86fabbbfda573f27a7e4b20ff3d3285b63d7576d049201bd7faec3ae8aab769dd76a88d6331b2198111f9e89cacad5a997afbdb11c8f8b6314abb1d737a1715e285f479eb57766f74ccb4af08e4aaf7c5c87e9bb1d58ebdb4b318d904292299766cecececb3aebd4d53880a857e9adc6331b2e91071ad57ece7e05b8b6133638fddebf2e833c2c7cc3072de344d93f3900884821779a3d3396375adc6089d398fab23f3411bd1c344b7d9bce748e86336f4486dcd626403c4455ac8de7270dd672b6cdb388f31d022adc717fd3686cfb5785d0824e3d5b6a1bdb4bae7f035f3907f0f176d96d77cf53b86a00bdb5e7cddacae56af375b4bb5b02c06eb738b42beacc245570b1792553759b3fe8f596ad9e43c4ef5d80979104e7eeb7174cbc276efa113c4ed0202796773b4f536befdde6d9cc7202a64797d405e861fbb317e0621dfc979fc1fca5337cdbc22df3adae2bbfcdef557e63c863fb6801c39bef5da41f61673b39b6290783c9364bb38cee66efddddb9585d1a94621ea7a40319d6e31a30f13c55c9920b2ae8efcacdde9566bffeea53651888a7c11bac3d791c2f51cab52327b993a870dc6bf6d4db7a285b4d32b64ebae5b61b376711e6f18b3e3fa48581740e46448adbdbed8f3d3d99cc79b66278ab9ccfd903e9f8b753ddb45db5f1585a0077cc8666f3df36963a4efadc579bc79d003d21d3ebbfedad93e1d759cc7905f072483b3ced5ebde1827e4c9792c438560b87bc837eb73cbe6536eb0c5cb791c12551c90ebbbf56dcdb173cc59e43c16c5dc48240b79dd5cded0b98eedfa659cc71bfb991bca72bf116021a7d7472b37eb687b66c879cca946a04d88ba1be7230548ca4bca8b9094fa45ea23d9c8ccd06b2c46364278c87fb345c8a8e5efb72ce43c0e4d4eddac491473a7e9435415816814b3598dc5c846045142b771d186937a3be793f3e02845a52525e54548cae6d3791d1281d887a8ea2c46361c80b23e6be37d675ef9bab9388f43ff79922e08e7746fb5c5ed59ca795cd9ff6a237a98c6292f41aa99b27a94e2324d33e54548cac6238b914d890c5c6ba0d9d780f3142c02dd14159200531a5812b8c2025304aca04015bc6303ddb91f025d400313a082023ba498428a0c5c408a2b1aa5f0e6391b0a60c05d052e9084921159200a0ba040e15a5b80613307a502cce3e91c5914986202f3433b2430f347aa88c01410d850f10051688aa638690ce880e954513880ab993fb2d9d1002918d03154dd6cf8886b0daa5fbd056c7628000309d86ca440c026c98c81e20030946703f3e9c0c0509e081820c60205e0cd87ee2644892605083000dec44c118a00a80880fdaf36170040ca13950666478e8dfdcc8d9bf0460325bca93a9b8d28c96340f249b0195028f998f9d1b0197d304001a4365ee0081fd20e7490031cdcc00666d480063390410c605006192f70c11862b480052b50410ac298495285c000519f18cf1114743830f76da5f38bcd094c500212181981a4a30966483a9aa0891c602880d4861860f02179200090e8801d24a96a44079248928402820e3c213d128a7aa8da630d3d9a207a981e64f4b05af448e9e1000e48e2840376c082c4811c70400c69118a901c6892cce2115920e2d3a158baf359c902491643b2a0408924652161f1862461e1052ccec02208120a0f2c7220cd7c7c4892261188a82e92260c27583880872624942a78acc1c30c28222a08ca34adf048398421a4dae1804254cc8c87026d409468f347664c54c34934038507caa72324824ea2094ea2072449a26207ca099aa2a2024ea02002af979d8bcdb7f84d19c8da8b5a56d946763dd218c8c9f8dde7bd60b35f87815cad39cea6abf172ccbe0c19977bfc98838d23fc66c9901de17d089d6defb5f802c9eebbceefcdf68db2ea02492b6c18977d7863f71c4376743a2b74d4325ff7e51043daf6bede8790a3b3d16b27a475b4c2656f9bbcba3527248bf1cec88d2dbe90996e42b2c5fe99efbba76fba2664e4ebe65cb523a3f4ae9909c9973e65b7b7c18e7e3121ddaf576b74d3c2d96d5e423ef7cbfdb3eff64dee6809c9ff0c5a0717f51befad847c37ce76935aafedce2125249d8e272fea209b4cdf2464d759f9dfa22daefa4d1292f6578ed6c5b6bf6024e45d8db2e59a29bbafad07095923bceece603b65661f21a765cf7fbeb8e0a5d61192d5be7fd9e4c9b339d808f92cb3f1da767667d76b8c90d1bd3dda8f7b3d48d91721fd397be7cf672b5f5a1521dd178dabf93367b3c144c8cacdaeb5ec22651e9b2142b69bb536b798ad6ca33d8464af56dbcc3c9b568786906d1d5aefe6f6d9dbba101246d6737e74e8cd1242b2c81ddfe30b59838b3b0ef9b87937bef7d1d5ecc22163bc4ddfed7d2f3e1d846cc8b7c5b6e074ccad1784a4cf5ebfceceedeae61c0819db9b2c5e7ee88dad0a0849ed83af419e75c23be31f24f3361f7f74b4b9c86d711ea7bc04892c46362c30f1839cedb2f5b1ad7b591fa4c74b1bad9332b6be46ee37e46d9451f73042e66ed15a01f11d98f0c1dfd1775a1983f4d5673898b821979b96dee66e7d5f5d534f790992c20d0993362adf5ad9fe7dea1a3664c3ba76ddb9afbb6e03fb0c267b90ec8cd558638bd0aba56bc89f8b3e9cf3d2ba685d1c4df420dbc15f347a9bafad852f4a1335e465bcaaebc7deadea6e1cd20224c5ae4cd3102129ce358b918dc919267990af59e85875f6dea06d95f3382482292f4152aa0f202922aac8e763545a5266422faca182091e24eb55fbf1a4eed141fa9cc77e0749996de62284ce1ca59529133b48bed4ad66f0ef7ae89cd641ceaecc7e2f76fb68ad7490ef6e4f7e6ea616421add03267390fd60843edf84d6a77b4b0ed2a34fe66b9f3d52bf1e0709d74fdadc2f16ffd566e120e36cc6ccdab61a69ac363233b4ba0b9337488f90b6f8e6ab2f360b997f98a421edacbce663c691d947a90b17dd5b98b841faabd1328b3e277bf33658039336c858a3ffa38dcdd896b187619b206c901056c8bcdc5b5edb83eb6e8ed4190292029b47292f42a6a95a839cd5a37dcf986b0fdbbd1640305183e479eb6c0f2bb5d6d1c7d2209bbad66ebb471a29f5478364d5e37acc395a5985ebb9c919e4740cb6eb7a5adbbaf96e4ccc205fa5b6b93fc75665ee1e91212665903c394e37a9b3962f7ded8c98904132c71afb572dfcf518da24d48f69b29f84a2f0814cd0e0dbeeaf1fd20b6f739cc7ac81613206d7fcd88b8d357d7ecc793c93840a8136949da6bbb1764e5367865e9849224cc4305fb5b45f5bac3de77d6854519e3a4d53e83d9e182aa4b21e17c2240cef3a5e70ae581fb4d13d189c7d733ab53d2b6cfef00b72b1757d7673fd66a5de9cc72ee525488aa7a33245c1c40bdc5c65cdd256a985b1b92e3c1bdbd23abd4dca1ce33c4eb16f9412d3e154139214fa4629cb45265cf8371facb71db37651cb792c1ac540d1888b8f4adb026c6ef56aedb9c6dd1a64fce69bd746e79abb4e3d9e59fda3d22030d1826ccb1a3ac8fc9f7d6fb61504932c4867eae6643a2b6d079b731eb766662c46362e265890cdba069d4dcbcf98f6e43c66579071c2bb38be7bef627f3d04132bc8ffa737fae4e8f7f97cce635705f911367ae15f375d7beeaad935c82c46362a26549073567693f2c3087f7af4782610b8e13805792dc765dd84cdcd27749cc76b39becdb118d9a4984801f2eaf62284efc1d51a3bf77dcf2d8fb53637635b6d1205e96e8b7771bfb7cbac3e108b918d8cc91972b1e5a08dfe1e3e9bd78251b90f1328c8cb3f5b651446fec93a4ea59f201d65dc3d2f53187d42a6448e7a6113274886f6e73bfb8cb5fa2ae53c8636860aa938c1a40992bdcba67dac27b747df5db498a669f2314dffe9dc3b231bc184097245a78b31857cdfb4fe388f3715ce783cf34e936b7d642d41da67b638ce18e37cd52fe7b112a43b07aff3ba2abc0bc69504e93f9fddc5fc39caacd6161324c8f962534b5dacd4f9b109f31f47c4e408b24e678f56efbecdb6d08701999a1841b2b35add63336be6fa721e7f189de8854911e49dbf9a6bcfd1c5a87d8b08d2fdb2d141fa66753152e63ceec7ae932cde5c5eec5a1f7116231b6b3204e9bc5ccfe9edf2377bbd0c132148e766ff73778cf673b03d4803932048369fb2d71c8b6d326ceeabc919f2363c630204f99cbdaf6db40d726bb5b24cd334b118d9844c7e20abfbaf7eb698e3846f721e3b2f9a890fa45b3a9973ae9741d87f7b205b7cd545fb2e65d6c1f64c30e181b4363ed61ada7676f19dc90ee47aba28eb782174d7ec7520dd9dd3b665cf368ff152931c48777b2783eb31bb22e3e7e2c28184ce5f63ef39dbeab3fb8603931b48fad839d28ebe9ef5d9e00e4c6c20eb8c2ebef9dcc15ae77aedb118d9704ccc90efbeb7dada0bdfe4781b6e4c6a20df3167a753da9c451b8398d04052d88cddd2599ff31856cdae99c5c80688c90c6074ce9c6b7f10765cabad685babf1aee5fe276b9cc7d3544d5343622203596f7d75dd8ff73d378c233089819c7f9bf9c6c9e8746c2d0c644fc60ee374ad52669d97d1984318dd45778e5f5bcc316ef1cdf687acb137a7bb266448baeec3ba38b63ae37bd85108262f901c63cfc50dd6875cdda10f4c5c202f75edbbe7bafda86537fec0640c392b6dd4b67737da7cb69939649a360c6d6022863be7b55c73ed357c9039b8daba8d5aa72f42cee3fa5564b5a413322ee7b35576ca9abdbf9c57411e259c90ce36666e578d1f9aa3209e394dd32446c926243f1a1bf2b51f1dfb47ab91688aa6695abce15a7562dc394d48ea169deeba7b4e48d933212fbdb1cec66e7d7ed15ac79890942dac7fffc218ed9b7665c3979014d2e50e2ea74e7b5d670969af853e9d9dcdbe52d69590df78be77a947cbeebc8b12f2c50b639d8bd955198d91eb570d48ca8b9094990701e4c59bda11813a1ecffb24e4ac8bbd236b6c424948e7e9ecff47d79e832ffe480192e223e545488a5b33288984ecf6565df48ece7dba2889f4e1a20510394dd3344d90c5c8268c1248c855175cb0dd9ef436b695f338446d440fe30c1fe347445f0df9f973065fb7b51c33c7d5f4428ed4fab5f03942ae76b7e79ad3679bac9df398ba9fc842d983665e5e63414923248db0b1fb63f3dd1779aec0c808591b65f4d9e95eb7858e721ec7182aa4521fe4b2796c11b2d969335bb718b5cfa822646cebd9fbcf5bf516991b414922e465cf1d72bf35bf794f4448f7e5fc6f63361947f74a0eb19c47e8abf98aaef16bcc1e650cd665dfbdfd9ffe40506208f9d37943d86075866f7e2124acec99bfc5bad967e12384847f1dfeab1edb743ae390f317736eb96773f6b21eea8628d154490192b292f222240534b99826d08ce9324ae090fdeee9a3cb32c83aaee83fa41907258390fe587baf7d9dcc7fc21b75502208c93f21b4f7576366cee683665e88501208c95ffd7f51870d99afc8bca9420920249c175a667eaef7f99b4c09257f90b5698dceaeed175f73c779fc1eca42d4104af45999a699d0342d1794f841be65b66e9b8fceda16bb73913ec8ca13de1559a3b732636f2624fa4817672a94bc215d64fdf74e36d763cb66737c908de965efda581d8cad35b8dc90b5fa7dbfdab1c6ff1c4e9333926962deb03312e656286943ce0a61bfbf8bcd7e3d1925fa6c28d1a7232a61433eba383a6646e9622fd23dc8dad6dfadaf1f46d8ba398f535e82a480a89016d304a242769aaa69aa8f6495ac21efe2ff77bfac46dace2ede70e56644bd84123dc8051775d6ef5ecabed52f324dd334239aa6b678c3a2cf9b1135753f9d2794a8216d63f1babecc2a3f742b461894e441de6bd9a3ff36ceaef7effd16519dcb8c123cc8562be5fae0ba6e417fb889d3b4d9cc696290c5c80649c91d2483d646da5f27eb1669b483bc953ebfeb75ba66b7da3a48171964b8ae57ea3532ff50d304598c6cc028a1434718577bee45065d2f876f45c6b6319dccbd2ea8d292c24222d01c64335fac358badeb7cb0c941aec8d7c26e8bcde96f31ce6318070929bb93f6b4bc22abfd70906dd6196d8bebbdbeb0716331b20941c91ba4a55eb9b11aebbc0c574d43062f4252364d038d23649ddf3e46c7ae1fda081b21a3ede9bcfd2dbb191a46c8c8eea3b4c50b2df5e7e822a4ab8e99f7b20e6173c740a3084967b5fdeeb17395e1738990eeba375dadad5dbbd5102161eb0bafed09b9aec9da2124ff7dd3f5c7387dd96a08e922e5b7babeb5dc72ad0b21ad63466f7b3769a5712d186808e1bdea8bdcdc1ce1f78cc3c5d68dc1c8adb1e7eeb56efad6a5ee3dd8e87c4e82060ee9ea5bec5a7737725bf7721e6faa8dfd7cd556a019847c666dc1e7bebecd5717e7f1a713f3a4a011847c3376376bb0d90addb46ff10d348190ec56fabe3d63ffd673721e57b5534dda0c9da0018484b75ad7ec6c43e6f15dcee3c647429408182f012841f307f9f8adf8a2c3469dcfc63e0fa2366f0a1a3f48db9a2db7dceb56576bd5e480b81d15347d90adb2e50aadff7d96b5c9dd469a37e48b7ff9b6bbfe3d5d35721e579bc62548d0f081a7a57143bef59e1bb4f645ce63c647d0b4215bc3778fb6ab76cef63c76e5d3c5345547288ae3adb5d6dcdddddddd19638c31c618ebeeeeeeee66666666e6089f6bce9a81a4acf780462f294384a42c6631b211800e346c48f7f6359bf0d9e9cfd5f620e3e2bfcfd56b3d46ebb8d9e84dcd1a92ad2fee3a6f63ad3646f520ad3b9f163e74ecae7b5ba3c6f2e570b1079b7384f1c566462773eaaea3f63e7e1102aaf8bd409307d9d3be6e3cd9ecea98313c48c69eb7fb6bf6838e69c71f9a3bc837db337e34fea26ddd0eb23a735e8fe9a477cdf60e68ea20ed73cfc566975d66f05a3ac8fa3ddd5747e6bfdeb47390f15e66d4c27add5bfea61c66f3652cbaa6d4c541def637c2e53436beed3138c89eec208cb3ddf6e3c741346f906cfb7eecf726cfc830529f4d1af2b5b61c6cf3ad7aafabd70dd2adffd7cd93da36c87f7d216dcc3247a78b970d32b668a79bf4bed77adb5d8384cf2efbfcded76c9dedaa4146660bf6856cb548df6f1ae45d0c23a4ccbae69af58b06f996bb95ae696b3357d73d83a4b4f65b77c1cbf0f6bf19a4c7199b7de7e5e674fa6590917d652dda66f6b9854f06f96ebd75dac9dcc70ae1a3212b5cdffcf15d47eefe31c8f90e63abebc1d8dcdf8a4142eabca67f43ead1551b06d95c5c3fdfa37ea1756ac120affde6da8d6fbe38e9d72fc84b678c76c667de62acd50b923ecbb4f2ec1b99fd58bb206d6d8cb5eacb7573ec552ec88e76b1b5d3f67df55ddd82ac8f29336fac6a41b265c8bee9ab1f6d8c340b92cee83ef247cb20a38e6241ba1aa15738bf3d63cbd12b48f7e2bdf0557bd77b736a0549ed62a6edec73dbdecf2a4846db32ebd6b3d7cc7d5241be5358df7c5fac7ae3390519d775eea96b8fe9ec35a5209fadd459bcd4b5e7ed4641cef91d6775bde0d7f6ce9035fa85f0d508e1bbd7452848c8ce27bb6af92db72d3e41c6b710d6bf3dffb2d8a213a4bbcc42a6def4459e2b3641da47e97ad0ae09978b8f09d2eb8490f56d0f2e415a7f73ad1721bbf3de0695202fe409d9196de7983b4c82646eb3ce7ed6dfcfcb201264b3f9bcd9fa864790d1c5b68d56462773fd4690ce1bbbf894de7efab408d2dfb608e3c70799ad4904d9b53edbaaa5add9f8e21064b53ee76b8ed54b2f83429097b63b57d7b7af36c320c816ad5bfd2e7f9bec1d10e4ac90f9b6b37bcc20fb81bc6e3d325ff7e9a48bf94032e89ec1f72e75ffdc3d90f52bafb69c756c35ca8f07d2b5f6eeceb7dd4819bf1dc8f64ddf23adf6efbcebe9404ec636c6c9de0bfebd3990b679edba66a50d69b338900debb2eead577703d9ee3eb76d5a6add84cfd940fabb5f6ffd67f75b73ce8cda6fd1afd0b9d740c29fb0b27a978dec6f391ac8f6ae5f9fbf9beed29f81a4f02b6bcfb1177b95817c7ddfd7357945b89c8d8174cbd8ec4921bfad0e0319ebfc6f6fc50927645a86f4b71c4f47a3c775a92343fe5fbaa24f1a6d6d97db0b6465cdda36cbfc2d57ad0b248dee35bcfdcc3563c8bbd8aaae27ab1ce784ae1143fa5ddc225bff1af4e8bc13f231d6e072d6debcce35e7847cede8dbda70bd5ed57d1312b6ed78617f378cd35d1332b6d7ec3ad8d5bd789967423e6be3ebf6d31b42cb1c13f21d73f5fbcef64bc86967bd7e2f83cc685f4b4867e17ff7476baddf5a09f9f7bdbeeb21656e394a09b9dc3abd0e7a7bc70a27216f3fdb9a316ffd6d1f9384642e3a73cae6eafb5cb348c8fbb73e67f359e7e6650609e9bafb3aeb1f6b3767f608f9fffd6ddd9d73b62de608d9dc3f658d6ffb657b1b212d85ebed5a333257fa8c9090619dff6b45d61eed22e4735b8b5abecc5fe354846cfada6d77e337a77176222465eb229df0355eb3672342ae49ab6dd0a77de65cec43c8c5abf6834d27fbc9b00d215f5bd6d969d95b685f77212474b4ba181fe3f5e6432684b46db6dff65ab3f5b28f43d246dbbdccad166be387433eb62c9b0e5aff87d10e42366dad5d6bad20e473eef2f4e8de318d3110f2efdbaf8fa3f5c72820e48c6eba7f0b36cb6dc23fc876aeedaacd9b3af3e60759e16567ecf274f7f0f39efa48369173f441322f8f6ebab518f305b90b39de9073725f9eab3666bb32c879cc2c0d39f8209f3d5ede7aaee777bdc779bcfa0b39dc9097327bed2edb7541db57c8d1867c2eda6efc6fcd79a333a79a5b8462b828401672b021d7b42ed6d77cb97563b59cc7cc43c8b107e97f9fe1b4eded5ad5ddb5de629aaa14205ca4ea6ecc626463801de458433ea73f2bbbcfcf1b7cce79dcfc1239f4206bd7e598ffdb4ba9c3c979ccbac83475403e9ecea7936eeaeb3672a821e18dee28ad2bde08b945cee3694a22da7cfdfaa13e33a24e10d1344d53354d4080cc70e1a323aaaa8f21326d804cd334d5ce34b9223f3621ea6e3cf5ed34857ec30800478e3c48e71832ff1bdfbc8e617540c88107196df51a1f8b34b267ebba83b4de0e3aeaac33c86b393bc8e5ee9dbb8bd55e16610721471de4bc17d267635cfcdcbf4a07e9ef5683973d5cd6798b73905c9f33b57e7fdd385ddf20871c64ac77ddff07637d74d6fb221172c441fe6cb7cfaf9baf3ebf8ef378f3e01839e020ed8ab3e19dac2b85eb43a056418e3748d7adcddb207ddc2b726f380db95ae40bd7a4d429576b398fe1e3400e37c8656b75932f5dd4c55579866eba3f44a6c9c275841c6d9097c1fb1c63af45ebd41fe7c9e460836c7575f3e8b1b24a1b6d1bd1c33c167d9098630db2f1737e6b756bcec5feaa417eabefebfb6c0e7fd99b06b9a83b5ae3a37da1adeea241526e7459fe37fffff93d83e4659fa374da7663f4f56690cdb3f931b33ce7b3d396415a0bab63abebaa707a5b32485ef3dbd5699fa50ed9a221eb9ad3ad6d95f6dbbe750c92b5f77c7dde39fd2dad6290b12fdb7fb4b938b9d21a0669179bcb2984ccd6d6af8241ae3aadc73add3bceeaf50bd2b2ef091757e610ba55bd20ed74d4b2f7ac1bb37e6917a483b6ce7f2dde8e943ee582b45da3ffe2c5fafeb2740b32aec8625cf6368dd629d582b4afed6b5a5f73cbb549b320a38bfe91f2adac9f6b140bd27eeb369f3b579f2da35790fd2d7a5dde627c0b32b5825c6bba8eafddd51cfd45ab20179bb53e66deef61a4930a9299bf76e7699db519e714246d6daec6fe4ed6e6d32805b95e83d456d74ffd7bc628481a1d5b67bd315cb1bd78866cf76c2d7ece277db52314e43f87d7adc77139641c9f2027d308fbbd06676d6b4527488793c6f7decd9fa50f9b20e743f8d8f3e89c65944226483b6765cff432537e0f2e414ef7165f7b87b335e7500992bddeeb7132d88bdb7d49909399478e70fa74bdfa2141be175d656c99df11a4d3a68b3238e9f5690469d7a2ad394bfbc6d56811648c8c3a868d3173ab3a11243386cc9e5617d7a3ed86202fadd0b6a5d3df53674d0832bae560bb752dc3176310a48ddc6bc1bf0f3a770804d996a3cc2ba476adc6dc7f20fdf662d3ef5bee6f6b1fc8fbccd66b117275372ed6037919474bb93a7b7651ca03795f73436bdde78b0d7b07b21973e5c8e2ac1e2bd581846c9b356df3bde5eb9c0319efbd8e3fb275f7d98a0309e1f467b13d7803e993ffd6cbae8dbf9e17e7f1c7cc8faf20870de474c7663fb61665d3a319b2df556be7d7e991d25703f9dec5c9fc60b3fb5cbb349090adfa1de15fe89abd33901e9788a864f0aa959196a22086310010425949150063130030302c1e8d86a3f178a2287af203140004597e6a9a422e124983c1500ca3208a82180662100008208410628cf14a116e00c03ef6a440347b8ef61d6168e8db8d0df74bf5611d510b68ad2dc4e0fd4d8a705a5d0d20b5810f42cc59fd9f4544d406b19c83a5727210ac88d8bc7a22b7f22c74413e376766d43f788a5fac2fdf055a20aaed78093242b7db8e7c7791f20bbdc6d4e1d1c0af715c1647479b78593ce764b6f93fdf909a5f5470cd7fea27029f280eab52b3137df15661e3323b8ff7015830f651a7273da49283635c46bc941e5f330b5c53695aa4c414c740ac11cc8cf434f43e3b88e4e300cbcf1b5855b61443e3b7cf3ae2f58cbe3a857309bbf341814fac97189f5c7dbbd563afe96028de3f4d559c637775ef79a3917c321f061cf708f244ab71818e38d3693729bbadf51eb454afaaa0d78a3f4d96679d2e21ac2a4724c040e4260cf2b64988d8840a4f118c18df8bb57c4b12d0f1378c3da0aaf7845d991ff3d2e20506a60f0aa374a0c8efa7fca2a0a21527897b47f660b144cda256ae37b42d3e55cd014e24343b0245cc00d7683431844a4d024634b43b04256600d928b43186524d014344b43a0635a600ad515aa79145472ba4a62af3940685bac813d562c2a15454487a9b188e64b508086641d025fc6b50cfeb6ff590124f46d0febcbdae95a0e40be251b52f6d3c1b83e9328941be548d995566b1a4bacbc4fb17900195418442a82bab0fe602070a2030b4eed4f5c941dd598cb823f387efd4d4632b82e965e5d48ddeaf1cb73606e2728a1388010a05ff86fe03848fab7cf105a2e4006f4b5c860909ce6cb43b4223b61ad1179b067e396222d21b4b2fb206a21d49117b35622ed207421dbb22a26e4e92315b2af3bd8e0d743812230636e22eb60c9c3ab2a2440bdbb494cb10a390de587a252ed413d3d1fe6ff0381dd8e5b83a72928c8a309d4fe6985bc7bfc47c0397c5f1dbe276fa2f2b5ff4b24dac5c183104e9264bedc585d4cb8a6f1d058ca38db8ce6e276d68cbd03a55b24bd0f5d2245eb95cd7fc4bcf0aad93978332a153c81bf241fd5a11d38da48bbd066e1cb1474aeaa8c08413c8ccb8a5ff1bcd97b5b4daf0a490ab1173b17d4c28bf2cb7e87f9bb272156230d209961ab214a29b2415dbcb2d9a5f38cb4feb8525bd6b510ddf74b7417f656659966b0d9b666a9e068e85db46721620ba2f4a001204182f961cef46f5396b295ef6f0725dcc37df84e951d1da2c706a31db74f290f1fde9e2a18c31dc6c1ca3fd8cd71ea7da9dbbdcddb6d970c5a861734295122e6558f85afbaa0ced3d0e494ddca948262bb01a15bd7ba69d12db681ba49b30cbdb7d19f28eb2710b7b85237b6b0e9d4bde82f1c80913ca03e9e787d9c605cec4ea6c6783853117b6c7ce70855075dd0ab7eca674514177509eea1601f155d06c868f7e9ac0a2bb4a93744b2c62e552a7df82c7c80e9410c6568f1a106f5926ebb53c43f68cca8287dd6264cde7ba3e28ed5506c217ce7c270e662b2b5907a87fe8cbf965efb3b7b4b5c7729ea531371476482df40841102bfaf61c052b0f0f36752491b2b48b4d352190a2dbc7847ac805d697dac9d4db56be954d37ef10cef6614f290e60e834e594ac79483a807ecc9167e8b4e7fc17e64d6a7197a7ffb60324d2c0f265701d05829a8c5336af89c889c2e384a5052572bc0366cc4b3f92f636866a4a0ba2bb4e41041b08b68d12286dc13911d2ed884c9befd5c8c24c76df134c28b0aefdbe99986f8071a010630bccc416981aba14c7171b16bdf4baa4b93303585488bca03c33f1fe37cec4ed5e7db1cd7835346c12ffd18a84c2146237de06cdcdc199f64778ebcd2534020bf1c675f868d73e0457b31e2ec063f3fb0a85487dd6f5fb2fd7689e767eed5744420be03cd8cc05d25fc961271803032f9c728593fcde6332a54317018b5a471ad5e0677b35288e62d90ee373d126c2e93a29f3d340ac41f68f323ae6e2f80e81b27bcb68aada9e470c4716f437ef848369151d5cf6d460e9a38c27532573379c0dfc3517c428f52d4c94ae18c3bc42254650002d2c6493ba240c163a89265f3d0fe4f44eb282f3933c701949a201f1c217b46b28d8f5f9340f6559debd6f3a3d304a6926664c1c7740d4ebe62c7e155015dcba450bd716f65abdc3fadd02458bd856f5b550c362b9c58c56695bf06b51864573ab2e5ad8b6b8d7e28755e416315ae8b650d7ea1a16d32d68b4e06db55c8b362c9c5bd868f5b6c55f0b342ca25b55475d0368f1440ef9b59d3bde22f31d0369abd85d6897557dec455c4cc6a0f8559e314a7dd11cc36957b5cb6c70c7015b75b281a61ea2d4062f8d92666d82865b3a2cbf715deb6b0cd46144d7a1ffad2adf582b639a0c6ab5f23da3b046c3335cbed52e8d6b32de6aa03d6be437b4d3509f63115927af415d07ff1a85606d26c3d91b16695c36eb171bc86dc4df0d3dbdaa93b17e8d9977d0a5959b8c626fd8908db0ce78dfdc349ff6e9ba2abdbc22ab74781919c3ce111c1ef12dfe652bec7b42cb849dc1fa7340d3d0f77f6d6337f7df82cc9804a31b7468715d4016c709787d4f16e4065c7fdb19eaa279bfa83073765a6739bf1351e54f40e22a2ed8f7640d0d477fa262f489c1ae543fa3dad1213ec7a51a841cd666717e315c756d879077f10f392723212f29cee423df9a0c0bc3faca117b65bf562bac05247f0d95d89e1da5722ffc705194fa79afadfc08b0004faca5e3497d63ae05195f38e2262756700962671bde531c050685e24b445c7a0a995f26d17990d010f188d9b926e1d70e778b0f1e1411ccbe087cbf73c6a8274169ba76a8ed86ea20f28f3d7f27e94f2ec26f5cc5086c13f48d54e9f2bb5f0e7aac40cdc85e5c5522d0d07c8f135a0d67d9ef80b87cb7c8ef882c1dfd379e4b1ca17ff286936d98fb4fcbfd43a428c3b888510f14cef3f8a1228446e62f3ebfbf801a18e91203712601f84ebdd7b4c8d53ee143988c3ba2e7cf07f0de2e122141d06a40c9bdaea3c5d667edada6624e0edd34b520922ba36ff7db796b15cd379c03b7eb0cb5923ea410a9d47b0e2f223fa4fbd6e450354e7f2504f4df5cf4e1ac89b8eb197ca51d44e6c78fe0d066e627ec8ba4549b6f0a72cd04ebbfe59cf1eebb1e294fc75bedce8f02c3c5ce6769e661f1af1366453ffaea09e3e2c3dfb8dcfbb9def19990f05124a4d3bd87cfa9959ca9249122ee17e94c077ba424750a2a93e1fbaeada94959aab5b77616f436a9c6f788db4ad2b58c1a6d0e684530461ea6ec69e43b661f939b7b3cb02792844409aee219971f726fc7e7d87c8991a18a7adac404bb843238f551c28e41c55f69e772ac4eb54eb212708e75e70f176c0addba40d31567ed46f177816bc26d2282a95b7ef80148e8d3b689cc47ce52f679a1435fca2503b85ef17607876b7f92923f06f74b9908c0cc0730b031422c631b3e7a26ad511bbebfe0a908d334737b839333df9933a4b779edcf934dc68fd7432a623579ebe5cd3188f5d1aab6bf1ce093dd198020139c92dba6a4850e0596c1f317978aa487884803257c71fb8e8bbfcb2566fc88572d71082992bff27a380da0e51382d7f438f4070dd56fa239e89f7e4888d5c9ed7685e2290dcdf23aa6a8c02fde2cd94903d347eb7033a77246c998f064b19f922b17855903e69d553d04a0f6713a78de139d6d1ceb4694ce727a5c27ea06a3249a2e2a559a6da78357142b20e0089356cc31a9083ae55380fa68403147bd78ece1123224cc9f5dbfa4b07e09f8bd21a114249896b4df49dae845a4cb3cbecef597936000d8be25cd19e5b88bef4a557c398606e21965771450f4a5aa10597598a6fd4bf570190c308bc353d738c6f7891c4f12ca7b93a81fbc00505211291fffb4fef73b01f66eaac5a1bd1756c0818ea8abdee109d333e504cfa007d240142d0039dc1dfde81437d3e7add96ce88716644aaa3e275acd46d28fd9dc73f345f6b3f66ab40446a8c05e06ddd0845d07bc27f6b7cad87d00408eae632c5022bc42de5f160def1dc433bb5fe55d7b31e80aaa249219f58926c5970b2ab480bb6f8faf43ca4d833d97708dd997e0897c4ffe2efcb8f305b23c2015a9f70502c42bc0e5242403c3c90272dba7f8fd2538604a5e6221148eba4566f9af324ef844bee428366f32b279beabe6d0ab7e9c63c7dfc2e59e9281e8305eb71f0391a8aab77a1fb73db179e58d100ad2b09be65dddae58f344dca000f71200e27b63e0e7f9563481aa3dd2143e80d118a5aca32c02782db66e6439c9cd38c4fba064de9bc0de147522bc701f2e00f04212ef34ed702e017b623e53f9e48fd659da91e073b3ae75d2861cb3b41a77770d3627fb83aa75a2e88907482fd8586f69c8acce86d35a3b515a06c59c3e1e16c5944bf4e1718d6261d46e2fec908b569dbee34e195b6d751e188d3c60822849889cde55ad4c92d74111e0ac2b65a50683789c797e0d99f3b8b9398b744d2cc17c366868104f1b9f9db742325431149ff2546b7a51514829021be68331d8dd47b31d3799476ea3020419016cdb2c37e6a0a96dd19bc7e99a554f2a2ca1227f5db47b7e749526c9d65fee40e3fa2d6c0a6311e014c430a0f3220de787861ea4478eae17993b2ed31ec8fdd1ca7884d399f2e31fc8c9fe12c6c38890fd6b190bfa1341e63dd6f167abe9986a0853e59c434b30c1582a5385524445e2d7beb7176add1b8ff3d1a26b790c03697bc14646b4429f71eb20ae4db9a8e6b2d5d05e33fdb4e71caa9d35f692746242f49b6ccf5d44df5fd1011df591a66e3b9ce474156ac66113d8332499af1a49a1bea188fed2952c70de93d1b7779edbcb4c5e51b5c3816a728bf0308616e637cef76fa6d26ce824c5930dcb0dc1782df32613e8c29dd89461967585c0073f204507682b1cfee09e7cd246e0259b780afbf3fb8e297b2df2898245b5ff37a816a148cb1c185a76798c4209ea1a6cb3bb71fedf267553e622a49767e724aa594ffe57652577ca2036b1429cc9e7a528185d4302b9dd17fb3ef69c66a59620a9ead454d36ba99a88a8b94b1ed22a5677ae3fba95d37a179571f3d4ff693c1de9a1a36bba217ac15f026aca5ec0e28188eaf2cc243f89bb9591c44da6b52e9d773d17112fd1eb4b9df655206a6b87a074a0c55fdf375e319590e62e4969c93b0e254a792ee253a25c9dcff4d506ed53961066aaa304f2b18d2b4f965137a6f668f9e2914cb8b78f8590d852023ef7afb80f030d5659ea1613b2dbecb41277da0def3deba0051b1f5e71c93259b7dedb64d844c61cedd5a8c377739bcf408afc50546cab65551eb3d8615e6f1a500fa5bad569a772507b12a557abbfef016b4e869298811cee56683b7be466088f2050cfbed4cd922dc70c3753a04dc841acbf06d11da42057d57e45f57fc304edf0d22a84a55d982864e8c754e09c40aa1fc9e134d83b965702b8a48bd9075ee7108fe36a68d18034e3f5bf1997d1bf273880807d32fcd6487bac28315d286ed401814f921de50198bc57604ef4674175d442492f921d0630d261ab364cb8057aaae69a6b334aa85d99754146b59264b6cf27be1b87cf894fa7fec72f3d4be3dba0344647c0dcd4fad9a0dae4e20a12947f02c2f33c9ee5110e8a83a04871538980d9dca4b797ecdc32a735a53528123741455be5d05e27968fdfdd2cb8f81e75d2d902be426a9ce9e718a14bf41134e6e93b4e3e0ae32dd9e1bd8cc355dc6c58095a4e90d8b3169fb0ca5cf2c76dd4b0cc5bc19b54665370d63e51191cf0c7863d68ebbc1f22335fbd4247b004a43ff3e5e398e32b2b5b00fe91668af55a94639d340bb836564cc5503e18b7423fbeb9204554b9b41987bbcd82afff1362d666b76baaa3beebd58451579bfe256c66c5291132383fe50a489c041394b6fa2501b98b8d9ad5cfdc79a3a7172817c0be07f91154af6125638cdfa772e5390a4014952440686d30e572d1242c68d4fa8e1e4c381e1c461badaeb023523944d8d49a3599240faa8fa8462137b89c17a6117f2b3a9114421b9a1df747148b22681bbe9617c0a6647584499be813f8474cb31fbcdca8572c269770c1fb721ed75c3be1d0bf36bccc99d533b007ba7f80ea2035f5c5587f28bc08da9185a7e80d62ae65e90440ea2df604b2fd2b747feb45eee25eeedff5ff7228f4823e108e7506d4b0b8a864065686a2fda4f6b056480ad750c41e436abef1444eb1201061109633e14a99f081d0df7ae3ed84a69f8ff8095191e9f35e7a936588e3bb6e518b1c8dd5520ad87c6662381c920a44b1368709cc922e0763574ad0f8a5e106b4ddf2cf90331013318ce0698922771336c3e778b6f92f8298132ed5519b82bc9354544ccc3d8413997b4e641973c296e87ace7f9d26cd58a13461fe902626f4972106d7c1d4b87e6d33ef76f8a840572bd0762a0273f4beb07e74e48e481c7d61f3c6c54e758dab93d8525966583625153c95e472d537b64b9a4f532a830b43043700aaa39c8a7f6e54bb1f3185200f12e9e24e31a827493a4bd3e44849844d0a617b77304829c986729ec4b6c0b0fd58e2703e6fe4d990328d6c30f0ca073a0c8da671939601005ce50221ba2c4a5375e525649a12d86d8d6b67dd4dae83d82f2d4e519410a4b7285480feb5919d995fe3bd95752841aad49190b4d809316bc0b658fc75b9979931c9eae19279e5eb6fdfca417fb9a9f6ea5efe4ef1a370e67c68f2e98a3695be1d099f8731f5aa5f5a14b534368a4c2b4c7b5b6b542709b4becfcafbb8e73e6ce0f7e61edaeed2dd28736ebedf03e8132c3cb8f3c917e0f95cb08c28b3c93fa4e1a468a4e967e8058ed173fff9bc1135503c50e7f6aa0b6a80cf1941a4bb1216db06d8a5d9387c8451f889420a5b9d78485512e496d262e2c170c11a5fb88abfe294daae3615c6234a3b443ce6b7ccf98abe848e7cde138095329f9bf2f591a577b1954dd07d5a278048dc3eb1a1ede406bb26b7b8def94b67fa1e91a49291c11225936b163cb38a1b24b1b2504ae35ed4afd2010d96493f0a2e8c791a596fad4dba977ade6be75e6b32d8592363b0936cd8f9e47c9e3a6addcfa17fce0df7b885d27a64dfd6d8b2ab779470afb259403799c9e50a4e2024d09b92b43ce18776002c5799925932a561ea3512179400436170d10ef6866a5f2cc22b97c81cb495ee77379ab21e4c2c4b5d150fe7c5327dd6bb1ddb9275bd95cbfbd760462a798f00a2787c4366d2942fa8c2a779441dfa3a40387e1b5831698a9b4148380d157dc25f9186455146cd767dbbf4b858576b03dae235e5e9bd54039e34f55a7e26c60b1ce8a51b4de9c0d82fc766a2d032de07011ea0732a90431bac4dd5abed3e11979e3ec6614d12041bdfbcbe16e01f370e9e2c3887385e0ea7f50cbc3cf6e4f2dad01c243cb7bc6267e100b6c01ab62b2f0f0367287fee581ccde8adf52ef81fa2a5eadebbdbc21888550bbbf25b110b3e8f17720570f2421e5ccb58b3c687f050a20eb9f853c9d23bc9e2a2c6a79994de238040d1dc7a0f266158d08a800eacef02346932bc301f712801f068d24a095192310014fb0d1723eff46c802169607eb100908fc48247546758569e9f109b1ef79c5c4a72cce6c4e8c841a88e3b278426c307c76872285f3a058df5271786c874c2afb1b2f8b1fc73bf7d72d1b341c6585f8f9fade1b6e5d6bdf442ae84a7de9d14c82a49bcaa16aa217dd2a1b625812c352cc0ad60a958382702c2f6903eba36872d22582cffec8d4885a1f7ea2a8c21083effbad3cf83d14b75e746c67a69c74fbe61d8c6be7e5455a24f92c671b98117011c1ac04dd9afb756cf440606a1ac349509f3bdc171f51fd526b06fa21d41a74176fc92029899cbdd311876cb419644facd1d5765fe24e06926bf1c2a3c5549383c287d49bb9340eafd09642634eef18504e04ddf0ccf62b06bfc0455f1c52e2978cbc105507d43c5d391fd6e60e243005886e9082a488c80f09564067f9329d546ce0b47435484e53bfb8a3010bdd463c8d4901bee7d2d21222f618e5714580eacbffe81fbef2739c0713a880e8ba7111650da432a158a6ce78f77644c1ecba2cf34915f50ce62d35dbc9103e0aede0442700e43935d1732f89e9816ddf920a10589d0502ff690d3e25663d2e84f49ed758909865c01fc44c568d0b8bba6e1f9bf59e56a146f1dcdf4e4d458e841d5836a6a57c2ae2e04f2f195093c09372dadf73ec1ef940daa4603f770d4ac65338e0f90cd03d758184879c4d17767de5108b0d4f22db99048f10f46f0d321284058a158a716c077093ca5215b380644d1d922e1145a7dddf716015dfd7499a381be17f4ab2ab9fae43d5db30973aaafcc5223883940d0d3b0a7833903c90904293c4b7b88c7e6a8fd734f5428f0a29c4648c418a6e0357f2ee9c883daa3135e28eca0a75e06b18b51f8081c452114027f1b64006c59047e96c200505405f048f82d108130e593f0190a0241d0178123e0b64200c7a9f2fb40a87ccf1755ebcbb25c509d595394aaae116e3932d53b538c88877f023f9863bf09f61898f179bc670cc5efec43c1f319c1ec5d8d737aac1a2286c1787242140145936f5397db79dc31f8626dfedff3101993725363c3246bbb538d2c454bd0a25cdb69cffb77f6130391dc204e6d7f6fd2bd7aaf37f649bcb48f6ebfb5533becf4bef2e5e4530a49a088f88fb1581d153fb0200621229d9f3b6f87b6d007c589f3e4b8241b5549fdeca443fbf6fdb5f3ca34f45abf8368f47e269ce28e1091d392f91a755e647abcedaf931fc270206837028b605727b0649f35f92ff79edfef7f31971628892ded4412ffe68702577d8c0a008cca2b21dbbdf19ab264a423fe5105c80880bfefb1b04635a45ceed05040a342edb74ab7298c817ec3a69fce4c638ef407b43a4c022839aa1542ef34c57aaa6f86ed755e9199adc08ec0cca900b9f9055148b23d931eb70a9594e72389e1e639be4641befb49b6283b53a6fa2b48a27bbc90dce3cb532319a6fbfbb9c132e1ed0e52ebd1d627472098d895c0fa10cebf8d7f3a3911e0e5def01884ceed6d2bd854ab07808e83942d3b37b0feeaef0f36f0a87abde0620696634cbc1466917b0d2ed67e70bfe1e5e0512cfcb27c80e8d7537cda2a9d93649fa61e2fc705df0b6ad3f520bd8faa12140f6b52398b8b0c503f11a6eda3977e60cbcbb8fa55b389668d5f6e258d8123608a591d9cd52dc24a7f7f8debf662dfe958de04526bd4a9c8c37b8c44b1b7ca7bbfff6357afdf6edf047f13988dbc4cb4641bb9003658e1c763c8fd206b96821d1281d2fee0be074c3b4b56a48850e09a8eb9c165631d805d85f6d238b847a676428dc9b04b3b742021d7dd890972be0a32abbc913558a4f417fbfcfb396dd189dde5623fecf9af4dda686518cbd2db55081fe335ad8081db398c83421cdcf230ffd96721e7d8d921092d617cac5a8bf4dc3380c0d83ae6f739318fe3936f4f021b45bf1a112c9167a48a04079b8422ab4e70bece405eed0cc0626fc4bb1e5a1cfedd31c74abfc41b64ec5b6a9419a002fd88959e72a605ed59206ae936b79ec0a9743f981e128e05f709a83521d048c3fc2fd7f9607042476c06ef5fabc2332c583f68de3c4bd884da90996ff53012dbd7e66ed4ae4ca24c7e5461b4221fc0e77752678ee914ec852658452bac7c7320bcd5c11f32b09bdcfa49f714cacb9a2076eaed96c46b1b95806c65e154516a08832d769fea12ed0504340d1f8799d77757b00f3a568fc137fd06346bde0d06ae1f50856b6c0d79c1ae930ae85c9b9ce4d3d83f6bed66187a6a6703346b27bfd6bbcb0daa3801ea1cec5af7b85a76c7ba94a3752ff3d6083e5f4ced826068453092c869d74847ed76ff96f6b8258b2f752d1041431af1d6847f51ad9911ced22d2c5ba38aa970f63c7bc28aa647caacf1c0db3a612a35d5fa9b74efc917b9cd8d727ecda576f0fcd0f92fe45e0be1fbcdeebf68f460d09511647b6448a2a791fe7dd2a392defcb3d7e461f68b0b42ad999d645549e2411ffba6f120fbac7af9c24e72d818e96a8884a75b72eff36d0e081ae6b030de0c3037d1fa22e8a99b29616cc7924b0319346d756f3ce9eb78f62d9fb0a6319845546cff6f395d16e19e0f370241eabb1cc453170fdeafbe019f0130e28814890900510e15cc9d3bf124b28bd4eb0018a8aad49acc320cf08d58f7d32f486ca56ffaa2c83b4b394cd1d5d9e39cb303ea2de75b2a3f5c7e3261a345f2a3919d2ebb0e1a873e9a76d568bcf8eee7649b5973acf71bfea9e1be04c6e36f387bdbcfb65e5efe2d1a73c70e79c9569724cc3fcbd7ced46ca039b2140a46307f86a172b558eac56da7922d72378db41c14ba8b0d02f70c436c623a01828d724342d000c5d6dc9e70f40013035e4d1c9a5559ef39bea42c5cdc001c6e735390bb9370ec05e99fd364b6b5068be035e66edbaa08b38db961fa35dbd2ab754f1f8dae74c8d07cd36520447eb6d52e78981a22dde389761af78e72d7bfa7ede68cc5cd4f175b5b6817119e9db4c71f2d4298bcd5223f37d85d72e5dedd8466ce5c0679e85ec930bc8da509be3654062107f0dbd5789fed93a1e2ff2398ad48317786135b7b10d3b8081bf62b3bf4e26f338bc7a38b8727e083d4ab3839bf8427135efd0d82895bbc9f9e5397b117beabcbdd403fc0c9f13006e2a699819352b73a9627ece9df07df6b4e93e8f8a3bb9ed5baff4915f9987dacf7a409549f77ba0f8e58b5354921994b0bf061a32ed41e3dfcf4d534caac4356eccae07c98a338af9245ae7e1addd5dd6c0c534431875f09cb334c344966eb19066d6b150b8198f40a6d66afe827fcf8cef3f3c3b2f3a31c992e11fc1fab3f4d802e4071ff7f1dda64cf41867347a4d25d98fd5557a34bfd07b77efd1796d92ffbf28bcdfbd3b8ebb38ae393879a8c44d60b8de1095c7462fdf67077bacc80117e78ad2c4cc86081f24fcfd1238d23d1d018e194e50f287ed4bcbc51aa836cff51729b9a019fba6ebdf979dfb7656ac33a5ebf12f9524af9d68ee00f30a1500ab688edcf2e495afaf7504a8e340e5bd8f9de33878933691f04c72feced32bbe92e301d7550b2217708cffbbe632094beb5a9bf23cfdbf5aff71d9d8556ecfefbd326ded2d331e1ad67f25f966e604c89445dd307500817c9c5f9d5fab86d44fa7ed2737c43d3782e759da40ad9e8418cbcfe50cf36ce4de3e479a4ac5e23c690b73b69f0d27c5983ba79f37d4d97ac3dcca5ed0dfcf65f11b6a7862decce17ed67689dda38a4df71563a9329991b1db0887b720a30f28a74ece4e1a96ccac07988f462854e67f9380c242ef09a8efe95a6be4c02706f8a767765b67a7bad4e8bb479482e163264db6521dbaf70ed6bff9820e3c1f850a06e9b37b2eb3ef95956ca3677c0c84ff827c61cd492197eb3d2e0f8910ffc73639e9fcc2978aacdbf453d307f5788445cd48e339a0bcd69e4693bbb078598b3370fc9a99ebcf8217dcbaf1e6df993c58d2450c4747bc637db8d7d6fda1a3beccc7b28ebc28e5638da8f94a997f6aae02aee6953dac94fe83a89800394ca57f00c68c63dadfc0476428cd7ae79ae796f362a21dacbeafe232d827ea9b47b8d88cb18f9ce661148c2dcb03e7aa80730bbf4b12c9b38e77db696593c1b9916ef633bd1bf164a9e70353d5d73bf6d4ba405b24700917aaa4076f11d10e9ef21268077620b0c9fd4075feb4d4c298bd85913b18d854e909371b241a2b4cb7b6bade9fb7fbc8dcb67f631955134197d30f13b7a8fae12b7307426f55ffe6c477d4bf90aa352da52402608ad4e91f14d414b0fda2cb9567643c8f6994a6a0d1704e7bbb38e9007cb4c52748e7b575960bd572b1cd338a900d8dc2f4b95a2029c99579767e666e17b98f2ae3e438f99c46a420404039b0d0cc2f151fd5359a1ce6290169a330b9f5c73b7fc705ec9831fe2b949869b74ec5e83adc3101a7a6886a72fe89a748eee48d4f270dd00f1e982fbe3da37c00062b8bccfef710dc6a81764d66f5d05906166d02da05b041e7fd4e890bd5fb63d717f5e03f6f8271f8e32fa46e753c073c878a0fc3d2041f4b1233e3f077e6e22b99265becd40641939794df96b46c6c78810fc45949b6054245f53ca2f71e2dc14f97b32007710852f07930f0b2cd3403c85cfb83e58e073719f05728cedd3bb2b3d194f96d3f0bdaac5fc67f3d782be3c84c7fba177c6ca61f307addeaf3931510fc45d31b9504ecb6baa7c2dcfe637eebd6d6203863f3fe95d91a5010dae7950ff0b6c14675dd77f8e2bd9b37f727af36be013e00dfcec11044c80db44288f783507e69878ce26e0a9c6e29ad5c8e0a181ee9ed023824f12035680596bb80758461dd835597f05605ef5756d2edfb8f1ede05351ffbc2752e1f3b016ad321a362abcd28e251fcbb663d246d1402f1e10990faf604733ddf1ecae3a66649f9dd3a1b9ffbd132d4bb1af11ccc174106ba9df3dff558c03489ec2446776e2e52190492e3677fbc865a4dec930d5a14d185ab7bc0284581a4b32fae82e1b384cce3317d7e8409fcc7201be49c10488e2288694d029070641f57a0f8142b559a5622366c4f91f8f41f315b905711d18a3fb5b310107d5d000dcd57a641e325a7aaa283301becbaee001fd693f2626aed0ddd517d39048fc4abb656841ed2e669be012e160271bb44479cd8dfc83ab08427e845060c849ad94db01bd5156a8de42c76f236cf1920e56b8f7798c61d1fef9a4588147b4dad0d3ddff7afc5bb02f4157ca808cfff53b0dd86a760db56cac048ee18e3b6d0887aec975dcf9c1aed39ba265ed82ae74101403e46784fc96f9a7af9444a96897f7a73e2d8718abfd497ec01215e841d0055022443f0d9ad14a05e097e12380a508e89c760496aa059c03ef8104419aa3f0292f801b06e1fe6c81832d45054316c108901d5428463b35885f8a87009726a1b3da1078ea367016ac071a0c6b8ec45154b369f48538087e65089ea88a4147eed153813ae0dca8722812429f1ac56f4503e04bf3d041650468761b3a8b56ab3bec12c0960d73d3631b9cb6c664d30b1b886b0d58535a0d22d42a2890e4319a7e519017c1c320f662000729470184aac04f835c000b8bd09f0518a0141500be123e0562210c7c927e0640a012f420f00ab85408c571e0097a9900c0cba003402be2d02329c68025ea6107c2780a84746a541044e419b9839fe63a538285e0e1ce0686965d0606c5e0fa05f9317632c0ec2a7f75871c9b7ff2569e640323df9a8af16a107e6382da6bfc5e59533c6f14cf03a726b0ff07358e2aa814a3fc686a78aef0fcaed790115fa9eb3264d024e82abd80d0f7a74acc55c46a8cdb3c593cf95fd08a08b6a659bf02883543418f71d2607bae5fed5207952f5efb13ee73cf597cb8c58306bb16d4c7f59d25c23ced72a6bd04b0ed87e2534233e2aaacdb04e9c0c77ff20235d952b1d9e69c8c7abbcad49ee595ead1070fbc4a5938bc1bb1b4ed431185dcd7b92dfb8d04d4fd0ebfc0aff2f17faee4309abdd8b1e6f2a995208112a5ba83d4fda2cd1491bc9e199bdca4223522bb30dbe198844c06cac52414a4b7f46c8bb4e74c9d4fc90483b53c348ffcf9ed89ff800ac23b2957a711031638dd9b21751184fb3b7c3924499647a200cf88888c0ecda7d14584a7eb5dbc02d64bcfc80eaa3d826c087a67e6c4885939f74f23cd37808172a3ae9b79134c040da756d6da5372617d339c8b5fcece04e71cd32cf605d7cb84fd98a3f5e10c6c844207c88f2ed27e838d0d243af92d9e7aae63909863d5493ce0e0ef45560a0eb9ae0243cbc74da16d171fdd1bee46a23f07c300cb726c60dfc23e271b623f185f69049fcd4921e50defe37c4ca777bccc8174fe80797015468743fa65c57f7937ed54214694d69028287e7c7552e976a23bd5c7c46f7f52d1b3473333e136048abd60f26d47fb65d7ed16814a7eeec98e44274b5229637ab96295fe0a579da178f26631d94cb012e0e1fa37facc309a51be243292a89d42412680d2329ec4b901747be18fbbb520f9a4f6e6c181881ddc5bd3f773658c9a160475b9b520a8cc5fc6c470c55e364bfe6263a07d44c8a7ed0a045456992116ba411c0caca952377d9b58b27d6758c597cc89ee5835f0848af387dbc8de13765e2dadce1fc03fec394a6d5b747e8040e08010ecb31ca4db31c7d985e7d054823549a65cee90d3d9afd64ff61b97eb7c079fc453a55c4d97379bc2bea3b92c6496a265b012a3d3f35ab0fb09ba21d3422896065612374eaa805ccc417c6c2f8673b9c33c8b5717b042d9e0db14b067ca06c4ad2f42c00ca7ee9faf87c7b6ec446f8243a85f218f4fbf77410c8d741d3b0463046684fb8e1af3991fa593d1693ac60d1ad5ab4e6b0982a20abb6796f9acd62ddc323d76d24f03bd37cec28fbda6430494361afd74eb3dac0c9bb227509b51b0cd5e4a4303844c641e091976e1bdf707114ecfcf919b0688038a73a1cfa39c050a4a4fe8c1403fefde5d778714353f6dc412f727c54a2c4a9180944588883af17b55f6644e906f7c5de55da56464604c647175a2e28a290ce1b284090410b8f990650c1da1771adf39d831f2cede93121b745fcb95b8a20d428103ff73d7578cd646f65c869b86b44f0b2be734b387fcb464ba2c3fc7b59f8cb0eff2c6e92e05f6cf5dcb173df2c5084ee3ca5606abf07222b057178d722d3fbe2e4f20e277b6f9fb3b4de253680b48adb05a8bde23242d1270b66989e17f365d2d3cbf7c22a1b11b52d023f1ea4119fb2aeefebe5bf7b7d949e8abd0e57048dee8979fa8f9a923689f5399e2691e91dfda84737a3957358218f174566e5a07857b28656c36f624bf23d917ecdb60b68fa859d0b0fcaf511b0deb591e137131542ccb16436dbbf1a3aacd7008e7237e8d58f9d026932331668169d0ddf7ab3a9c8d73c1fd305e7513bc7f12f2182f9b58bfdc36a56c6a6679f3ad8875b493b2c5bec3aa380788a6d35c4ce754139e74f2627efcba8b838ac86085f3ef65b12df9145656a71bef88ecca6ee97a02b79e2691e0e9036be9d6a3b10441186b426bd7338ce79e806733087a7b8f37e22bfb3247ba09399f6d696c85bea41b139e723c22f918fab56ac96075961f4b787ac1d0a70bee3736d882b95246ed29075db870b758b8e07e7e87e6c4852e3d9b45ead8383c59a08ac2851b403557dbc3b2237556e211e8f50affd7bd30c6203da89b9f022e4b267c037bbd31ca665aed9eb1ac7dc62769928695cf1556b17d16ed57ecf342bd483fff7f4e80db65973fda918844498c6fd469154941a01bb734d950e6b590129eb34626b0e3b2f6079ab3c41d6ce99f330d782e76499e23e6fdc18535eb0889759789ddd6b3a7af0a74a96a5fb37bd9a3c6c040ab2441f66a4d0ed1f14d1dedfc59af3f68d8fc3c98596a859033d7bd3c167e4313fb2d12dfbcc7067cd2308f02e73bbed98e412059b129f5a73fc6f8785c1708654789d09d28b46c747021d65f592833b9a7768bf3e2df0a397128f9f090b3011f5b5eedf548c04acca020192319d4c3f77d95bfd5f82ef1b2f96b37471c2fa0dc4a5a7c1cfa211e378e223b495d0f9cab91d85a2614bd1d6614dee8a37d496ab68538f788d73d28c9cc3cb1eed4a5b76b0f335c9fca8e68f37ea8d85783e7a935248f05bea224f1522797347a3ce77445a3434d5dde8e119f4fda400cbb37d91e6fd6bdbb6cbd441afaa21c1149b5fd04fedc83bcd6caf7b9421462761a29187c126ec80c68bf04de83339e9ab521fa28750d5bd8add669ba83d2fdec9a1e0cd0823f263e7fa25a3ae301731c4aa98bdea0d95bd4eae0e0630b73f315007b71ef4ef344d7ad62ff171abaaef55dfc82abf1d53f136cb859108cfab933036d3372c1e5b90d022737efe30c27f2e1c833fa655ee2ad5fa0cbfcf895e60dab807e3fcd3861b0467e3fb6f007658af778aa47a66a5b18ef77897989756c0c99461874aea86bce804951f47f86cc8e33da5f59f5565806f18066aff4ceeeccadb52e530849838132516863e7c44c6138f4f428cefd85952202805b7df9cff2fc7a9d502ffa304763b8ff578efc5ab580dc98b4b99fe5f090ec1c58983e340075253120916f10e6e496142b1f4d6627434094f714a40fcf3f8524de0ad21584b982bc3d74b3982e3c0647d59b471906934a7820f8e65a48214948b4b3f818b5af0b451b610cfac76ca0c2d301aa7eb92000a894793a057eb8020883764718075e0e2761cb025eb0b91f5387eb73c44c800038c182604cc096949dd392206804592ece1bf5ce6f195d83aeff758142cb7a8d19bccc43b4366ab5834638b1db7c2ba783db2722bc811b1ca4c61d0b14deb70fc48d8ab896aa50a18581f37c38dd83254d6510694daa145052c84b78a53020b2117168deaf9663b72d18e6adc5306662f1005a338e0a04020598bdf848894e1687f356fad082532d63e4fda3f5c796c836a1f2441b498767a52cae94b92207349714b4a7d3693e8b6f0bf7fab665db7ddb0fdab158c4141a7781c8a4c672f57838789925b812de7aee0f053ca88232ad582e98af92bac36f3943110cf07f96c288d3df98d8c515a29777ecc10c7aa2b976b2490df83365a5ddbf1994991e9ce856958325024411c9f7f78d02b50bfd9e73038af47bb1480d10c2729cea20cf4df1979f3535f3ba04f0b63c352d62230ee4e14c7032078026815295d3f8014b0bd366f2bbf5f91101fb2388f7217b072e05b41f270739d5bef78bb8a304265a9f32b153feb9dbf16be6046a15c917445ee7eb310b12b2871e156e0fc5d0c9c26b6e571caf9618b819e42c33a82b583fbb44c150ff333737b1439479f12b51352983688060b7c29cc260962432318a955ef92b2e811b2e89f6e75f20e1708b2022414f8aa5995ea3a15b13c25c6d4fe327aa2654b2798670ea8752c07fb5a47c6592fc2bf5a9a52487afcf7a2051d3bd53ff175527a0015553335aca6c03c55c177d9f94c88dbcfd3efee47bee84d36bb7c282354c7c0f84716084b9e754c3ebee02f4d027df4b08131311d05504f5c426d961a24e72e3b8bc0d717f6c3dd9a3991bfa53f4f2c448a18701cef19701eef285d252a85edbdb9b502b196ea77c5a95567de216097a34ceae75aef3c1360a84a8244381cdf0edfa73b0fc76958cbc2394c54c11417bf479dd86577dd4a8cf4bb52848bb9997263cca7bc9dd599ccee7d0aec1adfad55aae38cd38c5eb40dec8ae2518f48851129d3d7e38bd9d767b43158c59e3bdceec2fb327857ca6780227ff3937d393272989a76592999db2ac03af9261a0ae45b6627872a0e528b6ce6921c0e974678d446887821ae38a8798bcba3706348f6f0ab780b6c77f50f2dfb0ffdd2874a30b7a3ea6cfe38b75105bb34a7fbf39b482e9fb1eeeb700bd1a9316f6acdcd3ebaf6349460924e130856920974aa020d9c6295f11a6b1ed8dedfade8653233aebe4e2c0399aeef49169b6da154cc2471694a613ef60bf7cfbfd636dd1da0b5bb05b259715543710af6126a5242a6f7d4d7e324887a08578eaea5c8938cab7c5e3e4317122e7d08aade36614c01a1f5d36a54ba51abb90a433add9247384874e7d2e001d86c6600b85b2343b0f690e310b825873f91141921d9ca266afe4c63a244023150a57accce96947b3bcd3ac39125d4ee472e75bc831becc3c7c651aba627976598f72bb75834ab83ec878012c8355abe7ad876a2ef96c630fad84c96f710c1ae2f59613d3c52d38f054667c0d2a9259ba576ca828c9fd632178973386afb6e845c8a2e1e3194de0af1a16a4b04349c9d154a4ca39a3f8d8c4f138249e41d77179a99da09f9e4a73b64041ac16073472fdfa89d1ce7c15946595f0db3f9972484f290a9a91fdffbc3c114eeea4106dd91b89bb5f5f99d01323385ed83d1b5693733a5140b06d832977036e2d03721c7002425845bdff156c3f519d064e1df2873fe72a8375a50c6d5bf290249fa7a4dea6b840f0a6fd5a8536ab3238eea474bf74ced4771158a8c7ba1f32401cb8481bb0fe5d259a16abffea8f8ff1d15b0542122741c32088b7a705e96178daf28379ee9bc3df3ebf3e624962493f6750cf6e82009636c24f15cfdaa8620dbd945875664ce01688cbf318c2500003e9246495a6cbe91a0e0a41399b4d9d6c26509ace35442075ccf188d29dae494da195ae388e3a6c8bb29a1dba574a1130845468714d97f91b879ee28d2768960740bd49d43c94b0c002e93a52e3d07e0a447b26193ebffe2a10ebe0cd518d0221a2b118b3f6c170b0f185780880d7a2f324ae4e207539dbeb167b6b840281de93191ddc5d9afd9ea50838d8c3c64671047c4fad289d5b887889ab42e50731d16cdc1e630742bb263bffa6a56cd445766b26d1f7640f296a4bbac8404307cca0176f0a51f0d8983a0a7560f38095ae39b4f588d0de5ab01f419454c424064854ca8845cd36464300e277180bc74933ff8b15e0d4d47344e9dac182d686a1b4390bbb68b10ad57394f83cd480c4c50510e3c9038f56bd4d061e82b60681ee5fcf9a1c722a4e39c7c01d7ace184b9f2c38c8bfd5bd99682ffe893650c6c0f83178d0064a1bc2ee449e3ef2e71490b473eb80ec1efb95d5c3ccbf35fc755932528351aa6c50b38c9ae5eb58e8fa009b47be9279b5c3fd1bad68b95960841197d52ae062e0c4c865701f26f59ffb419571fc3c056cc86dc3607e4caf2406fd5154c064118a3482dca517d7dc6f6aca2acbeca999a3e5ad0df9cde74b1e9e728791ac3180d9fbe230c5ce73ebc309d457532e1d519a20b491f3c8282cfe2ca6765117c4c92de8c08ff9fd11abd2e5e1b186dcec0372c8ef3d1542a7cfc6a5344b15a56d13b06fbbcf2a8f9d416c98ddfe04d96a5d9f90d8c8e9e575d51b772302c41b3b16b9bc2ee9f198863f8f5ba4cd7603135dbc961cebfb34b473ed4a367666adf2b07e44ab1fcb10d4217441fbabea1eb428bc7045f6f1ea9e8aff9db94971de26ff960e4226aa964e21b8804d5536cdb05ba46acf8689183624aa0ef0465c2b963d1ee809379cbfd6a98831af3dd9d6629e3de56a084277f132b67c17717f385cda1566f9dd9a1daa4def780d35d5827dc0f6ac2639ab78f7f08a480cf18bef0e69e34ffe825884ea2a015fa5c5ad34d1f623f0822e9a15450cc367dd8078bd75b71002969a06734dbc47bf613a4c744006e8aa37e01eae1070041b5a119fc7e0d822e04660b21a16af8c077c59ec97d98f75350bcdbeaa548c3006da4ef08918ab26f16e1f8bb5bb88638a899514e0009573196ffbf510dd0981f02c61c569aafba7f025602aaaf5cbe2c517cef47a219feb00eb44119ba8b2df1109b655f1eeba3c4e84b80acbb2c7b5df040c303f311758e22928fa2ade189f1eb232d4940ac1361d17645ddee7fd893a1095d866e0d461201c08d3562b32ec556b2bbc2fb01db08c671fd1ff9a64d33d082889a0ad53af4d7ac0f02e01fc703a1baa7145e2e9123f903c5a185fe094233cf3bf18521960b11932b412bde418e556843bab311212ae173b6f0c1e11e2192d86b89ebe484df2f7c56215151f96afee4eef2eb1f225af644dc578821727cb4f28e19046c0a0d1be5c1bfa490fccb8ae8478d2bc424df6d34d6dc9ed8387d41702720df1c382c0d44bc3fd423cd4be54281e88a6da4192870c43c1f2eb7fa711fa4442a66543ac4f81e90483fc3b1bc5351c11557552732ebb7ef0f4022ac4d17ad720b3975029daf394684242fe4a03e94421608fecd0e51a0ecaa5d6e82e08485352503305ac470adc8bc90cae9820008abd270a8368871721f487a6c518603b7a5adf1d1111b2fb34196d35286003d19dd652f979e137d79ac4932d541ab2a0fc05855515bf0a132f6d5b1a3d2a21bdba1e6732c65f9d5304853839942e90184c5993db5c4a4a22a86cd323a89becb26a4a6de39b09ee77b798957db5a105c1212514d3470fe412d64979222d99c49e6114b1b7bbcf2a2531f5cded156292d56923e7e673d475040bdfc54c4b6b95bbeff75c686dc8f57d2cb7d496686e896635a38627e83c8de3abc2787f0b4e801ffbfbcf33628e816baed975bf2c60987ea3c6babc4c723c0f9c8cb91514deee9e6947246f573e4c7d773901e0ef79f91796abd65e0d5e732a3dff06a842fb4d2c9d8b8a7629190936c3fcf779fcf36f1451d55ca24194ce40fb5472cfb10cd51c69dd9a17dbb6ea4e1ed34f668e20ddb50a1142bfe01bba81df274a3855aaac96101f9ca0ddff95549483c6ff9abf6960f94b206c1caca4d548acd3f97588806bbf432f73147ea954bbd07f457292bca089de8040a0e69277e07e69a1cc9af124c1ec0318372cb8045ec7a52953c346eb8728acb1e2117f7c85401f322834281cfb982f24af2431b447f5f27ee579185f6e7c6e34579bb27d13f53b894f9fd9933ed8d1318bb06ccda1221af2236f9ef573e7ad68d6309f988a028ff863c275386c425812a24e18a80b07df91b9a316228a92e2da39a3e9f48213cadf61dc25647a16a2141a996a69d755cc458c321aba0c748f666112400d473d4c11617e70765e82832b0869b98528a33ef8ace312d96f3f4d25be8f2c1c66d07dbebfede4169174be0153cbfd9568eaac4f9ba065095786a87e5004f07fc71c085e2f5740698113dcef8f07738ebfed0dd736530d3931dccadcb8b772f68be37aac959a3ce9dff6180941f5ce55665c13324a037185720764f3737eb0030294b91ce519c05f3467e76f8164cb9dbd287e034b6b012f93816d221ad8f9cd68a03c2e3a8ca14bd40d79bdb1842e52e7cd094c7f329efe79e02981def22f01d1117b0650b0e04a2be79ff942c6bc751309fe40f7b7fbade6585f772c617e3c890c2ec07f980b16027a68b46c926bc8f205613c4f1acd35dc9158a4a6b136f745cda0901ea9624cfec022b8f034c55ce20a3b1a3badaefdd5e2602731221807a2ef05c68dfca3c88caeaeced8f973ea59828fc9b50b997d27caab83936ffac0de02e87b25b9e1133f12a90341c7df3917d21fa7ad18eb89f7b300c75f10fd712e6fb217bf36d3be4d8cab614ea644c026ec29e7f087a1e93e19bfd371fc035c519289a1004ba914541b5ff63d786680f7da09139a6397226c705bc6279239afba6c7f53a6416556abe8680eefddefe3795158054039e9c1095d23da86022bc49b07d2abfd97a94574d6626026768b21148068095d7669e8031e242a81582f8597aaf31325312bc2b8c975020743d0e22c9c47846e3c42d65d4bc26580d1ce392f629568d11d74456aa8609ddb3af0d9f72be147300a636c97b0aff027282e449361fb3c3d5f8f26978d09eaddcfd37327684eedda2970b8bc13608a547a473fefa09a2b242cfe106b75ce3c64e6c34cf1c6ca183c19e4fb92e146f50496a4764c443b8e7b2365b7a912454b50b02015d7244a0f66c5bbaa9a50377524a0b11e4a349f3720c2f4ad2e64a749d66aa9ba0eda7194e4bcd391ebc9977855fe2c9cdf41bc630180861a18f308727dcbd0d39b976d37a1dfdf904f77a6a40ed06dcd94738374389027d9018b1943c5b713325dc8b5de53e34db7cf819a55ea2fa52b11b05b2f06f31084fc2a47a1f72d6098df6e66181ceb8d40135120f055587a63e793dc731c3439b83d9ad34d6c234c11b5e368983e17679ed558a5ea7a3ad33d5b9ebe300778ef8b8f578f6e30d7363c82cd9f03e1d780087c4c182d72e0319acec822f2de2a32f24733f57413f6d2e693c7de3ded77e48fed03176d03e7629c68662b9410a68580f98cd4c0ade2e5d113f8d72379e78ac6038525b81ef549b934f85e4714425e6990805ea4f011f7e62088d86b11de93ae990135dfda335ba4d6899d2cecc2c7cd8497f5226b3c59af0264c537de2ee237fdaa594788747be37d35c4755475ddb9647ceb63b2066cd4ffd3500d1c8e023e5a04220b3760b46439330f0f0f0f0f0f0f0f6f4337426a6b9f908494a454aa976679010b644a29c99492d81dbc0b9c99f87466e2d31546ea6e34e301030b400bd30a89305b754ea153cc4f17311a1a68000d2d6854c0c3c3c3c38bbc0c801a6220c214d28388d6a39e7fa625c4388441e5edce5e2284ea63058d011b39ba7880214c3a9430d9298b440b63214c21c78b914df249fe104218b465c813f91f15620cc21871e5d6434b9e902208e3440b19a91e545479a2102310264f59952647c8881a157284188030a5e777f438191b6b016084187f30968e74f988efb9a75363edc3c647c12d4b31fc6076b7083243e465059386161e1e5588d1077357fef6f47137b6f3c1246eb35ebf9237ddefa26b68c06fd898c0923d186de28afa0e1d3d18e5524823aa3a7f3a711ecc5f174b955267a972120f8697a4b4aca5548086062440e3430b1ced12c891000b2851438c3b986ad27c74ad38f91b362002e50a31ec60be0c7df524667bb5af83792dced6c4fa09da6e3a986e5baf64752ef5e139183ce54ccb19a24a29530e26a13e57b8a89e9519d6588b83f14a456cb56ec2292538184ef6d8c9d0918488a637e8337975ebd52f23c70d068ba6bba5847e25f3b4c1782a629b087a7ad5c26c3089f59c82129d3c8851d7b09af89d69d3fbfb5d0dc6d1f62762470e252d4d83316757528ea8f360123418f542e3924e6a44fcc81990e79e7592d8f0dd88194c9fafebc329b7951896c134e23e23f4d998fa6430bd560e39a29ab0a4d9180cf2246987284292490cc69ff9d4ad94264cbe6aac1962848131b7d9ae20536c3430587a3cfe09791771fc4272a23de2880929cfc70bac96e87069d927e98241e9d349674cdc0575e242a272ac3d2f919152bd05decf52e447e9f4c1d58229e72454dae4f24ad5c982c94212972fe88d05632491b3d1174a4551b942fa4b5e9f1a1d4f3c620593aafcdb1dea296787ab7067cb13dbd46a6255a86052e6de267ddd4444740c31a660c48e14d192429784670d0f69267f4761d7125365924b5ff250307b2425df15c2ab3e9e438c2798cebc4dc6e52427182d8f7c87f2fc155d9b9078710fa1cc4c2618c4b6044942924b583ca565c7d2217fca9460b6317defb0d57f214930f68dca496adb87f00e09c6f8ddf3aaba54b61ec1d319b135ce74881ac1b8af27c1be6e2c9f72885104e34a34a14f45869e1e11c1f41971d72dd4ef538660505921e5e715e517662198aeb346eaa80ad2471b0483e855f79c4a6dafac4030999950b9206db573f20786f7efec4e7af744f6d00d317c9068a6965ddd0373b6c41c939397fb82789007af3e53a24f9c24edc024277c56ba206f92b6bbd8a26f241d982aabd675f47091d29203c385e7eb087bed220eec0992b642527cd9788353fc38ba446f820ef2183630ba6e8b6e0fdb298aceb521460d887f49f4d7280f950662d0c02ce6e13cae598ae4a1b121c60c8c5e3aa5a81246eeb8be8618323069cefde76f856889c5ba9f53d8cfb8d2aec1c254276ef73aebe597e91546fdb4edca31b57923572073ca9369bf4a2b0ce7a3d4bdc8c6fdafac30dba7baec905ff2bd5d85c1e444e5e6fcc83cb9c69aab1960a8a2ce761792852429684f2accf196653997fa4d1f15261d523855d7317e3a790a5418cd4ea2744c5863ad057e820fbe1b3672743185b13b6591f11c23966534b4a0d1821c5ea0c07451011a5ab4e0867f71011a5ad0f02fb8680ed0d082c69db5c02340430b1a76c39d8bf3850d2df3a251f05186c3bd68418e2c85414f7a0f8b2426297b5218d56cd4a8f4f1f6b98fc26c71d2cf88c5eed35714c6d1e965fdc36fe49ba130cfbc8f288f7b8b2c0185617f3b4be7fe2cefdf270c2e4946d0155a3ea25d066078c2a04694e5ed59d7fabf138614f22c56a8958afbd4d80d745181b3829c30870d911e72e6dfb29cb809e39c271d99a142de4713c60a7af1223444ae8533611049c5fbe69e4bae0f26cc79c5de7b74ec10a2a55cc214b45c4d9f92aa22644b98d46595136182ead866f2004625d491cfcfbb1682caa2008312e6a0ad2797ee5b93e1f8c8f3008c49186553c4055d59e46449560086244c1529ec8e55d808ebdcb8617608302261aaca9ef8b521b2eef187106040c21ce36e73278b47109700c6234c6d415f0e42bba9578405301c61d8b7aa2ecfb7b0145463edc373d8e8e24e05301a81d0191e3e6444790306238c713f62d1e43efdeb35d63e10522f602cc2544ae26e9b84a4425a6aacdd5084a954764cf86c3fe67101231126b566592e665c46b4cb4c000311066d912da851fe41a4d3210c7f61db43caa5b9681bc29ce467e498a51121a51026e5392e9f449810061d134a790ae141982508f5385721447a2c087329ebef2f5526e60f8439ce6ea464656af2640161b69446be8d8a21e4db3f987d62593c6bedec52fac164f7df69fb631f4c29ee6e65adff50b3f1c16049eb6666df8331458ed029b2249f5735d672b4e0468eb5ced10bf0e223c905400c30f460bcb4f1faa542ce53aac6da471d0d0d34600b30f2600a6982a4b82e5539b45c808107f3e81e93b318dec1a4646858588a4e96658db5b230ec608e26579b3ee26bfe5263ed830d07a30047af200130ea60103bc23f8556eef5c3737c617e18061dcca924a54fd2f75ba489e760d64939b722bf65cfa68f3b030c399844d8a9a0ff63df851e0783a58689a7541bfe4170308e507955fa6358f5fd06931033ea6bb47583f1d37376b8d5aff8691b0c1adace3e87f8b922369882fa4cf652daf4e49035183f2d98fb051d6f92d460887339fc7327b17f8d8b56810d143806baa8000d2d380dc6d02222d553f5ee99ae00030da60cfbf57af7703eca3318b7be26ee8752224c806106f359678b37eea9457b30ca60f2cad24946844f8da700830c067517ed83b4fe1ba53406e35ad871cbd7e3b29be50186188c5a5b37bbb67d9d3d6130a7883fda42ae99f6d100030ca6b3b00b914275ea60d6ad01c6174c9d5444af9b8100c30b86f43b97bffd9e7459140230ba60ead4157ac7cc264b8ad987a11c6070c16cdd162752f27a1bf9ecc3181030b6609049317a1e52d809920f3336c0d08229291d26ce8fc9979033fb30b5d2038c2c98f7e2f3558a8afee75830a8591ecb3d59bd3aba82f9564b7b5cefaaf3b582e9b7a3e413d23e29bd55c1f4c9b28856bb5890142a9854e764a53fbedbea3b05534d2c7d77aae2e7775230a9a06137d2ac24465214cc7d1a298d2c75d9520e0a062d93b297d095ad84fb0473cdbfa5abb658eed209c6d5b4504ae57cf6779a601a6d61ff45878ffa2513cc6992b07fff8ba054b40453ec0bd3d6ad3fd7394a30789add480bffd22d4a8239e8a860fb5fc94bad483089bb9f117942749b0fc6114c49d99a488bb011cc11840a2a87d1cfdeba08e6ad6c6a3f4b53438f4430682f11b211f3b22f3f028c21984bece28afc8a259df6f0281f8607430826ed4eb1743e136f97140473bea978d6ecd68d05046377f5886b7a7779f903c3488ab964a13a9f181d0e183e30d75d075d6e32ebb33d30a8b9a43d7479903d2e0fcc155ad41d988358499ae02af945d68131e4c73ebb49c2c4e57360743b717eee57a16aa3a1c58729da62cb60e0c03c16225cccc98c8ad40dcc1f44880525f46f5ad60626fd172d47dc9aeceed6c0702a3e8a4eb942be80410393b4483fc2d7e4251d9d81712b23a7bbd58fd41d18323005a97dff932a8ec9321646d3f2380f23a2bb25b0305df06afbbbecc9f4fb0ac39f4732f3d167b1a72b4c62a284dc5e893551d28286161690000d6d81005a6148fadada644c92159b5ab10b08801546133af5abd492d72cf00f1b393ef05620805598c2da6ee7d3a810376320005518e4e7be3ecd5f68130502488529ed2911adb40987aba09d8b0f1514c31b282801a0c294ee84ae4bcb97eb2fd2028f403985c9c427ff298b98c26057396e9696ecd1430194c2204566e6ff7bc8be202408801426f7bc6769a476d2e6e8628b1a450b0f8f519852f8879265f7a62ca6111e672887243dfc2e5f7c7461833b8ad0610643d075973fa67a8f9a40e828c32a2a3ce928a24e7e51e82003ee5f5e9d25954612133ac65072bb2f31cdd0b30b5c4287188ebb9611cf7f346ec1f9280b833945131efaf24608dae90083214938713af79c599a5f3086e917ada2aae7c4e4dbb9282fe8f082e15bc4bd54e42e186f74ce695ebac73fc905d3e4169973514af6f45174d0b105939294f522df4d9cc65a3098ce2945c991d4a0230ba634f12a4b92e4ce6663c114f428a56c47f44b7e35d6cc6868a0010ea0a10109d0f0f09041c7158c3a493c699153b357a264830225d9e8a2eca4a500083e0cd0610573a4ac9491a89d26710f0f5e0a80e003004ee8a8824175ca972e6fc99354d5584bbbe139fc861766aa800e2a18640979f398e421775330a470175b17b4e335cd8f0e29184777ac185636f3f9d482060768584002343aa260f41c6f25c5fd8ad599066868416303342c20011a1d502874864861fccc3f5d634d058e010f0f15f80db41b39bcc043c7138cdf5f51527f36d52d7e31812e18e0e1e1e18163071d4e309c502297969610c4af8e269844926a0f777e6a7eac4da18309e6642a590ea1b53721a9c6dadbf8e0251872a86441f95a12d26a724a30ce4fda14f14f27d54c82797420c1f82bea25071d9f4ec5fad071044350cf11092a4a90df8d604ed1a5478f96fbe6a4a308a6ce26259d8aa076f5c2367410c1e861c4e517216774ea5e740cc11442cea3152d76ca2d4bd02104934a95e6d564769c488d0e1d4130c7121533b2e59ce3b36573e80082b12ac6071ff57ac2439258213a7e608a9d8492d9fe8a7caad436b8f0f020f6611b880e1f18d447f47fc7fa5356730f0ce2a942a57c499bafc63c3047c822c67284a9b2c80ecc29fbe46025569e832e9fd0a103b3e7fc1232faa774e7e4c01cf793f3466a383084dcc93a25f5ff0df50d4ca9ca7476dc49133a6c60b29bd1f7afb14b538aa1a306660f22f9626db8458e7ea18306e6206b92a3ed857ee5ac858e1918420a7bd723c553493a6460d0f5c1f452ca1efb7d2c0cefb13be446fc8bc8c2c214b73d6ae7707e2987bcc27841ee5225a929617b579872aa3d15272e88e7a915e6d6cf9654e58ffb5cb3c21037437755ffa2e4945598ca3ebf8f885615a6cd946839e59c0f6aa258c82215a6cbbcb99c13ef0a59a0c274ebf6e154485b3e39a730c7ca4a4a23ec1b3958604c61f0109552ca1f254afea5308ff04ff18d70fe1eaab19611c88214a6109479ce3e7d7a71bf1b4116a330e58e7b1a4134925b4a8d355118c54f951eb57f2af13d01b2c1c586c270e2262d9bb4acd0528db58f0485215e4acac38ea8c6da65208b4f18546d3dcd495acff2d558bb40169e3065ae97764f1225bcacb1c614c8a21346fd9113ec52a6fd7d1865c1095359fc4fe2d69ddb6235d69c8bd37622c86213a65431d789fb6ec9ae1aab09e3ed44f5b62dd3fba61a6ba90b1ba78b2f361326bf8a1f275d5f5ca45a70234762c26041a50b2b571344446aacb5e0460eb2812c2e61fa9c3e2e2ad5d60879324b98455987b058c23ec4a2812c2a6108b2697fa6b273ccd696035950c22074ec7394093126ea933086850bd1ba6a24ae92306beaa591266143422261bcb738a2539daac41224cca2428c70df0f6a52e711a6ab18177cf257bec91106d331e4771aedf183dd0893f214e18410c16cd28c30e78f9dae5f21f5b96511e65329fb9cc9274f9e2ac238ee3da3edb7f2fc441862a7a0ec65e554658908c366cdac8dc9da499243982cce9ccd07194bdd19c2b0ef49cbe6c2e4d9ad1006d51ac22d564ce6a93c3c70b8172dc8714701107c0400085910c214a367e4d6764b8a21b40fbb2c0661bc783d31fa395996bc200c49de09f123b1cc4e0d8461ce65948e8a1ff40f0863a898dc172d79c59559fcc1fc1366accc52fe3c310b3f185fd2986f044bd9c9f7c1105b2f2595a4d3635e0f0f3164c107b3af873455d11e4c41c8d1f1e446bf4bab078369dddffd8fe855963c184eb52b5be8feed13c18361bbf3fa95f60ee6ca932d9cecb0371766610753aa121242aace33f70c1059d4c1d439e88837fbe5a9743a1826c6554ab24d5cead11c8c6f66a3abd255e4242407d39aa5aca7a7d42774e2605c0f7796173a7030ae99d9870bf274c4ce1b4c25cbb446abf55da5dd602c714b4145a9ba384b1b0c1bdb299dc50a1bcced3b22ffd55e94145d83b14ee48aa74feab35435183f452a593339c8b7d360cc095ff91192a48b241a4cf9447eca10e6198c6ddaaf636c9abf04cd608aee22eb352c9a50aa2a64510693ba1b212f7e4f0653ccb17062d26ca6c8c76036212df34b2589c17429a87e1ded15742585c190d3d6efa4ead494243098b33e77309bcf174cd9c4a28a27715e757bc190824a3255933f7ba574c1ec7f9def42902729cb5c30968e6f2642b21ecf780b86a81f2584b0ea13e3d582694dad72fcceaa77370b463951a5f379b29b5ab1601cd5599613a24d4af30aa6b0fd59478d6905934cf68f3b4a8ee79454c1b835794d7627557d122a98ceab3f2b9a369192640aa63d75bd5f4ac63d77523056866817f92267b68bc2b1c32585d1eba0603cad94ee53e8cc0bb227183e4e9e30fa932cf79813b4b2cf394284ad09c66d131e572a74d29d09269d3e2c89c6e5d32fc1b027df4dbd64cd1229c12446477f3ea1524c4b12cca9a76a5fb3c2642498365436cbda826b5716904216473075e990f354e794e36a239846082d22d4cbcd7f8a60d056ada0e324f5e7b03040430b1a75011a1690000d2ebc40c1166a4430afa7d8b6cfebaa1492c30607ee3e90c5108c3732d64dc7ee3295f5f01082498e65af74a3ab1e4e48c82208c68cd1d9a16a9ea51d0f0f0058210b2018eed273ec4bf331e12106b2f881219ad6aca4e2f4f42a3e30778970abafb6d037d758c3f1e1c517391cc771163d3077deceb58dce4ab68d1c669b050f4ce13f7f6d9b8b0ed9da813925fd6b5e39393e6f4ac84207a6246e23f3126543c63930e851973c6f527d4bd60b59e0c064f5a542b05c69a7a31b18b4424f87da883a216f210b1b98438e962bfa05a5b4493c90450dccdf9d45c4cef7d1b28d42163430880ba7d353d6f0ad9c8442163330c44b5de92da84f56a2608b1b5e98690bb2908131c3b5d4d743462ad5be102316a620d1935cb45426b65b2ec480854925c7d3f5ab6b4ac5f415860b2a26bab64711f95d61cacd4a4a08f1126df256182396f8925e49cd66b816831506959c4e091d4ebfa4508d3557c1163752a22ebe78d2858d2db640018e5e0189b10ab3255dd3adf5d5afcb3eec0f315461ba3c2b39ba92f2a7570b1a34b4a0a1050d2d68380a9a021e1e681f568718a930867c864ef19239f10dff40157cd8c8f171e3867f78d12858bb618018a8307f2775dac6235e7ec8294ca2d627a414e6bd448708314c618813d383e4b7fc214f928518a530a88dacc84ff13c7c0e298ceb4195cf8fdd859895e9284cfea984509d5fc4a5105198a49afe05a11e4e3ccf408c50985c4b948c999d94da9a82c21c44d0cad974fc42d0ca270cda542cff7896212fa29e30c514d33457b7c61a0bbee80f1c5be017313a71c8a6ad478f87306d08313861cc104965dc566aacbd9f0b000e626cc23cbaaccf36de1aeb802e2ae0e161ae88a10963eca7c8eecec494adc69a2f51c19503c4c88429eb7b4ae1930af3c13a25c4c084b13be7e87ac1930c317b78e4c0b105171e1e1f312e61d4f6bb0a8babae33046258c2786f229ef77fc66a8f5109b39a9a4e5ac3ccbc932861d0e72762446848b10b8e2d100bdc930d0a4cc210627f98999af02177bab0b1c547310ec4908461562b89bc7d593ad901312261300db38ed725499bb68504562161160f13df7212de1344ec1e508256805a0e1c5b70413a10e311a6bc2345655bc8b11c2a00f010c311c61f75df31ae5de72a1f311a6150dfeb104ae9deab1703311861fe523e267f2b4a387b11a6ee7c29fdc65c6dcd0f1c5b281b6228c2a49f133f8450d7d93e0163b06b542449d1830c311823a41c429a2d7d1f2936920d1961309d460e22d7c608e1078e2dccc820030ce6141d11f4b94ef81a71f105938c116df11452e507820c2f18fbeed674f67f4f3b5d156474c138f21e724bbbc3f7cc05639cf7288b2d5241c6164c414372f658bb5acb6ac1706739548a3769cb436464c1b43d49697dcfb7a17a1958308f34ede929ea46907105e39c1c5da645a78ecd56307c96be28afff6cc184b6c8d1393290041955c827b5d5cdfc766190410563ffc80e1d65259ca59ce046a3c06f988c2998d74cf252302421dac3bccf838a7714cc637fb1f6c2733e8f0d20030a86744a6a990433e1697f8239ccc5eb15a1ca3b742798723aa19d3dcb92ce5213cc7d715c46a911b1549860b48ab5adeb4b1eb46709c6ff5db7121f3c5ebc4a30e7d332d5ac78398ff20b2f92606ecf2d39c6073569511948309e8e246549e49bbf1a20e308a68b37799b2ef2846f04e36f4bfe2c7f8b6711ccffb13e92ea49189d08269d3121f2c63f04839c5d8a13a24230574e9ffbd485ad6406c1a0276a9927395a8940306d9747f8c85eeafc812927a1b4cec49095d8fbc06413a4a48b1727e1ef81219dcd5dbe9ede34f1c0785abd25f72ca47c7660d8fdfe55af9589b60e0c96a735442cadbf951c18e4ab465c9771604a29172e37b981a9cf45b72d5be77236305a4842a5ebce6b60aabbb3b3f78ff697cba081e9f63c47ca5f19e272193330859a9d9e58c182da65c8c06842627c7e512c0a69a74aecd30916862065724e69a7571873d5b63582d29bbf2b8cabd7a9b5a6e4b8a91506a5ea2fc590eb131756989359a7ca4dd6d3d9559824971e95f2f9a4e0aac294525a8b7ab721ac4d8551542f5c695d2935418539dae81021a354c7083a85c9545a5c9e780c292253985b2624a16c4f98cea15298f2670f2aa69228f9218571ad757f3b72eedca3309f49cb232f8bc2581d3af2e321556c4361bed355ca666ebfce939fc87e9e13b3f309c3856cb933e2d7f9c713a620d16f27db9d30f78ccae1479eb4b339611c3f933549ba095376bf2d9de029775213a648e17c6e24ebca9809b3cc5c7a8753553a870973d4eaa4bb737d0973c8a7ce5a2679b4ad2d61ce96ee44c5889c9b75254c7b41b99d122bb25953829cd47d98e92761cafe9096462d4f58256110d671a2e935ad279648182bc951dbda175b59818441ebe8d121afe7cbfe11e638aa6639976fbec511e6942645e5c4c8e26a238c9246a5b1b29326228c305f2e616245a87b087911865827743eed5811e68bebd039f57d3e281106af78ed517911612e4bfd126631b6c73d8439480c15a1d22d4eb88630453c3121d9a38414dc42984c77c87b77a5d7c32584a9e4984ad162e5e4dc0ec2143a65975feb69782b08e3e7efa7916d0361cad0102994a97aef0161d0b19444134a5abdfe07e3cec4cb0e29723ec90f66391d7eef7592eeba0fc60b25d5bc2f760a5a3e187e2e74a5e0374a64750f6611a52d29554e4f52d583c1c7bc52ce97e6c16012827e7d13d5764a3c18fd4556843e1d3f72f20ee61aa5ef2ccd6907e3e98513b93baad696753097ee7ca53da659793a18b4a50a573274b2d8cfc1ac716159576ff1477230d7249b5119119205c5c168a64ca8fcb1a363070e86fbb871153335b6bec1f8c1e3578a923b65d50da65c7a674ae9ae0a4ad20643caf993bd7472b6246c30ad5bb8e59b4ee126640de69a942729495e0de65441271db75fe43f9206530e42a913d16bdb7244835135d3eb3ad8095bf10c8637a1bbbd3da2f58666309bb4d116452b8341a8532989d1cb7e2a2483c1cbd446b8f14aed8fc1bcd75eb27ff296c4c560d24baea5544da91c0a83b92be8d23679bd94c0601ad393e2cdb466eb2f9845ad83c872ab1cd50be62de91ff183e75eba601053ad8b13b96098a0a4e54bb9db82415bdcee24cf23f93a2d18f5ec27dd5e9705d3e44fada15d39873c164c5db2464e5e8d35f915cc296f217dac3d9492158cfa15b154073597ee2a98e6d449b5f8ad242e5430b7685321f2650a06bd9552ca69a1cf220573300f3337d9a260b0f568d95c8382d962786544b9f330da134c41c48f7d2a6d04cb9913ccde25545b5049c653d60443d637cfbf9ebd6f6782c97eb4ab5eec4e3f5982e9edcb7427794ac98812cc27d62992b44f72912418336d6fd5ec73f61009261521a84d2b1dc13c5acc549424a22719c16ca67eafcbdd4254044390977366d224c98c08061d41ac7efcda11a91a8239e6c4ea24a2e71195178221659985e510776196060c2008e6fdcea346628dfd2801c15c39e4fa32747ed07d095d42dfd828aff8c0246fe16ff969db43ac0703e8814196840927c663a97d82ce417630001eb8225a3d5ef54d773430801d68413582ba3ef5531778662e18800ecc152c7f0ab2b4f7d44bc630801c1854687c9e5c153d49968401e0c060276458fefd907be1220ce006a5a553594e8c906766060660039365b913ff3c9e44258930801a18238e4cb83c5e0106400383b6163f378b1eb4245be011c0f5a251d00511c2006660f814b157d953ae08fb00646098d892b3e85d64b13716e652da7c929cbd4ab1030b738510c2bbea5252b3fc6f91f6bae315e6385b11827b52f1f3b7f3b000d0a0c315469dd176399c9599b66ed8c0f131015c0f74b4c2a04ce850b245e67b973a58619e1ba533f12ec9885b598549479f12c24e52d05176a14315a66842c768951f9dac4d854962a90baf734ad829e585a10315e42c3eda6ada276d5c1a10011a5ad0708087470bfc0486868e5318d2861a5f516df9c46f0a73e84fe91e762d8579cf65ec53ae3c499f5ce8208561a4f5a5edbc7aa98238bcd822070e2fb6c8310ab3e9edeb1055e31f3f36d217386ca42f7088c2f09f3b848e3bcac1c51625c8c1c516250885d9b3529061a7ce521a14a65425b98298c849253f61dcb1742aa9cb4a2192c40a1d9e30ae6556d76aa5147fd40953ecee70499b862ccb55a18313a64b6da9fb713d04d111063c3cd00d12746cc22827a731c2df83ce1a0f0fe42cf0227468c2149a963aeced99484c18ae3ae4ab8aa2924aacb1f6710963f5966ecd975029a325cca6e47ad2a66b47e95f09730cd36952ca497815d558434a943aaec4728667cb4551cb4fea63b44e5de77f564e051d93309879b614725ee949649230e812b2fa431821b1bb8c844977c88927c47dd01ff6a00312c611b1b3b7a542627798071d5af8cd9fb7c311c6399d45ed9aaf97bd1d8d30fb8cc821653f31c290e298bc93ba16473bad60e8588421a94b48563271f72b1d8a30c7b3fc20b612ce4247228c1d45f4e6a868a3bbef408471648a3839d96bd9e24a42c7210c3f5252929b9763fa39011a5a78785c87210c9ee22eff25154eda1d8530bf5e24ed22272f84141a5a94a183100629a3a346ec5bcad5a20047afc0c30305387a056410c69c18395cfecaa7a60bc22841b74cfef4d1d080046804c2ace2b936449dd5870410a6ce1dd15ab1c6d5f407d3c8fe68932bc70fe61479da4542fa60ec0fdda253ed7c307827a184b49c4e5edb7b30c90cdd2e916b7e62ebc174f9913b87388d3cca3c184fdcc9951362c2e50c0fe6dc503a6cab750753a40bea2145b285f8d9c1ec21ea46f588141d3b753005a9262aa2891d7430d8c955cea542e660d4d3d972b59a6e179283219e69b7bf98f99cd7389827ce5d7b4a952d7fdc0107a3f587d0e9fbeb7883d15484f82f67ca725248e87083a9b3b9c90921049316521d6d306b4891756a724e1c42071b8c23f4b9a4fecdfd0ad0b10673be7b48296adea7c4c343081d6a30da450e56b9fbc34b5a63cd16e0e19106537ebdcf16561ae72b1acc957209f510cf3f6ed6582b868b2f7038063c024320c0118c1dce577eb535ac7335d60a4d312010c008e6740bd1907d93f6322305018a70acdf9b134135d66a060420827962c65c14496241da359653172671f1858d1a19f0f050f3d3c7120438a4d1129773dcf25e40002130d97ce7b2778a1408100453c4c9aaa7957b963c35d63e706c0104536ddaa6c80b277bb25c70f1c59fa96941801f3cfa6dd573f09c6404475a00f5cb81003e58b4859121ba3dc90e6d81a38b2d6e786a77400e82003d30083d96a654fdae530a1608c003e3a57e1aa154ce65fadf81c94d52c8d949d781396c7c85b86f93accd81d192d01b42c6a4981207c648f941282182b211961b18dd2dc6842023cdc93420800dcc791d22972c754ab849011e1e384a170850037396c7fbe42b42bf9b6860b0da89faa193e9f119025120c00c8cd9a7eb525b3dbe3402c8c09456d2c5504ad5079dcd8885416b4cb58734a977e219b028686f31939fa4bbaf4862c7965ac4b4f60a2965862b4c25f94cac3a74098b7e71c38b3b2d683c400b0f8f1b284001eb0f66b4c2f82571acebc4f6c7ae3061062bcc15752429d5a37b3f5aab30e5709e52b2bce7742f0933546130ad8ff73948b7a4c244c28c5498f75dc38490ab919e438419a830887deed02927a475afc6da47b261a3041f38ba066f91805232cc3885299b8821c26e5e3efd1a6be8c3b9485d740db4a1811c5b24bfa18587070540f0118055cc3085b94d564e720a95752a2508334a61906b5a5a1f7e56749881308314062df1bf54e5745d4af72fb8680e8cc2e0b1bb4327468a284cf1f65772b04fa1e357426150e2f4e99fb662300314a63065a1174f277ebe19f88451c6434fcd44519d843c61566f730d99e3cee884a93c5aa4582a48eaf2ac31274c17c73fd207314956ca26cc9dc27c5d8eb6260c3f6e41e57abd9f0433615a7f397539ed56ce1f264ca523a83c9d439f50e94b9854c6b8664d48726fb18429a730e51bebae61d14a183e68d16e71d348caabb1f6c10517fdb11f357278e18905332861b034361e33cf547d28d38c4918c485e420fcd4b6fe481286b5fa8c74fa481845a724f14cc84bd69119903049ed097f2ab47a9a6bc6238c59fa51aebb43f423331c611e376634228dab8f90bd749fb6c61ad96206238e9e949794d1293fc48b22331661d2f0d1c82ade9e29a24b6a62673b2dcab22bcc48844124c49b0da12d9de820c224fa41c49ed8ea0ef321cc21c4eab54a13dc3f8630c4cbfec82ba33aa46c214c6ace62d5fb87ff132184494e777bc8f191a3c8660cc210d4098f587922fea28d98210853e8f5f8c17357ce1c91dbc38c4098b48ce714237eefc68285198030e77fd3d5bc325d769236ccf883e95a457c7ffc770b397e30a62761f1473c7f64990d33fa60d6dd970f337a3e98c7a45c9e442d0d33f66010aea53c6bdbde776f01175e78d1650333f4606e13af1fff5973d619c18c3c9c2b54e9cb18dfc030030fa694ee1e543813415dbc83b1b453e70e9f676a5a543b98e5834417651e4f82e4f20e33ea609891d5ad20f3437b8c0ec64fe95325516225a56c0ea69ce3277a2521621e948339bcf7a99b7822c8ea92e461461c8cfefb123cd672bfc739cc80834967ad9cbbbbc68bf4e30c33de6090ba1ecdde34bb196e30674b2929a5f4a53af56a6983c1e44d8f7eaf173d6283a9e3e547ec3416ee396b30f5e82aaf48a5238d5a0d268b1fd352750d6d350d06b127d4d5040d0d660fb338a9973f652d04cc38c30c3318923e09162b46cee69d32185b82969482d0ea53693298743cb9fa57650ce6d8ad11f546e66973c56050ad7c51e24388d96130a5759ff0b62518f0ed9359f51232e30be6f7d98a97e45dde0fa9c20c2f98438ee36d2945081eda195d309a1097c9e15752fde68249bc24b595976405af6cc130b952c5113bd24ab45d70266668c160a2257e4e938967264f624616cc9b577e73dab31f52f81133b060b6d2f37e21be2e9a0d1b37881633ae7045b2deaaad9067d5580fd7c2bf7174b1013531ccb082d9459e4ade39fe96622412985105c3d749f556b1e449785430078b71b361af12664cc160da258267b887ba902fcc90825154e5d55139a419a5ce8882e146aa8d6da90e95d70c2898f7edf4c7c64497bf673cc174419fe9a0ea7f37c6194e308c9ae751e1cc53ec74130ceb26f6d7a2a9347799607ed32df12f397ef2dc8c2598cf530e167b7a12523843090613d367128c3aea3c7f98f03f2b418229ce4d90f5249a71046368b5af390bd2427f8c60ace4d9a9ae7253f45904f38f989f50a7afa31f36127f31830886e855317b524b3afd0fc1204baa8948faa6d46f2118a4e4594f25bb73c26843051f36d2e69811049376f80f6159cbb72540306957123331e5a5c4f603c38b49d28bab3835a98fd445670e66f8c028294e6be59ce6b39e7a60d059462387d1f4d12e0f0cd73a314bed8a4e4ed948773698b103f39f8e45d62b91b4bd3a3049d9bdd0c9ddea7fcd81415d794ed73d75ea331c184e828c982af777756f6010bb11271baa849cd00606f3db53e9f35ba5e86aac7dd8486506336a60320b0f6926b95a142d0d4c6aae22da08f5fce799310383eeb0ac9c77a13b5f3364601259fd2c87285af9cc5818bc732e1fd7de6ef5790d3260610e336184901ecb40c62b4cb51a6af53f25774bb36980d440862bcce1d923495e6798c4c8b6c2f4162dc952ff64a6a2066e68218315a6decbf5679ea6626833a0058d08d4c0d10ee0f3a25180850220f878808c5518649f24990f931a6bfa0719aa307eb07c75a227e1625f63ad0aa981a36b905418dcde372ec70e16b373c3c6ef7d51010f8f1a38da013570740d09f8163734208174c3e3865742062acca2557a45c9ca2c55d758ebc286c93885d9920841a514bf7462de43c830852958b63f616b6ed9ef52987bb393474ba9d4682e831406e9177ca2ac6d895491310a43eaa0b46acd9808f9230219a23028eb683149e8b32482a130dfc5ea4f3c29aab2ffa10419a030041b4941ded7d3e4e41326eded53ffd6371bb9278c92fd846a9b14d13ea9138611caca7276b9cb71e38449e4544984d39d4d94d3bd7388b264d5adba0c4d182fe4c497efece51241cd8439f6e9a03bdba6cb24e5c9c084b92ce7afec98923c65370d322e61f034d244551239794e3901f21a5ae04186250c415b2bcb8b76391369250c7a4f9ed74bb4d0e651c298a15ea2a85c8892a449983bdeaafd841589b949c2a4567e31c5437b1991309fc895b311ae23d117820c48184b5cc9d1e6e31e43081f619c147bbb43a538c21467fc83887b712bc55690d108a3e58ab6f9113a5e486284a93a8c2ab91c3ac8b86f0a321661c86ef292ac07f3b858086428c2242c94fc7c0a41fd53321261b820395775fa3071224106228c1727e976bcec9e2dafb156ba90710893c5d0115e2d5d3ccb8d761c1f072d20c310c64e592f7a59b6c46cb990510873c81d2689d029abc70961f8339dd5889eab84103918c81884b1439cd50fe5b1c2bd9a2a9021088396edcbba957e3ccc390619813029b1772d3934d34c650908a3e8ac9dd35a589c5f760b32fe604a26f258a7dbfc60aa0f594aff6ca873530b32fa60c8dad1d2980ef3c1202c8eea76d0f649d92bc8d883e1e36513225c8a5631f221430f26257f2e6c6e555b8c0332f260cef693e38308614cecd9041978305ed6f3964b09a2fdc30419773029bbbf102c9a0aca4576300839313546e6a9520b7274f1059aae40461d4c215a58cde94ff16cd3c12444ecadea8fde1964ccc1a0bba154a7c98a8fca0153461ccc167496cfeddde229d37c830c38987b25560ad59fb3dcf806e3b9beaec7d3718351444e7a4433de93966d30d74f7a75ef9c9316b1c041061bcca2f4baa9f5f7e764ca32c858833174e4cfe78e3ce2924e95c544728f3a4a83597d3f9dbd550e6a3b1a8c9a753a9728ff0cbdcf600a71d1d76fa10bc8308339766ad3dff1fdf288cb601a3917226ad4ba332383e1e4255987ec1faedf1a6b1f3612a640468d87a8449165d2581c0a8542a130280c8360f97514c3130000000c1e144763f1589e29bbb20114000442343056343c1a261e141c180d04e3703014068403623028100883c1a04028748ea6700c8b0f2515e935d557e99e1353aeb200d9fcc6754ce80c44c8119e6eca14f2955f0f1c331dc4d506d130fd1664da9c86913a19b432400ec18bb911457805b235891c4adeb651768091eab5d77e70eb293d81c4e3c2663444d433d431c64abd4c5e2ac4d1c74d6a65fd83cc3375796e80d929b7b27a360695d2efaa2e71a4927e3b85bf4b25079595fbd2e12d5ce34315756e9604bdbcf2447447949e31e3d015327d4ce6ff8eec4b19a3a68e3a2824240fec1a0c4a29cd8fb6e60e69df702c238fdf5a221c2e4854653009cfbb492309094f03eaf9fe9a44aef6c32dd154193276cd51fd88a713bc8bbb72614d62280f0dcb61821b33646137b0ed5c93179a1cec5d49039ba3d9b0fda804b3e9f375fff67495c531f413d2479b2969aceb4e308b44c3595f73e813bb039d68c5d33d15d074468af96cdc2007853353c5e872a516d2328d89ebea6ff34492bfb54746e9263e4f46a88595c6eb656166e4b4ff48995183760f133699db9bd3f91713e84bb02dc6f0280d3e028b4cb443aae45f1c59f868e386af9883444a0c3313163316ca65789f5ea051f15275dba98b19f039901ed51a26979dcee3cc0057f7ce0115f98c7c50561c4c70dd3a131d688e4dc0c8dbf95b9318d566b8c1a7f13a1820aad3e997bddc246f0501819d6dbe2124d360abe4e6f8b9d368b0e6c9650340fa75193d3f6165c390a5645f63a4630ccf23d0e988b646e2c50832237d45d706f09fd133460c2820c85317b4b310e3f2236f200911d6195baf9b946e95aec8046f4bc1f070cb369f9d994f47d747526de2682ce100b47127ff8a3d2a827fdb6947e9232edde09dc9d118655613024789b870a8c4c4a9023cfda92f006b7e5c2e9d26fce8d3531917d86936c09666eeb5d85105f5d96a1285d0cdc6088b5a9ce6545550fc62a55a82a94c5285fea0553886d36acb8394807da585bc695904589de91399533c582c41d09282f086e43284ed66f127a2d58407d58c66b9c3921c44d3fcd24a15ae568a5ebe6f550257005784a41641645c8feea284388cb28047a9670165e2f8fb11a03a18ace39a114bd716a330bd6276af016d6933466fd716a0dcb83e56b4553be0fa08563cc701c9322b365491d6fe6e067f4ba7832e5027bb66a42fbf982ccc6768fc7dc748ef8e74372037cd9c2e33969a5a8ba4340cca6fee1aac57efee90f26fbc8d5fed521609bde34a2c38edbe02fea1995c710f46cd8926f3ee054665cdef666013642696a1346dce3d9b935fa5dd876d522b5059bc58d8f7019d0b133494c18577e1ade092c4b7e1b12250b93e882fcc097e2ae27503b3d2c0545f0c15adc5328f93e951e631230d6579f7ee5aa358ed8e6ebb9f50ef288a543c45723ff414f08891a6362b4a7c585477a951373813a589b3513eb6ddff4d1dc76fbea8e4b03563d4f4bf6943bedc84aeb862c66254a72fc70a4f997d631840619285488e43d4e4b0618555bf6ff7993cd9c8e83d4507d42df8ac79ecbe7cf2cd1c8d51ef005c319d1b591c3dcaedeee1909129f14831e8e934bd575423155c6daca0b333ac0a6288eff7190aa94d26df0fdcf706f610be82a7eb81c69d36165f0f97435d6808c0b1cb38c91ef6680f65f2e8219ef2f12c2412c80db41909203cb5da2bf76d21f0a6edf92ef1be0a0dc7415ae763989a43686280f82c90a64bafda406d829e67911fbce7e50f8c9d9e4886e2a7f0ae954326d3c32b98d18ea3780d645642a76850a5eb633d09e8062181b846d2463553631a11bde2cb0b24489d5c41f0e67fb1e1e37159e99ea2a66f93fdec382ed9b60121641223d50946ac1edcf085e577a3607d2305510bc6127b38b6ce897021a09a554ad83c3d3d47a05f281ba95037af91c7229f145b624c8e36600b5adef16bcfb3e1760774c91ec83d9675d492ff9d7f424f813ec8f343d935f6c7aa7cfc9c9ad4a26408f147452bee24bf1154bc1421e669da917700f30d08c8414dc3d346bba0a73dd70d13a03c2c17d109ed09a71b79f24fdb04b7e9f589a33452ea6200b3c60c75e108fb01d33f2326022f2babacee5cdd3a9dcd48a8142f5dbb74c2bae7f146779f26c070527dadc04e5142a12d06ac44d69c68bf20ab902b3411ca990c250ab4a8295f5cc92e01c46c6f8313e0730889f94103c04a271a1a9668810665cbd920688daa2ab0ac9089d20193eca01b8c49e910e2df46f68e6512ad5385b1363d016da0c30f6def5453d35149ea2f30c5454043b06f36702f4f07841ed2c652a2d80f84f250e051e9685d1b9bf4710af4ddd3b1d58fa546fbb26549d5cff4339a3fe2537e46cd1a727a1f3f31cace2767cf447b6a6c2b2cd19c2803d01efa9f731c22a779f5235b4e70027e715161c209e23408ee15fe61c60367185730afa1e881b4be630e3034af70f8f12a7a902977fa47676b95d68889364acb145d639177c06c402624e91f0de01b5dc7d81f6f3157d71c7eaa54ed09b7247420260af12fa8d1892c80b00edbbf50cff96ad8f070f160ba02ccb6cdc5422419fe282f4a314fc05b20ce8d96f4f17d56882b6ebf66059e8d107135521051db202c099b7307e57c67fdc9b27b44e03c49d1c0c37b7104c0a645017d4c3bbf39d81951e3fd03ba90de3ac1ec34e460461009e16a010e9b2fbf61e8843fea3b97269bd44ddcfcef2e4f50978aede1bcb4735261489dcb44ede40c69ab926d5ab441563a5cb5cd513c0f480d8247ae1b730a9ca315ebd32be660f6efd4c762259ef8d71dd7b3c4ccd7b401479be91147834f9d154b8f4bfd1783a4174d4dbe951736a5e4549c86cf4313a4b6b52a8645720a692995df1f2ddafc3fca341e4ef76ba08b57f15a397087c02db6ab1caa3c75426fd433828c9d4dff765c57a22196fac2487ea9d1ec49c876ce273a353ff85278af8ab87510bd80ccd5a2a3672c6a1cb965cc4b0ace8757a1d06370430b48829dc1d645c47c30e91d02628f193ebaaaeedfc51f1bda6474eadade3e208cee33da6295565679256c4d188b64fd6f31b0614a508f9efe35e025317eac65e6f1b12ff2ace24a92b0a39e8e280de735f5e47a8ea2a9cd582c7c9f913def21a62c0d9708ac19216f7f90ec15018c5730f95e1f3b416bff1787514842ab6e6242c89073f69b261dd381c169785b0928962393eb211141e728da5a1147b02fdc6cf000f60b8adde605862ca16e03b1bf6e64e4f14ce7584274415967a248abb91498aad5e26818ae60c8a3985822946614154bf53ec087e4a9f42de02d4853b0b5020a2650ef0c9a8866091ddb41163b0f292e0dfa48426251b06f839e40f4b681606e5e4991057489c916c23a1a10f111120ab4a0eea4af2f70dddbfec18ac75d8058ad40d59ef704ab045c8e0506e67794163844b9efd8016364da9804ac9febbadd75aff27748af82661223f915301a21dcc370238d0a602024bd1fd430247b53534b3682fc35b9613ebe0830be262ba420825ba247918cb8c481a0ee359042660b38e7d2380f61c534dd182473045b738b3bd88d0f7cee823bf926103a40ecf63ea4bd14bba392e0725d3e2de186a6ed7d2dd18c0184147882d7d74f20a07f02b5e7c63e49b7d6586fc4b740f60a502dc94fd264c5691ed44e71655069eaa4c6a162a7f9d272abc898c52f2ad1c7f8a443fa2a18d66d8e95035cab372cb177a34618be41c976fec7648352223915586f21a5d968298ae628298b34cc729542169ad6216c156184b117d152582cd571ac306c5c6660a165f72e05a864c8b45e53dd71d6e8f2ead82e65944f5b7e0a3d16f1b608bb280a4b308d129e041a9c05d1260d01661bba70b3bd1596006a0c0e61dce18377031308211085a10ce0fff7f2d175e34669d839a773b2ee70f4e5ac544f1096d2479c1c3d1e8a42363e4511da8a34528dcd5a5986636ac1f1e55b5597d2fb1c7e13d4884e80a663246dba34bad54f32c81aa4d1a664651e8ab850c73c754189b59218b021d5a99db2c9cfd4eda91acac26cab18ad5c587f90ea981b8b1105e91d4b568ba85fbeee8fa609f2542566d22726436032c6f448b381725f00d7f6da63a51e2e5bb3f2080587eb64acd05a38f7b5faa830ccf81e6d83f6050098080b0a6e49c80709e02b988b6e97c2361c40a28eb5bc1f3cc321f7b2dcfd0d10510144060a3d04a1375e0e0825c87bfc2fc3cad2be668e87590abb907db333a2fc263766775c14e4c38ac3f41d5effc1410dcf315b1eece3416c9780ee738e6d0855aeffe1097e9329fc55d3e9ca9087c6df6b80a17e541c786e827099ce4b58a149e602dc906d8922365610ddb843ae98151c14a236db415ee677135d1b7075275f7097a2c7db3723e3d758d21e5462c54bf262b17e835eb50eb854909cddb05de2a3a42e75a28776ce6f754706652b4c3cefe11a91deb97fe26dd998a738d10a1fcfa3090139df3e1792db3d3792fa1a799d5734fe19a0ed81c15a46af7498e80f9e7f4dc8631d6f358b4fb7ce6d8ef496d391fab6b460156a256ac6030b05a1b43bfa89002589276a70e0e265de40dc84a84e5c84865a088ac1bee1ec06abf228b313a4ebfbbf9dcf8943699c0804b3d9fd09db19451f95616d378139a8d9e406c494208525791223aeb81cf08efd360eae8862706d403ae2817bbfe4490fc935d1bb4936a7d0c9544246d4d18beb20606739bb92e84044a44f27a1510d425446305293c1ae2b314d6feffc1b34a3638c94be379af27d12542d4045a5dfb6c7b559947740d5a75e6c831d8220cd4cf8a7e00e3812dd86d3fffdd6d5fe91cdcc08177ebd8e7c15948781be697d412d29e519ede69afd26dbe7d7d40ab6ba565eea80e62448f634b9b4d3ec6d36086214007381ce5e45158e66f6c7617970635580749fbe6003ee96cc3aa74de57ea131aca128ed9258365d8c49e1ee9bebad8baea4ea045a1dd445eb9aa551bff1f35282303aaab55f3159c040cf6999ccc99b2c93d965f3a952315162c2efaeb5d8ba5ab5142e77a35ed59e91f440cfe965d6baa7c729cf219e87ddcea44aab19f5662da7aea85642e55cae1cac810e8ce49c94c99ccc2dc588be5b20033a670bad09ea292df6aed65a28001fb8419a0bfa913f9782bba69d9c96ee5889373a889929155af5a87cd6e6dc1f13309c0064880edea01dda712c0691a2bcdc7a8dd32fd9d35ca9da2a44f5592f67f7b44a519e663a2d9c5b17032bd5cdbeaa0d0a7d36e035512c2eb62b309c35cd4b9408d1eb36395c47f42b69baa83781988d9f9af68c9693d0a2cfb19685467f9358aec464b1a400e3e90b4d15b63f6c618fb20b0e7bfca8b3d223538cbe49551a50f524d8696eaa54bdecccda325b59721ad7040b6dbd9576c28307109f07c6a45f02ada4021f4c27c70ad3fdd457f540fcd71ed041b90b96e85629e021e26b91fb357836a29e1b315ff8a662ceaa88cbc2dae08ab4cab5781264a89cf863656dd54a781afef003aff17b00b649223c61b3fc4ed93210d4083df7f2054ad5f8916a11250776bb474afcde8070a03ac3ab4642a82fd0d8b21d44f9e76c5f7b4306a0afba43828c8f86006948b2a39793e2c5fb67cd36e357a3ffaa4b5257f13d519c84c7e16c014db804ae7b16153b2ab5159a22ee0a8e47d2fcdc0c58a6f5bf55b235a4d367064e0e4dc820982ec17c53e9e09d18cea18a9b89ed4cc921459958cc60da9cd53225ff0e63ed03076fc4a041e6dc7b4e4a14fac99986f362dd8951d8eb7b95d7a28611de36663c2ebd3653358ca005f881c3d9897f0a16e74072eacd5f118d9b2a5efdb9b7b9e891cc2303021a86e3a6c8a1e43f0838d29c226cf57ff04dec33e016d6a36252c36ea35849c8b21a9763f5cfa7921011dab0f91be0ad109e2b39683674bf07674f3dad160c776503f680490ccbce93eb4cfde05655613ba1a611f364a06e2c4a0adef6d9cb79d12ba577a44d7295a8af828c9cc08b0db413592262d83227468524b572695a32bb50bb6910c25f221d1e459e6ed04a760fa838d2590b68433940f58691bdd1f17e25022389e0ea0ca70c8f94b603dae629bccf5a3dd7fafa071d093a0b6d97fc204a4c3ff45e90b1cab00874ad7d756880c480951be64e1ebaca40f0d107a5da0f1d81d059d59379131bb2288c1dcc769827490f4395a5248b4d40e0a1738c6c7df960866c8818bf2f167307a65a474d0e4e7f121d42dae258bd8e368c5f2520a4508a530495d3ac908ef6073ff0c535069c532deb887e8605b2867889a39b28730467b1df045fe000e47e3989990ba1981973806ad4085165a4bc1593924bf2b67ee49a022238f35b57b614c78c50f3931289fbcca9cdcb914d25302c994c1975870e2564a21ce049701d4afadc798e713ade09bd7411a40a316586aa3726e33c138cac22a532ee7c0a93fc9aff14bd712bc8ac13544d8efdfef2e7843779aae61ce72de0f97e7088bb782d4c6e9896a9a7632a536222338323a231b66e690cf92f64e8bbb466abee417ee2713178169814ce3f3cab878fa7828da4eb68c204976587778f0215358ff93d86c9f1da7f5c1a562049cc6a3435ba8543f69b84b781a58a98b04a45c9bf1f81e90db6a5a88153d7df27f23b4aa50662c433b04c5b20103079344120d91c52b119c1bb22f9100ef26cc7d746f92798e276ff8e7ca09fd068f4be423fbf992c0f99d10f7766b89b22c683c64dc34cc33b35d65871eb3f821d063403ed749c9bc0d400fea5c9ac30075cf431c69a462b1a7b219f68ba782255c7e683e988dea42343b4deada812efc2515b95025b3c5dfbd1e36217cb6fd280f0ea49fc22e81368b2a4fc6950ca1ead6c41c756b5cae6fda17481f4cd02a363b2c0518ccb650065be36a855cfb91c4d72196970e151c9429e25dae3d601bcbdea7a8468b85b3b2dfcd06e1a4d8f62a5f9ba3c8de9dd1429530265b37467ac74b3bd920d6b3e86f06b758f4fdc869a213da35b2971ae65609c05d6d6084e0d06e1c838a1dfeb6e0e9981011a7c0e427f88380cc0c2cacdd5752df7ad611a0f182d975ce17712a9cc292b30aa502c2ee3732fa41b2645d9eb76b7d081b0a24508b99c398440d7745229514a28e27a06002167b822982287535039c5f900163da00abc06453a610cbc71752de78db24f47e2841492a81119999032364964a5acf9aec81ee548df6ab3843717447163c286d6a084cfcd2b9f4dc1449111b2b9368afbc09e623171271f8f9ae165710844a9f0f6990e8a43c38f90d9b11560ca380ffe0eb9b59b411e0f65e1c8c6e28f2a1e8049692e181536899aa314129127804e3cbcbb56df21fd5be2c03c036039669bb355c3162a2d55eb00a0c9ee55fdc4e397f151504888d76721fb5d70e156d8a1258c6b39e6bf19bfb5130b57122f4b3b31b9d227e542b7e08768b3ddfc906067efb8909062ae0341bb0bad6e9bba5ed97ed8236beb408a1c2934f37a12f3feb891a1600f14ce07c2e6a83553293ff1441a2ad5e526a9a1cc1bfaa2e0a0097797cc20903967660c36109c602819029fc977350b10d505799971085720cb2c3d0cbb9cd37ba15ebeed57a3444fb18a2c4a10f80bd3b80240124d00086ba8f8576700a84c17239c5732c7a5725b5a22133aa23f7a9d9de905924c9c82c19adb4ea2c5575e61bc497c11f0c04cc23a32fa9a003cecc551d9ea042384a5f201ad5cadcae108a6f41aa960b032dbbaa1a7911ac62da0d819b7e744fa4ae22652b694bcd044772a323281d90205c5d5ee210a6b82251577c6ae0d70c99148ada5170d36751954b0bca23d7de4e8d8a033919278656d6e21f25c700041b0d6296e629f5bb8405c4ff6710ee00e56c1f7a4763b50ca5f061362ceef80e1904b2c69529064cc6b7c5c548fb3b64f259dacf03b36d9ddf5429993ae44100a51d35c2596505a5c040501a0f17751d00d8588369aac0cb8094d3e8b7ae995e87a88d9a3154c393762ef11323a406759431b868e3836867b8756c5dfefc509d8b75ba9614bb62e242becc15a7e25a13b623c0906d6a7a563835424a72c5f0f24e9e428b113c6901459832a3faa68543122575a27282e598e4acb2094be296b260f68461de88f59a22f600c0d4faaef59df66ba38876544c45fbcba2a6fca748dea1c57eb3c297f76d2004cd7a6d2b1001d19559189f29df22407539e9d4a396221bde703d8a83f2aa3c7650da8986bf9018711c782343210861750e0a1ba40ff641ee85635ca4642a6950fe3542eaa1fe3fd05ebee38f56d829c4bb9774623c4aaa54368ddc6509a01ed3334701e80e6774965fd7ab1199de4f99261b602e0d6549df6895d56053b1a492eefe45a0f23c9e58b5eb4af03fa7d6d9ef477a23754125a9b0a8e48f0253de535443e94eb0d9603118d0079697ab395ca1f16c9160c73600dc4bce18130aa31073abbcc1853ebabd656e8d6b432b42cd0597b70f674ca63111b6a2ce57ce8a60fe24597b02aa58fed7bdb80f5343cdfc92a225e8b02fb39eab7c6ef4e5f3cfbbef25b67bf053f58fa5fdab7c4ef565f2c7d4ffaa6a45f91a57df278f53447bbd75979c211925976126a1b251a27ffafa7fb836955d0e6f734b63f4ee894414c595b994e62f69f5dfc09093d7a5a1b410e66c398bc6f4b47a5a07eb14f0cef5a8ecc660f3f7dbc9226d7409b5368f9eff0b0b0c6bc9ccccb0347cf5c992bb49e631458b127ef44c6eb62acd7b203d62621f2d79834a481646816d50cf5669330dbb8d911dff6730373b8ff0674dbd82b6d95485bbf93ae338754ac7d72adc3897e2c41f29bc42a124704c92725e30bc7044937127d24963712a3a2929a8442e22bc9d625924d8c4625518955ca5383447c24aa2bed158073893be9c9b8b4a6a3edb07970af3dde535c082d078f661e3eeec771f892a7c89c475d1e2d3d08f5f8eb61d543aa87411eee95c77615349bc7c523a687821e1e3decf410cee3fd75b7ab207afcec71d68fed4d21c73a7b1fcb800ced88ae215601f185c8a9718ca8e8fea2304402136852e773ef5cc6dc38154709d11ba8328f2ef69ba23cd8f38e0917f7fa4d3b17ab02d6d936067d42722c0d223844530d6951c4dbaf4996653eef3684b379659624809d510afd6d024c57b6b4c4f39aa96ab5c3f991a6838adcf05bd98c7e00db019324c72d133e925ecab8105380e606e7c17f6d8a48295206ef1a84518b7de68e2e209810874e1c2343320a40f1b4dbc21222d3592f062ed80ae8c9a5e8611c534ddf0bacc3d815371278144dc15602ca81bca77d12b599654bb48d3530dfa0894c2a0cec0a33f31ce4b295491e9a716dd2b44043f846b544cc29aa5b420353b830475b0ad4b1d921f2742b8475a9a468637eb2c9724e430dd83247386e389c7a2d01701a0b6127b160a955e938c289cf05c7b3e2973a37ce871adbbdce2e1ab2114a9165a43179437663c6b010db77abcc2786499a1254e337a76a58360c54210ac9fc503d6965dd62437cf0db39b438b5e38219f22413635d0cd2dad7ebb4f8f680eafc362daa48e534991ee59ff25e409cc2097a5bccfdbdd82d9a0af8053c796d80d2482e28b3e47db119aaf2e005942160600ade7379ecacbb61b786d23e501ce9966c9715392a9d0c443b8730c07e787bab84968c58414d7026386141914f631fdbf871078f5baf3e6d6c3d48e16f255407b8e434084640a7c4716e1215323c2666ff88b68b6bd9b11a482cec660cb8586519420036266ed50e4a46870e6a49be064bb1b2fe617a189964cc13a7b6f55350c9e47a48efd563925ba6b746bf34499f85b1ff15f89f6e9148fd39c4839b8f5635a0226184a7aa63ee8d26ee9b4522bf0612846a6fa71cf5a4e7e95cb70bb944e8f0a2083ceed422ca8bf291d12eadd76a283194730311534b83d63c31940547b61049726078751186f9f6808515936e46c375436d78272173d80a20eb96efe242572ba38394724d3b7affe1894e34c4a46804be6ae3a2ab85007f400f4d00ab092d0c802ee0f9f1936b154aa37814cfa7de1542c0e2e67328d7387b3b7615ac044b68e4871e358000f4eeb2736a2abbb01501f26812c729f5cfc034b281e89c10709c5000e29e3ac5c4e65a59f09e34a7257560d1493dc1669ed86e005e7c7c2eed258ffa9cca61f7ae1d1cdb600b5bdb86d501c78206f056b279093c4bf34f53a9f7b40f8065ac623c7389285355f30ae06b429715bbe542a81fb1db278e316c68bd5818da16cd9d2ef063ba5026008fe0acc34c156710c480da7fb0e34668e5876c504a10e8fb7c4e6f07238189ee2d273f5b785ef929d876f94422645f08290457f9b1233676e2b6d51c6525448b06c9988d009923c72398bf297d971300f41a14f2951fdb95a06c4961c8ada0df257e68371bd16c010e43fdc3789c5f671e770f36a86440c45758b44034ff1b16454adf482ba65c0f93c26af075296796c02ff744904ef533db4090cd329522b2053bc24489a4ce527f9c783c227482d9110368caf03081ed464811e98626af381b718793196e6a3439e036c48d52360bec0432f046263ca3e706345dd7c283151ac431b06a5d9bb21278077bb5be32ad756c55b166646b427c3b6a6adad3b7dd5225b3b9af5a103a7d6e99d328fa5b986427b6484f5c5b1a92390a2607ae0a540a68a1f5e8d9193a4fd969267aa04b919c53642753ffe937704d27d1237467a8bb68d66c881de86f74dab694b0cc64ca809fe4a20bb3b4433a4e6be4a3e31d41d3fcac39078512da528f71927d7dc0494c51c15a490fdb2b8eb667cf9e5898d82f57384295f5aa0d761a55f0915048f53ada6d1515c04f93a579fa1d761a47a3639708c398914f465a8e4c3061367ad1368a6cb4da48f46070460b041ff58eb43d232355da918aeb9cc26f9cab1ccee9352a83eafc84869b782abf711c145aff6ce44d10b77ec1ef51193420ced8dfc141387e2c201fda4046f30455b2ab0ddb4036c4541a4a690e27247c29e9e5bd67e90c1627d3e7302ada05801bc118252935b9d6fd729c58552b9d376586f1308bfcccef22092febbd8ed82b390135e3154ea3e7e0fae5fb6a088f70c5c0f2f1d711ed60598fb8e9f5bd388644d7b493591821bcda8165c9ca8d95185676b71ace0a438e9585b482291764a89f3a65e8d499d080b48c851b94e44a410f8d8c0407daa6485209474185cb1711ee3a1cf3ea0dfc4645478157512e0433e4256a180698ce52c6e88255648aff76ee29943c60257aed1187b9a5be03a71ad645440c5c22a8a4542ea834f2f1362820b55135788acba4ba50956084a7ef114a81f87eea84e022f79cb9e30175a4804c444969a55df25710177434ea8a4fb48337c90f0dd289c71f3d0f00214229f0e9a381ce1d38bdef8056cd6e2a67e19850308a02b5743f285e818c56861ea407b2313bf1e9cdf8ab7193622de702fa0e09ee882b84e3c2c085d42f326fc4c423f783fb2a93b223540823bdf4f3762589803485210cdc40243ca219683c6a0a372b6b32ad5fcc174375c931adb1a6d58574d697e45a66fb79181559c8b71f816a90eaad50be42f3f741fdc7057f5e9544c8b8e4d94acda85b543398d3038c13f3de1697219b3407b3519b8d266024ecbcca858d4c3d2788c22b0ddb80641b18ed807b5081df10982f55b10c4cc49ea976c3cff91c73449f665d5134702930e091782ff2f88d7e5ad6582a0d0492edc0f9c3a52f57c00fb20f08e607104f2d0b7b96e92f97211632e90998c85d0fe722d2adb6524728f97f6802c85ea002f3b884379fdf4f23f8dadf5c0582ddce2ef23de637d3bcf6fe6e7b6b495e266b758f847d9d83dd179e38705a9ab87fd8fefb850bb4038a460987e2e52746597357b121ba6ece14ad9c14dcc082aa3d8a5320ec01bca340dc06cd1269c3bbf151efff71bd48901bed4d84905f411f3baf9166d0ab7cd4fb7fd40b20f4cac7bdf161bda88f355d7706d8eb7d4ceff8b8f11a2fb87a852037dce3d5c5bb25d156d5c92020d886c6b87290b213a4308548b3ba0cf6de6190751fc72032ad26acdd500fc1a720eaa4a762a274048c70c3b8cc2c3ed7b7deeeeffd78ffca3dbeb3f8ab9ab7579653a85aac3ff87e421a62fb19b6d99adf42cf146c9967a0e52381cd40bc2d0b75b7098c37d644725581eb609e8cc5c044ec81dd044c49389bf0a85165ff8a24e593f4fff04477fc0c5bb2de8c423ea20969dfc5d95a4db48b8a18bdcb601bc2a6d66c0700d63790155d884e9b4fbad5242e16906233635d2d8d453fef428faffac90deeb00840d88de0dc270024710739a621fc6ac206054925b84a81d3e89f10961b21482f37482a0fe20d0842ef222aca9c29825469a7d5bdf6bff881e13124dc0c6e5402750450015da19672fcc76340c634d8037cccb65a58caedaf501b047c3c69b794a256b5857c0881648784ef3e1517033a6d15e33111774898956608481597398027af7cab65075a5ea87f8909b13ee98a0cf1a40c443a51fa3c0bdb119a11815c7ca9f7ef86f13a1c6fb4c8038c7961c2320aeeb4e758895cab3cddece684873ad1cba72cd9aa3a40283c117722a0d197dfc71833ba3b1bb164a52f4fc7a1266b8a840937a33eb338f33360d475859b1d0dfff8dc3f88190fc4a014cb31b55748203c6ab6fca35a1b1e64c1a3eb2217454abf630c48495fadcf049f13e3306f652bfd225de84581b01bbee778bec44af16e551a87014bf6a1037c61f558233492dd320cabd87ea73802b3237cc792d2e520fd46380fc17e089cab21a84e3aec1e561646071b01731ed38f298e59c784c6a4625ac65c1123505716eb5e22e8ce81d03a7019465d22849273208a9b5b722f77bd37353bb48349da92b91bae90a610fa435d58f7b4ada1e16909c43de3fc97e094c3de8843355c5c101c60a0767679c823b7d6b3b7bde87ac1f262c0196de7c755e705b049e05096ca9a6cdeb141029844fe645fe976a0553c32ece269c82370576322f4ab1d4d8858dcdbef59f6e2ec0370d2ba9f39b8ae1e30766c2cae199eefd86c44759c75f43a2eeafc5fa4092f909c967278f689a8384cf8b0dd3e040fe03c2598811955d1301ebf2c6985e70ed978b83e131afa13c6af2b5cc25ec6e97733292be305b9a537430c2a6ccffcee4904c813933dfa228373af89f71aa0d6d216dc6d2ffff748a2bc0c527ddf106149a52584fbf05a780b8f179782300377280716d916ac67813ac52964e22bf1f453b7595487f3fc078e24c4f35cfac6c27ad708ccdab1bf84a8969bcb8243482399106f3b0a3d280e4187136b8e65811cf974eb94ab2fcd433aac47ddcb36e61d4c0f79f2cf17269290f1f3159e2f75b1f0dee813eca4021e89848e0b3660b46439330f0f0f0f0f0f0f0f8f3121b5b54f48424a524a4aabd75247e420a524a54c2989b7483b7a3a33f129a6c9de6498f8040402c20bc70b970ba529194ac5532a28a5c7a80127ee5f214f5a8e783a3168c07a4a297878ca32d5b663164c8ed729a9f85bf27ae3396c6c60c60ccf614305336698a143166c66448d9d4468e4d7c4823fedaff9a34760c189ee1077731c9d745baf489ecac9cdb74757703a42ca15730a19947dad605f82662425ace3dbc70acecdc3d44790ef216dabe0934a4a664a4e1e3cffaae0a444492b62a954b09a76a742aca8bd6799252a785bcb1d59a994498c769c82ffa484d211377595af29f83af9a33f9b8f1252540a6ee2a65df797284953527016f4925c3f4fdb3419052f2612c54f6645c1f9c5dc94dbaf34e8e0e1e80805abab13420e25bede9b147480824d136356ebd99fe0d4fd57f637992df6da800b68514ed0e1095ebb2477ddc43bc1c41c925f98162dbe419c603d922e696b494d66cf2698e469a1e67e5737d2046fcaf467d7f6c7c8e94c70494fd9e40ea57dbfc504aba5c77b83ada714d24b30392c55292d1ef27f8a25f8ad0c169e1daa76639560547559b885790a756180c60942072598bc41529c1c3ad4e23e6346c724b8b5f8e31b31eb3eac1a6934eaa6d021094ef848c8e1679d69523f414f60c60c2f3a22c1d786082a9a6b4ec999ea80049783526d2288fe11bc8ed021c7ecd31bb2c8118cd60ccbef49d4434f7e8398024e021d8de034e4dff43da943ca0d6211e86004abc12b8bcceb9e47c72c82efec5082418722d8efec7927294b29c9b023119cea94dd4bc6122ef22e0e175d74d1ef051765800e44f01526d3c4cfd095cf6c41c721ceebcba2eb4e372ae83004fb1ad2b43f3c2479ea1bdc51082e67e57491a5ec20042ba23db5ad8e490a5dc0050e1a9e6c98391737726cc720f00b49a530e5a2a26e0c3a04c1994ab595f54d67aadf11085627e5b2720b992de21d8060628d797b55a9945448c71f38a1ffa305b788ada1593fb06fb62629546366d3fbc05fafb7794bb0ccb4f9c07e8c6cb2d4b4072eaa78aa4efa3cbd5c3d30da79a2e7f4f595369a072ebf267597206944060f5c063d12ef2f596a767760b4268d3177ec16f5abc30e33e8a8c349765042c7545a0ac90e3af03958c88a215f4ea2b21d73b0191d72603fc9d131258fef9713904003a0868e38701b2c8d5c1711b225b57ff1451b1278c1c50d0a748e66c0052420811933686400ced00107f672f2159d624cea94ae60a1e30d8caba958a752c8775d631b3adcc0d7c7e049d3db36f023838aa0a116717b3674b081754b225685a05e035b6eaf6ea2a63ffda506d663cea1be7e3f8f9b062684a42fee6890adf92fde810636e7e5a4824cb3b45981a0e30cecae8ae6bd3bbfb69c02860e337071623ecd1c3aa59c45eb858e32707f994d591695e4c46fd0485e943b420719b84b4dc143b2181c5c181f748c814d31668b90f24bed88e4b0a182d221063ef2fa8dd96ec4be48018d30b041481229e4244fe434707071050c5c98fa4d41a62b499e44838e2fb09147d4d94775f111aa91c44a0076d0e10526ad28d15841684613e902a7b5b784a4bb50a1830b8cb6eefc93906369e8d802a74bea5f67ffeef4592d30aafbb3d783e7deb4d0d09105ce72d04188125a648c3916b811faaf6a21bd4d4cf10aec5a0c1dc945a9521347d46105365db2fe0ec2bf62765805f6ddf4e7385eeb163aa8c0bf7d324b093a22f7d33105c6826e0da9e33987d0b09156061d52e0af920ceaed453fa64a0abe880257a36e528aa8a3aff324b0fb4107143ccf5fb5fa136dd0501e743c81f7495a993a7a9ac72cdde81518740263df1aa4c5b1bca63d4d60438f6bf64d4a3d05bf461adea083099c1cfba469540c9a7a61435b80bca0000ae00e1d4b6092d6e49a827e97b549097cad779654913faba808858e24702ad47b2d54590ee16f193a90c0e71044c8bdb1f65dcd11b864392d57cc15b91742860e23f0b529c4226e4811f8c937713787e7583a18860e2270c94a9d48d14e770c818d1fb1b5e4256971371a2dd00f740881fb4fc24e488aa03cfb0e7404815359a966f235d79368aed001045e34770a399ba44e3a2b56e8f80117fc3d04b52153238d469d0e3a7cc076a4944a074fdd7b658db416acf5800d21966bcc53513dc303fe92f6ca1b32d4b10326e6a6354f162fa7d420a043077c090922ea256f8624e580af983daee4b30bcf260eb8bca8a34fc449bd7f75dc805352d3fe7609ad4ad7068c52e33b4144936be91b1d35e03c09fd697f6b9dc65423cd4632d322030ec841070d18b7affeffb190aacf8213622a88adbe27adb194051bb7bf2bc62ad3696e0660c4824d69539e64ab1efd9297b0e0bdd7df630c39e60418afe043bcb451ff25e84b2379d1e45cc16669ab6822061932556d048c56f0371e36415465d18c16197080b10183158c655325a3dadd5b560b2360ac821dbd92ae2fa7a42a7acf8dee95ed2e239b0418a96054a4c9c9f2078931a660a082d5089e9d95a2ed22458b2db4d8420bf30818a7e093d2eb2d49957809cd14bc4f4e5bfae40499925a0abe45e69d2521318690cad17e72dc80410a368b7efd90745809114f41c01805ebd9eb7df1828aba9fc11005fbaf41dfeb4b67356d8d2c2c1a80110a2ec4fbced39b2b928ae2e8030c50f0ad31c7d4aaaf9553e4e200e3137caea67753be9a2fe8a400c31368cf76b24dda453db5000010303a91a7eeed0ac13c5e3f80c109f6433669e5c1e2a9bce826b86c3a98ca21f754a4cf8dbe40299a6033fe691f9591f2f51f061899e0da6fbf52abe4fbab6082d3bfa395426b525a62b904ef19724c97a24e12ffa025f810b47defc40ede2eaa042754c794bc36e9a98a53820932fe645162b973266b128cf726a96ff142352b0926ae7ebeedbcf4b596014624f85361a75b7df6714220c1a5b6f4a4b324791e458f60f3ed72cc19b9bf73c411e40fc1bd73f746b0a63ba3a6902445513a23d82a4b5dea679d37ca4570327da9a4529922d8a094f64f113dc97037115c5e6f48c132e76bf8886025e62b7dd63985db7b08ae93e98ca9534ba5983704db9382f9067d39f7ad8560ef93daf2b28d105c3013135372b389b006c187875022b778cafb7bc31004bf195ff3dd0895589a0ec0080497f306cf3c75a1f29a040b3000c1e48ea5cc2649f78ca32bc0f803fb9927e9896b69681f0330fcc06898876c17327ddabc0f9ca5b6564ca67225e52f1060f0810b9195d734e7db905335d26ca4f4018c3df0b962e6deca9962d10327a964f2daf423b7926aa4a5d4346c24d30318796062aac98a936e6cadad9176c34990bc0bd4010c3cd89ff95fb91e52793968b4e0468e25598071076e82d4d518d592aeb809fa0476605c84ceb7119279bc8fe100461dd8d2a419aa555474a7d448ab1bc0a0032b1a24a49cb2eaea8e36ca66ccc0d145172968c0161478038c39f071640ae197b264f2a01a69280032c090c3b61be32565eabb730088028c3870494d44dfa4a275f90b07f6b3a62447ff7f48ad1a09da8b968041018801c61bb8f83d312ff807bd34ddb08132100b186ee0b754a760992f681c2260b481d32f4fb596db647c370301830de5a997875f673c598db4b741e3d0c05803a7329e92372a4e022fb830247f80a1063ec4cfb94d6ee6268ba681ab89f599a496d22112c3051868e0feb285b28d24e35ab600e30c9c45aad211a692d000c30c8cfd071962d41ad174712307a2d18243a30cfc7b99672b4d3949ca910c30c8c0e6fb243379cebf51df301b03373ad2bd2e26494a4462e044040f7d15d1a46a65038c30f09541c8b6104769a81b0c7c753279426e48a9319906185f60fb5fbc62975a47fc6b24046078e11113c9fef9ffaa3287d105b6d428d51f5754d0ae6aa4599a4ee003341200830b8c48d7a98269ee18ca13dcb8a10005cc98817c035d74d127c0c08c195be03d87de9e28e1e96987a105f64cc7d041ec3e30c0c802e721079545971a4d8f1d16d81c796326216f185740e74c1db28bfd56e02a66f68a0ec96973ea0930aac06bce6221a6f206993354e0aa468b0aadf89a9d62028c297039a4d32a414bff27111a0f6048814b49640ed31b31e8e93900230a9c087a2fc4d39ca43d9f000c28f06a6a44ccc94d5d502a3304184fe02ba69096f49350e67921c070022342321d794253232d078c2630f9c72af37ba8a568aca1000613187915d4af36a95cf5daf8c2d1043096c08e96fa9873df35d26ac050029faf3fad093d31a5bbd448c3190148f068059bf52d66ef901923bf1eace06aaf764210b9c72a188f9ff4c5948c9a6378e0a10ac62a77084a4491f719d3399a0137f04805e321b2c6b0efaed31954b06dea962789a6b47c993123070e270117094fc16a8af92586a89a6448c1c0c3144cce7275f3a8ae79548f52f06ada31a4d51f7539b413f8000d16789082bffd0e3dd31e09ccf01805eb39da26ed639d5b4913f8008d2f3c44c1a68bf729df42279d6a90808b1b34be7037c1bd4728f8ecde762a4ba06072e61a75f22d9fe0f45bea88dc9954d248199e073c3cc165ab77d027833c61f94eb0773a832cab0921c939c1b8baa88852f24df0b9e2080daa214df0216c7754b724ef0c658293a63ab2a6ce23f53e98e04ab9e48b1ad44ab29c4bb02151c342ecd38b765b82c9a92a497ecaa2c6dd4a30394d7e68087aeddba504374a2d26097253fc5d27c17f8dd08ea0a5e67f4a82cfa8adf7613196dc4d24b88ffeff9699ef7e3190e0e4782c31cf1174102a8f60d7f3a71ba5c4930c298e6035d46628651db61d6c04971db7da649fe7df8e119c4a4149b3d32f82ff68317ca32711324811dc774e7921672d119c8e57e90c4ac8eab210c1a9a484d4f862a534bc1a695e3c0dcfd13772e038880bf03804aba1f7c1c79432dd202f52d080b3f430041b736f8e9c4699f6da0bc1e656cb1d25d64ab6122118f91d6f7d62e6cfb11e04eb112be9d19f20b80c49738f504b1de225106c929982b0af511b6904045f7921f7e9789327e80f8c6adb68c7eab7d1cec30fbc67045922aa059dd85d7af4e13cf8e0b1079b31060f3d9c7aa33fa5e47469c005b420c7068f3c9c071e583d3df244526d2a6f907fe1450abe01382640812db4d8a2015a64200236328064021fa021804a78dc81bf0d6e5b25a2259196871dd8fdd7f50e0f41e3df1e7560cb5377ba9c3f5552e2c276e0410746e926d55deabf23a95c0088e03107ded42c4ecc7d3284ea75f09003ab6a31d364c7a0db937160d399507949b5396c64408b2de0c05bcee94ba998ea2f21273cdec0e7ce23fc94d64d88f90624e1e1063eb5e670ef5c9a438ab581bd931f6a4c4653a173b4d8821cc2830d5c9a103fe4f4e59f7d6468f0580397b32521c57cf2070f35b0d92e53f576877c927273f048039323270d41b99fb7bf72f04003939406952f23581eef68b4c1e30cbc66cb6baa63c94b9d3703139210adf71d595a82cac0ae07e193840613912032f09d95425afd6360f2e4cd21aae7564c550c9c309df933b7835fb084810bb5b2d21002031b9a2f495745be53ff17d8531aa4b5e6eceb96e405ee5255b6d6dcd0340f011e5de0367b68470f1616e20227d2eddc37d85b6074eedc9c72b25a60ec46d5e999ba9c72cd0223ccf46de5a6e9742616f80f5a91b3d66fced75c811f11f57e5267d660b202a355edfd29248f6d972a7059416d95ec8c1a3c4205ced6f2b628d3794c810f3993f6bc9162324f57800a1e52e04b480b3d5513a4f5ed110576f3e514c735a45d4e99c0030a7c861063984930eb9026e4c2e3099c9b4e22688eceaafa3b81dba429a7984a9dab83155080210ef36802579b635df44d954ce916e1c1043ea46c9aa563e6b10446dfaaa6bf4a15aca246f050023b4282dede5df90725d982471258f7fe2816af3ddd5624703bdea7bfedf4678c68c1e3089cd064fb7d2d2286c9088c29c91a52d4eb0a1e45e0236e6886c7495a821c041e4460834c49176c73fe7beb31044ea60a91738a71250979088111312747b5adcc23084c122aa44cf22a0f20f02121c7b6cf4954f7a6465a0b6ee45063c3e307ec7dda34fe39a66e30053ee0dd83728baf21dd644b8db413a4007909bce0225be0d1035e350615834e212c49be465a5981070f98aca24b34da6ae51e3be07a5dff4ab958238d460b6ee428393c74c0bd8f10aab27257ea9f032e5db598a794e57a4133669475c10307bcc6fe2e3d6ec07e5433559bf2353da7461a0d1b393c6cc0267d6f955c9e46b68b9c056e47c3a306dc45ec51a5ac2d66b088c08306fcf7a6a74ee9e324b8d135d02c181d3529ffa859324991460e1c292841eaca400c59b0f9a2b3a59be853da353162c1c64cd66964ff38a41003169c46ba9c41ad826e88f10a2627156a375fd4158cf4aaec20820ac973e7857371a3015a6cd182193368588c56c46005e36b1152455256a95b05d7d93dfb3e6570f71055704aa64bb13685f869cc18a960c7dc3666f7a9fd9ca382dd08c94e6737113b055f6661f984c590738818c314b9aa55e52c8dd1d42ca34ed618d26dd6766aa499c0868d1a34ba485cdce1214629b8bebc3751ea79498514c4f4be979a6246c19b50eaf52b8735d2708b1a39b8e0008e2eba5080165b68a1c5165a68b1851618d0220311d0824999ab808b220a46a407b5cba6a2878c8682cf2721265332573140c1e51845e5ec4d9a945e7d88f10946342519ef3bd4b37ec4137c0ac9b736d6a89887189de064ce75fa3ce48f5613ac430c4eb07e9e3668d9654e21493818b07088b1093ed3636a11a62e52e50a1b626882d7789692a9a568b14506228003c71a62648295e456ee27caf276d4628b2e1a139caa84549a218f5ec9b900a315625c828d25d4a5b78cf55a1e4b1435a9d363414670e4701c38ba125cb692b13b6f55de2053236d8d023128c176fab84954526692a449b0976152d46411de16920497432af9313b4511033122c1a9bb2074eea0b682ed376cd0b03b400c4870d952ac8b56e3997edc0208311ec1a70f96a643e893f96b4770324cae5725a9d9444412a3114c6c537aad47a6f4d931825127db2f4af61c82ed050d37bb8bb10836e91c159328fd0e221e85188a60cc738a693fe2798960f74d88a4d01ef48b880836289d79b2e8e468216bc1a1c145dd03ee109c8a95b7c4daab9166086e4da84ea9757c73eac210a310dca53549323b48fa3d1182f114abb64f445cd42fc41804af6bde71b437444e108c972a59225e786bcc6ba4adc0861781e0be53d49ecaa2e91ebf91022fc40004bb9e556ff1b56bf207fec2bbd2c8bdb30c215088e1074e864ed0aa8c90009f10a30f5caab547d172ad97748d5c420c3e303a6811e11b74759a7a0facb85568868c9ea3c50fc4d003a3217bd6504d4b22796083f0902e3f2fe95c1762e081dfd35c53c29412ca3bf09691ded36f8e88fad8e18b22aa73fdf31a69756077e455363b9d0e5c5fd4117aae29a84cb939f0f6197244cfb9dc532907ee2a6dc516370b1762c48133f5a733f7a4706064ceafb42b421be30ddcc4cefe65b981bbe0be9e326d884fbe0d7c1c25b24ab610830d7cee0a524f6de7b57e6aa4ad81fffbecff4ce376e5500397634bae1d93c68d1b9e062e9d4efa13cfa0611349f7ca83e40c7c9410724e976fd4c5941a696660e4e94b2252ccad0c6cbcbe9c734ceb924a9aa3b9487e821b9ea39c200619585189227d6d53236d0c671e59694a2d0656638ab9c9ae114134b00431c2c089b098f64352cc3e18f88f16169479ab4d8e91408c2f302aef87d2ccb92d6e9404de8517f80aa9dee3b9f1235d606c94e609e5f5e29ae4029b73cd6d4cd828114f13630bdca9f10c95a216626881510b651d923784329d2cb0164310125c628658e0748a3997a8a0235ffd735760b29fda6ef2743926252b701f2aed2c998a355e57818da59134354becd1392a303a07d3f9da3b2429b11a6953e0c2c7ff3a6a6ecaa954234d0a9c950c49a7ccbc4446a2c0059d114385b4af13d51a696b218801052ed365ccb81e47984fe0b2b86aba31218244538e14d810410c27703a66a769319926b0a33d3f54d289099c6b6b277dea2cc325303176895e9126253022b609ed96df22799e04fe235b4e503b2652be91c0a5da65151162e63ca523f0f6499d5263954da79206621881cd74559335bc7b3f5223cdb010a3086c5ace7fb7691a3452fb8d3b33821844e04352a9e933aa246b085c4a7731e9979043525c084cfed1e29152a74d9fad915670e4c061e30c023182c06afddff5be8554c2d222030ec84004baf8e2040f68c08c19ef89860abc701578c176851840e02387b5c6d5fed1efb161e302c609317ec0a59b6c95b4e9bc9bef183ee0eabff7278d27460f38d339692d57a8a044bb80183ce04d73e59113a4694b290d2b7a88b103463d3b2fc92b0fbb910ef84c32e68831b988a63a07fc6bce5477fb49e4d662e080338f9c5493f73760e409adced33f1862d880039c08cf9b25e97bec3e158cecf15477f5a5af4605233f6ad67442648af6145c060dd994b6ce501353b01edbc264d2e9631d96825196ddad4a65fff6470a3e68d2ae4e3712832419551b05ef31d7c79052ca8f1aab91562307172b30d645a30c5170a9628c1d42893a335d8db44caa38b6033242c1574a224529710d3223a0e03ca449572363b02ffd27f810ddd5d77c927d9072514c8b0c38c0bbf8220519b8fb820c4fb0994b748a87529f773a199d6092f0fba821d489dcd5066470821beda5bdffe287fd65a12063138cfab497fd2fc752d76568824d21fd6eb5780e299a8c4cb041bbc44bb2490626f8bf20e4e4d23b694bc4041997e0fc3b8752d7cfb5ce58a212ec45d7915ae973ccdfcba0047b27c4d742f2c89804fbaa27d126e73224c17f8dbd28cfcf2163908c48305a2a5f8f4e823e2a03125cacf348224ddc2ec87804bb7efb5927e9e4b9ef0826fa9b66cbbe89a7f346706bd9e79a274670275f456d1cb9d79d5d04f717ab4aa915c16529a5cc3b79ca5ad944f049e93a11dbdc537244f05555715b63a52c113d04679f4fd4784ac92b260dc19e7a89ff1d3b3db68560624413797dc44ea247083e272539550461f69a41702129e5a9b7b1bf4e10bc650a2a684fd5039c2023105c7894689faaad363f37640082af3e15f33af687468e147c91e60f6cd75a249d5367b3f2981fb8cc1941c4d5f4411fa5566b5bf36b5c1c4f34bef01b5fe05824c8e0039f2b55ae05197b40aded84f25e53da480603197a60edc5f4b49d87a4cf3379487b9bb4ef3c92aea3810c3c305a53e4a9ac216e6db0469a17ed5d2075818c3bf096d3856429febb586d59906107f66a74529d3585a424c70b1975e03ce4f3b428f21a8932e8c0765f2a33515a3f9ad648f3c2067216b8c998039719d6d9e46a726074f342551c292a6e70780964c48153aa72678e1fd93c66ec0a32e0c09a0875a5335310163926e374c173bdafe3062e89147c9372977c226d603de22515c911e375cf062ec8f83942eef1d0a0b30626f88e760941d6e566d5c09d4649232ff4594cc934f05d2aa297ba0822f468e05cd2441749f2abd233b0e9af36f456e4aa57ccc0e7a9feab495f414e481978d33962b628f53e3224039b33e62c495a8b0ce518380d316ed5e8ee754a254186183820230cec6d8b16111fa920030c9cd20d79a695a1fd5f20c8f80217f2b95712ea933686d0f0027b1a3e3182b264e0ae0b8c12215510dae45c60359dc817af94b6c0e8a79c1bb5d4f77aa405de5cdb74446ada484159e0765fc732af57e70e6181bbfb492b5a934e10cf15d8d4ea262ae5ea50aab502174be68d21a8282ae25a054e0615d5be4f757fe7cc9821830a7ca84fc1c44598104a3a05b65b35f6a4cea14d4c2970e3253b8ddb8b484a13053642b45819dc4424cb4081dfcc1e2a8ebb2425234fb82f67ee04eead83762a4fd9bc824d6024e75869344529e5392694efb3658d29a42c81db10aa4fb608b5053294c0d6ededa72f51d1b93256909104fe5350a1a35208a9420709ac67b869485abaceeb2338d691d35ea669047ed4ffc9319d9c31e32c0e328ac0b85f36ddd490085c7f705bdfdd5279913104fee45e0e35bdb0b31b0d3284c069845c55d922230849ad749dec723287175c68e0466f607b200308ecc4aca53f758a3925f90363704b63e6dd1753b620c30736c368c8e841c9e0017bf162d555b56ffea406942063079c576b281d7453788f3366b4e0460e2f3c083274c06a66cc3984a0e1a6fa1164e4a0dc7e3175ff8e051938b0b345634e704d31fb1b6c29659b670649deaeb962c84f8b20c49b820c1bf09ab531638990242765041935e0b209194b8aa56c70c181e43366e0281cc8a001972a7808edaca79de41fb3e084243522869cee8490f990056b23729b50e1971c7cc482512958127d13359b5748830f58a0ef6a820aaa57d493b49a3ccb1e4d57b062a7720a3ab5db0a45957a48c242061964057b3a66cc1fdfa4986a6f7cc102fec286aee224355228212fbeaf0a540a75de49fb099954e03f298f28212accb415c93ae8ebd66e9080d8ad59093e4ec1a78ed0a31282d0112153707b766934c54e29188f144b7e1c99b4a73429b80dcb2958688ba697320a46e9fc60f92a9ed3591fa2e094c79f9433fb72d3130a56744e4a59e6a0d1e20414dc79a83e0fda8f4f1462b28db1fcdbdaac91863a840f4fdcd9ad734d35937a1df8e8c47d7082ed3ed11925d5fbbbffb10956c5f24788e62e2ab626d89cda749490d68f4cf031a78da619417aeeeb295070021fa021801b7c6082d3a172723b9d3ab1342e6ed820c11962fab804671da3c6eca492363dd6489b3163c68c0e68b1851612c08002dc1b90fc4af161092e5432f5ddd6a07f3c3492175cbcb1c0d3096cdc6840f2828b06ac81e2a3124c3aaf9843997f8e9bfda0046ff6edfaabd19304f524f8714dfde9dd2aa693241811c5837787de3d8f44824d31b9566ae7cfbaf003126c2ea5520ee54978883e8271cf9e2cd3bf594efa8723b832fff8fed9f4d108f6745a8d765c8b91941f8ce07227b73f09f93a7ef063119c8668ca4c89a24ead0f45b031f55b5626a5f9d6fc48041b64c829e59cb4acaf43b6f0810846e555d08fa1ea53c80fc16e4e272187e8c3106cade68e8a26f4c4d41f85e0b3a6ca9244559b90dd072158cd49f976f613fa921f8360b527dae9d54b3db9fa1004db16d4494c8baffdf98f40f0e1c9e4269deb0720186dadbd1d524c117ddb2f3efec0a80d322c5e103d513f303e29650e1d7699bcac83c1471fb8b8d7975797e927311a7ea38fe10337d69de4988a8468e11e78afa0df752ff8a107ae23951069554bfde9e0f8c8036f1f2b92f094f4c64e1b5d9032047ce081efca6b394dcfc23bfd710756cb4d6f527f69418ee6c30e5c52634adde8e8764ca903636d52cf723a912fda0f3af0312499f39afe1f7360443a2d3f21ed36c6fc871cf8afa064b2ace79dcef2110776829d483929992a09990f38302a26a1e3e8c9b13ac67cbc8151dd793ae712a279ff0f37f021ae96c689e2973c79818f36b062ff914c722af92967cb123ed8c0fe27fd1b542acb7c9f123ed6c0c9d8a984d20c491c5cac171f6ae0fa4d997e0abdcf7da6c166d4f840032f9a9521585ac82dffe30cdcc99824050fd10f33701e296f44cdf6471958eda02455068f9653f0830caca4d8c9d5c61f037e8881099af268efcd787dfb4718d89c967b9f2fb5ed8a3ec0c0e7a0524a8a9b4654ce7d7c81cfec761df32e5161faf0026feafea22eb21f5d60cc3f075315838841eb35d2f04a0d3eb890a6a45649e70d8eae912ff8d802efef9a4ce87e2c65f91a6938b8282df8d00267e95e35d384605b1678ddcb11fa29c898597917366ed0c002ab959b4b42eeed3ca181830bc2828f2b7039989652d32935d2f0c30a8cb0cbfadb552724c96ba4e1e81af751052e26f389969ade23bd393ea8c0a99c838be7f4a9c24a16828f295c7d4881539ffe63786f28f01105c6b5cefb92e9943bfe8002e7aba669924ccbf59c65c2c713780972926f50c92685c8096ca520d4468914dc6296081f4de0ececedcc474a0e8f0be183097ce50b3afd268b153f3880f0b1044e54b99907e996dbb4317c288153f25ce28d6b08258307868f24f01394298d6216eb24db850f24704974344fc1f25d2afbe3089c9d7b56a8a7f248b9113849933798e5ca471118a51db47eae8e296e0c143e88c0462e2d42771aad1ffd6bc2c7103895835d8ed61b5397324008fcf7557592a3a2dc844a193e82c0e8ed52f23d8af85b3a0c1f40606f54cec1e266d3d3e7fd80310f26477f1041552f1f70935f538af8d9470f88de1953cd552cab32b6c7f01c644a2aad91f67ee3cee40a3e78c0beb678a50ea6c55fb4032e551295830c2a4a2cb50ed8108fa2b565c9d19e02143803906f60c68c1933707861e32307bc85a45719f69124c4940b1f386063d6179d379fcc6a9d0ca4143e6ec0fa96fe98a23fb796f861035ea4a80fe22afaa8011f16aae3ba994c42947af8a0011b928520ae51fc63d299055fe7aa5e2a043bb1943b78c88211a637c87a3b8b6beaf400128b42a98d31e8178f153c60c177e8535afe1921063d7905a752b44eca21befe8ece156c0e52fbce621c25540c034660b246ea4d3ddfd6eb8bc0d9e438923de514ab9e08dc55bceb9359a6213f04467b7fc8dcf974d0bb10124a973e08bcd65f32ede974aa4060358a12aad631acfc01db5bd9da366cb3877cc0dd081935633c1573ba075c44d752625a76223c60bbdb2bfba885d276c0be08116c475d94d4ea8037e91fff4348b12d25079c1275e341e898f7c5019baafdb5d2ed4e94dc80094a8688faa7367fd006fc8e8b0879a38abed48051a35bd9399632b402d080514987fc591b29f7b3e072c71169b34f845616acd768659094c782334d4987da0e0bde4d4f92a04fc96bd32bd8db20fb3a23858b5cc1c65115720e21d3d256306e4944922521c81c6205ff12ad5acf4c4d735661b2e0aaa9fe2655f09e7f6df487a454b0112fa994dd3c882c49a86054cc1e32675db749d22998ece1a7b326b72c319982f5b8a9a28fe54bafa352302a640549dbe2dd3a22053fcaf49b0a32e42073340aced33f9b3ca5ee4b098982b3e0b14a864877a38442c149d09031e974b92642a0e0c736c5fc63a15f1ff409eed426a6679ac674234f70597db5bcfb62451a3bc185a8ee649ba29e082758f3ee64ff7b3a68bd092ee55431b5e8e4f94d4db019fdd3645e6a4f4d2638f59758ba2ca9fd10136c0e6e962aa86a3ad9253879273f830a5132a7902538b7aae41f9a45f44ab09f16646fc85322bd9634b7ae3e097ee3faebe9cffb133f9260527e3a2d6a234acc23c175d61c2dcfb4165a487015761f43c8a052c4a047f0174476915b11a3ba8e6037e6760d2286598c368293f43ee249533a9711ac9e5a456c11a96d2e82ff4a4205957e2ad75404a74ac6dd74ffa85f2682913104d1a33aa2990c22f8daa04ee792f9c6c2738833ea7bc7102891b1f772af5308c6ef53e9484944ca09c1760c4aa8d1f126c02018a55df42475775abd092008cee4673a61fe23e4a809100836bf490d299dd4baa0260020b83eef0d162d2c784e13e00f9c68eec578e9cb33dd04f00313f226dfa46356fa7a1d40803e70fdaae555793d8a960f7ca89c83c8a7ddbfee1ed8533a2664ff27c9ab1e182b8d225cbf4d4c9a07269e59b020647b87140f8c502a478a3596fdd33bb0218ae6ffdcf4aba71df87fdb10849e75607469124ae7ad9c7d3af0a92798a64f4977690e5cd0294ab6502b21c6c8811bdb507a648d3e691cf851b5a3e3a83c2584032333d3a95fe40d6c599239ed836ee054ccf27b450c53b10d8c46cfa4bb535e8e1f1bf8f4c9a37e1b9244afd7c0ad5e4e509e1af8b48dbdbb9252779706ae425c2de88b896b8d06fef365c59c381e72aacfc086dc78d994a87863b51958fd98eb4fbf5344be0c9c9b4e4fe6fd92813753e331df6fde7d770c8ce7a9241649589eec8a81c99fe65a22dd30f07e2295debed62475c1c07632f97f7fba5d93fb052e6e9eaea02c45af5c2f70be25bf53ba0ddd97ed026fa6f7d2225ab0bb2c17b8b4e69daa73251d25bb0526b59b97855467fead16b8cccc9723699294b4cd02af31fa885930192fb558e073e8eb9ca87fbafd15b8ac29079dc5ad2e7b2b30229e43b036e9fdf12af0df1dec6490ac224a546033849482f9a46c6a4a3d8d9b72ab921478d39bb3461b09ea465160db4fd53ed8a649395060b37c54f0c8392ba69fc089144aec4bc809ecba68f8abfdff649bc09d90e857f1e4df4799c0a88adfbde5934a2f4be0fc42e5de88d257224a606cd773b0d34147962481cb4f2aa2aa4dc5844860f4a5dff020fcb67447e0f45a963693a4533d3502e7172632fb7cb3e6b4084cd0542d2aaffba54d89f07b4abca0623f0436598aa2eb34a488bb10b8917ac1f4aa53043d089c85a85dc27320b0eb5b17cd6bb3b9e807ecaaa94b0cdeff29f201df22a3c9c8d9267fa807bc5e92d57f5726f38707ac8a4e9a4209ff08393be0f488a42dd557c8bf75c004616aa7195295da39e0324b1635ca2cb969098003d6c6a4e8e9ec66eb12e0066c90b4b6b6173b882c016cc056b0983ea5a8854509500376cc2f5945ca909f24000df824c382e6537b92ca59709ddfa53b424a7e1759b076a6b641c60c522bb160537373b5a5dab44ac28271ef60b28469935992af602bfa75bafd75c82d5dc19767325532877c3995ade064a41cfa3cd5534a252bd82832e56e92af828ff77f27732d784852056726fdad3e948e3f4a05639bf756648aa71ea182cde5162258c58b203a059f47f209a5644a326f53b057693de7c71cdee952b041e5181e942865272505ab19644753fb9c951c05ab9e7b629be40e188028f813e969292d9a90985070f9b369b3112aba33a0605df3080de9ad82b27c820d9ea2acbcc4ed2a9ee044e3998a1576824ba52767df585fae71823b4def29a538b6fb26386df17b4f838d95ca6882179d420a3287ce142d93894e49ddf7cd31c18810fd4bfee8a5892ec14634f330f75882d5887942eeb7128c58048fda796b2f4b09d64b42889663b77b26c1f6ada5e7ae24f5488251da368904275cafa4e45ff59c16487035bad56b928f607f37a7183db9a4be388213b2bbc472d48c498de0f2ef5a2df3525c0923389d2ac4f4b499b4bd4570a579d3798cd1f46e8ae0bf2fc6cfd024a94f04134f5d4cc92cf305218249e199cba2e6113987e0437f4fcadbcf905531047f52624816c5358d5e08c69274fdcf55999a44083e95a70f593364af67105ce6da82e0b296ce9cd492403021e8da8b360920d820f9435dfa482195e40fac961a651994702d11e2076e74aa3269e5153b47fac08a12cacf54be897d113e70faea6a748708d1f13d70da293394e4e49a263d70d9572b4d06397ea53cf0ba397a7b42dea04a78e0255be5a6e5fd7fe80e4c7c5f4d13f3b8396407fef692a759882d1eaa03ab55c2237be8c046fdfb1c648890b4670e5cfaece6e37127e7550e5c921d446853d58b6b1cb8c929489cb89722513870912708cd19a2e4ade01bf894e9bfb265ee0626a8a50b12b462d0126c03972a752911dcad830ed9c0af7f3c0f31e5f59ce11ab8ec987b29c343c8ba1a38fdb739bf47358ba932810fd020c100d2c09659ba9037d9b77fd0c0a88c1c84ec4dc163e70c6cbacba944e47676d70c4cfcfc94acc192d4b60c5cbccdf849cc92a62819d8bdec185449ddbb730c6c4a691e1273c8184d31704a2b881034ab4ac78481ddea949426ffd5b380810b1e3d8bc48e6842f805be4b822a617b810d6d3a5a43e78917ec029bd449cd1e6348ae8f0b6cc564a62fb40546a50b6943c94f0b40184016d858395c6428a1165387055eaf45555cd7d45777052697c7ee4f1983bb6f0546a89b8a14325ee8be0a5c341d4beaca2df26e546034d9d88754973aee53e0b54308b9a69b774752e03c6ccbe2e6f5e09e28f0d1ca74a6fa483a7aa0603372004fe0b3ed56d079438a41ea047e937abcba4e96f45e9ac04f2e254547caa55e6502e7d9efd746dbac93b6047e4350358f9272168b2981c9196a2f51f34a12b124dc5929a8a44c6848602c990613f61ad2373b029fafd6f92a42cc296404f63b6e124ae494497e8ac05f87b2e021a6a63d4418c0106c86090620044647b030192369d6741058fb1e151d2d6e9206022f4a74fc983b6e08fb078c48e2f53d9a6f93d6075cfe911ab3d268d5b607bc9a0c5db595079caa0afe41f6968cef809131bcdd2c7e854cea80ed986e25541c5d269303de2f8ffe18623a6d161cb039fde37a5ad0a32637e0f7b73f834a9d43fa6cc0c9f7cd394ac6b425ab01b79b7a5574a6d8e901d08011ebb4ff2131df320b269d5abf0c9a6a4177a11690210b26554822a5309142751f0bb6ededaa72c5b0711d169cdf7755f06841a8ca79057ba2927e4ac2e30a3e7de6f2fe2b916de956b063aa6962bcb4b7cab082f532939e2d5d7bcaaf82932cc1335a44ffdb8a2a028daea8b4b065e2481c0e0643c150300c86e193d305f31308001838268e4582c188a0c9c27c140005462c344e3c2c121c2222101a87832261181c08048461302818080302c140201c0c0fcb0a3d0f70ba8f5f491016d864f976f89f9f6cc6117429941c168278c0b9b07d0815e404de0c45821520e670e1e5139aceb8b6510afd64fcfb39e4ce9fbb2013ec291e18f7c24987cb2b154ec964de2daae97b54239ed0ad7351dc81fbde55ba856e92bb72ffbb4b17c79a275646910142c82f341eaa41b97b68e27ac682828f1c8ed83a29f60620933f7c98077ff8c5c23660953125fc191e84fbe020fecf5a5be93f0b2486d02df86a78cc77b6b8e483bdd94b2bd69876c18ea9c3e9b8bfba31ecae906f3034c80c7a060782f402fb1d7c662be5a09df06fa80eac0bcd3aae9906d46562c1d45d0c3f2365681b6c0181b3efa37c48116e0115b0e65eb8022fc6863fe4a0d763f8b5de50f777e8caca8096f7719c8de7cc137b751e9237f21e3cb55f4d48255409658606a28d3c6a5412880d5143821c3e4bbafbc486aec342c3dd306a78126e0943c014bfdf2fd9ffbc768945ee80761076b837d7b9864e17dc05fc42e2a17a082bb419ea09417942cfc88b78ac3db41025e402cd790bef83b7f570dd4f45ca0b35c1c20e81b9503d647a987a15f4198c099742e804a3b7063ce5b68c772b397239073d8303417a81d3ce2f0b9484a6c08f50cbb5f9557c4a2e5edb70cee08a250e1e1d374c4933347bc6402890220472ac522af9fdd060527b71f1474ca16e3143847d0023a34a28333400f989c245b4c8f72f13320909325cc1b101a820efbc43c2d5a4655adf62fdfc53d0f5b676af1c79cfd00bfe584299a141e82fa41eaa87cc1aeccf08436b9da1e03067d8273c02a7287f9a631cf4bf3f725e3cf5cfc5a076eaac93f035292c16b610ca441f2f119c84a661ab00cc102774121209354308a15dc876c2bf01dc48c5f7512f285ee09a81af08882f2eb120a570cf3f5ac4e9a94703e96d4c5ff2c32cec270550797e4294904b8893a0065426c1af2b1c83ec1fb8460349ff27e0a12b72a9f95304a5fbc2d961f4a20629415cc068e654e214fdb546c9c891cee1cca69d54c4a07118669813ce09e1de0915941c0ce00fc382eba0d3a06cb01a44014e82766a5c03693bfcd7112c0272d12f62eea86ff4ba7b6fbec6b15e309a31356a6562f1ae8badfb56acadcd8aacd5cc747f2f97081490c712fa1c5f8a39ee7d7220591a2265feb4b715eb5f0e2ab1021add3c48f29fa4b4f451ff77bb3c8e8c08701c73b9772e720a97b8b690712a86b69c3875324825807cf72b681be8888ad73b25e053ec152aa72a4f20447dd9e25f5c4f910f5f588d9d391373a491bd0f4807514725378a640fb1cd88b9917cf0329a302a1ba8b535dba013232201cf5a5b87e2974edb1eed80a2aad8f699e8aee1773c94cf5df2063acc00c022b9b900db54fb2fb96be32f8bc82d66c77e572182a8c777095db6e84879f0c1c4b91fe6443a4ad5e4722d66fce13534d8d5ca091de539a65b59985e316c2a8cae81fbcd2ab326f80100310aafd155cb3bdcb99ad4ed9a9cc445b593f849c592be9de4ad3ae91a3ce030e74ad4a5e55c39d6b5faf9597614b79322e58f91828ee657da92d9531ffd93648bbd4a812cbfe527ba142e6b4ed819d968642400a1d9e8150b031e7653e983d2209e94f8ca91f889e33ff6f624ae3989c830eeed45ef2dba9d90422194841513e6a2d06942a515724111cab1d812ff6057560d02cf3f4a90b1ec6bb134bf5bd0732520061c29e3113b1bc40f61607a7a08c1848c4aa153b27c708c8aba0d9dbc9f713e81d7ca9032d8af3396d032ac59ec61a1340280c58d192117ea89176d1b7b498168928e093ce7eba743e3ddbadb95acadfb5ed98da9af6ef7a3db279ce88a6a7e6af10cc06cdd5f2c32456c144ece54c0cc9190028d80926471a24623796b91389ed04f6c6f566d0e16ddcc8959a5fe8e509032ed539b38d83c9c803d6dd24db586f08fa8f2eafdacc79eae9d06860c42e295e0d05bae40b3e46b314daf094539bf80180c0ba573ba1835ce2964cac961a85e3c580c5feda6dbcaa94b5ef2850c357302fc11dcffec3860800fca504e407b72fd923b7cb1da25148ac503fc90d4b3b4e0464ff9ea0dcfd58dce9ee043c6f49b1ee0c1e9239c8c5a547805f3d4504601493944bcf9307907d60182d40802b9a1feb9638a14165650c081d046848e0811270465a18a423908f9115236217d0a9cde4f16ff327c68710f33dcbbd31c94af58edd4686cefffe637aefe4b6a405483c7499cc2e07035820a26473d083cee6b561c953d1a211529e8d3ebe7407ad73fd316328e48918d144de870ac3221ba37b63165834b3125ffeef762e3434340140c7273b808311b62dd835191475fcf0f3aa7c5aef663dbf6b955b3308e298e85e3acea2ec7bd46a2f949d805b6492bfc63818d05a83342614185ae81061a9a299a2851a5aa490088d80cae64deaffe05217fe3b47893f8664bb16c2835e803e8e9d1f3927aa60a5aae012d3c5751a50295019481192141219ca4ae09b6469bcb85f67ade63210000e10b4c56ad48c66aec4a5b1575b37196a23dceccd8811d41571ec328ae81eca57a7dabe1a4f635b5a10905ac8b32611af6ec7c027d574a090559633b95de2ece656234bf422f2f9621e535a6e3940b322791f5f99c4ada6ea2e1ec3e5b4e715a660a646a68faf9cdb92f5b36dd7d602bcbe6cf4390bd87626a1618c7d9751a3f40a926835c23d525905d5d5be3b9ad2c6d8d02256d755f6692f0f710c054064598e0df5d47e94192eda34b7c1603c8732d6deeed3e9efc0ffbaea61e78ecfd22a2214e25ce8150096d90ca5296849ab31629926554339c101dd6f88160be726314416170260887ee0f4834dd18684c104d2fdaaa53e351d64c034a730af7c3d3c8ba64a11d6c121aaab4919fa90994ae1d7443dc4b69dbd7daa9054592532b53c10e36207650e0630c1776d9fde6ed60a97a248e40f4a42ee555341d860e64a3d13955da00c5b9eb23d732a908474ad49d80f2b0d767f813add37042b30ce9dcf8eaac7d7f82f1100cbc123cc06206fd97e78d155decae172ae58a8f6decc3103587d4d0cdbc87722ad7f9129bb66ba0954f4649f4e224c362b9e31fa9f88538d8c39d3051d2b68475da531fc0094ebd60c52ac2e38170526fc4464d64cd387fcbd677f3ad0cf71031c179b0a5a1ca049b86bdfc1b55b8d926340e1e42c7e6d3f9c345f84ea7e75d7f9247f8e116d9099db5cb9d53ad727af78fe0347643149152c5e665b8b402a76cb87ece60107201bcccfea7e5df35d6ae7f075186a3531c667295af6ed3fad1e528325c56f5dab99cbb470d78c502bc7c43a63199b0b8c573ba3a3b6669dd25074bfd4e3e6b6241135cf710f0a496b9d9fa1f89d68504cf65da483262183aa10a9080a7f95c62ab7743b55754495ca2361141f35b27d13b898d4fe498819789574301584fff2be37d434f7dbe30ab11d8f603c4648e2a1c5e36ba86d0252a504ce2408cba2e9338bf0791b6d2c2a9af4da5d051c906d5b2f9e86cfe91abdb7ff281adf8f188dc48c15624d70f908f33d9d7e288797b41b5846f0dafa65b4bc8d81653346ebfa19f3cfec6e3c743c8306255eb6b4addecd55feb25392f55597f20db544e1dfd3260d71cb5d44563c657a365e580bf8df1f9fb3383ff4d1923012272d67427be0d275922c2da74581c7ca846600397a2e58ac1548343cb0b75d07a946ce2ca9f2cd5fcb7d3c642b1bbc4a9890a6e16093d3cc641443b7464584612baf3bc824341458ad8e02dab48a833d4b6bc32822a4c17e03ed5c4b0fc9cbb95968acadf06880ac2c6b14492faefa1769b704c89b202b27f93d3d2c675951c6f32f07d9f96718d55285f25be7973aa2adc73aa46587cd51353b1f17b3f2f5279aa86210b5a9c3b18bd4fc878020f0d2ded14f6011188453b857bff2161ba5a6c73040350dcac56f6a0611917619bd9ad03a4ab53ac8e737b327a2fcb86e38ada87f115058f64b4fcf2798fc10e690bdb636c2adcf0355b28b9b09110c19455d8aa6d7121b28d76797d2cc6ea797dab4b87c376127b7167d51d2dea67d7f288b4d10442a9a817140106ae9e3ad25041c94e40cabd467172548b8e5190b67346aaae4ab45253f2aa68cf3104d3982c2912e086d4681bc55984be9b8d2e578e69a8b2364dc8c56a038cc7d7783b5f67493afa521eaea6092d4b764854f9946100ddf67b775b42cc84245dfd1152893d2d11a3a28c42d52a72fcb1a833654a8a548d5854e725d4c09611b9f77b0356fbf4cd4aabe061134a0247667b231855219b21d394e66a3a8fc3b8d330aa1c60fab3379f1a93d3c2323c2369da8493e746af60547391ad642ca084c4cf179cadf35ea3495c2694ddb220395bfda006f6e31119c7e02d0d66cada4dade822b09ee8601c3a8d0867b09b7a3155749df05fa874d12ce557e3c9f9fb2518c31a1e86686e597e20a72b5a3931883fe62671244b3ebba5f291dbefb72fc9190ccb37016c40dcb635ceb0587a3758a6a3cd6543d5182f1982f0347fc3da6c69bde2b636f27cea1a4fe6d8cca77e0a54e961bb4a01164223862dd4181010e353d3ac76c414c3d2ba574f8a12e4d0da148bc0fbdf07f41f85b2cb699ea24c5ce5e8e9d0ec10cdcefae347e3c4f2dc7e1d36e182f5c3539a68c01c94a2d2616c626236b221ff9280f9840b299b1dbddfce77080029fccecdc0ca27826ecf4a2d2463ba44f33e3ab6069f4420ef133784a51e4c966cc107274824dd62d0caccb80b936b01dc483035a216c6c4a3c88274d5a2179f93c3c06b42c1a44249a90c60de23bc4314f3b316a0b0fa55568f668a8aecf609d501e29e9277aec0df93c809f9638c40d766a7efa69528bc9d140d52a9b453c939f6571c095113098ac0f2001c41968da1529510d14f915c25bb1a416e5de4fc818d5769f94a55746ce3b499e2199309f965543ea3a25cc87d35d8aa2e8528e878f0ab7bf9eb488947eb87551dee5515f45554a98d2edca78186a4127ff35ffe5b4650e75d940c2efa3f9da2572afac1bd884f1a87a6ca08cef4d44a065392a0264612ff45c229b3818c49a86d28f9ed3acc37400a2aa010450f186d58b103029dfc21d456be086c0f4d8aa5c8f75d79209c419c3a92dba7af37604205779f82885c043791c7ab58cfc4e5686fe831e62cc821d84a7a992d3dfd1f5528c0be028cc66a8d13b58b59a959639e428cf79b244e13b0143ca6c568e55000a3eab6220ae32552799f898ba569dafbfca371507e0799f2a873f1b8590dbfe9104d72f481b53e1264eaf7d617691560a823feb120806f0c38bd6f81d6b029e9fb0fcf1be4c6e8cb494f8ee4894ae4de48857a17a64ef09a06160b6a3cfd373f8b0564f6e364625a9f698e29c4770d7e58aca888c1d351af4496ecfb33ce83a385656ab9cfd8250d6171474f91b92a3a9f57312493ee2f895f6d2b591cb849ca9c4ddd2ea73e29dfc7a3cd7e70a9b08a601ca7f4efc11b1ee83965cfd819e3323459c45ee23bfb0914bf361928412b0956a130d3faff8a0a135eb985c1f0c2847f1a0dc1160072b506076f8c347a7381852e0083ae2989217dc6b735946d5e6bc029041e780d9d72b757e506cd4e08f5c7640c65c997ff331ca9a0585f63b76c38715f5dd4f15c82ad2e68e1e450d5ce7ac2df7d175fc65a0158dcd02dff4565d8ac24ceeaf885458782c7cdbe78407d742c099b77d4c3a3405b58223959807db53f9a3e62d9c1ecbe31fad605cfdd4778bddf4a4a8cc8eb5b4bfcd18880d8407bc56ed43367b6e37332ec8b9b293d5abd92aed8ecb341c526874dfb6d3ada44b409caa6924df96d72daa46893cfa61d9b3cec66cc096d72e42e2721e7ccc2ab7d88e336333af546f03374c357f152153c391abc353c518c94055d0fa1c072bc965cefc95e1c6471578def335f1a371d63f62217f7423ffa45e36d678c97c265598ee00701a19636308103c6bfb6bd220e5d7b71bcf61d3e83f1efc7cf9169ba9330c7a6330cfdc88404af186a05be6e90e38524a116786b4585acbd4026c64ccd092acdcad81640469df7fb0c38d690a107e1cf7a305e41fbfda779e4aa5a3cf11d3f0cf208d4a2d4676e2d123be85a9b62dfc6205ee359cc382ab5dde4ed6dc08fd39666181df734747610c207b2d71158fe8e75b64ac8de9528ef107d27ee5bdb83d88d6c328de948c0d92b9949b6c8e4b0ddd6662041da419b333240515dd66718226336a9728fb205414515bacda8e0e8888833465108b42a7da409b4faa1f4da78b611c31ea4d42fcb76736363e651c0ec1a097d47561b581ac3f580378ac39db31f9eb50cc7978e8a95c76dc702a4f83032a80f3721119e1a5c15aaac7379272073e52cc7079aa5638e3b0eb673c46c6031a58323be060cc195b388f0e45b1afc45e0df96f3ea6e2a955d97a47343e62ad193f6391301541db3ba6301b3faa16466351582d9444e695a5d178ce842a6bd6f7a92507c2f9243a3425df218082be8ec18f288384d2e073ecb93a87212bcacc7f4bd470f2ff7a4aa70597f52b4812cdb4ce79298246b2a6ac9b1114db1674b65f44012c6e204b51476eeb1879683190667d6e73a00158102033024595516da4def680cc36dda08f18113e6abf6124ca84915a7a810125d4bd0b78316ce44c95200b0f154699820411dcaf534c49b214ba6a218b991be40ab3b5e383db51972fa382deb818902d46f16ccaa034dbd26601fc97e33b5b536570db41eb00dea66509be6dbf65fddccb36194bf20b4cc371e0a080969f0fd65060bf0e64ffa3928e36ef5fd246cbce35539384836efd3d5ca23c473ebcdae16a36878f3cb06abe378975d565e0390c76bb50065d890dbd386d07a044f6354f9272812b4eca08bd9365b47b1be49de0e3b3886f16cf314641ffc15fc508f46efa923a094f3a8bc375bef412450298879b4d748677208e45769e5c8992e75a1f5642b2aad4d544bf02a72efd5d55e7ddd022f8b0909962a9b16600607cb0edfdbaa4b005b6a2468d51549d2cc3ae5764747baf8fa223eefb5e73fb886bb6b4137f7368b34a78fd16ac34eea55d574c339c0b9b48e37acb522f50dd37859a2573afffdd9664864ad496e8bdba7da1b36bfc3b626c5d212210360872760727ef30da783335fe8b1737c41017bb00ee45401ca59b5cc4eb9e92153326314b4469b3556eab840fd0c21e8ed94afc1585c2b84d973d007ac707ccfa198b0e02a4f1858a10a54a08fe0c67c9d61c280cb6a0b72649f15b6ba258e1b2ca093042dea9c5f46394541633b2ec86a17014d230bc6ecd105b753cbb8cbee3c07b59bb7c800fc0ebaa46f9dc0335ab5c13546de116806b87a2bddac8e24c609c0b6f5f9304197a0db82d6a3a4eb675212685b89d1a64972b656dc9c6b691f30713708628147ecddefc1a18aa860a8adae579c01463f9a362976d069aba9ef7580866639c7481b9ca9933445abfcdc445678839157645b6f9949b0dbedf07447f3b78b9352915dcbdf74ad882ef2c6054bf4d017e90383a1817fe7c9c5bbeb3c7a1976b22874570436d64332500b67a511d6308ccf9f1230493dfd1cd4cd03d3a6cc3ac93e14145b7e368d87ad4fa8b21436071b910215b571658a16647bc7b64e2758ac084821ed9f00122b45dcf4bac0039020299be99987d90443e68be7def628975479732951dcc4ad6b315e19519b3f7eeb329adb56f0af64168e669a8d7ffbf51d49a5e20c3a1abd676e73ea6c0ea9ac04f7cbe3efbc8007f219f69d05deb114d617d0ad815833ba716b12c16467222189bd1102ff13ffc759ead670b5b18868dbdac8a85750fde785e1a23def49794d5621f06f9826b78c9de596cacbffa02fc41a3e0797a160bcac175a710e61ef9e5fa8e3df44590bb2951fe048140cc9afc38a1db64005f3c8bf8006694eb8abaaea883a72ec2b002eb82d5d394c87e29754bd29403913b45c39169d5817400a1f924614cf8573904e5185fb575d2f4ced6d452fb7e8d5086676cb48efac17063a740666f0a2993ae9a816535792355a989eeb3265a1c62dc22de1a4a7648672edff76dac6724b005471ab3f62cb282f46b975eb4097ec61a16b15491a77c17fbd01163f5f219c1df6b953e4ea807edfb3813c1fb4ce69caaebd4693e26089392e6ba5b6ce4c8173220bdb8762ca36d53170f2f1ebc4cea5e71a82a1ae95f4ad34e81d1b01d1484fc24f4e9df436d0c73a204297ec1f716922e77e7d8769c61e94cf51c2ec5da082290d98c83304fb0060bbf7b33abc96cab0ab3117b1bf6b125671e7bf5a6bdcc532752be94c66d0c0090750151f90bdeb24ee63c26f540fe6020cdfc12fe2f9eae2af22a68d70b15ebdc4fe626a6a0de792d8a375e826f45a848181888b855b1b73b213ee52e0843550179e1c0a68c6b44b0ff3c07f309406e75fbe33d904d2c3c940c24281a6a46aced01dff8ff905128a46165688380e0c2d209a4a109b1bda1614a5fe380d4101eaa14780a43602c14358b6567ad16b58007a1a23d433124b0d888c6ca6fb8fb083f403010f3911c06a034c033b82162f797a4f99b7ea3b6a41c00053b4df0b803d0d99132ca704882dd4d20ee014e0de7e708f83e974657f0f6da0f8c8adc6455792fd900e69ecb115f9185c626d200a45851c6ee269deef68858dc0f5309ca795fd5806d6aa533e1d03383b27e1d6b300040f2be852349237d1ac4fe182cd00eb1a5c73155c35ee949e4846f8d95a89c7d556d082427b686b4fa1e5ee01da1a961ea52b7588836b10e6101145db80d327d0584393592bff00c37d0c7b0f6cd9805d1ce70bbdaaaf68c1753477dc7a175ae0a0254471ea334755e8f07104d2733614802d63b2772c7727e22a3d2e369b53f5a8eaff865a68f90844a65f474e0ffed6b9848286a93331f8b57a515b1aac94f4b1c4b75e99a7c5140efdfb2e82d2a4a08adc40b01779ccdedda1a5fe6a4727829a79a5d082742a0771ec88b82813559635d0e758ffe82c80991473f724bc61ab29665c8480e53e4d4bb24ec1da62984b4b7799a3c10a2c9bab4d2be89bd0b971d8af469aacd0673280eab61fef85d8119337f68795f02571822c5606e764a197534e24140636ee8299a2c66b4bc1f019f9aef0a91619cf8258f972182f4f0032c9dbf71834c41905879c655c06dbdc0b4f166f62b38f711c86952943947da12603096f5c51573db48947358515143519087ba37c1c07d6be56312e29414379b8c4e1882f82fc2da19e509e400167febf68daf17409795f045f1b7aa9a09a5c25f7f21e0074921f1fd0d0f7a35dcb91a0e1640aac10c004c131175f4e93fe877897378ee476b417b1d9a682edb8b454f803d681e7df350bf4bd9e082b48ad60e02a032df1586a11a4b4916e19803ac6a0e9b2f2ec24a1e0010f0b3e12d8cc7a97ac360c586bfda0b4487e1ac1f08601acffbc4f291016d0f510368a51eba8b8574ec2184e4eec92c311c486bc1188fce8027434708a46c2c3f21e23c47e5d5a49e9c20448ffe258c98258ca7895d89905580a01ab089161b1942121c3d2d154492e6500c30032b7f1f0734b2f007f97e089e18f657d045c830b8c63b159a62c0e2360a3081bf0668c8ad6004dd9ace0c15601571b14e954c64e65133f07cc87497d7548b2f2f0e484e2e7f795cd067c464686548668f8d81723b8427d8cf85d74ade7e3a1a36cc6d140f73cfba4fa88c2c7df0548762eca7ec398889d69e9440bfd278419e7bf81350c4ccf000f2e83a5e069e2839a6fae4f8faf1f1f24be217e5438456928a1835a9f5d02df7973421512e1c3a6f7712b583ebaf2c02764d7faab2971645037b17731bb2f3d408e4cbe348a730714c7942f01ea9e8187ac4b320e20c24199ed9b549900952562fbd7434579645c1788b96ee5ed4be32339a3135f52b209c90ec0fff9e1e26a908642c74a17b79081190970517153859d2029c148c457c04fe99d3dd1bac1961faf4316f2f30c221a26846cd1b0486802e63df3143f6144555c09349abe3b8521638cc37993c48555ea5f60de1f857bc366d711f17f6890ca5a22fd6ac4f332cbb5ff5ca6a9c1e77c98c06741a34499f44d8c6ae074715a0909283a28637c1f24f5e7381a1293fa8e753d36ed198e9ea70023c3cb8be0e7f7046382b1d38d61b4bbade954f907d3c420066a9cc37c5906bc702693d6f7e9d0666e00cf7d66aaa58d5097c1b63b20e192e11214076b048b7b23c765f3b379a00b0471a5a260aab879057cd630cf0acdaac222a53a9866da61c97841ea67050addf463d95efb1b46b06a21c717624864a23aa2c512c1087530c60549623a53df694afa694df24e9ad93fb6a2b5637a187d9bea30ea90cc0a245215d26bf8cce53497bd00441e1970918924562eaf68b547b0ab63d760205927ba5451acd96d80c51edfc163247c3f0d7fe939c793bcc06601dfa1ddb2274448c3a6279076df8b779753685122d2794a99a2598b14bf2c65b7a1645aaa157a8d002eb3304a59e0412cf8d3f8a08c283ffd9ed82409897e26f5c4828772659ab347e22d7e921a3237b51b16ea134909f332474f7cbb3658a9f57bd4f5e45812aa9767b7683102993db0616192740fab0809566d6fbeec361733b792e475d96b7b26bd2553d603da20f78400fcdb5965fd0505473174ef239cf39407c7fabae2f6662ac2e3ed5f07184584dd223bc8fe908a4ef10182ed367f32da45153e78851d45175cd954598b5263540bc9bc4dd2c14ff169b1d5aab148f0d0777c1c321776f0d5dea17437a111371e9e61bad0aac889c7a93f09693fb519c96b452a7e486fe9184ea4e906a35619ac5fa45ec82e07870f7090cc049ecc624f37516cd9107920635d45641b65b45b4a1ef581807774a49f31104e6971d4c71413156b29b14f39d5fac2180d2e6de38004296f63410232d95ca1c11dc9f5b546423f6e9dd8c6e4bb659b254bcc2482ad9328d1c44384237390af69c2b65413d703c9c9e78d588adc82415b55933a0d42d1dc4e4232039f2d369bb16ab214b2869ef1ff231d7f26ce8456fde1e559af494db7d3df30e3beeca0eee54c180e6c9397894c6afe93330ba25821e23aa9edb29aa939cf10eca3754da50d4c6038edb04adbc05d7638680318f5183cbed609baaf7e3c5bed654fb335ecfd76482a56b98005c10206fd665ab4407a525087a29b3d42e122a45c9e3f743ba6ceedc466a3e86305a39808ca56c04cae69a7a205ee907b72092d4fd889c33e105ed56e485e14bea958ba6f6cecc7cee673cbc84bccddc662c2bdd334752d9d5b1f0ecd19f8e3a01e69f44a27a7ea05e16ca234905d243840303498212a83f9615a984abb1309bc07eb64ca98943818b9de52ecdba481e46d4b64f61d471af7e0c7b0e054be389a8b1b7635c284000085d81684e831b977f0a18532dec98d1883d7561293bb43949408d057815d420fa1462d3b16f417dbd0d94474016c3187d406a14dd9cf2700f21ce0c4dc7d44e8ba2d66c911484b059e29392c845c795f5e319ae10bd6fe2815d6f15787f08118fd6047ce993441f85648e3e44fb802848429e33eb08096d46aaab8807f48ef8e3f79d602445b4c5816b9942fd7075b7336709e2232cda8415e9e224dd891441bf4849f9678362744983b0e2348669bda4206986721d6649afb7817dcc1f6a50f7a411a2241984425887dcc03b83ae5f7ee320f4844dbab088553f4058b2771226037ce7faf4073f0f6800ef4a8d69f73256cb707b152bba4e470d57ce9c142d9f288fecb1e41418f2ddcd5e9e5e4d3bab4a23833d5086bcb4d97e6b549e465cf603643e3a523b48e83b7ea2f3a2d1fa015f2779fe271c6e7efd34ff100048dd842571ab924add6256e142d5ff9f192349151ad215129946e8ac62263165f27cb58d0fce9771b92fac71305d48e56a627c91dd530e6dd2d8dcd4c2a8ce0ffdb1038e75d33e7cfaf85ee3fe31e21ccd5789d53c9c9c8ac0e58456e81ef08203088b04656a2f6c1772158a21602fb5ea06f5b9a85e3d033d9e616343ce928487d5fbb87aacebc0323bcac3b41faadb610aec92a3777686a4f7e9b72d358e7c388055975afdf31f59935d8f17d9019d41cd52a4da3755bcd07dee3829ad370808726e96a7689b34f59f2b93b0331bb068990770b5b7a74abcf79241788ae04de0a3b1225763ceb094535841f5e22a9f26efe845601e7f0fedf8c0fc8c4dcaba9c98a06b8369132df4254de30e5e641ba45ea43acf7c410001e92a8dd1017c4ce3bc09fc4f7ac11769b14e0a86626c7106ec6c498ea7bf3e975eb3d090bea00ea65dd7c91808b0af15221fe364a398b81bc02c4fa6c5976088717eb70603163870be2e2010359a1b18472194128c47782a80255c8b1eb3486a8122aa1a2c80a870b1d24842ed7367245a1177a0a670dc2e9195354056fce67b608ac6dcd930e007c873bd9a3b950b9cb0b634b7fd8ebf2027fbb1e8eece5b82580edc5fe1fb5be43fad4d1c4c235f6b8376124423c2b2ada5cbc80b0a23a3f571d6e9f1dc132c3a6f0c5bf03c5be074ca18c266c9ebcc9da170bbcdbeab38ae09d061c7060f1886d5c6fd292ab2ff6b0724683b17211393e8832ba08d6544a4094ddabffd05cae4206813246f5c6c20d134680dd3a46285810fde053033d8eec23708a709b17218338e15af105d5dc938c2d4c52bcdd903815630bd56ab09e79a1c0b437343d4dab09e282a56f8ca297a8fb409e3eb22c561ca4b9a30e5aa490f90811c5b2718c290d9b4f040df8a3d01e70d4d8a0581103cb713db0d670efbe41ae8dacb2408d2d1987938651a2c2e850f523a642df26a789abe881ae21d07fb17059c355cb0a945840866309e783c5b7590829ebb1363f7d38d0cee8f05c27e102e268d47c7b52f737e0a8f942846c1f1abc1a9ef4a099dc2893f1ca01a0458735765c8c3f08970e59a4a33c3f41b870d23d9d772956e00aac8276152022d503d578927b9a4d0618425d3de94bb6ff87601e68630b21ac07eef95c708b0ce07d90a80dfca2ddf3c7213140cc1568a30596d1bb093fc64f85ee6e68ea7292d435e11ee041e13407c11015a6a07386ff668ef2bc26a7af9467f672845016982dbf37d55f368487ec60853ae288ec3037bbde789fd0102a4b25d120210fee66d60370fa2c5cb6b03832094ca8b7c5db58695a0f55a0e8b80dd9cf61ad05abe543af922d094e8f9bbace9a66b18e8185a2717ba8f94cb303dced1e55cd0ce2740a822a44a71fb5625ed980872cd5af1f126f16f7dee4d591b142ecfc77ee26d8f89b7aa5eb9794dc1b98c7e3e473a04ca094ddc8f92abf9147b9dfc9939a32441ddb816c551eff16163beb5ac283990d0eaede71a5b27803c4e21a3fa87c633242ec80af7d21883296180f29751338d08a21072cf812ad73e699ec72b1f5d7e2c62d44ebd65a7540a0da1c514da27e5ac6d3cf13ff5499c161d86876f49659e7c90043b2324730db637430337939a52f5fc28fa2b870066e3b1053fcc6b80dea7b5a179233b810443514a2bf0b5eeb1f533ce1c9c3397cee5b0f5a3cde27d6db953bdf87a7c99d10d165ebe381fe6829f61f2c60890eb7956218a0d0d6922033f802638d5076bb9489a376b6aa8ac67f25c4280922dcad9819583756eb7714b40b86bb8adfc21bc4268a4f8a1cdf12708080b7b98456eea30a55a6ff8bc5097b9e586382c47db412e438de5bfad90266ee2639c3dc2bedb3a94f9a84dc0b8859014486015382105ae040fc2514ec7802fe4044df0a3760b46439330f0f0f0f0f0f0f0f6f706ba4b6d6368024a49424a9adf153f8ee9029a594648a8433d417ce4cdc86362184d1863fda080d02010bf40ac50ac9f499f2b5ab325cc1873eb19c2fda07c868051b529a92123cf3a59820b00219ac6064bd6b472a993a476d6ce001362820011b5bd880c0183256c1a43e4f3166e855c1c61acb9f53da53c19f680d31c8fc7ef9265430f92ce750ff21afa77b0a268e8a96c73bd8b6ada6e07a77f46be99c25eb2d059362481a6aea99de1e29b8ed9027e4cadd28f8205a9265d09e29658b28f88faf7fb6d9d3a67c2818d3f8666a440c146ceee8b952b0de0b1df904bf25748af61bd2a8c83dc1260b59c53f923e25f24ef0f9647a8db69fa4fecd093ed8a866ad64294a3a6d825162c9dfe228799a9334c197902c5a24277bf55226b88a215a44537f25e208136ce4d0f71f73e275e55c82495a21e85e907973722cc1badec678997542094d25d81d913975ca5ea276a504b739a9c99e96d6f58293e034b7492b957eefc59304a373d25ff59e48f06d25421242de9f881448705192529f839074df23189521287d9e2a6d8a992378492a85a44935b6ed8d606c5c536806d5604284119c34d3bd2d79a47fde8be0840a26b2e45c5322a22a824f1354aede4ba52e272611ec560a22654919e97b47049b738a0abefb15aed14370c13268bbff6032a225c3109c14d1993d665536e11582cfcb9f9d2ea7641082dd2cfa73cca064705707c155f610e99a5434b5a80c41302a7b6be39f84a4ab77b1c3e8588055faa2053bee003202c1081193fbf9aa3db72203106cfa9317539ac4913193f107ee4a4726c30f4c12eb517a55374ef4f481534ae8535dcf49883ac4088380a12351061fbe14f5141a5e3a4765ece1f275d3b496255af0764d20430f2729fa2495b6cf6a870e301cf0001c376e84c1011d1798808dcb01cc41461e4e061e4c9b335a1aef0e8c48cbaf1284251d499b63c781c0160c68c08d1ba87164f941861d72edba183a090bfabd066edcd8a1038c3176dcb8b163c78d1b3a5c0c2efc04376e7419c3860d6263d84036c6172d6807e0d0e16274c18518a70b07dcb8f1858b21c6e9e24b11400c32eac06fd22554acab15931ecf72d482430162635879e15e14d70146ea800c3a3041dae44f8d7539863e073ed6c64b6152f3c80fc981f59c444c1b458e4c37f9e313e8a28b311c1007d6439d44cf312c37e370e0369ed2759d296508a63770c2bf4f3cb6ae471cc97003b7f77f9db263ee48a78c36b0c17c63f9a70f2d1dae2081a12090c1067662b59f8c41d449f30332d6c026e9d95c443019fd35db21430d69cdc135a5e995430b87abe0ec28c5011969606c4dfb6e64730c32d0c05d4a2633a325b520e30c8c9af2717dcde61b649881cb9644fd5f1acbc0c9143f5bfecccb5d2237c820039beede4698f24befa731f039a434e919ba83369535c81003e3be9e3f8fba06adc130f07d26ec5e82fbc43791db820c30f0d69fb55792f294542c878c2ff0232baff6f208870c2f30c1d4b485f4503131c8e802bb49a8532143e9a867c220830b5cf4283107a53c684b627761811b374c05376ee028db838c2df0d9f71b3d564add6b818f29f7c40a53da3cd959e0e249cd8c604158d0278b50be279e2bb0fa95449f2e09c9feb50297525636f7f414f42a70f1541236ba1a29c5a9c0aea9905e9ffadd53700a8cf29ca2c4b558c890023f4a5f27939f4d57d089b1838b09686087efe080b9848c28705e22483b9d37275a1e0aac5b9ff6e54cda4dc99fc0e62611c72d74c6de9dc087bc632da2e926b0aa96eb25242526302a3285ab9bcee8c9b40446869434428852c93fa4045652c81bed6d97174349e02b67b4b43e993de206097cbc48e3e621e608fc85749aa2c734b333023978deb6089c58a848a9b359f24e128111a6eec992a8f5dcfd10f820737da759c960260aa1282a276da7c552818c2070f6616363397dcc07029b2b22ed86d2b92ffb03c6f622e5ec5bdd26293ee0c23f72fc1b0f41a67bc0e7f8554a1649a23b3ce04df379695bab8f15db01373af39bdde4a4a242142043074b126f2d99262707bcfb6637355183034e729217e468ac0e326ec06b72b7aab497954d9561032ea5bc9a9625dd0695caa841b6412b92d438914103aec7473b0b4e7eedc8d49bf290052bde954f23668dec522c18bffc94549f62400a1eb0e0a44790f69af335ad690b1bc40236b6b0412a60630b1b840236b6b0412660630b1b4402362e30011b71f078059354c8316b4816cb84af06011eae60bcb5caf2ae294f9e6d05a739ad24d3525975b783218616f560c517e25b5269d15d8f55f02571729694d23278a8825dcf6717d306a5673b20031db871a30b47810e1d607c9123edb871e375a800061ea9e082ce6f2a29e615edcc0e555470ff1949b54474d4a46a233c4ec1abee6866f28e872918ebd4fbf020ed8292799482bf0a0dba5ba204bdfc48c1c90e161a3125798c82cfd5a33e652d3d9aa31ea2e0f562a5fa1c52a964268f507032db574590b955bdf40005a78334117358baefec797c820d795355ec8b1e4ac9c313ec8590d247f1d31325280f101e9d605490da994da8bcb93225ede0c109369552d1941d3d356463f0d804bb492413dbfc1f3bed9a6025d9e59dd8a273867960f0c804eb6bc18205d1a14665c5e081095427a9f157c97e31868e9580c725f88c3e22c326059d7181c723e47d06cb4be5183a2af15bd8bd9f679b128c8d92b9baae3777d4bf1843076ac063127c0e91458a5bbfee3872ec18230cc22848470c0d6c2567815f053c24c1061f69226ccd4830ae39a4a037dc8404a3e2263565ccce27fcfd82c7231889c1435bef7604b71f6a6b6ff75386c9a3119c4efdaefba57a30820beeda9b97443ce0b108268888a87f168c828722d8a4f4c42da12af7c41c143c12c17d9b56e9b859a445cb0311ac046d77cfdf158eca83c721b890f2cba2ffb628bffa0d1e86e0a4d999f87757082e87c6ce924e242f21941e8460d5d3a59844dac9fb111b049ba2c6cf79d46c33d382e094509bc54ac4f2897904824f4127a154f4e7c8db01c1d7a63a9d628e1172c5a6e0f1072e0909aef9727f52e843e0e107ae3704d11b5f1bf5ad471fd8a0db69d48be9b4343df8c04b0ed3bccb252478ec81cd173be8d254e5d0c2d17d881d142430bab00b00103cf4c0468e6629b45f27ab5efce09107fe93c633bb94c9e2c8f0c0597253bfd1be6c7d2167048f3bf0716d2d2d640e4916ca2d78d881cf509d2ce5300d95d781d321655656cb972548b4e04107ce7474bd749df4e50dcd811f75dde65532d6b8eb21073eaf280bb2627c8fe92e81471cb8bc9e665f59d4697239e001073ebf9a8e1435291e6fe06356341942f28d091e6ee05bbd72fe0db24c9989a305270c331978b481cb394951cfbfb1aa325f78183bc6d871e5c10626c9ec5e4a94aa1ceabec0630d8ca757f430b563297335f03149fb8e96df64d27f0b113cd2c0f765fecffb3d61d2c62c78a081c9299a9e2382d23a4967606db227a146d89ec528163cccc0b82921e26e2c9f1cdb32b0c92f467190819139e93791e4e7381a2a24f018039b338410d67b31256d1bf01003fbaa498a5d503a3b84b6048f3070a66c930c1d47b55f0a0cc7943456d25d2bc1e30b6cdde8cde9b1cb74ee385aa0430cbd828717380f6a7dbfcad3877ebbc085d7a9884c4a7bd0e102a3694925e854b7c0f9980e52e2297f53d10a1e5ac0721e0d2ae446aae091053e6fa8648d1d1ad444565df0c08297aa479859fc0abc84a851cb46895edb0a7c90dfde2e32fea9a90adc066d7df24ab8fa54e03e43f57966bacb4e81f7493172aacc4ba18ba5722995321f055e3325896aa5172bf350e04db3f376d929a1db7f02a73a7947c545855cdf09ac5eea076dcda263f49bc004cf5144aaccd39f3e133855f12c4b0aa1f2cc5f0223dcf472c9cddf48be12b8142237affe78d6f093c0968e65bdc89b62d23d1238b9e329c935f99ef547603f256bf650933ea57e47a5c949d34a70e71d84ca9643095633b86bc8ec24f88c9a63e79f940497512d491db7d4798491e083ccd9d245de8ed53e0d4864aade848aa351748f821d670336091a8f60848c5b413c54e7c71dc195345de7666a04bbaee7495e75868a0a23f8d0ab20624417c1e7a9ba20661d73f614c1e54d0db6b9f636b49208b6d2e9688f31b6f588d84c6434134a7608c6538a489fc97208779b8b2d0c0d43f0d9b549ff540aca275508464e4a8e11062118cf214cc5d1bdafef0f824fbdfb510b7241b01e96dd3546dc1f650a04772a846c49f99eb6090204ebc14699aa49273de9fc81f3bd1391ef3c7ee07774e3d5fb875cbbe9032f31644a9bc6bccc357ce0fd5753cb93660f5cec8951ebdf54e8bb7ae0aba2a8542a836ef6681e8cdc12cfd7e28907ce92103d31787ee91eefc0c6ad1c4c5abed8818b39cc3e3de705cfd78157cf9f8489c6b4392b3af04175ca7819a4258d990397530a49454c264a47090b68c8819598c13e84150736554a4ab27a8d5b88c3814daf9cfbe1f71bb84b4ae78edcddc089decda0cbbaf74edd0636a6ca2fbe9577da64d8c075ea5222d89fda5e740dacc8f6d49b37a806de7f84083958c839669706ae2496d03946fe247434f09b4262d299fb5eac7206ae84f6cf6f1e4a249399810f22e554d9eb32b06e19926d940e19f8902c54ee8da977947a0cac78796bce9253a5b41818bb3ae175a623e78ce068810e31c2c0ae47fbcd29497eb01218b8cd67a9fd93f70556f32af57684c5909917d83ae59d25a9c9415845031a5d602ba5a6cf6a4ae988991d6870818f9c45e8df36dd10475e70b181a5b105ce6dd369519a94e8a4a3052ee5e7fdd5dc1d92a259603746caa0eea7e244110b9c5b6acfea96bf026312526aaa7117216334acc048099ef267a5142f48a30a5ca5bfdbafbdf5b594a5025fb16c83690795ad73f431ba382ac017d098c2e291228aa8a454d19002b71f4443d787a8161b1b78c016c50b34a2c0a9260bd1b41e9e46690c1b1798800d30d08002175fad339b526a39b883c613381135bff42e7a8aa71750aa8481861358df4f0bdaf55354d57194c181461318b5cde7fe1a732c956101183ac240030d2670da83c48c6e4a62eab30c3496c029ef13eaa9367b4990d15002a7dff25f3bd2e4895d0e2d1c6178914a79b145175f58804612b8d4eb4a492b8a042e289534ea0633a55febe31928a510a071043676964ef622358268530a348cc0adc44b7a22e6b459544da051044e5409cf215b9e38a944042ec35a74d774567c1110680c81afca49bf52c4abcc7aa9020d217039ba74090b324fe62a08ec290926c1454408518106109890e495e89646aaa0fe80afd69c534b8714ffb328d0f001574aa594f4ea95e9b422a0d103ae57af92a6d2ec3b960cd0e001db63a3b761c98249d61c81c60e78136197ee62e80fa937020d1d70e2ff3175ac0b3adf99432b0c2ec45893018d1c70390691d73dd3f512061762e0d811061762744103078cf63bcdba1464a040e3068c77648d314516c976db804f4b216b9b29dfb7c91368d480dfb6d23ebf4d3d7dd1a0011fa459fc6c153263169cdd9bb6dadf376139b2e0a4de8e48f2cf34cc8805ffaa9236d7f2657fdb033360c1495131534fa65598f18a728b4dcad2d9aec00c57b063dfa52b2c58cc21cb21cc68059be49769d0bfe725439615ac66b4ccd851447432550366ac824f5971efb23e6dda76862ab8a483074bd974275d71093352c1be86fa4dffb9fd928f0a46435747e750b9b5834ec16d52da1d4d57bcccd514769e1434799fc508334ac189ec7699b71bc2724a0ade54667c932034e576678c82db6891fed385cc1005a73972758a9332a599a8302314dcc8bc4d2a5eefa5e08282179dd926a9ef6b62ceccf80497530eb641095d5a3ff7049784befc38d2e4a77d3ac15f5bf747b335c78e0381d3199ce0b46565fe379dbced83a3ca143163137c648dfc9eb7ffda6a08d8d8c2c603b6b0c136b6b0d1802d34c1675226f72f7dbe3023135cda10845ee650113bba0516666082b56c11746307675c820b41648af9f653841cb28019966062daaeafa0aeda2cb4b1c5186654824f7192501339c434da86125ccaf190439b9981044617ae6312dc067da6a794d6955f39b4ba0b303e083324c196de0d495e3a1b21ea48b0935da2e64c419060b2281d31974ee2a6848f6025fe577a9852e121770413728aa5f8e9d35a4b663482d31bd916538f8e3083117c74cdd74e593daa25bdf02202691b8043cc58045bd1ef2aa9529e79438ae03557f2aec816edb42711fc5a0ed9d6e2410463216ed01f2166d6c839041f84c4cc546117ed5a43703e7a3a53e45821b8d0e3993cab4fd54d08ae8450bde412f39f84e81003479587d1820d2462c62098a4b1d2d5f34316e90b82abd49bd9ed8329b33b10dcdf6e0ebab29724150182fd78edede611f278f40f8c69ab3f75b671d32a40c1e62366f881f5ebeb11d2ea2c5abe0ffc55c7cafece5515743eb0669182f0f4901df2b3072ee5a818214e1296ffd3039b4c3f72929a5ef3a57268a9000538fe781738ae3a2001731580e185eb08402066e481d39a1154d2a022a6d5f1c05d06559363d21a9edf81ffdb20313ceae474db0e7c2cf1d7b2cb1dbda375e03705b5187445f5e9920e6cbabe9873fbd69412e7c0279945e65dcf4cc927a6fd8b15580000aa98210776426e491294478ec98f0327b2e385507582039bd386beab3db7d1ef1b1855c942afc8f7b6f204ed08c60c37f0b59752c5bcb95deb6f0393763d5f48b55945c6b0819359b2fea8fd2079b26b60b744e8babaae8d9b570372848c41e8e86f1a1899befdf2539e986488063ef6e556aefc9693b2cfc08714da64c87631490d320397829222476b4f2caa6560944ad31084480c79f46460cdabb35e8292a5427e0c6cfb65a618835c0c8c25193a657dc8b1b31e0636a7dad0621a4212afc1c09eeddda8d2a72ff079eaa3a36e4a2add78814d7709a61642aebaa60bbc78784efda6e102a37394741fbf32627e0b6c0c4942c98c76fad1d50223536df69f8e27c966814fea937ecd251618cd88a9be976f17b91c5a27f8828b1d3ac648ae03479da0991414665c81314f2999e5106b7df3de0596cfb002a736a7ca88a12be860e238c1175ca0209d40877b5186821955e0728e223d847ecf2552ba382ec60e1c28e8620c946563030f6080316f30beb89f41056e83dc8865a332ef1de98b8303477f7170b0808baff2850e0bfcf109883106056edcd0e128d071bc281670f10503c0831953e04678091169d3bfa2648614b8b4416dc40b966d6b93436bfbc60d0e9828b0af395993ccd2983a0a057e948aa62a3fbf3c98f1044e099154b9b27437955608339cc0bbea086d79a46e507130a3095c08491e6b27fead884ce0a3ed77e7cededb9212011da7033798b1042645ae98aa4c6707515202e79f747d103a1dcc48023b69b494bedc9954f410099c52724379d01dcaab37338ec086c474ee1743974660527a8a418847af084c5caffe4a3146df9815e30b2e3870e346210263fd357a3b9dffc5b0cc60c61038916b4cc4d19f35e9940b6608818b7d2e4a853ecf82c0a6aafa87851ac78e436ac7026a3003086c28c949691fd359321983193fe03e65f41cfc7447440f0b66f880519372fabc37cd49e66c1166f4804fca247aba8a179ec61d3ce0c7bba36fe48ad88e2f8e0e318a0161c60e184f6a21aaae9f04e1660e66984eaa246da9949e03be72c774e1a9ce269970c097dd56ff58325def8a0d66dc80112965b1a0aeed554b1b705a7931e36a8ec9d3ad01e76a75f913626d0ce50c1ab09ade5a33a485560b0319b3b0c3b36f5398c9dac5f8e2a4d3012bb2d08245b5bb78569b2423167cde18740e1a3b5870a79dbf6486e0173b5d84e185eb0b64bc828fb12f0184e025c5531a565223bac6c60626604307c1ba9f106db59932725210e64caa83d0fb2924ff77081f81e053df5396a067396777820f40f0f9bde6e33105b533b1e1e30f9c773495f75250093efcc0c7902fa5595bd9c79429193efac0a7d7575aabe8aea0c307c6fddc4a3d85e41e58d3b4906741add6d71f7ae0cc3a06f724624a4247ff9107c6266ba747dcc9a22d1f78604c44fecf154d738595430b8cff820ba2838f3b70aaeee65e5ffa473d36b610400e3eecf0f9a638d16dc4b31c5a2b383a70b8bfd58193c147a452f1e4093dd1814d2e6abb746ce7c0244d49f7a27b7268e506bc0b14e8700a9c073ee4c0a8512f21670b922cf42ffc04a6031f71e084ce6bff4da1b36f0a072e2328ab0a96477aec38f0f1066efbdbdb424e11512c6ee0bddb46787814d16fdcb831838f36f0e6c9d2fac95117526e470e1d384e7050290a6480021420a6c30b2f8a083ed8c0e68a14a93dfff4d28f3570b5d9be59faa5e5fb871ab8d6f02c916b64d221fa9106bef7bf9392b42f42d51f6860474566919474d37bf6e30cbc89a6cc6a29a6f4261f666063652d4d32bd9652df4719d8a4845f977a503a499e434b4df041065efbcc1c03dfab66427e4e36494d7268a1e08ba303c78718d84b217ed9b985d8df8ae1230c6c6b2e4fc1c3b4cfd361f80003b7a75f728ed61633828f2f90f369ce21626e8ba60221c0d11f5ee02bac56c453e66f497268e1c8808d2dc84717b8d2bd110b1d65ee1d2e702a9ab698d47e47af6c0c1f5be0a2a5b8a9152adfb82106185decd80f2df07ea3465e8be6230b6ca51c44b4ba5ae4a4fdc0022337d3b78eaedaef908f2bf0315f658ba57b52d2b815f809b2cb3dfbf85105c63ce43abbbdd2967e50810b5a2c988f58f89e3ea6c075468f9e3a434a7c488193626a9d7a2df2c75013cf131f51f880427e31eea952761727c761e0e309fcf9dba64ebaf7e39999171f4e602d87aadcdf4a11d9a2253e9ac0240b21656b089120a41f4ce04784452dd31c423c1502bb858f3bc894d2561c9d600ce48de304607461f0001f4ae0aea35958974aba52b4c24712dc16d3bb112a6e60023992188701376e4ce103094cd011a39a7dae12253f026b2e4994c80db5592123f09573cab896828e6b8ac0a9acf02836e61584ba880f22f06d2a78d6d05be1ba6b213e86c08798be1f2a3c4d16c78381c330c013172ad0e11a2895237d7174a0cc0d7c08c13d7d6abef7dba1a4021d636c91868f20703ab3b957a94060af445bd03b293d7d82838f1f305a216d52952e59d5ee0336a88a646eb71d64090350838f1ef0f93de7dcc9d6d5d7c4032604f53cff705bf1b1032e8390a20e387d4164c93622fb8765630b1b5bd8e8557ce4809718ed3bb73c53c50f1c70c2f4a4511d947e52495ff8b8019354445f93b89fab83884de0c306ac4d7a2d21847077cd7ed480fd125943ca8bf9e18306dce8186a84ccd8c13212851ab3e0a2272931c82c416551d240b1430d59702986d6abfcf70c41e9c51874a8110b4e459219a9d75cf72758a8010b6e75344c52a6e41eabc62b38e1f527b45e7ccb9e0b430d5770414da9c896bf2b06b7157c6f1659fa9e55f28face0e257084144ea5bf09c55b03569432c846de88b2ab8eca0294216eba81b4a051b64c648769a6dfc34d77109811aa8e0f5b44e8ac1cff2f9478c8370eca9710a7645c6cd8ba233342e7c8c1494aa610a3e7752dee57c8b399dc610354ac1e6502a8927350bcac73cd42005df159a6388aea87aba35d41805efaeea2198f47cf92d68a8210a26ed56a5e5e46d691dd60805e3aaa6f9d53e3540c166f178d27cdcdda2c62798bce973507ad74ba9c7136c9e7cd283dcd4e804e71233aa44bfd0a12ca8c109fe6d3c27fdfb20121cc46a6c828de6f76d3aed4454870b1d61580d4db07dffb9419b094e78d69ea9742931b939b42a063530c17a301df3c70fea4daf4bb021d8764848a633420d4b70aaae9e63142537422cb750a312bca8f98ba81af364419460ac430ea62fae5aa831092ea4cb9433955fccadd790047b4ae8f04832640bc2ab1109c673ed8b9ca06cd4cf1c5acb831a90e0afbb228f0e41dd9258e311bcd9b8aa988b0993780d47f0d94386beccd22c4ad70836dc4f07651d32a10623b8fc20ef42d59563c721e6801a8be03ae7c5494a868fba48166a2882cdcf5a9b58969e16fc070347f72916811a89602c2421d2d4acaf236e705003115cd22023c70c22631138e3a2c621f8ce7b4994d68a212b65085e23778f2cddd933a61405d42884f9cd27082183493381d15b83108cdc284ae4f4bb210779d526a0c62018c929df7e754a923e6b420d41f029c2bef2b90969a5d608049b3428a549281b108c5ac664b5ead6f803dfa731dbe990fbc1ec5e55bb27cb1a7de0b49bee7ade4e1042abc10746b48894d56a4165f76aec81b37613ab7f6b7d8d1c126ae881ad4a6f13cfa6b684d40535f2c0a778a523a2f7d608ef0635f0c0ad69932631ff8d3af91dd8eecc3156d96d07264b0eddcfd014a1461dd8607282bc92acf59dcba1656450830e7cd6c5a45d42e4dc9e9f0397eb94ac499e9d9bcb814b9b344aee7890691407b6ec4dd7f78dfa2c7138b051d34949195266c4dfc095e63d91e2686d44ddc06778528d1ce936f8b731d69a8f121bd86a1d393a5f7bbd92d6c049c8912bc4a44d7c4b6ae0e32569a93508a1cb4a6960359d8bf6efe7cb104203b7eb163347d252223f67602c47d2bfdb1c3330e66e5b1dd275828897812b2522932599f44b78c8c0776513ca3f6dfc0d9931b0daf9b2978f0eb14e2306565f5d6f57fc523313064e2591d7bf3ed7791c0c9ccabbe165ba52b4e80b4cfc1b61315a1ce99ff50297d466536eb92ef0a7dff6c13ec7acd4728193d183f9a515a13f64b7c086eda5c62879d2a6b5c0698aa2524fa259e0b76b6d62c8799983140b6c348f9f4765afc07af6fc31c7d3a52cb4029fd3f44893a0a24d50abc004212ca7ec954ac94da9c0bec88d39a81016c934054e66bc1249e74b152229f0e51a4183c8a54382320aac9b8514445fb9a832a1c06da860aa2c9d89d69fc09932adaba43b81df51ba62cce1e9d3a8097c85901acd6702a3a642be3caafde359021b2fc6603906d9b7a612f811b58ff9fa25940476336af85eccff202430a24c9608d9edb45a47606d2f7e0eeaa1e349d008dca60da57ff222b0317f478e9913811f573f9554fa29350e813555710f293c21307a27679f9c267b8c5d1058d5ca9072b4030267ef218b12964564d00fd898e29d2afb33a7d0075c6ecf65b2ca2fa3567ac0e9602a7fe2a4f080c9a93b9a49ba3c95db0ef818546dd7064df144a603c6bec2444595d4ebb11cb095cb4a72f6ce66711c7041cf7c736faddda56bdc805327b2a434211bf09fa7314f87906fda1ab0935b47ecd574f4b4060d38f513aa2f79c5b59c053b6a21efddc9a8db952c180f12e26de6c7b87e2c1811d2858a9be9939081052f31497c2f9d4235f90a36bbb3baafe94a52bd2bd8a0932e765d48a14c6b059393ca9a83b5ac60fd4cbd0a3e4b08376d49a7cca2a30a4ec5dc935372489b924d055b7d49988e39890a36861092734eedac693c051ba92208d19ef89f33145c0b6898820fd26209095ae3dbc74bc1fee668427207d34c2229f8d2f9d1cc64879c9a8d8253dd88792354be4314fc6810c9724d3779c943c18b44fd4e32dea0e0a2c5db20ba235d2bfd092e7708393c8614c26ae409763be4ce58163a69e67482ab144bef7258999887138c6a93d9e4ae4896acd9049b2fa6ee3e32a5c78c26f85839ebb3c61e69419960a4efe51482f4d2d7c18449249172df622ec1c9143cb3a6a5aaac5a821149a925510a82e07d726b5ef2afa0f94070266408f393f963ed80e02f89a0a1f4d286eefc819164eba15ba134c8f88109f69e3a338d7eae7de0542da7de562b9129c6074eb4a63d95bb228910db03233fc7de4fdaf4938e1eb84c5a73c84fefa0993cb02ad613634af1c069c72da59eb9acbf3bb0f97c82767fc60eec06491b5ca3d8491201831675e03a8a75e79c2157254d07c63206a5936c9115f4670e8ca7ca206388460eecd686cc263c64d17be3c0dfa8e6e63af9164385031b24e80f2a47c9667dbe81b549b9574fd44c65ee88e106f3fb6fe7f70b2e8e18ae23dbc06ae44c3ea2d3a7feb46003934efb95fefabf3f79166bb1063e8b07f3ed77b38fab811321e58a1213d1917e1a98e42243772cb9a7bfa381b7092149db889a75e93370417bd0d4694f3b7333b041a8bc1a2f8bd44b3965e064875b2acd8999364306fe4ec99222bdbbbcdb31f0b931ad7c6442a08518388f563fc294302d790d037b22af629b0c4174a7e4d04a2dc0905a7c818d18a225a8e4926397fa85165ec01468d1852b560c92cb2aa5985482a50517d2a5ca936184716e145a6c814dba6b9fbe628f086e0e2d1c8866630313b0b1636c60021cb05068a185d3220ba605160a2981165760b466cfdaeaea6b8bb50019066861054ed6d85dee5e5125ea2ab0de952e89f85a323df4002da8c0569508caebf2efd42b052da6c0ebfb69a5dfd96b74a5c008b541837e8f16b4a951e0b3e429b5dd5947d4f5042da0c0572af51aba792d9ec009a54330a1326f94667368556d2079181ab891650c5a3881b1caeda7164f4de49bc07a0c399e3909372162029bdd2445123a889ae812b8512926124f25707d2bb12cc34f021b39078bb1d4048fda2381efcf9e11d7fa2370595a7a1f9407f5593702ffaf49e974bf6b99ee2270359aca6dbcb75a6b22f0515f84a5ec8b7eff10f8d29f6ba38a84c0c6b21d592f9a93dc04812b619bd12a757e3281c09d4c3a7b24d30f98a0397ff04a412b7dc9077c8e7977cf54520fb8f748f5fd67a1829e079c1e57b318f1be436807fc4911ef5c121d305a2cde955273c06e0a1952c896d702075cf95edc4b934ce710a4c50df8ab7c93b694bc95dcd1c2065cfef71ffd8a17f276b4a80193269824cd7ac9bb375ad0800bc1268594de654a6d66c107ab7849c8989105dfd1ba946c9360e9df587097b935686adefebdb0604f8b8b77d03b4f7b5fc1267da3b39ff0cb5b5a57b01a74db238af58ad0b682cda3fa94d0e21f27baac60b3630e65c164ac28d255b0e1a643f2dc54f1185505576ba7b3aa8d7e8d9a0a36e29dae1ed724ed525470273db55fe490ad969e82b118628c94276a0a2ead56cfbb735ff452701e528a112dc7cbf9430a2e4dd4d39eb37b8898a3e02a2fe535756ab52b290a2ea58f299d122ae2d6a1e0ae4774c49c82f60c0205234a63f013fc089946a8969e94a3e8095682870ca242ec049b3f2775a2e3a7d61c7282cb7173b668fa4e63ea36c1778908955384741e2f9a50d2c84efe37964cf06b9d930c15b1eaf498e0db43ec4b37e61fb376093e76c8912442fccaad5982d1c8ba5582df929a9ac3cc7d45a3042742c42cd974c658a29a04a34aa62043ed2da8b52451b220e3a75e5224b8d6984bcb74a9535a48f059e47be8603e828f29b2950cd13cfae8087e35457d75e27b758de0933c53afdd63ed298c60a4879c91b2bc736364116cac521a74288b7944882238cf9932af3289cade26825395af6a3bc9a415728a08ce377656804330c9e42695f431c5c43704972ea69cbadb7527e71482136b112253660eb23d842863b0b89a9b6206c146755d13a1a729a95410fce994d74d9d8e869d81e08465aee6d1699f441010ac59778cf92b850afdfec07936d7bffb2a15acf30393d44573d3362de84b1f3899f4f5f8ed5e755af8c0b5bad5e40bd97e54ca1e38bfd431b5edb607ade881310bd3e6eb77af21250f7cda969cf8e9747a53e181abde9cce844a4d975377e06ceb742b857765b4ecc09a4850d1939cd4b2aa0337d1dd4a3bdd4a448a0e6cb699aefd909a03a327eb5637269996037feda6e63147f41ac5817135dfcd6295f47be0c009fd953d6955eccbbe814f4a081f0b4ae77817379823c970cbd136f01d5b37828a101014800dbc29fd418479148976af81b111af0a3ae389f4d4c08a0c7da79a9a543594063ef44ee6cd29b134b268e0f55465ce9ef9b7ef33b03af2ba479decae1833b0d53157363dd2b72b65e02b68d357593793c4c8c07846091e54ea1bbf740c5c9fea335da23fec1403a7424ffe5c4a448b2ac3c046cd1959ccfe4566c0c068d0567b4104bfc07586e0f182bcc02599428a88f9eb02bf751593d2f47181b3a4fbb2ea2d85e5650b5c65fd20d3a4ef85a4a205bee295d41331bb4c2959e083e5f62fb10d8b55c102232c8ba5ce26bb0227b3d4fdd52651619a15384d1fcbdcb2d9e8d1aac08d4833952fc92a591915d8da167df7a4a64c3d054e7f571231674b0afcb6bd8898c98927ad28f0f9233306f118a3490b0a9c485c09b9d3e94bb39ec0f5c79c325dccf3f5ca09ec579b664b3781b5d12d66723386f299c0a9f79026ba2a33be043ef8a4281a456c728e12b898ff944e891f1e9249e0a3889853c7cb413f8804b637447e5fff09ea1d813b5da739067d79296604764c453ce6a0725e844ca000456037d4c9899e2775d7446093d0bdf5214534290e8191e32124a4f6244d6542e0b373d404d3d0be292e70b818a71e508020a0955a52ca2ac1c3ddd328fdace06b4105000277a2471c42017ec096674ada92bf55aed1d1a0003ee04e64d0a1f35e6efd0d0705e801e7a22663c7f1b8800b0dbca0003c602cc80c936f1253e5ba450e0ab0034e9dc64b29b5c69c357643074cbc8b41df69ddf353b7a00039e02e549b524205c001ff1d430711537c741670e1050e34c60e6501175ee0f03f0628c00db88b1eb3fb4325e8e5779c85c059060a6003ee227e964eeb9492fd05a8011be2e94f5a2359f20d0b4003aead455e8a36d3eb3139b494371815b8fd9805db29e6383abd6e0ed5f9172b00030718626091057cc8828b933d66f4ca3e69f7c1b1e3c610e368a0051fb1b0ac7478081e3432f880051f4b6b8a93ce7292267a059f49a72821c6f6c3157ca5c66c6923ed06f9b582bf2b1d2a241f3f58c1e6a86f4274b86afed22af88f3c42574cf1c775f4a10afefa46a78e54f57ffb2315ecb95d7896d2ec6b3f2a18ddac9b60ca7d349a4e510ea6378a6ade146ca90f1643bacd91d4a8146c5b881ba6695dba37a4e026b5f9dec56e14fc8d9dcedd561105973ce8cce9db534c950a056f6a5f5782bec9a0ef0728182147fe5f0eea4f70797793fc623e3fa1798289924d4bc7ddceecaa13dc7a2475f31141098f7c7082cd223429996983d2b13e36f1a109bca13a3e32513e30c1c5a08386c4bc5832dac5c725b864ba7372fb6b89d1cba159a47c5882bbfa90548a64f5163f8756a9faa8045721b46b497dfba0e91c5aa4b6bcc1f8e21af04109ce638c28d174ee9849e863129cde04914d968e24d88a112346bf10178f5d043e22c1eaa411adb316f7ff3e20c195da7595eca08f47f0df1b838cf963b6baa00f47b031e45831a51311a34a1bc1bafb687dbc5c9bc6c2850f46b0934c5dbca4758c41868be02ce4adb4bd493fdfae08fe43ab55501ac2e123119ce6fc1ad48990d32d09116c12c1f7538d8cd4f71e828dd949dbfd53cc0e1f86e0b4585a2abb0d19ca367c1482495ebebe6fbba5806fdc08c38b84868f8c7da8a4f024e25824100883a1703810808102e603e3130000000c201486429160248db465fc1480034b2824443e2c16281c2014161a8744c24028140608038160180c0884c2e15048201ccf84bcfc23fccdd9b69cdbc999e79ce7382bda9ccdcd90cd990f73c6dcce96250f9f0356c899d94abb0c693383abc7709596ce29ca2e9d82b9731b616f895c47837bfccc3d8f7b0ed169fade7f1c99303dde814deb1166c45d17335dcd2866080662750208a22d4acfbd8604ee0af7cbdeac53946a23355256678910c3f65c9854a1168be89b326a1661224fd6afd2d834fa7f6ba163cc780669085c05be215e24f785c3c2091c82a5b011009d7eb9d6810d19965687ffc01b79050cb0f5b5b7672bd90d49735ed176c4c29d8d26ff6656b1e3c5e68d6ccf32d42c88053d878cb4d89b356121c6e908fcc0d1bd5cad382fb3b985f4189e1093ff24a0eae6b9fdfaa5c7a996959b0743986eb3e77bfe4605f12f85557bcef57a853fb8c2e504163bad26ee3c3ea29dc52ec3ff66161d54e2d4b1c5b3e2b1d8a8fa2dc1c74d655e42884f4d4810f3bc45686720a124b49317bc4b00dd21d03b6a1336613f500a90229a4311fc3d17d50eb0280a5da010519193d28dfbc28a775be808433e704c21984d39b0c669aad8aca0c5806e182d8d867bbadb9df3cc3f86b525e4119e3efb0c8d706a78dfc143abb1fe5c0be0c2c521203af53ca677c9ba39e3cbeca9f2bebc27be75013e16e90f2092a199c3f5820ba5d5bac5913d05fd3d76a36e59f99f62c3158687dd53c9fd0d0f09e2b431be040f1436264a3ab96e5837d71dee86d59bb134156ffae571f766bcf11e8cf7cbbbf24c79a93c40de9537d1bdcf1cfd78a3c48f9d5008e8e819fc591a6ada7061db859d298fb06cbd5afe4de88881a8bb791ade8ab79f6fc28c1d2a15f31502527a13e44de07ae7b742f73c0bb357ef11f662e12d4432e6e2d6e105279c8059942ec486ca86b68539070ff4f306dbbcfb8c7f6469779a9ad6d6e460e0f52feb163274ec32f5c5b8c9815381b6604c5444de1d710bba30f9860b3a6929b90bcd9de75673efdc656e3f37b43bd4ad706fdde56e6f37843bc48d7add0ade9271a6ee3e7ea8e28d8a169d272a257e744752c67b9c5f0aee9cdb39a6a5d6a90aa9876c593a757dfb6dfecde67b6c4b5627db17d51a7852e9d76d7a612591324a962f1a4ac820d435cb2b47c6a3885148b1210d1152344927471f21a5202279479bd1ecae196a8e968b5c85bba4161d4103d0b8457b982332b1d19553c8189acb7927775e74317ac0cea48f51a9c552f9a8b1e799c1364f4e29153cc4d252a0a897a4a537a33a6f15869f05fb91614864694b76b2e641ce1cb30551477508c0e4932148e488940265835ca018c424be145e26d16c32e43082fb265165683c125a0171f9de345d0d14722bf73ccf4b5eef8122d7d0dd48bb5130da3845b20b0ce1fa21a9263f386e59ae48006dbd0dd2fb4101030163b313ad0e806b7b9135c8d4e8b36d2784b8b4ecba2f7e6fbcccb7bc7e71d0cb1288cf4d76b2f0555c40df0435082727b1ed7296cd0a83ba6c4df8d4210763e4ffece9e133f723b60a90efc57503079ee3f01ea559081746cad4dca70c00ea7d8b58dd8bb06ee401d05e25a05eb73dd78d934ea15db7a1745097603af90d5070b4aea9f052948fb361c7552134e496f19f0c34dbb77ce8c0d557251e7cf83215a122f935e5bc50db6d668269bcaab06e8297114998b432c92ce1d823e6783c1aae200af5ef57218fa4fdbf9dcbb015d3dec5fa2e8ab104889334ca906cf1b43a385ea9c07b2c09dfba501a262c88e36d4460cf7c4c3d4c0552c389c1010e92b78295a6b1e5d9495c0afa9a342b588eddf8989866462f8b5b2440cd9061b5c69132b7c48b483c7767d28780369438019d780586ca75b854e7d910baa21e6ba3e173eea11140c9b570b904fd41ecc560a217958c710becbd45d5389aded202876af974244a67c73952ad23619c2359f59b6dcfe3bf27b20851dad1a8b476a1b437443670d596c9630e547ff648a3749d2e00722ef2c6299394c8e993409bcd1d51553acfe093925723dea2900c7a55f6702e5f1f0a5cb3a2e8c8da7eaf2b330320861109db08ddc8add9f8b2359bb21ad000cf634ac2f598b19572b5d7708f19919632f6ae6ee4c0193252aba1ef3f8d4c441fb35297b165a611137747194e85e0883819076371a71099cc6adf9bdf4987f02ef182fae849bcddee61fa210009f1bcf999142eb03226982cee916ab5b02d44c8638000b246e30d3df95dbfa1be68858ae49e3fd0867190ea866edc860df2691ead54994a8555a2810f9e03a87b8adb40b4b81bb791cf86d3baad762f010aeed10190c80f89f19d2021873ef935831249264f3377a1dc9c5696c5c95484ec51fae7c0ed7a521bd037d182153ddbb0943d6f5440c1bd0ceca4fa4256974d0162b8b551462b1798ef7f3d5d5f44ca9d8686cc723e80a2c24496afa0f1d15133b6cc24fe824cfcb0e117cfea3abf962e31cb05af36e1be6dda2c07ec38d240c0761465fa1274c1a449b078c7b17401a5866d7a3468687e756852de462442d1c01cffab5d7f9e8b21c98e0b29fb214d56d44b4e6d41485d8d840ea2496a5dd51c30814c6f83c87ada6c8dd6980db039807197050b388d3433f6c9168949cd2d6bd8e0a70f29b7535694a600fee9b95fe98d8f1a6058cf8907852b3ef7ce25afaf81217188683c5459a21db11b15543cfeb47038fe752987062bd70956d0fa79660bfe538c4d10506ce825ca1ec9f18ecfa36c6a13045040410b2442bd5599307717502e0e697eb016517d8b090b497808392dc5c5a9bc8bb9d83fbe2f26606ab7520f9aa8cab5345cef62ea4796f45b325e6350c351528a86e3341311be125464182f4c566fbee8a3685c6452dec82941eb71c65412a74d56baadff13ab9b36d9c4a1ee4ab0575c83e8b488d15d9d3da1728f98bf1c840d621ffefdc294422da4424ba5e55013bcca5d07a3841724605c56df971d060567a16871405fcd63ae10619c3b8a9cc4f2eb4f6cd9182de961267e1278c9d59e06d00f5ad3a38fc3f19846635b4ac57707981c1b374094bb306cd73a02b7ed97a5d36822429e2c784579fda9809789b0e06ae0114ffd2da224e36f20126057b42f015905e4e28c09a4c915f4e2cd73f5ae06e0c45fe7bfd04b68f4267c235863e814c442c77631c9f9a34274e0b1655836d63fd7febf448e5ecb4e9aa1f103b0aa1bd456b3727e60278f5587faeec1aef32fe58362324bd29f6e4d061b7a9535998d0965b54089746c243fc63d7214d999f9a7f864c94e08ad517a298a654263eca4912262adee08a1b85a85cee0b35e8b67ab9c8e60216e5a5b67aef7004410477468d6126bbc8a81240518a7332a8a205f5dada0225f270174a03284325868ff7e2e03d05ba1b6f23533bf0a2aa8b73ed36dcc197ef27d2842010caa5538c60eaa81338aa1a559043f5658963ee5da999ab2847181ec470666b9ddc796797f29e3ab2270833f833991556e4b030611163d0ec60baac74a6faa4fcc27c226b87b2700c9e5a6cb4379bd3aa6b8cc9254b43eddb05e61c43ee4a91a1311891fe33f358e8da3178d6b49eed1ce3ca810fc8f4675039a7e6af4340a0e8440a270e14efdde9276a19776a26df890ee0ae41030858a7bbb4db02d4ea274cd846b7151ba7449874a4c410dfd89112d21f9cd127049c80c59dbdc98e8a95e8d72bfed25cac77c01ffb338001e970f2beb1e1a1c812977ff27238001b4d8522051521641e1e23e3480896fcfe198f6855ba8f995bf1a80e8bad7f4adc6143967bb1806abcf8e590abf26801b2244ed42b22fc25a3f248712961bece57c951a7e6485e4e4553c6ca8e61dabaf409bab6bb65cccf867e69054d0f621b84066e0f219d3f34702d9aa420139d0e421509e577c275e59fcf874c6acdbe1a741a6102e9f9464c478da4f748e9e83c6c3853edbcddaadc405b6e3a0bb8cc7f1d1dea915fc142bb8868bd9366b852fd7918f263e359a32d118704358481daf2149749c8e0003034d731cc498f0963b52301352e8d97f3528518e120c98f967812fdb5e7f95c63f57ee74bcf85af6a46e4d019e8a4b4318db5023c221cc603934afb720f8d4dd6fb2ed54700339a87fdf43379ddb237eb207ae32695bfdd68bfbc8fddec44cb117b95a286d37e49eb5ae809417641b0e7ca3fcfe6c6eb8ff424da114e99c39f4674c7c55376e0864a7e7ed14fec299d727f223e655b7caec63ab0535a3d14e349cd31247c70b4f472f4577851691f627052e77b25932965753d54abbb43e051ee0082c9026c74c450ae42203b2b47bd9c6880c284a0530edba2796dc8962b62155ad3dd2d6f16cd0e7036dbf80976396180a58f54e25c63a46b57cea14db74d96ab12d3c5e754a7e3991a0f3081a5105e3ded0cc4f3e83e9522a11daf3d8876f3b1eb4da137463fac6b2858bdfc14b1dcb80d0cc2dc3ea1e6c4c21fb0db448df5116580b6e05c40590d9240cf3521a4e8c2352f837302892e1a94c834369f51057c6bd385d786d3c97cfa524254632d407bf81cab69648308f9bb6c81c8b1daffecdcbc1a04c040d53b12e167491343c9244bd10ff11e5f2049c6a3621a5dae536c88de633c4556d5253f9d170516d98e0d5b654e72527d520aa0f16ad7903bfd25a5b1837c20d7ee24bb6e640e5cf09d0f98883787fb0cae54ca35f87d3bceb2f08857d634e990ff8b2a32daff820fda3a9423459f74c0e662ec0ec29b68fd39ea8c840160a94ce98cf1dcb405cceccea4317f8c473c0ea007198e6880ed9a8fcf4a83c2fab7ebc7be473aa0136eec07269d701849a0563825409352a3b0104a167275254581b92f503b8c2ea8518f386c8b19623ac78d146d58447b1d32fc08a355c93a9e77e16e99a9ccbff2593a2afcd7911958e9c2a3aee748522a3927e5e8712f11214ee84a11aa37e3a19365e9fe1746c86a377a96207a4615932a55eb100ef6ecde046f73e6a2a5b309e53ddcef26ebc6eff80d1e1935d93590974c0f1464dadf78ac48c95ed67f996f064bb784496ccc348cbf448aa313222be76bf78f292e4b81c1759dce6bb36adc3548e6825e20dee8fa622b0991e17915b8f8c1fdac02257dccc73dd8f002ad3061af9497b795b4d80b0084f9db04fe7247c9c0ffa97804feea0a05bd04ef0a0d7a6287c003033e40aab411300e60405b63ce460cbb452481bbc0e7c4461c193649fcab96ccb365aec8185e03c7c7cd79c094ca87856ea12ddc224fe4a8652c8a4b7126d55c0a6b7d70d25dd3b9e0711489252245dc9bda42d29c1290e7d5744b9225d4b01246aa98074f3b4c08a8adad3d23eae3cb180425d25d24e5ba7fa1392e3c45e92c7298e5a96ca3a719510ea523a78bab45a4c5d484f9ce679f5c7e26339f24ab053759973a37cce2bfecacb5361c0c0bd66a9fd3105b61f8e6837a87f8a2254a290ea10a9fe2d1aa7f228595dd2fe6f670b2389c9baea04359da53f024271ef25fb93fa9aa5be2662a96fff3e7696a2686435b2fa4a152f89a0e49a7cada4b30ad8c48fb003fc8158cfe90d24b314a0efee034d51f831a85f8c61e2a596954d4d70803ab3f3ec1b4d73a4bf8e55ceff43120e5c184d88d16054f6790590ff38ebf95f2201ec106305819f1beec2b43288995be639f3cd3cdcece819ead019ed9c7ef93eb51cd0d6f8f755420932c72769ce1c4fe8f14356b5973fc67714335cb4f3ec88ec299de90970f5dd73418865d253dada3aed3f96b829bf2284bc8cebe52c673a8f426b1888e493ff4cca36103a1009f3ee2c537e14fbb89d81313347fe8370035d514c86d40bcd159683b6053302ff9c96d679a30d68f33e669c78a1dccb4f0320df894e9a9b54f462d27ec08834efe3e400d221869df9cd1c220c1d7e235636327b4cdcc1d085beaf1c2113c30cd4e495f32e2bc5cc99d1bc637da41ebacdb543a2660bc70f20e9df33a1ad3566dd64a21b5475efa082e88b0bdf3721601ecee0025e3dc4deb67907de0c53efef0de38b020d7a42e71d4c8898673d0e1125f36859e1f51c1c6c185c7eca1c289c5848350a435c048cafb790486545e2c1e61d0c5e7071b13e7363184aba2434849911e806b327f01c4b58117ad9a256c56112184b25ff1187f54210d93ce74256f0f48ef5393044dfafb6751e71d80bd8822b506472b54caa1199a8817f15dcb0165e31a1a9039a00f9797536944cfbffb99801671d38f2e91e39a4efd422a11d0d8715c17562f42613a7461f90e6c42f9a74d86309d63c1c4e4877bf145f5a7a25256d64268cedbaf2c7661ff060d8207405e31db6c642717a6316b8cc16c27e944218dfabdcff02df4ebe2e7e7165934937e983215e16314a0a8d79cdcc05286cb6cb894de0d24c0069a9d852e14bcbffc6077234a2366823ffecb7f598eeb98c6ee7039c5a890baab20df2a49e4b2a59766d26480ac8330726356198778953cdd4b3eabb5400e8ba341271c30578f3f7a18a7a7d6dc6837beb0659bbf598dc4109112b7251148c97a06ec0dc844dc50f234e5258b828d78a6f364ac3261e2d2a60ba478c32af82743548901490f42eead5dd515a1f97d7a11704265f15fb8b7af19608aa9fe8509069d66c172e09f8291af272c3effcbcab6ab9fca97076e60628f93afe921a0b7e52b3748f14d5e1e3491281a5621d096f04a066f9fc2e306481aa260acdbf4067db93ca7a3f06be8e6a61deb5a681befc1d310b60a86c2c443a03c720aae06a260ab51bae780a53bd0222ba3cb4f927769fc084178f13aef04b12f5d1f74e43c118a49a0d519508a115f5541c00fc904813f3300135cb35c21c806ae3ee9111634d7f9d8f3c5750c4f84a06b5f3c9e8744444e590137f527afc65c7a02750d0a08028c3321594737515e0235dc67f10339f949467c24a7c3d7e21eb99a524dc37867bfc1af616ae3613652010d5cd4d05b67e0b2165a472b8e07e0f35a4914234747f81c67fb88684cd24e66ef858f545da8249b63525d37ffa641c20c5d6bc0c7b14e0d3155cb7ac6c0c5bd7955de2430101f3daed09c603d7350df9f4c09a813579cf234f9feb00117b9507bffa46135451bd260b384aef457b1bfc377943099bf87753ba518e0a2795d583b017f217ad58e18ab08ef3c2757d81348959b1630a97cac9c233790d84ddcbd94a404001295a34115cd63ee9b6201c79d720014110c08f40664d240566c2bda1b5c7bfd148953a56a4f16fe1fad1a26eae501b49962a50157555bcced0460fe98e3ec22c20ad98b7c8aeee7c284df811bd5e36d021a8defa91af1177e25391ebd5e27a6946184ecb8845aaa2951f2370586cd6cfa5fb55a6b6f9539fec900388af9224beda6a9c2c8bd12d56f7431dbf5a701948eee12f1a36fee9997f7d1067ef4accef88a92088a254f5a39287927a0af24c43f9d9d54bd043c404182d8a7eb26a7d6c5406cb700b7b47ee9d0f21d5bb3fea7dabd72a92a41f5b877318f729aac74abe9160a25d123c13af47541a53479e17158cbccdab65970878ced3a0ec1bea7c997ba7e9f174d73bede04133368b3719b3da7b199f52df3696e6f7498992c79b6561aef1ca30198f2338862f1df0a60a61c10156025dc54297d3ce78d848d3209c8f49b24dd8a036f7e6f96b1755a8a19802e735a6fcac53c7fb899137b083b22e5edfcf46521b0e6530995ee7ae497010c462ac6d2ebb119a04487be53dba42083180fea1454b32bf2dc165dd439301729c7d0761e49dea2717f64673411f439057300b270c39fb61596b13d0c10ac48a4cbaad4a80c7ce6e4f80ecfb72a8504071bff29f75dba42709c43424583f4f57a6390c7ff28c4dd06b91eda67e497bfe01a8edce4f93f612149436c2368c82bdf9b7426716ac4fa1cc5e176126f9a76516720f119d6637f51bf27e1efe978aee0b513920d151fa2928031df16644c42b622dd6158f8274e2512872bbfd6feec1e0f4215e0995db5c179d4924bd25543a7bf9906fca12504fa3a394d413a56ea2c47a4d492c343f1e5b2f90241e66455d70d44a01b214061f6f862689c75bf0d80b1ed54b150fd5be1ef1757fddffc72716ba1fcce9a4f62872cbda99d3a80cb7f213ca5356ee6f36c016c52259fffd302f28b13cb23173f0aa0030abd1412f6d972ff5590f8d67e45fc7bdbb6ef9850e9b93b40caffdf968b97165dcf725c360df884d2810084e85584c8374c4b5c6f59b75c4362bd01d2ce02d2e8c9d662b640b0c0bf76641ea4d0b637b0a97b2e958f0160bdb7b17062151805156602f7013067b7541e85119467240c9124e239861246fc75108cc77596c5d5e63b143916f5e221175ee1295ceda8ba483f321bc5c275aed647182b655a0311b7fc4da579f939bb29e154340e7468adc46f198c96c64ba9e3914954704dfd6f831cdc13da1f1281a46879db31a3a5a9afcd38ab73d52521ed4a191a7df8d845c3b2b4fbc06585c322c4e4e0a2c48fe3833cdc6818b6f02ea9cadb61619c8525302055b594db7de4db4ded5b1e8442bdbe73a756c65d56d089c9535301867813d5c8efce87f78eb745981415a0963208730d204e2b912d1627c7a48e4163aec994d160e678a7bdaa9ea4e8659b924114cc5d9270d57a6e4ed1f34dc5889846260fb2b16420688ecd0408268014ebe2600eab0f03a790612183687b195f9f6975fec47c3146a7f816d1d1b23dd610a23acbbdf419c90f19c8f7028fb0f3b1c9a64a25cc2a7944d9bfd29f76aa05473cdb075de04f6a1ef2b809d816080d885c6036c25f7d26f9e903e1c18d9a2c690f2648d8bb050da8c4a2e310a61b3e61f9cb08f7fc46528ee248d68174c490fe837129014ca4e0ec3506b9f0efbdc38cd5b39be743d4a8e65d5063c1a880685899f465b4784a730b496863443775f0351153267d71300d5c79013346b800889fba4d8ee1512c6f92b317e50d753d76e4c373c4cc2e10cca8ea7c2c120471e93a32de5842ed50479e062816ac6769f781a2a47fd5d25b9dd7fed580f473052298b8770e50d566d2f9c0c8ff2aa036f7d6a48a1a538a6258e581a5f0e2cbd3fa9a0249c8d6122b60b6aebc811d2797b44cb80ff27825e2120ceb43e045140449c346dceedfd4f5ccfbc488d65ed8e282522b6b2946f00fb59979609db58ea6d03c2569ef1a1340719cf51190368b557ba40fe7e21711349b696b1dc0012241c428b9420b7c8811f71c35648c9da23ae92f952f8226a848ed611deeb90a5e209ec843d614df82dbc0a3fc2acf05fb8164e0837c2c21ba24cad43042d08b6824f43da41fe44ce9a6bd66a111c7ecc8a84100c0990f481cfb0b0754382a2fee9bdae163e7f2c24072fa4ce9450782f33fa58c63eb75bf7e2c420476291243c88091a2908a405e1bb17f54f675d08ba7c96204fb097dc26bae259b41ae333a5ecb4be0415020b24eaa09301498f69898642326b1d2aec9755f26846ee8cd210e5bd491d26f8cd808656e44eca690ae33e9b6882188fb299327dc88753a326de4eec2913dc8e5095d7dcd963872dd4e95cd56468a83bf42586b56803cb0063cef42b41c5c863e691d22102acb329ea2d47f5018fff59caf96ef219e525abd6a29599aec65dc650b04c327c1f454af352beda3a5e22ba32eb0fd7e44d34fd07b5d2b311def030f7caeede5acc3eb5536a2242406faa2ef235099680394da385e27887c3265959f760f80980c611fd3a9566627a32ebbe6a165d2c00d84aba57944f1ea4cef4d592179623fad97d2880e600e635311233b973952902bb62b658a7c5184a9b21b370b8fe60d56c3236b2a00327f4dc556746a4323b0d17559d6fa49878230f58eb4d01f3faf44d67e5009c7f33dc416c018a58c551848797444988cfc275a8bd2da85a363b0a366d9a52086722cfec3b418f8d4702f636938caaa574259fea6148382440c79c528fc09190b0edbb0b9cd02c8dec1fa66797405aba8d05a58328e3ce3b37804b24300a9f3b875a2d8345be2d0c30d9e2e40a55a5e0760de9f02a66299116412797f21adc770ee9c3e5edea62d19306284a0b9fb72c65f5c1d14b54ec9cfc9a5080a5c162be5c52eb15930cb3faae303323fdc3ed1780bab1721fa05c9b72dc1e01a1c55dc7bf16a804b31c75b800dd1c6df8ca914b40022f0b26130c1dd8083c79fc546fd6f8eec49113e4ace29fe1dd1b40a255c412c0986827e8ead4a25d0b36f993f9e187574e9167adc002ccb28fdbf0f1643a3a91621fdfc0d7e7de909600e8d9cea1b92abde5460f34b0d313c219a13d62137338ce96cf2c3dd6c07601270d178d1d95e15d042d8ac35a5f2f0aa294aecf4c2a681fcd1e92da2e6b5081f766f281bfc4d27af3152b82f1b1427a608da3dd2751b35b1c6f9ec44bd57036974ca64ea777ca0e7c14fcdb91942455d7dd46300c973166ce03631fe6bc8cb7b801a0a171ea0c086b474bf6786d7462ce501a4161b1cfec274839c29599c99eb10b2542a10f52fbecb082e9ad4b52657afdd8670043a599568836db4903b1f1b225dac8686c7fcaec5c47dfdbacf94954e506fb6013f8decf2620b111829b3902b0b1b5035b2d77c3d79ec9661378b51b25d8016c670a4cd0e68813d9933f8d024e4d4eec4ea895fdd6966ab3817a726cbaadd321f029015a4f65bf482190de98a213feb9815a65caec141e687189d56712608243c6982c7eb0109894967865003a63b1f83f84f39fb1031a1662b3dcee42e2162940d082a25bd3b3513a31b20c2530e9477a4fe9c056a49f9f5ef36461daaa946f289485470061560fc4b7bc110253332e90621105bca9d8d9b386a7ad1a675b15206daaa00a2887a7558d5e9e3656bbe83bf25e8964558dbdd2344a0d7c7ac3ce03750bd054a46fc29e8bc11d97c13cc71aae8cf9fcd03d8c784aaf62f39f438689035ef0f96ff406b4e4b98473cce6b9579eb16ec327bca6bfbb6499da22364a10312ca2bdc5b08344e0e1838797d282b8043aefdf2611f84e3d717e06bbe1f6a6357fa453852d4a6407f4f52ddd4537c6982a9e2af7c5901d2c43b1092f0b3819ef564f37a6a04a8d4d81a1fa7a346187a5ce904d719ffc6efb74deea9ff6106e4907577022cb1868ee833b23c5cb608cd7b0fd308f207e4b9491538069991c3d1e00861801efa834f6a89de69b647fcb9e648c231ae80cc31147fadb619e1b480dcdcb43b58c1cdd65e0f8a25cb4e25cea6123bd5ca4b60eca7b0a56a92c4bce58463ce48223e21de84747f308097df3686e91605f7971e1e108eb7b974b29e48a93d903d65bfca9557523a3140b35d7e12bb234064d7dd704e9e6df68785545f580356d1cbc54e2e53ada37445e24b173370a360ade6dd16cb994b1cc358c9eae0e1a2b26361b66ca45216dd374f8f9d13f6b8f871bdbb9de2445afb3b04104b479fad1779449a092b9f154d4302cdc0b02ac5f660fde041baa3162988bdbcc002de380e0bedc3323d07050045dd3c6beb68208850196fa08e75719335321bef6d8bd7a22b784f4e1712167cee0e471223c23a5c776ddc9249a5bcf4a71090dd04e188f7949481e21f33ef96cbc8c2b96db23b55f6f6358347108e185d2e4f93f0f1120aaaad6664dc4079e945f02553df450e07a40e5f8ce3ddca2ac00b6fef4e44e6a805d241a167ec797b702a0880220491597fff8dc17b098f00bbd13516c9469b39182610e92e02899852cbff53c19325697d34d573cfc48c76771155b178a3cc8e56de086fdb830923674d9707a3186b617b29e04466c919a8e40dff20c41baf878c79bb1b11c7ad855de0864a0d5b7200fddc769a6364a32d9c922c56242609419430db85a12518c273ae4f42d96cde2c90d7ce90f47b92d44821743f443ebcda91c62048588b59c67db69e7d45355e3727cf0e42ee7a87382c09f94631427b910681c5330aa82c01cdc0767ae4c9cfae5467371bdd3aeb85b2ad2ce4f864a9db95ce6d71ce22d22188cbe5b4132374ff52f40495c1e914d66e03ab65cf49f79dae419102e5c47305c04e98ca4da7c03ad1adc0ef4e3f841068dc861f24aeddb62b85bb83884f1aae70fa0d6100b6a087a25ae0098821562d46db8bac21b4c62a9d093abeaa546543429f02ef404f1a7d32a343cf94f468bc9798a594756c889aaa314beeff83a9a44de5efcf9ec528b738c7ff559be327244aadb8b67bf8868ea7a808a9767929634c99556563cbf7a72813e570ddcca3b8b6ae791702e38d793270b2426dabf358627e4d78f777969adbe8af345a845d211b3a44fb070cd139ca575ddf27f2d25f23b67d48444357ff888f60008015f90336a8d59969c005e0cbff7686203a95207121f3ec5f691dae75e29a5fb83a82d9fce81cc6e1f641d445380deb97657089c741218ddaf56d3b1c91493041bd1aa3386feef390d8f724f0c070da501787f361ea0be9914f7b08de820ce6d645199cd232cfdfd5df43f76d37ded55b4c512dead744f18755f300aa1676cf627a08ebb10e0b5645493d57ff93381ee7efa7eabca6410d49666e884f89ddb65ce67eae91725133a9cba5ccae5f4ff8c3ddd9374e14e9be46e510c54cd9abe842384b8973010117474ea30c673f0e0d6928b5ab803de511a18d851dfe4253c6ba6182d9398c2443fd5d26954fc1c60ef59aac3f7b9ba9bab19796e229b00dd517d61ba51a1ec230af124a97fd046ab2e9282a8d14915145020663b0634bb8f8b29c0a0e86c23145514597781bea48cf03f300daa13dc0c5256806f8beb40b65fa3f8503a59af32ba7fe79939ecbc315fce4f73ae7d539fc51df5c81f208094012c89023e1bc4920a3150b46439fcffffffffffffffc2836884b6196b5f2699a4d43fb65e9f93292599524aea8a507fdb7bb1adce6bb700705002370ab70a2a0b6783f633402006064ec07808a3a48a09795f762b7b3b7018c25829438599f9948102331e8d11b081a310e628ae57faf7251fe28430560a3955f2e8312999580d1c8330b9a85c29994ed23e98046112426bde9d754e218a0261d07d7969a132cd4407104693e521f7d357d7e40fe60ba2e53fb473d4b2f8c1a0f7df345674b793d70763e86041041737efed2c1f0c6bd97abda71bd6e93d184497ae9efc5c8c9f9881430f063993f263296112dd1603471e100d0e3c1872492a49b12d6b2a5d068e3b20871d8c132f3b826ea7856a1403001638ea6078ad98aedfd9a225a7834955a4eb9a373122c77d1b9cbe2570ccc12c794be95eb864acd982430e5d8bfa49b2f3ccf19a0c573150b0813478607860666046197130fe7552e3a1974fdfaf070e389842ee11d52945d7f7eb0e1c6f306e8dbe9896f466a204898101316c6c1b38dc60125f5ab6e106071bcc7d7593ef53487a13101070acc1bc9ae57741d7a5d21b047567dc020e3598d5c45354f6e3ed48c958ab71e36f50461a36520d1b67a41a957fa38c1dbc7f192420f63ab091032788230de61093bb64954b86771a69f49a064ca08292010e3498b387c52461225f83be41195380e30c061dfe9e2fa4b012a5b4c1e9b7810dfa0635920d1db0251b3ac0097098c17055f24d25a70b950f9571018e3218ff928509db5056bb93c13022fe95bca4c492c818cca9bbb2b7544c072c050e3198a3e536e1f14708cb3a0c869c336554cd4704638ca154e00083e16db4d5271d9f274f38be60f894945f9dd6923eb91a26070e2f985267c7e40f2a2718630ce50347170cbbebefa72b574fff655c000b1c5c3057906a7f41733150000213ac81630b465739bf1b09deb5d7c0cf000187160c2178fac64d9e4923e1c8827135ecc297b84ce0c082c12ec7df8591db298538ae604a5a44856eed2748638c31ac803c930bf1c55392048e2a18c73e575e388d3d1351c1246fb174ef6939a6604a634244106627cb13a0148c56aa74a9724f0d237044c16416f1da547fc4fd13148c21737f36436f434d4f3007a1baa7f3236278de09c6ebeba4d7e72618f29d0863ea7cc276ce04d35dfce533a14e657909a67abdaf0f2b17613d4a302515d45e5e11d2c328098657fb71fb2072b86023c1d43eb69eb49e490e3a828d911c46e02882f9b292522907217663250229824ee710cce152cbbe49eef0d86e091c423059ecfb750ed7dd49b5040504c3a419174f9d4812820c0cc35f28ebd2ff22ed41c55cd0fac258226fe4dd30f5c2242b2cee93887861eaf91369e3ad257476615041d72bf2a90b53c8ad203ba48d94839d0bb27857c8d6a6ed1e63d973f4c5195b3109e38db791831a4b06a100bc26cc7b5d8d7c0b835249453ce7d71686fc513c4c8749a6c5ad85717f84cc979b1626d9ff9d90d35c3ca9b33059c8b8f0105516c6f8adc94959c82657120b73b00ea33fe8242c0c3ff163c40e93d542f015a60e5a34b55baebfe40a536e919ebf9f43c9cab5c260c9266dc6dd5cd28a025861d0cabe52d12ec53dab30a8d9114ac7fe51492e551844a6bd455c3f1559292d3fe975428521dfa7a97e855c21994e610a23fb22a27fa776c9146657b3acbb5ca6564ba530a5ad0cd1331e24a94f0a43f851ba4cedcd24ef4761f2944d5d52e5a5f14561cab75a290579288c7212dd84b8bd8bb183c2e435c2528c2c132be29f30bdec7dee2f1d2996ee09d37e6f558ca4d309e3a5668d50677db23c9c30c7a9d23fcf3e56a9b30993d25b39450a61f683ad09739a8a093a6974084225135ad70861c23023f1b2043ba9e1954b98c56554f6c92c215ac268651523e71257c20c5921e694982961708965563a65ad09f224cc7e966c7410af2a2749984f6915356b3d267a244c324ab456f81bbfc842c22897bccff28ac7fff61166d1eea0ac3ea7a4e408e3248addd908437e4f759e57216c4698e4979658f2751127a1bc3c8408524598724a1059eceee74b4d84513f449c7017f4e85111611eb9172e589ce8f9218730cebd5d9e53223f7c8821ea1b359284b4904298e25fd8ab6f5d8e242184d145dac5f828a195e7208c25f47da49935152a8230d998aa88b6a022693110a6549e4ad47f29b32002c21841cc6bffff07c3ae78ab5ebeaf1ff9a130eda7f4b3de0793e88fd65fdac34b870fc6d221f7e2a9f76048fe313c62877f5b4f0fa65879a62f25793089ffb7d3e21659abc38321d7e4ce509d456e7f07838ef2cc0e66754f2289b7eb60f4a03da4b42cdd4ae12328800ea6ec10dffad91ead3207b387d6940fa2a5c4dca2003998fbf24452c943e26048dedba17f3412a4a100381872342de35b6fb9737a83f9822ef5f0e979544e6e30ac6ec9a888ccf5d1b7c1a443bcefbd9899be3e1b0c56c235363cc6f885d660c8b9f9e94ca538b1e36a308d4895eb2fea6930aee47cf1a9ffd3480e1a4c419c9ff9aa256db13e83d9a468c93035aa92d56630ccc752132929cb099532982607bb6b13e299a3420663878430a6372a5a5dc660f4dc29463c93c560f211b978fd881bb286c1385b51422a3d35b925188ea12a1b694f5f3077aa7fb76a7fc88f17cc4976bd85a958296dec82b992fab64acf3f9ec305a35795aa0bf5313ebd05e38d57e70fb95c49755a305e3a799eb3ea3afd62331490057387e4b69792d2e94fc282b1ce3ac9f8f824e2e8af609219aaa532defcceb702e2773c96fe1155c17013f594d4ff3c21712a9884d6c4b4d27fe94b5330e80af627642b05937cedd25e9d4c27d95130bb752cb3ef0a14be74332f215ee509865b8f717146b632632798f774cc12fd9eac83b609667935ed977a32c12cd721844b30b5b2e112cce925d6de3a68195109061d52e6bcd905e1d725c170fed1c727f9aa9690604ad53152f8ed9e9c1752c01130533119c170a942d07d9db37d9e8a6048c27a72ca257be3f40a208241a28ca88a91ec29e7153004a3a96895537f4a59880284604a9e7a3ec5d472134ac13088a50b297e47c0305d4af2c182d07809fe2f0cd739d4e979331dfefac224b353a530b7f6c278313232744f5e9842faecc5d83995f3db85715de5e6f279498c5917866c15c53a56f8503a940b53ef4e8aee2192880be2c214645e97e81423a8945b983dd6fb920ed726c01606196d73f772511e24a016c66eddbae461e634946861f0cefb984bf75039cdc2a04c58ce963c5bca7564611cabfa4c11722c0c631fe729fc75953861619411ca530435aff6ed1506f9f3a554541235b62bcc2dc122a41ccd3071b5c290a3479a5821ebfb618549fddbdd53bb7fd87e1506cdb8930f2a5bfa5d15c64c4d0941881cfa74a93045319d5efc42a830e9b85fa9273f8541f25cc85cd85870dd14a618e1d44ebf530a8350572e661b290cd1f6dd763dcde8708fc2144edc4589708bfdb6284c7a31bba183426190dfa1e6d2749e561914e9c4cbded922fc09935dce8e16b395728a3d614efd6a3bf2e2f5aed2099356779ccbe179d3b39c3049d4ce92266fc298b7d6313ff5cb6435618aa73aaf6d24874f66c294a447b1d4b09c53b5983025b30ed94a5bf457f412c6dc52625da3a3a65ac2e09f442e91c4f38e48254c395da570e96927344209e37dd09fb2e53909e34bfe78a6e22909d32789332af983a57889846946470d4f199e119c10f7d596c118caf4f2ba875fa64a06c3ac794839e1ef434cc760fe9338b23ea204f5a71850296c961695c530983774de5fe5c748f20383d1d2b8cee7ff0be62496e339a8a4eb6e73720ae2b36c85e5d105a3c950932ea9d86c2b3db860b6d149c731d3cdf46f0bd97552ab164cb26eaa652b5ee66264aca14fc306b2db814716d0f1f3224c23076714d3838207164c65256e94e7b42d3cae602e65639ea2468ab896580d53567858c194f74a4df8ab2c964c457854c1f8d1ffe2ab04ddce122a98cbd2c80efba78318a76010b2ffca76c7837b09111e52307e89119b76f9fcab838228182325fd9b955216f0808239c78b9e9f72f48f952798e5ddb479d0179961999d8387130c3329cae51cd63bc96f341924f06842422fcf621c030f26982485cacf7b48a3a3843c96607a5753b31234069f87124c51547c3cddbc637cc85813030362dce06d604c108210f095f64882073c9060be8e707b3a3df668c97dc1e308c6fc7cdb17ebb81c3f848711ccd142463df582ae24d2078f2218dcf334846bac6f8ef2e0410453e7aa4a975b1a824988bb4e6ff11082e1a4ee894a21f4c54e308c7dbb9643b9db48f081618a37b12e59857e61cc53162d5b12b71c725f186b3ed552c3fc92e5bc0614111dbd30ca8b0e49bd041d7288f0c2fcb7b26f21780a964cbb30d90911b4a4a02da8ef7591e75cd92b9872a1e5647fb612c7854105b311b9c27912b2dfa21c31f2a70eb3a0c316e6be9c5417fc24574a1203033d18630c5344472dcc9d35dbce9456684f6961d02968a8b78549299a85c15625260b53ce49a7d873652c4c3ae5ca93ccbaed14c2c2e069da74ce64e5f4b98e5718bbdacf7792fe77571dae30699af4371d2a3ce7dad10a434cffb8dc69647f7d32f6d3384304638cd1c10ad3f864356bdb5c0997d3b10aa3e5fba0eea49e19e85085e174e8f939c041a331023c0f74a4c2e4329f7b2c8ad0b1827fe84085a923567708ba7c63c5e544c7290c9ee6f24254ccc841aa91c68d33c8404d7498c29436fa417c45aacf3db071c6096eec253a4a614ec173e62d78e578925d1f3a4861eebf35f959234ffe2cd101d1c1758cc2a4c39d48e695547aa92c0af328e195b2495d0c1da130689c27bbcff2f711ae403b40610a955eecf3488aa1b78e4f1824071d545937de0639b041b6c3132695b835264f85d1a771e34590fa848e4e985e23453f51fe196798e0d4071d9c305dcbaec7db0f196bc4522a2303d9b10983f6a94b8a569d674732d68e8d336e9cd6343e043b681390232de8d08439f27ff220642713863989f712a29fd26562c2f4c94eb2dae9507fed1206dd79424a8f9c3aaab584aa23e62b4db850072a61d2da2ed692844cd94dad83128618579683b02c49e19540c7244c62419c4823e37fca27634d67604619356ef40cce6a7448c224af575db2bb3fde8f84e1841ed562112b749f206188233ebea894479867c4430425b28e30c6964e12b2cc8d3027dd2108310bf3fa3123cc5d2b41ae04a1e5aa2dc2a4de2ddc27e6841cd48a30b6c77f92e93a237212619ee41255b54584b94aa5646f7934d0061d87304dfe9027e6892779ad210cca2f0511b9301b3b29842959ff7e8ed157f33c210c9ee3e792131984399a668c87b06d7d16411864e4a598b33810a653eff944673e7c5e0161bc4e3aac94bef422437f30be75886a79b0cde81bd4b071460d2074f8c13cd79ff695ef1d731f4c3a7ae3734c5d7c9b3af8601eb153224da7875adfd0b10793698951e93f7e435ec618a30c1d7a30bb8952ba9245ca65e7c110d79385c8e94e2733e1c1bcf93d16376542cc10093aee602eab8a15254f7630e959f96c48899192b6a30e86a0b23fc71ef5cb693a982559306de95547a890be3107d365f5f021e7b782fa7230460e21fff563bca6280ea6b9601eb7930eda3c380231306028820e3898fbb44d77fa88625f7983b9e3267c7b753adc604aeaed6404a196efe28e3618741cf16f3a5eacc975b0c15c322a5b6a0f95f8411d6b305d57c8cbc147fb5dd5a106534e1777429851c971471acc29b376245af09c67d4810693b89265f1e2d67106731e0f3ab23aad7b3a7598a1a30ce6da8e961ef9e62fcf64302755af9274cb8ba5948e319894a5d457d9573d9a5087184ca6e25e59f2bebeb07784c17cc97b84ea297580c1dc9e6309d9d1449e24ecf8823154dab0681ee75e6387170c42f99ce890e30a7474c12caa62c988ab7570c16ce15497752a756cc124776fbc453fc2850e2d18af5ef74d05fb3897ecc882d9c4086175fa43b0bc93b156b2091d583078593ce541e92041d664dc681bdc48cb29745cc120b664bd8fb0a07492c6df60247458c1249e9752be824856e111dbbe362263ed460dfc8c8b4207154c4ae7f34a7491ef9b2103c10180091d5330c9deee284b21edd26a850e2998d2547ab31ca794fe3f0a86ddf2c841c72c31f291a1030a26a12a28efef70161d4f30d6571e7d227a6adc103a9c60f6d4a347848409b9e464ac1513424713ccee275e4b54aa850992b176b68b0e26984daaff4eb0cba3bb97e139406f63cd3a96607cf5908210da11a14309e692ffd68cdd8f5a0d6446d748c3df868d331c2f0523400108c6188334a22309df46d01e420551714400f0840e249842fc3ec9ed18255f54888e2398c37b12570949449f91fdd0610493d23616ef2f8fd277923d7414c194ac2e2bfdd9b67ae8120f1d44308b4851b27c5e8e4a7a1d3a8660f8d7c8edd194086b4f87108c592167f4ffb94bce81812318c6eb30c2e2538255489bc0010c773e8ee46f512612387e61b60a539dd86eca26cbe10b47cb9caab16ad4c0cb40a30c397a61baadf06217c6a485928c355e9894f6961c612732d65e0767d84083ecc2fc966cb764f9cea582347270460f1a0417c8c097610305638c91460e6e705217e6fd78b23d89989eefb3326ca060066694a183336c90a0ae56c0910bb3e849cbeef87061f25c953c67d3e9d3ad5b98635bf0cbbfda41cdcd610ba3951ed39da487ad7a6a610acbf38e60e1bb744c0bf3b55e165521b48fa924143866610ec26b525239fd39aae39085d9de544bf4b2da4a411cb130e8b855faf6179f4212072ccc398654911b59626285e315a612ad4ed656b6256b0e5798f4a7f411b4b3f5c511472b0c2ff973be37915cf671b0c26c2f42eca8a45444876315e66d13fa626dd35694f4c68d37430f8d326c906abc0eca4011b8a0060018c1a10ad3b6c9a7f6df6eddd2e04885f127d68358c5b67d97a83064b94f9f2646d0959392e31486590f49e280c314e6f46b4a59104ff1692e85397ad22108f70bf9107c3446200606cc18811818e8c018637090c2f8f964a8a8898ec214d4d57a5f885887958619efa2c83cd6fe509834b6d4723c670f7080c2587ad243d076291f1232d6d0b6031c9f307b780c612d2f7a47ed9e30a5bb1c1fbd7119a70c393a618e3197191ec2bde3be64a0208b15383861ba60e931c7b38854934d18437877140fe1ff276263e0d084b9e4e64f503365c2144786b22bd3bfc08109c32753b1d2449aabc0710963aa9ff097fc1de32e352c6132a1449f0877f996304725cc5f9574ce7f2ea38451ee2eb6fb6dd44426b1fa9998ee08faf693b1468ac02109e388ddd115f73f1a9130868cb8723a1f27fdcd0109a3e9f0ccfa0d353a35ce40c6f10843d2ce12ea16ff53ce7a60e3735002fc0087238cf1d9b2875ce2137034c27c65daa5df7eeafcba4119c8c1089350a224690ba14347ed171c8b30c8336d51fab4894990220c23f52585ca3825a3cd011ac57024c274255b95c389c958eb341a751a9d81b3438439c4d39c471fc958db47b7349694868d336ed80dc26883594250dbe1c43ae80f1b4c6147aa4593abf1c1b20653f64b951f5613c7623518bee3dce28abc9d531a4c924288cad0a2c198163d480b5b9fc12022e6b283f97d4a9ac110abd2fd7bd3329854dda4d86d12321852f27ca3151e4f98c6600e537fcdcf5a621783b9de47fe23c9ffcd1806f37cfe9f705142550583d1de4b46f768651208e30ba6204743ab68ef05c3c758b270739bbf6417b0ce26d404317a4789b96012c9ea2b56ae101e4f1b67e409630be6533284058fe4215ed1824988faf82d162b744a66c11027cb4e106e95ddf5c0461a663c89411858305e5b95eafa3afbabac208c2b983a3c5e88e65ba1d5b182f1f397d896ac963ba5aa60aa160b299274cba57c2a1854851439cfc147dd3305d3dd7b1493659182f9530a2e63428d82e9f4d9aa7cdfc51625148cb17f925372fb1df5134cbdd96155c24b92f085e104539ae7f5b0939d208c2618648616e126526ecb1e0cc26002f6de273bff787f7210c612b09453c4f7ca49fd26c377108612cc7d236e7e157ebc2c1784910493fca9d3eb9d173f289d9186191d20411848205dd6da35753a0c8871c836d240037b10c611380c23a8f9e93a240f855104d34e6e65ec056da4814618443098dac9a93a23faff52e36d80c60dca40038d36e30c33126da481068631041286104c31a2f5f3920e1f3a45c69a06c6182318a6687d6e23929c6c42fc018c740827dc7d2f4670f0f10b435061ed93529523a4f6c317c6f413c9d94ea6ff5b7a61ceb7f0218f5e0f0b3f2fcc25ce639998eff0b6efc25421897cdd7186c3872e4cb32729ffc80e2f415d7261f6eb38aa53e592f4d4bee10317862826afec736b753bb730974549410715a4a6986c61aad634fdf079265abcd4c2ec914ad6a79fe546190b820f5a9874d8b8dc7df92c0c2a7fbf1fe7e9e2c8edf0210bf37cd995ca444b2cccb61e210513172c4c25b994b6607dbcc2b415f9b5a4e7ae305ef0fce941eb34444a2b8c559b16174197a710b3c21455a26bcf9fac45c9c72a8cb2f19fb2a8bea99c25636d35f0a10a735f9a9790162d7a0eb1c0472a0ceed9f49da77b8d7f64a4518619638c199851061d3e5061a7305d4e397448994fe2ae0f5318258e38f9a92b87b7df818f52900f529852860a9d6db370d9761406d7d1511db449a9f0210a539e3d95f2b89e1825e64728cc215c298b1eb2a030b75558fb089553840a0d1f9f30ad87917849a924af2f9e309b6993eda4e2de32a265f8e884794543355efb635cee8313660f3e3a8470f98f4d98ba93c8ac905532d66a70a3d3a8516ae34313261d43cbeba578e1b3f6e02313e63d19c1d2363624e8c607264cba7d9dc289741f3e87c6c7254c29e5cb49930ddecde81b669c618605c618037530c618a800c0c587250cf249a9eb590f495755ad84c96425bba4bf38418614111f9430ede8a5511d2d859c3a0e1f933024cf8ff6f24149bc21b14f99928cad8183bf71fc1109d3c70f22debb95c6dfb861010c70400c0c8821821168a007e4111f903048cf8e2621761e611295b91a164e7bb54a8b0f4718ed3bd88e078f7a154d679c6183046cbbf868842145f21073f11da45a186110f727721e7b89f7e5224c4129ad7f31354518feab5a23774c909927c2a4cbe646cfafb347bef081088367f7202c99de05391dc2982ad142fe4ba4da785cf830c47d14c2a4a56321f444de9e9d091f84307fae3c158bba222ae4c2f0310853b84bb5753da7eaf282308a7653e13c53d72a1bc147204c2d9e1fc94b8aecf00c3e00610a6d12dc428c94feb7910334ce061f7f30ab8974fa6247c6a9948cb51ef0a08c5484061f7e3045494269fe763efa60922c626fe9bc2284341fccaaa6246509eb88f51e0c1f64549c9fb01ecc67b222f2e7c98339c99e252d953db6bc2a7ce0c174f59323c7506175d28f3b98b3a5eb10dba10f3b1896e245855d4cc6da1563c1471d8c15cf4c7c96243a986c52994d1a1532d66e2033fa0c4f061f73302595836f9c0e231ac21ea45106213ee4600eae5931b392ce103a7571c074459cffb87e95ac81c68d3a7cc0e1f5eb9873667d51926f3042ce7c3593967a4fe30469860f376479e27ba54c64d369433733f14f48bc78c992870f3620ff392c8d1cf93da99e1a3ed690b2a85a97730a4a203ed4905645f0f865aa19c23490beb6f78325870f34a0426cbce362e9ec1952a1ef74e912bd916f0d1f6628ccb9fccb778847e7f0518666b7829ad193c2a8c4c08018221003052010030377f82043aa6a219e923de1630ce82efdb394b23664031b29e0c387183c73dd0b27bb33d20b43aa2f1792b42fbe3330986639463b2baa46cc8ad9ed21044be1e1e30b065162559e23e9875fcaf80037e1c30b0695b3e4eaca5df615ea8239a8357517a16142ee5c307ae9f270a65aa9287c6cc19cba2d651bedf92ab5160c9264f68d05350be63c31dfca7a7bed2c5830298df89aee6123c6750573be8e2ea2a276df3d2b186c4bad2aac5527cf84955f86f041059350495dcea65bef43ff988229e74a9db746968241626b8a897a11d1520b10a2828f28782962425a8da806cc28a36d6440a16008ba744cbace4eec0b0a1f4f309dae382295b897f0e104939abd0c611e84c930d9f86882c707136ef4e06b50238c8f2530e0430908f84842033e9090808f23dce00602f830c28d1b6f038e8f2214e08308370881013e86501f42b0810d1a0310f00886033c8051a30c342c40820f8f5ff8e2d1195e2307bd3880072f6c6083f60178ec82c3431765a06181303c72413c702186c72d08e0618b5a24c08316350ce0318b1a65a061811b3638e30c122cc043160ef088057bc0a2461a08f078c58d2fa30c342cb0810e0f57d428030d0bd8f81ad83863056178b402fd0c66d0288880072b6eace2c3431509f048450d0578a062001ea73080872908e0518a007890c21c2ce6e7be2c29d6ef0a048f51182f646ea5e4c87fe692b1766383e0210ac34910d533b146e68743612efd1a4943e5010a939795bea825f4f8842188fd91952304356a2a62a06003c80c0b8ca145f0f08441447a4bdd0a69545f88e0d10973ed6b856fcf17365f74c605dc8c1c68608c1f7870c29055b4e38ea4cf61271e9b30d7759ce84e5ae5c08d31c6f0d084a95b2e4fe4f4f1eb7c076760608c3170e0910983b25d55cb63c00313864b52dc7c3b889f1cbe81c7250c49dec48a914535f0b08431aec4884e1da37b66b5107854c298a5433db59f2861aa39cfa5b233099387081e1f4aa83cc2968479c4c4c68275f49461240ce7f9644e529ed35307097358f12e91bbec3995c7234c62f27eec43ac7a3db081027f1d98230cf9449a96f9eed108c35c3c7d532fad6e71469894322daa1ed4a5057711a6bb0fbeef29238ff03c1461b2e8e2315f65e75d7924c2b4399ea59727951ccd0311e6e46e2a4832a14584ef3d018f439836e5c3488d943394da109efaa8daee17c274263f8f28bbbd9315214c725ff9fa3482463f195c1e83f0f36c49ed3c046188752a0e84498a560c08737b96f18963c2e61a68dcfdc1a43b82be9b14fea94a7e30e8181f6fd4c99cfbc4a30f06655afcd26ae8755ba306fd364eda7af0c17cbd22136b2f1278ec616d78e881a453120b0f313e66f8028f3cb89664a747ad8ebefd0a3cf0606338c2e30ee6203ee94f6ea2ab82871d4c7bb22fb6f809cdcfa981460e6ad4e08c336cb0251003036280400c1480a0e8c0a30ee630d76e6b13a2e731d1c17c67d7af1e3c8f39182f088ba24c720a49a1871c4cf2f9ab3a2996a59c338f38a4071ccc39b669b57791c71bcc7daf6e2a2fe8f627b3031e6e387d8affb63b95b6e191a4d54b2663cd6dd4e881196d34f06003713f69d3b6ce93dca0460fcce81a37ba3230c618376cd448e346bb193b3803a1c71a4c6fb9748732a9c1aca743ce97143cbae9a4c13c729d2a4c84892829683097aa8f92e44b1471ee194caab2ddd26a78bfb966305f4dae907a30a9bcf72123e6e1bab0248456c933e1c19c435b78cf967758558488d2d9c15cb2ab73964f12ecc63a98828758212b6685db74308baabf8e16f2dce53998e279793cc92feeaf1cb8582faa447fe26090951622fad4a8b41d1c4c4905d7fbfe10cd4c6f400303dc601cbd922d0989b5c1f4e5397c2fc60643983753d3f521a4656b30ae88ce3ad594d3613598dbd4bec47f7acf621a18800693d07be94756673044cd0d8b55fb494290016678bf52366de16bff736528cf579678f82af7c9603c393975f544977cfa184c97ef3987cac8adff88c1c9f1b63dd49f9b1e065318e97a39444f0c910306639d99327f516ae4ec2fa47223e547574b222fbca572178c3e422871cb664a81015c684f655d4656ce16ecf3a0f447bab72d5d0ba5f39c6654d6d6fecdc2215bd6c8cd8b61420103b080a7d71c193978fa5ca1ec17747c39252b14d143845827a2df2a5c1e7794120b217fa860921842bd6be9cebdff144e7edfdad1df3a2978c1647b4a416707191085435ab38a58595a3b28607f3259d4e49ff8099f095f1d8fd59d7342365676a31d235e450c6802327475989409e414ecd4bcbdc29b4b40bde3ed56deecaa90014af0d2884a27843a71332009a59633292a0c4002f2e3c595fa08c6d1972c45eca4b4b2114cd1f524c50929025a548a949245b1141b110c42c9f814bd7df259870143b83d82bccecb16b34d0c10824107d321b32b899fddc140e959f809d3253960984388da294bf40b436eed911dd717e6f41c948efc25556a2f8c1bdaa176262fcc1f734df4574ef1bbdd85af615226e88aab31e922bdf1a32d5a59bab97023e9911b5e41f85db8f092ef9f0a8d6fe155ce3cb3493b3a5b90e7f5926ab530d8a828c172e4f7f8d0223b1d2a84d12c0c415285121e4c59a43a480b1553fa7b2c529193fe38963b395868a63eec45ae3a855f61d2397c8ed45859dd15caa46829e47a044b2bf8be5049c9911c2b5afb4e6a3f8818afc289a9754a45d57454e1f75bfee55829ea5498c2e6a4921d0b3d294385c14743a7687f293f7d0a934a21757eb1cb7e2f0a0b30853959c69c8dd2fb29924a610e93e396fd8c07ad3f298c7edf4994b83841c43f0ab3950896c34b4dc4f84551bec88c89cb6b288c236eb3a22561541228cc412b451555a14f1892cab7b9e81f12f5e3098350d9bbde743e7afa74c214cf6d5bf2af085d36278ea434bfbf4cc90d954d18cd752d9c12b226cca73b2cb4d794fe8b33618871134e998e1f36c5c47a1d2c7c76a77bb92f61d44d3d6521a7a4476a0bb0844949cb4105f949859754c2146a65f2c84b29615e8b2264a77021494a27815097f36479fa699230473bcf22e6bafd4a9130e48e94cc2f04a57d26244cd5e7c1eb7de7477f8471c259289323c62b4447742179b776c5d04a23383bcb95ad14762246182ea2c7bcd32dc29c6d5bde4f8a307f9555b8f6dd5b3711a63f53df9e3e879e1043c42bf1b4f34e0e6a3b4431a9bb5f24ba7c0c61f48a704a843f1d6654089334bb4f2a2949f22d5563c1b0004218c2e85c219b31263b6510c64ba373d2058f2823fdc2020491cea8c9d9de06820f12a2e7ea7ad30362dbeb2c1ee1dcc72e7f5075745ec9048ffac12054bc4f1f9e758f9b741525870f86a0e452b22e8fd41dc28505ec61ad2d9110947a3858d03e696363ed3c984f279d922aad9d85090fe80c2dfe3d498864f13b20d2da32353b989386fa89abd317aeaf83a9374f74a8d27fca79d405cdc188223b25650d9197433237794b88fba97148a86ca9f0fb210d07934edb177c674d5aed6f604288a6748aee92f2c80da653428a9c644adb5cde0663a968699122365c2aaa04b9db1accf9469efad8cb97ac06c39f48a583103969b83a42b85cf30a42868682cf758844abaad319ca67deb1b47274a66d06a3e5b0f859d75b6997c154414b87d2ebc89029b12be93194b52fa6a9899dcec2627075c6b32aa4340a83414e6acba9d34c4f70c1706c91ffa6fe73aaacbef004b112c7d2f45e30e55877e99d4a871d912e6031c4ca88a813ff5f2e9c75733f29fdf3d942e761f611625eda73b5902e2fbfb2c05fee4fdee69d16164c61299994246bd7737905254553a3c368d10d1d2b982d455d2e76a4492b56613797943ae8a95088262c23a94e5f9a42e2af33e3ea2c2d05d3e94b252feb8b422259758ab8bd408124bb4edba40fea53fe09a674314b926c277095527487f0f14b13cc2656742cd6ae5a9609860b1aaa4f65848fb3b6b0802598c3cb271de4eb93ec4a30bee59b28426c88d1a62474399ea1e90290505297bc69c9439ab5802318f3928909cfed93928c6038b3f8cff98b6048dda5eb927b2298820a226b5c12b1da1e8249567cc9e593ead287162004931e35af95b907031193456e74c0309d9874e661ffc220bc4e47febca4ea7c61b6cb23ed428d900b61f4c29cce4a5744cdca5e7861ee8bd61d17f35df8f15794c812d68549a84baa77252717a60b49b2246dc28529277b95ba5ecea2ea5b9892127fded52962a98a2dccab7a9a922b5c0bb34dec54c14dbc63480b438e53114b446761d2799de593c3b996b228ba08eb148e852a13643c448717c1c2bc13b322aec809dbf815a60f4946da89743922ea0a5365bb9c9cf89c2bc55a61aa5211b34e1d46c594156978bc8c972454d7ab30e54ed172c98dc892a20a9398e0ed274723473415c6f6cad3a67f54186b52fa58e74e61b214bd6db9f4fd2a628af7de53bcc25218e5ef629e5d69e47c92c2789f5ac9e36514e6ec14bd7f3d8ac294963f8c94a82a59140a7d4ba48fe381c268ee6945825be8b57c828b5f732967957cf27ae21e2d173d24ffaaf0e984499f595b291155173d4e1884458be623b409936e957a50353bdfad268c575244c676eadc936782ff2a516d499830a9bb49f95a5498fc12bf889b0ec94410a9f49628ae47bddd5abba412c6f932955a8424fdcc28717cd3218e9787f52661d05177bbe32e6f7e4920ae3e4685302281c93ecb275de6d49030fba85239151fdd6e91b1f60843bec8a62e7e658c46df00c370049eea6147dcad2935824932e691bdab2a8597a0a1e24f55901f7ee5a61d86c10893a7702742bc24f36a2fc2e83977989a7db310175b43188a30277d229e68b1a04350224cc9f3bc696d57080311064f41a9e77ab50baf1cc2f4621e57c3574318249d909594c8dd33b24218b3439dc97a09cbde12c2242c5bbb6ea73cb9a04198b2754f6586ba76d205611256a35f94481372cc0361943c4997d5a5957705100639a264d49af40fc6d1b553f14ca77799f8c1f8b9f6e1aa651f4c91e25f25f93a1f4c49a848496c3c5c2e59187b305ce94e6a4bdc30f470505be16ae4e9f82935100d61e4c1702ef36f957e9382e4cbb081827c4018783068939fcc4324a5aa5abf096e9c51469211c61d0cb1f77cf34cbb8248dbc1a0643c3b9c97e585b80e26ebed1cba5e9e1cdc58d4811f844107931239e9fc217ba553a13998fb23cb049192eef33a0c399874df53437785187799a9851107a3e6884923adee924e8283713635df82ee1094fc6f3024cb101e1e73371843a7f0ba038d5ea8f4af6652612012070402711c045248f51e00c3130010404078441a8bc462d13c0e85e1071480035228245836301a241e18161808842351201404844382502010088541814028240a27e196ec03ab41f74a5cbda0cf38737cb323ed8a86cfd25657810116da0600aa70ce296e6ae67566a0e70b7654604720f737c5c02e0d64724730741c6dd034c8fc50bdd6880191268b4923507cf74d766582231df89f0599770a1a4c373db28b2b0e747984ad00cdafcf08c0997b5e6e6eea267b805f181beeb6aac9539bb444f24f37fc683c9ca949faf447fea535fe479cd290c5f455fae73b6e1d5cb06d98220fc824eb376fd0c1de1d4480b743ac6e74a47b0f15e183e4091e968a808de6f2541c8e584911c341ca0bb86b6c938d8b7c3c2b5b544b4461523983f31de5922592fc69c79a4524c8671d92de4c7e09eead39f5d4bfe1a94df4278e6c79a33ca999541f6dbce7ee7fb86a418d54ffd00120f8140dbc9d22f28d7ebb9f1dee3f4a15f72cbe0681c61d3aeb4ed422a08aff1d39bc1c530481076fad49d9cbd92fe58118611efcd5e88ef6c36e3b08c946c14b908e148a6dc8692dcdeb6d7b5af9ff140f940d20c69f84ff2d9748fc199f7c0bb77bbf8d53bdbeaf305628eb7dd3512db1809933c2bbff7a5fda6e21c36a472e0fb4d899ab41175cdde6bf844c934671899fafe9b6045225aa6d60af4015ccc7662a87ee9f1d9487cfe553ed082d1c63fd550089f109f0a6476ec7a7ad90111def3be9d273a26aa725beb92225aeee3fdc6b4808250dcc5ef550e2b79094d8a6a18a5a039dc6d8357c3774190f03370365a7a63c1c251171ae9748682c174f23718da31b7e8203a5cb808e5808638d4d6dcc72b807b6a18fc51b26e5a233c7511c35f57d8d463b36ca40ebd4c484661f9c80837d1b25c6513ac446e73ed07f0e9d13fd339a4114886b7d702ba65328781a479cb5bf8ce1ec300d47a91f363af189a59d4e56ea9f7b9ab99c439bd905f5c0513afead53f1b3046c811da319a4ac96a56eb9ed2007c14672098d6710e0e0debf6e209b3fad0c9146ff7e6189d501df8bdd8147ca7b8f21e8e05ea2633757f4e6f3966859bab60e8bb5c1be05cd7c762000b61b38b6124703725a8808cc2d040efdcba015185262701af9e67ad7d2d63104284feb64d6eb5f0993002109aaaac1112dd71c4e6e0b4bb5e4d97cd9d90ceb3f0e98260ce2bae69033045f53409dfbba11a06654e95522090e53da0559ce056640975de35c9600f50932ddd94450109a84a94701587bffa21592dfb9e65012a0fa4773ae11140ebaafebe8fd28132685d21eca13d6a10f9ae18ec94421dc56084c35c66e1d1eca59547ad0fc0ec170bca1abe70d078bd5c17ed7772e7effbd63e4f37c520dc8aa5b2a5dd5887f3a93080e6504827ece1014f80622f0586fd0d16ab76c4055f7ffbba49c96edef3a47c98e35851308cc6ac01b602cc3fa2f23a0a7e6a87f02ed28826339280daa37f1d8ef6e28012ac3b7992e2db11c3c4767b0fcd54f9a2def88673a7a85ad3d44afb14ac087e5771d3c87903115f818a8250e062f6d1ad0383886173cf08a56cfa2c142da31174c58dd48e3914fd2ed80b49b531898070f7670907e822dc10d19421bb4d67440104da63b2a891a3ca4d51acf651f3c71e361870a357836b71da9ee74a069a5b6fe107877373c9b81ac41405283634e106755661a13990f1ee43a58befc278558c50436c5fdb45d569720729a7cd112c1206b628641d3171a19641d5baabba99dff00902c5ce031d27cee7732841421211974f0002e3e1cb08387e50c1a123dd7dc2192f560b40032b1c1f30413780ae0e0715db9d5c76af008ef83c6ed0f548e6a0d9ee7a387811d6507cb7d0d40fdab60c7a3f11fc20d9ec428864318099b40e6b307b4583b067722f1f9925eb156d5cb4058ea76f8be871624460c1a0669aa32683c0155cc4212c68ee001f6e97a29fa702c27bb2822a855719d837524ec18bb7678848d649a3dfd5dbbb5ff0073e0de55a38c9edb7b04a6dd12d71b34ae2dde6aac54b5f57a3d1efb775e284666143f458a510dce73dfbbec702304ab4c344334181886046dc4a1c66408a01c8b2d70ae21424e16835246a5346d0dae1894169478c33b565351cc4ca7e176a8e929d2614cc0e98350313f9e1584987a8375820e80054cd8f0c08b0e06505803113633f98021e3e088628c88c30ad93daa20163c484fc40afd50a4bb448f3255450e5a401a0ccca1b83c4e32bd7500e94f16a58d3b472e6c8135694c26de69913c7710d4a8ca034d91f673434fd44fb3e5691d2add2003467379045a5d75f175d3db4231ae012afab4ff57c033658c6d6d4f6eb167658f7e374eeff55ed2110f629d4a028503cb647c662edf598abc8f49fe9b384c8d9fd8c05cd5af0d549d3c550297945fd5da01e83faf6967c602eef7ba0baa36279709254d0da59235a64a31b69feddba8ab7b6a2354f20fc11ebab08f3e441faf066b10ad9b25ac15ca5516837a0861300f507c4e244389afa32cdffd7e37eb3294eedd42b1644ccbc68a20f37635b74cb661cf4e9445865d99cbe342c009b91a06000b63ff24116ce487b11a992c81c9b9db81761434f949930bdaba7bbd6c038d55283df3271dd4e7520c73008b4737df2c31aa1888f3b0e1878b1cf0b921327884844bee5a714bccac1ea25bd7f0f11e1b6e82f1d96dbe6a0d516fe8d1912c35f05a0e75b787ed813de8600d653d9c6b17aef7d2fbf5809de265ff366719869ee80311899639a26019e509f8151c866ae27e19840b2463f1408e11784a253050c4c141771070e9670e5cadc8b03d1c743106f610bc51c4fb0a2262485030b4fe61fa81a9fcdffce8654d55a8bf96213db4db24e8f92428c50414d5f7ea1db0927440a7dc31df51da2554386a7a54a906b88bc36eae965fdd8d8657d007f771fb405e35798557e9a6009aef56e2fa71caa281d2d71190a7f09990632fd0a90bd39bf0d50cf8b1a02981f8f9c18c838a061083a9012486c106702d84a56ae81d3e989721f1561cb282b4b0546640a1ea5e6d8e9deb6e2e06331afcc76b697620892e0bbe5e4b2457166de73ab573f8611a1f80b5d6c422c073900b3116aad24de0f3a0acbf719c3ea3988b7180b8014c160535c3871bc6433615e2ece25ae9c9197d090c624b1fd1c0c0dc0a8286d070801706b12c6e587ff95a8150da4896b50d079916720ae98d2bef454ed81c969944bc4257c8bc372dd3d215fca33f816fbabd579cd2d0d56a60667ef624413aa08a31415638ea0526713b34d30661cb537620f9b9eca9e0ca09059b34e11691a16421408d55bfd206f0b868ebbe6e9524a87530e7eac8c8f0a3b3d3c0bb8ec320c000eb4b950a0f5a89df0e3def45b0507e33fc65716c7f25654279a5fc2bbb791669c662cd9ee4aa39ce62389a39c175a76af872761a0d7d6ba436037aa1d7973c62eda5b1aba73eda03bc29ad35bc4e73cd0d34fcc2344ae4f6ea2aa4ceae9b1271ca760f1dbc0a03bcb7fcf552b02ae762167f9c545a6a41dc9e7235f35e42152451c14d5d2e2473e2bb1a7663b038cf79f831fbf1a41399f39950df4cfe176f8f416ac5a09f7c098a38c98b3c927aa2fbb697f0b31de0df2935f1839ad316e184e6e2be53b26e8ecdd88875969f73193c263885ec0f809f6c4fb0f29ccddc163e0a369d4e211774edd66eca0ba7a4c3ed95a8ae40cb70c1c693aca14c43ed386b24c54a524893515afc1fe2048b2c806b04fe8bb54d320e34542fd88ba4066eb37e8d2dc3d1c5c0eb4aac5923d9a76f3f610fbace67f550b5203e31a6e93cf4aa2ceb2eb429338628bb8c8d74bde9079364008916d853126280f980d9dd74e40d3449a65c58bb6e46b691fb52791582cfc56098ab40016e046131a182c29043533120706c40423b3d7a72b4dd417623d49548ae078f503e39425e044db78c0b65a8d5c12b5968e9c4897ce33b75f273e1bcb07ba86b3680161be25abeb05cb2cc30ea5db9a3ae57f41bbe72e94f6d8cc3bab49f93700c6dee1444990c542a8153af88f10494ee60e068957e8b5f945f483b67ebadbff389931e049939a0f6dca66cdbcc92fc7af95ad9d400f09e415a5ddfaa0ab5b495c9848644c8e68e964b84bcd453f28e142b58ac7795d12f3f0f47f20d966f0252cbe851e5e4eb152a546cb880600923287414314b9bc651bf76675cb6ad8129fb192e57bd2a386935e1352ee250d3c45bc5b02d53f201f0dd3199001ac0c98be3486af99261294008cbf83dfcf5f828e8867b750a5a3f6199b715c2a3b2e9fc78cf446b11896e53a15d74145014079aef2c1db5058166d1039dae12685e5f4e9caa0f973d08ff0af43e3310cc9a5e573052ff7610ee045b505e49106ee9dba0a4070bb03f007f417c967e3c455356bbfadf7ec49e47a40c2852004a5ddb1ca97bdc04e43cf650f8ea68bacfd829b8c90f0c9b24186e76fae090eb90a0007ce265734afa1281e43bc97fd59f05333e36138d5b1e2f802f83d18091015291935b2a23e02553970a05e55fa032c6cd4580f27fbe48db17a7788e5ee6f4074a331de655c63453a71d691f68a42db119e9c977de2b076dea2d63df8373c0090794bc017fd689b3bd7bb3205c9c8b9b60ae44a9c961ecb7a156be601ea334a873a870dd16fde4c2239bb8ee4788ca3b839c18cefa2c59b21f019f0b37e30471098be5daf339f81e07688ebea1e0a691e6851d422d3b74aac8d33de2ec6894006daddeb1b0448d6165971ee04a4bbbb7465093ab6950bcf93a930e7c00f8356e9d1bc67da851e07b79e39a579b39caddf4bda6333dd9c46c2a72cb2b034b261e209c301231cdf434b7e828f2c7f4464fd6cde242445cfc43c77ffb02800603bbe3c6fa133f04203b8a7d5bd1cec0efee9dd082435a3fc13bda89336040fa736b11e51fe7aa5ccfc20a6507c42bdf69fab2221e1e382593c02adcbf45b5add7a506c92e9ac02f51e620d37209ad315b59ef012ad22d3b3bb85ae67a4ed1f1a4a12c901c2549273db085365ce1f769958c7b0f1bc64a66dbe8318deabdb8986dda60f4b6e648a3dbc21263225b8b325402b39f406b7d23937360fa309a5bb68c60d1beeb67800a3100047ab552c63c5f777bcb8160ed2d0bcf74bd604723d4fa42f45b13874e9e95186c43835b3b80b5b1028acec69d0f71325de08d5327e9d8e0009896f340190fc7232b2991e1bfd1ff4133eed2cb74ee46c98f7b2a170847355a911f9cdd4c6c13ce38cddf9f9da12caac149f750c72238ede31641f0183f2e2bdc266a4f1823b01a888fa2f31316897220b27bc7461daa80cf6fb489f53d9f93ff6482e016258325523d4ea4d421566ed4384a3db5f5d987aa9401250734f5b7352f0d87befc1dbe41c92a4101e73a0b485923ccf99520071d634a14a8ae50d44d118de7a11743a78e936444da33f07ce3fe6a5bac02c14ee24de0752df349db8d0b2c2ac6960b8c58d3338be231e3a0a641c3a8326240b4593cde9804adafed63a74f0fd12b1a9ebefe57a445a814301addd9afe8522aa3f6f7206153ab1e480d043dbf52f9057adc890c5942f3801b6852d1c845a1a404a83efa945e3860990f826ed5a85574fe5182748320a55046810e52e0494a23c9f83c18c71a462c071b3903cd222be6baa84c8b9e44de1be90a54b6ddec20ee637e4e31337b734f05942b1e473d587bf3a711b1ef22391f2f6601cc8ebc6a92d684e72b04a1c99113ba37d665d60d8969bc13a5ab1da250b79960f23c0eaeb799deb659c22b917ec462a4f3b1a2b332cb16885033f106b17d04d12d2821d354305e6d04ad0b3bd3fe31488089727e858e118a5882e59628975ef7ad0529ad1d58b22b32c00a852d7d66b26225fae6fd03791dbe0992d2079d71b5e93972423cc1c3b2c4750307e12b136b6826583a11450877eae119c3ca6d26d6660276bb2a2d51445e14743b1465846471ebc9a8820750ecdd4133e7956a89034b7b6b427c53840f5ba764501366f91bf26cfcd4f040c261466dbbdf1880781125f3c2a946a936a61697763341490cd65e0ebd9c712e71224408a6210b7762fafd5faef3a9a5871585a6e94033c199d77f8e7989771fee7191990da6b5afacf4c3f5c67e0fa39af96315f44d15a02fd8e7cfdb37831e87e930a81e882b293284689ba1a5c3e7126bcdb4498c5b045ea120e4abbff1b4eb03c1799ab56e1155ae0fbad636244d1a9323b50fbe84836e19a98e52b5a490432a88d2a294441f4d16d1ced6ac6e02040fc82a20cd1b63b2a87f13c12441a199da27b8da08a9822f645096078ab13d8ba83e78a970596418829f786a24274aaac14ce13bb6909a26a42ef5ca50e4af0810e51f85df0ae9e7e0f9a9e749fca9f2a7cf816abced80cb722490ce22b75e441342ef96ca933641dd02cb38aacf8820ddfd85b9385822e5bba7ae972a817df8a66f96db2666e915ae768423ec88f188968a321d62a8178964af08cd2e104d774a34a87c4d4c00fbbb3834cd3a8b2626b0a015b393137efc39fd82249d0b67ad09043473ed2316bc27c142f254b0edde9f1805ccfb2986eacb51f67499b124b08405fe7f824b6b39651a4f9d9ba8753a5b525b5a8ac00b4ee70f035ccd38751480f8833a71680278183e8aec9d776283fdcf445b71abbbd05a6896653bc7d651ba5c680841eedc27a3266ccc67411c0b458d67f63d5a6daa13f31b62eb8b55f5c155ac30873801bcda2c0c6726a64f54527511838329578edde956aa40ca0d8db018d20f5a86401b8f2f8d5daaf7edad1667e97da463b3451f9e66606912225bf228fdc820ea3db5d6baad7c2905e8c22a22ab237645cdaef6db8b36dc9dab536a4edb4b8fdb24f3f250daa0e47cf7924e1a51b890ba5d81fba2d363dfefd2e90bc52a74320796f53465c2683f8be470ab5b2739c76cd445a8f2004b672115ecb8a44c7e29e2a04b4b5c07a8201c512357b4297056ba1eb08f706e259408c3fe2778bfe47e5cfdb356dbee57a0b07a26938e43e3c81147328375778c26e7706c74920e3f8c416dc7fe525b4b781f7de7cdcfd38649ffc9e71914596cc2a1a8a9b1ca11d31346982a5e898880c5dc092585f19bd2d171811440a85995b8fde6b4b1646a1e6557e3f4c95479690c1357fda02fc43e872074bdde2f020ab9647e6c9210bd745e1fd1f98974459fbd8cf1eacef6fa9b5513f524b8e203631c4d520f7da9f0f27153f976a125374edcabb5ee2b6024c33b19fc9fe2bdde45f3619a50912b174cb0603c186e61e065092a62f25757e7a7512276899aeea41c12eae45a019dcf612222d2c1b0d273a91d172cb93288c354e1c76293fcc7d6058169a804abd08557db0a5ab1086082fc9a4b7a74bc324dc109486c8778003825dc43babf0f8f04e2df4c69863747907ce3acf49944c82032de235bdb5a32fd364e9f13812a59aa92c1471b97eb3374791cce52a1e011231eda1f1b87bfd4b192eee36f40b89ac4525f0803108f2738964fd711cc844025c304b5d48020616223bdf31aa4dd557ca1931068551223374dbe4f2668037d05c35847884055e3ab5c152ce466865d15a01d3d5c7b02f2b1c42db858cb49d39143c96426b9a6551b5b90949f2eb87631757679534d21a64ddc36db3dd172c3ab28e378646efab7b6562cb76fe7e54c62ad2d6f12e008c49df8e2525a89169d3f409075e6221e99a93a6a7f463960fd47524e9954df4f609c1ecbf7f23e546e6c04dc4144778635ba1794c04b00af52d6d32684898e9317bf3b460627abab17cd42a055b28fd6e2d58f5a9c6df5b70d09596a29272329197c07b0433454bdfc25c02934e00115eddbd462e4577f2ceb67c44982d2c2b84eca7652f46466548bcd9fb28a60eb0f2941fbb67b2bbfc6d21be3379eb37bcf56c6b44ef24f50861b00de64cb3d6b0c060d955a50f5582222eb2802b3ed1de51bb8af2867d5989c45a92e7c7ddaca24fa404690d4bf5dfacfac2a22c0b7252f2e57fa74e02eea5a1b9797490ce100e487ba3bb892dc693cc60c27720aabc9e8057dd093b5d4d20505918635a1af736eada7b781254afbbd4a94c720f1f73e786d85e86d327affc96c1ceec4e1b28c70b113a61d5a5d15cf859471f435ec632113db6421abb55c6dc95fc8740acdfbaca88f5f52cb5bc31314b791509b1598e3773dae0ed3df6e13fbb43d6b91a1609c5d2447dfd4c8032d083b921e4939953e954a1c63393416d3a1d83708a9cabdd1e34b7bc53c4983f97742da9345aeccf5ee4f454e77c883d2314b1c6c65c2a926b63776e5f2b2c95f4d47ffba37c9b6f722cce51252cb2db3d87c35d2e5d25f778fbd950aa35a99f94556eeeabe5e60212c8484b072b5881cf2791bb6e618d4a407ac5841d1d84ea0053f32eb4d4e4abcf8dd8adb4b8f7d8e4122b4ded650b64245d8363663f109ed85315872e1c3c94dd2fbc6841a0845564b617d80697d51267c3827b588a48754838bd51abb13825cd36b931d0aac8503dc661e99c20946f185361dddab351e32385fa2ceee6c618b20a4d58cac8efd71478dc3821f1b44ad685a1a1d05bfe0087ca31db53adb69e9a4373a72901da6b761b2d5b04a470d90d312607eaf6189a71e1bcf7f79b9a58cd4a763a225197c3578f2f79646cc8b05c435740658e9065bc7343a21c4accf676c40cee25ac331941db3d2b6e27b3a44f56a9019e9e3586225ddd1bc29dd9b1a29a384e151a30ead38fb03236ca6dce87d46081ac9c54ae9254f70d22773c86f2b8a151e89f9c1fcd37dae479dac3207c03324a6dd0a65bbbbd76482a02eba30b02f58699f2cae7246e94b5e2a98c206435dc03cbd31989c0a83292745c8b5c57ff0749402fc3ca04d964d99a6fd5797b90ad30eb9b7b31f30b9fe80e2e666475596f17709dbbfdb54212d0d1a99f1209dbf446610e7b7f15370c45d8af465fd70c690045e0540c0500a3b81f489fa60bc869957c5f51f10e2e3d38beb1f8cce010c5b01ba2422421045219cd85c8ff667c460c49a519b94da79332ae6af53c562859499f8be6ed3353721e334b5087eb2ebe2c1114d9180e9779a9d3f1ca20477a6ec856c423be0232afd67689ba661cc549e08f75ffbf24fc42d234994e66470d1ccf7c48f86a1b48a81c4d61181019518afefcc281180f5d19c45e3f59d138f45c6ad546715851dfb6b8def5c350c277d8af1b072bba022bf1b1f7e1f8806df8ed2d6f6dcc4b30fb6e1700ffea230b5874bc89e9102d1629c0056438c1dd1e08c00abe1c62cd1e48c001535326ec0727683cf4b60bdfaaa56b9f5ba5064c2973f1fc833b148588970712a192edd4ee483f698fbf81a6fac471423c4b97aac52119ae5af7846a74f314cf587c0d12466d756890513df5c7fa9fc18330832df9f8473bd3ad7c1bfb6e6207ed183e4d015c58b5fdccdcdaa1fe1e0dc8b9792fe1c8c5933d91811967c0fbb31678d3fc578f5546f90389e232861b30088774d8a459628238c8554700599994923bbcdb7137eedcb76244b70f044c59f7e105a3822bfbd42e8e8b73b93f2c54cda5835738b51af0782c0b50fd6464177b85e414aa2b50071e2949954e43b0d24711abf56d6e800ae6cf8231d20a8e9ef672128b1fd670cede931905f65c8840b4c0c99d70ddef68663272021b8bb387ff5a0d7ae1b24ba65ab0783ea0235f20b54bff568acf1ec016e7f6e4cf6babb5914c03d55299e6c6b84bba1e92d4fe9254b982bc3f76b53c2bf3a007a6be2e3d18c0b3c860392acbbfdeba93aae1d1957a59f1a809784e3a791f428a3fdf6183f99039506c64624ed6e74f263aa7c19e14d1dccd51635f5e004343aef20ac11ec979936715701a820f9b34733b456e29e0aa83e6d540ccd037f7eb10c9620686ff5a27ac04f2a71271908e01c6f6a07bdb7cb16d84d8c1c7a18dbed310c2610bf5695c3e95dcdda912cacc075c44714d4bd0a775f65d6a69ffca7a7e3977890c910ed3f27fdb2cc51605f7446d9fe5a7e13c48c921b2f34d70f8e84469e6d9b43b4ab2854a1caccd81ff6c2e0d963dea992902e5144288d16d0f8188d01ebf147849a7b1e9b2ebb155f8f2902cf5a7f4cadd768c25fb907b97319fd7e897ae89caa42d9b6a8c066fa17e3b3235587a0376fbdc7bac3afc35c8e16cc58e5311ac5beae69e8ca7e94100268553f4f76a5619f0c8fdfa18eb468af8d51b8928dd351ae37813c47afe73c7cbcf928c808df3ed395a0e7e0cafe003dce4eb74dd71cee51574eaeda133b1fb0a3442e710a6f06ab29e7f33c0b31ca3e3b41094bd4c48548b8cc1b4259c8330dc00a3dcd8ae70d0a77a6669348ca8638c116ba91e9658d3e85866f77bcc16400438b68a58707ab1fd4b02e53814a3c7e2ad4542224d5c597e5842224290b9ea7a9edd8978a8c8fb94f85f837ed90d075b7c04992a167b3fd3e1795b97d87c3a225961b1f4de9d41b6b81f11ee6963a14bc8c048e9e54260adbef3537cbadc8df12b7441ae6e1aa85a58130094f186aaea06607c1cc3d4bfa06ce304b5c268977b03d6416a6748ad3a5d9d4ec8fe94ded80c0a2f0d0cd3d052a69b9129b217819fc2c4150192bc729b5edc0f7609d31a936365ad1f306a6aef0d892ec27834b9ab217dcab7b3a82fbb2dc5c530dd7018b2e102b7ea288afd850f1aca3927042afb6c69937ba552121f5b2c9a78fa21321eb629054e83eccbcfa490ab27717d435126ef5c9eead9964cc3376221e000aebeba8c9d3b3b041be98e9073aa21758b5ea04d0832f04fb99377872248c54a67ee7bcbe82db24a0edf465d8654d0c3ab5c41aca66a2533c05496426e11d3c658e0a773ef5358348c3526acf586ed06d857a2b2b19044522f2811db6f5e35f22f0a1edca8c8d49ddb32fd47443d2394f556ac9710c510ba4d793013f3063c7e78973dd0681cd02a6209a0b4202b596720e93945e4ed1ccdfd9490327a9a90d7fbc23832472af6e420b18759fced10ab618baf16c4043e94d84e296d3e5295fdeb09fc8ccba2dcb41274cc62b9af00f95a0885d51521fd9727c9a24ced543ab38e436ae80ccf88c4fd2ab1f58046132470bb8058387e098aba5b9361a140c824c8ef3ff12dbb787c9d6b612eae4c248319c3c865dc3c913a47efddb5d202d61f45f921ec60513803fc70afb50bd64777b10f7d649554eec1335b980054a1beb72416d78a871fc323589a6aa87e89d07b6f282de5190cc753336c96126820326dc6755b92e70ec41ffc6a47856c204223924c42f7d67ffd792fcc3889e63f5c600258311b93510ee600a2636b2579357ddb745b8b6489dc1ef29703ea877eb23994ce8afcd7f6e66999f30a06431f46e14e3e5c1417918ed5464d2b723fd0c527ae1e8b04e8e6f1dcf5e2b03cc89088f7271ff5317d2239d87f25df731f2c829d2c8c5e57912ebb159b72827ee8389b35f75f29a6ad16fe6e16c44b555aa9944dbc96ae0b1604d59038216957ef4fa29f452b5b27657431526f66125cbb6c2a03610ec9b82d0147c6cc12643f1143a270b9dd52d57335adf404945093315295d7f489ff562949a17b3bf97e1c08ea044dc581cf06d94c156f831e137e0c928ec018772da783813678286d8a0089c0a3317bc723dbe8bd8610a045cf614309e0257014c5b4cfc82688b70127d68400c8a3305523bf276903dd471a6a6da0faefaf07f25d0d97c713c8c1770ff55602d7dac5ab097b26206133af8bb155783333144b45dcbfc574900268996e2477bb7d7fc3b8171a2ea12d04a465af84e82a42f53a555cfecdb13fe2526bffaac5de2197c3a5dc993ebd7c9c77f14b3e86bca1579f2eb38a490b700e7db049e685b4bf6ec9e23fe9910db357521408aa0978d43b66ad8d80d075f49f89147287d0c3089df397e27dcf21f70f82567237c0dcfce6b85f3e3333d4eeef15f53931641e927830e7a0cc89c5d11008edbe92f904218d371beeb1b4f9136828205f1cb710e29b8115da70396a815cd9112791a240742ceaea4caa9a962e5cdc1a7f753c20cc7e89026850a342758d04ee47b4814b43ceb5236fffd5cf328758afbb723f92557fdf70bc16b3cea036f2deca4f4aa2bf7a1576b33d79b110a09f6b292885bccf7c6805e21b0748488ab60025184a53a47bbee1fda045ce314cef2e9067044434ef088a12b3d6c1ce270f2b378ce9436736e21b38c92ca8244ef3ac14a3af6e5803cc8d4c81b0f3fd412f3ef668e34ed585b62603322cef5bd8fa79aba174a447c8f9498ebb8a951545a2a735e0662bdf7fd29cac541eaffde43b21c429ffa4b86ec1725d6e832116c3f6d979641778a698848cb70ae22b03b26abee697fea238f8f6c61649aaf73a199e9d72fd3e4d4f126a17c802a286803884131fc5d0b14e93fe56586d542ab511f6d0e762e83560a930361e55fd88e1a18a7cd2120fb875bdd120b73f3161908119fa0d709f304f9d87efc53a2ecab3f9055bba5a70524a91cd3e0ee610e55bf8be531d90db4d7d949ad615151ae345f0fa522bc393c02a9796d7bcab3fedf26f1e1662e319c12173b200c6f72cfec3913c7cfc58c395d3b025a6ae4a8135baddcacb538e195a2b5750f1cf7e90227273684425e01d8fc67c35dfc8ea2f3d768c3122bff90187d207738ee4d758b776e53cd68da3118d063a1d0f5bf2a2234969fe0d76416fb69693b1e6badc9160d6b36dc69121fe2661911e704be85a8ee1c6d30bed5ddc3398bd76e0180674c9aac92531dc4ccc3c3c1ae721c152258507a92cb3dce4c6668fca56ccc6348c7cd6dac295010453725ee9694c2ed040525f66690b823115f13838bf5031d7827480bba37a936e151d4a45215c147655c01b5ea6b2cc3928c21dea76594baf491c37ab402416b2a244c99b8ca18046c01d22a03828946c15246708e70106ad758347c2f6728d04028a278c5bb2fa491b30737aa950fb2482bba68b5c12a7435a515a8e890088c4aa2a615a804cb91d968af8a7a82ca2c455794fc53b357193a46b1ea1adfd640a53250b7255d2eeaba76095e6744c7463c031de7330c3d83434d8553522cf484a1c3a19750c5a17a5147a51e88f5c49183cd373afa0afd1ceaa9a3b094f7afcb701488a8655431d4b9a827ee08ed15531e869fca16a84cb08cff9f241f4ba8f0285f65c42f346ba943ab6fab32d1a244b1652b6c987374c8dc11c732ec5ad6f2fea1b02efb1dd8cbd1cad184519ce80fd09c1b9db7ef07ea3f7432a999aa46d44d422bf2c4f9ade8553db582f75f8fb2e47566af15f565b95b560d37a9a72e109848ac3633f5bb2a63d00c882c1a059c18ca30c54ba7284465a04e75cb4a8c8e4695416dcc018d169f8a942168a6d486701d30f79b58279cb5db3c09a632c18b06369a218be336273cad4b0fa10a9dc27d41bc0386ace2214127f248d3a4f32149e19d6e89dc6af5f07cb95bec3cdcf3b884982df87ad8609e354a6c08ca6bc63dc526c36e88adc6c68645d2d8ea6192838fc62780eb764ee5cdf44f346d2f41cf5ed6b0dbf0b46dc734563e5d6730a2d92ce4bb2a5c2a8e601923ae4604a3e05c13e81eeb227c5a918498e897caae8a611a735141f7b59ca22138fce786949d91d9c831b418506c1ca03fc8bc5c0c63da50c17a462d56fd724401c0d66e5c85d05a5e48ca310c2b4ff902402288e3a3f6030b26694086c9ff4c1f0d4e066ec3024aa10591d94008b37af412a40d7a0c9814b8095871b0d817a845a4831f3af5dd66be611c05b01d7977c159a1431f0dc1763b774f348c8326176d47460d8c9014bfc7263c1f32a0284e12c6a2b17e64a36932d79cecbdb41a4feb715524f2011b14790be7073739ccc10e38335c4566fc709bb14a447a85e0444b9b597196626524361376c9ef1038ba6cae039b315e6ca9711067e837c3661bfe0a721bd86d2cb61191d80cb6c5d5b9bd91136c399ee3d8b691d98d65e51887534f6c6677d6be0b9dd88cc9a128cdae8d7af166dc144cc86ae5c8c6b46caa02beb045f90d3660b0a4900330333333333333333333e3ca4bfde37ddc1ff7de8d60c232aa45279a9292921209ac35aebce01de7e01dbc8377f0d67401ed0da10d1f0e4d52abe0757486b10e62c41ca48223a94327bb321b1fa7e055a63ce1d2e660724e0a6e8ebfe737785c565f141c4b1e13738c50991e149c94426d5585f6a5ee098ea47c5b29c7098edda4077297396c821f2ed492e698473a98e0b57d479bedef79094e698ae918f197b1129ccd6695ebd2243829e68b15296548706a3e6bf050691b2d3b821f3ebb9d49eab09fcc08cec713724cc9f4712c5911fcee30daf6690c11bc4f93de1ee45552ce109c24b143ffe8393cfe08c10f6311d467d6233d4170e3fb6e36eb2b3b0304d7b3cac52c5de59a1fb831ba6a5f7ce085cba91a626726b7f4c0b188eed1d5b47a5978e0a4c6e6cb13d9819344ea6732248f611db8793a3e87b4505a7e0ebcf6d0217ad8e3c0cb4813d66e3c546ee06d9eb7cb1f04b081ab5d9eaed2b33adab5f082d87f94ef83acb569e1b6c725211d3c0baf652e4731480eb46659781b24180b2779e6c95154d58c312cbc489a7f2bb2fb8faff09225c9a1f9871c6deb0abfe3284a9fc754af6d2b1cf97854438ea7565b56f81a3de4f918415388aec2bf64112d4398e081aa0ae762aeb8acfee1a334156e69baef49bf7df944859f3a948ea297a7f02579a648ee5c1fc4148e678f9e2d867cab580a2ad4c986258f144e942011fd330a5f2ddfa71ccdc7cc88c2df509a156982c71d0a377687f7e8e0592d28dccc21dada625dea3ee1f49d947ac8924b9927fc8ea12558b020695727fca05eb3a74cc509672285e718de849325a7d4d392ae929af0439248513535d57932e1a71c4ff89c35740e0f263cf7499b263269adb984f763ee36d1e953ca58c2dfd80c7fdf1e5fa412fe86ac1e49ce9a630f4a38496ab2cf5c26e1ada698aa6221ea2b92f067b3860f5f8984ebc9936d65b5ed0f020947cee6db72103d6df2083f847f2c094f911e71847329dc86d481a7a46984532187240b33c2bff0d03767c851c72ec20b29592ffb304554116e064dcfaf19bacf4f841f7bf0a0437920c217b90b73c1e3104e6a5bd6beb74a1343787fa163f3cb66e1e342f8d32621dd29ff84f0c2079d6254f6993708af3abe93f1141fa515841b358636cf5aaa3981f0ca3c27bff1f3ce00c233ff20d774567cf40fce775027a942747cfac1f50fa66346abd14efbe0fde5caefb1458b1c3ef871920d8f7b0f5eb7e414ba23f5e0556bd01a3bf3e066a4d57469ed2d9c787043dc6f23fcc776c13bf81f77297898e2b6038d29d9071d07621dfc4f39cec17d460acdd1c1f19caa3e883707377c10739a433e084f0e7eaa34ed992da5b7581c9c34ab9eb482e58b191c9ccf9c2db25f8c31526f707cb2ed322d37b83982abfbaa4fcc698333f39f4288f6d92d1b3cbf98c2aaf755e6881220630d6efb848fc963560d4e48993e30b7ec3fcd64a4c19b481552485ff5c6340c178421030d4ef504dfd8b0ac40c619fced38168fdfcdbd449366011966f0524e89acd441a357b803168601a30c4ea4cc1f59c425bd5eac066490212f937073e943c618bcb4b8decc95a1ff3b2eb6bef0a28b2d3220430c95e6b0fea3142eb68c8c30f8e21ea4b4a9089721cc850c3010c3fb2455fd525f30a656c6e688be1788e497e6735e0b97404617dc0e1b724c4939d892b8e057e7cae361477af1e82df8ad193faf355ae1046468c1ffb19c3286adc6908f0c0332b2e08cb77a78cd1d7e230b032fb20232b0e08590c1be821ba92e68f274d1257fc8b08293c26a32976da4bb8e2fbcd8c2aca08b14aca00ba4808c2a781f89a7d45e953cbe80046450c1df4e9273e8925ce00432a650351620430a2d230ace5cd0147a26c3c5568d1a99749001053fe23f3e5189b858be31c87882d31756db2d212d4b8e2623c87042d540818c26f89299cf238fc2cc4dc6c542c074f1850714d72083094e6dee4de7d31a1daf8c25f821cdfc440c2a5143274309e590638979a2e3586720230947e6f6c163acb83a073290e06dfe9c25a40d1f117304c773f81023a6c4b88a11a86ed5f4f4be087ea8b6cf1fcfa9559808debb89440ec9330427cf769c329a840bb1230427b84b47f3b17e529d20b895dded953d40f03d677498f0d19c477ee04555e9fc99c423f73ef05faa8349ead1d7647be0bd664fd61ee450226878e0a4c8a5327b074e86f71073c4e69a4a077e900d39c8a164fb2293037f656cc35598780f0ebcaa8c0d9afd22e3065e4a15edfd4b82e71c45860d1c8d1e5f4ff239f8e8520b377264c4bcb1ce63b2d0c2b9f6d68aba6916cec9c7b45923a1a52bb2f07290104453864f6d2516de7c8e3b280d8fa25705168efdff6726af8e1e79857f96a5239f9493d4872bbc1e4d4dfb186a3d6e8567993e9ccfd979b4125678eddee5a1a9526125abf003adcc9a93d554481255f8697d36e498c35a8224155ebbc75a1d9ed9c1ffa8f04c730c7b4df6e6fe9fc25b93e41d95b973646f0a7f2cdbecc77394c20fb12395f0b1a884b449e19ca71ca588ee8d3b7b14defd871134ea3ffc220a3f720eed22c77328fc10ed339c87b1fb9941711c99c7c19f70433e881e8ba6d58678c28df6618794365c6ad209d7cc2549ce0ed207ff72c28b5531df99d4a3fcbb09d74396ca13a2ab09a7ec2a64dd0489566d26fca0fe3ce68f35cb6a30e1d9bb745f889472b0f5126e1e0d9fa36bb58417251ecbc420e991a795f0dfaade3e085f29524a09a723db7d32fa78949293f0dca26886895312fe69ae0c1e1d44a66846c215d90ed70e2b64c925249c1829ddbb33a5922e1fe1a51c87312186565c948e70a23e78e9c923252936c271cd718a5ad4a41c898cf07d653a74e416633b5c843749b3e414b25d21a1225c4b216ca203a99839897025367ddc610e39db7388f02a5d468a9eaab4ce1dc2ebb40e54428721bc1c237d20e139469314c29b4a3f214751199226841fd65fab669f2c293908af2e0495a0412a624e10defdcf0709afd61e7781702b4d88b163f848313a40782672f75761d2a4cc1fbcdf902b85c5f62d8b1f5c8ddc954f34d607ff438a629b35ab6ccef8e0c6584915d6d91efc389e1cba87b3ec74991e9c98825d5a87fec9c195073f84e8108b1dc777b6f0e0e794356f26bf15c6ba83ebf669726059b3a65776702d6cc2255955072ff769c7b9a347e242073fd688ec40dad7d3630e5eceee961e678b62b71cbc4a1a25a925264b8c83f3f663f963ea8bebe0e04cdf5f86fb4fd5aa4911e30d6e05cfa8e571109f330911c30d8ebce6ded0b8b4c19f2ca99307f5fd5f151bbe10ce53071d522cb9585d839ba14722db5c4c88a106bf7c443ab6b7480d49831fe608319a79ec65f5e130c44083a795455624bf60887106e72fa9484bcc47b61dc30cde799aa7e89872989ac528831f2d7325cdfeb125916290c10f324d6fad3706bf277ffa24993e77c7108317a1e53c36c86676334618bcf940ae03cd124cd3c4781c31bee066180b2ea576c966e20557d5524564bef34f7e17dccc79429c489ca70c73b1759683185cf0da5375852017184c83185bf02ace3f36cdac11fed1829bb53abedab6919c3fb64819c4c8821fa2e2be3d858ea7432c3897f264df1837358f71b1750557d42c64a4325bcbf62186159c1c6677dfacf6f5e657c1dbd8398e3368baf78de162cb84e1c50b900831a8e0df98faddfb7de0999c8217db248449a99e66f2c59182638b300c181d460c29f8fd3972d49c3c59c48882575953d7696da9fd5070d26a44e592cfeb63f182055b1ce58a184fe8b25648bbe49ce0d5f747e9552fd61a89d104275eed82cfa4907e7ba18156c46082779b43878f30cff0314bf0a254f5775039281b318612fc3084075feef9c24d6c8f102309fe4fba0ade59eab23b48f0d6fe55a5031569d31cc17f995eef0c8911344611300611fca822fb3f6a6d086eb7c79184c41cb9c4b5841842e8da73bfa46304c18f4655e5644323463e06100c125307296ac80fbcdc71322dedf8e08e37a6c5b85c7a40e6efcec14cf43cf02a25252ace63077edcdf9922bad681a329f2479be53843c639f0b3e6385eadf78eeb4371e057faa0b6de73032f8b86908378897677c6b0814925e7ca746731520ba746e2dd2c2b5af8173dad66e224327766e1d4473ff389b62c6e93bc19258e85f7e95aaeb18485571da444b779b5c89157b831d53be6945f336c5ce1a470999c337bc8f05be1c7d6d829bade53dacf0a37a510555931ab36c7b10ab7831c72982c5bc9660f55f83163f9b6844db726a7c29c474af2c72e7563a2c2f73c1fd541d3fc3f7b0a377dac1e3d336b8a536ed55c653e61624729fc6c39bf5d7497983325851762dea8f48e2c878f1c459646f2460ea273bc280c8b312387394a6ff443e1791023e4b01550381b3165a3867cc2c9f1519e34d2e4709527fc888f91d6f368ca612736fb73959c533bc6092fee4f5bc262ea33da8411368410c4e4628b0c03d08413d22f7d1061fd539e4c381f7afa1c652dd9670c261295d26097bf84f3398a9d27ceea52d2125ed234c135bbd587a152096f43fa8fde424ca97228e1e7d618553e3aae8f3209e73aad87906f3b7f1c92f0b27d881ac3a5657723e18739bd234374dc390909673407a17a62e411841b4d6e12e308d77ebd3e8a4eef5d69849f2ba78df0b072dc3d23fc8bd5dae571ec5c2ec24f7f4babab15f1796ccca525c2d97c215b9e17d91c8a08ef3f6b4c1faf5fe6104e84b7dca14c5b6df20de16be5cc8a9d42782a1d45d4ea3808e1f6dc6f068d109db3c7208e209e839298d22505e15fae79fbab74200a89946eeb3e8e2640387193ed347bf41fbc8f43e71cc9a3fd4084f475b91493c7edf5c1b5e47f29a7cd714735f3e178fb38b6700fae87afee20c5d5839f83d89a87b3bb8418427454f93e78f0ef53761c5479e41e7707bf2c2c7c799437c729b583339a3bb68cf920eaa30e7c8c8a31e530c71da3832ff6ff9dbeedd5b49c83511573dc217b8614b61c3c2fadd70a9e38781f793c34724f761e0e84a87cc125f75418dfe0cabd44ccb176f5c92c089552f02ca4bacc32a131c22878193af41c778c1de51c14fc8ce91d85f4b149774ff0c3d08aec0e7382975324f6f6868ba135c1174d299364d487d162821b7294a3e4b496e049fba87c903257564af05245c8d2ecefb72a097e10527aba8b69ec4307129cba0f59f5417290d271042faf5fba8c7418c10d1da607ddf3299d53043745998c670fa34d0e11bc645d15dc21b81e955d730826590bc1cd1965b662d9cc1b0427be83ba9f9b6513089eac445947da4af0fcc0f95c1f7da776b3cf077e84a76fca6678cbf4c077b94f159172ff8407de5f8e63794739c00efca8e3ad4992538c8e72001d385ed6215d8b79b8ca0172e0845039ccd9c73f29e40038f03dca41c2a6567b0939c00dbc288fa255d286f2200938800d7cd91c2b74476ae1d846b9ca10ecc3e769e19dd684c7f9cd3d3c66e14713424c394e9bdab42c9c9e0876962b7786742c9cc91bf75148f9c9372c9c35efe0ad738ae9ef573817c3c71b7c57f8693ac5a887a487dd0a279d44e720e5ce97352bbcdb8ad6395ac50a5985f31f4a6d6c8d4aad0a37668aa7cc4a332ea7c2f76023a36999dfcaa87063b6edaccf1fc7fa148ea57bc8a19885aa4de18d67a57043fbdcb3fca3284941858cc20df691d78c2b0ab7deb447c35068bf390812ab8282abb168159a7ec2f598bbaa247b2a0f4f381a835cf8d8eaf46527bc28293ec55776f992137ee8f7d6482321addc849b3caadf9837849b50135e8478554e294cf62f139e4d5d761c478bd51b269ca834d9a1b2be8413a2dd87d1375eea6a4bf8513a97927b9f94a7ae84eb2396ae634a53c20f52ca42e6ca2c1bf524fcd414434e1d95fa7b24e1a5d4603967ef38b427126e0e326f4bf44f8b1e4838993654f6795f34cf233cc93efed31ec5fa8e23bc10b52e6a348494368df02bb52a4c76480b1b46b8151a953ea3c2ad6611aef4864647b5390c1945f82942fecd914984137a2a6787c84abe20c273b7b69aced4f09743f861b0581fc28518b518c20fe672fc9bb3570a2185f0ad627658dfa7f21342f8311a72c60aa61d4c06e10762ad599f20fcee50bff271a1251208afde526c594b5c0f083f8e393a8f473a4dfd07a7cc3ca60a17c362ef07afdc36c264fae065c8c79afae083a7c9c6638cedc1f114317f242322293d38f741d24abfec6a1d79f0623c6aba089ac3e8c08397af4e43dbb22ce60ebec4beede0fb658ec3b5c73373d781d90ea483db95b263344799369e831f74bc695210e5e0c6d439fabcc6c1dfa4b943f1150eae654e92f9dc342a7d839721d9f12de5414abac10d1d87d9632b5cfb6c83671a39c741d2d431996cf0ac5243541fd7e07465956c1ec658caa9c10fdb614e558fe9bc4b83ff7190c3b8d5d67cd0e087f07392dd3378bdedd1a5ac0e0f33381bdd7bc3bc6570bd83f5b05346062f25e6495932ba778cc17b4bb9376214afaec4e09d057b0f6518bcecc8476390180ccefdbf77c871bee0877e29671b8f17bc145273f061da2c962ef85a23bd31fabbf35cf06354262651f1efb7e0a5ec142cc3460b4e6bc654a9e262684d16885e1d7c482958f0b5dd6247989bf82857d8ae6445836a0527749810217c7b1456c14bde6973850a61b64205e754623a4cade1a932055742beec41ecaceb102938a15fbd3af351705cbeec3f780ebee3a1e07b0e3b753a9fe05cd01056511b6639c10f2ebae5ac9247e99be06594778f3f8c0e1a2678b933640a1faf5b64095e84d09b11568267f769f1ef9104a73e7f1c7ae88104e7fa7344f5f4b1cfe3084e0e3a42bc4c99dd6d044722653bb06c566a17c10f513307496622f82769a93ea423cdd921f892751fe628c71c9b2b0437e58e62f28c06c1f730735467962e4305821f27c96129da64f8c81ff822b612c2f47a10a50f1c33fbc91b246687600fbc4c3158a69b8f5b451ef87d1a6fb9fb8314b20327d9c7a1e7f9dbf6381db831776ba596f9162f075eb4ec100f217b640c07aeab4fe6685bb63206b8819b5fca26967d5c6f001b781df97a35c7e553d7c20bda21244d7972eecaf058c93ccc5acdc2f98aa134e7cd70175938123d3bfe2894e68b36165e7ce8133d473e2cdcb056a1736d7988cf2b9c303194cb755ce16a85bef4c85208dfb4c28ff6917fda9e70b16185d71f555cfe2c4a8e55f8d7b1c74345b0e05154e1ab767c3908396ab44a2a9c9e994b97b7a35454b8f5a9c25a8edc29494ee1e49bdc418839c8111253f8ef963c8e42be147e8c9ddd36ea34073d298a985635cb1fa370bd3ecc3c7fc4ce1ea2f073ecb952ce23147ed0724b33d11dc530289c1ccea3f9c935a7f127fc1017347bc7ed61c69e703e481eb6aadc0937b9698e6cd2478d2c27fc568f327290183ede4de09303a9f50fd584dbe9cd639294cc5ccd8493e67148ee9a63d78909ff35c2574a6dbd6dea25bc99bb54b163094f428eeea38e2cf66325fc28b6e3d764172585126ebabece7c7196fd49f8c1d29b6f4f648c92f0d652847f0f6be922e1479914113465c57490f043aca6f031e5e0ed23dcbca5da97426f089a23bc28a61d474937b3aa11fe878c9d3c3a9ec830c2f30e3e9c644c49c3a48b7025b2cfa25fc44c114ee694e1eb2b89f02d3a8ec73c06117e0c3955d33c840e630ee14a6ad792397b558d219c7416ca3fe410b92b85702b7518c27f74ccac10c20da95f4f7910aea5cc9c42737f50124178919e6adff1658e914038e3b1fa67f324361140f871d47879349dfff3073f6c9c5ffe2d898e1fdc10cd41a3c61c65f4fbe0c72c6ad71d84d2f0f9e0e5a9081297ce93f57bf07269d80e2b7f90cf430fde86ca520dc9fb3f79f093bf44a494c6833f371e9d64b21bb3efe0aaa7e710edae1df51f695e8f3267b90e6eb7664df1618e89321dfcbba43ed391de4a9e83172cfbfc6a2c073fd2ae58173193e5c4c10be396fe29c2fa0f073fb4ed896e1e43a76f7025888a7bfe4e9aad1b9c546fed39d536f86e1ee788930d6e6cb986e6c91b9daec18f3247fd1e199d326af0a312ef8e47ab7325d3e0fbe5b0535a5b0f3e687025ddc392cd61a9e50c8e4d6a0e22df9ce4308367f159b56337ff0ecbe0498cc86f6bca9a0c9eca4756f48cc14d93261e3a2ec570598ebd30b8b93e0a9ed181c18f88ff5af7dc51e60b7e468de778096abf17fcb0a93f66c4f4a1ed821bf37b5cfa7555d2b8e07768161beb3129b305af42a37cc428b5e0474c512aeec982df9192da771c2cf861e63c76472186d4b9829fa3beebb11cbaf35638086fabe0a73877f31012fba6829f72ec9b704ec189704b69a191829f3b9889cb11053f7b700b4bf93ca40b147cad309adda33cc1cfc93d4c158ba810e204a7530869823716b3b2e4ac262d61825b2949aae6ef9827bf045f353a7b234b18f195e066f449bb764bc93992e07de68f526c4ac99303097eb2aeb5f18ad27e1fc17f9ff6a8e41d7dd846f0c27806499ddbaec345703bd88e93c6f441083311dc9a8ab89b5893cf1d82f3eed2df9999735e85e05884c672d70e490d829fb286c98a09047f237bfa851ca4cff2077e58e40c8b613eaef481272947c991e981abed9653a2689685077ed0d1367fb13f0eb2033f567c681b3d126975e0ffe63953150b90032f6cfec366bfb2fc1500077e249d9d255d3e89ae0037f023bf5c3612726d8a15c0067ed8d7f93cad3286ad165e6cb41c2a365af8519a986d9259a7c92c9cbc621d694bcef943167e858995e314652bb1f0d45f2be7e8520561e1b84792263d5fe5fa157ef0dfd3ada66d63b9c2d9f48186fe68ec2aadf0d62b47b0b14829cb0ab7630f2b7d24e12adc8c728b2947a80abfdea227582c9b8e3015be5fd545e5303a8e0851e104fb0efaaa62adc7398537f641ba2bc7b1bcc7145e6dc4d4ea94c2ed305ad424e37711527895434f72f5d1dd3c0a3f4fca986286cdde8ac271f30b17257d6a86c2eb3a3593cd80c29fa9d7f8cc7cc20fedb183af142a2d9ef05288b38b3df127e984177f412c956685ac70c2ebb1f338a6ca26fc186e42c2868c29af09dffeb2df8924136e6a8851e22398f0256d5427e98ea27309cf434b59f5bf25fcf451c75399551ec757c2491f6d78743c259c143cca3a940dd932092f3c580a9e9364f99084ff31855812b6634a1f91f082a58b1e3cb49608094fb3624e533fc289fefb0f153bc24d1edb46f8514cc5a7d258b95e4638eea369c5738e83f02ec29f0ed3be43c7b1ab5584efa16a089dd22a443411ae660e55d4a453f78a0827c4b4f92b26a3c27a083fea682bb93cb5c7aa21dc786bf5ac4d9e2f2d8497aa766df3b9ce4d42f8a9b9d36b3a085f543d8a09f2d6a320bc694ddd51bb2731108eb8e4b8de83b4660908c77fe5d4a492471effe074a8e17fd38c4f871f9c4a135bfbc32746fbe0044f95cc32ed933c3e387ee1de7bed324bf6e078b40ea2a64eafad1efc73efeee8687bcd3cb81edfe6af110f7e0cefce76d91d0ca9af52f6783b90e6b73ab81e5ad6e0db35b92a3ab81d8748afcc1d2e85c8c12b8b2995dd2671703d54ef8f573a38781fcaebfa63c8aa746f703a7a0e2ef391f345e70657d2628769a80f2ca60dce46878e1e877414346c7072868f6369bf64cb1a7ceb0f79de72f5fd6a703d7be4a04572be701a5ccb7739c75f4183bf2134a4671a0b5e398313a33d9121a6ceaa98c18fead0d724a40c8e89a7c5ecfe4af927836f39ce399aabf1a8ff3178926e2ec4f42858ff6270c2fc6d75dcbacc1f066f2a849ef09863c607839f525ef320390cf71c5ff04337d5140f29217d78c18f3653b8ea4bd1bfa30b6e48b19c2485b372990bce59f684a40f72d0f1161ca91cbedfbde318b35af08367faccc741d566b3e046bb1cabc574d074b1e0d55b78c755dd26ed153c099b434d9f90c9572b3861fba543e47ca779f1b0a3b4c20d99a952adfb2353cb0a672efdba8ac52cac5556c5baff63ac3437d31db3a10a2ff664ffcf9b6e1e7ede48859f2de95108d73aef3750e1c5ca1aa9627b8698be53f827d33d99f2fba5e698c28bbba41eb2f3c4985429fca0f597a23b59be5092c299bed8162dd9a370a3e40fda91dce5ba4c149c654578b95876677cc7a1ba22caebe650b829ddff7564c7b61cb2010abf446c638aea486df9849b428ed581470a911896c28627fc8f5bcd42a8eb550b373ae19c78960e82b1c50a0e521d48c20627fc2862c71d346724e0c5c6265c0f1bce43e227c7686bd4d8a270b0a109b7f307edd8983f7a8f63055e8071180e6c511b99f083905c6d5372112d4c50e92932965d1313193652f89770babb2445788dd259870146172940b584bfb221b572b08401461717d8a8847fd9f5b17b4e295157b4997d887a7a109d7b42cbbbfc4938eefeb9225473f6201e614312cef976678e241d093e4e2675f9e28684973aec3a5d5269afec1187f1b87338c29678abb0b70ef70a79aff1289bd036c2550be92b98472184ba1b8cf0e37c1693a6cfb1087f725853eb137b091b8af0673d7c18d357527f4d02612311fe9a7af9c7f9d307416344d84084af6934c2a52c1b61e310ce8c4c276d172f4def8621908fb78314a23c0b001b6c14c2db681e2ce6d01d734cae0e3608e17b1c678cae0c51a9a941f821a4b76c99b3e5941e82f0831c66cc71777ebd06a292abcdaaacaeac7c5e51228df87ff600e1af44358b31440c6697fdc10feeda2b751cf7e4982fb65081f9628b177451aa0a3b60c30f4e4ecb24b12f52c7aa45b0d1072f870813d9fbaa2ae40d3e2053a7eeb61aa6d26de961f4506334dfaefed88d3d781163aaec9f8fb1adc2c596bd0bc0c0aa056ce8c1ff402cb43a0cbfc8835f21e4683347cfc596a5800b30b6b00ae374c10518c9800d3cf871b9a475de1cc3a4f9c25841171f3841170fa851a3460dde2d54e08215d0c61dbe08030c177cb1c51602d8b083a7f59623dfd47182159814a4e0e08264d5c129b79c3938952437aa0ba81eb0410727786be6f76b71f54e7080018651c1165812d8988313527ef3205c7a6ffa2a0c1674f1052939f076112f2257259135356f96b3db448c1e0bbce00d6cc4c12fd390d992c1a3a6145b75a0cd7bf1451860e80aba48c11746058a81116c711b70f0f387db0c39763ce98336dee07faab75f8c1eb9e106ada32eee4ecb23d4253eaf8a791c39ecb68f8160a30dbe7a6c99f6d1c63cd9dba20b161c5b18166cb1050646b0458d0d36f89f39a5c89363b61e8b8b2d2ec070410a4e5a60630d6ea6314f79324586ac1729b80d3538d61dfc88bc5e5ce02eb091062dadd3ba34c35633cdb6e66290b953b58f49738213787101167881811a354ee0450af2be0883051b68702c9ac6a0622f7e1ee4622b055d187206ef425b7cf6278fe09a2f5a00066e6c98c1f7d850219fd4d25c9e8bad93822e0c29832713730af3fa4bea09e38b1680915c8471a80055f05da4003130822d686c90c1dba4314721746757c7e08ac66cfa7d58a11d31f8315b8e223950cb09831f7f0ea2b6e251ee3060f06cc6265708ff3959bee05784201ff786f178c10f7334ef318dfb8574c149e96f51e9a639940b6ece9ec1453ad58c640b4eca665b16ee344cb4e08b5d6a0a92d2a5f6f70e26fbdd7b2c389d992ed9edea9d2b38b235bfa1d6a3d86105e72a778ef139b09c1d557033648d930ace9b7cb470e9297819fee73cdb43b1b414fc9118b2759028b8b6a93f8378471681821f89c6a658988fb59fe07ab86fada8589ced044f52da48f1f19a857013fcd0c346abc87124394cf02d36422563489163096e481fc12347555a2bc10bd1c166869cd2c649f03227b3489535d521c1f5207fdcae1259b53d82e3a5213ab5467053e5e8e314db577711b4cb9ed006113c3b931ca6979cd9d3b3310427a70c95b4729c3aa4674308ceca7fe4f164f74fc9b3110437f465cae1a291f3793680e06d0e391ef994424ef36cfcc08b6079e22323692acf860ffce875de4198e46dc1b3d1833f7bdc23d1e581131e9f63348c45b703e762b4f7adeaa0a203bf62088dd530078e7814e9adbe0d1c789fea714ef213a6be8d1b782aee5d975ed299b7610327b79a4711e9e31baf165e8a0923293b8ed26b87167e471b169ebd269c7666e1857d1c449ab2f02a3c76670a1b2967b1f0259a8ca51c62d607165e0e136b3ec7ce9257f817f239ca945aa9e50a27e714d3e5dd61c76985b72efd59c3c692301d56b85146e3fa833a4f59859bb54d3ac5b8146355f84126c5d87452e15f7d6b06f3a0c20f16730aafc7dd6352f630a9620a5f632bd67df4518a29851bf31e2ba490c2b3f0968c12320abf26b4c207d1ef3f88289c4d3d69fa0c853715bd4dd3dfc620289cb6912c62295f0a924f7829115390a858a9239e707ab3739035b30c914eb81aae1e568c8e909f134e5a86ec3064aba0fe26fc38720fb1f3cd4bea356125bf9cda1f4726fc54291fa61ef1f83c30e1a6ed914b96dcc2765cc2e94b1f65d7b425dc0e72b678f88e1ea42be1db7d18d971e71c7253c2d39c695b622b33d793f07360725922857f9925e149c664f69fce718c23e1c61434e7ce3239430c09275e24856675966b1f4184fbf3924d1de17d14c226767dd49a36c215f54f6da119c62319e1a8c744d5ca1e4de722fc8f467324e36d174e45f841d2491eef12e16f4c1aa53ffa87194484f7e92d857d203165f0107e040b734136fca268083723e51842f028c28485f0936407a9912384ff39b3cd86078f633708df0397bbedc958a320bc8f2aaad53eacc50a849783b07eb36eeb6105083f9c995fd6fcc1fba01a2ac37399871f9ca416aa434da60f7e289363f48997d0c8f0c10932397d58397bf0a37a771817a207ffe8c129cb9d3a79270f9ec6589f6c62f0bae0c1afdcd9730cffe023e60e5e7b7cb183539a3b2454eae0873972f4317d70c1a583ef992a31690ae123998363f9a3935c297db372f03de54aee7d1c9c742ba6ea3d1c9c90439979a455abbcc153f5a0b28accb4ef063774fac852eed82dc7d106ef5d3eb00ff9f38d071bbc8f4e6a9dd3327af41afc8ee73ebe540d4eda8a9d95638f2ac569702673e821cd46839f912c26979cc149e7a3d616dac3bc197cb3dff064d3e797c1495531f75493c1b3b33149511d8393c94672faa468a38ac1491be722a1d3a34bc3e0c9e4e06d29f64a8e04832bee41ff57a4aa07bfe0f95a88d029e8052f7b9691986ace65ec829f6ae1e319f34873b8e0e7cd9888892db2b92d78b93fb5848a18fd3a2d78136361426c89e7c8826f79f278967df96b58f0d275fc5a26623969577022222bf67c58e295150ec248feee5855c1894924a6145eb93a54f083c9db1e3705254f8e9143450a5e6a5289e935240a6e482ef2713c1628b8c96da225a67f7c79821fc6c58ccb92db3e27b8e1710ed5e2728cd56982bf39ce379b63cd39c304bf54ec249c4bc8d6c743865109558ccffa7c26094e8e2a4729a305099e851ca61c5cf9d7468ee0bb472166e690b152c4085e08398e6899c2f5e58be0a73c29c7131e4470f37d184663de48d13104b743c81d875e087e5c21c79572e430dd41f0e3102ec7dbea1db440702d8450267f3167f3074eea891dc5ec286dd83ef07e26bc6358c90c750fd61c2a5a2c0d0ffcb2b90e3a8ea6fb8377e0e6aaeb491e1df8a6ea1f07570edc8eab3ca590c581f315be56ed0dfc1c269329f769481060033f3e0a59f2abb570724c4134a6ce725269e1c76130d114d159f8df79629ab01256230b3ff020f7e6138bbac4c20d19636bbab78f21b0f027d8b5759a0c96bdc2f1d86453b694ef2a5de15a8a11e71f6c851fa6ac3c6b6485133bf038b29854307115dee638248f1682670855e19bc731a46473ee38970abf5a3e920f2544a643856b1e473139fa3cfad829fcaebc21a5c542d29829bc4a2e5b29973f47560a6fc42f420ab7ad4b7286ef706a915178122b872963f7077922a2f0abb327c4431f0adfc3467b8efe79c20714be450a0bb93d5e8d9e4fb89a3656e4303a5a763ce1dc8da758673ef1309df0443458b0bc2177a4e1842fd9999673d4ea39b309b77275889af346b2144df8914afa8e3a997574c9846fffd92c5b65e5ab60c27331b32c0f3999e6124e4ae7ccad29470cb18413738c1243ae849761fad206cfd9b194f0d64cb352ead6ecc824bcf4edb61d7e49f869528cc9b28f849f72ba9c3e9258110f48b81d2654943693db8e47f89e82aa457438c20d29738e432c6af67423fc38fa2883947b349a66846b729eb2868ae93e7a11ae67d9e09f61430ab5229cea286bca5227c28b219484b31c45af20c2b394fca14b88d6371fc22d93ec3996cdaa8a21bc0ff5d01f47918b6c219c1c4426757c84f06bdc73902a1d8493d7c3741b9ded422a08ffdd53e64eed953b32108e66ef9421de2ad70908cf23654df0f30f5bfec1d7709f29b2e32d1ffde0888ba528967a7cbe3e78a9352b92d1dfb6e3831ba135dd6a5f9c670fde64694bada93175f4e098650ec5c62f36260f4e5cdd5a0ea3078f030f5ea61c6bee204436b63b7875de1f840caff0cc0e5eb40a390ec283c831ab83df1263989842072f4a4a39889123c65b3f072f7d98e39e88c90aebe5e04627390e6e4e6917f5beeecc818393c7db3f9387cfe50d4e270b6e91376ef0ede5235aa749744d1bbccb1c25a2648397c390cf18d5e39e5983e3817f320feb715d8a1a1c1b19f1acb1b672d2e0fa892509963b98074183932ae7e6317557cc193ce94e131e7d33a02165703c89aac5e8f155f964706ce63c8cc1f2e6c818dc48313c3226710d8bc10bf9d80e3eabc5360cbe44c8299face4283bc0e085c9e123491e31a45ff03fec0e2486da94587bc195902991a84f92d3053f4afa63c2528ec25cf02a7d18973d795bdd2d38e9fd2b47f7214b460b5e856745084133250bfea754b9b3ad58f0b4cfa34a41bd8297572b86902243f2482bf8d27188ce548b746615bc8e9db3974905ef3a96d95c15ea564ec1cfa27541baa30b0335d6e04fce29a79c3e31c73fd5508313323b7a98bd37c7d2a7c14b52eba1e71c26b9bfa0c17bcb29575a98902c6c6a9cc10fd45c2c977c7e50c30c4eb5a492d58eb5366519dc4c1a1d7358ab99f385b9e200c7e00bae4106ef3dc8df352b1d440f1a83ff95917cb3e5387fe41083ffb16dff88ca61f0cb6d523078b162eedb58096a577dc1691993bce0c714d27f7c1c540cf9d305b727d347b221d6e0829f43b68fffac3b47c6d4d80256eda66a9fb121993a72ca9152430b4e287f0f5972eef5ecb2e07dc584a5a5160029d4c082d71e76567d566feae4158c2dd917b493a68615fc1cc40edb516d35aae0dda58739f8daa648550d2a781d9322f685cad86b4dc133f1b39f4b661f41ab21854a225cbdc4b3db3f45c761f25ca79428f81efc6f76924f179f5f64208c2e9e6a40c189317956091ead553abb45d1a0c613bc0c691f9a48ac66ab38c195892cff0c25175b2970810ab01650a3095eead452dede71b155bc50c1162fe8a2aca67d00b7c81a4cc0446d6525cd3d6ea4da530ea15e61420ebd1a4bc0c3ab3a66a4bd1a4af0a3e418d523bf6b24c1ff782e33410d2478c95cca23357bb8ce41358ee07cd011933a0acdea670d23b839cdb6f2dc45bf0b1d1f6a14c1cdad31720ec254938670c0053588e044f5285ba7ef188217a3d4f26d9ba7206b0d21789b377e7387641070950bad2f0f0f912daf48d95463f0fce7670d20b8f943baa5af508d1f78317d1c8597dc686c54c3075eb28a3c217610f56bf4c08b1dd39e03ffe0f3b13578e0d6467d798efe0ebc4ff2d7b93e7fecb8d6812f2556fea1c8f9a6a9460efc157b8f21fca4f848db410d1c78221f85b49023dd6adca069cb3ad5f07899f56ad8c0e9f4183643566ae157a7e4db964fe7a9a685174d93254b9b5938d1cc276f92ee78a3280b37326bc5dbe5dbbdf3a20b1ab1f0b5bd43f4f54fb1013460e17c14ab932f890abcf8420229f0e29c8374e0cd0a345ee10a67a4a245394b5be1c874960929fa8b4a8815a0c10a3707d6410aef1e1e73ce2afca02124e4281d55f82d39e88b1239346f4c2a9c50cb7d11613c5f5950e17cb04a1a73189e39f23885e313293964ba47e9834de19da4cb5c67bf1e79b0145e5aaa0b69aa228597f2f45cc8d1cf7ab246e1895864b5dbf049461285e7bd1d9235191de51e0323d8a20b1aa120bcbb2ea6e6ccba5c3a68a59453d88e06289c641d2264dfe827f6ac4ef35a8f9334f3ce41e5f65852746c3ce1b4af64acfc49245cccd3e8841f29a7f021f6458f5f2a3438e15ae80ed3d6e6686cc2f18f5972e4f46868c2bb0966131fb287d9c74cb895d583a68eee474303c384118307c48006263009198d93b4cf6040e312cec73fd541ce1c96a024625cc2e34443e6b633ca448e9b5425dc4822f9bd2e4c0947aa7e23c3497e406312ae6a76da761b25e175745e1725e6bca69a48f8a1e55053884820e1a58491508f5a2585f8115e24f7ff984c39d2d83ac2f7d0d73c8e36a68fc735c2cf41960d29d46784f7b92ba5c71d5c4461e6716791f1e63dc9c358af082f04092a398eee72611a89f043aa7b54f76977c88108673de6f83dc474eeef1cc2d99088507eb51ed6c410ce673b0fcb3b3afdef42e4b6a22a59ef6521de5539a8ca1e2ca5c8488f107e1c7b5699746d15680cc2f3bb10fe628809c297ae18a5a7c3e88f628158a542522542d6ace63ebe903420fc384b984e9321c337f8072f49769c2b578c4f1de407277fce2629c4e8e9238f3e34652d27ef51976a5e26d197eda5154172f0c1fb38233eaeb2ecc1b1b4f133db512fa0a107d73bb67e992a4d1eb677061a7970ad2622bbe51c68a08107278878184248be71e3d1b883375152d49e790fddb71dbc8be930b2265407ff553ec8418e2a74f0a34d26edb183e409cfc192ad16abd6146f49096b8d918a395a0ece07a13f556d44230e7ed2ec5959b4c39472c0c1ab8fb6159115491de40b2f24805b031a6ff0b2e5ec9d3199774cef063f98921c42da1c297ae6f8c2ab0d7e1ccb79ccae90d35684061bdc482a41c634668af28a69acc1cf1e39b45384d5e05ca808b229d633a6541af2940fb9cbe9a3c1cd39a38f7a449be990c6191c09e571ec2853766c9bc15b7ff140727f06b9b60c7e871c7a90c10fb2cdf585bf1c61b531705fa2219231657116eb115b44424aa798187c390ffad42a0b4356b1769e325612369f11338520f6c126248a60f03587f8ccb3e182b8c00b10f080c617dc54b38f1eede8b56337a0e1053ff9df588748a769ac9d018d2ef8bd1e7c5bce2c122b840b4eff871ea22593c61614abaea9913497d4d8b6df88f513a9a6a105377518bdcef3a65c9366c18f5268cf97333b738ea48105bf2d6a7aceafb973ecb98213ca254be890ade0a5a70eb36c39c8c6a80a6e5db8e49155f0cec1a854f0e353796c6c7aceb1e262eb042bd805d098829fcddd33cdc4b8d88ac1910253321540430aaed445394b9675952e5170c58309e91edd52b98602776b5b25325257e3a7bd91557c825f79c343a8faa8734e2f136838c1ed28933be6b553f9c409349ae06a872d1afdeb3bf630c19199edde90f925f8e9f279f4b14b3494e067ea4ce96147a6393322a09104ff25bb47c1e3be889e41829b7b735839a87d84466dd553bc624decbb3607afacb9e6e3a36104b7d3ed338fa56814c1cff1f44732398a06117c8fe9e3991ccf07991c34a03104ec3e4aa6ee89da808610bc770d5e1ec60cb1262708defc4848fe7cf141f00061ab1b95956c2dab8de84afe33c973c77624971f387296d2c5687e631e4cc3075e0ee222a5b1e84d6147a00b347ae04a38891e476a8e83845790041a3cf0d64224a4740bc933b883c2d42a3ac6cb5536694c7a69e860cbccb8cb2e29bbcce8aa8c14c22b648ec3252eb668e4c0f9d06f1d7ab686988368e0c0b9f671f1ec48534e1b1a3770fdfbc4a3d9102eff84860d1ceb9cd13e6ebeac4f2eb6bc08630b3050701816a05560462dbc943752c59c6bb2f7dc8119b4702d3349aa68698d1a555f80b13366e1a5cdd41dbc86b270227c74f5314962e1a47c9329c33278871558d4a215dbd52255ee362f390e8f36f2fb0a3fb4d0719a438e2bbcfa9446f36d8c291fd30a6f4a63ca9d31acf05346d8a8b461269255f89dee293586c7fc5155781333bf59678af4b1920a673aecd248539f6c54385d696424b8f97d4d4ee106af0991a9d9716a4ce19987ac3158cab210520a3fc8ca07673e299cdad05bb79d517877122dbb32224f8828dc1c07eb21797684c2f758631e73ea008553214a92b3530f72e8f8849f2f8f6f867464966a4ff8416ffed0622abadf9d70343dc6b2c709bfc62b4fb466e4ab78139ea598796e6e4d38e79fae836c33416b68ef50fe03137e0a2657de1ea690f5125e4a0f35f96b7dea534bb8e13dc8c16f07aa15530967d5633bda9794f03ab68fcba1949370726945cf1463dab428093f8c65f9bd031ff1c922e105f7b0963fbe20e1fd47e4d4563fc2e98e93da54d48e2b48331ce17534b39e7e723ca311be79d49683f530a964b88cf03b70e9e8e55e04d9a723781ca33314e18b847ccb895ae78c6724c2c951da76d0b1bb72cc20c2894f95b3d2d9f57bee105e0eeff5ca1355529a0ce107b7f12ab318f3854e219cba0b3174744f88b32c4dcb3be32ea55bac374d06f3c8caa4c283f03b44f1118bc8917546108e66fed01dc2a7e5c01208af62d68890feb2ab2a80f0eb62b68f273a3089fcc1f5c966b13d9ef8c1c9e01fa3f45dfab0923e38a5d1b3797ff0c18fd44335cdc27bfa7f0fde8f45cb79fcdbbf7d3df851a4bf27f67fc5c89107ef3d0e9d2b4bee8c4be3c1eb309447d25cdfc1ad30f93e779ebef1d90e07d9265b07e7435d75103ff2331ddc181ea6e093d2d46673703cba972441e33f2296831fc4b4f153afc9cddc3878722fe629f7a4dc3170f06efb93f4ff779027fa066f2d438ee4a7e330f36ef0ff7d6dc2e5c891c56df063dfc810739633d8e047464ab9af424ed98233d6e0686c984b31c786f7c0196a288b787cb2b5310dbe475f479d91ef230dd1e084b449a288f765ca9fc1cf72c93c58c80c8e7daa9ca9528644580667d663c911aadc543a32f89d345888cb6163f0358568c65c89c1f14054b335fb6c0e5918bcaeebacbee4e69a0383ebae5e31878acb53d517fc943c0a1d741879c1cdd453c9c3aa762fcb8c2e78ee1b62b5fa9f7a79580833b8e0c7305ff9349b2db82eb2c12635a5091e99a10537cc7868a5edde285f169ca9c98e3e87cb2fdb61e1b2aa78cd4e891a29ab37b96e91f20aae45becc71b48c153c559f8f3fa70b39e5ac0a4db47c4aa5c7cac7bbf95f7d67474a05cfd3d7490efb7328dd14bc34bbd9f00831a637430a9e7b581dbb07761f75a4e1408d1a4e9811052755858d51161dcf57a0e047592343d966b7cf3cc1bfd41922d3d638cc70829783ce1f623af72c95ecc0173498d104472c46df768f8a89640613fc38b630591fc7db12aa194bd02b2eb6eab2264e666653c7a8b4fe511382194af0725dfada0cd28c24f4b35951ca2f8404cf2ab8a85a08d6a8b10500dc30e308acc86c744ad6c59667a894657694a24db2314930c308cea44a9875190bb57946115ca9243ed9fb23bfed10c14f512de5b29bc71e3d660cc1b35c29b7577d9c334709c1cda1c3346bbad4586d10bc105d913768464bf00082ef71f420da27e9f3b366fca0ecb2aff77439f5d841d4af48ca9fc2337ce0c7fa383b6bf7356a7c61460ffc9aa88f1d59c87970171566f0c01b9f0fe5993eca5d31e2c18c1d3839fd85e4b4195386ac03bf2ea4106be55353c766e4c00f36513296c77bcc51b89881033f4d4ae49f1ce5067e2c19daba932c821936f02c4c6c6b8e8a149d530ba7430ef28dc84f0bacbcd2eba3a3dc453c347314a29d2db3f0e3e389d948933b458981116cc1820d5938dd414cb5a33f547446868d58381d33425c7f59f48e030bd7facffb7e62c45ce52b7cbbf2f90f993762785ce1755de8988ad8a874e903e3e10182c161c16824128642c1cd7e23006315080010541a0c45721c0792381c7e1480015d1e1428281c1010120e101210080a120a060806060008060606000006080685414276608e65301f113ffb4f02b53e38081a6d1e2e448eefe4e0fb5cc5a118bde5a418ef40a7a3ff30dfdc617d9b34ffd7f073d12f7e1bb37969b31c27467445e227f755a721f8aaf4ed82f77e9665f5bdba1d93731f72fa089045db88560ebb5199a4d834c95ed3e0c3d8e404d1a98cdaa2134f16942e68ba9fba41b2ba300222fd6a06b1c1ca6a896b6ccfdc63360f18c3951a5ac915597f4aedadcef6e00fc63a94a3a3b4606bbf1e2970253b672a21a18e88f40dbbad6a3435a3816bde8308bdcfcb169b680e54db13f5408b1acb24ca84317ee7365b9dbc93794b5579120d7a4ae5240048fbc521b26c423e8706e73d5f85f5ac1c5afa60d3a589fa8152aa14171dd0cfd013d14c91443aa1ce2f0943e1a836035a3a983c7980437517be3861a1f8f79b8c1b1f927fafd06f66e40a472275af5edc8473ad22bf37e0afda5492f7681368876d3003b81786e5f64530fec6c8e0351b39ae5ce166f2c92c2e4f8d4fd982f223b601fc623f544a3904486588ffa2f4609c33ecec7c0752a2af78c9e50cae72365db4ffd4d9d5f034c4951e28cf8a206bc3158b8034ff1d147bd080f7bb7c5215e1bf86aa9ef40ebca6dc46c27dcf35d31a2dfed9e13d1ce94590fa7dea84d510c01c78a5e7e03ea7262b79991f097b16d45de0bc047f6bf565f0d5bd5466c0150d689bd21e2d4b011cf4ce4d925ee8b33a8c9d29b4da52c74554706903e0f8fc281d6b396f1f8c7a4b0b1c7cfe80e15baf1acb1670945e9f36ab648e2ae2c6d954997c2cc80ddee4ee6cb41a4e12ede533a4097a029fa4a4ec773ec05976c55a48b8f09349043b5b4a28a671479ba5b3069e22dc94788a66345e7fb8cad240ac505a4a328a82ff007dccce8d4ab68283ef9412e3b125435a8180fa0a4a56afb162ed4be7443bd5c403962e29574c00cb41c01e849dbb75a9b68cf96f89d63dd92d6eed27aaeca953f48c9963ea2c04db3bbe3d7f183d25a25d32a480d55f84827834a980560455393d3e25adda443cc509046da84f6a044407c91208f7a3f80a52b9c0cca6f2890cdd31822bc35c105bcbce2f53bf4d765625b1393ed2d44b9268cd2bc06ea4e09b5bcd5bac084fed0034fb21abf6115ab06e62168ddbf0feb95e4f7a4ce9cde2074d78a9d21c6d57f7b5cafbd44dfc3f328e2e5b5ee76589391d0fd824bbd2c3b7d43c9e8a2ad048888d77a5745e48aa7f2d7e3a12101ba7a136ec898891e432fcdabccf66ea0f52ae4d4dcc70754345454b8a8052b684ffff4a5f26add98134ee9460064916abf75c718583de2c9ceb02e2b4e15afca12711fe70cba5fb1bc39e9e95e39764a8cbcc907b0dc5c5486c44c9ca42be1102f402ba5b95234f000fe40158a79905ffbc14f40d2525f74f40a85166555322f1f70d2f4c06fb2b339a1b2af326ab74f181a4ebcce5d6e6b32fb9051a7e9cc2341be933e18cdf05087ece950e94975163b55431635214680eb1e45e63900ed1901c956df73349cc845b2a216ab50ef40049e2a0fc6b9bb803e146d5aedb7e4fdc789983c9ed8817ce44849c0ca78be6c68b159b3b8a97609dc37edcd8158226241d48b004d8f039933a65a25fa0236cb4cd74d06c94966ecad561f4a198f8487c8518669a09c76cc6ab824819b89d942325ca44e8dd2f9795174188ccc62a4d2ea26b5656cf15d7b2eae7a0bca35a67ae7e83d26ef945f036f900b1030d8f107ec1700caa943234993983d18a22a49650d76d20897aecbc70e29c154e2578275b2af301cd9257af42bda9126b6a1b51d3cc92457abbf8a38e9985799d8b2d951ba41710f283d174e059d883163a0ba2b624bc6ed34d99ce504e31b2c173a342ffb6f102b49e09585ad229b0cb2bed38bff2f439d37a65995dbae0abbc1048961f62ee362f04b4d213c22eb7ac8b7342784be7ad77a30a41233bf7b46ecb290f83833f9bc307696ea4777580c982a941c4f715fc34589d90f834a4adbccef9fe469290344b86a7dbbea28281f0561a5fbca2408e420ea552337eac8227057a935e8a52d892e0334c9ce596c635652108f790a16cbd412e96f3a9631fa5b76cdcd1d096178a1bca5a55a454cef8f0f51949590312af52fd24695dab7da521e9811855046b01d728180095e577b1c659665fd3208243b8f42903c07959e8901640a990bb89bc9cf2b1b4b0a014182183ea944e1013da0aa376dedf002b4136c0533c1ba5ef98054da57ff75b7a8ba7f0905690241fbebabec72460bbe53b34434e4158a7a4c3bf7172ab95a54de9030704f411f2e3560e193d60d7a90b8a68fe143a8300f0acaa5600cb64c89291f98d8fee99156c19c26cb4a4c86c005c5b4c74286f9e05416ed8adc9b0443dabcd45031a54a44c719b5c5a3f1d93b47208fd96a81c9eeec29d02c5bfb7d31cc52c95b380ce2b6ba652f96cdbd52d64d609064a090f33b5bf85ac07c2019eaee010202013b6c352bb2ada2e5dbe4661697ff80a0678af24fda14cada154ad109d768a34502f1ba57b035dd4df1e3662e40725b987da53ee41685d6fde29cc4b342adc9b43efd6690cfa5860dedef1a4361a948e62504cde6d35ba2d5a49d758aa21ec1439e477e9424faf023dda2409af5aec88c2b99ef188836c7cc52ba3de648ab5b38515a91687abe5cbc924935d37f1407150cd2345a7b90f4f2e6af4e259950ee6a07676a7f2301b1c4df9ebf65ec7e7ad5133889599596d0595e355e213ea6e7bf67101aceae57912a7985c82d11e8475c5e4aac4c3f01d09cb25441a6adb32a478309590a6e8a47d3a1c16a3c61608f78e70e7b7dc2dc45af4983f1c94cccf2669dd08f98f5563319a15505053770e6f11298d706013bcf3c60e3c727feaf918fe988819a1a215ecaf25eecb1cfe29232477c21f97a611945678d33728766099f9a14ab62dd78cc888b346b0709f917598638607ca9305263612d850c308be4401402ec908f0454546af35427ec40a97580069739498b124c803d968a10f1b8a7afa46ab84ddeb2511df72a696ca1b55be0bd0ecd58ec06909711c7b5a46a28d5547ee7cf1daaffc286401a45201e09ad4cec8b8c0513b6d0f097de3e6358420431f80bba358630827fa5459c551b535731f80e59c2cde40c25e39b763f82009b4f293383d5ea81074fda72bbc32106e688a10450914041825764d7fe7f58f2e0081c24e56152e6e8e475250be06c6d984c32752011dbcc593b5fdffbfeeaf99c5022f40395dbe3bec2e11dc014c3c3a2311c13d063a2f0fbad1447b00f87c80490824da5260aa5c85ca450b745158e263cab2ce3196d4056012db99b102a3100c6a3f99e76a64bac0e628ae133b3aa59006bd2d43959391a90cdacc87ac62a02ee4288121dc11159330b63de8a333fc1d77968bb7faa4b0166a25258b4e4310767b7a0ae651928a396b91d6d7048fc6fc437a0ef7237ccd4d4e66b00dd59f29ab01b4c9373985b515a7d989d8d5c8afad9b9b72a3054e9f8e195ca45e01c234ecb5d4994779a860d15374497bdee5f84618095df991e2744ae8a492ae497b846f48d88e4b58ac7ab46dd8912832d97873e79925ef0151a2d5a415c4b0de7a664f6a342d0ee6b501e22044b6513ca105ee3ca45117bee4e33cb01d461e78ed9c4204f99127636cd27ad2995adfe6206925d63354a8ce1679490e0f7895f46a9384f28f8c4a9cea12b48b675492948cd1c96aa7a9bfd9cb71adf730b7d83b4d41c28781d44e55213cfca21db544ed4b01a96fa24c8bc80f16b34abd5dd1b6899832e75082d3261a560aef9aee4651f5a150498e30e4fa30acb318fe21e917892ff3621c4646ad88b2cfa491a410c4a19df7c6091657125e3f49297b7a29809c2f7812f1e64a04c27dc801b6248c043de9bd5094749de19cd6007d97af0837aa29414e5148890be1f44c0550d3c8259770c19462f8b426bc3daa66ec46d72955555e0daf4245bc289eb0c5213e4353d5014c141575761f954003e3d0381c8e60a9a3fbe47607feab92f4dc8c66a6edad89ef52645c7d3f5570a112f49ec6a26e92761f6242c5ff7634567ca4fc4754e64e5dc591501639fd3c03633e8a2c63ede1316ff31e4988257ef77ffbcdf7a1690f58f47c9c42d73bbde0e289a73074cea6149252022552b3fdb1f9229034ea5747a56744e6707b8d03ec9245596b9a45173a2e48c1e24a0e1c0a6c41201584a458099c7f64a85d894fd7c98d51e352810e725f2a163144a8d3750888740a5e9439186063ba8a88209cd34aa2f4e11e91e0eb79f4ddba3e334eb5128b6cc825536940f9114ab0de49509212767c01867d7b918bd325894adfa7fab8669db630a03f7f3ea91182dc083cee7c83b1e644a082ebb1ad0b8ce949f2a433e7986f08c20120b1651fdc53667b0d20fb9a07bd532eae5700d443a401ba89f34502ed9f5477b62a52c0c666ae6daa0a4c659fdca3d28aa184d1994b09d9ed5661c919d488dd708f5cb11803e6132da66803d121633adb0b90039cf3170e0b37e65862bfca93611503c61074734b1535dabe239326746a2902cd32a92a0ad1aa9dab303e5c74bb4b2713989cee1cdaca26c402c1c868eaa0249d7ad4af0d6795e3d3680d09b79dfae20410ca217cda3c1760ff686ac454c08548961c5996541617154f0b87333c72a254de1e097bb386516a314600e041c444a7699478e5b34b5385e3f226ae00461af8b234efbf4b22d1e89710095321397a22a98179e92936eb336ba64d1bd35f7f30d84d07f344595035b30978e9b6c9311cd1f7723ed5346591f1188be49540c62932a08be7228441999a9d7a9075efd56ce0034a8c000928ca8416f91dec4a7433f24562e75db5632be999334f2a6726b557845a773768d8c9b8495dcdd4e474c6913676198968f139478a3f7e4da5a1821e8d25c52de7dfb4358ab744c8e44ed8a2e70a3a749341c53b230937dfde8cade31f4db385b80239c1e65f29b74681c5d8f5e876f113aac87ddaeaf0da31c1ef83695c3253864d4d8329a37741aba91c3e8a664a83f0b7eaf34b87b879b1757469a62410d51059f44711276347a1c5a3c7c7678d2f3a75368ba8c0174a1f834c1dce04c7c4fb5455f438e008cc656046e1ce7ff5c44b86bb6ac6fb3438021ecfa34b8e70ae7718788987121100e52f5b6300cba7ae0f7e0aa7d9326479bd643658ffd181b0c1f01042f5029cdc15d051113fd001a253c10c78b3f10357907dc7407ce136c8ce71052a0370a826f2a24443da59a7a38c2807410f999029f05be30586edd3b7c76dcdb8cf23e5c88df94e1ef26c93f972c6cc04283f90b5cc8f3afe258b0f4f9c19d1791ae707eaf9df318fdbf526fa68cdb9756d9f0ff85c2b923ef549a5ec073d4ad22f2904404ec439f7fb5898e27ac347a2b0b1a1500eb7f6f5635118d18852ac24ebeb50868c9efa0ae0cc5d007a401778f2e11cc6877d98036bf02fec3dfaeb801338993300e53cdb670634730fc83c9e28b1e80f620745123475ea5a4252ff5d807aa8542fb0c6f03bdb04e8525d45e9e91a3ec93c55016a322d8a7f02e8aad2b2be3d708ddd5d779dd63b89385111d5d8367e74d0f44be72d9280c1cc985debc2eced4503d3f7878fcc9b1bd1904df9d9f7eea4bd11db68b4f84df69ec13e23c66896b206517b34ebb6a6faeb6aba287327fb50c167388ca8f4cbb17044f47e952efcd10cb1e9d56c017fc51dc959d88c5bd7fdaf374f10fc9dfa2b812aa11ff6a9280e32e91b4a558c522727a8faee1a7ed56d7f00d2debcbbd3d9f15524c4491ce740c818957da3f17700e6f4d2deb0a37628284503368c8ad4b4a753eae0a4d637eb130700519400d800ea3c0c686825aef012d8b8fd9c8ed0b896918621602d239a05e24b81cbf602b9d0fd0b50000d3c38c7af7b035c6b9d8b56f782f5957386eb766d713d478c5f23e3e2507444eb57a78817369d02eed898104002d7ab2bf811f05f0bf1ada8770030925b691310db3640f63a41718a91e4b5d5a811222daf022e668e0cf15b5f4c1f40f4a14d36c3c7a7cc897444652ea15844500d1bda8c6fdb8c9946f094d1a96906f6970711a21cd58598c5d391bbfa0da0d26207503a85844ef6c57bf8683cc2400b9cb0df71e41fcd2ee2263fe17adaa5ef808f106af4cbb2a01c25b09da9e166c64c1749a1a04edecb6ee4285d50607d1a546040e8f2671d9a63500dc6a8577bdae4e8dbb37371dd292589c2163477b47401eacbb169348e6f2f1d141bc0ca8d7d2aa6246e56a4949c6e45f2ea7a064eb745193fd209a9c2fa0f38a01437e719a862ad0dcf6e347ad359e0685f6c6f138a069fd5dcc685f5d50031d0f9607636e61910b61e9e17ddc846dcc89508ad55a9045e1b13b70a17097c4022216d2102e80c3c17b6772cdd19298762b73ebbade239b2146a8db532eaf6d378ff39acc89550a640a46bf1fc8d04f7105280a6858c3e9100aa50b2f32b205fda164ed2faa9613b8b34b6ac1f1fb26e684c67f17ab955bc686244bd6d2e4124e669db06470e9c2f1a9804ce35a3eb54d1b3137bad0f8cb6d1140f8c235c56955be911004ca25d810472a90df4b6d1d0cc026440b77f83d2da8f0a17e009b6286dfb5d3f32e22bbce92081572c018b5839740794c965b8586434577dd6b4ddb3b36c6a77ef30745dbad89608b3ffd70f06d442ec0da09164087dba36f038c2820d3e6088079a6821e09bbea05c14801a2e787160dd9db28b0e2414990c6affd7ad95ee64fda22f1e1c8d6134e2054b4a7956ac8d46f5bf2813e45ecba3690cc10991684333e92900dd4fc9aa2980a385e63174ff12f998cdb4b39dd3cd4a9aa56d61e93c5113eb3473ec4d9a4c3b55d865d770c1dc69a5b6a8810e91c955d32f3208a86098500cbeb1628c9a93aa33a9b4eb22af1f7e33e77822d73b0fc3059bf9ba5f0f0726fdc4f4b639dd30a748eb8ea9e93e55cc35969d6d4b6c70345c5d16588c8233799272522d2725a20f106f60950a3eac8fc60dacbbf0e0e270a38f44f1820697be78ff8630b20a7386fb94a5ea3c5d11a0cdb9b79a743bf6f7f7de689ce18a6eabc4cfdbc4062011cb263a198ad9f06dc8364a2997469db87f15c8814167893b3c7b649e7c27ec59825a18a57a6c71852b23968563e12e22de09ac620a5db2036cb0f2706a4b579c523cf402a5b41fba1bb72953e281c457604453293ea7001e1b9147763d2a8ec587c2563f7ffb65c8f217c7395b56d648a779bbd6170c0e9b99337bbecd9ac8a82ec1b880eb4b33a5ee01484550b3a2456a02715a5b77c2c3207c6c158a69c578a549a82c495e5aabd192f10566b7a9c85941d39c1c580a6883081eb744b320304d88213f5fe64b0012f0e665dd7d62d9be9c345334a2fa71305ce4e2964071a768b7506f17b670a94ece1ecdf2e17691168d6c3ac277e2347525738196b25356f602a42400e3682b33f497062515a4bf4fed6db51d3933d5f4643451866922918cb67fef684d5022948a3515f854ae1d8e0530e84e7f274041d60005b25faa0f7b9e6137c68ac301c8dd56771048f7a4ab331d60a333053a139c4e21eb48a94dbd80872461441c324a515d0e0fa6c52e5d70e7d7e1ff1bbf41ab3d5b778e0e8c355e323b6fcec0eef53063b366676e23a35971d3510999cd83d27721f01e6ad1bb7b26d37ab5f8826089200e8fbb587294f18deb220b75a1b437dc747e26912ec11934b95e1551ff8b22e060eac8c09ae15d0b4b6be9afc75dda0deaae5e190305338f758410ce49ad9b9b75787b61a42e5dc2cb6a147a351df04e35d38c992bf985dc1cb8e87808ad4e54012de7ba0d2a593f142807ca71dbd6c5706194d3be79c0c6c11e99a2190391dd1970c88e76ed7dba93a5913e8bee33e0b6b32af9ba6f62399a6649ab915e1d6381083dea087d142d8171496ca623808337a0e0ebde307554e19b96ec224d0e9fdbc74834bd0a4a5f8dd8d93582a7634660a9a11252200046da4066c5bd4298b9669ee185d029c790179a43fc08b2ee170beecb6d3f57b19ef4e9e14720867500f83ece013679e5bc5ed613b8cbbbc4d5c9664aa790984b227b2d8df330200f0cc0a16c167a0225d6e1c1bbf3623e19077a6fb8fd20941a0b9309196968477e8c9a12e6cdf7c8ab8498509b2e7baab63fa76c25c4a5cd06b5069e952157203c83654f51f5a2b2ad1a434ed5ba2842e875d78d06dc8f595d91cb28b81a0bdff4da939462c9e045f8e914be8d359d3eed869d42da1694bc64ca56acf6000486c8e844982ca2f8ef43139f6e93d76016772d40177d16d7c457651ae4ae45dd2cd16a30f8b8f2dbf30e942c9011d8a2ae5d2a2dcf237e24e84445b37dd8435f4eeca89af80e7f6c0386824180445586f6ec821d866ac93da463624e075f1772cec40b134eb44786f78a96fff28e09468c81594d4c71260676f3110589e879aa0731a888f3b14428a4d5422d63f4076c15a77c2862b420ab1fae43b6e5f0c2f831379bf3af7fe9748aac1842d262487139e3550d54e1801c63445ce6602a56b4998b828a0c49a5485a24d2fe624e86b88d66051cc1a01b960f1cbdbe3cfdb50290400132a07819de3ae92c500584fa09beff22efd3cc9f6d7db49e5516f0d70b15b4168441806c818284fa3b031d5c5251a70e21e28e4a6ab554bed883d617c2418cab0310a7e6aabe1ff60e9ef71c54cf7c51e99d4ebdd9b48744321d5d1bbaa2ed6e2f6de673a1d97bec65d8abc57b7a749727fb5fa28cdf46bc475dd2fcb79e907491f6b935b90eeae631bb3f9576722ca14b48b7be2ee3aeb1d7bed76e5e5ddd6fba1f5dde7441754de9fa55bacb8751de8913bab1ba82bb94d37b5e0c1d5cc7baf6d3ede5bc2a0b435a4e2bf2eeb0372daf015d36b5bbfc43963ac8d635dcade75d23bacbdf7895d9ab6e48dd1ababf5c776b650691c7e9c2d415ac4b52d74e177a5d64dd8abaca5d8d783dea8ab3dd42e87011d2eeddf4d6f476e9f5f0f2d405ed9aeaf5ddbde744cfe0f9583720d17dada1678d5974ebe93ed4fdd7fdd55d10bbaff990675408ede6f4727a7d7a817a35ebadfbeaafe2a66b9be1facc689bf8c930abca77684f8956c0b8e719c67893cbcf07acd96a53f5706355fe36225188880a23fa090a0983b42efd80622050158e645920a3a3e79efacc0535e24664cb277d86a2b1fef7660e7f141ad76eb950045eb3a80522ad1dc22b8ab5b73c6c58ac4cbf9b9b927bb5045957a867ff01ed2017181711feca5a8f8696be0879c9662ba0fd6f2b3215cbedb600ebce62638facd876494f9e84ed5107e8e6d857f580f4dda4797c5757f5cc8de220280f2e4dda454c90ad1cb649e5d9b0d7d09af97b2e89b99a867dbb64a904208b51fca950279fd0046d09cd38f5ee40d794bdca940b38025a5181532d6c071840baabd90215e000569667e851533f098d91226053424ecc8565812c46ba5997b570300abb2970f659d5a6d528fa2578736588e78d00ed9a2555573bf7ac19bae4736776cebb85ef1df6f67cccd87173c51671ffeb0b2a98163707103cb76c5f70a4a6f42e04897f5d591c2bfc5ede80097d1e43b30ee56f59ff5a4fcab15fdd6cd74f8927b0eea5398ef55fe7d3f44d6bd641fff3c20beecee4ec0903f129e187add46db60bbd1da525e3033eec967aabcf936b6c2e49fa8003dd1574f501219874cedb2632f573b05c430c4b21e2471ff5086a4e74c6934d3f9b8368e66a687fb288eca34891b8448e8e2cc1b5c8e438694800864e62d8bb3d1cdd1b9f2ee83b8a2798a4a75dae39b5d0fdb0f59b374aa7e72ff32137519b284623602b02a7755a09f82ee10b290d1be4ad3d814fa6db0ccc198eda902a1181439a20f48686f5f016d9334c4c375937569b7ffd5523c106436c2fd8c75bb943e57a0c54429001ab84a78230814c789c1732e94046e8c4c017a30399598114fa5581e2126808ea8e405601b80c6418e6bff97423c83457052f37c1effc7dacfedd74108147102fd5fa380bf3ed070668e82ba913204d78e6272d5ffab557d7347489406e20b7e00a411a0532ed422048bfc0af00a0b1a80be0815509bd41ba5ee0270aa55ec546810cbf0722e39a7fd5ffc005aea5af11c90288bc48f03209ebf526023c0f64b247505134a600e5d7a8e7194f18a3d485c363d1b58e491b807a3bfc3748fc143b25120b08c5999247fcef837a74fc149423b1c2485860e00632697ac8ab9eb3c1aa39f64b0b029001c102d902b6026481a4106432498381eb0f049169b06924441db2e7ec6b6ac12881c31a647cae7bb34108826c1f85c3707edc54d8f600ad48d08d505c0632f9a6f40035952023490215d22cd0eb60a01e373c18580c2ebb02610f4d0913f8410135124ab856bbd78c8f1a972a8155098d446776e00d44a7a92750511cb095f42fd205d9ab573352e50bd60dac46cdfbf659e1d2c7807d94fb0ef2360932c11d28838bc08f1235000187ab2ba806eaadba654f65ef868daa2029c195d1347b68a1c87aeaad0b028ab53b972f4074904207f003fc003fc00f20db0889adb5de499429c9f2a95e21e722534a29a59412c3d7751fce38df70a4d134079709030935092849abb65d984491a3fee424a6e2a73fd8564f1746d50dbd3b9fb4051d2acb8569cee2bca8a43f8ee75de8c00597d4c6926c49cadda2f0b4af6ab999afc3166693740853f7512dcc277ff20875afca26b409c0600436669420081f1011392cf01a20e03043072dba55adbba8662db216c654740a22f24255981db3308aee1953e2d9202965094420821a23344af0e8a4ea90c58c1a353c7410e2e181808e5898836753caf4336ad4400974c0c268723ed9548b5f613a59a7962b2a115718bba40e2f4abea9e9a81506b93f71fb16962459b3c268b296ebe8f419f1d32acc419930419892df249d9781d44e154e03e407346e38a02315954e6a54ad96f11e21353c6c9c19666a830e54e8f2d9a6b16919e3a5599f3f5e44ce969119a9e314a652f9920a6d4ba2b63264809c8083c314a610a679b2c80f35cbf9606b187494c220bedddc454cd0771529cc7ae55f41f4543d3474002272a330a6dc29b92d1fd5ea1685d94de9c99f243b140695a49473d4149d3a897fb0257a07288c2e6245895ad3232ffa602b9f30594a1f269dd88e12c4f484a99389df9315d64f8c3ed8d63a612eeba4dd7992d6a5241f6c8513a6b53bef52ea3927c71f6c3a3661ca3b2a558a73fdea8cd584c92efe255325ac8e124a5948d09109f3ff870902e19d0688475a0a3a30619244d733bdbea47b4c973069359ddb36276809e21f7458c224b99f08ed163b23229530a7493a8a50514c5aac3ed8da2861ba50a92f9ea75caaf5c1662be89884d154c7bc18714ad8820e49984e662f947685f3794522615272ca387d79623d27618384593fdd95595ee41e61d0caf124b784913dd20fb6e208636f9a6625a1a4dc973fd8ce4464d89801f27b35403c6c887434c29cbda2ab6ea92ff7920e4698edaea477d30f223b7e4de85884a9c4f1f867e1977c4c14613ad1392de82ceae78e44986cc484e9a65a07718208533a5954f81cb7435cf77176b9adab62a525cf8ea13f091ac27c27ae5fe5523a9e2d84693e9c924d90760721cc5616b4bd9f18b24feb1884c184ba98af5d259bccd621089312ba3a84b0a04018554b892245ff75923f40184b527be6268a8fdd3312aa20082724e4e81f0ab36929c7cd9c5bae5c8c396b3bfc6012dd52a85a1377f4c1e4256a46f498d09d8422aa821a78c4a0830f26f13e42cdc9792fe5eb83bb6f64c8888d8e3d98b34bc9b65e930439793d98af32cb3a85f3141ec22c74e421f5c935b4db1380c1086ac08083e30735424254d0810783ca89a73b18b6949ae06f723c39be7630db6a9f60a5e44fcb50471dd00c2b4bd72a97b36c2ce4f88f2a41caec4e07f3dde75d0e6929f44c47c4d1eb113ae6605e7d0df5bfe35e6b92834909ea5f64b8dd5f34fde360f44ee2cd3e880d07e3096af4fb83e90dc650928e39a69d6e2fd5e106d37d3c21f465bb0de64bef954ac5b4adc36c30fe8d09195f4b0d5f91d0b10663854b265a54e6684b01e149c0c10184ffe85083f9d6f32fc813e75d4f3ad2601a17bdcc4b9ec3554783712c8993cb44cb9a1b9dc1d42d26754bbcd196630683ca9757fff94cee313bca604a2f222da7920e3298540e65c9dc741a135f0d19cce81883297fe7fc8d0e3118467aa83269fd92d8274e4247180c3aad5ce5e9f99ca7c4c376091dde9c86cee9c4afbf600af1966eeef582f9c58210e7e9a4527717ae7ab313b7994dad98756fd17392439570c1a44dc53cb1e537efa28e2d984d7afb8fa6e374bdd81d5a30ed7d527ae6dd3fef25c4fd7cc8143ab280a990915dead21d583049a635cf4787c99620918e2b98326d2d3ea592d74e4ac60b38389a091d5630763895b3b37c324c4a47158c1754c5d7621d543029c9566684c7765653c714f28ef3ba9495d7935f171f1374523ba460cab1f4e7a81b2a5ce88882c953b0f6b8b5143aa060b279cf13f3781e9c196a19e8788271942499605234f931718269b404dd1e4c124ac95213cc3177fceeb3f466e799604e41899730af6309e6a09e942cda2525983a9cb8f87e9a76720a868e249884db074f7e695b4307124c723577e4ee925462551b388e619254924cad9cfc388c61b439658276ecb929f972068e6298b4f4092bb292fbe89318a6f333311fbd3bfe05710cc334b7a2ba392ac9deaa55814318a693175efc4d46048e60184c67c9057d9ae3b10103d31d3c484be62f4ce2e2d45ce9926f2ff4456ec9526d56854b8b7535f2b282f7961ca6ed854910f9568fa6b2534962c3c6c13b0e5e98cf3e872d41d8c6077b17297da5dd84fd521766f99225d989df0825cec59ae95ad1dbce62c75b5792df4f52427333345c98bce5c63ea5a758da988170057de6020e8e5b984ee85293db45877f12c400872d4c7262e1653f6ab8273fd86c80848c88c858ae85b18332d554911686cff6ea9372b8291316c72c4c26e7e027a87d979c9418b42cccd9a4a44b905ac99249e2e00003472c4c9296539694c8115a270fffdc12b4b980031606a54774897657c2c0f10a634813b30f0e5798cbedb35af34c5a61bbdaca96b6654b75cf3ccdeece25439f943870b0c23c6641fbd4662e5c3ee158857176f4a792649978b104324315264d0f4ad250f231482e70a4c2b4ed39c4ce84bac0810aa307cf3ed87c00e21882d2672f23b951c34b1a9ec224dc67c9ab25c94a6599c2ec1dbef2f7e875f1bc14c6b724e50b7d5143059b145bae2eabb4bb751d9e3da51c1e85d1475b4e59beb38e2a0a8385eb9653ff3842612e25fe277f89bb711d14a6ca72594cbcb44bd18280e313be8f4eda4c505d042e9880274c27b7569cf8160c383a61545d51d144ab50ed45e0820924270cfa4d7bd28fe979d2de84f16af446b343cb9e18248980b489c80019b9a109639d0927c73b7b763765c22cfb6796e34149e0c084a95285ef94175fc2f4a6cade74ee78be74b1c16109c3e79874262c8921c408a4122629dbaf99f820b231250c26464428256f1abf4dc2b4b26179b115d44d2a09d348936276e364ad9f6bc9038e48987a2c6c54ec29c9b40477c00109c359b0923fc1843c1765d4a891c8e07884415e520aa9e15102b6906f157038c224267928f996653fe97cb089fc071a39333c6680848c74c88848238c96529ef49dd6f296bc0c3818611e7195f7d361fa10bc8d20c0c0071c8b30474fea55d7ab83072545184b94a45b4f8e2311a68c7867a87aa8572f5372124ed7111019365ec08108639e24fa872d9d43986a4457f024491bc29c946423f3528927d7c85108e37bed5a901bba73bf1c84307a0c7593d5ef20cce339f24e0ce5f971148449a92027ad053d9167b22aa881c7e1088479d4847eccabd97ad00d191f62839b0310a6d8d9d3e7fc273d6a7d8c1c16e4c7c8b1914118b9e4f80356b1ec6a634cbd5bb37cac73107e69a2fe317258c0c1f13132c2c1a17e305f366972beae9bc5f203ac0a93f6492ac928413ebfa930bd68115969c162afa830d8a7480b699652509ec2a0e24f990a52f468690a83dcc53b154f5c44a530e5ae20eaba39290c361f74bcaaae52988cc21cd6a669aa4b4461f435dd925e234a6a4928cc967368adb1d4410a0a63c5d2f1e3efafcaf409835dda2755923c6192c4c4ce897fe9a64e182f48d1b024cf0983c79ccfeb1f59d9df84b9a468116abce25aaf09d3499fb9519e4c18f6b26e9c7c4225318409839e494ae91111a7722e61b293827a7ac5e7e558c2e4392a8ad2719ea25c09838a0aafcb2f254c6fb735df97c4f1741226f5f9fbbe939230a53f490811ad2261bedd5d4be13a90308993d352546d8ab6ce23cc335b7ada29b47a92234caf7b4932370b96fd469894f849a8934c18614e25c9b13bd48a5ece224c175774db3d5bd88b220c625e45ceec449872927e6f225dc562441877f4ca2cff9e68da4318845736c9f7358441e4986c117ee9e52c84494a55c1e5469f1426218c6d3909ba94386f826c10a67c26eaa912cca365451026d94356c6c711e656098439fb870061b6bffe2cffa46256fe80074f1955dd0fe6fa792b15b7b5d3ee83c92e8e0e9bd712223e984e3a0be1fe274c76f760d029087562c57ac57a305f8b1e1d6b1ecc2e7ad4f9a5783099ec15bff6bb8339c7495a449576305556f2ce72296bb93a183fc95972796c74481042c8f3cf5acfc1f84969a8d5fa3442d57230c9a8feea8dd697521ccc696d9f544576551c0e462f9d4bd408bdc130ef234225533d4ae406937dbc29b96b0f0fb5c17019fa3f8657149d840d2651c7732baf3598048f3e7b6aab4e76d4605092da2739c53b7785d3609273eace1f677f5e643498a4554ad94f9413d9f1198c9fcc44d39db1190ca7f38c302fd9affc32984ed465a98eb7e1276430783c75d24236bb4dc6603a7949145d256230e5d35af154faf76c87c1204b67f3e3c67ad082c15c2697d2299a4c4ba25f30765730c94b5e30ca999e57f4e4ffc92e18ed635fb7ecc5ff920b66bf4ae2762ab7600e7d1d4a27cfa99d168ca2738e995fa7f27559308a2ad9e7795b2c9884efe027bbed15cc2ba78458e8c5d69315cc41df8ba59baa6052ded9d3b253d03351c19caaa37988eea8ea4fc1d427e90bbd242779232918ece4caae2ec9841645c1dc37faf7f6de2a28818271ee5a4d499a6ae9f20483bafaebce75ae753bc19c3c44aa5eba09a6607f1f3d9f5bd033138c6a32c593bb4b30d78f4a09a61b694a2979b424985c2d0927f2c63d8a86048392d23e8eeef079bd631877cf4ae82842c6620ca3afa969db8a613e41cd7897f061b4a6c43088948f32ae0dc36c5eda73ca63e8662a0c734e1f2b6997eb9e4a83612a532a0973a6835e1230cc298791a7f3bf308d6c8c7a2f6194ecfb829d7dcffff47b613ae195f37249d0d6f3c218ab5aa12e8db9eabb30fdffeb29f9dd924e7461d86ded24654f2ecc23f37bdbcbc4380f2e4c2a9e3b4e7dd2fa975b18fc527c7f4ecac2a5d8c264e94185c9762d4c6a61f2c930a13e575a18d552f6f924ad5baeb33096bc54a7722a0b9370e287fd598a99672c8cff7ad2c68dde37818559c5da4d5d2e5f613893f2f44f922b18b968af1ea65698479aa5ed9c7e84fbac3097a68a7dc719b39c5518ce7e2df4e4ad68a20a93a47167b25352618e514f4a33541843c9d36bda97baa44f915222fc047db229cc39a6e9f025a514e6901e3474b2f029aea4305f92426d864661364918dd1f11da9e8ac2dca33b4ee8bc1439148651da4de78a7cba101486731925cf7d8a957cc22016432825c7d013a68bdbc104a5c24e184fce29e72f53c1c7424e98e3bd5cbabf8739a54d98d5e4fd88993ea9e49a30c82bdd75c29e09839fbd27956f553909268c71a5f774782e618a919febbea48f53b184397e99c99dfaab84f9bfe4fcaf4b09f39e64e296ba9c525027618e3f5acdd3f98f1825615215524f4c353bc945c298f2a9c4c95d694d3b481854904f9d5a2b9cccee1126d5f93d7ad6aaef758e30e82c3541da9b6c5e5d234cf9f49274ae7e57d531c2e426a7ff1599351b5a84b9b2945cea278a307c8ad7e9de245549893056aa4ef52375748a0883c9a57b74c58a501ec2a0a4943f076d6782aa18c29c93bd5ab6ba10a6de17b724ec57384b7ff1c38330d7985c2e72bfab654198f2a4104a4e6a5a9403613e91f1e649de2f95058429f8772595a42f53d23f982d4992a0e412f4c48ffac1bcf9bb21d45c929df6c124d42939db9412cc523e184f8af638a54a1247b907a3a9f423dea2be45d3f460ce4fb597d3cc83d96d47b6bec9fb56e2c16079754dafab787f7607934ecfad346d3da9991d0c3bea92f4252c8a685607835a4bb24952d492974407c3bb9fa0533acdc1242e49a1bfe29efe921ccc9adb41e9949224d57130557b9f54c2c16469fed2c28434417f83e164f9fc2eba1bcc7e552a4ec5d0d1416d30578d8e2174101b8c57733d622d073fd11a8c9f4b2853f293ba6851832997905d49fec84a953498b37db455caa2c19c4cea6798588207f70c86ef4a65a7543318e4fa49eb6b49977019cce9aa372cc5899592c1fcd94c6754f2b4dc8dc1a0c45f0c79366bb75589c1247f0c154d8979f5255961307dca5652f894625fcad7402f984281c1b836d23a97dcbf605dc6bbbd785ac8c5eaf86c51f289ac4982ffc1565e30499d8332fb924baeb5aa0be6926925593e8f6122545c48aaa7aff821ac2d187dc6e74eb9a985bdb2775da6c6abd7ebc5d3f569a9da56160c2346794ef9ce55410d3c6a5058306a48efe05a5fc154826acddeee18ff90154c67294ec6e560150cead57639c2945052904851c114dac376baf2d3693b3505c35eae79de393fd8a4600e1b65926c4af688b61f6c782021231905c3b5883a412e37c6836c302828982bcd9224c90a5a6e4e912718f54a3a4ff2f555e96bd47082b93dc6a68d58dca86e06d504c3253968cb6ef557ca144131c19cf27a4b92a4be874e9ba09690a4c52a2c2518c3ed7c734dbe888e6f25c1dce7a6e494d57bb70b09c66cebb174c24d10fa3e3b86495909fd1e5c94bc26c518265982bef0dd9e2d86717b33440cd3a9ecbadb6d7ec8304cc2e30459329e1fc46cc230ca49f15db9aea4124f1f6c3ed0609843094af283add3c88d326098e4fb13c424fffc5c930fb682444066e42f8ca162414bd6764b612e41872f4c62e1b405ab245b762fcc76268a67bf796198bdb45f8613afe3a81ecf56124901e2217d1684ec5bd73ed8fcef5806780793a4bc4a76bcdbb8bc201a37928709d00ee6b0aff77bb2223550d7c1b0196332342f1b403a982dcc7f4e594bbe2e3938076349fa4e89e19e1fb3837230d7971c95837e1de360f0a482d041ac2465c3c124a527a9f49c341584928d1a6f307792f44dc5995cd51c037483418f29a57298c90949aa65886d305b3ca9233f55de6ba0e7410d1fd0280107870818816c30aa992c39467e7efa6b0d66d39ef4a8c5a806b34793b55cb2c8fe5b300d064fdafddf4af2d1602a9db486e797eeec9c3318deabeae7e33efea56630088f23f65bff83924f1a60194cdadc73d6de3edd514206939ce3def3d7640ca69cf3c8d28ffd95223198fc3b89bde25fa353270c0659420a06a3b598b0a1bfc42f98dd84aa28fb9f7126e805c3c45ec3c552b06daf14b4546fb6dc74494bd205f3dcbbe9d91dd11d6711b151c3a3900b66ad68d5237fadde1d8d238305885b3076f05379f1839ed3e1c7a1164c999697fb3e6300b39055d66856cc5bbaac7026a79cdf4b59c482c9d34e094ab89c2b18be6409bae72dade2bf080216a040042e98809a26d00a7cb977785d6d886c85d1258daead94c42a2c77a544f9091da9603cf9ea94ec789eaf94e0140c4add892daae45c4b270d11d0484f402998c410b95ee27a2b58ea83cd460d8f432460140c3aacadb3cefbc14603a1602aebf58a71293f07133ec1d8714d977f3d22726494ed009d60fc142cdef67e12bd0f0ac22698ca2413cd32edb4ad432f036482410997bd8ff9f62f7a1f888c849c11912598367dafa42474b76cab1aa804a3f89f244c8c8b93ea43a3c68c1935108660124cea5795df7f1dd038211e6a238804e3a86579f224aaaeab814064bc40051c1cf908448688d9cb4812101a770c63a95c6277d06fd501a146e2c103746424e5658c243744560535f0a8c0196359ed12844a7e128262182fdd9e891a9d2742ec32561084238651de2c98ba4f0dc33c6362c9134bc7eca84e1826614de5557ad4b5985f304c96f2626aa2c5c1c1c131850386490e7d27c99b17edabe417c6fc53dbf9a2993b8dbb3ab116eff255d3f13b7e9e9ccdbb5e1876adde4b12345e183cfdbbdededc85712d49e275094a5d1894d29f4d10a57d827a2f1706d5d034b58f7f4a3e8b0b732c3ff1e27b720b83e7ac7897bee6399dd8c2942eeff5d80515cb502d38d178f9acbaa07a5bb93c7a4f0be3e7f50adb4fa5fe4274b859983edb28397d9770b230f889a6ae73f0b8658a85d1cf47ffc84fbb9d5f5898ce4407b7bbec15461bebca15a6f30da9a2f7d30ac42e2cca8ce5504b277a95b4b2fbb7362b0cb282ca13254fee746815d65636bb9b4ba3f19d756fe1ec842c13cfa20a838c097f429c1c97479c0ae3792a49e7d36e264e438559dcae4b924c7a8a4259123f5318ecb7cc47c7afc4b74b61ce65ee152f67cb49795214b5bb3aee2bd7a76dad658892b398d5a33075da553979432913af1385295dd8863eb19d47edd9830b85c153570afaea2bea754440e1ba5b8a5a49ad4f982fe9bf699fd21f4dda13065b3dbd2b4149272849d7097357b8a09fa4ead239bf5e384e18d46bc7b84ba10f3619c7ecdce881b94d98d2b7a5aa9cdb7388f35d5034613aadfde741492f13c6aaffa417ec04214a4988e1e038210f72983098a5d56c0f51f273b62f61f4b10f4afea44a091a42219c258c9f4227259c9c4feeb815e12a61f8b060a9c3dc892fdaad0a6ae06183a384a9848659c951547616651c25dc24cc2f4ac57512164a9c931cc249c26c52c5933f6ab288ae46b848942b5cca974ebcc141c2a04baf07a5fd5dcdef7b8441eb99de7aadf4f88f239284d59ff8a88db811e5fa12b9ee107b7b59cd3ce11a77a58212de3946982ddde52aed27d494d8224c9e54f80a72564ded451179892faac43bf3126152feaf972daf890afa21c2f425871357f62fa9b97708c355db7fceb69e214cdb77ba5784acfcd10049f60a61ec38d144b124e57ac9470873e6b789bf3519fbfe06612e3be526990ef5d3f69f208c26331fd5e402618e3ab25f8210f5b59d0e0e10a9a552b1512bfb0aed4e69f13c07d3ae87bc0e745043c62d10ee0f6ec8b9bff6d12b91c1f9c1fce147e4ca8c2cf1751f148bb714626e25df16d54a506a3c4e759658f1f8603c133de588aab894f3116e0fa63ad94ecb98d827057170e8800648c88888c78dd343fa29492d0b7342270f57b2bf92d5925f94c6e121edb157d24299279d34031b77874cc35a5ebbb3dae325b19e46bff4ea23221e36446670eee0ec603ab7ec7152086509ae0ee6ea4f82b613db5309277430aa7b8e65793ee751627330b7c94a9e2773474c2707f3f625f18adac5c1249ed2d5c1c1e849e9e93149c91b4c49861026ba17dd3de706838652fa96a349137f5d1bcef8545bb939ab4b66d244ad6851d7e4d860165929cec7d21a8c76764950693f4689abc1a4be453c76c54e17940663ef2549c9374283a99327c9c4efcae549ce603a25bdc74fd946891e3318e647c7d22e6530ec08919e7193c1d41a97b28dc1fc39aec991264a3ea518ccd7e361e6bc8292c63018cdb4fcdb6779972e81c1204dbb2f1844ebe44ef67bc1b027ac855c3bbfbb0b26a5d484e90b71c11cd482103b275b309d64668210134f44470b06b9962a3c56b260d0f9d35b5d8d05a3e737256cc65730fa5bba7072ba24955ac124447a6ead4fd258f2ab60ec92fa79a194b426f6543048b91735da340583b070c19485f2517a2918f6635ce7fb5130eaa8d86f224ab47728983ba885dc18f917fd09269d24bd52b932490e39c1e8490aed67254d304965951e6b4cae799860104ab4a52429f7a02f4b30a7a6aaf6f77c4a3089b85df83709a696d71a1d91f2be1e124c49990996963c865174cc536951725bd08d61b494214edbb675febc18c613f6c4b3b29c180635af1794cacfdaf961182f9a7af219cf345d18c633f5f3e8a76098ff656c642bc030a8feeb906f3a55aafcc214dae49c4bb6a074dabe30a8d0e14e16a1f2a8b917c68bd6a2836b658d14f1c2a4ca42dd785dca268a7661146149ed6249b2a514e9c26c99a7848b622ecce19df359958f38e1c2b4fde14d56ad3a93bb85592dd693203d4e3c6d618e596257b9a96ecd502d4cf5be7ae2b9cc2749b4302729c5ca836cd7d02c4ce13c78ee139dbd735998449ed83f268a85295b49f23142b030456dcf35695ea94a5e6110aad54a1631492eed0a63bf9eacdeba15464be993480baf92c40a838725f511b29d6f5e85b184d01f5a7c76b316d8ba80d905eeea22f0a103101a17280e5e0ea34001021084e402fe22228f6a84d858000046446eb8800001781d9c1b3aa0716420400022218f6e788d101b09880100020000000040000b00000000a080f71a342e20d2ef35683480012b0262e32c20008900808848c24100019c91e31c0508c019395e2384e300001800041210f21e0c0040001e708020d8e005828cf800c477812023323e448e87470252173666a05c24af3123152071615cf53c13363d086dd25b00e1cc4804485b1c206b812023211f22323c3c1290b430c5afe8a973bdb3307d2749127a61f2a7bd6561aa3e0b2ab7eccd95508d19337e06cff8199bb1c8aa64f9bb1cb38166fc8c9df1335013168906c88c54807c050d90198900e90a933039efe53fce2e5e6346fa1839337203d90a0419f11a336e7878242059617259339959b26398f083fbecc69987bf1040641c10f436448a8dd00041111a202332406e241e212dc8558cbcc88c9f61805485d798910890a94840383352011215083222e3c60c0f0f04e4294c996b623fc8c714e67eef20634adaf81db314064f5be2fdb32895a693a41885716c8ac2943a7b10f2f4e85bf364288c9e2dc8bbd7b7fe17144611622354e446e315e4274cd2579f9f245e8ff484493095bf53fc2a41cb101b40f84e9892bc8e4f52d65f7a13274cbda6b43de8b44f3a64426ec2e8a62b3c090fa6e2b7d4c4952aa558a92e7d651bcd36794866c258f964dc73ce0942942270c1041213e664b2c7eedb4a55335ec264f52727597c63d52a6909e3765ae94f59a98451fdc4932ecdfd9f7a29611c4fd13357ee244c954f98d60f3296ed9384e1d35c0a3e62dedeb48c44f2f5ae2297d6522be4b28dd07ba71adad9848439bfcfc4550ba33dc224687a16154a6bfae97070a4238c955f6ed1ac64bb20fe60f3b05163cf04d908f3a8df761125c60873caa8ee9ce453d7cf2fc2f4ab57823a71f74b5a146192f784caa23d904c8449ae54ce9ba1eb732d8c08539e7ac9a3a64b16cfa143983aa7e792f25677bc3b6908e30533adabb2562a540883ca1bdba5122184f94bdb9b0e2ad7c120cc7f5549befdb5fc1c09c270f2e93022fe48e3200361d6bea43b7a98db5c8e0e006170cb5b51a2a585ca655243860e3c465ea4d81f8c6392e82728a52ecc637e309ca04a92f298c925057d1fccf94f2a4916bdd926a7201f4c3a66265f540e22eb0f6a84e8600fe6dd3693c3789204bbfd834d0fa62ccb97041f59e447b4069907a3c55392924eec9c04b58c0fc183c984efb2587ba972971b7807b358e9854e2e27fd441a20891d4c1e4caf6ea7e8880f505a1d4c9220ed9467e9d7ce061d0c7736d25b3cb6ce723f0793a404d9498e92fb602b72304949dd79cebb566a486226838c8371b6f333c7a46839367e4424657088c68d942a483898f20815d3c193f20daaa8979c87a757fecfbd56da04991d0e0e37184bca33f7bf62b6e19465477f967daacc68241b4cd963625e0304366c9c909155410d3c6e906b3065c4c2dd67cc254ba5de56f24dd492d4e239483598d693f89877d134985d3cefa9ac9dd4c8190da60c75722c693c4b797f06c37a9c1394ecde0cc63329995c921cce949c530673573ce9697d2383612ffcd8889534f623442e30432167390663f52561f721db90111b2906d3e7effc24491eb530988338c94b54f23269a604832673c962ddad5adec5ed5a56944eda7112e4174c3254099e37cdf482c13bb848f5f4c92e98db243769bba28dff13a8a0061e2e482e98542c754bc7452fc73fd86cac6dc1a467ba3d94ec95fd93c8d91101c1d4827188c0059d055350c2633cde050ba6a454a509f369547f2eaf60b090a3f27cc765f52aad6036314ae6b3831ac82a982ca6c71331f53962ccc54052a1b94aa55ea72d6259ede5144ca17aefe24af61c264f2998af3ca5d352b28a783ca360ce3115fcb2bb75be100aa69caff760a97c82c9478967f1b2934e30951244454d5213d7441f6c2320890648c88708da07b209869393eeb3133da88f950e24138ceb2979c96df15c82179eabe7243d359e0f360fa3412ac1e8a59f6295ee83d13c904930894b7fba6e3a5b094a9e4622c1bc2545ff1e773fd8f818a61b517aa55f9d52461f6c42e8c17b84241e232033decc18e6fb64d9d1c35a9f30fee0699462a0426c8ab4301a0f6880bc203d80c43056ffc9e1243fdb123e1f6cc330d8a7cf262bba73e3000ac3a43fa4cbfb97efbafec1e6f13e001939323ea42e18d6ac59b433710fb54ad1732895a4e4e2df0829d6c030f8a8784e2a5b481715d1b8210210fcc2e47174cae7259ed2657c726478388d2f6f230830f819274404692f03847d61d269eb63ae27a47fb017869357c4ecaeafa8517961be8ba6d2a9b57117a6feb292e2093a8a757461182594b01667920bd3769f24fb4fb034b9425c187c2feba756d589ad6ec1c69bab5a0adfa51dd75ef25e50137eb0d53822201c1c323e3928e0e07819203666d4401c1c2c40c1a22d0ce22bf7c2dce42446570bc3d5c591abf849848ed1c29cfec4ec5de66fba6916e6184b4a897f0e29a69785399824a8fc21be047142b1306a7ce509164d4ed21f58184c5578b4e4c19368e32b4c9dd4ce6d4cec0a53692dc93636bcdeeeda56186dacc489134dada88f082b4c925ab14f4ae9e0a75d5c853989e96c71848926070668daa80a9368e6a2ae63d2dabfa9309992b257befc537e212acc16a746cfe675d78d33c0536061561d6fb39d366aa77da0298cfd5be779f6a4507e82a530b577f04b625ddf4ea79014e620c65198c3a5d47759944461300bf5ef24e93db92ca130697a0963a269e75853c9fdb48f50e169003ff103f44410b013e911a7656aefe43349c809c3b48285db8ba5ec953a4775f1e0260cdb167af5834c13c6ad784947e4a5f5e83013869d5382dcd88c983086502a7e5749f2323b9730ffecd58e7f32a5e7ab21a3aca025ccf296e3f2f9c70e0faa0496bf4af5c196dc10c112e880064872e3053b05a484d1eca4a9f211da4eca380993b0f8d1c46e64953c3ed0c899718792304d89956a374c3ed8426c00e13d641c1f7c62244c76af5fb515e4724148ce1ed1382322344a900609b369114ff3a21f7e1f3e42b170e9dd6d2e887a59c54fb2ffef9ca90374844168d7b21cd637c274c19364d7297950254698e452be2df33f96b4651186932d5b8a3028d3237af47789308baa8b735751829039228c95e4bcfc5582fcf2d0210cbab492fca8723f416c08a3aa0725cb4e8cebfd0a6174cfa1795a374218439ab60f2dd5208ecfda56595171d30ad71022ae65dcca4f4198468bd82dd11d1716d141c8f1b00b84c1646a494a673f893c68dc08f1a8e108085332d1d3abb5ac05ff60fc2d495e4ada154ae68a7e30e9132e9fe8174fa50941807d30f6de9d9ede356444d33c66dca071c807f3788f2511d332a2f4b80783b0b21cc6b41bf22325b002eac1246fa851f2a8fc1425f6c126e2a1c6031a373e46540598878951a8642c858342d27030168c44025130105236cb0100e312080020601c8ac502c2509ecab9aa071400037044263e3c242220180705428138200a06c3602028100604018140301004851e12b5466aec6dd202d642c7d1043a3303790457422b52b1483765c50ec603e390758149ef1a47ccd51a256ad7a2e30d23725ebd5c390a40dda5cabbb9717f88fa83d8b896bc0928eac4fa97dd102efab30dfb58fa3bded1b9d10e8546d76a118e1c7db2e8731f9f7d1d4d1ccaa4110e4e65f18d10bd829455e32ffae1b30f91a700bc1ca8a529d8343d6a8c7151890a723baa76852b405a0c5136421b3b0652fa88f6dfc192d60c7b43bffdebbab681df7f89f73aea123ce3b6576a6073f0fc6250e4f2cb84ccc00f8aced3ac643766987c360ba84482a1b0f5c1aa89f0bf35e10272e09a962168652212740c44ce96238fbd12658eda8941beef21a08cd2a481450f73a0818bc4417dd0255067cf95fa01007124cea80f88831e7652235a0a50afb1d7e731cf341e044ae71b71316280a05e5c349e3fa2d75c7f7a3f2d8db63885800b15fbad77d2f0671046049a64c10145aa098011d16299e65000abd35f9542496231ea457845d2a067cad9e46a030ccbbbb8ed374887fe5c083bd8fc8e6cc4ebccc5cb17862b9da243a72582a8118a599d8b36ba711a87d89898b4002a655995ca2be404f2a23bdf430e88093b2a0690be06977f38b56e30d0fab96c7ea6cc82c62cff16440f2171544c2d025c61f1925ad00fb72917faa9302493f43b14ee2a6f4e310a7bbcef9458daa0e7863a7c43752e0fe720907224f53870c716e0a3225ffb68efb1cd035717e80f26283493f19f6d3b39b8414abe59f047bc24ef9d6d088edc2de906c7843cdd04319a535bfd982e4459fd26ca2b9b1228e28e41497eeedbaf08a387f5a87a5e51bfa44cb2b9465972c196215d675b0f2e6260dcd11756f37f755e2c86b95d9a01d8102b782d16da29d22b8ae7b4e6f8883ad1f322e26fa57c80bcae8b747476d411b7adac62c233c2619ed943a4b876ea232ad1861471462392ef62494bf68e048d312d54568079b57794281c91f827e3c0a18f157c5b0e1c65d24a58a827e17c1a5378c930ffd84f3238cd837c11b905fcd88eb61f864b6079f339f45faddd987b29f6f8072eaaec4800ddb11689b7ecd78fb5204973113050a121e0fac233b40a106490989d6fff2515f0da8486682c5b705cf471df6279ec4965f206ca8896e32b9c34d589a659f18aa264672d106e0e19b5d3b1c66f6390c4519a8cd6d17f805b2f8677b6a7a8bb647356f9bf3effacac6914789ef01a39d5d775d634ec2c8921437e56501c775ea6f98e4ef902b0adf5ee88f9aa49c5f7010e6b16e6efebe134896b0c5d3c43afdfc09ae7f0588987216b055276cabb102522c103b7badfc9c42befd4e2deef1f42548e55c7de9985927e5a47be46ce1ddece4bd331a29b5a9d035deab7216ddc26c9261fe9920ea204740d41889a950cc5561d63b0070a4f8848e66172d69fb4f4a9ef5ad9a29ac9fb3ac05e14932e6ecae241ff586980da5d5d4a733f2f2a57d089ef538953137aa0883dbbd042f48f1de869728dcb57129f478199153eb1a7fd9760b4d585c6c808a537107d605516310bec2e7388d483190439d129e099ad6b04d5548a42ce1982aba0223972b107efb78e2568732db94ee9bee544b10f31adb6b1f9d8867460ac1bb5c450e40a5985c0c316ff80aa34138a361bfb291b466255a3210c72f296335e37c5073a314e7775f146eaf05ee224dc4393f28a7e8ca114448643bc0083899467574d3303e26854d5aa238a4786530804fb26961674882cf1a3f164063260b83eaa32e434b781cfd15f4a93c3bf8358b63dee87d00e9828574a92a5d539b45c37f24bd7a8c5d683da32b2f45e6859b6bca23221cb529d871ad042bda4cadf28ea4ba5bf07521e0cb0089868bbac1be6d46010ff54b331c81164211d7baa4711a898b9b49a27257f7e4017886c659e9aa19e4f9bc9bdda25c66d0fecde1dd224c7b9eab77faf1fc35dddf7aac41fb3b8102a30b9442c76cb10dd6b614bf1e3e692041d902e9b4e035a1d82665a484b778bd1bbebfb73897f9e8e0f23423eacc2d750314760364849fc49bfe1496c7f5671daec006a8f4b8305a75c00b937b20c78b4a94605cb0ae9324c8529847636b603f7ad512d5e02c681621a52f767082127b737acebb3b5b11fd93d8039027f1a47afda0ee071645304ce4bd77e458ee384159e6b5b587efef9df2066adc1e2932155486c8ab88e3a39f5616307c6ecaa44b573ebc61c2081d89d8428e997d17d016ef43d30b788b71182ab1e471588c1cced97288a4640029a6f51a74a070490db2c59403c751c0aafbe6102aa00dc361b6bdec27aee50f94a7be8695ece5ec5dcb98a80a8e18d4dd63c68bfd2bc9e14d42ff2ceefa39cef1e11084f0f1a99495a9d4c9f412748abb5e2fd1e0f45c9bd0608118b0a4460278b3723903530dd94d965419d70ee3a751e3e04a9e15008f8e51223fd921cd8a55f2ca5702231a0f64920d6b8679e79eb2c9ae29045d1bb37d4905abbafa59cbd9c5b197790ba6fce4a497be58a6a2f7a1cf12591b29226dfb22d392429adb9abc66b59f03ee64fd6d081af2197e63f971f24841804c03b129090293e14dc23bdf2f50bcd29f3e25e29e31f0b9ea46ef955319c7d788e140e97cca1ad466a0785adee2a000653f7b5b09b13463c8368dcefebbb4e761c2941bf36b6dc215e57731fd5c6633297dd722db240eacc4c98632c89e6a23d3e925db23fa3c0d4b176cd1cbc307bd7b22f6081302011e1eed53f45c63cd3d845e220701a9600d2670f78b802e9fc65c602827741b57fa7653382338de1e8f7d485d20a0bcc46f2472c9fa2bebf602c1e04ccc41210268a32699e42e3b906e50bcfba8837ca9235d17958ce868c2615f02ef8e811ae58cd7ddb196f550b521519713a543e5f8a62024e558258d37082aa6938d7e701d01b83d938945a8c84b4d1cd167b00ba7dd9edfe07c50e653f2844167133d42fd970dfacb889930514cc0581bc948ef89fcf0bd66b7968021791b468518ab65870c72a1ba2ce420d3bb897c5a55d275278d0fa7f67e638e742e83e872b2302b4b5f7bbe0a70d290cac1ac56c52d24fe589f3e1d3afcb49127ddae7004546bff062c62ca2dd8885450a3219cfd50fd84e4da6fe0fac56bcf6f9c6bcf64278b465a209adfed5c614a057ededcb7bff2c0088965aa85afcfc4d04273366da26af227c9971d84092bebdbffd14a074121d1ba617910216d1bf8edb6371c10b601340450413381867dc080cc733a50fffefebfafb7f80b51b00fdb7cdd170e0f13237e0679bac452723101dc83234b5bb1196f5165dc2aabc208994c186295fbf700b7d18e255965977a86f0eef1a2fca416265cdc114473f318f992231e0982fc26a1f35c3f8f7f5a43736b3dbddb3d1056673b6da7f83a3b609a38a86d8abb86a566bdda4413ffadaa1d6551aa6a0317812f3fc1c7769a3b8417da10e8a08cad44af99a7a8b45329702d65d234dc41b0d419d5e12c5abbb88b95e9f8161b439610ea18a474f62c40284c81380bcdf8c038a89ae78c34098f036c5047fa69d3dd1b878c53dfe695b5f8864d32d390a5d7ac2f38cb4d087e5984056ea6afcfa9ee0234576a10a784af94d92fdc6f56543da896a18e9d798f36a8506ea22f48f3eb5c22052a76de41527395f18b92e0b41ce1e4f41026061715a73fd0ec0eed3ffc31e1fc66525340bae443a40628a57f349ed51beda8ae2359c5f76249fe3f9f8429858fa18208315a9a298333d2380014232466f68e3d545191ccb7ab62e2a2984d5bc7ea28cf47c366a6218b6e0a8f67ec25ed86fb8b580b2cc49d5d9fa7647a0ad14fdb25e430260a5c28218c6e48745e3c70a16aacb1e4f074503a254cceb27b9cc0fe3cc191a1c72d1771522c51ec0a18d9cd7b6d9991028474346be9c31ccc2cf988bd23c0ee7c4cc1f4f6ab499061df36abf8824cd42b292014f9be97db9a9331eeef10ee40cc8561cfcbe8e4d364cf0cd954ff8d7ef613bb4be68fc195bc2ef2477dc962cc25551bb74b22d0477100727b0964eb70bbc1ac0baae647db86ddc9b4ab7cc4d0e12f150e764f73ab808b767bf438e3a5d42f9fa298dc7abaa9639303301689d189b64235f0eb415965d1ab3d466d6c6d1b07d4baf6075793f83dc77e41e28cfb80885827f8a506d32265c5918d036c3b23798a08f4b8268671e8435a73d7d9b09eaf040dba1459bb5d3375286baa334784e1864f848bcaeaca8607d2d18571c48938125c65eb8dfec2fd33904df9d443641eea5c250f71caddca2882c2824851a965b2751e525cef9efdddc11c54158d7dcf74f83f29fd681d17852d9d57f3948befa84fbec052cfb8109234973ca65d8d9e6bcef4f9854e5803b3aba0f2e8abad37568cc5464bde14ca3c5e76839ae278c151449cf0bb104080756b907292fe9ca1f72a631ad64e02e3066e31aa73d1b795b1c0ac4939a7314e94416dad496d5fb159fe49f9a1e5eb428c573b8aa35b47385f21441503d741872fd1730b2cbe066093f3d511c0dbe264f381361cb6f93e62da6e55c6445320de65a10040c8cfba98f908752c813f049a27450466a0517d21ce714b064cff6992cb05c330ad441f9b7862a904439ac5ecbc22b8e72375c6fe8d7c955391cdb338bff23904a681f7176fc53f05aaa07bf301b23ee5bbae34a9354369c25aafb7a39a7767509f09f5a364eb3ef5918d91ec179b9b594392f67a8fa435de527bc133ad6b489b2cc523252e7101ef287191f1f1b9854e4d2b16034c533418f616e6c3a96d426c1e246a90e70b8edb2bcd8e6e21fba0dbf250ba4d465dc788d6b750c00cbfba7e2477bf29fc19015786a729b9e3058c35d4a87b0236f7c74341f05766b4a6c51b7f990ce6736332bb7fa53b9e2882e5ee4ed3cdd0379cc9711b47fb751849d1f75f8bc1b060da4c1fadce78177c2f5c4daa6ff1c6d23eb9d9aa9b6e71369f96e243fb31702478756c77a7bebb81d6d48d478dcc6f9b44f43f9b8f29626f7d994b2fbfdb7c55d4f231dda56dcb0a04bfae52a949e6222815543d7c8a555e8241b5bb7173f9dadb2bf16c6d359273bda357b1ad603dc39140a0c02de290e0ab967f7d379854037bb712fee010c1b6e6b09d8e791fa9f9cb3bc5e60486070ab8986d4b3c480dde0e139601c63c3db6e80381975661f74cf32d8af7b38a2c15aa16710675ffa66547743fedadcdad5306fd14dd7813f249c0ecd44af802d327629e3f81be6b1e6010e004cf56a4faf4880a5e88267aa3a6143b4023ba0ed8f2d6bae6b3be370c09e5b89816926aa207db24e6c87cc073a506722c5a2d12d164a4fc0b025df68d9a52341d4142cf498c1505cbd386eea446a0dc7d8882e70b3adaac404fb45050d1eafc23d4576b21188fec0d7a55ccfc5c0b11104abb3bef167a6e10db4168d7bcd61d62c2df5106c33f57ce2cd51f9c26a0010e084986ec05be05b01c67d8e24fa75201be42b8ad29d07e5531891819b74cb2e78aa619632a0569c3b08210530dca661705a0b594a0f7b21cf172b7ae737aa68d87521b74265216d15274714d8592723b617e08ac5b7080ff010818583fa4619a6327d301130e484633028ec95fdb9c1e4906da575af185d373bdb36a85b4544b350418102531123f04398b8476dea4aa34d8c916dc5766f20dc60760d6fa2cd0aa41b9241ce69291ae44cb7ff4c2570c5b68a30001c1dd0fa442f211b1033453a6a1d3dde5b2298cc981ef9156de0659c54ab5fe378236de6c201e347b168210166de6508e669563220711a4702d104c0553efbb62bed3c724155ee6b7833365d579124d058ef11269c5f0f9eeee6ee19ed91bd1bd456d8ee55ef52f6673fc3bdc53f5d15d61e617c144c35d3752333791a4327592d30f0bb0da70f402e6e2790a3fbf842fdaf8da4b15611049a6b1f4a10f5446041f13edc03c0ffdb413a5ffde64d99e149fd68d044bc15b2c549f6ca4ebb5a80e1a4f9123eee4d989aaf079c113557af7f72a2af066bb5f58bb64e75792814005e2040221f6560e26ba7f67e8f86d98916a0442bc6a16464423454616b05976c11325b58510740ab5b4e222030173489cd49ebc29db438166d9a4dc29c8dd41a9c909833e22a67e56fdd3ea909ec3134f92edd68f6fa546e32e9803d93be02884671a1bea34854efde78ec6ecbc2487b5e2e6e48ab7731f0463cebb7bb9f6705b7651e911ab10027e22a19c9dfa324bf79f58f9550a965bda60f8fa030a6b25d7066f22df78ab82c01273d5ef08059ac93da83b522fc007601385e234f9207022f1bf4d96ca922b3d0fbf056b0aa5917e05a89962c79944fa505135c0339cb9c0a628096b65abb3fe79304a144fb142a8e0eddbbd63220c0f5420e1245927826e4124f7c2df0c75c9d6bc512680fb4bb91bdb0ef343ca5ff242152ab8f9c9d92af3b9913036e290d36d60ed53254d15ab979b5a2069914a0bc11fae5477c133419a3f144dd01704a3e7394026ec52d8f0dac21633949149988a4313cf04aa59ab45a70e03cbd269034fa25297cd3f4cf0185e94cf02cf8def2d91642c560bb061377f9ac56471eb2e908e0717acf103b1987701ba470dcba4c3147be0a26cc1915c99eefc75186ff1252abec10e15a52c67179ec0a4ba586ea31b0642303260191e6e2d1d19deda9d37e4cacde5ca9526068caaf02b6233613aa1d21b1473d9ce2e5d95ce5fae69681356248550d7eb45ce136b8028cbe1df541cad7953c25b197ed3adf32d3f9dd3442552f7767fc5c25f445c1a7ea7461007a2e3c30d76123307ac379982cd193ec6cb1d2a109ec509f0588a1b70a4fb0def95285a750f55987fd7460a90a46fc30c4dce33ff4b000f0e63bb1298c4681830dcdaf23c8a67db30e028f07db816a5ea9606b94f235838a5aed97c9fd322b9d37e887aa7596c4d79b6c5ef6715f28c44bbc4abfa191fed1d3e4527f0e0ca7865daba8858234f57140e3cb1e754f5c78370c587dff4c6e5d8f2418142ab553573f18979b05f95c489377cfa275a50118d20c6a33bcb519bb26b5e2c495b9a3a6749b6b4f921db042f860729ba77af44107b6a1d676c4a7c99b86565d489f1b302186761f4bbb386773373ad5839b53dc23655a6bb4d20cdce7d4dd7c0ab8e90211b3cc0cf6a2308ebfc83fc0c1e834d6dde20581862b576c5179b4ecb5f6a04a3f784bb73543a44b59408ebdc6a1ac8031710cf5c31171493c14ac4c3f9abb283cadb04a5adafc9bedd363e5fbeba67692caa69abe260c0d791cfa6d37e1055381dec62006db84d9f47421ef5e7268e5f2a85b3cded468531775db7d6c33763add8c7f2b89682527c30070e44b4d54102b476757c037d26d21613222918291bd762089bfe886d8172676723bd8c176f67a69663d59d06d2ca0babc54bcabf570a740b848f8987c959eed4a236bbc73ab7ca7138cd3962e80565749aff806cebe8bb2168c44b8d2d3c1c2c7fe26078956a5e887925ec48289f394a19ad789321abd6205972db2e6144671c9ad757a31db7fd97091db7e875762db7c01b601e4862242eea8ba4d980107701b795616499789361055ea7da88d4b1ff4c0455740b9cb2290e2d6c69268f7596bd5889b86f0b92823b0e43c4955236ef6f26c6dcd4adb9917de652216aa62b551a55af86dab96f4263fed1278db316990c2ffc914b2fe6f424254cfde29d37699582021d6708ff2ab76f21ed6a39b13054b6b3fa60e9ed2b681b050dd4b0af3efaa0ec45a912e549b4b682d289b1df507464d66ff2ba8f2e45e9d3bb6ec63c10fbd82dd9a6e49c945233587e82da87eaaee4490390263344fa1660982dc1959f12574ffde37845983cca07922fc0f75319ab217e664ebdc79b194e02ac958ab816519587e1acca4fecb0bd963aba110cc0a754e3b1413448113ce9cc9dec2b2c9880ab7fb3fc4098a8d445926786c6669651713894f8ba69b0698d636d372b785030a76773c2ba0a11dadacb9cc33f18f76e9134898c88705e007f12d45c3f696de4481a13c4486fcd568b47437371ceaeb5c3bbb211b4f9aaef4c1e3a0f96683ef45aec90f51bf23e2dc2dfb9ed2d2cb7fb80c7520b9dca4032174de30e58bc7f9d9eaf40e869664e87d170c6953c16d12b4758d79324d47c9c34f97aad2aae7eb61c798f9af34c2b96625e0536c5b0931fdceedec387b929fb164a0d5715f16f3d2de3bdd5f7d282223f65dc46e093632d9e08cedb10ed5d3554c263aecdea0540a43a5d83c29314bad4497d3e7f1c1edde729ec51d853d29c15977801fd36064ec15ac8fbbd59c7114f4dde54835c9ecedef3255a250cbbbbcc45151c92a692a04141c321052343bd200faea101ee8c72d9e605146904c45061c7a3acf1d34627048a871c6deba7dd1a8e9801162eb2b0540608481cb0e7bee262d2b89f93e462ce078802405eb63f2695d4edc9d3cd5c02a22b6c7bd95d37407b29e2a113da40679f1304aaa5ca92aec08acdc985f77f232a0b0f9de32c0fed3bb13b859e65913248b6bc2b71c186f5ac48375fd05bf7f45ceece8ca65b4ce327e75264d1d12486b1b6e709726058d8a0068a1107ac1e01a1b6cba60b1ca0054543059e9b5da1ba58686329ec3245355cf99e2d04e27d07f2446e8fab54a0ee41cd453004aae1b66c5d69e7a2a8a9f87dd546f7321d027a2c7aa358d0405fec0eb110622567ce455278607f05c1b032c04f3f1220deb220e2fd5f5552769bcde517a988ce1354fc0425935c8d220ea3c853bef1109994bebc66f2c26c29614bd832f0d890382d35814224e0c173d2e83b37cc3d8c8779e6a272c324ff5297d09e2f234b3f3c256219690a43d4c2d585a94460249e5c0c09d9448e457cdd9921bcef82f63ff8c0c8ca4b410345011c01f28db20a6d39865840299fa90757222b5f0da0331ec443241d43b115a342ef2a6c5c3395ee0b243d2bb52c3b9a82fda19439d382d48894b31eb3a24fa1cd85f42983a9c3dc992a52230a8d91e0e4badd33f5fe7471d01ba4b7ae89b7ee66e220b4288403e51640a34a984a3367834bb2ac8db6bce2341b144808087bf0cc3de51b9b0abb71f75d34f1b124c4a6b5b1c95897b20d828842804c2141cda623d4a2ca134e219d7dfd0f2754e25900a3dd8a30f1fdc87e27f58958cd7af7d8446a7fb3d96ade5e1bcb3f015de47e3d24db8508579347befe9324125afada274e2981d0358d5248a18122e124b615985a6c0eaeb99689270c2626c2868649c5ba7f6f17a0c7438e648f89d0cc57e7463b43a9262f489b0e650b9fa04306300b20632a90e1b6f4e3d69b3a4417cead386a6ad8bac776f04447afe5c4d6868fdaa95000ad5e1ba60af4460e710147baf586fb7a8816adfc98bd6d43932cd16b56e1d04d9d5d8bb032f57e89cca12d3cbf259ce0a8b4e00f8341494a94aeae4915a8f8bf7a202a3ca1291fc211451a6326810a12e25b1e4f9b2b41b44eac41bb016ac6c0d8c19cb8558052632c3892187a008f60b18d9471c356e8082187c6c16af703249cb6ada558ae264398b686694036bfd2e64d93506574dfac010bda8652fa7792b4a1032fa3b77e7db3e9a9a9d665b50ec1491e483b6b93959870cfb8b9a3e2c5d724ab616f69b970a425ac3aba6fe3677558506eae0262bc934d8a1ebde696c56230e5b55ba283e9c44c117a9e745f38e26cf98c39a435e1254db2813ed291394a19e866139934a3623652fc44808d60891689b3d2a35be87ad5ebd891bdf0c03d1bdf495c5604e5461b57736aa4b802a43d9b406ca00adcd9f337f13b8c64a7e58700aece3d08afe38918b9e9bacbcc02e67a94d16abba965ec0c53090747b6e93864c03897375fbb6ed9cce93bf84511dbab07a8cbd75abfdcadd7b0e099b19bf371dfd0a",
+        "0x3a65787472696e7369635f696e646578": "0x00000000",
+        "0x3a6772616e6470615f617574686f726974696573": "0x010888dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0ee0100000000000000d17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae690100000000000000",
+        "0x3db7a24cfdc9de785974746c14a99df94e7b9012096b41c4eb3aaf947f6ea429": "0x0300",
+        "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000",
+        "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x426e15054d267946093858132eb537f105fe52c2045750c3c492ccdcf62e2b9c": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x426e15054d267946093858132eb537f14e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x426e15054d267946093858132eb537f195999521c6c89cd80b677e53ce20f98c": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x426e15054d267946093858132eb537f1a47a9ff5cd5bf4d848a80a0b1a947dc3": "0x00000000000000000000000000000000",
+        "0x426e15054d267946093858132eb537f1ba7fb8745735dc3be2a2c61a72c39e78": "0x181cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc208eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27de659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e",
+        "0x426e15054d267946093858132eb537f1d0b4a3f7631f0c0e761898fe198211de": "0xe7030000",
+        "0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429": "0x0900",
+        "0x4a83351006488ef6369cb758091f878c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x4ff3897794d496d78686afcfe760a1144e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5c0d1176a568c1f92944340dbfed9e9c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x5e8a19e3cd1b7c148b33880c479c02814e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f27b51b5ec208ee9cb25b55d8728243308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0x5f27b51b5ec208ee9cb25b55d87282434e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca0b6a45321efae92aea15e0740ec7afe7": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedca138e71612491192d68deab7e6f563fe1": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedca28dccb559b95c40168a1b2696581b5a7": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca308ce9615de0775a82f8a94dc3d285a1": "0x06",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe700e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe70e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc44f9aea1afa791265fae359272badc1cf8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e13000064a7b3b6e00d13000064a7b3b6e00d0000",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc4de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f13000064a7b3b6e00d13000064a7b3b6e00d0000",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca487df464e44a534ba6b0cbb32407b587": "0x0000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca5579297f4dfb9609e7e4c2ebab9ce40a": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca666fdcbb473985b3ac933d13f4acff8d": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca6ddc7809c6da9bb6093ee22e0fda4ba8": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e169030e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e16903e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade980e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade98e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedcaa141c4fe67c2d11f4a10c6aca7a79a04b4def25cfda6ef3a00000000": "0xa8fdc74e676dc11b0000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaad811cd65a470ddc5f1d628ff0550982b4def25cfda6ef3a00000000": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedcab49a2738eeb30896aacb8b3fb46471bd": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedcac0d39ff577af2cc6b67ac3641fa9c4e7": "0x01000000",
+        "0x5f3e4907f716ac89b6347d15ececedcac29a0310e1bb45d20cace77ccb62c97d": "0x00e1f505",
+        "0x5f3e4907f716ac89b6347d15ececedcaea07de2b8f010516dca3f7ef52f7ac5a": "0x040000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaed441ceb81326c56263efbb60c95c2e4": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaf7dad0317324aecae8744b87fc95f2f3": "0x00",
+        "0x5f9cc45b7a00c5899361e1c6099678dc4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x5f9cc45b7a00c5899361e1c6099678dc8a2d09463effcc78a22d75b9cb87dffc": "0x0000000000000000",
+        "0x5f9cc45b7a00c5899361e1c6099678dcd47cb8f5328af743ddfb361e7180e7fcbb1bdbcacd6ac9340000000000000000": "0x00000000",
+        "0x6441fb391296410bd2f14381bb7494334e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x6786c4cec8d628b6598d7a70ace7acd44e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x682a59d51ab9e48a8c8cc418ff9708d24e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x6c63e84bfc5a0d62149aaab70897685c4ba24bcd9ac206424105f255ae95a355": "0xb104000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x6c63e84bfc5a0d62149aaab70897685c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x7474449cca95dc5d0c00e71735a6d17d4e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0x74dd702da46f77d7acf77f5a48d4af7d4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x74dd702da46f77d7acf77f5a48d4af7d62556a85fcb7c61b2c6c750924846b150e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e01be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f00b304f91831830500622780fd38770500",
+        "0x74dd702da46f77d7acf77f5a48d4af7d62556a85fcb7c61b2c6c750924846b15e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f0001fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860eb304f91831830500622780fd38770500",
+        "0x74dd702da46f77d7acf77f5a48d4af7d7a6dc62e324093ba1331bf49fdb2f24a": "0x02000000",
+        "0x74dd702da46f77d7acf77f5a48d4af7de5c03730c8f59f00941607850b6633d81fad1867486365c5b304f91831830500": "0x01be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f01fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0x7a6d38deaa01cb6e76ee69889f1696272be9a4e88368a2188d2b9100a9f3cd43": "0x00407a10f35a00000000000000000000",
+        "0x7a6d38deaa01cb6e76ee69889f16962730256ea2c545a3e5e3744665ffb2ed28": "0x00020000",
+        "0x7a6d38deaa01cb6e76ee69889f1696273f0d64e1907361c689834a9c1cb0fbe0": "0x20000000",
+        "0x7a6d38deaa01cb6e76ee69889f16962749d67997de33812a1cc37310f765b82e": "0x0080c6a47e8d03000000000000000000",
+        "0x7a6d38deaa01cb6e76ee69889f1696274e7b9012096b41c4eb3aaf947f6ea429": "0x0300",
+        "0x7a6d38deaa01cb6e76ee69889f169627ba93302f3b868c50785e6ade45c6a1d8": "0x10000000",
+        "0x7cda3cfa86b349fdafce4979b197118f4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a8910c174c55fd2c633e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e": "0x04e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a893e73123ebcdee9161cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c": "0x041cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a894f58b588ac077bd5306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20": "0x04306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89518366b5b1bc7c99d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0x04d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89a647e755c30521d38eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0x048eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89dd4e3f25f5378a6d90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22": "0x0490b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118fba7fb8745735dc3be2a2c61a72c39e78": "0x181cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c000064a7b3b6e00d000000000000000000000000000000000000000000000000306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20000064a7b3b6e00d0000000000000000000000000000000000000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48000064a7b3b6e00d00000000000000000000000000000000000000000000000090b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22000064a7b3b6e00d000000000000000000000000000000000000000000000000d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d000064a7b3b6e00d000000000000000000000000000000000000000000000000e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x89d139e01a5eb2256f222e5fc5dbe6b34e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x913b40454eb582a66ab74c86f6137db94e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xa0eb495036d368196a2b6c51d9d788814e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa2ce73642c549ae79c14f0a671cf45f94e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa37f719efab16103103a0c8c2c784ce14e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa42f90c8b47838c3a5332d85ee9aa5c34e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xa8c65209d47ee80f56b0011e8fd91f504e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xaebd463ed9925c488c112434d61debc04e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xaebd463ed9925c488c112434d61debc0ba7fb8745735dc3be2a2c61a72c39e78": "0x18d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c",
+        "0xbd2a529379475088d3e29a918cd478724e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc632a5935f6edc617ae178fef9eb1e211fbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x047374616b696e6720000064a7b3b6e00d000000000000000002",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc66f2e33376834a63c86a195bcf685aebbfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x047374616b696e6720000064a7b3b6e00d000000000000000002",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x0040fa7f398074858a02000000000000",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb30e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0xd17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae698eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x88dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0eed43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0xcec5070d609dd3497f72bde07fc96ba04e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19500e3a507571a62417696d6f6e808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19505905fe216cc5924c6772616e80d17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae69": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195066b8d48da86b869b6261626580d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19509d4a4cfe1c2ef0b961756469808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950c9b0c13125732d276175646980d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950d62c40514b41f31962616265808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950ed43a85541921049696d6f6e80d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950f5537bdb2a1f626b6772616e8088dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0ee": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba088dcde934c658227ee1dfafcd6e16903": "0x08be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25ffe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0e0cdd062e6eaf24295ad4ccfc41d4609": "0x08be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f88dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0eed43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860ed17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae698eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0xd57bce545fb382c34570e5dfbf338f5e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd5c41b52a371aa36c9254ce34324f2a54e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd5e1a2fa16732ce6906189438c0a82c64e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd8f314b7f4e6b095f0f8ee4656a448254e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xed25f63942de25ac5253ba64b5eb64d14e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xed25f63942de25ac5253ba64b5eb64d1ba7fb8745735dc3be2a2c61a72c39e78": "0x18d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c",
+        "0xede8e4fdc3c8b556f0ce2f77fc2575e34e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xedfb05b766f199ce00df85317e33050e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xf2794c22e353e9a839f12faab03a911b4e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xf2794c22e353e9a839f12faab03a911b7f17cdfbfa73331856cca0acddd7842e": "0x00000000",
+        "0xf2794c22e353e9a839f12faab03a911bbdcb0c5143a8617ed38ae3810dd45bc6": "0x00000000",
+        "0xf2794c22e353e9a839f12faab03a911be2f6cb0456905c189bcb0458f9440f13": "0x00000000",
+        "0xf5a4963e4efb097983d7a693b0c1ee454e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xfbc9f53700f75f681f234e70fb7241eb4e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
+      },
+      "childrenDefault": {}
+    }
+  }
+}
\ No newline at end of file
diff --git a/substrate/zombienet/0001-basic-warp-sync/generate-warp-sync-database.toml b/substrate/zombienet/0001-basic-warp-sync/generate-warp-sync-database.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ca78ee290c41d21765ff7c45f534315d2231fbcd
--- /dev/null
+++ b/substrate/zombienet/0001-basic-warp-sync/generate-warp-sync-database.toml
@@ -0,0 +1,17 @@
+# this file is not intended to be executed in CI stage
+[relaychain]
+default_image = "docker.io/parity/substrate:latest"
+default_command = "substrate"
+
+# refer to ./README.md for more details on how to create snapshot and spec
+chain = "gen-db"
+chain_spec_path = "chain-spec.json"
+
+
+  [[relaychain.nodes]]
+  name = "alice"
+  validator = true
+
+  [[relaychain.nodes]]
+  name = "bob"
+  validator = true
diff --git a/substrate/zombienet/0001-basic-warp-sync/test-warp-sync.toml b/substrate/zombienet/0001-basic-warp-sync/test-warp-sync.toml
new file mode 100644
index 0000000000000000000000000000000000000000..272b5862e8e89fa8dbe7c0a2e7fbd116e92af1d3
--- /dev/null
+++ b/substrate/zombienet/0001-basic-warp-sync/test-warp-sync.toml
@@ -0,0 +1,30 @@
+[settings]
+enable_tracing = false
+
+[relaychain]
+default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
+default_command = "substrate"
+
+chain = "gen-db"
+chain_spec_path = "zombienet/0001-basic-warp-sync/chain-spec.json"
+
+  [[relaychain.nodes]]
+  name = "alice"
+  validator = false
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  [[relaychain.nodes]]
+  name = "bob"
+  validator = false
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  #we need at least 3 nodes for warp sync
+  [[relaychain.nodes]]
+  name = "charlie"
+  validator = false
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  [[relaychain.nodes]]
+  name = "dave"
+  validator = false
+  args = ["--sync warp"]
diff --git a/substrate/zombienet/0001-basic-warp-sync/test-warp-sync.zndsl b/substrate/zombienet/0001-basic-warp-sync/test-warp-sync.zndsl
new file mode 100644
index 0000000000000000000000000000000000000000..dc84804b70b02c2460b70a991b65a20cdea26670
--- /dev/null
+++ b/substrate/zombienet/0001-basic-warp-sync/test-warp-sync.zndsl
@@ -0,0 +1,30 @@
+Description: Warp sync
+Network: ./test-warp-sync.toml
+Creds: config
+
+alice: reports node_roles is 1
+bob: reports node_roles is 1
+charlie: reports node_roles is 1
+dave: reports node_roles is 1
+
+alice: reports peers count is at least 3 within 60 seconds
+bob: reports peers count is at least 3 within 60 seconds
+charlie: reports peers count is at least 3 within 60 seconds
+dave: reports peers count is at least 3 within 60 seconds
+
+
+# db snapshot has 12133 blocks
+dave: reports block height is at least 1 within 60 seconds
+dave: reports block height is at least 12132 within 60 seconds
+dave: reports block height is at least 12133 within 60 seconds
+
+alice: reports block height is at least 12133 within 60 seconds
+bob: reports block height is at least 12133 within 60 seconds
+charlie: reports block height is at least 12133 within 60 seconds
+
+dave: log line matches "Warp sync is complete" within 60 seconds
+# workaround for: https://github.com/paritytech/zombienet/issues/580
+dave: count of log lines containing  "Block history download is complete" is 1 within 10 seconds
+
+dave: count of log lines containing "error" is 0 within 10 seconds
+dave: count of log lines containing "verification failed" is 0 within 10 seconds
diff --git a/substrate/zombienet/0002-validators-warp-sync/README.md b/substrate/zombienet/0002-validators-warp-sync/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..662360fbf3c68adc545767963de1eeeb4f624087
--- /dev/null
+++ b/substrate/zombienet/0002-validators-warp-sync/README.md
@@ -0,0 +1,4 @@
+Refer to ../0001-basic-warp-sync/README.md for more details. This test is nearly a clone. We want to warp-sync validators and make sure they can build blocks.
+0001-basic-warp-sync chainspec (copied) and database are reused in this test.
+
+
diff --git a/substrate/zombienet/0002-validators-warp-sync/chain-spec.json b/substrate/zombienet/0002-validators-warp-sync/chain-spec.json
new file mode 100644
index 0000000000000000000000000000000000000000..8c09e7c7b03215ae5c6833fa359e047581b3e03b
--- /dev/null
+++ b/substrate/zombienet/0002-validators-warp-sync/chain-spec.json
@@ -0,0 +1,192 @@
+{
+  "name": "Local Testnet",
+  "id": "local_testnet",
+  "chainType": "Local",
+  "bootNodes": [
+    "/ip4/127.0.0.1/tcp/30333/p2p/12D3KooWFvMbTsNZ8peGS8dbnRvNDBspstupzwYC9NVwbzGCLtDt"
+  ],
+  "telemetryEndpoints": null,
+  "protocolId": null,
+  "properties": null,
+  "forkBlocks": null,
+  "badBlocks": null,
+  "lightSyncState": null,
+  "codeSubstitutes": {},
+  "genesis": {
+    "raw": {
+      "top": {
+        "0x074b65e262fcd5bd9c785caf7f42e00a4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x0e7b504e5df47062be129a8958a7a1271689c014e0a5b9a8ca8aafdff753c41c": "0xe8030000000000000000000000000000",
+        "0x0e7b504e5df47062be129a8958a7a1274e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x0e7b504e5df47062be129a8958a7a127ecf0c2087a354172a7b5a9a7735fe2ff": "0xc0890100",
+        "0x0e7b504e5df47062be129a8958a7a127fb88d072992a4a52ce055d9181748f1f": "0x0a000000000000000000000000000000",
+        "0x0f6738a0ee80c8e74cd2c7417c1e25564e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1809d78346727a0ef58c0fa03bafa3234e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1a736d37504c2e3fb73dad160c55b2914e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f5e0621c4869aa60c02be9adcc98a0d1d": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480100000000000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f66e8f035c8adbe7f1547b43c51e6f8a4": "0x00000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087faacf00b9b41fda7a9268821c2a2b3e4c": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480100000000000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087fdc6b171b77304263c292cc3ea5ed31ef": "0x0100000000000000040000000000000001",
+        "0x2099d7f109d6e535fb000bba623fd4404c014e6bf8b8c2c011e7290b85696bb3": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x2099d7f109d6e535fb000bba623fd4404e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2099d7f109d6e535fb000bba623fd4409f99a2ce711f3a31b2fc05604c93f179": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x267ada16405529c2f7ef2727d71edbde4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96": "0x00000000071c0d84db3a00",
+        "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01",
+        "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9007cbc1270b5b091758f9c42f5915b3e8ac59e11963af19174d0b94d5d78041c233f55d2e19324665bafdfb62925af2d": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da923a05cabf6d3bde7ca3ef0d11596b5611cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da932a5935f6edc617ae178fef9eb1e211fbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x000000000300000001000000000000000000a0dec5adc935360000000000000000000000000000000000000000000000000064a7b3b6e00d0000000000000000000064a7b3b6e00d0000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da94f9aea1afa791265fae359272badc1cf8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95ecffd7b6c0f78751baa9d281e0bfa3a6d6f646c70792f74727372790000000000000000000000000000000000000000": "0x0000000000000000010000000000000000407a10f35a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da96f2e33376834a63c86a195bcf685aebbfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x000000000300000001000000000000000000a0dec5adc935360000000000000000000000000000000000000000000000000064a7b3b6e00d0000000000000000000064a7b3b6e00d0000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da98578796c363c105114787203e4d93ca6101191192fc877c24d725b337120fa3edc63d227bbc92705db1e2cb65f56981a": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b0edae20838083f2cde1c4080db8cf8090b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b321d16960ce1d9190b61e2421cc60131e07379407fecc4b89eb7dbd287c2c781cfb1907a96947a3eb18e4f8e7198625": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9e5e802737cce3a54b0bc9e3d3e6be26e306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9edeaa42c2163f68084a988529a0e2ec5e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9f3f619a1c2956443880db9cc9a13d058e860f1b1c7227f7c22602f53f15af80747814dffd839719731ee3bba6edc126c": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x3104106e6f6465",
+        "0x2aeddc77fe58c98d50bd37f1b90840f94e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2b06af9719ac64d755623cda8ddd9b944e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2b06af9719ac64d755623cda8ddd9b949f99a2ce711f3a31b2fc05604c93f179": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x2c5de123c468aef7f3ac2ab3a76f87ce4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c24e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c298ef7dc060436e4ed803af07632b89b65153cb1f00942ff401000000": "0x601de9615313b00e8cea3ef84e79e50b2fb70e2c8a47cff478b9fe8b3fa8f2db02000000",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c298ef7dc060436e4ed803af07632b89b6b4def25cfda6ef3a00000000": "0x601de9615313b00e8cea3ef84e79e50b2fb70e2c8a47cff478b9fe8b3fa8f2db02000000",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c2ff3ae12770bea2e48d9bde7385e7a25f": "0x0000000002000000",
+        "0x3a2d6c9353500637d8f8e3e0fa0bb1c54e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x3a2d6c9353500637d8f8e3e0fa0bb1c5ba7fb8745735dc3be2a2c61a72c39e78": "0x00",
+        "0x3a636f6465": "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",
+        "0x3a65787472696e7369635f696e646578": "0x00000000",
+        "0x3a6772616e6470615f617574686f726974696573": "0x010888dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0ee0100000000000000d17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae690100000000000000",
+        "0x3db7a24cfdc9de785974746c14a99df94e7b9012096b41c4eb3aaf947f6ea429": "0x0300",
+        "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000",
+        "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x426e15054d267946093858132eb537f105fe52c2045750c3c492ccdcf62e2b9c": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x426e15054d267946093858132eb537f14e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x426e15054d267946093858132eb537f195999521c6c89cd80b677e53ce20f98c": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x426e15054d267946093858132eb537f1a47a9ff5cd5bf4d848a80a0b1a947dc3": "0x00000000000000000000000000000000",
+        "0x426e15054d267946093858132eb537f1ba7fb8745735dc3be2a2c61a72c39e78": "0x181cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc208eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27de659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e",
+        "0x426e15054d267946093858132eb537f1d0b4a3f7631f0c0e761898fe198211de": "0xe7030000",
+        "0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429": "0x0900",
+        "0x4a83351006488ef6369cb758091f878c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x4ff3897794d496d78686afcfe760a1144e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5c0d1176a568c1f92944340dbfed9e9c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x5e8a19e3cd1b7c148b33880c479c02814e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f27b51b5ec208ee9cb25b55d8728243308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0x5f27b51b5ec208ee9cb25b55d87282434e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca0b6a45321efae92aea15e0740ec7afe7": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedca138e71612491192d68deab7e6f563fe1": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedca28dccb559b95c40168a1b2696581b5a7": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca308ce9615de0775a82f8a94dc3d285a1": "0x06",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe700e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe70e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc44f9aea1afa791265fae359272badc1cf8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e13000064a7b3b6e00d13000064a7b3b6e00d0000",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc4de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f13000064a7b3b6e00d13000064a7b3b6e00d0000",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca487df464e44a534ba6b0cbb32407b587": "0x0000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca5579297f4dfb9609e7e4c2ebab9ce40a": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca666fdcbb473985b3ac933d13f4acff8d": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca6ddc7809c6da9bb6093ee22e0fda4ba8": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e169030e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e16903e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade980e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade98e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedcaa141c4fe67c2d11f4a10c6aca7a79a04b4def25cfda6ef3a00000000": "0xa8fdc74e676dc11b0000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaad811cd65a470ddc5f1d628ff0550982b4def25cfda6ef3a00000000": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedcab49a2738eeb30896aacb8b3fb46471bd": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedcac0d39ff577af2cc6b67ac3641fa9c4e7": "0x01000000",
+        "0x5f3e4907f716ac89b6347d15ececedcac29a0310e1bb45d20cace77ccb62c97d": "0x00e1f505",
+        "0x5f3e4907f716ac89b6347d15ececedcaea07de2b8f010516dca3f7ef52f7ac5a": "0x040000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaed441ceb81326c56263efbb60c95c2e4": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaf7dad0317324aecae8744b87fc95f2f3": "0x00",
+        "0x5f9cc45b7a00c5899361e1c6099678dc4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x5f9cc45b7a00c5899361e1c6099678dc8a2d09463effcc78a22d75b9cb87dffc": "0x0000000000000000",
+        "0x5f9cc45b7a00c5899361e1c6099678dcd47cb8f5328af743ddfb361e7180e7fcbb1bdbcacd6ac9340000000000000000": "0x00000000",
+        "0x6441fb391296410bd2f14381bb7494334e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x6786c4cec8d628b6598d7a70ace7acd44e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x682a59d51ab9e48a8c8cc418ff9708d24e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x6c63e84bfc5a0d62149aaab70897685c4ba24bcd9ac206424105f255ae95a355": "0xb104000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x6c63e84bfc5a0d62149aaab70897685c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x7474449cca95dc5d0c00e71735a6d17d4e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0x74dd702da46f77d7acf77f5a48d4af7d4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x74dd702da46f77d7acf77f5a48d4af7d62556a85fcb7c61b2c6c750924846b150e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e01be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f00b304f91831830500622780fd38770500",
+        "0x74dd702da46f77d7acf77f5a48d4af7d62556a85fcb7c61b2c6c750924846b15e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f0001fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860eb304f91831830500622780fd38770500",
+        "0x74dd702da46f77d7acf77f5a48d4af7d7a6dc62e324093ba1331bf49fdb2f24a": "0x02000000",
+        "0x74dd702da46f77d7acf77f5a48d4af7de5c03730c8f59f00941607850b6633d81fad1867486365c5b304f91831830500": "0x01be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f01fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0x7a6d38deaa01cb6e76ee69889f1696272be9a4e88368a2188d2b9100a9f3cd43": "0x00407a10f35a00000000000000000000",
+        "0x7a6d38deaa01cb6e76ee69889f16962730256ea2c545a3e5e3744665ffb2ed28": "0x00020000",
+        "0x7a6d38deaa01cb6e76ee69889f1696273f0d64e1907361c689834a9c1cb0fbe0": "0x20000000",
+        "0x7a6d38deaa01cb6e76ee69889f16962749d67997de33812a1cc37310f765b82e": "0x0080c6a47e8d03000000000000000000",
+        "0x7a6d38deaa01cb6e76ee69889f1696274e7b9012096b41c4eb3aaf947f6ea429": "0x0300",
+        "0x7a6d38deaa01cb6e76ee69889f169627ba93302f3b868c50785e6ade45c6a1d8": "0x10000000",
+        "0x7cda3cfa86b349fdafce4979b197118f4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a8910c174c55fd2c633e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e": "0x04e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a893e73123ebcdee9161cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c": "0x041cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a894f58b588ac077bd5306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20": "0x04306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89518366b5b1bc7c99d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0x04d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89a647e755c30521d38eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0x048eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89dd4e3f25f5378a6d90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22": "0x0490b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118fba7fb8745735dc3be2a2c61a72c39e78": "0x181cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c000064a7b3b6e00d000000000000000000000000000000000000000000000000306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20000064a7b3b6e00d0000000000000000000000000000000000000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48000064a7b3b6e00d00000000000000000000000000000000000000000000000090b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22000064a7b3b6e00d000000000000000000000000000000000000000000000000d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d000064a7b3b6e00d000000000000000000000000000000000000000000000000e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x89d139e01a5eb2256f222e5fc5dbe6b34e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x913b40454eb582a66ab74c86f6137db94e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xa0eb495036d368196a2b6c51d9d788814e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa2ce73642c549ae79c14f0a671cf45f94e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa37f719efab16103103a0c8c2c784ce14e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa42f90c8b47838c3a5332d85ee9aa5c34e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xa8c65209d47ee80f56b0011e8fd91f504e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xaebd463ed9925c488c112434d61debc04e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xaebd463ed9925c488c112434d61debc0ba7fb8745735dc3be2a2c61a72c39e78": "0x18d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c",
+        "0xbd2a529379475088d3e29a918cd478724e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc632a5935f6edc617ae178fef9eb1e211fbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x047374616b696e6720000064a7b3b6e00d000000000000000002",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc66f2e33376834a63c86a195bcf685aebbfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x047374616b696e6720000064a7b3b6e00d000000000000000002",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x0040fa7f398074858a02000000000000",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb30e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0xd17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae698eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x88dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0eed43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0xcec5070d609dd3497f72bde07fc96ba04e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19500e3a507571a62417696d6f6e808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19505905fe216cc5924c6772616e80d17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae69": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195066b8d48da86b869b6261626580d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19509d4a4cfe1c2ef0b961756469808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950c9b0c13125732d276175646980d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950d62c40514b41f31962616265808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950ed43a85541921049696d6f6e80d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950f5537bdb2a1f626b6772616e8088dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0ee": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba088dcde934c658227ee1dfafcd6e16903": "0x08be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25ffe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0e0cdd062e6eaf24295ad4ccfc41d4609": "0x08be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f88dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0eed43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860ed17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae698eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0xd57bce545fb382c34570e5dfbf338f5e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd5c41b52a371aa36c9254ce34324f2a54e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd5e1a2fa16732ce6906189438c0a82c64e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd8f314b7f4e6b095f0f8ee4656a448254e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xed25f63942de25ac5253ba64b5eb64d14e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xed25f63942de25ac5253ba64b5eb64d1ba7fb8745735dc3be2a2c61a72c39e78": "0x18d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c",
+        "0xede8e4fdc3c8b556f0ce2f77fc2575e34e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xedfb05b766f199ce00df85317e33050e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xf2794c22e353e9a839f12faab03a911b4e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xf2794c22e353e9a839f12faab03a911b7f17cdfbfa73331856cca0acddd7842e": "0x00000000",
+        "0xf2794c22e353e9a839f12faab03a911bbdcb0c5143a8617ed38ae3810dd45bc6": "0x00000000",
+        "0xf2794c22e353e9a839f12faab03a911be2f6cb0456905c189bcb0458f9440f13": "0x00000000",
+        "0xf5a4963e4efb097983d7a693b0c1ee454e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xfbc9f53700f75f681f234e70fb7241eb4e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
+      },
+      "childrenDefault": {}
+    }
+  }
+}
\ No newline at end of file
diff --git a/substrate/zombienet/0002-validators-warp-sync/test-validators-warp-sync.toml b/substrate/zombienet/0002-validators-warp-sync/test-validators-warp-sync.toml
new file mode 100644
index 0000000000000000000000000000000000000000..df4414f5c8b5f1ca52aec28a9a581faf4cb0ac68
--- /dev/null
+++ b/substrate/zombienet/0002-validators-warp-sync/test-validators-warp-sync.toml
@@ -0,0 +1,35 @@
+[settings]
+enable_tracing = false
+
+[relaychain]
+default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
+default_command = "substrate"
+
+chain = "gen-db"
+chain_spec_path = "zombienet/0002-validators-warp-sync/chain-spec.json"
+
+  [[relaychain.nodes]]
+  name = "alice"
+  validator = true
+  args = ["--sync warp"]
+
+  [[relaychain.nodes]]
+  name = "bob"
+  validator = true
+  args = ["--sync warp"]
+
+  #we need at least 3 nodes for warp sync
+  [[relaychain.nodes]]
+  name = "charlie"
+  validator = false
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  [[relaychain.nodes]]
+  name = "dave"
+  validator = false
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  [[relaychain.nodes]]
+  name = "eve"
+  validator = false
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
diff --git a/substrate/zombienet/0002-validators-warp-sync/test-validators-warp-sync.zndsl b/substrate/zombienet/0002-validators-warp-sync/test-validators-warp-sync.zndsl
new file mode 100644
index 0000000000000000000000000000000000000000..05c458fbf4b79f17976e2ab33f011ffbb892a78d
--- /dev/null
+++ b/substrate/zombienet/0002-validators-warp-sync/test-validators-warp-sync.zndsl
@@ -0,0 +1,37 @@
+Description: Warp sync
+Network: ./test-validators-warp-sync.toml
+Creds: config
+
+alice: reports node_roles is 4
+bob: reports node_roles is 4
+charlie: reports node_roles is 1
+dave: reports node_roles is 1
+eve: reports node_roles is 1
+
+alice: reports peers count is at least 4 within 60 seconds
+bob: reports peers count is at least 4 within 60 seconds
+charlie: reports peers count is at least 4 within 60 seconds
+dave: reports peers count is at least 4 within 60 seconds
+eve: reports peers count is at least 4 within 60 seconds
+
+# db snapshot has 12133 blocks
+charlie: reports block height is at least 12133 within 60 seconds
+dave: reports block height is at least 12133 within 60 seconds
+eve: reports block height is at least 12133 within 60 seconds
+
+alice: log line matches "Warp sync is complete" within 60 seconds
+bob: log line matches "Warp sync is complete" within 60 seconds
+
+# workaround for: https://github.com/paritytech/zombienet/issues/580
+alice: count of log lines containing  "Block history download is complete" is 1 within 60 seconds
+bob: count of log lines containing  "Block history download is complete" is 1 within 60 seconds
+
+alice: reports block height is at least 12133 within 10 seconds
+bob: reports block height is at least 12133 within 10 seconds
+
+alice: count of log lines containing "error" is 0 within 10 seconds
+bob: count of log lines containing "verification failed" is 0 within 10 seconds
+
+# new block were built
+alice: reports block height is at least 12136 within 90 seconds
+bob: reports block height is at least 12136 within 90 seconds
diff --git a/substrate/zombienet/0003-block-building-warp-sync/README.md b/substrate/zombienet/0003-block-building-warp-sync/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..311d3550f766395f1294d37ecec57a2ae8f3a872
--- /dev/null
+++ b/substrate/zombienet/0003-block-building-warp-sync/README.md
@@ -0,0 +1,4 @@
+Refer to ../0001-basic-warp-sync/README.md for more details. This test is nearly a clone. We want to warp-sync full nodes in the presence of validators.
+0001-basic-warp-sync chainspec (copied) and database are reused in this test.
+
+
diff --git a/substrate/zombienet/0003-block-building-warp-sync/chain-spec.json b/substrate/zombienet/0003-block-building-warp-sync/chain-spec.json
new file mode 100644
index 0000000000000000000000000000000000000000..8c09e7c7b03215ae5c6833fa359e047581b3e03b
--- /dev/null
+++ b/substrate/zombienet/0003-block-building-warp-sync/chain-spec.json
@@ -0,0 +1,192 @@
+{
+  "name": "Local Testnet",
+  "id": "local_testnet",
+  "chainType": "Local",
+  "bootNodes": [
+    "/ip4/127.0.0.1/tcp/30333/p2p/12D3KooWFvMbTsNZ8peGS8dbnRvNDBspstupzwYC9NVwbzGCLtDt"
+  ],
+  "telemetryEndpoints": null,
+  "protocolId": null,
+  "properties": null,
+  "forkBlocks": null,
+  "badBlocks": null,
+  "lightSyncState": null,
+  "codeSubstitutes": {},
+  "genesis": {
+    "raw": {
+      "top": {
+        "0x074b65e262fcd5bd9c785caf7f42e00a4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x0e7b504e5df47062be129a8958a7a1271689c014e0a5b9a8ca8aafdff753c41c": "0xe8030000000000000000000000000000",
+        "0x0e7b504e5df47062be129a8958a7a1274e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x0e7b504e5df47062be129a8958a7a127ecf0c2087a354172a7b5a9a7735fe2ff": "0xc0890100",
+        "0x0e7b504e5df47062be129a8958a7a127fb88d072992a4a52ce055d9181748f1f": "0x0a000000000000000000000000000000",
+        "0x0f6738a0ee80c8e74cd2c7417c1e25564e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1809d78346727a0ef58c0fa03bafa3234e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1a736d37504c2e3fb73dad160c55b2914e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f5e0621c4869aa60c02be9adcc98a0d1d": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480100000000000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087f66e8f035c8adbe7f1547b43c51e6f8a4": "0x00000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087faacf00b9b41fda7a9268821c2a2b3e4c": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d01000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a480100000000000000",
+        "0x1cb6f36e027abb2091cfb5110ab5087fdc6b171b77304263c292cc3ea5ed31ef": "0x0100000000000000040000000000000001",
+        "0x2099d7f109d6e535fb000bba623fd4404c014e6bf8b8c2c011e7290b85696bb3": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x2099d7f109d6e535fb000bba623fd4404e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2099d7f109d6e535fb000bba623fd4409f99a2ce711f3a31b2fc05604c93f179": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x267ada16405529c2f7ef2727d71edbde4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96": "0x00000000071c0d84db3a00",
+        "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01",
+        "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545",
+        "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9007cbc1270b5b091758f9c42f5915b3e8ac59e11963af19174d0b94d5d78041c233f55d2e19324665bafdfb62925af2d": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da923a05cabf6d3bde7ca3ef0d11596b5611cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da932a5935f6edc617ae178fef9eb1e211fbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x000000000300000001000000000000000000a0dec5adc935360000000000000000000000000000000000000000000000000064a7b3b6e00d0000000000000000000064a7b3b6e00d0000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da94f9aea1afa791265fae359272badc1cf8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95ecffd7b6c0f78751baa9d281e0bfa3a6d6f646c70792f74727372790000000000000000000000000000000000000000": "0x0000000000000000010000000000000000407a10f35a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da96f2e33376834a63c86a195bcf685aebbfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x000000000300000001000000000000000000a0dec5adc935360000000000000000000000000000000000000000000000000064a7b3b6e00d0000000000000000000064a7b3b6e00d0000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da98578796c363c105114787203e4d93ca6101191192fc877c24d725b337120fa3edc63d227bbc92705db1e2cb65f56981a": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b0edae20838083f2cde1c4080db8cf8090b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b321d16960ce1d9190b61e2421cc60131e07379407fecc4b89eb7dbd287c2c781cfb1907a96947a3eb18e4f8e7198625": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9e5e802737cce3a54b0bc9e3d3e6be26e306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9edeaa42c2163f68084a988529a0e2ec5e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9f3f619a1c2956443880db9cc9a13d058e860f1b1c7227f7c22602f53f15af80747814dffd839719731ee3bba6edc126c": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x3104106e6f6465",
+        "0x2aeddc77fe58c98d50bd37f1b90840f94e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2b06af9719ac64d755623cda8ddd9b944e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x2b06af9719ac64d755623cda8ddd9b949f99a2ce711f3a31b2fc05604c93f179": "0x08d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x2c5de123c468aef7f3ac2ab3a76f87ce4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c24e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c298ef7dc060436e4ed803af07632b89b65153cb1f00942ff401000000": "0x601de9615313b00e8cea3ef84e79e50b2fb70e2c8a47cff478b9fe8b3fa8f2db02000000",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c298ef7dc060436e4ed803af07632b89b6b4def25cfda6ef3a00000000": "0x601de9615313b00e8cea3ef84e79e50b2fb70e2c8a47cff478b9fe8b3fa8f2db02000000",
+        "0x2f85f1e1378cb2d7b83adbaf0b5869c2ff3ae12770bea2e48d9bde7385e7a25f": "0x0000000002000000",
+        "0x3a2d6c9353500637d8f8e3e0fa0bb1c54e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x3a2d6c9353500637d8f8e3e0fa0bb1c5ba7fb8745735dc3be2a2c61a72c39e78": "0x00",
+        "0x3a636f6465": "0x52bc537646db8e0528b52ffd0058dc2705bea5c66d15541040ac6c3ae971bcf5f1040221a8d1f8b7c17e61bf21cce87411480b10bd8daa5e3c2b65f8c4aa364e5a8ddf27c0313827d06a2d6334e074db9ca7d876ac8d052862b9984530f4d340bda4edddd6e4de5ba624536717e1139e14df2d875c7f7086dc3fa3d398b64f50fffc58fbf4fb73ffb0d39cc2b86761cfe6d3073b9c1fcee7fe611b7f4875f9a7d8cfe208fdf493f4d3b07d9a73ad05c8cf39e5c4dde679c3c8391b9ceec4fd78c824d218e4cfb79cb8be9cb301eace3b7f8a274c182edb72e2e83349855e7e4a2a795d7e27998b94f46d92b42eb543afcbcf5f5c9e5bf2d52dfd9b2f93dc33262710e3fc79b943e09fe2d00f8dd7edc4350b92a692a2facb7adddffddd3d89e9babb7b8e0b9d61050b2b4ddf3efdfdb3f629e9edfe9c18c4f8715bebf42d6f6e3ff74be1b9c0c8b9187cb89c83618e5bce6ebf90cb3918729745244063391ee9710cdb87bfbbbffc6047f275725e904518e7f53cec48efa788c4bd67d104a4eb81534cd2bd67cbeebb075b4c32deee59a43da30fd2d0c979410f3db2fb2972cfcad89d0f822c7ab644bade3b59d6eeddc9925eef8f34e8645980eb0fb2f8d9b2cafddec99273d7bf234bee5995292c3051e1fa97dcb31285eb5f76255cff23de917c3f72c8afaeaeac6ef74e96462e7d70864ed2ef48be2c9ef05d8f1cfa6e67cb79dd0ecdabababab5b225d7f4a72cfa6a53d9bcf739903246f521840fe916b813c65e41c0c50b7b60fe76078bafc61ff4c1bbfac7d3887b3bafc37979f73580490ef389f9f5920c8edc3f3cee7075fdc3e4cdba79f1f9c200db97df896f532c31e008355cff83a7dff7e1791b4e5097b400cb89ef19def24533b4524b567fe2c96c02292fe233d5900f2edfed96d8f34d29c2680f3270934e67054b7a4b7bfceaf95fd879b568e777e395e3aa7139fded3ff484f77779fef3ebbbfdeb6364afae9f74c32bf6dd9ef3de714c839e5df7e908f8c208b30f2fbb388847f8a2354c1e170305cb6dcb3b2de7eb0436e9ff9edc33deb3fd24ed29ef50f602cc7dbfda0ac7df8f683331cdba73fd63efefdb2f699b79f45244e492a38b708a9def9f54e6ba3643efdf9d41acdeb964524d396f3ce3fd247fa2f7380e4736a01f2e59c72bcfd606d9fb266c81ce3fc32bc0d3a198071be3f3f8b27cc0f725b7bc6cf3d2be99da45f916a7e3f38c349d21b7211a2597587be4b05e6ceef17b908d1c4dd21112e95f0ceef777111a289bb43225c2ade9ddfffe2224413778744b8f3fb594c4271b83bff48831d3217995ffa73cff86bfb94f3faf3834ed69ef11719fdf9592481f68cdf6ded19ff91063b9c64df908b10cddca5e2ddf9fd2217219ab83b24c29ddf3fc51346dc9d1fb60fdf7e16934cdc9d7fa48ff4913ed24c72cff839a76dd0789903a49e5d06c80dcee7f629f9a7e59ef1f323cd2903720ee774f91b22454f610414ad21610c79c190160c991a32c6102286c0604808865831440c2057860431c469881042da10f28221370c9961881742e6186245881c426630248b1035848421248e214d42de18b224644a081b42bc08a11212032164081943081842d6102203212e102286902e84782184cb902d845821a44ac8154248304520a449080d3d36e8a9ea99a3478e9e387ad4e8f1d233464f0c7a723d5b7aace849414f153d24e839a247aa678b1e287a9ee889ea71a207891e237a44d053821ea89e247a94e81941cf0a7a5ad0c3821d11f448d1d3448f163c3af070a046c68e1a3b69eca0b173c68e193b65ecc060478c9d17ec84b103c64e979d2f76bcd8e982878947069e251e259e241e2b3c31f0c0c083dbb9dab963c78e9d3776e0d891c1ce971d2e3b2ed8e162678b9da99d1becd86087063b74ecccb133831d3976e2d8a963c76aa7063c1be0b9b293c50e163b2cd859c18e0a76a476aed8b162a78a9da89d12ec3cb143821d26768cd82962c769e7879d1b767cd80162c7033b42ec7460070440ec0072c70e13901b00b9da69dab101481640ba00f102880b807001b20490278094000813407e000204902cb51acc20a61390a51a0d80c850fb52bba376558ba3660710a5da1c409280e06a5635388058a9cda026478d8e9a1bb5aada1b35366a30a86d51aba236454d899a096a4c0059a386a546430d57b3528361e76987089d2f74dcd0a9d25943270d1d2a1d18e88ca123860e1b3a73e880a123874e0c74e0d02943270c9d3674ccd0214387063a32d0a9814e171d2b9d3774d0d0a143470d9d17e8cc40270e1d2f3a67e808a143848e077478d0c9a263834e0d3a34e8e0a0d3019da61f6afc80e3c71a3fc2f8d1821f5dfcd8e207173fbc981ef8f1c40f277e90e047133f98f8b1c4ab04f34b8f0c604288573fbebca26a54d0c8f083aa2af9f0c2c71735197e88a1d3c33787ec8e9009f6434d1b36573a869a0bbc2f3a778473d49e422ec2168453e11630203c1bfce0522347784527869a17542d68984219603d7442c086a8f902e34167294cea425023469df26e50e3a5878c70a926d5259b1d6267c8bebc5eb0d303cc03a1d2384307467490a583a70e74a851eaa0033d8e10bfc070a8568c3db8be78687c74f408e2c545b481cb4a8f14e06c51657851856d8c3bc8bc78c5c047d40f2d6476c83421bb416581cb062f2f2f34646ed42d7c24e164f1ec78a9e15223e6c54b63d4e2c38a48c78c1d95a9068d5a11f54aad04b51d5c68b86010adc61a6ad4a0597aa541a39463031033726aa08901c9445e21ade05841c6602307a9f423f827300d1b19f4d4f1657000825718382da827e8b0886ef4808123021c23708ae809030704384ce02c81c3054709215d709cf8f1c1f900ce062a10383e8852b468d0b2c26962c686991a7048b09303ce08704a504bc306861a326ad8b0d9400d0c6ac0c8990187861a3a74385063464fe12ce1c4e003063ec6f831831e40f4f0c04b8c1f67782ce8d104a8460fa79d257afcd003043fcc905981103764a2e8a1030803d005433e007ab179b201818d10f406a01dd48ece868e0956431743dd42bff4e8402743074387ebac74576a0a2a15758aae06b1aadbc07f60c68c971daf2f558a1e5a3aa577aae9a24bea66a077b8946a9868c8a0a1010d1d3435a061636606345e66e2a091c18c1c346bd0a83143c7cc1c3469ec0411ce40860b4d0b605a68585093aa69a131a25ba2c982e605b52d343e8c1bb0c901f6011808604f3c88784551b9c8ae646dc072f820fe88991bbcc0e88ae888e88c70c9d03dc18aa8319851a3f683c8c60c1a325f646e206303992b19ab191a66b0c850f1a282460c9c20707ac00142e60a192b6049302b3255c8a4e03df03f00d181831d4419d4c6b0517a55895334493b30b41534565c4b2e1ccca99682300d980e5e0d6057604cf306e31a3655231b3e62f08241f5e245c66b0c0eb48c408c3f8c1eb08943868b07e2d5454d1aaf2b5e5b6cdc78a9604c0387089c271928402e5e55d86001af6aba8871d4d0a0070f3634d4d8d1c3071b2b21ce268b8d0d3367d4bc01bba1c68d1f2ea859e387979a18c09a6c7880d95073364b3565d0ab9a19d4b2b091e175831a2b180d3859d4d421b6f17ae2d5c4cb891f37a89101784718c3cb0697198e858f261717ae12b846e02ac2b585eb042e295c53b8927081c015e59a72b5c07584ab0617169716ae14b8b270f5e0f2800b0bd710ae255c4eb884706d7129e17ac2b5838b07d70f2e1b5c50b8a270657171c065848b05ae15b8987055e1bac275832b07d7932b042e205c1f7005e15241cf54cd183364b862a8b99a2943ac439cc3e606110e9106e21be21d40bec0711273220a8068b169c3956433c3aca3c6c4b303073cbccee891c30e0e385c841b7899a1e30510aa1a143555b5276a4e4c2d707ee080033b576021d88961a7069c295810af357464086100bfe0203141600387cc13322600bbc0f100e8458f25c02dc030769a00c1787d51b1709d51b3807140acc1cb8b9a06ce11343000c204a40c58075e65d868a9b1012ba9fe00dba1034137448ba047053369bc6cf0838d1e3df464515bd0566ab8ecf0a0d34563f1d9507bc0116205162a544da22e5195a81e783272a2462a9e8b189731052e3b64553eb8689911bee18901048d57171d2d3836e0d48033838e0e325f006143c68b8f06b5a57a458c8b2ae5aa636c72a5d1e303a21db58a1a11b5281f31e058a92800a2850f18ea0a5e50d4cc21dea0a606231a43b8801101f321b4e25b8833a82a10e5a849c2d10296c533e3470c6a5c5073064e08bc1fbc19bc2b5e0c3d33e8b1a367e81a7a072057b4161b1d76b4b8c2a01903e452bb41cf17206a0021a3cb0244059d53a743d7d4d1d075a0d3d2fdd005d1c305080f3d5d741ce87ce87ae878e880e0d1d2edd079a0cba1fb40874377031016e00c61f3464d0daf0d9d1c7ab010b700d7d0b9a1870d73861b367676e0e14167079e2606e060c101838621e3820ea39de8259a896ea29fe82e1dd55f34091a0a97aa5cfc106fc423417304cd123448e41891e38408845884e834163192603402e4400d23c6464c8e980c649e64909029a207971e60f4e822a7889c12e488409c41e4808885468a460b1a15c4ba88c120e60558450503b442d64566860c8c19ab993b66eae8b1460f1af460237644ac043124782cf168e22143ab8adaa56545cb8bda45eb8b2fe245f042f838818f2d3e50f02178103c11b12b625bc4a44627c629c6a81814b12d3113f810c207123e86a8d9e0b9e1d1e1bd018301ac0cd8182316a31763163eacf0d1021f57c8acd00981ec8a0f86efca1783a884480271095087ea0270872a06a8e585e5b5c38b86d612b5205a4c842c08c908b1a835d42cd586fa058d153eb4f808c2070fad21ea0b5a21086f107e69bd117620ecc1d3a2268697453746774617032058d870c026861aaa9a1bd8d450e3854d520d1c364d3638d4dc5113860dae260e1ba69a2f80cca16307101bec28d145f42cd136340d4056d0589aa973681e3acb9ca3710d03902ee6d5acc1b4c184a3c76a5acdaa49032052736ab66066b164a260b2604e31a5983f4ca989c584629e60e6a609261573cbfcc05cc1b46246318998219843cca46965c6309f260c1357c50215983e3c994d4ea8b820a505a1261098400424f08006a49000144e40c001941820090953082300100091282c38c07979c648c16a072a6a528125539a00b1b0640938fd4914a0254b5abf8127529c003dc1f92b5c548401202551a440292a025a00f94c1cbc0c34bf24d4c40914222946455058f0e0956c3e89895a68e1f556b8a80848a8c7c7c0310f03b7700099c7f1e05c090935712224d48400349c3bb848084a1323a0274b80802cf0018e1d2cc50251a02cc10011900b434ba04cb94651805ac04013141ee70b03ad7003067a22c5c992274da4084d71c1060c64d4048a519426464551a0c870ea6021a1264e8c9c3421328a228500301c2b067212454a94254d9c44918200a3282e4871e2e4f6c0a9019429170345500a80814be2d020041c3a7270e660189c19b01ccc82132953806c70e26022175680628128529c2c8132e50255a0894d06a78a8b9e1035b90010d19215a24079120568ca1228536e91901429284481d2821404581c38780a14168a8880a25c40ca120c00057d80f3063f018ab20294a2282e18357122850a14178680961811499902444404c70d7e026589115011910b4e6870dae0222028465088a4b060e44293252b2c8132e53699f2244a1322127ce0c8802f0065ca25020a2292e28013481c361808c80520171290c213a015566892c20f9c35b828c809100b4ebc7091511420222016a240791c35a240b1800d4e1aec044a5114284446558096604068ca94264b88809e084171c116e4448a90ed06070d6e614913a3264f9a18011d0086734606a00835816204250a14191c3338c88914a10a2c013272c109501520189c3298480a01429e404215686214c5050b2c3172024404e54914284b96d0e880367c2083918403c3ca97cb4820e770b83b919cc66355b1aae694f951efc6c6fb273d1bcff3bc27c99b1b8ffc1beadfc75f7f5d6b77adb39bf963effa7d5d2be576e68ffb03e9f4fad1a6def7791fd013fe987a7b5f777fb4995b74ff9add99b2338b226566ffd8fbbe9deea87760f7d755efcfbbfb1b476ef70aced44a99ba7762f56e96d8ac3a99bac74ce64a65cd72cf9d3f0fdbe9d7ec2f661bfe987ecceca4dde9e73895dbbb72f5cf690794fac7edb4d93f76fa71d3ef73f7bc8fb6536766ca9429534ad9fb28f5f6ef83317b53a64c993fca4e653e66a7cced9476bb575ae5cafef19021428430c8eed4e5a20e7a575abbdd0586cc937a5ead1f738fcc9f3b6598bb5377efd1dd2be0eeb0eab5d6dae3d8b4dbdde79c3e67d3f6f6a6d4bbbf6edaecd46beaf5fc2af5c09d3af5599dddbf70c645db43f7daa42ba5ee2ff6f656bb7fee1574265d57ef4a7b093b8d31b37fd3dd41b052a069482b0dc31aef1a760fc309788712a8719ed3bf5ab97b727fdc13e4eb09e21e0176770a1386ddd3b9bb99fba3f9421aeace94db2140a97baeaf7eeef4f3a8473d66af52eade5fb7fb473fef8ffbc6fb3effe6fc981bf600dab4ddbb2937b37fdd1f7bceee7d2008a34054a820303bbfda1dc0cc3e3bef98b9fb989bb9eb66c7ac6eba772c67ee58ecccdd64ef581d77ce9a5dd771d7755d73d779c71db3983b666618666f6731c73033b35831cc95997aadeedd9f7b8e7b7737a51ed0ee80f6cbddbfe6699e6e8fba7703ba76f7a49501ed7937ad1fe5e9cddd1f7f5fc7d49dba376d4f61d20528c0030e9d7f780218051ad6f41ac7a969202774cb7cddb06eeafd79b57e8e0098ce016a351d6f1a86ec734e9eacf6febeef874c7ba594c62adb7ccc95a73bedd0dd457710e6e476b06d427666a6dd4ca33edd41f77228655a29ad94b6f70ca5b45217a5d4044a5db429f5da5e2b58bfaf6777fb6cfe3e9c0efae3e993d99550e7ea6cc3ce6266af71f7cf6b6776f630c63e67c8ede2768ecd364077e8edce727767d51866f7ca732661febc69f3474343536b7dbd5e73ce5adbbd84f6f6aa57efd09d046feaeefe7277eef9f5d7947e1f87cedeee4dab778314ac2085e9eee6ea9f37280382ec3ed929ad15a4947e1ff7d7d49d7d4e0ec3574e873e42483d44e2341e76bb7bddcdeeeeecfc7ddc55669e9f659cf979e8ec79dd4eabd7dab47af5efebaed56937add4a35e53da3da7cf39270c4c7be73c3bca6af72e403b28d33dfba360d7fc79d8dd9336a594b67f4e00dbc7edec3d99bbdd3fff3e76e6767667766f6766a6a0e73ebdbda977f7f4cf999d5266fed89ddb9d32333365fe98bfef6b76ff989d7a5f6f7766767777fed8bddbbbbf23dff7cd6aedafcee97d3319113c99effbbcef930d4000edc950af7e9fabbdfdfbbeefebfebe98f77dfc7d9ff3f77decf4fb78ec9a366d9036edcfdbddbd73ea7ded1fcf39448a2153380f6e0c10496901a805cf8805a448219a0242009e0011013d2192b2c427841e20284446207c0043d323a5a60b72d2a402424252402852d3c3470f1a1e464550aa00dd742d48e981620120a22996031b98284053a634b9f10b00450122ea0e5a806214c50522cb81058c5ce8c14115201696184581423465899322282ddc0cf1e95145ca058c7c3461a1c8475013274e80827c42e8e1c14188f40459d20314d444a8024b5688028585a2262cbc102128413c00f8800807690244e4032868895115a0283a3e3e807922048505274b8c845c686201a027b4ce88a88951d1073d1cfcac00a5888c7190220c00052d710245a8022e4c99111575d0e29ea22220a2292d4871b28408888a142740444b9a143d7102b42448904f083d539c0015fdb0587062d4a4024b58288212058a05661f60c002508880a870608980a200adb00400414208a1e709d0122946533040e4a4039610101520a125559ab480035b418ad09215a240596105294234b3051f0c446401275284849adcc054017a12054acc94169a181501b500c5e87b449102c5c84993a2284d888c96184169a1022e14d1584f80808a96b420e5499426443606c8a88951d1922022291730028a92032bf2596116821150d19227519a2c01226a32a5052943c62640424e9600add084488a51d112a1264ea4088140250a90b338c8922852a014110151594224c5a8c91328424da82c2982b2240a94262c38b18005a42c31aa02c401952840fe03aba3f986d44cf805a466c28dc462c247472c9009b7c20e09e9e8e8ab48ee47484820528b09231d1dbd8e8e68bb33399a4847474794c9d13cbacddb64f2c27c611e1d1d1d1d3192787474243261a48f8f908e909c9190e6d1d16482348f909ac96dde6ecde485f9c20bcd848f90909cc9d13c3a6a2647f36832e1a3a3a323a48e1e1d21cda3598f26d264723499091f1d39133e426a267c74c448481f13a47974e4313942ea98204d24a46682349991281346426a268c8484e44c9026d264c248938905bc342633cf168a9a70ff6aba2dbecb9bc2179ba6703ceccdfb193b61ec6d8ad3fa61f6369d5af6e654377762d95b3bc9d8a6622aae72ea625e8cbd219102ec61fec6fa1bd3105beb6f48a4d0bd3775fb6f48a450bfeb5c0ec6de580fb373b4b709e5b4fe97bd4d97bd7993686fdd14da9ec24d2876c109ea68a220cbde9296425bcbde904881f5f46f93eaf6330db1517b63d949e5b47efa9ebdcd29a7f577f6d6d5766e7a36a8a2065a90800530cca9a9c58c21d4f882082b9f3dea2b9a5002872dbef460a37656517915a572a2534d533447713977a250de975e0555e5509eedb450755fba13d5955367bb266fa25ff6d477757507185faca087266a3ba6cecd37bc08c30c20a4c2b0b1cdbf6cdced8f8b1dbc7842862cdcb0b1cd6d87735a7f39ab6eff1cc138bfec70b7bba9cb1c1c59a4d933361c31c711671c31c611611cc165882e59dc0c8c9c1b4288db0f5ece0d41c5104fcc1a30bbb3b395796543826b58f0c86e3ffffc59fbcc3075fb6f74daa76fffecd86d16fe36cee5c961ce39d9c66a98c3873984d395f5cc2d371260cf8668c26947f0b30d091c10081bb60640bafc2fc840c4b644c4d6cf362bf3cad61609b64773ea809492486310fd0f6e89d41d5dfa25eb006cc6ed2c11b57b26eb7724253b57a2ca562d8eb568a25fb228f9c105278b10f8e01e4da4ae9b0b281f40e625e61c9ad77fde00f293f00738346f3f0f5e6ef8dd3759346f7f8b25f065d9a0f9ac269a5cebdea8de21bebae0b73842f8ad16d87db348ce817ed8e586cf7a10ecc26e3dab45253409ebc33fd2247c0ffe24c16791e1bba8a4fe9c96b936cbb6936bf3590f9265b3a8d43be477e08c269237db8dc9f47f5c3a9f7970bade7f28a8b003166eabf159fbd878dde7cc98b0204667f3d1a38ddbe9b44fe9fd8c3baeef25842a30699f8ea54c689f79bbe7d1c274bb1fd2519edb3117299f9a5bf219b7ab3fe57edffc46deed07694efb74443d45254beef7f5fbe6cf32ebb00559a2094852782dcffb727edf64b51fe99125d2f5823c31c967bfff6cf98267cb79bb497f70762bf16f25d3b34ae677f737e00e425c8fec260cb7accfb9197c18c158fb78df3d1549a85fbe709564c270eb83dcb8fbbd47d68f2cbde73fe21e0c777e7b55f502d6fe793dffd83ee2f3c7daa7f5cc7ff339ed539f7fd63ede23dd16297e25914010fc231d9236f559396cb9f4451dbc07b95cfa1e07ceb8f441fa208834c367b1c00727f8437ec1076b908d92ef3bfab93e259feb03bf3ec86a3d5f56cb8e509ff5ac1db25cfaaddf21e9d2a0eebf0fbf92f3b25c1ca1d56ab56c50f725fd22a4138a906ef841de9f40ffb3a5f7a165f165d52e6431b4e5ed86ef912fd27b89394839935ebfc41cc4fb693be2210976a147fabf48b6555209cb06894f5f7c16910c896314df3df03d5b8a0f5a1bf0bfef94d017ad0d6895d4f7be821ed9fa2fa8d64f49fd6a12fa2c5b7a0f3e089265f836ace70bbe47dab0ec08dd830f5abe1c98e3d2071fecd06b3d68cb794befc3073d6c91e197f386df8d002601c1f767d9a179c57a7ffaa02d5b1f92e0bc1e396f8be43b2ff3ed8618b9fcec359c0168182ebf8b87c8d1446a7568039884410f5924c16d39a75802fbcf13fafd595f562e52bf6479e86439aff760fbe5760ffb32c8a1279e40df6d59af7bef950e7e210d3bd10095eccb22e7edbc9fff89273458c5138edcd6b3c8790d8024c56d3dd80a5926208d10e50e1dd52421cefdaa880024a7db7ab04396480292d31d62725b0fd6b0251a00c986db7a100c5962121eae1259a20948b7f5a02b641da0cbd7fdb8997976aef2a8e97a0f86218b65cbda2e5779e474bd6f91cc3a65ebe787e209fd2d5b4e164356927ecfbacaa39b4588ebfdbc959c17ac618b49e8fb4f71c86f903802d2ed3eebd9f91e34df46498981dbcf17a94e2f892c583c0a0ee4c09405072f138710ecefb7e99e67f7ec9136ddcffbfd07a3ffc1f5ffbec9ee677bedb5c7df5ee59eecfd11f7c8ee821dd90fce59c3d83f3b0f3b1a765dbff7839d38028be17d3357f3dcc976ecd907d791bee95b803c3b3082b387b193b89cf3418ddb405cce7540eace2ee778b04a6264a5ea96485178b774e1062b2eff6bf6303a1597731f58e2ce2d977340bc71752ee780e0c01449686541758798dcaa1feed091eb9646658c2103e296464f408065dcd2688632ba5b168141821f504cddb2286aea561c8eaf2effe56f1dc0a179e98394ecbeebbeb8f300fe6dcb5c08dab8f4e9cfef49da28e9beb8f4bb2f6e598474e977cf7788afaeae1ae9f6776ddc79c4964b5ef2821d3689733bb2fbe24e9184a72233ad512b7927c1eeea5a9b24f3fd4998efd608e4dc105eae51dfce96fd54e6f547bae47592bc6d045e7ea46ef69739ee7cd9eb3ffbf9fd5d3401490adae4fca60d23e76e38e3d6ffde6b7d25cbd607b1be7ef7dffb834d860fba481bd7f32d91aeeb3fb2ecb643af4bc5a8afebc31769e3fa79c70769d80f36699384e270177c7afd82df645f16934c5c8b24b8fe458eff91ae6fd2c317492f48c38f643aee8bf40b76e147f20dee8bec0bd29edc7dd41b3ffc8f643bee8bbbd9d425be5f317c316e48f68fe4eb8ff88bec38e8fbfa6e029214f5b9d63fd260f308f3bf2926f9beda24f11bbedfd0964851e070b749f0c129ce1a46f05d24f8305cb04317093ee86f5c90cac1735cb00b5d64d177a9f45d81685ef0a98864d230820f52710416e3820f7247bb72e0027f0b2e86eb22792ed8627d83e233d75aa0f8618b2cfdb23e64852dd6832451288afd21eb5b248b26b00e8b9fe707ebecd8336aed752beb996b7e5ec029c3482fe76e78c19461ec2ee76e880173ad83eff3bceffb496ae0fbbe2f0d9049708add5cebbabbab5ceb7e921ae8ba67711124fddd73e5225420097c5f0f32333373cf6772dec9af906baf6f3203a3ebc50f1ffc0c8cad677dfdef33307afe7af5bf5edfaf31c05792efbf1659de777d677d7dcfbd7a2cf0abef2495796bfd6f72bbcbfdddfead36a8fef72c1ea0b26c8974599375abee5eff880fdd6ed76675edda3ff9491bfff9fe4ddaf83b59c291cbac537effbd937cbfff2a9151788744b873caadcf621226b77eb5cc3a247c64593fc8ff7bb092966888ab70b86b04735bef6e14ded6d767f1842997f547ba92444322dce69abf91776b5f7f164954dfc8bbad6751c992cb7a9c2111eee41aeb2bcb32ebb83842f7b592f3bf725efe8e2cfbe733b5b5674e8e757e5880ecc1bc7bb0f307a7c86d03bfb625d2ed79fb9899ffe33bc9a1dbfd6693437e5fd33259d25a2793ee43dfd5d5d5975b9b1cf25bed9077cfde7f64f93d95f10a511c0cb7ec1ffabec07075a9d4921544bf3edb72bcfc4d86fd54beb27f8888ca778b90eeb42c2261efdba86febbd6fd9a1f9e5521669d497beb5493273d7bf4524fe1ec9e57cef9da4d29ef7b61cba5dfa5d8974bff9555bde6efd26677777fd598434e423f0f77b437e29b5414aa892f96e83f89b59b3e2d03327768055c6166f787a2663152e32bf6fee52f1441f1f7cf1a5ede37df8fccc7359dc7a2e3243f2b9c673f9bd24f5c93abf4e92ef145b606b04d66b5e904524fcc1c69eb59ef5e04f11c9b425d29d2cb2458295a4326f392feb2749655e16eb2bc99782ae6987fcda8ce077feb4cf35fe792bc9b241f5c1a7e250bdde8321f862fd14e7d2e86f59967f82952cebb35ab644baad89a405daf276c19f248bf49eac33bf340092149759673eeb8ff8d0ed7a3fcb5be490b3fc59e4541afdc726f97e64ed7a6425c119ceff489b6987e6f52c6fc1e1ee8feb8900f426a431a8fb0f6ed9d989a5677c3937830fe0c4d23e7ce9037111229e4b043f12a7f1f399ad6793966a36ef99626c58da2776e9d70c29632c85eec4d233fa3c68a090e4fdfc23fdc2584e2c977ec9685cfa37fed16974f8e004104e4051e17036efa96d92382a821a4010431027b0252dd56cf399626cfc494b6dfb9e6900b6f91ec93400db0d8914e6df50701afd3975e97b7f432285ef3d7b3be234fa9fbd219182f7d3dede69f43dcbc3b9dcfc92a7980632a8800837c230820c2efed21f1283916d483a6071821f7e98a2cb1233b0b18dbfe4b9f4594ce17138dbc4d23e1f5cfa9c436dd06ceaa63f80cc454a1ea457d93e2dfa1da547d73b332eb55de97df43f1bc5b3a5f742ae44d5edacf7a5dbf276a92b612d6cb89e25a2765f1e5d21241fae17450049b9db7d496d59e57a14d6a2e9765f66e052cf46e1336e67a79e50b0f30515f4062df7e672aee9cb053bec48226efc47afabab2b1f6c2c227033632861650d1cfd39e4575797085c0f1a86c8e244d48153125238a3297cc62502b7f30515382a0248ca55c1b1164d36fe3203b77be60030ef949cb3a1896b342f1131f0193696c5f11936b637fea3283f7c000c18bee070b66a7149389c8dbfbcbddb720a48c34af253d2bfc506ec7c31c5958d9fc506c0c81823047758b9bab2f1c7aeb77702d02925bba7f3ab5df7fe951cbbce6b345cece2b8b29e754fc979410fe97b1d9d9776c3c0bf72112f65d77f7a7d67bd7befdefbb3bcaf9ebf7befdfbbfb77e4bca047f2ed90b41bf48f74bff7d37b1bfaf3f6b5a17078df7d5e47ce4b495ab9c6ed06c8dd532ee23d7fe791437ad6bd1997a767ddb3e865ad52df7f5adffdcc7fc0effea67d68cfea774f848b3cd7ea770f9263d3eab7c8dab4caa3fa8fac69f5bb97b50febbbe72db71c72bbe7c145ea3b55e891fcc1eafb43dd9b9ed5ef9f3fc5fa36dffbed6bf37dcfb91ad4b89cab018d2beb597d6f885e96e59ed58e6bfc2c528f9cf7a891ba7625406e9fcf9ffe47cedb91f45924a17be6da08fef4711082c503f8d3af4f6d592ffd7e8a4355926280017787ca0bdcc08eabeb7d11d2f56cd1674bfadd91423529061868951695545b56015924a1a34fc511bc67ae95dd47ceeb911d126a6d92f8d3f7a736a89fdaa1db2dfdf677b353007e0f4e1109f8e1775f49f1998bb8de7bd0458e8074cbf0c1677184ea0aaacf1f9265fdf9e014d9835dced520c6edb8e6b53842f78b64fd16392f08b278807e16eb4592f52d92e7b3888465cb79d996ac6716d90ffe9106990c1f24f9822c92c0367cb043909c9745125a97b956f283e00cc1f08f34872059490c8ce183dfba654d526f688358df2059b27e2ae967cd568be4cb22f956be5e475292f68cc3e95a409e32d22f65b77b9eaee3b9dd773fa47b5913b7fb9bfe695b67e4763ab7fbb17dfabbaeeb9e733a1bc4b923907932cf27207fb0b0673114daa77c1adab8b92573b9f4bbff6af7f7f3bee42ef77b229f4f594b689f7264a17dbe37d23e35f77b15da87733534ddef25d03fd4e6dc85b7dcefb97d6c6e19bb2591fb757fa46fc0263f21a608eef760874df6952171bf07b927bb6b685e5dfe3ed63ef4bfefbfe79ccf0671953fcdda074baee797b21bf6e176ec3e092ebba1fea37fec9200f20e19230d586eff386120bbc029c3487b369f67fc29e92414d0b9b87bcdedfff096e3cd097b46a3009e230826bad0800439dc20031bc760d4b288643e1db17ce9b17d64b73fac3c6d783987a58d4badac67937336009968ec1ab6cf1c3b00b91c1b745dcd30c70d888445871b9e7000a34b1177d85804e7734ec943ce7bc1497b36699f4049f06cf9d7fbca1f8cf6cc96467e5b2f6b1ff0fd6fdae7033f16cb96ac6f3deb0b7b36b6cfc77a7ff023e7055924873f451278dcd096e1b7fe23f986a4915fd683b379baeb23f98224df168be49e95b23bbffacf95b771d3986be5cd9db6f4409fd323f98a30bf9246dd9d21d86195eb3d93652d2b7fb0c9624ecffcbfff9e7d4c52b29cd7238dfcf24f72ec19dbced69ef578bffa0fc5e170389ccd7fc645fc7acee569cdce03eee493b1d6366e7f289bc187db7ff3649ccff34ee110c96bc42b6d5cce5d11e3967ffb0a16f7fd47a769fd8d047c79df5988b40fe7ae7cb9fd46a67882ff7c1681c672d63d11cecdc074fb75fa67dafa8ddcdcb44f3f933c3d6b9d9ef57b47922cce581c615e9d9e4d71d6b37e0a8c47b7b60fe774371d0790c9381ff48e9832e2703818669f30bb7da4670e23e736c0e57e709d72112e1a3977258acb972fd885948bf4e5d2bffbf9a00bb26b24bbfd4e96936888af6ebfd177e9839ea8e4d52473adf4af9cc4fbee5924c1ff3bd24ef2ad64d97d39afff47da28f1bebf6d50f7def3a5245f4f54f2c1f52c73cd9f8a48ba196576fb67dae6d31695700da2cc6e5b3bb9d6efe209b3eb96b9d6967b3691be498d00b9dd7f2673bb2d274e54f2baf49da4422fb5cccecc5ce3205dbc7a7693bd05387f82977332bc60a6d132ccc0bbcb3919eaa0fea0fbd0bc9acf62166f06f1724e863ba693f37e97734c42b02ee7984470653d6363d620037617b9d621d7fa99ccc0c839a62dd72fe7985070cbcadf2f32c9d4c495f1e775d535763b80dc0ee89e1af9ad1d69e437c9c4e170b83b9f92464eef7c4ae7146386ee0f3a39599c7fa4bbeefd5d44e23d73f2eb9fe2fc16bde7a40138b18cf3d9320d387f9224f0052739831657d6b2cbb9a52fae2c1eb688645eced55075653d6b71885ee61a7f8b4886e6d5a5e15a7f8b24cc4b9f4916f927392f9343f3eace771109b5b19ef54f52c6b57e273530724e862362345c846fff28e322ad20fac10e1685174e923d58d833ee597973e7bb2ee764c8e2ca7a361f64ea3db973790e20370876cf3dab5df7471a04596c40bf2d912efd239b3b8b2af8b7bd21d96ef4dbe64ede906cf48f746d9fcafed35f1af95561e4cb29cc777b3bb22d213124c2f57eda3a92da72deee3db2f4db7d93fe47bc6d2ca6e0b6f9479a927c9b641bf74fb521f9517733813c34726ea98ddb5dce2d65b90c63918479fd8fb423cda9c4a70246160d807429b521d29c0570b204e49e913091f8a74842503fdf20b64347977fb200b202e81d2ff8a29d9b8074fbdb863df3f7a79d4742bfff91e6f6b119a1dfdfbd9f4f6bfbb82dbb0ff2a7ef791fb64f5f6fbc2a00590123f8a2bf84e5f2fc72de69c39ed1a70fbe4c18fdfb878e2e1d9a97da0a80dc20b74f7bc824c8394a6d8497a77d4a23df3ee5cc48fbd0f7d7699feffa8fedc3392531ae7fac7fdae639d79fdb27259834ff120097ec88e099bf976002e096d4a1fca71301d3fc69ade328fbffe0961fb478025371fb6b869431f214976f49adae9b20e91af5a5cff405705954d25d6abb6e7e51204319f90b14e42eecf21727e052afecd2f940a0187279faf7a5ce65066282f173da87763f85726eb524bd030a19dcf9a3fffcf4ec87acc6ed9e26d9badbd95228e73e1b23dbe6b482883b3830f586153a9c61732ba048e3baec7e4ed3e603891abdcb3928a86ef9777aed5e80dc3eedd94a96f5d6ffb8c8e77111afe3229d73116f2ed2938b4cae79cfdeb441defb7b5e93b567f57bef67b565add7fbeff3bcaea3d4bdb9487def6792ef76d523eb7b5d3f3bf4dda07e4a96fe4548b7bf497b98028bcbb929a2e829a06e0bd13ede50fcd3494cebff61a6958d85e5c33c2b3bcbed2f6197610f8021978342ea1af5f5279a4d65be006e8b27787742b14e7f0f31f2852a29974b446fc95d54e8d9a463246f433581ce3c9b30da339d9e75397358ac6736582e7d1bcf8ed0d77bf642055f6ef7448c4471fb5930ea1fcff517a07d38f74413b779b84c223ee3ed248ac3a27f9240272438f7441bfd1ef9002b73900fc045910fc045d133be3ced53d621edc329788015b639447c76ec9b9e35ec0131e47ac677bcdec30fce56f25c2682f4c412414081613583191c61632a2ef3cf8ef40fb5f1330466940f4fe0da89266eb71351dc6e9e198ce53febfb6e0ab2489e32185bcfb7f5f3bfd6f741f4e9839d888465025292efa72d83be9f22fd8f0cf23e4a270f6bfa1b15ac19e286d3283c37c83fec197ffdf69e7e29c473ebb31eac64ed591be3f77c9b45d6cbfe536dfdb59e4065de69a98dc2733d1b44bfb32358aeb3677077f7f9eeb3c7985eb610caa17d93dc44c5718650cef422c4236344172210e2f9beeffbbeeffb84be28dce5234beec25d7478867011f0f96ffa67e6f530cf1f8e3d00a6b7c9c4629e5b16461221f331b171e61b1623ebd9477bf67d0c19ebd9f733e437edfb1639eb190cc917f6ef3f32b0960c599bf63d8c1c7bf6fd48f2f4ecfb1739a467dfbbc802f4ec7b912ca167df87a4093dfb1e2451e0daf7ec3f449af67d3f7f8a23f46d59eed95763ba0b0128da92874b17c6e2b22dc51785786e149e1b147eabe4b9b30c6dc973c3cf893dffb70fecf9cbd88d79181869a467fd317248d3622cf8230cf94e9bffca9189e28ffe03f3e3f7c3902c22196d19fe57fe15df4596e3156d19de72e48bc20dfabe1e39d2d8b487cf96b3fb31598e2e11c808c67f1739739aebbb63f7fbf0b97fc2a67dff3d7873bf77912212d1d69e7d7fc443922c6577da3246b2ec67bb882ee3f89e9d43e61879cb9d638cf5997462ccb83c1632def295467e8634adfbafd67194c9fe673c3debc68f2c6796ebd9982582c575e6be7624c039bbdd29ed989cff8948645f8c6cbd18d97a3306237fe7e22a76e8206d752c2fac3d63ffce3fa8b3b567ccb3d6cbcc9fabac72e9e5cbb34507a50e7ed37b1aae75f4e69486d487be77e1e4e2fb96eeee20839f0472b808e55cfade046bc8e4bbe82efd4f4442ffa667fc32aef14f19c930a21d2dbfeffba8571a399805e46286dc1b605b9670895cfa538c71be1091cbcc52e8bc80bad3d9656a4ba4282e7df79f618cf35d88b75c3acb18e74f2e287da702049fa76e39a48cf5112ea202d7c42fdff5e5ec87884effcc9ce6e1f74cbb7eb5338db11c5b3cac073b474906ba30a28ba62bc4c3c5849eb946a74d7186e4bc2209640463498488ffbcdeffc88b046718b2fc27d6347fff58f86a8c446e8b88ff2421517fe96daff72f40fb94d5a7be7f09edd3ad677d68cb1b6f81ef42442eeb5d547253010e42405d21ee7259f4b2c8b23d7b7d2491c953617b4ed417e7943377bbef723b59ff94e0b4ee8938ad7b7e06b2c548ffd6b30ec8d408648ab19c5aa696f6e96f6b342f121fdae7733aa27d3e4b0454fb44b58f4d4f2cb77bbedfe8b4eebbf17295a55c05640463f725a8c045d0184ba6badd3379d23ef5bb670137a56fed530acdeefcfeeeab98506dc95c5c44e259233a9be05af71d4219fb482023602d3dcf184baeba5df7538c4a2255e6531212f497de2644fb94d3a97de8779f0f8b48be5aad106f51a28121b8f042758598ea4e7a3d925e4a7208f363fdc3b66aebcaf176b652e7fa7733f7d9c0df97eeeeddc75dd7f1cc72bcefefc85276f9fbb2eb3aaed1779f1e59c62e7764195eae43b8c66347070d27173d3db2b6c6e8d9dab376a6773ecffe32bc73ea08d7d8081109e480219433847f96c3c577f937936a72573bebc541bbae637ecafcb2aeeb28384da0725ba270fd2759f2dc39e79ce5ec9ad0b37e27857898cbed233deb9fbc85889139bb5c29223d6b4a96425198ea064d8b44a73fa1d333de22813b9fff36c5a8bcb94239977bec596cda92c89ddffd4ce7bdf7294444c65bbce9348020c8df24ebdce6b94de476f9df7739b7ab48c25a8fb450cee5a79c33e43291cbb2d28bf5cc93fdf5a6673b7276bbfca6946b311691944244eefcb6b3fbc299bffbd2f3f83dfe208fe716fc938b7e3ab718e7cf1890e075dd7bd77d10a5f426d67d4929ed485b32b9dd53727631cea746dded3a4b72d9755de74f20b70fbd6077777b7bcb00f697eeee3d6bbfccf432fbf897dd3788a8af5f5d3107807ee9de414e49a2795b095f5d5d6effb2bb8d5a890817c9a76701e98325330d625ba70b2a7391c945f896f4b9b6c6382f7dfa5e7b367ffec806f885970dd0e6394b505582d9ed449313b8ef8201726fc0eaf60c07708740ee12702901167480f38f984c7c694288af7d027039c744976be4d7bfc8fdb84873cd595150b18aeec585f791f1b1bcd4d7e55c1371b0445ccb69006b53a8456c05e1a247bc6050239d02165601d3da2226468232623130323cf50a3855408239aedf2e0196db3fc4c80765c84528002e915bde9044fe4454c6cb3ff4978a5fce5d4af6b8200d295943ca2ee88594e471c12fa4e4cc056b48c9980bb2424ac25cb0155232c805c190923c170c434a861714434ab62ee80a29c9bae02ba4a477c131a46477415848497a419890927ec19890927dc1180c2c2626e3b24446e3ddc9ddd0b580f30aa8286e49a19a8082f280169d86c262ced9ed05ea0caa840f4a24415929d1841249283184a7441b6228a1c496fa8d97734ac8515d31b0bca6568b0360750ac1277189dc12276831e10ae7d42b146364282e505bc46496f012c25c2616de662249092c4b58dd3126b3c41bb5c28493891a6238c74416d8f8728921d8625518170c16e04cc1571954d3edc94dc059c41836146e323373126d24e18593f8726524c87c11d39fad4a9ebaced39673887333b72a798ada72e6b69c35151628d87f3f8e0ffbbcf88f0c4dd9552fc8946d35f323e3f15134b6b574ee3fd9287694d31aca69dd4f4e6ba75c12b95bce2a9eba652f4199ec74923dccccc7bccccfe75156198c2dff636c29b3e5e8d45aaa6664ac66aa50cdcce0bccc30cd3055cd34cd3459c954dd923249d9d1025bcdccd4cc8cac8b4cf6fd4de53f3c686c6c2ccf6a6a2c0d0d0d0f4b79f008656f4566ca66acf7f3a7d37492eae9659c54cf1ff3b3cbf3ebd9a614fb39f52fb2e78e71dad74f29191a1e5353aacb949215999fb132a599b7223369ec0b323b3363a79722a4db39ae75c76c59636c39c2d85206b3e56cb4e5f7bfc8ceb195950b9ef84007d0880304b6594b2db551830db87165fb5c8ba8343c80abc3043656d73147087032e08ab0816c2859e9d2050c4e6063a7b95e7ca79af1c2644714554d6ea585e25ea04e2fd0a714c0616b24a66e4999a46ee75cb3d9d8b2a54c566df9f7b3b9dced9fe5b4388d9d3c5bd6a7ce962394d3f8525bca8e2411e534be6ecbbf50311dd303c83925cddd999f89e241130545c38366522d4eebe741e79cb28ac9c46233333433333c66666a64646256c94aec9564373ff333df3236375f4dcddbd467ffe161797c0d8bc682cf36997d61c6be20f3ad076913283e65125f4f712fd8bbd5b7555b5575eef3a8ea50ac677fe2a9b5bdb853d15792b1de45e6adc4629e6d4a32d6a73e86a45ae69496a9db1ff3e59c1a81d32d1b57c563d556fed34f4eebafa3ac9f6e3f68ad1ad731b69f26ae9fc62a1be7d47c9a5652d3d64f9d1a14fff55552b7ab6e4ff194ffc8c4bac81e05a74d2a1e305e669e9d36be8cccb3d35c6fc563cf4e0bbf63969d063e28533ff6e28c65a7b15ee65f3c2c3badf5330fbbc92ccff7532dfec3c3a2e0b4f93330b6e42e773ecc965566b42553ddf92f5b8e31cb4e73d992bddcf9a22d65a12db9eace07a996dbcfe33f2d5b56962dc7caf3f178b6ac9dadf3eb6521c1348c1c20e780ec3face707adaaa68d454e1b4fd127a7e12ad3d8c44f71fee3ef24d3323631ddae2375f72e5053fec3b62e54d40b7d826a2aae7226ff513a8ab1d5af4fadf0c9296c396979a55ba8a5c97f94beb7e255eb4c4eebffac37b93375d465bafddec5f2fbf7f4bd9fdfb2b63fdb9e65a7cda6a6f2a2e5f6971d75fbbbc97fc62a1bddbbc828eef697dfdf915063e950936d2fa34fd73673d38b97cfab9a39a8692515859bca35531729a7b537a99a3edda64ffed3475831061a1da86105b67e0ae53fae830dbe1061441054d8fa6994ffcca519c0b8b2baf2c2d64f73fe13e40a1ecab85ada62eba752fe339da82307263a70c0d95a4bffd4e23fb76903bf5bdfacff89f21feffba784fd55fc07b42538adb79838ff695914fa2793ffb0ac0afdb3a95a262f789605a7f537f52e5cebf72eb7dfddbd9f8971d2aa0f89f6584515ff61b0b2be9c5a2e2f4d1beb5fb077f173abf52087e2873ffeebcbc974f92b09b333cacb6827d4d2b4bd443b9f467e1496a60df6adfa254b7dc939f04b2297c32f792effcc7f6e283c3f8c9c52e48b9c5d5ce4a422a717d6f3d72a4ef347c169e2f38f22682753cbcea6b6a5cc4e2d4e9bb6fc3bbf9c52f367b30abe3f4f0debfb13a995b258ef5f82ff80e0cf9c361fb4ffd992a5eefcf23d5b724ec6b263674b22d569d4963c7776cd8a01e49cb273255b3dfd92a7a82dd996b3cbb664abeb930463399d9e6ec9565655fed3a50b1595172fe594f29fdb1fc5d8fca793ffdcc4f7befbc207bf64a9af6b3deb4bce755ffdef4b22b79c4e2e7b7b41f4eccc697d7bc1fb723a85f641a95ccbca589c8baa76fc884079b6b2d34a9e6e2175d31480a327fb76da7ddebb9effc3faac16188ab19779feeaaed7088b81791ba6698bc9ccf0a8f9a4a56aa37999272df1d86c6c0d0d199391313c666448598ca4e120f363c8fab15a1c040c6b6c6e38480f1f381cc425be46184ccd746fba8db445df738deb9e7ef8370773b85ce35e56bcfef737f7a77f0bedadab9ce650537846960b1c5b7ff3b1a79ce6b73975e3d9e404c29acaebec6d56fd847a7d2e741c2bd7385c2ee46155415541b1fe6b2a707cb6815fb693d89a4ea3eb4b1e5ff65db64e89a1958176ec26961dab954d1dc5d83e5b9dd6cf36cfb28dfa0b69762b0b9073ca59553faf7bfef71ffafc1ed991569c9256fc236f325fc91b8f3f8ab1252d8936eafdd2b4794d947e47ff567f69daeadfba168bbb5f9ab6ce5b323154ad5f9ab6968cbd252d89b62426116c32bf346d37245288bdccdf78d8db8c5d9a3619ff987f8cbd4d2aa7f9c3d8a5696bf9c3ec14a7f9b3ec8d89d3fc47bb346d9dffcbfecd6597a6addadbe8347fd14ea71b3bcd3fb44bd3e6f9837636396daa7aef8d9dd3ccd129ef998ae7e3aad69793aa658f626cddb3ec518c8d3edbbeafcfb6fae584aae4477a6447ca9c369f92efb4396348b3bfafea8ef44b59f9b79cf5dc31127dcbf5ce62bd7d4104bf5b2dd0bec00a9f3efb4f685f68bd7e3efb8f52d873c73834ef2765530affc624c4f6b22f802efb42f879569e95ff88564914ad67e534ffd02a85e1f753eab3e583560904676eda52d6b24aadb7525fa96539ca69fed47a562cabc47a2bd5be409f6d4a2ccb4eeb9f504efb703d778c44def7cf2546ce2181eb27a927ce2181bb9e37359f9efce766c58f626cb5f5dfaa3259fdd638de723edd9884d858764cd9acf80bec3411aa6c4f3d778c7fdb9673887ecf1de308ccb5b256f6979fd44c629c498ce5e7e459959f5397f9d4b7fca43e29ff994f4ef3af751c65b25b7e52d79ffdffe23ea74fea73e2336ee94d7956de54cf2d3d9cf7e4e13aa82e1d54ec9694aa63a26add9236d128dad4ddd2735e5c8be7bacab5485955b513aea59eaed55339ad7826ee4beec253d6eb7389712a31cedb5fcea7afea32074715a9eb97179066c766c5a9288e15ff52d361ec26e78be9b159695cffd2fc6cfeb2390f9be3d8fc039bdb9bf74c426c9dc454b359712bdc92676ba6b675cbd630b6aeb1b5b53508b6b6b7ee9984786c24c9ca6763e2b1f52fb9cd3b9b8b3697b1790f9b7760737bf36712d24ebbb637fa4731b6ef6bcf7b2b2eeb3acf8e6e6f4c426cfe4c426cb718b7ecb4f94731362621366fd21cf8fec334b6d34f5a7a99edfba4a5d1e63df8fcd57f929886d89262bf44c4d6faa5d096b4f436d6d7e797f94f12d34d28be5c3ffe528e0d7cfe318969664b5a2262837dd2128f2de6976636985f92d9c64f5ae2b179335bc741e6272dbd8d7290f9cc21cce78f215d1c643e0c297290f930f2c541e68fe4c821cc7f91321c64be8b8c7190f92239c341e687240f0e321f24652c647e8bfc38c87c16197290f995ac1c020799ef91351c647e47de7090f994ecc141e63be98383cc6f128783cc3f8a99ad05e8d15f8a6123494c3c36ff256a6ba71d7dfeafb25addf3879dadaed70883f1e78fb111262ac34698c21936c214e3c146986e646c842987868d30e9d8daca9c6684a9deb011a6b1071b6192f960234c6febe7c761234c331b1ba1964536e276ac61236ddf69f3f98fe86c2a9073ca6e0a89b1ec9e3a29f1add05c14ebadb00b4e500714d3101bfd9b9527ffb137b732886013eded86f3eccd7b1944b0b1ec0de9082a64e8ec0d034a503029b18226ae6c371944b0517b3b52c38730b43c75c9c1e6f4bb4f5a0a6d5e8faf55b79f296663799de7e35bd489aae3f134f63c62ddcb4ce13ccc146da2f65dfc1b1229906fff063ef9379b07e9e76ecbbe86e2fe657fc3ddfe9c8b1c7ccecccddf904821e667fed6317ffbfec614b3f98714eab6573914cdbbfe0675fbab6ee7d89bf81cd8b7f63692f6760404dfc6de68aec6dea8ccdefcade778d81bc7622f636f74caa7702c6d82c9be656fd487a5b4875dd2b1d5677d39e658f5a6e66d605ee4f1dd7a98538beaf657279967395131958dbd895f639938ad7fc6de50705a7f8cbdf138adffb3b7251ddbf7a1bd5128af72a886a2b15df53cc5e3c9441e33cf637c2fe6f523d46d575d280e21c40b47257abe100422480d636ff0b0421925c6f9bee3f44b77770edddddd8180618e12351a86620e3a345dfc10c3d02592e0e038b95d25d205e1be42100b1a1d43590c66b090470c1fc0843de0f020268c3131cee79c58c8030b0732618b0576266cbd80e411be154f65a10f2a7068c287818f9a3096450f9b7044c10dbd0963399b1ea10f236a7c846710118387cb0c8be72d3223e390a9537322dca0508e713e75777797c1096169c4ea87231731950c7d60016343191630ca41f82d8d342714a35e1d842010aeea410802217e10be72086761cb0990d2c2708c560521fcae60fd087d00e1e9842d233a2021521312e37ce7aacb5f1391f07750e37c7777770a24a470305bba13864174e5093d2e6690b053639ceffccc3b406a3a3f40a0cd3ef0a0831c0e2cf9383e7adcd8d4d0c878ccc8c46260785c43f3eada24e1b93eaedbd202b608af5e3dfc3aea125fcf2292f18f34c82212d81f6998ef594412c3748c7d0ecf902305402105264fa618e1926653cf3a4bab95e32d5a9ae6985a9a6696f6d1021391cc2ae66c82b7cc288edc1614de64ea59e3dc0027132ea97d7c1ce793771daa00469c3052654a1b56538caabceaf0c1881025108922c2021339bc3079c2822b8e26225a4c1832c5101550f0d20585145410d7984943b0a0c043029e128ed0c152470a5042488615cfc4a5a053021d223c7610e11942045ca30d9d39549849319bbd0c669f336bd54135f322811c26847264630d1e7cb0caea773f4b4452ddb84e2f483a2994735b767eeb33c1c82dd2a8bbad56cbd69b198ce574fad6b784e8a72212f08477f0c90d15df4d8cf5e54d7973c1564bd602bf7ecb96e07f7fc46364949b5b3ef944245f3512c7752b747363be18cb822c0aef5ba4904c268bc53e161945764b16ae7ffdde1391781f8fecc278304484622808bf450ac5ca5819bb2d4a416e9fd67b6194d82d85aeff4796fede772292d0bd1cb742b10b0b613a53c613bce8077e39dedc502af47e0fb6c872bce00bfcd7d3fea14d03fff5e10c403877c07f3d8fafffc872ca108f4f45242f6b44ef28bbe3f82f925ea3f009d7b748a1f00365b2da7a6f916578c177b20caf0b7cd7d719803a77c0773d8b43e1f56c697443f09d74bd8b485ce183e477757555c70dad5078c50767e822e975d156f97018f9bdfb1669e4d73ba8919d9c2c67cb967f5bb29b1bd9188b8de16d7d19b640f0f35bff48b3482a2db2acb7f54e96357c7f3a03c073a7a4b7f5fe21c93d6bfd1107ed90b7ba67916595a1d92292eeb31e299e403b6a67cce4a00890bf2231f2cf0180ff334aa9fd2029891f1b500308aa314b07738cafcb393594408063ac76ccde185d7074808291950608368ca3173433466f8a668391750508698c2214514fb33ad200c20318a4418307b934965890460c52e377830fc8183d393ec861a46f7840c358d360638c0ed0183b30406862ac5b7800c4c892ea800553d0e2780206682cd102348ca08931d6343ad862a4657460c6c802c3832c63ddc28df15b0108478c314e80f0c4c81ac1075d8c303efcf8800e5acec0b2c6194a5db8d8f2410f638d0c3c9861ac29f062fca2e8e089b1b5841523ab08da0c660c7141b0327e977366fc70671c3043cb9d9fc3050f6a9871cbe761dd3c7f09fe439f7f8afff8b3cdf3cf9cffccd6f31f61c17f68cf38cff6f5fc44fcc7d5e3397cfe09e53f391ffb98e757c17f609e3d781e9f5ff6fc28f88f8fe7afe23f33cfa408822deb05e19bb499fd07dfc177e48d55aaf99bf748cbc1dbffff481cabe475f0b3af24cd2a75f7b407c91cab94f3cfc18b648ffeeeebc3480fac07effd072f439256c9929ff33c481f568926f3f56948259b57f2f15978b9207c4cc7d6c3c7dffc8b54f261affcb02989efe36bbe5563afb86c386f639568fef537f68a8c4de9fb9a97d97cec5b1f432ad9c4fee65d37effa98bde236251eff7a16a97463afd46c4ab0bf717deb29a9e4b25704605302df47cb5eb9b129b5bee66dec95984dc9e6e9c3904a32d55ea1b129d5aff9b657aa4dc9e6fb9d66af4c9b52ec6f5ec65ef16c4aaef7f19dbd02635392f9d7cf904a337bc5c6a6d4bdcd07f64a8e4d49f6aff7e04352c9037ba5655382f1ec95974d297c1fdf81bd42c4a6e47dcd8fa4921525245b8ebdf2814dc9e6fddf5ea1d99466fec5fa7ff227a9c481bdd236a5f16fde8a1292cdda2b03b029bdde87556259a5f19560af04f34ab18ff92bd3e6e3497be5c7a6c4fa1aab54f357a6edadd27ca57e257fa5eee9e3904a3656e9cab4d9bc0fabe4bdd2f74aac9fdf83548af91bab646395645e69e69578bc12cdcbfecab4d55825f095c257125fe9f5ae3fe2209047b94b43b2d3f865e4cc69fc3c48149cc63f4356711abf0c399d9cc61f23abd3f863481ea7f1c3902a380de734fe919c4f4e637e1749c469fc22c9c469fc2139999cc60f9213ca69fc2d52e6347e1679c469fc9564c1694d4ee3f7c819e534fe8e7ca7f153b204a7f13b39c569fc4d4e2d4ecb398d1f691ed1ba12017283fcdc73c738c284e25abf0a5cebf6c058765303317ee397b381184ba6fa619cb7ac138a8b14f10f054dfe8f6a4e8f6a2fcfa45d62087e3b8d51dd62d5afbbbb9b54e02245303f14f47abe4530b6a9b856ebe787d97236bebe9c512b98ba8d858bbcec7f2d8e9a358ddf6539b4207b5354546b4671b5519f8dba1dc5b5fe26b6d591868061b3aa4175db73652dc752e6e4d04bfc21309cf3f54114ea5f41f4881b97f841f44926065121626010751abd20ea43cffa893a5b06512d3deb328836f5accb8f36d1b3fe209aa567fded14fbf7be7bfafe9ef39f98a5514eeb87b1ecb40e46479bcbe572b95cee874659772fb7dd8b7b712d5ab468712d2d56fdaa5aacfa55454949494949b5935454545454543b39393939d1262ba7282b2b2b2bab693535353535f534f5f4f4f4f4549f260e377113377113a70277e12edc85bbf0f0f0f0f0f0f0781dad4d342a2a2a2aaafb69136da24d54ae2ef234e322e00fb59c862068cbefd97ca2962d6f7a36653d9bb19ecdb167734eff30ca25866054944b0cc1a828aa16ab7e54542d56fda8a85aacfa514545b9c4108c8a72d9b28ab61cc3a81b2515e54d2d56edffbca9d56255fb7969b1aa179d5c2e97cbb596afcb75aa5a4719ada202499d5b555555552555252525252535a5a6d3749a4efdd3a98a95959595150a3cc5533c35f33a3a6bafe7d3ea55fa51a6fe80538db2060093d314b79c5d3ab2ec926b531c8173458a3c5abba9fba0f97c51e0daa4f1cf6c62f1cfecd234c50880203272a4b9eeb41276fdc18ea47736f98f6cfc88fa0ecddb3f9b6617ff91c9c6b1cbfdbc26a70d5cf3aad9e7d1ef1ec67276995daeff6c721f6532dad44e1e0c40ce017bee1887986b1f0a5c842f5bb23d307a141929b841e1d77cbf47d13e6590f83639d7df6c797d0fa9f17d60017b9c29987f2e314f7ebf77699f92af626fbfdfc5689f3248e639285dcbd7e780742c3debb7a433f5ac9f243da967fd4f3aae67fd3864fb20dbaa67fd3dc8be21bbaa67fd3664d790eda56773d24cd9e43167a60ce9627817e7e2538e854bf916cf79141ee53476b716b0c5aadddddd44aa8f54d6a19792bdcc5cb3e03fb58ea34ce6e57e2587442691d9fd50277573924d5cebff6c39f3d23ebdb47be9597727f5ace7979ef59ca367fd234c25d336960e8ce5f40282b1e78e916f0a5c643ecf8b4596cb392c926ed95e5860753d4bfbf8f45cd3ed7ce1fc5318e2f926b2a9b8083b55d3d7677debc1ef20c6a27ef7a74ced1334ad479111059628ec68ca65d9a245ca072c9ca684e0f2d43e41dee58a1ed13e412ec6d5d597ebdf3e8c657b89baccb5efcb49e54d5eaebf37799337f984729affa4f3b3448ce564bafe93a9a96758faa7b364e99ff6c187fe692184e89f3ea29be8997f3b8d2591eb445eb6ace0d8126d2963fdadb63af27091cf76d4f765375151f97ca69d37a93a8a8b7cefad6e7a96fd6acbff9494df1677529df15f4ad99ca367d496e3d06ca367fe2328999dd481712289930505a5df7bffd510fcd68b1fbee892c17ebc8979988f199a5f24f3b197b132b11818d8f8728921d862d5cfeb6833d163bbab5dec76a7dd77d8c25f6a3d75dbf676e4bdf72fffa6dd1fdd34adfe47acef64fd47ded3efabff512b46bfffa8be077ef7fd51ebfd975a369817addf7fd4bd0763fdf74720cc78043ee85a6ad9446b0567fcdb52cbe6b256705a7fc40261fe1efda3eefb996a6cafbf3deb8fc0ff7ea9651bad151c97bdb1beeffa47fef4996a6c626841cb2dd6d3ee8fbeaf7f3beabe6b59fab72396ad7f3bf2af7ff43dad479f773beae891b7fd0e01363f2840ea03b8d93c538dcded8dfe6dc9b3f90fe11c7d5bd8dcde965c367fa6191b1d9ab4b3f2ba62aab1f9dface02cb53a6aade0dc8ec49f792baf1a5b4d0c667481b0f075139b81195d60cc0b269b81898d2e500616139b898d30957a3132638f99188ceb8fc21f6f40d6d7fd91f74e440f1b9a97752f93592b38b7a3dab2a1b156706e472d5ad9064db69b9a9918cc08fe51f8aebf2db56c36d60a0e8dccde986a6c3ceceda8f5333198d105b2beee8fc2f7bf1dd59f89c18c2e90e57f14fef7b723fa33b1bf1dc93cccdf8e627efcdb11ec5d7f3b7a3df8b723f1bf3f0a9f35637364ec18b31f636330f6066665a395bdec8dcbc6449bf347a17dd08e2dcb2c1b56fbd9da21f4df8e3c1b760821f41f515b3b84f96e6987d0cf7f6433595220fb73fdaf7cb074bdf83cfeeb19e661cfb18f29737a46c690dfb37e1812468ea4cc458a64488e2d16890433671b20b74f10578d4145b8bae38eeb4135280c1a836241b2a09ba0b7422204e5f8d5d51dd7e71060cf1d2351918f21fe21d60fd51ffa7ec8fba1ee87e80f157d53b7bf0809d16422b6e5b39e8865cb9bfa44d596b2ef893e5bc6bc27f26c39764fd4d932ec1913515b52a9b9fe44fddedc6da9ccdc69735873c600e4f629f2bca2aefba12216ab55148645afd758040313f345ee324533333c8a643f34bf48f643343688686868841186e60fc57ec87f08f643ae1fa20fbe92fa4afa8766dbf2f6a4b1a56cdaf279d872e62626634b8fd952068bb1250ccc9631d768cb97cb9623f8546a405b862d5bb2a8d45cfa546a6e2da9d4dccf96df16d7f3efec10ced5d5d5a5b6a45273dd96df16d7bf34f2ae5b2a33b7ad6cd227c09b1eb3c8b44c33f3f26a6c280f598d89c9843d9b45da8e21172132a2b7fba1d7a532c3e2224446dea53f24c2a512bb5d1122a3befe437ea9c844eff95d9e8db5b80895f07645a8d0db15a102738b506951e94bed4dcf66112ae3eda7e2ba5e848a77dde6f46c1669eb47804c9fc8e87b7eda7d5eebf96b6db15ccf1f82a14b7cfe1136fe2bf6fc31d78589bd917763de68e60ebd2e8fe7978557e689a8d0cbe38de89d79a3d81d12e1da1019c15cd91319b52ecd1351f1aecd1bf5ad792222a3f1fa7822a37a7bfccd1bc9ee905f1c2223d725a2d217c736d7e61b7977be0fd2b936bf0749b936ff86ecb836df8664716d7e0d59b9369f86fcb8365f467a5c9bcf830cb9367f8604b9365f866c716d7e8c7c716dd66a23d7605c83e1da0cd764b816e35a0cd768b826e31a0faedd70cd866b355cabd56af3917c4cb7ea26a9154859b1245585941452725f4460031ee478aafae28a10b0ae48828731368e35a717d4000c28a83881162fae08afc8218771e6724eaa885b8eef6b744edd690f358c327777291bae63b1b9ffbbbbf70da3eb724e0a861b5ece5d41c7ed2ee7aea8aa01581241dd1e21c18f449090107fdb2877fe5123cd1e01acedd34dd6f993e79c64cfb9022e5cb8542e5c64df5812b9a38f7fe3e0e978f6bb9c9e7161755688e77a9ee7d93f03acb4769de75531c6f5aa80010c150b1876f0210926a82742d0c515705cd1e50a29afbb2e2d83c7e58aa4eb793ef4522b1db9e08d29b810e38c2fbcb03117ae250fe74ca29e2d5e688163ea06343eb0851561b0ac30e3035dd7759d155bb07458baa2b5250b261e991552d430bb12b028a55356f4205af154831532b8acd0e1735070cbe7f18cc86d69aa62cb16301a872e72d862820f6879838c2b1b6dc1a53fc271691572e8d04ab1cbb92d465cf0726e0b102ab83296fd749bca7f3c2fb3ca9b534ef3ec0b1eae8b6745c5349ba6962a4f4c3cfef37d7f49a47b1b25df69de5447da34807ef79d7da13eb5b10d9ce1870485044c9bf77d47ffb347ded3ee864403e61b245801ce569ffeedc8fbefab3df2fe85a3cfe25c0c1964c1d9e8d3eefb65fe4343701cd94f651f71e73fd934a07befbb299b06d0f79ebe376d1d3992b643eafe3cc0e33f6de3075f4f77faeb5d4fa442eb59df302caa70ab475a01e20b302f3a6883bd5b2414a6c2bcdcf994eaceffaa5ce6e9cc53d807f3627d507c5004ad4d3fab71534e9b0fd3c5a6adee7c5733b55337b5963bbf2389ba17c1fa300f635f807d7db689301ff331f685ef619e6de0b745d2b18f817dec5954e1fb986f62baf3452d777e8cb4f11ec9167bb02389fa55783debfd895468bdebfd871a70033ffcd737e026fef8ad07a7a802eceb4f5185ef611e85a4fa30e1d787b136f4679eaa386d3e8cc4d9d0e974e7cb58a8182975e7c790365e54eeceef4652e634a2a27987868814a0801f2252c1a601ad7f7dab9f48059b06bc5e10fff56c83f9b648baa70ffbef41d8b3a882f81f0c09236dfa916cf5412a2a806d49ad7f3500fcd6b7a882f8af175508bff52caa30da97b5f1774d89644856929dd6226ddca2c01d42974ada34928d9d763422755d5d0072775227c5643763cc47d9181bc7366698819513d440b5851646884ed45063e3e51c1549b0018eded9efd97432a767b418dc510618531da0428a2c7ea82148a25688e7765dd7f97377871b556429430d2f6164810596ee061afe676b7ccefbcfe83f9ffdb276dd8fb8ebdd6ee9765d47ed1af53f27bc9ca30204b77c9e6e066f94c5a8e8c0951e65e5786354d8304367a9b8b2e44d41b798428c18a618c30a8fcbb929d0b8f4726e0a32b8413abf2fc3eb799e57dff33ccff3bc8fa43da39ef7a3ccfb59fb08f15c5a1b07907368bf0da57d3bb8f38914a07f2ad5cc9dc0eacea992e7ce1c0a7077feecce2a140c714b2377caeeb4bad4fb3ec08ad50c99c21e1083975bdbc7610f88c1a9677cc1c9ddaeb6338e31e672ee04572e4f39317af7a5ce0562022f2935c11b9732d9e8c7fa87da28a5b3ac945213b07129a5fea3db8e83cb39135c71c5cb39134071cbf1697b1726f0c10447c891e3e58cf096cb43faa7daf87352545dd8e59c144997c5fe233ddd18633fffa69c1d19eb99900c9c88c1972b1a8050818d5e71e98fb92a2efd9bfee11c0e8793c1463fa77fd8466de95688675c63e45b8eb7dae6fc26c79813a3783907051cb77eb9e5f828005fcc3e77a6902f403a521b92aee58ea45c73bf8d9c7ba2897291eefb3b2e22c7954d27e9144e97a7e8aaae3f38d4fd34724e055d9e6ec9530eb502dca5560ed573c7d8cf391574f1efa4fce7880aa09ac65153b92e5254d75530d534be65e7e5fa774efe43a7a895ffb49414e788102969f5c68e366e8a8bb42dfa7ea8e8b3fec435ff69c535fff9d4a58318dbce2f5c73ce498971cbee72fd5b88b1ac01e01f87fa1ff6e11f0fa54da8c4a9150cb4899a041d536a06680441400353156030482c168e08048a26d7f80114801098b2545a9fcaf42888814a19430821841802000020002030334c0002449b3da1f71f290cec0d6a2eda91cd9c18032ff0dca5a25b87109f947ed71b47ba08981d9bf2eb8274611b9bb453e3e7ac8da1b052cda092de2ca54eb20d304da0082804cda4a1f3c20b1db431f06a0187aaa837b4efb965f92729070114f4bcea59b995635e6ab964472cf4a36ab4b19709c2ca9de559662a421ffc529d1a7b238b3f2aedbd15738daf14666fd4f24795bdb76256f795d26a6f84fde51b60d7db9446a2d08e90226a9d8d122b1a6cb88ea4185e8ab8e828c0b547bbd13679d2e8eb62008f3df7c003341b2a56a1313c5bee8c133f55ef2b6be3a8f64de1d95bb8527d6f859fb221f71f6bcd8b6c8a9d7e5ae19cbd1d83b6ef5dca812c912fb71f29ccf63e3881fc2ddb5d2cbf8e2013a84318cfc5ea0ddb63bb22e7865cad61f213d625e0059b3965d0d0ba019f1b9c8f463543f237858748ee5ea3cc8ce2e9169db250f69c42c4957ef25f05bf927d337805e7a9c127a68ab304437b4fdf1cec75c4976720c5cf675cbc7c9600104ec31deab1daa6da90ea2e68b2d3fb183b47fada1739a348859ad424dfcd9b5a51a636050bdaa24005bb3e09d32a06af898c3ed46bd7ac2df71250bb69135da4b3230e9a600952a3cc8dcc1ef833daf8af458999fb360a2a0b55ccab6b747098d712665194cb54527b1c476b4e091333379dbd6d06867ef58142c14f115b2b940d25b4d25e5dc424683aff6af940c398b7e6d19b796ea7247d57f6f1b29f5a3042643962d66c46aea38ee900a581e4719715dac6a44d115c8616ed20a5c64ae32713d2162995829cb618dba14a67e654b9a7aa0ad972cd3565b969a3ac543a5ca6a717047923c352c8baaad3acab74ac18f070c0da4cd214b5d89b3bab2805208b9e7870c36ad252ece6816850c9a571009a29569705ebaac0e73f4d13750b574673759a8e009465223fd72f4de9a84d861936f12ed4982c4395d1424c35e51c48136a3bb71e1d79b70b521edddfdd699a24380f1faa9b9e956b7b3d41859a768f66a9d89e720e4ef1c4423e57ef896749b13efdcf6ce9e1356c06ce10e06fa93e1305e565f67da0669b831e088c05fa2f19bc2ebf67657f7d691c9ce87d1f5761c8bbe256fe5cb3f027af104fab7322ded5187c0c5e42ee42ce8a270b5b252e3f050235054a7b7bf28ab5bea6c6b4f4964b56e2cb65ff8d2cea2a8a4b3f71ed05c0442127b2aa9aa3d5949d533991365698308826d8568c9a443f916060611e49de48596136deddaaca8651c4e1c762906a01a1b40da9f7888ada2ba960e322b592daa3de0455ba1582813a54d77f8d896cf131506088a9bba9f2e218a5a46f5ec66a4faf1697b1753c30fa2d759189369d38b8d6059246990ab474780e435d3f1772b935304f056102dd56386b9372ef6b781125778254d44995bab3eda025a1b15072bad43cc1afd5682b16ce25195ebae8309c013ed5bbfaa9c7820349259df8681249971dfd2c01ddc3db884b424f3a0126be38a999dec88aa3d05b904b4bd83d2ee6043c1d394cfae52f77a340521e074963371f336152fe576a72774a16cc67fe0188393e5257b75f154c9409184dc7882e8e76c44c617f8bbe191a9eafe4d9243cae15e21df29d5863ca452ef3245a288ba66b90922243c5425aba5c8c845af81354dfb276445e7638df27521ac547dbc3cba9a395ba982649ee347c062f49167dbeb91b7d93f4daeadffcdf3b893749e28ea96747a2251dd12dcddf32d81258ac5e1626fd71cad511914d5d789326ef8c6c39e122d373d120c1974946253fc4bfb63eed5e467fba65f46440959dd836ea6d27bc4a21e599bf34788ad8bd92bc90f8902deffc3049c8b70c9de0629f23c561da895c73531c7471978f3e349ec1402aaeb5a6420bfec49334613ba38eb3267466eb8ce8d59adf4b3e7fa89e2274c0b2c1d5e34047f6fa091d695fe9d1064ba530cecb62fcef245c4b8f43d09f1cfb284d2456bb7aacc819ca1888b7dbe2ca0ff83c8994bef1da1806f9c27a7ebb01f4066e489df2076af97793f05fc779fded8cc8857e1fa2017d627eeefda020eaf90d931dea0bf2ef799e2b75c10b0f8c339059b86124a8db6a81dc435fb43b9890082202d636438c8a86aba073f75df8e3cb00f25ec6f0720a6cd342f71ee185cf3ecc02d4534e7487cf64be6feb6ec18d340400426452f811407ee619e2f0a440bf0d20f1252a42c6506345663530c1585405f964c212073a6ff8b86b0d61a2ae9c0511f5e57ec7bb433e6514688a56697d15b4c70ba4dff9ab8ba44f7a83dc758e4cf30c54e781d89513d83d6c9915014b882ac53f346c1c4b54bdb424b3db0688c95498cb9cd1f3912197cad54afadd7992b8f40e38baf374eb32a5e899740e46de3a43a8f39bfe7c9f77fb734e886a2212d4c175032075d54e4f44663a096901c81b5d71042a0f83841fc18dcfbda063064b2b09936097c6d75db9116b120847d2f7e01baca50e9ee5276548f69e0b460954143ed52ace21ac28e0c83f9e3d68202df581b25a558ab3dea6f7903571f32706ea6f46e7d1e53f6d15283d8ec329093f492b9eb51e5911020f4c6275593de84cc4fa54886d513dfec010bf4ac8111316299d70238b13cb64835f4849c7656d2e0a85cbaf474a1b9ef97cc84dbcad93e7bdf19c407ddfbbdfcb660f84cb303a705bea1c8ca65fb7955df5a2799b464b5499d4ffb010399475a9bf24a1a5aa03ef2c7dd2742b2336842a1b2c0ad87730a7c4ca3f80e15e3855f446d650449477629f313c4f6fb4a4217a4a3923e2f24408ec1d306fe55d3ce2f2f74536516422b51e0064cdd56b59be5baedd1e0d3f181055d0133f7cc1fe93eaa5410f74a11b148f70902a9f4e2676a6b4ac09fe8adc5f2a4f92aa5b8eda56735b937214772fda15e585d2c2a28777e3e755039e14322c5e88726dd471b446e35431e4a16d93141a72c3cc5fc1e0ce7731033d8ed114ad8b28fb8134a6a282c1fc20b6c5bd8caf1dc90d42bb6a4b01633d71b7b117faef2ff0a21c6a04c3e80736d1bbe6e843733cfd43091f91d2457f54f5355960682c21079aa9029fd89d215e307f6a4302057a57c42e62e034e52adf29c32f54f2d3d99d80053b9635ef497c564f733fd658c2b2819f189c57e9ab1ca23f1f2edf474eabbaa0371d966c29c6a30ec7cf09e866b7f88dddf0491ded82d9750976336d482c070633bb3b74b3fb1bd64564faff999dc059947cee8bc9d7815955e5e7a395c65a9988e184cfa2aba11d7a67263257d80c86466de8f6608bbe5ce27fe78cec69c143a2f2fa3064b76765d5c5d29e4f467b4d60793bfa8711d61bcd37bd612e548d115f7e3601fb39192e1fc068ec54b4eb8c9bfbc03f0d32c346d587193b8ea03f89d7c3b0388800ce66685019b0302d438b54cda15e038f79fc73f15bba5e4eefa3854b37d6ed5b9871a4c68d574525fd6e5007eac2a7ab425f0f09b43d6b8bb407bdd007d57dfec15cc52977cc66dbd6aad4cf6ebb25c7c66c7477729dbd1e4102b4911dfc436e9c29b3aad343aa41ef334246749f382e62d8d479cac350015db653088a4e93b24be39fa1beb8e1add7776c9826d28c4e8a96d554e4e62560277dd21e413f73e700c1b10e90a442a210b5c402d206d083c21b9b9a166ce94ac1f82a51040b1f3125afd009698a7b3faa49f4758298e68b352fbaf599bcece122f88bb819e604cc23088b88bd725c06333d184a2fe4285c4adb755ee942c78e0dffe0ca705cd465f6cf41406053e51ba9f5d14894bc014deaee964462db16cd2b60296041e8c4028d9db38eb6acb9a1451d6f72e963f8a96bb4ca7913b7e16a174162118e1d94dcb0593f660ee859b9736261b26643ce67ff9f7cb76152f0f222db9042a421a9d4b642938423414faca9aafca9ac52a4e42fefe1fcb3a9769c4daabe989c05ddc21873df5c3296475701c66f8e8e05e3e4626b0bb90c5c81913b61afcfa5bed9f78b5d667473e9752ece61a6b78bbdc0c0f572d765d9e2566c5112dffe7a7967743bb8568337ee2c091e2cd153c350a1ef642ca8e59a70b18be35a73b227334de8796aa5a5f908ce82566553f0758566843c57684a09a19e832946a089080e73ec42c0e15dffa5d3fc3a22ed6eee702894ef04c694441d3882bab5e3b19b77bb39b9134f94c88af0dacdf39e785c32ce9e98219758ee795b329c4a3283c89609c765679600e120e0da74e43590531452a8370f7acdc890af227ef833ed3f89dd90c8c4212c55c15753ebe2d2d9f8d70034966d14f77a869443d5e7dd4f25387ce285d9fe78cffb02122ba74e6ec3d7316672bde6f746497f635c08deb205c8fba9babffdf05937e10c0ce4b7c43971ab6ccd20005665d40581912a831504cc53d99e2078a2609b21aa271506b5435301ef04c6d6457862dfae833c81651b0f1ba9dcc52a791f2aff85393f5d68a7855ab398698775e08463158fb97bbf52eb4ee24fac01c1a5354f3d257ff4745dd952081fbdd08ea83dcd92f6ae1863a07dd78ba04d4290fed64b1c6014814cd81c90ec593fd8fc8c9e66b6c4284518ca65711cdf049454e5a59a16f34e93c1fd23c2445da0b891957c66f9b7466cbc1fc32b0a382351bc5b631b89834eddb2a8d35d2c4f2261733aaadb940cfacc87c0403e7d8ba238d3f1314c24f4941115f54a5041b2fc58816ae3864ec399039a91f8502577fc5e9918a5c0e752ab49da983b4b752de08a80bf1d76cba9f556393aa8ee96a2d9d76f3a8fec390782b9205334370d4f25d0f29510e2f471c6684044fa496ac299c91e9cf4dad132aba8437a109d4b188b6381dccd4af3d725174dbbca4ba552a85440ef9cd9a2a2ce1b0658827443de4eb17e69e3ebd75c3eacec4710b3ee4c188d391abb468db4fce44553bfd415f77672ba125a64755f54e99547dc8ca391131c80eb8b647d9f2b18d07b17d015be5927b2a40a66bbdc312e16731e49afc6efadd90b887593c8f0b8ab7c48a8837d2918e7b9b2ce4b12cc5211481b78b474713c641762d99a8aa0aa5fb258a62a393fb6320e78f168251db5e5b57aeb0d02ea9adcc80d00245fc80b9b1000f99ebffebcd30bdfd3fe403aa53a590a57f94ebb7d4511a1e9e0442465b695f028e6eba26cab08cce4bd653d01a2494db4487a3dcdc294f84dc59c341ce6f57c976863b57e1c376cd23fea5c09ae5ede3444c64404597f3f3700f12dc40fdbfcc89cb974adddc12545701f469326f207c133d0e620693202b01a031c8f102835953a465db484773104294f553ce22e39a560466b228950fe8594d689cadaff46a6b27f4e6e6b26313ac6365b1a27268a86e41bdb58d392abd83920819849a02631c279e96adda9889d39e3be786535a4ead7082aa2641d98820623ef3a77bcccebe6adc609d7d2eafda7efdb410b95844a8542b575d27ccda880f4c430f8c40f9ca179b09fff92163c85214f868e9a91fe9dcea6fdc336d507b73aaedbf3275509a8ddea008f3a04e5847b6ae6b006c7b4655231cc72021e81cb57cae946139c848cf14f3eac4f842b16b066d8e2354def71ae1498e3b6dac3375d7f1653a41de6187acfef508754220543135350ca52ba889eabb99aed267c66d7a7627acbe02a279711a81bbebaf5eae1c9133973f49e66f9c6835bea8ee90033c0dcb5a3dea5ba9d7c3a65c454448d6eda84c84ecd37120b0d8e18f3bf1491ae04dc9fb8a980d92486aaa7ff1795f166f6ce68079ac865491a2b63250b5eb7728acfc0968cf9f753ed242c871a6a4d98c43393c93d281ecf57fe38bfbe7df0bbf3f5cdd764dc7cffb471273a2c76a9810446a1c374f97bc526978649b85703a35e6a6e02429332ac0d99f08a41bbea26920312ce7a72d4ad4bcfb2682e1d1de0174d36aa0d34abd484d402463d7916b493b31c135971183a4214ae08f2ef4c8d5b16e2ff523225e1d5e2c263d71fa0b1e0e2b9739fbc53e46261cd3e6f7430c2baceab7dacfa6e80f3c78406efc56e47a642c4de674c8b5d7cd35161e98669cd281daea8be38ce44a3a790012e4e78f2da5c1c0ac58c0340db48d6e7a1e13255ead70dd2e4a27c4d3af4bb7a517290d679628884204515a079c8ae88ecb4681903a942059fb88880ddcb8d47415132e20251249bd05aa612adaabd5cc0832e680c9faef141a7ee4abcf6c5613159737bc49cd19fe629a5f1be80b35cf8c79d78d591a96cb121569ae5c61df116e892e4090bded4b1b15628c1f85e2831f5414c8d0aadd23e8950c7d3694885a57ace181a0bd4b93dd6742033b4b982c5cce4c66586c3f3b1f682a9ef939a64b197e260b6c5edfc670847719916f30c7127d7b410344119fa2c0af3f72066cae9a77af860fb5ebbce040579efc9174301ef5ced5da526b5f20689a7905da5c733fcb7f638ffe874cc977a9d16eabcfd6f82734be5bac2249c28ebcc59e54a2bad5c69e546c0080ed310755e92eaa5a74d9537f8921efbc44ac80fa2a7775c46ac323495bf245eec0a02e64b99e2e6f0acc6f7a2625bb6d81124e2f7c857d09d08c9f065f0d70d78e3aabf2c8fe93268e87915e7121768a0c5dae4a80b502002d86d462394dfb084145326330cf6ed07196d69bd5ce3dfbbfbc629e78ff792c4071317a6dd87cd79fab4f436a6ec909a98233ddb29e058b802a16b4c66d537bac5c8aad17412ae3d0c3f3a4f663dabb21d51b393a96c23e41cf7acb5d10044a7e8146bd97e9f43dba6bfb67fefc076d7826dbf2fc01672e0762c4708c5cb2088307d946e52d7cb124cf662a0cb003702adaf04c0345175b811ec78bcd83989788f4e1b4389789fe4dda5ee4d74da8d54fbde74852312ea0c790ec4ce2a98a419d4b735def0dc3f20e6c0177c1f676532c82487b1d5648541255404d0cab3c6bbb9483628e098e6e823a18406276b89152fddabe3ab79a3fb063e06277a710a31197a50d815da9ba850d8633da651e85bf2945d10f58d559a9eb2790fdfb65c841e04bd5afc866cfe55bce1dd1738d1d2526e04e7fd7e59e1a35302c3511cf560c8fbfd080e1da8b05137ebb0e1ee3afc97bf49fc18031abc78bb60536b59514be897565860f2b22db46d52daedf17e0476a962ca623042a2a79ef79b8f2815258014be8610c01b17c89c7a5111ec4bbde5e67255f7ff18b4ef6a23a5e2be22186c1256b5b985809773e3ed2de021e8354add2140e28e298e31c7b19feb0c3fe768aa8c33f9ff2c6895f2fc12c01713c7147e1ed5238b6f429e70f6dd475e5f2f26645005e23ca1bc15f2872c9f985331550a198863031a98da57103656a596bbec59350157ea33a60d0428a78d711bd6a807d49371cc728c1abfb8a6aae18c34d0b2b36fc0533f4c929d6d01572763904996ed490ff3f41c37a44fa6eb8993050330e71b5463223bd8b53788cf6f648d7d2db560290c1051e6450723fb978a0c213f0bd1af931561c271da4881e8397c02f79b1a75b67db28d6f6f20051bdda420fd7c4612b20a3cbf9778f96301c4a70981940a072d2f16feae28627b44a64981e84bd589c105d1406eacd04b583fc2d78b2162e5c2b6b32026ca2794d38464d52211b47f2101ec587dc58e470e0b8bcedc70e31f5e02e2ae12d31f99fbe766657e943ccabf125d627343edde9df62e9de6a5b5838121e3f9fcb21d66a893986b295dbb78e95dca72a153110bcbd2efca9f860203b717b06e1b2a2640dbd133a3c80d3b7f474f176898ceb2b2772e0dab1f460367f61d11795fa715b91d3f17e507b47031d7a432bc7861d1f45db58651491bd0fd197a30a51ffff9fa2ccf40e934aeb4dcfbef2fb76d4e74c7233840be7bb858202832b39cc70328959c10045cbb234e06a2c1281acac44e7a2f84c7f7fa30f4308bbd045612a72f1377d55dae2ba29ef36bc95c195437c1a2cc4313c5528f6790c9120f38157128e41cbf10406a72b85e0507b7e1228a3f2a80e6b85d29554fb1872046ed90deb2d0e170023928856dc52f3671e60d928cf63edf42886fd2d4bcb17359f59a07ce5048edf58f6fd55965d770220ce1fafa445a0c11ddc30c271540d3f8135d170bdba4ded555d8ad4b3534296f2b0a762da4bea83d60d89373d5c742bb07c4cfb76c0b823edb23ecf1871ed27300461a3d38e360ee80d2e338fca6ad682b06481e8e83888d758f9c4f37764f83d8ac023944ead7e0a5664559e8bab6451b120d42088dce7ada71cf4a1c3bed6fcb48193d39482b288abba24643bcec7442d5759e9b3094c52dd1a1390a166713d6a0a37b3c7350481b187e25d71cbfc1feafcda1eb22b5d8730dedcf9be91adb6ecb16144a25631a496c5c66ebcee41d00b4640003eb9b1d394f5f8ee79736e2929ce3791b1cc3df155e6dd80b2bc7f91ad13c1997874e15ac12488acc3f4b56d50582f0423087562b03c5e14cab16d17910cd795ed4c93e496aec1c8e42b259af81988b6fa1b51a5e488049e14d63290d30463343ae3cf120486af08f1c0f37fdceaa01ae14858b4a7b33a1b33c1a12588bd226edc4b4b9e1950f63c6c1b91ed74cdcf08498cac054231dfda990740021df3369b6b917e083f70bd4650c5f4debbf50c304c2c02920f1ff289abb20c24c23f22a7fd0d09b3913960cfa389173cb50b1f33181fd6abcfb34618c82a073353a14dae776fe127aa44a747296904b4dc0cbb7d2462e042552d0f9a7770e103a780df978a841f8cd6e4d18a91eba4e27d15e4e2bbb5fd1ce94b332fc4737a572399f759f2d2de70d92bbdbf391252b54d4f9d2a85d6aa832c5ac0f259bb6e013ba2f6d387fdefbe287834c341e91eaa162ea5470ea969e6aeacab5edc457b0bfcf526f0be7d998d3acb54876ee31fe93b885ca08e03fd1101a9f6283b664cd8b66f7ae81af8c330f168269a3a00a2c0835be103c2365db06607e1b80df50733be2f24002d1af85080efdf2891ce24b98475708d11c44a9ada84e8ec23e5b6540f76a277df5beb0078ff182e145082c0b48e70b745ad2651bbb70bc8e4a44da8bfd261341f8b1b9f0eff3f5bf8f4cecb0fe8637b6414d0fe7dede56801b0c153b3bc732fe6905419785c47e72f5c74dca782f222d82c987d84d46c3f83849577f2f1312d9f7c43231455d231806b26dfb51d8ba02fa1be8a6899e3eccb2f5296a1ce3657f20cd4173ab6d5c6642f29621cbff6f5f3ffef84151fb5da5bee1f5de807e861ef139f4b5d0c8eb07ada9136931878d4dbab9de4a8a783a8672f17e87d089e3d744b63154270cfa78a78fe1cfa704129f5fa478885f56fe8e6cd20e377c600fdf148f36798aa837e0bc17ac305960771d14666f739edab5822869e9f5131173b050a24d269c7bc12eef2af6cfe83165b10677ec60f740aa0e14e8edfa28e6412999eac68e15de1d1fff9b82492156030b289ba7836893213fde4d4ca4d6489c2133a8332edc8f8e483452c05ab127846b65fc5930b858c4f6fd0adc85e18fc675aeafc65d9b9ced088ef36a8602b422833128d4263be2cf94612d8b6809da3fc68f4611417b55ea332ec007171df88497c2d16f589402e30bb79ed859d31d9d83f6904bff7f2431e7120b7517bd94dc57fe1ccc3965094d4c8e8be8a2e5481b575cc5ec4f76122c0318b34f5ea50322def9c366a9a9956b9089d7326c330655b82edbad92b26b29f2fd87ab40b833cdcc711dfc62f9cd7bf9eb0738d4cbeeeec7ddd4b6015639ebc1f7d1c01f716642d54edbb40c3a5c5aa960a7dbe6a063966885fa62d49b28ea00681281ccdce548ebfcbf26e751f1b299a8dc3c21023195d54d3347bd3ce61a69da8605f89c6d161737efe6b5e527544cdf3827f3e62ebf33a7d7520031b79f3b8967ff40822c9467bda6d2bf3c06b0e5b42791c3b04db66ba7aa48f10424ed7cb763ab0cffab6af5e679af3183869c74b4e2f63d2ee48f26712972c2d4e1e4849dc4c75f7a3100f5a165f5e15697dc70a5a3ce1f9d3998e8ee3e110c87ef83a5fbc2a20f64abcebe87293ac719fe5b20ac2afcfa7dd558e9be395d0d972a074512b12391d7a856e1eab046b1542cf803f928923f0350a1d76efe4800c91d65eb9659b051104f7163bedae3d2157fade540eccb48e49522780ed91c88b4882f1e6d5a9e4e956859ef320223ea68a57c7bb565981bb56086007e70335f42c08ff6d1ce6a24850a91251ccf43e9b9617100fee0f149ba9b3bbc944eb403286996ff9774228e77b6f9fcec469e0a3704fee9f7077cbef9c3e93117f8cbd5d915b3c53ad34a76cc7decdc8fce33cb69fd1a3db3d11f9963ec58c302e7288290b5a3614a0be453e048ac50974dcbcf9dbae46a11a2d01ba9d9493d386007defb4108f7504d77601c4925a6daad1c5363942e014ef97b2e7dc4a6bde641f4abcd86c5c178ccae69e39aed0f09980653a7d598a67d87587c06110e005a754854af55ef79fdf2034e5efba7bcfff842e16cb8ad4f524331a30ed6ca4b7d121bc637b804f90307a5c9175644db5e0917add4308549dbd5e51a4b45a208df16be7b50dd54e58545da5ec79bb82174614fea40bba4e5433357ff87c143611e007b7ed55347838820b5364dfd7de952e6fd5bfb344420f8ecf3370f611f1b8ca86c9f1dfc5151f5c3b3de30d55ec60359d2292e926c6a7595f5dbc7300730539f47274c2ffe43306cf8ee6bb2b18693b1dc4095bda26f3360a7d247ec03d03693849c8e3f91a802bad6cc4a9a4620f93c0d3e1a4c744c6cccc1d7a9e955431c43649497d61f3d162d53379f79cee4cbe6bcdc2d61751f09612519cae44ba28c9d9c481806c777a2070465aa43dc7b50ad106e6dadf39cd189d95d647b22a8ca6d931d7cd4da0bf9fe28cc59e705ee3a7e3368e5df8e746a0540ea25c8e769f6dbe1d9b5ece225b7c796066500bf6ebc057520700e429d65a4bf05bd72cead9948242ae7131f21941a627a08c6ee5635749207777ec455eefce4c13a8e956b4509c4a88bb6d7190c73399899730719b5c97974cb960cb578e885a1e3d1e1099dd25a1565d2e3cbce28987d10a8a7d9125c41f0163c50d7bb3bc7eb4a9bec9cc4facbcc08e202dd50f820bd081f446fe007d35b7c60d01b1fa136a46e92cf79aefff226dc939b539589da8912f1a6b4481dfdccad4b23ee88ac7312ca70d9b3f2073aa1a579d8fe7573bc7fa2bef54c696c6fdf7e78d4519e4c70c0c24eb83497faf40dad191c6e70faa3e93ef1d4c0b9eb43ec8716fdaa9ffe9f2dd04c99625a72e36f9ac234b0b681f406702964653482d682f1f31fef22bf1fbfcc0abb32da30bc7887cd6e1080f2d610fdc3c070a05da2ff98797c02832842b37a31486af908247de748b1b685700e2429d718f46ca2b34d19be94d8182562464ef17dbbf66dc9a516a2ef0715879561d631f86bad67db5a330f5d3143db4864349b4e5e439e6a145353bfca7928f2feace6eb5e4f935d923728bcfb8b800028ef0487a83fbe1b680b9a91fbc49d1847f4b0bc6d1d810bd1501affba3eb024258d5b681c5257f7bcf598307101af3bb497916507da43ced9205c51360fdcfa0ec6f9c3d6907a49c3944942ed6b1403321c3f47189122d85e842c1bfea28ac0f786ea654cfca4badd50bc7521af9093e0bb0ce3af8d27af12451912a7e03f9ba0884a04a6f63c436d3e690703b53f8016f8b6c884824a342b9d4bd811eaa40f474e30e1c54b7ce52f91e860f07616aac89882820a69da2f20aa2f5a7e48b6ae869c82ad837cac55af7c9e5a685474730c7618be629379d8a54b4bf5d6354c2dde2d975fc749a699de5bcf32dfe13e06054df534d6608db699e91390cb95e39778d8f185a045c9a6ded78cbb8bebb23c9a1657a9b4865c78a40a224b6ca1b7e087d0ad7113b3ea9dcbf4e5c377949d01abf2c32bba86950ca4d43aa3e271cbfa86608830fed8589fd5f57021ecbd1e54da6438a2454ef04a642a9fd42f4fab6590527517b7dd68956e86bbe299359914199efaf4397ae386da63f6c14e4a36c81f054218576a384b5108b23cbe4cac271234053799dacbd91adcd74df345dce2345c3a9707059cba4dca3537d37ee0ea4cec7a8fe6a79446e06814c687a9c68818f439d39aaeaebcd3e2cfe75774397f32430b66bd3877911495c0b90ec1f01cb2451211e8fac316c1084aca550cac2d1cf43f788f935a21c0a17b13f88290c543e6931996c1e25e5f1cfd818d68f1d718a14012873a7568e4a9c3ace3871dc91a530c3f8b3c08a115bbc421eedf719a144536195e12bdd800777f408e6e9aaf1d3b1b0bb87ffc3c94e084a0819bd9d3abf590030552b44ce0fafb924615dfb78247e8c7fee88ab90e7e2fb0f2f3d0369979b5e7fa727d6eb82cbceccbe6c2cfd363a489149a724e02405120bf626e544ca0fc97abcdba3054a11e20cee642794a24f5032853cbea21072372b64424a011e0df224280a169000737dc72ca147dfb1449e13e8e677e24480e70a695a9813dcdc5b1e3b94335331815de9e233d6bb925f0d7d308a3643d99d31fb370823cab57677ea5ad136b1b45c389b3894ae5f5d2f3b31d2ebb1e1d08906819b867c13fbe7975824bee474b0ed6c4081ae26e36685abb04e98ba00838ccb34b2f802a02014695e898ded7a225c4104411f9f92120a301c48795bcf49412e8bdce70dbf5198df4dc5113a9d52dc7ba1289e4b06191ae36940f6b13dfc92f6f18f669e92e0c3d5136c18859daa4a2557298b148187e29d8705f06809d260a3e5f676e2316ab31df76b55d641610ff61c97b823ed61e45fb25b89ad18d96d9168c1be55674a901cd7174e0498f1a1959721c12bf32c59a6d1b0b7acc96e006f714aaf451669379fb9637e82057cb1e8ba710c43ed117efddc17d4b67ecbec195561f8d195d0b51a654142b29848324853cc777a8fc1a561382e3e232004670bb3cd56762ae8341344618d4d47208f9ae5cc52718b08f889da9a97e06a80f700af8dcf73618428cb7379e7c5b5052b59918b751a4f32224c61a66047a9d609ef5cf7252744b2127b7b0dcd7f4d8d13419201b06df235b024967dc87a922b4aac44fd1ef94ca98805203aced89ba43710323d67c2ffd03dc483c224fe43dbadfcce5aea24ad2bcede482b31e9ab7a13b324162d56635f5aebac9329954e1d1636841199d58b8b0842b667111739611d939f35196b8329c0015252758e78be56e19c3f1d6e7b73d4973a07edee1c8f31d9f1d20c23403b2a69d1afbc501a68c5d04a537f5b6f7f7d8170edf8dfa4ea72f16891514b5d8cbb41345bf16564761d5c89ee29274db5a9a08350f6a2952bd1a9f8631b85a59ce5d056e32625c6c658d19dbc973c83bf165489269f42f7c502bd3c52ebad09cd44b8ab5e1762a868c442724e615c2e6aabeaa3e46c1ab7e6104a9f8312b55e914184f51eface583add07f9da6228d3b514c31ddbaaca1e2c5399ea3000df3342ae2ce01dfebf17217421e038494c4b3f8a52cb91b36c77299fa336043a349a2a5f5d4896a244afe4726e94f2f1cd02e89a8cc400eca22979c08e8fbee7aa0ead455ad470eec33fc85211e56fca0e18f50dbb16823a543c0268c73bdc87d7a13ad4465e7599845368875b45e64e77f9ac29910108941c4df04224bee7e0af26808da05b6f30a0d558ff366302d5b9441918617386790e390d43dd8972b5025c6c003aea8906482493b7eb6987e1c89e66b4cf8d66a6432f225636563d47896aa06320b538703bd7233d2d1529cbe7c7ee2dd4423412b1455299adba9e05be87f440f5e14012d7e44c0a70f243ea516758995fb4641dad229c4b2df55f4ed2569830fb84e55ddc040e7687690240734c5bc05981b9d3ac122aa490e35b08dcf2cb5ca0f9c3affeeca04cbdbedc41302e1f76e456709531f609d1747f497efa36735819d20bb73efffac7e9eff52b0b59e4d3378f92827dfd5044f3097f927bcc27172a13e535873bc7ee971f36e2991b3e5285ca6d09c9b166b6b2383a7107018ab6b541699593207c7925a0c5050de446612391dac6b634082cad3711cadd66844153421af90ca6ec7a352020316d835c08861f77717622817ab926a6137490c2df60c003e46831b23ed3539f988fd966b029475e30ccfdedaa30e92e76fdaf4b1ae25e58bc6623d7b0929aaeac3d7481d9575a46aeda762796905a64186caeb0bd257d996e9fe03c602b168926d04f5b3968ef45f001c25311619ac1114e23fd8b1f382abdc0b49754ab15076aff23f4159bd0fe8d8546f24b812f542c1fab63a0b775563536c8fab6282a5450a59ba64521d033718dbbd107e388c2a55fd0e4711900eb7ffb18f10f7f17ec0bc10d484c1f998edbfa3218494f575857949868393238dd66bb50341c84409381a5c5858a3090a9a5e3b58533aaaedaec495607d3fc465dbb027d826ee187dc2d706a0e058902d099e6bc132daee3c5c5e197d20835cc6942e849f9fd7a20cb3c51f707a9caf9af5c11c19bb3a83385cc47d78e1191d231f8ab3d1d9e783c7a17147e14f2e8cafd98a4cf8f1f9ffe7b1de3e8fd2385fe6e16743bd53565ba155d8b4f40320b9581ece0b38edf24bdebc6ba75c1fcf395c07a846cdd367357e89fe81b277ba6c89bf63ea5ca94e4784b72e43615990f0c0d770aad51c735ee622927c9ac3672eb2a61cb3aceea79f601296b9ee528c6354265d92cf2e03311e97acfc850799408287c1e6ea83720320c2a0e42edff504fcd6828da11b30e5fcaa543794f068cbf16518f78073053f5056c69896d91d70b7f471f180938f2178d0d091153276065fb61fe168fec0a4768f2e52ec14dc5c6281026d6bca4897d4a04f074a38b2710160171b4d2dd41e0245ef7da941f11e1c2d79d6ca006d018b395bfc52b92cb4473910a29ce103749da71e5f1feb322497717a0000ecda2e68e412d0ee340f70aab402bc7fabf24c05ecfed15496fd39a6b658b6f098bce75a34662085a725f364e6fc72b38368ca87693e2ee25a06cab2f13c10633ad73b4610a0edb78bab3efc06f38b29d3540aa3f72bc90efa1e3bf52e0bcd928af40844e9cc78b7df1e7d01f822e608089c4007f1578090ec3b3c1e9b25b89c2b07d48d6c7c7fdb0dc4b3899a32c7456fd13a8082b44dd67413911bf6bc98e8502520b8b90edadeca68de6641375b4cb4535fa9283490fc18de9d4df6e03e9b66b13103cc9ba7d5f3536e4e8814b5d70c2f01c7fb69161128cd4aff928ec7a4ab49e6bab1c7fe7927dc7adda2a08f0d1c37391d73346781c2aefa346499ea2e5d2ede2108fc44a03a8c38166dd0c4a95162db39cd9b834c7d804c4d3ab9eb3635502deab599d5bfb95d72b59c90614a5b0d74eaf9cdfd00982b5aeaeba9ccee837140dac541f5d0f80381e1a6a9730c4f8f7e8b592c539f96e73b7516b998db9b6940b65d5a0f0221eda939af58f93e7d77a24b06c49ff53589f8342ac16f6fc94ff29dfb4a585afee9ea933122e8981223bf3efd4af410088ffca42ee334992d706f527a8d8f9989af067e5a9a2cb1dcf0bea18232260654431dd51726d2483c29add94c217d05bb8f8df072f3290689d49212f3cea2fbc337c2c0a9812ee72cfb1d7acb55f9c35d61e5443e6aff8c447252f4aa7a1c1a61c06ecdca76b8edf64881827726e0601e59b5fb844b99f7ada63a13627730e93ec90310a41ee5c744b0c1870a1844a91155f0f08c4e160f9e8ba0a0decef6d6ced168987d707bfbb50e03073924d44e4238f11b1b9002bcf11b746dce92af119f877e66bce32ede73a19bab999413994040d76bc561c893cec7801149659b8ef301d6256931b573ebcb4b5ce0df690b72f8c242a9586967dfecfd553b34ac214c3dae889f4ff465a916d8849cb108a4dc1bb46d2e4753dc85642762e9d4283287ba83db9657a2e62004f4b0d620a89cb1a8784b54e34aad099ebc1ad7da627aba9597158639a5bfc526e68674a278d7b0587598890192478083dc5015f28582c8c423d6b7df57e2c03e92f99a19231ca14db9243bf11a8bab0a0e52b3bd1d4669e67461f34c00dfd0c48617bd01416c725384c3ab741c7f9c3b6da7fd521d4298563ef8353d0496a901838de4541b4559cbd589b083a13a5fb626ea4c8c042f89535ce839ab143ec88a50e3db04b581c7278f551a8a0c88f2dcc588482abcca00ab84d498b8fe29b401bbbbfa42a4cc226c1723dd88090ae5b22ba8917b5a060f2238fb5182ee2d41fd51783b1ce5e08f16626f5150a104e8d63eb005c41916c3b78ff58b8c4eba0dbf7ccec9aa6d2ccc3187a3a3c3e57243b0440e80824362fcfce297ae40bf0dffc84b19e9a44a14ae41cb024b9744ab18ede9e9e2cac6836fdb89bfc895a99275fac83c1baa87f0efc48166f755a68405144199f467d9e57b559937a996ae5a5f18f8295ee7db7a98a459850aeed35e90a245a0c6575de32d8eb0a2a7de98741e77e219d80119beefd82086712390ec8a2a37e78aa88704aa86a250c2f91d85cfafa9debbb80f82eb54509b6bbbe00e6225374e4a47fb5554c833ca88ba7eec656e9a5a403f7c0843687d500d2e66659f5ac6e26a922e047d0d0c9e25d47b4e48879a0caef173b279536eeea391eaacc1c095d2bce4f5e1a700839dd29cff2c1a158d13d28883594972f14f4bc943dbf18c1486a472445615dbf93f665fd7422e5b5382f6b9d148d0608df5f9209313c53139c979a50c6ad89841cf08101b2c6a84b18fab12f08fbfc2ca794c2c51817d67f36a01b56cb36ad8911d2fe033cc1359926ab888be8b04e6456ecd63805422364c752783210f6ea0dbfbf1607c35e9d40945be8d54d4d7fc90e7571e20cc7f8bda3b6547dd170a3e917606cea48db513251ec0129194d1342637a7ba2387ed867bfe195e002436a2f8f93fd2e79ed9eec513d79d2a185daa39101982a301e09c7c1c225ac2a62d9a3fb42db993f9a3f774e321c6843008dd08f367d3ee56f0543be85e04438800b0a64513803b6ab4a312663f544386e738e6f443e3fc04d0a4f81269f1ce79121e9f9466cad5c5eb475f26834f72cf718638528c3e086107f32ae58b8e29b3c9b8583796e9c240c0faf9435b770d89b007d2397b2746a1d9851f1b9c9b59efeb06afb1620d64dd67687b5745721b673c94adad2a4404c602bddbb2d23658d969318f449527b0f128cac9931845bfc300420011f792e93535fd3ea2126caf2c6b864cbb6bab4d30214e246464078127706dea43bd1db23d6563ced164200c029ecdd9e3330ef7d76092a4c2806c348170dcfdc08625bcb20cdcc4ad32ad2d289bf6af7d119037f605b5afbf130a6092e072dce1beb864023a9f79c5a3a5f98dab3a65515609b404d5ced7bc1375aa94ca605f68846ac4ac88bb194d6f6da7aef92c63733af3c43c30810409578e3d8e22d31d0b06283d6924c9bb4901042a939610c44bd3feb72862b816866ad20a54de52c01758813ca8b6ac36be0c97708225c799a837cb3cccc967080bfaed5163cf3d8382d0a7c5f482bfbcdf0a4ea2513670bc39a5e00fdf19370dc6542f5c3226d04b4d2c0c8a65bae7c481bc49ac926aed78aac0af2cb110aece11b8f2b6fb6cad716f50441029f1ffddefdce253c4708d22604a82b2f5016a63271cd02e506c7ee1c80cb4ced4e47f6383fa6eee82aa0472af9552e176672d5592362440923fda58a8509a950cad878e023c075f585dc3552eaa4af92367ec4659bf5cfd8e6afd04c17df69629aaf19d1855479b5f1d7c722602babecbaa9186e8895c4115b8238bfab23413046e63be7970c971d902fb5ca2ff4dec4a236343bea3abf1845c1b469d73a1582d164635cfcf2a04ec1e215e89b940fca1cbafddc50fca43805600a8e086e85195800ed609459d79690f4a0514c53c0f32c1c1b08222a1950c04972abeed430e0f17eeff06544212756bf8d66c5dac489283fc60846329da5412f28a0a83d30ce860d16f201887c0af84de974d009e0018964aff08d4a9fb14785d023bc804899568df516bfa449263b931b92fb3cd3a4f2708fdd851783d1362ca45ff38a0cded50a959292da82accb2164b0ba6e0d6ae606d2109b53f666359995afa62923bb4c3254b0bef114505603218e9a56528fef28461b3483249d1e9be49f2445b7a3b878eb4cfb1036ffc01f57ad9908c34da333896b780d4f748046462c192b269501842175b0e67d9d29481ba563f82c6b56f3421c637bce9bb65f7017c4cbba2ee7d9616657655095c1319e295d1e00c640eb26f2f431e1ae4587a4343a79b870d4528c8e0f69595a624599e938458ba643a20681980ab6970b017ac0d7efb1b5e83f1b1d1b063926abd58deca36d3565288acc2d4088b8e13896da1e46350c39c5e761abfc4703271e668c1059894bdff08f0614aa4772d9f72e40ca6e04fc34193503ef1c082e75c79095e9839c18185ff4a1551f946cd70456766db1d0a4f39e59c52f62cdbce32ed8a8d3dcc41fbdf155471ab636e474c6eed245703acd50824f44e0d6295915c1412371d0dd2536287265c93a71b58b937d47b6a8671bc106c95d7aab570c244ccba305e40c4d55127dbd9c5a9ba9447fb46c313266191a701c076b04f76ec98206554d22c4669aa6c85c0c762d20bbe3f6a9f1ca611594438f7895240610c58f75aad70cd75470f9a007a30d8b5a66b6cd5bcf836809b187d1ae86248f569bc749900106cc2baf43949fc306c496b9a6a34ec5baddea773dcb7be6e2f04e0e8839f302abd884c807aa696edf973eeaf905e67d6d1ec80e4026696ed140ae4713a22c64b59ea37cbbfe1b35c3ca0e35f07a2990236b360f30ad7e84b23b55ba60505cfdf008b59d44305570b0a6c4b61ed2fb085c6be5482d0a77ff94280fec16f228d04adeeffec810cebc7be2a3943f40c67fd14b0b35c4a3764e1b639249720dd7827cdb22a04e235c9299802b7cfea5b7e9b07a554046400639ac884ba9f7ca5c0315daeae4ad29a4a780f5bd9929780f771215b229624002975ab68241f120a3611a03619244c0cf5d911a6e70449cb23930c93c99c03bb04c229418c1d2547720e3b3f5f11a0e84f0f51fba5af4768708271f0d432dcd8c1f808bb517fca85b7eb18b4ed187e5fe7dfb29277cdf1e9b9278c766e79590745e3c9648a4a94b9f5111b59ff4aad2266bd4dcbb7515195fab0ba485c4b62bd46873652e4fe998bc4fe4ac1a50d4b0eed44010b2540927b78d2ef5310655f3234c947811482fd9c0c6cf8d57d82494189b66697dc8798404ea234f787ffd54f04af4e555e138802ff0328b4c181612b4d80208dbfe6fd60659c42b0cf8af21dfba0e02b4ae205ceb8d55ba19c43d801e50abce08d4456940b0b515ad01552167dd7149183d6d7fcc918d5c22d5a993660a5d87f30da0149d4d0b147d6e525d843a242acd3368170c7568ac5c4dc2c83b5623bc4197daa2e0a13c07552705d4dc3717ea70adad8004b6c51d8766d22d61599fb693ace46d0d7edaf0a79f426834864b8fc06c7faf4e63cff3dfc316a740bde3001f18212b212881d40245ce78e0ec4fbc0ff945338c6d62800ae1449d7404da370037535090fb2dc3507c93e817a9f9b5dc5ba646915052059b0130c385531acd4a53d6ef234cad7165e4983c14920a6b1dd439844c3e49a52035ee80c3f81caf89952fc057db6bc1bff7c84b99672ba5292ae0930bb2ffacb8c8c6eaacceb0de43af7b79575dc5e36931cf83f68165942fb9de822b40f64fb78069f6d9c4665b39d6c5a356dea6c7f23c5f638119327621b2f5921f5a38475344a68af2ac4c0f4c06f1dac3127766da05c31da5ccbcf18b6cf3ecd417178c808cce370407c25219795f8fd540c9cc89977073c9fc4d8638d7f1b18a056b42ba00da1a4ec79674148924d98e4d9dfd73e5260f663507af88dbd72c9b713ed17a919c655c4fca9b71693899e4d54dd0d7fda5dee217f563d1dcec94593801d3a5284a4968d5cda17684dd1ef507c10caf1ca437aceb7d0af69e89afc4bab4a19d5a3cb79d2061cea20e49495ff6ff4f5b6da38298de4dbcf9188b581a927935ae7da7395a63d717c8ac5eb18f1f5915e6dcfb781c4092d23fa99817d889bedeb5190597d71c448f9b70346d64334d17cae44d9fd1cd6abd6a1d1d331ac63e837550d40ae851ee34b314dca48f9de4d3d458cd0c7b422494006ca41798f11c6fefca4879067a76c39bcf38af2791c92ea1e810d041f517ea35690b4c32cccfa2ab67cad629c718014d15d0e79764f1e06fbbee7388d92db5c918955692f2e4e6ce4802bbc02cbc6016b35dabd0b3d7c5e6c50973edb775a83f9f51cc05e6674d572f0bdab7dc19438ace4fcda2c8787ed7cc0094b21c5127c6ed177f6364cdd5e92076b7d9b7f9a4859ac965fd2e454bdb77ab009e205a2b8cf0ec12c3cc6800e2745c3cd5d021e34bfb6cced466231f4446b3b0843de787a01c1c04d7b7380246d95a9d82bd2cae6d967b9edd23a9f8e6a2a61f96d5e277650b2057ad66aa25138cc5e91266e3be80733d781805527e225d91b044f2b3a1cecfabb3ae8e095f8b1eafb2ad148b8c6d410701f6c4dffecb8f431a49e70f337d1dd584b9a6095069ea7d87e14402c5483ccb79c815860349a6fc9eeb639cfd52fe2fcd5808d066a66c6300322d74e199fa8c014c78b5424abc5949dcb81c7e5cae3d6dd813a45c4582bd5bfb8450b03ae76ee5ea2ff5a1a3db944a2d5c638414ed72eec1656b46e2167f77dc9761e4243021bc45f7990b953ad35eda2538395ed7870f350cef1ba503aba18f172dde2d46de2343e22de42d3ea1c2ce175a73bd67f36c108ad619e7fb06bd27262e320e95d21774dc1b8cb65355f3db34c36bbd2f596b1e4334be8265e6d27e6667a8e163336ffaacfec3473d3bbedfd5b8b964210594fd36304cd97cb09daf43e20eaeebe79f08829e0700e685a3f98078c98e302a0f5fdb7d8d3a1ab30521ad8f42dfd27c7f9974f55f2978efe8f1124b194eda34f5fc79a825b8868e3796bf411bfbea58b0afdb042941457f3f321dc53128a36b89dbb2dd85bb9f96faa21961a3448033f29b2ee181443999cc30fea01d5e24ccfd0c5463eb8f51e9a1a8983a30093ba61393e1e8aa5287c92009f1a7058b09acdddee731e7a6c4861afc55c7091f2aa5c8ef698fa39eb79e0af6ba2eabbc5df753a0b36cbdfe42d955a3143cd93271cb8f012652c43e54775a31cc3e3c9b60fe8e495c395937bdfb8422a340a3071b8245a12c4f2480edc87ea8fc93101fed600f825a4314fa0482adf0eacdb07a029c1f2f07de4c4fd3a5c0107a6631078867a3a812c272cd2b97addd7c3b4c0c7c19e13396721783c4f9272ea714669dee5c51d246dee723fecfff678deb7c37756c4538a2b1945250e67c6c117e75d0a619163be94891e7f13ea29b7fad1edb8988bb19ca2af144ac13acdabff82d07dd1a6d72f527d0c1c988f3ed1bf0fa1cdde0bdec42b838035e659a8b2c53e1231ceb843235bfb1d7eb52dac6a6af0dd4feda255bdfbe90a80d5b24ab259f358e4f1fdd42ce99778784529ce1088e9ddb178ac67345e4c80bcce2120715a1ab4e17c0790abaa4b395439b5153ec5ad3fa4018bca598f242c5200df5c3d4ca72f72f4236e70b797355843533b291a40c63ad423ed5c16838c586142cefeaf2f4073fd06fd1198db10d4e327a9454a04fdb0afbd25dbde2d15179920e06664e6986a9551e6d0e750231c91f81065aa5cc56f313373c110c7f022e05a39b2b021b6f59d28733088dc715c31a410483dc68f022e9286016b05ca4a306182b829f5fa3140aaadf5160359b14eae2daaf5d9e0e55d52a97313d46c0ab641de352f092cbacdd880d85e0ee3be096076fa84c23cf3280fe1d4406da0bf9f233e1ea908944b8bd1964c5f8f0f765ac4c0fe9a9e0dbbbe42a6f8fb8b4b9e423fbf56393256669012a4dc005c89325a5ee52f14f98402e22b5bb2ff04692007853f3f3a376c7cf9c23c987b5e443c2d488a05c8295d0f0f84c6ca7360d3f22f3632f0c30377167e8d75b10c515fc21ad07824e0ef2b53971f73edaf1653c5ccca861cc44cae8354b3e92b4d99bbf7e590ab7a982dbfe883b872b2bf4c72841209f0ca3895360cdc5e7e484738d7e4b6886e227c1e2e2f1526d583117d7c654a75688b0c0f1310b6cf6f2c7dd49dc3a84d0010f2b83839852265f1fff3c307404f18b5926493b6de12288b1e703cc5f7f5ea06ef1dd2011202c80ffcea302c6758de23336d03c5d25f3df577790a4de49efd09472ba626a60573fd3320afc9893dbb35cbeb08014003cc61bdff6bb1d5c46590164c2c7a0b82f1707b8f42789a6e9b96640fff53f71c62840ddc5eb34aa4d3f3ffd8b9cc782a993dc2fff8b636b75ee60087bfec016c72cba50c76d30f9da80d8638f029d4db221e00d40a908fb7ca99f32c671387cd3448972d84a69459dd1a17f1b40e5512b04e46cc28b5c8156ad54c13720b0faeb614a97e08bb4a78039ea027bfccff6db0637cdd6e0ec832423ca170ad3deb57ffe3343c34f069a5349fd8eb8de975a56587044472f49b370550fff00b16e9fe39ce7e0afb4b8c0e43e234a4db043c88d04284e5228cca274ff92236ffe0f68ee67be398a65dc407da34fd518f807840732e79b881a06fda39874e17964b0f4742c2714e3e70d92055827725bbc7942d9dc4828d3227c7735267230ed24fbad8e9883907a1e336963125a2366390709741dc89e9448fdd2145be4e6d34a4d1d91470dac20b4eb76b970ca456f8572fc4633fc2598247b792687b1c7b331a3b4461f0012e4e9c9ee9b04dc587dc8371141a655998648ff89e91ea9264bba62c8e825489d9c7b6913443b8b2141bea76f451f489d05cd8241023b948b112a703a173fd65c849ff96ad41837bd93a18a59dd35fee4e6f87a9e5aaf775041f5da2d8112a138c0cb8594454a45ca083886b4e310d0137d663668d80b30a9ecaadb345d561049d459bddf0ae98bcd165f3d1ec3fda3e856e095d7d0800feb329b39f95c9fe291876825792a3203f4cdc3addca09a724f687018a24e104c3dce0bf414d27c0bb2d14bfc1f5860f3bb1d1b84869e0c8949b867e390207d96b9506fdbd486deefac20a0b1fc459983bc0e0b98aee13da113a36ad2fdc654a2f9fd8128409c00ca213bd405f60f97c85f4332738288791db25ca328b4e7b3adb7c0fef638f5cb4b1b31e94e47b9ab1e2e9a13753e1ac41f849edc5777d3e79e911225d79a952d93ac11bc52b67451cd6b87cd75c58e5ec3d2c1790d1637276914bda8b547057b6f09f9056cff04dfd118043bae7b50b13af90a8cf86475d6391ca5b22b0a23d769a35ade080c36174db8df670d0b7555619623dba5f03abe959f440ef0fe46f5c3b243c71d9f7e8a50aea522d08a3a89548150983254d893e3c26c8258f62008eac8e3187c0db5942ae141e62412aec3771cd63e1fa224b42a59847c6e7484ed31b26a1fd8381cc0ac1b86e6873ad8ddff7a50b08836baee156592c2e418a7c6b3294d246683b645f046163430e170d4d989fae7861782e9e85a4a8d677f8bbe23ffc486cbe8efe00a4832bda64d452a3000311df6aaa591268dd750376ae9ae734810613de6931414f2c3d202c82bec35f761dbf0588b62177647db07a0e9f9643862cc51e6403f02914657a27f457d717f19afa00bf6084b6b34731f5b9964ea7cea07d5fc5a85c12a00210272f19b38803a94e9a412f7de54621888be887f213fc7d9c336a07c5cb0bdc4dd73508109047147332fdf6ac19d17d0afb263dea52bf6a651a5a55ca912ffb69c71e36c05dc2484dc2aac4d0f848e18ee5718edeb123600c02b8df0614883dd215e67070e83b980571522882f83a1e9ce8e828ab2bfe34f42558e6a9817745974927ae5333d244821f67d9df9c95495ea16745e861e5f70b72027b74e25f0d125871b44f3463eb9a068bcef7cc2e5516bb9f3328e897121b563e302d606248b579f57b2deaa605316584c1ee99e24c5a257a590124cbde59c00253c501317b40c2afce813c59075b831ad1e47fd01ce1b9ea012264450f8d083cb43541c6b772bb254f0ea63ece3168b9a27ae823339c97bf53bcc40755ef1ad035c9046fc2f43d0730498fc4f82c511b831d1f6f671ffbd0f60aed8d1eda8b0a6c318dd5006684b14fe4a9b0d4289fb208146c66bcfa93837cbdc17268465e11b3bc4ec000eba5b06edffda7bb5b530b8f076b6de88621c368be445efc6934f7da18263e4945fff49415072fdc2432368dc42cd6fde6a9dbc6999eb59bea5f2bc2c1a311322b57dbbc7d66815760a6245b0a8801501fc46d4c86204072ea71310dc2170ece85a1a4e93fdb5f3279ba9ef0d8b214e89733782b3073cd170ba670e47d832f8d44d8cc452cbaaeda04e4bc0c8a5243f98713b02cac0047c88d02d7be6a9e661c47367b2d984668ed2631e89d848a37ff8f8b7466fca64fc614be9c9da3cbc16fce7138d531ba6d1cbc5f82cc7fb4988c4693f6fad48d115a621fa5a1386c3a158c28c25a8ef9dc7afe78faa7a3563650455c591a0d943da8b1854a3284fb24f48f8520da6e6ce0a50ee7b2deced0701ec88adfcbced1801c4f10b605819f80522e20b15084141fbfca155e9687368b7bac253f77f83bbea5c3a0a03ac22aca32e7dfaa5bc33b3ddd928ab92af639675012a1f14c7ac8e4370cde2f184e1ede5465f7e7e567f3ba9313ea13e3b371c0ab55900b58463fa2b623f2c2080b8bd6f0f040552f2a3177953cf405d8d64f1cd6f260cd10bbb1601cf91239eef86da322d064eaba184c4ff115858062197f40b1b91bddc8db374aadd3248036e6107e12d416d5b45e4e0a87f5e7366446c84d16451d93f985e9dc5dbc64394b513bf93b560abd74eb79bac566cdfd7fb0fefe8da81f9fcb266991ede82bcc349e8bf7302175f6abc5a2416043252e160e04c232deba30f24f5b9cec79f61801c199db899468416c198e9adcb709034392d70076c5eaf585cfc1f102ca014081a18ae0a5e32bc6acca708a6c160c57acc3aa20169e2bf91ea91c10aa8a2a58b2d498c69fb5ee647cba92832fa4473bdb495e17f6bf2cdc42a82b2e2bc0f7aa8884b16f147021f23b06554a56a21f9b0d9f235bffb1a1a9edb2e3b012cc3777409541acf5b275561741ece824ac7d026f0c39ff21e284ecaadafa04c34bc72ec88c8082cc287295d9c217ef957de0e1bd90401db8dc3b7361777cd144deb06d680236367a2b055381d645d6330af6005ce078240fe72b7ca0c303286c50f68ac2a419106b6d863a9b97f5cd88fc70aad3b8cb8cad39af5f736e88bd98415ebd8574e562f1c614eacf50215e1c82a930f3e2e82df5a21da4bd7120bd320b8f2eb6cc6d542e995e34d900988f5a94954c33bbca43fb6ade09cc973c836d9230ee66a2c0b4831ad630f49691ee0a1cb1465ec1ae046407f225fa016553e46bfdc4ccf459105440ee49e7da5db84014e2ca337069a8998de3b3cc25aba6db94dac1530fd577f6846e09e4e1f5c9914d6b0c78bf7ff28e9881437cc0e00ac98277405a7e8066963a29156f6a41d2d6a9630c903da922c9d720ff8fba2adf52e117f595cc200ae9ef0e7b51966af7e78c5ca656c549b6d617b8ed4aa9127f7ae7d80630f5536ac75ad2b56300dc9e1bf14a71d6b7850c312c702bfae60d0a6d50f76e07a9e3f6347506f636b13d271468b01ac1605de2217f5f0beb2f2e85c26ab56e6a91a108275b0bf844c958b0af0222ae7ecac2b96ea4f56f9ae0aee3b7845a7dd181ee81575fc1f440eebe579d10078131b2379103566478b904b5f28680a5fc9f3684f84bd7eb99967a9f2278595f330bbc41d10f7088c540d0d19a93b65aabbee34b26f2d6002aa1dd673837adbca65866675b2a125a352fb68384298c38e825f986f052db5bfbd1216aa11855509527d20411442b376f6424aa518d081a9371b6cd032718b22a6f0cc6e9667db39525e5a671575a706e6e5e644bf8b3b158ce06bdd9593f11a0f1d641109c25c9c0ab03b9349633aa57318914c4702a53223eef1923db68cb1c5020d905c01d0dcd38433006ad5255116a3dc5aa7e084d8ab10d1f270d1c786724d6c8760784d109314249181fdeef836d59c79ae748aeb2fadf41ae298d92d0ddba53f1f1f1ff30ea125361a23578ad4b937caa11a384fafa1c4978c19b71ff2f3b609810971bc6be60c0fb31acc3ef21cde2b85fd21aff4958e738b981883b7f30dc7ce85aff73e4ba80d4759108954456b8601d3c93c4010b24ece63159ea22bb69f02b60db70af792a2fa220b1035cc745c6018a5e967edc1bcf2e9a2ead4ce3077810b6f5c2847b43b85511e3ef8dc4dcd31a6158fa8ab3ec035d8bd4f134eeab0bbe1fd52c5c141e06577af66599783ab038af045885f2aa6da28f48408f667f8ea5b59587b5c475a1b1e55262b217157993e50549d4927766119e674a733cbe8caba446bda7cef55a0364a41e1aaa69f965c139b829dc7427e62d36873d7e19081ee1ca699422c92bdf8288e340b8ca33a9a35c58a92263d3b5070c62ba0b6313ba837040f4639a22d34982149ed38fa1204117cc7af4c959e0650dbb161f97ec704463b16a1589a08c096da40464431affdb0d6c0ab84e554db7aea6cbc316ac951f79a8c9459daadaff17f543c9c4859d36334b7518c52e9e06dee6723a41f96840d2386d329eeb316709c1d95caddf882b8cfebf27ee199854b124e1adfcd81b3c1e5f4ccbfe23430cbf72b49bb05c7879ed1aeb2acb1bc7325b900938318c7104d8dd2057eb604426907a637ed7e19c6d7336d83d112b83f3aa5fc6ff0984ad06cc6b576f6ec62c38f37f7b5080ece2c62d3025205eec7ef77c2f5c618669f1e5bf20d792365e6c44d3983f83128179a89c7cce1f7f9add93c736c36eefabbd2f501d1d423199663227edc8b90efa5256ad8c8206dae862489644544aae2b5342f9a2f4b325477667b2fef471db6c1144b15fb04e1f41a87a43f14ba69515b4cab35d5ba326fe8ee6917f867b9bd4e50a8f2230b06c8bba75dfac5785815c846c533e0983e997aac1dc83ff73577f4740df9ca1fcc3bed13b611da3ed055b25b12780f32cbe708a56a79952bc6e3d23c99312246b90d38d3e3c6c2e3c55ff2f04ea1303ae45b3617988af9ecfa86c6808f1b6bdba20c4cfda71e6430c58fb6c0e9c82cc0d0a9a2e63bf8e93eece12a943eb702e748081e9b4d2e37fb920ccbfa6dde536d9f6dee7f7abf2c6c13b0effcd1dd4990a52cc3cc6687ca703675dd1cc074b308e7fa60d57076e56383d5e5f02e1bfe29592fa6ae0e8c90ffbd94e8757f89cbdb196d1502cc598368cba4989beb574a8ac3022354c30a9fcd6a560c9e53c4975fd7757d74334459df724a84d6706975a56094de3e9d39090389951b903fc16fe19e6f8c80716f7b9137f6911e40b5540f57c27a47c68f40475000231e8c613fbde599d0a08d9276c2f58fcb1df2f111428af03f2e9d7d1c942c4fa58c67eae69bd5e51400b097d544b6be51e8c28c66048315e3d5cdf79aebebdca54118d5f32f5e024144027a63c6f162cf51527d130c5a068c8a213318b7f40776de479df22dba62d764b5b57b88c7b864a62d088466307de16f7e2d36751ebc1e2c4d046d2d1b6fb46f14c592589eb6fc5ed105b73692674121b979988efaa673f93b32dfb4641ad085da16e1e3a2cd9a9abf9678d3c6db4ac74c51132a0bb1d858bd9f247c016bf870a2dcb824231408875fda4ef8fa2c52114c7ee586e213834540e622014d6acb682ffcc2cccbfd13571f1266051578669dbd9622319359d66d27f14042feec254952d3549d8b027bad35780315b0657360aa18ef18c10917a0a9937d276cee2e8a4495b1c2d7c6c3ac8a06a69f31324b026b0295fdb3474d5b3c1b606eb62d851a1e2d84fc3576f99a300016aa356b11baba1e0dfec87eb544743ba15c92ed5c3565706ca8b521e5ba8631070dc1d1d63b5307fd2e871acc1268f0da20719202ff0f99f7f0f53aff74b773676415e9b1455e749d291e126bd032798675fd4725a2cb877d0e83d9840c74cc6e93d4c0011ca01a4100e396ad83ad8ba3bf80d3e3a93b4048edd829678d3bf9060af91c49c06c5c92d5d4827b310cc21d75817f02cd8bf4515155f90812d30ee24f69743314677574515b5c0463fd3a49aadec3d61be3067e41755a76cfa96e44d4dce5990ec80cb998ace89e5c8c728af14cbbcad72ef6559e0d65100e879db9934b71c4856f53a49b490509c2984f8612793afe9f285d17338e80a47ce8392239a1c451025f70ff2390538b89a5c1fade36f54e28cb17391294919f780f945fd047b639787c588ff4e9913e77348fd09e8ffcdad96fc16f52f72967b50d2de81ef3037455bec94e6e6f36809804b7306776c639daea9a85fe120c60eb6019526d3493490f65d5c9f4d7260b6dff838b311e1240f849c44e40a8a082a86843461a033df32f2c5f10c13c642b22563f15e83696f71c875294cf5706c5fb10fc7feb9ac57a4bb033ae537d35b204c4a9b0e6569c85a1e4ddc8d48371519ad438a7623eaa621a57934518f2d867b65d6b2582daee8f78be9db3a1076d945cef90d7edc816074cd461f4a71171da3536e38517aa1a7c1bd18433e0d86f82da4eddd6defbdb79452ca5d0c400d950d3e6f5e740975cdbaf8fce0bafc74d1527e6a3d2009cdaad4805cec0431010a42e2484bebc5dc1bc82648c8c802f16f563d929511f2372dbabab4173f59e082b69c28d2dfb188b60555c1e566f563f5fb665d50fe7513f250516bee2322fa4d73376bb0ad185a31b482546188288bad5f42d1b7055b39ad9e18824b4b1f134254c2ef9ba5e2eb0df3d7c777909f766f3368eb9b762b2202cdca2ab38ab0ef25dc8bbffda6159d3d7c0ef45db384be2dc821118538dc02c2f466e122310516687ed3bcb7857a1f74a48505373f852a0e4cb418af5bb8f3ead14bcae8a814abffdc9b8a37472e4a513497545cc446bb40eaa97d282da791bedc219544bafa8f0a8b045ee1ca9aab9b46b33547ab2e54735724faebb5e63edf483aebdece68ebfb66fd75f24559ab8cfa0287c3e170385c08e6d09c035f0c94ecdae541b7d977c6212d0c43f4b34f038be70ebd04bdfcfc9d57443b507e46f78d0f511bdfb9bffd4380fb7dcf0cf913c1d26c212cf594481e99ad79953a532289efe7932c711903e641871ec2768ef7e03fb7ffa15faf52889a427a82c8311ebd3faf8e1f077f9fefc68f553cce589724974cebe1943c3ac4d9cf67b73b1e64d92b566a679633b618b63dc0284f3993415ba7953c3f7aca5717d1a77c89117f4acf522b83ac64a0d287082a673c08959a4a9e59115f10bd3ccd267b96a083e7be9f7d67ff9cc4e78be0f7dfb9af8a526646b495fa871565d00e43258d4b262ac310f2ad34a31495e411162579a445191b221a95f52af9ae9edd82f0b687ceeef80fbed6a3b21c23ba28431c2c5219b4c3952f26309e9030cca68a3fbbfd218005ff7bfc96f715c328b3123746592211934ad04ba6a0fcb47485f1028743ab63c4dde6aa458b8040de6bc3e826eef4bda86851c8b68635ac210882a07f3db0f2c4ad5fdcb4174317efed3b73e842cf81d0bfed1fa29846d31aac9ed1a334dabf3ec6f904b77b6f89b1115a6febad22997b6f0c245555adb5d65a6badb5561c36e24ad1d55e115b9ceb91bd169b35f2077ee1a7f1ecda9b74034caa3c2d74a9e88dfbefdaafe62f15fd7a908ab808a3903f10346b842888e2f88de398c7118fe3388e771ced388e63ddb99eb3d974d10f346b5cf3828bf3675e604bb3863541f333cd6c9a26bed634cdaac5518faf6bab6e6a7ad9d7eb553fd8ce318eaf175996668d7bab47d54d1396c1f0af63fd9a69dacb34807db234611606abb9b437566dbaea982607f60d017009dea233186d26c6625acbec27e1e0dc9a8c6adcb7d5235a53adc6fd593daaae5303415f746b2d3565b058f176496c9408ae180d92967034eecd4ffaa29a878746c3341a8d766d85c1768effd120968afefa6d7f8988e218414ae36a194e998473c63b7767c7eed411b64d2093e1e0e4e4cc664d3bb527043f112747cfececeaecd096684b3c97c77eb3593dd2d1d9d9e1e1b9d1683d3d311f1f5c9251ad4040f8da71c7a67b2abe9687a67b74896bad866bb55bb322cd6c227bcc1a3eb4ffb13f15f7f8d89f5bc340b9abc6fd1bf5a866f0d57b86e53d77c5caa01e55c7251989e8a8e26523cb7bae3022cb219308768b156916b2f29ebbac718d8c4a23f2351a1989a191ad3cb0d247cf4a5befcf4f2da82654ddab9baf4ef6ce1345672a542ccd48aad5665b3134444434a335dd6645452c74ac458b16b0162d5ab468f1657c5bd8da53339b6640b4594dac41b66c02f2201bbed1846c4dee33dab56fab3f43f1b5280ac27e0800fefdedc15f5488f4d3ac71ffdcfaaa5061eb07733f4fb309b5e605e58a3a7487ecd0a7c2244036c25d5bb1b862e887be2811d1ed5654c4a285db6824d228864848e08794f145b24848485506db3986cc26a2dbad286909572b8b92058b580bb3a9fc8c32bed6a88ab08de38988cc1a96bc990618c1772002dcad88450b23b3c6fd5a8f8ef0b5b51e552f329bc4ebf8a2b5bf7bf6778bb6d66a3d8b9f495cadb579cfc0d246ddba3316b4598dd455377f6b43f445599806b06f74a76817481e64fd30d1d769607bdab03a5ba4ea464797cce72e3fdf33a3d8baa88da02fba4b24dc8b180cb3a9c6b03144d8cef147f90343717c91a5098b69d9114ece4c678787d6e3f353030a12f21355615b3144742b62d1c2081f5d5b9182fea21b036f510838216bade5d72a02b25eb2d65a6beda006fe6c91acd7f879eb625d72496bd6c05fe33e07f64350ddf2e8d23d3615b0f315bd17a05ffebefce12f5f20d82ec1570ffa8a6e0c7c05edad6086596b6f40777e8ccb2aabf7265a74e7382f0dda7a07f9b768e27b4b6c7a366bd8372ff89c03fbe641149b4d1fca817d83f3f6e0e782dff96d8da4afb37b13af12ce68ae471fd8af393bd5bd4935b951301e3111b8d136b6641b94c1d1204bc4e0deec6bc6bd595ec525e5d86eb3269d7bab269947c7e78869dc11631c866088437c86a82649fbb9ce5967b9c4d556b0fcc8b004cdcf926399bd963d332c3d2f1d7fc57268268c06334d8f5d530d6e8b5b6f9af6edbe6f1bb797682ce1a01b67f418c750186aa2dfb967dc974ece399b5245659ef50a559e505010134035dfb8194035b4de22dd0d70aa8914ecace68c2ddc52122ee9b7d5cd48b28b8a9d1516b4d45bc344cd05f57a3d23c8a0a939a0ded501add15253a6f6e3fb9644d67ed07a8b2aaff2ec54af17c512d490277dd658121b9cd1cde877e525f9b03caa06c201d56a49fc18fdd45ba4857323029cb3ca8cb8fc86baed77e51971d9d8711a971c4bd1dc719db3feecac9ff3af276b8db465362f7839462f4fdb12aa9209355743894aa1d26bcd95636c24fdf3986fd14400e9a2d3b8d78afd604755c2f51642cdfda061b53acb542bd2ce327d20c7c37842af3527f3d07f646809f5196791b26b748bff64c2d09e2570389e1de7c3e39b66b348d849ecc383d65b647b18e7dcb5d7413e77199e3bf6dbeaac91cffe9df5a6b55366038c6edbe3711cc7711cc7711cc7711cc7711cc7711cc7711cc7711cc7711cc7711cb168e3e91609635ca3618c6bbfadce26264b831f1feffdfcf47a3e3ebd5e8f8bdeb6b7ad4e4bcd56199e1a0d9ce3a9b7c842ddf8aeba6050b3d2b470f4ad67b519361f1eda8f4ea3b550f125e70a638c4b1f2743d78e4d04947ebb91a10ce63c8ebd5a267be537b7dd7078ceb07e20c7c3ec558865e8be619045caf64ac7501ae65ddd5bc6bab7fbc4bb4f50ecd57dba4f3d3eeba9b7483c79f6ca066d2909c7d333e3e1e9e909122228485ba49186e65b346ef1a9b43133bad974199ccbb7a8ac5d6e64afd1b0d49beba191e4575a74973f3aad6ca1a2462dcabec31f259863cfa9b91ec75e2f2ecbb284f59c5697b33c5c9443d27765122b52e915e631c7a6024ab7569bc7ea62386e9964ae694c342c920df4deb255118d2d967bcb8e516ba54f5c6fd86967588bb065aaf8cace0fe44000d66e9178384723866627419a571a6aafb2e72b9cb33d5c943d6334db5e6d076d755769e39cf22e9fae5216af52f8f5b3e346cf5e9ef8142dd2e83430e8e1299e1de4dfb8f2756e1be563073fd06cfa5ce7b43f3bede79cf6abc539edcb4efbfab41fb36fda27edfb540bf47df4733c2e3a46cff1ac16892c1d9f1bc7934e0b63be5b6c15347e94b4efd88f5e6b8ec777ce8fa66fd88f5e5626dbb348d9471f3d8fe8b661f4a1eb30bbcf4e8719a5dd9b0ee7689edd2d137ef3e685bec763354773acb3e3aa84e3d8c39af3713c3a769f33ac45a3e39cb8de46979db51ef59ca387423f3a6d44f78def47c72602467474b4bcb78cbe3e6bbd6df2b1f39cb516edd863a791ddf62c935891b067a2c71e137aecb0d76374db3035ec34cf7db397e716c1dfc01f3a79ee325b2411c561fe7c7739d7fa3882acb67d9f1ef41ad9e2ac35fad14551747b6ea3174791c6c5dd72a45be748ab93d7e2961e74129be6a9c12d02fd737b7ebef556f7d662b3e9739cf4721ad79ed8bf93036c36c57cebaf9bf675fbd77dfb5ac5ebb1f3e7f398cf5c9f3f5976fe64f4670132375d03999b9edd4471c090510db4eba0384cd78e63e632cf91c2ce9f05c47ce63f1faa41cc673f1ac0dc74989b8e73fe7caee339d29cf3e7437f1690e338ae418ee3f8e738280e183e54031cd74171fc7cae7111e839521cc7f1f3a11d68a0e33bce809af2107111e833df4171e0d8f11d5407cd91e6788ed4ace9ec9673d614e7aca9ecaca93e6b1a3b73a4b033475a9e9bf6a0db8bde001d708623e8514435b8b70c666d34f69b331de499e8006e1148e3de40bf4ff4e719e4815e6d20ca81fb145ef108f1c918a9b3f7fa6ffd585b5d35650fd83155af32b82e8a9ad694b484f6f377edda2da0166107a32bc229cdf9bb5e6133837a84773cdd5bfd8dabbab75aedc5b0ab9b45a1abf7aca0abdf1834f62aa6f8695c5e0884d669eb4d28f5d04081ed495276eaa744516b1acd337abbb70e7a3d124dd7dfc09fef0d076c8dd52ef500e7a3862a1e47a8c0c3619db0814956ea81a52188375569b53136f8d6ad1367c04ca5624ef0822e253f304c9a22bc948c9d3ab4d15b8cb5d16f64527052d8eaa51e845ae59945ef4c3eb1a384def982fb6280fce0a578aac8d653ad328e2c09612bbde77dd29638ea1345cce8520f88f45b5bc29523572919dbc9b23fa4802295064037e429256f894f2bc5c30b4e2989afad382b398344554ac684c6e82dead03e2488524826ce2abdb310114ec24e113d85de59d64368081cb687901ca4521c1ec89670aaf1a4d27a29d8b7b7be6342ac4b6f114848ad0b171d78b5fc02480fbc948c65367a67120a718a29466ff127434d255195de1d9c46d8a564d797035010bd45924de53255a54befe39cb64c38ee94142698e8520f5e5fa052187e0c50cbbcf55ae62dd2972bba948c8950f4ce2fc6a0ed25a9ce48e19091e155e68c68268af04c96b18c11b90b9b714144e3842ce36334234378e6074e991e6740087110c93019cb44e19cf9209b717a911973660d4c099c32278468869067ce9489612433251cc28c4e2c53430e9a15341925f98c0d26192e386782d065b68466bc8848f81c09c9408166ce8867ae40abd10c980f4d8f98192be11929ca7811cd2891cfac5006cc2884c606bc4a395bf9e94ed5dedd81533d98dd39ded226c8d381bd114fe55de5e5a97a759fb62c2feb70efbbcabc7b05ea763c7c957b1f0fdcd9a99e6eeadb029f2ecf5e7d4fe0957dc2b96f07c3d75a6b73c618631fc771b4d6da529cfdadfd35fab3c7da9f81bc00202f0dfa96f8626c36651367f382ecd96cca68fdf087718da4c7582b3f59afb5166374976fad78f517e77bd1259eac38e75c7ece18573dce5586f59cdda2376c6dd7f51cd7f9b9680633c7f12eebf312b7c02f5f9f9d77ea52603de7bc5597878bacec94f9f8723287312dd3315849be463104a770ce56657dbc9d9f6497b481ac7b09976b0f43de7a046e4e5bc0ba8d9bab3ceb343078eb349d75c739a61d64e0e95062862dbad4faed955aaf5d5f4d5bbb1e0ce993c4a555a0db03afc2ed49a25eaf52be81ff7a154dd0d77116579cf5ac16c9bd5ea50c8a3324fafaa967444367bdb9c8af67507c95344f415f17aa79d1adde2c0279bd4a2dfc7a06c55709d3b3bf6e33a2d2d7836e462d5814d59bc572f47a958efc7a06c55709d33833da5fc72dbda0afd792968e8c5ab0a8378ba5f6f17a9590fc7a06c55709d338b31d9a8dda5f9f310021fafa0f8d0120b938326a516f164b3d7be1d73328be4a98c699edd07c6a37bebf8e410647f4f59e0364f00287e4e2c8a8de2c967a46e3f17a9562f8f50c8aaf12a671663b349f5a905fd7200241f4759a03221003c60b1c928ba37ab358ea19ad76865eaf12057e3d83e2ab84699cd90ecda716e4a8edf6d737d080127d7dc7021aa02029068c17382417f566b1d4335acdef39cbb93832526a41018ba4a2183718442f86702b906c36ee0ddfb837ace3811b39250a9262c0788143aa378ba59ed16a6ebb275801928ba325a35c0b2516141425dd6210c1187ab10267f37b5d04ba26fa7a8e57b3060e5d054b39250a9262c07881ab378ba59ed16a6ebbc9bc5e2526bf9e41f155c234ce6c87e6530b72d436746361e40297c4c3470cfa3a8e930f2619152ce59428488a01e345bd592cf58c5673dbcde89e00f0eb19145f254ce3cc76683eb520476d433716462e703092969ea060d0d7f5102800cc609251c1524e8982a41830eacd62a967b49adb6e4638b3bc27cceb55b2c0af67507c95308d33dba1f9d4821cb50ddd5818b9c0c148525a9a119544067d3db64b6241000030834946054b39250a9262d49bc552cf6835b7dd8c7049f77cbf9e41f155c234ce6c87e6530b72d436746361e4020723496949c68c1ba0d4d40afabad964ea6958100000cc609251c1524e8982a418305ee0905c1c19b5605174231a5a6143cb7b0ac0af67cb94e4d741cb14c3af8b9609865f7f59a6d4af9796e9855f8759a6f7ebda32e1fc3a8e65a2e1d7679609c9afef58260bfc3acd32b9f0eb3e9629007ebd66998efc7a906502805f77cb64e4d751cb34c3afdb2c530bbf3e649998fcfacd32b1f0eb2c2c930cbf6e64998afcba0bcb54815fc759a69b5f87619996fc7a926522f2eb4a9629e7d7972cd3905f97619994fcfa0ccbb4c2af07c03251e0d76958269ba5baa74f94be356c156aa708e04cc1bffeafbf4e03f6d72dc0f9eb01d8f9eb00f0f9eb3382fe3a13fad7650cfdf50a58fcf525177f3d07e3af2b29fd750ace6a91b68cbf9e74568b743dc6792dd2751867b648d75f9ca245ba8e3b4b8b741de9d416e9ba8b736691ae1f9d348b74dde8ac59a4eb2d4eb748d7599c368b74bde8bc59a4ebb7d3c8225d273a7116e9fad0996491aeaf38972cd275db39c3225d2a1aebecc53832988af346feebe8e9a7d01974029db5f3e7dc3376c5b2abd563a761e7397715f3d8774e9d7357358f7d76eecaf5d873308fc72e3bb7f5f1d8f5193bb78d7aecb073db248fdd3ccb735baab753bef268380c361001cee5d44ae15c4ef56b44f752e589e8ae57352bc420baadcee943b785da6574db295bf5d8df1a599135337ad3bee646b8ab847f30fa559ea59a5279336e8052533396664425594a5a7a824ac2253df62f3b68847bec9fd1cd480dd7cd76eb69d9dc860d4b0c58fb40daacbc38dba83df64f033411dcf0c00c475bb23113c10d6db33133f280164149bb91fd46b9717cf938679ff349578b847d8be5cdd5d42784708a2d25903085ae8717352510117eb50732388ce912c4051282209115e69081d72386ac333a22241ce1252c011128d4c0c584294af092664bf8840b574ee083102e1f2768e120d38da03ba1491256824033259c80133444818035c58820cecc109aa0cd1340bcf940c90d55cc3819ba0a13840a6d94d47082324c3c18a306092134b4095302191680382289102098b9210d162354e0208a287e2051831211ae1491c2f77ddff77df58a13595db6a420458931bd20e80b1282d8f0f402991344208284f033cd0891a5a3049e8e26d23cc4e7127a7cceeeb7abf47ddf057a14896255e487ad11c6bcc981e9f7c1bef2802893132409149128165a5882462b3bd1c2536865245a4bb4866811d1ca45b4f0105a369c3f3014c717599a3272776f37c9bd5d276153f776a9eeedfacd57e92a5da57a95ae52bd4a96eae62c8f3745eae6ecd454b5bb5d92a79bb34f4f96c7cd599dcefaf8ea22b8390fd8b8b90d947a5c5f7d833bf35a97d06abe337af59b118f57c7252dd1bcfa8cab642ac1bcfa007abc3a0607c8c0c7ab6be080085ca5254e9efe78f59f2278158bb556349b6c93aca91b60b8cbb29b013211f3b4f419b9929461c0dac2e117ae7a46d76cca41ed550afa478bdef6ca8a59e2e469cd73fcbac5ba01a85da59cab94e3d76b39388d2ec5253f3f3229f4ec5ce2e3398d0f49c6a2746d498fe7343d262642dbfcdeee121acd34c99c451b2de1e11983e824dcbddd253bbe63863df48ca57bbb4b7496febace87b7f400ee9299e734da62dd227b756fd7730b1a837bbb9e465b191220b09e82af3c20a29e8cfd344086c3c608596276a9cc6b7aa5eece5c404d655ecd05dc5486ea0ba2a065cc4e8b18aa1f231ef49002892198f86063450c1018728200c2abf22901f1c2e585228c40e31466cdd83543ce194957948f1a6648a28627217ed8906f789203c8981c80a0d2040f3acc0026081f6fc2207e8040e583820f614029524723a465e9ab5dad6e8f5bda00575a57ddaa3b874e14d19d6347e3310284fe43b13f4675d809692bc63bfb5773ae18638c6eec1f8a2d768b51119bf12763d65a6badd5daeada005b895759342ec637dc92dbbb4bb1975729fba4a0eb571a37973f2760ce19dd9f874e7edf9773fef2f77d9f8bf9dc95778a637df988e67bab34b1ee172abae39cddd1b2aa156d49e3ae886efdb2ec2097204714f1206a7bb6cc55027368367d4c501122cd6fcbcb4df9bfd3fe0b225c31e2b7dde51d50570682d9e7339b3218fa7590891e65d0fcb6f7011f9cd83f27b3d9f4e126bbf572aa392ecb91c95ce6158699e7380e1c9fe5a01e5c29a63ce1a03a1cc741af0e17d92e5c64f5059900b184807db061041f9cf8d064874f903c7ee5f9f0f47921ab6d83bcb7d5b1e8bef2aef06aef2b0f87153e3f551956ab1e5906dcf442e1a211f4ce4f6015ce7d5074ed74dabfa92a9c9351648b148f87733952eb9fd5778573301d7cd8f2a44bad7f5938b7012ecaca3d9c6bf1c313434ce952eb590be7725479f3e6cd1b2bbef207e22cabd1fdf5defa063897b770917574572dd4b4254aa2dfeeedd3db4f2a4fe5aa9ef54feb09e7729a58c2422fb59ea1b670ce3a815579f76d655e9109469e9cde7e4f34fb41bdfd2eba7317a8ed2786ac968903fb1d84808310fc1af56b3db24cf5abd71564b56dbc55ad16abef8d096d7d6b7bf1ed8729460b153d543867c99f0e4e4e6f26f9c01cb41330ac584211872c16e49088664988e37805a7e3647c895680bebcc8320baef270608ad14205f8611ef766734296592cd83433486966090096f16f997bebf162c24e007cf51ff79910b0d80c724b4c972bfca631415928da105a2643eb9d37329c0a8094c0c9917a5a3d9a4de5cc723c23cc7494b6e8ec7ca1e025c40ecf0f49578e858796f318ee413c5aed19abff70095584e0e7617a024f5a7fdd678773396a7803b5440a13da30712487df3e5c9ae8fd20c148942474e9f6c1f2dba792397383086f8cd031e44dba7d70f8ed63a5c46f9f2b1f2c2d3e44b444fddd3eaf2b9fd795cfabd7f3eaf9bc7a3e3d3c9cb33991850c0f4c7c6872c495df3d25b061099b10ac38a10211e9eeb1f2bba7891d9a10f245ca153247d2ddc3fbdda375e677cf16d70b494f941792297f774fd54baaa7c94baa87ea55d5b3fbdb23f5d7693d9cab5746b6ac382199e2cd90b4ca6f9ad65f29765052f5419a3457e9a6ddf09be6e2062468b2a42cb1cb92ee1e2abf7b9c9e86fcf5dd03d513b5040dcc123431fe9b96d545ebd245c37a39d1aa5e4e34decbc9eaafd3743857a580e255094105104a3062ca6f9a5391d490ac1c74d0ea6242ba694f527ed3a0aad090c58b0b6894880122dd341b7ed3a4fefaa64dfdfd4d1bc1f08c607878d4f070fddd3c5dbdde5f1eadbfceb3c3b96a35441026a0f8e0893354d228bf79a4feeea4b2d2a4f0c31133e9e699aafacd531535044b08266868d811916e9e1a7ef3585d61fdf5cd93c5236664c243e49944fddd3c50533c3ea67886f0ba783c3a1ea7bfbec3c3b9edc48ea9a822524cb540c3ef9d094031460910281cdc2c49f7ce0cbf77ca1c4105c994a91a76a090ee1daadf3b5a7f7def6ced70b5d989d266cadfbd5335ea769a8cba1daaf169076a7cdad98d3b527f5da787732ba24822a48d14179b23a0fcd691009728322d0041c20e27a45b4786df3a5d1948212545083abce1724af7ce93df3b4e7f7def3ced0cd1a203468b98bf5b27eb4aa7cb950e564fa7aaa7c3d3b1faeb3a3a9c2362d3c49724d448c98a4aa77eeb0899a201092c4f5c31a12add3a4e7eeb4021400d1537663e6063048574ebc4f05b47eaaf6f9d291d2a91481b91889bbf7bd625eed4883baea959d6546f4aebafcf76385787f0f1440813c61899c22385e1f74c2acbc9c9852d4e4ca124ddb326bf670228a2862a40a208614c0ee99ebdf07b66f5d7f7ec6a86956646244dd4df3d0bb766e1d64cd4e588ba99a89be5d0c0820845ac10a5072e5f5cf89df332b264ca1a2e19485022dd394c7ee7f040a50405ae3146207993ee1ca9df395a7f7de76ce57069c989a225674a4e931caa9edf39555739505739bb1c29adae9c9d43fb9d133ec1099fe0e0e0d07ee3845538210e1627281ca9bfbe71a672af74e3508541da8441dca8e1e2f92deb0aa1645921542f84d29221ca191f3e64d8c1ab926ed992dfb22aabbfbe6557322c7009191170095994cc876cc8ce6f19545757974cd7e56495a5b7d65c5674142b53feea2ad04a37b1a2cad250597a9725f5d7633d9cab65821882ca961dba9a3ca5b685df312d28944cd165b1c1865dba634a7ec77688b082113b62d0b9a9926e9de4b776faeb5b3f6910490c44128bc5b0fec6b2c0581518e38131abbf1ed3e1dc986508104ce0a16b8824290bbf634e3574545cbe484121871ee98e9de077ac2e2143171790eca6d44049770cc9ef98d45fdfb1a918d5126d9670f317d6f575c1d47c5d5ca0130c7482814e30d80ee7162085cb0f2976f84164f71b56c14441452607246d8c18936ed80abf613ca826ac4ee044854c0ee9861df90ddb3018961518112b517f619f15ecb3827d59e69705fbb260260fe7727c70240c12416cd9c1c41babc26f33688a561b116490a2254cba4d1bf5dbbcfab1e48413aeb658e121dda635f2dbdca6c985c48c8264ca5fb3c95f73eaaf592565424999bb6d4afdf5b287739509146890f232246a2b4d5ae477a95501178e58f9a1042740504977b9f596c8efb28b053655a474ecca2c916e13eab7e9f4d7b7f9640ef97494603e1da598b24b89f5b7ccfa9ccaaacfa9e4edd2eaaf973a9c3b40126b9ca0e1618db92185dfa5539625b4788152c24b0c26a4bb44e17749d543af0c9621b8146193eef284dfa5d45fdfe554ceef92ca0bd9c68b9bbf6457ce22d5e42c2e2d324baba7a5f5d7c91dcee500f2e508167638e10986ad21bfc91ac4944eca0a503790c025dda409bfc9aa024001b36608992b4c82a49b14f29bb4faeb9bbc22b19e90449e9051a40f72c85f12aaaaab8ad46d9287733c49daa059e2e4c7961382fc7e591d200c1145b4803ca52993eed7d5d3ef57d60d26f8b801ca171d2944a5fbd5d3faebfbb5f5e2ca415e517290d794579317d5df57557e41e5d72ebf7a38577b505d4a1429e28d115da92de1f7a895801d2660713a8344d491748f5b16c8ef71851b98b4b015458519a8a4fbf5e3f7cbe9afefd7d36b081ec1e0514cf97bccc263173c62e1b10a8f3c3c5afdf551877320b841480c63c490b01322f5f17b749a8185146a006303971ee91e9f9e84df23d411dd0c312c41262b041de91e7723fc1ea5fefa1ea7462a6c456c83ad886e443522d75fb1cb4accb2ea59ed706e5cd2c4901e42662823432ac26f512a07942f49a69440e5871ebea45b9c72fa2d3ae143161eae7a38d1a149ba45de87f05bb4faeb5bbc12b1701091080e2246bd7e8b50184af4210ec1525d584ad461291ece6de089335474d0d1c2134a52107e873b4c6d21c14b218a3031a43bbcfa1ebfc3ac0d58e04161450b0f880ee90e7b3c7e875a7f7d875b215711619422c229e3efb04a2b6ca215527585505de12e94faeb600fe7ea159e0e2d4360d5d0c312e98edfa09690962c3fd610c9024256bac1ad0f7e835d7fa5da8809a31b42058974873a1dbf43a7bfbec3a7bfe1102d20182d62c474835db0fe825957e0942b100be85402160d52449460f2258874834f7f75bf412850eaaf6f702a074b37487589b4b944dcfcfdbaee4ecddd714d7d5953bd292da9bf417a28618286aa89287a48f737f56f7e7f559fd55fdfdf15ceef0f2bcd47244dd4df0f6aebf3f1776bc85fcf5d9fee86a9526303902e42ac4e904ef13b5bfded42a5851f94b8e92125ddf94a8adf994b0a2c418ad4b0860990746737bfb3d65fdf794bfc9db9bce4285ea6fcddb949aecacabb9da57232fc7802ca8e24ba256914bfb156d5902436403142e40459e9c650fcc65d5d57968082c85615978f74e736bfb3d3d390bfbe3354f83b473dc1609e88d9b88badc245559867b10ee7aa559b34407a3abef850a4eb3776c25039e81842ca933527004937de3df11b4bfdf5df98eaaf8e3656879bbf4eb8488d13d743e1a2acbbc3b95a86479612c82c59410a98d489df57aaea5a31b9bf2fd6022e91ea25eaefbe500ef0f1376bc83bfdf59c0670975205f5667ddb285fc194bf396618a2ebc70a3c64f8b2246de2b7b55a00102427f43802831b2ce9b63daeff6db9feda24346e91f56da3fefa03aad2586fd62ffe3d8af96b9b84e9b643ec1313bfad53056c8c10420424b844e892b27927217e408982cc942d4b6cd9f284e50b1a273a1de9016e4e57b4c7922f639e44118509e9c5b9ba0686105ad0a1c908315c49ef9aaf00981e11212c99024c557a95f8eb38f0affb127acb9ce82dd3e9abb76e6ba2b7eebd75f3047aebdd5b3791e8ada7deba6ea2776cebadeb17f4d6bab74e1ad13b76f5d663af58158faaf382de31a7b7aee382de315b0c7ac3786fdd0683deb0abb76e96a037ece9ad9b3ff48675d1dbecbdf59e2d7a9b5b597a9b5ff436796f9dcca2b7f9f4d66961f42e7b6f9d2684dee5d65bdf71a37739f5d677a0d0bbe4bd7520357a97bab70e8484dee5d35bcf50e84d3ad19b9c7aebb318f426796f9d4704bd49dd5be771d29b7c7aeb2f2bbd5f576ffd9545ef57efadbfb2f47e49bdf557958be8abeaad874588553fbcb8e2458f994da2f3f41ebbdeba57d1fbe5f4d6c75e888ebdb7be0208cee5d4ba4cea2ad5add00a0a940f6d1f3acc6c0a5d08bdc7a9b7ee60f41e796f7db645ef51f7d6675af41e9fdebab6416ff1eaadeb287a8bbdb73ea3a2b7389ba2b7b844efb005bd45dd5b171241eff0eaad8342e81d5ab10e6ee90d5abd75708dde60d65b9711a13728f5d6750f7a7f5d6f5df3a037e8f4d683b4e8fd59bdf5202bbdbfac87f2200882a283601623511ff27ce8a6d9149679d14bb34924cd269066a57768934aef9cf5d64d287a67adb74e12d13b57bd75b288de19eaadc79eacc780e88dbbdefa8bca7ac983de7807bd7110ebe293deb7ebadf7e460bd078bde77eaad0745e96db7de7a5011bdafee15c03583171d4800697325cd497cbe62e4c7679f65bfe1ec349d4ea77b4ab3111fb6f8d05f665398035daca3d9048a6653b6593827d3c9743624f496e9defa96eddeba6c274b72a5080f9539c9745f14fd5f0ef779fd7e979f7fcf3e7b95faecf92ac5f88c6585309fb1ec867c76d06ccab52a7d0f66b3e92ba5d0af2dfd5aa34b157419a5ad1859e13176db8d56b352a489ff3c5f2516ff55a50a840b9fadd98471ff15a1bf5ed1ee65bc1144e9a4e82d9e59e449e1b42a9538691e4b5f29320196b2b09489e505c58ac345d8afc61883a8888b70d5bde1f034deb6eab1ae1be7a2a979accbdcaab13cb5bcca9205b2e441014b59cac298a5e804acdc71428c953b49e81268069aac9465d1db5e5d5d5d5d5d5de1943b5b39a598c4ac14d55ce9944e75b553024599c18856caa674f5945a47f629655bc49f12a8aa572b3f1ab4804a5993a0527fd02554025df172674ded2c3f1d325a962da8284536b652e45a51c246182a452432515926b9955f1ad16e5c510964456f7b7525b228c5234a71a66b34bfb528714cd6f78b5c6599ac0d6f947345dc339e342a7b6a4eac4538173a765c95f1557f5199b2579ede9465caa82da22255e15c88da2b32323c268fca9b9a6faf663a92aed2b6568f1dbb6851ab12682eca0f8af592442a3f5114af704e0cfa7c75f86660448ab637e79c69554697067ffb571df40e1f7c38572cd2ea598de09716c1ec9f69dc100cbf0fbdf13d08826808becf68c6e126a4675c7e58c962d046ed267e9e453dea10c5a9a0ad6f1c4ec4b966d3222449ad5e95212b0d0dbaeb99d6355ba6cf33ba6fe01b2d63dabde1330404b83a5b8fb2676c367dd93400f9e6cd6f1c3add67b483d16f885f91b2571c21b83f82f8419403fc23fadf35b5b4f52dea19cdde1bf8b3df376f42803d3f652c6af03fd75ba4812e82a7067d8b354a54d3b2e72ca2f8f6998681116d7d572b119b4d1f885ad3003a2e00e1c20f016e463b80d3ad21abb5b5625a5355aa32aad7db757d6f5729a7deae5f1ae700ead1f59c8c36d5db1dc0bdbdbea216fca0d19bf6167ccd6d94d72da8325e7fbd8a4f1863a85b84c590062ec24966b5f681f6dcb6123bbe50160a63df007f7e4f31f41c8ae199dfa2153c71a8d634dadeb8c7f5fac65d259427de0f8d756b64abaa76aa4a5dd036a1592a5e2d4700639d2a5230377d8ba55b290fe01c0c45f57d6dcf8ecfd0471bb6a610b551e69fe5b4786934f75bb652958751297b355e9007d1f6642cbbce4fe801dc9cbeb8a58d2b1f04cffab9ad36fb8c73b6fd2dd7a2ecb5cf5b97b6c74ed06c7dfd1aab36cf15004e9ec67cebbc132e8df9e629ddab87d64df00b40ccab93d6afd9047a788a2f7a782e8179ec7412d3d1699c03b8b7ebaf13832ae6e9e7cde8c49d49df396346ebd23fe2579ef884f6df3acb0d51e0d31880d72bf2662ad2b595b69fff88fee342fe23a2190079cd831cfb2549bb23f393e8a4488aa4e8a26f27495288f42092249d244992244992244992c4c9f199a9cb4c9224e943923d64a9494d239dd42167a4e79038a4cb48922449922449922449922435192361a4499664261de8ac9782ecb553c445d97f4e1b2996f072cd45d77f81fe73ddc783fce7a219d4fcc7813c3bf6d1c5fcf432dd6a6151d4bae2a0f3ea70d1cb814edb858b5eaf97bf5e4ee3be5e2ff7e979bd5eafd7ebf57ac972665eea382cc6f3bd5eaf57cfeb4543b7c8836ebdf3d241b7d5fd6bf6ca7939ce4bf6728d6e0bf5afd7ebf57abd5eafd7ebf57abd5e31747f4e30747f4f26fa2a5f24ba3fddbf72d7bfbc76d64bc1e73fa7888b3ef739352efabcda5e2807409ebe2110a4f56ab356c7c32d6ab1b5d8626bb17f19049d043ff0033ff0fbec67cfcff3c901fe2e309f568faef730a9ba53ae9276faeaf9c4dddb122eba8e4bbab71b8446df2a7cabee5548020f540f3ae8a15fbbc4741a97667b9eaaf4005586ace71c6b9175515753ac47d663e7cf75d26d0a3b7fae979ed30bf07360dffc580527bebe66b1a184c7eddb8f6118e210dda367979db11376bedc9a178c2e827ecfcfc76b36ddd0ab79033f017aba9ca17af0a2366e0fba350dd0d3e50c9407d1254e9e9a68d22db2e29b674dabf9a138f14737554afe2ee14e1af5c8fad882f6df22f9354b95247fd1adafeeadbe58af5e170c81b426a8faec3f4cf4b6bb7dadfe7abd17ad36eee9817babb5d6ef73d2def2dbb9da8b737514f475a1223014185bae9ca1d8fc7dd94eb1903f300cc12fc3903f300ca33e10fcb21afb81e0976308c2e6efcb762a7f6018825f7efa2167305ac6e49c79743927f18484fc8161087e590b981cacad923f10fcb2182e536e905a22e74ce6ea03c12f73d1d223e74c43fec03004bf1c953f300cc12f47e50f0c43f0cb4168f8c1bafd40f0cb27a86073b64ba6c879899c57e821e76c06e37b31d8f5808688b77e1b418a2b34a001b3c3e38a4081bcf8e6308761ce91befda56bae1cbdba5895aa522ed14aa215fbdf1d7ef5af32cdb048d7ab93e1f9d5b1de3e7386e863eafce775dfdf33c07afb5e21787cebedcbe07f2478ec7914abcfc6797df55bb357276b48d3222a81c704705b2d8665d4deffdc667cc1effb2c0c58ad479fe31ce22d8390a4bd49f2ae3c2da8bf713f06f2050c9cc2ccfa47adf94a5951b5028be8cb9010222e2229a2158874ecb819290a43a464851344552c3e2822f2e4c663280a16405a90c04209d18e1622ecc06237a445f401113a2f5c3d845022081e0c584154f0a10513ed8344914ec3c614d9a071b89c408b3810e1a0c32945635644515a714249eca981826c9321493497c49001c68b3cdbc2e9c8806481b25c581b9423738891d8f3a5c52c0c0b7287a24c2be2b68308686b684665137980a8105f3ba0e26bcce9563c07e1201494673d00e92a353bbbf2d3c4070cc393412674b20ccd2c6bac9c1cc4038e48e341766b7c195f70ef05f7332fb8f55e6dda10dbc132b93373ec84b22a7dd96dce8ef3bd5d8b5ed4de7b2f112f116a24a9883d59c22024a0f87ae10381b0f98dd0d6efcd366808f26b42c3a277feac944ffa5665dc6a9dc80e38b06ffefa0df1b3571bf9bda0770622a37307e1df10ffe702ac538fac59c3fc8a8af588a719503fbf0ec8e987e2f020e7f0cd14babfe8ce135a3c33ce395f8b03db1efc7dbf5d5cc415875f79686cb8d7f2b2a665dc17ed5ec67b7b86042f5b9248abdb31da46f13194e0a1c3951f8e20a24c5a2b88820b550e3bd82401c142f1d66553aa8cfc96039f4f5da56fcf40073cf67beedb5f7c4fd4c6edb17f32a90f95ed6449eecd7acf11bd653b190f99d355cabd951129222223521455e4a368c8df5d0425dbdd64bb22d9aee8c6c3b91a4c52d0b1c044162042dafcbe59d00684221f38a10b018874dfba7edf96d270e95a808147096fd27d7be2f74debafefdbd64db7b9e936b7db8deaef6ddfa0feeefeea9bd45f27eae15c8e11ca08e11df18147922652277e1369fddd41260a0626929cc9926ea2267e137101e20305365c88981242ba6f5cbf6f4e7f7ddf9e6e43b41081d122e6ef26cad257445df4151196ee1155e91e114ff788acfe3a910ee7aa9a214852c0c1c81a18aa30f19bc8490a0612945c45e124dd444fcfe6371114971f393061e20b5710e926da1149fdf54d3445fe26a2d244da68226efeee21bd1bd2bb213d35a4a786f4d4d0d00ee7f609bcbc312187373a6459e2f7d00b3a2755218871626647ba87b67e0f518006303a6489a2030d27a47b68cdef21abbfbe87ae62bf87b0d20c1149331405e3f710d4d6908fd8d690bfbea24beb86747ac8e9afafe0e15c03c20061c6092423bc014289df2bac9ae84a82ca981c88689921dd2bae92f8bd220b4b6bab0d4f47e449ba57a8f9bd62af58c1a56545142d2ba6ac68b282eaef5e51155b115b115b21f5d76d3d9cc340cc112c167ab0c10d9a1489df362d105c684184351fc80025ddb6237edb7a1f6831028a1e5a745049f70add0aa7bfbe573cc17eaf18127b6203137b621363eb62c3fabb6d595536dedf6db3faeb361dcee588caa18525588c14699225cd6f1b9a188ee872e689d319a874dbb47edbb0b4c023ca09549e5449b70dcd6f9bd414d55fdfb62adb94980e156d623adcfcdd2aba624e2ad43871fd85c2453128adbfae628773357448783494800505efcc6f1552434dfc80626a0a4c1050d2ad62cacc6f1555171082e68a8b10639a48926e15bc32bf555805f15bc595fead020b96460511581a15512a7ca818f277ab80826da16e605b2a78fc75948773475a469280b0638a2921647ea35a47a889828d151d2a40916ef4ca88df6856932294e8a1890f51a8a41bed15f11bd5bafa8d6ea51be5824541a3c0a2a0538e7ea355301eda8447054361280c95faeb670fe76a9b1d08563d429042e607dbfb7d563160a80851040952b89192eed312f1fbb422021b2082d8d1852724dde810bf51a7bfbed12774084c84130c4c04317ff7097b3a614f276c77c276276c779e3b40f1c16e2a4a93273ec6fc3e3da0c5083233f08010c142ba4f31bfcf18d63cb952c1071a76a090ee73f7617e9f527f7d9f53e6ef930a4c1b306efe6eefeaa9e9716d79d6566f4bebaffb0ee754b8e131f1810213bb35a910bf7d04a7204ea08a820c9523e97630bfbd4a032b5ba8a0b0830c4d9049b767fd76abbfbefdcab198381126517fdda1cc29f7313584d7c5731dcfe9af0bf1702ec71122d0a4e08305166ab0f2e5b7908c1dce7039c1c525cc07e9160ae2b75056069c78a932844d1125b449b71010bf85b690902982902982909010d5df2d54650a4199423b5348eaaf07f5700e035d636e6842c9921f74c0fa1d54a138320213676ec04ac2857407fdf03b288745489a10aa70c16221dd423efc1672faeb5be849680898203060c4fcdd4159bda02ebd20acada0aaad20de0eb2faeb413a9c8bc0162740b0a10ae10b0ea997df414e2190828411509cb070440de90ebafa1d046505c5ca4aea863160d21dd4c3ef20a9bfbe83a682a84a266d4a266efe6ea0ae2935535c3ca02c5e8fa7f5d781763817aa41c24409251f9c8025e5e13790140792f0c035029b2e1ba64837d00ebf81a480a1ca13504988d8ca4a375097df401b0808ab0d109136517f37105409e4a3041a52d6ba4a205d09e4f4d76b3c9c7b00970f7690f24215ac255c7ed774a60c3145550a2a84a14a776dcbef5a16053c1c4cb08107066b8a74d7b4fcae69fdf55ddbaa7191b528646d4aad09d5df5dabead5a07ab55d4f4aeba7abe6f4d777ede96f6d08c9e4070cc944ccdf1f72ea879cfa21793f24ef87e4fdfce8702ec79414ab16744873830b4c58fdfe410ae2861b868042450712e9fec9f2fba7eaf0640bcb0a63acae9449f78f0ebf7fa4fefafe99027fff50b569d3c6cddfedd345ea7cd4903a1f2ef2c9278b7cf2e99101a022a814091a0f7349a714325323c00040002317003028180c8a06a328c9b144f90114000e63b65260521e0824f220857110648c210a004000008000008001a588ca00984ddc1a451fbaf9cfb961c8ff7b3289e65cadbdd42222f66c6dd6ab7c1bdf1cf354aef12ef285df769b694d6dc1a333d0b5a3f8c7961c74a0d18c4e3dd24813a7e9f27ff25e9a1dd91c9326343a600a343ef5146b088a2bb11db8e2bd1fc26e9e0acd637d1d476173dfddbcad8b587b7267872f7993e8e7dacf52614b1bdeaafcd3e9be3aa9665dfd2e71d8f38ead7514b0b51baa7d7eab015f23ca901cc98c0413bace4278363584745700bc2f7ca205439e90da644d1af0b2c967765d8da3d3df290edd2f9cf2f48b3bdca118d5d6219b6ae8b4c33159f190f0ad12d23661796dbf0d3d46d64c6096ca0565c41bc82e53925b09e0195e730346a1c0642ac0762c782667a657bd58983e3a8369db82fc14df4c805591c5fbe8a63c420b9f468bce76a6f6e011d37547d5725005fadc4e0fd345637e8e0cb18c4ae6dd1061371328c52b1243f80e949c444a63ba5761a8afe2977ec36594747496e8fef731c433c3eeb1d0d4fcc9fdf6b11859b24e1a25930c61d914d4faba54e98d5ed4fa360a3d63e77d8aa7829e273a89c921b8aed9487bb9631e24bb547289d42e9521f2525d787d157d6f87f49345f26d501e97472c6e0d1eab884ca5d0a58fd4dbf8f3918233d097deff66b59aafda223d13c89e77d3a2ef63da73678d9de076508298328aa1c0f6c8bbaeae0dcca05c424cec1a375b4140a5c3e1a600280a39219be2449bdc19889004b31d38a7abb8d11953520f59b045ae700a7da6a498aed89686f7e93aead269de6e7c31b9abd054b762f40cb42cda90661a5b4a99290828a69def47260d649b6b29dd69b987a21275aada3f4c3616e554ad56832442805a962a68854d48274f4a9379ea14136e4c3e8b34d6377e003f991b3b73e4954f2920b0a5cbaf78b2852ccc7d6f7bc11981e052475c585592380b8d49ed07aad0b6b4f3aee88367545be5f15a2636cf5a225089fc7fc859ff7d41bfda5379385a2293bc6a1e9bc464b9b2a059484323829b897417ddd929969b47ad0a1ddf0339df0f15388d7c1e88a801cce4e69b09988e7b99428bbb2bc51bb64ddf4f022d57f4feb932ef720745e33c403818245b4f786ec3445ff9b020a71299336c04ddadb0b968f1081b6981a7b05a70276f8a3e2475ec520972156ecb28d02b08c266e1ea436434c9b06eb243fd122bf46219028429b3c013b9b6746ab970370f957df6fd2f64f4edc25d7a53f220339b5337a1c145c448f46f9d2f638b9a1288abfe40a3ca171740f87c1da80fc6349a5cb97f64094a383086c0dcae24701e8b0e17ccc5c07accae4233dad06aa3f31c706e046b7e50e7e9012e270c941886884026fa8dd0cb94b8dfd96a9bb854b39853bb78b30b30d209e810e5f256e703a6a041dee10f28cc625cc31ed8dc3520c2f8593c4632196fd7a2a8d9a0739414c4692c11b771f94e059c92aab39bd05bd24ec8189dccbd68b43e246ae26b2169b03bf141a60d200e280b6e6826703a008e9eddaebb7c5c3e5aa63cd390c8884e9e5f203755dec2f9bcaf695e54d5990806af7b6795acc3450fbb5534e322068ed64018e2f83ed9ef25705b193f2eb28fc91190b3c4685e17053dbe12eaaad9e4b683e9e35b32dfa544f1e87e301a1c4a6a5519be059303174506af9813a142da9596c9f9be4025a77ffb80d9de20e5db07286065345dd331684fa9dc4c352704695315322e616356d685f5aa05b043aefcd8882a949190870984a2a0ac1711d1f32bbe380a5169c09fdb553805cb7839203d0e961b5c3b6712d736b0178dc0c8fdc3604458418ef59a1495ec17edbdb0fd93e482a505b98e645884c80cfccaa2ebcc151a4a59593d76476620572e0288eda5954c755846875d40ac7c68114296488107a4231b80358a59fa70b383f0d36f684a5119885bea4c36415da8f7e8e4b551d995b449472234e3e14f58c2e75bbb060e558b7014abdce08fc5bc86dd8d83d18df260375ab882fcb42866eaec9ad651cf204ef9790048beef049781281b24a0b6aa0af03f183259e16a4ae993d60d471ad0220cf65220df03161ea5d63150ac17e5828c4130603d662d2b7bca17cfeb7cb85913df739cc507e3edafa0525d79d0c432ee0611f908d7bbc0a4774701c159ccad6177486e090f8e1c26c2432b74dd77c9109bf448dc2b1a4d2594d3f90b5260b1f31bda13e67ff72b008d1c7b5813333008eabc0ab8e65b7943d79827b130f38fa6b3560131e08352224285d60ad88cf75986348845da5b733b53b4f6b2a722259df684eb8a197029e92f568a2328bff318b4f6bac434abf55c42b357f0955d4e879607e48cb80849dc3cee84f722fe6daedbfd4cc20cbaa08904212285acc9f76b2f9955511db465e06dd0a82d9052fdd53da7c962ca46052153222a0d7e8f7a82fd0cba40458bd8105b97c4fd3bd2728d0b0797559fcbe18279dab5b9a541ae2423f23e971d0fe1d60ef654a3b512932aa0ea8e369d8240358f3d177e410c37ec8b918b4a7e97a243b382ba64e96924e571117f7458b358242b6795f0afb0fa388445fe239e16cf02d1be3e6df042448478e1bc457769af7e9705c560038c239c0132892f0e270e30408e3f8ff30388a864794d9f1d8511e9940a802a88ad15716c87d127116145711ef66089106924c820dc365d58b73e8832248a65ade3ea71a224bf922885053a7b8371eee4c3988b55d516e545bc6e16468f800f27808423fd5291b48db1ea191a76afe23448a6af1277c06994c93b41354182680169c2843ab568f9ce0718fe09d05f3aa1f9b51aeb41cfa0c61be9935ed6841a1da7d44b15439934f91c5c412857b17b4fa0c89dd026c15ae385ea91c9a906505e3acc355dda2e9ea456de8a793d5f3299d80a9230f0ce2c4874d849c8041603445b9e26aed63592e7b51d4bdd4c88c9c39a7cdf40ac46fd4b48daba5523e440b8a4a44147ebe6666fb573dbf1b2359bcc94fbb656bdd1871efcf0d343a5a1cb3f4c545905919fb0e9da13a75a97a7cbe996b30fe5562190c095150871da3088bdfb3b235daf2378c3f1a6df731d7fc8875257a1b79fda8859abab929b323932b3e8059187c810170466ec1a012018f5c16fff5837e1e203cb1a110f85a23d09b23acc203f0818b7cb9b082fa1bd61446f68b5e03d58a54e2bd96a32437b3e817b459c661966891ada83fc2aac6da067c268ad1b58a88c1fa290553f059d3c30638956901de9d54485f5269b10befd432eec6d1a1ab0cc8a15b2453f2562c781526acde7801927b34893f06373533b7d45e6b48c4ba67d09900efee3e23162e238ac260bae8ef40a22b255264c0c3f21ede8b771d884692692e93f0ef41656946de9c9c48df1125a902fedfe302622fdfd23eed8633a1ab3c00a2b65b20fc67d2b913327b3a62b8912564d3781ccfc83713331dd27e782955322330f1ffb9859f8806e76ddde7021ad993051d9d6bd4eec18a7b4644e566a86d4d83864c2c426920dcd9c8895879b326902b2a14d5362e25053a64c2083ffb9b8d56f80b492721ce0ca09e3b13a3efedb415726ac3181ccff810dd5bb28d7e79890af32c6245a2eb3e2976034bd4e6f084d2f5aa0fd257493ff6cedd36c84b4087cd42bdbc44ba029a51dca82990a4767203b454a90ebefba85dbba68e356900edff736e47094354ea2855b898c9edc0ecc225bbb48fd7ee7896122cca36eb0bf3d850d82dae5665cfa9314c8b435b858f38556080139d75cf5da329d6345f4f12ae567c09dfa7213c130a08a4e90d4aa3b149384fed197e3e9477129567cc28f4a3847701d85cefb443f7718209ef39de54064c203cc2e07a9e31d01a934a57080af926fee6e5d37fe1ea521f6c674e5c8b44ed060246968eec115a0bb88e0098dd38be8e0d2a7832ba10eae4b325cf893e13232ffb06dae919aa1bae8d0d1f0b221c40a6ee862a2cb5e4d0714bcfb4a90fa3f3be27e64e92fdd64562c1caf3a87e0e96db1888000949f57014c69543bc7f05861d99cfe52db502d7b1af734c23b289c6182b2422d007b8195c932001c6c3fef3b1b3864f2067bf37cf8579a0c28466851c129e684437b6a7ef03cf06843c5d3cd0fe73ce5b215f54e373ffcb424e03654e12654f6e8fc1f49d92fa264323626bcfaae27342a64a33d4f09e32ed5a62cc85f0aa4c846381b297093222f4d1220fb4f64465e0ca7dcac093f3eaed7c36a7d09d4cc832dc5c15084cae1b96644ed951f18fb6d95930056e34cf3a2ca5b6ed0f6809c9da8b29517da5f008e020bb6ccd9799773b5999cd49eb715def6ec2eac642b4adc5eb185e9adf196977edbbd1331e867a8ce6dcc46cbd39d08edf85e80a3a967fb6a701457642b3b6f5be1855987f1396e9991d913a99868f6a55c23cb36fa9191101754a98a8e72a9f9e4a4cab429fd3a2771ec26d668590e339a39c94d7c687f245174db142e813901572587117075de0f83632315b37d0bf7dd455e649e9be53cf49c7cbecd459dc72821124a79601cc008aab5fec97a88375dfb7681a5aa4fb89d8bc40096e803c76a7ed9b7662c06a3f1327fd75d9dbf0a4f79729b0362ceca7466814a4fe0a9484d16b1b6acfa8cb5ace96f5aaa7f7cca31322ead83cfec42ce1205249bb845c14f9e1b7208f9c389a323aa820a8fe11c95a6a7d5bb5d4e35a7b190a4893578512ea3bed8484ba220a610d20c59aa5dd4c2b01dc5933a08e4bd6993e19922d8c509293b355736992042b58528d3280039fc0c3069eca6881234248338b9553a350df75c7f3956501c5cc0dca0c3f662ca6d9e0cce59f58b491c1aa71572702580c50698b7895da5a3e135e2d7a423024aaf7ca9fa1490b24cddc0e507b86167f263e5cf811e1b086eee70a1da8813507b5a0842b5e38a8fce326bd784108ed6a15f8eb5454850ee1d5a255d5cefb00b5e7a72234919859216dcbf7764b37cf55a32db7f6a6231a9b4c02b7d9478d263aa4ddbec17be80ae16f8bebf5f897e9658d4d7debff96542c658de7725754c5823eb134829f9c0da5cbb9d2c2f7d5f80e06ea244ccb5a3bb789963589fa5bc947dea01e293b509473be1dfe3cd60277f28ed50a59ba77c0c297a28d9e84629d64c80e9b7cd8dac03b02ac31f44477532884c09b00be7de1b71ac0d2c33c2461bcfa848d4983c833663d383393c590b80e9c8d9a95853ab5783c55c9c8c4afafba0347a7d192498e7b38829ddf3b8af967fee0023afbed51f7a5c73008cb8185dd3351a53b62bbd62fc74b02948005829938a905225c98302e795aefd0c2160bd7d113181824a3b8bb4ca79a17108c11faf4be4bcc4963b6b280f107787126fe5ce523a487019daceda0ac19d0a6a982247e0668f07955033fd80f668381a07443e6d854dc63156722aa9d71c9a90824dad985af379e78812b7e0451f161351403e74ad4bf00067c7cb433478e438e06779f3d7a1e4a8d69c1c63c0590bf4ca3e18b9841e8ae086ba00822f9478139895d6ed92e9e2a905b7d2daad989f46def36eeb5a37e2eec5899755eed980d75a2fbf5a1ec6e20b64fffe8681d999cda81e790dd0650bbaebe074bb9e78dd9ed1d4f7ed8e078e4ea2cf3f5cb501ee9b49cce98601063ceab24b4883d670fd72f301ba80ed73332f0edfd2390ff702226192f95a702cd767276ff17a11b87a79bfc81bfca5d02bfbb893eac560d4150bd82989659a32737d06256323d8e61020adc76a3a741101b506a1d501416d1a4abc7b9108bafc12b004f93da056573d9993f7a2822cefcd1034608d60f3be8d22a0a6311121eea938d6e8eda267294070b23e8f64994aafb95edd4708936005ebf2ba4282e2060176d1be11558a6664ac90e4eb923ebd25aee87d0cc9f3a83ff73d935c7e72bb8e794e6025fd5bb33fbcb32b8934164120c8fcb28307face6c2afbdf80ac6a06f640a816ca84a31380a3b138f96debb920689701f19327ae48be359c9b27963eb0f45687fa95f7d888beb4836607bf022c9a71b9d649079a271dd7226be9762643c9730b0cbd1b6d041baa65a447f231f84432ae121000326a32e488a01ce3d051f2d4e8b23e53eb0b4d5cb81712760de61828c35058b8c9ae89eaa85f8293eed0b70104e3e9f0997e4e879232bd392902816b792bf96264f442cf5825da4a24d6cce9a453c8e5188fbf0d508c5d468874c374f7050d8e58726810c81f1ed0062d303d0bc289b5ae7986409d6c586e9331021e874e0afb0e915ab0c8403b0c9e022dd6e974b7b61a60933e2b0c859df4bd48e0839288408cd1e1276550810871c30bd053b50153ff758d83967fd7c1779b9bf0b829c30c98d5c71df838891845b1f4256bc45c2268a33e40408df62df428d7800e4dd0bb0ebe1bdb84c7471986c0549cc2c0e7580fa422decd6a2ff549fb350766b16e063da049a96209dec7134ac46add0c501a430358fbcc7ba82496ad61553a5c3639bc3560d734fb13f0eba8a6f1159dad44f5ecbc6e0501422e8c18c223d80514bdf5e29b1734313cbff05a0820bf9bd124602d479094885b834e18772341028abb2d6616a820739c1305d59fc53323b73b7b3887b2da9def9060bde6570e7f40564ff7e598516f3cd75557c0736d25924e958430a0519a643a183d598fa7c50ae46fa34989ea6fc4fd0b0e5e022ea0b7a585b93f871fe91f0181aa7b8dfdf48a7e78dad35508581b5f75b7bf79898aef7b8724b53680afdbcfa692b72daeb800667fdf778c3232151a33c7dceba9e904e33642b15026e027593b26de1663fd3134c53efd07a705a2a277b6d65845bc8df1b1b0c754631ecc3dc1f622c1f19608e17727da8ed45c7ad38259694776dd713bef6ae7fb8296455859cbd49fe76b64e62ecb46dc35b2015882b80bf432c04c5e97ec9183d0e94053ec7ec53a24c887bbf63b4a30f3ac740cca4f0c4edccf83663764d3dde5118177fdccb8fa922b500b99e0dde9e98efb900cf727b1b715094475dd1506f070f3ccbd5330c7839d0bc2b1355c6351ed1a4b80b8b4fd662f1abe4677a0d39a82504afd79087554074b98613db55a5161c4825d19e5a173b9486a4fe9722201f8ac91b2deb558a83d1560740d10cb71fe45cbb125f1536f657daab26c995ac93ecd5623d0c49c6c29417475c8b7d7da8a49de1ef82e5c50aa85e92e9fa25bd3b59490ec1f182f90220e6c9d3dda03e676f26ef384c027078964f11b3acb9edf188734ab8cdc889bf71abc4041a7fc64e733951f06b49b551777b7f481df974784aced2540054d8bc14ddd38b8a593657a1390701e14b6178848346e0d2431e3b9f0b83b51e02d49bb82aa8d0907e71362838655a8d1c0b798a4fd0858ed8623f4cc7847f758be0bd1a894b489a54176f34af19786657be77fde0a0f66e970f0ab6c323ed33b9a2bd58d8768f535aa686c97b5bd12db1acc955066e47cdbb8b0ee0ffc4b78cf4e1104824ce3ededa5e168f6f0275c41120fe2aa41c4d56795225e82e18437c9f2464bafda3a7acf8825ee5eaf8346b494ff932c0dbfa1873afcaaf0be3f2d304ae5ac84ac7fda4baf5d3cdd94c9fcec4ea83d1ad99600b89ba928719117223081699196c1f058f0e2f458a9bdc172edcc8d6d833ebc5cf929a0ed3937dab80888a2e19ad5d2c6dfac4d842a8fb5515d4e7e278ea572729b1d75d2b8cbe65bd5d20ca72c5e70116d4a919b0c42458a8d1c5c0db95c7147343cd1ce75ae1cf0ddda17484995281ef575a06558fcbcd8f8955b78cedf8f3ad053482da3ca8a8c4268c6388b257d160cad4bb8634a3be743f3403e6b797014b9327ccc02d405f9a2472dc05830a1471a264ea008c968296e2da4bc80fc303462614614dcfcbcd71ac0a1af1cfc79bc233a4ae3c15691501abdc18440c409000d811e89caaf57c4734b1cda101535ae6a08390cc2aa778a44403e75b276fba8b20949531fa481ff8a7176f0e4a8b527acebd2ebc2af8a935aeab85e3b27cbb2643d4aa8d5cf052add460e5d0d50248abd0a309f0bdf883f843ef7e7219a968e64f9d6f7b8cf3334acd044c63a5316e1d0ea89e1ea13c6c0faaefe7c03c4853750c8bf591e6448a6a3dd0734e7ea2652b0b321d516cc98fe5a042bf754a5d6ed54e28ef1de1e6588cc280b1760dfa4b92d322d025f4c6c0f7a1800b8c9a31a8dbf9dc732d59a5caedf273963ca7f5b83ed9bbc38fff45702159e04ad5a41d9980b3d6cfa40f4e6e73096b17843d47887dfdfa867cc0899b16f57b5dc173d407072095ba490be9601d19560e025affd6c3fd7c72b888ae28a0ec089ea787cf622e4038bfc30c9e3b14430b77d3f9e2e9955c9fc53bec34e6b2a7fd9b6ec69a7437cbd112e3a8c52e5115aa5dfe206b53b0407521bc8c62b86fca04e4960f144d7f2f24972c019d6a001e8f5f0884b4f3ea124aab54cbdc12d6d0e7fbe953293a6c1359f3d2593f794c3a2898ed250cacea02ec41ecf08312b999794fafba93070a0883a7b1524cc59fba3bb85a02942bd2e0d4160f1686b98815f8b96ffccd2b406f581661b70e921a0a2ac80c15ff39c9f133aa0204cec49142024cb765397103bf1f92989af2d67116e133ea8a8e86bd323b5c256584661fe1f366d40e3aa20be536254ce39ae4e65f812459779a91ea84a1dc9f0d58533d205820462ad75f484d43151de8b765bb8fb060fd183739f834c8aa4387e483075a3c89f4d8fce0e7a163d0f7bcc9b276611b57122ade7f5a03916a861be49a04068093a094e11deeb2fa00b21795218eb897cf0e59b555f738c92299d7146995ea78b274a69353f632d5c31c39e4cdbdf79a91761bdf08305938617d5efc49f755aa0e6b5c6bf3223c9f9058b33fdf2a88479e96428419e484bfd46a8a741f31cfc7d4d521c11a9a1c680b1bff22b306173095c6d3224274dd22db0e4fd467f9990fff220b758e21b4f406f9acb6eac1c993250de2d35cda3156d71ebb25ef04476e3e0cbea9882590744c3be8cca0ba5146fbe7f3dcef9d7a74ecb14884158704ed2aeff71871939e9874a5c6606af1f80cf558c1857dc4855de7460d4511126c922215c3e742340b31d1b5c3b75c848a71d71e6f411274e3b1e0bbc306801ccafa0c24e30aeeff05bbf99de67a47cb6f9dd2a471819902dbbe4e13f2b700ec818e7d5cfdfb759c0909b0ffb1105e3475cc00d382ed67a2a9321e5eda935e9960ccbc2da161f65fcc009e8efd76dda3fb759ce9ca624b9a51bc1d25470eaec57cd68bdc9e40406221871d87eefc7e074c5b064de1f97a7f874603671b74156e2e9e2b8416234bfabb8b9b1498df26dda1995549ecaa2d6b47e406daf69f5c8824bd11d2bb6581f3f7012b74ee68ea0624c3ef044597e1bbc7bfd047c087376b1bb49a575e6b4ed52531f1ef9d8671e77c8c6f500a0365ddf2ec8f8e58d0177d8d8a52832298678e6f27781d35a3c4fd4c87eb124863e8f644a01a630ffcd5c45a137d57a14fe3a1e2f87d2f10cec055a5753c351b3355520821ae8e90144e65b3d4410b5046da3d54800aed416770de131bea0df5d0e6fa1abac86944d5bcef9a9061f5dc82757e998fdefb399ec5584834dfc4ba4f47db06991bd1c7ea8452443fbd12c9c65979f66093a5ccbe708e1a5498a1722619a93cca0004c355b70edb15d1f5b3a601aa6b8d647cdb147a034da108e24448ff708a5d34b979327258edeeadead7b2edc619199863ed14db7b5b4a7a54adb74f45a1988762a2e1098d81277134d7bae71e526b5473ed7a8729ddb5d0ea3d3a20a57b13c4825aa64ca96e0909c2384d7b0f30fb3de700afb1887675accb6e401711fba90632520fb680e5f28c518b2784dda01017dc01475a245e3560d324047758ea20dadcbe1fa590b641d3051697069985b00ac1cf8a5c1ff7ac920093ab8606e52264cbf63d7e8c034e32699455cf8d1a2ba5a7f80f77c3795940d8de31759c66af7c333103b7fce6182eabd3fe7f051c0a515c513bc87a5ab8b292a6d7b350eabaae8b4584e6d1dc67d85f9bc0c6e912f69209ecf93291272b659e2069d0354c36d4b744bf9d744e05aa98d94d40ef903cf4a33e4751b66cc238a9fba76e1bf2b136819a3be28e6fc16d8293d73b75ddc691a393f7793154d550d2ef70c8c99cf9de43c1fb58b1770835e819d8c590f9c34995e818d4734319dee4a18cbc9a4372002663e275d4283733c6ad80f69361f768fbd9cd1805e454074d487ebd9e398116f14f22810f94f826c01b903e9b463ae9d050e2a6cc801c4ef9e3d7afa8d174f172e44914d8208699d85f0fd77efdf3d7b849e922f52f24d5238bfa59e9be8e411b3cd0ed770f34fa8ee9d7e318632d1761fc03287710e6f86415989ed8e6857b82f81597b2917434d1a72f0423ce20afd758085b152d02e07aba0998e7c9a75993e3701319e70ba52ee49d07e65bb3491c9eb96cd1247779441ad1284a30be8b7a162188d97628898a318ad09485f419f44a2119d7aa6bb5c63b4885cfc65dc284474847c8954964f07f8db960545d6ed93fe8aa96dec8cdbb208c8963dce210dffa58f45a63923feef227c4f48659b27a2452ca04573f369efc7cfaa39e90f7bbc926617be5839d9aec0b85b0765f527ffa39deb652860e5a4a53ab64d6cee1dfd345a0cf0f7f7a54a120d6e3278d78ee1145c456ec76d58f454525baea32bcf14952008939d338160179510ef2ed0324525a2470f499733857cbb5132c3bede02842e5b5347186e8f5b13c3aee74af83818643eb4c23e7f10ee10696b90a07df12444af27d75765c52dfe9211869af2c1dbf0ad9bd768a31c9c3fcdbcc3c39d54a0b24408969c8ba15bc31398af27180bfdd0e47009e8a1a553623bf67d2f281a428e1ee9a70fbb98cbf234b4a0814be188d57bdf432380d3a6a6b1a800cda084184ef999d3843bd8fe96f4ccd7042670597696c382cdffff90137bd36d7bf6cef744ac335c5dd75ccc5250a954a1b600200a758f655bcfca7ca6a2448c340b242dddfbcc5b02ac6c7b62280067d49712319607c255c78b4466610e790eea16ebaf9765fa21c5a198e64260112c05ba9382fcb9573bf730504a0b59cc16f914fb8c640d9009bc94dd1128b260184970ad6d20af4476c883a557250abef836ea1a5820ff10456a84b29c24ca66aecb31dabc89b2d98c4dd50cc571101795fbe9677c2eadbe349b1fd22ad5ba6e6490e96934886376c79567291ccc13c10020c25811ea15691655a0417566a5c163dc6c60336e6cb08ca53e903ee50bf82edd7d5508169b2cc2fb2d9e9e79504455bce4ffa821b3bfa8c1f31faba1f9dfc81875f7b2f2f97fee01ef3f56f6e85c3cb428310494dea4454f03a1f182da2387a597878ae59f070b0b640f124be61e2d7b6459dac9288f438ab90b7f22cd750f74209e10d773bc2495909d36a13d4d4b6a3d5f96f83d9096a87b722d757b542efdf670a1aacfbc40b7f724b207ed9b0edaece34e7d1c4d651552af72881d9803e3f30b266654b461d6259f36125db2a50da697d4b561f8259f3652a5b6db06d3efbd6d24452f97b4ff27e13243ef683da48c43c1cc9b64b5a176d97da9fb86f02816b329924411489c501812d3a8ad606d0146113ecb42bc8b919cbaddae0c66948909a629a246d0683b65dda31d4605f79413619c505c757c809ac4c98c7780d25b9b032f0e313789efa0a4d4e017b329524018d15b9be4dedc4edbd35e8e6568bd34cb99bd4dcbcabd3f9699bd302e137b732c37f56a2c7ff6722c43eea558ceecede84e60ef233ae2c732a8f6c9f92658b9894c8f9099a9b60eeeb0c336dc80f19d7d5f01ff46d5f07393d53373b7ab2b717fa933e5865227e6ce566fcaad56ffc4cdaa0e999ba49e39775b5d99fb4b9d393794c7666ece708a19db4b663659197d7765ccb0571031c520420edda58622d7dec7e859ee4324e8dd874dd0741f3a41cb3edc04cdfb3009baefc32668dd8749d07a1f2641eb3ecc04adfb30095aedc32468dd8771da6509320ea2b50a79f4e6ce337e5499f81713949d4e2aa5969b2ed1e457350cb309e37bf76a8b26acd7e08d4250436914111a5a5020d44082e252c352148e1a84a2286888124553031214c41aaea258d4e08242b0861214911a5aa240d440f2e4510d5ae2ee01b89ff6b6d23e1967470a5b710389bd8a5da7bd22d105c84b6852c3703faab5d09075c08e60a65707108e6cf751226990044e47cae72df795af1f7e3ea1c14bb32978fb2d28a18b0c6a47d24407e86db92a3f3655e1bd88594e436c355481d09f19fba94f2da6039ececa6a2ba1db369304359350a72516ec7cecded51b1f4064ba791aa75bffc0da11fee13708c8b8fe9057483cee7b22cba86e228915ebb46bd2143a590672c82bf340cb89463f793628d9af50fcb3ccf3a6f0b8bada356f807fbe0afeba3c173428774d5b014a5a52d0ba091adaf7b38b308133229f6ab544fb40af14949c3dba11da660d92e10782c84df32ecab758743b1629114645abbf4998a1d0126ffcc3a1d0a04dc094fc10e31d7d7de0fc53c855d810ac644a513cfedad39bb61fa8218009f4549a1f1920122cb3b891ded681030a6e5060c54291c8a20af0068ff9f402097710e4155177efdb30b243496212cd5878d58650fef871238488f6cbdd69070db7f4f8a6dfe1baeea6ecd48060088d15101c0f9d5c2b175389f6f2d540243d884f0d4c47e0373273a72034ec36ae693fb5837a6a3bc959b85c6f026966187a10da300f610d99c0c3e17fb340959320be4a683ed3b530f8496ba55a0a18c527dbd8f347bb0e23647156a450f3431d6b8d4bde9ad9c55d0004012cc62418eb10e39509e6f77f6afa0c86d96fa2c3c27523d82fc5c040b2cf6a34bc06d9c26513a23dd1771a42dacab4a0c038d99f61c00b575eaa0ec8dbe42a773942d82a923816423a58af41b65d0d9528b05dd75c7540561e1611825c33ea0179594483e07d108218e109a7d31460277728bfb887a89155ea5ab6e5ba8f8a83c5a70a6d376ef4bb60dbe55bd971c4df31b61d48189dfdcb5870631e3257e67b5248517ace70b1e4b42253518224f0a8558b7719c4c91b9f837b10637c4cae21c6f8807fee5fb803fa7bfffed9aff4fb7dfddd5fe8f75efcbfdff41f066e8a505cb01b44e6242e3fd2aa67ce67fb8262fc0fd4ca1be1a153cc366ad50a9a5bf58296ab5ed0ecaaf7bfbdeaf5632ad5c303e73572c07558b9880016a73859ad0daa24dc943d1d3b0730078a86e85d311e69d769b1a321ed96873ac9775ba1240f040c27744670d94e8209d3049053f4c9a2850a4137916854b56a84aca506bca0d115e44185048d4dfb3b3d445ff8ba469a36cdbea834cb51a259105e39b72c1132aa7dcc519557243af3b5427e3df49070421cc0fb86d0a65a0059a4a4bfb360f8f49aea084dd5ca39254d8d255aa69a030bf3321dc609fb0966247802d67e10b5461567ff8980bfc97c831d6aad5181183f71c0ed3381b7e2d0b461b383b07dba7e8d2bc92670f843ef8d20f3bd74163e3aebd215d8c890036988238459bfc3263b6c3b889aac2a461f0b643f3cdbb402773be3f5a879120d2393a1c06c8b5a8ff8884d14206f8bb414c7f7bb5b3cf29f8472ec94409bb3e3083f64efc0f9e6d220114a6a02770391b31b86f320afa6d3d819bc6660a35281fc9d170d061a10796ad6000a8c8963684011c2a4395464856a656eef0193c3b662709eeed769bd3e60741b0ec67a837b4feb9f8017f097510e63f42b76fb0a96e306affe1b5299b0e38f9683ff51bd6f4144f551c2889b1838dc22db9a3b1a742e75ee1500231fd565b5adb1efc7afc6600cabdf84713377be876af28f2ccdf3cc6ef971b3ad034709c6ff8b30f1ff76bfc6b81541088d6f53d1f24d25a98f339704038d51be8c4e0ec2745057192a9c444530b38ba8d57ce150d15774a8c0654cf19debe0aaa829a6a8427bbea12b4f1a25b2c63a94b5fe5c9429ec51a617e22b3c2305c05f5104ad034746582c42dccdd1ac5d6ce523a2b383d4e98a83ec19aecd590f1c6097064cf7f0a8bf08d1f78e55b0fa5250c99ea43407d706431cb42248e4122686fc1f674860fd0765139f1526f451b415653c9dc1d2cd5f9fabb4bf2a0d44aea6bf4efd13f89726d653f60e3bfde2c92a1b871196f7f997e85a93fe8ec948d494be0597f2c6a873f780c8ef3c8238380acb747b462003e6463410a1fca9ca27503af986504a7365ea451c3588a5f7fa23c4199a0b1e6661587d821320eb323998176026156a3a0dd04495acf90425724b9c67f441b9413a1b02d145921929d5054711fe604cca4fa26084ead2912aecc4c16a261fabad8747859d19451036ae8d8be5fa1f479d40051d1144f6be80826c7846648a34df0af6f61674cb0d56adce67d8eff71f9ffa18e951bbdf9dfe66d671a0aec902c08e8fe2297c8edf6b823ef1010f7f71a44f2318612539b58ac033df658c0fc3b2747cac106a417305a37baff069cafe733c1a19067707713a6d543abadbed259b5f74247702e053801dca07add35e77ed4f4491c5624ad0abdc05c4d8641e84ef293327c875ab65653d8c81443a571f8e5f74e5a2f240996c441eb6567d64349392e7bfd5e513453d76eee12ea57dda92c2bb35c99f8f44a18ffe04e5aa8be4fa10d8558738bfb1ad28bc5c357cedb7e067861f186dbbb3a245960965927901f5c23f9004a2e27005ecb7c3b9352d4cb0c0b4d2d630d8e32371a64377dbd2af7900d45ecc30950e2643c76ccdb546daec8e6223e2bc9bf8b5425b0a2d24ad75e055472234cb101a81e7180dead1278b1e09abf3c7355aa4d5c0d16e97e81a711646c6975c6c3efbe6e8687a5a20304037f3e9cebda2d2978bd3028f7bcaa1d09e3889a49472e7655bd50428c67731fd43fc2443e0fe4063a48b880b9b75015dc58455fbeb2f81ba2923730cea811425dbd4dff6cb20e76c33e8e4f528506721fffde6ba9dad16a32d3949b4ef1930f8bedc94df49b7c002e4285cc5c8124656ef9021ebe6b9018aa1a7481daef874c19e7d710e52d1640a4809b3490562c75feba6ead42d17c6d2e1fef5aaff8b7d012ca1aa424838d4280e5052d2ff93cc1a20b2394cc889305e324ce2b5c643a06051cc679cbfd0811e503197350f38ded07eadd56cbcc0f9d222a21f14be5741b8ec479bd388ccc517c4d42908d3c398cf37b2ac243a6c78ade57ea7730c51b30273e2e5e637363ec74567635c6056609a3c6b59eecbede479deecd0b2a7a4655f73e3569f2ed324eba9e1ff1520a2b4905af6c0af514daab6ac69232e5637be5091385079cdc2248c063ca1b985149239f1433b06081381f11b81b3a968d90775d6f3e55442a4b8f3f3184fd181e4e6762f0afde111dd22080814703b1e8886fffda8de78dbd5eeba706bb1ed45803c233e05121f04a613dcac7ba7ee2b34ac59a2ca9f439ff06f7fd158f84f8d508a3d4aaca7505c7bd07b54ecaee5bc708619bfaa0ed09709df31c6c4f21310f11bdb3f2bb89df2ba91ee7f7d425116290b19ef5cc3cdf56404b46951c0c8874c678b38986c88b2fb6b2973c13a57269323f5ec79f876612d4b58fb91c44586ac06cedbf7ae14b67fb009cdb3c5318fb90adfbd6c6c48765b0b774cb05656b1ec65762fb6d728b2aad69ad00bc8a0f692348357eb87530467343bffeb1284262a3fb3dff9a8b075fada0b76e05065b0307f14a765f79af62ea7ddb916e23d76c7dee007dca04eb8d8187516c2ffe7f505d3f5abefb8b68c124288937dadb9930f77d395be797c2a4a7e60ab9aced9cc3d4976c77f1682e847b27571f284d8f3a514482b3f37b000b07950c45955f900f31d95c937b99bab8ca47d1e7c83b0bc459f11a19f74fe2c695e72bc8ea395cedac4b38abd2ff977eaf906c0c43eeae22a93032a7870d01e19bfafae85ffa9a0f3e069bc0374bbbe968176173b38e4c5383a35d80e4e863500e21905f53875dd4d78a0a5167e30fe1b87d34b058bcc55e4e22c83fe4f84cac685c81efa79ecae4a310b5946793fd85ad07c983daf78b0522b20105b88e251a85dc8a7348328f4ee44775e3e901eba5928c2e4a900c02be691f12fc17f014a3020f68370e63c242f120f822210281406693e1e897e47446785755bc4c3899b5f5220fb96a21742b45ff1c207c99369b21494b365a757307b070a11cbf3123ecb1bbb242996e907319e05e397b96caa6efbb7658ba41e4135c5f9962f7e0422be3ebe65e6d6cf69234bc15fa008f0780137fab22d3b01f08091f96e154e218c8c7c25fecf1851bcaa7a87a93572ee23fd5c07eb0bee3eb4243ec8d5d3fcfa0ac38931664682b7506be24d5f7927abb13d5220ada0198536889fa4369e97f1b60dea267dc127b17238b89b29de63cf74d19bdeab661fc9728796dd58b981f0f37a98124019be0afeea881ce2a58da5780f662531b30dd0e44035eff384e77c3c53d7204712b82224b5cd96cd69c6e05b61f8a8421f006741af436c36b573e0c32d62067db26a0edbd89616698bd4a2d7a8626f15dc670aaf110701e6f24d03d90aac01b7ee0ce42f957f7fc73b9c40d290d5dc885a1e1b911b9211398e8be81a3454f1994a26a89ea276f884bba7e8290b0bdf5ceff1eb39e70b749210340053aed762ececa2763938c8e3e1624aa79e9a388a5078631b4bf7b1d71b7ff492b03879d24f7d4efe48aced9423421656f270c5dc9b4587fce4a1197487ab5b92b7eb079cdbde043c6b60ce5c3480b4168ea0b335c2e32aebd5c4adfa95ccdb8796f854e097f0abeb4cd2a85d0be6ce5463bb14de77c2eb2d30cc17ea507d6a066e8727d2133c62a286376bbfeb5be8f6d4fe8adc44371685ebf9d843edde3cadb992ad9eae20272ec18fff90f44a602c13a64218756e0affc3ec8919d70f11b86eecadd3e481b5334de453a4ed9ba318a7df66a3366e18e16ffc6386452e0f1cfbe6f61e41b5b6423fb1cd40ae5a884dd68c2e396fc5041cc957f4827e8b796268b7c97c25f80ba7c6f8eb8906c240a52162402c6669a62f6953c77525d241e13a0cfc42e8e9107cddd492b08a452e9845a16eaaa942df3428150915e8e62a0dca2a6af6b7cb3cf2fee2a267cb831de31f1357f1ca9263a3cd0c05c87264e20f192dd59412abdff08bd5bfe8dad4ab0674a81cb631a1a202309ffcee12bd58ed3ab9c01585c3b20eb9aed7ebebae70c6326ed8eb19c1b05d48de221504784f30282bfb3a52e7d0c0ca25601abf79eabe090855f26880bc8b7f1d77c6514ac1f09ab2d29321de96c570d726f6467cde180f895ec3c2fbeae36680c66c08d053d7816d484578de03d64c22457b53b8cfbfa40fab9ad1cfd93a8343d7db99529b5cece2e0853bc7f0c20f348797e8f3bb208f2949e64bd788c9626880e8de2e21d092e906cf31e2bf756d33f27d8cbbf2a0a06916ccac5118b3cf9a15dc265f61f874637a17b3f026abb91651d02e2f74be731cc86d4d32e174bf2bbd84c31a6ae5d3f7e9a129d24422e2b61611f852a505706abe7f21893fd5bfb0c0f606260a06871796246bff54b9b1fb4bf57cfc8cd6d72ff3bf9b31471c84c1a51be4774e5c0a17911e8c35a3f4d281a061e94bb5a75df2b9e1f0f21b6bcb0b38a37a3ef32e549b74181e32230c950bb842061fcd8f6ece4b4178ff27b8b8c17da1eb987ac6c1ac84bb41afa445190652c6d8e21457b8677813399d59d40c9d5e4038edd0eb97992cfd3607ec75d1b5b2ff97ae76d93a041a598b9b42ae5e2a840a72058ab80e854af4e2ecdda6387520473db9c345ba22eaa93d33d6991ffbfc996ee939d17cde47d2d4b73b4d10ad6dc0762b0b626a8a411358f362e89a942c7a8b466cc21770b5061bcf26faa3811df30592b8194850377900d4da4dba5196c6eccab2cb091bf4551eca27df5afccb0a955b5f43ae71df731ec3b02c93ab27a000c7304cb3011bdf2db43bf375f1910d58b6c44e270423b5e480160b8301e05b28c0e2404d403636e0114aef7181ca5dbf17a0e274f34609e59fb6b023a50b969862209d4a0e0d1021305ecb60a13fbb58ce2f81306dd7ab2181409975458129d875694ae7a13c1a35495fc76647f80b310acbb78c4ede3c2812947472f011606919b6ba04dec376b3e734a07b506804377c7ea4f6120c7d851690fbd561c01ae76b8b79e1935c122910b263ec61be06c75bc2c7f611ec1508971615c22641ef0e0e3ae003ddd25a4ccfed87b82815fae19da3573c813479c6997212fe2b215be94be2921a73dec66bb97f25b92510bffa04c25a85bae883704c91cbc82ab3fccda12732d94a36b29823ca4746affa834bc7be26afc809abeb9269b5493fa9e9fd27794d1711a85adc3a93871591dac2ce4cc39a8332dab7290bd7423cbb63678dcf2dd2ecc72f243ec9489834080d2c2ee06f4ea5c20d69b9afee922fe2ef3e4c99e80fa54785d4d32990bee9051f460fe02dda20af7b70bfca7a1e3c1b5c42d2e509961a102745eacb08e8b3019e79dcc019444bd2042d4cef10f1bbc665ee2164051a4adf0d4a278b97dc50d69d387b4fe0a015a2d8d3b95492bbf54b10400af950c9cc5b7910ebaad51e09a0129f5183660db0f579242e6ab4d0e70e98d0590b427ba1969f05e949c2d28061351bf832e63c134bd2945dadf3e36823faa5f19bcce6b8ddb8af81b643b892594f0a4c35ed9b77383083ee8e06ad155ff61359a939f6dc39ad6af842b56b4304c562089a1e5f2b32d21a8a6cbe96cab661da67ce0baed4719fec895af4179814f0741b893bfdc21d275a4ed8a4d0af98d641ff746396e0d669c92fa6ec5094db8a3b10ac697fe3ab8aac1d4318cfa36a0f56e91f6de0579aee033f77e9a757d7284368ce5e8b374a08540c8bfa08d55ca6fa036d8c30ff3d6d8dda98c2b4e9742c68f1ef89c5935b0b930791aa39bc756cb2139b6114d856d9ac9cfa940abbd0abf6d959b56c169cd211c2b1cc72a89f43fb52b0e728ccb64d4b6b4f42e9d600dc0f8542ec300258f2275afd6c32860ea73f82f1d77504183906a9801372d70f56fc6700295b99a83e4cbfa524045a33896df7015237377d9748a0341e5a5faecbdd0d9f902f429913836eddcbeb276ebebbb1d2223beba63e69fe30298f387d87e1f04755200ac8cbc93529bef2bd80962a25ae865e4bafa033bf29b0924957812c228984c2738812d203f65af8ce20c281e940e9c9f0c6b99c4906ff397173ea1f815790e3a55088e78d3fd82f3f7638e30cde40384373c1e02477d9579bd6de1993560dae29e0b12e0624d3639217ed873c6926b3460688d428fad0aeb687db9fcc3b36af336f75806f920060b7c3c01ed9e76b43a67d31330f578187e684b9a7cb0773178070528f9e1be1f3c36a96f3812050cf491a1e414efda1f46dd1c4da13b7dc1614a627d27366d30dfc5e01a52f3212eb208398396a4818d774364bb814be91fd7e27f36f2ed61cbb6f81bae58dfe61a7b19a29978c79f9f1fa23c3da26a9124c81bd8a6e7ee09a5e1f4e6056c1ff6bb2a9131d0e2e5edf6034a59d4dc23beb14d673b55ce77618ad1e91b88a8ce0955291f773ee8be47fca68f44c64612a62db627296d50f74445b47222151142e0235701d166872d863298bad5d9a9bba068a030bedc470fb834cedff4dcca543f36e84515722dd1cdaec754a591e2b2ffe70c334d0c4e12e10f0fe9fbae674b9e743ed0f59d674a45b17c44de1149d4a0078062924580ef266394d70d4f5d436248bd5c5c9156342b9fdf0496988349aea451d356ecc639f8f2322aa0c354933e1aace38c4602b6419d424e27e873cd401f4d74bce890a33e6b831260c899a1be34f709f43f68d58796b80e3fc8d3970d8a29ea3d70353f550561faa2a76315adf09ee7f9414669e1ac9f87261dfdaa4b5ceaef76f9d34f9264711033aaec27ac1e5998e95ba38da9be1f83736f0b9057d0f6477ffff38ab0b9daee2b907688bf35681ab33372cd4431464f335ffd6039d1582957816b91348c0a66623b9422795d797eb7a087edce1b35e0debaa8ab2d53665c8e43880bf0fdeb1a0b38273e5bdfb6c16d52ebcf28db601d146b4bbee54857bec63d10fc2bcb486e7694eeacca8d91307cfbec3935d2d762316c5616d02c1f91553520266aa56949ce2487dd2617ac020d83e9b47f5d677cd0a455a24caaa1244126eee3d6c6ab6d94608dc5d0675658c3861348aac0f46deed4d0e19d1981ecea73f28e2854c62f5f7f5078869f3e18f7e77b2be0843935d50be495e9b5635978c77aade571ee4aac066895332300435e00e79418362cd2cb03f4164a8c1a348b80deec28c1553435e97aeea1a4cd3c0662108b32aeeec32ff109f58914e20c1b742c715e1b50b8b47aee944b64b11a691454887dd9a2316e7f7cdf38d195a2e91aaf97a46fbc29efb5dcbc63c89ffb5143ab8d4b243470a158b07850bf1084295148b422e024817830aa615c8874c208a8537a24385054725d462bfddedb83ccb227cf4b34287970257f545f3d34148e8e6c26fff538458b91ecbfd59229f178a2b395d68da5cf4a30ce4452698f0135306e7d7fcc0348ccaad10b25df686bdc8d131c46309012e115894744663756279538b17891640d460680f95cb89a5ad0434e13905bcf9da7a6fafe672301afef0c3b72d67aedb8ed8f147e68a164c60c4b65906765e564714f0b0d534ee1f1f91da6dfbe05f3109670b76be344f044cc2690898f25de1183e8340e5bd5c2a27a4b585e32b428d90a675a67cf610fe5761228b8e6c029961b36b64a840960ea1c3e9529cb1d6ade5cae23f6bbd671546d28304979c51f7aaac25528ddac359a11f8cd632758f401bfc44fcc19e76ba8832bb11ac80458cd8a6433b88821cbc80374b057dbcf4607d0072504c14434cf61de7feb2515dd597999f9270227dd9d7c9c242e9d5d8436a46d2195accd86d90c28ec236f44864c1363b734f6570ad865fd5edf34f4ffd3e6493b50b84509bff453382097ccf9ada958380befe2966463f86ce83dec5886e8fed484b62352fe2754bb457f411da78891766bcd7832f9eaeac14e4dd693b8c92b34ad0d821e81573b7bbff2205901092429cb9e2d8c841b730abe05b9d32a3f4081928fdab4395960d8a26e70b81d73030ef2a1399f708cc4663780716cc78ab8e56414b0f1139611735caaf157a9f7829f4595c4bcf35fcc61d67507d08f0aca0028e4f508b4b052737bdbf46a0f70a2d9e43d2b24b07dcc6f3052a2470da80d2c50d72204dca81f9246d4034838aeaa262608096de97dfdf00d491f0e8be274f02ca624a3fa3f5fb46af1ea3aa57e5f70ac1d478a4ab7e0f84460013ea1ba3d42517f185f1c7c854681c4218ca810ce011c30d5d205054c58812d1ac946d38671a00b3ff3ed8ad2be3f4f981f8c59712f14b8dcdef20d26d8082b7f139935e9cde131c350ef97b1f3c29f459ac456f6b543bb94b1407cb50d0ae19f0ee428f79935c73999730e15164627a23e8b7fbbc123ecc78bd505090e9a20c2f485f0cb8e074e16edebb753b9c41b74366539b9617f1a0753581eeb44402e93c5cb01ee8215da3f4eabcafc2c639ba18e55f192b29a24f8011a54716beb885ab10a79caa3bb75a690bedad7b9f832fdd5f112d579296fef347fb487e506d2d835fe05988130b3c7ab8058f735360287bee1775848e5400b473d8dee5e5e49e088065727d72673f788ad2d63905209c9c90d5d7970b96494a2733abe136454a48722ed19f392a6caefbe082c109a568ec110cf146020410e6ae3584444cb4d59754ae8b4d22d52c3bf7f2ec907dcda65e4ada081231df4562a7032f2c4d964d10b8a3287c615e89151649e08b97008e464a0867e15286277cb9492b71abf136ff0497ce8808a8c8cbf1e52f8a856dab61e56c1755937951ec7c70dea12eeb5ae848384457212c317d46c942f377f0463b30043b41f0a0f67bb12f4c0807f0c304ea2005dffad0057602fa7c633656d18bf681bda8ae2f7ae73b336c2d034719f0692398353aff7d16ca0671c61d7f5adbc448a1cca51f4de6d571c4751706094f1be1602be5664f6eaa6372071c8ccea8de6a2f06ab83c2273be27727082661878944d76228ea601c1531a01807d7c2f9298f0fa4eb8a4a2f0fa78b91ca7e0a9210dcce16249532a4630746383c072e303df59aa34a019e25af6f2dac4809a77d6f90a29ccfb9f94ca4e3d39473035e61594a49bc296d3ae5b1a804a7323a972a1552b56aa68f12684519f02be794d06c5e9849dd3f5150beac987d80d2572ba1103230c1030ce349618d8519ca772d9921d12a89f2c83103af0fc8b5d189dd90841df9c911ab72d28319cad9b544edabe35886309e107ccc09e96e3284e0c87948b598caa90b022fef9b03726c59b7f23e02bd34ebcc9a185d623f599527957a4846003dda1bbdaba360687323df9d5e9f0a10c911d45c4fb8bdf0e8557fdfb45323174f49bb33036a7046e8deb57e602cf8b890657da8ae5c1cf97c763bfcebb5e62307de5ec47f0a7c307c61702dff064907854ca69a55493da7273bb08222b17eaaee7fda7c0a18644d84505de606da2be649464765d77d111159e96a8c44d66b4d59bf162a1aaecaa8c464fea76cbb117b55a71c378cbdb38edd1e8ca58e00d3c8c97bdd8f12dbf147c13c01a4c9000e26788631d62d3b736036882f57a397a5ee2ebb0a9946b6aaaed0f56182d795941216a947afe632b3848765c00cb0cab8aa3f7797978d3bb54b088a4058bbfbb660377da40625952210c0e8083d1623402060ebdf8dc697ef93118f15190f36c911d9088a78ddb18ef7b6a353d16bfb28952f3df6a520abaf632a00a5115ac909586741495e172c1862cb9af65bd2472be1ad2c5a96093ad05be1d113c4ee6ab50e50d766d3a1021a790b9d20a1b40210d2c9875b8ba95b5b8e1ec3e2bc85d7c5e11ed456d4303b49408a6ed7d5844ddfc2185ed7bba8a265c63e47992ca6fb0e597721f44e1eecc1100b11e6f0b96ea0e4d7a8c35d79e865a32de001606555fe5c25aab513fe434779afb16190168038c20cc496e114c7987343d8adc9976bfb2e689e1e3da4af10f6b6c7f726a9b9abc9339e988169831dbdb1a52af73cf6cc7a83b2f18f6306bcafacb21fa1934c92eeb94f26e9b06b128ceee241f294056a7160f6273c071ad600cf1ad829f164590cd507011264bb0741676e4008d28fece5e0a8f59448e4b35a8b735c1ea2880333f07033d8815bf022e2285b0ca525ce3acac512b4dd1353e1cd97140886b1d48d03a6ca31c2d0b83bf98008c8ddbbd66a6bb192ec0689ed92c93b35f246f69e8e946e6af5e81ce52af6a9c2590a2790e46f6ccf38456a017aca453e93560f09b9981c2e422e2c834864f3545b026987fa5a01d729ba98fe84c0316946fcc4371653dd99f2e560ae0b4bc60162412b0bf3975987ba294b59e2877ece0b71b6c448dc2d99e1f856e1cb4b84699ec1311cea4d29a2e3824bb703480da5c08efee30408bfd6b9272481a39caed7c82402eb3988a6893a3f5f8576a84946a8e2f3600f31f7f2c9fc27aa4a70b6bba8f6609764bb2ae05e43411b34f4ae1e665084258e4c0904698c2d6b9da455f2b3a68c876c6ac722e7cfb22d658f26fe74a9b438d48f51f4529e02b8178f6457c832f4e8ecd3a7c762037552a5ee8b7fca1dee72be675431a99a289668201f6dcd4b37bbce033a3c59e5e115ca00f7702a86df9b5b27915122a7357b4a16bae0ccc855103271dc4dcce6112965d42de6ada72f51909a08351900146c317ee13b27d8bcadc42a860b1b0472ddb272afcdb71e89485044019a3ec47b3ca960463d651eac263959f01380f8f919e2437872c0759b8e5c09264e0dac8e027e662c2abf75c1b1940c21e84e87a754d703713872cf1699547109aec7dcfc3238ff05873f96c1554eaefd0bbe377a29e80de5b85d83700e540b3b9d3ce0b024e41104ba6537aa5820da19a703cdaa62056cecf1c67c309c701df078e6b31026ed56e5e75da84c77bcc89632450232d54fd155fb03b19508b05002a310906a7321517d409d21fef5df3695bbdf86bd0ea43c5562c30411d9ddb6dc52a694640a3f0a930a7a0a49baab77559830c7a7c6777777ff23dbc3af9478632d47f7ec6c867d0c2141fd7d521f305e89359e34a89f2251047586342258a1c41caa2e939821478d31ce58718253da345236ad60819af6464ec125205c6567da9a6823679ae60f3346ee1760de63188691e6d2442a1f46397f985e029991b46dc70b368d944dea038aa0a0f5b943c690109eb08365825dc7d102a232658b9cf1de8a5c2959ca28658c314a12c827121dc3c14475d62d7fb617836c624448d8633f4c4c462c462931a90452d65fdab4171489667452d77b3e856ac618e35c4f6e552aa191f387b9bdb0756d240ff5fbcee380f5e2a3e20ba5336872386b2576d1054432c618a39452f20aba075ac728a594524a19638c2d85849146d05926d823c5467bea07817888c5253e020285fd3c94f1100f4d3efab9d19e192c7105f6386b0510c208218430ce28230ce6466512ccd2a13a91214bb22c215a32549d159fb92f0956fd21843470f5603761a8773295793217c166009b4c5af4d87fb0496d9e73a7a8a87987818ea8e4ba39bc3337ea10c3a28c58ef6059e0cb5f722ea58cceeeebec316e841c9296d25f3e74a34590c51e93f882b9517e652a7882c5abbe22131cfabb7b978461779e654a39290a4b02859a1b151a827232544a29e5bb9498942e4991247f3d967a786c1913844390ec52c2b9514a29254c179bf5c984978c31c618a5941247062ed7faccd15bc818638c314a29a5143782a1b880a3ec22482388e2db8821cd1831677c4c76362f6463e3332c903354df81a33acee6f3bff9f25ff3d001eae8201e1c1d280cf62f5926dd3413a9bd1c1bd4cdac0659616b6bfa4b2468ed30b922b2ca8e48890414230a7a7102f44550955c34fc7e6805917b9c3366934d36516cdc666e34c610b988d18f986a8c928a18e3a909378521a5134fc5fffa6408598b17f8dc286b21e4594c76648c31c618a39452da3cf119a44c22e7d87d85aacb44af46e832665294bde8eeee32b6df444d34708da62db0eedb24accf199dd0969312ca871042093b1a21a53db06c73229b2fe3cbc766b7af611b0efed14b3db0c6a45319d316a94829638cac448c3e027667c87d53e3016a1c4069b7fdba1a3f2e25bfe66103d4d11f9da06c803ca00ed4d16f32c1bc984c5b47eae6954a7ac9f97af17968d55c9ad86f823a7352ba03777a073939f84a7ad13a6e6be277a4eebb40f587ebc507c2258645efe0cf0b9c4570f9a432533024647a073b14935366922435b94919a3141a236f949a4cff9e874205712224b4519b1d2fc28c9874f7f7624449ac0b82094921a1fe190fe551b0852b7f4eefedbf444a229f40a1a6a99238b842f59c2b01d86555ea0cb03451013568d30038f842264d28312c4a8ce314f772b06a7bf79f476c9acc49229988b4eccbcb71c4c663cf0676d99e4b3f622a94d6afb66e07a6e92b70bf34de90e9930336afc9d2073dd18b5adc622946295b40a564e7cd64faf73c14cac66688cfd090f7cc209baf7dc47ebd38434926ca038d5ee4a6324bffa2c52998905e5ed3344eaee2ca575a6f1ad72bcd378de39526378d83ab12b7c90702137fbec3ffe88e27d013101823f1e917bb13adf33f4a2af590118b353edd9afead293881788d2fe9de2ce504b411f85eb77e303e0ebb11f8f1bd3bfdf01adf6b746e7f7dcec738b6dca394524a19638ccd33371aa57494ff6cdfba787ea64419aa47f6cabc828357ef41e95af966d81dd5d97bd97254a7a4ffb68a55ffb83c8440df1bec4a75a70175f7652132a6fb4c4b4d2fa58deb53f6481829e388b0d715eb866c4d7f944d723dc0b9d12b252a425d5ca930702ab141d5dfcbf1cdb81f99a90c650fd8f57a977ac8ff7e6d548fc9b41923b2281bb03303180fadda3ac84af5286dc1da6ca4b4b1e12a090358e9c7d7ecb509975fb46eb78644ca7ac46e8b564bedef8c3126b8628c53ba122637794e789e6f3fa1ad9452c640e73b16b7927c79c1482e47e05b943039355226a794513a9531658c5101793029860e5ec293d2cedddd1fb58355a5f7df4e229fd88169fabf4d9decda1f720e2184117b77c5103b222cbab92f0ec9b51e3b4f2261ba74e9327d90b24a9cb3e3dc4a1fa594b2b4a132cc83d08a3d4a4391509913892e6397b14fe10546fb48caa67ccd378d944d140ff451933b0c7e8f1d9d7f2b976cc881b521e421a2d8cc629c9352938905514a8f95480aa29991668c2065267f9b1f9bf5e933444248299f638c12462965472b40992d605d8c31ff79f43f948cff6c62fcb7ae17d306a580ac173f3edc940ff67a8b2af693ba806e32b8189cc906c8a634b05e1361afb499b48e2483b4aa08114efda0814d01b15e0c5797263e0ce771585420fa8bb4cae6074eed7ad35597083930a8feb04a8e0e1a86e3686afc35000ed51f66dd733562a0fac327f273a35b946d8112030e688cfdc055a4ca773f62aaf29deb266c131554ca29698fd89d9c78ebd35d069a0d8aa46da5196440d9d94da67fcf43a16c6c823c212434434ccbca1333ec68d0abf092242d470fa594d216accf1c359e307a410e9fc2f424e39c93e161d773251e3960a2417c3860abfa0f3940395472a654ef207cc97d471cd6df1a7fe89877cba457c067009aeaa68f729bad1527439aa6df145fba52f7cd2d8618ea4765cdba1f4a23a0f0872cad7187dc7b805576356e7016e1ff91e3d7bec6183fcacb3c59857decbe24ae0435354dbf0c0c5ad008bd015dba74f1ea7567fa68638c1c638cec0426d9a3a0497fe8b0d46362f2bd63a23552168954f9f1715a8b5becbcd483df25d63986b1173b9451c739bfb93941e5c7ee9b1f8397eff0096d71288c8a1f464e760b7fc71328c40176499a9b35967c6c855d2c01d92e409274a90628857579e7d1dda33bc767c618638cf993891bb1ece1aaa8fb84a911a67e94865865e76d4d3f8ce7ad4f19042c71450a32ae1d48265a3254d9c71fa7997bae431f18507f9f506afc2fa6ca0e026d4d3ff30028723dc0fa41a0f5097da40ecf0ff461a21fccd803a13fbbbb7bc78fc31c343b0a9b7e26ff221d7c715075af82ba0fc117047a85754dca01dd57fd7888833a0542106272508fcf60ae63a5ffe8f69f09e6bf5fd5cb7fa41ae767a82428c744fb207860b158ac157d0d869bf1f2428d01a840898ba51a6718a9fe839638b934f1b7971a3fe37cc02a89c657fd7f60553ef683d6ecbd044456d921d92e95d4c5ad8932ebbe10d408975f66e75b13bf582310d57f13105d8947d4e48882d7dce28c524a29638c11670a97bbe646d751805109ab9450a894914b3da27b1258e543f9fcb2f301d6d83918fbc26646f2a098935293e91f6709972b4ae95e7d0521a270c8f88c1118b61ee61553e2476670007d0105e7c0cc10ca8b012966537a703e918f5ef56e08f67ceef28744312487d60acc103cd0c2d74a4f5d00e4386c22e4cffcfb1153f57fef09f5ee6f6f9aa691cf2528930aa69ff14c0330c2144698a65a8475cc3e3e6dd5f6f2f1513b30ac09c576ac176d24875a6f879217ee4b9ea3368e6a26129771cb039511930f8fd8d4f8b00424c6132c5430eb9622076cea129923d9a3f8c8aa7964734286bd76f7ef086f9539ce87a51f70044ba4f8630f5f3efcc861ddbe7663c713a8ffd6f8b3d423da90533d7ae7f3c86684298c30c556034e38c5ad1ddae75da2d8d08bbdf9e582cdcb00d42a197e6d3a195ec0829efa6d3e6775eaee44011e2fc30b51c0db744aa4f42be0bb13c2e36578193a253c3e679504b5f99bf72c45bdcf407b23f7a6eb3e5759157c35cdfec48212e1e324d4fdadb1053627a526d3bfe7a1b00d9680406c8bc79d84c8f0de7b9d12254bf68a26785652fe952ce11f7811b492c2bd005e86cf59cd1550f8de2f8edf6f56b73875fafdd661d5007ebf9b70eac6ef374fab08f0fbddc3291bbfdf4f5895e3f73b0aa74cbfdf3fadaaf9fd06e2548ddf6f2aac2ac0efb7154ed1f8fd0e6a958edf6f214ecdf8fdc6c22ad4afccaf017ebf8b3825e3f77b0bab0ef0fb6dd447ad42c0ef3bcb99b06ac7efbb4e02dc09ab52bfef4fdca755aadf6c67347d402406ea986e0600ddcc4c07b560b07f7a00852e48423dd0228469c70748e899010097030b88cb8145657b80edd4fde778e213f6f69fe366466362c8909941a386c9c60deebbefbaeff41cf75cf7e178fe9cbaa51edfc11e1edc76c3650ae06c38f8ea8fa1fb260cdd0bdd67dac7c191ae905ceced9f38d21047d2c2debe0d8ef4626fdfc491b8705a8bbd7d1a9cd684bdfd199cd623c36932380d88d3acb0b71fc36942eced534ecba215692a4e3b6a9afd14a76d619afd04701a51d3ecefe0342c4cb38f004e0b3a00a751619a7d03701a8ad39e30cdbe0e4ee3699afd02709a0ed3ecd7701aab69f673702423a6d92700472a6a9afd0170a42c4cb34fc391849a66dfe3485698663ff35998ee9b1fddbaefb5eef32aaaf29fb2f98c85531ff6535786bd53d6d1c035a3b2cf2e4edd1862222818d57d2ee22dac62b21169e9a98b62b1154e6d152864a9fb1cd4aa5eed6793b11f4e7d994fdddfcf7c3875823e300a36855318104685539c82ba8fb9302b9c6214d49db20f547f92a01f746547381d006e5718f7f1ab6eadba1f3920ae52f705c02951b2243be2b59272f25f82802a442b2927effc55dd88bde5a95f7624031700ee60506644bf7e99bfeac2eea34b85bdec0802b1b70fbdd89badfb31f0d00fbab69fba0058522327009ce3096d673e7ed57e1e9df992874b5402e52752e12f078027d49344f835c2a036bca5f6f3164ec9f77e6d967a402b4a38cdbac9200832cc1da5a139c51fa462a5967acc1fefce9c29d3027d1b7461a67bf6fa73b0e7ede09784c22a29f377df35274171dbbd79a1eeef600fc21d2c58425e0ef6a012edb727318944ca489dc7218128f6e092c642b4da5ee3966c53ecacb4b721087bf07db0870327f8c649e9d73829d873a9c7ecb6090a3f86236c0802b3391db0454ff5ca838f205bece860c362b9a1ab0366acf37bb6f468d85ee7b373fbb0a9a424519bdc5753e7673fb98fa6cecebe01d4993177c4a662d84f200da8185714a7b01d2cc51ffe7c2deab7afec6b08d1ec49af91b89f29ba52dbf38250448aa854f83bb08ab3879f638d2a3c41fd76d41802d51a0889c33ee3fa39853d01aad82a5330aa6c434424a808a7becdc203a7aa4c014b859f837dec00dbab70cb10e8967ef0e4fab774034fee6bc66d1529bc2a97cd39272966393e9b1a2712d8e5c70ac108203a706a76275a6588a644a938326e071e046da907a8cb8328b450616976a61a50d30ae8e755f8455ab52b081fe38a703bc0af82ae1076762842048876972e15b2480c5305160c62270a3b2b25374c3464b418982f75da155eaed546822e2082cf8af44b78044106aed5e97356383e6705c3e7acfe7356dde7ac6cd4982123062d2979f9527712927de94b9d92d2679fb37ae17356317cce8afb9c55ce6abfe376098e33695028fc18388ffb2f5ee07070a82ef4e3d7eb05d71084ad96d1d18b3d7eb1e746157b21817e04b437b0f2bb0df6463e7f16a2ca4fd8e3fe99e63ed4dc7a6ea6769f2938849c88b23daed791f6f34511f5eb27cd8a3db429ec71048a3fcf13a56391cb81e2eb753464145f928b5e6c0dbf47f7865cb61dac2b5c5b7e98f04e8b75459525ead74fbae30fa7bee8457dd5299c621d13d425aef038d9b6137792008e3f3d8e0e081c7ffa3867fc79acd4235e9103290e903838de86e823e827c6ae0738030714d61ebc7eb185838b91cbbc686f606cb57e34aefc71a855710a512ce510c491177bd35de3ab5571e85539c630047d810138e24fabbce8856e9b669be6f923117b1363b0354540559401a4e1ffbf71e3e78badeee2cfd630571b54e8e745ce434d4ae06abbcf5463cb8615f4e3d76b6f56d59449bffad5a4b2084e1d10a71702ae4ea7ee147f57a7e7f71e5a63c842e3891b628397ba5700fdd41d88e080dee06c70afa5062763050adff4847ef107a855fcc5d2f03387e1aa3c82ca1f9b88ca40ec12e257a603fa404c7810d47120f843839bc1411e2450f832fc32f8618802ece1600c0e965894870d0aabc2180eba60100f7de1e050d3f0938ce0a645e8064e7ca2f84cf9f9b9a1c42d6cd2a567e54da0f09d09744b3574750224799df0b2220bc756dc012ae271c25ed429a27eb149e579e23d3d0ed4aaf8b38329b6ecac3c0bede2a7f26b6fe4de7021d2c21e3fd1162f2aa2c21ebbab7320f6f86100837eb1058de20bbef6a62bbfd6d21b4211da424bebb057a942d4abf8d2db8be051855cd8732bb1ee1536d0c2a499e5452d9d56b39af0ce4ee52dd5f0428d3f4ba05ffca9b0f4a3eb27822abfc4ed4aeb0d08fc5ec8ced5bb6fc9ae366ea32085240cad346e57923302dfdf091d25a854e9c9520f50d7950517d47e6d0d7f3cc5893dbf38152b3f1b716a5d5c742a3f1f754f4761d5328188b9706aab58b1c3af2fbaa2d87eb814a17e3d31e9409cfa62cbc5a9af5f419cfa9c4788535ffca95438c52d22eae7565af5f32b7588fae1a89951fca92cb457e800063552910cd4048d2d4e9dd8c55666165cb17b5d81414cd08f836ef07eed4dec4e34c81a3f762cb435fc469c622c5916faf5e3d756f78a185851bf6671166e827e3cc429ef4e4060779b0d481c13715116e8a6020ae58d1c8c5346da6e24712721a49c95c69d84684a66d3f86b9fb3da2d66d98bdd89867571a1739240af4e12e0df7eeb44407afe5dc1f7d7be243c597e7c589add0f9b1a5535beaac6c7691cc66123d9c7245cb3eef4237ee7035723f2d7c5854e95aa2ab97515fd548ddb1589db55e4785055f83be39299075a16148abf8683e3005665f2d7abf3f73f9b39290d92714998a6794801dd69c2284545285e90b781df6462ef701887530b21dc66d80961af83b0d75c15d42bbf0338f590fd0b66be2144bd3237f110324326eaee76ef6e6feff676ffa1113a8311c3d6ece7d4ad5b82e1051ca71b364c3568cc9091112386c2bc94368d944d4c466f2ef5e330dd6e7709cc61662d1af42c28bfc6dceefe12bb6ef729e95e62a0eda6f87d57d5fcb0dbdd87bb8421057cd7fbb77b994de0b367edc7aa91e6947feeee1b77abdd95800855a0dfd736cd78393835e4dffe93bdc781df886fecf57774c83db3ee7cf8717a924ed215be0b216ef799e0cf55650f29cc370db71d5f76303eec9c3d538c5d0f5e8f982a7c29c828a57c9798c4a4d7d825e10adfa9e0eef0c6468feefe53da9003ab57ffe07fcc70c297330ba1186394d284ea41a1e6464d419a97c327cfdea29412c3b028636904d24b3df8796e14a3a2273e0c2207b1d6374a29a59432c618db05ebf38aefdec88f9a8a42a171dc7a4bda6c6757d9fdd6c4e84fe4dd87d8b418639c73d2dea22d6fee5bd45bd1dca84de5b701428c5146982e3c89b076be3531e70a4e93f4113e3d57e201f17be80453ba54434ef59fd8b70f5cb1d7e6d6a51fde0cfb65ce0e4957ac93bda51b62e745c02eda421e0da1e47c602863e46f1fb8eb41c687ab23fe46eeea48baca6e3958614bc84c76aa9c1897b1883c077bf23df6e4a3d893b5853a28e3fa0af659d7575a8853d8cbff30ef6d4e5658eaf14215146ba12afda769a4730b63b0873fadea16c6e5c022b928afe47bd1ded474517d8b2a3f3641950febe90822dfb4e662d5b00de36690251ab0da8f7158d5b00dfbaef2fb8a8c51e5f79133d991df58a4785265073db3a4b0523fcf1b6b71ea93d9e1d487c3d4c33a9ce256932ad949953cf5c381956ee00f6c6a7bf91ed814cccb1712c406f940ac0afe348d7cf9436a7c3c173c13a623a809aafc60104172bda85236e99d22ec658dfa75508d26823c7a0ad4217f4aee2754f9f0a755dc6a9ad27f35de53f9301bc72d2c3d05f2682c56877ce923a8e93ecfa8fe162d1f05c2d6c82aaaecda4efab1871c0631d8b0bbe6614f76cb3aecc91df65ea874d0d6cc981c82f069177bf25fba06624f9686a0f2fb49fbc497dfadeca589ca2b4c2325ed1a4ba95bf6b6eeeb2c59117bab7133b0275fcb36c8e1d0c05867f30215f49ba9f2bf47710a56f95e0e4ec927717d853d99752dc49efcd975107bf284f51556f50f8bc5626225bf8338b5a9ead3c57a5bbf1a5a6896a5d95a7db02ccdf6c04ed54bd9631c576d7138e36417f49bdf030a7d28ad5fd1ee84fdae5887694ed8c38a75dc624f7e2605fd2ab520bf0eaaf26515f49b55be7c29492cc384b633d88a9df268ad2eedbaf3273d73c23d8a5b76ca9a7f383585819808bef0c354b054c873a542d65261f6ed9287531fb37a38f5b98ff4e1d4d747d2c9d17ef2898c52e1cf1406ba822ea74eeb59b765ddc47100a74a0fd9461e65599665fd5fd72c6866d9c3ecb3eca83a15fea1428ae591b1a00e9f2fc78c8f8d3ce29e8c057970142d9bd977f771fdf88759d079380ae4e14fa08eae87ab951fcc873d1e7e88e91cc9a3c95d0f70739e5651da499ea6c93a2ddb6612f4c37c6a14f6a0ff34cd13c8c3a5581df0a14f2ab606fec7f5f327153e73e73eb16e95574ffde4d12ce2d409e661253dfc8cfbdc0763b52a16613e58cf9be6cb2dc097612c0fd904eae0c2a923188eca14b54af2b46c0279482b5007fc37519e58d4a4d2d9c9a31eb3339966117b5b785a25839a069aa8d4acfbb028f06510d67d33ebac3319f452e567cfcccc2c5bf667533b6bc9035f5a813ca411d4c163a5c2ee301ff68eb6868b34823c6418ab630b5b035f4aa30a7f4615d4ffcb58af0a3356c6246bcd17a78c38d5c3fc24b36a0f7f1e712afb197984b57290fe93473d24a195df3bcf9342f2cad6609143328b0cc2ea80cf9c1cc2d640199471415f062d2adb81611b58689a0679eb66e6c85c12f443d5c9d0e173fd6085023b254b564b20f30d7c23d710429844728c2ee690c400a94020f67aa83affb7aa16ba8999b3ebc8f5bc5a2d14b95b684b0f35d1164e9dd61b4b6751a27ead056ed0d52ad872d5102bb4b235fe730594e10b06cd49a9c9e4cd23e88732d5ee866c8d7f0bb52a87a5f1f77642757f8d3179c56f5467c2aa77412c9cda2a5e04d50f6af988a840e425561550503fc8059311eef070cabf5d9c3aed7812f5834eaa0f55c7e16f62820e6995d734fede3494aae7a2f07fa65f9b09b49dd1b64077c3381a8333f22396ce561172e2a8a8bd198891a8f061aaf93b46977ac4d0b46d7ef940302b2c6931629adbd8830e85edb319323eb26464c9c822bda67dd6efdda576271f5bfd6bd8eadd8e2ffce7e7541c7e79e75e301b0f6774321d5c1a9c263dd6652f349094d841939d1da8e0ca125cb0cdd9bd5b317607444f44396a96cb0a52b297eb78f38f886d1a473f868342e349dd897f57349e76277e58e56fede7a0a02f5d13753dd459d8831f040dae7598a69535a15b321b77f2df1a3f5691385ec8c274c594202afbe7f0bc2a8a2a77a82aa8869580f0b0002654bad30f9727e8a9fe393db43139b05eec6dd53458f267ce077892c00b2780a2490f6b45e3a1d4f8053071558e46b784c6d378cd937005b20026aedabf0026aeda1d9425343a29fd52fc736870529a8b559bdb0cecd9b007677085aaf5e00ea70afd96b469dc565802224fd082dacf251c505cb06a7748d0fdaf5b9bc5e4c072c11765cfa120027af9b0a1499090201042f86a5513f58b6a41e1179b65b0772835a1f8053db65a2d085403048240104b8b080241a01a5d340d7914424643746832b443dfd0465be58ba37ac4a953bf026a8cc161f8f810b9b6e8d76b6f4e2ff4809a2a4c85df437bc3117161556fb12a08e44d2a7426b5bfa85f85232a08b151e6ddea8ceec0f8f30e4c0627c43a974fec7cfae19bbe7e5261d7722d68276169e067f5eb2157510f6d0d7c1c9e4103fa75ab5bada2f1f0db8855d5781853bf6ef5f7cede34511b310d7c58a36b2d760c7ddd1afaba15d3aeee83810f879e40bf6e56d011a8c0840aeb0c20aac1284ee2c62eb81971a9d1680b976ef08d4b409c61bf7c4aaad635769f076af3cbd51f0cfc276cc43615a029157e4701721e226a17bfac20d42e3ea27edde48b55f1503fec9d21232afc9e25885c0bfaf5d0107c085953a0c154bbe3d7d6c077223aeb56b9024f6d22f6e07f5ce3b724015fd590a93dd4aa1a73526a32fd7b5eb76874ddea1935a05a7f01f4858f0637025441ab58a155bd76516bab8071d45b6a0c81c2d20ddc8d6d5d02d23380e82cf558538cbf476e87726009a5f6b3528fd6e1428d5c8c0a4b3ff6bfb81bf483a31ab95861e986fdd8ed7a5e7b873dd82df6206b68ab7c81a5c25ac261bf3b243570edffe1b597d4f68d39fa16fd50d1e18fde2ff8e2d409b6a08e0a9af00e4c41d8f3b335f0fbd43dc4a958e1779626f2963761157ce26a2d9cda2a5db02afc36fa9ce53a15cae8dddae1d4077f2a7c58e448ebc06e52e1cf2c40e8f0676fbabfbb1fb6063e57f8700aa79430810f59ec4116e4610ffe0b3ef48bac0a3fb25a059df4ace0c756dc8952a114ab2f36893d3398013f803e82ec8dac39a0cd5718c0a0ce0c83f6861f3ebcc2a97df804d81af87c621f9cea0adf06f8413875a3c2ff01326115f41112c2a9adc245940ab554b85c2ae48fde28f8397038f511000671ea94e2d60c15ae950ab9637803e7e0d4c9042b8ebd81b50a196d3f75dfb4022a43ab0200b323e8fcd951c685c422f990a6b0caa687c464a82ea949dd8fd4438a5217be738a531ff422b238f57193d3dcdcc888fa3997ba91c984dd476ad5a5375841492d4ef1d4ec8853cc5c482c66c9bc8cd88347ecedcbb05d3c3172ad92a0ff302441bdb731711fac375ef317cddffcab5537bf34de0de7b9ab69b8de781cb6e118688f6cd8f8ccc6bb8d8fcf47a7c7f1f088536e63834279debfc9c4dd112cd530bfbbcf6117b926f4c3a2d47dd3e9e38fbfbef9d1cff4fde7d9645bd85ba34affc37e6a76d4d5a031a3fb4c2fd37defc9e83e0f15a3cb7c62bacf86494033a0de65af0c003a14fe9715d57d2c0aa7e00d6e2b89fb3ca8eed313f7ad95e73e3efad68a0d1a6607b940f11e87e1ab55cc3c5e0c4ad02f3b621ee8a2d014bbece8e326fbabf116006e573e30c110786ab4a005364db30f03125ef72686ffe6c2f01fdd176c1efbf5d77a93813b09f1f6a80a32385a799fb3dad21d11b023051d1e2c75ffe38fb7442f728483ea26e9ee7878310fc31d51b8c2cc5354c4a9d3101d38d126caf8691f3633146193cdc6c0c23b2f226e93a90f6fcae8db05fd3628898fe5d2926a320618b36930193d749bbbbb79316e3eca6b150f41a8cfce07c6f14a060a283f377bd9cb975363f8e285080aff232a0ac2362818803ad355e66e69fc913932fb47766f006b414a2e5b08b9bb7f6fe1eededdc61d68ee1ee72faf296851281b5e158a72499886872a502f6d51108c319cc561140ac53242deeef80298232d998f6188a828089c1886cd396d5c41a8aeeca93999c79cdd3d7fd99bf3677f4fd39c1deca67ceadd67a23d9f605be4a62ab05ed32c033090753f96a6bf3faebe593706d45ffeb7434578f801b2b6ca16a6d4fe21adca59f5ac3a4ca8d72fc9f3421e2fac4a92ac853c26abee7329763fe277334da8425b06d21a5fcec7e128a1b47e356798a6df25778a0feb16e1d82113185a0f4966c57ee1ea805ca3f7472cc6f81873d862bb3bb1b918ff7cf66214babfdf8500eababa7083ba6dc951d7d545a7d22c51c618e30fa2b020fe0c630140a2928ac05cdc0750d7d58527d497baae30ac34c32e30c182164840794161042618c8034b851e72aad0b245123b34d882cb166ae081ed2183c15a931ee7cb462aedd30d81173e3a7861d1d30323aaf0000d586083214461052bf0a4000c29fead28d2c41456149e8085a585a7987eae94d27fd0050c301da7262a432915b02c91456271052be850da052ba84c951c0c5552dd2a2e29ea47a1cc00084940c2105d24618515fcacf81f85c222830758698214a0d0a0084f5c8941fd4c0c797a6044142bb4c0e4f50fc42a28383822092944a1042ef8c7f46f031858e0678b1457086309415491c50b725084235eb005125842f8008b140844c10509b478a9c0083ac8224a9421a8c064052c7801152014094e4c38a009275842093818421255a860c21646208494524a29603efe1447909ad0993e9b18429e40081a26a8e28a294498011458780a200d8b2634a1e352d4efb5d0821cb55d5a5842d69a257091832368e1043d2862d5388c9deabac2e84295755d611ccd1bf8a854b0042030907022075380d2802d88a2f841124f68190285ca228a1ca86c3982082bb610644416cf62b148f099989ffedb000a24559ad0320250115c6042164f88f84901128ae0420411522c9607fc60092ac842062e2eac7041e5a75f8427b60a472062a2488a249a5471e2e708294d3401b40510b0f4e4e04089297494782541c78a19c4ced4b680051e37f104284d749c3cf1411195d5ee20082c28a83882111257acf8b7c4a88ae5ab2b8c292ada335b80bb40a89f8c8e23258e6a503d0c1254f8cd50fd7795850549e86942ca162656fe9453eca4faa338e5bf83532fd5dfc60141f6065688048450b52be99cca51631735da38827ef4a12b0b46a834aa3f34716ab759c56f9dad12418c1bc4bf83b14e8a11f8fdb25392b392bfa520b23bed6a36cd0ef933d511e4c386203f4026426c56cb16ed6bb978a71835838d0e14ff0eeeee6462e61d6c89ddc19c3333c78da61a5136ecb54692dc45d86bced1348d0477b0581a89599cfab6cb163169e7540ff293cc9ab5e64ac6afb79261b392f15f8d19646c1a89967e3f07ccc7bc36a4fecec29d1dffbc36fd98d2cb520fda49622d7d978080a04b972e433576473ccac1ca9da53217a4f4d2750f51c372f6c6bd1669950d4cd3df3ed8b381038fc4b3714170d89afe1b56c79459263bc8ca02876a7f7f6bdf0f593e3f7b8d29cbc77ce85a9adfac5a0972562188f19a73d833a77d89db3824b08b977a68a46f9246fa56890008192f045cc950c9e84e41627c8c4e095c8940c6c7f89c553faa39c80daba37f72386c8db63725ac8b9c0d5bd36d037b1d3b0f870e6850ef7c49b8fa3369776ee0514046272546b7a52031bad3aefabbd44352c8da9ae6536cd2ae2bfdd0497774f611c48686acbdd9da5880426d1c4c38d8eb2cec7cb0c7ff896098860b34fa3bb393a47d64f833c31e435485306633750c8704da4882d6a8ebc2821335d62d4152851c3fbc02856010e5e01574296dda7b85091a407168b66da651ce14d331313486b6c9b4850d7605dcc10a0ae2d407afa87c8581f415f0676e948353ba586db8a810540254c9ec4d12f686fefef73764fc500c380489d81a7e22b008085ba43eaaddb75da01c0cda1a6ef8a7de2c5b8b534df8a196161f5566ee85bc44508761e987d7207ecac54a847f074e1580e115508769b8053b4839ae366e403f1311e80787b4186159960cfbd47cc6985583f636ad8af1a55f2bf205e6b71352408506a87088a6428f63e8da80705543fbfcdbb4fba829497ce1bef764fc6743e6bf18d58cffb25a7ab82a1a5f2a3d8d199c0c27835b4e3ee44affc221698097b8e592b07fc376137bd0bd189d088088f142c0558c183f572d444a975363e4ac62fc6c1ab601fdca8d031aa3c7c6178ed5102b7bf7ecb9e7413813c01ac3e210167b081288e8e0f13b76dddd9d65bf599665998c09676bfcb353961539e2cf03a7369e04fc246152dd1d8baec7c14cd46fdb1b2ed62bdca0faebc0a902547fcd27b0375185f21d5be35e6de480fa0f69d59c1b58ff22fb45f50dc3d4aa97edfd5d1301102faf9562d7dc02125053240075863f1b185c5591a629e2382de793beaf3375b351b798ba65757bb8aa18bf6d1f83dba5217d0c4782e14893f4cd6d5fe2e6f7c675fc2dcde79ecf73766d92b942bfc8114fd235fea08453f3b90577f885dba669f662077f484c89b4dfd83372423a65339048ef836866a872a551f9718208e941e5d78155db05178bc51ac1ba8c822a3f2acb814525f56d91f30a2a2f1121b74d235292341287636b60eb57da2fabb49fbf714a3edc39c334d98e2f28c923751e7b9c7133f3833a7eb9124e4132d2d3b9fbd8cc3aec5b7345923135daccd5fc96cd2afba1f6cb55863d4e3787c4541b07ac7a00a63a56bb33e2b4e58300f34e02dda50bf74bec1b5bb9ecdc5aa0824c38bc1c54a0eb7a15d5cff41aaadf34e1f0729c82ccdf2a84592bed69abb2e79f1a6ccdd57c12c744089bd5fcd65c69118ad691709a94713cd4f8b9bbbb8c08a85b02b253a8db4139f92b59d70a04f34190a5dc9bfffdbb20d97b17815d651d4b8e34d0b65535bad082b5da1b1ac4a11f6a6dd29a33e2b4d4cfdce9477c7eee3ed819e13f75e7fd3935a7f6e9c7e7d4e6706023fdd388bf372cf1b78c43ee02ef6abbcb3c789779975b08389f5f6bcd5586ed66dd94dcf743ed561a49c2d565d4947b330fde8575ee4299b3dba6e95d02ed82aecb8ba2fa4d2f788884306b158d78d1f28275f28f8fbde44eded1b08a5dcb8651edf9afe263bf2dd32a621f39b92dba8a0f4b3460753b1ffacbea72adb98abf252002a8db4101417c1cf6eed285b74b975594400356b1dba659f6b6b9abdc605b9bbc49595e02b72ea6c60ed4fe41a31663cf6de376353921ae7570131081f0ea2708947efb21a56efb21fb3bb650247b94fd16d59c55ce8a3d761fd43826da538ec9f6dc0e3028923daa497ad70092869cdabb8ace958020a062afc94deb6f58fda7c64969d9dddd5e7ac93a1fb8627362327af747d78eb6ad9282fd6e15e209705f2190c562b1e0d27856fd03952727c5dddd7d484b0a129b6a2449d7f95ecd59fde84702bb544e7ec631c95e0829486c6a9236407ce64a35e464dcaebc6309888c2a716858fbb18c93e20363dd3de3cbec7c607f8c1d092bda72ca35081debe07a1108efef770e562d629c0f2cb1f7d681d6bdb1c7ee8ddda8f2b1caed33f6e9c7c23af906d8a57a27a10efeb81a81ff4988c9ae86af2cf706f26824904beddaa51fdeddd6f0c76f23b1ab61ab07b1da7a80eed009ac5446d25db854f88ca4bb7479e903c3ae078c75c0eef3973fbccf5f7e977050e2f18708620948a56fa8442c98ca9a5432442410000000026315000020140a068482f1804cd223dd0714000c7eac486a4a170985610e04318a216388210400001000011019a26d003f377ab5bb613e6773c7b7ad172515035068d34b4714ff6b36f4da4ef25b18a866ebec8c5ed5ae3710351334a1fa1a35d8d8b174c1cb07a3cddcf370caa0a4f18ca71e5e99be454e27a5bbd3b4d9de8b10fe01d9231f0e709c8260969bde5826edd42652b55b6554c5c67c4d7150b093502931c43656081818b8e4e561203835855b6ba3580ab49429c045171e75af299afe39e2b17855625631fe2efcfd492ec320efbd472ac454ac0d48a413ca6d17ac683863bc003292ece4136a8965134b23c12d9811a31c2595432145f489df68ed5a99f95d0190fd1c40642dfdc45792c4d0df4a89242691056950718080448f40d6cd63c0ea76833a10ac5466b185d102a1a4e7355839cb5ebea1d23bd392a94185e4cefe1e6720f9f29400cd831ec228dea517aaa5eaa7fd2751af49dde8252993126f0f9581b70a8d136fe121d0b971d95314e17ec59010fac9bb7099e2554d4da0ea396844a78753a088b156a13c35b0eccd07f5e52c5748f32479dc65943ed57b9e024b7540fa8ab3b360f07ad38f0b4be0d40889f2839aa56db96b347e05a1a45117722763bb0b7ee74d12c4ae40f590b045b8f6bde26caaf3b7f07379cd3891ed63cd382985e53184e3302c1af07ae6302ccb3d0162060a79104d50032e374709d3b2352aa940126a124d79d880190b85fad77cbe4de686e74b00e1da5deb53274074d1fa9f4eff58fe56dfe05ed1b5a4a9dc50998fa3b8bc46dca3da9ac6d4d5e4878a5ce0b424aedccf5ed6175071495bab00615c6cdcc45b2bc936a77e46aec17f6a6741608de59c18565aaddf8f9a98592c3e6b9420226b4510ed8b4a4a44a2c55822d87c10f7293f21a2a941620984b42b51d2a423d1325f18d98a3fb7ecfd3cf49b48e4b259d678e7efbc6f2b21d87ba3151f0b7b8d3b16a8fb5bd8a3de6f575b6f462d367ddb2d0d6d04dfa37731b791b020fce10a45e8bb872140ff05f1fe61eda5fdf7a7cab18fe24cfcadb5fd4971c8d79274cd9c019e3c3c79af8af682a2ea5bc6855f9267ffff6699908005ebd5250ce40f72aa81d73cf979c417a32fa676b7e582309174706aa7ba44be174219de7c7521a5fa8e07609ddd62350b69e245fcb8f7506f9c9f803b330f2be207b12576284b970715b935c7925b216a1fc0e73f6124472a400b158805e52178a5c404a1d65c916f563415684f90bf0fa7309fe49d7c9eba8e64cb5b9784778059d16543dd218e5fd94730d675b81bfe103fef107f1bf9ae58375e39248ecf4625eca9d31ecbc31dff20b894cbdf73e49911aebcb04e34fa05dd270cf385476397d9e7c91acb81c6fc04bfac104d93f05f0f053c667b47348c0523852215fd47c6913073ddc5efb8378a65e143b861c687e438d9cccb30a89f7072af4b2aa5199301ff23dba48c45f6ba662b9a912fbd49533e14de2da404e36389f052a431bf84983ee5c586e2c73345554642e1ca39a4d0220162bd7e23a0b0e6cf0b1f051b8b9c8c9c11da9a91742d3b660994fc5a78fc09fdf2354dc9570ca1f3a798d40b861bc03d4916845d32063d460b76ec4e5674535bb53b1631522eb46873e13419d20412c24cd02ea3b0be9780bb0dd7ad4a4146a9cf9bea45012b4c3d643de2613dab88ed250903698938a8acc6c28cd685da380aef9d36c0f5a0c1815936a268d3e41957e15804be307f9ab066f5d8ef7701c57a22b946c337bfc63cabd55d7e2f1fab31951d9d8aefaa2cc918f74e3519dfba80947184987f5f22e05321df6a8ba96ba6edbaed4521888cb65a410f893c97482b2ed783d89a103583856d1e6108849072e3036ef39f6e76fe4d3a4b6111fa7badec21f45caf9efc9fb8331219df48783a862be17c2466eba2d3679f8e1fa728e84812dcdeb1c4e0d023e7f32e1f0768fbabe1fc896184363d9f314006a945ff67042a23813cc6b53ffaaafeb0f26480e5458c774b0a493fc8f8ead0774708975ca0d9a4069fb21354fc8037cb3c8849c2fa42c7157b89286b2da1f412556e66475199af4e450d6169a8cd68e07a65ffdd4c2857be10f02df592be35e5275857609e02980a7cf32b77ef9dfee5e6ebc6e5c675d3edc675d3f5e6f5e675c3fdc6cd6eb8ff19b99fbff927c4c5f109072ff7473bdd16df1df5eb8de6a5ac0df4edb08ca5579d79dda5ffe12a1d1018cf8bbe172168e0a7bbed5e2abc6d54fe26a8529266ba3c2477e67a6045d4e2ab5ef98173209562a4e71023df1a619548448218499e589ed90975f1c6d5aa394337c2e32f214e547d71aeeef764a028aae6798cce850b3f839ccee4ec37a4be16eb11e22033e67587b863675e130318f1d1602a414f824075f8357b151b85f110723038cb02bd8b462c65d0621e7993f4635267c8ebc5068d3df1cbb41e9b848967f232ed17db6dec092ff3151bc2658e3dfad7841f8a1e56c5e60c4d19dc88b4054a00ece8b87ac0793ebc1000eec281cf8b27615aa01f25e3afd0b8f7ce03c7ef8dd00898ad28e62dcdb11b408e27de71f3321341d9a8deb9f2f2db0471ca006148ec19054ee8302e35d9378e072dfcfd44e840dc61fa2550b52af66a96937c8a8cc5fe737f43c1a2f6591404c2729e645b9487e70efa7ebd05be6287de044badf7666c4ed4feb51193f42bb9613f79e293a96b204aa383eb9f941bed3347eef13eb25af4434358111b3096092ed31eeb06334504a4edf4dbe4ba59e782fc56495355beb7c5d6d9440b7a6e9489855ecce444c882fbbde221ce00c275921c6f93d8ef43ae1d47815c49201edf2aa880b29edd166c1748b11354ac7b365c6a14749454893af162fa8b78e3ab25bbca0ad69dcf3c3ab34d3a48ae6b4bf76e97a6a982c4b8449ac10c405c6cf077dd54940365253560b7ee4c4b4475403c65d28c2c759c53d7097235521fe5f5a8e9429965a43a6f548f83ca70427f05c3a35bed4bf1b4a95da7265b2513beee10942f2ca95c8daa5c073e6030fcbb60f5cff4cb003d2df06405e2d2655def0b0a1a7243423c409eeeb5d22a0f4cd2714d87459b6095b510db21feb7b7b4715c9b615d43bfa65f89bf941b27c80b1f41b48611daa2b11bda36c5bf3224ed2a4ceb1a377d3129b3af4a492815c298e734fd96cd5c056a1ccdb93527c65e4d47f11ac058d550140ca90eb39517638fddaace56822f30768faae5237e1f55c3d08f3a6321bcb90f8a599caf72c97404484e985f8f28e3c813507c10d42ba427ab83cdb76e86856260ed86b23e5a13cfe74041450f6013d516cb0aea6afa82aae6d1ecd1cfaad36d8a85acf24419c50e63da3ec8ee934cc4dd000e177a4df31d369901ab7670dfbd494b27a16dc6c8e8d77f585cfbf0c45bc9c8dc86a4584bbc24c1385289310d0e0cad3efd8a1a862d8b06074838b6a9b52dab0827a2cb60646f16cb4323da13615342c9cbfc866646e513f53a5b4101d92eb63cc811e198a2b76b99d21454e32f02d8a06c56446e4f90783f0d72ad3ca1f7eeb8e6ccfc8361495f79a53e1077d316e7dd8758c5d582199002e666a8a5e5c64aec2e37384615abe9c52a8eb4e915455144c7949fa9b7a7e69d81b275aef28d32a69e4cd4bc11e196cbeec649eb0838cad87536708627419d5799538c0924276af4e10eb867dd6448fcece16ec464d78856b2b40a8b2cb5745685d2544bad13666b4230d19cb5ab9ce9bfabd2a3e7f6df82b02e744bd312434e1c26c68a79f5a8d9c56eeac28360985291f9b020d4a4f30fe1c1da0668eee333f91d4208996271b57e39e7ac239b24d92f61561ee335007e08b3ffb5be396983ea0ed3dfc4f24cf8d3cf8a8f4a662870e057ce0924d031c1ba98bdbbca5dbdb0478352e6478089d96adfb243cd5adb2af412ffa8e85a7cc60d3bf0ed0fed6ebb638efa405bb183551b35f27da1abf6d5864845270eb8c284e1510f8cd8a8212aa13780eca6db6a02a406ccb9c8b7322c2779828efa72238792930b88594e3f7b14bde0bb007708869dc115327065423b7671e35380a8476a70b0c4ac28dc9ae62469a98a29aa88658c1f1fb472ea88de83eee85c72b295165d8922a560e249541274f441cea02cb6b885664052e1022fe209759114609260e06bbe326c2e73e725dc281136b5cf0417abfb3451ae9d83dd52657041ad6e7f70efc4b97ca602623581181f991d06e3e3fa25803a78d12acef6caaf1607127900b7225dc81e81cbf566ab1d005735278e026e041f3d10613981aef008fc75bc277bf243cb94f7af030530431d817a0bf7132e252fb3b6c64c6b5ad53b29290a38096823f22a23961fa0289add9851277f335edb08e90ce950575c2178dff053d927456ddb8c2ef58e68148685b7c4a07a1e429f28a71df96ab8b68d294411dd33ff1137600ab2399b1a2b9a9901fbccaa97fe886263dd8b4ddc7115220416d52dae0c3c04f9388ecca5e76ad5c84d09f60cade4ef45443733f0bcc55e1cf9609b4ac71636e7afcd59e03c36a9e2fe72e2de3108d2f1b75e8556ccf2218a9739721968add49eade57e3ebc15328cd1332c0f0c0e3de997b853c3a6b134da6865fdc8867a7186017dd812a1cb9026f321e49c27f409b26906afb980c5d95ad2042394bb1db3a7a094b4ff2eab417998f6eb7ebbe7bae9369b7521b6c87cd9a666c302ba0e4deea8a6904a0fb8a9b8f920420871230a3a4eb5e4a9282855b3b15f7543117832439fc1e7aaa3166c2bc45db3877a3b80569c606268bf6327093146a0e035134298f03c8edd736412c2ddfea52cb484618163e0b47848662586d1f4e19a6d17da0a561a68af1cf04c62c8760cce06f41f09ea0496fc186c4512cb54d265344864f81c47d58c043438485835d31b1526da80b46a3bda075df8616580db1c5eb11d701de4f37e86a8f11eb472ce4ccedb8884f038e617ccc486b6b4b34d7f39670a0ec2a013ec0b99aee1c2d473e2b1922d5b8deeb2cb9b359ab4ffd1293e64702c53a927288d6ccf579387a48622df94ad0e4540b3c0a4b5007de1ddb3d64caa4bc2bd52c75c9f901a973a0a41850961e52616f6aa27e4cf08c205b20704fa84588c891be84226479e1ac6411715d6dac3c00855e37e8633963f0fc291608a95132c856caa8b9b5a6ec7d62a15ac6fb4fea54299475597523ae48917c093ca6ed24d70138c4e89a67e8df9bcc7b7998fcf8f6c32a4f1d5baeeb2ac984c382b70d3d1c0a154c5dc28d60c2adbc70a01881e7d67c980f2e336c783399058070b2209bd4afd09e929226780fd5baa2ef7ff464031b05824a8ac42e889e85d9e6212732f4c3f30d3d8701ab37ad231a655a1ae023728a303557d5e6e98b68bd7da95b7b15e9ffb6b4de2daade39c9abcbc619885ece1414cb595c3bb9132b41e142c87403adfa706f0daef98af834507c9c0628962ab657a01d6e07e5aa1365d2e248eb7cf47b0a5cb42cc2b3c32f91000102ed721b51bf1602e7cd3d5a4f6606c96b6f3aa1745aa0b1a8ec0285e46f0a01d91c846d82b83100475fa9ed12250e13641b51128e5a69e7e123fea07aeeadb0d1627483797071053b81628c8bb42d0f5bc20cba0c0df9e844854704a116c3714381c7478f64e1daf2838d8fe7fcbb629cbeb2c21c3e060d1d39baf60068327c9284575ec96a8401c4791cc48ca3df2c1a1b421645ace5c1f66139222dce0adad47cea0174ecc3a374aa3d1f2b5e3e8b48748d85e3a940d7352a805bd7c9591e549b6a6330f31d851531a3f2780ea1729b0bb145e920610369e00446da2a428912e1b8509118fb39029bde68cf02093b047533bdf8d114c2ccb956ea7a1b90b6d63684be84d37273b9f06e65553e8ef6db3d2bcdb4e2bfc126edbb54aba3015dbc3e4227b96648af98671ed6d286f375d6dce40cccd60d6b2c34f910ba84dd22aae682a23a4676b7e34f3f9e0f347301ff35be4b1808765246aee8d0193030570510c2d16471e8620985b52f82282c0422a2d603a3d387599e1c247324cd74b6ddc7ca1b1ecb890a1c857454728a2b0474d72a7bb5163fa5bce701076dda943d32e8bea413af0e13253de6aa3fe9ec13016f30b828bf3be7fbcffdf3b36ef11b2a2bf4c8f95fa36aec40f96d5ee2085578b8008530dc2dfe6fa573f21702dcb2686a64fef40160e8738c1810b2ad7c298d37eb0a3953985f0af10e08d9ae67041d50d800c38028a0e38c7b9aad57b24752a67db9f771b5a959570e2efc39c8f900a6290d66f26cab4d3bb540d069ddb31bbb7e96d10cadf7dfd9337b95f65e006f0dbc8f732293c510cb8530fcd93e15e81564ea390a80ac2876b75f24e3ffbc217dd7d05d35bdaa11bc619e7734082034c7c485d2d4041b9610eb221aed05182242cde059461c3c0b818d4a0c03c83bbf864ddfd745f9a937ed2936394287350b4ccac57c6601b65ecfdf0a81c70e6e285dbfa38b2c47654621f002f12c1b33a5d4e23b45da467eeb6578f86f6840cda781b221c3f18b97ee9a2dcfef2a9c7fe16ede06004d067436990090c2585ececc6ee86964e02dec5de68eb3c64cbd016e25746bc18c491188c1d2c7fa4115bb05d1c8285ca51bf7090fe68ac50090f3a140ae70d88afd2d085b8649d146923f1facaa537badbed807b80d662ba08b0b728dd9f2e1193419b1a45bc6bcbd2418c07ae1b037c0b225487c7db855d19d05c4dcbd3537765cba5410df7b2fd08e030a4ac17b207bbd4cb9dfd6baf0e3d31db8918784055bbc3bf077316ea1dbabf74c831e5f7518556550d3e372ac08b28d3082ac26f5b145face5a8253143239e8c214cee939005d1eaf77063aa72b7e1bb6f656eefa5ab54d451f953ed61f788461d8cd50279074d341d1691668feb7ca4858e9d6c907e4e2401c4dc29077416014ac9f1345935b8b59beea17ea7d924471b9efd8c03971ae0d9bd40c663029954e9068f3974208b688caac6b1e90db97312e01d8d8cb97073cce05fcf85ac5fcbe831613a58299f07d9869d42bb3c84f0f448a1d9ea9850a457d590353d8244d423ea95e07fb494530d5ffd538fa03b85484d939dc0d59238cbc4726f7139d3ab699bd6a0aa99ba728aa1226a4235e6c09f038e7d3d3d28ca16ce021a2fbfd85c90e66281bcd2124808e92d5f1f9d46baa3577d93e58ebda38671baa9a212651f8bfc72b61bfc85b80da9f4d6aed850fbe6512c3b1740236bac56463a497df357cace294ae31493ccf5915e9d6313048da035c809e8285a23b711052196a82eca830585de3fc564e83cc0a965dc1b25cc0432e1db47f6d89c0969505151d5bfdfaf4cf02382dec9ea91e409b6411a26b5940a1bafc3da0c14b974a5ae1ba534a5afd108e6341f8f4f86bbabd07300007223fefeef8543fbc207342018e957b88802d6ea17b398ac4cb5a05133f6eab839537f6b0c89133f3a114aecab88bb776e409612419f09dea656c16b5f4125a3cca32a2c0938707e3663d6b8b2c0a982598d9b4c8b30ac2fcf5a71f858c0f121e871a09f8b2b259ddb6219cee464432e93b2143d405bbb5f30dabfb20260b2bad0be4cd45edd8979dc1905b57f50652ccb16ebf50ce68ccacd66f35816138e06406d5a45cfd67d1ff2251c29fb378f11410dcfa5d39886f3d6d2e13838bbbec5936ad912c562945812d4a02926e50fe89ccc29001572fdd5a0bc87c1213e829ac54a8bd5e39294e71e696941c1678698f5c9eb4bbd0c5b3dd834b54bd629eba7d45808c983b1f6556570f3d2ddde0860306105f3ef18b52632fce3f7d8511cd4d129180758890113d29c1f46e3910a1b7fffc8478a7e15a0c8a86510861614af5a86c66240533f6e2f5e79a997bbc05bb70fe5c69bc5c0dbb1242b2018f684a596e6928496b605db8962f91ad2748132247db5855f27989e869b4781c37df347cef335cd61ce99393e9c78dbde19e55099cd48251574931e615d6af68fb1830e742b6141c7347d0fe89f03866d4665cec8e188333df6a8168510f52a929de4180b4dbe97d2302d4dc733d3d057a0d44200eaa8562a464d429005cb804e00d4154df4a7e7572cd8c56c6f35b860416d80f4b164945f3551ee171b0e922ee3dd3746e77432c27457e49c9baf2c463c4eaa5fc1b2e55e84142773acf6cceb70becd25377050d1901fe5dc4f82777651ca2671a0994457372a88617f47e896365fb7d0d2630ef70d250fd8ad269a1d1b8d615d45b0e7947953867fbb8f82093ecc07501ae06f0699fd383e57d23427fda748868d46831683a375a0f2d522b6bb988dd8e5693d693882cad11b7fe74397496c79b7cfacce01232020fa2b13ff0b4017aebb24b37d2cae2ba2c8680ad70684ccc01923369eb6c08b2ccf3050a85baee3b5c7657c13bcbe4df0720766037f093ea6f3a745f7031b3367d24ac6f694e34c533c47838623335f49ad5a5f7b85e1980283841adb9be0a4b930354214391e796c051b3523d11987dbf4ddcc3aab83bc818191c76278c5e9468d01a3e9c3e3d08526d9c53b39e550b80abe04bc2193989f124ca73b3e4d373c7672e2df8d45a78c85608d61c02f81bfde5afab9fb845ddfb173d0e7c7719f65b89e3864524ed14e54887da35e192aa967a49e8712947449ccd465497a1e3f8e5aa4a56122385703260e781dc0e123be0688fcd2b4f655523941ab242aad40c461dc386c160a8ccf39ecc017c52d19ed38d1772b5c70d74e2a53232b020d75c6a0bdcec0d2a7e97114ff66f49aa358b8ab63a4eb451d5230351e20ebcfe4c6470b9825caff1e82b2d7fed3771902c1fbeb6dc2840f31e93b7bb44c18ad3244d152521210510b6e3d507eabfcc8f1169b1c503631c8d29d95fcff95221dc492a06a5d8f55decefef653e219e8d2d9c655507fe0de978befb3b694ecd660db1927c5460fcfea93eab27cbcbee0521ccf339dacac74f9323b149e9e50eba2bbd4e6d6f21c54e2fb489236e3266a0b0db1f27171b70148cf8404324384b17013f43c45f32690e92d3f36d24a32aadf180d936ce5e22a2f52ee46923b44be6ef6fa2e25bc257dc63d0b5ea5d6b7f54ca1e233f12d5a6c3dfac15e865f0aaa33e5d4b3cd44b62b3621c592e312da4c3884468c861b7e9ef5cf32d613a888320b8d506ebd336f404b7532da2bf93ecef13402278d1ab0c3cc38e2faf85a00508c675fc1dda1d407af9c9c9f0cbd45db155167fddc2a4fc702f7dc45e1205759e50691d2bb31c9c6ee900b63ae15f43c32c99c3d7843606f724374933b22405aa81700fabec8d034a6453f305f68eecb3883a579d90febc625194b9a84034fb72a95386aaa662e6b2b1e6353d5e3416ce3ca67e7463845179c43f633199ac4404ccef2ad050cfc2b1c575b368e14d928a0759f34664f3d078e56b17a027f3a62e19cfca5bdc81e5eb0cd7f73aca6a40adc8c45fd6d3ccbdf78362ca2f9e8e2f07e39b571dadfe9b08a959def576d7d7036b8421d45ddf888e6a0cc384bc57126488d1ec6779d9469f4494e60d4467c2e12223a7108ec564e2925b9e8f5c91119c4715a42035b4291474eed855cb294d69f232029db6b03b1a1751d34b038dbf934eb81d46c078fcb474516e9e04e72c4979478a2fb8697715fb18114e0e0320c3bc5e79835ebee5fb3468706b1d93d96fa2a3373ac7e5e28182740483bf5918405222e13641475310e63ac60295206a11fa141d1014101a4fbd0565e8845760fe424294b458a66670dc144aceae853a3009b12770926346606fa01cfd1422cd536bd7a34849d6d331d7370dd0adc365ad720063013bbf393dbc3abab4986280821944fd81837a65850e83eeae9c9e52c5fe403eafebc83775203a14a3d0d351cd0f0b40f6a9bc8340168dec8e6aa8b588885f687a1758a2a894ee7f7e5125d522cbb5f0389764815f3da7467e0e88f3c03ec8d2e15bb01ff53e5fbc22fb4211fc0dbc0472aaa8cee97bafc190b33b3cd1ed1bb281cf6c19c94617c5f496752448656e1abf3e37c3946a25845c2efdc8efe6df563c24334103132586c1aa7627fd95707308f33a693e7849698804bc99b6b0874b5e8ef94414c3320406021455faed68f05376b6290dd288fd50227966070afad681cfbe241ac50155ba00279adfe2a6d842f14c6fe54115efdcd503a264cccfc7dc9095ae909fdbbff6bfb881679b9e3080c4aecffbfcc043d7c2d731a652f60737a209361500c02e0099f2e9befd39d5eabba98626baa854beca1d51cdde819368b67195d12a0c3e7f0bb7df218d6ec85ef0757e764b87d00674148dda870d6e5cbc4d1476b30890f74687b7f64378da481c37183347c4143b0daa1aa4c6cbe35a98d9d61175204c73603e6814dc6cd00953b0f10ce6a5b3cbbba2e703c9fa0879297458793d95ca1575e03ff265f9a9b569383dc5e94df14ba7204f34aa86e51c00df341bc3a8eb57df6b135f16b01bac7da6ca265af0e8ef8e53d2f69dd9cc1b84d0a1337a8cf0901768be4d5a23a82deff1a7f68866d9280d7df16417bfca2f30ce5b117c81c7a2b2cf789ef2372465e31a9524fa965c0b0a2da0c325d0f69720d25bd49038ab1cee418a6e2d4b8a129f9dae8d07e64adaf9cea2485f477f03d72609bb99b0ec600af2a1e0a11946d18910f495872d1fbe0e3090271c03a9e74095da90234ba249616044c3d1038eaa3183a8aa9a8c84d3b673c7d840476830e244d1b19e6fdbd6c05bcf336eafa2128072b3d97dd345061b144c4bbcdafb0b16db59a2bfab1b847ea40d183c1bd7730787bc1f91db15e7b758a966992baa6837608eed4519ba45a1b611564788fce29e0f88d5c11a26746c6ee0a3e3327efd8a31774adafed080d4a49f3b0164903009f97ab9e532770ad0cef7beffcb607216eea8026fb497d6a48e4c0d8706282abeacd1a58bd876d39e5ad8b54e78a5f28881af27653c3539fd06f6d0d66463bd557441440469332b0272793e782eff237c73575fab3a030bfa284526d95d89c1b9c041ff0b68113ba713e191e2a40aaed97bfe44420a1b0954480d8fd5db81aa31e003afc0c292984250ed599b2df105124eb7afef43045f617c544424b07f241d151509992b6f19c09479a5c92185165bc595bc5a2e02b72bdec2eaa386667911b5a54d2c1f9e75886ecda5cc1a5af1ff3203c863f98a20f342da55da62b01ebdc48c93d3cc5b72171df8fcb62b4bcdd533d90d493b07ad2428261984a075387f702adea3ff1446183ca1bd706d870f82d6fdb22c8ef905a7cf0d34ff57570eb262cfa2e6255c331b4028c215f1eef3de545e069eca52d5a3725b57091296aae4b1ffc87987b28b2e591d4717015e6319c4182193e4269ec515993a83aba7c21b935190e56dcbe33aec6d6b501384c590fd7524464c370043c2becd636f574dc18d26ae1c27909b428be71190859d94ba77d6d64151825280178286b0fefe7f6a5cd8af505d0ba29c05bea2556acb0fde62878136fbd99d26e290816ca8afa03477d6be4b0eb4112c5bb7dfdcf962828bee15ebce9ad9bd001771241604289db16074947eaa6201a308eeacb2bbb75360e4ce80c32a2d0de4028c00d3a9ac8af175a42bf564b87579c1cb37f065751b9e53e067a70683c34e02bb34b95736acf6b31605654b86810ee64512a751d395159f52bf1905d156b3ab709f68b94b976cdc737eb6d96d47b816e91230cc51ac78f7de223c70364cc2214a043d4fb9349d26e94309540078b1f1472bbae0e84893f523c31440cda29c352a067983868b1cc4935c0981a7674a89c48fd3daf4524b300b9956e54e9359ca7016a9f6c29b1fedbc99ede995b41617240a0c9ab53a72b7996533f3584d3e2c6a0011346173ec65ec01b23578c0c358c0fc7af9173b081689c5930ee4b510967c602eaa2fbc28f56e66a41854363cad7b2ae0984cfec4fbeb4e96e5d559956ffa7fb02cc8991dc870b08bb8606ad9455950e9406c6b592f9d210950fe58fdb8ac101cff9f60f0b60fdcdebbb473122ef8730552e1479f462dad68a993a7dd1981b21634bbcbe9294d41493c87ffe26c1344572f38ff84900666250402bbe0fc1e86ef30d48521463e973a42085da45dd18ed0c3d59a56446cfe06fb8d63941d79a62f20715800baacf3fb40c769d0a7f0c290dff1764538a7e37f65a996939fba1d841ba9b90abfcc65e757b9488d38f884421da665881021f1c4365f1291e56ef5ec76eeab0d204c54835f82642a13fde36fbb80ebecfe4c8eebb56b13906ed4dd22829b48a0f530b6824a262be77b9171bd08d8c7154f5c0e90fa4691d8fa696a7835020c1841c5d549679d3473b4f07d3774390e8fca31f8c8f30c524a5eff708ec4e0f53b3ac9da378119046f14693918ff3499cbea0e0ffa0d6dcc21857c905c558d5039e1d0505fc174d2faeed90a3d1a24a80c6b50919e7f5af72841c03bd895ea3ec4c84fe85075c307e239f915c38262b98d49612ac3aa4ed0f464480ad3789251b2131012e1bea8efce99b60d8bae984ecd3f6696a61a0541d275d643390998aca62a9789c04de27e5644fe52182ca337614e3961df5ede92c65cbf8a5c6c0cf4045c229310dbfe9ef8a3a42fa34abc7a606e7e69466f8486615ef139d4e257caf13eaf634f6188bd04c037736ea6a7bf783463a23f40802f43bde08c80528aa6422f4b869541100a3ad677c41d28185c86cc4c3b509dc01dd1581a1f09635c547ff7b3bf792cefe3d3104040fea7302438492345dde3ec9cb916a01891323a9c34f5b38ceabe47c1919752dc444711de5670f702142570227e161541c4d1a900e32fc6b09b4e1cf4082e676647ecf0404c70c575bb90384078b340a4f4ae76c5c1ba1088bd518c4fc14d8c32e0cbc65c0a2cee3fc6edd5ccf2228f93a93cd622082c2cd4ee614776d45c67021e28ee6ec77e8c437f85d923ec6375a8d3d1500eaa5d465d08b9eee0ce59b9191dee77e77c37695a57a546d13b9ccf42bc8fc5bbcd2f70952921c20694411858e0225ea94d7d86d48e046833cd401b72ce94a4415233dba5b983e06a662b69f21624abc613d80398ac2177667f56489b48fb45e93c95636dc8c465aab680f040ab0c773e10e05cb129703c1000b5fc0dfc4f32ba4be3d9c738a9d6a4086c0706ffc4d1ec08bb5f9fa7df24a84a3924857410f2cd3e9186b42a0010fc0545b644de56e9ba2f209d9b6f95b8eacddebc8e2dafc10acec466e455d186e27443134b6e27f591f096de8bf365756a7eb12743c33ef03531a8e950b450dbd170524385d6d2ac9469357be0fce6a3401f647c3dbe8e8343f13000f3b624ed16f704855cf53804dc2af0fe7210abd5319f1f6558d5ff40a4323601c95ad2661046d2ec327f660e6b69aedff825b90b6ab01f5354e03d653ebea6270688e20095c6492fb5ebb6268851e95f27e167b77b19797ddaca6518d7283ad3e5eaab8ca880cedc37f667688085d4a29c1d791e002d983b3c31a87ef5229d3083ded95ead402b78f716989e315619b641f11203eb49b1a451b00701383e382e080c84d2c675be7eaf48452879f88d7516ca04baf1d5fa54d610f9798cc7928de56bfaf705389d6ce4438a16b7848ebb9f6ab418369c51f72f5bc16e926628666dc63148df66686deaa9d45aa2f36e54f14538ce105ab35ac04c44567be15387643ff0fdb6cae0ce9c3a85ec15cbe485e0b4e96cb12de946be7319c3527b8cecc58fc1a92e687ca66005e87e91fa5622e978abf8f508316a6ca220445901048167d8e7bedf98347600101d1c120506002028eb1750ab4c2be3473d6e4d0aae7c2cef6f8577a200bb1e6554b26de6e965c2594d76ed3167b341c0c49b48946902a4d808b82e1a36af0594909891cec57a4486581e37c04c89daa2181de7104f1c8308604ddd1e029b747f9b7af0f228b8690cfc0c9b68c5a34fa7c4d078dd5577bdd7bf443d9cca7823fc1635b5c0fae65b621276768c030c35d9d073613591d5a7916ecf5af7cdc0897fb68432d9e93f25ed5318b86a6a0da8e4126a42a011be885f0bf5df2071412bfecef2b8cbdfa90bb7e2ae8702e85bfff1e732bf541dd2cde0f5e39f498b65be3b83933cd624465b722a4e52e3038d4efe310be15d4735ed0570be421de546880fff9d502ea49ddb98dec4eafee9c93fb1bfc77461fdc35fb034092401cf74a125015b6f09e52eed0138c4ecd49ee64380515da49957512dad8ee044eef060b7b1debc48358e596e49f3f82fb38179e4d3fb25cd99af884caab2f6764613ef18030df31784ceab1bb40e9382f4aa696f334f908a370ddc14b70d316e9ae93f82b81b2e66a5742bca027acc94c7f1290aaea9130b9ee841123dcfcf6abbe94fc70621c8af7e09ad8b3cd3258f3621e1622fbd99c661a8431754dd49f7dd1bcc8a40c81628f2c0df6e23fb897841dbc7b82c2ab877739ad4e43f7466a987c20c4a4bf0e286fd1a34c02194c46280ef30eace9cbc62dbb1c21be78599d20979a5d8a4ecb31b5e8125031da50d8b3e645fa062639bd1ba340b2e22fcf06ba4bb2c58424ded7fd7c35068966bc859fe48fbf1c2e770cb89de049fc393e913a487a0c228c6c66f564f60d4c248247a51912a1b023ee9e92d43b3900ace1e1ae30201bdc4f59a8bbe512220a65cab16b6e952e0f98c7750bec33a11b96bb3eab5b03b4e03f338748eb3482e665a6648a6349291d068c522be61da3689a75749551c5c9e82aca10e62b8f05bc3e2882d4a30edb55d8f1b3ffa6f2d10d26f52b9a38e590aaa0115e0992e3406e09270f03a3093b26d5a9feada1e7aabeeccf8fb128be603fd7313c5e9754fd074a6e533d6033b62625ab2cbe7f47642cc719654b3b96f7aef73402b1241399e6f87b63dd6fdad57aa28caa1fc35dc11d0f6abf552a2a6a12b9739d226eb8029cf4a6b57114104a492ad170fa75e807f24c175ecd20a31a3205e51248fbbf7907e1887f013634fc21fb051d6036cf8f6dc220ed39e8d3056beed5f593fa00357b9c17327d14c480683390b57888e0aef319fa56805642d9c58965676340629f1729becedb473059650264b1bf2d6e595e7eda059f595a7edef8792c9e5210ab5322f509ecc5037e759e8242496f119a56d6d7a6b28985d7c10e23dbbbf127227460fc439cd8e9c30874c80c2a1951c1a15259f12644173088300c6b80d8b840cf6bee1f2e0f98414674ee7f323538b29a5f10736aa39743978479579f40c5ef5832fa211e315415578162ec1cfcfc0ae524fbe754e3c15c56adcd7e1d1dcd0cef8b9b7f1278f56762068242138372c5edd1f883f9ec903a12333966a5c71f6293623f7a63648e5e3d7924569765104b58374ad2c2654158b1e94c3ee075fe40b20c52c3da7450fa7a3bbd2830652121f56299af10a5739b87328886e26d810334f30481695bdfdd04650eb668628b8a487a6f045d423a90ad6fbd112059bc812c9791f9c4cdc9d68cbb791b19af03cdb7756b30e9a0d7041b58e091507df2eb039052d947011eab0a72046e9c55bc1a45f708633ce5b5cac508e2018c9a512fd48891f21888094e6ad3ab2bc8cb4ae8c804e0ce9ffcd5004872d3045cce3680e2f676912562a57f6260778ff8100ed544454f6b672e27f5aa0505ba5a648c61c13eb16579c76fa986fd82e6cd63cdfa1606b17d2004f643ae1b0fe0b13f3eac65dfe906376bb02b7e11c17438ca458b01733af6915ee5b8690fcaff7c0af759dd167b599dfc6cf9aabbca6cdcace2a94deebbdfca5c11e917e64cf961cc8c29168c410eca9f3f24fe23cacf51cf6c8317f69c2601b90ca761b92f3e2c063f5df41f9390af587acb014f8a19714c8de40dc0b234c71b2c5a5b8382c0cd9cdd1fc6e1690d48cfbbd17d60e0f325ae3feab4f9b7ac016bad58e96687a308263be84c924c03d663617ef8b2f88ce62381935dbf9a5b275a3ccebc298080083cff471d819e23713fe105c30c203e9ff99ae052fdac47aa6ec924e5a53831a5fdce3251ee85824284e0b1f45676e5cca603a45405eb98fc64f4bf8003d736e869ccd99c66fb4f4b4ef1387e0a145d81eeb6acd91d7ef274b60470a04a32d43fe53f98c2475149ebb0a425a3e87d8a16d664e5073abd6ba43d7748f54757d592b8c4f857b51f9d692a5a1b4620da0d95a48ee1b2626b75cacdb17a34264f91aecdaf6ea5e1a2a381a92af3546c204fac86a40a2f01f606264f4067a902c4261e1af98007c2c46e3148784b0bcd7ec6176197d64b76e104d7236eb577cb88ff4a3f6530b4bd8583a5d100cd02db88c64b6f5a2a456284cd022cfcd2981e8c889eb54464ef1650c1b0ea803974e05d727bc01723ec65d5dbd2c64195bc2f02acfb62165ef97ebcca9295ff6a31bfb96ed8b9c43e70b0e29d3925d43d6d07c1d058398c570da909dd23be25bb2c02c1b9a7f1885a5d0f7bb13317c76a772e698369948411a38a4a8161d0dd8be8eefdb6314702ff4ca8ef02da3500cf1b399dd291d086f008708614a1a5dde41ed364206e13f15fb00e54e5e4fdd7580e5bb09b507c542b09e2f46a82d558e6c640df3164e51d9aac1864cc9b982d6c8057ae2d6fcc31ff22533ccbb95a2df33566e071a306158dc01efd77ca1ff1a7b661af5d15330f2ed55efb73d8008efe6dbea3c03743cf21e8f5a6b0828900370badcd8df6e51610c725378646c5fc300e886b22104343ea1de191b41a05796c850e3b59c32983dd6feabbff874253292c6e464e00442ee1586b0b9452002650b7e147c55ea8aa6ca6129ef227f7b6d7c13442e7b01f48d98c47870328d9f961d9bf49911861d935cb18ce5246b04e0f3058d33e46a9f28d6e156dd62b5c633440c8221d71a5c12bf5b6104acea94e69955e2119ddf65b9fc2ad3d5a0524ec4fd765ec97cb9003135ce31d674d239b0a16a59b8021dd91aa215589618ed0b2e3fe62c57f42d1ed600707b5b764abf009daf8ed9d54d458a4b7d91f51a8961229a4ac01d6cecc9d9c1e0125eec0f2ccd9bc400e3a6640a1683e8596760ae73bcd9469bcef912c2109f0675eca2438a8313e7d4c06e087d1f8a07d8f50fdb963142c75e43d59801921701004f08b3ebee574a90c92066232a037b9fdd097e325f300b6f1d6793961180ca73dc58d9d5654cee84d62027f215736c2462d8e8694ac8039633419c563e7e0eddff8c591c5bec7f5e34d809d010301a55c65272a1d50418c7ed0edd1886e49b62e8e0363bbc8fecbc987fd5bbe31d1805251d88514cdfbf7d1a113504bf64133bbd776d5af1fc3e7785ba58d4334fa0033e20b4ac56974ea8b35bb11b8de12a3f2af067742f0774b2cc99645e6e3ff048887514dae88af3aac78f2257a5c627134c40a14aa10f42c8183d01075a6e60ab94012e58a7164ef0d714ad96b27d0395a7d9df22af6c02461e475fb1c03aca0e515831ce2164b70877ea4f359036289e1c257963aa827eeafd8f1a184f3dbec109f7728a9f03fba01846a9d7121c5bf6957a00a3c95e2e3effc5cc96c214450a383cc00eebde608a37f6e52c53802b6820b1208622bb870204332df8cb425c0230bd3faa6792f514462c0554c96b39301f7bc884c07d0b2b0ded407a6dc6829202e89904385e4a6c2d0bf3550ddf5007e5d4a18311882362ac5792cbf12b0ebc6aa7a358f5b18a72cf9821d7f804ca206bc804a0ae734bc86573c67e1df8b8e5f119274766ce6e6ef295af6706876065bf6b7535256444c58445f70e80901587d9b333a6f9dbf1440173af9e1632565ad9bea741eff3896e64f17d73427b24bcdecc50b80fe31ba345c84fbc7b3d82722a46070faec51879c1e5fd0b854eea3e09e2c0bdb009a06b7d5188c9aa1f904185bb3bf1fe192b7eef5ef7791c7c081d986b0304e3f9d3fd173af2d3bc06736aa03f50ba787f0d497509a0cd7a16629853dc84a8c852cb0c9b1cd72112120e5ac57f339af7448fdfd003dd04ecbefb19fddf55778b869d191581182c84da051f55169196193cd91a6dfa028b2e6411c7309141222c2d61947e5c5230cd69df1391f3312bac67045c1adfa0caa9022f5cab051d5302e36541083110d2abd78e7e1abb6222e1d488dd89a20e75a1112c001c4fc9f8747afa88516463aa48bfbe606a219dc30cef0af2f8d90fbed0344806558cba64997210f779e9e45f2b080c3499416fbb3eac1a978318ed9f4fd34c6fc764a689177105047697acf52d93e8472a3190c6798901b36dadae0864eed48165ce57765d61272031a229d6605be903e38b3ab044730ca7f0bf28c182cb4d892ecfeba20ee72dd13d7bcefcf92a053ca91ffaf301a486ad92fb396cbdebfb3920864116a41a1d9dd27f5ebb53e4dc6a6fb4d656a6f4678b7197132046141040add4b2a135c027da490c22ce2ef5fef5d569ab94275f00b9be8a1055fd0055a19870788f1f37e61e9bc24c8b4f1852ec1a2c3e622a73ac3aa7fe57c0d2ae1bf372047d1dde0b6e46069d71113e34824b9bfd6d7206d706b0df6b389a17441954b45665bad78ec6e24a5d222daa406158ee49db4f3d964f8d7d908a132a805b65b5439f62f2a679c764b7260c2eaecec3a35019a0ad9fa4b35be9dd113fbd9e3858ea8f243c038bf283856a14642f6cba12abd3b9c7df3843e148522d2a5906b93e035ffadf996bdf6c648c45c84aafbada85302d3053b4c9ad653a57490ae578358f6bbea9901146417586e9a11e57cf050a4d574fe8087db4b98035aa6e4c84c416f19832c0737f5578829dfc64c38ce32768adb9c81cc655ac1d12e19d0d696da098f8cc2d10c66a7fb8b7004e71f91376f2f35230988784b8e911eba83ee469078ba79d1cd8097e472ecc0d5f233bb558e6dcb17509010f71c225cab060d5991004bad2014e0ff4eacae4337dc325acb80e63e9c5963b7ad6e52012ef07748b21b7b5be9eb79dc97fd8820c848c8ded194317ba556b9b58e364ef82b6986629f56d4ff65aae25e90e94271f0825996302c5cf2833cb825895c97431e5f417a483b8e7f3a61c3fabec64f8b0688be30a1588d2a337a16eca94e4228e6c5e608586cf6dd13345b408b2650a62073ea6e3038a6e0aece2bf6800513041f4073de9d53888969ae66142d5dfb7e2f0ad8a99607f2deb46db4a1dce01b311608e7562587d1adb9a1e9fcb326025410c629e0aa2148a5863d6a9c76b353c67c43ecb158ff0efaf596570614edba03f98e9f55c31daf8a7f4d8200defa06055e14337a8db6af16049fdd257aba5f76c54556489ad91466f800751c79af635c37aefd3e665d57c830805428f0ecf2fdb2caaaf55e2d8ccb7f96219c2fd5306d931771d8e206a761300e50a937782372767f7edff86c5adea81bb92b8128cd17c23313bca0dc00db8bae083496e215a0de67582f6f20ceb75dac2bb4afd98f2a6cf9dd780eebcd6fcb66203bacfc293944cf93aa72441c23df722f07c07161bebe940464f8a8fbe6f9e3cea2cc834b7c30236d3bd6db17479b14bf63b8442aba68ac1e2573b79536e6155aedfb17b82417273558261b97f9bbaa2a80ea96273f1e8df597d91df824ace3452377c5b96a48bc8b434e838d2d95ec218a35799e81833c067de69ac2836a0f57cb37dc07396ae0bebd0abbb1072bd0fb0a2c30b2d9155b304754b175cd6d94cb4b44758ebaa38dc8aaa5957a9dd012aabf7620fc425d05a30979ef357253b1227b89569b685eac691d45aea740f30701b341b51869572430f1a1c70df06150df65eacc14a1df08d446bd51ba730056b143b086031a500a2a0129211b4f45fc11b311d37b0d9e273fb6b3dbd0f0cea5d13b3a67e5856a51af7835de2fa32904366fad847229dd4af2a72d3ec12cef9e301d8ea34b18c6531867e4127fcacfe419240b427c662b6fbbf0a7b969abd2fe6484fd6da591b8e03cbe21dfae0809d6de5b0418966ea510503b8f3f3599050b6dd7e11924f429dc69b2d1f82d9305a7401e716fbfd53f8d51b0b7fd5f3ec53eb0fe8b76062ed9260a740626f8ccd3cbeb38d646dee589075d039ef7208f83e3373bcec38b05820c05fff0b681ef98a384bfb1b933198f2df981e8445729247cfe186dfc7c756683914e5df31296b162623309c2f86db977e1acb8904f8ef9e3f3665826c1c2ddb5c3411f8424d040afc982042b8845f734d2a7c0bebf0f0da25684e54bcaf4062271a080c3a9b81f601378c9ab74a3a22d8b902256efa8c48c3ad3dfdb295c5fbecf286eab755cb8be7f5205ec61f17bebf8464f817713224da978b44f8dcb9a7cf720626b2a47aa3360b91d712477ed3c61220e6029802a904ef16cba696206f455781a71bb73f0127bbd002670c9ccf1f132ce0a32be28fec58d7418c1f3c5b4b0681c3b73fca26077a88939f4960ee07721f1859e33f9b8b2191022883e724494588741e2fb858c1c823b34c20c2b1b96c609cb396d4ef7891870ac572c5d5c60e60f6709bd613e3809764109305f01adae46105e533602452572f8690f09e8ae449ceaa82386c90d62c22c5236a31aa3589c6ac38f864238ab0bee3a86dfd674db6281557a9e034975d3da35976d6a3a42cd87494821d9dd5ca0cec2753d1a45f6f2dbae438fd077500bd3268389c57793af96d834854b5f02124dca720def1c66d285c63d316ac4bd482bc492147c60720ca0de0c1f5bc4608679e1226a1150a717a45c66468b04714ef17f88ad968169a43c80d6c7cfb8f50dde222eb957e7ddfe5ab517e8d17bc5aa3426097ab67ad2b6cb2d5a56e70494673a465868277ba7d2d3f5654d180fbb6cf727fdadb85260e3383e183ab0db365dd8b661a2189df0a9f93c0fba98640f5699859212933ede180d2056bf8fde789aa1317020d220b5236fb351112c838d25f3bbc054a197e76e4addd2b0edaaa3ba1eae32a39aab52c1a40d04f85e281a69e5f24502deabc3862b004d6ef22c6ef0e97bc0b7d3abccec9f40517bcc06cce9e5e83ca14229120ba21b1e4672f6a60b53543adb6013fd60c89de7bf59622350b5e054260ba5eaf461269d222dbcdbb3b3b1ed46269929396bae63a0ed98db64a35791f5a307c308b242182d1f881335e7470f24145446a9d71065a02759047d439e714783dba45693f8f9de0e490b834bf861c68d9fea284f4cb9c523efe3f9393591e25ec9cfec12f8f37bc8e42dc3664678941ad2768c73927711dea2f42af9256617bd527f339c68c3f95bef715b442c3eef239e07525cc8e68d2590e6d4386b111b42ac60507b9c4048633a390c89ddd42feb4995b8bcc71d27acd4d4452d071d5f1a7327f51b86b8b0a747f1b46faf80789b81f4c323f67256603040095a34d6477f47a17098d4661829be1be804e3d69e95fd3a0a3fdc4457c76de7908b73dfcbd24cb5cf69041be019449a573b5d6a972b1dfaf351e4c20224e70323cde8986d509413cec84b017c7f3de1349a6b78da62b5389060f37d5aa4165bd11c7f6238de1c0c08deb6c760e108897a9e5a53f281e8863d1c4758dc0a15f3e3e927cafb6f5bdcafa920bb86924c119c44e1a482208278e222140bac402068280953cef01e60838b1da8898112ff941a4969c496309ccb300fcdc7ed72457a131f67886587344b15e2c0b8753faf395b432ac1bc82af3a2e0967c250532f0858fb4f6bba4479952b1795a2164a78fa9e3aec4203aa5131281faec613b4489109bfb9d1a6ae516af4f11953d65f3b1bc15f2d66a46ed473caa07e321e697b06483957a0f1aad5dee791b005fc57580cb4b4c0872f597d7d7b5ebe53b9c34983eacd97a18f83cfc5697f8f9d01fc280f2af023efbb1a795135a1fac6d66ae10285bfe7efa17d4911fa650b088dc6e393340ec6cbf9879649c27f59733638e4c1d260fdf808ec9762254e6cb8b66e2694933db23a8052f11526c75083f212ce0b63831f5ffd93acb91f9716d042706c4d6ce06350b72b341cfe54fb30721a97e5a2e203edbeaddc482a634efade976873fe04b93679877fa4e17e1ea812930c4a755365466517cd649e53f9c7dc99406f9687c1620636971419c85cc37539c80823c9c4472e50a7c5e95ec1bd725c02bc768d31154bd70da3b2e7447ae8b438c6387d772904551fb9ec94b8b4ff52c3d9403a6421f946e10197a016be6e401c531497ad9ac3317465d6dc5f676bdecf28a67b05380d5205f05dfcf1ea6bd031f704d3819bb332e8a57cf1d74d66c82470db235f66f96483ee3b6f80b4e6ec1709f26c59aebb28d54b757a3b5e7d4b4ac6f53f596c6d9f0deb1f2ef343311bbeaed4320f22837114d58880d05b250203abbda419731584f001d30e633aa6f8395c04e1597162a0c3ea572e58c5b423eac970b180fa25b770b9380c120bb37e7968ad5da8fb6a58bbe1ec88f368a628a8cee426274f5a20134d933d785697cb3b58859573addaaf3e0adbfe6d182c2aa56d8e52d0270c2b44813560bf3739ee468ebe74e1e8d910885dcc48504a661506fd7744fc0091f8f26d08893dc85b0fc8917e273f129350bc268ac897f1792c2752112c64d3f2c18b4e3fb38782c3354aa0b81689dd087d742895d23c98aa26727e61125f764f4b78d78a6a82c543ed5423d88e395c2ae7e279794d67a6159c0faa5017b0c4bc03d231d53cdfc3abe089dee5c4209fdcb93acd3c802bcda62170d47156adce77cdaec5b6801e07adfe56153b80325d3a37df6fef3bc623423daa63640d08dd15a8b7a2a4f4650951702fcb5307980ef1fa87d53d874931b0d4e7198907b9c0cd1fdf87a79111376184e88554b08143c091235197971cdce96407d2749fc271d286c752fa1981c2871cc049990f6eec5c51a657fcf4ee7862f578562df757d674f80edfa86a826d080405b1ee0246e60e978241a6db45ed6f59a90b82843820294e269e2ea0e6066345992c4a607641c1fb48eabf528b2cd2ed3897fe3be18992734cdf1a1b6a0497443bb6a7688f70e0b3220c5d0c73569e889976c70e0cfdd9111ab1829919d9b8a840e6435dcd7274238cb8689abdba6a0b6abde895655020f6f4d28f7edded0ceedb8d77c64b098026a210ab6a5261ee66b6d73a4369f8001ffcc67b25c6760fbd5a8bb3c4ad8f3f50b00a85ff61a8ec6e96ed2ca5aa537f9b115af98f82f46c15780f44a57409c69884bf8ddc48625c4376874eecaf928426e751d125a4db14af2737e227c98ba713f69909b2b46ff00cdd9c58e647d9b9e1762da520607e8b39baf9b707584ee277c55e51b8ea0e9cb039f2badc3b1acb230d6da22f8525f3054418711c66c69fcae312bc3808f098c17ed489c9861702ecbc2f9b9f4e48bea2914c8c158d1804b30df29af34522307832faf004ec720a0abcb5199a18ecb816e6fc5a14f5090a541d264cf9dfa83c31ead138ca5615b8b72d94b321feedefa56e8c9b4baa64c358a974f9af29134fd304b798243ceb3477b032f2c638f73260c9685623c57ac0b33c450821c78b6be2f9917ef5779b137c3a4e06c28f287d7645cce97c8891825c1d442cfc38af9b9b6e452c90a71f27b55388ff34a4f56b5c5c1cd69fbf19e7947e1aace7b60378e375ee65ddd702f986d9c24c19d1ad712026fe021b3e98b7254c64634364626b2ec625082138c9517441677e0568326eba12b939c04e473641e49c49eb2ecd72bc0cbfbe8aa3a11d91e2c32db1ab2d90dd16b001f8b4d9711d3f684124c6d9bc2a9dd885536613d295d11bc51ac7b2005a4d299a6952a903c06235b2f97dd6c4cb364d41e43bc3b445b4a2afd81b86b222729418a62806ee42af7b877b67f9a1b17ce61f9bc907f2be311b7d74f70f300b4ad76f08480d3b6aca0b48ca68a57a3930f54f438fd046ea82fbda6c6cc76a87ae52a03f006b2b75b0b6f4a832e53d496455c3a42dfa667a8d380a72e8a451812f4964b21b1a67afc228554a8488757a01523d59048a5e4a8b1ee4ef13a45aa4c98dc39ed77642bf094d45c41e83919ef5b28eb06e99e8cf76066173d4b6cf7fe5662d18a8afe4c1c26dea11e79857135d25878abc0a02ec408a62eda2d7a6f861226c9a99b3daaefb4fa3cd07b9199609fb27c0d1af0810bb335c28dda91425542db993dffb7e127725c5002cd793f33197fb82800a076178913b54359a44cf5328e149cde8c1576b83544eaabf341deb45f394da6230e0862a1c7c6c10bdc66358771b5a144dd2db223b595f8cc32bc79225034fc05dbaec1302904c7291091ea791793e7adb41ee4b22564198445745750b274751cfa052e18f550c0b4a60645c6cc6eb748a4836e3e75153787496ff230f6b5fc9abcca6a19ca4288c1185fd1f27988a21f8d1784b0766304d2da89be3781df4b8807fd735387a4299674a0c2e6e005fb953b5ff8b1f6715fe9c71404a246f1cb0f06e96c8897f271a17556c7ba0896568590e2aa41638317bedd969febc50112bfdff8744e43475d6974bdc6118a322f69fdd07493254c9fcb47dc2cf87d89a7cbb65e2d2399dab7667174d7fb21e427b39614e2963155f18b22ebd8ae875c2dcbd8e864b903c13a8d7d9e1fbe7b46df27820759b844fd5bf47cc3a5fe53d3d48a2cb344217916ece7e6c00cb847ed9918a887c5373da3ca224341025ebc9437b903de8bd84d977493f3125774bb0fc9f6fc94e7a4af7397f97d60356babb2939032bef769694d79c291356d658ce5441a67ea118ccafba69a4c8e100d730389aacf46a6a49023bcdd9aef4aecf81a3a0b9144cbe9cf3cedf8d8b4040c3f6dae8e44a38c7acf6e0582b709f90fe38186b3d82ff56b800867b1fc4102bce2ad5ffb856725b82f08a7974f2ac14e52f75422834f1c589c6177166ac552fea5623afd8587d512973a993551454aee3e0ca01b7d9a2ddf44b0a6b563ae335946e1c485a2f149787a4c6e410586f57b1952f53c75be5d87123a0a733d3ae465651a508f172ed5a1768c1cdf1470cd7f1b61fc76c67daff94c3dd33a5de821f08b6d128fc6e72ce24821ea945366e05f0cef469c064ae33bf48912f1b03ff9ea20a5e7d0f2adfdd48d5de69812a8a921ac48f7ff90b832819e2c472c82aa584360633c32185fe92257eed0161b2f8ac8d836c7153f6a51957760b35a1d6d665b58e35a1006dcb37450e0a6bc425ddd4cdb281d5254f991c0a193ae1c1824191b8fc29133cf0f180cc62b2bfee3718f875f909792f7c51c2a228945b5413e15d5515e721576889f942c97657382c29e6bf201584929f4fbd60cb1dedebdc87952e8b516c069a701a15e0bbfed1af9517de5e85ddce3281d07dc20f2a0a65411ca6d54412d5763e3f8443e889a7aa49a831bbfc9c0e84fb1f04feec07c50031c2fe91e2fb02ce28261508e48fcd42027aa03d27da747b3de5f95f95ec1439262726c9fb27a676d70e0ecdb2472570b1e70a40f853569be95cc57bab0d7e57d7a6904c749dd7955cb55d35113aa481be3b98effc3d662f7a595dcbe57cc00cd7abb613a31829756462e2a971b99e8283556ad0469a981590da86f1e14e0c7fef61ea00ddaad8441bcd631e9f68c3ad1e420d59d24d184a3c5e0d1bc3f230a4d24fd4430a2907aebcf28322a0cd9cb368e53a3420f121362dfc4843b190fa026f56f9f006978e6913fe3afa1ee2641ecfd52cb0f1f5f1fa68517d9a4567e0958255c28787f6eb294cc01dde4a82c7c3ddd2934ebde822a2cb0c1d0343a7e4cdbc638a9345a78f9380a96af9ac1131c6d3544e4e734cd33d4e08fe77fbc32638b88b7a61359c79462b131b4a53dc3be738de25aef21dce548b2b462125d6e6e167c409bcfadb1dd3e8fd937017be40b0e2bd58312b13438d9aa92e10148bb1b496aa41d818446d48a688b4fb65947977f6fcb0d6a113a053bbb363a85da5dc6f5f91d54db2892d977f8c2c2e404ed0d403c8d607a6035e915164a5b5ef8bd462a04f24073f528649bab27510f61af5669bd98ac7a15b3d706e751f217e4f4582f9cac9e42a310c3688226076f761f5fbf102f2c9dbe30b573340401dc9edcdd2b3a9459a00021959d441cd1f59b53b2ee7bd62e8382351bbe8b5e3f95e9e282bebe9c48f34a24fe377ca46f559c754e46746ae5a2ec32367eaacf56ea9360b92b31a647542b99da86c3c8a6065c24e5f9d1cac23d41b8810bd2a2ec55f4a52ac3cbe8de1d94916d392497c31c0767828883f938c090f18db508274a4e80d206f0aba97f07f6aaa59b062bfb7c7f5f0f9d381ceb4b9e54103be29ffb4efcd43d6a076e91e7ae3bb79e2b1bc512ae0e54648327e0e3f47d347f5113aec681dfc71800d151773c3aed31c03e45d7f9a7917f144531fb726acec0fa583849fa8d7c36a39a7deb0c8c150884985f402e50b7b384555610150b7afbdda9d5a46c19e6e79ec9e14c835e9685bca997141c73f701cce9d94f4bccd5cfa7e1f25a0411ac7311b08a6e10ab633782e8fc2799debb0454b5adc5dd77ad97aabd3eff8cb373ccf8032ba461549508d74f7062aad45ac7e2012a07bc91ce41a253bfe2463de0e5ea2ef32186121aa3c65fea6c667c55304f776c621c0d99189ab5bd761deaaa021c011a6681084af1e61ffa6420b2a3ba73675505e7428138d47706aaa4b630e1fcde009daea0a84895a12bc1123826f9d69d0f3670778a0320039bc1ba93a43658d41139fd7f296b863e6a6ddf6f5ab75bfe707f1d97eea9fae733268e17e8f703400169994590c6f2da7d55b7a446c4a59e50c62dfac0670f261a87374b894b405cb3623370e0530aaae36982f31f57abf2c2f5de9f0fe8c5d2a226aba51ff0d13108b4f8c9d421ba9030d66aec6d88b0226974e219ccdf3617568483af6fb37485170b6e3977841048aa70bf493fd4a17eab2a20c7d41f4960e91a5af8d09ca7da9a34b62bf95fccb07353915d15cdbb238f53d6dc1b61b6c0ac853ce216c172183d971ebd9e90f19c7ed23efd3e642e95f8488bb55c8d4ec472bff9a8fa8accb8cc5a586990efb70f0b3445113479dd6fd517aa15e36de2204ff7c181ac898bd7129c17017d91cd8f8c57d01cb4ae8995f7043474a9e4fc1062d7f4e8d0d95cadc1a2f4f44999c02d962e8357981ced71fe64968fe72486563b6e1d070aa5f523abca9f9f99ac43fcafaa452c72684492e40ba4e8a2cb3abc21013b23508c34565318e4aada1cf6a645ae0906edf030b6b4936460942c603f5da29ca358473e7d08d0d53c1b5f059559cfae579bc3ada96ccf0fd56cb7a0b921e408d3afdecdd7cf36ea83ab805ede9c4cb1bd30ada118e2828899050829e0fa9afd306d53f0b6b42edb20014e80183d73f9f7d06c69950d436f8cb1be43a12a95a7b1abb94090d790875e92232cb213b516b36f3d9d4a7cbe67d55568fd095c70db0a52b2e0e18dff623b24735d002dad91ad0368e0f6f1b3d4fa3b2384056301a34e6406359f9d408e308c5b70a75db5f395b479ca2b001a2a5104a5f89c922cd4d4482539ddf20d589023bb0f07c70bd3405521b4a86b12036283a768defc7ec32b08a7e63c09cf4316cb6c9e242c56a207c422f4c97cbe0edbc2d3be4c7d3951567afad7bce6a7b8b1f85468f97d63e6fa833944dd5d8d31fd0c5ffe6af822ac9245432b75deeb6296058345f3a8ee36fe42aaef01edd48c541099e3182e76d1f19df1003f14eb997708dc25a42f46fa300ae10edbf73b45f748f002400f93de9fef9fe92c03b48e9e8bb41e92c868328c78eeb53e92908dd85596f04da1383a7b3e6194763d55187e3220780a7a20fd501b31e5cd32052925640135cde8219955aff51ea08c5973acba08816c681569be9120c785e0ed54b9659a071a036ea6b21ef874512193d0141863673402613c2b0ea3c6161312f0007c08161607bd97bc404ddc522b42abdc1a8af10abce2eaa93465d1ca1adaeaeb3535e269beec6977ae59c76d0dd5d5668c92444c02b1f48dc356ae6ac0c9891f597710e8940217ddda28f1d8c815af094c48194d96dec3f397a460e1358919defcbe6b6011f7e04670e96e5928a9e08d2aa04a8852c9ee8faf5dfa748b9b063d7013ed7c8c911b3d8f8da1f3a62a87b4dcb4da545ef17931d8beea0bfc86dcc99160aa56ecd047b54248b2f00ad85d38d7f693afee7fbfa2128d018f99937dce7094db93f6bf0eaafb4d736bb8cbf5b7fb84efb93150127f16a30b353a6a9c3d9273ed790d90ca5cbbea36d80555c025cfa488e25eba5ae7d5c566d8540dcad41c80be280a3def80daccb8be3958f4e144d8a52290017864e4d2fbbeadb30200f88fda044e0c7438d8fde36cc56dab54264ce91140c7cb7ca2835e28748aebdabff0f0c4ff606b69fec88aa00b5dfdc10be5c37db87e3ffe8c858207429d37d1650772c9e7acb15bdc46af3353219b0919c792334a74a3ad9fbfa646340a8961037ab4f5ad1879aedf735e6d092c6b778021529a342acf125a44047eb094a8066fc2803844994b947123c1d4548a7804a9a642a1b99636574b67531884f4068d3f3e84d795368fb21399462c01f79ed4c89f24c58755c8423fd8b821a96257874ce559d8bf92e8f00309587029872e9a0ab108f846a386c245dcd1892b5c3dfd9a86ff085478f350d12b4f9f11b0bcca23d26af3c53ffafc6120f653cc441d675ca61e6384a09a7b75b347b24409633e3bce09011330ca3e3e0a04728a926910a36e0ea91c9b7340c50e2347270ddc2a8da6b816507f0657d532678004a8fc4b13abb08d28a85596f293346d9d8a42a5a70f662fc9cb07a6703bdb242fa139c2d861a9575a8f6207a10f8eee1d6a0d832fcb39f65461e7e734be83f1795bad95d21646a99a9fc5f0bb32d672780c27fdd0bcdd9404d343a7526291ce4238dd835790efd1429da4bf874964572044e403430fa9161dba21f70f703e2f635fe0c77c846b517fd2203039cdcbbf8ad13c6f3af43af3a8c92fc144ad1b4f8bf6a71c1ce9a238d256277e93aac5a4c0521a150bbb01a873c8907479f28d820a51639650d9c6cec2d0885d7724955b670a346725a04e2fb3b33082e55c3191ed6f823abfe671ee28921d919c6a1eb5b11aa0ce8346d739ff81fdf452ae2d74dedecc6bd93c5d0b45f94d5cd1eb40b15ea3a2524197f3ebd198520ab466c97b0231fe8629a8c273399e17e7a23a7bf9b76c281555653a07f986c72bfde7636d4616592a953a79afd01f01286a30f83049e489b395903b0fec128f9f3a074d986f9a4764350f0bcd0e54c6a3cf8b29778b775fa95b50f0af0034e1ca4ed93c4d3206e7541a01c134c62291125625a940b12a8e308e2fab3962764a80735cfc823d0d08aab4728565565d1fc6a205fcdd42228492f1c3a6f17cb0f6b5f9ca0674a8c592f11fc6a98a249a52c1e8f548cc28fbb73bb6324c895f862b2565a60b31ca61cd461f52b523193e27c598477e46d043e87012314e7234649958b8d3ea9fae87ec089af840f1304e061b65736c7d8809075585dad0d3699a7904aa1a3a8cc510ef7d5331ab1aba16bbd2d94d080887f8ce7d5d42f4816d70ed637486f5d00e654ffe14d52c3081021a8cfedc416ba75d7d6b2bc7111729e2409f4a03602f510ad65b33ebea2e98a54988e063a851ae3f3c0ff43b8136206132793b4a3ae32ad5b60358ea4fd3fe03e4746a945183085c6127e3c0b7ae06fc6c0b4bda553f12c9538a0f9f0fb86925a00000393c60b2c3b410cd4532ec09b069c89a819f95ae60af26ec66cb619c502b69188ff2c7ac883445008b909a77b81f97c20e5027487020e1100223817a1ffc7ce380412c0151956c1884e72bf1dba0202a6b25e2f2ee1c876f2f0296bf6a8f790fda128c9ce581e5401caecb39b0605606d6680cb2c05b33e8069569f9150d0ec2f9defae1fd30af0dd01e4ca75f829c81d6a29080cc9667985b76bfbc799a2fb65ce1a43382a9a512bc0c4185d562977ded362468a8be1e9a3fcefaa1f6f33374fecf3ea3e4150b0dc108e5335ad6e317f426e4055dee4b0414ba9e6df0f73f270e3701fbe2031cdf2927723840115c8a08aa8f7072f303bd4bc6554edbb2cedbc12036ce2866200434117ae83a45e59526342d1ead13981147d1b91dea622ef50c8d1f378b005fc06d5ee210b61f92c6267e9cf46efc41b55d37b800f2a619c2c2bc255052399650e2a5a8b1f2818fef77d1ade04b052d45295a6b561d92455efc1981e3260cc568f25a496a164013bf83ab9ba1b17df021668be876f9b61a194cdb92a731269fff309ee834e8563d5ebcde36b8f801bc300c2c1140cbdc12fc28e978889f12dc25299acbd37b8fca11effa843e0b72cf0b0cd474e678844ac4a41aa39b4d6a0d4f43a0bc05c4034134e14ac7444bbd301677a2b10837d4e24cd467058d47aa21cfec762bdb72794a0a2bc0143b90596fb4a0ef9e67afccb35bec6c54f25aaf8d4edf6d2d1e73f3cc18eddc61cfc89ba29bcd1f5aaaaae0952e79f042a58ad68628d515d2a6ed0e9b10e5a42736b3172dad43e4659fcdffe275750c9be96506a066e6d1d839c255446991457248e3597dda864b4f00176959fc0f3a7c6f1bcc672f2b0ccd4a5ccd46ecdb3b9a63a05a85beff49e8f88e98d3890349f92207d338e1337b34472e09a0b098cb43c9c9a034882dd34d893a364f65131a07a2f5da74f592834db75a9b3066030ec30f5f28ce8bf08af571ff4c47e8af12c6196c85b0975f88a3f089143e835b7a1879ec3443460d62b2b60915b88ba0791c6475388f47c398d026d3ab1ee8dce226203e9fb13820fec0fcb9b34f82e16e60a8efc192e0c381a1417306bce978eb8d05e958931c9aa533e8d0116f32e0cbe982b0e6fff77e19ed904fd2ecede624924e8bff0545de88763d4decadb6b07dd6115e9d402b999da3ce19a66317c02215914d15bd016d5cc13e674c27a7d0e2221cbbbccb0092031b42d52749212c297ecf6c4ee983f48ec0756a318aa168b934838d3c3324a0d2498ba3206a7cf8fe2dd13a9a5c29cff5c905caa9469760c80739a75f67f28cd02299e57f46b8623484cb00cbf6859a4298e5117f1cc41a61d1943199dbdeeeef45040870d5d3aa48763433f2370b0cd2a52c4bcf9440c55f3492e2e65f3914b0b380a655cdcd48d49608c64d981a47de3933385535bff5952d9376b4287d3ead35b307663c79d71bb4c007e68fa298c080ae047064b2f636c189278a4bb97784de29675ad1d8042baa85a23f810b601dab69161cf493108bcf7f6a1f67c397db571cdd169caec777dcdda34abfabf6ea70beacb82593c7f680a58f8a09e988f845616d2a7ea2a15bb166d04c1d32ded1ddc3be2562f6c252a7e49de157a2482a4ae92715ea1461a3a0159a990fcb344c37ff81bb0998100252ed801d8b98b067d53d11801145e7a6300e104ebe01405445f37ffe7856b66ce4ca3ef3838e0d6439df1a4e86fe767fd16fdceaa0d20c74fe91f3bcbfe7078fb3cbc7a67e61b6ebc8044cbe1a72fe2f7015aa71bc464cc078b630038a555d985dd73c2ad80e4ca6bd372829564690c857f14f3671d7f4737d7ff5367ec68198a1569f563859f5c60b7443980cc1eca7e4a0419a6ac875bfc598fb890cedf31f430ceb416d344b7eb007ce3eb9c8483faa824c7313b84269850ce88471b05838889064ca57c31ac480678f38f3d94c14718995aed836bbb72986dad40dfe4a65a24f2da03fc25042a6157a95a30d815271df1a9248c74b1cddde5f6e2a8e6ba65edffe82edb4892c5790a2d1d4de854167a7c90fa12714c2f6e57e904a07904ec884081213bc56c66429fcb8f0660d4baf7a451d822a6ced5476bdbdbb61142c82664ef2df70e5c0acb0a680aa44ffa19defe76eeb3fb7cd3cc96d0e74806897e589f475bd55a0e5b49cdfda846f490ca54327d6693e964f2ccd8fc99407307fcdc79d6a51e587b2f0af583e092252c968c138aa9a43de5db8ef2713f7db7441a556b62cd1699b3c3c3e289f9c9c0cf8f063210f343b2dcb5d7dc6f246b4ddb4d1876bf1dc65dfb4c4bebbad6b49efd997ebfd2533ab47387d96e4f43ae3b636283b4414afaf6c990be5dfbec35d35fdc4d18a6530fb3e75ef1ebbe8461a4dfbfb4f697d52c69c3dcc8eb42a6c8403991647cf6299ff6d3c71de5db6efabc97beeea34f74d2177a0cc5560aa9a5b4565219625c99819f1f0dc4fc34bd01249555faa6efe354865da67b718a9e647fffb2bfa7bfda4918b65d3b8cbbb5daed8772ed3bddf4dd8f3e12d54894462f5c6bb3c3eeed33fcd27ec23052ab6297e95dabb3528652ae7b9209d7d488ec4b58dbba90e53c91e88b2dda212d405ba347b38436cbd60c3404a1826290cc913b4a3eee337cde515fe8299fe9324a285f8a9e4895862fb65264a0f0f8087991a0eb22080a1a81b5f7a2503f088a404890b5f7a2503f08364a173af71a138a0a78b225148e3bd1c87daca9924028b3e2ca7cc7a23964b1240e6d3343160d59b8b39ee4b8d039cf74ef332d1b02b283cc7d1b727517322513e9d3208c865d349443287353dcce618ca57470efbec3fbe931e442691f289b18f787931a55ca956a94777fa1bc8b13e58d5f29efde694ff94ccbce16946b32a77be7beee9c0e1947f94bc651304cc71ed65d068ed3e217ca5330eca461da9dfbabe3ba9317fa4ab8a686f49ad125cd0dce4e689433495f6c09098a693d1283a7eba2eb64b4b16449cc85424ae1b6a3bed3657cde51bed2492926ce76295f6c914cae26ae26381abfcc0cfcfc6820b6b5f7a2502c6bea80f47bbbf79a93c52e53d7e1549f8ba6eddd5fdbbbf73b0cd3e14aef7e3acc2bbdf3be9d708aceacab190f8943dba474a4fcf457ca4f18a6d387999ef23a1d05c34a3fe118327dde4b5fca9aeea55ea5772fa5ec7778377d47f7d2a7c384e3f44a385aef761f8de109f974fd1095b1d8be96acb985bc6ca150e157dc0cdfe9a8cfbb8c0fe5a42fe5a510377a7767f8620bf5c5968c2fb648251cb345e6ecc470cc98a99a583af9f991959be2ce4cc167e0e74703ac19ca40cccf9c2d76ce392de5b6a3fcf49a947bdc86537d199f69e9b8489f993bbdfbebd47da615aeae1637660ec498e832f37c8fe862f366a79d38b4f1a7a35e8ee8d29fa7400c65202dba0615dcd3bd7337dd3ee52a1db61da58461a5a7749d0cda60eb64f8e55d0686a5600fc350f009cbe86497b1291ddcb7bf381c67865fa6973009d7d4dcd7885ee39d7bcde8db4bd36efbbad0c813dd98fb0394f568c86b8484db970fa515794e94cf3fe5d38ef2653f7ddb475fe9a42f65ea2ef26228555b285f6c9dbed81a7db165127db1d5c5cc16a984c7496318895df49d8c19dcf0ae061257240e3102c547d9f203b78a2bb3f10f6cc59597178016ae7c877e48d5f3105ba45b207ddaa7407888ad9a1aeddb6bb297de3855b18bf498ede767ccb46444bf9f8f3ab4dbbf2c86e9347e6537615809cb88601b96d191317dbbf6995608e6a923633ae9abd922c2291da56f4ff545b7f6a2dbcf6f2f7dbbd9e7bbd297ea974ebae84be9289df454e35709c716e9a2df7b114e354eed4891020f4ee06447e9262ca3f312bd84613a2f7bd161dab7ef109d034a20e1890b68685a220ccb6e2c7d243cfa745ca2675f4ad3b62f25c23535a1d774afd9aebdc67b0df71afbecb1b5512153356f3fee9345640ecd4d6cd9d8ca7e4cd5fca4204933b33922ba947cb8a23126ad953597559248b0649784e879a29914095aafb821cbdec8228d43959c9a9996906575958078c3ccf017a03daedce0862c1edd129b7559837af2451799c562b1589946a94a5c913ff97451e5345d4e1f0e47e8014fab93dee9935538a20a39ad6e7a13264f70c3049ed6e91fac04318b214a5a76dac027a8a5332f714a0753e9a6cf64d267f2fd4c1e7d268b3e93439fc9de6772f799cc7d266f9fc9f63359fb4cce3e93eb676025c88410d43abd0434c2a0a48582f279b1c13b1285bc8edbec923caf61f19dbea6b1a2a06058095a51a54b5d81e8ec0c51d5f79ec3b3c4a851176eec398305573ec7c7160c4fcc22c9933c9fa387667122cf4320bac4aca5663847573c4fb36f2f8e9117aeec9f79d3459530fee40cdbd0d4e8a4224a33d1a45f77c9bd7bd7494f7bd7c54945b4a3d402cf3ad194807dbdf172afe86691cda2edf6bbdb760f257a2612fde2f08a3ec2212a775ff82cbf98c3d71cb877b7a11ba125fab65f9fbd5a955dc3ae2de85a8c03bf3498612737ac91b3d7a89fcc3294837db5e1fd667827d477950f9c1bee8752da2c6fb3c84c4a8baff59e33cfc69ca2077308e62035d71f2f097349ccfdb03f06c495c9720016b0c1d9ad7883767b613030080c0b813568823c4f6337bc12e8e6d44bbbbdc5b058869686532e6d66a69544fbe254e510cab2932909d3030d59b68087c7933c234b18b178354b2a521b53ce796f63db51074dc3b012b4aad0c5709e74b13b635629cd689665d9a946c4cd88c0a17999aa3ee5d9999167a785fc08d260cd3020ec3c519329f6a6c5d120fd15375ce5db60f78c46c5aee675b16b25907a5601c306701557faddb11a675927c4aca43102945393b29364c9901b213e3f82c0accacab31764d5b07142d59a932787489aec5dcfc62c91d56ca12d1db4b59a2a6a69dcd16c6896987b88c151e4c5460e14ea07c1d5aa8bce15f3c1751dd73dc41479b19143ce6957d765a74a4619623e9a25b4425e2e986649913435437a88e9e1e57ac1bc62ae18ce1671b55a1d86c68ae58ae1e1a3c60b1874151b66a3507395a3596068ac58ae181e3e6abc445a83c62a7a34583456ab154d0b2abda71936d21ce3ca6b344b7871a81c7c71bd7ab061754f36a8fcde19570554a974028971a3125dfaa5db565cd7719dc3c5b259d1a811dba28cb83d344b687bd878c111f323082c87cb7a396c34d8e2613b4fd6060e1b2f3796090f2bba34901cf25324c80f2137384790c07a2889e1e1831557807e04f9010403e2e142175552dd16635d276d78c4f49034f2864804830fa0dcffd16d9ccc71bd9aa55fc0d249906149eece85b4d08dfad260a31a943e70ef1e72f7ded13a49f5fdd436a359c2f853eb411aed57346a744bf40250184836aec6f0a033e28a6cd06bf0d9edd7e125bc73ef66e806d71cf57c34d87fbd77ed5ea4d5d60d5f1be98ec6c566511207896788376cd886384f6933959ecbf203bd3c4d9d81d7f2b8c71c230bf7d07eebece779d693527ad6fbe6799e77ee0b676c0dddf02c8b7cb8bdf33e9abbedd3b66bdb69839a77db2cdbfb1e0e376c716c508b59d34e3ba44376972be64d8cdb03c73498fd93c2ed87f127025523ba1fe2533bc46bef3c731ce5c4167ba459ea61eaadbd17853aaa491399a4c12a711aacb7b3451e69547d9548ecb5a87b14f81588caac1ca27245e57aed8b1905ae583c3eb9c678882d98a9aa625ca9a4c1fa0ccb9d06eb27852ba7ac4d38ddc88356e220f105e20df3d3621c110a793ee4f2f4a1691c71a50c37bcf9d6e89621ded2eebdf7765d4a323379a770c3e8130407bda49138b4bc41d2c8badddd6dfae28692c607874facf206f99b53cd4906f2071d0653b001142d450a72761a5996652846e415dc20d3537a148b434343938216b5414f2fcd810e4c34410c5d48c10bc400a345a3c8947699524a293d856e509397b36cc615395469400e6da091c525648f61b42267437c51051429a8428f0a8030040539fb8a358427677f3122673d446021672f856e64b11e1c81232160082264fa1bba416f2290f4a8c8e189460e67e44c256736e42c873472868224c09cdda2a0276747d9e4ec6f96cca6670814e4ec2356a6032a9a082253c0135114ba9145a146a60f152144cf8c9cdd339249968e4e11c418999e531142103b310959258a205240809cdd460186abc5584d105a90f5d414c139ab91b32ccbb2b39aa53ebac45c4f2917997edacc467616bdb3e50718b2e8c1177e983831452b83226755d080660753f8020c9d24b4b22539ab020956e4ec349a45cb599665d96807379663de71b133bc78b4f79e5033ac56356dc990aa0448f361013da19e68925920b23062064dd505828b18f445391114041a9bae77b64414bc40664dd3b4d3207c11842733d35059eb398112596341ab5efba34bcc5a56c49156c53c8125485a1573682f0a8922f754837278df1141bd44aa3dab59560f20834bca91878b2105f0220603d0c2f572e4e12227c9ed72e4e12249017eae8c1c79b8904245836b73e4e1a209aa2cae28471e2ea4001ee16639f270d185ca095c7ca1251f01345531d397f6420a99e6d873040ec5e962086eec0102498e3d401891b721c71e1300753c59a2c0f86329cd33356dfd992ad9627dfac90a77d0a499a40b00f1939f34283f693a30834c1f76900ea52a903a48faf8045dc004364b08a50f95ed65593f6995fcfc3a2805d75adad59fd962ab882af92b9c3801284b2a04fdcc96d8720214647de28a9ca1226d00c1556356835658a10609e5809a856679ee8ba0661965f90ea743d22df2c80f67827086d70a2f69b4a60f92d84e93243f4e0421cb276450b384bd24cb870d463d92e5659d42969776489697960a4b45db6021b5f0e9427ee15333443eb1ca611fe138eb0364e346e39721cd626f6c911b7b636fec8dbdb145ec8dcdb13b56490ee993e5b9d08dc638ea14341acda6fefc6ca11b5d8f344bcda93b35a7e6d49c9cd9125b3b4a787c6aac8769433726860123ba00e0e7a626cf7469b2836c6caa1a871588c70d9ed9626353257fdb07757d5041d9e736e1b13e1ccd7dae3f3eb21e4e9ef8110426a483105d3c10ad903d309338c2c429ba45a6817e92a6c11a9a2136f2ed4474f1403d9039c693ec236e91a9cf159ee4e863852d72687d7cb6f8c9d6a759a2cf15ac681612901b7d8c009467c8910a3168b20c51a04f9329f6000dede08189533be489c31c62f6c147dc22630fc42d1a89db3c3434b9af10db014dde22d74f1291370dde1829522409ce9128c0901b89f5c9c9d9d949d248942cf16162254f83f230e878bea027490c1189e14e2a633c2af5f80331e4e9cdeed460ac8127db49170d368bc4a913d56205c6624e6c036e0f4d1557b493a8ea8709c832f718bd85c9823c51d060c8bd0a23f7971869b01f672a82368c1134ca7d181905d0184e40d9438382ecc51772a53396819a259c4672374b7711841c71c88a0fc137d8a780912e3418b97b8cdcd12587987f40c5157a525c918fb345c3332da94d19144a1c197b8a6e1cc24dbdb6db6f384efba55ef6da2dd6709099e7e35313ebe85686230eedad8844c99e55d65a7b061157625a637615bb553a5bc64e947a79adec342f917934935996c52aaa2a204a7e5bc7d1d99ce4a2260a81c82f9c91e3b3500e5e68c38d2cdbb8f285b44a9c5c6bf5116333c680c46b73688e0be53033e56e846883f15d77e3dab822bfd0bb9103cd368a3a11271289449b4824125991481365a24a4553d42229baa1b6654207e4071d6e9e77d103c921e6781e628b5ef2f85e1f8c18b7c7c3f80324440b1720413daae2251039595681849decb595fdf0ad842c71b89a715483a89924c6a03b73fc0cdda89a0dba33b4430fc9d95f6237118c394630d59d7b97b7cf005914c5851bc626303dccb709721afc4f13458a18094216326d5ae9875570c3991cbb71634ce9aa473a6822884c7118794ec793a2c65092572231dce77005529ce77972b4aa51524ca49208273b59d2c7fd7a5493dddaa4cf5e633f7ae314c52e92f6793fd39ad9b5bf320dc3742e86d98f0edb9e5d510e8943db68cfaea3bde257f6118689bceedc76ab3d7b66394fdbba5006d469419f3c49e10923908c138acd913ba3fbd347bafd52dda62fd5da97ea6c33b99ab89ac8202020a01e69f1ea2d5a8cdb0f59150810d00fb3abcdbad61ad2b9571d2ac35dfb0764ee7b9cd231bafd0eeeda65745edab9cbd88f2ea3f3e2aee154cb8c6e71aa239008e20f21d16566ae08398434811c01a55ca6d2f6d7e8dbeb372ed53cc4d6a8d5de0f201a6e0cd6de8b42fd2048234392439b5d9f382f456688916232625e4cdadc948e3a9df4a13ce513ddfb42efbe7bee1b75cacb6c9145705c1966ad563a622cc678d0e18a2b73ce3963766b310f40329c6aaef4d36b4c4739c5a9c62e6edbba14ae54ea300ce5a6c34e2f95bafba5fa5d37a58d597d712a7b37c2a90c7bdfb68bbe947d77d1435f4a4777d15316efe82e4aedf01ebaf7d04cce707fb40c10a098a67c3af528dd63cb7b6c99be542d7da98a5d35f735a353981e427e4423576c47644457935db6b86e12ebdee91bef26f49d6cdf7491c6e99c50ece726d6a46f6c6868fa2674d15fba6f668ba88814e130fe28d13e9acf4b17d1377dd32de822fa265e30ff00a4def8a1e254db7881f911a45b9a8633591c25695347afe17eba992dd2364e1ee10d631a2c5bd97723d8ef5354f58c1b0dbbb6bee924ba88d73c681cb412d987fb4b7bf387c3b099968c4d9574d2431a049aaf466822cd32b3226da459ea90fbc596bc29822377244f8e92fbc956119c9c1d253cd927fbaa0d5da4735a49fb344eef74ac6fa66aaebc99ac4b4328994699151de5d34a1fe9a65166b78cc7498c931f4052020102fac1b4b5e8f735da4975db4aa34fd1b7bf441bd660573412e1687d709234362938397207f5d99f3eed29a3934a753b95eeddecb9d7681fdd6ddb4efabc3d75ff6a3761d8e81a9631c9a4bc64b5cba0dc3ebc2b199d17eaf73232ce7df4c9a07e9ff2c1745e28144ee9189d7baabffdde6ff81e86721998fb08cbe8bc4cdf2e83f2d139946f9fe9a3efd6c3d88f0ea37dbbbd8ed1ada69d3e9dfa6ef4d2b7d2a8f4eda4a75edb49df768c4678c7f6d14730edf7b1451a7da5ed2361ea1a5121d2a6484e698676e7822eaa507ab984d2f7982d324e23bd07572cd4c75dc6d73de543f9fd4cb75faa6ea72f551f4a652f7d4b94528a83524a51534529a594d24829a5946625d26b45a174ef122551fa55a9547abfd47587a19ca3b4eb3eee4b357e7ffb4c4bd3629a45667a1e37d248b7a4f8a08f4fa296b58bde94cefd553a87613a5dc2a97afcb2ef308c746b755cf7289f8c8ecc09a7babbe99321754f55d2b9a75ea47327e1780ea72ae621b62eaee941efd18be8b72e34a254f260a193fd05bd7c119a3c67509e4ea69db13c451867f4893e7724d752c293a74f9e9e2c325b66d054cdd9c4499e4524cedca1b8831a6806379c3bdbbc22a88a08d4134e27363c441e160fe6cedc993d789e3ca078eecc9daec1bd84b7c84ee835dc453b9ab5386c9a5463978753edfdb5ddc31b27c21268aa66ccf327679b2d5e1325b365eecc6edaed93adb933adbd77a7795a49fb28992df701dbc3f6699eed8bad0edd706defe6ce74622a993ff38a3c67153dd349c7162d21ea20a01db225c2b09956037dd3e666e27411ee9c4c9a25ec2e0228dfe91b9df4d7e824f0de843f55364e95bc992d323af332a48f2e53fabd7d0da574903efa8bf4d1c4afd22fbe53652f7bfec754d1897f78915e3a0fb1d50316838148b8f4b9a68a9ef48d7e1fc6d8c453c695b8321fa76af4f5177a5c0e1b4702149863e4d0b756a29d3ec66791a9768d6aef6f9f0f2dea6f13e1d40ea2cbe720c2b1c14dbe747fa16f5fe8338481b293af8b741291652ad14a9c14913c3eb14ce9c4892bf41d96390dd27358e2b492cdbbb36b1a4c20bbbbbbbbbbbbbbbbbb5b7677db8bea6f49109bab17128936d971b6a6e6f6a5e67cd7ddc3b0d0bbc33ce9356d7920b0d57bf7852ee2ecf62d13e14f76dc66cb4099306bad5ad4773f0d6e91ab3671e85e8e07d4a9cce0662fd246fa488ce6c5f5b1cae10766c255eede5de6ccda7de2d05ed4bb87e04d7409e52ac5edbcc3f4a13bfbf61cb2778dc3794e6a9f30dfbcac974344962e2282f5b58b7c98d9625bf5ffc47d1357ea43f76e441209e170fbdcae3d9cf7f09d1f6afbdceec3fca9c13aab7d2825f76aad943951552f71c87da806ebbb5a67d7dd13964570779106ebb57ac366a23613b9be999038f4ebb970c32ec2a2d22c757ece39a7176b6863c53ef44e280a1ac11f4184fc90427e48ef2fed7a892ef337c796ee947b188f9029f707704b8cce7d36b6157af7d508c16a856e635ba38732485ba0f7d116987d555f57347c61dc9adac18633d9e2983f32dcdac9195b52d1129ee8a1bf44384e5508a7ec438fadd7a74afb08a76ce83b460f61191d9911aeb161b5ba0b615bdc778444b8665e08dbea1e5b1e76bd7c39aae85b3542dc568c090863121610862203c25845a6bfb305e647e2e6a1b75fa4d69334190aee0bee15fd35bae8f222d14f18069b91f2a5d24f1806bb33a4df4b895ff7270c83cdd819aead10dd4dd3f8c1c34402cd1a1bdc340dd2110eae8ca3340b77da9d5e2a992d293ccdc2a45942a740d1a5e485c8f2d2a01514658a61d1448b08441095f2c596e94727c5ad398c403274e3be93e2663f82d450c4ed3cc369787dd83499c62f9a88c211b01006115f006ad1d3f0499b4f0060dc27cd92d96878862f5632dc50dad8d4e98cd3194e25ce8c2fa5fda92fa5e11f5ea9cf380fb13503c32e4e3db66678f8149ef1451a3ec3e50c34c8af741a3e199fe1433d86487fe9b8a21df5c9f8a44dabe869fb1c9146a8cffd2493d0279334d8207d0acae8933c9fb459c2f45367c212d0b27c04a81722486f634ec99ccc268925d08659ab06c15879f566d4dd4d273fa7cc892bf311cb9d06230f8e1fd927cbf679992371f0e28a892d8748225922f9b6772a49dcbef797e80244e6eef3f9cbd9261a8d46229168f4eddaa7e592c9f4fb1da5d26fe932285f4afef4d8227d2989533a4847f98efb139639fd1e05cbe8bc4ef85e86f4d8eab24fcbda2512890359d3aaf921448ca08efcf8ec072b7d2fae982fb644210dcb1c9b371ddc0a06d7b605940830b8f9b1a146534a299594de076aada596524a297e5981ac06a72b8c44c861244296407f3ed62c210ba6074ae99663cf12262cb511e7ce6740e858a64db46850cb6d93a495f4cee5473b3f3932269bcc16dba26f9be8a265fa1e22b2c03448b7e89698a9a27247f2cc16ee07faa2696a32c5400fc9b49443885e8a6bf397d2d1ede84ec23542bca5935d473bf7fbd40eeef7dc2fae21fdbef4e9a476e8db374ee9307bc2589283344e499be812caf47208a594def9d5a01bf64e2b992da553d3e99ba777327d67fa52db675aa52fb5e11f5ea59bce436c99300cc433ad9055c23a1d82a6aff4d100c38d2daed59deb1b7a243649a64b32bdc1992dd6de4b7f3fd27782d11830cdd243440cf490fb23b5904d1aa4177d92678786505bb48a9e760dcd939f2f32a5b28b4cfbd3b2b599f4c556e672b0b971dbc4151ddc8a5d158cdb8f65ddc5baa8427ff821c8cdf24066196872109bb3937e1fca941ea477c1348823bad8d3eb105950f4acc8928a200522c7a0adfb81c082e0e689551ae4bed1bd4f14fa40d64f4d5cee5c7d78999abfd3fb8bbbf7790fc374267e79bf1816a7273bcf4fcb327423a523f4d15f211ca76a845f9faaec33845753458f23aed07bdfa78abefb5834a54304b79eabe1a6f1a776bdc110c4f0931590e310ba004556a7bc46e965f6507ec391f6a53c8739eece7338dc3ecbc50064798e468a71acb8707978f4f07129b970c3f81379785cba1379e4b51c7ba0c8228777053702653f6861cd29d2826cf1405bf52f1d2324bac8cf8b20f6704d5304371408892b93155d4279561c2382084ed7d67329ae5fccb985161db1d08105686a9db3d67a591bcc76b3a19da15b35cb74e9af441c62bc2114b78883a4efc6e100b27c78036a0000c061cdf2214aeeb8d26f2d6e189b8820e24043ded0ef5f20b6b060a20b6509c30b510b395221776c61916608bfdc8f724e29e7074a1c06106f90af3400904359664ef89899899cac3bf372f6f8653bcc07913ae8e2bbb3ac3d309bc956cd128a38ac5bc5f2f7e44597ea925db6962d146e189b6020ba3421cbb3a6aa87980b441c5e30d1a5de47f2842c1044e6791f335319ca81c6184331c31ffdece7810dc6b366cbed97c4a1c61be2258f96e3c3d8042666d0c5568d7c8c57e9d67b6096090b2cbfb3de5213216ffb96e60909db431ac9939ab860e931a3138a438778c3fcc42c23b05e592fb86174d2835a7befa39356d95a71443de8bad8639ece5833ed2079c64fd3deefb2ac434a2badd92773d5c1cbd9bbfe428d6adaa95671d75f988591ce9a793674233e76ee7e16c3997bebf8b067e7b066cba4b392529a6913d3ec21a594ee44eb7516636a06a81c1f67a593d619638b26a594dad43cdb2c61bc8c93ce39e7ec8e0b5aa0546a418a49062d68215a21597e5a1a032dcc89238ef25352e9a493bdd560c5799b25c6497134d88f361a6c1afd15adda0fae0d2058b38cc2e0aa3cd3ea0ceaa4d32c3dddebd9d922a3aa3e461a7d5e5ec6b85e965846907a1bb789626b53cc0210714111d900446e28c71e17d428e17239f6204186fc9ba172d68344177296654560308a9ba98aa018ee28c71e247e4023dc9b630f1231247cae82044e0ebfaa2790544a2ae795d3e6d974d22a86541837a4d9569b9d5a39a2b2fa7431c618230ebf1c278d94ce397bce49bb637777ce6194360a3244dd21ae7cc7d67ec0dcb4717ee243b905503f8632a8e7082472d8345dd3437213c91da3a1a109a29b8432890872b408430c2ab0410f6243c8a1f4d9410e654c62d1319913ebe8a40540c8a28e4f72d7cc9c808830960862084bc08101931cca224608914389238fe48eabd9e24310648083253b4fb65085560b213721db196b42104f8c410b1e317e5a3d45ee5f9cece54682152a4600c1003f99126122532264c8f43674838239461c0c90b96ba11b5c4619b182fce5ed59e8c6c6534365468352e786a8972b9ab42afeb42a66ea04045a5d11c4a26955cc4ab069d56c41a1622d6092eded9b25a4ff28fd8cdb90e2db9843546e154185ac69a7a59f9c653c4520e9236ed8b19f1690868606081e1a1a3b5bfae7e7a68b4c234f27a42e58790576e1ca10e544e264c9495114f6ca1863dd682127e0450d4ce0042a827002103d4e94411453f8a6894c4f8375a2072567286591e98d0d5880844c8f0adda07726891b90a10c487821451450340f144540913296b08230327d4a8480154f38a2022504f2618cc1586b2d8ceb158b7fb960228d1a8df1f33dc4263e31c618e3a682ac09b3091fa8481423dcb630ae9cc748f923251631461a638cf81469157725c4adb13d7b26d1c959653fac92892b1fb1684a29a594524a69a59452dab19e2554fc4049cc162bd151634716d4fd4e344b89c32c561da02eaaa88c9260439e3f9805716b27133058b58cb3e7258e9f0ae8c5157a0a647f5149bce8327f85ae4f01f0b933f245e9e0cab7066ed7168951d4663c7d7170e5e365164839f6576badb931ea92727833496679f9cc8594e76d6c91a48c73e5a3ca6c25745165e200274f7ff28bbbcad6de3b43301603820f9cb83b477cea1463c874708489c9cf33450bace8eea69466b5577727c623d6c3478cbe6009cd6685c4b559ce9d314615f4102aa707c6cda1bd3f3589631aeca15dbb0f7d1e0dcec693ca39e59453ce4b1cf6889973db68f3e83135ec9a314d9afcc4f468c2c34793263051a820df0cd44595f06e3d37dec881916e8903144f1cb9993f11078e1c4bf29c3c730a2249b6b879d6501a2bf21444bac8da125411f2c431ada5d1e012f6abd962f1276d7b848a1f1b6a4829aba4524ada5236c1d3b35b543ac618e3a3c4df887059f3190d54661744e4f4e2662339311be4a9a494524a29b5d6524b29a594ca15488f70795e6ce0c841a9b53725c79e2558b841ac0875b670349e4e94c3a756d5c7305cfad076f40341672b23cfa3c41b503d327dd5e8274a5c49a963a044707e86700399be5a8066fb6dc3a7b8321fa2783ee4792e8227587e11661553d639e794724e29a7aca11b92ce1ccdd2b3e79c731291854b26aba856c898f4913e32267d60af4019963e71a51e003cb8dbedb577f64bedc09c2af53a890a52b841196a603ae11236b265bfa38629705a4038a086a755821aa6c069592c839aaa6aa7aad630058e9d42078253e5801a9e96c51f0d2f50997d5631a2a422d8cf6c1ad44595b0d264da302b1aa48ff93448e792e812338d5d6be9ec209a0eea201a1e164b071949b89904b61dce9b36d3264ecec4f521d833dbac26b38c7e4183324c812850a6ef9d69edbdf3872aa1c8d4c79b3eddf4e927dd12c21d9b35dd90da759ef499dc073355f4351c71a1d8bcf8dae17ed238b62a9c357348a6dd1de4136b42df1d343b1ac213e7389c4428928963278e3671b28933a5c8f491dad4bad32db932ff40e9251d22aae88bc834894b95c8f41587a84c73ba90e589a94d5ca19f5c1177d263267786120a9c4c3f71664b131155f447e4c4c0064ada2674a3876472c68c8a26964bdac6da7b51a89634422a8de905b4b9276eaf4212e85ca3cf3d71b5980b26ba94327d0f99e6ba7c0d5fdc17fbe1c81eb7e87dc3dd8e6e7b5703127706ad794c00bd10b6c686d5daf01755f442d8d60d2b35e4edadc4a79095b8c6d6c5c5f71e0d43bd6733e4a641b06d6e6ca88fe842730fd17ac81c92da214b452a71673645245132809be8c283835c95c835895cdb87c329b9e18dc3323aafd0b9cb78dfbe830b9df3bc875216bf369cb2dfb8879e7a710f9debcec9fa1a90b832f4e1a896082f727df7b54d6f32c8620964a3c4460229b119722381b61c1b4cd5b7cd270c44a14cf631f10a64693736077da4bb69cfee96565861450e591a62d20994859f5a4317eeaa4392c644972fd3f7882e2497d9b6e3fadb2605e9690d5f5c170ee2dae7a05fb1bacf292ffa4ccb1b8930ec7e34d36a199dd7fde832a48b2e733fa29d6374993f19882afa3801c0832b3ae9323342291da48bbee37ea44374d277884ec2309d1dd20a3be0e2062fa0a16991f09daa968e9c4662cb0be11da593b08c8e8ce8252c33ba5f6c75a21cd1a553de67b28747df2a4774e94c65e69eb85a5c999d3d9c23aed05beef3eea98b9b61f0ab22973ff50b72460e929d9c06737696d41c6a9454a0c9a1a4024dd67a882e33d3675996512a8f9044642a83c840f33386259206692c94e1304621d37758823c710f394d7bd29eb427fd86855bf151e04fd735721a046bf491adfa4e466a73844597104e7419407499b9be91ecc0a20bcd0258c2cd00b073654ed114c52eeedeeb87705fe37c9d33557513e3f60d8e146e289db48d932adae64b7243e9244ea18323b9737de7c4313861840b4b2801c517805a7d443a914e52605c0d770e1ec2adb48b066be3cc961cefa1eff01ec232ddb94e86bb875316df06e736c5d5b004c2d24983f5b80877c2d480c455d5fa6ef694dd54442986c595fa9211892ab5b6760521503124f4840655e8a20a08be0630dc50f2f0742f3ca28b448991690c43a6d18b4c1faf90e9398d4a9ed992b2b4ebcedd5afce2be61d8760ea7ec630bc6bdc3298b6d8b6e53dc8aa5120de322dc50eeb4f66672b51c2fb9d76aaa68c6e4d21c99dc28a5ec2ad2308fb8428f852b314824d2189dc2912194083231b129c1e0081f538e3d4b96a084114422a571efbdac958bd2d31a4b9ac8deb54a744055634224887e712bada75bf670db28addfb66b1bddb62daae86128add46a543bd55e1aa477f9c034cb8b521bcd224fa190020d6f96415759d1a55b624b8cac0b4417fa18558dbae25611df80d8e29aaa992cfbae596bad36f6d859638d353eca1669f871657ef20702ab42f0f9810abaa88223bacc56b7b8af1475b839f440a6b2d5511129ae4452a68d6f5cb93adc4c7f587b5936bae5029dbcaa32ca31267b8e115d648e4d5c54c84c0306c61583b9f75e18d72be67ac1b85e30ac55ccd535ba67ffd8c8227ee479d8c82e71ccd7a3c196f23c7ac4f9f81ecd127177ecd851bb7da77d3d627834d83c9a45daf77b584dc6f0e8d119c681590df6bf9706adb0c28a1cdd3de2974c91c3db3fb8a1cd194d271f35d20580501271ac001d820c60a045567d2ceadd034518446826788191eeeeeeeea63dbb9b3261c2c4a7079f263e384a39f62c319243544f7592592a8c484204303ca9f72ddd979d861abac171b53ed380c9cebd725cf6ec3e7030cdc2d5d75aeb39bc7d309febd560cd7e3badeb05f39cadb8706bbc6aed898248ceea911bdaf823457df7f282ef6db63be77d355a555970fbe14aae7498fdfe61766d2c2348bfaa24c8fd4af30441e719a748fb4bd355c7d16870fb3e55f516b5c44b532f6eb8ca3514325373ca6ccaf53d82748ba8de064eaebd53a35922cf929c5cebcf92277218bb90118b5c3fe9aa59263dcdec8c08223c8944c8f133a24bccf2973474a3b69438e8434dd3341ccda2e16e1c0dea109365966326571b3824061b6c9ea661a359ba098d1e2880624ddc7e54e95ad34515ce4991b8420fd420ed2f32d56692a964ee34487170399ce812caa3df67f473e77ead440060dc89a495a4e44b13091039464ae2cb934a1876b19d2aedb0119e69350e9be7c6fb911d7d8461a393704ccd9e58f2ccb42c0ebdfd3b676862dbc9eef9d9fbd15ff7a36b3a0a86dd9b1ae5a37b6bdff7afd1efe8250c5b8d7034dda27c2f5dfa8bf41289849a2aad278cf4128e5355fae88dbae0fb46dbb8e38a761957343b5517a859681660ec9b21779374644b2b99aaedfd2e64e38624301f7ae82fed63d5d1c073650ed10fc19138589c9e1e239de6cd39499ff6d117e7d612ef207d8465644aa35f1c5bb195ea1da4df7b1930dbefb8279d84654cf8e2b7ec6db9433bb774424316985802354849a49209e5f6d36442e9e429e5744af9c5d7963eba45f9bd2d7df457e9238cf28b47275de6a67c32a593a8a4ac1775414c95a2190120002000c314002020100c870362f18040226b931f14000d83aa4e6e4c1ac9d32888614e216308318400000001181111d2b40920ba942a8cbde81c14c3fdea0a82824b6abf724bd5fff5abba7e36cd081f42841a3e8d589954911c46deff43d4a417d352a5d0bf67278edc51fbabef31ae69679b2f1dd7c53718eb4ee3afb8976666a8e4a974971f14e7bfdf38fbde0ca8c6dc55ec5d42fa48ad8d2ecca73c5f6996e2f723d936103f66e275c9145969712f4612c0b4531b223d07758f54d2fe9d5b254d19c99c68c975561f8a97eb15c2e93bec2a5bbd2d9fac9874f4cbf027ae16f95b9dc32c4f565a0d2dde3ea347a88ea53a6e693af227ab8074de3b2db55046dc750c71d88229e79b6ba4ccb7bf918896d0459cd1e659e21344a9c2c948c1f580b88168fd34359736516b624f824f43d4cbceaa5157c429c9d4203232548654acd9f60cf4d5077d4f4e1249fd985da0b1dca5d7b1915f5fb94fc274ae5616a5b25e6d5170303271e1b05d68bf326a82f8d260bbf471cbaf7a35e9025707ca0043f5fb7ab67a840b8b3263ecc7a7ddcd4ca2c30387d8b46b73f237b8df39c7a7e7683cff2cbcbb2193eee4b46756a84d1c2b465119c01182ea14d3cd3412a64fa67c286e7f82c3ef05221cea799a616fb80a57c5270400df974dea340696b8046bfadbb678cce68e7c8d00faa8552057e02b5fb713560ae861610cf83d2e4e6bf81943810214c7fd0402c44a772326ea421f35d8bb1800341d473566097ecf7143f5b041522aba2f3f8bca1d41f35ad19a653f799877d78ea3a01b13047cb28f6a8a34ecaed45ef33d6bf160c45298e1c6ce52a533d086fe5afa71844882ac39f71a41367c99d302a77f10f59b4bd36df93aa7b2d1552dbc1232add751559116803536225b4b0a121dba218946e5136d0e835a344bf0ba5a7ce6e16d03068bdb3a852a69785b99a7949d32f24b00937601115dbf53e1e5f7a7287eae0f4532a0d76323d926d91bfc7010afc08de1a571209d26f999481337e3352418b104402042636689f359abcf1d93235f48d5872853dc3f7f3ad2bd331c7cdc15c9d26996c706b6d20785c8e81f1f91cf58df09529a6e46d78a0955eed735b51fd8ddbb65e6aae25de354b86647473697135a38ab943b7235353d654ecb64608e63cb11a83e88a9c62b920735e21b7831b5c2f39f289cfded3b3d641d8e781679335c8a9079e768c77461e814e3e0021cc9f25738c7225091cf68dcb2006da4adb010fc4f8c0546d0e76c93b1b3224ecc30c4ff942c4781139cc82ff2293312b3bf47f2aefc7eae52618ec3c09fc1d3df7203bc0c850d1039b68cbddcea7fb8c622d6b9d9c07aab8a1e94e21dbda163626c5317278f0f06ca4ba80220e22ca74839e36d422158da641399e40921df24305e7e82ed435c376bb999e24e1260d285b6a889a0d7228a209187a20001d53b9d38256b37eb7b20a24fc8d251f69ccb4dcf071ea9432bf5f31467bf588e446c442d0a3fcac9456c150de2f062ac465c443a4b26f569e763cc131502652ff50963634a3b7297ed7edca438a27f163d318a37d428c664bf4e2f501236ec7c18c1d4c97aae59be2c689146c1d4d0d90e5552f8216bc9e2b6de2c813ad9c1b7fc487a7c1bc86c4d279e2870207f616f06022e5fd97eca0a0f0c05f5271b51f3d21e15cfb147bb692a72ed7acd5988deeda8b571b821aa63329dc7676b69b753e1e288a4263bd9221bbd1271b345f8a62c23ca5c946d31b0ac65ee7c057af86d8e3ae749202f030baa6ca2cb060cebcdb88593f0733d995bed518ad7b36225a57ae709c23847026329eceed3d0a0b680e29db470a3ac7ce5b80c0d368bc1a3993d949e9a83e1a4319b740b02e58ad6a0820ab7a017adb3d06d00c8ba74dc4ea33e52ebd244af9152de63303c1e2b38e0b66d317bf611b9fb039518c189f8db5f6a5502e2c9210746fba55065f4631a725041fed2511b0da29ec8373c15a5efa4bb7eba86802f5d5a1dc854bae79daf08254c837fc2b36db3ebe78d09d7950dfbe9a5405010ea4de4aa0807a1340e88284e10cb8d90a2f13935479c3f43df595b3440f2889b7f35d87b3356e3b162afe6b4927ec0ebe42392ec9fb999b4fcc2588912d430e4558d174f54bb361c4ff8ef4b163ec0e790f9dff1ed7c29cf8bc9e64f572ff7dd22eca03f609bab34fe18a4762c25593cd178674ea7b502874384956254f085b83fb3e2d7f7e318f08a01cf8b8c49f495ee913b6101418c659b00c640104ede37e2a3a4024733529d721d4003b5e5b786c29a7388450b3a641ac258ad9091b9bb5cff234c89b72c886b043c21cbddb5c6102d24264426ba7fbe73faf96e1dd2e69c50fcb430792c64a0e3ff061b0439e4c8a88794aaf6d299ee70f8fb3a79c779936d6fafa153a11be724991b0069a8fa52ecf46709a6c4435665917ec884383125606c7775c21a035430de4293ac57cbbda062ccfc23f546c2be6049383bd3f83964a411475d24fbd8c9e43a6712183b120f5009fb080eba7d0b0aa3ac2149a8229f3091a94a820c14219ed5f5914b32bf934fb7ac5f128218b94c128b2b691350239d536e907b74ac039f3f2e69dc721927668118607c1b68fc0ab47f85e79026b2ce30f14c29834ec3f14ce5fbe05d0f1e4e60c1d9a1ee42a79c41d659f2f24b0e1f82edfd56bbe680cacf94694a1760c3144333d55bc7f4d9529d5f8489e2350ef480b787f865293c5152fd9ef71c432a358a0829676949b0fbacc62b9b36f623f03ddffb1e3e91531ec8c128d54407a1e2b82880c465afa49d2fbf0fdf099a8b6807bb2f881ee22caa658f6ac1f1616f133d5ca35d2193abb8d4baac97bd1c4cfc3128866f8eafb35ca1ee82f2b005b8575bea9f27ec427885d50214f1fe6277d71b09b07130556a2cabf00ed30c9c20d0dd9fac0dd6696baf139e6c07ca531e1c8c6e1a3084b0e6e0d50ae7275a2e14140c8696734ef8fc243ed3bb27ec253e2366b99804ce1f90b094e00a5826500b1ec278068d9c5bc017c71c307331f2b332ecbea224bdaa14fa6357ab8b300d2dc81d97144029a9c1f87efd592fe367c51b3836c8ebc51fe6b8b85c123e6f92a9fd7f0dd62bcefe2b0f00a51c75250851df3e74ba4e678e5c49d88dacea588556380fce909cff8039b82d811e0585eeffc727834bd8b8dc6601573e8fbbfba51489b97f8a12d8fe4849761f6578df5ffb8cc4a5ec3a3cde9060385227f28411e8b282fb124558a600deed95789138c922928e4de8c03a82eff7fd4d05dc0501e400388efbd2b91920156622d7f214b60721ff5e1fd3f75e121ad75f76fef59fe249d860b505865d44e486c6114580aa86ab911ce832c155ddd186b5ba2279c00a40c89261e14c926b4490364d17d1559fdb6f79d73482d6b400d73fb05aa973a3fa096317964ade506c46db2aa910f91ae70267c83d62a701817aac49d2d8db3bab47cc7b6198bc75a327cfff3695f557dabd673448d45115a151138d2d23dc5a31788916aaf88f3ca1bfcfb1240e0c32ad0eb13dc1f5b6342a3090695c1a87c735bab6f26a0af94b57b5480d4c9b4e91935899a82c662457cf91a7616ff42d541ba3ea0d46724a4729dbe6f5a063af1fcd6708ca048152fdab2efc64e85f9c2f93054524e7a21a743ea9824712d23921a4a1302109b4783609a22ef39407ad727ce30a02ef619ce69d4886502ea8703104510f52d1d961f642d0212b0bc87d6833b8e34fb6f4cdd55aae01a63fa305fe141d7a6b20541e3054642392c0dea3984fb6f7b3a8deb36c1111eba7dfcddbee491bf7dcf1fb590aeab2716cd9993af260eabdf21e3323295a34bf5f9583f6ad63030ccc6e32a2025c429ae047640390374f01822fa23c72ce5a9dfbe386498e706069f4895cc518b49f9069d39b2587875200bdbc830372e4003d57ac6448bab4402224bce39b1d2268de6cfa0e1bef3232dcc66810fa447280227ba8c81694e1b55a060295b66735bec3b69929d90e8d51db54bfaf4008ea06e5f7eec487dcadd53cb657495bff8dbe03d74bad404af68385497799faba6eb2207b6a943a63b3f03c68c80f3275bc1a0bd332ad79416df200bbce6ec7c8551de0ba6939d0f932a171ce482f1de0fb926b94ef5685febe1610cc3edb4aff83805153de8ea2e9f9e5e332a9967feddbc29c5a00e17b75b7d59b2a6d53c249730a749b6540c870f18388f102b085e44bdb44889c2d956a70360395465bd0e34b40ab5c009f2896278258f705fd28c2f2596a79c10de9d6657336b44f658b390e4e4149bb3682dddd2b2fb48dab1750726bbe1a059bc60c0831589ac33f750ad1beca08f5cfcf0a407dd8c09b28fdd3d9ec31fbd5ab1fc54978bcf9e6a857bd794c7bdbb3a4e9298d07ec1c855ad8030b0520d42df0ab770317a3235f78d1281622604401195becbee5143bada08130deea7f2301e3b6172d7a8715e223bcf31645b27e0e558e5e5ebe610ec4a8b73ee667fba15728dd0e2234009a7ff9e6b96579a3d04fc84dbb5a277181fb379315dd0dd7d820afeb4cc69668a8690d493f3a54604f06fcb73e0dafa07befe56198d76bc7e67d47da62698b0f3b1047386e110e2b5d84da07ce4930f25bcd6ec27fb98c2c7e52f5a4e3922fcd05587c3fcf4649449b8fea7cd947df28f9da4f6506fafd229008bdcb101ff1ad4e0493eff08cf720dceb6852e5d40827881130e003c2ad9e54f15794eabae60b5a7d29075d40c7e9c264d7c5c426b00719a1ac3369c1fa29f1c89d192e1304542709ebfd8a15e724912936aa3cbb48ade181c70ae8b4635c3d604a9686e8432bfe909f6365c1ba7ca85fd3c424f9ccd91556dac0a137022b57cbd5615a189f8c4ac403204bbd61ddc4fe568aa1b24eee6676d8e1a50c4e4d3aed42f21d0b0aa73a806cfd3561657979d4c335be15f0579ef847107b0562dc126b454e39443267a441722ac106583e7e06dfbf9704290b659e9e11ec901f31b00dfaf26e5edec1341ee2bb3260a1872ae7b471307bb97c112be0bafc848de2b7e7860d62e517b6f7516b2c5f26493d6f7cc9f2de67c93e44214cb72c04d46277184c4fa5a31bce681153484768618cd68e147553953517ba55c0ea5867a4088e2d480d31ae67c9b6a3c6d6bc9e21a32c85d89a9d4733ec97e5390942daec9e6d357b2609a6c58f20a76b7e0040ca48d0bc2fcea5132e9ece05fbe4669e275c5cdc02de7398513c79190f3ea0d16410e7bec85e7b055beeec354deb090617b64c72f4075e5ce16e590b599ad61cd043b603f9085be0d6af7d586e7359016dfcf26e5e18abfc99b32e4915346d9b76309d25ee98f7da743adce963b25b7eabf7f976cbd9d1af9f2f46a287c8cb79ec0ea37861a60838c00d2ec566bccd4e812f0842d4db134ed77359df06959eceac428239e854052fdd86d14941c71bb9adc208551f39e3329769104e0c8eb24742735b828c2e2247d8d6453ebb881ae45ca8887521833b545886039302b9ac39ebae366307a4d9d9d3f4f40276d073282e3c51e5f510da1cfdeb6ceb0f45bdb38a64320810a8efd61e0527d6290adceecbd775d47ea2b8f51cf6d06b68516b2dc305f11b656f6c3b6d8da64d4c7741a2a6c056cb64713abf8bdccb655be03cf8292f271ec0e8a468391b4dbf66d975a8005c418b8a56bca370a448b59aa1b37294616ca10c59fc130d7187520dc90a6b6864d2b7432d4ac0e3a7c87853c8dacb90c9630d7c2272fa499214ba803da96f7aba412410cca108698f74e0b2513748833427eca73a3e79ca3c54c6451611367efabcdd872406d8d3b28abbd91ab70c0ce1542f4464e957a59993dbeb2518961ee07201170b1049a010c407c01d9643bc42948e676f14b6271a416e05cb140832cd7601a2906a16876605ddbf5228a00b78efaab6662889966d902bfa16467ca55db9c9dcbbf43fcf4ed74d7bad523288f494f1c3dab4e2422c0ac4fbfc7e7d8cfaed6f97981546c5171023e460c447414c1bb1fe1807374da41f78d4240c54885655ce55fd4429484da394f1f7949b0239512fd02c2ba92398bc4d7eefdd94fdcd14532eec727be4e5c7bad11381c7c2544a7d9b67a5826f11b1e4776aae6eb636c2d0bf32ea995bdfb803ffd8a7a565e23587cd66c3986ae179f6b129399f286aad7e4ce26efce8532c01e85850ad58f609eb6370a7dce18b8018c85824f37e545b95df1b7e04638c11546c006ba5c904212833b48c0caac3a21e367370cc100df488d20e221d1c071e06c16c28682b7a877475b6e123dba7c4420809d3747b653928c2fbb55a8614be89a5aec4e20b36b0430939971975ba923d92c54a8fe760f14b5d9e78f6141234b6507fa84b06c87f47c7939de2dfcbe6f910c3d056fa4977b51eee5781c4c536ab4af17fd623b417e3be4c567f18c29353d42534ab4a460b55be0bb5eb85295b16697499d165de1d5f3e402d51563c83a3e25503ecc45343253ef75d71f358bdae4fc65dbd7397c8937530371b34c803d3ce74b464840b595b84ca08671a610281fe8c1b3db9ff89387926d21acaea6967ca3174cadae1dd6585dfb606ab396b2827e0a57195524ff9a1326d427964a27fa8d3dbfbff44e550fac481ee644e1d89552af309c9efe2cf841d2126fee500d5802f22b60411c899e14b0ff836ccb85429ca8a2050d4d623e691184941ee4afa9e29ef8b865110d6861c4e2f305d9a8351979f4ebbbe759ee0cc9bb1637a78285897fd321ecb937ef08cac77666e5caaab72e2355b11416ae100b304799f5d416e59066edc0b833c01a3410c1b9f04959a1b62e320316a9268d7f1774a215ff21b62ef2896b8353335a32903abd275760197aaba2c6d8918d24424eb0f492315abf235c01b1a29a8b713d121f9f32e0d48a952c2882191fd836e085cceac673cad2f847ff40292e3c12f2764d29c4b2931f2c2b489abacd2b32aff72b1b0c58d242fff95c88cc99bd122d147f6d6a270403c0d8569dfe492478fb051fdfd5564286104b78c1c9155c048000d26276925961efdd6b8feae919f1a5de380f474007b4f9149ebe8bb5e229e4fea7ca54e11efda06d5ae5b930406e0d8a94c16bed42ce73e6d217c6bb5fda479247be06b8fabec7b99954952feab89ca34eccc4a3039c527955fd78f12c85f3069a7758287c57c27a9651e4304e07e4acafc3f6b56152fb7f5d0484656d3c378f5ab38346e70735de0461db6ed4d491f9af1699a0cf3dcf6aafbc3b7a77a053433abc351a6af39d59fcba3aea431b19d7571ea22dfb11c71321ace3b8c37fe23c874766ff44a4320a75d54130d80ec7621df0219b8a8d3e116f5e1d0e85a38f0a84c15dd40af3ed4796a5291dcdf7b012b89c528a348a06b5f9db31b4e18d345f36ded3be82a879744cce0847b0e13fba15c013ae892f0ee8c7c6840c1a5ac7318de809d9c2ea43f2e3a5136e8858f82bafc7b14ad066120226191be7ea480658ed5103c85d3224b110359236e647d5163f2e2f9603a6851bd367e395c84b4898196faabf63eebf1e4314493bd14f09eee37c4f42b4b86de4afae186f5b5d75fa5941dcb0ed5afd66c7f4070ab0b4585632d3c0e8de767d1865ea03bf397cd50e4fe0d7e0203a00b656f2003d3f6f591ec2ea1c6ac7542a567e39c366ef52ae892915081e360014adf7a594227c8f4bb03c4371343f4e24ec34bc23ec80cf1e7db1534186dbada216d7b9cce945e87614222eca43e0e33304c05939e44f5754e7ede6ad2f6268fc142619351163e7b34778a5c7807ead0695d07113e7a11c176a94021c3ed9d0cef3e4b274ae293aed5d9d3e9cfc45e35f5dd2d4b4ae761229b05f8c81db99330c207131b319a13d527980cbc82cb0704fc465ea75f02c4cf9bcb9c320a9721e27a4e9c333133737412cf8af2b3692334d3c4a0fa6b0d6eec86f69c1f88582c6d7645c9cbec53a8a47658ec3e1de06c9cf5fa67e4031e6db6895b6ae9315f67339fa290511850ffdf64f1dd5ed66c08cfd53fecfda9b66c7b49d9fa242a835a9da124ac62891871c1fa5be35e0ad9eb2b27ce3cd42e767ed91e4486bba2ce72df8c112bdd0b79b3562ee5f531d0f01a97f64238ea8b28f054fe4f37b6ae859f56d17acea721d3b7eac6f3d7a85f2e8930bf1856b8ac75cde72eadbed59d53f717cb8cb54c56589f60c995801e94391fc4724e35f0551e3b301f17e40584ee415819b3b7fc12d92f3429c3b54079acc852647a023279c2d036a6e29d480618a9df651e150166a137efcc2e309c3f72b8bb590cad436477909f0b8b0d94b9e6c7e1d682d248d67403c55ce1ca82ce8207b626e4ba6d737a16c7612a61e93984dd6c28a46f281fb34122bcb7c248ae39207674ae287a1f79387df61395cb6679443e482493926bf10290ff5666ae014d6b82b6bf139ddd89a9e34460640b3caf0b70485f4d37ab6ab6362429ad0c8658b76b900602ae8ccad4bfa3582bc323ae946d1b75e44d88ca86d0e5f637a6150882ae0f6aae405ea12d6df77ac663e28ab6e63ac9d3b8082c951d2f83df4550f2e645d4892498c52a3dc023f4bbc5500a3dd810a382966ea97d0697cb4fbb338a4f0b078f367ba4938059f5ed83a54f39788bb8404c35309bb49943d730237444bcd1467f268d8c83c6356bd751820ee3c9c576d3e538d5a87d63e0fa4d35ec0ecc6c08976f9c768e593d7229d4f3e4670f7063698fd873ed5712c0bbc2fcb87a08c432d3523798cf0119d51270496dd5e2fe3e56132962dee12d2c2f3c8f41f8fb29fc13975fe24ac35d696fc52bde035f4134584a005936c80a4102fb56d517fbca6b689da0b0cbe0652848599c0737597fbae03741fb0bd756fd40ae849d8c15ebbdb1adcfce40091323cd7f0a2d06f0fcba69a35c0db345b3170d6d03b7cccaec060b39402f8ee244c649b2523db53c25b6b4ce6512e08d2dec88ec22b203a2901ce5f433f6748b6aff81085733a1174ec4a3c55219f0962c00d8dca47fb4953f768e0a7b45f2147cbb8fd0871a2f180d82af43d00b3cb0b88fd63ec21e89e1e2221d69c7bf8a01cac477750127a4d4e99ad4c9bb999ef51e493b8c8e39c305fa0b86284dcf6c1e714c40330316d555eddba7674a83d2bbc8762a22f69d4ae2ff64381a2fe68a6a2e07871d4f27a9df04aff1ee0ba714262ccd301c7c3e4f18ec3e05a0f9d49c0bf6bb287fc7611aaacda61533305e7b488d4e03701f8d26632847e523797198d2ee4c8c8865cf1876e9b2bcfc1cdfbe6271a231922616a2aaf372894f6f30d28b065e3274f89faf3e02a24b0a541f3d5995d509511d0eba57da48e857f40882b2a65683b1a48d59bcd823f34094b754365c2db67dee8857b277a206a21f42de6ed2c55fd11ffd8d665114c780d8b7de7e685dc7f6fb36b05db99afb5fb745d74984524677c6babd41bc08b1228a2288dbc19af134abd271d76de955e0c5f4aee350a12487ed1013310a72ae9bc44af61a650d1a8b3f006044ae90930423b0b45a9d669502b90bdb098f9b4ecc5c8622e7429a0dbcef72b0cf84c865a8e938138af67523985787f0ab9b97da16f9cc888beafe8823e0a02b8b200756d81ee15adeabfc0eab9e6a3180a6f7c7bb1dacc65de75bd082d13b1b5fd055c487c6f1bc423ece879ee7f87348cecb87b6a8513032635bd29017deb751c9e08582117b880f6c355db47ad76de14a141da2bb894063cadd5c70520ba0015b286f61eabed0d88ded949251b40a1a23b151a1877329e86cdbdb1310936f05cb4550e069192a93af62573c4b708ab221d94210b874e5825bd6b2c52e78e8644773420f3759c654ba1e5d258ade0963191b5a1dd2a1ddaca4669666deb77496021ed3a14f0ac93b0c7babdc59789ae8a7280149a8d38d1ff581fa38b94c16ee8654ca1b6507a9a2b8b0bbb06b58d49e109e2d9019766926667e3fb0c2c2a41e783f7e9eff953e86750555e0d24aec890e9951583924fe18987eb161cdb84b13161c8d41caadf7e0bd6f64ee815053ccc00bc967c84584fcdbe49890a747cb647d014d48deeaa024afde198581960957923c48d94b32e93af7f9eecf7c635c68c2742cec1c880f20207dde5f8ad586e55d6f0987ee5b2519fe8cef1379f8dce8b39a42e38889f7e1e4c6aa3066b780d7ef584c3fba1b54cb268ac10ea5db8aaf13f1ee2136dd87325541233fbee10f25b3d1515bfbf8ce2e3c66bb0867ff1ae219f8805caad54b0a3191ed46f7e61d18020c3c9d8f475d077e188218459fd796c46b7598899898b03a0464140a2154bb93cea55f60d6d6742781cb0494b0954483360abf280d7460b52d3fe84d95b60ac9ed9b977cd6b65cc9cfbe7b08dbfe3af58c2e8d8b847271e0bc4542c1989982a0a22f5453e0852eb76d6eb362ffe82e709133431e846acb9184fb4f44918fe97389528384c01f81eefc1a1fb7157b3b864a2007111d5fb554a6d0ff87097af4ccca2db136b7e23f79d6aaad245ff998800442ab84a424ba24ff38599655418db7c07da9376e5a474a9c7d81668f8acdbe6e17c3f49035e01954d57538a98ad3667d2b332916cedefb47e5202d76441e6acdef3c748ad0fcc267698327f32b8331bf3234590be98077ff14537119c4f2dcc7f64c25f2f76bb187dbcba8e5a227b4f41d43a56b6449279adeca752e449362c7d0818fd99a4baa620e7e057426b15b43daf1832c4219959dbc6534b6667d13312c8ab12d38f7f5ea7f8b69498eb8abaf8a716db958eb8706451414f956e505758890ccc4bcdb44e3ae04d1d2a21603c53367a9e6eb009d4171bba4779cba21816fe0ce2c371dbb09f018c59ca15813e0a04119475bab3c1f0d3ca79884a1ba3d8f264367db973ca699a26bba920aeffb8c98d4acd309a8eafc04f52a4f5d4ce1adda7e0dc7d89e759e2ff479463e34a5676f56f796f6ad4e5ee454660dd642cfb5a874d4886a402ce029744bcefe5f81bedb06b1dd5b1f63d6da35bf22636efe884ae42582bf46baf6e0592385a31c853d564e89ab538bc12ed56fceb7dfb3e037b93d70ae7c315edab48a9c561ccd9dc91955660d371eef1548c88cdb8acb9fbe5ddc4cf7e4f461c335e0f8a3e8f2bfa8e3ce1227b17cbb943fec9e811eb3be16b4bb442d3cacf352dc9feb05c0ee0b3f044dca5477f3994cd25088209bf36fdd82424d8d695d0c5a722aee9ecf28c352958b2882a901e93c4c10ca49e7973e17f96fd56b99efa37dc15a2f45ced1cd63b972b18c1f1d7a7fb6dbe4e483b91a6d842d8e141f3bba1277310b41acee62472f184d24aa2e6423a3943c05e408a20231099174373c763e690950b0ea6e31075d414818c4536aca58f98f5ebebe3488b4a1ffd1e023ea9df786666643d2a4b729f0060eb53886182a9f03435cd75f318c2549a79366761dddd71ddc21d5ff01aec0c9a33d4fb649f99759a393764df9c3db4119e8d73b53dac303a8ffa3f92936ca1f4abf8d0629837090a863d85775d3d4e26e99dcf03cca4c9cf32c9d98154e391b6c5ce72f28e912181ee7fda8046181f69caa360506644df207ee55e8a17223bcdb3719518dcbee8796a0a5ca43003a757a841e88563cd4b72eec2c62f2b081a60213e25b810ea0fcea7dad26861dd7ed56c98767fb7b5a5a6aee612b843a9930bfe15bbf25b6c2aecb170361c67faf22a5066ac01b1c4c9f416b13f4a1081604bd2054f9e46363b67866577d0c621046f7188ce6397ac60844e8d8a818ef1fa09e851958bb252381b84afc7f382fbfb9d7c857fcd79fc8acfaa2f78f88ce3899e0cf7146b5011880d1a1946103572b4eb3092ecc77c4d744d03229a4be0599007439da4ef36fc69c5f59b229a46e13c616064829997155caf03bb0fc07dcefba8477adce1d668edabd14a708fa5a496950148901429609dbafafe7d6ee9432376415a9d4ccdeb11446da6a17bfc3015c6c449a0c9a371fbcb7b24c9d75757ffdfca3f0c043d91124c776ec3b5083ff0cf93448ac917acd9ebb2bf44aa4f5d78b138c50cea407ea53887ba4c162dee9ad00aa1e7ae861a8219aedcade0f05b14374f8d12cc7562a4058c2620308902948dfe6099b0d6ab962ca116d6d97668413fe562fd1a6308ac0f25e8034d8366781757775c88417709273b14e5775f4aaae8d7592b848a2eea62cfbfba52884742dff83cb50b1ce52b31c2896077430c9b3e633e9784b6876e32d065276df0451a1d32c0cc6fbd87e75b93049d37e6caa0fc6ca82250742229863dc0c0dd58ea17249bd06bf7856b3e28d0f5959e9dfd0de7552a892821c1e9cebd1b54aae2bd5adcc79d6937997a086f2ac7e8d1491a27ecfa0e6bddf443b797689d04d576469934cd21fc9f80e65b1c8100fbf423a0a1ddf908dd24ff14bf8f05b9fc8506e4b8a90be677da9560c2afc83de491cc4b97f94403abac0f0a194fe64be626019bf8426dca240383b6b8b7f8ee2d330d5efad6939ccd898bd0d0d8e0142389737439d98512164a7c1a6882194e72292abb10cb6590c0ca258fc4eb274ea4e3c342bf379927aa4477b962f150394ea6832831c8fccf69a5d8a0b32128e18a4344f1551cb06d2950222ba23b1c8c89655dddab670f4846308349cb9c0232deec73a8f44e26fe46f03eb45e5818b704bc967528a9e3620ab508089ca2b9588d23a9b664742892c6927e758dc1223fd388b65fae4fb55b416935de3d050b654918b8e9f78d91b49b994a69c179e1a2d80789b4e1a70843111a8d3bb7350fcba57d154838bbc1dea4f9159001b5bdc71f35a629f69448d2650fa0032919423aa1ca27b606a6fb4256346dbd0a60e3384f5bc9e1f177a4205e8be892ca8f6919246029471131f4efa04f69f26a3d23a3ca07a57a993acda25b63457e1254400a61d9e4e5cdfc13199bc835bd22a848d6fe05801ae7b8fa8a10b30bb7d9c8e4cb583e8aa5ae4830c9f14b933354dee709f909c1df1c744e6124d06a7708e5b1dee475f0a2c06719bdddbc88e4e43b50733fb956e4033bddba17c3c2b66047f32f304e54f56db386d4a0d10e52f93b8440a164719928625ef4a683e9666a56b0320717c0f9f14fb5edf9fce986b23cff84a2aee5271ce5f9798bafa4fe6f6c7e7812711692e83363c017b946c0f91d6f8be40eacf2fb827bae3d54d6d4f9387b8e92f3f82a1392b25f22f64174a19e14149a533725048908b6292200567ed9fe2010c1a7ea3347727ee569d472d03e260065991e26af101c251ba23a7d7480643295fb203d5b7a3b3e6e25af36a9c47ad7b9c38498e771dcfcf31574b8390c9191075abab3f89d01bd559effae6fd0c75e488cfc6379b8bb0dd3be1f5374c87758c011ab5b0313a0b34a32375b190eaea9760f336c664952e07beabfc838b9b8a81a5c420bc1d2856a83b67e6ec93c1b6258aaeca26b04145cf218cefd7b613aa83e3b9cdeee9fb3f1f228bbd6ae65f874212705c407752a0b1d740caae552627de4ea66e87360a180e31827b7c9fb0835d9c7ab168706ff865dfc7e1deb6e85d1a544baf53944d11fa0f6cf35c6355e202dbcecc76c52f3d188a43db6cc9dd73a4f8469a824b196f62124d32370f5a85ea45c14abfd037b752383cb7c5ce4725f42251b4ddcef8b6ad07e5449de1e58cb0fe500f6251ca865ad36c08340110ece19144bab4cece6964cfe2cc3bd1d29d1f193260ce92e734034630f2a35dc34103de3a7dd0e8b8c03d6edd8dd277ab4a7785710528ba32afe6a9225ae4c188bc5ebd50634fba8cc59ea7aaf3c7d0d052325daa473d2871e2f3161fccc44876a1c79595f6a46366296ed1b0c1cc49bd5cab8e05f59855139b602dbb0e1825889b2315de3594e6883d720db5558ab61b58efb142ae4c35b26a14972fd034ce7a9c831207f2a17aafe4de3d0bd1dce621babaed2fc8e1f561660b9626a7902a80d0ea0867508c9c0236c2900dd38d595b3d1c5e5d787b3dd92a23edec5716aa1e56d28f1987b215ce02664fa6b212ac3c842ebb7c579b3881c61ebebced8a06acdacb30ccdaaeda6ea8dcf57cbeff0eaa54252f18709be6c46358d9656054aebb848c7cd1b53223f36e94a5262215b004176f6963f05102b736dde71a69ffc688758c0961515525228552c4f630ec468399d151891721bb00a3a1ab5a92fd29ba2f3f465784c904adae0b00190ca8b0ff5cf003e63c258a2dde978f139c25b7f591c064e854521d02336fa3ed5953f9e6b66795c1a3c58affa386f8e752d4d57b8b57a88a4bbd31a297bc82da93217c67f803278cc3b8c6618154445edadf6e512e79dddfd81383ccebeadbe3ecf42e7ad28a18880963254c9e661bff80a7c84f7d7c53aa7fe71afb3c5004ce2e37ce595e88c642599718affcbf64c904780f035931b5c98985693ff9c6403a2b10be6750e6eebc11867ea182f0134ab5bb5c79a5fb7f527750958cb0e08229b4377591d30f91d1a534ff23e87f5c2054c11a57ba12fa3c2b976c00c1346185f5ce14de8ae218266e45ddddf98344364f4f214178f6954bcee6855bd3296b610e0fb69c8bd219aad27987fa31879e4743006e5e0f92d6bd15cf2f4b95fa0d8b7218ab21647b0bb1c0b83fd16ef26d9148d389bb09c5963cf9c9d4f6f539d827fa269cbe81c815c4f0752eb32d86352ba3e3e0427b78244d1e360c5504f830394b40948ccc8686a6578759b6991a4df92984876467262e6636642cd55877420344bc6569715e12071e692a7cb22711d90feb500f83d3df3f1c32f2183ef4fae32de6e8afdcef1facf6bbd531703d0a2a8838a503aabeb506bbf9fb87e2836082e1c9c55b0e5c082c0005b62a7778580858ac9d4d82171888b2c605d24b137281cc4556faf70d786dcbd9ecb11836b15e5fd7ea078399ddbeea4c4394fce1c704fde18a3588ba080cec67ea2bc3312cacb2a500d60b8e54ef07e95b3ef689ededb284e8c9c30b587443c77a1628cb3340ca7796768fafdd32442bc2b182d8c30fa54967c312894179aeb37e6002bf92f76af8adf5c12a0a43a7b419a178ca582d4e7190fa735411f01b8246ddc10d866916bee3dc55b59e58facc2713350bdeec614c937012efd402a99c5ca83b1c801d879c456ec4ae621d58c01d65680e52329ad87700789000a5c802ec7734bd7048b6b03fa009bc98e4a7eb2c34d3bd5b811042424680f5bc6c257cc32726f24995f53cd1ff4c746631f090e60892fa7b9e7d1f0d683121e2fa89b09d8594974064b33d11a9ea517200b2d570355eeb9a39f8cae722f970053879cba5ffb90c551e72adaebbdd15fefdfa0f3cf4e04ef9b67f9fab96bfb5d72d6cbf196fa98f1ee1e878ffa145c9bc4aa3e411954494aff8b80bdd7049fb3c814ec70dbdb414c34db693d6f5787592a0f1ebf7c1b89bfcb3fff936d7d7cc07326a52a57206c33ab8571101a11ce9245a6196e1e5f922edd50a3ad03b8e36fcc21667453c4399b0f4ee39f15550985c911cce8d26cf7ab1b815e7216a8e96b8a812462207f8a51e9a54923138a0ac220bd00bb11ef91e1e79f53ac8a70783e7a6998680e36000d002d53ba97fd51a09774f18d9a4220ce50c39fe527ae1024f2f285848ae29af638a1f5eb056305609f5e15cabd7b90f15442765684a010cfe570db9ba66de5ada9bdcc9456a3957bfb48d7f8051ab2234dcce2b8b01ae557c182a8e9500d4867951925f01016cd52046d8325f45add9128200fcd952cbc13230d6ef0563b0bdaafc71ae3c4f3f6e68d5b873f164fa1b479ae98428bb1e3cc034dc658b8ea4980e0fdf7adf91d61992d50a36597734fece06d591028ac47ccc25d7d988101e6b5cb656c34e362af5094e92c20e0d1f3c36dbe2f8cfa0a84372210ba20357e76f18e47e3e4006f1cfa400d087a61fcd2f101b11befeaafdb2994576a78f75839b6a69174175af485abc0e0a6dd81e12377ef180101d3f6d21c36eb58ba64c26f12a1d97c086ca5846a36eb3462bf35697fffc9bc1b97d0266f85c8118dc6594cf4ca82fb8405433583610c50642728ab66df25b1bb94c5efba828b7df6eeaec9530cc9ea33106e18a71790e0e4e531247379efde8299d39980e50a9176e18ce6aa82ff11b5c7f1694ea16294f737bcff2a0d9b4b26bd39db9d4961a32210e5321c667a95be90acac699a906accaf29ef36762e878789970f13fe6160db446ad1d868fc6857e68ee66d6d085b863ed18846e55e501a8aed72dcf5f08bb7ff70b48e50a144e7a037d214043015c69b0f18f16fdb7f9166dfb55a68480567cadb4fb21fe84559bf57e35285b43e3aeb1e5ac4feee183e701a834a55b0cd4b2f61eb9f37ca8a9e1efdc97921304be01b18e1d8a2d50f2c7978d090590f5c8ad4ace6b78b551e65cea365c8e352c5b4d6ae57c5a32e6eb632426b6e6cfb290198222b29705b4219c632e95124ea3d35f2925e45358733ba4ad75a7490ee8e77f8c623bdd3ba5a7c054e922fb8269e684ae154ecc668738bafe1a0188dd3beda462d254bccbb8187a9cc0af38f7b86ba2750b4a83b7a69da5a8316aec1db8a4f1fae550f37deea4ae9d47ece3f63fcb8abd655a94e4a13c3dcea1c662ff564e18662602ee74df9841be146c1c537454c28c53f4ccdac8c632c4991e8eacc8671782fec92f9b7d2495692f01880d715eeb4be0389c94533b93703818e330155076f9aa9be168007635b1f526d1ae5c92df354b5595c8f6bed3cde41ad916a3ee440ba1b65a93bae9994c4f8e601e079493963ee67061874ed5da40cdc0dad7247f68596979ab7105188584309ab480e699430b5a433b3c3013fbd4a1103ee8b570ddae0e9bc2f4567a94da0d98b2f182c944f3b919caf8c009fb15b91057713ee370272adcd8199de644ded7c908803c28b47eea19f486e21cf39d0576605ad7018612958263f1e672d044026f20eb1998ce3a4eb5704353e56b9b34b852dc948dc9bdbf1e8ea0a92a11c0e69c1ddfe16f39449f730681897cab56c9ac9b7d010005b1a93201adcdeb8a75390c6ff54b5bde37028332de40ec70694ce8fecd780f66c031cbfd4aa7c7d4383e5db1d2451baec921a76bbfceeaaee1530d7bec19525713c63f37a1b18df145dcbed6e981d600a6e1ec26b540e92601e841eb7114379313738f413fbade80b2f501f9bea60d12a43a045780cb4b373aa6d610e206ca386b99ec7fa1ab6681a9320bb86402d6456a8866ef352efd816affa080c327aeb164b11c3a51c467a5c78ee303787b0ac4ff528feec12ca3914f778d57b31d8a7eb2b8763d95fc40662d230d0b38b0e5054c775ff232cca8182b3896e6c8d1a2deb67ef93701b60768ab267073c7c89a070257ab1c771f9859c63414cb4f7b00371efde5d423028016cd0110c06e83069ccc4b26762deb14628080bf62b3700526069166038d95e9b1b1124775efc20bab823a52505ba008f3be66d99009d7730983766a9101f6ec5da1c69405036fe5de161db26d6ea785083ac9114148221fb14858b5f911a561296961b2fb232b0adc013b6802a2df0a766aa0524007f932a585782a54be574ef37a4db1095cce6be681302874a9fb8b1f992e2e0fe8ddbb4e84898cc168153e21d70f2bb2c8b9492782e169a753d9cb525e8d49a2500d34eb0a2e938ed7307563d48b321749501595da7af439ccf5861677e3b90632669029110ba5d59e2bb4b6f832425830e954a04d994421dc8a739c9878282fcdc5a928e20cfb8498b4687f921469938265809e04fd7ad21a0773a96e034b02f066edc0fd0afbd445f88487a72973d333ca5037a2d9f90c5eb0619616dc4c575d80569d9827e26a277d841586f9eef6394a325b5a9da5816b0690c558aa29a1331c55c38ec713216efbfb9322ff24cdc82e4d4034b3d65ea8c84efefbd3e5b116471a9920b77088a9d898fcb49cf8c4db764fbebb39b39d7b7b25b121d7ef7958930de12ab652153b0e893673c23b12b60c96f8a7c28d0ba6b5fccfa50594cfa6890e32988cf4ac0cd60480a57a84e4e25f21ac2eed7c9ed841fad933e2777f7f09a13bcf80988dae86dbe877d4e2e6d57c49d22625db425d9c44611310c5f46514c1a2c0f6b61ff1620410c05dcba6e427b9650d3baa8ab87e031f5a8cab39c1fde0be43302f8404f5571e5af37901145875c1d3fce05d7f777e1ef2f012850594b004888133fac7d0e4dff2b04711364bc49509c2f7e629b3a4f991497d542efa31b4eab2e0625f9d3272247e1c4030f9a19416fb5935622bcace9f200fbd6b7704e655e223135a99f78ff664764b0174a824c4ee3b0192c2768094d7c30fc2ed5f70cc6ab68fa1b493902d21cad675f0934c31e77b79fd45011bd0e6c6fa386f39f942d62ba5adfe773eb958318a52ba4c81e075e1411f7538ae17ad9d89d7f6875940226f6d00f823a9c58ef23480e25949414a5f090ccea2542db643f22c2560e906ce76684a618e231164ebace175f8b31e3bfed98153775b3a2004dc9314832d5ae47daf51ee6a813b073832949408cf1ad7cfcfc7f51cd2bd4bdd969751863183fe118995b7a268f35ce53443b6e12cfa4bc34c084e6d3e9215b6b51e477cf5248998da802478bb3192781efc22bfd2b2f85fb536a2e55e0295c094f92ae205a15bbf77e709b5a6b8157832c2d3e67669fb054c1f37c535fccfa7e409f4cd81fe8fabcf52ea3991ccc37016b661ff5bdd1d362ecb0d547a4351d567e1a839ca9e3c5bf27a9769528d86762e0358b7cb1b5a51115ea31c2afa086c93865c2410096e29f320b21f1c0887f25bcc50b320934fc9daf1d6589cfd66bc267f77d1128003c18b5c9ac345e883ac5ee11c5c41f543df29718dcda23807b1736fcaf2613003844b709a76c35d89173668af77459416981f036830aeef0eaeb1ca09d711bea22350f2a49db81dfe1b5a97886d6a15cb98190dbcbb877a3fdf629c30f16a6dbc2d674285f746fb1c2e4dc81f42b52f064ffb8a32da578d4ce9b76abef5a91947760496d1281804ab6f5bc079e19f02fc1ac63f76402f7a01beda48a08230a9dee6de6b8c8998cece6a4b3d3a37e880dedabe170153c9abc9541140cd00b9be5a0678cfbb72f268f145f265eaa781c34e8572b96327a64fe48d57827d492fa52f48907c0726062fd737640661d835221668cbcfd44c18b8debdf7c4efc016d4def3660e89921e037c27c7cb8c350741ccf2ac9b16c7ec14acc7e4b10d25ebd205d7728224187ea93867da359a8a6ad25d56a6e55c9b56c7b5ee3abe763d6b672725238c8c6037e8435fbcad8120f61617690bb2c454aed5e3c3a96f7d9c09342a3170040ba6e8d29021c70326cb3b8187e14c9aa1465b010a933724962ee485d4a46e1aa9d2d34d485827f3cfe37039050029d6d9625888806cdd36c0e1735c0ef6da4e709518ac074949a3c299b54168abce3198140d1de4d1bd92e48d59daa82abf6efe19c71cbc62f58b4efe1290d3e53381f0fe6915aa39492fad9e830408fabd9f25f0aceff1d41e9f51670e3cde28d1f89dcca8c1205df05b2e6c49ce41a81a9bd1907fb8fd2827f41952e5cb779f1401f3893b6a09bd0aebaab5b136590235e02f74f98fd49390757d8e55df118b7accaebeff5e707b4c2dc06e0cdf03d6444b63ddf3f2b7642e585774130b8433a322f989b485f6947a1e9f961a9dfe9fc3ef02228fa1586503d389ccf054d5c5c75c3bd96e065180487783ece3d78f79fd925ddda2c371ffa5fcce34c1e1462d54090d56ad53fc0090617983fc9778893d016ffdd7d809d440149b3447c6567ab62e4b43a90c784f4d42c777dff2554775e325d1c3100bfaa1bb997aaeae09f5c8ec8418345aed6d18de9855388c3fc992e3dc70ddebbf76cceb7fe39883301da39e36de59900d16d9db725f864746823bb16eb2820f1f6e4f39a3026e90d14a0f773fe6ff0ee3cfc8ba0884e0fed0e24c5a4f97c6d0e5ed7e07606e06aa4d5171cb43105dde426b9f227e69800a77f0797874bc401cf356cbfc83f8ff46cf1a38163d58199403ff40ab0177d994b63771332b0a7adf6674aa05b720dfe350fe87907ce62cfbe711c34b75a3e6eef46582058425ceb36c6e28e091e262054059cac5b54050ce32e8c3174db761ab30fc66972d95cd0d64961633405807e0d007556f5102dc2a49007832771b84cc8253c71bd62b07fea9e4772a7ec7aab58b23316faa9baac9a6f32395c986bd4398077f13cf5d2c0ddf0e6ebc469f46eeaf22f1e21714ecb417406a1b90192da3f1d4495c24cf6ffd5d101283b4649796ce7d5a802891d59ece54cebee724ea25adbb4f35512ba0d03570b1990b77c0578cd3364b7e51def8863d4268d1d6f3ec90d2bab2f557233d0d94e1a364474485c72e07cc9f90dd393aa587200c7680cb7e0011238712be6eddae7d5658a5f87a60432fcf767210978716a2283cb0220e5f9724a85107dbe64019e2763722dc8c6319909ccd96161512e216b137d044536ff5eca2434182c31c0662e620cc56752162d5b3fc894812f3b6eb862b4d7b8da5921f73e5d03dc8599526509cdbda1d6e8d80198018a5a91665a9d9fa7b3e841b769834d97d49932971db5659070201c4116ff76a0ee14eac2ca39ebd5baf84eebbf3cf8c2e3af8bad70d973f1067d12744c4b652ce27c2c1b80112115cdca62fff9e27de482a5ea08c6a63b633c514c73b3b52aaa47b1d79a65ede2f58f5b8cf5caea9070050d4159c71c0b9a4d6b552531ecedfec19e61b69ce0591ff82c6197f73478eb6b8fa7e62743169c92b5dbddd52c185029dfe5b558c7af6c7a919dd947c7492798112fd9772a62303014c62702ef28846a4279d129118662791a8ad1c157b9095dc022165cae6f190824e5841cab8c67a9ccbb432a5f18b8d2d3c89c57251bd22d4b62e4865c1d230c32b4b81b825fb074665699c8507af4c97bf4582ee10a1829b3994710b27e19cc96a1d4a8b8385e9b3b95b13694750eea4820d7917b322e6817dd048ef06d7bb21069cb5e5faae526cc71d9823d58635d49cc3221eb57db3aa779b5d38d94c87261048282fabe0afb000f5c53a3ffdd98b3eee06d37c8536e50fbb6b54f197a94bf8ea7ee7036feb187fbe2dfe1cd57637a54acb74ba3bf009e1bbe308a2041c61584b1644fa562000ee0320f33f50d34ed1900cecb47f91eb82a2ccfce0c8707651e422e913aea2ccee913e8ec318dd4aadfd9f687c8d27e61d30695ca6599c07f7b0a8c03d2f0f4859cb69d082462aac6634c59928942cbed1a5a18e439f5e9a3e8dda433d092d38f4a1e2dac01f36cb7cf9e0ef41b21cd4e9898557d15c1318a884a3090364245b86af30149a19866506f0d5e80d8f946142bd4930761b994c6fee386a891704809442f8b43fa770185123c9dddb3918e6c9ebfae5adfe866f66c0627553982f7cff6112636462ab2aba37c4f6ce5cc77e3570354785c2436e49d1d774ca2b9b8299805896a4a88390ad8d821e0c96f8efe651e4f7da2bab403a1c7fb3c74529390ad51ada3c59fa0b02bd22198a3ea84e291957a0554f22948ae7262f74fc312b1dbfe4363a32c04f7d126561e88d0806e2658c38e83d88ce9ce88bffefba70cad88c090f9ad9c9f5c7f933e80b69862dbf43bfc3f0c726eac154eb71e6a8db358a60670b5a310b6541c22c2d81dd250fea72f899a641570219215d52145c703d39008b6e5d31775ca33c57db4818a6909f69ec5ab55a5a6c680775d281c593cb21efc3dffd4a1b78519a893d259d525ee0a9c8e980c9d339c348dd0315746f14b1d2276e5b34c83c60be9ee5bc173c5a7ef69a5fc66a93482a6cbb45690d0ee970e577ca1998c614abb5f35711e00bcb9f90fc50e84b8e47cabad62526873921bf58b5f8bce088c99cc48a377114c0699796897242ffb2d7e2ff4e334cbc1330d3ae17b92e004a56c937c58a6a44b386bda191846ba8d140d2a09bf46f374987d330d8789607a353f5b84bf979db1fcf591174074e6fa06141bc046725d481b39c60ecd7d1a5cd9246f3485719911c2e8a8cc71ee9b7897ab385dc5836d28aa8de7da5b44a6b16545267a718db680765bde65630bb513be1fd796097da98d13ff347daf38a8e535035682b3c530fca9438f7596c07b04ca338132899c851a09b0f0b9cd22807fd9ad4188c16b68bf28ef36a1b1942d474886d7d87518e2bb7b8fa8cabf6ff95038f39e724b979a600f73526f0bcbc59155c609ab86f5e13a009ef1c201616d9f3dfd08816988631464ea60baa276b8f114a8b25d11aa70871de5928f7c6924e22bfd23f8a9330e5144f429573b65d72c21697a070924a2ba0c96fb84b83bc369809b41dea790ec0ce2205e695cdf5e74f53a268ca6d222b21b134638ff7bc1752482f8c47c3bc972d15be545b56601eaf81b55f0d0d3c1eb7aa26dcaf3831ed471bf02cd247df61dd4a6919688ff15bf80b1f16f4d017a30d7121fccbd875372f28d585797202fbbd9cf499ab0082c1dc4cb12303689fbfa89f73765943e4e9c8615c9ecfbcdcc0554a06fb192ae3bd403e834b1adfb0fbf1e06e4f8e921afe7fe707fd0ec9aa0150249c80dbeadd8c3b00e409f83501c10450830edcb9c578e443ed9a81130731c15e41cc04bb00d0c19e06d28f873915cee7b67fd4bf4f1e56fa0f53a127d00337bef1b0daad2867259ead6dc3926d096c053bbec653f99cfd89e433ef5332b0eab9cf96ec78f7e4b9284330729fc23464064200f9e6a9d1da6b487db3c210763d0b6d3bb3070ea95b5d2604946214aecab35051e2f8bf9262be2bb49125ba70a599fbc0377f029a79f32460dfb0df9ee305211a2b4d190a82130b26a0fdad7270e88a5b455d73dc8bce88e1c9f4f6e02a2d9a558a1631406d2db441b32c513dd7b2c3739be0d2d5ea4b5b4a460d3d90af5f9ec20337c7c2c784cb9fd796b1b4e2ad9615a258bd11ac8e92652188896e7799e57f7f249ec23233294b88c8151b5995739219ef0fa17eea76493ee56ddd7c5cd47ff779c361a83f2d1407c584a4c9b64193f61d14bae8bfdd45d151484fcbd61566cae7b8f1eb51e8c958e398fab2bfa08c2c8f8611bdc7466b23230bc2469be14d2c9aa20de768e4368a6ed3848867296d88a165b009de62a00a4f512c93ff57a70dde11ab1078a74b5115be11e43c39517a5ca141346654353c9094d0d4bf35ceb90f383776c47d57420a0721040966b6c1d62e0e997f7c2d3bab51e0be7549c17982bf84e6950901acbb71a44458ef48191c6a7bc6965f61624b48fcfe41ea4c1d54327cb34f7ac221d063b2e0b25520fb4db3523d39be5f20c85ee5a5d88c7da538110dd9fda0d0a62e2391945220732a02885e7b98d0a58009d00a3a723ffb9e5470aaf7e0ef1eb2012ad42522930da389e2b7b8bf6dd8dd44687c5a40585df8dced13e219fc298c74662d9714039092aa6c3e1642880c6f8d4d5243dd87be90fdcf3fbdd9bf5813124fcd7bf3dbcab63201e88d252c876ac5194b4f6d086296d5935ffcfc5cb99cb54b966906a39cc28695a1851906484b392c27b7d195917dabc9f5b3958969dc0cecb925d8f55639722da479ff0d2c232c87d3981ef17a9ab12cc8a61b04ae12edca7f2a48f363c9d18d6d5819b19ee19003bd2e87455418272156ad11ebe17492f9dfb1d3e128689c15a16844f473e628f61fabd0b88fadbdf124eea6dad220042b32e11d87c6a1d5787dc6761127566bdab8357ed1b4768f90d6611483161d22b4a8389186d6996f643496734388306ce548ec410c36c00198ff25ac2f229b9ed53a29581cc744e2e7d8d92490dd28360c14c93598baac073f86fa123f80c531a66e8affc021df8e749432c82839a3bd28122108a8442bebac3434c8a16512ab55955018555f867b7642b9db597894a75ab0000c81f2d1ba821a1a87a1b3ec952e4d2cb8286934537700c6a8603d545bd127f6cfd3e51b35422d0b2e2f007e9a55c284005ddc70d85b2f8df037d3c75406614e0e6a1c077ed9d8d5632779eb870c6ffea54f21ce636b58c94e3a5c437c7d6976d98b3cfa85bde04e2de1553ab7a214abf4ef299652a954418e423bb0da3b49a2d341cbd563cf535779fd9630e88c4de16c02a17d7c36ffe88c10f29c1558e764ba7925ef6c544493b7cdaa8c64c604378ba3a02986fd92a4acdd341a8c0c7bb3f1f7d9d9b7ee58154979b526944e9f7751faa3274230904d4011379cf228be33625d4cec99b9baef68f972fa9f3211a9576535938589bed476b56a5729cb1d9707d4cf43fd6ed0b4905db78439c4318620aec3353342d9203c745d171e85652ada68c2171b556c98ef3f8b0b54a9d2cc0e83c6e5c83ff7c4a6ff5ba22e18d42cddedce718e217d9a21d08d61bebd244b612990112b9fe9cdec3872d4be6d386a73ebb4db0ba5d9f7e21476f6e9ff929a608f52fc711a40d68bb7fae3b06a76718dc9836f5b2cf5a0eb86b529d33183692b028de22db2127c7201a1522de8f22716d09b6cbf1c49b72fb7bd212cc57280db71fc19b9d210a6aa08410440ef76b5f40f73fdf1b7abb41b532e84a03d65dc1c8fe63badb0f5227ab847eb58772ce7dc80bac4287e1e1f5677e908d91a035e5808e9c907eef7876ccde5de7987da71a8f81ae3402dbce411f4515d24fd23bf26d7005d4794ccb965ba56dd83c7cbdfee0cbda9ff7005a1c6ad912a44754dae1a1da6ac49bf288bb8f89c8e7df2d49d98e0c92a304bed8974b46f3b0846296b6dcdc1910f82adfe392decbeb5711772e9f89cd384dcb39c44a1ee077eac184bcb95133c273b7654fbc32ca2a19d783555687aa08388391ab83687ba635e7c8117a620d2658e203fdd06f835623bdc0a9d1f67ea1899e5ec8ffe6224d1db6b3fab67e1252a5ec256ce229ffd39d41259bad1d69a46ce425a005628427d395c0971d0711cc7443e23f3e34b53066a47ce124d8a70c7fd9bf5d61716309d63bfd3aff346054cd1ea73bf0eefa90a1b8cc407069946ddc5b35f7affb6a2bdaddd9792c056c9aba563027e1dccb3119e25f723815bc87de3cbcc770ccbc8ace611f10e47dbe7bad85a2a77b17249c3cafcdd1ddac81f09bb8f70aaf17cb8ca28a5c3a4ea836ed7153f86773a160bf24457ba03809a6469a292ae03a58981a8b1fd87c42431a23ca944501a3c8be85c339c32aae8344a51882a537362f392112efd0a0f62e1b89ce5abe7b08e50a1a3788f8f5dc9e27d7acefde45394b27f77cd22ffbcb26002665e29161b6a908a2801615842cff2491dc1c32a4319dcf622f9a438eee9a029eb80f8bf9e3507a5b7ea938d7cd82169964b6e7d08118982b1328c5316951d699ce2b967607a94df334ec8db489cde8f03f85c1953dae353bc7580d248af29958f941655da334a4135a24539e0e9b88bd898e944d0005640dfd4fe42691ac8b002d08bb1f63c602bf4fed452c190a7b00d93e16cbbe4d24eef721a64d3c84063a32a86539dde55e826264557fce17c04e130918369ab05f5efa631156d2c60f7469b5ccd7ac47dad4714a4524af2a9586f3908d7b2b8a6803f3d6fb58d5a25a412963ac1417ae9edbe25ae17a05e2debc7b470bbaa96e75c3a5966d9daecef89f8b201277a91b8f1467691344bb74a9292822fb6a2fb56be348509e9fc25c1cdd7a0397fd918aa89d6cdc1d51ce9ea0f12ea90cf71682ee34c3362e86d4438df91269162ec7afe9c55b9446a957c4c54a3ff475145d9a6b6888117db4e5eaef1386c221a36cef00c16a2f045b9975e15386033a40ef364c3a1e6c33b74e531ed4592de4a34a84388d2c3aa5a23ded91e4095e5c759960fcfd6f92aaa77372c47715a99b2c48d256de89b11c09c7b5fe2fa78ff22af4e45b99d2c964e4b11c5a37764aed5b30d611ca8c24441e99f960107b4dd07932c5a866d51a0e0cc1ea511541673c44bb94063254860f2679491490640f8c9fb0eb357dbc7ff6c4c2c0778f245018f4da9eb1ebd01ded5c649568e9c6711d811727595ccd4fe4aa0d30647f6796dca042f24746ee7bbe4b5d8d97893cf04944666375771f159ece94482db13f4715a4cf55369689a23c53e170e0bb06bdfd2ee15f9a89d5fc132ade3713db680b7fc368d4bc6b39f6e1f68e7aabd8882deea7461df0211c5426e8cf441e863fdb02e051f5f2f3a15ba7555ebe67b8fea237905bff2e1c2722a412b7c860c3317b6b882db62da647dcaf31a8838088e0c3c0bf4dc411d807e81401e72bf114dea5c1c6436a1a298f332be146f2fec813f1bb54c5707f06be8707c016c9c5a31013e10581bba3c5858750e91514464413e7e88f71a89c92b29b5ad9859b920d7921c85643e18b4f28a75b7060a7218eca89946b62daab95ec39468e071c3861bd773c5cc8b3b639fea3fa278d65a75b9693f2dc0aae433aa4758816d5be7c52e8f64facaa5e78a359e4e39da8ba28991ecf200a3eef2564310bd5b2cd0bea1978c5a89b1a8f5898c637afb718dded1d2f173809134cf29ee3875e5bfae417608fc2bd3dff223a854b9702f9aedc06302d0681c199142edf24eddd33505133192ea41115d8d5242f14791067755ccd10ec98b1b8c4090d4dc5d1ed2bf804ae8eccba4a2d6b4a1b017080e105656f642bf99a80f71d98b7612a1c337048da3d10769c12373ab3c3866560abe4dddd8a01ebc0f00bf670b36e232e160ed07f6a4794d1f717cc2e2daec2e579baf1eaab862be879a8c33f7b9aeced65941ebf2bfa66d2662585caa87724d639dc1a87662439131371e71259f6307ba194d70fab5f59190a0f057b301220076dcbd02320d558602f7698781f5a609ffc291d339618cdd6f1a69e4fb7eccfae65c7507d1b361d880b2982075b676f64d5f3cc909cf50f833a2ce390eadfaa0d41d7996848ebcfff4333d9cd080eb120ecb0df74f92347bbdddcfae579dc14eb05ec23fe354b5d0f09fe94beb6d672706319ef985e5693703c818356242601effec71d2f204746608c53a1ae490d4a2dcfde8ee032c99d7057d6f635b260e811fd882eb490cbc510f7e6ace0c08a1f8e38406963829bd55db708381155a81a52c2b2b4f67796144d965b2c8d38908aa8f0372c3d91e0559aa37365a669c661380d49c107eb60a4c81440c33ab19a71234d167f8a89dfbed148ec217ed97447ace156b4537e0d460728b5c280385c65d313be39baa27ce3f44a532fcd56577947b2edb9bb24c95b5932778e2a6647b2e9bb4df2267eb0ae8329ef9ff284191aef781769b9575becff7d51c5d028974b4c3981c4f4c7b0fc47614d2a99791868f6331046603f3a2588194fdbbfdd998f8049a565bedaf51df07d6892174d19b4876a3f5b1c4f7c5e414373a2ad9874351fdd092dbf8f6fca5c3c645942809a341e7c16c2ad354c759dd39a81faafd4cefa27aa40a914d3c4a5c0419d12e10e039e1166564e1dfd0d1c11991b2f7075c212b69e1b2b1287a387a133a7945213e6d503ce976a5aaa58ea3cc4b0445b24a2c145bfea82778d1ccd086baae94c9518df7e185e404fdeda70e3b0f2dc53b1928b977cd4d9dfb526cf374b9e4b34e740e4bc975f1ead44b2632e1875773861a996388d9566c8037d19943067691b9d7a429418d5387314e69454c91ae403f99d717c92eb0f78fba6228e61ae2e7d01caed2c9fe645013b56b9926db39f0c4fd6d067c8b3b9c9d0bf72e040195ff6b7d6b8bcb5b78b302017869b8690e2ca1a728c1e17d9d154ae12031f01129fd4e955090f31098d3a1655ba9b87b307a9c2c78af427e7196470eb453410ff9870e70669b60651a221166ba6299bb95571825247aaf92e028c1bb5ebd9915c5215c462c8f4b1dab28a95dde7cf2bd1f5f76a7447dc3fb6521dddb6e7b1bedfd76c53d2eb43eab18b23a4bf06d4503e84054e87e666ae0339f87d1fca555bcfe01459818e053bc99aaafef4d5df2810e8db206e31068459c31538142c9311042036c65e98090f331ed60b0bd4b77f30000ed4636610e83a2a664f2e3592c7144fa89ef3e78fecf4fd4072168168a2c5620a5c60119e48cd8393fded6962b22d5f9091f83626ab1a0d1e47aaf37cc3c647590ca6450844d460c4bd8bcad09294af2f527bf63d9c9457826755ffe4d1494839a39b7aadf80198fd179f99d2260bd213770a450a58b7f4ffabeecb6c0cdf066210570ea29d05b2905aa47413d512980a404195bc1ebcdcb6620b62b120142ba720cdd4c36ebb705bf42098a0afa6b4287782b38f514d22b5829ef4ecd30240311c795e886988048f34acc6009a2dd95a82aafed03326905af4abbd258a09f834a312e5366b35b7eeb502ae405a21b5f8b2e68c3a9e71a28e7c2699908de08a9385ed73ef65351af80faf37f78d8a2473742f6df73d2f508cc790c8c0d23539d37f74bfa2a0254fda72ffa2b3acfe4d2fb99ae727738066ddd0b6eeab8907d00fe444a38ac1e8bf63c67f93a9de4944a54deebc49952878bcccab035b0e4871cbc220a5d7dbdd2aff185a6bd5a118a345a29c6c9111bfd96833283b6839664153dc43646c2deca06755095c82098e30213c985dbc15dd1bb967370078c65577a50302ddea93917f2060be444967424c96f6bf3b2dfcd1002138439e400fe3d66dd0d38969df0f61cfea2fa041ac8aa7cf89b02bb63053c040cd416af653ba2e8b7b9271f0f56f0438a491614917de7208e63e4c926cf514fc97a7884602c348dc20d02d14cd5aac8ec0ce7fba996e2ac4a2dca2a347876f88a3706f6274e21a91ff43596fb4f088360d314b7054c25c127840c00a7338f00ea50f952ca8b5cc6c3619aff0278317a7700498a3053c764c0c85331585d36466ac76e78b7dfa88e42ba633ddd3f1491f84a0c2cc1a6d56f78dbf4bcd48c53b9e6234e32d29acce12f06f793634c236afe1f360c294c78feb8d548dacd6cb5f861ff590b7d8041037cf918c25c5687e0c2b69f30bfeebabd6b76024f11fd04855e36b2f5666de151b8b681cdf2d97088a20388f0aba54c08123bf6982b2ee4a300ffc1bf292f25a5007df8b73a5dc5dea2a3226fb400f91deee720601ab4c63df6dc4ecc54661b9a18c93fcdb0199bc410ee40192b9608f1000b3a986ace01e7823ba0027cc1544ab4a003650d12af1227d66db74c78934d7216f378a3d20711f15723fa7b4bee9a880a1fe5060282738b75afb5661f95cb7cb635f42386dd299b28b9706f6c08b0a10cacf71fe250bd90b246b430972b6cfd8a5727b62119ca3afa9918aa36424121fa1ea0638cd4e4c0200585c1023d5127e93cf585a05dc7d485fbbdef7b68d6911d0ed0f4ab6be285a842ddd051c4958d8d9d89d403560b3e78a2d7cc37d08aac26783f31e607dd375f4c552ac477809712073838d30f4e57b24e729d580b781294d763b25c7d3f55e34fb5ec46922d948d2d364951129ba75bbcdc8592a67fe1355a5a4b42707d14b938467a9d43c5fea7a2ae564c0467281a6e3ce255ab60f0b7eff7f7f24dc7b057f2f02fb5479dd954f90f15063d1b4db248429d627e8f234dc2df15d639592e550b3915c7d8ad4e9e7fdcd4d43480930c450dc942630f3238c2e7b176e912e10d7ba2c590be9da0367e4ce7ca02c63a23dc3e2aec3f6e437fcb0753447260a556f8409e24486b2fa72ded0c624b14b0c53313c40244942de5f76e89cc44f1cd62124f48d18c1a0da12d775e9c40beafc8a36770863c9a58952e03ed141240ba04e0dd4cf88b11507b9bf58bf4746bee50cf3792d1af80db365290f25837da91f429a3d064a195876158a32c6ede883a0e245951777c163106de1822c82f093abda3ce1b5fcf61a77972af3de3f7e2892ef55dd25d25f6ae7df6b01927187925ec17feeca6a64f00c64f1646e4d3b52cf75706bda87454d01115b5f67202741c19b5ea04a3c9ae94a999346ad0e90c74d519c4aa4acc6a4a58affa368c5b66afbde5a6b0f7c4fd1bfb24dbce0df84693c0260f22366cb1b2d2aa24036ac494717f296bd1f4b6ce8e75a0451910c3c3fa2a5e48ebf0e25cebfe2738a50b44f313e9486e6ae1e50cac3f20229fe1934a7005665dabffbc725140d13788984a5c12b0c8095a648699946bc37ad362d2ab79a84cf8d4bc0346227a52b40b2ef6e7f1047bd98022b88e71767e8eb8f61f70c81436bbe0a17abad222d0010c26f5b0f26d4b28a3feb1eb2a34af3ec491d63ff6a7da0aae0fd8ead6977fc02b61961cdecf001a6984e41fe7bc0b9a8ad24dc6f3789b8d3eeddd443de6bd3a12abf34ebc2ee7152cc298369f2720e10371929b3b5c38e9a6d7ea91aa4e14c00115beb87b0aa0464eee762d5eb474e77a11bc9a8fe1462cd018dc18060dc3bc8f0703178b3177ea984321610afab35cdba70e7539a8120460383d11889645987b070c481a35e713a2db71acca2e9d06046a41dc2fff6d4d9c916443b5b83b7d99fda4a3b0998c292787b65e8219da5edc0a63488a1c04c37e1ad4469a2821bb38dc9467f05b70ca3f26e640c9b14675042f5125c54b060c70b3f1264c61d0fd0479034796340290a7230060b9be7969c07dd2fd7c01dd33f8542c67665266e51f59946be712209e1e8bed1847982c4788a20839aeab4cf35ffea55e9eeeae1eed2fe8566c81063f3fc8179dfd25004a41e41e347012c2dfe66809d1d659bc6ed1e4a0977a229ad8ecf356105dc845c1211758837d55fbd9ccbf6f7de4cf0fa6e9423e2ee376b303dd4dca73b490eec3ec7fc1253f4fc898802d593edf976c9b38c5d1f9d37d0f7e6d5cdbac952664913596750ef5805413101401176be1fffa292bce4dfaa2261300a0041254eb1ff38a75645bd4c1ffd0446a281ff6f5b1bfe820ed69d32dd47f8cb6f81843801e0f2ff3b52c103dd60abbff87388133e294c9411fb777bbc9818e26e5b80eedc054c40282b280fca915e313c911aa5a0d8f0348ed7072d0147c898f2317b2490e16c0cdf0f3065c035724a19245de8926f3647db59850f32e8e29fed16aa27df418ae91f5c93911aa0205a29e9c70aea54db6c261a569a8864f1002e89db5bd07ddf76ab8c00c767d1218f40f3db05d211f027cdf7debaa0e731a95df72381ef094df45cb9ca0ad7a81ae600c2df4977fb722de929c7f0922f41298f1cf79d0ae17a3e46a6e16cedff9490356a5d211cf8dde32f949b649f493065afa31f1f34c325c425132d0b9baaa196b8302354527579ef2b759eade6745eacbbc11dc4219cd6f1a01b9f05f82952f8233485c9f57079107a80aeb11def45b06c5b0c46a3c7040677bc09de93c9c3b21be4877e02f90f01e77492f25260e3ee9764df120b830c48376c86d206b5c0b2a4b4311b845fe757b7522f500e92aa636b539c14c01fc2c20fc956ceff9b74fd087c3314dcf81ff8e24c06adf0ffc669634bac29c1cbc0d142588bc3f52de2881b6290ea00750ecb9b2a9e204d45102405fa58af25c02166482632df5cc525c751ac1873aeaf9cbe6893f494c999b4bc2c68837bafa865949bbdc3c445290f6ddfce018de6d9bc19ec01931b1c1bb918f34755fbbd61f4bbb089c60cf9b14b169ff0a077754b47a9c4945a12ba50830f3fae3d6fa0e199f5a77211a942351979eb19cd1b9d97ad5bd340873fc5c19e7a83028fefc6f571883490dfbf1bcc41e89c0b7a404ae77b6b2318c17813d9f0ff29b1b147d49cc7553646feac11a47bd2a20c59eaab4b730085f06c0e6d19fb26922f1ee1f05328d76c7e11f0aa90aad0f7aff603d92d3d5eb7b99ba39ccfad6ee3abc1f400c2d770b0af645bc652dc6666bb4f24b8c93400179e52862beb6a1254c97ce6e9de196adab02b623ddde97d3cc766173290cded705e1a8e81519cc19836b77bda6478edb5ea9fa41ef2ed53561d6a4bef3e62ef84f0ed339b1eb4c9a5677644b12824557b609541f6690976ec64d7456dc1d712ec6fe573990a63537742e586d07b7a6d5d6b7a4f2ce3db2328905014762c809bf622ccbe50ccda3742ad30c9c4c19895b5681e6f338b92895fdc217f2bc408dd02502f9027723ca9b8640abd22b39a4332240a7634d9048838e0c3f5c18acbd36f6f87e8cb9ecc7abbb8089366a7d5eb6c3d01a7842c4af95fd11fb3c48a793e2956b3042e8fe14bba5aebd16b71cce0d5d892645ab16ab19da271bf8b755d4938cdacac96e64da98c20e29cc4acfdf1b4f56851e2d80e1dd277e1fd57c86d05340b602fd52c8059e3e3d7e90b6ca7bb78087c0d1fefd90b1a17a4db4cf817b33eb1d507a83929f9099c169f67c27eb6d83b85f48da368c4ab28db4a76de41bd9967f55e0fba0a4c55aca8222a3b79b53a7cd58a462f6234c2d210c60a7adb9d69370a20993a7fd0e60f22c9a0c84f3c4b8404f8c09a47f412e9456f8babe3c636f2500f28d49dbd3abe8678d4dc2535af179d4d2dce797e0f26881cf05b0ed804922dcabef989484114dad59acd856edb10b41400c10dd2dae21503072d95f2615451580a6f8e3222dfb890d5dbe27e41b46ae2720546ce8947d2e6c8866e7467366def50ac1f37fad5169d263cff7773dbb35f8b563290a2229df50a8df80b2841ed830a81e21ffa07f2435b0652bb8c51a279e60816aed7bbfe5ea35ccc2450eb2b3fb5728bcfdd1e5357ceb26b597bf2b71872231a136e67c36845990d8a959035456032a63d67a5a30145ea503994e4191ec1e2aaa874b6a029bdd3c29cfe5f63c1694a45895bb0f30e2c0a823ea2fd6918ebd058120d24bf33f000cbd49fc7ab310afae7e6b5ab39dd9481695cc0a48eca57e98a0f6edf52dd99b6cb9a59429a51475077307a907d099497bfe9e821dec58885b34dc62a1199ec80765f70df91ece8dd6a03c839ce9b1ecb949cd63268ee59e7a64b0d670344ff31a0d3fe4c73e9e6080cffc5c19cb9e460334199c3a78bc1b2e2e48ba5946506f7a9e8b870e560de892cbb5e41a8ad262c245c9e55a720d452162b96a66686a6866a6ccb2168b8b926bc9e5e2e2ea2f5a0708a00ac46a535b6538fee632c3bda79cbb56eadad59ecfb44be9071757abd56ab55aadafbdfc9801c9e572b95c2e170de887f250ae191a578d2b860ba929caf52ecfb514d3329454f8ec0411bcd4f9f3b3e7e745aa5a8cf7776d32f33edd62209583542c757bc80191595c4e539d5b696e37a05c6568af3f08e7466b50f24d1c0886542ce34080d948e0b404850a25966035a1f90915d0da63da63271858d37e25d39540e6655e93e156503c009fbf04503c003f7b7982811f76363054e881cf3a205eb5af407bdc8f36f39b0e9ff619ae37ae57edf9db88423346d51b29f413126fc00ea73d98b781049d9376a8da62d29e3b92f6dc6d7ca19ee448edf9c6c4855a67be7f659329eb3efe2dcbba8f5ffbd3fbb8c6cd6721b1cec73205fc6ab5f2b195bb130cdb84e924242714a93dc76213047579c1d23bbcf26f2425cf5c9eda9a755f67a9ce318ca53a9defa9786ae79380fe01d37d3ca7ee536d1d4472ee6c0cd18f4e28b95df21d99b70983c6aea886a391e11ac991609ac6096d6ad9fe9d5aa0f72eef4e2dddddbddd0db7683c4c544a9807de2e2a3f90de591f13892641c15ee63faf2148a1f2cecc333fceea6cafbd6927c6f3f3f44ecd0e7d7ede1dcc621cdcee803755724de8d3224f758aa974915cd3a6c970fbe3dc3e5127e7dc1ed128e2e48473ab0326f3098d829af227a1981cd023e8e6dc52716e7150316ebec62fb3859e34de3c2d736e6ad9e6cc6cce6d13319e38b746158339f598266c621b746e8b284e14fac1189b7308f0817e53c6e6dc01686824cdd89c3300adc9e21c8faaf1807ed0b91d4ce6131a0545c5b3a27ad60a9585733d558bfbf313655e724d64ba7ec935a1dd760bdf66b3395700cac5cdc6a43b0b0f1695158fca4f41457902c40a6a1555b138bef8520c2eae2d6973903c65e5886873aee01d9cc4e2e8ef25f848edaf41829eb039b7332305cee9987840bf89c2e65c0b262c9cd3f14d709b7304a89333bd0c87c3ff40f1d7b83dc7b429e0f838c939f61a0aa71ed88d630ebbcdb91cb4051ff4e05df483ceb1508344bf89b339a7faa2699173386a70a0c2e6dc00ba702ea79ab81b4d687c6cbed0af860ad114ed6d4ce8dc0d19977302d887ada453fdcde449eda7e198885b2e88f66085cdb9154e3882b7611ce4362fb5f151eb508ca3f105dd0eded89cf3b024657171692fdd45fb80e68bc780e8077336e70240e96989016ccea98063730e00345a10aacd391c9a1816b0b03997c26f3feb51284a592cae88cce3f03f321d94cdd2a9fe66a22f9a2af58959fbfef321fc98d75638f598a9ceb5f445b562226e716cce97428dc7ada76ab8754a04b3be3d3ba8e5d89ceb564504d89ce3e83c42bfa96373ee6990b02465e1d8c5b192a7963cc553d47e966271d07cf1543f0be80423d06fb6b0615c13da563ad59f718c85e324cec22e14b8078ba3df3914aae909fda04d127636e74e989ee27678886c90406980f563a2130f28d6cdf6b4026cced9548c6b32f3936322a6d21e4fe954bf9c827eb06773ae46c5b826f425c7454c45a66322203467a3ba609a01415a0cef88d5c60bfa4158dd7fba37f48636e0d3de81f06f1847671f7be4c36fde617af89a16398f5c57ad6bafff97d307a8fd156e8e7f370f7ac375e56aeab9f188df577fe7c19bb3a71ed039ef2ab150e89c066dbc58c85b64b2621dbaf70ea0f70e189b9b717c9a9c01e5f7b8bed19b3bc640d3ba09cabfeecec528bb5bba43e85cba4008210c1146e8485d60eb7c44e0af167d1b07be38ba75f7d2254e8de30df30e3861cba97295ef70159beaeee391e1a43d825150e835bdc39b5466a1ca2716aa3470fd3889fd0ae5c5e124e88fb168dee1244ef5735d15eb6c7b9c456d156c75f38e95d1575e4c4a6b5037988c527a49baf0d07d0df04244514a5a355a609dc510c2a8292cbc1861e2c50701e4404f758bbcbc4005197891818cba455cbc1c89777777bd07e70fb5226887eae88bde689df87d80d8d92cff77361d4df1674ee8abb808b63f5175d152151c8a8a54b9010de20e2fb943fc886508b14b0e3b4001862b2a7191c312e10ae6840653d7284912499e4cd102830371050cf08570922cf0935c1159052076eece76842f00156adf50a576078ed73c6ac307e23562988cd371f8bf19a7c296b638951fd6f0135446a11d028f69b9bbbb3b33bbbb4b8feece746803407c77976e7436c18068d105b010e5e66616742bd5b12240bdf26cdbb62c7b53f7e33de53f99fb28636f7a1bf9304fe427eb6cf8f4dadb48e0f4da9f3a1b6c03b5fff43612e663303d8ca9c3ba184e359cba205ac79265475459fea8fd9a8f8f7f5201aa9a71369889b3c13a096c6f83fde989fc642f01eddf068b61c3be86adc3ba186a78223fa66f55e5eefb51650744556568cf67f061ee6ce4f3dbc8ce05acce24b074581d56c27afefdeeee1856dff9cbe6388ab23226d67fb9fbb19c0cfb31b4e72bc38f0fceda407bfbab045b315a051fcc48a23c3e1ac6cfc3a30b4cc6d051162e35c6960ef55bd7567494850918b78a8b1a8150e3df88b2fb9b257e7eac5facd84709b335a2f163e499b2e3a992072e9892648b4d0c7376447ef6b7bb522ca6ae51932c6a7758f74dfac3a2dff415c4000911484a29a5921d322600e580a48909905026a07062d54f7c71021efebf091640a8b6402285d0a2c3115478d1610b0d3a0a2962600458e504592069a2a5dea8a1355ed7a889154e68cbcdcf809d9dfd3d39806de03e22bdf1a9477cc901cd1ff9918ba1573ff297fb4a50bf10c0daaab1f3ee2b410cf4477ef16d1460aab103414c855d13f9eb83aa7a9fe655c542f3d7c10d5f885054b78aba39f0c2a546098f66bc25a32641ac24f9e32f6164057dcc43edb701fa98090f7a4a6d278cb8a27af7b1d26c2c5c8dab803210cebbbbb8b104b19cc548ed25b5d7df37f04e06b86dd89e2dbb535d3c3d3d3972701c8dd861a0f3d99ce6d14259e9a7b99d6ccf3a8abfb8cff6b030b03dbbcdaecd699f9882148a39c675c03b1bf9fe1fdbc82e067ee8e37c54bd93b67648506f43825f4b010a9d2aa03f54a420b60895795136ecaad50a0a0a0ae2968cb0b165a32756b539cb4b9be29f29a8fcdf168157d4abdc3577a94c4434b9b5571ea0a500853a11acb3ed467887e7119aa4f22f2fa9fcaec3f6cce7ef2ebb3337c56f43e5c9df4a73528a4211050505316fcfd3c43fb66e3db55aadf679797fff019bb31f143429ea9b835ac789608f9f6750f959e096f3cfc9cc44ad266a2566a1ee100d910f4d6da373569f1dd42dedbf0ee22a9c72c94e36e5bf4d6c133d3d3972701c0d1adc921dec5848e3b8a5853ad1f6c0f7f7d76a402613b210b77a4a7bfe454de479d0c32dd53f460ff467d51e507b9d05ef2cb7d1f696a2edc1de86af504ba046d002550595c269c81e7b4d4a295fc3ae547e2bb2d002938f715c8922514f691da5a5a6e2de49d5db4b94b0e5cf4cdc280653aaf313db93bdbf133551018a7c9f4062b985663df889ad90fbb88adc42f9e57452a3d5b18daa176d4e134a5390424d2b45e58f2888c8777835dd79c5add841c0f49ac641272a47e4478b5c07606783d9605d0cfd3df810f0518d1c1f55c86dedf721ac6794a0f5c3ca5159541657d2c6e88162bb9caf529042b3ba3d337b7eb66103857228fb5dd230bb4e82e529e69ae81f5a89a0cd518259add36a9d1d6a1d9bfd45d23a41adc384db7699d59e867a42f7d4a36356ebb8bb43d6a232e44056b7d005f2d4f2f2b28fcde1ef1e720be5b81fe887aaad04a891b4cebac01cd81cf6b13dfbb13027a528d47a1116ead7409cc43f27a528d4ffe7f1764db439fc0ee4abf6d8573bfbc395c50de4acd9a720e452ed3a84973a80ba46432c51b5de94e6dc02d63e3a3a6a94114d62a72c22e65ba8a7a8f9654e2527aa44bd71059402142772c5852e872e560a4850fa7209efc415f32fb3b4616510db637afafd72b53dbcf207a982da520719c4e62ce15467dd278be20bb0ee934ac0ee93466cf749225ce82a579bd38f6384d20eb573ebd591efb0ab8196bfa0bec609fde2172d58c787faf4302fabf00ebd82b282816416b55f3e219dec4e5c49a3f8257e9142dbe39b66caa0cb7768bea78ccb559d88a6531a6a1da905c3749fdcc2c8897c2752147b353a510d117465d8546f922bf90e7520fa8fa2be4936d4fe5e6d8f33d2f6ecf397dacc456dee52794b6daea2f6c7952bb9922b05c09536a73fc6b81e520eb2c0d2f289dc1c00218b2bf90b2d9dd48e4ad854b752f003900ae04a87da3648a12446628e5fe2176050a9fd722585a2f40ec792455a678dbe78523b4a24416040513fd94232022308f5934f3e0954fb393252af1118536a7f2cb283fa451e221224107018aed43a6b34840a6abf7b699d156abf73f207949f4f326c4ad0fd4d09caef10908fc3fc99f99898a72fa3c37a0d7b882814a548744e4a55aaae407b5df3343f239fd854bf14b5bf0aa5ba45c21c6a7f0dcd8c944ea4112a0959446dd9fa47a1565f6aff4a0acd2003735e6391f65a0ac52f9bd32fc345256c0bfd948b602c01fa63b818c6b2d06f02a211287e59b9746a2e8af6d2aa58eb6ceda56269b55ad9f0b3c44a11205793fa39abb6890913f57325fda5f6c36521b0d47e9c661254fb864c5d1a59e5d40a75bb1c75bb9e8a6aa2ee6b6e05eb70506bef4af0ce6ca24af52bb5df93f01f76875b9bea4715f1b55210b5df83b647e968624747be33f30dd37d936edd87cae487a25dccd73e6aafffeba30fd68f839edf63a5d78e5ac7ad60cfb1b052db7fe8209f93d25652f220131065a1ae4382a600857eada4a4a198a07bea74a05f077590efa8828e1ec0eea9566d0f7caeada4a41463ec3eba425dba297e5e4e6dce7e9f3a4606da5229a59473e54af98e75b283b07b50d5d6d322c671c58afa8227155279c1120c6050210cb8a85015a5385185922258441942f203ad547845cb912184b8c1d5c5163f108a20c85042b7f20ed3096416355601000b02c1aaf04a0ca290e669fc385ef7d57736528ffec5213254fb97e3f83c1e0742fee6f7719fbee1a9452aea1cf8e112c40227f343082184703e67a6ccb565779ab529ffd9858bea4d5c2bd81d6eb50baad3d4af5932a8fefca4394a7d9e2cd45e2b5b84d94eebce6404ad47726c38438d147600be90b84e57cd1f0ed315e55ff72c4d68821236b129236cc2c464844d684213fc1d09249cedd1da4d0e3388b33dd3835128f4364e1cc6f1f90d1e38aca3539df26a04b039fdb1f3ce9398c4a2d79ee76d4e1838dbb34daca71235e8c8448db1c6e78931c6185315fed60005157ecf18638cd1852a460405810809546cf9899da5c62d6ac46a8c31c61b75594a961c434028e68c188649214241d7a0803c157d67a5e840870844d19212450f11e081d2cb2e2855ab8abad862071981a32f9dda5547e009a04e6d8da927ba50c20a5350d30d01d0820715b878f1c30bbc60b202165e144151188dba454b10a2c2d6124dca0ff55bf85ceccac085123ec16e0e413b104695dcd9f8d8caffc256eeba0f7e0888549f765a5b6653fd348ab8d40c28e8477d053ce79b9ea1474c4e547b0a80d5d4c1d9bc5009e324f562bd39243ec7249ac6eb0ce34f7f08b963b7504b11df414a29e50f5030821720615151855505952baee400042b60384141144140c8a658416b872794ae8851b4608a1e5e43614bc056498e3046080097141900200846528600c011c5ea1a4979c1f4a72ea5f420a548fdbef20c623a5ef50e54edeea851942f5555d7e88820542d46b9c3585aca855a90ca1f3dc98e91e00ffdd86584c414779ec244acb6a2c2671eaaa8f07dc0e7221d42d4f4df9cd23aa687dd42609d3f613f44a9eaee6024f6e13bbcfa767807d3c9ae7321d67e46e21dfdc3e2800f77d48f5d7cc5d57d2aef3b0c728783f763020ee3070af69f10af3aa0a08b650f5f83f1e32e60ba0ff57468534b5424431847da9e609cfba60386f43875db1eb7752bc4abf6262e6e409b5ad60cdad4d68a446b53bbfbbd9bb3b51765377f92be2852fb073e77c1406e6a3f3f7f6b7d6ac23dde0d55054880f3dd78ab03df91000bec7cedfaf2582bf575f8e985e8b54ebf00ab8f28b4b89ec9b471bc9e694d23a830fbc180f6fa3ddf89a153bc43015e60e8f6cec7e6f43fa13efc7df80560e22f41f14585eac1962da4173d4829a554819722546104282e20c2059d2404138694219a8a2a264802bc92859222f1e33671c5bc1206108e6843b8c088c88a14459cc00737cc2956469a8afabd0f2d1e27bc07f55b24a4badf2a1da1a56e171f688110aa68b9c1122d48e2c7b11c61a5ba472104510a8660a2080b58f0e3af4ae1080d848c8c8c5870c38fff0cfe85d6353a62ca1147645a767b365effad3d7f17bcef5437e7f48257f7d30b587517e00bd9e905b9dc524a97129a60fc7d7a6e4e3fbf8908b46b3f991e802350adaed11142d81b1d11449552055a943c95f24265ea1a1dc13a0248059de8eda671bcdef13ac5af52f114151d1d2121c9d87da1df561f7513655c0f821d4542f977773b082184104208216466ee7677a1bb37ef36ec61629cefee32fce973be4318338fd9c4a07c87d9c4645c8a02e5668f2d73df56b185fb37dac389c9fec9e35aa4221ecf3d1dde411f150f8ff612f0791b17949188d062988d8cc0a1327ba89bcd41fd6eaaff5052752f0249f522aaa83b447ebab97768da3069a8e7ac1046201f9610621d01a38a255354f80fb1183101054208e1a90796a37e5b0e8690d0208a2a290a5bd48c410aa0b8e0cb1660e030742503362842020a1f562084112994cc304b99c54e477bce037a315a70a37e5bc56680a562180d84a818851edc2a5b2c11e40589269696fc402427a298004e3a37fac333685529df291d5aad563b1ce105cca473a3d93eb1031dac503f1d15f2582a589c7051e14348045185464418c9c0880c7cf004880a9fc7e7891315be0f1fd6088aab2655da3a271acc099d60590192a7763a1182110864594ae221b1850d50758b8e0045b5d28c8c60c1beb0d59f856ce4b141961bb22fa43d66e6863437ff727333fbe021419613b2b44186c8204286ac8fca0b32a48656dadd20429a0767dbc9757f743e8a509cda36b406d55e3f1fd12bc4c7d6bf0fb70b226408f6dfee90d6599e9352f6b129fe211c7bc41844c8108fa73d5e0a524377b7c733a4756a689d8f37d03142d426e1ec7791cfb055d7263ed728e37d5a4b323284ba2e33011b5a49467e508178980c34b763f4fc966f0f4de5e5d5af9432cbb239b1971c08b03a1f62523a0c1c06ac7c9a0f8ba8d4dddd2625e0869658fd9c60e0971d10afdf7cc871434bac6a9f1c306374b2f380a972c7455a45d0cf592c2424f41d47696f635ed39eb34d487bcb4166e64c2205e140b043b86e0b5c5ea406b3ede90598ff1689b7188eab0d29d4a789ee2e96f6564224ed2d0cea20ab3d56dd77972bb5a40775bdbbefac2f4b4c7e7ddaa769e6b7ab756a7ebf5bbec3937ea8cfe3a11b43083f20f3634e3d32245de602e78145aa1d8043754f351d92b38b9fa6fbe6ce74dfa4b4fb509eb3f6b2fb78ea56f82d1598d36bbf9d7a9c3ade3856c241ededdb9801fd980933691d5eb5b73f817c27884dffd6227d80dd656dcf4cdd7724eec3ee746b53fbbb9f759f2ba9fb2dc4ee386bdfa609f473d6909f1833289d018d988052f92643710f399cbfe1792b6954fb655996bd7c9f6ea19d936ec6dad4b6507b926b26ed2dfca73931804895add6e12a65c74aecda82ee774ba875be5e62d24f5a67c906beb7eaf2903c3ecc25a04832c00717ea4a5ae7e101647436fcfb23e3f77765644e640c3fdadb476a269dda8f5cb7322c5a75f96568cf480333b4b7fbdc7dde02121894df1ec6098912c3a694d23d761edda5ecba854bdaff407dc6d8b967d3e1cbce3d7670c2d8cdb781e653e343b8df8120aafafd00a26a61b98f85baec39eac28f4788ac0e39fad9cc1a5ba8df6e0fef3e8f70dbcb511bbee6de428d1f2b6cd96d1c39288c4125a0220c5457f8f0a8fbd204384cd01d361b6a7cb871c2232a61c224e878f1e85015c173e2068e14aba3bd8552aada833096a0db9768eb1be37f83aaa11bb682083b1d081dee8e7686ee0edd89488e476032bb2123460dcd8c0c8d81396d5a669a37ac563c28254d89c51831d61833bd4f9b30e639e7d6850959c4706664680ccc69d33008fc40a2800c491998c105a4cb15083119a974dca360e3841b9b1a34503364c4a8a139c26225090a5ad26a11212464c4d0901244444d141555393aba828464455252162e97164a4a4e3049e70ca537287884224c663c37363568a066c888514333234363606e58ad8c00011d61b19204052d69b5881012326268688a92942c624f63604e9b86fdf8142dc0c711047e20558007ea42289b586366d6186a52ca8e060d4229a536a1d4349865d9369526f59245ccaba19991a13130a74dc34c33d6d025284609b1a247c1c60937363568a066c888514373c36a650408e8088b9524286849ab458490901143434a101135515454e5e8e80a12921549494a2e083119f9f52f145e365e27bc6e5e36af1a2f1a2fd46bc64bc62bc6abe645f39a79c9bce82be605f33abdb697f632bde62bbea494d2a7943e6334b9c7d8d160828ec5d88ef1438fb086eacf32c687f26394cf9551e093164c663730a74dcb4c533260ca528cd221364d28fcc7e3ff3b00f7df1675ff6d134b2576dca360e3841b9b1a34503364c4a8a19991a13130a7adcad1d11524242b9292b27069a1a464d2dca4b9c91402697a8dddf421e82ae794262d738f99d330db7bcbe0e61daf87612eb3cfa64f475fe218260a26b3f87abd5eafd7ebf57abd5eaf215f6e58ad8c00011d61b19204052d69b59e2879c164c623be6cbc4e78ddbc6c5e355e345ea8d78c978c578c57cd8be635f39279d157cc0be6757a6d2fed458490901143434a101135515464456935a4a3060dd40c19316a686664680ccc69bb61b53202047484c54a1214b4a4d57a22243444833324209df01f8f8dff7a78d838e1c6a6060dd40c19316a686664680ccc11162b4950d092568b0821212386869420226aa2a8c8cad1d109ac19f9de29927d111ca8093c8c307ea0c4c741f50365fe37e99ae69ca1f406857a08461631c905f3bc1c2a158f2e72c5ba2123460dcd8c0c8d81396d1a669a37ac563c0001c5e0998586c9ec690ccc69d332d3941590c115c3d80d3730a74dc34c3332c0c789a50e8a68fca7aaf15f0e9bff74dcfca7c373635383066a868c18353433323406e6b4699c24286849ab458490901143435388888a6cd85484c92cbe5eafd7ebf57abd5eafd7ebf5ca5eaf9764254a4b344c66386b9a7386d21a2854f7bf82e7e550a97a78787e7c8a16e0e308023f902820435206667001d90076b4c264e6c557cd8be635f39279d157cc0be6757a6d2fed95bd4caff992af1a86ac260ab89545ecf41f0ae6bf1a31ffddd0ff6cc8fcf733ff7534ffe1d4fca7428cff3c19ffad30e3bf1ba8ff06a0925c503364c4a8a199e17a78787e7c8a16e0e308023f90282043520666d8b86f034a34045912c1901b562b360204c44798c54a386806674f3099c535cd3943690d14aafbbfa11487344cce68ffd56cffc940c5d7f6d25e3550a8ee7f054f7239542f13cbe70c9a583e67d004a18931c69e1707d65d319618f6d8f27c3c11091aefc8fe9bf03f53fc6f9bffc198fea3d80e5ed39c3394d640a13ac6c138fa2197c734886910c3b48c7971ccdff9b0e7cc76fe3a176fc02e4a68b3757625774787f0e50eddddddddddddddddb0218410368410c2861042c6b1ce45dbd581d07b4743b82b3dba943a107a775dbbbbfb61175386685d232f5a35092b758dbc4842d535f2a2c8b99bf93eeddc56ee36fe1a6817f3dcd1ae06a89d1e06a6b379000dcdcccb3c09683a09c8689d4cb73f9048e537c51334c524787200063f21b0deb4d7031802a5375a68ec4e0dab68b375761f528f54833176b32b4177b300f573a5947008ab1c080dad8290c3135aae349150828014456b28b5f2c5529ce24a500a6a50b4260917248104126134667d2eb62fe1c77d47653bf3bda34e3d078d7f5de030ea6eceeee6f4360cd31b1cd00f35e1eac7dd77329e1f3304414914b7ae11e1f620b07824f49b3b284f39ca860a14109e6ef6807e1e8fd6b9d13ab1759689708344bb0685e3a9183e0a158361ae61355840b1179a4e87e93e140c46f331cc3c8d4cf779357b98ee9b35bca7b29fe9b8209a51ad63de61defdb5a3fa09e98a3dccc7701f911af37dea11f31a9f5c680e7b98a732446a0b8995761d04c6015333339853f7cdb9751fd53a1397753b6fd4ee38f6625454b2551886614934d635222af2bf0423300a2459832d7870a4a3f84f5d28e8f71ec70382b40653f4c0d81596cb1a1cedf02fc591cad403742e3249f7a6e7993ac36e4c4079e3c137aaea0bc0fe7e00c87e46f9180facced5d3a90767ee9ccd1b5e53e1110015e47cacc33887cec59845397fce2e4ad3ab4c3894670df40ab7530fd6d89db9adcced796d08bdb339a2692b6b6b304a6c9adaa3c466a6c9530fafcd4159db9db92f46754ed5ad71a76e9d4f067f3042df1cc6d8157e9dc39999b48dfb6454e7beaefa6b9a6fdb729f7fc3f63e186fdea142a8c44cda688296d10c0000044100f3150000300c0a870342a1509646cab03e14800b739e42745a329ac6b21c4761180419ea8001c010430040000666a4d100d0df795064311ead65739644e40f58d6d7d089910dde5a6450c003bd139a4667ee089c9e430be73a8ea1522c421564652a7fe88484262d4c7de3442e4ef095221ccd1477b1c01742d59e3aa3c6e52e799b1cff4561f37e28ac7fa8340ae0d1068d3c4e120163cf1eea548dfe0bf4beb6593d54af47777ca04379f0fec2dd2023f1904834a15428953881b2ac036fbb044643a4427c471ec9e520e7ad5707e81ea4bb5ba0c62270eea9deb49f2f50599a0e9c6d610d24017d80d3a1af5301defb70de48e57814baa059841ad02f0f1d09b6542fb7009c8d5a04bc01bc8bd6674c5c8a265273a75554ffbfb4fd99a50221497fb1c0cf988a351ed7adecce5f0d696c3c5a6d394f4f1b5f0caab64af889fab749fd56ad7bd06a8b72d83b1130f942ea13c1a34ecbf1812577ca9ce88a0df98353b6bf924231a30d45ba4a4154174554da53a0e06540ddd5bbd80bda6c712eacb2d393e50256644ca044672ac681d5721d57a3d2b36f5405d131f362d02d360f7086530543bdd056e6eddf7109841946237ad1030cc04927252ec439263842eedde300f25ce859e460148ee615029f20850064bd01235ede6813610c8e1b4cabc0b2d70d78539d0182fa1f40e5e7ef2d82ae070ca3b048407507d8f2e7f7f9068c31a46d093d8b956fc0840cd5ae720f788626094a750bd69c9ab65e7b8035c270dd85ce8e1f1576e0f025819324b9ac586f30663ee34bd12d18f376b7cdf40cb4ed162c0d75acb7411c4bb89fd10db699bd050b32b46edfb6b6070ce27a5c241fb61d386cf492097ccc059af8a3d4e4151d119235a768d469e6e1d565b567de6a635441691c91e989be5333902c92ec5e6cd308b17a601a8b6fbcec7c83d96cbb208671c05380771a8d0b0c3fb01ce3f1dc746f70d426ba00501d3f5dec5202669d090c68718fd50413988a3736373ec778e79210a88896951cd1e514514a581fab28c82f151e4da366e94782f3f1cc0644c571be3c65830a381fa0364adf7ce615553fbc65f8f26a72f4d6fb6c8802e65f61435ca39db3f85d08bb1f76ba6c8c3e0712a57d29c52e27e3dfb34edbc418de55a8696282919a75d60a099e5817c4d81b227c19f827ac932a455832c5bf4be1bba015ab1742b8b3290a2e9b9c2a7537624ee69173af4e34ab5c49b99b3acdf78586521b7d628addddc1a36859b8f79b8217b781c8f9a4b6b5827b9a1411aa811218fdc68b5c1c0678ca25b5081c0e3152db45eadd4e8cbd613bbdc991b758dd7a5e765a9b0cd76ba891f5c209e04be9196809ff53ff3f22632d9b47cabef33078b50740ed0f2a020bc8e1eeafe34422364d82264cc67994897afd3465dfe7944a7bc6e2a997e58ef464802fcdee263af90836a2f6456aba9cc6bfcb329d99f17daf7ff2a909b494ce5df9bf31ce92bbc7ccb9e732906ad4ee29a87541ee6d76349eccf5c9d7c0814262d4badc4123a4c6456da52462decc5c576d7df7858901dc2d0dc4e88c8712637cea1d1c82ade48f21dfc7ebb2e7e574b54cc80eba0634f80db44d8dbad324502308500c92e8eef143c24328020d45474dc3a0cc2bd01ea2880f1be68222e47278a9c6fc9382b08621dc09b4729b04c0f0e63d240dad460d77ff87d4595350c42eb728852205a312d2d76990c9f1c8589fe4f5b130e2194834cdcb54bb388c7f977d7a138e3d9ff8d5caeeb69268aa4b9fc0d43bef0c71c3dbcd5f1624ca8388d0b2805287b3f16fd9a66136baef238a7c3280add275d7ef67c499c4f69a30e7bc7f668c2bed1f33779ddbd78c0dc26615d33e7df328ae240e8c8fcf4ce12012810aef8ff1cde2e74124317de6ca06c6e5bbb7a182ad3c47c65067bf7135b1ce697ff70979407b833d413c20ef708f8007b0371c9e8db0f939ecfe9e184a5acd59e91c9d118338d091aa496bc48dd9d280ae2e67272dac33c635f0a1ba7dbaec6ca50c351344113856a3a59b731fa4667cc076c0158307c29479f835bb30b24c4523cb12808b0eedc8e31e260a18082814243048c902d9502516e584269c4fc8e50a923dec5ff2998a842f9ebc68a435962aad1b0ea76b7e793a917275110c2741018cb14be13ce6526387427d424f1e13ba53b4add431c9349f50b3c61f3d8145d6be94aa1b38a8e89213b584e434a1d253546f1617772f5e838c071b9127e40ace55ff197b06f35d83245b85ea3de48088a4bd2c4597f3b16fb3a7c36cec6d56d7b1ae3ad5bdee3ad791f54533837cf5a69a32628daf4f4729ef062f0a7dba733b7c8eb1d214936c081c953662ef163e7f0ef3ac14ee73bd0ef6c2049e1b0bacc8f69514a06b623842675d886316682a7fec877e8fdb7e0ed0eac30edfc049b69a97f05533d1fc3b387705fc2492301889e45595ae072f3c8c7eb33e420846a20a5c82b23668940c50cb45c23d467fb1ea415cba14f47f037a70ee9f8735bc0da0003facb729d6a0d0c8ec68413ee73e37905d0bc6de20c572880da62e3251ffb982d41c8f2e90906532fbc2d2a7d25c6747b0511a9653a66f7ac49be061bed33989e6f61b6c90dc4be5bdc3be29e1aeb4c1a9ef16a63e094e6390511fc83e453f3ea7c9c69d8e1b4b8eb7185e9db238b3ebe78810e2eeb7ad202bcff13112d149f469f42474bea1ab1b469fb67a6fa51577e5b8ba236d484af528b1c59fab24742877332ee36c2b08022aba9cc045685f7e274b3ab3c7df070bf839f6f3aa7f978549c77b6daa1de3baf7c5921f4386ef2ff34066265667e2c45376700089aebde43b96749b8e7fcb4a5ac0119fc22ad2d841b284f0f63f353c88fd675a0f69aedfa8c5f655b6caa866868907981936b27d7f19619686d503d90c97178534ae06ac93a59520ba355be79ccd1cedd67e15497a3c997c443ec9658b23f1b5f79164d52132b29a612c6723d1eb5ac9b8fa9f21e760f1d2c142b937cf45b41e068fac75015587e3e36fb249677e54df3fe83c318075450f819cf4f4b843a55914ca0da4ea296f3f1ff1a510220a5d8ec022b45f7c97acc9a07e477da97c98ae1abe554431dd3ce5725b9888549e545ba8ab119cc04468b444d5f11ddfca9cad6e7c4eb6f3b9105d5d57e996b4191d0e3407e46d068b36518a1d6ea0a3b52f7d87251df3a36fb24a03f7c5db8c5c6302b94aa5206179293f052dc9b3eb7aabc04b4cbb80848953ed738a210d7ccda514ba9cc1476f3ee61d96f4ddad8ad5514f76c840e205457dee2ed0a9479217e90e66bcd8c31079dfd0bd32111d8208e3091f20bf4f6f4332f128b596086ad7af5e09de29efb4e7c07e657f098fbcd34112aabe7b9fe07accc09279f643e3b8541f16f5ba4f32019bcd54c1eb531607796c2d789e33ec72c23216461ffa8ceaf9fa3d866307c0a8f6e8ad6c5a0b1de239f2ed0d923623fbbcb1dd3dc3ab19e1a610974a85f73b73ea315834fa5a42b2f7f88eaca71d4ba180ad2ad6c5c77d213cfc5d4a8cb2c3e633c4f38b0f9052ec8ec2fa0ec23087d612a77d41a8ae25706f71d8146c30a9276ff05138c6b008cc40ba9bf70f9cd2bc6ec67090291a34232045387e6d696d03b96703894d074ec635d0c15fc9cb736850c7ff4f6b98685ccc06e4eff2dd1026323aeaebfaae06e2b6633b998790b4bbadca9fd68700d9338de539cc53839f6a9a8b721d880bd8d9fa196dde968eef8e37297c57dbda24f3c4def97686c7350027db4760ee218dbad664b4c05b1735c77cbc73b876000e0dab04e5c7a3b34a60dddbb1a60214d874e29bba9155e5cd1475faec963ad9889d4abcac18a2bda43ad971332e3cd0f961263b155b63b19f6689acc082ec27d2b72a38bb609078dc85bd576045873172549ad4c600bc0e1706b5bf3426dc6ca74812025330451d81d8dc643a16817af9e13385942e3c6c0de4302501a43bb027fe3d18b6e156e19aebfe6b0bf6e3bcfd181cda0ed654b92a432ba0ffee05f613fc4bea680446ad040f6d0a2ca458b65c050769f94b1fd0ff492b6a0b6fb50ef3bd9063238646f96ae75a893ae15709aad73aacc2b8a7b8fe44d356fdf879ec319ef9985ad49e17cec4538b4e00bfb2c3d8495d1480fd1f1752767a18ee8459454fce06c8b02450d6dcf50dac32e951453b0c98e1fe7e2e3de61566cd3079f4bac8fe404acf07237d0406210e2f7f800dc2534ee689f48eab0fe0af6fc8e60a821759fa76383dad01a00b11f260b7cbad6079e05eabd455f88e608c3615ae191cd60727e7de3b08ee483d60689edf9bb43f765e7e0c47ffd1047d13dac247f1268d2c8e17a765d6ff48fc1fed4b3bb443605a5ee55b42d54464497785436a0f74fa4669dea8b3921012c73af3327dc75f82126a68fa36b0e8b059e0de4009fd6a20d715fda45227b9c1d82e37007702c52cf5cd929535a777269869596a7766301d9a734b98e9a8c8701e3e1711199a014feba06b91cba96b9234a97e3fca33b91d122db83a8d142202854ab2a3232761483f03f31df63de5cc63b58cd8b61252b9507ef8bddb540dc9d8b776b8b3174dfb65a9d626ab4219b01b1018d9146f59ce21a0e7e386986366c79d2552b165518b868187328943d20724055a8b1cded27b78c287b9494110f2e8abfc61794176ce0f999953ec14992ccd6cf66c85b5ffd798751f23458e4c177ae9fb3c30bad18d0ec743b40924b4a1f2b6e89250695e6d01935e3c0dc9ce3f2c61b062e739390cf475be0eccdab1655502b070949a5f499d59b9ac08c19cdf28c1850e5d2d072bd0eb64c442f1810fea0762972bdc05e69f2dca7de0a19b63f62c1f8bad0b49ea1be7c963d85f51195ce9f1bd0aa38a80b89c22216d3e88e7012934b65db8af45671f79eff83301efe623453172d0ba0cd103319619761f18fc4e34707d1358c32015e5b58d2e1774988b84db402d051572d3f9497e57ba965e3e3cad30a43a1f25ca25b43901580108d3e6170ce01806ae1a09ebd08a04b3e1169dbab9c1aff4cc3f15fc8e5e0eb16fc9ca8d0cf9fe54a5da107fa6daa580e007636c7146ebfdc2ae45a23059b58d90f203b48680743b458c6fa916e3a368d1720cdf07855e13bd1f53e9b0853754827d16f96e2d2809ab3cf1bef14fc37c0d36679f5a0ffbeae887b99a3959b64faeddd853285608e2fa0c9bd35febed6fec065e0d983cbd8c187924757664a8a1a52b2b8239682a5f8d825fc5d821967a86390d3f67f8587cc2a46a274bc406449f1052635c7680e4e9e36f918cf459759ebe40f5cdb278094c7a3fa635c163f922471f31902eed7d9e3cde038abad625f7da1ff2405cfb3bfe5813747a1607bc223ff872c27663e9c8113ac4b81c569b8adb78072b471bf497600deaece3631666a400f9d1d4993bd3ba4a98d7598443f529d7b2949584e26a8740af14e66aeb2974dfb2908a269e07a87a3b6d1910f956deffaada1417e463f4834feb0eba9bc4e7a58344bafa5de615bab8fbebd6c604a6c28f82923c423f7b18ddbb6c0d221a0839a40a9884d694588150112893a8a72f7c1b4984fcc1f0b666d4868b0b6f46490710d47defe952a20bbe4d46929a59086fd39989c6ff4e01f33775112dd31f0a1c6b9dcdd8b1e40c4aa7e3578ba4d29742bc796cc7fff3dbea996345ff02b705e253a16c7400479fa29d257c9024a38eeff5a36f386354167a59e86e7d04bd74238bc3fc1c020d8ef2eed09bf0c5ab03ebc5dac26c2670a53b3545997577faa1e952be4843c1d474001a87bb15bb92d4b919809bdcaaf77a2427b0113d4248e67253782de84f09487167295a3aa038e9091ea44ebc09b7b2e963b73bfb07312b55255e0777fb601fbf2ad561399947d7b55b36cadfe8c39eb7f07a606a4c348d4dfb7a7fa07c989f72739c42e096be1e0d3c35525f4799d89fd26273a32b7e1f2a7e01a83b7e4029e125218276b6e5568d97e7d5f78c449bfad2b66c991452890e2ec07bd555f5c99dd50e59212de51211af6cb6827cc6f9b17381056e433a18e4f3c132a4c6fa4708fcf3078143f80a1559a6d8b9d10a0689f4fc61425db27380b00e6cca6a2b6047de0ad42af6b6b7dd3adff083c0360a6214cd9e984c8f0a48f8bab19ea50a2b93d04bd972a3a04c05abcaa20e346732c91b58a5944c1505ca36ebcfae15ad9c5c0ec3f3cb6acc271be14d2927f4afa1282d5fc7673887d6c08a279152ec4292fa2a7e6a99bf32885ef541c4fb45c9d15b181c8511ed5c9d4e44d8b656374146cad1bd6c602b892a816efe15f4234266ea2f44d45a8abd90b06e54939d05055bec508c5b76017b815c893115f164dc0b9432d6417efbd137f214c8b4370813d997f26f2f0e8c44ab8ea402d6defb8d32c1879aad03afdc204fa3b03a8ad00baa06f5196b4e0cf582ba8e2c110856ff46edd4e524583796744266489d9423e3782aa9b25c515402456613775356028df4b348b77d9fab9612c22285022b40352346627a1388015821ea8a747d8ded86809e215402a9017250fd61b106f216d465a4c6e822f930ae7f723dd1c57a98dd91bd0bc3a94b7d01560477c0846323eba415220177449bde08ed83a2c3504e52958936ca2639b5d8e6a71ca5669686015f1c645e520dafad39addb64f3cdbc510127c4e495b55201d0afc324cdd87093bd90b6f83d0e0404a25d82dc0ec66a1bf7b601f80f65bb70edbd5edfeba657cb077f4969d7c5e323f5719a7bfb8662ac24996a8f4ff1a8762f057fc9211fd0cae983efc840ec734e605f5e6509629b18e64620206d58253bb22bb03f480e42ab31a796e0f5c1ef57625322cfd184843e6bcc2a34c1f58df7222a7c3790433b7b6cbfd47646155e420cdf42dfc1a27c366d1293ad92df4a7d01a81cfbfbcc98a3de66d935c8afe64335bf1480a8af8d443af41b0bfe830b940a718fa880fc74a83a85b7952e907385eef739858601124a21e0f9a4c898b21e04eeaab7c59315e9f40da080a04b94bd2403714ee0caf44d35319f9ca87e1a6bbb5f7810a100f957f95485e85713654d9fed3233fca2ae425c10475ce586bfbd55db18562ce13e57a293b11411363781cb950e8e70e38012d6c02e4f06251476c14a2a30e21f8d950860e20028f8bab834f1efae6c6e81c0ec8f4c834273398f06eac1a065717b58410a03c109633270851a1f7636684415fa4cc530efff811b7e2571760fb11ce09e797d0e599012013e376f2e04c6c68d47cf077ad701153f3ea2fa478348e50fcb2e05a1218e862bdf9616d603a8fdfd2adff361b9fef6f8b19edfcf2c1dfee1fc8e86ee47573d83ac16d7c871877bce5751bf1fb09948bf858d43d70f96347b052bf2054008810e84037daf658b41a34c7fc8678abb1b11eb37b2de8f8389e05bcf1fdc816cc736219bae92a531fdcd671b2ea485b6e56463d81ffceeaf34ba5062eb537249b136b9564b2a83373bc8e934bfed3d8c66ad83f0e5d851d6cb23c18832a22f4ef93e2641ddf13c8791f06cb2eb2017ae72138f89fe1c85f2e57f2438348e6999c0ddd0cdf5438622640b6ee30796a4b4d4fb517e425b1aa9de428eb56285414240aa00a418661b5724124e29d1f08af8f6dbc8e834f574e6c085950342ca7209794a794e14fd583f4c807860e87029112a7c58db8915d116499f0af0a1cde3867eba69ca6fec51a16c8bdc9e750c35181d4f7b54624dc6692a9e083ad55f69109ba79b2e5a7c8706b0eef5df4ed13f955833c4d9949e2e0d44894694540fff8cf50e253a26f4c094f4a176a162a8ba2be16d894b1c4dcc572d01e04e8d3fa6c19e007a0886600ed5e5228041dea74138ce05528cba891a70b935ba81b208001a75e29d2736b124a85a6ab50e440b147dcaec352575167876bb07fba9e06f3390bf2e46039aea0188f8653456b810805cd2dfea5fb7bc626194c123e97da879e63bb3be3b830c86661dbc29d29651e32fd9ef156c95128652ab3a47c6b5fad20fe61d18d1220bdbf6ee0dedbcfb5f549e765ee92eaa151908ef72b29baed959920547f96ecf38fded3dcb668c9c703d66f37efaabc092fdb4594b46b673589c67e4df6a2dde5c9525290f9272ccc963edc4cc47133888733c4bcfae643754f248e984f476e63653a7623808c32001a191fc4ede45b04afa77da9e2524d9b7e62f44bdcf8820c421022116874f40f2338146e3137be335016a8271ba53dcbae0485fa7a147dc45253e19c2995fb68b0385cfa8ee0e7b51b0075bd75d651fe7d3ddcd948edd303d9dd149c607b32d0a90174e7fc22f4828b0403040a1d602dc520ec239a1f6ddf523322c9fcbc2ea02585f92dab2683442d7fc519df92e6f0b0a4925c5224814128538ab53962f56acfb068e00628c54edf44a2c23014629036ac7211e07919f61ca1ec7bdd6d8cdc431e8a17b15f65268d5c5b46b84bc09706b708f62613b480bef02adc1b69a6d5bf041afedfb1015a439e3fd36516eae779024b7e607e1162b1ff69c5cfbcc25210fbe20257827019ebd97ca25b9d8c639c913c715a18636bffd41acac736f050da63012a53f6c1bc918b21b064008b7c952b505e20fdf3e6ee9b3487d92442d100326ea15da1162c12039e7aeb3698754ee526c182ac4b327596514a2dd126671513eb609fe787f0c98e03b048881f613a66cb636ef4b84e0d4066f1608439be18e23e60e42ddc1d423ef57f7094587c682ef243319eb1523482389fcaf2eda2e0e9a635ab67b0b161d8c4612ae2a8f7a465881762b3bdb04203e209d4c3a5a1d307d42af73016e1c4a47140d305e5d3d32df9b6780e7f32a5b7b7532ed50614b8316ca9187ff652744db4e18faf3658f9dac1000d88cf283a3fd0e5d6ca229599e6aaf4f8ead73048d5c0803e47a5516e8e80defba2929ced244a30f268398d2e6aca80367861d605b2b6f7881fbc4bb86d0b6c03bb4704782251d3935d398863df66aaf9531ab00649afa44bc478bde633e739abc7aaecee9387af290898538521e1e1160f9429f50769daf79506e85f3d8187c20d89555cbb5c398c502e376a80b5a5d8f853ae59648e99eeba0672e121da01c3f72783de68543eb9f24feb5d9dced675119f758ef2efe309099d5c33536eea5fa0c5960b9ac90694b498f4eea9ce02ea426d14a9b1bcb9bcfe8f743c69175a6d5f83aefd3b8a60d932c24bd6bb1945dc905949138db8b41f2da228efe3e7ddc80a689e77d80398d4b50f1a414ab513a3f9abc133a91623d6d20b8ebfd2d65d872291099a3fb4c807b087aa0c1902bee1e3501cf16b2ca68898a045e3c70974da81b4a0771e81bd8e54cba3ab409e92923b0a21a569701e95f800d2f061c752c3abb3d8debf906bcad8b952344817d84a486d4828201d84bacde7a8aa2948dd5488446ed65d34c3747b3631ad3e9f16735ffc227092f697a856f366b8014bc69557d6a7062139dfcbafc5c7b1c36662ce66ff97d3778d183693ecab98cfbe941602d6e3c60bf6a9388147a45896e29d4925fc7e12c72d32a25b5b256206640e8fbd7224202e584188f52ac593e13fdc7d4a5e81337af345796bbd65894e0b5e86c19d9c8bba0663dc6bf4a4663b167bc14592577c803916b0d4e2467c1a2d12ac1463744b18af81d28cbe8f822dd51c1201c4275d6b79e3acd08b00f475003057088abf5fdaa30571ff0e62e419c8d086994cb5163abb796e86943142a8e622a6efa5ecfab5041db15e26d1ffa69136f7ae3bb9eed26407385b72a02e81f3a2daaa6e094e5208c38a84624c64f80fc81d7d9caad4b0aca4953b0eee10529b4a4272f97ef05b49630273dde627f6121e39afce8e575917826fcc131cf113fbeba77f2a265f3eb38611c8a5418bfdbd916cfaa06f4b95fcc0ca5d1c6e5bc48cc1e5d221e3664f098c008ab98cbc929299bc6dfb89ad30580cb2d69830d9a885934218be71570c08f8aac52d4e32de961368063aa7f72a913d98ffa0e09c9d377ac42652ecfd29241ee6369a7b3f4b167f4d7799ac227378aac77aa1c431796c6cc27a422919556157f6f7e7aa17aef1d26239afbaa735b7f0d4941546e6e0bc27bbd4b848c2b55e3f7b7bd639fbc31ffce601225043bc09205b307f020fbf96e734a7f9fb4919dc3c30f82b8b63a35c88b6e007f6f82ba89c30d72238288599711e000fdfd84d8d05ccce8b02f63a5ef4af63764936f48a9b443fc621cb15e439b6043e98eb58d7d2ba85d0ca354025c35524c05393588c75d4ca621ed4f66197e893b5c4e5b04b9496ea94334d32c446d995da7c8d59335a42c5a0d4ae1cda57b3c3b5b6d2c68cc873e056726b059a22e7435eac8a5889bdd2d456c6bedfe386bf519ac9dcac4740f7724eadde37cf22de3a243b3ed97a4fb834107019bc8b97092036d60095ef0eea350d29cf0be4f1e6dde1691453de32a5469d2e675f91846284cd5ea828a85746cd7346f2f8426a1c19df7cb0815d9e9d35290772034f21c756f88d5006de821cae6851125a5da3dbb48b8725fd3a31a25c3195c2e8ba295521c62e856e66d7b68c3d232e2dfd4170939f514605c2a22f3766d52b5005b92c11cc0bf8acce29789eb33ac008f303651b3ff7c645650391f46d4cb1a87a743c524c5842490101eca0a0b56eb74421541bd9f0ac39683603c50c99efc3704c9bea057ecc451baa944b0822355e3f59108a67da51103337deff97dca62378c1d07f17393775e3800100e73e5ff1c24bfcada77d9fe10226546939a9d4b58d995fe679981f0533832bb11a9dd3eb602c7f65e3d35cb15bed3a6e1d8b11e1aa40177b45ed3199edd77e0a2efd584996c46a8913c6fc8589617fdef789253f9279e76c161cbe4d3a8f439c28cd963cb8163fab40b9a0cd8de13abf7c826040a5241fa1a8fd1324eb40906f1f40f9188944362e983d39ab89b87d622df8b32b19c1dbc4d97c4fb9b4cc287ff50de6ec9487bfc6767b2f1b781c853c9f139e1dcebe1c1d7927514b68eaf2b0abeae8c442c775a20598b91456910c819132d19b30fdce330aae2ef32a90db888ef5e09fd5d747c5e54dbf130af6c29677c120ea94e61812530b76b1e60c6dfa31a3a4230c36a90fbfc8846bf932620e3e28c4e863b7992012014668cca1e7346d593a8ac436de93830077cf915f948917d0c21ec2511d831b32ecb99c77fa3c8bbf8542b01ca252d179aed4c24109a2bba3fce9bce75b80f13a3ddf96af9094e3157edf29411e677afe1127188f442ae59a6a5d2ed26c9cd0ba8d9ae3560790e40cbc829b4950585e97bdad5b3908e9a4e108f6a3274fc7915677b74a16091904c21b546bb01beb7c3fee40c8b41ffd07bca9a1187d1eb35cd2cce60b1cef23d58618b255a12ac6a5f0badb9af5abf40bf5d0f201b91b4b9cafe4b0d66c60f7146a6ee25ef7f750a81d6f935027d00ef70e9f48b75d800b0d305db87b8d9e39a1d152fbd1abe6e6dfe0340c70fd2887af99a04a36f173d5ee7210aaca7db26727a5e5e261dceacd56ffcf3fc2038d07ef4a93c12699dae49de9079616e9b38dadbe6bd1c3bedc967f150ef4f02783de16eb8b74121287049024fef877ebd8de1682faacb7962a8fecacd5370bacee8c2302191b0fdef9a79d4a18cbe5ca5ef3bad66fe55fefd8d9dc35e08e8bb11ddbcb9bfbe9b122a6b76b8dc66d99a064f26faf3096a4de5465ae8dacfdbb4840f9334475b8357d42140802c104bbbfa2fffe827859ed650ccbcf5c7dee37b288b34158a355889067261faf5af94d6d2e2cec9caca7edc1662e68a74fb41d9d5ce39fc9fb38539b89e1ad71a7fe2d658385463eff43d63f106f2171c92c559885af31c0ab7ae85a8e031208e899844278eea1d3da9aa5e4a94e8d9b73549ead2085088f13bdd567e1e2e23923072ab76220881d015e3fb390687449bc8ad829ab6286823d18bb8440dbec107c72d15f281e316e4c0548aad0fd8e9d7e7706a427ae31db9c2732d4cfdd671cb99d5c7ad6555f9f583a60930ec2da44dc5423637f9a3b655c284b8269e9a0fd9e446096468056e7a6d598190398341421726f366ee0261c6d0ad1203198378f1881d9ffe0061319105af7f2f9fe91357cb5033999c0c0f32496a4cf22878368556c146eb1ba76433e3921bfb36dc09e1fa738ef170a634a64ad9c2c93d485a7dd7d38a0895d936e29284af993f425c224c3c22c4916790c311bd120eb970b43307cb9273c98501ead19ca024ddca20ed8a78b797d4b164b3223f8a33790f94f1daaedfcdf523808207e8383cdfc5fa2913507d176d1630a08b2f8a090081c41ad355ea28606ca789cc2aacbe421e13bfffc564ea6e245acb8f7514f6f94da50b60fa95a3d256697aec17c633e1ab278fb4c4ba3acda78ffdd628cc1277f9432d2c681419a8973500ab4ded261d4b42b3edb16f4198e89302822bf11727fe79a5143b43d40dfcb1ef38a6ad491a788c4bda413bde92ef99e44604db7fde66a0ef8a3c4c3a30498e5ec09b2a65abbd1c10e906853cf88a05119aa502b8f8fd03e9647c81e1887ef754ae16fbaf6e387db28643b8b66a4e9e7faf31d087f5e1350257bc5c802a07998bf666a33fc3f60b28d9835dcebf8c5809e622378670814c30b9dd457159fb26b53e1c95e168660809b882ddc1c3d4549288db429866d34c76220154ddd4ab9e5596c13f60e13cf96bf5f831737c841c40aafa8e905cd01d7ab146bfd12aad52c7a685d8515377ebc87b2a9b1c3e6a93e0ac6a54d68a86260ddf635adaf7b09598a7d21c060a04e0c9273540f449264330a1d8d3f2a33cd214b7d4b76489a8eb05246f31457281204fd66872eb4057ed6284e4ad0f8095c26b3f54a17ebbbc427c68b12586e5104ff44053f4ac1f17aa6a8a59a4567d7e30b5394b69ac5dda4b22ba27d1c0251d2e60f627cf05e2c984cf15f84e0a9842896dc232d1347dd9a1fb0cbf58c2c039258059c52731179d1fcb8913b1c1a158858a408172d333c2f894e7877824f0b1507daa2733aaba1cfcbeaf786dfac0cf36624f6146a8173df41f0daaceb7d50e5dc2472c079d5adc8361313e20d8f575c031ede05dddbb7865d982f272dce26837d7fb61c6990e77379061ae6ce5b9fc9f3355bd4ff9a7db73f940fdfe0eb48a1152e89c4928723e9edc14bce90b22779c1b72f36bf24856720cb33f6a809bc9d2ad421fed5227bce558898c88f3f23114a453e7af0b0a760f9483396b571a37a4f255037ea0b2986f9a1f398bc80869d5d7d1de832cc72a10645984cd021c490e97306ef075a842a3791b2ca4816f3d23733ca16e917342c1203d8c846b1ab1be32eafe49924c8e1b81489d892215e90c59026138d530d1577b2f8010057e218bf92446dd05de7d6b9678420e0ffe060cb9412de06edc13e639d5a655b08ac6e3523aadd118ee1b108b5902e9f0cd94f59f9b21b25abadd84112b91a60ef254c0f394da418e64431e6eded88c865a976ae8b6332b92e02c324ce0238aeeeb94f1776b98401f04da5fb7e167fe892753678f7bffbfc1829c2ad70529723034e1bd36b9ca33716114aa3b90bd8c13b4fcdb9fc8a0235715a1463a91d7ef8814842283b1258808f4ad671c0e7611d7ff28f98300b79b63e266b7d0443ff9c99f7ca59936cfb22543b319f4ae0f8612416d7ee803b04c63c275d721f6fad0b60dc7a053fb11c72e33a78424addca64160ec17c71c5f0094cd63d2df90d565873ce629ff1f0bec2412a5253932cb1f931b36f566f757061fee36a8b4c4548793ff9e71cf318743f4a1c9488be3994f7b7e86c6e1281db3e77804bf2c7622474d9d9c4ca648988fed0e6d84bca4aac8479dcd701568470bd61f0c0b2888a1f23a35b559c0b816acfd6c1e53b892f17b9ecdb8650498a2eb11c812c800ff12a02b563beb2ef9efdcaaab337fa9572e92eba5aea0bad4877fce4843427637b7fd88535a30829795afff493e9998b5aaae17cbb6cb83b561a84061beb8619da0ca7a2e5142f10096d9890c65502ac423a1b164c23afa34de779d0ff0ef6d883f44c9628dab15b6d5dd7ce05118633e841f563d65ebd0b2614094a2e1b0de1f9c3f230f167c8dd67e2a20fe7f90ddff7b06f55b7462db05987eac44bfe9432bff0133585b7494c9a4c93b76edaff2e6d22a0e93e1e9e1985c9f8dda50822ae7747a8ab46ba238f438985335129a133fba59fcb64e969414be2ed36efd293956e3c89c5ebf846283b6a2d78cd2a5e3858e18c51cfa4255a0121b4af12ec4a3295fe949668d6907f7b5f0b9f9640b239d6d6367073680ab93f2cb1851ed0aacb307fe3145bdf49df5fbd414e3c225d645aa86c26f5896f1d7aaf13cc0a00cc2dedd5d3453bbba6830d804ad401b8fab7f6510dba3a21d65d5468e1107a7ddd63c06645ce6c7f89e82fb95439384811ad02a1ef00f16bca32421490c87f6d3d140d1ba6234ff9a3b74e66e774aec2807fe18700587a5090a6aa5f0f00e868f459d93831af24186695eb3c33d68cf6df43d2d3d1bd6f6420f1d7ef572d8e5d1d60d9f5071ffaab15d02417b4d6c94ace7a8246fb6bb4c2d45f04ec2f44400dac6fdc84798834340191dc18b137a836fd394798eed4ebfc39be3850e33893de7f928deb834d8cfa9342e2eb1250506f0d555007098d0a21cc8e4e3a636eff171ce4160a842f925ff50c3b1d257d699723b3b0d47225b092139d06c9043b87c0bd370d17064c7fa9b35ecfa6c0acd3aa3ad8170850d3c9a5d2bcf14221d77378e28dce1070af311c3c5a72247d9a43eeae38c0fbede23f500cb8a372df5b2c6a1437725dbb82f94dacfe713b8854c1607ef473d8b437bcc5866cb10a8bf9f7d056e6501d2e89ee8b52546ac2c1153f00b7a765eb435eba65bac805fe592142aeafeb5019d6d0f15a6730ce85837e2a08478c2dbef608b0c7912667f3576817d187ac4a22836bca24addffac70c15cce5604b0d7749d856cf75f7875c50b747ede9a43d3878708283283bf908efb14d4544ac28e96a7ef042a54ed91599496c40bf9fbfeea1a49c7760449c5d4f7008d7224d4b3829aac6b55a3f2295966d31821e20de126a7bc34a17d65f1db753ad4868a847c95a79b6d1b037ca9403f12639c5d94eac2e8087b0d302f914fb068290f77be34a0ead151b5e673273b54c0a986c85101d3616387644d3d535905e9baa83618092c54841479a06043804e081821364af4a5bd7151e77606ae4756e415a6debc80fc31e0f40665cb4521ad0eb25f09c307687630652570d83defe779d94d8bda202dd68b64b7f64c39edea7b911f58b975bfbc2de1c1ccd55bbd5c5d98b3e3a6a44899d4733dd5e73f5091ae98d83cce87a252d710a63b68b6b4d738e78b24b4413463850def2ac43fa0a87b9fae3d84a53df24655d86dd6a367f92eec4f52a2dfe029bf0d39fdf1562f38419a95fa3f1a9cb44d35b944c02b499304de70db1430a535522898b77eb812a54d0a8bdc3eb5c07f12e5c215def461a268a01fc77e2f3d43ae5daaf1092ad043548adba9db475f903985cf2075e1dfe217d44105466f6f107349c0290aa4f7e2f5d3a1dc1c8fde1ca8c79332014b6cc839bc05faa9e5405948cb91955c07e00dadeda8f0dea0a8e6cc6a6d93d20b769821f5aa4db2c0998f274583e6e5a648eee828a996341e1497c63118aab06c06c7195b80aacb62d6be6e8a10fc50ca56b9b94ab03a3c338e3a16be7aaa6b3d385bbea89c81b5b907a0c8c2fed07770ad3b1c8390f4c1215313e6981235160fda3bf0f46421b834856c83c6c42a575cbcd255cf4e9419f56565647bc1406f4aeceaa601732585496c4d0fa05b221b55179c211b90934b756c7c00afe15894635538d2267924c6c244a01bb536e08dcd1b35887db3d746dd7bc14923b54a3497da8637dda356beccdc18696cf58e69ab762792d874aa1e44c5a8dd577974d1c667f1e8a0aa72814bca3f937786b74a13198b9355606f8b11fb174a8b8b2d9c81bbafe90bebec204a3a93050328eaa3285f2f056199597bcc353e14b308bb5c3e22d91edd401124e03727bad236899b8fc26d0b51dcacc2b0da9414aa7683c3af2393cb106ca6223d4bcb37b77706a31bff303252e2c015dd0cd91a28fe85a9c28391e988ce70827c1db78ced988d71963e3e6de4b0588101375f33b79cb8d57c09a1c3637663da52523aab19532c031b883922e4ef836f34b515b3dee861f7907fa04c0cd4e083d68225d86851cb9f671c81672804714a9020acd0ca0be4f9c33eafd9286b844fab9c2a8580b5f79c7ed7992bb34c19eb5ee1aa38ebd620c999b91ffec0902d5fa933c47667c0628272ff3e9d58e623049ae0c3caa0f7223a48bd647a58ce1e95a62ba21b7505121cbd13411982ddf338793177c821ef7e2454dd2180c7e968f24cf53efbf7e962f769ded72c00c7312ea2dbd47ca95ca1eff0aeec8a8f331bd7405b44840cb0ba3b0cfded40a208730fe62e537c99561714de7d4f3c81e0824d7a045db8da8f9c88e1114a9a0c97e1fccb7f0126a95d942350ac132157eed442117c22cd69487a004c08d03eff97569e18adf23d2b54dbc924433b6efe4e20f42311ccdd66943bd5e31db7d4b1052446626486800a178347c5475274751719c7ff66073d2120652cdc9f1affc2a350583ede431cc85ec00dc441a6b529592a8aeea99047d257a05744f281982f8178c9a1364e21c9dd63fdae573e2b47f87b138a4b3597377a507e898492dfa61bb255c40fafc8bd9349896abe0a08b191cf1adb21432660a663656c53bae3b8f7db657878b2bb2d93e62ea399aeb6f5757e775b8e7fb3696da882d24d6f9465f1566edc0d2d6c08d2cd1a5dc56f30f9c47f78fedbd58d09ddac40b279026d513b7f9c1ab721dd1f8a6835218b0c62d8e03c6af48d530d6ba7c74ed3f11b51ac0b9a8f319ced2cd2846b6ed308a1551551dd598fd2f406e8731af3a8da3dc6fbbed744e4b22b3d73d5331bbb7245082ac9df6d72fd59db877d9b8bd442d0f671ef0eb2b872439c1eeb6b92368c52b662536b1e85645705511119f00949d5f2890652d1a71d5457674eb761b9d02657498f9b9f7bd8a2cf1cd6b1d5b45d64c00c7f2be2e546ab6e74d491898addc3e762c4476cddd4e5711f5a4ab6153e333204faa185c56c2a81628ddbf4004ccf4ce649c120d20fa33219d0196dcc0c7bafe2e34eaf327171a72a52c93528559ccc5961e1d502b158a7a701114c47f35cfedff455c23a67f5de66887b46bcda187dcb46f00c16e2225e88fc9fcbe5667a0676bbd527d371bd08eb4abec65801c226e021da0e0526dd1882755901482e8070572a43366ac23da5a14bc96330afb604b5367f64ac9fea96321efb0ddad7c329b3feee015b6a668e4473aa520c94ec95d4e367b50fbcdfcfd81e173052526cb65a34aa748476112c0c25dd60eb7a532d90f541bb948dc26018f4443bc714c6e67c0a18dacd5c6141b2ba8cca6bc820658d6de9523a8a42066fb0b3b56eed8f9ddf2d3735f87fc49ed82542fc2f8c4b1b71b1ae93c62ea07f1cc052c9dfbfa52f2f180943ca05feb7d5dfb04f57d4de9136542f9facb60af908e6c4a047496bf382a1658ec47d3a27be7027ec8555222f9f16dff7029983ba3bf0e99a913ee6f98ae03bf295f86469f935e0c0e89658d116a697009a0ab5a99a7434d55c25a770d4b57a741a55dcd7ae33ee33e819bad15413789fa3f1a6f116bd45c9cfcd8f0de0fe6c71814939633b8cc3bbab36ba416e0fc45a5ede806620506a6e5e222f0eae213c7e3a3a359fa4354a6d9e04dab5ced04bd140a0ed447f9ca458a9899933495f0337ae057093e52ad9aab05c6e4e161a540cc70e4f24bc7140ba401b836897e8651eccabf4fc3a1c0c829668dbbfc3448dd5cb20575753e7b1fb97a098386a10c9fc551021eb23eb681dca3c440b98b9bdc80723afdf5f22bbe5989755e2129648133ac04c1975118af613dfe9883d2982cfae922a19b44a875ca75ed3f5b92f704a2a0c8ac787e9f090f1b0c6f66223985544b68a5696f2afffd15601443e29d2afc6d9ffdb4f32b67e4e8720fb29102cdf4383e58ccbbafb106264e5a2fe47ff0f0e573c2e98b849a9f1b3129686a071e9b57540cbad68dd72e553dca204ee40ed99e0367ca45e42ca058f9c14da69349c183d8fc49d8236a0e81c9daed7082366627e9c95f72f67acacb320ed35c915d1abb8e49340e41bd3c04cc591a115e1664a9b6d8397097d9a6622a7c60e7869194589be5c0c7d6f0854dcb9f535625af328875c6266c3c0ff3df818ade7283bc1aaedee4b29e90666ccfe4e2b0d451f0972105ad695abde4cb846bd99573060701d477496c20f5c8a611cda86e46e6194b8b2974cad6b5fed3af15df6447fedb1922d54f71e325e7f27a8303fa42f60c14c6caab36ec22053599b1091540235472e37e774eaf461a4a64c54b9a482629495326b53b08c825e0d19a725f14d12fa7e2efac47bb2cbdc598af68f24e7f338c5d55950b2d47e09b6037e30247083a29038785da56134b57863725531cd427c13af0298dce83e68f17d13a85c2e28fe7d34a05250583b1a4732ca0090be652819091c161205f7edba145eb9f65351a85ebbce227e9aced84dc34de4cab1af36f52a01f287f1b8d58f35a17306270a19c057809e24ff4b78082df40a77de032f987d7827299f616be6249f4e5a3e190cc6aeb85ef605e27b80001a4ec66357ef621ad06649953c201770cdf8ab794ba2d74500a65aad04b9c8d793237185e79aca34c5b8d3399be558c70e4e907e9e70d798d62cb1888b1b0d6aeea4ab6c90c9a2b045221ec0a1df232b6bec70ebd5accf45927311c96e3a463d03039a27c137caff88b36ad06388da213ec1fc0c75c6c646faa14da7fc748dc01be9e6b62236053d79a50181fffe0700fd7d78815c3b99445ae88140febede19210e7dbb3db72b4c55b63cfd78aaefd598595faa58f9e72d00bd9b102bedc15fd31f33fd3a840c19987a91b1142b1f26df9635230eacc243f27b4fce3b1ef62cbcee2b30f3ac216218376d40db08bc35ad5f4a6f5ac0008a9032ed17e78798de71ba21709c63fddc113f14f320799c29e7ba89871e9225ac953bc3457e45470ede7b9fcd70714abc8dc19a4802bd06ab1acd59d69816778d55e7c9f10ed257d28e9c6e9ae0e3d53485a20ef6c2a46d6355a64ccadb040450dfa5f12c3f535c296e08e1183a685b57ada0ff8960a6a0d895e09c511fc79aacbcd03026b47eeb3ab4eb57beac82492303e129c3e168028c112518bb7ebb9fa4269617cb2ab61484914993a79a3f117434dc928047f2f549bc7fd0a3c4e593c7a554d046a94e549cf505fadc3537301f3be458add522bdcf5fdbc9942dcb34c158cb713e2df0ef0db5c7ef5500bff6bb2822c71a88b2c094d1ffc7e130a53552b4b3fab54e8372be661614df20cb7396a788eb565e30979e3c2b318a51257323b0f99ae03d179247f888ab731227111791f95134c2efd1dd44ab7857440fab93bbe07e6ca3e9b0d5468aa1c478ebc60606f5716b6a1bb53c366fe23fcdd205369178acd5dd230abbb0734270ed92436b5e73d0bfab9e956be48f2c31ad986acd2dbc06dea2763ce85e55ca73fb13e3d12fb5e8267cb7450057e4f4a0d1a7e3436ab139ec637c0cfd8d5bf14cc6e43cc61665973524a86121c07ae6611e43a5adbebe35549b42a4488fa0914243d47d13368da811e38483b67ebe5a4ea2f09a23b70dad0dd3693ba771899dce8da192f9b9536b801d3e0391968da8416b762aac180e30add2c730c85e400c27b419a2af339e481522297e3283566d296aa7691c15a87bd8c3a831ef477e13e9ac3d44e62731757b1838ae3b88ea3a5db9eb9c7b38bf16aa75cbe2ae9faede2366a17f9a208b3da4af81b2af3a7ca7b6a8c874d5f0d59e20a26143e911d4ba99925a47c5cf23c72d788bcb756a75653bd55cb0c13cb93e930b2e4ab236318e85d441b52af6793996abeac4e692961f7d335baf155068a2e99625def90b8434b80357e484381a791ed7ebf981d7dd5c202a15bd2536845660dff3a9a1ca6e9b7a2f904d1920cd7954918812ba863411a026440fbae3dcb3459d8a2c44695d23eb3abb56e2dc1935632787b33989b9876c6c3b03e50021740d3ba464d536e85a486004812ad1544ed10c4751ae13344102c44e50695a569ffe6d4083d5b26c2f46d7c5840c27856f45938bb13bd91e193c4f61c1f5ec2ce8e3a322a3b535a992633c3c82b62e5a3b81eee21d620fab80af635b1f85da35d204b07e5b6455d3db7e352f9f2968edce3a0c34fb0ac425da027b98d509d0862ad351763d7c4c9a4432b2cf741e2385bb26e7acb333b093aed231bc695330b188f140dcb89d752b9f9cf11716a076bf19690e8196f0ac4483e775625500edbb88e78a3befb70cbac0634ae3b998aa0b34db39f0c088f2196550552015a405c20cb171bccd981445b21176c24ebbbc32b2931c15a0f84fdeb8a9650f6af563f60b374da42601a6f7c9e1ac6ecb854712ccd5a9e811cdbe2229d8d517ff7e809e758bf7c03a88884bd33f7f1cff3c4e317d612e57c42af0da0deca619ec7a16f49131aaa68d42c4119565da3af3aab8804cf3e81b9c4cd389bf1c95c229a049b696d2f20b348b68d1c41441158a1a866446164e9fb4367dd861f287bd543eb164f57b1e80985bfbb0a75be18ada1ab4079301502bc7fbc086d2691082f4fd94c90c9429c99a703d724ea4287b70d58759a75ea71106b0e9745fbac0ac1d4b8d6b6c06b885413e3165f0fbea378507ff3c470a9acf63d241777f486386cbc66755d170e8a5a80fdc88d26b018aa35739993e7e8992ccb2ccd4edcba28e6cfb6241efe1689dd2f1aae17a4c1f765e5136a2288db67da39672195e702596a0b70b47299741f4e83390e3f342c046f2545766807f7b5d7ec0d867ba5e086ca36067a3e9c48ae593e101c9b517df65a4d2aaa16d3c996a1fcbe7fceb97a1f5bba29715407900f03f4e072335c34be830a347f75b74431496e01bea0f6767c3e7094be5669b514526fe0e55e808ed29f649542d2b641308cbd9b5f899d3fa8557891cc925bce017ebb6ad0c2fea702cc88dbcee394038c6f0b340db763e5fe15587df7d396da30abb4e3261a3fd41a36b17646fedc3ab94e585e989dab3ab2ccf4601e272bd1340e99ea9ed62eeedc719733b3077aecc88a1a77635003e81c1192d817f52afe089fd96df5f61f2c0f4bcd6490acbb9ee362247b8553860b5192d32b9592343c52f51897b45e3184c2986c2281572bc18a50463a2047c234fe0e7182c4f80600dd2c282209d207027be10db7e706e71f17e9c2ea51fec610fe718a5bca17387fed873dd0ecd822921d280487ffce790df1cf8e538c3d2864ca7532db8208f4bddd4a0fa9fd8b38b87c921d762cbb10b490af8262ecc0eb162b9d4218721a71c19618ec7e0392b9cc9ee104ed99474ae02a21b9af976b7b126696d075bc0c253106ad98fb7112844a6f5c91d2dc74cbb81d0225b2ca6baccdb8a21d08b3c500449aff7cf3bc704827acf1ed25ab076a0756d4f435b96c7b3f78793c311739242dff63a0ea974782d6135d49222f2d66f3a801a9f87eddbbef3d4f8bb9d14697587ef19a190562f768ee29b79563f4a7c3b9f906cf54cd1badba02d2ed7fbd5748988759103732fb186d2d1f2107ee1e8a706dc5e82149d7ed370d425a67c3f61686c652616e5eb6d782798ffff47b0a697a02a767655534c1bc1ecb71534b1798dda5c59adcf3a606a08c470d630c48c04ac34f6fca0baee01628d8b52d35257db44e995f3902ed32a84115168399107f2e4ce29733e5e9885f890cf53bab977906c42053d92b91831f42ac0f9562495c29dabe1162d57b2afc61d53cc893522818ac13cb266406b6659c2b8256401656e6cf45e43faa3b08a05dfd0307e6abd2365db2c7b13cce1b62c296d1b839899fcb4ddd31d17929822870756b93efd48f65ce56c0456ed0d376d7ac275282beacdba789253affafc7c162cb205178b92814a447c0a58563eb212e2c57693c25a42d820dbd5bd9df82c38e2e0cfb37823dbb5eb9924a848c83f5e87d53b324855499615300e8bdfc06beeb90bb2357e729f1f5c9c1ed405708ef046d602192ed4c3314b2e882ca19a175bf3a2cf2fb579ca16a4a008147684d7d10cc978abc1a15df0999d00950b92c34fec9340a25bf95e3b82f74b046c20be1ee9cea051055961e997e5c2e314141177a745c328aba7fafd05149b4430135836eca3cf076cbed9c34c3f7a93b6a8e8231266b24368a8b85c694bf7a30a046b74e25955f3615d404585759d215c38ced97abc0eec14251fd0f3541a6124ebe4b0309aad20459f750910cf1fbaaa49b7ab023a7244815e1ae4f5a299123548226d512bf52995aaf7112bc5470142587bad7258cad0ffbd9e5cd720dddfb467a61cac7cdbf0ba8be4be4d5690cc6bf9c2cc7ba65e8ba0ac2bda65aeb969502aa4a1c78e079b1cab3dcac5fad3618953660b40eb0d3487153decebee55dd0fe8f3da986268e7f980ef85395d02b277eae1a079b0ffe9df8b7a3dc7fa208125193c597c5cffb5f6337d58374fc5fe08c0c11bc6d7d114acff3898afe8a8eb47c8855983dbf2c57e0742f3e909cca9221ca770001bea85283cae48429e1466ca9669a4823e5b2842c89a462f6bad5c9b257e8ba1d1adb45382c5ac695d92683f06fe1838ee8da71a35741d3e208e664abccac8f311e8eaae2702f75199eb32efa0ba3d986638fa160096ff52c6aa2eccb10994de7ca31d1b41e75e765d546f0d29ca1596c66e0a59117b2fffa8965517c79dcc1dca80245f37960f606b468de54d8c53a481070ec5a136a228e38daae7fade7a9901044410a0622afd92bd0f75e4186316e3848d975077b9cd2f9445cdd53f8b12d9e9b84a1253f28e335bb5e6b7ca142fc70ebfb9d1a0160d6b740c7f920cb6156ace9a7ddb1eda66d2526151335eb012482b2559b3dca10980349a6a79919a7f0a27b29ac634589715ec9960c9368a5d1e5ad6a54b502b99f81a72483e6db177ab9e6a388a6350b3c9d4dc1a9568f6ab37f0ca9fdff3cebcd75ed1a9d65ac211bb086247334fbbe72d1f2a1ec892446ff72e425f1bf535a9e352d6237dba279d24f2c4cfcc15f18a38073955ad568e208d5c2fbf44f6991d6bebc2314ef3114de5d33c5825c412fe9b8e1ecfdf5e6895522a11fd82c8520579b6699f756cacb3ad361d18f726f57607606f009de77c45a37eac0a5ef501ad875632f44b65696370613cee04283529bc539ff8ab8dc71609c730c682f997548c6b0f878fa5c3a915d4a414fa995b038582c18ac14cbc38eab69a0cd06cc3829fd1955736bea523608fa040ca5f25a1c3b078bd821a093775a22e45f03aa4e3f578d18e9653a78ee96968390f999a04d4d8dfa929f14585c3c59118acbac5731584424fb8b054105c18503ba616bd91acd517c11902cca023e9b339c2745b1441bf5902189d035786038ef7468d2102e1803ee2d0823380214cdb80aefe2d9542231a63182d1a4d1e8cb9aa95c7dfbec0e45fd99e01260ccc7f6a8797f842dc1b1c4fd00adf9c01213731d793ed1ef15cead98ef8ad8600a4b6c22c0b4a6ed630fc3fa6edab6ff1cdb93da7fdb01482529b0927e00dfd849da00a5f0a3af79ca756dc81bf38b55dd992a5c4b195fbad7879170eb6583ed6e6da9567f48b6c29165e094ac78c9314885ca81dce5e83d20ad5abe1748a85a8d77797f425d0c212ecb2d9c4340080c304ee4ec611bc1b4c746c2028b213cfda833a8ab031bbdc86f1573794918cdba8b9b12446de3ab41f432c06b0473964832934b056df907d4d0886174e93207012ba0510a2a720fbc123df3d7973994a2d37d17bbde65a9052c32ea4a9eeca6376f6892efaccb15f2d2f3147e6323012227e06df99c3290224fffdbefddfc0419b35c43f3ff605622c3f1f637d705c6f85735332539ddf944f08899e9f10db362360f1fd81887d9ff1b19883e160d33e8c43303543637dc2ef471838e675033d6422e75718011fad2d2aa95b88ede49e63515e01b4a67dfdfc10a7bdea9fc44c367b32b5bf1373c93f7408590214f8917fafdac853e0ac06caf29c02ddf46e3e9fe6dd42cbdba99f3443b32c03844d7317c46b3736ff1790c121d27f58d02e031464a79d14cb8fa87a0f36cac25e161ae0c86a579ba9dddc25c9f22a894988eb3f082a4db6364d4124b163c427433707bd65f8749a2fe9e48dbb95ec522ee1532647ef4c3d3914245934d1956b65e62c480e138ea381c008cc36ebe541931164619c0423ad3f1b006b7180a670f8ec42a1c5d23adb34f94e8923b6cbdab6e9bc461c1d4e760aa02c9a58ee57060bdd61e69e418db70caaf5d627c8c28b279b0616573d1156edd31aa896783d6b9d8476c399596f6212b2118d9c4252fe9582c1d7eabfa64b63eda4f02831d2c26877654ba5bff1f7221ac21e1978691d5f0ad133cbae796a41c4cfcee54742b8c32b3b3ebf665920ff9c5064256242f9b3123960dfcd6b8b565b05e6fa4c242869cd191ecea62ea130c4022cc75d73722e90214529268a1116da3c388f7a8444f2e38fdf232d6d937a6f927ff639e46822a590bc08334165ed541fe4df286b04e692b3dab68fccca13f343cf2b7194d964600e40c7e01bd482923517bb537f3dca989c551a8677e92a8dffe401a379e020e8cfc5a50f208cb28d2277a3f0b757346c8c5949910935816cff07c5907aa121737b5ec576ba6eb598ca38df1bf9f9ce58e7bba9a326f1f79c371601885cbf5f869ef7ab61de86aab68cb84ac34d8b00719f0b9d79202e34709ccd22c865f825a4592229932b87c68c24e499a99b9be071737a506e80644bda5c286e0eb35d7619a4a482c4f07da3b2775941a499b0b3f5fbd3a203fa0d071d210b358c4f40f33f26ab5ab24db6090e90ce194403aeaecd0c710dd65795a035a4ffd32be81f52b095c2eab2cc1c50ace483e6767ff07df49f26d32563d8694edff2c0dbe650cc0e0d8a78f71854d8b0dc1758155cfdce898d62e813727465086f016468572999e70c8f7599d3a1354c71f3e8daf43b02ade7568ebf03cb076ca99107f81f04cd8748062fa4fe710ad3539493982f23e810a3cd7cb9e0fafb22b939132219f65f8402a77a4dcdf086e2f299026bd5731088b97434779c3a91f063cc9067807b9929ba5c956722dc00482329780a6bc4934025743e02e0ac2b844c3acf44352203a5947804369db5ca4da286d75d68d6f2422be879c3877257725ca3a84f81a73e5a81878164c130a1b53ab3e07a3aa990fa30144de232cb800f910443088a9cf5087ec0425b0832b30765179ff971f412c48acc27764aa2970c71ea67c2ac841c0264e80213a495c07cd7b548cff5f87453f314772d0b64523a4ac346e9a7638a9778531cbd0ecb60ebf7c801ca4a42628954b6bbfb9fe749bf421efef45f71b970627fd0832f00159414c0fa210346f2d3845a5bc917325360827db8e375bae6c56f410c79ab3a7fd70f1a0fba61c1a621bd058c16c7118420a037f5ba8d7260f0c897b19b656565d633d350859f5648c8160c63f2ff1b56819d5bc90febcf4eda5c0e7a2ef10149d7a5baa45afa7f7d423f54220f4342625a48a5878718f04888ba5c4826dbdcd4555e8075537bc473dff94aefec723d89d81838f646611219e01df5ea5515f5530b358e16783424811bcca5e5316dfb61a8f67d84106c745b0b170bbb7d42d0197e39d1a6d12114ef37488a0715d063e84e98fad7e342e2d5b3b0843cc1f456b10a9a2644297791076801cad64081674c08925bb49b324eabfe08f75c12f46308e710d3219f6941204b87322f0d3164ed50d01c8238460597a83a713ddfa14a8bb5daa0e983775317d21c24c17cc8da373c96620ff27c31f57978213bc7edaf03112cfb1fb3997129eb31d5708c2a6b605a7d4b109540c96803eb938dba7cea21c5edb5ca7255aa480ff3ae4d1d188366b91b984cde973022509fd9d301368dadd383439e5dc7eea2bb0e9cbb660c7bfc0224403fff18a8daaba7fed38c06919eea938ed5adc281643325d1de87365f00aff9d50c68036a020b8313f0a67a971cbb6350e14f0a8c06aef9954c8efb6b4be2fb4a13d688109098852e02fc55bbcc01baf052648cae44a93cca4fca29168dfea1d06b9c9344b8a374f7c1058344a47001c9ffc08ed3d0156652d9f2882615ae76d8d1377224a84dfb298c83f2cfb6c3cef1f849519c9ecf5e7e52e62ce9c66f85a9400c63fbd02b3d37e13f2c89809e12741be003afc88f995ba60b5477650f63df60bd30ad03921bb65b4c84582d912426a153b537c7d824cec8e1dfbb33b2cf30ccb31ffd013232d3d53c691cc262cc171a3ae9da97cf5fe677433728acdc3294ea79dd250cea4d9aaf2bd51a0010b586dce393017e292cc0459a835fc652d7cd66abb0500d95e3f04eb309f3ca90dfec8c1119c691fff1a04a384ddcfceb74e3162940920b76e64c80cf4ce4a5b3cd449c839b19c2e0068dd8c46fc506e9a905a4a16c3d21665a0916014aca5468390f8ebcbb375601afe0544b194eb97283aaa499733fed3944241086a1d82001691b75fc051a011e1c98651318b48b8d109d821cef3663627986bc49ddb55b93d60fd720a8759f315ef947b541981c32c403ad430e5b9cc87be358fe514d4d9b6ed211c77e72c71c136412728fb037faddf07e84a03a91bb28feb3c44a96604d781e3b8d100b51b651e029d19fb6b5261307ebcf27bdadeeee7c8fc6658785cc1323aa2a7f5d12d639ad71e91332f80ceb3111d8e701a815ef294ce7e2d247052c99e9b64413e61c87e1b7e96198f8a6244b94b124e7b2228ef653dc35b48e15a148664a360d21278907392cec5b37ab60d703ccc71f2016f33eaab3fac531ff92d840230d2a038b5e15c3e482c42b2465ee1e0542fa0dda7d5f5241cf8536fe98c4de80910eaa0bffae1397a1967e7b00f2afcddcea6023357028ec884ed5e5dc38da4d704f6259f3058d4bc2614739cc6230c9f1467c35c8bb4b6421680020c365f619a407f45cc5bc0197069e6991aac28e3f1589bb59fc99ca1b5aca2284b08e441eb576f2b708b64d414b2223e46f6fb55225005395bb1c8ef94079a7df2d26437051e149f6544bd10a66585604ef294c9bf9a783b17117ffc3a05ddd7073b629bda6a582270f3ed12e3ca40a9a83cd1d8148aef840e8fde04a4f2942b5900b7c79dd941f72be5dddea884c8421293cf08e6527400099672e1288e1ab957df1ba3090fe9aebeda5b48ef6bac2a39fbca30b5baa3691d4ec7661bcd2bdf5ec4f2d7cc3018e9e7da8f9571aa2501f9d3d5678091ae413e81bc9368f1193fa95ee437cd27447d944094cbd034a04639f5a304cca9a0e7589ed157bf66477b1ff7608fca9fdfbff9b9b3b641b094267b4eaa879bbbe76e5fe3b015a3336b8f3383f78bf2ab4a968fc14f467b68e18009de8475ceb0a13775033867d5ac9e00a1c4d5a6f5ad2f69652ca9452b009ff09ad095eb8a6db7857f58d46d363fa463fc134fa3b11e9f6771a6f2818488a1dd0eba24361a01fecb7e7fa36c95879d371110431afe5b190ebf9bf96d76a7d656fd916b7ba6a3df72a22e7f8661fc8cb2f2f8bcc402dca7903099ea45a6bad319c9925d11b7ab228d140b9602559a94af294a5861dda3ca1823d7102aa82c902ca87294fbaf8e1066773434f1625fa54cd98ca2689c6d0a40b13830c459e89145190512203021688f0c2e48a270f6aa9dadac31319ea931b5ab0b8169a685f3248d3b2da7452da462ebdd1dff1a79452002061e5652d38a4db6f474f0bee86647a59b8e61d679836600c2ef3f08e993bd2f87570154d0a799e770156f23cb6e23a6b711d851f5b85978b599ed8595428782a5c7724fe3c65b26432b71b8070250ed368f7cc73698f10e4ada265209c0cc442f66c09f6e59d1439ce10eded5aed97ec58a3e1c4d2c8c1810e1a3b3d3e1198d4c795cf0a885151974f5e3c88b9590766f6251ffbb0eddd521c6ebf7d7d1222190c84c4ca6019d3ca72c752daa42802f57dfdaa61336d4e2a72370b4f3e661bdddf5a2b8714b8f2fb8bb96c96534a798f6af795efa4cd6d9fbf688773fab794d2369b062510490c2d24619e2419a1460b12aa27ac16992254f8d61a37355902b01801451528a84070c50a2c2c9cd43047c0b086504a29e5374f6e562062840e55508e65864ea1c2e3bc10224bee8e5fab51fc54a5544b96268cf820c92029cb113b6a94c8c2e58ef6a7c097f7dff368fdabf55feb83c8f79ee9eb61cfe3fb9818c4f5dfc3c4204e41c07f3ddb2ae879dffa59f74734f9336bb63694a306866c035fa2c758d36511efc8fb22f0bda7542c7a7deb0556af138b5a2f4523ffd61bc9f73e5777420326282dedc1d7acfb23db8e5927ee402261040d9ad896e779b226c2082f9cec2281af50be8b6afa2443fbce18305f7ed17c5934df138d48903ff4a7c8f2a74a833276bef4dc9334917a35d83673cfeb231b0f31484bb4df75eb7974deb7bee547363adf45084708e97be883e52a11e80a5fff0f03cd9e6be5fb17c97759c522f99e68f47246e5f3f0ef5c9cd978487146c51dadf73a845d96423590d65961e54f4a933ff3bdb09b73d22ecda17817ec8c490342ad9cc639a409dd751fb61ec4c2c73ef20776598706652cdb8c9c8a5c2edfe57bdf2c72bd271a59978b46523462514eeb123d7fb67963ed4efaae679b0ce57bcfc3df25067105b1cd04ccdf0104a9087786ad188bdf54d11c1c047105f9bec500efe543c0e554e412adfce9209ea844993eaf7eeb8beab7bebfd5bd271a79dfbd518bbd8732eb56e87d51cbf3de251abd510ed9f6a1d8514693b2497fd2bcccd77dcff53e88fff7dcef7a1ec2513fc793f0c3856c5071509f6bad5855378765cd1df9ea7aaba3b48a85ead67fa13bb251f9f38be4cff9522c7a19c97f8947362a8e3fe6a5dffd9ce6b4a6893e4eab5fff93e0d0044ad8d1e7d66ffde873d9fffb22ff4ff4c4a27e17787dfa369da2e0512ace18505f3e8fee5d0ce2dfbd14833815f9771f447efdbc56fdee6794b65cf5bb96ab25a97cb16e6fc640954f9fc7fc2a0611833815d59fe2cc16a47b29ce5adcf179dd34f9131e712ff4c1f6f31d6934ff0efdc9c73e9efc99fd4736125adc815482064e6cce69b2d6dc8124dfd6ddb5c4bec964322677cf75e00456260c8ac359ece6f67f356883fb61b1e0e5af6003d806eb6b89c81f0f2ad8facfbb76d878745be0c7be88be053bf96c03c3991465b656947d2c55ee68afec6ab70377c04422f5c1270212fd9275fd170bd9666d38d47d0d3656e7777e26ffa8fb991477207993fce9de99e48fd2d0ed5e03275609e7bb9cefbe8ff8d304dfb1ad7b9a31a03ef822d087e9fc4e0c49e902490a7db0f2f90279cd5eafef81746fd47ddf3ca8bbdd779307517121184fdd3752f7d475dd94dbf591dbfdeb7beadea978902b7dafee9d18a8fb9d1088fce95ea7fb5619eb504eebfe25fa93d3baeec5275676bf430ae588b3ef63247890fcee7548211c71f6893c40fab00f521f7c1eb08f7d4c0c421ff66ceb5e042964bfebbc8060c915c0652f3454dd0e08fbbdcf3748f4896f47be828560d81a796ebf7c2f949d2bcd1725564daa246c7e58ec8e9c5f65ea459b78cdc91d193765b2891d6560083e4ef31acfe52e3f20dd1935d9c48e3469e5abff4db6e1dd4343b50e5e5696071848135684115a6ca39fc19dfb00fea93fd20ec0dba2080c543f47093b7653d61bb621654c6c0b5944807471eb7718b6c1ced46a6e8de25632b70e89b9d5b3b2da4d4b4c52a889d6818586ba69484b3714c4d8ba4ddf3def251ab9bef546df473ba1c8f5df090d609b953ff54d6800dbbc6f00dbe67fa291914cfed43fb2c91f69b24619cbb6d6b36dfee8cdfc8f6cdd14ce5cdc81d438f953bfa15a8326d6f5f903a9ef79d666ddfa1a38b1557efd7e924250d599a450ebeb7b9314aa9f58df25d67770075238df15ca5752656a75538c27ab81be5e3ff4c176cf77eca66eaadfb5833b54af56ef755d68821df7a1b973d87ec3c73edf87c5c23e2c96079c31e08b604871662b3afa22850f30d8ba975fd4bd148bea7bfd23db2d72d96ab0b1ddd7df81d489550d0e25d95116fa60e9f31d87d8fc00a5852cacb842c35ebab9964fbe9295d16e4bffef0322979ce6f5482e8d4777be6d59f3ac1c7b35b28698a24b1a234b7a58c346bc61b2a68d99124c29520596272d1e2693c89552ca1987bbc1063254a4c8a0851a2c2c34998207a90c0e862c5ba496f0ab2b5c58f71cde04eba362ce39e79c73ce2b5cb430320409a41470b0cd3477ce39e79c5fceda862e1560acc8a003939929407089818a2b4c7460340095a58817485071e5031a299d264652b850a384eba1c817567ee5ca085a4c388922aa34fd80431a2f8e988200586438024a0b16397421c50f3e504a29a594524aa1585862045a72534c0461a3515c4a29a594524a7718c87fecb9fe3d6c835d72210127a2f0d084e588ac2dce5c5121a74991264fcc60254a114c707028de804e1c0cab01a3d3c4b160198105154cbcc062c604ac2d9e3c59a214849b27babc98f8110f63de2031c40b356099f29c95282a5ff28d99c27577e22c2bd084952d597c81c4cb5499194baec0f04407295c38391182167bd381e86047cb36baeb36b7c99e76dda54c227b5a7727ca3a83da878f4c27c1cc2cce21b3bae7dfb1879ed37cd049a778c2bc3e68d72d95c99852ea31f3147fd0eb2fbd88adcf5eadf2877af2a7abacb2ca8e79dacbf3798a9465e8e38e3b578eb992622945963ffd1e333f03b5ccaeb1fce3ebdaf80a37bc44ffb8c1652019069779f8877f8a2f83feb43b0ce442dc7d0acbfc1ecdc65a5ecbcbf2644e29a7b5ded7f758a8eb2c9e353c6be49c9d0b3feae59fdf2985dd009e73ce89355a2cdb3fca50b2fd9ed378ced7654aeb0b92a964fa94a7052b2995799776b13801dff33bdf231a39ed8845e1fb88463d1fbe518c17ffc866413863c0051fe3828f312bb2e07bde82ef7919e18cbecf1fd93efc97f145ff329ebe0c19ef231acde81fd964bcd18c8a2714f93c06df00b621c5780c4423230c1e03d1473cb27dcfb3ade747598fc8b618e205e1d10c7370feebd705e1914d0cd916866cfb906d3242b659101ed9186cbd53fda8b7257ad50a9647f430a33f4979d0d4070b9de67f3aaf0e5d5716b2edeb20e779fe6370e771be43fb3ce128de1d91e773489c30271c7d884e8b85f07d7ff0bd8f219e7fe1c8253b8ff339e17874731e0724caa1f43de0707c9e709c97e777c2b1efced3b0861536d49138bf131e5d1d71004d03e76738d6b8389f43e684e0e384ae8785e38c1b7b1b8eaf1b13619f43c2c2fa603895427f721a94d3e4c34022973897785fbdf9e5ca3975a5c089ebc18e8ee39c8e30899daf249bf9a79b6f87732e71c7c578f92ee5423df4e53b94074d318718e29c923f522a9c54f207e7342a6a74772d58bee3c44d9c377138a93495a6d2954e257f80b03f451c8e891b1af2260a12e5e0c08d4dc0e4dcac6f119594586105218c501652104e80bb630dcb1ee9788c283cb4765ecbf5bd4058cce2f4effc8e38e67c8bb30f76bebfc551e777de493af9f3849e6f30e7efe88438a1b58285af304aabdfebafcd3e13c76791efabeeeeeef4ba4f2969f2a7264a29a54bd9b49aacd297a27bd3d04567f70ef61da197ced9ad3a67ab9bd22a25129a90e70c0116e28030420abcbe0cdc7e497fb69c68269a2128173e5f57cb342af2ec98465ff67c815becff4cc1f6bc4c26853eb0e67ac19e6d36146301b874000bb832a7c509dcaf7330609b81a890d9c47b4911dc623f5a69cdf39a44cb3a5969ad34031fecce652d50b840ebc1e6bc01c01bdb61411bc27a6aac99322e18f9e23f1c8687913101a83273c41d2d2dcb0cee8e5ffbe1e3037c9cc3ce7f2a9b0a4ead31235bccdcb6dd563a2a4f539a62f676bbfda84f4d5198a0c0708e48dd8003e788940d51a02cb5129813c58b121f43bdd44a9dd4482f9daa23a0a8d1498dd437201f8f14313bd478a48891d2b7ac36fc3e5c14d8d086871914d8d026046daeac466859e5c614793e63a8f8757850ed3c2a291cd5c74b121c6ef776766f3b291c5dcd832a0d8018294bf89005408c143143b5193e9300307c9962070402c0f0458a199271b47bdbc94f4eca62a488d9e1766f67f7b6eb6a53ef19a45e776f6d37e7f5f0a86b9da68f7db22e8da56d9b27853c2b73a197e7341b7f87b2bbbbbbbb650f0ab6866c9320d10efa9ff77ab9d0ab461bdb59f7b9b13c293d2576ac5df953865eada291101b156fd5c9f45c36bda1e9796fbd9a1372a6dbed96c456eb53857aa2893b565c95fa1feb541d13e5e54d1e99e18e526949ce8f7249e74719e5098a0cd51d254e4aedfc28a7787e9461aebfcc492ba43b4a2cd966821f6516053f4e24a52527aedc7132cd28b21f67138c1f2795eb3f71e39c7222eb8e936a86a9e0c75935fb719eb9fe136b66e59ac0b92345ba1ee329136d9272474aa95cff9142dd1fa9d4f5a754b4eaca1d698e9eb9fea61e79a2883b56a5bae4ba6749284d5f64957c73640a8f73ccb4a24bd40aa557d76d236d731dcc94ebd31d0c133ef5a58601c3d379bcc40d2b9705d21554a67021e608054d535c3db504973b36d51d3bccf5aeea31d7cf4061024a0c848dbe347a13099cd8b9a353b9ee6ee5ba4b5d7f1e9dcaddcb1d3de767ae3f7390bdff3240a2ef8f80673968e4d1555421c2e72ff831079f0b442136a71e3ec4fff7219d942871bbe27ff8168044e1874cc59521e3638044322cf81e90c882d78db17363fc8cf19e991be36d0eeac628c3c28df133902886ec08a5dbf31580443db323eeec618044b30a5e06125500c3092617c6530012c190c97e029048e67329c85d0a9e0724a26082097e07249ac0f29009c1e5791d908867c7b6f33920d18ecef398aaabf33820918e276fce5b9028872685867098c04102078704575c1c0c2e0ece5b2717a704555c9c31572ecec740229c21da0fe530c25a31d61ac0e2b8638d6b9f77b8b600d7dab74c9cb9f66555415cfb9fe4daa73581c4b55f23810dd73e0c24b243ae1b7b10248ac196007361ff02896042e07f2011f8aabae3ce7d8577ecb92fa0fb7abdfd725f4b44b92f3134dcd7bb40a2d77fef72595d97eb3d90c8555b60baadef40a2d6f5c254b99e19cf76168009e256f96092eebcb9dba25b90c30fd5a65ad65e4d8937b6bead696ee5b9b5d65a2bce6b47833bf630a18416258a48820a1f3276f4e6eb460d246a88a105092c544b77fed3a8c0dcf9b5249ceefc184834876aad3a2e14e941892a374954f02d7aa0c0823164a6ee38e34b0e253022052398b418f1e68826ee7c1848346bad74bbdd54a0c2050c324dbc6a2c819bcabaf3655ec4dcf94f4408ee7c5a8d0821eefca122a898829a536d9ca25089c2218b93275c8b2c3cd82f83a924b7be8bca13b0560008d0c5aa4b955bdf135d40a2c9480d527ed022eb4a198f893beef4383144d4ad5f65530529983441040b524800e5a6cb08902845820b9b5b7f7a7fc4a44d15140d48a84052c536b3e8d283102f0baeb0a34cc6369ccb9958106768b398d99c71a700ee9c5235dc2995c59d5c906cc982021d3c18920b5f0a3930890bae214a2fa6262da4a7ef07275e0a2e235ee850a86a458d515289e0bca8354be810ac6ecb902693470a750b0c2f48f6a6c7a30813e52d4d30f01882dba225061e448e6c19f38407529519a8cfc1a2659dd75a31e8d245959f2bb82ea6a46c8ccbb82e8ec840073bbb8ceb220d00907851e40d086a489aea1839cfb16f31096e7b9e4be9628fcbbcad3c07d5583efd503220acec89359a459250e188cd68e785b89b9bcd29f66ddb098500e0c8cde624e5b374cfe8c8858923900b7b0fc7791ba55190204284e0ae7f8e7b61a10907f8e28bac5166dd9ccff910bc98788209fdc585b12d278cbd5b715ae3a0947a1022013cc536e86d98d75f6e5aa8609edc51d4223814b19c7f82ddd35cd88fbe060ad49b9cd0b1c00e625c173dc74057566718c8a75873fb5d7a3206732c35b718cc83c2cd46b080d3ac744bddfe5c4bf9f270d655fe04d368878281fa5b0ffb58ce83d03f9c56c28f9d43a32302c9f27ba38f348d2bb6e1a9e11bb06ffeeee839b631bbfd7e866dc8b7dfef51f08dd8f7fb146c23e763b19b63a517f6d591b173476e57e574ce2879100bf510b7bebaa2e2b97ed3d2c9f11c15da9de1343f83c51dfdeaf663d52072793be8cb9de3a07339e618dbb9b66a346c038b6db4d886ebfb3b8b6d7cdfdf6fd8c6ebfbfde6485af08d9ed234fa463f358dcef9b1dddcfec6826fe4bcce8fdd05dfd0f96ef2254953b8b86cd886f7bf5ad7437965d867ae988172574daca3601a7cf93be92a754e071ba3ba7df908a5db37a96f3495297da3ab9a46f78d1ed3b2a6536e3ff912032931902f5172fb1d89c770fb1d06a6d1af139e00fb1c49a56f3813a6d1ef4e6e3f0e95db6fc39ea2a3601afdb0b0d5308d7e306c2ca75d856dc540cd40fdadb0730cd41f463dd891b360583916a8aec8dd907076ec1bece948d2153bf6111eaa27dc0eadd44b5cb0632bc16e4f550cc19406ca12942476ec250a8ce45098d24c1de5891d9bc93e15914295a62939d8b19b5e4c8ec3228527a6272a4eecd84fb72e5c18e9e2e607282b33d8b1a126c09acaa2089b348d6ba99c1c1555509921d253fd85891d7baa02aa21724cc034558769c18e4da581522e4d19aa9c9baa3141d8b1ab5e4f5db6c0ea92c552e7fa8c153b76ce454595a686a099424a6275f5821ddbeaaabb4db539c3e436e50688a936423456b779b26363d1dc1553b92bca7456bf01811d3b6b3e2d2d21c40dc9c98e7ecb80ea48921f89620a8c4b1451a2b8442186cb992ca52558ece84a4f309eb8c0d0c40506325c9450e1b2e4c51214253bfa12ceed892c24a6284aece84c2da521d24861d5e44e831d5d09b7c50d6bb29ea8f8d304538986a7efc6a40a282b382911d8d1713bb928235f0c29e253fe658a1d7d6a4c054a5262c24889b9024b4a892b29313938958711c28e4e0584a3f2059557f918afaa54b919d8e0925879cecf006147cf71172afa06046ee5576e055261ad5003c814b502ceb1bc0d0f7674ac3617e4864073c5d4c2a73484153c0c8126cab3fc4d0d76f4ac2532aa2e5a246175e982885c973650ba643d7143a2624779a34f4833507961c591a4263bca233838a9b42489ebb66407a5255176944a4762514837798b2262064b0b17555143965882e2831de5d21230b70549d29314a62d48ae6c51ca3145b9c18e92a975cb59110595155c344d81623f6ff965eaf64b2a0f9ae0f6cb2c59180f629c1a9c3c63e5a3c4926fa6740975fb5b090aa766c9f5ef97563c68e6a27c725a3fcf95f2692a197971b5aa8c81fc9bb3f5c29b5b94239ae4a465a85879b57a6d6a509222a5345de1aca865802f4a3cd95ae2914d4a59ef63205bc50ebe1448d0643372bd908ea266cae624ffc8f6b54257c82091d7d55951eb67452d57382b3ab2e590267487d41582ecb68701d9ed6f2155b7fb1a8edd74ab27a56ced2ef4414122da6275797786de6dc9cec12e1fb3003e9642d236a5b777f05506f244727a908b3d7ec82bc48fdc35f0f5f821af8b33297ee0cf01797bf077df78a2f365f28786423a2b21b52648a86c4eb3fea3dbe2cc028d1442e34d53968d7d838f4e1ab29a2b2c4b36dad5f7c49b90fad5c8a9fbfa4642e8cfefaa2864be73d9a0ff6397019070b619b2ed897ddedddd3d0f62a64dc76eda83d28e763de83b9deeeed5ddeb8feeeeb5dbdddd6b37adb46b57698fdad5aed2b047f557ed78ba5e7ab35dca1e3de99c41d26ff4ed1eece8dde9cd3b6ba55cc1c06030180c06832989599c9c17ceeb735e39e0386f4c84812f58ef4cd17df7bb9444b97f9dda703d832074627f77fb9c507ff495df0ce57fde4f7faff6140c21f43c1cf57eca64d68e5eec5d9c9e373de8aff733304862bbefd75b80840bb08dee2995219359ae79907d9ca73fe441f43f1bbe9c063e4e689d063e831f607071c4e934f073b8f5faee2c4fe81b0b4fe80b0bc7d605c597d3acd36efdc4f979a2e7c9efeebb47cb1934a5777b3f767777777beeb3d66e6f47a1e594b8fbf1abc3d677e151ec82633803c17bdcd6bbf75edf0aa86cdf762f1cbd1edefb4f30047f31508ebed19752cfeb72f878c4583b4b782fb95852e537db70792f5d9fc33de48077fd7d4e087ff4edff5e14a42cf4f2a752faccccf45be2d8ba14e7524f1c615cda458a2fb782cb5da4e0e17eee7d47df7bf672ec6875debf14caf90a03ff25be2803ebf7f55ba0582ba0a28e1d2dd11347d98591b3d369948ab30edcbfe6bece6377fed49f320dc77eefe70c9a72fa8d13fab2e7795ef764af2b90c1f673b7cbe512e56d47a1a707fb150463f9c71d7da36f6dbd8be3bc1ce8eb89b30fe4175fb03b56cb6d12174873ce39e79c5ab6d8c2ca953f63c8c7837a9aaefcd7e8197dec3352a52b9fbfbf7850470025b6fb640d17727d5f1084f92ed1fb1ed6a0025ce2d823a3ff8130c348f90a7388bd2bf6333441c8ed76f6d2fa1efc75fd9c52a34b9cb99e8a2f97e89910bbde832fa9c658c936b7a4a5284f56a6c2e4ae661645f22047727ac9a90a8220deefbdbe1fb712ff97962ddadcd77f200852ca693ba29c0af9b6402b85fdc04ff080afeb3d68bf2d90081499698cdffbbf9e411082dcefa7260882df4f94524ee340dfeebdb0ef1667ae7f072a20769981bc10e4944c8281644b34a1e594d32437a5b0f9359461c620774e5152814ad851e2a86efb3355f29c2633b3bff4319fd2e94d3e376faeebe75f5da0cb5adc58b99fbf725caed073c8913c612e51feb844ef1369e174212427ef918abceb8bd06c4eafa7dff77db1b0ef9c733a61c71ebedf2be4eb66ca35c0652d592c5ddc652f97b56425dd9d1e0f8dedfe73c2ca6f70becbe572b93e27ece77a97cbe5daf120970873c55c2e97cbe582c580b03d4ef3d6cb157af7f57a851cf0ae0b043f19c85fac000c247362b1e9e5844e385370fea3af1fb621f6e070c99eb0d8b740d87f1ee8c1843d831dc4fe85a3033bf060de97f862a059072fa7bdc41eb18379633171c86931256ceb7b7a767660b158ec5fb1900023b0b1afd669fd31716708471c3d02046169072fd08a218c7d77c2eef6dc0edc715ae3709a1c62200240d94f1c77ae164f974b70594b9698fbb95e5ec89f1376945d097ecb55410d33f687bc2e79bf594c3c0184f9c1f7531c5dff89de77f70b47ef8b8923901b73b99e9dc6379675edc73e87bb4ce8ae15c7be31317489a06520091359bccc409d43ce5bb6f1bd74fd50d390eff964ff999f681968fe50dfc0611af3a5ce7d39cd479f11e7ce2b5f3db7e70fdba8f7831f06ea8fb90e13669ecccccc93999927f374f38db5878164723e9db3328737586571e48e3b35c6da8ed3e7015f134c9897190887813c7e859681b2eed853c1072c6bc1c2ea71d846d8d7f320b681e463af49e1103dae1d43b519bad25fe08338682fb3d5602199ac7910ecfbb99b89ed86751048170693fd912de719023c3fc11751f032d1c8a973c471e882df6211cf4f70646b71ac5d1004c57e863a73c10745761a4ccce1b19c3f22b23018ec3de070fc11c679753e271cfbe63c2c0473421c9d30f63938e2009a46ecc170ac71639f43dae9b41a56d8873d188e5c55e3824d60e875e883abaeace5b1abbe17569f41b33b12c7bd2b7dc4e290695d66c22acc6526aca42e1017bccc84150cb73bf0b1cf38b9fb56add5937df7934da92696bdebce0f5609c3ef41f6c5b2d0c3f88ffc0e3f9c170e48543f4cad46cee34c1c1c1c9c9fa109325e5447fe13159ec1a23f99d00e25f54bec3895c239c36e9eb7d3dab73c9fc33bb43f799e41229ecfe155f729c0c1365cc8a9e48f95424426f87f22305e06052f3e910a3e94fd054f64f616e4b8209cd1bfe0637c18ce76c470b623ce18207ecf1789013a5970d04982c5883539580069795d03a1b33618207ce5e5ba216e799db367bd4e66ab4e0224104d53c63ccd97d5837c24b7bc4ec7649a2c6786b1afee641b55555521034d1a65ecdc9de241f25fb46f592daf6ba6dab7acac2c20f2a78d1dffceffff7faf8a40fbaffaaaafd2d18940fbaaaffaaa87c23e791015176a1f206118ef2f9e959595e5b4fe2e060f1f5fe0052b6ca6d8e4961cf12d2ee042ae25edeb738d08a49c4fbb70a4728a3d66276957b1c7a44dbb6743f1e4e30bb880c4e6089b26595417545703de352176fb93bc7c7c811a97a358f8d242d3e5a8a42fb788cb5149b7fb3eb42f36ad6efda82bb26e157ff8dd80ec8e406eb7dbfd21bbfd6065a6cdaf5efd49c51ed7ebc6fa7356b1077d797bd4dfd9a9228e2345a46d486773d2c0bcfd7ec3dd6eee21d9d1ab4924a8e4ecd9fde524e9a0ed124bf0dff153af43fee8e4ecd84c5f241353333593753925ede7fcdc71e24d5a86d61c34b5eb81a5843cffe9762967cff939efe998f9d19ef7d211823733f1d43d5826f7a1c5c4403558a6afa1953f4dd5a3c4ec266e1eda9f81b837171b05a621bf134b903fb2c5212530501776ec269ab73463a96fcc97efd1a858fbda6b799d7b1e9691b1ba894f5337e91b93a984eeaef94f0fe508c5a6d15f4397459cb9ea2a69951ba16fd06a7fb214ea3c76b968dcf2baae25d6e48f7ccf7a9d4ca4c91f1d9c1dbba99b9a264e0998cee96a9da41c1e4c24aefc190e154046bb4193d17288d8916941e3ebe6c0b96c2c175a2707cf6b87d2491e340a09b18d66a0a6c91c363de5ec9e3b4ca64fcf0e5fdd4973da1c3a0077a131d0147f6402b8d2935db1e3506d2866c3c7e3bcfde1153bf298dbcccece8cc3c809cb357a54b02c8e3db7ad1447a32b9f8f26f3d16c1ad51ca5c29b2815982e6d1ba54c9f7ed75adbf5dc6ac960f00f7d119cd632cc62e97fb114ecd838cfb356267b991403d13fe3340f8d8dd1c48eb599fc7ae79dc9e725a2d8e2f212516471c7ce758e568a8bb1a455633e076c2376e988c325ca1888fe055d58cf72e541b866c25fd84cf887829d856d34e8f4c2e152974b1c5b864b41d90a3d90a8d5b53a113665297d0ba0b0f5ebe5a823315c7939eac8d2a5f5e7bf6a388d3e1dc01256c7e5c0698dd5420363ce29ddddc5277777779fb25f3bd7ffebe934af041edb609e724e1c9df8441bca5db5acd166481bee58c39d597ef9d8a756ab31820f1c595f86a8aafacd15bed16a9886cc72c75a96cb625fc1a8902de6d0c6835cf4b1e2683ef619fdd603a8358dda320b856dbd477f874cfe8823b05feb86be7f3d0fd7776290ee5dff1283381575ef1267fe3571e6570c54bffa19db594eab5f3f0463a5486b2c97c8a28cdb1d964315bd5a9349211db52a73d4fc26abbecadf1c634ba0973e093e74882085be2394f21f61f9c187bdeb3f4f6cbd80c81fea33f931ab99c46ab562e24bd4d1a2af1cf2879e2063a06efdeb257d5848935d38434ffecc8ac07f3d28b2fc697f7deb5f624b647feec0ed102b4b9039a4d0f7f475009142afa7fc632dacc91ffa3487d653f6a4508d7f78aa255af9c37e3b246ef669320b8ad8d90e24efbbc7b97d5da3cc2fff8de5cbcabef043990cf6fbd7fbcf9d1d2cdfef5fe26cc7f7b306b0ed13dbf6fa198fb6bdbe6d2ff1e58f8c81eac7b6589907dfb7dee8b50309c9f52fa4d67fe26cfec7b8d93462f9e3fad6cf6fb5fe138d5aa251ad32185aacf572d487affe67a590b4d51ffd368d2a59c643cfb2ca0069eb442b9fb0f4bfdb1bcd910d699e68b24203153a8c913514b1446e49c9932f5524c9a4a8335777e7725411365a2e3ffd915d0be36e0ffee9ce74ce661c53dc01986760fe5cccdc62af19a873af9479824c93eedea07706c6175632b851410635b43332e490666882f1c577b2d25aa3ae9248b232bb237380124c0188ba228204575277b4566677c4cb512c48b16f03922dc858d855065b2c5826032d1654a2089b7339aa0a2e071184a91285829cac65b437510c9171396a851ab620411249282811c3840b2637de9021b5d65a398082439aabdb11596b240d4542c026290d45e342eb7294162c53522debbcd25a690650589ccb5157b8d09454f941b2f672d4151c9eb8f2441645a4086965aa0c915a6bad33cc550d449e5a628604c1c290145ddc91712c1525451452e48cd4bce63f4e4fac60c4c2de6470439b0c6ef6438341d513187861e9e5a8dc981f2ad6bb1c950bf3349b0c5551556e789f28235f5c7a390a8ad51dbfd62447dfa33e6ad77a33dcf16b90e18e4338b424943b32d55208eec863ae3c73c44b142fa4a2aa9031442d3de9d45c5145d2940a498419e248ca1b23382c490551440b36f93aa4900796a678818d1a1e8c28d964eeda1ddae5282757dc9ccb514e7277b44f83068c90220d0f52acf04413f904eadbc242adb5562b48da90a0852e7e6823612002ea85c90313921e28a53074435c86247838628635e4b9bc4f9496a66b2f476959bae3d73a2f7ecc60f065c99f389a21c907334850b88105304b6868152d545beb981699289076d6b82e471589e2c2b81c55e48b10b59ad76ad349e9a44961e5e5a8225eee68a558bf1c55a4cb944e8660353de09c308249912f2cc8265145b87407966680c10b93149535b65a8d2a92e58e5fab8146abd59418695fab81a10245052a0c946432c40a0a2570814c0a6b9a904b34704314370481c20878b805e15794c8d8e18b2263b07893c3937f2899e48eb21741d21434ec60868724ff503cd29ccd1a2b68b24082839632b51a184fa3064a22e112e4b0830b6c567022428bff20388cfb5b28773327542a31c0a188353621ae289bd3f48cdc0808bcb06213a2010b36a749a9bf6ad83c30b9a264933571c6a37e97664c931b6c426057b6fa9d68d44e048182954d488e0bb62ad27c83fe23db375f7456548d3c230aacac10c2260414c25637e8d0680055aa18926513e2512bc860abf906fd95f61824b26461a37da553d4154bf787bc19cc78d059d39f4f43ebdede3e1b0528eedeee2e9f711fdb867090f083032a574a29a594b286d736f76e8b3ed3e50d1ffbcc781835154fb6fa4e10e89ebe37c666f48db159f913847d79b98b104977ac5d2995dc18f4c18eb22b7f2e40bb1c756b73a36e672e47ddc2005d8ebae1703f64a11ad45208bac45045893636f90d82d04d10c672d44d863bdfdd8bf8e4532674b87df2d541635df1847e138e6ef747dfe64aafb790759b1d69b1eb1f631b5dc17510013c639c2fbf7f8ade112ebfdab5d2ee64d470afd49bb8e8b47d8bcfbf63a07ec97dfb7b6ebf8e22179281a5c50b2b35866ef317e93c76fdafdee9d806ffcdc969934f5934b998b2d8c273045600545d5c58b20605ef65e50e76b4ddc213160d48724aacc87a7ab09e10b164c8fb2cb1e3d36684c08eb44ea6596a951953ab21c58eb5dbbca209d7550b433898ec3834a9a8b49082d3224b0e0e60b023e3a67094bc48c17991e28497262b2f529ae84840163bf2540c8b6a4892253b8a6cb0235329cd2b8e7c57ec204204b6d891ab3e2c2cb0a4a061040b70ce958b62418a112324f880b2235b794ab92ad250596151c28f2a7664ac1615152b50210390a114a884ccf695412c95b2810000001000a315002020100a87842291480ee4d1b87c14800b759852785295caa34912e428884106194000218400008c31c42034662400841b56c86f71fa51417e37e4a71efd4006fa43a135d3dd9925766406335d98e1f3e42b414e52679ac03f9b8fadb2dee55c91f30e1778182846c5412f0ffa798402a4f097292e3f54c25f9bf50c5a21bfbc262d9f838ccf13512bf4298100996c1df0280bc341994c870ab3476634a005339c3ac35044545f0142aaafcb7d202390cf0e4619ad6342aee4896ff35f326500502460c97e021613232e30b7204cbe25e8d5798ee4187c6478ed99443a591507d17ee3f4044db28af9c22619afd3a4239f17ec93c277f28adcd5b12617c01685ea8c298b4fa3d65432d88bc90533c25157b51de23d6e2949123f0c450d880224a9cbfed72488d92710e8b226ed4321e6827097a4e04bc62e2e0a1d64c3da301fbb474a3afd9bc9cdbfe5fe9b20f199d9f0a907e4e9c9b7781d3914c58569fa7036dea1014008d1ca956e1b0e3c39d5e9635d5bedb8c92cc67d04a3ffd72f4696a91e01014c7d70bb6622a11365cd44828e603513073a02a899d4b7a23e85e5a2bda008ca259ce31112c100d47009363ef61b191bc7c2f60784631d254fd276a92219cdcb8de3125580c78bf433350ff14ba7523a0f1c12370fb631cd1d121e115a9be519f7dd5c922f02fa60dc1de55cb7e4790180facc5afa2332de183dce8bee354b21b45c62d69236ef2117f24b4405fee26f65e12f22c25bca9ece60c8e7d7dee37f2c11ec111aec2cd05792923b459d8e705ea15603cdf780e8559bc0a233c572a11c44f6df3d4f933733e9aca49e091339e428d9152f693fdc3274887c1ed38afac03b8162d70c32bcd8c4cd123276b829764c4c55610929aa9823c6b90c8ce21238edeb5e85faea737c4667331cfe8021ce1b669c6a789678861770b2a3962896746e7d7c7e501f18f50377e6323d27fadba284e56d9c46440ddd99b80e0fb7f5790c79193e6991c8db54f059fb01842936962dba14f3a73b0b4f62b1ec615d9d9c4d6d16f8b58f5f86305e517f4a1e0f6f61257baaffdd9b5ce6c01a6f85ea0dc58fa0ea13706ffa74c43727a1352e52f47229761169b983a3e23a562d7721af8002cbb03f866f0426f1e1801f62f99bb2933ba87670e11faf1e3b5903e40da79c3c87b1f4f819f9e01842de0b853f88576255d8a9ed0af895fd66348f2a07b3a5088497b9551c71de3680ae0322c1aa22931084f63b6492df2705fa031976583f01e568ece8af6c4d79ce5f5c59859e18135340d925f33139bc3a3731fb57177ebc4469508db24e289f37635f6008889323ab619f542c1f4b14be1d67b08fba2b576748c32e764558742cc1c40d583fd07b256ce20f28c3484c020155d8c8e2adb1110e8c9e3a4df7c2b33e58a9a7e91b64ea71afa9de5c7a1477e44288d3969f0dc465e5303d132924e1a10225790e101df415554b9efb7343201ce30b3b7ce9b45930a0b5ea74e296274da48b24628f4c94f004e06a5c089d88ff510c7d32d020ce5749f9dd54b6144708df323539aca15de33859670536ada3ee520a7b26f779c21fd5ae9b08c9298dc99eaebf440c4ff7e789ae30a8d221a2818c72bc07627527953e2e6e5037b9e2df569de38a95a5297d9c4db126b4c17b7054d2185549476bc3a402612353abe2e2d53945376a5cbd34cea40eb305f028f655648a4db4fefda2b4b67bf9d85739d13963ec899175688d8a2d0c33cc15831e10040f02fd3d316878e79a528b78a0c6435da6c25ce340d11c9fbc71456e2794791c94c214d9052118ed20add31cade11088cf3a407de4bbe8102d7d28132a9bec53c4881bd99f47398332c0cd517ecf456fcc1179316f452c7e6c3249c4a0165eba2ba422eae611a5465b3e8a3faf6b35cc5c1a216b649e4bdb8afd3077940ac2635f7eb166dc10edb075d5e1735021fdffd40b51fd28ac28cd742b756b4db53133ec632cb56f5942347191cd7e6302f14fcaa6645482478598055d683c69c1a592c3f6ca1666aeba3d043e40afd031d11c79084d629c932679ad7f8e465826f199954919508baa410c204cca2a60446307875713040b242b6a223352e6452fc5b9374f90ddc0684fc98add717c36c9fa0111575e43c2514e535fab39d6392017714691276deab6621e547308212a62ac848a8d78dae616383eeb0f4326fc1ef4b460d6060eea79b96318c8ea79513259e56c95160e62cec5ac56e93331a81a1639eb4b8a6a687f4c1db40cd5850b11a45db9b946fbfd284085c10500c37e26354723ce43e00d335e227acacae44a6b3539f363cd35fcc772d8726ba3f44ba304f0c2f9722b894eecc9c2da2496672c8770a2ca56c63764ca5738923b8b37d5c42a0251e6b66d6c7d9abe487c1e7231dabedab3215adff85e1fc7f6513aed6eb14bcb70c19aaf24ad82d413e364b531ea42f54cc7858d969f07116be9bb2e0300c32915da84f61a6b1298c5472abd8e95228a1c660a62563268545b54ecd57ae16fc10aeb2c9eb4855e941ec079276aeb134b1c76d03d8f5245b8379f22e82b500939b4bc17639f547948145660c96af5ce8a391dc34fcd46d3fa2b3ea23c6745f799f3c4d42e8952de67a925d8f1189692d24d0f8049f239026bda8b68ce7d62a5c0ccf09ca400f349a7631529ee4e26e7332fc4ca9f623c486b32b20edd172fccb7354c6d032b3b9ecf5a5cb960c5cfc7c12ec65bbbed92983280356d989cbb4ebecd6569020aea7e20352b3bb2fb69aee8a6a51df0d067ce3790361571e73820820437ea77f28791374a8904907a70ad84b30595491009b21887301019d8cde5688095ca3b56317d39894ddf196e1128c5629707ee3949ccd528ef7c4e7a0754c231dbac62e0577390cbd9311f60ec3cb8e96c3d4f60a1b4019771bdde4bd4a7e4b780071829878b16304288c69aebc0d34444f6ad1a07dc9f2a3083f214f54b53511246c4134be6b180219d9fda0be16a1c4d1ca6671df8f1d72fc22fa607704f52c9c810cbce163c7e8bc8843a770b96c958ae5387cb6df7f36b210fbb3459225f06b83e6c7bc8756f9403ba56ccc47c59043d04d3b750a516e60f56928e3860504956004554f6b7a0affb84a0b536980414e880133edd9fbea08010fd5c0918a1ead00e6810c51030e0d6e17c14d3ef862857e0dd2c503b7db37c234497773a5483ec6d7d9fb7beb43b7cf25b7ac86ef370a2c42ce03b60848e6f18930b6f9fe19961a6450ac39d9a55de5cb6943fe226ca981a68d77a989aa17ab483c4dd957bd2ca80f6e5f9f61c0f5a5f5967b02d7f6161d0e58a7a2176bc64f8bbb0ff17797b7a1796d40b092b78d907b9970055e4537e2a6e3713772e07a58a7a326cd600c2add81aba8dc9f1466474ee7e126fe0e021300c97162ca537083d4c88bae6313e61c46bd7ea07e456504707cd1165880b636213703c068645cf205d855307ced1c81043a691c2351e6e571d93375ecebf127be3a3cb2c2094cb8a66d47dfdf26071603385f8661f65d099ddd7c22648f6c5e861de69184ae19ca63ee7a1d68607f56aceb9e369b12e7b1ed37261d9dc1361910e633806d77a8ea7a067d6cc101f39a2503ef46247f505726e242c3d2103140f401986032a030bfdb7ce5a6b1591dbf6381ea31e88dc47b03634fb1be460c0d9d7d91d7965e67c9e70a5c833de5d52cf12f64e94ce265efcac479f97809ff9ba13cdb4d7094635a1a63fa04eba1b1b1d3b71b3f2c2b2716cb92b0aa7922872de90d4be1bcf06ea21cda6653e7f2df5f3aa0b33ebead26ab7618e26cea3040d8b83406460f79390839cf83dcb63d26280333194036c26b5716aa10542667907dbfe5d3f1197b4aa0c4e85596d297f8527defa46280de22946203a49a2b48b363850ff260061072a49e42a7aec7b10d5b4e672716cfee4ad125bfc9741eaeffb3380c34cf02faf2be702901256a5ed80e4f684b87ffd87d962c46bcf7bc11b667d728da01e4f5f17adafc0e7e61baf43e3636b695266a2433559bcf5d7698fc913c59b518aeb4b6c66e8e8c37d30ef931212733329cdbfea178dd2804411f2b6591fffd5144a787f4b3cdb8cfd083257d81bdc4edac8fe5c2844f8228b6cc45da57d72b8fb0f62f30e42bda5dd50fa2e834090f509caf7e35bc5a4d43ba829916776256218d8d43d1094fc580796356c45ef880bdd476bbe9e933150892ef8a81b897fa46de126617d52c23c9d9d0aad823cee0e4f2bbbc0758b2ab0ce0d4d343a89d4779083544521a3b80480319c6f7d9587e08064381416a74e492478bcb0830a90598b90a2e3c115ded0db6fb04a438da79ca254c54bd77558ce2612800a7db2cfe7917076b8df4cfa1cf1faf20a668dde5d128fdca12374ec36fcbb1f77f7f1c9ee2bf12a744b6b53137edcaa9b776ea94f34c1e4cbcdf2bf02092e0a691e2883f16c852b119eb012640e7cb697426b133703df66e6615fc8753cecf57e28ac8ae88a6bf800b5da25343b89b6f868393bf0c79ce2719fb825b9568569be30bc3d5806aaab6a19f2d056857d275d563211d0c11d40d06f65d7a260cfcbafea4a6bcfd422c60ec284abb50a98465537bb4a7c83322aa591b6429b3a6698913153b799a0bf09cbefc7714b60b7ac6d3e20f984bec3620f53ae44153540daa67034fc85b09aff1f29cc015478da5559651122ba8501a67ea0ec02db71dd865bb49b381374fb84a23e44644badb7f17a6c4f606f6befe6b6f89a0510a10677bbb4d7e9e165010e3646b67beb85eb102a628ba121075705e536eaa2d6fe55bf0fbcc4250cf007ea711cfe59e5b6720850484d2890d591e5d12de986e75afceb10620b96f6ac0e27c8ca34fe4ca17b1a0852b392455912f45817f39cf02a968331031c823ed8e022c0d06789c61eda6832e9c192ce590b5ddc885d74fb570828880086f5ba29124dc73c9e1f18f8cb83a1eecc8d51ffbb0bbfbf4e671ea104004c4a97b1aaa346a87e02fe9373371ee006d5a4d4012c166c0e3f40a72c77a96bdde65caa49d3f084aed6f65c532abf408ae08cf3b513491a7e09140d7355c89410f16444cd855626314a3bdd0af929772252f17672207cc8239ddc75418d3aeb0e598d4263cd3eb0c4122b866b042d4fdd6cd32b200b0ab1e8fe08f5ca4dbc302807c2cdd494b91dea769564b1aa9d4d83529d1d786f471db47f9dbf812c3843e433611dcd4b07391db4d6e4db7ecff3cfc0c1ade2f451be34cf7d00d86a482614d1b015dc99437ab043756346f361466ffe977d8c6a4bedf4a37414cf7f8814a98a06a4d11ef139081432eb85e856f033ec62addfa2f91c683f52f6bc17108662b6cf4a899fcbc4e840b858fe3127d9912e4ba84352f88c8d34b4338473dc94c206deef759957c90157d712a0e534a485a8ea755d2acd8ff22b5ec754c21487e5d96551e275b10e20338bb0fc243cdf6511a04d66dbcd9a0c59b1657c9a924c78be832b1242a65c02f041293079ab2c598aeb600211b909fbe694ceb1a91faac3f8037dc370d8af630e4637d8644b517309f9074aba1c8edbbfb857cc617e972f10c672ecac8da1ccbc7c680d4d8e38dc6f83865446736e90b4b6540e1145a7e7d4f201833df2c22317721320a43f922a629b197460b21bac26470e3012cdbc5d384c5bef5209805648a41a4c5126e3c7129dbd1d48718bb316f71012f504fe1687cbffa8358f0667e528e578a0463ab8839ba62bfd36e8216d8d9fdf301723527c20f87cfa612652e6f657fc92d57f98359e733d481e8f1cb9ad14cdf7f725920572c678782d9271c8733aa1629a9c9dea4012e5b0e8117f1bfd81c74324a28d92661c9376196bb0ee04e3883889fd99a18a4131d189d9a0ca03e73d0d6c167d53c7f58db13aca35a323c572473bd03de31c1d69aa4337b8a794cf5ea962fd49c035137dc600bdeb23f5fbb080f30e7bdb3c5de8a24954aa534d0ea27fc20270eede74fc4d270781c39119a859af32ccd19c9ef0875032448bc93808db1c4304694485f53b4dc507b52879a027adf3476269a8434272bd12220505682fbe978702073925255462b3a5cb14d90742cc29592266dcbbf28dd6c3571358bc6428fa28993e333189c60b9821cc89f813ca58b0c6a3da74fcf0387f888f1943a1e3306ee4854577b25500dd28a84ac5fd1026f76933435ece7f38bccb0ef16c744284abf84f3a24b9f03d81a3c09449f6e2e7f684ae73749e08bf4992cfc9d7e4e95f3045ee15746c3aae5ff62b10cd9fb705b9eabaad56ebf5e1d2a4f975dc27965097c833016d59eda716530ad9e29e58e2f2ba171399cc3303e5ae3907584bf5346e6b119f0b0a9fb2f5a617bdefade95f4a36e2861a4ccc047b3a3f655b4ff9f65ed139f7c1308f32a22c6f5b56c0d38054d024fb26ad4b7c6220ffd7912ccfab37b59590f1a3490c53afa5870b8463d7e6251a9448d575e4327039a2416bb65d25cfd6ee136d595e6bf28e96b60a58590a805f166d4d0c8ea09eb431a81be04dcb6a5475dea07f0593afbc7dd138a9ff99aac9778bf440d3e8473fe34a663d0c018faeb09bdd5c1d283ac464cefbebc942b49ee6f4bccf3c2e59248cd7bd3c5c0d93c9b68e34c70403a73e2d839b36ad4b424adcd7eca3a4b34b2e4aa294c847bf977559c58eee92299ace0fabd21d7439c6659d7c74ddc78e9d0710354e45f45f6fe396a247be17fb7067eeb344b000787dca4e003d133fd045d75c97e176320d3264fa91324411d3d6080cb99eb2332a26f204cee4d7ce2d8d399618481dca8d8bb577a183f1ecf971c9b94ee228dce1384ee7c76a9715861055cb09a933ab602b2920d41091eb5c14ff15809430c901aaffcd70ecc051e87fa6d62f9a97e48e4a60347f96d0bce2e8dec8ec3ecafd291b9a2dfdcb1219650d1bcd0b4685a4b6302c3351a5f030a799172a6464d3032889fbe1777d41f42a5959442551cff5242c8247a03750457c416f0662b6041352d1435855348f81566769593b1c8eca46e86ae44ffa4eb90a2af3789d3ab3c893b54778742271342e390c1c686d59a22586fb3ac42439011697dfa5127a83f1412d36e3dcc7697087d07b6fa472b9abfa79535fde6adc820c5f0e65d1cdaec158fcb0fceee5641ba6ea5623b95410ae1367bd55a265c78805db58af2fc062916dff637a9ccd0afce96c349867ae41c7a1686d68f056219aacc81a8c291930f9f4602a9e861aa0af51710e05c594434d56445f23cdee64b8c5d43eafe2e6904e97a8fe59b36c8ad1e7e8574ba29ee1478a180d0bbffe8e5db0eac4b47f9f78d91285fa3414aa7293409848037188c0750cd2a349948b7c32795d0e48b4566f7255249f48d56fb2d1785ec3e4934a3365cb35af90b02ec768685ba199072041c4b3d6fc7f099495ae99da95255adabc5fc6b3ea26ee056a445950003afdc03891bd0964ae84e6f6361b98999515378da4037c2b2dba5d5f91da039afa378fc7a382be0079792ae9fcbb5e2920e4514c155eb025bd08bd142b5bc67fc3772fa6feb355d02c50f969b281e43804804b5b01703c9fc386888d4f3bc808c61412de13a3b70e66518e56ec8de304b2901d789effa31cdc8d12331663a1a9c61f62c0584c99f5ddd782158e3df32f5509d191e06bf97defdf704688d80fb48b68b42b0e009005d8361b758ad1fbcbf655c4b2a965449a359738c91ea7f13a528a83880022c893f51020941815c8f6996c36fdf537c9ae3e11272e9334a57a911f8a563c47089a4f33c6b05bc95c002db0e040089ba31503222b6b54525837bdc6966df58548e790a38941b7b28df87bc6c7c9c66860a15913999769cc125ef58f83203833625062ec5675aafb700b489366786c14d621ca9edb5297f590ca43f71a2c93211cd7e7338dc1dd8ebb1015c5d12424470c46a0dd7a8f2862171319cb482092da1a9866e56b5f20afc1cdfa0247d783368164409d05f95807e1f7fdc143ead9269e916c125dac91d2cc0b267fcb641e4c08a28067b4508b77d106fd4849642696f820982df7344ed9910a2004ccd8704c2cbf10917ad74c242e5808f9e39122299a3ff4dc66f3ef957666564a3225cbec265086bd05351c3ecbff9c41219ab8cf3ef1ac58501442b083c09a8d43b26b8d1aa886ccb046d04e152f471b77432816139a18ff6f20edbde91351ce7c4f4be25a6109812ca62dd66eb558ad28fd6decc03263fc7ce143f60af7575d2048213b5011b78ca3e2c78c64dd6e38291b46b34ae6abc1f188057d17296bbbecd5b08c0395120211f3e9e2d588d34975f8c6cdaa3929ef58fd1f393b085bfb0deb11b433c449961c48195ff4011a493492fba7d4e54e94a3c38d1521280116ba5ff19b627d858898c403b4dcb0d1c80e39fb9acdb1b836d6a7605e93281cb1f64746e6913a8910e27abc301b4ddf69a77038cacf1f36a4ca51706aadebe9e0313585adf901482c0de6b14154724ff40308a4076d024ade8b088441d7fe1d17b15bc8bed23921b6101b05f9436b382ebea409e6be863b340cfb103608a87da97775e8cd056c688353112942790ed56ab9da46322977ba0c426af2046bf4025cfa04ad8809dd04d9321f7087b135cadbaf5126dc5c1182421496f8b50d230f5d9a103f0fa1a2d42b4407f876a92b416be125ac60f0c9c10ead93145134cd1cd8b968768bd42af51da46073c0a19dbb405cc30976c1f3874324bbd425e846303b8c8c01542d6863233a122c1144910a8b2396ad987306a4a2dc8273a40d741b60625150922d0167738bac7e4f6b6ca52ab1cd0ada5e55d5d5752d9019f707206290d49b31c3018af200419258098cd159141c34d1fd803ad74a382a4fd32c57d11a932a0c6d9561fe176513e0cdbb61cee338fb54769c20084255b3ded5093fe0783796b18b85d5d93e650f5e39c53e317bc0e881a75c542a36653e517bc0525f5370c68487183b6e3c4f7e9e9ef258a0d67e09474c70c475e761cbd19bc62cb9714c79e9cc13e1d884e4c226f133e181068456373ae0cdae6b2d141dc72b477b0d864a57f5b5d3f32b6bec7e8d262d8a694a030ea07071418da035f40d4bed45df3c18aaefb09817a51e667e81e97d077849033beb4ecf4be80b504de9baba66bca16141bc89bdeab8bd66af424b266e6fb79d09ce85775615d43a99ddef8ad2f6813a7b0f8603ab8f6e6ff9b3064fef8b1843c8915d4616921e58c93593760469b8dad6017e6b289acf31b8b2ca59570ae8bbb622a1538cf7bcd7e41bf59101d56634d39064217d21d63ec8cce3a1b746ef54fcd124607fb34893792122e5cde06d875e2a7330c20383d2af3b07dc37a3389d1ec6197ad2e0586a46d700cd656a339bdc00792a796e3a07131a01a9f47d872938a326074abd889f81f8fad0f2634c1b8c6eac8af67ff9fc9ad0c1a862748e04fad1c8454e6cee6fe83804a0f16f68a6b4737aed674b5caf706e8ac8ef421e6e7f434e799bdfe8426c359764492900d6a7f1742e3a32a0277731c82430cb7bf2c4fde836c50632ee7cffdec82c03e336a1042d3307239ced5b886bc13a23e0a7bfef22c1721d97214e8c50fceb2b4189a583610eda9ad21a0a60866a165a799184b520baace846a7e79a6ac1dc74cbc53c67f30ebfb622a9586a3714e9592da159a5debe8ef376708fd5dec1b17e83d5ebbdb41814935a69ac4c5194d13927bf7fc501a5f5fbd929251f9ec33800c5632a1236f844a75b49106adad7254e06e48a1b13ae4cc0f09463d6ff283e68cd7a01c52720e0c22c9140447295798afb48c93c242df820ff06d70928fc6959be3a16cac9854b572de7f7006af27ec864b576f3b4222d91ed2aab11e66ae912c1040e0a1cf1cdefec6eaa263bbb85ae81c724145f093520014597200a9710d9127f0b3e6601928453910e17a85f1700038486bd8c132556b894455130a96cab26441c0bc9510a2977e87ff002991331f5aa8d4700632fb2f11ddaef0203ad8c14e2cc2cd7dc0163e03582a78a78074d103cc4790f0325056dc2f044b37a80ea8397ebb9581c5d22123415506f9a081e9424dd3413000460cb144a8f093f619971faf6d98a3bded5c8150e7413166232ed59b2a4f099696c62f47a84c39930d26ba981b41aa55d0469519d6a4acb8269aa5471e45c94652ef611a88460bb31c7bb2596fcf65929e2ca36297de3ff4e6027e4d503135649d8fdd91669d324ed39a1061a3439a53a5a60a326dfeb45eec36f832018b5b444f0bf1524b45cdbcf6133bd96a4dafa1c9efca189f8e1260cb2246d8f02c4842406161ad13ed4a55a87b294eb4789fd175437eed5b028727ffe7439b1c3b4962407c30ae26991404edc855c4a01c5b54010584e81680ce4808f1ba314b00ccfba5f19c02ca4a4e14357bfc41f98a3377238f98de8844d1c3ca022591707774f4352b2a1c5d3e856ac9f5660bcb587e8c3580d6c76fe9c396e06ac5e8040ccaa46037549f8d900d9c29c40f96a1863c86aeb7c375f5d3c484fb534902702304fef264025ab229fe65e509871800b224b20ccea288fe7a38787a3b7442f300101b79ce690583384cadcb2546d468d34318fb3280a853cb6d60bd4f33d2143dfd03c062772ca6c9ba4317a3b61dc658da3e35c91a2fc6e2b1552579c52359a109e27667e7294cffddd04a0937808253b7f84dd977f9a1e00b88a219ea7dc50d329fdf0d9d0ca0c23882d1aad09353bb1ff4a53f3250949c67d1da8d420556b4d399de51a0c1dc77b64dfd5c669e6d84efc158fec2313fe629cacd1733c4a5f8c71a77218f2a56950376c64d7302c4b56c31fd3d44959d6afad7bdd39dbdb4d514855c480f23d106dd50844209b0a546723a4c4c82b2f1d71dc3460338f8d59c139c842d5b22de4709c1317182084200a338990fd59f7ce54cd90991d2128454a0823be45aa93e14446f90d808f06ce74c76f3ed2ed03b0dbf5cb80fce8936eee86dd636dba53a6c66c51b567c1262da575c4e3f6bae55ed01830892898fa9578f4596ef081fc05ad20c6c58fdd0dcf9f316b42eff73de75ae1737f10f5f9aa6898b7c8838197a4cffce9ddb44465c92bb6e77a1f79a172ded3a893f17beec8431da52cf0ecc0f78ae3d6ecd3da29eedf8769669d3e9bc7e6e0e59a160110e4e82af2894800721638c65f60fbe3e80b6d89fc99b52cbfb50292f3c7f513bb221f42234d64197a56260bad1f06df318236cea18bb5700149cb01473e335d7cd6ec47d4ae8c902077106287d67db85809837bb821064c9ae0ff9552405a68929e054cb5af4d845b6d342184b55aa25e7efd55e379ceaa9f8672817762842a1958162306ff629d0bd6d6c7e991d61c00343e2b400244c5f483a163a9a76ef38b8e8750e0b07d4be5716ec971e0eb409db861747134338c8989bd4325f3d7b5c999cf7ff595f841959225f04d5d170522941e4242a972e12f5abc280ccb6738669007b59871ce7597f9596b003b41c233b50f35c950793c3a625898fdada168fd0d18c81db19f51313161545845d8db20b339eb7acc5cfe4119b746d671b1e80c3fcb29a0c86b22088fa77ac035a07eec5bbbd364c0d7c4258c3591cc102844fa863353590206604838b78558ecb075a4cb6738bd2e4c203ef9a6990b8077c627f472d0bee8c2140ef111468d8afa022d9d76117ca87b7f562bd0892f16b574a924ddbee141166977844943c09b3e65004a5bf0c34ccc6c60b70d774f6758b860de80cd08d5dae3d0951c5bda3eb9f3ead78e19b26e2b16cd280641c4a320c051ce540433997b337f5f2110be182a954eee183ef8a93ac4d9f250531e5a921c79e78bbde82d4995da489170a73f9e4db0df0c203655f0e52f41305e35365908131867fabcbe1a54d0198c1d001d11af417a6e0a7e75a7fceb8645563e33fe0ea2aaa4c4d84c7b03c7f05ec37e2bb1e011bca3f17df3076dc4ad2d2d242c42ca857cdaed821a0a95438cb5018b43e305a8d188b890adb3504180c7536a90daa81ec34130865db10c82f9501b67a8f50a0c02fa63b8a8ada4967fcd9d7096f7dce32d854e0e25339b217382d835c555f6d0d840f72d0b1a8f8078f55d7afa537ebccdc6a75981a74f60f7f11b600408a7e417ed66b889f940fdd779c7bd194af212853687378f56a0b70fc89b47aebc32dfaff70e392f74382fd14a06f4e43a74479bd371bbf86a09ecbb77bd6acd63e2673d392f61330dedc85c4531316016c08a1c3ebe72060b7a0df1615da352da4b849123a5f0390e3536b2b020899d99ad0c2ef0d9f963e0d203764cdd806f92e8485ad4537bac7756ed400946897d756a569b00687daf7f519e73b75161f0cddcf79cd4ab672e45a6d8e97637a3b2ed1e520a983782752ec266d22ab3b75479ef5a9ef74f5c2ffefa4523dea50a3ff507dadbdf1bcede271233116c70a9493fb8943b903b84b2b340b63109b327c12914cf9f200eb131b0e0df5f7982482c37bf784881c7d8c294221c8b989cf0dfbd0367f07202207ce08d0590e9507db901a2def4478df167fc7801bebeb7633ccbbe3aea84377b533d6d00c90cf9ffa7e20d8809bcdad167cf47ad4ea2790177825eeea966c020f83dccf087dcc27cd05c1bfe448419ca557c94d7513dd0228139b7ea58561c1ba303064f3b5b90580feab4ac661677cb373f9d52d8044c40e120b5b4459c9f795aac1ed50be1c1d18a72703a42ab317bf108bd2c701a955618b240e2fc14c22221085061c28cbcc83c491780115367c83057491b516cb15c1fefb132bdf617eb942fea8cc97526fc2ba21cd3266d82412876b9a0f83578e7faa3e631c16f8749329eaa03d7cd9718b44d2c8429539cfa8eed9ef2d634692c048645e5f2c641539c83563e8514f758bfd2850d7bfe15024421875917ae698cdc1108304ecd83539766e0b22e820edd45121b336072e67acebcb2e1a9beadb84f06248e4f72b0a00288ba59f67ccca91cd94b56cc6c1e8ea77b385bf2c7ce0aaf026c12fd2d7428a5e482a0fdb2362ec17be85fe971759ffd054919a45cdffa348ab0e5e812030159cc03b19d78b2d57be5c076a2d09f54a91f91a49ba38deefc794483c836ea63ed4252b1312f2617c9948a867d6d7c9f95ab61fd6af15f95d66c265bf9a98fbd75c3e73aa30e0af0f8b1e035b13a9d0bb613e8de0556ae00be92606bc95a90ab20462a7cd6b5b9b5fb252926704257f87f4e3887eccb60620efbe4d17cb84c9424c342f989162ecf423588cf36aad32cc19b0b0eb1b1ace3a87092bd070b0464216d203aab6ddef2b2758374d2f10094b4152c7ba5da4995e89bd4765a7adbaa87d5762846d79d52e6621c10e203ba175e7edf5ede13e761c2cfaa5cc17e5cb64618f69853c091ef9fbbabd8b57c9e2d72a14e23d3ebbb67010d8f472c9805423df1e68dcd526e21891d5b0f235e7a59aab86e75f882fcfd28fe8e2aebdd6d2b19d8b9b19a2807349686eb1606dea25cf97b2e587d203232137924fca1db45dd2be7de55b6a760dbb01e5b2661b3381994eb61a24ccbda60bd322646a7ac4114ab145a1c3473ea36a6628a5fed87a616fc3ea760ca41579e138b62731e66143167f791c88a67820b56292353c9f9f318db9a142be455127972a298055e93315f9e548c6518e1cae6fa1406b6ac8f136f4b0a217d2de576672ea170824b1dcea9dd37431707a0bf6a12d411f163bb30d90b5d972394d7b6c32e87b7b5b7b88f6c88e265c2324565f92fcb17008f6c5f9e99323271165a0aa6a81494490d7b935981dc43c5296da0ad648d16551654ee2b7a98bbe0f8d0a5841d2aaad430aa8cda85a2ddab1be7d2049f241c3e5baf1ec8d341b36f8eb49c1ee56083c6d28f71cd6f4653cbd98507081e795a066e226c0fb4d2c6e1fd7fb7e177bb0d390319b4e0948c720ba8b1ae58c6280247b777a7324eb1d57c9fe7330ae227f9e4a49350e44726936775937367fb46b624b6f69ce3a06bf0e7f9480d29061d72c495e0d7b4c9d66289d944857fc37925368e3c34d03429e1e5273bc27918535a15e7336c140ac8124e9c2e9b561880179812cd08e33ce09ea7ac52197b34c9da3aad9435be0d6aa53357fa1303870de46ddb4358694ca249e4632b25d56f4b458f9b0dcf5c91764bf8a94524c589c3756bc0b0af4f2badd46e6ee0ac4e6156723f6f6746312a50495dfe4d5a1f1fc85412b61363b5b1bf5f6d29e1e2c6946868852701d5bb057df911b71f550481dc191d8901a445c12b698ade5583ae67a0f226d1247d3fa6dce4a78a0cfe98d9b4b0581b47b88f36c34abb8e7737964df85e012e77640ca78265a13f4d3428329c1e53f6e152cf4715f8b129145142156d8dfff644233ff2d175d79f87bd37e1948fae2f574b1d274b0ec13bde05ef8db54f1982cc795a40119ee01099662614e7201635d490e7243caae301d912c0b703d8dbba7a78d299d1fa70293202bf7cd10a7f8bbb3bd231bc8a97b0b0060817e13e747687db9876febade1be570d631772395cb676fab1fce95322ec350d9672423da22ea02b930f3bfa90bda31dfd614047feed67c1e4cf11c4ca91fc2f6b74f5383521e5c1cec9e3d81a8e5d948b5400c87f9a0fac49508eff3e1f95911d5dd13f3f1df388466a3af4b1c397446e11f2630b55b061d9b76f2ff7b71885a8ad424ad8f4da9f5b901f5707b438c2246983018866826cf7eade1b921ec3251f5a6283d37699964998d56472bd1a08fe463da4a91ed118af90bf3a7ff0d49fc554f5aa79e38836f6b19ba777cf37f8241aa725dee6d7fc0f1dbd3e059c6b69b75dc280217426f1f3a251dda3fe726e24a0bd10bda449bd55df63cb9bc0ce77f0a32aef85c78d69978e9de58392a631dd21c0dea658065d1a5c2597763c846ac512e0cd160e9448d1d7cda8a5198cd8a825434d4a0170cc266aaef5a78c7d030ae80f136dc41692473b059d04b1e972943d86086ea019511d615e21272599c051e54e458b5873eb3450437a251dd7fcaa5f6b549f1cd2dd1c82dcb680be32a1af7f38f20067e7a249edaf75ff4699cf5d25b52ccf8c35945cedb620f0b9236b267e804141012da3b543abe6bcde1f1e363621ae94da82f61cda86eeb1b2c0e4523035499201ed5ec1933f73104ebaf827eb8bd1fbaa09f829a7206e8369619a47be9ef37f6563e31271c9cb44bd580747ec37cb50f32629a6233c07239cd8ca0b091cb24cce0bebaba8362701d7570b8d13a960d6ba7316ccb9d12737436617e8cac9921a7e15604cb692da81213980b4742882c2cf0d38cfe221b8deae1d01bb26e4ec56486e02cda2b172a7944cc79857a8744533ecb0e5d8d59a67be46712c48ba5d2fa34fac8fc8b3b12f3bcf5a06844ae2c44462761d752a8de2cb38b0018e868581ebacd22690392810704661b5b3536c8281fcb7e1ca7f216892a1b09abe4260a96cff14138920f514a3e86139bcd09875be55d9b45e8a674980170c2731f53f221f7937c9474a400d35900bc75a41ff4d50beef98cd403e4e7b30a89041d6a107bb376dccbb081368e5d5e64828a2e302ba0b5123c048249c60751ae5c747716ec4bbaecfc1c687ee3c34bae01e5ca8c22e1d791f12a72be28d16c4e6efb85c162741b27f2c9d5c7cf704734892da45aa0cf00062c390c5275fb52c7a2f900c1029afdcedd88cdde606925011a85c42d6f3c70af95c399ca9a7322b5cc23e58543fec4ee52a87532d33106f8a4d0167e9b7db2f16e016a0c86ba70fe6c03a712897083ead0d3b31175c331db5963c30408370c08b11e7f457ea44954a54a6f1c15ed771eb2a0fb1335a42967fd05809a1f6c3c3376a6fc80657a9842eda066c91f9fd9043b889f822f83c11fb28e83fcaf2864e5785d0ddbbf60da73b86539feaada1b551eccde7df9deb238a963666179416234587ffa89eb4e19b2a992ae6d68a07e18a672a958df1c69c1f872a9e2c9b2cea80b223aa626b3b23d81ce4a598d2d7c374cc978fff163eac42c84a6c0cf88ca6c279579ded7d6f621ab72e180f5b0279c7b72dbadf5e04ac30d0764834e83d5f15b1e50a9046a94c6fb653af7ef215a08428809b8a58032e78dad5ab058cafe3124c000144920d85333c62dac934dd83c7060d7dacd811dc81ad13275a020e202f8f9b8632577249dc1a8a2dc25ffb727fdcfdb7f9af9ac6ec8a6f096260f7af709b689a22dd2f187ebb73df5e439d2f9361a14b98c48f9eca0c5259abd3722dbb3bbf98b83ca4f440b6552b1837d7aef7c607aee0a78e18a0ff430591b78f62cd99fa314bf7396733b2e7d946b5ebc34d0d86158bc6175d5cdc99560970f34e1aeff5650cf47e4237cca0b53a981862d0e8931b0ef3d8500496e04dbebbbf15ccae0da299dc0fddc597027e4eaafef71bee2d6d74829fe1dbf3d2d7836115a80cc5aace84838ab19e5714dfb010b8c79b0008c6f8d350d3c8687dcb2e48ec269d8ccfaa9d773e7207e1dd28a3857144a4d52057cfaac8bfd41a34321509e9b52c16358b068917d5832c6654647c4e2d305072df04c35b2178bd08b8c29e91a417128ae5ebb95df1a24a06d1f1b1eab3b5b1ddf1818d613909ce3234242c2aa8cc5e163009bd4403e03732846ceadcc36fa935d62209bad635a69c4e13a71f4bed4f81a9d514aecc664cbfc638763add6f8b99ec84a280cf5e9683e07b20b11f1cb0fede3eb5ea69af42e40ec973ab65fe40f5bf283aeb72556df84c4808cb28231132532d2dca7f78a99c857e7c67ef2b1357b28b994988d90a8640d8ed9083d315e71d5162c7ce8d08d4660ba990109ab991ac399b951ce4c46b3fe7873a39021e7e12b04e653a305ba793a54003c46769dee3197f2ad465a298cbc42f3d7a1f480efe98d0253cd95342c4cd22049cbf0b0c267a104c8b33f961e2af95026fbda6d204736b18b49700f8e87a21d096acb73dc1a7ff29f49032c5c2e7a45594740fd4800a368f7e08758f2450a803a717f5ec012549c04bac9163b8a99ab94cd5941671781c0f8fcfafde5279e14be8e5360e18d26e85740bd89085e1df9bc3189fdd34c6e9538f47d061a2c1fdf2529f4b2494a5f0f6de1e40b3156dff9b59f4299844a507cbb36f7bfda9c35454f47b3690986958f46c80710edd2d116c5e0e4faf7c5a68682439bb925a164969048d9e86f2474aba183af13f6dbee1e839e9c36e0a6aa342c86722b6e171280e1ed4e58531ac8129cc0beaa041af085c63c777a5a66e21c2b58b18379948c3f5e5fb3051517b889348deadb315425536fe5dde70fecbfe37a5e3660efe3c87e8ece9576674bb93db3d0b47f3a771cbd8e7fff13887b7bac15735d7c6d9c6ac15dd22a400f3deccc24949ae9219c9ca1e8fc88fd798cfe5ecc8d259a84fd442be39514c7d0b7fd08ef112fb70df9f231362776ed9a766409b8b809b043c681159bcfb72331de75cdd6bebd4c453fd704bf7dd295499067191511415a4536897bb943a6f5f5397ed9a8ab85ed1cff8782a3e889769e5306737b81249517ee2a105479b54f45be9d580f83d85c8039d9b34ad6312d86c6bc48c30a3dc1c3297d855d49ced13e2f353f9e41f252b6a83e72b6afd2a5e7cf54068ee99f2191935166c7d7135db821b3fb4b5b598bb0413b1a30d8bb731e19f57b969083ee6bf340b5547dc0fc121de1d079ac11336e0cc865d22986d3b95826fa6de54a45e9d09f63f2154a6da26dc785d33b36e6004414424fd95dca6682601fc1d61417713aa6a2e0ad11c03e6cdebe24ef83ac1191f5c77f43135db0e3f7fe515b185873d6f6ceebaf125fef4500e4754569303240d40e6d5c7308cb1d27efe375c5a6d613abbd2b196cb04becd63fd8e1612bdb291848e6089a5258991254c0f4c6f4737f27c3e6fe218f59b7e3fdb5423066cd2eed6fa539b4d0018ae4ad65ef9034d7b1592556e7d5aa8051bbfb112236bc6869385e19ced1e2fc2c4db4625d439cca0a309146071687ec3f7cfc94e3aa282c84f080aaab2e4462f841537eaa96378bb74e2c2c7e24f38a3f720aa5f37b4b34bc5d1b2e38ae1fc869fc8b558a35cb6e509670a24a4fd9d024ff6b2d2ce730e0f0359495fcd98a2199ca42b35613db27865dafbcc75c719767c48708733e65b53d052ea0922b1546b33d76cd9b1b0b11bb1b79aed07a20e8c4a99f0a37132c6b86903f556db9130b354698e3303e50c73aabeaa670a6aa297c1ac7e9c66f708fc5bdbf397474a34274f448d7935d8b040285192b6600cd66042fd41400815fa9e2f838c315c1a02fb820c1dfb36d5fcbedca77aad73ce9420e7e52a757edef19e21909bcbac302c7b1075db767ff16e8c933ab79b7ba4b8938f1ee2e759cbd383aeb18bdc883d21b8d03d0a312cb2c307d754889022acca3169054122d191dec1546eeb6b12b8bc940307c36fdb9105d512b5d631ac344dafd65096e51dab35d1c33fb1c1bdc6f535f8467dc5b54b888c6e58e2894fea19fc684dcc35e22e1126a7520d75d736a8ce3e91655dc1e8f46a99cd05c5411d72b6e1ad6b34e5bcedb860ed62310e96a431fbfcebfa14a444bb134a73251c3c1a33f75c11f66d97c813fadfcf0af55f00efd498ab1bb1ca18dda349098c881046e7989b162888d63841172a5bcf65b42af81887b60e9aee9f27b6eb1a1957e6b1fcc8f807642e568621dbbabae3abaa7d03ec80b915f155d01e6aa08f2f6d3e24bbb4c881a49dbce2de1d45f7f999c8336304838de2d3a57db7f23d8fb29026021268cd3200bd7d8937fdd2052eddeb68d8510bf3562438ea0eb21f5eb5611f4f8e6e0871716e786e552e4b480c5026bcc85b7103d65c7059dd30239ea05a4cc337b658020b061174d5c00e5a19ac7c3bc42c2b9310dc491fd37d50451a67aad59a6f12ea4b65a5077e7ea387589955108d7d838457d82c90bbdf0d2ff79627ff9b604de9d2cb55e10329daae942a4c5eec8c53525c53367b1f3e971b63f4a05e36faa7065ac35eb21ae0dd8dac51b045d4fa68babfece59979cb36c54cef4e4363d86377d0d667bf30263d4d70c9f95d620d1a9b1c584bc3f08a940dbd6db17528dcd1ffe1e68d28b54be1347ce0c91e3abb56dda5ba9b32ed448cfde6368f41910160b19b908f3b5609cd833827c990579298fdbc527868f01aa563851f094847dca8644eeb300d19dd419da702f8bd79b2b77a2d210d5f849bf6f771533a9e9a5593baeae695252629a61fb341478dd8151571873031793548503f53791692d5318d39d93abd6cc5e77f5683bea336673382b647829101cc83b2c49405d10a8a50a5b4ac733cdfd8f55d4a2cc36d2144ac51c95a6878a041fe2c79302e7d69b11112d4214a3cc2d6d54ad40b9b08953842f1ae0352bd98938bb615ce3b9197a8b39e25fc62dfc7ef784695315aceb4724bcf8d3c7a4c0105fdcbd8d8508adeec78aca5d536d34840f2d0d4d33019e7fcb75df9becc703243141d5cf935f9d42f6b36e3f67655845ab79add0f050c0ce40e7e28179673bf54c52950469aafb65303d0e27bae68c18b741ba8f7c1fe8f9633066d49c47b523c6f09d7e441895fe50a71dcfac15e0fcb13f5082d2fc94a5df8965b5e11ddc4d11d36f69cae7e93694e214a0996a0705ea35139b3f6b9177343ab967c6d848a43367be183948083883f4765312b5094103b66e8c8d35cadfe3c776154649a9385a8442c86a391b23bba19ebbbf1d0201471337522399b781b5376b9c3ded4db9a00f271904655ac4ae42474a2cc0b1d0f3528f72c57e5e62f800a2c6c8d19413e51c42f6081bcca51ef3d87f16e16db9597beff6801a76c3adf2793a939d296f302a351902a3a9dffbd185ddc24f9eba8d57dc001be14c69b5749c6f6c6a7eb6163b1e1571c6f107abb3b9a1be3f3fc0f888e69d07bf07c24be2e01913f7df895511c74ed0197681ae1f86559ecb64a09f869c50412a9d8ea3759f356aad509da3617f739cb1b95da1e19b5140e8c0ceca139274d2ad7d41247b275ead5039d27667547520f7755f9e2c5c2c6836e5f4027b0160801bfd3240e73a65d1a97f3bb48e431c241028e49eb846939baec30c42c717f4cae9f89a62d2fc51ad6dae1cccd268f606eca0c96dcdaae574fd31152524bc787c244c69b31543bd1c488b29f7101f8e425eef3c6abd2bc0c55b308b305b30d1e7387462087522117596cf1dfd14a079430e312f137220959a27864c8f7b4a2a1fdecfdf7bce75508ee81679731f32d1f7f3198e3f535bfdfa09170ff6cc0a95719916083a0e8ad9d3e47120c9e98ffc7e9398dff0d74fcb3361b51b4f24d293c722cb7a5ad8954b114192833d3b1953ebc1e8d12fbab74116e56d0e07519ad354ab86056234cef3704aa91c1262b4d3db4fcc12c7a554a10051f52800a0dc718c519effe3fd329057226eee2121d848fe075fc439955a509a5c1ff8506c68d54e6bf338995b6750f9433dbebc89bbc3be0b8c650f2352925dd5b22dfb43834f15aed82f3f70c32a948cfb11b4867088fe0569c2f5ba14c012f23df7076eba3b55e2cc70527d42ab4e57191f8a25ceb41b9d4d01dc64a8efc67fada379ff5d48c33a0e1c3521387fb0952918d8427b695e8862f40c222f20d30a13c7c6cc8a679fc2cb8e469018c977c31168ad502dd28428530d1b630e95ca75d90543b64da9470b0a08ba9b1d45b956360cd7a61e4d9fd5f339de6c508b4831b55a222159f573d55de262c44e3efea22dccd0063826ae5882ffa001f78930142330c4d652c067431fb9a574fd40fc436b4b04d3e9cce778c02569f12dc180e092e8629fc7c38a70867360dc6da0d5e37c9c14733816595ec3e418887e9b9119fe8100374c6823bf5d06d5d1d1469354971be8640850805827dfa6f0475dc530737d8e552701cb47a35498dc2e01285f910aa51583e810d622bd16b450a78089c1dd5731e1cc5bb4fbfb2911b3c8aea094426c16985f27b085e89ed84baf28f85eb3cec2d31c65116978a44a575087b72150ddc6460babe6a332962faeb90c4002887d174dd01bd4194e04488afcfe402d54b05fd70f9d19daddfa35e9427eac7f4ea0c4cd24bbb1fa04e7543df268f32cf221b57b1fe9156c034c4aab5576d7e91820be44060874136b4bcbcc6b4f27681575d3ac2c0f396b3fc9e8913c225bf35b8cbbd3e4825412f53c6b4ce56305961ae0abf8ee5412eae33462bc489b6c28a3821e2f89afcdbc34fac7fd573699e46f2b381daedc84b34f91718ecb7de5268734f547f15d21089c88b5bb1bb1b5df6ff1ba655212acacb9a1d7afc9927abd09fb7493fe49bd010d73e0c6f5597c7babcc094c915c4a1414583e6239f0b75537d975540e73f3e8bc0d1b28c073072a1b0596bb36a69696c514dbe9bed38ca8b624962632461e4a784c64dc0f258d2c383d0fdbca7a08c39224e0dfa6e13d99d70cb5290cec2d725181c86ac2e4dc3fcb2a5e630ac60ac4085d76b162abf6c90a3969274ed348ff8c2493ab00b7251da422eacf82247cb2f0b0f4f31bcd82ce43c6a8160ceab52db4d5aaede3f71f878cd109e6795a01b7ecb23365511cf890ce9a45609fe555ee41680d902141d3cb45b46400cb08e53b688df527b14ec84264d0ca6ed9b3615f55e4f4384d0c6d4489cd75ead20a2db945632752c965d06a402f9ce0b0adae1caf70a77ca665e2b3642cbf93557356ba98b4a46dbea590f6fbcdfe359717f1c465a2b7aefa88894f329c22f04e1e3199189a71955e727edb4638f849d133ea0e747b1f3043400d4a2b8d881794cd24cd299bce6cce65ee63603c56d076a4a427b7b86fc48be1f436ac3cb21d969014c803f0ab5dcf72a72e8293db0c4f0d8b4751349e144df9aaaefdfd875a98cbbf9858aab07326e3e44d91c51813cdb84861117bde4e5dc7a84f9bca8e960801c35d29e3b592543f5bf197982646e510b6d53c697bd3518e462d7788b04d66626952dfc99e652064cf68eb6993eea16ea02c30361a1e69c413590f44cae96e8d6a9e1931a45379a742c246bdb78a11497d6622eb2e0aceb201781a1a22b6c1425319aaaa10a9dad236d99eb1019b884ff186d6759e18948b8fdd46d6cf83f5efbc390a14e97f8781fffb40811dfd57bc684fece0db13aa6a1c214493f19cb0707d9cf72d9602293ca31bbe5b8d3834094a8d0e92feb4aeafad66853ae8c3b6dd410abc5c1a5e94137b325200fcb0545d6121a790afc49a8c8cec757f68f5991b0c00fa1086d54040d1452a819a5c1aef4f3738a6db25505a7b703b11659fd0897b62c36f951a4e0abcf1aa3e10e0c9e0e44fea6c1a95cb7c5a36d9933f9445fd45752fe1f1f680af3e92172c55fc159d0f911f9ed2116a323ffdd64faa074e649017f7cedf28515ce3d46cc6d01611617fae87d82df6df30546c589e9817b9694e4db98c63b0b9ec204eed41186b62e4dc60e69dd9fb5e3db4264293b1111aa1be2bf9bd982f2635445f53c1688e52143233a10d374e01895d072ab317b6e878de15a65f991f93d367e634a8019b4166927c9a24b98ac0725278a7dc9afc616e381782d503be9e49422b45377d34ac9bfc0089b037bdfbb0fc7eddc00dcfcaa597d181e39b7ad17586fa8cdea62d8dd906f56333cc6a831b9d03cc5b90c37339b6227489ea9900dd5e1d5908c28020694d9a3cf024cbee07ac85add847c1aaf2b0b62b303e2d512b7c08fe72e17c603a9b7c581a7b3fda3c522c3e30f080921431e3a4596ffcc941612685df714c506e0b216eac8cc7d9691ade7cde74edc2fe418da8b3fde3224eb882444a4392807d44d161e5d6c51dd3b771dd6a4bb30b91a20eb64766b8540336473dd097dfc3490e8de885f345995c8142fcfc62747bea4983f02bb69e1d567a7c0784e456d326a41e697ca8a8f342c28203df70ea7534e6df76201d93acc2f9951ea250261215ac58348ef6f32e1e7fb5e7e69d9dc8107d9a253b4ce4efbd5c6a8075b23434b293fab8042e9ab62161373a9679132b775394c8c6013489ad462c86a24431ed68abbda932058ddd126a4b088e3b4575752404072d48cef7d4a83e6ba7034ef779bd527ff4906b6a62e15d4869f51bd30047a7b60c9e29522d6b02cbe992283552200559a76552a5cf4d684686376d2b69572d58ef12c2bb560c54a9e17295c8727e5ed5b601eebb2ed7bc9d4f52001b12d5ab85123dd70db77b346b12eba8aa653bdcc49ed987dcd9b6fa9e8073c71a311a06c31442e39f7d6954f05400284403af0c880a71f3a096289f9c97f8756a485baca2066f230e0abc16cc07ca8119caf43d44ed5ccdea9af525b3fa5e9c363121d15e6e898215d6a9dae0764599d66bc88bc037f291c879f31b05e9be4467522ee6d36fb1ce9603202d0f6cbb30532a962f3881e604af270b9d639d622457985216e1657d25bcdcc0df17bd023a5729c4f151162514e1874e3d970be14dd08704172488098370c27a90f74e15b0a5a1612d29feeef192c412454da4040ddcd0722963c254b874dfb158253845fbf7b6015b0833ca2cd024c9200096cc9df8a4a41ca0881011b1392401da68cec795093af2e2e7f83916089733fd4ec303dd9457e17a2e44eca9615f62ccfa3870ce672f2f34a0e92bf60072799442adf708c17c163c0d97b483fce83f12893abad2b3c66c1b1ed0e2484170799a561b5a6c9d6c3fcced52b61e14cab90698d4dc9093b6e09aeb491e278eee4c6f257fe4fbdf77f79a672cd5515c78e49e9dc3e81b0d51db9f4d970bceaa75e531383c16420759d972e8f7a7362410f0a2aeb0014fa0fa76b4546b42c8e15cd4f7c0b5228240e4f0c6ef6007debb09c1b4c8e63e21798d5554c21044bcc2a6e7a2136a6757bd456ea7217bd0e88aa3226d65611c205431747d132602d7f7409cd74c167471f8a7041f60b4d41ee292d551377078a5fb9361961513278cacef52356f1064a44ae356380b8bcb6739254beb5a3a6cc5feae7c4f99dbe81073fa38fd3905bc159d13b4e896bd023bba3f076e276444d87360b3811eeede71b96cee3682a27d35282fd6f44989e73f4138c4a29eaacb47cc28f2c5f2f2933218476c497737ed4501ce3e624598b6ef0efe7de6a37d25a051264094fb366622ad6f1be5ad5c3dd49655f0977c802a55e6e570622135047dd0ac1984ad7c6b0ef865ab2e64d15ba658edf0a89595c2a96470eb134283976accf90a919931e1247f39f15296f667b09700e990ca37ce8a85b9fa32cbecb6238a493a416201f6b24beb3e45371c973744430ae02d85237d510c2a5ba7106eb4106cabf774d04ad3a08c66e84675739dad7b11268a21bf2f7e51baf213f4dbfde2ce71fed0c043d37ab246a288d96ef4131124c9f6aa4eafba1d2355ed51a15711e2b827329ab1415cf7c61cc6d2ff614a2c9d05500b310efc37d8bc05f853d6da21d0eac7e9a91ca31841402d249db15a370a44f75ed3991ca3c7a51a9b84e5d765d316402c11ddb9df587908e08054961f9052c1aa5327002f1e2f8bbc3bb594fff81d8236558cf5548a40c4b1b03721e3275c561aa58b28f1fec346091afc844435828685e71cf35814d50886a0012f3fd0857e3303d15f11b2a0a2b6df2d71a9fac43b0084e11063cb411400f4fb08cf6e9021a498f018f66bab530b20e58f0fcea73f64c6d71906adf320cff8f1556eb4c9bd4570d362d1b7db57e8115a8bfde565a4a2430ff5bee598cd0e01ffea8b3fbeba0db07286a4fa5d61aea62608f6ca5376ca18bca8f3a60585fd47d8cb7ae18b2969adea0748bed7ec7442d0f88f5cae067d899c0b9023a76c6388e22cc050eb0b55801c1634a971b4ddbc2d3ad671a57928a13f321d9e335e56ad02fa724fcae024189cca7587d498df9fb9c978a2eeee7ce73c892459f0452ac026b20f1f08dd4d3daa48b8a508a5ca9aeaa8f67bda8fd57c837877d5924a4caff0f185688c4336beeb1034b700f52ea05eca02e38a3fe60e813522e082ef724cab829511e0fbaca9a8eade836e33d3356e41bf2e1f156984b189f56a464fd8cea525b448225407c1a41c845ff5e3fc49c0fe37ee766f0c0caa2efdeae03bba2c0d1a28b28a1d14abef0274162e109a54fd0279f86e9650d038bd6e5648611f1dbc141d110eea7ae35468598dff70a8a31da0516c45f40b5dd835c419fb1844fc593d343d78a2a68d05794fa08d5630fae41036431b8bb5393e139eba0eba01ea0876ed7f6a93ded9cc30733f55d9e67cedc7e741a20f5ebac0ad89fa43b8cc78aa42c886032cef1c11293cf21d23ea0873c0ef7e5be5179918b97d783cce1c1bb965c4dc30b6244e16bbc3d56deac22f5cd50625a95d3f6e4272609e3c0d85dcf23d66bbc3197e73a096ea919a88b1f0c62eb4eafc28162623cb1e96e523f6f08a1fee78a64f6949d1b4cde3361ea87455776582f7df350a30768c5550bd648d6f4234a66cfcf3696cd337357153e2a1fa3f57a6fad70b369b6766b46d9326ab4ddc3183f9e603c9ac3409017acb59636ad0b1e7a9c65743aceed41ddc86b0f08caf5e4e980dd5f326eabc28e1ce681f62307a2f4b7e2c031765f8931c449e8178688fccfbddebf6456f475de2791e12f8e62c434cdafb0a84cf00b5490a36b4548e59bd7a9a40c4417cad2567e8ab2725dd0bb6e1f31072dbe354b78e4695ab14c41824da053256cf8a8c08e118f0d335bef1d324ab554dc01e4b00962f272e9c092fe1134f4153f7f41f4362306088e5e936642260e35bb9a8a7de6f7833a0ccc26ee9ee69d5c5c48909f1bc01028fe64a0fa55bafe8b02302f0f8c2182c254a9fd584ced26ae066c3c56fa68281489fe8cf0dfcf08cf6a93fa9a83d7186145fb5034485b99724f8a3603b54fca0ba520d87a2151b20f75931dffb2dd128b8d79fa20a8da46ea6b97e8d4c4f2ec12bb07b6ba8d781d3712af3ca4d0b1a9f37c57ccb2bbc4c53fc3324feba1c7745f59ea2c010932994243bd40268841bc44eec3e40bbf5ab275a02b1abe007bd399e0b8ce14b12a28ba0c77864c89e05cb5a78ac626ba25e9bb487c5956c8eb16f42b8423536878352dac51a1c92b25b5f583f3bbd52c50a235958cf45b0497cada21a28ca88424c69bf6a8f5e270e27599802c69fdbc0af25e8f70b6e5d66360f95499904e5516c39e7e3b1486bd57a55ba24e002028c164d3614aecb67d141a5bca59172acfa2819f860aded79af98e2107d4da7fea951f16803630644afff40b27e8911a23916f958d579f7780775556001a64a80c10b3547119c29823c8e6f6221ea62f2cb7e7a16bae65baf063169db7b4451bb545da46b5f77f1ac5df1ff72ef38898164d53b23bebcdcdb71d7d45e3fa3266cca0027f87c8e8eb6bfcd5213c01407ee2810ca8a1ac73a63fc5e345be45174753380949448e786161e1de2863e4c76f32fecbf5443b07c1e31c7c579d4fc94632797586f8f363baa792849914a98484f91255aec102e65ff4a92d5602ffef95c437179a5d2c483b724c403d0a1b84ca08f7fd3ec0a78abdbb7b05e1bf110308fdff06e141927fcbc11f340c27e9bc82fb043e1db113239202307473cf339cb291014307da46022786cfbe62bce9f8877ebfb67134312a92345d24a88082d63e0cdd4b7870203e874255b458fe5f3804f3ed0ec25670af750b50f60fb8acff97d707741ccf770928634dbf63d6dfc3925ff9efe8f32ed70ff71f2dc5907aba4cf35a661875ae222693057ddeb481c668c00656b714d9e0391bc1c8c9983f2c308b2f4e69c1620a6dc6c3cae2e3e1873ea13e31d1fa29cc15806580e534e1a48c319f6f28f00e3c817ccd451c82cc28bb95623f4d8adacb54eb9ad0fe7e0b52385281a4930c28c2a33d1b2b2a141aa219dd6adee1c59b172159e466d0071b092368d658315f9e65c6f6ae63c376adf3309f05ca3411848e14af0347c2e446915951dcb91f2ce9918e09d1cc1201cd1da2e7ebf6c3bca0fd8c40985e2519c892915de2ffee9b50d76e54051d7d21353230092ff24e0dbfbadaacf9f85d56c9873974b4382f424ce4007b93d01a37490155e716103de87055724886d57c68468f440c5ab75317b0c101260d3d3f70b790b4e8a10a3fdd846b40ad1731a868d48bd5dc0ffcaa7c3fd6c0a4ce9e085386670175d056a53161b7b35caf514e93f4e51cd54e6906356c390b8c93dffb07c7b0ca69ffdd83bb7e0d309ed6c788bcd3e3d42584af4e49e103614dba2b78cc23b35b2e8228d81d849c7ff133bab5c8adf8264479f86126e1090b897df48f9b3778171049ff92b44010f1cf03f02e32e196a14fa09717cbc829c7cd619bf03ef832d995f2848d0a265abce8bbc8fa2a2d0e430071e8feb302bccc320a05d15aa8a99e88e414f2212bb81466179e51194d1c5a01d9e274d85782d49cddbc46cacf3a14ca1072be7e9bd1799621c41e050e4f423078e025acca7e2d6603f63ef4d61a3e79518036f0e1b0c4521b6dfb4fedc938308baaa7f8833282e24cc0037ce1b27ccb0a411c3bc735a0907045a6665f80e92ad1a844fd47eb4004ee922f5c7a586c46524242603aec740fe292eaf876d47699158faec3c784d0267142d2b9a4dab63acd4ae53ff7caf051615eaaa09d4293b0233e3498667e97a475e6472d8e9cf44fdb26729a570994d223d1e3a424ed686accf7f895d9459b1d5a95d79fbebf67057248922c6751163a1dcf8471b41c49470c29f1f922a2f4d77eb6d00da4135cb688e9960eb28eac5ac380a376e04b86b623b7b4a2cb1a051f5851ef0489afce94bb94b7a8c3682c00b4882051e8b9aa6aa6bd60eb0fc43410255b19749c08d4091fb20dd8e11bcf3f810ab03e7ccc98341747201268c649bee58110048d3d2aeadf623ef2a1fd0c77c30bd7224a93562dbf6377fad34b0dcc60445373e1ec6b2c591b0a450ea32f78623bba2cdf0ae3b1fb4661d4e68a865e6e4869d9727b371a78e87d7439b3bcf7125c169d47ec8d13da26820b215ca0cafac680bde1e66288d7cd7b5585dcd062272350ef5ab500a3644d368e5aac7379843a174ddfdf46150f926dc60d0fd5eb3b3bd399012c1ba36ad0d9d5d77e88c601cf410e56f83cb43896929e6745a0f8e4a43a30e5501205119577328783ffba93e6ece4b52cdaebea94e26dc7c228703ad2cbcfdedd949bb20ca040b786c441791a45a7c986ca4bca556d2b9a42c273008aa13bcd3309db652f608582348187809e4adfeb4a24d5abd7aa26da0791be3b799c1f3c83586ece4d63a83149309296f959fba783ac627cc009ad18f050c88a30be908eac13d503fbed0f6d981f16de606ff194cd97ee6c43407c894bb5c2ba7ff3102533fe649df333b924c2d5d28bc0149723578881229239fd802a8fdf6a56f1bb53c09a91a913c499649601248acda2845d015c14af42f0c9971346139de39630c20c5a60f651f02f6926b29632b641790516582f9f0a3e42e626228feb4ed6abcdad4a614e3cd57da7fddea64ce6303e4e2e6f26bbe629549943f6d6081ddd6997b9008f0dd4e78b761249f84f5632e4800c4fb05921191a6ca173fd1f17c4af8f2171c00509a48c4f8d960906cb86e3aab7b0e79fef798ef5938c8d822dfec981f2dd3bc31375fdd17635204acfac307a3487d0451171c12ee1a209f103cb2b7c45fe2d358e9c5d2b2dd9d300271d3735bb2514ad3adf67699c2b3ef3f802d0d1a08aebd49361c0f9c5b134d1f214768bc6e1cc588fb0fa3aec1221bbc1bb3757378d82807861fef9c634f13d9e9b9c3891039de80cfae1fb7c30d78212860da6046beb7317bc7e760c7777eaaa046cc4f02ba68314657309c19a50367919a9f3e8ff1b54898cbec5cee96c4aea4aa90266193660efbae272cac2e61f18c5c3202f108aba1620d8c2f020182801ec0f2100a6d1b363a90ae07c5bead6fe25784bcefacfb1bd97b4b29654a32a5145804040483043fc46088142a539e9052c462600b059835f57a71bd18d1a8dee2eba3d6d0f057b6592fdfb24adb238558bf2d8ff555b64232f7d547ad61f92adbac6c7b96678568f9172c991048ac96ab86c52ae960cdd130002a180e31f0dfe20d228a6079ec8b68f9173a2d4ac074b27ccbf7fbf2a88d96502c58e6434bf622d34637e410d866399b65fd0a673839d69095ddc8b1feff2dab94838363e87a1c1c39164ece6549232d9fe2d135faedfa95ccc655ba715d2ba3d168a5aa5aaa2a23addc609a6be5b7ea476f55a51b3682aaef01c7cacacaca252556246f304d2565766394d9b8c134bb7384a3aaaa1cd670dc108bc5fa4d8b2c8bf4625996949794524a79c9eaa5bca4252d69b9110dabaaa48d1ba7972775295ed8cfc52e33d8a5c205529230062e84fc4197f7eeb7efef377f98b53710deedededf0fd2d58227537d6edb0fb750bf166e2ab4143448c023aa19c1f73a113899452d3fea6d550a0c92367f93479ec98fc6e79dcf26c0f931d22c49789155a86425608733770ce71b303c2fda658cb9895df65cbec76cae9fb47d59178c75c6cab8028cbbddb238898a6a94a7a86e43712c800349a517ed49ad1cb6ce3afdee22ac6cc850443c68f5a0343662fe58bc7fe07cbb73c101931dbb8c25eb0582b2596910e2396571942acbcb3947e20a9c0e8c6e829a03256328de44cbfa24026eb480e816de68335ecdaf877db87d90e1cd678d7adfb2ded60cdc9dfc132a2b1d241964fb125df6df22f292fab64bd351ad1b0ac2b46964cd9147fd3118db8325ebfc5b7de8aa5527c7959d688c675c9aa5ac96854d9c51ae3304dccb6fd6aab321c9d384cb32f7fa755551fe3ea5428d4cd0cf86e9b19925e2084f0dab0c931cad2cf4a961a4208e146194ab028f22aa6e10c3de841163d903b4d3451d44415192eb420d4d811420861b8ac86f35ad6b2afe557cb57825143fe84ee1d3e7efb30779e915873dfcc211cbdaedc5d811e1743767e6420a4040c51e2c3f70f5e315648603fa900c217865c1a7b982afe00bc80d980ff227c09af8fa51e3ee1e8537c1919653060f6acbdf752098c0a28ba98efdd0fb01212cc7df5a92bdb80cceb65bc7e4735e05bee610f9faefaf70c2be8a073f3491852c6a7c409cf7c34ccf782fc5021ca3f29ea7192c4542ee693113e148a69f4c97c0f3303017dd2139db0d4d2eb033be3abacebbdeff8de7b3038ab015fbe7ced17b9c03097caba2eab8a80cef71edfc1a8117fbed23eaed8e224307f17d2c77e349c0e3a6174432402b044f38a111d57b3190c2430fc7d78cf26b0ffde87150249673ee8c31762ffbd10485ce603ccd409f1b21b9480adab29a989df14f9f92f2ad8f614d08782a53fb820899423528278ca114454a4f474a11342f8e0eb52ab6624c69d2396c2583e225c1fbb034405888a8bf921fe7a1b403afc36808080522faa1c71717952a031dc3b1f2b78e74365dc0b1f6c53206c8642d127eae40a05fa1915d113344b539518d1641a819f627fcf7746c7369719e1791930eb5ea559c2850648b8ac80861c4c71f1a1a10916eff251a2e779bc873023b06d77b41d229e69b4c741c13a6a138f1c6942e707a55924148a1645222c45c0b6f5f16142476de24f1678f972478029400108a00cb880c6708f4365acc0b41808d335f879453a3a7a042d113bb6e7b5f7105589cd8c065093d4d882699d796665db02d17126f73196743e46f72265541bee1f6804531b87a94d4735997879f898bc58131857035b31777ffee4cb2934c4e0d758c75cd7b80373bd45357e8d8198ebef618ac5ecbbe7c5fa1151889aba00379ddd9d1dc2989b1467bd8d85f7ebf7e083dd3b58b18bb0eeeef6e8839dbf113c9722780dbf9d045a8c7d02191a3b48c2ee4b62b06661caebf7fc79630f0667c5139a05afdff3e73d22c21a28ee04a902617b15c8e0a4bdfbf573944382f9bbfb7bbe648808ca69c60b9b9e417b601a7ffd1b3ee0e4d880d6a80c853c652663587337acdd50044c8b790ce1ab1e84aff2e7f253ec19ac640c6b314eb6d40a42c055c95635974073c7f7b2205e670fbe4cb3de7d8cd556104d8bc1c931a34c4e4142cffb47cac50a6cd3283b7ac44822318dba3410ac7de6c90aa32fafc4101114b70c3720bcea7ae5724f340b53dc498c6bf1c518939c463b38275d181244db97f272a2a3b3fbf3c7cccccc9c392f6d3de0e4871042f8aff478b004999cc1e601c6ccccddbd8ebbd7b97b9db9db77e3c608a360294c3fd74419afdf830f767cbe6193f302d6dd1a83bf479cac32fb1abf63d5de0826bfebeece56659663ec67448c4d42475595a5094c1fbedd1ed696486683b525d2dddd4b647b4a3b647bf4692cec59225de5e4d8d7d26e8411427f858e3fc5d2aa5e96aa4a36aaea5996f5a41cc9fe37aae17fbd0d55eb2d592ac9973f83b5eef15e4544395e5766433f6e31b391a584307d9dfafd02a834aaaa663e58eb1dac45e9d922f05b1deccc331d2d59609b0add70291bdabdddfcbd0203e75cf78e94eeee0f2ecb88c693b0d71f6cd75d42b573ce41e8205ce71e3a084fb09d73fd9e7b19cafd7b7ed1f1ce38e33d84ce41f7dcbdbb25bd406cbe2ef55477f7dff6e7de95600183b96285a5ab990ac1367ac04197c33937849c910ec59a0ed3c4f8d6c1cf6199a3c3555b7e4508e1cbec848270468c314a1d7e8d68b8846e79749f21a584988eb6fab78ebe33f60c2847343cba8dd6d1513df7482fefbd6ee8ba1b967e3ad70dddebe79c73eea4c8589285c9b41ad8defd1cce98d5d10e1c64deb0c97d8a515530ff4d0b01434063b46bf7209c4b30d9f735d7fe5e5dd3b217d6629c2efd8aec4c54877aef596f35c26a4403be3895b9e4dceebe760f3b704d20fad7c8f5298e9594efd9893594945e954634aaca23af389837aad16f392a7ef5562c954e712687bb4bc8f022f5a8068a6922cc50a7c928ae20c3767087df33379bdcbf0c87693ce30c4786d305ecc47f61158f9460694c40ddb8682edac60005d85545bf7e0f3ed81da7a0a0dd06bafbf337c39d80e955554546de17b5e13190610996830b62da0a4642069827fd6bdae904a439130e4370bd03054cf5af61ac397f2a92cc28606e27059c4ea7d3e974caa1323910718299519bbe809a0a1db41196bc7ecf9f7764d40d4980de7bfe9ca4fa5aa3833953ec42843a383848a4229c85333f6e899d9d203b5660c1ee6ed3d06c9a768108c484859a8914371c61db62f8b6f4a66abd9560baccb25bf55e611a46627cf32746830ee183cfc130835876e102b6ad0fff4cf113a39d4e33393a6e8e080d3d39d24414a7d3e9743a9d7252806dec73f26102867f9e3869a593ca9c26f39ed486e7d545c0bc446facbdfbf5731ef1c032e1c764b28ac482e8803b53d5f8da69820f112245889060dbf69c7a86c0a498462f1f2208050535219a1b6a6e1a4ad3b4d7b409401930c371261b54806d0c04c4049e5c0d94d12ce4031b4a2d2d9d6117c768afdff32122283c7e18e9e1f9fa3d7fdefe8a520522fd5cc96cb896ab840035f15725abf480d6d4c4eeb4794096d80373bd6532c63dd107c5348e089122fde4891327575cd1a40993b9699aa6695a0e36b9cfc1010b28a6713e37f8c1ebf79c6558ae3bc4aef184212228afda2f16403cf5b5289e7714495acadc5c5cf80626d8b63f3fcc404344507c5a7b01c9a016211b50bbeb2bcbf16a27227cae3b7b374cf32858ea520936cb5db0b43909a67ff3e0e6e387250622e59584c89c7a55e2ccca162e3b65f08135a1671a850de123826f3be57818ae19bd62a3920e9d3662a808c771fc3d0e0ee78793e1e028451cac392f6055c90de1c877590faca11c6ac6cce30724574604d30a2d85bff7f62d33ef430821fcb74bc4ddfbb9f773efb7ebfebabd776494214bb1845dae08330df7ab7dc7be355a262f06afee41f74f4387f00d114159c93670c7e8842a314b3848151ee22176e278dc107ea2b1141e622a6ec70999ee9f778cc638d818c9a4e289a955d66750356d8c646e3ce42cf0214e986e7bd1b8a8b95002dbbc4811a6790232136ac33e38e889d188f0a1280a17334cd35595654130c5a9d48c869026bed48c979af152d97b103e1acf66a466c05497092ea6d1d601cbdc1f690c6c87e395b9414c8e23d5f6d703936377cb6bf481c9afdad563f2bbaede7d4c75314d1341f99906a51a8cd6905093c78fb9af3a73df470560a647f6c8ea3e715a263f1bb442eba465587b9d2c1729988cf5611f159c6620e9b5d3ebeab6ac6c3b36838197ebe2466dfcc6010e40296a4335401900821e2a93c3110c6fd4c67b0a3e2722448a14e190cc806ddbd333e4f4989999b50984da04055058292ee22286c251e8e400036c632226e22729286e681540b8430522e810bea1202127344e34cd3d01db5648a8899290a48bbb7b555553f66b20e9d40080ad061b38e0520310bbab23c6a7043a84ef46131a7aa2314dccced41dfc41414242397c3a9d4e454551a250494d1e3973377b895d0574081f7c7e5d2e2e2f2f303537dc198a351bae88d1b58fcfe3e0189203a55272a8ecce0a41ddbc6abc82890bd3fd86000dc374bf2da0a43516180d816d27d4699f3323703398579baaa66da3a0408a2387ce0e95713cd4e478a2b041a6734d9ac09c50674e601bbb2017238675cf885b8e20c2c47d69bd04846387b183bebf0efaee3e04feaea43073615363320bd853e1832bccedc47cc4d21f9410d242480b283f509cdbe0101fbb0b86e3cb8be68af5dc624fe7fe456fe791ff65f3b930f02b1f5896aab2bad730ccddbcce9fdd7719863575cead7bfbbc9d332bb373ccbcda0e33332bb36bc15a67d700d8c63666deb25619552765dde3f3d8afbb338deedac58e0d9f7784cfabe817d67bafa5e9570783edebcd5a6520f4ded8cfb5eb6fa7704af9fb98cbac9bb461af99661f3412218470480adae7d160058e073310f99122b60842c2c303173f4158010f5b502942944491dcc1922e9a54d1c5130c3006aca74ed10591c9075d3cd186740125092225446a300322b438a245920dc8dce732401865f7b231b8549300d574360603d4c4598c262f99cca2433cd28177e7f2af940256aa02ebe74b4d2f231c56a24861e90f48489912450b213f54621005c67b0d3a8194a94127e862eacb6a6c357ddae8500485a5038c11f74cddfe0fcb296408172ec32a4c09218410c22020844f4addc27237fb9dafbbba2eb391f79c70c2df69d7775f73777f1d3358da74bc533f3fa90cbfe7ce637c8d84b5c8708d85e53a87cab876ce0531e9288e080b735e776b672eb2d6ceb96f6e02e327aa6ae0fbdf85fff103e27929e60a6cfbf8de1be2ac192f01ebdfddcdfcbb5b477392d7ef515fa639b42efc8659103d3d6329b8a7d52c805c6825444586869c14a181326099b0c412459ae05004b6ad90d0154588526af386869ca4b630379da2331dd217b06d8584ae48a9cd9b4452284263ad3252c2779aec1f137a0b163688bbc2ce921aba055878a719f705f7f71c421dc23f7952852a40010a4c60021290d080b9690dd0344dd3340568cd05d4a4b50d3b9a8f108478788444c1644811137b647f36898e0ecd622a16a652406b58244ba653844da11bd514217c9d18e1f2c408e52e0f0fcff22c4f559d2047336c11e5d3622c2dc6d262acaad262dc568eab7e107655599f62ab6a29a5bcaeb6b690a51baf2606520ca5d186aaaad0ec1b737fc75f2e8b18049ea1a5a8c1080a8542a152286772989017f02e84259e6ced0e0d64fab315a55ef2922069a84b357eec355447d5b875db31f78a7db590114c6af3def3e7fd1bea0028140a8532c0d2686035f7a80ca8cc4a91496db897f939e66d752b9b951cd0c95b6b8f394d406de09394308592b4484280d668cee4da5d8c1849d329801c61f2db080a0a7a95d912065e7a6ce0c6f0a236ec2f4a524db57d8ff1e5a53be3f1638bb83406662f31103f5615b73f8f511b864668fbb2022f6ada1ca4c9e3c7644c4dcbeb8ef0d81d82110f0d63bf0dc86c87fb63eef36a0c765e6776eb56de4329af070584fe5a922c55cdfa8dd1923700f568c4157b0a96b8e0744ab91a949af8af203e3ee48e838367480e873dc43804db3468eaa032ff026cd321140e1dd446a5081eeae66d2378dda81bd40deac6279883a8b48d9b0731ab118004100053160000180c060483e180703c502451f914800f638a3e745234140844418e03298ae228c618420030041963084146a1a14107e32dc3d1252b309dd7fa2bc0260079069572cfdd25f0912778bff438acfd9fc4976d00892659e065144eb16a5cc5703f884abc36ec39236ac9c68d22f6e8dfa9c3a2e0689183a8b9b2e418026f1413a23a74a79d2f4fc72542a96905712f3deb2e4531df19e7c0e10e287f6d526f88756e52b727ec51c9fede104e2c3f650d0d090a14c493773849f2a8d8e49a7722596df977ff473ddd6bf929325352d82d02c772d2f10a1ba7c21bc6f6669c807882078fcaa7754a09af00aca0de2b5c291d08c12261090a0f716772ee185e9a3f5fd7820abd449c3d71a03acfbabca4a9aa8ead156be86d6c98de91fbfda227167382dec6ba64cac7a1273009f2c48c16793ba387921bf88293cc582e19e2e058fbd918441e4d030758968975a6bc2a24ca886e9161b84f4f619fe4cba73e775f2985728c8d7cb80f84baef87cc221d1fdffdc0e8b36261c39ef596fb889522843127c9f02c5bf723e22d9c77103d53a8b3b467cbcd70d441bd9043c416a5b9894e80a28c580a7aad37a643bc85460e67af37ace7611ce4517666e2d1737b287fefbf53b37ddab7920e087a6ada1b2dc7a9222179c8fb465cd2c27124757e6476fb7317b7b070896f2b2a5725683da7ebd52634c1d0d732d25de98b488423cb0a07be5e440b8c3f7173c48ab255a8d4f08920620a0b0262ae3858d66f92bfc215a462f4ab9ec066a74c32c4411c77cbf2f2af5bd97ca2a0b8a4f34ace709d8862ad4f5c15a5f074acb7bc720397ea0e50f9b45f845b7fca5925fe750af5e3c4e039c9be96becf7affca4afd7315cb64d276a998bf5f7aefb6d64f70c4e0497604780aefba6bb9580ed4470635a02ce349bf79a2c87fbf87fb17def7793ec92667a06c322b5a46ccf986e89e52c221293b95c33d2dcf5cc8f9fea810e38a4c257d615f359989c57ed79212a9e20f04fd1e045dcb9619677c2353b809c48787f9c1f4c119a01b0aad3a8006a23623b173de268a308dd1f286643599a366c277fafcc6b304e80fd667c9474b61fd6c82a1d998cf082bb8c6dcf29da4957f3286bcb93f6e6d497669a4a4084e54222410d0d1c543030fd0e326c4c6903bbe3d7731db407a623a41a3d7f5b6943a2bb6fe63d2621e6eafc9cbd408e214fada0c4f7c6b7003b9e22c9ac29d851bda1be502af396da6567eef582742cbf80bdc1756e1974d332d2a90507934be2ddb9916c97c88fae15befd0b1acaa06cf0ae97b65ec5104b13e2b729a5e9c117c6503c78c55cdf8e2fb3bc1ae62becfed8a0aa76989c8e6e84e9bd4a66d308826a604d0a170d1dc5d37e88f9a1937630bed3ffd4ca3899990f005511c1d3999bf833e5ad7136548c3977e96c1f9fa6a22fb7f72e12fbbf9534f8bf7960de7e0b86081a2dc883200ef0046000d7b5424c4bdc443b374118dda2a3008007b99b625e52eda4b3d2180355a9591ca6dae395db38bd5e66ee8ed179ce12c97a46bbb4aff9a361f481487b12943c8e7bb34c577a180145288b34353dc659e999fe6142f6002ea0437a472dcc4d053ade531d56f2303a59c22a6ac0f213e5cc2bdfe40bda80bb0f41c4d73525fb8451d0c2506db1cc6a1c0948b986c243423d52ad65169166cafb029e770de7a25c6100aa75cbd122a5a29d5d2b23f92104ab1bc0d8569282a7dcbffeb66251c490c005c6f1c40ffcf6771f2230b80abf8468a92bcd8da023a0fc26269c3d574e66c9943d7c28614119e4e0a7b71b54a4a2b486bbfa9b8e6c996fb8cec6248db170f020a560765ae9df90214c5b1623cb33588f87c01effd151e26bf3b45650d0e2b18b0b1cd23b04842df3e687fa28de7aaca8436702c7a6e166569adf90da6e9aa1c0fd0c65f0b64812a2d1dc6a63924f3d3e2d13d648d97380ea56509c53526b002511e933543b46cb09463ad4bc5c3e4b121bf622f015742bf76835417224e5ebfc63bceb42200f80579eec1fe471a30905bdcad33ec7e36a33b3436a2617246af64f9543a422f53369a5a6e75eacf6b57307d8410b81e239cb9c130d45d143500ece27e0253baaf3f1095eb97acda7891c5755725c9452e5eaaec3e5fc740e707854b62185f74d26b756a599c8d82bb8126b28f0f4943d59a1c5d415d5597bc2cc0f643055500b84a455a768da16ee34a57696cfed198c89b6c509e0e2635c585229404e76f7147c5b6cc73d03a083a78e2c7ee96fff9aba14e925e458618540e171d3c929a094f3c396483ff9632e1c5ad8bfbb611097a85ea23fdfc13214ef0ee3dd06b67d805306a588029dd59873a9a84882ad100b799bbff483b44a54cf4af18961fe9422b20d9a2bfb20955115995842279365c97d77b145dc2d39b4431b753ab06bd573bad8a76b55d65a779238ae2c748150473a9bf3ce516a3283b03092d42f17d0af4109d54cbb324fe109a8998e40bc4341bb7fb2724ed875bfc04aa78cdf12fad6e0d73bb8370f3cd5dea055906a1472cf2df66e9f801ca39d174db1de9da875f416b7b1951d55a7d0a4681efbd7843f769ca8a55a7535f6dcb1df52df8ad8e82773acf407d7228d28b92851c60e2df939a7e5143b1a3eb0e8048ae7cc8a415bc276c6996d73f790f9f08ff254c4b7403481d0902e40acb349ec5f48407b05d5768d9fbfa0e5cbb88be68dbdc59740bf05ceb10d6785981635a8a871956b99dd85d25bbd2e8f5e5b3c44a83e1edc5b9efbfcb9cf902dac53f413e8a43b0942f521e2d6ab2ba237705f6bbd5d8d797e3f788b6d03d87360c5abaa967e74ab22d93fd226f5ca5b9a19875511abc0d883fdb7f060e520ede22391ba4e86ee181bcc5a1347a63ba29968ffcd16cd8c972382dcec61cc72083962a8ce45efad0611d940195a9b97e0b8a162d6e601507107a40efd12b09f455ff7953a34a57137a9cb7e7d95b8dac2068197c3786d8a8a11ba05213fe306bc99c070670be8a0926ef2a4dcebe3d09ac76ac206317c7c4acf6547dd51313e7f979092027c7951daaf7b24298a116736cfc1a2bcf90a91682571c325595548ae8fda47a62d8eea2670e7dd1a5d91c7abb4b299436ef807641cf19572ecc6fa4662979e1bd145efec0c26e39678c4d6984f45e143130c0071ae448a36758acbcf521560913c2600012135c879bb8dfd75afe6f568c571899c22744fdff38d2fcf8d72b90a691be4dcd0dc71d32953a37d0ae133ec1607304c42cc103e2092858d5301cdc7bdcc2c3d4090109071fa09e20142cd062af13d09f1da11e77a0711b97d0df886c21df7d4f0f23f5faf5021eeaf942bbb853d487048766646b481242ebc5e74d5ed648985208dc9c6a61943e7962a625c2d705fabbf840893302d6346f729c087c7f9d34ff97cb9ae3db3b49a215be9951a728558fcc2564dba3cece45a34799c181b5e2c6f7b03f98984262853fcc2269c93857a68ddd8a01c8a065737585202aa172cbaedd78228cd8f54d2fbcd24774d906e64fd8530170dbff84127f5ffec779c7e2a6a57dac009c357b00c9d63a8cc0c30ea20b6dd2b8916eae0f07db64199a8eecf0cdaa0113a8412866cb1336877f0c3d8a8800487888e03e0b0190ab936dae58cbbf610e0ab9e835963fc570b902d867781327c76d5d876268ff6642042c59415be738c04c48f1d46aeafcb171b9a898ea95bb7d2a142e4816ecfb96e5e67eae12f7965312111560fecd486b761bcb42054664986ac5a6781ce7f85070a611eea49fcda12684238fc73f90dc2d9c46ab11fddd48fd7e86d3d8f119ac2936bf1ceeb6b1424bbba8f0ebb8d1dcd02442fb92aaafd9eb9c028526a29d5fd1d34b5ed9c150cf915b81de6034343ff5e5ec45f1cb8cb82e2a0085772a728112c88b88f98caca38228e0479d8d2c4431a44dd7a4b43f513b037ed8a1167124230bb62434bf47786cad4b5ca2809ffd7af6a6c700b042d3c1d74e0590193f4197f65fb37885d86ff8a710cbc451f3cefb04bb7e13a538db8cf9cea37423d8ac44e016d8cf84c44b9f63f01b170b0a8abd869d824a399c46240043293b24c567b36b5a1df40a3119d4d17b5b2f21c70fbae7aa256159a113e1813f0cd272c8fa1edc833da0ab3910523c2577b1dfaff6cc93c5ac8f5ac33ef680c14786c6fd600f2dc180b9e96f63c896e35e43e13a60b05224f8cf11fed8d85b859e75d0341235f73e60b8d385efe0db1ca614babf3fdd073b7ac3eb03e5e8cf34db305188031b1899e9f30148f444074691256d7fdfcde7e7251e08697175d25b1a2cfc6a69e63eaa08a3bd3e925513b10c766c502eb616e5e2a34545682e7f4b12caf7d6a41c81197553d3185bf0fdaf187ca54fe7cc1af5c6463a41ca786c4d60e76a2cf71294fb0ecdb9da3e2765f679e3157bc48c7b684116d5e76a13a0474db2bae834e93e1408944a3377a0ee3e48e066e1a4b6d164a1f0dad493a8bcda73c8832d256375f7c8bbc3beecc3523ab3ff53c4b59bd5d7aa76a2d617df64d87743d5601cf306f1edcf67a742b2462e652fdecd1fadd5ff5a188847c090cedbe91b07f11be7a0c5ead55724fde695667b2748da1dd4b4ccc16f3ac9d1d12e238451e02a6e568299bbc482a695d7907131f1ff76e69876570e9fbc590547d0a578af61018046788c64f6a36c1c683f55c665e5c597f3f3c04149894547d691cd93a6fd3ead19c602d385a55ae653847f812c071ca623b58cb4aeef98861a58432e499e991c33d61004b102443283018bb8ff7420a1e0a0bfd955e79fdaf57c438b6687a7c382a93a16f78147fb2087a20066d0cc3645e4a6c0a7b6fc3428af50826441e7bccbb84c92567935caca940479dbd78b569d9dae0d693d0c83ae597223bfe23024292c36d1e3bd9d755fb4d7d59db78e75d9ab5c06af0de5582791b223606790bbaa6169cf38fa2caa82a1e46d549938987a9ec3de7df22b693c620f3b885c37d2a604e78dc26796016ef5b81a3274cddff09cdf898d84f9e1e990026ffce732c37cb35fcbf8f8272c3613b9a2b7312caa9b7556e16bd7e8ca811c85d8d59d3e358c1b6f44fa9449687a01a8da8878ccd2b73697f225667ecbbfcd166958d2185041ce9b03b0908070f44e9827440c7aa87653f354fbdd4589ff4ddcb27cffe4a0755aa4b1fd51602dfb3c842dc1c0ab78b748c7afd08d1d5418d874921bd0da8b447839aee22371fa4c2ca4a182ad249704d86db449ed91422fda4311018c7da08645f46d7ed8eb207349a1cedf2e4bed7449c5cf5615c16b887f186aa44e69e0b52cace5e8948b190b19ddab7a7fa22a7778589d3e7e1964ad2fbc142063e0adde6750c238a40d39bd93e3c8087822c869c4cd8e12c6d075ed958fc7e06a0172d99bc4328fcc952c60069e14c70427a91c43d8bd5c650cc874836224f6157563aa8af9ab1e1536d1e6967a2d8409959ff1e03b6ec44f46ae70b6d48d1ce93c1b3d38e1466300a3ec8980e9551ecfc90299124b957dd5062cdf648786c70d8c6596e8b57d287eaa87aaa1116e406df1708a2a03396be27ef79338e1498a8e82c747b099b2a791827cf97bb4b70ee24d612db8f6862a8bdc9553d831114be17ba9a1223d6f919e952174802a755753337a7a7ad63e7a2d9e3a5d723a2d530bb703838b20567f34101fd1c40ba07e60ed212f1bb6b0c89f963bb1133d59dfac88f2eab5c7fc146f51d321f830de09760ed9d8afa6c4e50bc02bc560f6d2f026065cc14107471d3b40b4ca80b76a9697266e6a58b239236ee06ecc25cb4bc5e353bee892da74527310810cc6eb7ac3f1f40c3ed7cba8ddf8e270ed0c53966b98797d06c6e75d7b55014c315617ae4560af12e639aebf60232b7f852ec9d479010b3f328affea318075f5731d1f68f4066060977428b1cc935a8a9681b4b144c394f8719e80db9d01f23a18952387d513181ad082e87264ed2f6ed18a4dc1533d0a35997712718bedb972b873eee40a2a2df8de6739aa9e322bdbc4fb71601e03a5a5c05da08f179dd5c2a1eb3076383d052ba2790b19d992f1001eaa70f61f17adf456b6bccdf0aae90dabb80cb0bf303e5fc1ee1fd129f74198490dd877e7eebf9a2df0e6032432bd0699f0229803debc0da4e58ada9f4979551a51f5a9cac181db016d4dcf17090910000abfb5d7c89f35f803f2af27259ea6f8c3e8c2849e2332697a89d5020f46ef07cd770bf1540fea48ab0fd336905e9c347d3379fe41f248a388bc004a050d072f381513f64f7843802f865ff3fd9805a10e93685d59403122f68d2bd8871d5157867e9b7635842690f6532d70b4cbb22b930548640b9cdccbd0ff1e6928f70d2305472d6a13cd4513f6b46745ff86f54318eef2eb8a023ae06211e0f6923df53f7c36574664c1987ed1df5c5adc085e3e110ce91cb791d1fcfd9903b38d3d6615d3e90e75ef81b27de481e9b454dbc9b4994da8b4ce704616499645e019c21d90d0a3daa60760832019816978fda118ba67f67ea0f930fda00e275eef1c1b17d7973726cecd9b75308f9631508f0ec34f606cb92a5d1ec3dc747e44b22fa88827059ae67f32d7beb422ed85948e4bcfa0b9ae1b7ed355a3792101e67619c9f2cba9c440d7f1c51adf1c21acbd7c46982c09467c4463fad0175f16ad4b1130b9ab20671d412274338313d0cba4caf1202674d2144a9501991d4585c8ac48d00cbc0828bfb15149c7311e1210949f74beb65e81a49403401d6a669621b52ce362a8911f04a60ec415980b78fcfebff641e093465091403aa4206bdfc7767b97cc0c8e6da82e97226ffd6fd40644aefec499a666268996d2ee7f27f50c066d97d2118d118b5f754c83632a791765e500002121ba23234c49e17310ad04be4592f31221ea5faf4ccb80af8c14befea77e4d3e1f1e056111a19ba29bbf688736fcfd4a1f04cecbb170dcf51c542ff6a3df4610e173c2d79d0708f976a75f7e1e6d8476294a62af717c92afe490d6221f5d1cdff520681516f47161480fe89c043257c60ac8635a3c57db15fba1d3cd8d71b5af4b121fa3c30e27fd2562d953e22343c816317e90fcb18784bebf259a8a3705fb249c4a74f0e178190bbe24cd352775911b53f09467fbdb3de80c9424a1f73b15e82895886920ee8147b3d1498a4a123d3191e680cc0aaf7a3295bbc64eda3f32fc3aa08764c2492ec5d59ebf4a002b2f2f1d42a6308a00fda7fef23b5c892317b24b00abd135a58ce5701c5d868642238cf32969f264e28803ac71f5483212c94b66bb0b58a719a181025d17f1cc381b9cd7c3c877d236ab68be2e5ca94cb8a3847b7da3a55af18b0dd460742730c790bc19130f33f6ea11019865b1ec1937ebb98378a26a4085c04b00b21d1a62b6b8e116242c5c303bd0e5971eece4e54230ba9ca99cee962b2e89319da81566eaf50dde148327073f93e9a275a665e938342bfa3843675048d0ef8183ab4bc015775e11722490a02c399a29ba427133a25b618f164b496807784f5d8a5f6ac49349d467320e740c9eb6ea08604874f07b906293e8a71a855298917b7060a845e40401ab40ed74082a31a97080605ae7626e256d4e8ea3bf68987c2f0a7b5c653e6431261a0b3266307673cc330c8fc84441abca6d1a95707d621a2aaaee762b0e01cfc89bbad795fc71b5bfef138ed619cffef71b9d05e2c8d394954c5c21a07be021318035bd3f2dd890eedcdff3d024740c9441a4c228651ee48144a1610886d52f07d52f80046620d17dbf58830fa30d1e086cbdde0e8798379629693a9b107643fd51430f5c20e85f5f16084b0a5f5971dcdabe0696c0fe41e1de64eab245d2a2ccb4811b2b2a5de54b57357a9a80a6bca9a79e1193dd1a9a6098ecf8162ea7b2c26a21484f08d32daa41b3b1a1d9826e575bafb7eb5d74b28dd46ab98f57d2d3712fb55a5bd55b955b518b0fc68ac7b9878e61a3c69c629916a6e6aa084e4fc17d47f48e3f843c7e8010eb6c8a88d184400f1bc4198322c1aaf55863fddb0021d3b3c0cf4fee7b2c685617f49e64884b3014e836c0e02a6c59516affa8446bb119c87ffff6b2aaa2fe3cde9a54204eacc1e38d49f3dfd656dda91b5cafe586f5655de7e4658625b600c1dac54176c7b10e81a2dd75f2a25c9743ec394c8347e10a225c2e0e5c0c26a6015e6aef8bb078fa888329d40b450766d639c041d3fddc1048f99e847b0031f09ff9acd3d97455760c55cee5709ad1a40339f879af2509cd68290c6809d3d0182c4cbbd8f611a40eb62ec1c72557edefdcecdda00e3134b5b8e41fec0a003dd2c3506b4bb2dbcf588398ee49040bab7460f1bf2af4cd0d061dc7126e54988505e64f596be25fc828a0c9f1b62cb4f1c5973f0cf9ed439a4dbe68414db052caeefe64008b2ea722b080ff3d0fad241241999f9468ac3bacc28c2776644250268b7c3a4b3906b4b3350a8d141023797459f6c02ede1b74b98db06bf44e30822aca84daebd80d82c32291cce91ac304a80b4869dfebb7151493169da0c419e2d0edab5813aa2febddd1dcdde643e97ebc2ae881074762fceb1dd4ccf9a57a03ac831397509fb913f02663d6ed03c2e03a41aa387fbbc62ef16d214744bf9d96df55f78392a4d25ccc34c0aaa7ca7c4cf3dd47f508391df3e839db57f7b93838c3dddeb73e8e75cdb8898178c868e325028a86eeb271394e8ca2e9b12fb2f172405d6322ab678a404b091aa52cd18978cd32230fa2e4e6f04ebc34faf5bab8f35e4d11d6ebb2640094da629fae19de32868d75ed825f8864108873194c39ebdf25417c4020d0f721ecc4ef525f3d36e4dd63d62a0b878a91a1662315b440f3b1c0d04140012744991c2f3585dd68bf73bfdc804e394ce17c9801074e8b270c616d0160dfb2e0e6435d3020f45de64f1fd55e1b93dd17ba2e6e4a2592351b44598d732114a764c45c895546af728cc919bc4013ec5dc48094aebc1b477d396c4356aa4cd233dc3dcd322e69295e6e246af8bdbf50b410d86136e0e38c5d2ca1b887f07a99d610e5f6b8c4ce27793c1358ab34ddcf63f2b64b65c6ed06207810576fb591543600107e80e49ca619c14936c4c029fa50a4cc2034bc398da83ab6968452f451c833f45b3558207004dc060e77e437e06a17f2c93d4405316ec26c3066b6c828abeeb80ca85c52c88b8ceeb1012513dd2e298c5625a4edabbd1e8b2b495337085df65eb7f05d12e1d03e1234721541f85546141d233326dafdb85a93ab615864e96c46042f700e6b4e43bc65d454b7798df39359e2681b8b6fcdb223d2723449626f106fb9187e043e9aaea82be91247708ef1111f31a46db2788234ffe29800553e2d3a7e73ec9fdf41e6e95ed35c97a4e28513baadb0ddd952cddfa0b91002c46a7a82d802dc73f66522ad3639f886d7aa52f32bac2f1564b819049fd87d7960cba44dcbaa5453c9144df9d684a708056a596309922cae60b8c123b88fd951b0859816791cc1f7232d01ae4fd5d3ab3bc7e15dab9224dc799c934e89e06d231f5bc475a685d4053a9f3991434416fc83b103490cf4e1d882e64fccb6d4aa3d4d19cee4f91a11002ef25288c2c0085cf053b4e7a81fbd1df14ae177f66382c271f78c0f605635d6b53569ffe09b339fa90e3ba63c08a25eafa97f5c554f65373ad254c359e79ae98404b5570793d20f9a92a323aed1aab908769de5c0dfeb13a808b4a58b832f4c6e2e9d0c890e8aad48e063c1b82e04c83e67e34f67bbe963404148bdd8cf6cc0797ae998c84068f3bb3dfbc592af6268bb39cda9b9bc55513933ef62ea18d2b69b4bb5f9ae515f718a77fed7363393fa1097a126847bbc556df26932a3797968dfd63bc928f7c73575c72fcfcf38e70a93e80f9823096bf7b920c2e2cf69be33486e7c90f78c01a75a0770ff0ea613452340755cd0c83696f19beefa7988f5a0772eca56b3db6b450d829854867462465d88a5b278bdc5b75a2dab07cf2a47b4bfff10bce98576ba64bc72cdc12fbd7cf0e675ff41d002582fdcc5ff80d4bc476130ac8fab9729e746a2c9a23782bb57ee515d01f4036042df31593935ede2305d54eb2bfa4cb64aa752a952f60aca5fc8d4fac98175cd697206c7e0961674fcb1031c28b2c9ae9b2ba8a8e861a009cac598eca6a72c26541f219f2a074cc6b88040008d5234f704bb44fa1a28f8b1a4e0aba961da23eb93ec452e8b1ce6d450c01de456eacbedf8845c0ef1ec507aa684d572a6c6d510fa3569066482f40cbccb6d0046227e45264a74139d3a31106d13764b6562f82fe0673351facb4ffffbdfcfc85a30b99b3f2ceb38a6858a7d5006283ce8d2f9526f7eb942a8c886736df899e7c8c6388c0600b4479ff9751013380d0c640ef9445c2e8a9c8d86e75f4ab0a045b12cdaf1fd0d81171dc4396f2b88149f1d6a714e58857f04b954be2d48cd198cf244150c8431abfa02a551d16db246199ac36327142dfb42e57dd990aead33bf41764b8161274801148d3fd506baed5aa18a3c39ca078d08f8b1823c1e0ebf83af0c5a5697407857d580e32573f717dc8a0325c46a8782e7f10af319c230c422a5c6d4f23bcc18e016b09fe90e1a0ee05072fa07e799abc40b7ee9ebc2ce6d5d835b05c7e17db5c1c813d05ef2d3b9aca1d3388293edc512f0624b95a8ca8a15012abf54b67348462b4efa5ddfb56491804236ead4d9d2ec0c1dfbe85ba3a47ed59b12c675e19308b515132b2601bd62b2a10fdba37550f9451e2bf5c01bcf6e45fb66439bd2239f2773c38739eb5c119d26c9a38d6c7475726dc8f6db7acb1bb48d5cd055a7bbf87b22d3bbaab0937d306a408b289155f748d63683d464341118270e86b631c2cc6448e34abf3904d6b27104f80e8762c398e39db084559ae88c3309a52a999bc40be1c09b8ed0c9bc027fd753935ed3cfe4875ec0a2354aee2fab065e1dc10b9f428621cec5c23e4b9058701c4efcb1d81fa68f5a6cf5b87415cd1fea63d5e8b74bcbbc94593373e9aa8552754554da69cce451d28770459d622b7eaa0e057f5a5b2174ce039c40fde8eedee81339981f5116e4b27de56d4d42d1235897cce28375aa95508b14cccaad574859e1084d0b9d581a637c14aa8b132a66c03d1eadac01a2fae834b083c7f606d911c5fd496059bcab9ff82c12da259eaa2d115f395c2a91f91ed154e22e4aa1a8e05e4527c4a19943cfd1c42accd41525586a01fff8e66fa06c876b2e80be2c22f1aa9c2a57860e18f78704999a83257e5686b197feb97f9ebe47494586c34ff91b587b68ce05700b9b72b94f28f1522f0f08cd2a1be22a83fc826daaa20552baf3c9a9abfa88d7313d5c99767482814d9146cc431edaf7849c12ac1a6f7828737acded992383d8622847980e30d116b00e70eec3043c839259601e7378fab8cd9ccda075ba245fb6a1f0b62cbfa3a69b8c1ae753c677f517c8e52aa5e8f861e54264a2c43e524a8e36d2fbbb8b949adcc2ced9dcfd09e3d82f3fd703acc4077cb8292f5ab61cd830c6d43be9855461ab7e2da48f233d53df31c37a058045c76ea4c7a2046f572f54873bcd2db17e78bd488e4af2002949bd5f3969f7de5f7053dc844a28702de30b8b104411c2f8d6bd527ab3321efe83947ef3318732bcfcc6a74e43800240fb0f028e53de04540b80b7ec1bf15605707140b0c57eafc8efaff8182bffefa5627551462394cd8ff91c3f3e1e87fcedd3cb504cc49a93cded15f9e2eb0f0c27732a2cf846c6cc77da5b3383d3c2a50d9d87b4ed94472ea7b55ba2f2ec0fac5b98fba936aab4bea63e791b40bb270775d8497c078d046d3069d28dbda02aa3e6ae0663e83bd102dceb4464e80d0b8d4bd19f33568075f3d508c1bf060ef9bb8a4caa0d15aa6ea98a120a1b6a6ebf599ab1b74d526edf7c9e00851465f26843bac5df8a0a3f604aa6cca8b088ff5859141a66dc6c506be24347086309fb9f161cc2b035475a3424c0ef3eb0f70bce43c280698aeb960f58fc608e662f4cc046af85219b88f460786c5b78f97aa0fc8f3e34537ebf86a2c0b4f5618d042b5c99c428068c3e79a9c7997d35fbd35c0f93439e48f022875a432755d5cec569a6904097a1a99fc1348413bba428fd672553a40c595da1e721838e0a547b6ab1a1f1a08e8d4265f2f9273258f60379ac15bd15077b8656239310758b422ac3667d1b14f4c91c88f6075e742a98b5ce08d1ce57e2643333ce97e42a76083f8f2cbdc484a152ddf43f9b26368cea0cc58987dbc690527a80ea8cce61cd8db7774a6563a3cc92983ad3564bb0e83be9b52bdbd32aef41193da50cf1e1a4d755997a5ede7288e4d48f43876080bedd047309cf83d2f651054a42719f599343978dd444bc6d0f3ec99f30ea4c0cd2de5e2f642784efe7aa4d595e3d6e3c528d2c3cb1f184132500605e51c9e2642a5db48e116f650905e49ed81373d1e2ed86726604938149e5f33a7293a013e9bd0d43d29f594ca0536166e33987dc61db4e0917329cc93c2833391f398e6a4c0383fe4a1fa1f709d9176bdb92536ab646d751e59dd02db2d7a9e0108409e7170277d5f858dac385bd40bce6e0886a7b4b33bf4924bc1f2423e3cc5698ef272edaa02bca8cb9000e4120fe35b43e7e9c801c0cc5da4a93013dcfb665d05f5a954266e20a9705b8799582f8f8cbf0291e681740caadb6cbcdae5eddd814e49c080bce664cab1d8ba040713f0d3849e898d7e36ac411919fb56018b80d403dfe62d603ad6745769b60d0b6046e9d1b4a9c896ece6ce644c2f6b922273abf60e825b639a8034238450f93f822f4d96630af25b68db1b8be58a8316f2313c5f09c6ac8ececbfff4081a9a938da4e1efe57ab3cfe69115911afa49897f0eff48f450c962168644b1ce7796058c260570ba229b8df9f7e85286cf1d38d5ce78b4a9f82d4b448a0124b1dec0f47e0473a5d8d07d9c13f42734ffcd29c450538c8f6c640d56919fc7f230fdbc387130c9fc8eaf02ed16cb74cf7a4eb3816371ab3192f6d82ce8472e42653d22a5fae0ab296d935e647c5a1c5d9909ec6528cf83cf7a4d00b0f74b0e4355900ed127e64baf6836cb8c18985a0bb48b28e2cddd0c83c05ecf088f45fdc814fd915e9207075dd8303281660411f70733f50a661d57d2dfd5a2a296313ba43c7571ee5c46e464826ccbe1a6d8726b67d0a4e56fc2ee76bf0b85c36dff559c1ecf33d4a32b97f81ac0fb3a1ef5fc8db98723f4cc5d2aff315ce2e0a4010112fb97e9b527f41bd67b2a66d43dd3586207f1d654948151cd44ca321e756c5cba9d44b9e8f724344c4e94814d82314394c28733b4877013d1e6cc237e4d74101c84f49ba9a7d00dcdb668b3c3b507e900887d9115aa991fc797609217b6a3de8f7bcb078659a668ec21166c538fe894eb143b3df42cafec0b8a583182ba2c8ae314afcdff3b215ccc60a21dc18b730d59d0d47ec0245c60a65e5440acc76c0dafc93ae373f8b6f56274e079d995ea79ab561fb4c15a5c307b19a617510b3c20c215e3da04ae61b9036685c3b105026d02ab1278da66627f11990970f347d22e47170894f02c2769f5aa0d5f6db46cf3ee996c68ede1dea816bf49158eb9a3a68ea6f613d4c4edd46a9b295637a4c6b2c8c3fe690d61090ad3aa6ea10321e6b559d6a453f716bf19860ca76fe01e8d8e794643beaf0bf322a0771494a2645a95016531daaf5c7a21b4db01c558749e3e159d952b02652d5f81a59fccaf8ae3f280e727c965e1d3fe67ee427e1fe64f1aab09032d7a09f5aaee06c2d4a34a897c1134d9a220e8e0c9b7fb935ca4401aeb6942732c99b8401ff2aca2398249c590f0cfa0d5639e22ecf1aacee33491a5a4e2d78882659dc06d3f0186b09ff8f4bbec1b6e161d164c9a8e3cafa1ed2278a2c8b283a85988884acd6484b618395181c9ba38abe4f7c57aef001fff311fb36504a8b11e9ae46272f810111dcbb5a62478691b84eb9ecdbb514a69646b4ed801f3e8b78e913b89de9cd902244d9cddf12244db728227795977a1814d065e8752d885edf1b4d65d427ac0550bba5417281eb56c05753720dc997c56a08c44a1332f4b46569e13c0568187d8cd7ac97a158c5720167da760119e015bdf1db7d893e0e4a5e40bf0254db2ec91155413d9cfd912a0242e6d27bb974a01444d99436296944c4dee492cbc1a086f250db52ccd47cf478b501332138f086fd367ba991573affd6bc0382975ff0bd10eeba529c6d9dfc12d987ebc49b7954053fecd8d1725f77d75704fcb258c836faf56b7d1a04702903b5a0a7c4c217feaa9b2dcdda821d7eada0da9766cb4996ebeff3fcb283897ae568417b4bda3e3c4dc729a39ec3e4274184316e842adf06e6a528231d82d3c2ddbf9fefbd06f749602089161601e4093f67c4cfd1e8aca4167104346836752cce382ba0868226f0d9428dfce013ed1da11469c158678cd9c8fbed77cde8287702e8bcb3a5f0b12caeb141701747caf5a6d9e694dbb6c24295241a1aed81a7d7e49e22fc0e4a22756e4548e1a222f3da9d318a387db1ab0d8e54a62bc9d2d48a50e98d7db21c18322e3032dfa2d5df302015bcb687910ac3a23708fb32b3128b03f653dae55d9b7370de05305bf6d5e54ee9488f2e426ce857a5fa9b33c3863b5810a1dd8664aac0b703439ca0d038c18b2c63fa24ce3575b5c4f42430088b140e7fbbf1420712f8bf92043c01bc522774d50a33da91a2f22e476bc05dc5d8a308a9829357e1b15477e171c960dec328cd521dcc3c8330ccdf52910b11223069e672ef024fe761a618befd11814951b2015da51ed54193c22d1d6836a6d706f4a42af4ab275ddb9f6ded2339722c9f3fd029b5304c30b07b0fbc0dd092a386b502f802aafd202f554242caa1059f85c7e41fc1d1b866b4349facaba4255b0f849b225b10a513d496c6ce70ba6cbdf166992fb329cf1f5ceed998770d56174de6f724881cdac946eb34d1c506f8ba86cc69b97d90c8b2a0e4400b54debe16e69c6654d2b9f1d36b34f80272169cbcfeed61c5a22f146da42a9b3b9411cd790b2a8b569c7554557e55e555d10b0d0474d75ce281cd59fa3701545170407dc76070bc03e81f6367175d54da3f9dc3d10534fd8869fea87afb0c7f4c527066fb025c2ebed3f5d8bbae1082a2cb5acb1b7bc659ec2ce0f95ff10d8ba2cb1a3ffe56fcd2e4eac18b5216cad870c9b81f4c29acdf211990dff82d7ad422d52e7f8d8b097358a596dd3f19dad9315fb5c51f1f9ed9a0095a396d7ee36c07d1320aaaa3df05d120362dd8490ce469a55b89b0b1bed5fe317edfa1c0e19106046396ab0934af72be7be909835f651a153c2bf208269ee4270067ee0c6dc0e66a52c7340c6d86da2e5dda9dd30d8f7a34e931b7625a30efb196ea2b8b1a1fac2d3250791c79f3ac92a92684107218119ef83d5374e4d78538b497f7ccc8425ea5cd1b7512f0ee1ba2bd1c5981b9f7741164743808341b91cafa456038417a15c049f2169a44e87cc50fb549a62cdaf0cbe85a4bba4af70adb5d479dca07fc654ad1105120b877c4d66f979e6149a7ceb655888f4b51d4d4f5e6b3a82e00bd423b23d334856ed1997562cca85921dfcc512cd01bffa23b5b88053c7d279720057a0933029fdbc049f8ceef897411a919a624198bea23c89b3211c6c84fd77712c9de5b38cf2cd73423ed15de063ead87a817cb85bbbd8e58ac46a202ce112babb60f648eab22a3e9a71e702d8a5e01192136bc1ef4a619d4d0310ac9c14e8d0e80ff9dcaf887dce2795a48416f4e64ae0188a67cb9d1abc3f1e85157bf3aeb6dbd3f6ae40257f95ec3005d530def59031e6360f6468c30a4cd34514240e08a8cc08961bdbaab75590a5692043c17b8cc3d6780d955c4f1792b781a93f45612b932e221210f17429b00b4b35008145482f218abab9870c30e191d0871727ae944c6ed1571978477328fd986509f1276fa6adad31fc978fc5e96db5b7404db0e7086d5b373be097a1390c8a92e617be7848e0856f5a5e53d4376f12c3967fddfe04ff868cd428131ef2444b573d0e7e7899b2a5a869a2ed19da1b2b70453b883e74394feb55f53ccb510e5e0965e2828492022a8a7f88c6f31c5bc6d72f41dca8744a54c562b22401a5dc368d5ae15980f0da0554a0ec133d8bcc023abb40646344e6d17f486dde77ebb0fe3e49ce0acb6afb6e11cf70d874de6c7c2b484e57efde757ac154c4d53ac149bc8b77f414808b2a8b71a3091a81c3710e2a9d36de5747066a9b54cca337b10ea947944079de1791066e959b3192d15ea7959bc1bb39663dd9cef5dbd1f36f20d6fe7b0949c37b7ae135ef57e70de21042b54266ebe7a743089a783920aa537d88f09208d8b392a4fe77d24793fd3484bf6de780b65b2b3fcdcecaffc48000d252076a2d44fde6c283ac595e0f99f8f389780271ec6852f3f63608b47183942aa757f07421b718522199772b50f07580b7e4e98b848e6d5f6d1d784e7b8b8994d0f2b66bd1ea465724f6ab50fc4157215ed830be3e792b0c908a61ae01875698cef994dcf63b8447532893ef274cc25b7a8230840d1d442bc30f3eccce9485472ab1b3ae7a20a7d40089e7d7287048de485c6ade633549feb12cfec21f13e9b93877f32302dc77ebf0bd6f20325c6590236c9c0eaf156777b282724361d3099eb116948601a6f41f5abf30834ed32338f169e4002b3d026231a48a70bef6d6b72cf3df05dfba0b03e4a357ca678b885f3f542c8fc195b52b4ae1e34df456fc42d28021c8ee01c3cc9ec2b6612d17044c5ad99431c9dd7c65155c85b8e0e8760b300f60e4e41e141743820c73b011acbfeb514662c53121e0e8d5e752eb1e8c639dae88638e4ef0334e50374d508e8b31a74acd35801724e8be6f70cd5f0b3c67854283912626aa3d8f2d861a2813752bb55059354e09025da3184235f983808bc11dd8371668c39d49360a4e81ce740d03cf7a4926726b908468029eb280c08f6ab1f32fde9b9beab2ad2fd2217c8c0946e928e49d8e6f901478ab904994568bd4bcca65a92ea0ac847efaf359dcce8517cca9e42c62506ccd0e8732256e1b0250603d41223da7346b75962b6129b46665962307d9563b9813049b0c4d099ee2b31e19544cd33a34392f9a1db0ccd83c7c7ed9598f484247a2d591f0851bd728d13607891ad099345082e1592e7de18e938315063c05cb5cfda080aa52b2ef8e12134c8015dd4287f456aec4b3a842b858e4e7fe6ac348cb0c17360cc32910022ce688921394672bfa1017c757c0cbb871bd85206f64d3c4530c1c6eee1435f61b0356813951920a5626a4a1ba512eb232940c80ba154db09a4782075e87c5cd399bdf80f8a09358b22c0dc5a65f3af50db313913b5bfc6b70d93104f4ea4707ec5c6413e96a849bb9ce589060b725689d5b4ebba4b5306c0d795eb505495ff90675b2dbbf023381e3271c5631ce9be67ef2d838684d3178625ed2d5be716e72fc965c690602f36295f64baaa5507984d45e3250971d9c0f97211b6e67e44a431bf3e7c09566de3f59fd7289ca0dbe7dcaccc49b6e68d8ea5fe81d2b9f793848c2b35196ee684d15d026e802013ca54a2798ada5b29e4d5fba9398ebcd5ab3db9baad6ac6b702375e8d3dffbf6ed5ec7794ec8b28b88b5a5edf578858ec65deb1b6c4c2ee4bde05c8325f9d3ff17a72db12083265590da06ab3f875b0735971ebe7a0048d4767e330647796454572423045047011cfc903a82dde9bbd4338319785fd38c34e19014a2bd6a920f6480c39aa17de8790334c562cfb61494a90dc14a50a95f01a2a82185e63d9190f0caa75a3daeb79f8025848e472da38c13036ce84eb48a79d0b0d1267a7c5ad0733d0bb050603142edeb4a06044d17427b781b27039abe21b17024b3f273903c4a7401957c90709df19a4451e404221ab48f05ac0914e0556086e15447f7e90309edd83a96a7f9ec3bdd37c87e8970f10043441363f3f769bdc48e299662b229b781c53f7d00a7d39bd8eb771662932fddc90d40a2becfec6c0206fff2a6a8ba62f933111591fefb4367cbab6bcc840d8bdd7e052925a878bc1d1369f88629f75c4729e2c7036f652dea484396fd48124f4187d144429aa57e9106d214e7dc212db4365ac8f4e0b3d24134113d1250b3afd606ad1bf7a141affefcd99530f6640e9dde85108b04474ebd1ab8bd673b51ce328dd4e3cdb314f0c8f962e3106b68589df552e11e7903f87527778c3fef9f4fcef42f7822c7ba86ec3e69ab27316a8f96ee6b9ccca6ac3ab346815144563d07b9be14af51fc21cce51dca2aec0910a5d29a8703331df63198139f9004459a0d90638ef7534c9028ed620e2faca92fcecd3aa57cbaadecbc7a0a9159fefd2ee89f793007820d3418991d907e61baa1fc668ee4f8ddff5c77cf488059b9a9b0f5a277b28842588e75270c1e77fe0d9263e940809a7bf95224078a6804448f2c4ea20521cc7b2171de2603585228bbc91a398df4dd927f690972a8ad928167649d34b116bdb020574c04370ed6da5e7f928bfdf263cf1591a4fb63ec147d880d0555e40c022092959e0e7e9f86014334f7afc874940e1f9d15d61db7c8d45ad7698db4b495d238494df84f7074352761afc8f4dc48da95174cd84f9fc02c0f3da4d53e685159ebab0c2a6e2a7af29fb8cd5b555f091e9d20ac014d8e7a32e34b3a030ff6937ca54596ffa865199e49c4e5257b6a5a843ae49bb2c8a58789c4639fd6e769b086f174d0b1f96a187a41b0f5656b8b80237aa8066169d12eb690944835ef2f9160212ec62378a09d43153c9ef9fef570953dabec02a51439575079e680d23b5a8bfe370020ff32a5909aa828f3b5bdb6fcc8af6d75b9f8ae112eefe561f51602a97225b3580264d105ec6fba8dc052d6f9e2000be6ee3c077f6020aee3d52ab39069c4015d8d9355386e7566dbf237d00b0f9326de98cae0fe1c44c4bcf047ccde6a4baf9a7f8b8d533bab5f2dcbea68193da8289a5d068c162002e93047de2d35e4f07cc52b6a65cbf66f8b536b1aba664e41fa7f67e7823b70894dd5937649a7c0a199526f9928bdf722e8aa444c01c8e31e8882a80d5d7ecedffde4637795161d06d9be4960d40ee103a3ca9aba9ae5e4d9beaa8c18b415d7e790c966213f8dd29d4b54ee55cd580d06b99427ead75fed4d1b1ce42a4ba29a9f41039f542d130eb2a331c41ca853941393e9bd1f7596d963e66506c4e06371334b65b79cfb677d61b6bfce635894c06f9ae1d6b5e9144d0c10622a57a934cbca5f6df39240ddba8073ce6fdc8454b74e43fb229e9f7b5450aa98ba4b85c0b14415cdd4433a0ac0ce309c52d7ad733d845952cc7246bdb406ac822d95096e90d814baa71821cb4e39ec432163f6f305c4fb76c6561cb2923dde27c17e5339145b47fb9bfe450c052d893b99e4f7302364433932e4a5e26b0184387bdb403c6e26e646dcf3ea58269f083ee1911b759e9af8d141c0a6cd24a1473194c228bf562426ae37667ea055cd4fd8b7f6c91b77040e239189a79607acbfa7f1038e3187ac3f9f4eec9bf1ce4f04b67a4aeafff2ed629e6ee031d7679774afa270bbb784175cb0a7644fffacbf40438177bb03ee10ee53346403c1a284430bfdd0de66af05430fe8413a26d6bd791c7bf4ebd1acf637098711efa7eae8a6e73aff547a421587cbf508c9b5271e8a5057d136dff739a1fc05f45ef44d553e2b95ff1eccce39b7c5a8447ae1b78a4a6bdb4a09505a7d8f25280ce2a7cde2f6268062a07c8c3985a0136001bbdb602d5713543e8389debcac84df0f156f61dcf2c3e3e462e49b39d3f16c009f8cecfeab0ee65b2a5ef168a9f21ae25e4061a1c2df63a409ab85a4506a2eee736139612ff79044f62bab0a4750e56dde97248eaf9d745346f5a4d6173849ccc8d5f02c2bd55886162c8a795332c2673c7c857f5d689fd37cba093c0ee588926a1f7f5a071ea3452340d41597682663f39de020bcc3b60b0f2c2a3890a4c893d41f26c7097e679a1bc798c3d4bae849079048866861b2305b8f7e9a4a111607c9ba33fa594b7922cbb620de516aa172e6b0d41c033f890110644963578e61e6eaca32cd2e57caf1825fb93bc6f09705f06dbb88160168ac5fa76296042e17b5cccd9c3720032882ff476ff7000ed4dad02d3186dc25bf0b41b02fc53f5a292fe25a4fac97afe7965a377a9fd09779d3e5eed756bc10b6b61bcdd2d354b43ae5cbdc75a2bdeb3a18b6736ffb671d5d1ba2fd8ed4430fca2edd450aad22c253f88805e2bfb44dc8d4a617f37f49bfeadc8b8a97b69f40ed43003ca5166785b30ce424a07026d0563d3624b9e585045b675d6f88af2f2650b0a863ac375b916ef185a765479f0392e82b1fc2c59c513b167383d6704629dbda1392dda331023d02c5379d0573c7b3edcb730b3f3cff125217befbde59652ca246584074d07580746320713d115f6efcb79c4d8398c0a696811fb8f161b4ac638dc9672bb94c7de85d409ebb17320a5443207fb66451e29d163b74618e76c8d1efb8ff65890635e038243192e13aa3d09276358e289e88a8b89ea10c456bfd76b074de4f9b5d62ded9980c3d13770f4e72e98bdf41c30fbbef454a8e1a763b7d66f10cb8473497966a6492e0b6369e462ff0eea3dadad991765cfdf2457f233f7d6124e32dbe06da5c2c9189688a5114ac3d4c5ac13cf3a33c59dd1692fbdd3da7c9a8a9b96b3fd1de89cc9134f3ba7a5d576fe80ca2b355666f369aa8ca394a336b7a320bdd5e6ebc9c9e916576e9bb3d3c0dc3d719cbc76823033a5a1c8aa524ad90e020eed6e5b314867edeead0739daa7e368bd4a5a6d7733ac6d574a99d17a86a33da59436b576d4a7b596a3b46a1d05b1ecada3603d2339ed4caeb5d64a67d6d7959d2caed5522f5c4a29a574aa524a596badb5562ff294b56a980911194ac9504a260d194ac9504aa64c1a329492212aa30d7112c76a3808f57e64d8478fa60c671680016b43397f3e85644efb0b9e0b2db6c7b4cdb6e0b3b47155051438ceebd19cf34e68c9c26915f734d055630d6431a95c6834b4032171b43f7d0b21731ac914125a80c7a389ebaac469d13d9f4353680aa986c8546b8d6a427c35e31acf4f8b9e4bc920e9124fcf52fca4ac1c4824f1a33c82f59c488c9933e69c530236c4d0303ddd508689d6a444492899dfc4738e538ad1112c871fe7d2e4b2f9386363a6ecf264c9044a82708202d49a94499432b36676b3835c2e170fd31b520288899a49b09fde4b930b2945e68cd9657ece897482a04963ce3969d83c0d973f3c0da741430a134fc367783d34da490d92124dbec6b3d75393b3a7bc9e9c8a42c6a71ce5f5a45028f7bc1e54f6a204f15ee79cd7d3d56c79ce2513cff9e6f5709b4fc9b3d56836afa95ef3aa6945535e4b0204afcde035c75e8ff601d2d0e31b24b47cf655e1ba520550bebcc5625c3aa0043de5e95cf434262a86a1dc7b7dd8c205cd099cd0e204d6bad488bf4d90f99bfa7befbd4fb0ecf82d96780bf298fd090e7ffde27ba99080bbf7de7b594eae08c20cab595e13a323db164e5d132c48b426ae89971c300b6584b6262c38920135925ec91f71ee02043008426a1206d0cbc94f08582043e4c48720169a849c9400a8014c8c9c2001c4c216474e9e48c2020c8c6aceb09ab55a926d5e221991428430b088b20598dcbd443232832422224cf9090a80999c7a89f433f4c50f124ffc40e12c2a9c8ca1095119436528a1b12e7d0447d4aade9609218b3c4e8b2717dbc4e4d3bf2ef26c59b98133d6a2f530296b3e8ba40b94c773eb228bf254b756ecaaff2856cefa9defbdd8859e0be93e50d5a2f5e0c81224436d2d097eccf116477ceb2d5abff19166aef8c287232e578b3a8fc67d5db65b89a399ba09123298ca70e5600229685c689ac660da62362c571966dba25a9dcee974ceef7a67860d25b78f5c0d25198bdc9e5d467ad0d57458ab614f81984d6dbd6066a90e101062b94b5d91658b1d7e39fefbc27de1beb8900497f558fa419f66901018114c245dcff51ed02dcd39bb55c9e35ca22658bf49a1ca505b94d8dbfba99f30cef99b42736922993ba6d2c4d14adf48be5b1cee7a08390dd1272257d1cb08cc8fd4c83775b5d84a734787d163cc2a6aa3986c435a5a4899e8ca4b6e400daf81ef837c4f81c8344fe5ac431910276338c2c818466328b9b8202aa2a34498248941248653bf60cc9827a630929e8ee88f112e308ac0782ae3e933901f080864a466a5d3cf34c9a7e9edb125a963a3c2f17a86a8b5d62aa7d3d945e8104dd3d4dedf5376eaa686758cba6a0f5121fab2e16d1acda514a3445a795b25a34396070934d44343f410ee21cad44df488aeda312c2f1db986a8100da2afef1b1a1a72ad00c263a74cfd31313149a61a86b0d323fa7d97c7d3a1efa3b6bab223629eb9d6229e007044ca5b8b268f19a988230178eb9bd763712de18857099400838594297489985a6bbd7992479694357ec479eb7289b75e7126810adefab7e4ad7bef48a4129c1173344009a4a126ae2d4b6468112788626b0e2290c04494f1d5b3a326967873f563f7b58aaf4844dc60f4d56db64ddd0f752888afd8fab0be1889b1394ba7c77810be7eb92ba3648a122c3708c5944c716448496c042a00b1a4a40b20158496104999ae8c5e896d1a2a6fede4412a8900f6d6dbf5226491062644b691921d0905c5c893525a6b6d254a7d299ca199acd43b0d6b476186f9f5254df333f46b91390d93396d43961842501ef1df681c74fb0cfde3acf9d622736a97e9332db616c9a342af7a8c18305eacf826244c4628500dbb89f369516cba847de0640c4a9c80f102230999ba1565fbd2b7a2dc33295545b65e613926501f75524f1b4ed89c3c351967f2d48425f41c75b6a24c7f86da0364be01648e0d9fa3ab38796daba595565aab05a9137db24ecf3c51273379a430aa449774cc64eb29bf6ec1ceb90c95023d3f9239d4fdb90b6af2a88aa437a1fa388fde8b9f312fd87c7a2798900a1b70bdf819e382f1c7a3fa68a4443cf50e1ca90d638b9982872dc4f450bb9ae480c482a7def1a74e943a5198cca14e614e79a44ed4a99337757aea488410947b86dbde0d7db2734939e8ca488b64e486f5518bd4c71c96671ed1d65affb99ea7516647cd534debd6b954388b64ce9469349350c2f3ba0c0c4d7120ab03459c1651a107bfb528c5a8c529472ddaec5b53ae97bb20933cc11b2d5acf204eaf2c0b9438accf10640e94b7d979b48e0cb717e4c92473cd79e1640c565e62573aa350f2f376ceafe79cf34eebd65a2c28161c754ed6306b9a38a4903a66986d51253b76c5624bb228e72862619c33a543928aa2fbf7e55cf47d2e242a8cf260b7b021dade03ba859faed3d3cde92967b41919519eed888a1f679435c13823a7ad4ace9ae60eae0989630ba9837b42e650a7463267883c72464f7d33a23c0d83e5cf45f1c7cd6886238bba165444e22029112bc5eb2079b420ba72cd1d163671507769413e04c128b5520cd156bdce84a44a4891ba85cd1dd9d3c4419dba164479e813623cb530091be229bd22f494a67ecc96640ef5322dd2cc296b6a91d2316b921486f3e74d14e98970ab2bf2a6183386081afaaa62a4e90a11a22b36c03a06548a10ba62435191e6f055ede029f68b4e9eda524b8d24f258b52c5b142f8f88cb4a749f9883be0d67f3957105ebbf3aaf87528ea31dfe6810875112e9a56be0248f386585ebb42ee348c963ad49c04bf77e988180a41ab13c561a366080687fb8bbbf5fbd33b106ddc7820d3a8c73630fcce4117fddcbe604b9060f073b747043c2d286854a67c991f2583de8a42aab168ff0d966e70be797f5e086d27ce5072c9d7f0902019e6c96f2511e2b88036673251cc019d939620949494a4a5c66d69522a961ad1f783dd5034a716a98002080a7dc45041b2fdd032f64e3d54baf60371ba857edaa7cbb1a68b028c256de13364410800e00bc748e881bf39512411e7108f57573268fb547cf11bf9e50109b624c4fe711ab7d7a3ddc00c258c794478c03e7fc7deea2c89a2fdc83bff4400679c40408ea845445373627050802238fd58397ce8dd065d747c0f325c4f79da1fea42474b5836e5eeee0965db493457d960e0fba9a35a6aa481e717e52a73c6ea3ca54990dcdbd837fcb22675511271c47bbc3584addde7b25186bedbcf25e6b6dadaa5aa59492524a697777eb349d61ed30febeee9e362fa90447a9e5e5ea65d5ba9f86e30cdf614d15f93e8d410c2c92dfe418c460bc6169cf51fc35fb5a29a55d6fd42c7bea17dbea9cd7d3dd466bf52c08e69c93ca7b9db22e9d5d6bad1a94c9e0386fe0b0c2a6b47691a758bbc8bc5dd5a2740dcae4e9b8c5fc72529ab95a25adf5de7b6ba594d6ec95b9f6da5a6bd55cdab95d8b6515d265aaefd3b67a2de6bc32da56b39a6badf55acc755e190f4b9e35f33a6bd5b86dd3327bc95cbfb6d6cc6b9d30d8b56450489cc471ae69ad813797a20b558a9a735a87bb70a4e135d5f7691d963ac2b983a250e36bea8e976da28f4f18176a21e6b84d7bade332ceb3365ece53e2a01fe86eab92af732994ddb814d8e3b3010cb28794a7739b95a2a65d97a207e6a62d4d58a5ce759dd763dd9b3b54ee58e917d549a9a3276c09d6e459dab33a795af0c70a7a2ef584101c1753923c28805053acf84c8eb179db658c278ce0a919a454f514c7a9e32a9e7aa6fe35d1c55377249e22393186d1d3536f297982de6e915f473c15a47ed8a1b3e20955840f1c97208f092642b07561eab0e8a0f9a880897be12d4bdbd22babb8cb8bae2413311f7c52006302063f3419b97af0b1c2c8a8071e7cae10322a010f3e312123293bf87081195d09f2d9f2649368c0c5899c7a896483183a10c94174caf825121120a62042048e75f9d571c660a8a4d7e1f74d27b80a562f05196cd76e3f417e8741ec6fa0abcfcbf4585a2f05d902cf1b94cf49aeadd7c33927bf10c1010636e09f1d7e248fcf3df2f8fe2087782d244a86915d24151f19327f21b9a03c124c2ff50e75ecf61ed12e7287b467465be6b1cb1ef398cb637bc563dfbae49a9caab42937e7061b80372d7c426e1ed0adeb1cf806fe8542a60e2598e2490e5a1414b49e68524b94d74f4bc890ee86d613940fc95460a5f544f331075d217b89969c280f8bae700aa6d43b35eea36db2461f1ead11c67e9fc84c3d63dbaae48cebaa64ef477f295bd5ebf1b9a17e9d83b0c6e80a7b06de50df20ac4c4d7485bd82c92f649fe82d7a7c891edfa1c7d7f5f8be1edfa0c76e63168be4c9fce6b1db29bd73d43b358edd26491ded1f76492d938d8faa1fad91063e5a2a1ebb7d519e2cb446f87fb42fb03ac99c6a46aeb06357961ac6e3ba4457d89f62c9a37db5973cd6a5c7d8ab1592875597a48e49231c3f3259cc58bd7c3351235532b74774855d7a12b86e8de80a3b8fa64979a444449cd68d9eda22d3f0b19f28914d980ac74c54c3f1c35b953c5aa3948fd5db3b98e11b0df0468bd81bbc115bc42e9f01a9b0fac6254fecfd243eb5881bcd63dfb6e4544d78420eab13c83d57ad95c730db84d43c1af2680f92c85928e4490b995f0f85c8319e285af282c9d5ca42ecae9634616e3fbd94134d049916b5883d1552a21631f64b947d70f619e00cf37f481d9b63f7a13ccd4457d8714e61e750a0fc0d94df4cd825b6fdf4f98de6b9d449af3095d22bdc44e66007e50e7a84c48167cf6d4bb6b676addfdced582cd11a69e196ecdf1b68034d9489e9e808069bb1212712a71165fa8d62fc7dce8302a13fcee7b6701cc2f43ee61005b14f30887dab5129bd6ac72115cafe45dbd712722c91bb27f2f4ab9467488d90c917d47ec8d2c49205f038ba99d685deb1dffe02d0b7cf97440193058c7c177d3b0cbd93999424795b6951ef8cd40895d23bd4c9b77737bd14ea1b6997af42fef68e873c9d47d3a3ad67fcc0c918b87079bd5e499cecbd768bead5722057f0c909f2250cf2acc19bad1952f08547af107f5459a194822d4a90b6cc0029055470607008b01553fcde9b44149a8e3a73ac00fa5a3b89134014e32c35e1a46f7e578a7c2c588a319d398382f602054f38bc709072c3d367003f9014b5010542568ee0f2d2ca112fa0f19b19194315463f473724f919ea19d8ae497ec65b6fa30204215d41f2d665116f2d75ba02e5c72e7aebba42c58f3de5ad9d6d9bacf0f58ebdd6553b640fca4f90c67333e90529c8a0797b7611dedfc673d36341f3ee6aafbcdced5a0be19194a6e0f670d8e099107c830078db610f9b947d04e9951dc149cebc1b49061a7d967111d2a29d209216a36fb083f71d72032579eb1f2c6951e2c7b9f401985cbd4738416925e8a5b74292d46225cb4b6f85ab85b20048567cca793427bd9e9437889de835b0bb3661fc04717ce6e998c9de09f4a3b802835f7e823bcf496e6eb2ceaa859f731bd24f5083e7384e7a0270411e7da83e9b1883a3086b7ae9e998495af2d33914cc043f4104fcf474ccc078a8f1bd42167a6d3d2d4b969fa0cd679e0928ef10b7e63ce8cd747933e705718338bc3d7f6bae037163253f41033cc7693ec1d9d1e95d97cf35d6b4c7a1750c66ae81a38f769486a588c14f90009f8155e6d010843eaa03471f5fd8655d9662ca4fb0009f819dccf911a47e56c1f80902e039e9ad90b578a73441f319de4cef97f3a078f47143eb13ec6e28b5b002cac151a565cb4f90f519a881a30534d087eafb06eaa8052f85ccfd2f289194927c8633e585207e82e14b6f85cc259682c84ff07b892d853d75bfa0449a22f617df5c9748515cffe0550f84f31b02998f0a479b4779d722762e93b351362080f01287a30fd5639fe1383c77935ef0d24b013b0daf711e3dbb098af017f452b8a10ccea3db6380e633ac1ecab9eb61efc0f92660e7c0f91c9e586250b68892dfddb44ba4242b2f91b018f113bce990019acb1645781b3fbdae459473d43be1b62009a416bc94621291b493a246218f8465e92798e3bb934851bc7e821fbcf452981b9a414db24703a2b1209ffed2d7c4f7216617cc300df0a6ebba5c3b1478a36929f046736d626d0678c339e79b731c5803e2c61c28df03b78e4e303ec1b994042848f593531e9b60687cf1aa1db2e73304c14249e6f56991bc0d225a1332c7e1a87aec5cf7dc8979b4e4d1b863b11853ac29e6147bdad1f2e29238a80d1b8f026de85c81478c375c446346b1a3182cb684029d9317dc41e6e040cd97ab45eb63b55e8af0e2c48b142f53bc24e96879519239f2b9bbfae9ad1e05ae1ed7a6a6a332f248e56533fcd16203c55c73fe0cd1bc0ba2a7855c665353513657d03c3b613e9a3e4a41f389a4458d869f6e83fc741cf167467dd84c14d8403a5e720fd11f5d6c8ca39e29682ea4458dca167dd864e7d10d94f35cd609c9951cc244b9e833922bed0a2800f05acef3681498f318942a787a097b89d465cb5ff1fa0f5e227591f29cd669e06c0a9bba145104d1b4ce659d06cea7a32b623bb449d64dd488af8e99acb92c0a421fb502ca37405f86d94def84ce35ce51e31606a13f9d73ebf54c07e14a96e102d3fd65389d66538b5665258f3e6cc2116716678fa45fb12c5bd4326e03c7efb7e975285be6e8e94cf753bb94d0b491dea12678eb5369168591517e7d7a5a389f269a89e425c99c4eca8c9b4b8f85e94e7a678e38484b5497d50ba2c29135def0e969e1db67e6bd834275a89a02c709e4538836f1b4931b37a68b3635925e59b7363d28cff7a1c2cc7edf2f160a3d2a6c003fca2d131bb7804af5d35b6cd15a950d68a4c84cd37a32db87b72ee50863f3f0d6fb8824c13a0ec71f8fa7d69a57c3006a3a923a2e3d821e71c32ecd91d4a185fdd2e9925d0852c1ce688777ce39a7ca6f03e970c9b8f2a0181cc37b7de2b468e7b401279a5e596fcda7b7de320686d2f374cb7a27e91eb3e9ad6b7367be756d86b66d87dd3d7dc020dd42d5622e7030c08035d1c2d0a2b52fc0d0a2d5c01c39509895434bbece594785e3073e47f3cf557ee3c60be78652bede8937faa5853e3e8e428b3a54e47b820a3e2dda51e543fccce96d816a5909bda3eda0dcde70b4c05f9f5c4d2da0455b82064e47813e7eb468bd877c9518294f01f58e9d28b7fea3772447bd9e6906956ac187ea512ffc0cc7394e478152f3f1f3c17a1cba4079a63c62593bc1348f8d4fb7311bf035f6ab815ab41bfc04259252166f2d90ccb17e25bf28400515578a145d314274a548100541ca6597edb89c2ca1c6a57fde0898e1d2bb1a0464976e933397dfdc9185aaf98df91167ee58491c7646e8a1386d0d88e92a4bbab2b2f581972cadcfa2deb961c01c737c367f1cef4b691e969559e6371bb54ddbfcef78b9ab6930f40ee79b11a9a3bab5ae0f2ffcca34c47963b264075b953c30d0150c94a731ced7fbfbfa0556c03b08a88786fdea320fe319b628c5021c8a88690103072db67001c5481364c8c08829a264b1c1c9ac4c492c0bc5124058e9258ba6af8edd71b22c82b8588a135e9d91c5ebeb972f6fad95ec3858108de0d3996441c4054b5d50b9610cfa848932342c8ce044d1b26035ab0373c60757181c7c180a134410511813bcc244e941284cd21108588185b102041038620af365070854390ab3050f548ec28c910304a8307d354b61352bca8f1850641a2f917ed26071430f4d727d897403098c18d1e58627696e90f2c31d01ca4285e3acfc7047b63280b250e1b828595c2e233680968881c2868d0fc9880d20d7123150d8b00145cc754ea65259a5d539314c9a74680919c215910255a69794e9ced6789d3dafabf1e6161d949ca0256488a6248a2459e4eebcc65acf7377eebc1a8bf20e47cf6f4620ed27b40ca3e75c8327c8cf35ed1c38c2f039e49c07f57cc2c42c91f97bcdfcbdb79f832a79ec180338bf01e3faf5eb9cedbae92fd3df8ec9ce42f2d0eb5507c943c306d3abebb5c7f8f0372cf3d7c72ac46da1d650c8e4c23485a92564c846054a4b0317326446085ad587cc2f925a4f524ebd86d6061b803588aeae6b0056a126e13a05ebab48f63ce5637dd5787b69bf28cf34fcfb824638662eb0163f4ed88b0bc7d48c70acae26e1067dcd8bf2b417b9ba391c5bcc5fe75ef5f51de34290abd39ee1f811c9f56738ba9099b40488574bc8900d8a0fad27d387cc145cd17a9272ffa8e4b1632160c1b9b763134657d72f1ef353afc92e6174c6955e082687b94e5dbde3f9756aa4773abfde31a963fbeb0d46eab87fc3f1eb2ffee6e6e2efd85ab080f29b145232749e72947b9ed2209c4abdea6eead407369816af7b6037b578bd03fbcced588bb7c77419b09d5abcd733a516efd2bd1e02963aa4c2827389b1c1b9c46c6564e1b632b2282063b744327669e7c4d22b9808902035408310960e175abcb5928ab7d60f80c3ddd039af013318c4aa5a5ce13a0e715ab4dfa7815fd6b44e2a2053df52b9e67a0d28e50afc361c9c3983d8e7401c15c7398fc6a07dae3b2e03f33b9f5e0fc63d1e8a0b551d289f66dbd488641a9e401dd72fa13bb9a32345b9430089a50e96ccb1ae52b1b20b6bae098ec894295b1954a8e08cd475b5495bd21fab4d8b99579f4b9e04a84fd8e80e4a1ded46fc0cfd33f45b2d896cadcd42ae660244965afc2f43418380b250e1a86099b2f9b724872046bea68750648ae937edf480861afc1cbda0a14dca921d9c704438224b2ce162441811652b632b830922b62a990a9d9146738a06e40fa9c3c65b0f2275c8ef495e328738e21979b528640119968c028f164340ca4b4b34bcd1ac07c92fa985eb47ac85ebabedb14e85c821189169add685fe9ac81ab6529cf81a560a2583415ab4aedc2f5d79cb001089c37a0d7fc81ceb1c9c208ffe35ab2e843e43e41fd631ce4ed65a4b438bd67f380d3fc21fd4696302280b150e0cb7440c1436c2d8b8a19ebd06fbdc504f79f69b94d7f80cf73e2a2160e11a8950074dc941720688025d59af01adb5b65abfd5390faad6bab5d67a2a64512c99456dcedfe7f54bf6f10305f6a02b6b9d26e5ead662c0ba0fa9a3bf71fe7c9664787f41ef258ebd55b060fbe284c8921e63230c14ce35440c60c6bc9a7208ba612c81a523de709c4f6593f9d8f5681fcdc3d2116f388e6c1a6dbae9e9e441f274109d403c6da78e01c993e94aeae09eba0fa9a37ef3279341bd83b2b0837c64ce03e48a3a8bae288bf53d2da8d32b8aa3e4116f3fe69f8eb73272ff985fdab6211199f66811ca8f1e48799447d80c182eef4aac0d883c666fcf9e045269d2a449d3aa2d64978b490d6d5a3b22fbc8829247dcdd587032862f498a94c6a83f5e8620f535ef3a07727da401871ba8f116a494524a432099b7822c3d0c643e760e879e0aa31602b93ee2e93ed7418c7f8621902c6442bf7012a79b2a2ddc5c7aee398f6ea9bc0b8b741de6b6ceafd7aef39f1a5a5df893726f0b81648e352628cfc0142acca173da85120cdbb9e7cdeadd9c5e89d0ac67f7a4938657c88bb195d01b88b73072b0bc9e59adb5f3a66a5eb34c63d54bfdc3517553de58a73818cf6ffab8f1d3592de668517a074359ceb00653a6dead754dd7a0647052aee44803f5ea3fd64720c058c38fd22509928451c88fb2a6907f86e38f9febd47f6ca5610e5feb877aed1bfe50ff09c71f6f4306d4fc0ca524806cd51426fee9429e4caf610ea96d812438e2f086d9e29c7399b3b9901a5a5bbb0c41ea03c97cd47c03f4997460f3bb85456a70b58a081992a64a165d80310619695a9bffd4d0dac29fceb9300492b9740b32d9864cd7d150d0cb08111b5a45649ad6ab466b0b73d8fc670b2f38fe781b6e60e4f0b57e36e79c8639e0d60fa62be943648c888c1f2e63ba94f1a4f5f3a47d0ba9cb1b1287d21e8e887ecc4743eea4fd907d74169625260fec4157ed1d8893701044a6432d8a7d5d903af0b7bf30a50ecebb8af1dc4490a7cdb6853917b528851aa1c92315a2453b45429489cc69bf61ca54c85f680474deee0215ea9d9132f9f6a644dfde4e2813a9c33bf0463b42f57dde8114a8574d5f1f6c91c7a654322dea1d3a4a399dfab0348221db4969b13da66971a38ad3b7d6a12cd6b7731ca5aea72727a7a69cf4a8348d1656410b99220800000100c314000028100c08c5429148200fe464df0314000b85903a72549bcb836910a3200a32c0184208008000000800801087aaa60800c804c07847778a62af42045c3eefb1395633e29e034b5cdf2546325fbc9c514f576782761573019d19b546730653acc2cc978365d94273680b7ab0d6ba402a841a45626b2a7826cc0148433ad8c14b87bdb74671d85c2fc8e1cd5df4eff07fc2f3af20fe69ede617637829b6f1ac2acea81d7b731e23d615868225d8d30e4a2fd73a9ee00fdb3bb0379f2c623787d6ff0e60bde4e2429651c41054f1b8e5eb177d93487f1a85c27fffeb02c5ee47001de08d4d4e3da1a43b78d0cd36823dfcfd63ab1559e12971e51e16ad1d9aac40d1b8a1d5c36535fd152cdc1dd743a6d1e713dd022c657f81aa1b1ddbb6ffcae518ad2be036bceaf2921aa2705002f800c7774a43b0ce527d08b6496bed3e58b2761805597beb0c54416617d55f1b56af38d66223fbd0a748bfc1abad4d37eb1cb6c53d2572046012dbc8ad1bb71d254c3a3cb7c2e3dafb5f5a980f5c0bcf895fafada1b01c51473e5f878fa12557bf4d03819c452e6f12e2930139c8d49e428e443fa2428e924dc486bc24fa881878a5eb7e4cac4db4c33e138c559a01664d15c9de976c24c17b5706157cccb889fe8b74a68fdc3dc5d1e105186a265886585229a734336ddc1636a4af7ccaaca6ddc215b168432cb21f5cc0beff97ed10668377117741ea4e0f3bd6094655b7986652629084ecb289add5684280d798e06fe7c76f2dd87b0b80c6d881dede7223cf0df9aabd8beb883623568337f4eabd45978e1e8874268ec27d758f2532d17ba33b412f940e2c3aa0f4ddacc85d4d89299fdb772c99897e86f4d6737bd32d3df748eec647ee3edc273419315e634e5a6c633eb08a285b4d240cd05aab26cd03c1faa733e8e2ddf046250cc643a48e2f4b14500262a0095c55191d8b7e95851ca50daefed250b591c12e1f27cea70f3844a68eaa475d344ce97aef58357f5a422136c8d1fe0da71686bef4fecd995dd063a9faef2bda19214a5b53976c43765fec464fd51921955d1cb6be50b676617246b8478ca199345ed4fe1a90006ac71abdd7e67b3b1780ddfa7087d73d18fc125f72379742ea53aa3087501ed05505f77d03e141d17fdca58a194ae6d0c3040397839e50c2346a68db07d05c2dfa9d7f84c1cf3973f67a0f7a382238e01e438756988ad898382dec85da89415f9d93bad46179f09ec8ef6e037a8ac7145f753d6528ebfe58bb482feed01572e5f6413e4f7eb147d9e7570bc205523acbbe61a3cb0387a5b206768dc06055259084c297f7d579bb1dc111afb5defbbf1d15ee906a5e81033acca506cb4a6e9468ed0563273e2d88d221c33e56bdb1c7160e48a876ce33926373eaf2aa82588be50b23e6366c5704446ae843ca862cdfec095680aab539b47e3f445bdf47b92032a3487f5b76d1e2202c3282bc794d2f216d7b16bf4593d654868899018f277eae3f8faba52e7c31aeaae28fdd02f09d4032d3c3b7b30e9411460b3cab5d78d182d63484b6cb23b69315305a9d9a496b9899c4defdcca32ab49c06efa833c6e110e30e0e8acc1ba2ea4561595cef8a4bb8bc6a5520ef01a4ff440c6bfd79a6d175045316452ce210924922315e8d66b83a70966a8f2962788b7730a48439c0c57b50a3163d96adcaf00e8c58928bf5e783eee9f7b9533683224120d8c6fbce093b5cf4e17bd49cd8ec0dc92480420e5ea6fa84c455798b19cccaf848dce911cba782654134648acd0024ba76416ea60957934c9b2586926a42e08bcc6a3915093a968ed2eaf9561160d5b5a798c41377d03a62ebd9ea92c56e65eaa1e918bb67ad93c4d8c0b7e91209736a37da56e81c540a097037024cb036586efa74a4262ca2d657bba891bea062f9026b07ffcb72aaee241b57c1d563027cdfcda26064625d9adcb55825ca7cd8ab0de4595c62f72e236d5595f588094b439dd8b73177fafc8b8518787ffe52df8a56d030a1819e651fcdea99b504db92a225d1202c6c09f9a13c11231a443ff9b99efa069efd92979f4f702dc291b11f316fdc25965832d7605c31193a2947ff72dc8dd500b70802f66daea38bda1eb816f1d2eb0a28fc2411f77a7d5445cd181120e65663e9ec3d12b9b088f9a365f215c0ced12e609c478f0f8bd0fa58d2f5dfecff35d7e121921b90809b93198aa87ba951c80be1f90036629d5b15c67cebf3d496f120e9df73c60bb3b831906e7825194d91319d9ba2b65720eec3e7e3292168157621f2796903e8cb0cd5ad2b5f85f5a1fdcaa42772ee681b7c3a0209ed17218475fa3928b0401e2bad58841677bc944569126e3f1d148abec182d675042ec67a6f1be04dc4716bf184b398c903621717c280132166226e5f549901c16d963e80b4d295543bcb52fbd3e57f548ddfa59c460ddc5a1efce7908f3af2647087f57258507ea2661a66c937bb28509516795888da0695c34e116d433e305ec12cf9d6912e881c2f8a76b1e2e4ecf4742f3118656312552ce3da13a8f37b4e846503f51520ce9d76b10f2419ee8d88b5e4715bad2ddaf1ad1ae58436353cf49b1a719577186b4bd0c48403564039398b9bd6054b8bf13732349794951afcc2adc2265cc215a8e7c17a2516c9a325940469611fc5ea0aed01c03d8d035ddf7fde924dd6b32b8866256f35fca8886f5a4153c445366f61c0bb452a2ff470b0c4f1ed6dd9bd229998be2910743241261156fbb9feda06160c6201a02782ca826232e4f799922bec0f2794a16588fa930952dc4b3cde1ac6a174df06ff9eaf4e46c7caa56040a429ce1a79f15828970cf01a5c806fd636ead0e9df1953890bde4c8fa4639c05db3e0fc9bc0078c67e52683aba9d5528ec84864fbf4e42879d1ac22c28f0977d2c5cc565455db7c7a7fb5160ce50a67a58ad1e6ef4eae88de23df15a9043b9b5297179c238abd060b40798bca8731db0557b35b51c8304a9d7fb63017622a05e2b0ef967f29d1dda46d5b740d2b9f72b4b4f3ec7829eef860d9217b54045dce60b23d4bc8921e5f33caf44bbbe4c05b55fd24d3c00a7f2fff1bfc02e6c2ccd077a2cd8fffbdf1d54245da179e3a1269fee5b49c77123fea85bba483f55a507b8d50f512c4566c2787a59514b02af6c508fcb0082fed5dd2a26b356ba7ef692c9dd18b6e59500b7524c2cb0722b25d082593da662e301b0d6c39769bfaea7f3ab1244e95c9fce51f95c75b11e383cc210e55194832dc2c4b5bc9a977ff0e205beccea0a7bb4ebd82d1bc3a9fd819da5cd48f959ce2c7298ca44bfa02023e4de912c2ba61389de414c837c8ce7bd587017ae64da958b875084bb77c306b8a0c8520dfddce7e072cc0eed5e62364336c02a841efe26f0bfbc79ca321c8eb8ac8935678c599cc85c898673ca03fa93d052917a94364561bd32d3cefd43de8c5656b538d2e151e9bf018f170ebf7f2a8b5a31a79bf049a3fbc9b00e45dce6d81b8d9b4f45e4053b6c741a8a3e1bb364ec15b7718d488fc3c59449992aaf97a1e24d108166cc200a653607ba74325e1b8f0ec9cb25a87c15b4188aa8fd4673e0d68c56067ed2ea874065176af3ed165484b2fc8b0d2f78c80d7aba42ef9d66e3619d3da9d10bb6562604d5adc509b5dad6be2c0205cc915c8f099118c4d0b0bdec8dfda7d266da81ae89f8a6eb30c3e515b8bd846d985c463fad024185eef147a81aaa23b4b761955b027711d49655df8854ec2ccb62206a45f8763634ff0374b5e02737791f02bb47edfb037296d897de719e91d50b92b27ec7d44debbb2776cef3d762408c1466ccdd991d906cb0586f0947fab9987aba1ed5b7beb899f20401f53a79c084d4abeacd3777a60c137220248aeec16e8db96666627e3c4f1b8a5edaaac1535925a8b17ab9595336c800c368f078dd7c497526858b2f330c953a18d1f199550d5b13b709f66255c42c90748c4d884dd8934a82d7c832674990e2c530523a1d9b70f7dad0da3190be9e8486735baab7af0c6a39cbf1f98f67fecfd9fcd81dc4d9d396b7d5862fb0effae3052bb49f27c3c06e46b2bb92977d4be43a32d513c89ef0644447d1697a3ead73d57eaba307b29d884289744de4937cb65864650997a207f7ac5d11c3553e3ca3005e683cb74e79be7b787c31d6bc2bc6fe1025d57cb72623819ae8eca69232971d645c381841b72de279ee4e7bb7f543841c264b85501bc492424bf1ab2184b7d2f4fe1d48450bac1e91512e1e6e117069f66298d3debb42b8999a261bc135446fa74d27219a5fbe8f45696577c87f6f7096c059546712b1fe7156b03d4428cb242d2b56290caccd8927aa18ab3f7db81bd0a6efc765266b76b4090cb6420f68aab7c5db9a54d8c326602dc6a0c27aa7689e159a148f494829b82bd2ae450757536e95c89b6b4da68e897fa20d4e737aa559493b19ad5675a451d27c785f034d5f3151cba0305840c72ea9cf0c6c3369a9abc998f035696f40605549c942c8c26df2591d8eeaf429fffe619f4f9afb78a10e57cf8e12b4298b459565b6f2ab3f7d5c13cb07ca53ebecf431881471fd49b0a6e0371c7266f4bd1529b546855c5406713d2373ae3a294c82ec1034012c956c95889f36afe71b77ff65bb7c0b05071e5f398d55c13537015f0b2f2f4d3c72bdb337addd708a41eaed5b626d09b49ce479e5be7676bd72ecbaf154a11d448ce1571091657c91cf73dd66c58160b61510851c17d90a9ccd9ffc435888c1f364dba51b11f65404ec8bbcdc945cf7b3d3ca1e758a130681879002bd0332d1149fd31bc9d1f2611754cc59d788b2b4bb40215abd0ca033e579292ea907f6b0f30dcc8540fd0ac55475698fe9fc28286208ab0d0fa1bbf09493889ee0ab19d4f7902815334182359be35cce0ba28918a8dba75202a470349f3cf4a8d00b9b765ec78bbca9679179bc57008ad28b77119b8ae8f0889d582318fa6ac6df0924af10399ca8f6c8047a88b651e3892d22d76e0166603796fd69522a3cb88c59ce36312830d16a88e35a43aae866d58d4c78b4c6f116de4fde286a8d9f2d8eef7d70cf9b28633e3760f046d331d15cb4aaaa766d4ee566fd6e0b1c15b29a870f6c335b3de247e267cd5020fb3c365dab1309af01107d8d4d69ef6824ef12d4b3bc5aac83bef9c636a27113e5bd09531089f5e514c09cbe9d80f8544dcf7bb2fa0f4f65548c2a827812dd36c1f49f2a85ba0337b1e278c26358b274335a3f9e632a2f75accb2bff78f45d8f3c142d34746abde7fb592668e568db0224aa35522c4fe6291670f0e0c7ec1b4e829bda17edc6cca97df589ff45b0aea3e9a6f70bd088d6c0959741423f87f3ec210c7fb93f79e393337d8e59f68ac40b652ef684322aeaea11affcc733676310be2860d8aa0183562eb00b198ec628ecca18edc841e533fa1a31b7a98dae68d094a3396b319997e289ef389d09c251f23296332eb3750fbe3c0bc9ca3b30c10aac1af8a89140feb4560004e758844d71fc26693e5020a5d35da4648213283be0862223c3bacca945e27a0dbb90939ce7d91d5e2ce1e6d2097a28c9a3237d32580e3183187961661ff6771d74aecd538be3c0891d26f0bbd9693dabdb1ce18135f2d7db42833d7a390166c48968397abf9c058ce251b279ee9ffc4c7709ccb077c0d21d4c915ad87c9143300c3c36b277eac6c2929d903beb9d1ca6251aeee830fed76d63844d7b73805b8846ddc7be2d377dd8883064528f0d05219905a70b370113a01227cc8fd4463360be2c62f5093bd1f7881d51fa7b71c69fb1bb1f6ebf00504dd41594d168ee702d81b9c6441d31f97d587ed7abc3b70c382eda4e9d3f64e86010196b8613090d3ea64e7036fb9ab876d5390daada4c74c0dc4fe89e2ec0735d3cedc3754d7b922a6d40410e51a47022c6477f036564555ba430978216ea1681fcc3ea06efa7d32ce98ab73f4823771e2c9f022cc84143aa1bc3913f9b1867c4fd3a27c6eb1d9290cfd457907655d44addcd3ad2726dd351e98a0c2bc831745e3ddff79b9d228ad638ce92273290bdaf47eb54b2d457c6df2226981c5b41cddb291e14d48058de736720fa7151ea79a6bbdb90f3779159bbd577b011680c7a1fe3db4fb5bbcb2ca2b7008ea0d1c22970fd6bae591564070006488eb5cd0bdd12f3a477125293a1fc7515329b1c1be54f53999e874f522b4633c6276e5d27e02bcad0b75c2f4bca4529a44b8ad2231b608b280bb7d9d1771d1baffedc9dcd906edaa43dbf43bac2652cc1c78586e520da1574b3161e043e755680380a511748d8d6c7078d2cc0bb699d6b2ed7e2e4d6a2508536462894188f06f570c60f182a92882b643350c22b85eae96ec9cf1300cf7acb00e1aa2e29a3872975be0ad3f104a126e5d37e640e53bfe7aaae15e74393cbd9984c99b293e9ea4636423e811dcbc585e6a6be97db4f9e187887568ebe04ba8e47375044fe5fac39b7446dbb1b0b196530896fc00c0b012fdbe40d13e5f2172b2dc3af6cfbdd62acd0b13174e13cc126ca5b44c341cc43d9ffda0d0cafd4b8a54ca125724f653e4864d51a797b63037f48c261745311bf8d27c410b60228c13afb6c184965469f25ce033550bbb03ce70d5cf28a2f219f7a30ad2cd72ac3ee52dc9b56a0fb3e5d2bcd8120c1260649621968891b1f1de6a626e14d7bb2f8389faa8a9e97838cc2a67c23bdeb028f6862f1fde349915ac1e69d419e5740f5971f559a4be3a2da91338831fa8dda71568e160f06021dd75dcc772b6802c70aaa5588087ff01d5795baedace066395bf32e13dc7477559200d799c4c717f28a21b82945a1a4c4a077e89a149b94d891d2a377a66d6eeb3aa92dc1ecb576ed1241a96814a46da8ccafbcb081b5736d4e90a666c3368ba6792bef17b6e02e5840dafbbaef7df9df9d84fd950d4f0ab930e0d735d93dbc923f4f19341e447b2ce22fb27ceaeccc67dd6faba4550c78b61925cd7d2fd789e7e41fe6bdc7e451032a442f547a4e64ff4dcea090dfbe5eb2ed04f5427df0d8808ae5bb2e9fa79626f4e2c2a6ec2485e54f251424747308560e11a24343e02eff07ec4961221f799614b8713908596d8a400bf91e5d741db91bf1890c3856a7bba7876e1f6d3501850eaf899c0eb76b50fa51b65876989b8634215a663cc54439d5d27a4999d4fe8270a00a2b30046aec809dddd8368885324c129f3a3ecb8cec18db0f046de988643a34a533b52b5dd140b9df3897c8c0aea401f30ff0892df608b26c5e7eb3b17913026dbfe757a3e7fd88bef645700ce3947c6868e369e8e60eeaf4e746c6e3f409cd6fbb0beb404188aaa6f4c5eae5e8ff89312f6a7d8063c3e008fc34cd74f97e52431d42857dc5f7bf86e214f78389e2464658786b5889d33c91ab278d2add0122ec450ce51ec529e307fb46aa7f96e98f925119ef3bc7d836346338d18bf4859e9d67f907748675be65321a46f3312877a34ffeb3ae7500429de8bc423ea758a55279402155d106a446566f0d684d50b77cc97b4034ecfd11a059e4e91e5cd40a7a78276330ead47a3a32c7886b4e3ab94d2978ca64adde5453ebd46df2f766582a6ae39377da521439479d4e70f03bb70b101a21f8eaa988843762525236d4212d1d31785f3b7f16911f897a0b0d6c4acb63fe03feffdfbe821c0d908bdb83813558b9db6253abec82205adcfe71e401e0897f30f3fd192e534f26736359ab24a959baaee44c446eca96a1729e4b900624533c710c1a95314fb106f15729dd62b74b7345dc242ac46ad0114bff663fc011cc2c16dd093413758ad1246c435c796d434123d5798baff894a6c60626b60750c505840776e32000f44d18748ec3b38dc2a4ef87e1ee4f130e2768b38d45eee75eee9d7faa68889bf22295914c9b43eb80ca335ef4a09e841cb00b2ac34573b342d4722eaf837091d6b4220e1263290f006c2500534ca478a29504aecda8bc7e1090fd63d81a9815af311f338f49bffae5f206385e2bd2ab9d6ccea77fb1b1263ecb428dda194dd756b5fb13ce1ae19532d41669cca28711eb44c86718bfae91a382a1e8ca4e1e502e8686533c04aa4734cc189df5c12594c96eee18d21706858c350a3129a873f7c936755e8ab373a35d90b2ef271673359fba688050318a9644a66737e2b66603097e4005e783656d71eab1b5c79c7dd21453cecaf9e417534333e3c4953dec02c44da472495a0086e29a017e0c5fbdfaee1948d5e4ead29c78c52eaf14fafdf09ec09c7a53a6a8773cae0be90d2b75c3be34dc3c36b6df59dc148c0163f3480746fa027a32c953d04996d1c8beaa2fed6c835c9a56675d1f2a24e731d8cdfc809f20744cc0c56fb7e0139769bd057ae106d0487954bbe51579cc42b303df1f07e42ca58a41714cac5d669e43457c7c387d3fc83975088198b395fd3b4965c42c7b0d20e2d5b231d03ac30961d6b9fa1d12e73b7078799f8412ca3021b4045e3a6b34c976b281e327155f67e5d76489d4243eba0150d3fc9af300926debb7d394b6b121adcbc2a2351465ad06b497059430d46f970d0475cf3c8d605c16094316cdb2c6f7f6a6141f4d5ae01ea3f476502bb9fa2bc04fef37625d89614c480a3732cb6643b984549bf623d33b5ba9fd50a77e8f86edbbc83316810b0ce86f4cd2170aeb9d611ec3d8c718a83c7a20b79dde15dadb7530ded64d4b5dcf38fce242582329f9d6b2d70e7f78add99abfe700b3c0741d6ccd0cb5a8a5e913724fc3a89ba16547d2b3ee0c48e36c1a5dda14e740b8955e03debb344bfccb25c1888524de63c6804b546c419fecb95ea41ae7324275ace92a99695afd356abf5c32d432ae104654a61ceae1cb409c5ec0c6e13a513ea6e67de8101046365b749c25d29e4fb1e193c224dc03ec48d9aad7d9687478395062766f1964e7f75243c98db05269174f145149f816113382d8bf337d028b2ed03b98449e48f1c28f3dd3669d9c17a8a27fcd18d28abdbd3a5057f054a8746ee9fa172a9467a1e7941aefa9f38790b2878f2b85c4ac240b06d9019761ce37d8782db30fc6a6ed3094223a3b96efd290ccd85702a4ecb8dfe069aeee384281f705c1a1710fe9060439b05df3c3f7673f38b24fbb9cccb87ad2e5dc84a75dc77f2bb03a4bb700ffa82a017d09b48e6e1373015469c09357e0894aa22d3a0eb5ecfb078acb222d004e8e1b3f46652b419bedf149815b8cd143402f70220a76046c1c3cdfc8b28ed911a6ce754c718c20fed989007d07389648f2e4f85aad282f0ec26cfd5afdd8478320cdea21884a44e618d514eded2d18e5f51b7c7cbbbeac558751ea844d937d7f1c7664dd10408aa2b23bf87dc57f8f4cb64f04bb2108e6899ef2f7b2e449f3e429669dbd69c5ff705ec8d616781a512a602469f1880c6ac596237d602ce35fdc4d9021269a97fb8074c890fd117dbc587d5ac360906cc07f799d3f17abdd6496cc8a9ebaf5b8c2231097ceef6409e63f2a25cbe306f79b00ea9bab38bfaa9bae97b2a14f6a50fb2156c9331c6dfd2950524d1c0108dcf44aba1002ea6a1ea530eab216c731131b482f52ea75415fe8eabf4f11ada7036dd8081523a17b6010b5ea8ef0795bddeac1e7f42d710371f00d881eecc0d7e8e0900f02927764ca33070ebd12a841d6d3495b380a2fbc346423cc4b11a2fa1021bf567c3a8e3e9ac87f02cc16098bea6ede1074c527dadc29a80ed57ce3eb684659039462ceef603a9ec1dfcbc26832f5e3a27c3b7b8e02b297e8881d9a528a02d01fed9b3c1f8792a5f0570c8e261a5a29713bda9bc0fa4c9b5af332d0bc0988a883f9f1dd4b1e0238b7aa34aaee15f23a90849e7be6af8919888128abd00afa80e839852b88bfa0298f878e0a62a39af6140ea1cda4d37c8baabaf07498239a04deeeb59b8b7f8e43fac96c7e3e11ac7d6fb613d26643189e8c068cba9ac075ffbfd3ffefa4c8f26eb34bc914384b07aba06eb957a21a02402ec0b4ca122d3d00de6c16bd64b04d98ada1ca2c71bf3fda34c0cb603558337619a531f4e786224777da08fe0e54e083ea0f6a48c019fcce2edc4732b16aa203c2dc77eb7ff6b7047b524dd9bdb88b01fab841b4c3cad0ce22e7c8870d31bce93967f09583e635de14fbb8a10fe95aa6101dbc5c4c3b1a7a2722cee3b0e94bdf39ee8dd9608e6e22e92c6e2262907f72f0a5a2b7af8908ea9aa924e41d13cbba7cf1ed1841aec16051a2faed66cf96713f9b05e502dcc5722485ac11dbc3889a08112c5f6b8e72dd57905ecf8891d98ff4fa615b4fca0fe93f56a21e7831d0a3eb363d5ea20b2120942b434bf4c3586b3924d375442c59411d8f91790a16ba8f2bf8322b8631628b3cb201b08dc02eb2f54fc6721cb2beb47ff5f62d01ad019177dcf94bde373d58991cad74b0b37db45e97f03765eb7f06e8641305519801e46dd422aff8c65dd78ce8dc2ae80552e658876613ae24e1e082943fc6ec1f53ebf60bf8acde3e5f9ccba39f2e443c190286bb4b526e5fc38c69be2abd470f15e3505e9f9446dab80712ef019abbfdc16a3d5b818225313471c0b45314fd9706126bc85c3bae0b9f7aecfc80c7ab898fb4456797e9a748e94dd08ceff58f18441e8bd41df47a7022239ffacad6a79325f9421d08f4c81c621fdee3bd9185c78f1768aae42f9d6e74c5d4b33fe454a754ccbd5feae7efb687004e569d79af6cc538eda04341dcdc4c140e22ac17b5270cd37b712b6195f3c0c6c299984e78aaf3be5d8dbd785e18b0b58de4ec46038d545227615983a5ba217ab7a0d400b1624d9fa254b7d8e092f06646c9ea557de72b8dcecda8267603759dc58a7ee097566048cfa4580f790b0e9c2a8de1fc05b48ffaa20600a10388a77d44b4829569202fbe10e6e54dc0d4c39642b6b0f3253ef7dc764c896d897a0ac5ce077d7f2aecb22416ec44e3fcae0cf99f77ecf9e3aa85eb7a50a1bc5a279c40a45cd0732a99fa967fc870cde5cd9865a89362bd5af786349e737b70fe5c54f52bfdf90f829a78072007880b2df682906e611ddbab939104299c0bb78c182642f8909a93e58d3d56002a9242259e0a06a674af7854203f2ff8c55b8f3c911a140630ba6832e7ced3799fa6e2e4f7cb6b2efc26327e028aeb52865b8328bf2745145bd868b7b5fe7bb1c03bda037be8b13faaa9c9da5db6fcf055e7f0fd59ddf66006a1e2b33a815bfc0d1ee7df62545f359ae0a07e001ac56b59a019674b2e0edaf2567a35abb0b40c612f65c21af620c1a8783a09cda88c01c908f688c893cc0e90f70bafdb3a80c7dbfcc574e0a0eefa05637be9d9cfc8856527a829b0207d17ad486c881e0c8074e8e807734523d403e0c4e7dc0a0bb3eb84aaf01df34d2c00069a8d3646224a7f4bce96804ca74d02069812c538bc4772b01b63d1895fb7e7a0771ca22e6efa73d2516251da333310f095608b9b9c9a0f8d8b808268e3d710218289a1293df318ba543521561fb57ccd98eef73e7565c362319d07b57a5c67df699719a4ab70e51235c18d59dcc014df08b1d75653369dc16b7102f4cb534fa828efaef19eec0df9f10389cbb233c06631ff5eb4e25547b21bc5d25e09aefc978e98a5af91dd5a748431d774b0a1d38423d271da3a9e1731f858cfbb6286c152241a667b723024f135d2a9436a035c5633b420f38175f6ecffe8ad869a56c14c78f89712fd35c5357f71bfbdac3104642b5a62f134e7fc8e9f047dd925b4d0e9a709172ca6cd3c344dccf0b5d17f7f882e2b5c81c570bf855cda92d1d97bfe2f103ee264332660fa57807a58f9ab6530c7b6b984bbc3a7daacce621642513e85f37dbcd421e6adf5ae764b9b64c2fdc47187192c68f16f615ca7edf987d117739dc7920de9d2b7f917034b37444f488161133bcb609a6b586cb32d41817cb502f42c96ef625ef6ba7045cb4c8d1c10f8cee86805e63056848534e04b01889d5e7614c1c1d87f9194044906db2bbbcc96d88cbcac930bb02a56de121a107b51eb67c86d66db7b59879ed79faf887449a34573f4bd38525acd4a355852e0e6328aeff41343a7bd285a9515cccf7d27636e3a0f0e755eee1bf5d4c8a716e9212a7d36bd7250d6255d7868f75ceb2510d8a36a14d2abf7abc0bcf2e33585cc2bff3784b890f78fea584dbd84d886ceb93d8a1cf6829147f22daa19d85d5a006e01753f484a99461619a567f1729f286b51e8d3d4205be768d22ca07375905853e5cb8c5a4b3532625f0bb4a1563df02ad233fe0f1e3e88a791ec4e0c07e1d621a9f052c963aa6dde02df6722649340088c26c83ebeb53c49473d0822443767526aa422afce8852fac6080dd90ed81b0290d3f1d8b8e141ac258c26dc469736855636f63e0f251fa4184678bb039ce0aaf5247a5aec47d93d17344b0d701a1168df0926e7551c847111ea00f37ec79d0ab674b5c01a2762198df803b0998561ff956a8114ddeac273b53c808c5774c632e26a1344608e71cd720d901db9334eb6e36e4c27773d9cd0a40de072cf3bd71afef9b1bff0d01737a8dab3ef9dc8cfc89956dd50e5eea663b7e266ff042b22ce2add235ea5628469ad7b50eb988cf020d80fddf977df93f1031f74994cdb4d88c3310197406d0fc1379e3b91421596465040bd500e275b5ef1f77b4bb105afc2c4684e0c6d6abf6227f48e8057c184bf7313933141581e95489902f6f0ea86c643d9ba018febc98694093300f851d8ff52817f69c805c1fe3535bd9ddbbfc400e3c217543950a5c3bc99838e114fd55ea9200b228bac4e9d20d87c15564f00d143d1e00a45954053da15242bfdef7ca2cd69ff60fea8896ff9a4616d6ae84d9408ab8733a87a5e3d642e6bc92e16ef57243a359e83c51d5adf6cf5f51636c9fa8ecac699b2ce78669db8ebe04f43f38bb53adfece5ef666251bd4795bd689716086815ef76c0d8d228343c097efdd4632555de08c69e98e2f91738776ef88d203adf3552b503fd4381385f9f7e7340bc8381da712fb952709199bf570b45069903c77dcb608526e8882724dd1a459affae4d999a1267be00a1f2042ddd899a028be5331860f9b39d001ff509e243d9e636346ad4189c4fd9351d06d4ba128c1c4e91df7f96fd71859cd07c8d378927d0d1040a31184a141722cf8e96d72cadbec660c178944a7106cc3a1b97c824c741f33d137503c1e55575d538db5032717969c7fdcf89d5faa692fe9016f1c7b7477185a06ec6ed03a660b36ec115825628b22f8621fe895c04e36d6f97fb523295d70a2eb1ec2a1c5f8ec2fe9dcad70094b63b890b05bcd173407f092dc8373f25c1420ccde3bc5084c70d5eaf2b2b1995745e4cfec75fa6b882fd09c31e5d36e2a57056efa4d475bc18f007891f83337fd5a9cf262daefb57e56d830562622265b29067fcc42e64867fc71501cfad996841e60f10244b41ee01622fbdbc5615050b9be2b08b4fd7e4f6c06227f720a8d02c410595ffe8cc4aed707f022ecf917284a8d3e871c50cef30328f69c5c526138b14298070215994634fef1cc2213713e90bcda24767b84172513f066652b9074f34a0499a6cd0365769c1a3ff5fa10b3380c970adead64306c51cbfc2d4c44c8c6f2776028b49f11718466c3861e40cfc49a1860067629f36d52fcf1cb222958c8c65269a947067662bf24082adf5d0f3fd9d34938be4e22e1ecb8453df2dfdd0f81c3c52ef28270c1b08feada6f9ec6ddc177b2f24b515021dd74df595bcc35a7aa154bf6e770161d2969a54bee6c3dca42d7cc444372da1542581e840c4c729259e51fb6e753fea441b6c4197cc6d4d57d3b491d68e8e4ad2a8f4d10f99b930a28695aa80c109982d1540289cca45f7267699ac0ccdf594598d370b185a117ac3afa9764d9525b550d12dc6f2143d41137b21f1ed0b31fc430d934ea2a938fdd60ee85c742645f24c6770e3448b59e7344b6a561afc7a76fc1a2efa8da16fd3601b9a6843fc83990156f6746e81836fda5fadef4c52eb54da10792a8e6048592d0b5f7cabe31963ef48b4f0c68b0c4b6a729de7030fc0596904f1b0e25419a225f407768e8253a989fd4306fd71001408f80beb6d3e7bc30755cf9ed10f0a515cb8dac5d4a0939ae50fd5e7fbf71e0fff878bc88e040a46f7c47439f9dc6e9e8430572da2d4efebdbcb59a7df4473e9c6015a84b742c519a8b5b9933a58135dab4d0feea5f0efa413d57737b3dba0de981dfdf23aa51e08db8aa24a7d68ad2caa1283134045f444ce97473271c76572c90aff2b4f10d006149818047cf2a900ef0ef34a6406e1bb9f5e438040a6c27e2ec197c2357c8cec32e231abb48b20407994403688940c4b8d6a0f8470ad695d24aa00c083992857a00d5889d73265894a0307bbc546ba01bf17feb60e2dcf4123a721da5d59f5a47e0d08d949d19d20c5ac7d694b6417916501c89fb0518b0c5ab0be8b3d8f60f15eaadb2a65511273255853cce06e7616db6dc48e79c06e63492d5243690d52ec79a66a0f1ac65d5ea2737b324c0a8a1c72a12768e406d54f8fb5419387a270c6627bab9f3f1cb00774e639333d696ebf6666699a574a283270d17d05d68c8e2eca900eb5e72a7d0e6dbb5a7b23d4c2e99ed7808131b5b04cfa281fc0d38cc5677e55fa3eac13ba2b325f887698d59029138dd3afcec9f950c6578e573973e04e6302a33c7a0a0d10544ea43d5f7eb5b5badbeaf63d4fc2d636e19aecc54ec6a12048226a878b66ff7e35c114c438c0423982df94ada9f80506e3aafa4f90eee5220030d15b746d0ab45b37ed63bda7c0e7241a84a46d79a6c5bbffac788e9119845b83364aabd5e2c1fbb8909f23ffa56001db509ffa3ca57da35c7ccb14d1ad21f89c1735a016407d60518c5b6bbce4e79dadd126ae0f883d80723f9e2e8ccd75990b80529c04ff568059b527b5c82cbb2c14851e7b252464cde9531eddd886ba096c8a904b516ea01f06f80e682234a1071722cffcff7dfafefaa73b2431b31e88271bb7cb93a596e48470ef32d4bfa7486d904fdd7babd89e1756b850ba6318c68f05ef45c6b92ceb47833f2f81950a19ff39c0f1042be5a442ba6fdb738580713b0058618b4685e081a32c8208eed57d50fd0bf271d721eb5a0bec1e753066be82714a0b93aecbb729d0df8ea368741ebec11781c067a6d48821822b370186b2e1e6c20e7b2c4b0e55e7d6e1211a3fd6fa81adfd3a7fd114cee79fd75c7aea2dd2e2aa87632840b2c75d13a4631a87d73c7fed14ebc9f4f604d22c1408ff7d27504fe68e4d0e8860daff1b9cfcecb29a425a63e004b454deceaf5f6e94b49fc775400f1ae021c6b582774c18d280c7cf6732e455798c1f719a3c42e6adf011716a38deb6ca293a57a1d4a51f9412851db92d054f22edb91dfd62e6b52be3a64f92521238d6393565a46cf0fac72f38a3cdc2b60a6ebb3eff89b1b5db544941b46cf64d68ff555c8653cb86ba6753b3e3e87bfcf62aa140be722bc452cec56fc8647d8b01edc7071ba5a04aeb598a2eb5067dc4c375cc81f553a11d586f9bed470db9916d6431708ef4f3f162549b0d8192f36159f20235cad552e822d6f27fb9ca14b1bab94dee7cf81be67aaf913eff0e512b7904afe179466adf109bd74bc0c105251b91557f050b13ed4185b69292a9131b03298da5dfeffdd8be5dda7f65f838d0b6fec298c8c445dfe6421afffc3ab88207974af4deac3c9805243cbe41a85cecba93f8ab6d2ee0a7cf30b091fc739fb7850d190a7289a0c297207f87b159a0561d55400fc6de42bc18db19b0673d45d1fde93d6ad557011883186c0c99f01439e51a213fea6958e784b5d7a89b74a64910c758a38425b9b9e6891c32665313b825909ce7c5cc3498b061edb562b8da00b0d94e3112051023c63848087e41cb9e9d5ef30e6dc1c772c730e92c36a00fb5a76f3184113b3aa680459b4e4ecb6575644e27144f46c93e9c2bb359428dd05fac819963db353defac9ba605f6506ebdadf953895a60f23cf55c2ada02c20c16f4887385383602b23aa16a6b75940d19b404bbd5a2058905cc34b70dadc14519a119bbcabd533f47de6f4756944966a96aac379460aa55231692cbbbba35606d037561a4769f19962d01dd2de5ff4b17dfbc4a04cb20ec7e3ebcb0d8326e0d77e9bfb3ec0b17dec52dc2de60b47c1ec360e0162ddfc82018b50962a7a7efb97cc038347646b2ef453c6af4a9d3b7c9e0df8a5d9018dafeafae65d8b6022d0400ea512bb80f3a3dff9dbddd909c792d289fffd196ffcc3fdc3ed4597e182b1cacc9eeb6de434545066cbdb5fcfdf0b28205170da8032a104199b5451e6a65ea15c6898e681531dd096741dc3546f6fcac4cce11c429574065544d085c2bbc02807993f386b6060ee0b56caafba312fed026f524ceadfc55490d8f41160fb4ed3d702359b320c0ca62944a833e344a8d24079ade725b853b3ac979023504cda981810cfcd6b230540da59783ee0cd4cdd773c16b1aa68f52bccf825fc6bf701c73b73522efe067ae4762dfbaf4b6823c6cd7d522a9b84b597283cfe5ba748c42c1cf9227d8a28d37be1843c54e91e2a7fc5cbce2f689a1b79a4d88898f8afd619ee6883752eee43233b12570db76eb9fb8791bee3ff20c7b5e77fde9c64bd8e8c3146850cf0bb81d74f72ac26303a866811da35388113158a891cc2ed6746a5581aa163ba9c736031e37b54bfb6ff00b424e50102554109567aa16b814cb4ee905800c820287c1512bb241da79cb4f5eb276579a83746181a071f6215b3bcdc90cd057e17fb06e43e19d92ed01df4101d43306b60b4aabaf073e4d10a7844c0d47ccaa06b30fd437488921521de8d354da6d2af9ff5873e4ab190cdc9445e4d629b5bd56d866a7d292256d51804be07f35c336a2a53910aeb12ee3ca68221e00d3909a87a0cf76a55d4140d9c5701eaeb7d05c2475610268207ad0d674f56db3eb62d8e89d800655150174b8a4cf6c747124dc15c9798e5ba0dd62a04e8e67b82f7c950dbf8af6aa9197382704a911aff2e458ab934fd7fda4a5620dc02185e972c93cb2b8a8a8317fdef0a9e7ee03f1babaca7760a941114f43c96ea71bc00f532a6dd63fb497aa8a4421c63eac8ca722f636a27cbbf94ac3a81f000ceb3b97864acd43c2f07fcd2b55c30507b2ef1481f6387c33b5902175de5b8baca2be6f900af631c26ae1c93ad9404691d337188555b4aaf9a70820e53ee9caf1b2f284f62908287bc1abdb7d55357006326a6177890a79642b0a270e94cd629d65e0a1eed0e8d340e901c3d720bdc3a28f01a1876e26db30e0d0323111c7f8b0bfdda65e88a6da16b9af2938582a1a16e9f8eb054a01a50ecf05b2dc5a7619aa6249d865974dfa1f2c69c5524029eb3a05ff382b2573c30077485397975a9e6bfa649a4a8072b7ec42349991b30328d330c6e111aac471c664210ca01ca57db6ceb3b01d9c3196140459b42f70df7bd24d1bac7a753c014e3a407df854e157e11b833c19e613ab7e7da017e16c1ac9bb1df67236ab56c013f48504c3b2dd19931384cc055fddbe83351d074af7da1119538b4332be2ba8406ac94c7cbb2c7e98cb68f08265d17f94244c0dd88c957bc58cecd1313bc1e0f1e3b2361381f1b58920d6618890860db7a321c8724c41d826facc5c56f9705b41d3efda5fbe0f7ca3bdb93099250e495136d2f8211b88202684749f86f3d26820c6c7b0c367a1ca3dbfb31f80986b1c3389b4872593d31a84e6a25b131091974764e01452fb5270637e41bfcc5aaba6632e164e68a2811ec5d17f6b94cd79128a9512b3f2f7dff1f18132dc540b36f1f2ce798daff58ef873e1209e6e2ff9821f26101241e8f47ba58c52875d6ca85dcbd1b72238b540bc0a9c4c41ff33868aa0822c70a8870b08cb5d80914ef160a3378da4c388d1a7335363806bbaf1b0e9cd689327dddfdb327b894b091457748d3dc30e605d63abb2ab27606473b94801791e3d9d0692782546ec582337c490fe09943d3e99e46371c1f788810f32b94acdda5936304a585b3d8ebe64092d1b8f6249989785cf13c6ea70bbd94eba8f281e38bd796c424dbda62fd2f9801690e16b6ccd9b3ff9ae9897b245294ccb71f25effbe4f0256d3f514e532794e792e0fcd5b017a4a02e68b86b0d22a169a1d42b7e20da054ba4f8c4d65fb330f729231de9a258a44895c2f926e4b9b4d16befbb2ff1ae9147cafebbe32523788f504bdc1f95b9f0a5e87423867d9e2e3ee6a44211021d46db7cececa656ddf6338ea0c77719217f192881d7cec3f3a26eef04cf2b1937900bb38f79f45bc95777bbc11636232d8e198a9330be3ec4b4677afd2342b98a22d6285279b49b2f6372f259f84fc38536f3900a4d63351744894b4ae9825da6ef650e1dbde149230482f64abc1250aa1c51c4c304db7323de36c3e6a78de0a5fa496246ecefb657edd048221be03d15baec12e72e34a1727947a66acd961c35368361717ecf9177ea0f15bf4eeb7c60aa1a5baf6e1b4a2445842cc3f8b2078b62df2424e59ac2773075a749661cf085119f8a0d997c8ba1efd3b84aa090b4aeddc42c730500d295c1462e993c7c63b338402843a307e16b2409a6b4bab98505dcd4e53ce1b339ae071f938aacf44853dd9b66c17d5a85e81baead308543ee1e8a1b64badc316b1a0b250d36b5a8c992c45379fda70f3dac5382b687f470b91640b2aebc55cd681f9f24df4b9da3303a61fdb1fbfb1efb93f38193c6d08b48d0946a2a7190202d08b7f65eb7fdd1567da5541540bec7314a250e10a1b2d4b476cccb05764acd82858c857392f532b8eb1de95a82c9df013709342ece1a1371c210791ac5b45b70e0c3f0cd0ba6048e413dc458b593450e32c63edce10ac9ef21ad1b4dc825c1510c4aa3278bea3e8bf7b9893dc9fcdeb4a510b65679f608db85940bad7071b7f83bfcb61d08b211e05b255e8b022ee90812189a69873934cf8e94f469cfc7a7488d51132ab8ae55d90bff0d5f9370ea6dd847c4f2d4d54c8fb6825004dbc32d869a056e9cf3cf3d1e0967579520e3eac734eb2621576dd5ab1ceb9fbaedcb225468fd3df2b473abc7578dcc33786773c1da1ebfe2d2108018ae2f93d957f72016bd2fa30eb64c9b3b9df3046edb284a9e86523040beca619afbfa1fe873c786c0f4d1afbc71928f58fbd1bd3ee2f1ee929a5181c64fc24a351d58b5567b4cfbf0228ec373f0a15834f66191bb7ec622ba406f58ae6ce5637e79d7bc83c632350845dcb8fa14241ea1988f0c41ac20ed17d3ab20e5b721737417532e98891c164717f0ffa66b1f8473f8bb8a6d5d2933cf26b46420f794acdd8e904e22fa4cdb530d8c43be850c85ec143b21c3a6faa21bd41078a8e509e9fa09fc48d5747f37652790bc6f29b60adc9f0faebe7ccc21a69670c58023355c4da98852a2f9ed027db7ca2012bc6021ca6b6fea003423405a3c3330803e7f0debfdd0e7a568ea4e9ae51e930dda296f42ff213df04fd1a5420e567125d4f27dbe5adfc67f4e8544f78a1fc3c78507e5292bb970d1be158484d394607000656bcb5f27a830ff7cc4fdce386ab7ad67147cbc66fd57d56a909c3e850a4adbe8192bd1567310673579364780f5d7da7a17dd2ad247b35580961ee44d288d14f72c84167204f455490aa47a39f955b56be55068365f87bf1307b3fab238801fb59ca41283ad2c16f85ced17dec48590f925ee84396ce2ad70ac400381ca959ff1f4129840a932daab92112788bff75cbcf97abe50844bc4166fbe97b7922617b5dd81a91b9c0a8f46823cb168a75b5eb9aaac37e6260fc40fa3afaefaa5bce19e43d1575e4a0f9d332a29f123aab1a590182d7dc1c5624de05d4508acee1bf9ee36d6a33f3385f347f4a885be7b31e0d4a6bc8249a1641eb43f1c1e6994a2ea3b16eebdec04acde26a27d6aa9d7d0339968e7c8721729d85537e38118519fae8a41c965b23c0b7f5c65a38ef79dbef49cd8f975dc7f87759560ecbcc4026540d90a142e953e571f25927fffde1891b22e3c07c1861cf1f37759230586b499a8f4fe2fa31f5645eedf1841ba6527a492c42d6484b25b7e0c2dc4bea2a70e13459c34274e33def0535ff417a851539ee782ac5db3621073d814cb7acaadf1834c73bb36801f802b4b96acbfa4c5004fe59d2bd32a24576cda0f33b41fdce3ab5eeac4c47c8419b501e22c94532c1899f50743a4adb682ceced311479af705b43f718e08946112c486232f6de6ec16569d1da3ed57174bf973035b52fd4d780b3262a732c1001c35faedf21a1d691354bc3662ee43d9453e5d393070d32b7c62b9f14e0ffb845a6d0e1eb2618d2e1b91d20c36d601620d4c64fff067b9c54891e30824e5f77c1944e8eee66d624d69e5465d667c326a9a8ba9a2a3919ca3bcf9afa0d70300337a9a109c3b77e52e07420b161cb735f8a55dc7c695ac5cb8a2bcea0365560c74f8160b10e879693db13a131f9cb6094a16b4076ba397c4bdcbc011189a6dd73dc7e9483a42ddea5ac11a7b3c0aa9655150eba55a3ba56aba086b51585b9037283c6b65955417cc8a6b514fbce1da452ed2aa0a83fc019c85ce05de6900191589ed772623ad73283a92fbb9b07299c89dca21d452b6537a695a55b286fdfa2e37eb4dda913c7cdc96d8042659533c9707a72ddf0bdd652722739402817887bb96cd8ea77fedf9da12e51aeb58e837b41002d4b7f563ae1f07f355dca70179e36cc41e55f0fde64a823708ae088a69694d4cb5db5f756a26f21b99cd56fa04ed050dde746f06162869244a8605d766074d590e3b5d350f06b68d731be29532bd24979080d78aac31c207fe53614a9e74cb36e5f8b2e5a41bbfbe0783004c77a0a649e1ccdab450f1544688da6ddb016d10a819c2793158997924ecef636c34c36427c29f0648423a59aa0ba9860594c1629f69a5039731c898fda902e17f5ce62e541b56a84c6917cacf72cc67a137ff34927c58ff84b6c8584c68141b6d3fd3a7ab403ecbdd08dc1ca63d9ddb8c2de8e7a9fb6f625140dd123707110a326227ccbc7842bfd5aa9ed027fc155a2ef8da030a6386b3312270f548eefc6c88eb20f5c46663795dd9631dbfe45575d5fa9035af6546b47d679b02036cc01881feaaf032c5b23241b675b41801d8b37be5a8961849b9f56c79e0bda89d700f529926fa3eab15f7351ab8d67a5fae2f6a71630667ced0ad0f9d5a754ef5ec8045c8dc438aefe8c0795557b2db4a93ae0b410281acd793a37b0d66697e15c1ad2f244d537a554bf36d53e160aa8ee9a77eb2053a3ea6ef5d435bcaa77ea8c29e9a373862d17038b3f41b7e342cee7b9e180ce21ee0dbd5838e7e989153353138d77d4903631410ffb91777db7f5b9bebd5d66aec6594aae2ef16fbadf63cd0ed9af01dc57b02ed7f489ab03d5e2eba8caf5d04d511840dce48355be0da1c8c5f65caeb8149a6acb1b59b50a4d8903868729d148e8d4274d7e91cb16b59e82ab10c8c3d714f4f54926c3ac55eb97b72d4ba78b72815187fcebef017dbeeed57b062df85b7df8f28348760806fea24f8c1600b6e5c9ad7e17e32cff29d42cfcaec2457f856ab7f30cd1ae01d321914ab0733a8921566407954b9fba629c0448a6ccf3187fa62750b70c07d89db7702be336f1001b33360acc7a05f2cc374a4f70ad15ff34c52ded921bb5599e5b86ebbb1e41b3117c465946caabcd25666fd1d7edf75c0706e2ab513775f8c8a238c49eb3b0e9c6ae3aba42f60094b7c7cc8ec07834d272dd997f7f44183bab7f6f5178e20479b7216729750a18ebf5677e9a1319e0b0a1c22d9fe55adc259ffaaba8f34f3b131e006b8ffbf47e82d244a6804293a9139147953c8171e7b0be689c35ff633e54ac95e6719ea7ea5cfeaad03f31c63a8dfbe06578c1abc8569ce1f9a00d1ef61d165e0d3e3b347a0ce03d44f4335074d86ad6e6a40f692d9415a01dc76a88ebc9030d41118f33be2ac3146de9345858c0d06ae288f2a7b7ac75eef79d35c84d1a3fd42b5cb7faf16a2a9eab9dcb33059ab867ac513bca348e091af38ee6ed54de90dcac28c86168038b5f599e713240bda2c40402984ace1410fd9c8d4e8fc31570865c574290a98f5768761ed68258807aae184709bfa986db86fa690129e9305a74e884df6c5cd5b45bfdbcca3aa3dea13b9b8e982e1805d21044a969a370889cced618bb32ca38ee18efeab32246355104e21a51ade50290b3206c8cb419c844ea497bff09863dc0adb8f5c3a025dec5e51ea3eec5f3ab824a5955cf590db9a875f9dbb52e735b634d8cfe5f28615474c354f346a0bbc22ab5dae87da94742ea3e7bd28a3aa8f7b0cb9cba91401092aa77b608d3518b2b04a7f1e93e065be6ae931a0e7a6eceb93ea78e57788bfb59d3b2b45ddb286a513fd0a48103ce416d08dd331f771526473435079441ca0a060e40f393b4b3fe77e16b8d6bc1c94b0800756e852bc0ddffa73e8c897dfd3c332ba21c507aed811da3d0be39ff6597a0fe50135a74eddcb7c4f68c863cb1837e4a208af34d561e0d84a7a45fe854b961d0fb1492db9862ac80f5ee5eccac19583283524049dc578b0b8284daec6181e1d4b308b1500584e5ec0504563a1de8fc00ef25a685101547a2aff6ab62886ab5811f4fb00e2005dffd74a21dfbb8debd16188c701514c472d12ca0a93d5e1f575d02cbb6520077f997465f797a2527d4c6dd28f1d1e98419c45d76b78f2af5df5ed4ba5de31127e4f1056f075a72f716d77e2a8d3201b1dacb59d22a61ece1ffd3e3d8e1b87e08fc7890b850fadf1334853acd03b1feb2f824fbc771c050494fee381c7542730b597b5eca41af19d4f9b43c22cee22cb27ed6ae5e0606f772ff849918b7de30b08a57bf21a1b89dcaf66c999507d032610e45d5094d913e842a98144744ccfaca195bcf61b96f9a5b751ca651d0a4af77e835c3e09e0efaf6665efda482573842bfe235b0ea00437d914d93277f0d76c0c97a5fed00b014560b27cbaf94e8e2b343d8869d771c9baaa7963a4f769ec11ae617228b5fedf936d75b7fb9cfda1fd0228a066cddcfde670fef4749f7f3b5ca0133893db5839bb2f69c9cc42d0d9854259c05e179f466ca8f15d9ac52a0401c5d4dbfd1606268457b7af377bdef8524079ed339e267ae1a65478999821828a6fa57108ca3a780a382a55b0558c3136e3bd3fe451731eed7e855d713aab78e9ebec43e6310ea79c7a10ccd187c86d35e9deb96c5adb4826783d21840e3c36048b3f2f96ccef819d125ab0ea24d9807d0535f1c855753cfa7def4a2863a8be3d3d40cac6055abf27b738bdfdba734f729ddb8f894429c05ee3efe25bd1d030a8d5a8e78e0edabb5d667b9d2c5331727cf167c6d5058747388a59844f0157ca85c4730251dfe464324010691bf767e287b21337a01133f1230cfbbac12d43bb40967f3775306b13e6e4fd7097b8694287d46f1a8671fa20cf33d51665f89de15cd6b8d4362574c690ba57187839447c95f69f5120e51e4d95efb0760bfd2c4c8991e1a4a8c0b79d1d614ca444c928a56675ecdaa31aa90931451a4ea464984691d322041bd05ebc8635900f4447809e503a112068034374f2dd364e16a95b85ce610786446efa473d9a0e350be60208cce974a09bb991a6406227c92711c01c1106ceec16c7ef1b218d0285bfb34af34d7b8253083eecc5360a820daa4237e441f071fc464fefd4b27edb0f480ef192ae587fa99a805045574ad5a0dc5149808549b6bb7d73852040dce7cbf0ed5f0721bbdc5824f56bf3875bd756c258d104e1f36f94b1364aa26a2e49ce0a11c1fb9d5e8dcb886abe4f0f9d1f27c0716ed71b1342b3348a599e422f56858ed5a87093683a82fe03022a95e4aad209fcd48eb1059091fa0744853cd044e69ba6c29f460e9f4d8af0a10b7fafb4f5c9c70aaae6f688925618bbc27d09cad29bbd93c37dcf6a3c9ceb309efdd0dd21e25a83645fbbfb2b87a7e93407e31264f89f6af4ed3e4022f4640961cf9d098b56fcb129cf4971dc3b9b8fc70eccca2ef332252979afac760e20af6cf26c6d09b54b42290f17ff4a9eec01dab5aa5d463b5c55573b9c7290ee33b953cc781fe99c81154fbe121e5e66f1750d326827c263ea3a9681e5dc0256d2a52975d400fece0314c8335a32e59980537ba80cf416b433dd6b9df0314bebb17446d0646c629235c5c6393d1b0d157094a1cee84bb1aa393074dbe4f16852fbae8a09db910af7a3bd2adccfeaf013d98587c51c78e96653539b62d4c636398491758c1746ff273716d7e0d78e63aea748bf9a48237a589d9baffe2fb64244480a4014e341c969d8fe6077cff35c998149cea5bd1706c6cfc2de6531ad1aa84ecddc68ae1c37360b95ce355293b8295b9c804f72c761f3b57ef2471fc2e183e90d14afdc70c9ef4e98e0b46643596e995263606c3867f45daee83114e74e50c3149d69fc933c0ed990789aa0b71f54b1c5a01a8afca063e29f4152054595a21e101d395a491ee8c6d9bf1d91eae4913a09d90910ac0513b10b0fc6513e17f96584c7d9cfa6bc86ab1ed366df18e1b4abc30d0efe08f1d3680096bf9b376ff81c43d04dd4cc802601329b3b26b435d2ec04c12fe278c66d20979941b91ab1ac55ace047b55014c0ede4ee29d0d99086c2821556f4a91179d56cd5ec1feaf0054a9fc0ce0af4ec6c917f156a639d91629985b13542d569483751a3cc134e22d614e84dd2049aab3ec31297a79acfdd5b2e77fc3b287baccee5157fcdaa1a2cdd6614f9db583b6abd06e90d50885a23489e7a9857472fefc7a5c475352a3aa08ad5d2d18845d8f0cb2f8859f2d758f0f67af6116888b3c5ade1e2ee78ced3e5f0bfe25940940b99e7bf1e45fb87f843462f3fbb7dfd8eda26c8af81b4b4ac7160a2e7f887edaef3a81912b5cd859c81e11946c72f6ffd0168437131f03a5340e714066e67f66b2ab2f55ed676e84fb27ba9428905ced0a5f7a119ace3a840a9c9af0d903e399ca912505c12cc4f3e6cdaba7e11bbb3135b4b7e36677fd6859830084d8c4b0e74ccd02d03157c021dfd255ff3537e405e3f1d0fe836c2f1cb4deebb392cc02e6d4c05c2dd910d0ffd18e42f674647bf1440f5166266f5d52be6fd9539fc52d487b82459e73b5e0ca251216d76c69e0fb4c4019e9b4a501ccb53158a967955c81eeece059a5b0207fc28eda87de2470627f8af7185a818b9893a24c81f3920a25e196d668589492cc434bde85ba8926c5fcb23c57f3d301937d59731a0a3d2008c28a5324098b2bbd263c0f9a1074fdabe4a85121b72a74d0b1314385c757be1a86b50537998f3efb14999ab9c69afd4fad3badc61eed9499025a69283ac0bb55bdea481d09ad2569bde73c6f6927e76035ee3a7f80c49cde86b0cff1bdd4cd575391b271755e2eb54e6191c58bfec1961029f178aa74497bfdb42aa6e59bc16d58c95073ac95842b62b46fdcbc309d9ee4b424dcaa48bb17c5dc6240e5b6a2ef2c3dba724a79f4ef1490a8797fad94073897f428eb08cc76b86a6bfd465a694e3d7c33fd9efd540e9c72d2ca80743774e246d1c8d47e55be6853f5ae0029283a522f46f93fdac991513ff38b7471c802023738a479ebd9d38e638da04d557dfa8cd4573f8a3b2a13c19e6baf482e8d9bd0885a58cfbe4dc53c107ac456ecd7a087b3bea4276d52a1479441a00505c66377d6fe693682738494b3af989a84b6252287b2d78fccb585b410c90d849cfe568103712239c1704148bbda4b342fe07a46d7b0cec8046a04fa23ff468c009ca41c4565a93b432fe50b46ac56cfc0f4e1840c4894bd3357726ca7c36ac2625d48104b707e126dbac7bd7b49f8958d6af26797c3037fa6c6cc0346872f0c4ee63a8c76faf67cc06f3dc6800e99bd53c3bd80ab522e700c78b0b1e052220427042ab99e8d5920d0ba4a0789afab4ff41b19c0d004ede52fd750e36730b063c54713c06f4eefc3c7a3c396b6910303b55651867664b102a26208e9c012ec964a317dce1fb2c3685af643016533fbd608ac93ef43cd92bd09917b4b99524a018508f708df0842b10b283f09d80a7026ca1f6dd7c69db8c65251523dd29d47d943e3f628b548130a0df5cead0d2e413be2a33efa78247feaf4d5d928234d182baf073e507e2ab859430d7270a60d30747f770d48adeed3292b7b2c958783e3717b685c822653efb304b304b46ecfc9ee45001ea15f7a3cf855de4a51a5b75bca745945c0e3f13649f070910081b74942ebdcd3517785c242d5b059ceb033d592b5e373a64d15b43f643dff7cff1d9fa3faf8fd9ccaebaaeac358551feb78a3c171c1eb5ab8c9056b7596719c4179d75f1d44acf1679051bebfa68b4625dbcfa06d9a8cf125ef96338ceabe6bc7866dba76f917bb5ddd7c0119be7f9bbe84a9fd1d83c12a5f408698c43bcaca2085294354c608856d9763d1b58ed569669943c1e3510f87358ba2acedb185862e1e8623619eb03d98ba6a079d9373b04b3d974a3df34c116997b7b0b33b3fb118f34ef348275baf7cd8fc77cd196936b2f97d2e6a215ca8aed9a51b165073dd125ae01170707890e3f77fb6c7bcf1011097c054780447e22fdf3175d571aa70659bc756783539292635cfd6b8eb8a2fbd6e5df1d928321fc95a167fd398411d2ca9e5c0f11894443c90e190ede01c600237bcdf17ff8d07848448112335ad5a0384f11013edece710a09d1b1e37b5028e54dfd1ce06a3da72ac05b46b57b833f0c6e37df1db78abfdca95c7a0f6d5782ceacfab292f060d77e640abd6f6c531891e69da9176a41db5f66d47234790340fcfded2d89c9ae5ff3411ef91cfdf4d3be397489123acfa987635d4eab837f9cb27106b37d55022c94f2bf2973b41c39648d59be7a979f871b035a1fdcdbd65993bc0cbeadf1851485299b9b977c025008c9ab8b32c97eff29392bf5ddccccc1f9ddbdca4ca42757021703b46f624c68b538cc98a12121528474c1475868c19d4986804b7bbbbbbbbbbbb628290e0b3b31d37f1c8e9b0c8fa1387002f16e06aea6e29a39400309c6c3163e8b5acf164c46dddc8ed07caa072c3531151173750bac1e886a4309cfaece8b19391b9eba279970b2e0422caef33b2affb141b63d4589aa67dfbde55dfe2b66d31fa5744f66ee8d2dd37c61853bdec3451882863163251926127d34f9ca5b9dcd98948501c1276b056aecb65f4d9f136668ccdae038e893613edba4f868cc2704c945f3291f74800d8907af94154bf3d173fa005536c50f9db0f69514aed555f90f6b5e2fbf8cb83e4d78adf0882c8d7be2097bf3c09b87d12d027f555e9d00534e587bf9ab08419d22e873242640bf59fc925987224c3ca4e8c3136e9581500329a54f9a908c61893d0004510485f286d6962058c47c42f0c1369ac18c71655fe54c30555fe46b184991a0863c450e5cbb83748428818638cd10331c610c3a5c6d805e7504950e26a982c66d5c8a096a48005944c8c998c0d1d8ec814dd1023f38215349119a2c80260c82cc124ca0c2616706a22c3e5862f51646650a444068c1b88c898b1c102543c8911030e16f87284130401c058c2e40585872c4ba0b858da07644e4d929a8c692f64311b906c20c306a2346cf0c42436864912d4f2482d6a1e5f933146c9bc05b7756577a4fa737b715d712291cc51b8fd40184e2b706202bba1090c3064326a46d54c8ddf0bdb997aa46b0b488e7aa3c62f4c81f6c9ad9bf632ba103f5617e2e344fab1564434aca9fd610df46de07098a1494abb3f5a23bd758de1f60363c42c812d61d2637ca006514a9c94c8606d300e1cd0fd30d6b8ad4292daea1a6afc3589732fa979ae72724137c62825ff7e2dff50a0a9fd6d6533a4fc5ce88f31da3e8a7493730e628c51070be87ed27d77e516a594a1ac45bad8b030ae0eebf8816effec662835d3b959fb26d77df9752791dc5a382b92b342a3b78203da68a38d36826ccce58713638c5e39d2a7f281c7f766f6707804fed87275687751ca9e1da3267bf8a0b6ab1177706298b56be3152e80baa9fe3c9a67f7a34ea8bbbb7bb84cd9ddd7290046d058c3ae76cbfc3a64386e1fb79f31ca9f3f5b93114afafaf3c7285beef4246ec2f776c13f8747e09f3bf6c5dfa4b5bb7ffb87ee66f160f6ff68bbda8b3c61a41b54ddbbe3ae9432eeee8e4be3393f8489839cda6fcf693cc250ff9652fe87c03b48000c60445c84616262064668a0c90e34389343163b98e2454049f913ef24452bd0e287a41df84003154f8a4fc2d6eeee6167ecd27425873262ae8851014622ea01c64c51c516269808a20897c1961a30c1c1f184aaa0faf7f6e8da3121ae80820c8c95b07240f96ba5c0fe49aa2bb50bb4c0a28595ca7f02901061988490c2534480a2fddaf342c5ff218292b0bf886b5f0b3d2415db2e4998a95df73739b93a21fef869178ba084b6526817be166bc7c7441ab573e4b7eb5d3cdac5eb84a5490dd74989863e4d34b9be38e38aeedeb5cb9d992977c739a7cfe9cfc349a1daefcae572bc82c0bfc06da852deceeaf84f6efa967aeee9b19e3f8efbfdb39eb5e38fb48b3ea1fee1ec7cf8330bdc49c5384e0a0dbbba404fb3a62fbcd4dd528699caaabba50c3195ab91ff020afcdafb884976482843631bd53bc6ed07bc80925153a25423538dae3dafa426b58f5a8c5fa87d2e685c94518b316ada27bf7dc12b7f8575b1e3eaede12cd5df54fe4d6a1abf4ca5bcd5e9dac57146d6b6692b5e1dde38068573c518638c316ad23deeaed4b64ddb18ddbdbbbbb5f8b1bbffa8abd32cd69ccc3fdab5b4bb37d6c6d327b46b3f046ef7a04b4d4ac571aa94a66d8cabc9d9dc944a95da1c57f456673fceb66d4bb172ea4a7777df388c7126d95dc6a86952326fdba64929b79a252dae5edd7ca6acb15dedda326874cf9152935195d32eafc6e75d1fdecdae9bbda5e3563c68341937d50a38c6892915192783855e09796215d7b9bb0fe936329b18db2aa678a4562c16a5fe43687cb058354dc494a879bc86de44d58daaae8a53a53457a9542ae7544e44cf709b23e78ef628b56d5b75504043625c6e95d3a57efce5e3a3c2ea476a05e4bda254bb9a48232202f235eeab7e56af38a75d3f9b8771dac5dbca472af08fa69641798fea5543ed045381add68243bed6146e41d94588004155debc6264a4d2a2a6b9e611082866fdf191ca63236e83c2b33585e91e0f92a4b49556ea587be94d6b2828a82abfc734cf92a9f2f90c17b54bee88d1fed83ba8e03687cb21a3b3ca3258122c06c5240595bafdf6feb1d991aa9b31b5f1a91bd05aa183a13585e6190c62908bf852bb9b53e551cee11f23cb1145c366637b18ccbe787ba8b13c1d667b3aca5f1c420c34aace9fac0fbb29ab27ef612ff6c54fa64ce577352aff93f70ccabfb065bebd87937aefaf7e1a4ff5b1886b7afe2e5bf273dcf5d3190ab5b35379d67ef29eee992b6366820fd00f7ff1bc12e3591028a076f17fd0792cf3177f121495839bbb6b9aa6757c0f716aaf2ae020c7fd148750a2822d757e3fb51857c845705445fac5ef1fab7f44188a05f70a4490534a54881a6e540b322068b850a9c631228b585d1dd4c5e26949cb512c06ab61d80a29507e2d5f30ae82b4a6b0c0f717abc0055b53b45f9065441935dc99bb76a4e7e3af2b43b5178885ba92c52e3b10b4cb818a29a104ae288b448a18d515eb68294a110c3c298a13356428bb9483931a466e77a10122f01ef91de0bf998081e1ac6bc4909e86b1a268f547c2b0a2a51f70a8fe4466ad2f701b2ea31449f9236fc87e78cff4214d3274c5d03fb8e9a57e67474b7d3796d0709b90782472d73aaa8ad66906a2eee9fad5bfaa256e8041c3598dcc663bdb59ca7be6f7e41eeeb7c7c63daad4eaf403790ff7a9f8d5dffcd2bef0c6497ee107b53fb6b7363882c4c89c4dadbdccd45c3a6132543ba85ffd48bc8784f66242ec9e552d41bbf697e3c47b4eb0affe18a692271c90ac0e0fe12f88a328d155f79777797957d3de59ba74e9d2fd71982e6cc27c0cd61ad6aee62149049dc5269a18d2344dd38e905490180263831a59a4903dc1a4c687a218c8a198e44a524a29a5c6b47d318368484a29935c79028b35a6502286882e9c698a303da8be94012545b524a7abcbb483ac0cd72df93442b04147101d0307b34359ff392e1e06604206008b1504c8328500aaa05add25a62e71dd054b4ef0a07ddd25a62975abbbc474e44d96fa0a099ce1e405982b76f8618cff2b5b0f9a51d1126954839438bb03254ee567668900a4d0ad2e130f3708a3868d8728d5290ed30e666aaa2e130f5cd490fe5cc2b7d490f500335fa0aefcb0035292ebf0af7445ffd36c41f77763661cd89318f3182d95dd573e689e7bd54b6edd66bdd77d230e272326ef3d52aa714a793bb1976d979d9aa7bf9bff7d766a9efd7ed058a27fd050da11f6b9a95decd42eae5c436eaa1c26a9dbd51ecafbd347351f3d1b7e72eeb86df536de115f7d8d27a45d71e58366cacdf7cac7ea93acec0d47357925e811627737efcb18a5bbdc26f6d23c2958d38b81daba1f3fb1d2c7499c5457c5ad8c454e9abcb84daae3525d978ace3aeac14ac7a58a624d4c36f1db091bf911151db02751b5417e2e95e4b1cacf58f8dba9297e69721813466a29ed62362ac2b1030d39eae663682855ee1b8fc911af4ffc73fbc2f9313f0d214284610cf5ad80aabe85e6514d6905b9f1fbb552d829ad203537bf5f6b63128eea9e7801f2976cc98ebbc48393ea41e51e1ba39913a3213889872d356c2a957bd7c9b35476a2863c2602aea3024ab43d36080530dcfc0d0d409ce7e728efc1f982664802a200e7614801ced3c020ce1704821fc09b1b5f1008a2802b213734006f40d615fafc9579da5c000605fb2a0e28d4c5507352eecf63a80f7ca0fba9d4f37a5b395ef5735c149ff11a66039d1f721217e73782197dcad971a620c314685a6afbfdf678ac34cf7e0c2526da5c00f6648408d582862b2352a47b3e0097a3b8547e3ed3b05dda010a6e871f87057787a356879f9f78f093cbd5319bce4983f382168c17322881422c45d1f442b4040a0c1a018b2d305088c13c394206c65640abb7d0c0cc0cecd14314483118c845efe834b16558230b224e76ee05ad0da03043060a390d4ead15be209e728319a240a1550d33d03f4619b460e6040aad5e8004fac72f8865e0a48918284473c611e8df6eabb112276494c0f616148adc38f4182bc0785a2e509834711919506902395f42c31846a0d026a31b460a18249093ee04ca4a1328d49d39e268dab08596797483153230888198c129060af90e47a076460a1033b06938228a285003a306982890eb68342d6b1c29f10ed6698b2632e712f58453ff10454313c8f96ed114451228d400323d84891a0c6a98411328b4d383981844275c684004725ad79e27110326723003b9ad6b2f686540d4c00914ea34aa84818019c0cc402e654506284ea0d00e94334dc09c56407b4108c0818c245068aba0828015283102b9ae6b0f0135d8900472abaebd03b4414311c8d174ed711618cc10052e93922e512047bbf6dc8719c8000672365d7b41ae0519658a40a1950e4f14dd74ed79d10f349881dc8daebd20f985071a66a0d03a1501469caebd78650b2d92400e47d79e63a146124720373dd0d13550e982040a31bb1358cc38710472dcb5d76a982992815b85194dc840cebbf63887299e20818cc31145c8c0a03ea3062398b604092b92402166bec107eb7bfa98dc75cf751dcd8faf7e3e7b21d8597561f5f397b43871dead9ea5303333f3b6d1d4d43c57b3d56c5b951f4b69573f8dec35e856b93528576e0d2a2b173bd51a5a975aa1a0aadbef340f8b45a993eb3ff0e19b67fbfa1989f2cf9cb88455ad41b515ffae363ea2195237b903a49582fc14f091ea4377e276f2399dbc67c1e94a1ee522384143f752bbdfbdc8afb5fd5657bf54f28e6d338d9e3ef8f0114be1595dfdacabd5b3e72b2f7e77146bd84523e0da0a838645e2d6004abfbf95be161fb5cb632967d0bf12553525ba8572636957c76a33c5ca1ed7560ae189324ddf708184adc7713268e0fa4bbed7efde1159b1a0618b69a7586d294c5868377d1dfbacd0fdb063304683e3a464667ed9d139c4bfb065a21605f8b55f41fe7e30eccbd73e18aa04d967180cf2f96b2cabe3bffef2e7dcb3820ec94f0890cd0d686a5ffeae239c5e66476a0e7ad05251430e780085b62cd0007fb4a630ac700128b45d010350bef605ad164d4e4a80429b1210a0fcb61510f2a8fc49407f7fad207f7ba92465c497d60a9f267ffbb4179a33dc40e70e166d0591d383f6092e567801063cec2fe5e73c1454fbd9cd5782d5c310ef7922eeda1e5e0b44b6ede5a1fd7aa14fd55ee09e9db5d0fc0d51a29188d742bbfaa714dba30544fbf8da47262a667599a880aa05a8cb4485953a9b87a97e5da62f522a173b5f49b949606b94c0566d86b2b216b5fed82cab06a46b7f093c1026a9fd496a7f3f0da4df05ed350f4800aafcb65d75733c32e198be38a9367599bec0bedd1853af799b53a5b7af79aa8f5e00ea265dc6df3eae50e89f807cd9d5cda95acec6af43a22e4c76256e66228d33c47df3040d5766831ab342458a07b6c7cff668ee9f2d1e83a7d82f8f45fc34ff682e445aca5ad6b226d24da4894c2dd409112832994cf603886a319b1cbac848e7b0cd3245462277195f70cf0356cbf67cfbe2af41ab600b1d587186146210000a0454f61e95dd0b5e4f29a985763191fe3eb023f87f42768c2d4d2e040d295454932225d174515c03494a9467686790ea0f6dc30119cda4ddcc8e934f4c16ee0c8b152ad508926d9a91718f4b4c14ef88f11943c61828471e738fcd8cf88b998d301bd16464239a9c363a90329ba5543355145c1a45508c60b1b2b9fcc53db7d6a28be23aee3eea280dc4aa8b7240c39d4d1ab9e7169ba3a0b151236ca53a9bcd664a9369622370699f1e4858b8a3847009fc710c438cb00c5a40b9913468d8b00ebba836a9bc89bc67f51edf699a703cde11ba8eedf3dee6711e9fe20d2e768cf8f8f8e4482aa28b895ec0eb4eaed1ced9a60eb149678a494a95834f556a23cee1a870dd8d0edd0a071a32d18a0627079a9a9b266ae80d26166a08b5c942e30e269b9b3528efcd0d336ee044a191c331e273860f0e19d0f8fc383aefe5222226f282fafbac8f07396e80918395c5647573a3abe33f844be0cf6647b8f1c54cc756417dce9821c30a13319940820924101111f9fcf08f65e5d0f16388dbe112f8a70008b0d9016b87fba6053d77543bce83c71b5de2dc51ed481c208af8949a130d37c6f270a763b2e3a345dec0a0e12209194af59f1d1f7f2d2e0e1d380e070dcabbbbdddd3631a0fc5a7c5985f24edffdb40f8165357edddd0d44eceeeed8dd317677f4c254f566efd8da1641f9e3abee8dbadb366b65709b13c68e9ddca6cdeac4df1882d4be6c44b0994046d9695b472937d9cd8a6f33048d326a51eedd44d149bbfa7520456ece2dceda1efc5df9bb591d790304d555fbea7d495509ba3d761dcbdf5d6af365949299e76b9d9c40ac470da58ddae51f1849d13185c6a32e4654b99aee612727560b8d1144598c9115437efae019c939c9830f5929c7c7c8454382e2508d2f24d620699ed6c718a353c4e98f1f7fb6d8a02def9b7e1869887ff0852c1d5f485939be90e5c117521c319c2f9c4621f59b161b34ec66ee365f386521ad29f21dde3a79cb521f51f50ffac610aec99afb2c5839ff0eff863e55b00d4766662766e06ea2061f93962dae2899a8419558a65489455665134330f183ecc9a104462e4dfeb38625a6b8e2a5ba6a36c1344e57643a7fce7905cb15236a76708ff8f30aac4625246afcd6ca47a4341011e58b0e9e58d0448728b248d1344dfb20f5a44445893035be8e958f488bf83259719f60cae149e205498c5102a96a4890a9dae758f9d05c55601113638cd183950f197657e454eda3f6338caa3d3d628caa3dcb4a1355fb474287236ea8dae358f9d05c581c01e6468c31e270d951441a463451841155fb1b2b1f1aa54bc49002eae8090dba28e150182104b793ce8ede6c971a76496324c5a0c6b759f9883963681874e5438b677471b50668da965043126a6842d59629842a59aab021832664f005112d20a28baafd5639aadad3346591a166a90a518df157ed84937c4dd3344d8bb17972545966aea6254a142f4a4a645c3465c9c2c251e4da1e4ee5892acc1237a8a416638c93a67eb99c06d490c7135a96ac3040d57ed218aaf62ced9f49d5de25c41455fb9d1554ed7d8670aadaffb0a06a4b31b8220b6e4372a2c6d7b4170c41668d1fd6b8f2e505dec5883238b9f221674e036a5c42ea414c8d1fe94e943151d4700415596600e35c9460c0006003d452e3c777aa695786543896a65099223c99da26b7edc809903094acec6003a8288c80c8949682f8c208880d8a5831a4a52c456c6abc92e84ddda52c2f4882eea8bb9445869913b3073821bb517709872527742883f67b6fef2e37af7cf65ee8caa05dc39f6550aee1772d5710e83a3dafda1534741de99e4e721e924907d89ebef9f83bdbc3e6e9872b5b2f56b387f86b6adae86071f7ae0ebf8dd749de53a45ff1e36b5ff1a39918d3a871e38259286a7cd5174bc5b88076aa317e38239176bd14347424588def48716e7c1f6a16941a9dd438654c20f0c154606b05185ab45d314aeaaa3102404643972b27d2744a8b18a4356541d6ae363eefbbfcb5fc85eb64820f945251513c8a694d4949fc1c0d1b51c16691e324ef6125fca4f247a548c44944f10b3916e78cb18bab18e5aa536ddf7393316a1a5be917d7481cda3d8d6ba7fb58feab5fb0fb9045e4323281e8a7f37ef82b16c41be22f21575443463256412d05015b828192f61a0c90ea9a517749ca957f0a43bd1899c0af02f7778c8cdcc87dce55d1eaf0774882f00f274569cc7bf84914218ae0278e19ad0e3bed60b1b4546a4e6e7ee4542b1fa9e7150af3b7d7e616a3f69af69aa63113738e07e1bef3f9e13e97efa83e745556815540a010fe9091d888a1b831565081db17d16c38aa53b62f88c1d60adbcf9f1f0cf3b7af06d97efe377bfe825b7703e12f2e0b9847c130e03d2278012606b6806cbb0aa27dad0952d54fef705610ede517d49ab2e3affe7eed7b97bf3af60fa02b50fef953d4a10b19454c45f3e733c1b468991d390c894a0f35eca893665d44651cac0b0065a2f88b37f2392a95f21ae6af281c2ccfaefc56b24df4042b4b37015086527e9ab2d509829fae18b183862573445136b6879f6417557ed8f116dbc3515c832adb68abf69325a1629d7cf7f7afe352352b1fbefdc79523f1fc6ececa3554cb5a42495977547f61cf729e15030d218a2e5964e02165e84aaee44a4a3e49d876bee7a4dd51fb926f6482f4915be891595bfd496a557dd8505256fe9c50ac1c28c74aded34ff6253f4a1155be92944e6db43a12ca09a71ad20a15c4a0ea7f3809003464074d367e8c9fe302628107e530ed35951f877754aef1fd9f66a73efc9bac3e2028eddf811ea9d1a4055328b78ceeee21cc7c0758aabbbbcbb8d345530c607bf47b7f5d506e57bb583a50ce3bd512b4e917a309f1f311e10a6522a8b7093f3eed62614157c77b806145b1c58747102933dcb66a620201fafddc0e2fa85d60031318b8c30b0a126223643cc4c02af377bc083aa040b8974254ee93d4766a9e30cda3e359bff9c66a0f7ad6b0380fa85d1bf7add607df4c1e4ebb5aad0f85ae2dae6edf5468533bb598ed7b4cf77094eddb8a53dd24b87deb03ee08168668336a9eb0a554212a109ff1c2c40994ad35bb99460d0ef7d1766d34eaf01a69fbe875d20e19286c7b96c74349dbb3d3f639be90a56a1c8ff385cfbaf185ac8d05866e543620a5e6a1f9ed1b4bf3a8d0db37d3f6d07e93cf79e1576ec8eaa777f3d10b8b2c540739d2757e3fde4fa14fbd01e16d3cd5afbcd67caef341f05a292198d8526b1a69076b7b6e87b75d10310403819a67fe4685053210a680f03b3ca0e6f9eeb7e7be1049e57e7a21923a9fdd0be777c441f85af31764a15fdb775f6b7eacf313c2c445cd99f3fb8f80fcd5d378ad14668802a85d714f65e5f168d79684d4aeed456883ce57a179e647a45ddbeff0b81ccc62e0ae2ab06df377dab5bd099e4fbbb64fe5405fc906757e612bd52d6ca4bafdb46b73b6cf0587511568dd1fb076a054287f1bbfbd233ea5fb58e8178f61a24e89d95e917d4261bfdfbd10ec537561bf91585f682b050f859eb457a576f77bce20ede2ef3d3e94ca3ba5fbcd2bb24fb55d8b71a7985591e45af4199130fd19699e0d970cba83052fa85ffcdb218942fb1b22a45d5f147de2518195449178096a62183f50f3c8a3caaf42f3b0a050fe1fdc2d7911537b3581fd0e6218128e88902726e2e13a21baacccccac04c6520c5566662ade4cad1d12b444f146f9f8ec33d7354a7032071774ab5c41802b03d16a2b85cf058d9bdb24abbf0a5400474b5ebc8ce1a63db369cbd462ed3021a6ba6e897a73fc58bb1878ea2e49115565f4a8e6e100fd10a10dca83846ddad9d99e6caf71e1769ca191080b438eb4a66d5d1847f45059fb8aac530a5d18473cf199554e56c2bf9d26e8d6d8cf0e25bc20edeaa75cc352146264f4d6d7d6b25e987d90419a877f9be1e989334a0051c39e2d085150ee57cfadbc86f217b39ed0d404bb75da50298772198c363bcc7bbaafe53df39eedb74a46cbbff9dd07c30743151852afe27ece397ffe0043270aaa1224154ed91eb67d42f361f8d4b79cea22f53d09c181ea43156c1f02559db27d3020f1d747c45faa2e54dffa2bf53191bf70c044f3abe2dfbdea4356179d8fbf1884293445f35bcdb7622b7e53bad80c8a6ac84620704137075dc6a00106c230bf05443ff54940fa0555f1dfbe06a95d9cdac2cbb1652876aa4d5e08183014ab468a30602856a7c020b4c9c0d46f9fda425b260216da5fd84f7593810ba63ed82603b7afc5338ef217d450c38e70f217ffa6c9dfbe4e1ad3444c5a16726da6767592bfa648bad2a4863d6b275dc4db5a9750ba87953419542a379da91cbdc3e6d6b61766a6957ffb884af3eccf28109cbf12b4d5bfe0a6b630abfab0f40416232c2d20db02c2ad9fa2fa84546095fe24759ff793d424b50544abfdb552bfadedabac1b695af27342bf260155e3ee744ee8cece67478436e886446d6666d5582bc149521db3fc6c36cf458c9663a9e90cb7d8ab7f10edd931455f869cd849141f691d817e0489c2e15504ba87edd1411b336307513c81421cc59725c02afda0062435811f4ea369fd3fedfdf0819ef00389f70075511cd43024ebf403c9eab88deae7871bd5b56b7bdea889a30534649db0f2a1fdaea226a36c7d0ed777252809ed72c7a9db05091e6ac84426f8d4241dabbae05a40fd49407e76fe1610f3b7fe62b0fb19ec8fbef6fe24e0802e9fa04203b58be3d57e394ee809f6e5ef2f85913e3e8a3a8a95c1450551fb439b96c02a02ea360d9d51696da212e539417168a1336e67bc8b1815e18ef0c38ebf711ff990d632b1d2f7d43d4def8186ac1424a9306385cb11182454c3c3141780f4855a32a411036b825a01fe351e9256803390d404e47327c5867f0b5989abef121458aa4735cc4bf56f22265090a9feeda47b968b24180c16c32e4d61a63ae8cf6d6c85612dd7e2af6a8e1d1224341c551aa2ddb3d2d675bef2d1d1acc47450fcb44350f304bdabc29dca4afcd3dda7f23ba11060a15382ae334cb56a354143b6c25492c4a86ea00cc54fedf2ff9ad0a54fabe36fa3023a47c0f5e90857b9339f676ca679564b104c75fe74549a4154fde9a0e6d96fa2213fc57797a2fab399edb1b5bb9f6284220a29b5bf9c6f9783536cb49fb6f16a94bcd4137eac50212cc4232ebfbbe3f7d7fa515598693c01390e5de718e2a3d0709f7866c84c5c8e01161242991583630c50804eeddf1edb7136b553b59fb74788105f7d47646aeaa8f36dea4cd5f9d3c6f358db0b0ee0df55737bf7053c046739fd82a05c4f5804833e3319e23d3f29eb818474169403dcc37dfc211bd81ea98ff353de065627fe72805ff1e38c7b465c356a8c435627c6c8c31237cca0e14ecafa77ad53051888029302abd31598abc57eb1646a8e9ae372fa6643b5046d9edd1e110c6003fbf20f67eaeb6f00db83045c9989b9690af1971764684531c6d2594c7fe9981ce3588f0bac0e06f8e5afa37e21463885e4b0802ec736a6e5c0a996a04cc6b22064a1a87c44d096dde430146e98392965b11c025b7dceee2c88b4d0aed412f42b83f277165886b828d13c6100b8abe9ed129959939b9c526eb29b638c31ae4777d75ec02a6f5d3235b70c547fee8eac52b1b721d3344d8bd107ae6776a8a3ae4df476775f01e1182a4ebf2825c3a293d9bb70817243ebcfb5e3f3365f3379720ddbf0cd17b2ea46433a3f74edf8a4bc3db9bddbb67c21847803a75ffbad1415f46342d070ce36a2e669178f76c9ee62f7a87e555e0bed496de7495bfe9fde96507e2d885b80431950606090d08241620656892f5423464b1358a5bf0532644370a2a88b47f7a89e559a27ff0b1d0214a479b69701a6a8a8a42ef64435756646000000008314000020100a860462b1482c1a1236691e14000c7b9a427c56990a84519203310a21630c01000000000008608066c4120025949beb342a08da99c14bd40aed6e5ae059c18bece3e31c32031202481e301737c55a5b07996a4ef450ab8c2c9344c846b0b4ed9c39f2e3e8455d22c6257bcaade8167c40387c9bf12f38617fdf5e8a2ea2c7bab614bd54564dd3a17670f89de9fe9a112a22d00169d178fb531749f72dd5877d220f48ff91ab95c5b8268c8f25c178a7404d68694635be7478476851009fafed2039e96ab767e9e83ac46814d3d4ca2b497301e6338da96dea5e2729b3d48a6dc9a6d87dbc21cfb8d6f41ed4a8735b32a40039082e76c6040c40bc1a446ba2c5f59ca560a3c5451c72bd6bfb325a370f2c9d559ff0d6f893ab4fd1f12021e520069a0b14516b6e0305a22945032da57ff829965ede15325b2ab9320edd598e99f7b3e45d98eb05bf6f44c1bec7a7860ed09932b335007cc3d6f09de42cb657c656d9edf2369de1cd2eb564b865d9fe0321ce12d8312c8509375c4f2a62f0cdeeadbcbcc761d82f2f5b80e6ca90018b2a9e704d2c94fcd6a170ad44d4ffa4faf775322fa1579b46436aa18636555991c2c3a06467aa2d27554715e24a3d38b2aa1d61f45d7398236e5d57b35a4d3011bd71c6ca5d175f0d215d1be0ea7eb60eabdea5ebdff72ed14081ac7342bb16eb2a84f3643b2707906d419451504e2ab2460bd8267ba6abe7e26782a7d0550e3d1b826450ce28e53d3d325785889bb5f17648aaa8e011338940c4c03c2be6fa9427e5ada20d6ada7118b4f507f07d0990ce6c835a1d9ae8d8ad303a4cc1a7975b6ce2a9b378a1cab18bef6e11bd7db76dbecc43830b5d3737dee3e5f06013567dcda06c34d1438de4423fe6f985ea5ba9bcea516c58a060cd26846d2b9abe4bc1c98b08d69255f68221b9a75c9018be647c0e5de9f24a5ba6844ed731fba7e47ac6fdb12cd543dedbe1c3b10ff92d4219b935d7485d0b8bfc446c94d299a4f87b9af0a838b0978f3481cab9933c6cc36f4cb86d52f3c61d63d307c9b28680d1f364b9b1c8dab150383a7222ac62492a5c686a9835a0d513a08dda2463c144a490ed1dcd06dc77f16e3c9d0b94dcde994b0f13d5069433403a4834ae2c03f76ac35318415d3f208e3748e1ee9ff10a859fab119769aa2a63ba9a7823d9c72f4b1ef903730a7a46d9d2cdbd77ff8367e2e871594a6e75dd028f7b9086bad736b6247c859011fa399f401c43b8a742cd9ae6cdcac91ac54a1c9e7cd241bea75782ae3bc9e53f9b7ca7c8f0ad8edc40a297681b2d32f574b0ddd1eae80e0eedbdd61d69e3390e359ea48a393985c96d8397d570f74d7e6e9ed7872bdd8f299815a6d5721d05c17845597d8bf9e64c8ebc5d33126c9c35b5d7011ee389bb5e19b8808cfe9055e606eed1795297ca82966dc8ba3532dba779e7f91f14c0f25e8460c9a4ee4f238247a07f5d624d25548d8f0d15d6dfaa3bf4afced947f0ddad0d1d9ac8b9254dc21f769e44db7bba0f96354d7b45a7e0d89523a666da797c33b17572127faf0ff3ac99d0088b7e966765ee61590731521e813f07311b2251a5959c858f9601aa44d11f53fa49a8e62fa06a5efff21a07a2647b5bd85e31a465ec3b2be336f94ed4db158173fe8719450e01f99cdb3486540eb93edb6036baa5853fc5f8d312491a6cad9896d0271892f12dfa7b8f0388017beb01c3faaadfd32a4b189b72ab2daed67499490dd426de2a40d1f7ec5d56271ae571b680d48d341c3269ee8a96442280579123815fd02e97bddeabd35bb7257ea4ec1af879df3f74ae0c01c6f56c7076fe3ef7e05bf0d552ccd2c733c7a0cbe9546053c312a870ee00db5f3ee538a969fca0ce58e672824025a679ce5216e6eeacf3f505820175ed3be7a5bcba5460dbf1ebd60ef02d610f3c3f90cba9e7648b4187455f724c5f9c9f7aec75da96555116ecf3f3fdc218649260d406174def4f2e2fd267e81cfc8d7881d1c92dbf9ea3f5f154e81832cc46cf1cb0344b7962e31fbd5471f728928e93e69d692670a3c84259f220c66045f1cf5b75baaa7cb0e7ecd804c5afcdb5bfc7c4f8c8ed88d8eed88eda0a6629be786b8048da6d3a2a29f2aa7d965a1550cac60aa52bbbd72c665f54ca6a5d5b2a96f02790f000dea89a31fdf32a9091c6cff0c4eb1f6fc6781d349876f8e1ac2b23bdd70d43348a09c35e3b22bba9ac6486b4de48388afd0203ed374b0346ef63650a0c0dc33fbcd6e3d1f550526c252c313beee7f8815c809c0a0aa431bf552228eabf8864a558b2c1139bec6d35a49e2b7d9d3289cb40cb3832960e6ae2a903bbface4bb5a99fd5b1a8bb24e897e62cdaa3518a0424df95d2146611e29742899449e0927ee966cd051005f36cf42e0bbaf5ffab32b0e7b5e892a665351b2023232ae6f5e8a59da1ce9b54d67b4c6ff3b1810cae5b9a154514266a98cf040645efb3dfb63aa5270217648623142fec434f1bc7e85c4dff0c03f4375fc9cec82941e533bd73a889b932f829ce7b343e6be751fa1fc5b7e5f5bb99af0842199218465909134e78404490113e247b12328fd15b10e40b4a9e70ba961ca33ab1a8098923d29288f1ad6ae190497d2538c52748d3ca7c63276961871ed89e44d2d781b8272a8b89eb47f24007038b2fdac94fb49cd859854ac757cd192a8c4346a01c6f3f0e55f0bfaa33cc79463166a2e2d1fe7b623b52ef03e2560e813f1ee2f13c9f125a1f49f259abf95b4add92ed9b2ad2ec303c41789bb1cfb3c9cff949653f6f967f462b7175d4919e65f021189b2c40db4cb6012c6db9462b70690208ef7dd6070191f7d000dbb022c630093cd3257f81b2d2c2e9d2bac7194ea88f4228766636ca966cd997ec13b20c7fa672291090e7a370e3b5dbe826dbb9f546e4fbca1d20597c57c7ba254d4a3b5c6f625ec79561012156c77d581878412c89f76401ecf2e684804aaab91525138b7d42255a4069cdb5d2c4e54234282ea76b05d96b6772ce236068cef19c5b0438ac8c37895c8352cc0fda0bc3add46852950dc1164546f8b853f1099b9fa9ddd38cd922481aa35c12ea5e1bdca18b577f1567d391fc64b7d5d04361bfdaa5c6536772f6e5db87efc213fdca1b38f20bf81d2a7918c74a5e0c6d3fdd4dee3c6db28791d667823316ac4e01b4e407aaac34edc907d790cc1353c67accaa7380c9a937fb58ef3630662d90e7b39b38c0101b606183eb5d5da9267fcd6801bc20d79528a571e3cce59b3b2e8da18fdf55806a3cb16fea53e3728b07eebc2979e108f8d2d9b532423d231e506c0546b2a7793284d9a07aaea5d03ecd9446d6a27f8b551dc233b1d869e85f654fe929477169c237d13542ad3810ef416c39e0e4dec26d093682873d6d909dd8cee81c07f72add41da08950eb414712285b63d1fa6a0a99b1d2a80bcf4dcbd8f407f3492cb86b4901141ade321c9b7147c20ec43306cf6d8d72b2fb3c962a2e1b547d18e239f4b9c43d65fb58a181e09a0e43ecef88bf95cc7858a6ddc8c0e8c8a8d3b3fb407e37d2a17cc05832d064a4779f1d3f346b74ff69f0a5e88cc5b7a56d6113aa55ac246f96bae29a6cbd62131b56973b7bae3bf81fa0ccafbde42e1996212a081d6d47b6807ed3a5d9186d4afe6d31535b3a71dd6fc41cb83f1906ef84eb21afbc487d95f16dcbf9301f03dc10cd19ab81ad9be7bd9a68b4a4e5d70d8d7d77789302ac51db2bf43f53ca3647b4bf3064c51ec0f5f5dcd40dfdd28bc2d94d132cc829d13349c9e6a0571e3848b2b0228222491c2ac0d7b31e56c942f5ed68bea2724deac0271b0c2dd8677f707d4b0636408e0eb619c5e89def5ccec3304378e622ca32ea91fbbdeb97849da203b157a8951e1ea4bda398ff50195f042fa29a464c76126be7191fe2365e7bef6f5adc696f30c5ab448edc05019b47533efd2d1a8e9a98fe2d2f4f71da215cb33d6b5527132174d202ce7f46eed2682782c472200bc296330a43d6164f4a4c0e8841e907f3bae7b61a9f00deeda2385a7ee777a3bf1f67c65f55c81ccbec3e582f22f2897432d2dbd6e071d5bd68678bb4562d645c79950edd76dc7ce9a26712c3b788875f6b7daf8dee73f79737f314c2623a24acbdbb193958ffe8c3f834c659dad64901b437b736e823824d066221f9f296c4b07c961e8431238518c86e4a20ad19a8e14bd1b772234e0568b6c690bd31935380b6cc9f50b5ef9eed3af09fb477359a3f226e6087793d5e49ba0343cc5e6b8e41534c1a6015eeda31e3871306aa5075471542bd9b324417e10f09789e663bae8f6464847544fb56fde9f8810ece2aa1af6df348888352d3d2dcfc0c19efe4445b65721baa97730f665fe1e3dfdd9cae5c7281e553868b48c43cc863540a8eec6422cb36620147aa6a07e8df4865b62bf0336f71d99058aa51aa302fb2e3f26aa795233cce1adc34ea64029ba611fb03070bf8f5c3a619cf28f282efe9deed6ef22142bd61d9e15c360e4df2b90b3e25e590b9ba564e2944a4966e7e334c64c71ec10163ed9c9e45ebe08a3940066b96bb75cab2c3020cade315faa88964168ae278fe6ffece6898f92a4e4820a84fc04da65026092b58d522dda43c703d746f61f198300635f47dd5640f3d07c15de9c05c05bf87e463e11867141e6949cc905cd84de3175e64b8918fb9a60297b654e8828a4e5dc978c3208b52a14f34a234086da23ae5427fb012be53d3d5a260e45755659458c9624ad84813ef999b24c3c05a4f1ac88e0580b437f4f001f7df7c344cc226f07dd43cb0e8832b6a330c0d5b89160d968c8795b246065516f958c9faad7f64532ef0c20c72d393ca7a0a63afd936835c53836e3c4949708cca9bd452f24d2df384ad2fba0636872482b2c72ca73a8272d5dca3081bb49022b312925c717be76cd4b20ba54d6fde0ba3a34ec9f520e42634a59f83ece07341c16e490bd7cb0ee488705fce61b00ba28282f14fe49dada049e96d3ea7c5ee08bb984c8896d16a83aee3aeb7255296f21b01bc43a2dd4eb06ba5e208fc5c2b343b691b96aba210c06ce91439f09ad60ecdbb596d885999b6758b9ecdbf8f96e966fc3af177a1efd6fd9197f55050c0a93ae7f5a4a1c38e855b462930a7282f7008aeb9d694f6e4134dc359085fda9ca36c205db9fd3aebe8bbbd5bec90cdb3b005c809d8af3aa4c1024a2afaf5bddab8f94a50ae23b4b5bd00fb9edb99bcf1fb0f3deeb6cf16ee2cb310f4b679d9470be66b7b4fa11a845eb2acde4687d1e0b19128fdc2d8815c222041cf6282cc4f7e2dfeb3a3aa13890fe4c19e223788914aa52082578214a027dcd12ac9558d59bce8bb718ba3592a6df05eabe9e83256bcfe2a00c114f513ffa81d1064684b0c9f8d488f913d518c08a9634f09e6a0c8776bd68e7868808832a1300ed1db4ab2719cdc4c6e4f8e2bc55702d411c351c29d2643738ee67ed12ce5da1d099d57590eabf96ecea7ed375516973bc9234af21d3c0c197d0b45a662133912d18caafcb44a09a5a3cfff99748e07dd590c5fce43d50631be3ab47936ee1c4e43f171f2b865fab372a60d956cc4025d6c93bb8afc259439ed9cf38f7a7c95fa2d7f7e3afb63e43b904d6f2cd12090ba11dd3ab90d08eee8d49b8fee235238d8d3275a8ff44962c4d00eb1cd41d2dc54ab0a41d7d86d60c93152cfbef5c0ca3f803831d0f1c14100c64a9a260ed6fe43e2dd41788795cab5e373e1ade5f354f858ec509d2b6e59736cb4d25f37749703ce7f6664f47ba82c21f2386b55aa9b427218d1195ca79f8072e7f0dee8d09f0cf7b868d14061a2cfaeea8d67791bb916f7e8d2a87b05c112730a4b0a9c064ab8134c6cafebabf20156ca9840a38e7e53975f061c76e8335c021ef521f7554e8eadb7bc726ff20a4c4297221642e3a7c4923b854f6888a9985fe6e3f1ca48296385683c5b9372c609068569459c9d9ece3d452826ef245008c09814804fc097aa40a7e0db1dca621041bd08207ca708c3c03537af66d52f4608fbf49c0a56e5d87c734e39a451c7c975a07d5a65aaf63005548b6b82b9645db2d6e4133b46cec7067eb8bac33f2dcee9e22479ed878b866b68fc75e51439457c42aec219b0401884a6f8db72bcd0a662f4e275c520f663565a10610135f5f4924e9d54a0a03d2ffde49039c684b95741e0f7b35c173c8f915aff228137912fba39a768cd4575b788bff724102b929155b91d74001393cbe84af7d46552fb7a9c52b92d86500fd41e4d4cf7465372c8bad7d15db2043fc9b7ca2df98cbaa90d1df75b504a7b82a3705423a17d22acc5c8de3444edef7c41e47995091bbf47fa343924752e6e3b51e210f1248a5960a79c3590933410efcd04a52001a73ea87c9a461d9fb476859a4d64a28c651056b2c93ce99e7f422751d21738ad857212e2baea08158efd8f47ce8b74460d6c928136aba46bc3674d853601026ad5fdfb2d485780be8da5b0d82c98714b6cde9d72a2a747fe6eb29389c40fa75c127812ad3afd5a15622fb55022f8dd0bf5fdfb79adbf08ae2de79131d476b7216818d133fecb35f3bb4c5eab12efed4e125daf8f0ac0a48e6cec99c4225ae4d913c5730186a081236616611d094d3b7fea045756a779eeade5c2c38cf99e5555de212e3506614343492f7f178072b698d77c124eb990fa12f80143ea745a46ed73e8b667d6a9e072e3d5c99a821918b3615c7932c85874236e8590a7814a3b9d8f6fb2c018c5ed045f9c37885b5beab2e5b8cbb05c4af5965bbd6e21ffd0ee71dde62559804070273904a0699d07634d6f373743836c68a5c0d27fb5c9e87ee55f6408aac5ea7aecf5dd543218acee9ca3183041a7993b42da88179c1a657f3a43bb3ff16241b519e8aeee937e80d4b00f892ea09bdeb76f908cb0d81e3984e42e8dcc0df59bde0448e5e5bba48437c1cca8aa4cd69bfc138a9ae8ff0b3c352ed1a489dd720555deb55f05ad0bc8a62a5cde8a82746aca9da02342d18aafaa63fde1c98e7ac68a3f832adaa9ebc594f70aeafaac5157d6d9584ce11b5b130cc2dd872dbfff93d0977f91bebfab4ed7f92c13c8ea7b2bb6425a6e7a501c819b76864eb305b27e004786d71a2e9b0b85a64b2a2326c55e60a586adefaeb15aa6d9357b542755b45cb27431f53206ce52c11f46ee6f22641001d83e28b801e4bad813e7e83c6bbe1a6ab456384f19723c140319846d7353b6e4ca01ffb7e5aa88ce57bfb4af38781b2d388b03864df8bef400bff1517482428067bd2f285bf43ac8593f54788b404370c757647705a15ba1e5d940cdae74c7623905d6b5d3cb356ac38badeff3e899a34deb7dce17f9cfc173613dcc9b62b1cdb0672d64a954dd90370d22c6d65e89c77c72b462014370f9bd57b49938dd17e6c4464aea2d0e63124ab89c6ffe10468ce7b23c828bc51a3ba7cc28d1457fd50bddec21b738340b0b5e6b9c8ab8416d01f89e36b76a667160d9a0039dfd885d35ad84264c9525aa531ae66dcef1822f703e3e909141e29f26325a0830c7b4972be562788ac5e50af9dfb99749cb544e0b21c3ae1cb1cfb44254cb8b162973bc17279c94215d5f4479d86f94f8910b633d6797d8a16adeeff1b126d6707c99d073ce089ddf3c475fc2a328917169d7c614d649c541a659155f523e44858fac6a804a31bd1252950804e844a430f64e0a203890bab444fd84425209496c5fa43d5f5452064482029c6c6c018f069d30577d018ba006fb44e4a0635422efbca3586892c0e01d0b35bed3abf1d02d9e32d02c907e9e4f9dbed8e5bf60a28c955dbd51dafad029bbfb829da53a655c8c3673ded35b7901c98c56a904b8bc557acbc264f38771909f90b2a20f79d8f24e37e41fa898068686235cae85ba9fc32e243e234fc3995bfa3d27ff8520bb491c0f356193557716b353a0f65e5b46acbf4e4a14b7f341b9dcd6122f9aba0e6aea55d3db4def82787882021ed08665181b35084f519f86b4e720e159d04c9c9915281e135c3f2ac4a1a790a67f591b01779214bf9b7e6f9f2c0b6ed88c1c907eda0e9cf552c6448692ed9829c2dafa593b32e2f7f20f94c41ca6c8098ab43537adcb9637d4d2e3afbd12931e875882aabe67a1c034211b575c5725fbbe98e4ae1aaec5aa44f1a9bcdbae868366c43968525459198fe89d368482d8d6154c0314849580abc34bfed219f171d08173991342b2b9dd3ce1e298e3dd5c87f634ea72ac6ac5253062cc4418b5c03af73adf7319068415775135d19ca4dfaafcc4a1c5c81382f689458b144d2d5c857a4fe9a012ce69b6398cbb8979b4c177f6f4478bb92e09f033f032c1b817d99e0968ef9f95b8a3b600ff4850c4830c8f226cdb4ac9b8192a138a12d32453786e4be7eb4abe343063e6a6a64454aea7632ec613dc872b3858fa4b2d29b1de3b111d8c1f1121540970999c73821623ba927afb9abd090c65daf437e1760de8977cda703e043f7016a128c2b17c2fb5ae246408ab280827dbf5525565507bc02ca56089384d007cb9dc4e649c9a4f4870137dea2611fe7dc54f09e2d0e2e83b67ec873c64dfd44f7bd25bceb52d08662389cedba8f174db93c24b7a6721170eb804d6953da084a6454c61780a8c4cc9a0ec816d26c19f0cfd5edf20086e037fb3905d490114c107aa59a08a3e09642f8f8197b7a5f121a6c61a3f3d1a3aa7e1fb7dc2974485f021eb0064da66515b41b77e0b4503d6c6351629f55f7be94859f4620c6aef4d34e2730255574883f33b4de348e09fd3089be315e1e775506b75455c5acd7517256aceb4a9650d1a6990f713b44512526d3cfdb064df0b0ce8788ddb2a433a265c67a6bf5a5fac5a5ee633008cc4271d044ca40e994420cb1412dff0b2c65b479dd20679a6ea5268e8a0d33b48530ad1b822111b4f312a4322ae2e4b7b00c2b8c4f1094fa7dc55798f01141d6eed89f88089cdb288315db50f1477f64b48c6fa1819c38e03e52e5eb563ad94a729dcdb8916a4794fb78dfa9c28d182a0ea12e5a560bfd34be1c3c413f13c52106e604b814f23f18ad3826a0109fb14c1adce0345831d39700d6f4f9ef22e8ceb46855c3609b0cc5c34a5fc546a97b74c5f3bd84ebede1e798de74ad54d963625cc00fb45e7652481dceacbd7280c30786067bd7b7228a0cd0c3427087aad96ab11684e8b59865373102a628605471a476023c9e79ca1096d1ef01f9fbc1519c55e19286e4909ec13dc20318f434c047a6ed0887a1a973835ff0ac7b757ccadbf24febc63a53cf5add643da960a5ad78b12623637959940ca7185a5b314e5ca1a9e7d777cd5002f682e05d3fc21e1624774086d5451b9420ad8b3d042e38b90079d78565be5185a68c4b113da0abdf7a758c35cc636ee7dddd53e078d77b8cc54701536b979491600bab02832332def1bcd73b34a441b525ae77aae318aa2786532684dc5ee13f7fc52a0cade15b086cb861edbf21f0907b2e73f50fdd3509799bb117522d3a5cc643cff9d5b07ae50f188441bee420d8a2efc3bb013f582b22439a5d0464919944fd8816edd694d827541a5c8eaa3aa7bbadc27391b82d8f442b5487f7100a186818d67031ea3103db375899b1eba23b3c0f6d41fee2eb18cc795a8c2723a26145beb918792112cdc5f5dcb93e11f748f18cc525a3459f474c7744bd5ea5b1a251ca33f199bbc87ccef9c0a3a43e2b82dedd3102ab17f0dec9d281fe0969c5f175eb90dbeaf92e061b667cf5c3819e1e3d5a91eef7b6a4d5466fdf2091eed321ceb78bea8e395573066d8df8b650215771b9d3f2e4fcc354a4fda1bf4d7fe5901903be8bc7696fe436a72e2e8cdc1205e754af016edf187a8f2cd2a2da3b335ddb47bd83949000d9743dc04ad0621d42471455f2322331e744ce7246dcca279a5f9f30bfc72d4e7de8a02d24930240280457b0cf212f465b7ae951c7d7ba1a54bbd28aa579375d3f3161a89c3df9f1740356e578b1b364aba992121962e36f2b96d4178dc1142d1d4cc5174e9b11030f6fef82541da218bdc49b6b115f967ed929fb019f2df5f51ea9c0a59fc6beb7ea99c30d08093d31f49ea9856bdb17eb1a73fb953ce362203eb7d3cde1b8d1a55f81233dff4a54ca3f60bb856793a855571004363099abf71a092bf3ea3fbf7f5b7241379a3b1347c603b0489995f60fd279c973f6b9f9d8cace18f2b7991591bef90fdf5283c21e65ad024fabac0de9a61af0fb69f268e8d69b5b5e0ae4001907a8715eb5c7f5c2d8d95830bc02ac5bbf059791c0fd28d1d2e2f6ceae94de1767058dc86d82e7bad218af6ba59fb1dd951974c274a43de9236d7f5c60a4394104c85b024e99140ec6a5baaede28bfaa256336b4274ab905c6e8bee5e92c55e8dc917c966015c6315f07c1d8c822d5dd036180a5dd2db3f6508ed8ee32a6a0efb0a4d1b8c59f26981f70b811ed26818c7004fe0ccf44e758c8c28ef019448be469422514de3fe4603f0cbb8dcd405029c7a63ae74a886e4ed392f374f742d4cdaab4d326160d47d559b8ec21f725d1cb9827bbec15599ab7191ffd09b514b246b7b50404b68ae576ccf2fb6198ff0ea591a7f15355e43a11af4c61625ea302a805b39d7fd8fcd97ca915b53c989655b2ca666bce5d2fc384096bc3a55d4e0d9d79607e829a708e888f7960bd6ee06c2e4e11948c2d35afc04b88cd50ce4c06ebbd07bf54999018bf9b2fa092d1e9436b4c1f0947123b27e5137858ab55b1a9f8913f3667d1c588d362065cdeb656cb0dfc1b1fea4b7e2eefa2e38ef09126c9a39926a40db466bedf2df53dd0201e00c914bb4cefe797353039141de0269ab7719d9d477b184ff63bb7634274af6fc5169f78fc65d1aba9b8216107bbb67bdaa3bcda654722add7f2b32582e798f8d074c838ae7b8c34017e30c87f5764d82bd020bd72d544a4fb2170061c19ce40d10fe8d11d5892a4db3331f055a757e6b3a42ea973efdf1e1ea6436755027ee967a0499b762cba390a1923da2978706703f28e3fb01456f3d5352c18644f16ec55e38a3907a13f2f63ca41b75383a855119e5d22fd60bdf1809d7e30f4b62beb9cad5d2717d97d700fa14480cbb8d6053ed86b2b618c5b3f680a00518dfc4ad6236c9a4128c8187c71bfab5c0c7568b51b2aac54d62b9fd604dba152c7c2b27606c3f8091367de8d04b703d3c3a2800cbb8b3b1b0cc50561fe09059ab97233a827577a435192fe00e8f1917008723551ac688068fe5c75081e33c62a23786cfed5a5c10b1e9b763cf4b7f384e8a9f382882aaef4263e8d4ca32106eddab2f7c87f7f15ef114577e0f1e0e3d5aea118158415f930e6b0f3135a77016c65f3dc810d64d161a9bef1611b7308fa516d96747743f8bf9a60decb6dd4e9f7ad9df420c25084dad62257f963e49288ee0dd309c854f73cc34d4a53edf54d654c49047b23a59c6f13f65cedb3902a226b61bff68b3b6e64a6f8c5330da8e636e0b819c0e76fd426132dbb12436a4cd280afedaed90e772f3c5c46c76cdb6fe6e7b770a521270dd6eb1510e59713fedbaf874434bd78f297bdcc42cb4c2f4da9fa018003cbcdddfab79b432e77cb8972a130a8b4c689d23017dd1753f7dad7c48de8d85e3933f5c9d718897119891c38d4a3a93e7454abb7808c8e4fc4fa230ef4925d0339e92d1ada7b5cc5a482df4a054fd1603548234a7443bc9a2d7b664967c3b5b84b6d9825e27f0fe8f3626ac41985f54807237a95cb2a9af87b01a7462cf43556b902a33b335cd17153b08780528d56871402c5a3107b1f40f1d62548b38b53346b7434ac301d5218b2a5b1a02078a1dfd4d75a27499398d1584dae3a7627d2e53de5c3b6bbb8222ad23a904863d68982a4646b027e21f6a8d5574398bd6f30a6c913027faee3b880a4f5c038a0eb7d3af133f96273c64c408a4001870a93384474678001a88789795ef91a3f214823ddfe8b833f64f61344e9ef3c8923fa1d2ea35927e1030b0a70921842374fe8cfbe1379c0d23c06024954fd4b4b77c98c8ef93beb96c6b165aa1669d32a0897eb705a9031f9636fc9ed8e98610a24ea878b8349198945285005435485833e707b3a91bf6907506f119aa4da0503c5dc7baee6e855ba98c7cc33abae0e23dae57cb8654e1e90fcbaa1ca35697a25061d225ba2b626699b4802515fdf271f324a3af9dac3fceeab0339bfbbf00934912ab1c05f80cfbfae102cd39c978437c61b17d391788a0b0613b86b51d8f5079a32f8498224025e835077f57ff1f055af2846245427d4cb4fd97e6c526a9d7c417c0f6e051b2e1d3520a45b6865bf53b05dfacaddc4a39ab1ac06657ae2fa80ffd19003e2448de43cef866a44d59b0e211264338bca0bc480308fee2ff9950660a2813029a85836ebc758abecd548fc96c020eefd2ae1ef93435cd692b26b72e3ec803eefaa7b8a908bcfa74e939ba82f50a49a1c4e45ef0b6b610f37911f8d28d01f455cf17588d9db97c47780cefd4d32be7c9a4309d31fa2710d4d0bb3c847e8b43cbae682a2974c01ad8fc5563954ec75094bf3f4e55e28728bc425160f4e9621a3a41486dc4c641c08ba3bf170b715d486e355d5059277007297c7a8dda904aab666a411a92a8a88e7314819cda8089653c38ac789fa7e1dfa0bcae9a9aa3eacf03368ca0f59a47e94af0b09a564602734b3e768e48e6b05eaf7be03586a5fa03c73121085295397903994b3c0238fad942ffa17bca3a774abdddc278de187079b60e00a4c775409e3b61dbf5a59b02df8b77ed1fb2ed8041dbf88f9028e36c78b20037a5d2bf60b1d8f58638e3c743289260a5bfcae7946951cd640be6cb80612796f746cdd76977522c4126101d3f0bb0b1f94bcbc9728cab904397719205ed21ee1ac9409052ed54e3e46cf391009956f1884a89c7f0c2b4dce98a5419cb78067dd7a1822b46777dd07945d68d4d7d34698a1a3f7ca2c4998835212e4ad403fdae85a02c45e226b8318abcff5b791182b64c1c90b118d9c29d91dc147d5818b3681154d32d3b33ff8e56ac2192d4052527cf7e8566b489135c78286ae6ac87a295df5d6561a9eeb3038836b58f8a563643afa1680440925d5398883f10508741be320ac6c58d230f8eeaf63140d6c60ac900d24f5c6b5b60f6d813edb94c991f5676157320f3db6fd33e2a8ab87e92f7f7c7718fb507399a85adafe3942f8267216486910f6787ad1b455993c05fb075a0fb6f048d01a502d8b9da96b3752356a944339ceded31007ea022e0d4796471fe2661040587232758e46d6714f81fa53883bcf0ea5590a9ec9e7c4b94a6ec399aad3b81f60e8a2a07f924efc52701ac53eb8e25718c301e16a373b10cd997f7a2ecce6f270ec04dd4c27a2c5636b6b20889e4e6911108764a8e48c2739d83a4e8e66f95a9121899625efaba6cd348aba1fe5b60ec1d6bd2803cb5eac75efab6472a9bddfb6453bc98dadc6c246a1152484c31352cd7785baa371a8785cf59f64fb0e840acc2dd9de1a64d17903e5cc707fc986271dbdba632caf479829eeaa6708945d4003ced1017b4769ff7038f83f32d21b67a3ee778fa1a5d2ebd33776dd796da8466ee68d07f35ee4107b61f00bed982f94d8069451b9b042e78e5ac365fc4816c2c9923ed63c483c7d639aa16e7ad4fbcb8354f748bc3bb67a5bafe70cb48ac175ddd9f9c6d86d58e0911e9bb5f7e9d598012f3135733a0c8a9106358d429ad64603bbf6c57c5d0a3a391c591dda9168bd1feae8de23640a41f1d7d9cee48798e21d0fb4a8d7cd8d7652d991a246b6d57d338d7f965d7e4683f0ae48eccecf0a475245f9f33bad5ec4c688943553a0f94b496de195b5eea86adad1adc0afc65dda9f70e43d853a184df9eed774a322a97d8d1b82304263067b17a5d50928baa384fae2bc007929c22c05bb74e3c7435330aec68df4a40e9622462881a9fa160a6e9493aaf00fc665c2baf1eca494086ee05b59cc74e4cfd91dd0818fcea0f53dbb50b75965b402dbd1e82664a592af2089980799ac343ec0b70c36754b9f7c82d237008b46994e8be4c6a00b545bd1186e370dad3e398e61abf20f980dd4eedf53003f9d3307b30ea7105590a29d2fe55e02388339be7d0cb8a243fd572bb4197e5fc5f5b912a69f09b6a5294848bdd19a652da4fd5c638d9d7879c04bdd441cca7a25a80da135373b5febeaec2f36b2fa4a33d143679e4eac89f15e2cf2ef34550c590c40426a854a627bd9c5ffa2c85cd2e43423ae40c1764a6b07acfe6be5040cc3477250b9fa725f4382e57e0ee2babe440e36434ab19b0ec2f001cbcf821788c2a02e8b2a23b525a7a7f01cfced901640d87c3a48bac72169d92d2c178fbc4881c1d8e2a9f1f411bbb578950b6c5b34af6013cc16af496938044b983981a97ef8031371ae8f028eef7d649f4a0560e70153ff6ccbb72c807b1f39e473de24b6d27d7b6808376b7553223fdc63ed22eaaa595c26e9f3ecb30fc6c9e1586a14773bdeaf2da5c6003e783ec65dfc25bcf354afb64368e9c538d3708e5dc635e2b62ba7a9f62344331510b7652f60e04fa399fe5723935d44d6cb78be7ebe96b57e7dd384d61e2b3cbfcd739dd13ee46959a537091d60b373acef04a3889286789287b060ed76d189fee6708c5f8f1af9119ca241f6b934f0b9a78d487f72912d943ee74fdf7267f2670e6ecc8bee4c2ace3dc3d6f61e3de2e92d993450d10cd5e29ac7e91c0f47c4e6b142258e075356271a64b122348e072762ada3f11899d5b71c8c0680a6b61aa142de67025b57640e35c577d937953d1791e1d34ec1529e7ec01535b875f87417cf4194e36843f664d5c7f72aa31765900be30d760fdad5245d4696d35a6cc05ea853173e50fac202a4e2d903b3d876b34f6ba09ce6eda810b6e5e0d47a664072d09967c18f71f37917aeb9e47cd1c5d02f5da2c0618aeba171719a03ceac7f94aeac2f10363f09a5cb8a3240703d1b6afe0d3ea0d00a72bee9acff19cbac28be12012a37d55b79fba3705763b75d16aac8209bd164771411b3ec96c0e7bfaaf604074e71336e1b60d8bb53801ae258c2d9659d9780514b9319fb8eef09bae972ceed2bfe91f7ce41c861b3c186be4119306f94d9b0a183ab0e0a0c20dd5e217cdecac65113f8a7c320e177544e6eee8b3ff4eb76ca1196eec3b722bd0a16ebefe705ef777ff4e86ed751c6a7f80562f1419b9e7dd01f7f9c0f7b919407316d824964ee2c14663b3c3b0602565dae13059336dd9afcfd9042c4af74abf25b5ad9e4bd49795ef3e01371a5e84084494823b8f93191d14a1c2b9d059be8169866222ab532b233f7a0aaf1613517cada50f71057d6880e118bdca0d8f6265ba1f8582faf97b1d04d8d85e26b1b22f3a501ab930aca7129a05aa7e8f4ab2d68110d0f9684cdac3af5332c753213deaa98a7f079eefce267cb69f7c67634c74eada140b30b3ed83a0d2f8ccf65e73d3259942d1c3dd5de409608612869a198e21c51598cb5b07d674daceb0df4a58640716e2e139fcfedf43da2de3a64a4ce6e7a8f672f3590a1a2cda3c2c4edcb1a885b09343439a15c62b11b26b44f4ad05935722fb4c98cdae873c9be541c207437ffbe2b7a80227b064572552f878e39f838734fde73ba21d8466f8d62c83321d354a10c3a6dbc81ae53c57bf03dee816b7de38c4144b98983e71d9d05fec4c08c53622a70f80c9b268928b659aa6cfd95fe6fa451d021789a9630a71f7c2b1d20e73624d3e7892591d9cae0654052e5caa40aa689c66b111f6e70ef4d98382a0e3123192eedaeb23de64a2f22e68081e533cb840c42db55de4a3e5646c9e0d7b3fb842f7a640dca6fee3abcbedb40f6ab311494961ee2e823189bf6d8aa91f46c333d9f384d3cd43ffbabfadefdf7a7e9a6f7baebf73a483ce68c775af34e846ae009318e83646edb920a31ecd4ff3bb0eaa9badfe6a1d26c66b86ee69e23c67abe4eef8638a6abac625605dda1229853cfc2c31fcc562179a6078db6a82a38e22c3cab143ecf1866d9fc41d5ce8cfbf1cef0eb67d989dc40836246e5e88331b479959983f4ec91d24061c0c88cb7f03c78a1b76e4f9303a2690f0308542bef979959e06f78a4152eca5f9899424b086320ad320025b893310c4c36aa0be34532d9f025a88b5e11e2b4b986b90c4e0511aa0e2c65d06de49d85bd1d7823cc819504f80b6327913e2b8b5aaa491829ec66d9b75ba5ddf5a6bb6ababc950d1046004fb04ffca53a79d8673d695468bb6cee9eed83d101e0cabce36add74ba5730ed7f04876e862fd07a2998c14a0bfe2c9d6d25bc8bb8873707e97197eaf78390a080744790bd61d5dece8360f156da94a3a61d225f68c92e2b0da4a59817bf7f81ddcd16f3a20d649f82cbd38e18637da7306f8968aca7de2c16072626fed7cfff047607001a7bdafcdb52cda29897aea74c59402564d11e9ea0edae44872ee60a8011867cc53fa38401594a3d38a32e060d84c0329b53e1d9a8190a9358f4863544efc945a1d737cd77f5c6e598605956b7c9211e4d8f880b2d8053511601d6289cef348e1f9727598a21a57f99e830d030a2db74ca7e0d1cfc621fc81a05087dedc0b7a3f4a302b63e5799e50d3d9de36534afd1d5e209d6756923916010f94fa44f079fd8f6e6f27645bb0abecf1eec911e1204f529db990528d435293524904cc5362a533d278ca267085ddd44ffcc2a0a023425dd41764b719cbe5b5c8989b40def1417caf775738ae660db10b4982064272a70aadeb92dc7720ca6dddf8625ab312058ced1922592bacd722d17566d4d8ef5212210a86c8c5910aaa06b43de1ea53aa011450c12e84bc58a1acf17b2a014a92eee2b8505288b880fcf8ddbfe7da413467a0a29635d3a6e4a9141bffafa63cdfb21d124df06b2aa82585ee1f178722d4de0931e88aeb9b0823ef4a4ad0bc04c97d02358404c8075ccb9bb71364352ac4a9223a55e009f548037d98f8c6f0d53715938b3fc607983a7990531605ff47322a511a7b7507eecf4889acbe8f2957dd5a2a53137b4ef3e920a2769834e23931f45f70321dc7a425b6b131a229a8c4d7c1087699c1814d751c7c806eb22fa120e07a3f7a59fdbf51c00494d1d9cc947b14ef3103aacfd51a0268469c76a628182e6b170dd8ce36f52b329f89543d85cf0d0c5b87ea24384f2242bcc35317d53e0a91c15d1c921657c05e1098611d2fda349760ac815b7c61d2da030e67aacd20358f54c255add543f22e5afee28bbeb969a661934590ecc1c3d8cd66633ed6207c7d8605a2c9d72bbf8fd6cb6652f37b51120e634c0a438938dfd68ddc941519e8545fea41fbcb2e65e77158f7bbce6c561a951b4ee6bbab3cdbb36ff2ff8e1048422aad5099f9617438ede1979361032887ff2ce2c2f28aa01f692116994dc05450f572ab435778731277000f48ae60288cb01609ca1ca60dbb48e35c1a85824934c9a7b8eede5408e3714b88fead02c511c162502bc4d0c8f33da4166c16acc1884336e123675460d171c33f20955c894bf05737a68e3081b5882f7441a2625daeef79ec96b244423a4f992628be30db48815a9dae2eecdab262f1f9c54df3603a419ed5fd8dd7e0353181c3035dfda84a06270e3db5c4e2a3ee695b2bf5391bb2008094dc4bf417547e0785c17ea56c1e7abbf5cafb40f9c428f8cb35370ab5092b38bd2b33cc88dbe85f7cfaff06771e4fe664cd89bda8f8a9e4695f4fbaa5b0bf148c6373dc77cebc0d8009c05031722303e7ff6e4f49660202ec20d6d6924d8b716364cc8ff60c837ad1086f484fcf64cf71f747bd0a72ab48b7c8ff61fc403adde3253fe6b6f8a726b20c9ab2b8efe03e6a22dcfe30f004b2cf5219f79fb881931be2dd5a5236b3bb3413e02548b28ad729b6e263c444c41d42d4162cf4e3c83e1c6985e84939a8c4c9f5995613fb353ea5f49acb808fb872f2f5d2382f451541b6b0eaa46057fae52c9d7ad15b2d2034ca8f82444098cd644d68c4d5003622b41cff80eaba989a54f1d9ee1be8515cd41caa27c85bd30875ef752e2e27d934f9f74d2d4eb94637968ef5a420a63676c83c942fe03f1dbd1b2aa608faa1a1093d9fde94e3e835ae1c40e29251a85e4ed40c2f5b7a2fcf62768650af7634c8153203024dd6d63c3d085c0a8ab720b66f022d1b9674dfc98e0ea5fdd854d48270b796c935102cc32ed0a389e79cb3fe3261537e741cfcb5209c5d4725161d2f4cb199737debea6b7497d5883567c00c967fa432b1fd511822a907ab5019e2d0289ce79d25561c95064a3e73bd54470bae829825cf1278dee01931314fb3ab93e573807ed7df3f655050ad51597e4d494aa55c08775be61c6c62ac7336454bad1bc8b9dcef3f6b8a88107f8c87dd0ac3c0d5372513f5887335905743d39cd66f20abde60bc0b96623dfec7c1d6c1962fa06495d9723946b1318609cbb7c87c1e952fe8f61beb352ab1f0b4b6cb14e970f48a730b69ff7be4afd9000572c6a83bf45168cb9948bebece7098e2b02e89b0e00141ca8e9e7517c3804c3f1d2233509100b5fb01138f8e50cde1414cb5d33fdaff786acd6f64854ff0d635bacff49aee8a62db2afdd05736e4ccd26ead9b99086bb046250c0de2a53b12a29e81b8f8241c33f737b506823c7259e9eb37ce7c50783ec24d858cf5503b8b044c962af1be529c79f2e1de78d64a728d02ec4e9360d7d69d5bbdd9a13e2a865e9cb6f9bf2c09a5bf98e7345747df37c335dea394143d2fec9091d3d3d237fdabbb4d21429ac60a0b83fa9db382dda7f0d444ecd5ac1009aec380b5a7b6264b9c4ad50b67575dac4a28e96686004f2371267be1cac849ac5b900cc51370d5d6aa11aab3d73dc102d91f329a5e94a60cca5740a9e02531d35e7231558b28fc6455d11b6b3e88dd9b8a59160dd646746125cdae8f19ccb41a47d33083e93073e67ab23d4a04f5c2f76d4b02340183720f52439083195a2964f8b661b7fd05146c1c6f783896e3b5cbf64a24aca407f3791dcf76103bf47343720029dbe239d897bb2d66d766a8ab1710ce4a1ca111d11e17ab3f29168f315d41338845bbe3ed30f5c75a0406c1d3755155a9860511bb05e8b5410dbd6836f0429687d10ae29b2171d0c2b8be71c06322ddee6cad1b6b6b3593a77a724184499a59a00198b83e1ea944ae574f00753d64191bb00d69db13db487946f03d97a9aee4b3ec6e105a0c771062349ee4d32acb30cadac76d5c68b00b26e956528f2d474a188a03489aa88744fd630f0c889b512bc993046919a97480e96ba2dd6525bfd567f95c5588e14d5c2c540393d7e11c9438e07e00141700610229138e94f92980321ba75df15de13b17d10e4d5947122e217d488590ba802142d1069ba847f060bfd6de1bcf10cce23a22515b86c6ca7f037aae88cecb0e252c5d76c113b07eb5a463ca95028861a0890bc3bd228cb77efd30b68fc8b134492b42b5a16b0b292a3ba2247d457844ba775fcefb05bdd7771fb79f40bb60f48de308a953c093a5b3986c06e0f0ca3785e0060295a59529e69007c7a688d815deb50230adfc90c3ed1df4a9f65e27c05a7272ba58f5a9165cfdf07119fcc228e0f5a32eda758fc690ef6a65b7b887b584bfbf54e7fb559202c7a6fc628c82cba006ea866cf288c7d4990c4ad44b8242bbf80f3d13658f4f1f8397349b61ae4dd616dc24d0fb3fd0df0e267c2409806439d14807a0ac4ebfb84803c3cd0d92b0ba2495fa4f8489ce8057625be66fd40cc99539c98f7849193aab82767fd2b4badcdf70d57dd86b0f670d89c24a97da7eaf510b6a73a95592b287824eb7cf21563f0f8630f767e80c3b04c202ee36580fee19fa80abc78dd28017a134093722db8b5aa122173ed4d1eb0765605bda2e82347487c78e065a20c52862cab7d059dff69c5f01ee140330163df3fbc36f989f9dfb39868fa608cd0dcf17b9e3bbe44b4bb31b790bfdee40d8f62d1c6a9e8674ab6d0bf11c151d4dc4808ced08fc03094f0edf5f73123f877967921b0529148db8f49180049836fed2ff509ab28b58de46010ecd1603680f0a687626ff97a5ffc01f63081d6063f69385b5c8b40c0c68c1efd500410a4292106afc743ae5b054936ccab21c7946f899678d57c8ea324d84228c2ca0b24b7fbf3354bc8d5697571ce0c47744492a2e906aaefa9bd2ac2084e205dd58e25d5427ae63f65c905c2b7c3c6abe82e8380334204dbdb66c32722f645b8d0e054d27abcd5773280234feeb8c7fd907c568dedd247c2bed67d547dd6fc58faa6486f50f4da612bbd9cd68c4d0b24ce2df10a2eecd4183753131eb191859768ecef0c32a5f9e26c8e85b068c9a922bfa9e216304d37c2c49984d16450e0d2584440f91edaa6ae7e6e7abb661f436758f067a9f0f43ca9b82c4edb5583aef9da02a6d0f520c3655db6916cfd8a3d8de73cb6618ae56ffdc2e16de5e4b3c86881d48934b73db6b47f144e2d42659034479b1b398fa2ad90ecf6bdf22c923de9e304070793b4d32ba7f4f05535aeb3a0af4fe3c90442323b331a5416dcbea2edc590ea359fbaa8982e73e28485e86401edc51b72560afee7c4d79f87d7e6e1703d360707fc01f17f8a23bc24e98d19d9f37fe1d19ddc2754123e878ba26547402e9367359d40ef916bc289f36a5b63bdf336a63f4e23f211a3cd0afa6763ce09237066874ccc77ddcdde214e406275aec9eecc7c85ecd666d54ff08a508af33c958cb1086f0b63ad85815eab4617d34a71f486d835602504ab82ba172b559755e6a200fe09e25d55b12d49ab4db4f4f5d134688b22e755a7f75d6316f4edcd88f87dcb8a6bcc9eaddd31d9508289271d64c956743aff3f6666f80b7774d44f5d6b35f10c31f47f6a420450c0ba0f235c80f6b5078dc5ea1abce0cb0144cf60f5634e6c24cdea5f4140b581448b6c70950995fbb5d96499dec3c12dd1260f26c81e98ce7a6dcc40398b9d1efc62c46908768c6ce60b04be82c2510f5411ac9898bcc04f469e842ab79b2abfc0aa369e9d993f37457a2adaedfcd84f52a127b854b038b174e6fabd668ec33cd8540aff6c73381732d54b5bcb6ceb2ef10336390e0747247032da9db6b275f196bf65f80d0d1eb6d06713bbab48bcef4cf78011abaca99c0df1f237ddf34a5e09a75fe1563e09425e2e4291d50bfcf6b85dd25fdd9d0174f9e654440e991296c8c395ac6bdf03d54827a437cdf8e61b7995adb6f1d5cacfe2faeaa368be7d37036b4d40fd91900ad7ea668fc0e614417bb16e62111cf5be8ccfd95a17d877a6c900fae797fa3b6162824adedf38dd59cfa949e797cf8b8bc5369bd3ab017d2cbb95fd6637117c08582a0cbc17ffefb5307a512ac322d9888ba36bf4d8928241cf69e0f866146accac95aa59a7e06115f5db1c732e7198d5ee86186709000915a5c78030966bd95c6e53e079ebff20f65f7bdadae2348880900c1229433ec0c5ce1f22c7302a32cbe860549dbb89890f917ac4141fdcb2900eb0f840f1bc1d8e083e5d9dbd3b38a12338345581e53068a07be6a1bc605617b87986124952ced9c7d199b4eaccb366dd4338b70248db90936bada8a417ae357cf54bd41e70fdce12f05eb40b47bb8bb066a3e7b3bafe7aa82e1c32f14ec3876d9f5e0b54e66fc603929bafeaa0799547265e800859f28a0671ab0c8588b015dfc2a4149d09dc8ed197e74a58fbd597ce28b43d56d8a126e508db508dc28b8da17a6880368dd884c0d1276cb9fdfaa549ba4096d30b58c41ad1338387b3479b791627ffcd9c542a65ba49232d7f94ef54d18c3fc60c29d0187e228387598f15337b64bef3f3133e8bc367a01df3e65efd14c8373c245195380ac2cb2b8760b8278470c4b1bfb75fcd9e523f5a69d9d962b4695b5f659afe6d24dbb26a0b67b857083f7f0f718a0110eb879fff0c79a80e5f72c13b64e8e206a4b36259d14fa31cf01a80617e5deb4ef092503ee1a01ad90e7115ef89ba7a92c55196d0509b6c6c15918d738fc1326da169974f6b0da7b77da8ca462181b27d75157b757490457220a7c7e93d31862e1230c578f8f11538a54148ac72338db3c11c6e494345f7bbd3ba0a486f151bb72402f641e321251c08b82a2bccfbd4d8d93204752583dddc8fb36dea1a80fda6693d38b3489ac43440f55b8337d5b3d8412ea35480cab494dd2cc3a8bfd913492750a35ea78a25bae3221590a8d5a8e054e53c9e926120c63daed779ca354b86dbdd5d09ed5fcabdfce30c9a53329e8517715ffb89d3a89a331d37ce70673158cc04e5b75f43be68d78ddf9e63b8b35435bc3812844648c36b4a836601cbad9bd754cc0f875158a627e48f6f316538fb309532b7fbc1a3051b2bc7c9bad1889397415ebdf556be1c587513ad8b04aa66e5dccfb36bc57e03853f52e73bf1b4aeedafadf7756fe07ce66fcc8a14cd8af03069a0e5e6135045f0f8830b3cd3e2e5f23b91378af1b2a22c5b4340fac8db4456a1b165d76975caf3d4c263abeff92b6ee9dd9cc379e8321258ce4322bee5b7bee0ec05357568db17dbf4df684a239ad0b678c40147e73faf5ddf2440e92142682ba82b54297ff48f1a8839dc62cd524a62e932e39d0eb2cc7db4254f210a70f80640df0aabcea7beedc496baa5f87d2a3be20124f456a1262990e93d1e850e0568ed0354f4128424504d600334278146ffc052846424e6ebb233bdb1c561709b182ec7a67e371eaefc4a09c650d7785c588455d3e5c6f2f0cf70799278a685419eda16fa0adc03883ecb9d71f53d3a353038b29fb48fd6c4c804b09e8be4de9f0749e18fc80065694ec1662cf44de97f2fe4fa9fd0cc32b04279c3b1a3bbb18924c98b524a55a7c5f4053bb65713d07dbcf74182e8fa8a7cb1291209a58deb47997b5fb5f281f6028515af21904215cab456e90c004aceac3e2a1757b8a8963d9a271a80e1856533c3844253679cc8f495dda6addbc98d8d8f0b1903b797e6f8d6736902e535e5d7084de8b98a98a265d60f091a0ff8f0415c654877ded29c9eeb95b9aa26abb6c7a21076ac8db903f358e94ce38b0adbe7f61714fa8c028340bcf92b80126181f30a082d88ac0a07c42fa4435ee0dee6fc6917dc0a0ad0db573c024d1ab868d72e876b0e428624964c952ef79fef55f85355821db4fe1e1136dacd26825abeef7971ec42509da3370ea5ff31971d5590e03de35096ccad299602a55047c8ab3485d41563196c5b4d3880ab605c73eb5eb8165ff5ee5473820e93e46d42cc71f700982a32ecf64ff1a565e58ae1a4649dfab17096718e6ff5df6dc059e9c65c4538072336a6ee1ab29d9138d017da1971335e8a71a433f6d13781bea4c80279d2656c0fae2b011198cfa13b0989e228fe2a8c29061d85155d69b51814235b03427276ee228c79a9ff8a3005e3260a942392a9b62ac89181456c40e9665a906e6ea42ea99d4a632c67f6c7958b10662b01541fa53b2e865f3641515d2a685d408db977496d8a610f8977abfbdd27d941c2add24edb67d0d86a7304cdb9637b75f1a054d228c600ff5466a4df03cf5a2b53c367050e8e7179be9e76e8946b9c3917d146c43a78af0756011af07245aa3d74c84752f9b0d08024c532b077221ee8e695d66e572a66042e65d47a505dca98578c8adb02f7d1c2a94c83f459d58f5ed936a9274805dc4ec5d29788edb8b6818d3108f0b73f733a623b08c15e176e8a40cc179e8371f04a55418fc081e5a9e9d2dec90b69cfb0ede5be668284e337c7a6cbc3209698fa366c5c413e3bc0b199c31409c729abef337ee7073b9b1e529d3ae0418054371e9da6979973be3c56b36e12c85374fe238865cfcb55e5f30ba80ef00d2bfc2c79022c8fcc31cb137c6a878f9969921d604ae98899e9d519c75d95171073f12adf00a2ae17d0940407ba4cc0cee2bc82ef564a87d5b0701df35e417cb9a113ced67f0af049aa5953c3aaa3bd40a5a8d56c8280c0b12d4f0a3ffaafae3503637c889eda78e7faebe83bb2b7c353ac04ad8f36c3d4e587c5ec1e0d63c2484b0aab8b297ccddaa1987d96be1209facf100166d11a7d17203d6950cf1cb3bef2ef2d4039120464f7f828f3f7bb99bf82d170ffc320f5f5bda400fc6a7f300e446033bc5f7ebbd4217d853f379fe1b197a3e1b3e02166f4d54394fd3a014b1ef6f3eeaed1cf8a538051b192df38f161a1afda14768b792c609e0b612c2826995414413f65cd5c6f827e922e8b8d5cdf5016dc62db320a212aac3d02a4c3cbd86b6a4381d27be74b4b718502e89886aa485784f20d6eb07a878886e2ced02a9f34d42016b8114d55eb0ce2efe413d6f0336ad4294fa6683acfcdb79520688fd7a2db9fcb9f3e430a24b3ef359467b858b3ac4aae79ec836c62184c2d666d2b1dc3ccc21db6dfcf566689f87e5872e7938524312c563545c8c7c187124f3dd1d4bbcccb0cb654d32efe785d4afa96f5a6ff9879ad1f93bea579049e46edab020ab9e30a9e8e9be68f76e2bc02c51b24328eb2a6d0a3bcce9e4625b0a9bab52b203b50fceeb063d898cf3184f400447443eda016f1874631edd5311134d726608a4523e091b7b8b7eedb22d9826274cf4700aef3f177196bfc1f92e1042be2439c77b4bbc1dee8e5ca28a69448a9014a1a9fd2d5d14b3103bd7cee397fa9d4e34f097f3491a49d50a5fe66e00e92942740839994ff9a88db1c00b8e28102f61d2e0a37e228424a33e8cb64024d34a8de220cfd2c51ba0091c2a227dc84714a60f0f9e4a0fc04cc852542216c5a756e33c914e18e3a297556ac19ad2d796e633de97daa53ed0d66ebb8153f8cd2fd01b197f9c8f3bf89805c694edf192fd134eb942f37820971df1bf096eddbe609563e7637891ef1ffd8c1f557afbaadc7de1cf4545647ce41e51444591b072431c4ec6cf094c2716c365ed2498a81a44f4f10314b15927dfea8c012dc089549f11800b76680a4dd946003ade35ac309a4c420a7517cb1399d5f8cfd91ce8e8d92dcd680b66e6dde5902a4f86df016007d489413689c72c2d4088f5535aadd953295be45b2edf2282593b14f9e77cdd4af04c2d7473b1d3b02ddf76169695ba6320271a1e0d33a00f50c024622c7f6010ece88e03e0e238af667af9d72582dd973e84bc5477593c5611cde8d79285b41c7096313bdb1431520acdae2c1368a2fa5fc7e2012f1d23d355c2bbd319471b77a22844af1566f668bd54b52b4500bd8887a037a843b747bd46dc97689bb32b00fdc518add482328b30461954db7edd1b158a3a2d97caa11059a1bf397ff81b971bd24e8ad96067edffbfa3093d7e9f34639eb5551f3d6e9bc1743d8d6f98a66c9311a14a86f761171f931200ce45d62c34341ff4f677a24b563309b3441b799c2d66b755ed84c571ac1a1747a8e2d460ae239814c142b6ef7d0f1328e11b620b956b5c5996372b9305d001ff4bbf6197fbe40f62d19396234191ad09cd27dcfa0a1410ece3a7355b4e59a6ec71da467360f0a80b9a47fb212dda2a3b2823822511289a69f3a48f6b913207d55a2735a07333f283287b4177c55d1a309be5287b23b94b4f30597ae7a843797dfc04d9d32f3826138f772116631bcdc1f0f252214c0be07a269d9f92e09071221d12e2f4df8e846d6265f78dcf95a07a6a66b2e054cb1f401ad7abdf81bc410532741465850b06d00a282c81561daac2a7945894d2e9ddb80ec7e84dab9c9444ec9a48aeb0bee07eecfb87b305762aefe45e613a62b2e1b5cd2125b945bf346aedb4f1dcb01ff20a70b9d55d445464330a0365ca78ef64c280c25e0f2dfd1f90e9b3dfb8255db412b2793cf91a914d66ee574d8c5481275f2ffc0bd20907ed232e40cf572f650f3b9b20df3c1da05cc511eb1cafc01f3460520d59540608d83bee506c9d49c5dae91f91cd4bf6af4e7ba7ca1913e0e3d22f3fed6f9fba77096a4bfcd09b47f26f1ff64785634666c682e0a2113af42955a70d68095e9567d8d65a7af37ef9d705ad91428222b88276c01a82e425c044cceb2e4d950d3109d1d1f0497bfa5308782de55e93648329c06aa7c4d0216142a4371d0ca5e10e08afc4eda47d343c37b63dd056e5202e3d397c0d212e66a5f1d50406d8c0eb047a8727d7aa0a6f5c24f27e3be894a262862960318f1e3b8ba8a44433f13932945e0108d3ff43439f5743501b415c76d031acc351ca63299f8987ed37e74d7b5365d9057d7fc72a5f8baaaf0b107b854887b09cf2a1c25a684211017a66506fdcacdf4067505129a0c93cdf33143f0cc6615644217bf6c9e21138174877b948dfba3fbef1ab9e99d5a1fdd4493b98040f186aedfef02e1be02e6ee091b958ce8cb0165eaf629331622a5c9705475faced7e17483e220dfa71cf2ae6b04bcf9ba76ad7f2fd8a07d23a8dac6a99ba8bfc929b403f86c64991af57d8c68d8c820645189038691069634454286100704555d647db9828d0007fe4409c9c35e1cb0fa283519dbd3bed45025b60a8e83c487025fca91d8e3e3d828d9a182ff331ebf1bf5a7244fe1edbbe172ea0af4ffa4445a91d168896e42b9f108de91866970c31b6d4d496e00d6f321c933781981aab303bddd364c6ee14978f6dfb448cb4882843516417bbcb6abb0d800d812d2bbdea9d3863af8d9e6af982d0f4e95a1d53ea25534bf23080f6077ca0a2579a5a810dd8615d6ed065d0981a13d10e0215410049c4f949dfc343736edaad8a42d443d0b0ef5b0a342564da2959dcae5d02014c8de1b16f15c0c4db6129e6bc1c1ae74efc756d3d74aa2eadf1236ba95ac256450dcbd78111bc9e38c0aa0c989f6c0d11169ce76ad9f1603eda75de1a7994705748b07e2fe33f707576c80983a3ab82d9235e63dcee29eace753bd8d2e766cb8966be84d9350bc082cb4f71db2e50c1912acf8766193de087a5cb51ae7897a423429b350e314fb57d0fdf3b7419d72c257df3587c919b6dec98ef14278a6c0eecdaebf830875e591f4aa98d9b15c99aff07071b1a98938496a230159b9bcb091b064d44276ac168268246ec19bd67d56453181b12e453ce92666d5ec0b18008d0f925f8188354108fa508834cfec3f84fb836fd40b3b6ca1d7915beb26c88ea44fc9c7de840d8d65cb149ac6bc1655923cb48c449a36e94c256ab6baad13070991588e4e61aba968630df9cf5783a7a0991a8593f0fc7f9fa01769feebb28e8dcdcc77b10a795b0650b956a94597120825018daaab3023cf6091bf7a9cb98ac96078f008731512a3caacf61e5f764d8a57acf0ee61661527361ead048be13be85ad95733129ab05e4d521a1da81f08107e2bfe8bd92533c9d8a756ecdf5b6b9619430b0fb5e4684d0260048bba35ef5daf623938731956b3eacf37ddcd8e268e3bc5351aa6b85367d7da0c0cf37fef0cac309182b6571fdb08775d887e75489865b6380c599551204a0a21e51e7cec8299a31180f4158b573c5cb6d3a8a3bd61f668c36f7337443d231cc60778b249ed011f3c5ac38142cb3e46fc604d40d33084180a7e4b128d0b5c89e25c439179318c088359b3777d2c4443159057c6c5043471bdde99710b04c10999538670a290935cbabc7a2129441b426c046d33421a35e9168b8d4b1b1c6ced3adaecf038539611e5a92bb4657cb937e775325d2e0b5953b448e7b9cbe586af04d7c1aa4442e8813ee399c5fa3a9f58ba7fdc6865bd27df63692294d041a158343aa41f4686de6c3e92630fd906b4c3b16cceb174e2ea7e58ebd7447d3a3d11dc5cff66820d6a0c7364092aa0be5bf0f8d6923bab94fe830956799e47c1c430c9bb6b6dfc9a649ec90baa78b2b359b288af9334259a3bd8c3437ed7c884fb94a0e5eb7ac86471d57f865326cb15618681198e001ac8822833ea83b2095fea41c8af99be51ad2c97308e88facd973845286a98a592e86f5b93f2a6bbcb72ccbe03c7c21009ed392c86cb1f97b056bad56aede49fe6489ad9dff61d489f59571c88fb64a6d7c2019ae3e980265cb43a44e8da2111a8258140c31e93c5d14503913a705a1c1e81edfa348e06d9c28b4dda02d98185868145cc43d72187082c388ace7e19ee9e2b30f4f18f25c9545830235b46ed5838ed0b2b8193b8058cc0bf5abe9b3733a735e2e61ad6a11e435ea32f77530455aa65c06be6d1c74b9e9d385d4be1e41856f62df0cff507ef5f99717c8c98ee151f72a828472a17e73b66c303054cab0965aca620beb0a43996cd91427081d585376c4f04f58e5f74387aca95daaeb2130dbc08acb4d9b81a4f98eeeed61c050bbc0e59d0a18f9927bc5170e403da59663b295e98a1797e5434df7d8cc39f785b7492fb31a65b4ef8b791f26acc252111837b448fef81b9bf0e6d24b9fd718abc11dc1bbb103a5643d45d504b467364907c7186df40c585352abf72519e8c73abc055a8e44e4d0681cd89dcad907254e84ce83b718a1b643a6b564004b9eb36b7340e834a08ad0caecb1f2576c400be6034647b248d2bd3f8a7c6b037034edf8fbeff6c3bd04f3e952fa3d0bd93673bc332b1abaa31b2ac2792fb742fbfc6d477c02204423ea1dd55eb3a0e9acedbed6f182dc80747f488a4d9cccd280f6355226e6e0473f3805489e77c3ac8b832401011f97b6283996d347e97f98d8d639e1142626365a3f186eca5da5a39712ac1ff366e63f74e8f5c4e13f40915f3e1fee2add369bb880ea668564c2d1748035a13c14f42f65c88732a26859a8fcae53f0d84c593fc8d9754df6639d539cb612b90e9ebcb9b0909caf258aa70fccddcefdfb7e12bbe4d9662936922e31bb927817be35362efaafff252f493f97580725810213b3af048ed0b1089729f1705dc2c1572a9060e1314454b57bad6f3505cbbea99fd98490fb88dbaa56ff2221f6faee10835f6e4584e8152668d1715677ec9c70bac658c2dbae6a9a8f01e6ba59b85df1cc63c0c893e04faf53af156a76bf77c707478cc177b71e5f90f9cb422f1428467b6a7c812ac44e81a38c9cdf192c85cb74c727bb016f9e40385c5114e99bc48d5cc0fa09cd763a9d80b5647ba643b0d85d1e288954c35328f1647bae4a7915db438f2f8e3f6d2aa88718ffcaa62af6cad51d435dff35f2d98c61ed1ee68399e8afdbb60aec14c7baa63ef8c38b03110d8fb44b1c5e9b293cd10f5bb0c7c3973f7ca907fdbd72ff83ff35011d0d1029a63110d1702f9d7e61827adddc5b1068d4a3879c252e494d88c7c0e1a77a7df12934e405e00f4e2145990404c44e284bed917c65a083982e55463d73ee058051ed2b5260c501812236ed8137268cfddf25e5ec40b74cacb8c2684c0df7a19fdd7df1346813994b61fb52800d5cdc878571b448da9320894a8269813e96b19fd3ae5a76a4990fa817caff7b9521724243f889eaac25cc377d6df64c9e501d8d44b30f71aba685f85b1ae9857a23d133cb47196b807d4ebb8766936c28bd58d5acad1ceb31cdb59a6826f25cf866d430c3b34af96d174df7a6dfc252cbb0dcf5fc15946a3b3253380be242e3e40079cd26d11c9e730ed48043047f81bca6523027f88a364ecd66b2c083a3dc3139907225dc66263da3513e49bef5ae844c9e4ba4abd3a2ef82f0c31bbbdff516f9d879bba8a8ce59133464d5043e1b1101a552c9f29661e6cc3031b478bd4e1bf7fac6b79e6c09125ce59988a7d1c1b7c278ac13b79f275fe53c8675a7509e6bd4ab87674206cedde3e9af682da4c76bc8b33292013c4ec41e5cf0e71b5becfb528190b58832fdcdee718987cb6ab679bff3d31809e48628a7269abf99e4ec376cdba18aadb642c990f12d3a017e0d26c617db836d2d0296a36cd4fc189050713c7bd7963750bf1059b73b1614aafae80bd0c6e2552abbfb352a34f2639499d226177b22adfa30429c14dd992354800c4b451a374f55490bd6d02d03663f3f0da91fb52c671634ceafb7b7f3e7499c3699c130f75afedc1ddee42e5940f73ce5463f96b857f0073f31476dcc42929adeeacf672f9325ba53c189fe2ebc162efc1a8478fdcd805796455cedf8ed31e87b932b751b006a33246cb2beb94ebe44a9257a5983fd1a9d9f317d3dd10bda11438323283335bc746ed4bb74f4e3bb98d559d000d490ec843cfbdd7587557d462f09ed0620f52c5c6fff7c54e4d593c3341f68405791c1e9b01ca233f029263ce65ea386b180f1e7a9cc5eee69154479bd017484f03269e4cd7f60226e2801227012f713d6abea192cfa6089383c856b4ccbc3c3e3845a507a5051dd9be7c885138d7a1dee1dd6afda4d84aec3b7fbc31c6232af11234b3a0c95c4e4a4e5cad9b56b8b325d69c257a037f38d293feb77a59c1102504f5040612f6a96cd6bc5ea000a626249aa85d0b0fd854c68217e9db8b6e0b1fe833d13f5fbbd6b0788e64961dca7c6a9a362aaa58d508313cc5fb368dbb57f48d9921633a92256bf49a13e4c00369f7dc4566a66f46732945a49baa75198abc50e170373ce3a381cb3bad4b040285654572e6c8213e2d2b8b4407160d4c17695a5d5d9d653b16a12e39ba490ef49ca9c075f2e01c701f725a5198095803ef4601ec5432026c8ed9d33dc38ba021458c24323bfc2345e006b5b029b0434f28e04280ed1443058f53228aaa314cfd1918c2abe80c4aae3f5582bef8576e4ca7a78912fdf9be2ac9d690852cd504e07e59c8faf35bca2a785417339674292cb5a19659a8a98ce9641c48c35dc831bf61d24b09c78c2b67abfade50ef405c288b036d6e4cac9c1271411af959235f602dc3e4e7e882406110f4e47555b44d04e788956e33439d81f33e5c318e1c156e148c10e003d6008641c26d0593cee1282e5acf7dcc4eccee4ed4b36b48ab3ed1b274046a83a5f102f808aa17062dec3324a1e1e6d415ee1e2257f3f93400cb5a6efc1bcfc517024fef04e0a95b3da94d40aab810f24943854a10dfb89b9cf9d0d10fb68a61085800ba14581100af53c3c326fb103c3c9ff012d91db2d44c31579f29f522175a470c89e8adc62bc1a57113839711395c94188003edf748e477550387d636b3f04debf1d65c1974b39c75202235b2ce9e5c5743148224632df292b88bae45c77ccde542c9ca16864ebfae169e04da5a365b1714c72460d4d4203e9385ac86be04c99b090bd2a071e28570b2f71a360324c0357adbd7fcebc8d65c1693c74956ea85bf6e7d823c0268c84ce6a57c7b48e23205e15bd2a68f43606ef4e8d3fc2a1fce594df950c95717af73c00c845b10e3e2fd1d168bedd362759654d113902de61c25859292b152529cfa200dfdaf6161dd96585be5a6dd9ec6e5decfcbbc5f78b99b18b9481fc8db9327b1a384991109d01a804f38756aba10baa0324c6487e339fe2b0db6acdc1096c1051cb303af0c8278869ad1439702bca63293634ddac1856f0147b082fe6332ecad08829f34a72cbcf969c5a24cb1dca073bde74e0cfd183631dbdb1870c0ffaa61d82f80de0c6c4d616a3117574a82809c06a4883ca63e0314342550efc395355540dd8bb8e49c844818784274bfd86465350a8987586625e41bcff984f6edbb440f1ceb42edf8c759aa184f3ee9fd0f06fa6769f98062978f7438d36e72e55d9ab190ef09b27037e477193157ae7b8cf9e808c3bfab668ec1acaf224cf21a41ae7068a34c2bc22a518129f7794f966369dbaf0984c3b4f88d070ca32d4b988c3a18d7bef087233d6ec03cf20d768d41c5e1eca012e434aa1412d08026a5de46c24cc370f8d387030657ef46d4e6744f342070c77771be046210bda3e075d27a4626f16e6a87afb45c95c524aa536f00ae2782aa0915cf5e3bb038159038a58ba5d1824cb04a237d7a94a842d3bd075a37770c7edf0dd11b20a17fb12c05a8223278d57788109a721b8052b0d3cbed9eac8c48e4ffc83e97bff6a9b184118e2c09169e79e16881127df462fbb4f581099a6031e7d8380b9f5499640dbb1f1a445d02d3e9450f96f9c8a5b43eb4e3205527da9fbc799eb5597bd8c761808add79c2e59d0a2161e02f60bcb96d2013f78d97a519f5be94a7827ddae8f6af915671ae50716b64098a2d9b0e309d7158b269248dafcf3666c47cb08d52854803e6e20ad4173e1d7a683d63b9b487204bce22a2f18a2ab87f0a44fc846a3e4c728c2691caa226263b1fcd6a821e279269d0e38ffd30d852947008a180bd1ab7e431a8fc83585c8d8968ee6fb2d6daa3f695837eb558064ce81d3e4f23362c7a30b8def0e1cad6b527ada0df038ed347461d956e7fcd60a7c98bd36b3021513a403c8148f181c03d8fc3f04cdd2b8f8e4124121c408f9f8cc945ef9169c0c8bf072c6826823242e077f2325d6dd0f5de852dd2af1fcfe123cefd014de7237839ef4ae393752bfc43bc6ef06a2339046561c81a5026660293186a703631fe24a76b13323b1509dcd7be0ae1cf6c6922f8013756e8d71108f02ac42473f21f80d70e710e3953f5f1690e22bbb3b8594837409e3eb7519699ede13d5ca6b0aa33765c198d4c0180b2cfbd743afc36777a346276e9fd27c0fc58e10dbdadf3cd45540204d718cd52f8d87313d44fe9b6e9993e519127981878a32203437695f21a5d421d01a8a5c68de7c23042494758ef5d344ca8c3d063d4cb9a570e736ec3e824f575e5d59093de70b271359c5491b5997d2825a5af0112b89a96897d93dccb15ecfeb0488b83d0f731cda2e920e388728daea48b29a32b1adf517079f3345fb296e47365df70aa9598a735e317e060f8a9eeb5c2bdaa2372c3bf5bb2fec4059703a62a0185f0cfa94cf734cd26ed49c06f7a2149d0e7eaa628f588e5d5afc74815b24c04d3e0d306e0ee0a4954f2290d94e7163d5722252b18561f1f5c1476d6b1d75d000c0cf8de0aef25ba24d976d7a7d128d4e2f9b1b41e6d54d5d5bf9397ceef6c311ae8b3a08fad0dcb013a1424a22a65bf7de311aa487bbdd42e7d12797fb46016fd41de6effc87ea790049b86cd186e31c56c448b8554c416482c96d423bf7e449250ff8f1f35d52e07b3188ea7379df6ec42bf30129fdbe06e08eee3481d8888e43ee481bca4363aa6800f53f4877e2ead080625b3e0bd0c71f16640996830d79e5340e91ca80a94e565d94bf4c8134504c581b878cf64f3e87f979ebf9c6a8858786e028568580422ba525584c8b24ea4711b217034fbbe97b3aa73824ddb74df7baaea1fb54b7cc6659acd7c2df81ee5b88c1e7e6b93c82fb04af84b5d583e3e4cb2ebb9a32191397f13b648140cb165fd0803256269bfe1d4020e0c01cdab84f30c5d2b11d43a57c7c3ef5747814508607ec20ca4645a1a0a3e2445d96ef6dc5f7ec5c7c73a9caf42252370b34617b92974017f9924b66764b4e4ecd2fb5814afb2dd413a8a9b12183ec19fed07b5d3839a2643229051139805de8821b962e301161321b1823398e7c3ad40cf155bbbe254af605d610aa6b9f2635b5c065c443d515fd49594053ac6d54ef8875631679637d65f12cbd9542812b57722090da030df62683e30095887a65d7f4e28219f3ed27bfefdab21a31b1665fe59101154698ba9327ee232453eabc5cf943d7e14e33ef703e4b00f891b0e62579567ea8df6063588001fc8edadb34c76cc8f49fbbdaf152e5f60e11285d13358869156283211fb0dd002962200707290494e6a6d07fd22cf3888e40b44d7f8222df9eef51ad11a94117a706c241cbf573f44f6fd502fc345b68cd12ed202b8b89d1072dcd76855a410c889923400d1f68ab640c0ce55e27d8f1e5dee76480523b45abf216863e158ace23579ac4fdbf069fab8476a3afc580859d170050d2d39086df7be33bda9d9881e7a788de0dcf7bea40905a6bca36bc2d04dc81d692a5e11a7cc3a6a7777731c40651a2b5da7acbcd00680c5d476a74321c9fff4ff3085b7eb36103cb0bff1e9b38d0e398e1f9d67c22288c1257ceb910d0f5942b26aa0e31b08bff4c1aad1cf151a952ad91ac6889b2a79e076ac00df04183578208305475e7453d6abf66c03ede7bd3a9bcbe386ec8b3e56e5b3643d97164a06a4e1e04ea7c6b945071fd73c4e12275384f4fbee39271612add7343edcd19048e3dbc72cf78b90bb2927d989274122064d39691326317055439506bf101c5c763070f87fc5cd8233b1c229fdd02a64bbf2792b86d864eccddd7c21a133846ad737deacbba40342702d3ffc1e8b83dd2c273e0cd7bd2cc7691dd290118a64c3965e1615df8bda12fb1218f3b5a0c9f0f79153f4e4590436f6311a08ee66044bd8b8a534c674385771d0d513fcef14b43098489126497774c0ff59ddd5de28df632ccb1a353b40ffa1709a40a073b303ddb557532422aa850e31949a768b4e7603cde96d075c87e492d291418bed49b96cf69e3c651f33247a5e9400c698bfb665b3d5a4addecee71c0057c84847a65a4b0af2f42660d02ce4a8a8c907484038ac40e43092aa4d050bddcb00afbbd70b253bac8233b753990da2223c17f2f03354f4778c8fd6d8d8b1f43c2b7c02e809c0ad65822e5b1688c1f70f0685d0c31742c2886793bb122ab3cc047594d387930b10adfb88ce10d84703ddb75f393dfaa24bc903643b889611c7b03d9b88faf7060b5c43ff8464a42514c8237f1d8fb11bc6c44ddc952f56954350945a02a4fd537c9caad27f120bc8e3278f91bf2b68b998991b1955f374dfadf87a978aacf0fa253743b735678f36bf52b1ff1783f92589e1394568e5c7ea924048eb632facbb07aff3456fa96ce301c4904173ec82c728007a2e7b9402e3ae81b1fe51e980cd41b5b83e079181389507cff283a610c1d4b0aa06641344933bcadf5f6248acdba454bb054066aa3aac8f40a4701a20ad8594a6fdd14a6db03b961347f407058cce7c18cdb50661b842a081ccd7fdc0de7a0f4428b37fb09ff1da08e912d083ab20f3e53fbaad162aed0f8bbff263bcfd34978d2a78e08efca093ac15d8011337bd7617c001d4b5c45253fd83edf9151f59b9b280dd531b3a560b21d2aa37c77c9d25b83a343b993740bc5e568e49f22546a8599d622874e276aae802166b2583a5b5503cef5ae8f1af4c6e5e1314be8ffdaa512705cf7008f849a45cb4c473585e6f892c06f620954f76a077b3c92cc62ca368f2de1847a8b96d7eee47ec584bd8514a43f8ffab21bc07b41104daeb82995c30ccba9a0e251d2a102168e36481dce2c0d163f09bf18284e080c6488505424ba5c256ad2ca04381c9334548b60574387598b96fd7f1d76954156f4dfc445d8b88ed585ffc2104c7858e5cabde0b8da691496b7bb735b9a594322519d9095c094609453b64fad3484b9e93274b261268594af776caad6e49f5bc77ded7bfec7c4dcb4442510f0da81f5e8061ca0b9313198511605831005330a165cc172699116392e4f900f0e1872ac44801922d26808225082856386fd4336008c0194c9c0126d7c7e027063450810214966e505a413a0d71c39c73ce1e6f68ae7274ace8c24486972a5670c40a9acab0a18c33c4389921e50c1472fd1ede50ad2408a28647ec124446d1d413793e8f8e183c5480058a29a35c7f07930a78c091eb5f20450aa6b0c01baa1b971c1480494111b97eec36f9114956cc39e704bda109801e39cc914222d725505084822272fd1d6fa8ea3821b50206b9be0e6fa85a219ca0c97133986fc7c832c60a79be8e37346f5217343806500031a41003863c1fbf5e4c4a00c316585280c20a098510355b2b7e07bb5b8c10d4e4f99f373473c894084396411846e4fa9f4385eea28ee45adf460d91ebdff0866a17f50421b07202a65cdf863754b7271d308ec895e96b784375b3628a1f2576f80835608a57a2162f9074783145982861b6f862875cbf07e88b2e72fd1f4082e4784375bb225a10ee00a36403cc152610c204b55c1fe60d551d1474395dd472858a92ebbfc010e5fa34b0121266b821072eb40c219f20620515ce1417f8708145174170a143aeffa242b48af7755dafa09ba6e2eb17242e50f8c224d7b7f186aa1135d4787122cf7719d9e450e143835ca3960aab61b8d428c68a14acb0a28b5cffbeac3023d7ff2b9ac8f5412c72c8f57bb01893eb03d5b8e4fa3fb21022d707b294450a725dd2e2895c1f842d74c8f52d90812d98727d225e6878bd6aad482899894133edcaf34a9729baa45053830e1722b0105197b8c872ad5aaae821572c5e86115dbcfbbaae976b56c18214797ef73a620bee36518124cf5f7d3184956b9b9e92c8138bce9309b9d65a6badb5d65a6badb566b92087ae297c9862cb0979fedd52459e4f5f3f905133a3531679ce295158b5d65aeb4e9e45042db1f7058ba2498597164734a2c832bbe1128563b7486293b76d73bdb098820595d78d422a494d97292b6437d784992b8b231b1750a0a9c2a866861566b67072452992a935d14c79e1621135c3840b2d2e453258acc0d262ea66f922ca66191343b785118b89122e8b266f04ab2b689d9621544f9c653a62b718ad66d32ef1586cf2c4633187f7554bb2802a9cc25861015a142d69197364015434a9b0002b8ea4a02149920287a2055cf1248514240be082f4399a4c6dfdb295564aab8e272e8d1c9762b872e472392ec5c0c50a3184912403d113198a7ab85549d365d174b020430e3218b1e446278ea0e59d2519a05892a1cb7dffc273bd9c80b224d39f5132998c05195680a48b4ed470845ad0c2ad39c18223eeab091597660af874594a607155392e359122ff52932b4ca83a4930189d48622ad31c645cbb45cce8da1c979a7851c495c971a9c91832382162e2ae725c7292828e14eecc71c9c9121b392ecd30460fa782eef60ebcd0c20d2fc8eeeeeeee186eb6736d312846cfb12f6b73fe25c494835105827e3ac3c9184252b6a726b8ddb382843d665cebb13e2342dd07ab5f2b16c27a0e17693deb8b70dfbd11211ae74cfeb45e7ebc2dfce2aecc7bcf61ef693ecad8ccdf6dd24209667e437ab2bf63a97463c60d6d035ac8fb8ef5716db749eb240eb7928c612bb7f3be48eb65dec345baafc1600d4c9c47642d066daf3c49c8128757929125966164f9f3732207392ca5c615d785a5918cc999bf1f8258cc602040637ce0032d5c448a90d6771f65ec65f007baaeebbec320f88005eeb7f0c5edf4dd87f1098b16b64464cc7bcff3dec320f80057996e7fe8442d2ca50616f7bd0fbb080bcfc718dc772c25077fc95509799f0ad75f853530a5d3978bc3885b6bb88e8d3c87e0affaf9e1dce0aade5ff5dc6c99a3acfdc8300ee563c70e9dad8ba1edec6b2a064510f42efa916c21f9124a3a5296b827cfa2e8d2684a1c76b307190b5142f16f0ba7466beed3126ace6613ffc148618ca498299b4573891f492319258732cad1e752554297e240f553314b563df7f50bc17f72d063f2064b407dfa1c547f0e749e2a2712e33e2a1c420d679e218ce0b92ec0e248bf10fc371a427d7ffbd14b802a048b00bc7909880e4aa9fac54c9b62507de95f8b3c3f93c8634bc41f9985962b57644d8350d67cec78bd646454d39f1479d8978831f95934451ee9a59f6a2a2b8e43764327f269244a9e1ff3c4b52831b2d6535ee38c58ff1870f800e4a5c28d1ebee1fe7020b2d25aa794524a29a594725229250754f5616cfaad1be2c2ac94db263729e595745220b449bc575c07e2df06af136ef430941b46a60dbaa393d2de6c383d95f3757c839e5a5cfb405cdaeda3106c73f78a9baacb7be50c0264851b9970dd95ef6d822c4109b61792bace1b6a2d0e7abb3bf548bd9dce0c8c9cb41c4d1a35256530dbb918db5dab238f1affc3c01e5f7212931d6a7af48064d2069bff74cddbe994d14a14145d249ddd1435e53eb2a1c254713159bef5861c07894eb20271b3d70f241079e4ab96b81209cba317686e28f9e3a2f93c8aca55ad7c48f58ae72742a41f1a41c24074caa111a41cc2fce6def5c1fc6dde8810cd07f3a22330999f79966c72c1904fb27cf9c47d4287923469e4a054d17db9c47dbc972f84e65d2ff33580e65db2fcf120dfb12bf9fd9c8a741a6e3515717dcdfb27858585b8de0617b179d7d77c456a9ee6af1897bebf74288fa202459372b0dae028635d83a3941bcd93311eb974d93d329c51a8bfd0a964f93964dc501ee121aa57492877a92807a5fb181c675cff469247625c9d12ae7f9d5df9b11eb9f263457271686404528aecb8a37040b961877941b9f2b54c18910c4b40e71fc8c854ca96c1acb8321ca1e6f72f00cdcb775acf644c65853e31e2b8012021414145351d4509239dc8a14b1d4d41426a922f9f38b9d374b8f2639634ea94ce9671b21286caac84f2c88a54b7d42487b28b4c924c5dee510cdab23c8a729fbcf84f902c2e618162924eb24ba52d619dd454a46b4992f2a89564902ea16a209157dca71fe93aa883918ecff151e76b212ec77795acbd5729c7176b2c71e5bbcf741a89ce21c7e74daee40298b4d3f94c68a1300ecea8e9f704b7a1ba269b24b9928d25f746de799d0f811e082e4ebcc0c504a83184e6cbaf6b2e80f939e6ebf86291ceefe0225284e4f81cb888fc4d8a101daff345e4e7f8fb51fee8e022fe3a709431d6b33ec71765ecfe90b1f96ef3fae834609f63ff7e278536bce12b13c1f11dfed5f7aaff1b4f3f4aafc6b79e88fc71190e1cda0f87afc7e1dfc021986de01a3804ca3fe48f7b7197cdcfc1a187c9f36138b434f00b872e26cfbfc1e1cb06879228cfafc1e1bb300d0ec1192c83c39efc6ae110c89540599d5f2beee1121163f3ab402d912796dc4991677e9ddee4e0fc39abf48e945575be28e4440e4eaf1263f39700b1e449c5865d8989eb8e83882b8dde5949465d6ef8b1ff2a03c04028f7a7179e73832f8932461bc1eebb1122d87d47c4ebb82279f52dc580b2524e282eea6c51c6de5e4e1d392bddbe5b750772b95b712b1528bd0d883ba3cbfd2d3d9244942a35262644a13f29729f965522134d2abb90ea48460a555fc6c9eede906398fc2f7706024b0e5545d51bf24ee6606fde90e3d8e28676ca4e5931d6be5ecf7943931e1539d81d11d20d3b5957f41a81aabeaf2bea64f4ad980fcaf673fb8ec83b99fb548fe2b1d9b9937545ee13ab4a36e52086bae12dba45ee538418395415d12197dbff70ba750d1c2e4d8e5bb68c206ba0fd48ca7268a537646be470433f72cae176d4e3847b73e5aafeb574433b7593c4a54734949472d8c972ffd1a447b9df33923f5b918cf51fe5de68b93ff490727b49b99f4611eb4b0e3d2bb228748b84b8e1565494fbb7221bb7a2dc5fa162cc63ac50381c52a1324c7e14f2280e937f24e6fe94e4e1bae34e8a314a96c450b6ed3b6a2a777f03a6d086ed94dc8eecd496d4b84706e972016b2f2d6ba5a824d418e6452fd418d64d2e112b640a3586f513b95063291c44107463c08893a21cc470e1c315412c49117534a3a2d4b049c0095210484b556c01430b162b284e0006892701133932753ed0b8187f36b757c6a8c521fd4ae9eb65ed638b438c514afa93cef8515c8cd14b8eef4a3551b76337998a5a26b65de692f27cf9752698fd5eb38836ec47fa21e0d0beea6df521752d8675509f6e1d1ac9f439efbc0ebed0089df282b813417ff9e188608f18f3ffc99e43c38716f24608f3733831ac83cff53fd74975b044e83179e27f9593ab56d56e5ceb762c4f86c635f3381fbd211a35df3eab5d754e62065ef4688841d5d5e3a36bdd97f9f845dc87f5f17be623cdc7ef27add44c34c2d6f28adf556206eda57bd87cd84b3ff149e0c2cf0cc949f48f42d481e8df474070086c890ae81efea01733d8d13dfc77d830176af310503b281a384d5e5e37b89b6c70e85e831baa9110e0b9c6042e9a9e4599cd198f95813e12f552e6b6820c6179386c31de6db647013d3dcd75d4d7611c7429f7b73874a2ecbfe1b0c5647f2f76646fa8c8e30ffb0eaa280639ecbbbb63b7fc09c31d06aa4a4375e1331c9791eaf999423019ea8e0f2304514970a92d2185822c4d542c2b54289c4890274427011347d4b6265078188e7208eee8f172648261492da1d229636cc5e860fc5983129b5015a24253889b1dad1bcb0acc4686f5aacd93a492c478fc8ebaf225c7ee22c76f2f3108a78d9cdae829c6be32a5ca94a51cbf9562108d8f4528e49824472639badebf9fc87cd84744eda489688841351f9f7af6145bd64443c808139f480ceafe87178f31c6da1621518aece4b129c420c7171283bcf701a44190dc9175a2df9cebcaaf0ee7a3dfece2099c4fe626314a5d3c71c3062c49eaca97dcef44b98bdc8f63e3833dec6dfc8d1b30182ceac6d719e7eb6c03ca0b8d8f7ef3937949889c1a9fd3942a35a4a7a51a9f8dcdc33ee7b9ce1bcab1b1b1b992f375a6f175863129d1f862c6e9dc45ce247751e4a9f968cd376b3e995b0437af2f03dd4e723f95dc35af4fe665dee66f6e6464648e6ebece355f679b36ea2691a7ff8bd945a7ccb532c098a1f9641f74d110329a06d5b35a19341f8bc5adbca119160bcfc88821e27d747a9fcc718ad6931721518adc2fd55bb2773f554b019dbd272191a7df931ff50264a7ded413000d72a62a4f0146b2ca474f4b47d6513f2ff7fb8edcefad93376fa8d6ce5de4e98f3987e8f63bd9e818153b2bad95ee94e0cae4c8d40253d1f572646a61881c2a6801e97e0b32b8a0baafeb7a41c9335a700188abca91a98523605a20daa1dd9a239392339894444d2f48321633a53b3f5c1a53e8d002450e9fcab53932295122ef38a14409dc40491253922472f83d3d4877f98fcb63fd4aaab9b13c57c751a970707ab23eefeb56d64655b3727134b6bb92eb64951b9098251ec113d063c68c19d31eebb65a57a6a37165a51c9d3ca95743bd9a1ad652afa6c6b40102410bf6006d30326e38694c98bcd1572f8f4e2b99ed7dfda42c20dc6c09c620dfe13e1debc8838100727f3880ec1d1b87e6ffc69cb37538295dca28a594aa18a5a4966e73d6bad139638c314629e5cab9961de99cb3fb557fce3a65f458364c5c8cf12565534a698cf1467635b8bc26add1c53bf2dc2e8a09e46084d9703d3796db6fc3ed0cb3e1469b29433a5d730c4ae30ced628c118740e594b1975295ce6c49c97594524aa99452ca158beb28a59452cab1ba19b59aad6e46a9ec94895bcf50cab9bae8451c4ae0ca6ec76f88ce53eaea62e49194524a29a594524a6d7c8cbe2ddc7ef9b4bb439d1c256aa5b5ba1cc442d4248fe058667904efa93c82e777106f5b0e558ed5089ee387f5e72aabb6ca7539e2d75a6bac35c6aeb6fa7632b5d63a536ba5b17155cea69b33da5a9fbb795557df7412a0945219a3d71fa2e30dcdc773ce9b5965f64c719a4637a51ae6e4258fe0596a86f4e5770f05e7e33c75725e37382e53029d9bc5e95577f7a455ca2e5772b9b252dc45b3abb8928a2b7174b0b3a1a1abf1c2d0b470984564ae6cda9a6290dd2d251829c1483926090d5232f13061e84c1266d231b015b88a3b779e71b13dc33a885fe414814ead9bc579e5f8bde2b8ef5b71ddcb7d54acf8ed31c8fecafb4ef515c144ba2d534d42e4f1b7dd4d718f74d11204c82c71cfa43062510f37ad9b5e03a4d00a379216aeb3e96a3c8fe5b2400d04164d6bc6a99b76901ef03a9879cadc1cbf08526e26d6cacdd0b4726a60d5d874d14b6edc9187bacd0d2701073f887315243ae174919b9a9a542a2f9c4b94d3ac553d7d57c96d82e5745064efa6d844ec2cd97d065a4e8dce02c10a883c37861a366cdc90403d3d3df267c571dfcabfb8f118470caa407afac7693247cca0a3ba87bf183b56756b50345f254d164af4a7adc53baa33e825620f7f2f5d8c7237214613f7e1d078dde0ccc701135bc1cba8f20512313098925049929464ca28989220fd1b4d773a414b122c2fe2a27325994cb66405160a52b49294548832836486d73243c76ab574726b47abd5f25a1f8fc8ad9f2d26246372eb6f95dc6afdaf00456e3d8824b7be87052772eb8156c8ad99536e254912a3cf67cff33c4f0531d93be2c4a4c2112ecb9373652e27733f392e8527994ba18bcc7939ca036042a10935b273fb28c656837664ea23533a001aaf6090c3a8a50bcd804ad126f2c9611fc9b49768403f66c994bebd24a420d37f2165fa1f0231327db0042032fd9e12aec8f481984a1893e903214acaf48310a520d3ff000428993299e045a69f01fa44729089c08ba21e32653ae14ba64c011f975799f33af9a9b2cd5cab93df96b9dbc9af669ab9998e867375359d8d8b66a6e686151ac9b00e6e3a37f68091d92ea6a38e7bccb9e1c69f2a748c1d63eceed8dd91c6ee27dca42f99f8f4affc22209bd33d467713b8f84831469d3927954e1d989c2955b6fb72e5538a6d94f5ba125b1d816a256537b74fd2f9d58f66d5eab33182f4adfcb939f5bd5a6abf036bdf1b52596c75b0364c4509d9c4001de3733b5f1402bf22345000e3884c68e7b92e020267e14b91d0055f040400e0e2284a28f616c8b80fd991675ec6bf70479699f91fee9fcccc476f68c6a6c647cf068d4fc7fff0170a3766fcd6b5dd0be686b2c88fcc8e5a375afff26f73ffa68efc6cae09c1fdf79ca9c30d5f5eebe2e0d3d40d250ddf7cbbbe717c7b43aee75c2e3a66cc182c3947a5aea5399af33b1ff70dfe0e88fb776cb8709f06ced30f07e77f382725c5e108343ffd6cd89367ce174aa770484f479de04a263188fecb071d72c5a1acc1667b4614f9c4084bda279b3868cdb8345ff3f6551f4a1a77b3a972a85e7a43aa8ae36b8e987138def960f279fccecf0f0653bdfc0dfc602adc001ebff330893de081779ee7c1876dd8039e079f0783df12fcac8c71bf5357cfad6256e178ca89f023cf77bdcb254254ca12873ff2c421b85ec7ff70ff5cafc3e70f77bc4d11b6ed13c100746772b223e24ad294f6297d42975c7243b90ffdde41c096a964b1581deb6547955a0afcb61b9c100115b42652fe944e93d2734fda6c311996fb6553948a8a4c4952b925131130e4502a5dc9dd3fa52b2146892b5f02259a6c9c4d173d0e74bcebfd73fd8effe1396f9f03df88d0dc79f085ec3c08f3e78932362516b20373ac0121e0f3e0223fb003a2101019eb0fb283ed86a5c03e0af1f0ce87bcf20f5fcd6ff5f60b3fabb0857d21d4bff987b45f97f375dfe3e3b103fbf09837d46117eb69bca1d5bbbca1ee5d1feb7574cf7a6ef5dd2865afcd9a94a2ae92d39383c0fe90f31ba1f3dc70e0f78f7b9a83c3435e19c7db1c3d1cffc3c31c78484fc6f1f83f2917e7693c87f3859db717a5b1610cf4641d1adfde100dd8f7309d8fded01724e7619653b9761e076f3938b4301cde1756816190fcfaf971a0f3f7fd0f7f7da10e6e3d8daff307e5869396fb713c1ed293bf9f1dfe6cfe3e188eef93dfde3f27bbefc3f1850d73dc0135caf4bf8f59ca9c9e6a505153535150b5272737f223a424a5a626a524243f8a9a729917f98ce6349f4d452935393dd5a0a06a4f4e4d4a3d6b5a1bf511525212521fb551d37a166b112a2a6c595117b56c2aaa07282af5e0f1f100b953e6fe87b7de88833c3c7a7c3c3e1e108bb0e5b033067a3287c320f987e3577d18d85e7a43f8fffb42780cebc0cbfe5ef6778c819e4c7108ad973df95b2663fd4684769e87061c108544e0de0151087c1eb8481110708fdf791e1fde1e9fe411b66ce7a3d08e0f63144f186b418840bc835fd25a7eadf7aff53c1f2cc88e8771d8015168078e3226b4f3300f5a68e75b6807f74cc65a166b29b5fec6e79f94eb5fc36dd4a851a3468d1a356a7c9d6dd8f8ba461b19b9769ea3f9c2ceafb7f9866e705e62b007e855bf3dad6559a353df5ce539387cc1f04603d315b698c3385f3842cd37ef72798d95351f63cd4b0cf6b83e04ba71bd7f353fbff0e6dd1baab979aebb1b8c3d8cc76a5c51f2d1915f71b05fe67ede34d4c29ee47ddde746df852b4b9afc89427d5434739fb02ff87c890ba0df82afa75c00fdb12fba00e4e7448d50f392dcdfb289b4b966881b4db511c881bff33e80b2a4d5ecef3407dbc886eb4d6a9fdcf9bc04c42758c88edd6886f2481a6530cb270787b8b20a491483a2fc96e1953e2e254dd27c892bb32ca72021d9194c49c6fa618e3bc98ac4342d4edd4a2d3b9a328a6a1a54cf6a71aae73df6c41028dc3ae8595681d093e50f395718033d5985c320d27654023c3066cc18a7bce1213de0ce178566974b8b415dee974631a8c34cf9f7909e3ca427cfef28077b4ae9facff61026ee2929cfe17243497bb2f3f40bb0b3f30dfefc064123f7a118e66fb37fcfef89a11c543d216950547ac8b2cbeca79def0989bdd41cd4a1a5fcc7c378acbfa71c3bd40ac9fd9e42eb3092d6500ef63794910e9f8018545219e5766f6dec6926e647fc3b3c947712dd34504a95a69cd035ed0195e74feb2428e28c07a294522a71f28422cf773a060633c6488113279c7084a48288a93a43539e566a92ea4b511493932f96cc4878400b3424478c9824c961f60025494c3308a1e40149a03a147a3607bfdc558e4b4a4e782d2d51a2134ea5ec7ee3c5f599776f68e667e48cfc5519575a4e46e6391919ee7ee190b7ffc3657dcb71975e7ae9a5dc8febe387b688f8e3c231c65898091a6c25bbccf159cfd18ef51ce775ed7160bf22c929e57c6eca29e5949999796e662674654a714711417a1c788e52463e6c2e711f9783bd4d23ff79e43e51fce72c923f52d692fcc9bbc830eee332647feb0d61e9bc8aab57e6b8c8bd27399555197766d673fe0aba00c8d2822c71228e3f4e8b5f0c8ab97b80a4bfc45362a6a46c6aca5a6855c6ad1a90b28fa48f309e6864f23a80cd23da7d2865f3894c5a7bedfde849a4c8e3f208c71137743146fe75e6412ae54a2499342391ac375d262af5d1d7aa54ef17be72eb0b6d9e42ba1269db5e25b1f538f0fc23f2f8d323f789b2b5979e3295dda5cb29739f302acd22f70925929c9262e4530e27d13c92fdeb064c4d9eb237921e20b047de97b419fcc0b2a7c9ad1543a14940ac9227f6e13d34df061e73202986a43aef9da424e33a50dc6071c3e8247ffec445a450db42f2e9c4b097833b40f901f184b8501123424032d61d6b4e515f28c150c5dd9d521a630c928daf74f9caf366712b0e87b8f0063fb3e31fab14eee7f0a504be72f74b8544189d6adb10d50417471814700722bb39a7063a87ffeee3ca9f41087bfe3669ca91a949d2528e4c3248e56792c14bae3f9da4bcf1722703e2529ef89b4febcfa7923b32790cd8de4a0fa828e01404073fd672e22b7b7f54124d94a69c90bd8833b2632b59e847dbf445fbff8cecafe39fe3378cdb0f5edfc8c8b4bf2ed78d6e5b75291b241f5e3c76d92af5188a5290fd75bc658c42e215c52aa1d65aeb96335a485070220c192238b2811ba0c6a0a054c2962db63cbde045f17483122c6242d081394185e7cc781d95540ebfc722795b69ad7495040d546011a3c313a229b6b43013c5161c9a98f7755df7c6315a48b1f0c2d30c4e2c4df1658b628a3050ee65e264c3840b2624a0b92e262652324e8e4c4c96e43075d2ba59d58aeb58565e4111003916c522abba325f6c2266895c7e8b1cff00d18bfebb86a5e3a4322a6b9b71cd0a04fe903f351f7ffb2800426dc8c416a0ab4d8c4c36400ad16022644c7d2ec47577bfeebc8e2e57adcb39e9e0ae643890b96d0ab7a7cc8c4a2929a986a456cb1b627dcbe3c0b3ea672c919679e71ff88f17452872fc05b8064282282006a9b647723b9b4569b55adf2d3cbd157655dd6a48b547b2b328dbaccea2047902c2cd7433ded0f6331e079eebd7d86c1988535ea441d105397eacd66a5ddbac962405f84f276d76f65ed4b575c6acb596da95da14990fa88773b95c3536b55be5b420cad9500f4c1b1b9b9bd7ecc95ed4b5eee17f5f2f3abda8e633236a2de946fecc7cf8caf672f78b4232ab4c693fab85284ebfcc95f9eca521f18412391a2d9623b1fc6bb1d6760a0009285cbe2c51b3a20769c50f38d81e2b434c996925994c76245ec9f406a554504a63971fa464fa3f4801b104105053aabc10c409327d20415ec8f43f10022aceef07223b65afed0be48354cd0d510aa4207e90c2f85025d79ff186aa0f5b7c209190e75f6f68ced083095a35381080872ab2f42025d767d9d04981c20309b9bee70dd59a274c5290d0a8c9218a19b9d6e7bca16a8520aa5959e014254b14151130b02c8f284620c5084ac8f3b74b850b5b6badb56576108369075a9e4fef9c53096fce39e7bcb88acfa18f5cc15cebd10db91e89c9f51f9c814987292865e40a14047777a0687941060c0bbe9ed490d84cc9987df2850a355a9c6c9e4c417125d560c181862317682470410897a32892ccb658418896a3308a8e987020e30425990bd6056e8b5703926ddbb62a68b40aa3cbc311551551dc2b872232a5db539ae569cb52dbb2406d59a2b62c531edbc026b668a7bd82a6ea525d2f2b64326673f86205da258a902e53b61cca6032a5a02205d385b26426048b1294274a8438d5a008a144c8144d509a8e087932fa9e90b4525a2d78e1d21c979a5ce1056dc9c9931811b7cb71c9490f3b29383102cc618b135c1a26a42d3a90f0e1dae4b8e4c48a0b922c39215a7232c61126883c168fd825b7c9eb89c72213513c167308c68e80628cb991e3120d496a947d4efeb42f3fa39634c924c6ecab24cdeca2ea644e30fb8b946c5f1eb98c1283aa945f3b7ded25f2d8a75fd71cac12833afbdbb73548a61dd94a22b2f5215b1db27d570e97ba8e6e2869921655ef82726592fb6c336f5f1a49c9e1502a65fb5151dcaa5379181e1585fa03e2ceef1cca999cd99ff6673e6924690edadfbedc9837498b3cf6372eaea3107d5648a28f6a87f6993cb40fd744f4a150449feeedbb0939b81231a8b3fd767ab7eff5972cf1a7919a3a83bed26664db28c8b6bfc816894bb6d6beffd05092c49f0cb808da3e12d97eec22b2d521cfc0c47ef55c4f6e3f573d06d477e170ade522875deba4b559becc7be00f0b222303f3e02dcd5f07ed47a1d7a5c130efa310cd47a10bf360e6657e06c33c0ca5e6a390eb6530ac6228331f856476d4a18a4130dbaff97a64ccbeeb039231fb349f53b5efbd878138686393ccf7818cd9bfd5daaf6f0107ed4365fb8d74a53390b3ee61df43ba32abb556ce3bdac9aea37226674d29fdd6b4b3283db3cf51caf2b2773e27d79a3d25f79cf4eaacd6fca6b56fbf8f74068dd43da2676d876d1711b4bffa7a8b085a29eb1ef66d7b1163f64390eddb318c5a397497451e6b27b6ff61b92b4b439a6f71c8765af943b61c9e13e987a7dd502737533fe9eeee4e8105df9698d88beb3fbb890d377a584a13f7799913dc59420e6bf2fceb8a41dbcfe96097a6fe58002e72ecc902a4e2b1bc96c8516210e33fd83f7d45c7fc6b5051397ed857f48f3ba970c8c3e250878d1cf65383919d8bee6de4d067339f55e069979b504ca7f9e43ee184623a4d2db3cb84c2a7c824242f90b4f09991cf7cd61598451e7f3148536492ac85f19f98524c420b2d4d579cb2cba7ecd24b76da4e336fba22bbf8ac27a7450e25174dd28718f39759f4500162f9255e55b23b11f24be4e95a3fe1d87a67350e7f83fe69619914f2c861010ac0fa2ede4b4b77e3150ed491436fca8e7978412412f672c3396b2d1e94a0d2c4b484d64158ac8779e081f71b863540f5dcdb8779c0c1a4c530676158c51e744f571836b1072a98c450ba0dc31c43517d14da3ebef7592b1de3eb25f8515122bb0612c8c106fa2181787ceaea73082eea7034a600f7f11d3948ac9229b5d4e577c45de51824a3d71e02bc2c710da4d537fd0f885bbf33dd24f716e3d55bfc41883807e3aa704ffe0fe346196b9a8392ca98162eead4af8fe867420bb551c4c07f03e346198b42dcd32e6da3c8e3bf857139b74fffe949e23e52616b44b123893cfed1480a8beb53fe3886dbd88bdb180a7dbd7c4274dd1f470b37eca7a7277f9232e9754a8c31c87c70c782e848efc84d73374d36b1ed3845e48686eb665cffb069e0911b85a2500824611207110a6b8ac8589b715be68ec3042476c05e2491d2332497888346dce80de1143a02f57b9c6d447051e795dc28e3d634e36f3fed4f4e2623e2e07cee05c38d1edee186718a88aa7fc619e777b9b218b42306adf2acfba99247befba28cad6cb2dcf856c61f1b0011f20108ee038bf88bdb0f10199b1f8292a88b7e7090fac89c54c62ed9670e88423f646cc65509d1845b69fd721c9c8d03c98d320b064ce2da1c999e3ce5f056c182e40913201597e6c8f424891a25d01daed3ea3ae5d65deb477fabdfbd75779d34470259b9d19c6a5f39decf6ce395e3edd0696d9ea55c51fadaaebd76a3af1c6f874e6b524bbb4b819b52caa77f03f7e8f89c73ce493ff6f4a89aa136ede89cb3937246c5182395b56ba594527a2da5946e1b1254c61869ddac8a524a6b8c91d6788c2f393b2be5fcea54553a372e0a183060c0cc31130c183060c08099748699632818304761cee0a24ed8b5235b172d99cd365b8ba88848a9e46aca71f2f1a4211670d07f840c38e81fb59a12e03e90dd1054d77943abef9e257b8040ff97f781fe4a5468f2a7993ce6b6afb41114775292060e42791deba35252126773582a57917163ed86317078c891c9e315a6274732b54adc1085c6ebd4c2930d275ca61b54d0a5eaac40083a850d4972e4fa53e74a0d5276e4fa968a5ceb2da2883bbf062436d01ca851134b84bcd06484059329a3291784b880549bd87ccc923282b833487408716768b8e0890f31302e54d9e1b6725c72018a1d2ff7e6b8e4c21535725c9aa184292a318733c69c79811873ea2f7d6e34b640e44972fb093339790f3d8b41396250cc114714b3f944b325f46d8c71c39ecd9ad6b2af8b965c99d0d3f7f1f229a5b321b87e1a36b636b926bb66b24cbe99db3af9b532cbcb5de6b84e06a5d8a8248df745392ad19400000001004315000028100c088402814828cd835db10f14800c7292427c5c369708b324c661144286180288018400038801305354e3007682e79eee7040c7e23542471cab3e8a5010746afc592d0001442be9be613fda755f3bff06fc67ae8bc9ca997de96f1d991bfee11f78851670b5b4b95668efef23aa28d84cff32f9e73389ff847f590a00db04c296af65c491abe3239626006d70d79e1b50b2a8e531e915c542949b08c52a423b61c2fda524c05831051a9755895e1a838004331485d7366eea40ea1053646b76a6b3398ffa7bdf548259fbb75d0a2641fe4b53720ccb00a8e2a12e7265874ac9fe1c9598a0014341e72b10ad74c411e5592742c7d0d6560d6e2bbf532d6e3b93e5cf47dc076b5e091e66f6ebc986754743fd6af4aef6ee3a306529b3e65cb17656e46bdba337a7172f212c7dc14a71782b98036879eeceedf35b87e932858369f19ae72d42f10e70a33e4b73084ebd9d2541774ed8808b5d2434c37bda30b660efdfadf39df20e4b9134759d5195464f7fb9e90642fa50bcfeadd576406b94d4941d98490e3b8a18b89e601e2ed493990b7f6bffedf0b768360bc28de26d84ef4c2c1b9172118272f62bf53f842898cdd30bf1538cacebbc17da9c752b2af19a22e18b48ae093c0f38d82df097090c7ee2c06ebb421126d1c4266c9b584e3c7f902d10fe7e96eaa9665ede7e0556184ef9038e40695d5a9bee647059f5c304ffb41a0a73d6cc0dab4cf8e8360a629cfb0b172ee198e0fd13b5ec739f7986cba0f06980554f3cc2a3e4ce8d29a624ccef6d7e09c0c5ebbbe055339800b6ce564edabd1fe63ccffb6a773d2d6812470681e7aa4a32e34cbc41a0e63582ace32718f8bf1771e47685e7db024b98c5a8beaf54ac4ac370b5782cf42ce8c0c190ae653f34ad15f5188a6168b383498461a09652f82a8a1aa1f530afbd18776ff8850cc83b11315bd5bb196e62e3475875ea6f3047d5822bc946de632dd8cd6fca0e287071e47bd136ad41b10b8496a6ae3876c5d8e381bd6dbb1a94ced56d323cf21353bf045b32e525b0e326964b11344d8aeaf6cd8ef23836171e31b7f7181a9ba0ec6525215513c42d561f3f0827d887c190d0652c7d110d751f2ed6c67f011590d1e39c94531a937ed345eba0b992ce21a48d4ebb9d0de364478d859e0dbda75473f819729f61af4905bd86cabb1f27206f3be97e06d9d1a73187a168b7bd811eadd8953b27b00c5eaee05d885db156a8ef6c4a801525026cbac229c472aef2aaafce5ff7a8e79abd1b6ac827e7e458f481e0b791cdb5c7f5f950f5398db7a4ac5ee6ecd3bf9a2e4992188fc8ba142ef93b5a0a7c7e357dea81219fc92fad06e6605d5d4d80d86ad2b506e218a887b4fa9197525f82253494a9a1008b27403dd97f83a2a960c9c57308bcec5825f0250c6b865ee6cc2648aa84018432a72efcd72da302166301ea4f56e9f2fc80f0006b6507f724242c13f630a8cb1277843665c572e9161bda2a4a65e24c5e3a7ad532b5a171a3e3d87cbe23531d81d99a4173d6b28ff6c42bf6eac3fb72bb9e3f0af4d2a42c1e84a9a0d1d271a7a0a2820c7211ea675bb18b356681e60a28be3fcb0dd198b81c2c7e2e1a9237deb891f2eedf971cade6de3593c824b140b528b206f9efcba4738f2be492128ee5401d147f2401103782899c198323182f9deffd9181ebed7962c5bd5e3f9f34fbf6646fcde6b006d3cb342c8618f122078e02c77d27119ff066b4918c31fd57e2130e7400fee29e9010d144ddb296c9d0665c9e3de67ccd0f513362b26ab5abbdcfc31ce12a2a91e98b3314671fc95f9df63b3690ea1759b18b9beb2b84fac899206d6a80ff66d73863c79ea7f39021fc9c8496fc360d121079a2fedbe07955b2751aa6e1516b55bd982b283d37eb7f959c43c9ce3d7b94f494eec30ab16d60d0efbc2cffa157921afe127cfe10a146fa8484968cfa0eefe665107151aad7b6bff957f9f0ec3779c898698d4fca929b73074ea4faf5c8a6a7171bd3263cf97a169e1908adeac7b3d95cfe1802fa74270a3034694de89423dc548ff858e8f22388b915badc1b04d8457c32b64b9051960a5d4ad684b31c2d8543afa5672e85b633537b399a97485d4468f74985ad28b5b624dbe2c011bc1599cb1b98061bd21eec7b63b66924c3254f187d00232fafeee16f3ca502a79ae6c4fbb6e25592463f7ee7eb145dbaa4d7d32ebe4b4548db2520e3682c79a7ee34470ecbdfb4b6755443935f664bb4907bf10c5275e485cd70559b01953e147c477f91bd24db739898e47a03d6e9afa1cd9355437f3a3d2b083c3a44addb3f8613544a052804c2e75674fdbcf836c4d3755fcedc7f2488e7a9e99fe1cc82de48ad6ac17a0a9a2ad38b03d2c57bceb38484b1678aa278d574415bd3e6d355d12f02dca12677f77775506d0f844e3b3a0f4c3cce3ad081b09c3e394db22955bbe392310cc33bc5e76903c2c46541748969f6655e1986febd04cf474b1ea758dec9030fcecc1dc1a3e4d967545d7a00ef220e1a127b326d585dba2f30da5da00b4181abc7c1e3f67a9a30b085434fcca8d848267ba21a7b1a5b7634663975ce777d0892c1cd96672a6b1a646c7ab01d863c832c9b47fc7478a0b3f07bd39e11d8da08cbb2787c4e2e6f903d2721e5ef59a2811fa7065e19d64e69e1f9a1440147a8ee0650083dc729a4b0d3609e47f7f829fa1a9b59b9b06fb672f996d43780981c3e3e300d247841f76494956d40f9529c791dfac074537bf78efd8e017a8e05b986019ea70b521a24024e68b525b16986d6d2f8379c909608178633e390fea3617618e8ce5b833088c111f6d03156e9f1f4d3059f58598669a8eb0aa278eb07425e9348a17472bbe5c27f5a8051a853dc0ccfd5c3f685f13ccd4c7efd7c0d1bd3f30cfcd2c234fc5f4a29d24b5f0de189f6d67d5a7f0a77c48e1b9ca785d1c02c3ac557cd2538f11ac84f54fdc5c9644c2dd0dcec2dd598292c602d2549c45282c581096f4b4a00d08cdf503b70b33e37b54fbdaf4b987b72da3501da27b5656979f7f0420c11b354d47d34f86cb3aebf5aa992819b0fae6e8298e599d5534b776bb1fb69b56639ddd2f2aefee859ef4c5b631a772e7e416d168dd080816f4fd409a194df7faed7765a51b58218501608f5029f9714501e090a281889343c139186a783736bc48c699aa58307a278acbb86e5b1f66a05c6510922d111a0f480a0693a2251a2d0b98b75edf55113c98962c939d21cd9dd11df61ad460643519705930224aa3114acfee91f2d9232e9c8889f12ac2aee97fe262a7299b7c18236e7650740e0ae8889418646be6239c3650c8de14c6d503763dfffb5a45c0222af22c67151eb9627e2686df42edb06e6ed1ccd30c81ab17f10b428b7dc6eb066b5548744dbc33f10c037b9857b166eee6ed0cd9098c744cbb8398241b38253d37584776b7a5f479db366551e4b586f720b7d00ead598bb921c4548f49d9368273500ad01c914a8456dd005a4346cdb2057ce80cec123fbe5bb3d48520c69b367b8e6d864ab81193fa1555ccc08780686a0370be40cf22acc428360e24f018b180e2a27e9598631272b0bff68a6b02531fb6da3a61530c5aa804575c7573c8709557022f7456c2b33629a26c076c98a98a8452242558c13416ad78b4adb2bd2b972a4d3358abf44f088dbf9111c7ec6fc9212c729bc88767724d99ccae0891bde99eae80c2589ee2b3a033d301d63b22c5e209172ea6b02edfd11af599309227ee974f38d9b77ce70a4bd642ef160ffd76e853d9c1fc7a27858ccacb653af36aa478d9a6f9cbf904d437de6771b70b761da17701c138f5f1a1d2dd0930c9e5c7a4e0356f1bd0e429b2144dcc345511955bb471514771f22a53bb5ca1a178b9229cec2760c5cfe549c60fc54b0ddb8f484553cf035eafe0c508b0837671ee314c11f1dbef267fe402024b97b32b40b954080a3e7323f2eb8e58cb71652bab0c1b246bb912190ee56422e3831b6f3a6698d4051b311192485e565aa53f2eb292848669909823d1852be4142869a19752359346daf96e7e49f85f2e152cadd4259339af1658d6e457bf0fd7cced16c8e686434a2fc5c0f89c62d589da28a96b452660a78d87aa8711faae79d2732592b2bd0b3a560cad54c9a9b086b9046972729f17d53d04f9d32a9fbe5d9d0d908c1782bba71f3f0f9749abda0edb1edce33b191de79aeeeb9ab4f6b7c7dbbf1932d9ccca879c11ede04d96dfcc4994ac73d4d8f5e5701ed1038133feef02f4c01a2c8d3d5b4e767a9b512c33c16dd7dd359f04802fa2e9903f2486ce933a53a9b84348997508e10fa63c50dc57d0accadc6004dd37791cffe308d2ec05ce42c60dc60b4484ece62c7a24c495346cc8ddd71984877f02bf4c338d4ef0a2d4ce2746bfc5a212aea38545c1937008cd03e20b4e81887a20b2d0a6a8a96870bdef54f5e943587d33c9eeca1511962ec300aabdd9167a2c59048797045a4b002a626c624e4da50a2635de6b619b2af32e3e0351635b254d4870607f183290cecd3271a8835433d7d10d129b194928d6a5c06bd2e94e589e4ca8ae13c03d9183a63394e3cb220787b8289aad9c6236d35b496023a27e85ed60a14c75328b3ddb69c7cd0ee4c4def6f1b7289089795a029bafe62f7ce585bd3cd1814cfd090cb0c560f7d370d91184594cd06fbea69afccbf1f1c20c31e15c1783c4b3c144da257695487eb793d0041d88b8f60186bfc9b607f2a2446999673216bd2cc7060ac49b079ca05bbe83f83a41dce6fce9afc7b24af4d55481f59de189fff0535159aad329a44a05626ebdbf1d94d18b2657037dec74412c9c000fa5ade20e3e01f49376b6fda09b8b5de67fdf22bc3e040e1efca4a25ebf80f3d8e03da89ea107709c74a49082e39f7944784c2a29479a83c742be426d4c95779174ed814c5b3a66b151ae1a52ddb3355aa2a22cdbff22ae7695c30090c2ffb9b46e33a0b1bd500d69169831b46cb5b9673d57c01c481fef575d16dd22ff5b558de252620cd732e68421f18fbd2c2e9a3624a981e56fb684f0e296392b0ef94ef77a13cc5b4a2eac92d805d51f3011019024b492496b40ea0a2a8b318473fb9a6221970200b4311c39cdffe6832770f85569c58da0be34673e2388156f074aa42edd75f3e468273306993682db5767d3711a0d14ba75655a4c64b9061bb831b6e5c2d0c58872fdab87baed90ef512c184250ebafeae305c60f020fb802c6a169db66651ab9d677a2c971c9b71531809c1c1d0bb6b59a74c33f30e2b32200b2328513dba98e30a73f4d20c3c18193dc02cb46e52684d3f209ae0d801de4b70167bc98f5ddf0885aa2e28ab142cfbc01c99be142caf3b3bd8e8b5c202df8b1ed4fe24aeaefd6b0420ce74816c33135f48233dc4a011ab8dc4cc13fdf762bbedf24257875e2e2d15818a38cb6617283417a8aa6c6a6c36642298cc7f1a17b65ce4902eb64bf247cf84abe02942ec4cbeed68e0b9cdecb995a32ec72683c4029fe4b2d82e946d458721ffa229c887196ddddcce7e20f42f24fb7f012c40c24526581348d93aa66c09d96d1e908df8643270af9e9fd8fd613e256b8b7ff340eef5bdc6597eeaf034621d3137ce4684aeb817bc76a051dcebf2691a296732082ccb6120336e69948ee703f4c50062ec8392a5adb464c004ec477fb56f457a5ae661068608d04ecbb556b577da687a7e67c73627c4c47aae74210fea689cbca5da2f031b5e06d625c1430ac87df6533504dc9f0c5370b383172d82d93511b9d759c7bf935d5230c213962a52a49bcf748044e59be91433e2ee556ff6685ab8fe3b938be2d57db7285684e1e0eae17fb4a2d6ad272da5b729a7c2517ab1e0f550c977ae955c16cb20bbbbbc5a26a2798f5e302ead4183265370dfbeb229a4ecf2398fcdac89e9634f4c60978681e5712a064bb8e2b07a43ccacf7ee08b4af294d8f986bcb304ff82a3204a0a487b72a8f45bd8aba3f8a2333137420ecc71c2d1692e24dee4c63ffef09b67e1dfbcb222422bebb4e1009cb8e2d1463a353529bcdd97bcebd6da2f11c86089e3f20c4a63341ce245ce4ab3de841b081865ded615e8354b45a77bbd8704905a06d50c1c17bf0bb072fa79fa07617bdb52f5d68ae777e033d8ae8be6829de3a20183ee72485f73b921cd56b5a6a3ba036a1e1c4c89355856c4d4b69133ada1997ee7915b0e6e73677a1b48bbefb015595566054de1ea727e2d6513f74c7d52107fd901691a4019422bf1809938bfcf6ec19ab951431acb030ab3dc52a071498643d027a1d41adfdb31dec49acefd200401d66f30435fd0a757f15e7340f89aeee55f573e065bbffc9b3d275ee4ed7862f610d47edc0997caa88ef533a590fc52f082a472957c27cdc09651811966a5ae676a1250a11f912080ede317449c7c84ddfe6659d5d5933c22814764fce43e42cae02fdf3340f4d0a601843d8cae7219a9acf4314d4a5cb93c2eddba4f9bbc9bbcc7effb373a88f34a5bf444435f11eb76f3934a4f404add9282378e3dc15b06c008f766fed68d1e15bcb27a976bd9fa54ea0201d986bb5317f40c31cade6f4b4c203aa967d2871214ee5765e88c8b4b6401faba2b4b2302c0e529385d90b4430c657b15531b57f4c8e3373b01c225065c016998af985014e5c5e8fe99893b300b96ed219b6b5468e4ef9a1f0b960456e299e138695be55514f1e6ae3bc8ef5f525b9884aed0674da427341e50163e1da6e72a2a2674d8678cd01634473defc80520b38ba14dca438d0617ae9642afba9ad3834305f7fd74cacc9ebafac2f4c74d3bd68ee6e827179f52d9725e6599d2f0d79b5668c53cc76a502e1223c729f20893b2cbc85ed5c02ace565c9c6e2d7161e9c96a6eb1ecdb01c9f549f260cd4884599906444059193ea5b27495be531a64c60a375d1caf782b9c6e87deee7a2be5754434dfe11dd10ad41374608285e23ed834a44e2442f4e804e885b556e7a41a3684600e6bd80bc9a21aba2f51024dd1f6491dde1fa6f198ccd8f5ce8fc56d8af9c6fc798adcb52e96572e90a051e1bf94dd36e4bf40d851920eb87be3ed26ac19d32effd0d51947f1956cbfeb13b0fea0e74630915d1f79bb786363b3637f9f3709f894cc5513391db01cce56e827f34738c26fbb06043b3cfc08152ba04e20bc4bafcb94bcc791e7560f054820f3226c58715957015472b5aeaa6bd0fe0a0be6b328e14e95a1ec28928d1d3dea3d85b07d9f2a685333acfd0f4e4f9800a911d2b83accca03ee80bade8909cafa71bc4a738b05d56839f7681b365070707c19a06900a71851ab10e5454f3ca17c793b41cb38e1a70bd96a2c38d9d84c3172032436bf3e81030d26d35c2b1de54350d7f18f24fc4c70898a8ffebb14d378a256defdfec1fbfba3e5bc54472d344fc1ef7b392fda337fb208aa4acba81da0b9e03f9d71871cc1142e40f09f57a2afe442b077d05dd98921afa5289630a4f699afb81ac776a99dcdbb919728241c8b28701b5eddb2aef8e245b88407bea83b0ea893442c61370021a03e5048ea818f2e90f81ed46c7cd0e25827071b00f4a01223fa40171e1642ac94c184e212486ce299b2988515b187ca3ad1c9f45d85bea3fd4705443952de219720fac7e540a77ca02d466980e21dd140d2927d38979029180f10de1c8fed5d368ccc6f401978475de5e12091c62d0149f64c615150fd58f30407cc2bb3923d8da06da6a8b5f52d1529eb9929b32843ea11c5c8baeec819c8afc5848763657f84f6dfa63fbf050b3fd82485e49c30e29d917c29f5946fff9e6b80897fce88e0688ca7e2b878ca1e44fb4b4905502d0458041ce4cd42f948099266302ece1ed26d686d49881806021ce9e148021c6b21d0293424136d047df2ab35930927f1f41c73f42e9bea61765b54af114dde4b3e26234ebf42bd1108696765729a8927443bb53311537c043102fa466c854a4a4955ae5800c7d479abab134b365e59e9c72e83c8c8ab35a728248464794c4858ad14339ce8d4cc57b142dda3497775dca2c1ba3412840d623bf28f6448b4c2ea5d1f283948cb54924b2d423df8761c4f5782c3b12487582925c3a10153ea7bd91708e9196f57115ee4bb4f19708bd23d391a472b981285e486766209210e2c518ca341884bc22cc84267e004cdfe15cac0d7a1062ced52d1d44e1117ca4230a6fb57bc33300f36e9906b476c724b6c13c72ffaa5528c0b5b45764c747b46715688ca847a7153213de367f2b0c7eba016e299455b69d31e82bade1a677fbc3b702fae29a5689e2c90351cd1ce808b12257a0a81e02d7aa7e65f88953bf44ab5bdb6dff66251830ca3f25bf540dbac8dc7b78cdd7e29378071b040de96448ca954ebfe545842dc40a712887f35eb0cd32fdb6489e6cfe715c0e903e8b212b7ef048abd9d66053fe02d60f5ae16d1233a2cd5519050a92992ce98aefb72c163e35ba664a259f6c17ff66fe19891cfcf0254ce9853a8f6884c068031b553d9eb990ec723dc06ceb9419689a14aef187d74ef71675614fb9d753af8feec9d97c89abab3ef8f450f55e13ac0e480edd2f0fc0e53e256809d011cf6b854a84eed9c432a33f348725593419df15eb381a2e730121a881abf7b29e600d6419a008340565bd7c866e6e10a1ccb6a9049ee9a94d1fa35c5c19720b6e25f54c61821879078a03ceeaedc6362bcd0898557b693f587a70971581fd0518dd6a83d2bf9cf1f05f2b30a5f0ba290f83849587a3b795c2d1e350b25e273b5953d8ae5c8858743b5a09d0a2e9d5f772ec8f1226703dd47ef160622d3fd2b5787f17963393184a243ee6fe0861e8d48cd1f97505d6701512ef41da07bb277bf79bb973027fefc9c8a34ce27aa50a99e207e54bb40970cf63c88c8104068a675d515910d24b777619dac0b09b022b7f8e6caf8ef2c2d7c91f476f89de58c90d4c611143a7f772ca2955eb543ff0d7ef5bec1d40cd2b6d4ef97926ae1b98d709ae9a819389e26445727323fc7664bdb1c8f5bad2ef90f1dc82ce6a4682b7a9effaf169adbcc3db015b357fbfa8f9e773061c9d42eb22cd795192f4da985833de501e775f14cd58af70cd2a2c1e71849602cf265dc8a5c654411f73d1dce6997c1c6a02633edfb26da42c6a7006728ab1068f80141fa8d5f9630084026b2524186b34ccf9e3fea705dde4606a797e1c3435a1fbfe8764e4e5ee211e55cd368926eca0437fe0040fe3bf12861dc21bc736891b23112631099456512cba94706e56f50e175c1153d36ed93c85ce8ba194161efb5f9269bdf86ffa35e626f65655e0e1bbd9becbf1853d6bed5685f3fe1b2a08c3be820f2853b5c9e83c66f28530d135641343e3b06498fde7e68de70837ca49b801d8a91e9c8164e23f964979e99766431b86ab2fb4785dac439876afc34491ae029c7548401ee818d7bdda9e00a795c303b679c9ff49ea7d00f5587c8faa59e6744926d643ad35d84e2f8a67ade9c476dcc8c19d56ad6ed1456ae4f0284815427c49f2277f59fb1faa29c6500f1baeefe9cd0df345e1a66bacd6adfec55cf2a2d2383816b48b6efa53ba673f121e915511ebf3ce246deea71578581a904a5ebe1692a8b71ea8fd9635ac82084625148c9fe6698191dd9556b745f8214b257c41a3962df35058ee57b6dac70ad887e76b6dbb35515cdb62c320d3b8f284cf94ba2e53c8f8a6cb4ce4a49b607125112ae54105d918f8b80670e8ac050a41562c3c73436c8a928bba6694c99dd5d1bad666879203eaadd31cb33292999a40d16d26befc6fdb6bc931622ea8fa0333843a397118a10892309441a83b82f84ae0fca6987d56972dd553229fe2ae1e48a80b6370d030bb131fbdfdc1f63437bca62fd35c4790ed5ddf0f1b3079231a9926c135072c58740cefedf2ad536922e3012d7482fc2ed5ae6a401c11aebcb0dd28a0149095ca1f27a8c13722c782698351ae6f7819686799733555a5b22029891d732a365be636474ae59cd31dad8c2972e42c6ab1a04b0a43a9bdcf1e6f1edc8420f10b7c2b189e148c60f05ca77d8ab184e0ae977fc8ebca2c4ccd8d7d03e8f46a4f7797ade07877c1459732a0898f62f1dc0476fbbe4421c6e7dafd02c2b577a4753979b583072ac9739b79ee952aaa965e31bc34a7ce2441f7605457739c0ecf54e8cb11c9604679b01faa0191869a98bd942d11ab993285655dbe54e2e920ed5038c202d18cb7a9baba3dbe66e2dd025ec5685e2738e3c10001ee0f0f548a71e4b47890280b675a028de6f66a8082cdf4a539cbdcf2959c1a2dc148efd55218fce24d410d401b64e5a43a2bb4bb8876c75828931a1b86da756dc2ecae9c4c4d22396129a76274c92f0df2e88753bef5b4ab8fa9a8ced53e2352c16b9b005ee3b5dc14855520f2f59fe210e0b82351c0517c1d8d16927c681b2c7bd1d42a6962093373ae9294fb7cf176cc3eefca7eb2ada239f4609bbae5bbab837ef2156d40c830203efcd2f0e289aab0a138ff68540dc0712551149b4586f631ba07d6f85004ea84b28c1cda635af7c3b231733798faee680fb909cf1c6f9322da48d17072fe433b64c60b256950312dd51b932087bea40ff0ae20ea468cad25d79fc0ed37b3b9305f7864b111ba58cc4ff7d23fbab72170baa458590fde830231d98caf2be60abacfa9150243bb86c0db1504281c9fb9679f33eb505ed5204a9fb7e5c8b56b3dd3788d328e2a9d15b445f9ff60a133f4c6c319fc1dbf886d6c98a2097041870447cdd7738b7c81424106fa275153a68206ee7f21d92da4153cd83c944f827cb786538db0334224640a096050075a01044200eb135ea712472cf3fbf96a67d9180f6ef247f0f89939e90b159fe1f3786adfdd6aeca0e092c224b8006b17751584ee068b5f5695e2966b684aef5b11aeb8a8fd2044275161210d9acfc8998ee926e7ca16cf38eee05303f39a2bca2f8e081954032bb78bcc3ab956a5b2060648fff8b5177eabbb704f1b5555b5de8b80ab10947cf52c1909c7784b8239e60d25455f35de3fd4ad6f6614d6fad5e596c59cf48c98787491785c7725a7fae719da7e6bcf43499db4b14a3120bb794bd99f31404a139f93b8e9ffe6e401b7e200b3e4c9f6d32310473021aeb814e8916c3ada7a5e82ce39246b052eb9219e1ff4d5a00e37140b96dd9d18fde32874334ae6ce2a22db0e31318acf98f351ab5b0e4637282483576f3906ac7c90a40d2a7fac82d52e208be812eb4e05fbc939496122560a7be667e82763b7d60d6150c7f09e10c14ac9c62cf551c45ce322e62fade950371aef2f37cebcb8e1ff09d302d90e9b85ea974e892d929f383ade43a8d7738129fb5388e388ce8a429783d6602f1c1c6cdb7128cb14afaac30283d87f5745aae4a74e5a72feb93da962033d6f4f49400fbe0ecd5bb40adce3f8fe41abec029d5eedae924d0da2df33912e07e09f40d9f998872bb06deca410f84f025f99f02af712e86d3e5e800f7a80da30889e99d62f5887d0410931c807f70ae12790ff941721df1fc85f92a6917c4653c41dc00c7af993400209ecc4d0e8e3c3d743aa198220e45935903411f05e4a033024f88724ea8178fba0eda71999c2c00f2bf73c888875bf17f96c824604cc1688c602e13361145d9ddf11cd5f1edb9e71f5ee2def31510c1578593b75c86c6585b6ae3f2e89d822507a1f7af736133c8d1ff6c9f89d3a09cd2e1ad8dd53a91b9970430699a8da912a6efc3c19d82fa8091e28d703c37d8d2293a3d6baea2445212e8cb1dde0ca857e13257ea888071729b78a170b6b6a805335edc1fe09946f59fd029ef046003dcdf9b02b2272d82721cbecd40d0a8ac8ae0b4e9f4c71c63076a3faa191aafbf096b33ea760bc74d5d78f0826b7b03657aab5b67d9f2636ccfcfcea5d9fe9b312e155a8d0971a78288f78b6a0bbd1384f40366383733f59657cd3151592a4d7a6132cd704c3f025224170cb3172fd66f49efce417cac2ea4f2882d651d3824f9a0320b493df7b410a38ad2722032a9921d06c655cc0c2b5bc8a6476b27e132c237d22d5880275f6a48444be5584281c0d76afacbd2820a766209cdadbb523838535cc5f7f69be0f34e59ebc9bb6ef9327a24e79b60b0105382b5b7ba673ffe1251c2995cbef1ee3d6efe8251ca5e5deafb2c9df5904a401033dbd0f3fb4d09a24b9d5f28b29ae396b4fd7100b6eb4d50e62d1af29f018930e0f5809082b0abd17f1eb8baaa0211f2bbf6cf1e2a51528b71bcac670d6df28e3618c8419dc63d4d5bda899e4bd4c004f13e7bc6f6b88e287de654a32417a8e273a90c588404653687716d675302d3f58513fb6b293e9a9d0c6c868a99a129e3627bcf25cb531d7a79d5aab4413871c8a9ea543d5bd16dd3b811b6886772a65c3bebc39d4e59378f1d63a2f67d48c6dea1f6cfa455dd8fbc38e939e2406d4e7130095f732b307d98aa190a4a32a92510592198e817211b43bf640b8b795b262a9a6274227d840f7605b33181316faf3b49fab71ea06b846f07f4a95baa2ea6e24a28c514dfa730b88da2c698641005672ee338672213a88f17441710a9858c9c64d6c7755689596291866eaf2d7c09c76433cadc46400fc522429928a004ad3f748042adfd9513c207c0208048295808ce7992216693e00b57b8c4bd24614389fb2c86feeb60dff532bfdedb74da93f268e4dbffbe3c0db41aa8ac39399b7d3b0b60d8879bebff4edf4cbc52e84ff592521a3dfc3b01e98d42e1cb57d1fd6de43e9f77534d6b2922a8ca937a0a6bcfa4c70be0000da13c8dabd6777bcdc073e0e08b95f3a3efec6cef025145dd1fa7493930c8561e121457a653ff46c225f1a56edc767b0e61e236c3529f19beba65e2362ccd2715117aab698829e1af7ca222bc91bc101aa9b0a5012ad6c9d4a35dbb130eeadaab51978c5cd5b04f0a4494fc432b1e485fe3c4b8c0d42060d5018f79b3642e4bb017fa604a00a25016e62f72ad335a8ca08516f516201b7d116571092a6413bfd03e3b1714d83eb6f2aceff06eea44745634c4d44826fbef2f7f372da0ee6bbc34cea1033ff82d7fa2a831f0067ed02f0f1a0d79cb26b4d0521da7259f234b25b8b5532c12659de38f719861703dc9b4cd3083324e0478259e42483a61d6a44e84fc3285bfbeb65c2c8e4960dd0feb02655f7418d81ccc99288abf0486318c8fa04c0d82cdb46adc20600e841e4168baa44f5bdfe615c66395e141f76d45e31599ccd9189afb234564a1a787c5e1395ec8cdf4a3a863cd134f55e49409e6f4446d3c18058fafd1295b2e19d0666b4fa2a7268932d307ef6a9cc86e1ad21da32942b1593c2c3462f9d1ffb36b2d88683ba6d7bc918b34cd5f1d412cddcc2f8228b34e1d96933c6c39bea970472655c53f977348e1412f7d0e124b478cecbd58f4a5063ce2059e9536ea47b0e43172c2a7c76a8e7bfb3d84327cd7ca671c957cb5c8b8d14530791061faa95277e8410eb3bcbc6f38daf0d97399e6467bddaa5c55dbd309a32e6fce3ad2e8940f2360dfc8f77b194d2381e55a9a4823a2ea3238041a4238e8bba966123f548a933c8501b10bc6d8639be1053a756c20e46310cbd5bb056ac50edf1ec389f8ec1c041074590c964a2122ade63a3c7857efae06971a23a26a0b18a4cd9c2e94cb146434a928b73a7aa6f71001ae4f61d0884ab43299117bb1626ba9b503f81a302380eb1c9275de3002749e05f112d29f5d476e25b9f97b905787cb7c70ea14f39909099a739c17f7b532216e5dda5a7156e2d907722b66c54ab23a69e0506039a33a18a3abaf859e19e1609d7b3115a4a4bcb6e690e459150b416a587202d30bb5395677059bfda741626babedf072474110c7b8a843a17a216ac57a9925142b179f89e537d0cd57f3739f9ffd50a6f4c02ac5d8443fddc2aaf53bd9f0fdb018c53db11a97405ea87b44b59c85014fdf0a398caf91c670cdb0805bcdf1e741ec4d36ab77e48531bd6afffbb96e6218f79d358a84e313c7bf4805660c38f76e0aeb106fee5197976f2f9cb0e6dc90e1c35fd09f9c68e5f8e3f45d8115ec6f8fff05f772c8dbb5c0d44f4d90ce03336d579bd68d22101ef72a9805e9c7b152bfaac0ea15c8f3ac21b1420c820d9dd580163fdd743b0ebe9a26bd0d6d2197296225e7b18f3e55d8d26538c5728edc98dd85567797aef9298e00f13c8e9bb80a2d956c944b42de90731553906f8f41be77af8ad36e7cc4a58f165b262e9b30466e1f817175d3a1d9dfc36ff68a0da3121ebb820ef72888c0331d0f06b1326d76979d477ad0438ee97710cc1c86a03a21ec778c4bb7b18fa9e7c854df32ed9658c0734da9507b8e628f4f3aed61101d928b65bdcc84cd9c70ed896190f58bfb1be0d489a4b52dc003987a0b4689642758041032aa394fa7b8e04b3011a01c11d020944b2cdab16776f0de19e3fe91e0df5af3b067f760e97245383f4d217e44a815cac4131dc5fedd83e89302d9d38c2997ed03f868d997f3a0083ba568c8ec8cd91082f34175f74c9c9b37df2627262079eed831048b345613f15c2ba1b20bbe40549874805d1635716205574248f2001195a9bd87dde611de01cccf96932a3f51475930903145ed5a5c481416fce8ae0eeda25e966034254c8624db7a5376772e735476cbb0ae36264e044f4ff53f3870f21a7199cd1764918a0c628b054e915e41fdf34d9aec399197827917b2bba39c0471ee85ad4c56d1aad9f2aabf35eecf0240817f197d0ca5844acee815619c6afc4df5c393e8c306f5f26aad7528f80321577e391950e62d8679be6e43120e186df31a8091719dd077c32d82a2f7a90a2ee14eeacd131aa6dec47637b1ea59f52ec76e63a9cc1200f666325d107dcb41239f72f0ced12982d2b6cea4f16bb6f4fbd6aed01f661c877a80610ee1007f5e1cbc83c9507725a9068bd3f8136bfaef15da0f27966aa17cf9afe610771f678c5f70f79d0bb5bfb4b693b9ffd0928c0297ed92f60f06563a4fe924757622554f32d673493135cf3a9ca668e7ec46e23ab4b01735857d18a6bf06981958d7ce7829fe0c12c34c646732fa1ce96141a65e5b99ec6ac4b8c131eb053b459b91ab9b09cd1a223bd789ae6ed3e1cf17e0b2c76b90d34f1cbcd5a002d8354ef18c01cc9dec8dce67e989119841dc514f427ec2d505453fe1d4a932f46bb1f8e7d9a65cb9fecc307362a5d7eafc3e4605e7b2364673ba95043a78cce173ac38c710b2620e06c5370120c15869299bc88b48eefe98278a83d35c46168fbdea497c34c613b31d4e9cdedd4628c4639bf2526fe1121a1277b03dff90605746b735eaeaef73fe08ef8e7e333bdc8e9c00c245840db48aa3beadf5538b3ae43f098870d05125cea03bd43f6cd4c055eb8547bc74ca32d6378bd0af58a846ac0965870a49fc74a7ca9f4369cfad9c21870220d76c42fd4eab9ac029dd336c0b6afec4f3a48c58551d04c6d15b9bf18fb9c2c2890ada1f046b88fec1391e17c60ff0bb9bedc271d6fac69610f17e8ea37fe74a176c82702f4cbb1c1ed44071421a6e296a1945363ceff1ebdb3943e72452c35ccf7765f378c4103cca698204c23884cb6048f4576c7cfd9de75667441d29740018de41d9e68004915b9a715dcb142480469f44b298bcad5d7f50a110472c98efa412de53ca818e04066d57415b8ca81013cdb59a006c157ea511efbdfcdc58d86cd3b2d4b96b209a53591cc17e3cb00762d5f62255618be056110092945a09310fe890d789b2c106b8b6c8abd6b54066246732f7e5575628795bf7d4e503358f93505bf1c30f136a43740e99322ce49bf9fd6ab4181a0f1fbb2755d8d993d3827107d6d6f8cdfd7691de9d8ee7f96212cc5df2af3bf437a2663719d788c39bb36a1d9a59a7b5d7ed4428581c248863bc71c33f3f8a9064a504f41af47904373c583e04b971b4996907e236289a21265b375a329fd217223815c2182639a4c54c03f038f01f2cf302b8c1df57710c4e41e58a8dbc444ee2cdc05aa4c168ff056099f7d1a9626c762e9992b459eb28c3f7db9ef9d4b63160422801b711f0413e0bb555a08336aaccb2aeedd111bb913ca118319b0061ca2bde5d6bb509adcceeaf11d2ed69fc6874cf7fd4021d8d7c8d7da0c3db868499997379cb22c41b8a7a408e7e5c1c5450835fa9e10d3cfd2fc9740245f260d4a0d2bd85cf0292cc27e7fe4858cddebd82137957308175dc04811a349e7f85f2c1ca58dfb9e04cc843b66042e0b40443f01f505360e79d0c0d0d7493ce4b4e7c2e00192cfd717b0b39e5ac2e940012072d8772106cfa90d9bc180a1c6dbb3ee876a19952000e51dc6450c02caa5ca0a11a12014e4239947749683af4f55352056abb144395d9df4d8bf67d4526925451039bdda0d1c744da5e4575145989108407320efdfe34a1165aa3c4608c0bd1a333bc68ea071363b64f8e228a9734727b43eb87df8410c0c1b05ea3eaddbcd7f53bd179817454c7ad158667143be6f7c025410386475aa646816fe4d30e6510abe49c585a5e9fc61e6262a17ce2b153c192ed05ac637a34db89f52a7180f9e0022be561ff29bd901111b5f22a98fd0ffb698270bdc19718833fa847c615f253be815c2570c5c9f87fb061cc63cc50741a52160eb2f6154dd41a74658a480420a1ddcd214acfa5f54f2dc0f108c4753a11d7a9b8641e7c9fe3744ed3d183a6b888fda6417d1f27c53cac96ec2cbf62c6268b240234e4283f07323b1a7617f726151f2e16c668a78cfc22507b1a164f81e2b0746cdce2d0db3c63f04f82456189b9469d6768dd409c370526c6d3fbcaf1af7d8dc7675b6bd63e05444eea6d5e41628db2035349dc171e3af02be77f81a6822d85c29bd5dea00b6d9e45f2afcd18f0622fd179c0f05209da3435174bb789ccebe4a627f11a95692eda3d858310b7a036d4a0eef435c74a5c9fa344a9cb37983b97343b4d2f50a5a42bb88854055d14828fd99e672694f309aa168d63b7a1e5b8441d5f799ae4fafb4c7945d8cca24d40999fd8981889073c7dc3bbca9b060a0ca2ed5c130920b3b0c03893bb8fbd3b5b9a79d92bd31cff9a8fe53deca91d0f3f5c3f7deb1221d58a894e0ff93eeabe670a146b2f18ac119a02b2c74edce75900eb87b2573e091034eb1c8daf9c7a131de8429320e6d3e9116e789e4a53fc619cea1e670b48305bcfb27d8dc05452e1f851c3978d076bcee70dfb8620318b1fe7c9fe3ac3305d737f7f51a738a500a392e7c8e0f2fd2dd7930e5392daaae1ff131cdc3800f1bbd40978907523751d460f1df51c0e8c8b51d9a0dab61b7f580489eeeac852ff6e8ffc6f468e8f9d780a6a650e9ebc3abe5d797e021a0f7597f2c6346252b7e8861070c1159adf9955993bd1eeb7d0ac155864f4094f9ac658dc85f2f32cd9eea110fb58512ceb393c8ae90aa9e31012d08ece5927312938ad0669c0a1230408bf6bafc395ff6d965c0aa9b0687a66639093cba3c5e8251e5f1fce2502da951447c43d5d1acf9985260f7a092b7a5b3e929375e635bd6a8829a1a1ceb4768a912f6249f6ec062a0ba9c0334b4b0017de97017fd2a7c2de60ae95f3be46460010ee4bce35e1f7ef15fbc0ba6970f8dc202fc1c3937fa6771c8185e65fa062b7e1b7f9a2ba3e7cb829abe5f5c3a527f60fecd62d271dddf1b7ea1c4ff19dc0dce809f26476b9f37b55b8f74012f2352683abb408053415a89e912a48b399f0b7df5a15cfb7436c94ccbe6d7ea3c94e2464e51a7e438a5ddba6f93ad9369884be0034d000a401ecd5b43a68ae644e7761f535b081cc420ec76b50165d94ae85a8e6da6892538117e41ed23cd75272cd98b6ac35925b03a17492c23875231abfc0f16f7b90c3b58f4f92d8b361d31696d704bf459abd1cbbc3aea66baab105f7b49b8bc79e7193aa07e696442f3a327c5d097f0bfb2f6cec225cd137807a8f87cba1b9fedcc816e1a0bdd6e2948f07e2b6fb0b71e3cb8886f37e0bea940119a8208ebb4d06106338d04081291cdd753b1eecdaa2270c16b2093c71d53aeff1494867d0c4bd4606785e24b7ac400301901f4209c54a911466b494b4fb183f347178c0747ff1dc6432d6b1093dbb36e292cae9e35fdae32ca9486c3c0b15441ccc27a90c062c03766fd07d77ae2ba283ea85f829e46c0231099d836da229458d5c700d3aa092d510b2b4ceba1ec11650b985ba1709604ca8804c3d3c18a4811fc433980e7d99df65515c5790f10410b8052080ef208b145ab7ea40214168461ea56d93d45a8426c30cc2699e812ec620d71cddbf31eb3974c35025e7acde5dc0ef5ac054a6e30841c805986cc1a42d1a501c0abb8e6934e1b56a40d70d0499de386a66287de65e84962c86645ecad5379ea2882449035d512649a6f6c88a91085de595f4c3b2ebab803d7323aa00c0a7358a47d83f2bb9094955494fe6853495c4e52133840988ab8a72b948578afcb2b209c126a344d56cfe56b2ae33b5b89f96c7d6aa35b788bd06ef573fb71a06075868e4744af71a4aa0b665a4fe79576219e41f2ddb8c77c498ad2167f11aca8c9376a0a199cffa877ba059bf4f461a1373a93c450293c3300103d08642af2b8c1c1ccfbe3fe4442194786d3ce3ca22015bc59259a5ff83908dcbaf623efd2c0a908191fff58aa355d48b44b1a82dce31b36a3abf6837882daf5047d4f5d546677f894b956242799e3a525b7ec3e825f4e003055567cbcee91b265e040d82581a7c19f7952547b41f157e5752f88bf60c5fe62ba56d0de6f45d130007c4de68ffc66af75ea5e89235a5f4b90a00647e79a3acbc9a0e33691e4cb1f18d0a7810442b49bfba1eb77450bc27fca89d6c3f2e631e3c2d040cca1f5579891fe1752f493555ccfb29e675fb7d5ada7e02c6d026d049a3534b342196b075e135ddc6078dcfdf4422e62400d5830233ab6b24105ab164512913578343620f3713d31a6f014b4850811dbeaf506122feb2041250a77720f52e746a6002ff074c9ee00829ad2ddcfcb8abe4b1d6d9832f9427673e9b8bc63de25ceab83be3aae9778918a1b82d6549683187c900bbe43571c4dc3673c480a3de7c9a8fff20bb320c84f2d20ae2bd98dc9cbd220330e27a78bcb1ba279b35e39ee18806cdfe7d7f6e3af5bb03401362a78d994227fd90ae65a5d63996280d857a8999b02e215da8d623fa12f3444ac98a94831d38b07e90f2cef0ec21ef7edb0e575a855ebb0a5aa777093bcf435601b82bca2b22949166a751e5ff79b046b76d730b000dcc8d75f56e7380e810bee5775d244a05f5b8c9568504f39dedff95b53ce24e68fa1e98af8cb77e5631e6dbff8f3deb62620b04ae1561aec71c8df9ce27bb7b7d64bc0b8de3c2d8525778fcfa4252e51ee6f1f366889365494a0853aac874dcde127c9941911b8606f46a9cd6a85dc027b7bc9cda337d5bfb04fa7bc193d2da402cb1e9c3f3d053b6301360a3806692be13812076fb9bb56f519ce815cca7aad43300992772fbabc34a7c2a30dcb375080de4403dc5a109d0ecc2f8de6f19c8b263398b839708952cd354ce68dcf2c6561110235908d65ef5eb404f77f97fb948b8c82108e41d4337ca53dfbe15f31db3ad487386435507d773e59f90a5e5a1a3651cd45b02773d8f71e4f8064efa3a902e815e1a0fd98446a1491f84d8df6c8e384115fa6d1ffa3265a184d3b98ccb21e885831ecddd4ec90663367c0620ab7810a0dcb19f101baeec58e171e4713603e69ef69c946a041c7cc1ecf088ea2956b55c8a9ff8b619d52cd08da70aed2f47a20fdafcb5d4f8912fdb914b328670ad64da9b0d335190d3399de7d611b9c6256b3bb128914c3ce18b34abefb09db252f2107fcd82efc9bc30190853c512156166a03f52a45922e9892f7c017e58bb3e8a7f1f538840317ab8bd931dd20cf69c64b4ab6af0cc35c56e786ead61cc8ccc8bb3c3c6bca3a0808ac03b8822f4747141704e0a783b94aaf7b16327a9787226d4f90786a832c5f2ef2e6b64111d9015073f4c8d67687a45db95651307ee1df2974ca5ace5481e1f1ea2bd6e4e41cd4036b4097fc8ca3467e030e785833f87654bb53570c28f61d52ec5aa93e37dc9f72ad8a2a30058319f8abeee5846d454267c231c982bd9a760a09dfb7824dd7ffec872384b01efb78653f9d84baa3e492c22a741d1b90fce50e79a877a28b80eb23061ef2c3b623cfcc0cb8a13c819cfe049b0b0d376bd0ddc1b8d2df6f249735a5754b6d16b42607981549d74e0538d751a716192777bd23357bf88fc3141d404bae76ddf7fbea845d6c0ab2472301c1a6d12274f3d662d91f3cb94222f8cc10e161063d204f11cc2152ae5a6116fc294cf47811e202a8296874577f8aa65c7d838c4cd9169052fe26a6382fa9f4ce52e92a659d41b6312bd1b50d2860b1c7dee8375c43ec40900223d9e35bdae127c9b459ed75dbe4f9caba443d2926514b6440a11362a04ee0cf73e407280e6d607f3e5c0646148228296f92815124cfd761bf584c90ee09ba17ae0d0cb94f414a65808a15360559c408fd0cc8bbfce46765eaaed9a4e726de66914211222d901d6fe45ce9b8162f1f60d9a90b31dd0d49972673afb202fed1ef043630776898c49ef67adab577e509a0a1a6f28f7e3d12288332ed022898c6716206176d8c9a61024a9e442adc7adb34ec8046447b1d0af89e0853c9491e871012940af7d30558190e150fba91bafea662a298bc726de678e109046cdf7ca2beaa64534234650af2c3b3f5e39580f8c8288adc95090e0a7bcfb26a7f1d3cc0c815e96e2a1c24bb699ab000e8a08753cbb53d45367116130238a4daea5d766deab0cf1b75376b3e3790f21a524a274bd517334da91689bf73e3cdda52854175b0e0d9058bc99101266105f0a24f29c8ac91420af246a264fb2ba2e0ca20e361414424f9a4529d1b34ddb9ce7af76f6c977df90edf25fe1517815c1e021de8c90025f64a97a0722d9afad4ab8766758d2f4461bfd50c9a91f8ceb27952a466a7f01bf4aebb3ee739ec2fd7e2d0f1eab3336d22b5a8dbdbe802362b14496f6a6c747ac0ae1dd13c1d084eb33d7fc1acfb77623477a5acb3db14f36572abe60141fbd4b56ac608bd45462f44d28fbf432647e2bb105443529eeacc5fec45b665f5009d400c76dd6d24a99a7a4ff2fff533bf9e931085aa92fc5c9ed7875032bb3d523bf8851b154cd57fcedfe464e908c1e984fafeff246af3f8082094a92b8d10302f001af04abaea3892e90d9085a04ce7c686dc64c9bae933ebadf1c556abf84f6d6b9fbeed692fa12c6e906264ffce27a9be730150c76ac24735756313f79fd5693f399bf50c823d5fdd8d7230d389afa31f829183f079f5e68822f1d0e891fc03b0bc384550475718205b5f5b1ca2d4b5c15acb571dd3d99de1e346147958693b1945054ede4800f78c357974c4168ce71a78703d63ec9996fdd4e911cc6cf43a941c14e66f2fbd3c0433497b45546e9e244fe17ba133022791eac05f9ae3d27fbbac14e401ef94321f6e0129fd0b936f4f125978873d5d6931e6fb576a4cba0c7834c7a451d8baaa5eb7149cf7d86c43fd55e3a9d311ea3b297f54193d741dfa7b5d024499735d23e4ed0a810018b7437735935ab0d0162850f01b1be88f6f6124892448377a29ce8e4149cace7186409e9cf99d90090b3d007d3a83ff4b652280772fb9f3f4eb0ac5888c06fe1d7745769d312fdb9ed0186a13b03b13d2e241a1e91ff2371de143e982ca0b4d99b74296e47b9671e3b7d90bf9858be611a5f1d433e0fbb5be5000c03405ca82d8034ad2afe97b6ab6421cb6877e2a8000308f393007a7bf13403087068176e16a16ad61a4b5cd0546a601961a263f922adfda6950131b301632e0ea696c1921c32e654b658285a2c267501907930620641a2a028dac050e0d103627a2a6a154304de401721c3443c231988cecf63b6b853ab5ad4c32b4a1086b4c8b1e013ba52f26c96c8254ac201f85eb73d53a56eda2e4b2caf05ca4c90a9ba417e111b6d17c84082370b7e0a0951594cdc1e211d33c11eefd09653f4028ce32b8697b8837bd56e216e73d71669328718c2499b453ee458745c462c386b8f3f129382e3a4c54217bb2156cdc131286d9b68bcc7af32731a8f03d4bf602a4fbf9e14869f0aac5dbd281de986bcd23c2e00a91599f302ff39f6947aab6a329011f584191a58637c7a44f105d6b39b41947686418dd33a36df60e621c91e2ea9e0558073f7a20385eb359ee016a9c697a17ecb78ca760da0b1330a7de30694c6518311058a8502e3862e507779d14149c4409ae8b10be32d70ba038201102ba80e295da21db101ad32a508796f5e0597a49c03c04f33f9c108268c861275bbb0e12a9d57425832dc42b682d64e3c9af3e157aa4408cc48d4f16a59a7f4860950172077d2b4693275be446499064f113846ef55aa755b06cac23d2179e3a951b528866f2872a4b5b599367e0c9625babf1919b3891836321e74c30a7701b2cc68608ba2ffbd986139883a47e937ab0972719d0813605bde34bd62e2106baafa345c03d6a07b8c8181ec883bdea7d6e5aac78414ae6402e608477a9f3d5d2f190f817d8be1a80f78d2a304e01ec631400b92f577d585967ac41f03511ffc78bb54a33cfc21317011a46c1b076f84cc4f06b42fae1fcfaa409ad5b93e5f6be0f0a60b02ea5024162856e3c263758b91287a95b1ff7d6ef443b6df104560a3fcd454f76fa30a5bbf6aec7afed8950e5e899ceb586b5f7e4f112f5abb49705059d4f2339a709d226c4e8ecf57e300d060b4e753e7571a0a71d7262c974dbd14d16f4995241fa9b9f8abc9305b81022f8747fd0ebfd7d49c6700535909afa36bcdee8cf1f8f5e757f4fe51c4d37b2d23a58abe1027bf70c445d4fe540143f0dac1bdd65477e96679efb045119353e2d8bbb87ebef4ccba05460030dec2f105e4ec8cbdb6237badf6c66c009d4d9c048aad6cf8274b5789c809dc8bf4c5b48141010977d55ed8a5c1c6b1cef254fe8837b1d0617638e48474d70cf38724d6d5e7442e4cb0185415aa02b463002d052bd4ee3f92b7641c1a33e609262611486e3caa3a7671e275e84e803b408c408f922470b1129c58a563941e8d4eb1784a614805c5a56e547b2637062a1cda4e737ccc41f1487874e0309c8c081dabffb52347eef0de26a73abb341f976f82ea82297612051a4f8240150ea5fa0b07c6521572b4cb827e4657c57e9e8e08362e68612514b75efc86b805af9cff34cf78d74f7f808d471506be09d0488297c168917044de93c68c2776e578ca6b1108d79429a8ff8c721a520192bfd560ceca52390b16d06c8b649aca0bd9e9f3cce24d2bf1fc6353aca13f95b1a555740685bf7fd9400615e76b6f64221419a31d5f762466068051630aa8fb144f2f15024c36d239a2efba2522a7d8ab84d563805cb19ddcd91c716b476c0f1538cbd034ad0fa73f29ea898652f712d060cbc2717a50dee8a4f2fbb86a350796e8676ae1da0737a83736090944627c91775baffeeed78a33f8478fa68e3cb496e129e41da07bd6fb2c41f17c7c24f803372c542a0ad7e46a7e0d0c753d95e60e8913ce694113eec95d280ad4b55488db6b71350fc6de4d477aee70885b8a22964602ac0351fd7aaae7c3a0f414239d150aecb50c07754bdb8c7e566470a58f38ae4f6b4eab52ea4ee2b6cdf970e2ee609179338d5ff506d46a52621fd44f5cb1550d507443dd1044e7f22bfade45b97690906d19f6788ce2a4383b64a791dbf395d0b1cf9076b1cda679908ee4a7ddc45a14b725101b386b17e493b0ccfdf647a01f5f115273c2eb9eb9aff8e20c7c2708091262211eddc41434516ff09dbc28c36fc11b19c6e44181070af03b30f8bf4fe41e69b27bc186871d360d27b5775f93b7fe8721b28ac5d814875eade81f8b656c69e00ed7eb1819534d1248ab61d52f84f1e004a72caf5c8df0846beaa4e8e599823d78eb383bdaf47f70ff92ba6b4fe16b352a57b370777ddc87ae43f2b9f7b3a8f5c39a96f3ef7bc82ba51620f89561aeeb936e806e0f3b426a4ef0626813dcc52aaafa76fc47a5c2b943ae8594d04366b1672b3486073d7e298e802078e9464a56fe77548afa6d78f996245e623568888b98e57b1a016f3f15d1cb17a2bef10cc2089fbe5a2203f6c505886104be9b8c6c5e7b3c3b18404d5ee37d254851d495a77ab348f0ff4755e0a38081f1fb738cb5864735903ab0523cfe065236f1e6a206dd86effeb3c58565744e24d26f813aad283c6dca20283303724143ef81dbd25b625c47fb7cb478cbdbf53d6391e4a6d6df4cea26900b91062025a850b70b0feb918ff7d43dcd06e9ac72b0e7bcb43f5db7e8be0200c2df9156ef91f7aae0f97fb8463080cadce9d4507be5cad2ab54adc68bc22e64fb3e3ae2ba58f99e8639fad36371b889e7f899d214da0418dbc3c4470b87552d8508a14b7f7201090f522b13a64b765e2c42ba472b5e0395681c8fa2b272207738c4439377e2832a87bb14b6fbe7d90342e9dc69a3d8051c6fdd602dd5d1f197f862a4023426643e8f0b3361c5ec2fb76cf0e47838fed41ff25114f917fe9d96bcbee1dcb3ec976a9e2e55e8ab01abb7afb39eba50a9506845e5ae168b13b2f55f0d9347482ed87540484d3856f17b81f7bf0f1edbc3eef5b7723b06311d84617dd769000aff6c2305767740a4a44260d4408d5ee0fe6d867ac9080b378cf41c80f1cd3aaf18fe8fcd5b15f203da2df112c103d3c4083f9f184b6ad1f22425b1f188cdccc215f8e0311a8fa202ecef048fa9f97471db630271fa81ced5d8f4788d350c0f1d85832c9e7611a63ba30e31db103e2140cc352ee720e4d6201c01a96173a37e3478a59d6a046d5afa24b3473f368af8bf0dac0ed40cc1f7ce3c1647ae998804bb353ac7f65881feb846f681650c856ae1a2c6cbe71190bbe14c0a948ae24765407b168ed6f25d85c22b7f10051d8aead42d4d915b70599c57662a8d5fba727034a91af6d705d432a5c688a0389ff69164787251c00f9217ef9fa4cf00c2536ceb1c039db86ca2ba39f1b63921b941e1d42c7e98f0e290db381b42d7ada32fb6f4b07127ddcc992e2f178a610d5acc487934e0578d07d1b0a5d9bffb75972851df09b982e8340f18705f0af40143c3db451d0821600952638b05900c965a2ad665938d625123f9ac3673cdedc791d7704c3f318a08aed37e99f7eb27bafc2bc49f93446b28ebf749c27dd644f8fe245a0d21ad06b16b3f185ccabd017d1bfee04c4ca16d92a3c2f8fefe16819161cbdbbbde145c0dfd72491f31d25c6b9fc661a5904589eb84a1c48aff52a360ddb3ce0dcc9cf64740d1ea822a08b2145aae2a0119063906e4ecc3706571d595ebb63ea13034012f21fddadc68769823642b863f9d33bc241523b221ad37dd29893b8c5161422e46ffdbf0e78800eadb9da845c5d5321bf1534213fd2430dee2aaa31910b88427e2c9a42eba7ebc52dab082a09142ae109f9f5bc392a22e4574a880323c0132228988b0dcd98faf8eb8698bb6160aaf3c5322c010bf6e1688bca65d5f791f5236bc930cf7abe3dd00096f3efbcbf8ffab1f34b365ec1dabd2b1f859c7c9f062b49ed5ec2009bf90f50ea4db1f983d5fec538dc358a2ce630a96d0040a8af12bbc73b971fafe33d98a6985f5def9b6c8c9cff80b847f6e144d0ccc5f0073f57bec3432e0bc4d7de3c05290edbdec0777bd31e7a83466405a3dec93b3ca3f9a7ced23c5961574568d370293ffe64c7bf559302ea6bd0fc16c7f59d372fca6ef20e24d26a65efbf96721e4889cb4e610520543158643f43b18598499627fa4acc8632bf9e5317994a99918f8c654d4bec62411b76f68680ade5500215d49acb8331cf63018d51fee0f665d01bc3cec895d05bb6cf8f0603014c2a1eca7afa0a2e282b7fdc63b094f293a1b6ca80026526290d98197b521e2b5175ad6723ec71cece2e6f650dbeac74610154c7c1fce1f0dcc713a6a426afe73692097042f0c1b9b7bc4c4e61bbefe2818a979ceb0404fe60a730e8b8df770815465b5d7ec234ef8aeec66d14ad2f25102170c8efacccff3a93946f7350143368afa0bc65de027db0db117978c073317d4838c9a5b140abfd68d9f1b136937a1edd86604f095f1cb094709e6b6ff66212ff29c0ac106d161bccb4aa66f383263bc66c924793909b3ec7e6fca29f9fcbbb7ebedd1cd0d5102f4146359f1cc362905d0faf32a863bcfc016927c1f6486b31193dd5ca7f3de37561ed4e18f14f39343c148c978b5be431c4349b511fd220e726eee022de4cdddff171d956914f188382e5c83b2317ca21266bc761aae7648b2d7a3243c29d96e3df7bcfcee559dea2f52f31654561fbfccab1390e4c2c6a436a66f9a453f8c2af2e647b577788ee386ae6984d68ebb3227edc559781751ea0320e1626b75aff587289ce04a6a1fe04acd230ac85f9ab58b9994a8732bc22c2e25434e69f88b34f68cd3e09a383c228647930c903f88fa2ca6b8fc7f5ae2cf46b99da9e6efd7c3855406ecd3ab83abdf8edcfda9283ccd95d17b4e500ede81967fcd7798c2dc9759894ed46ae3ac9c1dbf228ad8f15742c2b2efbfdb287e574822c51140eae7983d9958e40ca8f689de5361685c20eff44f0cf0923d8f5b6de6d28c2e0239e15dc55ecd392dc68f1063679df00b8178502d7943780674dcf5dcfcabbcbb2853615c4130b5706aec20b074d2a6058565c0b7a12cd0e6880fcc221f9d6c184ad336ae21d71f187bb0014d600f2f7ae93a764722d60ed8c96e12105a8acc09ca0daa53269ab0da10827c5d8ba322b2943953bad198cbd714bd93c06f0e017104a2c08a56cf5121755040e68aafc11ca5d2e8308d62a4d761ff257a5119a63a485624ca89162a01abf7f0227d8ca07dac6e54fc06b236e672345f07a03828daf27705a77964ba15db181912376b9765ddf9a2a0f62ec03df15083d9931fed94972de4bbaf6ca45018aaeb49502ae6ab41461c6b50e512be7bb36d590068a55045c1753e0c41d92d11e096329a5642b273ea91f7042794928ba2d92398d9365aca43b40c99ce0b2868983fdbb5e3e4091bc516848fb6fa85f6f2700a287d93874069b8600d101529681fa52890e537f331a79ac32b1930a41f18503666875a87be7b3ffb93266f78c182cebde965b2b114b67b21ee8bfdc3486d1cf380d17c52788ddb06dce4c298834dd14a032f791edf2b096f83022fc0d5420b69ebb9d739239f424090556cc8139082419ac90fc030f91dcfef2df8cefae62c01c9631f1a7706681e1139c7d25a2e6541cad2507ceb3c088487e8de6a0d60124f07f32d518c14e9f35c322793b89c74d60b6ac7988061044eff19ab982d0070f5134d2e1d5176be0e189470c26bb94e465eaa37f5564fdd6f2b75fa8449b964adbf95efda31a0786ddbb54e6337fe6a6a0a8cd8b5ad81cdc83b9e42899eda552da5c0fbe43b7bd40430ca4db196904acd59fc9dd6d2d9a1fcd896416c28677ba6b741f49e36cce89abb946c8b658402d3e71673f0deda41bc7fb6b6487bf446e944f04d7cdd1fe35d8c11f1136e2238274e338fdb982477072d596b83f0a4c56bc1a294ab6c403d4e2c93beb83bb2afa51d50f603704486579fca1a56c6823972cf7886c78bd09b99251d1dfe0684bbc1415c309ff09a348ea73477cd24f1fd2a87a78f2cb1003fde4e3b9786600eb4976e066c3f6418e25dc6ee42f9e587de0d233524e872570d07162edfa3770a0049c1c792098b8807e3f23b04569b2e5383648e10fb93b0c8d790e1a0b5bd85a7ac29d15fc5d77ed867f1310cc37fe6e37ca687a518c88dd5535345fb8b4719f20719615a0db182cb74f9576b3b8f1f8a439c04172a293f0c4eb34759cf7cb302e6ad0ad0527e05891b90c3b5122cf06957b37846e12038225f01bf6dfbe94e31b675c36c9b0c65c9db294c0154cad324a36b72413ee68af50c5e8f7076af3628b2230fd72bf44a721bf4cf9cddf65c027d642a18db7dddc0dbf1212ee4327657149c8b0189933b3a83a5da495d9fd6cb0a1c2f4520419ba8a26d79528d715f10335a0d4101d4f6da509a3c2e3cd32c0efef852114644575a7ed150c66813c0b7511e9463182517aa608fbdcab48d152bb9ddcb0494171f5253c86f8ff85cb1c905e4780910708422172cacc0962edd2f9d7b08e56756ef9d0965228d5d7c128c278b456c403c5756467cf3764a5987e0fd0693cf5cc8e75bca9ad130782410cab4d51691bf04f3b4130cb514f4de8b4e1acfb85ef18c3e689b2bbc07cbdd64ccb88fab44ba4cb9d7d7312ae0d4ebf8015fa4f9842c83268f2444bac6cb057717048eda2907d68174555cfc1c5bdd6069ec460da69962490f44e20041f43c23ac04964388e08d1c2db030734c10e6e84b17ad86bda100f678967dc6a9c8523469f1f362c7c1def807f5914d1397b254a21ca9d98dab989fadad6fb853412dfc3f63168e9e253ba61b39b2e3ce0165c5fe2de1730d6028030b144c3b3db810f773ce4f98dcb3ee5084a62ad2d076a12515d790197eee0cb0dadcd55cad4614d7d13468234b78b4d29625faab6768dc806c139011752dd36d096c57a4d9e4086915bb9d019673286ae37b02506283f13f2e272a31dad8dfb9eec4e2b48541ab683441fd5854d498757c5e0b0d2b3e31dd9b58a129671243444a72bb75e92fe7f32779320b042e8e1a908fea768a3c292e09320b415865054d17da8168015f0721de685faae1564ee66900744c59ed23d2a839c6cbf582341f8eb41120661b5363188a5ee9431a8bc29caac697344b6abe260a5d304be621a9a00cf171446d6d1de576bbb97864c7792b05161c7c34f455397eba9c509cac949bf71399bdb9ea97fb38277204bd22964ed90a0c0612060c56f7106af32da9f387ffe107d9d099771e509554c1fde9c36a4b4ecd4358bcebae2e29ed99f953e910b5891b7269cc9067f2c06a842afd18d157f86eac1be24a29c9c436ded017fa41a3a4adf75d5bb1cd61b35b2545070086dfb96b246bee7424b3323f379e3e398a527611ea627fa2423ee559034f58e01c67c1573971e42675fb637bbd0f9490d8d8b0a05275651c73d0f6ef35656b58fcfc8a09ba244e2a820769e1316ef82788093076d1e342e595f2b663217e4d2f3260cc6b1c74d844440bba0e4feb2798c03a0a0d045af4a16f65038739c54ee840df2fb9561d32cc8ff709213191d6631e313b95fff0de876c058e23f9d1eba5ffc141640f445c520680c96e8bf7431062921c5a5eb5f402efa7db7efb7998497e7c0caabbc6bfa51e7311ef277185fec4d8e91e0c8d8438e9c651be58019da1fdcbe97d1a046b9c0114488dd928618f71202672c33234fce51cb15f4a6b2733eedc8590044a72aa83fe8a3f79eb1e1bbbdbeb00bab7b2282e801957a693a4f4f0e5954cf88326ca59fb19c002656c12b5dd22e710cc14e72a947050735a09f168582d782d459c5424944948151263cf65b3ae5271bf377e11f235e82966524b1e9aeed22dc3ae3544ae660aae370792182f07d7767b4cc861193b79adf7c8716ae767b1760f958be5290b6fd1b48b0a12bc79be3a6e2330038bf7268d478f83cfefa3baef16f279a6717e616d586e693846fc49462ee5936632e0aa65b05834ea6fa78e6d4a9384bb905a1fe1b5d4fb6788a109113d9be875cdb7e33350e15d038d44b485c55f637f4cf50b8b6ac9769e400d78ff8f8a3ae6c7eba2a4be0763fc70e6350c6a1a2a64a18fb9c64cdfbd52428255502e0858de1a04ee3297136e9c5e588b50cda1cdac118452315f3282082e86b0c4be17073913718bb8346dd8756a47e59845d9901718d53a7b58ded58f442d2a6f1fb1d35b07fdb0cc2cddc5f0e64eebfa18b0b5e6ce5fe687cf1f030bf7c5146dd74c83b1ab7e104cf47ec0bf01947660ca532a778c02772a1cf4d23827d2b9dd3c79e0b9409d0d91cadfaca5056eca7204ef42ed44eb1b1e9443d81d17aee5f0fcc95723961d6d5f6389e86a1ca0b1ee7a30f463e39954207a5049280d2beffa264e30192325a59caeb9573eae34741cc635bdd2322b11cf113ad00461732dfa3458d5bf81200a66f9f79779c844e20845b8a8b7b67a0e64edafa20858c3567d3fe433a7954287fee03240d983a7cb93b46c5fc80ea253a622866a994c01d4bdfc3e235e551392b064b4a434e40d45950006c38b448ab40ae852f9b52c45604235dec6145f6a66bcd709c71396c903a196258591d6cd9bcb7b7bf70b0240106b47b5949f02490c1450002bbf9e312d0fcda6ce5b27e8a6a82192700054155ccf1a118a0d84c91603ba9075492bc4d380275e43651228582481a1a7ea22c35f20be435a52b664b1bbfaa8bbc86861e077f48c84fc8df7b8eee2f522c5b0e756df61474d3e13a95c6fc96e92aaf5da158307abecace3ca29e5b7066b2db049290491380a641f3bf5a87f12ac448a27990676571ffc4a4d4d1446a7bc8f25f5c5bd609ddd79ac0120dfd0520f4f3382e28dfeab834166f4bb27af544399c117df06450565394917c364a517a7a10c310d18f3bf7ebec3605b704ca42242be2532b00166d6a3534d74dbf16085d493c6852eff9a4b002f6098923ea8707857e1f08087b0e69cab39090569ab59df8e5f1035e4e4d21673831592b446a05eba947988535ba06b3ba45bccd54845d26d36a4a8acf5b6782e12a55d90e55fede0fe5f443b57e811114263c668e91806da972a6f6d3b8e2c66237699a1c5a1ca4396a91b1531d458adee2592247d21fa938709647b1b428d7ec9e783b807ae1f835a8327aefc9f4b359364f9d6fcbcb1c4870c0034c53b7dbd09452e449bd224f1854843f7d54000a7d288613225a6c66381050261fa72a2f9d7912240201ac735ebf77e5210e5befb703ca4a6300d7c0424639ed8d09e06c41ea3a21a87b3950392a2f783faac210726220b492b38f90b45b46e671223379a6e606cbe98bf66488c5223c665151290838b8850524ef971ab8d918c70948a62be09aadea955b105ae642224c6762c520cfc44a86db2908536e7ac4782fd7d2f4c4a151aee54982a1b4485cf6b84f88ccc5ad420dba073aa574da294dcc89232b951f5cbcd89abb9eee2a80c5a3ed2114c21e24537f47c7e52b0555d7db24b300e5acb4375ed269673149d42a5e1e64bd778792ebe96445ed33c946f00b0b1182dfe1aa888605d893c398d48892d0fe6016fa3de9665a7422503d10995676f1b4991112141d832422f23ce245c08198b451c7bf9d64b9989e4b5575dc3f70d5b95746a1b8fb26c7ca9490670908d724c3708996af3b9d664b044f7e4950210a2896d13e54a8c1f7d0e6e72c37b53195b11f30d1a620462c02c65470738455bddff7ffb1cd289338ee9cf3bffd169a7650f9ee481544605c7ce19063a87777f180eb77f908f230738a822bfc675d2a4ec8efe0d24fe7fb14a0ea168af7e41bdc822cd1cb72f73e212f3f3d8cffa62197a2795d2857d0aad8af5771079c68935f2727d1930466652cce0dd947aac90e430b2a3bfcce0326298cd480b9a03f2f721eeb4506f5df67403669ae6c7688576cb9dc4aaa0f7f05a11db6c48af522f74a69b506f740c4ff115f2cea0c5d2a93d8d591175445daab3c24e17e0da5b6dda585683494afb3c7423874a235a89de6ea4dacc0a3c48d6e06d83687faff2fcea016a2822cc25d578c75ac9f9b68ebb531307f8ba97f3645361c921369f25656f9b38e547bae0685105b34d0d0e8cd3879973c2ee6f1d99e63a669534d9fa7baadbc97ff89fa9f161ae23dab1cf8e388d355433c816fd73404dcc6901c10c6cef13b9b5bd7fbd03dfab0c3100e6e3dd88187d78b3922eaa803e0ecbe3e6c374cb85dac51f0233f075337912e82e1f884e4018ae22005352d4d3d159d81bd40a5ae914f07f26926a2af720f373be19c36239f2e9b50cbda9dfc7533208a04eae2cc68431bfa0418a0b976d3a204f71c2820c4ce2db4dfa5f66d2e966114c59d143841bc7e82ce9a2347ba002a6d5777fa5f8588185503bd70362e15a845d103230c240cddcb4d0edada2be960d095aff43f20d68f34271cc69cb4d40260c368066823d03b837e0f44c57a602ca1b70703dfdc05bf56f0ef9acd46bad10b58aaae821f91b114da682e1ad3556f4c28875c2e5a3bee0378c12624825c4cc305d20b162ccf76502e3450747f0795210099606813a90863cea75133814bae7767698a76c016faa3ab21b61c5498633d55466f2d990760c00fe48e7d64417e3a431358598fc88f0b78fa200165b40e5ebd40e35decaee6fc696ba546c929c72813384f43923a4138742a443c24c5dbaaf6184b6badb6dd32450eb05ae99032bc5b1fd2204ee4f1d149f836b084573b97cfbba9bdf45b42f81f25223bd427fa528e3718e6baca056bc083b6f89994c838f910eb9b2ef60e2c3f59f9f05b1c6442df0844cb906aa7aff0291659954c1dd510d9dc99bcb9576e21e297124d771adeab31478adee2e34f27e5352d8a43e8499e2f3b07c51babeb5ae7491b4183a66bd84a1b6b4d124e87456ea612a4da147ad49b5fde21ac34ce49c8ac1e364fccf0bb099a75af914e1f60166008fdef134e3999488461f9bb227825df4ad75ca08ec27ed200cd0419131ba6335bbeb9bd623b4d9ee96dcb4126f427e8a458567b7d36f13487dc140bb2587fca48162adc67cd0769bcc09d309aa6d09b23650adcfe97652e00d1e24f1d8d2105e0523ce3deba68e3eab113c5aa633637cf7b1ee413dc288de57f0588ed27cf8ba0732e5a90bcfef8419f1acf73f6318f7610ab07902dddbd5bf84a4068f5249e6d5f6fb9fce44c661759ea3ccc76c031e814453d05cb71461b84aeb028b6143ea3e0dd4231e614650d452a423b5a601db29685d05370e369f4939aaef07c8c1f73f17a51b5e82296cd0299904a098a7c97025eee55d14b29519e75f12f5dc09f4baf55bb8e58c4e061c80dcee40b8cbdcb662a596e9daea7bb60c8ac2a08053ea37f2584c6a1ef5e2e02133d8abe25848e94e61af5381192c627f54a121934a703ca941684582056b24a07f26597e77e2fbd1946fd6760593e9d316307dd13c1cc5cd5030680fd9fbbe537813459e0f28c39d16d1f823a43ee45b6a9ce15d5c0480fb04a5f9178aeb1adec2563e0008b56d2882464efbdb7945bca94640a5b08c60743081ce4f6734b7e06e248c2862e84f373dbd21591dbec59f971fca3e6421e61422e452bdd18390e23bba217535a0907ee2d6e8112ba4e646253fc3b3ed9a64c791225174c1d9138454e59698ea223ae742e713764a6302ea9b9f1a8874b32b211cb9187e32db9f52475d1e32ff6f1e12e1ab1cb3f1d2c6b05298505a41591c202ca5e7e2133b9118c9175771e7e88a6cb11e7684493021bc62746401af40634583445baccf58f5a6a8818298b28ee91cb754cce90c4cbb821af31847361c368148d5ac8cb183e2c09643e3afed286a28ff69b0d3c1ae25127c05ffb0858edab6133faed63a282cff63dfda33de649d93e123009f2d15e7a524640030e358c407b157c827cb4eff12d763ea48c407b29db47821afa4be0c3dd8ff6d1107dbc411c7f09619deab2b1cdd67991b91c5efbacd142b14bc7a13a2939be3d1c1e7bebf4598eff7bc45f375eba14563e51617fc3a38149f439c206907fe3dba321faf41f21295d59fdfca8e58b928ba568f4c5a42f1e6151f2d45ccd7c03b13457ab29af944fa43c41698d2bbfe5af66e6929116a52ba59371e5473594ba7858572f041bc6a335a6b02c1fc6a75fcaaf76257db61928bffa9939e77cb2f20060836d8761793a9ebb16747c7b355ef4d1e1235e2935afc36379dad778ec53738477a6cc873a2e657b2b106ff968ec816032cf1e83fdcc175aec6bea65bc50478c97144384f1629037642615f6a9172f05ca97f259be7c50e25c2925273f8787c36b216fa1bc76d2445de3f5136fc9674d91bf153971e5ef68b234f453895d20d05f03096e3c0ed1e7c627a58c5db279e5c735983a87bbf27b4a3bd12f0008f5122d574a19a5a419364390cef1252197622e3197984bac8bcc6426a5c8921ca9df94321da386e79814cbe15c5bf7896126a0946294821527d6ba5a514a674b4ab9c8cc94524add23bf5ff756c3a5cce73c654f2ffce60c1bf39f93e38db367bd724e2b95e0eeee320773777777c7648c4ba639991963c6d8c3306c323327ed650c0929e7a44fe56cda22e5e7be45d62cab5ce4dc82512e1bc7338b8f25e900c93927bb2acd2a9d53c75f2f74ab29c0376d01be2264bac7cde71727e63b1a0431df3cbbaa7508114782b5f94a31ba84ad52003fd8d465242cb818c3dacb485850017e81050d70c02209ab821dfac1b7018b28f216635800d104c3304c054b2ea840cb009ec06207af08e78a0757b2ca6abff21855bca06b34acd8c1698d1b97a051458aada2835395266b650bee06537448582cc9ace4dcb0e6aa9e7170552a555293ab4ada82b7204aa56a6eea6d6eea53a92b7eb8a92bb0dcd40d82e801a8e57e0123515f918070516fad407151cf483c705284aa904191aae474485600a1564a6b2e0dc0a5b40a1f5c6a45511534e01e84418333785812f2c1aa38d21281d0c419480c61791c39515153ac649538f2e5eae80834260c1555ee2cc09d54a471670db09ce69c734e71842b6bffc089271ac663871459dcf9727e8d72e7dbd51457eefc0771a494524a1b3421a59472dae008cf0656a42062fe9cd3872f9cd8d003305a70848b31e79c938389020c1c512461f5824d8b5a6b553d11860f9688a2972788d0030a0a96d4134d442726cb830f9d1051504634e1a29c9218628342d4219d407b22c479e1244b41940d0a317aa84318695014e107fa6429b341070c668582a21ac50e3c4c178448a25140c941c2ac86bcc5350a24807061082d5140e1c4851428457185095c2062298a1cb8f0c4c82ba2310304cfb03097ab141145006a14e1c40e4554013a29420758952280e0a40726b4748b992a135dacd0ca8526869e0041145104af6856b1b10d10b12b82cd0013e19db8a2497d31c41bc6a42c66d56312bb20c03e31bfc5206ef99be0faf340c4bf566bc31587ffba212f6d552c0c6dc41bbb1e3f319f51c1b9acdb4b09e2e8a834f6d3b3bfb8b69f2aa5a1bef03b893e33fd98e4d2db3310fcae54e6d3a25beeed1ef81e84f8e27acc47c45b3ee3840d75e8e09d7ea2973e19b1c5dfee1a18c6d3088ecb1db8ae354ad17ee35a6b0ff6b1ead724d8ad0df382284563217e7dea15c9324ae9ccbe30d2c7aa473f529b6ed9e37b5c62536c395060b19f397eb0fcac060cc0a0728512582831f9c497b10138f2ebc962fd5b7d5f911217507ef09dd8b7d773a77f8fdb2db8ee188350843aa5ff832ffdb02f94f383b0aaed60bfb9234e82d54b3df6d9e2a89b882f1a88a3f3d957d4a9e3e637bfe370b4f9126befda59c72cd6e834de19b99b2f1fabe37f968b3407da4d2ccc6524a3265a2db0db6524a3237880646485910e6a58ae09891a24a108260840440d8a3080218bb5d16a52032d60036ab0342f23f5604526c5d32a0c16e2ad9dc9c308e01300b0e38fc9bef10a41ba57b4303100f35e6830e29c80009efbb12b7edff82c9b8bbf79949977ce9106e30bcd205906c18285b1f4910e8e4dc3505046df12843484b0d20eb604218d20323a16383b7078ecc03140eb1aa051a8020b50d244af95ab594dd178de110eb361aad1b204be846c327a1a42b00ca94228c01d19315b380de756ab93d0a3b16d31cae8b1b52933efda36d4dddd1b7377d7399239b20747c75fd8ecee7677f7d8e5deb1bbb7d34c0d5863c0c72efe2ea6408169107b49b1ae07f65e986d15fb9ec6b288bd0cd2458be130c7d2c9132a08bbf87980dc18262d8679956a84cc74b78de3ce89329f64661bba7f5766cccc9699ebe4103ca1583ff5a6645469c1a114aa4255e8052e7e55a494b40dda066dc3c6c7e8d3261b9f37ea853acc1fdfa56b524a29a594d99c2fa59452babb3b7f3dd2203fe52ed863d8d4a2820df2cca47429a5942ea59492c1adde60e3b39452b2942e8fe0a72da69c5272ec32659729bbc8c984c904c90425cc39e53bc628bb4da13ad8f82e6990a997ecc8c86808a329514d4d72367199b2a949ce262e534e2967939499724a2e7236bd787c9fcc2e19e717b99c3c2544e614fb28eb9cdfe3d393b3004e6cbc731ac166e34dfbacca4c6699967dd56483dbf7f4f6d17e9edf13fc8d7a717e766adadcb6d7e6c7e9fde0bb3df5f8c6d82c03468d0d573d9be296ffc74e0c7bbb1f7fe727d303ebcf752bf2965d8fbdf97d27869d9f7db6413965fd2f321fa6d3b25ff96fb3004e3c09bddac70273d3cdb0d9036773c28a0f4337895fcb567e58c18dac0323a594527ea1119c989898ee7e791a2ffcf9617eb5aa55af52a9bed008cecf4f4c4c0ceb5931ac2fe6865dad98c8bc3c8dca0b8de0e0dca059794c66647e62626038bbe2602a0eb7aa41b5adf2d26112192691292dd5b5bf2249e4f5b76ebdf0486b1d0a853a9d78e774ea3adee93a7669cff18ee4b4df78476e9ba6f18ea66519bbb4fad2abecd29ef2cee9b59fbcc33ba9d75ef24ecef61ec63c18df68df9ff23076f59f3cca3c926ffab5774fb24b7be94d76699f3ac9937fca637679cbe7387bfacedf7e117f2939a97a4ec5a99ef30fc9e993d244f5aa6fe6552a99998ff9f92b7fc1fcacdf9e6b2108baf6b9af5e9124f2da47755f68bf7e6ec69389f12c8cb73a72398ee338958ae35e5eec498a8d6deab680edd95b42a53e0eef43c5e3e4ec943f9fb9c8a30c9b7d6cba217d4d03927d614552e443fa49d9a40cbdcff695808a7c2acdaa57de8af960ed7d8006dd47639b5f04491874432925a0529fcab645ee7ab40ffaee7fd2b447c27d32d05cfb1aa7d99e6e6603c8741880dbf27b1c8dc3636e75fbf3553d9fbea755a7af764e11ecb3eeadfdf6c278bbdf5e3e36ddd46f1b6fcdc9ab39e7f9957d65fd4217279f7947fbd3b7abbf507b1b54a47941454d57e39a93af79bd3d12fae10cb79381e6729f7aee1e502f12fa2128a27df745b4efad3f24f44329f39bfc90d0f65cd62bf3fdf621e13e294d645ee6e96f350e78ee7e707c4fcb78d55b13c717840da07a99afab42ca7ccdcfaffeaac121f3f337d5b7b7a341557fdfa00ae6653c1c3532ab97f998d43ccd3391f91baa9f7926aabff1d65f333fbfc6b3dc52fdca5f377ebe8ca7fa1e87f1c2005cd557a47bbea87ff14223ac74431074bbdf842eb32bf585ddd7bf3d5feb6dcfbae1d1784c561f0dda0a8c98811041508183283e3cf3d9adfe0d1e68d8fadb56fd45c3126ea3c947e66f883e43d48749908fcca67dbff4b46f85fafd80faf2bd5b81ded63efec9930dbe62bee3623cebad292718563e8b85af97952ee60019e2cd3ed60af5d23742af0c7eabd2152e98ecfcdeb6ea890436f617951824109b7cba3de6965797df0af5fac73e415d82d82d3ce5d842561ffbfa19e6dc7caed7bbc9427dac3275006d6a6aea72b125d46fc1a873642b5df9d987f5a994a1f7d1be12b4920f957eacf3d15fdb9b9f451d77730ef3fafb01fd45b0fa2d18e9b863a0e2df6c1d4485c7d073e707f57cf71c9fe3f6e750419eece9f69f7430337318743d36ddeed9f568f693b3fcf9b2b080db31b05658c0ed5f0037dd3032bbead1c468cda6c635d87111d6294fb27315e8b8f543a2e3d69f3eec4512996e8d4b1c79e29491a79550ac6ea1fc0ef2e137ec5898efdc39a0629f8fed6bc7c2fc2abd96e26e5e91ecf96a5e91ec63617ddd0b5d855b3f242adc1a65bb3c85a0af0cd87d8a7d2cd82eb6f86c5314b1b4165d6a72f02407368842ce03d2164b785ec7288f36c6529c174497df89cbafbafc85245801d9380496b1ec807451dc391e6ebf6d918b6ddcf95d3ba7b2e06d08ddb0044aee6cbadb77b92f8caf6ddf378c9fbd772c047953d3edf19edee16a1e17a1cfb77a45e8a3629016fb045b3fdbcc96ed2dd333bd6a55c3744cdb4ef54bc746f5a9bba6f9d67a6bae6bd3c63a76bcf1fd95c586a561fec81ff957917f26c67ce10ae60b2dbfea88e872eab35fb862b141842516a13e2e62ed86c74ad1ebc7589c915fc6d58ddc754f0bd51f6859776466e62fbef65d2337333773a41f63a4941e493243e7546c6a571ac4d260fc8c1081e185af71aea051609b99397baf34f8168b62ccb237d2491dbb3b7667f1e5b6fdb66ddb16330f89c77844e784418f02db4410613771fd91ba09de6116e294ed88066583ee99d751fa8829ae431147252d0baef30be79c7372546c3f7fa1ac517af4b420ba31f7eb12b26460e33b958d19bb825d91f259baf7732fb179bb7bccbbbbe3f01a77f71befac777799777787797777777777777777f71fe2eeeeee38eeeed57d453383a326d3b04a3794e54e5d4a05f3728325a3847583663523a324060c18d58b92ee74ea524a2cead4714a68ad7453a26595e6f84e89ccd1a111d939e4155b70f4cc112d34976a15ba3e31724c3774a62e10601fd7c23e397450d9857dcbef3a439d4bdd85bbfb7b8f9618f6ad79365b11b91ec52676e4e3dec2cf7077af2291d8f86347b99b73dd845fb6871bb95c356a3e8c6b5cd6cfcbc894f8f2acfad4c7eae476dc5ba6d6128bbe88568b78426dcfcf21022e53c746452ef126bef64cde8a356b27f1e6f9c75f9e14562391c7cd8845456e9dc8976826262277125b49a9a8b97051f21797c8d35ac49bf85a70616a2791a7978837d1ad75a2d84eb468a9f9c215eb0bbfc64931ed84da3acebea852b3fb81dd1b344966acbea4994fe67333623a1b7c4b1a75094530315b542fee728975a225525cc7c4c4e44e2ceaa4c4a553e294b86c182dd2a2a8480bed732dcec4a5c1a8466f914b6e8cbec68d436057fcb05d0bbba2141cdfd960f943d7d2ccccccfdee9fbb96226c8cfc6125aae9192628fe4a713aa7c38814bbfe1b31c8db3caefcdd3d41b1f4b18fcffda6715bf65aad5ddb3bebd495479388669986f5b66958779fcd8dfbc2eefbe91cbed147c3beb0d2d45b54ca9e1e75d2ba8ab179f577e93289bd4831c62aabd58a777a48b768582b76d9558d0d965ab1974fc32f03649ad6f508b2e21dd495cf383f1f9006654c0f36642c38b458f98eb1a0c4963ddbb24cc5230a214123a5947ed635f6fe713e730dd2efe94a64bdf31174315a44f7a675cbe03124b1ec924f3d1aafa65bf235cfa65bf2376fff56ec929b7b2cff90afd86028aba1c807fdc21a8a2ef5519ffea84f7fe3066b8cb49212b726c1aefab1eafb576badf463cb4ddb5b6bc79ae6f0dad12d6eb5f8c64fa0975ff4f945bf1dddf2c7be70bb61bdf38b4166a928bd1d382028b9e8fdfd2bedea9d8d4de6784dc5309a2465e87d28f6a5d0a04c815d724a4c0576c95700dfc8df648f14748c6cc8615c39a473c2958e01704de45100dfe4e01d156e5060f0a5c32ef9f3637c92d1afaf7d3603a25f310cab7269cae0d421a961c69578d4f9e062d1d6f9d8ae4f28ba3f82f5892311b5eb9e4f1fa134189f28b1db0c341c894e78a76ff7f18412b2dda35efb6c72bc63bbbc46c0adce7e339c86387d7dfab1566befe9749ac15f40521f0ca8cf4883324a2cf758f730af7ad99dbeb3dffd0cfe02bdd57d4d755b87717d7aa95e4e24e097eaebbe1b724e9f0eb77b1450b7bae77ff18274ab63c1ef0a7cd371dc6f282f88f5f8caedfef49da058ec27e8af15b8d53d19b7ebba0f756ef7ec5de7eabea79fd8fef89143eef6e985ffe40569b0fb976e736ee66562663e2b1353ebdfeebbfb5902d3bdeafbf156f7b103d260f72727acfcd87d4c2452fda97b98d3cbab4e1f0bc54259d4dbd3a34ef6843afdca5bdd9f76b0a7eec3d5ed7e86ced1713becbbeed9a6fb8ac4a2d9a726b82d08cb0daa61c615ad8b51b4eb9f7591c84776fd6b17857cd4eb12099273b7813962a3bf69596c162bef64cca33d6fd66b40b7e847af278506290fbb280a7c43a906d84561f016cd00dfd06ae90b7449763d2aa5f4638c315a22fea2f1894486b0f6535f14fa58402fac98b7cf3e2f1fe423559f7ad5c7024ad1c09280ea6154413ed9cbcbfc4b4d7d2f1f7b2b4e919bac1cc795b7e8c378ff42e7d00869907e7b400d6adf4f8354c6041de01d19ec0698c79f3e911778277bfa30748ea66d377adacb08d9909788f00eeae96780794e4f5f039cd33dfd0e700ef7f48b70cef6f441c02f1d6fd19fd1e1ccaefa272ff24dfdce7306eb731e65b0fee66d0cd6d7f1178a932e7df6fada47fbeb117dbff42fdfd0fae9b08bfe098adddc7ba1418abaf523c22e4a9ffd6fb59f7ad587e32dfa2f40f653f56365f5b38f95696fa495b4ac6a35ab0f7a8bfe69079b42e760b9d90734a5c1faf1eb740e4d143af97067add507ea9e7cb0b171b0f10ec7925f5cb71ca65b1e39de9827e31b7faec1d6b2d8adb9ca2ed724d75ff4954817684a833cc5c636dd200873a3f6608b5f37cb7ad8254176a11a1004e3c0cee96f4757ae87777a08107f116100ef58805d3c14e01bf9d2524ecb62b51b72d6f9f00360b1f236734efdf60360b1f5fde7e9bbed39a0d367bb49e9c7a2d91bd9329a51a6239dd3577e922c56de21424e4416fb285bf7eb9efbd67efbee7b0e48fbad3f963b7d23ade44ddb9b8f72ecc43a23421ab1c929de6ae951640fb51091d785c9859c49cb1253176ff563515af2566b51aa4a995151d2512735166ff5917614c588e3a4d745de92d2eb28a827442dd44344714888a94b149ae1486bf196901f18881c252d49e9e9e000e9a95bcc13194e7a9168860501f601bde5ffdef228e4adf68e784b7a44bc253d21de92de4f0d273d203838e9f5e4e0a4a7a383931e8eb72427bdff38e9adbc253d6bc349af7a4b7a2c80959dc14a8f0501f6a9de72d90918f216c8498f05243f18bcd51fe4b371ebb4590103e946302e237df1837cc55c19666e7c18dee98f30ec8a32d4db57cb627d75e58d4fead7803d7d09843dfd3e1616560d45379c6fa495e6d785d2f53fed6081a68438389d1373c4079106fd67f7d3e0ec6910c7877f83cd4bb6f0c6652d872318bff0bbf1f9dbbfb0ef3718afea200aa101668c31c6c8aef81e5bf16f7c8c4a4a428ef4e0064764ecd84c8012853ef56cda61981c815235246717135309619c77c5894f66b0f20810b656cac4c474e4c81115143664a623a4e61df9354b42a6c1e460436682b2bd98c15c8cf47041709d92ee74c56e27948a092818daaa6cb02133f15175e94920423a8bd44b1362528aeb1893224f04d231e945b506962337f222214474705216757a51ca89b261d5ae62d738fdc2f9be756c5ec13d874d32738c07f0c2c2740eb78a1dc6b0c63f295629b4610392152cb0e189248c80c40dabd665a4329eb8a7cb483cc8610d185bd1e83064b208c21658ace08c2cbef0342a30450926306083871900c194c4134af8b0050d2c43284388223ce1c5510f16a5140013765eb69203130428b2f5b2951c90a04866108159c961e86e97ad3461a3d7702d6104932266a0841437306a1fb41449741835a805549a8cb6a8428910d478c2a70a2a866842858c13302142900c94a0820aa32fcc6062061a407409c3084e4c21c4141d7079820344d0c0062e6010c590920fc188043734f1448726286109679cc14df082cb900cb890b16404dfe25a18074c8c8104222ba46c9101ced72c965042b542c4e4486594016385480757bb6c85080b256af31bb513467d74e5092b188a201714c1a8054760b1c610429e250442f0392aa3890a9a60804614a38612436432a4022f24242424b4c589932daf4587036891afc396e82de4d19b9c6c1c5fd873830d13bfc8c3374c126f94427fbb51250ebd0f76e304966f84e996cb1b3e08aff2eb7e649c445edf912de994dd4a3d61e3cf2fda25fcf894131b8db055ece5639827035d210addfeab55e6d56fbb014e56b5c7b4ac22f19034d03863256cf62b599379d4c3784828babbbdddbbbbe79c18f6cec4564694324eb0c619647421c50bc808828c1b968ca0ba8cb434c6cc65a4a5a4251a2c4959ea610c36c640c21867c85c461ae34ad218518cf182315430c6500e4968a265088b09c4c8811855c49881182e10e30731726023e632d20fb460f9c11596062eb8302c38228816fc608805b76b821117264b142c2bc0a2888b824205b7a302e5724610714f3f5c19228b10f7e53252184a9edc4e8d2b29c88282ab9d11c44d8101c44565f1c3f51b5cf1214b0f17ab82e8a68a78b8f40527b8d5881d6e0784934b2f23f960071dae652387db3135b95996a1bb8561828bf10087bbe180c99d575c5992e5869b4971c5862c4aee160329743b175c69cad2c69546b071ab1057d6c8d2846b2f23f5a0c915266459c2dddab8d2258b126e97c695247041421635ee16c6e730c3fa11ae5f4602030c30ae706a051ea51777f2004540480bbe04549f521a238db45aa01f20ef6d9a4cc005e6f1e71d5a7fae1a9c5f6570b0212bfdb4108109580003fcd2a94a3ab5cef97702fdb06b2ae18029ac341f5c71346b28c5408ad534987d2c1ae96fb4522c64d51f33d6844666c4e6a45fa433624f2316e7b4737e2c6c3ef6b1300c9b139bd954025cd5ac583435362be660cc38b2e2332a3a02408d0d8b66b5a259ad6c914dcdaf56384c4c61f31d0489c5528079f855bf21f4931f0e24f586b4101d6cb8ba14c0b1d915c22effd313db92597eac39b1297f4a39a5bf5c213e46619198babbab7588191860977c29dc775ab86f488331604f7f089117302f89bd1660579d31e98b47f128c3c17182e3afa885192bf94f6ad147b153e2508348d90c6c4c3aba72a59d81893c1790e11d0cb08b89020cde0879626bad4cb1c8a4e9c0daa0209ffea98951b3ac9ed0f276340fb0f22bc3aa579dc60acb3ef533d495f5ce2484628c1c86b591235e926e1561977c0ff08d740ebc61977c29db73de06ee68d088c300faeb87d6c73a1fddfd61970c13ab02bf56de927f02efcc977fc32f06230ff6f209b023f2642fbf00bc739379ae1df6d26f1579b0afc53749270800c3b00108615c6a0a51877fe8b44efc8142ff40c17da0905d9f73fa9c523be9d0d9d9c8ee0737d8fdf8f958f7c39b92310c8b18d6da09094a763f5cca1fddfdf0ee47164baf96c56675326d6cc3c1649bc7d91b564d567bad734194514a83505c4249c02ef923881995523fab948619581d1d22f3669d8feee228b294526efab1d7e3587772c262f3d3316fd8d42b6a566b96d55a9bb677cd6ad0715cd771b33d1edbaf6aa66d9f0e8ef6e9e0b827b3a4db9e28875d591b1362dbb8b94d8fe0abc5add9fecdbf524952cfa32e62b14b3e0ddf14619eac12bb5babf5c3191b1c21754bbe94ec352fab300d629c7bf18838c58b4b744b7e0b8cc06a8c825df2e3137ce351a278378c464652fb19fcc57df1894fbe51f7b410e9c355dcd0fa0d1e6558aee2b27bad350bc08d4bd5ca0b53f10bfb6cb8cda673e263fcc2dea625a57c7e9e99e117b317bf5bf2d3b055e9a773429d2b5f2fa49342e7c897cf2e798212df0ba5d58a5d2ef4db2b1f8877fcca1701bf70b8255fca9608e057c8d3b15f401d060dbf70bcc53b4da441f92f6ec97fe1c89ffad4bb55e7006159527ab9e1eaa66eb7425fec5babdd0a7db5f7a858edb3a206811a940f34a48508b04bbe8f1f2a4a1e15cb376a58b20d468679b19734d2ce86108d146157e5f100dfd49ae5f0e82e07a7c1fa59e61969100625360ee1a0842c8f06eb6799bcfd5e03d8557f93c9c1cae01749bdfda83fbd4f57bff690c2699dd6f568b2213788a37b97a74e2bc2afd3179d74ab7efd803882f635e1d6df28277383fd10e7662feeebc7a1531c7a20feb2df0a25843d7ddfea22a95d8f9f25a8afbb38d460fd9313566bc2adfa462c0961939e685eb5ded250d93357351dd8556313bea99cb7e4861208f970acec51570af771675f1c8252638dde12ee71781feea3a269bf753d32da0509ba5aac7555ad91f9b1b28f393ef9e2a2938e43cd796c0486ce89482292be8dfad3671f89bacf501fe8adfaa78cfb2efb581a4bd37ed3b22dd3b2f756cdbefa30b06ecdadb1e885093892b20f549f94b08dc958794cff64171bdb586b51d7b24beee8168f6ea598a7a5e29d137ce686f64acb3b280cfb0dbba134bf08f65549c106a5ddd1a0b49db303a6b31b3b20a306ab538e51c29678c7256c138505ddd3a3b03f7d2c20fb27d59f9e7dec07f954d4a7b0477d2c20d4a73ef5d150c30bea837ca27d98b7dfc37c8ca1de3eca4e89ac18a3576f4d4c27059dce99f1e8d3c6e8a96e276f47b7e6470f64d7041d4ba1c1d9e3adf9123b256193db61d32d8f6fe6a901dd9acf7f9a73887d0cf08e0cf602cce33f5fc810dea13fbb1e18a555767d213abcd3fd7c149887fbf93cac02338073b297101d1b73dee63983d86b1e6510fbccdb18c45e88bf5013fbfeaa576de67c9fdf29609f0ebba6ce9d18b6f2d6c4308c6215a3d869074b3f7c1bfa014d9961a60e8abc314ab13232d94894813b40558a6f60bac6dadbcf2cff7eb4f6406fe1780b356def4aaded1c2d126141bc96659a963d517dd243dc72a795ba67350832ab35cbaa740fc889069f68f5b34dab9fd1da5d295b966173238e1b639aa6a27ca06e7fab2817a7ad88b26939750bbaa7362ccca79efd25e3431f27a394f60edaa53c3ab90da6e63198ba55ced2e7b1e3045a6586629847867a67784786d5b5abae5d8f0dcbbebb8a79dbad35dda230dd52a5f8867efd2cbbe8cbd86035201de407e41dfbf45bcc7302e7dc20e0456774548b3a751c10c60246ad2bede8f73418843a901d0e82dd0ad86b0ff3aa1798afaa52ffb2bd9156da364e92b9f483d0d73c5ee2a688b2aac926d53e97a27dd65e0c49e4bffc9e35bc722fa2b6a8546d58743de910d100000020004315000020100c884302a1503420c8b2de1b14000e7398486654170aa491280762140541c6186000200018628c31c814155501adb64ad121e68267de05dc66414b0192b2c99904d78b62811c63441cefdd086fa45d23c4ea2dfddcce1af0e3e2b9ddea3d2e65bba93f07f1c59389cdc74e88304acf3892d9bd7ed743c5fea13601808dedfdb5ee3a724f371604e9c3c41cdd767795a0debb90827bb90a030e1cc1dfd6227666abe0f2476168b85d92c8105e546b2f625141bc561002aaaf419ad79bce52906ea36db067f465719d7696e225044a49a1944f2cdfe99b65d335ff143e31df13fd157505f6c8d55161dfe7a963941dcf6f1784367056b8ac3af7f5e79d56a67d2f31b99adab1b456bcbb4c903d55af6a1b08d975cc1839f970c4cb19b8540775c70c497c8614df17d3c1c6d92d3c4d6a393e768969844f72dd9378672fe1767d6bacf8ad3187b109d62936792a4714f90f447c46d1e2d714ab200cd582025ecea6c41c44b72991bca4827d5eec13d91c86d14333279be7f2495e5cfe611bd1395a911d89829d4138382b157cd759061644b49a4e62f79a67d563ed009d4439372611ab04b89027da8ae8fc1ff9e26894452a0dbbe52e816fa154a9015b680808e3231f1967445fa0b6cade0e21f5af7a2a63c6f04da34723774ec0661b00eae40fa42b09e00adc0c738033ff5aa9da41b66d1628c3473c368cb861967c284e6ed6536b5c83e56f0afa8ef4f7cddc1a78472bb7cafdc0cd1ea4be39889d426dfec678ad6e36fe4714fb0764e72713109a3682a42799ba8702b186ad25858f05f5a92721cae4265b49c34890713baeea52c19ed0afc09751e5e6ef9a776299d9a453d27c28b6d2355b92920b120a556c08a7573e95b04b50e1768a299818d10d1b0c6c9094a98d6413960a1f7d66434bbaebd38f3365d2a4e280a540453a1f4223920964ead75e64f80f9c31489363b51bec9705cc492215a5821e42ff28aa40794a95ec20868a655ee4de7e1ef6aa196f3308396955d43125fe9c24ee23ccea8dc5fb48a9b02aa67ae73fc284c2609569dd126f259e793a6f130c229054df76fe23a5da284618ad2a2dff2317080f55553d41afaeaa8f31e88530de31d809fa84afaa4060733b7d1bbf0812ed7d9a4f721a0b43615996bf1a0bcc6c2c9be85ea43187100ad1db7a5cd23cf6d3b7237ea15d8920f8b6e0e4e44545daeab9aaa6a6ed7c4376879ae63d2a103dd7c5635ee02e00a1ba53d33c3261721a8cbb66166c7dabed3e7250b2a2a6ef6d24b56610f6ce4092ec34e08ea0665aa101b9c74981c65fd001986baac1f9dbe5571fee8f6c82a53d14e384038a60c7307d62d8b99de4e9fd119b6f92533eb4f10b70844a04b294dccdb7e86271bc4248c5c9bdc46104c2ad0a53bc49089f8ed65274b951adbe23bca97a17d3c55b2a3bfe96cea8ff886e2bdee6f48d59ac02cb337148f8447e94a314117c400081ef43b57446fd8ef046e1073101741cf7fbaa0f1a426cf4d4f6d3ce32478e9123d9a85d65b97488fb2b10ff4fb208463a19fef524dc6d95a7f517e1247a350b3c63ca17cc9225685af1777215bb009538521557088e156155fde15749a2fb1fda51ca913828e380c705dd90b1e1dfc973a3131b1fb72a9273e09dd2385222a2e495d4d3a53572a27eaa1238cd2ff51cac5ffcc2c02dee07d88becb4ad30ba7c4c04939deefa2503d75407a767ec217e38393a0d2ecf49581f5c84d31163c62fd866c581093f60b2fae4815d615ccc74ee1cab7492e25400f5556ac244f267636c9c4c5a21172f42a8d6d8eec256c4133059d5c53e682798c6086212a1c7d55774db521a0de1cbf3f0492386efe7d1829b3be6d50b1989f68af2264c77d78fb6a38d6a9c27006900141c17f7879b60a74e64ee56fdce02cd8d5c25722d2792c9aa1029170c2cc372bced2357f48696905c5b53955c7a659029067ae3531fc7d7743cfc82d23c48c4f99892ea7d184ebd733a70c2ddc33752b2931059f67e41a0075b4a3d17bd2ff0d11279a121c0060dfc30b1a449f612e33d5811f7c63a03f81b633dad03f9c8c43144ba623cf0f60698c9ffc860781e4b6f04f7cdb33ef6831aa06f4f6824798609e339957358a4ed42f6d777928c205fa88959fe9dec7f8532db336203713f4f21d6f6122f9eb016717b46bb9d8860ae03f2d212f52006a300f31944876959f48a5ee16d91baab620d705407c31ceb3a6b42f00c255d2f3e828625d3895b49675f695e8b66fb98b5d05afd4ad7ffb9888231160f42447bf7eff30819e938f6a52fb9c04363bf97f4c5414a13b208bacdc17ead0456093b7fb2369a244f849654e9cfc340c471993d1e3ab3f4915eb311a22d0cece2fa919be8a2597a4427954bb9076a0ae69b0469c6f4ba1c2e318db7fe076d243429592c90a360e2dc889d999d7816b9a63b122e48508aa84dddbc4d8426aeeca2bee81e187d8e2ec0b9b82e9a2c9180968426a6bfdc06cee6d17abac1dde03a9d6af0e0874d72e753e993263b2599500d08d944ab5564051a10a0e536a7a935297c985d2d09317920b5ea574b1c6c8bec7e6d7fdb98a68581de0e38630036c1409bae8df108a9707885b5cf0841d69cd09abf9996b5e475633d494e1796c700dcbd74d64ce9220c66c32b3318a4b1d38094d572a390f65320c24d4888c4645a8f34dc7b6a50fee352779e8d90e9d5cdac20e0515835cb03a819cd61724debd0383ec328abe6512ca6ca1d684b5b019cce4d17ce46e18a5a67051498bf3c42745579427c8cbd19fca8535393bf3c0c30d98f04bb8a1c99dc07da1bd04d135b11285200767ed4373f87768a660c91e51fdb1a3351b43537b613c1fb9897b4daf87bf6fa10f414709dd2eb20176c1b52428f071c987b563edd726f7db9bee413acee6ab92da64de4e204dcc74dee9719701c95c6e4a7dcfd5af771184a209a9e80673226882b136a71e609ded70c7293ad46c8ff9c02da7c12cb3a4bc537060ac28867731a823c30cb62de804a186026e937c80e8d8880ba0be97ba24805564deccf2c3189b4708e543a4c873322aff11800904e9f33992cb4e7d1ab04dd12cd9fdbedcad5d25ba2a1880fd567ea77c9c6fb1f2bd2f8e183f6e3661f61095d5e898811624806b71b7404e5dc74b1721e353576697b85e24374b78019f0682b25c779f32b527ad3ab93c88f129b3e91629438eb288db08a33af8d489679378eec838c52b407733003a8d84b998d7aefb39b1c8ff18a370f083f6387460aa09c7450bc0f9ccffad59784491efb640622727de772c5c53b83bfeee59482dfd0fe0fbd8df278a45fe95bbd3494825c2edcab25571d2ff195b756811c65ebd0ee80dd600de274489d0478a5be74fd39a8710e7f8883209e926300270effe1fec05672780d41612633cb6420debb15c6145af01e1cf8c6086f233dff5925dc97cd2a89d2737e74b0da8c0486db67243089c587de1bee42ec1977d1d457f9b75e6d988f6918108c7903495e191c21938a52ca0c9a9206bc47c4eba798be72f9126bea561470f21dcf76cae091812455de57f9ae30636ed4780e78c80b3a0b51ac20e4ff375b4ccc4461e33a8f9757b5442becc0ae8e6b5b44f0baa99036063b7a01449fc12f37561d1b4abffaf89c7c334fdb47ec4c8583da031303907e0c0ebf2822dd5a76606d278a1290fb30e62c38198f6223336d8d446d4a84f0bbd96ea93fc0d692e291744ef4a5abe72ecf1c701ae35ea15f7ce98282df4617edc6792a00342b698b3cdc68cc68811bb8c9834dbe9e0e80d0cd163845b9deb2f766c63b035027ca22d3f1f1dcfadadb8f41baf53035988f851911e8388cdf2e14ecd1836bc77cb2d42ec19e2fb8b618f8c753a78ba803d726d770eaed0d2abec200ae69c04841c15acf60477b213035f72181ab0df77b1950886d7508753c4fdb715f84de16f81a75e871e4c8eef68aa3afcbca306f854f66fea2058670914c556f22e4a605436e3c7711a6f46d5689f0857025c46f40d7dcb1690d86eb0ed6ef3fbe5e0f2e675455277bfe33b09faea9cdbd144a8ecc79184ae29cf48108699f0b4546079e4ae536a8ba24518ebd7590fff3d5acab0ee3fd99e4785c854bbc5fe7da3f5e51385d2e4cc359dc6c2b5c6007cfbf530e4f6badedda96bac0a8dc5e65acc9060fcd1e884af99d102840b2889fc592780161a9fc48c9ec92d1135bebaeab1e128bb0e2f5a2754031f01f99813b925df2c51916e2e5916f54534ad849b34878346003e9e8ccf0862e789ad4622e0f787d25ddaa0d32b567dccc81cebf28d4d01ceb64e80ff753e06a17c926f695e315c8eeb067b0aac0b1c17e279a274126463c1405028fd83ae65490e83d07acb41b2bba5c77791d0e30cac1fce9593115b6c3ab017f630febcbdeb4ab1c8f6d07a11303b00a2588377ca35d5e3249d05b7df5b3a7f4e9480bca93a37c5f3fedb1c13033cc30977e65451a3fe467460782ea48f33c064d1c205bea5ffa8c8062a29a2e099410c688dfa9a8bc4f5a2351bf3bef231a131067799eb8701bc28dc269b4d1ed39974520347759ec502f5f64da015297d3d44a061e3980b1382529b252f07a8a5250cea15aa665fb39567afdb3d572caf7f4dcaf12c9544ae24cfd6e58c1665ac9e7e1c2ad8d443dbc5bb11c29cccaeee8ac42ead27cad770c705b238b0194f77d1224f4ff98a3f5be76679f43e25fa36fac564ba76f7031e90c2e784569c8108926ff075cb8cf2724ae60015922a80725d5ca5e1643a09baad146efb7067e9775a7280d3018a3669f97a2df154d33d91e2ff7915a4a843e9101efc20aaa1a6aea475f8218eb02e890ad1c1cb35d3128ec83d9fc7bd90fe5a986c6357f2f5c8ca05a42dbfa326ab7abd56140040ee4b61880aeb680b262f26d892d77bb8201cb17fd3ea5f8856001f3fbc730d37871d2ce69bb586c81023668967136e0855989f92d9fe7e00fc4115af2a153ff6fc50dda5ef69cb5ca4449242229cdd65bea42e6b98b1fe19b5fd97e2cca219806b17e256a29dd21abf2c5a85aceca816ff5a0c047b9a61ac37eafb0745fed28bddf11e121364a1cb3bbbc25dbde661380e0e1b560fe8ac69bab1dfe152fd34065008520c9b786783b260a71f5cc0c2e2ea9181258ac2ed1a304f87482e43e6bbe10be1f62f503d9bbd6555b413880ac444e5950c55824043303e24b9a14e88e01f039367aa38829dc22721d41e9087c55132be348e63d79760ed90aea7594db9092374ff8bdffc17dfe3f900f918b50be49a3baeca61c67aa5ee82a44e4a4b03eaa10d417c9352f79377dc556e52fdab60fb7b7f6633243665d9cbc2a5241b08105b2cb54003d221bae9b613dc03494c0766d500442ded0e59de875a6c587ee0a74f2aa900d62133981d7054a017527e1f0f2a06c24b0d09d98d9974d8d5509d26f0d3c5afae09ac6de5252536db18b420ccc31649a76401ba124e338af97d71bed34ac4c443d3a945ce163c4a5626061cdccea9b9bc5257d612abdf0c8eee23157458c013cb859286cad6913651d62ac3d81248287f84b32b7467f315b964d1334658a30c4f14179e5026ec2c30e555529436899953c9042b8a196a30443e8928434c31bb0efa6f29c2f8be7108532c9c2b2b46c512afe309045c5c359a7787ef4fdc5a47e10f4a8b7cb995cef769a4287ea4bcc0cbf885d16451964d9a120287346f660b332662cc7b009228c2e8ea9f60038f4fe8609930924b6b08bd84ec56ef9cfc564d605c0cc00e265e7cfe14cae009cb6834f16d93eccdeacdac6e7badadff84e6c80581f20f8e006e0920d64bed46d7fae47a365d89ad71888580282957c19cc55afc347edefecd2522ea26e9562f84e8a0efec7f898c7f05b82743f8330556be75c0a83a32f0a3606e18b3ff9f21b94ee15ae92f9909564b4a664fa72d8ae413223ee34f5d5b3235e659f265839a27af614ffa38a62d4b7908e526cd4e302122709f68f32f74c44a55ba2c2801b66cb199a2515823dcc7436d4ffd033d5e1fa0cf433b2288df9a147dc9467920a29652fcdb29c7d717dc576943ea90ae9b5a393d6b8586d1fc1477b670ff67fd09b5be4022b7abac859474bd8f8f3d572cabb9051ca547247b43489d339d63655bc6d135e4da61ebabc149f9e78da150e02c0babf5038f0984c13ac07120f20ee09c6ddd03f0793a6e622558c994e7350bb00e8c2b5289e6e87320ffcfb3a3651291984486dca9ec8c2026bfbcb4d17507c28e255828ff01373c36d96c97cedecc0f218558981e52cc73e11745d12c98d7911f1c725cce10339321080c68a01c3e2e169e025ac61e52c0dd4e40ed7c9ebe735ef9c229d8ea7602e75bb6746c2147b735a8f6dab5a5cce634f36a737250853531be9023fd4d6412b2ea58c16d055735928677d97ef181c51d170a405c87bdbd0303e102542a9d9cc2bcf71b7ad1510d99a6e46652c3b8814a911bd16ed4a7d54e68bf20e3139ada9727a4e9a9c38266f73f25e37616b53baa7d3700fa4b8be61852ea87ac2866267e524a5f6ee3bb7850cf10c827bafc0e323f1eb2172333df3fac7db189cf11534610db4d6878f9488975c1f807ca7f89490b55688ee625de50dd8f723baa37d137d2cb7308955aef02a312aab1c241566c843bf93971b4a0c204b0368881ca0f66b5b9315e03b1c21b1b9099cc267dbae4c880810c1b6b327dcf250596c7ee5b245b8f5413cc7ec90a515690fb5ed3d481a4ae6f921227349940c5eab5055d3ee976c2df0f28f139d11f79e009ac4356c279cf2cea91f97cb5259350bf1d01e415490060ea217f56038b5eb9720beac1f0a1580333275cc8321a48f3f56cf51a4cde698c6ee246ea9720e33741ce4896eea7e1064be8e5f1af395463b9f5f6c897e46a50beffc65d9de65f9a2089e92ab7563fe32447a76dfdc327447f73c7768904d29ea15a8fb875b887ea37cd48faedccec84b239330201baba091952963db90c6b647284ff145022c78827f368bcfa805afcbd21dad9bb5038dd18a525d890d66dadc241f6f5f9db575cb72d7aadf9226ab13f21ebb5db2531b4ecd5c5128f533a23b6a0f316bcb43b1c1c9cc7f9942b4ca940591cb9e30593dba7c433808c4f8be55c8ae40d9d65665e5e62aad402a16067347e61199a6ea79cc66469f814d222d5ff2bb7c9b8c57abe74cfc6b28ec2ff16e5f25f651950b8030be98a3471a2526937a7861824678cf2ce12598826f90418662e0bc08f16b98634d494152d84ac034164541dbe4fb9cadbe4fee6b7cc78068379dc47ea9c254c405103b6043ec3fead90926710f3308ff84f1136f67c325046fb54929860fef5f78814810def2b736ecf4905408dfa1edd3b5de549bf3f1a4386ed588914572373e39f97624c928c7d70ce2163b877e832e42e37d95662462f1a151f92456c6b1376575d94a073e27e88926e56164c9e080932201e22870aec4f0c82d17db623ebae21e5737c31a6b9d2e8f7100f88439071749e7fe15ae9019e9ae42a0f1fde6566a86c70c401fa9ff88bc6c56ce0d1291dd59ca6af157694989109ab1135f55a0bf4a48848a84f530fd807566601257b5c69e65a6a604c1629fd592047719a9ad3a62a03329ed2cc44008eded2255f5788fe8b5aaee082198d2b9a1adeabb68c2653b8f97e223ff0504209cfcc68b282f391956f3119447462097f8f0ba3f829baa8a2e753b3998e04b19eb69768d834492eb6ab304eebc55f81fbbcb106dc30f6c73a519118cc5c727402f623799cddace960f82405c571733987fd652151a3e2dc672a6c82c8cf00fb5b90d120ea5bc07bf90052ded24bc664dc2ab48b011b8342029f269b27c25ad618cacd1bedbb6b08d15389380628fcca383855077c9f05240b84a5fe97bb1953970691b0e8d2390119a1fb73ea4e2a7ee2fc69a47de3be80ed10cd7bfdbdb14595a4812c1b73cb5d5a5ba1c22541ff01ddcc21637b4c16039b5ded8fc5898f0fb2a61f8d2f8d4e7997da2c1a87d294411c4841c895063d1b18d2bc9b0dc7622c8eb38e4b6eaf2ef320c2212517cb0355b225730078d29efd51fa19501929e8404d46243906e2e2130820ee00bd1d849608dbca4c3a9e8af6c44e94aa48cf5654545e9ad7dec1694481feb72680fdbdbf95c7b5ada979c17bafb3627669d6b9fd619aabf60454228a10a99049276403b5ef266d8eb8c6d72d4ec508fa46480706267d42db00390a997cb11ce81dbfc0f933c6269fce244e40d07b56c8f0044ec12f8a0b04f841f5bd44e0d78ca9ee0f15fbfe1f46c4afc03960b83c37d2f39cb0d72e32b1f8f4bf484e0860a68f0d8b3c41ddf909ac4d5b3d7c4efc8b43203dcf66091b18d51d5571c1cc96ad2d143b0af68bfab3e5d4ee37684807983a730fc53308f6defe48bb53c323e088b6577647305e24fef966301e90a8069f6baaa0b8f8dfc62ca6e549205fa498f73f5a072a63fb44b9a65c2c9671d4e2449d69e6152e8a55413f93f1d45fbe3807240fa2aeb6f1dd3b012952a8cdea136be7f017723423763dd2e089475f1cc07836e2257cfe8d6d87ecb14bd347803ad37dc04bd4b2373e530869e3987d28e0b90da2b6e8d11e6cd13e2624a0435dc5918eed3963801269036d9865a6fcf642e7879d00c41e3acd8c1eb2aec691f6f09175953d90e4ea56c95e12cf98f2223f98da000b884322cb57388bde3d7d37f2fbdb1546cc2a629a8fb19cba1c6e8096f901986ef2c866c542a7d55a36a6bc989714cebf4e431d9d4e22ff30446d7fbc0309b5031b1c02f9d325d223f547373c4ca349e14e85d4a1b3088d1c495b2f512eb8cd15c2b4ea598736625782d600b2ae7656bd9342e3daa030e11f6b920538960f0433605e6d4c429c58e5b5ed7bfb49d1eeeb626c5adb2a3bd190add64b6f9dc3ae55e2967fb870b36e23b7c15a9ef35868843a7040a0d0fe2c8c274b532400074cd3e7589ca6efe4e1090bb5e41edef21799337a627531afbcdf552abeac42877bbb8dc9d4676f5168d0bfaad782f8cfd708ac2ead7ad138cb686279f1fdf58c2adee4230e4922ff48ab7bc062f5c6918f6a5c6de614613e9845d2f0077fa24f9d1216161a06adcaff4a07ec9fe0bf3a2c5fedf35b591b95d4d828f73c0e7f59cb747b99dd3433e5e7ae32e0ade2052abe4e2f48e1b05c76d2499cfcef01427b00d67698b8c733dc2d75cd9d3409a95111c306b748692c9fc74350d6799be551adaa09f1ad6dcda31f5e460f67e06d768e40982e7c212b64c78ce98542022fd9d591bd1baf2af3a3509b3535fe31ec1534b6aed8d163f98515298ab2701dc47f1f8e09304514bca92271f6bc8602f2344424b6b410bb69a5d25195bb6d069b038e72e7dffe79f1a0291759d5af51869fbba2e0cb6557f1cfae22d5c38aed8f33da45e3d6bcd4fcd23789dd5f9f932c35b64723ef8a8190638c965735fcb400bbad5954a73a8c234c889bb84260ab13d138fc0263bedbbc479fc2d424ead3a735ec5b0801198ddb80f317dfbe84185ef5f797d5d72b4f71128e641cab789ee105cfb0926a4e1a3f9baaf81ef7204ac1ab00b46fbc9842e6bdd997b8a37df849ed4f629028c36dab6c4a0e27780273135f619abf468d8ea3a25814a8018c095d7dfc0a0172efb7c644cbbb14db5f8333d0a7bbd70a52ad448f0384cd77a3f94c31ec258a0ce37115eeaa6b62fed5c8123453809a1c9fc806db38a1541d04aecbd593c6b1e741868764c5a2be5aa9cced303dc9beeb68e7fc96a24806f4d2f280266d6441fc0224b8013194bd13672fc08ace2cb7e9d8980e600b48298cd5a82536396eeb9763cedf26a5ed9196bd43d8256c3b3137ce8115dc16aac3b3da26bc2ab9bda444d3e8dca5723d26fe0cfff259dfce3ed4e52f89d622c00da53bec616d0ebab2a57679a4a8b308dbaa51107220787df9fc594871e687d0bb91b84a09f0f852e130c5298ceeab1d2296b741008acc500d2860ce0915269fd47af8f2426765090f88f0aa002935b708a26a24d69c34cd679875cf46442ae65fb0b6b7e0c85f7784c7bb4f5a60ab94e4a36b8ec67b913e3d663357bc76370accd64011443fa9075a9ca02e057292f0212b3ca46c4623f62b16dae1310cca836227de1f3f0ba40ebb4eb0a4ab6602343222920b151e9c4011810a15a07891df8552bf72e6f46af2dfd45d79c959d1c436dc6b9462fb146636125915027582c380ebf73ff2b8b15c4b21f5b99c20f88ddb81a26f132129d80aa81fc55bf1f29a6f0e4e5c65bf4a1d4a0fa451f7ef43b950a357809a10c1ed1501fb92e447ab44f63d4280ad6a45825d233d36c5c670900d0800ae3e0a84454517d6bc1f0b675e01689ffc156ec75ddfda8eb165d41ec411210803abe492e5762f10b9a44d2105d304dbab22281535e5ff570c6d6c398506803328abbc52fbf5767e510813d60c0bd1d8880f6a88b0fe38c8435d6314374378d2ea937b345e32dec1a0cfb0c64638ff8ec2e832bc99eadfc949ec1a97b43bb51da987e301e73ffda8b2ecfb60ff0470255263069a9afefd7c75e269c8d53f0dd46d6ccbb46069ba65888e6badaac8978a31f6724276962195df087fc6bc8469a4ae1790419e2309b486b830f7fe6c287e366db1c398976a79c60c23b7c94ed66e92f54bb61a1a0ebf6a041d011c6cab0994fd80df84d6118e080f072715ee03402bdc9398f078c494144629728edfbc61e26d6c7beea2568c0fccba7712839197799683e359db3710b91ed5f2cbc9e562fc4e1a2d9bf82e69c065b3b29ac139f03ad191fabdb544755e606c59807b6ce4ad4051decf223d840e4f63b7d0a1a32a79de8f01280c02a9217855d88b7bfdcb0f8416432b3539da890547adf85fc5cd367d9db1189e6c79a1bddb73b701b47c89d971c8749d7ddfc708959b6991af53cf421c9d88a5ff1a8c041cc7e94b926f561a859dd417c8d7ce169ccd495447322793499b97668088d899696344ad964cd94c471f80f97ea5642249afbae784d8003a07ee8f588253271f1eed3bd520722eb4fa2eea55059ea65e34572c60fa52489a4e31c029a0f034a1d449eb87d3284abd77858bf7910ea8d0cc0b7827a976b3908cda0a84d632c7ee4a5397c9856ee019f8f93fc0dbf3f374b2434789796b181d99859d3e78045f0898bbabeac292c9a545a931df70e40d3cc108ae2ea732bde581ec67f91cd860cf94218ed63941b1bbbdc4fd443a5b62dee7ebbf1f00a35d1737488a096ca649d118a1b4d3b9498adf1a3d0a72afaa62821639eb7643eccb5934e8354cde6328608204703abd6c8d5c2d26e460381bfacfdea6ca2abd188b4f1a98a5e8431f228e4e82658cb6f2909c49ae72832e8ebd09c1c2a0a588bf490349614ba270fdb94388ce49c8ccca1e2b500804140f54409267342c105bea3c6c787eead27322e8ca09703b7413cdcf6296ffb438c6ae1a6c4620cefe2dd0b16dd6d017ddce8457134e2f89d58c06608bbe299be9dd91f77c028813b6cd53f6debf885c5d45685a42d035744bf77cb128c4b0fb85749000dd0ca4671b26a9648fd3c8fbfafc1bfab8be9ebaee200227bc4810dd6aacd9fb6609ca331e54b5303b58838f39784477c80e04aeb1a1fd63e7fa6568a434d675854cfc190e922ff5583d0e4cf56d8a50700a5b1f67300b8f8fef2acf72005a950f12153f194cbaaea80d5385e9236b0fc53260aa582e69b4c3f9f5b0e6a47e28e780b556eb6774b1f75697f0c45228a60bd608a3285395b9f5c9770e8a5c11c8afbf79196a854a92a0f3e007ca8bf14964495ec65eebdfe97c592c509f57fab9624a345ee8168e76a430992fc7925a4275aac61493bf12f7ced7cd3a14aa7c8dc29266086ad7aa7ab69713dd9fa418fd0e5a43525fb1f68ee103df4f52a6d29277d51feeeea86fa830366bf0b8c6fa5571d881a7e82d4b7f487a654152f6d6029d504dcd60514232d84fc790a245899364d944207c8cfad8b9481c41508e11432bbb4052abc4912e8c4fa20d487d1964bec0be49224d60508e5afc2ac903e6389431276c6cf4656be7cd5b53049747e5bfa2b47d50cf5b4756c87dc9af30459dab09fa931fc9c6362339ad3c729ae13189ad538c8097f53267fa52eea1cd7e6b8dc4427c36849da699955b4abd18d3b10ec3623922d495487fd38e540871a69719a77935618f66795442194fede38075d3600e6df797f38ff491e753bd31af6c0f3cacea884c0b62d2e308534f9baa53cf4f3e5230a1dc6ab00acf66bdc6a44760ee75fee62a1767184c852534d5f02e11faca1429800d2da226c42b82e5fac89218067bee9365942ca8f9693285aaa98290a7ccd55451b4b16d0fc17a9f6376cacda42282939115732d20dfdb177005c20e7852a4b161d6e606ae2f88288556c41dd19c2656b546a0e1af15f5368f63290e3f7530684c80f0a0d5cca8c20d0c64a6723f8375283355aecd0230444f6f2a3a5b156c0707b2635d948ffe2859410fcb05738007aa0e41cd060ff20c26e70688999e52c7b1dba716ccce36dea3d70b3e32e43a5cf047de3b057cdc1870e24f15294408c659de16cbd937e9fd7e20de08df9f7b9efa7f44dd9472a8b6a1fb9a3ad6e63eb28fa6d7a82af61245a5d9cc21d594eb670bc70a733c7edf70a37de7d861b0943417285ad6b0f7c87899235a892bcf25a37fbc12012fe0d24d2c019271832ab12589d0d0de81914ef9d89d32619862bd7cbc405bd0881e34267976cb18c62d7f6fe6a72609ee8c08d197f801e1b472b1b870ca0515125e4bc0247be43bb959925b41055db1eaa204d6529dcb4368c5d004ccf7a58a350d93a81a91b4f866489865e0e490cef54ffbecafd5e6ed8d3bcacc32a2c7d08c9bc9f98ce0ebc6b93518c87e66046b0290723c5047bc773cd7751259e35ece5c880b04f85d4ce873736e648efe11bc1b823a07a0ff8c6cbf15387b4dfa0fd0cd4568450cf468d17d01dd01b417d705b3ceb5d86f4809e7e944382e532d99288ebe023480bdc17ba8673146075ff3031ec93ee9516c2a5800de32ec7604bd311ff959320b7dd88de83bc20d850d3425eda31286533a02cd628228c8e90348bf749ec40b5d1716c7e6d63e3a0be77621d86bc3b3a3d3ac1620065ef4e25130215a49ea8312c4681a2c548d8d9bd093366d3c923ceb86320b56ef84d29fb1691ea673a311a883e16bab6cbc5d5005e5311fff76d61b68bb4a32bddd3f9fba7c509e04fba8aee29d02ba40ffbd2c4266443877cba9dc18c1a6324baca6a6b54cc41b42d11647d8917a260fdb911d5872dab819f72ae6f3576c00e3169ba0b7a2dd06765bb67df0ada8a1eb412527444d27d3f13f384249ed547b85a70d8e6f00196d3e19b44dce1f5b152463de577952cb1238023a973ea392ed895683a8ff364ca5ac37c06fe436ec91c7e91363dc4b0fa194012ccf166557804f9c12774e1dcb6907d2f262a4b0dbacb21e3d984bb725b3e48298103c97ead4dc958e5925bef578d69df4cc37b97869977947d3f49ba071cacc65159dc11837e50daf12e5969b9a52ea613769a65137ab11bc0d15eccc7d7eb98c71173f5cd548f06eb0e8507ae04d7993b34407d389b0a046f24e192c012306b9ab5b4c9497985185430ba511aada683db869352a37e93948b2a7d75a2bc72588d54f13ec7b886a558258208e4005e7a0317a721a57fd6d2c4ac6bae4f1ecb93fd1dfd72debb8f7da4b986d26aa055d2d9e9a1b15c89c62097166f2cca5b3a133abcdd152d69d1f13ca0b4708c264c5d7a298aa5cce299e281ec9c95755b33a1c3d7a046d78c7eaa14df33458b642a6636cdfc0f925561f68c1cc7e868d2d31b1e5d318e419e28d73ec1a206cd694ce0cd4637956caeb778630bee52691252958def97a88f4c3aad9b29133b3502c73de0622b8cfd9e6539decdb3f356040796bd8c9de8ce0360969877b531636694a48b063b8f350a503e60104c598f2d42d2b6ffefed4f83e4086a7fa7690b095f867784e99130efc98a39f8cd322714603e072f41cc2b49570722375e631a8691cb32fac31c84d7a81b490326246e5f6ee53ff2cd0cc62ccee594191a781e3d5336d7e62414c70fdce8119c04507bc741436c56eed8131be3bf04142815e29f05287bf5d88dd0c1ff041428adf0500f7145225d5811a6a8be261118c32af7549e53f4b10727da65702dc41aef0918cbc8d75e20ce7e46c2fd7e7145e2efba17a3fd5e865964119a2785102c1a4fba30e0cb8ba128ef9c7a3c105fac94e51d1a8c47c90c093a298eec3b4afea3144832ea58b6392476b2121a8ffa50ca8d8bb0670db8b8bf39f59d71c67b6c1908f997201f05d1dd5320ef3fa889c07809a87005eacd497a6beb9e40754d45411cece865cba7ce6cab1d0f5c2bcc6dd14e7cc8d0fbcda8f446893948924e8e4ada01d87f81fe586edeab3fc61c06a3fe889ed179c01d18d5d18d2ca2ebf4de4266f1487235dcbec04c382e67b7b96ef263cbcd0f5b8f5eee165a5e307294f35ca0b6a470ecb238880379efcd3e57479b64b06c7436450b6dd38353709ed7addc9e61dca4a69349350ec90158c7056d52fdcf2165e2cd8ea06c8159dc20fb1aab5358f186f8496864aa2fb7f005b0e68e5ea7d58ad596be96ddb6ffa8d03e968b2c599ff49bff40ffe4a100dab2e0a9af88c8853470c0b0be4eb3e44d03decaf0c2b3e77f3586658099743074546596ddaa0f76fda9c4576f061cfcaba691d20d34551d89838c9f287169bdf7a4bf6bab4d845f295b1759ddf06cb72e0349af25df4e61f83407bf273295f84e712fdcfad67d4700ee6cfba8da7c724e0280c0e8b0bd5e9d94ea5ebe3e17a537ba9c0e50d67bb3fb4e4c16f50ea8b649a343cbe72b77dbd59ec588bf915790250202dd10f3b3f5a50972bfce46145a844fce93e7fc3a39bb8f5f264b404e0ce551ca7db9000ac3d471939e1d78d29affeb6fccac41e45d7d96559b1735cae8cf7c7e32787ac64f1ee0e073c0db24b015ab3b2a040c13fb4192420401a03bd87f85ab8ccbf80c0f825328c1db39c105b8d2c7ddbefa6b69cd34d5e75f828f543c76043dab30ea62387e6e257fb20e6dcc2e0c8590fd3bc6422653a582abae4dd1377c1cd6bf4a2fbf9833b99e91e1780bda61e32a47450ddf17b06d347aff92d1002e27f177b97751520827491b639036dbb483a0260741e109786e48b8c1938126b895de91ee94f073103aac2a3a58a092880cb739c1c63990bbb160442a3ea3c62822c92e1bbcf5ca26b114a958abc8eb6545beb3e93e13811d69f52c6a3098a336a024881eda852369d6f069c73edb6142c63e1d67607007b6d37ba494603064488c2daea01d2b542de8252cc39514caad8a98241538c42d959de569c1d2043992ca71ed59de90b91da4276a68a9517336254b041d202d4f04a74d3667d95d91e101d0cacdd3355fe86abbe8f112a05b31216225b114f63ebc9204d051d2d54657c80e661124a008d546542d2876804db8da86114099b19ad230811972a196bbc76e1bff4075832ac084ce91367c1114663bdd207c10dcd7173d7a546cb41df09517639272d6252f3816b5df0fca75b5c4f20c91f11d27b70b9d6685b97b46dea073b67f373cef11aee84a07dfcfa75c162efce3b33b576f50e490717440fc336493572651ed9e11b947e382ba64f94f246d31b51f82b02feaa8bc90c19b6e19edf9263c972dca1a4cce2958cc9eb47ac4e5b1d3955b8509952b50c7206e1c58b711a3b1b681f110d3e6d5afe66c8b57ec6d4bdb581cb1e2d6a07081b6d004bc7562e5ae4ebd8b034407c6818a6f6dccf49d99c77e7b2e19908c76bcf3ec12b3376af1385165842115ca7d4162644fc0db3354e80124b5c291206763fa8c50a3a19a0ff051e0d46afdc5e8ce608ab25032d760a1582320769b439a3f958fa294c79177a4f57c85992e6f3436e23cb9017e935732528fa7661829afa83372d51a7c63e1e946cf4c9e62260743436ea102941ae82cba04a9ea739b550998cc385506db268a9455c911e0a1099f755b167af95ca0b468a8913e7f6bd90809aa429c7d68c7104577883f1c22743ef09ec7395f5b533a8095be91b7c9ab6884769131081dfbf48ef8bbc4076e824f3ec51b460b1911a8cf3eb1dbf14b696738203d5ce2bba17f45fe1b4f14d02061486500a292c46becc7a688168df040c9ab1ee8fc6d4030c3e6f06e851cc54c881c14a82fea782b1315b22c7e3f0a1da2e5db0942dd642a7c7c9940b4f47485651d9a6fbc6cb86ed4f5f1d8d99ff922828c2ea50270ee3ea4c864cecdda00a894bdebdcce2c3901ed0dc601830aa276ea90198204146accfa749a74ac40d5b82a7b648d8c36d9abfa31146cdb284a60288bfcaababadf938f67b1bb223a1bfa81f0fbcbebd24daf4ba41751fdb6e4265c5a50b07ce69c4f2f3d96c35863d4445e188acf83e5cf76bc841596f86ae16f47e8f8cb1f57579c38b976e7a7386e8e6850cf778585e553a3945e61e54050923ad7eea7639ef52f26ce0d6766887c1f62202a1b850ca3c3b44a77cb04563b30ba57dbaf2e29ff450ebf5d60f83379c5af0e7e4ac01de828db26c4c2f5c11d7591706c756f2b6d1098b852de236e555494090d706fc11a3f4f9a2d115702c72bf211b3cbd8f052044e28f4f2f71c27711916715ad96cf035d1ed588efd2d17b20b02ced01a87272c05cfc99b9fdae190b3b92357cd5e4051d5b2bec459428e4cb0ede41e848a0a31aa809208bb531e032aa797e4824596da07f99972ff6d6c1b72c911655b01530221bb10c2b953e7a1c9bc808e751fafb34db23cb349ca12bb9f2833ab1ab5b1a51c2da99cf600917e6264060e10d2db35099904f932622ed48360ac334c7788c3528e668b152e9262d802cacf413df119443727ec3effea4468662fa6c6994d02159159f0220b73496906732ec3c4ca4c9bac873dc90c479ace8f52b71ccb7e549494666658251ccf8556c7adfcfdb9655ee704514a262c1076cd70929dce25c836573b069cc26986c3c855824339d761e4357d482f5640c956a733fe214b6c0357bc247fd8e9246eb9a256a20d5a10bf7b0deab4b241a92618c793f688a1f36b0c2160ea2b2d41f66678881af4dd91058ef52f662ad0a49d75da4073814c7c601c230ea59d524fb8f911e0a6546af7d6c7288c3da58aeac4e1abfb894811e212a2f9f541864d249c4332429e0c0667e463279474f277789105b5ba03273f0f319c7185205b18b4f073144a1ed081c9162ef18d71c652f74befe7313d130941952cf4312338f095163075c91785af6c8229f2c609c6909e6bbf117892f9794b67514f2c8254fdfa5786d5bf042b9922ce2ede45dfb6bcc6e440e2aeed12788c349eaadbd22cefc184c663b1b99ede3681cc52ae0d81cb51eaa92636f966ccca8c7177fb0a21faf331ec03e29eb4c3edcdd5bc2e7db0f29f2972668872cddeb0ddc7983c7f851cb6636bc52acf62d283689e1e66284e079ee6d3604f18f8125ff92b0dad007677a43ae102dc6c21b4cc31599e26d03c5b9ca1f1596a631cc2d92c13d014259da4ad2e027bdd2cf25b72dd0dab9e41995cef1085c2e8e1846f3154a4943ce33f92ba6d1a07ce238606c1c4d415fa78a046d7e0df504df6fd099d112f6c0c1f19b231d8c628f450668f1e31a7f2c61646b6c63c3fdc39cd49cd21853a22d40c66a6e5378e82de2ab0b477d1bf8d50f0081e4bf415caf82e04b895aa342b9e4c0cdec3ebefca5da545faa162628888333b7e32c0bdde0c1343f62ec2f9a2fc23a456eea48de8cb3a9a2a4085821f2c7f749c27d2144afc426878d64829245fc75edaefaa2dd0ffb94809272fcb776b2568c433069df6a5c64d440f06516539e2630cd50282cfbd9151695da13950349541d22b29fbf936778ca390a27727165319701ea0b8b8418f0b4184b4725cd3eedafeaea12984cca61a44b77dde4195dfc8a2b3a9ab1133bc251204e8e5a24da39f82f2c64ec3ba41a7e5ec7bf828440be64073bfd17448438419f0b6399282f2a2d4f335f9ed7d9f748b379c2faf344abcbd42e3a08c648a4205fdb037ea9dc48708675685c539e9c2b48b9dbd38ddb1d9033fc41311c35b9ade22a86dfb93415cada5646b6c67c3aa017ab5942c744be4a33edc089d7bc163c224b0452f3b7dd495a10eb1d480b7428d6dbdca88a504d368f6125ac15350d6440b60f3a0a10450858ca80f93b44da4c27a10973cd323ef86199932585250a6a3e3ab408c035814190e76cf93da062b5f087c8bfc22fb91edddf66ead5450e2ef9130068d78f485c86be9802553e8e34a70ad2545eca03885633881b85507c65bca2ab747b2992bd03624b6a5933bde7fab0482b16282171c76f6fd013b2c3daa3e7d5174bf8726d2c3f402cae5f240f5be729d8b024a95fb49ae6245f6f02dd49fa511b5de45ea6b4f0d8ff5d402193912b3f96999b4a7fcbed572147e0b02f1d3a78f1cfdd6300f93b9c4b18a64efc1b649cdc0cf873692ab249306c87e27d39c136c828b94163fbed501f392989ddd99c817503616ba9c453b3b8e4326516407572dece4e4c04dbcfe9bd76face522671f1318415ad5cd38fc7c1b1972199ab7e90fdd6bab8d63d3613af408f6acc76b054415c06050726e684ada91064409aa081d145761ec27d891df81e195b0e08e8640b68e126acc23247508b79e7e9cadc730a3f451abd483f01cb6e938758216c0f6b1d6e7b67d8a99acd8c1ef1dab92d2d14c977ecec03b872a74f7632a5e1e318749d923b9f8ddf0c0ecee5b9f0b1774b7b81e91b5fb1d59fcc13c0f16993cdb78a2457e657edd9541476670d447538be79fefe945f0fedfaf24b79b030ebb1a16536bd66b87b23a3f4d763b8291db1cdbe4ba366ccaeeb324d91b78a2f533bed512a63ce35b5b9320b643214a6f2c69c45535c7fd1a3bd0b3495a59e1ae8b2f85bf3a39f3efac8e3503fe01ace8c5fd565ff5cf207620c2a1899148d9ed0816bcdbb2ab8574fd54c84d97cd4442c0ee14e3dffa83e65df4b17607ef01dddcbcac52c88363913dcc2efa57b03a6637ec44a8c1e252214e728d915c0a7184b632a3e4f1a92b520c34488a45b57a27c2e98c991743e0fd8f916ca874364abaee5744c61f4024966ccc69482af7d817c4cdd00369285a7debf869fe646fd0903753b1440995a3bab952f91393f1401d6392fc643e213146ba6cc79940cdbdb35310d4d85382a2c1205e528bb24263e850170540fc1d071c4223b441f1eb8d783220681329d1c25b35480311bfad007d8e9b85425956c67b19e2bb4e62b0f6ec495595b37a96aa053d0b7dc54a2ae2223e1227e8fc3a16229e4f9a904103e2376898c56a6f7a032fb17cce48c298faaf103b433e7edb7f4222a671a47800d25d0fe2f39f7db4aa0119b7166a9cbcf1abe35869c52f801b803a759266018ae3c349ca05756310a64203f48905146a81f8a3d9cd0091a8fa7cf378525e350aef1ee3876289b166c10187b9126d8af1ce95b482fc95d47b29b11bf70efaebc56ae3378d2f9b3160907c76f80ed08d5ae32628efbe6f216cab582a0f693e8bbed4236c06aea5d886c3d4f7195033546dfc22d731aa95b038fdcedc79f827b4567e0de2d7f86c79e4fd0d491165bef6b031f83e2078847b52d21fa6fa6975f37cd0e50f3e25e893f704b6f06cba4e4846580f8e70590cc30660c596bd291935361fa23f00803277514e5f585709a71b88be0d5a2b051cc41a5135402416e307d5081959e85af76050b453227611f6d9ddd028dad8805a3c286405eb92f010a8654a7c03183c1bee9173a43bafc2b0cd34f7018360fbec1d0bd46f215fff365159de3047f461830b66b6527eea31baa317a4b27b24ab6013d434467cef156bd3416aea227b5386c11a18768f51f45ef9fb511cfb92dc127a24336c6045d3788951c6fb2c2ea14a73206b7c69d03a2991f563a9eec1fae7d42f793b61295862a7028bafee1b9d5546ff60d8350e56ba071b7bec964b30f4e0008ec1849bd088e1cb28b17366a110a6b39796408140386ffb8d4603830dd32cb4117f70da94ddce89ff8cc0fe4ae0b3355fb90b1c620fa6d85c3b8416e8cad051825ba064cf27979bed061b0132ada91b9f19259f83e5f419918b2f05695e690b64343c382988ebc69bffae31fa57d1b713111465030aacea73174d4f0873094cbc96817ef66cd4eb81c1eae442ebe8792b388a68062c039d16071cf244c4f191a07aeb5a30019c2c8d6d40facb5538438d0c749e5dbfe78487138767b40b47f499790075b8a5dff57c70bd67f03dc5f73a18871de36aecfd292bcb0a89b6c0e33ddbe35e6a541904c0b8eea67145f9cdb4fa0a79d7a0ce50d812bf579259679360cff1398fce1dc06c4599a00332959a472a319a46141cd07805c010c58555e054c56ea14b6087e11af74c0f6b99c82e26cf88199b95e03e0cfb2cbb193dd27233fff25e5bbfe64f9863c1118beb13239fdbe3500f77e4e02606e9c7d3191b6cfef270462df39dedf9430cd093d0f85ed3d0f22b457186870c036cdf239b5d177d05d79dd4a761af2ea46b3a50409e56da306422f4b0162347a7e79e9468c192c3ef773fe6412629dd9b6b0ebb48335deeaccf31a17bbc45df14f123bbb6deb3dbf854a3fb0037f6c88f7c3482bf8b4da1b802ff1b8322f64cf455f2d0b10f9ed120f1c93dac20d0838de107eb9bd1318a61f2dfd8936104efbac5f6ffb673562329227240b2ad50f65441ee15ec930dc74b087552f254753f9ecebe2d63bd77ce6ba9a6cababa926796bdfd5652976455dc1da7ad0ff873349ef3dd10a1a5e0b92b3a6014df06d80dfa692cc8407d163b5c0c9a8ace50d1bcf164636ba49b92b7d49931405be577114347cf1c4d85c2609126025ce2080783f01737879249de7aeaad6f33e091d54feb4c45d2830f88efa01fb32f0fcf67dc66ba98b2060acf504d0ea5df09eecc5a501ca7ec9901871d044145cceec8277a8728ea34483fc480f6cca223019c9c7261427a4b418e1d0ac40dfa170603193598cea1359b3291ce8085318a7cb67548aa1f1243db75719da8f17135064b984b9e5fa96ff056f638837e169bc103dc360a284c06d3e68e79a91ee5dc14ca97ba4242d3b7e09ce531fef4582ef2383131ff5803a36ba05e260984eab61be17d5607d49ce5f6db11c50e90df29def9b44e9e48227c5a6c8a1dd37b5cd59da7f40644fbfe795e5712064042e259063b3b834aa169f3cecdbc2c2fe16ed9d588942a664f6d17a9869f6532680f3b09fb420a875c225fff1fa2e26754b84fb4cc1ae54e4101457dce3d4b2c9177c78f5caba7b5498756bd6345b18f2d3b9a9a7e56289a368f4893b362ea98799b4a76a89cf3261cc1909ba5470d3e078872f1b7287a36c986d2113a29a50964d5c80bf87f3ca481cd6748a91c31e94e8ee8cfda615ab9249eff787bc615e014a11e75cae53f9f9573e8604bff5b880ef8499703463db5a71b093adf60981bfbfd00fbaa8c6690d0fc27b2aa75d58570bf3c1fd77912aba09dbff32274e73c575865d5bc73f9f1cdce8066f925ccd31049c777be01dad7452349408566f4c2810c13b95805792513d0236b4ba7e142e5c8c7dc26e0a628396c45861b614c5f8d627587adb6574d276e68b0f25bf0e7f10e439e80db2c8370813b4d2b4a03c6a5817767d5b328d1092ce45033748f570d0ca32b19d25fb6ac12c6f8b484a8e2ea509f4a11b7996c9e6d3abfe2f1d89ce3a2705f2a1adfeef2ec141f1f894bd5d5fb9b605bec011c4753b25c4f2d4c5d35cecd409ca6d290eaa52e416cb0d601918098a9a9dfea46cbe6e4ef61e67094b313f04448a5e0706d49ecccaf23d083dc8f4c8eaaffb8451746ce85851894960e7df687bd24babc959bb71084e93a0b575db7897628675b9139ab6a9c31bddd58c014a860a64103053ed333214a4e8f928459e521ba4bc1f1936e7e2c0ad3a4f35f5545288345ed1072a302aaa4bb422d041ae5518deaf10d869d939ae43d6bde03b25085483e13311288a27ab6e211079d9141ef89664ce6289cb2dc18097b444a5268fc230a81bbf4e01aedd925ce2d1e73a809f5c1bc6a33e91b28059632d1c7feac77df453a38b5357cdffa0d234d2a86ed0fc34d019e7ded9d87cd6dbd537b474d448af3cb74aa45ec1c6bd7c59a7078820f11e8bd9e8e8edeacb24372e4dde9451ae6649bf4abd605cd6730703437a2f36916deb13b8e8d183bb4d7c32da9720e9f1c23850663bda3d8c268471de84d892fbc28e8ee22e3369c196fbda6124cfab2c54e15440c4e27e4429bce9c4297287f8ebe939dea95324eeb981a14897bece61e35701393eb3ab659a3159ecb19e6d09dc0d2a630a58bdbbac1e0c536f2b6e604eea740054e425bf34f8895719a7be3a4117580571087f49088652af6450ec20fd209020693e31fe58b18eacda49b3b245dfb0ae0aeb0d1c0f036de53c8096582b813db096f3df7aa38da5803fe591c14166bee99118e227b2c81149322489a56a696ae3e550e23f88224c8db8ca0f048d246c9507ce33f901b859235a225e26bd0f35a74a6a7d85d95745ff6d45ea5aae51ba42f5fafea5d64f7201f905155e743d561cab3f0dc8d03398852b8e24a1e27558266a7a868de044c72d3d1d064775bc9de806a8eb7d2d735d70e37f34c33e4c1a08828f333130106f69c60f5648d4f4419bd6cccd57188417521dbd1ea4f0ae2257032749fe196667ffecbb3497ed10ad35873c44db037ff18123195fe916afebf28a5fb90d91c91c702b4c4f23e4e9fc6badbf1b678fe76ebc11333a6db4340e9da126dc84c2ca815ebeda2f7ecb7654df3d1958a7778ee2678bf64578ccb93cca228d770494f0d59ec89f1b2800756690429060430e77c0b88fd7c2214c559d44474b39fe269ae6fee2ef6a35d70b219cea7f04bcd11706e2cd1f56fa8ba8d399c0cce55b18a3e995882733ff0c63c5cf184f3a38a91a902b433dd3c2d3a0dc4c50e30d5f3f9bfd7f60519ffeea0ac96d4ab84c8b8f329161f4622656f01f7252006f24ca1f23d8ce243c4d070a30183f5e4f1779703a65a48da90553b6e410738c84db270eb129c82a62c26f812d9628a15f45a8427f6f0c14100e398c488633d2ac86151388697db61992fc4948da136040ecbc0eb76aa7aa07908b72cb2bcb719a54414c3755229bed338306bd4b5491fa29ee3a16525db5c1007033db451d5cf0da302052fbb766de86f3569af6e46ff0945858f9dd52f2a72b2966d7c54ca7131aeab8b67266b94d3871c513d52e3b532b00feac4bc93fc6399237d0ee6d69665b3af154bfa646a3a578b9f98f7d858893507adf1221b073f2e4c50b274ab280e1b26a169886e2bcd4893c15548f11c7cd830505306779061add04b1e5734bc67df84980acd74574cc205543f991f118d7284ccb4c4d9f54d1871a00c6268a48f9b59dd4ddd4bf8f861a3cbbcb5748660a8182c6cb3e1d6bdecb54f56c6933817ba12afd74b8e8ff631203fa294aa2091f40e4914355da6c1f0bac085388d17345766808ae5abfa59218950dd369c6e256870bfb5789f5e1d4a97340f9a962e4937aeeb0defd980e20598bdd68425518b018d37067d1c365bbc247730db31695240b2e2883c58a8edf1d9e37108b7c5f576fa2ac269b26883f541a7dffb25146bbae4fe3900301fcadcb8bc0a00b0fa316ff8a04a6c55209fb127da406f9674009c2e20db614114fc5743383c2122c52f27daa70ead2d5e00ed2a50de4b67d8542b08675fb39539adaee2338e8fe19846d9a18e6d9682122c8a0a622a5b835db000d3d8318a87a76d769d872a8ccf01072f5f71058770d1b1dd5cfc5a5af457e62cd01da88297319668c5a8645c102158c5e7dfad2932711789a44979ad7e7337a69b7dcc29c8b1279b4704172adcadf81ae682647fc684351ae5da0ecf6ee9d900cf8d7d29e7ceda7385b98b2c05f069991061bfb00b1c7dc668886954bffb0ec5a198982e4ec77869fc79da7d95b92cd901d8c36f6771a64ed81afc8fd0c0d8d5f79d4f919ecb4506badedaf8fda5e3a9de7f8dea577def88c1e0f1b0e14e08a47ff85c2a928f95663d6e2f5d1e9dcff9f001c1306db2243ab0c34ceb26432c877597602bb2e8bf463d1f9afa8e39de67b3b43f54e80bae59896dfc7569b043319cb53e379215b0c8c8b8a7c67f2e6698d72a343f303e715db24d77ad2acfe83d3fa1a65d1f94d719c8d4516b021ae0a488cbc52b862b54cc3b2a858be86a9437856a978eeecc851c8b0c0845cb597ce6b093dcebe0c05b375a5c823aa03e0449c9772e35bcc145c1bd7e095afdec8396017017895285b31782509314209e3c79ad3a9d80b0f7f54390d54ba0699d23e53fc0eb266fa7d777fa244a7dd9dfd7d9313f8cd3980076e5ab1e62c6aefd049aecb887ddf2323fe90df38b2bf76a36f305ee2b430ceb0b2879c63800ca9dca94a5b0dd6ff768d516224ee7d9fbe04d42ae16f8967182d55155f0125526c8cbb1f651ff2867c8f301621f65dc3334fe96b5ef49f9d913c71420533ac86d769173c2e9401ab74c243696de8db47068b7e0de56b63be10cab5a6f09f7740021fb9be99a60307a90676a65c5578f9963a4cc256829811fb2b45cd13085e33c2390f21f9cce78ace23cf2788527024e1041bdc1a430f6cdc57f36b617c1a45267990addfc14380ddb3fff321b0eb61bae24af2ad33de982b0901cf760ec0bdc59cf2a1859e9f0e4269c3e82c06c354ac7552230d26f955da5df27b1957e9570eb687b724da2ea8a377bd068ab26ca9cad6d50abd1d87be51c5d15186b4e0c898c7db513b0bdaf74df89b18fc88770e32e0263df00adfa8afab90f160e7f96c33e89d3533fbe0dfbf6e1d1e0799638472e75e01a2dadec7ff6d3dabd5fa79f3d5d3d74f1ae2ed72793031290757dbbc7136a782db59ff8c85370b2c08025dfb768a8d487797c1fb3b0568af71ac2cf2ce91822fcbebae6b7b154747d6cc2855262fc201294547a187f5db21858930fc157c57f9721204018aeef0bd79ec5d93271325891eb61f06fb70e6d4618abc0efceae62c20310a9063371e5cac44185c78c67254f531638d9c61ee5fa2a4f02dd8b8327c40b271ecc475f411375ed945f2bce50803d41f84bba76bb3e48fa814d610b83136a0589682a57d852f601a757fc627000fbc4d2e2e9035492d7aef38f07aa0b2ab0e8d444d6ca9f2c5b1f92253de07ffb0a17c7990a05665d1cd97f57c089001d3e627598132e8b9e963589234398950076b0876b316eec96c8148b8a2ff3fabccc76c488cdd72a928f6a53ed3a95296833ab8fec8b77be7f10bb1c14ee36c17ebf3108468039b7fdb468bf2f0c6982bfa45e09d88356659a47e95f2fb4952ad29dbc046ad40ea9aed96027fd6243fa4b0d4e2927b06ef2cb77bbf1ca0d66055146aadf8c967858499ee6c85ec3cddf1155c4970cdad5eaedf0afd1c9e7425871e5a1f0d03aed0f042a96b81bb19772dff69f012dbe5d5ef90d2c5052b493fd9c2d0f032d9ebfbc648d5c887cf90b1fd5c93647b4628a8da8d0bfabfc0cb568faf2926d741670a2bb384b7884da13df42a20b91ba8da822951014bda239c58d4e16a4e7d046c7082e741a1510b98c376c596d71227b03550f4cc767bf3c414bc2219c7e2a1cf049bd21cab406de78576d9be0c7aa08b2c24dbc34c752a6466671dd05bb9d0ee2a35b3d5b5828f3e0ce7b48de3f4021657c997e98db2004a823b5e7f98e5fa7d010d6422a023d7850f982512a0248837c6eff2322fb7b77b6862b712b3d094eb835559d72a14689b014ad943bcd3d978942bd1c5059ead3f763339184e10a9303b6b117e2de1eb3003d7064ebabfe52136cb6c999065ecee0380588c7743c848580967695f6c8e67a51a1286565e2a01fb69b104d74be196c30e4270505ef4491e8c8d0103116093c84414cd8697484bb6357465350c180a4eefc6a8399ef384bb39ab2e52f8ac410f13741d8c52f0d467a5462e4852c208ec49f65635abc2251f3a9d7975774e076aaf7971790b78aa394f1587b377075ef14d6ef3acd7c03a7b805f3151bb09847b4045c0a2921ce4e448fc1e0dc2c7833bc5cd4b76de9187654f65e78de35e0c3db36a464fff70f295b04c0fa2c4b03f660a5e875f1acafe4333cc07706290abc7fbae88ae1fa8cd454ee1150b6833e437fc7cf59c28dcf99d07123860aebf1e36f1d25f5c7f4dc3fc578f615dc25340ec59fc27b0c0a5d2b229a3bc7446e313534d9156ccf28a2dd7366ce439da125c124aa8cce12f62f49b57b190c0efedee7d9f49ec8f91013f863474e2df0cd8782d978db791f84b9027bc804916bea310002f7ec933a7f00d10af21d1176aef1a78249ff41ca4603b67ded5bb46ecb6c3e084b465e733cba989d90a92c839bedf72b51108d7bba586494b95c5d41906474ca12e87a9f88e102f0ec7d9ccb23027534bd71218b224a5fa1f21b21679bbaae9094339aa79ca68e9ce5e4cfe626d7cc98484f35db7ba5bc1409044b5e3f6888dce2e8709efd2283327ea95f037c4cfb2082e526e713fb8ebda8417eeab48e9d8c78fbfe74e0bc08129ddc3895533a2926798009eb2f19c884e2256983882467d876d1f6ac0bbf5027e24ef0dacc9967895c09a803e858799a4ad6e5a458b7cc3f73d68527f36ef3f2659d96c945ab4137241ae4280559092d502d739c30917b3263e7321b53bc2e15fe5fa9065ddc2b81d2bc11822fff8ff012c384fdbef667b7a3e8aa276126810f2237fa9a7b1c96c32b20937963729eb527ea326982b5017234ce330a12ebd1c93d05fc06decd5abc694d046e0a517950fe005ef86dc66238610be6716b67e54d9f427c845c9965a3146553794fc236b2b050d7aecc440a00c3d46c8a5149dbd902256a1b4b8073bf68521e6bc186c392b6864311d21bbbd72684415e21f0428891655e96eeae276a1958c8fa7ee031e2bba2d75ab525ae2d3100a20741823747d892c46835803c1dd38ef419474d9d0573d303239b10fd6c104891cb98554459d2ba41382241d86db4049638b1e9eef17edc3332e9038f51b15123f95134c575d2ac7e8921a48d38f7e5a9ad6d25c0793498c25347c80cc92f6de08be9c5092506dbc9a1c9a1e1646cbf7d21f9bba110741ecf26d9ede1aba247b7fb02fb8e80f773c6af5dd4807de848e57fa0fef3595cdf71010152e67c0b4988a28d431faf8a0ba01dd423e3e3d1030f29643fe17bb72f29a1dd80324a5f92ae414d907655e1d97f688b0140738afa5d1ea610b5a8d7348a508cfaeaf2bb8924e462b6516cf15a5f882b1df813803c4cbc0f1b821ff974364e3e312ee21c2a6d3fd0854d8e2e086979292a2dbf43d3ae08a016cfc384680f66cb64c97e8fef67917d2d3e34228ee539f47ce0595825361a264187504b2920c1182013784d06d418b89dafc1469d6f4fab5d8386e940ef11e46fe685cce87337929155f15006687de0d1b1bfd9f9487c4e77d623bbcb9c96da745ffe477dd362e7f6bbb7f37690c388529cab9ccbc577ef96cd0d32ec9981730cf47b2753fcc26407e27aa5b32a229ca3613c02806859097b75cc96c46655fbfa208aa902232821c2402e780cf933608b98f0f3c52f79b15ec196283f481d006bd43fce075e5618be101a717c810b2e073914c711549fe22c39bcf25f1d0b4c636ef92c2fc97651011b59f99c6a05157c7f7aab0fa1645cba9e7395dff61e13e6552bfbb2ef415f46d5ae71f0f7cfe65f3c5b39b5d34db04c5f166702b2fdce5f04c487ed3028accbf3da510c05cf104bcf5633ab4a44ea32df7814acbd72fefaa3f1da9fff62974d833c0b732ba563634168a75cbabd4b4785c762393ca75efeff7bf5150478509df5f8709fd330df110ca2198b5e4ce92fc5c613e4d41c21e79029de18c01ba130972557153d76b21c04b50d6e1a013158f5c47e8a1c77b0aa5ed18ecedc4a523a5d6b0aee7ea0a75572a0b54ad2cf96489577c86edf4e906b1913dea529cd7e9dda1310019c6dc51b4641a038ffd7924b80b9af6a12dc7f8ab09770612152004efca8a65395dd248c96aa4845452b884ae48ac74d7eca51b40e9bbca282e14a265938706d6b101dd7f5337d4b725c61e1a79e46a29303b78d512adfefeb0b1e7540df32f7e513b51def3dc7ce29176722ebd991ab5acf9d7617403c6985cef3601ee5496c7582ae4ec98593a5b746586fde02aac4a2065be599adbe20edb135e9d8ab13ac00add4fa50eb592d5630bfc4c2d325598bb97ee38956233d1eda5602601bdeeaaa8d2904764322021c3a64a144cdc2e8b76ca3b9825144e9ef8a5b9cb2ad281db08caad09dc51d19670b975128d5832d4a44ecab2dd4e392396eadfd322f9479c637e4fc10b55b2afc66e6de7ea30ddfb56bfed8d3e05e0a4d2751f49310c4419262269bc9a2ebf4f8bba0bb94d452fc60a2ed6bb0e578e4916ebbe0ff95ce265a115d4be44b6bf650b5a4eb94fa77341969b3c0ebcb07bb0c7821bc0709a93b4f2478454b741087a35cd07a13a685675ccc2eabc25d8ad3c7f5af234e7241f623b133afa9489f8453227b0a7a259d43721100714d2857f9615cb846ba363ef789bdee76bd438c40c7fea960a8bd55513033348699b7961cad63f6f42d66cc431e660e48bfc1adf43aa0dccd01e4b1ef20decfb4d5cd47021fdceea9e16328a0de9e33187ba04011bf12683b2ff85e8602730da0eeb96e5e1f2ce64112bcf9258ca1ec60093077f690daf1f0b4e95233a4d87c092d8bb758a856be895afdedce82e5148085f7e1aa71e279b8609cc1f89c8f2dfe7201868e754b57eca92a074b05ec878cd5db88ef975ce4906255b3199ffd16caf0fdd4c9cab70ae3872cd807b8bf4a364babb7acd6a989c89eeec35172fc47e398a85490a272b8feb983e69ba725f66a4d10556db21599d82805f6b186bec99ae06d8c068dcca64cd4d34b339b5e9076ab1a4fbd8d93d0a378cece535fb0b6fa581f66561d14b99b374f18c63063e1e7b7d1bb02ce395772621fda74625592a1509bfb7476f1089809039b7c2a26c2d64c320a5252f91e4414ba9061109f2860c2df52966398af4e4c210b6b269869702a909a19ba3482e066d50f8860673122de6304c1e9f974482078faffbbd3a24d040a2498cde2b5b943e20e430a95b7f307517543042edd7efaf93c99abbf5337fa85bcb7c53361c8bcf45bd1df499767c06e6b73ca5a7d4e06d6ccd0628eb48813e87d6a4cf519c1022b4dc4c5bb33bd6f5ca7d45509dffd2e6e76fcc88325810881ff9d11147fbc6a2a1b97fcfb9b5426003eae371b2992d95c0190ebc3bd6ef09e792f93e061a6ea994b32d401febadd90de2a5a6af4658c78c6298fb31bdcce8148b972d98b7cf0d3731e6d91f840062b4afac78bfb64b56e65b2de22231bbb313dfa49704fbf7cb077598514e25e43409fbc3b4e65db3b0c0ce5b835402e66bb09dd55a86ea57be1e582366d67ea58d365943c4cca29101ce70af911d6cc3cc204eb2fbcd07079a098c6fb99d632db6ed099b602002ae7000c4231c70832c87bf8b916facb0016104069e0297a228e4f24b1ffc9e37e8e604403ce491e4469cd0592bce9a5fcd2c1a960d2a96176952e6e6c7c53c950e2cc3efe17f4f8c0215f7f4c9d81c615e7c112cf37234325a9c6a041abee4f2e1483525ed7ec6f864c25985ac92e2b098f6ae42ee429a451305383627096bcf95018cb22cd9a1140ec78319de29c8b5211874042a1a2b6b2005f714d3c5688ad364ebf96c59216c32d325bd66b4149e8acf9817483c9f7264dee0ee6c17252fab5f1afb4e41f5d513ba4cd18c818c557174f6142668932111ae8886235d28355e8ffca886470becade505fa99472c03cdb64e9c76d20e2fcf77d002c69b653060cc13920b703afa67b36190193abfae2edea2b75ba65a8a94f147cb10c388915d2e620c813591476b40526bb0487d18e28d882d588be8c1b6c01b8c92b4423a80279b31e14408086d27f1795adaaee62273c4a2c09674948107482445230d40c2d51200613e4a7801e2d09158503d1c63e1913580a22056a8523239fd8b5eb7ad4d6688b65dd946c63c5e0343e9e207b744fe28390bebe69ab19bce1671db644f5c4d706294bfcf23b1045c0dae24a1b548f832d704c1171d668e046a29055765f64cd122c83349280207f713ec6d7e3362320df75136a5305a49103ba72b27f5820cc524a0783fcc92540a636b56512542300ffde127ca48755ca33eaeb4a3fcad21b18b0a6c2379d0b877c96e7020070fc623abe006cc2c593f76252b6698f12d8255385b3bfd9974e5664117d49c8de9b6cb9a59429c914a5072608a0075147ff084d17cc60fd434a95744317dfa1ba4da541305656914d0db60632d8fed8b42a74adb921786955adb4caab6ed3afb7386cf5c686d996964d76f5943d656b3626b253d844a20f1a8cb25bf64b6db5fa6d255772255752ca8f88a505d7552ec431eea87bee91b6ef65b41db17e7ba46e7941a26cc8532ecf3661d3d8909f7eeb51b2e1dfe84d0d4697c2cac299764c0505b9504389c5a729a62b2f08cce0cb7f8a89415f6a3042b9fd852745cd08fb5d7563172737642a9f6bacff1642080db28ff94db5213e710038c4184fa85f0485a4bb7aeaf54fda0c6020d611c6ebd3f3b95556bd12b3f14fe85437723e47b1bbbbbbbbd65a8f1c8b952ae254413535e54d0daa9973e7fa57ab34cd397343ae9a33e6c63f8a4b110a0b8ff598d8138cd8eb62c0b08e68e958869283e5862e0575e39c7136cd836f9443e7862e0525e78d508cc5f735cdc3d930778cd1ca78dd3b07c1e7cf8f0760c6cacfe353f3a8f5b6b1215715b1d61381244b57d8ec271b3b35c8c15b8a032d754d70f76fd67529068acfba633da64de9857c879f7a46664f0492d0a9725d2a2e71749a6efca3168a11ca56e5912d2dc50bf0e0cebe6106ee3c2a21def9448e14462b979fbb1d57b08f69d085441063fc1a638c532ed56044622b2c53c9e8a166fcb1f62012740130c813b99c6c1524a61b72951179b9cf6c56242bc29572d42ff71e0d36acd9d31d2bb0f46764ee699023a458f71d21c5584158314887f41212e359ffa21f9f6ebf75de11ffa3d677cff25e42fc488c7b7aa4f5befa55fcd949a0e76dacdcd3a220dd778414eb7ea394fb20acef28c6aac32207e97edba851358af1acefa8f531e867b46d528f04fc59efe560c31a3bef48f7f6e30a859e6fcdcf0bdfc5747ef835fb59c429cdb49f45fcd2af48ac5f18b38c9f64025a5e52cf97a5df7e475adfbd7722b4be9751f7bd84b0de9f553b8ff5ac2772cab1e91971cecac609e89eebd35823042e223e25d80b7024d4d0831bbff5b343aa1cbd19bdd67b566c5867b6630536fbf8f463adcd7dfb4e57146375a4cbfacc7b01b14fff957df721d2cd4ca81fae3e3ef55e402a53ddd667b1fbb1fafac9ee595ef79af44224ae5ab95c3dd0faa61835b0c165282aae5031755b9f3da07b1a56f6da15458f487f186fd6fd583deb930dfa0784fb2cf3340ef403fceb7b25b02dd66bdd1722c9d80de95fc9d0e76637a3f4b3c9f28a6419fd2c760ff0cb755e9178b9af886f5fe85e96d198d4d967c46fbf5c791ce8d73e1328fd5e3fb2ef05a4be7f28bb1fdc60483fd2be6d3912f4110cc443ce1e0dcaafe39c2cb93010f7fb833d5b4ae9359b93cae539e753c96c3ca8536c910a7318b558f0d6a128050a150af9cd11055888d983f8c523ba5ce9e5f613c1e011285879310822bedcfe1f18944188b90d24defa452706923f2c61bd58a575c569ea7664ea9aaa24314c5a2614eedc6e40ebfa73d26d8fdedefe8d0245d29a52b1796cee98bd6d904e4a4106ca420a6d308f301eea98655946a3dc3e6e7960b0ee7e10e0fa34ccdd12b1be8492a684ceb9a3259973ceb92599f354c164712749994e09d5a6821455ca93357162369973cec9056dd2e4882964d07ab0a658a1e7888642082396cc07ffe75da87ea54049ec3084154ed04045455e6102059dc354032b3141f650dcb007d4144e6ec84f5041526fc258a3a429a19452eaa50a2a6a157652a8e20e8d32e79c93ce4922abd0228a0a3ee78a2e0d0b090834349440872aaeb0e2c9ffbc79f39455b14605695dd6c75a3071bca0f64d1a1c59bd0cf5a6cc0dedcb293e9b72ce3748ace077ce39c12ede68916f787012f98d0d4b2cc8374a5254ddd0be1072e4c869aefad81aaed8a4e887941bebf0c840459fc6a0c76e16f16def039d75d7009f1d9dd545fc4a59f4fa31affc79e52743eeba0fa25e451ded2c078a28a5947215853806350f8dbff0bbfc610ed7c7618ccb40714d0458a8c793c043f139c64e36f3478e1cb24ce33ea7fb941d7cffaa6a610ed787c1ed8ed1234ecd28986fb33a76374f9613d162aea05b30a160cc2c2920e924e0d0691ea2d0c18e17477899410c1776a40e52bc10a5704297b0cc610799e509a5945236db9299a539e79c5bb42496ce6001536689cc218a3c38bab80e021531a490c50b7660708a414561270a298c608edededebc00792363e08a715737ba96ed0410f884c8df3c98b71a3dc6e81ee8910ad12a1f4941fbd51fadbe97907aa4fdeab35d100d29cb8b525b836050a305954be3b21a2d92ee2ae9fa1663e762a0d690b02110b96e8df8ae27567e3abc8ce66fd33b92c27cfa47d9d3ef25847efdfa1dc93efb65e1587741e6571d5614841dd6e06dfe6929a557ab11af3134e2d78b8df1ce90b261e50924ebd95aedd71e840e8df8cdbe703aa5596c31db7caef40b91aee6bd7bfdd4cbe873d461f4fba83639cce46fad785d57fb8d3fb0d9d3cf3edba4c746b0f68528d4a75e18847ff5fcbd7ec4d79efbedbbedbd82dbb7f7fc85aeeab18725dc50fe10d7d5e86fabee39efc8eb47f6abd5e7dacb8c662f1becbc7e5f7df4b28f9da669da735e1d12224529dfdcec7fd0cf68a5af7df54ca0affd466b5d7daf9708fedd1bf5733f02c7942cf15fd2cf7decf50be97f202265b4289b6a98628c5c966dcd5572488332f3a10648a2c776231e1b729c127c931cc75b59997dd7de40a615bc3be7ee3e65dcb05e4966862eab276a758f05451837c6b8c48a4be365f3e07169bcab2ba2e1fa0bba22d7054b66b817bc055dd10516fc8caec88219cf65ee8cf7e98a66f8bc8caec8a70032a264e0b83264bc1d7365442941726524a9f2fc262a05237ccca9f3863560d77d6d73bb28244144252d0d453279b258cde76a3f57d3c0b8e26a618401834c0e28305c30c01765044085c31ad7816ef8737de8ba7781e7ba175dae7fd142175baeef7822e9e9d28832521084d405cf972f7440a2a44649621142c4192584b83367694af6f0f1adab8b2b61b8cda52fe9db00ac10b9aa252e7d59b9b8e1d26f592323ae9ca9a109942e26903c68b182e32ba59492c55dea83c10d6ba4d962882a2855415cfaac05144f292d028719435c5ca5d1428d16488ae48f1a353c74c31a2b9872a91aa815dc61228b2f97feaa2ba23f7628163c0061a1e6d2d7ba22ea0202aa8b3ca410183c58e0e1e14a2d5f5ab42b9a63ae78e2ca9f49288f2b942e6582cea5575cb9d44529a55d0d3b6899e109a8289cc81d82684329a551892b5fca6a0410ad035cd9a4c7d2a89366050bc2dc71d59942698618a70bead059c167aaca823a5eac20038cd30c3b4e96629471f2b1d342cf1a19766e7062a798a69a62d82c515a524f3d45b0c022f364c57462a85a76d840e1ca24b1ecc459dac254e9ecdc5995e1ec78a18599daa044a960a856539c645254da0d4fe8d454f58185d9942121472853459960c14798da32a558a14700c324a1acc013471853e577902cb198a5762d599f79394a69e986f63fa62a9d3063c4065466c2c0943063260c336f02800233564099c90206eec1ff018518d3303ec3e6cd0842d0f17721fb50679e38d9accbfab8a82e33c1b441155b5f0077b03d337050c6763ec048605746dc60b2aea81e2c8dcb5067daa839a3050726b0f632141a261c0461e56528343074b0049a18b8a0a90216292555283478aebc1cc504889a467ec040524af9335e4687c085667cd149c6e7b4f919b9c5c9bfa393537b216850dadb5e062cd8beaf7e19fff28ff148b157ff8c7ff97794c5fd339a71e413a570623346082f8208f326d6de14368c4edcd5b2854bf3882f1166bc8c1732e37bcd8f21e435bf2016bccf736c8637c5f09a5ef367fc8bbecf7c19ffa2f463cc789fef288606868d5ba2d30caf4e4f460c3b592d5bc442710aa7f0001cc56418cd16da5aadebbb19a760a16efa81857aca9d78a8e7ed6f5fc86fb80d0b0d198e3ac00da35310cc73f226060aa3d395641836e5423e45471b100d19eb4d55ea80815efdc2a7e14dd2c730907ce9f235505ae2d132a9f565c78ac54ce632475d3e40fd3008e65da6c15a7da21030900bc52c0c237ac3fa421d6d40344f66fb42171f400b0a75c0408f7e215755d9f8452c0cd4ffa6898d71a83450a2ba336b20e221edca0fe10703a434c240f2a50c6a50d24062c3a0fb2fc45588104519a5121a141465f5a15f0d5783f25d4f49e23031c5263c24b770b95a8c04312221c85410128884800d150fc9205808749893161ee2d897332e3251472465494957f8d2cf3e99cd7eea713569529b94b4c4431dbf081ceefcfe0a033592fe72fb6392152b6e686fff2775a1a2a27092ee002e434901c3dd5afc2359eeeeeeee524af9bc926337aebb197d38fd6ea8a8a44b68b0692029212669a064e9ef7822e9f6c73b3db8ef8f639a47f7fd318a7d90109f044025e9c647bafd118a87b4efef383da85a055f6e57cf9eabb56ea1e5cbf52f32d1225abb4da5795471a1d677670083657deb8dcc4b89da87442974f3c85483a51f910f095bff82276c1899989a877c252c12b21ecd636e3884c7c8cee306394f3210fdc85402fd76b99828c779803ffd6a784149f0af3f6bade4b1f2c75c60bb3c86f5bdfc39e641c3fae5d743d362ff06d1e686b1ca8e226c18745b4f36fed956726cebb21cdf1144801e02906c226080201ed22efd1e3c945d4a298d94ee6890067957580b368fb075e9d3a78fa379bc44982fdf68befc5e6e24ffe534c8ebe16058f0fb06a9f7848dcf2d1ef2a74fdfe5424eb15d8bd78fecf267998f23ff1b82af20b1cb135c945f12ebb098041737ecf1ce64c3ef6e23b6b8758d06df07b38e0b6e5cc1b11cfbf0501d29b788237f4c6a9fd78fbeb7430f5caf21bb600561c35aabec8af43512af4767f9137511bffef93050af56b4bfc6cbe95397b3bbb3ec9d66efd9f7aaaf5a332dabd98a66b4468334fb5c0c445d48946905875da8d6af66f139ca961d65ec2867d3bebe84c423d947a4d8ecd7be5f46dad14b483752cc575fbfc8c45ffdfce339992753c97d822596b0239528a5948af912a6c91c33658b3995d426d9145a9d25b78261c527fa7cf4c1ee75d655cd42326c3ef5a6cf902bbbd3b4164d8a1224a14a73ce3971e0acc89aa024c86850a299d214154c4f64c8d8d089939da1d366632e5aa89374450c5f5889f23fadcb5074cad0792242894f09cbb97a5c574baa25852403fbf23753f431bf768add020ff9d7276020f95576fe0555ac43d9f935d34ba766f26abd9db8a71c2669d59572cb93ed0fa55383528bbbbbbb3bcd6a56b39a65533a15f13c72cb4c63a58cc997f225a5d3952fe593749a5912175bcfc8ec2ebf38c34b66f6cf04feea00bcd8500ea08b0debe54827ba942edb3f966ea4bb7b411a74b11c638f066316fbf10586e5675d6139cbc62a39dde8aa11b5029b1b81e460f969ac60f9392e2c3f8d26cbcf6961f95759587ece0acbbfb962b0fff1fb698d952fbf23f225443b32ebcbef6524e94bffa691cf77ed031d16654357c631d72ae9e9c95aaa6ecf9e3cd2aae8c3bf6ea25df050fc3a06a9c36dd9e4591303655318d6df2c75f0ac04d3091bcaa62a4a45a9eacd92a20fff4ec2427d03c3fc5b0505ddb8a18106afd70d69950c1937a455d90978c83f1b32a7e8237e5d259eccb2afc618a43583e5a0fb65d7bf12c2c84005eb3f4370ffa0c12f96a5571692672453ca9c65f2e7c7ccccccb17f91735e13e6471dfe8573ce497d4e77671f43bf3f32f3836c57aeeceb17cea79ff48d29fff44c4aeab37e6c3e98b579d0d9834ab13dc3fa4dfef931d07c39db063bb3e7ccb3f7ccdd9d4ee7a4b75fa553122e9862fde51070052a3fd9a046e99c93524a69651b73596599ad2bfbfa8594d2f7d64aa394e9277f8d95ae7243db1c1c1b3fb4769b2fa5d632217b7bf9f20db3eff5c35efa56725b99e1b2496da756b3596687317fdfd1b9fb0423d90581afc6401c65fdd8ddac3e0b8a3f4ebf6d153ffa8842d661433e30069b7d17f13c79eefc000085ed9e7b18a5dfd4697baf9e3b23f1fec8600525a8103e2019aca084822bb39a7943828e6ef6e4759ed39698c47dafd5b31e2976f45a716fd4fd5196d567c4fd113bac23f24ceb07540e04095a7536a66672c505b9da576ff34222770baa755bfde6199137669ccc3167556b500fb0d6ef2a653a72b7a05b3b22dfbc217eb72d7ba2ae73ca5b2f145d8146e1c6f899c07a9e3c4c3d3f645580e3b2428aa156d13452cb45a105153e3b1df87abe0adc215fec351b27a06a14a87d6b833de4a7860fb6bdea853528e0dae28324c5dee1c6d42b77a2a0246c2a777efce2d2276a10dc3afdab3744bbd37f2efd420adc213f57360f198ba2b4dca960cbe001f0fc2e1a6c28a5dc7e0078ff1978367078ee0ee53ad3f5a5eb9ffca8e5d29f1edc3bd32bc2527e7d27a7ef1efd1e4abf5b2cfa1db73dffdd322e7695b6d25418a8df29d392cfa5c914e91a4ad5604f6c2a3ce4b7eb58b9dc2da0bbf30e03f5bf1abae6f627e08654eaf6bf7ec40fe79ddb318e8cef5a2d8871e89ae843aa79b00b517bc5e9125df2f61933aef4e61b0094b131261719a582944be372940a4e57724f13cac6383ca4cddbf3126183e7e085800febe46f4a80beefe037f080707836dec3f130cffb0e827cde14d1ffcf87fce4c6c67fff46dfff3ced5efe7d363ea39feffb8838ac8170bcc77770bcf737bc0e1ec8037a22df9aa311c777248b3f8ef77e03ef7bd0bbf1409e8defc0fbe7c0037a98d7c17bde919f07df3da39fcf3e0eef083b6c83204a6c7c47b218d978d81fa9ff1db1f1c19ea877b8c1f13fdfbfc38d8dff0fedcbdfc8c6e378a3ff9fcfba977f22e0781b6f64e38d7ebeff1d58d8ef6f3c070ffbf083e6f7e1f81b9ff73bb0b040dfc16ff0e0051f4409d077f03fde911bfff33872bc87c3fb1c38be1b379e633f39fe7ba31bfff3396e7c471e8eef891c47920601781168e0e1d0e003f044fd9a36bca58ed9f8f794304140ccc62f75ec7f7a416cbcf446e0988d774f88c7fe6f784772fc8d07f28eb218e9f80ebe23254c121003faa518ebe0757c2fff7f8e1d2dc518d0bfdc3b92c528c7f7f2cff11cbbf1475efebd44d0f138de28c7df781ddf5116a3ff1cdf5107ff7f04f4369e63389ec8813c8ebd67c36387edc0638b7018d703485787d7081cc3f147fc1413c18d17018ee7588c85910948098eefc637af743061de5cf22607de065e00bc977c8efd7cf18af7925facf27dec30cfe398e6c5022eaf25468cbf315c3786651692317e2e7dffe4c243f6dbc7e743ebf3af2f74f97cf8e0f599532e7480eaae9fe2823a6e28a76e5be0c509b91bd2a513a40c2fdc71c3b914ce23b8c1cc7e1e3050f6d26b58f63b82b2677d2178b3ef6453b67d2bd9247d4269b02753f6cd2522ac9cefcde33d8e6d36bc23b6a28a229262287448a05012cb223f86b2c98697c1bf07802506eaa5a8a464632ff150d75ab2f1ff05a87e8a4f36bc230e63878ba6180a1d12306462598808804ad27d01f1f94929cdc3bf5794ba52f70ca5734d1c7fd31fa9629517e3c8407a75065a9c4e4ae716d65e8e6a52e786d6095ba700f3d849b54113343770b074095818bb41c1e21811c3096ec860b5cb514d7668e2060ea6d8ec7254132a514d5450a1d1ac71185882a8264b3026b65e8e6a920456452d2dddb0c5883d3fa0952c00781d830e9391d3b48ca39ccb67b2b495c7ae39f8f3355c96ebef18db0220ba6ece07ce4fad2e17e8deeede2e996bdb6e29a59452cae972d5eadeeedeedeeee1e4677daddddddddddddddddddddcc1e6b5633dbdd168c891cbf7ee2cb96d3a7f469a5f4e8eeee3eddbdcacccd63dbb81827c7e1abde9e3be7b43d5c10e7838dcfb1e9996105671f9d9eb4eecc2d2959b29bdc26b4d2404f4ae9eeeeb23a33334797524aca75c58172cb28375db2b816e703c7c6f7766666890597c5c697cccc2c8362581968dce5486d4a275a9b34b35c6b955a46679eace59e676a92524a3549bfd612cb0d4a2d8fbb9c4efb0b7c95ae71ee56f6d0430f31e41472dce568529335a3938ed46a46670f313030e2c96378d0608f1e2c7b7a68cca0b2517a936696de217aa259cbcdb362b78a110c8a42b109cf2acb326e3e07a475b32b5b4a6c7ca2bea2803b1bb7e23a6d55a90780411804ae7b0ccee7ba1ff2d20910b9b856d6b2140ef89e8bc613cfa6553775537f37b5f74c4bd497c8870ab7327cba46833e3e5dd17c9f0e8478b7ef91351109e103063491e8e3b2eb2a8081180f118765868c18b56948d597b2baaafd2a41f974b716c72f906881a10446125c1e2a3d75f2741191b461a590c38c242e2851a25e71dac2c275289f0f5d6acc8d5467dec42dc6a51b5f32c9a6282638dc5056915602bf3557b533ae1aff036a727eae5ae7ac9e03f31712b9fcee69316ace9e11d97dabf5acdf9cc7cf5baf46c36495a42b5c4cda925445ca690b978e49639a4774aae1b6969854030f456b5f0cd419e5be90b3cd43d3be6d83fe5af36885ace7063b20ddb79e763f58dffac2ee877faf1fff99c07d7d13581ff7b1731edfcd0bebbdb776f6e372fd5416c45663cb6f296b6b5ab665f57385f2fac88fb7b0fd527619374565839d7d3472552e06a795317e1f2748ea10db25730d1777f4b136f2701e91fb6958fbc795a53733478dc50c245faae988d4d1842de4fa823556b0ab973cf4bacc1139ac351937cdbb526a14b8f5d3a17b2217b2600e192f49b1fe10788abb27c81bdaebc3403e633608d1076d14f2164720982fe70bf22708f65a2f7b0c9ad81882526280c5ceefad2b821297ec09f2b6d2f471811c59f6072d4eb23069c70d665d7da275355ab027c8195d51f3990f78a559502de058210a777b9f79675cfeee4090cf711fe76d2bad66744abf1bc771ab8de32c6bd3a17ba1eeb3b55ad75f30eb16602f064d408860ac50b9fe12c808ee7c39878c97a41b9f8ee04a2963dd04bf61816a4900b458d762fde517065961c0c4fafbac33ae3ee7e0baea75f66f48d06dd939a0748d6ec6bba29ef7aec8468dfb0171ece8211bbcdb13750cbff5930de82be3eb0848323821c1020625b2a071136386ad7ef3647c2b2f94778be1c5cd0b8feecb7ecfc70ddacf6708775b9f0d3595c16deb3ce95b08384f3e6fab2f3cbad525b38e63441a6563fa723e9dd3887b992165432458fce49c1f90ee8847bb62e3e253c5f6f21b48bf34322f064454adc72552c788878a14173684b1248822b0a041bac10b2a52f0c49aa617a03883a51ef1a5890b4b5bd4489971e20e9427636a70a18a34f38212197c50228a175e52e044132c984c0933450a253985a5bb301126490e5cac5461d102945c420e1a178620c10ada784953c606364ddacc3047094c1d32588a50f183152956cc14d1650c92152469b2f06108252b5188711c783042c30209dc2041c39a3261d88b28787e386229890c45c43c0a9326f06899414e5211601070c50a2a2559e84c8142aa480f767218020571b248e14b12121f78c0f24445c78d12333411461b20f0a8417243145216195878d374c4164c501af00186285190c0f3660a05484c48be809344c40b4c5978d12189282827a0a0c9d243122e28beb800c60b4b9078e1e9d5449326a29ea2c890844422ce1b26a0f2cc80e4c9982e3d749b33499871a24c0a787e807204961f5334c8f004551518d0482e0ee7688a9492921b92ec70c5882fb248c1c1ce114f9c48228bb02c3081a50c1e20bcd040440d5257527053039425e4c82db379b0001c12acd0c59c1380791a824a082849ba8c31c2890c42fccc2084933a2e8019834706b1c110456c21e70b0c4b3c915a6201e29c3b1828488cfd183dba7497d2047fcbf9b894f2db06e0c532736c61e39fed7fdbd1e08423e55a96a282caf5e8cd0a8faef605c99ecfb4af861b1b1a91d7ff33af2bb259966599b31cab7d4fd8ec897ca57d6683953fe78330f61101d6317b0cdd98414d82c3e6134008cb178479ab77b780ecb320acfab357f6b5c197f6f433ff97f63103655fa5fac2cc5282534018b22ccb3249b92b9f5969a35936e79c349392f9d9a564965688bc0cfb6ab55a497777e9e2ea5dc732b3e5724193f53959f21429a59430068a43eee04f8d70ce39259d35f32624b394cccc524a29a5945232b313ac2ab6c15d00fed81579db62a27f5a16fb63fdceb2efe88f8ef891621c97fa6d2cfb5ef30ba284484c7298fc1c6e2cc7b4cf92e52542f6ab37ca7e95511965af7d47447e81a7ec439ee25864a21aeadb58babeb1bde56ba706e57b66ac7f3f295929656520fe4660398a853b37690496a35a48ba1a0f55285151b4cc1fb0a85158f82259e79c73ce6f86a72c2988422a4e9dd804e2ce29ef9c73ce282876aeac320aedb3d5afe25ca0bbbb2b9a9991797d6a9a94ac56967d8b2f708d4c6f0f071b5dabff5c1f1176f55eb4aa736a9aa6d1baad3c49572bc642c677df3801514c4e709e3ace5add7cf7b1ddd9fc699817ff6a6dfe8b962459b65e45f5301c193b4607a37750501838e4f72ef97e411359d34829074d3a77528e41ae17eefc1a3be6fc1a656c92940bc5e8c7675895b65d9f552297d218437214644727e8e4b084ba5952479ea15382254f986e08e2887af2e4facf1326782403eaeac78316cab6678ea8041ea25f2debf983feae42ba27ee7cae85826a341577c670fd2368d3f0100b2399f0e1fa00b4a13b9fd9cb9d5db24b3f01309003a8940278c0f5e79e3ba9f3263b20ad1f0a6c2baa553a23730deb276aae824be0a1eab12bd2ec4ac4bc91835d71e1c1f6e02786e2a9356ce2dc59410855f47294933437fca02dcc45d5103e709102869730f2045b7871030c29b0810c1236fc8025c825c50a2edc2c718309a27832473acd3373a20cf15b94133237e427285e739dd9506597a39c28f1840b0c6a2995a9e4b201e76e6c86c0c00e65bab860064e17282658f26632b1444e0d486aa05343d2172820020b1f9e9023656e804a933356a058b303179985c9d28a09262d38993f9f6813a529b436dbea7294132e576cccee85ae382465fff42bd2baac8fb54feca65d8e7202844cc1c7449b945ad5b41ab34863f4e862ea8dee4aaec7a406659426868ac2f247270957be7b174cb1fc52724bf68e6eb60c54b0fc910121307f80d4b1973cc39841068a3f35a4e5cf66d44bb03def60201b622cf3d768707a4b2943ee5a8e6777fc9658304ba794ba9c9e0e4456b2c75ab2f27988cf8df23959e98c69985d0ce4534379e7bd7bd8f8e7b3cc595096654fc199516a5d73d6ca94259d328b9369fc9a3d675ea0eda8044e974435e9d0d4000000404000e314000020100a07042281301c1ed2e55dee14000d7992466e5c9ccc635190c32808216388210410000801060898a9a1210e00686d76025bc4ea29c66fddb6a2625ef32650a17d51929d62e56f757534b5b9e7b69a46ae0504606dd7041902b0ed88c9166c7edae2f917205454e88abc5ac38df461653ceac3153de72f6d48708df4bdc8f5494b6e6f0e589b8d05e1a32f599c0eb4703af805f5e7ba19063c3213553b890b1e3413f8104878e29d927f86f3302866c12b308e9971a5f0e562c1f5372fe18aaf8e2e40d0dbf772add0bb868d736f6fa555237dfae0d3b0d09a62de1bf91eb8496d23c5ea087cc370f1123ee8c4dd3f680660bf4b8ff0ee53012625341a6c7d3a262ef00e23d8b42b83ae8125ec0359d869361d26e8998536ce15c471e4ef808d8917825f6f8af2787bd0dea78a4cc528c7fa1ccb668f297dba1a2587c1d45e900e0e1a3020ba5062eee10cb5761b9ebed3d6a6d0672b8cf10a10ad077cb63340cf968c0f51a2c04565806f62d25b8e8db508a6099e4a810b9d053c74d86a66cec8875fddde71ff2ec76a5123d2803790b430886eec3d83b57e1dd3db0386ad98029a74eef4ad1fd92abbf0e77a4fb6aa8ac22bc1126c21b4315717640458ab3492e4d0679644ed8d371a52efccc24715b1d5a908ab0ba4bd7c94ae6032833ea11ccf7efa2c004ba4fe30ee2a1138e6c6868bb86721ae3d088a38a0e8c49e63b24a275a614fa83877dba3a46d7bc2abe565ac528244b10bee5e192a90248b978777b897ca8af3bc37313b80edf8696418bf91832ddad7aa5055822c6eacdf814f3f9f9f701fc49ee5b94b70642832cb9b883f994f2a0050fd767cb1d6a7618dd35b7f49a74726bc5303fdda29631a435b091c33f32810c0cdf439f1d1c71e520e206f798ef2713ae4502fd133463345999c6d44b54c9753a4b943d2c1c56e8cd6e248e01d70bb887a2bb224da2517a133f668b32dddd59f4438ffe030bc036072a3eba9ab97fe5a621d31ff371be3ff8f3cda7b6446c797ae9ff1a3c0dd77c0202b91eb36f6048e8b42033d1e9ec14d211a7d430a44e1c9956731f50156ea6d7b70d1140bd850de7c9e4e5409e4519fcfad5aa90cf606e1bd68e2c8f49a2db2e94a3cd7ed0a1e52790bca95181efaab69a04bc593b91ce64548bd3343ebb108e882c57cf4be98d06fcdce6aba45422417e8d4c8a8cd9fd09dc95ac0e273bbf35c6a92830b3daf1e96bd7448a6a9691c5377bf6d35ab30331450c9926b19468c9792ef4b554f52349020eb109f6ea8c8540457cf80334706f511ab5419a891c01b27f28bac0e8878f851d49142885f64ffbe325bffc7080865f3c8d1ae5391de18526bce8b43d3422a994182d73656537c21ed39cf4a578c435568bd8dcd4d1d0d4b8aa0c8cab19efc2c352b5157125c28f771c5eb7b36f7ac89eb8ae6fd25f3b9b8feb4ce8c9861a7ca6a4a6121de7eb91ffc4aceb45df6e58e185c55316ff4898059a018caed30ba1dff6e5e5d2bc7489a09d323a2cee41a363990e621e5ae9236bf1e9d04c747c1cf713ba3a6c59d23ccee2e929b1fcefdb7445e8f12382c344a3bc2bb8fd904dc6bf3d66c6924d4c746884e0300298393c069081b51d59ed0efa673ae13ac788742757d91846fffe312d22b0b064a9269be70c4f592c0c6c0de52d8ced45ef73c43a5beb5b2ea119b026b36a1effb37f5a12692677ca2c5541421b230b03791102770890cdc7c70a662f1e82aaadd35591c2b36d7013a371e49e4de7d03423f2dae50a3b90e9179cef4ccac2c355af7b1e8bda115ff7f73a32137f52a4f59eb8c6910e1a1193ef2084d82c9d356319c934e1fdc96888d0be44f164cb03cc48e12cf2cb060b0a25a9e54b91e06353967ab779355891c3dc4d5630fd838d8540f72d9e2e0a637784e68821893b91e26c441476473e3c5608e067d75ecc04043e73b800a7dec75044d97c73f0e933ce1b83430b4a851104e11e1a6b2069e4a1c1a262103ca332bca7b0e252e9c66c4dfdf2ae04954229363bea1f88c183b70ecc34a2b2302d3ba0bb9a111c06ec5a2dca278802217fb0855a3ec8070b1176240771efdec29d0b4880d4371392a170cdf200faa9804599f96c90c7dc90260072255633517ff0fb5095a771c7c1dc51dc867956f830a24485d39f37050231e5fcb01e0449c1a2c49b1e4c41481a94a700c177649de02bde910e27fa12161399dfc84bcac462f9142f5b20ac5b29a50cfa442a04ba756843f75e50becbe095baebe4b075a1e2dedb473f07352a268f32e322013f4ac1caec9e9796843fbf014747798d3180c661dd459b583abc0c72ffa2403f583034288187c83ee4262581cfb45a1e6eff1c18333dc76a1b123518cfc9219879c90dc6413baf3b142cd965ecc06d11508dbb941cdb956c18dc67141a85ae572d5e9e7e78289497fb28733aa74b38115f72453178729f537c645adc677481290f448b568a5e7734bc7e30ed2fdb19473908e08ef89f0e4f7324e7f1c9dbb86166edac1bf0225e2ce3801a1ff61ed21c025793a38f267ec88b38328e908ff60cdcb51542c8d424ef440efdbd7eab13d3dd9c8ee930882250051dc5fdeeb70b2ac9eb2ef950bd21cbd697f544aa562c5bdc5e1dba3a89c20da006ab3577c6090257b5ab837564a2eb0faf6063c6d3c8dc238054fabd9e346ee26029deb5232d786cbcb997eb9f237288aab003a534f990912bad043603937329654630adb6c17aa52727e42b9e776e716128f077f3333990953b6d51d344adff581943dceb93a3455d0b577294bc41bec01d431489a681f505c165eef26738811023a4f2a564dd7112fdff8d491e168d15e8f3501af80b5d1e19542ba325cbacb755d2b8af9717eca17680e11b6e5bbbc04bd11a8ab82dda34442adbcf5f4268d1d0adccebda03c2d016e87eb329efce80ba8b5c80addcc018a646550acf33944ce4a8c0a3a99038ccccaa050f73980bb598976e5920d47792da8ba2a7cd5e94a0c0a583de184e8f67ebe25b5d8c4c9c1daa61cc4dd4a2529296f5dcf99226e21b98ab904fe9253dc4fe610150284f374145d57f6d9334f104b7a92c2783915f6d230b1f5a9a1bed31536ed668cea09d414b6979e37ad5864ea0e712b725889622f2d616fe61611e03ea358e44e46af0981ccf3b25a462220d52f354dedcecd5d3f03a2169f892820944e343bb2c9455ae24665a05401e39b6f7867f7a178a544c27a1c51888c447f7710021309b1bfd87fcac3a9ce0babc7d84fde08063f1a8fec58de1666fe375287476adf88e8d03a83309f524de2674618c0ed83842607ac8ddd1bdc5326ee942db97e00be6c4d95042884d9363ab6d3128274de8e879d587779b72e62bb96127844eaa1f1eabfd65292cdf32cd2ab58d76b040ed1b39d738a4f154fdd0ff34a2dc6a1cc05a078814b075386993addf53cb2284628838aead645c15605ada73443d9b002004d930980570187ca6d7f22dcdac215541e626cb6888e985c4e0487d8e2286a221a3dba8987177bbb57b52163203ce118a1ba0a546844fa000b36aace6391cc654bbc9427b45ab9a484d59b48a9a16ceb9f3a1f81479393486371a2e6703064575dce91a832a90fdd323954a60820eca2fa9b24497b94651915cdc36438809cec30630136b7514f7169a381f181c4f93c2dd854806273e69b96b74da636c1af04d7539f3d9206487aba6d63eb9d8ae9f70d8499cba1750f5d4e032e3b8593eb412a36e382715c64f066c874f6970150148bf9182abd3ad5ae846b1ed687ccda5cd9b96800ab09087052ed6927c1c444a5fbf287ace9521cf27cd561892629188c58425f26258a2ef57351e5cb1955a56500e640e0e2c6df48a5dcd24d071482bef17d1899fd9f5630b3c036568aec8d0f6169bab3b695ee320130083f9f82d6ef2201de83da92fff4a66424813cdb2031f3da18ae33a7dae28d83102a9a3f3ee06c46f1d44f83b7824e2201297183c742391ef22a5b2de7472c4a7d4c6f47b809f68723112eea94036ea46fa763d8dcde494fc82f2e0606f80e583749591a2012c1d5a04f4b26d545a89ef91098c5cc8c3ca2dc80be25d28405725a46c9d1aca405028b1073ef6d2f94ce8a7368451c9490afecad731e617e682989c002f0d1d848f63340ee072ceb5767fb370596f4c182cf6a836d63757370a8320ee74cddd8ad0cc46927e8f9e64fa6c1c4587df416f96d9798aae74089c3ec5f0d5075c18c3763dd516627cfbc9b2e8df870996cc7a99d3e5631b9c90b64589ed12f1cae303f8d52ca09da7c26865a5a6f66fff17bd45245a315f5df46e7aea209535e5e30643bbf9388dd477456aa2a00ad4951520f4d115801f0be5e62670a9ae6fbece34b9f6cf672ee60ee0ead44152a26a3fae43e9f4588daa9010d97c7e7b0bf3c0551b55029443d6c9c00135f0d7830a266522780fa1cb1b79ae7ea0e8b14f0b3592de045824b857558e5cff771bfc9ed31ffa6b159fdee0964a6b7a534b6b0b159793b1d0c9a9c9c24bce3e66eb8cfc4bce036ecec3fa88b40706299a6698f4bcda375b51ad53854a0fa537ef266b37e9f2a718818cb075aa6d7703b5cbd5458bb027c58d54ef05f187c1799177ba2f7ad38c5de65bb4ab96a161f6e46dba55fa8d2908fdecb5a622ec76821400a23fd771735cee9dbae0df327f24846f426b84857d027f7b4ce3b6d9994f29466127cf1f4eb852f1509791d416975cc5576f68b2eb0813cc6cf025f77fca11b365f6688aee19c7e856055fa5202cd01dd05447bd22088f42d0d06e808588bd35394526e023e74e1eaea32b282610c7bf4fa4fde324a374b4cde461b7709ce3560abd8592aee09afd0d3fb4efb25bd9ed5a9e2a1fbf9fdba4bef0af6d5f74db0c0dad119684f9471bb57e5bc0df284472af5bffdb98623d08c45fb29d7b905ec28e353409cd8fbfc3c5e4fede3a8f2af098c073ffe6156539dd7c65fcf1e12c3410a7b69a5a24bb20af60b6c707b49b1d4bbb89c50eaa91c077ebf3c5b5db1ddfeb78d4e993807f1a34f62e6d9a8f2e9a5307703304f2787700504a8f61b467cafe2e9c80e10e9e351242c40da681931aa1736100cb7196ee7802ed58efcdb7dd41c76a54f01c2d94b38880324dd9686a0e087aa8efc647adfb53b21cbe24ea0a625ee140d4762277ba9f4affdadb938622f6a288f3206ed7b1c76ca34e9a1bd000a2dd53a424b96558974dd1eb75991e051dcccbfa83e81a22bc40a3bbd472c7f623d0d60b2bac20c48e9aa52720def41c406505c0cd064784d4ad74339ecb926ae4736ac33d5bb5c0b0bf833f0eb4feed4409b5793b879ac4f9da3938101215fc84739c4a78e81adb26dcd612959e08f19fa68928b55d36a715156f08e084733ce8c686fef5281e8d9f97fd146aa81a5a45aee9a72c426c479f4820db4dfb9a3122447dd75a4c7f69679991247902e80793237fb42853bad956f94c7ae5f2edb4638fd7b510c6b962026e3567eb26543b35f9789aaa5002ae5f311cb1a5798d42ce1f1e9d7a4d77da7705bcced0fb37af384891a470d2a63b2886cafd7d0930148e77e1200c207264232e931cc4935afe50e61bc5f8d38c09d1d85ef1994803de4517fd0601e40dfbf91030bc49e8fb818036d03ea29bd0135d20b90ca8d39077286dc7f90851a79b598cd5d5dc711f95496864ba1418173c3f0eb74a8cc7e130896e7b99b03f705f4ff8b4fdeb26c31f59806cdcc4f09d3084044554d1b052c0691e9ba0c6c1b4bfef820ce8d3f4e81411cf9d89e47575a8247302fde9bd864c628585df5918f07b270d202a938c58d1c4f70591d6887ed0c4b07916c66c71019e86dfd08831d08593892a41db5499d17345dde2f39aacf439213882ae02dbef297dc7fbb94ccda52a80ad4d5ddccf2dc73997545b6c39b1f29a105e5e10cccc06d5ff79954632ac034cc395db74b5271e0f1184209474cb4155c88a8d409082df84124cb5ce45af10656ef70b8cd49a67c5ce923ad14983ac3ab530a710638c66434738e03299f25be424011d4e2dfa94a71b63270f9bc0db460325e402953f1517ab84eb0ab628451eb0a474d4bd8d755298d670e14699611b4ae1454a0485728536c6ee46aae4bdc678e7c2f59e23fed3a6c86f87874045d571135e438fc35bbe4a12504ac96ed4309d64ddc2d021b80eca9b2c676bf9de37164d61ed2ff9ba205fb23d285d59ad5d0632b8e0c45942c17430e20559ffa7d8d69a9a5a46ab4506d0ac0147fb1e53431788e8dbbb44e9df60394c6e47c624a28ed0c1da21f97549357b16d4c998457170f0e82628b4f1733696143322f196f7d3f978825f3a0b14478e1c94de9cd0d961e82478223a705421a3a5d47ed49a0e8a57025e6c765bbd8d2cb193acd09492e6042cde10aaa1b6024e226123908891b69ac0f24205934c1bcac72d011103744640462dac81c4ab7404de9170d629d1edd2a95801a962c4d7934f10c127abcd8c21c91217ecf666a99f4f8b9bc421d4a8832618a7a1b503557f67add8e4edb6f8155d174ae0848c8800d4e411d847ab6b084f4b49daffeb5f9c7af769a887245ea40b55bb2e3be2c643771686fc5f6ca27f4a5af6b7a091f7890d36c0ac8761e8bc047864dd09cc59abf21c638f29ee78088d75de7979b759d3800363d57fd7a01a939974a912d71d2834f8c9ca82b942d0fca5d849fa3e9cf23c12611a355fa22ff3397a44a9e86b1ca6d5281d6a67f4a7bd706a7939c17cfa753910e99b730ea713ae976c5701ecabcf3323d01c0a6fc1e85e60fc82fcd4d9b4779eb4464e9f33914289d3dc5521d1f331025d7f3d1ab5f88c2ee2ec72b274583d01fa3dadbf73d4fcbd3beb3e38fa7b962748761c07d104a4a62ac9fb2442fb691d83ada38153f65164de908146378ac870ed904ab8aa0f6f6608293dea14f68a10288766f70accaaa3d66ad4ec19ff266b4427a240bca7d17b27e74f9bbd272930f9ac40aa9ddf0ad088fe16fc3f41196c10d4563c53991a27453b4aea9d1eeb37d52fe06ac2328e6382daf5c60610638b0032159d5caec79adf47e861cb439d60c8231cf0ea05edc48382dc62a836c49c24b34a285cc5783613501101f630d5b545d679918955cec7aa40cafccf208044306029cbf03bbeb2c9b7dfe2aa3102a9dde11859c45a5daea4f2c6cfc506b9e63319cb90c4c90c58de303071196b7d363f9bc82e6c4c5882bc661b472fce6c836c3cb6952192a3fe74aa3f0e516aa24655c579e052b9b45dc74da903df117e411ce32b2c94cfcfb11249990ba9e4312fd84f8e114ba6c184ac91ea88b692d09c01401802ced0c6b2718d83c95ca4f38fd4f00c08f8b8e30f019c2799df2b953995fd32a314d6ae03395ddbc732c60c7d66f428297e5d802dec21a26d4e9881016d34ab9b28ed0012e3302c10a9902f2d70d0e6b4ff4ff8beaace306931d093f5cad0cd0a1657a5331484e71fda0bf5d5287b0424f25187a7b0514ecdf6699ec5f85147475e4993eadf79ffb8016c9e1ef16362041c063dd373590d14caf8fb191410e62c23bc4b6cb04f3105d4c70858b2a41cfa0128b3c5899822cb79d047b1687834dd053a242d1687d2854f8e9273f8ced39e82d10d9c0d10399ff4d7aaa75d8f08a38c108a80731d31b792108ac21e09396d5dcf1f9606bff035113687fcbc695ba3d19110d3e9fe9307600126e0e0000e166ce053633df90058e0337d882c84ce184cfc8b9b1c6385556258e1de4031c653609f20949136ec5d639b1da4d100bb5c48d4f42b17be11bd3559aa1146c16cd2e160d42354eb84c150c1839708c646b064e06e04d085e3261e23c9fd105ac363000bc60441416a299970701609e3b541b6e5045b107b3619c4f496a725b6112e0cd5c4d6ea1fd55f9585981df823acf7939d974c98097d9608abefff5d29fe1c88519b20c652780b632683313624f1f36ef5575cdf6dab54cf6afa1b1301d5c0f8c0bc2196142b04c115748494c20d2c702d84c80d51c4560d0aa5f7b1bb10deba8833a06540f547582209eb3643c356a914661d811667cf2aef048b29ddb45a09a8eb2e6e12968b9bcf40d8bae67d89df437d41a0d063d912dafd639fb7c393fbb0bbcaf1720c09821c9316f36a36d0f0a663bb546dd98e51dd4ed65cbf240064737662d252742b994fcef1bac11060e9b1c290b8570915c623ffd5506cbf02b1e8671323ee0d7b0764d906442a240c7e6bbc147dde0c391e2147dc9cc9a916006d545daa04109458fd3e39803a85ef6ecb8b98982f7d3cd52cb34b0aafea94c562ce26e04b53006a7ad2f0c1937eb7d065eef0fcad34ff6ae80dce7c0e72cf471d69565fe5eebe158a1e95d8d6160abc4782328e5e9ca8438aaf43843dd70690b44f02e5bc894cecdcf8c4dcaffd72dc6287285aba75e03adccd9ccfea2782c302f64be619a09af731410f72614b85407f9bc9f1ac5728f8a38c8fa30bc1f33bc05476c1d4355e235f9b198760f0174120c32e400ea5a9bae1044194e79f42bc9dc6282d2e8e503f4afff1d222d027d2e80386c9521a4737d9f19d5857926cd8f45f99b84e3d5ac10883664f674bfd5d3bed864f302e2e503f3b038ae0974c2707c42fef15a8ac56aaef21b2cbcfa5658b2aef3ba27c27df53e9742cefbc741f42f3c644318201bae7540184792af7e95e87f6b27a94631543330ffb8cc2a062a366a7ade77c166490ae2e0206073933d7ec2a9dbf4e15be9e5a5a9ccab5d2c6cccfdc984f89970ed49577a9669247fde50920b31aaea972d25a7849b893cf16a0ef41b7c8977a2aa18e7588bb5242327db9008d12f5a2a593e14616c0a634fe6731741c04ace10c3754acdc06faa11d3a61381fcfdca365e41eaa37f516550589e91fb1fa34a7f591fc42270d1f85d3e69f297d5a76795436ecf6e9a8968ec686b575e703e3ea8fe10164f7bf587dc96c6f50a4a71efc3c9e070b0e98ef6a8c512edc3071ebe8d16fd89781ae45e010cf24eee2958dc61fa5c30699af775235f552f849676978bfbee5c752242596185527380f1cd40e18c5bef5e599aa335ee04d6c77ddaec1fdc1217c5c127374b3b69c139fa19b83c7998edb182dda062e757e5be1a2b6cb6d36b44968cf1dca232a3658fd299216342724067762365cff57e14bc4d6470e5cc75ec7a09fbaa49be4dd76f3f9626dd92b3755a2d11eae9089a8733630ab481a9e3d461943bbf1bcb5dc750292c1b5ec0f6113bfc9baa8d258a6c03bd29536f62691fa4a200ca6e24767e9dd9b1ad5aca15a251c57f7d615d0ebc2a8943d256095a28835d16ad3d6e60f26411beadd4ce208558abdd529f4c7ef29ac36f8e0726e5050ab329d6b041ee84db56cd83b9b95191aeaeb2a3592edf681721d5c45f001295e8a89e9446e78ddbe23f5f15bfbfdf1df1bf63dbeeb431c906279563457126b2a7481c6b7ba0fb4f8d8e30ebeb88e82f2b350d47f1bd243cb4bbe416b786ef6d193922cd16c5548f5b3b2d5acb3245019201f383d3047974cbc8f3160fa7e107f0cd0177ea67a79ffffd0e25e42138a03e0924702976104cca260c79f78c17a53800b2ca0c6603f2841649a411ceb6adabd228ea97622a2c3ad195cf9e8c029d218e3f3731bd741c018807db42b59a44885b40772b0488cfb0f3712803bec5f1afee58f6237aa9904c4abfdd09d24c22889d924754512b6e435b4ec22753ac1fbcbc8692001bbf386268436ba12afc57710584f4420e4dbc04a2716c5adf49a14a1dbe201107b737c88a07b91b0ceabdcdd53676d5104c3203a71eb93ba402e26a8764bb4bf069d957c795c62751614a91dd2003fc8f5b0af86174049e2867867c0ac114f1e40ade705abcdfc8e4e1458719d1e199c2f184527313cb0da23ec01afa53a2006f37ccaa3d50acfd8e8416aa705d49e058b2b82da0d7bcb3e0420c824d8136306e6b0301e501f00987c21c1b9173ab946e931638c9d56a794cc0b3351da7a604ef8d4b9bc3e8c2a1b004cbd60f58f72b0163e43b16a9b00e6eef7b3c3fd2b886ace554ee41ed11e31fb3816d1ab1a07165855057baaf5aa13f38d629f88b5d0901eca002e4d80357814a437357e0468924dae70ac5293bc734790a18c7910041f99a8efd39f673198574bed10744bfbc0ea5471f8c1efffb4556db3fb618d91d041eeb057f1d436456205315eb75469365dcfe1fdc22009c15d8515306c4fa61db008c9ffd70aebe56504c6c38c8414f00ff9a0084ae8f928824609b259beda0bad48d33b408adc1a10a51175919fbcbbe057ce4041c7be2c0bcaf9d772ae05b48523a962cb06070210d94a0b2822f3fb030e21a08226702a2870a9cc637f8c2b26660cb699dec04f55ae4b8814a27825f01dd3e8134d082f07371799664842184afea0442f00927eb038ad4018e760c4f0b746e19d21ef70a8400d8fc89230e151207de4e0c7d5b32fee2f775c3063238dc205b52c208a860d296bbcc2d67d03eab7e588b25f271c87e37a6bea86e05026acee08d694655c62f6c043209a868c632602271383ea3e6952b08c0ce28ec010f2d62ea4de050004451e460cd4c4121cc09caf28ecffb41d74ff0bd3ee48ea25d71748504112df0bc35a1d6e9d9382c069e63c60d88289e837638596f57fa22da3e7ce906fb85202efef24356e0ad964f6b0be5b2452678af4e6fea45d28b4f8e138c77d1f4321ede96b3bd0f21223a1520d7b74b1ac60c4d1cdde05d054e47f8e01d2e44d0e8ce86ae1bcc030af4d554eafca9cb325fb2af676aa3d125db7b4c5571daf742bc7f80be3b8ca1474324332a4db35cbf6ccc7bfef3a1a7c51a38bd02f494230ff4baf7a6693f9aedb5bd1ea6f80d9ce8a17b35f51b079bff1e76291297ac81bd95aa39a708940fd4ec86f2afbb97b4dcb4baecb008dfeabf9ca52f1b4dda758fe388ac68f6589f2b6dad34554db2b74860ec5526bed67b95dbdf3e8ff87a953c324a24efa7870cf3d73025020270207bf7c4be9bc8a09e3130473def0563ea4353304c5d4c3383458a0100fddca114f74e378fa06145f5faec7c772e9fb9c1e78cef7cfff22e844b02ae7457b07691fa49cd106e03b1b42956ffb91929e3d0f00f2e2dd6ed5db63974e18ae3cd459d9268d4e20bc9edfa95124920783bb1d06c5d35c8191e6d455ff0a3a90d309c7c25c9af449d5ba745fa10609621a9817393973bf4b4ea75958faa39eb0715c35a2a3de6d6976a82a841ef45afdc1f24b06a6003e0b3a7da9e5c1b87f054aa09efbad578037dbdfdd7d2133abe925be59f9e7fd683be7362ca46e37923f00bc8768110ad85c387c76ecebd8875e97ec47421e6093631d09ba734fecceb8af3614fe20eb778d06cf6bf4ec1bc1f02dd391ce80fa96cd7877c0f501bdccfe8487ebc87788acc1445bd3204323f871f3fe0a28f130fdce254200b3f1a36d71a1b6147143f4a430517688f82f7f4e40fbe7bd29f864964b3017ffed1bf2f69766afc7aa372dea1c021aacb624dc06b12227e0cf1600802573ffa4e113e27fc16569bce7616da9da64681e4acf896d45eab051c55cb3de88c2cb8e9d6282e5dee3fd25c88caf75eaaed1ffe75a7682d4b3558aad1a1520d7dea7ec1c1b879e099c0e5a185628abdc28035ff34867a855011efba09fe7ec1e080aa2ffd5d9f194a16552e7c57a9605076d50b79975130283755b4f25df301368536e93dd48669b2aa2e80a990952cf42a7ac1366c946a5bdd02671a495eda21a8dd1bd54c67042028a4ffdd5ec2e3a2d943d0cc8cf2cda0d608090898c939a828457a5ca01774cb12a1963c265f8777caa62b39042c8176de6d63ca2903c0b6982f45375a44f85fd942077aaa7564584259b29ace640b53609d67e0306e757699d01b30ddc2cbb6323427db79cd07c9dd2fa0ec56820e00d1012a2953ebaa1e751ddd44e378c2ce97cc6281162e64a8be58d6c59ff8bb73e862a6be3165103c5c1a845825b93f1921ab432ab021d3e095307f8b836ae77ad62e8d090134a48f2b3edb08f891c2c8ac3ce18492006d6e84cb725f1164b5827fd6caace9b0150f1462d25939f0e075439df17b71f53bb5036e0ff77547a3ac59f3da65ebfb673b8662e88a2722511fbcca8e191896f5804562b1b7e383952858b71ade6407b42ff952f9d7cc09411e84b1f2ab9a3c634cfd258366146ef8a883208307b6091aa6de65c7f5607b780093bb429429694e34ee6fb8bf64b1ab45274a1bd1b5a11615b20a4b3c175cdec3a376f4c04bdd7213b9ebfd14192fa8cdcbd7a3ea0d67c706d650558684fbc0284ad0d5566a75b2b315ade236f36c82709b561e59ffa63f6808137d157fa0ae4754ad479947fd47510a4972bbc5523b73c47b8f505d24eb84e77856cade1702aef08b9d115b99f1246d271f1a2abcfc6c0af38b51a7779c500d74353352c98e825e3c710b8c5ec26940e8ed90de734da7abe28fd5b132874c107198c9decee9626a57083a30d822218f9b781c3395761b903be931b19132748c4372b1ccdc487d56629fd775baa481a7aed10005d5b1f63a023854295e80dbeee46a99df02216fb6a22142622d363292953843f5c5eaca138205bd5a4654c37bac8865ba2584b4b79ecbcf456b6132120425d71650c2324532b982a988e5361c95e114dbf0a8897a312296fbdbd10762e466e0c8f45623356ee903c45420ba12d390ab8780f76c14b08c64839bdf1f9caea41756170bc82022834ffff51cb1fda1e00942a8dce1ecabfb7bfb4785795e5c05f4f1d1a9a144e404683d85653b758200b984a151aa9339324d48b5c3dd1588bab30e335e9cc0bddc6f27f226ec17aa8e9b92cf9ce5999b46ed016f40124f8ae8aef2b85f93ba8cccefb7b1e7742967abc134e5774fff2477b997b570d74571037b490ccdd4d1110ff28401731b2ffb680d28f80a0606ad8aee68c7d3c60ae79a015d5a1aae5df92c74f45211a1fc8070411e78df07ed0e9c27f4e98f9833df9d906d7f2f150391639cef8a3994f0e968096395d9f00e1a2f4f358bbe7ed22d657ea8fd9da9c5edf21440480b606840ded9be0b0d5a4db98dd9d650381c2f1147fffda3d51e13c124e4dae72d5b59c9f4456148e026157f4516f95dc1261488878fabfe755a65c644f11b78018bbbc429fe1a79d861051fe5aa38fd7fec7e653e1728cf6ce847b8643c770853f19741fca90de277315a9a23ea1843d6c44aba2b46d67de4fa5ec1b037fe37d59586305b1835ec0414f4f1c867778154831f8311806b2b0d29923e96a77d19284fbf5518976084b19f54ffde40508fc8a4ea41f27d6817defe93125e9d3035ad687f8f460b5b9dd0616885a4eb540f02792f93b2cf547646315633c8427b9b80401b807da220a671fe0aa22da59bac88d90a7e8a513c9f809e80c84338faeb66b52ea111be9daea01168c49af7fd67691055f1ab15c384d0104715430f32ba7ce080f5bfa05509a95d0328738b1dfd9dc6771515c19a3f4db04f9a24911081e722198753a510133a3c05ce5e30ba983ea7585905940c8202938bc0c6835127306b394f6fcf1e5836b1d9d6eba112badd6f08db63c7a706932098e312f4f200695bad3751011e8b5dfe0053fae8ff2d5c354f62ddae0bfe2158813dfbd4029c2f5fceb959824e2c7ab18f513e7f293a023c162119761e2cc1520075b2f7be552faaa70c1bd6318f3bd6cb6fa64224671ed6acdcb2e996661373b44f065350d0a2e56fea12bc6cfe326ccc1b64513f117fa47e0ca8c583eb25bac76dd47801cafa753f195dd99408ea4dc582564b228fc505ad6cadb22bd22fb5ad412163039aaafebbf07b00c8798034aa81159635892c737653b082b9d2a723dcd4b5260f0d43c41df65bef89c507b2fc3764eaae98e0bf6000cb36f503c8a584d84b7d8c42eff3d05d8331a3126846b390f198d249139448f86f07e50dba15ca7ea3a86622f4408d191cf0dc4f854fd1b52c50c5128c41ee071e37f714eddd1450a64ff8fc6988dbc3b848c4a8684d02b12d87e0d0d3185344e053c89f974a4694c47d54d76cc352d74f86502ff871974f3bbfc27cfc3aa303161ee9a84880953b275a7a759cb7ec9155ede82be28c3f182dd9cdbdf315969d52b6eeefa3a27336c255951e4ebf8556a04b4322eb431a3afc0ccd49508551c24d43a7e1f3895aa0d8e9d72c15da0f8103dfa1f9fb1bedf88d1bc1d7d3f34bcda9f41e26d44b864cc0c2895525f362cd7257d11aae8680d33f56cc98adc548b47bba82430f7d01bd0a50ad9bc9d586eee2ef3620f95f3f37d7e8cac4ccdc17f7e91486dd5018ad3f2257dc475594eb5e8dce5c5408195d052b4d92fae966fafd851e458143ba19bc4e5d9cd3ccd3fc89894b62d96e0de96b8000b760de82d7733c8bfa25f4f5ae0373cf9f8eb2fea7903be204931727066744d0f933e2b24a5e48c262367379d49000b65c968560233a851a4208bf2f89a2d7e11a37478f588c26a1072a446c2d7f46e6700aed9cb9a358505b60d88963dced832ef99dd989eb43cb4a5a69b00b49e02e00a618c63349140041a62acdea08c18c214f9dce10243d69850e5eacefeeca4e4f87396b6aac652b748d72064faa23c275d668c018a685b44e12637cc7f90c2ad8f3236c70ade26fc4310d4435d7514bc708e1e54757325d7d8aca953c0b6a7b2eac1e91152480bd3d3943dd95f636483302483fa22c4e691279907af25fcc833e1688731da7a85a8bcf2c7090a236b755cbb7085f446214e6b36c02d1b9a228769ec69b85f69f8a525e90a7f9b94aeb73d7834b2cf0f84fcc801078361d228138ac043d59e54c240c269d16584950f60a08ff46ccbb1b128cce20305d8a334d2a4a65b3e6d6e646a90c0d4c4abd7f5516f0c0f5fbd7caf1435063799d972904554fff0f5c7aa9ea8127fae8be4b3c112bd8a34ffb2547310d00466f706e10f1cc4b050260d320d1bda3f8124149a0a96243261a6cf78196aab0f7b08b536c16eb65ae7c7f97ada7c938aedd41a0d52b06224b348f505606e53179a1dd9bc540fecff4032f7d7102ec0fe345bcd7229611654587ed28f09bbb5dc032aa1526347af6eae3d9aeac9835213132ea3e3e71b86100aab66b817c7cf7b921560b354514aab3ebed138d8180fc004557a97be9015ac00ed49c3437f9019daef2e95cdc99133519b845ddaec5a02cc0d6e994ad5b33d50d393f0fe505808140852e8a6af9ebfd1db2d8f074ad29180305f87083f9e3fb77ededa663ae9531ce44074bea3e3bdf23d635a0102a5df6415caf4e1d780e3f2f2c0c1ff3494a1102458aa9c58979b554c3a71471f4d0d80c408468633d02c7f645716aa5d1959f1aaa51fbd377584f0daa34f2c6415bae4c2ed42a748b78f5ebc08a905a8a6ea5d1d7d791f236dd456cf52c8d30bd136435afa94df4689094ba1663622d6f737c1ac5202b315143175a7b26ba1dcdbb276246d10659255848206d10a3d87664fb557821a1515b368efe5b2263500d8895464677d7864e4d51b0d3a26821d214f94fb027aad69b1b35159600de727f7846f7a2ff3993d9386b56fa38a8cda76d909d45686216d8535e544bb8d3e6e9597d12ea42db5481b8b925e322359f1717dd83a2d6cebe47a94ad52e3ad9d322c69487e8b444020eb8f3a96e1daddef17b5ae478711141b3120c994371518ac72f9dd302e1395c5ee75b641eb05ec81b84e74d0829c202616050fe320d6f31d53b0fc9969912cc9c205a17fbb0c502e1245f91bfa91d0b0a1b0b042a2049240c6f0356f88fdf56efd83f4b32155d66943f92a8f5d1383a159f3ee1482232f1da96e83c77deec7e7947fa771f9596029c118dde3f9f76b3fe12ff52c5adca917cd59a9b95577e3e132750644803baa609ed0cc25122a20c14531d5cae26ff8c9c0b2a0772401563d5218725924e8b27a081814dc80bbc88a414d2546cd768fc937e857224e3b7d00fb22d82c788bd8998b8f79877c225ee130bcd6fd231fe95bdb48c883332a4284ae83483b2f83299de1780da1abcf41c8884d21667371b046eb4e98109b23eaf2715fbc2d206ff444fa664609340c28131627d622484d4f2824d9eb0534f63706043f1f03f66969121c524c269ee5c3f1970a86f61cec1e69d561c6add3182a252d333924c06ed692e22988e9adc9253e19f8ccc2ac2416c1f0fc947435083d20bb44f3572388405a1335403245a03249bf73b5419100278f563b92674a81462ee0251e942f60671bcf733733064733606070cd9b69ce6f35b785c480c341841251c33e2379a75c6e4fda1d91964c53fb1a1b68bddccee1f266e2c5394385d9c4baf082a281d304863410c3ef16cdcd45f20a6479df3f1bac6024e42a10316e1e58f14fdf56c274fb99fc20f0c1129d9a8670534cb271cadfc0fef4a7ee4eb1fe46e50ff4730050d689249336a46572156d09922a23b5fc30d2f1469d9dd9d33080455665b330d9a9f71bc7a7eb21bb191aa3f3eefd0537754dcde2d0ec4a33fdc75cbefedac2190d502db251bdcdc9b73dcbf9e76a54fe4cbfb707691c92bb2681fd5ef0c22899335eff3d41b0c0463f25dbd0faadfc31258de222b7d70570bc73bf828aee036cb2ac783ad29076daeabfe694ae8812aaa522db506ce3da6debb5b78ddcf357cb72ac488b47b517edb7acc80f8cce616d4c4c25b125e6a21ee741d2ade25fe7837e475a32669b30400c560c3f0cc412a78052f5f82d1d1eb1bdf5eda234ab55f26c7ec586f93c95154039e4eb248f0d8e3b72e1cf5ba208d01a4305c929d8b6b420a9a64542a39442cbb2990856e9e8b61669bf196eb528f9cb8ceb1a7d17021dd34eb15b9541e290609c44e436b99faa512b6cf606f6225e6ffab94db941818f03106f200d426ded1512a1d6b8d814337e8c636ed341e813e5507de6fb8e7508c9e2f8290de405734b3af784298853d9b07cbf098f32f153c70db2a14464c4854aadc45641c744f322d0a4d02bf608d7469fc88e0585acd1b3691f2887cc02840f8217016e9cc87bc205c113a689cbc641b8ce797c32153de0ec7ad75a0e89f251fbd415fcebf7e88a39166ed834e141c34dc861e06c3447484f8f51fbe67cf46a80a6e73a4301504aa7872ab32139d9536a9c1f8e0c584121b2e200f30ea6739813f008904035976f26bbad8af4e090258cdc7aefdf712b207ad71de30c07d127bdc8dd9cf713ef009834628a1c57d510209122f0e2f41199e01a6543e58d6416e8c49f768ffe8223ec834de81bfab71db97c01922025bcb7e1cd3fea60e752d25b4879cbbbe5a6dfa00e32adbc043da5c62a6c1e810f7072d7b42877a81e354b6b4bf13e65ecc804e507b41eacfce632feab55774216b9bdd40445eaf151c457a924e5449daa02640dcff2699c13bf9a96901c0c84c82e1224976475619999179a253f823a06ca6b8fe11f9445d4c995a7e82bede49db3422cbe2bf9c7e81154f07767b193a41908f079432d409f8ccfc964a49d9fda188de07244aa9627807332a6b99bce9e95f700553fbabb053a09f11ab3c1d073c6ae4f4b2da197e6a1754d0381bd9a5d4d4fe45b3d555d4012089aeb442fcf05b978c65f8aeddc6d82a879cc2cd24a7d5aa45742f635be976874fcfb62aa4ede08b7a27b75a3b1768bca69e8fcb1683fb083e069a48e369840199025b737408d365c45645e40f6bf8a3f39d09c758743ba5dc4916431758d7b468d451686402d9a81a6a602c18911732069ab8b2f22d0988bf0ba9a33f728cf3112abff76aea06e2ec4b744bed12d1e50b099583c89aa5941c38c4203a54ff10903cec4f18aa84884402f82cdb473283f91bc5e60f7bd319db11ffc74c4bd3e31b6149be4d12309420e967814f4fb3f5daab019a58ecf89244bbdc20b131c2468e7dfa2a33f7436eff65a8ca751bd3dad736ff04ad0e9fd8ca6dcce3d46c9ac185d7cf8cfb397c4888f043f2cc48260a190bf1e5a6d75ecf5b3f5a31e5b67a34fde1297a8ea7a3a9644d79b98ba856e2d9a9f3e9f62a1f144b022f995242a243cea676e0c1e20553c7af32bc847d0a4376811d688a8effd19f15deef6473dad972884460fab3a1454f4bc82305e80261fb92752baf4971dd19b49de6082e32602183902ad2975d63885a2a40010114a8c999fcc934724e7ec68117872c18c60e60d9e3a15911537a47b5520ea6a1915d0f2b73583ec805bbff55a38422c85d2c1f70951cb793b76412a8390f1478c98e24ee1861bbe9a48907143972a0a85f48e6ce0bb729f4647429869ff33003f649638e700988613419a95e5f48f4e553e8b811e79001c0bbc73c2d291beef22c48a3ba271c604d55a5874fc1b98ebc42f029c04f3d6b6a7223bd2a50bcbb470c6c7541f50c69de850413ba77a7fcd6cf539371277d38b4ef6374aac44e46658e3aca566394ff7e2733e6b6656cb025b71bd694d236a0516e7b3dc12dcde00696df3eca092fbbe3123b9747c93eb179d925bf536ae37c009f6e021281fb2303a168d2115686ee366004201ed70e2405af6d00ee2b0c1065118684297e24119130ae6df79671a71e5e101264114c407e157f3a7e30bfe2a89b4ae619ca3e10de20c843316111df289d508400d1d550fcaf2501da33bb43adce25c7154c4a843c582c29b0dbb9a863c35a94651acb822edd59b1f8bd09ed5778880374cf56999150e204ad46f7f4ee903d6f548dbe00177afbaacb8255664bfcf4c9d12148bbe14fd65070bfde24b1f1434facc9fae1593faccf316e5d3f75693fe51620a249db1f6e191ef0eef924980e94fecbc6a32f9f66f3cf510d66d8b0e531876799eda5d40eca97e9858e2637d258805de1e43b69f0ada8d46a29eccf0da07e517624705d085cc35da3a92d6d489d04af97e2d748793a19fead36dc40124763b8469520b36e9c6d8fd9186d24e6acc52bb791c25e8be971989ba84408437b0a2f0577fd27ecfdb38af4e67f9144e27e6f9aff7f9e282f0b5188014976934a655a1e2307b2edc3d81e74a8fcfe617279e6bb0a3e8526856270efbf2a781b0dd96e3a1d471bc4519c60109e5d216250dbf9905e7537eaf9acf8f71afa86535e08e511179f3ba0024e2305921d855d9295dd3df55ea384f678a55da3779a00d31d262434f2f4b682a33d0c319472dbf56e9abebfedcffb06233e689f9d0f014f0e885bb767a2b8536fb5d85a92b924e01c2cfca852212bd0bddb1ae3528b3c4175a02c590e484bbc8467e500cf6051a0bcbb315f0902cca3f4942a33e2a026a522234fbe3ca064d539d617da5ff1f1a59f15ea18a386159ea1d4668c93d58f45a4185b57ac191adea4ccd4f4378516276c84ecc59395461e0b740e6fb4325384a04a50f48fcd15dd1f69e0244851dba66db4120e14a3b3089281b13433f57abe60137e0c9fc6c52043f9bd76b90086aeb4dbe7b850b750b6bb53ba8e1e71a052b7f08da5b816b91d9122a9abbf2da561d5f3e6209f26915f60c1190af367478b2fe33735775bace397878f302c3742ace2dcee927901cb09d1123cb7372f419ba7970809ea25c6979607d37d402e64485843c47cbf5c952185f33be943d0701a9d7a0a1b3a665bf9570d3d4c7d372f5bc9443714dec33ecc847a1da94dd54bfb9ca4be2c1f195122d0cc042de68739e9fcfe2d045770800829006da2e1041b09f8fb11f577f10297a6bf55584f48dc777ce34a415d1d01f0e264499a0880634f5b1aee639208017038c4765b6a0da523c217d4a6b3bc59fb99818dc5d73f576583fe6fd6300af76371115c07fe007808732198eab5e66190cfcebb22340e64d1bcb555bb2ad0305a2e6f97535d1b7bc2149895044d2332714a09289a698849876ef651b181bd3a42b7b20c7a4c72fb65a8b933458822c85b141234d1f591489a4a7ab9e3c0b4312257ac29eec498ced58894ed8b4e11fabfd5339dfd9e952de5e7de42234654438f3a2830ae8a3029db266f50420b654a228e1c4bbf38fe863bc6d98402760eda3f949441387086947b15b05aecd7a24c33bf2d24e57e5db58bf89c1820ba54cd73919c28fa28246ce977178f818903f31c585e8490f09c483fcb962dd9c4c7203472f7664b1e6892e3b12b7ee06cc9bb18e0b53ad2ece96bbb9eab356cb3dfcf8ac35aed3b0dad5ade14a34c80c53218ccffb769bae236dd8d1199c7ec7511a493615f3e6b4d68f9aea112b5f97e437714dc555f03b084070c744a9b8316e3f2c1d5615de61a7f219559cc7fe17d58206ed80ea9b57340be35960c2c50b25d6ac1c35f579fb2b506c91a8acf130b7db23626b4c2a3ef959e7d691d5c9eba7de5ba65bf4f0cac19165365ea57e921e6ac30fb1fa381667f2d526a38667cdc94155b1f994fdc6662b2a4f3e11b1a4a4e256e819e3afa069824df70a003e161ea426e868b7f49fff155ef02531b13d39907bc000dbc72806374a8ee4e6838baeb39f4aeab34645e838cbef0189c5f97c6f68305b59f2dc7f4e126141ee36b9eee6da581df7a7f840b92b9c171c6e11747f8f2ec31799debd884c75856865c5ef7f75cfd9eb31ec7af0df66a1857eaea47f80973c025c4e456a0845bb004e87370bd76dc530b8de7dd85c862bccd7e730aa94ee87f5c825e93faf2b1d9a4e1dda35079a6b6a763748735cfa19057d94b664c46438d3c5899520d9c6d3e17734840724376ec7809e4270fe686803ea53b143789f9f21fe6aada26aaa3e136c23167a7027a04a9daafc6e7b62a1b07d2bc08d12781e5f83f6cda491f5aa31c23dba13f6273a97b6f780955dcc43d8dc6d23279c337d3562bd250d61b168969b1ecd1f2f90add949a96345c541bcdf1ed967a3b381dcbdfbc336d8dd35f14aed206300f5eb50e65be2a77c1c38b791e6e0839452ba0805231b5df19166df0b99e2e5f8ed5857429e433864ddb549f1725e9110ab1e0737a62ab476d153bf3174d3d2505f1567d2b5b0ea20dfa332893dec5881655ebe236b199de5ab4f412f92d192b0e352a4c211b0f23c2a17a8300c947fb2404fd65db5fd68173b43c99077bfe45bed7c7736b3943017a314369fe560322ec9210c1ee710fb3f8bc597b6819a64858b49f503174eb37065ee96a684ab58dcb7ce4562c80d2c20c78ec256431fa245c30981911ffeb78d659312172e73d17f4397c0a83167f1ee526cd5d12d2d48ffde9d94803956597a386eac8d66c4389797f7f93c53f5d9f4c7c71dc2693aba15d5b95d0ad4816e4304f1c6439b59cadca720fa365ca897bd73a4e133653d93332a110ca1d68b58dc98d26561b362c11dbcec605de270e6889f95b4efa159b8b1edf8982c2661eb11c77a2d1a0380a85fe761d053c8a894028374fe60094cd18a869d87f9903b81824596ef0f920871bb9e1a60c7ee860beb741a1d36b189dadc644bd0a0f95cde7c45e51023580f81e4245cbfc28b23968da0937696ba007e8cf7e404173e6882d027af461ce72092301dc90e71123dc5c70d24299de0cf7b26d3b38a36c6adf0a165f0653bea90f8ceb27e02a43cd541ca43371cf6308bc1b9d8bcc0b2f7889aabeaf138a610a6833a8245fdffdd656418d0327f5c322a3425b6a5c2e1fe1a8189e90e3f02ebf9a77f348b03a6235eef5443e8942df8d3f63ea33afc37d2784167613abea4fb1465e8aaab51f71c51d35cd726a5d5117784c314695aebccf967bd185747154ce9557b457969f490deca1a805117365c47f75a3e4cab87bd1b00064ce7c2d975f9768a545bf77691152c4aa4bb6bfee0eddd98e790d7ba913738e99726cf2f09b8495e3531cded6d96d5119f5da971579f4dda5102c27e563d174d0f12a098139f7c469a135f4b790f350c4036fb67e6224cdcccfb2e9ff1a41f939cc68dc4c0b24070c92a7b8c42a2ab216107c94e621a2c74d3059e3409403ca2c737acbb0d29fefc69c9ff99e06a12ad9888928e4a2a353855d4e171f0b3816973812edbc6f7cceb6ec2a63628dcb2409d5fc385c40e9e01dd1ba6b10935222e416665957baa754260ded401f2c0e11b69cd174799a2c5090358413fdc14ddc0bac60219001fa97322f5b1bbad5a7e1caa8220fec2b222bcf1aefd143e52ed8b353152322891fd153c8d8b6bc8d7e45e49dc89f0df7de23110fcd8b99b28f4edd1497b5d679c769f0fa8bd3b8cb92a035d6788d1dc8ff7f72454812fa6219192a4818b7420e2361e0caf4493aa2bc1b751847d818a08e3f59b29940cbba99a4e6fce60252c70bed88724dee30da6ebd9c4795076d17fc94e8f61a62d300867ef4a76cfe433c1087e66a4a1bbb81d1ad209b579c442db285c11a1e89c66604012f0f6e7e142b5942a5b40909b38805d1b3c762327012a89444cfd78000201753625c86f108f5d180218827ccc1e6bdd402fa96e80a32bfb2b720b85ddb168384d38b36bdb31044fc9119dda0482bf2a575878d8989e3f4a1dc93b693c754cc5b27e065bdca5deb7c254f83b21fcbe680f0e817bd9a800c7c150603f59acbf7aa5c76a3c7f0053cc7889868dc4aa5d54fa216067671fefc11fa04511ab513d65f2db00605248b974250806022f163d1e3bf385a80ed5d2c60a8f2814662a1300adf85ca39dfbba1771ab2b3e534fee7e51129b90cf92fce697219cb7e20a06371a09d1f64e21f54c2537a3c5a0f3ed5398429db3d1591f8c7a66a4a2502bf4d0702a24db41e9df2deeda38fc0101d5eb3654f75c474afab54e8296b60087598967c1bb8a0db4056163b4403ce6dfb68e721f6db933e606d9effba251e7d056513117031906aa79307857c029ccd87c719b32a80afe7c8e2ecf5e2f60a729f28e230cd75a377a641bacbc2221f397c9fb62b9632806e7e33db7a5e5e3ef7d96ba2b3980dca335ff4a50cf36b51c8c90ab8208ae8359d18a71e7bb190ea7fb40594252ffc1c2b1d6b86840725eeaef5da16ec0cc337888ec628e9bf8f1f5c5b381bf2a267c11bf6c634f1be8115b8d6be52ca1618e5906942fbb6a682e4171d849af3c973d414a26ea3d87c23999bb80619bed6c4d5a2906b80fbe8a41af1127b2034ca403e109b7453c73ab467fc7e472f2f6aed293c96f3f1b32fd713b298e060781d8b564541be9c5c79d1475835006174b448490bd65fd0fb1ae60d0ae4633d5cd17a4d0d44d5492394478b9bc9c9650cf4698cf795f64fd40f035d1b72d30762f245c1c8be85f76981758001a1b160a56a812d5df257a297b7e12d084440a8f111bdfbd081a1e320a2e3f0a9f099d032304f77f58d13991b8c6b8ff822977b20c66910606412b7c5d5e8978b2d5b75f7295524db7679b4331c5827f0f81692cb710e20c7f3e20e754b34118defe53fbea9c3a0a65134387bf3cc9810a6ac7b3b3b15f1c8e88e1d068cbcba076324d732c9f6ecfdedf19214f41f85a78039f63da2447e1a9e35a0d8cbd2819cb6ac6b46ad11fe87aeb2641e9814386dde74ee5667180c26371843b569c1103c13b119397a269318f1502761a5ae0c3fc89299a914d3faae9fc95c38e1a5b7ce9083a4fa5bffb963b2770b900e90d587096a9d33981b179291c9af15036b1f9d385c6c85980cf9580c7b898534d88c16ecf5ea245ca0587959c2fc791376a38abb575a8b9b05cc155ce4572d474d35e323942ed289403210f45396309878a57b54065877f3aaa59758924373b47ee929b0830ab75c6fd1fd855e3a4321afbce4b84d15e2f71f01ec0c1610b53b7b3460988a6d9534da8c385188d57c88973db4d5eb8e2007b00f53ca35ecf0ad19cf7bdad3b2aa68cd03fe58737a6cfd2c8b370a70e9d4b433953ad1040def61a9caf1367f02698c694b840df28e078a0a4f581886121f860fbef28995036edc9e4b9cb8ea3f83811f9c8ec5a28252cb80d7e3cced9c82389e410c36002ecf25842cc523a58f7d046c2092c63006d8205537e3aeda22ecf2f4c479226cadd47aadd4985ebcc11e1129845d53fa3023800b358ce38257275ab3c8095ad61f6aefd20ce441560804247c8a7d73591cb1412b22952a29bd18485a0058b9742f6feccfb86de074f1d19f498a16b65ed6cba8210787ca0b3a9201cf8de5541bd599a62d519a33c32c0f7fbf329578322c6ecbde3b92d1be8241e2146d691d29e970832189746f968ac3bd79ce43a5c5558b3a42a743f3127a329c90389fcfc22d60777210f3ab6be73ef8cdfc5ee4b8a90f026b4d2b462446ab5dcf9aa05e37f1e24b47aecb77b63541228f78115283a615d40c8ac4a9d51dcfb567945cb12bd9ce47d1a0e05781d9d351ce863065d12f7096ba11d5133a0f119f930d5f15ed14fbc152a24f5e9b10ec10a1165e3b747c7ff5de5c21603d24676c3f9ffed4048ebd002e5f5427f5e40912f5799587348ca28512a2e4ab012dc66d7ab9221a55a8aa12c977ede77e96f7c0a01aa21c0c9c937e13d8e4466adccc35b4525ff01ac17669a98e31cecf9df6bc825b68b86a27c922104f28c0cbf1a6fd312577ba7f27aa1e1ed80621cfae46ec385706a295bde402cdcb8c0c6247b6f81b1d4cf222908218cf8fa275b4ce29dce03e956052bd1b3a4ae1061095015079d2fbb5c8cbc3be96041e4b60a5a019c8d71a2402301e86d0f5c67190bbd013ea90d94dc4e297211be06015864ba75001be8cfbe78bdc2f73a12279798fd56f9ee918e2f3e65b8cf84208160cd3c113446f2a6894c5136dc033353e9a87b38fd160392cf724a5b591ce8818824415d6bc50b40643d2f61541ecdff9e62e46085683614d9849c3aa6b02ead05f8b7c001b409d1da3ca7954f1acb8281bf3f53f62e7e2ea324247941a97063a2588578ede81f46ce3f59e7e44ce42ee6dad846c8216d000ba5c0a711828bad9fd60ed399fd703c8e9f2f1cf7380807fa462187080b71658cd17c653b152c22cc1bda870e98d68996194894d0867fc7f57a9abcd496cd36b19fe0dd1c54300a55d5451d5b67ea969735de4fd6fc3f06ad07a307ece0074b0d80bcbfafb30a8656a9965ab4c2d8f911430b11472ee5ef1b3a2c053e48db3e82f1d4139aff10d56d5a8d46de6f3e960a806d7202375a272ee99114935c15bbf286a875a28eff62b3f3bec83b765d03e5c8d01eaf1853a380226b842dd18c453ee0720c9a70b1b53a681200b232bea0d2d4db5a1ffe3c65ab15200c8d6bd963422bca72f4541397575b8d61c291b2e4ea95c3784e75c663ecbc073720efd1e8556112c3a9ab2871c408d1df32ed653cd58411034800b897666ab7dc16846defaa9026eae1811785025a33f9d3b33b6b0181335194a82b99a6bc4dfbe0fa3bc6788df9cf8e9c7d1f8098d14c5f365ce355561bb4e0820aa3cd2d786cc44688d226a715456ddbf4e483a555b1683af231b32662d7a1061ad6ef1bd4a8e9024522d9534eb88ae5863afc33461eb6f0696a74762e4b8fb742536ea0a1e01d1ebdf94165c2547d8342d67bd8ca87191f7f071ea412153557fbf0580a723b420121e101b24cedfe97b6d897b9be8de8779c482538a8f4cb047b5fcca13aff715880e1211e7119d2457d3484440eaf0830b6f845363f5e63fe4abd50b301bd0bf746eec90ea03a36ae540b6cc5c125732c9b7daa7878a72ffb84113aa157cae408c9e9928600db33d91108e465e146488c95636715048b86a9155a5dc4328a990c6cadd4d01bd30427de3b4deaf3ae5f659689b5240209b61523210d0576b4362804a554ba98c9f31b39bdc19e56e8cf1611006df99f7edc9ca8e94c54c40e235710a42bc200249d377c3b183f596c60fc03ddbdae6bb4af1480eae36c59c0d11b3d6e5a8e5ae7506ccbb7f884eb6b1e72d84f9695e96d5b481a5d9a4991ea5976db9a926527121e96ad9afd23210350286a5b32cecb68870ff1b9d56a2acf6d8a71c610234ffae297d84125b182a4809f7c6ca9b00821d46ec0a2d6a59a1a805b9aaf57b72544f40d54cfaf36ab7d55d295bef11044015d675abcb831a4046d00d29e109405c01527528f0f5bc821b0722875e8664976d7deaee2ba2b58d6b70f8320895593a5673944e3fbd7e4040b5811df184e069928ff23e309d149381e5b25440902429a8ce5ea394eec643549fc0512a8477ba48df6d564af9ada1fea8155507ce1e45d30be966853cc2b0806c5a76ec92d7e710ba1c0b9f855a59cc094699788e2a747a0971d2ed9a321fc63a22ff5dd6c29bbe21901344665628c55001f998806dab99d9efa692bdd340de9e19c814f4577ae7745bf441344d92320a4dcf8494061470d25e1e26612336677018e4e439c870022214ab11d9e71a9b1491ac1d0b376f0e30218c7e48d497af6c62cf4e7722e56030c11d26b1ca51434e4fe8003cba95407ce1c6438a6b2c99cd33bfde34b2682b3d4c2f8e60dd11e6881b8414182ec2bc9bbd06e579158f0ffcafef3610ecf0d59d4ada78161b2d5fc99548d3a236436b2e38d47f21fe34dd9d240ac85a9ec54d1c4890ced77124d27ae3555cf47cd5dfb1f0a4b83984cfe51d53a56f2a6210620ac6f9c9923950f70bc4c5738d2e4e9767a37a91714d969ad66b7bcf52c9012f15dc602ca95798c59159cba69cd29b6a4232cabeafc8c87be24dd1f02842204cc1332b8afa3f9e09e6cd160704e1ca7d1332b890a2151a94387b675564c52bf662bd6119952be8150c8c4a245ccb22e6db18a05fa121b2b577a94c71b08d7d021a5e64d54438cefc5d2ac4867c10868d68d6d0a4cb48a43084a06f19fdcde7472a84d23abe8bcdd37980eeba6b9ec6a356949159187d4b2b9d8a874312b3b9983514787b102add531e6a640e8b8fd240484b80f3d1ccc95b649b6c2750f4a6397d33c59367685e5cd2530310aa9bbec18ecab748f7545c5ed8c746b34b0102780954347e5650c6c1bfc23e66d7d9f438c32d4903e8326b927d26088b1317c2e3c1aa6db9f1673bab5fd7fbc9d45425b9e413f24b886105edbd1d23ae511b45384614a5ee7710e7b784205456d861425a6382390a0f73fe10770c4f3cf23f8206b410e9639784e632d79fe439db98e46193784ff8ba338d434ced3382bbd790a85ea122dbb1dfc9d474a566b455f2be3fd6d2f9bc6d3d6432eb437accbb4db6dd83271f07828e0857b9fdc64eb88cdf2faccb7dc00be0a17353eb1b0bb6c0d7695e6037abdfca41b88004fd3ad06f7f07ee9c8a1b602c7d306d4e9cb8f75fbbc24c9da340f406ef9b1647524a88c356a14e78072535bcabca2006086b852c903032639bc6a285982625f0b36d3440798101c8d4c531be35db8e9311c43509c378999a52c6415d666c69ca58f6ad912ccf5d91a80a9dbd3c92988222965ae047f8982a412fa9f5aab07407419dd5d0d4fe961da0b013b9fd9f08eea991e4fca2edcca85d4f43bbdf6c3fdbd478cdc2e7f9f9f177569d536f94b7f36dcae2b9a7e59164259bb533f59cc22f97604e83cc41da5c4ec16e15cc6940177352f08fb5345e4da6ac2e2f695bbe694587aed814e117d3737154e07f59bbae3080afc2ff6beac6988862d3700b57b5bce295d8d46816cda8808c4855c1da25c99a205d0a9cc344b69165b1fa50c2d32803cffb399f0b0e94806dedc32864bf1b10178c014815f553a6be84a2953e57de36fbdd9989fec704ec9c0895c4472f90b501d35e95092af866019481205e60e4cddfb82880e5448b9afe51e9d2dd4099be398fb7fda61ddae8610542c683fb0d3750e97e37c055e629b47e4d4e1f268a5700f133d81aec8acd014280bada48a6371d198b3a5920a1b5b2b88ebdb9d4e0f1b972045c21d34e1b542a1923c0a2102d3321ecafee4494e0960c4d798602ae3af5ed1c681fb8e85d4a26fb8119acf774214e61517eabc537fbec3ddf5613264e5ea3f8413ba8d24f8482b94c0109c662e50f42da86da41a2ac34e38bb7991bd6b0038180802e4f9b709feab5b9c444d09473d458e5ac30a6f9bb0cc4b00c24d32f79910ab8e9b36826b73102aa83a331f7d1c0ca8433602ebf935c217dfd29aca8f8e9ef1e3e9f5acf9bc7fa003cb1fe4548b54ace0a4b619b2c3f207c7428ab1803ca56613098d859c885a93dbb01d7a222607e27e71a15a34a7d1d1efe0655b818f044ddd4ec4c91ab49ab18d58a7970021f0c92e99c3a95705a797a99a8b536baa6f6d31d2a74c4c3db08217a00bf8026555a6f869285d79d8a7f8db9a67db608dc994a3d21e07bb7b333c2f423a5b31471a39506bc823b6310441d9f6448c9c7c8aae1bc391fff94419da3e5a6b4c5edd87df9c3fa25b8d4a7da86c44c2406099bbe6e80789c942450d325a5c147f1961ca74b7e688be7ff322616cf4706a9149c9fa114dc80d704df620c8a9b4ce483085fdf63d3154c533b645729c3783c6f4a95537a230c492068e61091298b3cc70e90431e26b516ac8ae634910e1c17f9ee734165f88f366a0552890a246f7abefbbe6438d93b8896be71db18e964ae0f49e9adfbc1e1b987f212148ee5e2ea746909d8f857a17580237b41957ddb2c0036b0db4741cebe30e42b5983f4ffb452ffa9797b00d55fd33f52b3100a274c909c30c60c0907a2ae864b145ca41031eed91fe779141baf7d871b6bf351d82c415f00c7c848f937b98eef20768782670cc962bc4f51bea2c23e3539c6377464acd12eeb6ebbc623713a3b4a22cdaf4c312dc9b3c90d4c1603d54f738e6f889b445d8001709ab1db64c24f057a4350e9de7772d559638ce3456a3852f8bd5f94d6cef422c1f2c40c6892cddff12edbd983d4475fa59bae4dc9b9b1ab9d6b6c3fed4046559700c194b81bd7ddfbb16e7ca2b620a2541c1a7e946a6b6c86036862804e4596db4e4fa6619def02764163512278680fbf40bd6f44485f771cac100d379773d58d2a4d2f21f2eafbd306f26ad52ef2a8abc0ba39fbb9b985f4d9415ce937181466a0a24070956e562bb9d00549fff52aeaa4f4c6cab434d017588775cd0737b551d7b7979ee32c12361a7512a60083907a5e6b97f061a2920a210a89b35750fcbe355fd58d7211e986633101849b9ebf53912cab3d50a61069fd3f58aa08d9f9c5ed69e3ba31563316d25d7ee6c62b7b629cd0fcac976e9bb0dcef4f69eda5992f81ecc1d90af0b5189bb99072377c2239560b8a9df3ac9f9b36f86fd2dc9e7c7b2f2ba82b671d29f11f15777b30544fadb41b1620f2787975a02f0e64d208d2bd3f9e54a00dcff19ba6fd77963227c654c7e358042a7ab72c24c1db6842ab300091f3cd7b37611b94d732b2bca6703fa096d23540b5b1a80f80cf3a2af3b8530e85e388093464a98c3e30fccd48a5fec468d683dea74504f645446f0ce029575e879d855acc68cba782af074fd4ea41169c71cc488d861d31ff20918374900346222eb083da3251ba1ae7cac6d26ca1fdb3d0ad3595f4acb0679855f6535f8d0d954e898eaed73f65b62367857daa729c5d315f223cc7502bc90fd1ef70f73df55cdc04875b5f8e387f2c1efa73f090e4320f31d8fb62833c5a052b2405ae5886314b98d6330309c621862634a6879816a73d67302b6a1a57f10c2f3e627b5f1790dc3f8b9f4025aeb03fdc30744dfdc8c979985b3a6096abd32cde191087125e03b9878f431e0be8e353a1804bbeebaa6723c9832fd53ae5ae10cecf0356a1c8d0ab70e720a280e69bbdfae01b3c7cea347ae04cafbac9e9b3cd707c8c099db3526c06803063b427eb46e4116df13d33c5e5b7df524dd1cc5bba20036f02bae5968a1d00223444030a4c06795c308c4a4e07ebde33e77b6cb6e745b30d681b967e9329debee0e531201ed67bba102646712e7e606ab87e4441a758046cea5487196e5741601cfe3abe995ee48e7f0323a400aabed1d0da27f5fa5fe013c84b437bef2de5de524a99648107790758079c16a78b2a85b0f3c8e5cf38ca2f7f06da5b083b77dbb87da305b88dcbc8a8ac0a5917f7e5df3e201db41657dbebffbe22a128d15db509dd44af71dfe2083df76a5b6de30664e7f56bedb5cd3dfe4dd4e2aa4389a8d7dfbdd6bf3312d14f645656b9fdff1117f7ab1cb0a4b24e54517295d359c1c5aa11f7b54bfdc27dad155685dcc57d0ed8c9ca70dffda4a437e6ef5125395ddf5330ff97c7215403221ceead444037f7f641b8f17762a9f735da9bce155815a2cfbd0c532028a80c51c392132f5078808b65220e15158cac0eb54aeb1b870c93710a0e51462459776b3dccca00be6bb50fde71eeaa268a289568ca2043e9044c7630aa72c3ab7a400a6a0b0bb3872311966a40410a3166ec127084c8709ac4c0e9616b72ffde264b708a6e1370cf599631683a24db15b20fa626094e042e2099b1d6daad5a6badb5731583765d7d5a6badfbd0a696035f83b6f427cec974f1fbad368b4319e816ad2fede27764cb0798810e43ab83e723c4ee2da7d4bed16f92506a69a594d25aeba6744b736da873debb8f6cee63d4086142d209a6086302154bdb96ac80e3c25695d4eee33d6729a4a0046f06b950a7547fc8fa4cb3b9c0dee5d68bb6e2eec6070469427f34a7fc6e361d757e90afd91e382be34a0a5338144ba8084848418924610ab25d6a319ef7939294d2df58bb8f783badd537a5d4d234de0c0ab95615f10cb5487e145a47657150b9f8a8ac2898fc69d3a10a0524f404184e609182e504242758151698105984329e0866a0c061db4184378345c90e3fc867cfd995dad67bceaed076f9addbe4cd2077771daba78d49c5785f46e57cb9daa8ffc97914ea518f42bda638b647a13e9c17d8478d2c3aa0bbf2c7fb9cf113cb0af6b8f77239f851a811bf833be8bfcec9f970dac8c911eb8362f7d543594a5a1232c7b536c77dfe8d02ad9cb9f74422211cc0078feda3e7a1bca172d2bcd74151169871460fbcf780fbcd1bcb567671bb973a3cfe39cf23aa763e14e83df765ab14c29c88f23c07776c5fb6bccf62d9da1985aae1799e8ee7fdac42a9f7428a73c0ef537af4b1cccfe5926c096d9abbce3fbbe7ef44cf9efd3f686d6fed2ebb73b873efbed6aecb9ca69e145df7572cf5f61e7ff77df5ca233beba0ddb443ecee9ede21768805a1fe160b945f1ed9de885fecaed3e9c65201a58f7d7f47cc93e59f12bd8ca78dd6f6cfdb7bd4c7b2b5bbf7442c96be87f6edf0f85d52dcf7eaec1bdebf5fe78bed63a980dd3d1ecb17bb0c3bdf41b737e269c3bfe5e9d04a74d93a7bceb064b1f9f1db2be2cf6287e9d74477ffc1d0eebec478d30f81288e0f8676ee511ed95dfe8ea81b4bdf2b6f042102dc1fd9734f8ae37ee7fd043b2f7fedf2571022b0d2c037f7aded818fdfc6dbe650acc59b41d7ea11989a78282929d19413b4ee50a95695c4de9d1aee96f2b2713470b809e71d1472973aa1f376da789f0a4a8de15ad55dea91ecd35a6bad8558d1a5cea1b5d69a47cd51a291e8d1aed11aad512154d786425dd34f18292d618b794c25944e3da1b98d1b794c24362567d2e1b123839214159817dcafafb5d6dcf64c2237ea0a88d8b4b6422f09b1bf94a209d5e05dc0021e67d3771e4f56a1eef36fba89498f2e94e8efc1e71e7feec6559d5f470ede1357f37356b31b577304d2fd4804cc1c8178d77bfcf9c16f9c235e79231ea70e71c5adca32a2f46ef14e4812d3d528436b0d7df1f07ff93fd1878e203527a774070999a6e1121065f99626d910c9a3d5c444294d559175a94ee5a42555268fd28406793c86643e688e011d7f4c0bea73a38e334c581d4ce872d264474d827ca1d168349a75ef8046a3d160f8da2062f48deb94db6a8e011d7fbc0478db797344db82bfd0b8cd5ad5082dcaf2a12f5e130a4aa275afa3e6ea893e74705059ee44e3acdd39a20c1502a29ee45bba7c411ae2369ad39ce65b10ee3dc80c528530a69c2b15d3e5c442640d12547a6cca7854a19a0f893e5e95cea882873a1fb0d3940db496506daacb4d95b99baacac6a9d1e5d090fa55001d0cd19a001c03cbd1cd2fde412229cbbfa85abaf9cd2938960e0d6dcc6d37af5cf0b056edd85a6bb5b539ebcf596da57a1363551fa86a65532b1b7777fbc6f278a0aa950ab55aadbb6d7776956c7a7baaa93d675962b14dc986440f499cc95e9c6c4f9b52957befbd4b565051955c41432ec10d97b3e72ccb122c66294e94ba74c512ccea50abb4ae5966594698a5304496a5166dbd211363062b495274dd73666506194cac1c69d174cf99953056b47c332b55665644d8df9eb32a5434616940228592cb4847820c461449153ac45c46e69922a6334ad018d1118aaa78b9280e3218417379db5745fa324a62e48a4384acc8e5e1af8a5e53f2a6e69a66a0bc70e49aa1612a7279de57c5a12e5d602eeffb2a1123b336c399970bcc2a83fbfef78f6c22463e22a4bc5c608c7c415489b9c05491087d45b1c2e4226284f322cb4d60ae490990f355b1e55290400a25971114938ba404407d55f41f8c2863e49a52e0f08393cbd349d1265f684c2e3752692da2d29f9545691554da747111f13756b481e332429b2081ebfaa82ce79264cb152e231e1043dbd048e4c2c0260531b88818018f704d4a00235b9926ae23faf572557105a4522a684f4cae3af2c0d92908168ea8d72cad793ffc0961387fb8ede2546a47ab5cf5f1f418d90955433c61cf900ff5f1ab52a97878787a7a7a7c7cc8300c7f7e7e58b0f0e6d461dcddddbda7c72728fcf9f1f171afeed5abbb7f2b5fcdfaf3e3eeeed5ddddab7b75afeeeeeeeeee5eddbdba7b75777777afeed5bdba577777afeed5bdba57f7ea5edd3f16fad361dc5bad5640aa162e5c00bd78f17a6f8aa238864463059ffbd00d5518a4220ad23060c4881123045285402a55a8dd9d060d1a34aead9486cf1f202090a885aa45a802c2d385d3161f510b17ef22c8d2f0c58b202272877beeeeeea5915dc7175f75afeed5ff5f14c571ac00dce1a001e80763c6a0313cc6ada0023003bb71108c1ad467850123460c13741d65c890419224eb63b166cca001127d90bf0d90c823d23a8cc78821838824594d44feac1b435313a9767cee2e43860c70877b24a88106f60542f0489205ee98f139050dc07aaf5e4a396c67ad7a33543342151d67801af82e8f78343e1d46d7a861e3d361b407000058f059e0b5565b1ed1416b7c356cd898b5d6fadd7bef68810ab444d7b1fc2cb0a0d50a400004f0b93b6500166f660e7fafa7503771b890677f8229b29543984f341fde5459f47ba2f0d74b6cc0e7a0748608c1ba298bfe8092f43bf0b40e4a27b5a3fa3014150f17180c96278b3a9329e44dee4293afd0e42838acc98f9a7a1e1084e6c3000e9aa8177ede6b308339f3260e03e283a99bacdc8180f766479f362e3562594c1e3e9f0f48843f04ba3836ae088802a9a031ac49112c870687866cfe0949f029d96afd7879ebfce416b4d431720702721890e7e2d36174e9b04d5f7c1fc5e10e03896aeac54e8a851a6db1c65edb1eea032a17a4d8710383f765091e304ca0dc69fbb73d136cefadf758079dc55830fbc2011833177c8863a685daaeb5ed3997466b6f81661b102bc10f3398d1326506850d67542d8011807d6dad6a5b6badfdbcf4b0b7b75b0b5af63685fdba98f12245972b33b60d2a427f1097372c8badb5d642e00a9b1fc8a0a04413319765b32d0d4cb605b7b5d65a1e2ab6657078c2d21d2c1026b3ade58264db143e0a13ac5b4f5b1888bb1ca7a5cc931f2d4c2b2d67aa84492cb4b489f93cfdac80e449cf9657b80294253c1a2835f9ac80258a2a4bad6705189cec24f18c8192d2f2a4224267470450b42a5401565973b6c2d3955814a31e578e909e662724151183cdb68c800ac7719c15d9374978928d9a8c683a0a941e28247179d223cbd1079cf4b0525466498f2ab42094f44821294d093db6182561420f2cb4190b5158e9b102d3cc032454e9a1a5287c41abc228ed527f8c1b748bb6ae93302a5d62c0f4cf9e332a60643ce99e3d6754ccb06054d4e87f2209a8c3708a538f2935fbafa9b899f23df941a414a51e5298286b4609fa1b018906f79cc59eecf2ff63574cc83ad4aab047512c07bde365c60934169344e33232aed0dc120d11f477264691d64acc2881b652b068d076cf59ec0d0d2ab11390446164333054d4b0e2031812642976d0b7948ef5edb5e38a7a083cfa57a4b4eead1ce9d7bab2550b92962d974b7ed15a90c8bea5f6eface307dfdefeaa7c071bceecb2b563fe1ded9ca356fd4e52b2cb9615cb1a45cf2abc2c6b183da8bf71c97fb9e0af2217d8afa8fbaa66289a7ab922dbbe46cbf1533ceaa840dba8af0dda69fb07e5f83a6b503a526ecf1e7c28da75fc1e47d125de5bbc567d774cb75b3b3e25e78341344d8ee20ff4898b34321ab52719ada98b15b4bb01dccb297b3bd60d1b59a35aa62a55d9b441ff0160740794a4a2149a8cae5f6270532af49e6002aecb7e1551dbc50aba3ed2a6235cd7e746d7b1ac62362d67354252b3983a2255a34b0be26a9a5fface1914a4edbbd47b622d82d1f769e6fe0eb97b08e5fe7e1db978701f73f17e13571b16b9747fc5cde954d11757746cdda0acfa198abea3f883067b80e01e95687f6a995021216be7914db4da7e22816117fefc9c08c32e0e7f16930cb9b8bbda461fdccf0d44bb70b9fd2a836e6fa305501b8b738a46b4bf6f969d214b0b33a8acb2cd3daed3fb184a5c6d5a4727f53535a6bec8ac20155d525965794f521cde7bdeac792c3fe86077bf4d173dd8368f8ea56ff781c49f925ee78d1d45a1b4fe3a16015344f54f3425b7c75f71fd0d2afd6a77c6983e904a47226030ad78abb58ea8ed270af5aa71857fe7552b20faf10864e755757b4fa5bf52fa459efa984c4ab45e478b7efd22740c2264d2666d7374e5fddc65def26800bab3d7a2c4609bfbec5b6d0aea8d1ae0711b29121f4850afc1efc421746fafc5557efdd3851257795cfda88ffa0df4d3478df48ba86812c87d8e48912829345ddcf66da8df60e77f679c95f58d1ba08ae8df54e26ad33c4f44f528a1e9caafebeac77dd42fc03ecfeba0358f3c63113dae7ed457fd4a35aeb6a7f4f5d3d7aa5f6d23eaf5afc447893b44c00051bd1e8910019380e94252040c109ed73e5f84877bfde1ab463faa2cee9fe7555ffa9112e1e845af373ea31efd6f8c3b5f448f2efbd28d94e019551c87f281a24828c93d4adc3eab258a46a2421388990a6b36f7f3a94c61082ecf8ccaecb27ed9dc6fff65af29c198ae3421e18c36f72ba751927beead134fec922e39b14b8a4604b235bba46b36d7c42e699bcd716d7e3a5192e3e85115a2322aa301ac292481356ad4a041b3b4942307498ae2cf8f8e4ecebb3651b2be57b10826b7a8b188116ac4930bcc7d9e31b210f5f55fe7f5a833fea847b2b2eadb2094bcf2c54214bc2ad3022bd22b94b4f6099daf104ab5a314d54a631b17c58a2e6952514c6f493c288eaac63e07f382fcf6194071786f3ffb0a98187c6fed27828077fe3eca1431d91215eab9625fe9cbb67eb4ad97d93607fc666390b66d6d4b8bbc310a25adee9cf407d3c6486563280ed302fb58a462a60dfb3489929ead688f8d3ea6d1db584e37442440c59a2362bf0405169c5ca8c713d079fb7a5ec0bd5d0179d44864b5414fd24b8f458cd027925ea8df19573bf8f572a5c6490980f5d7d4eb4f8d9f7ad4a7c62761db79c5b6938a6d8b448f4d1bd60a5dd2188d6d238dd531a6472221bc5e2e8d1a894840e9ebebe5d2634fd2ebf5727914ec803783c017a818b9ea1f71856f74fd20eb33463086852663a490418c511263f6449ec9e10972891c9a72600aeb9a5aaf67d4bd2426c98e729abb2426c9ae6e1a773767eec720d22fbe24263bbf2426c9eeba777edd2f8949aeb31f750ca85be0bac6fdf246d0b3f6c67dfe1af7c6102b070d1af7ea7b6fd4a8d1ba31c4dafe9406ae5af537b4bb6edbb75ddfdbdc1bf723508c8d7b8da449920b8a111463cb01b7a018338ef03c4a291d29c514079d94529fb5d66ae9acb5d64a29a553b4d6d25a6bad94529aad78d85acedacd5a6b6dadd6564c71688a81b51587b556bfd65a7b496b2dbec1db2e75ce568a73cf58abae14d56590a8d2c7b456d4fb9cf306aa06fd26a5d6526b29ad1445524aa9a6d4da9be7eb18dce1b8c3718763afbd1b9c6b3738ee70e824b79fdbfb06b67de72ab7d56b647b1b277beddde05cbbc1b1d7ed7577270be78b3783ca5a349d668a2f77b76ddb360e5f8e26f99005ee84dcc959f4e79eef50388efa255d12b2d0a95dbad3c59f76af7b3e750caee52cb89f1d03ee7a1b77fa28491fc438dbcf74733a42a716751aa24eee64371da12c74faeea7efbb7dcffc29fbbee918383939dd29a84a958b76d80ce99625f56b991b1a74dcd480044de726072414103ee47ce3061876fe9c6f78da59cc6c671c9eec8c030876fe560e5e86f4dc81e382366739ae862336670396cdd9a0c4e666376ca9810a8ebc51f30cf7c3be4928ec7b3f6c61df59d2153430792fc4c84c21d3b219b57e20cdae3448997de0f5b29d3d53c133d46070c0aa66681234c311a784b540481c60010509e90ad212dbb2b132c8b6d5019b5073c0a187292430d44ba749939cbfaf634cc0129a5031acf03169ca89e18b134f098cc106269d2a6452f4cd4ac830981743104b7009455d0c4d4eb825b21c83131dd8f2f8c304d92c8627273f9c182529e18712a6274b7e3429aa5204f362c20f136a33193eb0e4078c89862f84474d1586155186d8fa67519678c2e950ab42a638af598d8928706a90d2c40629566238d1a83d67525c8891468a0d240b5278505531d3ba33cfb7879a73ce7b875c107cd3af7f64eba074ee0952588ba3dbddb62be309adb3e70c863755681f353386d03c3ccc4881fe6ea061a4c13036c070820a309040bed1e0130d3ae584084767bc1cf900e648461e25bda0b4cb6f591454c7b9f33e300744695027b5a38259dae313feb05801b570e1e2c58b6305412f60c49041b266d0a86103002ffcf9eb59a4d37c727ad51cf6e44a5e3accab05ad00086000376edc20000ea19616d779a13e2f7f1d06bd5287404f7a2890e8e6b80e41206d732caaea8fe2708da4718a32a13f4a5677b7d65a6badb5d65a6bb3b515d7ca430577ef56ebc5b5561e2ab4bfb5d6da5ab3b5d65a8bc9b7d65e5aa9b5d65a7b456badb5d65a6b3d6bedb7b364684fafcb5e9775a8ebfa4368fffb41d0aef5a2eabdf782f7de7befe675f7d68c3bee5e226cadde7be79c2048543f08c869bdb7de5a6bad76c35d9e5d9e9823efbd97db26b74d8a290e71daa8b372b7dedfeebd3af587ca9c73cea04aaf7fd0aedb7b76ab7bb31f04590fdf6badddbe8fdb3008125dfbd9fba6cd41699dd40eea9b14476a47c5d393da51599e7b6f8f4f55f1f4f46c9e9d3d3fb5afcfadd5faf60189eefb7cb527fc6ab5f75a8b83c577efd517e8de163e55bc66399cbb0704614363f2e14ad5d6cefb7418c0c109b0b64934101f600eaa2a1929c551ca41699d8fc90829d0493d06a6902b391425264a2328cd5a5532528aa394da5165150f16cab55aad2664b2e867803a95f089762578c6d9743472a7692384c27b7cd8b051a9787eec1552850c096148085a488e1a9bb0874d0f143d60abd5f3c3a27ab9f3bacc429c17bc601ab88ac87fd808a9d56a405688650394f2daaa039ebbbb7b0577d8bb836ece49575d5544f6c694bd70baaefcd448b5f6de6de3a6e83ababbb5eeeeeeeebe7118679c73477d568cf3e79e73eebacef3be1a443be89c9808ccc9b19bee54965277cff33ecfc999f6fb9ca26a543b83b46a72dbe501411d46a374ddf56da523ce41a1505a6b9d21a21c3b7cdf0853a9d40e49546307dd2110dd2a1e90082889ae63a9bdd65a6badb5d65a6badb5d65a6bad7574f7fc5d1e8968c085abd6eed5bdbabb57f7eaaea3a3934aa5767676542a1511518f4f1895554e1e4a1d746010310407b90811471fde7f4e854dfa449f6a94299bc640a21ac3a2c1112f81c928c42177538de85315aa5b6a14c7a0569916d047a2f5cba68fc2941acb5386e90b3124697dfea49422a184e6508ae4068922d66ceab02f94525a4413344529a54eec1d4a2b0e4478e0043e74608511580e6cfaaaaeebba9f212165776fbbaeeb2a120f605ea0bd5cf9f1e440a2bce9edc3ed081cf6f6b38aed618448a20ad9cb8531fe376208a618bbac6184525396a61a0864455071c66e7f99d43cc984465f950f46cc0050c43d7387b8730aa625fbbebd976969df2150d8778811ec4b44d2bedf3af364df1fd27106cdbecf030d07f645d3b46f1a12f64dd3b46f115e5eba0a5da6cb2484d3ae2f5ebabc340dc6defd68632c44d3bb80440a2e4079c900b36d70e802b6865440a4400041800922ceb68fdbdcb80104961940f0b06d8e7d69afd76bcacd21892b650389364bc6daa06d6bb0586d34e55463ade5b66ff9d93f6ccb83990e98e101cbb64ff200c5b6df1a62b2edeb506261dbe721dbf67d70a01467db0fd203d3b6df8107b69df960c5b61fc20f4c2f2db0a23073b634c3b63320901cddb9b570a40993315a509064042c2cd828a4783c4ba66bdb33d8be3b3051e605ca832e75ebc60e4580a006aa103ec6586bad7fcc9a272d2c86e2e9c598374d80546113b226949a6072118e8953b452d3444d143557d46c69f1b22725b050856e62405816bbf23302a3950ce94aa8e689858ca9c86789a61f198d4acf12b05076022a3c163bb1e4041a27d4f8844e4e5025e1d44326cbbdf75e36489435c59459fac1060d0f48c491648e8a52aa906644eb423ba2acb9552119d9131dda0e19214cd03fa0e89222a326ca1346984ccd494e125d34193831d06210348180a6759862429b241d567852c44b87189ca461d241c624044cf88726b8a933a20967c491114959ebd044d1e606ebf006ca9dd8e2354a3fd630717a87244eac2a8c628a1f51584159739758ef1025ca089c76e80213c10e47454d453bc8a614a114bef036806025a9e0c3942f58b4dd7336850c8c351aef399b3233010833539a76a99f86294db08af4ef399b52c5192a55c2300446e0cffc16e4a19c4b3ff3d72f73e89f96b2c0df11756c624bac6298432bea5c50ce337bea7c39d3f89773884e447d8ef8bd8b3954ec6ce888e564431ff42270a744d47ba2fe1cd17b1d31e7679b0d72306d80ef2dd9d068a858ce1e76a9cb09c410bbd47ba6d99a875c3b3aa2426a9ee7c9947833a8cc479b7b8ffb12dc9c36f7a56a03c1dd9a6cee37cf0a4a72db6b73af83b2d8a5dd774baa4275ac5b52cd3f9f6e4dd306f7155ca14b2e4efe42716cb5fbdc7369e615b93493c5855c9c79c1b46eaa0836c7856073f768ab2579e8ddc7cf81fd5c57f46f5265713f5dd8c73d72e12d147719b11125b91f63dac77293825ff7a80ae1e7c27ba4b967818db82ed8c7d78fce09bd7db9955b93d1e67eab71b5cd4dee5dd034978f9ce2ce6883ef91b5770a4121d0f2a042add6745971ba3c178f0e9a73ce39e755b5bf01f9f4ed58040c10f2e9577b7f0392fc4b7e9109ae7ed8afbf01f9f48afef68fb8aab8ca9ff30884becd39e7d7599c5b67189651127c2ae2a2ca0261c4788d9594d0df971c6c73471c8c039f2ba238ba073f3f75af0d76b00d96dd1a8a83e7c1cf4e1487eac1cf6d288e9d073fd7288ed4839fc1cf4854686baa2c30a8829e9f3497d96036aa4239ccb1581592f1e0734719e87111e61e7c0c23638ce573628ee12d542897a12cf08fd0a08131967329682c679959a682b1cc91e3c68d5d724fe44ff0c7aae7ef1f71ad7a80d4bf2311303d4f64044289904fff882bc7385865818fc7b1c45a1c4b1dfe58862fc6f2398e5659e0932ec6926c31963fae46163fe1586a9fb1958f36f89e7f3c222e8395f01266c26828093ef9d365c5551e2fe043c6a7385815c2f8e9712dc44e1ad3b00c912345fcaa2cf0afc81d7134b0e48eb8a3a31cd59554361a734c2cf118d3250e017e55a1eda8b2c0bf9ffa9e3127bf6e4ca1679b0cb41da58e8e36f8d3458ad3c523e63594045f2566274a82bf23e636b94649f075c43c0525c1e76855686be26038d35e18a68b3608eb621b7cd8069f3baa421989b2c0cf6a9ad0fc52584667311b3cda60ce98c71fd4254397d1dc13f75431e69e9e36f89efd5a059817cc0d3e90fcd2d9bfecdeeb44164c3ae7c11e3963d206df836ec494fcde52f27b1dd43352ceb10450d71d73acb2c0ef9cd0b3ccb1a6a6a6a60d7eab0a3960b2c007a3d8e0e7b8a0e94ec494ec5e8b9692dda3c41c31487e308319043b2316748506fc493e08165901195b3f8b606e95df77fe551ea7cbe6d873a2714adbe8a82c1087f7f33d2cd6dfc0f74c4524603cbfe713ecc6361c5416f818fc2c967a83ba07fd3d8ce679b40dbe3375e07b97fc20cd20cd20cd60fef2c17798831a0cc1f73e1104c1ff3eaf29e1cda0922bbaad2ae4faf7a2269f2d5ed0dd779e534ed90f77d1a78f7a1df451e07ba223117d54163864dbdfe8304a823f4170aa9ad0df7bcfbd40eeb5c1df68756eb40dfe26ab186fb20dbe0b9a2e72a3ca025d1ca1ed57071feb2ab43df8215985eea3c632c49b2be262568d7eeb256cfa7acd765a43700cfc0625c329f404260620e00d42d8c107f3821bf49dd20c5c844d472edbdb0ea60dbf42039feca8c48c9a6962e9d08c00004010002316002020100a87c442911c87f24c14dd0314800d65823e665c401f88435192c34008628c21c4004280310418620c62caaa0ce82a27d81a1ac6c4d01061b5d9edcef91f453135597b57896b298b5c3fed1607cb8201197f8f5f0b436057a8d99f0bf9df4b0982c9d8a91fb0b66e869a4f43fa1ddd75ec69db3caf7c264881990dc6a65fcde8b6eb2fd58728b77d373a70d78b6ab8db30c1258e45eaa8e9bf1378e20dd0f39bce6dc57d9ee720f1fd0bf4ec72b18683abeb89f8ecbbde6857bfd033626cd43430c9911a89c73558d1ade1cc59ecade19f68984a28de704b00c86e1033c924462667a000997ad9e6656fff6e3aa9e4c3221c21951df47598f989bfb3a747f91fdfadc6fb8a6910d74f90fdc7cb2040a317413834047e19b9d105e45e54c75b7a7c8de76a4a3cb8b2b970206acbcca66c79930d6e481c8615bfce2dec4810865abf6c19f6a0c1c2a98c2f23c3bacbca2dcf7f44cf630c6ec94b5026011c8f8f599dfcac8e5c73b2d5dd7c505ab97fb19c9ee6409494fa22491750fde0fd9467f535c948f53a394e0a3fb5a51439a474a43ffe0da2f0fb6225beeae4d2bf425289b3d7d24d1411cd89049d38e1905cb5c1f58c5a7282a2aebb4b01a7f3cfcf1e91334257e1c78ba5ef2af4f6591ce6e3da3c315dd24bef1d6226f74ba6169fd7c5f7107c2e78bd0bcdf326af270dc269fa5692034440a399b139884ea4386b2e6f1818c921af102f9a4d4776d6e1dacb78121feb114e2da06156ece0b1294d364a6f9a945644790f06d10b189394897602912627164d109876a7d104b94a02d963b04c98adfe403829338635d40289c7bf7ec49b1885578e65310819420c4340b0223899f025f244a068b79d492266c9fcff60100068c9cf3b66322c9a0e59f6c641e7810e1f95b821c769ddc56ee1acf5984945cb94453feeafde9aceda418d5068c6ddd8431a9b2431330886538fb0b5f29e2cfb904739c92981f50ba5a8a09900e1cbf7ce45b53a3412d2199c79f3d73279ce7bf8c76555c28536b3115e28e1cf42d426884fdfa5657aa83f4506f8f2c20a335085c96c98e8c841e481cdc5f8e789bce4f5fed95e47bb40a8f0d98c2bb2805ee504f04ea7f02d6119965c5fda975c2f4f89a25a6b61b4201ea3aaa0a9a9f0ebb8dcf3e12b9c10b0b18ed82b3cbd7e99bd98d85ffcc22551f2a8ddb51e579d1c2839cee2b99994c7ff68af798c5550d55ebe53f2fd9c7cd7fafe95ef8b372883c2fd75f738a45ae9d2835979ec2e8472f86e2e9dc91b3027eb487aaf74b275c9bb45fd7fb93b914fc20c0163e2556e6820d3e87f737c6b4167f9950cd460687eaeefb159345275223f0d26ebc0348d4feccdb3c955e74251d4956a1198835f2549e842e1725db120c2984255cb18ae10a0ab8cacc0ecdedfc96e82e6954497942952d6861f9b4d9927fbbd06b62bae756af2d71b39b2891f5676abde8076e883d075b9e6df8bcb3856d6e558bfae510b77bbe76aba13ebbe1c8ea3c63af59f36c84d316917d238164dedec159226a108c8ba947c9c62a0c03014eb9c8d509ffa5bc05e41607c6c1dd535b1a1aefd55f6db9f96d7a3b4266d2eb39f69bc491c6705170635417c76f54703283816e6819c50faf07ce909da0355d728e3cee04d1a8a8918516c52d4e508ab22291c139e499378066fa2098da96ecea3b20d632bee696da3f856c7114bc00c7c795d6c50aea4a5f77c8e8668e51dd5269c2ef02b1c48dd6419f6cbbce964b8875173e27282c87f2e351353154d91a39bf7f803d6d3d51d912d98309669d2010b52e5839308a2069b02be7d3627223b48889c6cb50d6cfe56f7bba647e6faeee75aa747dae0c3b80d82a1b20897a22569a1aee7de6dec850fe285470d4650fd7ed5bff265cf56e3e0b7aa584af25fbca77bc576d8f8e320a50a595325a07b4a7cc9fe66bbf2e1dfc3683c6a8f769f2645cf49f1961276f04f5a9bc0cb9380747d1075107a28e7a5b6d071242cab1cb1e0ea9e3f70a6e4bbeba8fce40b75d97b52356f987ab24fa187d438aa92fc23803271ffe4d658dd7f9d4b4fdc4ccb8e39ef21b13ac9f116ea22bf08059a1029821fbea8ce91694f634fe3e20670d28b1805ac5bad5c52de942e18e92dd1950384b594cf9ee9db5fda8399a017dc3204bd8ca37c8f9393edebcd9fd887d35a00d06b25c7481116d85c65c45232f6495ad569fb53fd2efa112bea7534b0cb2d399b4caee03b8d601c6618d213f97632f991829a2d23a0e988a01184ada7b7d6a20ab748f24b75b7acc32c90d74eae950073858dab1ae2a47d95f83d02dd2e42ba19c89c073e8394857ff25a567ae5be5d255ebee0367125100a3d1895a5c4794c0679555eaf33c0f7fc85480836be9d8a913631f4c1fcd008e5d0d9df2ebc2d77959d0417b9eb31165b5bea1430194084028e88c6f2955dc9b9bf641c3a6a718d1c0ae442a5378d747440564a055d57a5e6b40dbd02471728212291f7bcaf2a6ccce8b9c4c47b03330427cdf29f9263bdc8cf8021c8cce00b28bdbf0af40bd2d25e6b0476e5eb662ee0ef846570cfd469589934a62d5cb8eb8ead95dd475c37147410608873b81452f58247c2bf07c80f241789faf967072df51961e9fc4b31927fa71ce272e5c8be516e761f8754f05d74b9bc8074ff31ac4eaf56e8985bdbd9640b994fef6feba9e81defd161185527321d3ea19f3cf19275ea7135a42da5955200b2a990c4d2e6625f8cb513ba220f1d67fd3fe90b28eda00bdba9fa161133374b3d69d9663794b9d60e423bb4f92222e3c011f1367d71055c4f9e49f007cd48ef0c6b59517c8d34f9cc2895bae29adca51953b4d75035c7e7b437a5619d2e369b310823f197b2411afae924ac4111d40eeab670594b05482e41417a181c89128e3595a6d09c0db69a6f9d5693a3fa789ae4c1265e64768fb4ba30d5f41b7e896c5857a57722bb24c2dc61bd42f36f78b5d972703c07644f72c2b0486cdbf9042177938bd4194fc2564851ce6342ad4d864df71fcc4d3c6755480c9a1ae1eff08b461d3404ab9a28d109975dd48eb47b23a73dc73228d20e0d6981777c23b0be501a1084d4f5cca8b54773e8c85fd612003940f499e88862c0e7e0b4bcf235a960fc5e925701b59e568474ba462a9ba301524dfe5bfea76bf83959878a77611885cb2265578cefea64cc9a2456ff9436bb136ffc38633df479f5325a5bd0587342436c0a3ac35da5f019d2f536810e36076dc04219cfb3ba8fd1fb3987d7c4782e7440bdb1b8eff106a67e52948bba04147c8cf4191cee1aec8d2df88cefc3ff8cbf5b353e4566453b35be6d199fbe7d073f90b35a7833bebb682133595a7c04631904f560f184f8b8240c30dd5a0e449e2db9cb5127c5a7ac0f1a70f57da79237af81cd81088e977d097e61138949481a1137b4de92edf28df8bb787c9102ce7befce19e382e5b761ad2d03d3b71b0887c05029fc4f7497ee6aef1cfb1ec7172feb4fa09eff82041ef92c32ec5de519defc68c2736e9c3edeee16bd2f794eebb42bf65dea99b110037f29017aafdcd7d91d036569bf32e00d8b7da8925ad6fe4eb49316fed23372c42983cae806b82a4f7cc58597a8f01fa84db9aefd1e48f975b892764ad8b1c3a7a9fcc9a27aece21e5883c40bbe52821d8c02b40981d6b65fefd7922ab78966632ebbfa852d3d724b27093a6b47824b0a6b0d88d2fadff1f5901abc0959139faf3fe39d1873be45e5fcb7ed134990172dedcad8e998158b2bbb5327e5a404d95953e1f51ecac2561767e18e45e2d0aae56a8c471d7aa7140f8086112591d9cce551e38f0ebd2fcee6ca0cf604986e4d1e98527302a132d103a27077a31d525c88986c67cf4a82ebf0bec430cc8f1ffe8f92a88c69672cc364ea2b5ae017ba9d74188f0c75acf22dea894fc5a1cdbcfd916491f296fa19c755201e98a3a190cc5ea987afaf44006da82152eac9ca23e503729f814944a78a604891d0a8d0729dcfafb6d58e98603c8bc8eed584fe24c37ad1b7c09658f982fb7cc585f4f8e7e637b3be7c20dc89702920252588efbbbb8bc3537f892a44958ce2719a15f1a5ee67e5b42068d8efbc16bebe6dc98000aeeb5cc297310fb464df60bbd49aa5265cc59c4134a009487c1c97aa94f53c318170df2f91110acbc96d6a289bf75376ea0ec600c3e52c5cab8c0743e878335034ec53ea79c790e617ed5ca5c6066885f1ec090f3255dee96b256f02e8f7d36fb9c1a476cdbfc23e3d68d2a31ab99fd207e6c60e5a74b6cadfcee3072e9a551c4118f3e28faf0be5bdebae8015ca5a829732ad95e599a9348ed881a992c356381a5b5f0df5aab843e029e0f24ef7e5b5861a0291b8d5a124feabd0d0c8591c19ccf10578d813cd4809e55b18f625f879221052f514ea5629ae02e7e80ff21f9e0f680cfd0aff1d1b821be69b73d9a34fc08cf43260813c0ff7a646541136e4394c5c584ee40feb07ec8f1def6592c9b624f73e47dd7542ead4b43b22b47c40ec1b8243ce508114229a823c2d9a8c8679a0c7133a05be73b83765153decb64c12d25895ede4ff315904d593edac9a0bfe41d5d958ca9c999c775e619e2af9d6acb34d2c7f521e11ebef4dcae296c28e304d14410664e6cc9ae8edd0bc5eb6d2c68114745428a0c29a69a5f0546b2d3d2caff559c304e074f7e5c6727ec59edd35216adbd139e32bb199d5837ed303550a2b5cb739ba2f977aeb92a304c20481c9b834e5a2bfc25bb7d9e547f640821ba1a82c5526abb8014898b0b5d051d9cb5f28a445e19b3a2dd950c01204f1c7669ae2131694420c44ed42cbfae04978fa5c57548acc773861715ab9c7f047d72420fa8adde633d1156d5497a5329dd6da7c2b340897cc030917c67c974e145fe28b04d0fa082f6270fcd7443a1dc948c9c297f66b40da218fa736c8e30d469189d5fc6675bfc5f9b5aeb027c3dfbe5df94c11f74226ba670c628ede39fc2e76321503e2a61a02915b098f6ed2584d053360e58a7a6a9c24cf8b7704ed642d943cbc97d07a992a1f5ecaebc20401e7a0203729716ba6b31ce7ebe75c618f998644fd9a890b581586d596240c7626a19eaf11c116e401875c37f5c7d880b10f92237f941e269710c77c07a5acc91de1e4728c5c4d89f07a235634e62f219f18efb3616102006a12c9f03cfadba5514d5a52ee8ef3e3bbde7c2c413a2146ce87e934659d4504f71b763f423ae176e6af2a606a6170f834f82346d632448cda60f28f874541cce70ef4136548a07498c113394e64a250902b398edb23d3a2aa588830149328f483ac398405be16f72fa02b0c214c2d2564c4f7338899174d7277ab2e2e81cb2aabb7624ba23bcdccb7adf73836718044eb753229d835c634dd9e04f1ed9c1623006d9359f2159fcffe3e4f5acbfe2e0f4a815a080ad0735a752a6b2d7b378c6ebbb439450d7d475eaba29ee3a90314475edc8248f814f88aa0701cfda12108a323942e5ffc5446ab97457776a384d1e7073b85d9e8717a91b9ddc1298f4221817d378a7f2f0ab05d3dfafdcacf15462448839c82a2020495d44204bc49a8fbff7f19000d8393c670b92f5e28f051a6fd336f00651d094e25b23325c330a803c32d013db104b79129954d725bc94b807d5cac913c61b84696ce5574615d9d5f6b5ee87ef037c3ae921a7477cfffb77e9e76986055f79479bf16e1c572bc58ae94842233149a8845a279ba6c67a8e6fd357c1cc47baa6257fbf55bea7c025873bdc1ab3374a3ec4df449837d3e841ce9a90055f78f5c05e9f5217e1437c09c05135d35e3da575ea1c2ff3f90c11cd0816a01ef9790c159b19dad415457589181ae8b42bc4c9235981e0d61ef29e3ddd9747826c5f97aecb0063e132857176e11030b302c1d3ffde49776f3082c3d30f3ebb62ffa322861e5a88b238c78d965621ce69d1dbfb1a5462893067f99452f2cebb646401be4550fca1e268fac4efdc31b1f9876d55bb6f6dbfdeefa8428cd0bf3a71e3ec12ca2d341395aff4e314650fe31dae67184ed130bf2417a7a1cd577cd71b3c796e75a0fd6ce479565d2f24cc1ce97aa276b2b9381644c5bbba4168c7f81147e60d5f0874ad8409424d7db856373147d036c6b2eba5c3a042d146cfacb30ec4663701fd2a437f2f8d155f3b8cac7947f0b226d3e25891cc7a5f2f7815e9ee68245c23ab9ad76683f27532dfef21efeb63b4288e29d8365011a4335e2385aebb80d558e598400ab5be7e43cd49d1be351aff492523477b50c6fcfedc8092456d50e2aa89245a932feef1c48415f849ec4259165bcb2e7e2b3ad2782b9998ad1a8f4eb0e1f2a959a2634d643e5ab4b0bf48136b810d205173c7799a3ce7b4319821926feb0c756d78f8486ffc99c46ee5756e4fdbbf15c894814c98a1d5346e95875166b22bfc010c74936f74dee4a177b3fe1402f60540d13c36700a8b44f7fab7e4106601b1f9e70a03c7b262ad83a9f9516a01e7c7f9b4ea9b7871970f8c35e35f08387770dc88e32bd6ec2ba924b91af8830fd36a33d0837be85db1113766167f79bbe241969656f848299f88218757d2509141648a25db98bab04bfe79e5543ffaa492f823fdf4adff6369b37bb93f6a607d73e534dea327536dbd957edbf298da5d7d9afedd156f54f96fe52eea7e407536053cf7129c1e982b8eab2538206b3e0ee40f81582cd970efd5644fad9cf72a46be60c6f537f10a6f688ff4a152227c333d81bda8244522ed828692b3362e1e1489da72b95e14c402478922307856c981ce5cca51772a8712f661d441d5126f9d7cc9b5d821395c7cccc1774633c06a7874c1227bbe284b8a0695582c685817749f7219364335e07068e9264512fb0ea7156be482e076aab1ff85b059a16a99732343d0c3f01b56b381724dbde96093f716025f098329b9dd7449f02d00a1cbaf7582f49e89a2c6347477834cc210947bc3bf93adf364c0e52b95a1c2fad7d8d46345a87b2d83e0b0c2ac7e6817bf6befb6f4552c4356f3ce9bab94e91c835c372da1abdb896fd86e1587567f86506b25ff1cc8137402724630d1a6e6795f0b0b5fd4c94b9a31a81a40913a5d5251b0a82f77c0dbf6f4375eed7e34d7499c9d65fc75fcdd5f839678c6918b015882cb57c4c74d030fd5e06c60661c23b3cb3e30aaee8bb3c66948f776a705da9db7dc6c89728a0716a7058c7ae127dee1c63d95b75324ab28f68ade867531222cbfbbbc7426fa6b245e29c0ce08c05cac466e8d6067f216604e72bc4d0319c93c69282a8325ee3973d5a56ff521dc0a62e33379ed36108e069c38247f2b42b3a1edae6fc9bb45f2648a3557e4280ff6b9209ab9c60821233e81312b5f372fe9de589d205a773c8043d33c16f8ef38462ed9c434624c213aacda13eaf674c20d75d712b4e992fbb2b3188ec9776a319147de8dae1b8140c1f7dad7d16869105dad409a0dd0ca53244bcccb90a397302fd208d6fc4decf8a9c147a7fa33800f5de467238164ea008916557b9a8f8a19c00bddf4aea3cb139f5f0743a83641b764917b8fa07d047d83609ebcbcc9ccdd4f3a4677b7e7acc37467afab81def59a09b8960694d199d0b62debb85613acab89ee5859b41e6f6eb891fce67b290289c0b33419841a70978da9e711a023a9da6941d5122660c84844ebb2b087c8eef95eb0e0ce5a8a1b9494f16e57d05c1e3a0fe13730f9c9fd6e026d1e4e5b68870ad0f832f5b8d42a691bc36db8f459f36c84bcbade7d19d89fecda504c6e64ca2ab9c710456130918899ea439ffdfd4728e2593fc80354cac56a517c6d0010ac764dd6818380ced161d6a89fee0ed9afe545dd749b6006ca89220c69f8f39daf7bde019eac750a129e1612de1c5b8b6da9e438898d667645789e12cfffb0dc5a1759c98fc5b02b387f833aa559310f062db5adc550a04de4ad05e7ebe46c7544d822dafdfb8782273c8a95c0a707babe9438f76fe5ab46335979328f0bf3cae9b4757b7f3ae364efcfd06a83122f0e81bd71a0cc22ed62e9614124125af12cefaef02cd343550b8860c38fb8ad0cd2d5f7029c1180c00007cec855a43d54abddb4ca207660846fcbf12cc9834c97b2318e2706fbb8e75c9efd4a124f2608bce7b5172e7dee2b8dd24d9cf1717a505051eb659b7ac3b0ec6990e77e3411ec89a86d7c106b21373d4f5ec6aa034e24f29f9b40a1575932636256fe1c2007a5a95db515d54f2351db807713e3ab3e81f29a723348b6e0a1cbd158d36a676f3c5da9f85ba3094f7bd70dbc2f824f4640bf6f4b210923f64c061ff99447daa9fab2d10cc8eac73d8cb2a398670bda1eee8234f747aa1650d2657da29ff8ddbb3ab44ca2bf9097bcfa1138391a68482f49b86cf19f345f81916a819ca3b504ecf853840ae4d56599edd4cfe61095c9bd03b69c75921c6f4009d04da38357c226212467928af5885c8aae60b3ee956e7f96046165fcc7196b2667d276980c4f8c51c143685fac6243829f00e7c90e63a59fd993261a1ded0b202e58c4c076be600272a364d229c1c9139b3426271fa5d889eb6522142d589a0420323c1e53559b27e161d9fe67d28ca80855b3debc04c6c906072584ff6c051f6c4e997c74838fb9d157e725d55ef61ab258aac8a18d1042a5cce74833b4e1151d3ecb39d9aa6db8a0dea13bda5854d8196b41c2b61cb0ab2c1d673d280615e84e2311557d97e542a09b359beabbfc494d45b810e82761c3c049487cfc648b7a9bc27c42e68fe89f2e23f3e28e4958e3083356b54fc04d1e5d70fbf034e0db313192aa688bf60defaa81a0889793e68daad33179b924af7ede6fb6f97d6a51b018e3af64dd9aff4879816b728e800f3acd2f2ef99feb4fa6f9860be97b95e9b9efed7ca5d0d3594ff73ae50f64bff6036a92be0c1097e08c24d1525bb1f1047e60946366840bc0c559c0c47716a2c79dfd095fbb35f54a57d0f2822777bc5a6e6783981ce89a55999814a31b83a05ef1f54f99910a78fdb2202088a369fecf5209531f46acb16648c03232b24b9e0245266e3d9d08268a59c394f58acc75b5a47fb5088b5f8b3d5a9602b4d6040a999a29864a860a4cdf84b6c3d26499c6ed6e2f71a74d1a7370a1057a65d25fa7bd34120cce69e954d4f7ed3b510d6c3f6e99fd4d24509bc9ab57929b742609acf035507574b0f619a431dba47ab9b9a61cb8b09f79c694c392ea1bc3271042e2c835aaf211dc2798c58ebbe15fc4b66be58859b631949c78cb0c22b42aba140d28a50dc5c55a8fa56705028dc1c044576a9546c45ecae16666dd4a4c8d28937d66d89d54a5fe386d07c18e924ddf712dd59f4563434b14bc406def999c7e9358ffdba647b9420f4e3191ca553327665ee7f68b0f6525774899f1fc840a49f5de96a5775990a1f9c7caca4e6c55e4af053c36b95a597f5c6a262c44ba364a551f21dc6d275ec05cf7a7b95d24ee44a02627283ed6e3e28202bb5c70d86bc83a7d8f32e2d15be65d53926eb1ac2031b0ff2c860f0ed23dce8ef2dbdcc3d588fade57de8514b067c257800fd300fd1e51f3ad58691b4d0bcbb549600970cdddda5acbbecdcc277e8f01bdf693869a4234b9a6cd216812172d705c8b69a73dc97c31ba0635f8d0811ba7b118b9aa855dc0584a02d2e5941ec1b749750255b3a9bd418ac5117c0c2f4e3b52f4092dc915ecf99af53d2aaddb94ba2d41b3bacf405d47bf7886fd3b5b0c5cc0582700453fb0a906e214cd35247840a12f344939f78e7ca5adc366d90088c01223f66be5110460cbe00f1e84a9128436c299f045500ecfee680d69fe14b27cd3418b273001b43cb65b4daac709bd4b4aea000e3ca8aaf95e8f60fae327734d716aa8d80930aec558bcc424bd2030cbfbd3707de433ba43c6122c014d63e052c08d0118f14980b576591afbc204ba19b80dc5d047fa7f7a3ff92e8df5da75460d85d2282bc0840f9b9f78f043fffcd317206558920c8f5295d520d88779f75436c0171eab692af86fa0ddc7744fe435522cca42fbfd081fea78fd7f6b984222219da97851bcec481d7845ce2f55f1c33bf6ed7517d949e698221c74a21d3728b3748a1f7ef0a3bb1cc917e656b37b2f55bf3061983a21d25889e4ec34a8784f6af12ae3d909eec0d58f730c2ce008d5d5f72eb9427eebd4423c0c8b61a725bc0f9a121b5b3a73c551f71bc72fa0cc90d2a21713052277e2eba3b5c253a8eda809aa671964a7426afdcad8e76005b37d918ab051f27dd13faf625cc0686923c385d7fc1408aec4fb0edd4a9db18c3d1b1023c818597fe145a0be2fc2d1e77be16de7bdd51e1ec88d2b0d859f3a9a1b85d51cbeb90c3961dfdba70952ba444ffaec9c233604976c382678fdadae4a0bae5b971fd85f5c6c6f38a1d56db282ebe3ef698c7e44b47212b48159a00c102e4165aca1e4ba0f781068753f56835cf8eeb97c578a92d0c020c2df5d9d29c532814b7e66c02d5d5ed9201c07843c4d8df519ccebcf0fa05b091b7b60a1884bebc103bae7a71251632517c153f982862cd855b904f70108efc6951b7cac2855c2bdf3a0658552a3f4336f473ca5bd12088fa3becbc8f05c1189d01012faafe0471c262f1af7382ed398134c41ea6a16958a786677efeddc8b77240862b30d07af6ade53dad1adb8d01fac102ae29db97e1d6357926311ee8a712f5b7f23d4353790a988357e13dcc119c5d9eae3d6696cf81ae24748401fa270dc3d6c5280c4403eec3d35125e8a8d3154f84a04d6751e00788a62af714ce12244a61ae16e8779fb231a014c71005fb58df9fb37cd0a916f49fae00ba77641461967b2b493babbf9a9d544d66dea97c3015f2cf04cc93c8dc239557d8503a3824878c788da8f7196781894b402fd8e2d89d30dee8a13eea62bc8bc843193e519dd70627b56a10a09372ca7a609d589c31e755900b0e11033a624200deacd23d58d5a261dcd289b5fec7714cc15907b986fffc9f48ffdc041b6707fe507a3b91d9cd15d74176e6963e2caaf777e0555c0f22c0747b275eadcc03560548278bb0d6ffdf9ed91624299f8f070246267dfc85eb161c05f6cbd9445c2fe0e17e2bf3425050ef35ba3cc0d74a55fe8d73b52feac3fe2106c18b0a8bbf02b207170cc541b61b829e8b958897ec7caab7dc79a17a886b5c2d0b27f69c29f458c6c64e24fc87ed1eeddee1b0ad699ae2fb6f79c664fbd7fa7bc9fe62077c1b5a20289650fb9fb9427790cb786720234980d00a435a097d1b7709e40f0e33b6180f2c56fd3eee3c7ab131772f57afc39e9d735edef9b9ee0d1ab9519fff1e7f6b24f685f8ed0ac01f199585590588babfcf077a6dd39c7b37ed85da08c9a4d42ec6112877cd25e793a398b763075bd44cd6aeb8a6d040612a5c7197da9221a1fad69d837c84b8d08fffecd18799f13383375fad267803dccdc461f53c2f255b9bfa28227f182224abdb06c128548006d3ccb0442d88ee898f13fa88fff7edbced3f26c8ccd568afdb6e481c9af5b21e4e11f79abe4da39c4ccb8961891f5492e5fbf0fb81f8df23f9fb3709714e4fe55b218cd035e6cd0371a5344e4ceba07f3404e20f6a0dfcfd232202345a7bc185cda2331b4e6f38f18db2b1ee94514234d9a4a412911a383a3149400793b7d64e4d511ceec5899d5b7d483185f47ffab1f1ccc61f70165c0f68e842e60eef4014fcb0bcaf6870bb9258804b4a2179b8f372818e90ea2cc5dd208031583ae89fe3e012c818ccc361b26e7a6a67643d47d7a06788f04383c665a7d71e424d22f206a7ddbe0e06169dd0e9c900ac2edb6fd67da36ace681ad3dedaa02b6f7306816e22891715ef946ca29b12a6a2f6a43b1684697740a0ca56261073dc15941cf8cefcd7760ed44d676eb9f6590d52a7a6ee80814fc43593a492d39cc9e6e80e9f85fba34751ab426703d33dc85ec262c751ca69326e6d4104192fd9280a1982f32af1bc0f43201a773374788be3f39d12ec031e11b7008733521a20f15f38e87b0be1ce2394f568bac2b3aef576a8b641267ac81f41506af7bdadb5a75ff18dd1c801b84128f733284e4ab2b7db5601eeb191b98ce5a23107cd0c7a01500f194df7c2627fc52a2b73fc2d955d66e14e6560e88447587054b8ba6dcea50fd3ecfd184388f7c6a960569cd2a4da0be53568e41a72a6e7645e1e6c435ff92804e925857e9f06622170510743db2afde1a329dd0953f27f5344afcde33181b6f010adc49c8710961b92dfa7cd2f55f2b0781808638e209c4c5cf5aaf94166fb1824bdb3c956444aa32379b79743b438972941aa811a527378863190c31bad24304fa9e4059e8afc284b980587683a8f14628b0711709aba9cc5af570870e22e45d3e84beddbcfc382d864324d9eb0409558bd437ca2219ade60228ba6b4b4ad13bc4de71568e492f8ee78f4b8ed1e2228bfb20e17920d8924446efa5e1a4f5c343ea31e9c0db8870fad37e4a1dc86f1618aac9a91a103d4f17bf8baf70a1ee61672b3faca04535b49093a155e38361cf78521dac54b70575ea75915667da5acf9e7ed2a453b015125aad9a8679137e696c4c947beaef0e6e84fab616ef04d8b0549e835aac8ebd9c76dd01dcf1024f2fe320a171f318be32efbda1c7582048bff3ec7196799b5b76d8f97df001e7cf9ab8bd33bd45bcfb73e6ec840bff3abb3979e4d2012ee291e3bca107030f2ad2043f0601ab1ff1be9c7654bca225b14730f6792d315542c73aead0c78bbe4433758363a00dbb3418007195bc1707b0bbb00861909a70cf1d5f3e51ae57bd428e793b071c1bb1240a7e3999ca9e9f57eec805de1c6d99dccf0a345e8c1e26780f32be0f849a3390619a89222be8219617044219a5e20f6c99c2024ace24db1f5b1c10a597fe6583de0d2657ad9024e0c14a2757f0ccda2329a077313a60aa4707da658e6abaed10fe94b078c625cac3c0e75b1be553179c424866f6e8a86e924f6c365abb22f4bd80d0b52d774ad757c231fe5e461f46312f310a37534873ba75162f6febf89aeb0ee1304bcd2f63284d9ed04417df1f9b5785b39b317c565096a7318abb0da0e264e77f2a28b41093569cea1a7b6001e557a9f540a3f26b094a110d0b94687924fd1dda3ab59a3c0138beb014a2ce2a39e3a88d69d98ac567cf394e31205bbfd3a7b406a928adcc6a604f19a30c1b06dc464d514f68029c2c7296a10ad178e9caa7e3202f2b58e3488a643e67b505017df4d11b81647b126653963c701e645cc112bf9015789b4ad71e6eb450e30a957ca0bc1cc935682503a6d51c79a933fc8c11ba37a1ee0941236093081394ad414e3bac384846cb7a72cf9b92e4e102b6fcaa288de03ca052c1aba40282f219f41b43b95d643d2cf0c2c5cfdb704b3208408f3fa3b50332e06d16ef4444bda02edb258ccf0cb8577824c6537389b8c4d0db14aec3299b84ba2165ff4bc4a6b98efe2ea6a38bc84b31f6b3194816b6bf93fa543a2711504cfc41b1c165641e77a718f310967289107bc231444d3c921540aee9b7ac8e3e9aca9b72ec18c266812a69834141bb9c70b4c99d911961e7ad05e7f28085839026f4f780f808fa168b9e236638584209aaecdb0eda555debbf4253825fb0bc3cc63502dc854cbf4341b9fcde7f2faf67070ea4b4b017ff10a8f45052e50d416b58a5303fc6c74556936682952093f31f119ae24bc07e7ddf3a6c2d591a85d96a0fee331cf5ab0ee6e9a30abbd45814d9790cca5fda88f586fa09568205a7ce078d04c46356dc96865a1a15c3cc279794593521988d615582e0c3940a9dc9f37927f0fcdd1aaae0960d36df722dfcfb02ee7ae0485231ae9af86801ce4a7e35f3d3c6b668218668eea9419d2581f1e52a3bab9aa42680e4b8ce2f06a98d7cd92b42ab46410e58d2443064c60e81200b38016aac53148acfc9ba6a9272c8fec5d3e852d0af0eacd018582a007be737edf271901d1ae642f903e319af0ac8eaab754e55de24a56b338ef2fea6a20af7e808ada3c78eff9ab3193f11a4a138078c66531b0053b691b7c939357bf3bd7373e9bb316934e6f00d13a0e488ff57a4a3f68da70e302ac956ab45028908d716a3b98bde9e9444f4a13241afdc42a457cfaf7e4f00be92e45b5864d6785102881d525fcef67c7d7348eb8a0da8e415f6f22cfa9e398cff8780d12af751a08ea5ffb8dfe8e747f2d6b883347f8fc3c7a29b2d9b66a59f3d3a8cb3649456bc206d5e301c822b7be430de4ae6a7ff214d937cef4718477e252fe6bab45aac5d1872ba20a0aa53f171158852e3e1959f2ad3bc7ba5b63cb3622a8f996dc66b5b71cac32dff3c363e1c8ec309d586e5e6e8144894325ea63836d56882ba1553a1c13e153ada13b49d0adc49accecaa10370d5bb43357c8bfb8045d6c4d105b339f76746d297d07ad8f177dad9f23596a6ec75b74f6fd692bc95a29fb3139bb200c550b553a8e371f7cd1b06b33f5e308729eee3f417dd08d3129c9bfab52d32af84e57d117aac2d839422a813d7f68471cd87d322d69c729aeab06aa3f56512d8e11d093bb84ac765670b94740e85e656168a3a6717d3aa9d2d818bcab86abc2f3869f0c563b12b048054d8369f16a08ead9d75ca920c769cc6a7315bbb4094ec817622497ff1865c86224f04f6646f899a13e8da9717133ee6c6bf830c3ab4fa90f328f55d8faf5f445620a9ec07261c74b05d34e11b4ba631f5cc14d5b1d5def056d978ac35a7500be44962c22d25fb878d333f6c13c3c9c5c811c220b83fe976fb2deaa8d980535cbdb565aadcc907ace4f6121fd6075cacbe7ced5bcac5c7cdf1b6f1230ad67771ff749bb994dd91c1f19eec37d33355ecf6ca51b49ca0baa9906de2c4f2dab6704f74d9e1965f9aac5ac4659a5792b1cf6ca60e818e8d23de1a43e95e88c41a995c90ecc0ec22a676548ca6ee6230a153217bda9dabc71c1ccdf6aa967b62d7a8753cb0dc78c835b3df663ce7d700be6d90b55f4037eee03ea2a1a910f2e511c1da3342727af92d5fd7ad83b86fb6d5119d2eb6c9358ac765528273b18d831c370f8c3e626966a13679469b41d4ae427b930049649565a17186a368ea679e37c0fd74c5f55eac3641ca1f2a0c125c37cdd22f12dd3639b7674cca3d0edcef440ee648690a69e96c9018d3c41f19ee6e6ef68dd1fa71c7fa7fd6a99cd04e8e66172e282bcf9245f4a6a8c0d5840b26c57bb6e243b95e9395c79be7bbb75c47571bb83f8fec0de3e0b37c33db2188838ab67a4d388893d58b061aba9f0721ec167f248cb02873e77d59752682733eb3436343aff1a76ae51487accb15b2c6220a157b3538bf8048c8b1834e9ed50a6415ef771dfeca20241815efb838331e59f63fbd2efc3dcf618755b0e8b6d4d0d6441c5dbfd969bc3adf3e1b8bfbf5fd4e212fefb093474ae278e7e9e46eee3231394815e0e962ddc696417a9503d8399310c459f1b1eda2485717544a50418b3174954d5b3c0c30284bd8ec86055be15949821fa22fdf7bf1db0f24ab324ff74b4c9e92b623f8f7ccf1759a534ed63a88a8595530909456e571d3bd3d7c6505b28203ed41b341a5ac67fc4fd82c184ad88bf903cc33adc8d0339008c1f2b8121d908195d2569e4a81f601a0d123f1b215905a717c9d23cb568716b0b7761acb2603fc95d4eb45543e14b4c295836cb48ec97b15f2411d5e1e285dd057e3636def3bc225ad757c23362aeceae3f7e819172297f8073457bf8c4996e52790c0ae5e361b6d563b74efb22c153de1cf75cc075856c86c40ce71bdc9a3211d19654fb457f06c64bd34d5e0cf30ce0b224a22328d74505ef2590199fa8e894d3b285f81384428932b30a644411ee61626db9ca111369c172c6fb3cfd09372b6c884a8e8cdf6c3c8b6c80800a9c42cfd4600bc0817079b61f72312d5cb32ab465a5dd8df1e6f13e8455eea31992ea86041188507e92cc6e7ac90383a25c88741d19fee86760804340439e724b4736e90879cc26e3117b1b96bc78a91e9ee562a0c48012c6f38f0950f8f2797ae61acd7cadbfbda4dd651b4fcf2ba87fab9b751353ad772027847e67d033c4aaaccc05daf4f8a736776bd890c8e123ef3905d055d072426127a717829ea04fd0b62204f25e12d48c57b13a8e7463309c83cc3c6d620413e95dae059ce24692a98291891b102fe314f1352e0fd91499aa48f2e8b444edcdaf736277db2d09f80c98adae794d534de325101097ba05d739bd7cd2899583b67977487a7a6f3e0f13e25682760dfba50295dd0fc82ad3095a76292056a66a8c6cfc802019a73819e0407164aa60b27603e3653a45c93407c691a982c9da0d40902a3d0f683523fa6cffe235e56b3f2f92d4c7f77860437d64e30a09f490a5d7c70f39db4b23c8c5a7f37ad5935b9913e2e755e8dc18477a03ffdb931bea03535e136922b1e514bb0bc97bcc948a79c063e274a61cdd7cf4dc9bc1431de207f08d7cf75c938148886c47e9e988c100232ada72d6928c3530ffd85eb6eb0aeadf4a9d7be23039a88d5eb8aa6707c88b0f5a9067ce15cc62905875cf42859b1ba74c2ddb36dad5c8622c229ddd1e4174f239031037e9a7a4e0a3947d359292c092387804039cad6321936c9a8cdc17d993634817d95c1a5e4bea3bb728e60da7da5ad46f1f1f5986542c84eb55328971250cbd649408bfe9896314693c84d021bc7da0666b257ca0b1cfa811478e5948dfd1703746c30cf117f848b40f01682bbf7f3fc7b5c5c16919a57aeea9e124a45418e148ed721ba7c582ca6d14d560a9c7c71ef32f8e4f9c9b7bc9fb99d9174c45bb238a879c75bbc79fc76704ceba7258af664177211ebfd66e11c8dfd2953b87e01181a17658ed3576d572ae5b42b7df366755637108d4b431dafba62aacddb46efa2bf82d4c48559c9347305823cd5b8324c56c923b13bca18b6e1ba1ad6347ae221035b9a83a5f27b9bc1ba2c65b8aca4d36d644d22381c4baaa8d0c462439652df63e96449b96923e70c15e43254aa89baa549e784beaab4e9061671b648d24efe7b3b5ea49d21ef40eb5e5059612b820e0b89730db20ac5825057eefb25b86cd2792eb3275ccce960f8b10b0bec0020dcc93610bcba5a0acb5e135c67f3978570fdd739a0fa6343b5a43a14d26e4ebbae0ad93553dc7a6695cade9f034fa3b15ebc838b587f78217897327d8124da372bad0143fc0f063d3a02f4548343df13c5240ad4f0e0a6ccf2875f2b7a18a4c90c333aade36b3596af339b287e90f6ec749941718019b0b6dc4ae7ac0b968741d6783ecafec30b8a87e042a6ea9f53630606a1a3c4d6a9bee5aaf1d4a979f41f68c40efb236b0fcb172ba10fde5289ddff7ed50b763c35e5075ecf6449414a15bd606d616024ddbab3454f940a64b958acd85684b40cda3b6c5245b38422d7a3a54a08083271120e65fcacf4b782415c2d21ff034011a120db5783589acc177dc67694864bed5713e4516db58264657a600d2bea9fecce391912439e7b2fc3c3161094e8639b46214edfac6aa178b49550007611456b0a17bee73c1b55cdb1ef155fb7b5d9ed605964c543d286719ca4438f2071480450bc0c1cd44bad920313ecd3f70f6f8d78f2a1c5b7bf2c4b23bffcc05828a5489ea0a4b66e8190eec9120e7381d824cefdf9792495bf7fe1a6ebeef23c6af070b56b5e54cde44b7e507115a8e4f8d1d4197fd2ab7b8795bf701831f1bf0df21b3beddd2f470765a529a23aa8c4a755cb3d898d39031065f6e2bdc9c60894f12d1b79e4f13d23e79502775abfd15d54a42c59c48306ef79fec4ba76b191f4f43733fca00514d6267367a057c42e5578bffff741ffcd0c79201cbc0ce3045baa9f4241fd14809d5f32bc178bc709b6c7949394efce4b93448408059bd4204ed5cd48608d7287e692e5e8488765302fa504ccd65269f541c01086142f4a715b6a1f2fb1bbac3366d91a6900b3750e681f015256201e1173a2e6dce48bb83c114cef2bfff8c564b3836dbb0b59148274c24a041edbbfc4ce336e9eb51391ab30afa1e62d47dc11db58aca8e872fa126d13eba3729681e5cbc4b10e5faf32a7e84b8362d155a7a16f27af5750e5d223e4a004870409f02d4255973875c533f4a78b0795e813334319a7a3a4f36880a86d46f99b76b1814803f3279343814d8f980e5513038ea0f0461d9ad718afa5dfe8554e34711a00621ea67414797fc1898a3979297a8bf04e502e119fcc73353deacb4c6e910ef8ae2826767fdac30b9f4fb26fe93cc1512a0c1c0f055335f1d1026ab425e80edbe137c42759755ccde3a703fa7f8fcffe0eb0f9219bb9d2d571f9219b23711231eb48d6421e3e6cd57e0b1fb99473c415df767618026d58a73cf1f90054c681c31988ba9d4a013e1a1cf8eb9015a32c62d117db16f3e3c7424b52d8f75bd54b99d9ffe024772c10125658e814bd67e8db2075b7f663cbeca7b8b96573eec67ecc241c2c5c7f3c1e837c2685b5e733cb21201712ed0d9be67702c5f56371444fb792f10d8df6cf3b28b55b950f98123055f97c039883102a48760b25efe6c70c94ec7a020b252fe3ef5e5ceed9877973f1d7d17ae1e301dcd44822c72128ebcf149f57163901081c0e5a47a23556d88ebf51fec757f38b87fe6f68cc34bd29bb36fdc77c19e01feb061c8437bba8ff1c1c9cb8fe77d6b0bf9dd933064f2804c4635e6c7f36afa1aad138523e0e8c15d5bdeabcd68ece9fe4c06a4c98df6918dfd657e030838eca2e080443832b0703d44e454e09d0acf0d0df27e43e3f9df0a003f05d7b49102d63849de00803d2527b285d1f4f9f87d2000647663846af838b513824ab2576ec9d8e7100f1745eb3ed4fb4796142245105818d008429ce040c2376fada931a490f225c7297c58f0076a00f88a2f8c422eab67fa75cbfc4ca40be363d91df1f92d49b7bef20114aab86d3fb4c91852e833d73e64c489e44fd2bbe810f1d534e20bd7cf9fb276d0a896f5f3ae506a84d5f2831ed0c9de277079d310440f9cc564430e97a541df9188fe49b9abd8a203561e77022b6dd1ff96ed6aa883aee6f3ee00e132fdbc8c4c4ed23b5e7a1f052a803b2f052106d87bcd8940e7e687cbef6e19a72005b30762d84e37c17fe121a8846dd9325ee8df5e60bd5f30c0d3225306ff6227f06d84218debe3ee16fee70f24a9d0097a4913ac309f619832ded87858522f90ae60a84e01f592455ca38ae13ffcedcf3f14b3868fed29e7c405264d143e6704477c6824aeb2cee72d7cb8a22f56c9922b4552777833fe331cd917635534929f51768dd055ba8ab053eaff83c8265dcae994cf52b99478b471e97ebafad6f13ee52f677925e28c1742cd36baf0e61d85658e080cf5c26b86363a5002a4d535da0407a29ac5b5f8b4d730632f76e0c8bdaaa4873602bf275606813f53a82552aa44eac4bfd1a17d4639dfd3b8189643f464803781640a224b54bb3f0cecc8acca6c7196be52cd47bba012201af5a42e40d19e6f014617aa3f6306d8673ffcf12ecfc3146676103c33d41775b420e199f9a5ccd9e69f56532ad56d2f09da9dea36f59206d65e1277618b9f978836342374875ff278439766893276c298271612655093bf8df19fa8f5bea42e94337b39792813be84f84f6d91a7c22f52a86eb9605871f3d1a975ea41f42895826568bc51c4233e059792c3e9daabd2439c0e343543bef3afec0dada24458e63e369c6e42d14784b4d3d0f1a801d9c1f4d8d9d0f1ef112d1e96f5a188f9be74c55f00b8cc31466bbc07405d72e5f0907bf6f05a29c7c60e0f497f7ab2342f9d14dd82bfd0a7ac63767b27d7cada2f29aa7c7afd3e4a0745bc14863c4e973e39679bb1d016d8fabe7fcc47665810663c078ba646cd126b2824b5f2448f194d765f22bf6116073980a984ee51966eca29ddebdeb045b9d09198af0f4b427180960e4429870cbff7054e9ac0118d663e7d352393243698f55b613d8e00965438fafb4e9f2756e80caf90243a48d2b064ad4d9c443c77e05024cf84a68bbbf69ef0241d7f04fa566cb719ec6c99005a9ee89032eaa23d93f105b0c1f4ef96d83d85998efe6918bec970e158f387015843fcbe7d9fea1e748ed5ca08c06868f6649363d86100074b6865f508af811c94247fd87462fca1b5c35763e21410c705c4b1e07cb081d632943e7c1e3d4f2edc22d698e85ac112592740e03c469a7fa8875be4d92dfdd008549ff60408f9866ec4c6e9128ba031c18285686c5ef6fe31f3ae5dba8b746b7d0ad7b2f7c629fa0312155759620ef37f4bc6c349c6b46087f91fa31a4fe51583f1138c7908a344b937d0c900f058aac9b2dcc12c4e90c093b5630f462fd1a8ba4cd5251a9d91f5982a24bb3f9e8b42a6f1d01401625535d7afd9938fd84ad2701a86c81ad463c49b869012f2c9655a7a22d8a786a2c1748dd295fc289ca0ab2fc0f80e16956048c51de8d5e1720a6b4c2ed0a824b55c7f1bdae0cf278d490f0abdb350c848b88992a9e456793c853bec5d0b3623d693f65e9d12d0af4fc2519e90b5e978d3c9ef0a28649c16f6609169ddcc044bc877e50e9102a04c0570080bc99533890e0c2fee72fc7bd9f1d2ab90d079dec7fb12b43a4a0579c7cd26be8cc968659dec653c3132d026391bd139d9f9efb71baeda2200c77539cacafd6dbc9d3ff142a6940b87212ed03900e936498010f77580b62b52e6e22a2b74dbdf09535fc7e1b2c33d454b61f7fbbe9254b46b58924427e0e36464f0985de1b153adb9ecaf06b007a8dc6c5ab86e7d76c266a428b10ca65faaa1127bfbbb8566f29a697fc3178a3a9938d202ae7480f78dc79fd8eea2d261a56c17d609baf4fd5195443db72a9902abd4f488354b660eb722ceee9cd58ad881485ede5314cf48955a82d44392d8b511dcd5d7a6726b4bcae7825808c704e8a880c892f607543711c43a360c747b486899a22a731940e582c34c6746e476873e5d6ff2463a1ad7a4d266b7bc4a63843701e25d4ba789ec91073fc655f2e08ecbb91f32aeb746a37e1eefa5347ec160912223fcedeee3175728a220d08b2c314cf54569da8cf3f39032f5eb6b275c849b066f0e0ca120c41da2907fdaef2ef627e0d12834cd2756422aff55bd4bb116f5f0dca276489db87550b1e38ed98bdafecd72869bfab0eaf7d114eef5e337bd7c10b9f2c69d6d764bc7906e421edb6ed9c9ff06f58e34bc004901784489a71e00ec1d90b72819d3b55f47922a8ccd7d4c9d4f7f36fa2a196cae1998c99a9d123743b57110d0e3fb0c744bf894287a627230b00a5cce0c0db8add0b690d1862101b07e219f1e4ea5eaf4ce0cc89f65f88f078c974926819cd36804291b8cf62b69056c365ddf717f0864b46f3c7ed7e614af9f295c9fc7fe0eb3e2101412cd38fd9ebf95a7750c7ad60683a26f876e69e33a03ee7887e4e2e6e54dd5d048244aba73607e410c7ec899cd2b7b50d51f75672e90c143c63f575e644b1d6913df6930e21529778b35ec01743d95c099c76f14ed0ee6ba80b127a25697f5fc885cf6f260d299884730fdbe5e7f4b51c270b9699b5dc5f4f8eedbc5fc85d33cd343d455c3daf0300a6dced162ca522b157b3d90c82354a9778ba9445d89ded62704278e52beef9f95e7ddd25aba3afc7e47f3ee878de91ee837acab605771f4f5b72c1afa40b76bb8635310d56a2bb07a99820bf686a34e5c8ccc230c8b4a9b91e46a096dd85e16ecc40e97e19f0959846e621a4b72e5dd38104012da037c10d8c2993a94960c2d60b3bc8d8a09de0ea1e7d2b40b26c2f1446e7bfe41aaaa1878e1da14fee86d9fe51b35c719e1de5215d78868229575f5fa3b849c6fea86a2a04f9acfe106ef670e0459d044fb510424b82d3fa3ed586a052cba5356949103e945cb4da21c0ccb16b6542c2c382ef5a2935a1e9fda1451ad5907f10486f4060afca2aa4aa0aff201a49b403454d7cb4d29802884986baa3ab96280878763b51e197ca4c659d704327dd8a966c10e969ce02af81411f5968e58490de59e730ef83dab89a3a123fec9cfc8af360e27a961345dbcba8f78e322cee41079ea15628b1c382e9f765e17aade169694353d0956d87b0387bf9494f6c3881d58ca9b9558f0bbb18082d4539b747675368823213d496807fcce060c3efaa8b5b5f6abd204ff9edff6c6a1c0584908cf483165a98865e785fd0a96556c27d708bda67b057929d6d4d6913e9d64e90838b92a86addd526a9fc0135d4c162f216c22c0779bf7b0e0086e014258185b8c2ca2ddbc29af6c7bb2f3f39fc5e77680c6e0604467256477245307b8367ea480bec0c23b86a35c937717f30d3dee87a46283e75f5f3f78c74071ea2764f53f66b893f123412be41b12f8efcbfab0f48dbbbdfbba5f899d0a27ba656ab3d4f16532372806f5197b9ee60dc89b69711f88997c8c745e08fc4d9eccef93a7cc31576ea9cd0670e2e017ac84a8b2aff23b3b240e54e27046cd469a25cd2128838e8bb54a218ab7a09e0aa409576d8de1d68c30228151b86ae33a215674cd059defcde2abd498c71fb1a9a2a1319776391cbe97163fa15232e47d7c6508756b25eb81563c12b17a3477eed186bba073571c1e766e54bc79ec58a23b7a7f8d611ff75b081659b59a4486ff4518f571a8123c6545d17b200b75618a7948a703b46f375837b33f3c810b53758ccb5a76b2859709bc23da25cac032c4153fe1f3e1643018b41e733f285adfd6c392ae62d444f98100b6d22b8c3240d21ace2d1f71870eaad62cc139208548d7739920055a703de7bb49818faac984b8874c9dad3e61bd2414f95ea476e43a4f2236a65511b430345e4eefca155816af2bc16229f41cef905677a5e786d64a790bd1b2ed61698b4f92a040fcd5a896a2de9349739d5b6ad2595e028ab0ea570b21ca1c754ce95a6dab084b4a70bf18f2c1953d698770708b1c42def9becdcca4c06f3357205460bfcd901a1a0979c4dab3bebed5bdf4bfb2b7dbc968adfa08879f3cbfc96a285521c4d8fc553eb31dd84afdf382b4f5a86dcb40db0adf644affa4387b996601d657647be5d384801ef5d841da65c3fc065cec94b333d5ad8a03b89db3ec1c4c21232bfa899cc079ff59df4fd78d7216386b88e462fa40c8ba7b4a30e61f0f0fc8cc4b73cca3fa4eda9a84de6444ec58e6e338ec1747fb15ec40afe8643d325e3fd6073017f0855ab0d994ff728fe242112aff087133da467a437f29c96d0f5a9c7d5f3e158a7c9384d10f4900f015dfb1096500586da61f10183b49188971c27e24aa620a564c2128c828653981fc5e9f034e52d9cfe6c6e222d50c0cde28d2206d19f723a42f88524e7b98b9832c45bc4194ee070df3d9081639f5b91a6811e9cd52025d2d259720de8c4529f311111d911e2c0a6bf4d5294e2841b819e5d11b043d4b0844f5d6d4708901197b5804f4756917588b02d97a18616f43e1f88658cfd8a863a01ec49bc3c8c833290876039da4b4f7d48d68bfa6140a6e4c22f6503d5b15a03bde980d07cf2cf6a4c6cff391abbd24d494e7201feac8c3c4668fcf9565a18622682be0884ad162589b06f95c288ed290569cc527e5425e31d2a5bec58b53cd7ef507840a4162e3be4184a3f496f75049f55a3491cf8b1a1ca017699fa910125cf93eeba2bddde17604152f9d368bd8cc334130f94bbc70f88b8ef9178332b48f8a4c38f60c21778c08efaafc4850e0b819e68b84106e6b1fb2c99cecf181dad6aadc3db7ee7a84efe5d0c9d42dfcd1696a2b7d0eab3ebb258768ed961395576d5e84c958ca2112623875b7d998185b5844901b6a1609297410753f91e9a94361cb1617ed19b9f8e272710a1ed0981102a04540872ce7765c9db290be76af87d0efb2b0aa928e85a54be50626b6181b9ba7526a7d45e4ae8aa828d91dd917ad32c319e5a0850abff1c4c8f2d690a0fa46d98c299e91131279ad55fefd96a6031b728589c8df4c3e097568eddf76c40a6cad256d3447942e4b0218958d2363b3c38ce5b6020df4ccfa1ce2fae3892b343aa84251d1ac480f4d218dc481b3d23c49036408269c428eb5c399b8696bc079662b0c143bc562840b41829860738d3ecaa3092aa46b772cbebcf497101da277be91c042174423a6a7538368083044c27453a7469c5b2ca7c35001de8b6ad60d2abc0b3015a1a2aea46b71af2f0509e61201830f9aad4919e75c0e9aebefbf58ebb7605e942c6b210cf9129b434b999f4074a66249975cab3c23e9dfb30db820d7e629bd8d14adfb0c32bb144d2d2fa066ba613c699c469b90ace8e6d38040815ea69e575b1bc4de766023fe3b2b842a1a7f77532539d992f880725cf03767168c21ce1f4698e0cf5888c255a297731c9756795c5cdea96f97e6f28a741e310dd0e841eeef5debeabc71081ae5cc119b4484b5ac841bf61cb3da27b553f1db4968ef64379c46149ae56159243910f9c30b14c9cd1e7196a4d5bf18950333e8c7622a82d9293bb4e615aed431b40d7cb30132fcc8b4fbc68b361599fdadd228fd701ca3f44a8538487150b9a543190867d0c3b91bceedfb0156f4b020500a02125aa8a7766662a41a32fcdd3bb21a58d94fb69470f37f7e43585b0bb5450c0c9da0b88e40df21e3a12e1b11f17e223ef98829854290c5eb9fe265f860c3ec79ebf78a6921dd743daebbaf151922babb4d43fb80164937be03651dad2692c996fb81bd8ef6cc7b697d9dc47b3282a07dccc95014ebd3749bc4fbdeef468de8a5e9653a27464b4fdade2cf8daa1acf0df840266549205902376a65f295018b5aab2637a5362076aff10cedfd0d788b503bd09413b83b476e06510b422d825c62c3870dfa33aa514e4e791f3b64e293f3451900e98c5807c9f844cd57607d89eebbe71a70b85197b206ee6c68f243809488281bd00ee03758334d8d1736c74e7de7c46c1227f22c4273ab16a1f4423211550f8e96b7265af7359478ac550937c86cd2ef4f3cc2cd6618451f9c5e8c01a879223118ff7e499711cdd1f0731b70fdd7b5739cd9897498f716738b038863a50b25f5c6150c27c5536615ebf828578a29d23adcf516f836e14772f93ee6bc694f69a845f91b3bd81333c97c907c8c885822518e06fd035ac09e05a7a3706d62aad3466c923578a5746c79041029f45f99f04d4fbd003bb6805de9a8576002867b3d4d4a6af0197734baadd2ea3e903aa492167acc9259f227f84116e45d529279031316f794cd529db374cb3e59917da750ead0f3b8e9b68de0436595ec1a214ff3d37dafcf1789c65998c049722c5a4d95db7065f97b69a7e5dd57ad1e6ab7f8af21d4d5f5dc042aee323187c7e4f1d82ce11472fbdb1e2f978027dbd16940dbdff59a1eca22147fc79cf57a163a8e877d8723423e27e6c6eb13fd7f68a5ecd9902e38d0b9e6866cb01c3bf9ab89bf3160ad2dff4e9bace58f929a8676e509a2bdaf6ff9fc27a8b78971447af602f70e669ac636e62d715b541017ae194964ae5c2dd7157a8572f2417c9b89af50bb9370e87986bdf96b52e2ad0469dd3db86bea32df576404da3f3c1f5a085f7be512b24e0045e11393be74f98d2660cd5c94589360f152af1cd8a46e4320d1e885204200994515879d601eaaac3fe8c518bbad5b893b481fa43261a3cf89e14b9e3b8a928055b8b53ceb6b5e86bbb20c76ae3d9cdd002078952ecd4b89acfc3465320d6c75a7cf815dde49c3cab279fe8624f8253f98cee7519998059f6d514bac27adba9fa7b99ea998a6ee41b3631b906c532d7be0fac9f2ed29c31c99e9f30edd132f8df2650e7aaa162d21e2c1e4e2e9ea81c6c085394f7b9d706adbf5d3f99a0147e9ac7e4070624bc6add5b9f21eea422ecc48ae550b27ff94322d174b4e4ece165ba3c02b75775a746ebd046b870be555d1b636acf23b9ba4a5d7fcc7c297fb6c17356de085ba43c28208d1aef0af1488cbf65337715646a7f23381f54024f8bb9bfe387c422362ce92af0e2e2de5ac1a84f75137cd7c66ea4052981ce51a173afa843b8e7dae610622f50c51756e567645d189fdf3a5fe0fafe1d2c56b11d531d62679f10c61df024814dfd95524789ccb24469ce1280760a9bd26fc0754a477b498fee0a81c53ff1cb26ecb5f33ddc867d0fd12a41c787a5c5919e0f25cbf221d67be6a12a4b05adf4dd869befa1ea453723a4dde1e3796f2aeb3418d33208b9e8923bbd6a925ae94504a98c48b7d6127a84cc4141a5161136bc54d0dc5069af5416d383a8d12783016990d706720707f85e8b4aa178a726328e9d5b003468caf3b8cce020dae4c7196cea937cd1170f3a4049db8906257e6808ea8e0cf16051474aa6d5db0df643121c991cbfa7c0291f5591b572f3e8fe36df0a72cb4b6d9e69db7f32a1b5fa21f30a99e7742c2ccb4a1c850e19cea7e11c394c178d5055d15c0b490cd15980b97082a1026438dfdf962f14b49edc5654f3ab2a972dbbd0125e324691b711cc37b9de1445ae644f02e4a618a70248b3232afbb332b58508b7068734f523b6cf7a49211e2be59f1cf3bb2ca8b77f891d76fd3fdd820ff9193a7a5bf067e39d55814119920b19a3a8fdf5434fcd901b8565257e60e404ee02617f3d3565bfcd90f0f16a3538d20c002a7ca78580f645b75514ea4bb5076de34a1a8e05657a89830f40db422bf921d38aa287489a3250d922ec8e620ab0414d48cafa09e28f54a24ba82ba30d37174ef53ab0249f3759cf608797cc14c1ff88be8ab0580b8639eb8fccbe8d4eb298cdd5c6bb4d6473024af389685110280d6b3a39d3395132b120482b223f1040bef91ba9a51f9fa287a49ba5a13fd591f6bd88d3743d68a7b9300a984e0790aba471a66ffec552c23ca2fa118d6a5b987910706cbdd69a486b7bef9da44c291e06fc063b06313186d8f7c3c418d42cc5c499c730f39eb731a9598a7df8b11e91490d8d09bc813071e63dec391613675ecff33c94f0610fbbd94c883d6ce6f5d82eb4338fc77e3e3fdf6d5e4e9d836a937312a15ce0d7796b42a75befe89cec797cd338f43c7e3d3c1ff2bc4b64eaacef1199d42cf57c90c8d43dbdc5d455624f55cf5550f3fc27edecdbce46a82f7fe622942acefc9bc6d7ff0c0afd7e2ace5c54caf23df84da38b09161969e8c811f5f36a967c9e3ea55f7f897ecd51a7599b4f4599a37f934e3427f4d3c9c70728eba7be8f8f9028b77ca65396a8a5c71f91871db25ece66f5f4fc4d6e053d8f413e7f9b4eb29757b336e98ea74e198c424bf5652293ecd52c057d159964a20cba62da216ae95148ac0a9fc7f06fb24d28cebc6f1a6515cff3c823ce3c51290b4379393983d223fd1ee9f37cd0579149cd6c845a79ceaf6d96ea07894c136ad6dae480ac07e5e5666dbe8fe5599b50558c21776380bd3883127bd8c744263533a5fa24f0584528de5698383ef85085c33139c9317c2cf561e26c89be12cfc77efe9134421ee7135c94d8628b34c418b05411479f8a33a5faf4617f9b57777a5ea278ac17b35ed4accdf7aceefc9b0775a78735e57856334bd2e64472f3363c6b722a7cc970b3a6356b73fe043cdea69607d4e452480bca44dff305439995eefa7759647fdf161b0c7b4e203ae1ad714ddabf67ffd30fdcb3b945ee98bbb9bbe7c82f94f6b21074a3adf0e94d2ef2e9799ed771e9ba07ddbdfb29eeaed5f99c1eceb1621bd778e6bc5c18267415f8caddf89c2012286bfce0d75b1d7716ecba06251465a2972ebf2392329162cfe3b96e0c24047ad51b912bff25b6d0f7babeeff55d650c14bfd7ab07cc049e87895866507a847d8f30d1a98e3cefe46316d86b01c76623dfc76c8f12b6e4238fa885069e11f672f45eeffa91d9c8f779ef1788e27e1df0142d6575326d3623231aedffc5535cd77b52dcaf0396a222287a9ec8ffe01b0aca2370ceb682f2211441d99c70b6d4bd7f27fe84e2d177bd7bcfe36ce9fbee3fb1136750bed777e26ca96302bffb9ec7506acddad6ace1a6d3cc9a35cb238fa0e5f1850b5fce3557de239226614888898a614191b34979141027e02c9146e825411b13fe98f902ce0e428408792e4fc1c9f2469d2ac8d00a3206196974e9fe66f7c7f31596a5e5237b240a595a0d4ac1acae7a66387966e5b1362734ab2bf975df045dcaf3bcc5988d62939a6058c3d8e7dff74d30ac611873a344886be8c8a51131024274a402b18542624262f2f2e87a8c6c7f934878a40271a344488c687e3c5fa50dbdfcbe3b12abc2fa0eecb67d31900868439a529425b3d6555859ddf7816f5b625465456330269ecb23ea9ec2604cbaeffbe6ac9d6d09cdf57d0814ab955e61dda615c6e4fbe073a254ad8dbec21ac6c21a86b1ef0b6b18c65c9fb4739c9ddd765fbbbb7bceecce53745dd775b3737767263289a6cfe95ee7eeecd2dd6b6766767707634176a89c6efb6e1d13cda75fdfc9cc36afbbdfbbe77ddff7cd2c14fa73b9ac9cd057adeefef96466ee84be3dcf33a27d9e47f43d337722d3917ddeed664fe8e3c3fc7d9e6ce3fbf9ece705d5cfab554be8d03c2be4791e1da5363e77f7aeebdc3bae1a92a9999e85c215d84c347b78320fbdea6ee544ea935851bcd9f9fc1f9d4fcff33c22666666cff33c8fdff3c0392de3d073cff33c9b91e7defff03acf3dac28d2ea63a2d9c373cf9bdecf6fafba572d71b7799eb7867d8ee7795ef53c4fc9ddf0bcce465d22129d7be7eedea921474ee75e97eb72eee5d49023a7f39c1a72e47877c7ebbcceddddbdf3ee4cfa72a7b6ad7aec2a3933cac509b5867b97f32ea7061b723af7ba5c97732fa7061b723acfa9c1861cefeef8634de66e29bdf33ed0f5a2151663201893ee8576b88e3aa52831295a563c55575655c5b2b4d0482c8915e4f323036b4ce94a46c124546df3925268e41ab906284868c7acc7078ba1c059ce63636267cd28a50965a5d34be2244e268331f15e36c4c34b7229f06f422e3f90ee8582e72098211e5d7dd14a5f3c916a1f4d79db73b7aa575de5790ece32b14e43d2e4c7608d85c5a4f301c164566214b22614d4cccd35726b4b6e493bb8de9a503cb69f62ed641b06eba86e2385a6d7f41a1e3c66104827336a424da85966464da8324ab3165454b7fcc5a5eda6bae53797f65475cb5e5cda54d52d63e0d2aea2bae52e2eedaaea96ad2e6d2baa5be6e2d2bea2bae52d2e6d2caa5bd6e2d2cea2bae52c2e6d2daa5bc6e2d2dea2bae52b2e6d2eacb8b4adaa5baebab4bba86eb98a4b1b03d52d535dda5e54b73c7569bfa96ed9cda5fd4575cb545cda6054b77c814b3b8cea96a7b8b4afaa5b96bab4c5a86e33b8b4c7a86e31b8b4c9a86e2fb8b4e154b74a2eed32aadb2497b619d56dd2a57d46756bc1a58d55ddda2eed0c54b74897361ad5edd1a5ad81ea16c9a59d46757be4d2de40755bc1a5cd81ea96824b5b8dead6c8a59d55ddc62eed35aa5bd8a5cd46c7e90ed4366ad835f937effa34d28fa113dbd857fe38f2a3714d5862608241022f5c89800b10b0f28016aa5071000b2ba830e5968294063060010a4800020e8082010a70020106608200a204000a00964a20610425114200e183271e74e08483264c36d060bc4b32c0e0022549922cb0211d2139520105468cbabbbbf316a28798b28d36ba8d968ab9bfd79d06f6647ef77d84950662281379defcbee979a02cc2b48e91684bb848ca2ff2dde9b74adfb93fb826ff06263523c9bc2542cf13c3252c9b4598d6305b9df0f6dd298e725ab594cdb2a54b9fddec9cbae1b9d7759f473f57d7d53bdfc117ece592b4a63d5c84f2e7cd8a48dd6354bee47c5a292c84d5a758aca7613c62b33b9f863c3ddf13fa589f9e1ff1c7072802a09f20a2202021219a50d08e1db51d42329904b21d43434386643c7810e131349b15cd78f4e831418f990f1f457cf480000223087cfcf861e40704ff14fc0f6b2bb02f8a47441b410448221089888e88220002040908519020b620408408b14048101a2d8926a4564b52a349208112096a43865c304402cfc31e17ea2194ef44ba6ebe5b90c890a20c8a883c4d2075e70445628a4c51640228a30b1815f912ca77235d47c59d6f04340a75a0c0df29303255010554472aa802c991aa232456201d5d6143c2c2025b164916689124690b2549b8b8408915061774910106185892811777c99bf17ea1c108c6061a84c16483ab264cc4e0a0c9184e3820a30327703ce8a08c271e98f1c1933340f8002b041032204208682889a0811194d22061840d94400207964a5003004b595000b04600a0b0112500710410458e0902e8c0004c6883000370e304026815e084370c5000385030c09c03a0400701078823010890430109f0c00214b0c58005ccd10006d491d2003a529062e796c207a6dcea50610adf5941051c0b2bc8e0001666a0e2001aaa50c9d242951a1ed082162b0fd802012b4e2e40c08608b870c395087079e14a1709bce0050609e0c004430e31306189e1cb9d4f9bb0e8806bda41061c981964e0818619c264a1414c0d59a0b4d4d0c3162d639cb690b1c1a9cc0d36f8c0e506335db8fce0a54b140e5e80c80187209e7210e2cbd3103a7c39b3830e4480d9010d0f6072617828424c1823a0c41cd103549a313da82133660265c820e1439935667c48e207331488faa1024044b1090208258408c2024308b1c49921da107186093444349143e34411b9278c28028a238c88224de50976e823604de6953db8b0af144770cb59344111232314547004c91192cd82a4244a2ec020832577d46003264d3870d281074f3e00210411944620a18425004009401401983000029c500003a07000042440010b604003a4a4709ba2c20a2c38804a95161e6005022e44e0ca0b12808129062c4d8d6b197a86a6a1b3740dada5b7b453dbd0373497eed25e1a87cea19ffa4bebd03b3498e6a1c3b49886ea1e7a4c93e932ed439be91f3aaa81e8205a881ea2cf34118da6735d441bd147749a58db400748e5f3db7e5df03ba5ff7bf01381aed755a8dc29ddbbc0fefe16865ba1fc39e9eb6fe1ed34d7fbee4b6cc1656f54ae07de1c67b3d96c369b4d4a29a59457fe7dd3a960a482d17c158c5430f2e20ca83be4f294196c5ccae35364bfdedfacb838658a3f089dc856faca96b31bec9fe24dca7ee3ae053333b333b3333333773a5871d74d766766eebae7ae73f7ced9d9b99b13092396396d8eff9c57d8b123478e159e2a030e381f04255127250fa919d58f35c5c645b174834428aba494a449299e73cea9a933da14c599a2443690352997b8a8c2284a92f644d82f9334d9a0d1cb967064514654196ba8c018e2f6b84cf585d4a53c332597f7f425fffb66dfd366cd639a3f452699d734be8d041ea9c87493f9df6cddc86307fe1229edecfb28b3e67dd3e8b2b34f6c81041e95442627de38e37f5d89b3251c55c3429b20fff54bf3ebf357f92f91a9aac55907dff77f4fc599d2eb674bae7fbdabc78631f95cbf444a291ceed266ee1903c5f073d92bb3e671d67cba220c2eb25c0f4a1e71185b9491483d4e0e430b2fcd9def69bdfc4a61dfd4afc6c5a57e98c8c4d474a52a8a94ad2b27597c05fb259e87f53ccf7be21253d087df34de786be61f7b1ea59db9381b413eeca1f407f7d6746e3fe801d9858aa83454fcd0c595623b95e924ae1cc2ef6f2bb6e02e1839a693cc4ef2b054124d029f3c37d9fd6e61d79bb027733a7d2394ba231df71ae7b3ace5f4cefbc029394059baba653d20112e92df31618532d1cda9cbf61dea896aa8eb346957234e727d4f100c4399ec1f8b6fe7248df62f9365792e97cb45eb64e2ca2a9db0b0b0b01a8b7e7d02c13094b9aa8bbe948934f4f2a97c1e6b2f264549ffc65b208c8a4d66ee36f5584fd3794a79c8befc59a59bef6f9c45c5f924aba4d4d02f99435686269c35d9535de22cf62c4536e2a409e34002512130e8a78707f6469c247b17dd41bbbf4929100c4399ec9f8a4de49589b3cdcb29ec2c4993bf43149508c127e992469c249b8986aae20a893723d7f5af9732834420d187b3c450bcc9c498787b176751795d4fad1117b9c4998b612eb1c9bc3723f7c65946f6d64d5cf9df7472dd1b67dd8c48ad6bc4d7ec90426d384141444e6611071c4f23953858a08ed448679d39b8913a9809e046da51255181a7917a5a4f1880a30b2a46262c3ed6185922c122d4441d4ae046ea22838e0dcc31d217951719a81a29f522aa0aa79156aa3590801a29ac8a306f9c461a0be3ccd59b3284c88d3484b2c269a43d555a5983971bda8cd4a74a2b6f0033d566a43f55daf6a2c50a6aa440555a2639068e54165b231316a6630c183a46352278995822c1c27696787a625433457653278bab910a0505350b0d6141868badb1a9b1b49c5274de2a7ffe94190265a2e99dc8d414b03343d588e5cb1a418944ca0b8437f082b3366b73fe1499769041c3184ea38bb44e62ea08ac91ce9601ea8ca7715a1e5b76179f349ff2146fde688db4e1ecf0343a9189026a6434b49863cdc85ea8c1658db4ab9de53034f084d548bdda5926b6620b17592396971458d3ca664b1dcf160b6c8d1dd8d9231ba6781afdfb0ec8a00b041f9c48af07c16f4e127611f9a078035d6e6f4d13c6840a757710743d88f4025dfcb2409dc4254e9d51c575f166b3048d3450c1e1264c8479b1dcef13dfd288e6cb3a21e850d0f1191599e01675443ca1cb433e095c354a8309e1711ba4c72d901fb7444111ec1087ecec7dfcf80181f511410f2033213c6a6e8786b89515b9dd51c4ad9091ea3688e5d1e74a96cc9a5ba0fb592512897c7aa4bafd71eb73ddf6b80def74cb93d434a9b36c01172555b754092f91ed16bc605a2592e6d6ddce25d52de0a20d24136fe2512d0e40f75707b5031813ff396b375b22bcd96c4be4b741a844d6a407b127e107defd810f08402108892053e2e1a30704ffc3462012050122a4469380c890a22213185160a40224478e6c481624495282c10519dc25e3061a30e1a089130f3a7802c207212889304209242c410140000410c504020ce0040314a08b1214aaad8b94038049c182ae262500cc6d0164a634a08c0af24b8187156a2b619ab48069720aacc9df166d6156a86efb884b59a86edb884b1d50dd76119752a96e3b776995eab6d15cda4275db445cfa80eab6cf5c6aa5baed212e854075db425cea4275db415c1a81eab681b8f44a75db5197be50ddf60f974aa0ba6d3397c250ddb60f973255b75de6d218aadb26732996eab6c75cda54dd760f9736aeba6da84b5b86eab6c55cda3354b71de6d2a6a1ba6d1e2eed2cd56d83b9b46ba86e7b874b5b4b75db3a5cda5baadbfe72693b55b7fd7469db50dd760e97f60dd56de3706973a96edbcba5dda5baed2e97b697eab6b95cda3854b77dc3a59d4375db365cda4fd56d3b5dda5faadbde7269eb50ddb6964b7b87eab66bb8b4c154b79de5d2e6a1ba6d1a2eed30d56dcf70698ba96e5b864b1baaba6ddca5dd4375cb772eed31d52dd7716993a96ef903977699ea96ed5cda3e54b74cc7a56da6bae53a97f60fd52dcf71694755b7bc75690351ddb2072eed20aa5b96e3d216a2bae5382eed21aa5ba673699fa96e79cea54d4475cb705cda68aa5b7ee3d2ce55b7ac75691751ddb21b97b611d52db771691f51dd72072eed34d52dcbb9b4d554b71ce7d29e4075cb6c5cda4854b7bcc6a5bda6bae5ac4b3b89ea96d5b8b42950dd32072eed0a54b7bc814b9b4d75cb695cda4a54b7ac814bdb02d52da371692f51dd72062eed36d52d635dda4c54b77cc6a5dd4475cb665cda4e54b75cc6a5fd4475cb702e6d28aa5b26e3d28ea2bae5312e6d29aa5b16e3d296aa6ef9ead29ea2bae5302eed0b54b70cc6a51d51964a18810a19618a4c0385301207ccc1085c94c025acac586a49c90acb8c0fe8a787ddfaf77137fbfddc7d7252c7493ccfef7152ecf93f4e82d5245a39097c7e588c87cebff99ddd9dde9ddf9dae3befbcd13b937c7ebe9c9c14fefc0ae3a4eee7f78909bfefc702f9d820a11db2211eb31e3e20f8c145f6878be48716c8060971917c98ddc145f2ab95d9211e5c24df6567b6870f2e82808b7e70513847e8a325046f70ef7c6e3e746df5d33365403f3d56640f40a1191158055cffd9e38621c82008be3b7844d63e6ce3e9b072b281067707ef6024215c936f346b42180909c968225da6f20682408420d8b91e04c5255cc27ea3b9c112ab1c6067c8807e7abeef6fb0ef6f3c975fc9f79c844e9077f0e922f2db0235e9a16fc810280c7f5ad18822b04cb907082491be9f3d74a875228f1c4ff4ef867bcfa7dff7cdceeb3a6f4eb71fd0f7c942300462d9114a248df6830c30743a5dd7d3764f2783a083a1ac7560083e4f36e19ca1ec3c91e6855606e8b5e7303dd91e967a267c61044366c92c999925b364e6efe9f1f1f9f9010262212166e6f7616666c92c9965b62b0b7213e4e60aefce095f96b649abc08856011f3d61da74226936224fe4d195bec2e16433f7a4311294ae4d6f9c6d2d1c15a564b9137410fcc0cfddfd7ae715d40ae378c3f7e5ba9e573d8f525707e5d2939dfce4d7e5acec48a4be0265cf798393389136f4ec2b27b0cec2ae14abb4b4aa566b85a083134b6ba2f181adf9665e4d2bf06fd3ca65acca772b086a69b95c1de875567ee12227a943c3d045dac0a38cc2418eb9f3a5d60eac500d23358e6bf3d34469219bbaa184e2ee88229c5ef0d1f7f367183c31506792c1488d9bb54e72a58b4c99a881099b6df9ba6ed7755d57ab7ce224d95ab62f5b29054b279836ff4a27e9ac2e327f5291c4c69dbce5e562d157f24a369cc6126d17e1f7b7bee24ec6401cce09c411e1fe65681cae03c12f8cf5f490c964412ebfd86f8f6060da1ce2a32b9236e9874a12063e4ac2b4f936499b4fc5bebaca5aea22f33bf1939fccc9237927903b5f5ec934241288c5664a4581bbb2ea4e09e7ce29dddcf99fd7754f9ba58c755d8fd2446aad247cd44eb491b469158b6959595ddd97e5d13949def93fd2ba6e8f9ab07b29a5c4698562ccb0e6b66d20b8288876828fca740f4c9bdf4e5dc79d6dc4937438a14c82651a4e5ac349f226739cd473e7576935919eb8487e895ae2f670e7d49a35d87d59394eaab0b55aab2b623271678e8be6b3010317c544ea37e600e74f2d31c29bcce5e60cf3ebb84eebce032ef4c8c3febeaf6777cb29a79c5e85334ff7e979288fe6f7ed5726692e0508ca99c691c031c8e5a90e7820ce9bb0839801e68d335371d87ce1431d5f48b065482e6808301b000347ca0d38fe812b26cd89ef14bc9812238e1c3b5e9cb1f3459d26a82b78b89ac30cac2b92703a6850307903079c115b561c78c2ebd47e38a18a34e83c3103163f40f91cb20f813a1abaaeebba2ba400e38501e99b31a8cc5c5dd7652a33767290800b194d703953070b0d0c31856f8121c7240386902cd8042142881c5f1c088c1a0f12c82185a03d5138b2b429734689ab37ee8120564c2068524b1a566feea06163ab8c91d11b2a36535084e0652a3650c83ca1cb546cd0b02923ed0ce94172d18137f241f9619b3754312e6f5c5bc891f2b6bc19837e3d2e538959e2d2cb5462d208d1c1853b45a46933831923d6c861f485c75185c5962f6e8ce12285865167bbec4ebb42cb04be2d5f842133a9c4784165460dd7130d5da6d222cc7d5da6d202897b7ba32e0ca3967d6c847e792a8e5518278b2f0edbcae16a035dd6b0628d71d28983c5957d5371a6be08c3e9727dd3f5bee9d20f7ceec1e3846f078931263227c021ecdb5dec56e13bb7fb5825e2c19e4c97074d2d806fe5bb9ee73df1264d37d9c47bffe941d3ad12abdd7f6114c19dc738893b30dbdd93bedb2332a4e63fad4c3e99dfc4e7ac83babcce05ba3b0cfcacf5afeb5ca0f884ef5cff2a3ca5bb4feb60cba9efbf8f69a44d63bf27ce963cef9bc6177fb5209bf0065e998f2542975113e1105c1c2da5a858d162bab245e3d0927ac24a85b3a54fc9c927ce48e0d1d634468d4c3d766ed6feb6992e428544514d59dd7e6e28cf93603a2bd75abdb50667e6de9a4e63cdb937994576612c293d89bcac89227a0a2594952c2325a3726fa454d59a36b989c4e3d8df663a89ac52a68bf4f3982ed233694796813374fb659544aa61f5d41c3797cdcdb1e6c471a9141d32edb3c7749996c2658143ceed3702967ca8040c1d28a95388460000002011400083160000200c0a070422911c04e248177d0714000f65783a64523215082391381848510c84530c432110c22086102619320ca2191b5000fe119b2f79ec20e98583a718e11691fa39be5f84663d1e7d5568c5c2e90c46c61fc91f537bfc407132d6e8571cb37ea078d81a85a8fe08d532b182b5998d69013d9c71789771c5122b9c17527f21b526f5b4e6b465ac4ddf395a537c3198b9296b86b57126b6c05b3df56f9fd74c84817f9900714e928259802658f5a4ff6f9541ad2b84f154e13037523a695e9f2754a5deec90a13f335a901a3be75bd0f54a724f810c69536d4d04212658b9171312f131e35024d4432e96ee8ad01704a843c4b94703ab55e0588fa1e8a38756627c2b9605bb7c5a310961b7cc6c6e78494891b7c06226f1df093469c07ccec0b16e634ce30f42f44c659e1ddcde70e4e3946f8b495d6ca37752f85236b222e838da1db0239b2390acde82ba8f431446d84acb558c7d2889d50fa64209075818a604537fd45d2ebd4fb748845fe54049309847ada679d79a6003ddfe933419ef93dae1aa41667381343252e3fb92ce76e1491e6b7bacc8b7393f999f6259c70412ffe03d4f3515225a586a51d6feedcf6c36189bee722c5839181998b5a1102b6e411e603f7f0e7af2cdada2827c62e90268448bf44887012665473272323d353ad65e207044bff3b76984da6a5584a625ec990dad613f477212189e01be8c37d06c80662b6d2ae4e82c990bd296c850da2f6ebd3ee6b3229660410843389ce78222091d201fcbce0ae0a4e77d2e330c15cbf9babef1e4c62485c2818e097c08ae0b90b40c5a02d552c262f557b55b37ad1f6289b77dcc81ec3d8c4dabfe0870de6b9757b0a7cf1ad492d8001ea9ce71494afe960758a8ec0a4d180334b21db9e049b1be4dac63e01bac7ad1c96e2154ca89d4d63d0775dad7ea88266ddd9921ff03235860c870cf35dc2553f666e9f5a1a359c544021f178fb55e4fb2af9a357fb5049bfd32d771df33cf334f0fed50f2e765404037058271620e6312754c01d375a736cb9e2d193ea3fb8e1776a82a5f2f9bc248828593022cb73661060810d2b1ed123fe001af3340a59303ba729ce3c9ca6ae97c74964e9d87fbcdeedaf805999ba5a38d6a3507d9a0d81f747e7a67b1cb4309e6bd7709f4b39176940d24ef7bb9c43cc8c240fcab1be31190c652caecbd84b3ef5f8c071c7f4338422e878481383f05dc987019d0232ac0856628df9a39c756dfa50b696367b4da19a9c14636c2d64af06ef86828383b3810c10601af19e6e9e9a52e632edd6502a897339fe73e4ff7f794598e517d9a8980d3bbf67959b26054563f2c0a90fd2e6caba6eeac97811db36c4df002c306c30c50868753b90adf445a62d87c71b5df90056e6506f3fa22b9642237c7920c04f2ad66a1dd70e87efc0e440b2b37748938e61686ebcf81f62ec716c6a449420785d09109fcab8211d1932523a47fb19207ff60e606f1f0ab329a71b13a23da45c5472f9a860dc1320e71daa154cae3e1ed0c26f0cb99c080e91e746fa3f99c4781d35c713a4b8270a16b712e3424e1e4ac969caf2951c96bac26d3189f5db3db9b95d41d4b0d9c465954e5a5a369035256e239b3153a57238a030dd19885b3501f60d45fa02b4cf21e2c4079808dbb9515fd47f4894987c633d1ad70c06862f42decc13071533f2c63a1c685854cfd38493f6bc9e5349b871eedb7e815f5e1520a3f31f6edce2280bc18f5922a8a170b152a5624664c55f1bd2a8c718590d154b03d03371f2f34837e1a926e954fb68cdeddc55ad52aea3d67062c13655f44d7978a1483347967030a30163b86a010ec9a4da939b3b4cf66d5ccd293de65caf3be3f1e2343a37fe7fdf05125815cac8b55ce2a431633010d481c5df059d2be3de0718ec276d215b6321612428f87c7c4617cf6b56222519974dfbee97734e52b1a3890401833e45f2f9fe06046cf8b81ddf2be892545fb65119d7887e95a257dc4ea2640d781c59ffa767c1e10be6fe4da8f33798c84612ffcfe3548d501d4bf576bbdefdbf43fe1f77dd4c718c8f755b895c6365ed1dbad8381a20db3ce8325f4787dae2bd8298b08eeeb50c4b25ad4e44e2d97f771f81680b6ff3c468f26eb627d0fba81bf34dff129a0facfccf1b71d8bf35acc5a75775c4a98692999208fb8f27e6ac4337016a171b90f9466e4f8e9ff72e6f9e3907eb2f29c5b817f8c01a5e11bfd238ffda9aaf282e86f70e87f6e79fb036d285b5403785e019e3e9f019ece2a6c0e59f8bb2016025be3ee1e29940560bead25b3b381d3919cdd91103a32f03a6a3546e8bcd9115f960cbfe89ac14a099df3f3e7f5f3a005f4808a3d26d2c1cdb5f0fe3a6122687a55a1293b2d72b80ba563dd0b9bbd481d32572cff070b09c5adb6e4aa242db23c49688e19cf0c895b090a37c160276410ed5723ad5afa835b9f3d1eb8a3df8691871fe4795b9968dbbb4decd698d8726e398ddb84634e415354c3b88d2d3459d23bf03de538685e1807535aaf341b2fb70919a90adfd36d82e1a88a089da0996d824e814511a080054bb6b2d4ac78215e90654433bbb1b1fe4ee9c2064ade943968e0d4cb630296560a2c4fca83eab3560828230277eac1d61224ac55eee676f298149e6772b53266bf0d6b47359bd004df6a2c534fccafec66bb18a65988d6ac84f566e2a40121162c11310c0cdfdd645f69d3c7701947a82116e12a8a94ffb363bf0e9b30fef63c3acdd4615e567fc8c6939fd8e3950f0fcb341080306317c8d97d6a716da352a5de4ff3794eaac4a0343a42fd5db26c349bcd80bd0124260d57952ddad545980fea828cc28f0265267960d8f89ae3bcde8151e1812e8c5510a2c4fd21aecd6e6dd6234482f83a5c1c0cd7ba0f6d7a506b8a4ce3a609b4628c9e8a2383943995df99fef146ce42a104db1061e4677dcda006328ee7bc2771d29ece5f8971c56300fdf1d3242868c845974b551ff2151a8cb280f0cc2075b8dc2d8a5806c370d115a20a9c546f3e9d998b7c90fe3306f558c6454d207ae51b0a514e579f05553c259a83217f068c3997434c6a307195a4ec17f5dcf04f137ce10297df7114f4bfbea3baf0b8f25042b84670a94d90bce6dafec1318c481d7d25e4b155181af2aab2b8ffb1f4551544d5fa5e16c8141d30cb5fb5a9dd00fab5f9bb37bc658009b62bdc7b0bfaf34b4a4e8fe239ead0968fab92a73050ab64d521b0e0a4656ec944bb35138a1a3e33f369f70980feb26c69a124c407824ebc035965d114ef6258d81175d3ba17756db5d69e5a0b427f039c7640f8541b8e12123d012837a8ad7e6955bc2bc56bc5826a4538bdbeb66114e104cdb134b3e0e15d7f58978b85f5c5d556515b54b7f52c67b338e3ae502e93c3257c0babe0b1ddd8e2bf86fe995403c4d8de3a876b92a8821afe47f812138cf3252ec9be34b3e0a6e07f48f6d1b881316c97b81dab215dacac75b80e40552c586dd1f2ef997adccf62932415d645de4ae27ee25beddad8a34e707de5948c2d559fd4b974a0644da4b64b54da45f6288aac52d9704c38cd364e5a46a25252cba012a1c8c4fae605165e241df31d11be60f7f0d71e3c981f2298dde1ae60495fb5b2165a7580d8f3b32f35a587e4034709081a38ce88be45f34b31dd85232b2b3059b10b22f9c2c50468882d0ae025615cc473d4a14a61076380000701b35e8285fa602dea80850502bef6ae6535645d258bae7d3e269941d8126a813bd24bac76d018d041a6b7258413a49f6b8a6c3611da3c7547a575a2825942539373cf188d96a5e0852e9db4acf01b52c2c29ced8f9f71bd360416c4fdfa9d4b3c152d0fb220e2b12f1bc376a197a4093fd558d2adc3e839fd6050f637276a83d7758df9a3b784cf2492ed6b2eea56d769ecf287db1c2e9a0f453c65c746985501fd6ce3498275c2bd57d2aa3ed12517af954593c6169b794c812c29515866aa7465b4569bdf04a80da439d6e9f6ba7a21edaf63a7130b0474ad4a822d850f8d1553549038f049aec7ad9245b456e8abf8c9eed2c716794a016348594e0fd48f3bbfcfe84bf82f65e1503cecb947d8cc1654278ffa7237b67d4aa97853d04bc9a736629e693d794f6e43711d02220c05c2dcd5fafa8640181540f2f49453ce9419b8dee6cfa512466834ee9e7bb937d3102a504ea62803561aa2084f4ce4ce52010c1a6ccca3b54f5015773f530ea1537f5060370584242c1d845e41a20c709e905e87bde3b6935e3b32c46a951ae533ec7a01a1e2873ab8550d5801471ed35795dced4aaa8c1c312a83251d4a84f276d6a94b9aae182e0b7ea72b184eddd286488663154d12e1697b806e8b8a90ea150c392164183e32afc05733ed8292420c87173ce394774ecd0b032405bdb7abe30529106f868e3a146836661cf7615241912fd2b9f5bfa5c1852cb3aaee8b87023f1555d2832d6db526a460982282923be9d598603f25cf6acb03a71b0d9387f1d655a223b3c47261a677d1808fff37cfb8ff39e7734d73ac7a073a90060cf4447920822c10f4e11f196de8277df9d4e20e761508747cf8d63e62461a431135d9fc4f2770f54674b64a7b003c8bab13812d367173c5d96d8395aab241f10efa96109f9d3cf674dc3474556c461dac57f00cdce6678bc99d842ceea7fb5dc89a35e9a0570ff5d9c91d7b64213f6dc672c1656100a7b3223516add60839287c3e6946b40535ae799aaf0df1a5d88dd611a8e4f5684458be52b6e15917d98e8cd1eccc47ba0cba9f1972d348dfb07c5fe0646e88685b68868bfbf3dc36b261c560ff497e5ddc71ba757a1d060dd0d3e9d8b3c9bbfbf354c460cb8c33d1571b47f97c1de8a959e53f3410a8836d7de7b6d3ddc6aee4d57c1df53fac4ba00de3bbd88ebdd9909f36636db9ec74b7f90abb9935e7296dc51834185b663a0cedf69ad03d0540a951c639bff9f224b25f876a4cb6a7964acab129a6853a2b54eb72897925b5844f589a897fafa40238d3708ab591f467fa2b952bc0e56f31b07efa71851e80e2b47ba2ad49a63265faf344b014756878b8f5fc3c91c0a09954687a2d7896c4eef4bd18951a43253d6cd1dc3ddc8a0c764afa8b65a00087fe415b70926a3a995b113ade89b8a59aaa42fbab28302538926a648caaafff58e306434092d04c233c7ebe0e789a0f1d6d9eae46dd8a6325f383d36e48ef4a6131a4fa204ccefaab8b87d7bb1c91ea08ae86229f364a39b68a58729e0ff2d352393412a547b192f4a14cb6668ae8f380e12d19325182a15add83bab2099e09f3e2dd5275f26c8bda0baa5a28b81721463728ef7cf2c90101d540b12c276948413f0474905d5e7206a8215c8d8e559865a082bbadf0d2bb8500fcba31f8d5139548bff03045de92c42236892de493e813caccb82980b031dfde3ae48ef6bc49c5c6332468f4b2105689c55132e645c9c88ea186d809a54b5742d11c32ae7fc6a0d3038ed887ab7be650817ca585c100af89aa50e25fdd3b7765e7cdde70ff32ed3c32330504e7cf6f983f369018d24fe3f7013cef17c845e5d8dacfa9ba812a72b5d9a0fbe3d9a5d47bcbf67b43d2065587e33508108bd4c53a00046b63ba709e6ecaa32afe5b6c87e03aec259f716a45406bfe56adc8f5e329f1a4b80701c4e9f6ac2a881d6dc126891634a0b77ddc18f214b347d6c692916b5dfbc8414e7c64399628e65162618b1e88169e013c8815d6ba21f9790854513cbe568f00ae14ec9bfa2442ceca8c6ad5c8824ace7f569bdcf5f2abe63745ab65149bc3fbe6c0b5785c116ef208ef017d02f5aff1636cecaa05e09e5bb522e0dbe0d1ed924dcbd121262bc9ad2a6a8748165ba15c542cbea0d5fe81d826c4d536879d1f5fe8584108012736c235bdf7927a704d5bb62d9d947a81058701ae58433890a51cf8e217fc312e5b169ded94efe6b6481aae83cd820cba68c406d27f90f8891cf5c13594748a56c67e26d5fde3d11f37910e98890daa9d4306f84d6c0e983429a0a2f5819c677b2e65b0c472a7778341b25f7f42443d38e0736f00be78c809c5e7c8ef3de915ad25268be88e178ae67bb5da915005260b9c24daaa28b84b517ca3a55d0cba7e0b3c546451c25141474f0aecfc3d10c0b37087c20f050ef77ea44268241aefcbbed82ed3d95871d01df3ac4ac58122415b720ca3115305c31c708ee8df707fa8422a20e721eb102814b232586ed9b606b307e9beb259e7f1aee62038e737fe2b99697c188aa42a7620bbe2fb6c04501a51b233698b5e5f515f191774ec0e9c028ccf5562ee5c4a4fa0f64fa85c186e9867beadd179e8124f63f7b85212459b236622de6454180ac475b59109057721a0826b8d51adaf8866fc028aff5616480418e4ed45694462b7eb5e963666ca921b3e5418354a3bd6ea488282b83b5826c9bdd8e2848176d789afd4f7e62b9fd17e2375203e3fd26366b70fca43bacac9b7d0560c57d5fb5fa7314162be7fb4ec70386974d8e037d22f7fa70e2a7df0b885d1e9a9233508e3012c0d230dae0d2baceaa3be857f4576969d40e57daf6240f54d9f37bdbab66bed2300e6574b711c8b703c6856961c039da44a855cddd5c8e8a7bffc5deddf1c7523400ecca6bfb749aa214f524530011cc91e4422f1e8584c75967d9ef5b8f416ef16af03942ada14299c3d4d70a59bcb40b460a92ad0b239513e7d48f4ebd974a4e5479d1eeb4178d41ee417c1d011242c4e17eacd8249955a4aa9f7540bc5b8e430fa8d8974bd850cd48171e1f5024996bebff4f338f0a024d13262ab3fe56807bfa9d4d5979a5f0b42ab3b04d4f19c474e80cf1fb2e8d9e612723babb57e66d6a326a0db6a6e18b48351d6fa394a71ca174aab190c94ae5d589f04c8f2d9a12b18f53150f2899e89ccb27ff91ddce3345afded292707144e392b581e4849ed43bfc051babf6463d175bc994434edaf9c6789fb9850028b8d74f431a033c8e6763268b4027f1c9108f6f218414ae1e1b1b762841fb748891b8adb421803f11c2bdb12c6a0d42e5d5de84396f6cf6d407092c3bf5c406b1bc1cecd31dd990da0f075eca171d3f0ada99d16145efc1e7da565301de1ed10a915d77e2ac5efe45430a240046b0145f58b75ccb4d98960109ad9263cfbdb598f08694c1011ac47e0fe1290b203faef9bab3fe1f9f82f6461ae1304f4bdaf6e6f949130f250fa0123b910dee0e62d0d3e0dc91a2cbae33d0efcf4c053d16d1233bc2091764ca7b85f29e8e14d2747d8564829f99310d28009c8836e39e3af0ce757ce1bf85c7238f822f29137dbcc37d3f0342207516ba79c607eb919e97a013257772e171eb84da9212a364dd1bf54d7d4e106c0c0be94eed395d5aa682a1f8b8b3421c6b59bfbf11b8bc8536d05bd80da44fd002548db3d605608e0bd664241cf19744d676dc5125effb00810ef332c47d0cb9484fd46715e40f9eb6817686a3084a3a40070ef204b109a11b326294815931e4c86c9ffaf6d0a314788d92c93b3bfca1a1e1733270a194cd274a336678e8833e0bc51b77e792cf4c0e9dc5cf643f2f5d03a93b9dc4025ef80f9443763b77f8ca09c5c5d2380f3f05d29c8c0df2d5a6e49ca33613865edc8527eaed125f0af8cd92d5c0556385ee6ee189796afb64d8190dc57d4f4b8b5f93dfe4d7c07231967daf15e21827c85cac6a977058356ecce0d1cd92f60b0700bac30df9b560702215826dd6d86f07270bdccfd475a912f6e0ec02a5935dfefb1138efd8a745008b223b1886fc8015d5718d48b860db05955b1074d92bafe5823d51344650853d86f4ff773c46aab645fae90714743de5361d050e21d11f9c4a5509ef60eabb162a204d1fb1243bfabd86b7ea3a1da566e56ae370b83acbed768aed29b3b18a45d1a87e23fcf0c550dbd663f581f34b0fd8c8c6e296c0ead83186c62840143cfb76bf7d3f2a70b7cf35b61311760ca9bd6311befacd0281ea17d8a0a6aedccf4d9255c4f529685987d37918fb2e5504d174c4ab5ed72a75d7e4a2d60677214b58f653f960525addcd7a4eb9603793e4305f5cbf7bf91e8b57e498a70834cfde331112142f6e9e51101fae817b11ae2584a8f8aa06213fb39b55027257e7c801c87fee64ba66701d1cef47e7840ece7d085265252be04958ecefe3dce6e3c29c0147d778536f985b43f85f163575d5e2b783386b5e0aea373ad7d5e83c5202e9562ef0a4de9107aa50f164eacba26e784292ea16198d270a14ed60506af0566f77b3cbb48a4f75689ec8861823376d0f7873af70016988a536dec84c6533fa55ef49e277c01b5982332113856c41fb8cba8b2817ea879a3d2f34aafcf73255dcac858771cd324fe60458d3e60f29dccdac5c9a0753a2f7a60238f6bd422853cb438690c929191a91a85529bf1992bf750c630517988ef7400ab85d6d35119be8259496369008aaa0a8af84db509b1c38abdc6d813bfba97c3f62237dc27d85030c719cce17a9fe97eea3e0a3824c159450c19dab45b7a648ebafc68328c6ac55149e703da4d0bad530f4ba28ce731296b5182553000642a9bac31709a7e39f3580e94fecafee734d05d04e2982173771a08f99ddd85506839e176ab380135759333bd4fdbb9ecccfcb4a15d5aca3ded4ee24cc6d3362e39ff3a6d688796644ebb9238a3e0b48dcbceb04d1bda2d2366d3964d99b4f4e4ed42e0554a73bb584008c9ec0a8610080903287e10718edbe0c30e7e045be3af47a372784dfba8f18ac8f5ab2491b254386530108451d5902513953d47bdc9bbed179cc8e0f0b93fef2a6ff01183a8691e15096efba1fd99295c12ef159145b4420cad3f90943d4b5aa76a425496a63f05041667c8d9a59e89d50b24ccd53d85d4c6fbc03fe4575584f00aef5b9ca2362312ef0a3858e5a32d9d23bc5971596cdf3864e1c5fcd43d2fdff24eb2b3b63fe861cc75f2240de001c5ca56e1321ca4e467f3c2197100ab2592dcdb213e71cb2a0d177842ff98c70ad309d398573abf47994866c8007b79d2fbc1dd24da88b7d24ce411dc6a516bf169c8103d6429ebe638fd4cd24905bae87a8c3d743dc87d753ec43e5d1e635f1d1f739faec7b04ff783b85fc763eca1e321f7aafb31f6e9f210fb75fb98fb743d847dba1fe2de3a1e631f1d8fb9a7ae8fb14797c7d8afeb63eea1e321ecd1f918f7eab21f232b13018c0ff4d0eb1bd5488fd614f64951d4babec83d3f222295dd63765f9518d14ec01105716d40ace3659687e27f6b6aea84a772aac0727bec47100faecf492ea65d926ed5d5d34ed6a6db3c7d1035a16591f08f09cedf0abad4fcaf5086b546781f4dbd3278d4fcde8f531596b3b992efc5a7113a7369a14bdb26a8f1080b1e13a7e803776389eb96edb7a8d40177bc3be0f28bf2a64bb690ae190fba85b10021f482bfbb1c7d1e955c6cd6ee17caeb2e8b397c6e45c76cf8528db8f74cbde4d551cb164c9c1eba3d480f7058fc597998bdcc36f5b5f1f04a179d2a70f1edae5dcf3dd3bea8c0868f66d3e7be57de0ac46f77715ef7cd07d4c5a3c988b398862534689d06408389a270b6369a66a5378745b9f2aa86fcb9c6db3b3eed580dc6552f875da3ed11740af332fffbe3fe7098a4f219cb45c93561d1fea806100b8dcc67ba65413e3b905b9899ffa7e3eb495d46ce782831787da586aa8c3b5cc5bf58b77ddff7d039818060df2198e9858cd961199b31124b978dcf4f11589bf4a3888301a14e342ca4bbd5e6b89611b5c353753fc7ae0c413d416477c31805bc64138fb9247c8502644c0224b99c80fdea37828e1253b892658b9591fe010fed1f42e8a28b7ac14301b45b7d7e246cf046cd92c6084827360b411402a22547a78ea63a80962b2fc60c69c3391d7c0b2429b534e48206b9f2581d805544da231ba2a4d9f702a23627c70210f08e0af8dc9214ae9063c5afa96249cd14f94fcbe6325049f256da42e24c9220fb7be600219ee5c06c7ee57f59463b657e9bd50cb1cfdab457ce9eb3cc12995a887d5980bc65c1ac51f99810909ce80ae88e04da59d6476b8a644bab221aa502734575203b12c05e791f6d33322dac0ac1140b981b5581ec8800fbe5f5e00dc869655544575a682e7405304702ed2deb83352045ab7513ad7201b9d04ba01d0b69b7bc8ed600292dd795e80a85e48056817e50a8bdf23a9a2624b6b86a82291422075a07da4321f6cacac19a23b3e5ba88a6a490dc2835d0e3802d6459650171444955fa3a7d1615d18eac89c0f4447185740ade65d4e17a8c4c2ff015ca101846e8a6819660be959e65af6038f59e7f1b01ac2ce956fdd8ea06471127a6a88b80edcdda7bbef0027f71ebb0925024c4dbaad36cba3b58df4f1dcb06cb06c2b15063d00a0e8403cb450380767aebe024c6ab4735241ed1e28059b191ef07077961cc4c64c9f79389b8103023b0e6fbcb212b08981735f3fd71909503990bac5c7e58c49623662246fe7f7964a50033b131f71f0e9942cca8a895eb0f87bc34664860c8f5cb455c123122b273fde5212b88988bdaf97e701095838c05a67cfe78648b11732256fe9f3cb2420823b135f71f839452c8acd8caf78781b830642432e4f5cf445e0a1811b373fde79095440c8b9af97e18888aa3cc45562ebf49b42937212762e4ff9747560a30131b73ffe19029c48c8a5ab9fe70c84b638604865cbf5cc4251123223bd75f1eb28288f9132767dd46b245882d72780e6efd77aad265eedb4b84e8dda55723b69d2280c62ef2fab0e90942f5fa2557039b7e24a8c62d71f158ec2d0274dcd2ab8f854e2040eb2ebc7258e83501b5de920b876d6f13a2e12cb89e58761221747ec9cbc34e4f11aae9975c2c58f42b813ab384abc566bf08d131165e5c2c7a81107a73e9d560a1af09a8774bae1c167b35b1349fe414cff74d81cc5ed8c9b94cd2f00a3a4efecc826e73f4b7dcd74007c30dc37521bb78fc429fa85e2f633221b82062d220578d080a74e9963b505627145cd330a94ac03ae50f81a5bb055c3cc7f0b5c399ad7d31c3518ea81363acd0ed1e6b43403afc3caae17c382a1f4ea7127f8c7c2a6de48e7f54e9e96341feebf8a60ea3573054867aa4f0838be382b17bbaa49258a856e19b386677426b161529f0c858dd04997d417a6d471caf11dc094e0e72d8f18dc4f5e67a3449ecfbf89cc04939b7397ae1565534992f018fa675bacaa3d3d2102954e6eeee8a6f6b21f9a4738aee0c796ce9bf98727e73ffc772758621db8d34bc8db42bbda0567ace869a44dc142b048c7ee9a8bb6834880fc80796165d6822176e2acc124224701275b491160458d4917ba6ff1137ef0cab2a2bc6d013b84e7e1e29c3163c961da8921edd5784d84a0f9efa0432db155379f1266fbadb50cb7e0e083f878aed2f9b14cc17c782585087ad4d33457711e1729f6084f1887d42fd4644d6a7ec756a363654d63c8ecd94676ce0e4bd1067169fa6fab643d27d224cdef44a908f2715c3ebbe35adc470a532f021433382ccf21f2968b384f46825ef81aaa80c2d3339b5efbf6b44ccb07a596eb14670e09adfe230569e9b5a8d16b1b8357d966c8ca6dfdf7baaab977e4397553c99d4c5650c0c6f1ba113e1723ec0853073d33113d9e97cae7e9b6e11d093bf854f3f6391702bb13ed261bd4bb968eb0a9b736cfc69b186dd11f2d60d349226e25112ec0d278f5bdcebfedc39492420eb69c221d67ae5c5bc2ec8de209df94549534b745f9531d56441e1926e3709cf2e87dd61356f6a6027539e119df563d19f63a28ba7af9e9ec79e3ecda97d00bb694adaa66a9f55ec31705632f84ca7c7d07dc6075e7754df867dafb4e8b095372e3c6db295cab859bda9df10201f79f6120107b8adc98be26969ffeb21611dfd7e7794a884ba5c9fc7fa3c75734a6104cfb910fe75c748e1fb1e59569a5267d9e96f054bb3cbab20b38882825bde1df1f4f62d6f61710444c18716487014c517a058f70fefe79e0be48034f5524de6989b7d50b7b65457bde92ff58026f60c18a9cd8c3a11390f64eaca5db8f721d5e137403cd7adb664bf5833941d4e73023ec694802400d29c5603c065d92ba5176ec2eceeca28c5c4265f84007eac27c14eb80a1d4acf4bca5e6cb240b16510cec5a468e64b4f7b7cbca46b7656195eb83658d7b25f7f179e6122c3fcf88ded36270086c9e67c47caf7c66c96e84799d51f25747716da79bb600eef7539d6c8fc9bcf4ea7c8d40c7a06b40d20390144f8f8f54b65f1306b07341e2b935b88592092318267b14509eebb573b5bb439a0cff63a25feae606a0096c4761b67a0cc28dc5d77043b944e5aa279045c217a39c17f93e0b6eb2481ca89c2e5c2b9794690fe9a8e821ed412200eb7684de10e8fc44de51706fdfd8a75b326ba1b32c53e083709700719baf45b5f30a653bfb002002cf8b21310db1773bc429442bee053a8a2dcf438768002021315fe01d43c7b50f26d4ada50a2e5d066ba12e27712f076df2f15685955586f194189b8c005c5a22e0eaf5a114677c1052c12b9c9d752666d3b99418d5ed2972214a32eb4991308974b6e11085db7873389a8598a6bb5d72bd447fee13dceeaa09a8a96a51326abb4d9e9c608217e9e9b8e2c6915c2445f4df18f6b43452faa6b3d77596e34caa3cf92ae04fbfc0227c91e9c087611612e5541b93943b1d3cac13819d66aa9b0130b8a7c55b2bced8f63134cb6076c2443a918f5dbd52f16b1958410250f56b4a0639b2e7ff484ebbf8f41d76058c20f76d70a1469d3165c51da10067bcf77c485ced737cb06d4f94d8eac408d2235c2ad2cdd3f4526fb7cf44d6a0090ed7bfca0319af4b2144ba13806a764a4e1fe907bb8193a4b4e1cfb13e0c5b85013683ddc08bac6748345c19d04a1d515e11d55e39d4b6f0b79e6077f73823bd2a506e076b73a60728409d622d6b775db016fbfb6fbe56ea58e550a825323d8b552dce3e70657add147d15b1fd00159a2967242fefa37d8022d17a0112e373a3201fc1dd32cca4edd3dd9dd8eb20037d12545596dc1818bbf09b676abcc273ca9b8a08d7761a8515add6582f9c7249f8a3145a461ec83d8ea4aec5adbb7035d8e66e8e619e20b379d7ae071d4838234b7362f981f389dc18afb8299f4ccd6b4c5f308149f2fcd89e888f64d6bd44adad62f3c7a5eac3ace4a7521248976edcb06a44083741105aff0f7c2a6fa71f3dea9287372a81f17e29991e3bfde777668a19ec16648c4fb21c21853aca3c045f3ede91acf102aaabcfff8c6a8ad62c1e612f9e741c102f8ebf1c02ad66fc5af60902877f279094e312954adc70c1ef7d12b855c2333d14c68732ab73a8c93e00c94565b1e755ccf4113c88e8d47c432f6006c326d8359a3093b6ebeb9512414233e72f400a1934174c2d82b1cbb4df7cc3315e84a12b50de71b60605ba6ff780859cd2fe063eb05afcb6e383537566752976787a58db6be0eb88d1884912e51950740c1bdc948cdc01bc7da5a585398132b9dbccc96ecad097c85656481f4042b28b8cbb2013d07064bc1199c3f74968034c15a14781f8086f0df43389122ab3ece51ae1b83874d59c99802d05b34d4fd06e9ad58cbf487a4e78d23d6ed0b4427e1ff0f47c2247cb90eca4688ccc5629b10dc830dc255a72dd65c0f40a508b24deb0e5008183dc1061ca6d06408b30208cc00e0bb5978aa5ef7adb862434e8f2d5fe71aa0a57063f4333408ec128244d7c05d253c78de38249c12bec676f1ed2aa71e350178565646338fbe1e155fe52679d282a68e05be44483e463701174012fcce3af8e56e49b4697ffa7df43feb06ee718a7d6e1615169634f3b109599fd70fe49dc9d55215585d637297b086ca92faebf359e77dea47703bbecb70a607f44332795f64e5c267f33db1e44420ec4703d661692d9b6e88d0e4f4ab55d9c0631885b1f44f36a2be002ffc01c89524ce544486aa82e15ac9884a7ef6ce2e5640d3bd334eac12905426b2b771418a99d924c55859504643e828a40d69de91d013a2d62c61fd5a958ee518aba792ffe79813305fab11fe67f9cd2250efaeddd98264b3064ab3db1873b13a0d124fb6a171b504f9b624cac3c6082ade878d6632a4f07950cd4ba95366c1bd42bf96ffd2d1b56b5483c140c0187a37edb84df314d538f61d0b4433a04b174b8390f5b641b25aa159e81835f8832ab19d3e679fc4914938ab897158bc2e2b309112ce6f69a542c36bf861df3c06ebdc296a5189fc2dc2eb5748110a7e749a4622e8018020d22aeac517a42912d56471d784d669a7c4386cf52d072fe5113700806d77b59cb2089786d9439212740acc868e6f7a02fe30c8f6ebe06bf52fa5328503819945d970a0f970e4355dbd9464a31f90a689e7cb3c7c3435ab31656d667077cc1060f53a6aae3a6d2a767cd050bd367b101b0041ad2fe2bb23f76944051e6df5a0c49a329167b4728f7ac7ab2f0386e825b3381c4ac68048d0410f03c65b004cd2b8395cc66472fd3513a05913f8e3ad944c8d45fc5ab1d12fc6b94c6ee8234cb56ea083fd6e7142793418a253a032874bc0a2efbd0753e6345a4b53d95403c4d40a9ac3c034d539e661ed2ff06688789e6ac1b8e76a4a3af3b940cde3c5fcc5f41526002e6975a8123c3647b0e1475a5390bbfa7c6899056bccb9ea0695e38366003dc56a62c658b1b4d990cd95554f7b33c472aed4437dc505eda3487b4e57dc61f3d7e9dfac66715275fbb41a68f965a002f3c221442f3864d53cf10a1bf5318344b1decb3999b39e1c06a8738a439429f5d83f966573582f050754ca212366ddb19e5784ab41ce278c187a92bb2a24b2bef50dfd582f2624fa81ec1206bc7fa2cebe5f5b1b66b1a3c424dc7228d77ed211341f90d6a7932a5c5f0b1330eec3d2f1ebdc1d78e9f3f69c31f0b268bc545794a4a76b19df37ef42d987c74a19752915a78aa64fc5c016a683ae0ca14d1a4e6582ba079f862e9df0d5635283e04e7c839350b4c1c60978050ae78f13b08fdf37e155b36fc2cf5c7e5d72eaecf2c7573e56ada22f4fa491fcf05ec4f820ceb571cb817193dbc07ca75871439caf688fc846a10be9cc03620a1525b233e2282f2598dc616370626d4b537b7e9d43de831acecff895768e953f037fe2432ac3b1bfdfd55d2d476ee491ec11d6b6c7b8e9e5276b0cc7df4758636ec743d2abeeb797a8b46682a7a4c9a1d8e9393c1185e84ed1686f9e385ce4c0ed0ff7cb518917906229432f61dd48563cf3e3b94cad4487eb08b1758e3660e914b6f351479e57199c33b1bfe4b56248e89240455c245eaae2554a54de941bb958890d4af51c8986951950fcd12254d4ba78b5ee41c400327ec2eb37701c591987d91333942a980f327a70055954f220f4b826cc79c099550309816de8e3c814557d16a1a73f0f8e8139a2135f69f187f25cd5bdc971a912ed28d0af229bd207792310f7bc3a9732f70c187d0cc55ce5545ca726d53fc00a9f3aec619bfba0ec4b4852776d589cd315b43e07c13311258379308c11b975a438e38cc50a814edb18ecec3f8f33119ec7c0bcce20074ea60cc3750b05683cea2f486ee98eb26d17515525c3ed37cbb10a12411dd1566cf6eb8f3681a0e351b388dd8303ac60f8931fb3ca71f561e695113b976156e7e9dc11311c9c118734e5b92341199d10957bf496ad371c10fa947cb48fe2d6436828a5581dca2c7668a4afe42c3c1bb23fcb258ae3ec47ebb44ef07a73a6f4f24cb9289648162ea6b51bd85329006461e921428c310cde6125d914906222753416601d453c686078cc6a5237b78736811659927c43a2b245e5374f0a0788eb5d63541644471a390e4e62b27812b3e2b84f2f05b049b358b0546aa1c30d68854227a2343ee3293d8deaa9019047d9f5d50b172545d6e8000cbc29a6d1cde162c1f4b91429e394314a4a3f54fd87744ee82304bcdd1d55e0310c830602c74fc92e094a8b27fdea2b286b8b09ddd78a89012d66c01c6a84545727629ebd5cd96c950c8548ed4fa73981c7039064185e4f28f72fb60e115b93835df6938d8040194dc447dd971a76f5d1a85ccbfb05b2d60a38a8fb47f22d95821d1b53d82c79402b872db5984a55352a181ab3a5e38e45e8091fb015db034184637304b5eac0b1e9c0386be3cad265ca6c67d25209915c6bb0dddc0893cdddad9027c4178527ba705b8abe9a95a4138a84a7487e95651db272e7b8dc344966e58530362580f8061088174a6ebafb67646227f9a89ad0f82ab479fd8afcf063536e726451460561b635465adc3835a05cf612ea1e97e9f91fbf8be34d6b264de119ea7d1dafa4b3a76062c1643e22ec7ea17bb374a24a893d0018b73c1a0d42aa9721b42912532ec8fca885b59014935543f0149716dc72f86014e2bb74badceaa228d5537bf72b538a27e52bed4351a8a06ea638797869c25b065924344010b811eec5cd9f60455e81943189e473542b34d9cb2ffb05c5097dc2cca887be639ed42a2f8634f496d784d2020eca218bf249298b9a82f3e69355ca54a44b0ad3f4cae5eab74e4900ff7c8261c38be5d2d3e7a44b79512daf3acd599e7779522c0087711be71959aaa4ef741648cf059c60800bdb9b96001bca50c8d385a9b02cd46485c3958f5bc850d3491d61927b524424114be8660ee055559ee32c4a6e488c37272409b062c52059cfec17f6356ecdc22eed08112cd85772c0e469c1683b673d84eff8c8a82db8c3faec2e5c6b62726044c6a8deb90dae917dde4d0b93311a13ee12bd904f179c601b49e826b0070dde35039fbfce2d4976b4018a876641e1f348c50ced53db4216c4895dbc05ffbbb54cc74222b11514a533676ed04b2b50315eb5fb75c139c84e5301a0aa9f21666ced5b425a0008fbfe21a3b60957fb1779e379e8d00ee2a85a8dbc45422ab71def9b92a992bc638932ee17a85f0f425f3ffdebeb9fd607501f3d35233f9e40f1c6fea8c56491babf5a2a0f8c08d2f54a98eaeff37dd8fc574a9a60212bb74ee8c4650a9e8b7e14d2040becdddf171b23c5ba7189aebb14ea0d7bdc5496e316b2c74a9dbc235d0706bd92a2e0ea0bdf48c5e33ea053a9e283e4c67f94722cc757b392ae2123124f03c88a52a8dab26b38cbac4347e1f70a5ff08e892f397159e57cbdd15d86cdb918dae75630d32c6724bf9c2af8563dae3b8325dd138534984194867173e7d9e8b906ac9e97667cefea387ae4a997dda43f1afb857c220128fdd3f12bbaaeb7fe0d1bad7ceb4b532f1456ccd5d7af3b8d66a74706cfebe986c183f3ee77fc7e3730f487a51cd8770d4ce115ef8ab2156baa07912d3ea1822d6ba0c5be7777bbff161ec792de29f2940e10ca0ca162708978450a12f97c1c5f5a631841d3e05991e4dedb4eec91a8aa641ced9f0d01ca8c4f991b117541c19fb4e8c141d9c30f37c0378f03f10a26adb849eeb21a16e2c6576954490c41ab7a6363461e7396a5439d208e1b099c1f9850383a402f010eb8a8fa566df863af97f8301e8359466eafb6df57c36a0e3ff90f9b214b6d4ff2879eda8058e7b6b3ed7c88c636c7e588b0a72948fe10a84f23923d37f1c172e21f138f3d23e34391fe85bf90bd22742bcb86a7d20767d161acc8db632593d707745b7e38be07e745ddcd3ebcc1563b587f208930f5bfa0e641ca8939052eb71e6fd74be343818e68a311b680a058c6bc4af003fe3a21d5082b94a5b6bf4edcd6eef6de7ca35cdbc4bd7f88da7bd1efcac9c223e6ebaf08d17d883cff270c85c95b6060c6e66cc99f99e2f92ae58f5a9e798a8e6f3eeafb0c6a06f9f86c7c009d53c6585e1e8e9de8edcd4efd4128a7f046077e353afe90489ff612808368f4e0200f6334b8f38309d2a4df7541515a9d65e727e8acbfb85b02942e15c2578bfbccf676820298cb6901b4b7e03b8322fc15ab49a73f19d7361d84ae9a9947637aea0dd511ad61c1040d2297b8b0a9ea71c7803adecd828267e2ea43451b878d47578444b3faf416521de3205af9788d1bf64bc580e0b9c16c165608bc544e9b16e6a13225b4d8ea58f2425772497ccb8f8a8871de6d405fd746fc0b15af0dd4bf8042b8b07bc8c5e1a656456bd1646676fe0c560a6e067c5413a9459a88919765fd2dd0f58b50a48e958381130d881243bb127fceabea4fa5a112aa0fc5ed6bbfd638da931efb6a48e439191f010489cd32b0b31e6b4553b5a41471a85a90ed1355afa5b41c2dbd525bf1ff945dbfc3b205467a2b602fb65ebf4c09d254b2eb2ea694e2f3b5b239550db193ea969d62659e1a015f258e648189217544a0af6422b02f0e5db2a1af4aaef5c0287f9cca3ae03ddb46d3f402c52f36a4ad3675affcfa6bfff69b7689f181aca4acbb683e19facc9fee7ceb50e32536e9db29495a41c93e668ad33101dbf7cca098506f49db7c2e4f928212cef2ac534c7bf489166ba002ba738997489e770c76dc963667b8e5524e33039abb17a6bb6980a6948faa82fd97bf5cb25cd1004f3525ccefd5cb046f2396e3557c24e83e7e1c664042d3762bbfc3fb39778568fc67363696be9c8a01b580b35cb6be6b46ab4ac055f09de5ceaad881403b310c8d3d7104356d3cb109e1e141c1f75de703225d15801fa85784251b785996ca76f9884c5d5602ecb3568499fa1ce9b54dc7ec49f8482d41755fc20d89175a1b06d362265af4b2c3d07ea82c5657c6da0b660b37a66ebe6536dcd66297cc53f8d3fa6bff62fdadcbb21be3c3e63654eaa9a0e2b8977b80bdbcfe23cdf57ab952d2cb61635e5e445ebe31c9efbd1b6ae534ce7ed0e5043b13d9b6d1a09e8e81080624ba036aa12e8657205816a703f9819b4295991c26757055b82fe96e34a8125773129a97aae8feecfc88f8292ae25cdefbe214013b2845fc8cebfcfdeea32ed63c334d3907afbb01306e789d8d7d99b24cbe15ff2bbfeddd6d6fb9a54c29c922086e0865082017ca6ae58c133178d272c44b5dedfbda311848f6b6b9e8125d97df43cf35227288f41bf8da1645475da04ffddbd8e28c81c7d54298955b468e2e548531dcee55c49121da6ac86cf9a967385538ddf13744fac97bfe86742f3f9def71ba0325b889def3a61722f15e14f6d7bd28947e9aad71b26eab3e1d3827f4f20bc2395f28fa49863cd024647660284412ea54daea36385220eaba3d65a06f9bb5a512eb8e0c2473d49caee99205c9648e92393eb329cf992e3f7533500ef3d93fc99d2e3a1dd4665ab7ac0134c61d1b48ca88707bf410c5ff52a97dac3505e99c6dcbc2ca58266d247f75570d1b48025d1cdf8080569427e59658e0b4180d9b3c67cf6666e7d9546b588b81c3375ad82fa6f1d7f193180c44a5c59101004c654db7f5b7b8591c1e1ef73baa9b099259fd97959033a328ac0fec77646f2628b9dc023e71109c059e71e743105272cf6d5828ec868db01899359b713f577ef2d04f959f9c59fc04abafc819ff8ebb7f60c7ee59875325671c0b3b36ecfaab9fbfe3286baab46f335a0c3ef9cb8eb25a8d9e4dae61ad86ac51000e173e15a6f1279bb66d75ab9ad69a0264cd08a4e8353e388a59de023ef97b9be13280f5ccdc09ee197425e48cff085c49cfef1cff10d8391d14f65ce7409390d073cf21098544fce47f822acb09f17777fbc08259cc624d5517c0bf87a0ea1a1ffd4f9a7d66c82c1f66b399aac539552db6142ca9e73d3df349a93837666656a3a767f5faeb703269d1574eae4f958e97f5c6d2413d9be9c857b779dce3038f0f9d5729c4853aaf65daa9e3083c422b5ba7aaaa565df3829c4e2693d99a52266b56e17d1e15b57893999987300a08d6b13f1208f6c9019fbc99d5203fe1f2fdf82e87cc52c352a7325953256d4ed77fae1ce5393e5bf7f975706135cdfd4315d871aaa6ca513d5389c4b0e3545def3b551368aaa66aaaa6aa67ce6da31bb349811030856f0b4b58774ee6fa6fe0f51bd747d77face17a3f7b8ab9953842278f23ece839d5bac123f449b0e9d0e8f4ecc63147b58f4f0c34f5079a5af4dda110d193422426ed4dfd2ea24762d24c1d9a82c43ce987c0c03c2914220a212ea19531df27c91975ab5b2d92625e5efbef9afadaf3e81aefb570f469d15bda57d1ad1730941ee2f8c94d3a2f6fd2417b17d29b86700ee9d954811717d2cbfc8d1f42fad18f42215ec2286a68caa17ef8fda4d01444e66fc8fc0dd390d29bbef4a6973931a149fb984f920313923ee685903e26441285f7484cdb9be8c39042d37c93f6a497425e3ee6634224a62d3c22c4e5edeb2073621ee687c43c4c28441442460ff342d810498fd7109851a803f3129a667844079963d2483fc4e54921920f63432c29dc2149ce2881483ff6c851bf7f7c1c2f735ec2284c397491ae2b187a1238fa17b0e56340978701edf367d291791d648ecc0fd1f1a5979f497b2dd4b9f144748451f49b1e3469323a748451d452e961625e8852e803cccbbc8ea7610c1da9949f489fe36352314ffa0ac07c8ed0a443223de7bcbc3ce7bc3c4ecb8032c7049ab4cff149726e80262d34e9c8bce97384486ebc298c22f4329f244706bc11de78ebf242dc08b9c7becc9b9e86314ca1f493cce871b8fce82b601f47f89cd3d2f29cd3f2387d03e49c12c8399a4f8b3e5068ab35764a04b64fa7564f7c7c644099d34f80a200d150ca74b956ab2d86543d9897ce051c81cfa305b4626f5d3d11d82993cbf694b15351ba46037275cd4be698f875790a50bf1cc6b039e9cb6f6e73e3d015767e3868e12849a861b87f90a7d9da7713460b6b9bfbed473b3f7485cd71a917b344429d16a77dd5f4cf470d400a3712a5e327be3182056d237cc32d1d1fdc299bc0ac27ecc3eaf7a4117e59f97cc8a7d35ba485f245ca481716d3cc9f22c847c822a4b803d37012f2347f9271e78f3d1ee0ce25eeec959c9993888ef7ccea03e4e0ceaa317d7af9f3a1b3d385d2756ee897433f9d6c61097bea17bdefee169658ed76ef3d0c98384211d6c8d9e9de7b9c762f7485e52b67a3be97ec83c7117647e97f5c61fb8e7f04071df7fb0d748267cbf9befff3c01e72fee6be7121ffe6fcdb3770bbf2f3b0449234fd149469112cc2f38aebea4427794c665b62666ecf9ba51668a9856935d6261565a0a1659a69bb49e9943c7b761bc8540bafe4824ffe2bbed144e7825132f0c99fae98891517ec6ae6e94dea69301918f5834f387ef2e7e71f16c73217923022d2a6df9f0212c55b704e7cbfc3944bc4515f58e78f8460bf173dbb80ac0bc552fae431d72808b67e5faddf8878bbd435dbc4a1022bafbf1372060792c69f03d9899c59b1941d587eb1ab45b0087694414138ea4706f19c6c92a1243a57ddfec0b130af3b719557349860a7044836ed47190433b9baf910c1ecc82eaf0bbb4edc6a8f90a6813a57ce0401ca1901c10601393b87a378b99968326bd7684f1f8a7f09641037461c91156ce415ec46a97ad4b585dd4b0bb6c4795de53927c79e0ca2f785447d4690489035da1741daf0bfdc201cf585bcf213dfd090a3ac3e1b561ca579c5e148a3c8c031af021c05ff6eca633013a4e8cf51f846879de0c5758e12057649200e9233fe0b0082c32e094479355d937aa6eb32744d498afe23e82251a23cf977d334a78b5f1cb4c353a4b08cb3308ccbb8feb39999081fcfeb28a5f46f13e19b10c81f8c92fce272fd475748189d1f84a36cc84d644b18fa7f3fd7bfaf8bdfe56217bbd8c5ae3943eda3075a3061c5cc54f479feb651f6fd4bd226f4fe37a4cdf6fe38a44d871a8938d8e1f99c96fa2210880d087be97b20101d18430f3f75600c9a46e4b26844e48d9bdaf61cd76d60e8a927fe10c029009e486f0b08d3b6c5dace748a42e16f5b0edb739b6df916b0879f5a207ecd012116fc8af9916bc2d5d1adbe725fad56950833f4959cf1245656fae48f659b59ec0e55729d2e99939d15faaa45f00b3b83e6939e554c2833ca9472a9346ba5ea993b9fa584e5ba159d1d3b76ece0e131c82f06bfcbb5a5a48445c2bebcab40def0c034cea335e5206f8b47e70bd8c20bec894b811debeb4ea9b0ae196b8a47977074165c7f1b8ead44e32ee4c95f148ec2d191f08523b331ba8baf3c9fc1556a25c562b158ab98d02530c0207a278fc11a8bd5181bb24530df43dc2b4080c2ef7243d85a46d78c9a6ac7f5ea4a0339e33f5facd335db0e5d511fcaa230a02ea067d02b940daaa24be40c738b4271d8dce9e9a427939e4b945cd8b65381da448df18d16ce17d3f8aa36c1286f62f60c8b15292f17eb89931d9e949c093a03c69b985de79bc9869c50b88217d765333bd2d89c6958b4202d0b4c8bf1c8ae6b53d0903447980212aebf26a5fb32b42854a05c9fd2555c2368506c21699e7869ab96e6735de3b9ae29b9fed40945ec481b2b8d6a257d2a83ca681579d343481a9736fc4e1c713d4b2fc1727dd450705f9e3f1fa2679791fd3c1a8b89c0c6f202f6cc0ae87ac26a273c2939e33d5de32a12f4895f66c1b2934509ffe84abc65ee0d83bdfa497743e928a95e754ff3901e86926667812618e562f009039589baf2267cc531ee420c867115f6829df00a8fa031a9318e8ba9982891418679475f854db0a34f1e7fcf022ba36bb66f959f8266cfa56ec50b7b498b211556b6d84b666490e1f341bf82a14bc123950b6d95ebc2b179683e1f737acc614e65fa18de041a8e9cc5570e7398c31cf672a2b19ea8a2ac9c256de83777c48b515e78043bb24f87a3c68489b4610e7d481cb7558d4ea64e288b52262d1ee0009f8fc91d61433ffa6ade2e015e48861df9d53b3cf3b7679f57cd91fa24e02c65748ac935808d4dad5cb7558e7d6e6cb0e1f3d1cf60e83678849f04dba55ac8307eb53845cef85356829ca1f1974a47da009133fea1efbbafe1aef13e0583c1d8a04f5a6451271e48574c542d32fbb89c30100d704f550d527ca3853a4c235f2e2951666c763161976f6695e9c574c2f5b7a3d077b2fbae3f1fdef77cbde62be8e52beaba14e8d21e47558daa6e89f278c979781a7e871c666147a157ddc27aa5c4dd2d5fc7fda4c6449e0ffbb0cf086c292dbaa2c819568b4e562219aba6344aa74ffc332c32cd8a56c67509a3726da0311a1b698c871dd887ad982f15d3b0158caa66f049759965be1f5f35c363aa9894ec302fac1599a73ca3adaf1665420f43c684529ea6640f71abb9ea15afa68cb957afd7063a00368103e0ed517d98c6a7aebc89ce039eccf181d1993741653e7c43af5032a81a3b88d1181176ac31719e214ffe57aecbe810b329a3311aa3311ae338cef27a7158633e6ef8814303aa1a5418d000a64ce88aaae6773978dc11b6bf7b80c7da75bec2af51aa0deb5fd018743fa9938f862b592e8d491b1ac81b5781f32b083fe0178d4925211b96569127ff3358577c281badeb7fe3a331baa24ca84aced02554e52df77196af441d27ac5ee97c10f87c841e02524640488e1ca51b5336653077984781bbc9f5ff42dcf6a4d23a6b5795c7311a9bb18eb1b792334e5a6445e91a1f2c77a4b11834a0eb515cca48633cd2980d3406d3112224021190c01026d2a9dee12cda0426c051e056c023810e9b389ccae7c3615b583956f61013581ad53c74e77a96399b5168e3fa0d6341d2f8944dd99465e954ef4cd994f5aa9d28d19e684e3426da121aa3313a2de09140a7d2a73e8d5ec6f5d74020b64b4326c8197f0f43d290402718748247cc810981d880b0b75f03df8f8fa76400039f8fee31f0ddb0018ffd4a8df5180e8b8df575bdc586e52b55aa8c5f2e98273dcfd7ab6b48307436d3d9dc5635caa0e4b6aad10d6c60871d38e03d619a1a30aa82c1277fd235382f83f5761ff018e4eb32391306182f47f912a220850f460002860e63c18e1bcff5a70cf3ce2fef48205865ac52ae7fcdb8ed5c4f8244d529d2865bd5e77edafbe58f866167bd4348328fd33e4c41609ef442609e04c3313f6d57c381a53b20cf40e9a798977921312f43fa98f015f348603e26e4d776dd95c819ff900d4b5fe6c0901e66474ad79048a153d0838298af098b79524cccf277463ce92812cc8f3a607e748143be9937240260ba2ff423bfbecfebfb422b612a1cc4b3dee1d8e78542a1d00dc58032679e2167a0c034565a9cf5c412d4a27720df18b0731a7422e649608967cb89d1d1d35f82b5e854a695299b58ee94855d8c5336d615533932cb9036f35b546034467ec2f577987b8cbbce578b77d553e627ff6db3b6549a29e01ac92214182599f674cd9436678c1a112b285122ac15661ad7a76cca2efdd219b6ca3629d3989cf1a755349e23ddad29e9896d9bb53446631cce57d7cc0f78fd810f7c3ebaff0008b63bd61583b5ae384bd7b077936a4cfab6d2a8988ff99898d077b2602983ca94981f3b8acc8f0de5c7aea2144a5f72653cc6619ef4386dfa422a2c87ac228135e6ef1cbf58d5ea9ab1c6ba46dac4aa8c8eded47aae2fb9ae299133313b8a77a43123357684e51fc7cf47f70cf62df2dd50c4ab31695345a2b88b578d711581c7af66d2356c480e43b6206da412d71b09cdab73951d6458fa9d5281b45102f341ec63054b96eb3b17e554a6a07ca5a451358a85c25ec51226d743273cb4f892332e73c6ba3a5dfe422a2c83da75f7771813541aa5b1ac8cdaeafa87bae60b8d05b70b79a3a940d2bca4cdca511e863cf97b95cdcfb0ee57aeaf1c267ac1fac52f7ef14b5ba2f5809a1239c32f7eb1e6d335a394dd2a5efe74898c56719d3eb94e9d30b91e8edb168ed6964ae1f8e27c98077bf849bcb1f58cbaaf28a3933ca476e58b573edf78299924470ea1bf0d39f1c8b2a7743e4ee3a07dd3d9abee884d5dfed20a6c897e0ed96db914a56346b340234643166854817aa92ca44003caf4b59ef4e7d26f4f874f87d0735fa2ff8e12620b815be8eb735ad564619c115bc28b007a72cf7a8d6ec198c67f0d46f50b5a72bb7e5ec0285e83595bc88d615a14e1ba37aed4a28858aa0a3da0d73369d3fd836eadd1335e836f7a0bd93ef056b7357dfe7068118ce7dc601c8644f54f0bd6b29dc8db31c5f2fd5ad2a1fcc896b562abd5f37d3bb2f48c3e9d1d20477d2f7afe0ffcbee58788de8abee5452fc4e8bf9739dd8e2c9665bfc586a6feef47a3377528e4fb914988e85d5ef42eef1f1250f67d53421381f502dbf2f6e76b2d282dba11972ca4729065f4489b225ad883f66ec4ebb612d2a6732cb7815aa444b032685821a2d05e88ef5de67743cb14e47b9717f2bd4b28fa51c8834c14dbe2359d2eda5e04f6cc82b3949cf1300d5b05599386b4b902ab5544af5a37c802a87bbaa7c56ab15a2c16abd25ab5aa51510bfd91f7e295a4b063b77ab688b69e9033cc05df74e7a0597d65d69f8f1fb88dbba3063c76ec96dc9e55351cdefc6ef88122081895180cc6400ea4c308931968c643b8fe332698cf476b74bb188fc1d1ed969cf1d98807505c219bceeb7ab7ba55c33d55cd62188bc1e2a1e26ddbea562577b3b85b0d04ee1e69b3d5c7e91fee14ec15109ab48089eb9d7cb990009231c38e3d6b713ff6ec093264d81b6652ecd82d192b36f41df5b6ba79ceef1f04fa869e65ac60719ac17ab7cab354dd52a92d354b5134ecd8d3f3b41edbefd0c28e3debe16184e597a965a5164b5857de915d2ef04fcb823bb0520b1400ddb17be413aa80a15185185c91c62c0cfd58ed8edde380f9a67e4a04cb2e25ac2bfc1ce0e0c777013812a8d25ab5aad11d3cbc17c460144bc127e7b055cd7a0106183e1f4e7c36f5fdbd9bda0146f5ef868f8bf09c3de72401bd4070923b9fc386d2270ffdd8be5ad8add08f1d9f79ce2a8a9e288aa11fcbac198fc18f492ff9e9663e853fa1fd58d3ed5b9aa2ea9e16bbc759b552cd6d9b556301847e66251dd81e703c27ed66f0669861003bccf218740bc851a29fc29ff0264e5d57a4fdd0431f6286c4aa67c794596805c85d9a6f6bd1bb87fc6c8b53c219084083c720b37eece4ae8659dda2fe85507ce11276ec1fc80e82acf1810c2e1612d53d7e6af10dab68705d1ae1fa11d28b9022b73c099574150d96b8feceac59f7a8ba877e17a56f6e5bd54416acc106cf0862b00bd6b317fc4967712cdee34e3c359b990bc04a7413492345b7a07b4a4cd8b17b1a4b8fae449485f60fcf6aba35a78d0d37ddd35724d713fab17ec7eeb99f0fde69d19f49cfd89028265d17bd121689eb3e32024b9b204775cb51cd6275688a95e1c28eacba11b116728a79b6b023a7e61dbbe7867eec773f1aae4c19836312d5e5b05946a4ecb64f11be100a1b2eb1b31f79f2174217b36ecdba35eb59cf7a26fa3c26020b3ac943898f3bc2f695339bc82bde829f90db4adab470b7d9b6711777fb99e26e1c645bdc9e4118d16b71631e39b33dc8861d79b56d630d77abd94a77fbcd13a174cdc8473090a3a436f211d2a6eff63ad28657726607470591286e224fdb6fa328fe7669a8847b98270b368a104a88f9de6f510899efbd10f4bfefb1bdd8b1778fd4d46db0de6e52272d6e4fc1f9dd90e476340c7b2ba8a5aefcb8c7e96a5ff44346159ca9db51cf3f5310d1b7bc10d1b788420f85881ec9e845db57b053d7c74fdb083485defbd07f4f2916ebdf813ca5c50dc84f9beb075310fadf5760bef740d8a62267b66ddbde51dfaac4f2d3c6ab16472e0bc4767ff8812ffdf938ed59c9630b8b74ac4ba2abf527581fecbb759ad77d921c1387eefe48bad1e6749bc71d6119a4b7d3bc0ddcee9cb7e3a8e6b579e336916cb1d6e77a61a0b0f46768da3c3485deb4bdbff726eefd33857ed382ccef7e0385ccef42d3f6dd8f9e0385f87ba12948f7a3376da1902eecbcff5ef4a370fb91fd9d963762cbe9de9a3621ecbf84435c46ef12f6f0537d99d37d3ff0252267ea87be203307c74ff5394e081cc562fb6b0f03dcfadf016e7d2f01b77e07ce204ff5bb8fd19033f537905e6945ced4dfea16f2acc7ad0f7e613bc525994db36cb381b828a52efaaa556693728a5344e80c01c2375ae801a619c2a81e7a60141bc127244b64194b649650a74d168d603c70fe188e3c2ecc8f31301004b8b29329996acd41b59eb5ced704a3ebac569133dd61bd22692a19ddcdfa457d7d95bd9a70f7578b3ea5c50a83e88458adfca38913153ed58c1a0b408d5533d86755cd60546da2731f39d344cef8aa09f729a4374ffdd1573d66a852a4c8eaac56a932bea957244d25430d2e083003d50463be6898af09868a7d26188c622b9a99d90ae62a92b9260a3ca078e01b2ddc767adbe19bfe5965dbb92f03f0d03656f8f020a170fdbb1b7e3118b4c6180c465533eacb06ea041a03e3c5d5a736a9aceb7c53a7a837a0c20b16cdae691e3ab52f477ea1c346702af472f118a42f35764375428dd526eaca058f5f3870119caa818a01f38bf9622bd8278619fa01105080d73140cbc1ab2b087835562adda82bd3fc15f00df73b3ca61ce8f37328ef568382aecc342cece8ab1b8fe3475f1d69aab3b3c353430e0ce9635ee6774a6fc4d672e5e72af015308defdcb1797aa7ee58122467585602f92567f097e12401466e8294338c3c46e9d3a173605ee60b327360428ee1c0696cbea84aa632d5ef4c5e0eda646575683ab0cf310e9236f20acb292642cef8f3b4c3fce46d04c16032495f3eda89e89dee22a88d2b4197675c85c388d9b1c48ef5a519616b65b1c871b26d8992a674a76738b1a88650ad27a7d888909f18c128ae019f425a830a86a4f1e7d3c8fb42cc4f5aa34104fde08cb0e394c9ac2cc112648481b094167de4d55abf90370a7d558a0bdef49955cc2753c9ec993c2e782eb80045cef877313b5b09247a882a9a54859a8a6735a4c08ebe72e2acda64861cca7c144a94ebaf49b9fe74caf59f54ae3f3fe153fc78f3256dba90289ec267be7cec8ab26c8b673eee4dc63aab41be92994f9f41981f6f9002cd8af9005680966fced9f2cd1781324703e54d329bdc80697ef46a0d3b726c7a9f17e220bb90354d24123128354dd3b417cfda29f31fc9b1561704cbdd915bab21f00d18d5293fadf8462c2dc17a5184920fec0e3855468b31366c6ae58a327250e81322fa165260b9cf851f3b3207f14de8fd17206d385104248ab330031802b286539eead405e2a798eb0bb30089b95cb1de36b07b408514bd7bb87fd08276c92460b1ead70e4f6a95e2d20784526d631ad157fac28c574cd3346db52af57da1a93c69979306ea29edd350ba74c36b1c8dc3d3869033fefefd4835c159f886959044a4ba2e08b6cec08e9d1a6bf87e882834f177434c1ceae488582b53bfe84dfcdef726ee5ec8f748a2e0f09174ff0185dcead5f51a1a8003878ef21c85833cf9ab80ac56da6ab5ea55af7ab581dceda4b6da9ac80a3aefade94f10887ae5bb12dfaa26411a825b928d598cae6bee2b5be48ceceeb691524ae914083ca4db946529a73085124be1eeeed259d0f168517a73523a5dca3927d542295896c297668b7336a1352de81514d4461b1bc7416183823627f51707390703776f7ab3062efca6014cf3af1467111dd53b6c481aef56725bbc020705695b6d1804050505f115244a6706a5256c12b7bb881a9d3a8ac2fae63d68b70abe9fa2605f73e3e88b9d080a92335e586e5f6d35c00112ae48238b531a965e99451a4069b45cceec20290976f4eef5cbec2c6ab123971718528c4ce9060e530e1d4e9d3a75da820b0f863b78bc000018c453000410c38c0c343d661800010840001a0a50538029e058a0aee1ff12cbd2a88ae5a17d3eaae631ee75faf4a6f7c3b4ed98eba5522db164395e776e9bd329f55992a5f652e9fea88a9d2df29c1e02b960f657540186cb3ba70004ab8424765cb67405c8c25cb1c11ded43a1c42500645141b1f5ca2cae2821801558d29559ccb2fcc006f998cd9e30843bafcc62b6e2e1413453b18d84f4765c39df0339e5a720fc14b33cc5101205c44fd2467bd92c2e1cbb899c2133909f805c40409bc370470682e18ed2757b8a3b843c39c75c3e72c683662d863c48693ea8da7cbe99a10d4c23830d4b48a147e6d3cd559b3229ccf09946c65260d40fed7b34ad292067e6ff8fc7a1b3bfc5b0a39c89dc125b2fdc125b2d51e41b8e314d174186c859bca6c05e8e6225e4c9bfc9f5af1a9dda8e97956bedda2c999bf358c6329ea99c30162bcdd34c38884e4da353abb5d6aac1180ce697f6fe42b6d0c21f39e392335d7bda5639308084f00d6f2199e594e6275866999fa858af07d6c42f734cdc3304ebfe1c964a1206b20556dc1948eee11bae82892ae48c5bd2466b438a5790a2f3c05d84ecc1c24d8265adbac00e445af487f5c81997c9aa4c26639946a7cffb5081b35ccc1823fdedfa04d1f0c0eda79e3592e3f617a1e198e3f673620c321cfb678edb438e5b84fb51738c392e573b346cff37c71c957eec815b84fe46bb508f8ee98eb6695be5667353db26a5734ef6baca6bfc748e5230bff3b6e91d0d694d84bc9fa0474790e4b24ff6c071bb73765c881d8aba6d200e9cba53dbd8351f5b05c769396e2b21ca7130fd83eb01e616e1e877dd2247e9e4be4e2e1c616e11e66ab8bd12db3f964a258fe3429a86c4a6bd168e20c96d0e9caef1164a19c3fc19a2da6fcf6d1bf5aa51285da8fbdf363727d7bdfde0c3f5bed2ed470edf9b55b0fdf6e78fde9bda08641bb7e547ee47a1f6ddc0859e0da9e8bb341cf9ebe7c3d6c295e511f9beef3322de5ac11ec4aebdee46b1866a35f1f620de16517d7912fdf72ddf712e2010f5ba70b3d62de4e2f238ce85b4d9e32a47f2c7df1ada14d87e17d3a86954f3b4f9385dc11be4cb4b696302222fcc0f09b8f56b38822417e6c7fa9b3743a12d7c6f9cb743a18f646248a4972191b649c281e36ffca8fd86e36571bcf613c717d1b690391ce1d6a27ded06285bb45f02678bf66540af45fb31a06dd13e098469d13e0c7843c660ff05c42167ecbb8039a468df04be3cd93b0a4b72c6fe078ee2b5e13712b945be1789be2e044405e5d4b45a1fc7ab374bfd31999365287466cdb7ca3c9d8990962307ad959b93a3b4bb2bad5b87638e4b7bc871399ee198e3ceafcf6d2d8eea9e8e39c2ea8190b675b4f98bd4ef2ced7e4ab939394a9fd66deba17427b7fde55c58027d4f9b97f26079b845ea87359cda15d80bb9c06e4f9dfbfe0a8a5db3859b87251c7fed37edfdb5d7e86b4184ec7f2ccb6d93deee4e6bad557bd7b4f75a04a2c2890bc356e3d1a8d0f7e9c51e4fe4008a99b1c68a7ed7021a36d40ae3fa8f1d3709a280ca7db9520b1410e176ecd51848d44b1bd2a54eff8926977ee743c8438bf4c31e5827240ac74fb46b76685e42d67440320c24cad61f590797527f7b433c7440d6701252a4cf3cb4fbcd93903552d2e71ea72cc5fab47eedf1a894751e929b03aaecd60f8542a15028140a8542a1901129bb45ea6f1f0ad5e7ed4bb11a7a9ee7799ef71d0e1ad0b045425fc48894dd51f4f53d6feb72e87efb31f4a328d4ea9cd5d6fa3538aabf3e10593726ecb6ddf0fd180a4729bba1914d41ec8f7e88fd91e887b4bc281c43ef3d8e87a311ed3d2058bedbcb9003badf3c50fb7e6cf543a1ef2ae87de759db6243ef51d0dfe285a31129bb5d38562e046ecff9d85aae7492c7e851b8270301511a82bdeaaeba542cb93917171c857211046b11fa11f56496140c73314dbfc0056b6182143016b77beaca0b1825d987909d0617c172cf546a5404172957a5b56a55a3dcd4298bc1cac10c542e18524f868911330315b74bd9e1e8c92ad30c54936a52a47a443c29508af5973255b03258ac8c1a56260d2bb386959fcb75f1662335048f8c10ecd8ad1d50b07c7e72c0aa3c907881b504005708828b284be041446bc62d2fe9a0c2cadbf24f856d9d524604c1375aad35a238a8540dd65639eb140d0800000008a3140000200c088703e2e18040a20782a83b14800b7c8c407462381608932887619451c6186310218400010118819991ea00be231d829503017ee523f858000fe934e6bd14408e7c2f48bddc293628b7668cfbd82a34b80ff58d0de48ee977fe6222a58955f1a59754c38eebc5b7c60c4662a7a14ad62fdf93d6308ca6c658645293f2e1525337a4beddceaa9adb35a60284b6dc3cd149aea25d23877de2a0634845399c9e97f975dc4b0745e765e4350209449ec12970fff12ca61edf472a8dec65c563683a5663114f67f615ea3374324360f9b59f8b8f8e925bc3c78bb47c48c70514cb1321624a297052b30ab69e8bf9920771daf3e3d61741ddc2d6721ec3530dd113343ddcdc17c4418420bbc44d145f2d1019cdca430c21da2ec409670f01d9bc8f5e1862ff62a1efcde85604ccf36a60e41eefb1c51bd54c743670b1d093a14bab127131ae1be6bfe2fbe49c2faeb40d62dc18686b29292347407b046573618310d36dbf6379cc9a889a3e08101d814272c68e62035168fbea7086647677a35f461cc0120f0aaa2516b38a08a94216a1af50e83a53f990341392ac1eeb63824c8f11cb85e3a110dd3b03e72638ff878994f9a18c49c83dbd9980321eb172f4b02603f81b42c38679fd8607d6870fe780c11b9d4f18fc5b767d9abc51d2150cb39f0e3c8242a02517254c14a400a37b0614c03a2fb04499aff770a17c9e0235fc2a6df0f0525d6e2803c56774c8da1946e0a8bfe47899b04b441d37e92841480725543b64421e69531b6530a15ff2762652e0cb33294d41af9495978a48187c25bdc248fb47135de44f3435d4c227b7496bfb3b49f8b91b530f7f94fa60080fa9f42be88c1634fda7345939f0c5e0d08937a205b297654355e34881e49438c8c72b0fed9ab6c76bbb98742a8f925367419bd2a3db73d43cf59b8e80988191b498d19aa73082fbe54b07f2f9e0e32917a77b9631facc2bb9a24b39108ec8df7f477e994587acb973b682fa487aecc635b9b891811f41140f41867221a81c41df8aa24bb1c86e2ba8055bfdcc9293845829ffba1d3fecc63b2256d91b01e1abb6f6483807e418ec476c25f1b2571906044e2e19d8f54dba583a52724682627cb320d59133c676da2aa6b3a56eb81983768bdcb47e34a4f07f9fc972a2cf1906dd924583587851246d84704f0e746604fb1ad19ea2f9db8a4bf2dd6689d9b0ad1320be5b037fe0e4bbc09d7a659b83cdf2c05c770c60ffe2f8509e77cdef3e6564aad574f657199f75f8f4d06bb80f0f7d322f778591aff05e6fa7cae2503f6b22a3a0e979cd644c86443a9e245a7946d7f13731c82a53c04771922436f8a7fb7e591329f7d456afe2dc3d73b92412e8c614fbde13a0a3ad0a82a6b2733b21132876a7effe14027633bb54b183c822787f1eff91a9628b3c1faf5ab44a14c909145a0ed886ea90d8e2d7e89577a32bd6c2b3dcd543749d839a898fc15cd9b29f1c933a0a48f5b354977e01ff0d5d021e76991e152b354721490af95754fba1039494ce715b34f82e2bf47ca3fafbf11f202f481d7dd457547616e1d373975cdc5a018ba09234bc86dc91d1da138f0752cdc0e5bf83d1397266496b774657556d41b2362e86ead366b7783911866bb7c7f441133891c063be15ca86d977bf421fdb963426a2d7bc8179ce6a77eaa924c3ccef1ca2dce60a6d93915a0ed72ef1efddd737d6e1ff3527a644940c341db1af6fa9ab93676ec97a9f2038332ab555336888815155d9dba9a1b8e03f3dc4e68fa81003aea8afb2fdb9608e48f8454736078d0debbc0be16a9e7101c7e6559e1e2f6b9793794426c564a0ac2612d2842ab453974678475b2391e0b8d9aaa26e1cd46f96de73e3a94bc92ae5d0f17d7e18528db4d444f2837f33d93a3f75e2e7796ed4b8031ee25d3c8f84bdc11a8298c821630fec94e76e46821cb1f975c3351414a4f9c48379ae87d2088ebe8b9116f9bc358cf770e9d8b61a4248a16d2909acad65c2b08a6c0dc60d53d09c59e838c4f0f1c716aab44e1dfd114f2294f033cb843edc6006664473d262991c1be3f261817066fab854d64570e23cdb817da47be1f9dac4394f8aa231d200dfacfd960e0f5cdcf96ae9efb0b07f703ca50b2d3b8b3d3cc0cdf194e84c676f3eca501150378d63684fcf4613bb32837a106310c9ef63e227e5c33872ca6ac421cb9e7c7d864352192a90a146e0314e5bd9f84ef527678a609848592d523c7d2c612ed23509920303599cd4a0ed794b0a5064d734c39e33bcebf80baa1be98636d1787e1b678d532253523036f182587722876f240745b41c385634f575ba32efc70fc162a1ef248ae23f403f5aa0a443145a76b9bdeaea3f92279f9c57af7c0d39d169f7a40b7159b1f0fb7108cee3fde500e851f6e57f394bcf7520c3da842c7755b8fa9b7d9b31eb787d7a2f5867d0b87433608c164c8ae5edf1c00de6db67c984ee2c6ff6c1a894f2230f96bc71ff709924c2d2ad0fd001e2c9ccdc735697168cb56063b188b193380ff0411ec4b4d77385895e7253b2371e3e4bb17667bdc9f226647bf9d0a59b1ea296860d9fe57fd70f696998460a8220749f2b08d28599825099efc44266468207b8df5eb5591dd4a00ec167e27ae536ae8e337931542554fac246b6f5120e0fc359051c998840edc109fdd81e56ce4ebbf9eacdfab1947f453bc034b3d2c27dc0928bd417a07cf5c79e225639a2f792a028de6885f75fccf8f71f70cc0b46c5f1d539a30d5e812f34afd09510aaff8fa4dddc0822549cab8e74126dea9a89aaeefb4f0307a083617586a0e2c508ddcd706162e22daf2ab62b13ce3d99d1fcd678e058821f5ac770d208c5078fefed67aabb894323331d3fbeb9b07ecba64aeea4e47918f6afd2256903897277bb1dc319c9cbc8e2ff6b700a2f99a7a9e10e4664525d6a821b690f3b41afca6d4b504aef3129a3e020a499760829b0086651e0fc8262e80ad8d7e8bd501481a2599666bc9a91f7e84f5184216793e54f10c1ac7e7214092632e603a6fa6c75c77fca21451731fcea82a5eacf26a0e2a06731e8f74cbdb7a77ba73a716ccdbd220cee1d266657f9aa96d9d1b9ab6b9a63ca7e56faacd8a19900d2edaec3fd32bab0fdc2280a4613f46d66ee7fe8523be24189fc9a1569d4d3db08e9d673e4eec35e862586773f2126ed00cfa240926df00a4e6471533fce91396e116474c3c0106f85291e72f4dc2f28163a115bac0c8f82dac4d72b96ef6141bc6c84a0271cc8ff009c38bb6affb12ae4df714c8d16bd880ff41bdb235e4f4f3679ed375198ca3c417d03bca9d68a9dcc8721a004479092519428c9942a80cf2d1fea4bf1359a0abcce9bc687105667e614333327cdc79f46d82a75f2b106c65700bc7c2fe13e1b3db829f677692fe3bb93ec59d188c96b38ab8cb27be0098ae03ba17e35966e73ff587cb7872717d8423254ed537054f98497aec21238c0916e15568d0a4bb2d348f4bebff37cd0254a121ba9dc099f059d1e26e829567f7ba94892b2e6bec56ed354a7c435f4dda696e12322fe789508ff8d59abae962ddfdc1f6d07a0a792b6c2498e492f0fc2a9c0e071981da593743964466e5aa8519997f355ff202c5b53f53c0df38af0b94cbf1f5f1c0a490c4e1e82d56c69188a612045c218c8ffbaa50dec70d26672b44ffe742e19a7f6fdd2663c58256965e953d367e1b1feec4362c335c1f6f5be3f2e2678df5accab67144e5f1d8c7316aa5637ef939915997b923018a2dafbf67e4c00f1ee5b0052d57454b90c204eea5b349de4f8658b1529760d362f51cbbac81f275aa24258a1f6119395a41b059d16923bb865a86be5d9b31bab77e9b0319eed1e88ee80cad6f9eccec4e0450aab8881e3b932d2cec9bab0c695fb0ddba3a238df61978543e1bd7e8555dbc85163f63d42f58e2762dcf7d05fc1e48984130eb09c6df7aa6f8547901942b079802dd79efc0763aa40d4a1290a9061effaa39b6b0db3d38ba62b4ed2e24677e4b5995d588bdaa417a52dba137a069e954c0bf9d893e5887a87478da10a3e5b2d238343c8975932ef3149c139ce0e52d704ed288279dd4108868e0c5fd4d408541643466f25bc4307535ed3bd21224e36b2f0a9c44563e81765c487668acf99733ca5eeafbd6ec2f03f4a4ab0da67e70c0404928832843367f7dd8dfa3e798cc300f067e646e4cb039be3f0b9ee84e2253a2689b4b233434dc537e5285d1385b58062363ae6ec809231eff1f258cf4839f6488b753c6b796ba50da9ee60ea084c936764dca09493d382871997036073667513e39f7cf84daa19e440b18cec99959a85441435bfd08fdf62e51b895b0c17d91247681ca79ede288f1590a41a93f991ad39882360c5ae27cdba6aaf167260429c5793cd5ccd9b1adef5016e64d981bbc6e58f84290e594de303dd5c45f7fe94c4ec6308e1ebc34decc3c5bc0fb7047d05e465b311ead1066bef6f532394d299dbb8d7171522e1b5cb450bfc9b4f0b8cf4afe402cf115c2c3d56f9f7dcb4428341ef1760e68a058af0e807bf42a18adef36a6c8dd3f63957416e08f4fba4f40351eaf5a009c1f3d50d7f9ed3e95fbae627b30ee21495855a4e512850cd9360bdd803bdf8449ddb9ec73db4f2c283f2ca602cb662438f6a1e227c3c135bcda7d698db6360d4bce879e81e189dcbdbd124c04d95ca03d5dc274f0f5011c68a5791f7a6c817d95d2bef506274f3b788c44a69464f2cb0000f3d7139b9ade9ef87659cf299f977d66c2ff1009b7178054ca3fa7db27ab62178c73cb38639ad5ac4b4f9c90c09897a5626750823fa3cc05a2537fd78f294db47a1f3a4a3f0df45231440ddcda4061a57807b421ec3c018ed87cd8fe48770cffb8825350f0ad8861e7a64cfcad27a32ea9370d26e0182db8f2db2c6582717a315adb60f48c00d2a966becb3e52383ca89c8012698d30286eae20cc8eea74f4011bb78e021da309366e49d047d1418eb580ae9b41bf260f1017d2f3f22b04061a0890d9da9683f7cf16a23336ad5010d61563857c890b1e267f11647ab93899b5f62151757564adcbc5202809efb6230cd1d19947b9fe6c38af442929805a357f3c9a3603cfbb996721101a13c5b2617512b416e7dec41999db32e8088502681933ed74ca29c75fe1f1352b4b94ff99731e1e4e79938ecda428228f29f160430a8aafdd90692c71b0bb976d944d1653f3c5dc8e567154bd8b756253e0e7580c0e6fed26b12003a7a8a13ac5ad76f45f67413fa26671ed93c0385c6df61b39bd6faaa109a0829e07143604f4801e5720458188e52959a5d7d6baca94f853d4c7065bb0bc0a789b60892ef01a8d6a6651be0a5803cbb28b5f3c3891b107ee99424b8d6069313d2ebbbc35e62c5805f0c60992c5e090ba1c32fd17e4d684ba47b851809d60113180c84adafaa24b7ec3bf08299051f3980117945db3ce2fd775d91574b1e4b3cb607a488eadcb387fc028e347cedd67e5163b6a34ab912383e3726ee01b85dd017e3ff17a06040f0357e474958ff9aa76a7c45c289b5ff245589b4f06287be8aaec2ca4b1c9c8f18a68c1954cb195a915f8b4cd8edde3fec5a9ec30fbb5496450144f8e2479b68e1e1ddc156405f45e28d0581eb1779d25c272096a1e856c190bc399c0e0c0d4d1bab1388b8fcc69e1997b1397ee0080afac909e7c045b2b181e6c6591e4ad92ca8fb6ca2e1602ba3d5881090048e7cf52791a5acf6ef22e49d18cca55ed2041ce1844555aeedc6334ab92b724d2f8962b5c264750a3c11f111af0fa4befeca44aa2c441726bdd51de875962ee9d673d212577e0494b893dc9f1f2076ea2b3af4555c2499f13d27d358884d030984c59edb302313af9b802246fc50a9664702315ed2c0bed99864461bae88b3e40d254a131a20a7e6ec4cb8081b6282a7be3a6e64c3ad1a0134be3d5dbed2c6932403b629b448fb656fc6562b68bd51bb069e162e09cd03dab434501b48d40481cdfcb9daabd62da73ce2a8a3bf20fc615f166713a7fc8be1ff082195134ae95c96247a4ba918f19fac2c26c4d5523ac3691aa5a5c132a133ad894579c03b3da7628cb296ffbc0f1c02b26d2fc7944e67915601c2d5184b79ab07f6119d595eea475d0968bb2046fa9fd0275a0c9cea1a1ca459abd0e309f723f2d4fcda9fcbf35c0287cd846c27b58bfb2df41090a7cdda70a508c473e33e733ede6fe8faaf627228bffe8085ed2f40a6936244ab85aef85c5bca5d02e0240350d4b564f65d6f27d3b9097fdd8260179d0eb1fbf33905a9dd9b693abe278436450cd299399907fe14032b97261eeffdbb20785798ad16774c7499abc7565588beeab1d9b62c6090d89c31a437633e82b1c861d126619c0d2537069f7f30edc2a2b3f89c9c0ef202035d7fda3d44ed9e65cb9b50b349766205ea63e24fc764c26ee49702dc836b427413b6eab33a95f77e0eba02375da3544ec7ec50997d46808267f42baa67ab44ed7d28aed67c781f8849c86f18abe4ef4c52612525d225ad2aa9335e7a7b6da33585bf1d6f4b592e853ea40d67ac1eb14af71ddc3b482026049b7146318c5b95051158bdcbe53a46329280273f235588625a9e726ff33c793ee859d082bd3151694f0f89028945fed400869570905306138e668650bff26a7f1b02a89654f0db86780258bce146720f3a14a80fc0cc503cfd3265ed272291cba4651cbdc0e4c3d54233b67a994ec94071e17b10fc9ad959c6863de13a3509103ece71197154f810b28aac71b810b982c5f69555cb0561bb3ea3b50ab5ddde324b7c4c19d2fb1972fa2a3b74e4a10354df1de5d49e35a79a8291ebf9b2fee7f6c67fa79058ee19ce729c060131d2af4fd861b510db865088016e153b3050a407f3d8754ac56616cd460a130f98c50babc8e9d575658cbed9d1d221d8b00651cc208058afa0b8310e85cc80a7ddb6eefaffc2e24f7a9bb7d886f1ab89ea8cd108b770f5b4ae139cacdff4a5753a2cb2a986ecd8d1a5672ae03184621fe4e08e210fdd2d3253ed57408c8d9f8a1727bf22ff4810deba87d44c8ebb40a3d7b1bb00640567909b401aeef254306c34412933e4a83fa0f614c494617c85cbd19061f9e8f1cc778453a8f749ef7c45c2ed2a362a8a9333c781fde05dcffc47a7280b957c8e75dec96b78878f9f2eafd40486538f0dc8a9e39944c785d1369c52172e5804b865177c45ed0e44dccb5bf2f1a5a6ab004e73e5fea79926bd0cea3a79e3a93618e933c9c954fa3a37395753930b1fafda91895b12c721f475c1efdab64105c874c130a5755b2daa8d82f4e39a095d9fa488902783718ef9ad1bb24e65ad1c63d9567cce61e87f6b5065a3e2929eb8d70e20aafa251934ecdde984a68e2f1955c91ea19b4e72a7d97c4eb0f85d5cf6bedbd8b12760395cc5b1f55fd90b9dc34f130ea2afad88ab917a9e66a61aaeffbb2946c79c6b23b161440637c1e1b19d7a79d489f52d347dad34711c3dcbc2a220054907b8b7999ef97cd1fc1b298a2a2864974c11208252cfa11882f9bb40d678d9d05956cf293512ee9c19b81fd6469576f48e8d1ef735fa2adda5059227711937d7cd7fd1b4f82fbc2b83b198759043ed751758359cd6da4fe4951974b66fa6156f5200164607de9b8bfb0fcbb561625f65e683200c49793afb5cd2f7ae0a9d5b3e1aea03873e66b1d68336534a935e6574c593d589b44017bd5c1442d51c1377a1cf7a020e84c220038eb037822945d2066bf8bf94383348cafd4ec43f15f965eba005dfa38c5f94d79dd0173418361c2652c4ca4014c6d0cda75a790a6c3b6c77e75d0c172c28e944d97def7b9bf023278373652ac0cd40851f94470874ec892d80e4205840504dd402b76863e2303983f840333d48bfc470146927868b43caa0f9fbe56af036f96627567684cf90fb8bc94437a27313e898aaf71de55d93720a664894be15e04e6b0692eaf21fa7ed279f8ecee91c9fd8f467f3010c54e58b8c3ee3cf83588622120379851b4cd506724796c55f7c137466dd480ac5c23d954a913415362dc572455ae454a2fa6092439b9c6a5632d84ad71aa96dc8574cd10d4143870757fda0eaa43bb958222f8d4f7e664e680ee7214a31420da84cb1fb486fae544dce469705c01619d9c14777395b892979c8276f4e656f3ff1923bf5f7da8e5dc75a76dd63ed1027b3b2512661992528744afbcb8384dc81d9c1addc6d13ca3b4ac70f33e04fb5c09c61d7fd5514c3109453fba7f7376747d22356e95a6c70e4c2d30e43d4f8e52825e83f163451592793fb1c708164ec42cd069b40ef372faab79aeb5d08e02aba14c8f89772c5c113ad6d4c635d718db58157d815a4a540b357f6686b29886a4aea35b1704d1423e1ea514af9eff46b03f7e40c146befa2e4a082743a62e493c56a59388c72c3b78637e7bbff6969afd01bf16b2fd8b8e0759dd5281b2d690b5445a2600ba3bb5515997af3c8d70a40faa3c1b6087b63274a8b953c88c22225637f931d6317e1d340abfe51dce3c8dd119ce2ef6c68a957288fa3e424ecdeaf16857b9189727cf047ea352b7e922e6735381b1a3e739024cfd994f4354e97e3df4227f08e61f1badbf04485f10658a42871c8f3df3f360f35c3990876a23d97f40af8fcad37b82ed38419ad85d44b05b3792b69bbf0a538118210d56c9d4333fa67820e086f4e56ad466e606c84f4cc9462702153efcefb9738e769f499ead904a0a266ec8e39eae699386d3d1a7e69c01345e61371e855938d850fdc6fedb294ae41bac012c82413f3f2f3488bda9195b8929b8c64d9e603e042d3824816f551d775c02bd3e042014622d81ea1455d3d8680b9020ef09b143345d436b4465d050acaa6bdd20dce09b342c0965c976d7e9c25811478f4935897280789c09e052abb292513246b7292ef97b1517837dbf7584d7826355e0c4c82ef4bd88cbedad2485170a98539c7c72774d0b2540bc64188c89bd4c05e44be5e66bfae8ca6d1844ac0aa6cfafcdb2c7ea527bb247fb12b663922516994b220407241a8c15df45c6b444b39f42ed0caa334e947ecea01e0e01b4999fc8495211cd2f03f5342e3dfdb1f314381cdca1b12f74ff7cb04bc79ed7b1a33347745c388eb07c760114d84ca408d1c2c6eeeb920ddd7f4b89be9c9c319e6a46769846ad9ba88646391849671d1224732c42b43c5fb2675a15156caf76d5d332685408b87f92245e70db3c999e57f8ee08e4cb6b836568e291631cb5a634c018363113cd8b3cfb6bdb6e542bc74b74e574cbcda6fea681b1b81da88f32a6412873c804b49388c3e136da31179c529214288ebf626180cbb29ada0c0e92697a3809ee35d5750a928a5a01ea0ac8e4f3cb615b002bca4909acedda0f333409b6a8ed4e3245f99bef2a4fc43a73bef2fb7e0e3d0e7347db10beec567b7f6d1a0d95bd9ca1bec8a6c67c091fb30685e80d6f9df290de3f41b8bbb3a4fec9566cea4745b2db16939930ce3bd515f85d5b054d88475c0bda4162217b89aeb02acd805495fae0b5827ca969cdcf76bd89480d51970bf68df2eea4a53d0febb1f76761c0d640586cc66e62c8f85144b571096a6c834dd44bbf2ecbc343ceee97e0570b77cbd8194313241a8d6f814684919f26ca4f9db682b84a6d591f1627ef86871d79e8a3d83d84f62c0c77325bb241a1b45e6580df458b80d45efcf3ea95b322aa279a250de6927100e51c66d354e259170e4afd76033d9977cdc7e34b2846d1e69aa3ba28c12c3b476e67b7b868fa73353a5cb2b228ed5ef9e33f85869e1186e487e5fe96b16a9b5a272eeee82fbc525cd913baa6052c51345e9e75a87570bb2189594c749b3f56d395d3c95392e2f4efd9452f95615b5ba1cb1786d18f655fb0ce96ea9525d003f817b37329f8c345bf4eddef37d1cf1bd719028622cfc2b325821db19f7ba70ca00ae07fb9e6ff0df889c884134f86796a680473bc76ad9a9b8b79ee7ce6b782d652615554de6fed04bc06d4c5f3bce8afa8171c83943ccd4938b296410aa9cd437b9fe052d0d9d2c078716da054ad7b430e9c20ed62cc48f3b0b12857949afb94e68e2d7779447ce82038a4fa8b21276704162160b5ae71a9a9836070e28496a2df502a8c404f5a13b6880185794ac46de8f1e1450c069cef43213e6d7d067b47545ed0a2bfaff20f11d798c13cb7c0ea1a29814602aca5d6a7d1116f97fb6bb8928afe32fc443b7e03448dcf4874939d2fb9dc54ec2be43f11509cc9bfc49e80cf4552cee392d321a1e4529a54b904ac7a88097663d64d949d90f9df9482f866cd027d9394816b029639427f392b781a70971c310ae20e3591e59c76dec0c768c1d3184d78891321861333118b865d15b14f08487316573211b30fe70bd8cf11715acd5278cf10a3bea32221d5269fefbda5878ebf5e45ddf2f580b1e0a1f19e3bceae34a3ca7159d3fbb125fee3b28405df5d8e0ae8d9c9cb25ea15711ee33faed09b2d18771b047053ee9db5f54c8451d475a20e5a17b14d88d1c8301264099a13358d0639bf96f600c542a812424348cb027f0497f9fe7b13e5732f99a389429bc1f11394787aa361f293dab8b93b52a80a819256b34183c7a99e35c1017c6de0eeb1da011d07809e703394b3ec37148ca8fea80e8692c19ee376cb7c6ed665c16753b526e43c32ef1f1bd40ace941cb2aaa1e66452427fea2ba8a75fab091612876a1e38d134474b6dc3ad6b9fd9b3f94809387112a9dd0ef897e794285fb66e4ac3eb393087579e873d8b645ca62407f0ab9d8095e7d9cbf75008d63c3906ddd2f69b194ad87279b308c445cc5a508f8a2c0227180d483053a945664be07935c3d10bb00bf16f8b34444fb3566a0bf04d0df57bae4bdaedb39497190f3556c51d19fd7353f41971cd0b7ecf145af628b364c841c6d99ded3d8eeaf3d12bedc1288585c112809dad72c3a1141ef622ca7cdcec4ad074305f961212c497d5e3da196ea4fa4b87e00ba79012d0914e225461a172ebf1c89cb49baccb27c31383893d463c2ebecbc5d4e4a2c3b54d0e38ac21b90c5e8a7dfd820d074d70f2dbc5bb1c3cf01c3d8153fcfe8e7768d801dc8904f5f2a77d0b8c91dea52209aec560413126372ae7adc81f0b6ae0d884be4298a59524ff80cadf0ed8b13804f9ee9a5376cc241d093b5d04bb43d01633c1c95082b975a7bd22f27878793d7bb7ab12a665cfc727bb4b30bceff3740683a3d17ab1a07db3e5aafece1ade5cbd1c6506e4cadcbf36a82c44c8714899b699bf1a88637b66f2c9a529b2c3875bf03b4d20e451bb4411dabaca8a03dc5cf031028da62da85bc971de37975f9f4d787cf24de9f236f7fa543f59c33b8da97a6c43227be219de69717263d78605fd8a262ef3bd56c1264c03834d1dff8cfd00fa49b9a18e46bb76633bb89227e609978cd67678572dcfab9405093fc8f92fa9fe8ea643ea110080bd1bb65c107c6d1516b5d8ec820abfb7948d8a91bccedd2219c6f6cb123ae369adf1cdaf44512d425acb64e3229acd232da5259af0681efec2a944ffefeb1cf80774e41f96e488f2f4e3d9e5252364cbefc358e8a3603e4eab29bb9362d37c3a0d0da615934e2d83c51fcd725a16454ca4389ea59efefb34277ab9ec678acd1c8bb2bd39db618a5816098fa94d3fd1207fd74b547ba1db55ae113048074599f588083968a4b4b85c0c84248c2454c3560c5910b455b2a3c58afd21f71767247e475082ab953b7e45f5524e9582465da05eebfbd6997e4f992b2f4f5a4db881c06c0a4d7d67bc1f89ea57781af84669ae280a0b005cb07592305274b13c07cd274cf89909791e90d7ba5677cbc703b3ac5b6a2bbc0458d9430b0f4e52040706b70b28e0a3d51edd8c334f4659e53ce3ea64c5818b52cf7a23b852634ae66282fed75974027c7a2fde03d72f33a0405017752da647fcc6586db16759d20ccd138705eb10887dc2b1bb9f8dde688f2e05b4cb06bf1f171dbcbd80c00711a3b064f5078878e0587d35072b00350cc416c71bffc577ba38cfe9e967af0126ee13f70d83e033a285c5d09334bca6c27ba71d4e8e328cd8a3824c3210daa9f7d9a57878468ee0bca12ef01190798b1a3ffc4228f214d449333111590d5e9085957caec71d2b76522de183abce98e283929bb0c3c32741a628e284cf4c42337dd292702d28e9a063b65193aa756b9b1eda37e107a249721fa66e0f566e236b042477cc24498bb8e115ecfca982a118f28991640a8502217a6d9af9a44964c5451f78eacb86ed401f0986db768170609ef253a239de19d036e78063c364888868eb4f10c2f1111fc102250502d7c51fe605aa6002b85e909bc48b02bcf7759d2e4d8c4208ae03b9c850bfd5234c496ca985aaeb6efd7a03c2916e8861f80379887ace64a8e5f198dbcc28c6d44d9c4ce7e529bc0ca89ee8dd376702f2b4a8b5c505884c3894d7888b7a620bd351be945398c0a85df348a5c5e1e617938bd8799b804ffcfcfb56b9466af445b4c140b745c255f69a6c79349a4c32a1cfd44aca486ff290fa160413f9fd7e16088e5304ff2428d209c36ddd3b0f651d636f423e24e3320371b8b03a12f390054ccade002aae2422e84fda2f007b3e7f929ceb911de67daabeded28e3995939401ab1ccfed6cb211e1fb8e9c187518c63524fef89127360f20a76c851bd7c98df9980922f9671015a120dd825ce4a4e670314d0d5923d733f64cbb2ae0954e47e2e5c9cdcb05f3f7a0d2b91111e5c1d641c654b3f12f543fbef36f58b32b80270d27e48eeb3d44c9987368972cd5938890eee583a4528daa243cb9d2ade01318176a1ec83400551d746c05257377d79dafe0e0d5e1dd9e0445983c947223a40ab65dcef9f373b469a651da47e74725e73d077ec8e6965439cee220736b156d504384abb47256734552ea69b7e3c8c6aefdfd39f684beedfd5addfe6a32c8563234d1c9b611a3e59682de7efc3f9cc9523a56e9d1beae5aacf5140103989c2fc295ad7a234caef29f09fb5e6c8108683702b27debefec2078b7bd8f30d63b3dbbe5a09ecc83aeafad2f8a7bca3eb97811049ac0b7062fe9bcfa42ee160a889461a9d8480ec0e816c7beda7fd032f960be7adeab3b9c8caec1322938b0c99fb87ac18e95726d3589a2bd914ee15614c8e2878ced75a91ccc2b267971f6206033d6c40842659c1870f6f464d0c4966ca4eafb8389cc5c979f83f208c3a8d5ea6a5ecf2902a3fdbdbe7d55b5e16bcd1e2d120c58a4eed2ff44c5a23af32a21eafe5274ae675bd202b1781b7b977bc458f31341cfd3a5fcdcfe4d16fcb1bbc71d36bb536bc0b41860ddba15cd57ac95a4ee5a80c2ac4628206b616561048263bf22c5ff297ba0589ea6596df46e90b8098d1606bbc0d8cb5c1374f38568380e479d9d93ec01835b218b3ed3b6017d4f146672bb16272407914d98677cbb03d85075738d915435a98ee133ada2bb344c77f03229762d1a06247fe9559683c493fbb80a63901fd4f30c9ced26ef9665f39a0cb7827a2303ac124d2cab1ad8efc8815588641a00990e4063113cc3ce6e48e056335808fff5bb61c61091b26e2409cc591941127f89df7548fd6e0a8fdbe87e72265b03bff47b848ce41d279cb386505bcb86e1512a82682e08f039accaaa3f1d821f8b8ea833e666c2bedb0bb1f41ce8b1f41b25704321c5dc7982e73cbee39979d9c8b07a7c1ad72f2455de5e6079621ff4397c95624d4c4e44f563a56fb85ce99d6693187bfcdbc7ef206e312f597f6ff9b4fd2ff8f234c3c873d66afc7ed2093f3fa336ca02f5d93830634cf50cec09e5dd3433f6de986aeab6a67dc425b6d72fd445846b305e31347b76ec7c9e7d26b0228e50bc1cadbb018cc32c211f40973cdf5a195e6c31f891c26d75cca0749b4b01b4d02309819702979098e58cca06f06ab16a7ed5b09ad5a57cb942e6bcc010428c38bce727881b00cfeeee52de91335e62b9b31c3c7e1ecf528d05502ba54c4e92d902da8bf41db79a83351565998c25dbedd2dd05c068fb2d08325c480095ba9da00320370fe0cdbbd9672169adeb1c5c013deb0c6f7824e796a75f927ba961c7da8c82de7a2a60552eb63cc2e7273ae33caa3e8c15def0aa967dab2c1235d47204ef60e8ac14ec39c36dc66272a09d368693d64e1a7d8548b501b9d64436f578cc0a91d7fa1ebcc0711a8a396a00f098dfc105b8fc4450ffc77fc1bcbfba6881b0130f04f78fa6199ca3e2ade1e464b2d54c3d9d36f3eb5f6c814e08db0ccc8a76b8fe0aeb85e22cc28c6b76c48ebc9e4c936c8cbfde80d50067932a70488eda1cc5418fdf0c1161aaa3389b47e3568e02efc6a8476a7a1c95edaf4cebc1693e46c57d739fe01def2e988f36c9a2d86089a8205a8f66a017ecd373c5fcf5c9a7677e5bb2564ef4187fd61ef230d5bedb92d1f3376296d6a1f738f8037c5425e256e2d54a054a277593a3698de56f2b439364c9a8ff736e74e993a741df893fd7fe589cb2097de9d4892cd0fcc27df14b77d7d6e2a4e32781d442a1e5c3ff5a487038e8bfe5c3aa06a8b44c53c4e3fea58e58c9d6d59e43f9c455e633b397bf3547d611b6e0fe3263b90fd73e503155d8135139d6ea9bceb09dfcbee6b68d518ef4833102308f05bdd9bf5e872d11da13a5cea7090c6215cac0eab1a07306d73731c952939fe242c1b2898b4ddc289d37ffe24a95ae4157389dc9d49c8b8f6244b2b55150a2b45e149a04005988b148c8820015d5117284e9fb3b9a927bfdbf90611f5345564eac866f1a22c833b2af3582bdbd6aaab9d683f4e45240ff7aa142329b53ecbe889501b987441c07c799f30585fe236fa0e10660b4c4bb9bc5daef4d047f0d4b9e69de3d5198d97343f303090520fd3832df14cf52cb583e3a6ae78a3e313981ecd011150c5f52546ab710b1d5064abd2d6e1a250b1e325e8dfd948e9b4635af7f821fb0f95e8ae8cdfdedee00b85f71430b41905ce800b2fd544a4f19afa98c9ba5019845343640308146e5ba8ddbe8db12775e516ccfaeef95d2ca8eb6b4b7c1fac90cb34a6f0fe87649fc06acc9d45139c4b2d0f4447a9589fca8468efd3465d36e01ae6c6a556df1417ce4da61366f3b4359e082c43f7832b46c64f52da8cd249d3c30163eb948199532daba5c35013f8ff5c0f246adba9cf79a03f0ef80038feb71211ee59bab93d725d11efff58b77a708bca225c6b40eb87bd468051d9028d183025c67c6b9b8e7c1907b8ed204326cc6ec953a385a8b13b532a145d74d78808b17360117c68bef7be55f3d8f9f1910d46be16b86c3f8d810235cee45e0945e111541407b8f3898c8ba21d73806765582bb4928b726323381f05acceeb205f0f65fe50fc70b016cdee488d459c4f6215b24f8e0f5e5dd2c0bab0a1b2adadddafbf6e10a9ff2ecb0478da5d73ee4691874bbf53af8dad139cfb2a97cc9f3b5be8edaf5602ae0f6b76fb911353420ad352d76693d5b827e4604f7d6ccc57556f35a9dd8a62b4676f062a3f9e7f764ca50b4bf98e15c5fed57208ec61e6aa52410365a32a65e31a3e93dede1b81ac0b921612618fcaf5137f0316924cb2ba91afbc3f088b3412f0ee0ea5c0f05c771a6c00f637c2ff4dae3abb303c073a4860960403e720c204e7f1fad39709caa27d337b3d8f572b435cdfee518661a1fab8e64c7aac1586b56135d92d04ee9f4d63bd516c0b8373841cfbc5d25c7e808eab1e4561e0a7a93ef7c731dabbdf6405a5f8b1bdd92a736942ca38c1eb349ee051910a27e10fa7b91ca5c36b8823aabef1560e81e719523f575bd954e8e7339e6bf5a9e8898e34a5044c255519bda83282a5114250c62d9ee4ddffa2f527888c3ac010c8901da01f4464842662a07192298eb8ceac5f06aacd9ec8c095d83b6fc4750ef763061710191f7f4c928bf0213922e17cfd6536e7b33fff955b81169749f1a24fb6bf3cfdf9b97156092585e526e78c3784ac03e78a6972122ec1f555c61ad2cff36ba604390421589e045a8d8b84c40507adf6880059aa38f437afa672929e0c3aab215180009ec6aac1beee8a69193f681eba3c8191780fbf1e20b8c2f1f62a7a115b98eb1e41499b8844d362555183c6e3eb8d203c692595ddf8712006d00f7be4fdc6b42c90b9d761a1a391f2804a517fbd31befa9c2c66238b965d8aaa705457bf331492926aa7fa412072f2a55d43b667c3572a716943480992cfbab67cba785ec4599643d24691e11e90ef8a5fe71226254ed1578e01342370d100a0b908d55a319bd39f03b5e4f8ef37e08f08132b861af9d7cfa2472173224eb4b1c38bccc3248538457c8053a530a8ae51adb598f00526cbfccc4c04a98af0306c82a11749d0aabbd1b6b792271985770eca1f4997a4ab0c6d8d5338515f50a40d8c8459d845a8b275a4ef9042e753d4f5db404563f4b071639572520742d9187634997d189dbfa0de42ef91b8763fbbb5b317d6ae28543b9d112125506f9e16be829ca297f0c1b3df5090a63763051609219350dfcf5fa94678abcd5be8ca8339671a17cd1c03ff374ae99f51bd1603a2fd9322b3e8e4cec10fa41f4cc756bc46f3a1ec5d0f301ed8ec67339f317579e66fb081581c28588ae07f415013c91c18fba3b17708d838dd92f789e061d1356d24ac02c0dd0d8d3ba44f89d5c8068e967ceb94889e3e9e87064450dbffd478324cf4270e13f38285755964f537853fc403042b298e68b8368f58259cd3b0ce9bb468b55bbcde7aa59f90b3b4629364c128dd11106a82541c474d47441defa9a7f9938c439b8a2997211d64c9642a607c27432e8c6ad1ddf089a30ec1f4509bc0c26b922cb9fd16c68cfa4cb6db18fe540352eaead0413a5469fbe9a65cda02c7ee85ee788a1fce28727b3a4e2eb0d320e1b568b040b8c4bb85aec536a096d12d0c2ad7adb391190e3a986aad53d1cc8640f6f42e1375e6a17673b6af547e90ec9d18f0c7e447f8109d111f3446b3c72ffbd4e54d4e95daf9d7b1e57a0a8dd50c5395789b2d50e58a0598d51e682997d6239a6235c1e3c1d0415cd0226df024a5d5a4c27010ab4488784b62d83eb2d66ff073183d34b028a101ff8c223eac5731199bdbb907c02cb845d3abd65008a26b44b5ac8195b12931140e5271483179949ecdbc3599abef333c0305bd4f7005d9bf6366428191c05f3399ce9027f82b5f5812e71a14ed8a77c4d0cd7a8b9084e4b95c997e3b4041a64a454ff9410ceba45f069ec5ac8f434dc2172e147c05c3c255a094cd68609be864c7187b95aa7c5ea772e295581975fdc8624c10bbb847b41986a1a18f6385930a229bda2ed9acf82e043662dbfb357c6bdc288f4f2f1dd9f77ca03ff6f0466b223fdd86e13ab702b56faa9a1d2124363f76b2e59dd73d62910cf27ca79b55bcd0c179e0a1eaaee09b3109ccfa525ba8aeb28c5c329b5aa16eb2b00aed95bf1f3d53ea74f7af1c0e152137d7690c7e59a8a7442e6505a20e556a8c6d0361215711ab69d2ecf02ca479a40cf4479b4d47c8e082d13e4a78a1fb250f3a00e2a7b03470a6e790f266847048d73c388ebbe0576a69a21867b50a56d3240b84eeb1050ce30f51df03facf240fc2737b75f20f8c1f0bfc00d985ab818a44c9c3b43c214af8684d774b88823520d9986bdc0030b48be3261e90744ad06447b62123fca6aea5c073ab635d7de7d15104668d5471c72af988a05676de3d14e2ff8b2dc947626ce4987912034bb469ec6d324f24d2e0ee99d784db08fe7cecf5b1a85aa0558531a752b115c0f2902828ced5ae075662a5715beb97eccaeccc5e2204c011cfcd0ff0a73b3f79512a78d65da5f2c448e41ef030c2b793a33b53233d8ca4caaed376b14f1439904c84c6a534eae9459c69948654fbe1094bcd09848c0bacbcc65289c9ad8b5acb7253c9e63d59047c13374ef98a28495f3dda9c917b0174726125df9f9242e258eb46ea183b467b38bd29773a06ae66edc46e5d3ebb7c30b5c5ba2d6980648505cb5769e37af64ecffc9c9fba4c3e1236ca722b7740ceb09f8f65017f45029694eb6ee9366a50715d36e507b1462eee151948956beb9ab25824611e58059e24bb288efb57bc0ae052fc7184c732962b75c3f599088e0b2145dee4b46cd260e50296eb3c4334b7da4757d30da6ee8a3dc04250ca2ec6158c4b39c02e002a30545b021a93569152362e60a4fce5e2b0adc835fb1fbc91e79c5d32e3bc4491944abefef218349fefe0615bb64ec6086ed398ab56074b98787878650a5d84ad8688c1a4815f5be54c546513d381a6e744de59086391621abc8062f4523f4a3ffe4e9355cbc8ba6455ca6044d64691c215b44bef2ef281d8a2074969fc411ce749b3f8de30346694764432f467d152053262610252f89f67f47204e3152dffa2b00d39b122377c1906cc63ad40f38e4bc1dc49a3606060517cb5453d0434545ea8e02870b859d2797991933fa02d40022fb9f4ec487b812a6b2c551656b6162d6ab1759e212cf2d42872a43e0e3ec372d24f37d0f7a0e6daf41a95c80bbff0e0bebe6488af7971bdee534414e3251f37d3ac799860e7f5fd4b5a093b152940a8b4bfd6a2994eeefb0eba935904531738fa657f40969208c7f7f2994a5ea02f7a8ec9d0dbc9c4cc21d7bdef28a753fb66440fd19f869495b0254b3fb5a76310280719d06aa424d6c656db36ca44013692b63648166333396415c843628f94abe19067717ddea9b9b8f4ec0f5173844da8ddb29f5b633229295c741d50b64d846a6919f798061e383158e3dcb2dc83e171a1a0db89c16000c92fb1e903789fbd75ee15ffdf1e465c35fff4364afbfaf0d82d4a5c1b64c31369c2a72b2f484b7b5c773234f066760f09a3b486519ec1804b14f5ff005528f40c6c140be2b27d7a87ad1cefee41d59701c540c5fe38cb3f408a28ae60fb1f489c352821e5f3eec3b983c7e84f070902cf36a5f0329dea20ce823e7d52cdd341faf293e4d3fca3b6b4f59a01d18d4fb3f0c8ecfbf3645782d48937c02f98d68dc1790220554f573186f890bc1748a4597574a351d09bbe7cbbb13eea38a36032b7520b900d31dfa05b628ef1c880c30eede5673e8ef87be4c7e1eb3e55b866e0a79dadd40aabd51e921593fb3eabad598bcd788bf04b2c9ab31c7e75d4e10c224a11e9cd4ba65f08e3cc21b01dc220f0f6f5ed04294f40b74bd946c45b5dcd841042204f87a0c9717aed7ab3d2a7e0cebbb3119690915dc9aca0012a7ef3130b7536e2e6ee58f192d5b0ac29fc0b596748b9540714395b971c789a720136ea2fa8be33155595b6d6d6772a90b580180f8ce6841253249b30222e85683a470d91e0ab8f4b70bc75d09e98134fd31aea8ec283a8f09de0a7ee68f366764003e7f76ae6ad0b9d7cd06599c9ef408b1dc97c52c82833c5317b09a78b3d65a375e56e4778f4b56e9b52f5b88efcba089e1a16d9a76bde1d1a2b4cbd5482a26a1aad7a7c7943776cf268f8881cfb7c09d80e120685fea9d962354b9b78278d0108992b8e7119a2e11882358e84b6a0ca60e7f372ea5a4288b6d51fb7484338e9e5e9c055cb4eb64f71eb6fa4a97ac46df0ef065bfd2fbc7191135d0314496d5d6f6d0d4ea9d15c51499160462b4659f6f67cb5066df22d47c1472e245c4bd146381a3aa6a735dc80d6eb96ee6631cd488ef3e049664085221c92cc74329a41edc4081a040d95204220ac4b61e7d42aa30e2a0e28860eaada6da05f6e0679e86e822c548782637334fabbe432b30e7dc3e7d8b0a66d3f8fb007fb6a188bf7533a02dd17b61429582066fa45ea122d13a8f2f60397ee7b184d750926b9fc28f8c4a6d27e452aa3b6a52f239f446ba9eb5507c1f3ab679afd9efd684f1845eed7a9da8cfdbba0bb96f3a2cac22efcad9e5dbf43cd628cc9c14b5ca529d572770bdd9507b3de01fc7ce78bd3b4d4fb9ca8ef177eb6d58ddd0812329467668e28bf966fb571cf5643c7faea3059afbc912ced37bbf97b964c2784b009f2928709a1825dcaf8ec062162887248ccd996342aec5b84102d5a6808ab3063cc6f35572a62e1d60575b5670401b140f2f797353a151969c240abcb8a20228c53ecca4065eb49f49c471e4955b3b000f70e0a4be99a45fd90938b70e66deacf1b407386deaf54dc40afcda5a6fc1ef220c125caa2b68bf22ebd66b1a2b164d048e9b91f043cd90b1eed4d2ef84b7a24dd553fc67acccf4008e53f6b294901957b12f5931b6ac2b113317a808dd0198c10ac51bce247a1bc793b8d6e96222823580bcf9d5e2f028cf6116b88784fa1477a281d1478ca9f35bcc636c3f7c5a281d85d147496f99f93eb35db15e8cc61b4d7efc7d2b79128fb569443dc1a64dc61fff640d6f6c766e0d12215657bfc6f62c4750b4505f78ac4e10a64a32fe686b7615b69c5c0ae92c0a22700f846c218276444d40cbb17ee03299ae07c477e25768117b896aad7714be3377a34a3d45c14dcb5d9f716d6a977369d902cbfce970841ffc4f5af51501f3884f3e731b1a35867322e79ccf47e886d3b51a4a280833144b7a5474a04d89b0964cd6901b48ca40eb973c2bf394752dc574425f982846bd873182f02d91024493f710e6c14c9b46c4a1c08594c76df400da0f2e01a8857bfb5a898582d00ae02214b6e6ef2c3454378e5c21489225b05db4ca9352e449d2f2eee4e5bdda8cc85296e8ac50286eae97a543630f61db0d222c49d757cc95473c494f063da26680a3b9513ee5830a644aad338cc6feaa84f8582bed672ae3304b0598e44f3afd3aeafce0814fcebc18e38b4355e87072329138114b99cbc3556467c8619dc2c96843a39cf5423fe3c5f823b705ca74b8e12b46a32ad5bb82ab18456b044bd7f221badef67c1bfa5b8b8486a96f32ee7604e8136b2d3b1463569c224fd5081938db3842338759a1e62d8975b51cb035efb896ecd57b988c9f98db4b8094598883b5774d6e1dee0ee66a529f4138a8b523d5f4f2ba775c60f15d6eae4df50db6d3903c251f32f6e456bfd982dc5d33e1a89a497b79b9dd5ab2b5bd0f546a63e5fd02c775124834fc825ca88a773ed052fb968884c1f2d86d71db0831c29fb86fc8f1f562babc4a55819fdc726bb5025497ff15f070fa2081c07cc1041d733fc712687c483b40499f62515e8b23b4cd6136430e1f8114dcf68937942d3cd88069bf34d093fd49edb71ae438b505b0db13f7fa85fc3c3f90a70a73c1eca04b893d396d5ce548a608b56aac3f461f3e1883c6b6145afade6c7d47486aff547ffa1e309464cd51cc8abe60b32dee670bf29f10c5d6c2f7b35403ccd563006149c698f491129f04805ab7acbd67fab2c9f2bbfe74ad21faa31db21bd92974f4ce58600d52c957c734a6dcfc42d1043c1063cac03d47808d022b21bcae03ecc905fab4299a5ea87db60ca89c75f3d0d2d6df536c884a9d4de24943b1010180183ff4cdecfdd7ff9241fd9a3f61ec02c3eec0649c7ef1927276019a35cc76d40bbae92d2ad134498f5c8291206df0f47f7da3b3add1c53e52f71b8b45a48358c0baf7b80207945d21a5a14b029f29c6c70cd2d0a7bdd7701ae00ec42ed4f9ca8876dbd0f5a4a714e3329225f7429d8bef3b3c99d5804b695a2a18d2241c265321802d0ca5994d49fd05fbc192997f3035d7f355d2f03040518916a39b8fff20832233f1f635301b10479b9428b107196bd671ad3c79b062bfbda63a66242763aea0c90d8f195331cf40e55788661425ecec129d767ab7dc62db50a9c6a84f3822163ddd55f8aaa6f9070b4fe71b9257f7fe4279840e06a57414ff1fd6f14506cb6ae73d3e82b04d2cf3a883b16f3c95d1a56046b6b242048c0990072ed398f2284a98ede53d156c3e4e8476ff4f68ec85cde5dca377c65af6f9b4c88d5821179841d8db743c4295d300d020c28541c4b5389179e5c20b3989843763fcc75f9d857f5e82e163c75dfe661eb532b4e5578532764f12ea9714994ca643d5d1029edc9baaf7000df0d511dac74852796846c1140f720ba2c0b81615470467bc1fbf81af2b421fa74f0a7b3097fa2f612a1c85999e5e965986774b936cebb08a1615d8f89af748212b572a633b99807a0de10d7eed93b476685f9203cf8e17dee0cb5b3badecc917645e8fe4fa6bfb31a59689760ed39378155441df9f182902d7939b78b6dc8a6cd193829dd2599a328ae56e931a69485f2420d909b73d9da4d84d927462421efa566b53b5228a0107d2fced97c73bee3e59fa9b712dd61f4a8197531e9224f95e5559bad5b270a3965b34fdf71ee4cb7b007dddc6e84e02a8610ddba6924b7a9ea6912e07d494c8523827b1894ba6bdb50e17f14c40cf92aa43dbd6a21fd9b01eb48157b87166b72d1c59ca7d6eb591d4bdb5a9bf96433a7e90c7bd05156dbb39fe5f73f3cea106fa4e084904765faae98450b1e28076b2fe166cc501fc13e348389cc00953170fb69d8d17ba463bd930a6b2fac7a720f214b0c0800f6303326f030a2d08d7d76b8d8702a916a057510362d2b2dd0484e9762b938f4b76836b77c4f7883706d9d1414ecff5c94e9cb8cf875985b3e26fa47e7ca633fcd83da2d6d97df527ce3ebc575aa9aef2890aa645f1ee506b4524da4930761a56a4536f3090473a97474df0f1ad17b5b879d385ba251ac5f9a5c64b7d929518719896832d579e0052db554ab831fff57550b9c2cbb03ab063933e05b1c0293f43044f9dbb623825ac23e12b1fc4e674f0098f1acfab472b1594b522515a416917106e990b8ce03c3c34091291c4e8a813ae3685f0ef1a98500f94308a1d756dae7cb2a5f6e658950c04e4c85a4be542a479914dc310bf9975cf4f322f5b52379eb11037ed306ebfa3655f630ce5fcc01e9f9c98166db4f5fe5e623db08419def7fa089d080841320d70aefef0bf2a4509736d4381f81925b79554291f956d85ec7962c30373e2240361958d5fedfd12f05eff5a5d06742e4678de72102b8c0549b00b2d21fe392bad65083ecc6012a327240bbb1ea6a11677274c30acb7e1e5af74a3b836b195388c735e1b1f97a0a6962a55d1d9f5c813896a7c0b1d1625af4bad9f9cd41c8c43d778dd373bf0f9e755d83c2a86a444a63c997ad0447c40f54632fd0670905deb60dba56a574d4649c51f7a314de94b19759f6c873753408ae49f71aa7b714329dc36bc202a6e976d140ff3529492b5c87246bd7fdf145c56e8408bde28f1f9d5e9feda39d0c5b952a073dff8627b7ea805f9d57b96121966ae616751879a27bc0cd9e7671d894aeb0148c3f6c6b94d53e09bc35b44753a9e4d775fb5eec89dd14b66cce6f65938355d55c0c5a3ed5d2d6ba02bf1defc8d29f330871c5200e9ff49c4ab5f0ff17159cc96ecfbca8520672cf8c917a4b5f3c632e862609f695b774ef219ff7bda407a08f15b0f75b81247dba1dc1dec5cb247d8dfebc17f17520556ada65aa06d490ad59fb8e6c49a7d9f7736fa4af0afe222686b141fa0158aea41ad1e8706f3fc1692bc32e2157c2a4e200350c06651d176e9f0fa304d0cc72a4931a550b6587f31c7c54ed61ce0e010efa047a58c50b2a57fe8b70e481b387e37da9976ac9850bf24c901ffce85072cf5865dac2a908f8b882047795b8bb78919c2607f8dc3c5a718887f70d08520dec343fb623efcb9f448c1550f07c1ba075b910c8f916b65450faaec150dc6c2d3cfa2b56776082c831e885cdcb5b69235d4497e65fab67bf4ff8839ed58004fdae901f09aa887e147bdfbf5d65c65b1999084ba0f27058139ea1e60c0d37cd68948194b7c0e8be9f585c64bc6c5100ce9b7a840c1b06714eb6f7f4e2cacf54326a33a49d6480b3742d5e3554f47ff171e187c51eb6aa0976ed496cdd87ed71aa3598c8c8691360e181bb2247e3dc863f5cad877b7a5eb97135b53dd7176d7dd3006d41744b58b861f889eb4468750ee73278ef2b21ca1d5950073c1e926da58250b7aa7d6478c4c784f0bed51d158f0ebe6fe26330b56c7d07eb6809de72265587175e8cb17e3ce22a05ba4500e543f3fce8e5685017928857d4793454fc5166c922f2cc327b8faa5825437b6d4addab460aee7116537f3cc418d47155f41b21132578edc403ea7f62d4e58567f007ff4c61ab1cb90d0cfaa09a8277a97e45a8b6e78b162a717221af6fb13d515431aaa4a5f1ae85296165a6ac3363d61740b3ab36e1edc34e8e73a022d724bdcd3a980ffab6e1de5e3e8e1ffa931f263d5af061e1e56a83d503791bfaf1c2711d1ee8280d94c371afa5baff85b174653d6c875dc2a9e609f4484b3cb16bf99bf630eea650ee31b31e9bac271579a3eca32efc7bf5eb044ea4589c080ec20ee8aadb75cb7bceb7cc6890a3647ab4a28236f08a7d7fd1d82f40b82a5c231143f6261e17307c6095423d57bbca23bcbc7c95d3a72d2c35b76f67af91ebff4e8dba568c277e13978078944ba48ed8b8e1758a17236f7c5dc809936a37e564f8c8d9d732019dc49802a5ac3cc039dc8c795acf1523141dce6eb6e9aa19fb4f72852806595ad795a88ecb557e5e7d3ec0b85d692981b1d577d4c1668b822efd5c3fadd2f4e82fa47e701e65100a11d776c292f27656edecd981e89245be302bfa8e5e81f18bdd1cba40a5ec19656b02e502fc18be709cc1699f1afc16ca9353829eadd98066242e4f88382bb879148e9da0dbe338fb7d083b6fbe66f3c816a3b20ff266889bec9a43932dc638867f85e655f1384c923de503f4c1af2afc68a0a1fbc2297da0d7ea3587929a9d2838c8e09a535aa4b76d6a054e267e3d9132bbcc60447606306dd0ced5c386721e0403edb3d8dc2b64d09f9a239d512b04e0d6b3814196502292a118021364eced07821573f4cf3da7d6ba94ac75a1087c6e7a78dcfe2f8b87741cf156de9d449a58e552df95b6cef5716428b37354f98f62023887376ab4824a55d27b8852181028d24bb517f0fcf60695aa465575b7d16adc11954f650496f52d24cdc67593ac11ca4291676f48fd23a342dd4b685da3332ab5f4991be8a6c6e89c9df6ca31467d49139b90cce8c4d4c06ea3b35ce854f143f1c03bb7596f7462b25f9c8262d49ad7dec663ab49a4ae0fb0991d0a35b6dccb1f2e7dd5be6ab4a33f302331fc2b2798cdde9b71596d2319478362bf842471b7ff025bed5e28ee6c509cf363e15bc4a846241b62a212c39e895aa38478592d1516ee7b5b95c1be73ec1f5a1285a9a09879cfb76eada1f960f23f59eafc89555a69a21babf1e5978eec61b5c6a626d0c22865e14d30c6b72ccfb049de909c0e5893bad84ba0b090495ebb2e3f0ab28a5ca4d2ca62b40030a16c9dffa9136916adea9c9d1ceae7038e2ad8d831a2734b87f0d7b2f6f4358785e9723027b308fb39385b8e4763e6e67fc9b5c8ab22928039684407cc98a5e7d37803e6f4c1acfed4bb1c37e5cc1963d3bf4c743c06633c68fc7dec89c9e05e61073b5a5d4e9398ddc8c7e0bddd5f35923c931b3d44372de55da5b9506a1ce657a24645f93b58010077e1688aa9cd85404b7c4c61971ca5ed1277364535c2de422f01e082a74240677c8e6289f66e51350561b86de8f2aa2441913567d00c7aefb18b124e53ebf057edda8d7f188b653e06ca313c8ad9d723b8fb32f1a27bedf5cbfb6e1186c367a54d0fd303d7bf0f4898164f49652ac71e0b38f0052b202d93218592a76a96372ce426b1b60e2959267c59fb08dacb26e24d24627e63b7bcf632f6d3d75a08efa32707fb9a2bced37b22e81c2d9d97434ce3a6a7b0ba434fcfd6017949e25e117db16365681a49d5cc4fd7363f520380e6a37518eed6759fa062b811c833dda6528674c0ab7c2be5159a62e8c2abede6270149c965c03a01456f581803ae4773547491a52c8b295504bf3492ffe5bb220a43e1cb6001fbc75948f49ce875b3e055c1fa2d496914d7f49e98e7a1678b2351aba528ff14a2252a6c753bffb0a044f76e813b84b0538fa1060144887e98976c9eebc5f89bd03a3b4e04b68088230889623d728f9096b1b29f97066974153456f15f5fe6aa040ad4df7ea73fe6d737acb29cd20e0b87b158d053836670a23b31c6fb27fc13df39f906dc7a7289fba17c1e3b5d0de847b97058c6799d409d78a93f441be76eb8d0719639cbe3bedabba07ed830c55704aa1054e6c08b7b26be44bf6345fd8bac2094d383bb1863e625c538050df18cdc375352f06e6665313d6789299d5692393fd1d468ffa8889a866fe5a6f9aab8288b89f68889896e146a7427c5037697a0eda944a3f4cdd0d98c308fa41d397ca52fbc7d653a02f5b2ea7f08e00831546719dd025a379c9fb87fa5f1eada8d64c1c3c8e43ff861a331588160a9cbf19027d095e9d4d98f8aa358f23ddd8b598aa89ae982d8431b853aaeb7ef0d859cc9d62c7e864e4f771efb18144d34e1df75abc740e2f84820a387f1042f21e3985d25cf354388f0b6632d949cb9caac901631b9318d1e92e7f5caa3842bb485ad398d724f584b910b4b985c743128953147c49ed9329acf4cecbc7ce2673590d9263be40a25f640c19d3df2d27d04cf07aa2b37eeb8a6cc08ca470b6385b85ba5be7a19702608ea502acddcd01486ffbfdfcd5de33045c3656954c9ba1be85f4f2060fc9faf57042bebbb7633e167f2eb34e47e293714a51a3341ad46252a6f6cd9ef476d3de991030cee72ddffcbc953b68367e287373fcdd7cbf2ac1b5a22d8847abe6ff29a7577d09f8bb8c0becb6fbb2220726fdf21c3deafb67ff65fe7ce1f4e3867c8a6a818eadc00965592df155e94bac654d4c3acc5cc779abc3dfac21c553dab8f72515a061bfde0dc546817b04189831efcb38affc2f17725eb6c234247ef9672a1e89c83791321e0852e196ae8094afa8fa1f5152949fa0f8bf1f9f465ca3a994d33f7b8c825872c8dd086d3b38f8d1f7874ed0166668a903049ff5ae76fd66343d5d093fbeea8e8036d7688ea6cac5bef200826943caed7f0811df30412c11fbca212782af7d19c8e913e45b6b7b46888e1997ba42e8592dc03d6e03f03078b42aedffd213bfcb1f592e4dc31725c33e68b7bf48057fea93548e7bc4f65debc9936efbbdd883e40e025bf7441c6e357b4669b008202f61ded44344c7d0c8b5e9c9068beb6537a4c2b2c3a7b49ecaed3414fc8d9a9609b38f623b0d14f1533e27264ffacff7aeea69e0339abde8a9b82e4564bcb9d90a9251a35217dce79afea1f3f4a311340915afa33a7d4a5bcf6d2feb0c2437cfe7d4a5f0d938dc078240d38a3d9b7fed5124ccac30d29f4b09ee7c0ce7ca317a3e1cc91623755f112d9fb510669083a3f20341fa0ea2ba4857485f7ebc7069755aa734ca69c14360906d9164d84c5fa62029db6416cf029f0e7862ad9d025cfb6d1f3f11bdda828310ce5ac863dadcb615b3b931a364b0d34d101d9134bababbbb8273b3e7f2b9d411f2702aa5b6208df89b9317e2d9541c42e2ee339f4988a49fd10310c3b3562775608f19145b66cb5c34046054878edecde7831cf2d8ba59f37467a525620f6c728434484dbbb32cca6cca8fafcda45078c2d3f2b3f27bba120fecf4dc575610d4229a0acc7f9498cca52a28105ceb7817f358f7db4582d9aaccddd98f5638ec5b1e45cbc7a86ba177178e9ac0d22d536df35e5d983e29fd24e654a1e196ccb60ea7c46efc720b94b39d0f86a0fe526a68b8cfb085d8c81f5f8dca0aa9efadc06858e3460e8e18cfd92f6dd29037017899a9b7cbe2a88f623383910d92d5c36579180ebdc884f95ca153a81e0e27eebfdb6315bf4bd2e9fe78202ef21cd02d1de1283fa8b8f07b76dd4012f09cf85d141978e4c8b0ca5c1ed57f5097f1e580b71a9ebd63bc907d847a4f233f60ec5aebfb7d059840d6d6ce2ecda2975ae2459ad4765098b69d0040c23db036a54ec11ff7cd04a06d50dfa6fe90dba93b3a37e47d1dc3feaa34047122dc329d769ecd06878ae8c1e912f0b9773e1fd2138ae19c70d3dcae23265eb67005e042d415aac143326cdb63c3e510632e5ad72a23fc46b8806810b02c1ae90c6054cd09b4521e61b7a606ce456d8ecea77d1064835b88ae6eeba25c81c943a21b365d98dcf830b070d590f74d5c20098ad43b984220bba0196bdfb4bc9beeaa1088ba4d307ce6675b8f1f3b96d9b940b82cab9f7f592673bcd4b6b4291ad1269c710d9b8b0abc45ec7ac7a85a2560a8f3494432a8bcec00a73fd92046ec9f35b22df7c065b2843bd1a0c3284c47b7c1d47437a70136e0f2040bfcb761f6f148eca114cc925b37fac8ec002a44d804f0c470fa8498ade2733158ab1b913c037c87cfb4b92292f790281b4609bdadee8b8c8fc23ebc390870bc157e6cf8e17303148b2a60591679d76f096378cba85a15f07bf357a085b825fae9737804adf64e537426242861c1eafc08e3eac8380ea3898d9d0a553f53374270a4be45a7fdc088d3f8923ff4f1779cdd4c2ee98926b855985b13d1fbcbfa42eacbfefcbdefcc464e88f56aefafd74314526e408b3b23a434c741706dbd60926e0db4f99b7d8b4b8b5e2e2e2757c9bef8567be60500096dd4ddd53b0be674f347f5d224f569a8cfeccaf9e80dc5125931b737873682cfc43a62704b91964ed8096c527255283c3fd0a6b8f6bcb963380a91e2b085e8dacb81e6577e54288f8be899b6b1f0c2a21672ff176dd1574d6bdc98ecc1848b122994e7a6edfc8d29d62d160c796fd3e5fe91772476be0d676724f5a27007862e0764ef792c8e8598a79ff4157d57e80756e57e29a5cd64ddc68ebd43255e6f8c3cdf60f548f9f98c719bd7d8cace6fb37df13903322e538eb19a8ce3e30a37e7341e7e8c511a27ef302814aff8ff40aa7f1e8d96f10cb4991815fa9ab3bcf7cfda0c03adb5e878ecd99f3f40d31812b34e8034a5bdb6dddee350734a9f6ca88648f63aea30722ba410a8cac1f7a58ba319b1c3b04887e23a85c2ac01397ccab62f1102c705ee10bb878d86b66198d5550233ff8f2ed7f3e22d48bd800cbb600a97fd1bc4adc162050330f7b1942b6f0b499d8e423d03e8faba442407dd8ee0872cdcbfc15e2733dbdbcfcf033160c6c9f6384915ddbc2284d5aa34f025ec1658b221e9efb94240b3ab170e633ad0eae39ee9ea6cc1898fc0ddc662319c322ef2d0cd714b8131420ea6c8cbb1c94a49cc877d88913a9a084567aec4fdc0138b601a8a7db0d8190964b867da451ad845da51ff99fa41493aa927000cd5132b0ab93bad88a3e68cb42430c0e3d5ec93bd91f43b260f983936f65cd1a9b4fb1a87ec8ba3b1ca85166cb9e1a4ed2a5d15690d94e798e1ed24f433dcae76d72e5537f6563046e38ce709ee8b2f600e89583feb492df6f42aa17bc3cebb99cf97832c72602813a5067296e434506ae063fd5fb0b731de2e367a8d130615c9ae86f884fc60e89ec8c8191740f861cbe56dcdf5c21256106951f651ecf6f1f34b57ff1171b763c1ad4ce936068752926c5a4845f048c35a9ed64adce76fb7a34ecb35d5a12c05987cb24718576a6f9b78268f6090c4e1a85c954b504bef34f75227f67b8b06801201887692945936b93851fae203fd54d1e11f7c24334c5c50e5f79cbc3d0dfe7a8be447031e4d00526ee6903409191faaf0e4cabe006547bb64060fb846a21a120d926fe4744941e8034d318e46087b91129173cd765d36917878797c0d15837fbda0fe2206d8ec71b265ddbe4bce9bbbe9387475ec2f2ef1302f060c48db264394fa80ef270c2c09da2d995d8a00a4a500051ecfd06d6ee59f16cf4c4308562021ba1091b63506e4d2496cb0f8274e49b96b4d120e815bd508efe975fc988638e3717a514a238e8b95ec5d6ccf0abeaaac310015763c49e49f7b1886b81f46e1534fbc28ca796b233e820b4fc0e6724bd8614055de6ec312dcd1760164ba2690ff3b61785755c603f7e8b15ccc2d7a5585124895786f69755437f6aa29c3eac0666c1699376c0b467a1e1ebf175c07b3ba2a2cd3f78910b9bb6a564d84c1e2782c73a5422c980b68d1e6dc016f0ef1156bcb41782453e4ca77b2ad3bc2bcc1596fd3ed4b0d6f16243c14186b4ca764df572edf2c3115afb12f730666ca0071549d07a2ca3ad2c20a1fbcccfdd1a6641edb2d294d819b292a5e40404a11af20b65ef638eefe150b9bf5bcc73317a6d60e410417724113a629a94f231d15aff1caf940f023b08456a3b4e3f780d08d93bdc58144dd3a3afc3df3f96adaa68d6a4a0005c1ccdf1163fceed06346eb3e622bf2d62388561442d825d597af6ae31726c156a8121ac9dd171d390e74603481852042909bf596f7187b76cf6666da36c899ba466965e802722751f6997754bc2f372a032a09985ad2428bbaaf6d81ee99c9bef3019c6582974926721629d4321dd289fa89383fca693a5d4bdc60555225f11566392ee259c6546bef9ac1e26b8241ad9846efcda391e160b99160b5157407f2e396e97bd163c9baf30a45c887cd6a4e1735a675374dcfd364c1ad5eb078d511a9bf493f7d54089d36915d74a6bbeda99c742e9f034b5e5340b4f5e791b6c987368b5ca6c019733258df6f9f3159d2a298a5c1f76e51f152558c1e5da90deaa4de403f20ee8f1ca479ad61394fc810817d97f9cf52eff06c2e037e3cf147f783ca5a20399350d48e50ed349958706f4bebe6b9db4175efa1016997b88b4b7f7628c6a42c62377d4ebe88c84f9401474afd9b490b760096ecd5d7fe9038a3eaebe08913395cad829669cfe05120df11339d3ffa978aed2e7ef211f05e2d26e420b6ca07f01322c7052a441b5aa24f1223c9a8def535b541e61b3f160ad3494afcd2f092de90a929eb9bab47a078009c9a53da0a2bd6527e73d000cc5431020f15bdd85ad5f5d2129ced3eb02d40804faa7fe885720d8dda80369d5edb5b5d45d553aaab4b34857914e13829bf64654c9261966fd63dbb691494363e6017c3f98d1b15e5edeece10d8040b4c6778c09a43c6e7e1fa7aaf3628aceed347072e5ff219fbbdb6eb9a59432a514520879087c087eea9ce0a6a445c1f6adb646981096deed8f665b8584a6f16f42d5c27611b2c216bab86d04f903a6f17fa24a61a908314125b1e812854419e1524b1eeca0422f5819fe42dc702e41d29420694f6cc892c6b54ad2685325699226699246a9a449daf4991e52b22e30d8d662adb6baaaab6d1549b5aeeacae3f16c9e0d06f33cdf30b7f1ab43678b1677f7f73c1b0cb66d2fe29a2f01a102583a37ae7a3e9dd753708dff9848645c86f4b819bddcb8eaf974de83de4396fd96224c11c66d2d13c6a50dd63a302947f877115edf3dabd94aa705defbafc0fb929c9070c9f361618844d28dccdec85a4bc39ab061c3fca3542ad7612b58d36030180834ea713344448406079124e9d30e188c460d56b163e4c8dd1d6bbfdad5adae358abcdbad180a75b1eb6a5723778cddeeeddddeddd55ae337e21a04704d02c09273e7849db9e1c80bda3a49b86646847b708c3f68731eaef3628c317a3778191ff24e172758c162dc7edfaaac51322b4c74efdf5418879947f7856cc5ed77cf732d2e75ad2e4d66e0df4bbe3086cbc46d3c149740385c86351249b09d4885091eb3f6cecfc8097b03267e2d73900ad3f803a15e71e71a7f990c060624ea71e3a00f0789d0502409d79c741c1cc956359e2063c7c8919bdb4837ec155dd1155d5b6f5bdc6273fb8e91232a2837d880ea27351d39778cd0aeebbaaeebba91c7e3f178b66ddb647c61258dab854bdbfb47572475ef1f5f481cece872c51797e8f58f57b024e152bf0cf3d35cb3b9a060d9c4262cae7b32f8ddbe245ce31f4534ae112e11e13ddce0bad7180cd40ea9ee1fe216a554a107a771b1ca42e5613c798d0ab1f5459683f20b232b028169fca7a822ba8ca476767676768cec189131992756d7bf8b1c63c766ee1be6888a27af79cd6bb4298d3436b7cf9b799363e40608f8602f1836e98d83a20c6d05d7f8b37f77715d8beb322e39b3d74d298d1ea5f1f361c2865e9bdfb2ce433d2c8049fe8ab02b768aeb2fb6c277380be622ca261e06cc654e664544b93e856bfc5532559b1ec60e5f1897d81f423737b55a4be9cd4d942b1959a462c7c8919b6541aaa591d28d6e3146598c41e246dbb62348dc464712f7bfa1530da54f5bfd12e0b569c252080a2023043861fb23c035fe096892049ac63f2626f46cdbb66dfd59c28a98b01bd3606ef464700ae4806b74b0b0bdd1205ce347e2916d6b7074c453b64ac739d8bde5e06f44b02d16f58a25c44a2592a12896bd8f8a0de5f57fc5183932f39c71048140111465deea6696f10517da8936ce628db19014f6891a0fae472aaec71d5c7fa70293dce5059760de7594f418a62937de755037a61b0f836ab2f12124ec0daedb8087507c018b715d72b1509c146b4770c913ad78ace2510947177089bebf6bd13b3c0b2ecd8f43c47c1881b81e6770ddb770ddade05db8ac068daf26f385f5da982fb432be6abfb0ba565416492d93c9643299cc23eaaed55c2a95ab93459290982c268bc9e88b40a2be5d8ba423227655aaa642f5e3944512334f8f3fd0c1ee641de8eab8fe11159b38a97a17772e1e995cef40d1e7274e0ff42010687aa0771b50bc71e32b358dff87f6c37ae383e223c2f5f7a468015ce3ae831376def0e6d33961411fde88e6ed3e9f8e54804471072deb9aace6aa2e14eabaeafdb82e8b3c445a27eae1b2b26871e102e3bafb8c2d01d11ea66c4597c4e80ed7fdc3d053d09c5630cdcca24e2eba2f9c604c19d7b84c76c5f0316ebb7a4b1458b82d8bb55a3b57aa4872ad56b550c85a97aa5659fc0212c51d8822155ce36f43f4825445528c4552e401d3f8fbcb5452ace213abf88395cb7cc7bd10f90b2e85eb1f12312b20f4285c7f1b9ec5f597ae488a3d341598c61f89d00d6c105f1012030b4078e0b0b0f2146b2e03c92c16f1e43b91343defef5dfc0ac699a0f7772bb8e4bdbf37a171b870a973a7fde876f7bc9bb255e34857f3983299ecce952c9298a5cb5ee9f23dd0099826922ec034fdcc85aac4f60c9a50b5e84700d3e8d802f37e25ca0f3d97305f38616044de4724eb47048e6630c10e07db656e13c618ae749ec700f7f1c3217ec4c1f3ce3870384cc1c1f3f1dbc46e33677ab673eff992f873df4cbf2989e7e337d3df8d0ea6d932a1feacc5c19f7b8f28b6e787c4f73cfdbcfe84e8bc203ee7118db866bec80b2b67cd01ba27830eb74e2bec0cf1bbc7803ff73fba796edbf462bf0621edcdccd03df743bae7be2453b64f12bffbb66f48f749fcbbfeda0bae9913fc4449b0f2c38f1f2b9d5e417e118b11c6cccc393723b0935fd8f62f5ac618ed17b20893524ae78c94ce58a3284e4ae383925239279d944e49279d91718a413f4797e3e278afdeff289fd2b05e19075d7a3f64cbfa23ca3869d41fffe3231cf4c3f81f3f5aa07f04618eebf30bdf47a5df0d78e76de639a2dfccfce49df7521d599df6ec4bb7377d79530e02731888d1859629877e620b2b35d394fe20b46ea279bcac38d8d14fc77d3892405ef711b5c79670a471fc8340f3f8b07c68cbba4262e66a24a46be63595758544fdbad63ce23b124dea4d6e5bddaa9452d64e344d94f2bb691e1df7e99eb0db13f673fd76338a10c491f02f1d9d73e33e54e4ad22b8a6ce561e0e085f5a1f99f191c6e9562f41eb86c25a1de9a6c56677773a2708052466abd5aa6e72dbea5665e5a4a7fb745252295b5cd33070358e5361239ae8ee09dbdd2f36ec58fdd04f9d0bf11c36b0f2b7207caba856d8a6545ee148ec0bf300c24a2965f7f1401f2ae26e75a249bd45d3cc20d038fd650b246efcb8ea2f34004dac5fd07b272f3fb8c2085b708107ea09d1017da148131f86289c564ed8b0b31076166ef4d30d0f3c73c2e9e674bae9d837ce830eeab43ac9205c43e794f5930506b0894dde924dfc1fef47e5368e9bdcdc56ab6debb62ae20b12b1e9745af9670389dce48992f4922378809972682780f083cbe4bd114d0a1203a05bb17d4d206f2b92dc89477151e1aaa8135127073f2cb6d5dddd5d02a6f130da861162300e8ee6e18fa3c7781fdedf112c4edb5fc138f1f4a526340ec7a5fa56d5ee9faead8a8d53a479f8cf4e32ff22dea73fedf1ccd37d8ee3681c1dccc37b1cf7f3f7e339734d7b4baea91f19e3c74353b85d889c71ce3a6b8c31566baddbb6515a2bf56a6dea0109bdc0355d802fd4c5ce90f7fe5c158d22c9fb66601a7fcf62b409a92159d56ab55a0d0912d0ac999bc66ddbe846bbd25ab7ba511a29cb91ec1163947d7a60437f5db7c1e23630b7992f63acb53d5c953b2cf921e435aeb919f5b8d9116385abc562514ae98e118ee3385624b1228d1cc755aed46bdc7024bf27d890778cd8e047dc66bee7312e51fdb07212259627386d8a5415ab2b602f07a5d36f918dcb5e047c87209114a35061d5eae08dcc11b13833839b629e394cc0e502b00da54c30e81fe2b83ce399bf654cb04d2bc1b4e536cd9af14516ad3355eb9c73ce39e79cb3d2a9044bb94b348dcf280cfafb84c2ce26521e45b3454534b138a8258c1dfdd01a2362138d11b949cbf5a781f58471e6a6985f718ca84d51c4b7e3e68d11b1a9ebbacf526b4c5f4f65c399e2b2d5ba6d33156933254f0e42e192d499a82e369c29192a6eb7613bd89952c2b2f763a6666a862849dc828242cd9443ecc1cb04c31022e86d94810fa8dbac3a6d0dd1ad6198a908fa60449115599755ad0dd56835b06e54b061b35256dcc609931a9592af48aaf1345054505166111316036b2ad11525b27c60c39992f9195fe39b9941e667fc4c7f43647ec6cc901a1ffa1a1f7adaece74b13c988362eac77e04c7f8dee97097d8d2f898d0f7d1200fc8cd7c144433403fa175e07538c6806d4d9108db62b581a2ff322206c979a9981c6c73c0664bec6338e1a49313ff318a8f1386afcccd7781c684c1c1f80c7c0cc0be0c3c1c6cf7c003e1ca60cb1f1338f03001e47674394d3e30a36e66bfcccf63a98a82bd208d1a1b0176d459a0304615de69dc6e733f38ee3dd0380884d315f030038be991a2aba7d3313a8bfbd0e37462aa22219dfa21bfccaf8220d9a074c970bf3531416b9309f13ad28aa60bef8648698bff14362fe068d2fe6852f89ccc739d113cd10b1292462538c884d34ba4fc83fb1a794dbd0bcc45a9c39e82e51110cae710114d7b7309b8856e825b8cf0d67ab8b619022184cd3c91b9b0a60cc142db2680e7adcf9c2ced4e748e31aff2e78c76bf1e435afc51d445664c52cd189e8839899a2551c74eaa22d185e60e387d479e0128dc6cac2c1808511f31d644b58a99adb8491b5a2d1bca4669309e54b644d9f59668a6be60ff38a0c08312ab028b10897933ba33839588b446898a9ae61a68a843cf3d08ce7be980f41b7f14d554ccb66b4ac4616685441e6eb2d66cc142d66be68b3fbccd46471892fbde16c4d29b11559363eb40c7470816052a4451a6f9cc8126388248e60d03fb23c92a612ce510c26aebfcf17d7b87baa65911669916524922218318c9d1d76967891365373ced93595a231900ed663f0325fccddd2255b9265ebd6db16b7d8deea768264b15eac178b158233078d98e233b789dff216d7fa28e30b1bca4e4996cb6da4152e6ddf754ad45056556ca122595226a7b82eafc89914b11536942c09939fef1e1472ff96b0de9a7ddff711c99688e5921549202859208b6e3af849bb9ab41acb8a8291d4bd7f1a003bb0d3e2d545f4642092011aa41467c9c0dac2b66ab74593ec275b9dcf7c06f35d0085b2e059afc2071cc00de34b1ee086f1d53188e8729b3006115bad2a31462b3706c125d6d7856507a713969382d6ba6ddbb67d88648049f1ca4bf67ac5dc30be5876854932ca8bf5928105856be2a64567b9fe339e39a145b9e2379e20595c23a3482b5255a0a638edc82bb8c6d5b1497f506cc8b4193edf3d0628066ca481c27e8e965198c65f52b92e81705d5eb9ee4956a758ed4a75aa53f3c5f9278339e7fc7c3e1f4ae9a4f3f3f97c4694d239e7ece1a4fe7c54bbd13c1ff77d2fc4396984b1c562b0d7bffe35e7dce6165f91f4953a6ccb84f29a5aaecf2ad79fce6df3bef9482a116167fdaad5da5048b6c00b03171b53602b08cbde6784f55fd5d5b6dabef0b7554c4d1516b799b05904977670295eff199bb348ea3e04044ba5ce28dcdc895ed8ed89839b152cf7d2003eb0fe7c398a2e5c6edb4c96db843175533eb5d84272d30da7943bc60d638b4b7de327aa41c77d463f380f88df6d9b1f3d2022bf51e55dc04d311505dbf160d914bf7faedc26fecbd5625d8f22d912c9c086b235a16cb096dbc46f7be2a02792810db727dbebfa6f5ad8fe30a656a9a852a55253958ae08d2c95c72a5315695cc776cb411f4f1c74c6e2e9e964aa3a6f015c5322029ddee7864bf1e30f31753363aa4a3855b2255b32bb4d617bf27d7860a76a968a3207a74a0a9646beb6205d30933298491acca4103369c42c0bd7bfb1c0a54d62c134fe52b8fef10bab85eb63cc18bcfcfb0726c9163321f55442515a45b43ad58598daa61853750256019b80d4af2879c0530906e36a3261c4759eaf364210aea726cc55515485a52fd9ba79d5dc6e5dffbe3245ac8a9815b1d754bda66aaaa6aad61d23071dec566db1cd0710a5b3810c0b103b302b56acc41839b2a7eb4fcf6284c42e0a892410308dff16d73fecb8e6b8c8c58e8989d93eb5562bf7484ecdea2aad9344d55250fe95db6a48786b8ee3aac771713aa83f346a95c2073a34a4c43123140242103233ac9db36eb14306084a2b5be48832bc1ff17bda281f3737a36ddb1a4581202f24923acfbbbf17b93d90cc2259d56a35e7768c7adcf8e01a121b4ab89b993bb2562a5b69531a69ec6ddbb656b54a35a9bb8d0eb791e2a43afb32bdcc39e7a451b66d71dba20cafb25d6bed6d1b218049120c491bdd91478475976b676727ba7622084a54241941a15ed2a6132e3d719b3058d2e4f6a11f782e993b4c9611ff18bf21dc9784fbeee3fe685c03055b7feb264dd6228df770e9c541ff3837340f5f010b1a87abbf936af73e2f22918424d2344e4ef390bdbc20c9f97c5efdf9ee4f0dc9e713424237d16914922f36d08a741922631ef5c8018670442dbad3f5e8d445b1d026940965512b5445a15c7f19455068c1429fd0551435a1729b761b896a169394db44978c0f36152342511445538d436920002736a42852acd5da900f360036a0a9bafa01846f7f32e5a05314d7f8e7bdbfd1c38b75d74db90dcb1bb24c004278661e4fcd43f3ec7864d7ff46b760352600950d23ab968a39d8b558cc16c164c5c513a594527631bbdd2dd7bbbb259df3935d8ff1c186a35b639ea73dd03be84b9283a9c240a02f097d2501fde73b8f6846f4cdf4c3b4e787783c0ff32561df9e7b1d4c3a7414f5c2151b6759708d47591436ac308a1a82dbc022699afc6bcc6d7a78b15dbb2145f96f35b7691a4579fd627ab0ed9a32a47bef4bd2d5ee874d53c21ed7e455589483ce84a6fa0b47280d8091c635f091c68d60c31fc51b273676fdab169817fb1702312708174ba5891bd22154081136e458ade2fa6701a3281445511445515477b2f1454a29fd7a924b112ee1b8fe466c9032923a402bc235fe9f13a4eccd49acc52d77cdbc702b553ce65dfcc51b07c1d2206ce855dc4626817a13ccfc2458c42e65e35227650ae34423e020ecd410d7047d4dd0b7e33c34f85e60e9875e60528ed320e0728ebf935a44a790d0a42291c697e8aecfbd39952291e44b348d37e1f3854e8450fd4287c29bb88d045fa2b71697a870a9fa1242446887a2bd096fb9b7ea87a2703b91edf5b75a9ed06f7b68ba66eb7113631e16e8c8c7a787a5dc9467e592dba8597fbe7ce504c4650f24b3fe39ce0c84d58a15e3220506e5b5a56585ae56d5bd7635eec9c27237fcee6bad5f3f97bc15144d226244af1a87da20d48496218108a126ec12fe7586374d7bd5ae48530433c7107694ebcf79b7f2e0fa3f5769d9f951fa021bb26c031cd000976ef00126f5e949f3f0f76853f801130c869a4707e1c67558f33084ebb18fad0ed6533fa127da4f6606b80083880cb65aad56abd5a8c7ca52e166a64c9bfb65737222a94a493b0f1555aef9175a96d69430c963c34858d029cf97e3a371b88f86e6e1fffcf2726898afd7e49253abf461060cfad3d0384780602b705919610818d7662c2b66f3dde3e68185a5b55a6ddbba3098f993827262f22122ab44b8f35c91b922658e48294084694d7a1b69dc00d37dc05988d0b972743dcb105ea24966334f3794b957ec8d1bb24cd6cfe7f3f9eae0e73381e8f92244081b322dbc61de22fd34f847e446caf20d43a0474185d828fecc32c4ebe9d787610a1b72145f50b9a22996fbeebbb9f9978076846bfc6d11d6238a5ef480f483b040c041e7bbcd7c60e10d13029e28fc206ed3d94c520cb20797e4fb1549001def36954b5bc771de8fcd0697526069304e7f29a856864b9e77cf15eb5d7bdd779fcfc7fbe1f916c944e172f6084bbb1f1a8d46a31df1bc1d0e8e1cece1e08d833e722010c4c16e193e88a1dc85a5091396955635143a1a7532274f9cf8cb10979c8e4236c0208dfafb236bbdf4a768042d9271ce398af3e5acdf10a7e98cb07ec31010d6e6c086f6ba7c8fef38fe7cc51084d840dfbdb0262463e380c1216c689c3e1de1022f5a57282143316d368aa25028140ab56d3b463d3a06338399ebe82736d4d0a76ec234fe12a3f333ccbbfba5773d3cb0a31b3f9e15e1d9ac8894348cb98a2d66d7218bb1d825bea2966d4606ef3ed7f87ff7c726f3b76ddbb61a5aafadc6c5a5261ac7f3fd963eccc370c586b1359f348ee7065c62e2243fbd22c953339aacc99d4892f1fe13758a246fd249999c359ba44bb6e42aca28cc87f2142a854aa15cb3fae578626722107ffe8caf03150eb5d08a40709a4e49711b260e63058b5a82e212f3c7631173f6d5da50282e81b9f10718d10cb771116f5785f58f556e186bddb6214245d87645527479a660ebfdcfe1a4c8c4458c1397300c5c8a33f8dcf0bdcb7db515bae185b0d8b88469fc7fa84e228a6bfc0a1bc6566c6d1f7a1f4ed38f058b6bf12d22601c04308f7e5983112e4d0528a0fbc25a3d5f6cc556addba8c7cd5cd950d2ac6256ad184abf9eb4165655a9ba9b9b1bbad55a6b7d52f7616dff4251b061e84a5291a8c4f5ef2118076c33df85e052ff4da4691ccf97a479f88d77439e7d5f6e92d4f79bfa85355f6e68641e709266c25f51dc2074872269014ce37fa35255954aa552a938ae0a19e260ff27369bcd763ce54fbc7054173f7913dae46a4339399184a4f6e068462c51a06c9f56713991e43f1a816008d6b39e71e9b3a104dbb7ebba6e3ebd61ab26f390e17ddfcfcb077d731e902888839e811d52a20474615b3509543525e9314cec31f48f4056a6e9ff421b2af7db047a04bd6d40e87b6c60d8ddb8efeeba0f924e61b1b5630efabb604abf0ecc2b895d389950e0f6e57432a14226985702533b9d4e261d1d2502a05513cc2b71c02c6482791d253cc6eb64820168827918dc98604c30cfbd6c900f0b9d05d3cc9eb0ef1a62d6a63b3d836189ddbe9909f408e6f7ac023341d0c2ed1cffe00e6f5a8f59382a41dfee5974d9f006c4041bf6cc51b3d96c369b51ea33cf65b67065d65167a08f500eeaddb6b1043b9271123b5713e7873bc21cd7a9cff67ecc2f6caddb3665a432da3ccd79d2d15698344b67d55552934fa78e0c82b147a3ffda5f47c4dddddd3d09e80bd8ca94c388c90f5ca629fd21c36230fcc0facf990830974b9fb95cea3a7dca9175ea0607a9128be408f5e00006232ceda0b0f23671d053ad1c2acb7c3a9d4ea73ef58952a7755268ec34b7711dfec5dfbdb8bbec642097fc9238ee03eb573b8f16d6efec9e5e3708d391449fa6c37d7d5a2455ee0b400dac90d98d1e5e2ccfaea36ed846c0208495c16934da9c3b68758c8e99274f99acc7b03559173f317a778a42987843d75b75606a24b5153bd7df690d6cd8ad4869b2586beb38a9487f09781e611fa0f72f82821b9c04fa680d0025712793ebfcc53b2b1e366458ea156b1efe138b834da4b0adfa9ed8119020ec1d9c808df81371555c9062080c3ad83c8a500029322292a06a8566383ed40aa5a4a452527630d26ad156abd5ad6e756bdb463d5a33a4b85caf1d2f586656645ec0b65497ab7dfb500f48e7e1b863c3762921c68a3cd142609c2456669f54deccfbf629926efa497ca2a2a208dd4a4214ed84b80385b5723da9f2ba5cd5e572b95c9c886fbb869cbc2e4e2754cb0a1396ceaa4aeac9e90482b20623c95a2e798de35dfffac562c1e5367d1b50b047e889f66f4fe9f6fdfddbf71ba91ff24e7df0648db06d65db28a5b6e3a55e05180a77fb3ed5ea606f2fbd1f5b1525c1bd0d6ea4af9123f2044b7d4ed70dc0a300bc8502c0c6a9410938416aa05d6c100c02c1a07f0d8d83a479f8105d584a382276da69d970c4c869e774629d4ea7d3e964b1405f1cc7c5da49b264151df9454a296badb5e6c076dfc1a049978508dafdcc5924e6863cabaf5a3b092781b5849429490e323b28d3e773e8b8b032791f6b50dc660726758d4b325c9a21272c7f58721d06256c18dbd5318fc13f0dfaa6312fd61cac5dc023c39b6133d948e30f33051b46d749a2b8a71c05b2dd30db33dff3f15c1679a28f8863acd185edbeb0b7442ef10a26512298c67fca941ef4e086edb272c376f911b1567bc2054ec80df4d6e73e569cc6fbebedaf5d4caccb89d30d252ad6ac58ff6e2bc27d72885061b91bf2dca813d7db65a579b812d207066740ad4820e42a0a39c42bd624ab5dd48adfd4502b4822a96b55d45c35b9721bae166bb1166b1e0fc735421c1c4284be6c00c1ccb4b1d056df4412dfb0870a0b739d524aa9bb870a6b61c842686665b15a739cac5c00b3b826a6c541eeebd4ed20ae7f6c988f9c9b90671fe010b007901841e33414be02140ac54385a5fc04834180328486122b024bc6daa4d06655615d094d11aa227473c38ab1582cd6b6c154890921726242c310a6e9f08cbd906ebd05724c08970470fd89c0000a283d19a6582a73847dfba9967e433ad50d79f6b2b6880d2152b013f0dcfe402e794c888cc562b198903977787c60e6a992826a321b89b551eff40cc1728c49705f9f37fa7f798aafe2adc899354a7b38cde69b1662778cb17687c57a37ac4dba35c6186387c5c65e71e9bbee8574b0729b9614a61ff6eae670e5d50e3329a3bf6f6d6795811d503db0d36bf0067430dbbd6ff5e7ffe5571539ab55575fb93c7592a97f90684929e58e9119dcc43dc3803e1eee330203f27ca4b0ec604ebfbe70f46166f678a011e89b3ba31d5be5975365fde837bf1d233b3827288b52564bd6a54aac61cda55d946bb53614fad128ca6ab5f61f0447a366f58b4b7c7d764faf1fc6a5fe1fa6b84634a10b76b3a351a86d121c3721063d58c294433c220c93e7bf54ca32d7d8c993274f8ff60cfdbef4abe7a39f1107dddfeebcad4bd8203b18b1b65a6b592c101073ceba4dea24c65837fff13f291d758a76c157b0204290e80ca100eff0175917589066120d1a39187683cfc042b854e3bae806e192288bdb42827cda415110075d6efd520bcc11fc4990ab7ad2c38b95715e95759356791031ec7c820dc1eba22dd81094f2fb85041171b121087acb240c0683c182ccb9c3888e8fd8100e7f99c383cc9e93ba8e3adbe9597be9d8a45cf274308d3febe8f1ea973c5dff26820d2e729a5ffdc9d51722ac97cb59a8e8b2e58637314358ce4205961bde64a982c9cd424595cb598ef0e2e2f6eb543f1e1ffad55bc4729dbda4384bac4a9f9acb7c65893de186bdf369653942ec86ed456e348c56a415aef7f0aa3199ae80df5aad0d85fe417074634508eb1e1020ec20783ae108c5d3cb4ece628425d8bc765eafd7ebf5dab6978582e338e68e7c24e9288119638c2e9c4c32af2383fb9890679f1f8c2304300ed83cdc13b14946c4261939ce711cc7fd370e17f27e8608f41f519bac884d9c2889cfc788941c9111c910292972fa3cd853dc225cffb000d73f2236f5dd3e326e9a216a1367454a723899bcef603ec7258ce805bb9e08072433433eefbdf7f97038d271a2d6e260f7f2e19182c5e16a975feed362a5b07cbd9f7201192118a3c56f00e8fd6788580121cef5070bc0a53700f3601b4a039530e8df34d063b8eeee340ee42ddce71f49344ce38f802b15641a0eee73d41d5686877624e420d708f1b8c5c2e3f1b0876745aac7e3f1783ea311087ebe1a699cd890675abc97306157b9eede00506fb9a410278512383f9847949b273a52ba05e5ca78fb31f67432b90c5ba4eb72201084020e1ab1e1c80d48224d7f441ee794d45ab972ed20b88542455253a9b5d6eac9c0846b9c874a7bd23a6e93059372228d8eeb6134185c0069d9c0862db3f12f12699630e908e7c3c3033bcaf3f5ab50a47893277de7dcaa7c00036193152690538324f4175360d05fcdc3fb0a4c03c5f5530db8d0b296a3aab85a2d6ba18e5454ff509d340a2593c96432d9a8879021a998d5687453c4061f3db8cb4b0b6d853a236c7f884bdea871280fd73fe4031b8eee0cb9949147233a1a8d46a3d1b66db5be55881c63c766668e0fc3e50771649a077fbfa00a1760a61c1820c41096609acf1f120117f1174435780cccd26336123bc03cfcdd3fac2132820d6faed74abf9b1b29c1ea25c618afb07d638c3146902cd65a6bad52f610620e7d90213970dcf80c001036e4fd33925e003f2f2b43d7fd8642a15088527a84945246dbfaadeb6eb08a31c65879d63ff817e19201a4c93ecc69f3d8a8a24b72e474bad1830ad606f0869f3f810e97fb7e90c83ad8fd9d534f06f91fbbddf2f35d07deeed37d1495a0c7f8bce78a9d119f8b9df48000e10bfaf682f0057d33de8f803ee8bdaf0718a0a75f1f06e663be1a693ceed99bc17ecc10fb319ff7cd44a0043dc609e483bee71aef0b6d002fa7c3fd70a28f8c7ad9ebb82f6c6c62fd7360439ef12039e06bf57ca1e8f6733f2bc27156c435d25899108ee71a219e837630a71466446415a6d66a63ce39a70e9348245598da9da304db452f3a78716fcf8b2ad61491b8754422e97dbc17aee99085ebefa8482272d2c18103a777a8748db805356534020000000033150000200c0a860322e17848260a728d0f14800c70884082583e1a48b32088611ca4903106210300060404400433ac14053a62ebe1d49c3cda53fe7eae98e3e643a94226bf60417b85a91e3e638bffe5089ea7e763537b32c3cd1b038c3ed906023efb9e63f336e064a8a5567cffe1dbc0c094a9331d30f3b69c1fa8766c68dcdec5dbf79c271ee0c74b7ffa91677432bea0e7760a7cc1827b9935fc8bf91b5072e98c86924426c89c405bcd9ec76dbe2abf8b798d697cbdc896c50bd10f35b60d3eeee2e3a9e6833d8c3fdc9099ab586de87e245e3dd53f5a77d96d350a46ee4a20ec638faca8d75b58722f4c9d5bf121a79728d4dbff51812d25abf793941e0c2a3e16ace0527081eb1399986398e835311a9d843c292e10d193638c719ef7cfd7f6db872fb15176b6af55a7c41259774b743e7789008dcd33fdb5aeee4c0821d8133f78bf84d086cce763fd2975d25249e98900256f18c87ec3ec65ba3796c66396f3d40cb3e4c9235fbd9c386e20e511a6494adf8484fec0ac303cc9fd5ce9de955f3b8c3d890d84fc9f49851918390692050b930aa0579e9ad95d4f67abac99a2156e8e93dccbeff8726d19dbe1f738d5e6ed7c81f89e00e560d99582d3511fd4eae2c29a878ccd80c50717ab9af4827868365075a7a67f4f981646cae036e7d550443e5b091d11a8dbb68935740a15ed5daab9b4b9c564bedf47b8c41e2b26eb9f4fab1ebcac8d42f858421a2789cb6abeafa8603cd6dc3ae1df90ee6c4ac2ee834dd2688f12d65da7c2fb57c0b5720d571f17e5b89b64333557a8403c519ee0153a81296d23cb115ec9cc8faeced45f44fabdbb023c37503c1bda0f244dd058a0871e98bbd4e82b4b63b49ad2739856ea36ca901473eb0b125b68361cadce9e8fb4c36654b25830f9d53498c9060d377291e29da82124d2f2f2b081a8f4863e004b0616448ec2caf20752c8ec48e23aab98bd5aa73d6e853ece07c8aa7c44562ff00118bb279768075bf267ac182846526963eace6824eb4f159bc13b95b78e24f09182615f1f6c8da9cedecf86c906d856644d1778143198c830b1d57beb955188d86a275864d4f5fa80a4c72e30164540087cc42ff9727c32262ea5fc500adfbdc04c1a29e92a9f226a78adad762c357c9c06f4635c001d00ce22e486d8041ce8b8063ddf6937531de8bfaac2e6631107123727a9dd72003ae25618b18b7d7895e442553a98a6bd0b626aaf43ebaf5713efdde821caccb1fc37d15039cdd5081133f990cdbd4572ba8199fae0fd85cb60836e247223e06cd98b1a2fa39f743322774f5ba60978abce004c9f467bb2bcd1b1d1f16bc0c0b1bfe4380594a60e8c292610bca3f87e4b333474b25b02f8c15541743895ff0d42318117dd915595f6cdc4236582b62383e04de142221d853474510a33e68c682aba033e40b58ebc76bbc6290c30773b02cf76fcd1178b3a2ee7f8e8f0fc7390ab6e209eaf8cda14e00a8d0df50fb9901c367b8d55d2671cb402de4f72c2e7e2287ffdb07044884a22902a1b17269804e76d75db1de3187ae9943411682352fa2fa673fb0b818702808f2048681c5785b1afda62f312e6b7b34085bd8e3327cd5a3516ea969af67a2efb5fa660a86b841d56073fecdc848b0ab4820cf1ba6a0518546fddc3aa69f5022edec05965ae0c3dc47e8a6e85fc73ac1b4e09da48ed3d53a56bc3688a032d9ee5c8a52c55e44998a3c187ff1d5957efcbe0dd644cfb9adfe76930432b7015d19ac16f64b416e9a0b4d35431c27fa157c4d6546b94469717208a9ef5e444089ea933e9cc3c016aa0d2d87cbb90bd340d5d291e694d283f019bfc4f428959d736f5b64ec3e26bd24ca3c5f47394d134b17a824e181534f7c4c7016c5975e862d77f7c17203f98155dc4bc3dde2706189ca8a0f30cdb6ff0b7ac52c187aacf776aca195613a013c29d387817a57895e7df921f24384c56e9bc980f61534848c2bf683912224128644ca8599eb24a5afe099b80a72846470d30e9667628615161a4e182ca3ecc012a5f463a792f424412cb371d5289c610963613d2c89bf147ab590b596ad168d09f959ef77dcd554a927e8557c038723f857f9a6fdf08cc80a557b738a86981da9b15998db868ef528d12ae19edf7e79192f43b0030a00dd35ae6422ac970c657fc6f05d16c62d285b56ae153ba5ebf61882126f6416070e6d6caafc044f1410cafcbec35560083280eb41ae14101b312a1f906d0803adeca8d56e3b55c8b7d59082f6f0967ca9c3013ee94d68236909f3592ba01c801f3066d9e8f53db3ee9917d641c7afabdcef143a35918ff1e0b3ee042966632845372cb10a3d3d7165f0781b38fc300e1a6855ff14a54d9e0b85da30c8e917554f58acb08ce62b3b4d0f0cc431fe514351b0dcfa6ee4a38048fa8e95ccc4ac6a6bf7187a708329cbbfb45a20400f766dc5fbe3f8bd6c01c11363d1d5403eb63a2e564ca500c7c5ab9e57b63b842a4ca541f88c27623994bd1223e82a53e4ffd467bf353255ec48c98d1304d65a0bc0bdafa55e8ddf9fa060cf497c2745543ad5855612761105814e8c8dfe28965282f1121502ac17f9e23fd242b5509870abb0cfc3cea02d28700aae84c53c47ee4bf9f48611b8c30af99f36881d16a91b2626e9fa5b2fe34126128a51b518ff14868931744b9cefdf7d89295be661474a494f2305e25a17568dc11611278160b9ea49ac7aa0c4f9d1ae59aebd032ee838a6fe11299727b97cb6f0f3891bbd69cb48535d2f68b8e28d7a7e27b8cf0b8d8e20ffa142478c06d8a0bc22ac0d7ba8b3afc491980c809b0eceec3fd899fc402108979470025ebe8a8a222f98194fb3e9316e16ef9effd147df3da0eba96289ae5ca9e362b9fedc74695958a965df4dad6b72fff8d05d4a4be04e5dcb923077c745526bae38d9d6774e4e7e63afd4922fb947b0572807c84f889a32f90fb771a682a9bdf5155a31e0986d469b0e69181d19624d0ae384985681c49ffcb2e141ea8440f30b0d206d9815d7ce97d04067f1001a7f9aa4cea198e2bc91f6310bbd35cb4658d06a1e560182dce36c20e3ce539d4aae733fbc4a2edb6a1cbf13e18d3c52332047fd2f87bb177025aaecd21a3d78b3f859ad953338f7d710c9944a348921805137c51cee1ebf3b7abd2bd2eff48bc6c2f9f3bdd0b32de2ab613313936e325cbe3749ffa7a6377a01532bf8303a282701f102eb21647f7cd7fe6703cf7f5a0f1fbb0a0ecce432b02d948eb1bb99f850eca8db8a04a2a42df4ae6d8640c26f51a6926fbbd67a5c6f408c0d2229665949e909f22b189f71e1b69207e6e162b7c085dc9b1f84c419878845a611d6c7e1500a61d132064056bb5329615241cd71aa62ee67df9700cf1ef5725fad2508f59f41c94cb7ab6362247b7d9b9914c94602e602c81e1e69b2746dfbcfa05eecd43af1277f83745bf2a2bcc8105fbea6e82656bc44a25427fafd91311c34049fbd38599b17536390b654c662572d6180f070a5e1a5eefbaee7b186f2a51d0f94eb86423f7049c09867a6ba0e8e831c963a0895b087d0a72382505fd857e22f100695c6b2db6d500b563e0d93810de15bc602be8ef3e3e953f6f5071a3cca42145469abf001a1d644e6470733ab6f9153268eb85fcedc950150ede8e01fb480db574c85a9a2f49e5df326c5bedc8ad6e28ef29d8fcf5f0188892809f680888a9dc93c51f3f66d98713b45e19ce33b05c4f11d7bb1fb015bdaf0629ffc8633b1a0fa3aa3800fa003a7f72e4a60588ec8743207b6f21cf9f96b0fe20cb33d3e5361989f0cfa05ee8ac497760cb21e4e253876ea6c690fc812946908b79e8a354dd2665f3415cfa23420fee8b62d1743447aab966c99df93050992cda4ba6125f713a111191a8220b177f575b71426f3c25aea18ea52b6e24be13f90de47ccec53fc53d328697ffa8601d6f804022c3cb68e97f047cc83abf819d3218d36ec4d9951ade708a04561c7eba07edc995ed404c7c1b7f174246a2509c5aaf325d3ab9e467377de354d7d1802a79804da159f2fbe2af88adc376df0046f15a7c6bd109475608da1dabd3043aaa2d9fd190f62e131fabe00eb1487c39431aff841da124546423ce668fe09ee5500fd5abaacf527d06e5dcc128e77c0f530ccaed2e9c9d4b0461c8cf5af3bbefff458dc6aa2eefefc4f69e522bff8463d0343815021966c9f5aee60e025d943f37baeca3e0421500081742a80c14d9ee95d07f88d88e62e88640803219da46a860f1d8aa905b12356aa842f2d8e4bd536e625d3488720018d8663186c8cad165e9f3e44f6b6ca5da5329850b9332056d0ecc5c1cc7eb691c14d2aa9344cae648988be775ed2a5a3767493f9ceebfb7e54268d5c133addbd8c83e93504f758d452df4d7387168061150bf8d1c2e562078c4ceb31eb453672d4e18c45a5c7d50b3d76f27351715f300aa0507b2293d88489abbce4edea2a30b1295927f983f4e9fce7b547a49b1f2dfa38a0bb207e1a3a12d89eac800d15deb523fcc44cedc16afbc04e160e26662b2da8f05d238d6b81fb8abbc5c40e5c7ab175242d54e20fa0f839d54b32ec3ba87ef63e407746998e6536fa169dfd074af8a30a42996c6bc6f155698dfcc3ae14b76c556f0c2e790ac3ed65101d3f746a62e45d12556afc0841c038a7f9226ac88bff4c9e13eaa2ced3719a7a6cdf72771d3d1420cf79af1945e6299988d9630305f06c1643bc4a42d090e97a460602988dd09d55a0f3338ddb4f6898290dc1bb69701dd35b1457e1a0170b56380b06e82a7e86aa2ad2dae523308089e49c7b499da12a5826b44556984b4ce04b44412848a638881b2275c58d00ccce7200eeb5771b9895f0ed4d841fda00b28ca8cfc8f9a3249ecdfc74398fcabc720b8d458b3557ed9fc641f213abf5a7856f49394d2cb8b1a3196f55fba01a9691fe8d5c96701cb0d89f20245c76fc4ca49b6467f2a233142aad5ea75b0b4599ee4a86bf48f546db9f59396f73a836c176ea6544b4a640d6c5cb5135c29dc7ca942ef01f1e9c93e1520c961a1333f1625e04057ffdd71386530417f1a5d7a7b6c91ca2c870f23eb8cce3d44f66492c44a8f353f836afba51fc3d64c372c2e8b473a721254bcf0bfceff3867966954f999a814c4a5d0b0b154b6a3aa5f83770e14de14c8e9c390d8410ff361d5f0838dfe306959254f62e48adc6112ae26527bb0062c12ba5efc99a6fa8fd341bca9730ca51a730e8086ddc4bfda344f91bda9685e9867f16964af46d2da38c4fa40aa814aa99d13749bf4ee6d155d113be71763d80333ccbe9ad85090b228552db7b5bc3851cca82e80705b740df45251a2b3321d7c5ddb0fc8e064c802ad6907067bfb6d3ea8bef3726c87bdbef9f5cca7f30d644a1f5919df5ca9f58d02dc53007b2c001b05008efd46bff4948e11197283f84526e333ea5949f592a79c9a487ee2deaf5aa02d976a25db0710717faf8b196f6df9939ea8f409defac02ec7e97fad3500286567a1fb4178d785b85619f23ef685ce551434af46516459e00fb1c5a1b88c1ed57300fec042a57f70f91aed1093ecc1f4af0d1e34f494adc503a0a40739769cc95808f2f1e88520ae5b3f5940995ba243a12576a917d1beee263657207e7ad94cd2b06b3068c011c60fb1ff9dfd2c07386d0aa3c7f461d382f9ebb705aa3db04f03b651ff004c518e63f7c65baeb517b0845d83523f57feb52cd31a0dc803ebcc521b34e3c58081033b77650efa62e9187d2291b314604b21df488e64f4990c8990a6f36a9367bc838d6719d2ac2d1a2d7d667b56511b37271a94e6ca3caac8e3a1d013a16037807ebcdfe18bfb9e0f6521cb87e4fe087283a3875e9e60b550a0ddaf9eb2b672bc3d3a708b915eb573e4eb36cd2b7774b21f8a3504794586673342f0e8b13d13e46855f2aae9493fb020bdb826bdef0cb42a5aba683fbe60c48146a1a77da9187a73b833550c8bb91060d970ac3d2ec5757b6353eac66c81f4a8e488fe6eb69e88086ca3633b5b3655a07c8dd2ce7cbbb26589b4b8f21d43d723f80f0c7cd8535217eae639934e30caa982bfab4a6c3b38fdf4e163110414168ae9a527a6605160885dc7199f8cc3d9afdf7a369f26742ea7df8486badc6bd765a2fccd717800d46c36962271b06b00dbcfe576984c58b5e7deebc5b0d24608a87799298632ef373118d225bed47cd647e298643587c0a430b01ca837c52e0788df4030c6b52b278bf8b5847f8498a9496aac1b54815cfb50c33e5f0581ddda77c7d95c38ef4d9ff0268aecdd02d7b164bdd7267b66e91f0cb5533ba3cd65840ae0303838d390668185f0f8b6235ce490134eaa7e76ee062c82999e666f30ad251cde26fa4aa5746ea2acbbc55ea1dd785d357099c6b0ee1686d9d4942aa96081d29bab3545acbbd2430500971ed86b1f0b2482530ed2ebf14f7bd4ad3ff94eca7831fb70062ce6731ed80454ba3bdf7475c4b919f13c491ccdf5669416d170e0c5793df76518e18c3772e91b5ef1c6095fd9d4bfe0d973b3666042df85b6e02f1973eceead3aa3502498508f7c082d764a1926122900a2c20f4366592563d1b55f972488987214d63853a6036339fc387248f9da2ef7214e7991c23a16b04431468d795e3c7b2da99257f678d231d8b89cc96a26a68c4b8d82a451fd8ad2c79546402bfa365c58f8bc31137fafdd03be7cef9c594a4b7f1ab17fbe233a665c1f071e5a3073c1cfea76b9b1252409bfb16ace86d006880d08f0a035f26e689f27a77e7430d41b77785b56d31c307d2c0b4b1a33d8ad0dcb042a2330947513140aae52d98ca629b717ece28ebc04fcd85c549ec66f63ed8dd952f1aeffc971f5469330250336e774f057afb15b224c07716bc2b2b33d1c490a67ac82f84147c54181cccd0fa76f5d3cac128c8dd781158ffb581ad87c8e0abda6771283d6995cc2e27a78bc28f9dcb6ab478a95f01047a55321a3ba8b0eda1db2d9e8eeef611a0e0501a83cd3b17567dd1888a1f0aa7b72c48fcdde05c13e5c909eed65b6fdaf0ffe305445d988476f4d518566aa03dde53ea7c45cd1d63cc700457b20e7999b1b04eec640c4e03c0250477b4c24b34513fbd7a58eae9ca9daa3edc905d52069886e01351a9d344404b52337532253dc27b3685bd71cc26f8626e9b1b1f8f0d51fcc83cabc8592099d3241cb7af063e03d71f688938becf2efc9160494a2ac78d5074e928382d6412719339a6e7b07234699d5147c1b8a985495bed6f49926844b2300a0c9f7aab8445de6796253f54205e446f2cd0113a8c3ebb7d3e57361f03cd71a21c2319efa7da6c0f3c417ae916fbacef331ca8196f8d104e594b55be7f9a9a11cea92feb65579f2faeb5d2d2895044ca2979969e3b65d790a0d0765aeeaf254e1370465677b6a2366602d1328664f23693de008ff39441030f1150733fadfeb6c38cff28519b02a145a4c6364d05a756b1e78670fbddedc947e13b6ae175fefd15a10564252275495f6b34c996bcfbb743644cbf89a69b252966f9f4047f5f21011a90f85bab824dd2974a5125f8bc6ad6b4a80090105e6f8342649fcd4da0d86ecd4984e72783f6d1e657e3da8b9cb43194c59fc429709e4e5023e8bb5c50e864d27a11a6d3742b5acadc4f23ae21456b9020ee694b7de5663a7a86670f34d5217f72564eae30bc40f510c2c60b081230adc5c2aacafd1e66f9568b5703f6446c504756ee69733fad92e9aa689823d0a23b97d46b99612182c95bafc9819ff1067cb41922db2dbd3ad5bfe33b48767a688aa33f393abf4933263989a7a564345d7c83d0548487b0e09649f112201c3ed470109dec0296820e1505b76575d44d4befff5dfd01c1fc49b010593470761108bde3a441c7c4fdaafb190b564170de9ab9df051e7bb0adcd9908e391dbad9f0ebf0477675ecdf311799e69b02ee8318bbd2a025c3c0edaac4a3592b79f62a4837314c11201a84f31e9e6d958e57866040a5f2bb06982cce859b06162e7a040a5b33f2be5623200756880a328c9a19ae924fb7c896f5496a60340abc3125eec47590fb92dd03ca44299e8716bea1d047d06acc421483b6e41fc46a4a745e158aca19797068758b833d51a5179d53d42138f6381735cbbb0c2b54426754a62afaa6fa98d0cb4625e0b03ca0a3d371cd2e6dd1ad6da6d2bdb297f5f13f597d5b7077ad97108d0e98ef8ad3321cb4370e8bf374dc67e3e00030171ee1601d2f95086414f8c70209dc1716a50219e35992df51d221d1fdc9a18a45e8b29ac81e5ca93d30d428216c45440b8cd926add5519b0054bb86a61b307c22323015401c2eb728da840ef047d4c2abf2996a60944aae607e0e052139c6d12df55f4e28505a16c0e7ac134af49afc298e4f7493270bfa502282bf2bd621c1aa9383e0a92d5858523b198cc46a14067c1e00d8de0b32ed1c531761786b9e130d373eb9fccc6eeb2eda5d8f75785b906bc1c05906e0097234487c6f9c1bce308eafa1615256edc6b6b87a2e70d81c86576634bba14ef1b2daf37a283a5f4cb18ae78e59b20362d53afe4710bcf560be1b0bd378dc7d95accdcd00d0c880634eeca564b4796895b914c7c506238ae3c395a68137a2195e000451995588909204a746379ac80f54b7755f9c430f7dac534b39ad28c28b99e8015638307e72450b8cb6d56c68b791582e86757a7cb90d014c783178b14b8bfe53fb1abf2a9111591961bd0131261c82275d1628a06024cd36e44e0e4fd5204894b6e17086a8c8ba36d0aeab3737556bc35642082d351adfa2270bc1faf0ba09d661ab6cf443caca1997093d787a97413cae68482221254ca6ad099580274db1646fc195b4b105cfed9fba2d3ccabff992b2e05a6aebb5d6ebc7ae40ddde56c86763007485ae72adbc1375be6925b889e3e02259bf24b1aa12b76f9ad65306490fd405938953c69b71f50d702e82e4c451a537200e3cc349f342daf3a4c3c7ccb0f15e616383124ba5de8ac5d60764c040ff56c415220aea6222300c018f7ca2ea3dc57d508c677b779fdfb326d77d64b7cc573d08f2d8d48e79cecd62f080f04b96580534a807432fe4e4f0433472e7030652a9a146b463f83bc36b46c41ffb48b1325c11a3538a845639d98c970e1445658a013a8d9a72ba36aedb034b621b89d757e460e32d771eb95782d6fc4a726c9accb93774b04d23430bc9e39b9c2181878fe1ceb632adbbf2df4fb39fc55a73fe78cf0a50a40791b2f94d84e756b7c29e6f7f8f0f4c44a87775423b21980066231bd3cb306d03a86ebfc70a38aeecec325b7f9e8c4ac1494ee261f2a283ad8a2970450d2cd5254dbefa371d98ba1b27bfa0284bfb1e4d069735b724225ad6d93912466c1a74f07cd9843d4c411fc05540c4777283635a8ba7322b10910fba436c84809e0c1cb773f53860351cace24da7f26f1aa05ae4c0a1a1cfca141c8d28c05a16ac2cb83404860d2702cccb54f37aa462a600e70546cd3e426f7ced4f257c8a47f406b1a0696ba3af516dd6e02e3d55df110ee1ad2539d3d21f7fdda85ead65d32d69791e0ab6b3be2b2a3f158a38b2d8a25ca8ceae350e29a573a3e1c28310a92bfd4cccaa5ca4602788c2936196e7b694c31001029e7e9131abc4e57be60c8d60d90dcb73f084ff7735d9b6b40e357f528f934cc700c8d873c4018b91b15293e280528bc1abbc95f361e5aa23a6df9f4c3ff3a5c6be857892e384b0889b5c844f5f0c63a698c04bff8571655ba39c0d6d98bb355d39b4eb75e43715665d93f7d840aac0539d367298834087915c53105f9282082bf20629b93072355d70ab1772d0069349560a1901db72e359a81848280cbeaaa41a6255212fc3c9d2c035f185fb6c3f0a95daac8bbc6b7baeb449199ca6e671f1116ff046fc4d2fe77d654cba12b157f2f217f4c9d24de8e021b95fc4bfea89bda26b27e2dff3956947cd72fe88c34e647c24f80a64f157eb3537a44f4560089e81ce39f4814c7c921a1fa0c5e85666555bdb78b272bde309a023bb70ec66ca3005144d6de55edea7ec7394d1b2eed9087eff331eb5bc5f92efde73c5b1449dfb5f8d822094a12624a6de71d2efba4699d16baf0571eeab785a885669f7a64c1b5cd34d43a2e27d12e5a726b993525c633796837224003c7b3602469c8e509304f21905f743b88340ed228bb1ec4ad54bbeb07e8216d08e31b295c69dc52ef205e8ebf038bed90be5f70c60bcda7782207f3db2650d2154d7d774ee622bc31ae36232a1563d1067b4eb0e46aac2fb174a39c0b066de4ad7ff88b6625f7d7db6823b3c919769223f5971942dd7d3c9ccfa912f38f6096ada99838387799883324dbd265f55e9f8b5d34c3cdc699464517ac47a02a9939a82aa997f3a37696f4fbd9555e4189f787f9f71d3d290864aac4a1cb046a33875f5b32e9096f6969c4948b49ef670d0c8add2dd394568bd98985bc772598d18c3eed9327befa440387134671d89c27a04348f8210988b37304870ae817268ea4b03bdab17d757423f12a239eab66631fbc9b8ab917fb0d2dc0b89ea17114f80e01006014f1608233a4fb1f11c9d1b76e4ec072518d98848fb2373b034060fe6b635dd7af23d1188d3873b11a5eefbc847ab0c8308b41eee2d3bcc5fb3cfffef4a800eeb7a48b65d6991fb630aa53788d49e3abe8faa94d78b2c4f9bbb2769d9501e8c5303be66cb20046b5d82acbe1496501670b2e05439b70e57ac25fb3f018d4d37cb45bf7c42f62aa5e1e221c6b9b28407e6e79f9cf6d1b358d8461b9ffa992b0d40fbb18c5de6aab2aa76e3808fac00e780342c661ad75270afe59adf06d299d15461ef5e081cd4e32aff98ba8f7e200124bb361f1b0116e66e6595819e6eafba9af907db765da91d61dda9a00156948626da81e037589f371aab04fdbe959b4f1fe0d267b311dc59689b8ced5e175a1906f194b21712770f3b31c4ef87a826ae9515df000e88dac119c99004266fc18303621595fb33b04b0b8f6306103924ff5d26540b087aa20df6d04adbb9c265cfb6d23e1de3c43204f48533b6d6a5e7df1827e8f8152c75f7bad60c0c4d3deb6b3de5392798ba377cf6824017190849b04e2e14d774ad42480797d80817db91e36a5f26841809fc418d6695c867d0464db2d4390f4260b4f1bbdde97802cae777bb192f8b093b3ebba2a865458d262b1a1ee4d826bed829bfb52369e4a13307990bffc22269b41963c938b646935bf28b90ab1cb32fb8f5ea03229c8ec4610733b4b09eb5997aecad42b68e119bff37536d9c6fc0e240892d488c8f4e26757f640d94d07fd7a4b49c7042f7aef009a8495af1b9aabaa32b69bfb611c4bb6f53958ee3812cf95c091b0f55220cd3c6d8539e3682de051b36c348243bb6f5636ccb51d3bb4ffdf525e36ca342d7c45c5e112ac40b02af57da520e2ff87c06fd575aa8bd9a2128b9902fe131d9c39a9c7fbf496b50aed58cea85b516ecd60996ff961d073b42bb01ea4b14b6b8608ed3901a7f29302bd825fb74f5054bd1660ecc654e76eaffa4cd88fa28caf6256ec32ceb2c60bc50c1544c0fad34d0a51effc2ed614630e777d126164013d729701fffa0cebd3f6ae55644dc6a0798e2a068fae33840a03f6468b5b22b60db75c6faf8c97e0f069fcbf8fdb60c9cc5879357f0188b68376da4d6a0cdeca36e729a63e0ce5f59de37e3017deb575791c57e9620fb2de96a7d8f21be0a7301939ec61819b8ae52abc17fac40ad022fb06304f71a40d20d7784408a4cfb10636de17817ff6fd862d7ac0bb7c2b640b5751078c4885f4fc28b803ce31b20267443e1251f6f248e0607299a9d912e73a18dda523911c36f840c7fd7064a245478505d30994d090c2291627f44552ce0bbc8a37008de2a018a38a4c55ec085301b5dd89d51ef0981523d72f9697d8158d3d030a48ca9aae08ac397545e443675925f75cf51cda139d3cf07e73397fb8dc520884214c292b43d343258314c471f4068682a463877f12c8581681ae56116198752e6735176004d5934c99e2f84f9072ee8d9d153a340fe80906c95d55a8c9cecc6d502255823e95d971ded6d2d6a1cea2f0496c37e609195b0d0e500bc15228be89f59c4d5599a4c5bc19e816d4f6067aff643c5edafa203832bb50cb18980704e560ad70f57546496b34f2d535c779a2a51596e8c7855c05c0e7cd9a8b916782abc2430131ffc773837f1e26bb650ebb846377daa39324f298956c08ff5cf0fbdf2a3307ce0213b375696e2be34ded5835a6a2d73825f79c92e74add5ab94393066d3821526a7c720e83f80a44abf231a3222f0dc7a4538d2f9141f7d5ca2be517827943108279dbb22385046c5ee71ddf7ea41e16b077016028f0a18f000f821cd83ed20afb1638be0296efb9865c816e6292d4416e165d8f4974c87aa9a1f9a49620494694ffb742a5ebe486c5777243355ccc4d942ee5aa512d80452427b384eb5f8dbfb2a53814d19ac1bb310b8e47e243e615d68d9bb18f33b6c59e6ea4cc0bc61a2a24672f23d9b1430d8953f7be0dba7805714cd2984c13f8a7f55932ecfb1ba008738515170f305854a408f2f25b2780a915575309959024221d8d7d3501a3538b604d2472a73282228eb7ab5f1f23ace15cd85aa28581173b847650731cad92b488f04a9cf1bddb329051e1c411aaca34467f5d1c6105c5cfc059d78f33ea865c8f3787b531c0603bb1c6374ef72adc8106690f86de4806481b7a199ffff55106eadf8e6a2349d3025e9c4d6bacad5b6c569f519f2e85771d601c0014c28c570c17659b9ea605010700789703e086fa669d91ca726bab52998ec221c9bc9bdb144304adff22d3738dd7328b4c19f76c16be3f76833fab29afaa5b0c0b15135d7c3a80421a150c48fa4f65792d9ecd9e14e7cbf07530f0122f58a1159e1bebabdc375861850d77449bbeb5ecdcad20f2b6b6619bb9e57520d187f8eee371a0f01c784d1491746686ce3415520922ff10b49cc4aeabb185a9f41c449129b99c51658acd5ee7418027c7feb40ba420ebbfa2e759895257576d9adae4119ca5949d7ca113a18a1e7aaa4a0f5574b0128fda51ac7f91453424e4550ec0b7f3643fc4f7ac1900803085384deb4e016f21bccc1007cebd66d52ecd217adfcc785d857f162877d41016f197b4e2f916689bc7d4b205625c4d348165d917dbb981816180bc59afeca4184c842973693b6568f36e477a801a8b4e6d6c81710167cffd5929afb761c2101acbf754f7a08583f33dde4978af1af3510046f0db6756684ebe3e1401d81c00e20f3185a863e216efba675453b202d28c62e3491d6eb63c7d37aa10035c85a7517795a330b154c7cb2f6083c136e9fbb25c36e6fb192d8fd5d55c7d99f40dcc6518a419cbe4e4bc143aa301705733a263402ace984fb039ceae69907c022f7219788edf9c91d30281ea6026149c39e2c208d6337e76289c62d7febb1dd5101338d03c489b6adc2a94708a556c6b3558e49ac548eb29cb428c0b584cdbb554f3473f478d86a071e67cb2857ac6331c1a99c89537623d4ade22a5b8bb3f58c066cdd5a78245b54d1b46c5508e9aa5ca480d6c0197c30ef4ec078d86c7c72b9b43f53201f6bcd62b5ab8d7b67b01078e005fb58ddf52c091c11fc63a04db4d4f5ba97598ba81cf668ca917e6bf1b021779ac9acc81b2ff42fb06b2cefd491adb7d616bac7d314212a8966e5c79f95bedf02304968fbb040c76d423533b96402fe7407535ae831ae5cc893342eaa58a7052658c43ccdf677c5b9a0a729ce66716d1e0e7138fd5713c02d3d3aaeaaf2430543c12610caceb5e667c3eefb43e9c4dde55220ecaf3df2d3e55fc660fdfd6d8f4a399394c1fad386e3a30945c406ddb95cce3faa541aa011b4fceddf4f4fa5eb8491ad0598cb7f35dab27f8f5d0179ee5c3ff96d970c92dbd67826be8b92a1012207fd80ccf0df4f7663abe11e21717fb20a130a4b7cc3f2a4ad0909836f3255c844d43e9eec2e91a5683962f89c0b8c5c7818e376b0dad205bdcce83f18f207c2e7fc4ea3f106ce02ae803ceefd8611c8b708b335f8c2fd637200cb678123037135e0f237e6f9f18b04e30947bc0f0ca60895407b3e65dbb7720ab08f8fa46332dfd0e26a4dece89b67229f4a44ce1228e404b179442133e9a6cf90af982dc87c8495ed2f55e69c3641533bb5c644f8dcb161f8373a87f8d90984853151252daf616c94e0576a0df0d7d8c8ac2c6df90eb70af87ba0ce497d35a1b0b9941beaa5f6f17d3866a3bf3eba92347c56e7195483a6b66dc4d504da7b010674f4197340b44bb4cdd871c20502fd1caea9b820fcd47c828afa01021027e538b49239b9a990ef86730c82a4a9372e956c04a92b2ad355c1b423d487c3cbc112a990e72f755b721057880a4690a8d1f92099757ba174d7d887f1d9db36756d051ededd04c9b5b5020f15eeda6e02d5bea38696fc277177cca7dafadfb0184ed207ad0f840e0d27bfa626e48ade790a78f6f0cd5a127e283a93ada77af832706bc1a66d87f73f7f70b26859093f05ca7baa3432cafd5a42981ace66c4bcec1404856bef94b15c0af397bada8e30fed61f41681050cf98c9bafc5f6b94d8e9adc8551a31608eb43ff9754dc6d389eb6c7eec194c6234735aaeb5ed3740c5712e0a2c4d550bbbd3820d8353c12a80089856d01d1f559bb8c3d85d141e571c7351aa84001f802004f06e06e0ee4f9418253194a80cae1f68f3ea80186a35893eac6c32be4dfe0731b4322014d8b666a58081ba67c209afea223cf0750746672e268094cb4b1464c4b47a6b3c00476b645250105717a8ed7b42809e35ba86b264e7fac5d704493bde4bcbea7f7852649929b2eb3f1633f1f9fbf8d7a208dbc9b3ab3dfb9b2449c00afcd03ba03660811f9b6bda0d92003dcef87b32e1856e5d1cabe9568beb8ca647d0d32f9e2b040f0c30ae8ba71c02914658d6b47e31d620e7e85d4c6e32acaa125dce72acaf3c3af1770bf1ec9a2c88cf20ab6be60c9a44b0a092432f54e4d31abd701d5515cad6f30f9a62f20a5b983f39fbc3aa7997b9e60fae514f7ca3a18312f396ea699b7362b25e2132c34c1657adbeed960afbb0aac991742f204aaccd7f80432ad058ac4062b68d5d16e8ff8953dc32adc059dc572baa1b7495a0cab58ea3eb14e0103ad282a56b91ed5d43d6e0f18f175c98e02eda980b864ce32368c60381a9912a4494a376d874de059734e878e1fe264c61451161c4d303c98339c530d2a5329245ee2f081964883cfe76601fecbd0e9cb22033e74cadb3dc5857a37c64b5e01c1d6f809f810563b38d000c7557613475297eafb8e2587192fb9cb048869ac64a48737d4971363c80a054806df784cc5ef30e083e9ac6eb8c1701b08495a832340270a4b604a9f2deedeadbf50a16f12aa03dfb2d8009028f3e9baf68732fc24a95b65feb3fd0c25e7b52b021a50c85c02830f7dd0729bfcb440fa7a471cd5ed864487bd068a0a766b5e15305934d2ab6caa449ebee6c51869a064dcdd418306763257289ca32e0a7be9a93e866f388cbd85fadb7d68f55e346b6f7fd5837b3a71ac6e245b39c1f1bf48b0937dcc0045d32a2c8f9ce0f4a29deccffb65d35af6994a24b743137efda26c028afc0482ca9034ef0005a8ba5ec7c450f486b84c65deab89d00acbcaffd3191026b01017b56bad2969c35f79fab7d7e6e555015ea9872557a551cf7636fa579cbaa67e1867991c93db45ec52ed559819a3701d6daf9c104dff2647451dcbdd51ce1f837a86dce8a7e6708abce62b85fd8d8130c8834c7446c571139b3df6a375b97a55556f7199c74787303703de9ceafc1880179a61a075f80761836b98ae5502c1dc9d860a244328d1a33229c3fd7b61fea92b8bac334cd36b971071f38aa87670dd178417e4ef29bab34e4a22685f57e1cb12c899605bef84494cb058b1458fd683b86517dfc6e142c603e48c6cdfe3813a65b8c8fec9fe86a0a80a20deeca116178e5ae71cbf4226aadb7098aa9a87265437d62583528de7ffb1d26c887e855de6befacfa6ad6ba55b26dd1dd27c238589144a2080d8a1dfb3979aa1c8e0e1691ad3911ba66b1ff705856e0d451f8720d2b05964fc6a11509ca76b3060107cadcb45fa3785c418348321caf7470dd5e52f756d89ef4642e241e06cc8626af2d0db5da0d76ba074c59a0f8496f45a1d55b61dc9abe52e250a34f6ec79cf353998e712c62e9e7782c24b68676813113269263bd5a36801f88c39dde6f7dfef6ea4c3972c4958fb0fe63b268dff39f7b3df2481ea4acf1bb5db76fba5c4981b7eab77db2c23de2b11e2ead7db601cd1b6f5e86b5e6c37418763555bc8458eff7e802b18335c72ce12fff68ee581e3e230af6a56bc0c9dc99921ebcbd1674bee1b902237f9ab70edb6b655e82cd7cba88b8e2849e2f15dd206721ad142984f65ef13f3f143e5d95c25e37c4672f3efd4393c0f26b5280dc330e74a704fd6421505f65a923a4b21c40668102f7b15dcd0f82938fad13c4747c591a3ee84725634186877219dbdebbbcb83b98118a4640fe93305b571e7e912112e63e1aab96867e438c612ff5b32b828b09dddc147db76cffe1dc8b6542d388948222c1956118a203456e37ba6178300fbf711de38c758531b004a227f1fdab53a826adf3e6329dbc6cc72f3ae57e566c502fce9aaaf7d8bd42dcbbcded253e6478429bf846db7c0185e590d391a1da5eadfcadfec21aabbbe9c8e97706c6eced6f8b1960f41e6086baa9c2f4385195b124df5825dab2e57afce2ce59628ef6df2f5c644de08071db5a1ffb3d061c3ba083c4c874bd9d040c87dce6d7039550afd7ba98da24f7fd96a07f44040639452d1e8407272a137c28233a650706cd554d37c5f44466dde0777c801ca7af1b3e29d38e2b32321cdf8f26d269a8c1dac3f5e95f0393d2fd0c1911bfcce84da0112d556df7b06748c14c66b1b2910840991a75184b669b0a83bbd65a4267d8cd65400e4adc7ec4c706a478ed4d5a7923e8bf68941a6f397b914aa2137daaf543c73f8415329a5277aa90f6a632d1bb41ba4a9da1bf741b9e640dea902c906f510af80843fb59f17dc8dee8f27c4b255c0338ae75918311eab7100518f536fc3f1927bb56e3b186a9526748c61f7cd768fa1ad1e4376c6dd8ae91391a8a7671ec8b446b47d8d92a27ae5aca8d20368870a731aa411a2ae493fd133ddfb2a2ddcee5a8b6ac3665a6fee0c64124f07339b24d4ae9ddcf0f46ec28c636ac7fa209fa4c8cfac5c4c0171df05e4d8c69b8516816b0df2b05862471f65a7612da344c479270a78cbbb54d6f496a2333024b818b0d21910658e6aad69ab2c816a8d9af76b2576b1447f613039a5757d131b2bfc37351642e3ae6a2b8b262d4160225f937190bc7bd8b774edd8eb2d12108597a1e5cb05213fdb0cf0e1458f16c74c71105ad80a14ed1680dad776e6213c2f7a65cfdca20cb7517802c7d30d25ced7df83a0dbce5212f427989db4edad7622bd731d9d74b62a318858e0586547395d772f5f7d0ab376bd6839b9c15be9c111181d0d5c3cd460a0d1273bbb818d07bb0ed2a9dba9cb59b0e839bc040bed2809aca1b069a83dfe6da1b1b800bce62747dd66a3d270991335d0a80f1fc555a6c52b458369db029071183296ed98990f888ae7240bf8ba8609111b01f64dd4c7f9df805b81a58abb8ef49be421820093b54efa715f42dafa6e71a205c7252caf80b72d2ae51c0c017d40218932150304b2bd548e4bb009aa5a968d182f9d4702f4141208695d230ae6f4c8f7cc28698d3b0672acf0df2c36e57500429b460cc89eec2846e14ccbb2c2d569121dbd8fac0f8f291c02e152e0f51889b02e88b8469ef16e37354f3f63fd038696aeb8ae5574334845ee23ab2ec48cd066aabfee7ba85ce307242abf794d2128608510bc60a4774da2c9074ca44623460ed6da1c958aa10a88deba50b1df4d783618d2a30186845edb4d44a24cf3aee719f0db34cba41ad30430db935c2f30d276f11e35b47b6315e82534d07f8b1696cfba72581e5fa3cba2e7befa8c8350d68315c7f758d87da0ca0bae484b910babc2f0153255da145dee6546d8431fe487998facc1e8a18b4b2017c0f8a993b08a4f853d645cfdd7f12294f6e65057717656971d2bdaf8846350e6a7b4db5565bb91a6f13eb8421f1bcdaba61f5da99fef77b9b8b6ab5dfdb0a1fcbd2624146e6c54efe99002a7d1ccef3a6a049aa79b3ac7a082c9a9f6702df0e8f1fd1c3e0907d13ca2d5c9943be4b5465b0a5922f69f1514bea4cee8368afdb09264d20a92b4b0d54a917b8554efaf87062f2e7c1441b8a6a44eea9fb61fa5d28b2dd1fd20e88281f1ff52d248786693efa499ebd7464b3738aced1f499222af7caebdc4e21c5893461621afffc7edb52f2f928747875a10593dc114836349b219122553d8acb0eccbb105349265538ff196a8cfe7293dfa81ba58ca7b7979ee3300d90c5393ac4a82c6276c57f930346deb7721b993b1bae09e47cd6272867e5b236920ac3efb9b9d6b41e29ec033a586071e5e53cb11e1a8293e1b49673624225597c49a63755c2f53f95e7c5d0857afb31ad163362c4f8535e2b2df837d64c0b6adaf017851baa167877f63733b6715993e3105d6b1a8f6202388fd5d6ce021ed6bd30f7c2145977e786dbbe968e032ee5929e65bb5f1f17ecbba8a587c29d69fe430780d30434db3f205e13022675a75dbb582c0ec8bbf00b37e157934cd16864af98080ce4789b24c40dde2d45692e51726f42e5f5c406deaf27b33c2e268dc7ae03f8d466f5a6043b814fe0a23cc85b7f6e69b6750e3b9352b34e78471f628ddee680be61a2cb8b371d324451181e54b00468eb1edd149feb6bd8b65621b6908b9d90dd1d76da5d212bb6afd6094a2398b2c54f41650082aa65511cbc89f8dd6b8ba81a187e288d75f120fc6581583d6502bb0b22bfa99cd1ee45bf31a3b9039587081cf28a91496152901d9fc965c954cc71dba5c4dafee67f7c0b2b62a1d7616999b27bcea58bcbbd55d7956ba41793854e4d2c59b51d6a9114142edcbe9a6e95cd0a1733b4c2ef80dfbe56c5e92d516edc68646f89ef271cd3667e0c3278c8f968e8020bbe7f51b65fe82cba0ba3104c48716d03d3975ff1046e6644b528c89f10624c1f99b4cc2936f268cb7defa05d49f15d5a82946c98a634d9004a315d50364ad980915a758b35ce3e91962e96199ede91d2cddd212f2f3b1efa465e0ed0626a5fea7652b4fd2aaec1183db649ee9504d5cc415a0f92aeac9a4afc1288341d8cf74a711984beb31a82fb605cbe77599fac0c08ab17929c6367ac54c9c547385518ce3a20ac03f700d97b38167f15e8011d92526a9d6391a57e297222d6a00a9be584d59ee91449bea91c52a80087942c66ef1ac5bbe7f38a3060b444552cc58a6b92fe4dc679542f84061ab27264ede6aafbfcbfc1d506da2b43970db032dafc7056419c003e7614b154482077ca1ddc54a0a446a8116a70f0c6c241ce2b43567bd8416fd29471544ae581740ce95a52983ec0963aa073755b73f0e5c12d796b05c6a7542d9e4e4d092fb8ee0dc89a8f5465a43e0a92c927bb32d16bd6055d2e2abe860eb4bbd652ef090dfbc52ec9fb3e86a069ea63fe3390ffba165177cb3768e7bc5e45d0b86b0aac27d6660426af993da77b80794d1532c1e20d8c52e89fdc370f8f1b087ab689df216285ad668f1a39985fdb8dae8e226e54ad723ac96f8fc4a731e0c4116c93fb97c2857ee985a8f60bfadbd82bf2b1d97387c0cfaba64beac91e72d525beff87935115581ab9afd1812f1e61b46d99ab2e9016caa2b6b11a6959d1212e80aadc5c1210bfca8c00d8ed767012d4cf8101a2b4654e10cac7342fee7fd869e8fc83ab7ae0caf55189511f266375b4aa66227e9f3b1f0fd37cf9ec2cd64d27e4c4eab78490d0cbd03ff96237872959b6b64e2893c80512470794b1855e63b1077d40bf835c93b11675d24ad6396a5327321c19543d11bec71cbb802aabfc55b9d09c7d83fca03ee3af414fda88a4eeaccbb3f4717e9aa7d07a0d19f38bfb3ef445c3f6a5d0c1d9d89a2caf7812fc36d1b1e10bc5a3a5435af6e2087c34e770c1d73fabc8f0fa908aa4e487a8d2f11887952008622ab8b8d9db8d981829c54e1a5de3eb3766d0f5955ab74aa2486067cc75f11b74d400329c23c07210bb1bbc39204f83c445de9875f9dcf94e0415271b5925eb32813035122555500f78f0c4a108d7e0a1b119c278920e1f3ba344c1fe250e56a577710377b4d08dbd7dc3491f4c3414bb9fc995fcbd34d7b408f36f3b10d8af513d3a85a62428f949586babd70c15b0630afe1db956d05ec8fd7ee4d4250df08ddf254e1c27ca192accafad9bf4c9301b62b7fab614d0667351334c92a6bf8d2db855b9d2031d371059e1569b4e3df408b4e5613642a6ed26e65c7aec3c2a86cb2533e29e80c08a3d03d0e653c927032393602a02797119d62c678870a7a13b6420bda1889804c73e930f65179fe8023f3fb1661e64d9e5479e247f7c123e9666c19e89b634c322d4d1b3fcc45c61c4b4574822967601096a83d870ac9ef98e82cec79c008de2e0b9c7afc95e86b226dfa81932ba175268f0d7e390951e40af0b057beeeb756f7983496ddf18228bef4b3a8549f943e88946ba49381da02aa1bd67d0d737194cf1dfbb93e36b5ed54887dbf908a353b65092afdda2d4021b575f5ea1d4f9cdd6e968a96ac3dd6a442343d90b1a28ba19d955bcfe338f40f59e53812f5be502e2a082e501c3a356200b47e7f0575bea4bdae77a9e385ea9c2b71817fb942971cd659b2c3b0f80b0342c7c3bba06adc8d75caa5d44209a8bfc55000053d43868041d71065ca61939017c00d16f9398704c052eba7e4869d72369334f29fc432587c5608ddb47bf5e6c08c3ce58bb1257b12973a89b3640110accf4f26a7fd0ae57ac5db02b7709a27f811117bb33669f1139e2043ac9d1286f288cae9696a75522e8f4177ff0b7456f6170892c7865a92ad49af6a85d11ad4bf6cee3d3e80c7388eb3666ebf4997812fe14e795f7515979f5f1ba3de1592c79288408862985bfe5c33a360dc963397a809ebdb21c20d9b681dec0590f8d98ed8d959ef9fc95de6adf19ba01d9049128f3f9f0e087f4c68d201c36b8aea07a3c7577aab068f79f64cd709551beb2165a277d2a2dbf89e653e512f0f4d905c6a5ec25242e220cf838f5382262481b6b298e32438221effd31cf0a49688e574e65e8c081fbf6a680fef754cd9135a16a4f932d23b9524dcb4831b9fc01e52c454a451759a82e776faea3a6f81cfb8373859bef442ed3dea358bafea3501b6b72a0b2886ab83a210b5378bd9563a7908d4d33622dc3e026d79e58f16a22bb7d46adc2a982cede2fcf5ce5ce7c5ab567c4b60d646a762345473296141bf0833e797eefe35713af32669b1cf9617f75c785300e2a092645bb62f23887c13089796a40954bae6426e1898b3c683bf623cc6ccc138445c5c52d1166cec802b0b6b51d52163e6d0c55989cda9f8d68270f9924a52e197cd38c0bba515d2a69a2002162dafbb5258a61581e9cda65163040cf55f7aff0117d6c2587ff5b3fa9660d53cd50b8880ee0ed3153ae91c591e6cc5d16243c1e06d45e827b377e988ad5d617af7f3f2686acf249ec0e5790615d0079dec7f9339106d3fc44463cac394108fc86c83fba3b85fa4c78aadf5b4d9ac8eb78d0c7291239e65a784091e77eaae8ba450a0a17daebee902daf1d1e460c992f8e5624583c8c651a130c14c188c585cdde36c00442dc29f50e5d3e0e88f6729336366920956986592ffc25e42d4fdd76fa9ef2b8475ec56471226869ee8be0e6bb0624db6c7808647cc9bd88740bfa19d9cd43c061ba4139afb3e22d814d546f9e82d338119bb9875a19294c034e881ab51a072e2888fe8f7a911a0f5dcd830bf4d6edec76b0ae66524519092b7ebda85eb38b432247f3874bfc0023f6c0876dd1476d29ea17c71804a813e80544fd0a3755dc2e37e8d951c8cf95d65192fc80bd21441814bfc249bc4d8802e361d36b86184da2697f3856c3dc4f0b86f1fcb8a33ba285d0a3acef6a23b7074aed1ed15a967d94339086ecdf896a7318f7fb32b864631b18d5761e2fdb6c79a1fb5c043d70de28d5f0e69dd533afac3b3d2d9cfbcdebb309b46388d649d0ed32d30d3dfc918eda088fa39f84c5694b88b6655ece8980b654ec3d47c0a0ec7b7797c0614011f7cf57f9c46cd8d2e90d9125404f92b9dbb36bd3d9f6a3abe9edd2a62e0e595a2fee7a2f67a344090120056b3023ae6a6991d7d20ffb0f38d673498f4cc5cf022c7565a716845f054fbf1573a6a733f54c324376112fc507c329feb837c31f671bd5ef970c28519b66b9fe09e83a5110bc14c031cdfbd4e39ff38a552342f369220e9cdd623f4143b3a4caa2b2a87c499f3fee9744d5d2cc85171825d988dc5bac0b26d8e7f43c25378d8827053bd88b5f06efa3854b530963439d108d92d87088a853e0a63b9743b495fa2d4ef797dd9f2cc3e6c1641d40f112b2d020c13da59676a122afbf6b6d50355ba901ed3384d743202178c557deca94dd20aa16223155b93e7a59eaa0416b6dc4ac8cacb3d39d1c28bb6b73638628266a42753149e3c30ab7f33b01daecd2bbf566f8aaf5a35892c3c9de83f20b90284115ad4f46b9913d9985f1e76757abd9e9c288cf1e45364a6d2623c0a04d031ed2017393f9f34923d5e79a5714ad7cb7404e3fa0a90ac881ee08f39967e6a5da7866d6b2075c293eebe7f4fcfc80c22599d12bc15f574955d7f49e75234d2dfc0536849a19d6f419eafd336789679cb96fb57ac9a6698539694b197593403daae72c162baad2a1988df8343b146402ae6e2a5f30e544cf5511fcf075ae834741acf68cd298ab3a07e7d8b53f040c677542af1221e261de84cd62d6c0956db0d92ef7830ccdc7928124ed20488644300a99f7f0cbf41513a84178b710afd5b47102ca794a3b267a01623308ae01d60f124d88c8af3695bbe8637250fe46f53ebf359ab6e501aaea643d3d597babc437b243ad1bed7c096d2b6e2f0308708c0dead206f7d6092974f0c23d10966b4dc501a03dfe0e842dd0d2418d35dfa0b7237ec43698110e8329a6b2777711535eb53dc2677383c901724df564a01939bdd9456b93aca7c0eb6117341533a9335a10e2d587c11d9916d7c4890c1537a439fbee851b0824b1f523bbff93b580126677f6ce02a9a5034fc9341b8fdc790f9ca2a24820ecffdd7f6036e4cb06bc0301a0f264d46e84621649ad65c7f24917f6dfead5d9385362a829d54c14829e16d559547f288d5a59081f4c9c6f511af5e94804f10d1fa4690ace573b82f10726297953db7c7d38523658c9d4546548acea36cc8d11238a88d8501462131b9d0010cbe488048b0f83d203107bad3d777c587608b6173c8c1d58dc88dcd2069ecd981f87cd9498196c40940ddb85601c467ddda3cd0ff014c7f779cdea0f039f28d37821ce4db6669195cf5f28741341cfdd84718b4d573dc633c42030ff1e7b8d11837ef70b52fa62d2b3c6a8df64e0cbddd91e5ca87173c32a531eb6a6215f9ac61d48bfda398750ff039ce903561f62ee75e1410b8c884f889bfd4ead3621b1dca902637cf3b4d54800eb58155c8869b7a5e1ac823c3ac40a191c894253979d0a7140ecde4f6c412ae707fdf858ca6c6de95db80205d1946460242d8887b9219c6eb1d67d94589dae015e2cf4f4709b5c0317b9513044a389110d22f70840aca7c8c6fbc81846e2a486b27304e1504033e9805bc41194f1b04a56cddaac691f9d612a6c95ab3d2b7dc4f25df31f5aa9349fae70ce2226f121556872a1c1c6333ce81a47de02dc5adf68e2973399991810d14dbdc2fbc6c022921383df5c03ad371fbd00b9bbb7e1ca6c63bb9205aef492813f654c2fe128c1e98c3c2843400218efcd34adce90f64614e752556d77eca1c9232ed2d7cadb928e330c1ed0f88ed9834ad62de3bd00eadc32e5b79aae44e1331b15ac08356eedf0e8e6132e820b28990b837246cb03f54e073feeda6a8ec4f9ecdbdae07921c6f0b06edb399f77895b33c843d434a86d538e0e8e37700c88110fd54dc2fc82c686866cd1c29ed427050751b2966acb056818da3e79b84c4e37b1779da3a101f812af231f792285c789f087941431225bfaa2512af3f4121791b987a83c5c46d2cea321ae16813056e4ffb6c9c6c346d79f5e9b9a7fa70368af5a7ce4f6b3feafa57d1e61684634e07221012e4a03787c7f8f3da6d3107bcf03eeaa47fa8d6b09b2e7549644bad5974b374dcc1da11221f81c22f9343cd58e43f229a3b188163606d4a0fe1826f6eb66d1b6d8a3ecb8e3c434d419af53681c842521ef7f29a3660489543b66d80a1370600e2ad5316f7d3278d376ed39d377a076e01b9e95d65da55c2cadd3a2b6a3ff7d40a3cb14545d08550b967e48da7a903fa632b90b5667ce5048ecf42957ab53b8b712f0dd68004351e2c5d89bbfc2261bbf76795d1388b034514ad4a335a4dfbc17b9f736232a470d5d6b9957d9f7abafc020523c74bdafa9b82f2d48554d56db16a04d0b26938d2d3d13e34cc3a1dcd9a0f138f7471973e050bbe26f6813ae1fed03ef91daea1cab3490a37d432f1af4dfa4304d1131ff4f30cacf53153142f348f7b51a2fc83e58279f0e8603393321d86b97ffa7cf21c8a1d198bb9a8ee3b51c65e4a4e0ab69b62f084410f38d9039920556751fe3391bf6560e2acb3151700311331b02fa54e44bfd4ba103afe621cf8fd1fa83d8c30184a15f6ad48fa9c29059867fbd5caf143a40282e1d819bf3c371bf31f62df1d80d9fbbc5cfb4a18db255c51b6d55a912bb0465a175c291ab13f838789ba549214caca259192ea38bffe43c84a87e4cd5d6498ae94ee3a0f99656d3a825b7172e9bb28150ccedecb77aca715c441b45772fe2ce4e7635ee4c8258274f3eaa94c482d097232a66b7611c8efbd80e5fa315218ab857ff5ae03ff33976c4ff92f1c4cebe43e993f7a5a9b8b2a132e1fda7dec957b3b9e98d36911829909a284ed6ef1240e02171b323e922212c78cf84ccd2453b092e928c9a04c22f7825300f5345c3dce8e5967856b084b851921a6257a68d933b101b9cd135fb12a159c190dd0a212960e72c8a0fe64bbe958025dd845d296a509a760702692575aad8f0bcdcd9eeb7c83c5557b134d999cf01ad47c7c1cd1ac7406af0a44d5fbdb9eda198aef9c41e77061506445e4813239e41dee6cadccaa221fc66f6ad87cb421821fbc9172d04793c0c2e044ec1be5d81e006e2016ce7339022b7d52b37b36e1e648a02f4400902e9d8ca229565d9d3ac04c1dd6a8d4368f302b789915aef24b76d1859947b9a551be34ef9b4386ecd5cba2712d3f4a9afb50bd2f2575a8d98e75b065c8e29328d89a1fc74f2aa6174ddb527eeed80e5fe83475d9a78fa525901e582a05e88f8ffb558438e32d68a341de6e95e6944d10ff97abf89cc5c4d4abb6a55898b09a9c46810b54548556ba7296aa31a80e5c4e2cec5dc58b0c8edfef3e41541b79bb844ca925901533c7c0ab303f9ca371879cb68ed6fb9b900476dfc175be1803f14848ebd88d6af69bfe28be8d0da3896e07d8b8d89f40f348b5ebf010698e92d44d4c2976962d9b576fe6f9bff1ba382a4a3da6a85c7f087df812800e3939c26b4c44de3a2bb4d0d5e5e6c5c09d76524318c2116037afd338985499b26049e7eab7853d6a773c3ebea01f73d010159351c9a303e11c1d5bb9970f18c4ff54d4b690a7107664d73770cf628b8606d13ebd6e4fe80549fd336e5c6808033a8e60d693f5dd3a339fb38a39654188a539d984cbee76662ed9d5d28a5f1a9a28120487f888d825f7c3541851a6220a2eb06c7380cb6733978ea5e41f0ce2abed93029a376c66fa7eeefa056d6f2fa00f025be678e5b4a25ecbbbef826495f01101205991592a7fb231f5e0726c00a4b618206d9a14843f4c30473b4e091d92f41f05ecc1269559fe17fa2bd7b881791513551312b058be92b229f7454c153776162f92579b10ca2b35ef37dc95e504b6d92a235462325f312a95953174a3c4bf8a9599ed4f44f49dafb0fbc49a3b2330b5db7588a792ec00d68677addcebf77680831cc74302c40f2b0268144b5f1970ab4839cf8d466ab3ab00547a45e1eb272519ce0a613866863b69f3e5d9f7b79eb9313dc04a09462c354c2845fad52e5406cc412b77a32c071caac2c8032840a4dac3fd01a6b4133c16e438ecf28812432b51ba02a939892bc84c087b54be99705e77a344021f2b70964c2dd445120323c85b4a2a16334c682fcb0869ac0503cced5b51fbc5abba6b528ab0bf139685f9b09f313c0e9db38cb3955d49eb5d72885d694d8ddd9e42531c6f11297e1f15ee92be370a967092a09eac04759681d0eae33e5043cdf7d2d4129f9c9fbb227270c4ad69db3b3e119002a3726783f273bc1abbcd469278ada4c7ff8acbc5a839aa52a33a8223b3a03bc80eda648a6584a220e504d435a9c014f2ec135faf78cbc7f488b532a868baa0f4536bd4323e7e27c1951e72c65d2b8563c311b676f7c2f7c6eeefa176085a6f08b62e03a23c131739e87bb9dac05c0448093a22dcb491b8389fe4c6c962ff8843ad0e76baa23a6ad6aaf29048e3174d3f71b5e1109852cce9b92a8c0b34a065d5b761f9baa13b335e95e8927483c95c7ae2baf97f59dd50d397c6714e0a5f1e3cfe4544057ede6ee94bd4e21b483ea50917d1aee469701008d0baade1b55e707eab23e929cce9f730ec14831c9be24dc7e071839714ea095568881caa5dadd42a370032a289fc0094731ba4946d479788ecfaaee55b4cd3466a5b4b2446b04a30d5a5503e8523d958afbd1ed1fc70f487a579d11d0816073daeaeddcf85cdb54b54f177e1bf3ddec7075ca8ef32f9735cf82658a145586bcda4a06ae26d61b84a59a0baec5ac897dc5663c81b3b54976e73c92d07f26fc98c78c733eabafb9559e843598ad76cbea68336c70786cdd7e7e0d680e7d9e73caaabc8b4f8d35dc60a19dff7373017d59b4106c569a2839c7b7b274308711c58e658dfc9ca9756cdff2c1716010df4eca49e2d1c2c7fa17ea110a979d7d046788ff86f57ee164fa2491787dd64a5e13a745eb60638c20017e013e04f3572fcd247b0d71abbea295dc36134b4c238b963a08b00e1a690a8374bb12be81ab11026a27aaeb533d117223a35d4ae0467a7dbbd0d5830d6917290a5870e6dc46f9d9398b5173b4dfecaef3bf7ec096ac4253961925d592ed75d9579b574a129bd1025492c08aa835ae96cbb461271215ad48cf5b208816e7cd0c847473feecf1d419cb6bba5d77fa4225a20288f5274846ae94f5987bdced38d756bd8c396fb245a9e2b4c1326cce16a120d8c30d3b086a2e8e6245a358ffdee715c32baff63fa01a32659414a0e24f2db0e2afaec89365f7c45e22b662f31240e7969723e008876479cada45ae650743cb4411d80eb74ade9202275304e624eb0fb12fa93f1586f671633907e4b713d4c05b5f2b1e70454916e45d71ac2cd380764527240489901ee3a00cea6088faa2c5c9a799ba93adc666e41ca3ab4839a53321a33195854748128a1596b4982f223b41f48d514b6a484eb9bfa92d5af769bed16671f625442b5b0f289d39e8449cbd8bf01226429c5f4407af4a07e75618135067374d6e9a2b37e064ed786e6c7dc20cd45bb73b95b794250689e8a557168277439e4bba35c842c1ede78a1f7944d74f4ff9ae151b6051612891b53a3d9f224672f8744d6d09f81d5308fb7ff59654588084f44158214eca054eedab94d6930b15f1452c727c5868f14e02c9d9945ac048439c393af89ab61a422ba67e4d8c07326c463a2c5712ed5caf34420296a3749ebc694fbff47f69753195e2489d98261da76dab7831f5e660aa1e21961104954140165593b5b0b6ec9525a337ac3d0722d0252cb0b1c9b958a0edff3471ef0d509ecb6ad68d5e602a17b00ea99fc3057236d18676cbb8bc5b6988a8d213d1d31634f94a952510fb1ee1b66ea3117cf65463fa42b44b96d303829acfb26b791b30780b87c1c7cbca3afcb97f18adf3176b79f003933d671d5cd48d57f049d8759b5475a5805373d53b003bd004790bb1a6403ac35a6fde7e9aa250ac2dcbb0f9872181ca2f6f1c11070a53a37cb88e2c4ceef08b0dcead10ed26f90dc3594b7d2b1089c4caad77fb6c505c9a141dabac72e3ca17234e5567c08f86138fd871a104dcc34b0bbae329470851487f16acba4b6da1f4f19e239a6d68dd7c7819706a2aa67e77a778db72d911a77801c443b404e6e7a1e91664bbfce3ea8562cc8ffce7700244308983df19e007043dd66d86cebf257cba8227f0993ae355c4c6a1e0dbd5552350495524e5bf594fa653073ca5a38b4ad6e20d5e1f4a4b44d54b95582d74da101c06625259ffc2020662b1738dde95a6c67301f8d887c32793101f74408a92a83c199492de55223dfca478067406586faf309c2ac2a15c450fb60265b27fb83df96ced792663d61f8eebfbf827e939bd0031499083c8e5274b13e6ace4991cf85dbd35621fe46219477bc996b6dd7163c85cd84c8f05ae9c7604e19a8b2cda641afe1a20db79a5b2d2c937c9f31686694670805cbd7f4251f99568fc1b9afbc6ca0fa401221a5e3bab4365240d75b84f64be0195a44da6d2e0ffb1cfa8416ddd994e15307f86225c777d8257ae54bde5e6c5ff8b89ef5e225f4b6c7f4c3bb50851cda62154d0081d34b91344ac33d72b0faeb2605e8bcb69a9135cafade1a1c540ac9e10193e95de6d58591a202918c7044bbf0bc59186736553289cb3397189df8a1b09dcab9378de24dd0434d46b2261e76f2173112026dde1483186ef7268294e8b91e649b36e83f3c92570b334e662233c272b9284a6c9a0da34bb670ab02f519863a3b50f874eb95648b740397870bcdce75b0d66e7d9ab763b04ef06cf5434c1b02c54c51e83a41d7cb7a9d1d3c516cff1fd371737211128e46a2a865fe1ed3aac76d689d9cf22711e879b8d76f1b889f61aa1df3b03dae0c35d49ce3027182ed32ff993444c8f63e4f4a8065c91ab8b0944e24e74cd1f1a244a05068b5a43b1497df6ebcc3a59956cd10b903fa5620b949dae2a184dd589154ac609f1aa9ef3fd0c3e687556e6c943a1975df244d8786240c59a2e490d50aa785bb0eb33545ad00aef11fc1db7b1a674874b5f89dda6e307a6eaac1cbe471c6dc279745dba6e8a982ad94f5e26ee00542ac96cded164bbc9b3539e4343606f84d19a41f76a3ad681a343eb32f7a67978a496b15f4914625ae662a173d536ee6f8a7ba9347d1131d7b96a3caa44533f5038ea67e9993a874bae31966bfbc794a1f35b9efc249a6076e639bee04c1ae6234f66cc53342b9c5983ec68e165797054adb636ae71c6ab6973b63997012747b504ee426a46230710528245f271b0b4b120e46e731cb9f978abf4be721391d0915c46a302ddf7b61c23fe34e0b7988840c8b06b22ae586443a2623be6a79cc08940bf004ef733a5b7a559fc8128986c71170c5e461334b812d87dc9ef3c46bc0bd667a144bc0dd7c26522db94ff204d942a10408f3107b8d3478f51018d0d7afad1116121361260f785beb5185b3a4a91fccd66e982ca89b438865f0d60913eeeb9df77b36e3e79738ea1517c888b6dd26d8fdecd1153dc527187c9a98d984552102752e695bc2c5ae18fe5ce73dc0f050e0d2db7c69fcc8c30b878821a3d9df2a4214869075ad75c1f6e5e0ba980e07f91e53ce10a5e8c18fba754a722f28a369765561456974c0dca108bb1f420f833acf526301b018564d33e1aede0335b000757192324e7df4f80e4c11e5b8d806e2040425b926c26f9be6b1e0ef5dfc70bd993339bd39033abca0237dbe6b2073d7327f314883b052f3831052c2626ed92561d50b1be74c5c423ea7df697540c6ed4e6f2737870ad91d6c80554a17ad37ab9727dbdb821662bfd23a2f8c3e8687e299c8a7125a75db559d9b4518a2b1003186fcd9838303260186ab2b0e44b35de5c8354a68ea69d174b7c33c10f3879709c5fee8c1dc22f6b0c07527011b0cbf6c4352b391f162e8c7424be55e855b27d3ff613db56e85525af830dd0233d1312a63e52be6f8946afc365f9e6903b23bee323535c3321f4124a404496318f6a1f94230d8452456d53ed43f322d04928d02ac565e5d5481699de8b7efa0ff5d9718a89e64d14f05716e3819b67ff4bc5548cd8d8ea9a94c313cd733c803f15c1bd8ae962af3a4d5c491f590f2b3b0ba26c925e48b1b9bcf8e7ca281091b0f5d9ad2f45b655a2e5ae9739edb51658c7a7cc788fda2c833646811f9fcb2792b89de42156a3c34c07a808879bf0abbd9b08343b8e08adee2a3795d5f24196e719dee7b220dca49eac557a741b2bf9512b46e665ae7061f0c9f4421f8ef5d9ffd215ccbd837fa15ac05195b6ee4699740a5d835912aa1d8ca58246b465e9462ba9de0f9fd555288f8e61863697560a366fb0d694f1a03c78ec79130a2bed12f4deb851f40d4eb27fd5c69b885484e8243138a5279c4547084ca1d9f1c6b56ca0d4e4e3c0b616485bd8fe6e5b8c237f8676ece24102ae885238456e04d8cf72437ec20acc47b707dd0d1c8338ddccce6a67f1e135eacb57e4515deac7cb2705b1352a16bbc9de10c2a059f1ac7a2156ae841cb41f6f0ed1af73cd166daba0c5d5fa8382a8fc877b746478b2564aae4ce2a998b097bc527b44b00ee4bbfa0a14c7b807adb4d31f070594c494fe1404537c644290abf3174fae852800e6502c6c04a0d00cdecb84e291c225fa40ddffd53f28bbf2bde3015acc0a03b4e6636ade4f4ed88909ec9f51b2c1028dc74fe40664a989f69b774ed56388b6cf2d7a3f5b657dc816b08766bc3c21724284400931a7a1d8fce0fb947cb0935985338ae90ba30e407b2bd5f5e85751f6be259a01b3fe64bfac0f2f96e92898496c51af5580638e45890a8b17957278a474adaf90835c9bbca65c39d6a5677425eebcbbf7d32c5eecc1c495440f1abaf550ab0347431c9b24ddf0f50ce24a2af3d964039cf782a7bb6ab822b85d6587576596251728953d92f6843d14c207528386942df47109f9d0a405a392e427f1f34b93d83490048db38bb81766e35cdccf2fb903cef71e4c9228559dd1aac0de7fd7658409169c468d382eeb512f87d7bd8e50015f74f207b1044e89644b87db3e0097a7ce2436cf90de5f043157bc942683d0f66c535623ff162b3ce598af3943f27d1114f9e67a466c5a08bea0d97c2cda582aee94e3f8a7f7c4802b7df4fa798b0da5b8378b03cb1927acd376467d1e78b860096683a713e7d3cd8416fda734ece30b6dd376644f1ce3f4dc0f77eba11b913ffcd52335d61891c368ce76e63454937007b63a96ac57e330687ddd2ae8a9fcaa6014849e70e9c0f981447e28d08eebac4c3b5838af4a321a535911f6c539b109705c06b051edcf5c4203a3c628891e741ec7285163099f07f471b47588adf898aba0b7189b80f525841d9f3e1093824b4372fbe738316a43342829b7b1e7374978610bba6d961b3ba4a74d5a504284693bc9d1ebb69854370d0b3a8771bc71dc02077982b8bb03338f600a3d2ebd98a57bf3d46ee7225c618f7ca9071c6a958740202610ea0282252df5d2c62a6651640c83fa8e37691165b359a786ec6858480678b62b8ab6f3431fe743cb023d9b1b8223acd86b169a164e2a62e3626b780cefe4a4088432df4a244be431ae422f1d586faa7bd221433e88866ce7aa7b42a71cb263301a120691d4b5ffcdfb6b8e3209762b3edff6286823aebc5451670792aaff5247b313378042c427aa37816efa2a06a0424f27254ac85ce13a04cc641403b8da44ae5ffabd82e7dcc195fc8ca23cb085482957119db777e14c787d28f82d83b243518e0dbe28ffa5eef745405e37b4973bb43c563124854b494ef58af000c2c182fd76f58a8743bd360478432d4b0ee97ce1c581aa660ff111e65f390cdee20420d8fa4d8d692076167e6b2ef772695fde4c3fd420b94ec04761bb129598ee707397da0518c054ce178a646ce0e9db289fc301f2b432acf1e1cc9ef5eb56448f598c72586fbf008c08e07fb047bb70de34e85f5dfa9706bdace478a0be5a82420becef94a4f1d94263de507bd21dac40648c4a681dbf628f8707d2d2c6dd401904ee01680ebe823304928cb0239193076fcb5efca1cdeb12fb1e109e8491e5207322adf4a044037f4a02818fe52abd813bb931c2509640afb1aa2cbbf218b08f98472092cf7fe0842444e10df19061e34523bfb51038ef29cf29ed18fac3f290d2f211e228a219e0ac384d3ee01cb628b6e210a684ec13b15ee16ff5c9e7c51e1d83657f30d74951381a2cf0f8e4bc458290ba4b340d7e659294937c05ab75c5ae3aa4a38f4a4a0fe0dd2497877a83702c83724a24de7152d459239ef472afe5ea9ef091b66012237412cca772d7b391d89aa8512c21ae54d3dd91f2bcb46691dd9d955ab171df60d861860137a5a5dfdd6fb4780b2ded6017d0b663bd29a4010cab8fd38eec114a37d01aff11406605486fb8ebd155f275015e2e3d893ad5220178f97addcfe06dad81826225888604530d0a16571cceb45635fb0c69f60ede6ff091074722a3d749cc99eaf08c522433b2a75c12532437de9053666968d66dbbfa4d54683e1635404e12b975997243d9012bf523ae51be174232da9065ed45c4886165434e87a136943bd4ccfb9c5e62aa2bb41ec270296fb4a2eb76f1091f79a2af8729b675caea7774babeef5a5b1dcbd7b88c31d83847edadc280a4e02942a1419c4f8511fff75e4ea13d3d40737ed88ba62cde622fab19725a98e018b5d51281eae636a7b547ea4941c26a8b7b5916fb648e274040c6ae13c35fdddd2f49874ddacda922a0ea56eaccaf1a2170c18847246c8feece050b4a1511da13d151f30e331880db300d0d58cef821c90d02df1e817e68b9bad148242f4e016169eedcf00ed03054e24275de95f013ff591ceafbc27a9beadda8c0f1adc4106a00e37b9f8c1d2334f097b9ef6602cfcb10f8c1347717a563c92f2ccc44654df86a0a25d84d364da7ec0d2008f677fdce7e454211244da0baedf597cd5a641a82bab1e959d71eee131a0b05682917d427db195b42fe63b504cd1fa98b8011218f17891852788d1763abc05c7980a2d88f1102a42db1d38804c9d72d7bf4f909c1ff1dd4cb3d2aa543927385e0c89624aaa6c6399ac10f597c568b01612dcc3a981d10989c4042141611b5fa3c7fa67b70b2e8e8016c41abe720ab3eef1ce57c2723de3a48133ab87f047f894f2cec8b5e4c5ad1d0dca54a8315f4e82f1f2d0d7c0c5f60f5c51ebd70bc013ff448b596848de3c2bbe96a42941b86466d643978dfc82667b19df25b491ac04907d66cb73498242f88c54871da6d1c592eb8b9d6d7b3f83276cc4df65ea541ce82d7b84cf2bd3e6a62a8631e3c9c48488183639399ff3e7a980ca4a0fa9f41b6ab69923725f33603a0d8bde144a4a5cd10b8ac21344be6d7045e58b680fa5fe684f3199361f5dec7ac2a331327f4fca6615ec591818d8a8af43a8c92436c72d8a884f11b9e414298e191192cfb6641ba2cf6f1a5f494e5207e14137e16e6d1f78a2c38e6d1cb44e36a214e0587323816448068b04e22538c1f68e712c42311904426712dc5c50e89908ca93707a60126b6e79cc09ece4992cab2288e226656ee3c83530971ea6196aab06bf41e4ba08ab1423559e22b009c4238335a44f64e6f68281d98762c296c8f5c0813904243140db2a3db11d191432cefd034dfd335ece71dde2303a9446d9339ac36e59e4a31af53722e19a8ea36dc0c34dee2912a276f1658ad823e42aab286e1273a11d804aaaa3c4be2dc36e8e5fc2378c64d1edd9f26d245bb1c0f7d9e3413eabdd20e0b171275eb208c94307a5320a9604b32af250a38ed1c1c7d103ab0051d1c0e781888440b77d1af5d99c32ae8ff3418677b3dc7ce24327f9a934f8c02843181090123229bf2c463f75bfba55dbad63689cba2df98a203017c8a03da1e8a6e5920da15a903d9abd27f458ea7769d7c31cc9d5666cf13012eb38c2e4c5d4817d6c9680af1660be02e4427ed4b600ce01cd600702076e890f040c95d081e7d3bf0c3b271a7f28ca15b4b4222a8027941dc6def2df79652a69402d206c606e40623d80c9ff1a2a4c1f519df2f6962824dedc334da87b3ff89c940c791b8153e3e05916bc120a89953cbb7a09e6680a26779fb32c0202da8a7960641508752097452ac766fa01f10380871b9efa47077e53d6fcd65480a19af7d3cf849c67becf96466762dd44df0c5869e665c0e5c79ef3ab9a28cf244ca64109d4376219bc005394a981692149200512e71fd59240d98013d246cf4b22ed64a47739f59f8f33ea3588b5d064856404f829dadc9f290460c262b7c6245d7d171978e8e8e8eebb8cee7222a78d286bbf58a80cd521bb2da9881804bfb47a24e6e57e089629ea8999aadc93387cc23e66a2a993ab3c8f567c9cc2559ab944f230a2b6a2f47d0abdbf990f1392f36a26f7911588410a719dff2334432b04922e1924abed8885a5ef4a3a9e049c97ae6e34d230adbaf434a6004bdba3db4a6bd4c617d786eeb5e0629e78712b0f839c958dd9ea823660be965c6b7bc10a7fa5dc04f31bc88f46223fad18fc09cd18b5e889337832451a4171b979ff12ea0444998ef67bccb8f482f3632fce8650047e0cbf72ee0cb07eee0a7183e0650aa402dbeaf3526634cac48592c2f56fba25d79d65c8245a14260ec86fe7850b7012d131b70bf1f31d109a0d440766a29419354e28f188f9458f16f0bed6f037de8d5953ab012a808c5668809569ca86e990c2543c9503294f6a22b64133551ddd665c4609c73b240f30769fae91af3266886283373ce39c70bf8a987840192127203c60f128689cd2143eee0c8144c4345e7a84cb3bd8c0178200b143b234d4088f18425cc9546bba7e3eaf63d5bf50dc8f340b16dd53d9de366b58a75cf0dc8f34031ae9331f2c701f246de0887e7755cdd34dab205700956b67a70fdb9d3a4681c5ce7182acc47f86ebbb7043e5066451ec23210827f304d739288fbd2f4da4cb60a010f9c59955158bf75369bcd4a386a6c6a7b3ee0669e3c7bc6672882952fbeb681de337366d4629dacaaaaca65bcc2ea936aa44875d59eca9acdcc524ad7bb58ba4206b7608204ec94f36385253b7dffa3a508d7a90ba7e0aa629a15d3f068095724565c7f1a46ac58955c7f8fe723c2ca97cbc31e3f1a94b0defb007def49972b7485ae303564479d02099575fd4d9508c35415c7f8fb083d28641a661a174161e57bccdc1dc182eefc5e76083de879f0fefbd16b94a88d22286c836255d2a2bf4d3925d80357afd65ac11e82a017879b99b99b6a929341d0db83f6cdddddac854421c0fecaea09b2bb3b6ba129d65b591eb6a42bc4a7461df1fe03736a4769d2885362eb0adc99a982179a68e11a4f7ceac0235e71a4492e61187f9974a9aaaabe5c66565555555555555555516aa393cd5062eceeeeeeeed6f89b58e107a8536c14628930c1211858d0dbcf612134b9623ce5fc5881bdd7e81c7c7f4e3188abf56f93f492c3143bf6583640840cecce2311f1ea71fa00baa28b2802907f38a658973bc198115eb8fee5e072ebd7e47ae86dec5b30476af1841e273be37802fdcafb57635f23d9db24d6a20848ee46e26b493d4a18d44702033b03c2bb01283361cc4c99b97182157bdcb6d0460947e720293839729c1c512c2547ac82a8e48e4c713299176b99ccca703c742c2cd3f8f4004e8f3aa43be372de6b37a42947ee69a0426a82650f6d3cacf2c2c94cb0672f9cf721ef43a00fd07f209f38506c1f4e0621c994370ab115e4389415e528479709e226ef1df40a446f973f0938b39d1ed6670f3be5212705ecc2b287b54acb98a60ad370d30939cae44892a3cf26784029bc4e89b1e29b92a6940c076d6a9694dfbd1ca24dede27ed324101c348c1ca261bc03454985acc17599c4f5e7da88ebae2a71a049204cb3bd8c42d6402661c428a1f0d6624c09639b9aa6699a8d871330409bb86bdc03304cb3b111b817390b1a5101e3c8710d23a76a46cf8a56b5f95a47032b8eae7f7f5add3628e69cf5980e12616549ca4d1bd5c0e66c369b513aa56bdba9b5568ed5e7176ddc7e1a2014d45bc11078c8347c2587ce128707d3c80bfad58e0ef49fa67d0fea3ad07fdd7b3c80fe034b2e60f0f1bdb7f2a1d7b4eaf2848f2336a15f791f1ece4bf7f7d2200f3cac84409046c312b603bd9f76d48034baf1e7750ffa1c30c7035d442f6cdb01345260020e6ffa060bbc600710217ba53886022c2b712dc9706432994c86c3712b51586245a68a8c47c8d76b072baca7dfe1322f9d16e395e08b7cbef385f8a10b560c7b8734596b297592cbf526055d602d8bc5816dd1c76d5bc48ae10da5290786f187b2e347cef9e3bd58dddddddddd1a7b5d8963dc9320b650ec77c55207c57a572c953a87a39690da154ba551693492a65269541a953a28d6eb4ab26989c545370fdac443c2748eaac48b0a2f287891058d2456641f70fc72a84f3f1de697c3b6b5ab3492168a5de176668b039bf5846b48eba458012feb3ad0c7f7476c3e90c197e9e3653e9f3a1a9858ffce8ea4cdc20633f3a862c16ed788d1bf09863bd6a5f88ffb78e83eac924fc9673e33b39dfea261fcfb5be7755ee7e7013257ecd8f6bd063e17ae30852f2440ab44f791b9a2ab1e7045dfe19058d9627948c308cb2c27e22a1f1f1f1f1f1ff7711f4a6d4891125aef689675234ddc7332c90bdd3a311cfaded8a0092638874ddff0da840a7ce246e65070a64acfbc9182cc27e8262716ab321addc4b46dfb949873f2e439e79c737a366a74873d86f4a9128bb2a3720c6c62e53fc7bc5eafd78e275c2e53b581654c8561fc64fa77b519b6b05f415ec781c03ae76c1b7c474cc704c3f7d0e50b567ee7c0ea70b95c2e970e4aeb1394520aaba1d2b44d6a018ef1f7c14d1501579ab6efda4198ca6d928d4d0678e81bfe1b49233961abc84710d989059886effb0e1ce3308e03d65ca06fd8d0bef1b0524d2bdda0d6ca951bd6b18e553b44126fc4f51ddf683d0449221c7e2ccb1c33478d7eece29a63099f1d2178bda28462b59b03e9a43ca5e372d2446b088b476584fbf9f9690ee4714c41946a744a3baf683d10685d292edab4c30b870215ae37ca9398be8567e1499c0aeb38a85e83ebaf5d61454fc16029580af6ad48b1e00fc8c30e8aedeed63fb27fec0f140bbaa2ad3d52a0fee43df7d607568914de37cc0391c026e714c7b1384f718caf9048adb8221e4ed95cf4aa6157a86c20e7ac54ba87e826ae607d0304a5e01c70e863150ce33f04ac75450f58a9fe7151e9d98fa760ab15acbbbb57a9558a4ba552a91df8467f123ce5291c351c637323831593b55ab162517660465e4f5a3c158562d91512984a07ba4e225defe2fa92eb9d27a58c59e9ee4ce34b347163b8ac8512ad4b3f20fa5623ddd717a7914bf295af6444f9bada532b5c7f2986bb46a3781595693a762cbc07bee21831d8e453ace46bc54dae285f2bf95ac9d7eab5922ff95ac917378bccd554ada68a065484693628388764b24295a039c6ef064a9ed56baa54413c0832e64260182f5e1edb9cc0e4ab5153c5327649596513922402c748270ee3bc85273df5b56af1fe0b710faa3e05c738e854348c7fa0e85c5c7f0f149b0572c370a0e85b340c2849c334283a0fdab7a002e63275c534dd73a01b218b24207f5fc95713962fa6e1a0742191c079b5d65a3f0f9c71988ee11bfd376a709027c31352c662b5645294c47660515cee84a65229562ae52c16d3905a002f4bbf45f9e4fab33c6c79d87ec475e2933e85c19a34119dd5800684218924830c2c2e1343abc2ca9f48b0288be52c96a649901315a534caf86476840f95580c0683c118c635d2d4fd5fea1fd9339773f68c695cab2995c23006a3c104eb75a100ae07be50d0f75ee841341861c546813c1fdc7befa37bd088abb31aefb9f701faee6342b0f48680e831ee4b9022bce7be08d0772fc4f51c071cc3c2728e7020112f35dd5f804f1df8e5d0af69df0d25d0c097991a5e72a0e2cbe6328515676ca0c252c043972aacc8aff9e9606f835270df2869b2a222b1a8158c4a4d0b6d947c73fb82f6b17b44b1941cb10aa2da49496696b254b2121c8114c0915c9f0234763e722b608f122c7dad6218e92cf447a91ab97188d82ad625aed1d5ae518ee338fae823a5212d1c368e23eb937294b526b19386173616a341c48aeca2410496b5d6da0edc073dfa4ec3a0513b49ac5fb1562c7058859dcee1afd1b7f01d18a094b8cb437f6f314d7771794a8c0a1c240a2bfe0522040926c6518bc562b1586cdb3e2ade88840ee69c7394b2f267a9d65a6b85511a6cdbc61bd76aed68c4b6246bb576349261e871746adbb66ddbf64d60bd84c3a07e7ad997b5f6e572d2398cd008b8b3c72f9670fd6b04b1628ffd55607b50cc61db8090638cb1c9a003db9f433f10728c31a64b5932bd2c2c10d26bb05d1c9345dff0b79e85f5cb333995ed970b4c59970b4c76066b2da53c76e0ece0d14ce03009ad262499210a2bfdc331eebed2beab2e97cbe572b96a0d39c6c56264345d78508494ac9e73cab64cf30dd1a6b053a206334918c169bf7de55eba7b0725a4d324edfad73f728cff04c230cc800d06d75f93c1047bfc306261457e694e58314442b550c21da3fc5ae7f49e98218e391acdf9df7279083db0e28ae17c71e4ee4d50a9ab80cbaf99948a85bd21f4c51c51ea9a0b344dd364386de29ee7f34fa93d3f0b81c9cbe7f423e485cf890bfb86bf0c0654775a9a0d8648c2ad9f6ea00d35e4b421e461406986366861e89a0c67db4036d05ad358638fc5ae7c2c76f43e3e432c7b48a5f4402bf60b5970a5863e10e775dad4b8bad53ac339f7858e8eead553c4e52d77e22bdf9931f7c9e33293089b5a8700d7df554ce357c63b274df64587d1a0c28aae13facb2eaacb50a699b22575244a0a6153cb078d04c380c050b6c9681e92249d837bef76fffcb5a3d572994f6b47abf59ab5c637411554bf1aad1608342b28b45102b9cb16bc6913d464f496d3371c023e30d23afdf07666a7ae93d137ea26b51a7434806fbce66888c6d1c98139559b54677c05418d3a3339335f135e33a3191d978e8e8e8e8e4e8dcc93f2ffebd7afd555841498b0a95500609af6de821558e50425d07859b15dcde3aa6258da4bbade76e530720414a0508da7feee9fbd916c38a6c64350b4a06c5718566cd503c18aed5251c0c3510f8ef177cd5c3eee72b98b028d637bed29f8737e3e33357da8cc586c4ad122d31fa4053327d1a3eaa9e5f9991f80aa27d18bdc1589fa7b5e791d4e830afb329faf769a3e3486478931c72933442d2d2f12b55811c9cef8185e943f35325e87c7a0b049fec8dbf2f2478c1faf63a377f99834b98c4a2ea492e85b5e9425ede98f07913f31d0ad21c00d3d2af46a446143ef695cb062c76231f9c3f2f67fa68c22653226757cfa0649362161a18fa7482c6154521cc6bf3562ad5432406fa9b10473c728188bc5c299b2ce82c5c62ed7eba78a131f1e1915d893e972b19cbd8df64cd65a0150afb02f3bf8a9e7edd7130b4a62e9e778ffe4e9974b1cf5cbc562695f353027477bef2b98537fe33ee783e11f0eccd940ff32419b8fbe8fe7fec5c67b1f9587dcbe971db4dfde4603e76bcf270ada54f0067c9960cd69eeb4abd52c579425ede258bb38d62e8eb58b631c6b17c75c1c3332d359348c7f17302e9a6ce18a6d00ca288cd194d18d6bb2d060cea94d6dd643f6e8a17953aea1693dfc9b2013baa78734795f396f7605fb89c350c07b7c13ecd8f53138c6ff658c9bf3a20f35c6e8e798264c2ae8f9cb53430d38703ccf66cfdc0d4f9a617e369bcdb6ad34da18a8b657cfd66a6d206f03792330ece5d3886f9de252ba09d7bf91f413b197741324987a4818d8900b6040032c532a75c9927a48538d8419d239980e81d5004b804bd3488ee6aa860a27c45aadd3adadd699d010b899678ca5bcb8675afbb57e53fa4cf3b9e8c0b287b7bf1b660d13895aad9da174d5755dd76a750e6460f7ce816a6534912c79691ed8ad195d8189bb89d40b266559135a2a9f222b554b65237beac669df01fe0007543d5a35fba902a98fc044e0d0f6105d9715d184b1a5ea3a15f75dabd59ab1999921f96db53c2fb451c251637313c4689b9b3948376b5ead6fc009c3d22bfe126c0f4bb84c831081dc9e2bcfea8bec73e3a107403058917d4413338f1e48600296916f5d70fdf3e1d90d0d7a3ac56efe36ee15146be07a6afd826cdbb681402216bb12fa40228fa5b3dc4a0d7d54d3346ddbb66d037d9625b4c20256cbad84be0ee46d9bd771356439c161ccb0d878c4939e9f202d6b2923d1ed92d87abb24768eba2476e4a387fe4305c463c58685ba4ad7c934130e5552878763b8ea412a18561c09c089ed7fd1a18ddcee1b49c10a366c94a6aebed8bc67bab9f4a582363f9a1246aca3c1081721d896151b562a51d8f852c31246f6c460ad82e5400a969955b0a947bb8ab83d706db3cd25af381a81110557e708a5a9abe09a15a18511d63ec2465bedd980c49088f580cd601b0c06b37198a60283e1a8117501d3509a864ab57886b08e5829d1d15028ed09b11a56a56106564a6dc60cd804d130c47ad81c48c52e20d4a4848dda3698f7844c715c5754adda0c2ce781225c6f2de8a80247e17ec181a4d62899ca63e9152b2af460b3fe8b1ce143e4ec2ae75447b35c34daf6038b6528160ac51282041344505c2c168bc5623729ce2d9526a289182580c39134351305d0a1936f7eaac05f7d05418d3a23e76c1a680bd8cb07f0e33e5ec563b399599624ab540a435913aad4101c1e33b8420aa8d38f298428a7232f3a740fae33abd5dad1c86b50bba669db65e7256150723d8c22bae8557cbabb3f3d42830e9bf564fb555f355eff9476b7bf49e7eb8ad7742758b00e7b85a26f996911bd7cc5341bd3d02b7a57182d87c2f22e5e1c9fba24f67b1dee45bcfe1436318df73c3b5e8d5c77306c42dff22ca496b724d13749868ccf01fd8c0fbd88b4f220d207e67c2ffa1cd0b71cb111bd8cf7d102ce781f22d0876d7087d0b7fc4de85bc09c2336325ef4392c3f03bc59791198635f460b89e54524fb73b290f83449dd8b3caea8bd0fa3db4998d10d1de83f1c159702865771186fc2add611fd0ae23e6da45ff7670ac3f8bbcecfebe7355ffef297bf5e2f4a619dbb38d15ad358e3e6315f5b2101d1b70438b4461a898063fc7de0186718ff2a5be0c1857dd19e6f09da6df01d2e235fbb3c62d7885d231d34287169db569dd8b68d37d6d1d9b0e083c372c79126eebad23182c5e101019a3044804d38339d23878930298e157c28ce26936dda56ab27f3dcc7758a389594942e9b996bb52ad5ab54b2566bb5eb54ba4a9afce42ad548baaa8e8690a1320abfbeccff022e13c40557ecd4a80512d515bb894de4281ca5e7f3930d1031ab0047b9f3c9ede7516b10ef4917061e848007490bd5e3aeb7bbcc640b516eb77f9352cd063318e18b91e3d8fac6711cc78dd2b46975d3ea07e27134053b63c269391648b6eeebcc04b94edb368eab756686eb487cbbd5753536375cf0388ee338862c47ecfc9186a156ad473dd28bd78139317401060f4e393fbe24a723f47ff40f923875dfbdf47b1ffa482ffd20b05bd50097ca94202b021359ebf3beeb041d232684cc9692d075d09282f3465b5f0c2bc060b7baeb5958b1a90ed977a3608f1d845220429060626cb55aad568be588bd92e79c94523ac1be9225537a75b80f0971ccd1684ed115ec775166bb5361a43f2158ff2aa511b3d9b8da09a2d2318262aac39fd020866d596c8918aa7e384cb1f28a55d37a36c36d7626ae5b212e45d899f67db9569487de1c116c8361d858adf2ab42c7cc35a3b3d96c369b699a3785d6fec31a0fd8a8e1ea2971bfe64282b1251afe5326d8fffbb55afbbf6d4e34959479aa092925ca9c5276777f1886f839e5fc98a1c4ec14fa1f9c173af6a52c0c36f528933e4c334720a314639453aeff94b210cf9c734e1114566c253bdf0e7d0abd46aa170c825ed10442dceebdf73ee47954649f293b1db8a78f4347677f3754903ddc260f13366945c85432954c25234919c704e118bf230f1ddcb1752453c9502e336532994ccaa48c521baa101566e6f97acd58c591a639271039ba48008462a76d28dc0588331ab94cd7754d0242ad10002c7c0d52781d417bdaae57932d3a47659acd077c75bb374fdfa82feff55ce7813ccff32a28b4d1d203d555c0652db450e57a2b9452daff9765e877f7d73c48e2ce27acbf46a2b4524d2b694a24a574d229c7719423cb15e5a85d51b21cb1e28f9e102bf68b254b96a2ab821b720c33b934338a5b02bfe24b77d0093b8ee3467f0325d0af51272f0d3e3703db301211ecf793d2eec8d6db4637ca1a1de0824eeeb4bb9bfea6c3f348d20abbc35d94d00ed4d11be86803450f78a0f73c1f40d77b1d1e690711ebbdc82e1bc01d38a858fade83409482a8b7c47a339ebd1e0741c3191b58fa6209071c331dd75f6d14b62389f5fa50e36a4fa5699e4a330c050c0683c16a361b25263caec1cd5c7b7e9cf8548945a9d5ebea0652a954dae488a86cf7ebadf5946cd2d4e329b1f28acf63b52bfef5ba4f88edeaa655971efbc2bd1097a3a105db2abe53f5e2513529b26a7d31b0948617581f47fa7d74efbd8f9707da8040ae46ecd82caa28d2b19b580f7f504f471949f97e19f1d281deca75001af66262d943ee786c93b4ef6feb1cfcc8a5dfa3722c2d4a6538ac97794a29a5da87615d00b022c452f0653e0b71bbd520cf65b48edb36baa2a0495ff30f87bebda2a4ed7a3f60130e2887f7aec97432dcff0c21081d8676fbab8f53a7a0a26f386b27d55af56a4541d106e0a35960c20bb60409cfc85a511e826046ca04a081384cacd8abd65e003f92c1b2700e467abb4e8ef19c458939e7a4829d1e7ee1c4b6cdd9715b2761484ab05c00f017b06d9536cbb65adb9b42a552ad60fec4c8ab88ab87a544a51a8d46230e65a92459a552188e46fc725273c3329834f95879d0b6f9b0ef3912b7c2bef73cac3c2805969910197299896aa70897993c3185eb29573292a61a2961ae699ad63f05abc4271a66e02a8e718d44a43ead907a95d349f002aa75fa315b4a749195ab52aaed4557a9422f690a7244abbff2dbb63dfd2ca001b9f31bec41fbf99ed7a058128d443fdfba4cd7812f3bd8173d0f2bcf028a56de87e86d079244dc8f6ef7deacd665e66b2ba4976949deaf3c0fa067017dd807fd0ae8c3c7ca7bcf27fe74a0afad9034ed7b04a3db81228fcb813e8c6ec3be9df4388ccb4d6e727b52c3c3fb95d0adedf3335bad34a67195f3381157f5ca55bd72550d35e0c06163a55ab9cb086aa55aa95e2a954ae594da50712e0315b8d979641e7329fef21ead824fac8fcbd09722f4a28c22633b5ab7c33457700ea984964e4bc75b5d41d933f668d1df0183892540d6006d8709f4df7b9236f5f03a4792040ad71fe481a27331db62e65968ee45928a846936ff828b2d3c0b6fe9788b894ec78a2988709cb7bcd571a18d128e9f6f8ac7de0aa594524a295da976f480d087422f0ac0d42d8771d7102e9f28a5945a92e85948f657487d0a919eb8fe4e5c06f837164d84437f569f4224543d8942274bb2608e039c70c13aadbc10276f85c4e30709b342e2615f447a11813f802ffd166c70073f853e04f62861502e43b94c119c63fa4801430ade5728740ea6f95e7419cf2079ac7c917d388ee338707379a8846392f40d241cd3e2987602dff07f3510f8868bdd9a7139c61b089b7634bfa783d7921a74d139ba7796b72f826edf986003692101a2eba8648eb87456b2110100000001131500001808060583e190583c2e9c27d51e14000c61804084643c1a09a4410cc350c820638c610600620000000c0c91a8005bc4b75540a5a7c72b1deac50145f8dc4928dd364c074088a269ee6dfe486a1253dfae4a91eb83683c7be2abe30ad51f973c7c268c732e8ff712c14d2b6159b51439e66fbb7210af987b982a00826bcbf7e28eb27efa429df022e047c4271939921063dd42feddf0f2719645a76fc4a962a073a7af70baa8efb54d55a27d93719c641f8c33029f90d5e58d35719c62d7755351f582d2e269d3d628a6a751ed31a34f8240329c070e9648c5802a045db863d9cf40445b0c278df7d0fdf26edd62eb90caf0a8a0a1d69d84882dfb62ffad8faa54d3307de15dd3a4cade71fc11a4c9fe03c21e02fac399b2997cc8a7581f30db8a441934184df0eba87bfd4c734b0a3500e2cabe6d7e2587073cea4c712c021a900e439abe8a36df876321bd5e1dd189f53fdb99d07b13dd5be66c12e3107a6e1fb13d2e9aaaa80a707b64848797408927c17d4278565c732853861a9b5652083c50acb269abb8d77f5325231858e3bc3604e0cc020993c41205628091b626e07eb718fa43c37cb4e2d484f935d82269a29d0c2698a6213032ec325c24380ceeee5160a8f8307a02a297966fc2f63df573a80452eec54da143bfcdeeaee51ec6f06c1c04c9b27c675ce3ce96b1300961209fab8aae6c6968d96a2ef24ed067633fb5349caf52c366b82f5361003c7d5dc4f209b46aec54ceae2bc361ea71d77f6779559c9b30548c205520b84d0c6c00b953d273ccface5a88ff49f5320dc4cf82f7e966b2d97d82ea59e90de3eb2284f69e12fd4aa8b8f3b63a290a242f139a2bb71e7fdaa2dde223820750fbce770f88ce7ffa4963bbdccd1923811cb1a3310872841489428b57cd37e8bca7095840ec583dc08bcfe2a9259390a06bf59c1972f6db1ef75c123888d24db519f82c9223ec9311750ca9039825b68a01cd4888bd54a844d70eb0c32e7366dc4dc32fa794fe4ffcb78259a2e16d2c1397a38ba90c9bf56a2f4060c24048bfb2304d1612f8b233594f77fc494f62a29c14623721828a1e4b5264090272e3efb2145450631bba11192cc5da390cab66c8041590d50a9bb19390378271977000321aa13ec11b9c6b5ef849f56990610c2891094cc57ed207da0b58ff2630cd3030a2343b72fbaf7863d5c02ef0fcce269c574fb398d5f37922212a71037e680942eaeabafaca5f8d22e00672ccf690b3efb177ede1c8e0241ea5f6cce84181921802f9e88ac7db43133771e6ffe87c5078b9880fab08ef7f586d6c305f763c9753bdc537bc200d22a1b3552a06463d1c1ecbc7b1418fef7470020eca9b44e47dd34f56179f4d3979cfc99ae87c3d50a586b4e45b9f38162737f84268c7f031aeef6deac37571ab87ffec269b6622c4b8ebe1bd9bcca9ecfc587f01d74ae4205fa715b832ff7a18ccd52caa79ffe0bf8ba31fa94da79c386099d32273c4b492d095d0dfad08c5dda8ec265996925e12f3dc56165fde30179e24c75ebb34ad4d869ea5e7d04d122e6278686dd34d01192f098e5f11178f25da24ebc534943b0c54da911116a0225c41a7bc2b1ddc80969369c512d042a0983f92fc084a8ba29eeb386d4fb08afa396330a5009b14ab80775aea993744276dcfe0824b6c90a3c105ed2385304f95525c3c7316f5e508b3e4d48265a737cc2b2427e2d809572cf6190871215ddb9b526e68599f27ca8c7e9acf43f30f9180aee798c64a33295cd17b24a643b62ea6ae59d78f71369b67de7a77c0fe88eeba008439a19e32ef7b88b2095c2187ed8a5bba01de81222a89bf6167a78184d1e358988615b41bf88485c56ab78871c2f25a76443eb9efef0bcbaf66041011f07b8b71797d5d82c0d326c4edb90a633f4dae21cfe522bce3b749ae2a19ea31fe08ea8cce9ca9d4c17157ee00b22931e61f68d277b4ef9a623f4cd7ec43c2958fa53a43b50fd4a3fc47bfe7a05a39e5be281b6f58110248ac2606f7c1e7848cb2b5a0e3ed9875d048c9e8e69af173ea71ff6910b7d4dcf9fadbf1661c5db3115cb9cb1aed85079706255abdc40c69d0d2810a2a1ab821f4dc5d2a141f3c4a74ffb7dc1fa3337a8e53db2777235f1bd902d7165f482f30ef08313bc4d8e827f8abf1df92fb57482ad4f85ccb67ff6254990853988f8e34c1ff7c7c2cc1a8553ceb6f714dced694df8c12b789fc51c671a3d56e358cc4ed05c3c08be80b4322d7fbb964c450acd41f24390420649b61876ca9e84b4dae0b44ec88662bcbd6627f1f9cb43fb4406e7a4231e6686635002426c5c5cbdc10157e2e0d03896c2b2a85d91c7ea3a2388270c6de417c82f0296b6ee7ad0a33c5175fe4bcf5c0488d85c42924c9f66caaa4b7cb5c3c486ce6c1e4f736f27c42c10810ea7e52b86ca09826317c1f4e791ffa7f970d753bde5b1d8890e2110aae3e960ae47bb62b05c7dce68304d4478e444d0b0021a16dc5c09e560d108b55f9a83fe4ca4263c25bfd1ba7a8cac88314099149e8b8a3302525ad21e6e171c4857023c0d22425e956613687fb84caf0e1085f04a5dcebd05aa14149bc9000f40ae7d0a979eac196b3ea77cc1e900472d196d9dc10322a43a4b63824b1a73cfcef9544ad41a9f541500cdd601ccdcb55239616fe2cf20805af10064c9a2c103eab785fb5afcaa0288287402fb8881a11ce68d4acd689fc170f0dd4df4605deb214bf82b78db0c5dab8a95077a0c43e074b61820de2d5b9a3d319331124705fb27d4dcb192e0403cc241667f512595d84bd36f1fffa60f0455f9ac022e3402552c38da214794ab8f1f925952569403a2769c7dcc4290de6d76a71702b2d5b8c26662793abadf79337f21efd7293cb1d57f27c43e1643278f7014493a6eadebec9eadca9c8c8337e69fa88b81601253b10fad222b24f717d93155181b51cca11ba3a945fb686b5e81fd95feb5aae1d18036c9d58c781f997df3afd81d4c32b8fd02498cbaaf172d0ee81b76bd4d4e8d6f2edfdabf747de81b5f0a0ee42841b7f50dd2e6ca5f682e69211372f3bd5ed3101ad0c3415cf89f4fa0b43f7049528721df18c30e6bee31e41b7dbd12ab574ed3128f7bf85a1e0603cc1611690fa946e93cd34c0464626e8f1875a506b2264317cb3a1d54fbadbd5b0b2117bb166dacf872c6f910da40765a58474ec680cd3a095990db68c06cce2be4490b31c7c2e5c63a1a61a95f9a026ffed3669fd2ff1cd5b14cd2c97b97c05d12208576bbb3aaab596342dd5653ba3892f73943305d99ed76676ab49765defd56c6444a20d36059d73a3467917a7462baaf8c7f5864bcc84a436553d58061691eb013920b0ff338f4af469f67cd8fc77dc77b15a3cc7abf038185113104ba82059b8b47076ee02b7c3a8a02af80e0917107c765d0a9a602cb280d28b8a1f1e37e678b1d6d1dffd1347b2433322eb500ac5c669a3f595cefd6e21c7fb2cec274ae8e60854636543912d940011857b03cb3c9e40071656d41a7ffa2b2c27ba5e45e73e406acb1722fd0611a45d56117ab5793c0b41d7b8e0cf58a768ba160db3ae9670ad342aac065a4e48b12a8648c3b2b0c52498e3aeff2091cb30f630f9f360f533113f92ddc8d77f4c7184a3950b9960661865dc046af7fd502e451a2c1ef5d02ee69f95a2810789004dd525e386936d41afd48aefc038aad78adb8fd03b3b28580a296c543deb10f79af3a1cb06670df1cd083434d9e1baaa7105aa1b1d3c737064b21ba962fbdea89fbb4af8d4d1ca8045700b6411cda7b616d1b7a5269eea20001de27a1d306c87eeef553e34df3cd071d078ea81ef12f9b34ada1905a9bef9e589e60554abb265bb1315d20c238760207929536f6e2ba2769cba4c786d75f9f3475e1b14ea60bb0ff131d7599c205b8dbfd92acb7325ccc4b069d0563f30ab50c54812c66f0a7b0eb7555c3105677d10c2d6fa795b06c9a2b6e73c23be86dbb3ba01fa702162eaeb905cba71a18041a138899b7efff68b82245aa071c00a3f2af2cf5a4f01fafb2a3b6ae0202394cf177e37d1c739a6998d2d3ec9e60706782ff3ff22d4de1f2133e0b22c6c04eb6085217a07002426f234f7207ca3bb5afcb0cfd66c61c8770aa7ccc0608c53c43e753cb300cbe0d3a1c2319b96fb9c510afea4040e9285c320bab877d9d0af1580c3498e6a16fb58566dbe542cd0fa7d945d8194518520194d2f26278ba18b76b31a4a74088c9c3c35060c85d9007a4707b6ee0bed053c580d2efcf5911213e2300b0b510058f2d040c9ddc2ce13f8e26063b40f862245ad3920a320fa5012ae625435b878fe65e367265e5e35bee89b3f612ba3fa1465a463c141c99e6da0250c96a9c2ff6ea8871bcdb4ae49448a0f033d9ed696bf24981cf9efe568edfda34912c0e3ffa3df8fffda3b699910c4d5c183d98d05bd8129e1f3d1e0fe7fc0d5c813375dcd1b51e0f4f8ef2ce5234a35051cc4c0c93ee922e7645c121ac28e2c7728129633860f383211aeb1c8311f3b9633dc0e506ec87ab243dc6acc4f05ed9f2da9423f54791deb92ee12e698f3857b4b0f7afb5e33307655cee87cf1c5757db9c25cce8c40aa0a45331790844606dc4d40a696465c4bf79c7d10dcab3f7b8425cf62826480cf5e108686b6f85d1f626e12a8107026d1d48d56b2407b22b34d4807efe83e83782bc1468dd24ca44f1aaa2856140929b19a24885d06161de4802df2f01c2f932fe726068cbf3dad0baf78b193bd59c0923acc2590b53ae4f915fc0a22d3657d085139dd3d52c45feb687c9a03392cf530bf92095889bc942763396398baf7a754b0e2539a16db4cc63adcf983900d2f5cf077192ea85ce7c3f94b202f32648055b102a69b500501ba4cf025ba411714cfe7fda756d812543b31f7920efd20968bc0911faa7c23a24ad8ee628eeee220337093e246d31362a87d746bdadba15ea2625f769d93753775056fa3cbdd5bc36b1d4198e8984b67a31d8727720d3f1351916ec303c58efe0a0e0bf235296b3c8fda15d69f8270263d26de3ce55556cb61a3c2829c4241695c6874c0e6700334c567df1a25fd379579364e3d563ce9375ea227f13f027e6332152580f80a6dcdce6bc34e17331ad311e9d76f43a1dd64e1bf8402b6066e5f9bc2ff61cc4e27e1469e01f9c3cba70112ee9a4fbaf73a47445e9913963d3c6846c16d3307af07dfb56d9d416324d3e933bc4644b67a61d4a1e4e9dc3d66a002207672bc3b66b8cdcb0e09af3d3b97ca754019f934b61541cbe73d7c109f3f9535cb97a5f75d5c086fc2b4ea0cbcea4bd2284b609d4a5718201e069000ddcec080ca97f8f7fee1dbd005cc8527250d8a4bc1179ac1d74aac425093c162aff0f22605059b7994783f3232f4dd96c5bb1fb3fd522d2da87bc2a28d94e5ae2ddb2a6c6004f2a51dd7c0c3e79640de48147ef7a0f70c3272916d86e3939c8d83e88328bd11127d56b487089a977093b4e2b676cad27f44dc3f4d28139a4d6d81f5a91342974a1ae1b8634396d64c634708e28e48d39df050ec23d228cdb2d45ba753eae3f81b3282838d9c1ebea26a5d07deaf56f2fdef6d014b4d7621d7c2797c1532378df8d1815ef922536e52b1305979a9a64bd3544a486f45c39afe07a8d4201407dc16d2407cc31b247babe960952c56986ee75c5c1ba142facd46615372e9e88a360f0165fbe01e8ea572300c86cbf3e8fd1499d999163cd8f620e21433a520b80fd80e1557214b7a644f09f897091a362adaba63c5071896bebd27e1c9268f425239540699e6807a2c23136c082aafc4c29502628f4bfdf396e852a62522538c0780d812d3fcff8991528c5ecc10800607df981879205463d8e9e2bcd776c3db3ea0bbfae2b431f324fa3d1636b51e554f219273ece699f8f8088bd9757390e4dcf481fd97414486aecc9ced42c6db6c2d68303366e8d51194e7c443f5a8d62783c4b7b21db259b9b52b777db591cca8e2bab424ef7abea063244517d78ac424b1466e8cabacdae2d665388a6f811e69abd342e1e9c55516ffb7cc5924670db1c26c9932a7316a88a4b515fd8e2ffbc378d2465811f892c80d743e5c6206b1c0c5b6cc23f0bc020d695d64582781fec69c308f352e89d3fc132cf19f0951766d7875d656172dfded480a15532c3c5c741836c39f99ab258fc55774a35042a3dc04b5c1d89fda1f0da289f1296ed453795248dd9542bb27281048bcd6aa8f192f41bb39c9ed3fcfcb65a3c28b4f09ea79940efb07de19203573248c986c7746c95a1574a9eec60078c0f6dbe5a4b7611390671d38d5f3181facbe02a09e7a3f2bf1c276aa60be6d1fba3124c272ca8c67701db7168dfe3f3f5f7faca407b43cfdca7d442b390eb595404e51726c8733da3fe70154f7a671bfa23d03c286b8aba37efb31977c4d3a4d6405463e2b504a896cfd76ba0f754f3e801bfe5a18633422fd50ba93c24302eda7f820584210c54ee037d37db88b24cc733511d1711e5530b02101f3fe70cc297d1f2977103e3cc33f7f50c7b830bfd2e485d5645ef17fa1e98d5dd430a7c3fcab0f546238c6c6003c2c48af161ceab17973e96f58e256782d8deee55172021c039455d71af78f6f4a9b93e73d8e665b94e993710bb710854c20aebdd021e6964d1909a875df30fc3755fa9b61e29443157998c09c1fa8546cf1202d8c01520d3e9a63a1c538de76203d87ad2f673fe4d0ad34d90d04fe7d4ccb14759e339d1e886cbe9c59c05f73c478dc5d6d05d822fd26e9b137b42a97756507811d77b89daebf9b18e7c6bcf0e0f08e1c4152bbe7860af7515db364fc86436f315ec87215318ad64aa9751d0ed9286bb5a9f1ba25b42cfdc8d62a58655d82f200e27269f6a43c8eed9a7483e24ab1c62b45ca509e9cb0b0f84819cd8c7556ed2b8ec83faaac3949d56c3a2a197c9f53970f2c6c37af0272c8839b2017316b4d38ace2151e9f3f47893dee1c6d61c31d24449c1bbe9a5d667f0f70ac9159b9171bf2e221524b470c24ea40bc16341e0fc172b6d3172488ff911e9b5875a0b2626029b8419d76aca1031f60e323054b5eb0e0c350642731f88030ad1faf64a6a4076f1f40e9ced772881da70437f16168fa5c3fe4c36cb3245a04e56b0d195c6b8760308052cf8931f62fe34ff28210bb876abad9210731bcb1e40f6e126a82ef504461f14788de7870662695b53b2b0f75b58e7c20f6ffdc1fe66e78fcbf6390f5c76d10b89b7fff00d43cc1e0ca9167c82522cb7a5e1c3b0b052235d5e96fc6c87f58310fd0873bd2e551b8a5e198cb2a27600f5057b94a474fda69a6dd8f10837b6ba578f561e94f135aa25d0b508a58bf7afd30cfdbdfa5544192f6c7adc0055db1bbc95499e227fd40b1ce63c443fa438ea2b72d7ba454c6f6120de5f48a79049f4a4426c5253981a4e0d382a4a965d3d0fb769ef5a5d6d3d6bdd28577a3499ae518c3f3dcfafb4ae3b2011dfda41d042bdc10b643f1b231d11659e6d8cc8ac395bcd948932e81da32772c416ad932f0db8c4ee1aec87cb988c880a31167c56777e7851648a451d7690089a01ae253995c2511792f4adf9ed67b40e60bc179c7b8f2bd51afc0c80f7631628cd6a126fa6c5d1c66d568db8d32f7f6e39da066f5c62b9c49389d1c9ce6a70c6a41293dafeb7d726cf24bf0d9240b0231d628690802d50238fb5d01a1958150c601a9821fcce1c9aa2593fc3f5ec53ec007c1cf1c7bf2fee13bf71a34e04a4ded34dee000cdcc9f7b51166e4a9a640c97ebd2d4b287525fc226a5e1959851825639227f7948b6e1cf3cdbea9398373f86c8cae16429426c462331cbbef3a338a57375479af28b6078e1aea62909b4dc30fc2bbc50843dec6f7f28942283bce03c0ea1e7992ee34982e713d0c6b11ffd5e5ca23296f27e97ad7714c8fa414dd3bae9c205fab2d077e6349da1e40f620ac725f145565b231df862fc9405c58b2d507a2b699935287b860ec7da0150b3bb93092925c232729ccc1251a0737b6a272b82a21a65cdee1f15974490e8eb826a6a9b57f0940895824659a0fd44fe73be6101b7ca86aa235dd3984a65b72cdb6d801499f1f4e14fbeb22827f4eaaa5327e2af6d472faf5ebd9c9d672d221c251d89fe619951cded6cec9788680e5ea9b617f5e667670adc80ebc230f4bb9b1aa1e26a73fa787c3699b244dffc88053cae09c51622d0954d96ca725a7f1f196d7e7c5af4da93afb134c6336dc4d471fe287701d580986d5e2f9e7ab6413380dba9aaa6b469e4f86bc82affec94353ef1344244873851ef8ff96aa537a6cda05c3f9dc0faadd387c0dfe1c07fc775a0f32dde5c4bdbec0c6e454a172de29f596ca138aa27f77549b24a193707289be392fb54524394f158abfccbf0920ae379963689ef1a3819932ece9c585de74d697bf0b5757cce238c27f5aa7c015500fc27b751339eac4655158f8029a87ee2dd524fb7cf48371d437d7507a664e835ea064c0183bf90ed0d504f11952aeb149d4405f6bb08594b491c4b891adc52251c800a6631b2f458bd3e2fffb06ad5b7ab5739deeaf65f9ca59d8fe8a1d5ce5c62a378036d148ccea23351231951cbb37e52f153997274782f33a1bff0120698706e508348484cd6ade31e378ee644040cf4b1e94a062cd992696a782938ac494395e597356e521cdee2aefe7b2915e2168411d38dd3ac38c72f4aec8651b5faa50c5d0ea5417b75fc5a042a38c5b3306c7ca817f50fadf12602d0cc1b904e747fe73ee15ca4f31d0ab20911ee0fbd66c972844050aadb1ed586fb23b6beeaeb80353f31dbe00c9f654189568ab15beb542b692d4c60d17a8c01b1a4df9440e41abcd118d3c27b627b78192eb976effc09f3f911fd4d55c4e0296fdd250d4dde80ded3991d61704414efc5de9a403852b6c4c42c6f015c8e75a6fdf09bc45070e70d189d42eda5b20aa431a3dd036e894e60523c20091c0696aa367fde0fe6e8011381c49b84a0a050c3c200f997b00248f1ee8dbb7c26d7c0a0928128f3aa103d40d548bb5bddd4b873a1a799e942d4e4d4fe9080804574149f75ec757915984aa798b75522da221fff0e37269123ced35d12b78ca6782db74e630458df7f4942fa7b910ebacb38ab4f45b572cb43322d9305d409c737b6929d0cd6fc84469134c3f432dc1f420e092a2b1e613a948f502a5165f781d7cb447d97c82a9ef0a94e57d827e051ead65655265a167b8eb4ba198fa2372913af11f12b88db454dee48893c4be33b40347ad01a57e2b2345dd483e1871a34e6c57d36af4b4dd15651891bfb71450902334c1fcf33e97c749e07cde87cd8adfe233f02b5ca7cf9746660fce1b5c0f09653979fec34b3bdbb86e56df7663cceb82c65b75bc31233df99d32ab520f4ac9154a587ea42f7fadc824479061fc095476e384c73722962c88c394968af26b1189abf3724bc4bfa296f4245741f68ecb71ec5325171fcaf44cb1fff56ba063234ad465741a2a11e6e5ea1818898bdb7d37517f6f16da61623641a4e26bd1d5588ab6a9c6129d5ca3a4259b943d295427dfa0b9baf551f6a42618c906118511675b49378daedf12abd77de1975a091e6a8ce98a170a3205b749710175d879859b457ec988bd89f2100eed0a9c02e95a0ce7bea68d5a18dc223b08d0fcbdc4eea3438e9cb310f72464992be3f5fd45ec6b3cbcc3a282cb0455f91d6e350169ea9045aae6e0b8c5dc190511845507f105caecd0092e6430c512dcdad69d622a6af8373511dc027a65af7e8f3d3f52f6ed97416f8717938837aad82dc000b797f739bdbfefc1e0c740a49b2e53df5339af86aba1bf116d34094ee24db37a0cb16eb06f6edbd451c7a5122d1688702a56c18352d5ea017838d9e8df9f33d8e51e9c80e7cd84253991de7f31b5990e44c210199b5066ec89b61d12af912333a253f76615b7eb899b29c8df7b591740f7c9162b20038a6342796fe99a66ec397519e602f352dad809548bb3a70403101c069c3cce76b40a202af446ef9145de16e0d33c646e9e36258f9a4ffdde85c3155603e59c6a07296a3b93e0003e552f96a6734f6e42742cf55cc1d425ca2de539ec2c4c9c7e123a77e40791534e0697e3d4482716dbb5963a051ee7e6e381d443ef62e132092387350e3cff79c22e028cd4dbd70b150cceaa2cf7449caa20c679576d15135eb22bed8a36f893c6c1848d96b89fada8850c29640b639fe6368975bfcf863c5d27b59422b181ab0ac18e04c57a1bdb2a98a9653d16f6e651853137c7a1b546088cf06530e1f0e17c0fa75bcb8f2f4ab6c29fc3dd81e5dea0a4492573e6c0a29f8c090ee7cb10eee41c28c7f79dfac954d95b8e7ba9302d7fa57f2698b0a6c496c77b483767e423778200c2fbb5615ea53b751e20daaf9964bd37bc787f61374cc20dd36482840401de24097d9610e2cebc2273eb99c866134a25ad804b24152d751a8596914c2c01c5dd76bd388121d2171205614445f8166625ff79ed11b425bb4f50de399f3fbc3011c78da96439c0a85db5ead0dbc568fad5763c127c3be6b2a8c2f0ca463acb8969fe8480f289acac064b8ce5c024abe6abe476391f258a051486d35ca14ed4988a94ad0285dfb60772d62a2611a811fd30002cc86a296752d1dbb7bb4c6a88cdd9a5c90e99d02d6cbfc97c64dbcba749028e38fa7fc33030f7f6e21ae7e680600cf4b2a765fcc4b740ab6229776e1561eaf196adb281bedc3f8d10efd1df336468af4f04438d94987b88993cbdf7f143143dc6636a7efdcc838e65213a1dd11adaaa4fe2810ea161a1d2cc154c3c5c28d8898a7b8b70344edcb82ba762bc9c8b35cde31d785c59a2122860b117b3078339018d3c176b6f07c8a5b2b41fbda86c63a48f74cafc3d0d99819debd46a724e17656abfb21d20355cd0572a5f85612ec6f2b58486c5ba80811a90b9c69ccc90cd754844a53e49a3f507ccd51bd2d8952de78ca474df3543913422312024012c670e880450cb97a18033a464d5356d57d2f51f2bfcda01e5368d8db7c89916c773d4341f75c51a447d420089b5e6d23bd5eff3f439e7471418c0d8b68deedaded2d4ba2dda0d0c995856196d7766ac0a1473f5cfd9ef411ae7ddffe3fb2e76633c5d17d9eef36a420a236e6ab7159dc573b5156b91d4ac6687978703fe02861ab9b808f7aac5c5bbdb137e334e4a046f370c4ff51088ace0bac5c232a250bdd29ac26e8d7db9fa65f93a12203996726986cd1c0a1458aa42b16e43ac1321a4a31a3964e5e0486aace2bdf936f2bda43402b080b083eb1200b0894a64820c37b312138815e59abd319d121456276f22973290f406c61c489fa920d75dc084cfd5c1aaf7660f238f0329f8132369431b5e48eb67c612a3e336cec069afd52994048045ac69c7065c410d6278171e99e096a04e2bd23213532b970656c5a06b75906b73b52f51c277d5d63e70c7a2e8ecaf58c89ddaeaad68e40855ddf76e04d3f1edbc88e4093d84b3cd0fe67e88b983fe444bbcd88ccef64c2930e1b7aaa5be2cc90122816d0cbf48f0fae630ff71d621fda69d62042e006ad96a3bbd0588a19e65d1c8712ac8b587909209bbf5f009fbcd2e0935628a4e999635aa1deac96b4abf7272905cca58102d8aa9a8f80943d735ac52faf6b816aa35e868306b9d1fa2b56249fd644a23f49c73f10cd6f089bffaa859ebd3a1694b8b21cb5b0ae9f9adc17c23db222d00e04afeb2b980db309fa90700bea810a590d23f809b03eff7d30962bda5fc942057595f79e2879df7eba0df55ca77453e84a7115b1dc9427e9c6dcf20c99dec66e6cc34962dfb81a60498a40b84aa7b3cc04b973cd63b323ed1a16121d826c572db5bf4e7cd8a8dc5748741eda69685280d8c3c416cc87a983181a29a292b201e32f40ac3aa6d035c82543e2955ba01d0f1cd355b3035a18b72bcaa9a3ef6544de4a3729542ab11aa9590ff1d2f1895159cd3d46c008c608b0c940abc6f6492ae342c7e8c19072e896e93516d749b646de09cc355385753472a71310e4e5627d4bcd9455855c3ce353cc0efeefc5f318af3f731d0d26f7dfa9f308f0fa942c003c2fa7217dde59b746926d44e33031d1ecff9574d0b9e7f2e13537b0d167e903fd5dbe050e1da40618e7382a709666bff057b39b5373a96c1d6aff5a10546234cf6eb08289cbe8606cf75eb41eeca09184bbbbe27c334ee08f0401505812346546cb03b08fb6affb5378624228be5211f1904987d4c6376b8191e58634fe8294ae97ac9091dbc67018bbe695492668c02dfc01819d98a25e3b26be8c11891250211e19d80764f69c64d241c49a7f5b5700efb0e0218dbeae2ab0d41c6959ec1f7eddafb5c19221e0e57944a892b6580b8de6eda32c49fae0e944e8d7adf8bd841afa058aa9c69b1a44988ca0aa1f2e2a4804334c581c96274917e99f3098ec0cc8ec29ab4709aac9ea68a7e9a5cace3f1725010ff310979cb3cbfd06e3de92119c9f3831fae082e3879909c50c02c71dfb2e83233e1b6f43c0cadb38f62cee202963846ceaf67fb202cb1e9674b19abb2ee12a57e757bd8707f150350b4a52988de0ff06ecbd83561cac68454511ee69cad9b752aaa851cd63787db35e6ea54122436a4c3564c2058640dafdb67a0202c522dc68d26233e1f0702e8150cf955c7fc1557cc1e90fe3bc52a5750d85ca24f9f83a0576994a75a300aec370eb29877b107c8e656df2e7b990534b0c1292b3c4f5037f08d9a7e265fabb8c0296534b59b1b364f8e6203173d67ac9805d1011661750192f3907cd633db59a5673125d4f7c323590187c9b0e0f043a307e83fb9b22722334912263c16177a9bb3dcdedfed2bcdf53c5d4c32c8522d75f76d74208fac5f80259d1300bb2730c86b93a029db926ea0f0ce83f45347923ba25ff2727ae66971c9c2941ad5dc4025428db6afc1e7b72d7befcc6db16976584a2c66ae1ad676f6245334bf4712074155800dc048cd340c0dfdce0585128d1d53e0fae1d68229c6d70542413b1f4e5a4b9815be942c537ebf901d98158dc970a00ef63e77de541172f7da53678bda02c0aecf2c121a40bb9a91bde2e84442177e397264971689c0240adbdeb4e83aa18eb0b9cf6b3986c8a39865e6949231710c6e720cd05a5d7dcba28e2ed5f934069ee0b70bbdde8c7fce7d2ea26825bd40b5b3a04d3b62c8708898637e613a22e4e351377c95e0851ea25d85b9276850852e80b2c69ace512cd2463493a0eb80b91f2532cbfd3f910c1b2357a468dba2e7dac6414ce295f36b5bce993ea757d450f78950c1040ae921e1838a881fa99ddb27b8de1647364cb323cc77febac0c4d9d400313027c21d205b02820e85a0942e9e4047d65b9597dc26e14b95e3ea1586740e113e218772e28c21cb8042bb68fad17caa1536f8c7f54d816a02ece6e7b0bd09d1c487f32e55d7c200e0d036b473f45ace576a1de4007b639f3fe2d7e8d09e63e6c04a0bb682cb80ca0918b71ff16ae4e94bd4b2aa600975ba444477c55798d321a177506d5861c9617458a73d153b67857c541f84aafe698cced7e09c6600205f03ee14646461c63527d70843c690844eb7178b591122f849cf1a5fec5bc0f07275d5d102a440e5912f2f75b8ac5c11e65328970e9fd410e55cbf4ee0850daa696581b943869be35e431a472951d7c145b5d6df832c61e5f1fb95428764f2f1f1b13582570f19f7f16b1c275a33a04b370ff5e202e7755483fa0db6bc41b142a431a7ce87cd09d41154022c7e36581e3cdcfb81cc9c20aa2f6a6e362c766f4aead5719f2c3fa95ef972bd1fe7a500acce6c360455cc1535692a8d34f030aabd67b52ce855d67e3457b2089e8d12f3468c05403f414f580b41a0e302c1b8894a695b939564858c5c7b7b7425e1f8eab981acd58be6d2094cc98668ceba21168e6b6bc94ff870de594f041490ac3cc09e5fc80c818c95563361e5fc42656ec689cf182e15e4ce3fd8dee70c89afde7c072f5dce544652145e04c2c9f1e31c02299390224b68c4b44c3a1bb5342cb491900d0983b70594c132176b9dcaa69271799715a01ccfd72b9e058d9c991578fa81aa50f541a55db386a327fa6af400548ce9c2fbf495b9ba520b5df6b4fcb5369862a0d4f43464379c3fad7a6802f75782c5bcc9863c5354536f0a4c090951511415cb22d7d20e8152576efd513260582c2a1d8754d61515fd25b0d4e9ed72380b9e2683e62a3a92c5efe570b8995fcc9d620c46f2c1578f3c7bb5ca4805b3fb7984e87ebd06062b5b5a68fa3ab60a0dae27c1b5851e337d0f9e01a1f2d2eee0d74e092ab282bd7ebfe2bdbf0d419a8e61c615fb8a819ec759d4c0d114f17306584c9ef46b16f7761a1f0ad8973714897e3ff8632595af32aa4839d6d7901e103a5f1ea6a5153602d2d416128e927fd978eec93a40d438e5bf6bfd535dd8a13673f5b880a9f5ca5734526a4118b2b53fe96f8779ee452b36d3b98b08cddc18e2ff0fa1366003ea20ad894b4bfc2d6d3c73f7d4ecf32850085c4b6a0d97e17ec7e2fbe12269bb3de3d8c8d0d135de8e9f97a5ba007f91399e1b30457beb9e1ed01d2c9dd9903ca645f022d28b1c29c4c80bf65b404c16531f3ef30cf5297c8cc81e1907bbf29c463fbd4b997fce4a5c21aea9c78e732ec67c3f551734bcd1388ddf7a5a7bb1c10878359805e605fb4fa3bb28aac12ebf267927fa7e776656d325f74ba29da5c2bf3e97413234efabcdb51d309c362bae4cb685612ba04ee50e7e9fac94df9445490117765325d9d9cc2536f9576f79e0b607495e3e5a75285a0adee504b1a78e65edca0862f2852d1fafa4888d098df513802120c26800c93d2d729a0722ac8b1d43bbdc9c61b8b0d61551c6b3ba6d9c76844f1da1399d459cad53f660a5b08f37bd7b5c60f60a85597d7f9bca4a7928ffe83e1faed5b40776eb974403f42477c91c664ab12a5b8625cd0605719f1cc82b9d18a2f100b279901ab9f66eca211f23d9c51155bb0d67bf434fb9a5e52bdb13c148a4b4f5068124bbb1fe18d3efb69612cc1b021d7e7859da69f8af25084406f289bee11e19bce8fcda2beaa94e02b552dc890cbd8068f04d6d759d916c1048bdef77a5fc3f3c1df687a8592b0246f0b476c820d7a01546fe5a2f0fe1d450eb551a492b65eba8840174351856bc4b4b1af8062263f8685cb81ecfcf3adc661ca2f34dc6089d3d173092c634266b9df1a8650e8912545984129363f4db3caebdc130a758209dc38777ad5e759d4039ac2e68a3149b1fedf082deb1b436284a6c557a6ea1b0a3ac7a10206e4d477efeccbfc3004ae888dc3eaff9ee62b8248c68e66b66701c0da40151b2c41fb02b3a19dd0c40b30199bb13db63e566fd6af3e3812f469ed23341e3c0972cc6e1ac0868ce0043cee79f89922b14d4b9d40a7b4c5ce184f5850d4a91de0e6b0497598062604245d60b27a37a27eb37faf6e801a04e89b12b080f74925705cc9107f29085bae3a8c5d368ac4e1a76bffd6169eb1f314100acfc4923303f72a1425e9643ffba82c3da63b90ed822eb405711f21ae1915f8816051ea837bd335bc10c6a3aee24e0fa4c1323cbfee3062e1b00516f60e50ea2758f725fef3a27ad16fbf95d7958cdc20b5e81a44aec8935f4d17116ab8f59a24c74a55746075848b991017651d3d1a6b9e6185e591c0bc206856988f2f522d132cf7428c2b45b678aaa38ca5d2e99a80303b95381b8d51450ee7d40c4f18cf6428a07aebaf22533ff86f8c43c192df3e659320c71826e4060e945c449d008113db777a856e9c89050adc8a96765a74fb13ff8853936d1d60d98d764d2d07c0dab6f795719c8283d048424295effe0711e12214489a970351b55644541beffaefc7da8c1a86fdde7deb735ca5fe3123ee03034be9bccd4ff3df460a9e8f31be0dfb49116a5c3dde10d9c955479994d3fbbdf7051aa94da6ab5c7391dcfd2903cdb350e40a2bde5710bf582eeef32128e3dbedd2b20204bccfdf0b57754169b31d72825dcfe0493f17206e6b06103c3091bcf693e0868183eb34f80f00763e06f04e2e60abf92f5f8103e288ab431266ec594e0d80c68dba450c6ecbdf7a0a84d4dcbb9bc5b21866364e0cbb6426993cfe5dc03a5e61a6d62805d8c2d8cc44f04b4e07fe2b97f0f608bf43d47b1678e0ba9f5095e5340d492a795a0d9de9c398a79a9caf105763ad6f0c56d492989fa088729fc1d62b2a31070f3a3e7c7926761884194ef95076370ec4ed8bb2abe0fffd4d1e8fdc7bbff8a912e552d42e44e91bc82fdf8878098f5eaf1bdd0d8e3f4684e13a778d0c5fc33ed7f048ca2f9a82e9460767949f6c0ee7fef146590ecc664b28e28c21e309a0b004974d44447fd1ff477ed9403e08f27864e4d354aafe3bd8152a89610276fb71342a507220493e94da9266d2e0ee186e0a492695111dd17793594b90709daecf592826fa480300293785fab87ad630c430163dd2871eeb1ca218d6d84d52d58e8ddd4a6d510444b90db32b562d4a5e76a84c281630cd80a3c41468757100ddde4d28bbcf1282038984171203c268c697741218ba0bcabdcd5f82fd377a1eac1e09f9524ff0d72a8d43e5265767cb79ee7b25946abde2ce090bd38f907ab823cbb3ae3255e9c1bd27c8f4173cfcd6ce1136e908828d1199cd6553dcbaa45cdbbddfae2ae13270a5e15b11dcfd28c9f040b76e1d189879138b807a116b00abbd1850f56db94a9b5cdfa1c294ac24811992e510c463a31d8dba010494d8b77700b186677e94fae402bb9f69ce396320c1412f65641314b73280580872468d9671b0c546ddb8b585ff76210e0e028a98132a098d1127b4bfd7b3488a129bf3111144fe1ad63e085f9e63c6b6022b35a557a34cbe8f8d82c58d6f015ad29d46d4eb607fcb4bc102e3cc726d153d3c0657d4171dfc39f3ad31962629769fb432aa010e43a5c30b4e71c0d8ba124355c5b2a111280037569a63eac424322c432758f7a007f0962720ecf5915ccfe1c01eaeaa75969ec2fe588e808da49ce8135f7d4c51d58ccf37a9b8538576afe6218bc020731ffbbbfd76160d546f570d58bb2a9131090dd2c31967d66a471c1ff64f939e38dc7b4df8150bf4be18b58721ad96a177f577c3b5eae7a398e30dc8297b476aca74ca8234b076a5afdf339381200b8279e92e98bdb4cf4c0aa48af634ed738210497e6d000eb99cbf1ae704071a6c431c9abc8997c23749070d53fe4fd53838acb06aaaa79aa46af9c564305718235a758add978bc65d315bc0d01e5a2511b4bb03c3715973a4666b9cea3cd9b783e86ac224443eb948c2baec8c99d18300410cc1713b92202ca86f88a2f877128a81abd3b08057c7c25ea57f2a1f8d9bb974ac05c7ab0aa100df66600ffbd3330ce099be1dcc11f846ba69ec08b0c96b6649ad5fd96e11634260ddfccbffc49665abc458943444d0b339c4c445e16e114a3b6ac5c498107ffca4cf541b30c684729c16adaa0dc2460b8aea248bf7e19843503b9fec3bf7f1c6284944f6fc63016e6890f07fe630427eb0cb471f191e238a43f194941738a0d19930e8da9a553d3c681673a832e013911cf85407f0c8dea55c91b47c01179f94cafa55f19480ca240c7b5b1f372b6e405bae9495d32e36b698dc2ecc60353d114f89ccf724414c2d28fe8cc36308a5e6d4116da7f59aed50d38ba103fad4bbdd6f183ebef044732439fe0963305ea5485022c199eb4241ebc6f89dfce44bcae8f927d67ee80467dd20e4ce5955bd51f62dddcb617d399c43ce46621f6e5dd0a94c8c1ad655b532a43bd8cfbfb783eeba32618e662ab00c0b80952688a45423558401a1bf07c8f67ccba199db609c3c1d31db6879fb919e477ed6e940020665062a84ccada77f96af76587e404ef4bf562ffeafc45a14dc8b18a4129dbdde07655c940c27cdbfac313d04e80b032574a434c66bf19f9017e715220ee28f478f748c72190e61638fd5e763b5fef74318115a0d85c9264f6708e002a50fb158144a4cfc23658848771d8fcebc522942405345dfe00f9b6e8c19f387b13470d6ee6907606300300008382d4686ef3de62517c93837f2f60fa9347d211f5b166fe4d7e531c05c57210b88b29e56c1405cd6c9b153e3f1bb5c5703329037b2b254be23223e68746dab50bc1f25ea87020f2d95c818f21b63f386f41c0fb0dd8254155b81dee18cad39426ca90e4a535cb9e76a27a089b2c3ae6cf104e69ab3a99e937f4ae18940efae603b8817676e4d600c46d4e427dccbfc714dd5589f65b645eb9ff71c70f9c0374304ab21d76e386d628081d98f0b3ba608ede102340af0e9b9ef8226a8a72730635b0921a25b3a0578a813cd9db37dfae130e929edbd48b44d6453c29f2bea4c53dc358e8ec9a1fab04808ac103f8cb8fd59aa9992f8c241449b5efd1852f7bf1c9eaa003074815f9bba43fbef249973c30fcd29e5d0de69a4f6b6ec6cc12950ebc85d7ace1d0ce29d7095a3ca01db64cf02123814f82fc5bcd5dec1eb06582886a34249bfca144872ce269aaf50ea4b7e71ece906d7ebafa2a2bf81646f4b66a203e1c8b44f7dc48f2b90f5e7f728b3ae5fb89b6b4bfe90c0d3fac21ce81545abfc3f0d7bbe37e209b71310c9f53bbf4236ca4acc586a8a70341397f12344cc97bcd25f6c3ceee685eb9a35c0fad93837ca52af8ea92d03221df9eed6ef563b23941f87a4fcdca2dbba87a8c2b9cbd05a106cbbca20e16f93d3c26415e84d970bc54ffe830c866ab4549a12c23ff84645817219f91fdc101048256ece05958c0ef86eb38eca2b55a28e397904a0f8e0b9f94d39d49c689367610fed215e50d17a051fc26f14b07743aba98a218a1434f2ef82cbc168d72bd658550cb8c2acd8f3fb02ef70a9367ab085d91a51e8e5c4f2424ab56f0f25382d4c11903956da35da763f89e4da7bf91a9cdfc7a54ba3cda529b7c04ad2bd23410288075ef88b13a9cc07e5c8ff4cdd79d476666c049753515aea4c54fbd2bbf28020b6935e6b3b93a106d310cf407818ef8aa6b31df4d6d190dc20094924513cf488e1610899310ae60cf9946737833a074822250cde9288cbacaba54b3e124c00da42ec163955197ddb58e9375c0907220c93d4113ee729e8d98f6a34ef8c6713609972666b4f84e10c7f575742e1f6f8d641d99524446eba86e9b3e9ccc180ff0ec3cb40c8f2d8ef8e520e180c289d3c4ef298d6f86e257cfecadd1e4638fd72f611339af20bcc7b98b2d71b55a6c2c468412487946907f476278c10500512a6bd8386e0ef261d9b9d3f4010487bc45823b1f36ea63f71a06bb1a772f14a09d9b8c40d250b6b8ebe87d0c7292b8890da226011b96addfd8a75a04621a851d368a0a1879e22436408d11e66e984338db2662e48130ed18ab9670d824c80b189bbb74fe25b90258a03ac816cd00a59566ed2e7149ddd341bed866deb076fa4d0ddc32c0952815a633eada34deda23925d3949eefd2c296d2b2b801d502933445214d79399fc2df95b7d6a311add180500d0eb98a965cdad919edcfb2b456c832560370607c0ea605330a6a25c63a700760279cc1f650df6bc8b7f85776dc6ecdce55b4bc62eeca940663ec638412300d0fea94ca33064cb8f4e022a5fc8ff9b1a71f15227ebfd770a511be21f2aed815b9d27814f88f35cd51a197ee29273714c2ac5ad8f75a898bb44cd8571aab8f69cb2af4db6676db7b2f530e362b1c3bd0fb67caa48cf5df5607e56f78083e7137aa97bd7da13e3824bd3c5e292c81d26f7d1078a29935e05f7503659aa56271c5262391d6c8e2a08fff86c22f6bab3f3c1efebbfe42cebd00433f555e517ed822fdbd34de4240b79b5c2dff9aac290c3857463180f21591ac197e218244125fde54dfe404420bae25f8d781e28c9ea74a8c2f746d428ceb70243577eb03f8321ff9abd41e8e6e7a8ba6b4a3bdee9168d2ccfa499303d53df271a15245f58e0ba28b94377ad046138e287479d9ff58721587043af7c89b03210cc1e8249f3dc5f45cec07861b08d7f8ae5bc094b0a52c2dff86cb1bcce9644477114ee9b257e4446ec63de1b488b155a8bd9955425f6be3699c5d2be7ee10a4ad426d2a693d7e0ffc0e38d2623cab55f28f05c5557c1da59896b38c07f89f141a4336c304cee5c289e9a05581b0ef813fa1cab7026978b74413d261b75f6114aa1d5124e8cea8cc4dacf091128675bad07d6f2b6b55ba182d57cb5eaecec5a39c6479873e0e37587fccb6d07bb0544437e2aa8f2e89a548e87d3329626438df0f8f8becba8e0c41f45a1e4fb5a5444eadab86d8156b6319654cd1feebb1289a09664828afeb4adf9a5839d01c85a238ee5be9a24569d7146f5c5a9678908c3c4941c72b6666e42a3e6f4db434198645b9686ecafe52a100316169ef4fed55e036ccdc099afcf298d73bea505df608abc60225504566aae2b83d2a221de7657579748efccb0a7c70ba4a6d0837cab4d58e46f9a48a07756b53a1a5ea0f7635516b907bb64881c5731e8fff60097fe4335b275e56df9d80d97a7739606a23efe4fa7fb2dcde63ea992acb3491851c1f94bcb67a42ef5f7844d293388b315223cf205409cb9680103af2b223dcded5b2fadbd0d339c75bf63b19042aa77869f1ce4d54932f4e9b7a864a1ad8fe889077cc0c885ab105d6b4ea87eadc70793f21aea5e5418915951d3e7f59783e9a48007b1dd3ef033c6140a6b41ec4c64f715c6343507d05b88110e024350867ce3f6ed080e90e6d7f9a480556a5a70c5d17ae4ffef9011f769c763cb0941087965d3ce4b4cecfa81dc37f6359e4dd370bbebdb1cc895dd53a3b36fec10320f4b16bb39f2204210ab0ed1d5fc01cd489023914de7aca27c8891dd700cf07bd28c9278511f3fc2b9da833aef11cfc46f4b3cfa147b2977b99930c98f359eab14c71b750b8efeef8265c868c0d15d5175e1f77dd22ec47efb08c44930ce860d12497ea7b9ee5b6354be91e6d0cd85ac4110cf0d84e60855c5cf5c3a60bf42c1034209c8508d516a49e360014f62be407adb5165fe7e6d215f9a21ca0f1957a92d3bf40bc6687b37e8b90347d3e854fc3d06146acc42bc6e512bbcc7b90fa3fb627d5e5a70a3048dad8ac721f5f3e11112cbdcee5c1afd6d1a31d0a81c91ac1d6a50eeefb966737e3ba4728275dd0a300573c37a22470f859ff5db3a31ba6fdf2e5522b143ed2283e5e8d29ae429c6b6b81b843118e67509bdb87739b1527c63491df3cd2916c69c5f7e09c7a7e6cca493eea08c77144706ab7e5f3e1aa8525d3cbcf2ee1111ceef895f16818b06901c588cb4f71680c411c0a6e7a811ee6e71b0f5096304e6b2469cb131c4ab174fbfdb82d0d9755612428bdb0f78f85fb7dc4565580a61ab107fd4cc0b9ac381a859a8dac21d182c00efc11d842834289f2c3f487b761447d55fc6732427612a66dcfc6af7321812de5277a3c681f7200016c0574a107f1c133dd68d1ce966ca0a5d99fe1ea1a77e61b0aecccfa1273a46036a1563639926abd89d323eac27de61ce714c9b840849937535767dbc79925dece58c574bf4244707e91aa2fb9f26c01bad21602bdc064682a30e3f5e5a48c978d2c0faccef90cb904fd1e7ff7b13b67adcd221e6fa6ba7aa63d05190598dcc8e0a1b60cf58ba335aeda1d983b6ebedf045d4e77d11c2270ebb158c2655ef7fce3cc45f39c0a83f3d0e4104d0c88b71cc45dc235aabfcc9cfa71c115a9161fa08a8f946c2d205c023740cf063e0041d98a91684f080c5fdb00cf4defd83cf92a813f93ea01e1e91e33d8fc60769c8274b254dca39fbc8c2f2aaea89d0225eecad34d1886bde1d9066959e853474a71ac6fbb44714026c3b5af802c9b977aeb83338d5479c9d7ec01c86bd357d04c80e4eeed0564ede4b2444a99d9121b8a823934c270906b48ba2d1b35e0057ec2608338c70db90b3c77e5548a002d88fca8b68d07136a647de9d2b94a0dd8f2323c60ff2185237ba07efd8d49b4bd809bcd0b22a864ab8a279cef7cbdb22e0ecacd8cddeb6fc8fe24d94f2788d91eae144874a53abca9e1c019351654663f5ecf40e1b256d13a3012fff19af4c119a5d0a3d256c87e05dff323f3d89af38b8b6975abc69d3a5cfd70a78bda5488d353a97bb20805262c3884eec00c098c9472a9c17661c273e05d409c1d7dd569a25d0f8e85859751609e6805a8079169517dbb8cf82671034c8ccdaf73f8107d191a524d23bf0853acc1ebc400305425371bddbc230e35675770b0c5c27e0d59e294db4032b0fac21c83bb971c4a57242b40c14d088f9b0b3f6fd422a951da18b66a38752273df0419a74579e1d18a82bb8d21628ae1dfc1744deef83163062281099fba4840177acb4f68e4bc97c249f4a98c1e778eb63309528785e6ab1bbf9f48f1f155b0fa44a76e764e2b678c4e3282e9d386ee6d5e844981fc0d068ce827e092c66d7016f28260cae6966b6f343a2721489a3113fc9cb5a7b18044a2b3c883c4a076c01cdc6853036d4eec04ad9737bd327a350df1fbda99a86da8c321057903c15f54c82eb040daf29d310666013fc8c473b3242f8643d1fea179e1a3539d4bbbeec7579da5f2d0b4a0057639d682b1cfb7fca089c02b9ff52a68242802b71292926a7c2206572a1903acb4f705704de9f6be532ceac4a4b30014691d0a94c12096d7d4659a86061fb91228c073ea4b0ac2364351573000dd3ae49964dbbd915341d3c548430916af268b05883b15a0cc851bb7e755a0325a0b12fbe7b2c725484e50ee3087ff80c2ab5730b91b5e5e2bea2d2823a40a68745e75d0810cc1a5e9bb5b35c1c13af83ed9a1dd43984659e4acb80bac93f55b2efd6721635a0b3713048288f2a61c5082af585a61c621046c37133df6877d84e79f9d1fac2490de14c798440701c6d41a00ea2996e1288467cf08a7825e88ae82358fe05293ae71f91ab4ec498c3a157c01910a31cc017e27af57f926f1b4a11273342924f7a0d08a48b707560adb1ce9ae81fe0cbca97900b771bb5619a88b133157fb585ebcf264f26e0246a29126c18cb7692456abdfb48c1a102aa54ebfd5ba3ad107faac1bbe07c8ac8c4fd217e29bf142ae7d386cb0ab4e560a9db9bbc25effbcbfb8f35df51ab5e76fb81790176a6b84331800015895b09e8d8caaf5a2fcdfc518a2bf8a31ab50ca30fd6a28ab11f96ffd8a1be471c34613e29ec673cbe802e17373373d5b069f4d8a8531066ce2687f0c32e0056c1c5fdebdf3d163b32da327c74d45f97d1cb31e73596d0f18a3a0622914df5d2716788b3831cdc3bc4459bb9943150ef090bfdd1742ac89b472388cf746ce7c6e6115e31964d4d22849c1e50edc4c42fe91cc4d7f2ef3f0f66898183514e2b07b72b73ef9a63313466878209f0b51901ed12442924d60512bd10562b500965b18e8487c73564df6a393e1ee64099c13b880d3004e31cd1d3bf0043a9d2bc52f6875d7bb22efb00e01bd10256817ee8c7d02935cdfb4925868c2e556ff0a0252c6f80b41e3ae221a845b2e0d07188a6b1f22f533a02f2f13bf2fb06b317577764c40f057808b3138e21f7b430cb79f800f16f899372296268643d6c8aa884beef196ac118b2355181c687341856628a9fbda1222b327c99420912bf62b838599195d1763c1f7be40aec21581be1a12b2d7e267811a8dc4e0cc3242973a15308c24732306a05da8320926255fec276050ae29782f8eb2aa510f1d55d30682edef929e6ccb5d0342f4411187407021b5b11b61a4922ef93e94ad1abda2fe548c4a81b79c3ff4dca1db0984345ee5a064d070d09c51b7a89a423e97e198c75d99d0363112df24cc35c051bd577e3e6f1c4dd0b8d66a5ced9ab0648c8dc6ee700d445c3c3e5f0368168ffcb0a13e21202bfd678a94891c7be25fbc7f8b9645fe645c8e2de4060a0e496f2e1627673064fcef19ce19e313c1fb3384740fe77dd6155804e46fac78b905d906ea28b7771ddfe2cfaba204eb48d65c1c33e2c93830940ae44e5abf50e0c50e67c7b6500dc981f7831cc7d421a9cad4119787c1bee501df5b3e419006a21ab5cfaec44c6b28bf082ac31865784d732ad407974a6b9cb3fc788702400bb233c8250dd636e4cfa559e73dfdff531f7d151aba75b13c93d007702759d4a0d5c7053d3c1f84a46dfeab5f1782e766fcf738eaeb2bce8edee1a08431aa0a2c5743ed412a0d68208398d503d0104080c86bc3cb4901448a1224f9d4a57e49cc5b06a2357ca97f13fc3067a72dbb559af7f347983854a28597e0640619c0faefe4e306aca40c6c836b92aa3935154a7d2387994c9eb371374eaa0f64c651ca76eed4d2683286ec2a6c648e9e4b1f69aa91fac2c083824a1381c583f369b8069c1df44e799f0ea0af8fafadcc2c0804db33a7fcb5e324d55f4271a63d70ba7ad9ddbc59e440316f1ea85ec74e62d1d5a9200d965145f1480d93791ab88bdc71cffb508d587e6636dbd7c447f5416f087196abf41e65823eb988cb9341a9c84549ce4856d4d35545fb1936c8003f2a637751f408daef9dca9bc63121197e57c1133520e770a5c19795d9019c9668a1546f7a318b4ce74a0c49e0f6363ea597e60c77db1c54e20c758c58ca1e30c27a22e4304be0207c5d18d246253521d122c008222248bdae69217f5bed647a6b6df7b43ed3740c8f2cb7d8239e0b0f2fd82253956b92ef29f123b034040c8c841b013f1cd23f3bb0b2e595d5862b560d52fc24342b656393e7fd5ec1220d0b97ace46011d61c31b2cbdc87626858552362dead4bb43feef46d346d8133c72f9f09786356bef5354ae1d1720be9e0e382cccb9215f514d52783d63749d5bcaf56d9287cd287230339627380ea20a0850b5cdc3c4cb413dbfb493f34c827670404e281f5d34b80e1cc129f2e0c99c6f3bcd475a38c10e261d22460f6c68e59c50c328ebc3e069d1bc1860c69d3bc3f7682eae08874ce7f8a7022e130158eb8488c5af85590e35a53dd5fdf54d716e3e7713a331151b25386de025b0eba5362f4b8297d66ad5e6f152e9808c7e921145ec445cc0712379bc324936161c6f5cc4cd0c353c12683aa6a424a502f3d78c42cad6a5f4b7db57d0c364e32b3e8d8cad4d01c6472a33f002257cfd7585af45a41084f932c2dfe8acb5b8822b79861729ee055ba89b96fb025d7a6de8bd9e6297dd89fd206e4fcc209c29ea187d8e496333d2789a8a6dc5e20ad045363805188fd2d43aaaf9aa99d066429916e81e1227977e065a6ae7f3b85ca5069a59dba92d96ab00fd17203a110f5b9892251fa731b8a8494c2818734315e364e8366f66f69170672ed93283a445207fc617244e11ce338ebd22d5d7bbc5b4138e2b9075055f91b5a28741a71c22d857e07865504197f63c5c58d9b4556aa6b742fd0109fef09250c4c4cbd037a2cf9a96dd8f731ac821c863a5130bf5e0f86f498f5d22554bf1552200f753ec72111150b412f80e2f55aacb764a9234525c2410545c445efff46ce2f2fba6d58c3fec874e694563b8350820d4af9fbbe6ba6d14c983b3b6716b8f26cf73457fc576ed54206e8eba3ba6b25b9cecf347d9a06edd2a3dae8ce97035fc246050206568ec815dede61d503cff6e9b7753604cc70bcf80404082eaed037f629d3fbbec371e7a5a077ca0d9b50c9d38ba11bb4ae6f28032af931d3e183e4421c39c91acf01a99d6236755b914b8655d29fb86c0e543569ffa995eefe52d2342bd951147cb1a4bcb4cd4d69d9d080aa7bd07b57e15a0e0ffd8f96dddb49381bd0ed88defc964af041207569e67777a449d6934dbbd359bbc45a4b8d218a8e9e6729fcb26169f74204145ab9e2e67f9ac7569aa9e70471d0c367925e9932c564828a2ea5c91f7aab2415285edd2d224671d34e54961a5b1200a25754824a3fb596b699cf108b538040bf2f00d43e8e158f36ce6a77079cf78978d94735332300a5c663e441ca07c7415f7582d52cc565fe08186c0939a0a53e596b62a424cc454683919280a218f8e21d8fca2e0a0b609bb035413167006be16a1cb9eae2f76893444efe8fa26e0bde54e54cf682a6f91a0d2faf7c4f31d9567972467452d2524982c6706b242d35989285902e7503c14fabe5aa442fef51a200eb495490e6a397dbfc4d594ab7fae388774a3a775a3da383e650521fb5936b40b0beb12c1b87bc088328785b80981f3510da3114697643df3d280fb6608b84ef69a7a5904d489334ef150a74ceae6ee6d704ee2e9baa7f4281fcb16f4bf315774f49ebca369678186912d871e9cd21f8dcf28eed11284eec6be42140e551dd3ec59e9344758468dde9e9ad00caef1f03e4827aec27e46586a51de2d26fc2e17c470ea67463130669f0c6d34224acc32458e2747edb44ed167f33fc2984ae8d0e75019673cce3130e6d4f549055ae941a0c6c464519221f73c728bf376bf0ee4e680da75e910f0f618b0a3c599f425f67acf2c31f6fdb95b38206ff8eab309ef755f3c2c31965131f290fa771851352125e7a795c08159c6dce4894d046aa1b6a2af7c19d8e8431c5ebf29997fcc22b7841d2039e5ea8c01195103574b2800ea16fd15388780eb1bfb2bb052062be6adf61884f043f871f9179681b40f2edfb9ae04d4f09fc1df56daf2a5c651f6c1655666822177b1f6c27b3a2bc5d5bb46476eac65e2be24e6095e162c138b6d46112c54c97c18cddd5069b836aadd18c1112eafc6ba8a044e07fec0b57f67cdcdd9cfa478890ddf61ac7b04c5abb47bb8525cdac4776185a100e74d6e95b92c1e8872adb07a329c9a7442f5ce4895dd1cfede15d6898a54b063d8d87274fe88b3149274b56f75f5f6bf5a6ca9999611bfb2e114742f96c52600b11a4a4491b09f046f5dd3a3e546f39d177f561aa35d884e49af9c0e2edf900849213edba22e252d5767ce0404f8bcc4f6c8d974214efd982463a94e769bc95ca00bdc88a5f62f5257e62f2f5f9f5d2faf8af85073b11a176cadae0c413e57cfdd23803405502679c8ce929c3fa88cdc3e0db896d470480b1cb1b4b47be284049fb79e04ed2d7396e927fd383716a55d6a9a1443fad25ae320a87ae51c06ff44a683636ef354d841ce451b79e8b5e896684c22ac6e54bbe6f73a01c8613cc80d52437bace8c0ff8b7576550ad2043223bf59fa7a000983d56c3a9eaa428b73e498832606a1cb8f3f7fc3825548527004fa224cd934c06a8d82ab3809418f8adaa2892395419acd0338386b6d1f99754625ce03630924dc74575cb37ea3b4151951fa9b6c1d3ae4bf689489fed48e86078b3827d37421ae1d146c4e9569bb0274419b72661c39b43376b9814ca79f2fa7b28ed9e04a3d498529413af3b51373c16d0ce9450d6b74137e12043045b530713d5106fabc45b8767b30c11ec4c51aa224aa6baaebd9950afe32c82ea597765fc020b567f681c7247275e748ef440dcc1c3463105d35b2ff94c83e1a73d2ce7d1fa0246bd20bbe58a97835d2830278bb9406767c80d8db5d849a0fa73d95e06636009b583e7a712e7627a64cfe5866efe2176890413af4637fa870f6340b501b0393a8c5e4a71c4e71f22a594f6eff9c74f26393e865cde5313fcb432bc99f000f1c1bc69b32aaa99c3fe0f1113f83ecd5a65915bc41db9799eb6b1b03d0fad3c6be77919ab232e9b6947d02ca6e3350f57b46f4d0068c0e319de44b7823b5cafc24385408f55a95057109fe411d2d77421af97c490198168677da6e59d8c469ec699bf93040b851a50d8f57923a2b36b25c5024b84f7225fd6a9c4c76f389dca07c64fc1987d8ced0694e106d58ebe39a001e471f1552b831b5f050da9dc19fb44171265e8f0e1696166579104b09bbd4ae41efde8ce8cf49f4f0a987f9120962c6123d25008387c6383b252b2d89435dc002017675f5efc51b486213c6608dc104da9ba66fb31cc044229fe9ac5b3db9efd0de219e511893b408d3798bb57215137641565d5ffd5095841b7a3ba6c4502fcea53910159284c2ff910612f2fdd2802d1441b242a0fab9d74a3fce6137ba649677933de48ab67d9ac2ccd62a31844db8db2016fe6753f2708e37237d8a9beb85c71e2d981327c33823a8d4207df0b0121a4c38badcc72f8f650ad8a3f1c964d61410a553c7fd5350e43063a438adfff5fc929b5e6e1d0215fb11cda94fd962a69645bfb0397f2dfd9c1a2267a56cf6c14234184b7365e5b880c9ee6fbd5f5e300502344afef7ff8add0203ca4c7e021f0901f5b79f2c99745496a16dffaf962d4bfe02aa3b4fbde7af311ada018384652168fea2579738ba3daec9a2a614fc1bc6bf633c5e4b5e9c4c29437885f927690cc55887aff87bfb58dfbe18f087a0d0789d4a454be9c37e733f6a39b1a14ddf0acc8c2d4c1db96b3a42511a01b3ab80dc2c50265493cbeab9534c8fd878902b7846b72cfb4434a63b67bc3ceba0ff42bb8c552572a560c04e9c8b76cbda952e23031faa0c39db5b158833d958451a9a6e320729f0b40c69dac259afac3ecfc852d05dc22c71425d543951a6f592337fa9c4d51b0306ecda6d23c7a6086fb5d96564dc0f717cac82b7679fda27bedb4d79c118f66cf64873e374023a55e29389186a0e1b8f64e5baa7f0894646129fe468ea9e0b39ca15be2343988e5a85344edd1fab58be7d8add79eb726a5d0544c836029d6374dbc85f93636cdd0fe783485e42d708c13344d208a9eb57a0a2bf368f9f1978efb3fd57501e5818debc2d3281d176a029379b0ef90b29adeeda8249654530ab16f489d43a6f8b04fca74d48d42d44752e2206c64e5185b3f8ef31667ab347b0f4908c8e963fe49d5cb246904ec6bdd574d016e0034701acc1c75c86c1c0435b9306473cf8a413794fb46840fa559adf12dcd7c3e09f86b7b17c912afeb705c395eddf457d125bc23d745674d3b7be5ba4ce3b9464b93095ca11bdc6a65e3e3470f2c834caf76ebb588c3fc654af43cfde26a0e0ff79626de3cd93f5f8f3ba5fc462c6a9928914ab0f2ba7ccd50d14d4e567e2e9b4e1e50f60c8151d11f962ec175609bab069b70f93b158618d416064138b4eae630bade7ca82bbbff0f54180b654ccde3528a950eb43bcd0cd30d5bc488fd5123ddb8b5dec0f395d73e67ea618a501f0a3d9a31d04332b92e9af355373c1913dd5a98013cf8f2637beff06462c9c5ccbec42e3237bdd7347374d9b3b16940be20ff8ca6119368087edb207bdcd6b00cd245d9447f9e92e19548e9fcf72ea2a8a6e1ecfce44af6864a9758b5eccae389e33e742f235ca10007ac79942f4cfd1e200320af1c6c6938516268d3823bb20f53b8a0282c6ef2d9a5dc3f0c9926685c3ec93d6a488a6de61b2b57271f7b05a997c20a87b080fdd8c8980c4e600c37845a4db55de43b023e646074816fb68e431660bdb72db70c661cee0888a9db65fe98b8a1d574b7950b5e9e51b24146007a2afb9a1a7c8352a10edd1fed170c93753848c0f70e708c21b552fbd9255ce646b2ea69e1fed9110a015633d987ca8fb6b99fec50402a5dc40d8a349a4800272867b9ae501fe9a94fcec2e7e86a209210d9bc2aab338720f9e28612ba1ecddd5cefb91c7dd5902f24937365028a879e11c17a227b2b38cbc6d2f79794ad52eab5d1a98ef13aaa3e22eab5db0c753e1ed856349e3a07ce6389722be9fb40077ecae38bc3b619617e61450d276646e5879c70c1d9ee90206960e470fe5da9fe925e8adb5672f3a7526665807f031d960c749d6cbc73a0ee040252e87ffaf36703e1bd29e1d540a824631f2418e7ffc8f7dd35c9327d0fe1373d08755ba1f290771fb65ea28bfa1d1ce24551743ea2f5f9e4f2aae934d870afae0dd1273bef0c2d6e85de10d9b59b601d7e3d0b1933de33ae204da73b335c366dc9b5188eeb059f7a5c6eb2228d41903c0859b0ead3d901868274fa4068e3c813d00033741ea73c915dc548822d584e368c0afb9c8fff7d4650ae2c2051dc60ee3eacb4e37afa2d870529cadb159d725835f05dcd2e56e16c2a14855a8ab285d8cc94af527e35605952cb29ed045ce53ce96d3012d2b87cb5dc9c5940688b2ca999417e43f13d350ccf33f13a8c24599a177032b13fb0a9828bef842959b645bb4be9843ce7bacfd24360f686807e329afd84902dcc15c93da620e0216276e80ad7e32891c526510d878fb53da51ef66f25e457e971c56158744e306d30ded17ba8cc9703f94bc2c663ca5456c99988df30cba8a9cee778d8051fa62589b34b0a5bfed80a7ac5e9f8b8067c0676581436a7046a87e95aa70532b8a9e64899a4a1d79d4598b914dad5df0276cbf5a0c0e6bf643dd2fb9ef53ea8e356417cbe71d05b1b81a51ae3ddb78995c1490f492ead7046b19c5fa0ce2c89175d9010c59bf2695a926bcf96ae79d347fbbb8319e9c2adb28752a6b9c1fcadad91d8d95b286b34326808aa6903dbd806fe6e7f1c1e899571b0bb4e22296cfd7412783b127b1c84d762e11ce0ff1d7a75752e198641454cba8d94192cda93586a6988c8ef74d97f6d083ff746376eaeb14ec5a1d6dda6ef4f261a08acc46032a2bf9b970e7aa8f6a6c4d7857d1fd2290477ee669400ed6f746a3e5572b849367d029632653ab6106db9fd2e639531b9e1098218a4f53473e2bb3d165b365b04f09cfcff0ca8b42ad7dbc66e93900b90020d984e76b5260a7658d0826120c8087850a135f7fe5fd8a30b2ae7b8c3d9fbcff4558b267097dc8eba576a2270ce990030638b75b7d462729830b5b57fa46638c6c00d6dcab8381c768a80131ec9b059b39beb66a77973a406c9339b06c4f376df92b49ef6904e741bbd04417a93b388909ab029f1c5db8a19525995b328138b99748ea71456e7a413241b33241d030ac8dd5d5c4014163707b1cd0e9bc5f1b25d7fbb7c3b7ccc80b57226f47da9cd3aa090ce9aed9b97c99f4b96b177130434f5f044b6c3c5a68bca0835bcf0b8df831fbb12c7e6b41f4dc96f61b6636cd2d67b4a5f804ff482464b9b244922654a29bf05cb05c2056384cf83cb4f3f94103246cb4b5d903f84b0582e44878a344992244992d5e52095e2a2bc4ea7d3898ad39f2845013eddcb896047740d85c169fcd3f79c565229a8405788ce7890f1adf0991b0aa3846bf6fa243ae6f35be130df666a2714bf82f37a2b5e892b89a6b1bfe4a7782856f0a753105bc4901fac7be61d03d608a5ba1d90130cc33014eade7befbda11008a6bcde542873280cc3300cebb1d1aaa27d62fed80fe5f90976a821b06359bcf7db7e58adddba17bb376443947da7c5d5c2d9b4f628ccab04d134bbd429ddb44dbb30f6bc1cba3f346ddab4bb5bebeead9b366ddaddadddebcffa4157b0caa7e3b615acf2e938ae082c8a6cbeb24c4921c6b53056f988e83be8de2c5f9cdb40a390f320366299ea609867bfee7eddb59b356a35ab59cd6a5ab679b125d42efd9ae6477d352d13d9bc5cd1ddb4e9fdffd13b2a84ebbaaed369752ff5bc9c413014baaeebba7c34cdd7ce78c576180dc57ea2e9780ff1835df5a0c0758566d14f7ea233a09675cd3753500582601af4e4613860f04070030e5f5ae6b305b5744c0aafe0eb743a9dacfd0f183a6763a6f9add6b71690795afe7c26d3667295b7bee5262c302569134d9224fdd60a0fa6be050c3de33770d3fb81ca0b5306372440cbf400402652355e04920973349fb80933796e3299a6699ae6bd366e4c9527582854ea89142567cf2a8a8a8b8a429521efba2e123c9dd05ff6b9f8d59b0f9a977edbe72821b0d85c847f9120830d5b506e830a19a03df4aa4fa1de7c93d237e99b660875a25028140a55832bad8ef58c45e061be011df33561cbd0ee017bae39d3ec206ce489f59145318e23a9ec1142ea9c929488d47154a94a6e855dacb550f073b57a900b374de747b221af72d2b1dddc60bfe1bad15123d040086b0e1e3a22d034ae23819e711e1ae673d7f9a85a6185518676e27ed241142fc2ebb9ab1fe4018badd27185d7573f198ce3388ee3385e570d1528a59229c584086aa754723a7215e148bc896badf59215c287b8f9f1136ec4061a7a16fb8b8ed263033e680002dbaf827e72afdb0e158197c475a7c6832ac0a107ff93826b16c130003d2a5da552a9542a595b23f4b182529369753b462514ef755d2c2ca15333b78897e4f2b067b25c696a0b1fa92762a75eb2104ff53cb8036aea181e5c3f2f91c254c634454d2693a99e40d44a92e5ebb85bb783cb5ade9ecea853601d554ca1d28131de386d0a3c23145b955facc0627ec9c2c6831d8e500a8ba1971a60f1caf0b2048b311c80d6af069a3d50433b096faeb986fb7da09d84f55bc15361d1eb3e22f067838733c24c099c4307f4491e29a295003f797af0d64b02f2b390b72b14c81b9ddc2852a6e83c89e61ee7799224499224795d35700f1126241126b2bbb3ceb22ccbb24c0a07ba6bc2e17b9b841d8e8cd20f94153e9ee79ea184a29b5ab2acd600411908d10297f375bde0fe8944958a2442d14d36b250c846e0ea50c500080eb836290cdb68e0b1ca5bfe1da41b6e735296d910bd6063ae80715374a4d48ea4b247888e3dd924b66489849fa91d59cdda56f762ec7939836028f494d2cb0bd15014fdf0421e0b13d833cbcb711f98a8cc510e904d896ad4ef420e908da734e2c9329090115594463c58f644e3687f9891bd241adb22ec108b72c933f2f7a8568764c707ed4841375c21e602cae1d9b1b292735cf2ca97b3925b720e4b9651bd3acda1147ace096b761790e6dcf6e9724e0ecf0e973ce3cb99915d3e1a38f728c725d3c026954fcce1f4c901d57da20dc78386f64da0472ea01ecd9872b30cd4061ad6cf0606b8645f0be8078519594dd33444f40c2dcb233a0b7a648950a435605d526849672e130df3f9f244d1636b60c78eb9453aa67e57eb6299acd0eebc35d99114beafd81213987e383f6c18586cf3e6871d473a8ee368473b86f5a654bec5c465cce639cebe8481c57e02e4ad00e28811977dd019f046017bc6403cb8669b5da39a96fd014a53f46819759a8d701f298fb68f86e71e61370f9af77bd22cc0f75e1f3548911162f5125493f07307de65027f7ed087b756268c18b65ae5ce977b2f4bafe15c86e3388ee39274ccbb736e39950e24e2bcc6008d002e947580451f3fa1180a49ce43d770dce751b4cce71b8ea4c1ef3e97a26368a87d5e96b4c440f9ef5d89810b748d972e43c3e5cf16f09a2d7fa6a169b416ab9de01a2e53eab8da0758995d1e1db76929cfeeffae95e3f8abf1d3e273d9e6bb5ce3931d3bfed4f87c3a6ed340b563ee83dc83e30a40d45a315b310b002af08cfdec9b409b66c8b699e301d05371aeab063686b5f6b2172e71e05e620232c4b2e7a74df3ee8e5d1d0e232b39fe23f41bc21a7a156ab889562d485ce9f02af40097452c671983720b9feeea64c0fc13b90e33500ee1e59f58f3f6ddf061be40349c7b98cf5912d8e66be19b45d1a783a11fccb24face177307c7819592982455178896c3c0c58233472411882e3382ee7cf4745c64ade01c8387ac99d5d724bd6998157be729917508f3619a097fc0179cba7e3e35df8cc92678058be1ef28887cbbef21a11b4cc679719f9472f2b36bfad805eb20c900a885f5436caadf4c8c572d957befa924701957000298c4acee7c301c85683114f96731875c7ccf8d1c67d7806b843140f057a84734b969157f2966f68596d2e777b6e9101bab7e5e215efa2c16081d24858ad3c2e832151ce9d8d037444e066078fea590574298c73ff29dd2772b350bc95c9dff01f7a8696a4a6e9c65155852af543dc756ef62cd2abddb19a200ca267e8fbd03768e5618817f40dc2a6f1ec45150d856ed131d46c9a6adaf19a9ac4445b49764c74a6a292784d6de2325d9324e19fa087a84dde888ac52f51533fd22fefada82615559b5cd7a97bc61d46afd174681ace344410f4d4343f6ed1338fe4838ca7919ec60424000441a01452f8f154d69e9aaaa8d1666c4ad3383d62ecf3c7d17fc450972601a24b744c915a83f0082a3c8d271dc6204174580149891105a110405c25741883a800054200319ec6244e2f40d2848d0ba66a661cb78e11bd70aaa083b516afb0788deb0842a967169ec01f09bc0061d82a40c2046038c2e03ab88ceb8c54e772d2785d1876eb652d86a9986853ead4bbbbbb3f4702ee8cfbc3cf0a8f7cd499d6ca82ec89946cb56a619c1287cef4c595d65aff71b390c2a2af2ed18d274ca9b121464bd42d9e26e76a85d918f4f0d0d3c3c3e8299c9e6ef5e0ac56ab9567c3f3562b4ddbc14385094f7cd05a6b075e7c20c1627e5a6b39841449962b2749cc23aa26282524e9799ee7d119aab3e309c93478244a0025144956b4472b27d414249df1d6553eab758d17293c57d4ac2a3ad3de2354499e4ca5195a928eab91349246d2485a95ab7255ae4ad34fd2248f409e48484574828c438a189d8c41c62145ac56abd5494de7399a3facc6d509c6d8349d3a72498ebc7704d8cb28f8ca66a8cea7d0353448cbd0d01d466ff452892c91259205631ae487d2905211a5911c499324c91a42a10c8436e083070d3d42a150284492a927caeb254ae45484f49ef968d7f38f86f9ac7d62163e97826635ab594dd334da1d734ba552e95dc1cab2fbddeef77341462095600123e89a175c4648d35c3d3c55ae3b991052a74898f530cc285f28c153e04678145fc251a46b4631cd9b8186f92c468f934422e517722691346d070f179c4a77777777f7aede1ca5949abc887690144c24f426ed0799fbf943b52ccbb22caf4b8b5ad6b2a2ce28b5274935ab939aaa4c52a9542a954aa572ee546aa351c4094a52a32fe2c4893412c1100b5f60b1969563a10a7cb5b004ae496a595b50026399c6f5ff6421dcd6a2ad90b5907a98cf57fb52a48ff42454288a42b196f553dfe2add042287eaafc944d7d2af5292f371312944ca3ebab9ed37c7d34bad68f8528b85d86e690f3c341f4aba74e0b267c7d622d3b500e38a168f30d34cc58ca06a7b0c32e7767013c8ee3986b78d5fa7d8afb5ec9c37cd674c01555cb0759080277e832b496652dcbb2ac652d65144192e5ca4912f388aa094a094692368796e18ed13e5c75d0198c1f80379017587452c454872ac791cb95640c2d43438004e1cffca030ef425ce603ed76bb9f9bf513310c046088816878ae76c7e7a6af78d4ef668a1b5409b502149193c934dda04c138599a6699aa679af8d1b53860e7ad5cda3c70668e8a6d775b917b829752170a61fcd1887563ce86ab55aad78d47aba529038d01ff61867173dd0a104477eb0d65a104c65daf54e5afeb30603b30985301b1d5c8a7a201f6d1c8805284001c228078866c5c84d9e032a48ce491afe7d3e2f290c0cf7f9690c8c41e1ccf12948be388d72806c4c588dfa5d28401023ee5df80ce47918c268bb3ee0365d7cb5b68f9447da47c39a2c86ad5adb9349a8ce94a73bdb7d9bdfb66ddbb6bcdda6792c14efed981c83f79d7b3d3f315a5a71ba7165813fbb3cc1a2ef34cd969f07fc7da287bfe5a7b67d94480fa639e557f48d2cfa86155e6891c2c165ada67d626bd9d5b0ec6adfaf5ce673876a012d4183bfa24318117eeba4a413cfb2e8e797bfdabe5c6ddfafb45c7e6bcbb9d5e556abdad0228b89f9b39853df2a0974bed9b42ca3f289f77e3e11e3eee33e31b75a1c07d6e898908d9b8ed9c1e3069cfaf9171f4c96144b88c565064b904abd7492f4141c71c4e98b68bef32e84e5092c9fd862884159348bfd84e513fb0cc72c7379cb2fb0e4cf083080ca27e3dcd2322d9fd8397896ccf26d94a394858585858525b3b8cc7099f1c98d9f252443c60aa8c683a18eb121dac183860771721e7427722ae2a907959832be33a2d66aabbd31cd9badffa7c09e6f9ae69fc98366c7d4d4fc0c5a86e6b57833090ad5738305169dc6cdd987606b6cd3b80adc0c30962fe87234b016b4125e1f17e13379f0632c0ec2cfbf45cba85208038b7ebeea513553b106d488f5390163d96607c9086db6f92b963021e2a6693eabd7da0e862bd3c00f7e06b984b7090f839d5074d62545665d4e9e60dfd9d1988096b33c03368388c27c773842e7953dcfbccec3bc83713ae974d2e9a4d349a7934e279d7daef499fdc8e4fb890f8f74b9bb63185823e482c4464130c46303363616134ada41d0dddd6ff0d07bf0114f8e0ffdeb4f131004c15a59250a957a2245c9d9b38aa2e2426b8cbff4b07bf66299a6699af61d0e2c7f56bbcc65b15bee99cacd8cf33a508f34500db31e7da77d8ecaa080b32f14ca26ca35bfd84d09bb37a29f348d4816ba41a15028146adb68183b1b60ac29d87996251d3a9aa63b555452809df4b913bf441be91bb507e572a6046dd206ba59f4f30ec1dd24539c43601d55879f5ace3e1a375aa641811e693466c83ce20c00b0e234d241013aa91110da8339caf2075a4223d9870348619ef6608eb6ac65d1f3c126fac66e6c422ba1c15f3dc10b25241fc10ea7ea4b4c4cd5a952a2a4c7799ed8799ee779de7b73aed06064b15aa723534c52be54e4c717c2627dba4fd77517cbaac0a2b35827d64a7edc7d3eb9eb3e9f87f38ae7173d29fd0cf9e17c92c56ab1582d91889e8e3a4f2ae564b59a8613f2319a46628d45cf9375b2ce2d735974161774c5e4c1a74d5c8687929e22ab7f1485d1314d2a53ca4404f53bf74fceea4c2c16cbc462b1582cd655a38edbaf149165fe2b58e5d371db0a56f9749c870516a909cb70b295560aadeeee6b93650765d9b5f9db319fafc96432994c9a76a2678f55e7b8accd19e833c34d7df4394ef843d163a1891e9f50f44e9c448e1a7ae17b87492c7a5ae81e9d494015de0cbc2d3cd149abf644777787e82a1402c19cdbfd5d6afb1158f4540a0473f6ae86e323cd5d9645279908d08d1e0b23984b8c48b14003dc581c0109967b7a1eb4f91b7d39b67d46ba8fcb9a566d1c908d38fbbcc44ce025f0767531d40bac7181dfc5d00fd21c4225a1b761437ed5cf895d951281205523b50245adb56bfb05fab073dc0812518c2320da1045463c9e37202ea8afcb36713a91669323aa22292eca9e7b3a7912272fc36ac7dd8ed3a8f0b8ae0b39bf3714047a825fd0a61c271dfcf9860ff866b7375eb361b96e9f13d1beee98eb52b400bb0ccb1758ee220446084ae8c6bca75396ed18adb5d65a8b596b2db6c1808a2a701676a1e88516eb70703178775805d8731294babf2021438c9aa6691a160aa5f22766cffb7080bb58a5a0ca543e1df7659fdb5d16168c3d2f6710bcda6adb6a846c885eb0710087459bedde2d9ceeacd2dddd38c0526ec011515102a8e85bd7759f8822c5eade7bfb2f765d1fe63baff3c511a81110059cb45062b4b9d0e2240fd2329f7750e94174538ecbbc7773c4eedbb13bf7ee6022d1cd329ed389349b1c5115497151f69c4e2b1b9b3055390cc36c9aa63ba92801b2d1d3eb7ef423d2ab4c0394427802cbf7c222a27f813c9d5ab4568e0a6b4dd3344dd334e94c2804821e78c19013312851a31c200ad0190269c4e3194808053838473c5a1645d67e8f553162cff1bd9c7212e6eeee5cb6a00fb492d0039eb9bc7508702f412215f61224ca5026ec25488ce193e4c665ff9c84611223b9ce45b6c8d8ba2772022c3ee9650042dba3cb2d1fa8613cbb69e24fc5cd2fecbedc315e2a7925f16710be8b5baed7855d6e5a1b1bebeeeeee9fb5d7755dd7957178c92e19072fcfc88fe401a4977170c92f198719d9cba4fd8e86e7195eb24b9ec1cb335e5cf2f5edf0f20cda61cfe4cd57758c0a26f6e5931be80554432b096dcf0f7cb8c16867809e04b9cc7814280c7bc44bf2c12dba00038a49924f3ec992f1019062b3eeee16ffaabb6d60791865fd70d68f1387fe1d8e6a2ba537887af402ce0f51005a851911dd116a02d0ea23882602167fa2a1070fd66a87b53f4c2c168bc5fa11b2f1e1a1564abfd5067cd46bafa555cb5b7655bb691976dd5aedadf6baf7da22863ce6ee8e5dcc8235b831fcffde7b5d49ca2ccbb2b274f7a157d7d5ba4a4f728328fa0676c3d6ec701922f80f2e0dbab0fb6291893c51c64cc6fa86a57d03cb9e9b66a84a7778749e0daf2357b0539e1efef59fcb4d5c64714583249779d702085307a1cfb235e2943c4cd96a95996e19966559869ab68347c912c4da16ceea455d6932f03ea30116166d1b823ddb8cd3575f7d5191c5b0ac0a1004310631884bd6087a4813d137b24c81f01f7c6479211c08acc9215d7f307a66253fdda125238b0f454616df0832726733686615460d819587fc900a9272313e2b327056c99fccb29245af594dcea8edf0b18a505dcb5a11f075752c2cdb2643fb8cc8f872808cbabc8525217564393b060c7c84f0b38a11c2cf1f28210dd2cfa23b40216475cc93a592e82caf94eabe3f39f102d327e7833db0582c168b755d66ad6fadbd027fbc2458ec966a478808870b85df753c5b48bbce092c86b4f0e66f5c81b3f01ec1622806ec490cfebd3871d3c239b55aad560b27f582eeae5d5b2ab5f4a2f4ba905094124a92a5cd46391b6b6da8c03603010720ec254a9284b69b408f74ae6cb3d8ad1728e0ed72047001fe2e5aa1a396ece0e43d95dba8a0ff1f23def702fc9f93f02181c56ed510a769bc898ea9a23405141d128ca309383bea055224a2244992f43728176bca759ef8576e93fa5c8434112962e3505e08bd2e6e09ced12a702a7c65d246d3b4ce33d6c960f34b16d8412fa105d56e0277dd6bad09ca186a6e7930ec0e077e50088c57f0bc9bb13cc3fdb04c02338e89c88ba05bad6e75abd53af2048f154eeb3ccfd3da8eb91e93acadd553700267d75ed9fd687099bf9db59496e06cb55aad160e86854129a553f0f6ff5448ad6507b81a241403096fadfd2ec77605c6e1f770db82f3dcaec09e4bdcc39bf252447e9ee779f6b8ae2c0aa6b5d65a6badb5ed3838f7629c7316e1d0999c5bb9955bb9955bb975b3ad954195123aa71c209c12e48887cb40424490608d78b454a9d4342dd664537466465e59242bdb4412d65e3bd6644ba59bada6597b5df6ba2856b14aaf6bdbecc57da41691eb889ea12814132a1e1b2459b52c8acedc286090c242c5c406255bea9824d7674976b4452c59b2da05f9fdecc97e3ee29456ddaa944e415114652d2a8bac9106515e439f582788405116c5836dc1684b2b9bea9826e7ca96e8ca96ac2dd9922dd9922dd91286995e13ce28986952cfaf188f42dd7b31db11d1fd4cf4f32c014785f0ff47f03c8ce1192108660e1411423734b4dc619685e84cf9284eb4ccbce9cb0b9ffda8042e3b5ce9900000000001c31500001808088442a17048342295b7b23b14000d537442825e3e1b4a849124c9d114a30c328621028801408000c150892c2ddcd8ab999bd4543d9452a28be475855e6441efdf869a9c7eed04c8b24feead4d784bb5e98b0eb34645472f2c0aa6a5cb1e45c9525fbb94b0cb7f78143c9c394150da8d0fb07dd83214b014cbdbc732b77ac29132d9d931009fcd1a086ecfd58179be1a213dc83a3c45775a5bed482df17138484987626691f016730dcdd1047c6aaf9a6b54421a328c5e79562cbae5dd98150d7d18fea05a2d2282bd9da99e3b53515262afbb684310daadc2e33b5bc08160d9c1027a6e280a71d70e120f70c43c48f97d58de2761878cdd226f85980c9a9e93cd6f7ac287d8fa75c023f002e713c5b76ffd48b5ffd85062a200daaaf1e0711042b3a8126bc2c5640cf13778af074eaa29f81fd4e241a49165a50e9f539d751e5c906d684d935cf592db0d35020ed627c712ad834431c04ac64a13f7a72aebb6809974d250527c7c41f7f427597b5cab489f7c2631f34e88cf3ae4f42baf87af76ece5576c5bf0b49233e4484a6fcbc4d814942b2a9c99f313cd00d97a5482901a68aba5dcd569425b9da6c8512bda8a04f531448d64143806f621a0b7ea653ebb21fd1296bf63551cb58412662de6bc64232558eab703222b9166339d28217a538498d8c55f451fd8d1af76ed151e5d86b2ff932ffe56c4c59b4e0610aa12840804debdf5af4577aec948eb8fa239b7f47fc6f92f4f9f5753b41d7a0a1d653f6c4625c01e609eb15af69727ed58b9a14b2cf2b0ef42e4cfc1312b79cc6a86359867f18b96bee4cca441a7ba31888c4c3ca6784cd22a999a54e6700f6238f43715d7c03c7c9345e2eda3e80047325f9ecb2c8e083dc48427a206966e39142e75cc1cc5a3263331e9ca51639ae5996b82cc04e58f19ea44f3245cccf0ed4bf25b31ba3103ad980316cb264fe8bcc08934ceac860f64eefba4d5969aa5c18c1d7948e8424d9199def6ab0d9a1152cc7d11fc038e70364293e7f79e80d20d7d2f823710d1549f325459250e8157debd11b931e82c9662e4fd850176a1b6be3b6c7d3bdd29ac108fd47ef07dbf639aa9fb076792061d28b6dd82aa88d417f2c7bfd63498e3a1a9818731ccbb2b967def42f8bdac8fdd6c19703c113ab6ce9e2e2236205166a3a77f4f01d4239b635650920adc89154b0d635a23c631fe10436de96ce08af2ca3065bfa1789a704e79d6c8cde9cd1a1923d65fa01e373bf629356c1448bb36329877ad885d023c5b4dcac57a10659764699d3e2f7c2c3b128553b6913ac4f039d903de3a342227c0212916db8893c904313ff3b5a92336f6b21242afb37af5c72bfe908db124646186a3fb597694b6930f12dff4a139fbeebd09a57638f42aa3d5c33258f8565a29fa0915866561aa8e2da28c3761ad2884407cef8e13bbf490ecd17d5fb1be6bb9366b8fcf79418540bb930dae190e431c90dc9d81a97ff9f5328331a95eef4b243f6efc1e13c8af4d453ac47c1cad32f35a98afbdb4f5303d54434b73a45991f9ea0be154d7fe48a9634fc5f5104fba3e8209aa723ade8f9ca96ca9c2bb4515f1128312160e910cb9249ee7b93b105d91834d27c25afd9ec80ca7d056b381a4309e6d30d258f92cf6059eefefa98d76324424840a08b839113193246ca59d296b6819e6765a3480dd053fa0bfa54a876a85bb1bbe512c7c105c9499d51b7c7bffb46680060d06dfc18a9dd4b735a6366b41a07c84124ea9415ba8dbfc6fd31553f857b0423e67d215f3b52a113bf8348f4c407199978f5ceb1a625dfbbd65e570d5485b6eaf5a58597b2103a2b9092ac094289327835c09a18acdb282964aad6e6e65be42ab39e767c9349b9fc89f96a4599b857c6ccb6f70d3b8f260017f8b9bc50ffaaaf705bec76082e2d52cf42ce46832193772ed946c0d51f87d935ec9517a2a1dd450760926bd0cf24167426b79cab2e456a44583a3a89de85bada3cb5f48f567504b26db24e66c26e00e01529e90cb19c29375688e776d1f7397e4739dbe1ca563ad4db46de9be29db682dc5068e5d8b1f1c944094d5fbfc52d08e9886a38b2983efb848a4ba6dd9e4ab1a3c6b5bbb713cc4bb07a21f13f378c9546447b40b9d5c3764295d85368a96637e3cab8bdab6fbe0f8bec7eda54bc205bc2d75953d535cf8a21d3b812a47eb8c76f51bfea362c45f6c87640d79d2bdbe392530fd0d22233d802a058b8040a129f1b7f229457e0ed2aee6a385afdf7cb0fe457e1d320bb0a90068c6b9f39cddd8cb0c7740ce68d61e094cd3358ed99fd5293a661d13250147381caf90ac58f5bb87ef6cbb67aab2e7156537593eab8f1db81a2d33f5d87d3d1046075ac7858f336c9e4f54b03065585d57298ea3d6a206b5db8de10eaf2ea6159684182c1bd447c407aa4024149f67dc69612c511fe0413d63cafbe347419a88e88922a901567780a0174a07ed577dd760886414ad95eab06d2f1b01adc55728ba22793c45c155e69bd6a40fdec8068107cb9e9e97518ffaec2545a5c3074c384f3bf7e14c80a691c69f272ff146ad861432a21a8cda43a420e1f26bd1357e29e1bd50630cda39d6c6d58ae035c4ad6120430a39c3d2d08b882463e094073fab43fb2905a94cf4a50e6eca31c4b0493857b59174a84afff3f07af2e9371857c2c53c523a93d180eb59cfc3e1b56f35a5ae0e377840be332dcf11f26041cd29ca979a20e84c27b2ed612a9d4bc3f00f5c4fdd6e8fd801bfa3c0ebf2f7e28c4f406a5f472558a880c2568dc266fe86f51c9b9e22e62df55e1b0ed003f5ab3533641e6f0d7842bd1b0776a6cdd7d63b21185e4f96ef84ccff8611ee89aca01daff09e941101c89de345514507acf9635494e88e928b08ee93bd14951b00416b84d0eb61b10c1d2f73087724c45d8cdb374b85bb35c2dc3fecd85a230860b1093419bfd64dbf293284571adfb27bf951c70ac945e9a5f6b54e7917e025f16b1204595ea3fedae44f196ee001af608028511be53e9f613e9c844dda4741ef94333cdbef91f0f16ba810baa132ae82c70597166c28dcfe3f0d9f3bc01f78f62ea20a0d6358d00e15e32783a88277903fd06f672cfbd3acecf5d7f29bab88ea85b3498e12827d984e489f360583fbdaaecfa6a6714aa7d21c8f23334f281ba678af6733400fe9d11e5e25d0d1ad1497716a3587a749076624f81178015bf47cf0106e6818b828ba65a2a287ab12398b605e17f4e97576db31c709d88e8a5585b6a1bb512e628e73731fa8d754677cf6ccd9e9950874337f880ad364826df075a46ee444ec74cea06b678132e273041644d8966a8f6368390a121b8528966239f2ec58e798a9fa2b0a8b5e04d9488fce37bce285e27b803237a5c45d382ffafbb3a0be967a2b126917e219cb090a06de48a5adfd84f623b681742e860197dabc1f004109972f51651c495bb32c0c4a9b93eb99a331cfe8cfdcd4df2eb753ba9c34715886ea2f07814b2a7e633e0bf1fd49e6585e0e07e68dfd1051ac0d928acc8a21dfc91331f8472792227d6d9102c800f8f1fa35dacf9cf3a57122b5ccfb86489c049f2c6d27908adbdc1d3aaa36f1d4157d311ff0003f7c2baa78e4f4864161eef5ca101c97eee9caebae37532cbc6b034f320ee1780e3c626cab2df674bc978ddeb801cf5232133ff18bd52044ccd9ff0912177a1cb610924c1ba15a2d31a35b428223c89d55a2227e2dbcc2afe5c4f835d8e658dd92403a8730d87b9f851d70f8a6668efb1aa091b3ae5b9cb75b99173432730ce5e2e6ed66c972bd3085200b8bcfc257aa77cc964f483df88c311b89b2d19606fa6dc3b7953ecfdca90afcb81924870dfba42edeabda6b7898530583e060c6f27164cb67b094a2e3f60838c84afd8e95a5af628822719b919b1f0eca7a68046ae16bc17940aba218da2401ef4ae03d0ccd018e2808d15a6b5a0718b24e6d4014e303f3826ced880eff2f206ebfbaabfaf8588c3c2e623f2f51bf1cea41e7e4c7a13974921a5f42b346b01759346773c6e704e313999fc3e198dabd2bfc8935e5307991f1253156dc2a2c9c516f3b0d8e8871bac88740b3f477356c2160cdfa29863121b5d6dcb917415dd70bf50691224a16809f09b104b0ffaa0e0652c28484274c198be2d0e36a948f873f36c03133caf074bab48916619934d17319b20367ace9ced6e2505ceee5aacaba9241ac2fa4d5a228ce9a7192fa2b7b2de3581f858b11ee84746dc640b9d31403ccbc34194c1d59d2360cd937da21bf0e4267503cdb2e8872c9554f209116b6c60c7d0b15f0e2c2f854088734cf646a874709f241d82ca9c0e6c1ec9d90be5d7cfba4761d64520719a94ead7fed8f17e085c0dd17115862d334067be0b9b8e4242daf953f16b8c9cf1108a940b2788d7138ce0e281b20a4353b231744df56a1cb8c97af32eece387a3340096528af1d160b6bc4d2a1354adc74e520ccf3cac1841c0662c122b12ae26ace04351ca9657dffd66dbc59bc0434e5e4ea63b1a0a49fc7bc3034b8c780fe46a50c7f8c90dd1794df8c3233b61750f470c31005a899268ac887146ad8c11e16df532592c70cab5459eb768ac26a80808ad4d0e3711c2acfdb21a80982b5ee83354b2846450aa51cf16c798327094c5ffa98a28266571992ee3929c06432fe51fa14ef291452e77c8c32e18de83a195d1cedcb151281454849890fb730ab7642ea139bcd3c9a329a11fc002aef36f923ecb0c664112d8a557dfda6eb513d98fb5b6e2254d1364a788197055c422ca8fc1fc917d038c170dd88d7a7bd2d9a1909e1dff0695f854635fc37cf9f03a066a6f8674b48ec80253b1b33eee4cdbc32e8cf5c7663b06942f0103495ef4181f79c00b83240b5d7fb635d31a19db5ad1533d78ad5eb7f5031e779ffbfd13b46aa49088b8004b6d7ae3a15b8644931ba55e535998fc83cc252b1d1ae62eb713e6f94c492a2d9fd6103a2b9d77e78fa7588ca6c6b4c91b26a3ec974954fcdbd4d362ec644b2bd68a7bd4ac95343f73d898f26ee3c1c358fa5bc574b24ba47094304be79cb4da72e345b8f33678a04129f6652e3971ff22047e77706ed21b38e44113a1f8a347582dbc64bc4dcdab25067118a38c438ed952a323a9f83a3c375d5c5d75544f0432c7d416fa6d0919403ca69756272566d0fe9052e013dbc2b5287add033ac768518eeeadcb7faf3ec4b9abeb7538e2b836f5530a2fe436a1314ba486c41bbebebc2fe6ac95e0f6d7e9ad1065c1793100f255eafbc923186230c96ba9f2afe0f8555935a54a542bc54c457755002bd6c969ae0006003a0f2b73782b98681d45941b3c5d1f512126f253e1a1a03f249e0a9b59d8c169ba8ce5caf66cb16c74fec5e74c46097c3baf86302acaf298b6434926e9d337b30e5247364e981e2250fc4d6f2a4e5af3a59ebc51bd6382e86f35831ad7ca7ba4b6a95c1cfe746325ab5569f2561fe53156622ebf91d08a3c377fb6425bd6b710613937c0436c4ec796cc1c23c032cb9fd4d8ceaf6122abc18169e34e098331872e81a7caddb273a6af965b56efa1bed756313a8f8ee8647f24909599c4a2196542a0f96685b840e6daf1848b4b1fd9393409d76229d402340a325f6b1ce00297cc4680b79fbdad7c8bbd341cae7c95b92c1024ec2eb6f4976f669099f0a4177828589554a1e6dc8d9f47b9164aff79661a1e11fdd1e310d2933b224bb08ff5a86250b04c7f6653a0ab6ac9b1e93b9fea3ed7b3ac9c76112fc240ca3b78319fc140efdf24770d3f4306d6a33b1a49bba76db61c478be52fa4cf948fc51a6a587b9a27288a5ce44d857c3f047db005c13235bb79019d1fc894db43914083c9c90a2cbe950491fc22a5fee2805ca40da169e83fc1e6b82f5e459abb1dd35e1d6600c3b4d00f973c77325b9405b270ff2f55ebf047aacd26df7c2139698ec5bebb31c9037c183f299d70e35e8340072f4256dfa56d93a14b9c851f40e9b94b89790533a4a808beae3c3b83d08d105656073183c34f863b8f48768bebe057e55cb5be67a04f0e2d7ea5a99725de18ccb1477a74fc87ccba2915a16a593d49cc52687254b5ada3b15f61f9cb721bf1cf4bad678c2cc2b343893f9f0cdfb6566b0a14623f601185b809f957855b7a6f7a6a6544aa9456d3e85da043b47521f0b60e7505b0c335a73b5fe20d9301c668a083dcc442d65dedcd77386ef481be2c844d4ae8cda706627c9598a6854c3c77a6e04647e320dd7e887a1b8466f188c363fc31f9fc94170fe55b210d6b80741c1fc746c954dd99d836399066470e0fd938428a7e1780e1f4be40426d1f529d7626584d6934be930bb74393fe6801716ea34919cd327c5849e2da71ee143b1b134cfbf12ba1cb60ad5a49a9d80e72c4de474537bb21d27e0612532e872e90de18a426b08ead20b64bb0086325754a02e74b95cb9a45dba963f10b630d5a15a6e4c09581100aa30b33093c4098fa8214362fb676e06ea4cff1310b4d694b05b760519e5570fb1e522ff088cd2aa1cb3731797f6df1503a4bc0a7857f9086747f6de797278dc203b5f463c6b8133217dde9d1fa50e6cb98ae2b6902e727512fa332c0735b6dcefb3e6144c3756e2c69835c79b29fc05a15140271d86d973cbbd5005eaee72d9724048ca0b05bf6839488fa1e5002d715a943d2820a65f1a58e2352b55fb99f9b5f4e492a12e4c3b0ba06648350b0f240e0ac455abecb750644ec9064f7ce55073192d2ece691d217c3507705d6c7c61524719e9ca3222f1b8475912e4ee159ceb3b798abe032330945a539458135c6ab713e67c7184f0260702683d2a8e4c0b13ec223d61b9bd01823603a25724e2d174eb60681b8bde11de521de241c8dff470f782bf55abf5128ee0d3902cb002c74c5cae10e76271d6d81fd0475ecf48e551628ac9485143393589e85878c1374c6f24e2247285330b599a56670381222b54e57d3c1f38eb00e8dbe5e7046f808477978bf0ada4a7bb7be62b1c9aae02bb7934731c3be8c964805f3287b46a2ee216e66d914b916b130d063616a6eb1fa44d004bdabbe70860859c9675f89fd5978a6a7d601a8a0c6c1fae93419903aa3839e24ed43ecd44a80df420364e7ebe333a295f95328ae6f9a3fcd908345ad595069bd72be9058b281f33e45bf519c5f1714fd39b82e473a66ae4098982c6b7cbbfb7b30d949e94624affc426e449b924d16cb8827a640bc76e18b170fa8cb6548eba488d5fcd4de90ebf8437427ecb2906e65b061d303a29e66dc3fb44902e69ab1836a86207e35841309926d3dcf3a3e6b5908c1f1521f4fb9c34bcdc203d796a8b0be8a385b92addd0a36b247beeb210c0eb8ebc2f48770fd299055864fcc5fed0f37d0b0c8992b6c29d2c3af021779503ed1aa89ed2c3095c43e2860e50491439c463b290a7138035f51df94be4576dfed226544362c6aba12f8b37837952208bb260300e83525abbcba683344af6f7c164c19a472ebe85f68c54264fa30114a9f12395e88ef9966dd6f0ab5d1d3bfea1e8f8e36196769a885f841a27980dd7f47c0ccadf58434f82ca748728cb91a525f466290c34993462d9a71e7a47f0e5bc3b2303be19588d96e1b89b8ce24a114da4334ece8466647034c093855ac8539f141cfd72e89a0de523cd72f2cc65bc1ce9997dcb7291c4424ac7c4e6c2e1a5982d36c6279fc3cf437dd149b5971db863aa414fcd673c84b159828a1e9fc66412c90a70036c181425d6697b84515b11df40700f9d857f1026f711c71ee06e94e86c476ce1cc6cd1b81cb8c69ff05a416933e06d6d3cd18761cee8060dac5cbdde9d9f067b4d622f39e8d3f4c221f343f8c1ecaf2c6d5b9287ce4dd85e43a99148aadbcba7ad20fcbca2908c27a0742b821aa2fa84ba5df63795b17ab7a7598b87fb9b728bac19576f6d9a940b44b964924d82e765fa33ad33924e0db10393f5c19985a36f3c0faa42717072f9e2d9a34e048004167c9dd0ed4f679cc12158d91466e08be8b694994c934acd82e7d452a9cc2b4408b084341a74443863cb6713d2d378627414eeac776fbb3cd793d76ab71abfefdfca86eda324276ce779afd6bb02eb8a6a8f232c0452273f73bad5729877460ebdf9a663ccc4f27e7f559375d252d37a0519b1fff036b77863480d83f0a2b529506d045422c94951b18b221a269be1d92846dc607d0da70589fcbe88f9785c6e60c62f37a940f889d7875266054b07a596cab30915957ea5f201e44ac5595279d2cc7e1565572481f395b24b2bb880e722e3d738a166a4f213a06ba7dd128e1580a5893eab2614b3fbf6d6db963071358cd20bb2547aadf04537d228fc6d1a72baaf4ec38c905c04a770f0b236433df01584455731321862ca75d60ee4b5fd7f5ac9ed4380ac7d113bfda8f65de0d5918109bcf810a3b401340879b4f4e9571b2f5c1c9fb1a71fec99ee75747f6b6efe9a9460c001ecdd2a5ea819ac85a6e5dd8886937de53d55d81ee982bb5d682b3c0e921d8ddc94d7122499950407d112d03d8c9310e6cb3f58e7d31a90e47a6d7a729fbc425871ab26da749446f36b70c8838088a34c3dbf02748996daf5b45adcf85e57a88049c85b9e71f2147ca5dc3a8d2e6a1f84b68bea956fa149ecbd97b822d50913f41f6902d4c58823d9e3ffd03a911d04ea493690bd0d4065028fddd9c3088edd487b5887f8588cbf8b70d88a160cb90aa62536b6334c5dc5001b3e4485dfd4b8de407b1537299bcf6c36492d7b03762e3122d59d2fa0a610e8d4067a0bcb816417b52b34ef41807b65fbe7545ad51f11a82b4a395f498bd87b90915b19d7e1ecba217de937d3f68f85b0e23ca03438a623811b25505499286c3d6bce49b3bb4fc701d5f45d9cbe229b17ec6b901214eea6c5bc2b28e8695a111e9c8e25360b9dd536b29193ee9683ec8101c3d02276b85d7bedc25022a0ee8a5feebe209e568e868b66ab75febe44352b82e8b6155517c89c4442f265a25c38466a0fcba093ca29c4779b4a8886083a39ce39c6d6c836476ca3d497a43c7fc9621e5eee377f5b295b9aa40c0592f460388ba129eb18683a861b447f8085f42df80a4e58f068ed7df32af9078671d953e839581a456cca4d034aa923db9bd42b0723c46198a237c0d18cd6a6481e08edab6fa438b4743cb2474486e4b8035ad6fcc4530c03068da1c04d62c472b823f2f11d7a5e6007c84b2a93c9699e6696c29ae5d0a4937b17d0f4344053f481183087c2bab8fdc5b87fa62873cd53811d911e598ef194408376707b8946030aaf60689f790ee014b8de67dee1ddccfd149e469a9644a4a996b2f8a7a8d8ac4437209bc8df37ecf054c9fdcf2eb5c7cf87d2e477a9a540286e6d821e898f2ff22d5bf63bdf879db340f9dab9ddcf984a0d53f1bdae520ce76cbd19d5efcdf1ed36dfc1259aa6c202494bc4e02f60db1e8cac542162ad04efc1b77b4db45a73604514e3519e65224ac4ca4fcc4156680bc0a7804ba455c8f673070a4c3fe00b02d5ebf47598a635a18099c18da48e3c5fea6421b6711e9d211b437ac2ad60ada11d3968a7e729f6850e60a06c13cf2db1d17cbb4ffe5905a41f877bf454a24909238447cb2ff6f60497aec953c884b35fa82c4496896c765fecfce8a2e94f8d4fa7160d356a1538a0d87e80538f9f0185c38342c8e0b5a7553432ef4185b06dbde434887f6b2f9dee6d0e8bc59a458d226ed979d86a342b2b331133b72d4e89dcc152da2a6952ca3f67ca0b678d34b77dfca91654d5b45e3177b9f2888c8760ad99e99bf2a21a05dec8a82e574b1cb8aec136f8d9c58e1d921cbed385fd5ca04cd98b20440415916e30f2d38c211a2d4bb96e82191f7085c495f65fc599f30628ed0426078bb8fc2a81eb485213d6b9b8e3ef5ebe8d3dd2d2575a11597e50e26f7d32a4c50a9fc762a95f55d07b189f4039af12e4f3afb5d1bf642568007b70d96e9e93433b306dbf826f8340fe257444366729197fca98c1422e64943d46fa4f36db1e819c3096b59e9b24ac4e0e4940943f6599fabeefebdc6d14eb9165edb05f330ac5b6c0e27d17fa953c96a2fe53908b8d88c4cf76a18a8fac1641b9172768f611a7d3c904c7d0dd0a0f7f732dcf78983d1f7debefca4b0695f1c3955a3ea6bd61561a01286eaa89249ce4329ddcdb6bc11835d5b09b4072d14d2b1f75addb4a908b39fc3ba179c6c23d89688d4a374e8fc4a44bd846400cd0e57fe0ac52c3da024e82b94c3cdb084685e028256418cd8d57430617c9c14884bf877dd871c74ae9498bcbfb9173d38722f84602a18575e2f4185f5bdf44c44ae305019471ea44061d52c08564f9259d3d73d328a636ebe6132ccb7e8d6b6841c1aa00c93f177c4a270b52e3579bacb8c37d4badaaabfaa7758afdc594a2d09cdc02f66d89f03c780e3a001b8847aaa2831d97c6cffdefaff8eecde42659dce336870af544a12a0b1d58af12e5886ea048a275e4a25cc01c98d8b66f2fa2b5c774aa18528259788466897d323c54ad109d97f05763c8e2e1c2ccb7bf7fc0ce200cf596c6b8e28ba55666e0eab2e3fdfb6d5ad00dbd1ea6773fc56cea76d806a02ee0d8cdb632039137e56347d69e18b46715a5f4809f6200ebeeb8dff6f6838acfeb260657f58ecc0e0c5e6a6884bba4126c68485ba31f37343ac04e89e863c893f129f3e92a14acb844976f6175c01472b24c56d270116c7a72306c070b99b18822656006d40253b1a7428fc5b990b717c568bd05cc7b11f1c13b9c2907ce224bd32ec89aa9c891999dd2526d9addf0734c78465186b42accea6778b5f06dbc507b27886c515172a13e991a915e7c7f95d181b30d20a864f7b7c3d8614c6dda8e1475be097025355c8a49d671d9b46723200eb0a9658b803676ffd2d575841afd2336ebfc1f53ef211d4043bcb34fe88c06aa0c446706b8b3b2283671eb71f9568e39e1215ff4372088d534564fd3322fd25554710dc387b47f44bc4fab8e1b6c707e9980d9ff268ea72f0e2afb2f0bb70090cd1b0c94b3d61031d64e7d23110b6a846b26cec0b5560eba1d02c03e54320f19aecf6aac4aac952585b8601800acb40271a67fe84c7c317b3214d8ab36dc2728a8135a780278e48de7475467bb39e9b7343ec8f8d08ae9532e8800400c6089778d57e0a12a7cacd0a7dc5b5f880e7854073ff2109118c9dc04445ac2f0e7ff78b4a559008c6ee1b841a88c8d906b00ee5acf97466ec723495241af1ecaa9fe5b87a7427bb9356bf05137f80345092d3fc339b623a826e6d2f28213c83dd1b95032fe22bc7f2687b2c88380ac3ec67ef491b7dc6013b1ed877371b72028ab0a506ee4d36250438335c1f7f3cef52435f7f7ec7495431a1644f5863e4d1a4250d60aa2b5536cfaf7de04c51abd4de05ab98d7869d64df4242174ccda7d22ac7322379e4d19305697244e5124495030241406573cd425cc4ee9bd4d57c033f277ffaae35fa1096f3d96e4eaf36dd302bbcb80f64ea5c4a7978dcb8de06b1824c9cef5a7c72d741f6609c0c572b2a65953f24f71cd42bfc7d29a019767b7b5885e1485bc31a8ae30148020032cf944c79cfd3b100d76ff7c99ad6641b161f3432ca1d70c5db91064f52f86f977e71b5b5f489167e5ec635081fe9584180a5dd21855e35b95e53ad4f8d6b372ab4a9a39a6abfa482a2d19256d5f63b837c4f3188bad3785f4514d00a699850f37fcf53708d2a0c06915286d87adf1f5bf8d355063c7d605860e73e537f15f4806dc6bc08d1093b77a6025beb459624ed64e539ed31e95e8ca5ca440c5c5193455a43012b7885cad713249cb47ce2846c0283a0c490e6880c57beaeecdd5103e99851790f4011afa5f325e235877a5a0bfa96d38f535810f688019782d41a36f358e4265466a0468721eecd40f8193352c4f6aa20432475984255634430b6663022534997844970e1ef01bc69f4f63f2814369d2f745cd6dbb6089657f6eec3d081850cd36827b73b8fc911951ad2b761d81dad57462aedb1102365ad864f5b7559b924e0c086b05d425cf2bf8d36d99cb56add289899f8a7153e27c6a266128fbb88abbb8ee24c4f8f455645177cb1c9fafb5a549f95cfe69970c3f9771e732adce75ec10b16acb8b716e0f22481889b92b846525942a72ba408a11c751b59aa81c7504123e09a4162c554dfc0911ba01c62e4434b542c78fbc35f576520ec9d2115e4e4d5a7369eb72326276a29a5856c96ce2a86635025b70f0ae0d84f92d5a8442bd4d8c797b71d9f2df80ec33f2f8f36823d38a39bf37b77ad434e09704aab409291dfda2a8c01775820ab32aa38020b453c68d7bf2b9dca0401d51182d56bae2b78bfb411ec771ef526ed0323de1777690c47c9a20566f74d9e86f03b33a4613e80c45f1e0c341fa127e0e68d36d3a2846c5b4e944a2da195f784658acea1e9134be42dbea2206f4555bf142020aa876930b272764283095da7fe21ff07c27489516d9dd280c12ab7184c3c55df743977c669580e6703b0f98bf269730b4036ffd27bb32df59e6c8f996f539c046f880a99f85b2602917da7059fe718875de643ffce75a9400f7363574b9cbd3223d7d718cb7d2ec3f3e9fd3582dc4180ea186ede1831c07fe295a4c5288239fbae18ed1d11deab78d40c1217e6bb663fb742dbfd620eb36950a025045a1296f1c8cc58d69f6e99aa882101be12048017edc87860a4a9e53dfab05ab783ae6ea58b237d364f0e1e9c5871484c94ec394d6cbf4da1d54ddf72c08ddfb9f4f0ff393c5ad830534777bb1d4f4cde55f3659a8837f459e5d729ae3184105352b3e69d8fe44131ce64e0cec3808685f7ac4fcd40684646025b97caefd5464f295e8f4e682a74202773e3b15dc9c2cd7eee918a94fc7c454ec9b789291769d0d32ead9070df8284ecf81f0cf91b56f2e79871bb100839c550e1cae97a346dd6c62afdf4edd7e810bd910e48f717c159f6765a5bd2f3d601cf63427009544f0fa6abed4c316d45f10e50afdd501d33afa9e105a6e4a01e5d6c9dcdf274e015b7f9f008a259974f18b9e4d54aab50c16ad33831590e00c96f9d6af6e3c016f14a652b44a327787dbe7d3ac986e84da957cb4aff994b940a922e81ba2eac0b8f4be962e3ba8d554dff58e8b897ec40d0c8f4a680cb11a228bf3105e32617b096bf67b319b64cac1d4c2f74445371329a21c6d403f65529de61419a800c9b0247fcd3cd8f96dbbdcafd730657e651519359cc2bb5b08d98f819158ca983629e2239cc82d13e46631162cfbe46262b1c7dada16f2c36d9b0c520ba9059e92a496226f9736c94c39d266c98530f51b2ae9cc0f3a633011e2d730a6a22563b272306dc398d5e52ac580310883bb690595d3957542b4ed3a711dd780585f5982df60fa42d3aece90db5fadd375f12e988d65ee80b90083614da7298a8bc39ff1d9d918a65f16ddfe890ee74db420f8964ac240c120e59d942b0eff6f9271b56b23cba943efd4d439fc41da041294b8f263f3ecfc14298cce3b6b22fc6365067143721287443c2b33ecc42ac551b30a3f5f00a75410a94698a6f9a87829e8de2d9c6b2564e118ada4c223d8f44b0cbf3f934942d02a4d4d0511a99c530618cf69b5c9359f826644addd9270d0675e06fc5d1ec8bc2e480762caf181a47ab0dc13a95462d5cfb93c3150bce59c9231b7ed5034e647ef9d4b21b960d0d6a898bc528551ce0fc3a027ffbc48bb6de3167f2a0a4e9b34498774b8f03c032f46591f1e5b8e8900d1bc41b404b1b756afce3c3136dfda82d4cc1a5cd7b319a2b314c33790d4b9ac47c22083743da1428b803910891909bc200536fc5ce2b45df325e0facb0864356634716975bbaa784408a06219900948d87d54e7208ae128e29792e4ea8fd560097330308a7e8ef08225629fd84ca6f0a92e96c2178e5184aba21dcf7669ea49a2722e93145ea34e90816ca4306fbc759641a882854e50d0a4173a06cb1d40bbb4af82e278933a5030d220bbb944100b3824a05507ad6dae71861c8d38cd42d68c62c7ec37be50611861950bf32661865fba32df5c787b951a86f8d775ca81cf594534503a4d36b76e495251a8855801b0d734579b0f8bf4725a16508503bd16f46afbbfd8a31fad25ee017ce43b32651569f5b26d3bd9e4db1354910b8cf51e40040709681115b9a05d8c582ada63aa48b8ad53f186f716852eddd94ca08a40aaceefb10a4515d9930277a5f10a19cadad1eb3e9f5930cbcb2879ce29c67a6e08fffc77968e454646ceac21dfa2704590027552259af8edfbf5c4bba74853c5abea7f7b512872d2c338a0bed9bd85de5a6b982f51d10903e204afdd090ac23e4391db273bfa630750ce748308c5428873b92858a481e771b90ace55c5de1c6ecd36def60e73e43491c9f4c787889a619d90a82298e3b0969a88a03ac0cedc5344acbfae1d3d1b2313084a2da8f87ba1d6f82dc2de50c66cb43c0291c5c8cc0e7ec135534e3e26ed040915622d22c39f7dcc0a26f137b6daf65acb96aa95ff2b50a6c7ffe7f2ab0954ed6e923f1809f872857f44e54c264ed7732d28376d9d4a1a055007fa10fb923b28d259eafc47a89e9756ed4357708067e0f6de7c969dd6200818def3bf5c421dab786992512a3939f467494737d48d0c0d9c79a78b7af3c2252418475ee41573d6fc47c9a1801ec50ca36862b1fe984b313fc083b0d0f9be92476e760416115bbd4bd87da197e1cd83874cda87c0797136c5e0a578e55d7e71d8aab97ffaf2286a834db791270e217c0d9fd5f706db36e8f24d481e821f17ef33dd99797e3674fa560b28a1f38af89d1312020f17f146a36c1d23dad75c23992c613a9124d3e5545cfbd3051b91e55db54b1b40bd43a3f8fd9493dd1e3d5f6e48ed5a29bf429a614671f9bdf410479363bf5e4a7ffeb86d3e013628fcf8baba271c94e1bf6e1f16da3d772b39d75304b746201a950052c08f9e7d04828e86847d186aa1335601ad0204e836bd51adb0345e22508484b6cd3cdc9c0950916e318c33b0e74e7f0de57678c8e712b1c49ba01e7238a15686ecc70963a38636c5631ec7df0b59b85d593f2817ecd8a432bf6cc6caf9a9729d7ec93af35ea781b68ae94b550133c35b7da0c8e0f8f4b0b2ea4eea7dba7d39568f2acbf999916ef77f3d9de4ed73c38969bd3675a10c04c9c8902210671f88711973785f216f81b6be9043ca3144faa6767232edb5f6bfa7963ca3d1c9f3d5d81b28ae4d5cef5e22275433f5b4ad917a7f211bd0cb08b0ca7663a2153329423139edd4443597871300b00019ab45225fcc210cff1104660cf48339124969758af975e8a5e7cda4d37e4603270c6985d5facb53334a215b520a61802926db529552da0df2c0a1d2463628b36857e1e1d94813e212d98c984013b66246fff8bb094a59fe4bab6ae159bdc900ad4268d2cc7465d74fa49cbe73cf8261180d1c5b71f0ed938ae74eeba71cdc19a4a5dc0028ec16553fba0bedba34897f73a25aac2a8b7c79fe2a7e287395812d434c3bdbab6b0a81441d6495ff76dfbb55319af7c93cb4b6e9257b095d2c008844dacb0825f6022fde172b29b9cafb5e2b7e622c789d22eb73eb78461043a173e2b933e28fa50ab224578da1dbd6fba8d219dcb0fc7d15a2c1acefdc32a07dae30f0177b15265ec84bf153da268cc814640642cf9224341849e9cdae095a95328ca43743242924f9c1c61e924c9b38e117ad34c2d78e90c5fef223119947ffae2460a98ffda68add68482ef2a462689a320894dc1ca21505b993ede407aa849cda1d073298c966dcbfd935170382c4d38eb7a72f533645919c6a71a48628a91a831da57ec9c9b76225a00a47dd99ff7b93046e2f6240cddbba497e997091b103c0e144aa447641422b238adde70758c94311ed098c55ea92b407569cb365a8563e40474d7fa959dab10cf06a34392bab28821b43e00614fed85356c3a1aaa55bcf61260f3bb43e93d97394845a885e55a0be27988c2c48ae0737fd175fb38598c3463c62018ea43c5272098b73249ef7c4befe1448e86384c893accd48514f76da6e391d2a91e7cf669eeed8971b22cf808d0e20213299cff0f6f5860071ef14a431ca3c91dcbd96acf168933efaceee2b411c3a05215e3f23725e70a63ca02945f908726579ca97a85d468d75945e883d9106a53dd93265564431b5747abe0e48d0cf96782189dd99e06ae73e4fd26982f595c6ecb4dbf3507304c1a5511a345be9049f10fe5390c22dd52d2aacef0235a87d1c5cd7a8da2825b12d2e9bc54b91b6dd1857f9c7963d8b58f6c18e05c073a3224ca1d117885691f9458d3f292e54dc6fbe542aa982b9746f1788e8e0a318e7b0e24c458a7d2389646df1fa468e8a4f0c275e5949e5535237c57a8ba7699316ceb1d407f199ac0893679398916ef827ee280f3b6e8c027bc8029ae130d35de8f4ea640802cbb44baf51c8c9ad262720902dd02424ff5abf0ae738b83fc0df9eb46d4e17ea60b3b887a273aab899a30a0827ca0f79e0b8bc65829edfe9119cc504a7c2a691d102e74efc41000a039c7ffd13d6267262f82b4c85cd8986f274dee642e56e0009e97e887ca37137e0213be7c5c6d16f771ecd40f15f69e95ecfa5234cfee5a426aae4cacba826f1fd7bff17633cd826251768fb6b06f0dd44f50c599497a60015dee1f1ba9c3c16d5e3b7cdbed23ad6d7bac65004cf4f9613977563f6aca206135003781de7617aa53590432a14a841c10fa17d3b7009dd31b0150058d569b0d735430ca428c4a00e98d7fcda98d9afad85c07966b9d0374b0c38453bbc5c36c331a3337a0bbf23730783a31f860fd166eeec27db2eb80834f5b84625e345207427fc3d84633141c661b4489054fe0969d61408c6162f6f513c8160516b1aea89ed26516407d5605e6ecf9d77044c1da1e63ba72d49aa19b49f1e4844c70e0e212ff9467ea48b4a5d0760521d03af1081b83fb61ff05c664034c70e4a230ef8236b00ae89c80e62a7051c911d088c2abd88ec8033522a68fb87db47dbb1d03ea16cf1c1c9273d99ee14c80ed27da91d1d341b0c78d00e1e36723b956a09d4ee7f2eaf586707aa9b7e44ba615d7763ddc85fb3dea804fda11ffe45b0703aae2efd40b27e5fd01f7096f3dd9575d2325397c3e0e09bfc5308ac41b21ed448b10a32823f2614ec147dd003f97857224a761bfd7c87fc01271dbefd6b8b63831746132883b6c432b878881d462f8c64b907fe23e234ae8611747aac8dbed0dad83849d648f99cd6b6ea21ce5483bfa8c6a4504021b72de308264694001579647cb42e6a66a07277a56b8ee3a4c50e6cd4a65961d14a67a7b84fe0c7313e5fa2c4c43d738380d8ae5e23938b361a3eeb4d770fe657e9a198e0c4a623c17e337d63e9961024365682ca5634ae910e8e0d2d495300ef162c670b78368f3027a87398e2d36f36948c8313008f4e062b85f7bdc560c9a66e1c91ca9de004f7b1cb38ac571f9a81c587204b47bda16e60b7d644c7fee79f66f2eab53edcd93b3bcfeae6db6dbbb63c21704fb048c8723129d2c40539d862e6f37db337df49d1412695eaf3ed515111b2a4aa0fec3dd429d127b449eb60a25a9100f1466ddf30d9c76611a89e3672b56fffc605839890635541cfa5362da2ea532a34eba9b10c9629fa14ef1bc0be4dada92d00906f811ae3028297e1fd156f84fe4f0303bc77217be53897629b1142cd96c9601f57e6725472c0b3716c2110e1b20824cdce5ec02640fe2bedafaad274dad4bf6aa8d662b45ac47cacd2d74ba53d8bfcf92957966010e825a1826df349107d95feec3cff04a335d96639134e7dba1606dde82c2ae0dd9b81d1651c37ff369601587a6c53fd5cc8c38adadfa2ba43c934c129e653658372f6ddb0df3e33544caf26268642839cec97119ea1bf82efad609ffc42b8dd46d474136a7986eae95973f7acc1acb8195a70d0b3596d931c24857839abe40c452e390bcf33e975a4e4255d487f5f173e56bc05db85fb98a7c8069d4bae97a950ad51fa6cdd788a20e4d2afa788191c2303977955ba1939e5c8594670690a369f956d10cd266b1409f0ef1b30592a01fa2a6b777e25149d24de86446102c11584e61e26f9d37b09f735eeaf68607831bbb16075211d896c5d27cdba5f99482edd822f44042ae570fa249e19f50563e056e41cb4f019935c04ce1f478ad260569b721afe497856c61af92923c2edf16028cf65477fce56724b13ffc3d30991e89b29f101831d715e00ef4a304bcfa1a5277a94de16cddf5eae3c5fd9ff562312777e04f4ed4ea5243179fe5f44fa3e64f26df2d1df59d4f73bf14b82f2cde5bb9c5109faf9eef0893137224a2066a6f9aea3358f664f383d1b8b8cf3856f80334d3958283f2d7bd74902b28f1c888b74948448ca1be95efef9a2ad0a18c57fc9759c6fb907c41c89d2672f12fc26b90b376562288e5549e95aa1ca447a245d842f19fcd5197fc771bef00cdb6c4a56854b006f6448cddc84be01382325e85930ceb74c852ffe206421747bc45ec856dee7e67c952a78c255b9e6a0f2bf3248e97935a65cabbeda869884bc533a94c7dfad72406aa24c37c80c23419fee28364b0837c7d2156c3a50b051e2d1d49cef66b9d7152509b126bbc7d7801b27c515311175deaa8384a0ec2e3e715aaaac39ed95d7de7ad128ff1273bee0d7cb3fcee70f3819dbdaa1339b41e995efaeeb5a6a65e7015e6ba1becf7bdff67973b606b5c936b6245d26d0af47fc746b53a9b4fb3b30ee36fe48970febe382db3d734ece3f7d43d0c59299686871cec6cf7e09401317d21087284f384c9d9ce30092db0c5fff2bed078e0343c35b3011fd138de43dd35567822f7a422476a558a381c231bed794f72028b43eafe664ae5394d4db411e5203c5da6a32658a444b4fc0ef4f3c6f661e73f1cb09048b1557c8fe6fd5885c8b7122b8ab494329495597b1e504df7e399e50ab21de2ff8e0f6b6c60d792816273432c029b431e8b17a111a7a3c1e759903671cb8e1ab0d924d294be502495e23b5efc941ca720e1e0bbf2f56352ef8262f0a62f6ed87d4629e4fe09893b676221de295afca56bc3247eef64e262c9377cceafec2ca688dd873c4be3db2abdc246a28c7cba2de78675d7361d76c840a651eecc0a2db9ab4e2244c53ed942c3e2a3ac6910a710b39cddca4ea2e5c52b2bc660c2568a3c7583060b5a38bf4c7f3ea190ba8dbfd33db917b13c1bb45217b54019f53085be7e1de821d500a90c64173c43782a49adf5f5181c80dbb7f41c1f9c9e13468140635d8cad9f0486bd0a10b1ff21bbdae377caa8d3e764b8b2439b38708578e672382de17b17a20b7a7fbae90e62080a143073a48098fe0e26727a84741ecfc5bb473b59c71fdb84f3caf7b6d1ccd13c68f599f8fe40efe26871f641fd3c2ebda29736131809387d833420d65c2360541096242876668f6344351d469ddd307640f6d2f58d48586c90cfc69340d7758d3ce9a0d9f2775e0835a6781b6806871a5ab7151f2190168919d21b95ef3ae8bdfb28251d50d6650cb079bc6e248c427e34a7366e71cf048584a90a9f7d185180076d3325f4f2c30c1be23a48385e12c2b3af8196e47a183e085eb1f02237317a52f875576d062d2f0e9b0603350312819bb6bf690ceb789319728b7c045ceac783437796f38b75bda27b9a3d581a34c3c5d6f41b982b017a991b3147c019656e02af822f1b05843ba721b4ab531ac04c383c3385c0a76160c84901a579db7bf4604a20da31ba8ef88886a123fdcf95048fc3a184234c59a17da25ede799bfaf9fa3b7e6687dcd87048d5e92ff39a229655c0d55aac3bcc07fa3684e2a357854d0e4bb529d7af08128fab5def92e858b01e2dfe27552b3cfd03c25cff80c77490782cb0d657141537ce0da170c5315a42671bad21b472d2c6ecebf0deca0596b2af5111695b398143c4c717b1bebb7ecdffdb65c62a81d5af918cf6f0d58cbd655da5c82effdb54960ff63364658aace409f922f2671e66358953347a58481570d3c0edd9a9e0a52174873424555dc29ddf8b9a5594e1751004d016ca8570be745feb7ec6b0a47cb2cc79e63af02d06865af1ffe14576f562e536f7437cb70010b23ffe718649584d0507b4f63714be9047529e808aafb75de0441980c5035a980530c3e38886fe823c110e0b10f54a8cccbae674f1126abe51666a91d97814a6970a32d39ad5f76d83a3319d1865bd14fa2fae908edff19564b2f6d5632d9de0e7c0cd10471a0196629a5d61e99b09c4664f07a8320faba24164460e1fb4e263a4d2c8cc356f51a08189f95e2589db59ce086e884e30f5dd3e3902ef04d632fc530cc4479f8f166a3b8d6634c17c6684b2b1ee3a6c5b7eea07082fa4c2199d5279de8567161f48145f7de3af54e94f47ebf4c066ad4a57abcac1730896e23cad79aa8b5f8b57e4aca258fe438d6495649024f0e308b376744b5c662a6d1ee95c2bfdfff2197d486988608a2aba9efd1733342e704ec0c42c80ca78f4b6a4572106ead8947bcc8c01735d465d4c4b77ed1974cff9f3e28a04137b0144b52a7efbcd81192855b8c5f3b9ad29f195de871c4926d4a1aea5c176ebb4abc54bcbaf0563bdcc26bba15a58f9adf699d4e5d53c500d6f55aaff687dc70b78e0e3f762e240385cdd1521f13bf5c2d2ebcce37baf8b5118e905d15180be43f3d831c7c91ba7674ead6eaef5a18be999e09bd51f94156683f40afe48e87b1d1a77b02247268374ceef84bd1cbb8313c75d3819655e66fc6f8d522b94a518cf068e4c9f76d72ecd5910c8354f7d71bb194007723d16be13bf81c37961c4f67cfe9b853ca7d350806a6f1c758c47573fac9da52d46d6675e361f698d66588260358a4d918f59edc01488f30e8ac6ed7b5af8951aaa062771fd4dea41deca000c2eade0a404df79f19a2427905b1cde9fc72b0ada361dd9147a168e2fa1aa46304affa74a4e6cb3a68d3b9db3d248189a350a6735677869ca4783bd1ac7663545ce792b1dca963bca87db8578b52405837412154a84929027719f8f84c62a2933f452f0ea85131a970369b24df26211f74cbcf37f263ac32a22e128d80981151c435e4a24bda86b105873e3d8e660a8cc23e1698e8a146a5005f2054e9db911faa763fcbbc0205c86ddd23e47e91a76895bdf3f63192ce712ecf12c6d714cba02ad6b7c3810066ceac7da83c1ca30b34386e61e18797161fc774163e909b6252152b557bf6bc036f319dd7537f88b4358a241754aade0d866bf689c6749151dd9ebef34216107da9ae61a0ddeca5d3eba7ae18e4c9653d14865a645973e5546bb530b430039486bf4b420373355953677a5f0500acc856c816a874d831f3ed858e9c1e7d3e2a00f06b475f363a053e6b846945b6b53e8f0de71eb37a10d49252acf174a529d4298db602619e057e041044331ad64caadc7b737898a93849bcd1ddd96e9f81bc6d207dca8e6f1f187a0437101c8d9175d6ad37057a3fe6a7346500126370d06b8c1ec92aa651ea3b7cd17ec37912f542132d448c3024f53e8d6d47ea321e98914b0a7c394be700125276e155e7256f3c532c0fd5d1a10ac14401137a776be45ab08127d4b805f9c83506636f4bd64732f9875ff0bf5a69e0fd42935c062cbbb816107e9ec3ec6bd5688e4a9b414ce28fb04b31f0be7b5fc48b80d194ed333673a6b9a938a8260dbda2567726e1664fdf581fa5c24a0ac561909f5f2f03d204133b2a38548f56e1d750368dbd4dc1cf3dbe246384de6122e22e2e022202fc7b060ab5494bdd6a67f48383b21941f18d376fb4099998f7139dd6aa271573919b47466c16d0cad8580d00cbfbe55fcbe13a0efef82ecf1bec2592070cd366d9f721db3d9b48315ec9205aa262e35f2868c4e33b21a0f1dd016ca436160d6690116086294f17ac4c9e3f402dc04c940d509be40d54e10893d8e96a77eccd6ffe7a6b268d4a1a22a34d1d939fd67f525cb21b8d4c60a09a22470112fedfcaf8deed7e963597e885c8b099843db0a8bcb386dda43c9f9961da5e68b1582d985830e6bb5fc285a07c92c27c4a4c537983cf5d6e10c1dec23d657b5d612ef17650efa05711ef6c6f124bf152e856edd78b2a0f1f0a43c88f71e1f15f40102d9bde3a49a798fc85eb214e8a0f72cbd3b256d3b5180a832cd500359f97edc354cdb90466611ac6418ecc6e40c4f40df5eb56f5052e000346f7505e3fce4d5d18ee27e30114a96b17d02b1dac569fb06f4cb33b85f8352438b93d9d4116ac376a3d92d93ea66c69c5440945f74a43ee38cbc3a5c2dc35f2632d6ec78ef6479916d47f768b0fdf3715e402be01bb07b85e62bb1d8b466868a89e6a83a8f1bfaa8a2775453530e4122c9f16df2ef24f77b7a986ec2975ddda3678406e06d0ba7c525d6610e773c83d623979fe9cd23b00d67f9ce87f1cf2dabe327792bd225d9b3ee225fe9de7427f6c3651910958ffd13cde55eb05d90af8af11211745872a595e0ad787b6837055ff53b5881ffba8833a332ae57b13721815a47540549e03a9d38b6b89aa6a0071439a390c3414399cc49d0a27e33259696df06ad09fecf329718eae36f58219823d8f816a0764efde7542999aed9ece46319b876ec8219c4bc8a79750b6e87d02623e293a63b038c50656abf90098de7d1667f0569a36a5cb19f7f2baa481ea8f53570bb0d744bf5ec6716f07c0a00ee32d835a428ef30e3071c9b278fc19c4089c1fd1abda374c939dab7ef38083315b8ad9676fc40765a22c727640fb24635b86da0e5b9ee8faeaa1811c5152154195d1808354ad9da2a5ef80348786b0c482c7aa44d81f39781ac2e9e87616504ab229033de9bbd63ae5ae105b9f282ac1e82a3251e03b2955191efed4060db9455710c618f92f4f57f512e5eb8aed02d74d71bcb11c0ec2e9c4e299a8ca72c600954829c32ea7f67f7bd1e1e1f9a9844d9614cd8f5b78da4bc455638707a299050ccdab95ad4d2a91bd9f81288f09225871a358af4ae09ddee54edb7801bd51ee01350924555abd312590b106755314e86b4c6e4daf14fef4d4cc60e7f21827bb45d5612456206a2bc5059010ab52ba3ab568fe9a8e1ff303c4ad6a6ab38de4887af7107b9cd2408d83e154295cf57da5500f0beea88d89854d180389837902504e11ecb1f53270de9d5811ac4224c074463702917194b2c822b8149a4293c1f02c82a688b49a1eb55594927b0d051c06893720d4749e07a417403918c18c2becad3010a9badc01605b18c1e5e37b22c4f508af01ab719701eabc0a7489c5bdd0ad4e9e55a01bdfd295ad85128f288092325df61963020247e7816491842902553f9e4b05668a367639fc7cef98cc6afd0164891bdea9c9c25d386c084dfd13651c7ea16022db893f873e5072e599b55d627f513aa95bd8b1bea372c32893199219199753993a484ef18e8af7930c893b91c5206f254dbd28514a14ff14064365eb1449bfd23165e47cc87593a6a84134292963c87a0bbc8f3e0c12a3ea649bf499b87ec60845c44adea44009bdb273fc21d236ab7e01e0ddc267def96c6474096a8afe1a49f55a2da00a0f30a3fee65047db0d4da64ab1153a01b7c9f7943c0b8e30df564b149b7685a617388d5e2fe1564ab3733c899ab642e91da185d424122d84bf410f2e9e79064e70497869ef50fb9b9d8f463114c403296c93cdcef97415ce4c0a0c5a635d388547f47043c623f3abff46f9c14ab9b5f1c3357198c456d2019a69f448e52f532d8ed2dc474a96522ca1656f0a770f6626abb5384c437ee3857b212b3b88aad59e6b565d8d47b6b79543ad7e0716d3cab2907f512b9069d5c7de3785e068ce7b312d1cdab4765348d658fa6f539a5d8a7306517c8d37113868461bdad4b1f32a7919ad25eec686b1f8f84cea836856a94a07456a51ab56fc96a91be026c15dc5d9c07521a50582f99244e8750f9b6d575e83373dfc4e2605ab5812c920b9a643133ebb282cea0334f71e5437d98da1eddc0f50f36ee7cc78966c6aed662be312c8b1ea311f8ecbd349051c66e0229b54b499a77402f6a3a3f4149e629eb977c58ef0c0ff87f14c8a904ba219f297141efddad5617102021c61a5053ebae4d9c9e40123ca730744ca68a357114b0661da17092f2491aae12c8b9c8aa72d3327723554fa5f75c7a5be608e7a5674ff534e9e82607355abfed7b234eda1a6d6ab9ad3c35814553acb070dc85d0ceb806dcb0f69f71ceb8ce3878d708cc6b848e8319275b90b83a1a72790c117f7ccca65503c5ca178121a89eb47cbf575a7b7388b6143e8d551cf57c085590ad40f9ef56f84945457140875b882166d4a9d22e92a5779fc880595cdb47265f5ed1241bed76eeda69e00eb5d61b272bf792ca393bf73cf5b3a51646851fd5af9f3937981de9abfc75a7aee959e9e2eaebabb5dcd0316e0a7b13ec0a24e67e94cac4375acfccc01cc7496e80738c5d8f5fdc40381d05b8bda1e770541f9630ba1907cce783756c9803efd43f977c8903f59cddec74cd972bea9de860aa5c18db6e4b47e591b265d91ec7d476950bb3fdfd64c8022746c7366a060b451c0b502c9a9e3df5d74035bccfc9d16058f2ef1ec2f5c15c3f966850826cd7aef05814aa51a7918285702938a996dd0c643647b384d4f9bbfb85f70209d4bc1cb9a7b4100c31d220203b88d597acc1d6060e7b986c1b111f9d22a211640b5b8c0e4bb40482e09242ad3c80d6435d2445decffc44d03d8053028147f33ceab88dcab9b78592cf697893df46af231629a8c8b6436090e95ef88b66167b75c7b6fe7ee52edfe56fe2c97e78aaf11c57d9dde7d9c52627399313d27427df2885488164dbbd231b56761df171e81648c14f158de379333e83f9b7e1501e67ae5bdc9330f4d46fe320cb49d2b055d2a18ebbc4dcb008b9e41f1a72d54027cba7687e4419b658e4049b5726eb240e060cf599b58bc06966d5941c8ba904ff337ae8fbfe85fa838065b99e0a049a0b38d3bc5086095ee0d5a298d364eeddb1cd93fc380ae6764d2e8503201393b6284ad90ab557367dae61bd08b604d2bcf81979fd4a643b68764d4c387022799fc7be21083eedc7134f643312578f9fb2d2e6fb1598eca608ff3cf9a49ffd41ed1e525077a9b4f889692d4310515a4cf2c3b2379fd533fb12cd74ed248703ebd74bd544da6b8bfb83f97f39236b916760f5df44423479df36bc6c53c5d4f03c054ac0a85d9076444e85026ef7c4888c483b2c46c010350563f5381bc58b5af76f2698b0f52702a805f1a3cb9a7c5e423186f93532c686d54d9f39c0122c357dc5b01cf2b88b2eb8bc7e18576a30d46308c46075267bf043ad3aa4606f8ecdb15f860c69d4133c03e42c1775ee5ce4c748640e859a20502e97df08009733f5f1e93a8a8a959bacf20cd4b46ce47768cfb268248e00873d8e7e0ec1380948c087419910717c2a385fbe93b5e206d8106729c2b7e6e74896a472c953f9a2f80c82f2f285d1725c272ea735aa949244fc9f7005d2a43d23faac8e788dbe840436f21df1a5c0e11e16159ffeeeb6ecd8850d21ea0187c41cf27aec5783b2c379a04cb65a6c209337ecfcc5433d6df6ee600156b2043b2536eaf00aceb28ccd3a6b86ac0f73e8c9f407950221f1f77768339590766c967c617fc651e0ba92e2dd006d0818e1cd3df05a29d5cb5a5e5da07c69a3617f4bd035874718f4e7b437e20ed2904258405d2d3b1addd8f0c3e92507970281cff5b1618db7ad3a6405a868fa739c2969ea9864d8f1081d203b6628d50f6ceb2c26422fd5920974cb92dc8153227eb4e482bf12802fc626fba616b9cb30cf3f087ebec37f8033ab4bce2cd1e0c5e5886cbdf6fbff038784f9179ac2800608f0175a8ff5745361ba60d3835273e0d1eee2d1437e2f7f8fff57be2baf823d78bf19be36b1a485b84031c8075097e19a71e8ae80882dd92b507b67152011f2d3c737bda76db5d1d316f01efaf9e0ed0fa11738f5e8808e08adeca6ef235aad17838e0bd7cbf4b15c53ec793286025f6fff9fe46ec95637e1e095e5dbb8f8a115ca14baa15e373c5816d386c00acc88dd1a3e472e4692b1960d082ad5e8a062a953ae6d220529e4ca67f17df9bc69cc2903db8e41ee9d7ae41d63d56bc0dfe076790456f18bb160b7fce44df852d73d6067791eae69d6e9b06c0d8739433d988f0fc769f31e2c298b9ad0db0dfc0aff0a22f6b3c008d09c906b081c7131a886c5941c2d9e79c7db5303ec6e504c7b7e3cf24d28bfec4aa12247af47f3d5171d5d9dac0fec0387de709201f235138832da48a3432ed961ea72a140420a48a820c8676a9449b62e2cad85f63f64e779ae341898cb722d6b5242a1cbc49b43c43022c895d864a772881ac87423db7a94fff7df2d763957156e1b0dc2431f6545b9603ae4ab2838e0a5d7e42780ed6121e4548ff02959e8ac6581eb102060fc1bf5738c7321d4e5477cc73ca51388e1603e00fd6580b4064561c004a4796ce7c0f0d561e416a1a48ba26a5542456b4f46a38490c4cc5dc4f826fef82c8eeab2aee892b78dc7de1363c86b019d5d4817f067eb7a8722575ded07e5397b727081a1c00e90388dc9ba09c21fd16b23ff72a1fdaddb012e174579ea4290d4709511fe0572de5df6f1beba6054d3e8dddd03342e817ca82384b9c487db5ca88a4e1b73fdf500dcde5d47a419419212a025ed51b6e64cb18310994d6c36a95b7b8e1cdcfa4a27d917ac8f10247e40a03f56497894bc86cb3345863c7ff0dacc3f602c0275e46e4c58d126a59e171544622cdf587776645ce89df8007a086d9f1b786b7c50040e4bceab847c2d9fac05bea40a6848f6ffebee3fd053e30aa6803d0e9136b22639d1bca08785ae8fda927a81959ea3b13c84b7081afe73e1215c97bfee0458580d59453c853ccdab3447149d260a9f93f960aca9e5949f7a2ca6f7aeec4c8769a2f4738d79c632bcc2ea737ef4482cffd457f0658d4ca8874a7140ff6e76d9dc05616ca4ce82bd05b7402c3e18103f7e21b1db179a121a823043777d7ac698a8fda28be778df475629d4e64572b4ca5061656040ba3ba79cc3299c14aabe35baa2b457232c12d150a4e9e0d3b7a4fefea3e3815fe300a090e6c6be04e8fa511f7d9a65112d3a48e35fb97a03077500ca39f10dc249dfaa7ce67edd05501135aaf30cd2935eb06de6f204149e60d41099dc619a236b7d20634209c318138f3216a69a1c9770e4c3bc0999b33f23c2be1ac6cc98e1f48b4da194ca9106f257c8449dcbbdc525b7023261ba145fc4e616b1f0094559b7942176c7824f3969be8c09eba3fe4310ff76dd5ef39b018990db75217b3ed7577815e1b96ec5c271f1bb8d6ff53d859ea0c980335217e24324d4ac1fd5581b6483f199990c6dff014f0a6c7b46ffd0fdc1d035ab33d595930dad53607e5c8dc585e72aa45b8863fd60f0e78af06e43efed81b58131b6b27d4b4fbc55899a3031d56ec65d89c91a1060a27c1604690d718705a8e83f9457e7f9e6c1d0803e0fe7bf2e049fe9f8fd2464b9b249152ca94646205860574053e45755a29469c4cbd47d662f9567a29a59ebd3806eb9ab8f7d251278aab64431b924e4c8200b14aac6889946559966559965f7ef9e5975f3ecd975f7ef9e5975fbe17923165d08636b440acf811c9164869436bc3907c7d98ef67aa4aaee4743a9d4e65792a4fe5a93c95211b96655896362c4b1af35f9665f9e597effd7f59e2adafa0c39e96b021b640ca29eee28fe1644bb2a17b5d156c68c37074981a86a10d6d68c397ab34030c2349154e766fce7064dba8497cfed7a84d4eca904206bb94fdc514a394d20bf3b277af4ab9d9a3fb18dbae05c7fcf0eb303fdcd590922dfe8b81b2cf2ac8bf0b5444d3ba4e52fb730139ae6c67cf9bab0a5384385d40eb77398b4c8395bc3ce62ddc2bf71572104eee63c67ac4324692363732aca6871e3ae9c4c483003129119d084729c7711cb771383f080cfcd1673961ba143e7fd6e74a702cda86ff681adc4731c5077a0ffc89b6d1393c98a61a8073f5351318cd976841b37eb40d9f4247ac29dfe3f09e3db9f3e03931beb66aa7b40d1ad2144c01838ebc851df3cefd4ee5b40d6fa552ad9c0b7b8bd56a1b1ca6651bf66d4a350d7fae33a59c06d399985eb7ba065ef87c4c42071eb23c4aa93dd8ac1437e23ab57d380ab930f470348249c3075238bda0280f3dec74b84dcbb0e63167f4f0416524b9234a29a594524a299d18e7fcf9fc87a80ae35528346766df20d8a30898a04b8f7895af4d05640a2a910f2158562511f742784c2d51e76f673b140d8ad22d681628ea0485eae137fcf862b22ccb2e1a97c025a2a64b494b391d3a0c8d6a5d0b0fdadfd741cb287d8c7eefc0ec077af8eb073ebdd8fe3862c6d829a0e60a35572857425128cce650da36f8b9cea6c53eadb97ef02b07ca3f1c4551144551144551144551d4bda19110c2d0462770220bd4a3380c3a800043eebf66cb081530c678bb19085317f1da22d9f5393add17395618c3b21a343964e4755dd73499ae1d95da1db9acd4e693bfbd817df695ce15ad533401840483115a26922a884832917600294b20330048e43967dc073d938934994c26934966fb81c1efee340a72fab6ab967620d6e1f9f953dad54c8d408de3691545892a0999836a728de3d829cf7d918c580a96923d675b1ea198353899550c804963219988ef68d2c4a2f965d883e1513c67005a64fa9d8f233e4670a6625471f538f2e0466c15c2e73bda862b691ade4614610a57620425aa2528811c57230e57e24a708cd738625ca372857d52366181a1cab1a9944629f574321319ec548c4aff1472a5c9b142ad344dd33c1d4f87b1bdae9661d85e375585154d581bb76d1cdeb86de3f0c66d1b87b7546adb36ef25b4790c1bd0cb5ace89dc14881e33f84fc76b0ba2584a3d218212726a624a8245b1568cf1171983583948a886babc94fcda637d755d0dc5ba0ed234b80e420a1264073a08d28320a828c49448ae3872ce5967d5461a83c5b410af61ced42fb848824344c6a1f8ca552a8ce17f956a6555f831ecf157ac93a12efecd64013e84593d0a93cf875059b6e322759d7380ab542a95b52fab8d8806843585aa6e0200838cdd8729ba6e7713864c43eee59c73d79b5a2f16dcebe14904217e3deddbddb79b826677d3a7d76317c83eb6f4de7befe6850c7eea67738cfd3f14b04891bd2f640a81ac83c5f5ae8b8b32e79cd66698bd40c8321b17727d50a60273e5f3b7995d4c61b6ecf0813cec1235c3de5a6b6d6685ec9915727337441081ee8af495d1227fdb9b9a1f993e58e307ac0f9c2b1afcf3214992bcf7254496aebeae797154a4722453cdf615b95ab739b8901ebc5f6b9cf93db6eceb532f5d7fbb52069adb83738b1c201ea20e39508b38ec8b21438e5c6ee370d4dc9426ea9b3d67164eaaf03172a2078d691199fbcbe15199938cfa9426fea02e8c658a1013dc6863e17ae374fc9024cbb4d30fee614964ee734b877bfe3fb8e7bf83a344d091e70fc2f3f9c10683e32ce0f9dcd22a2a313a1ff957de07d7e5ce07d739c863f437b017f58ac6ac742ddac7985ad72201ee57de022a1fa30bc2a3d279ae9ba20e688a3ca029ea96c3b4683fc4a7817f611886611a913a52977aea247d726fac25ed63b8df3aedb5ecbb3522d5544b602d655ced50cb6853ac9a6a69eb8a700fd6d2a804aa715243b4711c4712d7d295611a892d79d552b6d512564b9ab6615ab66d9bb665dbb665188661d80f2e9381190c06ff055367b2a9c5bc625ad1812ec568b46dde8bbbd490c18126071ca81986d4596bd79e329ece26e3b99bcdba2b32fdb985429a0efed3fbb7d66b1c845a6bad1d155e593aacdd42097b10dc6a6152eb6412932426afebbaae2773c64a53355902164d7247c3224f56aba80da60daec89ce93cd7f512260d876927d3f3f7c6a2499324258720ddbb45b65ae410414c1b4d360de736ad5bd98f16d96a915ce7d2c1c241692b8c1285c17a7466bcd036b6566bed5cabd4225b64a9d52a795a2d4f89eb783cad96c78343c7699082b5d68a22c639ff6b1fcd8de7a8a190e7e5bef7da720b916ba9c1307cc21fc6e00cb75dc015007cce8217e459679d2dfdf88710cdcf067bfc36d8e3164c9ba29aadc51275c1c0206a218af7be84481d23cc39efbc5bb4966d91e99555f22c45d0319e0c2928c20b9fff006cd04ff17ded9b86c5b6cec7111f5b37b51d884ba6a0b4b71c8ef97518688b4ceb4f6e87ecc33bf4e31bb82ba239e77d5eeeb82ead7c42a7d3e9e42cc34a0c337c5e064b0c510534452b20950c6a510cdd8f23d8b3fc87a5e333c8685106b98805f42023842812e3697c72376a10f9597e05d4b2a2f247f011ed8710cd009aa24f86719b8e180ed01a484706c845193445db16e33d5088ca5017acab9d9597e163f818cf926198eb1ccc029a2dd218191eb33c986374169dc7d1438dcd8d0f397ed001844aee782787ec743a9dd99d4ea7d3c99f19c3097905bf4a1325a81edab74c974c6d24c98925460c31805838cee3a1c901877b3dd4d8b877d33fe800c2bdc65ea094524a29a594d29e349c93e5edd7183f6bf8a60058e0a35a648a669195b7b1a295ce8710a2958f010ab1688a3416509f20758396c89770210c51a4f9114c9c208a348a8223986089b47a04a9092d91664f80d30529d2ee14486a8012691793205c4125d230145054220d2b021454a148cb84ec201469dac602ea2751842b91b66d2ca036c2881ba4441ab7b180ba0826544889b44eee84c0f3d5074d26478c1889b4012cc94f54bee24c1bfea4690871184c9c3397e7b36a25cb790b3b4f2912d3e355b5c49c73deaeb6e68c2fe68c279f4a075622a52ac4fd49dba8389346eec0ca8433e173fb2bee7d6c2892413b6ab9401a4259d1987ca3380c062fcb8e62bc2562ce99edc5061a3a7634b16ca29e8ec807da519de29eab3a1d8b4bf2d90e94d9280d69d8aa3046476d10af87e1741ad2b08661188634b4f6e596d955be18eff5ec23ce0ec018a6d9bdb53692318f5266cccffe721ce013350b8f34d4c54e549da84a1b06398274a152428ebb5add253587aa0b25b0c6d5683bc085942f56f77a09d5f03c29c158ad30cef93fc7531ca190e7652e2efe8f13f185141c0018e48f98c15ead1ca673accd716f6e3169f48a0aab1386e9c8844194e3c175e05f57dd884bbe21efb460ce894321defa8155b9bac77814dfb0cd5952664c06006cafac7316f690738693e9e2bff2e273af24968f72fe7c7c544953e54bc8988b9e9488d9b91467b9776d6dc14d0dc3bf303d475123a68bbf14244aa22a70161593b88f95847125a9703e82290916c5b6d65a6e7bae7beae2e07f18ee66c2b611ad1e6dc3a604d75eab65afaa3db40e773219c6183f6e1b3a7a4c7c84c76ed6a6a6ea7a11258aa2288aa11a353659d45ae76ceca2fa824c5f730fab9cd18b0cce32026ee4ebef20d41b5399c1df8ee3388ee3bda1910bafebbae6e4ba0f253f9e4fae992e2e8009865c43155ef3e347f6d8ffd87ad42175116f6ac81a92478fa68bff689251c85f230ab98507017cfdb4fb40ff7f5dcb0eff5d8fb300041924d1852d82a08552047687795c2928a145175f37a7838c530627596373e303d7d1e2aa21a37531e7acb356ecf3c7d35a7b85464411a191a99a53b5aa610d925347505a1508ebaa54dddd1da2636fdb5328582ba20926910f219a481729d191d9796780e763541ea4513e5a2ad1122d8d4a9a66b79e344e04db69d756b56dabda76752ad59c69fab967ebfcf643883815ee8710691d100da94b8b4dfecee78e862d990a25659fb3ced3d11235512a326847d9db133dd9d169644fa3d3a87b85655bd6cd3963b37fb9fb58afb88d82f4823aaaac7553d5c861ee4a4557aa95ea5af14156a9ee6d194f5cd7cde5836a03d7755d97733756e4f999f63df86fa0ff5cef85643006d1e4e01e8e1e40a522c66661f39bd5d92ecf59af8b5bde139ff4095bdec4a1987ecac950fc496a625fd2232715e0d3beb62dd01b8dba4755f491f8d51a02716f840251263455494dc345da8d843811235ae7237519cd1944883ef2d168f4987a4569d6a2c874a6711e001dd3316811fc64568b22bb1645ee0ffc7c9f6cfbcc19ef743a38e2e7b3849a2a52f173823cb96e063d3a4b02eb01d7389c0e2bc8af850cce164e0cdac59190728044132d22c960e8a3223645418aa2288a62ad9d1f4c1ba0c8f33b5a9669dfb1d66e3ee6143e602214f9b85e080f293a72fb7998f6825a76b83f5da5bad7407ee0c7ba2258868b4075f48218d4757e1d9b0ef795abe97c77b8ac6e71f30495fdd168341addfb121a6952e8a9892909a694528a67eba3df4adc05479c2871a2c497cf3452d20ca5826b65328daa9c24a4911494131393c9f484c94d3e254ac95af156cbd432511c984c485a2d8bb24b9a4c319551587346e5e20a5df8dc3e685354455d4ca696a9656ab54c36c8df72fdfcaed4d5c42f158d59b99e78a916148fe9b28a19e3a4542a954a792e219fd4674fd4c55b4e52d99469cea04adc85e2c0549a4a53d932b5544b98584c399b4ca4c96432994cd70a0c20b40199265babaad86d0cc3b02539866f080df15f7f6d13a9a1e44dc6f2f939038446413748327d709236ee79dfc74fe96dadc66168cc0f3537b4cb51ae7a24ee28cbb2eceeeed6b29a39a736b5d63410f7f5c7075bde344dd3b4a7716d730fc7d542d74a69571965c6d7b5d61e31abfdda3d8d5f208caf8b3a6a9cac3975ec1089f0002214d262e9506121d77b6f8dc145fe0ffcd0f4efc075bf7ecdbd5173df723740e045188d829e73ceee401503584b336248dc7b2fbeeebdf7d2eb567bafb5b8de8de534978c4c4a46ec88030799d2c8ac7d77c39165a426c284c9e19ef5c04c5d92df3bfa7e942cfe74b807f381e9f9f370ef0324989e5b92ed20006814a0a8708232423a31b15fe9052253831ee10371f83a1a2c0f6f71407f1ef26bd9c1437efd1ef2ebaebf1607f4d7b2c34f2490beeeecf7a41225914824128944ba3744ea187177afdd3d8634a626c9c964c4f675f12b810411a2dd6ab28cb465abbf6f4eeedf98e47104e2030022b93ef83a34c78300be3a031872f6f87176cf823a3e903e109faf3e8d8fa036b9974b2cd94734943503b5d4faf9d86cdf22feb40de4b5d85246c6fbe914db2abb2bc5ad467bb04b353fb00efbabcbba161bfc6204feebd1bd5a06711797d265d865d865d865d865f8a2a2827d9354f6aac3322ccbb22c4b6b5fca184ca04e27146b0a9395125594d493d309632ce5ca329f33442efc099281c4b4f8449c928373c8669c7d76b91b7d5a32636a6af83e594c27a793a8042b419d5a6082214af04dd2de93b34e18630cabb141dd40ca1778d049e183dab60ddbb0ee31fe1504e6fe911a615b66b047d5da17952f68d6da69a7c51d1b5bd3384204492484d664145d3f2f900f7e4377b70f5b6be0e694c1900acc21b7f75e5c20bd7365ec7018eb27db699526398d27c8f56ac2ca8a528a1208655fc103d58884095648018491342a41c2c1109c71f45e42b4c385765d2fb9862d642b10d7556bbd735a4f167d5517c624d684d32a8a1255123207d5e48ea3aa474a2bbd51a96846158db9c944594959b8062bf2a42e2fc83a8fba786800a50cf6489be8aa010e64e0a655f6e80a3d5aad3b8ee3385e17e785cbc0b6dee762528fc6e76f593e9a61b08690b135c3bec4f45cc084a906a37164afeb3611482881d3a3ab464db9412142134f89d290bbd3a0b134e744067b341aed20f7e0e19edf7882f60ba533d4d3c57638c820a6251d6cdbb6b57a6cdbb66d1dcffbcf4a6470b63e70b2b2fd56aba58282eadce4a03a76c86053065b01711c4d0e387aa8b1b9f121c70f9ece6a73ec8566ad9d765ed8cf8bf1cda670041654221f42d0a0c24a1465ef43081a56c84288487b2166167250240aa2ad6fb801c4e1f3cfe14f83835540a72b420efd10419d3316490f69daadea97698c942fb81ba150180a3b0c851348c04d08019309d38a9950088970088e1234eebd84b073a75a6f46a50b46f7de1fe4fc00ca144d9053349102711f3781918c93e8fa16283214597c6837eeeea57a363e3428a24b850fc0f8c0a9f201111d50aedbc950971c2e0d122a3e70b27a3055d5da9266e4de712ccb1d9f4ff9293f234ea271eebdf7ca9052d3552c91b14506272902df8164361473890c2394423bc4aa6d35ddddf1a9187bf083e149624badb5f45a0ce49f18a3753cdcc5ffab3b505fcdb99da3c0052600030d683b546050426b5c8d754790107c11da71af2b546305061a8b00df9c12c5dd2f56b7680c0de70c28c6d7a45a0330258bd9635bafebba2e989c6f5c1de8e3bb78f8879f86ee91420a84843b0a7d5c3a4ce91e48451cdbcf4e87fbad0b627b6e7bae1b421404f79d0c743e3f7d95ce67117e5af2803a201ca2f6da6f8f3d2b88edb5b7400bee2ca0fdd65151744ca7d0162d411a8496301948e4e11fedeffa9a6538e6873b1ede3474984ab32830bfe811cd4a352bc5eae80f2125d13d275e16de161e0ed6c562b1582c16c65e8e62db5a6a69cb58eb323273a63ffc7692572783657e166152978f0a191742768cfd6554f6de1a342a5582d184c5643585848275a94bd376bd2297ba346738b144c74fcba7a2fd8794431f7dca074d29b207f1cdaec8a539d3ff83bbb80fee6203039386ff8c06e60c77ee060ff7ae07bb74030cec9b9c0e334aa67d373bae86325513bb8175ad2a92c12ea14aa55229c707f740aa9b39c33327d5cea6811f43a1b2ac860c0e3452604c92d9c74c4336b96d5c6419b68d66ce601f27e348c6e29250f03fee36f206c69d4291ddc6fd9cdd3daebfd129cd094992645ed180a13a94a8c5c0d62776d0597d630c04cfd71d0e3232d78533a4858316929648e2e93c264a85802924896173860c0ea4e6311821b5bb975d204e51d92d2832385b94bed8da897da23f421f6d3320cd39ebac5a5649b4da11574b29a55893b06fd29ce990c6ef0fac94c126913e0f88b130580eb30a50c06c8a0893c6942839547cce240559cbb08d524924128944b2f6a563857befbc531445ea7934a48d628be258924183eca1b73c9bf8b1ff74596eac2124113853b7033ff5ebae676022b78c26641f0d046708a70cb7484b5ad2520cdd7075a077832dcb39430cb2add124947a61e2a16c5032039939ef17e2de776df45b88d77879b1c1061a3eb16c510740684d42b69f13294d454585eb171d667ef4c39cc8ff953cc0f96cb0fff8b3b7d1402dfdddca402dddd574495dfc4b20ccdba1bbea5e0b71af4527f93ff1092a7ca08fa6286f5996652903671cc7d32a8a1255123207d5641ce99c18ff77163295a9e99691e971cefcf56559d6cf910cf6785d374a669fcaa8840e7a64c968040008405000831500001800068442a16040302094cdc37a14000d577a3e805e401c48644916c46008a2903186190288018000019299425500c62fcfd202af25a3cede476926b63f2a54c0fc9206d818fc040159cf0a4f6aefc8f07baa91e60ed749d43d2b2075d1742bcd3bb80fa7945c6b03d62f00a582e2d7e383ff660afdfb19659cc6015385c8a50af437bcd7837524f7e494b6b04eac50e64b6d2bfa44c81c8133c6b6b6e73ced05c1a6c24ed55d67c4e793a6a61b9a093193f59769678b8a9688a82c81b1de893b294755e589a146de29e630e9526c64172833fec060d2124d7fa25cf39990a45895a744f0967917d7c338afacc4d92b9f99e2f1427963fb6d07bbcace34e5bdacc0d7fa2d28aa0865e6ecdeb93f5f49cd395c52ea42f19c6a8e88b23f8427b54f294d5953230599815eff254d31dc54b89aec8180f0f077c75465fd946cec4cf1462a94c23935156412b78c13bc3b0c5dceab9ada90ac8ab60db5aefa194ea07c7797fe8537843952fd2c2fcfa626275d37e31da9e4ccf61327d44dabe18340429de298001def786b431a7ce3484191777928e9314ced8158c3ea8e836b83a3ac51886c4e8d470523b04b12c0e8dc2eeecde12a9cc60f7b6ebff74d1b80f0527e7c2677df060728f3455f7a41ec225d68c8fd8579603fa9d283b0b1c37a7e5568a19c1b3586e2830b848d02e99c4dddaca53fc844f1a25075c611859fc4e19206d7511e6e3c024201e88d02ca61076ff5210056b04017c2c22a71ee401e494bd4f7f985fefd0eaa0e459f1b64a5c723c562ea632c58793adabfded5ef5542a57da5716045e64bec5801589356b54dd105eae52abd44ac0d454f65a70cfcdc7553f8844295d833232334965459bcb2bb59dc359b221cc1e6541b33ba8bdd2994ec0e1b34f1aef368c5baf83d472599f6467bc44adc24ae290a6d0b8a8ac76bf3d42a0fc9f668b18bc958f481124b044e07f00618073b1925e58c15c162a9b830bd28f0e61c41b2629abac63472c652f087b0676e3b2d85f830ffd62ac5e22d87846f368b9a357c2249ce95e10fb9080af3a98176a217ff4d3d00a6e4bbc6cb81877c78e0356ccfb560260c3eac23fa2d9664fd88a11e08fdedd7cb6ec92ccd8b522a1d41008cc3c232bb64545679de519890597285d53b2671ffdbcb0dea41897c74d49caf1341b38640217cdb816821984cd168191389176c94cfeb9e17e068949687149e541f57a3f69ca67466f159c142a3af050b1549b8978345f8029501125fd07cc395a18741557f54496a191439f69def98e4ebd420bd64219404b58f3c91af362336cffa5c9eb0e42640bec22829b772c9eede40fd4903d2869df7778f7ecedd5774f4b100e746776a2fdde95ca10a3feb74a75ed01bccbd4516c332926999679fa8951155178a92b9c692a0ff1e3bb012689f538ffd11e70539114f90a13b0da116f6e3c87c8860ea453c91c4518a98921d5c6162d4972b74900ae45fcd8753cc61c5370c9d9e11ded5ad755fe3d0732817759f78221afb637ec7c57e3993e30fd67becbf4ae2db726811d0ddede8ec02734a435f2b192e4c8217c0ec681c956644890b25453d4b6bb720b1302676c43213334d24ad2b627409b327d1bec1ee3f06fcf0cf2811089ca9eb4326473277dc27d2523161c5617e954bca0df6c2a9654d1c3c4ac6719087917a382dc680231256c87b822c5a9e22c8c20d0035e542af3649632d6a533983ce8842a5e13b6482689a6641792c004890c1f19842737664dcdc43b4dc79fe6452dad542b3c48a7ddbf4fd26ec1b3b4be258c89f982de888620b28d7aefb09c469da0dda58e9282b58092d48f7e06fb59753701b436c87777b513159b43ce6aa785751a5b7a13fda5703f485c159a418ef0c1cb98b569e23eb32ad5bd151c5a4f75409c3e966de62d24c66c405825a5caf780d4868827bbb2efe6ef83e3543fada09ee8acd91b92a9b0a426799ed9a2b40bab7a9abc3c5db38cf3fe312c2424237a6ed5cd106d07b71e64f297a4626c30f4afbe78e2325258c0087b639dc9683ef76edc4dde00a1a83b73fcea0e18651830b82d60940785535eb302f5506faa736f3df332b86579a9a462e8880934aefc18270b8aa317628cbd245e60eadf848b366b064eceb7d199d023bf3f16100a7b4247af47512ca48b29a84359047501d7014628363ab2d0c0942d7f851b8cfc5375d3a63dad817a3b8aea4733952284530a9b16fab7827aa40cb3a437d74f5925b64dc5c9ea6ebba9a5c47bc79474b1cbaac42e3d8e96c8eac84225f706d16e113eed66a1b265f84ee753c6521a063f4b09ca749bb03cf7caa3a76c7f69e8b1f1fcfb99dcedbb67f5d3ad68d2390b39759ea25be59ba325308a46b3023a49c08630957c34f3ae33cb446b0b5c9b5e9526978bf55862dcc9afef56b072f2ead393efa23f8971793aca9c6213419acf51fad0cb2b6c17993ac0a27d94827d9e38e3a8725b527595ca7014cc4496c734fe964eddba4eec1b5bc25595712997d68405793ecb08b2cbaaf88c396dc02201d1baad3daa4ceaf59775714fa3cbd06802c95878d0f3431633bf964fe213e9cf56e1cbea79aff2313b56781c3b8dbf7e13aaa0849bfba71b82643208a9f129918a03d868e86987b589aa90fcfec0b7c3c4e4bb58691cb1b64593e2d5d923d4ad3175c5cc0f5173beb928e59f8bb6840abb9f8eafc30ed483b8fdd9d245afff0c2ae7cefa90b6d35de87e1e1ee29d862cd3885499143fb27d970e85722c5c52cbb3ebf78ad6d0e58a9cc5f238cb86d06ddc69ee718b9286c15cb7108c70aba2b3e70a0a23568e62a0943c745060c106e314443933b9a5e18adcfb1ad909891b11eb136071dc8c5507267982866d613a0ad7388ab6c2bc329d5ed826cfc012a76f19c9a3988218e8294067e7c5dbed236ceeb30619a490a95906d44546fb7fd59222729df91a7a510eebbdd71ac0972b124012f970c39b4159582f8f0850e028d6fb234f1244a00d7d4bc171e21ce81ca925d2e2afbd23d4a56eb6a5023d7193fb1546da43da033abc5fb0f2f2bc3f54290fa6d20c8bf6047381407fad8c58c7a92af6d5b0514ae1e97e74670e750a1d0d976830681fcc6e292f87305515ba69d0a87b0f01dd8436d5a65b0d7dddd1c1a4353ac00f33e38446398d9f5744f1deaeeb4e2e164462740eb0d351137a8b3e5d63c9362a538e21928fed3076071d05c96d070ceac4705076eed0a1f266c64a22826c8cd4769cee50b3a53303fc4a5bbd4e210c0d2645487d0fcbd224d63d8a5eb6be5ea590c1893c18a1f5a3c2c68d287343f743bd6d904ea00c0804893ecf34395237e5372b59889ba0c9d1fa2e302d13c2e94a021aa63df3faa3e80bf1eba8f27120e25845ae8358c62998a84a232c5b43d11a4f275bf5aea2ec8c1bab9842ea2614ec2ee030530a52ba9101eab409698f939c7e1206d1aa3199288e860906bf12451fb6a486c9a6c6bbf9bd75fc25246bb6136bbcf4719ebd4212226e7b97ec531c84c31f66904e631171ed4d55c2d0380c682eb5f7b8a837f3b0ccc8dca8ee36381b7f5cc9267ddc4051203afcde2315f9d4f4612538025cee70a924a19ca6620035decde70fbf2ccede068b1ddb27b9edb09e66d03ed5aece4938ac49a8edee848260b224bfd6e7962d97ee60f805d230c8d1dd279911c49c01ba0f7a87b04075784ed76de05730e121c45a9043a483b9a235152f0964b3a2878527cb45ebce69eac7dbb2ad2021d8d3e9178189e9f73a0b671b28a2384421a7aaad69ed778b30e8e077e63a7173e756f25240fbe40ad1e69156ef56843d75efa0742a11efea63ae4d076295fbe6fa481a0417f63b7b1e5eed1b5628f40e3c78686b2a31587c1be4a591bfa28626150f583d0bde714e8ab8c753552a4f6ab55f77010a542cba9d000980deb78a603befa003f74ba29b677d53a72da7eff92310c0428693d5ee7fbe99b32f5d4b6fe01c78a5563afef4336d82e1e2214e2db9389226a958270abe5b7264cf60315f5925058e87bef5637502b2313265f7a7d268c1bb5ada9008fd6c01da67c69980ee4761022d52020a4e2eea3a905fc41783f12068291f85803b834847ab62adc49313ed6f52c87ae37eb8f5204fdb9699cbcd6887dba04511866690ac16199ab8cc8c7b0827dd10608367e664cd177b3758d2d1d3a2bb8e7ae8e62175da57d71b007a244438b459b49ebd2aa139882d373b52acb6852b1bf4fe480a6e351d3a6847ecc255e889ab30701322702ac1f31cbfaa16fdf60526665a88cd1ba9414600720906d97969b2ec9cc8dbea16bb005cdd17ffaa4b2eca181e279fabd82e3734013b7c862760ce382162675d95269bc90612924f1fab6e883ac02697a89a58d4e89f567a4373ebd3bd0bbd279d5d20bde63ff24dc10cb2fe235f7a5c3735f09c3529571ca80b6c9dd9b078fa726bf31555992765c38c5c6480a32da180196656575e9bc1044b9758bce811411fcf7d2f79b2632ba4bb46e4f9c1a949e19f07684770459bc3546a743fc4daed6874e254238b7ec78120514ad4e40858343c960ac18ba84ba168b793da5daa2748615689ed5e1f8d6b3a669b61bb2c0755e472892b60e97f16e0e08557544c43e12ebeff854cdf4a867343e8c32c570b8549879b5f3e323d5efce881b44d5298a23f8d1ad7e026c2df0c58fdbad2a1d1f57286163fd8faf0414fbd9f38be581b686316684b50c2a5fa6a54e2b41462f21a7d503f3aac04aac67c142060662c32aa1273d0dc0f8fb4499947ea15c2d629b125694007e3aabaaad95c1c475def01edc2243c1529e16f86c6bee1cbbcb233b38414f8f800c2ed772f81ea9a89a67405e8db86dce67ac1e266818a31a1dae67ae4f0053697d01f3190302d1de03d40a878cd722ffaaa693647f36581f2b4427c7070a17948e194be98e3eee1b62663f5c03944cd88462c01711e99d943610a93f2351147d0e02f2633a9074efd3295c7f0fb9b3c6c1994c911950e2c2e8170e98f0c85656dcbf80bcda19af36be7951e1d634b7c154a5861e3df779586ad4ac54c34c42e00323b66e1c3f6ce7ae6688a4b7aea13d433bbc017a036ec43ceb13e264e04141a93ddb719f9b3c41cce03eccdadfb9e8ba4ab95dfbd3712054ee8c846cab5f936aab94c202c0a2949f90c9bbb9937ddca230fbdfb10a35fd5b6082487f18eadaa173926a8324017ccf81574eaad92f8ddc70d4585b75e34e82c643d70dae5a300e26ab120bebb5a83c12917324849b9b8f1c5bdf154af4ac99435cb445eb02128417149b91c116081bda59aaf18140ef2bc55207ae028835fa038ca06210bbfb11ac43c50a7657c687a24508b74ed3a693f1a174261006d245692616a5fa3618ef21138a308bc0b946efdd1d8fda64d15e9256b637ad0ef58f0bd7e7a0982f7ef138555a04b57c695924fbc242f4c9acb15afa8416d5284f21424517312199d119dde35c73bd8625e7a54d7d266eeedbadf38b837c9fee88fda35690429069b43fea9282e84d47117a465160878ac87ac67df5bbfa8345a3f86fee172bfff0c0a2184e9914a09b02dc3d5e5f9aca70c70c4db170e68cfa030975008de8a28e2e9b124792d0606fcce338d5e11dc1121afcb516011f4167a9f56430654665c78ce470fa902e53ae49807a477eb9e6fb4e03beea5c03eaa5423744e0ac17d1abc548ce8989854726e764ac4b1c109c490064d77c6ab5d3f9302370a9143a13824f53e13288f9d5b1da91cef3031d3074afd2dbb3cf4a6d7e9c13bae16a0e108297d07e69e248354e6d527f76d9a617475cb14085ac564085c80276dc57d4b6a41031a3feab429dc45e61b3d19abc7582622174e7f81d6337aa97ca672a64d5562679c80d9dccfcb8abb6397cd7f8527c7fbeb5af40ae8e64b4a278b23dfcd0bbb6030ae95940ed9d30f21281fb21abed9ee79ef14c78dceda006d7b6100514d9da46ca952809d4d42f8ae722c9dcbec8f9365eaf22820ac3b907dd7ccff00b164bb74fc3fb8e26ce70e49d8fbd5289cbc4e3198515d2e80ec75eb1f728a6cee7a557ac117f0cd8f189c55134ffe12cd95da9976b9dc750c1b48cbb805f6e6a0e8e928d4cb407eb2da462aa9deb1c0ea86a0a5fbdf9528b5af05241d8519c745ebf80d00271df256a2969e7c6a0be9c8ee8b8bba52ae4f9b12b2c1f7e1f6c6cce1241beec981d945d15d3557a61078c11cf3f229e81f670ab09f7aad3bbc055fb5d2d3d16912d8ab7013d1db96cfcea00e5d10f5c5201aea9dd38d4823f563839eb0e60c862e46d7f228f75acde2270c01685e8994854fe83ee3fbfe42350f4bec63245bdddc83de2640a841670c1e67965d181850347ce1118bc8e69f630e7036f374b6f382e7a6f5d065098bc505d3bf725c4128a4ef7e2a06facb1878d8d2db970ba5d807040a4a4e7d5ebfaf993092dc170719ebfe63cea2f025a64dba471b110192343732696ddef6f38e5fa7e8eac7115758fb971745998cf4e0736073a719a537b3e16d89e999ee0f0f244052adff6fdf2cb6a84b37b71ced93c9915bcaa99f23b01f674cea1600da4f57ed62664d4f120e8da4a1843612b108688b5938086ef15b7e460a15bbc0978e60c7a087725c212cdbb0a062b5d93e5d12792641c4f3bbcc128c8e6ed5ccc0851778ba5861aa36a35bc8fbc4caf891a2fbba244a7d76994c7e7fd1f2cf449613c71b72f16ba0029fb0191e93b45261e64a74832ae3c1ffd1982e5ecb7157024bafd75c1e5812ddc30591b09fd2e72e95fcf45b060c5a2ce914234cb65d1acf974629f98f274ed0903602a73a6391f4f6bf702b8cbd9a18a4ac92b075260403941e4fd136500848f702375294b3b47ef6e78e0499b33e4deb9cb658714d2219cbb93f422d78fa87f17553eba3224871548bf275b646056b6514009fb8a6032fc0e9409750f177df7f303987bdd75cccbab3789b56c794ec7f85e6fb232c4de00a4cd6e03d8ea308b25dc3dee58fa5762708185c82bf88278b96d8e305c9453c5b830103dcee14fd87d1f76da413cb7a8cd30f2e878fa02eae90bac34967f7120a7379d0e0f528db0382a694bfeec64f772e546346ff0170137718ec7d2a33bb4acf155a03f18eac426612784d1ef466f4a258081482589ad54204e5997f3e92c2c1b08190ac78fd80aff472a37ba9731cf50f6c9f56afe1109ad1af84d10bf5ce63ff9c609860912d3b6c06ee193d855de9ef3b41049b757f5ab942cdc0df858e16139267780795e100e04503cf320a1fe06e3a451719a441e40cb9d0e78dad4095f62094a27b7b437232895bc338f5ba0b4938f4cdc406942722940c851e5cfdfc4b93691bd718fd4eaddb71d050fb1c37cce18dc3617782509c7175bd3625fd4b0d9e89606eb7fb2b00a0ed54839804260142eb72a4477fa1c331734e13798affb63729d209edbf4a50c4ca900a98bb4a0f358291ab785632966ba14b57b92ad73e04fcb49e963d07fa266dd8a050cb1d6a95eaa7c18a8c225502e5cf8d4bcccf453f5998aa177e5a5a53130ebfce7c7d7e76ee4c6668412a52a044d6fc987dcc133df96880185254081c738184688e7dfa69fade9376b03d5929143d3e480eb9d3d79c42865384e3f24eca2294d5a8dd6947442cd3ee8c2400cf18127261846273c3362956c65b11a2ad147e658006d611c68fd564d557e73e988ed819ad84c9b5454455adb63458d31bb7d121ecbde3e5e98476d89485bf05aea48ac27112c4c6e1dc68435c69467617ef027f76b7f65ea0cbb34b5c44ca0d8096aeae18832b541f515cb59bb64f6a08f7d8b69314824368fd2f081db48c7ef890c3b7799afa9d2c18201ab1b2202f2e42dc8f672e13f0c9a2be755776c3772181490b98ebe09baaca3d6f4b3a64e93c74803dd2084e34369709fb7f5949c739727af81c1707ff4cdb8dadfc8c00814ae121090c48a9af2bc882e73eb046c1e26b042c46dc3143ad20a78110a0704374546e3884b8640a5b06b57ae60e9600b574d4838281571522703b89a54526930c68a26c3c23f53946535c1d93cb7dc2e21bc772fdb4ab067aa14da4b2719be6416b92c707a27622c55e204b34085a743f77148d6a88972d6c7c3d7b4ba2600a1f59f2b959927ced9917331e3b8e5cf5fb76bf1b2cb3108bee4ff0d0a7d01a882d87e30140c61af2d3212c971f7ce678084e8eef547e0bc65ca54431a0534cff6a4826982847f2b6a8662669b9e48064c6a7e7ae0cc52ae6655518ba5765a7d2c57f4a7c3850dbdb2e5b8f657820f72dc215e34dd75d49c42454afa42b118ba87e195d562e56c346d57d4c2da3f5b094fd492da6b96b41737a2e632500f8d0f67f53414132b3bbf1f17b861de0dbad2b0f1299f402e538ac08b200b901d054222e08f4828b6e9062094cb11f3578de02b4a15db227bd9a111416762043725c2d7a533a518608a0a00ed3608a1cef5b5b0cada9dd7f4474236a6561362710bf3350565a1d7dcef49c17775e161c3a720fdadeb4f45696ab530aad3fd4e190227d0cab95f0ef8553b98f6875b514696f119c0a18c7083336aa63912d980b351313ecc3f66c27a4e61462ee23a0a7303be455d81a6b5140fafcc1a71acb192b30a80b3dbb29d737b67a2238e9c7d8fe553028ebc9726f6391c81a88f33a83dc9e372dae6cfd756ac34336d1cec50485f887843086f90d11b187d6fe9e68062a59a86e14f646e01156911e652cf54cce7ec15d98bcb68b0402c29ef3f8b2ae24669698192896d29aea2beaed1fff9c63aab186ebd93b4557db92ba813bdc8edddcbec07112583da2333f62e6bb075bc12c88f7c87366230b7ee84a3351ffe7952f8c03a0affd90a56745a28dd8f3cabd53a33b7d0e5029fc6af0a8f8168b1fd4364b1c5e2ab7fc0a94a2b4bcc7904e3bb3f58d139c2dc8c5e92a334222ec27a10a1cee06c18a2bdefbde33645c916d10ecef3e38994ec8a8494c2aabe934a70cda2b8f31e1649082252aebc457394d42cbfd0983ff21625ae9a7004aea66aa6c3b6b70817d1bffa9e810ea5599461276c1afc51694fb9357da37fd556fd96de313731a7e92ae2446715380694f9f8f3a652b8f5cda16db33442f575c54c7f42ef0da60bbc456c8a5323a8c410d10b8a134a49954a0c1a6d7cbebe91463756f0a526aa7b369438a8a6f9c8110a68433f6c35097176ffa01fb59786f85ef4b2694518afa5813668c5222faffad826b97ec92c8b0739989096e970b366a2b2fefde632f3e199cf492833be9a54411d9d78c536022ce502ac1deeabbd86a49682275b51ba0e797c18fe92708457230ce35cac66d4701dd7ffcdeb316fe4522f27a3e099653808749ad7d87c7518fa02fee83c10e1067057961f5a4725127e11a210ff99d0f9065629632f4fc0e82ca94107886a2f40a37731c45cf22c160962f3d59129142d642263f280a9571fd1127679786cfc51b9ff4b9f25f0d3da7b2294c84f3024376cc0932069de82f3141823447403e555fa6e04d6511272cf0d2228c98a2749be9ccd2c0292d060e4f2012278271f012e2c32b652360bf6e4701fe2b84adce4a3078dcafc8cb8474215346293afe42439bf02cc3d0da7d92979283d6c8f1370c68f286441858c61fb266776eac6f8dcf2c36755a16f7801bdbc9bac2d4492e6ebf76efe88df38f0d3b87e8c4a3999236902fe525b2db33e36e666635380697508fb3aea391b8978c6aa6585a3b3201beed8a582167e97a90ac9dbc75a6513902f9cc9c80216ab400eaf1e7433c306129641faec246b2826fb711a2b0f5a0d7da4bf0a249e5c8ebdec98ba026563e0b81ee30ba846e42d01be1374026089fa1e58a7f3900c1d04e11d15307900b4c784a3fda73cc3bd8ea1eb81bb8b232613c6fe6344627336b5431e11041e9b5dcfca3955c858101333642a04fb71b99172035d8070b5315a918c639043305f214c083388abd9900203e62c52c9c8c3382c276492b971746b4427865414beca5f1e2610ed5a27e9aa4b453083c5652ef161cc04f1d49c3b6ff5f40444af49ebc71e15de033589e68c5b982e1beab107b85793864a084eb38182c94d0ca268cb4d59c54d93be162f6fa4025baf51eca72dade4d00684ccb84fdee4d5d6ee3e7c85cdf13bc1ec699dfa0018a6e3bced9868757a34e860bb38475586ccb3177fda5b6fdc859b5600580b531706db503f2bf55a7416289fed1c5e877baa0f37871be7c09c0d0ef7b7ceb1301920bd49902f834f0ffabaa2611f08230fb4d2e7fe6e075c0a1765e753b899b6bb6a5c5a779754369f7e4ed93ba8bb5bd4cf7194b9580d8ddb60ce85da4e0bfb63faccb5d4778750f2eedb84bf80c3616f1f8542bea8fdbc22eb978e4a030819d8d705c0c4aaf12ba3f1abe4ea7316bb8a3f94d0e694fce11cf6c935530474e099db288d3fe924b72e99f64aefc04314e637a57454e930b43060d314e992b58148d3fea48cf94663b07f71ab7f1255924d261158c472bf0dcc1630a642afbd931ab7d19d340c9344aa8f4daa86be9bb031a1ba52f730573028c50dd95fe8e7447d39832e3cc2d5aa740196573a802b4b9b70313b173f0d503bad24f0fbd689e06a401fb7771ef79d80d88dc4bd36bd243a4dc198646261176094746ad89fa779a74dbfd518c23d95335cc6b5299e0d6467788452cd09106a3bf62e537faca88892f228851266b1c6343248853388634e9a733005a145c6d46ce45f1921a120864c79a9e5c4ff0a26603e681341c3bb25bbc16fcce7fd242a904b81271a8b07c4c75da1fc39925d9baaaa8575286035fe5d24571ae28c0af6abb6c96171e6bfd9c4ab18527bb2d018c6efac2764855d70044cc800b9ede4b6b7ec38ef28738a21933bcaa25d105dedc687e8b8189650eec4f5d1db1dd32ff0ecaaabcd16caf445bf47d88261c2f869394c525e10a758e30999ea6eae752dc4917c6d1deec71265482f4626aff6845f47be3527caceb76c1153b235776be5e6d2a4a4ae63c21000d750c548477260fe0891eb1b9e9f1bff3bd9de9ad952f1b4fc3cb47d12d2dd4da2e585fa095755e56e2c9b6aa40573bfbbc6f1a0a34871e358454c5c9faa2908d4b50bb10f403f1e381b35c9ebb39d00aaf58374b4917498563dd488e341b7c0aea43de8f160de4cb5c2a2883998f6668a48e9e21d96d04f8f07311f34efa84c37040e92591d9feb84c23f32a7d7ec04f35872b51a8438a9753ce82171e73e0000f2d7beb6f236f2ccac0f548b1b06b4a254df3508dbf3e37aad35604118eb601c0f4a2296ed132268a9b805be5a5851cb76970ee3385bcffde98f07bd7a968552abe772ed5dcbd45946dcc5f6cd302ed6b8570a31f7d356e323f12f77e24141f7fe9c76d60dbaac3683013e17af1318282172ea45f93eda84fb338432f4cc5d488ccfaac24c6eb676c8be18f9a2ddad0c7c02bd7f118d7d49c669fad6fae566fca49f9d9adb279d4b1e6333ff0610e1e253d632e83437d359ecec21d3de502f2fe217923327761663d93a7c80ca6c2ce5993b71088ad7652650605e8d982beb012c9159c317839d61d64a9be669f10e85d98d582c2c36af66b5bdcadf66ea4de334682d559be1555348dfe01e8ca584793797476d32eba446061bc900a050bbd3676c3974934f974a10d3dafe8630fec658cb812e00bf7b81586474b0e25f3309bb501781506e676da8086f2924888cbb7ffbbbb9df2333ae069acbc92f069e56e916ba901b6e9d82067a262d6700f085dc5a802dbe0e99697723cccc2e77526c26f15b34efd455aa20374acc9b6114c6a64e36809af56de7f30e72e3c1b27f92f1ffa46ab97bd003f0ea39ee3e75263c072aa9b567572814d68a0671fe698c82ec6003f6dee5943232214b76d49e39151f3069e13c8a378baf3b4d1d08e0fcd63e09b8c333703669bb65250270f60642dcc63b0eb78bec38955cac4db336834fdda5a419e9352c371372cec4f59928b60ee5fa87080c7458df60f82162acd52c531970f0e3a8394d1fd6ad860397afc96c67c400ca3f73f869f892af4b1a046ee5ab321e1f65b650a76e2ab4ef6ad459b23600150b76b800d6d88d3b36ef11dbb710024165580b33fbc125f073b4e6462a4d2b1a58f4ac0315a3b5709f7624e63a3dd1ba468739dc167c3887b3a9ddbc456e12853aaf91cfc9e2a2259cacf0c5794b6ed9f3962840f5418c6b772cf0724b6d6e3c3da2ac764d404d5e308313cd56ee1f455c5f79738b885cd5da77ad4a3e8e2b33995aef7c456d0a7f5792f19c840e0fd9b67810e2f52d7f503870003c3cf4d7508d50e2b6c55e5b93849ec62b24bc929aa822e139c9b57a6df12b4818a15622cf075f32e9eb4952e6bb9510c109e4608ff6931025cd02bd96d534175587fc4d3e281ec845f68dc2aa060e94465c30bac79c2f8bab7cd2b096e3b2ba66c8f9b18ea34813e2e172bd55d47ef937194cef571262da86eb9ab5b32d1a317e196499a093181a8ffea317296b928df806c3f6b39d64ad6fb8fc8a78b16b1da3275f280f95b13021ea4740c91bc8dad97ad2fbb7b6b2787745aa5a46106c7edae4f062cf1254e8435b535f477dc9f150e5488c20d88f0473199146c83405bc8b5507814d8811dd049c4430bdffba1dc7727fd5a25d5cc547b4b36d52a4b4cb2354dce4100ccad5b59eeb53617671a9c6bedb62c6ebd901743dd9061a73286ca38b830deffa0166562a5b61fccbba29db1056722ee328bc16b77912e85b3d807c41b0d4956d295c6698e070645823240216abce102d212b3ce13a24ba87c5ddd6ccbcf6238743943edcecfd462828d7c2ebd3be4af91e738c60686a334beae5266079160d4aaea3cf278132342a6909cec0090eac12b2eb41bace7b602b7f4e23a7eef8ced7ce0996b3b9891bb51ad6f799985d6850c0225452228c159eec8056261ef2ad00d85bd12ae2b9c5e2642bb2606f092c714ee3c9cf04ae1e4af59d0e0213975ff9c2de2281884701a08c2806e3e876851db50256794bbe278afce23a36d95b7474a3dc80a0f7b6f64ba8d3e82f15fe2ed04432f147e9180561ee837ffec21a1a13bf5e304d39bfbcc6b0c4aaa71b315a4a0f7cd437b090cc280ec7d860fc7e6ee35315ebb906138ec05457f98b36530933e1d391c424943dec3701995ac57221b8a2fcc90063d8a8d12402561abfe833083b300c6bef70d9d53d1b79eef8ad7a91b95e7f1d810071fc6dc24d44f18e345bd4882f30d4d186a09aa3cc945293c33cdd60448b93432aaf85651dade7d436ba4f0e77a8bd038eddbabe862f7818be49d9816b3316eb08e47aaa6ad756fcda54138663c37475ef6184ac38125863b4066babe67e3759b7523fd551df3073cdaa10e6aac83c075303947d746e0bbe7c0d73ff5844b7d15a45e834601395651ff71c1fc2da244af3131809795685e3d11297b38f7b5ccb9b5663cc2aeea5664959d8d65bf9daddb1b2ddcdd87b2895b241a80e22b326d3563c80e56a769087346bbb94a9fd96c989f158fbe28377ea9f6b55684b4fbabbd525399ee01a086e08ff5483f33ecd062dc32b54220315d99098901ca28b3403e0f89a07a893d67278a02bd865366f915f1dda5a7b2c71227c5314a1bc59e8dfb2aafcf87e07433d25c54e9b95a526067e95fc40b6a6fe4bdfeb78f4606c5ac4ce2d1becc716dc2c987fb919d7cdc25d395f2b73d54c4cb6fae1351b928086be2694bbb87e244bfbfe15362386db0016d7ab02864a3ca2aacce0e98015cbefeb3a773e7ffeacc296df5c579b3d0f07052a1b9f48aee5f12ebda73f79b95031bd48f223c4b638f8d4eee87fb1ff9cfb295f2977cf8f269f9f93109573ff27ce7e99b8bb31d79d9ed602181829515d135df8744601e8179f043a86fd6cc057b06fef9af34ba30168e46e553c5b3e0fcdf9921db8a1a419f6c7babd0edad46408b9b270e863a32cf896b3a1ac7f25992fdde4579bf7e95ee1cb161aeaff8af849c32ef86009005829537f0a521ca54ca16886c3fba55476b23068d7a24bff95c6660dacea458e1006fcc4197d6b8bbd20b77f6b14bdfa37c5c495a6c5b0374f8bab7622b56039fdab072030eda1ce03d6a1330e0d33e0046d4a70667c273a5c61af4f0b193b896c5fb99a68b26f0a7b442001ab48c9e5fc04464eeb386d3947db3e14a2c38c7a25186e75330c5a816c210b3c65b43a6001f358bc0c6d8406832c32ad5a3002fc53b65f49ba405240e31b314f5aa1fa4dc9ee366fa7e0c4b4c5680672a4b709da37d2c9448ac1b8a317428590dc47429ae841e25d718682497dadc2044cdc57540a0c67e6c0f96033ad7ed71b48bc524a129c0a4e0735a397cf0e51e5765f56279c2a72d0dd1d59247f8abc64ca5d0519a691b710c8d5516f27b1cc6930e99243c1971c65d27414a9c34579269eb13b7ebc4e999ee7cdc39dcd3ba037af9eda42ddbcd9d882d2e816f85b6e7bea388e452b75b7841dd859f25219d08f479dde74cec802e86c81624cc7229137d0979b3ee3342fb7f949b9ae9fe467489b7b756bed08764e7221da1abec729c513bd42693470f36f84c8205b9e793515d70b8618bd0398b6ec7599ecd8c4995e481770d848d81b6a1d1384646521155f28833fba10cef0e603ab91a2ee3e0e0116b3a7685f474d41122cc947b33199d6262ad28b06047715a68ef2c94b329b38ce8d9e428e894c0197cc66e05ef783eaece0221a2437bf60084749f82e3fccf9e779e129c49f8ec1624134fae6852f8bebb967691ab790385e6c3aa4a35b88b9fb1c6d167b26a43e6d10c3ead4a79a5eaf8fb68903bfc5165311637b894a16a9c34eb438170f69ca781d6885d6a09bbf8bf0dab88a38a34f75d0f427d33b3d2a796156bc3929b30efbc1c1e06e226cebf61795a52104f5f95d470534bd0bc28bd19457a79a6649c7625820554d2ab695f80ca0c708f0cfd0e7d59515b81bfd9b0758fbd2b9d7bc1b59e764466416c7ac1cfa87320eafb891d73ac579d984a3a6d41d82e671ffff9221b7c57edcf2187bb0b2db16e0e445722a1dca40c78154dbcf7536cb2527d87f4d3b56604b63640b6b3978bd10af4ce70d0608c4c66c8d6260c8c802e26c4df85291528d6a0c5097424aa31a680df5ec9a41070144f342d30c5d8a4148283cfe5fd74a4a5be354baba5e725078d7d563fb4939b36681cba48a2ff5ba201ae93347547f696b5820b66e436c0c2731d895458878eda0d6d6e440d60ae1dd3a5d34e824b9cfa96dcd69e8329237df73cc6d8be2becee34b5d7edc53c9503a44138031a9be24f935b8e3defe95a8abb6540499a91385d55545dee69321fc1272d08e8ff0b8fe0a17e653f0254aa1f7fa368c6d4d5de4f29dfa8ff4eb976df7b8f554a571b34aa371be258ac0bd21078f044ab5154c9aa10ed56668627ce492905a42feedbcf234443820730740fb1ca9993869643364dbf4b4c6ff4d92bee72e44fcbeccb7f731f85d23195fe8015f0b5816b8290fb37505751b8868c5365152005b97705289c65e7315b5b69f76193c4f6dbb69fec77be5f305bf426917c0249982589d14a620c0685b22191c4a6365d17b8f92b7d3ca72c35f42ce9af50f627b0029ade625b103523a367a696014f20ded1862fe0e33ccb19092868b48ebb4ad43969951db46390c6940d8c8e80d74367915a7780044ac04df259b3db4c7dbeba6e6f56dc61edc215b69b283639aa5981de21d14b8a62599a0e59538442442b2235b090a1c5989d4687fcc93b9eb0c22ce8207fb6a0389ba0870738319a125d6326332756fe54bfd33f9973c0c35e91490469c317536ad3d848c878711dc1e52952ee89b32f939596fadcbd27145407313520dbb32e13c5229e35f9b857cd3d4604a8bbe63cd4cfe9838774a5d3a72063812d1b66e9fbf1591ea449964d4fd451e92f5daa1a5fd6e6e48a21a4814247ee3ed4e763511169e06f9c197fe00ab271b234f27f993c0c8011d1401b3c3db4754ce7a3ec6be141f91efc5a2de8ddbba7804f99987ac9cc8da33607dc479de58405843f2ae6ebc8533efd97282c32de3de3e835afa38d634d1aa87d76a9ebb0801e421959959cc34efa54b3cca73927fcf653b56de764a20564f4feea9a7a7c2603fb351a5934b33c0a278a49cf94a7822a52b35c4d70899e6d1a0e7b384553f4416387808b62bf3766ce0eedf077fa364347b031024044b52034989abc811bf4126830bd443ef833e5d92f47b1ba082a6232e46cd3ed6dde994c71ab76827e18550cee24921d0f157683a711cd58ef8afd3b27bca1f97afdec1eeb2ee009d895ea9dcbbc99c3657c7328ddb9258c1a347edf58200739425ab30d9c1ae1ff84bf291e616f5b16198da5f74ef9c1aaf881ab447b549e7ab1486cbefe1ca097e79ef0b868d7a501c64c178a7756f7547286aa0dedad17b2bf1c4d8608588dea2b765f6074d57e54dc95030e1a8601650ac749c9395b254de1a79833ee153339322bf006b01e7a43a4b15441857e808593d775c7a85587b56937194434a089469f741a236258cb04a3d5dfea4079e9fcb2711a1dfe68c3bc22d150fb499aaf431056d65079029454728b086999864e2e7fd1f968f72d37ce77601a727dd182715de56e0b79fbc661e66c289b0ad74037a5e536958fc95eaf2c36ea6504917550966164b5ebe2e668ce265135ac4b5c949f9fccaddee62f3d9e5905a91abf536bcc029b51dbd38f8e01cdd3c414975086a2124e23ccbb19818680b2d896a750999a9b34b826e45b95977c74981cd0fa9a64bda3fcd5ca96042f914493b8c8172f4e6558594275025dbc90509b84c5580809d22cbc017b9f923bd1c71b845a928bd91ebe31a50af6e3a9f38d24086e0f3d00688c88cf8b4ad315b6202ee7cb25674e5823ee5f269c7c281bcb207ac90438a56ec79a5cdbce21861819b798c98d326da3c06644a4870ed890150fa72fc24067cc40d02d856ce689b315b63d1c92a1619fbd9022bee6a94e88c25209fe68446a40b229005f70a4e45b509bc78fcabf4b0995ccd9e46d9058ee6e0acf26349a9dc36324903bfc6001880736541f402c5d40350d0e331b822d84ecf43295e28bc7ccebd75d1542a6b137bee79bf053816251ce6ce89883b1918e6f879f1a51324801c53b3edfeb759a41730f928ce53d70eb3a01608931723075b9030503eb38297d38f3b20a444952e7c4054a0971ba4cf911ccc8f3abfa0dff23fd170e0cf0ddab25f5ce308178be9678a6f7aaee4b1ff45bbffd4e1fd85d9fe92cbebb576bf28851cff3924e5ebff27c1fd184c37d64fe767f71f492abaaf7fc96ac23cb479ad16c5bdb4019f4c84fdf17fd2ef546278f4c27f937a7c1bf053772a53be0e7886572a930ba9a9cc55be9190a61a23b51486c4e6c901dc17a6eb4e7626fa93a7051e22163f8d34ff8cb2f151fe5879fc8ec3f09fffd50510b52cdad8cad8f5d317614a36048f3391ce800c49bd09bb91e90f47091f96fd59c1a5a7dbf47ef884e14bcc756f59815555016fa8cc0dc3fdf9de32af5f64ee14ff57aee0a26cefd51abfea360c8984add837d82b450da5cb2cea355f7fe47b63fb196b8bfec78be2756ce9eec2cae5802662eca7f98303388efdb864fd1640f6273d59cf1f32e1d81fcdfeb30e66b9cd800f5a33eb1f75849a41fe574d2c5f0d4e0cfbbbd35186c238f2a7f064367c10594038be2e51cc942037a7c5f2b1a6866239920277ba1a65e7a60c4a23912883c430c41a09d8e62aa53795cea2cfb61624c836fb879a9574ac9ef68bb7fd00b5f3ca7f94766e9c9a7e225502fab91b99e0b8ed631c1ceb84ddb012b8e93836fbf77fbd56001b1f8b18b61a43872df64e6a94bb90c13e32541878b96ffcad4a8ea41924ef319c0a65e6e068b7317be246a2d1744682bed142da46dfcf04fc1656829a733f092bec40124f0027eea838a5409fb4e1fc1b8e1fc245973fa6c53fb9a9661b0c0f9e1ff7536a92488d09ffa3c1b5a1f0a4cc7fe88ab0960d04b17b4d8f79bde38f0b2b24f1ddf30a3fd75b853651b4e73da1c840a1f0fee536fbabb213292ae7b1ed40dad312024338167b60528609f15457ae7b6941e8ab01302c72f6db288ce77f7161eb35dcf89bc84d70d36ee6cdd0ebf1c6ed077bf5caba58ea497aff1d9b3bc4cc9802a7b4ccf2f125482d6e0d1c6c4cd9b43fcae01f82c0562a8fc3be3fc2e534e939fcf2aeaf4aff5b0cb7aaea70a5c1480de76e00c2b35b3a205851ff1265490d126f0df0614250de7dd3bee49b0b39e673f2e4a62cbd0dea0e1f0421cc345f63afc80dbc51d1901135342f71aa1d2d5862118c869d050726d2ee09fef3e1384078a916accdbdc7fac1bc9e4042fa26fb9fd80551a75c67bc8b28c6db6072d070f54dbbfcf7bc826fd172fb42ca356cb4c4a9761107e0214e95cc482d756a342d66b4b6618d976349b25b263d2ec79b53c7d439cb1bbf8a68d0bb0ad484246f111a908c2be6adf43360fc50e093c311deeaec42e0c5818aafccc6c815d3244d88999daa4257510c34b43eeebb2a608b674e2b3bc4c38ccf2659fd923c0ebda89cb2d767b7eb9dc727a4899a605b7f5722bb8882b280ae252dfe0a925dd002ea5db098bdc349b2d9a57d21210eb44c4f9961c7f89d136fb095f9e0cf685788fed0e2202cf27780eeac7aedecbd2568d63627683ace9f5b6c69d8391a6a2b61d18c967a9c050ebc93950dbff161e59cd6f843de895d14f302161659c0018c49e36cb7bd39bb81a8eeabbc06540c5933db06a557a904a3f9c56d9d0786e4118e1b4b53eca846ae0212f930d863b8738af580067a3ee5b6c6ef1a64c1c27215324817ae8ae9edd62d0af33f031de707c06431e6e2de6f00edd47958444e5e7e7de3da0349f4670a6aa1f38ed2300ac7aa606d111080b2695042cc0f434870bd3bf710cb5255fb557f71ac6957f04684ad49ac63ae19987e04fd0981f4930dfafa236c39610edfc18040e8fbd7afe72dfe70a04597c197fb41d998c8449dfef34e650562586b6d09a1cf9610559311b157de674834e0b051f0faa74b196d14074e5d78b5ac6fb2286efa45a9a1d1189ed4573fec3323dd514af5d0f5de4e4affc147d2af527a69fce7b5376a90a4d86678ca62e56f5cb250fe3796fe02ae90c4865677b9874c40ace6bc288daf987dea8c841964cc37dabac6b5885e52234433dd6b00525f3dfea2beebc068bff9f6fba915231bc603b87d7a227dece951b89e2c2057babef5c57559efa59b2f7677e183d53e718e978ca1df9137daf4359a884937b40596392364a48fa217255d2180817fea2d3eee3352533e66b8c561aac40a0fb33c0044280c7059dc11cd783222a481a0cc3cd85d985b13ac204b790a357a845fd1502e9ff07ad4c1b51885e1a2a374748c00af687576219f57b49e8521f7e46055b6d1ca53111570d217560686c50c58615b78c04c1e217d69cf5d5966d6a6fc20a0b5ad2d5c541750704a9a072628af962b36de467b563026438d740341e4d359759609402c1935ad60eaf6f99d06b02f8781af16b0cd381e06f58745309c882490170d5f546aa9221348173440a0a8f755f335ddfb2680a1b6975d95fee57ae0990c4714abcf53f2bf79bd03e8a8e8b09489dc474a958b10e62c9992caa0a5e96853d7f2c490eff718273224720119c453ae3cf13bb8b151dae622a1406ec6d2b00913c26423f6d3ad5f16ea1f1940363aaae7c989742b8530d7ebfc07c6cbee8dfb1d7911c91f1b18e570dec5182dde7846af6ffd200231b46629dc0b791cc674c0568c9e4ea6b8f86fe1ec81ef7ce5dfd505b78d36764fbd5d17cc2e357f95e38e885c71d3c954f17dd6209ca7d83975b9fbeed37dfc13966708922ff9e13ceed8baf7881c543790cb87f5d2f80643703c35c84351cec52905dffe9d645f08bede8eac7b3377119700dcbecfe8850b0d07b1a710a90190b66965916bace8ed1d34855886ae2e0b0ec88e0f50f61730a87d8a062fcd810156c26a3611373454756110286255659fe2515023ac282c454b70f80fe0629c2a5353b1802d35e33e619e4e4c06ff81420ba10bb08d31ba1ba20e252ee90ae239cbeed027d4af5f06cb7482ccf30bc254b19ebcacad8b580c44206ed0ececa6682e8f7ad65e77a43c663103b3dc23cfdcda54e48de000473fe9d6cecec9bf20dcd05e7b32b3ac8b71d522029809e537f61b796e185dc8d63e700f03c07e997dda89672a6e4f6eaf9058f0fb884ad6a6d3b8bef13f6fb76da64c2c90233b4455769bb06b6f3b7a91dfd753c986ff6157f6a7e653d96fd135e32b39aadab067499268eb8650fec8dc0261412928500763aaab80224dd009827262106a2c900a6273845a42bd3d07c5cf9f21138a82eb3b7b2be3b7c264ce752edaa35d423eb374da021dc2b617f189aaec1a368202bf297fbb6011ff5c0157e65cda8750b7e3adf2536720b8cb94419bca4a4ac02de87fc9cc95c1f64df8f02ea3a05e8fc19f85d63cfda3c9257231064f9979553bf202ed6582d1dcf75d8ab168ecaa3860cbc08f1f188a72fc24754cbd51fb5fac4f5bda78107b25d034480fa370074ce14c2f98e31a6340372b6a85b2dd7d1c10b65872871a8c89bb5b6d6291f1ee8c83118fcf4c6876d2cf246139e3c829f00c64132065c272dd26f5ac72cece4568586c93564d70375fc7d510ddb0e60f86a1f0adf11ff636dc17f622a87faa8226278d1085022421aaee77122a234588227dc00dbbe8c6066c38cee9bda5a9e93c8593b917ca05a114fc24e03e5775ec6095f9036aadd1e386bb00e4272617657d12658342e3426bed1b2278c556ded8d22ac052084371a8558bc01933caa1188ad95843ae00892f1479aca1f8e0c1f94654fe6a8e966fb04ad38c19ae7398c83f0b65d8d28d656215ab5ec576a3b6082e9125ca956472edcd6a12502db97b0bba51b225cbfc2e490961f3f3fed7880fa08b59aa3175cb616083a360c89279efbf5166a5c151d8d7993aa16adc259eaaef8c919bb1881ac1a2c0896bcaa74d5b72bb06706a6ecabaf198a65b58b72209d2378b9bea7a78b779289c2ec7254d75c3544a945e6d79cb32f42bb8a4f0b00434151163a3a4d593cbbc6426d369380a067151dc55c3c44113fe7b1e8da9612806087161ec3c75d206ea41feefa987d925e7de71b401fa6bbade669e311a6bbcef828393d468030486ad9d006611fa4aabdbb8abe9ba4aaeb9847216303cda8076fbd851cb33055574b202204a0c3c2c487b8dcd06b37c294674a88fc99b45c6469ab17d8585d2d106407b08eda019babdd79f360aab765d93f407d2f46c367854779e40c571bb6e430fe9930201960b2bfc186d20616637db5bc8be8be444fb7c952140884398ca66b1e00319a88c4f6b36451b2c899e79d3f4a8c5d5eafd4156c28b2ea970200342957ad083f86c10fb690b3b74464bbdfee0b301fbe685ddd420971c29401349a7a5e61a7472f3e2e6d676ef9ebbe86ee1cb50fde19a33ea892cc59b4222cad73022a4a917b128a7bd6b60622979bb85b2556ad77a382574afbcf15e4265c35577811ee9148a5989c3870370ef610b364f21914145a5122ddeb6f87950dd87e3c3ab69dc869e68481ae43b4fd0b36868e06a391770e823e6ba442b8b8453d80d2c7088bd6aa039971a91da348582c4e51fa7eaaa558a09d72d0cb232b291826038f626a44e4d0463751c787c021f6f0ad2dae04ca9cd1aa4d2466026c8622499ef7346d7fccbe7490f2d9df3442051dac959c7d784330b081fd3736317d2cb69ccfaa5f43e554e348a07c7a095eb4101278aae78b6991289f71e3a2357e21c2fc2e0e793a206011848c528fb79c64f53f219d9a6c5b81a1650908ffaa9dc7e9d7ac07c647aa10b15a8fd9c31be18ce4aca22f00499341521cf195c24a79cd18a2afb1a332650ab7802d8d1fe5baf5f42471019d50091b5ff0592954c789db462c19ac469a16ee40393b308b58e6f35104913ac56f5bf340e7a4d0dbae945c56cb7e0e1d9566febe127029447e204513d76f5fdc4a470be7917d9e972f0e2afd2430052b0a9f4a2dd4669f739f8edf1917bcea9c4ed0079fc420fc25f83879e54cfe90781411004cc33676ef018a598ccd600acbe051a3e1093ea39ee4d1fef0718bf9540164a5be16a1d48fb887b09f902676f91636cc4d9ee83a4ce38032c88dfa74628a7b1251732d4ccee2cd4ccb1ccdd36111bcee342406ea787c79ce397508e5fb2503af2b040a824356724e30a502179bb8c6a336c3371d4fc658935d4181f5c1a793c8f89eb10cf53ba5385894efc739781f1cc15a12f910dd0cb5fe0430a9ad4ad9e4569ac71aef71079484e34082b2df19e760f2a821145f0f7048d6f4146aa939984803a547d77255fac21e1c2ac6665f153400335f81a60630f396225f3e2c7465cfd14e6760b20e9d6edaf1bc6705f4cc8cf575e2c511dcfb48c8297d7e946c67bdbdffa73a0207c97c0ab0e262cb5a7c0b733a4bd8f326439cd44a81de72989a25a3d10853f3fbfdd1650b725039e2c57eac1650f9b10cc4473dc3a04ae8f4c4dfbb087ea1c1308b2e0fd02625aa1b514395d709b3aecae19c0c31c5d4c0283126e959efa474bac198aec8a1a6c53052b04857520e8bdbce80c7f34beab607e660bca8bb97ff423e8d1dc7537b1ffb2fe2a115d15c5bdd556cb94fe4475856c94c9e296ec990a240a0d331fd0536d0722cebe172aac5afaf47f25e366b9718e26bf79987f9202a9c829c20745c35d6c2e852c984ab202a6d556dcbc04de62c74ea6ab2212241bafdce3345136362a721c1c5c2019b6718b0a7e736e5acc00333d014d7ad6a56d040afde47d361f19c93947b37c97e24d47655da3327a9f594e46c9f43c58991718232130a546c03cc0c81ac3b12e2361222ec87ae6b40b951a126ee409e849cf57c5d66555399ebe38e0b95e8b2020b79363c5fbdf73e0ddf2d0f86165ed56acad1c83ffb6a1192ce5941e28d3270113c5100fa50a1ce683430c4301531c6e7b1de339a102f4b0e6b6db4f23b16b3fae68f4426b151783312d294e22f330dcedba593582e6af622e1fa298f97de5d2f9be1593b7786e33ecdc2a6ea96b036d7e882fd37e39681fef2b7c0ca90f464bff5e2a1933be6d8547859e972b94957afd0d0695ed206fe0b75fab9f04cc21ec242fb26c8c09024949feba9f5daf4012e25b6deeb4f25ef105f223b0c7d71fbfca6d43f5663f25c5ccf86c15670b0434c33bd77cf31563bbc19106981a6557d2e29088d67c468b07edd397aa99b1a6424687092c6ae79045722b4215280d7ac5f07cb1180fa0c91404b1ffd0c0dfcf0b41d1dfbdb1dc6e2575ad61f401f1f71827f541f9cac859a20b6e699450c1813eea20903b01bb8c29c003e2a4fee05091ca637f9e1fad0ed0227512a2a36bd7e63aa3f66b388bb52611d2e246c9cb591142f0373b06edf2c9fd78b7978f6783a1a7f090bf18bc5fad13bccfdc237bbf7cf2512431cc7c5430f313f0fd7d4884598b9cb2f8632099dfa4836a4a99296f0b8a347754e78c3e08ca9216a0423366b4e3067e76da5298f5aca1827f1d4bad6f03fa2db26c1c2349f32c0ba210bbcf835823c8c420880a0c8ab1b4824158d21b1cccb65b6167bd85c21dda6e3e50bdbccd0888b10144041e8674e3036d6a178b31d18ec327ee9a943954383479c93fc21a8fb543065b21654a118c13cc0f2c34c7889a633f4904931d5ae0d2405b973605be9cd9fadd91536d990f5974d7970239065addd0db7ac20f966b58c0cdc9f814d94e6ad31580f27424b7189e1d3b7976e03d52238ff767396e1c4f92966747657b04611fd9d63fe2e0811485ce948c095fa66ae95417786cb8a647c6074dde996e4f96d5200fa995f495de60bbd321bfd2ae379cda28fc82506666f15e7672fcf57298bd7c4b90f62d4ff8c2c8ba5ff6d285714264c6a6821324f29d794f9c40a74abb0bad2045c327a35cac25c12a6f60f64e035be2b0b92fa2ba60f9e53e183229f99d0b399168174bee85f673526349e43440e568724b72eb475515c35feecc644627f181723da4c27aea1a9d9eac2474b71bd45675dc744506bfab468cf8a0dca0b2b01c517c37ccef474b744b3baf5cc8658444a1c87c849f550b08a2612abaacbfee646a1bfb6a41759b1a0b44c0de52b38311ac897d613c277d5efcd100404515274294d4e93d9c1da388c9def1ba4b5fb66c18451f11eff5a5e4b25f62257a84f12aca9a08de493aadde18408532f7646c6bc75071a17773b2963e8863a8ad04f10f1cbb87670858c9773ef6195aadc4062e7f996f310e0f8a4d4aec1a157e4fba89a2646b5ecd292a75c1106a549dd58f3835089d5b00e074a822f49b00a10753b5bfff2b12d574d4e31daa9faf8a9c348e65b610a61d3f22769962ab6d4a853f17c532a59a29e36f93ad5c9db2ecae4ecb64e59a838b57e599d04719246a41ccf12cd3995bc7766229488946189c972b15ce6cc5924798dd989f05db20731dd2d2cd1f20a94c1063bb75b9e4832d7e84d6a1a4de7573e5673f217bab3320e470ad88db461ef4a5d85e6f00d782b8db003be0c420cccb532a782b8608a898f451c96fb7b92f3129d7a458547f8a928e373db2134f70a36f491a42164b162ccf162496645d1d8d9c4158ff59da588825aede81c172a59ac534ddf4a873793b168c1aecc059d8b5dabe17a2b865b1d32d0dd6ff646195ce9e5f07f684ff2394ce5f6e7f449b19574bf66df92abb02ace7520c1a4444789ee12abb63d8116024c62c7abb87e640e79ef8f18d96462fb8dd631a940e300c2ca9ade500ba0aae6152183d96bb6403537878613454272ed7867e19cf02678358373aecf4b66571b0f83f850b5a7c652e674ec8269e56348e02be54ccb12db18cd69b23767e7269993eeb8d8c5279645ca11ccccd3d2fd1da18d5afcb718d96750f6bc590184d1854c8ed27ae2798207ab7c2a3ae29907e1eff4235f7ebe8040cb990a7051891757bbc9593d08699c76d50ea016a7aaad68870448f34eefd45660204fa03d463e1c6409860edebcc3a27cb4b508ae45cf2d2acfec0d91f51c4fbee0c1bfa261c1c47d152ea3a7aff3a8f065a3e6b192892faf85a03efc5b5d6336941fdf590607ef8acec096c22f39fba11a00f6672fb08ddd888788025d740039f11758817a72c055ec1889daaadd3e73baf9df1625a0891e750604b302069619fc0036ed6c53ee25bacf4ca31e1fadd68c77ae542f70dab8826b00ed10106a541f99b5f54a5fbabebd0d991ffaa927fa78d560add28fe08fbd66145349c2e2591ee4aeb1dc256fd4ab7352f44310240b89fd3bfdb9d289fc9d437379c36058bf256ac3a63483b4e20bef9252c8484766c03d68ae5acc436ba65662a80b8ccb08de04fdb449cae5ce49c4319e60f5ce8fb4972ab858ad2e602af963f92054348b38249379e1ffabb2df5b9c220cb702f92a7062177efe5bcab725c5e53943dfba69f310f71d429d497d96ce300ff1bb5f551f305fb3492fca17de04273f2bac0194baeb838bb000d2556aebe7d40c31255ac6536af19b34a8a3a040718dc58f167d3d16551c87a017f87647a27562ef4830a5c0430b673508dd90c55260248731939ebc4bdd7abbfe6e5e081fe0009e79371a580ddf7e0717cb251225f42b267a87b675ddad92aaa3753463bfd230b8ca0421a22e61f57bc33b0d0fa1a2524643ea262cf51251f016a331f29ddb3d8749606f57fb6584b77cf6b90f742b7c7b4bd0c0161db3b173bc0ba93a8f554e5f09caef6ac7e5139112a92528ea04e0be8099047c3e640f55db57bd8969c0b7b5a99feefff4d60fb8fad07eb142c21c519129a669825994fcd0acec5602c9d0bd3b59470f8b43d8c0b730eb4b5dfdef619b2c01729bf2d596bc9125db0774e08a742d1a6cbc53f436bc485b1ba429198ba7cb428f9bb216e6efd17b20676218157afef3f81ed0734e471f72d90250c17a8dd75614ed910756f64d01f59be57060ab23c484d8f196327c48346d1929ad0cea5c8ef4e918a2584c625ad33ceff46f8952f4d7607562ffeeeee633de6d7a2fa421ef27a980da427cff4d45f5962c1a70d6b89b8ad58852aab47af230092d01cd60c98321b4aeddf0027da7273549306515d914fbc4ce5cd25c43ccb5ed24379381801557f19e1d7d2e14ee0e256d89ab0a422915727d16cde6dd128d9d03d11b51d5c69d7135534ca6aeed8e5b05881fadbeadafa458af811c91757f29e1cff2a0c5e12ee76c5f5ad9e80c4d7798fea8bee7b8a3dca2e66e4ae3980c203378dcd52172416d9855a0d0038099755298a1ae0f0b86acc3392c5eaf17c71bde76a3e32f3963e470ae263c00438661afe371977a22442d9b837b99251b354b08784bfbc3e21cfc5134a2c68a94bfc1b8027819581db89aa3763b775864d27c978fdc8746b1ea82581d063026a2ca293561a8b1c0decf1076a18aa4fcbe73837f959b7ca8216874b03103fe1a43ec22340878ea697d5d770bb87ecabf7d56bace48c11aff6a9b08309cb341b7539e3c707fde42f72c2166a044824360e24638c31065ad1b82692c0521a8871ed51ac032dcce313f6510e0a4160ce97a3deaa8e68eb900d87b7c2726ef86962376a7e36186fb9175607a6aacd97b7c406c367e85bf8f9a6355da3e167b538bec7bd541f191b1d2a0176dc2c4832138bd293b54c93dededf8410af2f72e0e37c4e033f3f8980617a9e2f4341798a5ab15a798d1660d4028dee75adee4d0af74649470a228571e9d94b594981a70a84916add37da6026c110e9bfda93072314f35a18f956a49698bb5fd8d12cb481e51ae5dbef7b5e53222c570be1f9955b4fc03d825b4061e195b5ffb07b9eeb3a750f40e848b817fdf24694282d0e17fd0fb860811cbc7565c19fb4592545b8fd971aaaa25aa548479b6a5babdaab57ac836201179f129a1333f085388eb3986fefd370dc56b88265e303ed6c0c0c53fdf443d9502d28835768ec33cb110f7d9dd9ad3f01c39d6585f8cf0b5d2aafd279c421edad415dc82ca599c8ac29caf5d6435e8cc7f9a52ed4cf5ec25372c543812469789f28fd8d8d96072da1262fc9b892ca149acd93dc58f18fdcfdf45728238554a64821c356a1ec56461efa9926f4a5e509b7715c341f4eb15237c60eb4c7e2b41340a0450b4d1c0173e7dec2bf4c0a7248206192cc37916e860be965b151587766cdd785fa005d0b20b2357bf7717ef8e240c619e8aa01c627b16de979b3d56cb8191983cdddac1893911d6b4dddee1591f6a01126d65a492b11b074415e2c07590dc3f015c1182b92323d2ef456a1abe24fdcbc12cc4f17b7734be358be389844cb19537b0527a42cc7a685c4bef8e4fa2991f0bebb45d38ba4f3f44cb51b3cead60c764fb02760c51dee1e32a3bb671f67585322e23e86173630c0413383e7335d77df0a96d0ad6a6161aa14a4d4815a3d7f6cb74c4337da781761fa92a77e06934966e735eee1f9340410151d5de5f0247908ac95e60d67ecd78b9e0794afda2c47ccf319ba1389eddd974eb73c23cc763b884de374cefb9060dfa5ffd031ecee0b1119600ce1d2d069986bb1f099c0b036b1962c54a5ab693fe44675bd83850079da9fab5f3a073af9cbc2154779793ab22e7225a272f7dc599386f61ea1a2c148142d37150ace6786b2ce67caf2fb90ff46b99a616fe544088d99d43549b818211980f5e374d0aadc7b38ba7162aea7e785548cbda4ae85fffdbf7afbbba4384c634bdf9f97d2f1f5bd540689501364980a0e47b9e9985154f91ff9407dc2437901b9ae648fa30021fc638ec2af60846bf3123027f2bd07e508da449c3a90701a4536e0781313defe21cb11482933251afbc50b9164c01b75f9327e7ba850d458f7c5c27632f825c9c4585885ba9f735b8ba78c2b56740d6abd9460069c5d02aa71814c5e4010424e079c48509fbd9d87254ec77dc26891177202d14e2a3955c91b46bf28b6354fcc4f99f5ea70983f81cd73b51d11e662407fa4dede007b5248697cfc3e000c01690dfe98597fe37b1b3714289b67ac7dc86f7b77db724b99929429b704f104a80477766dec707148a66463078f7b677776efbd3317a14c9d973017b219ac07180960383c2d2ae2869033e9d3592ae188e082f2c4154c18d8d431ddba278a3c9564aa2ae6d9e83bf2672af98ee9c7dab1c88b8a6e2fbae8e26c36b3b163cb8cc717fa640bed2189fab0042d82c160303aa444049986408623f758866c48b52dd2e7ad20b1e5615e248aa2488b6614082ba5052a5a24d222f145175d74d1451769a92864a2289b55516294a468ca501351f48fc5542a95ab602caed2297acc251689f090cc61be63c23277e46c478e335a98f9656eb1b9154571c8771e3063642fcb2de2d0c762624c8c4df1b38781cdd0bfc83136c4846886bea585c5863445c533994c9c899fcca0cc4cac391363be3391c4c498288aa29128c3c58484a702134a2975efee9eb5d65a6b952d1a5488ff7f57ffcc1f49a3aa2bc4fa081b0c8e87367c17a539b42d2f586bdbb61582a769e34c6c7928d03b27744ff70a3f9a2a5dc75f69cbdaa75572b6eb68784ab8ee5adf29ae11030c8c90439c40ee20ab136c249bcc1df9d32f2cb37665eb8f9b95c8de9de04116a315118ac9623c82c631a8729c4c867f51fc9ab5be93a5a4f87f7f1434e0ac22ee50074ef0f6f696e0cd04df91220a5246ad76fb82c2ad0341e4d7a13e35a48c897bba19a48f7529a791283d294ad143a186784513bc6bed6b04293d51fcc21c9b0a10701cc7b54c06050f1ebe834307997ee5e13bd68e76a45f47aa82ab64085f69c4b2d609a5b4d24a7311f1f0f0601ef9f1d42aab9492561a004a29a53cdd0326b96bd624ed56332cb72ddf0e494e8e0b735a9f0b3826332546b20ad1134e26eb3b6b36c8646fefd4913b3566f774cd09b87ae2ca2cfdaae47e7e5923fa407804d594a83c0de2314390134ab2224231598c870cea710cca525a60c4590b8ad6de60b797b5d676b693373b4d34786a08811ea0943efd1e57e62a3105d2fd218b92d2ffff27219aa064d908c857a8f29ee5d7e56971dc45e9b04baa586d569bcd66b3d96c369a1a96bc49cfa3fc87abc96469562b666a561af8f1bcf6214d9d37ddf6530d431d3434185ce9a8c1290f955aa1c306a3b00dcb632b3e8cc23658e8c3365f0aa750df89357540d64b524cc3bd3c13cde42c57ebdb8fde99424cb57dffcb9891dbade5184b7932cb32c7fc566b6db5542adab79a41a81431f43385101942fce1808f98ec47ce600508db8f47a94f4a653fa5f724b11050f020f4336f3a1f23ab905c1784c8f94ad22709e9c3e15aa4c6aa8ff69161a45cda409eb8d29ab5dd51a5846f79625aa4a2294dd38fb5f7ce94e40d759bb7a1a10a0299705da247f754fc61be4bcb98d84bc798a69fd7bcbd8cb1623725a48c892b8845ca903f73e63b3f676f4428d631a69096f144f20ce336d80de6dc57a5acfa7f251ffa2e3ea890ffdbed769bb79c6ab3b1c1c3906e45c62f5fab1175cd03305d92268d0680182e872b8f2d1fc4b1a4945f721314aad631a495ae8d58c669abd97258695d6925b55cb45aad56abd57a28c116a19f0c988e1065fe020c068b113d293214246b2294e46130a2144e5c180e3da59340c81e2409ba2f1216ac1949605316a1425c6bffe9ffd75abf4787bd300c433725d9bbeab24dee2a56fd731c676bc51c0854bbd51213ee31752c36b1660fdf913f9d65e1e8b85c978d2f9c0dcae1ce22011934f0be1328e528e59842a5505c9696c6a5a571694ca152282e4b634d0a75023f8f86e6d6d0d0ccb05e1ac8174b9c425dd673014f2770e9f34ee0d2d2d228e5f875266b39eec32fb3349868e84629471a6818979696c6a551ca51ca71695c1a53a8148acbd2d29842a5505c96c6142a85e2b234a650291497a531854aa1b82c8d5746fb2914ed5228da9530b3657574e9c7142a855a1a1dd3cc9f203dddfde481cd719eed4cde079e64ee0c4d0dea53a9e04085940d7e1256b9111752a9542a582c52ccdb54e23a2bab54e645dc572b10a8c32b160b9b3b02949cb9f3e2967164b1484d2c361b0b162c6e5aa06646d3e8c511a9765373a52865b1c614681fc78202064ee81e19cc005be31cede346264c1daf7b4c4832d913a427376496127b0002cdac58b0bebf333317df197c71cd6a0e8140175c32651f8805fc64bc930dfc6c349b5846486ee44648b22732d993f9a4a8a8850b9a24e24c9e96a32f5e80408fa977b893f867d8b13a09674448e845786791196bd10204aad8c50743465e94aa03b9924996ed6028896c68064dd88b172fc2ee9e53b646463264b676db368b5c33cc0dc607e01750e9839c6fcb38e6c4f87c25b1cc70da6208c08454abc9c4298aa128abd0aa003819df0c10acab6b309e369231dec4681f37cae91e0efb282b5a2289aa11677d947d93f1998cb229b359abd59a0102673b292e91424c868666cc980142081505a51e4ab2888c8100020821d0a0b63361894b450821844063004ff3311c36680cc05fc9279938138b339c414e3880afbb71efeaecec804016ef002db15baea44fdfd626423718ebe880401dd6010f309be7abe1c9dd417e98e3cc3b753adcb58f8fb64da69b4df6954c9c297d1ec98bff0f7b0ef8f89db4f371a0e2effc8162ffda7bed94d96030189030317c12872d2e32cc185923e50e294676982c5b0ac9a59a8d1c6292a584c1602afc4813c84c79132365bf66912ca51c132583f8a70e8f0e08b3ece15e62c29a3a17e46e8988dc81e92a625ef85a9029b661bc84f1c0b54982041b488211207b2d7bdb9eb20ccaae8a8d62d692373f4431029bfcf8bd10f48061c10d6eb8410c90c01811213f9e3539263ffea993b22c14a16acdd60c144262160a304240226c322aacf049999d5a8879451481320c31898e636d20d2d13c2676ca6ce2346de2f494dac4e9fcba2a13b0400465488d881f375800a302e48614252b416644b622455b84dc18628c727362c80d22642a03c06e298068cd56b843162a4a64b1f242873b933b4a96248cc8d2c48b24ae4cd08b1bdc0bc307395c9a1b865c9413183029306e23123e8c4938398c4e44318a995d530b3831dc0fc90c1fb8dd8a830b19ee69042c48fac105946b734749a221d55e80b99f3b4a12521049361843dc2f7794a42c2ec4242fb0580e6aeac8562a779425885a4bb557acc8d1e10f733f2b28ae3ff247822b747c0a8e2dfe562958560a8f6b4dc04b695ae155c5dc63ffa16354faf3f3d8621d8f2d4b87e31af3a79f748c8a6b4caeca99d18aca95b439dd87f45e36b7784c3127574aa10a787dc34287fb0aadb53fdc0659426e63990f4ecab55163864bdc76f7fb7d79369e9826a960f1be6e60b8af36aae1ee3e6407dbf4e1f50d0b22aec4ed3f6e83aca1dbb8c674406a8c104c62c07de34d164bc96d2ca7c441e99dd6ce1e8e54a526b9a2f55818cf6a59ed58c2ccb087013e4bdca3d216441b524a2965ad392d5aa7848b2eca66559424299a32d464766777766777164700c8159f26122560820387d8d0223ffeec0e47bcd793c58911a70991217f8b204fe495ad159f6007140c65b9c188177e2af5916badb5d65aeb10b533042830a29fbfa3180c29c84e72e068f2eb60554858d48f2d41669828aaf9e1e57a31a2f92166888c6d26489153134a170621b00922991b867cb4930e413c116c126412bf22221d0e2f364f052d58946ac871da8816645758883511c3d145e9080814457028156d40c85864051c369821c1d104ed28880788e0606244e11544a31caad150b8d9b25feb2c094c98e4aa88b1706d6cb872051e82d89e1283a231bb700205930683c18e44d1a202203da50363a6307eb860ee285aa49440cb0b5c50b95cee285a6090e40a102d4ad0aee78ea265091b19b4b828cd224c6389e90ac79de30548dcb152e852d0414787254ee1c76311e6be46c8d415e4ad706cf10a67e998d8aed0f1987ad8b9cab231438a9d5563b278b82f55b70a5f61a68e5f2d17a5dcd13da92c318feee964171e93b58345140fa878078bc96dec49a1e93d4154eb110cf4e8b0ffb77c3c010d645abf8ae90a02f36b4fffc71d6b8489232d0f0eadf4516b25eaf6705f570292a7016d93ba8bdce188dc12db2c16af6fa4cf8ce57eefb4923f3468cc90051357e220b7cbafcf7d5af54f25e276585610d79faf62ae9a2a06575cfd5692c94a12cdb062d34a369961ed1d8e533b9b7cb2c4e7cf4be6563672a1262e4dee23159a6489714c706b721fa9600308ee4cee2315845ad0eecd7da4028c862bd325044209181db81f0c421e6e97fbc8470b4224d73b7231c68710889323372a37dc0f071832a8618ae8c3f5721ff958c104b7e63ef211a44596cbe53ef201a3b9a37499511bb8a74295c245a3e570d16834174d872b878b46a3f9d72e1a2d878b46a3b9683abe3f4551dfd5c7db88aa48d009aeb9e3a2d1683453cb90728a0aca08e1c4613b2146feb8bd132de68477174d872b872b29c9f522486fe58438e10c1180c879e9fd2d9ba391ed235bc68cc9d45d8a31ae5f07a8073febb2b56b1b756e34da08a12bfc2b8e42152b57925cef2e9a0e570e575be92b9df4d2c33027c4e9300c3f10fc4cb7939886735c2fbdd58a31001f12bfa40b395c345a0e178d4673d174b872b868341a0d575351f46decc499aa2f9c2a3c2fec7a2fbd7be68781a9232fd05d5e49ac42a680219f913c94deddfdffff9d524a29a50fb8930419ffd34b7777772ce54bf9ff4effab1e67b2de75d6c479edeeeff56b777fa7a07cc09ffeffc6656c58ab52d15a2b5d514a4998f7b3dc8dbbbb4b4ce9af7000e4631266f84e030306954c316d3c95f3a8fceaee6e4b6baabf97af1cbeb057ba12bfbefca29452fa2ffbcaa189dc8ca59452eaf8e5b793c194524b29a59452ea81df077a4aaf97e9a8dbeeb7335fb9ee6a739a46536b28eabdc8eefbfa724f2f956259777ac78425ab9b6567284daba69452fa1ed8e0e1779f3add3dfd294f6d7116f5594ae9d3cad98e524aebed0429d64c1d8952eae269e5a03ecbd9f99da9ffd27f7de03bd269becc75758cc63cad0f3cc9dc194a29d8dd327786a60675bf199aff477dcdff7f8f4acd7c3b5d4decdda2391da331a594524a2b4d0d8a529a9ad286e2d777b516d72a3357ffdf4bf1fd972b255dbd5ab955df2b85faff5e2bebaee28a1072ba7b6581edb66ece4963ce3973e6f4e9d3e7df64efeeeeeec972ef6a55f2bc39a7e339fd954657ed7dce9f52cee67467bde69c73ce39a75fd895787e375783faffff9cf596ad7f73fa4c25c5e0e7513c29ab398eda315f393a865677ec4febe931f8d9dbe3563a660cc5e17dead0ee6581ec983eeddaf5ed9873bc9646e7bd3e98d8c3691f1242fbf4c6f3f0347926fbada6d723db9b2debbb9084d0860b870e04341696bda9b9412c83db08374f4b75c3803bab9532bae72439cb8194b21e012d63e21bd646a57d35dbf8367aeac84a95bca3bf338060a6cad10c3c7490bf07c9165b9e34501d2141fa37412808216a803283211b55e194ffffc3c712875454ca01c8145b8aa4859b2e2f9e40e7883f715552c5c95083235fc28f5a95e106a2039951f10521b38420e28b1c3822dbbe8d1995109bdd2391680890a932c00c63d783aa735a29ad1fc470054a7e61a32b5492ae8c30aa5c8162063e821a1331519d1626ae787de3b5c91b00305c4e04dcea9e1499c33cddd399c31cc7610018b935b738dc608bbb2cf0e3e66648cb6a750cae95396bf220777409c575b524667f28e7ab1a8ec3e15fcd9793c3129ce1309e3a26dce18a2f873d0f3768b2d85911086fa898a24409b2ad768616638badef38b6f8face636bb15d7140826bb1c53756646c599cfde1b0b5788696e369cd90c3ab2188ec0e5ead153f9ee1062270936db7188fb0a0851147a0c0d8e182b98f8ef03074bfdc4747720899dccf7d7464098e0bae29f7d1111a5ccce0080b2e5e7069c2e080e0aab0d4702dd20b1a2ee782704603c2881035301244d1f5dc47465210c28c14d9c8600829bd69fa899a4f2557396a6f3a4085bee3d66788ec58eeffff2d27f32f4ff3ffffffffddddbfcf1de3ffffffdf29a51eedee6e53edb8eeb6ffffefee9cbbc9762050e37777f76aa25e77ffd7dd0efa9ffeffdf72efee52e6ffbfbbbbfddd5be604de53072e78b2bbbbbbbbbbbbdb57afeeb2ad34cf39a7bbcf5ebd26276d87e7ffeac5a2cf9a33ecd56b26b7cb4e8b27bbddddfd3bb7dddddd4d83a3ddeeee4ebbdf7ac773ff5957a652777759a9bbbbf707fa40ebfca4ac5fdf7274e94afcd57274cc3fada6af6368fda1e72a1dc3d9aecafaf5e95793f7b4f6f7e0385a9fe3f073958e01673f06fe7e4f9ececffda9d71e88b912d3ff80f5ffb49a68db5775d8a1b5d60567bbdad3e451295d5c29c1126696ac3779ef792b5f1779deac6eb735752bef0329066fc870ac578ffc2c1a13ca4df8815352d938373ff89dba6350fa2c21acb5f7fe0dc2ca580b42ae500d342ee46082792f147102222345e6c8080c34b2966bf04f1d1f138d23188e589c2c13832c834f2090cc494b11f80211ca046c054e6ae311413c61e445952317828e8488744cf95b1c872d132d20c95c01321d8283231686402ff2a53c62416c2d31edac90447eccc18d122b1ce5aaca15ab00816a132b5635638523f9710a10e8392b5768e48a6d40a07a332b12829d5c71aad66a73ad15dffa43ae18d72752a6a88043814095e21a2247e4a7921fd38040bf82232235cc1459f98b45e6a60643029938a8d4ec5de88e1136400013170000180c0886c3218118071339cebb0f14000f4c783e5c5c2ea48bc3a1481003290a63200662180620c410630c610632a8ea08003bb571b1b5d28e6ab92538f456f188d0a93bc2db4e411b91dfb7b4856b84d6e480282c8c87b213b860ecba34d473f9b735bbfbba91cb070e27583551eb3da938d2af070a9dea78e31d45ae15bdbc4b472bb0e231cad3c4b1669cb35b5de25156c939cf179ee56638e10ccfecb6a85f71ca3d35163060397332c2b945e7be8b899d412132c255c1f44537de41fec2f8aa318cf66b4d8990abdc9bc6ec35b76dde7ac80fdc36a53e9d587abf2f40e01e3970815631636c60ab0a1156e1d4f90f3bb46b4f06b1e5cd616eefa50cb268764122a6fa3d35d117befc737f84ea8b99db2c2b047e2f1df8604004e03229edcb7c70a7f661750314339dbff564fcc0e9c9a593a0df6f6882278635bc7ad7f242e6bc7fc8b650b4fe4b03d8bbb5a6a20cca8cfb705ff2d320d58f8250d4e15356a630b331527f21d78f0b09784f078618b31f88b506c5d3532bf9d045cc023420f54490e05374bdc7cf38d30032a38b8a40b693497c3e92b0198836f00edbe47f10128bc16a040f0755a466aa3360164d6d76a313e9451b5ccb67e7a33897cb09c30f710a3d73ad16548444cb207e87903444ee736dbef78077cd2f9adc6e9d6d3ed530e1a06a5634c4d4df1e24d7ea482951f4d033d2e2eddd15e64dead564dc9fccfab1fb39bc2e9c18b095510f64e817100070a66a3277ae0f11241a121fcb9dae7e9388d17891a97f1a180b4c38bd1126224e5b5f1888cf60c1c7c3f6c8dc5c77bfd82b912b1b53194cbb4a049af1ed9f20d4ed3bb4663028c538739f5839151ced87d66d92105c67058f6ac9c9f2c29ff0bdaeac1800e4455c7948ca6556a6abf7ff36e1a195a095bbf4daa9614e0733785d569c6900a7456c9b1520e50b3485d0470d4c4ffc09715281b1227c1a850f98634100e43b1cb279f1ef91e2a0a7458833734d31443a01cf2af6409bd49ccda11d47271ae8d5ea0e2b1df7e0d5b9e358ec19838921dcbd474a9b967b9494b4fd6918deead420956a79bbc567fa0f0f1736d0a0c00ab61bdd61fb4dae7c1c1dd7fc32c05bbc67e5e4884425336fc30b1fd3be75c93ed4f1222ea65960f253ca2846d2c0f4646142dee13f2dd0a4587877bb31b64186d40d1983b70503c40c61f9fc363133d3bacfb6e5a6d6eb386ba0c6d09ed88f1daf1222abdd5a1fc352bcd6c50ff4dc9dd38c2c09b5f1fe02413f3673684382a1dd44ecf827e7fcc956669913b75a0ae217bc764f8efb0a243667170f49b01417109bedef089cab7c89c627a9f7a7cd11493dd61ad6b4764e46300cc5ac8eb08f3b448148dd44a212f5437073bf71efff21b519d91fcd1729f4fc7684d2824d965102782691e37a21667a4a99c44e0950d4c7229be3e1faf9d1031a03029070b454a7e32543bef3069c915bac9b164dfd320658d64a7573dd8875b1376feb28e972e1266fee6bc5c75bfb808279c340a64e7c16e01d88954b8a5e38e6411fe04adcb71e5b9b20d20001d2c3b3489378b067930d9d171d2166ce7b6059692dbc6b14fdcd90ab2ada6cbdb63c0177a94aa6ddeb62a3139d49bfbca036d955ca5d145d29616274e6074620e8250891af575cbf83f6842ecb19b97a1e8c4e684d010dde9685cccdc21916e103fb0570e37e309a892693f9af27a698227b21cf152c854629ca0b34cc9a11a5b82278cab805ef2a2fb4aef2a3de8f203ab31848683d4360d87393e574bdef9e349ee0a42f7c1e13f0e620d005ee4364af3269467a237b46bda1e525da1d3df2495a4cea457a4b00acf0597da411502a56c7e9d3cc79a3f1d3096b2ee52a95aee1640880977a17450e8546d5ea6f0808b0c8f95c8815b50ab034236e2203c299503373d5acb9164df38d7cf932b14842ef4986b174a9b2e4b87f125d2a8ffd96d5517aecdc05c5158177925257489e9d90bc2cd2d0a534717bd0b2e8f6d4444f5464642f883294c9468ce820cab0c1d66012be6bdc7e47b871e7ee9bd53748e9f69a75a1895a1ead7aaf550686e75ceb529576945f464141c587a4cb3204891a18e16122232c485208b71c93edd5ec52daa140c96dd4f0b30dc7845f615e34a5a515e7cdbca068b8b1767bd0a3711205ba86ee9d3466d51622022cf2c34f7df617bf6e2ff800f9fe85e708b8417cc4e8943b75ab91e2f0117867ceb8c38142b34a2ceb90167101b8de441a66b77fd6e96f6f826d3006654bd33989cc79ed8582d574a764fff390e2e84a2aaecc89409f8dd638dbc1c3b482b9ef0f0c0505acaa620c53473345c9b22df075a3130245c7c962263f3b1911645aacfab545a1874317034359eccc515a07d2021d340647c1d7cb00555ec111cf988773c93042087c75c7cc67b354c5d2b3325c5cc260cf05280f81744499cb1bbf2556b89e3866e94f2fdcd9a112cffc07d51feccca81b3640ba1224109303432c4625229f5e8d87c620118894ce78261509d979c5a7b1285229d5c3cef4e688978c40558fd2b6350d0c15359c7e58d328a8326c6eca1802fce969b51ac6fea73488359b3c192ff8a0ad9862a79f2cc9463e5957bc0008058878fb6f122f4dbf4b649f0e61cfa6520f9df547ed9cece0d4cdfc2ca233347ec2337e9d0bb503c31b3c221c7080c828dd2b5439409105a0ebf1bfce1bc31032d85921c6443319c7b75c39cbd2729c9d510ddd074fcf1c422cd6adf9c80a7c3f4b091a699d1e5bec8e3bfab5201c630048b68043c31f3b66df91beae21889687aed006a7d745e82c50943cdbdeac4f3ebbb56b81c14922723d8f1e163ab24604b350a78632168fc3e30a1ff41d0073f52684cb9f089405181267286c475c016b33f306eda46ac0481d4fb529ed3c348860a38e373818b30e32f97b8bb124a366264276c5c5dd345b9b1fbede1ee200dcac8e02e2fee8dc9537f0c9e715fd6f6554e15ff007cbcee52bc1cc1e088283179a5adc121dc5e240b593518c8defdc1a41a12ab8ca33f19833ad77a39d0d80c2326f993ad123838a40757650782cd4660d175a2ec5195c84a008d94d24a6c4280f6eaee278807d2de44401291366e1ffb067dce109852b637b10695bd1226258241652a93be4959341cb5131f29e57c7ff4410f8551044860963b1130428e467c38a12858bd45a9504565d01f6ba0c901a2b90acd357d4e0094e1bc5e08ee580141088ea9d41bfd321ee81d8b055e759ea417e1ef71aa9f3eaa2a9d730b028a003cb997062e0cce01c6842ca64c94693d1a10ef3d0ced97afc87991acf5cff9fc785f2a13632caa1976a054221de0d73272465f2ca3eaf7f2be160f23a6a61b8a24b5b6b2283ea1ea3bf40f20c75d8de09753543dc80730bb09e6df2515280c52e3a4d0861da1ccf871f04f18a15cd8b00ed03fa5da1a527bf617a5d1e071bcb33e5f66559a8dd31801770a34e0acd35cc1882befbfb885f41bac8ce8e1bb42b18c16b5d28ac308b12d90a1c20f01c405c8e8f5c38a8e3b09bb614d92bfa3cd07b5f55ee47073e6601423ae0d1cf349a2eb1a6c3bd4043e8b156d764571a3b1eba08519a686bc0ba4ec4af54ade220078b463b1cfa3f5051854869fce246e841b834ec0683c589fb5bec071f3642bb2188dae89042bb2cae7c6f76cd42d1054316ae824c36750f883dd77d3341c56f9837ffa0c86500de8a297ab5621bc4162ac042093f2349de0dbabe6e93cc8a00978113b173012111db42b857dd4c08cadcf8a9f89443f87e9a8e5f46a5a5ea26e805729e8b8fd2053a2b84de1f9794b99dbc9c076c166d61b321b68ac2ebae1343e839d7436e9b27873c26988b3b56eed102b978223ede406d382c081d5458164edaab6c6da1407a417eb380dee5721459c8e641d68a30319bd2ab71c5487b42b07d183e763c98001f6d913e2f1a2aa269bbf0a462c8c10ac7825ded2b39c74d3e2f344cb2922bc3f61506bff128bbbab4e6a70257b0a5b5cfe7ca82c838bcdd291a078233da2638400e2b1a1a1e592ca09c584dcda74a0fd30ed18dc5121838921208750de5ebb6442a13e42127b3881d997329bc0223bcdfa30a29430c59b430f5731578275dc7a8b4e50e2e77d0838cf293122a9a680197c2e03cb49b35d70cccfc043cb5876e4176adb22f4905d8bdc2cef495263851d456c36deeb236c50b70cf770b28380ec20c2f6b9f9e4108759127261bf535613e42e2a3767e140bbbfc703f919427277591623c6141a4f50583eefd812f158edd7841af0d01316d1bc3e8631a501883b7328caf40244e9f005bf83c6a7512a4f51ee94de344602d96f05140fd769a3c351ed80d9bd7030dce6b9c0e913988a4f0b2db1dcc8feed0dd28253b91e57d19330738ee82f9cc5890617a47ad0bd3d229c701749d200d2eb8063867707fb3466ae9a72e7bec7df4e2baf69bf5f6ea0de4072a8c3280e008afe7617cf388fded2bc9411892cf9532963c4d4f0a888f743a98f44ecb7fffba61941e9989f0002fc604a06a4c00562c8462ae47d433040f0d1c90891ce0491294c4c5c985bca61919ba3127adfa366db86b6ef2433397c862ede49572217db7d3b21596af8996ab62446dd79eee7239097707ae3610d7deb6435c9bff8e6d565eb652904d46badbc1f11e393ad78ecd64033bb1594921301dc629dc529fa815df6601c1eb1fcd4439dd9a409a59c8bfba4990940a014137357311a94a5e73ee3ff18abe813048a9e0d483926f9bd68e3d9e5490b35140b0bb5e31ceba77ff8396bca321f38b385b902f493c3a5b5bf7e9afcbce86fa1e7cc3e297270f6a68952e9fabd6377b0e946901ad59895ef6c34dc4aa56a899aedf3fdc0d14d616fb08a5ecc89d2b333764c38a07faa87460d064f557512717902b37029eba00d92a44844a117b8374d5153c65346b3e22ebdfd1c20bcdf030ae244c1770ddeea3a86995bebcc219107f897339b5269ec8e7cd46c53fc1b0521b36f3d7c94db3e2675aa9ff644b4d8ec76b75d84f9f4ac72cde4a7c4e034b2107a7081866484a7da76656423629593a7ca81c1e9481d0d41967e3cfe00b44451936e111ce5ac1c2c64bffe56c05688cbd1a1be7a025db666b0d717ceac7e7f6dd15347ba1ea26f8d3221e68764904a5d1ac3792eec48b8d652a0e3fa21a4eb727717638d83d3043b3e7f4f32560439dd21b809d36ec81af37ed0b55d1b89a757f790d1a397846d84d5b46696a3bd6a6d12bd68ff7851486b0db7e628759e7e297239afcd881d99ed3234e4a13de9a74441b28c7691985d35ef3d06ea8b388adcfb0ceec20831ada9eb4e3f7e7e6dd1af5c29b9897ae57dba4e4714a3a5d391bb49c7672602934d403e6b483f49099910ee98983ab6eb252ba4267ebe742cd6cbde53de7b04cce4cfbb227c4dfe72f2d82c7d65eae4a7e3ec8cbe9afd0f97d1a2f56a1130635012ae1222b38d216204882ca83aa80131625dff0abc2feef24b82846646a9ea9ab2af577da7a720dec7a8afc11a70798c9fcd702503e217f133a1557a6aeaad46f3f2ddab59050e300515f8e4c9bb06a4644579f066dff9407293003862807bcb2caa5d618349f7bd81299fdfde77c1043f7777e7fd5a0ced70cadf7cbce5588020a266fc1fd8f6c8ecd0f50d3d056eced0e95c5e6c00d8b4dd0448adacaf0e69b5c067607177c61748bb37c4ad6f02eb6560146352417555edb29d5d1616a799ee5c9fd5c092ef97f9bc92646a9ccae6bd7324de5812d5d5ab96a29b07aaf86a66ff0b7e4dee6fc8d26a1e92e2e317991507a1bd22201fd552177d1e7addfcac2d686330095d4be520e15e94cd0903b5b9b1bbfa03edd82dc1871c9d12e8ca1d6a4e6fd337b3a64db7fe896f2bd2a525899bbd62b6770816c21cf0389502280194cd9f91c39083da68306f8567e6f70adfe37e4097225d8a57b8edafce75be8cc88dfb0c4118ddc5df05c32d406edc8777dd0e459e4995d5d1a5020e38fcc2c3047f134023aed8328e7293dd1658bee72a3771b40f9036cf06c8c644b5e5334dea15f3e991bcf92ed441ed4081e5a1c1fb9396dc9da999c6caa5bf237ad0468633090dadcd9b6eb53a635d3d92e8f572c9cedf4076e34601040c3797fd1b619c115b48003698612dd274322a0ba5e6385c499cdcd04d7d96aa41bcc5d958f03677d18e9e0c858c7925b4147a189c9909f24b62f1855db48278587d726238e474971208fd2f23102564415f1621c31b5ae7020799b151f659769a7e71f01baaed61567404a65dd1c2ea7adc9550aeffff50292fc1161f0b104cb161ea6a704aad0f460b244c109e476304daa3c2b3898c466e574bb6b08a5308e64c2e194f3d050d85b81ab4219fb074758b2bfb847047d8dd29fa7ae882752bc52570e8990732144fc371222dc249cc9acbcd1613cdba85355700d5243166ae8c798de09341d44041bfc8e87e8087af7ba75aa7d51eafb78e09bd1740d58138b81f0242c2cb2db38fa7da17951fa94523bdada8a641129395ab908721a50721ef5482c106fae070630c3e84126f2e7026e2cac916608e2c9cde19bd584076d4e58ebaf2fa0e416a30058348322c48336798a719bb8ef477d4d5a8106d437baca5adcfb22ef9486b7ed95a21fd11f5de0d52d56ef777b0f86faff9bd024772878758fe0ecd4b4906ba855af06d2cf03f74d715a82999b355edca070660d5f4ffc81d5cab272f1f3f803edb52dc222d207bef40e0751e28314f23996faf2f444c7ae53d6193bb016f9082fe5f724f903710fef65f740aebd792c13a7a45a1fa03e6da6f334c5258f63d4cc66950ff56003518be09529c1f3f94197486ea0ff39e67c4cac99904fc4d0baab43c29e2546c9c013d50cae6f2c49f67a528cf309083eb0c44671c5fe34541f08090dfbbc6544a650d1c8db8d30eca03e0eae5f27e2cacd570311733551af20eb8701fb885d50e9838f154f1daae4482deaa00119cfd741fa0953135681e38c633b0c35c4b419830863958d5e895f8f14616d5c7565d4fb6404727bc2606092825728b4865a8bbc548f55954552e1aa0a4f03930a48f64f8bbf242355c8c5f7a288b81d4ca01020f1799afa9cbd4f76d8d52651e10956d0aa1720528924bcad9e97446a1dcc2ecccd12493477e6994fcd031647126bcba93b6d09f80ef115d1b8f5652778a10ac4639454dfabc77057ac09f3d69b3e2998a63d0b5baa4fd16cb1d8cfb8f9f8fc496ed431aa7a5748605d6f74eb7c71aa5eac94662cd0a61da51a3eb3240a173821c467965f81154a185713cc1d94427a9284467750a918345fd158c7e1b30910b84dc5b65d2f8053252b006cc75785abd70b4263d62a80233ab8922ae393216a9d8a5674c12ba44111b3ccddf2a7b02e22f6ca7e5ac943ad686f0a4cd76c5a826fe61fc45a676c129b8383021bc4396917a802602b4271f407ab4978046c92c1ff39692fc6bee0e29c46987074c60de4820260195e75091838e8dec05f427593b0dac948a1d76c265f0489d4f68ceea602d18ce71506212d51f864e60c1ce9f77eda39433b7bbf1a0b2f280cd9d524392b4ff0222fe8a62acdd6b36c2c2a64c07b946ad2567cc2ced2d0d9e1e3d6a56184c10712988631762b92f137d3fced2037807fe6d21ec72827813d073f828a6c3b5bc573dd7a60d265e64dfb7476ccc961827600a891e58027bb7b8f044dc299d4bb0435902ef03b31fe65845581c192be887c17cbaf7e9ca897c250127141ba4c5f76c0a3c422999b39b7b52a923d0870078d55058891277ca6b3504582dafc146418a77c22c0dd1cf99741164506a70169f1855135760b3494832766a53947b33bb40d7f656b8caa6138c4e628ed40169c036c4e3e2386ee31e0ae55852b5a769c78a6e2a9f7dbb6141765b01f0502955608a78a7098ae16e75b19590c20a47359c6a144545628fc390d1c8596b8eef54ebf11ec2ed84b0fcf34e784a65d72f7a592c16cc4b693e6e14f0868417130192a5cf2323aae6c51d7cfe710678f8c87cd61d4e2be5c98af5311809b45be29f67eb5e30d6c9c6a02c5b5b6f09395b5510454600f6b673a21b2a9c50f177cafc02a20c63e23d06e898f8fab8fe0a693c8d3eeb800d390efedeed045a871110b5cdd158c8f0a0b82adc973fbf98096d0ac01dd8183ac7572251fbdf2f2c71a8306ecccba9b430027e74ad1f5eb755152d5bfbfd4ca1aed3e11d7b10e117f51da6662015f828b08a8c16f1168356d79a7a3d2611fe5bc0f0876129fa873f06c5dd54c6776ce2060883d41e41ca63c08141eae13a884e2059ff6a73ad63e01c127a0da3a4587e5b54ba8ba97465b216b997b6dc1bba316196c69d9352b10bdd0f94684bb6e95670ccaf6d5002d915ec185c8a6def1dd1194dbb7cf828ab5f0ac445b23a6a9e87e407069a6a5a8b06eb13084c5ba02448556f6680497be2e7fcac45743a4c492b69bf053a5aea7e28ca77b1cbb7a63c40ff29d5230f1470f22c315df38e99a6556ae4e8b6e8c39c366a8a96fb8bb7a8a264ba12d7e3d0bd689b4d5c3e2267adf52fed6ac145b50640ea6ce06b3e63245a4fe4cdba64454b0e182a5e640d50f39cfbe1e064a5e0d24fb759b7741350c8eedf6a4f64bfa7007bcec918f2b203c8dd2c7f4285f9a37b3e49a604ae703eaff2c1c59de380583e815a07585faa489448890bca0092ca8ac6fd9f9b93a9ce647b864f8213447ae2d045cef5568e5fe7c0229e33a56bff2d42bb75d1fd3acd9cf60ea464fa8aeacbcac788d094219caa9bdaa04904b148401fe2f010c0b5698a438ce50c7861b0096fca4aa3f871702dfae180c8249f25abacb8655612d1449efb10dc98bc1665c2fe33ee7f92500c2ddc59418083a4343a996525c044ee8edc0be298bd13f28be8561fa401dd0ad150530afd1108238889e9f5fa64f25a71bdb08e8d108e82888683d8ff8baf82b4f1709109e927612d95719e402c2ba0b1b9fcd1fc5bd9fd9cdb18600a626bbce6dcd9653a84b08eec2191420524f6678dcba412d422656b898eeedea9d2f2748d57c88b655cc3c31ed054a4dace0a71d7b4fd51bae7752b81311d65d42b7ede5e3c477845f7a06bffbca4b41e4305ae1e4c428ab7341e03af9a0b6ce8ee438b39ce09edf48025528c338b8c807b737080003a0884764b972dbac5fd8a1d196b480f6d5f1d9356a206a25ef7dd5504b46973418090c0265c30072b3ee3344a6f18d3d19cab8df175db8b3890d88d12cf097ea8e2f1543c1a0c06946f556b3c23781df1af9ac3fe2dbf781e09c614a10697c1096444f7e0da43015471de4d2bad04eae4493ca8a56f6cb8a4cb78c10fa4b138451702ef10394d19d2319a05412bb045efbe89a76e72b7dd9a4c0de56367ed8b2fd1605c9e5a4b7b5291a8cc992d2e2810246c8f747b0de7f7992395cf66dc180ea9e23cc14f5a55945c28e822cf1b58e4c7240b78b22e4e0973cd5726ce60fe5d20eba9fb791a036c29aeb8dfb13e22ea42418b06fbd28566c9746891fa8b388e8791c48c000b868181b06d06376ab1824ab776fc08c60a26c537d49d1f65d2d4f6830af29ef5b1672d0ef57c33f3fe19588efa84b41b71ebcdc6c474af7db3907f989235fe93297d39a50c528769dca711ea614a4f773951a3d3f6e1040ee7df39d6e922ccde0e0a8ca9aa25e29e03e8601a4956f4eb518588b727f21bae53405946812e8c89a32e8abbf7452a6697e78132994a47d69f6901f05dca76e278121f5dc4ab2f9228fa2865b47e93564094e39546ba2dcfa9920b84e2c40ce523f8f5dcfd91b25729b4fdae63ea89c7b241e1c596999fcfc03575cbd39fb0695d55d8e5152a58a1597eb72981311e4b9dfa368b8ca33c78977b54d9d3fb7525162866409962bd7ea34e201131f8f6c21e9a518e98fa4668f1dbe156cca4771886439bb43d4567ddfb34cb9dc318f3731c24f82df80305d1be941461806a6670859c3fbd984d197d53f253b32045021f40091dda44c0175408d80b235f82b40d708bf5420b6e1612c43bbc614c394a8056e818b82a0fb0645e94fc71411c6067aba2cb208c3b420e1cad140f112112a978947b8202353855158fca35bb8a2c201fa1ad233f64e8891cf0cdcf6a73b12da81546f188eab38bc602850d241a538514f839d01ca624d5a7b05496136a5a4a80fbf105a3303ded484e83f2e380605eb4162826e800fba03e24ee8082a33e003748787b10d426d980a89f21af41144c7d85cdb6af8d15a60a5819d31658226128875c0aed86a401109c64a37565b310a4306ba89614ad0d895cc682a52dbc0663ee9845e66e46c5ee09542140406e70a9c80b40bc92905961153b742fd27cc0358f9d22044411da85bc8dc264052b8d13e3be0bb9fff5be8dac7006c4165f30f349692ce70d6723161e0a716c2bdd6c29cfeac2468d3c8e81bec420dbc1f82849155b98a6500cb1db90c2a13fb8237578424368653da4bcde9f95bbae556858a874b739ae2ad6631a0955ca9247614b59e083784a6d777e5f555f9b1a0490f623a95dc651ff8f81ad093c29d208a832dd5def508bc040bb41d2775fc1bb80365efcc7c14911094c1865c6b9ebb71b58c02552149d21db10dc93f09043d9186996c0af98f3ad3a06713c45bc3abab2590e318aee9e0db39a807566fab1a0e17d8a0062d935d08d59882462120599e6eb945e714a131af453fa70f40584ae71d703197676c62b09afc5bec59786a72db2657265298f89d7f3d5d029461480913ed70caf81d9f31cae1495513ba0b39451a8591dfa0ceadb989d6036971f24c2f75d36ace8b8f298413dc459b9a7c74ec1f372833b21cf0f88500d4d61d930d0de98472abf6859082f9beab109e7b9aa24f80f67e2d273ff3660ac2ac265a037409cf83bb723840be1dd83a47b5946a12a07a3128448876cd0d456554e4a2c6d211009aceb63e86c0137ce21cbccc84c23d59131265004aade2336d2fedc26a1c2a9cc5aa272fe0cf5f33d27a067eba590e0b719e646292547faab164bd0c24d5a85bbeeae1d4ad72155f40cd2c72248bb0a10bcc284379c751a96a5acb54b027bdadb032b2ca0a54aca352b6b0921913fa0e7a0618c5602ebd6ccae333feb8fdc343f2d42f3aba3f411d69d26c3c5004bf99b3bf535877cb58f101d43d93daa296a94bbc8820a61569671d65e61979eac9f2a86a2ddaeb501fab41dd543c742da0e4527f04000a1c48feb4d10bccc079c4b36344416ea0948dd4bd7f0fdbd682094910ff468616913c01b2b07850e81eb873128683e889d785589c3c0dafbe61b2661f1415db244c18cfac9e30e86774b2b19e0508f3d687b4ca86613442315c42f1244817a7eb07aebadb654b3433e886534dd3839a6da9a58dda0e68b37dce520c9ee66b8fcb8ce6361c8bdf81d950821ff46cc7b40f97ea5d537e578859378357420f722a3420676ad204a8d619948677d93085936cf314a8f5bf93fe690c4740af777268f6ec35f0427b45f3cfa6da2374ca57a03ccf6df6b1103388cddb623884acdc4de051515d958878757e1125044ef03c9ae121ed95b353b00efcad93c6dde70bf12a077e7e227f01e2b5ebc00d0e0bb59617434cd40503490e9ac80f32265cfd297efbe64712357d5027a021f05a6c62081a890012bdad8a8b123b1a38ff706c0caaa50290c5bab95294c4c5c1731831ce932ee11a59f9ef712a080343d08c527263286cbc0975a4965e23d37c4b519cc4a05873e0376443fbfdb0e5d645fab842e6dfd6950389cd7cafb99818b709ba10eab352f3946bdfbf381cfa0e644df698a535ebbb98124d42d12d2b86dc702eb21902186cc0ff88688cbe46f1be0263ca1762029b85414ded2ff7010dfad105920f77cab0d7f4cda2c2630fda6d469ec3b904dd1ac5de0e623cf6a8cb46c709016d0dac2e5bebf3c0e458bd6203578dd9ee112a57b4915149866d828525105ba01ceb9f21da4d9c828f28eb8e0f5f877eb362c0bda0c6d117727344c2367b10ee3951aac6dd98d2759328f0ca6a99e7ac7d20f361fca569d8982d4044a028dce1d28bcf18d548cbccd50900298914726dd6b47200331cb7cc8b519061206db8b39a0ff8b8e6a261f9134f23cdd44adfa5e30b2c7fff9da6e6c6bcf86996a6535df054f3b58029f557e624d0d08bb1a8ddc1f195a23f4ec51c69cd7ff81d4257ee3d52abd59dbf4e6233611d14d001dd26cd1b077ee3c5f24f278b34e8fe201b830da21be340fcfa2d17f39924e569830e31f6d2239f7a09e3b9ee2990148656787baab78b42418742346653ee38dae9da3e2d363052ff6d704c7f667852f25862069e583fadbb1690df6e4be619764b1ae7202e9b583683ddec99b2fa1395e3271676b68df627c67d35d2774a0cbd91f65a021fa06aa6aa0059e3d9407e79ec8fa2941acaa6cf0ff4af99226a0dec8ebf9f3cdd36b099eebc434b9b235a519367d2d220fc2b96e065d4a348fea9e6cd2523c3a56c2721aaf8f51bc270345bae13c2da86b3838b8e2c7d708473d1f2729958c95aa65143a597c9d2e4b74eb82a6ed184147de7dc465c2e2a8a84ff5a0003d1e1fdf17d1458932a442ad009a2719a2bb145b3baf82c39858b5ec5ce8674599fff3828a48a3ceab0df7e9d86ff04d6fa7cb6e6bc031c2aca0b7310d090d812372faad95c09b55f28162f13835933c3b46a998600e87588ede951b513b77a1f43af5ffb1eef6801f4b93aa00e362310a02ba26d2dced2754a19156d7d7c246cbc939a6aca78ace58983c035390836758af77463f8f9fc349cfcc27964549dac7778a658361d84137ffa7d46c4518caa2dfbe738f7629abf505936121feb49babd1ac44ce3275a63fcba3c4c6b0d3fa99a5baa69dea226ee5b6d4fc5a92af6a5e52e97b135e54dc89b7cbb690a93b5dfe92df775bcceec12e88bd322e63e7200d213a0a9f3c4e92d950d63051b65ed3f42132fba7ccb62d39d5800f28158c2eed121b3a17fa7d1326584537390aeaae48f5d97cf95d3f584fa274acfbbae2a5ecfaf0ba6748afcfbedefc419b62b55e2efb49dbaa3770d25ff99d2aa31c67ddc7d5ecd8f38f42369502c3874e2d7beddc255163b98374571302598979ad8b2ff1524934dcd8f226717a37680e0765d434671d730f546be0b3f91a17a78e6f5c7c707297950a768ab7014d39b0986a31bb9feb2d403567f2fe252cfb926c1d6a20eb6f6e74ff8c11c7a06dc871c0fbae4c48bf59aab81557ea515661f236a4e8dbb07b38f824ffd068b786666002b7fb9b477d457a063a059f9a0e0110363897dac74d98adc34b3fd1d8621b28f992117bf00979eb09749c50e2774db1efe390935726f1a32da030e7f717da7b12b3c375490a6741e9edb81045d994a0a677bb87afaa66c4446bf55d68a1a11fa55249e671dcf97cd664ae851cef4552332eb1c76c1af25d796f495ea10cd49ca740a95dcc4e6e3b49e899053d542bc8ffb8441d335228fa17ed3b5251a8fc3590ce1fbdbe02135e831b30becb6438614d5fda70e74e730777331f43efc9a63348eb8fd7662b0d97386d002d8e06cac2354ce136bb82b5619ccc9f85df17f630c783912085bd1e259c69657249d72835db4005ce694427d4f0d5be59491c8ec4cf0112acdbb5b8b60da1ebafdb377af7097684703747f45f63db5f62e0c5403b497349d457a7dfc1f1d72dca54b40d38fc69f86c24f35f13891fee5b466f6821b4a0472dee3333a8c5d5ca5d1f0c18ade7cdb6932d9c75eb56ba342911760349dbcaf84a98dff196a9ddafc2b8ad6d784da52b1461198fcb2e318f71580bd217b628e8a119fba34b2219504d3b0ae0d39a41da448a85f2474f35462498f85321aee754e204d2e05bbc1e0d4fb167c85dd27583ac18f7ef81268bd220bf2b682b4e41fab524c55a78048aafc06934f9c83d641afa8c4e42ce80445762e5b3db843cc681229fe5b7330b50797105598237cac3a4235c397d81e0b6d22f4cb7c9c9cb341c1e7b494b9cd48a263b27f1cf1945ef0b44f4fc8c95ebe4fa0e6dbcf663b1693d8cb636dc7d2c4ad5ebef3c35b861db3d257c945e2ae536ac32de15ecd5369b8f1a254ebc5f18df7026cd7913706734a377ccf79617bf81b85f0e36776db11cb956dba76101a033d42e33945ad70fb7f1c6be0b9af58444c7f1943c54b3d485ea095feec24b208885e10dc260a5050c889fb21b68280aa67910063523b8ef200ffb1397296039e22b5c9b46cf1f48a88ee9c9200de0e1b98b8733922c72f7dc615f62d6456927a7517836f64c98143990bba0905980acd21df42b0658eef1e6b7c8602fb0ae65f72397c0b0b47f8474aa43fb564808c64df422d25e81d93bea0e04b646d644ff8161af25227172ae54ae674649a25f30a5ff42a92536c7c678a1df5e1ecc35700fda37599f7ac4afe7c2b81062b6a375f4e224d3764e1cb93812caf44508c5b4a2eb3eff02245f3803acc018e2ea94da9d17afe89b067f96b5195943c3392b8816f3b08e9e1c0b7ae7669409062000491bd344303f805133b314417c91969a181a339cda45a721404d16ded7dec0ae7e9bd9cd9ea9810c70a2ca6267fd602c27e4119779102d1e3cf98c9188111f8f60b4a85c14be980a14f31873567713f6821f3c5d52c5c9779472fbc0cf6374a3a5bc44d91f8ca6c85e8d6d7afb5f9bf7d65302460a01790d50f644db96bb809cac62b42952e0d7917983166df5396d739d6e871045e369403c518413586d8b27c3d7f350b24a83100c70dc3859455671e3679a5c9c092e15cba6012882170131a7022fcc1b739cd1051c018e1975274a46664e82583d57798dcd4183ee2fa6080dcc7de6f987979db612c6ff4cf1d89b76100b7abafa91a42d19151886ce07ffc557a49f9dc49229a889725da0bd10d60dd5246977b581e74772a33774b06ab9dc8e941efe114ed7581c616b66f0ba3a4dc05ddf48aa372d0cbb53c1c44596bcb14637f5e1121a48b14b569e6b86bca70bd01fb4a3a7277eeec368450d309fbe98ca9ff87b2c237d25d5a4149de38a5be1bb17e7fe666a068ff156d7b5b0cad2fef355fc14fce04e2496317f82db4727209120c0f3a2fd8be93e0775cc3c6a6761b8b75e37f99d4be23496e5708b92267735723443da89f0f96ce450360b9d31d1dfddf48055efd76941f07f9413e86d71c5d1df2e1324cd89dfe84028ff0c4be4a36d4b16eeb364f7efc2af51be8d1d7eb080bbe41c20a01be827d098f00f0bd1c52add0b82dee12b137753a71baaf8c30fd14ab81f33402690723e747e894b0f4a3c1d3b3050ef9f669c3d1da11215de238dcdc12381d8c65b2eddca014bea6d73dedbf0c232ec5e8ef5e4e786cb44a6d4631a99322d9ffe0c3495c196a35df44d56506448f1f1739d5dca53b8fccb3819e7f17f7673368c8b8048ecd4e3a6daa1072d75ed32d8bebc5c49199163c3394d926e24feb7106fdcfcea91599fefdef18d524e90337a92d9ad1586545c1dae1c3df6e040dce7f55a9f488e0011a36fe9460f8528fbb3e177127de898afd0beb6927c13fbb4dfaa78617b8ea234574b7b905bdb0f974feacf00be10cc7e0cc0f803c0e1e94031d30b37793cf72027675505ce053c3d537ce5b74c9b55aa9a2fade9faefd027c2c60d293d13ef0d7728680a70fc8f419041c9470b558396ecd2ceb572221bb3a7598339d2abcf1001bb59edba032a8446954d5f42db8fb5485f68c626c60feeb555da8df251182fd708ea05b834582f7de84012ceb40dd15bddf0ad3f86fe4de17585fdc5d952832b995316fc396fbaea639da06c606029311fd9251797a4ae870d137d329d2ee8f33bc59fa6c755f87be7e3382409c479c7889bbbb6760040889297f1a065469ebd96313e988aea3372293bd89b626fdd375a25b1fceecae324cdcd6a708b53ec4574252eda425044b255c78d5e21a3a1c29daeb68605c8be2fa4dee0a026d1f80ee24e01bda2eded0d8e1c07c0a3ee8e80784dc22b846d7be67f81b618a4ce7e186beb9f5fa6c8daefe87c2fdf58691319f0850ba2df97e62411f732b3e714a85c46dda776c869ac65caf1a74d493f55c7b1d8ee15f0be33e784fe7174b34ed3beeafd92026445b84eb7979050c0b2d16733cab7a2e6202459d61f9053746283a111294e593fa454c66749a7254c150bf507565f0ebea91417d6d20187ec42f5fb7ccd77290f46294acbfc67564d0242569c3090c90deb09200ec87d86ae83b83830960f96b5248e930bf753a9d5c19f59a135b686b42df5bcbe7ee9a9ef299b086c72ac82829e8ebbf5620d777324a5f94cb1cd57afcdb4fa9e3c3c4a1432aa1a3d826d92a3671cec4262104b8d070bb7e7a515061383133f906604a072141fc965bf98de1ff341069658013977dff786461b3b13621f27d4b181adde0072d163b1572d8ea08d1529612230a3b9d39a8c5d83ffafc6e30576b7796377da74a31a985dae10b0c7b4dc9954b3f7ec3313325c60ac4920dc5d19d93e5798189f7575938d7a4f2635e635e7220fbedf9f0356e053f4bb4866636ddab29d13b2eb767d71fa6115cc85b492ef5d7452ec4399c670f00f9b453dfac690d1ec00080b69305949de57acc2a1326e66a0078191fa68ea255b76a1357456f5a125187b6831afda8209ca31716a06d782e4ad4f3988e0dd2202ac6e31c3916edb999be0a17fd97a38e4e61c7348bdae9dc7102de2b788bbcaa36ba7221d3bf5a2d1afef867a39a1f64d59218628dcf9f8048c942aea766a318d86c902d31226baf33cfeef09248a0a4998054edb0e98c3a98b87d8f3abeac04db5751e6d1cb6ec93d4d36d65553700c782fbe25bf44f9dbfea94ac227ce586521aba6ade6c4a9c9be4b4f467ecd151f997c7c6255b09abb95098f0fc4f56233168f9a833ecfe0c7faa7aabfbd7573ca46f6c23d2d11dc0c51c61b56557cfbc10501d05e19c860f34f810ed214e774dc3c2be45e1a44f2c7e9538a622f821861c4c92fdf5281a7d0377a7e139d3cb9584b921176745999a5aa9a9e465fddec800fbc3e54c417d6402f525e9e157cfcdb6e864f83c8e0e96dbe54efb2ee0434485c96aa3d5fa1420cf0ad78ecd2943af11bf5f72269e5a64c879bd9c4f005dd5465c47dc4d13c66428042f9dfcfff61865a926a5032501cc4853f90b9a23ac75a23a943e7d85c51330a2585b43077489602a60a3fa82bd0edf6f46811adb5ae829102279f4b526ea99bf0796b48bc5902521da50b95aa89dd91b9288d9e00dfd2b804f6cdc9b08394273464b033bb8b2013b6cb7e47f8807f129bde855d2b7242c147e66dba936f735c1123a79efc6c44c03a0470310fc0497e2e17f857cc340802095bb10fb857ff1057868c6239c054f1d058889b50cee6fdcca11aae53a6f454c2d15ab7a16039702a2e43539b60ca68e562c13d4ecb565d95fae5c29e3e669565dfaea37b7c5b4b84de44580c17af18278e7a6d9b564c406857746e4d42560c0a1102d2eb069cdc01d2ef5330a2bed9bff252b9e887d284d57c89b52b6633969511723e48d627ecdf26279c93d6cf263bbe7370aad25d10db31d38beecc824152bfe11d6a713da9df7eab0f1b4c452e8d0e8a320efaa6d49947fd82dc34b389601d0f8aca9db686f6c8ac376f4445b705330038ab7efe3b3a9714812b6b242b2d6a22eb23bfe6e3a613f33d4ce3f3be2ee00e02662aad313031e3f790969fa4276d7329de32355f77a9ca9b50061391b232cf0782c946aa684b99c7170e367e1a72a3284ac33751d8c95f28a4081fee4c86a0d97a094c73947a6e435ccc81e3ec3d0e3498ea5ae586069f8193e63aeed1282f523b0bd5f0c93c7fe16aeb05f70100d4789a3fb2b036ed7f7f602abb478e5d63bd3381b612b61ef7fc1bfb3589f88bdf40dcbcc6bc95aafba8ed05296e40080ba6b79d4664630a21b62934cebac5fc73a197b0eab7b3976cc8d5674d457b5109bd70c71089cdbed50f0490628bd5c47bb45effb36341cb17bb19b7ba3986e3966b0207411479311b02189672e33c4148e5bb06593f37659d196eaf9b2142ca8dd5bba539dc77131e50dc29426f873db21e1f0e15c8e35fa2eefea8f6dc979c0e09cd9d7272c8ae678b90411c97e9d6b004e12a37adf668e349f52189c83554c356ba386542ab7ab81651ca45e6afb8c3453819b252625e595c5e317f2aeca3133081de114e370c3322baa1fed60877745f37d21382fa7a0f95641d60570eaf0f9930cd14ae03840c1caa08d3a07b4cf0a9a0d34770daa393c75bd769a76580d35d2e68fddc7404d4b65c3dda54a7b7e3854c1fa3fb9aa0b7eb14f9979e8aa4d0f7c1a16b1d6cff434f2c52382ba795289d40f41c3c2f31b977e86fae8310e71fb58672871e92bad782850aa25dbed375eebc901dd0bd9e9273c087d2de24a51434bdcc92629f2ae19aa69d0bce0fbdae98c03ee5e261950b4afd1c7215b119783a68bad0fd1dee23391f8dcb35394899a352832d2754275e99746677801ee5c2cf3329fe89f3123193ce52efd31056cb003d2743615bf3e7515b3013cef3f388569f47bbd5a0b6862bd3530ec34707f4fa14360337feae21899e100355deb735777fad88089ba3b921627a53d82ab89795e033ed0ef0e879598a3163d4229eb86145e8dba7db6b9e4e05069928cebc7cc49d2b02f4b2793d0a6da10c5945366e2aede6a1639678e3ed7f2a4ec1da5b8c26a78124960b70b461f82419ab75ec0703ac0286f14549c844e937920c94347d20e4582e45057d2b3e5baa3a51c9a8fc05407ebc2c5d420ff8823ee160f294323bd0005052d25ac938e05f4ec0eed7d3b4c9e087c834c02433fbb084f2531c414bac8920b45ea75f52a61698ce6e747bd2e018a7d3c1cd1b42f96f3dece717295958d84b46d8d75a4952ea4a176ee9a87696e369ecc53d7465e4d3c759aed2957f5303b0db25675c0d4b889ccfc4f9150b5d96eb16b49f61794aa2a97dfb397fd3b6662766a209ac593ed08b00d88eb0131bc97179612d911ef00fa49e646b6152a13ef69f3fdb0d424df27496b44cbc3dedc3ccc7e25c96d8aa710bdf2bc45e85182e202c5b0d23dd65820dd6a65506376152d389a5e282c8b898527b317256bdaa3be98da98527c510afd369920d9b616058b2377b9e361af7dd85bca3d35331dc9d373fce60bff7e704678fa1e3737c79383e8c19f8760554dbf43148110a6068817e9c8ac81272e3fd2acf50bc1e0320018bdecf258d48852e9ecad58cc3faee4befc393bbfa76b18d66c07621dadcc78002ef3a9180594bc2267664547444fbbceaf8a019d7c22080086c4748b5a020d90209b3acc2686b1fe14c1b02518bf891fec37823f95658a15cd83ccc8a023c71c5e8fb9021d9a3cce4aa48622bf9793f56e2b3f7f9a6dd006e803ff2d534bddefcc3b24b60f90a508330be8390941d8cac27a1ff39bdddb2dca07253eb8ff74d3db78837cc02e3d3faa41e01012153f2b15df2423cb48332bd4c7625ed2436a61d91f1a0389906dd6a74a40193f4d051fa7a61472c5e709eef74f16f307e42fae827197d22412ad6fb9c9a40d09a9c7d49495b5ce2836ae9f82ff8dd452bd35b004e658a2818f1c32e2bbc345f80ebc54afd32aeb33708444fd8fc6c9b43f312991b83a8c4c7d1189bbc83fa131559bbcb69c8415099c3b2a14737596183e465433ee60189fc42c772a1175990792aaf00c7cad7ce604002ecadc5f73c650910570eaa49a7d602c6ab799a87a256888310fa8ae2ece0fbe026a68c2ac6fb40bdeec8a921ed3dcd3d9af03528a866778a11da18b06f8f85a2596f2170f572a6f939559cadd9e7ed33c225c55e4ba9aef80072a550f0d85931ac021f68703657f73e8925f81cd779fdf4184bb4cccdf667bf03cf4eeea24c54f08f4d158faa2574ddbb9edee98cea195ab7460685eec506f6df97d14d5e5989c054ef428c2b462661433cc2c7be41a546b09c3636792310c300da66e4776a4848b3a3ea6ffa0ac9896aa4d0f77bcfc15eff57bbe5ea37a0981d1d07131ef6c333740e199a41d0e12ff0c49f0f7117b31c49ac91ee9d33b161bba92904026b665d63083c07905ee95d9ffb49b1df8e4f7ee3b92280ed13a3084bd324e3dc161787a73ad8b36eea42d90f332cd30c8d10c34e65790d59095946f013a3f630b81ada24c075bc00b0837c9c54bb275ccf57a2ec947789d0b1c6595bb7f79399f1e9dc68d804a486c19be164a450b431381d82331abccbcd0cafa1934206e502f76478904c492be848b6559c3e8b2fe65f947c2edd8f245bd6115afd0974873134f6730b0cc74f359f06047671ffc500f65432ead4bea9f1fa6ebd86604267d1e5b5766e3d77d3c526e3cc2ec9c21425b53390a0398d49fb9a3775f4b65039932a8a6d3673ac46ebe94706b4c004eadf4bc158309a55493ab94997836fa9ad91e698ae1372c7228d282db805765cd2d761d81debd680de4b9ec23d23381fc5fe2f6017c49a453a361590a574c1ef05349642d9d65a687eb19753a73634726d6c6b9f10b21bd984ecbdb70c2d0cfd0bff0b3f6032f4832df2bc5c22ca9f792d6543552d8bb86a6d1131a33c3f7f1dc5196c49f4381bac5505fb655f2f419221d6ca13758d257b20ab394964a711b8081c64bf7894e7446113c6a978ec29d3b19ba2299ae26d748d797a244489f2a42d5a94679c731e80c7bd899e2623571368557cd441d7a0af8936284ed163294cbb32201e8e38a45cafdd20e92c8955927b49ee222d6f56eafdcc7643b416d073f373d3c40dd0cd913893dafe9ba01b2b1a47e92d858f5047a12877ad75b38158c2c0b65c2b55f5a9db49557d2604fb5a0f6bf58c72dfe3c9df25942b568fd1a071c05c8fd5a0716cafd86b3d35d2ab520684a650d028aa0b88c419fb7ada13674eafa74bc41994d7d37aca449c49793dfd8933a8d7d3261a87ca1571a519712d1b34f683c69ee819eef518111a23922b17afc75a72f5f22c0b8c091de2d124b25167d80e723da6b31d4da07924ceacbcebb118cf27933ca317752d4b94eba7075a264d9dc6c1f2fa0b49ae3256fd9514672ea1ebe7899fd3a07b814dc1374790eb6554d4ca95e8df0594ebb54efdef01f38b85dcc3fcf73017f2a7606eaafb7d0e2b75531d4e0d913acc6f52877977188c63a4c33730bf18e71ee6387fcac2dcd4bdb7e56f4bd5a5c373f9c815cceb67d2ced52357a9771db6a96ba54a3eae5aee928a4172d5826512963128855baaea4d295526a91c72404a8734e381e9ba2c48aaea3defaf35283b3aca3cefef3a6b934a317e7e7e689665493229294b4a4a2a259592ea4fa9a816957e4a3fa59f52515151517dc62357f54866414212a6eb8e783cefef2c4f2614399b954f9d23d95913922bad2555f55b140d9d904d91ab1572ddae1081c6a3b53423882bd792ab3aa426916bab12b1db85b91615e5fa7ad4bd5e13925bc0745dd7e10f3a212857a05c3b5bbf6942b9a6d8934c922b6d8bc6d1597ac1d28de56a465da36e3d5255b52cb4aa5ec80b3a50f793ebe6936b85c2e681a7a1d322570d0bcec684371e93a954043724106f411b904c6a1cdbd1651a7a26d1383a5756b5495a4faeda0c727df58255c97832dbc18c27d7dbbb3511bdfad3dd80a2578f72b723770b8a5e7dcadd9044af1e7537a1e8d5abdc2d49d7a8cf82e44a631255f543b2242c916e893311942b52bd8bab194955fdcbd58e90e4aafe48557d96594b91727de947ae341ea9aaef4ea59f5c9f25c915e72355f54036a8133a51fdcae596e091ab0d8b56d5d77a14fc65f5167fd603b98e20d713fe626496bb1d758daa823fee27d7734cc499ce75abe79a88ab529254d5734b74492c92a423b9bee3366ec95614bd7a0d73ade8d59f56ae2f25d52ecbb623d376546f326d474f6c59fc9492eaa611895ed57aa257bf618d277af52f4ab09fc693ebb72ce20ca713673eee4ce2ccc9ebb7a3380373fd8614678eb6d8a2d892e2ccb77121d7d7ed9f6694eb2bd251d5c9b51ee57a4d6e2cb7ef8d24b9aaaf3ff0465ed15b1d912d25e55aa170dfd29d6ccb1fd3552e54d235e051f0291726814217228141f0db91cc326bbbeef73c996d3bcaf5a5a25a2acaf5a62b03af1387dcb8c18a7d7048a6b883121fe80452de8e51146c7300948323792b8294b7225b446f834582608ebe59165b5f6c31814724c9f0ddf83b62a7a79094b767f77bfe6011a0e86dd656275a52b5bdef44125d230bf6834ef01849e2d99ce0c9db9dd0525a0e84f2f6147cdcc95f4e90a64dc1246f5f53a19337888b00e56d4950be4e04925c4123494418c915f6ed441cc915fd56d2a610ca17fe9a8a9dbc61970823a9da0e8d24c915114852b57d7b864eece40d7f3d4552de9cd0c91bc5441c49d57623db59833b20cadbbf9ec2c8897fd9edbf0e3601245792b51d36112457a9d3210b07b250be1d1a218a33a56f4694e4ed42793bcab552b5fd74b72b5bfcd9bc39d1ca1beea2b71d1a6999f0971519e5ed2da191a3bcbd6336ec033a81a49de8641a59a963293c91a604c237c2f0235ee396586e0a0bf3b557ed55833c1fe409ca54889ef6348e93d3d31750251a473d7d71faac7519c995fca4cf6ed02b2d336233204091b32430394b22ce9c4e9ff1c41994d36744e24ccae9b39e6c8938833a55397dc644e358393db5226657d82cba2df2b6c3247a43323d6dc995d6d276d094073d633a3dfd41af5a4e4f85e4cac5e929915cbd9c9ec2a0bba90d323d9624579c516986e5dd3791ec0ed5f18aded1cf34f4449a498da33b3d768421c5192c08f3912bec545382cf5fd0a5c08ea0b3cb039916b58830a1be0ef31ed8535848ead853c72e04e6d79b958a4f3d8775dd54bcb98e3d1ec39ec238a963c781f9f51cd6062455dbafa0bc3d75b7c36cd7eabace0ec643afa41b34be974c5199a6be09c10ef3ed02362c8f5a7336da6ba2f6c286e5baf066458457645b1692730086533cb06387390cbeb9708ac7f5eba9a7369b882fb072202758019295fa0f9d5b7295d5d20e4cd7791e1090d692ab52c9f3feaeab317c7c7c7cb22c3b3a7a719b554292484825a4125245aa48b59515c995d6aa3ed5a7b68a327d6947ae342359020a92463b3b3b9ef7779db519cb679291dc82e46a23922aca41d12afa188513b82932e5ac68b2ed6c44db5644e4026f45529564bbe58ce4aa32d18670465a129c1167945ddcd45fae4b0b22b532bd6674fa2d081555f4305d672dfea0138c720065fa43a3db82327da32e391bed84324464a5b62c1a47e76c2bda582ed7ddada86b703c5245b72a5a451fe401fda7f3c994ebc95453421aae458745a65b1632e5764a2520d8526dcd23997240dc4fa6af8913a971d04f2d7a55ea6b080624579155da7822fe361764faea851717b24a3b59666d0793e33f98fc957632fde9724c448f1ee5723fd1a34fb95c1397038a1e3dea7247a247af72b9a0e8d1af5c0e49d7a02f01c9d5b64554d16f4cb22136898ec8b9254a4672b51d19657a17772b922afa97bb191dc9959665d61e65faea2357db4ed6551f94ea93e94b48f42d5bd419dd5b2921657a969b237af4db8e5c955a454fe92dfe32fad3b6f375cf317277b3ae4157e80b10673ad31f20ae2a9254d1d3d3e4e8aea0d47b6735ee8aca1d61ce287af4970afb71464831227596957a95654f6c3ed4e5f45b12d1a33cd1a3af78db891efd8b12ecb693e9b738637a8933dc29bd8d33df29fe3828ba38f37156c8f4b4fedb8a32bd762457f49a915cb55c6a49996a4699debe3790e48a266a3e72055b156fe415bdd511d98a94a912ee5bba93f5c974e542251712a1842012940b83e0912cb3b6eba4cc3e9a5c5b729565d6766d65fad295b9f9891e7c0a17e1728d883a436edc913756a44adfb8ff88adaf93bec8f3f2bd04630b26f9a0501e42b22e5c845461f9cb4af7061f58a49964753a9e7afaab8958ffeef3ae234a72fd1556d46f22d57fad848672d77e51aa1d20a7eeb4aa9ea7a7d24a3fe34fd7a89f9c022a4ed56f18d65bba76bfeb80c9254e074cae18967047a1954f7450628e1f151376cb3d04b404871f9be51e025242f412af99bd64d90b98652fb21798bd642fb2972c7b41b199bd64d98b245a96d1f6608430d2a04993096343d4b3ac258c11c6a15894936453f41941932200810a2ec880154190239011723c2ace7017908e8ece0e58f15d5c75cb1700e42f86c68daf93c896596cd14cb27c7f7088849192892920921bf9834994c025566401990c49a20a199790b1892311494cf2452553c85f5ce26345969734e0c97288065ac8f2afc110b2bc375483a3dc4336384296af714196078207135ac8f20c18628249962f020a59de88a11b504107073ad8c10119788a14a1c7a788157e868a8021cba11f21211ea2560e9214191d21dd20cbc3241da441e7063b3b60034f1347e85122cb1e3282f4e30411509010114f963dc483a32c1f731667be4d28cbc34d28b7d014497913da8c907dc82dce40a20cb7242cb825c9cdd9c4d2155d37e4a36404435f68f101419e9fddec253ea8424a9e73ce39b119f97a2791628a198c60ce20075d0a2613544d6610021990010c43621c010c2be8cce0838ef95aa8eb1c1d637a65a52ac295f686456e4455bc8c19ac4cd7d10091e55b75bd74bb7c1591e5bdabaf0d64e95d38124b298cb6157d4cb4020c482527d80069044d8fb410c1bdc71ccfa41fcc16d0132da0f1424b0648f9eba22cdf56c877f2323159ee2119b4e8921944accd3da4441bb2b027b987944022a2b50f52061209d1d09841a38b4ee491349a9877727970b62f8aca646ed0d050e5c8724ead7236d8c466092bcd8e863703001e958d9a7925bb2eecba2edaa815b9494faa68eebc24362f99f3a4f39a5794534e39a5fc94726612ce89ea1848e3ec0bc503adbbe17c9c53e2ec0abfb0e7f40ff62cf19ac8c3cd715baa240f7c81b9b806b9d3ed9cd23f8c2c78c9d95ca39b86e250a877af22ea5a09439e9724f6933c197ef630e529a89f6e6f0afe687c3437b9beca7a6f78cbfd6ec03f68e496dfdbfbdde4fb12f7433ce18f473edddecf3ee5f56a29d7e68616f615e67a697fc8a0ee77bacb4b9c8dc51d3d18bcfde28e5e0bee6ba50d5fd421d75d43dd0f66ad391d50e59eeef77cd2ecfda1b37dca9b4b4067abf2cbdaffd0d9e21b5a5815fcd5bb1c723aea5b6eba2aaf9129d74f56b939b906c1320a63d086cb6b644dcca2075d60df6398eb05e622c22c05c71f8b4ff01dccaced3aea792cff6458fed1d44896bbf2973b391b95a7ee4bf4506f7977bf9cdcb1e49614fce5e494dbfb5d057f30ab1cd67acf9391913c9247aae0abca57aea9ace0c0aafcebb2ca6ba2e491f0baaed35df0e9d8e926fc7557777b597e6a39ca9b1302f5165c6fe7eea2ce72bf6794157bb8726d4565e5d637a75281e8ac828360d93e7241c03469d26447ccf51980b9e21fa8af5c9827b74326a75ce5167f5008eafc24f920f51c411e2323a12322a496fdd745349efd2793abfd47a3723fd34f6f6e07e4c9292af88b4056b9bd9f4cb6aff77b9675d7fa1aa972835c59e5cdd9a86020327f30a3700564720afe78d87b7abd28879c0dca4fb723109d2d0e7205d181264d9ab4b209ff90c9278f3b72b5b5aa1ec6e4faac56fc6df8078ddec997e7933c196f71d5aca933800891e8d1ba71487b6534cb7ace47c80361e7c060c4e090d135e2bf1b06e0411bf1dff38c4cf4228acbcd43015d63e60d442f7f32594787862a80479228a3a5101262e180d8409c8155682f62a199340a3212ba060c401b2cbc7681c007a00d5647d7f824ccf276864d58e8c3920f9093e1a14fcb962c0c90abb74adecba48c5d7d5d04d334e4e7f5a169c09ad2101861bc380c6491bbade8259d64cbba3b2667de0b68b210ca0c4050a28b88a8c602b2bc5ac5e50b0359decba65c49d69793eb9039148221b9331c02c18ea9e5fdc6e98ed3f22a6a8e38c8954ddaf12100ca2fb987424064fefa25244bce46bab80c41cadf3cda8288792ec10940c81f3542434b6e2e2e93682a89392ac87e14c800f2a674c43cbf247a51069616d1d60c269e3f716662d1aaf8a905518e474747aaa0e17137d6c5c54546a665c4564427c3eeeaa0582d5707c5822b6fce86e535918888517ec94d44e40845355607ca53de33af93cde97dc234283b02731345afe584cab18b7abd29775ead6be5a812cab5e6b0cb9b8118c4f591a2c750ee970198a27807cae5738d440902e445c6404ea6c03cccb31586951c3434f9c80704a6264d9a346175d7b0ad7427d09d4dcc9fe8c5cec7757aac00353f727af2751ff39d2f98fb28a78460e5698b0201d1a0d40e7a79fa2eebb2dc51a0959be5a02a0e3081d8586ee7959b659cda51b37ccd12a78290f312a778dcb4a8d103666b12b576928841d18b4838ed2d1807e3f0d8812c97df3c858720e103cb05a7e40e64a5a4cb7ba4eee272212d4fe11e2e7ff90b16d2dd05a724e6f17297964b2002f448f42e6db95c5a44e5b4fd2146b9a7907b68c808326d512671c6f4f82c1b621f4fab50c9f1b4886a91291639d22ce47829ff6c892691bce48f59447d81fd2890c4418c381267604bc21389bff664689e9d1e3b6dc9a352504e6f59a76d207996154c5530968251f00957fc7979074dde2890c9740a34b31c2dae004dc6f00784e9a6933b91442f4a1ce40a424893264d88323689b6162acbbfe4eddf34ca4e232f4faa745c789e6e9f1fc53f68b2f60dcfa049247a1113faf901029a447312116597372bf566c9899d3ebbe6d2b9d6d27579777a7bb43c75ec0ed1f2141662e4c6e5dd85a4de22790c4961173c892065f9d91afa409119904a1b9d5402b59800922bdaa29802490a84bd33a53ea4c4a91d9ffd494c7fa80f6542ca679c8da42d7903135b391e43527739057249e13b7bee1c123df9895dacc17e3979ee64996d55bce46c36708420fc60c8a5933ab21f6d115d7174b493450f529cf926912de2cc377f72fce6901c5b4b620f2ed48a38f3fdf801eaf191ab26b2f3f95da7adc6e1e3c215b82e9168651a85c6d157e44f6e91618b1a5d17863c9047082ef77161d85272e991a872b9cd921253a02a02daa2401f355a82f6f4c096cb5b6e4abe59ddb1a3388321c955cbe3b124aa4377e4cac5e3290fedd1828d3ab9b38b7be94855fccb9d4952159fba13e9ce23a98a7771646dee2110a4217ff3c8e5c2ee9690000422f3088910bacbeea624a62dba641ec5792404ce884b0c3a310afbc122b8127df041073b20db927be80936e427bcf044d14f4b99a3dcba054e2a3430d04498c92e92ba89acf8c88a184708aba50a3b02464c0a24403188e1f3a29c72ce396717a44ca459a994d1186126e79c534a1b39e9906c49447461d817ae2fcc78c10848ac0470de0c6d2e51d367ad22a3226dbbce5a795df68ca7dcd825239c48d7135910b66801d0132420b2001e9f2764d08382a427828082999d4048aa3a7b228a152c00053a3a80b0a311bb30ec8261041b2377145d10438c28788105387cc1b2e48ec20b4e14c10b51743d48b62e22cecc13cef4dba355d76d77215f4ac0130e6e1a84105a6b6d2dc1ec1f4d861d764cabb2cfd4d8ededd10768b3961ac34abf6e91d28fcd2eb863348d3078cdeb9a9e91adb9878e78e10a360bf9fbbc47433b524516062928967be8881443ae9f9c88a717b439693721bd539e2c90a3ac79e2c800cdd81ba50239c6d32cdf37058165898174938c6118e711391ecec72c6e51d7755d5729f7d01126e4cf7ee640eb188de330d5fe936b13b91ee59a45f42a508c9f628b5c638c3046182352aeef187f72358254df874690ea8d8f317e12212455f1f144141101e39d58bb76ec12512455da8910922b228e2e2b9e42286b4652a5d5973eb803a1acfdeb298ab276680429b3b68d2065edb0891fb98a2c4d3bdc01529ce922ed2db5778cc61323cd82968a5a9cf893ff41e24b9992513e428886ec59ae509f90c77e599e2f8a6ce7963458e9237bb06338a2feb514ada20ca5100a6aa01f9f9d3c44d1bd018a1ef4bab33cbe6b39cae52b7749a9682a97e5a8fb37be69c2450a1d54d20a5286c75f4be1c828432914ada0e46c22c65e2335ecf60d2df02704e8f04280ae8bb3b988446fb6cb8d30d83eca31c60bd2a3e84d9a459eb185099bfde0cc277a970a3b1f77ae9e222bdfff681010504f0aeb89de757474a4f21ea9428332dd30d91367a60cf2bcf4996ad0e9c1ce90680434d48321ac83f29c8941974b0cf58027cf5324712615e7e74ff23cecb1fd8ede8ec9d9348ef826287a2a1772f488521a74a9fc3aba7cf2853f382b6f79c461b9cba3cbcf4fea86e5a9b33ce5027de42a75d31df5eea86bdd6de95a30cf9d4279c68e3a73fe221267523e3f8be40a7578048d60512b7fb2a7855a9ff168ca783f0a75a1905431498a1e44f28e1e3475324fe2ef47ec9c1cdf728593c3ea4caa7eba46aa8fbd71aa69d668d30873f744c513eea993933ae79c73ce39e7fc49e5b84f8e3b0fb99a5a51a61742a4492f26d19bd717a06a7e9221cfa9863c4faedd0c64393e1edd0b8bae31df42996af205b2a767c87eb2470ae105b5679d73ca25c823a0b460e1b116b6445bc1c2a2b460338de62963906da52c3be1cf5a3c4dcfb2ad44b169858db95e42d1ab6e1983691b0796a79c22cfd951fc93373092a704c2fcaccf354543d14e9ae998e9167f59663793e9d7e46caa50d64a375561adb5e22f55aa37dd1f4c2653ad37d592092b99ea4b2b7d714a3b764dbb66d26ebda95ec3b2c725639e0c8f7a8f05746f298058de52106917666ddb36ce86fe6272ed3a6a1c58f40a8b42abe667e93acaf39ad46e56deb9a0def21edd5db09095776fc1428cd40b5139eacdeade2a1d16d2bdfbca85a0aef2d4102a47fd46e5a8577cb3f2ee3571720a6816cb4d5514eadd6f50ef5edf756fc1382bef8ea302391b1e2c3db98347b10465f815a10caf72a5206299577951854df140bdf3d7513092e208a7490194e18b6047c1285f4771267efecae2428a3312338a1e93c696604558ab8fe2104552055f449cf95a8a534ebba6dd5a51b8130c046257748d79b1d6c5965cac08b3e2c87e368af81167e8e7a4415235b9cfedf3725e6e1167b417f5b4788876bea983b5bac6445dc594325d339d6ebad8d7a9d33b0b01caa6db37a7c3def49a78ba3f98ac35996e4d266b712a6551ac111a8a351d25eaa06b74b6a65b5392d5546852ca8961589bd2de9673ce0bc34e4bd74412e38c104278b718e3c4d98cd7fdb2aef15d2288914a794929e3c4536230cee092f18a18931ec4b0c65f863b5ed7bc660e8573083b646a88fb983300ff86cf9be1af8d72f6989b828f390ebfe1a68688390e4f41dc23e638a47adc7018bfe1301e00690a6cf6d835b128893d429484a0241c654882dc43486802094b202189dc4354d8dc43541cc9dcfd66e64e4caf91abd4498c13ec611cef2a5c93c9958753a51838558a8153252144259309008f817164ee6537ca30e336fe9d9c7236275807b762e3a6e065bc5933ae77d57bc4b80c2c44c663c8c0292e47c815d0ac4b55ec72581e4ec19b19f70eefd5780c8ce3bdc671627c460a4b46885291540ade06be078dabaec238399a164fbc9be262dc1477ee9e7715c6b171ef3800788cd410337ad4788af3aeba9018329ec3eaa1bacc65b0100f5fe0467519188706d748553c1052156be29b65037f4d44031b816f1600b0e44ede31b2779b756760bf4e7a76f29314134e0d112386eade853c06eee10951e14b95097bb8a5ea6ba19cce1a0e17c6ad81fb74b38cba7d1d9e0809477213292122520224747294fbc18c029fe12c86848a868ec024cbe41e12fac94976b60d951ae21e873be01e079c72003e8c18f77e13e31ec63172729c141703a7e05537321ee331304e8ac3a92166dc7b8f19f7b0102337315ee342bccfc03d6a7cc6676021315e03374b069671151662e466c655172203f7505dc6656021dc55b8a5ea44939c0da732e3a64c4fa5a49868524c29de4a0af7d44a8a938153284f7137329e4aa1c898b1825354b65b141977064ea53cb57273192bf886c655dc4da5527a7087d67ec6950144e66a514ad69eb0acfc2b87f98ba7522e9ef297a79e4ab9dc9452397794afd0a4c0bcc09f8c8b14cff47217930aa7b8d368c12915942fc8cc283fa9bc26e664538a3bb9a9d4cab9a71cfee4326e6a050f41e3aaa738dc8306567dc6653c95827bccb88ccfc0324e375d2032a79c64dc96aad355b7a5ca05d2dda4499336649413cae995b34139eafe885ebc4518c1c28cf21f7e1cc2c37b82bf994d87af917106e5b18838739a97717892c15dd51c96891ec763c82f55dc077540c8e16f66eed7e1551d3e3b39bceac2132c13bdb73d577ac3ebba258883cc2026c7711cc75d1cfe70327778af77b7ccf418387572d5735826ece1d4094e0de13dc66fbcc7f8c963601c2327f826c65518e75275f21827b89fc3aa91f0367781d0264d9a30d921b3c680dbac184064def007b38681c8128e000eb759306eb35ea260bf1f5d84b3ec628fb9cdbae136ab46cedb196313b78ecd81892fa630e79cf2f04a29a5d426ca35ed1aca0f9a0c3921b0b6fde446cee6243e27cbfb3d4720c39fee372f67da6e6f4e8637c8b55ddeef46deb8fb6d599b3ae8350c51d77e733e85c59cf3f31e0d19334fe25544eb984d1e420861a4810d3112610bc96b0def4723c39b60609b551f5f83c87c437e850afb6d25d4077f75ce68640cbf9382fd3cf983468e9797c9e2cc87cab285a609e0ef11ec0735001c28cfc3b8d6dc8e79183fb9dfc9eb8366a4e4ec7508c04bb502086c9251ac853fd6da1b376e683a04e03afc6ace2687d7c4d5ccea5773363ba04ea893a6556b6db53f9c6c3c8a1eacb54a1e0cbb2857351b7c92c706361ee5ebd5daa4dcde949b6e54123d28f385630bc79947f8d3456022ef50842345189277f80e45207245cee11fcca72da0489273780e876289c66dd8c9c9c93cb9e289cc41871c0e374e07cc395cb3a75faf185669d0e9302c2c29296f8e8525e584c36e6861535236cbd9d4aae3f4eeb5c26a391da7eff0eb62ab9f6ee7541030ef70987738ccfd72f20edf2108017c00ef68accc8e9765f6b7efe674c01ff071bc26621be5ea75b8343434a75c3dca8534a7f9e9d809e6155fd7f59caf9ee535b2068919f52d25057f39574acad53511b25cabbf2e7b5d36d6b68c8a5a45464618923b77468216b2c88d043128b1b9912006241ba783dec5bbeb020a26906c81040a22499664fa08c5904c1fa13852842d327d11aec8f4ddcda27797d45de28c193366cc10d23366cc98819343e35c0aa72cea299f05a203e6ec33628d15eb5cb81cc31f8d8cc538eb23516b0591282a6971f6cab37036b57e72db9bd38e72533a520ee328efcc72181e5eca711e5e13b59ae73c95c2373cbc06e3f4701e8ee3c3733c87d5dc3d0f37957a7eb372dc54aaa62663213d9c87d7f4e003e4ee9b7b711eee759d2e9657cc741a4f0162937d06d681e3dd4df7b3f93fdd171708ccdd258763ec4edffd59fddf1d1e77f45e70b76121e8bbcb7b81c03c00fc65c771940b738c9d0a6773e10f275f3511757a146743af410e08cc28f745cab19b8284c728d357242208657a8c08addc435464d1e51ea2624946a293e9afe48911830346a9e6c3cdf11e2e0f7f716146b930972ecc382ef67b61fc8147cf72dc87332007f6e10c38bd876bcd5d3cecadf7874cb6f774c19a68aff77ae5250f0e31317e612ef0310c8ea84b4e08fa8a534160c791a88b44b65a8b5142501f6e0e0bbb9d5fdcce289defeddcc3cd61e1fbe5644a2477eeac71a86b184cb9306f712665666b32bd394a4da68bcba2579f72ba66ef1724460e01f51988d9877dc7fdd0ddbe539e723acca89bb2efe13039ce728be4c029fb1ce7e1ddfd307cc2457ac0298b83d8e1399c073cc4880e01780e3cc4c8ea489c656426b56387e7f01d9ec335952d09b98790f864c8518cba30290b36559f9383d8e102b800b00fd4777867980a2287d757ec03f51cde7905f3950e872ff8fb75b82e8e934f98b529b76731d9145b537016bddabde2d3399b0be6a77b17f7833987a37678773f9cbc3abd1f4ed621871b24e61c0e7383c4bc03e4ecb31baf34cfe24c3dcd2f997ce3f6ded0c2d2fcb3f906cd339a67375ee284a04d9a3469922bcea277e3cde9a0c137be9ad921e8c6953a5c49240057e670e51237b01ffcc99a83c9723dfd84bf99ed3526ecb79ddeb9721c67632d863f1ccc9b433dce543c3b16da75428d03e61bb096aea32c375a8efd861baedf7043938b93afb7d88b0178fa0933a5e4a4d4c81b302cbbc7c0313860f853adc51fcc57095bfffff3bedb5e3140aa2aabd61b99a80651db80af7129b4c4ca4f39fe753cfcb331efb8f2e1313e6058d403e601b754c9e0962ad5ed8cba9d61b4beae0ffbd34fa7afac5cc3b69595affe74235ff57e1727db5f29c71abb3f6e4ec10180364eaf91315f077361c6a48fcab1a75c4d6e30299ccd75dd0f02d95ee56ad7c500cc11c8f55f677a733627db25194bb92b1a2a25db265945454545e55f17d9fb5d08e4facb9aae1f379b7000a00decf67e3a646c0543a213ee681a07ecf0977df52cf8eb360065fc05fe3299bbc0aadfc62127848d9fbc466600dc0f66188745366ee3326c5c067fd606fe7ed0c83030004ee3aad74800dcce32ee97a9eed7e51af79347c8f0312ef793f8078d3c4fe3defd6e320da824d2b81dbdfe2582fd32ad844f5698c8f525ab72ad7f78390bcb3597bb84fde2d191f77cdd775c1d2673c1b227c76500c49e823fef84bfabe0afc38a60dc895e123d70080b49f9e61ec2c292ecb3454fa6711817dac9306e3fb3761921a9878c4044fa40266c66b6ec277af51867637116bd8a82ae016fed0a13ec2751903f591467ba43974395c34b14340ed36947bc9049103077f466ae4fb95ffde99033611df51626058939eaa864e070cfb396d6fbf066e5780fefc1c37dc0427c380fef010b3172e3c379b8901e9ee3cd8ab906b7a813756024459d24265107e64f0dd1c373bc470f38a6870f98077c1ef9e3917fc8641818dcd13b86f119340e23c62d0ccfbbaad398110307d59bb39171a1920b7188f1c3e06f66986b37f9f47a0de35a6eba761e9ec3aa16a786c8711e7e93e33c601c23f638f526c779380ff039700ecbe2efd69eee07f329e5d5d6cd743f1ab962d36ba4e9dea7dccf7b7342c0b88df9e9de70c983533b6246ddc56b24ccc5e1302e048231f7cbf2fd2f0e312e447299d4e8a35e666badf5516f2d13ad96256a1129c100ccf65048e8542f54ffc12024156340668b81402660abc2d60b201344ad97291c11b95ca2be1e5efa1ce5b0208c98b75cc1bce52ae532390ebb28d79f52ea4d3030f04793eb636230c69e973fc92393e30e19e1486e79e9da4ffe82c48cba8b766df3af18ee9cae35077d603e1df6f02ff3e19fcdf65f97ed3f2fdb5fae78b87dcd6da972711f6e0fb7e50f997cfaaf9d2ef409900bf330fd29817a0c63c8266c0893b040c35aa3721ffa68783519da099aca18ae0bbbae09afa0417a45a88529b33c23af2967f462cf75daae9479e9631e3bdc6e68c1a68248f1318fca9d3b7f13a776a0327654c660cf77ce1d67e4f624547ca09480b00d4dc02e7a51ecca4209dc381ad6de9c19c811a3f89a1cc8f130cec8432886ace5a5564d9c6530c3160d34b863769baeac35ccdd3967420dccc8b25d2a6345d60c4347168c11b200e7ea406bb96261d89583102c56ce3c0246b80520682c0d6e57abe6c90296456fb3b0db2c0d76bc6eb396d0b03967841ed0e68457072694110e41c37266a075a9bd920660074e3ae7829009373c10d4829d12a020091f104187e107f69a584e11248c0cdda00966e831ba90a022092d4ef043a63bc3fe6e83fc793468aa60227f2dd44986aaa8414f14296862086a1882c492b28972cf1b720f1535c9a6dc434548f688d6cf826d2e421e493e45d306441b0eb48ef920cfbcaeebca2ad69bede6dcf29cef0b4462b7c8764d6e14723371a66aa5f78138409c89327af2317a387048f476a8dd400b11fbc9e46db2c06e7126420ce9135ac764119569e24a9b8176552a22ee207f4d09c87798d422077104b4b09f0c16f693c9376b15bde806f2754920aa906692269d60e155b4b0f0f29b110b85748dbe0a182c3c8c314231681d53935b080c36fe9a71c618048b54d0b41c67e39c0c71ebe8d93d67f7ecd9b3bbc140318c6254ca8961584b2963f2bca83c867b46b694f328e8c7a6402b652f3dbbc41fbc32eca39f5d83bd59edf89af304cbf097fda2b77ebb27d72ef7c9c38c524c7f7439fba4d8857f1421ef8f2ec74b25d06fdae18d2da4e672230c9b768880f8fe341c44faa83888ec472d621ffdc1893fd87de1ce4060ee5f37b5e37afdf5fad227f6d19fcfae5d3aebb33b2b9e1b86951e5f7a8d2c5d98afc38abfaa5dfaed66af77be5ed330bd2d61fc75af8f2032777fe384886fec235ed334fc553c4bf7a15dc336cf4db5cd73977ec22032633e801c41af8f2012bb3ee23b5f1708fce4769c726ae21df1fdb8a3cb5fd32a4a7d9230768650681d330fa1fc25040b1f2f2bb0e53819e9a8699a8f2247c8b08cfcba20b88edd4706642ec281eb9d254e0eeb7ae471e1ebf04e213a595e0f8194980611ade116b90f9108a069dd0ddf57b0dd4162ec9eda15ec372584337a57b0d9a78410c2ac218470369411e9ef8285ffbaecf22f71e66edddd36ebeedeb2190498bd0f2184597e9ba8f932e7dc8106000fc06bb0514353386ae5aeb1d316bd993b0a3028c95df41aff784772fccb148260458e570840a0d1488185ef4d87488370caee6e8bd45300e5eeee9e32c6c4c4995496b7eeee9630b08d7d3492fc804681902a78db51d84290b2a09021514da7e4869c0228ab846b5860371067e2e171e20c4df4e05519e64f468706f302da8364d9342746310cf380c019bdc982655858f089d82b04bb5261ad15ab87174837418a335be0479ef9b94d21996cc43c4bf70d7f7f07b18d9d8795e422205b44f4e6514e60e790a833758032c59148e4c178628c31c6083725b496f029f2018fbd11208d0862fb4e6cc27e91076a10a7b2c76738882d0e49d1cad8e3cc1cce66346275a2146c7cfd23ce00cc1f95d8b586339e60df6e77967f453a1669640552d0c91057405a0106223a39620dbb189cf9ab3ee283cc8c1dc38c88de3c8d94c2d94a944c1d29298c3a3b3c30893c672a08cc47846fae07cb3b8c8343852776585d77712012419041100bc7e5382fc7717178533b4acfb961b99188bb474e47841c8f96d36b5a844f5d23f4dbdd3175c4eb031ede5410a5c797bea3744af107e3212704c70096a7ae414e01cd6a79730e60790ae31c216f4094c44abd7b0660ce5e23e32d3dbba597ba8b0341c03385100bc7053ea2a7904410cb883cce0b3ee286198258296ca474177c04968424969193b7b038c1ce97ae4c5db973c89d3bd12b510cd57d6641e6cc6cef446f422b8c66963ac212267e8aec767b7a9a379623715647ab112caba8e8cd883f1a18362961bf78abc3be747abf0c578046f6615fbabd56baf1f4f06218a5cfb0434b33faef26c30ad0c8df4df69e9f3a53c7b4448c31e66843b1c89361fbed1661f9d54165b97de441a1c1da4f163c87b07c0e89de1cd29de52831c218233c1dde53778dc0b35c24ce32f2d2b19c8bdc351695b7ca63562a7dbb5f4ede340cfb0f9db1e76478bfe7084c085f57de5c94a5d39b93e30d72e5151c0068e3462ebd466eb7a3b7650ee51c8eaf9147dd6fe6146c44f47ed0c8273c77a6ce144a7189fad947457cde99608b4e9e7df6dcc4990b70df80c8d8558185cfb2d935127e592ec272ecfea0c93106b119fb01224d9cc93e9fa3c6932b16dcd1cb6663a16b58a16dcc6b175ad135e6e98557942e3cca227a33ab6d141fe329463f9a4c6113585932eca92c8bf391888b900e3e4b92f2bc4f134079c6a03ce77c4667a6ac429e3a7205ad88aaf979052c8ade8482fda68ecffc9ccd3242cb9167b24e0dd041823e72c5806cde8839fff2010bff02027b09a5441b628071f61704cb7d7923ebb79d114e4a31ce112cfa2b23555146aa6472c7c3932a1739b0f0510a1ce4f8971cb0e2e5fce7498f860b27d44352d0c9b1832c2329f0e4af5b9c8e148a90bfb6425eb38b332f71669281c6cb08905808641e73ef319fa20530b862152e256cc8c109ae147477cbeeee8edd0db1abb1eb6aec9a92045a1c4084534a29a794524a6d421bb023b431e5001ada90d25a137607703d8bd08694529a8080958680ad602963ec18e337f3978ad0463fe6993b69638ccc119ff2d76519638e97dd0def17f3c92c718cf29ab223c45840712e8c5ed725e31111bb9a482831d8a4dbc69cb31fe1bcb00bfb81c5ae26f3921884524278c2a08497d863298310c3221614e3a6e85637567adfa3efcee240b32ba6db867ca984bf23f2d5860cc32efafe840328c5b671c1d8309e408c4e194f5e34db221c006cfa2a4b598c56c26a29533cc4c2d7c489d9b8a49098e7b5d2f6755b561bc7d4b87b6a95fc76a53c59205fb133407326af439a4ba73b2c964b1848d79047e44b7275bb22044e402206186c29f7901236d0ec25bbae086722f4e0fb82d73c84104208af39bd6c622f110ee03ac5b2972c6799e72c4d6cd2db7962d9cb8bab94c15206e11bb3557cce2cc9946491bf4e52a4a40a29e418e42b265f57138e902f254ae4ebc615745032f97bc9c1841e26846109567ceacc107476094755c8df96278aa80479526188880b4b90420c2588c00a4ab8c2da2fcbb009f644470be2764a5089f800cfb682522b49ab415675404b4f604e10ca86884c70cdcc4e91822ea080080f04996147676768880d44e814a5d44026cac490813de58e420c6c802164b5dc518ce104558ce1055f18c30c66f4d82c771463c88137033ba99079ee28c850c5fcc001e2cc67a3a60040a0ae6ba27e20c08413af28818040a402851f9ca025a60d489aa8ec0401c8058c249028a11205105c40052888a09288a0029311b2eeeef6011172f7690ac0a33f1b675266314fb0f0fd3883e7212b7a727fbe5c97854b50824496f88978868e872965747663d735a38c538832c2d2a905c20b4613b412b029ffcd39273c651f6d62fd9a98d1eb98bcaed933a31836e7ecee19e48ad3057d2161e1e375cd6be294c472c4a2db66d9b265777777675052011e368700982057a4b4616268c30b754ddc3171e144cd84104a3803f003fb6519a8a58456286163bc1a9b33b330c88e3dc3b28cca2ca318c33d6397638c1d73288c4dc4d87dec7336f6c67e659916331a23ce6a60d1314a6cbbc61170ce6641291cc9f663c71c081f20e535e735fb03ddfd5386724af99a78c1fce564f9a923c2a3c81d68b2bb5bcaeeeeee8e51cad9b108730c5d843093ff72329c17964062d89c58b7a9d492177627463367dfae715d18c5e6293ebc2e2f6bd8d735fb7a4d2c7537be2044b141264f39a544a26577c309610732ece779fd82311a6918bb21ceb07c733912c227c42cce5ca62ccec0381ba722ee5cca16e83296d1f79db3c212cce095e1a71c81d4eaadf5b262b54a292fe7155a8c51da07d5a880200806913065f6f929bb67e4bff92cc64b39e79c73ceb89aac289b905168cef63c19191a1aa12c7dc83e64d3eeabbb9f050dbeb24bce970cd3c83db3d2bf790c675225e72f0c772b20a96ca8a46d15753d8d3a4533224000008314002030140c8804a3d1682ccc13416e3e14000e839a4878569cc9b32c88614a19630c30400400404000406466da00c0c436764055e2e393cb7f7b1169696b44dc3d53a14306f060f1015863a2d2a8e5843b9ffb1ffa8beda4fb023d1822bb81e7dbad20d60725548b59eca7d708e201e3b7810fef2df099633a29698dbd2f1ced3defba012367169b549e4d97c89dfa747367248fa832b38c5672abb70631dd62fb7c83312f247bb3001a6313212385d857242d53ca162676cccbb2253d5c5e75268c23f738cc0ed896aff9c3a49f7b4211fea5dd17ebcc4092a25af46e284d62ad80824a16614b6585ce602bf3971b0c8d51f74d0ae44034f3aea9ecf41d62ad7d8108397e3277bb31d0a1a1c8771c6c2e2776520bd4328b64ca5ef0d7aa8ffc40782d4e095f26371739baa153e4cfb722c8e14744f4cdca76cbb26eb4068f060f03935dc6e692010fe6aeb8bd090278383d7c603c47eaefa506271e63afa1838ed54ae28f32a6b9064e12c10b0b4488bc7adead5c92720472bc2420b75c37d19f2ffee648bed2445cf523c8b70c463f768135a76089b243a87348f645980f14e377a9cea930fc076a81638f0d0d90086e1d54713a8721f80ec81b7ef4c39bda043b160e3243110d5424069a3480936c7a4d954cd512e0642e15543b42337a6cbdbd8b8d281116e2510fd134f9c9f57848ecf632a45b81b40d5be89fc85854397205ee5d25fad1ae49424ceda8258c431a9d380e047c84615b261da9fd3d61af153243bf0aaeacf3c6b18225e8c690dcbe4416ffce18c230257e1d8cb20e0c3e1fe18fcd421986c2399fa401b3eca1ef13d0293c667ddf4869e7858bd67ef8bded878b01c03731c2ff9be456fff7694ddff5f69e73e8a185cc91e73b8fe6a044ca8a7ca55efd7ea8f8961e72e36431c4611d3fada9655befdc3426b1c299cb0487195a16511d77fe3b83ac56a9502e95d8a00ccdb971c23c1dd65823ac470d3418a6fba0523b28c099062a9e98893b143d5a8e1e9b0f2478495e81b84ac1722cf92302aa9269b36de546705a4bd228249def296ff7fad39edfa4317049cde183030ff9e1a30389330ed683ca5bf18a1f1c5d1c51b32529375d164e4ff80208ecc4ac8f2b3bb7c4420fe3904d931f937293c371d5466e0aa0e34b00d6acfb4e0c58f7f476a28e13f9884e0cdee4b5eb55c5564bcfcb3edad5367a6a5797caf0956978b41005a2bba3275d275c5d210e7f919a800383ae15989db5bb8c2f32433a440bc8ecf88a61e53b75b7ed8a01c2e4df9c4062b1c2b6fc48f701d70a8a87e34aa2014adbc13e7245a93bb0c2a6f41108779272ec56c733252b48e88ecfc0c57e7b989db3a5ccef273b165d5394961537143bd85c1bef0447647df647a9ddb3eccdf51f021bd69a5c4814db14a2df1b3986e44abc4dd8c2e9efc10bad6e0edc875bbff776c47ef0070354dec4310362cd23194b7037e939e3c6dcfda97aec58aeadeccc3afdc97f380e9a284383367c04da44e6f14a2f6f6046bf80c9598f35331f1a0e5113ba8603c2f863028743239e6fb643fff67e8948545b549626777658a5a50cc544b4e1639e4888859c598a9279f210a81dcaa528ceb010399ad36a9dcb4dbe86e2dfb9b1ba3c9169a3ca4ff1c4d288165573338e200b8e6140be97975c0a4a01d11b881ba1b0688513c657481b947a58c256a855e657015c8437fe54329753b0f14ca5dc2466031d3003d348ac380c969c5bb6fb579cc23582874b87202068b76b906831396ed9352a33632cb81dccef939a2960823a5a8714fcf13ef3f4521445ad7fa4d496d3dc4efb1c7837a2f9ce1089147a7b683113975e80d235164f2c02992f69340182eee9aea434f4c5b3f53f804bc98b2c1e60c6d0c98471c064e711a9cfcb5111fe990de1f10265f67d28cd21a74a4a6384d49e53e43b191a7e781f1d301129f523d964b37957d8e146ac0e673fcd126e69718fd540016b8314dee79fbe432bc35daa3f3078388aad066ec691bd0709840ed1d930e67738a2b355b4cfda2a494a9cfd26c6463e17aafcb5815b5b48ac8445e24d5f1cfda0b9ef3777c0f24a2f58cab0e4e63fade0cb9d2cb593caa285d84c4125bd80a1c6aa230d2c06e34a2c78fd74dac4733a1287122223f3ce7351cdb88d925b0edf02711ad3fa38f264d2f039299df95d04dcc0b17dcd11f1149f079538689e70eee6257ba8ba85532a9afb879e765bf9c64522a7f5aec4cbd9d8bfb1689f41dea405ad318c868aa5391754a78f8d35b47db53e8ecf87fec02ea293550fef24dc6e0cfc11e93b502d626c3afb2e1600409277155fd28a69bfbf18f2a09f67cdf609f61f8a3c890673951edb4f23d78920cdb9e08b157b1c168f45ad2f8cd73931a232c2b62d5c4cc108516dce83a4bb3260006e8848136064b63b69c5e8fcb9e3afbd61d9fc4623bd2487b5ab41c337246d643af851320faeae845109fdc4600f216fe429290eddaf6aeb6a8648754188c8b3ecd379e96ded7132c80288aec874cd785721725ca353b4903ba297d656f76292b5fa5f4f9be561c4de639a6aa0054f89af41cb7b338048ac33e7d8ba371515f93c4badaaa7d9222ab3d6dd2906da792a2769d17164a3ee090c88c545a3694bceecf4ab1e484acc4d232c63fcee98c29cb492f40352662cc0147d07b2580a19392e91a0dbe45ca52a0252f0d1fe4c976749a875e91a9824a4ad32df1acb490a2958b2b571c5061bb57b32665108f383c4a7d463fe69469322de535b6436ec0d31348b52283e2ac868bebdecc72e517c662ea1420e2ea0be47f8df233a9dac41e771df965e986cd3557f8ccfc73defadacb0c835c53fdd2f0fd4b802e585a67f29d292d08f49912853080132ccac600496561df98a1fdb943f1a53bbf403c907e392a3125bcba002b1581853775d46ad8a84d89b9d0c527f885ff7a1bed4a09bbae225512e8eaf4bac07d6eaf3db807dfa8edbe84036738d189bbb8e0b83da99150ec914475556ce094223ddfa764366ea61d81ccf668c9a81564ad7c843654ef76b2ed5bd8407d61621d86023f2d32b1d5b38784d4179f1db676e9f6f96f97882a70cd33e84d51da044ce43897a29e8010191dd76e3020d94cd3bd912696a4b2cbf873a099050f5050e1ed2443331784cd4da9d0dd116b5681b20de4ce509416829d191ad8f178d8b6a168a1a68f7a0a9d509b59d6cd9d732b57451ba7d59caa22d1c723552f4246b63fd06a5267695481dfad90f4a1646f68917cb45692155f4558c59cb9e6f1612902f88593d046c10915ce832aa5a74a0cf22c141fd5a75c91e608260d02db438b5ae0c2d453b39ad74716da369e58239773c59fabd7cd27ba89d90a52ffa0c3b4624ae55a9d99aa145307dc6f5675e79e3558f1f8cb09086e9e61f976c3f7f9de8331061585d02b49e0961dc181c4d8e048c0529375f4f8395255be020b88ef7e248a757fbddd76ee806ed79c8533fb2f1f8b00f0b42b8e62e22726a128239fbe2fe73ffad1d0478714e044a519fdaf4e4706b801dc16332d2184bc824e9041b6a6734ce7585cf52fdeaaa9498aa3fa449102819f0005b45b9f6667f4fdc400bdeb3c8d4f96a8144484ac9b8192bc7c2446cc3f370c42559c58fd2304f901cbc2cccd89bd5c4db98ccf407e05db64ab4c2176dc67ff2738b667f9706aaf55578e3980512f3c94e1c83fdfc096ca7b00ada08c4b9a7f2981dd8c3f3f323baa278672bc14f3d8d8db265e2b4c21815a78f7d19a500fc55762e262930f4b3128e2a7327b23dfb944c190fd25da2a7a6c2f28809f1e7390bb4a77614e8d9dd4d11a9c4412a6b06f6829beb8d73898743c877264b60ec764d5fda11561eb330f0fa6fc9e29f3c61444838a18f3b7b598987bf87f83cf8a0c707d900fdb815b7b5302e2e0a0eeb5c011cfe26a6475f8608b5ece79af3ea01222d31b9b3853f20b4569878eb9b01778bb180136b8917c6130551a2ff655fc189b32c56875b63e8277465b8259b2dc8a724bfdcb9645eecdb04da3c7ff11aabfe6a5f52026c4cf1978ef96c9f31a56c230882b9a2feeca8b39a187e28e1294e2f79aae36e05dd3865255b32214d4ec03e3f435724c100194febe1452bdf276310313add860c512a98e9de30fcd174571a482cbf73c78e5c08b4f9c49db2bd84bae61967dc7b7e7e807d9ebcf9af37e5c1af22459ebc14c8b2108d54b7fc92f0e415b25d293d9c98c921088d0726366e4762d5c16b62a72d3e058764ec60809aa67c49937576038955367aac259476368557b563c9b418ccb7055523bb40ce828e8ce4ae77d8b8e9acaf4cca4f081361b3b084f4f935099791bfd4b1751eec0aa0d1a604816ccb54923ba5798186c0690090ad100ccab762315eb4d0ee2fa776a9d09933c891169770441c83ec869ed7745f9ddb91d665069cce12176d12dbcca8b1048224a5119d499cd0082e0b24f74a6d6cc4640ef820b6ab6836cd6d374099f74421d39336dd554ac6c59a6328d5c4ebfddf7e5a1aa4db59b44912b25d2b1637e8a185ac0fbbb455a2cc51c3d06059d4d3bc9b72b419c3527e85cfd0ea43c1963f023d279efb094fa4a962a75a8812a24bf50fd36234b848566b364e135b53b81e8ac88f11e3898cccc3ce692e2bad8a36dde9b7d61a6aee17a0ad9ee49284a283424f4d9130023ed4858813e0347fb41d54f96f7986dfbf09875b67ab3ed2a2c0b4e485391f37334b7280ca971cc8638e572d60e46b5fe4ba501c40d5b777741f316c6fd5c56704405ea6bc294616ff95d3ebfbed3fdcb256d56946b6c04e058d732bdcbbf14c4b2b5465581d70a26202dc5d50b49f321dbb18bdfa69a0c0de8227873ee9b67647f8a3a7bf381295f219414cf7021d7b633b7f95b04f43857ce6998beab7ed66e02ce435f378ca9afc2d9c97267c9289dc9ab53f92b4fe7b2b506ce9f49b073d8bde4c82496ea32c16c043674bd820f5acb061b56b0edb407cfc93423bd161eebcc7be83b4127e1fd4609651aef10343abe834f1f164a3c949275cbd854ab9e294e231946bf9d5bf170a3ee72466d9a6562d7656d0525d3209ec8d839fa8834a3af685010b97a062ff3ae0c1a80a111424f8828620829497fef4953551fe52ee21f884a3fd53dee6fa17644471f1c59f7f7e01f228baeba95416b67d24cc975394a85685ec21e576c7446fbe1a4a701dea87f7381a10a929fe6a751e80f5d7a679b56dcd61db6553bd133de15a585c1cfc32babc38e429df36b9cb1b3e93c10911a0ac7665edbb2de33cfa3b101312a0c8b11e14b129197ff0eb9f121a617c44a805c17b44943f5cbcf4c288a5aa32ee2a5080ff8b943be8d6e0a68ab835a78f68c279e43712e350c34c502ccadbb24419da5c3bf22bad29696e0f3854772d50f7968b9ca069a2728d3905fa00329552a684e4e9e5f82d55121c1604db0ee006f1e0de516ab1d70bc0ea68472480b58334b11f2ad7a5ccb5a4032ba260cb212eaef0be6ddf4c95e11c346772740989e9faadc8f8c11876f861e512b894d47a39921ab4c6460c6e8bebc09354fc804cf9b59bdad3cb94ce9085005eac5cf49533945096844f8a1113b7b4af69ee9e75f7d0099d6e75bbdd39c240ebbd0213f73a4df4cbee7052df8dc2cc845f49324955886d000e51c89c8bd9a78c043fd1e48941fa253a1d8fdf06e00d28860ba268e24d049d96a813972283575024338d4c151e95c2a4510653434596a7d1d305581dfb7be6c5115b9a93152c70f647244f735a9298faddff763b70bbfa4d5901bea34bef9f4219f634fa35a93533000336dd0d99116e4d3a23880084464052a2ec469d321ece80db6bab330ab185b32a876637306004978b49bb01081d3a58ec5c3b2f9b3b5db17a1a4d2e9c9236631b8624cd2862fa1c324217ef737e0e46cd79c08f67b5f39db24580b8716bfb096bc790fe1b02ac658c8a3c33cf064d2ccb50905963826c6850e3a4117db24ee9b2bcd77171dab1bb4aaf63ca9847a0e70cdfdf3baeebb801c617eb6e7dee919eeebb194b238fc8fb64705eaf05ca0e8fc4f56510939759682aa7d5277b968c89e172ec3aeb851a16f05bc67c4a6715cd10a8db04dc5deb3457c757a65c8a3c667c5e3ba3c81ceb5036cc17bae2a9324c055af9e7234664c3a306f5450f3162a074bc5048b6fd7663501951c48015fc300a7a97dd7ceb05a8045ad549414d086536d6ba4fb877585d07e99f7106a36e009c422fb77d27df07a1e93137268b1bc8a23be72272f76ffb3a32bac5248c7ff8fc7ad3d146e27950700e3c2c59aa1f5c4a0d083d68187521a83e36b473cd5005f19b35e6edc23ccf897a4c3fb93f859dfcd1f0f26cc45a40859488c8c4a11ed9aad3d6cac4c0c156f8332cd24c01b1bde76017e945da6bd1e13db405e8aa020319a69b4826017a36a4afa4a00d51b3705cd4f3022e88353c8a5d0dd1fff6dfe234ac3abf1e9156411e34def8a982a74b9911909931e5338cedc5342f31e5e251b9739911c2954798b5140edcdbc72c2db3d9802807395a921921326292c6bbef0c4572a97bb5d7cdd5049a2294788648820a1fc9bf143429fb3379fd88c2ca5be114100b2711ae057f598cf75df8ef1c38865325177b55648a1d15b7a5252d04c2edfb49079b9a3b4046b1e1f87ce526545a018a071aeee55747c87919e11237180b5ec6e02e41a2e5f77de1d43155514b9942ebbbcb2ed59a8105e89fafcd38858f8ae336a7afce90c14e8eaa874e40b64c03afca87c1cdedb4261c9ee486e88f09527e4c24feb0924caaa40831326cb457a85856eb55d282780f5b939baf9264cedbcc435326cbbc3b661ee33848592d6acd4d983c34e06a7b5bbdb4af61f1caf746cca12648d9da68786846bbd6e645615496d98242df15a44904dbc2e4721600338967605d57fa23233cd0d4af629f0ec9e6ab90fd4a7412817a33467402b8be0161a62288bb95c135cd23402a11918fd250f3d6d0904f1569af6a54cbe389600542e2fe0b3707eba68556a9c522e8fdfbb31b6c46212d765977a0286045fafb3918d38c38267b0e3a972d811264401cdf3586844982dd59af7e0058031992c77450b0250bd7e5764320797d48a0f3f36030e45c1a21e8be1cf44814d080a7b15e267236f4740a927d028e4ed0c97bfecee88272bd827341c703b1d4c857cca9fbd3d10a96b3e6f9fb1421e1eeec91d1cb30cca8506c120dc7a6c616e370138a02f2ded6940db5c1e92941c416c2f2af7d50ae5381fa970c8a0a44edc0fabaafba29f38c902a34f9f523050d944688ac0dc001df3ae96a435fa621cd81a601965f2985b798ad3243c70765eb68f7f67e1584400b5d9e2729315e714ac75b0a0b32c194a75a3e9c0f0ee1acbdaedd40214324409db721cbff86ca6887b90b800e7860b9ada5e3cc499096a954134f4e765f6a58b33abc4dfa1e0221b46fdcd08adfe3953393f16a8a2a117cc52bf1d0f428209ba78b10481c55803e95cd3ec79099771ed3507e7b5f6551fad4b49f0f7a32c71a052187ee35c347df512ebc40bb7ae94a2389137dc510b694233b731af2a00bd1507e07c441d9c2f219b02e923ed5e5b7a1bd0b544e226474274ec8f35a85130468320076bc9ce0c26dd033b154356d9bb33d46c556988a5ec27b97de18f4915751cd18aba8dee4a73eb172742819871c40f9495d1121f4becdffbdb6617d1abc3152254489d6236309efce375519506ab2fb31c2448b9b32d91efeaf93b80251915292cfbd573dd5ad75726989e843cf9e3934eab3bbd7adc7087be75d787647cd70a5b69ca3337b327dfc7ad5569e23663ca5ee844b7480054b31fe72b96387aca843c0b59334d599441dd664685b56bb9f4db46997cd731d2da3b0089ff13c11b09f98e135666da5306a248611337788444c59ac0aa5c614035ff50f8272cf339acba389309006f8c477867590bf080bddf6bfa523027ab143c68498b11728afac88f684ccd8e04806c91d9312fe8411b6a4937d8102715a0bc838a49f1d0e0b9e27c047a1cbda06fefe380392fa1fbfedc21a0651d93b20c81a1111a7ed0c44cbcb8247cb703e575646a5241a663350e5ee0191bb9167a60cb71321cd7211ea634b735db159bb5b420b343d4073a333091046c703e45a5e43fb48b98fbfba7761d74205c68f733cc25bd16db1a4d633a9cc89d0cbcf3058f4b58e231da5fe8de53672689e03de0ea79afc6538a62d36d729c33c58ae66712493a44c9799d4016ca6e249e2dded55ee119f8d43ad1be5920f725668c8f96465db3a1c9ae67468b8fa006363d6d2fee85ed9eef9a113896a08d35bcf3783d121589757eee278b94e71e4e94e41bac9c0e7bb844740e3abcb211ad2060947948086da401d702af6dbdbbb18bee1375ac4b2f088909309677193aa468fc3125f3d6170a1afd7fb1e551afbbfde8f61d0b71d00ac1fe932c08d62382c1f97af39417f7cea6981b125f2f3b5f7369060f67adf4dfabd5ef3da7d1eaffc64e3178c0df4958c132b673b7e24dcff797937f72567034de94f3318ba0f66c241df9003c2f09f9f71b71f7974fcfb6e2459dafe8f2135090fc1cc1468b449dfc2e5b67d926c0af2be9a478da0005d53f3fe8fa8356d2470d01185b0e45067293aa82fae2ce8445117af79631f84375d7b4f9f4e7855a9457d3181c3d0a6c13dab0a1a41c8aac32bf5c41864cb436c97e7c739d749b124941dd404c9af42f60f4da322fa05dc5aac283f9fa612567b80a664763787b9f1761fa06ba811147deac1207d0c6ef943c33d29e9a031bc144b10b32e30cef6b7d5c7ee4a1762825590e05f6b3afd1212f95458bbc1a545cd66ba2adc3b9a55a2aa3557770c610c6d051239da83d277001dbbf035b77c7ce6da840f04d43030a3f065eb5f74a0f70b78f2bdc7bc9785c5b1369c9115d790cbbd8cad3d8a23d1efc6db23b8faeeec31c15489bee096ec7381f8729e6886be1837658b80a135c4ee7ffa6d06c6fa304994bf8ba9c4e7edc8f50836ce1e1c3d386a1c6edfb9ee95e5b1bb52dafa58f7be9ce5b0e882195125a53c4e33e795eefb3352da1c20872bec804997f96659f111ad109435b95773eb88bea1c124c4516ee559e7c581d9b1143ec5ee10f32c519e3227882d82c4e74250d429c23b044616e0a70cdfb63b616562f6231c37bb53a4e4206c21ff4d9d1c431a65963fdd765f068daaa97d009778b37dbe92fb13bb0e3ebab4821769b56b7347a32d1f0631672ecdadb753719d6a17949fade60ec0f1d942bf35eb5fdef580bbda9218bdde66519d8fadae2c4f36ff389b5e8bc79e67846aa4faaad24854e95a55e654cc4c4da3720feec8dca98950ba6598e9ccacaa09a404d52945f55248e082d366abd210594afaf5101cbda6b4ea4abf6e3efbece722946f79c2de62772118514a3e5dbff9af6a22b5ddd7b152eec6709d74341278a99637a94e297d4cfb40c8e954064fc3810ab0ea6e5a2b8d77f6fafbadcbf05385f82396fd07a0441b857f752c696a469414dc1f63fc4589df6a018d5cb6a54bdb3c59219ffb3570172b02fdd65bddba677814fb1dd29ae243a7f060bcb25b7725286bb3745eb7dd95be95bd7c47c1aac839153f2e480b0b1ff021e8f4a4cf3b34e5978093a48691fc83150f2e875c0cecbb37f6381de797e0ef00dc8b883d25f9dc24a2a034e05e45682bdd7fb3c865a501f63e52af077a3ba2501270af23b49502945e25c95c44e2a72753a338155f4aa2825b35ff71efd112e499212e3b7a81d00693c768c07a13e736bff9b4e35dc5accc57a344bdbb776326d4fc8e870aba582bb7f1ce91ec7993d40247a9e4491a9ef95a5853dd4551a860f1c5b5611e2d6adbc2aa5c6d152e5a546a87f6a3e5a5e0221b658e30cfdcd11b9d873690b833c345182c771b0a14f357ec53a0d611649b93af066f6ee3a460943cdb21f3724219771f1977b5f3846750f6424112a885cb10b10f48ae93756d470ee3ed54ed81ce8cae6c3877db6641b0643689973367125ef406f696eb58c67dac6f1c1767d4eaa82d0f4d35236c998b3c0bbec8301ef4871eac90dd66739b2c73936dd6eec169479eff6d8632302955ef3e01e20193c49115aa31773c625a1eab0d69c01fdbddcf56b6f6a5a799d34d86438af30624bee30d6aa1498514d436a73927182302d2d4fa426634492cdff758548690817c85aedda916b44073f881d0e1ce6aab2e7aeda4cbf24cc324c61569186dad962ec6de7bd095ff7b0c8d52f1b64c9686f70c73a2e3c6e0e29c283811b93e76f4579878bf19a1a65cac5cbf1dfbd53ce1621dcac6b4bf1b5143a90661d14ea2287de3c97d1066a4d405e76c20e8d9ce6a622ac9ee42d232c60d2ea1f672a24414458366e6e12abcdd3918c01d7e70aaf05ae487994a5b84fb97becabc2e6a564d1c0638516c384cb27f148d497f208142b358366adeaaaf229e360b28779999395849d5fafcd6d89d96b05267ada1ed91f9bfac8985d396d38f464407d46017dcb4867d7c5d1ec491d235a0d1c65233840b9f8bdbd237097aae9ada2618c883db74dffb7b2f6d0adb19c76492332b6e8c80d8f3aa6c582595464cc0ec84dbab790bfb1de86cb54bbe24e0ad25b19ea57cac39504a65daa8791c17b2d3479dd373ea8e9f0b7ae0388da35b29953c9d46cf08c263d24e66a91195dc748a67ab3ddc1d1b565acd2a55109b199c553d040501ec9c3c101470bcf49e45f9b40088dd22a0a40c2895f8e28d58871779e145562689e9ba8893931faad1ef3b13fbe728d11f0dbdab3d898ca387ad000b817166914a4dc89800c81c1b526ffc2901db2bfc615a645ea6d5d49ef7728900978c9ea1a02ff31545255ee28100e4ec7053a2631e946ea050df4559fdda37ba1b8ede8ceb446ee7e24ef41a7d0c7caf81b65b67262f7842ac705fe36f803b11032c3f4eabd191de8bbddecc64624c49bb0c098b73095799d5c69b0394f3f884c4be4bad81d892de9e56b8562be2ef4d20ef440d028a9b13a11cd8fa6fb9661524895dd322739c762bc7c13ab66d7912566709ab1f522c406dc6e3b54549b86a7b29fea9bc4604bde5d1b4330817d0d7647be40bfd5030cc6601df002854190fd186ec7ceb90976503dc76238653577055a4ad1034198b32d30302fc9bb6560af0705596ca06b4b6107c5003c225bccd708edb6cfb9e84defdef90357990be679485cb9f112cbbad0c9513d166aa8184818749807b2665e0a08234a81b8d6ae0558c251e684d3c0897d532f09a40b1eedf699639a1558f6c75e3761350465114369edecdb9e04f2304527a68183230327280e61d2ca7b0619efa07e98b133fa0b860a735a04619e2002e9e9a71732bc51bde299beb151d4d5b692711a827bbddd1e43592bfe844ef243065056e7f40ab7760504c6adb9d899c2a601eb2e44dbd635c1b051a8ffbfb1dd8e9029c9d15a4fea5b74c905cd615ad9f8643a9af046d59dd90121092022c0aabacf2a7dbcc82250f451e008646d51f0c655a6c86796016fd266ff7b2ce86f13fe6154a4665c7333fb049d6f7f9198ebfc7936e74340d74c3e745e6149eb31988b046f38e522b2422a6bd154ae0fe6e8beb7aa4c816bd11436a59956eb134426ec501ea9e631aca105dc86c151c0aefac881e0009149a496091be97713360f935337768040b217d9c407828882dd48091779884a834ca2999c031ff13681a1884d3a90819ede08e4b07c8fc5747144c598106e02d7064fe5207613864ab49276eb27a370b197348bd556d9881174626102866a2f862d6d6c10004f2ca0887d7f17f17343074c401d78ac8fd3f47ab55cb19f757a18b1e33b324dc8894f0307fae4575108d37cd7a08aa9c157df624a116a225a1aebb0fa04b38009a9cecdb28d20df2629a4346f2b48fca22bb65573bd28652d02e4709b663d7923586ff586f131a1c22f29f5303db8e5828011dab99bfeab744e816123123b66bc96e9e64e758f805bb202dfda12395c902566c5f506626f0e2cb038a9c7676817dc72e1bf196942893112c3468e306cfe1c0ed432497c921c6b7db911b823b7ccf7becaf0d1dfa618accec50ac6fcbf48b2e01bd3d781a7a8d21bdbe54c612ed8c8e433ca4b7f8a5328d1dd9098ccc63801d171a0f131db61dc46878a0923693c19f599dbb418fc85c7c73b7e04e3ccf5786dce0e06e084541d9e1db27adddf10bade7a791511e0481bcbf048da90aa09bc7bd019eeb51748644e9e6a923a363e1bf5c6b537775d5e722058fe6402a725e61fcc89a6ff6e379864cafcac0c03a844438d9aab5a97792ef193d7d5023d706b9a5b96c865dd4873b350e3322886d3a512bab9f27c9fa91b3b870e26647d52626ba26b332c17a22be9d4add760e3375d028fd10e7a6df2c416119c56830b8e0fc91c6235d39a162a047cb692e56eddf63d7138b0e26aa3fc693d7562be780c432dd54fdd8e18a57146bda6c30623b846f82737d685b2f42141c03edea0f4924e55a45bbbb07031c9778047e62463849dc3a2d25f5666a2b502a1d3593ff07f04bed875ce1105562492876d59193e79ca4135c387d005cc5e758faf234c8128f740c35ddb4903e5cbd69150b9e5e145019b7448c24b12aa0b60c1c0461fd0db1ba51eb4a1b81aced55864b569fe754dc6418de827663bffe0b38aab8cb0b75ffba296d84bb6ee7a90d16ff3ec936fe547877db655672288790f5b9290ed4f9285947453ee85522da2e033a6f5ccd52c828803d458c84647e09ca9e66c564d46b10c85666900bc5149bc5c6468341b3f737987aa0b7dddd2804e9f5d1f0318d910a14dfc9202141cfd79a95aed2fbe82631584c8a44af2584d8ffb2a56c90fc9f1d97abd66fb02bbe384d339fb7baa271dd04cd23f7ffb3faaa7bc34843f0f4353f21d3748eb401ce0e795831e0db60024f47884def0f5cc6054fd99906ef4c46fb872ddf55d3043f4e6c23b3ad847f8232f7555efc0fe5232d7dc7c5b3dac37be54f9781e030b2d2cc1f41ca1674b116127a7ddc50febe8eb00f1d14298791c65381eba2fb49474523e2ec5307a31bc65171ce3f098087a030a79a70cb844e88d1213cfa58e54904d86d2e0222075148152a7d1a2efa27041789aa4f8eabfcb5a43f2f905a6b01200967a61d15f0ab11cc558d388fd40ed4206662ee52f41930ecf87a0680223f8ee0b1f197e21e1666d19f6f4d5b871c07a92ffb8b8e90e30c16213d6a8d2a4367b5d207fbcebec1842e5dd7ce59a9a3f330ace7e29428cb660a06b3436b169ec66b92bff32f7368608a25a3ed7f16ec4ae410111a226c0194e7aa3a98e7fcd3ac238f6f34f5fa5711c37b6081281de0ab688ee667448fdad44ee54da9cf6a0f6f94cd0ed114f019b5bf2f9e6ed21622f3699a4437136159275c437736875adc7654931be3bb41d2e753407be0984e923fca1b4b086a5912c24b104e922c7ab58fbc374a12d75be1bd2a48285b00365bc3692314369eb1d71b85c42f09d747ee0054c0d9eece12f11596e86443013058c81843033b96f2031e8c2c39611d1f6fb4d384109fed2869b4f5313da0b9800b41ec60907fc9894170486fcdeb5835960ee31fe63a0d21e3f8b1539e938f775b1fed43ca09b0d6f9056384ce40d992008ab0bc44696cdcb99d24ab7bc031b40ef7ad59c7bc93c47bbdfcee8f5643c0504dfa659d794fe8f8643a0bc2f3ac9bb99091af3b0ae2784e23489f71d22f42a09e46b4de865befa2a346de0bc882642231c1f76cbf6094c23002be31429d12222de7450de501cd8b2af9202750593bd38b6c35e2cd25fe67819bd523ca87e5c24b7e517b746a23016f645ec988393a89f1122b62fe4862bceb1dea888c825bd5960d4029831af2b9aa1075c647291690fba5f82dfaf332ed2540c9bf3471b8744ff79882d22b5ae7d318d70192b5a12c4460d46cf1af641a69975b7ff07d41ef2a65ff1e51f36512af357c16c414055e5b3eef7b5268ad64650e4fd8c19f4f2fa3a842d1f2cdf0a49005f5d0350141f9490a5e2061dd03eda013346af81468b1855f1b9718020d0d158973a41b38b270e3ced6b50c4ff42bb78b4a3361b121ccfef2472d4c32592a2a3f4155dc202a8e784b661a1a28d224714853636900f10c37a31deb824732a3d56aa2daf861ed337d7cc89e54b648a78666279d903d475f7d0520561a4a2e1c25ca1a11ee59543d90ee4b80aefbd9d776187edf7bc35b3df1efd2f0c8410d5bca2536c75bbf08f976efdbebdef84cbcdc40916b9d38f1a13f32ce1f679fddd7c24f5f926c1a2c0a5ff8f7a657eb0bd21f1a10a0adf82e62abd75d057b0960a08773cdd04168a40ea6b9c8cb1bce3f101b1fd1fffa4dfcb610905f8279b9d2ab87f2db75757ec60c93937bba28a78d31753e536f04f9e84d6c7411adf693c26ded1a4451d08afb978bbbb2bc12591f520a5d2bbf1aefba606285c479ebe5acecba1f008bc9b4afb3503739bf1e6bec461d55dfda827fb3195dab61702d48c505b88925e2cea0fd0bc86eb7bafd2f480562bfed37fbc92b2e2e3904b07100f8da40494087a968425c85bc743e011b137129fedd7752a66f1dcbbd975e6fb14a047ebad528168f98d9491fa140717bc20dbeeda0c0aa4ee2d0498b2e017e21fcc06c5a8dd63dd56c7d93ac939832189bb20e7816c0e0b3d93e7dd3cd51c79cc27397565fc31cdb4ee34ef9365c2812c341c70e4d312e0076d0154dcee2682a1ae2aa9db1881acd181954a2e1743661cb7a3f524a855c6f05e4629578c357612aad2b23bf8b8e9151b14a008d4cdf7d5574d330706ef158b04f941249c139d7b2aea6e5bfa16d649055a7706e8b883c0d64a3331d08a65e56dac6fd367ea257f84ae464b3fcef0555aacfddd6f6fe9dc5a2c28f2b0382069deaf7cae4c14dde2a4af2540967ab8fed78d2d377d70084c2266d135b61410e1463f212360c290d1c7c4792f721b046033d6ed7acf193405b973818af0ec7e026c80d0a28b9fdc09ea73bfb0d0fecdc347d193d107513115d520c0739fd34ae7525dd795d0a4d6a8bd189042303c3944dc2c3bb913d40a918722ad5f08777bfa45e90125afe3160a9cbc067918fff1847147324879610249f643f88086295a6d7ef1b1ba0c6999f4fe41f2ff9b88d54445b94f58b066d56d405b452b3b38c8f51fea981f4a21da56426c1cbd71cba4dcf362e432481e4bcd317b5bd0a67db67b0a559dcc252b459ea1847dced7c8c8b153e3abe034f70e2b29f708783ac9c8dc073240f49a7609662801c9f89c48d55772ba037be420b47a473329e21e033021ae4da13729695a7bb563f6c277ced9bc63e305ea3bc2b1f9c0e7227099230376bbad2091e51edec9e4dbf0d2854f8e75aaadf13a5adb51a95bc19cf53f1d13716084390d1e765f3d4b296079700bfd7647086e9e01d4e35223a303b9a10fc061962bb29667f31261e7d6d00ab8b044ca292b91ddedfbe6877d260096660e23c6b8c41e883763b636c71d787c019b3eee8665c401178af18a6403dcba1c8b6fdbeec3a0fee6b2878bc03f30a82ea62d2cd60c46524e445205c68cce4a49f145e2aea07be1e7e38e41ccf7e091cddc2ab0f708b9d210c8bfc2af7b4d9b7ab67205b53667c8e7f9274e2eaa3c5e4cff1b6d637b802f189ab81b1528f912e0f398a6e9b6dcfbf2cf968822d95a69b1bb98f6bec02f8b2d4dd4e5ea78dd4648d4e9835c2c5d6ea6e57a633033fef44eb478a056a485c7523348583bfc549673c39768c9e0c51649f6792be29a213655f54ee2df44610776c42223ebf6eccc4fa6eb7f122fab17d82b85941859e556ec947e5af5ed293382485a5dd2e8fe0e34edb3e6a0804e92f23a4bf9892102abd65310a2d65b1fb7147d5a29155deae468fb8e470296c6a9c55f04b2dc6d42ebf8d65e6ceafbb42cdb526f7b1af844b7185234b687b6fdb64a530c5d63b60b062db1a9b2445b6d424f563f784e0ec58c70ccfc6c6ce04c70d2d7e48767ce7ac6989679918446171e50791dcaa69a6125c580e5dcc4ca1bce6eda84dc3539c95f658c37075b16f6843b3f5d306cbeacd5ee5c14906f58afd327cde5c43d5cbf7530ac0d510b206ff85da670d5ccd1b4c40365287bd48fd8ea07d33241f7da4b68fb0b4a4c55f481f24118143c7a52c5ffb219cfdab489303321cd0dda1232eea3ad777538a4a7ceefe8b01e7e10681d51bbb283ced841ed0d0df633d40fb174de1397c9b193c0e638828e82e2c9a20f59329ca4287d61feddd39fc3e476e4d5800cf9fe1f2ec61ee4313409af24d344c38c57c74b3ca3c0d0dab0ae4e8b91c5266605797626ebad7ab3238d4a7411d554c2c233d6c96f0cd15fff9c548cb6d38a7633359294a4c2d203297e0fe8dbb2392385632e915ae5d230d9eaa57ae5ab014b4519fa4aaa953795f9385ff9459b05b7f88f98cce6821e3532f27edf388d9d98fceb5b92c3276c4cd6567375a29dabb52a75da242b7a314809d267959b263df1e6f373b9c77d8861c95569c9e9797aa02b7883e0027637e1051995b20aa1e33db0bfa6a0c679088da269cde95258d64874164f02fe2a716bc6805bb2b5ae2e85f77508f28d09e5a493fc7c4b4ff811d0b205399221532c678a4fa0b95df74ac3c736a31654306a9dcb4e9465a15adc26c57442449a8c83319efdecf6d74592421c0860b68aaf60728912ece1ab8daa507e32caa501484fed83c9a5689c2de2ec0af973caf23d907b403a64b6b1f3c21c2e12fb07afb69b89aa6b81718dd20eb03e086e3cd27a9b64ae9b033b693fc4e1592387b1aaf070269e2f716cc694246582a7a7056c2ff46985a397770620a0b33c81ca8c908f889cefde81ab7830d7162800443649c13961076ba66bf3ceb306c45cd5848f8b6bcb6495f7013fd3e84baad8350d369f53c105739851238a9f0c3bf7e03cde451595445093100e63c376aff60a216a5d51c43ec80bf1fce647237a7f22bf19c83199388be072c3982af0259066fe01afaff41a285f6d990bf365f5546d455ef7ee8aa0c71fc95033068d0fb35e36278a00701525151b92729f20716ebca2a2a91aa73b8b3d7cf1095874df4b74ecbbc19523818c603877fec492228aaabcb49cb0c5f8256267b76647002d288a0d23591f620067e987c241bcd08ce276a073e21b3acf61331edbec6bd129c2e7ea3df45be5808109dde59d1baa6456912390779193ef5177f0ff4e977552ad603758a1373dd6b5094a626b55de0f336a058e390abd183a49cca8a965afc770cd8279be614b1ab9d1e3cf458490030411c2e1f2f04edaf1ff1a33d3e08961988b2ce49c2b0636a076cec93e6b2c90520cdedac14c4a87443ac5cdb189a42223ee196d21483486df2a64820c35ebd7b680b1b7f6a3d5dbb5756a7ae7d79a82ff82ff440b4ca9afcc1ed44dab63bffc93a3ec0d87697d2290374b472749fc19a42ea1db1dabfc41cd085fe6d52a1a557e8ba08e9d01c7db50515c2a32e3c5891a7ddae9223edb98edaedaa01915330d2b84e2e27a2b90ab1098c149a81b60b522e094923e158d9fee0f9b099a281d6ab3e9445ef4f4fd062624736cc9e620d256743c62c0d387c348c2fb60453d74f1a8a6164cc68b81077cb0d29d4d2846ae974afff20a6eb3df9e464f66c47b4bea18301c2eac14adcd9bc56eb6a12c7b6bf45c0acffab7a7b1fe70d69f6ae5093143d7dd900ca021ae1c97700ffd1b16617b151e8fcb7ed40af480580c9cb4a4c92c69b383cb88edf652feebd84bcf52b30df8dc58f485d0e74a8b2fc908bb69f2271a9412c9077331f537765b857be7d6ff48e0601b03755eaf7e5d2434077215131d55aa3a361ced31dd9f7d055e6cd589a5a48a2d43b0121f94b6a8bcb8353526b8c16ad83f7501a2df9bb237f25fd05bd8449b295775fbb8b6abe34f0ea66038f385c2451ea912db50134c77dd904a41ab0c54c1173434742c690ed384ad073ddc05144870c08ce31fdfb5b86ac5fee2f9e49a276613da33d682a862fa272236ec96c36015446e356d7adf5fdc197d757b7d7258eac95d90481973785b6471ac802f726e17dc824a5860dfd60f98f253aa6bc8376c71bbf88e14fcff5f1b0f473a03229308410fec36fd004946a8b6808219e95c75fc36e9dea6cc242d4d2f076e3c17bb0e7602a8012afe9450778acec6ecbe39d865b8e73ae85f9f3c448e0d7d5ca2bba4fadaed67cba29b985e22a2442daad690380f751dadc931ac9285a6054fd05e01a8ed801b0db90749644673383fb808a8adbdda51000bb08c522fc5768e8566b4280b0408c36d9a6d12ef4bc0a31095babf53c64793a3b794eac375708c3769ca46786bcc2d90d8b9e2f8dfe18453cd24f1a495fab30be5130fa2e4a5b1d22256f43176c4a58028ff12eaeec070eb35abc8cbb5beea7a0d3e390864b13ccf18d74debecb0f12e4db6b1b2608da8bcf3c4a6c85eef8db244b691d5732cf20f0d8aab1f5b8aedbf4777b4f4801a491f40ac7f5735ad60c42689138cb2d648ca60fd67548933c869d5f640aa29fc533c928911e99d375fd8a7ebe28309376500c48970cd28c020c7f3a338fe889e1766b276c6d175e090263edb794ac371a1a22b9adda656a7d3e3712cf20dd1413999b0ac37f0ffd3227c40d136a78c74592ad3d91e89becd842ab08a3d0b16d0ea230c5994ac0bc829477fc6e8891778006c50533b83a68542d30c36aa914408f9190ee72b73379b1ee6cdb9d8db26cb50233137ab3cbaacd0736f5ac3995804fe4949bc0dad0e1108f96f39c07e1b63081908ebbf9576235bfddb489460bfb94217d09d176947e8d50dbf4dca0fff975254a3b275b297b6930b2d04d9115e6865208cf1097a0cd1c41df0f8ab22434398a976fe8872c37d4171202fdd969cd66959ff487001c41dc62dbabef24b40a14e733f824bd4bc401cf0961aee662ce2c08e7e71dde9da5e7fcb0464ecd7c7b652403d712bb9200dc6c4b9dc80308b91101febeeb9d0ee049af0670d0205307a09d386e1016ff3e0247e563addfe562bf8f1b589a605cc713459c887111c1a6bded18b0a33eb3db58dec051796312261028fd66af69e9dfb822439c9a0274162d61a1a4c72cf0b2208404114838055e53ff0fdb86856d3c6e4a28365056c9d28b19ae8fcdbad74e631bfe053aad406170f9692583f09452b3f298dc7cf2158b4429cedcf38619e620dd60723a056213103904f39505fe4b956ac0e7e4b4ce3735d2db55e2400d27d5201fd2bc24cf45d2bd8878a0838383450e6d2826565c180a2cfc76cce131ca61a05bbb11fbdcb8bbd67e40d668ad90fd0a11ac827a5d07cfa0555d2b59b8f2f2b4f90e833ff119da56c87108581c2d9b5a7a03c70c39e1005f18f72845be647e7cb63c6bdd8d58bced3ed7df99f355492a32ebe824ffe90b33e8bf8eea189c64038f7870ef9bd1aa9fee79a43dfb806d11e55e24610dd3e0a635a2d039fc55e449d1b62f22c1662f619891f0ab0ea2ff76653c17985fd1b25881be516a66449f1832ee84562b63bf104f8d327b1e56bab6d6e14ee347a64b5bdcb23cf1695d7c85ea181e875c570ab971cdf2c80a15fb49758caf03da703063f19abdb6ce6e4356fd1c131efc9b2cf1d3dedf968608391ced7b96ee6d071c6a8e38ae76cafc922c3dd99b7eb5c25da32c8892435d119e8533fc3bf65ebd02015b7013b82996ec98d18793a6c43625f0ff004762ab4df9c04e83b4768ba6df27a8b407f5149907819b5344f0e4a76c433ef88880293866ff353ff4f4b5f35789694ea52008808e815026fa225f0cd3636f65846fed129935f410b495045dedc4e2a706cdc292203e0e4188a27690bea5f86f22b7b5a857cee935cafb9dd50ab51b32c6ab96a104271a12afacbd795976718602098b257abaed5d77d1eef63650f2db3e2f815b83a359f31a74486571335467c4640d5257d731515bb0ded783e589fb8559e3d7f17f455115860d679930fd5984411c39c2df51e320acfb8c2b8249f0f80501558bc9d97e4edc268de6f98b60905f169ead6517061521999f68d1e38c251ebca319e222f8e48f084eacc6ce695f847925a83d2db6b75ac221d6e092e7338a703e66f5ec3a3a4930e1ec40a7805b167b1256af10622fcf44b11dd191f4f145ec0ac5fec7c99845beed924138ae664b56fe112ca3ff0a2212a043651ad8b579f32710de1f11856dfc12c6be0f817fc81a0e9e22ebc75806103faf3bc26ab1854291ba3ac0649a8aadb04452e18456af98617a3fd3538f315e060fd875bef2fd0f58f8c2bc0d134e14f71637cf880c955edad8e8b611258b9d0895cf2304e46380b28b1c598043e82dd57e44ad06bc617f78ad02b205c9a0d292e0ccb903a834989365267713e54690647ea678a0e30f8545f43420a700b965204ef96330855644eee547351a9153ddae1175c5c3a49615261002a89a3c7d28061d6870254bbfcf8c4d3f232c3b458bbdf452b4ee34f22b3848515cbb8621ae96977019660a2a566dd107b2e69d8f88b8b63a3a3db4c384833cb5dec81772ed77ad64ba5d2f574c2cd0f344976ed58deba32a0351fd15b151547da3ee939f239e01c7243e77da80e84b77ec27a9ade9e837aece030d51662288da86781348da2cf9e4d91fb1cf94d77fa9d82927fd506624718b8cb4168d64f1be9d785abca0fae1fe967e8bece4a59e416fe8fcb06e2a6bf560d9025878d4ec80b8a1a000f3460ca67d4d0f389276b674c70b4222c1c22c5bfbde3e51faf73e1d4e1457d17d911bd02e2e9d96571a739353a1a39d22247711eb86f688155a2726035b1db07adfebdec94af9755e8a48273d18c61d81e6f03afe27cf96adcada8b8e2422475af05eacefd52e17a3dda8c655a41d9b8300f1e6f94d59a743ec7ba5245af0517981f8d9e6f8baf8b86a0c82fbff35b84fc993861b390bdae49f3c4c73768f4106be0437f20d00e5b95a3cf611821aafbafa8c73e48c18a7012c4d20f6cbe87e71f5c6fab6e44556e79f75b643915068073f7a1d94604f7226ad60633ed37bd4ab16e4415a7b80d7903b448f9031760807a180d55a7f1854579b5272b11957aaf1612d02750c1b0ed4a59f6a0260da01bdc294e39416814845ccda753801cba9e02968325471d550cc2b2ef8c1fa0fc8700126355ab49b98e12c2b160ad383e59a00692599dc3a35e8b9b4467ad4f78591a0b8fae470077f55f1cc14fa24a682c61762b12d9f60de3c89110c2408f3a83c4a2a9c87d0f3f111a71d5a3c35fcd49da62b08414d6d34a28878cb2b1a625dae9d88dbb12b6385b1ce48e25584b561963cc230d98d1c2b6e31505279a1f0bf4dd9f44a5b50108abce5b4903110cb5afcd61c89c91f2ac4be423f7de443819a9b38cef2b501ad2a42123a943856ca3e66f327b4030242bd9639c4901443a99f54c2c08d768bd4bf755ebeca478b2aeae56c936ac081d81c97b3081a4a48d49978870f31f7f774a63f0102348cd06621a8465bc756d11f7edafaee277d33e7f2c35ac543f025e1db35138430a298f796cb30bf208294ef18e18ed8286233e477bd1e21438a8088e5b88fc664bdfefad96158f5f8db305babc207f361aa787711edcd0040de5d2b60d38652981e2f1346fcb1af0412113ce3b1340489010c7f373f1b4218e146858c017ebd9305f3524de2fcaeccdaa814c7dc88b7202fcdf6aa417745bc1ed88fe3e2bbbffdfeae08fc3196641dbc86d76238e96d608cc0444359d7de34765505d899cc0d538bf10ebcdeb8d945abe5a1ce710b676394190b80a76b7f6aa56ba74f2a7c86a6157ce8890a5dfbe0a62ae28ae7347f0bd44d3b67461b7d85a6739215ee65c9f304f1d64d34baed53a40b135f1080c599e30fd504f462631e69f743e766f7a8514ded78feabb6ca781789b2eb83ebe056286d212175c9e08c0a5f1991b14825c501f3e7b8b59e242a11768ce43902711722b383c7e61e150d4eb1dc3d7b99dd14b1565b2f98f16e59e3f6d3506d1ae3c1e4f6b310da49462744bf307a6b1d361ab45835316aa96ba83fe8e2e5d5e2d0b836b396ea62de9b5f83e1f76cc1fb7adc9c30983ee0fed148a50489cbd1435bb0d69d2d8ee98754690fdec4ad02506ebc30f255bb96c281e1dad74ed2a0ac3a477f597d961b2c7bd0627a42fc11d00d04e5b59c950ca94d00b64bc0945fb3dc5e58241b4c3c13b846b61424c6c86c751c55749fbc48a2545b6375a0b09f5ad8927359de381f0c4b1294a50d8cc73ba487915775640afe2c3cc45a7f060cb1ae44b2931ac78a2e5539b3ba79184d775a5fae5df3d433e32c312df49171bb3c7ff1206a515562446b7a5a0b399d22247ef327a5487927fccb78aee4d40fa26f7c0757bccb233d8e2af61d588da5a51f5a00f32ca59af193844e11787f86d1fc968412c1af469bc8cccbfd775580dd646523d2fb63ba43e608908e372216bac21f61bf3a359da80ccc9fb3689d5fb058f793d2bbde05e6f1339677b48a606868818db2ed04fea2c00fc730f03586e116eba4642c404df12f6a09879ecd5d620c7af27ddd8e5b72a3790c48239ab4155e147d0c26085b1068686cf17b89e8f62156670e25f1d1b0234a2c8c2dd532606c3f2b8940066deadf66f56a922b8c9cf60da212194af4316cd4536a0de98198bfc9388cc1b7c5cbdeda337e1ba003451175a7b390a11d9e4040894ad34eadf3117b6b3861d7ce0de1be0a2404a40f7de0cad44410e0f892868a392ec0090cfa482ffe87de1dba5402550fa24fb045ed2efbc9461e05b52ae48b35f65185464cf6b462e063f4f2c6063dffeb4848b50b52a0a14105f89f0aad3dac2c35466ca7af93e8723ffdf0271dfc73506cdfdd8320a28137221b7fcd608d32ac486c2909c1ac125b05ae3f11281019adde1c1329cb3df59849f502c88f1bf3b9dbe218cad2299ee2b5cdb14715068dd52809b001e98740673798fcbb4569e6b557a9f6daf4cd90b4b55f6e151cc2fd4b9646e97136b108fde318263696076ee49074466211ef7c49c13ae075e9d83845ead3cc005304d81fb57cdfe489f2594235f94478622c8bf8383ff6074a8daa64024811500fc192f8c1a925a5db63022e2821d52dc8c53e41c5134433693b7f67e0429f6d0a93422a684846bfe3e797c3dab31cbd0e6dbe76f6788711d335c3bdc070c8ad0cb4ab20c22102d82989e9baed187e4e21df4b23ad043d91383869311668ebba68721586a097fa504823f94abf8bee2c60787b4e58ed29486b2290f005ea5b32ab0df41b648a4b8a214457f8d006b68db587d26a474d55acfe7bc8bb9a795e2c101aa468001dccf1271148b7818fd7728108d3e94ab8d42ce7ea4e38e1e8429e985c08a5b5e2112f514f35ba2f6efcbc52b672a1a6a1d8bb31a3353bbd89267469059d30207dde74a498105c20be18992bc0304053b1c45aecb1e82d652fd88a57e6d875f16ef84f3e627ec84d1179fa9cf46e212ecb9728c4938b398fa82b1517b33f1940bb31e13ee69adc6d9b1ac1c4de8c40caeb788364dc5bdef3805cb6e2ceef695627b21b443c45613a8bb2f2ed5a0f2efbfc2aa0d428179a308318c8c7e5daabbcc30e7849bfcc11c8db56ea1583f0de3d322cba806c9249c5542b2c9877ede25c23475ab5727d3543e7cb7a2037b9356ac95ce4e7ba518385a5bb1a752e9abc41d73b3f36286c2f0599d3e9f23895ad4c5c4b442811bb430c470e634d0751a5c5eb0b4eba30f482f35b67acb748c7a7df179c043f661a2a1531e30fa6a7ce50f9c2162097b0b3d168abbec56b36d2889ab4a8af033097c9aa15182f3f3baf6508bb669e14dc0fc26055f4699522b318cb6fed27025105446dd3c9e62d3d796934d0fca083ef3e54123992cd5be88cb6aa4acb41ef6c20e394e220d368258ebcac7cde12b2a3231441db814d82110e9a078cd9c3afa8e7cb06bbecff84ddaba5e21d0a20f66938dbe31edf9d6f0b28b8bb04167eca3b2ffe703a230e8ddbd4bcbe576903cb061a907e2d01feb3220be336bf9640965e64a2d71ab29ed35b0bbd0db739a0c3a686f44b2d3c4538836f9bd32c4921b8867036bf9e0df731b46458c0b24100ab9daba55026c39d8ea78eab8951f7248d77b119191f91efa5d7b698de7e209089d1b452f538762a8b6936a7da646460e43d49d78424a3848790bb9c2b9bf641b1dfcdd9ab695301333bec634e610165af8860cff21e80f301cc0053cb26351fb4160aca6e99fc9c1717d635396a8052fa97029219c6570642c519ca55d40883f1a49b1b94e42d44da967bd7983474dae43a0d9c106ab6957f7bd7e98f919cd87e29f46b4394ae40724246f783dde38bf5b286fdaeca31981fc047567e7f6e353833e548ba1ee51ecb2cc6f575737568f203bbd412c8642d36a14c10347b3843afe9079b67adf8bfbd888633c531ce524aa8c423e4c106a287a733c2dc49892493e29a394ca38c289136c34fc730d6400d66e56f5befb615a3cf83910b1a35f704e7aa114a843f0bcd23fad81276504b8f31298046e11e91332dca33890239c82d924439f258e00e3f4e621b6ea4a645fa1c451a0383913cf7b9f070861a92b4b935b6a513803dd7e65ccb44ae88611f7af66ec68ce1afc575f9241afb39943550afd4e8cb67ca4e6c5cecb86de427b290579a207cc7d8252b27062dffab384ba338d4cd6fc2573f02d4a0421a51ed218b19f2f0fe3d81eb819f81b4c6b735a31edbc59ebe5eba4b081cd151ea943052f72e036b76b07a70455ea383f291b6904f1f9eab6c793b645c73635108abf378a9571fa6a505de763ec58f9195c4264ba895c09c3be0bee4644b65b029d48f3c48c16859f04251fd2bc24d5d83fede56fb05d8ea311abfb620e56b13fba59fef5f22c98189d3a94cbed22b0bf73396d9ed71a986d07bb75e56f6eb4955ac218b1243c205ddc5b6085da66fec5fbc41953b27b7b151e7317c3e6f9fa9006f0f2f89cb53092486577244abfa99065e705a39e4ae5e2f9182626c9c67fb0c3c17870e6a3a9514a789e90dfdf977865d22ce65218a910214de41a7894766e9d41b80aed92573c0c12e1da0fd1592a78bcf60f9f4fb0c5fa1cdfbc792f78f9714ce6cdd692c76e05684158b827c2fa26f03a9dcace322b61a76180d8e91063a8807731bf46b5a4f05db19373b88d85e5ca06893277c57bf2c1d781aadafe2256b599f2103d19a9ebc7c75c42aba47e25e31883f138f7e5b214a3bd32ac84c41ea1c60dd43cf2aa7402729e7f6cd68bbd47e26426a839c8aac6faef6552267d0d7894bf5e95618a6d7bdffe5c5ede31515e1b4ed325f5f1550f8886138ca405ef357bdc79bc0115462404d615762d78913c8f9292bc007c9f9abde4ff78a6cb6f0d2640ad4407602afd3825f50af05fa65db34e8c8ebe1460f776ec01e512e4b64f62b81b3367c1572b7489416368859071baafbce97d325940304d6f58029294e354f9e03f4d03a42e4cd0e30b88c61d9399fa25f076f9bf896f4733a986d1d9a63d17e26705f1a681a36bf5b9452383fa018bc48d01a3f9d8344204c989ad191c1b6ab65993d57ffca0e9e931f34883821825e8378a74e824e48ac94607602f5f2659d35d41682c275c861afa189b898101bec6e1470a82a16ace3c95a03e878d8b76c6dad9578668fea2d0952778403f082a683c5df519c0a2580eb9dde228e0284cf84c2936d3777395d49a13dc50d38bacacdf6cf2003d309196c92c17983a179777451abc874331d342e02c115ea9147a565968cd52749918105793517e9ca35af49a18626843b6f1a63fb087e3b4133f55cf2ff79ad6b113f40e04420aa1cdc447c6b3700b6041acbc2a17fa81712445a07f070db66f4edb4408a8e499fa7cd821908bab367cdbe5f235e3023c588d872f3f415ffe0c461d2faec735a339303c63e74f57088cb89775dee600eaf9a53e6c9608dc9a8467d8bb5b4eebd69c2ed440927c45337184dbc906963f627a13f13185898faf4443dd558ba30fdcdc4a6144333206c945d7db4d5d1460596c31b2c00e435d6326e95e239394fd8e9bf411cdadcf6f9899195b0898ae37cc25720ad74042788885fd66da309c6b13a0d73bc0678f0afc6b0a71fd7414e880da125f5158d23fb53567db4a42141a121e7b2326c50d3ab3ba34bcd2032ebd41237c056575d26c85c426a8ffb575054ea3173f1c6833fe8582a10a269bbaca3d082ca1a52e5553c871f0f82522deb356c416e88538dad8e1b4b912c176413573507db238d1a725533db557c2285d9304e2b7d19ff4c4d24fdb48cbd9b6f19d9194ce5c3424431c0fdd583ab25305ae6cf6b25811edf0f01f7224df67873b293930dade3e3672055224dd0f9ed455cfdaf041268c8f49a7beb51de0aff27365b215a241d71f41174257eeaafa0a68beab5a9ddab171a9db0721ac17aaa90242b6943c394feda96730f8f85312d12c27a7a88e8049486f162b3ce5b02111db0fe360ca416d27796f25d9d2e78ed1e5ebbc0a20b4083120865fe96daf9125256bcc530a291541fe87c72eab57e15c9643d2a61e4db5cebaca8f52f9a85a0c78a40ecafd1526a927f18039af82075cf1bc0bba98f7a00402c1b803f4c574f6d40db76cee91506d0da21402298b2bef6187aee3b85f7e153386580b82914a4b3c69cecdbf1a108c70174d933c9db0f54bdf8f546b514fafbf0512de6d20d780a002bda80a5726055bf8a28603219d862fd92910297e4ed0227a3437e42ae3f78e8e6e22345dcd87ea404d0e29f6818bc82dd1da4109e030465210fca758bf462a474af16fab51128c5cdd66808b9e038eed7cc7ef9956a00bb082b1c4685bd314aa0ba2492cbd7d10bea7099d18d1d6a377bbf1ea4db13656f600611c12a84cbbed41d571aeb9934036ed40536fcf813125b2ebd953e25bbd2a45cb7a24ee5f6622e8ab37465619bd178175df9b7c95ac64367378c3cd0140069f1a771f53c1aee04e1f055038c566b91b95c7ca22655c860f06904f68b7e18261c129e2dc1066f3675361e66e7d2ab46b72a4c2a377378da04199aff21e80ab70b35db6770582ba46656d2137222a01a683821b72e589c8aa7f49217a74c628dd2017a48bdf83b2f3462487b2606f2f47b1eadd7abaa23616f5adebf77a39d3d323d14938ee88ceaeae23e1b4c9b3e3ce1f472632f5b5f39d76c946a67980a135458b3ccb1c9509dad37b522981d514b41b4c131642b50067fcc118d524317d9e9bb442ce396a86e5b428b6a40b0e6e9e857065be7c103a77ddd2532889c1354383e1f9c160afe5590bf756109964587b7c9f3d92666eb9783551511848096b8d8fd30f17c9642c58cee5c0d6de55c522906e7c45d0939454bb44fbb47348db92fb76d51b2e1d7b32abbbea0d179d49ee3913f8165dd8456d2ba61a5000ca6596b3b9f3723523e0a7d82bfd26912cdcd8870dafa7bdf5b480290a8a735d157012a965415686d529745418d21602241402b778291d72f7fc183896d77ee248d3fb8b61648c9c9a8e19492e106ae93b0cfc4306970a53bdf9059f151b3001eea9ef41e1eb894adaaf54a13bc734fa0e6f6112685be9f080717db0122d99faa1fe97e05fc1c57e6cc110280d9ab0dbd8ca86243f9fbcd6dc56ad9e77625902dcbfd7b5a172cda669cae253cbb95c3c97c18ec3584f70c4491f6d34a2c55bca6d25d7c99801f94e7661c0a03320031466d9e9adba4e1981b7261dd844d109016712db57388c1d35d1b999928634f84d5ca611cac5e53d2e2039b2d2c38a0d3ca438a9502964a21ed1ea5ed8c044b3e022a4aa02858f29d365559f77471675ef0755b25c5bf04c2f9f3b1f39d920e1b498a3f92020833c2755565baf15e96b2b266a118d40b39653c63033d31ba1db30d33b5f2e9237b2156a46bbb2c74619f06619a53ea93bd56ff1fe58669fe7511c7a990ecc1a5ed2bc9e6d45f87e5196d40abc44772e37ff7f101988e8a9ebb9ad25949d694f124c02153cc6970290d864c9fc72aeff8e522298c4cd489ce25e2789c1921c1422806bb805c617c8981f9af5fe0e4e9b95e6e60fa69beb19c5fca08a0bea187eed957d3893e77b59a91fc97d7290f6c23b4e17520f9430e3a898c7259cf76caa23d06ccf16d36e0c7900dcf3f1c0c6916d425e20f7bba9b45a1d09dd87e58bb85a621ba8d74406a767ab59f97334fb7bcfe113e966f57ea87b90f6ee7bf4ab3660f2436c764f87e32bd6a4a5f978fc6e9ca350260a4c1d4d1dcbcc7c059ff8de670c2a5faf08f5cea1d9ad4f931ad45fceaab8ca38719bf8ae152e302a7e03c453bb3338d02c226c1776fbe8e696def33cc9a8c9000c6b680a5d20055aeb5f01948480f2206be62f668247ddf0c7424ca4916f324aeea057e551b0629edc70cbb75059d714fa3f5d707c4602e27bae0361062da7c6e503e62ff3c30b0d6ea39534d6c23d2f89dc49d6488392305f499865b2e861f20775641888c38bac092a1338f422c4e159c1e1473ff24bd214cd639a5fbf5823bbf3537745755101814a4cde63c0db6511d4390fce353cfa12700aeef529f39da47d3d78b77d7ffc08871e5061d166580596586a33022568e0a95cf7736f611b39b315357615d4a3f6f86211409cb0cc64ffb35760123cffa28be2fd724596afd020fd0606d159ef9d5720fefe5273afe00cc8b7ed5865a5d488980d67ef2092d5bf331f2fe24071b68d51254e57c1881dbef8b4bcddfb4553081196965fffc1b05b39562a191b41e6ad1551f9afb575c21efbe8616e516d9092005a6084a09459996d80416e9ceed1877dec58fb910045aa73407dda5e58104366d3712aa903d766c352b84e78676f30cbfd99547d47ca08c2c8728e5f2ae3df8a8312186375af03aa99dba2af73c21f87ad675dd8798a7c997a65a3ae958d01b217cc4b98bb08a3abbcb77237092036d9bc43092367d4d0aaa905cc39e28e11a72a5045123d211ca54d98e669240dff4883fa2de45daf38c752977fa811c1b55609c8309b3550a367079c1f6fc8ed12bbe2dc4c9553470a59d54d323420762f84022764669e2bc16e67d0bfbf723c270ade8cbae829256ae252aae31387d096eeb18989067ff40ecf6d9be0342960df95780ef81a84951b907fcdbd61bb4d88492c590411462e5e1639a5fa251c03212ab94e4778ebcd48ad5df206b2fb4fc4033833b9034bd6ead0673578d551691020256fac43fb95aa6ae497134ca08e7d3518057f3261387cbddbc1bbffe402c25564a7f2af46154124ac783318364a6f22f293e3a82528bf3c284babc3d064f142758ea9d291de32f62ce0008ade2de0a150a61c86b011430a144588b7ddee8ac29f9fc767a89615593c7cef9a3e02db71efb96210ffc816057bdfab5fd9edfed807ffb3cd84a99ed564ecd5acbf159a7662b9e83f401c9489b65f88d28c97b3be308c3119a80eb23877cf281eb11a6be5e765cefa15ac4bcc8dacf47d8e483877609393d19f95c9a51932adea06a1ae4cb3c0ca4867dcd8dc487acf0cc0296852ec641da9d7c90adc81ef02981c82e33da89718949f34877cbe0787bd80b8a88a08b0d6c8e100a911a79aabc524e257890db7cb927f4305ab2683ec9d378019880afa570ae15f6a52e8e170567c9a91092fbc294a7bf71f5278c5f99b46b78713fcf3b9810f421acdb2b014059e9cc5627e96660bb8ceb2dd172f412e4f6c614bbded915c71ce29d7d6eea3da7cd166caf4ce413a5f66002edf6b1d496bde3823c26117940b9bf5f4949d6ec4df19310a57bc43a6ca03b020a28f1bebdeb251d164edd02169a57247af1122ca37431883469aa901e50aee0b69745fa977c45a9477c1f45acba96be8bf42a68e4a48ac6ea275dc87d5647e2e4bb616ba6f4586aa3a8fb3deaa7b8f082cc90e104a1611654166541f14826d253082135ead870a659606b596b8adf85934b0b079d1e7a348209359f8d168b15d0ef918bb3dafe822f91a9131008bf9bc199f3a422af1388d5291f23219001a3f3d5c5e109fc8d4ad62a06c63db3ec3d1f1c59bd61ca52b8e4f8c4840570a2e9e26665b3d8541ce32b34a5b12d9c425857fa1bec75d78721537a4ef452ddc253b79c087a28c5bf338978dc89be8f76cd64a252ef0e7d46944b1d89efa1889ca5c81d67d660f50610fbe71ad304d29f313fdfd898071a4e0562cc3b3a65c72a4341a59bfd92fe192d481032e53482eff4d94565562c8f75638a1ba60594a8156699ae300377c18afbfb4f302ea6b3963704a0410b565f7c971d249255883432743e5001523f663eed6660591eaf966200fc61e1b87911d4c7522d50ec5ec51c15578cf50f497b113e1da18444d50dc7e723f0363c352ed6ca3406f959e0f064827e72f9c80f923804a3555826927e11609a0eb522669404843073b098ae0603a2041c38a2f4214289217cef2c63ae05beaa00c4b77f7620750c01f1003331775706336f448ad32d03974ea0ed155c22e2c0b50284ac48930d58be043c9628b8faf8661d782ea9437cf7dc50820019faa5d8c33e845ac65b064d007cdf0aef93ccf25126d3827b7c60497cbfaccd4530e981976044008879c184324b2281f396bea0b15df5aef0a80ab4a74398e3110515c98a8de0caba4a43eb33607c9a1bd0776134292c039741b8e986de6cb8a66aac1ae7bb9472fd97d61c6d8b84070b1ff7096d4fdc52e66d17ea857ec064a1b77821eaba5c7cf25dfe8dd9188c7a70f327a4386953898c50515c5e07b0c8d6e20e0c40e749b414ca0dc4d78f302122a0d60d41c0d7fca4c5f851b06e55b183f78e629b3fd93c1677a707fec77251ee896bc52d6e13432c95e54ac7eedab5a6d4f4bf009343e6a283a80128dc03b60d32c47e69ffbe15c3cf1539a46079ebd954b9b07ca34564f3051b25957b3fd9c146a43835ec85a59bdbece417978db00e2d86ecd767eb9db491a3f74740fa159f871790ca84094bfe32f747885cd831b693d2e63e75e963254a313fd01e86d5d29436397bf7d69a7825a8084a5d17d7fa6f130b642e0e61f86b346e15fcbdc868f4409d046959b16662eb78ad806784ba3bd0f467acc909bef00a7acd467eadebe651ced6543c8d98538731381fd0a23cf0ee97170830e471309294933439d001954d21c72ce443210703b0805e073ab3bba107a02a78b87e77fc3c2384222163c35a4c46582b2448b3c808c48c862f1a2b4ccec42968704a2a951d320da2c846537b0fa1b5d854da779109d7dff4dc555ae775322a750112438bc976a3628945153369e17c1264478f227c0020a773c6437c7999e6764911aa5d8527567ff4cbdf0143e23842f5ad3c06050cd6c4de29450a9f2e0c9d248992872fcc9ed18dff47fc32527d0b6fe889e000d54e71ce5cee2188dbf37fc98f2e3d34873d09982e4011564bac12adb29f0e5790b47d2812800808aeb89821365525dcbf8bab4ff7737a89f634a93bc80acda41e358e611a024f02399520cdcd11d4486c0908e134c2f3c7c18f93a5bda9d6c5e54118598f93131d9bf4631b0cc424b11f043741ed6204a8c51808115b9e4b4dee2d50a31608f1414c3fc4de83a5c7f1687cea2eba3b92782603bfa73a54bc78fdcc752537c60b0f5f1fbfb4e05140588636e9918dad3f48d75ce931a02f39d4fe0b39a7d0eaa3e224ef825cb7d94d25380e1fb87fc36c760f3f6e6b62e2d52d4d1682f8e6684f49df629902262fd646ba2a011e70d14f3ac26fd3767c10709ee101153500b44e422a69cf21b5381c6f4b15f724317092d9fd7af23e6e97258ee7220020fde3f01c465d26bd888663966848540372608437fcb966a8d309a7d75858d131e72f173b6b85f1a27c80a88328a1577b68d201f1a77bd0dc113b061d544978f06dfb4fe840c2d8981148d625c85dd069744b55b65908bc32a4211568bbb20af3525d106d0ac97a0ec3f7f27349087e89dc5ed7d33f3bbfb5711904b085b6cb3e3346e0c901a641874a6de568564285939a19e317c7b4aef66b744d7ab0163911b1e911d7bd2f5ccefd9fb12a298240ef6a837f32714e3709c6e08ca9216c981c9b1a582984dcf0059310c09c55cda92ef77a329a8e86fcf0f744767a6c4616726bab748c5a6fc32f1a05e45a1d84bcd20c2f0275849aa97ad4d3f0451d0ce73a04a45016f760d36643afb9eba6d021ecb6e53b912cbef11d1f590bac099b3e98e8fecf332bc009c7ce15185796d3d2f8acdcbff84a3b11cc89eec9296df8fed6a231a8f41651a673f14540c1190baf6382354de66ea56ab686d7361281573ff327442f7a085429844b800364a662ebf996a6a3b21769b9cfcbaf41806d7cadc138b57b44a2abdc60a731d9c54a6c8323fcf279c2fa13c5c8e8b97896cf3c54be90ed130ec753757511ae6917b772dafe94f521461d63cedba8242e1105f28a261632a30db863d7e29e7835f3b71168cc8405ae199b538d9e3a5d89d16fcb1a87dada4f29fbb52b717efa0930a636924b530aa4958d20941a66ef0564d55ac8f667807bee96e083e2d6bdeff0d73807fb2e08a6df6154fdc05ebf09dd2603a9a387f5d6f0d146676f5274409f10e064f8d88f54a6cfffe2e69b994d5d69757d57c921983d16a7d0806cbef21ebad0b1f139466ad8b0c0cb8a54e53c3080c616b026149cf39c3acc29e759d0fd6b54dd428ccd182614944a9b71adcdfbd3e8a95944f79b1337050feed6ce72dcd4fc6b36bac51a05083d62406d0d4e83041632a9e84d3d0ac4ff393059f7224bf0ad5a4cfcffba0ae9660ae3f350354522aa3394da4ce1383faa6723b8063c93262a593a590d76d00f38c149e69925b9ce9ab15c3b5e88f94a3980050ba82eea1d90ff8530787e72564125ad5d6c9a2347d4d1b1bf6fb712fb96bcf2c20116c762b69449118546829be48b8d980e1e04712d4c90136832f2fc03bb9ace910446bde292d37e0ba2e228b80ab527406c460004db2e108a23374d737147b1cbc22532b8cac84b1bfa9a55ad8cf29fb11e04b18f9834763279aacc000b88650c893678a5d1f4ffd844f7ae79e04a33a1db7b89e7a4cded60883703d4c430ba44c7990f59b5e0e1537afb6caadc2d649b18b19c4b236314192e3ab8c5c62f007341ce35a86d809756859fa14afa6184296f65a4c262b14b9bfef9795860986eee85d52d25ce6ad99cd48be425b91d3b6a18236b5a6b327532a26d2c2d8387a338169fb882cf145b7e8434bcb7d829f22f5e954caa9e86a1d7bf1240feced94f80e00eef078feb402f008ff05ccb20eb1a74bd61089d92b519064ff5c2176cf5be544a2bfa705ba62bafda1c7b1551cb4460bf0cc233e2570b2068cad2dbcf92b112521ee8eec2d9703da3b49fc33fab217ffbe97573271b867b7e6649fcfeab4d359ac0e8b3d37b2eb1bdf4fc38e5a8e7734bc6e282b34fd6d292528a9d92740468988f9a2be8e47a838d538a0cb08b914e8dacb50c9e996e91cd9e63aa1a8df0533a60289ac23c577340e6bb490676a1f1c23fc8ca6f918049f05425f7d0d240f1562f8e05ab891bff85ce6fe67b7f265e1903d2e44d3c9a030cf1b61d62ac6cb6ea29283319b65cd3d1ed99ee9b00fa0bcef7f83076494857a1aabb73d8c8dab2bc97452e2a10a1d158fec1bd1babf8a836dbc0924759b67a1168ddea7ad06b73e05390e8c92b79703e6def143f28365b62e3c1e0416281da2b8f3c9b3adcc2398b0a7a4a75d9617a8fa5a27a5e9123056b1adf2fee36342c98329970c01b0e9271b4012653d4355ee0552f0809c288fc352b8b71bb2b2adfb224fe3c3fee3f6c9c236781fa8f452c1a3da1aa50fd8072aec2af1fc479ead2505224c0e7cdb00cf9712e282d964a6202fb6732c77bc425620b1a36a5f60bdcab24b99a5a453c5882783a1fd8aeaab85865842dd03ee87b3b4b7713b105ea4618ac3563234e2c2d2a249f7bc63e75ab93663b324ebca3775ce4bd3c11e40754d45fa24be8fecf73240d0208a446324c7f5e86c2a00a735a9c8e21dacfa4acc9673f33bdab6cd97cae66492989a4cd1f0a2431e58098515a1068a1bb703539672337e9b7b25ec0747737630c6e2b259967efd4b77d44d2a92621a25865b3900657cab83bd399557bbe6711c0fb0acadeb930f7a42feefb9e21efded7a2329fb1a00fb0288e463824882efc21cbcf93f671aa687e990f23191ce25f9a4d0d5f7eee8292bcd4fc031a1b9cbb0774cd2b8a792bb8d81fb55485873b875183e5f91ebfe9f1de1d8da605fa615e3b372b6d5dda3e70451c252c39d4605fed1b0f3bcd993005a2c398c6d0efb2ffb421cc4424563dfb530c7aef1292627ee24226c6bdfd1ace879a94f379bce15e2bc50071bda35c0beed005b269478aa892aa8f605c5556668fa685f7212ba0523881d261005b245b6301cbb132a45b636bc5c8d50876738073908aef2e92dbe881853e0b9785630679571d900bce84b8fb6459efe8c6d6227a2f5be9b8a0e274e6a57b143f3e52a8a3a1b36916575a00c0a35e238e3ff4bedd51fc1a80c7fb01e11d04d4898ca07fa9d641695cbfc0b7bb94595b05fe9fec182ab259ed771f4027a3a892bef38142c92eff302e5b4a3ac9c1a95d339ccc253766ebb29b6595d32d1190e23cebc5338cf91b4f4dd9c92bcc677d392690519712713cac72f3df2161f4e22e4c153ec8dee26b4918bf30b507460a93cc3d6cad0c40eadf6808ba37e80d93e31904f568edde2130984a123d19d58b59f02915942a54364e8540560fa6d9aa95025d3adcad447d05a09b665f02d8c2e319ed1f66f8b2e2b11392574e8d83405cff9a54b74fd2da9ed6e0497a530078d8d7832c59e37c813f6f4da8da2cabe89ed55647de9f912af9cad9100f4f1321cb856191e57051196aa9b54c0061c834be101a4d700ec16528155c16388913860ded7c62500b6098be0589ae1ceae8de53123dae708cbd9c8a88e96472e009737a1ec6464fcc28fe1983d8abc58f5fdd9353065bdc79ff750beee71b2cd45fdd3251b223a95403726ce4635c5fd20764ebee9e2b7e725afa457513bddae2d8468a907ebe1cddf204c831422bcb07c36d046cc0512e1861adfe67af02477513763bc8bb4de4f2ae3e04a201c9af37c4b8bed3e8200297795510a0f166b4bf301b8020615120a8ea242ee1da6ab60bc6373cb32da51fb3ce051013a7e20c519cf821b7d1c36ca1a0f9854d52f799b0454b5da006bf3b83c0853995887f6443a7e545b4c29495ee0ba8bb50f403ca75b35f61bfc0948c9e033afba4edbeb576322d49035e4cb60d113b40370cc87a35328e1f26f8dc18cd70cfbbe0abf6a81f1b0ec1760e683c2bdfcfa11bd40c2eca814f4b4195819a985203b41fbc98377f1a11fe498e21485ef200af052d2d8b7c40c87c8784e0799bbbdeab5de79328f8803f8d942a24e83e190ea1a0912fc950220ec17daf0d5928d2e8e2de07f2e076f778b1ff6a955f2d1602aa5cc1dfd30c3b70d0a7f74d2826c6792a6e211535bf946a4f50c684ffa188600acf10f00886014d881610f3c6b3df2c8a5a265dd2c45a7ff7482790ad62542af58fb8b339b82fdc171b28269acb4108e886842f7121ae47cc9fc472f4536506478e182201dc3e246496513c05920a3cdf6a8c3b47d794420671e592b93cc258b73e9a5d6901607523af77118d2b7e2294e2d6ab989cc80754359177bff28ea4341483e3b57779c4b80f5a041ff07ce5fcd9bb9a2ae1b624f6aa544e11c5c55f7dd8aaf1321fd9aa92e7640038545b24f0240d7257de4f2f4b45a08cb26eac54fbe52e2a0267256c1be98f6e7a6eaa3eaa5794d21e19b3c6341bab8871dcbaa5ad1b32916f152f7d5baea0c0a9feb50745a268ddd70a3c1f73e4bd7ff1362d55147c2a3926f92a4815db9c9eb1610fd357702d3e74cfa28889a6f3f38caa7962f5670a3fecaf725d0048036cc1b83b6f84aaaf44d5e9cf6ca300d393b03c517c4c08aef9924e26e7d02e9386fcef14c4ae018c91982f1944a7e5127acb6681bf4401d975fc666314642efbb7793b047d45b3dace5cbae92cf46b1e97428653ec23c06f208f1a4ef13cf8aab69e3bbd257e4e27dba671f5e128a4b47c1e876d192209c353f721ce48a55374b98a697036105457ce1e8ff732d5d74b10d1e68235647a86ad785262ecbeac5342b20025229dc4e2735552f37da064f36a573e0913993afbb98938dd4c7473cf71b0384a630c3d4ec85d486b69525095815f4797375f97a045fdefb535c683e5ad08cfe3c47a0b75792b35b6ad427f71e0106e2229a3d83aa9f22ae155bd75f84151f5e24a0c2352dab48a3d577cf0bdeda6d7cb8712e48a1d3e25b677ea3742f15953e39ab5621f869ea1896f6536c472d79b2369e70f98ceff2065cec129d1b389417b2deb536bfb04dcd088d04189d9765182e11e4354930af9a80361d397c6cf92f6d7427f2bff27f8ba94accfaa5e84384e45954d02ddec3a6504ef07a1c45f4268660d2645b258d2734d885acde6e204a8412f7d7fe25a0c3ae57bcaa747e6c8aa9225a71fecde5da8cb98ae17192df28ae7a6db30ba2bb1fa92bc051a1995e8d1c3d98c474af51a6ef010fc9ec1956400d1b6908a5c5dcd5c408d9b3e20807497ca37247f17e1cfdcb7d8e44556b32a898eb0d2782bfbb90d68e41147ba2170536329f531930daaecd543012cc48752177aaec84110dad6809c969a0ab6968e323e658b64538ff43c5af121e4f66399092acf200a25d932ff59a43dcd2da420c5ee72d4f52ec56e1904afdd7a87efe2431635a7ebd7d81ec5cb836eff8d4b22634ebf11d1438f91bee07fb1c30031d8da24c10b1f6b66d48c638d48e67af9887f7e59985698c2c1bfe48ef0281115a153d84c6e21bcff24231662374f7202c00ac6bff57307432222bcde5d86c73597deb83cdfd73bf2f3961308d2f4eb625b46d16b88ab83264a2861f3291a4929636885286d79bf9f45395462169ff6bd53e898f54509b38cf24570c6dd89601a5028cbe528a85639bf8ff0a53995cdbf18bb8fb9d9c9abf96699cdb4e7b067f82b8e34fbb7f095c98ffca8afd10c29b1b217a6d91e8417c1f5fba6725bbe3895db33948763429a69526454262779520cf05ffd78a07fa8a8997174a8d7b2fc34d6b39c6cafed1a6032546b2f1de727b0385932851a133acbf694ec0fc4ec9565958f480b698c81431924924c8075e56a52d00327c80ec2e2193cabcc2810b7bbf0b46e5bf39b1ddf653195a5aefa3ee4081a218e582349bec13c5b46ad910a7d036f0d2c608d9ac8feab9b1ce781818404bfba61f81394d4367bc8bc61157d70ec7d878e63982905418ab0692e4c5f7b3ab76fd588231ed030e1003665fce7c9c2440c421d28381098730341048d10df3dabf079eaa304eace1e3fe012408a8f29a844371f2546350d8787b435ccd2d014aca1c78bc6cbad243829972abe2acdcea7b9a88b50a90f0c9204ca3a3f9b54305e15251d2f4e10ee00105140cae798342b731c20e6cc34bb3318e4204cdc37d1219c52bc53e32e6bf45c1d6ef7bbe8e72ef9c5aedf5f175380a7e0a7b76ee2daf2633ffb1fb5d61a2184904df6de7b932de50e8b09f50879093a76447829c34abad4df71a1b6bdfbee7c3ce553cb49a485c4d6ac23a5dd58e7d27295dfa695d2c26b52db287b55a0c24b4ba11dd5d3c70a1cc147820fcf43e0a5edcdf3f8a95d5611f2d05a92c2c753e9b1d4e381b492f4159e02b9b582f156cddd0ade4a83cd3945c05f9af5a7813e699f4b2d3ed3a8c33c092df3e47aa6b33aad33061fe11a186637994da6042b5ad57ec587a7dae4c7f311ae41a789aad475d94d66b2b48d89dcf86815c12f55871612d5e5f391119c3a0fe91647e95ca93918ef7602eebeb614c00ba73b8fa8575a3ec233e28e9eb1dae384946766867c0821bcbbce92df380d65b80bb84e8b340839c2853cf2e31ae03a2dd2904492a4ddaa77fd94ff68521ef41ed2a4bc89963d1569b187b4ec65d8652d8d8692acb29b0cfcd46828c9aa8ddb0c15a9cd4458c729d650e41ee03a2dd600c59d9556dae2df774cd354a7572c4a7e529cbeea58ad187dadf49556a230abd66318f68a5ea66f6573bc5bbfe396aa53f7fcd6b7ec2c036f33e8cc269c52b1d38b321057a71bcbb4c7caf4ad761bc1cccdac4cdfead22c3be9938267503b49bb89b2963ca8b53a6b8297e9da5bdb6dd2b6acab8defecc79cc8f7d24a3974dc7877658e77a5fc7437b66f46c7d5c48dd79f0faeb1a9e05171b7fee38a7dd837c5ddfa327d9fcdf16e05dee1906dd3759795e9cb402e7cce909c1ed7c791325c2347a8b8f559d7d5707349d769a1869a4bc475b6aa26b95f5a084228d3577e93e9cb3a7c63bfbec9f46415518a76abe227c8ca742389ff1c141fd2b2a712edc4ac4cdfea17fc68eea97832bb595606deca6e3355738d845a276d899f145c637ad73bd98dff7ae2a0be67a18c7d302f2d3ce941b6bdbcbc88ee494d569a0e8fa8eec6777b52f00c2992e12c2cc2dde9687821bd6071fb431851069a961868a8b91de35e2e5b4f0a9e01df96b48e67c4ce69125b13908267f061ded4076ea82dc136431863a4674ae5bb80e82b5031c59cbe7022909997dff42d93d12a2290c9ee00dc0cd856c6ab38d3fa2e0878ed0f190c048ce816f8800b8580b77e93b9eb2e743193e670e640518afde1e6707f78404c11ea6762a445448e4a55ee0cf9012f2f0a50c0010e308001c48861125304f8aa995c3145a0947efa1543692da0ee021953044ae9d4640ca515614a51b9d6cfdc3a2b40a51501b7e4e670b2a29fa1b9d2222287b3b9d4258199cbf67240f44dec6572e9756bfdd3b6573f5dde1a44ad94b224105d19d17d175e5a674d60fa344331c4c1b932af00557eb25d4d32c249dba619c82a98a6699ace9adc80fbc31f62f8128a6086c69a8991f605326603ee0f31fc1c55f0f1509d132287fb0333f363d4f813ac9ad42298a1b9cc7f98b9932581bc3cf19df5f6304d30e7348114dce95369c9b315cfa14e878756470d2d24c12666fa4c8c8c26b1bb5bd6701241f79ecbf4cce384702217c4cb229b9ac47d4575ce654ed932f574df6ff52ad05da7e6e9f5e445b7b0186eaebb035527a33a2250b00ffec13554d00f3815fa1938157a47b121bb56e85486acef3c2fa106d9a5e71f4e08be94b570e9c656b8945a0c844b7dcc39abae4d75cb38c508e1d48c641068157a4a9b5ec80f1f4da2d7c09079c005419dceb52e4ccfd1b44960bfee62fa7152f641698f26d14fed0c593cd38be890517aec331f41cb8e20fc657514015a0d5cc7ac8ecbea704f65ce79aa59f3d59a16a5d6034d7a344ec79a34dd12a71dd1cb534a27ba750ffa48e50fe7b4b07bdcd114fb08d5c9d8200edf11f56a1e47e34c6a524da2f4f5d9da55280d1910da40b67fcb6cd3d849e99be6d1679405f254e8619a690cfd43424fb18bf89029b9747b492e3d1cf2bc30d22dd4693dbd4e4d4e29f54c5804de5c3ae9bbb9f4959a4f85fe69d953a1879ae8a9d09b6893ce3a7f69f31f8fe65e367f63de8b59866c13510ca3306ad679012fe478417331152cb954dd668a1c7ba5300c135d27041704355f313bb56da6c8a5aa3bab88eb54a5aeb345c465ad4d245ae9167a4ba3a7d194de3d7af7281de2d2b7109c10f323ea1555a94af5e9b3e7f24e2f7a2ef0f47f2ef1f44e06b5258863d5dc210f4a2ec24316830484281a31b5a007d388424c13f2a185ea64e4dc290bb91eefd655ef66f77d7242c0fb4ec47bef04702e0e36e03e06dc17c47dcfe43e00dc67d94d64a4b216c6bdf36f9959f408e77c56e0684632f89c17979f2bc3e5e7905cbf1e5f9048111ed2e35ed60ed1c2903dcb86121d7041bc1787bcf7624e6deb89ba392e989979729fd84ddccccc3c396747fdda3dd78e63cd9d5cbb5caf2ebbb3a364a2995a109a967d4b4269c85ae7e160d527cc364e9c7a629ce959b4dbeca94367c85c8c8b111dc62b08974018df45f4e36b8c81a3edb586302699a6254d4c44da857d94c18b57d32d930a215674a4792e289f40d773c13e659f4ea6e863127dbe9160684ca0d893394db2ccc2e920ede3d1324ccbd8c7ebee49e9e3b6acb6a69ad8497ac7b6ce4e770f19dff10238d954dd69c954d9b7d397b6a72aa38c30d65c33b3331dc08b9664d32184104238279c304208219c7114a58c324231c421977a9d46a0915330890b823adc91a7e4cea55eaca9e91ecf051a792ad4df42ec64390423b46f48b432a091e7f26c0bb13513031d136d87ce90bd9f5f0cf509c873a999a7ac8881c5a50e874cf7e1034845f5782a14f55aeb057074700c768e611733a9ed15b9d4331f59e50ae31ecf856b322ac9dd5e1697fa16e3526f0875f7843c15eaa3e995ad4ebde7ac5665555cc08943aa1d911db2fe4549447ee4f832ed443b32329ae071340e9c5ef7112adfc9d82e0136c943f63ee7cbdee31ed5c99833cb442492dd92b8eeeebe1cf05b13d79500c68ddf5c892fa59452da1cf1d0be491619b2bbdd5996adb339e0379e9fe0f9f33a37d9e688b68a79685d57ce4d2a6a0c1940844e15709de8ba3bcb9672d46f73babb140bde75ccc4bc4f1a0ade567dfe5944c8cbbff7ce6326e6591ef1d2da1cf5f3b4d2dcad135a27de794c3c9dc77be76179ccc41db0a110133f644c34f15c98a0a1a1a18979114e27b92625e14cfa906dcee630ce750faa33f143b6b91dd73aba855d66bfbfc88405f8466bd287ccc5af34c93d3a19d3734316930bd1104e854f9dc91eb2cdd9189102c3f770ced7a811b1125ff39f4d7d1238566eb4a51c2578b78a79772716c8eb9889919f1a0a24b449b0c0051c439d92f23c6662a4e5414f599bc31d6aeeba24aa90a7d23a213fe57c2a6e9e873c0fcbc3b91dd30cec6906dcb35b9a5b022679c8a66f434c5f70823a0f4a5178eaee53c678ea4eccf39053ca3f1727ea79cc57ea939eb24e886278501e4578a74e9d1664a8b9eea4151ad75d67053920e16e435cf739499fece49e6bd2fbbddbb19c991a3a4146172f8b5b6badd5a2281af593e607e3ffcb06e09515c02d0c158089dd4401b01f0b00eb9e8ac766189db46bd7ae15acb0768b6aadd5568b1ebe52971b393639363936d5fa5551d70d9753b1b0bc1f2c34301ae5480d75cb54bd4a2dbb5375486aad20842548d1ee18a7b690d8fa130d2bfebaec46e34ea7d1f2cacaca8a5cc12c16cac2ac4c7737cbb402a5bc68c83f4b5978c67c979597646141b2524f69b362e9ee66e996eea9592696ee696261a1c162b195841f4e55732be6ee943912102b9f78c6f4e97d0a22247ab5a294ba8bd2aa02d1ead4c5c235e8998256f56a2e33d50d1942082194333a569e15a5ab57b8465f3e2a5e0d0bd790f45bf56a6efc3b535b5919aa31335fd75ba33159d0b2406dc3a151978f26a14f771faef07b7cb565e1191264a93de1834ea8ddd8e2d6361ad5b23c9c5b2baaaa2aeab22c2bcfd2eaa726312d7b1af5e0a4b3e724bd748ba7b2ac58c896524ae9a5692c5ca3521c1a0e8d998f43a301594633099128cb58b06fd395daadbee1d0ee75eb553b66a75544f5d2559d890987c6c2352a16295fcda558409c5285ac8644f594361dd36af66aa5babb4bcf61dd1485d123161234ce4718db96a8bfc768ab943951e6449913658d3ddd58cf3955c6c6be31927a49cd292fd337cef909e7fc46cd39678cf36c23f5b6a32cc6c738e3678c51d6cc2a227bb4a5f83e96d58f8da00fe89ad70a8e6a8abf2a05e37d9abb549c2ea5c5f864acaf4eb5eb53939f346a8a320b75cbe4b9982d8651ec5b758f700de9b196aae766ca96e267e5395f238561169bf198465f2fe1bcccaaf5ebba6c7579dd3a52bd562ad218638c54468871c80f92758a846e57d2d2ba3e4a2995e9a795b049e97ba04b3ab1293d10fb7cda0f175981507ea319258910c9a244dd234261212917a136acc88d9752f2b425b8527d2845dbce0a60f26c41d28eb0538f171149e9067aa4de4da9ea7c85c9b7950bb2156832993604a2eac330cdddf71e469908fc68d63d1a251bc61378720506af8c5eb172e14bb5ad5c4a29ccf215977abc62e5621486612b37567cc5153ca3c8159f06d9fc6024cea2cfce9a7557df9cf3692549cdf9de8cefdd94e731921bef1a47d5f3ea9ed11161dc79cc3d5807c6c94868b41b23b91047157b8a71be15aaa3cc8bc798df8fe71e71ce0dd25b9667de5aa93a1ef4899e950944d98f87d2fe71eb93ef69dddcc33ad43ad3e8439ac9611e47abedf989ca62769b17cbdb52dffae4272c8eeace3ead4c7b3a97d0273ff1e8e1ff04d79887559502c5a58fd6ca86a3baf3950a14179e9fe02778063cbd9b2c222823b9b1bbbb9b9f704ea5415ed47e40b8755ce6f279153f6ba55af5eaacc167d7ab95ce39674b47cd4967654a62d562947e7b8fdf7bd396e8e51f333b66c7dc4a4ab33bc64e7237c8dd3af190b6e74d6f9a3d379eb302d2f617fde8a7cdae6e9e33b38aa87f9885446631bb351fe33a59cc6e1311f101b9954af9de7befc9091ff7ab43ed7d4e69f110be5bfabaaff4ade273d17359992bcf4e2cbb2d5755256de97d1e5a7093794d6de93d9ecf5c8138cdd9afaab375c49c56e6e153aa533844d36d954de66d0dc5859fd4a51193dda69b792a1211752e8557c62be77465b453934ec2c046ea145267855aa5966559f3b22c4ad9baae43eb0cfa654153c8e51a78e3704056dddabebbbbbb9b7ebea76a62a25b9e8c333afa6eeaf3247237cf77dc86efd04dd38ae6e79942e014d28e7294f51ebfc7eff17bfc1ebfc7efb1c5a798628a233333b3075a5df3de0512cd996522d14f72d3c6d6ac7704d7e8b365091172e555ea7ba07cd7bc3f51762be75c1ecdf6b242bac86e22510d8c5ff6358f40d5428206008f26867d34a314bb89ee0d18769ba2074fec76131bb2b05f1ef72fcac8ad1446dadd3d3d0cfb2c0ff3207f7336cfe5a4b81c0bb3a869514a29a59452b6045fa78d4c4c9c764d9b9999395e1a2b3373f3cacacb8b356796894494d23b1a798675782db9754d4ecd9b2e5a727be7e565658544fa45229b1a7ac578ad57913a7422086fe6cc3291e82791acc9a2afec4be419f1f24eca29e4f24b615b040f4f1a89f3c96c2871a35b26750fd5e6a9d4e2c3acf79e2c83f51e175c43deb2ae495e58cfca64175ce3559627f3489c0b99f93db6cf96ac1765195e5bf2467221bd90d68bf4d1923837de4d69a5945276216f2417f23d89433fa7e71df3c82e7806851e2a2f4b4a0fac26cdad966559f559d985e42274bdd2ea5bfbc81b97853b6597142e0b7c4ce329a595d6bb801b0e87830387c3d970f0bb56b4acec42be3e8ae14ed3651738ac57d5d25092c9bccbd6e329ae5bdc8d8a419b2e08cb6e382afb8feca25ad985bca1288973a9eca24172e8864b2abcb9151b028563a577ef9d53cf7f5a7d6b111412bd6b464723e9c3bc2e59eec15ffd0b5eb7b80696754f697d5ef0e6c250bbb08ff7deb39856dfeb7e481a7a51c2bee3c2aef53d245ce39d21172d6d0936f6076fe235e1cd8defeeee8df6d5dfe8db625c7e2a2d9e73378cf3b9b1270fbf7ddc9cd9f4ae5b7fdf3e13b0e0af3f6d93168376649d1fbf02f35c9800d96d9e844cde7b87dc5262c72c24aafbdefc09d9130bb26d652008e5256937b62c24aa176f621f5bd0c776651141e1925b2fcbd2dcbdaecbc2de2bccf368d4533494c3d044cf34ebafdee83757bac5b554a77ee34dd2c248278293c4aacbebba2e6c9bbfbe4d7b7d5155d7b7fa78c77cbd32b3a8522b032fd49933cbaeeb882a0f7f695beb5c6923136f92dbf578fa94cbcac06bbdfad63a5993ae8b50b46915515fb2ecc6d242a2bab555ae4fd1c774fd621f978cef2fb846a56c7fc133e2a9bb14de5c9652cafe62023500d45063bdfb55dd4d0821105d920de19ca0fcfc24c3b76d094aadebb3db34a3e3c94f0f08a6df711ff5b7756f93a16ca94f29d8ef51946b50b24fa98d3c039ee7a7f7fedee127aef13e515611d79fa557e419f3c15fd78476bb7cafb1e3a59abbad3ded96364f69f5308fe12b16ea96e90ece73ad9555bdb37cbc0c12d2469e5155761423d7909ff8f23719bed4e9ab0c4f94ddf84579fa39e37defef4d37421b79c6342bb676706e75e51b0890cb80ebb4c8c9b93936b7eadc8a91ba05bbdb2a4dc675cfe5130f92daa354422a0ff3a44cb756aadf21733c87b4b2a5ea155ea67abdce5bdf7a2bd6b9f0cc966fe5d2062d8d3301a4096ed7a195ff3c5db9efce3585bdedb6322d66335b6a8b9d5af6b273a26c891e7bc4a2b3327dafd3697339aeaad44ed465c1486f455885444d621d76d25c0ecc8370e6e2ea08960d25982eb163b343a90d256c2c6103f3a866d95882f9d948b6a1848d259ecddbb96c6309e78212ddce8d9bcb8930220d455bc2c689c634547d137a31e13c2efa862fb4f1369488dbb38194cd8d87d82314dd0b8675228b6233fb44300eba732e29f7c08f34f75234e754606822cd3914cd0a7dece6965c07e5e3355919081d7fbad1561978a91c78e797e01ad596a8c74b59c953b6c46c97e01953daedd95cf825780684f444e3188e71391386a6a16827f555279a8b715611f2c6a47ab495c4c99cf37f11908f274368517b79efbd373fedb3598287801ab486eaaa63c69899e185e4b2484c2df2138ca45b26f64bc3ecf604126624d331f313dd62c53be62835772d4dfebd62f05570c9a4e4ed7412bed142cb489a04374612cf4822c0976f51f17d6e59b6da9c4b76cbdae2c7ca2c1a4a32ca6e38aa63f4932ca2343f59eaeebab3d8af63f05ab6749d9a0065f9090b09689f885cd578a8c51810c2d09d8f318220744bf1f4f58134cfabb35be8734b93af22c300e89e3f90e6aa568920ed5611743275a94d6d0bddea52543c11dc7f8c849f58b13abbc29c3a538b43f8c89c9375260fe123131fe1217c44c431d6737933097c8475f888cc3c5acde465f62eb3bfc73a7c8412429f01c9fd755a980188b49b8e2b0fb5f8c8333339de9544c8770e6691982c22a2140fe63d8b88eb9876317f72374277e11f64cd4d47d4fbaa3c41111101e1291bd23806f4f164d6eb890fb2d23cbcef482e8cebb458c3cdad5db17504bc59b74c0babd0ab96c6a734ca5611f49174a389365b251e4513b54afc8926d2d88a003d4c8bb4ec28dae7279ae7261ae8ceb2d131a1c3f46348737385c6cb1059bf5d43cdc23c07e3676e9cecadae2d783ee29bc23361159655c73ec7b0eb309d61d9371010184d4e5044175f8472628279387461d7f99e0c7b523c299e1493a7e5116c460708f41110100602496c4405c8032b9383b42dbb333a3010f611100c34b2c204948140d64d4037b138039d848e594f9126d831cc9a3c115e9e5899be26761bc10cc86eecf9c763b70cb33e0a320a320a320a22bb90145a369bd1615d24fa645d348964f33bae1545a2ec5366d15b728a2815616589b42dbb333a325196890ef344d63d5ae9ba1361229147748fe5c13cbf2eca3c22eb338540d84766a27fa6d004fa605384817272d2cacb8591797e896c36a14c2793c9149a40d3679a98dd5ea8cb5f5ae419565529bbc5d339e374c2940b90f0e1f20caed3420d3ad4e62a7b7daa7f3e9f4ff5cfa7faa7b4e3560e7e3e55755dd54c223f339b62ad5ebdcfe792f968db435ac9fa609f4ff5d0e7a1ea0a1da631cbfac7e43af60df4ab7a8acc747d3e17945f36f4ead7517e7255199cbe5d329a5899be21bb8d6086b37b32bb615745f908cfa86c35817aa9dde0a71df5e564a54d77b7a7adf3118fa7c23cd83dec394c57fca9be65af144eef1a7af560a7af0f81348b89d48f87eb2dcb6e15d3f3113ec247f888a7631fde7bef82d2c4e4105af09649e419cfc48462138a4d2836a1d8e430cf84faa595aa4965627299fca2aeea323953186326c7ce33a35ec913c72106f1873d9c31c6159f5cafb71bf35d87401fbe2c1b6334615a85b6b9fdde7befa395765cceb24358c157d91c0539f53ecfaa2aabaaec302fa3fec9ac2ca3fec9fea1b8faf0abe715f594f8f9565596c2aa8fdd463093d9cdb215351f84675074daedd94cc2a036ec6eabab99032dcbb2ce3956b52cceb12ccbb2a6c9aaa6eb569d769379599c1b13c9344cb3a65b293ae3115166b504c37b5d4d3a51e9289da6191dce4d229452eaa615ce393ae77fcad2fe7f68c54e3c16c824bb2cfaf19c602093cca2a28732d18927f33cfbc75e009fd089282546004e3240010820630056d3ec05100000c418a5c010a19c9884401f4f865d96a2368ab2b72506ebbdf8de93efddb27bce49ca7e9772644589f608c89b2494721bbda845f958db6e4cad572debfddad7dbc29e61575b95a5941565184b25d5c9d8e4902b1fe37c71aa26a7e88c804c37cd382335aa99736e9bb555dddab4d3dd2625575e29491a4717e9faf74edb6e2949a6c72f489051107931c403849275a0942d25948f75ec1631ebd5f58fe6c91c13b12a2b33ddf8884c131fe1237c848fbc19aca118aa93e15c7c6e92da96f5ad264739237411c6cb4ff67db20bba6137ecd449e6a4ddac539b8fed198a1180ca6e2f77fb6d945025cf360fe65c7913bbb1911bb21b34c23817e7cad0419f76e301dcde39171937b9732e0438ca9d7329c061dc3917037c74e75c4807c09d7351b900b4ab68cea99034e7540ca039a752008d009a0c6d009a732a34d66af6767b11800d80dd56006063d88d34b229763b8c13bb65d26e32f186401fdbf3a2a124c36ca52c2b13af7ca5a56a29ea4dd196f897d9271b79c6cbd1baea4839c2a9463574e74eafee46b4cd0df5a699eaa9d4e254e465afaa5274aa8f8054232b4a9647a6e88c80700d792aee163aac3c9e438b3d20bb356466666666b615f4bc5b551c5951bd149d1190917cd53b8f82c05797e90ac05752db463537ba2ce6cc3291e834f2a50504692a7a0fad5292409af7f2b2b24222fd2251c35190471fa722293a232055b5c518d55c8ad1ed2585741439650c1b2ab194524a91ddfef8c44a28e508e7d6f7deabec28c808c8950c318ddea35d5bd36c538a4e671195d018d12d0e833459641195641acf4b69a594a320ef103eca51104ea9ee24f940e33215792ad3776e74725e8cace0dce91b691a05c1d145ba089592e4522c95f0744c8329f25c5e5e565648a4ffbd225de4cac72925c98d1f05e11ad528488a0e458d6a2e9552ca51109e11290c16c01ce86f301a2826d7096b17a5924a2aa9a4dba36207a554bee9bb3e293e94e2c6243f7b554aacda9275aa4abb4d333ae4e994a7534e17a573cae953b7eb74bea24c594a299595a5205ba51d51af9f522291234fa594a1cffaeba297b624dfb4d69005514aa90455b55237b75a1425a594525217a6657f9ae89386726872aacd7fb4ea308fe935a5e0cb96e4add75f405c29b8c6f478b2e702efb1f3b624e9abb4e4ab86843feb67c5d54528da89963d15eb269a7b139b8f508a7aebd53ba7fa641151d15bab9452fe52534e33577f70d059d41fb7625d31106fad9ab5a664a1d40a83a2a09cd45b2214eba2fa030546b5aab3a5faaea1ae3e205cfbe4dbfbf17edc780ba556ebd937bde94daf288e5267c16a5d1e26fbfcb81b8c1f0c639232ba07868d012346c5f5c634b2392976cb60882c4bd3b585ee81a45d920042870ff7e528e124348ce4e86c6ec7ed0c41e3c25c8065a016641e22783e63f880a8f02613a010e80f211316989c7caa38f9c4a3bc8080bc6051018145cb20d231ace8101513a572cf855ff88557483b4c8456906d2f1df8cb4530be906d6e679b2d5b63314563d144da8aa6e2c19051c6944f18b2cded4c266c5e919d9d9d1d6793813354d72d20e09a5b724dca0c10226d0c847b308d119c1b9b259d835f6c08c1a02c6c707ffa30a9f74932a4c87381e767c43c827a99b21092f38a02dc8c68ffe04351649b33f2e8f38820c988b647b819efcfbe7c608d2fa09b1797ac5578850ad214fce31a3152396803ca03a47f16869bf1a89d3da2c27d771f9d6c7337324dd818c1373733f4630a79136fe0cd0d0d7838a10d372419cc822ce00c8921babce3bdd7ec5ebcb6995b430b49b08999e11ddcac04fe64c1c60b1b0e831736d188112336e69c73259b73ce25d9e68c349c18e6b9c8bf1bf15ce2d4a47849e106373827cab83b50b58103b5d908597643348d72908958d0e366a11930b89febb4888318ee969dfd40732bd6f39660222db9a19384910a2fe0bcd8438f1d3b9c010b254062e00fee0a10ee26a2e26ea41fdcedc5077773373db89b335273210fe690e40863f0811a7e78010c7007406c01270a353c74e2202466c60a19c4600d72c8c210a2c08798feca737140164cb8828a9c1a306108317d98e7e2b2480213867421061af0200e31fd249e4b0370e690072c6001061e57c4f46f3c9713242982199450410728d82066016668c10ac0608517841c89699a1ab0a1f298020b7d40430de620071b0401ea8006150f78140951c105e6023f5c4970411772a0c8208410562c8021b0e10311f480033a08d98153bc81055317d04007287ee7c590374494ebb61892852147ac232c794ec417fc0b23a0ebb470c313575eb7c50ad0206326c0096e3e8639b8a49e89a20f3588c3139840042531dd5ce4478c3ba02e60430b824c3d842e4c95138e0061f0890f52204245c1092c48a18ae9c4c4872d64b006eaf270dfdb62055fd09b2d64a0c5c5aedb420660b8db23139c1093c7f3aafb1e1a7e6be59efddea3a6a99d13629a64047ed93a17c47b6bbf273778af708a3312018f609a3bc5799eb2ceca591096005238e9a4df22c7c8fc4967e4182b8cd2cd2b34855ae184fc4acfb175ee21a122a5749a788a16ceaef4add14fd3ca95f255ad1ee35df50d58d6bd95a90bd051d43c45e79dfb085ce8357c6fea8f60e6be379d9a93faa43ea94f869714457d4ed4e690f023988980a31cab505db760539fa51342462744844e08f89c10af9d101d3fd996e2dfe361bad497af5193324608a7e93d7e87dd7756e92398b96da72907b67b4208fbd49b7a85da564d337bf6ebdbbbccfede2fbd57e122c699e57869638c18dba955e62d6db38aa8eeb42e68bdad0850b768ada89de27c73be4f32c6279af46467154c4f359e29cd2eb5f2360601949055eeef2eda8f217bef34de9ce83451ca73b6caf44b736fabcf2c3b3569a23e69f212c6e8966a3759750b94d24ef2512b8114627ea377b3275875eca2ce3cb4e009363195b7d0831076626a7b010b3cecc4d477e30220f888a953d59a13030e919c980a6f728cc4d4a8e343484c95556bfc041688a013536790214284c4545ab5c641a6f0e326a65278d0c3196a626abd830c68626af5052700e126a65a794092b3862038e811533124b44127a6665a0cb1424e4cf564810b3631f553b5e6bcb8998226a6829c165f6c01276687b3f9820b45980d40d440c36f48034d4d4c3da95ae32d7440849d988a52b5e69a015b75793603f85554b5e6eca0879d9a980a0346ca1e84a0849a981dcc6f8b2f906c2949dc9ce634cda9e15ffca4c1c7865372dbd81c86c1e54c935d420c48e6bc1b433127cb4f0069244f0a32f01132b4ce9c93aad7ab463dad3e0b4cd32f7b91ea75bd08774bd7e3294b630ed9e888ebf157a5286de6520d87e8f69f83da4ce5ce030d29e504a6cf1731cddca76def0ddfe3cc7d7de13403998d70b4e69c73e64a6d939fe4ccb52c3ca30ff366203318a4e4ee9b514d93e4a8a649324e31c2a74c2949ea08488ace2808cf98a0803e608f2689609a373759f328c84dd60f2699baba4b5578aa82b7e0f3d139345e562aad52578081c015229c627c36a1132f25949406a9c944f808e49c0b2f2584d7263dd122eb4ffc28a1d40236dc82d4c403d224f98034493eca4ea2fae9956c244f8aa86dccfda2ad502756b0818140b7307c40ac90f5b739ab2cc2806ff0049b98429a24af9c429ac472c736032b1c3bdd542ada6d42f17c5e2bebceb998fcc2ee5c16f26837dee46c5e5e565648a45f14e5e434e6076f6c9a34591a4a3297a3c3c2c833a669c7754d3ad922eb6f2ee746073c70f5c443ce0322815427c34db74e2554f284099d9311c94af5b07aa5dea2d349ba05b6924afe5d1a914664196495a253ed280864db5e344e1b699cf6c2088744312e83d4469450a7510d16190e918c6f1612c5b80cd228c8888a0b3b67cb7a07270bdd8b6e89d148b2ce190599e01458c029eefb2848fdd64fe1ad73ee1b05494972273bc99caa868a846d86847aca66b148b68944a225504de8609ac82df154f6f7eecea8e9188b2615b1e1226cd32d946d4e90c09f70daf8848cde15814bc838068cd38a1bb94811510c1263d1840e915bc233a285d0081769e281de3645951136f2399f8b3cebe122f7c5ccf29b78d9465a42e592385d5a6861861e1701b7623b3144acd396641bcab22454d5215b4a9b4dc88cb879cf72f78aac240fef46ba150908ea43740b5579c0e9e0a828bee421314417c5385320090dd850e2c69350272718418124346043891b57647c8da040121ab0a1c40dd2151941011b3148403c7743e2233ce4c8345d73e2234ca4d6a16e40dc6a52cc7242f0090f323e5b19275d46b790ba25f2890fea542dc39f40218b775d9dd4647cdf7b7ffc77f73ec4fbdf65bc9055ada4ec66f654445374d2da39391bda11093f587eb0fc60f9c192fd6081d60f4a29b590702b8ee507d532c7f2c3ad38961f593896898bba0d7199c66516c9c233e02bbe86442864a2e2d5f4147ca75d99f6fdb83c979fd8677dcfe9a39068cec3d0685c886252cd53ebf3232d0586283bc9e2c287404d1dfc74ab2dd17a59c712cf52ab65b12cb52508a939f9d637ba0846ca484bd1606432226522f8dca3bb65dcd8dda218f7bdf7bae70f961f2c3f587eb0fc6031695018429f8f941f2ba5b41b12d30eac91b2a1e828a69dd0a5168a62da9976604d4781c1f816822de4ce77145d73e79d9bd36e32b0c77bc6ce06c87e3c8f6e240cb66082348f0fbd6452d2504c3b4d82dbb46355d5b403806f5900be4d013cda8dfa27c6e33633d03d02b0ae55b2bf56e918768e2c8c771a31bb85328c3ee512dd3997d14f465a8ae61c0ccd39156a1d907b75cdbd6e62b7ac85dc4b64e35d6d431fd1bdac876828c940f29ecb5eff7c3cf71105d7b82edb51cc40bb73a3e019f1991619098470aebcf08c2078b9a568b32a605437a25ba205e214689715d22f12c5ea155622238ad0b8c7c76e248f15b1c52eadded2a8b3cdebaaaad8f5155fe306c4b672e38b6dd3366dd336f3d166a20e35e93d74abb6b91baa19b96feedc28764e1a060ce0a4653370c22e5dce74cc22e1727c480d2ae16e748b3ccc8e69999439ef6e9a7ea35ba08f2b35c7d3b4d24b4cb6d25f58ad3393929d243ad38d0eae11a8a42d98643dc9d4880000800001011315000030100c07c482e18838d2242da40f1480108ca24c6e5219e86192e49032c6184200c00000008000a0499800d2c3730312345a41b15206bdacb84e2b1f029f9d8e502d16e8f9e56813233a05d7e6f9c8d82ba6c3e017cb304a39141e336b391e3ddd9753d16ac99b135d53d35460e5c9d4d87b49be59f3cf10ed73be8c02e28ca0009158e6ca59f306c35e552500df3a93e1c977f46aa097b1a5348ae8a5e15e4a59949d7195efba0dd2cb502fe35239603ae269b8975ed2594ab2ef2d008884cd6708c21b7349537e83bd1c95ea4ef8508c587121c40d06bda614777b35ece57c29eb573b2c5e39897c65f0be5698e40cf11f4ba729757a4f707b57fe60cc5f42ac8155b70a1bcd4f752e784364612e9dbd2ee8d85b85346723e0c502221ecd1a6545dcc4740916040c75e432cc1fa2a228b470daca363049e2b5eda6fe879a78d3d6a3fbc1f772b2e3fb96440008a3a1e05798919dfc836ec0dbf9099c5f7304ccd142332e09710fbe421ee299b6b2a787e60fe0b62745cd66ded1553cf41f83ead56b0085dc86fccbe95a63f976d03e45f5507290051ea7a0d17d6f510b7137c179850bcf9744392e16f609f4f113e7141b2825be0f6e829c0e67d2815a1fb71f4c3ee57ef1363fec21af9ee9d7a7b6d93a30e144dd6a10435c921a13e479a70816f50b96d948fbfdd0cad29629c63fbb808a064ddbdf5f285252857c0103cf4bee02e3e05b67950c87a2b964cfebb9679fe16ae67807ac185d35eb265023b73ee520530cd95a3631b4bd85714d8561ca9b12607418649635443037306056badf3fc80a1d5e3c3c0078ba0e3d15fd830d039a2fcbbf9e7d065dc1c5f025fbb4045110b3b2e64faf077a995daa30a2f52860410493caf1dcf1a4b24c0f2fd148402567e9d823f9f392cb5db961b7ba388d1db9ca20289d2acb5e88b4ca0a881d2991ae4af7049156f359edf613591c5a28c7bec4d3b288a4d61a952cf63fda3c8104abe4893c2ceb4fc686df7cb84eca5422aee0c8fa1c05d50f2fceab26e40f8b6377951a2cb9e685760ffde5b4acf2fe30e3b506f89273b1dfdb8b2cfc03ce8bca3411943aba21d2045e22d41b7e5aa0722241431ca49a19f0a838fe78f4e4f0bf36fcacb4c416a46d7dfde6f65da9eeda75dceb65207ac21f8f8bfa61fe3b77e0a7493eb84190b88db1c52d340a04e0e25ac283a97f2c1b7da38d628323c35b96800c3baebe1380615ee94a0fc25f33e4b11332a53a01cb821c571da192c18775f599c7ac55dc161352378efe0869e2e10cffa43352cd755a583d4dd4188519a1f0495b647eed4bc186d94c371dfa188a1eb1a270d48c9c74efb4d43c21abfd81c3e981af146730ad2f8cb3bed16782e0f6608bc291bf6e8a58f35953fff4a149032b1aabd3688b405e0e5c3fa4bf3eb96b82f11fdef11189bc4e1331c4feef2b1ef1f467307b6fe095ae9b2755e5699579148032accc1eace3054df08fb56ec6b645ca7969382e45667f8d4372954896f0597ea72e32fe50145e8e18510798543664576976520555ccf44354df9154622a337427fa80c5e87a45350a18341ab2c459d9ddc171639e7d8f68c5d270a4a383210ea2eba3920708022f04a45507e3ce61341110aa9f30bb3707b0574b77bd27ac4c45ebd2c8b61a3a38b619e9b341faf3aaf399c3a9f212d899f9b7e2f534d9add4469b2d4397f9fcc2df99f8d799f5fac7bf69492a66143b80fb9616bd314cba11f48afed0edba3232e68e8d2654e0df4516a7563708b9ebbd10d82c95c8c6fb9498461f3d2788b6c8ad74f0991dece840e90c8ca46a2b7ff8d68d1d677ba7b2a66d72254b86cb1a32085e0569978c770c00683ea85c39c16c55ee0a3515d9205d1235f2e3ba75020a4da072d90618259b4d7a1e890e422efb3347f49c5e8e8239361b2477cd28fdb5f587d166b5266edd8212a32799f223b098268f14b9b7200cb1a85daa48ac8a3a71b9a75bcdd01f440feb3e3782f5ce66033418ff16bac6d312e97451f4747c996334c916b367156090431c4b8c2b2fb195f87f1e6cdc62e9c61122cecea36d525a24918ca0b7343756ba003ed99fafb9fe3cbefef7e92577c8e7a8c85d4733942deaee85588154a31fab1ab585f3c21115af0370eccc6c6fc6e146ebfb2b1f9a5e4737741cf39488af3744a43f4195bd5f81751919f4f66e505253d3e04db13c7ff0d63c163f94ba0517bbb3e38763a508fb4cadb14016e28a617072b3ae29b6a9bccb0f60f24370d93b3a0b6ee37ccbc89e3cafe9d451b4c7e7605930f74fbadc11f612e7d37f5a0db49dce6412738859d31f05f8209661263e7e54025df2030ecee406a058066334f82125c5802d9205d7354af750c9c109bfa4dc64e19751268b37bf527bc1906bfe9bc3d06bf3d8b14bf785554b3e46d68062de684c403f4adb71fe0bd69a27507af91a600a1ec38dccfae80295a8f3bfe4f707e300e7885c37ece307b775ce7f38d6a42e998411f4422ab2b2bd8c39ea86368432b41ef1e6c3b0aa2a6442b76a8afea7ff39ec1c3cb3f81e24c3ee05b46c55850828a1a8e269139d5fcf2d0ee87eadb8cbcaa3e9c67218c33bd048a66c2a3cb318ad97befab4cc05f10ee07f709c54c9f8782aafe31c65ebc5e590c4437cedec9a31d59afcec40f02ccd9f9e29125d747ed2cb669d3d5ba2414e19583b4854aaed797e51e6a543ab7fc63cb80897c30c4961ff42ca5df99d769fb69106937cf32018654bb3d24a3a8e2671fa130fa8d3ea44ee706f2f85d1319f93a5f075510c5d11793b9c88596802c48532cccc51abc5db62f942d97a18f20428fb7dd7fc9b44f85f3e026beae560246c11571579f0cb7da5dece975c8bd20fba98bd6cea45ab3e31a6abf5fd59a4f3fbae4108c0720d99b3e6b399e42d3ac95e2e52eff661b8905a17c150ba6e1f359edc0b2b2ef6e98ce0b7808329e33797f4562ba2cb85f3424afa7a1be43903d96a54700df5880870ccd76b970c9b06ae137ad74e4156fd40b53aae42cf87e9b7b1365d510b5a0b735d151e08ec28ab9c30378235f119eb2437b09e932d4e016ab76908d933da0aec442c204e436a8d48ff3521fa9a2bf3021ca717e0b019ec7fad46b3207bffa64cee6d83064633ebd431ab94adf8b14717dc2086faaf831bb0e6f25c05c811e53d1087f85c97bf250422572a9efe9fae2a2af9b709db20eec9f498f344422a77bb7f2fd0595e966f64609892e1880d675f0a0ba59006d55eb64600bdae4e503ae2a45ca9a196806256def0213130050c4d15e5a8823b9b5bc4509cef0f39c2e74cdfb5a953038f3bff437e456f8119ac619d45af52abfd48fbfc27497c1c2d73feb9c7edba0173ab8e2b47cd9665cda557b0dfacebbc4ea7032f2bf57f69694c91d64d787dfd0991956ee2be1a645e5f0b4b30148b3b01bc406b8551784a18c2efb3dc86af943fa3b40f78e046a6cecf5e0355a4ebfb90fa7b14244316d28f43c3b3ba143123281a61f822a484f79769dcbd1bd6c76e1ac8f4b5d8e2d439528d707f395c1ecc1a7715a6b431a0f6fd89b8aa0285801ac875a99989f3e2e7630c6914e8b082b4233a3636039949dc5c6cb574d3c5847f4590c821897d207a116f7e4f5c14846aa8ff8f186e47bd9a49c3d44c43515eb3f34ddbfa99bf462ed95f17a3496673bd525367fa8b70bf479ebe4b8847c4af3c799001a4304c0eb826607120e46d61bc52f1275161e2cc84fe91f48bb50ee3dee807373d20fa3a6c5a5a4b755fcf8f031d34c5af19905c962426b0f99072ac3fcaffd9b390335e242adac4fe9f60981daa5f3921fb0c8761169d05782e3343b4ab290f4289ea918a6f512f9b020e804f3a64b13b4c64db384924f591d52b773d28ac046a4b81df9d24d3ca3a23cb7499db77b4e339174cbfc628b6b46ece7eda2b026adaae926031f03d30dd64b475fa820c29cebf8f4c75bb0d94a73b0c96f8c40d15247f7491a7be9162c0aade681b0f2675951e43f1e496cca6e8ce236e1eeb535a58fc1075a399e692e36eea60eed8880765871c2b78697a233f7aa17a975df36dcb7c5bab1e905893c32a41dad72b8f09152d65e20bab56584448164c2478015161904c0191d7cced300c98b438b6f5c857c2207e066a3f5fc04fa07aff49c18e77e59248211845faaccea9263f58edfefaa4b511f98d2ac3e502315d39d0d6d67f72ccbca371c88e5f429ca63ec39548e20325d98951df6eae992fa9adc8037347c20c2aecf5dfd0f06a1f653a3fa82e318e7760eef521a67816050212cc15852623b4964d531e1318c4d4411d2468aedea76da63ed7f4a1f7dcd03028917654f9edc46e39a778ebae52991488043cfff9b716e5ae7b0a0218a41fc1d4329bc5f32af06dd2ce15ec3f1c3e6f541139986693891042874d6ad25bf9525e41d2273b1006e84514238141b1074775a74b98abdc71490c0c96f0ce7e8a938a355502dc7c29f206ee7461b7c847a87e4b5b77d77d88d1e0828f312522104725f0f311b662f0c176668966fd7c82d3ac63cb53f82902e16d3a3195e8fe41337e651e58b285ba66ad358dc4ed77a68e2ce34a06b09875abb4be97c3ef01b0e5536b8648f90d6d0081614c4328a988772313eb8ff5612170f15480b0fd826f0723aa141902173dde1128721aa7cf33453a5cfbc6ed941cd8f0b5c5d7410d76ee17a8d5112bd03bef2bb716f59bf27374d171192df29fdc65ae70874c5df4adeb7fa87f625f569c996b84e04faee6c017b8e0d927b7bf127c728aa2a6060755cb5d0e930e4350dc0fc21408da19b7130075f2a5419b86dcebdd1b1382d89b4a943bd46f0640e8d17ab7d0168b277a3d3aaa453fc3aa47c7e31a92de240718a50670e3fb01824386c019a4a04684f448b01de0901da054a557027f3851d17924a53b73edc52ad55493505e017320f83e6e57eb514b2a72cdf470d0e8ee173875194acd0ed91d65770e2172c6312a4cd7d15b20a3eab600bd928077d55aaf086caca49a0dd68a6d5b2d564aa0c38dbdb28815c3402e313f96ac8f40316b28e9d428aad7c7e44807800269b2435f3da5ec446610ae5eb39051838018fb9a7e8ec0a74bb6381171fd99de482c8e8bb5e3edb65d8f157c01e2f2965cd70c164611664a6d01d43afd9b4a1b5469c90645ea739e132281ceb3308508b039ed6e2db4f9e7e97bbd36599010c313f36c18a1bd3518489fe8ae1e28b16e980a8f786260ea37dc95c889fb59f58230482a16d738cd50b009efe79ab0b5fc2212502000e8bad67b3fcdd3926a04ada27444ae69dbc4debeff9758405f25504dc685f2a69b28b6e0050b62e6667c0c114a18acd5e0d830f3493f35ea05fccb27b7cd8332be79d87868df6fe6d6ac5f255f3a69107ccb28143ec2f2213025fb087a74412df4024e4c2fe0901f01148d6d84d96a9d4b03fd8654db33bdb15d77236ebd135b254aa86f529fc3372977d447afaf24377da1134b8a58d8a6a52c69b20f7c2c2182fba4414587e05a7cd21cd26518a018a9f7ea2a78d789abdad06c7b9bcb2a845863b23bf39b82d4ffaf616022fc3ed961f46d62ff0a575f32a915ed9f7705c22b5227ced444d5d1758c7c52f870cb6e65dee78d959aa5aa40d87bb33abf9cbdf601aad9a8336b7e922e0c3dfad325ce257842ccba8f26dab31312ea462abb91594b73595ca7bca129d9958710a7ac3f3fd121a9cb53f69c913c4876fb3f2fe92f17addbe494252198f2fdf09767feb85353ebccb79f67ad39910fc6fbe93e0c7cb73ee5500a3c81db5f208430f95512820f053ac814f2cab2cf7aae262a89db970da58d807d0d5cf5a287cabc1d4b7f3769383c4cddb6a314b69ecc2be9f35d7d305a4bd94b887dfdd121abaa897616f7e5a537461ef11b979c2823349b10db0361c86c0d0ac92ea4489b2ccc7c1522dd42463179151fbeb184ad8263283acebecc87c8f58833c1ede47913be93583a57755fd16edc611a4075f16d029b7af9e4af2550022b33236145d0ecd5aaddd409a5097626aad88a2133bf1f3ef6272979fda28c3ceb9a14919e78d9028b79e444bf07b3f615309a7d4cac2406ca7daacb996461a54f06f959d153cc60c25e46d3d09170276baf4b39d37d9a18f092b8c1ab2f99cfe9dae28c4534d36eb1b953354bc992ef2c4b501ad0512c372a0b89d3382340043118f43e502913c247a3cf02982b2ad82d1876d31edcd3fa09f9905b283119a088f0ac4ba4a5b5fe53bfefc108693d132be8234385feebff6ed6bda88ef6d1a4a4710fb9a6798240d3e33f1b385c20a221ecd9edae3e407547d2181987e22587dc4e1f6a8a4d7cef68dcaf04b0b697fd8a1068bbe667c56d10e9141ee5974215e6a08c1083546377ba5f7228f6b5121e54b7862f9af677897cd92ba8de74677a39f26b6cc83a8479e39f644258a1f808fb8ba7aad54dc90eeaaf9cc9213cd13a6c09f443e83c19bc43e82c197443e83c191c331d30524d2bf03efb7937f4afea8216701096a422c5f4cd105e286bf982bfaf0a454f1755f80653392c82371c7ba7c163418f4616ca4fd7c8d2b5e0b8d5cfab4e83d27389b3651acb6766d21b20530166f91033bf316e71779152568b555c6c4a4d0a6aa75c9cd7dcc8bde3a8c09949d0b95c2849b6c13ed9a560c7f62e04456389952d5576bd5e11ed6609a8bd8f3ebf647e19f1fce29182be444f0dec69fcfa249a98338194d9f2d5f14aa70d6df21b9d74d01a3b1e11c71368282949ac53352cd82d2a43dd679e8694edd19b5b1b77940b9c9d0bb321b8ecc01a3768b365d814848465def84783350d6ec3a1073279a687e3a01a63e6933206489a3bfb9ec7326d28dbe684ada197e82d452a984ae58ca7eae62510f0508735743adafe18d4077144cfd6957f9176ff49d8023fcdfc2b28b14cede2c456cb06787f55ec16d74c3876cac91c13bab853545e13781d1fa4130e689905739b0becc649365f083e5cbe9bd255bc3ed4b005b17ff569d6ba7dada8bd8cc6ba005737e80f5df14c4a282d7757648a3b07e40af85c732cf4b3ab5b4a2ee2d5c46c74e06bddb50dfcf5be7de0133dc7e565b21d68e8e23560f59ceed05acec5735a5950adc4ecdfabb0b2b1d1f468aed0427ce672d3e0a5c6ae31c1329ca09e4e4e6b0c50ca2135a1f30e2d5083b96c20d74d77755e20cdb04b62fdc48ae20cd2bf7307ed21f7bdf0e9602ded2cc6899dcf376b526c40e159f60ad2109f435256876f564766bb38ac6dc0446e6fc5cf83e2ff6918286461c95aa67e7dabf5ba979ddfd96338af4e739c29a2be051a7b05991e25049c9c7d155318e9c421fcec1fac42d5f971767e8f6cc39fcbe5b00620136ef80f94511af7751eb228d2e00202856f4d2913df71c2abf2b02cbabaebbe4108a4da91f1ac506d9728768ff47c0a59a735c1afab2b85b4d6ffeb4d96eb6de8349c4848a83ee7a0eeda83c12f9a0e51a6d5955295552e0688c3e5655502162c54bcb685f156777a7f095f5b0ed9a5aba2e4966ec49b6ed9329c7dd1bd33adefc20ebb6d174d9ed86126aca5162e8861ea7f21b43a53cd64c12935286c1a6d3a0edf584b278e91165c2af27c4d5cfe13247cef088fa19ebb9b50ed04c225fddc2bafa4012e7a1e30530cd95ca51d52f6513d54ee1838a5069839b2625d84043f5649f3a6af7d8def5442e3f22a6f41c1d776ce8f259e206ae69d5327c537abd30eb971eb7479f3e754f42b0b31c2710e382856b6af1c9987e3caa24a75a08d8af8799ad2882e0931abde72cd90bf8f0d4eddb138e6ca4c0de55121e1da4eae8bb616ae1ad94dc3a00de1989e995d837d5d67b839b6a0bc13384460bd7c06b0a3eaa00030fa81d8d27b4d2b617068aa1291a557f7750b6e626459caec50c25ba8b9c96f5beecc4a30bd570029621e0bb26f52245b513efc320b1ede1ac634f2ae668b9a175cde54ebbe1209ddffe70ff52d1f9cb14290b645f21799ade1c7a018eebf2e330562a6726949a215d2a532bbf5b918b52ab648cce52337f403998e82438cd2040e92dc85f363d977e8dcf2c958b263bee7dd0fe6b3cd9728c423e79388aa498be4665a7256f2bb8323143ff55532a6e9073900daea1255a6ec75a12a3a072d8bb05b311dfccb10859eda8be5868e18340c3c3846dc6cce73215a131b95602d3c3a1a7fcdd0d9129a8a396657908bff311b4d940e36e603b18eae4733e61430aff35ce431e5000456d0da32073dbd3a5c5b9a402b9a515d99291b1843edc6cc49c9e8e6cd232b8242361dd65002f0941254297863bd19a8cf32e2035559444a3dd0838f8c6585f31eb0f67fd5cc9c0f7bdc0f264bda06ffa52e00c5345309fbc5065e26b3fe190a74f106886807dca3963c0d84da793e31d630c16cdbf49b53495f996dd68e5e5d11f2027b73ae3dc8cdd33b191786b9dd4b84e4471eb4fcae60b347a0ad9ff1ba45e3e02ba8301a445724e772d51e7d5459d2538650ae414561f0a6d1f8e5eaf03ef2bad5ab0d8566e45287f81fcd9fc78c065a27a8a05000224e2dea7515e42cd053402c2fa2ed74762cc48e02b2568f24ac15ab297f4a0f5fbb2580507678b903f571e2315b450626fe4f28795c2143739e7c61a54cdc714a9a82d5f4187ff3154612a522ca7bbcd2649d92723d1141d2ab115ea2f4492ac6210e05100d510c05a18507f983ffa91c8bbd63e898d70e87d5f7f97f90c44a345339f319d56df9611eb4e7e915c893a88af4295817fe6db3c8d33f4c327dacc2c08b8ec1b9cbd3c8ed079cf6388aa815d269dc144770194a4ac0f91a2eeb59ae1caad7033151ce527bc4ac6a28834283ed82dd8fcbcc656121bbcb6e1b5aeb92188ca9adb400ca769b23485c65545ed95a55bb81561d316c1eb9f6cc5315e935defe7ae12dc33fa1495d6c01cd52bfd77c78fc681b67613be429ce6d53116922bc3d0234328b792563a74b2a614fb2421f43f3c5ffa356963199ef295415cbdf9a2811d60e93c105ed23dd070420e4b6e667409a3184532b622d27ac28498080e418835a30b5479b8fb0de499b1fc80e3f42e4b54d0bf3fd1851ec1fe92ead42d50c6ab54e781de310568ed41399df2d478643c5aa11249371596d77a86b31124ac6c944dd0a9145cd2b67ec0cfdf8e3b69a7bfdcc66512ddb7e657df1683888331d44e65ab17fddafaf5cfbb3e0362cce8bc66dfbcab67eba0536e88d5a0abdb266d2347b029cfc273afb498cf8954bd3f210acbedaf9a21ebdf72103b52a7b7102504d52dd0d20cf7944082bca52a74ff4b55907c48927b79e1e5f38d70b9de48bf0181ec28ac1b95139a3cd13dc57faaacd3c18eb45598612ae8e36153699b1b528ac8c5665b3e397c84137afbf5b479dc22d6ae84770f1b67c6c3262596178cb709cc26667f1d2caac1608772b6930cd23c3e800e084f019ddbb0d8de12532b1bc08406077a32bc451f22406e59fb055cf7dc0a16861d9dc680db19d93ac1ac0d1c74272821a1a6a53cad80c6c8e223f45b2f1e09ea79bc24b2ba4b56c8a7ea8213e341884445b15c6bfcf7e8166684a94f80b0ebdb59dae8faa5222aa6812877da3c7f4790375901c5ed0d1b152f42422e581ee58ca20c0ffddcb60c7b3795d5c989e6c647983237cddfca4fbd6f5c94fe79ac2633d15c057018713766cc4e3dc64048fe79894a30b3c0221f92d95477994c32ab724a9e1c66fa68e73433a2a89e1d08c712d56da68ff1512b5e5a36dd0c2414dbb39750751c7ab3b59902dfdde7664544d0fdb8d02d002d4917b4c39a0ff0301b600f2e0d501ec6111a7be9a7ec61bfbd5af0b8a9e9e28ac8c3d508d174a21b74f80f24708a9ce52aa104caa2e4fa38827c09908589d607e2928d8716b9675f6ff2efa00eeb1ce04719a4e7d834dd37edc8709f84aecdfe374250a82d3b488273a633f390a38a0c51f1e7d5d515b04d8095d866b8ef06e96691cd690a6825ae92dcfdda05cd5354d49f2a01c6ea20e0f28dd50b4c118fb1cf2957e00608d7ea0839ba8c27fef304fb29f36ca40695c98defae48e8ae7467566a2233fab24ad5df834bae363d6bce1b4639b3abe7e984a9a687dcc63a7987ac4d0506a516f41b2cd84bbe7c66d942f650e936242f191d79ba72cab6c7e970524c73d63ee116fad4d8b1f8658c3c48871bbbaec31d1e4059be678d3f4c8b40ef9d0e3e17776068636b7a39dbec899ced2a8773a28e91210b236b4f2be6c5368a730c016eb8cf649561b694aa72bf5f58ae1c63c798027938e3dab525819e7f44c609e1c5fe0a32f6069ce9982c973e5224f921f25388760d4ca0d8ce0386266351ca0e3c4222db7e72ea55638ad22c74a57d53ce6ba3a5f5e1a46005932785d0851ea1a6f1e537d145eaa609d0ca03530981532fd0a04a6b4309b85281156c6e700e536682fb7daa26e40533394de5fb501527aa918671ce1e3a1227b975064bf41ee59a31bcdbc37082012d470e5ebf79d9586f6a2274acf5bf8b24ce15e78395740a66f87024500d82048beeb7e720f354cbcf8941be0cc2c609d510e0ad3157120ca590ebaa437218e8dc088c4a431911caf014226ed4ee2ae1836329a9c0905cf736a96e72532009a9e612dea2f3a501a9c2064d6e1ed02464a7382bea98ad208a8193a2360aa30fadb820fc416fcff7f4782dca64ce1ea177968d1c20d0276ee573dd98f8e2528b313efb26a0c05f7df49b4229ce9dca97766166abbc567ca1ff8c73a75c54dcc3f231ca8eb99049fedb3a21a9d00ca4dc0fac401105520cf6c3364a5e223e46f7343e8e27f8f8016607185a54d8e957af3a3732c018026fb0522dbd01913cef0f0c9cd6e0a53fb63e2417420d97210f664d205e212860b38e7c8d58a8bda31226d781812307822ed8546bdb7870333d9c2383a7d624b704f3ebac798e364dd5cfed960d770fd34088628fef15362ed32bfe6dbf53d62052300c9ab35b1d73fd6aa19888d212f6aa1012eef5624e31c69c387c6be3154fe218c5903586961eeaa296f170b295e23317a1503d4adfcf20348f2317c32469765476976644e05e2a9b63be363aeda872c73205c90b7a8d312dd8fa2439ad0c4c04c77239dfbbb5fa6f311327c6d241dbbd428bc707c72e41f77ad2907c2351fd02f47029f6eba31e737d182f8f46fee73aa2f7db0e6d130745d3dcc2576e6c8bd9c37eff853a285e36d41ec7dc7f7964311f80cebcb5266db0a48a9bf2e7632aecdc86e6a04124e890d03647c9b029fb3cf4a5fcffd2e4fd379a34bcc5e2cc52f392ea8a7620acd8f4c548ed52e5d9bbf4ab4794117c60c38a30022fe932861f62a3cc432d0cea07f8c5e2524a84d37a232e870a81cc3522f29df0b94de6c83547a34f7182069419fcc6e8c5b0718dba8d8e1eecba729f4b29b58d198854d8db401cfea8905fb30883efab5863cd17430d61c3807cf4e03cd75f5cc39705436e1139a0509401349ef7e2a3560a585d8e0fde8733fc16dd98163e834cf2b4e34f151dad2f09e25fcff4439469ae678e730f2c6402762e4d184804b07c88d7df017e47957423064aef54ce6a30d2577917cca79c116997f237c82e34c1c91f152cb25e6cd8dc38fed27922ef985ac604065c5ae5bd2dbbb0513ae2b6c80f001d71ab882d24e294f55abd4b4c4fd31c8960b97cf4226d1531baa897cc01584aabbb7a85c5ec55703922db3fdd7f5dae9480501d8b66ddf6c81bb8e81be69387c1c85d61221685b82db91822d8e8532b2c77bb4bad02760bca09a9ea341e8699b22c8d1986bf1813ee90c1029613c5bc3462e42a47102a7ebe14f4100c7815f4aa70290e683a88d9f4c1040ce706487ffdfa86210373d926256ccb3cc506d44b9bfaf77d0a81ec20f87c744691588ee7ef1c42f3bd44c755d4661369b6c45f7c2cf8812bca8e69aa0d7d3f817efe793e07bf904109af190f093bfffeaba66b6f0f3b51867ed1af86f649b7eec5fd7861e1acb9660b422d91bdad796afeb441837f9d7182c8b670c4b546031591220706ca905003592156d8afa63f8c1dc1fac676ba257bd55bd3212643bb95a1162f9143c9c436be3701ab6d8bc496e0fbb9dc94828c5885e8d045aeb3884cd08a1ef822224387d02a8960d33eb872668ff53e340d99ba243ebf8db5726dfa52f3b9521d1451daeaa2cef858c1a27b5c092c2f22ef74091d58ec1ffa1968b316d5b597cf909e5a5c9b1d9eab2aaae491ad87cbeabbabe42eeaef7a48a3762abe8f13d63867405ae6ff25d6f6ef0dd729be01391a8b52f16cdacd4a5d24e9f798a5db48eae76435583b5d7e44bee70b68eaa78631fb0cdf66e21e510721bf7918d8b85c944c4746b6b4688cda0da913201f1302df90623809ec4d2e64fd50d71124f4a04e420da47b44a02ed2e1d723c0f9c7a960426cbe15662b15219f88ef463b5359f0394580d1ad666442bcc4c69d3fad2939eae3bd6ec245157118d53c6c845caac80d328412355e1c33bb8f66e4b7dfb549773cb76a260f36505222af4d58cb58b3ac47295096a29d644526b538c819a148cf6464c5d3d54e2209e5b4b688f62a8fb3a0b3922e1d3b945a5eedb3369d76d731f536107d0402f9d5f60d11ae067bd0a6df04ed9f8f8d216cd290a7b23f43e2d6524f4d17e94f7bedf803c2497fa202ddfd76b2271e9ef3b791ba4a014330465f6d9be68b70560a3c4a5c7a19d45f8c2782d61a5cdfd738eb4fa202ef37737d0c1ec1ac51afbe203940c978aba6dec1832918074ac7289bec5573ab937697f42af6cf25065fc532d983f61034dcdc45b5543cf1345f472090e212ba49f2e82ffc54f442d2629f02eef88b44c48bf18702dd69fbc61621fea404615f888584f6f007afda443d564245029d55c8ec31f9409fad5a27c2c54e8666bf571209f3f532becabe16b7ca0fb34f48ef9c36ab7d5ca3a1ef4eb5abdbf41da1351d1b39b7d3f16807995a501eda3bf6b110a5bec5739615df0078663d3e53a73efec50a1519f015b315be005f9ae2474be305a4bb1d2eef89c83c4280d5b7aa87eff4c36459684c37a1bd4a66659a5da343dd9cd9dda9507b917c3b11ed9c4411d299675e9b27134570a92b9b68ebac8c3fa0f8f166dc68193da21f3780464fd6267b634982ca6da1513fe03021b4c6eb1237235489af974a600430d3706a45c3b0e34199961d209e5442c85ac62802b516d9734571ac34c5d6afc40db8a7b88f156c329647d4d0ea01ad1d4b166cdbc04fb8de59e43e4f25577c05b6fbd28cefcaef16dab5645fe08ac572f7068ad2359fc9c3bb51886b640782344e7921bad8f9922001cf0a751fe15f7caa441948b870e2ce9fd6d6c803ff7892bffabb0c0f48854287916cbb0ae71890aceb0d73cf0b1a03af6ce96363e9ec46959a53869cb954d2fc5d068a90359cfd7fdc86c278b1d574657e0ca4685661fa81d58744301358e60c3a228626c4ac8894569892d2a8f1c71cde57a94b2a8a88cb9a2c06822539e1aad35d062096f816e3384b92b5f5433af902a2bfd7f97b02c7733c8f8f8af1e5f8d773326fc20d775ce34e9047c4915a725607157aff08f514d1184ce6928abb6b0d39fb6b569d1391fb68c83ecab34a7ebb76438db59d2ff6e567a48af888f60c27b70c4067b20f75bc7a07b5cbd1655a768de92ee5b2f5476bdd815a9736158c7c757bf4618d1d18d2efc32fda7f3d083354ccef84b7a4d1c457e9c5e9ff01fc0c2e7cab690277c5cc5e72d4ba03bae321472a89d2c54ae3cda7195a51b6168718c23ee689d4cef1d765eae266bf5426386a6af8486e9ed0b79bd66577de2b69bcf3a6b7ba12fd672773a6b6986d7fed0724e3862ce34c2ff2239903a2498ebe2e652b172a2e8a6314608ab7d5ea9137fa3223efbe7c04a4f23f0cd36a6f0529952c25951c458a83ba0b9de9f4b178258286bca029108e013362bf2312ecaa5b12a5a5c3b6a1f1f774d3dd4e54072f2f65d0e5945ff792e05173e191624b230da7a20aaaa514f8e0df5c213766980d38ed5102568916a877417dd5041c950fc5c88ee898473a10a0a342f74fa4e832326caa2a8f16a200dabd671098a36a9091d5f269ea23c23cd26702cfeab76dd86335730682f54d146dfde1c2ae92cd4863e4301edc51afa9e8d7190e5fbca1580053e714542b7248f632153d4954d3aa1c597c923b4252aa841bc45d124dc4c8d54bb48e89f3d48c649d31a1a988146fa72f4cbd7253f081336d624b14fc2b62b9cde8696bf36d480e1cf62a30424946c06aa51d93d0953aaaf543db15766020e4888014e6aed9eb87084cf80596cd3aeaaa910baf60ff55cb086c1a1a5ee91961627cc45889c3990fa842c6c08c76dcb2b9115bf0dd4c34f420ef6d927f971df43817d7dfaa2a75679756ab9a990e22f7054d1915b6ace483c12ae09b4e09964cb7724e92c928c988ceb063b1c6da6ca599e3aa1c064a6f00d6c3f39d6837e5b787400ed8fae4067552115681e3ed505d4c7fec01b0cc4aac186c962d010ba1a5c972e7c57430a228a4487497f6759152bcac87570e4644657bb559898d272fb04c9cd314c8700ad6c4917290cb58d34ba989896b5164291dba324f5af2339d7d9b825f4748446e6680f0db4e3a7d83f3175ee6a077c94801272c3452e7c679b2bc9e28a87560ed884f349675409aec70d5c53fec3f980bba6dc8e681d8d05b8c42ccae51a204e7b7cd8cf38542abe43fcd733cbc172a0473edf11aebf7be106b8c0f9e5bf52f14ff80f83a164a677c2cfb016ac30ae28eb4fc8a7a5b2401a50ac882b223f300e0b22f5fed4d99b887805e581814265d7e730bf1e57f41d3865bf842b4ae80632e004b1b8a21bde42c776efe64be3ac68d5aa043283e1390b21aa759d57d89e817e7454f95ed76bebbad9426114963eb162c92344b3041bf729bdbdcacac07e714d16b775d8839cb432bd9541e6873ee7236e47ee27bf6dd0c43cd01b40703b0b03bb243323aa34df40d213a0c3fa8caf5fbb6d3d04bec6e5ed2f1b2754e5be961b5e98c658fdea053561f7358a5367fc9f73f93161d0d49807b20100dca7da6ddde64a9e0f15e92b523f687a8745b8f11ece51d37dbd11a094008ef235c8326c7bf09e262759ce755f7936878ed6b82fa57367a53e243977509a0602b59b14786bd0f2ee2b1c909cd7bbf1f597e9fd55a8d5b6d87f07b8602006c55dc2cb3c3c03c1ada255117dadf5064f43401ece3c8c2eb69684aaf34914793ee5dbe7bf3a5875349daa6264b55f9e3f88ccfe567b68d3220942e3e3d54327fbc9329de1bde43c4f4fda2f5045f51ae7528ea79fc7be871c32a01da368e929bf31b7756ca174b7203fffbdc1cc0fa5eb7ff71f066530c5b8154af1960e66db0514d0cc0734bc5e7ff0d94ce19b97f4441d793e9eb496f480c4b29d7d2e4efb862c5ef4d877e6795e77cc39e6314a42e160ef51d3f16e90f75a9648c8a4e075135e78eb9de38db2fbff5cd203ffd4ae2304fd3777117fd4154d618579dfd2955f5c88beae3f5c26b892f6bdfd811c974c7210b4dc83260a5d4fea4566b5d6371b1fc2fea5a15c801a16fdf275e17014ba65113c77d79f7ca0ec170507da136006220a24dbc23949bd644c8a1b7d26fd40c507a0a328d8454b55596046ed3305bfc22f81ed4bc3cd88fe8b0c00265f7d2d83979bba4f33be987f2af6e6d2201521a06d3e805e1c7147237b309d9eb7ac0e9e93f0b833146d6798f3c8f2c5ec742b43a2413de78b9051f8aa22b1608f247d979663670a3e2ca54d187ece2734413d79c79e2e74bdaa9dfedfe2b9304bf46d5d3830a99edb9f9ef76a086cb06816d66abbe79bf711dff5bdb72d2fd4dd7dc2de0fe88b06dcbfb614d035904d50cc3ad799f7ddde0a75c7e081c8165c29b608d816840a5ff49e66aeb68a6f482b429358a8e00ead8364a78a441074e3183a9da92466674210cf93093c7ae62a175530abe7337c0cc21b152b199ff471071dbc1fe31d150089ff7338206fd9954711fcdfaeffdb37242fa757fbb192430e1559069b8f39dcab3945eb75b5cafc46c88fdb865366efe5fa516581bdf7301817f3f55e68c47ffa60a4ab336aa57e114bfb83d2e6fbddc5a1d9dc9e67f16a2fa66886cfb6a1b5ebb5ae8abd8a1e6824b08b3a98f9e9f8f2c2c20c8264f0a24334cf3380909082e4e9df7df4f387f4137cad1aefa28da7f78bcfe3964005225450bc522464aa646cb295ec863c1b06645cf590de5b344612639d96b73c30250e6ad691eb214b07b5859f253456c9fe757bc9f38b6d63a7d5341774dffc1d004359e88987ece05989ee9ec2b33dbd732a7ad35a267fecec16de07d321e16241ded0ba67d34b99a11bcafc577cb49ecc3d241f57eff58ee8059e57afeecfd766232a2c18cb06cf22d5323ad3708c77bc7fcabaeaf94a2ab3ef4f58d7626dd513931f69379479b74f081543ffbed38db4a61bca6c9c1cab30e5e6c07833f8067b3c92e216c23318d7cf677662da646b1ec91e9459d7367c03a59ca7f5abf317cdb67840fbb78ae39ea6920d49aa93449568a431686c9c8028ce29489ef977c7b90fd78fc58f09b7403f4c0430075998a41b7aa7d18dd335c3ca0a47d74f109bb9524aab6a57cc019ccc563bdbdc5d00ca097cda449f2e92f0459271939484aee83fd1d51f6a7519fc03945818aaf835a1ab726faed994b6b223a8341ef1d09085513872a2055b86d2eb9d20e986cc9a2724309838967271942bc78c68c6fcdb55953fd9da2e6c97d3791d3c1942967fd82424b6f3fd4a8db88c4f948f385fcc69934d1a195091a518b0c7e8fb35c60ced3fcc545edc9929c1a8ca165f59cfffd509ca85ee81d6aa3ecfda056b69b9defd0a19795dfd83c0498831763c29c8316912a55e45495cfd1d2118a2b6efc117b744ee1f29711a1c754660e570429c1829a5f8869344634a9d6b05b6c9644b61aa8e94985ea5ef59ef5a67b54f60a4c450b850a1b22391df37626ba5c8e2c0f2e9ffa14055513b47266fcbc83b94153b366864662646f9068d32575fdd73bf699ae90a7b20723672180492b2ea3525861ca0e6014cf98a8c9040a470aece911cf3192737d042ec851c9665b7f8bcd830040162c594b354234f1a1604ddf8c3105712f4703310f4bf5efed90af739c85e4bb8f55328f4cef5f9fc3bd2c11b6a751bdc96705af171f228c473e2bed244103ebc02682c633b3188389cf8b8896f0c847b2e3e460dc3aa4ca80f52812517fd9375231178dc73c78a44ba8873b038d030154c9faaecebd50f1da10f1eb7f69729554025e88dfe9c1cbd137ca9e1ea4aba164863ae4b34dce136292abb78c072ad94a57dc5beed0dd8d6401f7b527722b7175316165f47b75c0b072f16ccd768e90c8c45278e3a91000192abcffb4d21e8189852f8a3f949282b618cb34ad5253d7342799692c3daa5ad070bc006508fe1af4b74ae7bdeb856141f93e514cabc3c834c5ca1b8755e0b7d5ce1c6ad6b07df4c2a0e8982fe91c5c2a67643c3c3dd2549a573bc14c6b22f87631dc01d4d3a049bb68de86f5a04339d5a7c9b8ccd68c7013629a2f850cecfeecdda5f4ea36449785c0c2a5bf95b437e873a5ee7fe6eba6436eca1ae50c1b03f47d49325d2dc40efe8592cddb7b3e1b45e3026aed7aaf5e48da524b0ecc9ae23bdaf29edb767f5a26a331bbff04ddb492f8a64e2a83836d9ce136910aa436c85b94161d95e43e1658323f45ee2229960d7e7dbcdb3c42ca206850f93c62a62295a7c638900b107c37de0811c8840042eb0a412ebf9ddcd37589a3303a31c373e45d79aea6dc1f39aa54dea88066f3fc6dd96fdbfb359b780441d6cc55042f562ca2bfae51fc854271595351e4b8f33ff5676e362a6125ae6948933698b9b1a720353fa6efb4b1b62b3edf9da12240a9a401b47de63744d0c05f070c83f0246c98b92ba58facce6bdc873f1e23817988da1232887cb26115f65fdf03f32a551faae98d1beb2bcff64390b57d82b671887820715b043cf87728889ea8040e0cbc17f8e1f03d6c2eac5d8c1de7ef8d98e645d383be6c835f03bb300d58f102d629c47a85f8777999ce2c34da9fbeefd3659993b93fca6d8013323d4b37ef0934e7a53bed3251e78b36af1fc4d48fe3b09f6747c1cb5d60336e998aa2fc593a0a9041593b79d419f394d8eaeb4cc6981c2c7d80660134120b7091decfa710bc3ba99cb92b8f0a090e39aedfbdfd6ddef42ac24c5027b50a1c4a8c2720a8e51ef90518832ed4de913b6375c3306b80a7c065e1844f8faecb5ea5f55ff1e08977741f0e9e2fde7be3c0108e5afa93a3c70ad72163d4ea97027c3ff2aea2f120837f41f616b48473b79df8cdd0eb8892adc2f1b17f37980e326e1ddd21085693bde25b9a3ddedc0c0551af368b0b88f98893468708738500c1b15f5ace015796b38cba948e7f533bf719c3ae414f95c39a3841e5430f93524c3e38f2996fbe93ade8dee9fefe89b8e1e2576d135137f33e5d669ee9a56b9c61e05e97e61da3db18ae7bdf239fa96c8b4e114b97f02f430d02f87ff370f51fb3890ce9ffc9a58242d990a93e9584d2e98e2d9a473ea70b91fe43818552c6c2cc5c1a2b02ea354b27cf2f990ab36b0da8b51076e7c3b1639c7e81852c255b705b96df329941dc49ab8fd475f2549125ed27d70f306edd9a4eff8b79109506d9ba3709bea94fd03fa4b7924dfe3399aa09bc7342eae1109cbb5bbe4002ce11e2b38fad73f2abc6c86a7c521a1ee8cea929789d39ef76624e300ccbf422325fe99b69efb38c3fd420881c02eb3e4d43d3ccd6814721fbfdcd914a02f2de106320e7ada640e9668a54b5e32480f1a9da13411272aafcf202d6f3c96578c111cd4acc894319b27b94ae244d70ac21740f12432251071ffde208ba19e4986e01066f70ea7f67d8c8cc78c34f0378884362379fd124ce5d979152fc22b2cf4aa630d5bec3020204574dc975f7a1df3fbd243b0e934c6e535231434304ac4a291f5a2f4e725b0648b40ba8d9843cbd87c4f471980dcd35b18bf4e09c9e21852be7de289303183e7575f38444f058ecc4cc6a491cbb3bc0c2b875da9c8c05d66ddb09e4c2d8b5cf6efb1dd3dfef0768ebed33a9c4bc832b2239d0f10062cda84041b8882da16a23d1237cd4f70288638cd85330e97aaa90800b84f05eda706f012cc442f3dc3beaf8088b1f3145ab54c3f9a9558b23bd2f1ea4883bb64e8ee5f38cd25f566ff570988b7fedcf25c69701b1f48c7d96c2518754996f0fee2ea6f9971363fcf3cb7378add722801b5fb731e0a197e04203720dff274eb5ae75a8b91be936d5c2e0d1d78acc6c16dca9174097a85ec3108a03f1034f1aa45e0022651d678d0cd18a04a84d43d068ee2566f452325662d274c2e67900a85ecc0476f1f052f9fb2913a393f3f2c0a6118939084c9b9936134881acf77de67f3cc4b41210d4c984aaa7c0b5384c8ed97d9e61be5ad2df0e889c072f84ce64a5b875e32a7ee0403d843dd2f56613555f9919d3078cbad61f059770655b5644dfe3c05bbaab56b21c2a20bd15dc85fa56e6517bd343097f6bef4bf8e710adeeef020051eeeba7c10983d8e82d474774b052cc0484504a1a831a1a9888c3f7128251b95363f4b4c07d5a7e89ee555e1bf2b1c4e9c9b030715e849369e8c3956d9c654779ac06f07c1ec3879fc76a401a7f8aead108521dea63a252fc0a453387c2b2e8a5d9c267c538ace8fb66dfa9b21c6dcfce0f9cad69f2f56c2e15c35ada0937078fa86d689bf132f599c3ca34e4256875ce3745cc8bc7434581f9e66683e999369f5c75930980e367d99dc0340184c6771f4d0e5a3f9c7fa2d382716d2298c3e6029208c50b3e73b32dd4a0af8dc71ae9e85fa03c8ec81c56cf369eeb60faf7f9c04f8a053511dc943332018372729fd368840b925e73777a7f177018ae09ca095ac19eb84cc52153fb4a61384cc11059f62a2728a827c5ce390b280cce72ced14df6eb3bf2edd9892b42a384dab92a9e47f84ada74a2588d73a0e0d645885a81a08881bc6da7b89c48a16f042e18b07c12069ac97be7bd49740a5e61e918843d7ccdb41b41073670b798a61e7ec5126b60bf443b768dec77cea7f0ee89f921f4e20807f58037d0a9bacda27c10c385889bac0a0838a6ee245f69be64b956a368963d4ee034bae244579a5023b7f34a1c9eb63416204ea38a52d240a0d89d6e9ecfe38661209181a88109daf73e3e0d1107921c9f235e0c34f12db0134e090bb0b7c3f579e3e05caf931f31d3ce2b905ecb39131737f3facf5b26f4fe7e6b8c04c84a014864cac690f9189fcfd25db6f85b133717b483263b4d36e59f34b3a3d9103922c5cea5349db183e881c3ba97d0e5091b27a9eea32c62ff8bde0d526c633fd08dfe2a581d9f764ea896c77acdf4e0790d942b9aa8993ddb8e923e2d6f5c4109361aa00579472ddada7bb82390c0b8eb651ff5b1bd2604fdfe5acb6c4767ed8e057c01f34ae6772e8e8b23fab3cfc661474624fe477f4960cfeb884fa353983725b2b2b4e94af1a2c939f8f24ab8ee7ff36adcaf33b46eaeb29427c57c49ee3431a027b635433ee893538a2054db5641063858146a0f7f1ef039f70c0ecff47e31ffc53da337a302aec793ec52a2c510cbd57f2521645fb87a4fde6ec2af2958d13d462747a9a5a86fa9fa0b99fef00f829820fb3a38f2a23c4e38a468be9683ea87429b9abadc38c4427cbeff6b5ce6db791fb633f888a2ce1501360d121a3529f1e5e54070a837c9ca44efdf4667d6a7f2f235001345ca372c6eae26857ebe89973aff7b17edaa29d05af280ef3bc3bcd378f90d5cf7ada6955dc5ea75070af06b4b788d39f9b05668e3413db5eb15073d03f8afbf43871f6e0214f9b525d374b9f72c3bdeb6266c88c5c92779b2a27397014158985ccaa84069a064347df1c1846fac4d170318f5be1e5eb56cc61985bf5243c3885e1cc1449ab69f31c9c261a61dd8a2f0559c7bcf9fad0cb5ec185b3c944aeba2a9dd3b8cd83d838d3ac641599a72c89034ed58d113348ab64adb0d26554cfdd40986c7bf7e1f8ba2db85d7d5d3cdc49ac9e2f989ed13136a3f01a7ae460786347a082a347a9454141c718000c458a4c5febaa45a8ee4bc9eac82f31602a47c8c13d94be9e9cd3e741c71a6e2a90687082ff2ab3fbb5cfb09d95ed954fc2b02dbfe41ea90b06cac6a69dc218ce6c6193eabe4af365c0271ebde7746d47474c385541a698baff630a7e91322a6e425241a5686d6f0a21333fe0a7e87e1dcae29fac9545859b7e91c23ad042df0ffec48b03290a4f78f080e59e3011f13c1325dcb1af514eb19cf4159741b4befe620486377f5f8b0994d19991199a327825d5ffa319f852522c45e21683e32bae8e1304b46964562f0944755d64b45b8e8ada1ae86993fc95d9aa179bef28e74c30e2983628a85a36f4796315f514894bc0fa33971c25bc3fdef25ce4c605d72fce41993991b62f35b74d2c6c9d91c3463a35b3f384a57b6468f05c63e06b711cb34ce621d7e989ed212026c83a9d71d8fe6a211d7205f428ec50ae048e60651cb8b776b75a160b2ec371b34fca664348b5151b1b52a8fcb352f4dd2c264aa13c0f973c62a28d39e031ca875c1f0413cb27369a495baf622b519082946dd111f3256a5a4b316768a9d8da1b9e6606e279436b4db6781f676e2e51f0035944b83b796c4f4150cbd94664161873cfe8a8be4d6443f0aa7e048a08ce2f736e23df47550245c63c91bf0c590b3832c9acab6dae5ee7bf3f210175e4c9461f75c4ab93d425fc63387697c7d70ee5d9a38abbe986a676bed2fe4d2750fec5607418ebd0cd82e36d93108b9a8e55c6ae0fe34dc6bda482e31799fc2b095e332279b7dae068c8af9b01069cc3d1bcd928c1e3c815fe98e4077aefb810e66aa40c471f68375e60f8a496ba81edb5692b8575d7abc8c0b5a955dbe6ed69c7781343a891a59671f48287f466ec02e3bfdf9527290d00b46bdd9f84dbf3b703e55b97b9f72bde3b1dae0f419fa40c0468fb727e090600ed503a0162b711f23daab2d8027c75801e12355686594cb943441b088dce43c582f53177a4f119e97c02e9a3e6155204199c80832fef00b046fafc8b1bf4f56088ee6077f6e73981ad5a235adc22d79ca70b5bb6c3918956e8d27aa39cfa1876680302a58584627516896c36a2666db867f12074276f985ba1267a696603ab7aa25b2920b204c621ae740d77a143b0a95a6d264aacc87014a0610c1e92a695daedc44192b7c893b4c16aacbbb9e12c9c3f3e722d617f70f4a5af6df88003aa8f037645b70c9ad9802e788223153dbc3b115ef5ebc6eb1f2536bc8c9fc190fd565150ef4b2f46b79c4ff7aa256d8943c626631a738fa1eb6e7327a281b7a4bbb53fc340ffd8ab47298b52547a04aaee5d1106c81a9e9fb1b8ffc16d8a40d0bc83650e42485daeccdf108f363a983322a55c7a5133483af8609d56860e1ef5c78fb75e05636a90a3641366dfa081d836a88e440416cef8875504a3c5147ce98cbe05528a1e8e229b611e3bb1a28341e47a196931ae1fbdbba9a92ceca542caf4db7ad4a7dc99a58ab8aa0d24bc1429162bccdeb9cb30530b9e5cd3ad4d1618cb29fe3ac0726c71ffd4b19cbf61e1c8e3d0867340e6ba57340502207589c7dc237a0409bf1b1fc6520b372e4e6965bd5def18342a8e8c907d2abffe08e5860ba01de9a2edfed52cf2432975a3eff07bf3679b34e872138993a4e5310a2b1fe5bd48bdcc481a8bb4143389bd73a7e7816290b33b9b609301ea29380fe44ce498a671954ee342e55ddaddf8d2cb15c4a3ed82ba5c5165854dac4f7fc82f82c37cd77022438a517fd01628f515e4c872ae25d8af1d07310ae848c36651d834fe4d1fb8f68fdcd2acc2bb2fdc9bead38713e9668b520900f531cdfd272ccbbb1b72e6e677aa66bd538c4f82eb3a1d5d349febd312dc577458ff8d397c3d4883e21c8f6a30cc0918db0f457900cd49523b067973d599de240ec2cc72c0b7ecf83c1ec4e1daeae01773b839fbfa7a38d521d75e18d08799eb645917a6aa95e548e0d19e0fc516b1f962da368b9dc33585f4c6243334d721d31ec8e8066cc924152fb52297aa3099da70d27aea79f482559c47d273d07673e0be0178d90800bd57e979095688ce5380d063713cbdbcc91afd044aa169e49483034fa0b83effb162071b9575b18da5aa792310210cacd5f06b5431d8392813aaeff41b4b52c0d1b8a0fea18b84e0ef542aee8dcb2272744eb6d44849e0a1724120f39c9ce3f5e92ce72f78cd9ded2eb0368dd331e215a619e55ba41ba651779ad324bd55b3eec020df8b3c5bb073854edc765d2cb7b8626506cdec7ceaa61338df51e137d69575a91e9d3f9a3a1bec997cea751080ca195b19483ebe8ed1ecfc2c7af3ac0b33693f105a12def795cfe64f0adaf2c2a8cc04194d6c88351fe077f0d10c8af5cbe57d912203632bdbce89cba418dfe6a2876b287bc5fa8dbb21ea4bc167b19c92973eca612694972d2f9321ab8b50269c3ebef7b3310204942ab828a2087744b445c042eb69383b451454232fca11d333426ee9d234af604529e7899048f6a2490ed8a78faae832d20ce3f3b31cd1c08eb816c8654822aa6a7e53bae05db4ce2894667a07189ece585c684b0d66ea7f3ee24a565012eb132af3686c9cd777fc9deae96c5347e292e239509e9a0943ee7e2a677d0bede172fa9ecc2f940e8038c7e04583c1887021f6a8910b9bd40bc557f6c729dc6df6b170075f0e2df1a62225ee0ea55fcad3aefe7c68a56f73408fc718f0d5a28aa3ddb8252e50fbd6986788d8015e365dedb90db8873317fc472f6530aac84d869974a0cc69be77959a3529836ab2cd5ad13be0b7b99949ccdbc320cc3b07df37f784c5e57f4a1fe5f38e3758cde0743e07c7e419d97a26c9f2d0503eb98aba575e723ab0c22f97c7320c950f9f2ca8af1208814f391d1beb29463fa68e3e5fbfd035b745477ec012c51cc8269d638689392a2ba7e658bc84c5bc8d0a0841843e79795bd323fbf68259b0fdda0c5c952736c6f6ac133f5ae4d5472c9e3893ff81473ba53904506a34640e3f6b5cf32719923eb8200607aacbb821d97fc6bc2abe0956773d1f6c6713ae40cc0a806360e838d5bd9d515ad6424a6ff3fd04618fe36bbe06ff8ea461fa7589abaff81ee8d4507eb1abbaeb771043d2989acebad62c6be310eba069e57f0269b5dae895e26498b4b14bae39fab4625f31739611f7b6024a43316c223fb158db6b13b87b21166b7d5e6f7606c61a433d7d64a173c696a39ee79f5b3b777e20ee67e9f01fd73e2ce587bf0f6d52c77e4ec22b69481134d07dbd952217d3e835dd220d595cfa7c24768dd74c8a79e63391d055e1aa9e8ef04d0291fc594d8cbaa596df39fceb4bed1ea6a474f4550e15e377f9c21a6eb31a97c682377ecaa5882fee86de1b854dca73b0d9233923796d3364fc3c743ff62d94201cf0f30c5cd2370a7454d73489db1c13c76c5c0ba8d18984cc1515e005d13aa83f23a670fb62650a576f4c9c298357085dd8d321660a689aaef300024440ed6206be6c034dd1b63f2bfd5e192e592d1793308e2d64096bc57736e9b4433424fcea1120f7b0f90cc1c30d507e6215a81913301e22eb1cea93af7fee4621a287a00c2588208ec024d5196ad82f34a8317457292fda110b7fa235a7525e758365f56738fd180d5e1b48a784203e0554f30521a834e837f2bbf44a7db6b275be2e2d185d9dc7ed7cde7478ea523ec1b987edacea7de36a9728a8642729adaa35c093f22ea7aee4427e7afaefdbc27487d06fb836ca7c7944ee6d0041cfbfc9634ab6e2ade2c13a823cf00d603569a3d0c8d8b251688860e9e225e300ee3b5699d0fc69afd6e6a95292304ac4152311359429853824dc5703824eb29309d5781aba626ed73337dbe189629248a99f28482f4157be885429c89292ba5ab7b718c098b47bbd57928c8c0a1261602ea3e866d3113354b00127b2d4d123dba66bbc728f7902440a3d89e9c4a0ce39b2aadf6df50dca410d5ef42e3c19fba01650c2b1c3be5c5ada3aacaa78f06c4f06d6b4bb887818dba24ef35e48df618b74d70cd5f32216b07d68eb88c621a148fca0df027b9234fd6a8dfdd5c31ad44d622353730af211761c518058c379ee52fe5e48250e885ae5d70175d768f9b13e40e4067bd75632c2ac3dded4587d9575b98bca7506061b4d270827ac7fd859cb75b3ace21890ba35a4d0a69e4738beb255d10192f64bc13ca2042393fba8398b28c59ef80245036699da8fb95228e29f682fa549c4637b8f2276250e923faa944e10f947d7a4a821be89943fb9f1911fdc38b430a3f3077a4bbf5a8617e34f2299886a9441466cb2af85765f404c837861ddacaca14c32e31e5e5bdcaefa9186fd774bba26863fb2b8becf7253ab7ba019541520c81b154fc9fadbda940f61cf42169cb27ce500d9f0edb6f3dd8217e0af71b662e4426d2b3b0d7f37e935a94d17b8a4186ed544d6879ed22edabf946bc3a5f4535807f7670c007d52bd4f466468d947138ed1a847187adeec84108a1ece2b01e184840a2a24b07fe60cb0de83dc76a4cf99e3f4fa5b4a34b340fe9312bf305363bb8d97ed4973302585c773d97e4374d0e0d5fbf208d716a77d44d31497f5e80893fc2d044d48f91821264968f2d9f6f19a2a3be8421f4acaf6459b455e5d76610e443ca66f9fcc659b4304133d5414a8bb875452984ebbc5e703328864bea78478a5ed3897a296b0037d90d151db3f79c19c64f14adfe8539a5463e2548236085075002cfdc6a543719dcab52f9c71a67015aa0a0a295e5838965a109e79b2975158e2567c0cfd11e51fa9d3ae9aadf2e1f9bfc76a0d4968ae2ca1a2f90fcea9689578b8db443086fc17ac09e411eb0c25aca4ea9c58fbe81ae7c62763d02026f1c53048fae4135e7c500b5ebee3e599e29a735abcf5e8ae43be4878be066f9c37f96c727c65f7d525ddd273555e0abdaad4a84dde0f3c27ef099b872421b1dd1dc53879270dadb699adf06ad37c533aba059963a73dba4ac9517ee9e526a47282ce14e9de4fb2195fcdbafd5cd7be8fc008c198ea2f2c02536cbfa0c7d9a80280ac6fdf6743a28956477bdd874a1ab2ddc4a6b850ae75d5eb9a10a5a891562f62eb6d888b38cfe879a45efce135cf1397d004fc36a1a1809255c85c55140a610900de2a9898dc490df6e01c189d5dcf7338e2851455dbab25d94fe88def9aabef3334ee4a1abef1bd011b49c733da7bf1cb1111038889c82039cacea16ce858002eeed57ab682055cb78a514846c29a8387c863e49e31bc7c0aa4e1b83e52e1e40de5e3eb52fa43d61756022e82b26091c2c5171746ff28b227f119080392384a55764e35f50f1518384cdde3844d90da4b99eb4541679e6d063eebd9b7d75885fa6d73442a94be876ff3c8c45e67a70e9947993a756a445589a46a3e06bad3434a89519f71d3ea63c8694c583420b4d498e899637102b137e0e30f6c2ee779584a9655a31bbfb3838ed5f0184bcc8e1d74282245bf4eeca888ed708ecd35316a74bb29979996000f90a6e2e68d6bc75d689453be5b9d13ee6d87bc647f52fe98c51c1950dbbc015e70be8b4f80bcc82da7d5bd0dd9d29f4726a793bd6735c9e56c7f3b233e490325c5ee23a66441abc2bf3968f4e712f115a154576090055a53250d52f0d16536cedeb34e389112a25b1a0cdd0cde0eb101a37dec22546157704f411a7ed00175555aead7f0da932532adf7e8512a3dd3f5bd911eec74a1a2acf8fc699c43cbe7c54490b88d3ec4f4cfd08759d58c27b380d05f28b6d215afdc7f79a745dbe3553145e300bb017dd2f0a1d8bca99b2a939229c68cae867de88d8a17dc0d26ffd6440fb183516b384fcfdbacf27e2d0e6fd05822c886f872764ede37ac1005405f918b590dcc916089fbdbfe3266f7d0e8c453fb74308a736ca14e46e04e1645ada74309ea90cdf9e45fcc2b6b80fc9e420dc8cb90ab4f4f83655345fee478cd8b020f500be19eaa8ee3e741fadc57a06f81caa08204d5f98356eb94bfe786eec711683f89a047d04a6ea3217566f3f25efc9ffc39362e0dd5e37260139f13dceb699153cb33a16bb246ae99c2cc2ff6223b309ce204384bb946a06ff82c4ecdcf5b5ab0e8cef268af51d8d4b9a1a46565785c5095071e48fafa3875e2c297a01b04b6b8e2bb56a7bde31d60462e1e4e28e4dd360b762b694e17c96ea150339b417c6dc70166bca55cc2639a71105366537b56d93a81d1594215b46fd0d13c12b099813f5a176849660b686f5464995050581da69763eae0871cee2dd0576b62808af46b46120d2d572d049c2cc2cb90cad13860adc57c5160bf3c1265ec28f1741a5631ade49c354cb05fb8bcc2bda74e625c93a4e5a35d52f48de12b4475bd4da1e824207d520942d1a684f4ed9e6ae958faac307fcc16013c9075bdc351d7daab10d728efef4dd1675b94c4d0aab920afcf7b86461da940a8856be0485a6dc2ea3d33e246d8003948d2f0a5d439b7a8727988d3471fe89616c69bdd9ed831eb19ed9a95be1d2d77d6970ced3557cc0ccb5a0def14171f84d2e50cbd4d6c0f36782089041fbe7af430408d1579ee94a443aed3cc782a96dd1e8e6c6460b261026f4d41bba4f93a14a18af6ffe9830f2cfc341330626685c17b10c592e7e4df47027db918bfbfebbbfacccce51177392acc77ff964e1698a88166408d18600a6220f3b47a97665e2d451a2e6a65eefb6826fe9fe88d7585177357aa4cc9e27d7791bd1763f26ca6db1fb0d1b837a3304ab5965ecb647f706d71f6272977bcb7ceb8e2354db9ed5bdde25f2ae531848fd707f8f0ba7adf7f099c7a454dee7f856ea1c31b06d606ff97d6e2454cd366cd78bf04c6f22c8b29e440f9017c2d9181253d76ad9017c0c7c9f233f404c97081e913b8310e937c9eafa57d53b85d07447a81866fb17855c8ab2b8781466df59733d46a4cdb4472d77cc675bd2f074d9dc80d7b06319f14f4462c48cb6ae27dc625ea8f2e8ec99e9fa95c14a7b0619f82a1da97092b2b1527b77aaa7bf222358e4012f0cf65def2a460ce3213e77513c405587614418f68e66e824874803311df3f999ab7f404f03c9230cbb6773e8c8c4cac9ca0c603ad1c453633f902161170f784ba0f3313e311d89620cfd1fe5c73967012b81de8d1860266bc739139895e911f38ad04664f7ced96d4394630d4d28d23e40a6acfad442ef3044ea219504bf1380b1202b044e85027ba2f150b832165e90958ca59940ccd552aa7a092cc85eedf8077c908482494faa30d0da37ba05d8f12d69a0e0d1da25a451dd4720f0d25ac863a3d486be908a1d5a17e35a8aa0c89a0903af060da1efa8ec99c4065d726a22766620feebe9e9e74d7fb2ff917a279ab3e45ba2f5906f8d55d518fc00370f112a370edbf3f8713fae71fb2b2621786c335d14a49f338e75b99d6e514616244ec244a66d9e25dc3794f4b5bb52f92e42a309af3aab04ee66987a8391e746df02c286aa1005ffc7c1371e1cafc120eff56494869567b6502166b0293b089f3066603b042679cf92fffae2ac317fe16bf4b87841b23a1767558bc9ccc70c8d050ec6ddded14b9683fd28a783198366175befd99302c25a4e886b5f2de63122df975a704e1bfbf5b97696f6905cdd1b2b2035814663c59039b23ad60a8788b6816a7891e68bf12f2e299deb4b401d151425bbb06b4005d4f8c6d187399adf053163131fbd744851aa9deb41bf1b199cb9db9051d13350d9f75daf35e52bcd8a79fe505fafc960f09e54f554b3c2c55f68eeee845e9c28506c543c7fdbd95211e55300f1aa41c2f45dfbf337b2167c36313e879aa8ba21ea14e38da60284fb37e68eb58fd5b57a2ac205976344fb91e0bcf15d446bb32d85f4f70dbb6df52428289a5172134c28f8cadebe84984a4a6c82017f34a780611531e3e1a491fea603c54cac59924069ef6cfb800d201266c45eccd40e93adca972449c8a6672337b2c254f6e1e1adb857845b4d3322c6376406da41e0c174a002a13a5f0738123ea8218a1ca670d87f1658d0ac263764c48e23c3065d564619e05a68632052688c552a6f15e77cfc9f0652cd214f9c0044463460fd4b562031d842da2e40f58584614e896d0cedec8a69f4021aab53b942b259b39e8c42ee3782165f4dc43acb1332fc580fa39df89b55ea0f931238a557c5b6d88ec93291ef0eb721ac7d7bb33c74443644606699822e74b32c1de3fdf2530cf44cf1d12cdf76460be0cf8877a50c075648b7303eb9d911e959511b026ef40f213b1cf5f56fb3bdc44b66a49e4d627ce35e7e52704db1a19fac9350fdaf64c6acfde2c9b0633e8ae8b6be2ff36b27ac43cac1cb2515220e5a87738972f325824fd22e6b7f8885c69e3042b7191d61b004364d89ed3ea65a1ae340944628a3e6f90c4aa194bb33730354d7711b16ac8cd7fc94c1b6589b151e3e0d00d25346654c9103b9de31166288828e105e0ee7b56dd7121542ec7c0345e9014309f9e5f86dcf932b7892805d856171551ab8840559f3e7f0d24c63d900163cce1f65a5873bdcc6546902a1957a68bc1407b7e52e90cf120ca87e05d41831339834858ef80db09fac0f7ac672761bc048554d8f1f9d4a03020d27b1af27e3b2b2f981af778ed674edc8165745239177d9613f72d6e5d65875ad5085121fa920b6769a6824485b8a73352f602ebb4ba36c452beb37c52f0f6a8d9fef3778f531d8ca712100bd19d36bf71ba14dcf2c63060af9c3d73e58dd67da15029d97a6cbbc746a84e8600913b1320f4c86dcbf278dde947f9052c4a865af96426c0ab3629ea190de96cddf59552e86e151a200c5ce043535fe10adaee7a537a9cb3ebfeefcd0befee356719664f43f6fce44de17865fa44b430739caea90d49129b841e6b9840faaf7bf319c6b0ae631c28764c719196f3454a2619ff5db129616ccd6ea684491e83e2ecaf26d1a0c00203de21af9cef4509b79961b0c3836889ffaaa7eba7fe8588d691276461612240477e115add24f036438bbfa9d2aea987000cde69bb6a72fb2dadf4aa66ebe3892cd88c34840f1e11f6d92a55d90306dc44d5f2fa5810f5f76c848d2d07ad793b66137a1a9026e338aa0c29d87e1efa095773fc58f4324c506bcad8c3401bffab14a606f67dc5bcebe14af28a5d94c2cc2a112a4ff156a2a901394fed2889d0b1f2474792900dc0ce619cb9fc681d01065484a8e21402476a1cbb48ba9e7ff611d969f839b9259aad21b3cf08f6522a2a72fe6e246a9c41bb2c6a20f28341712ac448b9ff69a352bf0331921932c4be73e90d063f543644a96f76724abb6fc1c6ccb2a141a03b506fcb8ac4cf929ed51c084ef662903b9704100540b55a488356dc7f082e1f0975556658e008b1b15f165c7619778e5c9d8b582468fbedf8b4473b4b4f175aa128ac47f7ed8b81530b81123820f09c5524d56b03ac7826fa3df532f89b110c4fd818382b1dc74dfb5421dc351e03231a3ae21aa500a68583a769dc4c29e6254e13616fbb41c9315f02c13eaece9710cef714357ae4ae8ea14a27adb6332847ac19a906a97fe12f91d367911a4c470d6c7ab1e4778b3d915a93454a7e4e59bedee0e5e5a14dfff5a3cb6208798fe22ae54a128867ac81f9a4f452808111459881a02789f266b838cc1fe7be3ce8569d2d8385fa19449c9884342249dc2d6985199a74dfeded4ba3ad0724308d5bded47e74ddf8cb78c1d4ef631c1fb143cc168d1df724e697bb7da3b8bd3afd3dceaa3cb29d1c2aeaaea024ae9b9f529628010f8afc4130f8e3287688b8d9f2a823af8a18cdb4819bff816ed0fa95048cb5c6ea13fe848b468883c41a09f17e37cd1d018437d1df080f507c0c9822cec49734568e78bdd684bef6b8df10cde6d803aa8e45593e8bec39a1e80127a239975046f1b19c6c6702a0e8070eae103cfbd5515faca38f097102d22b09525c7a8aff0054f77eebf5fce9ba00a226cff44384d256d2cbf646760b0a421ecc25aa96d1647649435ce747df8fe1933272f44139f2d2f37cc721e013015885add011d0208d0795c3607bba3fe1127e3a603539c272d62708d52d2f37d880e3726b0ac55b7406c1aca5038d450eaffcb31c88b71e91104bfe90190e03c50dc485131f160bcf75811115f3f57a3c12c12fbcad9a25685004f81b3e4e422a6101282afc7c3028b86197dd7dea1a61b5cf1575e243dca003a50930cbc517e7d8538606233c32ba37f7d8928aeeb5d7320c237255054409c105c2f75c3c60a36d7cb7a1632b3353cfdab53d43d73773e9c36c5efc847e0a819f2a340fc9e49907797d535e31c8a651ba480af015c98600346e04a2a97aaddcc2aa47af70d8f828b86f11e1cd4712dc4c46edaada701d62dd9924d7bccdef6d304be2a85656e12e175b76a6f353d8f4c6b0a941f2351f619c5e5740e5d9aa1dccf99a2b68c5d50f3ba8d167840e3faaf3b1dc4d0ff979d8e2b090ec916845229d18725b06f597b2f2359fd06593c9057f1e8a8cc475c0e4a3fe745919b721ccca99b888e444423c3a1494559e9345a2a901ed7096db378b5127447a31c518acb7fccb20ea53b613575a3b078b9b5eaf24b045f4ab110d996eeda9ec15d1b7bf89f4d548347849549ef480ef0ce0bf7ccab20411531220a20d3d77d876e105e02cebf2f129e906106912fa1be7f020c99e30d35fcba4a8b5ad342a228531d257ee47b67bc45398437b6826913abd58048399c490e033b07a917075800359e6f8949060e180a35b7d82574152a1e9e7998391f6ddb5b157003f17ad50c40d580ae3fd5a320b30da6a9d5213ecae2fe8215f7d0a26acb85f0c772d5603438a9d0edc7cf420c67bdac978d75ae132a08e518c77315800db2fa4c52871450a2f44eb94d70eb3eba47c7a28e910077db28a2ce404a29a9130c61bdd24cfa06ab6df2d688d7bf5a5a8859098313a4f057165e8dfb73fb9abe802cc8690a9141a6e5dffb2f508720ba006915f471ec2acdce5aaac040438f094b0ac947786e4360e5135cd229fe811520863d45128bccb41413d17d32f97689a1189964a009e0caedd78e264a2341b0481e5ac9414665501bc386e657c79b371a736205b770a67ef25174176893a0c9f2709e14363252a92ec2e10918a8bdda5dd8db433e0241a3cf1062f064b534a8c2668dd5b7dd4b2c1878a9f9c510b55d2c990f819d43e438d8e03c75ad39ddab498ca308bada6d51537826ca755870444b49bda83c51b4edf6283850d3465a46b7a5918f296c0b5040934dd76874f376a83ac3bb74860ba07ac7a00b267edf2638dbb85cf293a281fe73d058af830aef9d87c0170fa790c7bec95eee2595f64471993171aba06dc0180a89a2e29ddb6674d1054186e82d20d4f8164e164b078ed49772b78080cd5b955ae49f7bcdae20e45320a4be59874e7f591a37b46303563e99274777271316c9006d44737d20811ad68ff462d7cab94318d33e936fa4cb07d1a5c3d490c72e7e411e18f0647400decf95bc540b27702313aaa60c21c28c608930ebf40d629b7608a4fdd962fe78017f0fb0bd367ff2b258af13bc4d1e0b7d625c90d0213cfeaa9331ca72a1bc70c910deb150c0f5574d10324b6c5b09156eca40582bec81027ca271e4b21d1af2a4585b337042a3ca8b8cc7da9d808051db1ee8aa1c938894e54e2d9e2563d4a59d467e2a8a357293884617148c947c58a7464ccc57470228e7deef8e70146530069aa49fa23975f9055aa6b735a27ce4bdb0783afa24a4adfa493e1543ce6a567aff2226ff3b6541860ca091171a33b7ca9f4df459e8903ff845a9fa4d87243810d57d7ffada6bb8f24d247cbb36db877df7bda28ead8721b3ddfe147185140a8e9980631625bcfd8e55893d103a32e0adbc6877e28a3aac50bc0e86c65378cd44e0d240f4b78566d92f83eb0992e984cbc4f286aaacca4d6dfae22dfbc0f543425fbc903478dbab3343fdff9a94336f154c06127f43db2c87d3b0aa52e3b20639132b56bf01d871ef98df05966afe3cb60c99d0b4c785c53480e5c6d5bd3ed563525cab0e6ef924a158f2eff7a27323fe8def7763762a41d9b92c8f5eece23cb596efb5683a44bd490cabeed49e87ffac64e245a3e310e50547fa21a2922e67ea2dcbb9df44828a9af319771338945b16816bc0cc70a2d8ebc166d4ede75ed2028af56841e943da9e4d0d5dbc7520bae4c0de828773fb53cfa4ac80d920e1ef9db2216fbe7dfd15777833e24c35e9f8a8d13bf9e11e8427e5d2c791662e4c930a6f22f54e68538cb310bf2f85de14b76f7d2072a4af3fb17c5f4d2184ab904ffaf6353615e06ecf0c4c83efa8fbf4bcc6e40328abaf1403c7885a5dab800f2083f4e7a0d415bcb8101e82050a2f3329c82a3ea96e98888330d5e9dad3926189c03e8cea2f5283ef6a17c8dd2e40c8b328a12981b867596143b095abb6203141e85c623d48a67ca8107ddb7b3278d4aa0d9e2618f7d9edcfebc594d5c8045e8e49668895f1b1f54feb519a6d3d2cccc4e8238bdc354c92db4078995de9c5ce02d49f608516c7c4b4537a2986db55369f12b72b4a5114139829fcbf10f08b777b494fbe7b5fc6c8c11f4758cec291b9905d25ed3863514fc80470f0f82f129bfe88c28fcec4333686526f389f26cea3a525fe887cea7cd5d4a70d44d076711067639138539097b5af5161f67cde416e75ce085285474e485d1d59e2d003bd3c778a78b023c7b1387097dfdbcfd6625f16e435748c521ea2a4f452de0dcc18bde63533bb837fd213265c38f953ff8fdee911abbbfdaef2df8f5de6bd9f76f56fd72f1f2398b9aecac4e32e2f79541ffdef3105fd5b296705b925af93376a68972bd882ee81e3f4ffbf60c1aeca6743664f0ee5133fb38472a6c39f6317835e28ace65e7474e99465bc0c235819ab61ae6445fffd0159f2bf11da187ed9c9cc87fe10b67319fa6bfdf630602860985ad4784a18c9a36ff3f52a61ae28b21c9feb6a81e05085eee3d8c6cb9cf893636e5d1fc44664b55f1005f35b4eb9ec3ab93c4a6c01926c85899d17a437b7c7bd745fa2d36775c80597d43845884747f52720bbd4d9ab2129b120fb5d222908af7c17c68453bef0544646bc9b52492b6d7851837ddb1982d42c6a8a0a735b8a6ad9ee4e346bec0143619dfc1194860ad9861a8d5a477558952781b84481085e6be1765160240e26137f9fc3ab7fa7f745cbd8e9f97561953a9c02f9fc2d6a3c264e2096479106d956a69088c54d11655246cd93e12d4b810c33d930d9524926309874200a913b1c2755119f3461b39fdafd86d726887a8b0218c84cd78b716a55e10ff5764990d0870a58df4a8ac99ce847e9d9b5a61d1eace785f2280f460481a9501aff644c28660c685ed057d65f7465504273d4eaa5b3864439f23b1cad7489e5dff0cd567244eb0e49c23141047e6336dd1046bef4ff17e949168a21df1453a62a2101b179e2fa1acbd5474548fab837d4704d8328ac181b4b37f4e491b9d6c6821578fab7807c8d78642eb09535ddf778dbf7e3c1a8174a7fd3c86f90547da5004f371dc794a1f6cbae88effca0a6dc590d4c3f4b31c245e40e4d401aeb20609b41528bb8af929ba5bc4003972594b65571548e264a9af1f6eeb5c8722654d6d81b4a61aca5af2c42d5db597b8126a1276dc860342662f8228c1a0cd2f13c0709c6b8ec68e46f894ef28c775ee049d4daa253d8c78c2c2f77adaa869f68bf5c2b83826c181ae59b73954f131f4c3651d7ed0bb09d51f5893565574741a1c9e64394510d9c233b5128a06a76382daca3e18b778f8be8b2febfe94ed782f5baf445c41acb8a73a65ea98d8820823beac0a50afd1252a8641fcb8800c2e0694e185069929b9f8366450920591506b440b95ff6d931b818f6c8539c125a3032e493343c194fd5a506e7de9717fe8b43888d657d63bdfcee3bd19c3d021238c803899fa60d24e33b5c8263c434c44336a63a5b11713e9d748be5db1de927c7603757e127e912abd8fd42d3f9b6ddcb4ad2327462d1964cca8bbaa28ebc296a5de7746bdf516e82bf3065dc0c165457d3845258a6d819350495b2d3e3c303961eb8ff2460d9794845e5494f731c49940134a64fd5dd0a92958eb91ca13814d0c4ed78ec0004a581231438b66aa117291228abe2f585ccbf634e63516db435671f803ac3157005de9908284cf932fe373d18a8f0e0277312d5c806b4ab5f665153399fa7e1278f3d5a8eea451ed8c5d7d85fd4da9d70af5762b763caf15a1c0e7dae15779c285ceda55081391b4e35e224862593d219ec2d1835022a713958b709ccebbef3bd89e9d6111c6fe3a2e5c8d04e9485227396fe34fbacc317cb738451562f292a12ae42b106f7cccc1369990b95e5a84dad998e1c953177a40076759502d224128c2b9ea43c984ed1dfc09b6693dc2b4f1b8e399cb3dc1ceac3dbfad642a883023cea85913966618ae1648a35d4f4b292833e63449e42401fde88ccfb66100d462c9cee7ff211da2c09d26e453b499919936ee3493627ad430b2d9667016a6e94a65cc4c46a7d90235cf4a585bd552abcc841925b3b8b30b46e3cb7649c738f38228efd0747e7ebac029992b97c52654b26fd0cccae9e896c936025c1ccb9c4005ad5213ad1afcb13e97a60681bc50c0519bcf70a1c1dd77590a2b86788459a47f16a97909f78dc73770ae5de15a8364bcbc3e35b84a64e5e26d857daf71dbdfb5a55985579027e7a793593e393a33e22aa6959641305eb1227f43937b592886c52abd4eb294dfd22475b98e3a5b431ac678a2bb10f9967a02625250431087e5d13e4333f6c00add16799dd0f2943a1a68b032e7804d4ba4cdca1c2df58d927e122987c62091c633e33f5b133dda892b25ce8bfbfbb7520e77b4b6205a5cb0e79342f928f65420329477b4eb85c1d876368726573bd84d7d16c08351f793f935eb6fcc615d6d4472e7f6285f9d1727c6ef889301f3839c179a7da1159cf1ad7d3d4d576215e8152ec6fba631113dc69c03dcb95e9f8a06ea97f596dc9ce39658803a35eeda7880deda2eca4d81560dc0b80f943842fa54e81d78b2eb8285ee472368c3908e6c29a822421d6e434c8dac773a62e8237d5a99d2dff0fb1a805a08bc23bf9c737d53199a02e7f9ab6728433720fdefef05a79659f9798e8436fc634998a6bf77a0921268dec01a29e0ad821600066705cda322b0942b6a5fde571a61e0678d80ebd0908230757f6142129ac318509f59d04041249c505055e7d62698c7006d610f7572f6cb1a025124cff694152481f4a062a7435eb76759c4c8c60b0906bb8230e1addc5c45fa645e1b0543e1711ffbbec4468b207ac1ab1a20b54ff0e79a9412044469ed2fb5e1179d92e24be3dca770398f794f6f5ede03d79a7108771b1d886fa7a997b41cfddf52237610ebe1c029a8f89bb211554a488387298a3c21fb0d40c96909558920b2d0339e9ba249019ae390ffeb99b7cdab6d33a392de967400f7f024888ecbf1115b3033c948c52663a79e840bcb3cfbb1d20d631fd4ff50db0f3a745bf8a98c6edf330c72eae6f61b93ac97b93d6f55359ddaf76d3eda3906ae0e6ce2465a0818cb55ef155389602bc8e4757075e18b7269a264b321c00ef58f274f599a77127041754133c5891c58ca66c9e671e7f465a4bf7c027dd1f34182d9fb153816570f6f40e602cb2250039e5999424c738698471cde073df46a8173569c6db0076323ee137b5164db77c1a7acc560d77c9177401520fafa9413bac9e23154b274c6023399fcb301cf901099bfe0dda78f8fc8db75765d3a857e4bfc5cb79295cb13a7a8c654250f9d6cdbc7a326bc416eca002cbceb30f4529d9dc36d7ca90788174e5ff26af9a45764c0a9655f8d8dc8458c4b2af0a92d75f33a511554ad465cb3ecdfbd45eb2a5e91a2b74f51cd9983bf92bc2d32b3d4e034bab0479304e559e908305fa7add04b986404372cb39033d9a164695ddcabc884f72108b6d30239d4f8434e53527a7aa8a0c6536b86029bffb9228473df97462d41de9d5838d02f364d2240f2ff5046d4c611860c8bffecc35ba2550a2c447d14185bc09ae28bd59f2cd1969ae4d8ae010feab22a71f5dc4d3cdc5d424ef1393799ed5ba1f23e33cc93cece99bea6fb93f950b377abee6c80505f0cfd23acbaf5117fd54e5634e5bfa0a1f1208eee8dcd096706ac748005d7c64ae940dc7d72fcb849f142ca3fe936e72c84d4d521aea97dcbba3a74a099a8a8cffe0f45b52b09391413883eb161da7c38efe86989974d059c9f842a7b144f0e168349fc571ec2553d549f0de50ff478fe5ea0a24a0f106700e8f56ce22daeed89574087f7fa6b634673eb54980022c68aed03209c423a4cb53a81baec9e4b44f91bdae3006fcf61c9d661e4d9b342cb5a614a10a2d8fefd473c3ad56da07179083be44aca65bd15d999173aa933c1daa50258991f1cab2efa04cbaaa273c5584b6113f6016b8bdf79b8ce3e62fd28d540fcee28bdc640725b7ca1448d8fcb7571e30e91f5a6ba0b23fdded28858400f370178722f5fb70538ccf202e6beb26d81293227c3b651650ba9d8f2f3d61acade1fea2463b38971bae63298a6cb2ef4e84d9c8f21b2680d495cf2dae338cfcebcb3150ca238e2fa34173d5c6409bacf91eae00dc8c4a906e06f86a41ba571961e79634d0ddf4887f9f96d291e3da9aeac649266762213a347c88db941d3519249f661915bc24e82fcb0faabb0bb5ac30f83ca7f1e826e9828e7cc1bf480e710d66cdaf124e1bf8a214556ee67518131e4e7bd54527d50c3e1535cfc449e8f5a45768845093c60e9b9628c233c92bfc01747eb181a64d165776d0b22ee13418fbb1a172986b3a20a24dbe1165a637ad3e990f32a50ca8818493c062e1eb4c40a562ace5e5657cbe31424ec248815330ea675cc0a291ccdca40fcb5831a5b7fe5f2af6a52bad90ec2113d19569fdcc3ab1f045427462610610cc211b83e8cc62a3274dda7c07faecfe5a94a41686afca89513f265207470495e741b9aeae82690ea82c3c57d854766f0b825037652e87902eb676a0cff77cce229bbf0f5f9fed23aad95b55c13677ded6cf1be087137880e06bd0cf71b8ed39ea289a2329a98f48bc4c44d4c54061da9f21dbcb5776ae3bb7a4b7c0baae9ec94ece7ec8a7a8b80a19afea7da117b641964c94b9667717175754ac80d26002f3736e1482db3fc840a5da348cffe13308c22a43f4a11dcb9d0800af0b7c20d4640ec0b6cc2342af6490cf3017a6e518a198f1f2290b11ec50db7512961467c6fa9ec01e841a5b84fd1ae0abfa5e6992eff181899e142a1662e529f7a4b96c2aa121b97540aba5ef9cdd14346ad3c166c7bd18946a2fd8a2e6feea7e5238a2821dc0059b6078120b2f8cc6dfb65de819224593a4dd40cfa811a210f8073836ae4e1da694e72e342718e7dd355256323c11ba386bacc59ca502e401e3257f9c2e060ae047dcc4ab0325a6088708a6433a7fc00e2f0beb063b7578b381001a8a711a98a05dd2b591ecb05b464a073482db1fa11b49d2c68cf71825668a3ad87e2521673128cb306a815548d5e1ecbe66c0f74e426c55e1ecb0e12b48ad5e5b1a44b4280f10aea59d290e27059595e92088cd523fa2db62275624fff44773993fcd116cbde923274c58b0ab45e32c1546c034a158e6a5b30145ea503da7996d0e7ad34be5c6d5bb8cb595a4b27a6ce13003b19ce0bd01fe258834645ce122ae22511c5161d628bdcf0f801e33eb7bbde4ff37afda35e0ad72ffe8f269670e1bee17d834a7ffce22d3bc8de64cbbda54c29a5cd0683068306346421ef166a21168a21c68f6b70842ab696953f9439628c514a295329a47260be0ec373c498715877c55239b8fa67a91cecbf37dbdc5870dc8cb9c17f3e5755d908abfdb6b586bca687e8526ef69c150041507e45a66d69c2f9f29fdc04bed56ab558469eb59b80f06b3748e56b3fd3600ac71c2a9a48434b46488db33538f252fbe79459651a354e3885a8475388adc110f08f5262526ea80f3b15b4dfde533b50bf7d9cdae19f6ac76c55ffd9aafefd981fff07aa92406307744a6e668750ca47fde6eebb6973325bb1ea550c72a8e1004328575709872f0870021cb2f0828315e011c5ea2ae1d0831516ae6931238cc023acfc35e933c3a44fac4a9f137b29a7c4a4f499c9a86931238cc02b50c6cb74333191b24c37f33134326464cfbf71291c8ce2994c866518f3fa67c2180e4de09fd96233d8a20eafd96e2fc60c931ebb3119dbdd1d6bd9b1bbbdbb1ba63bef86114497c8ed5162324ab92b252633e93353aec6a1c2f82ea5e4dc93acb56024c7c86566d8cc30cf231789612d774a96f24377f795bbcdf5203d62188661f10a0cc364c4aec062160cc33029b12f24e65fb29c207ac430b98aa9ebc36b5ac76b5631468c433df699e3ac0ef73634d98732aa8e4dfe7ecaeb788b07c4f3693048bbc03630b02768ed058bfc30293b66e6f828c6e9be7df8f00192c2e19f0f12d02984da3239ce2eb2931455c8b0218a183728e151d49095e090430d798897542e7ac9e0f0030350a81728dde0440d99b5a2640316a6a2c5450e95f9aad790c3912d9d53dd38eb423ba523575653829c4471648601c81083f8d188961aa7a89186276a0cdaa1a3e1ec2a73d5abc94436654a1c894804612938e245415eb34a35b4acdcf080238c948ce0e086071021a186b0ea55cd902a90f88113c8c30fb6a042b3ba493ff052032b66c8c28a1c9470c08245d27ca6a25543a6a255b51857a8ff8186f3851c5c23d001ae1c1274d21a657cda3851a671c08fdfa790a08cfa55fd313f7bd487ab1b9c4a617ef6d9e4388e7bcfe9e7487051ae598eece79c9aa6693eab99fdcc661735962dd89666052e622b9b73c3c9d628616b74cd987b394aedd63e7b02c2809a00cdd7be0423ba757e3f4d7ae6633f7f9a842a28a002592cf505ffe2a5fac854f91a90f50522a06e7ed38b64585307f303bbc5c2d23ef38f88e6a9fce5664212babdf64a4680e021b2ad2781f918ca53f9d7333f95fcf9cbc23e55f62c60d9639f4a3ef6cb6221fbf9f3fbc1c01030f0e243abc5ca3e955c96f6bdd7f8d70196401419b1921c3c3d0a68c8454c1e1134ec22958bee927f0c8df3d3386110f971510a09aac373baaee1efd81917a7d59d3776c7766e5eed0760c188d3eddedcedd47d77fb6777f7c605c70884b8bbb179cec8cc3122f18845cfc89c25c6e8ede8e87883ab78459432fa17af702eb6a5a9dba0968d3916a4ec97de8e8ed7fc40c71b5cc5ff188966dcd238f1080c74a87119290284225b106088224e45b21079d2220376a40b1aaca06c60ca860021635ad18e6e51036ab5c56be3820a27451732c0be90a2b58ae08ea4b80a2353617e4f5061607e12a930325ca9300f238503a62b402af51bced4144d4d7d4c7d11414da5beb86a4aa9e5434dfdae004449b16d3475b3a9dbc7eda79724eaf67448ddbedbbc58aadb838db3495f0c31c56e4e0c153930e20b220b787531c4c58bae4ccd9ea8d9cf8c0b126c7183c5f12e1543610b2432cb22801a54fff954c593106d26af0ac39c161796640386618cdd4036d920a59472092c5a920829a1c54b1750aca0b224d960050d590d65862c0d01ac494fad17528d3f6fc4f5828b11473380410e929c205a22882d3ecf2cae1ae4e83a0d72185feaac68e8344eccbe307e3a4cb5205269542f6848690c61894ee188af56ab55e428c9155c38f1e2cac11169440a58b0558c5695115de934ceb2fc38c3801ad2744982290b23598a6accc2881a93862003e84ee6933927457129129465d1b8e0500336b9f81024776c119471118286a804e362c411d762cb0e2dba48cae504397486147772692207def1d4e4353bb9b84068c7109c3a224e4a337c914a32801758d440802050545da519ba0ce0896e759566d0a244b5ba4a3334e598814969062230f0efcf565d6f6babaea7daefbad5c398e83ed7908584d846ccaf8c671e388732f3f22fe77c42f40b79a96e128c2fe4275c2ca5eaf093da8c04887d3c8277016d905543a061ece91ccec2d33898098e3cb1836e6d79c2b21fa76c19f6d987e9c4784171c207c21996a19ef63bbd2bd49199b7f21ac6da6582262ac60082d228652c21b1262645998c22d98c61034f4e46f2d46234d1260a45050d5d028409456d44201ddd8004885ed24c9c4a07b93fb953739566299aaf30169723b99117c98d932104c4d0122a538e9870a9182ba80161f63c0df2c8fefb917d3c7aaef037ab071acefa537ff007e9d8c91a769e4a61fe8e6facc5afa381b6a22520e2487b47b96b8ff25ef02f3a2f1470a0d03930dfbfc5878109b30f39f662e488607edbfcd9f3ce87931f11a5edccac82f13ffcb587e1af3dc752f3b28f44f40b7a16cc47157fdd4cd7f46b2ba09d1419541745426713db3eaf4725102f3e225ea1eb6d6d6173767936085a4c4822b3f79af92808ec6f0efe52330cc3b22fdcefc06f7ce9c110eb8ed8bf2c22d4af07a3baa7ea9fb5bf393d100790e62b4b284ab08c208a96111c69ea8fd9dfb93144897bf8de434b69410d57df030dbb97122d980d70659a8ef10f7908480fb53044c92eaf0024862f08d78486eb14841fc837d72de58361c762a93868832cd4eaba2a46432ca12449c9fd8341dad81bfe06ec092ff8172f3bba55e5d780bde1da5e07ba4a4f05fff2e5cb97da5f03168c2ab8cb4f676f646dd6a921585986d2b0d3b0659f61588c40acd1b1280463be61e9004850595789071c146009edba4a3cdca0c30250578987293c18d5f07b8ba416282dedb3e4ea4a1e1ed7d5de4041c36deae17352da750f32ce32b8cfcfcf21013a122833aaf23659a0c7d688cf41a8dd3132a7a47b60d82cb4649bf99918638c3ed1fda36ec4b634616caaf2b7ce3e9084adc19f01fa518bd2b2d758d3b44c7bceb0d8621b581c32c5e2f45377b1a07c192f624af582f2851a477bf911091071282e699cf9dd854ccbf862c47c5e44bf229814d71f7b0b68b8efad103d1d373c14741a94361290e0cc1cf584f9974dcd999cc9005b835f3ec83632b7c1179996b49961a856a2cdec51dacc50dacc309436330cb54ccb0ff3a9df1ec59307745d4f4f4f4f4f4f4f99cc27e38bf18594c27ca1cdc77ddb3741d000314954326d8d661b315a557e7cb23596ee8dcb9f93d2ae7bf94bd953f9924a83724a95ccbb9bcdcfbc179c911a1c82ae8dec896d645f346a2eb6067ff1c9de7c91696fe44b25745a098c14c6bd029aa0303fe3e5c72316274eb1a07c39e38b465acc17dad0afd5cd2902a500e8ba19f12bcc179960d080c6f7efcf8be44fda715e94050909090909098983268a6addfc4c3ec641937e554013348c46ad2a3f1a21b9965e4c325b63a590b115e4394258f2a390e74496fca8240e7d2c8a4d362858edc7dffd5412908f3d0b8e7d404d7a16c85f7eaafd88b25f96fc653dfb11ed9837a605195e0bfa91f7145846c0c2753ab51ba10723f480668b369a9d95820842d0d09f78dcc96b4ad8010dbb656f1844a914e60ed8c5485cb4af255751d1f217c3021abad04e7b933b6571269dd76aa99b406f2667a55ec8012b21d085804cda096d8dd49c9476dd3fd8af55bffa1583d7c407e235d1998aa6a061bfac6c4e347a6d0dfe4e0ba5c2688a1a7f33f21c9a45a3ae24ac3cc799bc26fe9c9476dd3f08ae564c948a100410cfe9d7cbc90926323de938adb2803abfea406aa30353e3529eb3d8a1a01da0159b6c036324f6263e17f109ce4a7ddc44ddc87368c450a1fe5da917a35517fbe411f5efcf3e9992c0b252bf291eee1909fb908b7060518a28d3aa5cb492de6bf7b51d0150824d6e1ba7fa63f4f7e132fe7cb84ac21094fbc17ddcc17d5c887dfc2020e5730a07c7d40a42eac6defc622a05d48ed3e9612e770648ccc004b57db8da334002864bf5a76385d7c2b362df2f5f074f8fd4549ae6c3473e906725bc447e10b94d44aa0c2212878e704b57ba90daccbc165a537056290456aafc1b8db33ea8f25dd8c1098b949ec2812282c68a83bd0c8e2ca502f6330d764464fe3958056eb509c12a69c815133190f27584a046d91648849478108251015d25212521185816ba94e2b81e68ff2a0931a9d8af6f18c6428da3d2fe3114e771d8dca67c2e224a3db37e98c5bd4c0ac7fc28edbec33e1b50b56a50feb2745637b06f6713e1075a7fa0d8739dcf2d240d2a69500a3528352bf46bc8462b603a66a6d0551212aad86fbcc92859888d3c466a50be00aa501551ea97c53dcae3e9d1625640e3b1044d793dbc463ee7f98842c36daa12ca12757e412410277655f9233f062168b84ffb1d7d7808fb9529283666a6d99b1eb21f7d4e4add6d36a45bb338dcddbf0f40b32bd95a93d2676262626abd8c3c92e80ae1fcffff9f3c74f0c0e44f791a696664907037604c1d9fe051860e51c60892cd33e3d91926a349a49991e1646a68e641c9b0e2bb86a780523495d93c681f3a7662f849229c4f413334b403ddb523c4483bce42317ef3056f194e345c97cf8ecbe572b9a490cf8da741973b0d6e41c3e9e2a01df6666f76d9fc4960760d13dbb922ac18f4536d1f4f8ca7458f025ac40202e35371d1def4c3c0dc97d0033ae39391c105c5d88a3e1e0eaa28d58e50fbed53ede0df9e5f48155277baeba672506fcbc2c9c582f196a5793cd4200a6c834bb027f433d1fcb888461ba59a4341d3aa54f854fecc04658287ca5f68233343433a8310ff1ef9df4f93fd7afce3f7f32384a948912d32d4a7715a1c0edebdc0daa06117b64610ae2964ebc2deecd3b08d0bec09fbfb855bc57ef1eb582816317fa78f7eaacf1f3e5ba54a75ff1117ebae52e5a8ca67cfbe3b85a3b32cee0fecb97e347aae8ee8578e4a49daf863588f9f3f9583ab0f4c642a476318b61206dd1b8975330deeeeeeee763b4de7d90467409b06411bcf46468ee338ce9b7783a1eae158f2632592df0f0858d46b38994a01e3662a076bac699a37350fb5715b2a7aa738b5198cf0054fe3540ecea3810395ca81550e47f584ea0ed55d9f7dbdbe70a91c5db9bd49e5f0caed8d4771c0487130606052746fd893c1d1e58895c66c31a8989898182d26262666c6c46431588c8c311ed3311c7302bfd8c50cf38446514336e2a1d496cd07206088edb3623cab8028a80ba7a7713819266e18b8f2689c6f4229527f884151a4d07c94204f9e2821c5b69cb9a0092b4840b97b70c5513061b27df49db3bbce93a06d65a3fb1d25879928534cf041fb2c15666ef6d2ddfbab06757a1ba73b7e389d7a7737b66f9ba0057dbd48e04e9d3a75ead4977a0f9c301a5a52d42038a345431eda6716d72747c4a7c9556471c2a589cb15c58997902926f880fa2c158ef254c3a74bd35788c0fbeb4a297d77e3faee7e3dfb294a09ba27ed966977386b0e58e065e7c60c1d68b82e1d3a74789d0e28ee2e82b8bbbbbb5f5ca675ce3f7ae156d9dd940b3c4629dbc4141d9d0f596989a61a3e85120528dddddd1d73772cce06fdf7c6bb2c8d954d83fbdd206f3bb3733132d6e43b8e8a7083b92ba0fc73ce39a70735f161cb8a4667db2fbf95ced3689075a46c273c8912585c477614bfbb45a8abe4a40b126c9c34dc3e3831738f06f97d70f5f1e17e0f1f3e5cd0d91b7eae09ede183db6edab4695d274772024ce5e70f003f9290cd86ab2c450a17b91e9888a0438cbcb8ffc18ccf04e59e8d836dd7e5f4fef7864a7bd8a250d73d46667e0c8b8286ab1d5f89c2737431f624185058517612d0fdd5f2036b4728818222e2729520690853e4c95a8aa281aeb866239818824a08945c69024915282aa65eb3cfde8c42775775f7bb068ba06b43164e51fc553d9fe09947d2753c14c5a1788009e7c46c2b3498f1a8c094ca39ee72a171f6092447955f5d7a340eadccad2a4f20d95243bea18519ba204de1691c6e41e5dff53929f51b0d12cd5fc5b430c405f2573ea2418dd3534087a2108edc5d623724e6ee2ee5638ca57030f67247e28e64ce22a8ff7f838d6152a83f867dc488e66373ce1857f06a7a31755d47b4f1f4c47f148ac79c3c3c5e3d0db644794124cfc67ddb1666af6def1e797ad9164476332fc398962512ebe1c2d7e8f9e8ae9bf3eb71a3c5850665d6c37d9cab2138d3a0fc3ace5eca28d4ff553bfcb3cf9a48fbe8691a57d983cb85246bec065b92b610996982020a8dd31f3d09e5e6666460cd38a9410d6d666823115aad5641336040436e794f31826469fe6ab55aedcdaaae68cc0f5ce980ab07e90c82814fc4cb781a3df6b71f44dd403f05ada599a56e0a0dbb89441123468e8a1c0d79e9ffd93ec8d6e0efe7c0720ed0a2096d203e9e0f8fc70edbe8a0da3bd9cf148e2835ef9be1ec695a8a086ac842362d90866090bd41816d70604fe86f4d0b7a544316a2c12d579cdc9091274f505f3c61c26408131f5e0d2ecc0be8d72a3289155ee136c5cdc1beae03f766569bc69993c77baffb81c61ccf1e11f68bbd7fcd7a57b520e857285f549957a50d7612342b92e4430d509200a19ad0cb01326308fd979ca67d7326314b46d33c63b5d7467be34e360b1115435328b122d4519efc3d07e6b51ffddb6bbfed0dba7dabd0bf793d1af427a18924a954654b65a52a5dbad544b0df9e7a305ebb521e6aa2e69ca86ddb8c3a339a935277327ad0c948a7ce18427b66764e7376dd3f08ae56298f480af56d3427a55df7afad3414aa7bd25ce9289bb398b795ea0d45f57602c6f64e1fc6c873603c877eeb35309e4e08528db37d1e6e40088c944783609bf6dded2814aa67f6bd4429c95dbaa687e74c963b35e8de46d597696ffadd488605fdfcdb8c21df0f9056cb63f3c72bbc6373de6b74f0146b65bef6bc537fec07c16ac45e9b3888b26d93d8172e5663cc767fdf3518d03ae3ea5cd1073dcca3c10e2af47ba401bf0f08743ffcb8bfa908ec77e353edf874b8c2d54cbc22290906f47f65a48c0da5734257980ebf12164b4cc2201ec64fa741ef874c413ea603f641bc4af9d9476fbf5583197ff9f2e54b10af1c0601f9e964afe3ada47f343a67fe8d95ce8e4605c90674ca84fcdd395b4d7ff71678b6c68ceacf23dc205477ff95e76c1f2b995f94b287c7c7f341a1fd27a8d28b51a5b74b489654e96d7553bb37b2ab52feacf263ca5ddce3c6dcf3afb6c68ccaafb33524144e705f0cdbb75e83fa580814a2a4fee8f7d98c6be6bf59669dab95484a438ab817b2f5fc0889939b3b78da41465da52737d84149294992ec411ba4f7424370b9719669869716297a9c148df3ae55f73abc867f7d76097c2574a7174e15fc4b5d50872ff9cb2964ca2ed5ddddf1812f35fc69d5fdb80abae8d75daa1493d1578809932f5f5adedddddd9ff6a8466d956e8f8d5a4dfbeeb92f1eca300c23e6a373c2501a44560d45436b9e0685a0daf7a980a23e5c0939aa3fb42851da2729d79e5909b51feb2fd4deb5cdb25578f36db291826a2d8b14b8fa2f14285d52529ea4a43cd12289249ee8d2c4d2d258c9501aee2bba0e349c759bb33f206ba571c23929dd710ffc81f21361cfafcad1771f6c20e857a41454f9cde840c30eabc293199c407a6bcca8b1f6f311b5e75c7d50fa7df40616e7c7829da385ac038a66a95dcd7c41ff8e42b9621f0cf10b7d364b8dcf9a4fa4b1eb86b74383d0b75016640213c8c8ec1eb19732945232b38c531e716c7759d37380809a00654f81eca380fcaa3032fae7de70f4ecb47f2b30b30068a0fb11e8df0f05546a0876529c862a55765f3c7834b83c1adce769707757fe569b06b7f31aafd9d75e40bfbf705d2b2846825acccc2c9955df2da9115d59798286da5f1bb1f7d0f323a4e74748ef7e1c04ef0a614dec8b086145212cd5673df1e5f7133beff66e2a5c5b2af69bc4e54a9dbfbf836b2583515ad92589b667ec53fdf601a558d83ef5a90f889b5fa722807d60830cce5feda7170aa9a1f6a86deaeaeeee0b3f2108e67ae033f13fb29fff237b08ec6826557e33a9f2db3ef3683a677b17ba66f6d042c37dcd6c57270e7a784a32425d2514e4b0bcdb02ca7533b804e599066bd720af409edf1f00196cc006a7084f34039bd3c2fad81a5cf931b038d10651962455dea6ba5d2a7f0536c747f658d095e734c19e2bf77eac2d53d897419ca05ca5122ace2dd719f639b22f7bc9adfcdc23f27cba867b40df091535d4910197989d6de1bdd2c44e287f051a87824ddc6ecb8f908406a8fda1571b209f90f168b0f7b5e2b1e113da3d1a0dead8b08d04ec09fd08c09e5731a0a83a27a5fc3d8f5461bfac9edec67e56ece3b9c1b59253583e494a8202a5698b1042114350ba326504fdbbbbaca40b13264aaa50a7d6feb033298defef1f90d7ac8a05195f7ecbda9517d2ee419d9d16dd8dceb4caa2a32d550175a13852523718fe905570a4a4822e5e18cc0b6630fe19ce9959b675f78f20723d7cecb7e6b01f52ca7010ab7f22848c0f50647c80a2a4944489a5244bfe5c8f80c2748416a10a0ae84f038b653f9ffd1f3e8ba5fafbecfba781c552fb53450985727f74f78695800285092682824aa8abb484117fc1822d4f9858efa44b19dd37c77f7fd0cdd05ed6c90cea1ae999f891e5ade195df8ddce539f15f04959f1da9b22fb514d82f5569d506d45daa61a8ee60e4853f7b8b880921a0404dfa81e2cf0f9bc90b1afafcecbde51ee439254041819af4641f1f0828eb57f64c2a16a26abf9f263dd8c7e79ef8fdfc3451f1c49fc0b2a2b601c58f5bcf3df60179150bfef1e30784bdefa77e59d293f1531fd0fc38bf75a075e2b2f1901050931eedb1073202d23e36f21a1ed201ea63232ed8a7da4f4581f9d8f764af7d3f4df6b517c2eaaf67fea878522f84c57d13150f50931ed473a5c04f10b3b09f8159d803a154fbc1d0335ffb7e7a780dff0496e5e3e535ec427db84da9cfc96bb2af5b5e93cd07dabe16c21ea5f1872d5419fb80fce7a7daeccb1e7b1632ec81e4671f0b1890d7ecd74b610fa528e0ef4abc865b3ee42da45ef29ceea55e1687def21a969605fd1a7aab72f7521f35c84b6dd420ff26a49b0a4d71bd76f77f47c78d0697bf30e2a8fa57c6f622e8462d647e75ec34b87fa5f2f7f2224992224746a4808179b98290b06dc9d6d86609d6060a3bbf79a8a75e5f714531c462c2a47154dc6fddfe432ec291eacd9be12f64241aff16c2c9698855a4c4941a32d2875cc4b193cd0940d3efa618bf947ecca7da3ee637a0dba8440ff6243154340300000aa314000020100c064422b150389e29d2247b14000a73864c805234944643591224318c428818420c308400600c101a1ada2600cfb45151019851a3f4ca9642e3cbc9e9e230c410bddca5922151eb6290133dc8040710390dfa9d5f2ee64468b80d7bbbf9b50c6a5f8db9db7bc1bcdb5b99a8ab1417d21efb8839dd7eef530afce31d0b0d48aba7fd31c98afc201dd4ad87cf68586ae87da0b73c0051f036bce1c9f10bb9d9ca75d0a548cfc2f04b21e143bb30cbabc158702965b9984b789d054b0fe099a6802f25f61e62abbcaea765bbdc3e6cbcc26b135de1d173f2bf57e8fc0fd30dfe28c902297d465cd2c6071cc1711a58b54da2af8dcd35eff98c8983a40eba74339db4b835795e46ed6de5bf7680a20161c46f356cd46ec6ace0e307005ee094ef35939c959e05e7502ed346a00d948eb664b84ea0fd76602d2c4df7c0c0e85432409a2e4ff07d3efac79862deae4ae6633d0f8980bedf9e1d6d4f3f185b9bec6e75b0a20ac2292149b94301ff592d1152560019f0896466a9bc403f9a3a599624420d5414ebcbb4642be8297680a4394efa251dbb909bfb856a465519e302c1d58c73c26f1cd072508acb8e4f6c0de5976b654bc022c0bf059154ec50115f6a43a7fe5d5c351cc885a1c8a568492fc6688f56678ff62d926b0cd78a9db13e0437b320f81ae1533d5d9f233600ba074ebb18800db48727f031e718641a090c8c3051827e9e649f29567b897d1d03dbb5b1bda355624c9becb19a793a07af76844b36b903f3eed7d13bc65189837eb28f5a6ff06a5ae00af533206d9a0b10e636db6ea0df0585da3706480490c8821838ff5b65cac4af862f75ab69fb17df951268f7ace8eca935978cab224883c18b96d60c48f77c51cbd60b0d162becee62040fe7e8f281813cd569aee986fa4a2abdcd66322ea8891ed04b10f5ace5e7bdad198ddafd2634dac9fcbd12c25e01de377a1280ad60b6d78717668c492518025b6363f5666e28537bc547ce8f0b61814684452c48ad1b77e60a60f81578d9710730185fcd868486b2977a5b38bab058db322207ff6c23a064ce0472356f9fb72e5d0769ce2d49b3690636f2adb9e9937e03fbeef0207049a13003c28153d0762e5eb25e380af784f8966daf63e9870d52d2787c02fac858b4c47d6105379ae144801d963e187d1cddfca6730e8bdc4a816e28752552286f7d182c57429cfdc376ef3d673a9e8e43080a275dba9512541f6c2c8bdb9bc08e030479e366609660917d9dc516f60c1694faba7be3b49eed38f89322139d6bbf14204b46ed3c8c0477000be3d3e3a8529c1983019e5b87b7362baee849a4e7bc9e5798c2979f3909288113db26d78ad91258c30585b7fd390efa1a9ae0ca5af938e648e1a06021a961ea51a796e5c29a0eda16a72c8b298aad7af5badfb3dba5fd94f5da8ee00ea751e8675a6180e552e03d9f01cd087876a7bcaa3266fc40f652ff305dc5cb87b22b7f6f32c7d0a69ed5d56baf6924935c72733ec42e7a5342072a5e0c7977645060151b4ebf484ef608807c17baae0cce493f20bd65f20f3d00cd5857f5584a05863760897937d0b04f8ea5d85cf263fe26341e0d0896fcd69d58dbb6ff00514d4cb0ad7cdeaa005bde134efe0862e7ae15dfab73e63d81905206e6363ba1a3475e15bc721bc90e92568481d88b641266488435d6d3dde216eed4fdf199359e04c5ae0dbdf5c3a50de72f2f452cba382b003b584abaab53659757b51f6ccebe345a9ee57ac148f806c0f7a4b386e32a765651a45d14b7405708a8d8c7114db2b1e13cca7e9ed21d465256c6c1a6d0143bbdb3600287fac95b9d13b4cc504ab3e4e5d97d5fd028ae8a92557592f2012afe7990db1b9ee1bca96ede4d3c4bbdec8c979ce08569112729833c93d108d91b7e0212ff9f2e484f03d297edf234fbb4f1833a5628b9a1add0ce938bf5b50b1399b8341c17ef00520c6a10bcdb878826bac303a286e00be168961dcc83115f5d1eff3521c85569ea590cb4da5eff5c2ccff80546487f15e8d6dedf2a81c60aa8e103466dc75bf52c691f731dbbeb9044ffe12da857b36d23007136e7b24f1d3db28db579c0470ca200692ac2a3bbb79abf16aa53d97c3d4b2dcff097bf68563d9dd21be546e641da3c60689db8417fa5fc6aead8d4484fea1c55ab3a2b24b851752fcd4e74ce7473d036ef03a3df503c2947de0983e82648e7c9685b37f8d246ec786157689df0362f91b6887737efb7f4acea4707cae198add6e9e176aae46c956fd416bdf44e8d4ef0c1415bd8e305e8c3b52603186061dac74f078d86f0cefad81b6524dc9e89cde71bcf73ad0db24c805349958a17922452adefce8cdddaa0eb1f553b006e6d8825a41760241c8f45e6805cf5aebb45000187fc99f2c91879aedafd7a8eaeab9db19ae57a65fb9ace508b8253a279d96fdd3dfdcc9ddfa85e0a7fb57112417d9e741625f337ce2a6569362e8f87e159952ccf799783c830d5199443e66c30e0fc95acb1b431a30ae451a56c94e98039899d9f2ea24598cc7b3f6d363a5b6248425be3c213165574a24b8c867a3dc4b43643410a826568a0e1891131b22f42006136368ad666e5d429a28e46473f157e98374559d29223b4a5314c4072e1a8b0080c1c1073a484f09504e8f30264ab5c5c1edc05d8e2f9fbcd4b86be5b6774dbf3bf3c10c51705cde0ccfe45f19c056288801e5768da31fb4d112fb4a0a827164d33526bad5c4a38d966731f36d792f3636c50267a092c5f52150b665896f1941f2d2a6aea15033805ea2465fafdfa94d2450d4acfb45e6c91bc48c2807b50da164cca7d848e8211656ab39d15febff3678c214ae11201b4beb9ae8b5f075b4e17a0b08f1ecef2dc53624743e20eaf33da156f216532f64a4dfda7e2f98be5241c96426e9a4dfc500dce2f202e276d59ed82002528555407d9a8b216d7db0e4c79621cc76579e6cc7ac2e8ddbdf2c1aaf8f263f0002b0410a50cdda8eaee3fe413c1d5ff6c8b55666e6de9947c21b952d650f112abb16af715c9b3525a59415724ac4fd808fdef64de05d91f43a10a36da60d2e847e3694f82686c174a00c84de0207f9ba02d20b1e73dd60fd645372245041c0be35f37a46cc77b83240f882950a6912e1be9de86b355c99d87d880cbeea3426c06ec937927c65f4edf5ed52dc224a3d280714ecb67490569c92db668bb78c7ce42e41e16f28089611362e5ae459d1f105d11947dee239fcc91350de0e42946e0f202308a80445749decebaa4a7c13f634acf318b3b0a74327ef2f7890a40162969c29ed09152804966498ada0e7cc6c2d3c6345647c6f8ec41093c7e30b0022ae3111e80efeae238fd5eb426c3c2cf35f81fcf370fb93155754fe8763d7d32880ce330beefeacc904feb219491e1845e96a950e2523a9e6f5229aa90132d071b8b1e9cba1e29d56fdaca15c0b940731a31176ffcf6f9c3ace50877b5f3e2eead764a2b447442af776799df1092c83f7bf9b561783321e18ff9c82fa043b7067a06a1a7cbeb3a534bf9424a8cd89ebfd375ddab26c0a932800dd0000d53d4ccafc649d8ebcce4a54fad78fbed1f4616ca5b16100def77b8107b14ab05fcfac65f23d81abd3e9a2ce180e3c10bf60352d6b1b460857c52c3210baee9715b94b39ecd3c97e95f5e3dd2d7babb1e6c4eec7fed7c6fa55d5c8b5d615314ef9e36c6c34427e5a7e8fafbc99343030489ba20af84c7c3fae2cff247a234afa1f9592ded8203578b1f80eff5c3a07be6d3c0a94131fb4c10571c8379d0d422eb743a993848abd36accd3ed0629e262279b3950f20061cf3d99d8afb7c0918cf1a045cbb793b1608205c52ab32cb6a89361319f3bbd6b1fb330595552ae19954b7fca5433bc9e413ef398e41ac00e08c220f8b58eea709e4b90f8829b4287a2c770dedff1278a6ec97d1900e3c3e84e35db91841e11c3693f44e867f51c2188968a1a79d24aa8e41ea4ec0b9e6c9080922e1b75d8d3f00dd21cb468cc23204180659cfe07812fa7b171800367e00fae60590120ffba117dbaff94556f5f7dbdf5fd126e3cb1fef00c8893c4f60138f6863fc4278f089e247add297f86dcf4aa5fb0156196639901e183074eda75efe1c40b5a87f289f2e6a21c6213a8083369a1f835b74d6c8741eff024e7f1852c0ed554881327236c7b04e18d495a8e99cb22289207518d8d36e1b0f98522f4b376f0b30cdb1bb326f77ebd949bf354d052a1e52dabb3d0846d2f12ec85e44b32afdc50b8ef43e4661ee4f8189009517b98033f8fba3e58155fa77605fef0a0a04d5ae9224236d0c5228c695a48a67eb09d0c5a998bd281da0115c50d438f19331b42e51210506418e64064d11d10700c5bf87aed1e270e2b65052e98ddb6caa101c20b1a9f57c880435a6cf0a3ffea5c83694f2bdf6caf32e183a2b344ed92d9a54fbbc2d605a78edbc3bfa02b57da010fd9725b69f3863d0a28fa9f17ae66acfe5240d072e48bef1426f375c6d6875d0ce3c044eec0daf61dcab54aa04cd44f97fba40d4d88f30ccd08f26d24db57050c640687a9a199ccb1c2fe058325a4b9b43b3860c6abb49a6f85d4f6751f25fde8eef2241c31844c4bc36a2fa1f3e5867929f37684c1d14abf247ff53b1edc8507c0ff76464b68db3c12c3b5889fcfec2a47d0a35185a9615f8c8be63c95a7aff06f8f3318e5a2141746d8d41363251c386f09f4daa7a391f2e4c1a82583f4cbc73e9d5de5271786e73b2e277bb63d4a27633c902c7810eca6c2db134463b2ef38b21749c708e2d949157d97a645b792db50f23e0969064bba67dcb2ceb7d5aae4dbd60aa3097d979d361341146a7d343b42e51dbbebaa4eadbc21ce0f2815097cb0508c9e3ed6d8fb692d466bfc1edf1b2758e11f00acb397041d9f910aa401c476738145d8e2da15821c87acc3d95589fd293beca5bb9fcd1eea4cbec0db7de335e5fb5249b89a1688d9c40dd884bda315a1e55bfcc5bfb9370a17476765596d25dda2f889b8bc66868d209fc8638e415f0cada750ea232c6a793aa64e38c0d49a7412fe9948f31f867a0e98c026ba719eecd328b73c1f954f0b63085971cc1823be1ef9148c41c38777fa21b1ed374064aac6778a8a9e3dab4755928af5025237ff98b89661366bd702e2f70be7d67a4608828d86154271f9349b02751e0030a4711abdb4799d80bc9b34527baa6a58de8a1bff5e7fcbb71c505560c6e70bcf5c58642045794b7e85fccf924caf469f2e83dbd4dce90588ead3606c12afd46c1b6587ac8aecef66136370eaac6fbf9142d344448c9fa7f29a44320d8f3655847c06feef6d65a2a26bdc25cb2081eb7f98bb3f9feab89c6bee2c457c315e5d4b0c80c5e94b94ce295a31990d6a18b9b4fa550c82f1490a437ce3c90f3ddaca51e892411f7a4eb3648cd332b2f81a68b7a60a87879997d748887d5dd3a6a6578a98e8bc3eeb78b9e40544a4dfbbe2903ec7bc879f51b00e33e5b59defa5adc3aa39e668aadfc08b42daa5209dab4b9dba5d98c6a3f12e00a3c5b455d1506e110050a15f135e06790fb49cc5259a9eb616e600c4d27a279d6ec272f4b73b5a4f8165c2350523a1e0aa69ffff57e54147216c7ee780a0072513c430a29a1ec5ca7cf4ebb8e4595162380a0f77861316828ca47374cd61e3393b36e40f7c9e5111ac710ccf0bd6b0815061820adee301768752f0a759cb219343416fabc042357fd143dda81774a865dba41904349eda712121c5ded7ef5fcd131952c3d016775cb5b61593625aba23d041568d31cc7d4132f8fd644770a4a5fc9deb28d073f225a8ee7534701ba3d240c7a6605cbfd8155b27fc6799a4e1239e29cf110db55ce5e20b38c33b3adb49987dac8a5b877f7d067cbf721d7073879347270a528733971e87ef318d3386de7a77a87a212648f2fd6778de2988508bd9f4f2d99ef9a3f461229aa1d3aeb46581ec0f2ffe2ceb08878dd9c599a5b25fd13a57e698c332135f3707b5b9d64a0da08eae159bc9d605b683f6802bcfef7fab771cad584cae63fdbf9521db0e066432d8e7f17685e5f6fe92abe10fdde2151d0d2321c2a8148d10ff4138f63fb9b1c862c5f2afa6221472d14db06f9770028c9007c426e18658c24f6f4cbd06fbd1a5182c920c6cc4a2a2631fa4ddabd21e786ccb3215e87f24dc2c3159c693afca6416cb3168fb200029b728a23549635c8a8943b69ea89a113f57a448ac548c1dfbc747c8b75d888451a660a47e1c9278fbc5dbab6e843918d788c66ec634af895925d9522e9a060463197d5d80613841827bcc22d714c8643ddd12991da40d766314511d420743b59187815e1b06e63caacb6f673a944b781ae9d95cce0a684611d70e86428c421fa6134e00efab882b4e6e468b2018f6d59be986a198225ad01d20ae21a42d6006f5cd7ae06f67edd443201c274e99e0099bbc47c022ba01c6d8969872a5183c58397558e008ada6ee4ea3e4b80d9285eb390111fbd2a773d5e487d08a0748b5848240edae13de2db1dd3f0a7d01d8a962217a92003db2046e706ad27962f9f8fbc141aef1caaad7de40778b8b757bca3c4d340befdd50aed43b7ac2e1613bb337982884b47f75ba9ea8fdcb1968f939b2ab90f8ddedbbe17d3f345dca2921695425eba9d61b48702f17395e32d24263299ea9a35de8c49fd6796ce5342f1a2d26300d90dc789e3679f4109e7d0fa9963be5cb048786ff5559c5596e040290f1eb6ad1f4df3f93a01dbcf4855514919c2cfb174cc4f03a1aa3dc2a1dede485b16ac3a9749b9420761dd2d70ceaf04f92daff4be6f03834cc0eff37b38177a171804000d5573e2b4ce5998fb296070879f9f4571e61c2ed78598559c5b217c3c7866ce52e5998655c679f43ecfbcd055ac48a81af2ba7d151d295eeb933caa58c9f508c9f86ed675ba20b5cc9e7352208f939a103ca2f164e658dd01fcca7524e5e963ec9ae2517be1f69ba3ccbe8df1f65e565197ff9552f1428b0ee1445f01177f28af03ca6f3434c120f04154990a0f91f1090e9a323f0bae498b91dca3f14eeca78f210d96303343ef4235037418a9f7fdd72cccfe850a6e4c47ca23e4eeb9b6cee1f83647781cce9277b4f41dc6b7793e2b27c4c8c186688da8d4ee1f81f44245a10577440406ed496edfb96ca23c636f75489334a81ea58c438270d60dc8b61b5fa2f0dc756fe9593e623bfcb8ccd5516c906f9672c51cd31cc452606ac662ac1fe2d65c18798f40895d1016b98bad17745099d8645c16016153c11673d1cc2d05d083b08061e66a5a25ca6c07bf782200aa82f36d6e282f4d6bb036938e819df0247060f27a08e80b0fb048c7aea39ef25874af96b7cca606731d2315ef4ffae78280016124b092bf0e00c6d94c98ffc9a9ee11b02bfa403c2a9896375a501464eefe342d519541cb33d807b0ac8036d5f6ccf85f09cd8f79ade7570b7bce9641edd35654c38c3cec3b67022c40152d6d00e8d340025f95bd64b0132ab2925c7929cc692b5fec458a2fdc3817b24876958cfcac8cd4d3afcf79de99652ae9719763e3c4ca6947711581a25062f8bab47dfc0b20c171db507f67df9a22f28ac5ef24552535891fe7fbea4ef15242b2c4ef31df3494dcd720c088bd2cca466198a44f03c2f4dcd9a782b3434cb044e5aaa0f7512ef3dd32d9537e098b55dd33c18de4f24f73f7af927bba3c7915e1fc93a38a5b9f9e993c1c9a17b257b86bf3077a547bdc40fc9474384b0b50d912523add5ecb54ab1fc1e48b7154a381f5203b700616d3a34796103d0c49eaa2864ec9e4b7203bb0a3a100bba733d18e1155619b09619ce756db14e6384d23c2b4764a401285b2cf1bfb32888a1077d0de9f047a9cad26f6fdda22c65b947c521f247367586ba46ce3a5c1ca6091c677e56a5e0b9af919179a6cf9366722dc779ad4458d5adf40f6f0671a3f78d54a2631a6abaa489f9603a82f4b31bf70738f1e64bace59ceae66640f46b6e3f25dc051177594cddb84063883d6c6e3ab2aa3e2f5bddb894a16b25c95970a630e6f2fe42b5c1f11901273876310693ca6e19ed77602a3842f1b2069c01bcb13b16ed80d0342bf3de0b05662dcd10da1f5092a38c5894639a0db6a0e62058b00c53abd56811f7cecf3927fbaac1804853a478ee0d1b52121110e52ab8f2ba79771c864de8a3526f5430ba4ee8decdb81d60bdea0181b56d91a6ffbbb4bf0442f1926b3e8e1e15e71005e8f1a20e27e35ea76cc162497604dfd9d0ed3b542ba8ead33dcd7b830e3ce1b12fd1f0353f1f45eea6d62a423502b9b364ffa6b92dc05bfd3ab1e0deaa79a2e42ecffc9d57647f1f3e01ff4a3a7499f8d863ec7a0593a0ea4d94efdfc5fbc38c996df201f174f0b32ff6e8af22446eb9c2002d4a7b30ac8c6c5d77052bba7ca078af639a39f8a470870e57bacdf51018363cff4233633e5490930d98ae9471750e915d0a456e7f60a3f6c646933333c5eec11aa345457c8517bbd13acadd4bc2773c03ec7652e80425c68e8ab97a357ee35312ed0474bdb5a1539cb22d8e10a87c70eefd8b9f26994e8b3a14fadf39450459e4ad2136e58c5bdd44a861db1d8892c10e1523774f8321dca50264f6fb5fc4578418546975e68332dc42d884e5965be52bc45272020dde40fa65a0f67add422dd70d25d3ed54a14c5618b7ad30beaeaf6d54b9cc6631ba176a3e7ae4c6d4f70a8e92f2b40493da63b7c37a98861d90f29a462a30f5e2c4a7ab9699b0d104b1aa8279e87831e51ee3bfafc1d3358cb9ea7e3694269954ec3e8705d42703d664722059c47c1bf837894ed15e247e23dd745e3d8397cb728204482bdb5c614de4692adef7110af2958dde7144e0d5fa696fed12354895d931765794e2e4c16eb89b5b2265444bd152914f62cea7c9330dcb37f9a0e32aa0a9ff651562924fee39bc24eef1e5189f7bf3efb3fa6ff27c0009890f2db33c298a22c0cf419e576a058afefc0a8fb3f9078cf344c58f8b063a683f833d2d2fbb057f0982b88a87d2b3155cc32223d1893dda8a207f46777e33bae1f58b6973325fb613fe57e8001bff08f219cdb20a9314de5bbea6225b1e781aaf796cef47c3e826c414ca71f0f85da08b7fdce7fcd7613823103f6a17f4a38a87e144163fd8aa5bfb6230ee684210bd70f3867ee4154505b74f00c62aba397d81e42bb492dbbe697de556dd1d33df7de63ad51e02ef888121854a850f93d9a222629591e19ffe309bdb1b9b9fd3eb25dc1df0e8491c19cd6ff40f2b2da332896c368eaaf581c83e8bffbe8416c86c6a6c34de30966865e927895d4b46b931f826cc11b94828737435dafa4f9558dd97b6fb0dbdeb7b71397c106de0b04edc022cf3dafde623e9f5481a6b7502697268fd49fbaa4fdce873991b553d36616614ad0a0ed37805522e4af6a952c397cb54294f4480fd3a06655c15d88f1f8c2612bc696f874a128f4ff25468d726ece0a80468e08a2bb16f9ec681365690b7461db8ffb4445adddfe973b19bad28fef28d812069e3c9a07c36698ac665c9a4f77c57fb7670f9279a8b6fb030739b53fadd4622d9323fe0254f06bb74c23982b0e2525db8b8d0a370cbb062570a2aa64c15210ba0bf5a19052dcb86ec6cd2936e927a013a45fb6914a3318c59041ef1d5ac6aa08b39c0d5bfb5cbc28ac0e7da844b0ccf03db957900f1952c60ccb413f53d801c15bec5d7678fc9f496bbf36cd20cd8068dba111307d93428b1ce410b3e2cdfdf5493d43a0b3a6881b0ee411a0b16e3a4e65350cdbbec972903ef25d18c8470b3b594044766593d887b211aebff1cfe9e2f022a56ec4fd6573a04938c9cc554569f3e8e8d391a8defc44bb3098a63dcc9595f43d73da9e0f41554fc9d7ddc23f1ca6bdfc60cd411ba7d8bc2c4ad05beb66e6eac530df71d59287b7ab247e52d74d27a61ce98a4aed40ade9eaafdc282a8e967e24043f299b5ef2705b5ca5c1b34707c75976d2b0a18b785b3388f8b6ca340a7d3d8a5f7ca1e40e7a370d48066eb8a0a36ec4fd854aabe6bdc8f7431bf22cf31fdc79192a4003ef0bf40c2c3f4bea46609293d7b0e3eb8065a5d3cef62c4dcf053f12c1a857e65bd9458605bbaf99a93b9d987accd003841a32cb60351735979967cfade3c2a8a69aea7e9a0788b2e779272ce4e359d2e5359086f79aa56417b722f375b3477af4d2fa2df811a15ca84e2a2bb0445a452e70df980a8746d658a442415ade9985ee34159d30fbe95817cd58b9b27c87a077b011e5e8b68602533556d20e4d9d057a46a697d79882911c99949fb1d659f521dc3263bcf4453dab3ff94c7d8b12bd81d17e22a144ddfa6b250d6efd11fc906b511fb5541083bff7c71929575ecd4d830a8eebf03a136ece40351c6b89c2ad14dd6413031c7ec8c5407604f4c3821b032b280914ee9be88a57ca953ba77e3c83884e912425ad2d8a15a73b8307a72e696634bfc6b74c8da6498bc9153e8aa15383694d045f325b0765c1ab48ee88558366e18d46010a3bfd5d7595f9944e2e0f39b2e02a2190069f3396bc04d66ea8ee1aa719047a175048150cc4ed6b8745d147f1b6dd266e896c5ea1e93b357087837864f3e88fdc98d4ece64b14a19736483e664f945cb0e38eaf0cb50af122620833064ff7fb307b6f06a494eb6056b4ab3ab84dd8698672deb25c390b0171d19ee6623e4f47b0a9e64b8e36fb3b1abc2210fdba6f3c94138f66720a85be5e025eeacfcb80d75eaa9918bbebd914f998b9c3ef581b465445cec8541b96ec4d9299156730a0bca221fb38421ad31a90bdee4b4a215fe8171f531900830a7209a245b3a6b8d02854410b06289263718fc6d08a492ee5b6a506985ed8138b7e00000c6f4b7ded35e6fcea4f614b8916161a588355a063061c242c0a5cac779cf927a3f88ded44efd55f142eb8be316649e3b7fdb029a23d638abb0f68358877423c6caed110e57a76a051c287f51b87000acad0344270991de63991ab3ade4738ecdf6bbf48eac914086397b7032f61f483d83f535ec19a4e4a5eb3bf6dcd1efc4ac50de291e9a8d2d3f99f6b812b855ef641ad9ac86a9ac6336929de869c9ca0b6e2bbccd1204dbcdbc8dfa470f4742d783a92513f4a0cfd22731ef3b0afd14fbf05b5329be949ee4e3fd5d76c59b5804127cc1ef2c7ddeba106b33858f2f62305dc5b75951c395f3bf0f1cd4d54251db70a39fc6b631065f70d83454f6b5517ea49055b491cb0ca561b16d0ad241057f02007426e8148d9d4669cc47f38e1948816e8457152d3b59a74b315772f5a11ae842ecd978b150c20f336f6226bf0367513ac98201ba2465b9e4745740f3e46a920a75cc052b69d0d41a42c46695c76210d748f57e889dd77c0706ccb7d629a946a12c7c21d560b273618333411114ac4e933bae43c063e86672463710b8b57b155f96b2a8fe0b7614e0f6cc8bc9d76a268328a94b5afdfd134d42c35e6e35c506cf7fecd518e311063c929cee93f701844925b80503fd58513058e7308ba981b98fe5e23ded26918d81137923b5dda76430e5eb6e7cbf53161a160770f28601873fc0c73dd7b843142ca56ea388d8673a8ce160f4908c60ef0b49d2489f225c84f3c208c0a8e719e201801c19205156fbcf6926a8d60cf69d1bd28f65f80893a0535b4023c25d713ce9be17e4c839505320c18c2835237fdb6cc5e124c766e659a17637c6dad1bac49ad6919c8b7a1318c687513f876386da7e77a99c001be4499642d9922ebd3a302cbaee4cf7f5a9bd322e5c5ac58ab0fd250d4ce4987bb213ab5c3e75f07fe0d540b6ebaa8b0f92bc6d84770def2ce2c1c905e4e545118fd15383b8c7ace311869db2e6d3ea488509ac157328547c8cd2e50c88fccc0340c00948899be0306ee576999e31c0607ce173cea4853fb765f444a0d753e47f63d7ea6be648c1bfcc60308abe7d862c68a1a90a87bec1b8b15ebe16128d346b6dfb03a1a7ba90477a3d81a3bf434a4790a5137e1c7ed64304d75e026467be2423121e955a87dfe82fedce59aa263baa83a1da5f83c2dcb51292e5fad1cf24a93472c58160964f139e3242db3f75ffe4eda4825c1bde6ebd7aa2b503bbaad18072ef1aee2932cb7c7d854b2f4499ecac1a921e40c8ffb8e6fff2450d2e3430eb9018f8c69f2dc707513cf522d5734d2acb91f150a9ea542e5daed3449809f8e76723154e3d0c76ee4a656d07df3bb452bfd872a270db53e5439706fb6ff2dd88c435bb113ca57f2ffe70d9fdcfdc41340ad89803bbaec959dfe9a32d8138f176793b6040cd4c54aea0a34525f18efc6523faa6b3ec7e4b39eb491441f6ca53e69613d3418002d92f9ece907b50f1a8e3fe1c77368d05887293770bc692b02640d9e6f36d47c00217f4d199fadf75066f2fac4bd3a836de016d9b669cbb31c41d05a5c8a00b9d69dd8d1c94ac1092b891b7aaaf62c2e7d22766841a3bebdf390fa669791f24559dedff72c32fcc9c97bb9b8b13445a2d4f76c6971daa55c2284c41851629b88fb113f138a6a5ff521b34a845eed5b2904e8f5ee2a2fffa07007ad637fa7519ca5a315b536c909aced28a720d6f2ad62ea4c7b48399d27a32a20bce288e8ea3228ce97967043e7e1e06295159ab85d7d805e01e86f312834bbdffa02a5ff2601a7b2459ea9f030eff49df6d3962580917863f2c89e32c66d68b940c424f894113aeebb6d3e857c71540ae5c9a0dd96c491c43295946ad467902f196103d54a33523529cbabb8b82c04a875546749a7a975320d0c201ee704dcb30e91890573fe6348a0d0f37f79badebef3cd1306fc4dbb7db1744aa045eceb66fa66bb2e171efacb4e1f0758fc77b6aadc819b1a7d94d389600384b3eb4946870b5f9680c28e6734d8111ab4dcab7e56511d375aec6001fa7dcea48c3236dbbb80836ab9b6b5b75f4ec4eebe3d2e8d64c5ead9e6c0e6d98c89f911de90ff118bb6e2039f0dbb55bc820fbf9b436071ae80ae64edf5d8cb85fdb7b7a0e21f02d24df941da8c5010b5a27db34681e704391d3b4d771d7ccb471a303a258955cf4cca0146459c903d21854a91373d06101419ee3b52976496710448db0ed5f4b557f670ed2cf5a763b790e18ee88a8e2aa86e03a07d564a394ca4d8c98bcb2f2c48b9903d9344c4432a9dca485a15277155bd38a0aa3dd34f3b5ec24580b8cea5c45b2469ab8ba6cfefe3e7e639082aec95ca0ecd616ab9774b83a099c0632b4fdc2a23210486dd1b6889c4825e3285e0672f88f93a3481ed4e0545b85fc4ca31a2c584a2b4b0fc27dafdc337ef604c5dccebf69acfd0763c6d1b26c665c0616dee4dee5d2d7b80cd332cf84586382824072d7c3a9a71cf02f3406b7f11cc2004822701108c4636aebf80d2f07e55b38331b4e496fc05eb00ae9370d33720da213a1dde48dc65c94eab29da2268a1eee83c5d6801fbf24152fec6033c4fc55bd14b56223d5c48da0e78559c6f6bb31bd2fed400bfd6da3311e96839a62a3527a9e1f616124751451bf8e77561693f0da1f0bd30dc005aadeec77d4070778f469ea4ba277d38c871a2b8312f4100bdc2dd7831bff46ad639741fb1eeb69bd2130c3a20afc0ea4867f04c80d112909834799749b25333a238a434fe1b9a947110d260bcbd01e80b69dfd408101180aa984e0a5f99f2f6e240e3e8584ab53766170d13100b7c95960d0cd37ba3c85cf48055414c57ff8f94df64caa0d624d36eac6d059f11ef76cff51755531ae9dc235fe0b3a55e3a852e73481159dfb1471ef6ea06f97cdbf859045ff4dd7a89c2014b4d4925b96179739f0724fcb445bc3296afdb13024f9eb54be0712671d94acbddd88a4d27850b90c1ac76a4c255a2aa611ca2d16c58a383f73f86c62b61ef2be35864f9bcaf1a08b9b89a7605b93e6edd011875e7ca6587ef6cd2305199a5c4030c6341e559ff7d4cc87a87085e69dc70c230ca46327e718189dcdee089f7f72581b61e314c3b376c3072d8e75de464420a86f7d64d8245916e3d71fa7b1021f1bb1815baf4f4ceb1eb87a8dc136f17a8130228f559f4637a94295e9d951f1e3ac48c1a9cdd9c26bd407b6ca7efb78206285b7b76eaf6518d2decee7d6895b3d28e6e2873a896b0bdb5b18aa822e68aa9d91f1f5a70c489d5e3b7dd6815adb6482a3e8861cfc9610c1569f967607e0b4685861e6cab162d4ccc78072c72fc86e6325a66168442461eb5dabe01979f07bfaf80db00b0109274506f0476588f7c150d3c6a377c2aff2e08a7b316efc89ddde2b8bbdf26ed0876f478fe224aaf9ff74e094834deb59bcd3bea1e64c7bffd439d85ba11a930c5d53843701821a772254eca30a85cd43052341e72d19c7ce1a6fb91ca23fd3001ab526c1b9c0ed518857d18bbc1e2caa0b0b3a35e6a7853ef283f2ae9a2572d1ceca57b3169313aab34cd6a8d920c2625458cac4d57df04e48bfc16f8b974e178909535e26b965ae2ca251c881a995c6fb6206cee30a49dfb6e91ef822780527430c5ade57c0572e37f43d6a86d6a62211061c1b27cfd824320963cea0bfdc0e6123ef780afe27f4c0b5a3472cae09a9d1bfd5855ca6c6b0e214f2a2dd0104b027b518356adfb12dbfda7772f26ce6f9c98f0e9d8ef19fa4ff34677a3d233c41c0fa424bfa7e34261c39156d7b7328100db7fd1f3242db62172e3371b2735ca7d4e67d2f3b98e04a0fd74b9fc3f555e3ccbd3d024bb482758fd9acf44c8d88bf73105031e162bdb9ef7c2f9c08ae7f771c32bd945a0550e17c00f8c66835e9d7970f9850eafd31107efc955143254bcc9a67ba36013176080185504228c705d0a4e6c7c8f2c1792c79163206efa5deab2ab97b2986c4d8248e0b1368ef585981b11045edb837d014d0110c64d9eb5d79cde7192ad70d86c1460063f80abbd69c944ec1ac1758e2bd239bc49429300054f4bb0368d0cb30213b36d14c4386892fe4d10f19d30e075074f12a507714a853bbadf4f633ee90dfe85fd7939185afc14ce7621cc87e178ac6b9622e61fc09d29554bb5186f23447d8a35e9d36f64b2a0390381677a4dabc577b6dfcd942772eec29d51e1ff351e4cb792a234694da0a8fa4804d0892f4ef24cfadcb93c767484cb52b912a7d4eb8417e19406fa99414cdb410836a53841fe26ef0fc68933af2a73170c7fed35108f01157df71dd1156ccaf6f7540613e8af39196dda838705d60f1ed1a1bd8ad7178cdfe6e9ddbafc2e61650aaec18fcec6193ef860ba31bc6af99761f5dcde3972e45ac3efb17952a1d7be1792b06dc11928f60b54d856538f41ddb6d57e24f53c19983b8518c97e321720cbacda5702f6cb194e83d0a5a3d2342d262767bb78535b96134196546d064c927bb91b50e7e708f01948ba39158744333d441b68cbcb14416788596ce5a2307638d3b4ee925298dfac9d96475727a8e26a7b950ca53242e88bef7dc34be4461c703953cc3c2fece071e8d8bd5a74ede4b271735394725c28f45a3671dfc136fbbd19b37e834663a272b8421fbfc15fbcef3d18a2cc8bb4e9d9e8cad0f9cc75450148377a698bb949a43fa5067270e6c3f55a5f79da08b0c4a9d0fe4445f82b37497837ead2dece261244d4535e765c6f9ba336fdecbd48c75966d0ebd207289dd62fbd4f0e531fa24bfc4791d8ed5174367a2e16a43840c6aad41e3b93e09691f9923283d1115a2b451efe8a527e8f89b1401dde5161eb0a87f676894ba5145f7bc8b2a2a08e69b940d3b9ddafa9659ff272874f1562a2619bd04f93fde11c9648779c592dea291be88ae8da90c6cba989d911d0ab05250118e56e56395f634c2e4d45bd78d936dbd70100252e56966554caa6e51021d605bd76edffd8f61fcd03606f2318f9a408d03a2605117e2591a326f317dff9872b30104391a0a4ad3f54cfa769f4974168cba0f82ba17041a8135633708a68b665e357e0ad0cd7b1caf45e84ab0f1736336d08a7808109210fc5ad9814c1796bd82db351a3e704b5f123fe9f8f9d30d5685d16f01ea9ad21ca79c214d0bccc97cd9556e2e8d94295bee1131524afcd01346b482f17e3be3be5a9d02c7d4dd9b9fbfd6edd86f65da6905c3f45425b8582ae89049297d46363b7f0a544f80f14905fb306bc7fee6ac69ae40e1b24d9811f9661cec821e7df5ef5110f88d312ac5339a50a1c4e35251d94e0befb8967fa2b906744b832845ece13c1f8e630e1c281789b60ef09e9c5fcdef4e543f042d3c058b5a066772b240b5d1506d45adb3e8293d7b247ef76b1372fcb1ae35a16e24884204d62882f78d7bff054301027a5c6bf0cede50987f0b8e7b1fd76fcf72a8055e76bc52bc814310eb2c9f999e1aedb3766178cb05e81ca38dec64576cc80228e00f1422688ae1e7f56c4f6718692f1d7309f99cb2215b997012bed94b2f08d6a9f4b47e77452d50f50557b6e63d4f524439d35f7a054332857595f77b1ef290b42d4c31c1d2d039c69592b8c671bf57275e5bd72fdb56129954bd5fffedbd64402d9cf0e23060656f70b0d0a31e8ffaed2aa6c2a1482662c8f46b11d682a1835811d0095f85b0f3d30bac7b6784c122056d0058ef4406852339d8141a44eb7a01e4b50240b0b16812758d7e2ebf621afd8508bf8f427f4deb467574e1e9faea1cfb38ad45f19932eea0d97cfe312ba4295a37efdd62152ac47677754d0fd71ca9f355274246f366a1e88cbca7970d74e65d9b7ab5c1aa2ee4e950486a4f71ef0f992546bd326236bd1ef11a692f364788936bbd5a039b8e11df8b082a80737d102d88a92b79a8a151c155a0ca04d2baecdc0102699bb10e6b6d978714ad7d07e092e3a5768598071c76e04e187e285c6fc08caf8563864e91b4cfc884e532966049efb50323ebc8984d8a1170f37ff312af579f545ead37cc8eef25a52796100ada781da94c7b4d5a0a8bfdc1d6f7d0abebf4af09c70a1f9e22c4953a05fcfde3b16e7394e2a0ceca462ced744272ebf47d16d6063e87f730a673312fe1f10412eeb2a74f33410c6302bb4c1b86c2ff362fec2ba113538167cef340bf120a35ca65f74bb98ccc92f6e60efaaadd78fd5ac41432769266e7d7591269e4da2aec889a4a51cfb69ed5f66dab4d38ce39d8b380f7d09d17aaf2d36f0b264225e733581848528bd415474cf066a03503ce3e72bdacd10bb94a5ca304b455c1f0317c3fdb9ef75d7857cc4797b1b37cb05a32d05b4a75bf579ff595025390933fba4df0c9c4e6f3e9aaa423a7233167d7d7037cdab0f6a872c4cca02e35669bb252485dc0fc066d5d13b038ea9a4eab91cc5cd1db21615d00ff7f742a6b8a0df1712a3a74eeb38da4dea4a9104f95f3fe8291e355ac9f4355d4426fa57ac340ec7860043d027ce62a152d54d94e5ed143590344f664f1c0dbdc7b9ad532c277d76fabd94ff85b7f5feecfc3ff9fbcc84c294b073903ed3d098c2cdff1b0f2ee17f474af20bbca5084ddfe2301f0b7152df30e6ed3d7f2bd1c49bb320050c40f7c4edf9666fa385b458bf0a6a55b34d45f03fef9f72c2dfba39890428084c51a675c2507dbd760ac82d69119bda9fb7a35d321ee3bf12c589ec01ed324e05f8fb22f0271660972e363313a355f469b380e495de7dd510fc099ad40ebb169dc1a2112be88a0693cf86dbf47e9b81d2444dd845ebcd236e35e9833c08ea364c4c96456e44108264cba85fed342afc882eec2a273e9b83c65c97a8bba1f51ee2f4aef6f07a96c79933ca373ad08592b8f3f8fae7dc427b363bd8974e287cfc41c8aa62f666bb993d92da350fc1a0284524364fec375f98b9a757959ec0934a34bcedac2181d2ce390f79635b6fe0d3a2f65e471f65e1a99a702a5572b3ed3bb71cccea078c5aa020ca489d505e833c853dd155989f9dbd5619f621c579412d7641ebee51c2c548886a8a9ad18a9b4d4eb102e780effe4f8c28ee094a08a60fe4b35be16eb9c17dddfa30c24e98124429bdc06a4ed71919ffecdec856cba0ab2130739d9ae3267be008f4189a38a1d5370496e39c27d8ba01e975b55e9cc7518654c1867193d074a24b9416df456504780acafaf9a033ead10aa18bbc673d4a562199d32c08f0932fec0c81b941d8dbca840abe1babc68698ca2456953b45abbf823aa18a85a35e66eb7307c9cd4f29c29c4ca55f7f9588a885b963415adb22d0f033fb980398171b15afd2c52a8aab933c2805e32837eef01dba94012a18901e9ab0bdcca10eec7da348bd220fdafd8f35ff27f4a41deb57d04cf8b7fc12b4492f401b96724808ac44f263c40bdd650e945862a2ee90f556bfdfc540c4d43e49581460b48ec146ee9676156feda2a23390a03ec5afc990409e48bde24d00e1167e04f8a2c204211599d378c41cf0dcab8364ea75885520ab190cff3b324c7deaf16b367c17862338a1a4955f87da0a1b5da4ec1cb545d060458dd60fce281012f13e719dbc4dac4ca7f052881123ad6d4136d22e2a4225d85bb8333e9d1d124eb6b15870f57f63664961bb2ec86cc7967940f8c92d04191f2f9ea3ec4f963038bb4c36245e089815874517aa53cb20c050d6cbe57380a65d74b3ed83778602f3e53190c7b21819cb1f2168aaf869a5c57a997d9d7cb2b4df98b2cdba73d1d7742bcecb5beb234b00b6a79415ac596378e61a5953c801c87f467669b355b31bd347aadd7f4f1984ddf9d1de95bab69f2393dc4526db9d8feb911a9dfa805b462cdd825a8eb15864bed323e516fa2581880094463fca5e5f43467cbf4102874c0f228bcd3009dd05c77860c34767e7b038b35034bd705967ea781efa816e9aa97c7e93b4bc933ae9d418ceae0cf2cf42e9ca82b4a8b87045d11dd2c244d9eac00ad4897b9b83cbffaf46f91ee00092e0e6cc7cb533ff384374e05609e9192176f7665f938007fefa9750ecc4ec186d6fbb355a974dda7d9d97d1e9d7ae666b5020951f2d56f9885b9cdffb2f1b59d39743aca9ca6cf1988369e5aa6a0f065b1b7b9a1a81e4f0b77c88a87d709f94af9f15ee23b1c25a28cfc944f4b3dbab1f336883d86380bceef246126f0228e6ea8aa1be83992b91d59e2188a3c0ff1ea6a68b0b12480bd52720e6f2e681cae1ad9b98fcd03eb5d2eeac5888d50a71aee9f0387e09b1467ac24b69ff0364f3ee7e531d0f846cf37a4e36d98e1a7b608feaadce873cb6ef24852cb88043934c3bcf28c6488edee100de2c38af1f8b795f207a57fc5be0f8f81bb0326b8c3f738bed181126f103f20dc8c0f4a7a796fe89858e1da184e7676a2a38f639eddfb9b628e8cca1eb313b10946cd78b4c102aeef53e503119cd142093924846a51e32adf82e51019d4b27598c28b9fad71e743d7d2356dc984a544a7e32a79f4664a7a367933fcc25e818369f672734d7083dc68c3ce667afc8f179fc3876d49948142ce28a279a32a48241ee59ef957c14ddb92d327130f14c315945690c21021db1b571411cd8ae6ae61b042c046020301e89080f673ee0eaf721152d4386ec1de5f08ff8893f0b6bf3a665050703231bbbb9e516f057b56040e1e68e139d38c7c00321b648ee97ea8cd62c2263cef0f4da533140f399631fe3b8b081252414d8a7af9ee09989d1845f4c719c0f031a18f96ec086c1b0383b143e7336a910ca8183b112cca18f2f0e35da8d8382f89ef22a47070cf204c7a981b4288f697d4be99e7e6658652ea6ce4d0f91b2827e0ef18fa6531fb66ed5991218f0fae7fc27967abef1868c4aba354227d4cd408b1fa01921f6650983ea133ebe354c19e694450ae93f9b2ca7297bb4e736d8fc3b50868eaef9bd86ee2ef58ccee62917978b3d4d00dda33a215dfba9328c029b31f5f4e8df522ad3cc211e7e0a988c803ffbc812ea5f0173a2a4f907742e408498191b5a6c767cb377870df4755281d5a3ff99ecac9841baf88b09b45ed6ce5c976e4ef7c7f56c162b9098620b922a20c464d1cbe20d34e637f8624deb2269184e9bcd345b88c40dfa5918a5e4798206cb82739e0b1c4e9cb4106039e3b1017129288eb15a09aa50cc0375c12e31fe941cb6918121a2a1fa188ee45caa997066e256c02c333b3edaaac90b8199ce11c06dc62f18a3a51042957146f2cdeb179c8171f73f41a2694d6e65a79c41a2333e3686486137b1906099395164c3d845c06a30d2d3ea12eff1a6da440f7dd34ff895753bccf3130122cfd22873a4daeeb90732cb568ef8771f321d1c6086049765efe875f10bb7839d43b7dc974a4e3ea6b063d171a9128e4e983633dd20f04e2cd64584654b45e938d7ea7f08e527e2bf0f0a5b462db45d89adb7fc61c553ace880d2ca49fd869164402117ac28dc87c5868bab71fc203b84f8210798e72de57ea7de9585ee7f910f4e9ad053bde203cf43640496f3c73443fe4a8915d2196053ac175500e940f8e8dd487e84b5bd9e107b8ab4ad30ef8d69632cdf039e433032622b0c835fefafa45d4f0c41b2233e474107d20b50485da81339fbd20911d59cc7d9dd4bc2e0b47f3b1b3ad42374c0ad08d40626c076a1ab66491377d3627a17b984ac04d13aeab1bd4e43040060903d391c4fef60a458438d7c2fe63ae70b38fb8840c2329f2fa43aa03e562df0e1629abe281f63cc7c2d8a5ac7b075a3c2f162aeb086d9e54b0c5ef6134a5b4db468dc77fc1103a92570c44e648ed4131cc630c4f03e4b2f9b7511420cb4c00a0689964a070dfde5cf9a82357cd17fd6f574e4a26db6d8d8a78142fd45b5575a21447925d7a6256415202a0ccec04bac5a174a843b202522cbaf25dd125310a691bf6c04f83ae6c306b34e697b8337761eb6eff4347c62e9d035e1aa30be9b033ba311bf85cb1494fb70c6f23fe780f72db9c6c8b4f8c8093c516fb6ccb982db2eef75239e5579868dd55643c2ebe773d84b4c3b53feecd86b8ae70ed562cd9e7b4339fda497f2dd35cc8c30014654864a1f5c7568bb31f1c20ed38c947d63a1b34706d01dca23543b96eecd5038aec014d893afdb0179a73e5d7ce0287213013b71d6a2b2d3d3329482c9903bfb397f17d6b511895c0311840c6a055b445ea38c1154184fc64d8596a1db590d56b5b888fb9ddff83c083977a57560821c66414ec6de11f15a98a0b3d853df49d1c8a56026226e7e1e9bb3c3b716dfb864773c06cbd39c5009d5abaf5509955651b9f246d50f64f422887de398f92aa79f5428d4be9006bca81856210b7781ae9bc5ac9cf2de3a22b4197e57a2fe3619569283b606b446cf0422d314058f148917e9dad43265a326e590a0451a8a35dd9443269d858a0666f34150da644c64d8e4745211d013009fe4f04dfecfd7447e695f12454ef5b7c9f3350ff8ed0761ad73cb4871e2d22e6e749ceedd5321ce6012cb316ebaa05c9dbf9d5234a75315ed5df280c1ca916e121cdc236871361097716fa3b35a660fd5729bedbd139ce34db8ab29c177fc656fcff5af6d21c7c4995cbe4e99c75a567332bd842c339971b63faca21959943f7d2ce2e374286bb8d06a5582151850c71fcb441b50bbd256f34a23fa2283909e6f34559605293d39015f52c82df23ed39f8c37e6c15c94554f3a5e7d4c593e806aea1ebbcdd266584dd9148645c521261dd70a108b051d936a9207bb082cad684bcf30d9f36355c13169c3c38a279e2e257dce65d7f8c60ea11daedbbec5ef894adf4044260f15a2a9e4a725805d866121f171f384e666ac0169d0e0d5afa616e58f48c693263559aabfe6ab7dcd9632b481c40770b702346b6148b74b6324cad32b362398b7dafbdbc8633364186bdc20d0881ad338f73b1644a663a7f3c290a1f93f7e0adfeaa1ffb3efcc3c20006b3a4b31cd1f5c3c01db6d2ad1f418e6e78a400cc1e7b2cca06f8a391b1dd1d9bd35de692a06888d1dfab601c37808991d79a6cc5e87bf936bfc090865ec7afd4dd335e745523f8803abb9623d54a3a666d00d9b0353910b30f8afcb836ff7c5ec5247425984460b62f64caa234755d85970bed17782fc7c089a19a544a880b1eebc14c363ee50a9114844eb83cbc19fa662c39d58ef1bd82f1ac7ec5b29feaa1ccd3fcf197647048c8c9791f38d39c58d454cd7b694fe84eb67c3357336af946ea23b48f154c5512c21b227e63bcfeaaa04ae87e6027a380a5b706a22cf853a51cee12fe72e7ca7ec50de09676fd36926998d16d33f539dc1fb59e43a824411497b2ceecd1aef0615a597ccf57709ed27e7ae885e49a9ae992c9b5aa05165db4b1315bb997b4906519bddf1c8976ecfa6af7c9b7895272c2c0972203eb4d96247568634aaa85fa93e304e375341dad0e19d94eba0e1774f4095f3fd82a187049ed8a52ab1ad9422dbf3d9b6a70ff0dc527b19dce49b7ec49a0b0ccdee5d529a4062de19ee1bbd980e6adf3122d599344ee2371b4d7f15435a527b09d4ea3a1f8ac5d5b2df9a01390486a5df421a7405f806e4de1de8f46cc9e137a1b0b7c83ac53e4205ce2e7206cc2bdf39b2164c3734dadcbf2b669fc5b15bdcf4ddba31871963fe457857ddbb8ff884d7b0399ef0c604df356decc4cd68717bc29fb78fc66a11b367c1efdbca11f4bae259a1da674f5be6580650ed7b5455aa49f3ff325f9b370acd31bd359165fdbeaa13f31a64340ae631efcad27eda700bb479aada4654d2a88d7884547ed4fdb5849e2e5974fd7a768d6a740140efb3b52115675ed730c5f8110a6ddb6b884370eff78261cf9ff8ea048b47e2765d21126777f38f549c67b10e06cd870b4475aa9394c50913435a7bbde803d26413ba908cec5550b3f0e1d341e7bc88c15eb715925e66b3840b8d2dfa65045699c60b7c4265fcfe59e7868e6958174d90177620f6e7429744d95f4310320332dde683bc5576d9917c72a4441db07827895c9a80f83b5c9bcdddf1529cad3d7b6d385da6ced6ca54c41058c45fd624ca45acea8d4e8d397a9a743ec6b38943659431c2204d7d180684136a4a3d61b446400d9de162ad632f6cd01b48ee56e0e3b8043fc1a37f38115268ec2e3712c7a263e27853b6bcf28006b4b2f05d8e945242de1f9ac69dc96b5ecb6a9b6cce2cb9e61f4647f9065079f8eeb26b1842f4f26ff31aec8c9d601e2f3d42346b2e39ea550ac438a2292fc4b852f1ae43c67b25e30f101f8baf9b6004e0604e3dd88f067c0fc3f2f39d960f1f20ed173674409b6597102a9f6e14363f963d7ba694e21e574b397d501c89d7cdc1f17017300a9605e662759916c8c513243f786bdc6c5204578db07ca09f7a6e7ddb5418a5838a4d07a3f3b98d9a127cb75865edced017030ccf23633533455c63ca68b6dc2b046797c117199f4e8bcb78bf24c970e1d95f25bb29436478e14b1d6f353603f5a1c09302dc040ec7051fd5d2b67b6cd6a2ce3404f7c8cbb61b1a4a4fb27722638ac0de2f52f20839cd40b3de6c194cfda7bd0927c9e03beaf13d8912f0ebd7323831102f814646ae0df83f72b5f92ca8b0a7d021975bba41e1a6d6aed817e976c5c7f1409fff3f569fd91be85c415e1233be46844f648ade9e60a445b7c6d9819d9272ba4547a88299e87fc0ca23f61050bfabc553cab042091b71d813459328534bdea20cf55de19499be78a1febd20ca5220d90ba80724205c2c79ed0648b31e4cb357f3083fa2d40baba705261d07e24f0bd49c01862379b867cab68c5e68189aca39acaa01de8a864375e2b4d643b1dd73f92a55d94232e36b7525cd921f989896137314a742c402658590ca1f0a0e8233745b5e90ce628aa07c5a839a1ea6cf5dcc0191129022a06384e9852b5d289094baad6e35af4bc7a79237e26b34095e11491c9dae86468baaeb2026433efa38bb1f884db536bfb337e3fb9c42bbf53653fd3fabb9a3a1192f0ddfb08c1dc13283062428c3a3acd7921d1bfe0b6f3680bbd727feea3a06b1d00fbfd81df8670de150805510ccee254adaddb9eeec820375158e95d349fcdb57d77e37e4bf8f220cc7789e8532f33a24195e72af28cb4dfcdc7f96ae906317410faa957a77335271f67a11f06c64853ae19f0eeffd284e11a3f514a12ba681028b22825913816cdf8eb59b488ef06bcb118444a79a668ec6d396171eb9ef03adc121b9cd3436c92c4334e4d811fa59e2882eee1264f48c86a20db05fe693b61a38a0f410cef60bee734978f2bf38972c021f04e14b240ac9fde60399aa406a1245f39b5ebdf993fb3bb137f2c3941327e7b91b54d9ed6b1c59c95eb0d8dbb473b1442af4afa8689b7c958dc4579ecb2cf36253635fac682f28801f37312373147c8e7779b52d9f63bbb70ba58372cbe43411137285a3e783f150ed9b68ad4ecca9123cdb5c1e59551637ef484616d76ddc85151c5a912a0bbfe7e7c98e98b0293f86c5b4709fd1db455d6afd9aaf89c8b1fee09ccfea4daa25df9816a3a06ce1f80a24bfd1eb9f039112771467575622a342819afa2460a1b0d6f80d6ec42ca711d76cefea5fedef7727f85ccc09486a58b542f52e823ac2f34922bcb3135cae97bf69cda06853935ad638d55046894c0dad57c8f44807ea144a074e2fea4a0b8c8cc2dd3ebaf9f4fb863c1de4cb0dd7203adfab18cda6e65c0da14d9b9d0e1b0e6b7e483c19aae9ebdc9caced6937cebd1e2e512479c062a11acf774e7bb8a379535eb9505f4b5e16e2ada1ce92a2e8927067448e958180bc76652dcd4975ed48bb37d425d0811d8f41b25fa6ea00c45dddd20db14b7cf3c0d10b38a6ffcfa429bde32419a6bb69fbcb70fe5f800ed529241314479b428dd0549fafdf3a55ddce521ec03939955a18cb8cda2f3550b4f3d9b53d8e8a9c22150335973beb48fd8d26a367290cabee0094be097d3410a44fb28c9a21b164bad8ebfc8045bd09eec244d3ca8e49cf60f0d8a9e8d05811d07b2cffd7533e5e0e8f2c4631802dd9cdcee2736a142c7198337cb6e919eaf5b8337efc1449a1266d3369992436fb8ab8225c76594dd5e5ebdb0b5962bd9ef4f9e3718ecc1cdeb9f53b494b5497188efd2aadd2dd8fb192bc5bf14b1de22dc4341ad54312fb0eed0f902fce205d55055fefa45cdff123d7e2bade04c8853db7f4195c8c10804eb691d704b96dc6cb93259a23ae23e1c5f1a76ae9fa9de69996040c94646b9c9579f414b935d84d6bc0f70ff037780dbf987c23faa0535b898b4642d5145ae1b472ed5b9f57ed04ad3bdbceb2665a8a3fe6bd527d34913685aa5640361f52e00364de62be7c500b1adcaa92310b880306f5c376d7ae82f1b050342f28a2b54e28e491142604a43c98ab360ff070e6f457e51a37de4537e097b0e3ea2ac501a63f8cf97f3d6db198f673c10e29d21c688c2898b4488903c6f5ac3c4737b1d5004d137a86bb15c0fcd090ba5e42219d026f8d8f2848d31d0f90dac423cb75ba7ecd3700d6065c7b81d237c277d8062459df83d1eab50ba865b15c117983f8e9c40212d6de1e76b189b0ee108691d763d20229c0051247c30dddbdb3a14e4d69e09f914384fd5550b55de90a502db8f81df3d0bf33e8148e0a265373f93b1af792de3b69363f11912d170b07665bc849aba574dafeaed60a471255597ea544f6d5172aa43d3333d9f1bb68f9d8eedad3b741a2bd21f0ce6ab06e6c947b91a090b85c764231a898e7c315a9e1768b9eca83827b92aae43a771b7d1d66c8e844d36540d67adb50e19a89c9184ce7c7ecf955e7caf1f454d75044957d54d498daeeb0dcaa3ab0a5e6f103f6027b0c8e21e30b7279f06c19cc071b98746b8d2c0e149461372b430b0d3286262156154ed6916f0c8a4820dc8562399e971d4a12e89690dab4c8d28b30be170f9c8a534cd91d4277492fa45996083b9333e9078508c3ccb690c3fd423d7fe2bf594c8489e44fc929831bc199a219406885ed5f00b362aa15cc7604a17a38e85dc3dfd092c68038516f208fc452fb4fa88c9176d2af8557dd242c7682faa8da1e730168afdfcce77760de5780615726b025590d92da3051193d013699a5203571153e4be4ef16717c6367b61fba8014a301210526258d14ed6b73d60a365c5338bc60486c92a44ce103f55260c9896a069dcbfeb0e3834e41e494cc4870481e025d732e05faf0936884af1e69632bc16adc7ab70a7f955f7f82adccdf3e84e4249cb3559a1ea8dab4f732a3ead954279720de66a152dd7e6ac718381f84c28b42e64625a040b6de681fa543084d732d64a774653e33588cc9c8e92788725bc928bf4a90d122c4fda2046def513f6aed96d24c363b31deeaa2cd0bbc2167315301aea8a320778ac59a6a9a866a0638f6b2c8192d2d19a5d957bf8cf51036553ac474634416e14bd66324d9e6db380c7b057ba5813acc65b48ce8abcbff74ad0e233938cfcab854af10e0873a8710a5924ba4bcd07b5f1b90a7f8608608215062251e48cdd1f3eddcbb7280ee1bbb873418a12688109dd342dca4a07739e5999988e8883d13f5fc8d3b1dd2203092a449ba500cb1e25a554558d81b0393fc46d260452ee645fdd18eb3c7b0c68dbb87034c38feb61d85b762e9f87362208afec3748291114f64d3fe7a06b7608a0668c95249a704ce32d88c3886c76b025e4e3b11aafc2c40fabe81eeaa142cbfc79506bf292848d26c5e3b8c034e9af8980fe60761cba49c8d53c8c5f3d691a35178c40929a58c0d32889ad674f36d3234154e44f33907290c90e67076c4e8ca7e7dd1250c9e2e1eb010840bd276c6ee25e3da6eae7d8e1910a4ac7a42841ac1545b3d5c144488e3277f99fc201f129bd3aae73bd3c85c32a327f013e3b6ce40ade0819eb831147800b5745047a04b2cb07ea5e461e95d7dae88c499aed0488a1e563fab5da784f92fb4751da51349df5320a9b459125efa30e5ebe0efa55e7152583ab3dfee44685da5a8cc04cb91cb817cf3ee65e22762dbb152cf4dac949c56d4857616d74877b790f203f576995f85e31eb8c94910113758fb0bf671002fff176e06c4a3e2a58bcadb903932b727ab31e3482a386a774d6af6b778b552e07c6d9660d3b416e1c9134f9441b6e1b43a30ccf40a611b868808bb9c5447720081ed9a43df1485b5182e9071175e05cd65352936e2eb53ed2267e83b7e964d6eabeeec399c6432f30104b1e09bfee48ca514cb383164318ef063c8b881b35921c0135a310ca4f22284b9d0aeae16b1c9ee16094eb5e5e827442296f7c533e65235b1e511b31dda7646a4fd2cc1d1b67aa716c32bd896979f4d1fac53426d34d45a756ca25c1b518fda847a511fc3c9ecb3a9b42e2eadacc210eb8599e19f4f7b71e05d21e576a73ab0fdb4b829ea4a3853ccbcaa897b277cb0bca209963dd77517e430be48aaf020228cbc70d6c42e926bc850bd313ba0f424619ec67d990cb5442a7a206aabad19580e64ae12a219e0ca366872c991e41b408d628ef858c208d6796989061538f736ea05dd600ef095cb8007e170176a6e3edb78b7df27f077cfaf778e219d27712610e2151542d873817cf377b25d266fd765de3b05891f83808c194bad871ff5d45514c4fa0db8cc5d87d5c6402e4c2c163e2709475783a8056e3182549847f899c41c6ff5f3d442a536488b12f76e84bfcd1ec95405c08a73c7183189d17a1f125915473b3a9998480d7256d0298de110854bdc8a498258f9a03fba0c802ca2ba1e8e3501c871c4a4a950314006d923ab12a39c5178bc049f02283dd1035382e900d8adc81581cfbe1b4dfb75853c010a30c3257eae070c0979180961061806d0918cf31643ec2d77a29679caaef3ea9854ea33fd34426e8abde615240e4cc01a3e8d4800837f290f31def003304643b8642447915c5a66adc13263b727f2a8b82eb516d0a4f4d16cc305648d9cdaba7e3a5a1d3e9a96e5bad58275cd3bf81d1f91f8c35bc1813e8a94531dfb3aef671bc5624212697c1d25ead2da6e586968fcbf5b9d7fb3337a9cee9400a5732ab2e353e42438e4a44e818b7c48891aad87199c76e57b38213e1739a0d46ee5987504810d96eb5a42a589e717cf832e2a675aa776471aa3e4d6625c12affdb37eeb0711babcceef5a72e38f4848e6b650e7eb20dbe6197bd18eb2def3e16d0ceeb0bdca7cefe194f6884e907172b2f1eac18ac62970b06f62d56a2e169cf025c13ca1c27dbbd109cb2f0862b9394a981ea112c46d054a8ac48587dd59b92c145da9d122203ee412871598332254ce4300794d219981f13db341aef8c36167da1fb862583088ed70d89e03c38e4e65fb44ebd12046ba4e5df539b5c887801f22c47e611b477d61c55b2ddd94557ec9fc865137c2b0fa1959d6e2ad0cfe4213932858a6cc4941509f2f20193f7a940768f59e400f4231657471762e4217a1253a47bb7ba45e0859c082553995305ea5937d36047e1040e5be54c21c578315b553fb39729932c57ec87abb44a538dd2e9a14229a96f0c866eba8a520e0c84ed6cfa1e57e8f81a8db4a70b4bdaa495dfa1c976e8b5c92f2e59ed30d0bcf266809abc7857e795951c06d80deec776d4067d1553fbb6a4c696e46ef9b54b54bde4e9bf90bb68a952c89d99cc7cfcb00b050be0c9a476993c2c49e4ae5a54505ac4c3104e6fb995cdaa591658c4ce02b5921d121247224a14591598328279848a05daefc1a5290e0741df15efeca455b86bd5e615f233006b94086960c088b3c70bd6f972c89f3bc2e79fb93368a3e7579bb074880d0b51cba2a4658cf83c6a6fdd6d3fd54974297738b2d58be18c9e120174661d656a45fc2ef974def5c93a7b2db5e24481fb46771bdb1b8c1e1d858b84bbd984ac13cab19dd8846c14c643a83721093c112dacbaf87a74ab723909423cbff584dc07fbad16f981dd60d81178bd76d23566bbf766e77518cdd350a0199ebb6bc32dfc695e379843f0dd301d3d046e35a51fd7ed9ba4fe1e9b9bb5689899ebff137120af01a2d1dc68e08bf4e179c9418883ab82112a553cd506e339a1b48782c8891071796755dc713eea0c20a3855a69a2cd55aeb93ef5d442b139f8e69dd1f2dc78a4ceee2b0c9cf0df3ae1e9bb61ec21ffaa567fcb8d50dc174e343eb0ca3718312bf16888edd414a3ddb1d644087ed395d10767031ed792e0cd591a55028828a257d4abc7656ca2fe3ea0dc6ac609176ceb92fd629c28ee0179723ab8d174c821cda48a91a6c317e178626e53f16fb20b2742b8dd73800df074756eadda83af3009abcc19eff36b80488a527ae8bf5719a12c3b0bd4e5a98b5dfc04ccc31c23df32888ec1fc197d26f2e484c5519114dee59529425b481906e0cf3239858a986c0d9e93cbf28773a4e1f133444ca12b9b934ba6515239551f4dca89652285c2993d0f4360547b30f20e64548a4ebf2ca44dc0b481faeb59ea5a6111907b4ed2d1fe84148189c8b1a8d84a4cee667e06b1e2d2ff677de30e70923ef554f175e9011a373be6e99d8a8299c13db923e3f2f234d8477eacd8ac47a9c56b97478431c0f7993065177a1a1522cfb1c88c1e47b9a0d8b4eea8b9a75d35432957c5fc4f9a5b15d6b68d0af483c50d3e97809f782f9bdfc025c575ad7759546656dd39357d050de280852c6a4d3f57e037866f9838ae595f637d4bb5fed90a38fee1c4fc12baf6db24e83f6b11756a203904db334b6df046451ff267de3bf2138b61bdc5269b538a7e9895e59411a84bf147ae9e98cfd0cd221f1c40e9fa7383372a6f3ca5f88d43eba34290879dc7a9f69cfe3cc2459b819b61c627243bf58aa5c6a7267ac78cf042f46853d9b06c963057574fc01a8db60a3dd886596705cd280d543274e3b8f8e96623c1ac5c866ee533667f6497c312ad9ea725ab6f53478579fd871235a96181e1193637de84e80dbfc105e7572cee58b0188d7f1f6ef51f24e8dbcacc0232833af1324339273ae3eec10f8b0cde8cdeffc02c572ec49010786319d463ef2513f320146103ba3b82745c308eba9a0ea58266fa7dc08955740b5c605360b57c5f66d484a679b773ec9080c49501be08c87ebe00cd3cc310ec0ae14caa4340134e3a5eef9b4c21c36e17e94fcf1adce9e476981795bd72a191e668c416d2f6eeb6e59652a62465070740072e07dc0bd93a300572e1e675c7820a9d5bdeadd42b485ba43cdd82ee47b89784eea7d7fdf723755048f7938988119095cc0947cf74aae15538971cd6420eeb7b2794d3ef9813d40cf8a98b8a5cd9d6a71df5baec791c28a43eed7674617361f251c3c6b2a4c54e9a2e29b0ea59df48848afc5bb693c3dac9c9a9072ff221284f5072e64bba27a8b09d5af4204a1d095585448c88a8fed5bd9cadbe71f8ea42229a9733ecb416815aac34208f1f0e7b5195eaf10761fd2afc593deb71c8fa9fd56af5abb0c8ccaf1e874054cf0a8918adc21f11bf2a0c419553b0e3708ad11ef49d195d56a864e2985505c6de6254ff2510cb8d64b26e92a6d3ac67b319d5e32d79227dface5c25c03b64c6913bf325173c36d2152cc1489f1476c8dc60e44e3f09f43da99346bb81bda5b33ff6960fec2d43e099bd1f7b4be88386df8e077c3b663e410acc7ad58f8dd43497a8dd36afbf11bc67f2d175a9cf7e273bcff3b13d15f2fd043b157a4beef7b8e46e2cb9bf91c03413ad7f0a5d216f2473cea80b55d4471794b885d39e9528da09a8ad74522389c136a42e22f0d8484923914ab57aeba386af1f8d444b809b16cea816bbdffe8065142bc98f51921f230f4722d60799628c688236fb2912b29e1516f99945b4223faa67fdcccf204da4a22b27122ba4edc17cfcab1f659415385ce118831d366b4d4b93c98fbcc621817d24d67e8eb65a92a4cff6d652912d14965a1acea4a31a064f30004699fd14c8811df772468374cf853f463ff73b4ecefc7e2a1cef0d2507ba30806176286228b8be9cd95a6e6ad16e16c98643e05196152061f6adb5d6edbfdc9398f80226db2ddb9f5062748fcd91fdb9c5beb4d6328151629dca23fb938afd293f13e48e0d9f6a9db485912dd26802bfe8b3dec88c035fd47bfa9ef7ac9008ebbdf0e7fbd41399f93ef53faa13f2ffb4de7b16f8d33debbb1939e03a0626a2f91fef67be051a01e99ef53cbc87267cf92b9933a3d77d2034effdf673d6fe3fadeffe8608f09ee681784ff3fe3f461e02e9bef53fded3fc8fd116026985f77f68ae7d1a5ab017befc573ff3ddccea675e4030eba9ea59e05773813a2ad44c1fc7182c6746f4f3fee52110eebdd4e3f881c493c91cd61cf8833a288158f6a7e028ba9864b2679e91ad2b145d4b29e58b0a9e7276695a7eb100a7e020a5e38c1aea9e9f4535e35c629ab59e13706ebeca27305db8508a23539dce01ff7ff53466cc7819353443381c314e38ba38d77fe128aac21a8e327f854953fa1196118eef5f138e622b1c63b5a69921d6100e41f07e27794f083812e64f461613bb7c275d1b7a0e0040d9b4ec34da2686aebb4d7bb282c060b87bf794ee02edee6edadd9476373872b9a7cf321f8539d9d32d09dc6b4b8f05842be12f5dadeeb59dbadcab7d4aeb04ed579a6f485d2d23309db2c55a3f2d787e8e9672a72f0d3fe70d2cc051eb53aef56f0872ad4a3674c9f5ab7cc09b7190476f8a1a92100293e96fb8a3a8354a84926ca5b243aade106292e9d35aab8e1836685143982a5c706156eb0fb9d62f5799ab0cb629d36f117ed46a24268628a2706109125866b516e54ac549ae55860f4383951c198431e7c40cb6e97aa93db208da9466004388f67042b24c5a70a62a044393a002212a65c9dcbe6cf9c2a54eab4403112f6c36c460c06022d7748928c05e9659b278829100e36499258ba83c62f10ba727b4e5cab20516368f3fa5dca19fa3ed14789c436456b42642f6bceabb4f2993974c2514322d273c00859fe0cca950f6e7a3e33ef5db4b0fb73c9ceaa1bba2543887b660224666aa4fed806b1e9f0b7fa8c2c0e31ca20d557082a13a4818ad4d010593964c8fc8f4471911f4e7049a4095fe03ba47cab7639280c9c2e9697ecef5ad222929bb97dd6f985ce9095276e9495b949e38653adbc79c20384cf2a0603b09da4cbe6829207bf27c7f14b05fcfc969d1715accd101d71f71b2879fd3a23f8665ff6d0478944e3eba7e8c752e830a5dfea20c4a64f7d9b783c69716dbdb3e2549292500b2a5d6565ba96f1b121dc8a38b07198490ed1e065078c4221358059afb45e802dcefcfe19fe2c8602f13ebedaf17bba1a45f0fbad1c740fba04438ff948729d057e1e62977eaf75824fbb70d652cf4b721d1fd5a6b7783a0088f3733d92a53a6d054c184a60a2636d890840d33ccf032a74ed1841f1434814e2174ce06cc16a5218ec5feb5041e63fff37380346cfe30014ea5607c4808f12121440baa0d50903aca1160a2d86dabb556bbd99e5270dd68583efd1b06aee1ab7fe60e63e10d392738f64474cace19043583dc45e089007beae7e7108147093f80cc94edbad40c21070f1083ad0dc4116d282be18710f865503850ae6c99504a41c19f9b5639a7a4f425f09dcb90c8becde958770cbb2b05430d47fc426db7dd22d28be12f29ed6ed99422e1eea8975d38b4c56e2a84a951151b266fc3e4cbbe9b531a7ad98244f75e4b3d69690949949f63ca29a7cc3165eb88f6e30d30bfeed4dda5b4a981c17db395baa49c51c3454e96b5c67a6d6d12d34b73299de15adea52cdcd195a7faa8089f8a8ae0addcdd6ba5b5d64a3b9c929293f24ab939b53555069d73f21081ce10bd6d72a6f794524a29a5f2f502e1480d1b192175e10eb9dcefdee1f8fa1173987c569eb456bbdd71ec57e5afcb0e4af9d4e5e3ebe6da79524a29274d4a19a502a594524aa9d7b5524a29a5d4fb542b3cf37d18a86cac5c18a75836683c0ef42eee928b044770aca19452997f83b97524a594524aed6d5fdde01aacd68c67696ad4dc8a5975061c5399db6a64cc70d9bc6478121c0130c3456dbaecdfdd6c90fd3b9c9ef18d5073879edc49659f8181cb868deb06a76ce4fe8e86c7b97eec1feb3bed9ae9775d336db029a5e1b5b9a95123fb77e1cdcdab064e8b8667737f0700ef29695455cd8df355708ac320a536b36bbe8865595d4d4777772ef07c1fa59452ca9aeab5e54949b3497a299da192b2384aa9ace102bb7baae54eb5dbbdabcdd6ceabb4aabcefb374deacc32465e7eea56ef348c9b1ee8c47371a8f4a4a6dabd64cf95eb3943b94565aa90c8f4aea140a6af4dae5dde6a975ba3ba6b9bb53bfb91100986aab9d9133f65f5f0f6c29ad332d1a302d9a992ff6267405405691810c6a6bdd2a4e8d960694564ab3b0f645ed97d60be31b3b43ab9db9c27ea9f7d28e56cb62b1baae7bd985b24c9932b6be36d059bd6e7476543796565ba68cad3602b8e1d9dc8875ee9303ae034a847670894c892385060e0f2c0d1c0f78aaad0183f3e2e9a1d5bfbe2c0daf96563b64da4a3ff09922c5cde3a4fb767476a7d56e38346eb27c7a656d819c84d940a062cefaf007c3968c97326a70c277587f4d173c7ffc57e80a4000bcdb354d19c8c820834f47fd1a35d4abb5bfd91a2d0dea8b34d4bab442e3d3e12ab0228c7e58b45e18c33cd8a7637b1b1b78392d977f5eac4c242c66789b6c6021a12934a9e0a821f349cd04d54766470644f4be173f1daa176ddcc0deeabf1e7d801956d779988ad7f94af50d994fbcce0415c8c88070a9af0d7456af1b9d1dd58d8ea7a323bb4957d66e98306f34ce104e269b4835cfa46945c804a1c9ad5e304436b9e4709c5b643602b8e1d9dc8875310e3a0eb80e3af0a4f4b9dd003c297d068063436a1107081a383cb034703ce0a9b6c609e7c5e3d1ec49ad25266ff5822ac5faea9161b9483497c93e1df46545b2cb200cd9b639adb488a58f9037fa93903bf5034f4a1f1f4f4a9f248c5d5eeb8dcfeb66a63978824e0eb23f75f798f489c91d9f14088cf1c54e0bb3c316960d3c44d1f4d0d492e202950f543a1fb2b84b5d23aa218fddd460f21cfb293799281fb8c8aca7cd63e38a79f5d28725eeeb28f900743be83a294de48e0c2e410f2f5c2994789062edd74f8725c00e284852da61092d1b614daf88be3a8871b5e8a04408997e875d2efa2e7a058728a40ce145174e66f4c5e6a9405cb152e562af66091e4516f20eb976453a28c1c9f4ef3645173599fe96938229327d6a37a5211e32a55fb9e4e420e50465327ddafda083031513e4e042a6ef395ea26891691352e0f18a3a50d8cc8cc04d578c1607585b68a0c4e0021e9a8122f4c28a5e160f4c544d2c612a4e3e033411b5520af29c545328e94690f44141810ba9273c2859b8c07550bab80618c1500a4a18306c475c1420254c51624862002786a2387161a916258a0b062041541422036ca145a1c2845e2e3480134b51987819c53aa6650b316cb8803924b028304cc1ad2cb33cf9a08114d826cb2c4f48884cf08c2cb33c49914197272d32e0e2290ae604af90d4a8823f2736ca60d6908d21f08a080d76c038a9c613be4c3570c03335510b5e6599258c164c61c0a8410553174416b08d013606e69e9c00df285b4809e307518c510d1bb097651631546a1c65119374a41613b3c5d6a493392924302bcbaf5f18065f292fe82370bf510a5aa048ee14787bfbeaf7d519039d4722790b715a746f5197c5c4609fc205c4eda2058a5db885f108c214b1618c714be90616dcf09447fcb48ad32d98eb965d0577376f5c33601fa9c733a6e011a7bebf9b9e6cd93e02cdfea927f8738e965212a9beb08884a285312420a168610c5af6fb94e3387ffad465a8c54240e58e87f52be55e8242dc3bd9bd48909ffa1da9972ab8a42f4122cf41dfee0d456858e7f841ca0f600b12794f411cdde37d7f2ce6b21c6070151ef2289b7498b8269d2b0afcae16a58bc0c3257379cffd9bb70db4a0dc3102cb5047eec8afdd5feacd5d0098b08ef4997912f1a72111fa5eb885dfe22482df3f4ad5a9c019e5b04afb81c4b1c3eae3f7503aacfaff784f7f23a13ff5fd2922aaf0e77bff2dcc6971ae5ef58f55ac577d10d6ab56ff839f151209b2fa51fd785618fb9574588ed81830f4ab53a039a32c14a1e14f051c169ee0b0eafd98d7f6347c6d21fd1ffc1ed2573da534a4d1b0c8cf1c72587dffafbe9c85627b30df7b2b68ad8f630c7d7f2449e87b9fc4ffa3ef3d10ffef5b416daaf0b5d5d716fec0db130caec0090536cd61f53f1003e5fa9c18dc42f5c330b8fe6c9a4935e9db42da6227bfaefb0de43e9532d21f391b7881c7f76a10264196c9aa26ecca4d690946269d4128773f16c99386eb8144e40b8018439b11790551153902055ea2663fdeab422233cb0e3800cd8a7020050c41b38e6a0ffae5ac88e442862a42332fec0f9433d79125a425ba24c70b4573b2d2626f791d61e9deed515e774322ef91bcc76ba4f99130f34c016d246107da88c2374273e98ffb7602c3a979c6761abdc8a19a67742427538b1a3b6a49f38ccd25b7182ec678ffd5c3bff63bd27b91910374a11f8563913cbfa1644079826d942f28c3d85244cb0e1a41e28129cae40df49745cd33bfc7b778911fcdcde57228177605d1bc47ce80f2903bbd8ed80277c2118b39798f87c31ffc1f0e5ff3677e5e53f541583346e16bb258af7a396b16e84e0ee5b0ef3d509643d603112322ac377afdf03e0172a6fa9aa74335e0091f58019e54cdab7e944d56d0680eebd5ff1801c1ef7dff83c339e4b0a079e4b0315ff89a0b50bdf740beaf098918f9f41088eabdf766dec88c45f35f8df747e6ccfb1f9a703239ac5f334ce187745802e4cc0487f51fa9be6936318da999504d5fcdffb0bcc7615007d15ef3ab79ef83d4d484aff935ac67853fdf7be16b862f04785ff341bcaf097f8c80cc7ccdffbcfc695eb23e48cd4cf872ef83cc3ccd4cf8f29ff19ee669bcd6d3d474d00254bea505ba934371636067f2a5169de64beee454d4475d94db432ceed44950ee1464f5a3fad53b943b2d60155220a73477f2aa38aacd3ea7e9984b290f94339af43ad2d1dc21e9eebed7e5925e28a5f5012dbabbb7839fc3eea639e48efc98ecc529bb3bec965da48d7877347436c7032692e6a18f3f2665b247ce205ad417292515593e0a0e90208490a70e52ac40210cd5202ba58aec3fa5587fea604576b17e92303ec78657c8b54c762bddddaa6e7882dca92fbde46a240716f8a3c97348183dfac0989412e63547f697b0fa29b0eb8fecdd7fc20b914db7392f40261ab4e840c68b306ea8412cb14d7aa82f7ece5b31b48527bc58b550c33cc1b48277d1c2e54038c3ad6d58704ba48262b663b3d25a690d16f097a59210458c21c4942d4244b13428e91c2658760068be27440bb93eed5ae9bf8e00aa1845193d512962d43f2f9411982deef9a51941e132bb7928eddcfd7a97a500168a64f76e760a159986f386e3ddc2117b8bbea82c042656b64d22348f540a6229cf20bce45492d29424733ad7c4a9e3155869bd7a3dfabfb3877bf94f2499c8ad9e5ee656cfd4864cee06b2c78625348c3e0d65c3c601f08c2040691ecf80a4995640fa804e7d053a54c20f1e4bc6abc210155aa443c20a04812f7d2f2e2a32a514082fd1a73fc42954ade17e377b7bf9e9f0d1dbc66ba7bd96c6451e71be933623df9f136886938684472fdfd4bd9f0af1a4f590835d54ffd6d0fefd8e227de41d7bc98ffdc40b7b68389f72bd3fadf4fd09a57f7669f55d5cb66071519953eea7eed3200273299003abc0f38fa84dbe3f6fdfa121fcf23bf768173cb7344f33d5ecbd6f5fcb3ce21291efbd6f8ff09422af0b04d8887b276dfbbbddedd29f9f2c5f51facc21b973ffbe0264cf8442c29898b46891573ef8401441d0c686c5baf77edf7b7f9cb4fcd7730d6dddb5928142fa90c3a40fcd15cc60aeb5d65a9fbb628bc0435ee7dd6ae55ef0e762c04745cde3ea82bd86a5fe0643f64c2aa496fa4c4c5ab4c82b1f7c208a20686353b93c674deed4af453e44471f9252e4ceec41faf4d76642dea85f8b724861ca9d8aa536538bf53beca5166b95d4932e0bba1916a64c64cf0974932dcd5b30ff205b876cbb06dc2b8041a579f05bd6db6f26b2c785ba903ddee430e943b34dd9af35acfe3e0b9c605ab48f417b05db22b037794f7dfb2e54e59d496a81d2619b17712f7031e0f9d43c76c4f387a25412b875381572c73a90f441923e7e8473c081b43890088236360e2404044e026f368923913bf6534dc224789c4dfdf3de24202bdb5a3b9de40e7d9aef4f02a3e030fbf762ecae1702ead30f529f86488064b3995772672d18c038bfc8f6bbc8f683d0a709914c27c9817d25773613a2e0d65a2640b98588b2fdb63fc14481ddc99b869ab2c5d247faf474923bf6b3ece91a562061f69998b468b922af7cf0812882a08d0d8b85b36dfb6058fb36083c7ad9be0365fbd6eb99a00cae0041d320041843d90801f6c068f0846590400c836fa8d0f0430f5e7e1012bbf80106b10abc7a0116633420c236592a159d40dc01d764a954c484175434d001b3b2542ae2c1865091932745405ac4d8a0c953161867a944d4e5044426d8801605080606930649b863a286126c97304289e8034c4440d8d082b72c958878f0614eff6eab57473a6520696459abc9f293e5947f6c88dcc98084f573b1828c269cbdae7379333a9547af87adfd6ca5ab16f67ce5ad4a2ddeb6b0042379ba2a75f9f43a4ecea7a33e6bce1c8b43591c48a704e1d69aa0a6bc413d29592d55cd274ef73c2a6578d2a3299b1befbe365b43c16d9b7f73f391306987636978423a413940381d9d8e3f59432303261e0600e87e8f36a98c192e9b9b215907fe8694fef0b1e6914a4a185dc9743f980274c515474041c152a58244169dd36ab7f196b0b91893f993c78e7443cafbde5bc311d370e6de5bfc28b7f42479073ef83043972fb490c169e61ea81285cdeeee2d031e316e9c7657f3c8dcb31ebabd79db7bd2f3878c6a356d4e9f41d3c1f1a64079f8903d43648f321b903d3c96e691251a1275df605765e50196d0b0f9dc93710ee540bda039e49ec354c90c85f69caf21dcca5269862a799c41b98416271641997beefdab7fb7c999021d227de66637ba6ddb6fdbc681258077ca56cda0a01fd913812119909e0464cf1087bd181ce571b3d611ab40f9b5825c0a747a9dfb5bc2b7433e51f70d689ed8090d6891c70c2b37067fc63a416207d528d149efe92b5f94116a7532bbbabb7177775f8735a6d9eb6eefeeeef65abcdeddded6058da4694de48efc9512980cd49353d214ea204a29add45b4a995c1aa294e21a9e2f7f8eb329cba7b44b8bf273b4982b78caaf1183e5d734a5d49b524a699d492df250f711e0299b5221f49fe60ddb2f3b245264e645ba6750e041b55aedffbf56abd5fe3f6989e9ffbf56abfdff77d004a189f4b964ba073b3d413575116e72393d54510bcdf0ffff1f4c172e5b269625115ca97708171dfd44ba40ddd3b55aade8a8a8a88b7e740d045dab0975a935d56ab55aad56abd56a35ef367501438518649eaaa8d56ab55aad56ab79d01fe9ec745aed76b9546767f267e77d95e33e15bd57b5f26da3ab5837f32cd9e4a2d39680986a28788f283a2c0578662061f55960fd16f22ad21b8a0cc8f6eb513beccda709824b9ffbf26717f9134b6c224d2bcdc3bdfc7ea6a79b9ac9752fc62ed72ff912153ca548ce225a4fa12cb97f9c4eb2fcc9448230b1cc1bfd92e674c57c856aaadb50ba85baa4165241518193502fa95a28053912d63d0b94123697963a550bf92a945d03f2fd2976affa7a7c4e85aacf87ab64119e3fd4505aeceea1bb86b6e22aea1bb078ae610bf50bf5ea1b81fa1337fc277b0f9617f39e6d06b56a0cb0102247510b5ce00596284f3851c4154e30e960adb5b6061f5cf08219c22ca104083ac9cb096e1212a37ac55092263b34f1a4cb17274e6c5189b842cabdc208870eb2b8e00b185b64698111f5083741e1c15eb1c24cd312375ce1845382c3115a94184af08014461d02045c962748ee155090d45a6b2d81184b0606ebe58a1a85972c668a349822040690c00287114c11a6c9163329a7796e9e33c9262182cad01412601ebae01b9e10a203415d82a3329f3d8284e65176c90e45a61ae571d226d05c32859c8825398fd34af6a67214953d004d8628ba72e5ca0c2cccfc633c4e9072e4055f4039e1441033ff19348b3cc9aa8e58248bad73e0459dd8d6850a76d8c24b91951cb4f8a18bebc08154134a6e70128515485e70e1160890baf9f385807bbbe97dbf79de77537f5f08d86c98fa1b522e05e688b5d31008f75dd87e432e1c63a1c3a6ffcf7dfbc3fd06e4be0d8170bf85f8b3c02c937f8ce8ffd84ffd6cdfbd7cff5e08b09f7a20f653a10864fb2e7c8771e06bfe1b995d30f5f7132067ae90080e2be46cfbf153b65333fbdbd726a6a47207676fc0097247be6784e7c75a942f71748fe01987dc915fbfc0217da8b4b96a0007e562381a70824c862079b6cfb593390c662061dcadc9a59e2c3dc81c09997ad0352a1a19302053ee3db04648a63f45ee7b0399faf07cbfbf03784e4d231407acc608ee4d11ab570f87f4a13e3bd596872cb616ac68e10bfd23a4ca6502b422b43801921034e952a72c81258621ea0b2e822f5c1430d45a6b350192db4215a0285a40e22f7c0ece52e9a8288f1fbb5e0800093cbefccf1175ac064af866a97434248e81b72c958e6a68131c31b9329924b11c1df132c6568778ca5d964a4378916189b5d6da301f688d59d244eb8b314b527004e83b526bad958b0e1c145c8078a116610598302ab8428c099284f1c3064518474a66b8ae219686b052a543681e2ee575aa6f05f290b0fb52ca5b94650f7658d3af3209bb72c9089228e3910273ae091cf852bc2fbf1ed4f3f6f8debb59db63ae902b5117b61ad65a74a28eccfed441c47aa7bf43e6eda6783856ddbece3cae3ccf48f6c231a65219c92a8cf11bc9d88570bf92592564f51cf72bafae563be4abbe7d16a8d330fb1514b9d48b62f35831d63cdc5bee6e7fef9c77daaeed169dfd252592f288979440ca7666bd68cac9f62f879f7e3a2c70819953bf43666ebbb5077f5c0a9c92b2147024a9a3af7a5538aa8c641a8e3ade774672178eb1affbcf48fe7aacc6ef57a191bc0a475927a4be4a0a517d55a55eb5a382ae56ef90d95efbd95a6b3710079939ef9d3766a1aab413cf5a67752ab3ba2783a58023b516a50bc7f2c764217c9db34e20e89c73fad359ebac4dab774e3178fc1ca7230e32b5d6d818f27ee02bc834ba3fdf2bad94d254caa6524f53a930265bede05d1f62caa72395024900755cf04542cd1ee851fb77bbee479c5a4cfdbdf47e4e419939b0befcb617f5177d9a690c31269c20bc796013d162313451327b05f929229d88528299117d2f7c059929303935cde67b2ee6a6eb240a542a0bdccaf2bbf995febf101aa02fa8b46df844b5643403000010042315000028100c87442271402498e8c22a7b14000b778e3e76582c1a089324c7511404418c318618400820001162184254441c0020516c50695ce0c5a843790fb716cc6ea340f88e8727bec67ff44a591a7d4a03d016515bb9882701a944cf604088a9ac816dfba7aebf6559b1951f11acd87833f99578132e8b05894b0396bc3c14fda0d81c251ae4becb11b87d6df5b3b22abcb0321eda997ccf0553aecfa2271e5203fbbb049c307d2ddd77ffdd1754039b8b1d2194851b34e639d94b16d7181c34417a142328fc0043766f574ed165c011b932275e5aa5044c2139dae091585a8e578a2d1336986dcef41d8a343a2909289e66c6fb733806b46ba64a4123c90e2d87cd49fc6e03bb9a0322f89e04b7144b6a4664b0e235b373cc9dbcc5d5e9d5fdb4c8ed074022da12347a37f75f2637d809ff5aaa49c1207e4dc0ff36febd6f733da9323a466254a02390fdc1ab8de241832d2227f81dc8894000d566a6afda11e08d31ac4a34960b097c22b653a056ec1c9659af2a2c92d5f952168d6d5986da6a861728ed695f7c6c98bcca5dc585b20d0518e6d7556507c6ccb4a8aa2567ab12d6b5f718f3e062835b4ed068940d137ff25650e8471bd865f927fa139ddf988d7bf7af073e58f322439d70bf6c7bf81e675361d6008a9efe03c9fedd952df8c548de5ae9927cff1c0ede0e57e01cc7b5c0299081af12e7d99a239d46af049179cd0789f2245cb38d45bf2015786f07f8e1a444d1c025635f92dbaa09a50a1de1fdeaf02ea3ad1850150a7045f6e050e9a2af0c47432503e80f843ffd477f8bce44b7a47a9ec4daced89ff4d5e0b1d45d5fc0c678f68eacf4b061d677700538d4a1cf10b87e09d69bf802f9217aecc4edf23d0ace0ceaaac108501a41eb2d5ddc178b53990499e3bd7b804cf315ddc373618138c396eb1b57f2049a2483ff4f90f0322dd830fd256ff00c58a483c6fca47dc0dd3bae6e76f484a42bfe1f7a8d396f725d1c9a65527795a846f3d77abd5516e4b1c1648c87d555170d21316494f28c21cc8b32eba08697c5b3e01b72b4be9a80c61682a1861b4266e0a026a09947b0c78eed58bd7b674232d34f3ee7f09b099ec69e57efc7cd1c6a0907d1d0b3299df18240ac9ed79905926e52d70c2b08e8326c3dfcc503b8f21d7e589eb1260be009d1fce33223a67972f8dac80c55953eb04bfdd6b53088b008f77a3471df79b12c164b189474cf3efd82833d3db6ed2baccfd79e45b364011f2ad740de9a8407745e2a8d7de6218527b48a82ad9e5979aadf0ad542059db4e4eb07f06d3b5a0f0311f719d8e85d7f1080d21523f8b68c310950d4300d1814d8d7b32127e42d4b5553eac0874ad205acbfd234958e4a54458423f57cba213eea0326806bfd7a5852a4fbbad310b100e89ac16834a27c0019f7406e91b94b91acd056b1e086f0326a5e1fb51a64bbeaa56bafaed72b597588ecc825c9f9f1d18b473276ebdea571e43284a417ffad8d58c788d207cdded3c885732d27e8ba41f2c5a5d03f1765913064f5e9dbd73d28da823dbdf12dc756b1106e6793d369c239adfb7dd33f786536e4189798ec9f9ca3cc61a638e4a5ca04083d6548ef7bb3e1bab03d208abb117d6662c2e16ed826661bd35e3aae3426342d13bb8e7c569d7d719931ec6d173374fb16bcecf9b05870168fe1508c6eda0ae5867260ed3cbeaa26c4815302c657c4915a5af1328cdcde240804e073031cba83425810c6b8013a379c53b30b17e3527a427b35937213b184d4132e9948f5438601f71afc250e2c874f691eafb9a1a88252063870888bc49ccd9e60c85ba3651afc0b875d9e0f69f5910d01be54d96a5bc92d9dbe7c20450de810987c49b1ec4a39c71e988f3981762514d65a19446c0ed02a648abf4b43e7910c4ee677dba24382c020ccfe9f8c90c81c12fb4c9a675a66fe31cda40caf4f4698734d3d8d1041ab89e910b5c700634d049f665aeb12d6fe1c771995dd38518b11a01f0fa0a3ebd4437b8733e2628aff07aca3fa00d3b69c9fbcd178bae094903a04265bbc15b8b67701065c920096c17a21aa166da90b79884decf2d5da173f54201b7919997b71bb9ab38089fdfebe4cf5c88ad97802c2ca559d966c49b1caa2065e3bd18cc909659a7da867a78ab4566445521db5e200f5698186f40151831a1404ba072a1cdf1ba4319e93458fa4db89c9679a2b4bbd895ba381cf36372b3dc9bb3500e6dd863033007b6874ab93f0e2d795e650d0d768e9eb827b654bc44a5cd6b404ad7d646d3ca8917eb37868c8174fff3eb4372d147d9d1ff188e24667fa9ee0968a7366c10e2c4cbef1adc26085982e28947bbb1c907cbf8363e5a3c4a5daddcf20f8e96edd4c5060ce4b4d5102f4dbe2cfdc6b523f559a4b7b4df7592db24bb0fe1038d4813adcaa8b42055120979520b5ca66ce2dfb229f4be442cd08941a1591ad89622a79db854716fe4a94c5faf8e129cf94de03152c15338c9c68a0790bde558927e4fb6f28b26fd68c55a61a1a8906bd6302deedc17b2b996b196186e54a13cd3d7c2c407a9e284ec8dc8add9b6fd1049892eaa0451f25be43898ef8d567697653862cc6bc1628fa5672906520457d2bc90a4df8c8ba0d041aad13904562a33b797b1bf06b63a33bb5d9602cab57fa57b4c9c729ec3691d09be1f09415dad8cf364190135a7898d270a88c1c200671b8e1c767971b892a02dca774301a69c277232c08c7739d1a0ea04b05e44f67a84c08d1900afa40c3b704c9b44bbef45b57eec3fe374b339c86451ce7300f0d58c0c92cfc22850e9c33d3806099e4dea1b02589b7d8a2713799084703ca7f4e5ac476d70fdc7a6979f264d810747871fca9237808392b5bb4ca721f4c99a7a82070c65e7794c4f35bc4bd1aa66fe42e76a6de91544f5e6a63d7d77c9e190d0f5c00c91a5bfe856dd3770c5e8b44cc5a6b145eb348b578e9e2c74c6b9abf4e4c67c473c8e91b57f595d54aa527c8cf69020f5c195dc4f3cb351a8ff6c5aa761bc46aa706c7a7d915363791a760476223edf30a6ce021b82aa8a7c3aa20603d009d37640a3d91e0e26b0c0eac4d5165ac679aa2884cec34761f38dbdd1dd2ec38dc3a31b4fb88812546426777cd3f8d24dd4840b301bd1f0f7945cdc8efbe6fbaf30fcb3f6033def57b0520255f1126e4605fb55d2544a1d3df0f77c64eef6a49dc46d89373c6989547b44d06925186815edd9cfb0197be2352f67b36f602d480af3c620ed5a206320a36b1529ce2d9b5038061bf04e5de27b0eda846f6623c4a221fd76652cd83572c9f2391b4600e92d9e3729e0c005af50d79013f851d7c98144ec7d9733a329861b046ae76e4d228129d8d46fcfeeea1580586971509264008285f2bf81c6dff8e9b3efba76dfd97bfa8fa2400e1b00a77a75e2278d42852a52d3037e8897d437e1afad513ba13b24821b0f604640821f003706f93e6f1936c0802995ec54d54ed25b18e5a9e4877c72b7e3f9b2e61f8041f3cdbdb019f7f89a0e1af3fbbf76140ce2bd03b89e16b36e0d52b1704d020a129bb7339b01ac4398c614162c0be8b55792b8cba87f93bb602ef2ae0f499b9191132c82edaf336c43a81e142947d037e217cbd06c9256fb496e75d4cb0a48cedd2cd3ce05691a418996e99ef4734b59626ff43a8677616ff544f830985dc9ff8e4668a5ccda95efe497fce8b890172f6ed0d254119ae31f69affe67fe8251055c84bcc7c1cefdfc6a007dc9049518ae28c4e559c733f96acb5e5ce305cff268f0e234be81045a5e9ec4530f2ebd060c813ccc892bf88d395782fcbbea4ecf2f9e95f91d090f47b2c9d1ca48058de4fdcf60ce8ade0916b2cfe757f6feb9d2bbd9f2f66990ff89d46eb16f31827665765909e4c5d2dc21d2706cc273b9e69fca00db21273ed7c06effd3a3de8ebe8506f5c5626f40927f7b3061172ea62c176c449fcbd5c9f41e30c4f8818017b9ef54531cf731415c7e875f283e601d9d3234f4fec46018ab325e6e9fb0dd8bd58f741a7f7832f8bdb81eff1b8e30bb2d955ac7c7643ea6d1a99779963d6a4d811629cc1975b20f9af9eac32c67eb9b67ee3e18d48ba7c6d8cf7ffdfeee7fba579caf0ccaa756587dd14e6aa8e49e8d79062aefa82e723228a2aac0da806056f60346e1502c376fbc55e1c7223245e9af5b09312f819981dacfbc1105996e88f27b6d2a260f2b6ab12d9b3386f80d78b0951874f8cf63133dc63bb2ebbcd76fc2e8805d8592c5685ca52edbd920df6a4b53718ed2d791f9005e00d1ef679edcd3ebf1719f808bc9c700ec06ace9efbc31d32fe3d033560c3a88cef583e0e2ca13b574c13fb9b297b9d74effd5a4640313abc947bcb48235e330b49da7720cf9fcccd159616af63ab41f5bd0478a8a602d9bc9345c76a1f2c768d0070bc2df3b9762e401c97e8bb2f1d1c6d19058897f729c16fc1cd33a788d110cef8c3e94e29b425e7496b49b33c89321d1774aed8e672925c966d7903d63a11b64323fd284267a03a1d5fa3925e58e785e51b5fd4f6fdad90eb72e7815b31d30f266b8c2f81da0d6983ab8c9e22618eadae426de7031deda7ca17804ef99e46544911d6a769f6ac7b23e441bc96319da1c8323726704782029267afd29635a373c2f97ff12136392efd0528bd44f635503d2b6a7aa3dcb7de011973d9547c7339209d46e40af776701ef86499c7628ba36146d1e12433b552fe630ac42bbe30669a6e871ef3d47e93023ee883ff5300c865707eec9ee9a041f818cd4188046798c741828b83c06ba351ac3a22b6c5d6e905d38ae6e37c40f0eab05871c69e0fcd2a190eb4311cc53219b458caef1b33cf7a71a8e80fba422cc9bf201ee431f7a0b6e77f411ca25b0cb22cdec8c9042bf84d26ef4de0256ec37278ac8722e894c203f5feb8ca2797a02f9d3845afbc130b3d9ec75f427cdd27f7d0449b07dd2a95f73c79ce9038fb03d2af94f4745114b63693ed184d4443adc1c26e7d5f5dc574b4ad1ef626146834229e5c9ed63185b7ee020c950d1ca715589b0a95cb61a2637b8bda10120a0335f616e821e4c2882b6a2bd8fa25bfa88924d14d7e2292e54eb4f7233ace3da17fa6f32ecdf3bf3a4794438f3b9f832e73723d0d393d5596eb48501bfcd3280e11c7b70a73b08927a43c4f28ae722771f07780a46e16bab5c3c937e23d8b55397514cb3a5cce89459f55b72b4088b91caab967ce8fb007747b3f38a3377c599d1fbfda1d4a7ae65002face8fdaca2b083553e87de3f5896e02805156e0d71ee5944fcc450d3938016013a8d0d709d97fa9948ef9207cf2e620eb3f2bedb7529e3901a75719cc88517f5102c4614d6253d2bd9d7f3ef1a96687742503a0360a71dc85094c76be8cda0590c17f0f5856b6c8e9c04d9816f8fa53b6c8394a6c2933e093dfc453042707d7f22f6aa79bc4e0d6fe2cdb17eef233ebdeb8570bbf30a952a69d90df002c1a0480005cb8a6a12713e7de42142ff5848b3fb7ca268e3e2a3b68876b6393064d894b7326f428824b0042c324be77ff4145704f90978a4a6277695ee7ac18805e2ed13220491286fd1039bf11f3b1610a83beb79f175b014af4ffe380c305f36abd6dad40e8e3339f4190bad78145bff7d0ab424c4e3724da2d3e20512c82eeb3075a5f26fed40f12974b1644aafa62b1e97558fc072255533367b0746defebbaf63cd091f31e5b1f0a80e5c22c4c34e1ad68eb0da9b6e09e9df2e4b0e440f8f10812b210395bc14e20474f06d54d54ad78ff27565432b1ac53dd1d64e3d7e9ab7f50875a3c330e759e76a60d351619070e8a1437715316f07157f0333351c899deb20820ea568cb675b71c669325247b479216461feabc23f2797848c42651ab3f4976d9de701e71d5df03180524ae6cb38a5c900f8924638d9271e1d4aee733217a2220062ef1ac5a6bbc00a09b7bcef4cb41146fd734fe0021f35c9287fadb76cde9ecbf00a4f8639982f1e20e837f12e970b55d1111850b10aa575306cc6c88937e41ec789a0f81da85df593a2c7ee0d7185a37efc0d726ef8a8daaa73a9f1b88eda2da7a2624a503349499692a1686c99990affad100801a63f31e2500cb32ed3edd8d85746625b5d94d4225971d6647cdbe4bd87d8bee7d788c2e16218e7a432810dcd67bc6a09266c149f3522282231aa885afc0dc742dbf2a0a645f40e10621d709016b6dc03aa38218ff47f8449dac78300e3abdc899cc161122be8f82e7d86395571c8db99ddfd8a92c2efcd3c0e9c084420cc8b2aa7d4846800d08002259b3ac371590cf50b80d50abae4dadc004c6fc387daf60d0f73e51a4ebbdebd725381e06c13d8afaad461d4bdac6dfb347e95fed32dd84707d07f32ca6244b938a2df10461f6158af9b71d3a2c966fd4e73dea272950b851a9846c02d36ca02d0b4c621e92e8d7300e05c198977b57e34aa1f504a2cca1f7609b776c55828c90c35a604d1f1af9e1e7815fd1dc88852026cd817d3d94a7aae6155ff30f6903703fc50f9ff9eb9f32fe84aae19c40179be7c0e0d927fcceee2312394cab7500696461cd20543469c71922e4c15f3a2840d5407946cb9c13cca6667b9bba34ef5563a2fd26b26adcee9eaad40c506deb068c87c28a25ce4ac7193fb1981c7e03c56ccd12bf8caafe96371002092766ba901f13c105ddae20b71281e304e62c78ef5ff360869eb60b84e979baf76ded16721e89990fef9757c959cf270fdc9007a92d0fe5860f744b21dede2b55f9f9facbed30acb4f27b4623add5a6a1bd44b4074fd531a3e8219129ecc41d81e185dc3b0467fb2b3193cbf141a8f30baccbd51f155ca065344ce171ace7d4a80585a11a6c073a9e3282a338de6fd909d7a9acd2c9685806d11f6b7a7ec843690d08de4758ca4c016eba7dc9475158dd36f00990189bd5b07a54f0256b2b59f1f41a361447127df7aa29af93fbbb1ca757b2b221c4ff0b4c464656ba560250a491a1fddf9344815e6eb19820539aeb0d3aa57ad05424a6be231b5624c67f5a3d28fc18442dd08512d909714dc8874a1c284a204882677679e184128b933d9e96c3a196bc83fc902ed313405ad257de8eaf0c1ef734314afa34d22b70319cdc419cebc698275ad5a7e0f7d0e3ea6634d65714e8183f24c12e8eed247cc5246843acba50287daac8dca394037d93e7e675890364fade86dcf4d2f603b7ed025608e698181ade8fe74a183a460f203a03301d1b6d687b5cd9af18f1266299f29bbebd3d393958679948eff17f5d158dd1457c15827d625e69fb0d0994f255bec67998c9ed902f3154110514b6f2984cf68f5cb7832b6808238148056ba51412fb86afb38d65140d111bf3e1a0d6b5febb1cf09dee7ff98f06b893b65b05a6871d696b1708848668c8621a0858a0aea2316c3a20e1e9346114f45f2c7ab3ba6529b167b7dcbb1f478316de045103127f2830ecd763d92e2372dc5be9d1daba5e0b5dbec18763e8256adcd88c32cf1623a6f54e8bcb99bad1a52ad75c164fdde84c114f6257022b386c038193941422130a3cfdfeb95c416c53b25ebe54777de417e7a79865af4a207329b3f84f366d0a115a3919490b917ef14941df2c6f27cd04f0aa8106e628e92c76b386abf9a35580c325f239808d13633d2359c95f935634f16862110ff3dbb64eda2e78e8b3408b41df9a142ab8e066798910c42a2e2c86f778a7c4c39fe0536876d398fb901f780516ee6f9ef91c001a22391747873aa6dd654e70d66690494da4be7e5a218b911f7c3464ffff6ab5c1ab906105991e9bedc147b01a25e2358f3e3eaa9f7e2cc1d9d06870495f6b00a236a19e17dc205baece553bc2f94b87286bdb113a4d907e11fb802b7fe0dc3748c6ec3ad468e4b3ed691b59714e2f8d78834f7b986706e245d9c5cb9c345d7bb1f6a1137232585459feff0a33b540bbe0f55bb801b70a63ee3423c03db16171fb19821ea326dfe2b6b058de401699069f75d3126a97a81111305bd5b336deb48c95a6c1d60130176523c1a6c1cc658912e047c54912e0da4c0514ba39f9e0cc0d06cb97dd6c367b37d6e4b20fd160b7ab8bf4bdd8fd4ac9920bc6742307d7814a0d64e44f9b0270d492111e8cfc43606b7f509b96ef2e9b1afea5e5b380a4cdbac54b35c5d77e0a53649601884b4e9dcc7265c8e498f944bd43268364c9c57306939b6bc52edec8054d740555c151c6b366a55014353356c4151efe858e441b2afb29f095e4aeeca0a9ac9c91e50b5616c75e515fb0bf67b528f3938124b02d10729b82cb0f88bec6836f3e3548a278eaaf5e6adce52bb018bc2404dcdbe27e4ffbebb16e9d44cbeeddea399ee4662674a28a2ed795576d3dcabc62044de2618792823058d130f0f1509dba8dc43108731970f7dbd05fa5ff17b93b6ce01e5141f63c36b34d11cc29939564804b9cf98fa249f296e16bbef9e1a791500b98c12d3713c4ac9a4cc2366519616a1fa155cd1146e33d8d35c111406c1e900cdfeda1e2bda1602fdb3479910d1254cce02482bdac45fe2188feecdf23492ab460f7765237debf4fa8f7440004671866716f439c3939aee079ae57790828fa349bb9d263a6fc53de1aa65f7c8343b6522fc59a19dea1efc54fd92e99485c3eaa8bc392d5adbe0d2c742cc64d08d007bdd0274dfbd7e4e16846dd8fbc017e984929526eda1fe97c23e71d8381d45648df37bf40dc991d9685a022fcb2430f73a8d1b755e18dc7a335c21f25552c127023ff180623d74fb8dd498c7c0c53986b17384ca4e0b1a67b96217030aa7a24d6c39dc41cb2103491bc06e0cbf638e0967e4d8961d5c5371bf354eb9a6a7529db08ae3ecd5bf60a94215cac55d92a107263f92e2aa3d2f82b120e70737471560f7b132f5d6195b82ceb476ec9a9f86afcdde12742402a5c9b227e582e934e83f8e04cc31d5072c195b491a00ec454738a82b297e36e1b334539516d6f86356708a0ad91bd17a3e2861af30ca145f18c7c98b646ad40de9478993f9918c256e14240ec424ff2200c2c2e9ee77c057e3cedbc9139e2b92032df6e4764cfc00cb65aae672077e2949452beb6341536ef657f79690eaac86aa564a4ee53279d7d0d1bed754bcbc7a245f24a7af98b0d3441b6a1916bf360ebf583cb3968289a564e3bee2055ff209388f81058b852e52243c1c49d7bb9553d1a7b649ce25e6c4a9c335932c39808f37026ea32410be16d7f918bf9d65221268f8996c39bfde4374b02342db7ac237feef2f9ce33994f69f633361f40cd70a9e6550e6c6c6336706df0950c26c55525a9f44bab34ea4a8afd1217c9e9d685badc00a47e5b009e6b15417f3c4591815b1640ce00f2774ba163c94449cef009505adc4ba48b53c434ba1431f1f818916286484b6ccdeb4f76c9259676a760d0f2e9c4695fecdbcd208b0e41e48ed125ea7a28d9be7c7e9565f5e8c921f2bce7c1fd8b03702d2831c039864015159fe7ea8654fde8f5fbce48815bf8955762b616da05f0e0887f2bb9f543611ccf635d94c3a751da38183f71316d079c35b84d7a9e628466c05a04bdc88d3979fdc3fd67c08e578541e6bade0e3161a7a8670a9d294c18f38dff319506a02f9bc8ad80b10d6cce1fb2e68f083b03d83cc02ed8640bd439808fa0e902e9b1bdb51c9db84a41534b246d4e5c3ca981264787129b1164a8d6456cd57d4187f155311b785b7f2de477dd1147a6c114e445221a6ce380101048e1501d44f5898136505f6841ce181730c0e68bda980f9804f9de6be6d8c04235a470124c35c3275b6b78017d61b3f6b8d436161f09091c9ae7db61feec1a27c02bbef8b141dfb41c8e1e268841a225e1fdc6237f6fc61461c18aa4161d06920ffe6744c87bb25d75a6308343d378e13eb44ee71f45f81b16a12a7f16725efc8cb585028e814547180d708f0a2c98d102e0f5a93cd99ac08949ecfc28accfe672a8b9dc0b44fcbad8fd1d461c76a4785d57f3b04ad5f994c4f8a3f60829484df216ec4399961eedee8111bb59b041e9232cb2e5993bd508f2dd3f02caedecf428c0189316ba87f4fa5819c0a9da6a8396dcf9874c9bc4455af3a5263274cea2697faf1f10784c703a3a8079ccc0f26eba12497080e1e73aeb9a8f995a63cfe5a93ead4e1d7ed9921c0c21b78af7ed9d9d516ac8d00726dc9d5c7922829ff2654d64ac3df22dc3e9f27f78b38f3f6a80d63e1ddfeeb59c42768c893168edc5435f85e6a135ca7173c5eb892df138fe7099c7c8829fe128ef49ab75ebc582d3fec530e87b688670d2b3f51a59b437289555cd744da04f10a7100f8080d8d13915d5029a6771b63da6340bc2c2b6cf1e7d87b1df146480e60fd6c53be531c02d7f31a4c50820e5319c61b4931c81b57f89064d8a1f5351c85386f431286892426ea9e95c099215f68c23817d38315e580e39936975036569855f2024f0f339652b4c51e85c75740ae3d9fcb882437dcec022489ba24b4e6993678fd4c85cb6493e69b4ac192fd4f77afdd3e09c51749d9b93a75d90c5ece0c6bd9eaa3a37a5612c74ba301f3eff94add6417bd2204c220f90dfd1c927d606604f87ca2dea73556214ddea13d917414d96099315a11c3d302b2b70961aa432ee50dc165bbba49cf4481907e71258e3e5a0734d19c2f008206abe48c8ba99067c19fadaae9a0899c96abd2ba3ab69162c91a215d5da5881e614f751c69a74c5d8ec0541a44321a03bf1bd64ee391915cd5038d361e37ab2792ac553080363067d2aca54e2722fc544d63423332d8bf308cc08e3d08c33f425ce8e346d51f7e7d94c3cc1d1b7fa20bc3b0b457824f69f89454ab1e1384c73e0e64fd7801919cef697dd5c24df6385aa71062d7e3a04952949e71af3804bd0b3d400cd8cf99a4d4460f3a05c4942d15477e4143f86439ee2be46286be9d90229b1d7881036e0aa80270a7e47164d5b8fea73ffa9d7657d06ce2b364414c833e08604ae54943f49c1c4f7c89eb0bad3a643f4a7bbbd4814726d02b7bc29f6731ed9445a2060d0938178914b0beae8f7e099838356247ea574a3f9f003858424155aa5ec5f318ac715bd218531d2626e1eae94eb99eeb1660916db862ed52f8fbcb132f1c00e3c1376729e78b6e1d22f022392c56cb67974b5fb413a1cb33ca5dad651c35be0ac24951fbaf1c6a8b0e93eb9714428b36af1a3c5f6995523ff86ca18ada0e1b6cff976b0cbbdae3162c284d0474c76219d3142c86f1a0f83351ba91fc487d863d747aaf3b0da2d72cec230043712e2913822629c2d91c62a5338c173fd7228d4769866bf789bc1e85307bc81fa78b8c26c24921b415ef83f2ab4875353c289c387a9e613003ceca0ce96edc0430c8f7db88a81a27067ae909a2b2cd2c8b292459df237653802698c8097552afb80ca8ce6c782812248c4bba259aed93063395176eba28cc17072f5e74c42e4ea9081ee104b169026353b9b976470f4c72e6fddd8f1e26616b5677e805d3d2ac71d51f895544efb86f0793ff0c8b699ea4626fbb2336039e2fc34ca11fbf1aea1ff22461fd60bf7d86bcd6f8f9ae30059de7583b8205e240f05a6f43b61d1a23545c3d531801e60f5c0794345072ea829a7f5084003caa1404b90c9ed84876b9c9a7499308a3e0241a4715f779a33cd5f302756b22df7357fb1a26bab7bf02d2aeea1db427a784fe1a9d878806a85b1fa13fb44416ebdd04746a4245ac7b06423ad9b21e193d5bb0ebd73db5fe8db522014398110173f5bb90341e0d9d38ac4f0990d553be5215d6da88cc15fb5145562bd38466a40dc320aa757493a26e4bd8cc12c5200f4c601ec99795c9210c916bb8941452bfca5eab46cfa7f1f174f4044db3d25c38b3349c5675e004c4d29afccbaf0a363e9610678b55dff82947071db794d94d186aedb80f6ae695c2194f3c7cae24d635670899d996977f0b4e3d4ef54190f2e9eabecb611d8e7836551dbc35009415cbba97e50b5a864094a55b5f20bb49b14d7e15f64cdb496bd219f8267b205aa024299fc8a5df6a7f3f7e94a12bb25854e64b6e281aa943854dc3c31a41a6450c3e1207acf8af9259f792fa99350769d58b6df6dbd1522e7596b6677b66a3f76be6f030e06acecf5f68d8a40c61d20a2bb01c22d8006f467573cc7b600f9bf859aadcf1efbaf2efe1590c3541f316428d05647046be359a52d6328fecd3f17c93f8f6847b2314e552497b4d47dfa1d5c91966a806d1636ae7df95be10bb5dc3d0c5b3aa1157770cd26017947593dd2910fbee83996c68d2ae693c959c7a732c8f3d5e9298123b66665c4cc6e24cf14022179dca80aa8292124653762758480566c448f9079840b2df1d0b4a2b50f644264db1291326804cd95baa7bd0cfa24e649777d366b895cafd16a72b0208812025fa3752c8e5bc6818f5c8ebda7fdd367d7bcf3558e3c7e05de9430f1e5672e579c507279ade88a4b255c3e593f410732bdacd11f0d6ee8464b71c0023ef79ea2a7a406dd5e1be32e97c074e302f73b5d99661b0c36efeb5c721d8297b8b55f92ffe75640d633ccd3a44a2c29f639a6361e462db691cf6b32444d6fbb6c88dc21d63b8db2cda2f012b7b46bbe2b253f4a63e8d0f5c2f637fad48f901167ef8aed89c56b4e7bd5f515c605b809ff0f41fa93b1eb003b85f02ae24deb775aff054ae1a8ef034aded829c7a1f7ccb718d58ff522da9f9393dbd1f130bb1dd5cdb6ee61ac3822826f9f61a678d6f207f3edf9538b5b9014848674b5071b07307b715b5b6f93c871ff56b835457f63366df690e1f806609675b9b6db0af3571b0f04420ca7bff53cb0fb062a0c609fc715ebcad55fcd9497e4e898693c690d7153509f252df84b7e9df9533c8d022876f93c39e017aaf07be45c268241c50b613a830b550dd77e7c9180ee43bdaa5916cd223c1566e96044b96e8053556bcdbe2a5c3b903eea33055eb817d7c36aae87d795f168247f29f19c195617b2e40cd6179ec4bbc577f86cd74d46fc1dea01a4f31f0cf07a7851a87fe99d472bf65330d376ea7cd3a0fe1071380d19a87dfe20e16e7399a10ef84f1560b71b9edc08d4e2d22a6f78a89e383b1edec4140b84191317eeb39055ebe31782fec44a591466b45583cec81642b3a89a6c32881be04c743bd5483b7d9757e0cbc73c3eea1d1155f35bef6af62a5a15b48e58589cf7502dc6432c0da755dbb264a596e9ff0ea95e14e0b0562b6367b27442107acd36a6b2ada732efbb8346349a3cc2b148f8e5894cddd2dd0fa54087e800e8bcb067228008870660f41e9614fc98335cbaf334c659e3fc72b442c32f9f9e23840b860f11fa5bdc2bc99beeecb108f33be8fc359cfb807a56b5b661fa08b1cfd2ad182b3eb3d0f32cf68dc0ba23bff5e92fbcb72b133c1497be6a76886014ef1fdd09dcdd1d58094a7ca599d2c0fd99e351d9695d3dc6462e97fce7b823665d7c94140b893c51efc054de99e2fbd28fdd14b80515a91c98254199a9724b94c61a4d07c3cb19c8ebabe8e3d1fe79488b4652dfe9c0a491f67094c6b0602ac27d3e8e59a6bae0f71147c1d6da1bdbf6cb046d5f7d33d07d225e9cde1d3c43c479ec8428192e2563bee28ff769ab87badaea5a9cb2478527cca698fae8bbf59ac49fb63b13e712d1bc2591f2ab0abdaa9d3e11d44521deb07cd5705d453de9339dc37128e7ed3a52a8e8f8ae270ff56b3e9aa27b596aad85546b9f393cd7e05cf82d89f46848855f0d46a375b08c35fa8b37023f32bb39202bc853543d2b26be7e00dc077438d16d4adb5ca5d8cc13ebc0edabedeaab6fb9229a9cb80e6a4ca9af6df21142f93cd4773821d122a916530cc504f05a0e789dc6b5c4d45c0c3c587944c4178e3685b2c496e4f523d2499a8ae5741501b48646f4bc853c7d6ea48356c717311763a3b16e1e8119f78e78835681cfcc4a1d88308e58659ced19cdcaf467c6383ed4f522cd1292b6d920e4a3e8890df8d0a0beb3729cb54ff02580747172ed7e1a816d35123e32e336c26cb58e608705a78c6346d54f105dd93b8849f1a13da4733d8a46a65b54d2af3399994de7fdd3a6f05446c6a8ddc0e9908c15dc15cacfe11061ac56d0501bd066dd121a212dbc5dc880b641977c325fdfc57cc020f8ca1555e45de688208b5d3533425e706c52bed8dc4a47d5dd7c4bdab9348f25d3cc78f00d0dd9dcc4eba2c731b3f2a7f822858930eb8f8a5b24c8ae664f3b736fa65a9d7cb44e9d7f287492555acfd877544a9b8e83dfd1c2c53a7eb1f48fdb7adf90333a803b247492f5212cb69552b7c4e185fe58c45a12eeb2975309a4cebbad6fdcbe1b25d57aefe23ac25cf7464591e8abb495b4a31bb4ba73d06e290a70055cbda55a452ad41dd15add8b1ce9f8b1158bbf5a5d183bd5280393ccd0e3a42d1779d5113d01cb1539dad3aa061b9e30093babc42a2127fe57d97063f7798610b747f02c495b55f1f4a03a38c706466cdaf789eebf82cca093071bea8499e16fa2c9b57c964415419fa240267b33a50031f358b83de58360e209e0bfb43fc69979a47a799f8a5ba91165129a9f4f59e2d30d61fd6787640ae1cead847455f7d5bc35eb7f29ca7441ad3964ea300e5ef3ebba2bac00ad87d1886c8cc178bf4a13493b29332a54fd01f60405551afc63ec6f9fdff2b4a75c95d80d8d12210192192c6ba568b2d93069b8a8956c10b867d5e442e179426a2b88b213bba8cc037687aa499e0aece384522a29388718309f40d5f82942e2a0f337296f3328f75551eb46ae97225411cba07b7e4892d3331b9a570f154ee6cd99293d4e7d8525187915f47af3c6b395a6270a009b0b258fe00cb0dad6f668d1b71a335a551ec3530321c3ab8a04085574af56c120880866cb76a6587993ef5350a9642e810d2f4f32cd927575943b6834ea1785424080958a12a918d49d2a6be5c1a84d987a5fb3aaf54d8c51aa439b29aeb7d901c9d0107f42bfd1833a87713aaa22570a4f5f96103419c0771f667c33e5c4d444c38406c5562f7b2c145ef83ed86bf8913f5f070f3e0d047c5fd9106249524af2ce9f384926023a33fdf978a4c6df9a03533b524166c5c83334bf89bf4937ff87a76981b750070583c7919014c5835284a422a9cb317cc2fd629746718f3726df44b1c9198542d805a578327e6f1fd548ec43063922866ab83303c1ff9275319f10729824c1fc63a4a9d9b0c89040c238079202a7d0ffb2b69250761152e280c439a2248a70ea2cf3a5a03139a7509e1e3f7f59b602039686a616b4f5f9205e13084a0715fc243b0b8f36239c78bcb3f5fa7867569fc3fdf250e8246dfd16d9601105480788348641dbda7250e6dd392e8bace96ae0ec21c21ed4497eea5da02408dc13a9481db8e0f166cf55f9f01bdea053be32c85d1fa2fe860ee6aa0b9eebb58d8812cff4b624c8a3c1dd43d41e7dae38e94ff6df8298a7fc060102b0fc378415461f26c79721b8faa27f2bffc059f603501228034c3430c865ca3def301c5462462777aaaecb279418d7a7b7d688cc9574cc3ca50094ce3e4393100c51ba8d026eb1888cc988c6d6cf36d056b4e181798d92b630d43b25cf3f02195aa0d4883828a997c9616601e8cceecbff89af12881a496fce5ca5c218c76cd7511add428eba094f587f0fd928198e559c1583e3cff159b1f98af8d2851ee7191ed3bcbabf45348451c26d16910c2932fed577670a07b4308c53ea14ccda7d415d5498c8ace6a6460bad15ac5dcf1967edd2f14610e57630a089742f8a9b13e549ede8ec60dcc72d5360c1dcb25d3ebca23e3467b8830cb08ebfdc9d125fa27c2e588d08f20d2a06632d94224626f56c524e9368bac3a26b52c9a6855d47d72bf04ec0044f52131a431468949f7251b3589fc7549a89b931e9df73ca42375802ee658763eeb567e0698187ebe5f7c15843b7ef6c2f9b375341ef43cf77afd621ba74be86555d996fe834d8c11c1c753d0789ba37669a0996e68b59e35ddf31edf2b04c571cf2433c5727a0b32b1d159f77c60e29e556bb81bdfa3b6b3346f88a0d55a532364d5fecba74da018e715d91c9128acae6558a70269fc85e1d904b20b0aef87fb5b1566f1123053c9dbe3db0d4933a239d53170007ee0119558b90cf63d961f5c15c6992ef22c95b022134317106c7d0c56a1036ac8e167b40d2a44a4c62cdadd5d3c77b74a513b7401f98c682b8b020215be21cd5111ef0ae699946c75f7bd5577ae152761ad8ba03fc9f2f097e265a379b954e2fca6575a2e60391e2e84fd160447724e743ba2571b85126a1c76fe514a1c3de9a781b2da681954eb25662ac8715f2e5069ee3752e78185ef019f9cdd6da7c7dc8a6723ec04ff8f543f441d2661d9a808dd914b8cf7530e1d6de2d74c6a9de31cc5036250388ee29851f0e85112066f01a04fe1ee405592049484b0793105390ab6a5dc7168210d89269914eca8fbfea500c077f28a69ce1a366a38fad2093d0cb276f721ffe4c59c1ba6126fa8ee071af515b3de22bc96b8dcf6a4ade847a01d7e4135292718a2d2e0add0384d7a79d3e56cfd25428d885e55ffae1f5556d0ee2f5587346c220e8003bf1a7916dc3ca915a4c8e71b2bc18b5edb5e934e8625bd7c7c29189d842c36baca0a7c06b4c1ba8f1a3579306f4caf559f016df8a5c5ae96a902a7c040f91e3c5fb9848df1702bf09e365c663061b02fd199f3d162d24164533affc4c8f6f8bd8bdf3b6c901e2178e43a27301a1c5902a1eaf1fb4f85e50cb5a2c85b4c02d20a4a5bb47b118072765f140e32963e40f5557b9222666ce8641b8bba8e5c592efdf3d38c801c5aaeba71183ee74c05d48de3da28b21bf531eac910008b6a7c3baba9e60560f036c32c16e6bfd7deb9d16896f5369d2579dea22aa2186a3869be52b3f636f34ce97c0de6d9601f8bc195c59288260b8228852f382aee59d7b668a1b763ddc3134f99113ba7afaeeefaf674025afb1db183dce84c915782a9228ca94834e4cc1f265b5fedb66504aa60d1cd82d548a830e8dea02aca52ec47fed7cd5d296e693c9f7ecfc67a80cb721aa7419db0ecdc2c08d6ec1401428972bdccc593043a5aac9bf824b70ca074d7f63aacf9ba6e72c9a248f78753b509971f0aaf4e79f386e7c1811e8699d46217d87a31d101becc98f8f8c757e510dcf7826f05b43f969dc401b814051845c36cff8c00fd1331ef31efb95bfa324c0cca391282cf75258585e3346cd91b21fe5da95ab2caf814a6784396b7469f4acbcb3603d5af5bcfb15c84f3bf4c6754d404feae786d2f176fe7783effc714a0f7910cba6f00bf6bc4ca2da359ed3734c5f28aa257b84e3a0776281ce2d7902a65c96457c311c89041abf41fc61ecf7647f0712bed908daa0021b0700b1b0c68bd720bef443c118f0baf120fe7c5fa213b5d23c017cff4692b9dd95df857295628c29cdad5c08cba7ce5ba53514834d74a4b660f9f1fbccca1e83e10e89ec0578c0959668fb436e51189053dc331d42a1607c679e4090c6017192103872cfb02f300d47343d7ea10117fea905532dd6b61630d189c501325e06b64d53602cad5aa31e1fbc82c2c8682fa16dc798b0c73216b402a849b564a524e27e620e0855102f3b91be8434700030511c12e84a21d75dd77f95f2f05e1de40da2578d4875106cc53a0864cd573bdac96f65b36950b00ab1cb04bb2e6edeb1f6c4ba90ee0cf09bc347dd955379566a24c742f3ce626edf6fb38ef185be73ece603ca1d3466676a39d692c74f04436c495d269b866c09281724f914bfcf6d0d5be93159e8abc18a72206403c0b50e5f271d7d66a047584f1039157516e222941ec506620025c6981f4a6585424d87751a7eb762dce3a2ea1207608e229a3c72abdfeb845a2660b28ad6393c294f5bdd3ba0527022580a06847c71c7d98f16454a88799e90a43006d69ddcbafdc6a5eca74524bff1002a2ca910682fcf5d991e3173ef3fe1fdbbdde64fe6b2a70ceacfccfde4aae81e146ae88426669d7a754ef29fb52315b25c48e2d84d65d9bc3109bf3c852af1a87189891c9e3260989ce8920dec1fcc835c959d088fa1b5483dec5a5fb397cd273d77942f7389a656c00fec3284ca0fddedb3ad337e8476c8b0eddcef591187079ba00a7a14e1405ffce9f50580e6aae652b7f12c1fc4d514c239bf2a95559663cc0fc85be6c58b023bac754404064b778205e52d894c70d6b31377ad734e5081d885060aca23e4dccd3403c9d535b8557279fed82c690aa12818c3edbb64742ad8f092b6046be6148ccaf2e0363c7d85330eee4afa7237802a6820221863e51e3fd6f9f5c3989db6ebebad5017e3490e1b5a9cba19b40dc91b49f9e914a4ee728e6a3213f33e1c94be3eaa61781603e32ba41ad8a4c5afd5cb9a9f3579e4eccb60e4f8a7739b1432a81a63fc3b5258f0e791d65c7cc97c94bbece688256fe0bfcca66596bc717d75338d89925da126fc4b43e28b0c02d6999af0c197f7ad3d15c4738aba0092ae1952f60891813147fc45c8589f74aecbba9a0827c72bf14fc06253b1971f276c75eb4c1536cc634eb220177d8035cca3cab29519b34cb2d55100f7498bc1f79da8533100e7cb7e9a87b35b5099955e5b47300d6a5fbc880aa020b7096a66bfd34ec19ac5467fdb43552b501ff4a4de5548a9385aa40b3edbcddd0c6fe3702c6137d40cc2dc28974692ea53048e60ba53e777e7ef3f4ab010c57b996431925994d498b6d43c15960162296a1ccd0a4499506644b98dec60f25e7e3ddf029ff067f1b499d4537ee4627537e3b3adc02a3f46cb0588341f116ab5d428cfcd860aa4c1e0d8ab668e0e01471d9597e7e0c7674e242dff7bf02a161d79303d0267d6ffe279dae4e8d0a9be9d9e6c057c8678b79b8afa40e9ea24387e2a217f6c2c4a1e94933567a43242d3a9856c3eb5a175d445abc9a8d09a7b5c586b22d8d0f535a88b6c64b46b4c2f7206ae474fe843962056d41c58a70fa86dbc83c875a6ec6f9cd9a879084ed19a3999aff795a996c9c084b75b33e88f5f374fa92e1e03193c6e45a02ffac065d5ae1bd7d62232c4dca862914b2aeb724f14f498f11c528cdb68b16bc46482c5e5b3d13634d3ec8e67c3e552b4664fbc3cfc123082dab5e560c1aff0aebcb9f4b6ec8dcf5b1b231baa59c32b5578ccc54b109e43e7160ea7207805dd334c63cf758e04362c69d093c1b68c6ac2de3bd707cfcd8da8066765ea5bdea941139c0db092dfffea54808cef8a232694177ab17d7f5c97289389347b83cb33dc72ef157b298766295c4111f8ff25f8f1b38ba00af6074eaee86b17e192db2932c3165eddaa1ee46d355232ee844456497ba8e103a5f6e611e7fe72f900798b31747a88eb6800d09bbf09d34bad628dc7a1b00e1f81ad874619b5f1a8852aa0aef05fbb5b5990e672ab6332d7a0fa638c14a0a0ee024549459dad99a125d15af537c977802974e4944d1000633b8fb48cff0945154ee69047c5c1050e0aac8a581f89c3447aa458d114fb42239cfbd132abdffb87b08e1e15f3354e4944f12f4e85037394897ca3d0a512183ffca8cbf1092e98d3abcff28f118a3a72a0c4f6ee83db674a0647e513684846c39db1c6d4f061eb3b6a147be006d31a3eae30bd86082595a0f136d6993e0cc071c81c9b9112528383107648ce3aaddb6e7be075ba1f4012c601a514368008dd85b2ea506d8719b805112227ff171b2a6c4aeb290d42437939b2442592cdfe67a48ea5227388026a0b21283a8f870281d2fe97973738efb8c499aaf3ded77fb2819a82efade8eba95330e93e2405fb3b11cb012bbbe3a2197220eb55d9de7d63af674dbc1064eb63ea6facc21cb214a1fdf9d8e96f05c7946005ff67294a825168fc654335ba99bb381fcc4216b76da9ecf19989e7097df11dd7e6a4915717d7f8b2d924c35506e02318ee603c74061c9fcc813ca58c1af09d21c4ba754f020bc4609b728edcf2d7c2e4a3248dd5405719c9e98df80bbb63c40c8e8bb99c233688a6dda36e873189e228c9574d37099dbe2dbb8f318b86af32aae615e67e46d290b256fd26a398d4fca71691f8ca390b9c7af221f079b2e02e1072bea6b05be4bcf656704ff2a980bef27498ebccfe51e289a86fb44a365419be647ebd08c180e2d256aadab69c3080a499f9030dd9b96f0779117d964c0c8d0936c88f132cfeee15365592e46daa6f1f5c884264af51f876c169010a69dae6fbc3382f048de9bf61338b73f4ab5f02d2ca32f84f91c45a7ef25a34a9d4daf98d36a26a1592cfc366999369f75d1fda2262695fff49a071a14afa7bbbe72385e9be60a9b21df9e09f435e88c09b615185c564375cb2d1433dda29d0a9cd5eca59376dbe4ee6b4f467e2296a18aa4f81ac02213296990b283a1d36c579e8dfb8f846e4330d139c598fd94cfa777f3081f2bfca1cda029e63da1b946f213f9da70cc6e29afe479444673a73ba945a1802fd87f7f299165abd1499c79da2684f26c901677ea1e453cf7a39e774b128905eee31cc996dbcc17c040c9359a9f1bac8dd063436c783b225e722f0312bf93730a1f5cfe16de425ed030b6065e85f8fdd6d7734ec1981d52205fffe8daf6d5224b8137bc05981ea3109d4fca1be0c810e99307cfb8a4e131f1ab357b785ae0425e8868d71724b79f5a71cfe61b8cfdd9327de5a1431b1bc77fdc804339982b96e026d4ce8ad1f53cc98001121e2f5225b4fb84a22469deab4fd2780d8e76b3703d467a465634aa08f79f01e34000bcf3f011b009c28b42c75a45111ca824441c147a89a7cdde1b242cac3e6443f8c2dbe8a20151f4962d6f62364420d65fff06d5f034d2da4b2746818b286b09ea7bed83fc13b256318e407c81384a7063382ca1f8bf6bc4e48517fe08c6297b06d0cbd6019414690a29fd30cd9c4342854e4b67f347c861beedf4b02b3d424cc0ac0a4b78410952cf11b4f2166f90f053cbf38fd104af7161ee364fefd5211423bbab5449cc5e7f035f2a2b1bbb313e110d0ee4d1b6b58d44c1c3de90c0fd0beb54ad1dc064b6b787c8ecce420137a3ed3417039de9765813397e3cd8bdb4d0ff0a2b7d9a6ca0031f1950fd96f9012f35f4973175c656443217d9fc8dabcbb458d9f112ec68a7987a40ca812b17fc5bd67f6ca70d89df2fd88d6cbe9f44f2f924f355860541ae6f936a94a6fc65b636c0516b10c5029573b44d9a529926d1ee84abaf68daacb8d4af046de4cb1747fb7a8b9d23052118b534a81f5bf6078bac85b7666cdd3e3f5294c198a43cf0e9edc3279d288bbafca0caa7ba44c50d432ffa00869c0d3e1a859c73bef7c9142888e02a6188e5aef0f762b117949480a72aef49fd642f2a7a2bcccd4a20a0080b249aa1608392fdcb81c6249d32d21e83c2d04c65f5542243e052756976bf7243471efcbace1a614f4ea7ed4de64a7ccf7a5900212a51db03b34be2f41b563ddd989fd079a732d01569dbf802727ab65aec2fcac2df7a1b7cfd05749930a77644d4d55c136fe5aa47a2dee5d9004a373c0136c9e2385c666fd415dc1a4e4d3f0061d313db364f6294f60f2f0ee974bb3662bf87ed336634c4531f8b3d051a9fce19790eb924b833ebe8c045ad312ee7825df5b41d45516708d2f9ed2831f2ca1739cdccffa17a318e66b94011c975c1721d8b63593596450b23d0e9b6cfcbb9ea1c1285abb561b1cfbb96417c8b4f922f6ab7f2b0ebd44b9c3ea59178d252b384387f44bbe22e05b00ca713dc5e67367f98fb8cea641c7e803d7493737022d1ac1da6b41f48839342eabb19687401211ce6f77d45871e878f9d2c18b1b837d4611640dba82e3fcb827ea1bbc432541546c2bda81a01879bb2fcff748711895c0ce8d47338c150faec01c85fd8f7b8707f37707474b9fc378479f3f5b93e593102acce44de8a84fb2c62c350716904f1ebe596ff6874ce5cc800a16f6af99dde74494af689128fa7b4b0ea2d2b986504cdc4f64ee8a74462ac3b51824b59751aa3191bbb0e70af3a16a865604df4356e8b3157aa03b55f192b45f72d95fc552c96e033a827c6f5937da44d6b16c78c5d43824603f495ce7d309ac420e9061dab768eafa78c0f7bc4cf3e57ef391bfdbf7e74aaeabaa204e8152e0061a6c2a71be0e8aefa0fc6aade9e994bb5439b7ba8de53456d61a84d1d59c867e50ea969df1cebd011d801e9a3139ed3bc2d0524f99c2234461e22545a408d539650b381defaa4f9a35106aaf89c038acce3623a0e9d0eeb3d3471246e03720a60b6c748f3368de922502319eb716bd260d74cd03a364c97f76bcb97c70018dfe9e26f6982703eb3e3ce831deb0a2dacc92b5d8576e358da850fb49e084a202fdf5d97f57dd4d145e48068c85a0fa46ab1836e560827aa32802c61544700fb0e0a97206ee0dfbd650645e99c0a686fc7b5f2d9fd95f693ff61dd34ff208cd4f3c26eed4a6267dbf574c3f60e4aa680e741271bdc522d21eaa5ac46fdce781b6c9a380766e3ec3372c75f2c57014a42735d20ebdc007bc41dcbcc3a808ddbdd24f99af727c1e42b24d9d9505b3973164e6068ffdd8d172f8b1204a558a34d38a743e5cb88797a53bc4de440feec468754caf0e2c341679e6840dcb677103d87f343db996a5996a20e60af6355c6392af3b5c90ab0fb180c9a20960d0e07efe1df80c242382306ef787514f4c186bdb9a514f76cb587dd556e793f36878c9c6e725db870ec5e7c5d06244cc3e4e6d1c64bde84779756cddd44f66391dd7077618d51985ca45cb8010681b75d7112f4e423a217bbc403c3e4432225afb5356ab59f57109fb3ebdcc919dba08b8e073123a789de7669b91a50dbdbc5b866b23c783198f4ba3b555c71f2ec457c5974f358a687724f111532c3d9ecf3c947ba5c1476720ff0fcea5ee031a0f282ef3e319450b873705f0a12d108442166e4494f4d82f2d89c3288c7b7ac5177037682bf9d0e0f404071f1f2dd1848fc8df11f88a1f5be4b4fc098161b2233d17c92acb861e5e78b83d2add5c58dfe591193fcf52413ef7bc7fc3102feb4c87d8f0ccdf64177626125f357470ee2766f9f806e8ca4bd79e2311136ccc045bad10ab2d691de1cc6399433e4b1f77b2eb47f3f39d32a98f2c96a93b0303c96fd8a2d8ac0a37825f07da91a8d6a7a270f0d43717402620713050032c60267abfd294e53a0a9150eb65445455e32e6ed4dbbae7858be4d8841e28ae254101843e3f887e369e7668ac383c38924ea08a1eea05051ac7d754e87324c60e805bc12766e826a6c7082d65a9e4be20c7ebb4511f6a642345129e55156d5d57442846aa5c83387d82cbcd64664cb737a171cb1b6ce97b174e37166aaded1ef2358695be1c94ccdb91495f6692e1114ea21bc920e6380fd997057788767c30cfbef53b81a9f2289eca0a4804b048f7150b844cc93e49c3911e6257f9a3ac2ffbd669a9064ff28556c04215c11ee35d110c7b555b0ddddf12078f2ec44d6d95e3d0686098a6848f3c6a78b55845443ba6b16ddfeef16f8c6015328ed8d5c29ec088ecca5dea9d0cd9b68fa4200671e553c2955620e651ed6fb4efef1846a70878639ca22622116f5fb8b7617b348dd54b60fe3901027444abc18337eec0936a3a880b01a74cd97ee2be11d8972df3af7b2f2d384b22fc6ff64264f698a3d0ead5aa4e63d913c93f13bedb0ba8a5f7af021e9db01fc76c5e4fe944ab6b7964baeebdb6dd3c056e20b70615296a5061126ee1c6f4947ce69e08c4b99c4aeaed95e91b99aa0336c2ead865cd1e507aba16d2f88fc695a47ddf946fe0c19f511602d98ffe48b51ffd11f3353dcd139bedd76969ce674cc201d681c2ebb7fc5ca21e4bc53864de4ef0f96c8c1513cd01e26982aea0bec34c8791f0677bad5ef617643321e164506ee4c16cea4a2070bf64b42002c34866ab19360ddc3557576f9add31d6feff031b49eb6e490922dca732e7a368e6b131910092f574b5573760ec0cf788a16a40dcb9bcb91e2e1bf455e3e310563d0fc8997bf67b76f03b109e46e862bc27da116018ca32887896bda74a05ea5c111daee99100b11665670fa740cddd8278ca3f9eaa110385b60f11db22479dc7c6cc85421681278dd2200b23cbfa8fe618d275137688d335111b2823082cb66c37f76104be175c918f9fdcd86cfc34cd8065524ddc8e741195f7a9785b8b791d996dde34e1ca109887ee18def52ecfb4df4b759483442f4d0112a357e35321dd1f325e5e30eb3c97d8230d1e84c5ac2295f54f12608c78391ae7a69f18c647cafbc20832684d3c06f12e8443291b8072c4c99e1b8cfc1720bd5e19beaff324ae5f874cd0af84ce694d00dd84bf894122bf6a53199d2ea8057db37e14e9a057be7a7dc82a36a8b50bb9243e9c61b9843cb8867c50ef273781088640da142595f80997db8b485275eae9ca772ded5f9fd685ff701d2ed3314de89634274ffb921639ae2b3b2e6dffd395ba0d77c0722060bd2d94ca323b937e2b8056ac6dcf2afa5ff00be75fb102e9e7c947066001e80c7a519c3503a727a3df72ca339f8db338a7a6e2b974d68b5e4a2f75cd283571ed90916b2c619b09e3c9f4102e74fc9b479171f05676c35ee8b2dcac462c8c223fa371d7b3c1fdbe4b04d20ec20075bf13ce68a7d1fe73526ea8cd829f32d79e0b1eea0ec7b7afa64fc135f9c8cc002d2e2a90351102231ec9a2962fb96d8d8f4891e2246ff9130197047cad5adca757c74437d21bc9c805a837a4b62636b5149e15c02e26ebf6ac42383ca48cb489a5c08820deb1bf9a309e0111b3d42ea3cdf09b581346ea12c69a80cf47e7b427fe0d5c641ed1e23538b315cd23d267931875064a8f537965db436f47269a60d6b6e1464596d9179e3c82ef4851c9738c34062613ded7d4cb8298c60c9f7a96f4b109bd75dbb9e2620a1a9e8954c3c68034ff67fedb3adcea225a5d96a5e03dbc81934f53406b997f454af585772711a7b3cc9d3535f66c80d2c12cc3e3d1813975321fde4493058b784769d137e9ce2a4a66e511f2c327e93334e40cc3ea1fc6f03c2aea330ceb0dc3e340073948f5d991cbdb0d2715dde35a11949f013bbf3d4d90749db3b2849907eb584edf1cbd951787be304de7989053b9e384ef79278f749267ab4c62c946a260eb9e66fa223992b44e564ec5c45edc0355c3c0370a9524e4429ed68c90cc30d123bf40994bd14c25a754510940cf2ee9c14630de2b52efb7a3b8c7781f2ec77c2193a8a0941e37eca682b2fd337c74a4bb12a0f1477758d9759f3f07424488568e1ae9c706c6b08ba1b8b868a9146b9667f85e41b9b7664fb433d04d67ff32bcc966df0d2044ffe35ef26bc05ce25917c1b492822e9d4de0064696d9df6bd8b280e1dfb7610715349ed3ff83da7639edb2896ddb0ac3be364a6369e6449a0ec7fa322a11b6d66a83c205378391d746bf7e12bbb1c7aa988fe8c08be9a0d793ef08a8f3ba56f32589d7a2303d665c4568616a7e477a2975a1fecc8ae785e61ef148056da1dcbaae4f2bdb96d37bbe87894292dde0eec39c426a342190168a17698ca7ad319cee9ee5f26a0c174174588ba1b61959206ed371367f505759d6481572db2376a285d09ad2f92378797e10881072dc8463f4a2e00d85778c46642a0895f65b071b1803995420fbc871ad2a698552a936d99e7ee844b306c450cb021fd073532159225a4ce29179c47c506b9429cb28dca138eed324291084cbabc2c4b3c724d1977d463dcfdd439435132eff08401140358b5e7abcf00decccd5df4012ac2530a2990c6455664eb910c589bd951c91a8c30c7eeddd785993d835d1000f87fa1f046c26fe7a034b14f9beb1b1e89d68662092e629c149e423a359f7659696f27457496e3e2289c1d84321e371dcad42e5ea4cef279ab217b78dd2df8eaa6586f08b01a9ac77b200206e079f6ce107464f3568d586e9375f2d383a182132f99ac15ed8c2d15b75cc4e6c8c3148e6e3699c12251a83eea859cbb988ae03ddadcbce8b49d04372a319a446eefa6ee2da51c6342519363918aa982b18bc5700a4a5f8a5c1a77f38bdfc67fdb089df5380de99ad73fd168234569e22957c80e214b52f698cc912a0fa817c4ac45cf732251e4ac8180c015ddf2728f271a0bb63b40ede29c23487e5dd5d7f3b75836693ac86ce070aa6def697a6b13062f5e6d6a0822a5143a14b28e60ad60ac30236ef71e96dcde405d68b3071941b79c0f70cae1905a78e7ef9c73c4c167743621afff5112adb2488ab866e35af5acbd6bb9e0fd2f8174feb0e3e3dca055ba9429705d6c668d8ed95c88561c50b84e8fe5c69720d7eed3a83237963f461e8627a0b1ff92d492842afb7a14eb436686ce71e43df5b7fbe7c4948ceefd6dda4509c836d46d619f25690c2b8cc1f2a69a20456607c8da030ae6f9508d85508c22eebec9e79505504022674a2a9ffa6bb1e54724326aa91d41883c53648b077be2e9e5864a4d5b5bf29bbb283db8a055020c877aa42b08a957206b8b547f34b5b692aeed043340a3332b229d6824575088f84851072afbb648f8a0ed3ab031f3134107ca614880eab57acb8ff718a2d23b6b9b0354f76a1479fe00fc676a4659bbb04e03bebc62c60ad9f56b6d4b5e4c959e430947d35a1f75638c200c71644cb4485941e2756dc00f9df4ea80f8ab3f86af5a7eba9481116bca9b7d24b74cebae16955fd8ec94c1d3a2d957684188824674aada8da4f87a5d10683a8860a50e1e9834c6ff5544dae0ab7be4280a713ace8cf28b405f8ec4269767a74649e12ef07b5a19050d218c530d6c29ea1b18d2133cdab7f0fa43661851b6da737116e2dbc401d208b2453be61488c657218efc64e520466f1c21892710ebad3dd9b8983ae22c92ab7004ecfbd06933ad5d31d3094b0131825b10499aac357cf4908b374efd10c81b5fc939b6c5a3107a2ad3b5f4084ba4cdc24d13e43c57e2ede44e60a3bab70e71f709c4c0a8dabd805adc12c73a9b01e9ba9f4aebbfb478677b6f6460bb135297dce487435f47bea5e4532e3182be4d2ddd3f2f06440a93005e4abd6009eaf521242c6fdcd1f2eebb3d5dc853f591835907b414ad9b16287f084e8fb174dc7a696d70fcf195d4a511c921dc79e00659595b6550edff40083121a4c8ab8ab7875be3813e1c34e63877092b656882cc976f995a34cf117cc30e30844707e4164eb91bdff4c166e262b7dc128b2e87620fe26d3fca32a9bad41a95d1df3ce2881bf832416b5d6692a128c3dfa0a1b31136f669b4dee3ecd1a7363749172cffe0787cb6870a47e700f2259d43515406836181ad5776a8ff3cf5915910f586ad919cf875cfc3d35a3f814e21c9f4d921956a29a1ecbcb9033b54a817eb0725fb3931db55a027a8fadd840dd7e0e0c691a67e4c1adb61efacca5ce07ea28bfcfe5112d0e6c896e5687b236ae1f0c949f0c89ed968f07fe49297b2680fe27428de7411d3932f50a040d2dd4bd89d172d49ff3fbf993857eb30d0e19763662ee4f6add3b37e273ce65ca70b2693b88e508b53031ac7e5290d114abdd77432c2f8a7636ea85a2061337365374d623ce9812dea8d0fafc9a660aed715a386562846ed94a55f3868e0a151c186032f68fe65d038118f1b94e1f8fc3ce80f73af3ea65834d8556f459e9929086e65b19a44cd97081fd46071e82c841a3dcf2d76c1b23160f54ab5cd0912bfa3a23af989069580d7429db033ccbd7d5a3f4fb66f258b8dfabf16d52cbf992472b16cb8a193456e3c322d5f736984f7daa2fd5b0e63d3c191796954326321b8e94766e9644a5f79b3ca394bc1801a8abbf45241e6a3b0c36dc59030af7e385591bff1a54e6b622f888d034051a56c7c3d650ae8431f405021ab8949c8e750bfcfed5b3f1bf58e174e9e43f295198121a2fafe3eef746207baa44d77e3eac97d47a901e7cdb769e9144942a282cb7682351a744af2b8ed865d21ac51a3c331b63ea5ea00b35610ca36a66e9cfaa87dcb546d6e31684bf197221d16141a81455d64e628a8677efd0479cc0c47ba845def81d7e79d86864652099ac6b02ea28c40d10aa366aec23a5326b71b5e1fd66d78b813324008538efe2fff289e51c461a7cb218a7c80f1ba0869f89334564c112251219d7d849c944d57614ae5bb442268e24c9bc069058122b911e703b2c24c3e24dd65bc8bb350eaa8aadfeada52920d779f13e11b2687d73ab80044965e09268789a6c090969da3b0cada66c38bbf1995368660b35a83d7ae06a7b843ce2bece287ff51a02abdc6b378b9d65199ef0a72d20219495fad061224d241165a544a7d7df22322786e74f59199b682bb014a98c170b1a39e52e9ee645184637613838b0bcee7f792d0e03dbf492390f1790c107a2174864ccc009e34995b029074e0da5cb58f52282adbb03e9028c0abd48f6d5b7c9f01f98617ada1e93d0d45a79a2718f3630cb1e3c51846d0612e8c08560b304fcf4031ae96694572056b24a07159d088bb37ab4d38d0835da51aa8c37e30f5a145d4c1f95f6dc3df41cdc7f89ef4d0f2b5a280998d1ba9eb8412d2862063671b8617458bcf0b2f0f1ec2812f7f2761e7dfffffffd4ff6265bee2d654a29052f0909092809ce0c050a43f9ccf8d1c44ddcf4352971539307e1f0516742ac3d6a5dbd42724b7dd9fc3ca8fbeffba17383d983d887bd51c70d75eab85023759a5d17e2f0e1e0416ce54aa7ea1eb041aa30871d390e0a6a3f053d67ffcb2891992425e1cde6264dd3b4ef4971d4cb90a3529b73e0d8337e4ca0107165e241dd771772538bad43863772541f018ddcc568d62eb1ee9ba29a9aa2a2fa888df6a14bd045f40aa494b2e3af518110203cedf9c9987f64f899305e3d5445e1ad90c4a9cb4c9849163281ea611f1c877084a96cd42d1ac2b6d57449ed1f4965186973936ef5373b912d6cd01622691af600e23853bc71998a780884890e15deb8501cf3e9130927c0a30f5b1c72802465044a9850b932f11828bc02ff0e063434a82b266aefa0f6e43250672797b75f9ed05f000b51a52376c09efe3eea3e2266ef9fb94e0cade383c7beb277cfe33a23d5afff0e9d11eb80e13430e71b9c4c46dc83ad48791ba31fbd1a43e37c37bffbe272409de73136a845b01d436aa2d322d890b29d76f2203e8a2151a49c6e9edff9ca2a223b5fa444f3f0ecfc0fcfb42cdbf99dffd1debefa1d2794f27213c2d884decb6f0731d3afbff7dc04695e32135be11edc85d9c94a759b1f3d1e48ddc426ec02d6bc0b1b74816df917e9d80eac2316557301998f79ffde52cb473794783c3ff2110f0fe223a46ec23d3ac63aba466a529d06dc15c720d6b907af8e7ef758cb239a221ec4aabdfd349ff0003ecf67df4478be48892cdc164130ccbec33103b59f871ef96ad7d91d3ee1e19fc7860f79c2a29eff4109d80b75e67b106aa05977f5fbde2a88664f5bf43e87178a586887e71b7cc2f319f8c4033c3c3c3cdfe11310f0b0f33c08ad6a084f58d4423b3fb3aa31e11111c3802fe048a3e24153537c446b67db59366512de8a65124edf18b1947e32cc69f2be7e75de56bf9cfd59fb6ff8851e73ee5e1385c73e4516575cb982a972303844fce910c77149781c87f38437e79cf3bd07daf371e1ae8be33ec5fdc671e17844acdc770dc4f5d4719d3490882b8d3571dded5f778f66d6b1dddd9e725f9d205efbbd7638f650a9171cd7dd3dbbbbbbbb7fdcdd6def6e6fdeedac05dc7577777757ce4ca3a9996974cb34ba750bd26dbec875edb7c1d1aca7af48a5964d2a25d5b2d9867b1bee6db8b7118458d6d3e7ba66f681d9febb1b11397f58477f90ae1b4d6faba3b5acb8f087cae933ebfef17136862e071151e1bbe1e9f413e9d40bb4ce6696cd9612bc5977c90a2c5450c192153c5802133db0024a18fe194b4e9bee54ae7a93744529cfa49487aee88af2d015a53c5c4ab2945366736bee91fdbae473727e952bf0ef6b85ea95ab0ca0ca5f06d23ced3dee91bd7c0d7cb1454dd334eda56a487b5074e2699ffd1845f65ef5e4d4fe47b714c3355442fa7f34ab8064ffeb929f8121eb604de1f5e414eb90bf2579628b5286485e5213545ac1e447e218c21be9d10976000589082780810410d60b2a595260858923a27cb1031e1891a9209531690172d5a985b15a9af2059309aad49e9e7c8a55952750a8f2fbc91be9aaab02085594f09c78fc19674870ce3a42c2ca61d3ce5e526609ca30c489976551781e645dfefead0d2a00b7fc671886ef0faa3f0c3cfe1838d411c22f9f439db9350b695a74cf62e08d2c030c91610daf9f25a5f8f9fea19c3635ad8a25740828a92a8c84d08670da88c888d0429b9060c6b42a6210845400115332294700e19222796b992081028a60f2a2601a9c24555125081a58f0e4ada50ff3c34fffb444e07575ab40614104d4173e8881020ea0b4a0700694127c48c38725218c98c263eed147abf6be1d3e2cd981ded7a2949ffd942c9d78f2b746e1c9ae6357bbe31eeb7d2357395d7ede1a9ef410c90c8e81100294cabf2f50d58f2ac74ea344a5cb4a6e97fe3a92fde55355551f1d5413eb9c90a830421dc594142a3fd4714775679f3ae006f81085038fdd3d03def2e7a4e598f66662726a402ca5c494b4af557b47b5796ef1cbbbcccbbbee2f594a29a53fbbcbe94bf8944b48ba03954ae876ce5156ded1d7dd7d6ed7ed673ea1a2f639e62d89f1111bcd1a780cfeb64422146a9af1f33da97ec8321f7461fc90c4053318021b48b0f1c4162ef025234820fc208d0dc30a2c54502e62204608360c2a94e820a2a80111413461c51629e613543cc992bc20aac9921c3861841c2009c9d45da2e2045418415997ec52aeaffb0fbbfbe24ccdc9a5e694bed3478b3b7d939967ef99d30f86393316acf4f9b548a9d47c6a99bb53f7fc05e27f546366667a84d37eaa25993d70f70b7082f0f8a1b668f16056ee53cdd9c185bd9d7c7f22d520c1db976afcd775b787fc662224b23e89e92c8085e6b3d00c8f3aa1f93a4160aa3f4cf5704c529f7c6086d45beeee04b1723034cbb22ca39452174cf1831a34955fa3495514c10a57f9b31774107e90aafc13092a5e9040c2a0326f7142e5a5f27753073989caef7d4a4cb85229156b4e9516540e42f570fc9a9fd54032955fb008c112a1a5e2a3eed2882bdd3d0c222485a12eb8a89d85d3c3f1abac22bcad445cc765ea2534163ff6c5aafc3204d9170aebe2e7df262a767fc0b053f97128eaa0258201c870aa2cb20462142af38e0dc76d5a29a1b0af7d16703b65f33c4de129970bed7aa8bd7358973fcbe51ea52c5072994b1135449f2975dc2ce28e9fce615ffcfe1c730846731e86d7bf54c695daaa20371e185eff4ef94d4260d2fd532e9722597cab8ff53378fde1f91cfe04d90d77f8ec87496818d2a2ff0c59a101dc86212d36ebb4dca1c8779ae8209ea45dca12abeeee51aaf7cb65225c8a649101240da4e3d3891cd471b354c7411d774bf528ef70e4a3f61f4a0668a0558281d2376178232321212121f506161529215f7e92da034c93d0f65c4759ddacdab1fa4383194461243662a7f6b3d20a414a93d52285c6af528e924003a1f954cb32b044a7a713b51f072ee30ac99be1c849d38974007054e0c9dfd1416c44b776ecf0f161b1562b24a4f1e767859eb61a74eb679b81f7c3492218346852e43b25fa026fa49e5786a7d33a5078d5078f1778238fca38108166566c70813ea7d2c7f3993eddd215e73b28579cd3bb5d91f967bef2ce8afcddb6f85795c70fc2aabf6ae367086e7f59e342559875f9b30e73577f1fa52ed5ff874850007649698b231dc5a4388247f5e75e985e411d3b987ded7bdf60e99ccbcc54db750791cc5dba31f306aeb7e6fc49837431b8658d3f9472f85e1adeaf385948f0ba21b4940fb2094b5a1c5551a3cb4c428225253021e1042dda50c284c2092d2fe20c1b6981b0c61426a2a8c0093880811a501c21460649218f5220b865ddb4c06b4e22c47df645a9df3e891038c45beea4d39fd2e94f7d12a1a26d2bcab62442dbe72d29bc19c6accbe927e4de7b19702a9e0c9d0af94984f8a5b7fc930811f156f69fb7fc95b0818b94b0617e1616cd90c32cd4b1613eff0c89784b4847fefc2a3cf0c75b2ea512549f413f713390992a85711b55d5811ca8937d12213ff256160e31ea286fd14f228484236909a698d00a29c14f7f8557c286feedc322ef3bea578876a863c3f6fd423a94071dbd6a8067ba4c7e5405a5a19199c42d7370e3c3dfeff6d53bdfbcaf9d97cf6a480fd3d81e9cc43ae4b7e49dffd13796ec8093665b37b887f6f2c66fa0b7e28d1b52c78d1bcf205df1c68760b7e28d1b3f321255bebcf1db3be8db167e6f7f23e4a31691963012d3be364a299ddbb67d2f1fe6c79eeafe3d4339ccaf6b1f78836907eccaf2c6cbf0e5f7dc06eebce83fc6e0f871ab39defd7380384016c89f55bef1db86cfe0b8559877d5d08d23620dbf55423c90c5194c2085cf71770394350c290cd34ef4f1ce55439de893fd8f097ec4e1286dce29a17ce328979a1af33b6683c6872aa79cd27307bddef847b51d1e77779e2b4c13e4df9161864fa337f0805ba90c2e77c04feb181cc51df0d33cb06b71d5373031adfe7b8e763facba626228bf116e9449fc49c2d37e14abfc61256cd00c0bc5c43d6e60daca5032dcc03d90b00ef9854c4c5ac73c2a21abffe8af7e5534d0ff543330c8460cf5c37a16615ee4466b78e34679686407362ada818d36b063207701398a8bfc22483c1b703ceb7f3497c4f484373253124331ed0b2ccaf13afcac67a1acbb01f67c08fe6f20f845907096653e335343f33b7f464ce13371fc80be1fbfc7ce8fac9aa5006edbf2df0177758caeeaffb5aa8b200aa0d370870682edd0ff5441e8f3f71f1ba578c0aeeef473be2807eb7960d1ff582c168bc562e560e5c0f139fc7b5efe4bf0250f0c4ec334790dfcf9687a402f07b8dee209e98a86b09d704c5257211bb528657e5d270cc7233caa7f4ec838e11716edd0a227026f6428661e3e70f0f8f1791f8e276fe48e7117495ff33c1c373734a43720f736e098a3662111d780e357679e061cbfce844c0c9594c450ab4ff4f91199f5e327036f6c26947a1eeba9b34050a6004419b2775d53aa5c2c90b048da97d6473eb4230dcf816c6c5f3eb89192edc147ac43be6cb922d3d03de297c2470e76c7806ce5a4265a9453fee769cf494ef695bdfc1e9c6f633ceba16a39384cbf37fb1f9e038e3d95be0d387e5b48c4ffa37b3ea9276435a7a38537a5140f62b54f95b3d2df2143d1fd354d63f99016ddb5a11d2dca9faeb9bb873f5be53bd287513d3a3b365fd26cd3380c9a492dd39848c76ab93e4052feffac06daf9d5cbf769209d97dbd39ac7f9554991b23ae44f1b2d6782f46dc0ec73b80de4ca03eee2e01c58ad9353d37eaa86e6c3681c27b32c530dd1988c66dc38e0c8aa33f593079cbfaa4dc3c18356dd62a9fd9864f5dca986769e53694f44fe88e3959f06e7573c5b0f76621d47583943783684445a944f1f07dc791e50e7370e6c8b9df8e504ae727670f1564fe5ea6f562b1cd8487e28b32ccbb44cd3f833d6f8358d5552ee93012a0fa932540efd351b671bed1d84edaa866cfe47f37378e4a7fa3bc80fa312e2cf6f03f2fb88dfc762411d83693f323bf1b8789a114e72a285fc1ba83dceaf6a933a60afc0de01fba88d5a94eb922fd286ff9ee7a438e1f4c0e3183bedcb5f7e0fd8f32cb474c594aa42dda5154851b9addb01717e05faeb8039dc64555936e7bbf365b2cf62f3733ef54c56cee7fce855999c9f116bced36cdbca79991cd8cd4b1b4e4543f60cdafcaa82646ff33f5a03190a47d1ba09a640afad0292fab9deca09c7ef8bc0d7e12f4a22d4f33cf43c0b656fd3036adf420c0ad13e87172a7fcf73cf3bf8c4033d3d3d3dcf604f58d442e0ab6af8079f9be0290d84f3f2198a9ced2585e12a6f8f6d75f07b9f037e20b860e76d215d1787e31766fc37515a942f6d42761272528bf23d203cd6d802aa1afe8bacec9798bf87bfba813776ac911a481ef991d956edc11ab0e61d1c8754c93d0d38f654999f01c7afca844e440c038e34f5a563dc3b0c3f5a943fa481fc191c7f5b4d49234be5a74758425653d230a332cb9a00af0784e28d0dc55b3f2dca90478b92478bf25755030bf5bc149ddea1c435cf6c0cdef632b353daa66c383938211b754e185bc22276c596ca2a205d659ea1b8ff088e58aafeebb4c9cc99f7fe6ba06d669b993321cf99f7dfb6779006fc544333cfcd8032328fa45dc667405957b56d1f64fef632a091e9acc463a175550ca9f79e9b41e6b7e75a45c3cccb84d1a5cafccc732fdd107dc9fe12a4f9560991f9992a622ca937ea56f1a24b65150d313133e10e560dd53cf7a3e5fcf6b481669e478b3099df3126a93ed4f0c69f6a0426138e49aacc1bf991097db4e8dcecb6f7a09c9cf047ba8536e07c4ef8ab67214ed6e0502465e35024bbe4c436b0e655aa20335ff332a08f167f1a0816c3ccd73ce772e7737e2392b3b393f3ae1ada5435c83af3379f6364e66b5e82453aaf63130a89f91c5ea8db1725115a3d0fab3066cbf92de765c0271ec8c9c9c9f94d27272cc2791d24b26e7f13fe34d04c081b3949a68aa126dcf1f38337728c97c87cccc77ccdc7bc3fd79c7fdf8facbaad827e7ce647afdbd374d00f6ff96fbf3d6f0f1c5887ff168e5e8bdfe69f8dcd8dccff6822fe3fef8f03ccfbab54bfc950c65f158587f3dc736c5f32ef3ddf0703859301b932946d731970ebb675db16ea6c32bf2dfe688ec96ca11099f0090f398ff31b119c2f52629bf99c9c997094f96d7b9c4d666395ccacab4200ceefb66270de655ee61b88261cb91ad95edac8af79ce8dd8fcf7d90e329ffd28f3313fee506dfe03479bcf6a6ade553170ddb6c604a9091db0dec27919d026ac0147991f699d792eeb6a40f93423d79b99979151e2c1e3e74746e6c7af9bcc8f5fdddcabf9ec6dfe47df803a78bd9101475a657edbfe876b5566bf81317f038e3bd49ab789a9b951d1c01ced6ac0ad34b44e70e498ffe13bd418702b0ee88123ad5be8fd0f9fdac3c4469a3a3214aa316d3101de7a8f92670403f2bf6eb8aa21bbad9543926d1a94825b16b7a5a0042f539c52cffb3ef932e54ab7e422b74899e5eb0ca5d3944e9eb73a54cd19c6d055a98e1fe52d8b7d71d9987642e08d1b535454038d2f53b234d0f86969a07163aa3d76571a287b62f251c4a819aa8de8981326df82249bd857ffec0bcac95bfd947adef7fd8fe2d6a5c5dea2dadbd868a1eef3e8a0d4c684d5d1bf5bd4133ce9d44057f665d4405b7770f124d4cf23f7a02dca5bfd0fe54bf2984c244a3deffbfe9d6a3fb7eafe76344de8b180fc37c5bf0522bc19760eb620024f470759b587c1544d8ba241be16eac0d57584f0ccc0a548b8ca306aebe2a481b693500dd42e7582c8ea2fab87230f955f9e6c946852a71195e792cad3a8b2ec52f925970ef22950b349f5291ea4925d5cc988698937d59e46ccde5289246d4a9bbcd5b4c9839e9a9a68136daa4dab872a25dad48637f2539353652b4e3c51a88164f7d41bdf206da5b3ca999fa90a4a5b825b964ef6fe498424a89365ae436937dfb351aaf245529d3fb27cd449b5ec4a9d2f756ae8976f43bf0c8b9490df9f8536f06f61913f7fd315ae5ff66c9dce699cfefaa66dbaa6bb1ba669beb3de3ad55c77adea97e6df51dba7368bbf797e67e6fb69ea841dc30947efe36791b986959861f8a90bc78f0bc74f85a398312b51de58d2ea8423ddcf09470f271cbffd2f1cff261cc51fa7ba5f53d4e2fe0ca8e44f1ee4635b1b138e9e172ac184235585e3b79f0a9fb670e45179763c6969387e9b71d4e7ad56d5aed439e182b4a7bf7150aa53bfaa2156b7b4dfc06596377abd55b603c1f9737dc415c5d868a4557214b7bb9ee4634be14029a17400bc99a4c2913a73a92c95a5b2549651aa75777777a7f8658adbb66da3f9946af324ea4d5a8c62448b1eb6931671a078631f31a9de40485bab9e38e19653e0ad15509c547f19c340befa56d92d10e13943e1b6527fee2e4005b8adce5e554f5587ee45d60eaac2b4aa838caa7b8191b158e5cd6181e7deb5db17112b551db2ca441cabb0172ad3e0c52a7f17846395b35851c6165354e134c594de6f75ccf046f1f3544e58562d761005a255baf2c21bc5da3cc43a859452765048291bc8a594325c4e825b393993383314fe2c41b946b8ed9b167838bb5c6a531651a0c8236994e549090a6fe24ca2b858699212a597f491962c549438899b7489aaeb5477fcf0f30e6d28a9d4556a719f1966c7cfba606ab4f0ba37088e1a2dbcfda902c2e14ae9d239ced65b9bfcb232548bfb315ab89549b2499728272b4d4871245fb2450b1315279dd4b12e579ca634c1463012d491cd42061c33bc6d91856386275b5cf6177e0e351970db6266f9d2259581d7ff5503b9bae4cf26540cbefa28a954964aa354aa4fbc9c107851bc7eaef25bdc178cab873eab7e1fe22a5fd65042cda50b78231542142a8b5027242317eafabd1ed491a6f60f03e1858bc39d91b4e2806cdd17d755128208f56b71eb2a095184fac1248cdba83bd7c5ebe290430242d65d1a820f940d982d57aa4a8bd1db252d4cf503de2e699952f7bdee929626aa6a5ffb75a3b1e2cfebeeee761590cca0d2dedd2e8174b8b29a823e5a641e73abd7f3b36d7bf6766f21799bb144b62a866c6edbf6ccdffdd9d63c5ae4267125b81567055e566f3450fbd75715e466e4d4151ce3e12d5ecac3a5cf9e3b3f6564c183673b319596c9679095131b4827487728d6fd4f12fa78a27d87eff3f2c9d127a43d4df7ff4085b4e7ae8f635d387a14d6c7d18f90f6fce00e407b6625d57d1819fde009bdb000e077615be0ffe11352c2c31f2db6774b2e8389b68294272ddf500401aaf2b3b80ca4ca3e95df3d26f73625b8e94ae4b2ac331f16173ed78c460b3d18161b48cc5695b3a7bf0dd45ef7aa81565e85611fd5a3f9eaaeb81f9f25d6293baa1ae232eeb79c4c35a48519a53506ae0dd31da65823c193a31f5cc8074d48891c64edd8910f42b481bcbbb329a56caedcdd9bfdc0c1ecacb265f6655916ee77077252ba37e7a3d56ce53ebbfdb33a5d35b47582dad66db3f74bcf54190fa6bed4ee70eb56372584558b528aedc3ca2ab7fb6ae7491b48ae9cd23d7bd726336bd9d7dd8d18522ed7ace1f1eec32491695cf71b854152a5675a8aeb568479f985d9a1c2bcbc84635195a9aeadeac027319c16e92fa970d795fa1457e9ceaa2031af814f62429a6eb1af74b986cfcc27959abb160f975da35a66c8eb9a5f7d672699596acb9ae653669a9639e179443eb9be2b3aa774399dd022ad780c6e2baa72c8b60ef0949ad4b215674a07b0579c9916b2104443f2533b32cd69449f9fde8d61607efb1770577c81d9647d79f9ed25942d6ee1762ad949e66457aebb751aa4924abd279ec6592853d02e8986fce7d3ba99f4a9fbacee4e93bdee2fdbff684d0b97abd3cee2f187da04b9669dacfb72594e4a29cd6896895e5716b981e68622abefa3ccda4b3976ab59e972911b5a24227be0655cb783ebc6d5cb8f3430d91371a7f09f488b383fc8324ddb3939aacd15a57ce75f51be0682caef330bbb06da90dae0fab90685c00ced48c36306c2758802631ca1e145e5f746fab4051043489a4ab324e5fbf134ead9ccb299c2104f4d68e1d2930b6a963dcdb3b2503c42cc5b9b83079e5677e989c9138fd65d7a427a3afaa8189c94babf340426754324fdb520ad90a1c4b63e4aeb05174d57f895eacb65471db70b0b7564231e3275e4265a38195577271b388d01060bc05063290c2a6218218695165c811a03690c294b6364c182022c3ec0f224d9f8f934279c0f599665d90a7c985d202105d2873356f0124402b6d8c1144b68d962898dd9832ed030a2ebe20c1904f1a403277cc185ca954bc8c1199feb8b20787c51459defb3088d104fa4c106133c28411421c9832526b2a480f036005ec0a0cef9d40ba73abd061a797ecbc593359c40a50d17b0e08a286e708457c45bfced130b31d3acbaf081a6caa75e0aaafcaf8b23bcb6041e1f7fd44a0e9614a1c9833cf6ac5071842c82948c045e84a869e58a10bd058a9c568850e7e4a57286940851bab54d50283c2a5f166fa55b5b47b16a44b8d2add57858e16202056c69e298f8f85341044870e2815753b70a12889043081e4ddd2a4868238527783275ab4015b1c5f3ea56814a4205243c9bba55a09c48c251168e36d0ee4eb99276f777f713ac245169beb06e953482f018143985952080becaf9ca853ab27cc61d3ebc1b9b65b700403a2f6123b46052fd084b5a3061c907598c60698b2b517680c552d3117c588ad20265898b2e4b3f687a028436765f9303759f7a0e7e021bae00c2084f0841064ba060022107180801064f28d9c11231777767ef27ea589cb999b9a04e46537706132a68a209f729f5f424babb3bbf3b3716777777ee31a4bbbbbb73636131199e497777777632ba63edeeeece3f72952419eeeeeecefd947999bbbbbbb337167777e777e726a3c570f666777777eedaa18e907ef9cd8e458ed14c6e021f00d14c58b25041d1b4250b2c47685a38220b348ed020d1a8e623e6880a0c8ef8b842fd8a91f6d405c9080b946c09131b40c1b263c6c90766ecb822fbcacfcf2b9c94317184169c2406d44684932ba0b04829a744c2fc058371449447c42f852e66e0c591ef8a966dcb931b68c142fd4877a4f3b94182cb123e57322fbb728575e8a93924e12da8c00041451954904c0ef2138cb043243d91f4184c2f4da62481090b1289448ef15333832e68f073659d382e74c0649db0f0a05e83c838b1a2081e481c898fb16259414412ab7d67e993f3baf63cc2922112e62b417e0ae9e124dc9ff3eeb7ba5b802b929e01d7aa96cf2a24bebe2a863252eaee5ab7ad92322cafc1254a149410c75d837c4512672409ed165cb4408a10e74a9a100613a11e609a8a580444f08249a8879ea4c98458194a423d30b310dc72309d8163513582a4ab94a10e5d8d64e1760db8658dac04a9f6732fa04fb73e160aab56fd4b0f1cabe3a543d104de56191aa13c84b755d0b852fd99634cb1260fe21897e618972eefda208e3df9a0b168f4732c8d6d6d9555352cd30f269efc6d823128a02835d2902a20502b14e1414dfe4c6e4a8e9a5889518ca981baef29b6f34fe6a7b1ca1c638a516951c95127c18561e49852ed576a208d4a03f9c7a05a037d939c83f3e52526a67350a3a99c0de7600ac7c14ec74155652d1ccbd262c782b0313354313cf1782f61b8dd8aea493918199b1c1e8e3d79100cdc77dd4f57a7027df625bf5f876b7b541874e8f87170fbf96129030c04e851a7eca01fdeea1ce4aafb9299191a9a2536526c6c6e6e8e7096c0c1c9c901627583d5cece8e6a28e5cf4d9e4c535982fcf3532ee5d6e01f0487b891831b2c160b05265010455185292a743e5a3ca8475d1d66703e9d8f6a48ea00e2ef9896da9307937442878e9f9f12b0a003163a1654433eb1206c10c7a0bcf5145bc22e618376ebb65a50d2826a8895ac88f0465612eb3a72ec8963593a8895c4941cc5b6d46625310f3aaafd635d4d04c1108e5d1d57c92b22a80b520d718c4b8b354835432a1c532f3ff32d16c531a8a6e71897ee59462584fbee635441e677e1287f863a466648b7452da8a35ab64ab1a8065a185aecef5440becad0a6053eba3ae3820bfbdaea23e48dab34e4070c36c4a0fa09a87d71c7a55e542f324625c47fbe2743ca4a90b8f6d105c7ffb5b8a4c509f3b79e9c224afdbae0bc1b5329ed53dfa9972afa23f7dbcf7129493f05d2163b74da1d1a91df8554be67dbcb37229fa6a47cfa0deaa0d5961ae552dd214db19462b917eea6b6712a9898999aa6a01ab685648716611f0e4131fce392bf2135ec36e5e8403118a98eeb86e873373743eccbbb2fc78a1ac87f6a6fa4a808c9b64313c996524a0f2606a42faa0e4c894016c80631605b41439c01433c08b62d1cc6f0a0dc45a08c064e4c7184ca7fa31ae2a5eeb9a8a3e361705ab75a655a7c299e9d8eeb7878523ed85628a26763aafece5907ad76b4c52692d57f2553d9fdbf00814603c1182e641686345fccafbb71e3c68b239dd4e958ac1c2b48da71e0d869121bec720c29c263ff1cacc5c3e15540629cbc71a1c623ab9a3d677cb4c41f899452ce0e0520bc8eb1f68cc4466ccc190d278aaaa199f14b0ec7917f59cb40e92ffd0325bb8208542891dee7d1789e2b498c2580a18329a260d22cc836c0860b90886289255af083904b41a35377498b1234b8c815aca0026ffcea2fec0bf6420cef3f807dc10600c3fbbbb02f980b42efef635f301f3fdebfc7be603d06f0feaf7dc15e3ede5f00fb8209e005f4f283f6050b5a97ff8ef707da170c685dfe2cbc7f00f6050bc0bafc7fde7fc7be603bd6e5bfc20bd682cffbb3b02f180b29bc3f00f6050380389ff5f375ec0ba6635dfee1fbafb02fd80aebf2fff777ed0be65a973fcffbfbec0be6b32effd5fbabb02f980aebf2cf79ff14f6054b615dfedffbb7f6056bedbab49779ed51d8170c8575f97bef9f635fb01cebf27f797f1cfb82e158977ff7feac7dc158ebfa1bfb82dd58973f7dff705fb0705dfed9fb83fb8281ebf2eff7ff7dc19e58e02bf016086770fc0c7af9821101e97dc18864f8ecf705230af2f4f705232ac0a77e7bc188847cf7dcfb67fb821119e05f7e5f30a219de7b98178c88e6b77dc1880ef0365ff3fea97dc18868f8ef6f5e30a2219ff338efdfed0b4654c3af5e07468480e7f99df77fd9178c2801ffdff3fe30fb8211d9f0e183efefed0b4694e3597fe3fd63f6052352c08b8fc2fbcbec0b46b4804fe15bef3fb32f181103dee755787f9a7dc18888fc0aef7aff9a7dc1881af03fafe3fd6df6052372c0b3f00078ff9b7dc1881ef03bbe0518118f07fa00bc3fcebe604437fceb05f0fe39fb821141e07d7c8ff7d7d9178c28023f8077e1fd57fb821149e07ffc0befbfb32f18519117fafafe3cfb82114de0617802bc7fcfbe604414f8187ee861bf2e7ea20a843f2800f6ac8b7f0220cfbaf88b803bebe29700180150675dfc100073d6c57f0388b32efe078037ebe2770068b32efe068035ebe22702d2ac8b9f01e0ccbaf81700caac8b5f0160ccbaf86d0061d6c59f00f0655dfc080055ebe2af011c0272ebe2a7014cad8bff00e0b62efe19406d5dfc0600b375f10b010bf041405f17bf0c60af8b1f08180319957fe885ca0f0396ca4f8001547ea1312a7f75a1f2ffb852f95f18801895df851e95df471895bfc7abf2bfc0a8fc021040e5e701eeba824220a7ca1f0070d7b5036c21a8f2b3e045e5070050e5ffe9a2f2eb00775d2b80bb2e17b8ebf2015500f953f841e56fb150f9452e2a3f0ae0ae2b07b8ebc2118e9eeb06b8eb0ac15d1708be0f2a7f0fc8cfa345e5df59e9e46051f971c0ef8aca7f9342e5b7b1a2f2d7b4765d33618cb7c4ff52a5f2ab72ecba381c1b48a9a8fcda8dca9f4dc1df2b0558d1c8525b485ba95c79090d2a756bff04fae5e98c2c6a4edda53396a8bce1d45709e9a91c7e8ff3e4350b96089113cb51f2a4d440dafbacfe924a3765e164e5e94af54d4b6d0f37264a3def7b9ffe3e4aa78731f4fcaf4b675ca9feefc4240a977538aa746a71eba26d51393b24f8be2d6a6e514d9452598ea234715c9840d13d1941c9625f502f46e0d07fa1b28b67f4ed6f514c4c4c4c4c01a3daa884cdf66441ec10d1080000004100c3140020200c0a084422a16028186ac2b07d14000b869e4876589889c32088519431061942080284106008010081a99a1a00f9eefc6488e4606f630c03b257007b312e2ae872714fe80b28e7b11eb8ee7de9fb51e6850079288c27a492b5b8cc4e0ca9bb0b089bf9989a40cb37aedd12c2b831f3c51c25944241c49080b87349c3b3196f2756f4dcb3d198e2ca92cdcb0142ec2e6d9a85122e32f3b3add43d7208e66a346218d43b459036438066a326c6bac0197ec1a6520c2e8177586b9871c38a360c139b33ce1da8864f61120b5b3b2150ee3873c08193f2949d54853ac1095ba41d9b08498ec8f5c1727ac9b53ed393922d0d19372d94e093d1a003614dee8426b5a2ee7a151f27bbd18d3abe4f18e3775fdab7e6c3dc5ab68d610427098dfca8290f6bf87df1fcb8c19f3f5470c50ab5092b3b91e26fa60887da360a52be693d1415a9a9b4578876e59f20d6152da1bb68e17b847b02ea233e1e05fc33147ad4899561697016d0ae5421736d6450c4788038dbb671df1df7d0d45864706ea12ba9637766a89a6a626c072680ae5847f7d2207541c40690e54b32c3cc0b56d824ac5852bb0c6dd0736b673ff1903c942b182afb33ac6d1d7227518eaec7d4f2b6ab2111680e17dbaf76c521d58dc44ed52898414bc34162d8b886d5c17be1d1913a10845f76c69d02de0d37eaddc0b966968e51ece602eb2b6e5dbff1c89d1626cbc02416219ac459e80dff86eeb4ea4f6f02732c4450bb31ad8aa620a833d6f18fc5c2978f15c36c5d7352b7a285ca6c824933d01bdbc28bafe835b5eaee12535a7d930c75ec6812c69bad96de61e4e0e1b876a6dc03d3df6eca4951ba959ebc6004dbdd9e79529d42d151f3ea4da13185da3ededf38b31a153b2c55a8484415f44dea024194b51e77933876df34bd09b06f0266e5f9cd888db8d8d18c699f7cef8b5f12a243ab83e1628118d96012cbac3b7782f5f40b66e9ce58a3252305acb9042a757bac77fcb6d75c5614eebb15e9259538483d592525bd64ca04f641689c43cfe2d1bf972a108a94a555e3fce690c34696ead7ea767bcd61f08ca4236318919832d3828f02b1e4949dfab3a0afaff772198230a1883356505b8c45802ffe1a54d5ec1362a726f07c98c54585572940f8c54fec247823cea4e16379e0e25f19ac40c7eb86c431d1572332914274e5def29ca91e70cbfd20513ca6683ad34c2ab64ada6bc3620a8784f67158cb47fc9a3f3aecc7bfdb47d4d2c5644e5225f7222dedf70bae09f1c2fc1432f051c83cc8c3dfad0f45f5387988768efa311aa88f10c9fc5a2ef726851c20bc7d2e4405d39d057c3428967017d04d98284bb7992f1d85ca071555b65112092d52c7015e4ea5d53aa95f27498b5e20bc9be0d88f82633bbe908aab84ec82d91f496ca4ab16bcd68b6f144e1c46158a7a2d738b6dd9b98489e7b655454444b1f9b044b46977e7d1ad5f477e067e20dd9a6c3d0e364303e33c65a092e9b6f6ebec860a55f0f9de0ce7ad3c54d0f9513bbc754574b23e9f157b04780733720161060a77eef886c4380d5a3f33540ecc2dec2015f41035ce00ceef0460bacb043f6b0f7c27b84403513f0761dab0b0231a8b42dc3889983274a0b525c4c89a73b6982dc600d5be0f354aee607f9493b4f784887eae02474533726db297d12ea77290102158c9c490613faf2a861e75309ed024bbe9b9c708a79da204ef695ff0df6a74b70c0871ffd65672ac0b7eb68920e9c031a3f461bb613aba7b1a2fa8b41d178002e5b3ccedca14dd865f281f9078b7f50a41029688ea389303ba059932d58a0663e663b275a8e13b1df3f734a14bb94ba7c33799d75beaca92a1d490897e38b2cfd64b4c0b788475362577926fe0921033a0949b9a22bd037894db162657dae80072abbe851d93bfc3e781b07cbc2a50271165bfc27848db09f3f223c43227d07a412d214578360a672b0f9b31c2d5ff4f74c88baa2ab6f141d1521525f4e08e9bbfa201c89bbcdaf1495af381bf3069f145271671a8191b17422b12292a9a961087402df67bf614660199c9896d6f5775e7c567213d4c8ae730cc42221055ff0f402c902a7e6c875859e566414a9f56b5a1745a81122f0dc94265205b401c0ad2b8ecbe818f4854ef8ab42a0b53f3cdb4a84f755b75126cad72242d20e5c6337928e939902c24af9872da09704a499f320f751f0b2fbd832427214c3cc2118de8bc28425fe1f2d1690077c6a9a7f59ca0a2bf3172667840627f53dfea699579ff59f7928f3cb946c22cea9afbb0032008baa6b79ff8a00c3667ccbd3fa1c8282c180202ae064f858e3156109c5c79c3778102f78806289ae434d4485e0b5f18a4f82bfb40c60191411f01d0631d3dc190ece090fae56035c442ead1f6edd0803ee7b953be3077b134dd02c65c163b7cfabe11b0569d68b37dcfe6a7e7699d667d91793561df202c12728d18db0161e2bcf0e4dbdc8ad74542cd6c3f0811f2b1a6f2a40ff9c8073ef5299ff98cf1b1b468aa088745c1f8ce38da69915dd4134eefef453338ede853eef7f2941f48609b454c5cfbef3eaf2ea21db2db879d8f3c39f2b4c2cde497c9b1e84f28535a747aad42ebb249aa31c0cf213141734a510a31e002355e1d03902fae08c22ec0859df5a90c8073145ce05762c85fc8c7cde1aa96b76eb26fd81eb773abd2523acb6dfce923ec8f9bd96a727931cdb5b724e6266825226795d48c2d19d543270c2ce777f91524644dc32433de2f6153f60fcde82e95c01c379056fd61f34ca02cffa4a67381aa0f09d244b816e08168f404fc930f2c1f9783abf0d22a948bdeb9b8376189f24e6331993837c1b232eb140589a9429fa5e4928e627a964c2c97ef85d6d8a3dba18156d06b42cf0345ee8e120062bbe6888c552adce5bd291efc0618875532201727df082ca2faa11dd46262c9a2070ee5de89189b5fa9a6d55bdad20d79369f620b1da05ccb366b3a37aa27dedf55a4b4c6b25305015b29b0323438fa08b07666eff1ce21d398e0e83e00cd09196ccd0ee46de74a5f1cb01059ac03a3c9a4a082b65a3c8988b9eda1108ec9403b9c5de265d8efcf13a387866484fac43407a92385077f9b643d9a386149b17b7a477750ba42c7c2a9a77b3e4b79e61569902ed7d4173cdfe2b54a31dd6b819805667954e5a4751965ac08bf9e713af8aa85f2d6f8ac1b78bb0b1ba07cd5bf08527f1a4d294733337e618f0bb259f96bd7f2ee4a32a4e4295146287d4664c82e39a09588b403a7178b9aa8b91e14ba3511707660c2c703e306c29d199f0d9d953e5ff625c53fc03eda24dc81d0b30d537178b1908e52b171b9009f3652a26dafc8a5cad5ef8a7f1be640c8037b92294ce3a51dee1eba66188313b5ce45d8c357697b607e24e153a4d91788afda8fcbc09c134498c4e589928bec3770c5a6ecdfdb99bc73cdf0a911f4ecb0e75e5338b93557f2f16b1987ac160e414943238aafd7bfd936b1792adb65449ad6ac6bac2bd8fd289a0211dd0b4ad78ce3258a55d24560973b48cf55e5051b32432411b9d0d4b0e67e4ed9f9937aff6861c7d2d0352edd2cdd760ccabce0e70198442eca8df812948d8481bc978264c5aa9f26f5c01f5aac7d9cc563c09d4e1b70bce7c3b1dd66e1c26163b609890aa0f800ee322bc22f85875be551597deb6eb7094ec0a4eeb1945136be237bd1e009d463c8ee43488352c73cdd96773a7dac0f8bea55cba42d0794b64a73d2e980816cfbaed781c6aa06b51f659dae1c81ed85d36e153b57da9885a525ee9120489b23c276bea0e895b697f72c31ed88575475858a9e42afa2afa1d7d053e8d442676106e7c8ce4888eeb66149ed97d5def5d62b09c077714ab6dfacad816f1a1af166b6b2014583d5bd93f5339524035472d1d75871a9e68b6a83a67598284b1a2d176ccd7d9f5456268e12e4a6adc6789792ca3b01f29e3dc857202a600d6d55de5c07273a86788e8ee1edf582cb9fbde07caa546e9005ac7f1c9138edd6cde523194bb7fe258c6fd7f4a6ea0d409ddf62d6a53ff0b4c264b89dd520ebb6dcb16594959b863d38ae118b060b7cf4c1e62949e437cfc78e46c6ef89393f728459fa8ae08e4acbe62651f2c31c513b49db553df2185d9f12e23d6127341507a0a3dfe6e74889c072681955c5cbd2e4b0ea8e0430ba57e159d157ed6a156f3ea0d2edbbb2ad3181b4dcdbaddc3870acb39f0cd9c57024c4870ce01f883ca9b2315b980860476fd4dd4cdc5284bec02e60e95ac48fbd56ba5e71c16b9364bab8ff688f16d61625e28b77db4f7f17612f7b76e3798f95c03e7fdb8a4cad466a36e2f0a3f52cd2251e51432f6a69521846afa678f18f0b8e9b6923b4bb1188d79885401e82fa8090cd7d53d2a6144687172a51e6572f10cd5d1b0a13c8b9e2be11aed72f650471983eba2f1535dc0b3d3841947673bebc42caf1a57723072c3f0a6fb4e8ca8ead49941efa7f452b5128c1d8a4bd58be2174a2349c0b0d4811bc5c51b1898b932ec9d5e91f43e6be20130cdd2a1a675084e75c10e0ab6b8c2c1f6320bed5bc0ca2ae320472303e345f7d0639511a2df7f264cbe7d245bcbc99f16ba304817cb57daeaf0d8508a4e8f431f7b351465902aa68fa5c8c919d158e6a1410bcc3cc8ff50773182a89cf92e5dad4bd7ef09b1b875d11bd1dcff16f2c3b5907dc0918b1a86e341d3cbd05ee0ada485d2cae7e3a288b879e77c1db3cd04210bb2c88f55864b6304f44879f79473446bfcbdb62ecf68020e12d51b7e2398502e8f3f006454534f913778b33cfb280ff6af11da4a0190a74ff92c27e8a93da8379e5c5c9a0b9c617aa27d7590946cef564bffffd3df3daf8689e29810456a6243810e2f2421cf3c708223711eb42710fbdad89b38cf2ebdc78dc3d188c833fe8b4626611c9c373a4b3c08bbc0b51e2bc13a76047a8f26bee0332f72d3889a34d1969809c242d351106c2b97b1b23cc816693fbff5e52b49ddbe2abc5793a96f369318ac083a04b383fa7148e83e71a0fe972a368d910649f01642683b900a7d4abb50013c72ac97b46d3611471f6a87d3ed7b7204c68729557d883469f62a96e911e89752c798a0f2853ea596b982b4ae8dd6d92cf90ad3cfc796d05965b52a91f2e65a1167079043ea34ee9ddd40a19d7e7dfdef008e5a3b0745bbe6439af15b14b07872aed34d68bad17eb2c3f4fe27223222870c5f48a7f0066cbf9136387d53d7f6ce32b8afe50e4fad9a09c812ab3f0770e1e01fd465b212956ad9325abdcf3278a81633b8fdef3841db66daa5d6eb4a26a418697355f3cc448bbe0bb88c6d37b2c31f0aeae963eb307395c065d7321c459dc167b20b9882f47e5c56b8b84f6a8659c993b13b5a5c0bf7cf641ebdfe3a0fafbbc07bc76636ea1c0579078bb17eec81cf79402e009d68279e7506d4d13dc0556c98dfb0ccf3c855cf16ac55626658f47055e77125a488234a347f862ac785f936de0c2b22459cf21cb8b26d8da80ab62aebbaeffa78a291f15562c46bcf813fd75ec18f7a7db6044e4f70b4eb3707de20844f64408e98b385adb9a131800987ecda89bcecaa57ce810c9e6aad1575fc8296bab0e82e36b5ce272f8a36288a8b36603e951befa3c4578390ba6dedc086f83a2fd7181c8c3b3f17384b050b49a0ee78f606c83280616e6a0e7d01e8ed0d48312662f6a6933e2ff3bf89b2d7fb194ee0f1c374ab69334e65ef795d9d483ae21a57115084892259cfaa7a995e7ce72d8869667ca217b9399047bee81d797f5f5b4d657372620d8ea2f08460e0c1f57c4c78c182b517e6ac1fca82f6f5e736feae807622129a7f861df57a09c9b5bcd35a866bf7ba81f2080f8db1456d397d0ece0d0cd29825a5c344ca7ae9436abd65e2f0c290580ffde2ac9a7339faef3a930fa94703e1df9b91f4708eb086f1e44fdef492ea567e4f360596f88547a110caf8be7614b347c9f11a1b503794bb29ba52cf13e4094075ab0609e0922a7a35540baf0fc774517278eb801e7616336123d375bc427dca20a6673344a030dad468aae6260323a6ba75065b192d897c8049da355bae2c6e72a98c6d6a637c26009113c63a9390fd61cec4f583d2141a9654b2f176a6c257885d3a3d0044db333eb8f8a5f60f680fdce7e72e702ac750ce9b221047c73de797910218ca882e3a21c5b78fdbf7254d489a291d089a001e171d6e1fbc2897b33f193e3463ccbfef423bbc8cc2156d37e6fc46577a1132a1bc2147c55d8b320fb3c9093a92af11a55370945e2168345c6173c748868676e4f359c901e68214bb43c883d94cd7e793cabf9469c024c5ce585c0085f6734adc0eac894f07303377bf4a1fb731db83346691a8e100eaae3ff91a7862f5805ec70a94f268f6c4b4b942e933ecbf6406988f7acb525320cbb83f08dd27df781403de7095d192e9833f77f49ef347b4e57d79862a600c790a5ee528edb0dcd28be1b930e9aa98a96e3527adf0afbcaf029dd8d9909650ffff17a6ed426861c53d0901ca0f56fd995fc04008a7eb5a290c5e235a4de9f5cc5a7767743eaebc0b36cec8ccb52c71ef68625c43253dfd6cd2a12170cca252f22b3ea541cb23bddf0db0065a3fbf3527d97e009a4d3f4693b3e5afeca161e0b8dca863691ac7364ff9bdbef4820134278bdb1287da0da96987f3028e000bd93145b071a3582fb980d2d11b57b5a7f063523dc6dc418188916a990f023b01ec20d1ab4d1a31d2be8c791276c027eebaebfc6e8c83154e4e34618e63e71bf851bd8091b8e20f6aacbf9031069ea5ba6e9fb3574ab74a3c760d72340d2004040516f60e1c4fe96b7b61dc0a665013c2259e69954130e24a600814d502fccf0656d7d697d818afd17ab08558deeb858a242f58851649c3644b12144d55cd3cbec6a5cf4a6098aefcdbcd0bb6df5252a9a5e5faf3e9695d7cebf410327438924e63f3670631bdd0e432434e0959037c2f8a085447e563b3bc141bfc14b3d95f66cc0cf1ac0f1d7658426e743742504d482462496d63d8c567a5ca3473b1ae488ac243d002540ca44d1c8817fd53b41231731fbd8f1c36eca96727aa78b6c256dc5182638b420e7787dbc626d2b03493a9d27ff280718d0f376bbf4ac6e576101885938487dd9a3be01d7b92e1559aa9e2c2d53f02f91cbfa691a0009618a2297326c819b2c350636d6938ef01404a53c90b4a13d05a548a402c87d8b4d4aeed19f0405989cadf35f52538fb08f31e29f30a1f2e17a226628b4c57a0fcece4bb0caca823db2ea24306f25a54cb41831502f5d94c510dfb8c1313ba0063b85282bc10edbb50401ddc3b3a3b78799412f20d3af55ff7e300c06d37a8469944c8c79f4187411f24dae4ea3736ce0ce41049476a877264d28e853add467063c518011a45e89baa3d09ebb847059b9a0c68148071253fd7a0844b3bc830f27b3a937e3ac187cd8e8f3d9b3fc559d6105d540dacfd4c69bdce8180a8ef7211e3c2731cf0a6ea0d29f3df8ce2089551465a32a1fec8e9724caf9f6b5960f9729b56d51c26c0e3e64321589bd428e8c7338b346e4ac22bb360fcb9b89cca0be226ba870e6c32146304991433a06a222bba8e49882772dfe9541997fcfaff30468faadef75533e3845f7cdc7970e458855567e68bbd289b5349ab79cd19567fc0baa93894b2d18c4188e445c66d1d323de802cb1a11a251acd0d9498e2dd446fc4d0c3032b15ff8c1301fa474c37f7a646c9fb12883b3450af86a2132bc6de7f53fb7c01f90797ee618ec40642e1386c2a33ae710d2ed616c613b77393be485e45a6bd065a55ba4b0bd7febacafa65477fafc0855ce0cb18124666cae0b747b40243f07f6c4b6b26e82563d7528a60fb4158d90d82cb7f13fa94e5c4c7a7f3fbf7ee5ca1bb43f4aefae641446f00a160fe3a54671802e122e632010f52208b5529271b60780c328eaa1e11dcba426f9abef358139aadad7193bcbaf2216e9a8679489d75c6ccb5766e7355a5144c388eeb661d3a1b138623075a7ee66800709e73bbcb430d2ba48830cd610c225f002e4bba40621c78b67dbce47bb925eb7d9258d548bb593c4a2cb1d0d1034e53d4e79f0979b90b795defe507eaf8a6c6f9347a97a86c1fa5035042ac1abacba4341db92d34b8b80cd509ad49feb9c9bd6e4bab7db0086288d704be611d42ec8b1db752cb0b84fcb012f0080f68cbd8b8fd6c008c7aaab58195b592725b2bdf0faa4fec9a63ba0bd26d171deac847696d21ebfab550aca17c8c3b5f64982c980c5cb230a0ffa18bd6e545e63dbe763b1f8a748a9676e61565b1e0870538a29d9a8bfa545879e246441969c4b8935e6614b1bdbf9b2d45e388413cfaea829489c4b3c8b83462c5c2e2b6d4d35aa9e8bc5baa7436fa5e8a9e88637e4022c06f06bc5106e48834a5f8b07400c5ebbec14d4817d86add15679174dc482a01463ad6387765bc3b23d5dac8b73578e6f88714638316d26c6c540c8eee972d4a22acd04483ed7d9ece3c62fb5b26596004fda624c29ea860bb85ebc04677dd4b37b3e9befb1c8bad691081b349b2695c2d6ccf483824651b259604bebfebaef1b5710226c97dcf9e0803fcec037709fd757545eef2ebc770698043b3bb7fb08b120876bb88e4cd6d678dafb77e31f606a0dec0b4d71635500deb1650f55eca1baac3961b0a85cb556d80466369c2952ab1d9af45676986df38c404ab0304d4950f0e7469758ea3f4ecae494704e07f55ee1c0e5f74ed884d1a6020efddf5ada633448315490f69801958faffd25bc17e1d8e00702d1909e01b6e929a79626b5e0f25d62b3b4a41ecaace592cd78b07d17c818d903e64d50ff820dcf75528e8773b7f77c27c2feb6fd4937be255664ed8e79cdc1e4d50de3ad3a456356b6b550d66c17bf9a01a5cc836b08dd355efd7914c136a56b960754f56021268a710b282c072a260f5cc2c506b3d223465acaf051036f1962ca6ecd3b769c40233ea1388c8e27e6fbff44390389a7af60c7c71f252f993f11aab8b1e74818753eff1c0966c55a6fcf94ac237d3469258e753b08f6de14361d6ce50e58d27634ed840f71496cea0793b80a128414c4fbbfdde27ffa2897c94d63edf2fff9d097c4cb3bddeb5ef7bccff66824fd3b6d7fbe6ff34d9f83038ed2b5c8e81d8156c1687d78e18db2f055087f08043287082b4b061b5bd211d224a1d4eedd93f867b88c25fff88dccf87bdc74cc690d08fa162d9b86ab650cd8a6ae295561a750aa2a13070de131b7a55913ec3dff0f4188bf5748954bea5c7e4eacf81bc17a6a184ac632bea9420901a2d108d1a380d6cbfae33d0342e108d1928512e9f7469a0695c20180df06dcf58d73d1080327a3e3291d77ed418a963466fabe6b6d758370e63f6fe3dec28ad829ebac279bd8c6d838de95e91f98e020ecee5719a5246ba97b8f7572dae58fd0b6993affcdd6a43e983f20c54533237d132dc12ee4f8c8838502e70080346b24d697d433ef0b55d11624f2e4cb651eab2c1fc2896ef6ec0010ba55a8e820383439e3c5f42c6a43dd4362c87a3cf1e50bd6bcb3e9194e6f164c1642129d684a497584ad71ba09d1dd0635a7260ee724078c2b558bc5be82d2b4fbd86175717a993dd06fd12db08085ed7467c0bcd872cdadab301ff6e27b9101f2a6ff4d8ba8704312e2095f504569e87822476261e61e809778629cdb5dc55219a2946ea6374db0376b3f2904cc5dd2b501d07ab80087841334518dfc75f985c4a834ba4dd6e863e4345e3ed98341e5fa42f858b3294dcb80bad954b8aa8c0fe13c8c8f704239f5d4df293ea6c28240240bc637b9070d9bc2d7d02e32cd697d1d8521d3d2e34ce46e7003c6ab88e7a6af2a4021ee0c984c62ed3b927ffbfb26e8c8d6971193d2f1c5c01adc17e631cb359c73015735a3eae6f2c519198ad9f42f9a1217a964898cf6f7ce9c45534497db944d5e99358580c2d5b566e2cec050a3c48bbb12c1a8ca3e9235e13d1444a80031b9d362b287a3143e6c86eeff4eebf207160a949dfbf273bb6a794cc701077326da9c3e2fbc208d63348daea79e08a8a040b10d38cc7da4ac492b6e893325bc6b0d534dcc3a4a6188c6eb580b53f505fdd798893acffd0b1deab8767c53cda342641ebf82986382ab531eeb875fac03c1e8f4418d170eeaa7df3247727f04c7c3dfb3598a3c33e50ded0bfeeda9c0b0f87a0bf7d06ef03c474ba2048c0a2353b7c85b00ea7937bfc48d442c7b85f3e65037fcf2415c7d38d447983fde0323c115b45020b2800c2f1b14df26f9f93c250f0fee7c367c9fa13984509933d653f685a040d3ebbd8f0f91e6ab89c003b579254c758270fb2e7984c0d1c0239059a8e74dfadef16ef2864d250b6d7e33c902b11491d77ca0ae35b33e0a07762ad06037a1244103429a3c19c023c42c5c0412101076d6988d04ae24d6129fc7301cb7021fda98d6733f9d6d968d4ef1c53554ed63959b5c0dbbc4f4430a9a1a288bfd6a98319824ea338414b42bebb84a2a42dedba3793234f828336d83c8c991d386084a60598a4ef671d412e5343367a5daadbf539272c0c67f323e6aab78d833b378144ccce6264d4ba0f5f65343588ad626f51f6360087e93cc8e82986456f20173ab4fe75cfe6ee70c9178ed24c21561a7415c89cecbf6e3d16a51063a45aef0cf534dc7ce32ac8de356cc528a5aa0fb6ee16542842adb549669c141a50ab2d4008777827f1cb8a4c106e3e4a37eac07689cc40192e910d71d5d96b911abb75033b6b91a8ad824ce7c6331af35805076d3fb0aeb20da0432deaa61779b3fa0d5eada633e1ab410bc4e8ac05a809e4e4b90f3005ac1fc6e0d34e9154ebb6bfa300022b28ed9be72e3105bc3640b19595810076f3aab0314817979526feb6eebf7868aca4ad49b1649a85f228a1a7804f22551fe9da5510095888600f7d6abc7303420398f1682242ce20f2b7dfbffd5eb6c215bafa7ba553f71866b0eb4e47d257a1810166960450917f769c6582443126c0241185f7372e1cdb77ee061c6c2ac43a0344b65f6387e83084712137e20fc2a233360ddb18b0cfd10acbcd5ad41080985d9b5cab7965c2ab27a3f0529d9dd6d07c1d6bf0d0be707b5d69c683b6eeb6e6a9e8515e42a6efb75a62fab2361f235fde9080fc7d07895a7d65edf77d9f1fe52ce12c9de1a0570ad7716088da90b9fe7a8527999325dc9bfaa9078197efa95af252bd39ef924e96d1ca8e0fe7cff1d12270d396d09d1b160e9560181973cc70561c65eb6cf8ffe3ad236ee7061c4f02cc90089e10906300fe4c173cca890436a8ae6899cb0eeaa6c99a0fab25716e367ea814df9f2ab2ca5abadf652d70cc591416564165e9860da457d370fbe2f69d219ba14f6d74e2c4cb42892c0853e1dbb028cb49694f4f633eebfc65a14fd4374d5a34733e288e3ab314e922e33104f9bce6d137edf119de8ad5fe4bfcc22b3dbe2d78f515b9f098a768d2c032bb5041026579e46e422dd6640d27d802f2b92bc125b9df5b2bb9fa36a640290f1d4caf2fac484cc06236dd14edc48ae1c028f7a0513cb8c233a0b153021607eaca4c94290d816884008f728fa85c6a321b595b8b4fee7701465e0a887b34ce401ba93d93866cd9ba41c12c99b1ad32d7919df403ee2cd9e4d40491a4c55eefaf5108299b0ccba5c24e16eff6cd88c545eb8166c8374c73588d8104aef40806354900dbbf26c25ab866665f424995a0fd5cc1b83ea7ed4b9c24426875f90e66e8763a71a01e15c60261a70648579dc3bc55228bc8c31903350a34c1fb31e389824bdde9e6fd45e876931f54e988aadb434e8553a6fec51d1d14df848f5b39525bbffeb45ff408293a6fe090607702248804fb3b8400f2ea2ca89af7211fcae41bf2676c57a254770fc9db0cfdb4551fd382cc2628738f898aca16996fbcc76380bfa17438fc9bbe21123c81d5e0fef80c11398cf91c94905d6a8a2a1ded801294f22383fff60e2556c549845dd1848b96539a212f87941a02d6e15c16f6ebf063f91ba840c4372152220b171057ca18ac6e01805915087965ec6c621196193a9a1e285012e516de7da1591166c516f4d79e720d1fb2578fcf25941304843cec79647009dfafdcd3be4d29b1b2ea47c4b8181d8a641f01297f052c66c56f9dc7a0ae8a8547dd9efbf6ad1c9f356986143b7ed6504582b7010423805e114f7142bf1351a616184518425104a67591dc9a5b04de73d42d29021b34230f542f38442d10a1fd4b8b9c080290bb801f7a4689d90cd6d851aebd95457c39e807a13caf6ded826a85a815ddbec8100fc9228e3ee8588126510eaf84bad0015083c719c3956636e2d921b4f2df56f48b029de0b48ac5b236228fe083e031fe0f925b77bd26c6a6053d0077be8c6658728823a3c2b925ad82a628f658fa5f44b3ef8b478b8d51c85152c9e2587ac7f9a7be4b101a953900cbe45b246b0e34cb082187843a752793cb002710253fb2f7aa45e8da27edcb3ddb313f7b094c9f54055d2b61f501351a5ab2aadb0b61cc80ef314ff4ab783a0ae16ec626265eadf8c5d71f89a7b2a936209dd8a3e5779903480b159f6ab0451580983fd2e747f12d1c00943483d09296da2690cd5bc545f152fbcc022861901a4da55b5c74bf25bb09feea946bb3bf94c7b7a96c5e554963638e40e088649163bd41b05988490131af951b80ac287f9aec86ca7a8faaaf0e88ee6ae090972ab5d8b3134aed521416ff4fd5d64871494439f1009b53c67e7f9181dbd68d047b05e64c0b5a89446eb7471a00abc6c6db9c0cd4f8c10b8d1fe93c5da0d2f0c9a59ce4f5bacb0a6840fa2a669ce1425d6b7f3577b6fdbdf667a98581e89de94c9cac8139eda2ef1d769421fc202d869e6edfbe74a0629158034f404437731a2144f4e03293122851c5941a96f9da3a57e59aaada82cf5ae4e13266b0db0b2704ce674a03cc99b0829bd35d88577db9ffa83b2d461955140624d8cee3723c44ec857eafce821e9d5585f6c414d0f90103cd1aac26e5b0b08c69d0068e5b59df96efb50fe27f9ea3aaf8ef4366f8c884d573b9e7dc819239dafc88a3911cd3294966490a404cfea21b803953fa5398b60796bbd86a070dbf95b2b32b75d43485c8c0b8e7cc67cc4d6ba6cc4ff5989701e00d5968a4856bcac825b8b51e9533d53f583990c3ebdbc70f0404a5c05fc604ab73b245eefc092023d94a49998255c4c165313985e2651f1d8cd9789b77cd9ec772ff2e047c46aa9819c5ab461cb052f1e04f5e8764b08dc882b70d2c90241527f53de8520f1b451df0a5de2b1ac3fc70d58d9de121a887ed0be9f4181363c6ed3d346a863cc3faec6b19e476d29e134b7485430c7bbec1949173d0dc1500c2c8df96c029a073ffbc2e9654b9785beb439d203f0b96abd44a63c551a581acc088cf3d18d8e010e72c18a0a8a238a865b74fd47940afeb524338775c8ad9f0bc41c15d5fc473d6331dc94462db9443c20eada804fa2dc046ab03c1d8a7472e72574f924b621099fcd72407464f46100c1aaf40ef39ae23eb92ce237d2ec071ae441c2c7f43e8cf9dc4cdfa1b16336c57a53d474cffb718e75941df08670953fbeb05dddf38fcc6432f2dff5ac80f736077746014b75f77f1188a117bc5c42a69d59b33f76761e6bd636ac5467b723eaddae97917767a9b4764afd5ae239f9d65e9a5ce982e6357564dc40fae15b92764b568aca946ec6685957f99140b098d067c8149877d329fed61511c444c684c67664ff362fa85b76b99fa97cd155e3e94e0ebcf8b22805e28cbdd8b3c8da2d47106e2cda75a6fae759f71e6b6c33dbae16a6f3c947123311dfa6717883eb2e38f24867825917cc6aab32c8a65881e22c628a0d51d2f6aa66897b70e4afa400389ad59c31c530f7153e5a69a6fe296117d8d9d60775020f4234d1be5f5fb11ad42fd944ada0be201e1c1f9d32d42c4c9c496f5d3e10afc540f02913590433038fff6f909f74ef61af49719e4e273a0cfed51127490d9c8831cf2e251ae621c9b3cc53e8192f969047d187e9225b439058ef584b3ec937d948644022d099179b862fcacdbf88cb4c385baec8d5470ae8a43e8b2d04f843cb829c759f153ff2f2962ce4b48d0ca6f8c3187436daaac1f8e763b3acb93c5d36b28ed82571a1dc23e18d28a75fbbd163c5ae51e9ab74736fede2b11c86ea792d4b8efef8d806ed0723ba9b9471a527a34ab574044a22ae4e5e23d36a213f221ae8f0f7c3993b5c3999c2b7b859e0386e4065195d9a1816ad0905950254be89e7b597604c60b385e1d40832e8b90d5782d6bd600de17050476f1492aaad58c33d5c34686b9fc297aef57d8d7a29affcd6801e8539980ab61dfc8cd6474e18ac0123c6794459210dc763d8d939564974fdc4e1e48de9e6a72059717bfdf76939bc52c2ce104d519e4be91691e8377f29ef45c7d4ffe8edd2d9673cb86eb25619bbc9e40df2d2dd678427283b4e69b4c43ac9c8905b8ba26113031ff381999cd07eef14b27e39cdb7c614bb39a7e1e2a7e831f4af16da5dd432424bf35aad0a28da8de7039738c735a39c71f0d3a02a754b3501563311d701d5224692fb40fd43466b81d53748a6f55ae58cd1165ae2016523d31a5a7242e8ed5a11f162ae0ebd0f94940eee4a909620d4154121c507b01d38a9093cbfc3d1324407c5eb5927f4b349ace513f906fa2af708d88f9dff4ce2e78e4fbd4a9d7ec3e2510e63eaa1227e220f6b9ecf112188bd95d213b5e19e6d9fdf6be208c62a989a31dce9c06cfe66e2db644597fca6763d424ee4896f7d69772295ce5413d14525c0b9929e7f8c39b3c742f8d2bc5796080dce4187661fbe67215c35a0a610fb03da8374b0ee051102b9a3b72ec66798750f3c7bd6c874da0eeb750085235baf4a645800c479a2347ac2db015a27e236485496027de882f1a8b8a32150bcc60280231d6522e1d20651d591f0d4cc1c0ce23bb0194a414f4186120d5bc6de6d8140c1e2a8b297624fe124c18056b02c346988291be19e089615a37e2a1b21b1ca01e6c1694345f49196f3dde3785cfd9876f8bd8b5566bf0dc185cd26a5b1faaa41d8e248cf76aa3ab737bd5d1d83182d7456b747cbead6c4494aaaf93848c4d7a80695d5ef46ce766a58fc5ab40b44f5ed5d46d83a280a243f1a93bd0938acb7c0a5b2d1e26770c65bfd2e2a149c30e4fed0ae649fc5fbe306a77fb243e2b01a399639eaa23922e23ea13990daa8922522c6c3e94ac880d8707606971fccdd7aff6bc30fec947b141df86c838c9c2392b68d30ac6d8d3bb8e0a86b319d0d2502ba6832efcc8a5600cd1586d31bcba10ee66080482abd4fb46ea4d3678279c018a7399db99f81233c39e5f0723cd8897ccf467c89260c326b9c41e77136af26a3b972cc61874bf8c4fa6cf02c11df424022a0f00776400c49c1b0ff8c630361b9e3067239549e250dad5be14361bc20242bc0c7886190eddaf7e3e3a9d63ce6734457035d02ca859beb04cd0841361c4b39a754a9d33376287d90647e625951b1eac1c5e64b520509b9dac34e5fd657322142fa119fe1e7eaa9dac1a44e9daf93cfee98e6398c1f4366f82c4899f97c3d4f1b8b627244bcf13c62399a1387a8bdb82c350258edcb5509b7db00ef35082bc9c1cebfcba4d5aa3ef6c79442b4ba809915b16bd346708c16a02a95b220dea6abd819ef265d0e83cef9ecfca8e5b6a6467c9b167d18524e2bbd37ae05fb700aeb5a7f74f5d9bda2f1d686b3a54a254926db7b17427f85de99e442425fd723a0d5f8359d604533f0bbf99a0762767fd89941ddd922539469150aa4753110acd9bd52c35672de04d291c1dd17a0c4d01086ac0afd947be46c289eb8480c0f9ce12f16b9ee07b50d135fb404270aab9db50cb3a73bbbc1df7f4b29db6b432dcb6e3c1b1d261f091e5eb83ad5fa6703565567b9143a2d0fcb79a1835801ca29764144a769da946381d69d642d555e26c064ece57ecd1d6c11f049a8215fe35545e453868bfb9158f693c03f737840bda1e72d66fbbababfc4a3b0280634c47279a531fed08030e50186f01b0d37590781ac41eedf8c50ed160954606e26334f8bb34f8afb3e953390b213b55e6c436f557667f7e87d0e53f09d0a51a2efe167df0b362f9ecf0b4587864b594739c805c61428054fc40127b4a89661979808036c7a8794548fcf7ba76c9d6dea1990fcc159177ce34ce0fa9ec2b6598cfbb2c8325a2c49321714be67ace643539e70efa3998992c2f235c4de5c6e6be17dc873345f5ab9f75d6891de7dea3e3c7d89dd2d13d6d03ddf6ee1fd6763cb8a4014623ca256af7e7f9dcaecaa487e82cf163191d5d54322ac0673119351ca4380ea6d909dcdc5e6953246b0bcdae7a38a2ccb5ecba7521fc310656e6359d155cd6d976689036dad860a40a57f2be2c6e1928871182acb859667c3edc337d3a1a25ffb5f5f0a732c4a2f0adeded62abe871816273726c26d89226a3fe4c612ba633c329a9f491ca92faacfbe3d5a5d399a7e0dbc03af97d0408725fe74458e2a2db05d05c96b03e33d064ee358ba03e3df399962640acb927cfdeffe993716d7e125269755ab1bf500ae9624dd1c881bd8b74bf0b0c49959460af1adc7da2206d70dd8dfdac74415e3fd1011d9dae8b89ff0e04ff1344b303aad860aa2d248b78749548d467b78509e4f92c3e61a2480a36486c41fc9c3491cf10418d6fc9e82c97ea2e9819bd63c79b0614c82a4c1ff79746ceb4b65fea2baa6f7686a7b9389dd0ec2647332a50de73ac11c459aea451b949579cef6fe9af50ff37c36fc8f61ab484d6907c34fb994e3f918e54264e03064761fa1e317abd33d2b74684a310fa876e97630a6667f9e23ea211e4b1c6a494d5a74aee9a7bba607d657d74f96b735e3b0f5e21f920bbffe78866833c079e538ed7f96624d4bf98b94a9c9b549321ebf313e745555bb4d53b4e7cb48fee313b72e64b6acd240d2277fa2e695b538e76ce6cfbcddd61ffec232977ccbabe80df1c229ce2189856afee5741cd37dc6b6df01599f1ae6fb789f14e9ea2b3871271f96141b69cf7aa061dcc0d2b46eb76eb46e71980f9f0d53484a1fe71f77dbc9a09476abec4e3ca089196f10850298cb63502ae7878718503bb50bac7ce8586a7ce6e712e63f225a52cb6e6012da9a3aa43b4c30ad819c30d789abcb9177a902bc9a40c9c079ce4db71c2dc429f3196468a3a7f13570ac5b7e7d63cb1992d602c7822ce274d23c17de3656245b06c6e4733f265ed5f361a9431d276f45f8dfa79953be544377398733a8b3e8f2904452a6b159cc54082a3907786326d1eb864b0bc618e5ba79ea8df84e37a42ca9aaad10ee11249b1a759817247da7351d3c9c7b640560c619f23b30ff08e68b9b18ae2d94053f5e9309478f00a222c973ec9279ab53c7bdc16eecb89f53e3aa9cb38444403ef52d35c69be5a828417190d2fc315e30299b6991193736754659db25f16763ed5e8c37b0c0ceff456c5570a2a578741565b825d17486694306f2b6848069c7f3c19ffae0ae87664bb0bc9c22c23257741b33c5b8186fa8a03125861777e034ddb2e8b2424f73cc9725b118dcfb0065ab64f47061b7d7f45323b8d55aaf60e193cce5c104249b33513480b0f65bb87803a4131f839917c738295de37cfa3b1548e584f4198c055ecf23b2c837321d9c861d1ec439d0a0b9b85d8a268251248f1c329dccbc1c2f0272abc01f145e784d1ac05c1461688a5e2ca8a14ae494fbd187f847c62446fa52a20c97be9415c4beaa69a7b8d17f145fceb25db941fa401173bf618cfa47366b00249b193202eab9f1e80339d2159859333634f1c1a667265a6653b75356c8cb6f4400a6b884e60ec1dafb7aaa79f09320b3053e8d3559b0d68e7cc4d785febb8c0cf02eb979aac9e07f12566fcc2a9cc8423c1bb77f95c4af60bb1fe945222d1207a64a44c07bf8561c7122faf80dc0c12d1dcd9d99beb7b2cf80dce237424df2f13e63f1671430d224003877c21cc7b4e25e5501c36fa1d11056b5b866a958f3b9e20b43f03d5047c11547958962f6e96447e5d1308d720fa774ff67314f8cf7c973667e5c673fa08f6960d3f243d74f777ad2036253e2d492ade5322851df4407180a00189368b1b858417c7207a728befefdae6bed13226e41506232d28e1bfceeefa4949b4dadb720cc85424259ad5e858d8f267c43c23c660fdfe4566745b6addb15be8c03240ccf353dcf0fabf7b7947200e9a52dd02fec5a454a152f00b10e24aa89810ea6707ee057d41c883a5893dc933a704e1134cfdb2768f3131234582a2a0975357c0e1a5c058a6114e0ae5b06ae7c1267ec5da3da86ff8ac861ccc7791ae7cd5fba1fea287c2137456a51030fd60f62db750358c84bb708195afb69116ed09ae13f963bccda18a2dbc52403ee6fd48f4f3403619a30305de273ee783dcf033d69b5d2daa58fb56832d3f28ac9d869357489602e0e52dc5804bc5dc684abd43efd682e71759858a0020c05c8b5188538817cba910d721867af7dde666e9a1b6209a54fb5d8c3f4656a96c96ae3830ef2a2c41b8da17e75e60a8745f52bc5934eeff30685508be9ac185c7d9c4979de4b33cfb266993eb579f21eaa0018725473368a422f0272d8f090c677c8099493c16915ab8f45e7f88370afa20bc714c21b6d028e51b34b3607ebbb00005c5d4157a7b1f4908a9487937e2de75b33805eeb6817b144d4c3b9626f313cacff3f7971a439a41df490b29e3ecb84461b3b8fed352aef0880cb1b16cafd3d618d5e63fa4f09e7cab2f5399cdabadaee92e29e144bb0b62416b958cc0ac4dfa72dfcac18c97cbb75069d0f38149f81a7be1a98a713ab792b4eaacdbc7d6ecfd19d6f722386246f1e08d84b97fe53724865afd5408f2248b721480a9663fa88a55418b77df3e1cf26d4f9cc126fbc937992084745797e5a44d326d393dae0e221bb09a19c4aa23cf8a30a8d30b54e4fdf678cb82df834773af527fdeaa13df84fa2308fd1196985623f755911e1e0853ea2d9abd7d469d82a8cb63836592715f5d8520755b9832430a508fb476aca2d9da8c1bb0c30fa3981b39e7834a456e13de0f19d37c91a241125f35a34077f4b328638098294d7303092435529df441595886c160ff2f558b5e0c342b514f32736a6079c11eaec23e986f50ec9ac4d70f91a71c5587758089e17ca857412b5832f899641d6aedf3209cba44b3082a7ed574b3a5dfbf5369ba002554fdcdffc5b1f1507e686fe3d06d6271f780781a386f472400fdd5abbe9ba9747e9322c562b18333406326806f2dd31636407a19246d2f219e56435c7a72bd52d4ce3aef8002f82e000e5ba7694a17744ace5c107913036adfe8237d697354714d5519b848ef6e39b13a9886f333fc674d44ca5f130d57c2798dd83a30c5f3336d995cfeb58a4af7570a735fea9d66e846693ea2c75a102b63a0ae7b953c51cadb05fcabdf84d4520b692a74b840d10b099f327fd283559775c30cdb82fa93f2762f95ab04584ed72f7d829971a3cb955de0a06046020828b9d32d6de7130ba5068031eb9f055ecb91fee8c58eed8e9f9cb88356450c620ae8eda543c53666c267d839389c32b7caf1e9dff661cd3b842b6e8b64af819de752954e643369b669861a0d29bc5d8242a9caa64d9ffe1bea94687fb2169b6d3a82219d95652f8e78f95ac2b41a57b2c9a5512e7322b526640345b9200ee8f54ea0a91278ab849e943ebb390e30b95f1c6ab3f0c3a9eb7df16b3d6d570e1f99c7e10ec65fb2edf08a97cfe6acfdf911ce92127d0eb97d7050100cbc2a853b91281f56da2a38b8ea14f4f9fc3439ede7d2c1dfec4cc9e5320c4ef15aa351b02bdca1831248d2042bff9656cd2dcd4e619fd11a66586a88d9fc3447f437094efaba76577e1eab4e17c4a56860c9f989925b8d6e052f294a2c8e4a0d4bb535b82aaebd60e5f55279a1d314ad4b18d9b10387bc3694eba406d60f2085258c387575991f709dfba278ec8db674d2e9ea12fc2bd0c30d742977bfbee9920c24e452f4d45169ad7996779d2b2a956a3caa932b94452f3894a59da1c15c3bcf77ec6353ca6e3381eb121492cabe9156b8586d8b5582b33bc53b03c8c6821626f0185873fbc58bbdfb31072a9e4f410fe1dd8d542f735eadd3981eaf29d6ac3dd1323010c1b94e258d27c215c088933f81352bac5decdbafeb3abb243100f18c609e140d776682e93b57efc5db13c1df64417fe89c6b7704b08fb51eeaaf66830c823e02938845456ec538a1c0ebf8f91e6fb31596c57c49140c6370d7c153563b69f935d05ac705b60ffac7108d45f33ba436f4beb6f436563d80341fcfc3cac5e266cf8d564b9a1d1c897947115b09968a23d4e30b707d0f195c3060d6b71d4b367bfb7656258a767185f9f7f69d5bd825384d7132cb5b87fbfe28bffae397fe5c4ef46051e00dd07a9b72cd06f573dacc0b426b42981049a287dd7bd0b1d41988cc027699e6ab550e8fcb445759a09890773e4fc8541236f1bdeedcc7932b8944e19235aa3c65956fbcc78ec85c6b0fafc92d61fab74eb0b2d2ddce333f4289e91791a55070cb537a64b55f53cd558af5dcce24ae30b68b73e6429842836f4b35f9eec1f0df48beeb6fdf5ff79508e830683c8007c230a51dcbce0ce2c22291080850ae5a9a1349436b0ee3ecfea689bd1b3c16993fafe59a850a2c034f02a9a71f66873529b74ca318c8834986125f6795bff498e8a91e726fff3ef0aa3ef3b5fd028d23ccbf3e07a125f8537812b694e828edfd95878b0606db73339a4979422b5d64f42a01a68e1b8a16641203f01443b33fbac2a062a9f0b65270cb3e106c84f502b823cbaec2dc26ed0a8b698afb39c685ecea60e51c35794af2092ef085c1df74ccc3cfe188c4466b7a37e0f1d310e1b438e10b2c7eac248594d3a8adf9c1a68796375ce682d452d32f7091dbdad105a5581c8364013d542e0b3a0e528987c3c8d1d8fdb4693f216eb4ffd5db84e4be09f79b95f1d6bf87b529fbeb3d1327ee4560823ff7fa6c4b1202ba1e4e4794ec472e7bac40a610c451814a77b2d950146816617410804133272a09902bdc75aca7378202e100fe28eedcf19d1d13477206a85dec5cb72b95bea22189ce04608a39f02a6b45dfd3e68b8532076d7e7f6a90de6fbb242999b890612b057398dc0271a9d0be9c0ef2c88129d0fdfaecaa383f197bd731ba37ea5738ced3abe820f9e804b1b588368dbed309e1a62c0a5a3c71af07cc2039b7f183fe40351d6d82a0785e085ad31593ef885a53358b990c4cc2c650462a05a3e963a63ff2b5decd164022e07046205611a485f3704ad821078410afa13af1205963767094a23233c585473f1002b79e8c1f22d12f241c48078826c36a492b0438a81c414541668aabc1c3066eb36da4a77bf7234336dddc5402a03bf0fe3503de1faacbbedc358ce719212712d5dae67c294508a4cf7092648e738be41a9c4a48eda2e4f386c187c851255390630029e21a92caad7d54c9cf048138355a38408d1397e6eb4e35e259c95e271b815d682e7f2afe741052d1b70c0876809277e067c62211a0f3a2921b2312e4bcf4f7aa44d0b57ec3e1c8fdad372e13a94aa9366747c52554bf7427f72c586b8191145480a7cbafa2c47862783a41a0fb2ccb1f0036d0e9faf5e5631a35668beab75c36fd5d6e827f05a6a1e5c714f3c493870194d35993218a55790d5af757520d484c97bd9640bd7422bb1d42cb2bbace5c6f5fda69840d95b4d4e097e657fcded22a9d297fd92507d8c0ec7cd9371b704133acd1db8bc6c3e1ab79f15e985a12349ed035bd02ea14fb539fe51233565156a9bd6df98626cedfbc934b9257554472cb75e6b35c986a20b89d41e4039d0f2615345015fd335187337d48d43a2b32094087f2466356aa54b0099104f0a95f92591cae96be5761dacc8c28909ea7b0296ee4dd651d9557177c6fbac2b549f9904303f652d8e808b85051b3078e68c524dcb64f4b61805f697948f24076667af59af26696e0e4cb59581497f9828fe61a48e547c60f782a4fc67e84fc9ac9784d42beb0881345060d544fe5fc3cb0d2846e732b3240caffcc60ea17429cfc9277e6515170afc4b9ac4b4f9c93f81b8e556af197bd5bb16186b690bc9f1cba7d2a683ea5deab15d10ba4d09c66fbea91a03c2242a4e1a0733c2e029695a8fd10b18ae74ef255c72a1a9ee9fd161d3677f3bc4a2ce9afb6233e0b9f9aa8b98325776be92498eebf9b2e4e443bca3af48c4c57ec280a68872e52edc9e76caffbc2d55b7033161617880cebb31241eeac80211643066b0cc04e1724e48dbb60d545db168a55e778f902971ec6de93db1eb56600532ac31f28fe4133ee902d2a88c2947907d036080d4da0d35ec811ea84148a98645f7ff9716672dae14c0c0561d895b5c17f13ca97eb0120987c4c9dc08d0e10bc86194f71e7ff8b5df8b82253d08de99f58bde72b765908d4ba5cf493dc15783cc46e435e4bd14a02de3bb1425861674c903a3e884e8d703294f68ed54e7e3ea95038b2cde679e91d7b25c33007a41acaf75ea2f0dd5f75ff8393fdfde6bbe300d66a95618ee036f975ac47e8c9f4313544e0f3d2a4287b82b1473368304d21d1914f5a92e2a94a3382fb9d29008950c7f70a5106f36c910d7d2acda31404a656d92f8186f27fea35910a43e22fb2377254bef888ad473091d7b51150ac99efba4b1b6c0c7889c86c27c9cead524481344710a20e5beb252cc380479677690bd9d633141a8dcb3b9285304f43d390b62e37018900e3b512871303f60e8d9cd1fb6c054b902417934e01f3660b0cc8886ceeba4d13cd7b6bc7951553ae520068b110bc1cce3711aeb01750c8c1f31de6ac7280320135f0fb5197c40f603a46648e7325d45e3df7e21cfda9d63226d3d5cc2d810556150fcd89d32747e1913d0237eafa57ab7646a15e1d0f7e928f19cdabaf10c089226bf661f41da524553c29379b763949f8585561392d604de93a0194701a7ad4824779aab316b452c3d61245832b28f67b7116d684d5ee495a49b4676028abb3cd18a0d1a44946aa0764ab0d592f2967c8090f4c7b3ea737598e7771a59d6fb5527eede2bbccab8231304b8eece0870966648aae87450c12a457ca021e76a7c0419551e9a6da4b6cb07fa53cebfab1d381b577207849e829fc85b26aef139d3f02ff6a55276b53ff6826125340c15fddf869757b7585e72b217e43af610c81729876da5020a81615e65d4b392e02228d2d498c301d7be3350919efc6283a51ec580136abd7373844676835c2acb575b4de25ea6cbc245bb31f394a93e39cb53c4cb9312431f58c4b12cf24b3e399844f02935c1b5cf0747ef74256084628427e5dacd6a29898b1d746b20bdb7e6cbd32a00d5f02139d3b679195c22f74a63dae4774b4def34752af12978848b33aa92f47632375db472f05732adfbb2ae4520e6246081dc2c79275daee00d32d8bb1176d7ddff20700b2ce913e8df552e4c8610ccaf03bcc734c04bc3888264fddad1985a9cf389d56df72e3335e08b265773dbb273742697d6ca04f3c1e7411aebe8d56b428ef06e3324026ef17147e11dc17f68635cde19596806996c501f4b60b3f6fcdf898db9086ccbcc8e37d87040534d3ce3276956c96184a04f2026327c26ac9b083ad4fa37749affce8c434f65de20c83ef62926750628674c9c2d8d32fc49e3bb0461f0486580582636ca890fa84f202e097926584d4e496a7f3da8f5a34dfa565df0236b5a8aaa117f773d2dc3899d9382e9bf5cf07c429431fc1392ff3460ea28353cf8b53ae210911b72b0f70ae623fcfda213b4d5ec7de833dd1b9c8af60948a422b7a9c1ced2a3151c3a4ecf657f91ecf41bf5a825611c50f691d1ad49444dc6a8496de21b2568062f6dc6f7dc9662eb9d3302d316282b22483012d595be867f40f69feb582b32339b2b97590a509722cee918e409e8daa367d5851d12e23264d3f6d073d81c25bca2c2f94993046b571b3a636ca93cee0db21a27a90836831d103b22f772a06ff5b61e4e074f00c0cfb8fb15f108585960cff591eb750f91365622f60a6788b460b253117e2a5055228272f06c436e470d56ba961789dbd2ace13c127e3ab9e600728ed4acc51c0e04ac2dce67312a7cc8903b5c0eb3da16b12a7f1dc40d53f6242491a940f0990cf035cf4113c12edeaa9533426627fa8207a78af9751f09e4c9c6fd8bb039bff2382a027b890b7ca3dae0ed1755c202088e88e1ce8384a66e6a9a4b46261e0de6f02b91e7e38a373aad6ec7dc9b08cd31b0bca184963eccfdc0f5f321c9a6760b933a73cc00cd59c16ef1b35506899fe830f02f00a2894948c36f934d6a7ce046558d0fc992182c9ef8322cf96d38da0e2cb9561306a7b8c48ac0f55a54d48aca0ef32a8dfbde94b278398bc645e2379dd76ac6981b2a4dcbb994c313d167d6468a27a8aec462031529d543d7be62aac314d036c2dc252b905344a8e278ee4ee181f3097f7edc64d289b148e67b3e3593ba59eb2adb7ed728d464a9cd06de9a410c2d2fc9bf31dd4897ebc9ead42ae4a8d201cbb50d207a7429acfa30347616bca4f497715a2523bbe2f1cc1ec0631885ee1352fd4e5885a511f85674a423598de4df2edc6b9e956f1ed77426b83825d444e461ec128b58d25176648b07f82e6269aade0b346da6781fde324a19c029e543fdc5382f8557046ec60be8e9fce64b36d20f9180f1ffb07bd2878f522628e6fe996ebd7cae35a713813d0b2a6e49b4b0d2fada5f9a6645342ac876b2aca5ea064fd13d9652b007a365370ff13f0bbbe7dd010fd7b294d091ef0de48e30193faf6d0c55e54d3b9adc1310ca826e64261755e4d5034e56a1f0d1aa13fe38c5af61105430fb29a09188e6bd23ab2b66819a5c20155f7d1fa011de8d6240e76808a8888ceac6e5bd67035e9711a26a117d67c5c14762f3f94c1e0ded36adadf680b3a5b28325331c9ffde477699d0f03dfb813176b8c4e7627959d1d877e474a738993f46137ba1a297b2534e75e4f908256ceb87792aff2a1f11ffe99ec0eff0e2aa0e4262715de4b79833d3eaf5226abc5846bd6cf061bfd9583b216cf248abaf1fd6070913a3f707ebb26ab86cb0b130871b2f616e8f5141378eaee594765b8cf649f80af3fab7be17aeeb753aa64ef8ec49cd32fc20dd5d1dd96c27d3cdbb581712da6fce8f987986f0deb441f3ee751339d439cfefff96560b11842f861d5354ef28079106adf7eb8088560e4a6b22074a849a588d5c75042203972e32b2da77bac9585fb23d7db17d42a57bc60b7d08054d953e64554de39a04b9c24d7945ef22d7cad9ddb5856b03aa400feed5aabf09d1bd60d06f089516383c311f7f78ac4c6acdb68c419e039a6150bec2e09046c2e4995f5bce65dd36209c3f4e2cc8054292f9f009e5f2288da554c560d8d024430d22d8b762a16d92cc457243442adf25d219a0fc89b78a293fdefeccc77ebd918629a947aceb601de8258fd35ac83b5fe228a0f328dad21b3e75efaade1081ec3b5a89e615f2489d72261356f43faeb0c0e02484623fae1d293cf55210752c0ddc40265ec0bf90613c142577b0c4e5faac573d715287bd2c21454401ceecb45722f1c144530374ea460de1e6fe0c3c3f2b3c9af1ecae2f2cbc3f5ecc10060a080a26bbeb23e1aed0ddea806df98cfb8fca05e9257e1139cbe7210e427d6af98b5ff0494bd4edffa01ce8d848efc1e34498b8a9e38e8c0d05e87fdecd368ef87d9845d2b0b34706cbd67c2331d22548aa410e88f2a7596d4e2df9d59d165b2bf4fa973386d8a6a7d15144cccc38a436554e0399a74a854e375d2faae9c987d99cb436e7da3ba0bba64821e390098571d8c2fa65af64681e570432bcee2003ca1c0b2d0115e87648948fd30b6ec6edc1c05bceb6d4154fca13da8b4df9208be4c1f33933efb2556f88715ff7facd00044defd8cb25a65c1abbeeb4656146fab35f054ce56ec50f1ba0c512c52aa02e5688c5069e12fd97d802895d459cdfa4c06c71552f75c1fef78f1b2e5911ec819a004ce2ad3c5548b49d52e09e9dba0907351bc4ba62911eff30bd56a95358cd3fa08f3e9201e85069855657eaf5834d5d52544248e08d387d6f75c58d4c02e2c021044fdacbe06eb5750c4fa1d18631af2d6ed49d79098774d4f6ce2a6e44d3d27709e05331b8de89c57a76cc1c0336b35a70cc4ccf58047d204dc7a456bfba0041eaa8e35992ece03f2982f97fd0c5d640d1c550c4f8b8ca071dab771364b32407a967741b9ad744972005361f29fad3d36a36e7b7f476bb8b6a6db48e02beba9fd4b2415b71216ce091ec825515da0251456ca44f4a2cfbc00edd6507a2f44890ddfa91d96c234117f87014388b171ada3bbec39e8109a96cb0a1bbd6c9e2bb6223b64762e0be0961b7e1805e82993ff9dd181f5d13e5ecf52d67a763cea9859603f27b97bc54ce62abdd9d1e18a107147be07c8b53ef2488c208ba23abd504c51ee8796b24ccda856bcdc24cd2a82524bf032d74b502d14588dd3b4ff3b7e1bba334393ed6984406714eb0a67192dbee2ba5783f6b2c20ccc7f4d0f6651059c548f99e65287da537d0a7ef056d5be81031ccc2229290053dd106232a517d40013143ed9c40a191dd8dcacdbcd7a85c0ff0342ec32f8e2f65a8ad45ae53bbe4500cb9ff783cee8bef7060d1c202354082fc8ef0e8fda0b09f29144210ab08386d30d85872c603442a19fcea13d58b25af1abc43e1440c2c1671eaee9c9b8fdfcfe78e896a0d3a08917826db2d815eaf9751caee6230466f25fe00ec3f7aa2ea033698f68b830e702c170068b51c3b80270ed68831eafe352a5bc4d5f0608808bf2300d4517f620976234e846852c629bf5c1f0e836280f836d336e0e674de2d8e953ca58ec744fa4ce0f6166a6519d8881c37d3ad4babda1f1f06dc81746a0ba281d85ff7815c1d35d417fc7a2997f8120d1df0ef67dd5ad22ad6668aec5ad5a2d240254a74faf79d9f90ddec61d0f426bb1828868af387edf13a3e87e0409092e6564f80370591b80a078a2479aa6024a7223417141dfe94ac6b0ba87632773762db9676db70b390f0a2df2f63501c39195c3ac463f1aaeb0e3c05111217505fe3d4077b33904d06fdf348aabef16d160fe25bec9db8b6501ae4cd50fc9d038904b932fba76e68eac89a9e675226da5bf35e16426a86ba2398cdb5df39730c6697d5b0062cc12f256bd78e83b295be22181ec09280621f256113204f8e34c49acb713f850b5649eeb55d9580aca660db1ce28743ca196f7b26afc5b7b6b6a67ed140e4713c37b3197010166d05a53d27f5ad16b86491753d3e2f391a48359c400a1fb9a7403735323392e539aaca2e5cebb545a5a32017433245e5de1248a1d6955e09edd3114a9a459482f356280aa2bb98fae329aa57f85ab969fc55c11798291d3cf59b994dc555557b5795c9b32ca1b9442d99c19210aeec001daa39d94893d6a1e29a831f34a613c8da73600255999931d4c7390e64ad457f9b602e980400572e39cd1b88e5c9f052fd930db7b13e5016718384b370cf7edd755ea75a73c736436a19d03215fca359f663c7af0f16818115b9033cecb7072ea4560f21de6d44a0ec1abd6d9f3af81404a78d6bb666b5912105d921fc65febcc9f272db2d30002b616d477eb18e714866b6e41890aee1f3b4061dfe4b3d23905a67a98a882833acf6261ae426d0b4344795e1748248bc3e89ad48af708e13caba08cdee3d3b94dbdface923b309005973861868e7c9295c34521e0906ad854e2a1419a4e5b10278da3345fe65ee728c81a61dd348e2e3604680285d2402085b52009a98e1d4e61f75e17eef53aaf407bff9bed5b07b891a7030d7eec01a3c3289d749a6adec6f78b930b702fbd3a8bb0c081cb2e11cefa88c0c0c3e7bf036aaa59cfe626990dfd3e85ecff37a0786e25060b91933a266451ca90d03c73b174c7f00641e2999a7034344cee08fa7d44043dc7db3676a00a5dd586c4e6fddaaef302db3694e511aaf3302ab443525587ead793bf474c7d3b6e4a3192351e83275319fa6cd042f962cf82aadfded240c0aa2dd9da2a41d60c8ae75441575a7d1e638a797aa512c20ec2acd380c3e77d321660ef8eacfa32a4514a28fb601e8f87f357eb7d82cd167c45c4969a3af2a0b6055d046d866c5d9ad8920eb90e64d7a2d4734713c0915f12444d9782e768aadebabe43373fc139fbd605c4dcc64ed934c2e1130b2ee25bba24fcdb1d1f5559a55543bec4c60fa68ca079ddc53e9dd7e4f447052dcefc61ac20f8c0da7de6dffd62328740522d9e5e7e8cfb119f86009c0a0c72dec3a757ca64c64495d9d16a1550a3d74bfac7aab8221bfb6163d45b0a53009fba81f259d09fcff4a9ee3f30b4303afd87a23789bf1a63ecaae08578d09190ba5f68de5efe8c920a922c40373c139ad601506b2f4bc60e2129b78826b17ac5d954de1ac14f899a603bcfa2ca18742b3d84a66e23da145b4a3c42ff5c773a62226c8d6a8caeb50a208908222b2f601ef3c37599a48fd505bab6b90436c5cb2189641dc542603de80c1bee938e68a0c28b48e6857c5daa05ce25c4c84b589b3137b280c1df8adb5f4417a497947f05217dc888f684f6873793d12caf19dbed38cc967e408b900d239694a982ec62b7abccaefeed39feeab13aff90550e70e6e5b97c2f664e8b09d49df95b3729ac67ae5086f03261c99ce9893e7b7c1972822bb50a06395a4319405ec18a632b53ba958dc67ede821bb0ab7d7b36afc78a9722eb3cf92ce6619701f55333e845b22969d4a896b8fc739ff61ab78b66242f3041400e8045eabfbc66ef5c4082b2c0990b31073c1332480aad092714d30d082c5ca6a74b9128c413c873726cd010ca3ad4dccd442fb8551afc2fae2ddb82a5622677245814dd6c37342af69c895da809f94c4db3ebe4232ee2198ff218b17b8fb9cfb36747aafddcc32a02d91ce5baac5fec92107d7f2a891baa738867a0987a92f8c2407c8f54d74a05e5310a2da05643be465f374e90f8324638d86e7aad04f8e78e58532eb0b1baa849183849482f33c2660a9de2f5e50b245b417ba2ea706a8ce83c55543fecfaa8816301d98f187670088c9d9566cacc2941a490b470867085ee2161786d1177d07f673e2c0a8651d868a4ba2b976e0f2f8dd06f2281c2291b6a92844ac498f929687965d36d896adb294ce9c643d0435c05979d56d159ada4a441f6101b69b8bdbc114102f63bac7ab7ae99d62f3237d4fc4fefa46e8e44b0f64c847cde1ccd209f135b8c391c4a441bd2c2813888f62b903e46e6d6ea1f835818cbef94196323d420f5a89ba871b54982115415735db870d14297cf51d844e6c059e8fe85d6edeb533217611da6b19487b3aa91d41a006447654a4eac0a0f286982eaa3f11d1ef4c4309ab532bdd7202a4fe76543a2c481d450055fceb279621e445a4324b4a30cb73bdc817d6e160dcd84ce914226b992d106e291267e4824eee77c0a9d465bcc8caddcacc50b1b2642c8448e5a8a0f826ee8300e2e0890ba7c84500c22a0380a81c759852983bc24683ab87be4814ef38e2ed55a3e00400c3b505dd96238d178af20e18b40a622bf6974d7a3a95c01157dff989f8d2e2c9e75312064cbb8963ef7f34ecc400730d482c3e4a9aea1ba95ac8dfd0a264c43694b03542e04e9034f85736c5a14a6741115453c244c33d87d9829f102fd9f2db3546e166b3fdb1ac0d4e7f49e0e7cdc3e97e9b0a9d2b968ebc04edb20bfba1da7b56e33d8a51345864119e91be84653069dd51201cf312abf895271e2a37311dfb3a9d16df93f669992c6dc4b208a62254e84a5b65377632bf89ff7083db0ff0c332e9064eaa61b39512645774d0e229333b48aa845b4f4eb8f93b8e69b360db8639100db2b50ea1d4b0c76b8b33c4b620cb528162665dbb716581c7759d6c9d2cd8d631b594a474a9e21bc65c048c9f6716cd4b9aaae4472329f49a7b9bf8c5b7dabb606cf6e47930f0df472f604a2a62e03118d07ddc31746b9aed06d79387de62e286343f00bb5fd56bb02373d25c62eb8b9cd082689b50bcd40aae1b9782406b789695b073c271d4ee38b94de5c7d178b8ffeff91d46eea483089603f37804bf83962e656543c2324689a71d63423f88fc2dca29e319045b90c6050f19b74da2b9845723bbf2924208d8b65874a13aab6805db757a398497e9a31ce5f011d3076e49c6a271ae7dd147418b061602753ca51e6a2f7f4e366c2ff4b992719d174bf3c21dc1b286800a6724b51b1097d1912d3ca829da55ea9850e2fc19aab11bd571fb743fed9285790b98402741110da9e3899321f0647c243d5cc2c7605286a4475108446b0d46c2aa985409b083117aaec0fad22d080401735358cd4554decc2d09f7640b8ca7a719db6b129f72d298b6381d24f5ec83e4e9e861300fb2d6c00f34fd4d78b619383106c3aa5093274bebdfc230b8255bf44c49c6952e1414594f66af4361cf24e1734a3e36553297e296496af7d8db57c5af27243b959d51f20c7eb4654a0ea2593852adb900b5c90c17d03aa8bd8e6b9954ed47653882157d694853eea42c8cf59535e1a81f7c0567c45441d5a9b4fdd7bcc2ffee32106a88bf1921d66970313ee34652c7b2db0c41fdeae14d3c0b93832d497bb572bc004cbccbbbe704d10f2c7018fbc2aa4b7ff151e6eebd78d87c010c88c11c2e799e9273ecebcd3b2b4d7eb3be350bc15a8ee8d648cc49115a99c775ad63349caca8e261316b716a94b99dcc9b00a72dcb9cd8448e470cf5d90e9c5a6883390eaa4bdd84baa353b949145c98e6ec8b979ae700ebb7c70b0a2f9a86cd3d94bc6188fe4719afcd7394afae850b8b8a57c1ed6ae883a520084b317667408b69296bf68a92c51e0b00910f11c1a066361ab7cc40d01d83cdcfbad8efa6400c7b2b7df9cb84b6049808a74d860d18fa8f347274977067aac57790114c6ab32bc74e8039b06ef158cc5ab529e8b57b9147575f9885846d0b365ebd0e54b3d60171f0bfe7ffc2445f5c610b8d00cbce00e62b43e14dc55d2a32d63f795746c0d9c84a09d19b0720b6522e490447cb42b4619c3fc12d125e0484836180364b16ef6dea3403c74d9f92d93028102134dbfecc0f17c46a4d6317c5cfa69ff395aa84bef9d4ca8e4a81fe5b9e387e8663083d098f69e666294620842b804e0b10d7e5f0fdb2c30e7b19c5d7ce9b0bd54f5f5c4ef25fd8e83d22dd6201cf5008a0957ef1610e8868eff4b34382ffd76a5ad167718a0970451fba13a108728a21e040e8ddb9159e2a4d66990f6de00e9f4a49da729bc994f32fd21ad4379c602b13edc5ece29cd88c161fb53e7b5bf221fbfd1544b408cdfb9b69738c0f444c38af947f04eef7224ae440e85ce81132ed20fd6a08b7e7c7a22d5d731145bc1af3cba061f15d7ae04e76aa435bbf6d5a20cd051450cb00d054926f86e832992c800f82a449879454bf11d111e40907e146d6827956a0d0b635c054e844b43b8b8155af0a47b7c1b92f9c177f588afa6a15e7f2c318bea4268bbc11af70604ec9be9f6165d827ad68d513cfdeb919beebfa6f2b92d8692d4abd2c7e1c109e6c2513504cbbb6cadb2dd4f45504b77f8fa26581d6a7f5d18250f8289d705dc1d8bc2d46c8c8b56a3b6ec5ba60bfe37b8cfdab5e744706f4fadc4814ebcca050dce2a784d8fcc6c994d4854f977394212aaa46f915d9825b331f921ec956e6e5a679d0b0e4a4a8e3b80ba385d93016fcb835f415f4ae21fa8685c8df21ccd8c4ad0d20dc4cebad442240f415d6839c597d10f8117d059e0533017288bd86258f90a03710924b1558970333af678dce4bf782cddc68e6c849612a8cf84d7ee199579676266a383fa729b69c1bb3fcc99e42506f55293193accfea1ca602199655b13b20cea5849144a48da0d2bb7bee180f0043134c7496603a65a4863ee49c0d77b724096229b309eb6101274202e2accda05f0c0c3b034b533330c6ce3b3149bec663e2ff0ae78e2264739ed3f79bd4c06cfc0f54cd25f655cc5b857b92be8cc846f037fc398a656843de93789529a672d354ef5053ca722c71a628119cdbc89539adbc011256f4ef4013751bf94622331b18755b188e32079e0059158dbf2fca29fa918ef5096a93e27ea1f9e7b9586fb0db0e4ce103fa71927c5a30523a4a1b557ba611d5181049f87b5d3578efeb15ed62555c45c95e739dc48d5d89b1a19346eee9649720ce20be71ddf7cecec471e3790bac553678cbb848f0a2321d57063ac65bad11fd0fea13d44d12222989482291bd690760084e07b0073203ca3f72503621eac4f840c0f5af379d7e867b4ecfa8437fe6d613874d1a6b4a8fcc7d55fa56383125ac63d7755dd5d0dbaf32f63663d6630880bbbaf247949a2e65159675adb56fb19bdc7f89497bcdbe0848763d92f65fe7eeb57addae6bd332eb177fd8d192f0b2d30b76e207f8e362e211f4b1711fe311d1043bc62b95abdcd33c8d5ee2499df89c0d2c184a1d4b7b9e3427b566fea491a86661463b9256423ac16234e0e803a683e455310fd8ea0f9fa828ca96ef590587e2cfeaa3ac2af0a5a2c71b04499ae9ef859d197961cbaf681bb1b634e92f866dfa6d03024aa53e6f67db7fbfb36ddb7e1b4a42b76cda4c992933fdd7ed4c675baddb5002bcaa3c0b226902acb7d62f86bdb5d6643299be6867d96fdbdffc75fb9a724f19f8b587d956b4b79c846e0dfb2cdffc25d998cdd56399fe35bf7e90846e5d61e79c55aa6acecf3dbab027dc39d20eb955b9cf97347b8e30aebbb95ba77c2eb54a1527f6c42e480487e4c79f28a0860c410d77ce96b342183d9797c72eacdcf4da2aab8fd10cb3f7fbea150e81e14f5da137037d78402f7e0761849ed72a6bf4aa2a75304429c03ef62d60df02b744ca92eb97d4c72e0da50e108c5eaa8a1504160a61bb7d485eeae89fba62c04203e0eda6674c8c7388e34044fa56ab351d0825c4e8b3aa755befd65b5e1c41ce96357abfb3054bfd59f875cb4737d473c884518694f51656cbb2f4071f47f4e1d5e73edcc1e8b6657dc51b96bb68647d9dd6b2acafea4c22ddc15495e538ea43fdc1b774a53f77aaa30a28a594d2ea734faf023a84d0e974a702858218ba6c8f12dfa330c07a9475fa8c925616ad547644e05aa5cec49565d518e3ccb9d785510cc32686490cc3302c6298631886c11a42955583449905b99910d72a8d6adad4344d46d7340de20bc3988d0eaf0b5bb7d6420cb3f6664259a669dbb64d6bc7971046cf9ac3abf9b6c19979c41056964bd5d0b48728c8cf77fc32b05d6f189b4c27df3dddcc8c27b42324ee1cc8d309e108899b833cf06b788c31c618b5bbfc19a7749f4b61be54b992f4c481982fb0d003949a77ce2b39135ed9baeb6c6c6c6c6ca2436d03521fbb00906a3acddc1e39a7ac8935355e032fed83e1749a99e1381a9a1a35f0c6aa689de130e73457484d07d40175b1734a4353a3464d4dd779363637372854aa67e762685574deb821a35f35375046ef6cf00dbe12dab0216dd88836bcda6442379910148ee3407983729c6843dec09104ae40638ef9835be24ef5ecd41c570e1682bd317f292171dbab23f3349d6d07e6c163c29b96f15c1e8b5d3c3cd5e27158a37d45fb5e871107077338703e5b08b5ce9183f32204f403c210421041870ecfe33a211d6ec70e1e3bdbcece8eb6b3b3b3b363632313ba2184c3a3f615ddb89109898f234772dfc91ca1fc5c177de7e0703964f41c392aed33a7391c73721cd29cf5a633a11c5cce0de17a16e48a0075441dae83e66428cc9d5474284f803d4f4767c70e1e3b3f42266421beaa954a553435654c792a958226ed2bd2e1e9e87411da910989bb0708f2b83c78ec509e29a3f3c0aa7d4b3c2f13e256277ed43a3b78ecf08c20a343c8b343661d3dc6e831422b7ff59bd0dda7363f222866f3d8b163270bc22313a23c3221d72828f8bb0e631129401581e107459e11a4ec4164fbc748d4790a0001c884049009c11eefa9da5734c2087284e8b0070a85d4beb1a3fe260081262c8c6e44c6996c77aa69a414d248e98c926a0de91473ce49941373a0110906d260a7f657043f3772a31d03f6f73d938804c03be0f8dfc78813638c313a86151cb2ed1923b7a5ac01f5e855abf5b562dc75305715dd441ec444d8092184dc7dea5cdcaa28a5d4a97b2c62d239e5c3af43f2ab6ac99773da9b1e2f289d93cea9ef3c83fec420c5bf0ef94f2d44df7277cb5d4f49abdc3306ab307f5214a8be728931a4958ba4f690fc1bebc72b095b0f777c5a7754e2db7591d4aef4d07c9737d88ffe0d135809dd951ea25aeaa1f83ec3d2972caa940942861bb24c1720e1e1080e2e3e40022f5d0081cb126362161d30e388279acc3082262418244a62e0a5035998a84103369c71045a31a241135f9e30592209337e904598264884e942c90c2906121b4c0cd185164590994195320a10850c252652c2fcd0c5bc922305195e6c20081f34d1032ae6480f61c0600b285ad0031371cb912d3e948004484835f8820c19908104298d1ea028230c2c494954073598628a256a80d2039931908821a3054300010aa32f35d030530922c8a032c4132c64446024c34042811684e940131fc22c9d012684230f0021cb18198ac082e6e0c8ac02c9092ef0618b3159a0e10130a81847ca78312687107421811552fcc0831eca50d9e28b333e3066098914400105151a7ca1e18b1c03893efa000f9618d3449829611cb1028e61860e70b86203165ba8902408c3064e0091a481249070010e8a8408c1126472c032441857c0e8c10f860801164258018510f308119668a207625809410c6e9853e091a9a50b078a30438a1f68918418f40bdc12850cb4b84203661c81c313934a1a5794a0063878f24412497c8104822993c609c68ce0cb1667502fb48031c313204ce0050751ba4092c2165d6cd081862852ac50a5235420819409242d30b1850a25c48069a265a6801a01c41622e822461844d01b1c992f80687c6982e54910aabc400772043f88c00654b4c00a0e5ba2e002890c63c268228827be58c2872d907c51c20834c290c18a3368a05e60900ca2f040822bccc0e1055a403252762042074fdca0c50cb309241698e2041fd042891b82b0c2060f38e38805629630a3075e680d669214e3e3012caa4841175e84d1046a11812aaca46183204ee00507ba1c296201106980b105193a5cc981d200491454ac30da010f1ae08013740631d00004305ca0000733a2805e661648341bcc20450b30a688810697b802314a3ce921cc0d42d02d47240f31474c3027619eecf81188f8e323c6075a01e365c7773137a72c29fa7895e84379b0e3fb951c36ddc1beb82cd378043525c09f2bf952f46ef08071fc3ff635f237778d370229c6ecbbebe6ed7e6642366f6176f3a7fca5f6e96f7296bf157676cadd679928b5b38f9910f69f27d5f8a4d3d1c912f87327950cb8c6bf67416abec607c90aa3973d8ef74eff383e6234faab1be37e467f7e0c247f6ee898e1682875362db5335dbddf6c31a569ab54e9d93769ff883ab08a8d118b91d43f5ec7bf7127db7abfb9827dc79bea3f586503f9d20fff127d28fd1ca3edc41dc7cc97c2c09f4cf912944792ab9faa554b4a86061a68f0bfe63412e44646bea05de92fc85a7de7db9e31188707f8835a64f6e3ba6ac5b8ebfe33b8af8d999023f1439628367d0c6a195221f14396a44d6b75749d4201eae931e14dcb2e10166310474675fb58f153138cdb6b6fb529b0efeddefb4375fb6aefb5d785b3bd32cc6a1b5c98fe946127d3fd7ab7ec3bc3aa1635acfd479fa86947f7de7befbc990d2e2c135a68616484e52f67635fa3cf497f7557bc4df0f49346e3199a65cf68d9333371e6bf222af42b38a33fece929fb36e5df387f38f6fd4dcb593ee2a9093108adb5461b5fa6ea4e297dabb2acaa48ce105007faa81fdfc6c6042f6c19718e990026ed6cdbf3e3c76967d3b2aba4b28ab01859b08108b344f73697aac9356832cc33d955057d4929a592beeb9ee8590f923a99f0965d8b51ea4facfcf564dde34fa24f7d8933b5397fecd9137f8252330aa5d78362a27814291d8a01dad388cbf9fe010155203cf9032552f4a9a46c229bc826724acf8532f341d18b3ef2639229e22cd0d81f8dae2a897434f6855536d4017fd5dbc7feabd087c7587f75d39aceb47fb00aa55a89dcf46da5844aecf38954cece0edeb4eca6a20d49db6e94e6bb1b98053f2adf649bef724d9e791aeeb5c76ff115b072fac32793ddeae55996657fbb1aefbad310d6e81aba66dbe38f3f61968d31bc7dbf313621faf8e3a4fdf2a7fef7fb7b47bad8b24a4846f5dd49f4e2e32ff873244792187c17945c3fd951cc4cbc5d2cccb9aeeba29452eb9a3e57a67f5dd7755d9665ed58182db263557fe5b96bbe95b66103feeac4138a65f1a665106e1d1d1cdda6bf0eebecf8f6b2177677f6ad738b9d1ccfc39b96edd8186d88db9b18d9d37f75c67f382fc1f4f4b993def8b7b75b166d599f3fddb608ecb2bfa2287b28fb216b6b96bdbdaeebd22eec56edf433f1badfeb2f7bfb417263d7ea0f76b96e3fbcdf4bf06d6b6233b7aca75996595d62972e996bf9da7a5d6da30b2875826203287655a16f3f888691b5828454a7acb08e38dbb9ed9d9bde5d7f443b1bff7d7b73c5827d63ec462f76545bfbd6d3fc153931e9aa318d556ce6b4693965d921eb33df9b56e464574af5e6dc78fde7f4f70259a0ce71883afe34436aed3b86d94c04bb14814a50c9a1d276a0ee081503fcb90f108d1d7d9cd817e4cf49fe489de851fa0d903f3fe857ab8ad3afc3315be2aad6f710faf5c3080c922a92dadf0ad8dbafd25fead2f067ef5bce74fe746cacba2e4d94b3aba34d8ba436d54377a691fd4d5dde4e4eb5d65afb35887dec83e2951fab3999f6d95c4e4311100c981e860c98be060762d24b1c88e9fd6bc41bccde94ddca4bdb2d7fddf79f8e1dbf7e50bc377b98ddec7abfd7fb755defba48ce1eb2bad3385a89dc4355d71b3d9ca26558014365432b631ced6e432b6178b095c43d4497ecfa18e68e25895b49c5f2f5156696c6dfc470ccc61ec3bece8de9fa7e6928a7d4fa44a20fce1ce74ddbb7b6be045e637c35a6ab43d7f9f0671ff5634d4718c40509680fa5cecf20cb940122e5f31fe265caec21a222ae89fca1c0102475744aeac82aedf7dc00266d7a85942c530648a6c542f7a3eba856bde97b0f8aa345c5b3735b6b71b6cdc9d976d3b2ebcd222cfa0e8a78d82da59f43297efa3350fe70dc9f3ecb50d9cf3c0472d24b5099462960db6666def4309cf457f73dfdf60d98d1a687d9111666fea497c02a75502b68da3b10fca8161c087e07f2612d053564c8fed5307a1d04a2d5e8ddaff9734ef4b0d4a9aaf937ce237eecf40001459d1f55918df10808298c5fa94fe833dfbfca775da55f5c8ae042c49e1f87442e457079b267915b5d8e31613552814dbfd60af557814df557813d047fd2eb3fa81dd312de2118e052041727732b997beaa8efe5520a5ba38f125a2bfdfdf6b1d0a36f037d6af4a27dfa1df4713d7d6bb3fc18f6f13be8436eecafdc411e0c67571fa1577dfc0cea602c75aabf740779aaf9357fdcd657578da315ee64dbcddbf53fe2d88ef9176dd75f7d0a03ecfb8ab8225225e697ce96f988efcf8fe60f196387434d9dcda638e83bfc0972273b48fed4a50fe370ff00d4891f97e24ffd751b092edd80392a9f1f595d58e8357f3dbbdebb2fb72fcebe39fbeeecfbd04b80dee36a9b4d99c6efd94353c61868918d3108ea55911d2058d29e32fbaa7ddc5cfb8b3dcdfe16524a7736f6f52bac6aec87b2afb6b705c06f59c11e33219f655b5dcf8454ffed6c0f8abe594b29a5d4dddd35f6d907492dfba699fe7636fdc135fee0bfd4c24cc80ef601d285ca9a73caf8517a9c310a71c2aededddd7166c09f57e9cf4a0404747a82458716649f69ee37cbde5ffe9c2a9abfd4dea6eb6ffbfb35b9060dd6327ab5ab65d909706b7a9e4cb46e5a6541e4cf24d5964f935465ca94a95ba45160d93ef6f7d29b7d633e5950fd97fa56d8b362d8c2ae6a55f267554d19b140daf32bfbf153a832feb9422985a8953f98a4e5e200891fb69450e290b976717dd79f7cfa36cbd7d72cf74df6dadb2b13d22eedf2781dd92ef616dbaedd58f6f5c8d5b2b77f3d561fbb6c9642d1ce78e2ae1f5f72ee9c007ec88203cd2ba41894b6f555cf18eceed42184103e9c4257fe9ec89db8932ddd0996f9d39a724a6e4ba93f4b3ef6d8755ddcf5f2edcc84a4f4cafa2a3e5137777443767029824b94524cd70594caf17672e4ad79a6653ae5ae6fe5c5393b2998049403276e3bef964d6ffaed31beb2148ab6696b307ad7d34a7bc8331fee9f3fafbd30fa571577974f63956d0352749154b1d839abdcaeb1733bcb72db78b1b86fb2bfd7da6bb32cfbbe70df6cafefb7d033a1cb923f6fb8bb7c1a7386e05029e38b0a0afd59299d4bd38bd8bcdc9f385d010da3870202fee6290575fc973adc45cb6e129654df924f89e694ef50cca5c3132cf214e914f1e33b3440922d9fce4dbf4ef74ca88a2f33d1dd3152ea35fac49f918a20ec0ef4240584b7c3e3e04c20993157aa16dc450a47f33635ffe10db91f1f38ffbd0f8eff727c6efce7f9d8f0f15f6a93f01fd01f798f12508ff2d13dd41f4dbe79541ec0771967d764283e5fc3fee4018c1166cb975c0daacb10cbb6e1aedb6578c5e608cc4a972115b562dc75ff51ee141809fcd5db6558a52607e049c841de4716f2353200fe270b3d4e4efd08f9c6f7641c2f808cfa2e432936978f709fa4ee1e6f6fe4111e47ee795416001553173813a2b12e244319244779030000a1548690077a3d2cea863702576f97e10b6480058d11f8abf8d264eebb0ca3e09ee66d6cb8e7381bee761926e54cc1dfecb20178e872016cba7499009c179adbe51fdb5e81bfd9e5126ac5b8ebbedf9e974a755efc6420df651fbb264339c0d3fc7c8d03bc09f9e7ed4f36e10f90a3bc0700d2d5f0b0cb24d828e3f4f183628c31c6184f32292949fb1a244934c4f8f8a2143d2f38d9bb401e2d5227cb95ec4e64a70279b4d871e6e3cc7f914b0277f9a72607d4edb20f764597078071d1e59eec5f5023f3fc4fde8f93771e95773c8eacf35d16c0b6c947509fa46e1e6f3d5e2e43086b32843b43b8c3c3eab143271f8190c7480c465be7adbc34b9a6e66dd4bc083535b3cb01202133f1307100f149f857c2dfec3200382df876394526ea24e16feadbe51e9c14396e974718d3651e202575e37cd0c3e8e1b88142039b508f7a9ae7dea9a03ebebd910971a8f7501c0ad3649bdce51d9312feaa08b7cb3c1e6254f6c9f931972eefb071464dd6f135b2f73f39e8bbacb3ad4d969b8b3128bba703d3641b32b5cbdeded2c58bd29718268e893a34206335c1dfdc71bbac236b419745e87208d6043cb7cb395b086a72085f23e7fc4f2ec0e3e41c7f23e74765111e47d60f9409f05dceb1b90cc5000678287f88483fc238e9e8e82893f025641f06c84c7ebe8607f2a3a5c02772f44bd857a91c513942bdcd8b40f3dc5b2f13b2d129146d08211a9506f60821e7e402641873e89c6d641f99840ca30e01725cea94701712f28ff7914b781bf9df06d5657d9552b7cbb9ea80bf0a80dbe5d7b2a58b8f4c4206ca2ec665b07bc40f923f36cca872254bd4898f83237b97e879c9aed4651c1b33a2cb37503de8b95db6b19fcb507c7c7e7072cf002e0e6a7b54ced91598f3b95d46d964a75293bd4af42a19e06f76f96673198acfd7644fca5e253b8d8fa692e2fec6e6f43701f93354e213aff245208e4c2327b3e35f2f351379141fcb1f66d4a926f2285be2e003d296a7a29ea8821166694ce1a5ac17766528d80f134e889ec49e524a31aa6d76c01fc678d04257b042ca0b51ca082c44ba1c5ea864a4e3f0822c2ebc07c2d09903936de32f5982e1143938b1bfbba39414fa70337607b168f8ef5f1915c4fef5715f9f659402f0df4761ba05540bdbbfb5305b80c6850cae040474420a2c044d89492bafcca4262fa015b000da3ffe05f9037f85e853450cfa1416b629d1c7faf8275c81572ad00f79cd8b5ed575bd705d4a1ba752de77152e2d0002712a4878bbf4bd9db0c5f8180f49f71ee194c14058941fa720825dd522123dba2fe56cc72943e528c658f557d5917429ef9d4424104fa6e094c147181416bacf0b6b8555b6a29765458b69d9a11069d179a5624aa6a495722c4e2eb6edb2b0edb3b7d9b6592793c5f055ad4bd334ad5a18ce9f3fc9b4ecca6a666536bb19ceb62ccbb2ccd2d6c3fa4b6dfe24ea443762c7d732a49457bbced2d5aa1615d2487fbe67fec6dbf64b6dfb0169f64d883f2e7cd5277bfb37b20d1c8ee66d7297617d5b6766ac9a1a341cde5c309994f0df87d643ed743a65990e7aabeb8e968e8e96e2d1921b19c9997884d5ac565c6b05dab5d628d68575524a5f51ae2cde188f8ee2516675448a4947b5bad157603086611886bab1e930a3a5a4384d3e20a57af294d5ac2e549fbfddc88d6a8862845305555512f6769c28874a49a717c9d94352d7eb2e830d4af287685403e6a287f990b2f43fbc292a7fc6915ffefcd31e3b7a07218ebf6f3f3b8e6cca1e7573e2a287bab9c16167ef4a5fc6ec48b323102612c986a92a33cd859d6938af945856e997bc6a8555b6cd43f2e7e7568c16b6ac9a1f7af531a62f3d87c86da94091c4c0202c9fbe3771a320729bc0ba419c49b5a6c41f0752ab13d1a3bec5b7446f8a11d047dc4044ef6807ccd5ffb0172f4b4a5e941cc90b4e5735aa732324952b55934ac2a95143662643af8c3f85d4a0017620f3514ea267e56ac99c713a207a2c78730758e6d0e03ed4d0e2f5442fce1d60a951190b90e7caf6db4490092bd4f0823fa8e4829c3ef4ff5fce6a42f4cac0df4bcf8464cc9965e01863ec2612d6d34bb8fe8b615bab3fab8a12bc8f5c9f046fe83dbef70b277afed8855595aed14b5082f711ff24d84bf0aff9bd878c1173c1f2adafe40c5275c35bd66412d630849694f2f3f0756537d72a3a05014e10f0e747f15f70ab7a3742637f750355f94a4a5dba402db54a596b4de29bbe53aa5128e8214b13d144d1f34ff544cfdf03d890f9c5b0e5c3f0dd0f03177861cbff70f67cf9f2cadff5f5ad4f6eebb3b6f51f8e6519b176d543d6e70f495165af28f0bd37a386dcecefc38dfd25effd7bfd7529662de6ee1935c4fffa4b0f5dae3fd410b92f6d7da67fd56b7d51b9ed3f5fc2e8535541719b3b16e176d17477f23bc659ab1860df9dd481690499b3aa26c8137fa681e15bb9304cd74b88dcf5bfd63a2bc9559dc6950a70bc4c948e3ccf842b4c9ec0401bfb947b54b06f1b23d0864040de8ed6dfff07bb482995e613f80baf9eb63f99b2c72eec8d0a78e5aa441e992d5fd62c5a556cd2c2209b69ff75d8572630aa7ed1ae4bb0ab2a1c24ed6f2b2f1d117affabfaea11df56ad2c9d84eeaad2a82173573f77a551d517ed4a9aa8c636f08728eac80f6242068e91df754bd004a5c90ae2334e8d023ff6d2eaa21731fb1447c88d5e9cd782f46de5740aa13f67177db069adfe7ca3866c77ecad22387b08c782546afa714e3b5fc87ca1ca55747ab155f96bfcd7c33b495984bac936b9abc10eb05d7f5516d837edb1e7d7d05f0f0e68467fdda95613ceaec5a84bd9337f3ec6b5fde7799ef6f171601830b6d01e422bb6a6e1145ad52c4dd31e4aed09007f807e401ffe9aa601c91f1f03ea646000fde748408e84bbee3d0f2905b4c3401e1b4db0fc48136d0c7270c54a1949fb53fa7120622cd5d002fff5d6d78f5fef95b1871b7ec4aca1f9f3ba3c436168be1cf26c5af353520790528efef75fb73b1b9a69b4faad0aecbbb24c58cbaec5ae8a54c99f52dbb6ec2d8b94dbb66d407b4b6d58fef89498923f15f0b2457eb0e2aed3df7b29280668cb16ec5db4681460ff20e9ef4a385e680cf9c79f6f59b7aa1c8582fc0f921615e3c4b6d9d08a182d56651109817b88481691f38a9842d42e54a99e05384c7221b53dd79e9f702935addf58ef4f5d000442c48958fda0777d1b46ee6e79162fc1dd5d471b46d4a9ae286d1245208417e12cf01e368cac1feac3a969fa23c2b099da1ff6433a1b811afb548a2815c4faaaf5148498fe52d0339dec9fb2b7699e55d70ad999a960952953a68b3a7115020ba10f9a65fb4b27b6bf10b7f24892fa4aac4f808c53d704500d210fa5b9fa2b53c15f3e66c4dad588b52f25c3cb7677f9f43d53c13315dc359e720bf74be812eb2d4705630f3314b09dc1c03d0462ca309c9e72798994164e6ffad44e459f4ca36af4a2ebfa033b03957ddf042e34157d3ea20b81cc3c0ca6e79e9e7ee6e90ba9fe7a9aaf8710d2ba29b5374c600ceb88ecac8361060629dbc3c0bd897bd3b3c069d36f9a85199d653bef299bae7d135054a72e30f884a01c3a60cc5941c41bebadeabcbc04140ab24c19e9310cd6706e8771155777568fd07b58d1670583af84e0b437e2eed6ebbaae58aff40266072f607630da514341b1b0952923b7f5371b71abadb9bd4e6d0c2c25be5bbf7080ba14e7e1bf1dbeac2afb002a239611e99e87c059b763d1726256915f6613e93edfca34c3cc1a328dc8c801998618dba4628819620b104cb144c548ee6049054488913421bc4288a5a32962f4306f589268c0a008b7d86cbde3b0fde368e5555565966559395525bbeaa165d5b7189df5a77f16a4c26e5996cc558e87392bc3ac5b68699f910f87cb84dc5dad2bf3b72324a4da15f2f8756596f541715a9635bfaa2a2d334f4fc86642e49e9047e6af0add29f3778570853c75b31bb66ddb766ddbb6d56db3b66aa373935bdc7ceba12589515828a79c724a09a3124cacc0ee417624ac2884b0a3049a907ad47a208f9d99901f417c4ba9a1f65279d4244621843da7860a42bfb9e1a441023838314e4a679269c54208218410429f16662d66ede4ec09fd5a95fb5b1e71a2ac2aab56abaa2a286755559555ab5511e14c5ab9af555b4eab5955ab56abf20a7ea5616559b55e17d600cfbb989d93e60f0bd19cd13c2177ed866ddbd44429eba729ee13ce39a7432ef037b53cb21ea594525ed100cf23d275d67e73cf39bdf2ceb2e6acaa5a41f841b128494cbab88b5d183666f81ca574469c1c58777777d71046f85083b156021b67430821c4d9fe9002a6d40fd8e3eda43e1d5c08db2bae77c7d66cb14ce796dbdbe9e142a8a263621633995278f372204ffd4c77367794dbca9b6977c7dfdeacbdf6f7b34c639a96f9be7342c8536145afc82b433420a89431b32102a4e2a8f44e164435656648002000000043140000200c08868442c168381c1266557714800b7e8a4280661fc99328885118a48c31c6184200000000006064a6888300b99eb317ce9b79d38f19cad04833b1c8ff42131b0f32e2999964f16c2d046d4001a38a3cc705b6129d10be10723156099b1938d7682629f39bb180e7a4e2d2c460f8679ab9eb21c7e75aa9be2a3f29444e4abc12c4357b7388ca019d6f0536016a4a6b6a2df0c952d5a04727c83bca2fd4a46791d9583fc0bef459748f5aad60cbd08f630ecd1bf3e78deb71fdb9b88a488d7e56a2c31190e808912d857b89b2e5e7d88d13b607671d0055a047d0112ab65471546478f726fce304b44115771db376c2d161300de24a17c947635f8a08372eea69f7d63874235ba36f11928c8102e2d83a0b319f9605352a11ff330506663565ea2b0683e34b8480c03cc22410f2d752dffdc6a6e75f2e6f0acaa709710f641e7ac302d9b58d64e7809009f169525f499a0da11d9b2ebb1ed9804287635a3f1c7fd481be2d9f546e5f1eeed2beb031d6df1e17c534c4397884520f796cefa41de72489ac8634ded1b5de383636fb96fdb0e943039b398741ec865e9bab63873014c78a6c603fdca883ac74969aa6a9d9aa8ecc840eb18fc64f4cf1ca82469952bc2518cb80b12c5570c69b39e85843c18d4e585596eed365c90fe498579799d9993620c0be9121b5367b38a0d0c3cb5acd341f42a2ac1ce50681c68b60529cea113c53de7244aa31abf5f90f9768e2fee773a0046135783a1854059838adfb0205d481ef69461b784496b4b469c571a4a847451729075da4a38519b77ef07792f65f062481d79fcd0e6703ef3f37c09551b96d0539db6e832cb1a875d2e681078783515811b70ad77d8d1c89cf7c22937c662279d179915282dfd73d2a3b7cf2202943bbb2cb2d4b13f2c5c28ea5780ec033a514246f39863c5c889e1318a98d2dafadfde32a76da48dc84f0bcc13cb4493feb4847a22f2efba30b6cc1a396d9d191460f314011d98a13f76eeff5602776c6f393fe2e448e64b5a75daf31342dc435ad5cf831aedcc2d644f924464787187b896bf375023fc83fde3f1ac645db2f41ffbf09793fb3cfa13b42e9ab0613846b824c7fe87e11b8dc976e4e808d1f310cb5cc9e4bd099dc2dd6c06940dc3c1135fe64fd42cc3d414af1711f4c34796904ed35fbdcfa61bfc93bfea10bfce4db3894c6441230c26656b60c249f3234bae73084f2544aa2db933c51a9e337513258dfa1885f5b5bed36ffbbc3a1a7e7016dcbddc085219ad490efb794af754e34e9ad505975b89d5fac7fdd887ab1b4f8c858c755db5901678ca35840a0b4119e2298d90d5393773172fbb46fd5a961e0d688d0cec930db2eca6a999b6e071aff0beb04c9ee8c0c95f3c12e13583607e022c73030038396d0e61a889e38bd82727b4a2abf82ac1534fa47d426f855a50ec8e4e2f12a1be4f82ce814035c0d9b00139bb218e4da797e182b160f42a3f7fb8c20078fba474de297aace375ceb374e32a84ac996179336d731afd90a967f98c835f1e143de1950dd86014171af2ede66eca02362cc1ea2846a090c39b9403360a76b24283074e9a305f78815c42882e18fe63cd3603647af0bcc5c1e49ce8af8cf5e9cc29fb524a9fb6e77d5ad42601d58caeee6a8a032ce33af7fc2af9e3ff3aad83fbeec2a253ae6dd00c5a444f39b125891f9f81be0596e0ca29a5e9e95435912a4390fc43289bf5c651cc768ebcac84453f2e569ce56dca979aa0c914f794878f3a62793b09037c8f0658015a81bdbd83e4578e37efbf969f1f71b770750dbb8f8b92c23d1226c15ce474955c8a92c7717c31513180820ecd1ec0d0ab7877d414dea391fa0aa6571ddb028d2725bdbc5958877aa48b31983b30f7d51d3057e84db622004103688962f0acebc063ea55b806c152345e113a8fd096f542a52b1960f9c9f573a08aa1d73c2656778a9c46df9ef4924c5241a6f9575a5929fa0c09dce942cc689dd8712d33a3dcecd4a6294e70a0b718872d5d055c893ace9e74008cc0ed83dfb78020b32bec9ef40f9312bc424b0cd0772891755d5a5f789cfa31d18a39210624270c0857d85b2d561c35eced9e04186a19499dca5c2f7cee1b4ce2c1aa34269bb43f8872143c18010635beec9acb090f30051de30754d3f0e70bda9b70e090dbf10d02a1c7f87089890d07b41056c2e479760010c25e9d9e62725b9cbd0dce946b56b63a577e44c0c64f7206fdc814cea47594d266ab37e84946bf68585542299070162c63e4509677e0c98a657df302f302e024c32be17f36483ff47a3c53f933550398108b945cc74b75abaa3cbf72c5a99a5a29c1d57a49246667e07d462b05820099f7d848fa7df70dfb4ef5a8f4a5a3dfdeeb72041b424d620f94a2146e79f187527959348c3c09d41d7521253eb3ccdf8b1a7fd8197393eb51e5d3ac04c6f35a66a584b3a33edb06bb365e1d271761049e28a04105ba24588ee70c2501b55507d45dd9361ed1cd26738746092115dbc9e52783e22590543ef18ab2b15ba1038bb0da8329f99b7f505a6ca8c99f0774f1ed00ad4a120a05295abd4408bab8c22a04956d845c58de8fcb3e42d46657d10a96026dee86c581157c78ce6fe1af30ccc2c4209d449ca8ed025b0b2a8828a945d3b900da61609c544e00af4a0bc2fd827862831347c7983c0b6acb92d0a1a6badf0ed93b7fb35a9a54c916bac9767a5bb71088229472fef590d51dcf300154363d3e6f33a833838d8c0c5e05866571441ba315915654d5a51374998c18d2ded47066e692b6ec8aa9c6226f6b9effe8709b402ef81f9251552bc7f7d59498d17df6c8642fa5422ef28569e8909afc4484b1ee3c83149ffc643cf156f24e1662a998da5dbd83b63a15ff86e8dae5e0785f67c39c0daf205cbcbdab1ee3ad37ae23eb915083bcb36e4ab4add7f87fbd8b71946f600a6d4c15037a06bbf43c00b6813888eaf5af34d9372e6578394ba6a64ea6bef3f9acabd656a7ca6f238775e2895965412c414f7b75fc8790ab7a9f3ed5a2c8945523b866653396dcec6bced98392eedef3e3cd05bdec2b655577d1c431e6061be6cf25fa43591aed0a4db74db8fce72deeb19d48a7d12eaf49db8f5f983d23369a8fa23a3231fd638dc21f2d2fe3ec882b6a660085d3bf9810e5573212b061a03d0dd510882336cf1c57474cb50d0b29e912cf67edf09817affeba1cf1349cd885e5bebea78c52b8fabdb94173621213cd04802a45466a12d5c880f21365115fa914a46d68ecbe500aa537b818d82ba52567b1693ff9af1e5e152645a3131b42bbe5bb9eddba2dbcb67c62df50caa35210c1946c439ba983a79b2a947d5481b646ac4e25ffbdf552f94a9a67d78d9012e7c2489e89d861a81362ce9832a7315f1c17cc2154816d4c606d58538f178d0f528d3f70c47c9654b586895304d42c6d77a800d2e0734b0b9d184b89328d207056a4aa52828b35f72b626fe6e626331b166665148dcea3e85f6721e9206d083212db6773841ca4fb34a442cae70e4927d3053187a3761842005ece952c91b224f74399dc3895b2e7cc32079b63a73d256b987a4001df2606a269115481a06b8286947efe218a7940cf896e017c2c8eca100f805dbe6afb6962205fbc03ed798c61f8a42f0d423bf2145f8c70f32b3bae9e46735e195a4327cfd05712b6221138d9cf86a76bae042b4a5960e389bede0d80d5341f6c129fc9318b13308a012c77fc6ad0f0d95853e0a77b262c970e43631ba11465658b176e0e6450d70a08754bbd8b4c17396aa1f0d25ec1fa5d591a37d72fd9eca151a8d4b8801c78ac45912942d8c9e5a4b46f030f055fde15f343d7d1e6fe103e639254b342ecba69e5048ab0d605b88f7d32df24ef3869de4cb0268a0e4fc9b544e651846934d8703235f9d604e4cdfd15e6b4552e15f44265cf4229449ca9430523fd125da087ebbacfce07959863acb9a9f946c4f5b91106167cb1f4aed74661a4d46c48d5da407058b6b02e64568fe1cc45433f51a7a74615a83ca4ff58e4f070796cb4ce4c553b88a59205c1517d1c72e607e47e09a4d009ad335a5bb846d843e41ea5c4f0cb9f1c36de3dad3c67b9fc335a37e9a711222997e0d20c6e13b19f04a08718b8bb8c77da05e25088d777661c588beebaa10ebbf6e49807b008215a6aee5031f8613a160f99f6310140c9b29794b6b8ce91b8d4cff4ade7a970193267470b55853777f6fdd953d74ecff7d8a001f26bca7761041c83f35ce36697f865811ac6b5aca776b035307a75432d9a3b72a17fafe854d44aba7fd5243203faea55ad071e492b27403a554d725bcf3aaa2905dcb9d1bef3cf64685d80fce310de97b92be5bc2c3d55a51d4973fd60e5e9c3600f6cae970c2f58830511fd5ceb40ba50a0e270286e6067a65d21e7638e193afe5b3a99b59f42a9546245ae2dc99773b291b7d85fc537bdc3ccb8c9ce9825ad4f8a18c2eccf386f476d9702e623ba28083251ef712fa083ed3598b4c90182d71612d14465182f8b0fd49048a27a5e091747e47682cd8e6197fe0366e25378ff345d531e34ea3b761aa39b545cab93d7d040c2a1e254e1d9e3a68906140dc237eca1aeba020c6ab7ead9295ba8509164571b5ffb10c1fb6e3aa333140f870f647125b07c5d17a18e801c8aa3d6044ebe3718f2c41daed1568968ca540a3d78733678246244a2b841949669e0d2751322adda0e6a0ab14785bbccd4151e89dc61111695fbd254b1d5a33b146c9742f811e2e30ae5e63b370ac12a2f51aea517b17c23adfd0b20c0bf6911b6dfc23b3709d2f3a59c59f1b6dbf40920d05432013844032d413c07543425033e30ee4551583b62f611913e2e1de56c4cf1f6ed9f5aef7bfe7bbdfff3d3b25de134d3e1bf7e79df8433831ca605975b997e295c38692004043d0c0fda08e9269abd52aad7ae03256eb66053fee125cfabb04131bc56aa00ebe350d23629807ab4e9e93e5afcb42fcb72f5c0c545e2935ef17d650ddca3b1719cc9118fcfd62dfac7664cdfb0dfcf43403b69de86320102014c4fb0391134d6463c8045df4c8f118411a308a2fb4fcb97190a35d6a83c199195ee22dfa342ba317817db3e4c6595828065c4c700e9e3d37fcfc888d7ad85a30108e776347a70386a9281160f82c1faaecabd40d6c02a81b2345c122dc7644cadbc3cf8a23114216312da2e0a3a3274f0d942a73e553cef868a0dab8a4cb1795d54ad5aeea151b603f65af270c2ce2dfba6725056b667f2e2745661415e6a5a26b69037f9527bf9e5da708e688c5be8a6cece7e94ae555095ea2dad49c0f30628ff1c6edc840b1c5a4b3f857b8a573e35de19717efc83796a945825b099d376eac2cb9dcf76a4c687396ad4fe18d260db60a976ab88ef6080b33941433723fb3d94971571a61804115efae603ae575b619e005e72f04722f589b30c64777dcf4d79763fe9c06500464a26aedefd2075f0c007e64fd8b3200c634b369cd22a3dc916e7f2ee4791474a33106c0c8fca1b4d70fa81e42ff989e520362f7b0ea08bc9a0ac1f420e0ed93f06b2a99efaee2893e45452fdb27d1c8df09ae6daf40936a894bd4880d933b9648ddc14084b5a4b3c3845c1b9381b831329ef1445e1b13bf46df20888263197b88666f2c0443e08aa31ef3289e3764efa6ffd91ccfb9abb5e4ceac0a71ff0637368a71e6d315c7260f435dead76b200ee3db34d02c05a8c01a231d4833b4800748787a364938383374a19c602ebffe0e4c8d497e682708440d0c114aa444f93c83e03b2a3ddb3d387319482fc62a35bb93242726aea90882c53aebf01fe8191d93280eb6ca556aa07b20e088b78a880c24bafede68da0b3f9da7e5e91b32f19b32d839d2036f1373512b90e7d20384f1300c8d23835382d70ab7a1b49b048f96c62fce14e5caba34df71d8591580454c4931acc9e1019b6f512848ba03fac040fa15eb0fb372369828e71b5e5763dc6921b32904060ae63f7c2032d783465e2c1ce4d013c10d5c4ca996033c374527560dc0981bf81a2688abda9421d62e30c371a99871544cd46fbb822c2c444b5f10a8096e92f74d12bc56c28eec9fa581c4e97062e0de451bd807edfd68f5b234f880a90b46841b08fc2cc4924204e8eeb1015df476961d99cc607b1cb1271f2c55f1c3d22208306cf99f3bbbdf8c29cf04e3c57cb047346c9273645e07e726be99d0f7206bca2a0ba926f227573628e295b2dbb725d939932429412b5d9868c73579eb1f24e3da71b8a47baa6cff968723b0c330ec95019cf7c1268c658d2975af238653650ca84f80dc5c86969ce1fce802c5f84e63158ce087ac4053b31d11374fccdbcfc6b0a4693293693908683faf26ee7f000ba79551fdcb208adb2be718f16ea802b1845462cadc7be00c8905a4cbdf8b07f2a8b900e0b9807660e760b25fbaf890b772cca97150b3b518616ccb0d02361d86341226fc53a51787348aa1d75771a7de437cca05c38f75608b73c71f1112d81e90b457a3b61544d7a928310091871ba15ce31815084dd0e590bd1d192b1a29bc187623768576eac95178635e9ebe757c92518a368fe143d9bb6920278dc3360568a352359977ccd59112072c3a91857464c4952a885f30ad5cae12a4100173cb1600b552a63dc0883f5422e26cd4ac6bd044d1e63b1ca9c6d1471c60bc40040771e74fb11a4b23f2d4988069c9bd276e7773b437f4f69fdeefae14a5a9924e28a063d97b42fd843e81ae8c34557a988ec6a210719cf8ffdb5a9f9e918d6694e64fccdb915fcf98b62af8b40b79c6cbc2bdaaa6e4fb1c8a957c0efc09c61ba19093b07a1516a96e858fba65a05e7cf16a70f117cb6487704a865c6bf6edd606cb5eb6344be7f72a2ccfe9fae24ec93b1b3e5810146af75e0653b343b2a8897fd398041c9eb9f2f537a96e27446ce9efe98e1bd72439299cfc46d5da6bd520aecb4bbae01212b0c7672a600ea6295f4db58a5b9c363d3ff7349a0317f5986a70e9bc52f0edfadc2a0f61c0596d3c50413f50f56c4e4c51849ef403496a1f22c474d0812a73b586921840095c093351bfd29d4bdaaa840c94052670729b7b40064a28609ce26f3362c4b603d6360be79ec1b67847b69510db70378f9230d845b106f5550753ec23b87c8591766494d8fb0552a5e4a437bc62cea06ad937d72aed82a790a9d03a589ced49829fa30dab9a35e96e6ad6fa1e9f8f9f021fc7ccb921ea6ee43700092038f24a1e337dba370d90b869ff2ae9d307f92d1fb7be35ba88efb60f0bc7b32986fae188ae5c990c747092ac447850645950ff40acf7b93f4210d0090f33b9e946821a1d5c3fa50f20d2e443d8933ba42b6be7d9b8a6d3858467c05e47570f207ffe1546bb581f7fb3e790d838adca144639bbed26a8e629ba878ced081b9aca610b25a2f001626ebc0eef8823620ef356405cb6ef2dda04dcbb9968dfde6a8d82d50ae1b6d153c28bd3d4580ee532e802c3ff26f42013bad61da5c54ab3ba5a6d42ca5e482813c52473c6913d35f3e376ec87015947394d749c4b9c952ec50a00d13668b62656a7cf703b2a5ed0e628dc196e80e35b317e8d1b07edf7cc1f17f6403319c6115b3a28e01c6757dd4509495c6d60b61d83fe3e921ba351caf987b34bbdc5eddadc457f8dc06de9f2a19f8971bb7517f2459166947dcc8d516e5897956f5bb0b02d13686d46bc44459cd770a20d7e7c120ef074212e6a1b6d41d62af94aeb428f4f4659960c88ecabe4ce91cc9744b8caa596e6808e89c9264577dedc235dfc2e66b8ded6c14aac8e166e0a37ecfd4b9b83b12a52256a4322b04359070c7b87ec62bbf0153ae810ff32777f3e6fc552af48fe6da06b8ab2ec8370322dcd5bfced48497122a8462e0d97c7d401267cc8fa43df07e3c35bd7d7db9afe734bae24029ee0f27a69cc7dd5b41dd0904c73dd33898f49ce93ce0985b73cc1db77e66f112ac2db6c3cca9b49dbeb188fbf2c66ce01665839d984c87793e28c1199f2ce136b82f3af6e4de777e1e3600ee06ef1b56497220ecd0edf2ee279fc5bf24ec9dc835c4d55adbac878ad7485e442dc44776bb797ad79ff97aa0b763a72cd57f766af9ff69ebff227ef453661417b9d33c53f39f7265c8db667a99ce3c5bfb46e3df1fc0bf70b88cf2fdb59950ecd9eb1b7d0043be8a7d956d175e6116aed345f9ed2ca638f9d27bf2558aa7d8a7b840ad65f87d4d5c0481553dc9f81ba16ed72fbd7d053a7b5897a6f46d1f94e27a675be71ebd5635f1962c2a6027a97c44fc68488a1c14dc378bd1cc3d1b43757f4ae40b2c9bb5853f0a0efacb75b13c8aa0400672655c46f05012db3faeebfd2e088db1b738af8d0bf1fffeb628fc38a694b0fcb91cc544b7c32a4f60e024dc5540bbfb81024ef48f48392ad571e17da4eb69201c47cf5c37b87df77f9865eabdcb2d44c70049b4faf25d220b5eb80ec617041750e855f4e6687628bcfbb9e2d741d68b61ec99b0101206dbaac3821073092c0e1e00ddc3457048335214471d16b07da708ccd965efd74ae15c5135d172c4d36f9b1be0c47b9698abfe904614cf3a451c92d1ae2b0d5a405c8a86f2ffc54b82689b2b0bc7f06df474055da040295a87235304419a86fc42f93c77d8fa26f1913df8d8885a5ccda66f2a322958d80fea2a472f6a333c8ab66761b5e7d776527224c0185361e0ff97d92a8c89641190a0d6e2bf100e1d733154fefc33f8e0ceb84d06c8d5388c831a512508c03593a29fc360c5332222cb47d3f76395a54c96585b46014d66816d6302c31f03888f08e6fef60e99c347083d686c53e66014b2d7f3aa6a40faa7066cb0941e9fb0fc1e45105d6661cff1df877487dd0405b62e07650c704de170a2c4350780848148270b78d4ee5dbaccfb8a3239655fc7b1f97c5e4d79314af7156063ed6abd8eb567db3d7bc64e0efecb94ee6bd6a8da21c8824d6a8199b6c3d3043b27e8322ccf665126cf77e56be0f99b3e618cc69211fe20144a515b5f5aa9f992b7ffb08b36fd95e7aa3948024d7d424042529062b4fa592370b355b3a743591f9916b06aab3c03760093de1c6d4aa12e17cbded4f4ad9969d1eac0f06d09fb04e4c3868323b3d3b247a144d795a936f5a9fd5ef8e0cdce71d4b68891fe4ae046f192f3a241aaaf4ac6a8c16624679701a439ccd1c58a24fb31045d3f84914bc5aed122851dc2ec9874e6d3c0f0ce4a1a4bc05a9b532161dffb13fe440406735406507259db663d2d1fbed42a564a445eacf62a7cbebe791c0723e718177c0eba5d032e1e7a681ef1293f6f9f9f9fb9e74bbbc24eb88a70576d1a05913d5606564a3214d94198050946bb09dfb8657a872c2274d67b2b9446c74a6e9932d4f91a1ae45108d83d450ee37037e0413f360a6660bfb34fbc11f74b4cb2c08007cb5f64975889cdd83df3af1c046ca98eeee5a6d61757272902b513c50c2660b4522956a22c7ca859b1f2f19563ebcca604d34ca5a279fe6fb14338d2cebaa445b95c36a16132f750a5b38c7119fa504d877dc61f228076e56deb965cd3c1e0a119211cd4046c72f6467375d0697a549ca60617b29d60f5f5492e6d24b1dfc7659ac44e24f69f49758507994ee1cd5c3203c2ef441026c3e04a4e54c4bd04c8b18c8f294d41142f20a1372e27e07c48897ec7b87c69ad28608c46eab274141075611c9d38140c4c60f4567a4a086028eb46c3780ae886344e649a076edea083c1ea3f66a7a9bdb8e21aaeba4947bd3cbc2dde0764b28a744d622873cda3f88b65a454288633935a1addb590eda51d04548d0cfe976f2a8bab00c66f16775034b13ed9e9aa509a3ab4524c5fb58b305782cd345a4eaebd31076fb6fdace4916229def1c7cb8029da8eb939d63f4fad2000152b351edf71249f0b2d17eaa263f137a89ad82c5a94a9a388441bbf20f4f2a40694d54b500853cfb16d1982e2c94ba1e7b2e1c0365cf71c696b4d6c848b5e3240fb7a071f52a9ed934c56d2479fe0abd077eacd60bd4dbf16d451b6842411c9fdd3374184ea5215e4ad16c20da9cff2a005f3036617eeb33b50718bbccb46648ba5e2f6a16914d6f9ad2867f612b81d50cb9e5d63acc04891900a0e311ca91a9ea5d606838622777f96688a41a97c7fd095d36030ea05c5840a13ac48c9a6d45dcea7a1af0349f8981ac4b6e17c616e70d19f8a5e73454c56f498c8f2a29552c826c0066228a5008ad43bcf2395da2980ab23dcd8b49732ffbc7773004e1466c8b189040c3e7f24bcdf8ab8452df50699f1457bd4988ce941aa1e09d2cc8d30c99d8cf6ac6554f2a53f00842131021c14ba6ad314ddd5c912f12d7173401e16f04c0580875b3e2f45851d03f7296ca22ac7a4aefe6e919b5ae5c49f7c0d394b66b17f73ef2ca732b269e4c17324fad68ce4e6d4cf5339f92c9ec33a61afc76a573073b9c661845a32b661e746474c17fa574f194da3a76733f944acb529b7d0255ca7ae62d01b9b7405cf08e6d87f48277b60830e4fc70f893a247a080211ebe3f12e8e3465f4970f8a25adfd4531368b847d81a59200693ab4bf6bba2157ea81f2fa4a4aa8b672282035ff49e7511867a59b150da0cdd51e9ff4f52d4efbfd24b85086ef4994d6f0a495c1493bf36e8bc3a1a818f0cfdee61b623c248884acbfdf6c4500c074121a98e1682b0f7a1b366a72e5ba45101bbe0175e32e8b134bc5ed847435a7d06ce14023d7dcd0bbf2cb716b88404a286476b8419e888ee6beb0df853519b89ca7ff6c0366936caf064b1c5f1b2f8c09457d92ae1a8146142001bc60dfc05023f9127aba0f7a2b8dfe5e64ee53f29c31e3893a12ada442423e190911514cd040f2493563837a0aba541012651739564d2cc57b86a75661aac4a202eda38991f8e126cf74099a4222ed67d22b3e8a06baaac3b294d91379deb6fb5ec77c179b72631cd62460902ac8f34eaff4c40c199c0f6e75e68638724bded50f8aecd1183f4ff6d92455a4009857d2b41778faea65b53a570489eecf07d94b68013c3b296a59ccc39d12e420e02668a4873157e32de3645bfcd77663916e80bb8c92e8751f4a03a071f14efa11c01e42332838c8bd8d3c3aa7f10fa705f2ed537867f7101c6f82257a0b7552da28b4473ce54408706adc18fbbf7049ca5b4b511f4d1bd43438c1d6abb963db66cc378caad73431b1e2de595eda73bcaf5e2ff872fa6313c2bf673621b85ea366e315ca38520d318445b05b7c4585f40dd4beda6ff7847d50b6cc0b575d391bf8f083c291d288568bbccc0da89a001d5038900a4ca35f3978b4dfd4e064cc0945b2532c3e799ce52e36b46ee4cbd6f36b1a1a6da315d56a3b8948e87b6340333117ba62e80db55389517e5eff846210f3b77159c687b3f68bceb817181695fd23fe7470d719566c0c62e5cd69141c97c4f538d56420bda604900f48525179c7d4cd514206515d5722697c14c80674af95f37f6acffa2317ac376533e787db1009c49bb48f6acee3ac2370b2780630aa56862cec984b12d12abff05637521266f7da6ff97781e1c869f7298e320c31c30b296c064aeb5356b6d7d5ffec855bf7eea41e4bf1936b5de845e2975dd16a0dbfd44d16e8354ec76341f35ed6d7f795e4739b9eb7c8a8864d390286deedb7ebf8f97fa790713599f9890a2034044a77dbed0aa84b375589e644650632983e7a4e5d035c56ff29f2ce79181ef32bb67c888c23d85c9c360328cf5126c309aaa97f041f04bdd4c3be3efce04eba510afd55f7e9c2293300cbcf32d1d082dfbb7953b114517b3d2d16fb6f3a4b31295a96fef3606c1468a376fe36ec12cd93771112feb1a81588e040faced0ce8f08f3b3931211b40556d5e4b279831a0c0db6d3f612cb82e252c0487c6a115aa42983a06b41c2e8d05c44b5943163e80b2cfe5e70fbba3aa8633cdf268bc435cc422be60673819c46d75897712e1bf83ae2fe7c282eabc82e3a3588ff984eb3ee7afd448e789758a6f6776c4a27eb335c529d164741b4cd6a2a4c669fb64b7be6a7b83684be167ce376914fbeccbcc322577810241b0aae424b64580d86e1632be5d05d3a6b7ddecf61649b06b3ca4e44b0126fd6d1b87882acc47b88a7f95748efa7480c80c0a2f11a03d19d5e34b9d4aa29e482164df30021f1e272f7972b44aadaf7b9297af02f96a4eaf303a743829c675c4b71d777f6f0f4632914e31edef7a3226fc32af38816dd7e971f5c4a32170517f4941d766176a1014161807efc3a8a23e5e42a1d6eb8b1714835eed4de404eeca1349e3f077e09da66f80edfa9d8b82b15acc897ca200ec1d68948387bfbdc01e44b4e13a768dbb7e3102b7aaf6369f5f280a2d45e14bc35638d994c44c7c71b0006ab9097a1db7ce419150debfe9798ba93364c2dcfb0f909f71855f232360e6be38bc597790cda887e00278f5792fb53cc61773040782e728d0be49021ff68ba4b69f574b9d7d4c6184564d08850dc2788a90d14755538412278b9fc8b340a11ca64ab3edb14d95701c206ae1ee36d5d621e744d4394a99eb0002bc498d67e81faed6dc91c69f8f5089a68c8b01551edd80acf0437a7e2b6936387179b38e1fcc1d4ea94515abe0d3fded7b171ba5a72fea1fe1a1201947383f525cd41639ef787c5bcd22bff0982949d6ea7c152a990b94ba60c4fa0ea054102d1ebcae1d0da2af52b94424e229e2a69ccef43a11ce71ce7f8b19e05eeb1e03438afff407d122c93d430d8d15a5dc3c8d269fe104ffa09d0c7d6a1640ffd7aadcba9e5897d966f91efd580ee2a3757ea53955a5509b3d65bae22210e0c0bf9520f11295a53a4f573197218f5cb167b5cbc71b8ea2a3c3e3103dea21c81f6c0237150b7b75db481321fa39c116886ef957f7b328ae5f74bbddca7b6f5344fd09b1db1c69f820d503f49e6a7cb8810ea6ad87ff290511670a4738b6a0203b9eecdb116d4d80646f747c8d97ba311c0764581fdf98ac28c76210d4593d81b3d23be4a37ddbddee67e5470bacff2761551f00ef5d47aca184cbcecf6296137e0e37df8b38bb9187a6345336572a1cc34096771ae6a8698a68e5d18ae3d965cb178f347f606939b260e2acede0644bbee10189ef89abe5b0d7fca0d4020ee4dc8338d09b4d6e17ed2aa611683e6f5420f1da711cc5f5c9c86423e28253eda9832dd8db6233bd6e4e7c468f6cd7c1c03f8d53889e816f44629373553a1cdab5fdc48851c0d0b5c778784fa7e5c85a3e7e72d91815f6ae51423bb985ba596b1dd28ea32d9a9d344300bf54e75bd76bcc1d3762b57bd9ea6b90afc445764abd8fa4f3adeac6a892ccc91b7ae8b56ef599b0df8bb4e384470be7ca10f866194b55b90d12451406af1d447b14c8762f36b13e5ed937500a9463462e16ee2be628df16d1ff7855a8274010fc8e577c65a7e8cd6f2b66a4a2c848b5b6ef99ca7967ad81ebbb46ac16fffb7b235b008b1f89e20e396955e050c60086021833c3fce2d4e36b95a4d8faa574d76c6fd147a1e04702d3da269938fbc92185de559ee53dd0db0fb96eac950f01b39454317cf454fbc75ebd1d7190f5bdb394bf997386fe177aabb6f60b4d9a5b99d464f8c8b10fadd7fd029483e1562dd22da7874694d392103f92dd7ddbd4d89e804e6133495d48b0a240c97b9978362fcdb18ceeb8f39c64d4bfe4c58e6f7c7b69d73ca406102966e160743cd8be15649d6408e4aef42162eac6fffc0de44425cf5debe7de5534a3154e50e3a6a789d965242217c8b464480a4ac41050e96404913441f9b13611192773423fafdbaf6885252aa3b019bf35f325d3a5ee30295fa524e52ceb100b5df4bdc087e6ee439b2b2186581e0c7049abbd701e89fe00bda5c7c2795d30026b24a464b5e654bdb507e9c9c482a6654e759c998c8206b71f0a9627f59b0344f532792b55cb50f4f796c2b345b33940be328a27e1bccd1298d3ea569848652542a314acd926cc951e4229d1ddc4b2f728c58248f6258b153986ab68417fb008fd6d3a58e3a8d47249d5b055cac118afd30adba1a9e04107d04b5534c5cb77565ae04958ad52a709af8af0cff5ee8b715ce97c08f821627b17537d6008684f31de2a6c09c05655ed87d315a36394669f10dfb07d09f1008fd87721af0aaec924d82c8d246d20ef3f158aea12687d5c5f4d6cc1e4ecfab57b42e610cf870a9433781468f94fe50171b35da3fa1cf93e5a3ab3e8faebddfb1d566becaa841e0980581981fa32c9f8e6db4dd169d66052cb9d4925373727953a7fb8f19b14d0bbe703c93588e3ff35054398b27302b087d03fae6d92bcd29596840ce942a8edab1fcf4be58f3e3db8b52d91b243a8620390ae971908242bf7fbd5360faeb19c70baca3e96f3a8497acc08cf6df4992888edc6c67244a065169c118df4dcc6be1d44068c39e26693fb64f8df61f56c6c079e551f4ba93fe60842be5f61e015a21e43884f6caee37f962d3540c8d0bba43112d012f6d567f98d9fccdf602d123a249270ce2f59eae36b2a1f6bfcfbca9d9f7f44b13f70612366125fd13472b1a63708cd7477e3eea693d7e4eab06f3b971e2e519b2220189c406680668f9e4be10558ff819b58bc65fdc7587de86440f1623c3bc5baee3efed42207283b67a2e2f0f4f705de34ffdcff4fc5903d9aa358c3af4ded11743fbe071db7bd98bb9ce40f9d18300be2af0bc2341437e4b240728bfc42d66fea9e9ca77024c2bb671dd142047885293192ff78f48fa582763f3428cab6d6fe9770e90833b1480c914f88d0d77ed73aa3cabd85e101a9d2e8f109ef134893b4c840c15c06298c97d590831b28be4cf20710f89d3bbb012ac1459616d50b2b4c221b7f363283ddaecc9690e66a419c52fd5e84c228681300844ba7925655bf98d010006feb986361864ac1cbedc63a4139ad3a031f8181a0981e6a182dc7ab6cff79496b8aa4aaecb2b209f2ade21197413dbe7c7fb9a5eff83807657af64416300935704677b44408a6415d523fd027dcdee8a19bf969c0cebb8a776348c7bb627022a84d873bda054c5a23c1ecf3224ab2719fbb9740e6fda9626cf229d4ee323809d66c30e1fc9a3bb683c0494ef7f95fb2b060258a7218056d589be600bd8fe28a151581751915c782674e6ffb623294023b30bfe1d5f9ed3ea15c0d94fe2527148a4b1fc5458522480363b82d0aa9334a239eaebffa5eee83c0175c09fadf69180ebbda91cfb6d3c67effd3a7db74d6f53fac42699e8ed4024b1e85e3ec528ce53c772d9e483b249c64757696a3a389ab7562028a671ec60ec8329305ec4a2456d9eed294f0146aece6a59b79713c3db73ea49bcf0722ff33eb034147ffc5a175387e5032a4451d9947ed8652fc01f44e7f967de58c7c94f525712e92286d57397a9b19f63419089c836b68ae9e0004c2eda55dd4c82c4859d3ece3e6ade01a78b614ac3fa4ce12fefb52a0f552221b57a08184f021f71456ce7cb3371d6d94cb69e04f2ade483c7091360807caeff8e204a482e4181d2011410c78ebbeff126703844f5ad32e4aeca8b4eb4e3f305b8106bda8bc873773b81e7941168834604a42571596ea245852fab2bb293819247f52353bd9ab2450510f710eb540cfee3b50952eac8f0ccd3ded4089d4e2603691e8658832932946beb7c4a02d4db161cb8752858a2ef236c78f807a5cebc38b05435b6b3c5616304469a9c9fd245612bdd066308232e09a94485708497472ef2498e0e875d6707a68e35ab7f4a22633cd4b8f69f1128ffdca5c0624375e6e8003c0191e48d08f0cb659b0d08f7ab0950aa1e20c897c561a85630a3e2b18f8d37bb1f2a756ff8c927198d2d24584099fbbdaabfaac20274306087bc629269af20666dd7f3524c1bdfb8a1e49541d1df30b53459ce64e6cff92050837fd4fd93cab47c80e3b431b941267eb4cec6720534528d3628a6360f53144610fc4aed0fe1f931a7ecc9a39c2cb7ca603651d14c1c2aca9bf0c61069486d708ae2882f931f39ce619a5e70cc87e6368cf38ed97131c1145c8492ddef5676bd56a0cf659716638c7e7e8df1f1ea5047a45f8e5bb1b6045085504f13f518d410c7892e1a36909c9034fbaf63db1e0896337418c11c686d71d142bf4b445ceea2daaa91fc95fa69610f6a1950f02ac5db4582b9e472fc78f5eb896880b4a74e762342b0145927d6b5f9a6e43c6683226958b02e0fbbec4f0f3c96353da961fcfd1c39f9c368c2b0cc4797cca794037f9bc06da7db7bac34d203a9c06788649db16d1bff2077ecc6220bca84de9b2c183159f0ee2b5280ba525bfff3df986157965284d1890b3287ddbc664736a5ca7eb25e2afee50a940fb7e3a882586f6677914fa48ed865154753c7c524d63b785d374d4f53bac436b9c1760f55723be6d3f9d46604cdf32bf76160427b338587d8c0f46e06d367530f2ab4bf0b2e69b446f177bc75da7185d47f5dcf6ddee7350275e65fe0d8470bc5623a3ad6a0d0902bc21b06dd8e2a3abf905cd410de32925bc716a3d86267c4c04115a21a0d20dbaa7d3e96df04d8c7598f0e8fa15d2b742657e1b6fcd4fe14d2fc39f9aa6219ded46e4d3fd876e02e4aa7e41f148cb7181b6168123b44401b1188c7ebe7271d44ecf7c42c8b6eb529970e9557c202b4a553411367ddc656f85a06cb8214a4b20f7e934128af6dba4fcb8c23dd2a5bb15385262aee30602d13390e5f7af58d0bdb01366b3675cdde503164b9a75975b1d96addf1bf02bf2be712c259b7f3c498e77cf011663fe9e65bc98eed0a458490d2e621fe1cd87008a190b09c2f50e68e5167de078331734608aa5a3efe994d0b832370f99bf3e3a67a894707f98a2faec0dd8cd48a24d98f059a23774f793bd33bb9f79972a0059bb340a6489185a0db6c74e76dfc0e08e0621e56143b0e0f1a6c2298c1d76a3114510528f2e08d901b68d07772067170a05718fde10d2476743bc06d8e34a317ab2f4bfa927a1507e1ea18ac89de1e33d2c3f6da054d2c3ffe0291dda8851f1019d864128ced7bada9239d9f0afcd9b753e2c442eca4bd223bdcc490b42dee88b6f63edf4c94a4505bf8da54c080402746b217832c831e3d587e0256be3a82a3a9c2906f22298e1e395d5cb4131c5ba91657135918464e1e18386f3cac20591d5f9b8d1f0e89904fd163f3fcb631a1cd77bc082e6599a3f2a4f4c8e26954c7600a3c504fc05f7d167290b1774faaf86c05394b553805b7c4d70865c09230a43aafecfb1272fd4284419521b5319b03a598629a005e26c8fae3a9eeea510c3d761b0f53cfe1b4061d42431f48c474b70475b4abff4b99820163596fb38a4d8af197ba6832b606c1c939608cf1db118e3cea5670e4d1e0fb2471cdae58a626f4038a684686c68ae64a9f2bd74759f0f6f91ae0add030864421f0afc8def56f58f3131ebb02e99bd18327ceb0c3e7ca22c08296a5318ba31a0868a3e80bd4ef9ef8f5a63f2951efc71bce656b1f891b766f0adf619698aff31d5d11f02ce4e93022296c7abba33da3e83aecd24d791d24642ce0f88fb6e8c8286ffb887d22452b4fc262d5a6e915c72cd94c424cc98771194ba74587d8984f42dd0f5d2cc1a7e4b32d7ab0893de63ba3a20e54b266352b800dc2de80fbdf33598a68cb54ab9f38722c78ae0b425ea6ff031fd51e7fd0b27dab233ebe41e1b892f606ceabe49ba1cbc6edc9d2fb98f7b57e78297d3d6e086af4466bedacb4ca09776a12ec2b6949265a49bd4b6ddce37d9bb20aaf44b7e1284f9c4f5276ff8aacb3453fc2d2ba51c9a8e0c50e4fdc278ea5d839140e527de30726e8089e3c0c5c9f7d4b3887ecc5618b53da00b078a5e2bcb0c50884356eeb5594a1c595c8f74fcce6632446fab8dbd306c6d2aa59f99a01a35126919bcae6cd7a825a2cda0b3c2e542f41155747998f13e54c38f75d9e281205c4796e2ed31a08154c99653bafaf9d7502c69dbd0d3c3a740f3ddcd3b3e5f2786ce0c42f10d8e951c2d6e255c02157a94093cf4c4619b6651c44f3046cd0a2bd31ce0bd40f8cb2151dab3e13ff7acf1d2c3b82198abfbb861422461d3066cafbfe77cc489a52d3981f62a5c766ff6c2e29f3349c48c1c0ce748e2255e85d70c4161cad2c8acd3528889158ca05248b5e30d933badb774cc585c0a187a4b5424c9b15a322e0c5a6320ddd445eab8881fc7e34a7d751bf20a0a4f8fa6c05b55ac0e7eba2cfea298f5b3939383c24ead1a2c83bb5346958a5fce57c0e299b4fa4fa5601c06b96cba86185dd0bc115e215c7c7c9fc1d78d242f5cba099283619e7cf8aff8ee5f82ddcbbca6d33b869528fa4e3e598ca5d14b6251ae4ee0dfdab080d825abd6d08b91c28cc34cad010a3e6867c87c0cd14d00f2546d75e027765f88ac9e3dbde2858920ec6c6575ea103006f19955c3ac3cb5a8d41d33b8475bf17f05853d1b8c09a1b25784a66307fe7289388ab84bc438a46262f1aece39e3ca57bb1b2abf550d063334a1546812ea9d6c8a205e0e45b6ed2f6e115819a419c9578b1f2d1afe888c4b79b666937ec56d2b3144bd26adf100e41172bdaa1eedb2df12ad8006a66659574c006c344702e24b54fe09a3fd7d2a8a87ee3c55161467c80e26554455d2a0f0e4a4910c4bdecca2485707658734a6fd64483de1a901caa2984be1d108d66a9b5d04f6c2326b6cf8511ffd7a049959e3383604068a3e375f950850e356f5d2573e5f77a4ba2c04d04ea1b20eda36b88ea044f3706abbd37840b5f3787ef14094179129b54c283393fac80db3fd317a2b8f553f6459a7419d8b158589f04c5c70260255a1425be6a2de5dacd88961fd5ce8f49f278627b4831eeb3a6d735688b7a34124f935e03c60714db3ae3fcfdad8c8dc6ba4ac3cb206fbb7c4cd9310bfc0786f1b5e815b5360c49ee7e8d26f933823f05675343d7b9d53e90602b2aac9034a94c55c2e3210a6a9b6344e6d2ee78dc77e31fe38ce639f862654488cf0bb548eb32fc4be9631583c6440edc3327843cd80c96d27cca7cce4094cb60e3a701f845b02e9c91fd189dd9ea29c9e1e832d15084b59fb9bb9b213a02b70cd81c4328748b9a8893cd0bb1f845845ee25b9c1854f0166512cad266bf874687e298b8f42785c2ea1014d25e3b6565a9116941be22b8cf919327970bd956cdcd3dfd226c80e573079116ca1b223adca1264ab3962ddb96d0693942c0f33dedb2c9a662b9e3d0577c2f5b220892cf439be7c91b9fc89c270bd4f781bda9c1b97a8d5e650afa681abd0bbbd8c4c49641c0912a1a558a51243ff8a13fd7a1e7d0090ecca7eca19726b082de1cbf65a747b14a77889e1e998d769fa068f6341dfc433f85a41a086898f67007a9579ba3c29b5a899892221078faae6fcea923cf067a7d4484c1e2a412fd7ca898cb1eac519c3e00cbd8721b4ebb99dee40857a36c4db9ca470f830d13b5893788356ad0da70be61b0cee21197c6e74555fb5dfda90320a4284ab13daf28b1517552f50773421aaea469b2233b54bb2e7a78f526cfcc56c4d6040394b9ff8fdd1640d3b2bdfa797e66c22d2b29a155a2c25037ca0961dde875ee5f547602c66c609e8f6e53138cf986d80c78d0a5e8117ac743617797dd99970920daf81ab550f6e0a4f1caa0fbe1ac3f52733169a8c3a4bb8d684958a8c5029be4e821443a8f4145a04993ac4e20948642a2f35b6bd54d477f704a8ff3c7417b142b2b2e8591a6c0cec5c2de996ccb2c042d81e137e5b8c945e4cc536e678b11cd5c32be80e86d2f1ef04c897dca657ab54e4e4defdc425742c0dfef9383cb34c07b4ee36c5bdbeea8b84b0d25f58a3593b61d9a80eac846d89e50d9518ceec09ebfe11ac102547149125790c512d72ad759a36de382e7843f62758ea980317358daccb191184678632b5b5f1bac28e31ba1ac35605bdecbd9940ef1c7f252e73736057c43dc3cf543f284a4252f5fec770561443c5da8fe24e2481dca7fd0d38770cdc8299ea63a3066033626d8ad96b5393541a5b873aab6b5d53f8e911d02469ffa36e8c19df658716d0bf2500f3513811b7613eeb49488d02bb490858e2e017b17c4156be46083bb2b4e77d57cd1a716d0c249cc14ee368cc830c5698020ba66d958a59d0c1ace285f2072852158d12a856e9f31df085ba114c9a721e81447a0e2b93744e94117352b29283f8b541a1bd92f38221b339b3cefe0855819315b104d4cce7cc5881ba176991c26f5b3fb845416b30e7a3b2bdc139da18904c0161c42ee339cddaed9e88933bbf4c101925da4cad0ff333ee312e0decd57242d5f2e6655aa4b6afbe36b2ac9914e7bec2dbe0f8cc107113b5576f3c8a4ff7431110e59b26352e81c378118fbd9f70c1da569b62c64c8c1fe47da2deb45d10192a234d5089fc44406ad98596d915e87864573f2ff3f8484888c8fc5bda034b998a2b71450891b70c2257aff1a81f5ccc61aed5099702ec7b60f12985228763492c18322534ab3afb11105febb0a3f394a5b1e19540ec401127a76b16707273e39e80888231e373ec35a71c711626beb21d2bb07e413926454ad3d4cd8dc9381fff122a73fdb05d54b0b02e4aacf22321e2ff19a7e6bb9015f6293708a953d7c16b245a55e17c946cf08476fe4a0899f6dab3c14f7a6b284cea90375b9f3b7724dc781498297a398cbe274eebb29077002e863af2cba0c82e31562ac05ad5dc2c86331251ed000a1c830984e3c777df04c6dc178ad935e7683a4ad43294d01f6edb9e1797fa15c9191f88f6185992dec6ba7ff961be0c6400014790b17d50850406bcb019b0d0eb628f40a3b4366d68d7fb4d0cc4aa706bfc3c8f4030915b645af3957f1b469189de2cecb86f5236e225db0696937b7d3d56216548358530a994fa7fdf2276ecbebdcc42493b4fcd2fa5c71d9d6f166aa0b225b37e8031f67da4fc222164e2ba52deba42aba3566fe4a6105214376d70d1751f284ca131d213cd879792fd7ff1f2e9b1aa9f896b8924ef7a8e45dcd8fd97b9e92032850cbc3ff76d330dc40b45d46bb3543bf69f051c598e303b568a0e1e53a2c5542e8ca32f4336011e36a9805ea5fd446744a4e5ea5f55bb7a773899e43ea13aaedc9b53bc1a1073c3fa01dd01da8830228726146c8de594f386a4c920009602807bce027bbab820c95335269406bf82e703fac04638089b38fb446ea734d1d178fde7f1c4e940d2b52a8e68145445cc38fd55968e9fa3d8feb9b676d080750fa7b698947971088f12aad99ddcf41f1a5c93ab9ac679edfe8850c6ea425ac39c72ce2b5b814bb3adfb2f347c3e54fe9adccb4411f083338eddfde64ba2012d45a5058ff1255163dd71e4fa4ae4da46faaba14297ea9efd2e6baa41a1edb9508e3b67e3bc6e8975c0a29a2fb28fba630cad14773154d2b1abba50cbf7ea2108d8e0a8ed1593cb19c506dcb42ee260114e6bdf8821146933cf7f5e3272b13dafda40c0169a98218d85eb79672bb1b2e1cd0853262e944ebd01d21602514a05e342248d4b08e22eb43f8546b4dc430cf8a8450393ecb1a31b9d0dd8a2a61da570f94897f5beba7a462c9f5367805e043f235782e7e537c70eb4531f3d3c3f1a39be4fdaed6ead26b1ed761e539c2230655b14eebc7541b234a14370994e7d6c78af4d41ba467807ce2218c4d82fc1087a332d35d99b1176ef3696835e2e40cb4c6b7ebe60edb414cc331e8be095a3ded7e6bf81c5d0dcedda76d04c2aa7a1a0688db4fa6aa98f3c45d61210d974c0046fcb5d11904094c6700b73d1c48cc20eef16ca8dbbc0181e88d532d18ce1a2f74b5296c1c58ce32491535290fe453d41413d9449d0cc5fcaa79b88d8423569cccfbafa3f502d44b056b689911612580699422ccc95022fd7ab5919c285284bfecbff3a04e50b7614d971b542b4c4dff36a5de5de251090899c8a99b8b2ae10121dc2224a5ae9e0e84338545802c060681e0ce5893465ee1d2f38a883f85865d4b43c2a240dde6857ed476803c60dbf578d8dd1fd2f32172a9d02b3f94c95ae5f2cdf2b065452615b8d343d91a915516b930730a58147428dfa48064e4a99fe91d550bdd03812a92333e4b3a78649d1f69b484fcca9a5371c6367682e864194a4ca01d90eb79ceb9a35e34e9a58adbc528268d2e1580fc197a89b6b03086588fd187cc073898f437bbc669cb128e7b7cdfff8544cf517f2b833cbe1233a9aedc78a7b9f446d3530d1decceb6e3c1e8f5d6419cf025d289d75badd0f3e18987558f50b526cafbaf35a6d913aea65b16db180a0cde4c0ba6b463730267efd591483f515730fdd8c224950870f1049d3a0e0f1a4c4d2efc3f125466c1b318c394d0f134d919c289fb21801438fb85ee4eac5a561d20cddb2c176733a4b502370d1ea802202948f44349da347a7280f466c96c5242756b710a85d2e88f0251ef70031e3e85342a0a960badb1a693dedda6da76e02d2c0993235a9367a14e38902903663f6b3bc7033108de9c170f68418c40a3f3b9c90254f7f4372858715776d3905f7e2cc4db9dc83f2c9242f4d73e5cca68273ea8a5e9048cfb50091944f7987974b0d8d9a89fa6c8e81456c4f5e1240e889f36a26f526b753ff549a7b483c486407d719eee4855cf8e3d6da9b7c4ad92e2cac7612ef1ff41f5264711a8a797d6d424921319638aa1652a77a4c109a607182f9a0b22b2baff5bde75c20b990697cd60068bedf5463181ca2f820fba50599e12eaa09f97cea7f7768f1526c4dd39c5158167182c1fe9b82373865a29ae35e1d76956ba68ee21428da18121c268ddc9d38a2364d695a13250d139ac47f5619fb8afcf04fda0ad034cd5971e1d06038e18f431e4c07c3953f792d40e26c10cdfa523be712bbb263cf089c353df708a60d1e13ca5ad964ddc07e979b15b208471676a0bccce2238b2d5e6710a175d31eec4688a80c66056ff03fcd10fc64244551556fc2059a7c5058d4124fd39a2cb493a13309f1e49d3200f6e0436e0fca00fab147443b7fde8158bff75a24eb7c0acfb4cd047acbab1735b61a0eb6d61fd81f9e606a0cbf94a624f30649adacf1c742fafc048c25c8e1c08543b105bd7f576b6d38834673d34abd69007f76c311c4e902bf80464f914ae5acea4a4fdf20c1a67a41e6153e3c87ce422ad85c3595663c108bbac3323f791d275387bcfab21666c357078436d9a9f9ed2208320f0cb6322c32125ea1673579a3eaa76a8f0e726f9bf2c0bea7abf25aeef491fe22e674ecbce9a7831453771a1614cb67187d419a1ecbf8ffb5c108b085d29867d7e9846d4eb6653d4d99dffe46352533ea85e793fd39386e312ce8fb5cfda468903db37e52c3f3281d889acd0f2df8afcd19bc29b4d8aec5f156941432d679804700c38d9c07941fd17d5b43139f192effe95247eba61647b77caac4fa21584ef124b0bc24dbcac1adb18bbbe264dabaf339650dfd09f5c0f647915c15be98b165a8007e345274b0ae5a72883141e56722762750415c47d6f36ce0b0da24ceb7274ca6e1be5ce260322b2a698ba737bf7050fbebabf344a09f1cbdce722e7f566af567dccb030fcd51c9f667ce744f900b22ff84fbd3e87dac73e0035517eb2668a14726758cbd9710c944b9d51502442be1db150591dbe1b078e3d7dc020030b32feeb27c281600c928b3a36fb04ed2d077d4dab56e97e9c2707a14553b158d1692640ee8345c3fb2fea77d25e4a10ff8c2cf10df133e888d6e9f23f14d0aaa2bb7731cd578bc5bf541232736022dd9d0c7530b13059465556cdd0e5a4fcbf2bb92021e21ce9f4da86dc3a93f3eaca39dec791e11a7e6ca4f37594f36b1619221e90b7df84ddc509b920a610b61095788677c95f09b4867f988e7e3b10405f19ec6f21aa120c26cba98f05faa090a50d14288d5c6542fedc914db46f093dd0df6c61bdcfc5dea94ec72e647af7951e8e884701024296417074d71daf1f269bb7f6f077f76a3bd82f272c6849719cf20ef8b0bf9bbf56f7ce92ca2c17f0a217082387668bcfb0cf272312155d8a28a45d3fc9edd1e733fdfe1168a96657cce44b4f891be357f75dc98f826b4d4590925efaac589ded1edde8a25c4021928b612cbfd7c1bf46a7ac8f8813818112eee90017cd8a2d46436b6ff39e169a8869f69773f653ecc2032f57f0725745c9b986ee452a7f064284628f32599d3a88c429bd34edd4a489b5334f1f4dcfea84badfdf5311ed0cfb48d2bf4a9535b3c4a5b648e8085896783845bcd0f53bb3eee625082e383883a4d0ea9b3912c088eebde91def124e4cc76f808787156a62fd041cccd82c79c2d1ba2401661d22787125542e19655782b635b1a6f99cf2503d7f5fda5ea6e2a73b6bd5d291fd5e916418aa11fa78c2c68cb6036805224e562df0ac5ea32d3972450f5bddde9f68b7087328f846fb8b6f81b2ffc41fa3e1ff6e3e52a2ba4fc56eb8904b832a4dd51a31799e4aed56acde29f080e65f6388dafc04e0929ef018234fe9183c41b0d41694070ee547e18e77758a574b98518e1b5fc037d11a307ffc2af06c03dd84d68cafd7129c1dc855b0d829fc163d15bfa82fb13a929e3223e52b0a8b46e29e0a57618064d62d5bb301258ff190132728490fbb4aa5a45e741eead75352ad2bce7dcce531e20b9e5cd2c3390f1d2517139fff5d6b422e383ce9457571c8a1732fc160e02aa97816230adae105acac57345bb50959dc3f1635194c467068c4c05d4aee649594727181f8d8492e73862f5cd477f5e1823532ea548c301e85d372a72c968620546494e902e25d7922ba2029b7177cb8296b58e8dfcd16662e0d878c5b33c769df460822a6dc6e9a63612c2d439aee9bcb48bd332f99d1df7314a01f25e35cde0d85e89150e2039b0ad69fda9642c5095cc09f7d8ed98bd01caaac4bdbdb18e4c8deb0ad1b632198053546057cacdeee19b503e455d424c111852c65b1cd87dc726b9c5e6218ce5340d446150fd3e2317479120f978ee9bf60420033c040dc3d667e92885c6ddf33763c4dd15164c7803158194ce2194e88e94be3548225ddc1bf29625cc0eaf498d97ea822cf1dd7e31e67ba4d51a94dc327d85c4cfbf17340b8d99b73248d3c3cdc82442b338271a0fa01897b4489cc5a2defc5b8bcc00842c9cb252a60a03588e1294016b3da55fe866df3509cc94dccf0a410ce99e40afa883971bef29944c619217975196ac4a78166343d899bc0e76f87842695320178999c0ebd8a241f39fefafc583f2255973ce4c27776c36dd1bd7d78d1105686950561e9dca5d172ef96908c6ad7ec6f563fe314eead35309ccc54f983a0b06aa39f68ff588a982c3e1b23b03d4a7732a8324e2ee50ff43f98b3158373e9b470794c9b9bc1704340c05ed490fd03050e0a1f91a2d4831d4db04ae16db5b0117f6e5d81a463f52230ff8bf52e6797281089b4015a381fcdf019783c291b55965fee711f1437089a28d338722e070e8e3e71909b1196ace829e45fad7365dd8270f4d4e6a327725a1635b33b8c4a6734da08322cd7397cc6749342883c7ff136f0932286e41a5120fb12c2d1d18b23500c608bda0029e41bc0d6a038452a12d34641c28c6d42193ba12bebea464eb1fc5a00ba6df921f415ada821f2c65d87a254dda1f4a0fb3c9448e3e8fc4fa2e8f39ad8d20a91f7bb65f7c4ef62417feb761913fd68860b20978da8e4133a3ceb95e2388ad1a5bd10388a795d9ae8ed3cb979763f42b912a411cbaf22842607bd27417fb7a200e9f61133d1b4402183267f99bc0369f42580d9e90819d762e5d5b5ad0182cc1acd4f243f5fa1de20bcb921d5845667c453ad3649be0316e54d17adc98bea1bd4fc46a303c2ad18d1a81f721512be64fbadd6ae367c52d6c91f663cbc41ff79aef786ca552ba820e01280617a83059db9430f2cf0e9550dbc890f0af1309cead5e0f209b0a329b5f315a0c8df0408780d40f1c876dd6d7d973ad67818a0734da102ac34aea624e3bd6a54815e895cfe6f32a9f460d07b186c59cbe7b0ffa7b91aad31ba977733b4f2fc3bdb758fcb9c31eda20f69c346368bf1713100dad1932d0cbea5cd8ec141e68b5dd5e8c5d1205eb830dc4a78fabc0b80ab1698ce5fbc7e96abbb2a629b74db6488ff4559050c79b54da564e5305e21b10f799cf54b5e347b432ac60021ba63e53d0ada9e384dc2cac71afc203e2f180773c5a510030765143a7319a2bcd86513238227c10ab23ad11fa8f5628e27a555d548309017f61a685ba17ea7f5add012607a1e9ba3ce8f4999a6f12526628f7ae8ce0e709867e7c550d026ba9728a9d71a31cc110cc202d9dd4a61f091cb7852730fcb24b491e079198a4913b26c2b0f32deba055cbaba8b184b8f4f5a90900e8942e464ae1e00b52ac29f3e40b7704d9d074ed8dc368e08d46954a53ce64e0f3d99daeecf4af88acbfccb9a7441958494d18cd0e3f3f2bb704815b1c595937852a7a26c058665297d195f41b1cf3fa17a3e7f66213741450116e043025b6a56c1fb837c641b00cfc259b17f47b367be1fb6949582a0a0f8631f2bb1fa63f3b6f089b3fae8acf289451ec8bc2f7c832b5c29e415efe905d3aa3527b5761b4473b480e00e244d990100e3e88632491ee5d7bbdfcd69adc481a15098e42cf36694f5efe0882b005c5a41903f0f7f905296c1d3787e00282f164c2aaab966a788770263f095adfb748fc416d63043e45fe3aebf159352364de4c8e6275039b1d6a2e124280a03f5e6d26529d855f7aec10f8ce40afa49054606028dc465c9af853b3145dd61d875a0958a521a18a55f6d286e60d160b83f2cdc27b4235e650714ad9c7d00e0c347e8071a1927b880596e745354b28e82ffacfffc3a59a006e236586cbc74f1fe1d3cbece560e7ed8fd1fbf98f0313d3c1c0d9d34115e38d07e831a8f87f01b695cfa39ec8c3ca4908de6abad71b9e3b9c9c24e05358589708d413934ab1bac654ed9e05c96f3ee89b8070c022d6d61a6f7c55592e8c7565323c1bb0fc3e30781b485090d0757decc9ac2b3d09a1894aa213b74d18b588cf2f935528e8053a94f940fed7a03042a109eb702513fd9b57d467c1a27f27d9586d09c337e34fff214cd8cdc6449dc220d581ae25e2990d8e407a66026338b64a1842d57c292d466e305ecbb87580584136b28b3b8b95f573e723498e2a4b4313e0fc3754fc9b31bdbe7e1237f30aba8b6c72b66f3cd4bcbe2e01ed602c88bf20da00410fee28c37def869f5d06563cb232bd8d245f06db57deed11d1f59849f6b2ec8cb075e4b9c76c48b8ed47a1818884d306f2734aa8389c5cd28fa0dde97c13cec3c18cfad30cccb11ed9e213c79b95124ff1297b308cde9ab4ca097a0fad72e480b95d06784e572752ec1d31e0297326dad5725a8c0de32ccb4ba5d6f2af6f0e0aad26e0df52a25eb01b054c8e62e68081bb606633821f73d84c2d02df1dbbe98a22d453113448873f34e875d329e502a743acdd0e6f3f492f5874dab25d3c9a13b9237ffcaafbed1e071443c3b9eaee983586663964538018b2e12053a147584fb5fdbf5e51bea540c912f75cc332acb2884c1a3cd192b5026abe19e01724d8c9429b6450c14f4dbe59556c33d4e324345c14af86cf84c17bc26d1971752687f1f535065cdca38b7ca3a9b9ff6986b4f4335f0d1bdcaf6bba96482bb56384b727f5ea82b01ab96f86ce556012c03f06e4fac0e551a417dd43e9488869d55929df97404c29da98ac4c1d4952b0b25294a3ad89faad5438026399620ce36103497885a595b3bd4a0d526a04480dddcb233f07464ccd0b1e362a01365516deecde5ee9e28b329e2179504515b1930b6107a437a3d65a866f206708c879d88682c74b673f2f1dd99d24908c68604ffd81056a82a2b315b8abdc828a735b3e5a6e3dfe66e1917a628017a0f2856fe3002574b3c5d46d5f5b48a971a9063f1ae592d4f456f7411544c103d578b3d82be3a40c90fabead4c326b2e359ef86d07bcb7fa31ffa43b6bc96dc750aa05c4e7b3b4a4448457d806f9c8df1a5b0f53833425ae384e48bf565ebb45d119414456350dc8bf033dcc31663b2e0fdf523d8406bafa2010b2002b82823f15af74a3ad7c4c3e87fa4e03b63ba54465d5af2ee74988cbb32ee29365ff2083e21d85da37efc84024e6b51b541f8103a3f4eab92172f527d12360c74691acd3e77f1106849b51ff7f19a932900b531201875b719acc448b6b792741020ab055262581e78213a028d13c3d901123aa2c8ab098271374096ce0cd3ce108ee55f5e145c1f2a60157851359b7e5308ef576f08e3e9227233e868220ccfdf6ede96b6344f3541a141d1044791d8f08c30773a50df496cd3c4ef93e014870475091b88e36373e984e89994c5641430ba57bd7553582bc42ab21b88e179354b733c2e6ccac454b283ef2f350e02b0cd887fcb8bd9e8cdc70ccbe8024598fc03ead9a6019e866a41590211ea6a1efedbb79433e6020d83d6f690624e7ed401d6e90384a1e85d993cea9f83c199e16e462be0f383150186cb789dbe08f7999985d028b0b328708fb49bac9309f99266a1977b450abf80e5e59990f0690ebe02916cb5b2817982e40bb403afa0cba3a58f81ec7827f61484fdcf27d1169e597f2252c2188ddb984c8f4f0e8514f1fd90aff02e878401efe45b92dfb6ad4a317454776067fba0ed215a01e9238790280f33bc782272746de898dcdd85436a30814318ea9410618f35cc4877c7cad245548eee207d8225919594a024b8afba397e6d689bf4c15e87501e923e810d234799b415bc869a13fe4b1fa4deb99234ac7f561894783a90e447654df6faf1d98a9877f61a148aa1b2ba37d2624babcc86cd63497393681e70c67bcc959407ccc0600dc1f20f8770953a4f87a539206941ca30f24cb7e9d6062f8ebac08d840688818dc5ca9f98054a25af61310817e05765198eeb76e7c86487bca056f582fd1a39671f70657f1f59ba5622000e5443f6a3c442eb4315b6787451321f0e5efca5d19bdf9d0897b2e71d4c2a7095c2a13bd7591e1f55e7614d9deda69170ed7d1111f2c6216d41e8ed050bee96c7cfdac1318086c2915b955bec2821441269a2ed0cb5b114a82a416a5e61e2a3aac6a16af8a4854c242cde70c27ac553f4e939288e5e85c7a1ff319e5ad040750a69ecd917cc87418fea409359f757f46a28160fa2b457e99fdfdfa8ea7070adfac3eb5edd733c55e929ac8e364470da2ce336b8db6f55f3276d9da172c8a1f397bf59640307c2679060b7a183a6c1f4f1a5ecd19bc74c82cb7883ac9baad7a4c11cae903186766c33632bd780681f34bc6991c0233310b9e8ef70f6a946bd1186ad330b1668bebdd19cf5861fb06f4078f5fdc8df7d4893f208ed8be7a0050a5fd52f76337581ad61b9a967105e5cea8336efb52cdb3127e0d3152d4d1df52a94cf12a23076da06c5f63c9e725a5c23fdbced24fc4c8af680a56196dac59d8f2095124c0ee825b54ffc3348b5587e075a6fd6aad72b19a40aee821deb17be888fb4c0b3eedc467dc76481e01a506422bc1f2d977a98160923d3a75300934132e2184b80ba5d93b93fa5fac96db9eb4e43057bed1654203c2f3f2baf095fd335e970772e52e69418d363974d82829674ba0a3c064fa407695fcf82f1e691b6297df41d5312b8e67adbf4b2404e9b66e747cd3aa25abb9243111ee1f82fe560dbb4bbce29d9689f5f6da7e59f96dc046a7f7d85633b7210e684a767bfadc5ccd200f5649d0985229296971d5acad8fffdc2c1afe5b8627a8437e16f754dcda395d1f49ab7189988e3bd9fd26618659a50ac43b1bae60fc304e0c02ae1868cf7834bdaee9a5c7fd0cc6096eea06d17e85ec997dab35352eb77af98236451ca72018a5aab42ae11b02fe99ed0bab03222c82022e1bc0b2b0267f7572e3f8c4f6038e82642b023feafb046d7fd3c116be8fd7da587881c0ffc5ee8796613ddf4f82df91398587a629961ffd65da28963ed2eb25fe33962bb4b86b97849f434d415a21b473e6f0c9257ece9bd99ccc9cbc2c04da63a093a1cd6840617407ee5ad5a84dd4296d09ed2c52ac376e4de4303a4e3bc4aed34aa1aab836386f7a6658c3494b9f2dced9d9a96186b89c889d20a985266bb8aeed13de92a03e903cf33d54597003e49fb427172f988ce4aefff334f84f213eb76a2ca398b8c1135fa2d70f74f5e52a695f9d974c3dd69f8c473f5094dad7fc92e092cb212374182639e71cf99ad2fd4c9b97dacfe3e367ac6c5438de6169c7cd4dec5551bfb1e06be18cfa45b146b08bd3f47a6f105e54496f5301cc358aebb03d6ea5f7919a293cc41fa6c4305a75379eeee9080c2b402cfdeded5802e1c7d0e3dae484279350e1fadb6206e12b8c2be0041666ccfa3a927bc0267371cc849cacefc73b5ad89295708113ec15cf83efc0e76ee14d252ce68b2072b25b8814c2533c9b387e344dbaa3aed98fa6e886061ba3afaa42c566ea84e61d7ee0a9e1c3dc5eb74a5d818ac0356675715d48b9492ea2f7f18be5317227d7e0bd8163eb2cd7cf018379712ba3e23d47afb61c270c7c4cd25321da3669df270526dcff1a489fe1db9f313f8abf0e3dec5e7ebf5b01693499b011fa95eee93e3b471506597d4f4ff37e0d2bc9f1dcfe9b259baacc350f4d6ed4bf7b891f6d5500441bb3aa3a9fe7c8ba49faece7be1489c463664797ce8e279a4464162c22706888345828fe810774e4f6b38885810a1146e84e845bdac08a3eb5f35fb9916c73b0b1ef4e3e4f4948d3272169977558048fd795f11c6519b8b63e2d05d354d24fed29f7be3fe302cda5e24c7a52ea7d27b4f7988375d48b66d4dd0fa5da3efc27b562ac95d895ce51ffa7715566af1cd69f7336572ba4a7c5280a15f3373635aae65f5201b6b676c86dc124d85f164dc759da2d5fa4efbbbc5dd1c4f91413854a15876e3f748d2715f98068581421b25f8ae29ad78c69c4416895bdca8c46e03aca97be88e2ae480449c2640df963708162b07b6200297c07c29f051de67d817d3988db1a879ac6167ddadc78b4e61b831095e4e309a7082784d6afff3ea16ae3f35cfd7ff1288067ebfcb284b4f07c61e6feb52750c79a069a27398f4759838e6117290eb37fdce596cce00814bdf6fbdcce3af8466de3fb9da66b9d2cf9e09bc2983c0071f28ce3c67513f8ce561ac395ae40a1d7740c6545c667f94ab2301b361dd6925445b4c558d02a2b7503d6b185a5026001f7ea6fcde53a88e6f9be701b5280b5fa57a98abbc6578cbbbbfe9183ffa71d3de546698ff0a3dd8c85e19de7ec210443d5e84c0f774fb699c25ee8c20210c51c28f001037289f6d27f312f5f45fea8006b110f44c100fed60034a299e4b9b35f216d905418041a35b26140e196fd72a06c77f61cfce704164598b54f27b9959723aba4b8b2205a086141877b223f1cdbaf25f172565ff9b7cf077cad9163b10a1b68809ffa3fde074fe796546bdd39fd8138c5c8ebb503d69595cd968995113450f87beac4c6fe2b66251029a43adc74ccb5d5fe21993315e3434ed13f2d8e81ed7dd60e76fe52f347feb704f036470c720c28b965fc656808c2393c0b6a1b517977d54d17dadf34befb4fa25ea6c7cc0a12a4cc00aae7a174b443e483ea686f414049286f627a3aca5589e935fee235c3518f8f0c7c20d2319e8667dabdac051178d4a4cbfe77ae67cd2ab45aee7dd200ea90920efd30717f8bc367b01ffaa0a6bd3c0d8b8bf8550dd81ecd80ab3d1f4a248d2a527386223317471fca78cf6b619ce7e36f052882ec1dcd68b212727de8dbf39bc9c3ed0226a910bbc6ffe5097b28a229220a6382841d653707fbe69e03f6bbf280dc353d887b88a093c403629fbebf695022c720887bfa65772233ba09f782c8942a90cb1dfbd635c59390297111e4e646334a669c5e573f2d1ea120eceadc5da012b584acd9237927a702ea2f97d172d4f8fd0f900e6a1874800bed1ddfd771d644e99ee54c58c5e32b500b8787e6fde59eca28b8c114d14f834c74a1f8546fc3d3bc745ab9b423b369353d0b73a2b9c9c1ba3839b3b91a557fa7173fd8ee029698c59f0de3bfdd4fe0f70714aad4d743b6657f1ef7fe7f1e794d2b33d068a89a04d8051c858f90b14f647c5b1214e25ee8b68ebc1ca8edb6e386dd18ce9b45fae10e1111317114aebf4051acc57b53fb8812c68a8d00deb63f130f05896aaa38bbcf6f563aae9004a3eacf21874f74a4120aee8380ad2e459c28a3ada04ca520391d832e2d83e5de943b110679f3a096407dd3de0ddf802b0d98d3c1d82ddfbff4e7f3dfaf23a888e3b917ec717028395ce7372a8f05382201ba57d1fdc37126be791e2f22feb0777d4663a940561a2c457d575fa57cd5596c99abb3825d187dcc7e42cce4e7f2f644b6636cefb479f7f9012b7f0622ce5fc033c7fe846f076808a11918afb3e4355d223abb820c741f03375303b94613a16f926beb660ff832f46db3677982ac8967af136b65a8f5dad46a506485e3cf24ba69791961704161eed3413c376975940a190d2152e5b7f3cc7660bd0667adb8063a90d72da36ea8017647547bf07ae857f5b36d55e23656493ce74b4059a409a71b054a8bed97acc3966334cac1f98706240204f14b433e3d261a7b1d08a6d73309bc9fae4a3451991395ba6e565816f8ce4e752c7072d440a41fe121295398de1760865b178e10515e3cc3608139eb711df2fc9543a2287791342a4ee66ce97d4967d1b200f549fdb3a43479195541896cb4bf5aee709e8116c93d40eb0ff3b53519bdd9818bdecf69e7ce0013a4115715ea341b746a4c0260d3faedca6b0b89a3a55c7080054764d4e7147c5193e900b7400735e040c24e0f2023266b9f33d4d9d4a037b742a07ed223ff4640d512125c2484caf71e5439097ec2555377a3780e788f266d9058c33919017843aec43710e98f204fceafa42f6c1d528df1e2ce2084958060c6f078a4db164b9a4eb7c3e2ca2bb35ffdf49b0df7740f21f0c80e5ec59367c2d524524d09f32529eb4d3af8dc0f08e65b2277c3f2fabe23f3d347d8e3598a110d1c66860b2147e1e851a07270c4b052460c32cf4a3381f13e79b39ffe91962da126af94c9bff80196f0fef0a525eb4ec9f2b63b76bc2ebd3df1e4a3467fc88c12cdb62a24ff01b80eed8303564a02463c0989b52f669f70c37045823d470b8602fad1a40681e7b23effc6241df80b61be2369bf1580f260a414b5c87343b26e8c16fd510187904bf8fad3f5b1bc2ce905416e0aee0f64988f6269250882cf9dc832ef83b4cd21e035f7ed89c11d351c9a2971f5517c515e88eefa5aa76d65b90c5752550bf9bdfd0e3ba634129c3c5af487f11fcd480d82db932caf0fe43defa070a5a4a099ee2ee033054002cf5a4cfa7c97ee8eb9afddfc0dcbefe3a8f56a9ca3027669060524e79a6ba13c3eedc87cfb051346b8146fda85329ff6765a983fe848ddeae3048aa8911f322580e5a7dc36fec224d47f15a324e43fd4a091c691c28f79828c20461c14040ad48a9059305816a503f2460d49daa6f7c11696a91b2ace1fdec5ca0e4acd0c517debf1827a4a560c79d233ee01188823eb83f6e31fbf2120e805054e012fb5b9acd453c1ec3e0a9eb42c2fd3a71e37b3d6882464efbdb7dc524a99520a8b082f0924096ce3f2fc31b04de9b7ff0e70f90bc03f7adcd45c8699a91835a697edb1593aed47abe99f085a208c03472317d2f3921b3f15395a4d0f84505115284d8458b2fabc6b6a22c4922ba4be4b57eada51f1539ef76f32d5486986d5ee5372499fe3ee84d25a4da67fcf4947619af8a4e824eb2d7f01763cc4ee6b14dcf859eb8b17b232277cd1aca2254a04ab387b6444a21b185525ba0437c227c2aa91c58151d3464ebb1fb7286732a83097871899263e864512f5e3160fdd4d24953f3b69647b0bb0ca83a898c528dcf848fa870f3407c6f1c18403e3c88f5f01b6a11fff48ffd070ae8f6f3da83a0263e81f9aa5ed237299fdb88b25da48025e82bdf8f448fc4863afe0466ec59f338051a7d5712fc608551bd3f931c79d71fef5eccd39d342340c596760589504a2f8474ffb4892823dda477c2c7ef4e6523c299aeaab3577592d05553d3c444444695c807dc48f11034c13ffe32624619a780315d5488f7bf157c840cd3ec5d33f7ada477c9389bbe809e34699e44d5a4e44a41425da673dd9fb50b9381ecdcacfdeb9202de9921d4c7630e91d4baabfe60e37e8313a6c814629c76fe6523691e88d3e3f66dac7052ea55fdac1a4b27b2ef6f3b9f4b5b8757d7dc7924a5feba6ef14c228e3c31bede773c568dd7a2f97872e9699a664bf24977eff88c1ab24fbd5113733837b300693bbf7fd70778037da1c6d54fe90cc5c223272965984069fe5535aab49723ef25316f56b2b577e3de54a2b526c2f91d85bfaeda5cbcbef2aa5ce887bf2b7aea7bb0148922c27b9674e015c6c270de49efc1b3ba8d98fbe81b6e81e67d93dadc76db8bff131ff5118d5cb5fcc46476d2fb76deb71373bbfeb46b40d712eb9d0d8f60ff9b1c42a0a51f1a9cdbb17fbfd42ec42edc267c906e055fff0cbb4bb18e5d1f81ee338d3f4e7a1d806e2a061fe75d94fba8feb2fdb3ea4c52105a5683cc331fe57af9cec45469960a49561e662988d8e9a636818e39c6aa8cf3d03483ffafed6ba5652259d6a7079ee8bc0fce874aac1e5b9e781f9d1f3fdb970dbece95443e9b9e789f9d1dbc02b2641949efb20627ed45c90530da577f922257bdabe74d28ac4d8d3668b909494eabf3c4ffd17eb43457b1f97afaf591e5289b91d262ed6870a8fcb97de06ae2fcf3e80eb5dbef4fe3563b8d8afdf6342e8676fe4eb217e3d3414961196e632073d7a7818bd26f486a2853806b7213dbfce0c6e537a664e7d8c35f22fcf8d9cd47594daf5144a6bcdf8923aee8ede2c7bbea2b615292addec575df8650d5cc76dfae9477b3ad5b03df745467f03b3ff6e341eb7f93ed3b4ec6f80c0cfe93182047e0faeba2114037c1d0dcb201c753f2bee7f5640dc8395079eed39bbd9c02b1db8d91c1f007c5e610e2d1595dda3d67fba64cca5131a1fa065646ea497c43ecbaeebea2e4a4d1ea40db1c3184e5b2adbf90c2fef27949ea394de5c8a7d89d48d3a4dcbb22cf34dcbbe3b2dc3fec22c4b8f269899f9e740154a6b894f4eea4e3e7a9ed1e85fac0fcc8fdee7e549ffb3d26a77f25277727f97fa31d607e6ebfbbc7ce98847edec8e1849a24e08388126a1ee94591e785e1ee679b081573cd8007f87ec6de095cbc3581f9f9f950e1456cd66f918cb2b98b7a71d983f65d6065ec1d8d4cac57ed7e7c08924759dbe5f3ebdd4f1aa76bc2219711b6ae3cf41c85e45738a452a85d16b4af786c20a2b806c5a86d16b426f247c8c1bcbc8fc78771037373032333d6a6a328c5e53baf715db651b8625faa70ca334cba80ccc81af33037c1ef833f0bd0ca3b445c506ee132efccdaf0c5719d79ff20cd72c62422b92a71d86fea477f9d38ecb9f6ce855e94f455625fb3fab51fd6a3fd2e8e75e2fb3a4d27f7e8c310c7b86b0ca0863f04415517c981bcb9847be6919f642ae2d5bb6b461c31f39055c9ba9d248230e3448c37d1b3532a1c243df1d601bac2bf935eea8fd66bebfac0bed3c11f981757ba0173e7f462e7cc242725e14cb8000c9b0ebc7bdc1000244757343afd93df03c39af99197a4d197fdc3b8ad643d492c633d767d9c32c756fe0f82ccb328f8bd13c26bdc6dce8bb23d92fb5731996f83f6ff4fdf57af8a774a07f8fc949cdcda8f99db94392bab687a8eb2b0ba1761bb98ca2d55c9e7fa9a82a7bff1e32c398dd8b3fc81fe87dc557493f320e7c5a03d9356b3e1b172e818728855dfd7ab8d1e7c69883da3f82bf74bbaedf5ca575596cfb23a8d35205f81a1ae754524ba7bb41a51fd4b1419dc1a57db40f7f26ea217aa21d9d19dca6a18ef6e1ef704bce0d4ced238afafdf7a0dec0f3c1ee3bbb8da8c76d3ec67283c9543dc6de41c9ad37c4a836fe31b84d9b4c2c1d45d4af9a58cbb2c630da5996cdcf4e32649f39d76599f6cc651af69d61df18f69de6f33dc1e73bbf7f7e6f9bd6652719605b1ffc9da35b859164c4fe90c48e59ea4efba56e64c991be1b6354fc517c2ec6974c13396b993ac22b47fa909b3b8e2285a8332ea4d18778e10ffe23bd8928d643ac228a262e57a106d1355dae420da1abcd8d8aad52b799736a327e47db9f034f50a532cb94aa3019a6653d1cd146a4116544ac1e5f613a355373a660ed69222d510888a2101951374ac9d0b40c4208bfd4d58e348241240bf58854fffa7e97eeeb9503b9209ac6715cf771cc6d9ab669ad75d3ab75f7f5fb302f0e3ecc8bc3f51a65ce24e3dee6d20b8eefdb2503b45f920b3fd2adc298e6d53db7e95cbfd60da7c5410608c60584fa994c8f6ddd551847f56bf412aa9af6d95fdda7b19643ea6acfdca5659ed1ab65dd977d0ea98b437c987539a4e86557517825a8661442088f5c11218cdf18c42086c53859e8daaea750c5fdf526a822fd75913a18ca6d5e8d4bd858857d9c5807e328f818db4a837a59ca2b2c5169d462a4f3e1351f9e88f80cfca2664f214c72a1fde80ce0d7f06f866118b6759122b9f39b5252f4895009245ae7cba9e5f2155f984194032713b58c101a11bdce06f5bbb9fe566aaabbbb7b8ada2374990bf2566ebc1ed7ad855951112c9229698b8c7c84ddd9a0fa5ba9fe1f17b5cdf7503c0f591f640955a1d5242474bf2b0b64614ea06ab2202a42b9110b9a72b5645e7c980b6efcefcab2a36981a80883fa4d4dcb8d3f599355194ed68dbf234ac52edfc089d01d627141f108dd3ca8a87ff9d2c0f7cfcb57d608e2c6e7314585cf438a28acd13dd078e693555a1746eea018d48f85fa892a04b1b4206c412bb55fc0838aca97af44410dac9abcd48dac0285a75c58c19310b0d0a47a603e6149994058e124f017ac2c454d60c284279a587914ae7f8de222faa9824514222d2d289cb8c2440635c0019117b3ce14c040e3410aaa002209fa53646967a235c512ba5e6e4d31c6c52eb7a638632ee1964401cae2074638e2889567e00b368a5a555650831c1011456bb68c52469413aabcdc12a2410b51849c702688105b422a9861e880460f5cc084222ba2285d6e0941112a020241ce979fb4d5e553f9358b269c70a5fc198f16492a09130d88e81a0c31c485156674b9e58328acc009723425891478a1c5d009b24c2088b450e2074b10f14bb2c052ad27435c78b9f5a404330373085f620330890c942e7c53ca035888f0f324063e40620c278e085263b25670834b0bf9de9c5860190209126230c61a5b8c20011663e0e00acb77b0022e8eb82e27818b9607d0b8dae5561223b8dfa7a4179ab713ef543a33ec2469263ced7ce3369f0a08dc72bf4dc53852de7a250a625c1cb77a97ddee76e8eb4c033f36a1ea406666da1d8bb40bcb5ef38dcab95ddedc15aa5cb4bf6ee6d2c138ea9ad736394d9bdc77525cdea53341d4f59adc3431aa76dd8cb445bddc26fbeb395bddbbae87a155e15ff1da6a37ca344d7bcda52bfda8ab245bca3ea3ddd7d787783f1dae666d0ff1cacf58e8d22b73c9a28114d757dcc69d57d362db42125d8fb7ba0d13d10008d7b3d0d80b26975b5d10e072ab0b2b3709f44117f785cb2d1f44b9def6d98cc63b2e8344bd5e931886595ae5c605e1614acba8f32737445eec35312a256dc184228e0b82618df110ef11243dbc9ef934db360c8b379bd0b351f6b48cfad55c49ad8431044693fbe3728b4807d7c3b2e36661e53211164358586935717d5c6ef580755b5f64b9dcd222a8a585932bc513222b54b4b0b4a6bc6cda18350ca1fbc2e556184eee4d182c30b4c46ced3736a216308a89a2a0445554a22b626eefb8deed002304444caec96db8d583347a6006902cba3352ccffa2890b80cbad2f987891c665e172cb0b2d2ebb4d0a5b771fc52e04eec428655a7344cd6e6efa0271ef86c76fb0ed65b820482ec65650d3e5bacb7a7c3b172b3d89e3b867ae318c7bf7b8cff127759fcc2565309051b1efdf3ccfbd1e34602f93511257847d003e54faa998d83d17b82018666a1c9c69078b5aff8b97f437489f034725faa4cced4d7f4f8f7b2cc3dd998c2646cd300c4686de7284edb84d66638744cd7ec4da9e3ef6c17041280b580f0cc7eef180e168c85e875b3d381a6e68b820a4ef3b391ab2b7372f7041483fbb9fcb6e43b296723464efbd4cfb7976db60ed788897c3be2dcf65a6c1be2fb533f0509da7dcc51e062c286b815ddc90ecdb520cc37e623c37dc10eceed434e99e59f36c2b526e3c2da37e3757cec76c534a7fa326f784f808a1769895916f4fa0d27bfd8672f98bcb2d2eaab804b8182764be96795e4d0dd6a3e6eb713d0ec37e731b18c69118751bd2f76f15a62717a473903ad2b7979e392f35fd18a71f439b922aa97e8d89e962ca9db9dce24204976296ed377aca29a0ca50a737eb4edcf315261405d1ec4906ece963f6c4bd3d8d9eef0e90f41a471fa3db69f4a3cf3a24a30eb39799863ed67d29ecfb3199d49d76c6bd1bdde584c56245b1cababe64308acda069d42dd63031f9268ce2abc3c51346f1fd523a5c848069f83601aed61aa715f5b071d7a02f5fab8fd9cfbb18d0165d5c9acbad212d9752a1e532110d9e98d6b032a58563ebcea75926c72c05d2217194fcee8eb8279f0764c02b81189151b8f275a070bfed7e3c04733f1ef28e6ef176908cfe00714fbee7d5d4f4a87949d57817e769cdcdefb6c0b443e2cdecc634da0f89b7ed28fbfeaf9b1bb245f7346d76231b8d44b20f8485961c0dfdec5e4c74d3cc8ccc0ccccf984c2d34c60d696cbbb98921062031b8e4c47013b99b1e82ddccc29045fd642ec66dabca588692b80db786547025bf9becf4e830ce842ac85e3ee16adaa6a3c3c3f333f04851fb4bcfdc901dcbe39eff484ec7bdc805e9b1359765432c3704dee6283b8e4c4c83bd10ee694cf7c120e9993d86eddcfee6b9d9f76b5927432404e532d11466dc7a99688a1f5cc62244e6621b0c523037a4da9feb0f611827db8128f9dd3b5095044ec93458866118cfed1bae7342faa74c872475373bd37ddb4bf7f5f880dcbc97bac9d1d951f18ab254cc758ee55e8d769ecb9739a2cadcdeb62d320efb371df9b8a75ddb75514a63865858a8c609d13ef3ba947bf27574a0b6b4a9aede6064324ee9fd4d2c73b7d7816930f5291629a5305968a42f94d2178a75497cba6b56a963a6d9dc2ba27e48646ea5dab6e1c802d4dcce713a9c2c09e2b849c905e976db4cdc93929503ca57596e531b4afb111d90b88d3b71c20549c283ea0f01b7d97a6e30e2dbb68dbe63b8197e6ee7b8cde8e5c7e03693dbb01386b59452a68a6c6580e8ca211fb7e116104eae7c20a8dcaf9bf8fac9958fb5c7dbf2c1930bc3e5561845578b1c91fad4a9b3cbb847b226a6c9b2ecb70e89877141bacb76ae7fc605f1a75dbc3cd63b24a9cb29ba318e0fc72a258c922fdb7e321c1723ff8b49e29efcce89ea2f547207cc40cb1642b707781b0890107045a5b2986480b52a314e015a6700310d544df93e3ff0184e3061ade2fbfc302d15f83e3fec006a22c54a5a2afe3f9c90e0240aab68a9f4ff00bba7bbbbbb9bbb25d3305b33d0284263e85ebe8246153097afa041e52a216a30714a64326e702ff6304dfc1e8269e23ccd06729b18372b56b86a004f3aca57a144acb287b8f163931bb5dc6fbb3d04e3cc797ba02ad54050c580f9f282ed610c685517d1a8f8b451f1dbfbacd5a1c3e57e0de4d240d9fd98a853b8299864ab6a1c151f4866858b8a1df5e9b86dc3eed9fbd11437451d5a82151d2c97c8029b3aba74a3971df71adc5c84b809aabc99fe3143fb881fdd541fa6bc51c9ce10493656fbf9e5712fba1ced304d7c6e8afaf2a4d7a24296444a4d6a924f44462f474f6464a52881f997973d2fef43455a986abfd14bfb1d692ec8e8e50b67bf929c82c0ca932f6af6f1055a7c0d08e3909e5f875f98e8729c139e7bf0fb53504260c6174330e2076aace07f12f5a331a298c62f147d9900d195f642dcaca85ccfa50845bdfea3345c598681a88078afeb3dcb32bfae8797e501cbb21f825c9d0f7e31c62c8c9b7b1d8ca3b668cd6235fb88b3df79c8fc877b79f7d34b86a88078331ffc660c337b2f8e645cc805d9a1b708f99f7b7549ee9675356754aa79ffdcee7a80dde44b72e35f5434fefe1d30a8dcddcfedab76221dff41a02a56b447f85b33619c7e93cc9bd6e034cc30fda076c15ad498f821c0aa9fe123ee39048c98a0f6efc06afc68e0be76b5fbe8b23a308d3c03890b8d647152effc9ca2a09f73e67c966b8822212834212673ce391909ac1b4ca9c22ac210583810ac882d253cb04407a49452b2e042621221a594920821823099fc1586c604a65d6e2da16289152d084153de4c1ce932839bab73d30e4302872e5fc07ae372134b5b7ad069b55a2d1aa79cf26504f5e316141d776fb54c5e8eec3c881a39a1b5d3cbe436476f416186f0d84eafe8b4af1ea259d0dec1851f04a1402743bd03cd6196805e58e1f5c743bd1399a81f0f0545c9d181aaeb31acbbb9baa11eeaa1dee954efd01d541fdf990981cc936ec26468c883a8388b70b0019310a310810842601d6c00160d018628832068af92f04fd22ff767ff588beb115a71dd9db280b852807e35ad8ca3dcb4c5c4ee43d0428b085fe8dbbf75ed4c4878c1002ffc0a9a8fb84b957697339c5e466e1eb033840bffc3b94270e749c5d2156239c2de11a8a233720eaa2a1ed94280050b96200e64a1290e409287c1e9bb3c2149bbcb091c1a01bd2f6aa47fb4b310ee13d158a224d1f2b11653d5125f9878423e8d523fd6f24510be0c909a9afbb1961b8ce4403a618cd02e1731b61e333230148608cce5089cc9d832f68b0e3e2ebaf0a111f814c6ce2463cbd84d90b15fa8162ddc6be92088824f9b35a596244ed4efdf29a5f0af7f9d2450e55df65dac549ac4b3e2a5303d519bd0a2458b162d579a802549171742f8b109beac8d10cd43a935fd27a07f6054a856415a523fd306eaaa53b7673810b921f4d239a590decd795d7f79b2ebe109cd34a99fc908f5335d77db6148d4bf9f77eb90c4620713a66a6194f34a82d218e5bc28966914ab584629866159a66d1bc78d46a49ac154227db58d1bf568b4916238eeb71189546ba9e4e2f2f2020313c3059111a2a670828a0387c9044d2693a9965c60626e4478c36fdce81ba5928bcbcb0b0c4ccc8d1b26538e6b4aea5293ea1b3f986e4c381c070c4c4ccc8d1b3870984c3972e8d0b163c78d1c384c394c39749cfa9443c74966470a9d5d6106002cb4e0a15ce0d1a3c7d643cbb01e3d7a6c3aea0623733ac9ec484185ffaeb3768515666600c0020b2db4e07928940b2ef020f1e0c163c483070f1e3c78c8ec4861c78e1454f8ef3a0bbdad9d2315989dd9f9bfeb989979054e86a8020b2d78330480112c1851ddb6d082e7a1502ef0e841e303a3970f1f53fa88d07db40f1f3e5868c1f35028175c7081078f1eb2478f165af03c940b3c7ad0a0e49cd2615c30419927d5ad0b1c91be3d54b0525fa83406a18931c2b8bd20534475eb23150001c0d030d0d0d0f464a1a57604d0c44e53ea2f4e48b576f0f3217c1d05b043085d4c103d14fbb8ac89c7b46cda0183eaf282faf1d0ced0d0d05016cda1472882ee7403bc4cd47ccf347acdb75150cc8d989f4153b02a49146c23ffc6cbcf1903f3da283ee98b8c1e3e09be125237e1dec9dfad40d4dcf120889a2e7467cfefc4a8cdf1475f04fe8b55427af823ab840a0fc9d257c2308524ea07d52fbd074155a985588539d1f532ae1a9182b05041198c93cd3bdfb340d5280860f0c0abf028a8b7c0b55c9aa983e3a70e5425390255386c433171769b1ed3311c754d0451f349dd7cd9589ce5ded472a73371d4f4a02677ce6c0605050505ddb933fa2015044d79a9228a4934499fe32f5d5771b1429a329af34b9dd441fd3cc8a3b8cd97bae236e1361f5fa9122528ca6a742364481097c6c3863e83e80d44314ae97f24034c21dcdda1b7684d027ff83b3d146015cc04d826fe02d440b1d70fb91a78355f8b3fa80b80377e0ff6a633b88ce8232957bcaccfcfea212a7632399dcc41a5514606be3ff48f1f87a40fe66b0f5f4a7dcd1d0c5631f7847f869771e79c139226e9739c3422b19063c1e17090a036fc18db4ec76243afea9b60ec72523b5055faf93f02aa71554f9973d6e0ab6a5b0b44cdce594f1c08aabcca8c325f9b92cd06a276e55560155877ea8477be5b619c22a88a6fe241c5825671a7c6927d24a53404898afcacba055156b8379f347fd4cd975bd4cfabdc6e5d2b6ef3e1b8f3e7d756dcf9f3bd8a3fb7c324cec7c13393bad684c65544612da6ba4d216610f793b935f08a096ac70b2adff95feac6eb239f986f7c24442e50a2b8aa003db46125b2da38c2fdda89e6644b116df3c16c3d4666701b6825063789fbc9780aaa4ca6f89aa9b6a03244c123d0623fffea4e6e79307bf213cff51462d863cf2b2a4fa8ee04edce1188e215c686ecc4a81db12098213333d727b5bb9b075a4e0c53d2bf28d54107a8468d393ab80d5f2918041c85d99c2c4e90a81bbdd839295e161887e03e10830b4c8c1f18218740c500aa720835a057d890c17db97c850d297774f90a1b4a18418b9bec4c321d17449d7115fd7adcf8f165fe8377dac89e64f624c3bb83cf9d94ba0d845235339e4926422168d7f5542c503108e96bbfbd4eab590db400d6d095fa555335fdbbfdbc5a83c6f0bb9b7b98377b0cc3be31cf7e0713f54b5d8ca35c71ef9cf5f961c57d8e675d0f06395035ceea78a0726bda689d00d1d9d318994da5eb73520b600da5628c99fde0cbd3c8fa6ccdd1906d4fe9e8475d6454fc4c067a3f9f9b3d5b0fc69a5e4a0b0002e6e3a108bbcc651513ae818529a7f90f4fcb8fefe3a7d89dda9e6a80ef5f24beb44aac1225fed002271afa29e9a1dd81a8f927cdbb93664f0c900f5fd3ac0f0bfe0ff195a4a43d69f37f569b3d6996071ef9dbfc9fd5cf8acad0cb27fd977a5e916c0e0e2719fae989483ffdb6bc92160d2a27227de9f7a5f644447bfad4e2405fb35709159ef8a45772d2de2a89f674fd4923d9d365315b44c6f7374285f6c045d7536b011f08e143fbc3e8e147ab0344cd6738e1977d0ff05e492ef673aa21f28c3ebeb4cd8a3edba44ada096cdb411035e7d7a021834ef4e5a9066a79e49f78e25fb6ab448e75bf168aa27e9095e33a6a8450b975f97e70680a54f52a0668c40e75997250bfd8795abc15523cb1c216bb16b819cc6cb16301005bec00a095a07e94852d7633a4245ad862b74266a57e3176b6f542282b958b6e527f1b680713ea4763a782f6248a4381414d1cd58437c1638bdd8e2b3b29177d618b9d8c1604510d3482fa511f5bec4edd35907b4fdc6b92da62a7e3ceae9d74fdc45103a0976d2088f214aeb4295cc805811c6f95d413d032cd4308614321681042c834d43d18a78410324fe9ef90f414fecd5950598a00ca08a10cf54233cac0fae95fe1cd1ea39cd7d636878e085c18c39ecc21810bbf3df93206870bbf2b506fec16a31c07cc3108eb978fd3598860ea7672351216da404848a1ad0d40b91f674983d7b8bddd0b060927eef5f17a0ac4bd9c105da6a93a228b4d76a3e988a10bb3d48f7d84509531704be2800563a8e1a40652ca78c14a422c57c600ca957fd9082f74d03ae204373ebd62239ab1e2c65cf9b4827165cb881604910f85145bdbcc98429314dcf8728bfad53bd345577e943b50a144171f8001129240c51cc2054f5c90c78d50dc184d26d642064a6c37625f98da848171c42cc2093542965611683c2122cb101ae04887208a39d064060d40d1c0086628424803538c98818829401b116f6ad305e594725e39c38b39e7dc1202477114da84a3e496275cba90e58c222967248104356bc2fd6a3555982b50d0407d31a668c1779b1391f9e3c49dcf949a482e9f753a5c10051fcb16edf7e180848beecbe700affc972e076c2bba97d5b1a4c2fbc5e81c14a8327dcc8dff2a0e1badd501deecbf1b1c94dea875c441b9f061daa81f5774e18f9ec3c238d9c3e7cc701b9787cf157164b88d6ba5aebe465f7244b08ff2230dd84986f8d8c7c7e1e5a37cb12719220ef24b2f5febad748a5648e9e5cba7f44b5db51f0feea8e3a12f673fbad9af9ab6a2cb5a6f10420cc67252380a72562e8c10890a3f76f386b6606e6ae5b2501ac08c4a9d97e7cb37995e4e8c820f63fc669c1e1a4aa9fe1fe58860d76d756bea72300d7cd9e948d598dca66e9c05f5fbd44d0e8cd2f6d0d9f5cf201bb186eec052fd53eeeeee5f5cf525821604868a6a6aa3eae0bfa30815a3d79411fa476b819fab83ef284265efafd4abc0a1bf01f601ff45d32e3f64557740882ea264546a5ffe6b630cbb54aa948c6114fc43328e0a17c20ba1055282cbead800023f16b2018a0f3fe38244185a2be300c13832e3867037da8c4a85973929d9cbeb7229d910fa57f7f98df2e3d55bb48b034c03bfb92119957a5d08c4ae99465a23eec5ef537c5e65ef2ca86e84280650b2930cf179e2cf3dfd4cc3256a0ee318b98171e2c36f00ff507259f500154ca6528961b43e4c036b9ca480b88d3b61038cbae3dfe3957d270b1620687606b59f4f1e1f5a254a564aa215b2e255bf9351bb655ba8e3a2b2ad1d79a87340c6500ef291c02d5baeb4523cb2582b0821dcb265e55bb6a8608d1ca4c86732ae14fe359aebe118e0459ac96032c84083e4af792785452507ffa692833fbb3d11e9ebfdec3fdd16883aa51b5f23c9e719165c22e5b4532d7d7ada81d60451713eb5a79db9a24fbf57d4e12ba1d683a808df2f7b0351d1e1f717f16739e40eab10c10c6a53aa5258f2990196158b48cb8af6546415fbfbfbe10f90f084751b0a1ad30cd1a8db44d88d80160eb2dc1c97afb0c1ba4360528426975b4320e372d1e5161945b74504a13b4b77be469acf3ebda2fed12dad19a36234da229ee7d8bb5dd2abeca36522c40156d803f52a7b13f6d967ba41035a1d889ad9d78c7105d9a11f29fc48bf5f89126a7b6ac66022fafe45a875ab258916fad7f350eb4385c7bfffb2ed478022d03750901decb52c5a9f5e65dc8e0645a3cfd9688b5809a201f58abe6619a278a0f56122c40156f4817a757db44b7a757d0d1995fef5f1a137478fa31ddabbd5a27fd9d30eed55967daf32eb43c5065e3151424549665b6360581a0b44c167ff22bd62615da06e50e7e5161144440c0115911842689d9999bd2111124a184550462a0b8d67be54b4ff10de80c6348a20d283a296106d04418408c804d41aa24882c0d426178470c6d0d51982e8679ec0c48d975b432cb9dfa7588fb385c6333836f84acbae8ecbb0e6d0f12e36bbbd020f6a578710be91d9f5ecb8c745468ada4a670f59da9caf75bde209ffe32e43adf3558a21b7a062d6870a8ff6d9fb68f2a177d2c8e415e43c2baa7dbfd8d14752b677ae48af36ebf3c34ab3b36b2b3d05a2e0639d110aa9b568d4af592c0a37eb2c6d0438b6ff622ebffc41ff9b5c4b9bbd69cde2308dffe7c275fe991856997ef20fb9b10d86b33d7f896db4cc740056298027c09effd55120870ab00f7f78861ad79f70dbfb180ad75f07721bd75b88eb708b3567d4ecd93d6e48f6dab5c50ede03f00eaeeb34ca3921432e4ec80e8d456e988d8614512087f6e17f791a5a9e70fd75988debef5bb2e06b00ce0895c2fdeca400d115f7b2930254571ceb466b290bea47a9e6970d349ee12e8fa3e27677e20a4854f8adc58f85e4e7b88c3d76c73d2e6af721349ef99ca734b3ec295da59b7094f7138ef215a8807d785b7fbe5c109bebdbe569e116f5f3a12952aef721efc26da277e143dd41f01f541e5a87fee14a149181eebef19477468eb837c56de077fcfe243a40d5cc525d4d5a0a520a1da6aab8d7c409fecf8516f62a767de7f714f7fa79056d80ab695700aa2d5d8ad1ec2b01b48a95c8821b072251e5f54fa42083fab5909523f0fd752000a7e00d3318eef90d91bed31eb9611a2f2280d70057974d419415586ab75a0868470e2a7f771087304608234c615829478e48c1a85f4f99d21e1dbe13582ea0ae7b8eeb5fe93a659c78994bdcd59c91011e3a08104ce3ef4c7383f3fd9b4c371815f5bbbb3bfe8fec2b0dcd538c43baf33dc639ed29cae799ab537c25d7f34b5b43ff7c1e2554a2e5e1bf5e49ffbc94cc1d58d47e36991c06acb5e646a0ea9a454a8c1cb9809309b08a7610377e43a14d8b2660e4889306e2099742f1208a7d84d11c88da99445ad48f8b8cb8cd478f40c06dba280235bfe61bc7385ff64def97fd67d967178bf1bd0dc6a4c5987dcc3629a1d45ed3ec69085fcdd69c51a9f63f37a319ed7a80f7b25d8415282cb8b204145ba4b18a9e8a25d0e0ddfa87774b54e9efb90725848e43fc1901bca07aeec1a4b5a834ae9574410c15d1000000004314000020100a86c421b1602c1e95cbc2de0114000a8ba0447e529849a32008529842c610600c2080803100032033325b05e52e2b6ac05478bf273b1cc876a547901d81ba146452eef7bc0a948c6ed2dea62f4c9784d52eed030910924114fa59e0de1db03f7be46813a14b0483308478a33da0abdd88f57483bd0929767d894aa9d6a74997a1d1efdf20adb8322ff4b9f2db32957ea26f2727881446ec4a0366981f409e52a16cba27c834a97f45c2e8d2266ddfe35961756aafff73427e714d0be498bc34156c2712b34a8c19376272f61ccbb04846d1069abe353cffe41950d37bd97b971f906e73df893077e4af3278a08a15d69543ee8a40d25557e39c1447ae6f27d6fa8623ded381c5db8e2645ed5362123465a0da19a66d735cd0901b33250d21d3a40c601e869e3a9b7e400274800cf624a71aa248b5af2ddda3104e8262d332a7d4534f1d695510b5435dfecd623eec499ca60a19a64b673854e7e8b8351a8c1ecb49f3ec57b9cfcf6218b3142dc652067ee3018ee3f99e4bef8a6bd3149fd698085d9b26191563177429c4204ba735ae485996d66c534f02d8bea5a5f99ebf4df263bed1a7ea3db6ddcb779e5035886f68f9ad01e7e6a411591c11a285e9d386e9b95fe3849b3b131296689b60c7047fd6af67300e35afd4afdc8b1af0cc57d479aaa5bcc3b0495a6ebb1a4dee9fbba915a5e6b9a7b7a83e7ca942115f6a4c7636452c6cce9b2d3121d0873852869c1acea97138132297234ad9f71a7036ed93dce4a3d06876107bdddea8a2497b7a103032e60360b535ed44e2f434a3f286c8db3040a7724415e7855431fd9d2550691537de0b6b9ac00cf6060fe1dd1914837aff900d09e14cbf9b34ce17ad80f44f4cc1c7bfecd97eb4ccf1e734863287b6749e0a597b3217d375eea163f35075453223b0ad0463ef194305c5e3ae9d5d9bfb431a0b34fc277c567413af7ad0516f20f7526b81b41c14f0285746e9244f91818bdf417f1fd299aaa46dce45ec861de8b6ecc22c1f9bb604676a3429910131b10bb7fb15b3b27f806bcdd4dc9918ab7e5c3bcc653d35625686ca8a00dae6407f0e3abf8444079703b0dc69b0aebec2138ed0e46f218f23ed8fe9337ccc1d3174d3f22d25120b373ebfb55aaa7927d9e457a984be67937bd4400b158c16a7582a3285187737220644d1674744542e2491a3f12e3e2c208b0c3e6a31cdfdb8db67d6d421b0db3c3561a3deaa9b3300382a6375739025324c9f99e14007fa8255f8a775a6cd7b7ba1ed1430fd3e025ffae9914960d95dc21732ccbe6af91a7d969d7422103823d92b876a54989366723d29155b1b652a4d0713868417e99da2230a84b62b9ffa95df646bf920c6f5a5a209df264518f62e82fd04b877ec21c699d05a8fedd529a529a45777e211905de71d67dad532308ec29c450f9704cfef7205cc1d5b01fabdb8235f93c6b229c1b0ecd0316a9a37c2b468962deb93a00266bd779b973fb622e9455b014f10e126fde906222f62ed50787f916944f8b3c326ebb16f97c21ef00c3a881b683c196137cd1dd2181a9b61d00cade4d67256ab6c36811520dc8e8f598eac6b96bfa24807d0a526715456ad9dd5392e45d278fa52db44729ca53d27f8c746fdd628e7680b1ac639c0b4479ea1832dddffe9310f7cafcde26b1ce83ac0aba9fefde4f20bdd4a697e5ad76b4658292129e9aa3cf3a3c5e64808cd35d65d1ff1831043dfbf4e30da8f62e853e320e2ebaf6b4074bdadb306c5de1c6450baf472f59d1f579acf9cb60c940737e52f9529d9d54980e634f15b3732c56dc00204014a399d294e26a748e514f939650c25c9e4833f71bd3294c0602053a530d90abefd540f85f5e707211f476e865f51315c05ff6706376ac6b493cfbca1cd613bb8704c1c043003fc100f0b0c98d6ebde89a300ac9ff3cb4d9e179da4e307e3564725bfa5470c94d164049b5828ff385689b94f3f892c0f8a4de70594968634ea62f95b603392e10f934458131cc2829fb71b91d5ab7cc5ba8fdb090bcd6462d6d6b7112c209022d00c703b61ca3f70769d25dd7ec93c91aa1a3aa08b1fc2618dcf4bfcc7614dd6968549b6da939444e589d17260dca0d9defb984bd573771752bbdcbdeb245fa129d25aabf4e755a6d2ffe4a6070ead45120df5eb2ecee3b1116a37fd61d0bde355392efaed4f917cc8029f80aca4a44bab6f04824e7de31648a6a7f1bf33665d0fc8547a8d0cd6d5ce61e82974da717122f615cef89cda9cd04100a3f4fa2fc88e870b2d10d7a4ae535e15adaf48b6941a754789547fa6a793c16fcf49acc54866c396dd637c756f06d458caaf97b08192b89a957564ace6fff982c7a17a2e31c0e4393eaa2db87b007be308595948fcc286d4990731ef073d9cb7a3785dc08ee79f883b352a2f98d000978449cf4f78fd59966e09315f00af3fc7f9b408bbfd74fc03ae091c8e1ac83859f9efa1d1f78f1e10db9accba489de6a94231165a627439d5e81455eb98cfd404f86fe605e103c650133029087cbd2aef653dce4d82f41264787f5bc94d02006231e10dfb31802e9d52fb3d96277c0add8219480b9ec5f6b7a21d674f51b46d88d0354a802d758d6d430bdc4d9050da6b49b7f4b30ac0b552c13985651d3339aa0c309281050b4ac8cfea394236cc0da609e7e904b2159195e69959fe560b265d7682d212ed3065409136028c1381a0a6296e0b1c7c812f55d46b07b0fea6a3c346c3c451c03b24b260f8fef63aa97325c0246fd5ef1209533ef63d32cfcb5606d063cbed33632929786041d91eb23c1b6ce4f8538f013c0cd045ac3a21e793ff965ec171bd0a0537e42b9642b34c221238dac2a9bb72073ef45cf5f82a757abd14608ea9922b491ad78ba3bb9fc7405c6077e5c40193d65d9d5ff7e750ee19d2e361655c4e5dcdc4e5f09357e400891556e5ecb61c11823acb329a7ae7e864e5c6c8c23d75f74b9b5ab47844fd31d2aa0307b2dbee95a1d4c53cd2df7de0159c3283ed866c9232018ee686577dd0adadac3724742074a9a5f37a41fab171400a989cfd0c878270414f62927f78d20875e2028ce5acd0a66db899a666ba5aa361de96b9da3f26c5baa4cecb276a4e5b79978f005b3c25b44f3cb2edaca9b53fb08fc9e1084eab2d037ceca42956fec090a18a154383bed00d6a7d03ccde11317107e09c2351e99af5eea103af304365ec0f94b65a30f7d228c5bf72a36afd4c24c1efc99419f3a0c0fe5db33dd2358f60f78a87c52402324e1dac9722d94b5dc62f7543d5a09e03dc74cb3ddabe0228c297a720f54a740a663202a68d0e04d1367602598a391c92ff047c8d34f4446f95dc3bb60e0e5b86a49ce615ff5df72bb576a04f11d13b706aac6f23f4c81e540d31e5c0cbed861ed42e1b2a948a2111fe46a8535d1f168f9de235ca0c1807d8cc2dd870b0705520a0fc511a2fe5d442972e5d88a1ff98e7965ac31ca22d3ad1ab59b99b12703389017d6c1ccfe2df1abfa3da2c94e9e106b9bd9b64d112e9a703b389c8b3c9170ffd7ba022d5255ba58b040b37b066a79a934e97b8c14e99cc02c64d5de8051d715edc14114f4821039c4a7103750fab7d994471a32b9934018ed0c73b1637cbdbfa5ac8276e26179f5a8826018534ef1b93aaf04b00ea485c9d93accbeb24b6854fa6703077bfafdc655c67cc7565c94a39ce94922c5d64e5ba933bbdc1727df3818fda7d1cca32445f04abcf1be64a10f3d70a47026c02201fa35cec8c5692b88ea2ebcb178a51568d406e51b3a418c592a246fad460028ac0519be451405a592bdd065125d37818f459c1679adefb20963759cda88b6f52afdc628c9f1bdda3471d5b02344d492da4a48a83befa10ef1b8944782701b3c16360662ebbdaa6564130847ac848941251c5b41301c42a43d12e0c6f3defb328aaf8287fc051846758c866c5420f50325ce3a81b8c038780f6f81f11b83250b1ed750f0d2732f332abab1f854f780c34ec4af3db42b048ad3377828785e680d43e4da611d579e97de4b8b2c7c7f8e4caefea89e321b5fe868c617e68dc3ad178bacdac9c04a71a9f4f6e0005d1755752d04bb84a239b5ff2cd50865596899ca1cf3e5fe2238ad0d87e60f9316e150c8d873b08f7a08cc86576b2c79d5acc09b8adb4009c6528a54041815ad12a0042d1a7f5e3dda474554576152339e9ad1faf866494b9dadb37ced17c7c4d0ed7c8ada71d3202246697637015ce7c71d3bd6f1325abf119eaf2fef79e2c15c9fa7325a1a638fbd5028136684fc7e76092aa31c3f3550255fc22c9f1c89817236b743bfb573262098a462b22a4596de23e096f79956d744e9026aecdd18fe05af37ca753c6136534ab3de739f19054798923a4bedc1984f5e92e18a090ade04e7c8e8d41171e32d38e41514000bf47d3b57a52a07405eda8a9ae0bb5f2f329467fb89c10164176e2df92ac84c578c384f9bed282e0b07e3e5a46505e2d0f8e6ef0afda3d054e7e86908b1be913253285f1115b4e9931aa0f7c11823936d2cac2d05857e0b4bc0f558f2523a93f02dca963fb21a3eac080c54cda404946b72f727cc8fc6990d624b86f2d92ebc50d73eff95e6f3d6b9774a943e9c42f027669b6198a80fac4bcbb12b6df2fa333fa408dcbaef4016c3860b18274903728e23079b04d026968e5a3a07282190b052f0fcfc130e0d433a8eb485c318bf20e6d88ab6205521991bbe3adb22fe3c67eb88676c5fad8b9b3eb4a4fd405bdeade12df9fe364edc2114449d2620257ae4c46d534e2a41e5d09707e814995c550c7038d47c7249db13c408c308f782bf85f55d97f897e37a61e813f28e73824720d7517e9a17cd5320f8edb31ed5980ce787d3bc4c490b1067caf6c20448176731f37f323cc8a1457c04f7f26043a3f9d1b8d814e3c62b7c454b36d158da504addd16639b109602714fa48cbd1059970e4b7a2d4cd4e07ea37dfdf7373e1a18fc6a9d5b31497adb38cdf641a8837ae31fa397d79a303731f4ead154cc48aca45f0bffcd6d64684dd7dbaf5c7b87b6a04aaf049400d48c1a297bdf2621252653aa9e6638a24d39c06fbcf75ec2f87d72b15614142d422db44cfeeb8a15c73890a5b597664220c451cb0524579543bff334149951337c918623c4bd5a4b4f2327843ce48cfd78e24b716f18e2dea98361256ef990714f5db2f767dc5343ffb88ebe8f7861d07c9bbcdb843b66bc696174c421a27bb6e98b1b114fb515bec98854ac57d9040de57e57130816135731b67295d3923796e16aad075132da0947464dd314b4b2646d4e2ff48089b4fea90f0461d6b4cbfd8100e64523a02773ce0a3fab64e6955b2dc76ed4eb52e7231cb328c714bbe4ffc9caec215593343167eca95d80de326b113b0f1352add7b31d634103b7100469be7264a03e31a9e18a44eb0432510b6ebc53bad80323f531a8108c7accc67da2c573fce609ee4bd78cce03f17c6e24a31f37f2594b5d1ba0d4b573b1a4341635da765363f2840c748850c44c5abe535e0cafafa284cdd83facf9ea77ab4312dcfbe7079430c314c669efc11fa9730d3cafdb5a700bf5c1dc58443b76d2f1ef700f9935a57321f382e44e6b92c3b700ccfa43e6b9c4caafe48b19672062a126e26f3092168983a888cceb61799fdcf46b207075d13fdce31ac66a0905b6bc7fe3626d19a51b461b3a6887be4c55ef37f25a431daaedbdba49a0b14e9bc0ce4314c2dde4a2f7e8db506d6655a851ee2f2c350a78a5046b25dbfc326643802370ece24a4e445d7deb158c71a9bcbb02e6e180c00fb9eb3859c676d9bfb5e6415e93505454adaed082eb2810f364a619b37a69daad3431e0cc185d5fd28294b4e01ceda81d819f527f032771e97324cc8c94387aa6b67617ad4cfacf611eca215866d6355b14a6013cb2dea0c203d685bb19a6ee84517863e21c9c4ffbe2eada1ddad0430cffc8b49a6f118ebc3cf73bf846dca495129d3be32f45be73d2b126c500fd6e4fac65e5f9c7ae21d922970e43fdb2c32d507c99e60b2d67a5efcc1125302bf2dfc6217123bfe65005d9055ca9659c0fe162ac480015502b28d1fa26fa605e6a1c409096c70e0027cd9d214c8d5c82b8ebcb06cc80c05ad7e8e18cef5974e9f07032f889f8656e7a8187146f73911058b549f4d673f378e07be6dcf456db0f6168fd51fb2916d6081703634833e860f601737315c6ba830b14a3212b7e30d3b7d9b7dd7ab340037b2a9a60715e175acd103c6067dce1cb6e65127357410a9f6bc4dab2980c3bb30a911623d193d1be1162243e4447ad47455db0e3eb7e036f1ee08bc825ff2f43deed1791a4c9484525e3f4feeb73cf85a3cab289544c588f452e74beb10ab51bde1d8cdf162cbe246fd0a4958dd75713cccb3ccf6027f71144df0263c46fd652f25a15c81fec0739798a593dcdddd56db573a0aebc1556b45da8f826de5bcbf40b3760f6c8ae86c870c034fd72dc27333da0c62e04b858c1b0bc2e04896a7edb1bc9716f065f681e97724d7b653f8952b3ef9dab0fcdc95709064aa66041c19153ddb10183132ef5700c1068ec7669da674b56f3ee2111fb33e8d02ee44f8fa49353011cb0ecb865e52d0116480b9673d063f9ca93d33cc429259b33dc6ceac1d09e8bd113e80957871b327b9da37c9f1a6eb120b46ff416836669400c587eb62c3762c35744c22494c6c97c0447ca67b6e60c7ce7aa7444046e40849b290bc8b37208c395251a26e843977eb2fdf64a9cff1aad991be60d5a17d1f74248813c77863f37420065dc4886ff338bd69cdb46346e2d5107b014f6ab990e7169760cb9b9aa42a19f6428ec8fc640a8978b1564427dfae96f63602dd2646a14efb2b1bc191d364bb0c8ef68f1301de8e2edd98260a2a98034a2606dc383fb36e208524e19d799c18a913ab05ddce6e89915e29a26df4be867b87379d22af9b0b60d54a7799782ca38a1f390f5da577087def7a70b9b501729ca66a08e7770fa695aa0e0789415d7e6dc901ca6b75d769a52a86bb42d8de711fb3b83c4931f07638bccbc113c2b5de1126a45d0ef455427a22d79c5c22876cec885b88e80e40f6dbe3cb852057e0610bee421d5b02ff0f956a1a027ce331d581190187118a7988e594c16429df372c76704bd81951bcbc5e109fc56336b71d4caf960808092b06d3bf7301b4839954998e16f5924996e79cb5290c81b96a34d6e067f894cadafcbd2e2ca672cf96352e6064ab72cd3c7be6aaf35a9896b76ce81ec1afa927a30c2562bf7982aae4fde3ee893ae1b137d9c01cf19621788ceda0073592ea93b9dbcd4eb9f8697bd6716c6b3a9cb9efe994f1924f8306c34680f71042b0804f4dc0f600721efdea709803520bb08bea44d79e0aae25534d2e58ab3e564ed356b5a7c4bae03fb3e8683e0e507b37f7e9f1008ff0384017ea1ff45f2d46b725c10ac1b457e8c0dbc245d3b630eeaa26e7177c92c0d3b02c7a364e3ff33bb0db938f51de7e8e5933ad8ccb64613246d12899651599b2d35dda96e99a179bb4b15acb1a3508d1f7b556408691c5f169123abd9c66237443d96f9d4d148bf5c199cf283b5db45b0e7183e884c43865c7f3567d2f7e937198ef87a6266697e3daee88a68e2d374eb7b4636acc77b9e7a8f3cdb7a42fb43b1d531b2011d8aab383c5ed3def1059c01245a681efb10486e94570191376bdc20d663188519153dd063dfab66bbd551373c0672a3d9487d029634cabc5876413b4c7785c51e8ae70dc11f050e3b1a64d02a683094124bf966628b8e068390a815f7f79358729a59ce44697a9c11d2a43a5cf1572287d3835614391608cbefedccfcc730b17c489ce03c5d9954f2f7a24a11236a346feb1d3f3250204fa0eed4e8e8f45bc8e8ba9b10aaf9cb8c086137a75589328d3657bcd94055b85de9971b430508f1f824e7b8fd1e969caa6acc22aa23fb2e904044239d1779a0bccc0f6525acb21e760b624ffe5a645388865b7c5db599d6096723f1e0a11a8109a734ee1f21e84058bce70a939426bee69a1026111c802593595c890746b195c18cd42acf43986405f82389520df7eb85605b81c3d5b4516d771f22a6a89824fb651eba0a60b624c77ccd50a1249b6ad692183f25917c96e447cb60122b5b911c774692130347d8deddf74d9281a088b929047ffd07fddc94f6f59c8a249a7d0137f038bc0c7ddb825a6351636ab377a54217c148ea145fc2545f779b4181b8403fa22a92389685c9a8542682534c26bf4a1847962bfddd31fabba703c94619ad48e4c982d5e71643cef7e1259a7109d9e5a7d281a0ebc4347120a4244192985f3a5ca245e0f8ae86700ed946f00a02599e9bdd1d5dd3be72c471b0f3074a15461616ad8f8048508354b727220b2959104d84b80185b159302858c7a139d2b17d0a32c9594f4207ade5b51ca0e30eb67400cc8e85b50a5f28feef9b5be983bb277e40c09fa40520957205cbd7f3e993383b518d2eac89c107aa03299086ab82c94002590122d423526b08d0e6fdae4b4b2c7ed2b83da3428fcd8984030eb5bfa2a093a9203b6954ea25cc151d73c182564d38022c89a43f236e86995f82b923dc5ebdb0402826c969d42fca782b95fe01ed3379a50239446922317e67563af0033351bf28416815746cebc787ba436d66ba23a3d0308a2346ee384b94bb48ba865127928b9d220b48c97efdca93fae75e1433df6f9802bcd50becb760302e69177285054448c61ee5f76b9d570f9066220534a11d86deeb35f7ee18b9d82a82e06721c1dff1fe039cf0faad120edb8aeddaae051777bf11aa57be06d74615d0772cd1783234d8fdadb3743057f6422e6ad6125ed2292834d149219f63e05f7cf258f0c8f5e5148409116ab83d7f731cf02a553f81887b3903eb4fab00aeebeca8cd29366ecb3c91580ea15adb83aa02e02e07184df61ef5f15985e1ac6db9d976616ac85673fb471c2eab814a2d23c4f83549c1ce7c0d8dfbe67789fa2b0b09ddbb01ec673e709059306244e9db32a7cd0f4f9f2cd4658c68a1fdd8e6010e1d026bce66ab451045e18f861c0735c3a60d6f2bb220111e90223f5125166e66282b72db65c4f4f581eaaa7f2b79fa23e0a33bfb27f561346031fb0812a2a1c6155af99e406a80c33baaff903441c69d96f0a3904c56c7e35ea3901fe440d13c6716121fa25d7e49448a88157eba6f650d50e02ad89d0e8dc02ab765488e049a1e701afb1061de9b4390aa12428020f21bd9a0a23f1b73bcd8de32a4d076c4ed6d0edc60c52fbc1cb0c4cc7850f1d10755faed489edc0b925868d0981540afbe5ba5487bc28d6ded347b0d0a0137d4732e5cf996161685018e3c7d2b900330f2667e9a82bbd074b4ce64bb85e6f2f3e28785e6b0e2b99a4785c3bf403eca880bc787965b5079e63f5025e4c4b3cb3ca4d7dd53b4c30c0322b1370ce06fcf188aa477bdda064c09cd63ccca775558d45c9d127542f3b63134b80f82a53b75091b826dd0d446feaf9e97eafbdff7b7eabd33366b5310103c652141d439f577892f5d0eb154eecc3ade4eb8ad9c26eb314d8ea205e12d17077b752e21292bd69a9e3a5ba9b2a786956328eac0d35432dcab5b009d03d35f7a34fe39c42fa9e49d5763a734e8b0d3f9539d1bd0c3288bd6c26c4d6a7c202286ccf43145d921d206c7206234557603067703d32c5257bef912083ccfbaac09bb3846417adb8dd823a047e19bb001633d6591ff6565caea25db2121e10ab7a7b25ce6b28b05b821eb41b5d1ad819fe036fa53e8817df628b4b7681810fa8dd9f2eeb6197ee37f12dabe44791c2063ce607c874e79683fd441243d54144fd2a40475b772154dbb2be2330df1fff6db04ffb82c39c8bce50ccead992c56c6f09dc36197221b7fef7ea2bea65b7206237d32430578188a4ca203f7b1ba94b012d16bcb1485d754912f53749c8d760aecc70fd7f8a35b346a6efb530aca2d1a7bfafc3404170650429b07f09f72140ae078798680edd8071c8995d0cb9796a691907975b6ba8168d7e9973c287397dfa401e8ad47bade0eeab76fa47a102e707c147d960aa870f99f494c4143e571ccbdf32f79cf6134187b3170f5618ce44d5be290d31d9a19738319a00e66d451987c1acb5bf2445fb02b5771193aecdcb086e1281e6c15c8c13c7f8b9bddf936d8ba73c41335b3807f493a4e581e8b7f8b066c6405e0562d0f9737014be10faf2b3f36dd0fac95ff0022083e00425cb96bef9b6477dca946fe1466c367662aac4e83c2708b9ebc283e4de28d92316d62d335ea005fd531c96dc34d10e36af8e8b3d8b6a7912a30377c8ef8d0b7fa914b95ade0855ef8457a313ad35bac31ad48059abda2ffb4895598d1ebc2bf805627f193a4b2bc61f2280fb75aa655b0e427a14a0e79abd5ff2344c24478885eedfffd461216c5627c268089e8b5a16a0e5a41027543e0fa31480c212ec46cda9dd4797edad82c9fbf385825214d9331362824742a45970dfe90b3a21d9ea124ec478f86011689493cfec428f9e78477c42340c207ccfd9088861f9897815185850117b8fa94e9ca4b8684746816948d47485dd40708bba1c218e0da74801c05b190e0412c20eded8216d4871d6a4b869e65a1ae2462f1ff983a71b757c8c42a8dd375130c6a32121d22bda395dceadca9d2bbbf0677efb43fa0ded84bb0f40aba920317f0436b35f96c0d76ac9be17bb87886d4c745cfd416c4e1b10aa370ee30174a760ea796a2d265af60eae5f6a6245bf28a8c3be279d4a1781e7e1893158f133ebf1d0d7460817f465765a0e545c8d61b0d2547cc023e62ad2ee741798cdaa218bd753b6595c6076c8d1f0da89589ec7b07f3671d098a0479b70040fbf3437cbbb81b60433434f2795328a0e15f58aa42a61654e29332cfe10d6f25efc1b5d40c0520b94344d9e463a501b9393e6cec1fef15a55807dc181bd0b75faf9d0324c9c216ff41813fd617de51c93583ec0123982bf6c1749db84152357d2ea545087d48b89a033f4f54a8372d4ab56ce3b1ac450d81f69053ef372d379a1c7a0540ac7a24114711e08f85ead3870bd92d92db746df7cd7ba24bc6ac19eb8e1a08caffdeca19502f4c90337077113f211db1055bc0dde8fbd8d5be02aed29fc06962e91aac9dd3d8858374f40dc06db90f9a9e588e6f6fd90e20b9063e57183cb544e726ec5a94a02839308859f2cc3a609639647c80e81b0ce86376bb8b1085080f705295010f1d3e3912634f6b603d158acba7abf7a9f815e919988e16aa9020e927da69bd4adeea9afc705d5735e81e5adbf47643e88f9629a46b3971299bedbf2e05d1c0ec7d4e7c3219b256500df450d9042c2b2db7fbcaca9fbf282514d673b03514b03c706504d281c1fb9af02419aae94e1dae558341596867ad56a2e0d3a98169499b61e9c095be1ca01b09be153adc014935b2ad29b40ccb45f52c2aa089d9288f5409038acb2094078045267b96bc6596e498ff730a34f6a4fa6e2c3828de795c649a2866029e009382fec8a0d92e90da0cda6c2b84992ff75dc7be6b8e5f39be7c1ad5c4fd4ac5704bde5a2a0ed77edb3cc47779770ff44ac4f7be53e739bd0799a420f46217d1e6a9fcf876111c796708b2a508b37088aaa3975ca087a05ae7c259fcec9d83c3153d1f8f5eea9f17a8d6412950c45c04e91c8738793e8e21832d7a2a2b52755452dd17b53b1520d6868a7119f94b56ec3bf9ec27754e1f8ec30ee56eca4bdc4009a60f05d3618ebec78d266e4da293bbec28b05999fa9cbc8abf8c2a95634d1996c1745d8654e0580d41d48765eef94679790861f22f428872c64180283038dc0c741573e28686907140df7d5e299e6c5b8a2ef05ac1ffd1950ec858bf4780ccca2bdf06b42c20c51df415976a08fdb1dedb0fd7d021e3e1c4b2dcc5d5b5d77a24e671260a4237b29981e0a5c43558a1b56e636f97ff5169966a2ef2282a1ee075b6e00431a936e130e9a820a8d9ae34191240e7102eb753c8263f83afcfe1624b4065d3cdebf60c476c1b852155f6f8fcc3b2bafc64d9382d1cbd11d6e59c36f1272adc52ce743aa3c3d9c96b99be2f071e2704b32291bd74a80c2ca9ea9a26e25475cd658f864678efffe1ff456d9276370dc58315333e6096c1f3ffc30a1c4159a64c8591a4b997c24c3a32ce7c1bdfe84eaec3a07d0b7b6fbb8e374864cb49bfc3ade10d9babc5fafe88279ba5ddb805325d88d7bda0e4f229cf694e2a2187f894df0fe1465bfa997d8e10c66a35ccac58dedf0d3a0010b24e6a2c12867e83edcad13cf7663ce119bb8d48c0c977e3319fce73a6d3fb6e9b10a7fd9893e3d5d236c9cb03b0b0ed3680404075212903fbb664189ab5b9d3c5489349dd64a81dba502dffb2f9ffe2e171b36f98eabe52934f7d58d4a893da075e9cfb61d7f80d53668f764bbdbb2a4b0822df2df6beb583810601d36bc0c180e3683e3cbee52cb4ded0e4587c4e86d9237709c9e2c93c93e133136c4e3188bf25b8665368e489bd87c0e407faf38ed0f8f526d25d073aee60fd01071defb843bc933eaa99d4c1a5bff5a650ec5143ecd050a360f9e75cddb7f711fbba8ffbd2df4e509f0d2614d0ef85602262ee633725de6d102101ef6d8080c0fcbea500ea1fee0f981b53ffd6f77b735b2a5522b212d201f8a7fbd79081ce748a4f95779db0aef77eedc3afe6fba12fe1a6414c2f0ee5133726827bd1dd2b788f759cddf5b215878a2cb3aad2d420a6574352d733d389c02d19788e4bb9958bde5cb86dfcad33c24d195d56728b15614ea4a4553e290606bc8f0103ff3eef8b7dabbf1cdeb0db1273f37de761261bd966393628017534dccc4f3204588bfbc37760dc4a263944fc2b35a787acc4f6c6e912c458a08ce238ca2e104b6f8d7e7d43dc03bf26e3ace8ea7170e18a55256cd694ab3f32a3d838351ec47add1443284f26f0f13656efdeb73ebb211cb726b28c5f1c6519193212b8dbc8042873525d136da06596a3f4cfed931766ee502e6a1968b5ad5fae3e23f41aa4eb59ddbdaf57b75606eac5d2d8cc14adc5be57b75738d49248e2e611e8e5d88034b2aff775df9f7d36f132dc2cd385089ac4e61c331d30d995144211ff08eb37b85f8aba618c6d3102971f07c0dda6646de24e3f92fa323a029611f0b4f9a5ccd6e14c1429e4e10948eeae99f1b40e460a17e29cad00a11d88f1a4fe7055e0131a7b2091cebd4d2cf1e0c08264fe128cfa2f95a2910b37d4ac2c86ea313e45e02bd49226c3ca7c0e8e3573b788deb087f94337b62c134b12a3291de3d35848974f950ec4d77822c8d0fbacfb3f814104fae5c3c46bdf0907617a07deb27bafb0cf0e82f2a103c0daa6897e9e017d988b103842dd3c258b4b5e7a99f77ce3da4985507132212e56558983ea53e23c52ddb4fb149daf24cdee054df3e3f3863e40450f2ff1d892306f934d98e029fa929fbc799010883e7f5968d932bae83613f008043a3abee220b67315e0bb8c6a89941de6d4b90e1664d88cbbf4c9a78eabe9ee1809fcd8b87cd61e8caa50b663e6b308921fe509f29bde6deeabf577cff906883ec57eddca4d29d5bc4ac010ac5ce2a14ece0fb834e5e18b7b26ac6bd475119cf9f0421625071817b146c5a0e751b952fac022192f78050370ea198513055291067c37b37dc3b51042815482f41dd007a5b7c80fff57c941e1d7b1f01f0b196257e536541f3a29a0723e718a19a188aabe6a20d630a466cac365d1f95be9484035d100b48b29e141afa16df78d8e3f0f1c9e534489be19d2ee6389811e86207e601fe5afa1824d730b7665c0ba55958d68f7af6a7eab9ed802cbc32163a2418fef7276d2eed8210729d0829d63b1e5a5222f55dd2b392a8da58b34754f3606cc2b723a5a3ece8f6389baf21c95d91d4743e1666643ccc15969fd5141714b30a9a73d647f7dd4b4b6ea2380b9b2a33cfe202e2ce94f615782dfe4f4a61c0868be12d6debaf37318f32d3c59812542576e32ce58b4aab773f2d24ea282acd03fed7e727bb407b2da611f8c1f59ab4ac8cb515a1cd96a39871e5bf0cd7237665f2b6e7e3a805839e3bbf2aac6808e8b0434eea516d7255366e13754cd3cb6439b6dd03a5d1f62aec269ac1cf670d4bfcbc297d4418e823e8d63f2a256a142a31c327f3e6ee40368f465e07255484f8068a1a46f5401c78a17b8a4c0c39402de3cbd71cb294f91c5a3d578fbed0207a363d35a8bf7fd5ebee5f7f3f5737adcd4c7d390e04a24b87137b36a74dd91ec62d197570a677cb4bf4b626056b51ac28632302761c27f6e8f4814ba7f88ff15fabd97bb8a4f9872cacc1e970f12b118f235aabd43fa8d5a5fcd509abb03d46c26b300ad24488c9291aa43a086e0180947840f0f5775e8c9b4e5af33e4897857875e22c35de80b0d249c0faa929f73ab4541fffa518549d436de8caf339b1f3a6456b35eb199cb6a05c82fa9e96b09a68f930e635e204ee9038e280094a783348feba6158fd8b41e3f8c66ea32e071e066c0b9d048caeccf5be097367484985fc5a843d5b0f001cec072df05745d47957a68a1121b0a7f94ff3d732f865b7789400641ff9a545f2cff2a750601a287c880f6b7276af38c4c7582acf5f41461df3fd5d2295e864e97a1533bd725654f94291737eeab7629ba4750f9118e8b131fd0682a253097fd78fe4267b9662cd7acbeebc82318abb7886688a835b18fc85b4ec91ab0207a4afa13f6ad192c09808fa5ceda217b17b0c8d5e7e20ccc7088ded78678f66300a2a982ea80f0534290694b16ca53e9b8e389480e7c2e2d733dc9e8a2378b7a3157a0bae8233885003ad7ebbd501fc96aa7cfdc08fe688c06dd261dac840704b43542b9e5389422846d5d27d1950c6a40e800f03b07900fd9c6564cd312480bc880d428ba8fe4812475a41c3f301b4af8f19ac43d371687a11cda8fdc87d4868f43c9991e94a9b53c51fd67b82d559c24451933eb22e9dede2e0946d9c61cebf2bfe09d94eee6f6e410c595d2e770fab529b2a2f9607b9b2280e320d7d6b5ca1cd6dcf9850aa300c5714f4dfcb6320332552bb45667b9aaad4118faad946cb3bfa1c3daee34b99756c7eb681d116e418fc697e0eda2d872b2962701caba7942467c097f3bba2068860181e3f935d04292c19816a4d46bb1dbeccede72b1b00474b1de160731dbb3029763efaf1dc8c5c6a2ea43e15118896686563705eb7c364d9d800912f1447dbe0a5ffd5fd92234eeb1e312132d7f1c7cbc80065252137e7f842598d870d800fe2c540285449058c09ed2f1b7f5171e8ad80d18000caf9840ed78eef4e07914efc0b3829fac53f21ce40d17bbd8c2ffc9ace978909d5dc244d55fe03bdc9e1844696b4f4d801ae426b0ce8a86ad3e16ad7fb324039be10bd8162d933b09ae8d9520be283a500dc9353fe8898b70bde56d449fc091389ae4cbe96d2c5ca8aa791f838d40dcce19b56ef6c92d88d79b0c9e7ae87de26d47cb540487b80ec513c7793d904038891068f0cf1698819376fa8b352ce56adbec09293568bdb4e099a58c716ae617b69c78c731a7038166a43fca05c2eaef19caa4c425053f957a47826175372a125220fdd58ab6f0d02b12da8b56926e04ec4a8edfe9fed0321aadbdd501a94019c2bb96fdea3ba2645d1197841b2add2fc5d5c837b3334714ebfdd60ea9b6d021fe7fd468cf58edd8c6ed1a90222c9874f3de69a26b74d322bbc8942abdd1fa622934526a0746b69b2483032bc7a789fb33bc94d826ae63769222b50a0a67be7f804ed819eb556fb35bd260cb2857a50cef32164bc6c414a78a1504bf3bd08059109cf57e9611f55934e1179387266f1ec47477506e326f7dab99261d568f659379fbee0cf38ae81c0cf988e250466cd033a70de8dcfbefa0c58c2ef707448cf1aef0b7be9415b08e1df101fcbe2b49d1ba5e1c22db2983ed9aae7a6502af143a479cad1c3221750fe03ebc24057c111f856b36dcc3b01f127bc283c69a54ea4b423767d06d7a535f4c51d648eaaf655343005c03e4713733f39715467c129436c627b526306527dc8d965421ee4921310441ebcf07dcee60d92a87e0f3c11f1d436681e176f8e81a56f78b20e07608a114653800c8241194c14217bedb270d0a85e61eb993a29576cf77cdaa2c79a4c9b5026e1172d0a30a9c57bd3236a770190846d0be519b60d058300a18481c07cc0d342691179e2ca010aead2ea8dabbb103a2a14b3fc8aea0f9944f75cc2bc48cecbcd0d254f89fd473f2f19ba1c40cd0e2d26a1b6d98fc92e3d585aab68d2b38ff988f7a16c9064f9bc968137ed1c73452c009a228b8ac0d224352ca052617734cd24c610cb1492250854adcf81469a4701f8d0d02efc3e944dff76e86efeedb3d8c8e9124b42fe6c81a946841abc3490341ba4ddebc39dde83466e3918398f393d66f256664bd89cb8b57eb423e425035bcbb8486a8715445c80fcd6c8dbd335465fd4530abb41f6105525ab9d83cfe30324fece74f59123eee3fef4f25fb25a9189124b55256fabe9365ef435e16b48bb78e1b75fa6a0ee1e4c383514446b4d72e95c2e36555a3cad7001210e4fe7a67c36cd58cde12a657b1402ead77dcc32db34c1dd34a3628c9b518e5c2695c437d9d3e60792960a7ed673411feaa3cd07209dde7e6c0156283eef6dda6bb9aad4c57dd05c1792c6b607825ab0b47e4a9e0c267748328477920056abde478941f12b0a8a38fe9bb5f695b84b82e80f24a74f13e96b1a8e0b255022170b2eafe70d3ce53f65c9afc4fb8348b90598a9617b66591634b525657e3e24b08710c06c5969bfc6ce0d24ade764b4c2d857ef0db3e50b5196f1c5f1a827ceb5c7cfbce58ab28d37ab1dc9ef3a0c8ecf252b806c684fd4f75b18279bf812e51e4350b4069c9e2ae22dd8f181cad06258a8c4543d88f35bcb540c95e13347d560a0ab67a5a1c135ccc23c490c7fa3c3e934020ab6b3652fb1c6b5c819c514b582ad5a66c4194ee2a5f4edde7d824fb48e8371ca629667b84219cc30b0fff6759aac367349d83ef960ab6865acb24a6a7cc7eca1e8452012f01dd20d2b467ad84f033c7881c262fbdf4e60c071c112a9962102c8002d3aee0bf2378ca56f129da8bbc9c049330010936b92dc63e9f5a21b998630eb5882e2b8bd01517c0daaea8af9aa2b2e54dfb53ad7852c95c3b32a3a46cfb7cae9fd5340afb0171f63ae53744da451796bc30f3aba41f2bb99bcca0099fad28ab7a813f54677c639b4bc962b5a9b77b24e0852a29e4a0b720a926bae75202b9f2a44d811e7c823b77d8219fab97015e10d8e549aec085aa7927df32b558c02fc4db9c5c7b81f5f3d9a29663c3cdaac81f0f1c167405ef2e8e2abba60a463ddf80d1337c55d133038429ab6217a81908f5b9b9b23517b964a37fe090ef1efec62ea9bf2a14fc7e18ef3165dedd63d3f1bb2c64b925b6bbf51fadd04de5836e74ceb5cd57e2cc8a741b6d6e24145e159d1a852235366816b938492f085d98bedfa8a955d58c7cd73d9ae548a7e5ce6d0c8b7291548280e3263408800231299049872da1e42116a7bfb7afe14097301e2d0926116728eef9db938d209d888921b8aaa12993f6570e728081aeb50bda2c6ffb5fe9e9d98e33bc7df9d952a43e140d6a3b06e76220b769733d9b81bc6c2c7b74e81c33fa1b31e0dede5df22b7c189e1848f704dc7051eb83334187b2112a43bc0628f802356719b0186d1caf84238b2af6cf719e61a27f640b3ecb06d33611f929f6145050c43ef8718cb099ee9ce4ce008bdfaeac68b59ebf36024393e5cf679ed5271f8d53539eb40c316ede5009962324cb1fd7a8beefc1ed507d97174cd7e7cc5a839f133dc90d0fb171a8200c3fb463651dd033dab012b34415ed13a3afcfc25ddaa462d1420c6a86410be35776359938bf3ba99cd195eaaef4709754cd6000c7f0e0ab62f49a92117f2ba9c603ea143f24ddf45069b263db0fdfa2f09697ecdcb2da448f9d53e0c029e068e539b8c2dfaf76d382f9ea8d95304f57c5f0171224e85262052032ea7c2f1a0083bc4822480eb55e2e09b504a5a8bff361e3378c38fe8c20151cc774a8af9558cfcde866f858e6459fd3608b1e13db70ad36cce5298769b27a8bbece2c99dc99f91089a506e36e42d6baa71d396735f3cb2abb0b3d6250b83c0528c2b412ba00be3c95ce0c83e50ef944f05dcb454bbf7c60ab8ecc2ae452d0beb89693385bda25e7f87e19a0cade78ebc2ccc1416076092a42edc1b52ad8f1bfeea5ffc8f91a245cfba7bc607184bdfee0033361d118fe7371b061395de9c712bcc649b4a95dbec8a29ed3339f83d5418484730916d243f7a3237476e588dc8a5f6c72e2d4aa88b29159d5fef08291ef07444d588221a63af7992fac83ca35409e09c5bc23a72ad641221eaaa098c90cf6383dd0219c6fa8a6efc24cead13fe4999642619c61f7858b484264fa17ae8da2ad05e86f1a50b537f1fc47ed14579342f1db00b1b85d2cb9cb5b53590a0878cd7423866961ad5b776c6828fb819d78f5a2ff62792a53e8ce6d2ecc94a3a1cfa635b8bf9a5a3fb9e61888299662ae648047151c46e303264c517b5447c3a095479edcb64c65b76cc7c5d98b6d191797d9e9605b5b4606f379761fc669ecb196aa76c9165a8e80e2c021b36605729d9243c2b6f0419fb9ee1a905cf82adee5bf298d297156f1e6d943dc70a3fc40c0e07c59e9a9866f6b3119c7549b05bfc0c1bd3e652f4751b8d56cdd52060976b4db19fa827e895efb7698ecabbd038c7456e29de81e1e061f65075f4c8244b8d4c004943b266402deab8b2921e55c63c5fd751782cd0201c78070b68a5ae6a2b21d9fcfe3ec6ed896f4f3386c4365fefde1b6de95fd9c185238b206ef6e10ea6dbeb4e1f9ec4686d6c5270dbcdef08ed73bd33053e2f84df5ce6bbe5d4678c07df817f9e0f9a9baf629483209dfda20577bc5192c09c89238e8c98437e22a4b46692f003028a86f8fbd06f251d6ffc0e9207daa01de51c1563843888744a73d8b61a505fc576d26265e4c5b5d232b2308676189173f20d26127276e98d40b9a3ede0050b2d7c381b7c157555bb16cb36a9498630a6aea33564bb99bee57596f0a92de5f3da3f8801801161375ac220c96acd41537540fc6397098681da7fc45d7b1cb940959f229320d70ac517ead4c59077e46e9abc8acb386008f2474e8adfc9162cce5f7375c3e001e84f69498b4c7b67b64e62996e033e9ab04d7b439a04e8ede2510431b08729ece639c07ec3c9e5d7dc4ec82668e08e1b7f5d6489bd065e8fba125f505301951b0a985c7f66cff44cb49c7b62346c0301fad1a61c6db6f5b09ef16ecabb60a83a24398412f43843ca833f1f363f847155d5daa59c17728f8146b315d12ca8c238eed165b0fb01141b9bd65f0e6730a32b3b6aef82aeb4be9f14b993e7041b327fe9f6142ac7fd3654c271005873a6a41d4a404bfbe05b77c3d94abb1003e7a9daa5f6e52bbdba3eadc26aaa4fa43be755a6634d5cbbc6bcc87668b4245d8076af5defee1593d2e71e0ae0b269b18ce6051a6758669b4eb5a6276d280d7f870245c3b185c92166d43d6f026050714332d109fac8ffd3ea3ca511740b6d1d0e4d47ca048761a79946aaf5177c8335c3a622133500d192f412973a8160e464548a00e3261c8ab390fb2474ea18dd716bd9b062261e7e8f6e99249642e9aa618289a3fd9f6d1b925067b0580ef27587ef3fb9f23db0bd91b3c166d1be5e962b9320261cdb07a8f9df29fc698078a46b9c200ad9cfa94077537d8b1aba332f3c361bd0f8fed83762cec4838dfb2d861f48f1dc41636994641975336f0a5e667964951c40aa070a4812bf1fdbb01d8d0b73b37c3886837a06522a61d8f396e4509eeb0d238bfacf05ee7afec6b713a22be268a8944d7f0f0a44e3480e922bc0dadf40caa44542c5a2759e4331a975ab10f9094f1b56bf23cbf8d15386ff9d0c5c47c6e0cae4ffe5046c4da0ed542ebd3f8869fc872b1b71a866add2f050d7eab7d293eca5a86b072db2db7283091c218eb969220fd5a3f3d18253a23c0852fba7520593d00fbb7b03a783bbfacfea0b50c41d4549a5c3582f0299f0d5bfd0f8724f06fee71eaacc90724271b09b482a3ac4ab3f14b5c4b356a0b87bb83c55bb812130ac77fff131eed246bbb5575c355c241787232eb2c85c09079d01d20f1dc3f04f58df90becabe2ae8e4dcbb450b3e207d64be969a4fd136a2f8a051240f38a6f65210a14e3ce9eb575fb0774b838a8341fe90959a29a80a892f5e86a819bcc41120162f2248a13da26ef90785f240bd398039063e7d748fd124885cd07ba3536280ba47baff810a84a828e146b5219bfd08dd867ac61d67a3a85ae181f3be78e15d4eb74737bf7f79c168cd836de2c8bfb2e21d4fcb049bfcc594607c425de3ac4bb1459e07dc1e28f1e02e547007825fa1328034e7c2e18d03be8b713b4f21a24cd132e14ed7cce02537fcfe7696eb7b95b8ae96c0b6a8e003c9948517fb617be3ea21f5678336078c62c68b460a88541e235890a90b7282ebeac89c44b700d3f1513da84e1c9b8fa5819f5e6dc916acca2723db81fb1557659c8ccbe2b9e35b997347c4b5dd168d0ef4113a60c1e1216114d7d60585ad20f651c76abaf908d6da96c20017f26f6702ae133d2cc70bc65c43bf1e65f697d2e916007cc0c68de275055c71b0b4a35dfd21fb7d64633a04db23f49d20bc194fa4f72c4a5e08be701d0f325a0b1340e3ace5c979606571cfe042cffa80ca1eb922d362d1b968f8750f1b95d200c45e9ddf396b9f5563d7b47a1f1fe7db27d31bb6f415b9de9f32950ff0b443e35bb8d974d1fbe2029657c4334db586e8c440021b1119a8c87a3430e6e8d05978a21ffbb56347c176834fb1eec0da0a6807743e814e575f3a1173d6e11409af62e7ed7d160ea76499b3849dd551ba9ebab0a1e4f7e89da279e443c112569c9ef0848e9b88ff4b72ffef58c9eebbf0073fa80e4f38892c6fddf1e9ed68a44ec631e06fbc12cc8106d7ce3c89172f5fc37e65608550fbee699a7e788cb95e0fae5c8a36ac4f47a6207fd557fdaf3cf465ddf79da157652a67562f66683668990200c75138a4a210e439aa8a249e804423807e69890ac91c33febcbb36a947dd85a2106f22361e9d93bdf7a259a9c8f9b4e0818e432ebf4ff1290b31e282237ccf5cb17f42b8cc57b9e2d73db46c8d8175dcac384283f3d841c802af8ab43051b9c9ffac2148e8da667ca6a2b10ba1ff67ee4062bfc5fa66ae5d7a542dc197bd3bac25055683d719bbec07689aaa7099c3c00558745e7c1cfa938e05ceba3d5ee9cf2e0b7048750045011b9133d8d63ab2fcc076c41fa26bce3caabfcb5949af058951d9ac53c22c838d68a4221c28b3180d38f1c8b46f3cd4d9f3eac2b941dc718d40916f8311380703518ed721c1f042d7d18268f6e2239166001ad003339fbea7c3fe9c9a203a50e3433c8fe633879918975a8cc8a5774411bd959f69d573b791a2360bdb8c1ec23f7d5e0427b7e6780199c81530dc8d21c12f14a024f03e220a49b4204c88012c48397306736c16394d090c096fc0d75f5f1347e128077abdc0002016900d5fd6ff70e360b6ffcc1f2bf3c03b6d5e1496cc58e8ad0d6e162847c1eb282b5909620187e6800a636038096b4d4cd9f097b8d2903e531bf674e9fb159e34b1b1050521639f9d50f083fa5128c1ea11cff78f022f2b9c6729a1732e93258cab6f88502f6d7a222ca9ff41cb81703726a7f250193ce455ca70f3f918388562e19ae35e374d6aebd4763d226caa9bb28915577eafecde1ba5f28b47caeff0fa4ac42608066a6ecf646ea4231001d0386743d6462769f81f71967deba1117282c90958d42bc335215a451f3fda094e5c6a927a10c10312188944cf17a4706c05ed4e344c37d3f3e0b50e6f3abf3138f3b5e2401c84e10de31f09754988793241dbc580e656837604d156e3d5abd96dbd549e9d31c04b4ec33de7418904545294910ed2f60c70d3aaf74325f38e853b9a4beb41ee442ba49525fee31c2d4e4f2acd9913a7d584a13e6d793818b80202ed4571a626e7bc3e4e9fdcd3f44521049f63bad551b6c733f37545abb4dc07668a2f51e99f35d4338de4638588c64d0a17619c96f6920884441bf7d563c744681108fa96223862ae7bdc4dbf46eb1c4adaa31a40ec489ebed66921e3d51de1a31dc6d9aab594dcf94eedee1ec71ca4196edc8a7674ec33129bd56a616339bb502113e16c4e888b5ea4aba1c5520051dba1b438f691deacf598c3c9151c28df5961fb637feea239dd576582a441787b5f364c864fca9c4aa1679fef747ae3f488fc032921a30be9ec244585a2564eb7065fc6150d1b621b4026013e5abf5d057b53190f08bf10723373487a637355cecb13dfb6e29313157f248c62d3dc2308daf3f254f06f3f70238e671e7d9440d80e6a8da5ab67db447d51c519121fa412fa23d011afff5f8c5c0be0fab2b2da751d0d16adaa32cad97e7b753a7ba0111ce340114b38145c66af14b10f34d600a5782e15790f72b7abe4b214d040f843e9472679fdc9df40679c7da2177a6b9cbd087dac25433e9e7e549df68eda3221fea3f30d081914b7c9a204986c846db6ee2941661e60874f8b752afa147b6440c53965c1aa75d3dd457c9afd7dc687829e85c384efce6a6b0988789320372eddad3e957c20b7c03ea4e777219d0b636442f2477f060dd6385946d2df75bb47cf4f7afaeecf1e57b74ed179e9aa025a29e435fe1e7f7b7c3e8aad1e88c6d608bbb49bf0c07457f9820d8c9efde01ef6e8e72a8441f6f4b98e02c9a527ba270bb0f922788b11bfdf93fae5645dac0a6352bf39ef36729244a0245acf3ebedaa4089bef9a624ab56d18f03e602f773d8e6280ba3635f55db76e6a00fe2bf95e564bd954f1403dd3be0cd9ec81f185298d9ca704de1ea97f7694a973b1f5899bd67f12efe210fdc0a670cd4689cd43ed8e56383b01b84074205f22f47b8933f5954018ac8d98e61c6573372978f177938c1e446a80284e0c28d23103adfaff4b27d24329d1d685ad791b957dbfb0fdce9d208adeb927d9874aef367c0004c13ae0a86fc3fa18497c5fd8ef2d92efc176feb21ddddb02510e9888070ae8a517ddbc7742bee4b3a1a03a03caffdea17fb3c886de783adbd0750e388d207babb1e7de82bd80ce0bed9e949fae977dabbfe6614a4e881d0a51289672a5ead9a75dd32238660e11b59c81e48df6a45407582d593f8b3f34f79fe26aa040c5ce6849287c31384326c94edbb2744472929b3412b4b084b996b987afcb18c24b8ae4e0550b5c0eda1110111a011ea270c18852e70fbc38b29722e43fb0db79bd7736b1f0fc519e3ce6da2acb6f297bf610f9a7bdc60bc318ca762af290043af03e799962b1018f497b132476b87515dbebb7eb14cb1c28e587c58cbce3d33d66e9c90ed6b768795c83542308246582d4333971824364a40ec7c3990e73bc0b9f5d4ae59145dec0809fadc3e0160475703aeca8a9088530bb7c95d4aff4b6ed6c9d421240b7b815248c823f03397c85e2a41c29a94eb3eae0232027c3d82c9265dc480afa612fd78159eff068e81da3acd5a3aecc341431e9d86a610f2bb8e056707cb3b9f044aea4178e78bc7f0d062b51a77b41e6932f133d11075b4861ec78b9c2ed8994e2921597a07a488468ce35fa15ee4a5115a5197f62a66329a7aed8962d0e4fca1e4e3e7f92286fb70cc29f96fe414f43975e9f1379323f2cdabd545c5e6b6391afd1f2b30ea39c5affb62ee9f89ef15277f7dfa2ad35921f0b3d2b7b87df6922f8dc7c4524ed7bf955a554bd5ab27b7e761078daed1dc56bff2b50643c44ee6a54dfb705469fcc90078438e330365e89996268fa47d9792841c7b09f9df2ec14074af02cb26b708c85943cd94364167e06231e4ba6c31e46213787ccb67e6fe47cc5e3b6bdae95d6741660898ca966bfdc8b434b673385ee702dc321c93e04563cf5cf29e95e190411f7f1519b0a3ce6339759d0753b56028f702dd83be8c7db0893ab19dd503967060607b7425838271edb2cd2dc74dc530760483186771ffd0c9bec7bb086c4f420bed030b5424c1f781f3f9582156f54cd54a8eea0371bf2a39fbb647a9be623314c706390d2f1cf636b883c543c08ac7ba16aa77ad9a4667b93cbd15769a0cea2c7e92d600cce287f8b73c11497ae1f04b54a482e9a7573cf022c468a2a8b5b02a714cff14ac4c7bbf127c0fcfd47f23f367226806faaf7682b73b178e13429154edb5e544c88fe63f4305ff4baf5e7b95d0e53c4885053be32053ae00db3f4f052d4a30b05486a1dba7c1ae2aab3bf215078dc9a632442f09d8b08e9b7f5106eb72db85f72d7c493624505abd09c32e6cd49689cd0273510ff736057bb1d80471be62c7fc1507c11ffe57ee1147eb8d3e2cc2dfb8a3b6006d9fdf8bf67270535d3ea01fbc055c7c3640ffdce3a9cf878b0b057517d7fa73ce7f752a731676979663b6321f93e6c32cb615ef3c3b2892e16a83b1dc250f8902d28ff9163647a1b2531d843be84368ddd9ae942aa1e1a912462172cca85e91c173703a90ac2d0a65266a1828639a47313bc239eabe79412b44e96743a004299cc418c7a733d5c1d5940475d0898c96274632f5811cdcefdf03ec5b1b852b89a350eee2b0eba0ba749e872bcee48b8991781ed4cc5cdc4c5c7942ff8429f3cb818307b3e9e359cd3dadcc8dbcb3e0de0dc05b0bb814d065ceda06f2d07149510131107202279bdc7e3bd2677d51211f5865da3c003ba4948e5160db9404d879ef3d19f6b420c1613f10a2dd068d0424b18b7dcc36535aebf215aba4ec8246fb4c833dce17c83a06d4a1d00960bb1c51af5d1c57e5fe237a8d665197b2e42c956f8a1b262871ca2e791d1a93918ac3450284f2b143197a36e303a9bf624a6d445384457a4cd8bcbecc86e83af04a31bc05723f1e6cc7728360f2905e2586fe02952dc6489e33859abb869df56b6d6a46ed518a7bc9d221e58ee918444c0168e74ba8ea96415cd1390a56837a2b41a6a975af0c830bfca70a4f25c644a5c83016fc3b945f40b67c40d4328fba9aa4e6b26acfb27bc3c9ebcd8efa820d133cfb260101ea5b83ae634200bec90366eab172bb63cf01838b26d2004aee5829c1fcc1269863bf9ac7836d1f74f9e9ec631a9513d2012752c610043966be300618ed5aaae82b05e2ab33c1e0297fec247169bce5b62ffac3614721f4818abd7943eb6e6064fe2eddaf09c2f31572e26ae93bb008b7ae3518346548de1db3676bacd119f3c2d2c9d35e3794bc0d95d788b785627f69534b48c82b073d39ec9621821f0221cfb998d3fd1329e0586fa1909553da42c83af706365a35db5cffaad4e830bb5c71f77ce9920a4c7029a406f6bc022fd1a3faf7784e6987b8927d4e5e382254cb38320fc2b8f2a7491b29a5f33eca1e84fc073936b6b53356a808934396c738ba00034b8786e6a8868512d614efe9b33c8682ae3e56efc4832a1b4cdc178b0f865e3eba0e0721ce80209ee56f076ea7b622c39981a0243e5cd7e378d8832637f13891a76ab7fe9d8a5774e5bae530dc96bb60eb81ca340177e51a562a3657b6d51286eaf050dffa9845889ec3a9bed78fae9c0dca40e52b31e04cd752aa97c6779f0990afc40e679fa3d10ede239c3203bf17464b0366172fcc7647c72ac7097f79a822194c0e52fec351e9664096ab892be59ef697786a5d9e1d91c768037d13b4a289767bd53f241c499a13f13baed4b7a09f44ae5b8f2d4c74f1e259f9fcfb987e33772e1f0424e9d0470486df547e10617e8a08f1fdc641a83eb4aedbff2a2f9f4aadf9f6d1503719b862958c42b4f1218674b47929b136aaf84cff9de88cd10954e2ef9481715f941bc38a8db262635971e359a3b1acdd6856d148d63696151bcdaa1bc39a8d67e546b0cac659531b07b152091549c06cac0213b78e07aef383d4f5e0753e409d1e5cd783d6f9c07572d0ba1fbc0e7cc05be707af7bf8ecd479e30e1231514c69cada36dbfd902c8f19a6143d8bea66a014fd10a01debdd63e222e0f2b33930c137ba7be763440d00c7b83d756c89cc02a6060450c696804245d50ea43794cf10b03db03f21ea3c7a1b122e464cadf9ff1400fdbcdf1c9e4f7f043b4da142a898c56af9454af79d857782f7636e58b4c8b5d41536c325002a5be2f4f864bfccf4ca293b152b5c1a72cc1344e64996d167ff1cd4d774134e2176a01ea4f9f678f3e5ccbd83e3343782d9f1c87dd193828aca06ad874e712f65d9629f929ca9d8fbb16ef6b4d4cf2b12e84e91ba20281cc94adfe7db2bbd21509e6e482e004853fbe03f5a0e422173e95133eaca3d979fa0336f0477d478651a9a9011f48aa8b053e1a00a1cb6cade011b03225cee9cc0227675e31d3e16e0fa102c2568f577d0a1613cc4643c24d0417a7e0b52f1d038a361f0722c10271326eebcde6236144bd1f5518c3dea46eedc3869e90942de91ca9bc2ed7ff2428c6e79380a3b1abfeae5dc9a358887f90cb10188e164e4148d8b97594a01b85f6815e2a483f19577335e4d91bf6f784e9e0ed0d97dad7bcd7f0ea53afb6be6717f8e79b6e86161245a8be2811a339dfcac83db3d8e4720baff9e0d5936b79c75713ce2c68b5ef389cfe8fd9d683dc112fbfeb2fa5415c74e265e4e9fee8663093eb4b48bd4f681800a6d6191d17351c52af7ffc8d2164001a9c4b20d9be4781ccfcb0a8ef2a54725d3b9e00568bc4a818cd38dd5005abf2ddc3ea2b79378aa0f48424ad9e0e7a09c8064d2a20c111afa95d31ba7113aaccc9067e6c8549d640dd307d79c53727e6e1ba9b854a3204901ec76db04eee47e17540c092c4eb500ad60e228b8a0c6d5c8c0ee9b59526b2128e1c33253624181c06b51f0a09fad74efdba1c2121eea0239cc40e9130028bedc45ec61d975ec288fd0e7d2eb5af9274a0d6f91227d9b1ccab9d0154845b639b524ee5b5a91b2eaedfba29c82af83a616b9d31e6d8efc9dfa4d2513e8ded4da8b17248e2e08687ba6189f3a96ad847a26de7f3659b89c77fb972868e1fb547e080edb9c42edbbec1f422f7d46eab45d1ab5713b516ad95a22875906ee8c2857806c4ee33823fefcd92df0cb8658ebd950de6b58be2a1cf4fe9aa827f06622307924c1bb4b1b3b59e7b8d5ddfec7322387820884cfd860174813567db4bd4027a91a49a7801504782f37806426f0e19f74a4f59c2004627c1df0ee635b2fa6b20f3a82dd761ebad1272e58cb1d82f7965c320a0306b3d767ece37077d5cbba293078d32f357f0eb0b78ed9cdcd921b5346ed56fbc43e18918e8c772875ac17d3b30658a5c90c0621b22d2e4ae82b8648c146bcf836673f5eea9ba5896051416d84268f7c3a5f941d615f3107d763a26d914c1b6f04e59fd8b3e88967ad9f94fd6f455cb8b571ef473f5ac9a1e44b760e4f1ff15ad2ade6ee0104a53a98af813119d4aac13624fd6a466195bf6505f6941f25d7730bcc2e08bd0c15343665c2fb2fbcefedeb848994b6b0a927819873583a27c61a18cf353aadd06d2426825469a1b4c5fa3851e66d82aaa6783efd75b88738e2ca7156e209f8d75355572d5a65dcc617122f112493ed94f263033ca4e908ae38046c3d8f2bcce0ff1ae2c1b26db62f4db4e2dfe08cfde841dfd2ded1a96b6c15ba2ddd00ec5f49d6ae60496bb8b36806469ed07a2391d2d692bf3bafe08aaa1b2a5053eddd499dcdc9b323ce93997db5123135a8bde95285883f3e3d0c5ed3856a52fb79ef0cdd06914d52fc9c1c00bfc16a9e9248b2ee7f85ef7a1c1775a02010043139f828239b722178474a97876c431302dd573bc85f357eedbe6d71a89c2d07ff155c62688582d18cd591e351b3faa04b17b142f16ade4a93bc6c1f01c2b542baa8d92b59e11a88d34d0b6f47a7665e9174f7bce57e62ef90f7c939f2a87266f01b400788defaffd5aa46631ef391bcfa234ed8179a9a4b8a74d19bfbfb87a122abee14fc047e65700e2a3c0c3c3185edcbe20c65318278bc1b90824ab1de9a32e1f805afb2c00c0a156c5fed2dc98601534e145903518c896071d02e65a9f7e9453e39d1914a78d11dc2ff8390272e0225a32f75dfc239f938ca5ca29e568e99ab18a301071436ed07f672e29ea893fc1aa78368964a99b69a4820fa1ecd2b5e983c4b1685dce83d01b301c3a146ba672a763dcaacc96bc7be4ee0d54dbb35bb0c4a23f5be655dbc8e61ab15f9cce82e750673df208d78ac87fe3a149802951309f5e7b247ac1eae45d263e8905bba61a51ab771d43c2d23ffc00bb0a4fe9a8b39083b31dae12da68c408b61a00328687fa847cd8afb8eacd465fbf054acb2c674c2c244ad50b4af5afc9c1f666eb836545297a7060bfa7da8bb58300e76e4d31e5224361e4b5e45ea3b3ea172586f46a95901462ee15ba77bbcaa867aebb39b656523f6ddeaa9b6a9dcff8c12433380fa617996c1774ee499986c7e6b141e37f1d095f2e102cbdc4b06b655d5e03de7990250d3f478879ed20eaf74d9285be921c1f3472befd87120eb9a968e5c6c3bb772ec329a369376795351a89aa0d294f16eebf4bb50418448a7156dc385a5d5f5f8abdbea74f13ab2681ad49d4a7bb4d4d406c0f2fc3f0993b498cefd1991b1f75c0858f96c2e49d0124aa0e2ddbfd5b0c5995db19e23d02a222db6978cd045304c266c623fb5e4311df671f70dbacc03fa16ba58007701f6374fce0ca1d8772065779e287442a30ee2bad4e088c503d85d2a4e71d2d666d170dfeaa851a38188c399344ff04fc168f902e9bb9237e159d3b48b5c5f609f147826967f05526b550f06d5c2cdb200126a350ea6b54c84bb185876399602e85fe9a3124f04dedc454e2e8ffdac819505c6d02ac0949ef4f739ddc36733a6f7520846d4dd4aa8e618977a2343b2253d0f7e617bddc79f12b0404b6f6ff839bfcb00498ba49afc0b3f7c4001da0e7556418c0bb4d5cb3771c88573a6a4c8457abfeccec09215eea152c4831c1a024f20897660fad3ea0d2f678e9dd897f73fe8ce398babf8a87a00650a148de1e07dd59ca1433c15ce95cc18e65dd55a26f0776e51225ab8584abf80752f44ee6e67c046a10e37360e196fede0fe1038b5d2b6d1243d8a5a6a5b8168deeb0204172cd553ff26861d5187dd0b1848a192f7efc1e73453ba348e7f788f76449696fba56f674bf9d59818f58251325a4c5f10aa2812544c2fc806a14b370b9c446abf86adc2c98dd83ece888a78a8ec7407895cdd33d8cea1b9cae92e7f9f4e8fec81232064bb7ad8c37f6258d6dfd0a760ea4f4a695d734fb841b760789b1ad3c8e7934e5b36cca5bdd53dfacd927a3abad36fd7122722d0c614e4d282b711281a1ea444275157265c6b7714f6276876c5d34c8ff3ee5243f800eef3a1132cd46067b39caffaea48409536fdf4b09acc148472185d6ce77904be2a7f25e24f500527b43beb0f0efa1a4bfacc3c92bfc63a8b3f9c06759b2fca2297b65984dfd4ea47c62db8a08395a99193686375e2f4ab81257828e1069e95f4fa12261ae6dfe55896bf1c4321eb401a6945c98e234b312fddbc527e367ec353fa9facefaa4af46d8d4eb4376dcb97dbb74f90efdac7656938555eb49b47ee78eb81456501ca11d6df07c29f19acf71c75d9868d3f6a346642aee4d1701963eefec5ca446370d11d7eccdc098220779e359418cde4527a0115c1b0b9d3d22800da87bca60184d04a21ca40015b01a21813115420377200e3284805600befbbf0506e61c9408ecac7873d75c36d222463fed21a0935694e159c31293b6adac5e28375b6e8d8f8ddfdd317467251da698b8429c019584e7e1e3c7b62b590d1ef9396658ea5ce3080697b2d0352da18366454938e8e7b6967489d75e70628bf7e02cc134956693a4e575156549ba2d2607108bb34fe78186fe4723941d11132a799e7b6a6e3042dbd6070a80ee9d048e7ddaf19ac4bccc37984909e4801772b7cd1491def5bbbe905e4424bd8e6bcc19a2d7e7cedb793d75efdf173b0b17ab4944fd7cd7143fb786b67a3d1cf298177c0cb21e82c95fd0ed039786c5240eb9f2b504e5262eac612f9872fd781eab41004a72efe87ea9dd45fdc17085569afdae8fa4fdd1cecb5e8685b544831171aa89cdfe478ecf517f6e464fde1987cb019fa3ef4e83f6a9909f7f879723085aea16a374a2f0ffac47c5980711b12f8676fea2e752ae33252f626df3419e7e358a62054335d447329bc43860836af0f8b7154d2c5dc0ad05d2af46092d0959208cdb6d5bd24554fb94bc2a9dc4960d70bdd673d6e03d6d1d4964735fec078158822b7cfe44e99ff5e8249854b11a047c18971a49cce6b061069b02de621dd49060e9d8ef2749dfbc1a3d10ae775dc7d9ace45612950fff995d29b26de8c6bf1196d4bb52e9126201d4878155131f45d15c2d58207387d6fa28ab1772a5aed866f4bb46bc1f16894589191d423379b27b37a5ab4f389a49a72f728264c92eefd8c04afa85e8d1ceca4eebd7a1664b48ba68ae99cf01ad4b861cc533b83bf6d4d679bf2e113030fb2be0079832fcd115a8324bd1a7fc6a9b45723520371f3595b21c95c067040465a69e7387bf96265d710d6cdb4e089e35add86284b09d46b6f3a5d4f7c7aca86ec6913dac00b17b00975ad8b34c07a2deba83bd630542f280b22d768e9fcf7c2a4a3a8b86da35da3e3836a0b71281fb687de0e6abb54440b77b599e58f4eb163433985b5543dc9dd784d428a667a5787a3f0a11c931011e137c607dc3fa9f04ad95f6279ba63957cd576add37bb27cc52c0c127e25f7ad67ea4db2bd43fa52ac3582e159d726c0d432201ddee8e36eee44a53ffac797a95d683a9b42488f2c1896a773af7aed21c287b678045a99f16f724b3dcbbed1ea075726b40069a31a8bccf178e12cdb11dc3aa47f494ec00015095e3b0c586b79c46f0ad7ce1dc362f518d8ec4c628270417c565b6d3f996acb7fbfad6f81739681280f7d3f2e1ab93fad83c74e070dc4e099c6db654e9a0f7811ffbac96e853990481c833092b788cc624b0ecc0557a529b771573f664216a4462a5af7e7fe9f904ea42112e75f4fbab958a2439ae0b624141d1eb5a4e5cee7a38934fc4b9483c8a1adbe2bb51933a21adc42b1b0245cb42825fb5c6000574f7d0f86d41695d05aec3f6308fbd3b3de47f17e23446f2914cb83c462437a373c8522be3422a96532bb254e3fb80dc74cfa5f5af7075db85e8868f85b72e5a9c114e8bcc5af3d9680992312a0cb90fef5e29c0faa58fc72c973c56e8e24169171399cee3359587e7ca71a225d0932131587174f4419ad995d433e24abb8b156eeb38de9515448ca6a820aa9beca337b53cd666b6503e5b01b08925dae3d91ed9f878895ec6097885c2e795acb11913d93a80ad2ac4e2fa2a3ca209197db4887a4909664feddd79f97454ed22c4a02d9ce0181c4d466acb828b794773819e80f5837f6fb957202ab6410559a32a97643e40b927981b7578af8f4799f19178353ed0a3b41067743e46ce76ce3befb6bee86c7d80f32595c76e7ea33d4ec87d8b19c6fa9b1a2d3f69858db9490e2400ccb71d7fa66cff7c1e669711abb1bdfde74c14fac9d04a126caf9bb5ab5a84110d5ae16007d46b15fcdb46c0046a1cd50048dbed5effe502b5858fce71fb8d55686e6e59ae21f0477f687e6f33a4df7e6805a1e4176049bc7f297544ea8aa4915b5a6730e8b2c3b2d200ff0b2054baa6d26cb46cf87ddae15aaab8cadd5c1e2d835adc7c0fcd81e42a6a72698d10d889395e4d6deba38a0bc77ff9442122033e0e247bfdb225b825f2e1891dc57b958e57a83b61083da7d1829d235e5983cdb253ae86b32bc4998c9b00a664e471163d80cd352c8066528ff34c1943a4a07322bc8176b3a9946988d3f494fe5769b9d97ebb447a4b5f60ca80073ddb6e324b8fc73c959131f1b5823bfbb85c27c4ec7a25e4f846b7e09afc532386c77ef36a5ec108e9a999c0c768acb0b653be3451f989dc2b83e0dff812bb86fcdd4050be19bf70b5ea9553e10b134f642f1b6ef2fc1ef0aae8dd16782ccec29588fb37b4fcc3c58b6ca06a948dcd88198ded0ad67cb45410e06554f9856e51880f1911bf3abe0c4c27663c7f8480754587990f23e01ff25920c8996177d652a2b8900a8c28d61f7ec89caadbd843d1ba7792b878a7dd119ecf37845ec9267988c0f3947af2ff6e118355ec3aa62bf6878c5bb41015b3491e361c151fe2bd4ba6162b93872f4cbacc439507509a418f1fd05a9aa2e77d5fecab00554874638061349471f2a0b9bf4058dadf5fdc8aa236e62641a90c2e5ee315c377f9f52d83811a97721bda5ea6a326d397cdbd17be3a81e4371ab8e59dcadbbc9ac94da1c50e4b605d5431338ce34ed9aefe851cf15f8e029c702dc1ba355f5deb0068dba91eb2c3054b42ded2ac2ba15bdb3baa42259ee1cc50844f020022deb1c72c3e7233dae06c19eb4dc0623c3b9fc9b05e6c4cb1f4cdaa33bfd033fd46904275c5bb873064f6cee7a422bc8569699f39adb506341c6f0fee328f35d9a966e9320e4ecdecb3045ad2ae246714b103951e55031a610bd89be241bd8921cec4307d29da4e6e03e89087a28d7af8a104ec1c0795db59ed657c459ad73a005ef9759977a213b95ccf20959895148d969c988825a75e0da30e990573797d1a16adbc6372ba1ea149dd10078a1cf817db91b32639e9b7e4e0d3d8080818c1dc44ac37572aa5308ebbbb9f804c85136290c71bbb7c17123bd4e8c8922294f4a664ab15241ca9dbc1fb0e06850c7d4208f48d1b3b3baef8bc2a6cab91ee60a7a8e9424968532d1af40e6c872afcc7ab75fc08e27784f13dd4f729502566a138a723137cf026ccf275cbd4c05bd7f5ec14e24ea7fc0679e5acaa1d7b01a783325b9b1c5cdc12e30045a1c4a8b5328376b252d93c700544bf93c224d4a29661e074e05b80c997ccc3f869b27287a575ff300205abf720dda05442179b15cc62f4c1e7099b664b095743ac5d4e0953298ff7526950c1a3c728750fb93a77abf94e66defd6d214ae0bdb7a0fd7085bfb850bee5407f3c9dc1a973cd8a0607edc5e042939c59c49009bd84e2e5886427c7b26864e1e51e53b7a2be111be3855370a067c22f7a65af10c5c7307db899944755676ea0fc52a3511c8c302bf6c2342369bef5b265b11fec35b850233673cd70a0491b91a777a3ef3d634db61532158695964da4958c9b01b66e08b0dd44eb26c744535939c9865445c80b2f6421efe5d75299afd016c8bc60aa1783bfc0a356ac17477b2a85da4622d3cbbd496feb5089a7ec7b81db171f97277dc24ba4fd3fc464d603c1f49ec032d08e742accd7542671d5914c163af8208d1aabc614d264623ee8ca4c44359921a77f9ba92928d607815b8c6461f983db426d1d0616b5b333ae1dcd392977ecf181d5258d5550d4b6b39bfdf14596b19bb7b6d77283fcae385eb5f1e2363cd66987f2774e6a3daa64230328d1a8ad6a8accc6095110dc05d4a52b4cf7d8d6aa7e849c51ba043e0a823f57295f66caf769555c3e24df49850f388912941b94648012d5be687e576d3f5bb586c56654f748b48b26195e3f52f18088fb0beb82affb87d7aa0df53fa49ca086edaa16b4614b543d3d6652bfec05f654725d0b9124c03d278efbee4e6ecb80875e511a58ecdfd7128ce61744963c6e8f07ac783cea320dadf749066dbcc391fac9a9bdb651ff26838c9747b7cd4876ee717610ee7865ffb4f6cc853bbb5f6db5fc7f0b89d4af15500f2db06518de6939a10af925da60cd3b235f128bd1aab5e070d1b7643cc7e2b885be673d3c39ef359c6bac70c3104a3b5f03f3121537c78fd7a8aa6a4cb3fa77af704301b0c87f2fa5224f87711772e62e2e9747e52b7edbed1d8849e03facdde91592090ba9216032cb8aa12f76621d24bcbe42f40247e91562ede15ca60e0e73cf36e34eeec7d0b972db486382914e00c06b540a96a4a1a15754213f8e9aeafbf78ae17fca807ffbad584ce691ddd116db74608a126b4b2bb7b07280925093009878f64c89faf29e986c70870a36f874d293c75f83515bdc9e1e9000e7f0570780e85c363130e2fc4e4f0480270f82543874761c9e189821c8270d8a1cf811c5e861f87aff201d209494a9492f0806489c861cf7d1c7af097971e58f038fcfce8613db487df083f720880f31c3ea6913f5fbe3efc76aee3d0bbcee12597095485c69c1c5ecbd20978890471e4a60568a5c75a784e6e5280bec94d50b4d2634f7e23372140b372d301b4d2632a7c959b0aa0b9dc64a4951e23facd4d457a2be0262ce040501e04010f3ac08914e0468c7e24173d96b50d4977412731403bb9f4177b082edc85ddc48501e80fc8052231fd0de0db85105cb811222e0429e0420b88b5a0939c72dc8fc845d82100fdedc75010daa1a9e0a024a7adbf1d990206a03f146e08f73bbef7d69f0917da424f7242417fae8b1082fe727e11427892d30efded0bc004fd091d85c75c3872895c2341416e420b408f692a5c0b26c472dc480b381ed482b621c9e94f720aa23f13de447fb10fe024402181059d9400edd4d2dffd072c18394c53b92c10799213131602a03f120ec402d01116989c080b1f0480c883b0a0bf20076ae1421040c2139de484a33fd881682af73bf2c308d049582204c87fe0273f9ee404a43f58d6c2d07f682a9789fe7edc25b0030101e92fe84234150e48c8939c86f4d7fa124d05ffd0df8d7fa0a9e01f1f007d48c8979c04168280e80ff600682af7c87d0284c89320fa0b3a094f8290f0242798fe700ee4c9cd8d3c810179921311fd053913fd91f0007cc80186aca0930ca09db0feeec7e33e3495bbc29127399db082fe863c4853e1562012e463051efae37e64051e4a8e9cc80afa23f2a027ff29c010157492938dfe4ef85ed74712fd057d08921f1f9a0a7ee9cfc77b682af8f524a720fd21c99ef4d0542ea7bf1e370992070505fd04fde027e9a1bfd579f4e0f1242724fa0b7a929f23f990158c9c707d5c252a10d19f910f5181c89027399da03f9b2b51c187fe587fa9e0e3f524a723fa23f213f437e44a5e82510929e8240268274d7ff73a9acadd4d295c9e148ca460444b21058d3ba2a96429e8efc88da8f022994ab69b8a4a20d29fbe0e4de5f2e828c11629c2a3a960ad3f9eebd054b036a2bf9aa97075ae692ad7d61bd1543823468a1829f224271d3afabbb73a749ee454f567e4b5c8ed4bd054b2dd9402bd3c97a3c21dd11f7d099a0a77a4842739a9f4a73a47c4a33fee5a53c1db8624271efd24a7a9bf239ffa2be1f442b3c90004800293000c2d394149122426e4111ecb247c67a00b65213f9247780999841bc9402f92859c481ee14332095af2205ff0411948c3ff64215a02215ff041f2085a2ac917bc0879e72164efb00c0290ec13634efe23effc83ecdd47ee79650f64ccc97be49df3c8de79320074ce5566cc894e72ba863bb47422efe826a2eb648f4877398ebcdd9553cfc9d97172f7d46fe48c95b7e39cfa2a6757e50ecba6a5969466cab4dc225fd066bb021ab648b36bce48a0c4022936cd330b0d5034d833db1d408006061269861b2b0390fa059b1095741312923f14683bec0bbab7d6c3251f30952f68067fd08c9671eade9b5f73f6744d3f037fd04c14970b6321f9032bb53686242fc8577dde00a65f50845d1152cceaba6378010afc052dc52520848290148989813c3546f8bdb0a504a955fe1092af0d52f943deec801ffb87760ff5845b9b457bcacc9eca1e94e5a0fa2053b21d81b9a98439828881bfd4a68f6bb6fc96af6ce71e10d1ec18e26e9ac0b65dca6ddb9036ddb659bfd42715e035e814358928d6180a5f767d9124b33f986606f8bb512aa828a5690618459f484a67a500d296b3d62921851b9452eb5c00471d0586cfb2419ecf428966d494d97996edc44bc9a4e4de235fe9710f7a1ceeec42d2831ee7b81e3d1ef34e8f2cdbe9d123fb0ef723eea8c175e7316731c6b8f3e57ce736eeec1c764a72ce390046edcf4a972d25e731ea2931c61863ddf9dc3bfaab42b9d89d9093f3c5ed8212235f59b7f32c6f3b99ae54c897dca94b70c8ce65a6eb17f9c2227f2a14cf79e83800bcebe438941cbeea3bba3e411f8946be7ee0b2736c789e9d9d9d9d9d9d9dd73452e0fdd5331b03816f7cdffa3bfeb9f60ede3bf9dfdd3bfad3baaa4103f757d15435f2e78cfc992ad04e908a334e789eebb8771c5dec7b2ef00936fa3b9975a83594af9defe84a867cc119a94a3fc121fa3baf3c348ffe5c00d03af487f74a477f7773ab1c38f42757aae3ad755dca75eb82bf8894f445fe7c53693fc91ff8e40509b67c85923fdff2144afee0b83c15237f762e4fa326508fcb53a50924cbdcdcb8f987f78d9b9bdfc854e97a87fe5cad7f5309c7639764e7b0a34ad04747850257285d01b0843f59e6c975f91e19caec3b5996c1b98efe2ece3dfd619ce728f345de8bb1cbf5bf5e30d817b423ec7068fde5dcba32dc391fc5c91fbd915a608837b2120c9407d7a78f93576518625797b8fdd5a5a56f9a994a53c96acda30bfea81255923f4b6ab63c851b045ac86c18bb376960798bc42375aec02f36ba2ecd6a96d5d71398db10ca026178d8c00221d8df6f012b78883ca899b7c0123d7c07353c3019ac70c8384f63e424a464245314d04d0c7e8b2d180c16020c0683c160416021c0603098bc71ef4ddd7befbd5ca4f04e209b9818f8a548908bb1fcf9512395d3470a31126675030c03fd91baf7a6eebdf75eeea6eebdf7b2388ec25b44ead01d1e3e71fe7407f2f011a2037de25d96c3ab584b1583e7689c18771004304c1783d3255f31062790168313281583f7d4c01d776f90345832cd73624ccdb4ffba344e182c082c04181c026130d85dd96b56579140aceaa81d63d448afb592dea803d35257e75e1daf6b5ecccad5f8aaf47256522ee3a0bea01fb0204499e783abf38ce7d2ecf5c5f3ea51af65b97368b7f66a2909fba0c72bfbd537bbbeb4529adddfab8704cdd4eba5c15ef5be226dddea7a65daccd125a95aa5b5d2d77dbd347d656e9787069db2fe7eb384d43f1d7c09947d2645ed6618a31986d938a29860a8992a023c85fd9285a065032d6e9cc0dfcd1004db4b93e1533ed205914bc041261ba1b9c88aa399881accd13c643765d764d37da6f458762d27ddf058a6951ebbba6a164733097bc7061996c803f4d1b265cb1c76803ef2ad2a7006caf121ff08c1e1c6bc82ec1c8ee61176d0c01fcd22d01c420e8e66187ef2389a4168858066203b8dcf179b067f540747f30f56991d1ccd1f442e5aced1ece30648981182b504d30d24da28022bd910a1b45a228a85c40d2a2598f0129d1250ab2d565880e34246b505aa025b5354b7050515d09ad0705bc4e021c504d4b685064b978bb6a58d1e889a404a82071fca1041c46529892474205ac24c1250e84094849a24ae50524a02044a444c984922cc0f444d5c72d0783f2c1de3964b2703d2019e293c2df98a3aa49981926ad75a5b2e18b561176994f100e9062f2c69d6e841039cddd0a305b8ab800722c02c0cf808036b4df4e0a00a2270b621183442e0031a5bd88059649090907e40a38c1eec5cdab08b36c6ecd71768a4410234d668c9c10e5128a17936c4062184104208218410420821841042324284f1a201df15f830836dc07c8044163d5650851558db100a8926a640c28331f0dd100a09227ac4e06c43282480f0629352ca29a58c5766526ee84329fda69c73d25aa994724a29ad94126fb9240a4a4965a694ca2ba794320535958b0a0c2184104269ed9c41a6a5f605a370a296ffece79cf39bb79452fa694b27a573ce7fd99cb37ed63ae7dc2a47d3e06c2aa7def47b0d01ebfee69c733e421ff8cd39a79caf5965a5130758d21aebbdf495c4a5524e6ae9cd6c5d73e9a51ad2bbe6d24b335bcfd09bd9bac6d6ec525bb333d5da9aada1d7d635975e7ae60cbd6b2ebd34b3f50cbd99ad6b6e5cc9ae94935abc532f6c5a6d16630d5b461abbd45a6d4699905e88823489b42012e88b16a01fb01e286f8f84e5095165d2c2c46491b0543da318242c99ec329753a9a65f28e87649ee6f778284d9ddeea2180245a6881441905ad3bd1913d2182631910b8d484abc540ba1cfbc4d9a8b71b4914b47648184d2768408761602117e80f6c7ed6a64d7236e30220c1641881140ec29718c1016f4579669b892704a08e12319f8c988a495b5d6c2664f7cace2880d5ce18123a8382266add2b6d65a6b6d50d06b7f2da62c76e02f36e5590113103d6bf0878384d9456c20db6a8004f3bb94527a420c3050031a41d040882e4a88c97410812f6c43c51a5bdbf2fc8837ec2f4811f8655b11ec0f8eb19ab59dfd6177aca5d6c62d2dd8918a6db394d9568b6d7fb1eb2f180cb67d90d01222226eb0ed9f403962db4779c1896d2f0306ae40d262859219db42282268c0a4650c9722b874b9b22d84ca0017f6622f62b6b50fb2d65a6b7b64e1c0bd9d076012a679f1210363260566071ba6cbf562881a0629c352460e148bc572831fe6089e6a96a40bc826504f7488206213305db238819b8c008d7429fd8075288049d8186a18e1011835baa8a106163d30c0aa0dc1a8d1850f23f0b6211835c078f980ef8660d4308303141217c8d9100c1b5b94b0fd6bc5bb6950a2440d0b54755cc76198109109a2cc182595627e3b929b3eca5e77b6b4cdf96d9bd56e75d65a6bfdab6e72665de04fa7428922034483f47a990934ed0f50505faa8e1ff0847042a8a5c45077f698c2b4f6846b179a98ce16a4b2473e35c67ce268ac8184a54b9d99cd7296d15c245f2ca4745c8a4af0009882aa81e16397c472306315a0062ffa090cb56f179217f38040ad0c7fec06c47d7e3e19c357e5bed12f587be27927962e775838252ff504f89387eae2cb9697f67572437461c134a286e002239a2070902a03268d96c833bb21b9ab974a5d0e490b16c102a1845862df6cb92447d8f2d5a60ea14fe5eeb32cd24aebebddb093ef5e9044c70f986e4be40fd556432d44f312263045a26b75419f3a035c796409f3f5d556faeb512d1443227bea5363e827b00b0ef194c46d2b19ae0e6838d82e1b0eb5d65a71b85d34e104c5e102693629a5843e74d2092f6574c176e50f84b0a0bf30b51267905286b1d18927d0937618a38f59529b669a3e92f747f38b503bc618e352f67b6917a3d0de69aa539a462c942e118d80116ac9eca187b14d6608a554c9cec84a4ce84911282fd4280c0485444949f7d99388b6db0c6348287dead2141b78098cc92529ef0b6212c6e6375967ada78f59c4e244c6a6ebb387c296b4826c7d1ae36a4d2a8416586ed8794eece78de636bfcd6f9e91fc7699394f49dc5edc72c3edc566f6e2535e6ccb5ebcd985a49682cd9eec3113ddec37cb32884642b1411e2fc2a889ea679452a289346c90e766cf3aedc5ec475ed41e91ea29c098eadd8faa38191d6557fdc8a9283beabaa77495edddab7057dd4a0cc660ec1ec6b6d82591303c8049dc148624f644a90bc978b3176b517ee23951a9b25ffb5de9a3ecde8bda48fbf58c52d9bbd76d4bcdab5c5a50c6068e422505c1a691524a29ad144a144a29a5dacca44501a5748b0d0689b4a1b673d8c01149860914af1ad883da73729f7ad17d4a577182af72e474a43a3db2bf87faa83ef5953e9a3b5be0d5aba84e6f57ba4ad59e13d5e9bd4d17a9b4b73dd1d7a752afaa2b94fad41ebc7609460536f8f0840e19f822765f349f7dce5bed44b347fb4b0d342640230c24ccd02296a9741558ff647595a96151474e45a9cf1fd17b2d2a0663993e4a69cf89fdbd077591fd7d51fdfc07d33ebb14622c3b9c324e95071f4351f6d4bbc77db3077fe4b4fd28f5ec474e9d2ea2bf3fca9efacc1ed41ea73df84d17ddd31f51ed412d03d2ecd17428616ff336ed39493dbb51ea993efa117dea463706b5a6ec4252bbd7525a5cb249d4ad84edda29942812804bb5ca5a291492b5d6babdd65a5fb3a7ea084d69eb6b985a19207f3eefcbf142945a6bbd078740b873c021f465e8195bd40287c82a1026f100a39658041c120f213c03a11816ece18bc0a86311d0876660533172cc025f458cb1650c228b0cb6bc05e08b7e0661c6968f715f1d97a00fb5400db67c84102ecdb02712d22c6385495a3a2595b27e61938254920542e3820637a8ae6c61c5997a450d2ee98cae0733d6e4d0829a43adb5561dd81c542c11a8ba484d81820c18d134031bd460072796a05e10517be0806a731b4205f1441a323d5833704825692b488091c314293893431850c82eaeb85c9c01020b986146cd813e08a61fa99b1d90b698316306f26c6e674ebeb07cb9cac03c32e6e00d4d087da2a69312d9aefc81504a2965bdf9fbb561841d84a2505c00cdea05a00b019248427290fcf9a07c8970f856ecf0ae7d781da1c3bf051e067c012f177e2800f6c307d97148857cc18770f822120eff04e8f02c08393c94270c48c0a144913f5f130b4f1d3621e0d961910f3924f2a0c320ff6152618b017e806f874d2b3c75f83515e0d9e157a484c34732f2e723a2e5927cc11b397cfc42fe7c418a1c3611bd0bb596912f49867cd517409f7a9d31f017a3caecfa28a64c7d952f1813c9c817c021364731d58ab59672d9edb35b2dc3feee69d7823e57c7a5ae49a6a5dcdb674357dbfbec6aef664deceff1afc6f28573fce14f71ed7b3b2538f8114b37021438fb1797602a95c588c56adae52e6ec121705b6db16427e4ec387f566f5b8ae3ba221ccfa1ab38d9c3fd45d9df1457a577ca989a65bc21fb794d4a8fe178130e3d0395426892147243adec35529ccd53cde56c9e69e4eb862ad51b7942654185c6d96dfbc23d51a8ce091597d516ccc4d26283e50610ada51b1e709472925c9ccd1509c71a39d4786974bcec50a1a3cb0e343f93cd6832005086e70b1e647a8cf120ea25a6078b0f9ca05c7e9cf1e16c9e6640d802630a418b085846e06ca64004e16c9e68e4ebe69b10cee6f9245f37f7d10dd93cfb06c4470f10204080bc80dcb46ed8701b10203e3e5aea0201726f06044896d90a8290114408418810988f8f8f90880195a6bfc9ad9c314b6391af8a5bae1db18c9005c3583d527d646aed2cbb37cb62a09bde52aca97c6dd9cd0f80adadfa223457f4aac8d55b6a7596c5b8713b460d73b4e02f46c52f7ef922ab8f59764fafbecf3ebba1d68e5f84dd907d2a73406b47fd4dd9574f69ed98e9f845fe7cb41b8a5fa895765a0a63a6fa64d0da3bfad1fd4531bbe6c8f214d8bef1cb06a486fa4a757d9623d1ce6e65c36e5edd85eae805880f187f3a9773bd76762ecb2df9aacf9104cefe71bb56224bb2f80241807b491623803e707f5b48de7b513856ca6eefe918357beaeb925e8a51f255731481618cd5323beacfb5a18f1af88b513baa4645b5a40757789c00771b42618145191f5c808a170a7085c203344d6460c134051630b0580a8389ef2d9376564a2b9d954a2979a49411afe6953f334a29a994f272369093569b5ff313c279b3219c509b32c29b26ab66361a279a29291a0821a438986dc468a6d2362a3d234633319aa9b48d4acfa06a6cb322118295ceee55ede479e6b287e59bbb2648d7b8eebd37621a35b95811850ffb834f104a0c0a9ca298d00006d03cc1c36cf292e68a2536231ac8ac5146cd0d67ac985cae5043857ca0a905300853060c282618b7032ce056adbde280167b75ba5a750087bdbaaa4bb282647457acb1bb735d920e7eb9820a1d5a3069a82b7088612079e1e588e8851559d02ff78c0d60993744696ddc0d285dc08b316b54c181304e40c5ec54625b0e6cb16d6a5b6badad628b12363de5a1034f154d6c7b2d151cb0d65a6be9611535dcab04864958e67401cac53e09319d18a14622c91eb8bf8ba948c1929323a27898c1131531d062861717164a2a8049188f1164a0870bae1b82d98193193b90c247961d6851811d98000736c2e031c271411457ccac59139b37aab7d393a79e8c41d86403c71c5faf18c5e002671b424df18507434031850a5c504a0821a432d628bb9871ce99d93a29a5349b76d639699c73427875d8a69c137eca0c3999e79748e78c311ecacb28c116e99c93b26084c1e61ad8a54c770a241ec86092228d1cc6589a820725319ea600a20230589ac2081ec6809ac2e90632a26a193268c0e4400d17186f08260d1df6771cd2c08018692cb1031ce016b918bb18a59c52c6edf5028128683e79f5f888446e76fd5dd3734a2112ba604bf92412612182208fef16391a6f2bc7c2b3a8c50d053b5c601965193c378c0c782106195e908f686478216628398a9297d4a7f6b844b36060cfc33875f001dfc727e910e2834f332249b821d004726965308d724e55d376d919c9d8762dc7a739b9cc1c9880f69cb71b45b24408004a48d769bba9018ea773de9c118b04c9d79c954a092f9c3d70aad9828a405953546ed5d4da2a9b3ec218dbb2d67cec7a043cb6ba2b48fe84005fa99ccaf52134c15be60440583369a780ba014e6d0825451a3e8690e28c1460ec6e432829a2aeb665f4a9d4a65d0c8120dc5259769ba57eb56b7a48ee2f6e6fbb67543f9f42d5d333aaa74fa16a7b6f964d2b76862967187b6b96e1cc663c5b4afc7876566bfd3785a7d6ecf6fe8b99f6ae1e82f2f54de1d936d6db5cab151ba70e5bab556374b58838216a2bf5dda44024983e9e9eba4610a3f6b25bed65ba08ce9e59290f4f4f4f7018f18293524a338dab9e93ca182319b576a952d62e55c71438be4a69350c744f3d05b6e52c82ca1b1b3480e1c3e0cb426b0d1c2fa7f0ec18e3149e3dcf13a714f16903f7e9be60eb42afb843b463522960e9b63293598aabf976d92929678c12069b3adff13cf2e7b6648fdc1c2e93590d60f9ec35f37cc600d77f98eeda35a148481084792a9b64b2ce6d730432ae7602d011bee6ab6c4277f6fbabb1968f99eeb867e4991ab73c805fd76d60082505d37e9a3fd58b33a4e8210db659e3c504c6673e4872c1fefec396367cd0805b5b6489c2cb52144cecef4544e103de36848a62a9e5a262a622a5f44a09e79c73ce39e79494d26cd23969add44e29e5945266f2be6094c6ef7b5dae9b35b0f8e037ac5f26ad36bba9596bb5f225ef8f311827ca7fb5555fabdef5663745b53937eebe6ed00666760c7233b17bea267bfaddd45aebeb9ba7347f5987ba5258bbd93247a98b7694d65af5a5db96c6255f50c5adba24f05072f3aa99bfc9755be0c8d9dca8ad16a594bb9956df0843d549c9cd0be16d3229dc340a21b4787230c0f1355575f637e7cce8cdaebdf207de4a7180a5a473ceade3b0d8b009f8e5527265e008e19cab2cd35524105b21b1c6524b2b0dd4d635965a5a69a0b6ae5943abad960c5bd7d0325450c69a32ce9401633c53c6cc4119136a4d171c37395a5bb5569bdda036752e417e7435501d2c9ab05bb2cbe2a214a4c496ff766cf81d48246e8920c821104875a82ec378263b60e7248ba57494d9338613714b4c8a4848a94deb5210c5002865b48debd2f2a203c5a170bb255b077b71af1712a15be7352d15bb244d97e7aa150eee82b9588129dcb0eebee068c375e1c2850b17c8850b9c40383155c76d5a54266f78c117632c9960192424a41b9aa0816b820ce73406eb092b5450a4e0c6179dc4b277ec8fdbdd6119bb3bedba64815b74832203504f8800a7f9b89db556e044164e423441868b04504d54e00699a14698113c098162424c1c038a1928818118bc98c0024b21934503496819620359d81c3c80a4451f3a5cd26c7afabb04984d8f97b0c1a63c6c8051118c0ecfa64d6b36e5e2b4e95d9fafcd8383314a9c804c53139b5eea005320586bd3245ab029941248b82e165603aee86a0527581981034427040e2f749cb1c9a085458e0dba2daea441a3b855dc242db57ad84a80a30dac04ce96ae0d17746d58e1eac1b526cbb6869a6e0d3170769093a56bc30cbb83141b2758ad41828b46b5668bba0136d4746bba986bd4c099a00d1b562658b3858574c5f502098acc0b1acae03594e8aee83ac688d41536c4d8aea051c65e69b9726c08e5010f4499800607f07737f528de7e105949795c3b50603829fe04d20e537fb2e93fd134edddbfdea5bdab6f2c51460aae6042aae2a4e9abedb38bb9632e45027be8efdd6c96dd669aa76a29b019b5411e3c81644c27661ef9caced26480716c18e80e627d09910bbf68d3de3dbd8c3ff29c5c6de419d9cf6b8fba48fb165347927b11eb9cb6124be922ed5d113ed71dffeaa26df39cb05e5fc47ad5de2dd2eeddec292df0b32cfbcd32d6b58d9b167792ce98bd5eead888754d7b29dd2435fe91bdda357d548fb5778db6b3b41f79f746dab973fa086bef6a8f88c5fa1136d2479c3ed2ced2de2d621deb2a4ef7ea22acd266cabbe7aef69cb058f89c3eda8eb7eddebd11fe9177b551f7edddb7145665a20c65f664d7f20bac55f62ecb328c6941b3278b58e42b68674b4c536a4d1be4d956abcbaf3a1b1b9bd56ae5c47b77239823078e635d25e7385ec57b8e5b8949d8c91f79efa0777ca39cab728e737ed4ddf3debdc87b77a98b72367c2bab17b5be7afceac6b1ae62f31bafd2bd752b31a9d25558c7afb2baca4a0c77c72fea8e2f8f6daed255726ef32adebb5b896115cc717c231c57e9a39ce3c8398e1f79cf7118935d124f7b91ebaa17e9b46ef491cd6f9ca5bbb7eea55e74f3d58bd4c70c7a4ca27dbcbf70cb6faae7dc087f471fe91c3f47e7f847aeab72b2c77de730e6658fd39e13d7736ea4f31d9de7e8fc4875d7a63d4d3b715d7503b8b4a7dd4aec06d0d19e86bde39cbbeed2559c8a5cf77415a873e81ced11b9726238349e3d32277b9a2b7b5afcedbf6718cb89da8b5bd7dd888573d63b9cb37e74e369ddcdbb1be1b08ef38e759c1fad7e93d24e6ebeba016eb497ba95d50d80a359bfd15560dd9c1e91cdbda2ee30c624de7eebb2973a8cd9642f05e4053d4ef51f8c2a923d267adb2cc53ebf90a1e46c639927ba70810e9e32ed31a1b7b75a4ad534c6b2a2c9951a2222e882572f3902cf675789dcf544f2e7a2205ff0dbf69b67fe22929ddbf6cd6e5151db3fd8e6dab66ddb52598bb0bd7d9e955d13c8357bb61c047decef9c73cb36752d9522ca02a77e9ba4e007a1b8772b9b1cb77803db1cdf86e3baaee362ace3ce3a8c6d94734d208eebba23d6b9c318c775b7d968c7499b89595fddc8c6e62b7de4347fb4ba11be8d66d91cff88f5d5eaac17adcefad445f8361792b24b01c66e646f7e35e75cadceba951b87bf916d329c3dacbca93a4e952f9e3d54c70af0fcf743bfbbc10e4ac2a8e9a106259a6a30c40e492d08030653982fa830636fb03a2d68c286304a6394400aab0318558c1b5610b5c54c0d586ae982dbc2cb952bb6060f2805f50086085090051a25184115b11578e0863ddf72cdc3a0b2508305582e13e6e2ea722faf27a8a079844e912ff839e18c9762ec72fd305850107d3a3229a5b4a5c33329a57386286f1adbd4b822f88b4bccc7bcbe809171e67e3a1066308319dc6aadb5d65a2d7de40e63174e7f3344cd3066b395da0f8aa182c6d7b64f368535b395521d635652334869b3c43441676064bcbef818971809effa8179a0b4caa0517391b09274c5a5a02818547c8a5d2297c804d1ecbab4e76193d8658628a6e8c40c63b643910f0a92d0ce9066cf25f055efc248544c970be309e565cf29e1ebc99e8f51863d9fb62836388120661d679bbc719f6bab609324ffa26cd5b56c73b86995feb46df3450922e7375025e0b259cff1b2332a809be7bce626dc59df62d62eb3bd0e13e09bef759800cfdb6b9afeac703902d31b8ad175d80920eaefe611a05b4a8edbfbcb62e521eddc6db04d86d0475bb1ec6a65594aa46c36e3d8617baa57aced3677dc37eedd6137b45dcbdf0c43da59f66a18ae24d25c71336c284aa4ac0eb7262db4812f6c7889a4bfbb39dd1d4b24782eaf20d02449ebddeaac434fc926a5dedac36f96bd4dc45ad4f4070314a41d03dd10b0f138373404ac705e8e81f5ce1b92c27dbbd552585f5d062dcb2d7f43aac3a8bf21d576a1b9cdb0a36c2599d35f448236f90171d35f44da753b772119f12a07cd9774c1107713d5211c426f1f5065775f6596a6b79a9eb03a2b4b4969ebc5572fde3ea5691886b6738f7a6875d6ed3f2b48dbea08d06df5d097b6d552bac32ee7782a47a4cdda3547a42de5e639cfa199b09e73d90ddd3ca789eada6dd6f2eab06372f39c9c9c7d31d055f68658bf39eb25c002c505991d332e764d6e76d4526c0452dde0ec7532de2a8abfc16e88fbea36774d589f8da68756d71a2b472fb3dee5cff5c9b0216641c882c75c406d94bbc9ac1bfd459b3f6ce1d6c9707299953f2b4838ee23d2bc4b37c9defde6f84ede6e471638daa7e2eebac76fac5fad752931d0ddfa77e3f0f6563f40eeb8d29fdcab6f5cfea06c2e8a2a43f1b27795cd0b5bbbbd97a1fc91e190b5ba71564b47206e9ae48b9bdbdc856412ee5df6ecf190ea9e3debabcf72df70b657e5d50ae7eeaa5577782e7fac7faa73d7b2c7d24338f7549e6a75f89caf3cd5f16d6eb377e3ddedb79c7c739cdc3ac769f9e639593bce8da6a9f4d0cd3d8ebbea387b9c1e627d75789ce377d95bbd3bf7cd266fc7695d95bfb8556f1d276fbfb1d19f95bd1d6e57e5ef861eb2b9b7fa567a8875acfad665acca71af6e337e97ed6d32ebb01b6261fd5959e91828d7e5edb06312c28e31c429735b1d01b9777400efba430b1c0fe7032c7c96e385663774b3e373e40e33738bdcfe5a0f889b76f837e32ea5303563fc1253293d3f9d9de97ba189e92facdcec4ed8ae6961da94ac54a7dd085d707c2a03c2f12c098eacc304584a03b27fc39de9b8458b7c55fa6d76f84d38eeb5c7b93d0ece715c38872e1d97628775131c1db1e4fc669c692109378e2cc9903d395a96e1e814570bfa581d976aa10ea894ec98a972182a44230000000000d315002018100c09450271300e26b2aae90e14000e7796406c5099cc634990c4300a82206300208600630820840064942aa20301946a70aa9e4126bc9c963159da9b7e6a1782514880c1f32f774369bf5052c700b13e82cb399fa52af277b9f0d0be18b0876bd0d1747de2522fd6b50b1a412694da9fa8f606ba690ea60c289d1859eb9757a711b4702dc182bd32a8bf5bd29f58d408607197163c02efa19be661da82597e4de90c15f52dd204b4dccbb155ba44abc55220889d5250d440e75fd6a27da565ef7305e2b31502c2c19f7d8e10781857526cbfaac8d603e3898e6577258a12a014bf51ec1e95ca69561c00a6ddc5a608be431d301860c8ed0e9787ed2406c2825bd58d10a623630f58985a1801676ad2893ee0aa3da594a1d5b4b63cb02e826708cd6cc5497ba94dd1aca2a9dd5dc3dd3ebba452329d7322174473a262d4a6f510c7818802106581ca7f830da512e18d059778e5591a15aaba37ea057c195b8ab37314dfd9e7993adb4ab593cd51fa3c57d402a5b839d5d9a2492cc4404247883acc4420601484f3c3e32509d7f4d2c15b8db31be32fde779d62291ad12f7c08e24d5c84601ac8688684c6819f30fa0b6392a7619a5db3e8078d97710c0c3f517aaa1510eb405bf551329e288bc2ff9056fa88ca11fb7dab724506fdd8fe764cae53dbd5447e6898da82e3324e87191b76b3fc09ad65d42f271fab29f0b484c439502f24c003fc647a0bcd03911591df42bd02406a38b8924d50c05a00f190840ea00711de30518268952e84556ec3413eb6469482923289a966e568a7dc7aeeefdf159baad3f4b8d5e50bde370db8674310eb77e59379d9a708bb8de482ce0fe90e0eb41e9f366bb18a15b55730320d591aada7180f4708bae3668f6e0678307549de09f455d8c0b6cf12b9aef5a36b5c8e461425e7cbc1261836083b22a328e9ccd70fe11aa5da44b57014ebf535d503372bfe085f122aa26f168e462e048cae005da3d801e6ecdc0fb443e894dad8b204ee41b52f491bf611459364f61598c5ed6f56646f12232159dd37a3f51e093754c77ff125fb62f8a9a21c86073ed636a8306528554bca2a25db1278d603e83e8a7aec0f352028a6792710d15705a2807129821033548d75ec52cbbf0c7ccb466dd056e40db05d28c9066c9710da27c56ab21b26747771cb5fd6ec1d4afd5824a310322a27c516079ad0322ba7f33d30d6d017b8c47e0c635085a7904eef619e2333c063995a1f648d4af8bfed8937aadd61cfc061820cffc6434bb763c34a9469f74464d9b11014c0d82b88f6c3275a18af3fa2b053eccbc81f34f059cf05e5fa10286f6b4eb64fc53d442c55ac87a72a648b153e835fb66d132b61ad1adae757066402db534052afde3751c88106a10cadcb854350d5eb2d0a31d335feffcc303e46f324740124ff816f40f4aa2d945578ddda388c22a4bde6fe2942a09285cfac04877883264e0de93c8f505097a28be9c0ff28e7fc4ac6c8de4b23292e46474a3888090fa88f0a431e962ca8fc4829dff3d90755f0dba504acb0ff256e4643d7c8a090b63591f5d81e4bfd6b04b0041be29c93317113bbcfbb55815384933a3291b2f08297ed41297e88123c8732329ddbfc545915e56a7550fe97e658ced39b28d4099f935b00b0f5e443b20b0a2cc3f68fb1b4e3f42936b35be4836c0877ab9486a0f5081f347c59d72f0940ec17b1deb8107098a7392149972c8dacab1655b33e7f99a6adb094374b432c0d9298a45e82d9906443b380d9063ac1eb9a80363b5814adcbca7232f47d5cc19b98fc726f8ae8f807244683456a59b43994f645e2bd28e0f4ad7926517f646f4998c70d332c7a56300922c1a5e3797e0729fb9d1f8aff46695713a835c773c1451123e07a2a04b04f943c88c9ee0b687c1d6aeef18e71e4a3338505bf8109201099ad46bbf7c2837dda08a6ab02508bf0b3d5a1ae930a8ef2c208a23340ed3ad630e46967a73cb17c45e148f5c1c9a9cf4065f9ec912ac3f9ee6d11830f61eef026e2365957a02f820415dafe6ae30738c188b31204a109a36d95b03b2215fab322183f36f5934ba754137d1b0ef3c4afa1758f90fde37819d434b84c74011bf0d6f5883406a5742946e507d3c0e5bf204f09860bd9d2f2ce7326f982be1383b0d8438443745c9eaf514c7ac95db1d521151327b6c8d50063ba8a5882fc7372186824a45a886b788000e2db420d801a31c8fa1d76bdf45f84ed82478a347920e89bf93e1e4fd84ae03e90aa43c32a7c4da37295fdb19269b69b50c0fd179dfbb1f403f33e297b3bb1df44318c470ba591bb154592d76eef54e5b91e54aca063f1505188fefac26c045bd6d53a82b32c5d48e6995950a0a5161dc71ae261c9772400637b1f6bd1d3a8c2c58516d98523e787c62e072c7f421e206552147ba2a8286f120fc768f8504ddd869b109e1929ce61a2c7315011398dc6b07cf5f9f80647806d0d56fc90fcbd6967940dee1e67a841c703847d26dfc27babc58244805092230346d4b6c81c9086625d49577f793a64fda86db5fabc144d5e47de5513b60eeccdee0159c5786939a7224193acaebdcdb915b3ee50f2c71720b3158c7fd940343018f99931b24577086451b9856323104308868701b0ea87945cba099cb6e789a1fe861cb7a2336cef279581d2e13c1b889714b908074e2028857e04be0ba074e77f7edfc0d4022476e3c2034199af049d206ea9da807521d3741495685d4d77ce4dea8ce1854cfa64592bbce8da72af921d075f4fae73a15beb57742f29773af7c84e298ce4496ff7ad524ad47b96d3d46057b4db5d3de2bdcfae76123ad6456fe4feff92161ec38e7d4374d572448732fdc518acc302e148ce9b98951f47d092036369e59f3264b60ee3423cdba8bd1c846425ba95cbeea80b7e3e296b0badd524bb8dc4152fc7fa8e9f95434e31c54367177a2960930e2259e490e9b3b03298787912c0303d3b43585bd119e2686ab6899081d3b6bfcf5bd4d23a10d760879f7d574848956e50e411c831b2e5e698828b9b6171471dbbcc1f9f03ab5c84d9d5f7760b13797d82e5755b71f7017e7d60118f914b1926e8ef11c59286b602ac20fadb597cd132fc4c40c4594d3b7acc7e809402db5066463e7e5d48c3d8bc678e8519807a0a8bce6ad127a1e24d452d4ca096b373390265b2954b8ccc8d4b974fc361668f8b47580d2ea00c879dc83e700c917592d8b91167bb59981a29817f69b9ee6a806ff97ca8c821180d09468c0106221275b05042773577f7eb8fef0f3fbf7d489b68645de51e027a1a9b1c9ccf2616f613e654ecc0082bc844467a52a42f2c00c1ca99479ca6fc297dc4a235140cf204ed843676cac14cc7e770000d6fdc65404f03142fc37d715e945950341ad1c755fbbbff3702e311cb9450f23aef20dcedde5e52e6f02e4bd2fbe7fb0c6882ae633e0626e0f7838fee265aba10dae4817d1eb425c0d77b1a57846c2cb6c15bc93833a7cc250ee94debe58db9a8c0a6d83a014bac2555eef64801b548eb46f7ba60d2993688d86fa79cabecaa0721be4eb4f521df625cf7fc864c188afe2baafcd7e99e3e17730515795485e99253cb35f7b10075c878086ea5b58931bc33e6260535fcf1cea904697353ee7a66969854768685b721c4c67e97f950891cf6631f34016c8004ffa45ff2561350747fec1604d219e3b26e26de4a9882b55494af9706cad4a88f73e1f9574cfcb85db1e183137ccafa14d378701222c9be12f621639bc9480cdea0707a13208a91ac6b208c9d1f20981a3163c3da617b87db3a526af0625acd3331a73e0960c6110ac8fa81d80baa82b6b5480ca1353523f79f5f314ea0a8334e2814371860230a1ed33d3a98efb10b4a7211e67aa1c5b9908ba1ca54c57c877c42d66992ca5e601bb3ad8c34c9d8305b6554552cf3de2f6f15a1ade069c88f83355cf4a839a04d83c11e395888b6275f71518ff1a0679768233cf483ddb2bb3d3e326e6166defd884c6c16b208ed2eeb989469529213ce01b111826905af023fb7fd6146df1277b309dc28e102203045ce2080d9cd81677fe30b1731997effb4fe988f0b34f96c8920c117e18485cd32eaaa74c1c1f84dbeea2cf5096d66ab9cfde0e65cb24c82554e9165476e9d4b935570cb0adf7fe7c15951bc03c26e12295d8da204220424782647902575b6560e172535669f034f5664e8d9389e9d93f58bfeb290c4b5d39084f924bdb2456a75b7dd6a568be9531f0a69d372011842c20567a6f1ac496c63ae4f9b48bb1d285a412afc67284a350d5bfe18eb049f43268b998e6980155e8f231c49a5bd4e8d4e8aea4b2ea83d252c156b08c973bffc8b4498bc9ab33bd5b0fdd317e160b031bc5753b6950367b082867da2d11a5d34c5355dd642993c54b5feacc3b1448cc72f0ad4df1159ea12335115e7bafb71bb0d76af44c9bedc2070fcbbfb36fcb88ab86684929e1053925736ad2e88011c731b293e0fa73c202fab60adec36dae4cbf0252d6c46ea76cbf8d2f59122ba5c01057595955ae2d9acc87ab821c423460fb5be1034fe9aeec9561adc80d95387d82b0e924c6ac4af58f31a20541537ea762b2fab57422b684ca95204188d823d2f7c9c900e0ea445863343847e43520938bab887d81538e8eb936bc4aae9b8a9be5f18cec1ad2cf1a767b2030d5f1d85bdcfce8bb6d21806c9e7f0b9f77b86be6f633d91ae2ece2e826ac4c4e31b875e25e476b2ea89894b6805d349bb99d41c1108cc84af010bea728dc5768a9dc8a3d8f977299e0f76b3ee3bb3d4bd727c569fbd855e410b93475dab51d61e42a40753011e3190d58b53e4f93b6d64fc384e2ecd106f16fc0afcdfdd70849d953a037b60e9eafaed1768446fb468287d11f4bb42601f8e3e41841ac58826c6189acda3fd0a70c9d7792f368791418c8e39e4e26eefadf0ed092784ceef4799be02370b075032c3179aa66558db0a2397d5c8a87b50ac49661d149e32ebeda5b0edc419afa4c63ba19e6f71eb3a1c2d2b41d5a4e357eca4c3974bf00fd300ff66722210ebaa53fc0bbb239ebc3b778e603c36337ef5deba04ca0c9d388a917907ef7539abd1cc32f9cc4f364449ba01e3b7c11dec29590ead6254c078bc35cc368b88a9074775575c4b084718b99af999e57599e1c1f619a740200aa6caadff73508544da8729054cda08f6c93ec723ef55e7a737fc8d35c10d6d8ba7930755c01014d1a930faf638b151c41a4d93a982645264c9c6d1a5dbe08b4d937bb900e7acb4ed2560731fe6bda0f946cadcbf4708fc2e0a2b097b0f259ccbe97460416baf5dae28bce08d04050bfa6cf886cd577e3604a42af3c3507587519e0ba5dc98eae3c1e5e95925a5de75320d65ddf7163de8d203d00d12cb197c4e1093638564893641620fb3bffdefc88119cb59b7a4790a5cfaa07e76f1d71716da62bd8c250e082ea9470df3d462259532917fc00b5fa8d9f9eefc917de2483cdf2fb5f6a34c0fcc3bd0030b7fb0661486fb452f6c508376b55ea3c0512aabe3cd9e37676dad4f1119aa4cb12574eaddb5ab31a4f0caa7bb268493cbdaa9e4ccca2e1082565e55b6a3d7cb33282a6a14e64b95a7c4272c5a6e43b1213e360e6ed236d447082d97eafa04a58645371a6990a78a2fda40f12ad972e1e5d6aa9f0cd3498b93096ac25c89594dd6f262e006f185e3a0e811ce53433dc0cdfb887b3856044e7f3e105b0f046f564fb1c9cd8820c381dc287e714e0cf0e14289fa7db38944ac40bb9a15b285aff73643e5a83edceb5cbeda46b44503638bd7fdced406e75a00f1012f6742c4395dbb78d0b62073c117525475de6c41a9979a659ff6062790c6cc20101e43f59026320631cc26855fdd56bcfb43692f9e85e9390b9e10d720b74c523304a049f6d5a25595cbf820c52a41c5b683af0081a627181712e3597b6d002a123d6a054bfa532eaddaa1f9c2fa43297d1db09da529ba77277c7fec848d095121bcc1fe0ea2e4d71b7804deeb1194f65b3a3defbdeb6ba0e8d7be27454f985105883d9f19c009c25ed2f558c8552055d4fc4e7beb8673e5feb4354df06238859f31b5cd5ca2c1985e9d7dfd6ea5e4cc78b32783196a30052813c453d402707c9dd481d22d66a6c454cd65959d106b3961c1fc04838219b66f3a9c0d745895f849a2d68e8bdd2768ab90099289e4ff875b174dd9d0aab3844220aed91f4ce8c8165a5cdf54cdd40ff0b4b683708b18ea4264ec849a159cf2500a62320c49be9d0908afc423d8ccf40f6f16927c7c9e029ca1e27ca8963c20a8f15eb27cdc542102bde92dc18bcab89fd3cd6689f698741cb659681d73beef9a44d50cabcd6ebdb92a88f164b6352d93b05d236848089ee5f1a07598f33279907e2c1b9fc55bb73df30945321dad79a141916b23296d07b9d2170dddccf9fa146534333a9985739dd620fb3bb3c88c2822f7bf4133e9fcb6cb960605fcc06cde5e5b94186d045bdccd248845f7298358e49832b4a3ce2c0238747aca0e883ae39af6f4963ab029ef3d78814e6dff8220f5ba41be765470fecd3209ba44955d00eccd9fb924ac175967c264c6a445f8fc5ef76651d571fc7e4ff731f0a564b408835144d87b883d7aa3f24750404c06d78c9f065b57a7033331883a26fa1d3de69aa65f453f6f732b623b23a21d6cf1fd9a35ed77b144ccc2cb0ae39a7b744f8eb4856303818e5c82d2018bf22a3cf078e359753930dea267f48e4e9d3db1d5002706c724e494e462ad471f7eccc734b7dd02a384c4f402b662ff33c35be93c06889897d57657e7977dfce32a0f6d02ce3adc77b34af9f22263ab404f88d1d9573e6a1f1b1607927e81fd79a4d1e8ddbf3a2c8e1a92f8141a22c1a22554bc88ba5be93af5a54ab608d1fd8cf2ef04404b5f8aff50c82779c3e0e68150535ce4e04bd97aa28541bee0e214e14a204708356bc113cda25fee0b1e50b9c00645de6cf6ae8c113225a3274a6303b34aa7408b8e5c5e35c5cc80f10f24cdaa6c87f18b4774405a24e301b712408287d9e48a72daa726d863790fb46dc3543c8b7cb7a3a1394b70afe84867141a6594d2d36040908abb65d6eb539929de81e27217e49450411fba87c8a175df0beb3f81c64559f45532bae17626adfa837056872bc8f51628726817274d0c17b6703aa0c559397133aed1a7b12bb1d6029112b79cf5a26529069098aef22f0331c814159d4bae0cc91db603c5bb0e3481b479f951c67a06f075937d19a4e2d4cfc7fc2e604f59c383a88f1775fbae93a4c22c529a4581a0ceec498a782cd6bc6991f4c08133f7b14a866a7b13861ca448d738ab9a8e60a2015dbc2db192097bb1d87df887f85cfc2d462cb6e1c54ca4090374bb12e91d331c83da119cc96c8dabdd859546c3c69be55a6dd44924ddc6941e219f2880595749d9d70f9ead23a6838d09a5c48cfb800aefa1d9978105d344d13eab180a0e578018e103145a6445950fa86728cdc7c59ad19a7030f34b25f27f7fa0651f8b667db49140dc1596c6fb969a6fd2b99d1ca04e3b380172b77aa7262d428127937d0d8dee9f40ca82450a11a197bf7c4b5db0b1bac56f7f28d629cde4694893d7ae88b29a01bd2a2944a8afd05fbc0adcd3c32e58047433ac6449c48f360bd922d28f180b8c88629b92a95bb77501769136a98b3f2a12eeee8e53804cd74351a6b2264c2444a240b25c9330580d820ef0cbd726f6e1749f6faf279e37d1663976312a4b485f1e18abe117d2ecdf162a1d116b18975bc27b6e806df24cbc0618574485beab41b8dabcfa9e0530fe93d20147ea837038e13072a496be7c23ef60a074574888d979b6a690a4cdd5b0f67921f20177ad9b782d86ac95c2b4acd297fd34d84e81be44750f0503ae406e6d909e9d0f46a9009484942124af377600b4a3037f68948f14240406a38f501aa1257f4936d3a0736288938b80a2110c6a2ad1ffe29445959a62ccfa95f719235e4cd94c83a863f75098cfee97cf6c7d5b0dad3759b35db5ed8128cd0322919e2fab0b7d08ecc302708b99df12232d1c824344fe3670a0c21534f89e0bdd2f7740dc2ec794de2728657cf141e0456cbe33026be29b8e544f6a4e655bc6506cf9e9540d80a3b92bfc78729e5523c8f06d4a942d72fb1bf7cd3451a01c0904e7980ee45956d23cfae32144941d336cd397e37d509e6124216742ec8548210b9a6c9cece18671639c6d704f63bb6565f7690f7678721a690af9fc2987d0548595fe30dcecabf6192d83c78f8189260caee6bb691d9e5e1c388a1a4089baf06861450ecbcfb02efdf7cbf0a8ceca30eb394388959f2f2375cf46470a9dd6671e306563d697e89c7b427bfa7897273292062565a4b0a3f85fe76a015cf2ed6e4e33417aec98284e41dd54f517c69324cd5892b9cf478a8440b876e37d2b6bdf2d6833e91cc56071aff6dd82038f0a88bc643f7a64bc074518f8e200719813b7a096f4e435f632ac612c6657a4ebe74d23aadc5b5134dd160a474a1a0034352b1daedddd909917d152ceb277cfa11a74973f15c2803abc6d71fe45cf1a879adc8824246f99a8c3e00db7b29c5e1b3058b7878fa9db805fe1da0f2aab3e50f687b5aac7023f69c779d41110cdfb54beaad3db9b7e139be161eb7b381debd203c96d3b71dd5820e229067e67bc44cee6f5416fe2043f70a46a9ce7a88a4a41b037f501374cb9968144aa8606ab69096c65d3b6a6d6d9f9bc845e2d09011a0961b64011f35a737b46b4679b68599013b56e54b5e277eaa384b819ffdebce902a64b8d002c094124e91e1f17d4b2bc8c20d23510b6c9817e45ba782a94284683fd4dc18e474dbb636981adead3251354106dfa25c1ce77da0c0130ad39f1977d592629e1125846d6a56336a105d8fb58d1ceb641ae013772cd3ecaf0b48acbc4bd3ff9b70565709f5989960397a587c4812e8cee5d01e27ece34f5b16bc86c37312ef8cd7307aef4e6b6b66ba1fed527dfd5ae2d9c77f3ae61c6378422f422e9ccc85541904d391dc4fb7a0153baf24700fb94965adf575e1596c694a3d3a381c6d2db755f630c490017e9a4ddbc505b0bae695a6d42dd2a492782cb59c5d5bf5922af9b5f3202120c53b3eea8c9f2021b0dcc3c943e1ddd0e843a7d9a8ee0ced8dc87a668f6deebfa164db991e1b032fb462585933b6751032b651960d0f2d026eaf07565ffa40cb8b25ed15fe84544923eb111e29d2efaffdbabfee193a5dcbcc5c30def70bd7f585d37cadf6f2a8897b0a5ace33f8302b64b284f547a59ea976592065a23280b35f2780231becc3198b035913e200e6e78f38a3ef9ae646877463bb09c326537937639be1320652dbbc72cf2b645055171bc9601cbdcbaa70eadbf64c54fde5f78c42f17d03351f529b2f3cc55b1bb9466889013c6074210694ba8c3944ddfa8722929e668ab163625f7cf03d3a61078fa779879d71879d9f35c1829c26e55e83adf9cb255ff4bb0ff7fa237899ddbeb2b71fdf93fe59de5f6418793464477730cf1faeff90781cd1ae17df7ed625dc71e3b4256547fd8586a819b0f26dc7f49adbe7f09fd7260259d5845b50c43071a2b2346410b054df91ca0b1ef371adba99a9d556be71a95ad49980d26185a8c6ae7808a999a34bb9375b423557648d6ec92d1a68e8aeb3152257fd3573477ef62471562ccc4474707c056d612e2f1863fffd44a0685990876b1a7c1a6c68fe27a1127102413b432700ea794187c6f042718ff6f6c0d5a532514fb5c83aeae80856d64f0d5c169e4119e56cff1e2f878855bf37df1a5fc22cc0c6c98a933efb111054a7538bc1c32976eaff63040876a34e60eb67e442f4c126442abdbc764ca1673e9a8a45a766e22c30224a2c41bc9a86b10d6d741837914eadb275ada129bf185b0b9c46eb35afaa91f133d5428d1fc0d251ea7e8e1e9db869301e22078810d9a459a8974cb822724f588298a4b0b25c69fd6888c80b94df1086714c726af358b756f1fc6360b469571aea4556fd16e8a2760a2507d92a05d2eb7f6e35e9ff1ded52175d7b163de694a05307c59ab70071fc791c81f0b8ff979e164e3d0e1bd3fae6d44677e4024273174119f23bc87abf1189d5a34ce780d754415e295301f711fdb51c80dac45cbb17f40095220a97a113c50aea2e979e044aa17161b2ae9289f408cea251fc0a36f84174c70dac9d7d4aadc4c3ed722e7c2ab3362e7e02751cc9f7145af7821fa032d5b3aba9e7fc3fa4e358501eda77ef6138ae9ff0e0d1cf1bfa184a350a85b5fe1e75293357819acdd3afd62137e1ff59077f0301d32eb45ce0f98d46a4d46727b091a64f9a798093b97b92eab9c249b00ad3674e842c58fa9329f1378297a8a75f1f41961ba3d9ebaa2ac65354d92af723edb1140eeb2b557117f04bff12fee3807f9545998edb4cd24ae37ffddda6a15eb750be48630bf0147a7c0f44ed909d96bddf04658fe009600344284124d14327f0724732cd16d26d9c4271653faf0646318bd4c9198fd8a7014341a0a8bb02aca93268aac4b99da82c7e5587e2cd51c45214cb7229cf9b43ebd20c72bfb14f73978d1a42c23e4a19434d1052cfadd44c3b45122ae519d2023d8bc19f61fed2f1cae851b94ee122aed9c09884b283524967ef9e0f80fda203827de0562e198c2e1f0936a1d0dc14c53e4a64e2de08e5cd384e32caf568e4954579c32a2fc83b6aad4adaa702b0e8d64ff2ba18973ee6d49a35f3c805393b71a1c8a3429d2ffdb623b166801409c82f00374482053462dd309db084a50b73f5ee42de462c1d4faa12d3fac9ea167dcc4b7803e2315bcca7a75154f5fe1802291b5eeb94647c580b297d485e8cf17d47b74dc55632fe149cc098dafa4a8c577c0d713db689610726ef5bb95f3e4ab1efff63516dd143f51ae6766f91c826df31f9a80e75b5ee97bea1e04d80677ea5ab55e08fe736d5854746185d1adc0ad50f3867058a3439d6d38618d85018251831d37007818056263c73993f21dad787ed20e203e3673dff800071902fdcc2089529557c86a5b842e7ef5c7f84022a1149122a8e17a059c551802f07cc64bfb93b69b116c247f26b3e6bc5107af75af33383b87313d3ebe6753b6d0682f12a4ad0b79b4e23a8760a8bf7d03fb4cc6e65c954fd578471313115ce7e2d22898892ea363828f9f1a5980509bc78ce5d32e048a0d86533c881edb05847e2e922fb12283e738f69c17d79229f848e923062247ab94b8d17ed6012d258695917cbcdd64a1913aace0b10a61c6c947798f42ec81d84f2860390d48ae9bcc269998f2c79e66ec5bea917a849283c3c705851b90043dc9c784b8e5762c99b03c4696258c194991e64ea43ae20dc996f1f86f9db8e670e56054d126a679c15eb911fc048700299b6ef609c9719e946381850d8129079a058ceb6252aa2322b2dc797415e196663f7cd40c5edb42583769dd8a547a4a6cf0a1d7f169796506bb6cc9eb1e6ab4badeb91d4335e6a9f680cdc4060b9e2fbdb87fe950ccb19928ca1742f99aacbb63c2c0a64d7698f654745d34155ccfa44c18c3a841390b6d38c97c0c2cd0510582ecc6bc3ad17b26ca34a2fb215b1a6e112ed79508be134e09ecf97a84ea5fd9eea2c610e4aa977da1cd9011207630af99bc0ebfb13da475e51a8b92bd80ca80017c1adb0b53d66d009cf97e8598139cc072c423441a75501f6f45ad4c1afdc6b7c18ede322a5adecca571632a7ca23e259d0b3aa7f207305f23a17e45d4a20deb6e684c9dde60ed83b6e121ce158c704ac6ee642644befb05667a4b5fc4c01dd37e4d476adfb6ebaa138e93648f17f90c963a989aae13e793d29e1488050d44ad528692c5ef8444193c4687d984ea17efedf49cd452264ff6916c5c33a5306323adc1f4859fc30df9c4a09dff6eae7240a7ed4d6885fcb63ee56e975eb90915dbe883501308aa36b0eaefed2da7d5f5e7f10e37c544df6f643a7611c9947346b59d71cc60c46a1d5d6c41d450dbb410cbf79f17e202c43788d89b275d838352962450fad12b2348404315c347c994688b95544b9f85be0cb3ebea3d961b99681a5b9bd13c329aa23d0a6d2ca80551323394e1fc76ef27787d0eb4b89606161cdb68e5f538a41c7528bd9b525624db2efa1dd18be7f14e7e858cab45b2306e726789d1776b30347fe90d023495b923b74d674739702c9b9901cbcb9a4e7d3fbde930d6ef6c1775597df630baaf859171dc51d1d93fad28e8a452ff234801a9ed7d2cc2b1684453bb99527263b9a8c11d654ebaa5c4d098099e49332a29dfb6113293932dc50d822bd19af295c1fa8265262dfa0a5973e750e33ecd037f8c76538ad373ad9f63b9e40e4dff4b85e67f79660e27ed1e45d10d710ff4b92e0e0a887bc72c915e5fdbe6a5f2648ac95f163a8edd061bad1be3234b27308c611b91043d99acb0f64ef6f6ad04d56bbc4e779248775e1bc128fe0118e33d3d6a44c0efa759e7d857a77b3436f6f03d455a29286c20e6d9162cab9a5a0d24d1c31fc7db8964be9f4fb6d7435a0f2d165ba0f50010af81e0527a6170e738ac0d3f3c1ffc77b2cd750627a768cd1200c86597fc8d7671a41f1fe151ea7437534874612c25cbe5a29bf7192c5670b807de735659a91990d10938e0cb80e9a3ec6d5f53401f3670b9f3c2cc31ed0e6cc1311a0eea6989f92c9e8ce89ae97073a0e84194827076ed2e7e2e540485e5c5cd3c68ba16aab9b28346116a97cf101c815257cb0012250658c798a256a8e8144d3eb0da89423721cb0a25132217968207a076f8e0d40dc0607358a35963e6e74ca502187012cd8405efe5070064d9f403f79cf56f66a0c0225a7c7a1fa97d0ef6563bb6a42564e43539fc60006a717829a05547a3b5af02c43cfbd40f196ccd5c9e4f037042c46439e805dbeffaa7ad0b5d3018f2f3dc72ec8521e1c5fb974b90503d5c76b1a80404695f710028f69e1f87d34deda7b7b28058a70ad53a5f74eb429c44a52f046500f5fc9eba780256c6961d14835dfaab413b21fde04a2800dfe89096bbc878648bb6880680d9047479687fceb201b1d57c0fba429aa967c96bef8e6f0ad7136670656078e3ee3fbb4d65cb0af1d4f2a0a1b85fe8e0862267f748390d8d45eb1d16e0fa3631fbe0933de0894d3c9697e5ada267cb8c050bf80906ee0cf5fafe4517cb801a1951b17088ec2512afa0f4be5ace3ae61c343c627f78e354bb97cd0629d1a6e924571008a63440fad7d5f69cb6378a2f3f456d2ec4f617f5e8ba8504dd783b650c988e5b49585048602970a1b5642a00089405d71ca4f7b40f617bbf36185784fe04ec4d9b5a83ec0fc96e1c76868e8ffae0e7532d6b7402e5864dc77eadbe9275e403bbea8ada205f2550c50880e9b0342851c5c53007b7d8520847fa489c60b3541aa4c35a7856af6496392486cb14bf83a271a3b693f742bf102c2635b03c601cd23efa33646f5fd9b46fa5e44204727ccbb221934309c111ff8758719693b6ba2e89d12a3ab6dbc7b243f4bf6c8cbbb5d257d00e40f3e1fa92a9b8e9e46493256de71d1c9163922ab0b2a7d0a9f5cc9a8ae335d000918099ca029229a66de2aa651815c8428bfa1b94782f799057549f606fb8ad3d58cf1a37065da603094eea4653bc593ba402fbd7b20a3366c246981378dd291aa7b44442e78bfc2084ffdf38ee82b8d612c7f020babeac14ce5e3ba1fb707dc997652417564188382db5c25be645a6d41b16e817488c1a5120fd866885048788d075226599c81c1df626c59c5add1e5fc1962baf239237f6430c0fcbf97ca33111ab99144d798e18e664d5f8e852eb48d85396620b0f19cbfd12e0d867aec51d53cb01a81382e184fe12b8e90f7ba568dde8721f7abfc30ff322cf097b48b8eb1ebfd004fa5aa9600184ba35118a8cad1620626be68c7bb9592970a2785759d6e86b80a0d39ba9ae6823d4c810a286bc913df00452d023c6e0eb2f04453fd514b413683505c662c005bfdd9be192be185add7af4524807145492000d2ba8426b0bfd8f5de09834e0ea1f36cc59e79388f0c9b695fc273858ae101d3bfd2464bb53854f9a82418dc01f374dbdfbc5655b938c3da8dd6a0a0ef05a0bdf496a7d24a919181709c5ea58313e4f5aa1c1cdfcc38d146b4d784bc92e95c47a132b7023b613795646873fdbce42803e05d0cd01a9456a3144b18020e76e185d232c6edac45aa67b135c050526101ef051fbfca73b21c0a02cc5a9516dd0e04ea10ba00e3fa2e674c251450122b9f63a24cd1f262344f9350647719dd8fa4c24eccbaef7c4768a043cae22a5bf7a659198f14ad7cb7533818cac48bb6fab60a25723aae79572e14d3ce7bb56f96c38ccd7074a86c5743ee6ce79036e66c7dcf7e119d5cb789e85bb10dcab84b35900e4d40d66c1c34c4f2f821968b3923fd314bdeb55be17aca04245380daf4d6624866311133b40e4993951ab5630f9940e8ae0502f8d62678ed5278773c3faf6fdf7721aa02af6bd7a7f8cf2f71adf29087aa8b6b77715765826b9f7cfa73934d1c16c50e8f9101de132a073a7b3fdb97ba216314bef4a53bb8dd17bb72050d5e4a7951a176a57d6a9b4eb16bf4aa854210b7496ab3a461c29ca6bed739e81f59e071b53447c40be7ac99bb6d166de1f99e073f392a193bdaa7eba1ef3f7f5bbe1c9e92e063a8a816e8ea3f3ff2e70ae67c4dedde7c332d6b01fa00b3e8c7b168791d82b8be9a15d6118cee92786ac1743914515100db77d168a298b3034ea20e4a4d5d024a470048598a83695829585f56d995eaf536ee0dd0089fb9c28184563dc83f1436837b83d7cc3729c3e9e10f26fab415d501835712bc23eda7a28c49a63a5d07d202aa2f6fdb1da32dc38bd24110eb63c8102e11d5ed1280b7ec3f741b7da61e7eddd1b044a973750132aee7b96c2d839e0d3d41d506bc4e2cac0d001170cfab6e2aa593b166b19b9140a4f472f02a51d0b38e31165294dc7a274ea029eec584048b2332d551be042a60c59cc91149f59b46162de580a2dd2e2e7d225f60a215f7b96b89968390c1496c075d1015fd598842b8612607d07212a77294fcb0a3ff122eff95e06a5a208bfd4a6a91622d34518b43f5c869335d82009033422fa0383c9a47c21a2f00a80dd96aa3545e1928fc0e47935e2305da3e61e48ca4d281fbb197c0b91c43cc1696ad70d51197847dad972cf9238f10ae36552ea649d176f99f987554654a6b24eeb74515a2e909a2718594f4a3b47b385aadc00ea8c6ea49e2c2f67233f66e14014592f92cb2851836052b393df3df7690ff668a34144b2fe60917fd8ac04d177c3669d12cff0be796aec9e94ccac0f0e024803def499f42c8edcca491055984141164ad60c442a9e344b62ed9d559095745ba141602fad45d1b0562d185e6bb8421ea34106620010d574da18ccfae55d55f6a596afff2b474b8ad57793be1d888fe579e4eb6047f7356e68ee30c442403bba346bcb94d66620b8d24ab0382e818fc5de51b503c6f8485959aef311a511dccb861f546a9f074dc0ed2028b02a44805efd094051c4a1e01d221b7bbac524a60cac58667888073bf6c4803e037cacbd4736bb1759db6fe3ba8d48298e8adee76750e04a2a4cc2c3bb2292f3122468a9b4774e4e91d088fb524ebfd01d29e094cde2009fc7ad0ea755dc1048f53dedb49bcb3d8a128f61c8f6ee56d8ec2355bc5af5e0672a9a0f41349dc3a8abea87c0d9deb8693180736adcdd35e07e75c98941db24d6fcf50bfa9a76055313fd48a8b6f5e2ff3312b9c492c18ce7a02f6cae990e7705512441fd1ce32c511127be3b5c6041b76d3bdb196affeb68a85dd6ae813cfc7ffdd8488ca98227914a2bfd21edd4e80e091bc8c3258540f3a9055edc0321476f940732778d9108ed69971c0c79a603cc46a5530199d638aacf3edd41c8d3714e6d4489f31aaabf52fa0a0d64743e87ee2e5d8f9b1b56365dda61731c39f528f477c2d232d62c25ea7bca7eff94333e9cc22a9c127b9d5e46fda01fe421fe41d7fa742c5a847bd351e9681830a2cfc31ef7dfda2d8583bfa70189164754ed51e284893471c2c27277a98016d5a330930fa3247ceddd90474f273a09f331eb38d09bd3152b1c44f5fba780c90be1682f4315836691597fb9f43e8b3b35240b80bee139034eaf42672b3b19014954e1f04ce9552d915dff0a9492a37f6f5337d4df34fe112d808bdf25ebc349c6f39ecc1cb74af5d09c193d11b3c798f07254258fa60231e6994b609c0a8688d707ed82bbc1f2c86ccfe380785bab3864d9de6eecb703f2119491ac75ece3b445323b0eb24c81b6890d5212664a8eebf31639d2250ba96994685805762541f83e458e8f92d603c08ca8c17ed410f4807b06a68ca6243052dba3d3e6a6e4d7ac1160f9e83a6c4a9653e718fd8a0d5d0200db4f5695ed3ce9fe5d74f104b509e917a9f537191e36ed33b7b42100bf2eea794d8289967b95e7e37d79be102ad82ae718160f1afa88c76ae2b6a617f7e93bc7db88e16793d2ae0b400860a8fc6eda1952c21931799da4d7475828ac4e29daef9c261d69c4e04aecb4340959db8705445ec0069dec6130f1d18a097102dab338325abc82800d14818e9924d351f44f95773d04f1646dbffc889a88bcd28467d6eff739443b8823d9a4cfee693a96fdc15da5a0c17566ff6dd7400ef44e48088d52ffca79ce68e2e23d73458f65bf9467956c74bd504377b207b4e605bbda5c8e6750d7b5d7dff79339e0895e314a3b7bf063d8aed54dbac394b6efdaf477768559e5241082529a7a1208e2fd5ba55d85e992ce90d1c5e44a2b47a97ee4887b4ca778d408fe721d0f9354bd53cf17c969f398a76e721a2f92e0b68e4fb10891dcf060102b484532149295345eefbd4759c0db7d8cf3dc88c6fc34e8193e93abba1622f89840f2d21f72ba4ca447e0b6f73222a32e56b5193ae4f2d2771120d0228072d7218ce77ee8197fc01397ed084346eac458ede2413e411fbc95b91e78da772091de8592d8b4356d43e81d1aa8651e463c219a120e154abab04ae4568b463f104b57296a9bfb39100d49c28cf1c719806fe0d79ee3d5e32619b9fb41c510fe83ec729f218884e7bd181eea68f415fa688c4bb37316878ac5c4c0d666a5d8135a3d6c827a00e2b9433325ceb6d7c0696d8feb1c950fb150ed54a0dda88a563a84df2b5e37ea0b678cab460c84411f1538d0dd65a3ec5de4cf0c3ca8b487da1445c6e1a02b97982a719828c486b34c59ec0c16f140e44813e2c38e1da7f54dcc7c878281ab1492167021ffe40a9b5c56715f051bf525becc89bd97e543a5120f916aed56d69019d8c1d703d1a19ae38f1791c4da632f9d0632d000ebae327488bf46391d0abc3c1e98131e95823c083dae1a30860761062cd2d3cb9c60463cbcb67953f019077f52419e385f410119636220194d6d1c48cdbb04d933a1e591ee8f3df70d33a92841a57383610298606a421e121aec7e35f1222585328614fadf7674414e635b36459bac721c5660a70d9293f4fd64d9ab6265e7a4de49c205353c8f20327dfc910d531231da5a562a7e28ae1192545238bfad2e616d6892532dbc09034984b5905956b2f2794bbeedfc3678764ec104f8507feffc79df90c00d614914a394954f45575f67fe4d6a2f823bd476d5ce8d252b55175f698d725bada9424d08b47413abf077ec37c03dcb1da1303b8d97e9f1a1c227a51101f6d75921294074fd37370a0d65541fb9fa4977de1d542b98d94742d08211b97a483ff63e4976a36f51ddd197a4e865ec7c3bece84d88fb3659873e5a2cb75a18288204276614bf7b516fefc2300761dbf29007e1dd84db6a51d5d02dd5ffe26010f2ccf569eef88e331d4d6e9b1b6d3be695215ab6540b5335691721decb8bc1301c0e4eb547d008dfb916c49debf5e3d5c77a5b97cf756459c5bcde33af75a1c9f5b432ee3a79e77d36bc140971d256e6a211d5fa17644a06cbd00e7ab791aeb804920d8410b5b79b4e90cb72a6b29aca3cef5576e268f812d75bc973f604e2b6b4e5327194ce84fb7b284d560589a67898df7d06f950f1300de90fd34dc1d247abc374610ae63c971482350d986ce88f111571a4165661b91800b72be620aad9fefc82310034053811a08f0f0aed56a4d8f9206f11514d1f0ac16db842515c04fc15be54b047ff9dcad7be144dc765ff566908f0044293ae69f991733cbe38652dc66fcc9413af71f4924e36add19a907756c38b3b5b801a561953994a3befbc082d13941a26ccd8e97b8fbe9d9edc7f1e827b0ae786657d97e9fd106d8f91e6897ce945c81932437b85ad516698b6b1447bd8a5298cb87cbe8616e69017a2314f53ba2af6c6ecc00fcf9a0da605a1dd220f483d14593ff533bb2e92cee4746b4a833330c9cd3bc648982e176d41d0e965ec1318ea6809e1c64c63417f87983714d25950d26e0e56fdbb8550baade8448fa485cb2d804b12016be1d9af962fc6f715af9cd141fc0b58f3912f599ee1f8de42053688b0274cfdc207c413296a3a768088e1f4e0bf6e45a89133932e978dbf5e3a42f71781a845be8b484f40114be285a63da57b6e9815bfb9062dd707f8e1716f7b527550b807bf6285b2707e9df9de14134906eaa0e7409bf4043f20671926abfc3d6b417d748df1cc1be5c688fcc91349a224196e9421aaeea1bc67845c58843e1a92e37fc903ef76e52f1b59018f1e4b1178ca28170a622bad08664350191cf3f90500244dd754327407f8ed1b3629dc3e8c7a2ef525899a8ce551972cb290ce4b0006b9d45e44375039b0c194d1ae29381500e3e8c51d3fa971bf48daf18c8e8b9d0763b8f141961e80aa2f1ca4ea20fafba97909c669fa4fa9db27cece60092e3ac5c7349985d925baf86db82c86295973d183cea0611eb57b4f9170d6a4a8f066230dbbe15ef97d14f22308496b62b16423af6c4e3d32d97539c01735a25548d0ddb49119a6989196bc81f372e2ede51187d0f1d1c7789f744de4a87de6d0112206268057e7fb982681acdeb6511bf2da70ec3a391f1542228c3a23b9025c158b83e00f03da1bb9e3ec6c2fe0989c519a9e9e21b4f0d8e07d2367d1d5aedafb38e87be4f808da21ff13417f8be908181af67ab3b51c8c121e8174e13af04fe85b93d4651f541f6db745b3718883726a25cf9a0d9283d1e1e8d598d121859e8b509da3e64aa798ad086e29028806c2de4438d3775a060943d0af375bab9284e3c3a131d981c8cc3785faeae24622e5f87b06fc83119f3f728400fc7d790e70572dfe909d11013218ec3e5ba52884bed9803797f11496292f73d795ee0206ed23225b5af1a9e8c722cb081cbc97a68a450d455e382fd2755aff05da5bab498c90abba44b3f03fe9257a4cbbee1291429d986f105d3d8aa736bdc624444740e3c744576994fbdbc7a1bf949ba99eb113cb3d90ecada91d6b758fbf07fe79c56ced06962a3d51181d8e47ff0a66bea5d4fa7f3d4d9a7681b99b497e57af3c437def6360a44f3ab9c8b7d3ba0f21d73eb093336846324a120e47f6537f532a8e7a328f53a9a8be269318f31ceaa25304a0c4db6e0ceda2d2dbc504cd174ba6f864510e628557f13643afd593c2e382339ce3c6fa24c00221250cf1a9e441a35af53ea6de4d014e37a7cf5484ac45156453a4c5565e74369115fd505e2ff7fe00a296712612d3e9714a6a38dc4bef3c308f0a62f5095588d2957f362fe5f440d820d94040e628174b28450f781771ab234b03a282a0b93b325fb5ab4456a32e071ed83b539efc35413e5734fb527a73e4e094407fb8e1dfe2cb5d7e6e1e4335291f5fce22afd1661185211a5fb0f6497f331f7ae3b061313dc274763de4ed1e7b9feee9adc1d319fb2874ac162d99cb4ca56852017cdff765021a388689ce8ac35b771b5acedc6f12e8d377a3fb10c126e1277a503af594d6976c6d010158ab9d8023ad011742b7e035bf9c29d113912b514ac01eef3d90a27845a4094ccf63c8cce7c3abd5aea13aa45a18bdc4aeb6fb72e489b2285cb736f556e712a6e1088f977bd27c953385a4f1db7cb1a9dfe14774f3b4dde20bae242d388c90b4ea63fd515330ada29a4b0968873d14cd98d0cc88d20a67f0444dd8e9486b0a957cad909885705deb791089b40e5e8dc4f21d830e9aac746c093d2f1923db53ee725f22da3ed90e0121ccd0a42e169586e0fca06c3e4e9fe7dea2c232496c625f6011b3b6bf8e21d2bb61aaf28f7fa3afc03b7e15e5bc40f858d723d1367e65871d8b25b8b917d8009084e69032c0a618e7b5b218928b01027b4cc8786dd2f4d6a846cd8e22f585d985e0b8300710396beeaad4cf252a27576f1459bbc3e4eb7c5f48cc44c1d5c1adc721c538c18a432293a310e9eaea5a1d0736bef4bb64c6dec56fcc2a0d75ea141722fd2f8f9ef1e15b70ba4d678fdb167356613e4e264181fef776b60a605a39629ba7c8675c456fcb211203b34ea72deba70129d399bc749c0411c7722cffaf43359c113454c07c5dbfe846660e374bdf84f022919ac66f9b73c3defb6db5849235548dbd857cea9e3005a31a13ec81c7a08e14398ee23f54beff73d8a8eaa0d7a658ea1142b219033070b373bfab879f5e5ee9a9dbdee9060d68f5e04742a65365c23685db4d5ada6785ccf70c96c185eaa177e407236e27bb4d29b011a76be2f323601103524a6678d4f88df32e5855b3fbe59f0b24ec285e85576fc6538a7e9cc75534e70816766729c05198fddb6e9d6c248d4cbb5492f10f8df502029027823f808dbe6b42df07953648d789633607a5f1d9eb5e97c54abb1c8f74f1fc14279eedf9fa96a2090083751e866af3c9ee394fbc464bb5a5922e65722ab1523502c0e88077f7700861148da0410fabbaf00ada3c88eec1de7667cf5be321f77838ba587be1414e9ff540ee4b1829d38d06930369fe3b3cb206157aacdbc26e446bc21a14d49034627bb476c9b620091431ea590dda99280725277e81532655e7f1e910470eb26b33373e3ea08d0c76b4424ecb0d79d78734df5934b548574b5944310697556b7bac23071ad838482192c44f7cf829c1a449d4d4661ca3a6862350ba1078e63619c5198378cc83fc1df7168f3d4b775a923c1287dccb4b8dd6280c5294ba3e59dc04adb14f461c1e5b7de9ea9aecd4550b85b681b66c6b637d8a607142f2d69ed1c25d6ae0c5525b48a63a13ad597303b451be63ba66eedc75ccccd40765fd9fa853a81e63e83292c2de8c6d6f415d8e6bb7d6c4bc070eb9a456a2cb5a6f59c532aab890a2f9dba868a1125817231eaff7e59268376eb51a2dc920d182d176897d5847b49c217f0322e22c0aa6ce63d67110bd3944a982125e1216505da7bd61cf036a548197034a7cc58612ea387a6a9dc9fbe14908908f40c06775da13e384ac2ad72e404435b387fe52237082e8e708d87f29def0e6f44f89e9eb85f3560d5661139281699a8f970408881320c1402bff78c3569c9484e13398030a464d8d764f6f70d137c341d5fd111397a9cc0deb4fff2a253a6148fe01ee9676ff1ad3db52c073537e72b869c4d247ee53461987b433d50c176b1b26bf032b8384944290d5fd8f6c7e9c1e90b91b1c15bda0eaec5dd6aa08b9ec32852c60ad47c4a7c846d6954e88da3586bcc26f1271e90888266f54b54e3bfe31c02a88a50aecdca378cd81c02189c8d46436ebb4cc9695347d33536bacb80d6666b0cef3f3a3a16a4b631d197ba1212aa92164d61aaf3bfafa3bf7e691dc2363f121db81e95c49c8f84ba8e26f54ebb543bc7fcc78bfd3e83d550b30b7e55f90b1864aea21c4babebeb3a09013c37a02b193d15697104f8bc56fe431f655eff81170712f0f269812600215c68cc1ea446548186c3c86c43504cbec79a8a53aece6c9d683f5de3c5fd588ae52096e3d9c1efab578fa0aa902257546d73420bf6b84954d7b8d9997e9f204279dca44742bdbe9e2ec542e69ea41927bea276dc091dc6409ce3dbcc514944961ca08e5be73918f6431acbedbbe3ee1443345a5142eac0cd457fa51671150092f3f9137f83866abe5e8a28079b36e8cf042c122d723f56d7808ecf26b1e2c3ac53a12c3247b13a13d5c0790baaa883e8e696b799b23ba58ead308890676b35c466106442e3201418618589c805b7fc2fc2a6b023d8471dcd6c083c3627c90964ef5313771e414cf48cf4afe6b6508a99202bc95eae717769e52ed24452c267b6a789329e351aade4756027b14949a248aedc23aebc17afea089924e913c6830cceff3a670460ba0fd0d1cc6b96e0cb33ea64ceb5b3ade67303547b7330c0d9ceeb6b2f71e6d60cdb2081982483567da1a1a7f0a413b4c6e720035550eaf902f34594addac78826b09b7196952eb72d924782296790d6734e0e3c29b414224564ecf307fbc8466b70ff638238977e6b2b1bd0b60dd0f1949adbaedce51d778e3a92296f96cbc047007c457de78093d0c6072d4e61430cc89167fc073d2dec81923acec6e5a896ece6307b7c4a62c542b4995f3e16a81c6fcc70b58c596c3e1879fed05c1e3639ae61504c48ecaea18e2f255ff09ce0568f1ad9ed298022b27980fa9da7b5d2a84e4be56dbc6f3813bb443892bfb698da902a9d7b3f85a86b9e6f34172e6be038704ad825e8636cf341e9a5b1c34d53b7636be62e2cc3168fdcf99c6d84544fc280918134a5a6b35fc3b817da4dd28711ccba44864cc4f74445278c841be91d4f8f8a6594a5104199e97575938dfe086bfa4616b742409f06f7df7da00ca54b986fbd20bed4bc881050d7b5c62a9633a778d15ff959b2832aa5c5565a55c5d456193ff6befde5f7be58d0054210fd9579ca64ab835cb1784ef6028df3a65c236c56ab5e960e1d8b1c7f2503f5cc5ac4b25e58ad55b452917a9f62d98e94d1fd58e2eb2a52f9269c14826cfd2e983657f83c1536b25cffe5e5c753aaf6a6ceea7c94302949ed7fdaee5feacc2f5d4a5659dd673d9fb45b948e8c36a65b1aa1f2b90c94a973938bc185a87d8563f9a9b3beceef98d3b4013b31f4fd9c92c6cb61bc65617aaecd4f5ad3dbd49bf93520a77cd506e41c28226aa6dc16f4c25bacd16bc889161b9ec39446b1e88e9d65b1dec8d575c568511d748d1b2e3e977b3fc91f2fc1190f0473601628284d2814dd681197b9a5244f379ef286722203997978cf5f830391ad1acaca6b910b28a3a894f807d02b30bdbc8a2bfa649b1a0b10956c055311facdd3d5ade6339834c085543ca553d7008103f43b58cc96a4211f35f0de33033d0e73d8c490e83334d4e7c8b0a8dd8bf686f4cd26e79d191a6675ed85f72c52b4a86ebda19cd6ed01692fa9263ae453462e331961b2a862ddb0b79a3341cc727fa27d4202a0bc98cbbe698848b58a0ea195ebcbcd2b58df7e628b69615ccde5aaa14f8eb9869769614c64e55355e7a64fccd48cedfa2076831a0c0420d736ad59ed31a65e55e15255729e2eacf88ec62f0cb69476ecec16a814f705452c5ad6902f72f8e3559a838fafb4acf35d5edb502b9e5f2c5c1517b616a1eb76c0f9d6240b76bdc5ebb0ea3b40145eae000fa9d42412fd3788d9e7817185b930a6eef4895c61c37fe7cc2e3f8c71e5575cd44662e08381f314e3251e35a24a680b97af984818d3eb8871967ff84c0409c89a1c70511bc3455379204aa6f2764eef76652335ad9a6d1632d782d3b955081dc72f9e2e0a8bdc2a42c95954d9f7935d0598f104aac431b09d73b58cac47e2a36e4e207fab3773390cd83e50fd37c0bcfb587ac99b6f30375e980a840260b203b79a7afa81823cf02287609d4fcfa146e6ac642b4158149f7a4cca0557a69d3ff5f733edf3e06849a0845742e0e11432d494b6bd65f3689b2a67d531ab7c5e82fb70ad2340e30f2c49a264496d0759224323f63a1895a43fa3c44c83073d943648fd414b3f74f10e46f770adb19f5470b7da00abf5ced32b191e3decac62d7a97463ca5244b40f915955df7fb20f662431676038156331062ee94e1347c5ca0f181a65049218917bc12405e33cd2fe3ee1f468e0726b0c409af029bf214d61dc0c0cdc26955765397c77a12336224854e61959e735b0be7b501e4271f0f19b2d6b570a8cfed4093062293ec7c2c18e22c7cadfb4e2fd62f5179b32e60a376cab08319b6a348108d2a9deabbfc07b9526d75a32ad05085d9c3a9b9f47e6e0410948793a11c96bfad2820c6dbf540a60620bc0efc338dc9522be3e8574c422f7b0f4bc128fcd30dc95fda6a4a73a5c2887620e5192a54339703d79b369117d603c9e1a83d924215c7aa3eb12bed2a3bab202ec14067168507376f9fa2dc4cd435fe57559a934d0d50e8574f5b811ea881ab579de04b4d46a55539326847741eb13dc4b400b5cdc55367a0dbd46060ace696a280f638c7956480fda1a8bd91dc95607f2bc00c2247b9a5eaf478eca8d1d8bbb312f9de172b5b6f120ff914c48eb7de349a497f4461a02f9b5e5eb43457bd2240ba523ca04570121b817d007aeeba11c17e756ddf3364bff5da359806c705dbdf8cee8b7e48dd417426de632d27fd140a53aeaa62293c5dccc2d8b6f4a9ac9b0734216294d209a58a788fa18c75ebfdee7a92268f108b12f4c1b83c9d5be8fa4e346877075b41d51a7c6c5e9c548b83740995a87fca255ee89ace12a6493c9486eb7dccc9b02d67f53b846bb05afc56b1a064d86080258d6175492516995a19a634c37707721209125d6362cdd600adfea90bad40b0eb3ec7f8d9eae2488f5a86915a29d3447e7597478530a2f086ceb2d4f582cd676467804fe98e280c381dcb2932889578ce6a8990d57710ad256a6c8398ee412649c14fc7fdd1a0f3a848d482d2e3b770e00d5eed8f26a12f044b8e57578687d4c93bfb88df125fc104de081b3a5b801e26e2edfb4da4e3257fd7d10515a2ef164ff78c627ba5380f704c3bc0c093d9b32cf024487e491f4d2beb110b8aeb8ce70db4006c240088f4d1a60e414a84d851501418b21eb542bee74d24fd3a6b7524b19491ca8724ecee9ba9b96b3f26d3e4776ffb93148c45d493a789d83de6bebee24461de41e017039d1980b67eca5c8489f14a4a75d2221bdb6d479b6bc9814e5b312d2aa485700190a83e0df213fafff6e158e50cb05c570f29026ad700ab9508df1c1c10abd505952ca0e6c0c6bfe4ae3b9ad7d5110f11325650a41cc050c28e90ce815c0ef7fb4b1e327a5cc2fe24afdf46e4db41517350372b77381c69b8d00a98b4ccc451814feefa516035f0b2a91bde09db77ca8057d4266b2951775955dd0541cb34d74a4db39d35de5f9291f4655c29a7babac2dacdad8cd37033b9cae554f05da38a321b205ec0a0805b85edf40966b9acf362ebb585c58bf467e4d5025f30dc1d52b997acaf80358711f41c4ee3da5c7df582e4d87029229471c5d06ac69cb5f138558ad1a91b2c7e5d5308856642827eb4799233ac8a58048dd2ee3a254a5a13250328a35ad75c505aa6ed342d53d0ae11b2e91b32f97aab90b0318a6be6742987eae3fda663b44812b8c924db6c539a63e74c1573b22b4b52dbb1d3a6e64c2a07248e0af5c7f446470615049e9f6cfadb2989eca66c4bd6877cdc4286f4d0eee92ec82a8185af5203ee8368730dbb0b9257afeca0a34aeed888672ca74b2900ff8204b8cad939d07df4c215732b11d4fddbf0fcecd2f41bc3028674bad903e4b0e2e362dbfbcbe471771de895363937a63cb5086678e3594e7c09cc29ae4bfaf2137e086d5d4c28a20aff0e24777f5c5aa0587a5a3e82fc009a9a873a1f3a06fba77772716228f1c7c5abd2a1cf38de455ae8bc2c5b08e9fd2e469c4ed41bc27de3caa3f82ce00d8f2d76089ba66d4f00d13d0c5c57287aa6b9fa1f758f8b76caa09b662964fbd719488ef500197caff04c751384a5a83e4efc7693bc727862c04231f9d1ae15b38e70cc710ce6d4521bf6e4e7b89c0b369aeb0c8c6afe240b22d814b5738936b6495f33b5f5cd4327e264a1acc9f7d2080038694af34dfeb4a69146e8b872917c6b5ad755e4338b3a191fd6ab53f465e571d18f5e8cc22f4633afb92d01a8408247e5449f3a41eb66c959bbb9ef416a0a790503f534801a95e41dcf8284b2ed1d91f2a4bf174d264a33ac7d82b188006c8510b0e394fe60b84f352c8f67029bdd15829bb65413f0a650ce13170c7a52d61ce26cb36679ddcecbfd34ca9a934bc5a801ffaa8b62f78a2add22ce17015ad01b06cfbd1c5c1c00ee4b7129ed0a142394784535ebb24f2028d9632d3743c63429e5aa5ec2f0bf5939632a569cc31faec9c0f962678c64615f7eede107911a7feec98884f94160e2527541c728e620f708b647d54d96e3c4e55e85807783df46bf7b5a9640f71c8ca1b7f35d369817625ec824efb6f64aaeb98a11f3d5197ceaf3f2129720536761d3ef4e0aa6e9cd6201b5393e55ea6570849cef792461ea65303edd41e202d279555107e2a8a81e135be8acef324c421d19335d1f63f7b612623b46a182a1d38e9f8e0475800e010f586ced1dc8dbb49751023ba70c27e4a7ac8c6cfc045b65fe54d7842b9eec6768d024670413c49eda57d780e3a745bf8fed7490fe974737a943cdbb9a1c7e309fc31148f1bd0aab135e5adf6e856af3383e1d7113491751638caf37f2ea9de3917e680c77fd255c9d938a0080bc9560bd889ffdecaaaffe432e4bc8adf53b0f99015756ce4c5e435094c5742e751526a59c212e9042967502a53cac0e541ac50fef424e7b19bdfde79c4d13d53e467892c91edf86c69446a5940ce242a0bdb726ca17945544e3979aa8591a090c27534cffe9a5aae4bf50b39ce66468bdfc7601e2ef9d47ea32f63e3a91c22fa4960332565401c977c98674d675c281ad91842aade990dd7325360aba6a77b60ccdf76beea285c15a22233906ce039b524d730af213b3c5139355e8572ec045d2392c05f0a1c82440b3df97b515d912de448646f8bc63a710dd7c05481eae14e120a25ce9490f7000d134fa9cf3e5904c7203137e5c6b7999d073950166a931c06454014f521c3c5280395cdf99786d0877f51f800b92774853c0f30059c8423771ea84e06bfba1610257ca8c989aa7ecd5e73def82b538d2986bacb6b0f458c067934cd29ad551ea422742c3e12924a7fbcf1165beaaa039cb5fbf55eb05c819ce95f3f4ec4b11d2c3655b856b53e106607f9e9c8cdefdcc88cece54b01c5f81b46146cd146b7826c7d9ad93fb9c186cb46bb7e258e5e83a905348171b0b0824e7aa121c53384844e542dbca334b7310436c0fe4d1365a2301e78f79c900881e124fe20130319dbce3d4c68b73290677495eedba5caa53f8ce246a400412f5f1f4be8b6f13f6e575c1571d5ff6c274a8064591eec224ca81146ad772d3603b10db186d22c6839597d89e6436fb28c4d8677010e7458a65651f928567d4dad0d28e1c4728f056dcdf30cea688d929f439986247e173c685394b07bf4b8d26e916874af3e0a6e650a39e2a3fe4a9816016d5aef84e3cd99ce6c1e93d7d56238f53ad78dc0f4c386a5c21d45b243902607a9cf730e4183518bd2d968ac6ca82b2fb67dfb2f46bde8478e5c10a5cd7167221e392f8478ffac9787408f35c64a3009e904186b1179b94d571a5e01d790dc684eec09828914f9c05facc660b003d1b98b9301d722f6198d040377f0b3e8000081676ccc0add35383e5b2adf3d3f8a461109e678e97697666712eac072090eb94511f3f97e905186cd32eaae0e6f196db5c1123437884480b2ccdbb95694bdc0feaf1f2391f020c9457b02d1939c83b386759c47316d2cdbe8c765f2e25df05995f8a3eae348d3c5609642417015d966aa991974ea66ff3176d08d00849d88808a21028a8b6ea396daa24d99330cd1d3f390db7ca46c0b810be0420ac4957a0e14a453225320501ca580345cb71b3b567b3e487cd764cf441fec6246e89b129004182b374ea4df53bdd15f4227dc88ae00c8216c184d75ea8aa4a5d604b0c4403ef80f42c7152bff9ba9a22d30e34487bf0033c21a29d6407154ad64e87e13cd4e2c0c6d0ee0d59421f678252840cc19723ab54803f1adb66eb9aa56465c079887d09101e62b23c4e513242dba9994dbeb241ca16fa8888617b6cac2258d507a4bbd8e428dbb8ec71d341c186257cc8c0a657392a239c9e2c15771d14e83fb8818757704d07e07887e106b37587cdf9dc269a007a31d5fab398ccd4a09549ab9718156a892aa82a26327347da40a065ea5838f4b208fcaa462f29f718d981253f769071ded21064702f49697ecee70965466d56f6c4e961b2317f379f657ef561a6d86b05535726e79cb89a6582ba228f29402913164dea1580003ea5c17e0bcf44a26d21dc189f1b5996351ebe9a9ba9eb08675d167208e1f7b8f3c655b05a67468ea6c7d8612ba0b7a7cdbcecf735568394b404c0266f480d1800e7935342272d346405ed2077d4b16529302cf50be2c4150a112bf770068914ed6ee2cb73b4ce68c80e087a31dcf01f53857ee3f04bd3d6385bb3fe4eb47aa682a9633f299ab45504fa30bba25a20181ea50365fee81889443650d29450a0329046b6fd2852c97fd42a8d6288a74733fb5daa8a5734901a1e8b0e40602a430d721efe6d486786ce9b85da93d80e8c0c12dcc87f72017ed466d1482344eebdb72444ee2da54c3205c10a8a091d0a1308cba1b64dc68eb0d714614bf5ab5e0e1d6dc5835a870e09fab0e97dfbee9de3d9e45bc132489ce3d1114e7ff1e30f3cbf6f228fe7348ed55471ba8b0716decca75e101c250c8f1d613e9bf0c40b7a03968518443cc142842221b0603efca00584161fb21bb020818926c876c08204ce5dd4576ee07e61b1015bdcaf971280d00de1d323134b99ea51a7582855d0475d3ae9bb4164e7c60e2ca3b1ffe43ff91f6a471dbd02d4e69c6d4347af002f4ee3a04038effb86fee6e104b1aa94ac815299e4df8c73f6c0b1c8e284216459c214ed20adcaa6ac3d928512848a7670430dbe60507c5005113ae860adb5292f70b6b8b1e8a2c5931f9e40825112580f561c618c0c0c1d72d87a10460cb8f8c1890d37f01026c9078717d20b0b24271886611804a6c082071f2051f485123e8412b0c801ab825a11461068b0c10b0f7c40a58b2864c000dbc1042fa31f54f811f358688ac30eb04ad3a04783fb25c50e1842083d5ea14165ce89655224ad70bfa4d062d24aa552c954a158cf81af570babfc8395d3b66d474cc22affe2b61991b84b8da37fdb5880f13b8f368ebe24b0fd7a15d5c0fd7a49c14f8750bd94e2c704710047588afb2545ab251936e84816fc19c5129cec203d4631466683fb15450fa2c892443d5284a31d18010544c85206abb528acb8200b31b4a0610c1aa81811a910e560ce395357c06c81c208cbb75108a9748840c83be79499084dc909657b944c53652050d1875e06fbe1959e11986300810ae718700f7c7989a832c5aec1fbf4522b36abf2e71bd65885e3c5994e5e3a70b53419a3d795a42cda0ca0d71357b61cbd9ef882014df11b29425ec54aabd5e1e4e81568e9538161bb10c202a0e8af4087e025136ec0b1044b107e94525a81a7115172f4e6681cf355c0b3051c6dfa663ee7cd1c3f5234d5e444707cf8cd99b95e20220752be1062092928c0747882f900290618866158bca1e70d3ef002888d0745d002872776488253ce2909a0c3133e5a580cf7cb892710c087971361d897135f946007a9c54910aa1356387105899a52428c51ba7faa7eea2e31eca252cf11720501fdc4169824a4a32d46af22a221215710d08fb7c024211d6d317a15110d09b982807e602b499118601812a407cf0ecef72a4be30d6d9f2224c51525080ad0931f9fd90a03e64b9217a42e475cb66831caf2ba526485a8cad0142129ae284150809ec81fe9235b6130982f495e90ba1ce1c8c5bf2d5a8cb2bcae442b18be4cac2273641cf20f36a055a9e7c0c7b056a95494cec7eed481339940972b68d950f6370ea861d80fb3a8ab2ab61fd288f147e3801826bf3bdfc02adbdd0dbd3b5651a9e774e350bbe9dd6982edf78657409fc6d1bf42c2c6306cfc9294f26569963efb5aea52e931997d2c956ec81c52874ddff44b69a5c280b319638c47266e2fc678638c5147e3d0c2c647c2aeaad8f89d819f4ffdc78170673103b2f1e96331fbf9547ed693bd7c2a367751cc30ece6ecbd2ccbaebb32170aea9bbe34c677ea39100ad1385429f78edd1da571c0d9ded0c334170cdfc6dbf48dce417333f5af1b626424f12fb61552cae8d0217c6c4305dc10e78831c6d88ee35f3f0d42ad34424f7637f41a6608a3c396d808c4f16626d82f74e853d8c611e3f412c4be144208a97cf83146195d89fa594a8fa671cc19259533f60d7a851b8d634e2d621fb10845504d1822125eb1ddf276479af50eeef9a7083d6b658c56222cd5186354417728638cd325ab0eee170f5e30f5dec6bdf8589884e49f8dbb5f292a65b15008ba7ed502d4bef49ce784fb2ecbb86f4c9534617141b8cb7de699ae474d5ce9b94c268bf52007f227d8ff86e14ffcc77390fc5d2e21fef96b5e10ff6acd1238ceb3d38b306dfd80f1561218a4a4a38c3e7dfaddf46b2398443d4aa9c948c42068235cbab9c91026d246f46256544158f82ecd4d3ba8f33bde28638c32668865308319cc604e49cc331235ffba6191c7de4e187032e45f3b0cfe3915eb5ce94df533cee6f937717f1edba1e4246e9e38afbc99480a639e39a9fd6da3b54b395b7677cbee38e38c33ce39e7752fa2e085ad31d41b05a41217f221d991e5ae78033f85969d0f1f7ef11c5984096a7002777f1912496929ff2004821204e4aef81e04545d5268201272f9073f432ad65d10097ae9241c5da631e2cca49765524a8a69190644624d85b9749ffdc5a750662944c77cc8d938e263790458becbc611fd739904991cdc638cd15d42f7ee6e82c148c559d3e590869e02f78b065ce0eaf0ab77a418ca17f2414b4a8fbdbc13a09fbd054a8ffd122a42b02ffd92ece92fb9b01597d09ba16083758c29814ce800c40f2bfb2aa9bfcf9f71f698b3747bbc9218af0a089b2110108540f1e6aa58603304a28fbdd35f82fd5c42450866fa55fc25f4aee21582bde9b1a75fba4bec53ec210a4eb858a5a75fa262601727de380b99a784092c3a4a428845456585092c42c207894505aa9480503c080bbd4277bd826b627705e75dc1f916c03e7b0bcca793e54a661006146fbc95c4bfde02817a2b02b56861f8ace935cb814c4bb877b7673de7a440d8ecda60118a63d21b8391a3fe61de0e367f37b20da689db8e4c857d8ac2ed471388336c8ada36d555f686e794aae9bbe3f4ad058861961dd91eb44ac76d9af7e8b0e96df60d91fdd1f7cc945d29318d086dc77322c690a27cdf7c4079537e63a39277020725580d840314d6b6040e9660d5504103ab9e208955e32809563f4ed4a971031a585dc50962c0eae7893a359a3062d598020c568d2935b0fa87449d1a47f8b0da280545ac0a861358fd45a2ce0c0e5ab07a0c560f01074fb03a0b568b210410c2b0fae11735b01a0e5181c2ea87425147c715376cc16aec0a56aad503ab1f16451d069c008a17ac6e2e4760351080c06ae824071eb4b01640469820b0ba817004563f4c8a3adb1090b8c2ea8760a2ce0c2bac2d095b7c60f5fb4fd4b1f185d50cd0a18b1eb0bab9d081d5efaea8d34f6869620b963ff1a18b18b01a5e8185cb15ac7e278a3afdc4d018276075562507ac7e7f459d28041a7c7e585dc760758d82d5375a2005ab511083d5ef495127e78814b0fa1d4cd4a1b185d5363becf06383430c58fd3128ea94acb04e5a94f8c26acd05464060592b395ec1dd6ad5d062e598c5b672d412434551abd58223b072ec82f918b5688062c4cad1cb5cc2a8d5e202042bc72f9468a8d54a4207568e61729c50d46ab5845859fa401a865a3e43706165f964fad06ab55e50042b4b2825318c5a2d22a22cc1a8d5ba8207569652a018b2610b2c7260653905cb51ab25e50656965588306ab55e70042b4b2b520747add6105958595e916206ac2cb35001d46a4d798295a5162cad566b4a1656965c8060d46a4d9982956517295cadd6942fac2cbd4cd751ab65840f2bcb2f9507ad56ab0824585986d14ad06ab582d0032b4f9f1db45aad2d64b0f27c5284abd532e28795271428865a2d2a62b0f28c82671449ad16951e58794ac15d049ce794c8c59b121105064ab8683084137e68a1e086ee07a024474a10a3862dc2d0a2450e48c440e1435f09e20b134e98f8011440604f4a0003ac8a124cb181e27e31618299c54998cc09866118564312a4644e5c590d4a603e3870e2653a6902f37182c5886c87ac86221f319ca8c009941a56e083854fd0124e843003ccc70a4c8ae924cb747202d30ab61ab0d87c98e0848b520d5e309f273024d42838273d30dd60d2a20626947cbe2825ed207d8c40392182fa184d2758780d48d2490d309f32680d5a322735d48004adc2e704196a092c2b4a90c29ad86ea0e2414703550fba329ea072123334c1dd2ae6e177f7f5bbdb737aedebed89790ecb486c68da69d358d0fe64e266688257a8efb1df3dc779317772777eccf7982e1288ebd7fa266f65bfbe49061f9a0fee63bed63aa36e35dee4c1168ed15a78f3f29199af41e36df733347e06024d5adb68fccccc8c47bf763450dbf7a3be7e4dea6b6f3dba4a205dcc57cd43691705adcd3694d679784b79a798467d95b79bdc6bfdf579220daf717b9ef5aa97a1501268bcd2ea6bf5b91b33540e50a8dafde9f439a6c66bd7decb4570e5acbdb948cd6ff6e65ae365319f9d22865dd73dcab35ce5b6cf9eabd63eea3b7b5731319d8dd96e8fc6797b24367077572894e5663c279379ab1e8d536f3fe6372f23b181eb5d71cfd53ae3ae667cf6b5a3a152a95434ee6a46ad3277d575d90ad5dce937191999e7644ed9766580486c60ae7bae7b8ecb2bd423b1814fbfea90d8c0a9bbdab2df32eeb355f7dc67dff6ae50b747e355ea7b621ef5a998477d4ccca3503116d5bfdd1e8d4fd77e67bf7b6bbfb3dde59ef372132b57546ee308198d1da9ccb22c9b32fbeac9995189bdc96b20d208c43e661018f612a9c2cd07166594df110806047b1963bcd9b1863bf8c1f027180c1f8b3ee6bb40b38b4120d35b09e978e3f21e8138462410c326d4593ff328eef0b67137f372924c71a642666e8d6c7bcdeb18176e5ea279a8d7bc7e2de6ceb83083aa713bde7030cb31cca83f83665e04647ec6631e90eeb7afd0ab368a4a6fa3c8bfd69b9b208998fee6ad7cdc9e52c43d343e2b7de5beeb7adbb29ff1ead665decc0cdd4cf79907b9ef381fdd73d9e28c898ffa5a7df8dbc60477db37ae5f2fc775377fb769db6b703b3dfc158faec77ee32311c2c6a1799ce7318ec5dc9c3df7ad3dfc2c4391163e126b66840946b1e038f38c408ccab8ef47fd8c77243e5cf9b83ddc779fdd1eedb7245d9793601822f5aebb5948d73d4fecbc0c5bd87ef5320cb82d77336cd9af50832dcbd16c07ea65f5f2aba2f5ecb79b5da8f1db6f31a713fccdd3eefc2ce2d376a7e6f59c2e1288b35fa14ede0af5d99fbe5e197c74cf3deafad85efb2cbb4822ceec0fce6e0ffc7ed8c21a677b647eab3f63860b333366cc98e1d1cf4af565bed2e7b22cbb19e2da5e861477ab9ff92cfb1a5e6f40b6ea75f576bf09e12ae4bcecfb67b84a5da8b1c9788d6be94b5fc38b1b10fadc975ca871b99bc84526b2373d8f73dcc3af35e67b8e445ce37af5b2ee6b78b546eddf8a6054cc968f64db8eed396f957d97f1787685d4d8be765ec6715cee3ea37efbeaad3ad40af5fd32df7d7dce5b718ffa98cfbcd5e9ed675f65bcd4b6552ff5325e4dd5cc6ddb738ff2561beafb538f7a6b7ffb1ae3699ff2627ee5cda43c2d06e5c9004f57c8ea57ddd7f899cfdd1552e36736eb75bff2666a78339f79dd5b2feb4d488deee6263337dbb4ed884724e2ec22716c4309ac09eb0fdf48f64fb1d62a4ae501bff4b5e4d54e48295b21f6d27853aa9f6d6ff2b8bb7d7ccdeb29bde94f57156f4cda735ef6dc9b5cb0b7238d3726edf6946af7b5a4752e9cdebee6753727c10f79e2f6d27ee769dfdd476d092e7d73df516e2e9c6ec79b8ebb99892dddedf4ad952a8f92e7037ec97a27ea82fd936f3c4a3f6b12acbdbda5ef2fd19c04e7fe23910eb14bb0212a0ff826887de6955694529e689ade95b4a7268ee39ef332cd4df0f63909debc9ef9be65bf651a7dd373f44d4f4ddac5b6db33bf6eb908cef47b66dbb671a026d99163c0d8e72218bb997e73df83bde9b96bfa8e01675fbf1d7bb941a0095e75a6ef4ccf5d53fbb7dd9b99e04bc4e9a58e3d5d7afb21967510f7b6a374794cf8990ff8f3963c8857a65ff9b8d8c49e2d51b7a75f79401ff4e13b2e79f9c31a863f4d25ada4693717f91efaf135edb5dbfed5eea10fff74fa7af2b20a9fe8d7a89dbc06d2bdfd9277bab9082e55d5e312f7f2e310acbdfdb8eda8df7d8c77ba9989bd72f3e19876d7f431a51ae371f5e2ca83be0ff854f3aac903a27dcd9007fd69fa7ab3e91e91a5928f1e4cf001302feeeedeb50df6ad7910620d279401e2f852cacffec88633d99836bf62a68961d83542b33b03f63360d894917a0c43a876dd104a2803c4fef1b13fb2612cd29f5e9c7f8d6417890772130c679833cc4772c2f3ce00ffc826af1107c3c33ef6d682ec913e9f05bf0d53c8472046e23fbd8629e0e8829a24a043f718a59c13c3324a4bfe512ad15dde4ca394d11d4aad524a391ffacc4d5a18c2f70f2787841f3ddec0813b50d4b699c1ca145c7ab9054a165cfad209c3557c8927865b32188768290e15c5a1a11987e250f63568b08da314fffca97fdefed92d72cb9d9fe116eca85780d86112eec691a11658bef4f6a48704627a73fba77dd98d4798946a8306b604553318d2b6adca703fd5fc53f506e5b7bb175092a8e76834bd83fb5337b04fffc3c154985723088bfdbc99f6883a4d55f87495746f6f4b2e36f76b02bd820c1070fc20bd02f522bea3e0c5f2f817ff42b1f187449d8e415e9166c8e67e0d7905c1b4927743a757a08ec10d48f6f2d634c1e62638cb6872608564d96d9b1e4651d5793bb17ae9e75f5954c1a67f6c2ad53719cd943e9f4aa58770276e3b7947339db49d9d5ec171e95f88c173e2973e01ad43e34de96d13a552a9542addf0aff4d0abf793a7496347ed665aa2115e161e9bea4308e3f6a3093679d2bf4ea202de6067bc7400d4ada3d34d5c83de0f65613f3d21de6261df5e66821b89c4f3573ea00b4f29c4b2b039e52502c3bc8e37f1a64b8c3addf166d88addb171b401ac804f98e8934e13db13bf33ee221d8630c49006dcb73d24b2850ef767f92b1f262caf912b300ece5d06ceb1210bacabc0426323b00cdc6d44766f2c50ed8533cd6b074838ab6854dac9f60a2aff3aa8de48c10e58c01becc45db443165f149c35ec7d053eb1f0e59d510bc0c58d1e0a40040bbfb5da36392bc231c26d488e4038027928f0f78490d2c60f16c3cfaa9fa803595a8df30a8e39d8c679fecca9ddf9439b5a193f3e1d22a9a492528993c373b2a7b452fa254c353b7fe68fcd8ab227f03d258000d0c5ca79058531ec7c41f8f13dc720a04f02277e4ae5396129009ed8f70fca1f2fc31ffb36b039fec420cff1279e13dfdf15853c67e58de1ff60f8ffe339fefd8a51081a57d81efdaf69349988afa5accd9b70b08fbb0847881a7c7181e784dde9d18f43a343759fc63fcf47bc4a1370de91b2fd5f08ebb9ecbcaf9ac2e66f35bf1ff03b6e780eec07ecdf63becb2fdaf9f58d63c9e2c252088c8b0984e5f4a1819d3f77b600f0c4629fa7f7640a24dc2f2c493970bfb02881bd28ea74f424cff9e239d8536aad4af59f7dc99330c6f82c60eed1344deef14449e341b192c6e873ba43b1be333d27fbb983f30c4df24ee6e520b2133774d8c05624e227bd817d9c77200b6cb6d8230f2a9511a4607f9a96299bf96d039bba0afe190faa3f4d0a435e09c8a6704bf1830d70c0f862849f1d0ca8c7173b3a3a0b3684fd69686cbadbc6a87245a11f8233b0425f7441cc2dc1660c0828eac496c4801a03c2802612306582c568c0fed15f13a971fc7847d88c8393031ba24540571c1afa420bf64f55e9621176e872211f7215fcbd1b6c76210b7d0862e853a80c611f5a41c83f77a1298dc387a20f6c8e4371c8e3908d2245684a169b5bb168b6aa0f95f9363c0bfbb611b28408c75fc5c07a44fc359fc8c23b44deffc1c691cd2aa3e789371907e70b2bd83f878a46472aeae0dcffc1661cac81f7c17616341ae8151a0f11e239f05a213635a968a9c0b8b0bf121ff9363c8b3e0621ccd8c4300cc3ee4ce22a804912755a9c183653087443f5b1e16790abe02fbde97215fceb0d6c76232ec95aac1575e43bd21637b253c8735e5f68f11c0f8a32c5b93061734cc2fed5b760376a1cfe52e6f862e1169cdd08c98de4c55aa61cd86c53d95114b66dca46f3a1225f95020c6cee97e5c2661ba5b0d94ee1fd1042082184dd72f6ecd9b33b1e51c28521e7c3a3961747d83f55e408f491574629a38c52ce38b18a6118065d49112fc93dd247b08beb7ceba936212da24256db7047b0340cce30c8837e9e508d0642894285f5f716ce306805bfbf0a2f84b03fcf8e0bfbebf0e207b3dc85c0b9afc8ff6c3a1fd82d7ed34714c926a97a00e65b7ed33c55fcf80d069c80f19c24f8e0238e6790b874c2400d40b5f2c40a352712c28d31d0b2e2397d8597271870f2c573561870f225eaa0be7bd95ff2eb8eac8b78a20e8e6f363552d8fc7f6505406c38be6f3e6a188c79c4255fb00e143086cd4712c2fd42e27271bf9088f0c72094e765e9674b64e1e72560b07fe45183b1db8d63debc2409e725449888bfe21005fc3a0d540034c2a25aa9c23305431d104ac110429d4fde07f0d44461db891b965094420bb500c718a54c410a9e7640eba85a075509f46bb0bc9988bf70bcb4461296c61b252c8da276d47126e8c0e5d55852f033c452d2647c91c31616930d08b6a0f809623181b003b56d4cc0840c8e581546814511ab8d78a084114b053c60e16209c065049722569d5ddc40882156c54cb04412ab662ae04110ab9b8002c688d542b0c16788d55f04e1082256ad5af4025084a41b92584a04d022a208442c260bf029c20fabb1f0c20623d6f7050a767f1bcfa1c1fed45ff3af2d27e5552202564361042d7e586de3d1871a1920060f492c252a5811c6118b09aab5c5ae8448251e049630462c29fd8bb025bc42861118575094167c253d7a83a10130a4b67130411404ce1667095f46081d32a1b60d2d515a8247248636efe0ece8f01f9e03b1a79023855ec133d3f7a75cb31ff4e4767568b7fdc6e10374f88d27a015d0381e4feb04ec65af5083fbb71da58f1efd92e7a3e1675007bc3ba723acebf09b1d1a50b025d4b6f96edadd6472ffee99be898ffb73e933897dfaac61449f4253e9a6fc939a855f189ba9dfc08fa988fdaa1a47b4c266faddf0bfb468e2a07ae907ce340e7fb8b1007deb4ef9d7051715f42256b547d7a9ef697ed3ad00c8650c9c1d6741f8b0858ba3219c298e9716a17295ab5ce54fe3153aec57173dc0ac975b64caed11f6039d8a4aa148e44352e89314abe1353affef31f9ec43ef51a9f9f69c9a87b0a606974a5a95534c2e29bd42728a7f9e9442fec1cb43c2d2974a39353fdf8f681d2ba7749caa79a5506e304afc9b9fc4bf195f06c1d02b34d6817d53f3b34b566a3ea7bce6b367993e64e3fd08147eba3fbd816d024f14bae0599ace05db76d8a8f16abeb71d36fed53cf4e4973c16e04b1ef03188829721aeb936fed53c8fd7ac6116b96e1c352fb51a221f721b5658d3ffc0ade636163ff38691c34ed6c6dbf879e239415127c99c70e298b88753382821b5ee39350fe1eae1b683e6874005603fdf850c748ee9e767ea7db618d5f0516ff2627ff0318f0686ff1d84355e8e2f74d212c6e3317daac18d855a9a621a1212f2a12a442f37f22d6ec5b3b8162f9a9e93b10fe2dfec998209492121cc83b8cbc67536de8643b75274c58750f81a358ff6d8781920aef9209e93e10fcfa1475a2ad745f1cf6a5306c9201b33b0335ef5331f5f0a094921cfc15ec7fbf9b268d69f2fab78ce7605cfcf320b9e443d1febac149242728a1c62c1b124a2c9a7f1d987e8cb8b04d2fbc33f1b354f1040838d5d3cc7c6cf8f4851e73f3718e9aa79d37ccf931b0268b05906f504f16ffe11887ff4c8284151c75d320837f42af3a14729b1e9e62518fb98e4dffcf7e217bf99d9e7f6dcf322cfadf837df5d13859b29ae71570d2f435ce3b18d4786b11bc348b1f0572ff333de87b46cf19c159793ed52cfe334980fcda743f2ae543ff3b9c1dc0008d702f73e047f760b1c1288e5cdda97bed478c653d1f088f89fe1c9789e0c30c6cb5ae643783eca93211b1267d723eafc9ddca659f8df377de502c8416d1b79b2fe4de95311b083cd90c8debe90c8b30f3de939ab7879c4b76f79649915a845eb582f30169180319965df798d136fb0a7168b5f33af6b11cdf4321eec9bf8292fc683561a75ca2ea47a94274f39822296619909c7bfcce413630cb55608f405679969ca2eaf2c528be422bb74af2b451c07adbd48208fcc73b02dba544aab86f2a015ffb0c77995ca62367c605ffbcc7f8eecc582fc27eac43cf60ec573a2788efcec841d798e7dd4634018f3208c611fe36547d4b60c83b3f7417a82b39f5070f676fbd104a3ecad5de7446cf0ca08c4a74722717c231d8ea887017591407cba19da7bc3bf18fcc39e03fe61db860027367b286ce5348c728d655f3b9e7c3c27d3bab6297af705ffb0a71a3d71dfafa32f3843220989b85849ca6d74c57330ac888655cc84758fa5fc9b10a848d4517552c47060c0bef4190da1b044cbaaba5ff58924f19cf8f57dd4afb5d65ac3e0fa4d1fd6d7d115dc5e70bfb2d8822bdce6170c3f460d7a595ec1b008e248875863187d2638bb32a9be464fa9571657f0fc1dcf51f1788e7ffd1e5555359aaa5458efe15fedbe81945ef93d6afdb6a9b707b6b0252e300327607051c51554848912813862055bbad8628b11c48041104198c11170f02148881daaf051c1ccc28814203184215cc9d283186300318f3065052a3f4f4822cc183208c2420339ace04b0f2508eaa10a96021370f92268e04cb1e822bfd287d269d432460361c4a8ff0c4db089b5d05af0bcab161cf3386e8241cf72e79c73ce3c21c5f36146fbaee4cb246cc00afb3766d89c73ce09348e7e991c6c8c3d5b7ad1b7146d79d11d5e5b68c1bd4516dc2d01937c93d79b04a8cc62fc58a2b494655966929b04fc8bab52896634e062bcaa69b6b5afdad7faa79b93606fab45f0f6f6330ff59d1773aa7faa9f699bb6755e6e125304f7ccd3e87e86c6cf68cf3df184c6411a35be964a5f4fbf51ede6ed2bd7695fbdda6d0fe16b5f3da871a7aafd8909e65ef37c701f03bfbb99d6705caddc37d6b6ef3cce9ba1098ef99819dcc77c6f5a0ff68dbf4298bfc678272fd73fc9a03a542a95abed6eae1f83656ca5b1b57e198665d8845de68427e88261199c451815a51a9e0076d12ab53f60aa2382e1cdf32b0438ede38cf7d4335ed75d8d4b693210aa64361a3366d7fd065f06de4c24055393d31ece7ad2b4874422707af8dc77deeaf4f5bb6fd7b4d5e9725fbf3e470477b0a630f7f0747bb6ef52b8bb4452d86e3eb6db2a1a57ce9832a914d4b40e7615c22e057f42a85d6ec26e42082184282f13c1288a632c8e89f91a73baa70ff51c17f3a76fcad9989f93a6f0bc99480ae56522a98efb69396ea6344efbe9715caac3f3bbc97199480a6b29f88021449a0834006207a926020d80a08208462919341428385ec16928500e10a1409161a0a86cae58e9bfa3809e9ed669321675b279a1fbc8c5a44cf6a22e774f73ce79bbdae1a8a2a15aea53aa97b1aa4f69dfbda6c99c7ed6ee352436b47a35cd7efdd879b9ebba17509db742fde93b4a354d5ba16efdd39fbe3ef7272fbff0029e9afdaebb446cb8db23a379446cba4bc4065b1999542ad5a53aad6adfa53aadaafe55afa2e9ba17e87ff5476783e21ef539aa5da5ba99ce90b9a993bdf99ffb19af370834e11ede6c83b99b89d8745df7bd751de7e5176c1e431a0c6930f7f6db7354d86bff50a9d4ccc39f79eba1663e26e6a2ec678feaba1770ccc7c8e7bc8c7acdcb2f74977be8698ff24e27cfb166d3a3bd041a732fd8f080386b3df51df7d6a3b14d2662038548f53b48e0e265b383042ea4a0368bcddff78551a1e70fdba1cc44d052e7b7077fe51f83707c611eaf3202e1f6a3f8ddb862db8e9ed3ddfdca7ee9d0fd219c4d6210c4ad1939b09926486e2d10a778800a683ca1d7dc10ac651b9a54d6f0b77f98b3f67f088637737f02623f88d6533ffec7496562a6bdfd55894ff1e5576dc710863fc385e1cb7cad70d6c80186cd45f0f63602333ef5aab740e055f5d4b75f3dece373430061ee51588668e1f9337cc4fcecde7e05f290831ce42007b99f0fb98ff172fd917aed2377737cb1f36bb511e87ebef6a7b7945abbeaae8fd3d56e1e82e773f5b31e10a7b2fd989be38be5b8db937aedf6a09e7b1eafdef4b2bd443e9c7a5444cd78f8dccd7d258d7b2462998733785cc6cb4cf0b4d23f0e73af453c2390ebdbe7aef4efe625986adbb6c3f44022de2260aff48ffb7ab59be11f893be66b0fad7fde839dd087faa64fc2404c587beb0dc1311fb71da6b6c11c4d4e61eedb5f7a2af5b6dbe9db3d4f4c7d90edff69a0642490d46dffe03545c0f4d56463eccb08944c9ec5e202171ce1fa36428ff3f210cc7d47934c8cea3feaccd030c9a86e7eccd1b83350375b999b8ab9f99f279e3c2410c73ce765d467eff6ebd7efcd879579ce47cabe7c6e0886da43eff4315ef78e4f5e465d5a737dedf49c37c487c675cf133b2f33c1f56a57fe87b7979b29fee4264343b0840800220b128edf48208e3e64acb0f99f86d34082111536f70bfe8e0e1e8feeaf84a3ce6df1bbd83d957aebedae92be4d58a62bb59b8fc4a01804c4bb441e2250e4e19b51a21882168c833b8a214809426afb90d5316f9f55a800ee4d5b3ee2700b6c6bc184bbede7c642f7f4e186e439d86f2fb71d5b103679361fe79c318495dc4ff9dbb7a4bf3ddc1e6e011500f1b67ddc766c4d7694baae7b16fcbbcdabcf794db0c435cb3cacfa54a27e663fc76664b1b4c78f209e331fbe0e16f59aeb344b7a2688e49f8ccf04671e12962859706309a20b5e006e2c41bc009f1e7af9886f9edc76188165e0550bf1edb310dfcaac04fb5b8ffbdebc0976ef8863eec22d600a5a15ac3d4fdcfc88ac127fde8629cc9743fe491f700b9882fcb943b5b63d932acdbe09ae52cb3e635a9db89a30186b0eff6edc10e0868773d338fc336f003005ff8a6d3c20748f374e4f320cfb52c55a0bf1b3cf10630fe3bde11f8df76b1c3c7c45b388aa695aadb53ed5a6cc5efb1a3dcd93d9c758327daeaf51fab546198e64b8745be832307d235d06ceb2c46e8271082c3070cdd77cb09f0f1f43081bba3c1b9e05855e76c8c6095df1ca30f11109b1d80c5d2f03c42e1d58f80cf879d67cfff7b781d3e61bba54345909be242fd8ff864dd9e4584db12f9b2d24427e5e6343a737a85654060e4e5216ec9f2388902e3aea9bde2524e47209b9a440178ecbe58a49415651d8243c858868ad120c12f2cf8d8ca04ba607d005849424c465250616167e4c7a127bbc7afc78c0d10fd5878af419b5ee1e416c606310608f30ba60ff1f3f640f56f3cfa6781e8025684a1ff578ede8c83255a881cd36017de34f593b8dc38da4c80115acc900230e6ca62d486db05118f44d5f4d1e863ffefdfc98624d0aac114fbc811f05fb13ec57608741a28e6d1fb48ee91d628161d185ad7ec1332c77c9a8a5fa968c116cc1a4cc08368ca01bd9435711ccb3e159548a24b1f1163902049b3ba9086c9e8f3aa55799262cd18bdd8e37f9db51a4099a8b0a55183e54a3a13bfe2561338d5b6cf7079f8c2a5d38fb910c024202fdd01f22ea47447e9421911ff99117ecef5ddc0b9574c88f2891fcf123223ff2a3272da5ab8bfa72c7e3c934efb8c7d71be1fc38f39ab08ab2ec2ae97893a3500c6ac28a40334dd878e54b62c1ae2c8a3744576cde21a23f06e5080494654747961865099b77e27b32409c77faeb5ec2365204f2276ca6389a3472c7be4082a14a10215d62908b0ceb4f630516c628d115831ac74c1376826142e3f0998414dd592e5bf18a85374b2224dc464141f3c8bf56bffc7bfcc05a3d5430ae42eb09d6679eb0f0711cccab83b0bfc4c971251e6d61f3e73f5bd5874abf0dcf2abde69f7b3c5e0f256ca6168a221838c00323f6b1deff82fc117cb0bf0dcf03b4dc20826a7ea38ab7fba879e2d314451f30700073ec042d4ac148c2fe5acb070a1582dda14f6c862df8b303ed1476b6eabbe969bd41a2e9be406fbb7fd65f94f0cc9dbb53bbb0721a1164084c0f2ed8ff07929730ad658b43a65716a424239b61bcc2e608b47df7a7ec43d14571910a84bd077424ec434343eefae2d50822253dc6c1acb77e1cc883a0f52050bc29e2b697ab8bcd146b911221e43f2fa129561c0a7c1b9e657a77a1a12c363798f8039bfd487beeb3bfb68fe1155f18c78289ade8f0667be1960c07c38144b6e1e6258937fe9a67823ff1860b9b29a65a12f58c09306058e9a29ce8f57062b7c4de1277b06048699982fec91dd8577545f6937039d0904b4a15a3e8452b6c7697bba45004fac1591205cd90416404042a8c3081135b8001f4431345c020c51006fb13f9b2a323862265d84cb514582f5d5aa6a0f4b420db02a42d43bcbcb0ff0b54a3e932c43f57c11f853036d3a8c5669ad48497216fad228c9708ec9b35b10d88ee8e2a15fc197498e7f3b90afe363c8b4a868fe3dfd71e4e7ffefae2dcc0f95c857e1eafd16b6bbd0461ff94a4f24694c1c1e6ef7e9fc5e68ff6f7e9b8b9af7cd8480b0fca947ec1fe5a9047f129290bbff2d830f66a1cfe364a80b9a20e46146fdca3640f92ed4921a2a82387a4101196539e0c2baf0c722914848786a43c9248f4775446b082fd69bea688a894ad7585452d11d10c0000003314000020140c094422c168241a536565fb14000c93a248745418894990c32084900100100208000400000088c8dccc00bcbdf5763e6c71bb01c0cee3087158de58af47fafc668d52d7008b50c11dcace6ef541765362c9b20775709e16b79d1e2c8ca5fd113d585aec72495f95a9b562d016689e6e6d922c58f60627a7e5170064bc88a92bc017595dde71fa0805c6b5fb5338e888b1ce8242a363b4dae59a0cfe25656837fa81860b6dd383116b0544ae81af24ce2a5bafdc4a8308f5741483cc46319365a504c6be0e5bc65d12d3daf2fef471af7f1d91f59de9ef45639e56ab34d38417e9494cb508995c9744f9449a6a3909af86e09a94982a0690e6e8c28aecbde3bebd5e8a9f54cf5e83dd01c61ec3403c0ffb3dd6b1f750f5ee416ece557ddd8b94243f0ce583c9acad7be96f3249ed9cde7e4707c222cec723d0bb89738586c6904206add0bd82ba833c64027d57388382da5eaa8340c150adb0b3b07b53699df40684ea7d299eabbe986c4f7d87a0c0d05cfd008b8dfd5d85f6025c6f6ceec522e21b48633100332bdbe1040cc59c693db8a589a7dde0c756affd0bc1a6fe293560497f05b6f2870427302c2298b9c9dff58a90c1563f85691b21146af1fb6b6c2f7efd8b5ffc321fdbef62171035ff6cc51c694ac1af619b8a96c0c9d84000fe920376504d4acee79413ba024f8d9cb34fbcf2da288c33154ff8e28d18176376dd4c91a0c3e4969c85ceb9476e2574164263d7395f3a9fa3a7686eb5a79cada1dfdb82fffc84143d670e47677262eaff857ff6532badcede4f8f3ebc0f8aff899d6f4b46d11c8a819d0b96ed2a7898ad8b98a6f6965b06fe988f04efaa17a1520d020ef7cd69d983ee35621a4ae0d0f997742e366d3ec9c6179193ee51c54aff24ad0479472076105a47773dce41488748fb927472b8eeb82ceb988796236ab76dd152ce500cf95dd060a41556d6e03ff9323729cca2f563c671790b4c4335e868ba18d520c042d23214509e5718dd5e9a6a6b566be52c1852624b4e9a721df7cf094106ed7919aff9f1f071f06bc886188a6388081bdeec4f752ebeb2879cff93dc511e1fc92ad38a3511a483f971918cde9ce732846bc7cfb927631b868a5571f61539dbb0e13f71470ae4ccf9b0769b06edf3311b561bd0f337c9982c39a77680f6fd7483b10eaf55a387369f519d6ea5769b0fa9a5b6b0216d737e565404e89a7a8625a9343e25f753b87941f2bf64f38148b0bc512cafd94440e136ff4c6901e8a8ee9e1fa149503e02fb40d9b1476046497a64fea740bf5c9bffb48fa9756d1e32328ccf4af0be8cae66c24fe16e3ec865fc28df801d155298633e82815a526e2f779ffa687a0ee25a9f2f15c9ac3c0e7a65266f3467a6292e638f1ed0745895ba109b088a6074749acffad589c30ac95b854add954e3dd31e384c874ce359f09ea159a19feac963e71c660c392a1873510eea586f5504ccbb0b53fa2c2ab43d3cfd85a7aaeeab5785cf7715c6534b1c23af9b221e53910aa53b475a07810bb32476b1e6001b5817cb5c9b17c719a6736118962623323c10e32a486a24fb9cffd444c3397fca3a52cd70f0bea66e38cd39b1fbb6e22acfabcc9ba169e7e45f97be0e9711d0337f89ef6340cd72ab1e21e29e81a0feeda5064feb16dfb9bd6b128c405ac79fa01c6955df03f79cfea36f52f7079ee5b4d1ec9d50f149f1c0f6dd86658f832d60e088d234e3860a66423b3b9be9cb60d3d3a2451371c8bcbd32bde333731b619d906a8d341f009362dab908ec4980607b93d3a94001305c7d0bd5822e959bbcd2868fb30ff3b0dc88b74dc559a8f328fec37a1f39bbd06da88a34b31fb030b1e5cffe26e22af74b5d1e45a689c9811d4c58aec15de935c61d40463f52c8bf9b1330fd0eac0cdcb096a69c0766b745a810a546f79e91cb3ec8fcdebc8985e2f7bd05cfd34ffa1b62dd312df30fdaebddefe3d495d032dfc4496398498b61ae80bc23e89e1fcb58aee1052ad20d5aa1cbd0993abb70fb21fbb735605ade496bc58b80d1963aa41803105e44a49e782b48602fb8a26697874799b3c4a71bcd2988d8187643241c341a6166f07156f5b41303f713d488e69abe29b2d413bf940df1e7f56c14a7959dacb56df8c9b85dfd5e4b14cee8cf8a565d3f9fa11d3bb9457a3a782f12227d3ecec7b87b706c9135bad7415c47a48bfc682326992b439349301585ac1023033cbaf14586a7dffa9d1d17bdb975cd7517aa8c37410cde23c208f28783a0972997a22f00fea8051609f5ad58e1d8b47ad8ddfe1c64ecd3a6a119e75e2a1004b24f15a613991bf90411eb3461a34ee642dd4a4b9ed255e4ba05c64ae9c8368c2ab8c2c39bc6c44bca8aade4cce4235c2391de27b35db5d113c27251a382e4336fe64804d8ad5b13f161233d29a034d2257cea0ea8664e0d4b7662530a2d4a582a7de90239e8486faf5dd8453ef9911ba36eaad8631a5131319769c4b0473e57bb92252b6490c1cac908bb23adc8a9e830e91abf3a24576d7ebe5d8213d8ff942ac1c5c074a675942782b2ddaa1cd08605b3952af210c2069706d119893499d79bcdf9018dc59d72754d0e398e86f3015909e70d13423543ef2782ac923817c9059df621323f33ea39e7e5b3c4c1f614dceb990ca6ba30722ad6a7e183dff41f72ada08cb49426c0531f8c37a211b13d1b5ce424212267ab333a4fd7c9819b40bcda9d15516624df0a46ad4ce98e0e5eb5c8dc636fd0d2d58ca86c3ed73cae0d307d72b8d703922c848148d41040c6e4e7a1f48192f34f5ae45f79215c30df061682a07c3fe089f2b3b6754cf4635c5d0cc6c70501098278e8de5d29c8f0c6381827bdca12bbf22d84217eff3f7404ba81ae8afdcb818c64d9bcdcadd521281e284adbf2cfd9904696189b8e11a370e9c2fcdec7b08287d4a26ebb8f0b349121f2b9165ab0602a2a0ddd4bea3ba918c5381042bbba75d0cab849d66b1851677f2d80ec9ddb9d3ea4980451ca5baf77e003fb8a0177d2a4505e439f5cafd53ff5dd2073e1150bbf84366d79bde689588fee9ac52ce67a67446aadf09bc379cb106d1ad60b902956fbcdf3537e9309dab6be41b135e86034955f0a108bc753fdb584fbe2dc2fda70029cada1a8dea300b986ab35f26a03ca6853829c84cc864ca023c3d26752c1a2db0ad89a52ad9e3932a3f0a7bcfb5faf5c7b9a7772b708dbc86b2f6a66e626975a836d85f676f12e4c2227ed68311f29d812191224f0517526739bbd30cbef7de5570093dded20bfa76daef648e194abccde1b8f0eeb6ca48371f62f25929023190d0981f7dfa946767405ac0cd840bef0dff841cbfec4fbee1913b65405b751e6c103957595c9b2024437de8685632aefd073825c6127d4bfabebb3fd24dd3337302a9e1d7e48a7968fefa6b015bea15f37216868eccb46c37faa5b790bcad875b6c98d3dbd9fea891a711a50f77f2399c0d73ec528490bc1894b0eef3582d5f9f12c76f80e10ace64b4fb189b09d1f3f8b397d0ba0dcdad2f84c257ebe2313d3b7e9b9d2e98cb80ab06d8a60738f2ac258a52747b5fd0050167f5efb745223e512fa089e6d2736205c34939f8592a478e94feeddae146de36c96159713b85f8fe6eb75611f3a376884071362c27414d16bce21c536c7b2d54e2cb5d5c94401091f497d088d88202bf9409590b3f67545145e7816932e7e7afe262efa42c874d4c136b94fd46ec2d565ca8acea621ed3843e4d59bc831c4d1d554254fcd417ea6d0224f7ae40fc02d4fa587f37bfc605eccd990f8d1f80e95a4f83a15f4d466f92c87b1372befcf7ff9bc278038f2aa00aef575bd28045660ed57fa98d93bada5a14562397179cbbb048769f7bf888d8a8b7fc6266551d8c396b35b82a09c8514edb8854076b8b7c82f29a46b59812da87560ea2b934f9cb062b0390be579df51869a11aed68f06cf40fefb0d1e9db875a9edf413178213c8e717a8967780e5fad8be9c27926ad3438e85bf8d98780fbdb35937a0b571d0b755f010c483c97a16fa67730cff49e55b38bd615560da418c0c73fde0cd06657b1b78e2b86ac45efe18ac892bfe01d0b2829039f75b80f66c172ed913235c221dd7b2ce73546a9adbad89667b466603168f529acb08d2b6b12bef714af6437797072a58277e402ea2c9eb7a64c4ae5912053ecde75f5497957eb98f90a0fde91251e4dcc12f089d4366610ceb8178baa6ed38ee129f83955949ff37ea7dae43456ae2d875a9b26a37ee2f69a4c97c3fd42873c5ab026d9dac78af3337a77ea0b9a094913b0ebb9c840379795e061cd88b5ad0229745c40b9cd824967801d4b75f53b1c6574b57fddee2d9209c9646391f643c939b48fc4c2ed03753fae15da873183239cc943d60dd7e61e1446f4b66b653b7cff29f481b0398b82c434e919aab04f2fd21f67c097f71fc3651b5cf772545614f3860ef8251b76da66e435a68c1a913b511d39a9c2f141d4c9f44dade3c4f0cfd2c4bba2443248d45bf242836440dace00c92c106c5597cede299364e5248cda8a02c2179dfe03365ece914bb80090b7e3367a80c1b9452014cf7dc5a1171cc0af17df33f618557aeb01ef14a7d529cf190da28fddd1270d7f1bc4773cfe665b1f1d9020c4a35e32c55df1d934b98c8879ac9d51943632a67b0b84c77791f813833f906deabee4894c1793655dda5fdb72ff2778aa0828ffad5c6b2d03eab0210fc18f385bd319d0b8a4df5d6af1907a2030e497c9e104110740d0423410c5c126983222aee559ca093b5063894843abf799b46d943b2018431edf113a6e6b9d47c30aab91e2760ef7be455040c9596e9637a9d061dc1bef7ac06a4bf5c0c05155a5bc5532863557ba890bdd350f3b81406a042de67f8b320cfd50d4a1f6e1c478ec2ddfe7e48f3e1f222d4ca2313b09b39b4cc57256056d8e760bee7cab961b9f4ca7fcb20148cd7dc0e39a87e6169ccfab6b10537702ecd7e60c503edaf671d5796319db236c3b9432b92b621053912bf51fae699800d6045c8a5c0569c5664c6959a02cd172dc55e5e0a7c29fcdb450d10658528b28e9089972695584dee4c89f1602616bc765c57aae40662de3f6a216e8218678c9c6f90718cbfb40625b2f377c262e862a71af1afb431405ffee10f17d790b14c686fde64bca4455eb755a360353a81c1c3f3700b7c40bcea213a0a2aadad071fe16a37ad5e8aa28295b4aeaac4891f26fb2d1f2266da1f73181df6ad8cd76c2d89512e12cd2a498dfb0539f8146072f58376138006177472f901a3a5e885b5da22c7798e0f82b50fc3ecf53486e84f3a499d3444211220ddf027e64418f8b1d603227ab351e564a486f436cfc6e5f4ca98c73670dacea3042df1a217343a6d97d8693a6b115b9a7810af3b4432b8b167804a005135895d1bbace946ba8bbc199f6b0dc2c333ecd2e054db3b4bccb5f0a380a776c05ca1dfd8bcf55984a9785581c2bfd0ea79666325038ad436b5a627dac2281defd6a352ea7bf1848033b59653e9986eeb4b173e72edaf015fe94d1406bed8af9b3185a865c34005460c67463b42ba4143181da0d584219a0fb6d0c2b44d3a469deb7e3e45793663c837ab29514723eed0c88d734ed1f3960a04536a3b023b5021db3f3b05acc76b3194242a157414c37920258153cc9aa3cb1a9209224ae19f7d222015d37313c76662a8ded9bbfcdd564ded0c693d2b7f637ec601481ab1bd8a30158782528c3ee190db110d5244089ea11d5b34e3fb196a644ec97acf61598ff7e57dbae3ad27c79be08f85e0b4add6e2d845863c3a4e5e361ce03f3f60b32d08d97d19efb6f12aa4b6608aa2bde3353591ea0e855429ce829d50d9fe7dd02c5d4544472976b9db3b89073241d899236e1c7f021f2a31f5b1bb927d6097b502c62ddbe9f438f32302f572774ecdcf25a5e62bb7f72762781c8e28f32d056642de8fe2168be17e77b96c26bb44da5088487794177ec8fd1e3fb03ae797705db034ddaa6c421e090be3f82f805f5a721520e54922cfc4584c2da675761f0b26c800dce8528ef89ab60d8e6c962edc2e8ad3b455051ac350795f55b49e896243569540e38620f58ae9318c82513425a4e5a0b00c880c8df865bdcdabec578c65d31a7766013a319adcd5e08a7c393744c04124ec55506e093e8a10bc81a1022c500660c2b6e11372a852aaa75eec54f694ca101136df74a591fd3076d63eb7068186711e3fa62100f8cd583044dff7717b4382a46fa60ec84ebd6de0e5ab58759a5dae8e6dd82be47991b72e33195b76a49ce5549be04329ce0a5edb4f4a441f481a1fb6630befcddb44646bc7ceeb49e0c1051c04fbf9d1afa108e789b22ab61284549c6d3b43fc8abdb64d5ebdfd64b1e2239513ffbe136deea5e41cb046ce5bcceb09d949d60cb224562673e000e60f28f86ff0f64a4eddcce9b1a63e58a0d2dcb24f89df13202f5baadf62964d6fa3a6bd092b9b516efc9c2361d403355beb7a7e7606420f968f991fb279cf536cdab4310324fe01685f5cddf0882e10a6b5d463668a61ab986bf8d5cd9876a11f6f290dea7f2980ce94485ab250dabe997c02a473e399000cfabe4ae5eff783f6d281e4f57e909983c250cd3d1722b0d6c915d326b4ad57744ab6fa07adb81b578de5fb8d3cbaefaa4525a8e84a9900f2ee7a4ac2f2fea36137964de3ef2a524a30aea830f4680ac29618ec860567873e82c30bb54cda869e676758b27a360bfc99bba472b505dacae2a0c2b882413f8d737fc882b57f46e09950adec77578cbfc8c4a9facc280644d60b5d49be8ffe70479d610f50422f813aff62050c56b53f3dd860dc6ee6d37aca382b673f09aacb9a195ff80ccf6fabf93b6ea79212a0dc37c4c7db5cf95978d429977b152adf80ca9956d07cf80fd6fd3a69762ae4fd39d382e540e837d5d019ce8299178db971b7dbadf2b5a39fa342607eee133fd1ed9dd0414efe3c47acadee50ba6205f69ef82524c4cbe793cd73bfc6628b010a9344d626f85076b62e41afa88b7811101f6bc02d89171c79145ed83bc87328ae8886ef772a31fa4270d487c97f6290dce582056b4e3da0b60e666a9f9251ae843591c79cf7f4d519e76baf6b7171a90326ded473e6465785bb40eaec41834773adfc90ce8ae00d76ab1da3f16433b84799c26d1b9090e65ec19bc7dfae3d403b1a8f3592b02196102399580887b4117cf8a324fcc894e4fa4adbb83737a66e5157d0e130254fc2c0d673bc48b34fe46af4cfcd35f8ea6f8981a7afc32f3c592dd2a37cb879a89a1b5a54d112b29fa26e5ebc95d10bf443a691e3c1d91040fb3e5477f8a8559acd64c14d970bb17bf02b04184d426a068df17a5e31605307bdd85f1542510732b20ff8dcf39427563d9bd147c5b2e0acb2e8535a6ffeb11680671d62126e5baf9784993ad0f50d23f98aa56755585898e16d2623230f584acee1b1ce551b3e32e007a2124c4afca4970c48f646725aa770f7976c07d0a817a2d7d778fc4f5261374483b5cb6eb46ce340b68cbed4ad9ad300a86d5ae59da4132340a3514911f7deb56f4fcbfc88c940eae3893ddac04d0990c616f49d262b7bee75c2269121d9ff9bed49af63703d6238d4263f59163e2fdac8cf598e628f80b320517ed7ef93036e27b3526daa65530063bb707cb7eb5a018f28151b090f053804486272ac002764ca34e2a907dd091755b4823136a525b5c78e90f95b171cf8890524394912bcf068447ad868f0d4444d1474e4e3bcae03968dbd503c16797d0542aafcbdfc5201e26465560c2bdcebd33d0eff34536670327786342855c6c64e7d224eb00091a5fe8f9631c4f575754657f51eb2a4ef2ee780a0c2ffb13400af9484d3b86642649d00740a26fd0c0ad8d9c26f56f9b83bafa44f4fb7e0f6d93bd4b7d034f95636ca01566e60fd584c4fd6676afb592e8cc86f6c016c4b6d2c31ebb4d99a524dd063a7791de64f796854799a825ebeb537c10c91b49023c77594625d2d36d3e06365977e2863f29f8f1e6254879550f54a9b90a64650716bebadc514d06e3384380c9003b5290e42989d4f28ccb4bd733a0e5dd88e08edaf1aabb02aa09ad3ac24835b8043bc7c580bb9d061971e4fb334402ac542b17b54a641c47696988f3ebcf9c33980bb39c73d005b3b78619454ff35e1ca763443958441a1153820de26035086c0c012e787e797f40351738703850a22f1cc198a37ecb3a07e2b310ae52b57db03ee03fb27602d6530dcc1955b696b2ff0c27646af7e21fdcc14589c2f3caadfc98b273c9574b1931991549cff4dc5b657a51419e2b19135b07caba82a574c092313188015574fe605c3e05a275603f3ad7a0d50955e3e29df7ad8d91a28372297fa11a1f45249fd7e173d467f7fed9aa699621c1509875e2096c5ba815507c32d33a99ed598f5a14830fb4d4ab9fc1392cf97043e6ee82adc5a8eaa91af973b7dd19381a2fa81957b4f921144d9ddd6bd61cc4f18f432e932fff65d4088f85827cb1c5e2d34ba0267f52593aba9deb026229772971d928ca843aa407f027137dff4b13eba0ebedd147e23ba8a02c03eb65a3dada1bb84205450a7a9aa25d92ef5854d54e783fc2fc445dbd04c1fcb8bc73c85579c12bb271be3861fe027c39fe5b1cf080a4d79cc7c5eac2e896aca823fd8eb09e6b0704c1a086b54d9f463540e0191e000b74442d695a1799a4e3b955ebabca6b3034eca7b6c2b3bec138022a5b25c8011c6f5646c81c3fa844b9891597dc6539987ee13ba184238f0f2857348218eb79455fbdd88e500d5ddd53a9ba62c881504abe4cae3303daf32d9113bdd196a02077b24c919c2015beaab82960ec3b37578aa4de809a62bf3e8f7c63ba898bf0c9f3cc26914bfa0479830785cd17578ddf70306b4422bdc151047fa90386e8089386adb24b6b8d15572c7fbf01026c5af2de7eb0c2b5adb36c25b9c74dcdbb061b131e38e0bef894f90c3a36634e02851212fbbbf8ec840a06893e00d5fecd986cb7f6fd24c5c473fe7f5f66fe582c52e2b7f23935f19bd81dd0961016839db5f21991a58d70f893517121404f8a5622d4c0a074c7bf6f150d3b373626a8c88f27d5308e6d48b7594147a1f16f88f3c8f173a5c8e4390190d6cbeadac1e8cacf980becd5e9ba39d3568cd8381cecfab96dfa91b10b7b58bc89da82659afc7990b1e3e97f1e035e92449c97c5f6e7acbde920b652f89f785207e0b56b92c8db69d80064817bf5ba94a32227b959755ed526e7e05e98581bf23b9e3a8368b03508ca034e49005c802cd4490aeffa99db98a33bb15fbe8f836ef5752b14eb7078a1c43225c3d2fff9882b6895c4a3bab235804e6cde26d6bc41bcc6bf0cd72d33aabf709645b3829428d9a39512b1e76570af0822f8d8f878203b8346174a61638943c54c4a2ead1b40e4320211ab1d5bf0a0868346d582dac8986ca3b9011243c7f85a851a72cefc6d019c5a82893f5b84222c512f5763c73473ff3577a9274791eb64f101b1953e0c22ee1e30b918d815690c3836e779d011d1bce269ba653c4985b5b3e2ef479d2418b081064647d19b84aae48b889e39c943316fbfcf47ae349b2417dcc27eefc2be900cdf9719d693be3695664a53771fef8654bdcea05cc41004c378fa12a2cddf50ac98f43265e3e29328cd8a2222dedd8cb2d0a96563ba029b66468c7b8a56c1f02579af90519a0d2ba936922a254094ca8edd7ca4a7ea9f0807a074ad8dd9aa03098d469fb5df074d6da54fb92968572c024cb923006c87a22fd81fa59c499a3d0e773b4e68bebcc2455756380fe895e78b014f0545d3af69778e40ae15ddd4532fd3460808262ac9d30ea1994c422785cca3e629e9867ecc1855d80d799056ec73326366399e8656c693811c8ce653f1c07756c8ef1097d3b9496f1196e0a00eb7924743b2b8152a4953d11e42ad9abfd39499f4be64a833dd70daddab9d88e0ea1d46c50d83da768497574e74563eca8bf5777be0ac635f584cd65b9e9cdd064778df888e18d70f92a1574a904ba7209a61ec8e9ea2db350b2b764bbb78114e8c4c40d7828399a097ceda9615b2177c239981cc333a1eb5e75b14eee591eb486f87e41559658fbc9f3a83840a72f79dc19c5f30544c80212c36cd7c633c6064d527e3144907f87083da6c76fef47c49d85837bf7872fb5a3fb68ffce50649e11ff3632f2130de24fcd2029101c40a517b8de2ad59ac9dc7b5e85b514e8b47b281ee310278a5a4085633c5b16905ddea50fdbc8009913260e8065655320de44257f6bb86c6424acbbac0fe8839895d4fafaac62234d33125b83082864c40749d805fe81e70d4e9f6b67c1574e82d0ae40a8a829adfbe0100cf122ab347a56239a0052a5d1c1734141c1667fe9ec8817d2f6d7c62db5e3b1726eb44de3624e9d25907093d8080c56b1dc81858b6a36d8fe49cbba0291713b03cf99ee70030e00f3468eb2a1231d51f18abea950ded7b3a59c28714476b38e7f8507281315cced5d2130ed5ce20b5bd82004b3836f98b6e3172d971ffc5ea0b3276e6ca3bf135c9dcf49da0fa7336b68ba399708c3bb89836b104fb69aab8a9e3c431f21453c013b37a21d25ed2f3aade04b71e1133b36184bafe1d4c119642d280d81677c5867ac4d418fe2358ba8296ee4a8f0f2cfc9e9226823c2a5b36b1558fa19723d5f3723dd3cb2a57ac4cf185e93a7d91bfc4d4833c9b0cef64222965c9577134b3f5399c2e4bf5a6d3b74143bb20a04530371fa8612cc16e2c26a279553eb061504b860e838d85807a4fe685fb0b8ebf112014bee891d7786eed29ae0d6ce127cda968be7faab74a86761d727fbbbfe483630b54e1771a59fcfe7076762c00f27475f9d9bccd1456e65f64c9f7952f3b8cf5a61025961ab9c2f28f9322e95daf5de131c27f026755bee9f136230595c0e9302a85d1115ac6a8e785b4db2cc06b5e55282b81c720ccd3a5c6a4aa2a7c3661de3428b94782e36cf5e2dfee4b58777f38496da8ffa05483c22cc126d4c74af752cb35d22981a3147767685e515267b275320877ab5d69c66c8240274233c04771b59d4a9faf952ffd8b48a894e59087d8609285a738dd3faa752c2ac53a195dccddc5e6d4c9089507e2a2bcce59310c2b7ca15aad2e35b2f302936a0207ccf1da58143e4705601ee50c6919e430d6b039d4d79805614ee1db5ac9f2e5e0efc603a3e9b17fe90b60f11a781038b1eba91949c04bd49e4ac62d60a8fd374d287c649abe7780482399d05147a29113b7fe23bd5d3f9723fcd6adf25d5771480b111e7cdc95e4f538d7d6b66a95fd994256aa795bdd59e7f3d59990a36392c19baa6b0f77280f13c45eb0d73dcf1da213e1883256b7c71a00e8480605c0241f5e8065ce15200203d55bd87f360ad5b640e84aa34120614a0a5e456fa942aadab667848337d5cc9a117f10897d8cff7164300889796776de4267586dc7f647be27308af6aaa74147b31955c9ed5d6d528db089511ee643ee422b8c68ba8daa06c463f175a3639439fea3f1eb5a9422d6da4430b93bc9ccfd78c1868216c745cc6a865a148185d86a13040cf8f4029e99fe8511e69d52d974ced5d8737f24b5410529c3de2ef4221231098eb8fd4f42dc92ab85b027a300803647f805bd1838a707658a76f8955a7300dcd55539970dac5466345b9b697397dfe73dd8a9c33b6ddc8d7c5a0e74c6964fd7bfca9ecf1da92efeae0fc0c31f741c1ee1771a9ffd78f0c66d009e1e0e7260029fad0b242cb3417ddb607f20b204b8b8396f25249e18c6839e4e9a76d36fecbc7f813ade0ac4b68074a615c0c2d47d98bf12b1824e6187dd0a27bef1b0ba43e257624aed64c7ebb66f6539246cde441526fbcea52afa6485049cdb7901db46aabb57e6862af9bc93c51a4e104384a9e8f41c5b49dd40afbdda07daf023f8fd1dcc294bbbb709b8a42dfb07e46a6696e7f6cfcbff343aa54e471e2ebbac8a2144f74fc6b1e3cc56a71f2f34c48193d6c9fdb8d6b1f21c27ca74adfb502a81c0916ac79861090cf068b4a77cc07dafd7b65d18973d3b414b658d644a66ceeb914b1502de40dbc9e8d4fec7f214c11a8bc0c940fb79fb2b3bec90e0bd644d0b0510df7e7c26e759e8e867d657bdddc42a5b3b713154b64b94e0037a05f18e46afc587760a6c5bdd26b50d74253749ca59afbaf37c90bb74a37bf2ea46b37a9b0418f7bdead514d04fef50eb1159b99dc9e881869e071350f4fc21ab915a0da775ae5f61d4c7e2c5b3bd94cd5d39678b511b3c546af275cbf2691c692c7d48fc04ea632842c16549e632d3f907199d84f9caaad40bca46b809f3482870ffbea262fdac543f19d0fb176238dd863018a7a4ba2bb6b025eda03a8561e7b3f54ef0520ab683e32ed13c4e085d00845bc5580747a032c29db7e65d5e65dee425cbfa1a170810b5d1b0bd6b21ec90bb9f60c6b2e1653dc07df8b1205419eb7d174dc09d8b0a76111db1d50996385d3605e85885d6464ce1a0136eab729452b5adebae5addf0e1aa1a8bd61388ebf57a69f3a1d59fd4a2305cef3d814beb1dfc705656c003a0fba8b0ccb9e49e5bc2ce10dd2c0289b9509bc925e431229628ac0f26e2a95f59aaa7e188a2ab64b8a4114a8212c8caa7032220c07f5ea13a4e4870f92f2f35083443bacc68ee1c94b5f9f0ce784b5b2b6673be54a913ef889be364e1e2313464cab6738f7a797714894c3f48a1374212714a6ba2cef2251871ddae1abc1196146178b10a6eeb7fcd5a0186cd9475960133ec2e0e235c485ccf1672f6b4d0c9869979a50bd02574c77e36da2eb2c85cce22f3a4cd6eb00d1191c93b3c1c0af0be5965158e153c873ff8086b5a05a2d06a3a59502a2b98b7f7f12025e72fe85cc511f0396fef2053f9875a4752e429c7a11097edb0c56e0b0cf8eeca88ca796bb13311fc6cdf3a198697e5aabe7192e1f666cc86c08cfdaec702a506d8c46e03ee9f3513c9a8002f3786cb5b4fa83234bf2671c32b65745007c99c02a8827da804deaabc33ff29c39a25aaf6e7ce24510e7c0522cf222ecf793d018e19b4aa639e930b9df07879c1b9891306daf1eacd6b0eb9164df44d6e2e033de5e70173815c310626679f2b20bba7f03d0f1830856d970acc922a04f4147456881ca0116703379429663df745db1ec3c4bf370390bb00a9d8df5317f1f0dbf458629d0ae7ebd3c1632f39fde2ac412eda147d296acbf6f681de73b78c47ccd037090f51511208eb6d026e499af8196f6467ab17c0ede3c3f50b8e01f1d626d49e354c5e4d8ff9ee839061b92079a77b9d6f0372be558dc652c0f9e6a788591f64aa93abb59cbc014459c423250e06835f90e624b73f5f5d1a1e84c37852edb3c26c1f4abd664981f2d5852c9e377039bf01de7918687c8d901eb3a1ce1984db8f968303ee066b6a912c51c046fa7832df2b660ab588bba9737dd33d6c15a9bb5da75246c86520a8a0490148e078ce25f25b674cc05fdd1514ba073408252f414eb4d3c791845aec4424770b5a4513cac9d416a67be8e075b3dc5925ce50d663e6108c4eba29144adc2b08eba0becd5a3d2f5e36683e7aac4f453150863669c5072472bd230db33d06bcbe0e6a8eb602257c4f10cfe03e3f712c238125c587ab72bcab0cba1f21a2ece27431d3eb12c760eeddca04f41bc741179c3f211619fccd0ae50379275b4cbfc4ba6570262bdd8ba3face03a6e65d2fc6bd9c1fc4856a279de8a0c5e2ea58304b7af1b95a5ba6c2098a0debe67315acf99def2bd16adf079cc9532fe3f50be04123445ad2cf72e855eb36ee3ee3af5c958ea6d4436f397bf106727bb8dacaa0a0a044cb31f456a3eaa7e2c96800a3c59b6c3255ee8326545d956c9119c2a0a697168e06acf621abc8f4b81b49d40f25a1df010bbb1c423a37e0425cad5b2012ca5d4e3a0a33809535c4a730221ab583f478be52edc5f740adda94558c02a05cb0b56c88690e729bc549b94abcd6c2c8625ad95f31bcb22ecbcc88543bec00ab75aa7dcb1060bbb0577317bd8cdfd0a967d2654543e5eaa9f33aae3e901b2e4f1a97f7d374918f86ed083bd42c5a4b996d2739b7b038bdb46bcacaaf79bec7578ab39d64ad25f73f65773e859e2256f225d23fd74ee4ba350e12455b79330890dca9b7f42e8415bcf418991255b2df27434257b5f79831b7f2c19d930405c1f06b5e75a503e0e68398b1b0023e21f1923b34a75a1abc787cab4f2f71cef7d63915d4f5603d508159e12379ec711291f68b16399504dd2b1467a97397febe16770c0f2be84e1070bd7fe1e8e1e5ed91ad8d01ff3d9fda9380a4549d1ff03ee8e7199adaa900de48ba7e9716dbc5037dfe3dfcdf8287e58d41ba0b0974b342d201c991870db7aa1025987f13d1684998c2349877e37d0870fe0afc7187a0cfd23a91313c4e80ca78d029708da936e8b639735f06ff3dfa3dd4c0b88b836295347dbfe18db44f88f48083edcb1bf8d9b6e631c8c024199ec4a742276a570b12d7f6d9817a641605708c51d556f44f2410425b799f17c9d0e5598c89c75c86465e1a7c2fa137e45e7eead8a23058afcbe34ae1faa1797524ea3d5ba8cff0d807ddd6186280c5d452a60ba9286dafaac4d5462a6ce0accb9c7f2d9a2dff6f8e655d24213e46593ae40cbf59ba930203b0494d8590ceb027611ec73cb4af2da26f59d3158d51b921011e0513376b951babe06657128980117b3236b8a07e1b6339518c4bcf802621f2935e2541ea1510604ed5568a79db93029ed547322b7f491d814cc97b3dd98e957eb595f210c2a6291a01afd7f7322ca4547445fdbf605986ebdf5c1737dac4e0a070ba15efcddb901c24df73ee1cabaec7fdabbea8dbb7a21962ba70d042eb7eaec4d3d6a4b2c4ee8f17a12b7ae6057ae1d8b7f5bc74eec9501c25193300e1281f59df0099b98d44595c0d89e54c7ca284127fd416fabe89988564e4b669135d83f9ffc5c8b83049e2f0e8bbc813640e5953558df94f3dc627e1da26a1230f6caa37681bf48c951748b61e686c7fe2737a89680c6356ea4ab9fe392bcebd71d6439764467b3cb33758bdb38ed7e5dcd9d5ec9826a81febe0f5160696ee01bd105f2d693e5b3607a3e60b370fc8213065ff51080ab42c1bde746d3be6cf51ff385a9cc6b6a5ebc25eb4f82265ad6debfa04af85cc0433e6bd81dc9b841c618844604312de794c2c35a40b00d44f295f7fefc42d6245c853c9700dfccabaa12921e732e3bdc3316ae6d2288b5229ab0994ae45208d8106fc81be67429b16e51b58c2526a201e87b0c3b592b449df3c577d71f8a04539b6db1bfadd365e8e1ea1f857b310a7269f8ffca013ce0040e0a94402d721d2dcb7144842230d8ae5ba6096a0ef0e385442a06cc3a4fc189cb29ba7c73f01bcbe4578f2220fa8e9d8eaf2b3b30e44bd345fec1f4465cd4174d36df8286691f7de610c68036a1da277f4f4b6f0dbb9af096e28143741fab33a66dd42986d0325d7db58f8f3f1aec37532b5fe98f4f6712b05132edbd7a267ed2b61497fc5326fba562c135c5e3a7cf6e69b5c79d986fdeb5b5cc4dbd2f2feb682ffaf7b3db72c769a910c38a84479df4e6f44c7d965313fdfec9d38de5ab865afc6bc2f54d61391c793408189158dfa73e1326506638c269a3432c8a6a5e419617a7703406c8ecfd28090fa106b6fcd4aa0b694e2fbd71660f3c158f1ed1a71dc6308ce5e20e554460b5b6aa556be16f32fe045605dad9f9284a2bed96c0b38a5d4e3dbfe65669253d5ab09fe7c3f11499a8fa8946ecd4a614920d903daf0240cc858b286627860772bca0fe65cebf983a77b7e30b505f9f441a956f3a6dcdcff57d8185c2a02b625ac154d9a0c6bff61ae24d1e922c4356b5ee11a261034ab120f1c0d57b0e0ff17637de91264cbe05dd5bfba08aa52305499d3d066024c992e30ead93c16a2518dfa4021fb0642e0840e5b278d7b83130246640a831e05218332971a8f3a54f534eb50d421b7d53b055a6bd8278b46dfe7e5815cdeb6246eed85dd5fd7f696b988dd8e956345175dd20d87a952fa740653813bf5d6b61fe75d4f22cf02fe8b6f174f40e3fc6f5bffb2c390a69b8d8d4c2b57eceb9ff0cd485ef96ba1806728d714ecfaea3ae799b20a9005f3097fc71a5a35e225b8ac8732a79ccf701472f36e3f4e4eea47516d88cc64c1392908e19247c44fb364024b8d423a8f38c2fe59c47dfa238253a0e6d79301d9d776320b921936acfba6ca962596d9dd78b0988a802556666f5433b3e2f6eac21af4ca7913798aca6e28fc208aa14527d3073a77d12624deb7b20815ab75e1813c3519c1c5c37520a20b6aca1725d068671cb5ad166759d49905853a92e6c2490f2178feb5e8e7a215abdd4c4bffc239804416b105be934b40e1541934858416ea4cdddfa126f4038608496fe05cc14880c9686f4cd2e5c720282f44893c8b1ce3d65a78dc57b40bdaaaa452873b9cfdf65f872bc031a2c0c70191469a362e29b856639a90f17f131393ffeaed7f7d5e60bc82c8f7b1aee3fb798511eabb05e370cace1a987e43fda50243f5f5e7af26244a28e05f3d530fe25feb942c82d3d846b453a21f02f8003ea688a09eb4cda85f5db4a84b92a203adb2b91fcc1e838beeda0a61bd634bb4d7f3e07d81e70ae5ec0bc7e19f46d14da93fc3aac6270c213b42de1dfcc2214826946a151df09f67e61465d77b315040663a254059eaa2b2f7442217898c44e916ff6930ae8632d576d72680681391edc4aa1070d28a6984ffdb07fae5fe720a84e655682fccca14b3b95fe45e3534d2dfc9a8c33af0f85e9efbeea970d7ea6cd67615b3cbd1ae6fa268b3e944a1b257542308ecb256693482c425a72058f851080a90de600d140c17db9529c5f1ebf25624bcc4fdf21632702463ad80557089eb12bb31f885231372294c6b89be502b9fb67970b0e1342eec0f2e79a978e3ece3da45e3710375d4574a7d37b7ea180012f55c028287d3f196292b8f15cc730148c01b945c159079253081b0469f3f173969d10373e8fa3e1551be375b6c7130257dd0f0c64454faae33038fc283da2728131ddf19092ed4cca205bf64b58efde89a5f2588c80813b57c5eb62935436ab33317d14326d6d1a8ea568fdc2b6ed08ac46ac01a7c6947b5bf12d025d82b0d09a51d51b3706b8029b2db32204e8c14c5419f7277aa22177da15b9548ef6a1a1021c546c0a7ac5a55624793ba578bd21dc25a704f71dfbb7e00f0bd3a4d66f2052810cc522e9e6e2fd1fba9b82b60aee239697fb49c3c5d70552d7f5d19bea8bfabc0fc2b0ddfc9af698f200d9eb9c36c24743ffa456f09b23e9e5ed53aad1d7fd0580d173ec03e6ffc819e846c1b48e11ab6f5affda2359252d08c1d6e85e3b1ad4d54b987a3972609006169090f3a2ecd76e36025e1a63e586f9e7e3ac7056dee318a69c14d43dc3e8d10b3979b0a1ea2d5d295e1158f018553ae51bfdc0dce2773b4b5b40dccc626ecfa4315d5ceff2a04fc9bc5cd17155260dbbfb6aa4d8464d7290cc72a8b6dcbedff33af42ced74343d79ea8b0ccceb708278046f390b0e4de0174542c8b348f49e974dcc7fd668a3b60584681de095c4bb2459a0b4137e64a3c14254d453902b02a538db34632bfe1b01ce2aa901669e666a5a729a3418750525523195c1a880397813006ad911821c16b8a8036775d650b3b4171eeab7e2bb31cab766b05f649c881a2ed1e7c75c14f31b14128c4612a88809e212672cebd6e33722be749fc0802a2327d7cc5754ca6c4ae7da09a891c1f0fe58f9b454bd4e0a51af5e2ecef75f772b497423c4c649c12251070f9ca16cfa0738aa38968f569de57e21d23ca41e19f2575b819719b570ba228fd43bdef991de75303c8ba5293209598e9ff6b0f526ef6fa43060f12746dc9a07c8b2a5280506d2d499218a00488ce0e065ad8863dfed034bec077bfafc3161ae11163f774c9ec139cb2d5645518a76590f1bce60bbdac2d1cc4fda17e58ddb79968b07490841ff343cedf3ac1a30457350b99fdbc68e947c76eb6f11f1a6e0a5b5ae848e1bffe2dd4089d334657116ca14ffe2eb60d124ad10c009a9bb07005b3bf789ff688a22326909cefa80538a43198460683a9e4471b1a53bbd8866e349b387703335543677d9a4a54b02491062ca06643ad4a2f7f24b43dff7cf10b6143ad67cb1b94057efa53d0176317d56de1f6e281d8f69de842ac03dabc5548a7c980f8c8a21f6b3078814fee14aefba6045c5be1901993d17487fc98217755fbb946c6c411329b65a23f1beaa30c486814c43435bb9c359369b3f51b18f1a93f5dda68888037f42830fad7cd6950c6a76caa3eb0aa1553ec0154a844d5500273429f0f5099cf157084e086401591b370bbb965798bbedcf959deb54a07e91ed9a85943f7859369dedd6d94f3d6544386eebbd81189de3d5d7e804ecb2743fc9e2b1f55d390ecbf8923ef407b8891b187cad86a4859bbad945a5bd79d6a2c3dc5ea744dfea26af63501160e57cdb707b757c2b6f7aacad8fa76e36279837d4b118865a31125bf98e4772b2bbb74a397d1cd0ff53edfd81498facdab178efc1abe1d446f8d81074f6ed8e0e4011c36de9f15ea607049fe08e1a3d5e9edc7474ad2407c1d239ff4b0bc3678446e9122070ce4adeac8f87b5959189db3099b04c8eae02728c87591119273e30f7a02d5666093552ff32f35887b66daf533ab82c2988d4c1c6a5beea8a25a66d08982e842b471793713aa60b48e69c0a2a0e8e3d844e287e928afad1e0182897b98cd191355c60525231682082aec10d9edbf30243d076d89a3a9b10b9852f603b6d3bf65bddfc6dc7a9759f11715cca376b9d9d5e6fcc3b32da6b6e8e06ee65eca0102b82ff39f059c6891caab193a428729acd9d4bfc23b7c215c7358ca0f72994cad2a3636f244bd555399c8fc738cd689127fc465ae80fb0c14a23cffe05e490e4b2a671236d64b7f8bff6dc556664665174097238b61ba621725dfd58a6fa1c5b75df1d7ae3a10174c558603399f5c3ae3c0f5bf15a307d5c0cda1fee964db22b8f89768254c97efc8142d324820a856b1a00ab6aa4cea9bf90a75c5fd2f4e896c198a65b3b502722d5f5f333c066deeaf55da4814831026585a4bc27922c3f4b2b3c3ebad9fee018d5c454a7f491b09093edc15283e58d3f1f864030d00374f745f38ddfe4c28dca9943c9f5b9c3c368f8cfefd411a186a12862e4cc28f79b594c44b30f5b3dc42bfda773ee74147176acf1a2b1589a03243cda07a9508a02c9fa7d1b3b9b79c96b5c9f2d3f5ca7f88896a7f1f652eb43708d58a65b5b9db09456f17639dda832f0996f46c15450a8c404dad293f53a5b51b5201d72fd818bb8cd000d4da8c724eedbe4c84fa14f136676a679252d945d2c7e3f3349f7a94f9beea5afb334d341079e415b691620f70f04e0dd33a974800f6a81b68fec66b060fb7b80f2a6be16d0c484d78c2c88a129cb2caa3d7324d82d42a70328bf8262d72271a79dbdca2c1827292b4bf4c19cac9dd90b150d1179c4299c13a65226bf94e2a25cb5e0a44f2739f49c932539721a425806efac7923b20e85931eb52ebe109ff57261b7e026e0ed79eb54fba47504a94089da386ee0975c206cd5335497ded0352ee7b17aabefd6c059277c127397212d0a2619d6a3ac15409bf529a1bd7708ac51218b7ba7a4385c83bef7c2e2c74c0d823e220c930507d243a2b9a5c2bb944ce17ea5a0bac841d96af901769472de5ceb2dcea0230b7cdb19d76207f06815eaf8a6e9cb98ff004b23bd05db6ccebb87bcce47052c18104589be143e2523e7c3231874ab8ebe862ef4aa39405b87d512e4a113588aa315e72a3ca3ff692951a38e7532738c4f7de9f903bcf4b49ec12115caa2bbc765a706b32d9c3a7fda899315ac053a1b9f0882519ae659be9325bcbdcb0a5e8f781b88442d7cf0515fd7350887d2243e28e51352adac496b8d3f80a11d5de5f029b6c847d5929c985d20ba849ec6b29ff50af08b7f8936806281d2142383a45c1193efeb21f025b3581d5c3e2c2a025cb32e862812469bbe785cc8f4c9f5f33e0bf19827380f193fa5b4149fd2cd0c3da989d7130f4090fdb16813f460681c915ddec339f0ba91b75e50556fec47a8f3ff98d20132a371b23747458c783c76b3cbb991d5b0d65124b21711f927a5ad4ec04092a709b53c5057dc5d2996b50ec75a134e08ea11372f79ff577607c973cc4f8ae6a659d700b81d517a2e4c8ae86ae58e270cfd8730007945a36e2a961a9ad62e910a2f49302f72e37b5da2b96509ed24e34108def9699c60d764a048f4b15bd8c6dc5929832bbc255281f0d1b565b3437d8d5f79c38daa64e202f1e2486b6a225d84b6fc8cd10c6a1cfda57615c56b56493c513528e1db1f698336880c37dc6f28f003734293ec044363692ae938aacb95063b6e836df1a150ae99e4b620500ffc6f02d3c2c5ab76eca4e4f5f49be4b62b9d8429f7b119dbbe8f5eaf32378c6c974d08dfc816a3adebea48ef26c87f6a5a31ef4baa4ad2c5711bd842fc4f35b5b6bef928bc034772e29d7d12fd3b3b61cc39288ce02fa2aac3f5384d7795d09e161981bdd706ac5975169f5564fcde8730c8e9e333aac2f6b34c82a265896aa1f0cffa2c3922661c287dc70d38775a6102b0362580cf630bead344a7151c89a78b38b32e14e69e7e9225651d4d5e029c1e3ca3dcf644d57ba33a68bfeaa1a0774624230c57310576a5763e20461afe83d0aa7633b40abe05035e1227f91f23e20b2d2fb35738ee96a9b25cc1f2b4d5fe9e0b721c03c2658362cced80d794c73fe4987831793fe54fd9e8ceec69cc7f42d1ce401f9ff3ffc46a6b4a3def35dde3169f11afe2f511bd129bd3b98cb50a044d759978ccf24a5b2c36735f4a8d1ee949d3a7d2b2e6fa6e04c773cd9a9095188c777ba2faf365212be1a127917c8890e51b967bffb5d795ea2530742b83ebcaef03f0583b5a4b25dacaa5b0ec576bc8c8d130cb625a00fbdb9280863228a6175d163175dc7bfdad5c8e0f0d3bbda73b69623b29362c63783b428f3d7922a5199dde691332522cc5aef067f2f08f5a50081e761c4f2913036f95efd24994adbcbcfcc7b67f2e954c773e824d3d95f8aca04cf5e52bc671387778f56ceb445f671dd88f421e7c434b4977ab40ee5f5608f9b7ea08b23f2d870dc6266c3605194e09a9d6b9501d488008e1395ded04f2c8d0d744e23bfa87052621fedd6fbaaaca5ae1b386dcd2261468c7f76b2c289ea6e72743e3fb43f8019dbdf0b4504878d7b69528f44718ae4cc75d8038a4c2327acdeb3c6a6c59245c59c82f2120b46149093f23a21709d6c33e8c9df6fd25c110e7e4e248f7e96b1f914a6a53c431b0aee78db8ee06874dd6367473594005f6165249a87e8d5393cc1e1ea229a97170b82a5690513ded5b63712d0ce5d205d0024198f17a228d8f22bcec62a047a6fcbda1963d5d21832ed074457f62a30bd8f21aa1aad4284515117ff9607538eb51d51cc531d0fcf88ca9900bd28a07ef11551a114a2e691d76822e62a6c6274c8a57a33513f4f08d815fa6d6c4e69cb8c0fab17a8f8ddfe12c19a92aa13223213437ab2c1a8d60f4445a4017f2939598dd3a66ec29b695e89d79a5856594134095eca45f19823022a4c667b5791d28359c317c523090091f4f931db7c78421370ea8a7db22efe62cf1d571faad191899379ede566f02ca7d0c66215a9af4e8d8eaee682e4107545233283eb5fce62ce0149a554abaaf182ce649a4127df77911efb59e15b5ae5a98f481bb0ef1c99a95952def60ed376b73996903c459aaccae7f91011a30d6f7012136000dab754e0069367732339d2facc095341c57c88862ad0834fe7ac044dadd64adac246ff99569a120d11ade2f87666c8f801278075d0789038a7f70966c77d3e2eca2ddfb93524ba5b7b7fcfe082e6f3d6886b3b42137225509d7239e61520e98c0231562b6c1a48bfaa595b97eae369d9fb867b9d2b518b5ad89d95010aa1603afb5131a64f2c77524ef052659fb2d28398a995494ced22d049a22e76ea742391895acdd52ad57392c0b5295ea0f3188329614e748262de426f468b782a8be5fb653de30e49a986083863d93a004bce83179b28551d2d637f9ac90c28eeb637138b582491f55ebae4caf8fb76fc4614bfa141f62bb84b3e2ebef9aa8cd8b3479500e4b8c90ee94c49e8568d48f70a97f810b3f92a302e475bd530d5287bed51551d208922e93ae7dff3826546786d01ed0187a239ec9b8ad563622c4d849a7e5f74b7e1f2d1d13eecc1f5eab5ec6931d34ae1cf0649b4cf3086e85c48e6af65d3a2c97ce4b90c21c1048dbd9f76d47f3d77303a7d4d4228ed7329207655185cbd133a401dd27d6dd8936dae049bc6fb4a43a661700d94cd8ff9fd2a72a5a1037d5388662543abbf6855c2bcce3ff48a120208fa26491d12899d0c65882f715ee6e93f28bed2679a5aa7559b3ff172a82a96b1282f642d40fe5ed612e91680c93aad62000baf15bde39069cea3150173aef8acdd9c97784c6adcf93b5dfff574021eea110f85e88b446ac170a5293dd211ab2b12ed2aaec3114f309c2b4c13e883d91327ff45e8421ea22af943ddb9c214dc95a94a7624dc40faa378d1ec3c755e25c30329de3398ebe0327ee892ceff16b5adee16afc3806f8b6bd25739f23907521c06e90320bee22d3f754551f31555653323a9220070efa5242b183fb3365a7d8fdfbf8a95a3138cc71673b2432bb2b54ff07c12656c1bc10066a6a0120fd437e91ded602f30e13510dc192d657d4e6244189caeba892edda033d490732f8fd562c1f85dbe9310cd7df7b12cec8c21cdd4c9995de536055cabe1913b4d1d991e154b977a19512cdd7427b68c9d53bb59be4fca63a8b4d4fe9ea2714ca07cebbe733bf3550b1a9f62105ed08e7e1b329fb0a9c4cb7ff26a9470a29cbfb283543aef326aae261555569bc0efac348f9677f67df59455ac5755720b9d611d1b571db4b1086d59b8ca443fd1eda4197616bc8657e180ac710c3d8f21ba56cbecdbdfc4336755fc215f552fd1693e37cced71a8f242d3328456d0ad64f2ced4c33dcb08fe1dfb71fac591a99c151c8fc9017b175a21a04aea05ce380dcf14aab1ecf42e4487a57329b73f176c9b87ec17108fecd0480ede99343ca5caad7826f11d8903cf63b10a1b5c2b917ce04001eee1a7fe8aea78e1c32d0cee443b16e6d785111ea8813960469687e1eddc4d8b979be86295df22e6918045cf3e533e9f93a100ac582e3bab559e8bec866405f9d55369ed8768448232a148336d1253f6d3debffa81da1069eb1de59a8d955f8e00ea8168ea8658c16fd9ed04892e7af2f523cefff25de209e56e9c3b4c448e7e32afb5718778d306a9bcf61e6677aadfd604f15d433a567671d63f43019e94204a550f4b356273e5133f0aa468623bd8944236aab1c5e19c449aeee9c620bd057218a9c6cab1e1bf80d0e8a6ebe48a0eb35204d2e951bb9c752c71acc3259d5567c8f82babdeff387965e59caf39c86c53ef1f400480067edb79b70f388417f09ee989d306f35f8297908629f13459d2094d4c45f252fe6eb9212cb8d77960191d71191c03fdd7aad5d5aa7afa696e89c99d120179732aa8a3e6ac933abfae0606fa0e078f761c1f09f6b0cc64f0f8e167545bb22232e773fd268bf9695837f8ff3fc90e0741b4fa71a50cff68d9e460e851089ca1cf66640038782fd8c80738ec6dc1855f74d0cccabb4d84e5f2af83a98a44f2075759b5c23745d0e33b730cebb73ab9ed8c8c6e0bdeb4996982b13694d66d6bd341074e5b7e56a1466e559807ba23c1a2e2373b6540f3facc01aba690805205a8f11bfc74d4b2701688baabf495d5b87938f0baa45fbac3736f024880386b85009edba18285e07a8b46d7355d246a1bf846934a464a611e3a230512fff853999127e3ef347f88b0c563627502fc3de9b11a4a80e01e14fa6f1673c824eefc0b7d3f1aa1a8549365a63a95ce8bf166b8c8ad282a1d9a5b06f0132059517569a5a8a2f7b534f822c7315536b0a88a930a3137892a6a06c86d2522e013a4eac9832fa08ac24e462417e40a005208eb86b691d58f4c8bc82b1b75fc6d07b48f56854db1fe061ea5617dc1cdf3417179056abf928eef12563a60360d563c9daf969cb9737a525cd4d974592f16594a4375480c2eb41978b41e03fb48a88c0f2daecb9376ef900d4d47a7dbf7d1e3f7e917f889a3b2b4710e595d386b1e1a0680de56021a9487e3f9c613075d839febf48c5c3744ec44fe6552b11a6fd6fc485290145bd831a9497570557013b7067486df6ac1862cdca39fef15d500b7e28c2595923735bcf4e3ab95509bd45e52a4bc3b9ffc38d25d3e27854a3ca8e4e26a4866eed9c6e3604fba0db65a6c91029707e0067163fb52f72abf86deda90c7de18237fd17660ba92fc427806ed598d4a3359729750abf70645f8d3cdc5634d60eb338bc2281bd3710fbccab1247cd3eb7963c9c46820da15cf66e1fd5cefd9ff7f562f4a72aaa15abda7be8dfda8435662052e36ce1d1f4fef6c1111650267f682402ef3f9b97737c5af86db8c0c246ac0fc99c43995eb8cb5b4353079463af2a90b865c2041a111916ce0830b195f0a00874912f3b771f39631836bd29057b5ad4dc71ab517c396cad82e9d31d86a691e82afabab71340dfdab0b2677ae437ce823723902a3015b00edd6639b1d36f669c67934554ed04e7beacdb6372fcccea641ca77779ebebdd308ef4c764ab61f71b27caf467fdcadb2d36bee49f103c4df75571b4257c2cea459c15a2bd52f2c2bd7df629ae20c9ab853f25890be9dae831087d2161291cccc48d6bfd4143d19bad2922a20ac0316f29b277dac55017002327b050ba836131257ab0db76aad90d2a17183901b325c6cab9861d6b593aa447dd3ca07ad9e4658af4c51d782308b1f83e892b04c749ecfae959d68f12150cf309f90e8247eaa7234b68025fa40728422af00ce7d27ae78c646ddb0083eff09f72450b0cafac998427f618cd1715ff8c18ce3205cc47652c2c993568a40345f5eb72779b0004fd86eb2c1764525afe3d44d1e5ef3add97eb3ace00e9347afae4cd5f9511c33f807362e6f855098d3aa38bd3d26128dbd8df44bd80fd95ebc643f328a62e1a2f2421642a0c95a7eac4e85ebc41002fa5cfd2f7b40de7aac2c749dc7b65400625748c463add68c337ea116fe396e13ee1ab6ca65108bc8427dc1ee73983942f75538651245b4b6ec931413bb4c13a6bd514943fd65dbd27171183f6aa2127c8449369d30b6f87c8142f7be3fbcf1ead38ddf0c6157b0df3f852c1172663c8de5823db9b351429a6b176687428203e0315bfde28dec6596b15ed03be9c8b32fa4616dc8424a332aa680f9b53a1502df5ddb13bee822c83ae4fcc2f332e1d3a57fd18a5892b6d5b8639bb5f1813560d19240c3b4810faa1d8bcabeae02916d83b83474920a261d51bb09a8b871359647d173a61cecc81336c525edb5dc713e8d37046da3dc58687a93811c13bc4c0ebaedc5868ae89f85b59da4b02d751af3e7986556a75119e41753d10ba14a1116a127c62bb841a668642b763eaf92c03386436e1be91e3d10e6f83106a446e96a338e2ea698738bf6b8b34349e56c0dbd9d4994f4633ba2962f0cafa978140ad480dd24c8a521004c373f3797faeb90e1e9ca4b3e4b5c470a39ceff250c59248714e0d0d6e8381986fce4c510c3008725e6c1e6b04fa9dfcf572e5f1a120721472dc512c74d2ae082a4942fcb8dca9d6b3ee1764a0f3c4c212a8e30260f3d098575b04fae84a67f97e5fe89ea784a0279fe26f784848a2e4212b492bd6e24bd4cd5c14d0cc2a3616202fadbc1622e94bdd5d7c85f9b88c9a0e8ad273f0591c67ed80e626bb1e9135e137a0a49ecf77ff6cd310973c6500ff9bad5b5787b15e49179987fa88f077fd12e32e9c04cc217b587fbec7ec833d02a131e705868ae52eaa64d83aab95dd497c681b0d2c7e502d371e776cb27038fa7b094286daafbadb96429dea74f4d8e8f8e3df30e72dc6120509f172383d77d235c20373565d566be43eb966f8121fe23cfa3824e1ced9bb1091631be68f79f7a0670446479b462817c02eb3c32172d057557dc3172b12dd868099eebafcea2e6e738d213108a4faa0a7c30d39f5e9552e42477fc0704b9314b14cfdfdbfd6854d00c2d4b08cf33c52caea7c264433c68c41c6e80c51911c70e93f9c6d338f50d19965bbbb6e6a37167c0d70f2669d5d2feb413f7245f90ab387378d8bee0dc4a55fcb5760f235d0687b51b9e2a66cdb9a2b76520dadc3b58b101da6092bdefd940ede63791edcdd93bc71e82ba79c579e631e0760cba65f32417d977cd339660b4ad3698cba07bf385b0235fe192739f05167bc26f23b33cb891db00ab20dda7aae49d8eafb080829705033f324db6eeed74e327b98c736e8d91ee9c98ada6c686ac3e406771b287264a3d0e53095b835c723a4dade439d8e51682676ff8860b94499e1407dc1d523e8640b7751b2a0fd376cc50730cdb65551bd5f64dec28f7179538337346787c68e0ee50a240d563758714b06ec483e2486885d943d65ed65292434b69ad965271caf1f97d62380345602075bc3a41419cfebd0d88a681c4342b9b7753a3634fc19d561ec449598621227c032591e40ca818edcc5dfb3aa86450c4416c3c92a20f48bfd1421a9b208f56ca8cf8e58278c6077a3f10ba37413eb63783aaa089b217e755692f1b0d1e6d7bc4455153b60d3e8bb420968181183967b4b942fe0db86b1de6a7c1ac63dc9c4227a5ce1001950b6bd1c65cc8ad1e67e3d664a06bdbcf820e3b473cb09567a9d6f93bd24be0880165ecfbe206fcc5fa3e2affa5b682337a7c16c377e9c65500a7119f621220c68d46d55e57975a25b5ed45184d7c6e1cd95432db77667cf31cc57f6f2600494c1fe51be80184222db904ed2861a59e36fb1ace1ae02c068250ef9f4e51c2c235fb2f94b3b00f7f1802f962578723dcede3ef035980bccb6d38133c7936b2e3eb49ce18c9f2c0965ea153260e59136ab627c154b84c9403d45cc58e882e1cddc92add480a26ce86b8372848c3ac8aaa2e1c320220b52a8eb08eae20ae68aac994e2a88824a5eb791afe1447d443447c15852a16dac0f102f6ec6cc8832924983f4070cd22551e7ebee86646707b7e3b1d7fb08b816a7f77a68d9e28ff43d3264efe0497057676198446de33f15baecce729ccf3cbc77415a5d64af8d3a0dfac6d0c042ec1c811d7ec4e973049dc6a0eb9e0b04c91ad08fc7e0f4c08df76e33986c8da0c7a97eabb891fd996ff3f02e104b5dbdf9b7831c0326b8c48956b200d8b95ea7fb30d3f345a0447c39a3a5db56a664420fbd6e4896346f4888653f7d72e813cf8174b385feb65679c62f0f95d0fd3f88c4601165cc71f47d43f3b801a4ead5876e08903b2f523ac97733e25e5f5e74b757406165397a0045ee3b3eccf8513ad704a08c732c921aa775c7e36c469d20e97947026abd1778493790367dae22b9d70e04cc6ccb76b5faca3e5d6844e0bc50b7c2c910c53cc872cc5c010874379875a83cf0abfc92e2c4a57b644fa0ab02ee43c7e8cc328c8ef1cdc04bba8a29c0ead76d08963d5d089c0dc31aa4968d634f6dc803b7f7ca42fe10656ecbfef6f7f98faf7024a6d5f5049d3d16a97e23f366243806c58119d2b20188d0a9a209512ecde8fb4d6a1cc3b3c12ea4980a19eb3ccb7b53ad52209856cb5ccf01b73e420ec7e213f24e47bd9198f4509f9548ed496250749f49dad347e4043f6dce0b9735826d4a554fc043be7dd4d722b61aa64c7ecb3fca0eb59da5ebec9664b5c3dc4755d2647e4d41aaa9aebe9753804e38b5028096f964fed9a5c86c68c642a3b04a10df45d79cdc1a4641170e84b07d7067b07efd713c11c3c08bf401cb185ac46b4d4f50d69c5426f180f5ea342d7cc38e214d112c21a5b2affcaab8970480308cd3289c468b83a4f5b8ed822e2c2bdadb072aa5e8e3c1f399ca90d1de3f4cd9a00d474ac42e05295c43e51cf4320db89f78a8a59caef7f688d9a20f42d20065d9a19d3db3c9555da4680ae3562a7e2b612b7d7df47d5e447ba40e166d365a9a4b61cadbf99f16c3b75793b43751df1fd5547fe2fe44ee3824e85a54f30d0fc0f0fbaabd656a87a197625e1724737c18017109960a68f042148cf554615361fb46909140dd9ba5e0165279211b909a8d0eae444f9a099751d0cd60cdfe4b604c26a05850d247587165af630eb2688a9bb0e86a23aa7370408c4fe739bae2f1a63ac329eb81d076a8ea3f57c124d6355b44f35a2875cf390cf4f62a8bd1ddc14b825e4bb18a4fa236a949cd991efbd6651885f9b0caccf96c8e504be8cd53c722ab890870816744bd8ba37b25b59503a92ea64c13b296168c9d25de7104601d726e6559e9eb466d1777e1f79945b63eabf6ea511694d22d915b4313b9fdcb34ad9c2d9d5d450fcccbf82d1431bd991f9dfc05cd95d4fd877473e8b5614859ece1d79584ee30ded1e5676c76802679b69fd6cf9c9413feeeec8fff29c5b3dda9972977bd7c096cfc83ea76475790f04a3de4657ae229b7c225facc13ff83a6599aac01e25a8697d487febba0df9bff4339440462996045cff0245aa5c7d69b0dd04af41d0e238f92be64bfb4624970907077d2029330b864ea99315d9811858d58ab58a404bbf5485161a1612bc47e6a0676e451fbd209cfd024146d456f39139b50cb5f7df726be05da8b039bb246307542316fdea80fd80ceea02d0657ce2028021626f9abe05757bc020cd009a7a764ae70e82a917ad45cd24a193cb048c8d14be9445b63b7dd5f2fc084f309d1bd9b19d093e7b09b5cc927894594ab1a683e0d2ff510e7c414e30036c95d308c5a04f88036606ade109e013e48019612b30097e425c282368b5db048b031f201798095b0193f00be24099410b7002fe0638206686e358edf16bec1afd8d4ee3b7f16df4373a8dddc66ee3dfd869f48dbe46af1adb0dfa763665178128689b75b0dde187220af485a14dd085f09939e78cc17a9c3c7e66ce21635a4e93d39722d798395b0f13e3e7c89d330d967372fa9cb863c6d1324f18be47ee9861b60c13e677e2983246cb71d2fc19b8c6ccd162e6e4287d2e73206724d8f2a17f52f89a38c6ccd1629e18fee1e0486e091b4853770f65f1f97be0ce8c9375aa895121d573ef05cd9e76df3799ba14a82dfc5053b97d38009eacdad67af1c8c53e1d92883a5ffad380b420cbf229f56115f427e85bc3d2c87f7d1f293b507bbccd5667587ee23b807c1d60933f0325954c18f2ef11e725acc54a522370da8206f7435630a88d778e2b60aab653263f866d7211eb82031e018b8231098cdc8962bf5d82a539c7ddaf7494f2972a24d1c04eb3012101a0f3043e2959d42764987ee2f5d1e11afa4ed1dece78d48118c83b8991810f822692371e713fe66b6b2912e3e04a4fadeb90544590d3e7d18581f773e1e56f61641acc0573de12d6af6a0d78a59f4037767d25e33606496cdad5a83d215993fc27270dd6d22ba7927499afe0f3aa77af935be6fa7680965757c7cbc57c42cee0ae6c7833cc01d6b72eaaae5180aa3e852b02c973a85c017094b6d0f05bea797a0247fefa4cc50a5dce370471b0d9f6d465b6d002af78089e6aaba1dd5c56279b79c0357350f8a2eee06d2084140c4b1d805eb670f6d3bc43f1e54d8b391898aae102146e2d10e5e1cea833c895fff409fab2b184d9802e5cee2483544d2aa06975b483180a0f4fcb2928ee5ab0c1c775182f8ba15a882bed8c18f54483fac31f9bfd65d67c7d3c56f49194a88e742f9a92bb641c829a6608558975106ddbb6dda87a00ac68a70d12e5e061d2ee0674031d836b29db95eaf35676312dae63eab2f5d48c9ab1840e06969e395d80ab766927e3475ee314249585a80749d980c51c2e0f1d74d63b9e6835859f47ede59bb2c80814173d427d94d84741945cbb4f7d1a2a3bfd01fa4b512d40e1e36dd8c0c05554378ca76f78865f39458902a6f3071bb5fdbe7cd5f86e2511f5b77b2efe85eff72f5f65ac020091516dd31002f052b539222fa2f84127c6ad675d7b505b1621173952d648942805f969d7e4a3f8bd9cdf338b5f42f5f39a80e50345f3dc5504707b78ba7328379374be3c4344101f7b24e78ca78f6002977546776606c0e46db31b84757f95e10959184830e28ce5ab43250401e3b022f7340dda7db83bbd4d4e81456f6f82d1240da1cb35d077cc185d141b1c7ceb204581407cc6a52c813b618a04c7f806caa8df3d09b04a1d1ba57154867fe95318446e12aafb1b0d77cdc0236af234f7724a65454ab80c144f3775c92cc15006975936124b1c7cd40cd6c4ee3013195452dfa1341cb50228cfae44bd87812e15a0e514f5ca09eaef397dbcb84a35220d686f59b634be8810cc306c03170223c95054b99b8f33c1b14b20233cb3df430a868cb390c1ec34d3644fbd6bdfaa555697d7cb5cb24726dee2f5ada3c4da530ee15a693ed31aea1bf3a5e937adcfb1d68ee301ef9e76773c0674bad3d45a00adafc360214523581fecdf8464a40481cb22d541abd2e40b8ef0c6b2c64f2bd60ac3953522a148321ec7ff786a5cbdda9b39a791e09dce1fdcefbc08bd787c5aaaa79ca9602cd6e0f78b959163bef69198ac99e8cd7f9a8db0ac46df5df67960829408e2fd72ab370d786214cd223374d57cddaa898df01f7dcab64767004b9bc907a697cf090f10447c46b41506910d18ba78b4920dc3924dceff96b412bf23688150348a0d51cffd1d413b1aca1f142394e3afcb46b02a8682fdc88b15ac753d5b6f2163a9e5b1c492861478723700fab7aef7f9c3c7859627491a888feef4943067df6c42040a9ba8c93acdbde4bd03921b6278d39fa69e13dad6ecba0b7464c6b70ec34b93451b05f4c4600098e8b600b4681109a2c7340ebed12e62b301a936349fb7dbf7b0e4e7cd1ba284a71797a4dec830c731b37cb65adfc25e8fe8b27221b9debbc7084b026a1d9f53b0cdfa5fbc066d5d2d97311b27c8ae715085a4cd42080cee17c742163be37a9c00495978f9124df0075a2d8d77b3b575c96568a64a454c20c733bdaa3108d771c809e8d4a577d566f6e071f2e68ce086978f01af5eb88f80c990bd1154f98c607d6944bf6ca5984a8f4298491569d55942a62734836f07b17303723ceb98880cd87f3e0a82094cab9e73f7973ce217cff33510839860ea318856af9d58f16ad101c2a22d722e456f77c5b5dd27c5e22230a384496832e095297502587130b11645065f821443d336a74f310b4add2b779c18afe515f513abb14f1aef373d4f20532f612bce97183c56da0fddb77ece6313092d8fa1fc45bed5fdef6f0dd3b68b82024aaf760625dcff38a9a49c8c74d0cf8e1e574ec4e614a12a01905863b599398275b16f12e3d997c5049550196a893bb4a2ec5f5b6eff2bdea83b986d1e7a94145cc256979b5f956bcd9767498fa281c368248c8ec512a762d76aaef4ce388c4527d7c7b7fef2f5ca4de219be1f66189ec17409a0818efec1e3b1dd77c15a05bc63d0031041439487a46bd48e9d05a352734f3ba923d262d0af8a69ba2b4c1cc58055932742516311aba55c8b8196837e8622e1fabcf89002496e234019ed7deb3440a910209f8917e2ed152aaa86ed67618de87795fbfa3cc32e15aef20c1c46cd599cff0b030dabd2daef1df37ad186a75e2ce2addce2ae876876c3c0b823b30515f434243ce88baa3b9b881a669ab4a75630a774227a03a866ecd04f178be1122d2e99b5e00d5e0d343620347ad070e341209ea49d52914ce47111c809b802aacb43b88bfbb9a568211df44629f642ab2401623ba348d3ca60ed8e619005e1b9290b08e04b2ac7213aa7440a30e903847d6eecd39f7580eda3ee9dce0ec220c05fb2c51dd34725acc8ce054226c6426e942f7f53f24efc8b1a4605fb4e6b86cb4d6adcaa8bf53a68512b1814773b77557d8f6f32caa4370198910a00f99e9382967342e214d981edbdd03d83b91513fdf576152a2e7e70500c63f1ee95962dfded85fa3047526fd03398c5abcf3a3e1f02dcee7dd60d1d2d0884dd6631de69037414374dc5667e1180790e46449e10b637610e78e4600cfcfd6c7e1207300b0e1dd01c7a1923269269c866f8b6f075f3d5ac56904516f9ee9c5937a2002e66a0ff7c9c4c18bc9950c9a489974581e781d2779628435592d6f4b6b998259e910b67df459514a19f9445601155232449e94d723a6f9b92ab9d6727430c99c6282bc79944a43f2aa476efabe79332e9baff489d26676a4ef05f07964008361b60cfb10114efd31a910886d93d72ec3605762f722b55f26eb894e91db206d060ee4ea8e9238b974c465cea1c14a6fb06543629ee1165a34ce39bb1ebb617e96d80219105c3d35e3ddd246e2357a1c893e4f660cea2398632d567c28883d2e87d99baba04af7bf04542c24b2058ce767cc05232b48ab9d61eece5868b05533401dc2ec8bd7682de66ab711e89848bad04f56732803b2c3fd76080f299e7224e05b0a9fad8fc250c608b29be452ed8d8b6306556acf9f389a1270836a04413609a1d1ab6e1dd5d9d235057235390fad6faf8e21fa6fa9fabaff3fe86ae8e16ede74fbbaa32f73ad664d9c495ac98eea0e279ae266b9be1be102fd47c6f91570a91938ee7d3b926e76de3f3d7ac2ace80d4cb2d12a735769c2113368f28b44ffce9649faedaa6b98b7469a2fd3b5664608d66d6154ce85e4330bbcf3abf9d513c40d3d9da9801482019abb7fcef4e749ca616b0978a982d3e9c866bc8dd77f93f510422bbf4a5d47502761436d0d6e951822e396c3ea2f8e02b8c2b14d00bbae9f9cfb97c9d4492166458be0e3ca2e31a663b048bafc4cab50015039f67ffc3ebab48fd1ad68fc7106b4f36dd6f69e6b75264fc11c5b0c791de3ce77f9ba2b7239feaf4a87f7afc0bcced94842ff29d82192cf7daf49dcb93c2028b56ca886177fd293591807e18384558ddb900316b04ec3d623754250071fb8b6af2a4d87d18fedfdffb807cd408cc80f380030762e57a05d375b465a73f5fc798c68f54b4e809a4cc519618f7af1a468e126ba73d1a07906addcbfac2296f0d03de079189249d13c7377b9968a38ee2e0a2f6413a0c8df57327b2ba920f7595cafdb8fa79b58ec9a0ab4f5604d95ad1f697ff02e33c5f76e615fe588546fe0645ba6d1af5b6ca803184912f778b0db503c8e9b44ab8f98089b7294ef0ac01a60a4f1187a34fe4262909f561fde3d3ed1e6a5283c15b9964b198444d106e50998092d80a547d492e12f41a0c023fdc80ee111c946dc629081a3cda10a3b1e85c424ad107a4f6dcb99cd9811e6b225721990f41add00ea8b35b85387e09132f7e05e3a0ac49c9362a2a56b63d10f7c511b4c20250e9cde6d876114608e5d05eef5fef43caa203487dc81f6b805f97c80a0569e57b159e399600614a1ecb84c013930e49a7f4a9294f5c0b51e682cdb43676ce46f299b344ff2a8ec0b8dea68df35a3b10d5a5498a561a9f73f8679c7ad9fbf213321144d11ce971fdb9001581a8274a7003bb88259a7079903779b33dfc77dd5e2c4e247448261498158c4a6e2cb858a29cffdf2449b5f66584447d9a0381680f490accacac57bcf6c0ea0815357ef47bf7427a59d0de069675a8c7772d4ca9b6f6489b1efec5849c33ab7fc125cb50656e7ebecf740ba9ce542581c42a27bb853517d283e0160e445096a44577905f4b75056f4f86ee24e71e7a26fcd67309053f7a27cfd25d5e25cb7e152b2593e52db08390b96e867ab683cb6bdd64de1fe0f3d226486d5260e21c98a3c1fdecc460aa4589c9c7e2fe5c773c307d0a126c0ac11a4eb59e36214f7d9cf588b5da94fb963e3ac5e1690bfb9e794fa207e2a37bb1c92da3e0c611e02c73c9800c8abb6e3e96e9914e449d4ef6a1f531cb9c04b8bb0254dc6b99b33726e85d243dbe6afe96bddbb7364db8f90ddc2c55c56b7a8787cec8f99c2fb3016637cce6cd02d4c8edc45dab90e92470757516ab626ba967a81fd753c543e85630b70d7af61653abef4c880877201e7686d60c24773bc15c9a8fd5b4a2539bf3570ed1794069d31a044eaf39408a99bed0502aa6de4356809527399936eb60edc68b1be4921f5bbbd45c5ed17540886310de573e9024bcd290724386bf95602391dbf5c2a3b3c232d9d38a67422c80dd2a46f04b2baacd4b89c52986a90a5bb3a5e41740331f57e28f4acf81b60769c1e4302319c427dd1856f10704a8457ea09a50d7dad41ea1b7cbfbd428f3c7c2baffe07804800bcf8aa33785bcc42c8c910bb16217f466c237eeb8c9650d606240dd641329c2c4a641807a5cf4af5c070b261e4e3b3db17af687e2f946db01cef665837df1cb5ae982815b0e072ccc5eb6ea4820a553460be7344177a439c41d4eff30d84d8c69b360cf1dcc3c571b4b37b685ad6af7e7f30a7cdd4bedbac884bbd3b2d6eb4dc4d68779abbd387eba064596bba0c1765171b336d0e6c69a4be90223d0bb6f287b517b76b7e1ab65690b6e9cb6c2a71722ee3be095a78b3d4187e205c97e13b2f9212549ad7ff06a72ff5d0c7755feefe737097489ec6006b38a3414c8a8993f9f10bf5a5a0e9904edfc24584a06992e6de2c6738370cce0ee463df57aa4b77a59aff5ac9ed54fe137e5c6bd996ee8e6546481d5baf16fce1b74e3bdb6f7ee656f0aba21de6b1c017d88b85367f14f656a5b0bffda996dd180b98fd1d16854290a47847a04939bc1f9f6081828da7351104faf120eb2338274de14f873d7a7a969857b31957f1e323c82184b50b6abafc0b446889e2712db8579f42dbc752eec51e7a1bec5de6a4b7a27f678dceb3128d7b4a897e49e75b84352cf4e3d9374aba3be893def7c9f20fddde25ec7a05edd92f6b385b3eee562c585c2df2cdf2f41fed0d2abe7c2e2fab2e297e15907cbc50aa3f4e3d27d89c21f593eae1bf0acf657c5ab7a710dc14a736771e5cdaf90c060a5ce37dc5c518c66dec5952957538a577ba599cfd2cc4bb43206654af16aacd442b19a798b2bb9a8a614efed95373ea3999768259a942dc5bbb1727b60cd0e45375756db89b7f24a54fcbff2e8e8028d9f433f905edb8b0363fd5fffb90dddfe47466656dcf036f171a95ec15a377913e0e325eb8a5517b4dfeb54330b3c9e039aa3aa855b3052aa9a74ea14ae59b46ba470d6de23dbb6e9045638eb56919daa4b16edde55cadd2669b5a2c429a0621a8c1a841fc2100400529608e28a8c5c5e1ea20781e27fafd7eef55e12c6bc4fe8b1caae37b3b6d612a2d636217b6fb977e508e4071a08d3d5c93063a6f70428304134ade323c3ab90c4aa726154ac90fd26ee31c4ca02051e68c07c56a746a353a650a1d2f05a5792fd581347f922b613726c3134193e653493647590c28e0c9f2309f6abadec35b9d845c49f179b712d57aab7c34b21c37755ccc8d0c464f8ed03351226c3a334f003a10e0a199e7b7951c67824938ee24ffc9155bef803039213421d9ce10f6764bf0afbf1726e86af49d8afaa60049d3c8112447342863745f9a123c3bbd6b0e172d4ab65b75981ab11486402f6e8d33bd12cdbddc0cad938f1c795e1332e70b82a71e28fd59125fe1870f3848f8ee943391ec77aa932f48c92c68606f6822a00e00a226fb644596baae596ba6a3031352bc4d4acd082878367430cac5981082d980183e3f52b9b34934930482f47469c0d334a22986143110e36dc60030c830866942237ff2cacd79ea4b36389b2560abb59aa5a666a1f1d4c6c73de4c2980f6726d75777777b79431a3b3bb71f79d73c6ee8ec51e514a306c7c3f4208514db8bdadd37bbc72856d430c55518ecfa109413e44987ca802473ccaf111c9a7a5813a56ee5e72779883dcbdeb7e1022773f80e1451047b0c1858f4f8cdb5879dba8e46dbb0d236f3ea4206f3e4d70d00417b090b5c336d0c828ed912965824fa64cb041a66d84e00a0ebc9a1fb478811442190abde4243cc9f2564a964b4862038d2ce5490a1940b104a38d04d5b26125890c18174c36583093e784a922724ae8000e9450865d2204f2473a401cea92e59328813ab03f293e225ff211952f0db046fe88c421007cc93560f2d540470d24a5b5ad96ecb70e2c0cac819747f2104e2c7b0b14d8efc740a687e99b4803b38940e4696d8f1e666eb6daa3ad4ce7040206eac82f85dcba17038170b1c7bc95f1e6c09a590f03759460a58c929bff4e799e7042ab65ed5773e2ec0e869929868135b1f4ec26f172b64d579c2c5cd77ca90d3b7f8900b9d820cc566126550b2c0e7d13719ba065467b1ece0c4f3ce95c99613fd86bb5b6d592b03c3529365894bf24b0cab550a7b521ad8a7603ad8a5625571f6d48aba255f1628311484720df92675865fed9dbfb0f8349b0b6d24674a8854025a5437428d3a436a24374482bc106fb86cea6d995f436195ac928d7734a49a59452ca7e46339a6536349b369d4d2af31349da858c8c12d205ec66dfd992ba9c4497a3f6baeb4f292b97cd3eec322a3749adc8ee6e39a7fcbc72ba9e645795bcd3f2ba1c7541a6eb8926a59cb3bd98156d104688124883d50f5e6dfd633769ab924e94ecd47c581626d8278cd504ec8985524694230e803a992764e8c29ae8cd63aa0242424242a236dc0013e20398902a3f5202a56f909090909022ac616541ac0c3c071c5720f08aa214a1a13caf0cb1c168a9a252b56aba9d97e23830fd8a515830b231a2318ab245571e08a2427a91e50d07884068769a8e3d22cd545f1401348f4304d234d3b2c841ab2a14d4920cbc52d5aa66da81fda051a402eacca01ca240b1816ed92dbb65b76c198dae1a72c2e0c0e0ab6f61366258179113904498bf885d432ebd7bde943833d6dd46466b7777d3ae5bb7d464679dcdaa6514d367df289d31993541d5ea49fcd25efc8095313c0476ce395bad5ae984dddcc056fbe6dd314653de24d7a5bc4d4e526ec21a9ae54de3b2ca69336f25aecabc99b8d2c699386eeb60e84f53a96ea7086be067d10661a6076b20aedac4301bcdfe699aa6497a654728259bb3c8890decc0892644232072e287a8893432972191134300b52a154750031809694058102106900d8608030968074700418a15238080046486116140e9170c324018525a5fb4b42108815404243c1a08f10321bc60d2da322412628bb90358cb22592003322db0801416f0895181dd32240a228d9717b6cb902888a3208c0e932bb89665190f8ca094d23190fa05c748aa3efd823ffd82325158ae06444dc0c0082b55e4cb5b020bae341124234413506cab89272e2840c05a9adc618433a0384a810704bbca70e88c19c83439a307af32ce08e3c76e190e9d518433d238425249ea17f4f9017232001b3ca12f1f9200449524606087164970923d20609905329a65b406233489126589295714418a200769e4e00a1499cd3ab0840c5c800552e4600b1870f144e3828b2856605944404de45386444045e4cf7e8600a21184d08f1292f82162090330f1092288688827800c1044510928853434308411c4f8c072190ea521254a1a53764c61b30c87d2c8c11a6914e5c0b41ae3bd980426d7971a6918e1215c202221a55f5068a84a919101c038a23979280d339a20c1450f9080381a52034a9e191201c144fe9e63d6c46b85268d6a9a0788d08630541a011199107caa0a8aa05682b42b8698568a321a1021855045be604dd2c18f5012183f0308824f52108418c0109eb4981cb1321c4ae3072220903a0ed4564ece6896d11d32b02c19121921450b234600c508275e51ac29432223909899c2d60c898c18228527b6942191113e438a48aa7d038980e0402bc321352c906986444c9068b083ec8b21542a08c328096900d10408d90b8260d37082524a29f5a10645449c0f42d0807641240411911055e45586444240c9c0061be76bd958637422e67863582d43a21f1f3c614b39466984221aa29f2d887e84b2cd90e82708099d26c020065460618231b6b002762101318020c6154a88220650aae813642ea0598d28d410418449b135c321353a60a5e529cc73d639e9a42d3bc3f0cacf4b7b764398bb7be291a452ca86f204310a6a6db568b4c9df12aa840f980fa9048da22961e3db4a53ebc369b610c6186b8510c28cd65a82b07ea74bf7eb2157ac69a734f6a8a7771a654a9f4d082b841aaeb7f488187494db89510c3a3a12231e5589c10e9c32d4ca964a14231e9dec91ccc596b5167f47e8e930ebd262eded6157e4845b495aadc3c0e9dd5bdd3bddfe74b256d5a24552743b9db6abeec7ad4edf4eaadbedf6ba52e75028570a0f3992ed37fc1dc991db56aa956d657bc2495a79d5b276b3276b397bb2f69e77ef301175d90531ad5e254e8bea36a53aac3dfad445fd645d4e27a96ab5be242d7b249fbe42a14ef4747a94cac4fae9aeceba4356ad2399a6ae32e1242d4a8f504a69abd59242c3913c7f4f4669e960043a20410ebe324116ade4562283f84bc2e5c943f6194f5e6997b48361e2af475e6d6e938bf2ae3e6f5744c5624d6b97b4ecbcfac7d2e4ed3798b5c7169c211e8b1aebdca7655d6a3bcad5e567afaaf638777ade263a224a86441e18ca5ff421f2405046d939ef1019a1c6d98b8a1135c48b11e3af872c53af29db4b7872fd112526539b5a08cc8d75e0c94b622e9d967209efe4d4c07ef028d325ddf23e7d9276a1e5f44794f0b0b9b0d8b05fcd137a347449cb9123fb459fe8d2e28297b476a54a9c167c8408fb4558e4431bdb108158ad830748d954aaa1d6fa392b2cbd5edbd0b0255c85fd603089e3daaee5489caae10a68e7b473d8b51d265fa68a2319b0c6749369337da7ab15ebe1b767fae5c242261cd668d8e9d4116ce9dbe72b761160bedeb56123f334ccbb4c97788a02c0189379790ee7c897e93058637a16b604435ac24876d305c2f4cd74984dcf3293e9f14a1384d2643242c34ddba0098394601f83ba54a511cf8305b5621739d6b05f0705b9b8b05f0cb22252d12e98b029c3a69214b2aec0d22089bf28f412d4d2500029cd32186986a70eb209547b2624871cd8c6a15a39270b8311c2881f10a3917cc9d2e3c53da55f42edc94fb902cba47fe44b66b87ddab30200f892bf425a6e47ca1848338c0e2437f87a81a82fc5580f733d84b53edeac529afd19968f6cd8cf47218993235ff252ca8db2b0618d5a48ee0c657767a8a83d9823cb1af68b463627e7cb89460be897bcec97b4f25808b6d7b0972b38326219adc07eb625676715daa8264cc861613f2e77e9f51c9c0a308a9beab36f56577d536587dc94df917d6b3abdda7b755557a6306c0f6733645f222f12ed11ef40b3499b37562b1c93a53a0baa57f2f3f26ed9252b6a3ad4bcc34b86404fd62e85c0ace1782a6fbab2934175d3a5c49bfdbc29752d85e54d513b2755df698be52546a2ba09236149bc446615ebf5dd11c95818ce4b16d4ea73b58a744523356997a7ab29f134e16fd219e349c618a3f693fcbc277b59f1d7d3b7f6a68baacd5a5d1586556ada94f3b0a39485e55feaf5a6b7ee57b36bda670c167f3d64fb1bf47e4a3255f19055acc3c669b1f0973afdeaadab24abf08704667b61961d0c31b3e01d2646328964d7aeb14e57afa7f67e3c6493bce9daab6eaa3e753b6b37c99bba260cafd99fbe25d2528c7a4569d9e3915ccfdd8f875c67d681874c7db2e9d9e9ac37ddd2dd81568c645ec21bbd7a02deb8c2de6897da391b141081c01ca3ea281c2916d1135572e9b36bd7ab7a765195e5d46ae138b1a42a4b6618c95ccd194a574d24594eaedf2267fa2667e3c0588643eb829c2e0fbb19703cdedc48bd85e5b55e53ffc63c0ed527fe9278a8cf241eea15856754c9d093f56c62d7eaf328d5b3ba425d7595eaa2eab74e6567611b346c868ba48ec2486ebc9378291c6f1029ddc02d38585866df49eb1b3559e6e3a90b72fa9ca8393f3360513f1d09d667f774d6955d90d33728a5f4b2d56a7559575d5befa26ae16869c1d1ab54b7565917ee7476d865a5a350cf6cc8cdc27acbadc471b93cb1d81676d9e17ea96f6f8c2423523a0a6543669d85bf245e5f55cd70afaeaa73bd5f0a73a89f90d4a3bad6faac7ad945827ae7c6daed4e579851f7f452a705d990b598a9e6d26737a41a3520a7744bae971cf339ee4b75f984e4093d221460828a10a0e4d96f400e8e6ef96122216501e3d1e4c05e2cab8f40caf4ce6d6b1df6e7e4e453a491461a69a43021763ba158261c2d2d2d1c374c2cac154a754ae570ddd01423aba5595690f59de6b8b3dc387545b673f61c8d34d24823a5f6f4598e7e3b6d1cc77d5ea69c7d8a3e753f2179bbbd9f907cb2dc763f7a14b641c352ccb19c4b92f3519c2427af72b8961ba7e75a386e64f6593764ce701a2267e04ef614638ca79310976ef58d863de72454876c9556d1234eddbea45870b4b80ea5cb057fb505e3b8815930cbf330ea2f3939a7d3e92424c7c60606a3a1f13c1898974c5329fcb5562f2f17b645a55eae4afd2585ba769b3a9d8464d555f84b92934f9fa7f77e51084d5d6b734e54488ea739a79c534ea6393d14010911410e0c511221c892e505dd7769d71064e8eeb6e96e9a39a5940d9bedcdf92d838778d2b477f9c93cbbbba59415ce43082184b0b1b0f15edf05c3cc9d638edddd52ca150864a073ce49e3e1acad496e42fc13b249a79c3383c910692279341952da40e69473ce09e19c734ee9cd39672c452a71b43e73ce6932ad86a8539bb46693d60c0b4d8cacd6ac0d3a6bd6c69c342b514a33adce4cab6d64339b5ae50e4b39d59229a514cf9969b50d9ad579941dd92c7bbc966571ceda4696c11e95873933b9711c47b336b6d66446a306bd5a67d775259ab55192198d1995117758946a7d9c8f5aa4996cc3e462b29964367358b0df4c6c3dda68464a6fd9c41efdee121482d58ce4c4d2cc5a3768d846ce49b312a534d36a96d1c09bec309842f7ade3b49c1cac65da2cc5eea62cd8a314a7a6695d106d562a618fd852cbb21964ce88c879ad0b5232c98de3b8ada78cad96a6698f734ec945d3a4997c74c969c51efdd3a90b92fd3425ee6460e3b78823ac291d962e21ac29cd5caa9ac45940df007bf47510d0b2a1c8b4997c5c6c6cd94b86bff0a646afff132b371b6736246a398116db0c7e3a289c0c32ece0940c5b9e6d6db0f863b9521619ce3bb3ec5ad66d935ca9656545412c323c4b140875e0155d90599a32058532540520c3774d562e4c6929b2df64e9b490210bbc01c4494b0cfb554d27c7aaed08800c9fc30cfbd5b354605d707060c07593e1cb0a554c3fc86153e558c0bef999f4c7cca6f853653287f98e0bbb212fece1af872cf3ff5b22730a7fcc85d94b017f3d5906c73ce6dec3dc2f49fe51b81f0ff99f401267c624fe4e6f18dfcb7b7859f2c539173604fb4da01374c49e03c809bdaec7ae4b629a14a357fad52f2161a7933b86cdfe4da01a76dec265574300ee32e2c2f333e6891828238a50cc85f7c476e4cb85b9850b63aedb933f28d4ba9f975db838e251cb40c3e2a359dd8fa5fab4271348ca513cfab8fcc5a389c50368fe68527f60ca03a894dffa7ad2480b6d5c402816007c172e8cb57061acb5b0df4b3e19a2d003d703a45f58e2b90f757ae4fcfd55582925cc95dc3832347d03899c90c102bcf92a111368e43e0b5e041998729321511257f2869af09008102726c199675c02c4c185fd9a8ceda6331d8d3c3d2aed75dffee263589c21911256e4cdf428c4952ec5e50a4bcf4deed18af6e6e9277b6dd0b0d9b9974ea58e08fd40760de17014eac9aaabcd60061f108aad2e8cd13c69c8d917d608eaf4c82854de2e045ff35ba954aa37a7944da1de57ec65b5e74a61183aa7acf4913f4aacf0a489932c63f3a97b031068dc1b7ca4dc1b7cac189aae2954faa6bbe89b2c0bdbbdd59948891f64d8d1c0e43a3460fbaa734176dee83edf4e248eca9a7092770343c982f1178b2e5ff47da13cb5d0679b08590e91e74e9f2ebbec27eec6a1f66646e9bbcacc0a2091124ff2cc3f4646454748502091123e793e5e699c199b2c325857a816167633c8dc425c5724fa904df1ca7663924b8cafbf7081f5fa2f096c521c457fd13730cf2efa665af1a34a1256a41c8a55da9b309b88058c859cf626dea13312fbeef371a86fece72395be41f53773f7ee1bdc9a333d93c25dee54a8bd69cf5dfb93b53826a16ebcd2836c833a3023319dfbec21cfdce1ac339dbe9ba1c3a58b8496cec52f2ea1444edd3324f45c9472b3675be4b8c89db647a510d93e01a3bc3d0bb97604b0c66422c385c0a13cdfa44a864419a0424786444d8272ed23230b54f90132f1404a224a1bcdd9423e453f5434d013560bf58d8b0623edcd33c9f3f0eb22f2bc227f2ff98b4938cc17cd204b398b57fac5a47f7a3b71d95dd4549a79bead50c9f33d7718f9f8f8f8008990b022e94a9e9ffcc9f3891a59e44f2a416f2a6531a96fbe5894e75d70664279beae31b90d76a54b848abec97a32ddaced8264575dd9d1771d91e893296e9f7825265161a54fdf449f3c332b4d46dfc8f94eea9b2c0679beaf40ae0b925123f8ea8250a23272868d1660cac1a8e298c48124141fa9c2da2e86ce3ac4256425b0665e754b5ff0f0d0de844935f47970a804c10ba1580f2a2d84388a4d91447b16a970451f1f2aa21441e30fa7ba5b1a484231d8d1eff4eac258a4a26f287629311b294f3aa393f6e6a3933cfb531e8711c2f089b5d1eb0914d4c9269d51e66b03e3d1c06ce8945067c6676159edc5576d6641676c1b9d53ceee081f4307598cd0dded75c37477b794db0fdb766d64f2e7f23e578d5b6c9b9492b694b3bb2184d0e64e09d31ebc9452ce9b29e74d7777378b1933c6d8ddd9c60454d671db35a5a8a9b4954cdbc695b614544d2ab1a026163060177a3108c8b22cbb1a8dc0d4b030418ffef480d2cd4c3b64f938e98dd09b593725b69c34d36ac984ca3a6ecbc1d40d39caa6a8a9b4954cdbc699784add90996ab5d412947153c1958eb449b5504a0f4367162fa66cd8700ef98a93cd9291c5524bd544e965e9565abb212518fb5431a52c5a76ba32bdeede012b7f704a6b0651b4a1812a489841132bb17eeddb1f7253a2223090e5a7a4d99338ad28899092270df294b80cfbb5e2df3712a7c2e25b0bdb928d484404144ae1b4b48b4c7f8fa8064e64d99c19064174812c88886022cf4b0ba02053fa6eb528a5525079decce844885ad9204c865289f8eef21b0a36b0dde3eb86c21636c3b300e35ea49cf234f9949d7e3a9d8ef4cd119a4ef58f85b3faaabbb0bdee50da0c7f47724881adffea4dff2250ed2b9111488c3f59266529e31131b4296fb0a87d72761c72b0a1872f720f4639fb7a28ca59b7d3ed451fedddd50195d39d7d3be12fbba6e57acd27d767328ad4eb5d40e3a4b425fd2acd9c83c499b1aaa484848d4eee18361e0730723f8d1f2107e1d45bd256354dabb5d67af85a6bad75d62adf46d0d7d80a81e54037c9357badf3d5f45a7acd6a56b39a55ad6ab5e5663a91984b47b0116eb29eca6aba34d55a6bbdec82546bbaa9be845bedd563262c4ccdc0d0b22c05b046fb27a59c00f6d00e1b6a34b0466b6523ed69dfe917d92f067511500766ed3d05d499d71ead0415c52fa25133c9da95aca19135326ab536d33ad6ab430c30974e24e61aa98841b046bbe90856e62f0611a9efbeae7e4fee21f55ddf93af4bf3b2a6bd6a1046c3483a886eb141984f46d3112c15ed49813a11eab4f27c4ba9711e28fe54b15f0775901179be89140ee4393b0479ce22604d0e1bd8f8af6310ac99e768e267add606750e1227fecc39e747137fe6eb5733fc593a23eea22b869d8f41918ac681735a213527991af66bb5e47560fb72f6105bced6b8cb69ca696fe65285cdcc46515f7e1ac9043ca49f33c2181ff19c734a29613361d30eafd596f059649b854b1a47083d7d292332893fdae96dc0a16ff2b6c939bb66edb65cd23b3932c86e4913994c91357cdf896ac27e1d254e429327a641c80de050922349bcf6280d0f4f90c6dfe4c951f69671a5ef745f54910cc7d64aaf9f37498b7cf759fa2cdadd8dbf1b3fd21569ccca6296eab3342e229f1599d73eb34f9361f5794de2c8c5db1fcf0ca8f75177a1f010ab952c863cb95fe5b56f99bc0adba061255ed2a60c23493deb159e384bb57cd62d9bd5b1e3e4ba23ab2fb9ee2c4efcc943daada4edbb7fa4af927e92f6e83b3db26b181b84b19fcc9f39334a5bbe4f46c8cb1b833cfdb431c3fe30899bd5b2b5c4818e4a803929aab0cedbb9ca93ce3927b637d0c70b0ff207f3923f1a14963841a66f7d8c4c899cb8608923583c60bf7a030d00654a89342094e9bb05b1408a52831f2b404145d91414f06056cbe5d01c019b1865589eb9c670c6457c10d30ea14f64d84e296c1499cfcf1623955fcd0da5644d395bc258fb2666b03dd93489ad5619bbb9da77e609a314aadf44ba34e37433510961686c5e28945f6cf4924a29a59cb2b1946163d19523c8404198ad8b36f1944a7db04e75ab92f1b46948d8fa79170cac2aa652e7696197a7700bf3a45218d2ae95da5c6e4fac757b622e41628ed7aab575f26a0efc822d8cb52e8c9d7e52dd0f16a9345cbd7e49a011068a98f205ebdc65bdf6cde95bbc2c1dfe7aa06caad4bd9cfa25cedf72ed0ac75d375c5c386e6017015a7f790d2ecf812bd07297bfe00a4c61a4e52eaf80ebade85dbe4e77b956be4e6fb956be526fddd6679363927853a943a39cc22cf5f67eb08b7c8268a4bed35beaaa3ebb20aa14fe6656d9afaeebf4d5a395eb3adde52f6f5dd7e9ade7b8ebba4e775dc75baeeb8461e051866df9098f462f9f393e1fab481c1d9fad4f97d5a7eab3e5fafc093a72bcdc54aae59eee725bf7e3c9dde95d27bb225a0ad7f6ba4fd995ce42dde20f1a65fb6d83028bf2e9f5d6bbbc27d6faea56e2b854980626aeb7bc75971b69a9cee3c2aeee3d312117ccd3825ddd7c4f2c5691afd9c29607106c8ebffc84f3205ff3e799c288cb5d7739cf144674bc75285f2d98670a232d3f01f3b4dc8579a630e27a0be639825d304f118f10f99ad7818f84fec12328a70bb6f2650f632d2acde578e9c9b09c041659d4d5eae95b6cb53cde8a0c893cf0247f3143220f00e59e58cbbcebb6bcf59e584fcce5f6c4b6e65cb727d6727b622e37c65a2db885e3c9f4ee96be23bfea1a1291588dc3044c78518426a18c13e209e50d7cae0fd7cac9adcbe43241800f251f175a38fc76f9eac462219cbc850b633344171197eb30bb9eb9767cde35249b3962279c4a29a594524a4c23941c3972e4b8cc711d394eaf0e281ddf6989c216f69b4a344eec32c05c73d8ed38cd611784c7bb570c8cca9c1e7917c9eb3043188cb91f4da6df646ee797fb45a21f2b59c7656afa08befab5f6511fa150a878b4d91c7641fe83dbd1d65a9965be513222520c71f3ae87e311ac690e8af63428da13584393b2271914f40ad499aad3a45bbb6dcf41c57eda2aa35264bd7bf8f3be09e4e32426665d0c32cb7ca35b0e1bd8d3e351f7f2ed41b01f4d0282afbecd5b2d2929a4d0accbdc06aa3505e1514ac66ea35c03f50d8c3906b79356a2bd0934a5f44d6645df08411deffd7905d489691c9f4050a7f51f38fe1d078e7f15c7eb61c4a142f2d527cfe5e3f92ddc85ebf2811f50c3ce33761969c1c7835c88cb078e22860be02f3cbf2796b1eb0139a74236f807feeab1900bc3bdab09c19a7eccd5ae006279e1c2f018ee0b177235ef76197605e8580c587bf2c2d5a0c070352903fbd52a4faa6d5581817d92dbc763de9f494420548dd803ea7c22017500a09d51b54308849e71d8d5b07397911682e0d9c27b62d06524ff85bf8079048067c62ecf054304c0231b30108a452658098af5c4a6d88f266dde8579fb71e58f1f3e6e43711bca1be7eb5a46284ffda4f336b95f16eee30279ccd5b97763a645126702c9d71911084da26a4420da13ed45b4e88cdcdf00c0c2ed27b0a60fe43614edf575f2044aea6b4f2290ee40ecd11a4d6a0ec09a06c085f9476fa081daeb9e026b1abbbce7bb30f3a556f40afd88a9942dec179de0098499b03782e0a4f0afa270085bf986cbbf13f28df714a813f3be975957e15f0bb30efb887cf559ef22fac6c7bdb7cdfb50e7c76ffed9dc7d857f35775d8f7f9d4f873918763504e02e1862f69ecfb34d198a65ecc289793e0f2c0c1c14c5f25d784fcce64ed81eec5bbe3cf18735520014eba19e119be2df7e7d7c8b3f5a602294f3a54b10e113f37161daa38771fda211c80d5e017f35f7c03117079c041c913834fda277a187c1f4f42908d15f8c8f54c05fabf56da3dc0b7f31bfa4e7c93cc7635744c765300c33af8bc47bcc3bb286e63cbcdb93775c9867ee47e3c275d510801674f02314e371e13db06640149b42e29c980b329f919efcc743963bbc1999dfefb4f43c997fe6c2bce3fe97b95f4fbebfdf2287a5bc0f791e314efa464a1e972a7c02f9b8845d7eda5ce2efc72790c4d389777aefe27bcf3b4cde07cde58ecbd3ae08bd5764e63318c21a19f997779a5f7632d47ce6927aafe3d79534a7f7bcd72576edb8bccce975edf8cce90e3c44e6339f91c1de77a4773f99a3e0d57ca729cdf13d8ca4e6331809ecde775ae62e91d9bbbc5f0d7ec1fe7747e4de7bec86c03054012f91d9c7e93dfcd97c3ff01299799cfae0c1437a7f7d7b5def255f3352e6de5f3ce469cca5f45e9799c11f95afe9c48977893f27f2530999c71c097aa737862686493e8f6fb18361067f3d7966077ee11d352c9acfdc14bcef348ffbd5fc7afdf5172eec155ecf778a9ac3ae480d7efd15f37b1849cc656264be2369ee4e7ba7a7f9eb13eaecf8ebf599d35cd8deccebf51e3dfef1f83ff31d77c29a99d7ef7d7b5d24b07b19995318fe7ac8b0abf099fbd93c739afb29c934df71d83731f7b1037f4bf28ebf5e7321ac79e18f27bf7ce04f490c0ff975d8373f6e73087562eec3067f3ce41daff98f0bdbabc19f92fcf2813f9ebc037f3c4ef39ac75c086b6af0b724bff0c7e333df9134f757a1e630c37ae01d62e621e36124f432f732f432ff8efbc55c739afbf19067bccf5c9ad7dc1d34f7df71fb93b907bb22afcfdcbb1f0fd9fbeb4258e37de6e55d99ef38cc01a13ba8846d979435eb149140000000000315000020100a064462a140249808bbae7614000e7a9c466a509c0bc44112c328ca20640c308410020800c6001821a21901b02068fa44c7b603af965f4e0776b3e92439e6ee0df3f9043d0ba2916888a315e6157695466e2f4a16c7177c6a1cc7c508d3950d20e02481be892c2660f0d4ef419fdcc044cbfececdc2511a38f95a2efe2825a2e2ed5e42266650b9a123184c883a5985dc84eabce2305f065d9498a27bbbecd7322f50b349a2c92f2e591998dae67ebbb9fb5a98498346369818f17daa06af4ea3b9e2e3ee3d1b2f9240adec3664146f8bd6d5695ba63485d14ca530f552cb4c6fd15505d5be01c3bc03cfcb9d94e9788e729dc460dc8fa174560f28a237f4f44b96f716055e376589a1544f00059fc8abca1c349aba8ee5ec02610197c6f217aa1735a350b00aaec080e719a366ddabdaa7ae547d03a1419b5dbbe2c0c01dbe09070e1549ecf5f3cb5f819cfee76ae6d199e2757e38286671c5e0f6022810b3f32a86e6c3fc6a4e144ec95162ec4bb6bf2f85ef10518b454c17488d565d4221ff5f65c52cacfc016970e7b3140ee3e25f4865c7613e5397cdeb5c4db0ada37f9bc309934cb518f52ed3ff0146e557ae35776bd7e3deb7018a63c34eb7b4c1ac7d263d249e85fd60c762948d33bbcb8ce8946607312a51685b29f83b344c73b300da18ef91478956b4fd6377205d8c0a72dfca52cdc7fe47a5e80415542a9c802c4f94d679a9716dc78ae3f102c1653b2adea0e183061f3752ed685a1d88e2bc25dcdd565f0f2a1b81964c5adaeb4266dbe492c2269614ed8c80b0fae7642654bd006fefae302f749c2c96a2d873b9cc1786fc2e482c6326fd0c2e36e18618dda6b4aca0597a408a3f78815d2e9a00590a481de70484cb6f8d6ba4d0023d6b0c22a14d5876ee92f73c7b703c28d6ba62c4a9beeee1ec4a3e06d529de1c31e19c342dd879ccda2ff965a389b5c5ca79d834cb5fff56df25967095f1ff54a70d53b8983f5dd55de7cadaa146e8916d286eb4833f1d1a123bf24e39e5db4936262573fc28fad5369a46bc26dec02a0621ee02b1e13f7fa5896ecf3609c4c8ca5fa93695324f7e2d138916cf3f7d57d070ff0a99d71ada9e80ac8b9cb366cc399dbf0b8ceab1f55c7befb385a686eec46363e992967f1ea8416963410bf4f09ca5601112f1a0fa208e779d3f869a4493b048be70835bd1f6d6480cdbf0f75a27dfd58dc3f32ada23a9bd1c5b1ef15fa442cf400bedf203dd468bcb41c911a33837d941f71a418a2a96d3daa7e235fd29e71ed169f77381e86b1b2a5cd05fdc0896966360e1c621ea85e291ed2810410e98916b25f054327e2d7a5ed50d5fe8f5f3b5a93e52d6a6ae004b79c272918756ecef181daeb60355d748f975a7bad227bcb252f700e5cfaf9ecdb6d44b17144c155e2ef25f6eefd6fa166ab5fbec9900b17b4a9ac4313f0ef70c1dbe26a7469db161806c76f41e4f67550a101151da22ceac33fdfacc80fa9db3da808ad6479a05af102851e1e1b840c572ebee8f06eae4a6fc0eb4ac65f7c93144d98fec669b216d1b140b1f974ab36eac82fd0e1247b03bf2492b7237e6b7412b64f566d79c3ea4ddcd0e41013ee3a51d10af92f9a2771245d1d39a4c4a1b8858dbd38402f77427f1fdaeec5575d6dd6c5fca8f9a092f760863dd6e2b4af47e5f8e6050396de8972cd01d24d2bf9aaf82f4b1f9b9df5f217a21f4a22244b7f4f0745a3d5250e36ba70c5a592832e39960c15793debebce9dbd577826d60755aad603239865e8e4cf58851cc09ba5c8e6a2581ae77dfc27739f94d0cefd8e5c96bc4e10c3b253c4881138c0f4baf9f441e5c16a46130a90125618ecbb923494a6c27ad25e0d7c683706c3b9fb186370fb4c813e580ab3da85243d3b67d57b34da8f1b473b214806209dd225ecb78840b1c15cc7bffc78cdaaa108af8ed90e48e9fd1c7e6184bd1d328bc8153ca03bdbf3c2de2c50b60b5d06ec36080295bdf9c1c01fba71ffc84c06f67102f109780e0aa37f88b7c4e105db150b328c4fb0daaad6fad8368cc0b38a96dec46ec059bafcf0c56faf5d683a41226754a5ea094c6e05dd889b59bbd0a39aa8f870af1af6c19575a83f98d013097e00f1dd8c1745a6588e4b5c8fe8cda2b5d1e092a7923c62308bb7b14e8c8de31908216d89caf7a5524a030100143944549212aef0b9a0dfbbd7503f78003bde88f82d2ab8b55c555989d7efbf6b3ffbeeb98e8cb23644c0b5b9bcd2baddf06f1798d07b484cc6a6ea7f38099f162393b6867c91dc844cf7ab68e200dda96fa22b835aee20a135a349fc91522e4939b0a2248fff9b982f7720d0c4a1ba5a004eafa3c4f48776cb6027ad64715d879259c02660d2cc768cc4157d78e33a7c460b270cc8e5f372459b094dd6f9e36dd99101d1a3ad0370806813ea517d860dbd89995a2ef3aabafcaebcb0b56e293ced9d4aeddeec9d84856c52779acc58e39ee0d223debf7141e440ea059713e20bccb8e292bc0f0b51252ec61ca8663581f1280f81c245ec1cc7977418b4216fc57e90596fd21f8ea9c76d72921bf110a570a7d5aeeca8678de1425c72a6fefc3c7d526a557aec32801de6effab5d326c49950e16a56915182b2bb77ae37a2995ba27d7a5e7dc4cebf07804ca590e512e6f0497cbc8bddf992f8351c5013befde93cf3ce1ec75530b77946a453ba6882e26f13fd280c6d2c2a9b941e8ece17a4150f12d0a7861796e4461283eb77ceccfff0c3e4119dedc9785e19bb5b232c3f750967d825c20509f3090bd2b8d5592d298de1bcaba35a86998f366f484e85c9f790aa64e1161b65e314c551255ee1cc975f91cce014173bf4f6393e67b681cfee8571c3c82fbe7287665489203ede7879c856ac0ff738e169c68c47ae597811fc1a97fdc31c8ecbe470604d8c944003875809ad1f07001d117d4bf41857a92e9257b229b5f0e3318f1ec45b2ac903f3a4572d2136d37d2e0ba93bed7949f719b95d5fc55e45163092bd1fb729e78a9157299862fccb460d12b24c9edd78512a725aaafaeac63dec0cb282bd0e7fac500d7a9d9357058482800c6f5de20d0034bcb860b7e178165ecd39d90e1765bb39e3f82694a29ea30589469ee19a8a3af6d06a1edcdb574b8238b7d1b60a1ee3b0b02a37db4bd5f068d36cb2bc070cba265c377010af6c8669addee3d1d16a836e666a2a1e439307d036be7ed505033db9dbb60918a99360b296529bf9fff472ff87dd20283145cb3452e47d540833cb244291429029c3e71855ee3cbce409e16553e1baed26a875957b7270910a90ec1e021015e6b8836af1e01bcf6db986d23800d2c0b5edd2f9467b2e5fee8fbfc4393f15b763e8d2d9b0d1c5d9d9223cbdf06ca6dfaba08dfae1b9bda5d35eef451dd920383a6190570c17d03d64a1362ade067b8e975165d3825983264cca8a17eaba7dddc8a3b0b63bf1cd0cfd4e28f2b275a0ca6650d1f999e4bd822715c4148cbec4da862377a0679ecc77bb38b5ca3082c4446d5af019ad54a74526c3de0b0d1d637f3ea900bd0f1e776e66b57f97a80a3eff39d57c45393bd6a2ced250544e518cf086299b6b5f296d4130c9d9e80b9ec55a27cbc8680cf4eb0b55512489908ad637368b41bcf4ca700ee22c84696a5b73ab419913e9b3b64d6ec5603fa793f7fb4d24cbc5ada6f707b029f8e87f8f574cd1590b0880296d27446cbd45a38f532e4abb51621b40aefe864adc4ca0be1ec84581f2b0aaaa036e86ca1876bba5a30556e50981cc483375721f0149ca674291607e98ef668094e200ac068fa3bad6e6d046d1ea357ff37f743fbd16408c3e68d238162ad19d0b4273742a2c842520815cc3954bb9b2e0eee5ec8ff8a2eb86463dff758d25182754e764cbac00124b950667135b4e9a5f1b66eccf693dc8e3cc8ba6709a8ff8c5668af6bd15ad455dfb8b1cdcd295c4ca9937db9b1215cc07faf0660a4d0e9ab56fc481a6482e17492508167ca0041b812cd62b4eb015061120f2f775a1fca969af74d37da81a5bae7b8a318a6260329924495bc617cab2942392823ef4bfecb5de493a6162049225133400d3c10c815a0824a8b937de7fe7e836878d9a13bc5cce7a15dd2228e04148aae1b38382cfd7fe21a922fbf24e79515d01fedc6d677c81caf82c76976e8a55cdc40054dec6a240019cb5180393b207e357076f05cde25057d3fffb7181a273dc280cbc4260b7cc1356b76e249b759197ef93f1e3638f7488af8b46adf11bcc19887e8fddf322673de1c7bec2eedf12f31b9ad0a3003836452c572b3202562c8e82cde5071ce422396c10ebb4a6168742ac850a430f8affab0182c4130484d95e7d199a629c8c8cd73062c2661c4d143bd218c32e2cfe99f07923d6adced813c0afb41d836ef6d6e6acc09d375a63a1607f0340feaee97def24ed69acacfecde6dedae6eaed93b15677143ae87da89da0792582d9437a7c23be25ffdcaab5985ae65e26fdc262683c3c0fb892519ac27549a32d5271919e4676313224ac2755b6132e280956ccf6c6d6a6ebf2072cde802a3b5b0008372c4b6edd349408e74106f5b222d6136f5d6add4cab9350698107c1e026f8ffba6c4e75f070fa84cdc2ddb1bfcefe156932bddcda48abb79370f3b92079d35c9c4fa50d24a344705b227ff5a50d2e83c26088526e5f36745e30d1200a407a0147b889d7f05cf5825fcfb53c4c60e3388327a471fe42f91dc4441349dbe205e76e9c993feffc43864c591212b019558eac49692fb46949e6242d63bc8cd57b5e14d0170c27c569abd1cf025bf65a62b86f5a6340b4f03e265fe14ea937e51715f4314ab830239220c504c15615a643da015781eee3cea4a943c7f57b05a409245b93a1985ba856c0b50ec4779fb3e55425d4fa3defd0c5bddac73977a50543c5913b672ee039fc54e3dea3524caf3b7373dd9a4aabb657a603293b800b6e87d7b38dfabb00eeff5f6b28af5907621c89e5d82b6401403aef75a7de21a7538cd39dbb3c69b81cd452e8bb1e510025d04e7358296edad4e258137a2146c36a58731a9a9bfffaa915b4cf3cd06329012428317524330812978d47acfdc3359eb2400a5898668ce2807413fc3ee2570359c260d4c487debdd38bf9f07174f7206f49e23dbf6fd5a8490f8bb90ebb97af23ba7373ca85e8fe1ef1c3ea5b5df1b44952b850b67d9f68b83fbfc760b40357cd3eec28f634b25ab5c358176170cbb1c00bf74d4bd3f7f3e1ddee2417c77bcb0267d55db500e398c3cf6a05407ef0d03c9b04243cae235c4d319a76cb26e007aa40bf2122abe7e70c1a1d3c308a2c523a7fb4d1a351664e9106cc2674255f7df56e8256ce2dfb03e8079dd127b5c9c36502a9562f163dc76840d594785978433128b9b3eb835c2992650d156763670139fcc2768e9c2cc7056c7cdc09d8928f7b26ce7904024cd3a34c558df59368c563f7c917235182931c448d523f278dda44f0a3712a8a5ddb87809d2d72478bf5d1b466ae39f83c648959e191173d04e6f42705d6a281a6bfaba156598f58034359d6746261e1439e3865130eb07452cf218b39cc5334857ceb5bbd33c2e35e7090149de3bfa9c5340b9b646e817ed0c5bcd0f36a3cf1650b2490ffe9ac2ff05cacd54208e80ad08e9dec17358093dc7eed1192173e62b593286525b865a646b09266633336c06bcc7ca48504094d935cbb6290e1436ef075fa26db2902265f3d46b92937d2c7e1474cc8a4b5771279cc7a595153baf967ea9a8b50c84b2eb41e30e1dc1d4d99da4a5a8ad4c1caaebcd144ccb6b3846a04079b56e73e02e8b15d7d334d8f40a4aceade42e3333d32de4a2310b14f1a3b91cc6007b42f46b25a11f4839db46db88075cf5c01dae1af370580c601577ba06bdca77e43b2059a15269ab2c48f70d7d137361cdfaa5fa53c8e6292006722b63822fa0ca3b6be7dadf4b1d3600c70a77fbd24867202940b735c04813dbee21bb1b94d696eff9d7b9bf0168938580eabd7b2ad8911de8949511bd92071db1d0dd4c80f95b09e78f637f06d112a11ec9fae82a42150d667b55a4c03d8d61cca31ec1899993ae5a66bde19ed685e210fbdadfabde97ff5e01991a81661a227ba94641bf9da21095867aa1579a468f3fc187dc2c7023a7074548ac090f68cd1926d27aaad2ba709d2ecaf13d015787526ca3e474016e9aae3c5950c2d581805a1202cf5ff54e16a601d422065c4baba8ded193d825f3e9ed84230d7643e5b94505a732336ca7756ad47549f7cd06185dbf17312c0a285cc36d290c8e545dd9f63d9a7ee87b7f3d761b781cdb58abae61ddc99c5202d804353ba22c53cfb79066e2b4efa603fa5edce43bb5f4beafd3f0469f996ba161a78c893b2c28f5da804f84c0fd615941028714f3133c6692220fef1436ce0fce5d98a6aa38c16cc18a850f2680326aee68ba3f8d9d53b6cbd69167b98b7bd35e992d88e27813980f32218a3a66a0ecbcbc959db9661bb004c98596bfb91a61358d87a099b3aed0c4551a5cb42041149f101aa2e471818f793feef44f1174d7555b69179b7571af375ab28ac8f8f1a33e31c41335a8a18d8cfee8373c7845d5cdd3975e7350c6224ccebd87c3e70a81ddcc184c8ad6114159be29ce518285bdeb5808fde507751b31807335727d4fe4cd95cdfc384f6a4d002ec60278dd209405be92d4259a7e38229f3d50980c40e8e9141d44e2592c092d11d63f0360fc83232b6c074b7fafa265ea498d337ae6ff9349807e688668b5399d690292931c86fa51e33ca3202a9a77d68a9cb326945c967376a97c3d3938ddeb0952a492eb3b16652d2d473af01a4b0027858bcf837a424f989081634bbf7a11b2aac11f86eb03d31526ffac2b82dce9352e8b5ba1f26aa6d477b641a59ae62d7af011feb251191a627382a4c3e2ae2d8c05c1279439ec1793e4081db183ff46569500a9157f3970f642a37dc79bef4ad142533d43a0a24d75ebf7fca1d8ea65b1438dac006a74e6d7a8b238c64e000e846e63f7bd08eeb1f1d3e4ed812c710205c106fbf6a7e2d29d03ee7cbfbbbf11415fa5430fcddc99a95bb947153dfb373db0c0723c299d7cb3673fc7db6e4ce7a3d0076f7044b6c39667bf435dc5cc346d94bcbb05960045cb5ecd32d12a29dc4f984ab8c199ab97e51f77203b22bec7795071792321d3603af129574be29994e96186e7df2f5c57c9cf9d4cafa34e47054261e2bcc6069f094e5c1e1b1e2cde17e780ba90d113b305d8d9bb5913f7f3e489c0ba1d9868f3b816b835bf242ae9be4818099c2c8e6dc6b17e31235949ca12b9242b1a05323da125b2816710255280f0cfa6b768463bc4017b82305bb6815095324ccf5750c2d829552d0c38527c00874bbb6d6a6a4ddc8a65392d3bfb1eb6418be3c7ef0b464bb3d42bd982cefba7cbef003e4cb4c0e1ee01cdda7a0298854012a826b4c9b61cd1d4d0351a0415a8d810ac275c3e365563d8004ee64455b13e044e1c8951f8b3d8f37b0fd057da759ecfbac0a724e6abe63d01c662df91d42b8d1ca2bebc0b9b601fbc0194f49a7ad2fe5fe1a9136b0abc104bf2a2056b15ac89bfa2ad91e0ea53b116dadc4b4467d3b6bfbeca01e9172618f2654c615f4c61523f7e0a7ef9ac5b0430cec126d63c7af3ef0e0173d0c333437380175f68f096ede2f42b81672d3fe4156ee26a6c8dd4f241eae5b2f2a2f7cd8e544cde8813cf45fb96031970ce7632bd0820f2bc77deb00477a490eb47e2701d83456b2a08c4cf3158c455c8e217301ad11101fca9c80a1ae0da80ce68928b70d70a6caf878bdad5736d36a9793d0c8f605101aa4818caeb61806dc6ccae7bfef71affe90c02583e6873a1e1ea05319952a6561f8631750ba03c55f83698dce94ae5a8c7cadc299fac95d54e738e22b0e88ce40a330619c44a720c1ba2a844a07d6655dbe62e5f40fac450ec50d9f22404c3b624275373288065db41ee54921d27e4be57e1c0d8bb01471d7149a452a8d0d5a731ad11eaa1c37652203c88d2bb84f393f3f59898e48518f0ef98d9d6e260fcc29323efacd3cd5c17d137939c20b20040f1328dd98e33579f201d04339ff4017c95d243df3aef5e566f25224311cc6cb073d92f584e4ed94d0265b53a1e0208a6a4c996a3b8fea42134c42a6bbe74b4545c31142fc9ff13a08b0c0535486eb5928b4681b92482015c14ee9ff7d10791b55cb8725a024ae8c38d0f449205d38a198195d0fe63bd72f6f408b626126c93dc5353752e1a3c5c591e9efcd33efc937b4f128f48f9228457932695c3cd7f27004fab7508d0b2d3d539684e268f4f5906eb96337fb7aed9a89eb2c1537f7471053b9bc4a0bfcbe488d6f75fea79d30dd1793b00480d8e8c3da3e32acb1269a1c0f7930e89043dff22ce348f45a3d783b239c8e22967a544f998fc0b06275fdd92a0ea1a06e1f21bcdb68dd1f2f782f8db3df79af89214f2aaf20ac040f0f7cd3389357ed953df2767015479284956ff6900536feb77524a738ff418aea4c04cab2bd0d7ee14d356ebbc9ec07f2a7dd0a7e1ab7a65bc64d1bb2b0863835b08420669ea0407c0e3d37ce99d460e0030475e0ba4a470a07903d82981787ed991c565652e4c4ed6c156852f305a749e46c241e848fcde89608f68b823d08013dfb81342acf7ddba874dcc144c10d8257d24a3bcc8d2a936d7978bf89f6efc4db972e6321b9060a8a59c671348d3d9a2fb6b1a6a7da31c5a58bf38e01245e297108d0db23e060e19538eaeafdaaf8cee62f1acde682e041baad57d55b2f4f10773af3bc098c0772e45f4e15f8f4aa3a7714cc5c6b3ab22fb5bbaa1b16c11549421803cbd486009e5bc2734f3059c39479b6e7a9cee54d42fa56b67af70513dc55fd823c2b29111ac96247c4b531478a82d7102555114ad92185ac0b1cced4b084bcb20c5cb8f27bf85738d7d99ec2da8f5596cb5f5c5d250148adbc8634a17e68fef426b25f9797a85c2c6d9e175e96258af56656bff9e820110769060218a383f7f02a9cb56a5200b0b11893dac17a4d84dd2de42143ed0807201cc328d97c1645d4a0c6ea9ab7b8f7e9c09d3f13b00ea9c812a860af5fa1641b171e032aff3c8755b956a38a8f074a79a3d3571a1dcf10450f997c4c3a46c4485dfc52ab59b1216b5428e5322824b24012066cf2c857f044744156537ee79ed3fc9a2f94a8b18b1e160bab61e43df306368d30594f25867e4b220ea4640e11a64fad3fc3f94b537fd1dfc1ce268d1ebc5be5762a03de9a10058c137f913ace1121e1d11de1c1139693aff947e1fe9d734244b0459dfa2efc19e1fdae752d6c53c2fbb945cee06b882210c5db15c132d2f1f619bab4a734b56319aaaa1ff10bc0821d6634c969b0b29fa06432f2422d1dfd82edb74e482df624d0721a88b846d28d9296402eab19d0ad6f0a9ddedba7221dad00c84c33f1d16715f9842b007c8dd7231cf75310cabd2ce5d3dfda69daa7ffa79ca9f23c1a64eb1b66c070b6f1c7b9a909d4cb830c9582c6169dc100b188f1fbae69450c80a319533d4f2efa2e1803250bfbc6ffa61216af8dda157763ea727ef9b7a5173e8a884f39ed250ffb64153316130021725882b3752a37169df64b16c88ffa1b9cf1b784302eff90f006f02beb80e0bbd760fca8a2cd6a235d85d9dae54e384484f1220ae12851b8514e69d9e6bf1a475a8adca139b8fd7443aeec2dfab20ff7c1aee889e572817ded39fdc9229e66cddd4fa8cff1c7bdc5e58c43f37f9b6b7ccc79831451c53b3e7a17a810a42d1b8322da0bd8df1aa3e12ef8f305b1dbf8fc5a4c54c7b360b3de04785e97f1e9202b361949b3c8aefb3f1da0ed894a45e254bf20d0fe716ad321ef782fd02bdbebf3f25b27b1a66fcaae62683f6c8cb951222c03274dfa0736ed5a7e117b321e3fe16a034c40517aa4386d4e1898d8b725f298a99cc4eac79074bc99c1ec31a638c52eeb8ac6f48ccfb245831c612e81b733585c6c0cca2be6507d9f05e52e7087c64e004a065c845a7d724e786a5f7528abd56808b91b04f644d54aa09e1e5970ccbc44a36616af429b902b2c0e3e461a6cd492c69f0367446c9da40c3b09370b00f9c72048bae54d2b5300c5753c87389a2b65f81d636b5f9836751b7e34be400bc29df146bf35e8f78be6ef5219699d05886a315acd0c828cc63de998ca30c6fcdb285d05322c03e7d7f7a2a33ac2d7f53d2f063ab9a360511e721d47aec7e6ecd3ca3ffe28ed76bc7ddb89e0a64d3be9073b22654564acd9f9505e75c2728533a9671a127113cc9256b1557a26b7173d614d5144f6f66157bc2ec287672b10b1d3122f1f028a79bf6d4e74c7d426d2dca4e086de05401b0a9c8ad7f15202132b1761682ec6ab4a0264ad49e5c74146d40d4b92880173d9576243f578c641d63289eeeb22eb9e12eea32552d3ec026e0e7d89035155b8d5e47d7b607eb2fb2bfca7fea2c81ec52f1182cb1421d057a9079a420ea274a93c7b6fafdd1d7dcc886e4c8c3479515faf485a07082d5780992f524a3a674ff01523ac6010c453978eeb06417df9c72f486cfe88e826ff24ba2738c39d218b395ee884b772e14aef9bd615bee5cc1e9e8cfa7b4b627367733e755c44ed69e2321107fb97c68b39bbd40e54bced37b16655271c9a6d575e433156ab80f9e2be2d1d1f55ad959d87dd4bbb1c33140088f927382363dfa681710517d850a1171589da3b5df4b691404f733070420c7e9bce730cedbec68f032d352d868a815ed7ac43ee5b26e0189f62aa67989423d8c0bb8240398fef46469b9d016e3642f6a976ebacc63a2b6de541638d8ee5ee16777f78a7b62ceee5e71277752faf85a78c82f9b38a0274678964e9f056eb843e9bd5b06c50c8236c71f19ee0dccb07b2cd311affb8b83b2e4bd9a8ca6385a1494726986aaa51c2959e791f1720263a2e3e1fa9b26be238ebcd524fef1443a5874a3bf36369b7dca90f3969d70b869a6bd68374844880e5fb849704073d16c0877b35539f94e6cde74b351828d87eb4ad8dcda85cb84bdf3d8623fc6f8ec2a623c2df5025c666ef5c637f70b8ea471bad36d909d54676cfe99e56e500bd3c984463082ce1c58dc80aa7e577ec9ca3f9c73a0582f13ab5a86cef34fadd02fe0935667515a2a17bd6146f0fe878faf163c0172ff17f46eecc87192d23e961fb4b711da473a2166ffb21d49cb647a42bcb09d98cad42f628f4bddd12d09fc8731322b9f45c7700ca2897761e81f98d03823e4344bae104143574ca3ecef34f0d048f48ccf5889e0898df0527f9032b0a4d62c094f23fe38c78c9d0b9ff6a31c6a73cbb06f09e16d81b28e34703d869cd234532a4f90a91968560edf633de1ef7edfdc02157632debf0c71108713b30e143dac30d5ba72a55027b9721b7b04818d46dbacd8c6c9b2c53e3ab73f1fb2232118f5e5e35353bcf59647de5e41347aa9da68356a6df0ea20a50f236bbafc3eeb0421e2832e6de699a4287569517aab185b5dfa1502a5ddf6324e3428c90e97cc5c69f8ada10252c49671b277a116af7666f6c649570e6933f58211d8d7f50b91fbcdc36b0b84c89f42a7e47d68d612920c454053d4b48bea5f94481fe43476c61add25f8ea9ac634726360dba16e49f002fa64b70db2232dff0e020c940c441e659b9eaca5478fbe3345b2afc961b1418f01f84c61c24fff478abc556c8cf9182e7421ed7d5ba3e353770f60fe5d15c4839f671ed2c816194d64a588a24871a59e6a168a314b9d714db9310d6f99573a27c7a17be654ac317ecc9fd6ef11cf828a71c7b4e7f62d3398a759ea00f9dd82d94928da72cb5fab68da11c2d21e64d23f96d1834e0d0ce8f97aea3f24cd735903bbeae0cbc36d66e3ea96e7f028d066361c306aa914119015c316ab6617c0f932d881a518cc22c708cdb77157b96dea6e8935dd7243c271045fbee044ff88336d1059092067ea51342678ba9ad0c285de1165632fda90d50e1b7209c69d3c275404d3ba2177f6eb63e3fd5daa5fee0a7bc8ee9a1a54ba4d7eb2358a2048f8019c16bcd7578bbfa48488b59b8b87a188a0ced4358bcec8d86599d973899c02c7e16357dcee2d54f7aeeedef295685a3d2aa2bdd8dbb4eb3293755c3f02b6f76166dfa9d94157874a8c48243785c590303d3334a8841abb29f287841b2fa7cbc9ba280de3883246a91ddedd47c67b9d013424a055c0c24f28cfe6cdcaeccd56c5c744b812cc1ca50a6c27086ca610830def270da47468cbfb4c4d1f4260f208d36324787cdbf27a666009f760f4d36de1d9466dfec6052f80508e3fd17981a349b40e06ef05400250df235f6a9134a257937875bc11bd55f52dea1ccd927c51489ed4e8948ca5b86a8315e913a95b2492e725a029d69a13cb646b044006c93233672c9a586a803109b6d0d208cbf8def49d2897b03ed20428c4e2b803fa0cfa37d435d31aecb57737e76e4bb76679e4c7435d2302f77eac817650f735f069730d6cf2cc64c052ece401cd22eb4e24f2f122a6f0c16f56b95802d516a68a017cfe9d50d00fe396885d529006ccb32864d1a8b3041c149d3514a1800609f430caa7e3775e45f629b8a8b882a0a627b9a791ddd3376b499bc5edd20c2f73b3963876665434767afa375e1535699096bd9b63b31e43a846fccc5a99446c9259ae26cd2ab6d046f1b40f136ad4c9085c20323959c775c575ff12a1a7f3ea338f991e65822458955ac38f9bba68e34235e02db4c68dc73a70ccf4cff33636b02f34ac21025084bf42048332e1641a4c6b4b11caf4187808d510174c997261fdd06a5a8a0443051edcfa0428f94c32db3e7f89fb140aaaec66e2d2af45d4f7ef224d488cc488d17a16615d986c76682840f6b08bc44e66c60e8b0c75e4710ac75354783c554631a8a3e0607e090157e3a476069d920ce3440351e175b960f5d542362d11cc6f10be071d1b4ea4de1bc554402dd9c9af70e7265479ddee7aa94c8b97b7c424e666ce5235b519c478fb450819519c2f1f1054351eaf23edb19092dc5b96b674fe8ea22622481730f3d955183b5b66d663753c19d3182b72cb8344e63ddf0d4da719d3cbe513d6f13ca766982648ac48b669072157753abd61ff11ccaca0922c0fb28790db39378143cde2983d44479fb9c2fe50e87e83f11078ddd623f0694bd13708784bbfbfc46b46c17e0b5fe87c210bf3034dc3d1a9439ce9004019c138be7d6f8ec5bc010b4aa7cf01ecadcde2477964810d87c52c609a25bcc1001c0af10525f9654138dbdaf25b24a58a22219bcb2640f26cc4a507aa8024ab04de3a07f34032307e1b8d11224080724be7bf4cf855ae2a95e5a6701ad534149e920bff64a31043b415cbfa7470091a8105091065a4af8c7dcbe489b2de24858aaa9245d8b287309ef17f86b1e570cdcfb01c7ec82a2f61767d1c94e47c5f0bb2c7510063b63298a1e8457e5ac23ba3726d85015ae83ecbd60b1415e9c94dc46db990325e022cca6de063ea9215a053389d7b49b35276a49325269d0f94e96862821ca4c655977251fcd7fdf6ba895842c782c2c89addc2f89a5026bdbb9f48e23d942273621210fc2d5046a07c156120e6b04926d83b593e53469c61cb736e6259f95fc6576fc78722a05a1382c7be2df1fbc8bbf7f7237d0c775af540046d53ec7247c0de200c70150f7e7fd5127390442da085bf0367af3ee2f89142a561ea05d4775c4463d821d92ddcf3bdbe60cc776d97339e25dee77bbed116f4da22da6a26e30bdfaf36318b528263d71a2d07f1db31e18421c5d6a1f02c6ae4c4ee723489cee042e21ceae0c3b1da6acf9b2d3298ddb0335d2f75bd9593006f22131c6fcd30f57411c00f4fb95a6665edf27979c6e911387be4322767c88844b431f1120b5fcc595fcff81e5c92a3d1f8a1a64df3e82722c2530a8f817d481d231590ffacd4420607df6ca37fad9196846ea5b51d62f8a9637c40ad852b5eabc1aaabe12a23988161c0ff30bb25851089d8641f11efd7e8e7146030800a750badb7e4ae18910b9c796c1039d656c806fb38b0a3477da4940519c800c473b1dabf5a9957cf236f97eee1fdc002700779783379cb577c7cb3b030cb9e56dc00fb7e7c265317d7e96533ba78c01b4544c1e7171b9758e2a465950559ac6e902574571b553e8c0033933e7750bab6e785ad66290e0699cecd744f86cc1e3a28a2a3f6e6abb557cec7613cc49c33ff13a82b127e2865005563a44dce0a2a114d523f24f03f4b372ca2c40f5203f5858a9d3bc6e97b31600ec94898bd3bbc39d76dc8ee513aa7588ee3b152790822963a341285685c9c8cd095020c74ff3d1378ff9ec6e52d80947f723b438012d01590c2d897dfd5cb778ee793dc5ca7d7e6e44da4c0d9eb2f5a5d6f376081cff9ba45175677dab13255a6c0498c3320b53353ad4c9a4e18972ab2831e9ad7b4608657b1add140a8aafa3d4c923c04558e1e30e362219faa771a5592e01c68b0aa4149cd86873a8805a38f69008f1747e6ca3b6589d5ca524ae4ab40971520ad293c96e01ef592188f2ab977f674cd1917d30e911411ef7aeddd3732fe53c5bc49b72d90cbc09f3fd116e11438e061500c0abf121c5926f3b7f209d86f4dea6553c5692fa0b903074b9829b1ba0d1261ce7a7bd9fbcfe69521f1208d3d313130b21bb95cd5965dbbf549d39079973a237cc393218359cac66a14eb71c414d47587a4d8ee6930bdad911a3a2e72beba01293ae3781f4fa442d440edaf36a75999aa8373e565d65488e42e2f536031caf9e90a05aff63a621e4ae4e7c41aa42561db13cc50b353bc08d8b1625d33e46e6325b3da2058a3b98eee5e0566518a793842f2665cac31f32e523728a45c62cd19012c11b8877d84a0a6cdb0e74dafb450ae330a2317d174bfccfeae03fd09aa4e264f31df64d28dda21578ca331bf8738682faea06b7d45fc36bad03f6d4f0dbfd44d0697933e5577d1ba6e4537a7e6b7a89979c155b01bd8dce5867e287c4c988ea7d748e11df60c9c40e5bca48794f546268fa8ed0b068b197badd674c75db7d335694736869e557a6591859039cf1bcdb35a2f3239c29c3818457d8308a623260e56370861c5d1f91b7cffb07648ed4b3b5d51c3115e4771725986c33512f16735a5d6da85a040cacb2e84147c8af0e3c800fc722864991ad49259432d75e0d729a9587a681ef98d242b4db20bd95df1f3c079d4c98c05958f809cb3fe9d9e487c68edece4c489b6f2aa1887976fade781c44236e1d71de5cf59a64bc8f483384264f9ca1697dc5454c027811d29ae28618af915b62b2ac280d8ae5705d879103afbf99e0a86bf24f0ce7798d61d7efe5ec7a26cc95d0264e6f24300c491c89cbb52b144d873072fa34270c1aa25d3d7b4e2c4520587d9ed06126198fbe09fc6d32ff3f786ad29a4094c015270f10fb78cd4c4646cf851f903162e8608b69dad535a02040e933b1676c64d675c64f21e70428cbe12c06be37838bca025caf060850b217c46efc0f86c9a8478af759f71cd7ec9d5b51060d755c63e8e1761fc1feeff4ef3c93108d3666900ca89856d0c8170045850dda988b1122a50e50e5dd94cf39a98d28dc133457a230414d86c91824a4423498512fa1e9dbfb1dd1467eafcee2078e5189c4c2c131d3c7046eb1777f574ca7660a84a895625edcd856bf7adc61de7ee5806d28a399d54310f33a8acfd6ffcaa719fe13949f2b2af71f2df36043920a3abe327558193ae4022f196e26dd89ba84ca78d7b29e2487bed123cf01f32e9b392731cd0af8bc7735e481f670ee52c263362a687f60ec00dcf561020bc3fccb073de519e08e5c297242d6bf7f9ee3fa434ed0269f7ebab64e0a69c72e693e48204ff1f3e55ad59cacaa88f7cbd226fe11796217ea9eeceb06205cce67c2d12bb05ca7c6eb97d46c743d4a6bb44e4b891c5c32144610dff67612ead7ba95aa5e9f25d5b32b3c55197abb85bae026bf2a252ac28b79eecfe6096b08acf263def8fae9e39902b6412e5bcb3d5026d78d6c28a9823fea6f3b4c30f3b862c6c9ff50686b06c23d6f72f17a17d3735a0a602976856b086f53ca34353ae9e4bb0cc4e4a153e318ff55ca27c7219f7ac44db6f2906d88f3fdc382f4711c6f40dcf25a4e4dac4d6f6b1c809546c234352bd805bd5cb222e031824e07913aadccfb5737630d89c8c78d0ff87abdca010fa12ef0bfb431563d8f582bcb6c3a809af0d6f8a492e84056787288dc7f5f1c3e50b0ed1847cb7ae2ac003027e04d88047720076c46f32e11259137838f68bfc98c55637617a6f6b4aa570c0f182852f01be59242f525a1eb54f922e38695a99fef75a40c7f1140b6eb9665d30c3dff2a948882ac700c83669d8c2cfea21fda7fc2582829ebe923a810a8627b7cc7962eacb7048f2051344e2e656e357d4992d095e60ea0a52e7b4039e535bece44a7b42830b45468752db46c0ffc7250a71b8c26581bc3c89f9f4ede2b8843847a8e64e504352f117f026a5561340765a7901a71221d02bb3fd4c64a65c6200c408ae71e751b924bb92d5482375264e8ef531ae536cffc09c4d2fb3bdd1a2d727e8aa5c428ff47f69eeeb22b65820d1980ea8acf7b479e20747cb207c2a3b64ee49982346200461b8280b5bd1b0f9510214348582ad93b821f6dd69451c41356c323e9b75ea2b891071e1a858beb05e6e7658101b743013801297888ff787758c0adf91a5c3b4767ae292d5673c75a418c07ad272457b4f4740e103e9778bd15bd741511526fe62e28f6e0965b50a829bda3d69a6d4bdf318987a8fa66c76cd228d2e540dd5c4741a095d5b02a417fb22d7ca4292f544243fea08c42567772c28485b514a16c2077a4b9c81df7a8c57497e01cc5291fe29e05f2a640a03262920b5f2870432dde660c4d99f10a2f94b640c972c8c5cf27d4053062884958f496638de088513398203964fe12b51a08ead32600d9e02e4f50b177073b25152e53c876add683812f6ba6cc44c87807939f048baa221d200735c02acdd02c58579a01e5e3bef97306c4b79bc58eab3cb12b513791822ef92b84211318c1566f553f41fd7108b495d87a9eac0817ab9a34f3fd7f1bf94f14ee0a834d0c01340af85086367af9b47d4f0b0c8a784edf9dd8de2e697a7363d4d925402b43ad4ab08a619f6317e666d504fe06a2622f3fe449cb6cff387e49f59c641d7aae56cd5025246d896958951e4ff1ac80e83f35623d37ed0c517612be47d96f1005b21e4b680a6d6dd17492587add0c634f0e67488e10c5edb30abf2eb7015daa3fbccb94d8d81973174ff86760dd78b47bfc3a957977c3a7b39ce558e2353183a50bf9eb72802f3de1c06a7504608a4cdc8f8bedc3291ec6152cbb71603d0155684e29a02d218925086c97ea100e5c280458e9193dd949230f5d4d081fac95e9d0d62a7916e8e271dca11e41485e6aead38da1b65766d3d312fdceeb28c6fcda1142a1f7025697f436fe71919bc47b9e6e91723b6096b4833510431143cabbbc579500ac15ac664ab0d6cf3b43ca2a8d4c086d50b9ac8ba65b5caa0300aa23851c8498471038afa8eed0f78acc1dcae0ff851e530ae22cd32580d46c1d26a3e09deb6ec72aef402e643f63fe0e6054d0c8f413c9ba1a209ce7cac41a742244785f58f30f40edc3180cd98d8136d3e816aa4209d2d46d9edaf44736f1bee359fc8ad2f47913fa4c76dbe689f5d301211b528c0e8b364a790039c228828df3eb460a982b5093f1f47e5f4090a0dd1150440a2f26b63562c8da0f0dfaf186c8b7f7868189726584eb56f0171e1d4556d209b84360e97fd7240caf04885e2746215c7a09b157a0cc8cee307bd4db08ddb649dc1e8f27e3b81bf5d42865ff07fe31f1f4230c11f4d1bd065f1f9f2de940594cebae04412500906897d400312b36f1145f372e23175646693bfede6891f9816c10c2cc122219fa35877b28bf9b92db5f4d77f1639cd12fe69dab78f3b7c52b83b6131daddbf204978b220001590833aa0744408b3b1092c12aec207b35fb49b5dd9eab616093d709a4280510b3bd5b3eb02d8b5d5d75507a33d981cee236ded3df00a67e0bb2b56512b5e0e8b848a81e34547675a0bc88bde54bacd38062981339358f5d3b43e02a5e6bc004813b2c5baedf4449b2f7ccaa56c40889d1656f214b62d79feb3638b936315857dc31aeb6f794a93765dbe470179e4f1e17f0f452540dff1538b0409bdfa08197c51a92418c91c86c097f50b3b4981e293893b82a8fcd4c1e3a693c057f480f40ebbb8e0e5bbe72e07cf8d70d1966672560c79b9362312ac623b859f7c7e6fc3c680808d344c82946e1390c3f94d234451a936954db84095cad206d7a781a89c8fd6b49dba45fc32e09d5705717a8d1970f22cf3b772f4e87bcf483af6f25200a0b6e6bb250ccff9fc4c03aba70351910fd5b42dd293e999c0d3d514a698b27fbd689a62411a68d10255931f0bf940fbb62746ff45ee238a300d02fb11e2b85266122237119c0c4b37f18021f015eb2d6fbd6e58cd3de1ad5d8156c4692fd01132389a3df001b6200eee64b43dadb077fc8b0f8ce3d714cc26a764f8b7a3d8c30ea04bef18ab8f6189687f6e589ecab22b9f0349a61ff695555571a8de1eb2cc07ee3729e393f83c4171030d7321b65e80ea3cf71a1c7740b20400ba51c1ad3b3f122a4f83cbb1021d1846ca5c059477d89feb81d55dc74d389b4b7abd76d56cae32a9506c1198a8fe2a168ce27069d16a0105b19b226404ca39010dfa5da48e4b2ee27545c288d96ed643118a6b0916e459889d14a2105bd6ee75c65dc7c80b072f989e913ee159625eb230b2b30bdcf153092654f06693475ff7bb51d5906b3f9ecb74cc67f46047f98baa8b44a7542ddf776988762a6d66abfbc8dbeff6c3314eaeb9ac9d12971d92a689d58e8fdb0f93b395008433ffc876fa4ab638b874e8d404867da41955b068b59f990f265bfce2466899584d147bb16b96aa568e3ff2efec3ca73a8d27db14142d66577e4a0cf79dd634281bdbc9199e303b374ec928beae8d162c9c81ee96ddd9e5ac6ab35f88c46fb0753e7658b17253ad62039c6f843b0dad17eccc6b7bdbe6e7b8e5ed9a717b9c8c673e9370d21903f4921b85e982afe49396e5bc35686eb499d99cedb4becbfab9442baa14d200f6e8e7977a6db458b86eb143a55772a9a13856371a73b8fc846622ddd61d4cb4fb18d4546665692c91697b9719f22e9ee7d08119f76dd3267b8b9337e836e31894a07bc41ff9a84739a00f8cf91b51504ce4d6e538a214566a8ff2dfd355433fb7f1732c358a4409d01441dca68362e22a257ba5d723f7cd04669c09b47633c8b25ba49d3bb5f0b8f233ebb875999759aa1908368a33d068415394fa2e3481119c00506dd26e8b4e1c6d3177e4c3e75e14193bf933887d798a02219676bd71429bc1d10e176765f71cadd8e0fa549daab12193139a263aba7f24beb642d7b1002c13a759c30840978c4ba097c62331d61b281db82f2eeb29b92c0992cab28bfa9be1d52ce87ec06ef848f6943b6d2b7f872d19753adfbbbe95037d2d4d057872be6993884a612d24eac7fd854ea7e87548e05b595085942e0281cde4194c39d88d7f681dab247acf6d412885346f4707ccf2c5dcdf7bedf5dd002c03001d3bb957538db3ea7fbc793ba2cd37482bbbc3466aaf1344226fa3799515777dc0225e1fbb54e22d921ec33654102ac1e8a2db9b7bb4f745c317ea8bb296889d75e19692f86b76ee90bb266d89a2c09fb02520a1c581378226878b1474f50660f78c3eeaf3c260a4b3f30c2c23f38a1ae8a8ac7ca9222b417a796a021582890c817ef97ab63fbe5466255a0c3f1b684f8fccc7e6eb3c47a435fb8d1cc817421557bd5331a2862134aa7dabdf5e72c4f595aaba36d8447ba617722ec28f9484738ce3f3ff8c3543c9df0120c37f9d303181550530b6d36cd7ba0b719dc0eb47ad0c4c9f2cbfc1aef7b96e80d215f4426b34f6b2ffe33bc2a1ec878d5cedbca4060e06db58c129fb3798ca7ee07dee4914667374f93813afff3f772b6249bd649b781d2941f049832e3771fda8c5fe1d0c891c991778f63a7747cb88b3e05b8b884828885440f2cb7ab021d330bc4d4d0d96ba6e470bf7318e6e6157e1b3addeb2eab7e6b2299743fad1cfcf03fdf026213ce48fac7f91693d229e64f103702f3b1b62a033a274b08c765d8c3791dd4db8f04022f28f57ef4cd9bc71616db93d1d07d7207d3cfa3c83a873491095ba3acbe5da1a05d3cc29f254508ceb6476a4a1bdceeff6ae9f9f31450afa97f31667e1004329f9a9666ede9e806caa4ca1efb2351f7a1af6b378ba37507111c56c2e4d76b5aedcf944b9b6bb6fb793aeb088513836d475a20fc2ef361a1280e1079d5747027a5efc5d623941d4fd8d3579cb17dc42f13e538f5645608cf85ee5895c195325e247e5824e31ec5f83fd6d5b868036bcbf4f2c24be4100cde8178eaa66a034a357c9a1920bc1d70b238ed62e33cf0e37f42a49b8b2f9752433711d94a3e6ecf9dcea9b7c8d4ddb7a7c0058ae04bc61bfbf7a05bc7acfc1823d559be4dd06428cae8cd392eacb5896f2a6a4100b3012a8ae9f4f400cd1c88a02c68eb916021891d882afe5e623dc27fe1abd55d1c30f901e40019d65bc9325c10ada4dfddf4b59dc19731f2a0aae1385ac302c8f5f65aa73bf7a4582881b3d27b467d367ca2530b40864f471b57d13809a7dbeee4461033bc99819a926a084b735c70369f9e61dd347c97a931fa5167c3d51700d7bd79ad25681cf152ab9668dc982309076927a1f85e08e6f551a3f89c10add3602bb2f5e19a12321a0f204f7bb8d8ac5a3be4eabaf01cee1f687a29b7fe33e84436926005e4dc311ab8a44e581cef9c88638d5fb11274d8b1ef1e6e9064f409ac0b992d31e99d324031e09a1cd0f82855921d2d2881f0f5a4207748d10a403a04d465c008856251c91b0f3af112b6afba0332f621c6d25934a273234057948019dad33947af6d962e226857644bba37e0c03151cd3aa38293aa3ace9e2a9bdd16469e5634a4fd987f30612ae45d6a067edf7e51e56f10016a4752208096722e8fe6dcac78f34a975250869359c87ca8eca7d230b01e659769afe11d4fcbe4c964269734cd7da3598e3fa6f42303b19c450f983d1b973ecf774aff043864df2a2d2b31d160b93824443e4907bd8ca5c3f07c7912101510bf13b734a58d86887ea95b5b9baa27c38c487151b07d3381db4c56fe65b49abc9cc76db119fca588c8ece62a6aa28b00273867918bffb8796bcf3f0884287d8d7830e4c3662ac45c1823f34c4e5bfe6a98184e378fa9153b1665be9e9f0fbc610e34754aaf5c86a9f03798e2487d0c61a53413e0dc849a0080dce9ec665a04b63152adf34737d9d3e6d4c582d593dfe9c2d3ace9634555f339d3ee17ae4e295224c6f1643bd99d04eb33ac7416d041e9a496491c241ea668a806534e925a33f199a5cbf83392f4deffa37239ca8e07c7f171358415640ea4683fb80cfde05c6f30f3e8f9d2f15b8c3a0e0ca3b73f95bda3705858bcb4947686fc51c2fae87bee5726642c8b1a8154990961250b6cee87f9eb1a32b3657cb5ceff8048d9bfdd0a502ca5271c0c56e3b237a782496ba620809eb15efa34e0afe524a1a0b56db7c58d066974df6c1dd24a23b4a0a48bff6a10592abc339644316129611fe9c49c0f751c44f88195fff0353d69731c0a444e4aa0f7ee350e1fa18f12e575978e25beee04c2b042a0ea206ef51fbf0cc707e40a904a83e2a19c8904d3d8bea774934f138f720bd88871ced7fe8a1811a68d8df742a608849aab7fd90b95eb8a6970698430a3c720e05a2fd3b174cb6345ccbff282d7da3356d364ea437f859c959b9d10639221c6133c94dd357d45080d9645b1e804ac5fc24e751e624dd233eafd9a4bd46e45faac314e108ec77b940bca00be9caad4671107c91883dc79078ed9d242214bd5696484d8786fa7bb4b303263b8953a8686a2c1f07f9e306d844a4afe6c245fac954f8d667a09b1026cd8d67af985fbc8f969efa19f0b666fca97553a335a06e12df3b583f21b8583a9a79e8372e1a40c805c70fa402573beb132faae42ca492d80fc1257952c24ff524025716a9dd5461c89af73c9bbcec7ecdb7b990a85489c9d9960c7bccd8e745b880cc709e7687027cbf02702dab7260000df6df86ca3314693964a7147de667560bb3db2656ccb2cd1b7493220a9488305617330ccad252db6eb094b581c2a69c06cd773c3c611a33ce5bfbda061378a657d1f6c31a2bd1f6092ee403156ffbb3334cd49a67e47a5ac9b8b751f2592ebe512c3da705d99840d246dae7bce7d8154c2f35f9483d0e0939d1b4ced99b6a47afbd99a0d3c4a6036e7af1de05b4f4d2d1b32cb7c45d198aad21d3fc484e2c0307b89b8628dee366ba2e96b0c2a1f580a38255c17192792aba80badf7e978e30e42b346e8cc93474df35e2d0319199c0200e2f0c168ad9803aa83408ffd9c458802d226956c41913c17490fc5003e00e67925de798b0cda8d5eed7431f7535d0f1d0f052c5841f13396998c49a48a37dd00a4dd03a4d29561f9b311f436fa1e5740ec6ba106f1631d0e652278cac462e6afe78082a2d18d0109b926633c410153e54eb9beb1a1ad23cf6f1e577ac8f1b3546bea0c6d0d01cdb98cde4e356ca1cc2d0d0f897978c6d1a91fd319ed55d914169d32c343406945bf228ba2ffe2c0c7ca5f888b19f9742435946d01731c45944dc6d2c665625f0d6587ad2de39716aa244fccb73369412bcad4ccec3237ad9d0aa63009eee0c9b5a0f334eb31d73e415be6455d70917d28b6dd632fa973a1a9c63df2d45ecf2c4a921ffbd9b4235e441a568c8abe79927889bcf7e7ee417b2f23d3c98eaf770ea9cae755ab006cfada004af056026f401e18ab5b5937f0034641c92b417f59c627ccf2539f2bf5c4064767ab39ed6c01dcdf8594085856064481b430f8b2cc1c3d167ec61f22cbba8890d5f17baf63bcbdc505776797c635953dfb126624cc7a9ddffd784963de0f4f3b300ae5728085a8e8f2c2ef9618598eeb1b8daf5b31e6eb67eaa46f1521e250257b1e3188758b78a21f7f1144943b7e4aee978bfb1dc28a95ea03b6321a0a0e6b5f53cd1d10527d4176cf93525085e97427478cb5ee6abb5d6238462df3a2041b9aec01d99f20219a8f00b011409ca22a7909f239b1da1580b6edf8571af32ef8874c0a3780302b83c41f7ed57e30c5828bcf4bd04b8d9b293a31cbdf05516803134eecbc0df37d697382baaf8c66f9cb06621c23da3ccd14edd41428af45302d0a0ca353fd16f30f8f318c0fce43a6bdfee2c330f8ff0a80b91f3273e37b6484baf67a1a3945a394b944f3d165931ea5a4858c560800af2eedd82e9c3812977377c6c6339bad9351e3877cb5864743b44befb2a1a98708016247f8174b1413d82efe76f887630f660ac3039f4101458cd25b5c6a05e7bf31024c78d36f3ca53b5c91f672a964956960c775e80228c81e73171e5ca34c2cfb15d98f78b270a93b82191a0ac5482d882884c4eab21ee7f5a3f3158fcf6df191a93ce10bab165b5cd33eef7b3675ff2b2262ac5f2fc9dfaa9f5846e0a1c8eb23ffda8e459860426f1ee2c49a5f4d14b62d80d48d6400e6a42fef3c77862148924258fdb7fa4b0be1dffcf25cc8ba475c7d3a78f051c20350c4be802608ca1d4fe8afa390bf45e03bb94846786e42e03ccc7b7f842cca21545df417eba1e7469273ae38c4e2117f81f772d1acb24c4acf0c707a600654b21d96f9ee1cd82577d650c46b2fc243fc8a92e9c4377f25c8256b981afc17281a2d977578fd6e7e5ad2d5567b2464996508dea7544578541efe250c95fddbf958a373b80c57eb1d04fcb13b14cfb3b5b8bdf76e83713d1a4c320406af41fff1ee23e906deaa6c0041f1d9adf5fb1bb56237f607866b7345c6557bc119774f7dddd676aa0b1efa4a5ba8f10d7b6741c67311991d239e2318db93651af27e587d3f5604f5a0675d24b71e931b531c7245fe27d248d5d5ae8a9a64d62b341b039f90ad395a99f7f014a3daf22f6b0d24c1a38686a055dcf94b2d8572cf6d382444cd31ea8af32c1bb011a98b8b69df8cd243511310e481bfdffdf59dc9b4013ce32b72a29497f527c0be9b2393813e7b55cc0f5a1d3f9037950fbc53af8b0c185c411f5f880e0deaa51287a719fa18b82bfec6be3c1af461ac16f981cfe7ca86c60f8110e3ea286fc0da5dcf294058f73e5e3620cf552eb074a766e2b054493d12341c299afac1e4037213af44a8eb785b2b4bcf3e081c49b9685d3e7e0c0b7d9f4bb50861e4e97a83216cd1ead54f12f894667136d05abcaf09dbab318ff0904bc0368e3805ac82d7df57b57a76ad048f8a5c11c11c23048cb810c0515f63d8e3b960a64fc4d09f8a491301f0eab4cfcc505a86df794c892c095af8148d84b48d4635bf7405dd5ae9f35fba1de27fc18209f8b924e0d9be53e172ae94aca3bb26dc07f650c12614c479b1163dda2d08625c1881272be2a36c6e63b6412a67d85d9452e5a126c1f46d699b1b1753ea684cdc30a4777a4e520ff0610cfc484ff24f4d8c29219f33f660737182befa6e623963890ff53ca1e3689e9a0509311ac7ad383a17f95a6343234573f5c62970c9c3fb948fea27f995fffc4e162b55896ed0526e9fe392c077da2082c68fef00e433168ae3ae8fb6109908f0ac9b6fcd409d415e45375f0e6213e16533d626911fb7b5360c10e328c04423a2ab6c106f94ae59e35bea3903e235a29f4f10cd642ba33b09bc7a88e4903ab6157cac5b255e161c43f252ea6d26453128a18f4cfdf3b68e8e7cd61abba085f7c9d99c20f4b9116992f3eb36331f599f6845c4a8825e3d8002c33164799075bc1f9f3373ff49771179ab89fc7aa56cc60af0d474390761114c38d71870fed3fb9462bd63c736966c78b45263d7d26e17981df2e1baaba9dda2b24d2bd5591fcf2892f9984d128084fca1475467d2d1da996848948c52f8e7de949b9e03cc46612ed03d1dae1c704d17998771ce7af4ef8fd1188882497323dae7136732c6332217bea2bf2481ea3b4e8a7cc0596333c5a5a274e3f9e29096d3ab72b3fa231d8415b2d65cf362ea20bf43e3141e62f7c3312b119d79d365a93cde83494ef914afe180b7178864592e3fb6dfbeec3fac5b8bf680ab6edf411335a55e939597d0692c0bee89402384896516361ed06470a3e325e9d9a4279a1cfaf0652067a2d413f0471c4220c5cf8e8291fe8369f6ec633c9f7d9477b07aa6a7a10bd1da89565df506f25718716080a2a123678bd00e1557fce34d72793f8d1885c05f00ced1cea309cc8f0c69e8003675230a0ff32a552f8270cf5dc81afbb35ecb5274655790030677e8dc96474a0ba38e6661b573a873f4b0d7d4f75b9cca52cf29005222cc8211e194710899691afbc33017e9d5948c1cad5592f100ef1c603d7aab6c80e486f191795922c5cd3ba61dfe254adb74e76fff95c03f6d2e423a9c62298941ba8c1a2a42a1411005f574783983b6fb1ec8758318f35588fa83e8dcb112ad1558838ee0693c06bcbb1a7ee5461f882c292bc6f415ef068a64a889c1802f195fb3db1526494436142a5d3d894e606c4c33917721928001a5ec743fd55714cd366a71774b0df8211fde296c86eb9d174b1347cd51ed7fa73309e72edd4a93e3502cf31b1bd00a71e6a0af65dc8e4030e7d4a6ee469a0c67a9bcb2e24873e972ddbea021d65ee11a67cd296a4e365a0fd13e1ded90f219181ad20ea7d3ee2b6e773fee709439beefd52efff063776bf24e57f1cb9e92edb54a8bf904b46f70efacf844c4415ecc7413bf5711a41c1e12f9044b6a882f900facd184f0abae86dfd84de4169f4c508162492d16d858ffee2df7f7c4bc6ab0b45874c700c4636e706a283db902128d610e55e1dd3c41c694bdc988cdbb592f6445495c64cff52e3e37235c3de85204f6775c82a0810f39b0968993e4b7b70480754cccf08ce92770d60062cd4fd68c0dda4472beaf89fb2cbae928892146d4643b8fa367f503ccbc0301a83c190aca98f5c878fac41bd25c9149e0cb4c2b6247dcf99f859d307ed7bd2af9f3988b1079b751967558c42ef424eeeee43e5439a00d16aa98f9a727c699f033a7cb2618be02738c043186eea545597050865c060f5b0a154e494974daaaf0daa8ac4c2cfe1dda1074565c41412902e8546d9e752d4c352a0b4b5d1f4ac3292b687153ad9fcc93b2c3035532c26a96b2a7e69c5f982dbfdc2655cb3cd1f889a2a08bbf883980fc41b454b33572fdbd6d9ef24cb080a03f8bb92a150f9a53c12f4b393051e0516cf233cb9583abe0d26385acbd5bc1e9c67755112a739b9534f4c00c9a55c6aef0621824767528b11e3c066c9adb185efe676fb347c2a860ebe8e58af54d300a9b304d17b38fa486ba36bb7b61cdd655091451bf55d2143e1ec897cb62a5d4a3456361824e428517f5af97a77f69e580dfe6b82842fb89d0c49bd3c5f36922ea7c890c55de4faf2e7c02282c159d5734bdc4c45a84f292c721f2f36461b9d5ef6c107663cf30426d4d1f3160d3f86e101dc7f1642b7b092e4c2ad91c7b8408935282197bf974c975d201e95b79634e5c33864eb958273f781cbc5c6a11fccbd9a306e048c6d425338965f9728ef992a969720747325af16b48884f3a87aaf8d438ac9bd906e97b82954ace7e2ba378db35179f949bb09854e7705fa1fda630ce122e880b457c68670172050ea4ca02f2be8743135c77d9e740bd26194ea78885476dd6ee42125b30eea87102aeb10c3841073436a7d1402c69206f4f0802f9baa8bd67f39d0c27de9db3a5089818a9d2fddb2c348a2232dbf7daab43bf5cfe4d2f73f32a2ed5c5fd29e4a36a25c8eb6d07421c6de2a7f485b98f9baa861050cd7ccbb541368f73668e93208312138a528bb2336d5671a429747517c712e452e0cac4c18d9503b5718c8d97d6eb3a5b8e5923ba106039bf4dde3ebf2a01879ee3b668d9e11ca3851ae06bbcc74802c2393c0c7996907342b4ef20606cb52a39cf591b3fe72d67a34fb3f681de528ed701f8a40e0359db72be58f12c337f8bc7135ad3f3f15385a6148d2255d7a1e5af3c5387d494c6b97772bc9a7b974c46576719db46d5e8ba12e6c15fb3e4294428170d9e4866331eca07f2872ae69ecccc33456ac6855200a7173fb0aa4fa828066652ac1827ea4810e6d5daa94aa30e134cb9c841e6d85d961c2d86c38019dac91487936f77e5658c3234b54addab6502b8870e91df3b38a00b3e41417f55f49b9a956ebc265b5722dd684eeadb3ba279d0222b78964d9e685846ea4a80ef7d10f575c8ce21b51a29e81aed1a935341ad84cf4ea799281e035fb2f6e81ea599950509d224b8ff372d1997cef86eae563bb0a3d887a737045930675553f9200e48c9dac89d21c1a154bbbf54cb9703f29899032d6516e9dcaaca79c75d2dc761816fbb6875ab6c22fb79b9917451dd6bf9ebf0ca8ed822489056a3befa110cd8f5c95225395cbf0157bead8683939f48131e5e76ee3528a20d8323ae619288b8d77dea8b9964b1c1b92d2c49c459614ad50190616339b8281391a5b6bee82f2f8d098c9bbbcd9947caf711366e345c126f6a2ed9852eea45175ce0c0c07d089e70b7d8ccd3fba09f3363311ed55904aeeddef3f00dc3352bd18e24c433ec658dbd02f3a013893885adf7b96b4e1d899bcc91e0806790dd4978d8c59db5d075f40e5744f576255bd7816d8217cfb58c35e4a16f4b1018d528fb3468b5f4163969c78f45a0d2d5a32a281fe9c492870eea5cbc3d9d5f151380e46a383add0c5cf1ea679fd026ee68f42dbbc53d973cdcd530cb381aaa910daee7822e423564a6a757f0160745033b92854ed4133523be8d1683d369b6d980fc590606b3ec3a3b201e6fa64b4b1e02d3d2097291e0f54b4a059519a7b1a4347a3cb4e288f8125d357dae726638b95d4136e5222ed1cfd3fd5c62329f48a0fea5a1553a2b14cba21f55dc969ad86f1d28246d2945c719acf5c590412df332ee4e4fa1dbf6075c46b058f1cd5d873c67333c12c91662062fe879d6aa0e4fe330ef1ed06c92e7a9ed6f74d8d704b79fd37f9343e76962267ce9b014d51604557c3cf429fb43690f4891801fbb738a2901c86a64fbbb08825c7986052786786dd5d414c32861f2ae4ec2e0d0438c6a146764632a3dd25e4e3791f9b3d1e35ae7f4ad6cd17f0e004475781549a9c971954390f3ef0b7d310ded069e6896381ee5dd8183f9d69adce7f222380d918fd70435e5088df77150ac73d820c7d353b6a9f9a8d2a53793063242643a17385555e0eb9163b147fc9be7e208fbed7406b155c4336afc7dcc7a671a89b7daebb6a8574a95e3af8d73b7ddd688df10d0c284a0afe6a64299ffca6beda704ccbd12b24b6176eb888cecf2219c7b0c04b495b334cbb7fb2d82648229856f71419bc62f494d51b6dc9937caa690394fe598f3182d11fbb527e12b1a8017aa004f64ad4dd2f9721d88a2493abf35f94b65d025107d0d1c7a466a08e90ceac13eabee18337a8869507fd1146680ae5c66162aaf64134957c7592c485eec09a15fb31a56a6ce48c54daaf542b2878383b7687b2e63a7f411eb805d1700bfc56d072c9a651448073615590c70eaacdfe158067512cc79e6e3261eb13d55663b82b65b18282c8508dadc1b36776b196890e47cda38bd521ef61fbcaf201f432218df35bbdca3be2280dca04fbc575b5fec3bfb4e45505e6f4e03dc5a2295f2cfdd929619c3a80a92d3ca9e799cdcc6ddc2bba412c43c568aefe0909857824b6176f8728627b898e99b1683b124c65c82bed4cf8e5f177a87ad263861a0ace1efa56d171ec5c5bab5a7d70b4b1e609e70733ff1a72eaf1516202ebbb2517c1ca2a5c44f9f7e72282127882a977cf64faec89a235592698c73bf6dd6afda36cc6f5a9f31220518e956b3d3ced3f35157854c4925006d22bb394e17ac656609acf1f69b0e8c6ca12d63b580cf1336f733e34ce992a713ecfa3184e506c80be221e500c383112008750e509a883d70e0875aefb2029db9689a9048ab9bd9a1cf5955682669f85e164ece85ea1b3296e62edd4f22654fb26bb4758339b66f242faf49621dbb644b5a6399ca344099d9fa48e17aa0bbabc6f9f2c6dd1147dbfc777f53df961eed49ddf126583585efe9023743f14232b1347a183dd76f3a45c5b0afd89896bb12d5b702ebd31061572c10f894cde200b654171027b610c193ebd95e82565b5538bc00f69769f409b40709f969a6530d984e5ea22e0f689912b09cd6f796954e15e4e91fe09a862fb2d35fc38a34dbaa978511e74d0a26011b121c07ff2dc1172a23ddbb6303233f2ab7cd7749f54ff2723673d173225d4daaa092af0b4158830397061b2b27565e1ea7fe2dd456994f32f5690afee26390ebdf8dd67776d0b53b4634bf81e2fe734580efaf1b8e96d5dfcfc51862e12273270167a2c6a8ddf808f4f8459eeb8c0dabf70f39e347a38a943e073375aa435a8b6e69bfbee85320a82952e32d3839f56d31d647bde2c52422dbbcafd0d416c3a80956b1a946dee704085f4266b0a1ba43d043a1a1f9a5a305c15351d9981a263f758ddd46dd4f5f7dad545b35ba6d52a844a7eed36a439734fa8ac5fbd02c2071e99211c00030b60ca0084d1bdee9c330ad85c00f4001e6d6bf884261f632ffa08f661bf35db96969a889051237bcbbd777309f508dd0914239d623b3a15fde41487a563d4bbbd77637b775defcdfd60c3180cb3d664fa51287aaf77d7bb1b932fd5c5342a7805bf53d74d267b8750f94ad783e8dbe5556f5dfeba3eba4eba56377bbb6b92e3e17615c3ac35997e14eabadbbbed9aecee8750c117c7a651c138f6e7d5d464abf295df2136bc826d64fb9b7cddb03b664366d1adf683e817ee21fa867b8c7ebdbb3e62f2752ac2a347f96b4423a625d2e57997bd2eefca7e5d5e67afeb9862ec2a81bdbe1bdac8df65c3dc1f3f44895e5f595c9c9edecaf920f27e9663ef2af8266fdfede554e075f1a86511fd3159723ea8264ab668717c1aec42e52d4ec3f2abb46039b6d1295a5bb438cdca555ae0d8a92156b00a8ee91475717f69bcbe2a6f7ae9d977baa961ee53b2c6a12a571c62217682435b42e17bbded1db9fbb7b82c5fb9f82ad7050f5c02eacaf18750b98b3777cab1727c1a95bb68f17b9a16bf2dee7f4fc3f216bf1f82a5850b7c67963ec48902c22e30feca695c541bfe62081bf00b5c6f8bdfe4ebe2aa1cdf95c764adebb29925d75d931c0faa99f9af7c0896ab5c72a71cffca698e574ec382af72161617c72c180fe102636c3b557f9323e7ddff342dce72f1f1102d70c4bfc9337366aea8dcc7c8d0468ec72ca52da9948f3e28d38629603fd891ac795506512a67c823396229bbf664a98a41a9a44962cbc21695d4c28ecc17f9932f4b620a841ab139383ed6c7e463c24c39312726873227f644ccc7fed4253144512cc2d86861478290c8217246fd15521b65117246edc6b2882145f4758f75aa5fdc920c6c1879ec44a15e8c883076a6e2651147f0a1961563376e1cfab8f9aa17e56a5cafdd5267bef4adeb32311cf3b22ade262a66091c8da1666248bba34b84b13145fb6e188e9457cf7c8142cea0aff5f2c93ee8a504ebbf7e4171f9cc970b27d72b93e0e8d4fcb513031b4a9e70e664b90509836921ca5c4a228c4a7ece0de4190653155450c8533221cfcf9c1a8f1d003aa6145812c8224c66b060c8510b39c6cb0d48184c6a000231d65c3df345093e3972b561244f8ee461e1c99949266a5e20b64c0c3420a6e6656a0a24301561e506e6bc0c19b173c74513368463a7a475b16da2304f368526b5276b9e4dbdac96b4256d29a93c6273e1505a7d35166874935c6f0f36543860202f8bc82132070859e3001ea6c6b14d727cfc04b2a625130bb547faf03411190a9b086661d60ed9b2e843968caa92216710892a18a88e3d2e35b0d1464b53c5228df1891d72bc8b0c1adabc0559289040598749fbd8a64c122986c35196d8ba381eb24ce32dae064663a634d6fbe2a519d85035b34d548c14065bc91c311f1a04ad5eabd7b5ee9e3cf29440a84b72d7b48f8d3eefe8e3a3ca99528b3e78a6009d74e80f5d45ff4c54979460c3b884dcc74153f3c3290575c91591bb7265b3edb4ab8b4c14bdbcb1f796bb2524d8f0cafdf71160e3b2648dfa0dcf5ba169337368d533a07553c919d9eb89e4199fc81816976057765d5886165556bd33131533511876591aa31ad81e206a7834cc77611bf3a5071c9fbdb65374eef0d2325ce24be8b3ba648c7b56ef4dce64c81821cdbae488645765a2228d5844cd5bf333da8ae1409bf8bbd7b78b75915c37ec93899cf1913e1fd2d19641d2bff9e678c832094f2cd4209d7b64428166e9922e0ac644d1e310e110f349c0cca523368c3d618c0d1c34350ee01181eddee9b7399a30a589053943e659ba71a6b267573681bc11e95abce88626f0d68899043e720ba8f524d2eb4938147dfb453a463a7612965c0244b71fdd2f8b6eb2f5b66fdc76356d6241a289f96419a536537b943342df5ef1862d19437be56af4e9294743db4626194389ac6a9a96b56b59bd1addb6ed35e837bc4d99b357ad46f6d0bdc9968c512d2a35496f1039ecd3c890af44af9b8659c7cea4f36e44f6b0d570e863b368bc62be2293f9729d0b5dd355f944d5dce1512ed1c0d277cc0e13e67b3daa5e1527cc37fb56c819327296e87eefac6bd866e4bbe876e02b26422126f23562f6f0c9be07760f63b7b7b8b83d729c8f2d6f585a2163843eaff8a25e28f039e964cddb7028a42787dbad87b887369abb6fe7ba6fddf6cad5e87e3d05e85444ce88b9eacc977a9f1cba538a89a2efeef49928ea44a697c3514262c319c47ddbeef6942be6cbfcf614a0f912f3f6530ae40c99b7538ec66671b766d775af31dfede4add3e6c6d5d8cedd9bec63eee40c9f522063580fdd30e58a6c552443e89e2c57b161ac6a6dde2bc6236f8fa21bfec81b0ebd87a4b6d96fdebf7ffde1d0a6e6efdeb4d8fbbc57aec6e71d7be7c8193163de2947c3ebc9db75514dd4f579fbd25b6fec920dacf53a7f5d47c06579de64e27d2ef1de24f0bc7b21fbd0354dfbbeef35e6bfdf84cf1ef7cea6660e6fa11a44262e59f34298bc4acea00fa9f6cc85661a96216364af9d3bcb4e391a19932caf092b31f19c3d7b942167c89cb964a793f220afbd86ccb2d06916bac936335f58868c41e911edba76dd38b1df647ac3f3c8b15e77562c63a63b4ed98436fb864172bce24d8eb74920634c26b9df37979439a031a714b0886152461f9b2c420e298249e3585da04523489c884a62f013951811224f6c3373054cd9c694b3bc917202bf028d2db438b5162da24c8b162c2c518685656525caacaca8a844191595d329ca9c4e2929512625050525caa0a0984c51c6643a3989322727a55294299548a42843228d4623108c32202812451991e8fb3e6ba38cb59e17653cafeba24cd7715c94e1b8d8b26db165ca685a9645992c0b85a24c28145b30ecbaa2cc75595694b1ac5aa34cad94764799ee39a3cc9cb145467e5ede486909c104e8a70a287c789e48b2736489247472884821b26c92c515414b9848f12325ce1563d12bd30341a91461bce28a44b04215991e063d55ec9e2aadd78609c33353071a4329c5e982166d3062c3f853310cc37eb09f8e91e590962c8324905c226be426251356e630027b2387c8481f1313132fb52ceb9a40b5704c471965bcf53246a5ca22d7371614f3d496b1ce6add1c88b0b5946d620e43582343b055080707e41a56a1cf4c17d4bf19b1218dd9b558b3cc14c7999219111acd71c26c745249295529820d9f290a063da57f31bd2813e7fc8dd6f5a17b93fbdad48c61193246fdbc8dcd46422ddaaa181e949cd5a2966559169667a439d0faf29a942b298388af51e6ccce224f6b725f0338808359b81034777a16d19158c43c859846e44924cf2b7c4cd49c3c988e649922c655cb25661892a3e4287e01e3666640cec9040b47004a120435ec4451038b0832d87440822c18c18a220b491822054cb010638cb2bb37dad87c99b13b7637a594524a29a5ddb17b069452ee1b1762f63eceabf21095efbd76ef09bd61e9cd25a0fb09c342144d0e4bf701239f4e3b03418ce9ef3d39dd996949890a9ec8f5f4c5fbe4f4c43be9520b96d2574a573979a9f4caed78711baed9303f14141b504c9fe92b5d7b71633295dc0fd4647aca0d6f72cab5de5ea484348b5cc0604fdebdc9f4dad47cc232640cd3eb0d5db2e9338d82e3448d6ebadf090e61e412e9c689d2bed1b649ee878d3b0fa1dc9de3be594b0303857af1827a1e087ae1e87b41a905bd172f6e9c29cf761a0d8c9b0dd7d36b2fb237fcf0c5855c476fefa581a59f3032f7d0bd4b031bfa80912b07235399b78d865b16343747727cc46e2002d01460dc4004202964f93b6d3802f7892c49c581a3ac54ca48230b8a3e8d52cef328776f87ca4f1aa651c19ee6554e3bc7d1c44e698f9daa9a17d6ea795ead9ee9a4e4795da779ef3c4eeb3c1c59f4d1e93c3a55ff712a1de90453b92715fbbaee386155a72a27e26ab5a2d368441ad9fa5315590e3c5591e5b8d355c141a3824fafb59eab1d47e34315444db3548612c98aa84a011d38ca4e4e4a99157db5d6d1886447b556558761d69a4c3f0ab579efea3f6b2b0571d0cdf36a15e1eddfbfaf6a15f7b0b5b31da992ba3a1a8d46231044a12794aabe4ff483eaeea24f54323d364c4a8aa9d4892cc5a12a77e0c88a4ea3118ac99e946c6647d64a1c22eb6d9b8a7b941908c2714284aef34cf5dc8e2ef33653ceb28c4412812392c7ed40b9a97298060577f7c07b60e76d998769baaeeb700ff01e281a91482452d7913acfb3342654d7ed309d8b3b4c184b795e77af13bd870dcda277dde8ddb59ee79148249287c3eff624d2f72e7e64459fe9a298ce75dbbbebdd5e2e9ecb36d3fd4183824d9c0da5d96a48f32b83165f70a2ce3ee3911b87d9bdec72cf3e10147d190e4dd144b1567bab918636b0db87ad4ba4087e66a6b86061b32cfb68a3413c5b20e5a1e5ded9ad9769efd7d6b2eeee5dcbb2cc46f4ce3dd3a8956937d432dc63c4d1daa36c949548e006825a9659dc0dea43c85d7b86411f344cbdacaf69a73c3051df1eb8043c466c27e7dd4d33ddb3a311062d16711d531c87439baa51aa510f8737dcbd1ab0dcdb02325b9f5a9665f778e4d6de97bbb5a91aa59a46b9db542eb4a959c371cba1909ce1117978641b7a808b92c06176a2b089e298f0de81af4cd64e940ef41e078410e00d6d3278d1fbd8d75bee3a3777cab2efa60b66a2ce70e33851deb6813eb64d2385b4921dcd9ef49d466f9525adb7eed4022d32053cef74020fe2eddfd6ed7d8fe0d69d4de313f813f8ed21963f7c02b18d981dcc0e3ec3e8f7ed8636fd6dddf67e05718fd2777d6cb97bdfd062afd495e8bb114923913a52e77d218fd49fd733f4ee3b9d2fa47fdf356aff99b87bdb4874b2ef814dddb9ab8936d2a5fdafffbdf187c1cdebbc5028cb361105414a3abde1e85696652f1da4b7fb4e0f7e7be9f6f840cabdbba29344371c611f5bceb230fbbe7df47636d93b78698f0ed35b1f9ba5f7e8bd631f9b8fad1d00848d9cc1143370828f2d5b40ce608a194c71b0061a8eac659444414ae9290ebb6f9556db3d76c39470889146f560b5f5ab187b2aaf44aa28f444d64fbb77dabee3f495ef60b94a47e9874f1b5ec1342cf766da0bb7c74feb28d52a3e59ed9eecbf6b9dc9844f169f729cbe729a130d8eace1d0541fee2152a9448f128552cff3a84769ad59adb56ef68638b2cd40100c5119040f5ef35431df907f1cf81e7d2822d2e9f41da313dea182a3cf36adb7793872d7fd2405e524238128267b52b299c892ac5da17693f1047e74d2cabfbb912ecde923f0e65059b122ec43a5cdaddb56aeca4f9765bb3954f0cabd4bc382e35576e52aa759c12a98e684bdae533e545127c7f88855953c8f69a284e0bb2190fc715c08a4e32cb5f6d64e6d3be9edb449a7a5531c8a9a36f77a8ee34eda28e57ef8fe59ee5e73f6961702c99cd55eefa9c3373e0d73d7b8ca719d394cb9136cd35c49b471b7d72c672d77bb71da6739daf566efbacce4c9effb6e770bea903d72a14dc665dfd7894c9dac36fc914db7131c3de68ee3344dcbce5dd2b37b83c4ddeb6e3df07e3814619bf6ba73b7bb373ecc7157f36c9ac33e7e009196069ab76d17512cdbcff4774578b30dfe7b87b189a216f7681bd2bc61edde64f086417253d228c3dad4186b1c961e47f4deadb2ebd63fd87ff8068edea3f5bebd36959c0fdb1b9fb4f749c3372cb5d76ebbcff2287e05efe11ee06ddf90721ee79d50d268e4f5d6dbd6ed7d1bf5d6bd511c1beb9e7dc320b96d08247b07ad873b7a20f9fb4c77789b280f7cf70f6313e5dd7bf779d47adf4bd2edfb3cba7db4f33c9499eebede28d5b6cdebee9dd2eddaefdeb0946a1dd5a6b6d13e958f2d1f6fc1d0df39cd0b92696d8be93bea7d97dcbd5b9a17cf8536f3f346948eecebedb52e37ca9d62fa10f743fda9fb0e949fbe43e529b7f76e48b377eaf0a7f23d05d7efd486dde3f70bb4debd4b6b101fbc537cea4ecfbdd60e9f72a0fc741a144ca375df431a3dd605c9b5b35564b75b7ac38aed462da5d45afa7978d451da7d1ea51ca59bd5a4773311a5d7d2c7a3ece88f6ed6729f9974fbe928df7142d9918225f8a8a23693bb386b6d7c7d77b96bf6ca0e7ff5745b7fba33fd598cbbaddeb54fedc41dfcc87e23909bd67ea6439b69efccc2bba1c69dba7fb728f7f41a84e68463a3fcbbddcd91627f7a6bd7c65d8dcbc20c64edf494d39c3c1a149c929e6ac319b50182591a24bf344fa8d0dcd5b0de369bfd13b5bd5eee9e69db7ec8b09da82d7236d43b098d28c64a1ae91193747bf60377efd96bd753876f70d8c391defb7743eef16ddf1eaeb7eaf71f3ed4537cb2a7f7bedd933df72db3f806777a79db876da8e5e11ea25bdca3f4ed3393bb9496b651a4a40a8259b6d18df39e7d0343d9768fc361dd6a287ba8de1f39d4358cc966fa0478b8628ab9eef7ae7613b5a139f49885425b88f36e2fc7891eefdd74b14e79f8a10dcd75bbc6dd1ee063ce32108719c8e049f76e77431eb9b321eea6100e79944e4a38fc91edbf874c3814dd8b273547ebb32c3bf8ed8a0ede1ba21fd9e3eed9789b6d34ecb7cbfdb8c16d59e761198e1385c30cd02c7328c3a1cf4c798ae3478e8f41fcb0a4f949f1d988c9d7f7e9d58ae5f0d73729babeebf2baaeeb3c7c5dc44d527a123d985db71dd2932befdde34a7ea661bccbdb6818ee339d92ef6e4da77870d8466c628a4159ca08b4e19015b6626ca27866628c266dd22ba48dd094c5b044aed6afc6a185758e8480340c860384a988cde9db68982cd8503ee1c08ee1207285fd66c523ca707986308f4ecd03e9d4bc69e60cb1c252175fb0615cd2d6112bc051a2042272e844d949a58ff53a64be504bbb8f9462be08315fb29989f326a6200b64976098b526535c92b5deb488fd0822c2480f84423f3a4513c0c5a01f5186cbf4fa44a04e94b1995e2a1165ae402f8970090399864c1fca3164fa5076215329852ca74842a65c963ac814479fa892a9f5b09deb126fd7bc3f36943a2af43b3586c416fafb043b846297f499424829268afee8a09a3cc844a9a53a211d580b63132575e4a9951b1882944c21043948304308da27b70fd044054d54c7051b4aa06eaeaf4929e62402a353856c222ccd3e5186abc2a2204e27664e9461c9fdd93d6530719d3913d55fc9819539081334dcb507d98e8368b72692b9c444293175e6763bae260f620b1aacfcb952d83851f28a896a30581994fb73620924a1882d7d202020a03ec6e44661dbe78a4109a494b25b36edee96e10e748724ace1880db15c84d6311912369446480dc417cb23c8f4024654c7c49656c2368e4e755eb9810d634c0d13638d189638606b20a22e53080af632c1cae7d0215afc0e98e4013be325cfcf2000888619000160dca0ba005a1ee3383cf5500eb18e43df7ed8f8882d3387088a066c3873a65c71df68e623ca649f8fc9e1f34088ac8cb758394bca63343d4610dfc5637f8fb1616450a772b827ed3a3cae64dc93864f3964dce53a72b80e39dc25870bb1e1321e5777795c692ff029870e77b90e1deee2722101b80e38764ac33a5caec375c0425077390521b3f65006659f993208c705c6f8c696f95f20266a3e07193776aa050e51319d9a2c388c91658c1cca1d142a0587bf099770682d883fdce1cc0396c31b96475c1061b55010190efb584e177ca8b0c72bb30a071c7050a954383cae04704f9dbaa7c6a71ca994000420800bb1e1a947ec12464b4b0b0cd461a00ee34202f096c7d50df7249fc3e32ac63d497cca11e332aee386e7808500e0375c0616c2040d007ec385d8f0183711a0c88c1d260a35800be3dae8d4fc0d57755b6e8c8bc3cd38dcb852ddb88a71e3ea861b572d37ae60dcb8ba6ecc03a83153b7621bc6c400f4c53200ae0dd7c5ec7a9eb042cf135638810f0c0cc330152a8cb1d1c34f8c12248001a358ec819d748a9e3040a6101335491e2801b69a31cadcc0fb94353632c6943f0d037e8a5aca020cf96a7b289bc8f31207d200db470fe5111964c5555d49ae069781c4969969c17af77bbd46c05bd7c8106c057ebb427440b5fa3ec4aec003a1848a9f6c3373c5272c6f39c87ca9a71cdbed4fa1930e4ff4791e0d730a611ddbedb7db875227f450e684b045c2d67b8b74f7547fb3e2eea9e209d07057756abec34150d8e3805cc38a09eb71b53d443d5b6df71e9aac0d441932e4c981f842447cc9260b268e9c6123a708220c378fc8b3a661e28a1447b2c995a27bade65db9d3a91bc496f9eb4a2457267165114964a2e63c42c3b29133e4084a105b72e8ca5c8361d95a12a2c2528cc3c6445d2558f9309b1a0c8a80c4bbf6ffdc4a7c7a1082247890a80286945236866158cba6dd2d553ba07aa28ffccf44c5989999989923e4e4d0443125f24420030e7549b17a58d775cd5f3c72c7eb560f375986cfd20b368c3e34354772297354a2842a72d330810d314a4513ba20a2020c83a80917801f20428250980daaa0e9a805d49452411c74c5c1c1c189a886b1d13895cab91a89c086126789d9b4e79c162a478e20c6e80b4b1c598279491c216cf8bf982d67cf77b71665a62414d8a9c4199ee059459410d8b9842a46a0b3924300421474565189108ec0596975a3777ae0034728b2babaf0269f6e5839cc40c630264a7e07497a70566d25923f471ffa5b3fc1d573f55cb5d65a6bad97cfce5cd26dcd25b5a7f6486176b7a58a735e2eb55eb556975a65b89c40c7d2c9eda3840db71c755a4746ebb44ef5913b5902c9242a974deec82676e4ce04ca5d8449c4c2049a4016106850ae3ad3886d64a241330434880659249e39ada83ca8a1cd933ba886a7791ed03ccd9306ec48c67ea8851db17ab6755380381ab3bbad6e7aeb5eef3bdb6a2b05a84522c8735a279d2b03d9c2575b97b6e0a433516dd5478aa38c98b47a685c92650e8fb8e4013c2a0f2be877af29b6cc6b328a177cc0a7872592f8acb4ee001337f05969549ec00849f05969b5e7a70547569ae5042c663064a55d5bcf112772561ab60149c1b3d2b0adde134d0d129940e4089e55454d948cd911988004243b44622044d5348a61d8abc51e0a65c65e6f45f7fb41cb189edb7ca83ececc8a6d990b43f7369bd1639ac5a4155c8dcad19076648a17ddce46928c5d912790b442c6980f61184603bbee0eac0402ca92abd41a4111180cc13ccc091802e8ad6953656b94a996dd588f6d974e1486d5502814ba7693af4b2e4e1476b2b01d65d942a0efeef3406fccd7e79b9614b8ac895dd69453f6b02c7cbaf1d97362cbb22c8c7aa19a2fd3b22ccb0aaf8ba27f81cd2dcfda018cca4a9bd2534a69a5b23695b9be6fadb5ce1ad82badb4d25a2b0cb6a2d9a78956276dd95d67d3ee39273eddb8c2be2c8cfe4d9b36a530daaa1f9bca6682165f8419a5216d02413fe9a7920833833a456fd109058c760eae4b42b752a0dc9f411d6d6d7a051b5e38b92b9389eaba24b6583d9dea3fd7ead3934319106c587d8e4c597daa143f5950cb8699ab89335f84c064bd62a6ba02a9c0ca26dd6448ee954ca9414d727f0275aa59a2b0a16c02947b7234b02c9bcc972c70e68bfcb5a467db208727d8303619126402992ff4dd6f988a598093a392152891c3d81395a8e08a091357f3a1b5d1b9c646c300d17303096c189bf467a6cc01d23038ab6e15489181f851d3ef1f551d42a8923a3c35353535353535353a74e8d0515353535353a343870e1d3a746056a5d9d1a91361d69af00e150cc334b15335db6aad12c73376fb7d1688873db1a7fba14caa4e81a3930eb2a87ce5a39b43e58461262ae4a715dee4ec212b6485db0f1277214da35aadb5fe264b59bf6119f2862ed946c3ad6eb20cccd95e10dd90268baec53967ca34cddb9626839fe91f7b4513a5eb94bf5e1a581819c60c7dc0f0ace63616154a555cb0bc45fccc2469dcb56ea41c05ff403ab7e3bb218cfc7ddff77ddc51fe5d7b7139eb9e4e180573971edf1e46b724fadda2f42b2cd7acedbb28f8a44bce87ef28f8548f727bd23dd57b2761584a4a4acaa9621a1bfe22936e714893519e82439a9c72edc5a9742747a3f4931394d3afd3c9c9bbaee34eb89393128e13757f724d076fc82393aec9cd0613a613755fdcb89ae97b4f9484618c4e718fd12deeb18272c38a7dc0f856e88a0b96d7d3b75061c1a1cc2a57b1d7ac8ab5a00f16ab60dc8df644a09d74eb0257fd66e572c36962fc86cbdf80c3553808ea383c48001ee3372b19f7242fe337ab1c6e8e1bae3acd0d575d5ea5ba0c1c0400573d880dbfe13738a860c4b8a1c58a2013c523771afb25777cb082dc30bfcafb53672a315fb61e1934711ae6f44e61d189325c6619819d79f495539ffebd61b0563daade84ca4c54131657465ae982275dd19da09b8e8e4e5ca5c4d549461d2327df3c651fddf4947bcab08ed14d271d2b4ff9ca532eef094bee58197c7a2ec98e53ee12ecfc699fb9a46156c209c40903e28a470d5e7918814ee4e36af430fed8187de561ecc98d250f228c5e4294913bb12507730711e6e43d97903170d00521c288c087272b57f248cec8c953ae3c5d693252fae476581c9c21fd8e28ebbf574c599749b4f46918d23b943ff2d3a7979033641216b7b85e4c5967b12e77a24c8bd8622d911b473c7ba6ce9da73b713ad54fb9132574d3a87f72a576a513dd133b05fad0c82e87b49cd149e4feaa74e38a74e36a74e30abc713564a56558eec49639244485c5b0c4012277e2e6dd78d343a2c51761c5e9e6e9d69945bc775c983af3257a98c5a2a9105b0a39c345c628437c41437ce9236223117b07b17d109f105f342a2219e48cedfd1e4394e1de2d3a0bd974c58b1332cb3b0849e40c1a19830511a6a65344fa501841471379896cc402b1a53fd7106180c89cb9634413816147c4549f67e6d24397f4eb82b7aee8d45ef2ecec441996fce5fe7c22a50925a223cad01314f9294293d026624b9feea89cbb31b69cde82e5ca23220c7d424c519f4e5135649ac54579764dff9158fcfc5891a3613ab9d65ba649148c541a5deb596777727a826e42a49b944824d98488dc44a0373a6dc22b92441699454091682659913c512672356acfd979a73b0d439774aa0a3983662163ace02574872ed9c9134f21f7357be71222aaffdd898488f291319634cc8c22a65a362137cd625291db9b40b1a53f9f0841c1ca1e9eef4b1a66a3594cda853c0aa91ae47da88fcc51395d79651228a66b335140666a1ee7e7e4fa285d1ca4db0316728604628cd9303444be9025164d64938804223662cb3c7861c8ef456c51cdd4fc8c99491a8bd8d2e76e8f21b6f4b7db6490319e1051fdec3615b1a910532e72464bf1e284dcef20c4543f0ba62b4c468022a67710db07b19188a8be75fb8888eaeb6822d3c8199d8405d146ce6822b7409f202ff1851cce1d34c4598688eab7b8f3e72ec9730d3175c41772bf81763ad56f2372bf89c8fd9d9db91345c5595983145738d13384123d4284a1064e044d9c23e008e28c789f997693b10a9ad812438018bb042b63da0c7194fbbac194410b42ad71b307c7449d64287778b7a7e9fe5dfef3b0e9662531695d550c8aa14924cf1c2c3bc2863268c917ecc4456822163f57f830a9a24891bec4b00c8aab89716856c8162a08c68499420499a4496654c3c8d5270e0cbc3083b4287a767777239948827690c8254c41f2874221c2483004fd04fdfc502c836415f45dfb72466155da54042919423e620a9f385f26206f83e509d8d82c7d105bfa920731c684913b9bcd0f28acf56a447bc368414131413287f1c746187d76421782854e8f248b7c801c95d820284b4e869e5d8876ec4242cf4e7368c7ae23f4ec9403bb761dd835eda1ec210d9be46dc8277cc427b2fc4c1256eed022cb5f3631280605d13c658eb56a1017689d97143a4a7c8ee8d66182c57efdc77cc18c881a4684636a9a0830b84294a1292da74882fc81d40167a36144efc7663981053fba10d149affff9a9a9694084912d883f3a37b042981042bae8f5a7799ad1c1d3902e7ae44e13e718611007618206bce83a48d8060e0262535c31a1cdcc17d90f0390e56d8833a40a628c3e6647a4cbbf8832f4f2a4fec804da9823d8981d6acc6067cd34733eb4c8da8fb78ef4a4adb15d5e9e6e5ce217b1e593f235629638a4f9b352fbd4dedd6f363314ea50167746091595914e8e99b19161a973d56031ac424dd4d502454d1d6f762fc8c15982176ee0830023da6d4c549f6a60c3c86363c665c26857990608f20307a771e41ef33e54f9d2b02f582c54354723b47d08eeb153563643eb4395352c6b59166ca4481c59e28989ead9d34f744ff360938707db393251488e44196ed607f1aa77337faad66bc534df411ce47b909b5588cad67462727227b6f4e3ec79e4889c3187e496526b91687411e95e0983251c4464799774633ad5a3eb7913d38c46d6da8b623ef06a7434127d640a32ba27bf5b9ff634e02df80f07b1074728d14d28d3e88ab0195baae4ce13d4fd79c57ce18932a1dcda73b6b68d63aa8285827c820aa89f9bb9e9c3710f4598c9d3a966429e3b1665b673aaccf950a5f05899b54f80f61139033322cf6f9916ac7422893cbf5db3b6d8309e05bfef8237766f573e617907af63748b858c22f81dbc8eef2016c2040de9e085c44e7d3ac07fffb01012963dab4943ca9f3cb17c42c3fa137d9f083cf7378c45babd90d2c15ba4dbd3906e71e920b60d630fdea29cc803ef8db090efa35b17f54b570eb10dde3b0de85d748969be8fb010fb9177d169bc8b70ec14f8efa11c228b8097c6298777f034de413c318dfd085f744ff3403ad51360405c7d380810f866f5b8b28f40a25be3ddcad8192957ce876885acb5d44f9e7a2ae4fe09a70f0ff3dcb7abcd356459a3bb7c8dce872a6fdbb34b6dd2d0b013b7cb5f903b3b4d828096fcf8c81596f1e4892d54d81096488e4c54b73c92fb579ddb4ce9014e963b71623151f44d66d0bc42c76727f3c1ce8e8f4f94b93f55e820622193cc9c91800a9c30740089945276cba6ddddd285ba58392af14952440335c6ce52e4f0b109108ddd48f639e79c73ce89a53c92e7e90d6dae4c7ffdba82f0ba2f735e71e412ec2573a80ce51902a28930f597e71ab2c441c835e41313d8d02501d488f6992977e6cbd430dd7246392a392f68864fb28fd91158ab4a9e248c01a358b52eed9a9846bb8957d42bb6a0601cb1e13699ac0d7d62d544c584aaec32511d635355a1abc246faaa186ddb3ab3b6b7296742b034dfd0acd6758955666aab1709565e073c2d833e7264a29640f54347e20c2901349b0911466aa18166048a2d68b0611fc97d7aa49768249d2476f7916f8fab1cddb7ebe8be5d88761d9c90ed9926638c38fc68ecec9eb28796cb30131ba23cd61128a04082fe749289a2bd83a491ec20a1d612b1859a7e620b7d88084b7f58320dbd4c2189f4ed2c456ca1a71963622d1c62cd23c40ca080a20a3aa0a2044248a1831c244890f8f4b060618dd0914148924c89058e13990faccca14492f9c0ce1c4a2448649034431259be590645999bfb210f6820f73128260a934155d8cbe201425225164d8276ac8462a2ba39196465108c9e257a7a7a7a321250613be7f280165f348f5944eacc588247a684953953c26648d896417c8999a8b89a1151fdda84c7090b6c189b0c6131c1ac41c87a6b96481aeb03e9543f74b1192d83886aab890ad5c407045fa062b0d288c61796437070e490a6e8a8740d97b4450b158d0000000083140000180c0a874342b170409ce7e2201f14000d8ba64a7e4c18c9a32087510819440c21860000000019001860b48d00628607bdae1afb40ffb997e327352707c5c08a31b0c6489061496de9c085263ce1ee420974353c2c846dddaa2970138d3b18366d0fbc58a44e6f2755c2a99ec67717316a3968f5c2933e9d4a07a9509afff7b4d8c0072a1b06556ee68ca99b16357f77514715f4bfcec3981594865e7c74ef684e03124c027f2215aada7ad1c71c1d48158e77b03cd4fc2c5f47fca94f3a3b503a6f068dc3a14d770f61384a75e19e8350a5c96202734b3c1e23cd2563cc4858b4615c368ac40e99074db6073aff19db91e526668a4a7072c223bd6307be64872dc40879a83d1ef899ce4bfb6b618c07a9be7434516b19268ca6a26f768c7541a9fac9b1395b16992975874c8297f399d93b2bc8546075c5dbb88b3094877b48c6ce5ebea85d175ac86f32b60086657cb4dcd95ba2c0381608813623b9345baa6bd30eb626d18c83cbb42ec939fb0fc90d535306a2a58205c5c511a1a5091ca9ab75e852704458f038fae6d9bf35f610fee3ae4ea846008f79f9c09d96d92200c10fc09486385854f58036b3fb8e650b2e1ed5cad70fd2614b82dbc82c225195a5c037425d75298ec532e34b3dac180fb07c17d37d9907ced04282a239fb43ab9e2727a1fd3026154f51b048ac9ef95c035f76782d4c597402d3a9d849ae540749b0f83a42a8d6d90c57e6d61464600f2a1f95574651e19dcef569e2995595c1efee95463d23adb4e1dc57d1a2de6e3917041a4677841e0d66b28ba49bc5175b51c8543c4b9f85fe166ed878dea8ab12655e8557bcb1afac9ea702558d69e64262721add1b9c861405efbf33ff7f7cd13d4cfeb2c795ac646914ad58a8ccfb8d15c581c7a7d40f073cfec2318cba85327ba13f730c068da5b202a9aaedfd3268591242487227c417d30b10c7591f0ac52c27b329bf3c217d124c148ae91b67433e3bc51c1ed8744d2289ab68817f53249a9e0e9ac40a71fd9266f51df2eee8a13697d6c8a226179a17e5640b9319b345329d930945838988a6d2b1c567ec232cec72f6ac0c7b9341589517e5ae624c635207b53de01dee30683cff6824f9fd8cb44cc91d345bed990a0c8dc0dd2545aece2162ac058f5990a5906c64d92d397ac8303eb0409117a34282b1c09f12035caa5027c31cfcc875681038f0e955ea9954fa93db312722d52529df8292fbf3ffac215e7c5615f635306ccabe11c97c65045162946e63c9057a3898b4e1b6782efa7c93a4ec95be695438ab73b740398d623f8d223a59820819336974526c021c28877a57bd7797f39353d1fff4350d8e1cae2164946f6acf09304d23b83869f0d0486503b7be90e812aecb82af5ca668363cd0a569900275cfce2ab009d49336b63c6a101e24932b70b82e239e16bfb2795cf7261e54dc7b53e49cced8d0e171a252640fcef3768e04be57755ddf9627e0143dcf5d536e1254271380209a0b18a602e8cf3f9c4d1efe12272acd42c954ed60825dca15a191e53d4a3a7385ba96ff26766a173d0794cc660df0fe26156fc029fab5ccb1262bedae6bde670e071cc74896c7f38fac9d5682547ace9172d764fed0504e834d9629ca27d0201d5c920e42c882c6485eba7d9224c6940e44220959dabb4a007a6eafea42f4b7b83cbf27bfc8705919388248198133531ffadcdcbcd56f9abc1822647196122029a7be49bc44c70f27d12df41546118e97af53939bf11e1cebe8340b1782d65e3b5875633abf152357bd10787073e6740d6ec3974ff5b4e4dc5fbab4a08ad7b963ee6b44f8f9e2fab6e2a120ac1ee66b8079d50d8bbeecea329d7f8f4cb4abcc816d77d9a3a407f0c786f636303394212d41cb90aab2a242cbebac4f6fb8b68f862c64f8995485fb4d4c566c09c6c928cbf6f4f4f775522e4f0671122003f418dfadeb5849d0ce0d775d16b852b500ceea511325f59d408aac02c3eaa75fdcd034ee001821539ffc9d73c79918ed6f981176616bd19494521bdc5834977e4466b16a8493e390eb3dfc251ff5ba78d2f1fed70467b114f50dfeb7969c8561238d03f4af733406d58a33b385cdba9062060e76790c65d4e4a652e92536c0249c3bbdf6cf9bcfbeb8a2317257cf0f0bf72bf651548189d29d586198623adbdb8329db4b4102da44fc92c9101fa8d40734f338817a3873031052d18e4e31cc6ed614822e4ee1fd7330e85259e1f6bbc3a49d534e4ab8b95882641385884e24e4cbf0f57a1551935c6c313910e4d24d957e54cd17522035c54238519f022732cf265b1fdbba166561e8f75912cc26d2389e762fc476b5eba6aaefb2cc6d87fb7742ab16807a8024882462a0b81f5f003e853a8af3760165530ca366954ac30601bb138321b6091c7ab1771b82736818a41113157ac72e446cdc877a21884d9e049dcf0a1c8ec227d75518a4baf78bfe9c60c8a51da32312b2bd00247b101c3a0c83b8677373f1b5cb4c527dce9df333139d690971ba4d263c570d21d7e14e22f70ad95a12d3710215d0c4ee0bcd3f475c2aa0550934d93feafd5052ab294d3885f34e0a33c1aff9f8442fcde8b8288da1144f2dc59cbd148f0ec47199e49684cc99fbf0f9d34cb47e86d0b42124188a2a9608fc1412ea4dfdcaad5a170a62428036542499f762a7368ea7b4ef9929636000e27ab13cde83b4c686b35f60d700d9b92b8c81684a068730b64dc00007587f7651d9316341b6707be0d78ca87c031bc46f60ff0a6a3feb8fb1b15d0a8b3024a0c20cfa818ffd458f5f386dd84e71df6b8561f86bfa9162384394a0fa5191dad7fa402ceb7eaee813d7e708a166012100651a13c761f4fa95355414d5b00e99116730ed2ec688d398b195c8691212905c3604e4b3fc171aa9098f86281bb1f2fcc8b79bbeb33a876a292bd1615ffe92f6875e6bd4e92e30350bdb859a6a6c30ed5ba14932b74540e29e3393735ca1805634b22e24f749396948c614e402f7221eb8341db72904d642b8e90f9d81b4c19e7dc8c6b9044f37755eaf65836cb796b7d5b2f7a57e79e95bbf458694503e43010ecb7e15194e2e5e8abc69d410e9bdeb47da050e3cfebed7bb28d6a0eda9dab852211e3f1c8aa61d4a6b87ecc2c0cc3d96200e086cb06a057355030262593a3aa3aaf06dcc05c091e4115da068d87211e456e48e8670f61537cffda54792aaa078bdb8a58f804948875811c155f0c5c6bf021162b14b78f017ac709d942374e81675084201990bc04711fa700eae9bb4139622beb02511e0368077aeed34718113eebaf255c0cd9e84897a0216f8f0d80439c42ce08b641eb4609550c1a8dc839c583a72b46c259c364135cbf95519ba2e6c07bb1126cdebd02c29e35c413bc09f3d2ab7192bd49dd8322d8c41e4246273c63db828c8c4a871590115d0c47233742654423fc0565dd3f745f59ad2800020eba82f74049a69fbd2ae31f4719b8744594a360c7053e621819262fee971119ecaee6417c5a2e40c984f8ba0511ce55283841a48ffdadde6034f69a0481da5356d607128adf1239e86c8060ae2ff24a230a3cf6869e0c7a1dacf47a5d7b523542d17349c9f5512b4ed8d9273d23684e6c953651c35a4aec9ad9d232fb29ec33f26213e242950131f49b21870cf5d13e943f498db245856e3e20631ef9e438027d07f35b8f216871591b2498410ff4cc5c2a49fd6cf44928ecd20a970d1716e4e060066dbe4465c5475512cac110eaa9ccaee36bcce727f7571b18b702ffcbf630e2d839008d363dbbb8c04113077513cfb21d616b9e8a57975615e217b90194a05f6e20959125dcc43562ac889ef8f15d87f61d35acbce8484a008f1b3addbec08bafcf7c5252c390ea0102a4d8ad9286f1c33b23890c77628a1f1ede59e88e41df705e8c7800435e2a33026f0c481eb8fe318112365407d4361c47c2fbc6afc9ff2a0eab5312528a3a090eb894341c9e9a56c496620f617703bd1dcd92d05b2eafc65caabc42ce362a121fd3c8fbe59c3263abf8dd979c0a25ae772e1bfb55a153566093f4dede7ecceeb347b07d90ffa5c990a1226ef0398666faea318efe3bed2be149e85db476684276718c4247e04f7970af61adecefbf5d971c639af891e5e079eb98e8e3eb27a8d1f540e37fb815a27205661236db8425d2c749e1a7fb1edad2cd9a9ce07ef05633e0be4c8018196f2f738e1f1db99e8a3f21655858e9309016c50007f9f38593bb32b81286d4ee4771a64bbc1b59e259b467a845383acd5d51a285d68e63e56ad0c58c1819459aca1af798c53cf05bf7bbea429fb01759ecf44521394c9f69b1c1edab754c8f752eb80942976c1f2ab15ba9f956d347d036d9fe6b1674dadfdf48c127bb2807d227612c209d8c370eb07c5297abfb93d671c7969004f132f4c01a378483b45fbe74bc9dede740bbc3a04be43c19e2f6baa03f662661e28360803f26592a234abb6c8852f19dbb10db288c75f89ced5494a66da9eb9e44d4bfde85244d64702f1182a9b867d22b0cd8690b37ecc1ea0532650ffcc3a03556e49cb0ebd03d5851b10fa199244231dff624088c4a9f6d8f622b14646a672e4c6fba9ea28bb27e6734922b49398f15d37ec9b6ef7f94916abb4df63e5c802d0ef67289a5d157aab46832c5f281bebba26b1228b94baf9bf8f8240c3088c86c6f089da104c7106f78a3d13aa6918e5811cc74508c82ee0b472d6e55421d64ac22350535c4465ee37cb3d1d062ad3bd5e960ccfd89905b62684f9f063c239536c8f370964f866e7715ad2dde7f03729dfb203a4849d3320dfe406bada3363f2fe0e9de3d9a1928d06932471682d598db0abd0e28bff96ffa41b966c8b162e335c1ffafe241bedbdcaceee3f695c9bfe9381f35cac15b0c38a578a0da2760fbf93f4eabd2d1ed969caa04709f57dc274de1b35120e30cc68825660a31e2a5134f749b2c25fa4273d21a51c7a8aec8987a9780c1a4c69440a37745bf360220bd646fd06a710c3f9be977b793ed9a10a89372cfcbca3175001505b4f2dfdb4dd6c00fdfc623299202b95e1492935e4eef5241c75919cbe1d62ef7d49dcd22beda0da22c26db1a98c3250207254f40e2ca469788abe28e60541c6219357e7cb6058521b352756f68d28c883f70310fd94e01178ca2925848cc952f7b55fe3f5b2e00592b4a3e900032d46d1bbd40262c05a78ba3619e26aed24bc4b681ff97e0515e909e26fbb8270a4c9d97829df39d22f1036834d31a7b06a9a398f6018cca5a04df981a30ebc332ee016527a101bf9f537ac8ef50cb5bdf83d409fb1a96d72608da24b9993687560c33879029266a53b397bd6621856e510280ae19da8dffb1da775a51857979aee9c1b2812f7287873e8fe6b8fb3f95dbb15d233a1f3ed0a818ff671c3a395ffd9f954674800c3af45f2d94b8443dcc1f3104766083b71082aeef22f40e8abab5208af1f79ebcc19fb841b0f3c0ebe5ca636a3edf111e79404ff15cdb62c9cfc5a3d39d76d5f8297a13fc11d8da2e40ddacdb6f4ec0b52bcf098d0b544405b1b243131c23c0d48e9fc7e7c5febaa2a2875a8e5c421045d6dadf5b904944468f5a0fa93a71b5c41dad3fe19fda92723bb4dbd86e4f7f3429e66fb326470daa4d047c3eb23c1abdeb3bf91a16b67e0fe3ec023f76fc99c329c2ba05d75812b313250beb0c05a049c04dd74f9222db0bc29c14a2fddf76a60012114f913498285289cf7f96149c1e66bf8ec66201a80ba7b479d478ac6fe18aeaeb96a692bf36547c78ba32e97f59eb52fdcdc7f1cbfcd9677cb896fac05b718cdd3492336468dac9da2705b63d08ebb5cc8a9e52983358621c5c3ab6701d80e7480fb10966b6a3624d1a1bf94f7862477df7abf62af5965f984398216d8f4930e3c6160c0b9c9bbb771c5306be56a5a10b07973207dbb42afdca03c045241077a37151104085067f980f54cc70544b16187d45231a718018fc8131182f3c429908e426e7b8ead2439d1d4761b4d516dc89a71b6cee25ca89b3083944b19268bb4b51a2c3d49c020d9b1d1592297553a38cca8644e2231983fc526bd7f9a15cb36888f5f08a6a8e21df4c959b1f6b6784d8dbf7479821c47c27917dd804b79cfc96986ec1df61b8bd04d7637ab6b39469a773acce47ac4d34f072c54466c978692a1e3c85a7975f90fbba33cc38b257638f1069cca3b47ca15406fba6af7e8ed127de7f3074331f232fdb18f12a86e29e7f86ed692c710c6ff74e07ee390268572264eb0df42e504801827821136c2c20b0cd670e9e92b5fb730ecf6c6abe183253916875f1c37c40f035befa1050afda8adb3fc28458aa113810f2922229e229f08c299d4a8a8ce0ce1866d1a0dcfe7bb27f21acf24c43033d295ea8fa097b94c83f3816eb19045e6b1b39ea906d251993d53d55480db661563b1ec6b0cb36d03e55a016cdb89292da34e08e179e2eb28818d95ef5b881cd035c3dc559934b9d8bafe4bde69b865cbd9be2ad4ca7fb234274d95a2b7325618d106e54d8b4ee736132f0e0854727c15be2794b37c0414a54d89e60cda5c7189f213a28025646c555f2640759771a6526538db1c2a41c3f95e6e231ec59e6e0c64a3f9d590bd703af29e7546f8c8a4d680e8bc4a756e0557bd719aa0a885a4583d9b1653f6e01fc9e65b225c12333a3709809e431f8327cca9efb862253c64ca2683773eb78eaacfc1c07bbf07cb0b987f0bd82f2ae3ed7ccd3493b4151d7748fb640b8998478008edc8ea9c746ffa54703f235349a9f040e6866b1989113d064d0bafea15a88625ea7d09c923a8940b74944c73bbbdc9ca18a3ce4ca53102436e24a8bdbcbf7e2b9ebe3a9db201bacfee7a7fc532af8e73a1d7f5917f63b52bf9c36cb5da2c5f4c8d90218b390ad98579f7f661c2afc818015eefd707c9386629e8f4147ceef50e4a4a9de77a574980947bd891146c0f88fb6636c1025c3491ad48395fc1104b4f819124354c26347a5b03230cf0c0eaf54269bfbfbc7cf3ec23480a6a9909c1727db3c0392993c332c9efef8565624840dfcdfef80681c5d803009cd2abc50e0d33a5c120ef1b93ae73756945ecc203967f25598a90c845c2049f5fb8da3bb952187946c820faaa7bdd84f24bcf7d6b3cb630d2302aaf334651025875b762363f3f0d896c0fa43bca885c1725411b32619c47927d7cbecd6e16e4bc216bb0c6e8fd85fcbd9786abfa4fad9f0803ec11dada9a971a319c17e5f4266ac96251ee9a30beb28ce8d6cdfbf7c25596a48ed12112499580306b3425989eb52ac3439b96916467af337b6d6831de854af6e81884c80e187b9975ae6ad9cb9779fb310ffe17c9b2efdca7a835cc3532883e36c444b9909910108a65e033abbb7b050431f5ce27049108b97f4a3d8b5efe5e2fdaaf340429b8e4c548468f1bb312b12832c1b8dae39db1a438b51bb4ef492594664aee7e694c278b8a7b77de51fabd9fd938265dd22289ad49c5d340939f9e950a7e0d14473c7448eb6bc8ad2131223cdce37689592259ed4e6dd0e32e8a6344f88928ff66a1f5136c9c4b980693be0de0af7fa5cb0919523d55078a17eb8efe8f6b5b1965d35f5ef237eb8e46e2336cd437c57c892393259f241705b7bee0dca7b7a80cd073ae8aaea5d8a6dc89dde5109be94a2ed11b35b4d8cda6f8d61c055492e92517aaaec534ed527c0fefb482c8a2288de0330d6ea5094ad2838aede9c554859fa0c22623d18fd120166e49ecf970e63a1357ef70a7c830a8ca64cba4009d94639b29e6c95e3925f522bcac6b91b4d5ca75ed383f4dfb5063cb3bef9ca551454c044d29f618100a7ec1a78ab22582ee6472829230fbfde79cd54fbe284d893b5e5e2742b60f43b91528f91a1da137d64a4a9585be30b30e8f77eb1be799d8097a8990c6ec04c9d6f7f1f99e8678cc4f21a26f519aa3c3a16091fb9470f882a95957ef828c85c6415925cdb80b4b08b706e25dfacac1748d2cf3d77f96db445be5aacfd4ca5e755606e2601f042c45787794452f91d7a91bb4f4c5e42861d542b75ec6a10017436a247dcaaffaf751cc0389bbe19a40991c3c33ae166f0617d0ee1a013c49d5c4159f1f068f1456acbf894413f8330b027bc5845d93c84a5666e2943cd39b0f4dca5e87e38cbc53aa5e904d6ef70bb21f0b6b2b3244161b990d808a66826d04eb60f50da8d071d7f47e4a5c3fd2d9f7b4e1e0d8c0bf8a96dd7bf4b0d6c10ec1fd0aa18f524d97939b2749e4be3edd4a603afbd8be4312467102d1c5ef0f2107d514bfe681f5d5b64702bf0d4aa00643d1e13b30512ab8e61400949639ce12063e6dd402666e3ec437a24aae3e864835d4fc6fb38542625f60d5ab26bda6d1806e4b70f85b872819906c3a43f5a23c084962958adfdc1eb9a84ac70d4ad690306ac0c33ca56a76d1bad5bae88feec72256ce13578550e1a6b895ad964073ea0c2d571aced296e48c92e1fb358af3f810656a0da77c47a681eabe1c36069b4c7b0299b0faef33ff828eb1761f7f75e2a9cfe921d882ee73d262050d383335e924e0588ec6265f1b380b7b3957ef0c9ba0af2a51729a0d16484c9263d7c2a8e960707416ace6a1f31450c8263c3531beb2ceade9f05737180cc2723685368ae1302cd054111ad9e82bfb0ac0054c1946e81c720c8f83345d749d29562debdc520d595dff094aecaa3b71307017e3665c50f5044747a4116feeb6af777ac391d60735d04739d6b6ffe42fe970f01aedf0d308d965cd4bcae1083d6b1fe7428e8fe6e6003702571e299da69044f30f6547cc7565be556c517e9680ad87fbd339b48bdd93afa66873ca2f0e3355801d64d7659a050b7704fe37acbb43a237bafa8f573facad95cd93aeb74e850ef383f866db75ea8672014e23d2a1f217e984d2e8c1ccf85dfcd9837ad3143d3931867fd56d91f118d5888c04267a79cc408890d8739bafd490bc3021d5738497ebb59952fb28d18627692b51125a36858dd7f121ba7b8e2533fc70e9959c0188057b24c853c5597cbc484fcc741d16d30d35a69abf55471ec44cef6a7c28e04134105488fa66a503d20253310828d89aedd00137d1c24a6b311603104696dfce1ab0d69729d676acc8613b8c2e718e601debcec66092ee4727784e94355b6701d42de6e0605d90a983c6635a74dd9027bc5f57b969863efc1f6328fbbb1c8f2f1237382bdf13c01b1a68729fddb928b73a23e579b9d60d9f6f6a13348218f7bd20819e9a9293ff7c2489e4a69f98f77b12eea61bb57df466960334794f41589fc96261f28e7cb3c807808f18adf09c4fd3e6dde7500590712400b0d3cdf905a24b1c5bcf9a63134aeb1827d71debd7cc6dab84187c7e3c379847de41a796567144b00893d94b39df68efb733746b0f8028fa83640f158ed8b40bda609cb7f53436cd55f9499a6daf7662cdcad645e721b0813e3f4bdcb57fbeee427ae10ad2e9ac1e852588cc261603e8b984f5e4e94f3e97f9d8b4f6bb44d2b0ff7e9f93468a8612a24f0da13b94874f1a0096eb23763961a99116ce80cd3cd1ffcefc8ca8b33100cdca2f4b0091a4c05800a4a60914debae28d5707451154a325447d4cdfd6eebb9488225ec69cdc962f93b7e1f952ef5c6ae8f8326df8e362d6c1ea2efffd7579681734c23b637824883943b588a757eef5de1181081c07495c7c3ac01092c0baf4d648a54adf7ae347ff9c6359c213b49a81a795f64a14400b5a8fbdca5333b80122195d96709f8c9e3042c2063c8587e3ce9fcd1c3ad0527144b2d99c95cb1966b8c2648c9c11c1a30ad7c5bc46dd168aca9d4527466b2862991613f10fc96b8b225b8bf5a0c941e0a7a47ac3b19fa0f02b888ae93c6afb0729b52c1a3bb038a8daa25b73695d8ca4a960331a65267c0c13ccfa0f234134ae8696bc7846e37c744859718411a7658fecebf6c371d1ba114dc6d7e19e92e2bc772bbcf076fefa78ed5bf916c7431490e0c49801d2eeacf3d8e9f6bbbd2673c7836c4db574eaa25fa0626b82085ebeb8721e98dada40716b49bc47c77ceb46a40c6ed8e575e75c3f96c3fc186e328050d687e57fea9586bdefb1f29b32fba775fd5f7b2bff3f5f109d243b5f45516ea67de051c45719003d14b7940c4f5ae016faeaa00e7d9cf900309370f48f76973a6d41817cee190c4377c18e37639673936e865ca289b498a64f1457e8ad064151e87ddbea0268786fb15624ff1b5027fcedb9a1c7919856653a2fcd76f5286965c6b5c284691e94edbc98fd19cb81d92b1f11f9202464084cd3a645814e0d0568396e02ca72e64709c0fe891678b2a280d78ec435b5e65cf80faf27b67b31ac960098bc9f1539f5ddd76829adc8c84f529230d97a601ff8831dadf23a927826b169b4fa450678ae6876a81b05168381c21ead4a65a8475b657e12fed4eb040ce8e4358621e61cbfd79762478f948c4c98d90867d244b10dd3dd917c844f111f683a39922a2ed0c5665b1f40c17c21c4f5e34d4ec1202892fd68cdc390336fc7635f067121eeff5894d696bb22615b9ba04b08aaae208e70056b5cfb3c7f037176951f0b42719a1871ae12635ec3faa2740cdf1022a6c7597d0d09f243a19b2320c4e4d94d6e1bde4af0e310ec4796b178af415b80ba4780f045db65a3b8484f65556d88be28624466a675d6ed55844afc335a9b6a35c14d5218257b5bdb2bb28f481e5055307a4792da78ebfa5e5bb1b8aa77c55aeb27c515ce57739dd690ed3b77348150467808aeb64dc2252d8a8cd83222b599a173363ae9f40c1a48ec84e93c0009f2acad20fbf9295d03cc597e28ccb27022f861b8e0d895b28d597ead89ad120a269cfcf71567f984c1e29071bd6e4a46f00bf793a16770f899f2c5080287495df92945972b825897c96237b2d42beffe64621e9068ea3d83d6b75930d57d40ea0fc88dd22e5d0571ad8c181ebc05d0ffd8c7aaea29eadd323c57b405ca2c5045ff53aa3b12870b42ad5af5c69376ed4c128213ae66dbd9ec3d4444fad85a7075513bd444e0f8a7250dc0a3741f2b4af687ca3251e9acea3a5687e4748f00a06e4e490e088e40ce20b732a3e7ebeafec9a6711db1fcec9333660171aab313aabd25696dbdc6443e820a5f1ae43a3a9f411b321e0ce47ed072aed688ba36cc6052fc231427974a93e83d91d25ae8d9322abfbec95a875df97fcf56bc679ac7f062584d3f244d6e28bfaaecdd78c8674e88b55c2c97730906c3ed27d1cb97a1566b9f0f00ebdaec9019df914719de311e1a98010012b04db445539417487928dda744d5a72daa1986921f625d0282e94fb8e671d8bcb76380a8d475df23d3d60e7bc83e2361d860be83427592e15864c454eafee81397d5a601ec49a5fb5e79ba18722bdfd556f7978c0afc7bd15d0b01b2c0bea72af2383dafdb9f2729b2d976b71f28e8ba86b8c6e0bac7febf26b6e2550aa2810f2efb39781981ce990dcae355caef5f80f62824cf324f901c8011b404c708997a1ae19864e3f11e050959ec6b15aca471b17fd62a46ea7625f4e1b01cbe02b3a511a185960a715306f3b6658e3fb2fec74a1da54ae2a8132977bcf40759617e3094457ad059f36a2446e1f4745ca015cec3ad6f1af4c7c899d258af398b07c484b9040e249e0ec07d0b7cc1a4a405824a1e440cec3814da7af763aa0c42854161e3979b5d74de5a4449886ff8c36e22859072351901993ca87422fe7ffe4193164b185346dd82b89a2f7ccf60237c3bc52241cf475fa2c073fd639869f07a89406f75bf97f1d6a2726f1f6e065e382f700c4b13977b02e26542bf9608668310175ed9f69ef3004ab41a3994319a9fceb397b3eded87c3942df923a102e913e92d9ade92d6e39c7a95b3de92eb6192d5d3e2a9e81df30a9b807a51a4ee4e89afef2438bd146341b5b0c21b863b821b0a6ef4c36d104ea08f9d294e93059400bc9e9fa5387ec31f9f1b81a21e331fa0b96054e9c554f867dc40223af5cba662018930334467196fa3ff599e0dab1522c9beacf43387b0cc8b34f033627e81439d3f8fa5ee3729c3f57ff6e937d0952150ef75c728b3e6d67bd9843482cf48f9aa1d004c24977b56aa024f7518ec7d283e83ba8f7e511f9c0f50baf1368d791f805f52e6b8822f98d9bf91bee8832ec104233cc007700b6cd8d8852a9efcc9ff5bc8fef8d4041207a7795af176472fb0da6aa9a85f8502b70b41c2fb70ea286a1424e1c84537da386753c3c2a96666c521defd8be2082768e90f1109e677c4c836819cc88d2ae85cf5431a0872ecba05c421d0c3ab473c0e2c0f7c63a9fc55839a70b0b93e8e51c25432ef1032f8eac30e43e3aeb7df872e8a87feb378637f7104746ba3b77e1a6b3304ce5aa88ba42d8532bf064a911589b8eb8436b988a4bcf4174a2066e714d105a6cc8ece993df3a6d91551d858603c853e88fe1ad59cb64540e0ff0cf53da6258c87e5862b8d8edd13fc1e4713fd16f2aba3bbd356af62574d3c0139fc55559a6066d908551a34bbc576e5cb688cbff6acd00cf49cbe1adb5c4397335d40b0071e247c903eacc0e4a68ca3afb62e4c4a650d775fd5e4a4dab5ee27883ddaab2a1c0b5dd7d1998270e37ffed63f220eb1c6d9915a78c5cd2b3954c3bf0bfae030874e8fa17b5bb59c141046e4c724c2e20daef4c82e1306484923990bf7185a4bb8c2ec5595accc2e99605b865ba8dd15e0891b57da8264a71ab3fc267e1a32d2054d1817993d6b596656c65eb635a8cd0c2bd255b381dd6ca1d73753f20b59178cd1bda4d6a612fa15fa6f62419f5ca5947a5f666d32d790e8d60cd064373654ad147a47f401cc37d800311dbbd2ae7dcfddd1f2f8d95de384d6efdefc55e3dfff87a111195be01a1b59166d8016ac40695e8b50e30e34f1ab02338901ae5f101f011bea97f90386dffbef87a6de33b64b6a6db42cdb134d1505cea1aba117bff7927b6d32c4d5720c8182f699c1d3cd073a68e6ceeac122c96d1eff180ece1303b0ed8c254501da78a1c2f1abebf8e9124fe81bfb08c84469c200b715eef0d7ffc7871ef4ead83eaeb961d9602769c104f6d37284f4a7a5a9cf13596bb34fde37151e8df0f21970a3be913f52fcf9fffed0943e4fc59275d2291a87cbf3e71738b359d5b7230754b68a4ce85709ebcdc98f4e6f52e66a02f01daaf1d512a416a375982d138696206c89f31568c8fad663078d804bd53f657de6c7287effff7de84aa063fbb8e646cb808da45d12384e6b84d0adef87febcf70c9891195d08d4e6bf58d1a21ae983a01ff8a0c4b1a59970aa892722f4976139dd51304fd15b291e05178d4a63ac3655845f23bcce9e1ed9eec8026ec74da1fc3cc12fdf59df342160e1829fe90286226758fdf284e4d6e286b1201e2161c1a7534bfee7885062c1960d390de077d0ac3d5895d8b43af33c4287b34e5fa7841ba73722972d566db4d9fd28276ae28c3bef3236fcb4c6c7466057fcbb73ab9b2ff250df546101e259bef6b91b9bf6fe354b45660c5b05c36bf9e78c7a9c7269cd1ffc7648b285d729240b1c183bfe36c9dd348def7b44bceaff1f1b43ba1e94878722fd1744e24097a2bd67a760ecb8f31b1d506085028f63562b716581ccce300ed36f9b87d78498bce9cc63ad17c58cc6da32bda4a63132ea3cec0de5534c770c4facdccfb73f97245a2700929129aa3e774656b18ce47f44f5ab4a89ca086265493e1f45abdce1cb727cbdfe9dcf90da5484788a7b330c3d97d01c7bb8d4e051b6a87159079599b4f04b15e7f08ca4bc7cb2128d018c2ef5ddf4517ae5f35f05bfee049eff138a9bb8a717997c62ceb77d91cb9b1f517c0a5aee084af9f7e22b586e210597d33a5d392217f97e95cbf30337dba09ff5555631668a87ece94740ed49f475b82647209a400fba51baa9e12efa475ad5a456359be11f2f9e7180a61dc9943d5ca236b5f9b4cbf7fae8be445cb1d189c310ae8275e6b24696d1ba5a9b2c12ea22bb10d80438bc79af361c4066492b3d4ee12ae3b1d03dad55f78803a395e30573ccaa678c54cc6aa92cceb5d90d5a90d4063f7794f3d111c8a413178bbe4bdec5937e668268f2b3dc8fd5065313795b6a25167e3aec9de7c9bd1d1b10b817bc2c34c375fc71f479d3051bf6b562e013f9b0f99c2f67a2278e4cb75a7d2be0c2075fc8b5f33857a54ff423922f4acd89f8ce79e3ba4fdceed7719ab91fc361b647b79dd671175dac08b2e50f0968619bac5659c591e35c8f6d3e9a935b8ab8d5d82e0f57bdf9fef91b9fd6c0ed88a20571c619c9e5eaeb955db03e94eb2b1a435876d38f8f767c4d0366ffe8963e8154ab042fc94f4001a5397150b12e169d154930ca42980c41945b31025369fc40b839c275517cf4268e84104cbb83a5e85478d22181537209e56d0d37fe4af4d162ae371aaf6f63991f8233d77dd2a9d2d66c9391cf7f2af6f972b82237780303ff0acd31be0bd5eb1f37711868d430f000d4a338330d917ddbc8f059abdb0581005e13fb645f1af29088ddb3457d2259898c1fc54c83b94bf2faeec7ccb34f40df3511c88549703c0b361a7b0c3261dadd19f960e093f01abc235983152a9e14ca00e06d9cd19220170d90b8fad7e87b68a6b64611dce2ecf05d54ad871dd4684cb57330e5c0a8b0350e1610fbc593125a338fe97949ab427fb3ae97f33d08e12e4d3b74302481691c06fdd3ef1ea631b3cd7ad9ea1dc2689081e4f609959359d9c5c4ce268ec23f967cb2ef53af6f9d04029f05f7fda2d4a22646cc26cdafe5c0892012fa0a6753407fd671c1a59d73890f6481300c04121e5ab354448bb34d9870c1dc3d69c75abe124010becf4b456b444d0921ce64463ab12e933c971a930ccfa1678c86b9f7ed2eec857214f463b43989008a5c165b0c24cdfeb7e1860990b7135fb8319a7ccfd9a1104ff3ad6b5d1aa3ad51a734781d1e33dfa5cdd0bdbee9b26999a3f776fac94cd39ae19914e0aaa0744eb422e9b98d84ad5fc7b47da148c88926c916331a1d51c616352cd4111ba3f3d77949347b844432210af0d53efeb1ffa78d30b3820a08ec9913c171207c56a86a4e3ff364a4e8774fcb1c30c85fcab65f4ee540469e1e85b4f03a167940cb6099cbcd566e6197dd6f7110bf087ba164479c5fc203fd6c4661836b4dec8808a7597d8ccd43dc086d3c0fc87885546b21b1c58df4b1409267f82b4c196d93924b4bc5885fcd17d97b2b751791fe64fa21c1044c9b905737769917efcaf510a2b257a2ed5d197f536a009bebfd82c5a3c754fa5f365daf2a075875d92c9df63dad3f2c8dd977803a46c7363eb45dffeeedd59bd2fab8dea7a949aec59f3fcdb58610d1ea35957e249b3ffcf39491e4cf50b9fcb75815cfa3a6d7b6eebfc61e8b226b054f1347bff07d3c681fda6709ebb1f54b5a2eaa087c7a48ae7bacdd8a6012b8e866ad8e25b5d271d11a369462582a686938b79162ca33b8581242c40f8e623d274b6b030808daddf556787808c28148457a3f4195d5bdd4c60d8ab9d2add4fb49c1d5ee8630813ddd8d4ccac2bcb5d479db2f8d0756acac1e4b84db705d3fc54d0f78c16d343ea84d8e4f6dbfe64bd6ef6982dc2814e19dea1e8b442784e86bccf37118343ae302e95a26005381d43b4846e5873e1c815c18f456270f1c5ea4fb9601d01bffe4718745561397f3e132f14df213d42bae99ed8b13c4bea4fdbe026ab82c345d19429aaae2c00f78dafa8a9799486c4faf4f487c91b1f4f0de324b9f580989d0631f4f74cf6d63f9dd727a94a94db30029a06770f11be353ff5e71d3635d47592fdfb1bed6d1cb940eebca73c01c0ae17d7b9b803c7f9ed8b1e333aa6deb53a72b804843a31d10fb74375d378843ede6186da44ee83be5e8de78db31e58a1180f0f7957d4e21e9c7e5ef046f6e2bb291205ca674ea22915aa36ce9faf73a856b63e010be1d8e9f5924f6668d2f144c3f3f35614dc808101c0793877b3f53a7f8b96c29d2c7281f45450c27a3b6f62ff30bc51d3667f1aaccd18179dabeff0746117c47247a905a4b564c4bd5d1e5cfd2b9667fe657498026ac77dfc22df02398351d82f4982f7741a6fc9fc790bd3116b210c020d7941f7404a4733e950453dd04a8e9bbe48f3c2eb3ed7def4be2f172fc69eb551431ab0e9b530c4eefa7b5d5e42f7f26c7973f3eee7dd5c65becfe7387d9b2ee3f6fa907d19c2df3ec01401debfecb1d266eec8283ab30401d17d462a667df3e920ffe9af30e2259ed8967a65921988c96850e4786da3f083449086d50c02b9593441bb72ba7c1b66455dfeecaa1c79f021e3ec84c1b580d928a2e3901fcc05c2f43eca28fbc12c3c8a33a0ab94ea3e53f52e270c024494b9010c2fc945c5e11b3641c7112420be99459fdc2cc9fdb7336bd5e13882d6c2954819a04a05861710c4eef55992a978acbef0e040a0408c836dbdbe4061a366c36fc6068e8bfd9c7ec889af00e72a81109b0482ccf257b660ee7b5d20f85fa8abc3333ad29e1a70f8d2221f6989fed0a4951e3d663374e388ce0dff6fe171507e53cf8a8fd3c85db761ed251fb599d7d7515a657a0e2400f20497fe7f51fbd8ff9b1b8c67c145738ca58c57b2cf38506a243370a3c71fa9d5637a337855a8b78cf610613c94c419447526ffe84d9226c102d2f29daba57a780f1831d10264baac003bf984b3f47f18e37c37cd455781d7b3a6de687af9dcf18ba8086f1228f9c49dd73818793ff97715ba3dc67693fde399a8c6f0ba498ba420cf2420135214cfdd89011f710fdd80af0f288f4061b62dd24175967fc9045203f01e7ef298092ee97d64b8db07fbc335acde38ea0e201f83185a3efa0d87aece6dc907365070ee5dc5e0e7c5034e9fea5a804ef7eece687d6f088e7adee2275b2b888bcf0d510b3ca98d550fcfb7811306d8c9bacdbe6109c66355965bcf819a678996009a8e8a10b41176a1e368bbef54ff0a128b2e8c2d4a52b31243704101d71beac519ac3f10aead0e9ec6a5e4550fad8c54151f35e5e4b5bba53fcb20abc57c413a2607db266d6b5be8511dd1ee54bf7c83313acfa2c606305f0c701fafd50b58188ffbe11c71f50875c5e9201f520aa7f0b6a9dada402fbf6dc3548b15317fed91cbea69c8fa3a1f426e206c5bbb3f7506002824bbc2b834f28bbbc6689fedb14d6e14ecafa532d10b8f328a1cecb28402affe93b5664f5302a76bd085d124d656b6ccab8b85d1ba21c287d68a1284777de096be4ca8f89e98e4ed65404f5293f966d179300708f97c7c2ab961d5e1202afb389445add2318ae66b554b8d91332a782e4e49e6a473fb79e8466b34e16d8f3e4864a31e53b98840a65cb50c01c8030c7952966618d8a530cfbeb29764056f2c168efc00774512338169e582347617ba91bebdf60ac71b8371066e1b3f5573d3c5df5641f25b57fcd4b572f8a5a9c9b5fcc57ba58778653173d5fdf71aa87e8a8e7e8a4baa0002246c176efbc41d425ba12db094b8e64c706865931268c3330fad6effc93ae9e662d2b99ce5b51c1fa265005f25f15346528ba902fd30a0e3066b24608d677a850a14373b904e1c38412ac7fe332266b245e166301a26db75baff4a675aacfea15b9c64cb9add13b2ceb5b588cb3e7732a8546d53321002a384013319da24ae808d02b761033a6ee1fc57d430c54b4a0f8689c344e9ee9e5a383a832c54ae5e65dab3a16fc56f200970aef5687587c055e35a41d4af49dca9425950c7b03fa04eb8a665c34c1802e257ef3df5b002ee01a709584ce6e7c230ddade4691b50622da9d0f65cb4bcaba29b902a2da60eae7a467a9e71ce51632795416d279872e267b26bbe98396b9ea6760459fe23eb1af443f024f4b47fa5a0b4ec2766ba9e5ac8701ab033b536335917aa21024947d324c04057eb812753f8b77fcb0b0d490cbdd5c487ff0c1b916fb1620e4d6353873bc7775b755626f827352dd3dfcca7057d05e3db356f8519708239e63ed51035742498451878dc444eccd3ab5775b6450cda8742de5f380548f5e769fdab294ab3b4356fd91fbf0a8bc10c2e7ad3e2e55c92156d046af0571d9da3b28d460074e35478c0df8d7902e12012f8c61454b8399232538206deefedf20b0ef564a4eb504bc379ff4fbf80e38d5fd03f37a8cfc3b853f7546c879aaa6d21c99c9962555dddca49cb2715cc86f28fc868ee023dfc724bc89f075d7af1d81ee88bf4fada419e2e6c016fcc5073369c186f4427417e150e2879c86112c13f61bcb9a97368832af2a9e06f182ad3556bd93b434f03e8bc507dd231d7d56de8a0de4474318f9b7a613ddb4357ee4b37be0333d0f2c8d747ec185dfe7f69b9084d5b6b53910b01a74caedcddf79bffd3f035cb1d900a38739d7f45b29e9f7418fa07353f7a3ff07025d3fbdba2621b6c7fa0569e0a74292fa6d792af2b25f804176651387b73b181ef324aae94168a8f4f81d318f06f9ffd617de22821bd28d1b9017c6e7bdf0ececfbf18fdfd7bcffaf2bbadb522714c3d67e7aa12bd20299c20507abc7e2867ca6b39d0c253ab94ad8ccc02688fc7a887f802fe5f5a8c284a3be640362fa8af2c55a9ab38e923c4246603c39521a751d04930b043ad947b5022617dd64ffd8982c3dc153abce2937d5c544994cd69a2d54302e69e97a99e9f42ee2003dee33c67545c6b4e57b6284fff0344c7dea9bad1f014b335d7d39e2a240b6183e17dc9a0db7c17ba5cdfce15eb1f0733d059251e390353211db06071e909907af6ffec9e52e02eba2def6e40e340cdd5cf4dbdb1aa9c3c257cb22930936376b16ef0507963a54570e8f02c7e0525e83430889f33ecfb024ac44cca9937a9bb746a8ccf279e5d7f748d8558a774aa7e3f2803f86b0715d49345fb36724d06de20f8b0606a18451c662bd35601dce441b86ef1907022ae11a7c87341f62d063e5dfd6be5dd1225101f5412d340003248945c9fb9df7fa265e84679e600a1abb15c0dfbf45c050331f43675d8ba296ff00530754fe991a46137c216298df5706588bfa80fb779ba20a3f1f94c14f5832e6ee1afe190a1708c773796878f9cfd4b5a6f6ef531a31ce784f5d531c9ae1cee7c6b611d17f328e69953199c48cf902f5a206865b5ebff55090c66710084e8f0372f80c51419a77d12b388c00cc840428809a6b83050a2a660e3e5367badc8572db4ee333beeedb0139d72e103c9d9a03ed7bbdca9d9a06f9a17d4eb714cee7ed62df778772e8a81896454a1cc8f58c34e3fb74a60b19691bbfa238691c624279862ce434b8ac9e786734e2fcdd8acfc085860cf992eef37b5def6085accdf6f284a824984cfa1600ea710114949735afee0951e9fde04f09761c5a8a6e9064ab8f69bbeebecc5ceb070af858e9837c0747e4511542e21cdfc99556051ac94fa44ec01cb2e14b5641e5e33a229dc858246dce5339f74ec46d44a5e1dc8b45cb5b51e075c6b40d395126c5883bb87a4c62cb13c2b7d9a25a47afd0de4122c6d15cb4578539fa51a43f1cf6721c770f8fa4e41db134df9fd1af59a4b74cadc5c3420aadf2e02024780ddd1e320a1af632b002aac3635e75000feaf41b5758cf62eba81783bb7a3dae55af842964ef46d1747390d3f1c80e774e42f53fc760e7da7f097fc231942e06a91deaa8b8d18316e7d610a1aa27a73a58cd04381e30222c033c3205769b4be4de8545371a9fc4b2626b4b165fa08a7d0262ef024a1724e06077f1b54c6c4ee5dd9dc6f3e6a22b17df717326f689cd014fbf1e14800f14e1d4b04225288265d303ad3a167951599b43ae2d0b0a111cbebefd654926a4774eec0d3b97288167f6bb27e0b96a0f82faa8b2e13d0d4b8301b16aada9478cb8539d3da5797ecd60206f6295dac05a809b266ee39965116d346fc8aa4e2ea0964d18336412a14d1fefc763590d972acfd70e39900602942324b7ffb2142a1abc461dd50717125d06b953373f88bb64c6f72c4d5ba14a740d68733a11c9a22f386979ceeed2653c5d5b13b61b8fb3c67560a0a187b443e4fe5aadf7dd9dac47390c4437569894e779df2b5a7f57d6a4ba449ffd8ac9438e11fd3c88bd327378b4dc410fd3c2358455f1a9bec3241dae84b3ad5b6e847c370b47fe2d82feb88387887595ed99bbc1ce21dea7b189e98eee403315b48fdc1dbbeae94f72c9cce4d8a6bcf420c57bcc13265fdc9ab4954f52aedab343de063298f3ae6d2cdfb5ddba3ea6e27dfbc07cd807f2f2b817e6cea1f9be30dc53ed779730973c903925c69df96ee75ad45c9e01bebddd27b72995eaf50f70be3c6eaa85dfaa490ec1aed418531475c64231c2eb5fbb9b070da55a27191703502c632eff3fb6e8fdea0fbd0866568105b609b9806587af021b0e1f2f827354369587d78b5e7a7db95e2146887f4d4ce1022c670f269a2abead3b17199fbaf0ceed703e06d6e56891d6ab642782e7708917fc252d0aa663a8c3e63d8b5deb91f1b548e56c0aa7192e82826544aba0bc698e10cb4e9d1c0eaf9bbdea40ceef248bf896f25b40c7fa8b762d7572d197f4ee686e018bbd064f29f2dbffa32ed90726d183e05cfd02a84767336a1fd7c23663815093f2ead7620cb68f0760f0c2d736c9fa79322dd66f5068770fd7eaff4da3a96c887ab32f2d00454efd616e464a4f3518491fc0c24d2dbe0acca9aed5fdec2becd6910dde915dd61956685374929a46573a2dc0beeb81cf90f799a1adcd1324f547d5650978a904bc17270f8dfe584f6d3e8c67a959eb2ab7b952bab14511e45922a05547d128d1ec686145c53c3ddeea28a36bf219e18a95800f6231f833e113c0c832e21bd480e6a906eae3cfa060f8831e3856be25caacc7f8e24f9d68a18cc001d85722fa9463ac83eb58945d778c474bc1713df6a0b7a00877ca660ce3842b31f2540288ecd9f263d6d4c5d7739a968edb4aa81f7b945079434c09050ccfb2052492239d0e509590c731dc1ed1596780c94cbce128954f3ed4b5f2f16a280d1c5a0ed3ef01dd9ca46cd0d9930076c4a36f95d15e4734f7473e9918935b63e9529d79562f4fd9876127d95bb6c3400fa97d2b756856e6ca37a645c25da54aa1d785afad3c78f5763e4af2e1b038c02e3e62dfa549d230206f6db499367703bd96645701b1b82f2dfbb5fedad839168767f3ccde49841f8d901be51c2369ffc9b86a7b57b58ea47aae7996c80ac16beb51ec75a8fbe390a5f1d566c03947540a3ab66f7c0578ab3c5cb3d1b599cdc572d6e425665c1122b3cb52f82073c679d6f8ba987c3c56c3aa3d9258e10eb988f595fadaf7a8fb714486cc032fb53824922ec3d72f13613dec139e19c86297f5b1b80066a3e7c6b3d875ce6bdd0a5e4f59512ae4fb5a830971e8ac84609f2ebb0a9ac0c1dfd7d7e475497d42c11a7040ecb5b9e4f9087bcdf643fadce4ed61e6c17aca59ea785bd7f4f6f9dc3eb675bda3269cbffc212d62b0920a4a947815ba31b22a7068032609208024fd1420b86fe928dcfc91cdd7b306f70a6c75397da793aa2eb240ac0499aaba8ed640acf6ca08ba70110fda1c68839b2796014ca340555d0ea0bff51a555d06b2453cecfd1c3fe040457be16ebc0d967fcd158437846a4e39a6d094294b018a2e3ac7d59e105ce86035f05c938f245ee1d730298cdbd17c55a4213fa39ea93efaaf8e0212750ebd525b97b5eb24dbaee862cc7de73d9020c85bc78cacd74e6aaf500ccbb657a9aeeee9819824ef74f6558fb850570dba49f38a33510ed58d40eb5ed181a347e8815abf4e7caf5707b9257554d49f0f950c76b047664e448687285da13d0eb8850b5fde767208872ab4b66770be68a5594929f497c64a65d2658f007b70c17ad8e28ca3949400a8b369b57b595bd78a5a56e12c58fe22ab7b8a15bfbc2cb33c4fc03beb67cf206bd86809d09b7d98e669c3eb26ba485f8d5f794d0046fc360aa4bfab02a50c129b7b390b56414eea376526659e01b9f1b923965c25b1404c98bec2b654576aa70b30214b4c6070acb71ff7e8dbf145b0a912a829940c6ce1cb2e8da003060d50118ba6de5946039661342c445000c91f4bdaa7a343befae0498e685e8c4be658eea3c939322d3177452eb0c1c2b39a13045d07f336216b33435c79aba815469009191840ffb406c6fb583434b3643d5d921c4fc5408de8e16430590a4e6681532cc1690ca642ddfc79104b053e859b4645a9f9a1fe4b27c7f07532d8588b512e0124326405eecd1c5377b22619c6e24f29877f6f36a0fcac1a7a3f8eca614067a55ef421497d32506443d5b1052f479eb164e908172796206286dd576049671a6ace25607663c262a0a2c06cc0246b4a1853f26e53f00c5ee4e3cbf2940560545c9ffdfb9c60f2daa22d0b2ac7977676e6ce159411b00147a51a42c7f7b4c9e12cb0109921cac212b9ccabb2e7b10e17f570e5f2b2d95a9e511a246461eea60dd847b70645d1eb8536d01bc0816dfbe3317f74785ced5409624fbd81c53c49520c4f0ac13555498f97c38c1eeea51ebd20fb2c126875911478662a22565d50071a8b85e560781b0b50a49783212c8c65af3650693129bafbab400a3790e71d65a16d62a00cb3e64cc0b36f22d665a666f73e28f8accc080cb490b026795f3ac4a49995f6f364a2c1c8e4d2ab97c1d2faf12f4ab92d8e6b6e35e2512f70c67ea236a05c55a67ce2e34ba708f324a21ef50609567d910cf2d0079b6418a758138f755a1e848d198b9c1a763f244436aa7305272fc5a708df17fd982ea707dc08045b9a2cbbf2a8a9f3adad3bae3046e42ac0654b468366e2e88943cf33a363f29e51c17639f5cfecd9916623415abfc58928428978cfcdffac16600477796885a2e3eb75ede17cbd1ee4d2923df5be3e94dea46e47261ff987827c74050368e6acd15aeaf17b8301f60905ecbf50274d27dcfd40cec0fd189d9ec6fbc1c61d593ca8701bc32de304eea365189ad683195fb42b7c62562c4391b33eb960df11aacd957d11955671a741af1fcd1834ba832506110a51453387c7d68f049905550120684db6093fc2e376ab92726e944272f92c54ed9f108de09ee8b8fc8762bb926c04e459b476d88fb4b9304216b5c2f738def7589368849250026f14ba30e2073c2b83d8f75f702318a42ee8aff18fc6306c6f73e39f63671bdba214045c8c508936db83d8ef349b7b12aff222a08295618f1222b40a2f30b3626fb3930ec2c8445f902d689761d7b71bf445006e3c723c1a40a505198e6285807898478a5d12763015ba061bea3341ab38faf0fabc9b8b1232c2ac4c5a37da047491907e910ff3d82c66e3320283ade7b87a0fe48aca078952b4af222fa48e8a59577c7a9d49e0a814ea0b82d1db792e2a218c9a7dd92f69d556eac2a221d430443c53dfb9e766a07821edd4bb66400be005511986dc2ded50aa9fa4f5a4c466ed5ab0ae34a944f40a6c06d4862b848df4b893deabd4920a8f9a0dd99345a665923bf33790b35ce07b64b2e8f3f6d2aba5f7e75345fec4630164643cdc5f41fdbfeef62384947023cc67375febb2cc75e5c83c21424a5fe24a15b511f98f2981306628ee197baf77d7830c298e7df2744913a80056b9d040aff9af96896fdaa437b7bb82f64e0ce61aa06c4b6634c180a6b0da2d68caf2c1e633ee9cf704655f48721eaf962494d7cae0e7fe1cb00eb4d298c873bc6d761568e661fee4fa06638fc86d5cf25a607ed1d53a40109cfad398325e70afdc48ce9bbb6f093890f3967cc2f6d9b111b4689651dc209879d00e4e68538da47a9f067d0a11f1a0ea353cb93a4d182e363d673b0d3a59ef13ec08ab6c4898f8496a8a09f49e9cb728284b1844df4629c47d09c90991d20069dedf75f889fba4704c0963e27c7f9a4f6a7d06162dc6ac10cbc07f4fd0e0200f34cf26bc24d782d0a026e0e30e8445e9390da239ff4f00486f162c45b86da762ba40fa36896bd03b190a50a06b04d0a05ecc379014f4937e6c98429938084b45ef3bd2efe03d19879148692429ee40dc9bb4e476511231e930bf054e5474032daef52d61adde609f9a84973890783277862188dbb69a8613969f551f6228e2714fdc8df000ec92a988d1882d865c8ccf1ec69b034d2cef704ec510890e845d099d999060f0e96b5a10e88d556060745c338533eb7d0b838116e555818cf009735b56cbaa26ee2cf2b4a897de93cbdb0d1453af75f5abd20e2619e15369dee064b555ea1113a1e28c6e516ef465823c781c9b073600539376c9db1a829b1b0e4db98fea241a1d81857194f9f0e6e52a1b9b09c49f46c8b08623865ac8042a58eb62ad996032f86fa38c95a5951aaa39674f83f82cdae16468429e2c3282c63ddac98c38666b076d704dcb4bb72bbdaed64356a8c56000b5453fc80ad84021dea26fbc9483b0bbb0f993408918de67402877a453224672508dd36972c00a78adb2004df56ecef3139d80ea9c2c4099563738dc152b7eede3413f938d53a7c22acd1db359070d4795498c8cb2330a5ae21e56ec9d6d66dc590ff49c0441879826cdf5d3f5d89c8e8710f178e135bc1ac8cb24de7fd23d350c2eda84b01a6214a746efcf0dae462686219c3805ff66494ec4d69cfeb7e608d87619f9f3d5ccbf019e5d228c6a1d9a15d902b60dd4a6d72ebd7a0c0eb6710e5ab013f0613faa090afa930898c25cc09528b44030d2af60de0c8834a51370f849cfded966dbaa61bf04d1b1d4fe485f1122b3e6252513bddbbc5a3b5264c759a49941f7d7e214586ca401cc9d4d4dd1bfaaf32350fc6486bb0d22d0e8851afa22dcd0dba8f3d0aa60190169b0980216f34252187a5bad08b7b19e2a2f8e59233f69cdbe925a2e8bbfa635071575e30fffd6d2ad0dfc864ee86d9bb14513cc8202aaad7f82120d525b00626a906b7d852c41a6df1c17bf1073e109232e30f3db957d7e7566b7de694d0c673754298e8765a9d97976f44cb0773e0566740a1e0489d405219a1ba19fc5cc9f8abef8b7423862d2779b8e9abb19b109dec7b5079a253609afbbaba7879a03da8612221f0c8a2c4c3d204cc7ab3a8f1965374388a9f7a94c1f2cf022b3fb5cff8c0a35d7ff0a51d2f902a295714621d819aa7fa60c1ed787dea6ccb3961541a26769039be9e9ee6b7c0f1469ed8030f9d64f63094c4ef0502b20f1fa9c513e65e66829b1e7936b18e9eb9f7c180c80b025c96d49c22feae016a16650a5b099f2c0ce4db4bf5b86c97467cd37345403060825cd333909978d93e57a066ad6899acd09c5c517565202812342cda186889f80391cd41a0799d657388749462d9ce25138161b505fee4938ba17770d04c3b689eecd51159dc0c02d0962a71e14e0426f04eef5ff5b22d4d1cb5546b1a58b26c0e2c2b5bfdbe0992c51cbd7767600fbad66e6c5dd182681fe9c613d68f31fc00bb00b39c681e411b2396d125b852c2e0adc29c04541354499feedd46329229b3ffd412ebc37646075fae66368eba2e237ba646c61e11b8e14e1fcf9abb1495bb614d1d45390ae4414ccc2c991e6b0a1c6fc20eb4e2c3dce8db1998ceeb607321183e4ddab3ec49bd2e94de4965f43aa0de3b6eb7632f8ec3d8ccfeaa33a502f7a015d0b79681ca9caaba5ad6d182d27101bf14b5b0786cca9a3ba025ef9e5ff4df7598d0462ed92cd46a0bab22793148cca27b85b1ccb470b05261f0c3a39c4406de6fef7f6386116ff5b0b5b56b752fc8ef18194ec4d799fcd0c0c6f61ba22ebb374a01783dee533df1095cb6e91d775bf1442c8ad7ac447768f39eafd2058ab8e91e2604e0bf82e4405b386e92bff7bbc11f1dcfeccb2ba3470ee5fb8b9ef2f550dec104b991c325075686ae4284589c69a07ff948f9d9e4ca544022a7f6279ccb2ed352ad4bae9e6e65e9bf34e6de1941209e93bd3507acfdab285d961d473b7b16d9d76fa0a5adb04373962582c83098551d512a6baddfd23ea4181e401647b799c38dbb9604072d617edb9601cd7bfb6dc912f96f8f19de6a01e4f61806d986737a7983be290e3b417a45dbabc81dd355f38084812ee0e2fb66159fa67aa63efbbf157044ea181062b9a85d29d26de6301ede0d1c096a9ac16141850e834bc6905c6ce17e12c0096a28514463fc576be070ac037da5e30454d24369620b5dbd3b4ed6829d3060bd02b5a9fbe10b18e49eb926d1f2f6cbc714cf49c2a0046c6da30713d62f44dd7d71e53bd98a6a86e1f446c325bcbe1290d598476aa1a3426b62a7e248559bfa573d03268f9d2a8fda8138efdf7b7276ec25a51ed1567265414af8631dca963e38631e93df9e6a5be373a672760ac6cc6d5f30662dd7de7dc7a75784fc02bb9fb157bc3b76d9027bdd5e195905163149d795bbe36538c00287f67406191a462c6db3b3d62740d181fb6a7697ddce33c50bbe574df0c624085791db6a8fc3a482f651fb613f562eae59d23f3dab0dd2cca8ceae4cdfead67e6bd9b05a2c82b832e1bfd75c1cad825e7d2550b274276740889b18e5819529a98047cf3e73cced1232151afda058c6cfe5bdbcd6a230c3ec0a63b332769a30124806b1ab73b7945091b308a3c8c7c452a6ee2526d2d1d043518282cd1dece5b1a778d978ae3a1eab2b96352fb124704ff7a6e20f3da9a1a6123f4e984d33e9517949eb17da46825c5a83e4215446dae239a015512a7851632a3a202f0ea8f8b186f4356c6bfbdd05a87e0e67e78f713334998990ddedf2000d18093088372202e96f22ce482ac68c11d239c5076952be9548dfe642824905b24ceb58d49995ae0214b655630b44473c0db8b6f4f15160d936cb6179b43ddf380acaef00875f0de106c747a3c88d419fba00135e3dd579a71346f4ce33cc2d7a9dc1f1c88d2d585d74a98a63945003fc6f9ff471db7ca582098327f2217c099843bf4ad2f82e12542fd4b2900289a3aadf1e81c745db4f50aea27a196057d68c0e7d450f4ff72a460a512ca60a06bfbb4ebfd1d844c5a9c1c5180177d86d40efd6ffdb47310cd96230babd22ba62e5fcb879e39193a1abfafbab906f6b0c14fe2ed9f2f15e76bd84d2e078da2b61cb13023e941725d6ca63446eb370ef99098d3ebc9c6b2e5605a3aa24434ba202be22bfc9c10ab01f110e0c7dec7ee0673a087703cda24e68b33df6592c62b3aa55013a49306423b269b8db14ea2ed051c839ac3c5b57bd01d717cc04aadee10dd53e30040728e723185b9bc9c9b813fca7b9d8f0e06b665d1add0390f369e31f0034e6b7f93746407abddd81e54e05c8167e6ee2c21a5751680d6d64ce0925647a50ae00c9434c80bc34224273bd40722b3680fe26ed73a990f20bdfadd20612340a0f8dec82262bdd910175c53c457f4534a14351a4134c213965c8c5fbe9e776fc1abb9c9072af9616d2e934928cc6b4d46ce86f6bfeeeaf059e3c6c67b726f3ec960a74dea364ef2e607e276bc10512b6add49da43e47de84f6a1686cae93442a740109a251e70463d79bff20f6a8eb31238b7ad0fcb0f425a1bcbe6a83e1afd11173e365ab8b9191c1b70eb3fb979fe8a4f0c959993c44e68789a89f52b2bd3cf4d5a19bf85575a9c97f5f66adcdd24416185ee936c340738f68e3b4cf3b06ffa69a74a4d62b966b18387311fb786d6361b53a2d4ecb7e759011afa0b6ee86103548f48017d5d3028df992e21bd264b033edbb0a1f2f70f6323eca4a85fc15e5fac1d3d047fc5e762490255ebd8c0683976a6f2e6451325d6e08bbb8340a3cb871b26693c6796e268d926e5d54fa1a8ed277989e1fd86b892e152a106b2d6417e4566540040ab1ed099818015dcee788d7ffa55610d63a31507e66397adddcc35d9f9a82ba9ba4b5b1e0731d63fb1126b521fa7d758c329226f029ef6df9ea5ef787b25ffd3843cebec7b7111714e06501f4740d5ca2e61a24ea7f7b42d9ea8b1b38a8e001d706326a6015e3dd6f77604c0a19c532661406c4905a5cd5d616c483c7d1363dcbc505463f97652e08ba17326a1e807e3055e7b2d1ec775d54f668799a9523cdf8d2590f9bfeea4de6c2cf8c3a17334da1891d57a9c42d8185e425343f41a0ba3b98ab9a4d003e5d0a4f0109c5f04c6dc48a289cd85078539ef429297428f5061c65325528335a7b20c867f0ff38dc455b583bf1f4d83815e2a96eb34c966af1677e36d9bd6dc5ffa9314df9a1c9e5963ff85f431f4734ce22d3a8be55e9ac810016573ac31dee82810be687d8c0d45d439ff32c7eee9c34a55f6f20d116701b08a3d48aa2b99feb410a90abcfb328ee655b6f6f2de5335e95069c10613c8bdd392d08e77f629cf6d068b19e4146e5d443b48153285d633f9d1f1484c2dc75e62c4923b74f392afe401f215d81d285dc9aa5b8bfb6f43eb2633613a4539e1e5dccab933bd410f11c14853c60d2f73537a9821d230d7ea0c52f75ec64ce11d51cd4f19a5509c462d18f153d5a56a8f9d867827d80eceb02e7d439177a5d3071049762228f7d6d6af60f1ed7b4829a2d053e1e683cb2ba12ab57227f894ead70204618ebe08d246c52d11cb70f15e698302ef7b87ce31c5aad0a9090aad6589160caaceb93e8299f27e5715459967f98e577a20052c2bc96f5e5a4df606b05dbe961d90a68a71a55c31d8903d489d7078f8a9c683ed70d4352430478fc095c57ef58fb322560a1501ad71b809046a763b8c70a43cb983ff2a7a1415c6b07e991cbbc1a7445e0798aa6859735428ef049363016f4d988105cd61e3c9908c4676badc587b6bd1a26105057fdbd1e699b9a9b1f2b12c526c2ee279ca7dacaa990049e7ad63f0c53a9914b010164382c2f9687fef7b7af337077beb9d640a1c9d9cade1a972b1ab129efcb9fc912a52078d03f98cf330c7afb64cadfab2b93477788b52f3184fdb6bb6f712f86982c7c1eb2803a4362f3cd218e2a7ee80c7633ddb64b087092351ae700b38b5465a057e2e8efdddfd47a2e367af903a313d9a8df4dfe203169e7c0df1f881c4ad6ffe63d2a1610ab2b147b47bb9af58d3deac4771d64a9eb6e89e0b2cf20e683958653a18e49dcd69c16b36cd39034700d28eae67b15f05356c3f3d701ba69e71bbd9ce66395f1915f92039c0135790dcd492719bde78cfaecde9c6a93803e4116c52c67bae250e605796c7b9cb141cdbb8c85aea434e8388f9a84357182de00297eb62e88917fe1b4b5bab71fd839918ef48d6022a5cecbb706b92b56e1c9fbe49b9405a88a2584340c594bdc492908ba41e7479c479df6d3f6b75ff88a4b86ea6976868d66378587596ce93faa25c66a837795c27511c4cb3f6fde6091614f4cd567bab274c4993448de70f80044f008c76ce7174d4f85625fb4dea6f5b45a28eee96122f2d3fcc4ab02663687036bc3d9608e9ccbdb0773dade8cf4e911884d9f1572870cb913caa319ab42c45804a468414f3d40113d1bb04950bbe93bf4ad809274c76ca502b3c0e5db2172b3e172e239b5d163c60f578dd934100b62fbf009bc3d78bb31b4673d7213a46da687271ecac2d04d388653094dad14c81c147f4a49ee060f38b5173b4128b3474eb3a81bfb1f5846c48801ac068f0e3225a38184c1cba33f91a0a09c61160974ed849622312589a5c7da85de78be4768e1363ed1fe5218a26ba0905f6dd7fc7b111f050e9408adf80bd00f8deafae2bac60f19ea04b664fdfd9a24b9ffeadb0ce78db4a043b8f05a8f178adb10ba2232e30bd5d7cd80999be2cdb89ae1b18450a5a40a13373c2f232e3774c9166dca8eeff625504c8d4d5458d2da0db043a5cb190829cf5d090b3a5262a181075bd071610f1a3febc70b38e6858714508a25c712b8ca430709e191e5605c79c82abe3f5dcd156b99dfd7c53c0da886e979373e141cf8977ef2fd280df6c977a83838d08558e78546c3d0a93c57338aeac138c06c26172fc4fe4b38497eec5f834caa65fe4d5145b3048fec4f812c0f66b37ea11d201dd0029783b900fb21c0327cdd166a1e1c307c84364d012ee39fe04059112dde1ddf05454a7871238e45e69645dd649bdc921f060a2de7b68a8d7015350333450a3e5cd57187e5228cc9b7de5ca5d428bd61c9fe64abcf1b43bc9e335a76f3885a0ad906476904b1dac781fa9db05a3d1391be2daaad449cabdc483a79350e909847990eca042c538c4c83b74ea1063a47112b6af25ecc3add7cc6dfa563adbbadfc63e619d9b063a8098a819cdc45194f70bfbdf7901696fc0daf5e407784c158506d370564b1a814a4a7182e2509ea139beac8e44beaccfbde739b6cb3ecc6019af8ac6d115095cb56f039bc2202868f644755abc9c21e60cf48b503e853d535f417c9171757d716ebfc30520cb4648437f9ca3963b04c7da77e5fbf4f7b63ebe14bd113afee73dad00557547482ba7a5e0c46efd5af86e44ddc5332bb1403684b537f1ad9d7da06d00ce803b1934548378d1d06cec777b0befe9257e14d327260ff3201fafdc7444f5b15c546e9d55363a75302ef6b184358c678c7f6afea592d017abff6a67ae1df8083e75667a423cf2033b83678f2051d98edd63f56d3c5953351871486e5bca5df552b7f888f53e2d087ef1457f5813ee8529386587a762adf2c802f0767cda402916ed9586f5f8bceee5f433adfe7ac1119f656aa0ccc4cb046a18348c61471f7986b2e84af3353c60215037d5b1386b6cd95c5ab37d215353bdd321fda85c6637626f86294838f21b3bcd6bab439a592784fb83247345c51894b8fc83f39b5db053107132ee40090799cdc41900f577d627062243fb0f6ac2fdd021a828b48402c46ecf090dd94978fe11bde4d40d0f00405340280df5cde43f1ed2a025657a744e71c22d25e04bc201ddd20beb8eaf32b30f690d6fa9a1a02cc626704e8b32138ddbda631c9e9620d70a3a3e83280dfb1487bcb16c3ce81a810e1611dbe675f6555d123ae87217a27095f18b47b8cb58dd44e551eb4b54623c4282a69b88d54fc6e04e0a13d51dc9461a938f931f7fde18031bef785aa16e3278e13cf3dcb712a447432570cd78707ac98661033c6fb22fd44e6adce7fe30a1e308020506c5c73d25e0fe75814dd831155cd7dde542a6a4f1287dbf9e1ea79ea3dea1e78fc8d4f20c79ba0747d187d5a132024535fe86334aa388f762eca0e4ce498d978576f0307419e74c45998ae3e73ddefb84de251dd37bcfebb579b95ce8664d7056260f5bca0e3768d01b607c11321a2cf2187c2ee4f318c7ccf4dcde900b3c659727747d2ec528f3c9c13e76208f4020778d0a3c0c51e16dbe653346ec71d8cee71630ed69b4097b9f78cbabd0bb05581b8956dc853cb9a3707edc49227656060c34fe3f60b994f6e487e1b1047f105487e8898b30f3ea1cc2bc8e78922f2ae82126b7d7af5596316c4180f1e0a1bedcda9be7e82dec06e8db6f148030b832239c6b5c629afa53225ef50b4f02cd8bc965270fc814b67f08b76dccac8d8f2650da286d6845e603a608a455455ce66a02919faa01612c9f7535ba7fef713309fad078f2e157740116d02f17f14be0f4677fc5931c5d9de49b251811fa03ddcc4c5165136e41bae56a1d3ffe83bfc800a263dc6082fe2ecfe15ef5353567a824dc3703a6afa96dd0fa395758603a064dcfc72d8c4149eded1841efe314a01e9914faec47084272cade2bcefb0ef7b4d30ea927be12b1551d2849b4664d955a381db40757e530d7b4a3f6f86d33073ba4333bdb907fa2a3a63568b217bcd641b8fe6ced657055b31fb9f037f706094d1df567f60f39850a936d0ca4c81aa4532e987c72d30f9e59ba57406f7dcd1b84017affe2f9af56ceeb8fd45a3d9bbc98545a65bbe48712be9fe960c63a25ab6a6999b54bbac29e8f1f6315dc302541a060a3715bb2f91a949cb510e48ea8bcf4cc1c21768bd3d2a12d40d01489c910140c869bb9897594601820ed3f3feccd57b7b3c503c0d930f1182b1b1a38aefe13ac206cf910035ee7e4df6755cd09454b5b642d3a21a09040d6a0c42cb6721cd91a8c894b148c232ac224a41f697940ecb4aa220f73b001efddeacbb642d4f56053e67b2e4c560e7377047809fb85ac622c794c212b85f435ad6c4884e132f22c474768b73fa5ca69d763c78ae74192ab88f7c8f67f8df8ae381ced2769d67e23f6ed00d86473c003609de6d07a3d884a32f9ccf8684652eabb3dc08e0b99f7e7f5b31b83d2aadc707f536eb9e97f682e46509262337d1e5e17c627f8ded0148b15a6764708b00601e4615de3027212e4321abfa73c622d85317c88e5d9584614f4cf23680892c1c506c11a0908e7e6b793ca49191ac00038a7775e6ef0cd5f3e3c7314ebb16ea6698dba5e947cc808b48b300d7462956f6a3aa1a49db126d2a612b3022592ca24638010569d2e69d43843621e8ab09f4cbbb66b8734fe2d8df62807f20e17b21502f9052a101e44c87e5263a40021faf533bfbe313974b7661dc2598055c55c0c83a660f9b1417aeafd372fed6a202344e15e4c8e87fb0cca3869165ef0f36ad7170f57c09cfe824b671be17166e360dd040317fa65b6bbba50083b3d782d8eb48692d646700f431793e29d38ae8df0238a4f5625113e79b98e672130b4b8a0196464627e1edfda6146ec714f906083b54bfdecccd65223ccbd07fd86870cb4656acb541007021a7bea23027c6be2f6e0d4f91d98766f042fef26998b50f52a2674205d22396a59eaf2b8c71649a8e056189c0deebcc5f405355333ae3419941c74c0561774b0b14007ba9079ff9f40c4df4d788a094bac77f5fadb24aab7074d76622e47f28370887aea4c6d1dc87d523b365252d9efb86fc16fa321900616046ad41515e26c6f49d3dd3f560ccf85aefc5c48a04320019bb596fb3c901c766bfc86757f4725176382b301b2d360d9d120c16180ec60b07436b371757f4e824d53132653417600e15775de6f1c8e6f36dd5f1e21f71d0f50dd116a059edb803cb789d03c7b431c0b003ee483bcaaeb971b072382b703b2d761d9d331c1d67a3577078b18789a7b940f17a643429b7192d3c649b89951286f1275db9475d55cd21a6796a68ecb0fb5776e0e1eaf9f2a76d808360ef6b3c51f76bf1d768c7e56df7d677018c76ff10aaec414d58fd882dda02c230ea249ae1e0d1b886cf1cd93d5318c4d7607b577164c8b95a819e4487e99da2763e6a6d55f4159f66f186092d80f93a8dd4e9d8022f075cc01b56d424518bf05fed964fd8423cae7dc25478968f5ae8448bf6134b1d89731a69c3ba730d505987a8fae1ee1759272f6c5fd112b33a4ebca4e122ff67475f659e562a66c84ef9a6de37436a4acd1aeb5725f8c6831416cabcf8c4ca3aaf2814fb5a7a10e6f94a77789d01d2b71fc9396b3b6d38003be261f7290be1ca2c1018f432c0951a0f1f2a9e1208558e4563227be3c332da12d26bdac7ce02edc29c34da7344600448b04c3ba059dddacf0be424eab0ef2cab9e4800eddd247571cb18ff6d07d1d4a2c01363d6a8d19872d748e29cf9f26b3800310769dda6ac68319c5263ab0711c9a0fbba4d271334baa9739e4ce4450e38b4517d572498585b54613a9b5ff94ddc35c1ce11d13f3eb60332962022318de3141c39d000b03d84039d9c00ba60b676d997d99223eaeb3fda3f2ff36f3e0df25c58e4976536b8b3771073a59215f4aba9c2e3e1713bf6a659c9a06ae6220794de25fde6555341e00aadbc806e442260faac721d9bacdd710e887402d99dde28284ac60dc583f0d36f1fb2aa43b8dba23581ddcda33e26dc5ae09ad356da98940681fe519bcec25aef6132e54087f437ab9d941695d9c92adf9d8d904e15246bf2d9cca2146a29b7738f71bbbaf0f9a44aa8564d0e717afefe421fae29a841dd9b1b7f6baf1c1e688d7ed23f47c0c8ce5189acdef3422ce7c58b01177494da04dd31ce7ad3ccb9f78ee1e125d2db4414f5d15c7f09ef036ef9f2e94a0f80c402f0264d44fd9226a56f229ca6c576e2ff71cb86441f1c689b06b8ceb0dd7caf85b82e3a9efbafacf34591dd73d689fec463a1f11f2a85349c7294bc99a6585c1032db728cc08691d99dc5888f081601243ef02484e938af4ed38bbd6bf0d349e425800a2e424b602088d67c8a9970b158dadbbd2779026fe1e877e036eeef79ed82f258ad63cfe5006174ec9da4fe9d22c0883be069b9d20eb127308d31a363b7844aa5c3c3e405bfa6ac2dc5ffa74be0c58ed62f1650208b0cde362cb9708578904628c80315bb0d521f79dcbafd177527cc690c702d9a16a193d0b655f8c3ab92bb22843650dc74167205404713f6ea64fa2d0b70e8a0098af23d6ede4dbe26fd38a02189654ed8c523fb3d12bcd3665345a071c6159594a84044726ca62012d9547fd9c5be115c85b1b8984ce0713415773c0a51b8e135aa4dfa95568959eddaa3266dacbd5fd106935e285a894a9d7d0a9e5ac28d63aa3a4ab7470b29b6e1cadb0a3111127f96ded162420edb795c13991dcbd3971ada597a0a4f0e895dfe518776e1e9b61939fddb0123ba5d75501ba1983b5711894ad4a4ed17edcf5fa9a442930c2630f23d80068ef6645b7724e9c3b0f1318a0ae8bc3a7c02672281edc9b16d630fd4b1d84de422a783b7ffcd758d0b04c684b4854a09b2f0a39470f2555c858ad088f6d57cd03a9e676896510c15cbb44f2aed2ac5138c3522b54cba4dd5a53bd5a02f34d40d61f254723b05557b0e291faae9aa6fc056b6473601f8a882a261567979df3b08421dffb10ca6296e84fea9f1c5bd3ec6d011bbb6f4924a73f39c3ad1cdb011847ae3e9b9842aa654f4edcdff8a63e17280597e2b2aa5ffc7a0d8ba7b45c68dff41ecc6fd99c4a75f56b616d9109c7b86978b11ac9d8c1a4e4ae280b9712024aabab8b22f5f56304ea6ab78e6a3b029d5c0a2e61234463fe89506b44a4af04fa3874c86f6ebd0ca96fabb25ad8fa0311906e00fdc65c0785d9e9a3bd053c9952e5a34ffcc5d298a35cec3cb9562123a026e8f1e4e0c3839cb042afd09d35ecfb25c61f332521359aa7f6c9240f9cf03e82d731f9f5f487c6352aac0314d3021adc555f5d30522a9b0ef1e28426524ca8ab663d160dba674e3ce9ae2b07ef3299aa251505685066cfd96aac86c2e88aebf742986220d1c260a817bd5a040af1300a49a1878ac3a36ee8c6b98ea1cfd6ec45363dc2c3881006697befbdf79629a514f205ec05b305bcc1aa6f321d9658d2df45ec244bd23699d3b4134d6c46b5ed88924d4868a64454341372f992679b6c33da8e6c421b0c969c6626d995bf139e127a45f589e44e9cc9694e482152cb9d546772a6ea3f7da6cc6936b02bff15c3f3292bb72935e47b20a7acfa2f973306ed4f6304a095181512d28c9413261f274c4cfe32605e5c5a586241b11382fc6867fca9e850f00d7f15d19fd819234b125144900aaa3f92ea7f1a8d6a5852044be2b02bff203e1dc6ae8010fa41142f96e462497f1fee7994a652ff2c9a5ab650a5a9e536096911c36215344755152ad86847a5763763a2ad7e63d0d94d6b9f20744b4edcbd930e688082c61c6b7287059e1d9511d485c9c3d3625848335f3e561f17cc916e8ed067128428c8d177baf9afb95bdce11102ed6f74706c1e4f3c7ade77ba59c0d25800696767fc4b7e17d072a1b8ff8e1dde9722eed0817a17e6a7fc875ae1e32aef8cb747d5c3538b5bed10d4b7f1503c3d288ebb33de7fe20b5c5346158d0951a211954f51e93fb15869a7917d5040594dfae7657ff81e3e2bfc920c59dd0a47f73c4a6b18ee0afcf04330f47ed206cbc349b2bc479c26fd6f9af45edaf116bad5dedddd9ca404a9cafcd73e511f9c73776fef2697d58ac024454535a31e5a8c2c94b6265ca9d53c218618328218b80bde82c80b3943414008f1d9284dd6090e2d6029bd89113257152aa8cf76581097299c4d66a276c9486c1f765de735c88a60f275953b13a9b00d3336628193daeda4b6f3a6b03577cae4c632c54293debec6a063f7919055a8a0fdfb251b19ed380dbf7896aacc7369ce1d168e2a3f4fb7542a03d134bc03ad856e6dd211231fbe823f5ad2911ad42621a63a7b5ddcca335fb10de81ed5ad658afff58d41474fa401dd2f3d5a0c18f5ccdcf4fd295dd0929b18caacc9229f752b759310e8696fbeff6e44108340552b8c0c60dfe6994273543e4785a69df1dfc6f042cef33cefdbd7f721d8034e15f0555a54a15248814853535393d89432a2787ae2a94997265331bf339f128e5fa94923b1318d59bd99a8de43781f48d44bda08e56d14f6964975eeb899c29c4fb8ac03dda4a127d5b9981e4dce9f58932a1650fe79b58ca4d2f78b240ecdefdffa8790eacfea968f9e4769ec4b560a9e47e79093ba4944c84ea89b34645439e6349e47692af54fd24a52c7d6f4cf3f000fa9738917069dd58529764cf56b117b8ee4bc8c2edfd3f2348a501dd7e1f710ec979f2c3465748a1a9f54c00a1d17957548175dbe4c81638f60046d7997f7173ba6ba89fdfcf21268f99751022ebfbeea98eacbdbb467e4e56d34cdcb4f16d2ab493a6be46efc948b4aa37e98e73c75ddc19973ce39e79c5d4bd7c9a5630a99f3873961384ea3e226a7a2f2a8ef49993eb5e5e72e94da32ba5646fe11631c63ffc6719a14d88523c37666e280f3e7fc9df96541b7295a4165a6d71c0d7474c7409949e8349acd8ececef8cb0826b0d32c74eb7bcfa18367a88e584644cd41d5391acdc66667fcc313db6c0daa04c28279192fe3431aa2ea05044710550fa8f1345ef532f2a8f134543cfe47f8df9d5919550b68797e7e525fe8ba81ae726056fe960752b728288bbd33a597e2400a1be0cad230ff29fa80c9e543661a7f5ffe357e5ffd32aa1ef05fe379fcd7a8f13d22fcd7f8ff1f7b667c8dadf1e2f3f81fc71ed5ff8b63cf911cd5ffd813f335c67df1c85166c840cb55a25e8aa6c02e28aa964b5bf958f8de4029632c4fd1b2352c5ff2104e78e28c0354dd405751dfa807bba0a7ca309f82498daa1552fff22aa4c66d52060ccc7bfff240eaf730e2e732f234b9b38526b75a001c3bd37f125d402cc460e0892181681d4ebaffd00474541ae2be4610f71523ee4bf579b5db978e163398a63fe1cab8b8870c031428309cbeffb3719ae7fe24daf8f046da7b11d2041b279430734300374455f8ac07f21280a80a6f7c8e00fec6877fe3c6b36ea0f040588fc2e7b01e85f1c71199ff71c2b364c61cd6a3f0288c3fc86701b9210001bc0922eb4f106f3c29a2f0366666666cbc09e30ff26dfc8f137ee68198f0404af89cd597f0fe2500e04d187f98f000f81f25fcea81bcc22e4124c09b200ee04f10713c2916e00b20aa38a44d0735e941429b6c9b55ffada85ba51fcdba45f4bd1f756bcaa6d256444b9739cc5d4602ba7de92815168a0afb44856dd2fb243b653dc6e6e019ec0d7f0fdfbfa3fcb04b363be34db6a66b939d014717ab9e8630b963d89533d9b08e01f1a7a880d5324505cc886398f7d33086a1612a1eafc2f97124e75ba972def3bcb1c7cb540dc0717df58d2e5f398f8b391e4beea1fa566bb8bdcb33a5eca9dcc8403be33f846e23ce78d3e4d65b1647449894c44ec0036cc9107c9061a526fe61d09295941aa502d7fd2a003c9abc05ac96bc05ac763e36af79881562613db4ccc51b610d1bb94993fecb83eacff15619a5c29c356c14f79d08564f754c0bb5ec09a526bd95fa951c1c42a78f4749c29559d7d1a36b7be609db85fe685ee84f6ca157fe9c98819df1f7440cec0d1783765defa679c2eff9fef43de02f9367e4ebf7449d1ebdf2f0f4dff784a7ff9e47f8fde9797c7f3a7d189efa1576037a5c5512b45c261e4ea77b50605b0758d27fd4b133fe9b8b72bd35e91f9c1c96252519aaaeba494900a102cb8e81205210c3d49834e121d03b2684fbc42488ea34c94c63e11a93a6a1cf29292a2a2caf32aafa577e5f3d2e9f32aabae579a47ccbcaab7c4fcba7742ce3ae8cb4855d46d95c79069ffdb949b7fc9be55bbee507cb188295f108f840640da482a3a3de1f48ff27d3e4c3ac44600625163908d5e2096419d3f1855ef17b3bbe62cec72783944f797e1ce620670939978ce4a4b20e8bc5c2c961d96091a806a3bc4e932c43b8bea27aa139ae7d7aa9c7acf2ebec740ba6f2c340e303d68c80a23207618450e5e7e1b6f6a1f2f3ac80b29af4b1355bb97befbd6edc1718841a89fdabfb7e1b4dd37127f6e895b7d3640fd761b58d6e7d651f652eb8011353122d60814cc935a51a55e2d7f62f5f4197669064ca508ffc31095ab23c2f06ceccecceeeeeccccececec3f4d9ef8c1120c8911c90d03bcd9d9bddb1b8b203e3423f18a27962cf919829f109205121a9ccc40d4440a2366109a2205480cad00c80a211560b14b8ea2348164288a228de44807283baa7852e4480bb890a17a90c44fcd071b92340144d4440e4ba408c202206a53d8c086fe6a30248aa1708a2234253f0005315bf2e467c8cf2c92439325419014418208dd6700ad0ea9adf833ede73add15ad6eec93d965504f3407da64044db5251d74380ac2c2892896242931028a2555bc000914330025d54cb08276e2892f7a7bb777bbb7677bf7328e6ea5e65094a41cfcd0474562dbdbbbbddbbdddddbbbbdbbb35318a6c3e0b850c507a77b4df6cbfa3cd26de6c37dddac6f279e38dc51bb6d971c3db363b37f34df3f6f6762729a9010fa1fc2bc3738c7065ca19e379a9909190883890ff78fe333dd2c53db72ef315f820f8a7ef091fd503fe49f56d2dda6256dd8af1c7798977b12b7f1e5487e24cdc97ce44c55951b36e0d6d6b386762695a881d52ab25252d13063000498ae28c192b2bfec38d2de33e3128d7909a74ee3bd4f729323561df09c249b757211cc1ef1b4bf0bdd1d5a40df8a50b649b19edefe19272cf7395bf837ade7bef5ef7fffda2bb54f7dee55a66eeef7b15b67e63f879cfdf89464eefd234a7e79ebacb5bd79237c30a8ca458b2e1081b64d58b8a8a8a3847c7b89bba514ea44612edbe8845ff6920224affd91a21b666bb695f9b118d8b84d0b29b98748be35105ee69547d5fe2201d107eb79db8686b9886add815c91dbb2b716d0c42b92fb9569980231379230d328fe6b1c744b4d3149a327e9616626139da1a2eb6e5c5b638116cebabc1c8b652dedf89587f626b54dedfa1e01cf4fdbd880dc261dd8773e4185547a2820a040f41aa7f87d151fa07953573691167fc27a69e13617e135f9e672d24d4b3ad49a9eecf21a12b5f6e34baf2e55caa48ec846f30f9ca7ffaf00d26a698524c89c608ad168b3565b2297317b896dbb4c9362396d191c21431e651a2ea19899db0f44c8414a1991251d14c28e64b9ecd52336488f0cec4d433522966f2e11bfe2c4c3ea713cf58624eb3c9b4d81c9b11cb268bc5e60c605e5e3ad641ddf4662e2d2cbf4b61be9a49aaff36c36e22d84d86b186a5d964be82718ecd886ff8a302375f10a8d731d833099529e6e8ecd6a07e64e2d6a854ffee616bb83fd6e4b83bd3429a746ff6a91ca549e6906833b1c307f2f2e7ffbe0fc71fdd7f3fc0f776290a98042cf749d79f9f213fddf7ec13efc1b11b7f80db0528dbe709a862f04fcf237cd4d8e385370c68d7bebc574ee7ec8c3f4369928beaf705dd4616e99afdd5e0ce35aeb112d7d6a64316d25ce3a52e7f546ee4d919ff79946a22a209e7740bf8fe5493ffdc6ca265ea26f5a38afbd2b5286e544057766d0d379ebe24ba8d3adea6d3f188a3d3e9743a4de634e93839364dbab7747af8f42ec8118de3d435a2a0dd77834968d7349bad112b5d9f5f14fc83782f7f478d3a76e6fb8276638a8e59501f62b6851cc303cafd4682ef32ddeacacd61836ff89f3e9c4d22c0726d8db73cd82e7c7d5d8532154b20d57b70c7b9abea6f8373acf646006ad7502453314dcae040b9ed8659d8db5077aed2d5bc28540a503420f1135b33674a093e12c40e218bdfebe8967faab7a6605229a430bbcbc36c9ee3f2309ff3f2a95f9787791e2e0f33aa1ae665bc7c6a54f5ef4b064c932c1fb67c384fa78d85d296959516951696efb422d2d08517683d3d7f8f2728941304ec8c3f8b07d81b2fe28dab6b580f964e53fc0441c50e3f4d3c7952cbf4459d7329e5f5c8d3e4e4f131392e683fe9abb94caf81e5d91a5ae7b7b035f3a7d75d6f403dbf471e2ca83fe934fb9aaedaa3aa7ef5b301e5c61f996c3184a157feac49a2a29e3957f967673ac811184d5b88f301d1b32e6a1943018202e463c856bed334bfb8891d08317bbd66b32e6a23f07fb6860b4f10083f3c8da2e72b70f4888a7ad69dc0cee76ce65238773559d433577fd9b36de49f9db9b1a9cd3c31361c20f8295ed0a288ac269bec221a6d224d21f307e6d3640a3893b6046d9395dea4f96a095a4ed884398d7bde37c392aa3fe581bc548d5219fba76ca31a34977a3661d2644d9cb48954fd5fcc1535bbe8710a9593c6cfbf094d19bf50b7d8f368bb029f859a94cda029e38d43a5c0db269b42e537e9a22f35e94bdd2a276c0a75ab74da1c72a739ad5b4bb37103fda269a949f70eb717e107da2f739a09e3718eb359396130d50ae1cf9f4d544e581b9934186dc2605ddd7fc07ca1c6d904035afa12adbad3684bb425da52f5e762b4745a1735e9bf421335d9335a1bd168b4179a2bb139788cbde17f7a7f37da1a5e62094eb21d25cace84e015d33b5117b05998000a190cdaed395bc35da38c9c9e51356c666666661e4b162ac1064110fcd0719af410f652056511fc0ec3adb9707442b25b5d99b9bb9b6178a1f3b156734078cae9953f07e27c238b6cb21b6348b7626b38eecb0e22e18ca3d3834611fabdf7fdd327f4f91ec461f38bc27c4f0ce2bdbc07c520decb27c8bf7c82d01b042867eafcdd0294ab98ebe58de2aee602c6948ff499d0d92dc5e41ca8baefeebe49cb5630123ca33d763847dbe0c2f6dd871cc74d1f581141dcdcedc4af9ab3dddd45207377779fcd9b37770af72278639962eab123b2d0a47f221d83065a0c4124690a307c50aa0205330cc1233aeb3e0f5fdd75980ff90816b63531b1ad99df0b09e14043aa7b91128e6d0dd7fd37c28c72dd976a1b550ff01e7c1ede83e1e63d0f301c55db6824e5f7857af067b5cd27e6b0263b51b571ddf6df7be1d8037aafdac69c6f546d1f760f82dda8da461cd49f3ce63029e8fcd261dd7ffd4593ee305fc5be316837313549035af64c24a2a5c3981cd6ad6d8288a0ea5dfd55a40d87910e837143ecca1f89fe61a2a9899734a9c32322adaf4e25082ac776c67f08e5d1c685e49afdc1a07bb7fbe60d04b76d034fa80de4f0b481fc1bd8830a4f1f828f7a1ee0a3c653f827149fb6499511dd9ef3d8fbf80b41af1b59a4cb0b9237293e1cdf0a9acc24740393d0fe44564fd9944da139d4db9753c6c44253c6513e1aa8ff2e69d26bfe7dcfa32379edfb5ab7befdbe5df9f721287aad919a5ce2481f7f1c92d71ca95bb56e95dbac2ee99697be4b886aea085aa66ec881fa6fdd7ea8032c00aaccac270d9b51032d1bd6b186354109429747fe1f304292c5308ed6675d9e688114a5f881996b35a41d983908a9492d46c3a0297ada2f29cecfdd5d13d0fd263a8201121c363b6e6ca80eb45c9a0dcb85c4ee76b1a9269ba363aac95e124ed0316c32202de1e8baaeeb7e7b9bf6bc6e75dec6799bd76ddce62c1da5efaf29d5f28774ccccbfd3e4bfd840cb55e57fb18167078784176c8d8778f8197a9be69a060e9479773218364d34238872111045b3a259110c4533a2d98ca8685624039a01cd8488848a8c8478a1fc30d18edab9e4ff264926654eef6f83ecd6d25411ba35cd02e367cf903fb5710cf364a2fbada496293545f4f62be02a2a189ffcd80e0aca485d32d2f6cc48ed791cdb5533d2116db78924c4b4a36ef5126666e6187b50d8083f0943b48f5033d0466ada8f44747fc4f184d6401032d2cea800a41af1cfd95e3efe08c1cbe5aba01951cf84d0b2675dd4b396b5d00d347eb2240041f702e1ab66f469aa49268e8a08b978d3e4eeee6e775721039224e1323bb7cf8deb3ce5846e935bf3e6ed9f8668ca555325fc50c20f5984ac9202ea620141f73dcf474f8905eaa72eebbd238e4e4d87524a757056cca9f5eb34b7e1e8f8ceea0f4b70bbbb2c8fba76b89c481d22bf9c39915f8baaf9208a154504a55c43d4c7225e607676677766676676afb150e369a106456c8a2390581f77a03d7a23120b78109e7f1e8f3c9367a7c9de259eff7f1e5fda6181679b3b7ec33bcdd3c26c6b1ff3a9d41441d496b400fa82871f9808a5bea281f2c840b3f907887fd88128a514e88789fc004d77ff719afe2939c63ecc3eb13f516f7e6143bb45a98bb5a36f5650a9dcbbf8a09df84d6e2e624c933d95e09fbf7371b04df7418fdece30b703fdcbf4b82bc474ebd4a44d7b0cc29529d746b7b6da58afd5bf2fd336627ab5a586a0278f8996d45bd24fb57ca1ceb9a47f7b759630d4fe90674bddfee6474656b7df19cd48a86eaebad18c92d4cd6773fb6fefd2adf9dbafcc06841b76288285926b89134860f1ecb25ed014093950fe0ee830ab22072fe020ddddcccdcceb62c540ad20e2c4122d6214394110314c6f6b31e0d06464440f458ab868a2429644142a9210516406126858f213daa0ee7b1c6b1e19c6318eb14f73cd6db1e6d9692a22abc74393a7d960fe556c51cb57826e1ee7799dd771dbb6b9bb4fe6cda793208313473b14b5348184431bbe4e23d34bee73415dac19ebc00721eeeeccce1b4f66f776253da91d014612417c3cd07dcf4ba57e64f0191181388c37784ec42b8a9408519188a00454f480c81731081a628914454a569820091a9e7c5794a0464407198d99d99d7dbabb7378c40a21b57caf1ee1dbf438cfebbc8edbb66d7edfdc260f68b948373898210521995008a1b933cfc9734e9f93594da8b8412d7fb21b75ed535a9951f76f7cd53a9aec6e1860e4d3344ecbe9d636418488466d76f473bd719a6daf69a71a8711ef594f4bc5a880f21351e0088d2882848e5e30272087a39a0d6666f73ccf73f6e9ee9b3405915aa650e09344b4248908a8d5b56c752d5b2dce61b444cc0aa35aa66642c4c2f6be267a33bdfbbbd605922ddc87de6cc9bd8f364d36c77936dd363b96f3fe9bee5f990e4258eb13ed0889d6b414122d6c9e328aa0f375b68679bb14de4057b98b421c3d7030b033fe2a4ae8f6b3396cf20183073eb035cba1c0564bcaf3a8bcd3dffa79bf4223639b9a7cc8f89e948c6779fe1e984f7d8f8c7f7916984f7d0ecc987a1e735ed8c5260533aef7b7fc0b035bd39e4baa49199514d1d5e46260c579a2a48d20d06d3261b174f7245c19274c4b5b33756bbde7b8aedbbca02ed70a3a4d2ccc1d1a45481a8dc6756291d3eccbc325a7f17cc543cb223cedd74bbdb494fa9c7bdd9d4be19e6b7323f3cfcec0bc1bb613ed0889464b21d174b6c6bddfddb1fb1c705c5fa57ce5cb5b4a1982da8ddce6b51729c272eef771db6cd431f55b3be543433ea55c4019b56c847bda743f25e81c3d1fb706749f3584ced5a4ab28a1deced20f1ffefe3b3c5b73aafe18d89aad66becbd4251c4d93d35b4d3f2a45a69629d269fee43852622d656a7f7f9abca8142e3745b9746846020000d3140000180c06058321915840281c2d7a7c14000d77984c724c98c9c37112e3484a29638821860000000000002a008188010df3fbc11416fc68e1939ba6d428385c039439c70c73e9987a22a438b8b27cbd3f0ec0bd2f1f22d8870c8ec036211322c125d046ffcdb2a9682ecfd7848c359941eb62eef31ea41a0e9b0f22ecc16e6be837be6b49fb4794791d7be959424e05a7ff7975cca5eda5be88d77d379a1029b74aa3b986c2e6ab6052ce5e6d389b260c3852d523674af5e37e735140f685ce331425c46ef50458db95b84efe0fd76345e183d6e036bb9725c2e9d85b0a114569fb336e135508a236340e3d4f9a84c68fbdd4043d39cba62339f6697f30b53d7440adc6af45b42a9ef1c7c420053c20e4b87035ae92f842a1980ca84a01b4146da423fa5704e52259f53c57affb6d941f5ca24f58482a051301dc8b753579501af73808271fa9c0c101de25bb1341a86e21ba0df56907a5f7602ee0ca6f61158c2e1171b889bbbf67d5decbf929e574fd363e6f34f6f033bbe9d0ce6ae59df543f4b5ad0f5cd38eacd8882e9400b8ca96134338d0060ed4598b28d11be4b90407759965c2031640a104adb086765c590900c830007eaff2eb4dc9aeebf581a4dffdbfdee4d2df10eac3c7f2dfd6ff44e8faa60729746b02a1964910da4b533abb72d90939ff7afb5f288cbc1bb2c8744846e69967ea7750d08d87093ea4586b234ac576fb484b9a2b67f5000dc66bcd8d11629fbb0868d2861964711ed1c7088495f57397de8d4a309629a1d60c37c9111f46aaa07df2f60a789a99d601eb52b2b87eaf928d464531cc7e616f056b63c4425681df837349e18ffe0665ae9fb253da2fd7f7ebedaa7053793adc4433f30d94d30558bcc756befd89445c16753f59b64fa10fed62d23c4cbcca728eb1fe505c37a1dc8238ce0b6547026e71310fe90e73d0c730e421eabe4ca58f290e85bfc7207c840ef50cf28491560f6d9d8b4b19799f6d4d1cbf5296b7227dec1b4af47bf42b52f3b52852821db91d977c65dbb011e82fbb65e80d1b6b753668d8185d961abc42463504faf64a8ccd40d40da7a643e0f953cf77738fae3b8450dc3f88744e504222eaa0c036d13661f55d427d44c2b46cbcc2279e9fe2d9e92494a6bbe651ccd1d5af1906c83f25a542fbbecf013867219334dfd11a35417be63b4c2bf85e68ec4c21eacfdefc7902456f12be23e185e177779c3f78d9a0803cfbd8dcace043d3c748d10c6cd1fd9f34b0f55003326deb343fe8dae37e632b0803713f5b0473dcfe09f2d421053924c2eb654f1ef0897079a1909bec637fee543fec201de7c8caa3ee2046af66d309015204a001c4ea0f83865337b95722c98f149e227d09154853184e3657e2f15662ebeb3477047081690e22c62b91c12207ffbd4acc6a948974686815598c5a787fb28dac43ee0d361bbb0d3e945ac7c283e46ad40634900dc1350ff6f9fac9c285b9595ad7f4c281831772578369256fdbae12c7c01f0a86554d72faead2dc2d584589a82fd6b3739ae140685a093398e39ab6da2d3aef3bdac73a219bce352b3ed8a71a64741e8d500f011dd18ea3b2a211737d0d6b9ceeec07f7f58ab2a8bfd17484cf7484d9f9edc399df64d1d8329e6ee816adedde4596aa0ed2ce129ee8ddda18fd757f64023078535d1c109bf4eace3aba2b11e824656104e1bbbc0ad1c7206f3255041dcac6317b8cb230a81ad5ad58c196afa96b160506dc04acec05d3350029c34483d9b8990c9d32aa309adc08f7b491adcf3e47a45ad764f6024d1ec84dc78dfcf17038cd800167c74bd155f586ee9a626db3ec90c8a89cc5695601388dc52059cdb936c6c1281642042e301eb352ddb5d6a7af88ca9bd6fe37567816108c9eab58f80525ddec093759e7e9ed9d5f14954a5b9ff4cb93ecea763485445cd3ea8ca0ae5853ba7ef3fef741627d1fde17d3ebdcbf5f48bf031a2b2f27bd360a4b536e4efe4ddae0ee84e3b314c11f98ae123c429195f4fdede52e9e6a7f7c0d867ae158eeda51c704bb242a5548f92743812c2124edcae58c59b47cb3a6eb33ae1aa8f309153c7bfdc3c07f5f9129f16ecca4e9616d0ae86298611aaf0939b63e3e16cc5811e971dd290654c5506ea473c3c5a1a21434f1e1dd52a42951a9923228637f30edce85fb6e42209967c60848484b5e8db2a00c53ab31863cece850edf8ca16109583c72b0dab416c0f9bda585e091ca3829c40c0b9432203828fc4b3c3db08ff4093bc61e8b02a22a75de6e7e51fe8a4ebc88b6217ca056c90ba61ac70fa9372bfad57a9b937d3aa3fd8088df73cc272f4bd6b96fc5aaa1dbe4a61720dc781225d90b673814afa0ce53140d51ef58cdf15e7533dac44f8d8388fa25a89b94f235a44935f5e75ab342908252fe5c5c0ce5700a8009cb8061de7a99d0d6a56df6dc767e725ef29978d1e62294b940a6fe088b1b9f29f3097127957996fdc654a89a6e4bfbcd04593f2ff565b9e794030d3d9d95ed54703e7a0e4762f4a05f10174f4889fe5126645622b1e311eeef268d62ed3555e1c38529359b29cde014619720c59c0d2e8f7a17493a140ac916335708ba24eaaddf103ad728f2e7a10b77b5c9a737b76026b17acfe11e6f6779852dbf661d56762db623cbf2b8050ffa974d53dad7aaf9566b919b7774c0efb0212a41dfa65e84c27bd2b5ca9ae31ad02a34c7a00db57b5b2d81f113350a10b5fbe747f8a51f74e02ab8b3a6238e47a8b877c9c63a66219e6b0e440e35ef9379467501042493ab185098993d052fb57bc502c01e9f2110c4618c72c4678947ffaf2022cc0d86cc64634f68bbefd1b0fe8a74ebadeb1013db6b19a730a24f0409a85c80e5759d0f8d225288e0430afb41c6f48c8d9bcc1d6acee1673388346128589a3eb01e6be135d13eb4c042ad5b1fee5fc7b8407ad6a8ac11778a785105e0da8ccf8b86155908791f15f11c93e4dfc2c9617e4a0b246a3cdaf7d7c8e31800d588090eaaabc54490705670e4f726ad1caacb41120cf8062cbf3e00433aa2855a9cd4c72aaaaf9d85c6f015d7001194346ce6a9411a74fc147068890c2715d6fcd06e5d36cdb157f6e206062edce0499fc2468dad53d73bce1016f06a5d534cb4b9b227ef86445db74de10271c7a88a014c344e6911240ee78b4c1621e1b1f7a87964034a6f5bb9a7b5e8d3a7931a1f53a748209e099b771964db42dfa653315290639f3503b06347def8d35d579c9e0a6fbb0978615f728d1eeae36e6da27f945cc05c8b29d2b0752b68c04880232cef1f964e66818f6d1a2a044030d23928af467772af42de8023e2f503a37bc2972e2ebbe8cbabb05f130a2f4db22b6f4452ba201ea3c16d9737a898de8413056b292d1e93e18b393624f1b6af4982db65dc955ed442d92fb2d4c44295480a50f4a6763c960f656ab6d82737c5b4764317905846e2967fd1fa144fe84e828ef904740b2d3509a15568fce0733469a0af51749040467c9d8abdf3ec86678da489a86c51ccdf20d9bba9c9a10a21493acefb89f4124a01ae9b5c36f2a21321b192b18c7910a134bbcb8a326d3a6ce1a65a4385aaf1b0b5c1a8130b925c92fdf42c98eacce4d8930dfd0459bac17a15c2275d1f0e214bb9edd2b674fb403bc41598286f41ec868fb086ebf84341617d1c820cd5301caa7eaa34906278e4d4f4011aff783948690480b6e30b670a58955b24a82f8e8a940a2cb59dd548066e16a04ba71cb36f78394bfcd1453f49415dc2855ecfdb4f42d28849ed44c9f51e23a53a25ee003a6d933cd0781ef91d7573db0f63ccf87cf0ca26be8495eb1e06d104eea5a87fab87cd974c1e626a745ef4685de7261b4496e5a49462d3b67568ca821d8f2f65c9577f6fd594ef10a414bcfaab2d96d556a4f8fffd00cf0b3fe662de8b9d178203e0c6d861d95f4c70e8913a75b38f60ab00e3abb0aaf7b5de3629a8d448297982a21e20a019fac1db5e10a33ba3c00cc301a40af6cc506deaccb982b981ffb64f97a769b91b4de11acc8ffd8694e505899da04900f87f65d37986004c1222a81ef06be634aef422a700bf783c7b3500b2398d3ebd6024a70cd67e3ed21f1c2c27668981d293d9b0ad3c9b59fa1a2b38b32c5e18ce0e5b9ea9491807c5caf9b7405f5e6a292ab53334be0f03f8d750f7f82848de80519b34628e62fbdd9585c772fc459802705df60fe0831dc399ac70db73c6a3e542e320c9fcbb80dc4a3e29a010ba6b5bf5f4cebccc06ac54f1c33407e39a45507e2cfb3bd5dc2e451e36d7e1b5950cc3640840e89bc45c0174c59fe31a22486cf2b62dec2fe1a9ac65ee04c82ae9c3946d6ddac1a8053ec01a19a5cfab8afca6f3e0a7f9bfdc03c568a5f12d166e503659993e619d3b145f11c7254b8497961848cc62c47714d43cf7f7b84e643dd1c2c363b73383393b10324bad722fc410b60c6d38b44f009ac425500636acf2d180b34acb4c72b3b0a31f2be2eada2c785284742f21b81938ca1a52f7e3dd27412434d316947f9c2457ba69b9c5ac75cbb81ced1dbd0fa701a19c76d3942fa5e381f2c0c4f274cec4458c4987c3d8903458e47314903657956fa29af88a22cc49cc08ac33a9678c5f318d4074689d12b56c90daa79cb65e40025946822e6103e18c8e9b8910e7a59fd788c31fc30d51a9734eab0f25e9090e6a26eecbe8da317d7d8a8b99a60e2dbf698ef4bb406d391976a69f7478027dd3d5db0ca93dfcddee1b8892a4ec8eb8ec66fcfee2593efa570ee13fa7d26b7d7b6145899bb7c0ee822460ab2aeda0b219cbe3d678f6e3de043e3d76d1fd1d233497dabeaf31cc47d48591677c3033e7b0fde8047fcfd1d12415b3dee8d6f06199ec55c04904dee665234f66f59ebf7ba840220fe5cbab3637f4ffa9e8a9c59da675b25001136619807f7a5acd1319ff2ce814bcbb01c3928bbc425c40caa166eafb78278b116879c98756018b8bc8a94922f4a8eeddcc4c5c9c3de741deb995dcd50da11232bf78e242916cba97ea1fcb7ef479d55209e6c48913ad83c8f110446f7a1166c44bf180f1bbaaa104158ebbad2ea2a4236f44e658f9821884ff8f90cfee783d4a161c9a0d12386d3e27fd98a27448748ec9612ba99a66258300558863ae49d1ee342b9be15b06d4a4de1246d8adebb57ab312861647ed5ba9034fd49c4971346cddb1b47501dca38fd799ac04c0cf62a765cf339815d62915197eba18fc5959dba18e731419e55eb081613cb29db10f4769ed8c796a4fa5a2f6df7708aa7ad6b831efadc91b9013ad3c4c976ac2c3894096a117aba338b63d1c61ab4e049606b054989c751eb89c4bbff00a5aff4339b6c29e421e330014253f3358bc34926ada2b54bd483e12a9800e9297e91bff59abe75cf90fa2c53779cb012fd061b25e5ce26370ea529c42a5ee0bb88961a61f4d3dfeefee4c03480c6870bcc18e42830b5bf7028eaca7d9f6c3d50378d47c0f7b354ddd9a260e9ea118e411b644082e9a92994e94e665bca2d0670db440672c70b0027a8ac42ac6437f400cd99dccb6c74089f382f314dc486a2f5e3af36915360642600f87070e3bba4c06c6840b2179d1a1003ee9842fecaabe753511835db8df110998418100b370cb6921e37949d9771b3111c2dc74a86fe276d68619a752f332201ecbf315138f377eef90c7761d78c6e268ac2b2b9a9299ca316065f6a1b75defab79ff4aaa3d1722a406b0fae6686b6ba8ec1a621f58644ac702182bf5d9b274b863c83c7c608df188a437eb6823b2049135837851a590c1c728e5b745788eb0f4b5808975b31701f4941b40ec6e8133b80ee02a69e14e7bfc1149fdfd10a62a70fed82cce1e707e32ac6a11f59ba9ded4e25796024b1c729b0e9eb1a9e5f28f7e29ea2a7f2c37474df742470a44ddf75e180414b8a10290cfde0d97237c67395e942d233be269c6410554e2dcc5ab313af66b608c2aeb861556b383ae4629ce308778595f389b974b24f5dfb9cb8ac9019650f80ed15f94c67dd048a858f6ebbfd8551b393bbfd275495eaf6c4229bdc9bc885bad1a13312a8c6e73cfb003b18d924c02af490f4e6c86d3b8cc83b8f493a2f89a22380a5d9dea0e47a68d950b697ea7bb8f1a69878b6d870f14b99c446cc67265c2c78152dd674e4ad9ecb4c76b62b77c0d0f58655eb1b1a0144150a7926bad4a49c39b6ef8af0218c05affa96b0e31ef895f9ea0a684c072c18cdb7c3a6d833230eb9a91712fee75167242de473aa6e5b35e6782982ab068a5984aa944c7e9c85bb1ed8cbb05e5d140e0736fe3b4b774fb72428d714a7dadcc9b5779e9b7ac2c22d0e35471af7d2a3ec91bc49b5b58ed3c85e415407df96cf8fb67634b8b35901f299d421f8d7da1041f09580b2babb23fb6e8c93b16c1ce6eae2c60720211843db7a5f857c7b1ac0a4a00515a138934bbf88774314ade4b2beb1ed3f14dbbe19792a026dadd2c3451881689e228cd57800950e378647520f372b9d0b866d953312e1b8e9248cc12951b4cfe3e32940a3911efe1773dc191f220a154fef99848803cb8784cb8d8c882c8bc7c15244251553d13167e196446b554053df7da43d06042e5ccb7a30b12a6e9eaa6a988c2f6748dadea5c6ee8313657fe6ec84d5567cce4b24ccd760fe080f4f465aad8147d8fe1a317803c6d2aaa841f9e8e85983d9dd9ef13ea14b104248559a6d4a790ec178f57fbbeb14601983daeaef49c06b9658d34599b596b548d7d161482392eec030769aea81d1efc9b2a77fe0ce54394775e9b9fd4aafbd44db4cc79e8787c862e9e8b3c794e9200521abc41c4952d3ce651949685340ffa65219bfdb6d9801c26f58c9eb53353e5d4d085720e2d445b17d90551572648b6941544171101571e88216b74b077384a465568801c5e6ff331bdb352f2e97a7539c446949560dd1516b092caa3603a946218a40b8d9fe36957196de6869564abf3f47aa19e833ef78e90ab46e1590a113ee67c415576651f3e91e76481e1919c35b12d2a56755b8e5a44127162cc2abddb09e09052529cc6cdeb3e58cc03cd0e14fab33d0afa33a93e170c6a0466fa51114a1f5f3768c1f23e4815cec692d8662a0bcf136a623067a60f1c9093d6ef8cec51d4b3f65217b9a9b6f8a5ae6598004943279803464c95fcad3a3a000fc1f9fbf002f3d26873b4406d6224c261085d7fc4c1ba9088031e5b0e5f1f483d7a1a4ea80da9083a8d0bd1e397ac591886f855b2de7c375f0703b5398e0b0a3440b19f3cbfae6e09f492f4328067205035224b6a4fbc44233d78f18cb43a13970949f5834c4f40b1495b8e548efa78bfaf29955bdf5746e76aca1ac9f4b15e4184ecff0a35fede4c1649c6993bb28136b88929f0dc17260419ded7ec09d8d1e19b4037e48f57d2de6ca730eef147de7ee11336b3594356a2ab2657f2b1e720e69663d3fe36882c5ce9daa39a988880b0d1ad0fb73f660e15f6ee0e6cabbf6624669964f2d1207bbca2bedc8997697472588cfb9bf14f993adec19cd118909c29f31416200e89b843e74d79d0df5c610ac3c5f6ee48889c7e1fb01490cb1a8256ff117f837ed28fc761e81049eea7c45f6d130b29c52a065645100c4b000bd424249490a1d37b6443dd88601288d22f39b894501d4c1c8b64495c2df3d39d7efb21540f646cd9be060fc7c389e023752955d64bf53cf5da8b7fdf5552194bde3925aec7d23d1b46b814bd0ab50e82da3e777a1d6b278b71ae994a0ab2e140e14b0659979a56c2d45149dc04231f9b1dfd1942fc36a95864d4fd4da580e187c3b36e400fa8a70f193fdf727ffad0d95248bc1e2ce03ec11d5d8d3e1e32f331c047cbcf737da00bc35460330e473ef7166fbfc75dbcf387be533b00e9615d86a430fba7663af55690463d2f715a8715333b1ef6aa2e0170c4d2e3e912df3221e861128efbc10eea160079bd593ec5bf4af22eb648c8b45bee1b2da6796d50512177a8bf1025f1a4da4a144a5d8341bc40d4d8837327f36fed53eb1eb9e690396539f699cf9ac483cecec692175d619371b974e3ae5de58e2dc082219fcf1f033664986f15bfdf4941b48686c549143012e42f6123f4d8be8c19c510f3b506a1b68c1eb5437dba20277c11d94bd94a671b2f0f071c5b43c3c1dc2005007022e4c1b5c45564005f5bbf67b8a09eb06ef25b36b38945730f1d903fa8445295c71b9a706212cd02cc04c9a7ba73025dfcab49faa1776fd64cc2419501071d20d37c7b001b5b0a4b21955be26d966eb4a731ad37a0b9c8cddc0cc27def34a06a00cc8edc2d982c4eed931cc894cbb3f4cff3933b7151b71dd7f132a195ab05f9e420f3f6ee5a6bd2a189231887b9bd3b46f3a7b8864df31537c50ca7500f13692fd427ddb1453dbf872dc35c36a7f88bb69668d8672b9b48c3bef9e99e9a5e1e4d2101ae32bd079e144039325070725f0609aef3c552d03e5fa17041e3825db33711064a59eb06c2f9b7e36834bc715a4dde151641832f11efee1219db1419c1000fd6f221b4ba9f31cbad579905c6ea7dbf142c9da8950065a69819f99dc4862146bd2ce2d48c2a83d5ce0b1ba64d7baac7fc7a87254fd1ee0f762e0aa608338393eec2424f6fc169a6a6969a6a682f07a08006a03c797c0ec2392813cf6e75fda81bf6c3c93e844b61747a1c5d72b3bcc9982ef8af861e5299fca2ad589ec227ca8b1030b63a8e83e4bfdecc7abcd1864be4b3b45267731dcbe4e8d9752413689f2e1c50f009f438fb9ceb0e39296c816c124d44caa09bd2161db0f8911a094c1b487471575d552dbe1272e996a0660d2daa49fb03dff9b1a1252ecaa70971217b4533a0e7e59d8f07871c69f8ffc3399cd04af434440a8c30ffade43a287eb3117bc9116626f4c1005652d28f5468ffbf4f4a3f17290e27b06c1a0f4a37760122d4c283be28dcb9febd4b063c1a5343f134177e152e99bfda3fa150d25c15b6a18c69b8a46c953026731f4721853fceac236415266e898b105db0a3121b4d682d90f44770eee7901096b539863155e3e28b8fe235e5d474b4b0529f0611f060379a3e4f37d8e0eb397c932a01ed678d9018242fe6eb4b5d36be482b957c0d11e7ac0cd842261417289430d12c5d081227d207facc291cf02d22a75087ec0d9cbce192600c32fc62c5ed331a8fc5e463dba0d4a0711a1545b4a50acb31a43f95991d9b746d162c099f7fd8f1221224a8c416fb84a589056def4002369655ae7708909b982b4e7487b6d6089d9d0a9f7bf113468af5364ff749831a6c407cf782f2f99927150d93ca91b8587ef3223f2693fcba2074ac93fcdcadb7e89ac564c4d16a83975526e813790aef8851ac4b6adff1e1c41f84ba7bdfafa026da3e291802810610d78c34329825710724dd9a5367515d5813ed59b5c8959392ed4c462537da136ee3695e2495a737e5ebb0508d569ef820045d693719f549346aa410975f73a1b2f062bdb21da90df7b420a55a0b5948b63133ca6bc586d5c4117d8f1877f3f13832b0ed040127ab0873a05d20fc06e857fd5d43400a8e6623e5253e0a8ef4d85087bde4fd177122448e6abcf6803832ea731aa1c95fdc574f60328eee7304754f625f27681a37264897c84df8cdcdff3eccaeb95051646187ef0b716d64b5043189928a3710ff9e2763b91841ce42b10489414382b319a65ceb0a66571213ca6d2f546df4fe7d8668188389035e5b435d5d719a83d8c44079dfabd196f61fc60c26fddf345c7214cb6cdc80050a7a1212e9cf3032be97285421af45af006c4a28bf674e487d13653d141eaec1b729fc085faf2d6c6f3dd8769078bbe3aa86fb8b4258f6a344a2cec17070dfc698413a5db57ab9ed6ae9850e6b8e460b6d6c08853d287950af928d296fe4bdc7ef793f811a326f74a23eee7166fdb83971e174f140f2d243c9f98a33cb8edbc18faf98fe2637196898be92a3c94aed3de3b5a30d233ff5b4a22600a5b91174c649e5e956cf66becf2f9b741132ee7f8391ca5ef43d3f45f96f64a00b50b9e087589e5c15c2f42d57e0a95e1ccfb449a032b6f75a196323eaddcc37f24cb75a1060dffbec358a00b0fcecea97d04d09a50a578f14c92c71ae60ea816c4b8daa0e43a61c9ecb19c2b557b2637445416e91b1ac0d7c6bedf4cf8298e1d57dbbeb25a25e3321c2af5803a4d1a14e3921e4dd681ce948d9ac27b82a43f6f23119b0de4ba31108cf02ec93c53038a7163f2539588f0262eaee92e66ed030cf299fa03dd74a3f0571c66b5e76f95ba204de9d3b955354f53bc7509dad7f8e7169de94c534c0cbc3bca43e853482439b71d5c67a01bd0d036d65d76e5fe1854d0e923985cc151abed7e4ae614cb4f20aa988924f0b0bd7ec597629640001583632bd388419db9e27947ba6e93427fc3082de2dd24a2546cf3b7024f9eed1b42df7a56b588c888e88816a1dcd43df2b0793856693bcf97abd227ed703653ece68694f8d2c07495ec490c722d02331b960d59c9c0fc7ae2b55c4da7ed976918924dbef442795c2cc922f031c995bdc79173a291c0e13663f964288efb98d839289a615f8ca700101a22c7ba52934bec4f54fac46b11f955469bc14bed644e40184d12a353945c624a4c04f2f8ec36ba18b1024f4b01698c1e5f644983216ce2e3af9a85e2206a5c683c013c1e9c06ef95eff5ae4180e3c9c923eaeb40e7b57180702cefb6d368de9b81f2f6cea761bc7a4f55fa60eacb19229e5026e68e0892a7dff4183db1ba46ce0bcc19e0fb994accd11e87915984c1a508e2c3487fcf240e721b0cf35b1439a51757118b1c1481c0014e1c9d78d7303623d9ee86291ff9589d9a82c7e2d28b14955a7e526b096a8b96df6bd71e7dfdbe6a0968bd9d283bc7b347c39854eff2d18407e77e6d4365230ae1fe5e3e35ed5f49ee1e0b8465004dc2d0a3a559615b511ecb0c0d88487908ad1b29f9969cbe2935093c030dfebaca2454ee37322224fde714d23e4262e08f87f0e063a0bc9fb98fc9e2aae10812e2202da38311851983a9d9c901408159b6ddd435b87e4d29698496557762d9e16bef2b71260ea3d507a08db74187c1e8270dcda32bd8a543a47b1705df594dc0d1cff4e0e3146a0fc3b0778d912e4c8e34b56ce63e880558e2fe6263a4f5a80e963e5b0ddabd64c5bb73a6cdfac1bc260447d243aeada03a64d8dd5f094a2636bf62421f8c25d20b4b26d913508c9591420143211f55929e5b539882047029dd47d7fecd7809fc434b1c3fb8a4a940e9115d2081023f38bc76faf1dcfa48b46b1e20e6915c18ebf4328ca5f54858fc2f4816df280569903e81e6f68db31796c12d24223487aa2a178297a14e4ea390fe483bb8660f24e962dcf05687402390042d30a2c35818fa9de9316b3c79627400688daccb7d23d96e6fff42d7f63dc560675861cc35f5260f6236c922dad351e69ccc0756f8ad67b6e323a13faed0408200a0fbc0dc3780b22e7677cd3b232237aac64f862f33f64084ae221348546aa298c789a0d17c1caf968d3a262a08ee9bdd7653747dcdedddc3dfbd79be29c625f919f786811dd8ea280a060b0631b69941e50b0085f1dedd87ba954b097f5cf7304b2cf63160351c78fa4ad3396b4e58de021136df7c042e51440bf92556677cd630be115e14070e272fa0ae6a6f9fec24bca37cda4a40ddc37c9c204abfa6af193787b6718eaff64c0ebe362171dceaaddc6cdb3b88d92613cecb7c832ab7ce503aee2a0a64ded8c213b91ef35556b84f542792f9b5321002197392f180ee9a78cd21cd98333c305eb1f53372745721af6deb742a1aa622e7dc1964e377dbb9d319ce33e94d11a5d211964bfccaa969003e1d533537ea2e52d46f98bf8917f57247a4fea49c91f6711361f04bcbb320dcc97ccc81c84eccf956111de122cf40fed5e855841a1b4546af842fcf0a4d1645c3fb9505e887ccaa61389e4825dbb23ba77335633c895b41279e46279e02b18e96f566753825a7fe98c2c62fb9527edde51e43ae85263a1ba44096ee8135f2030c7efaf90720e8a7cf44a58953d3d6903d7390dd5dabd20ee242877b680de21fb206a75bf68834759d4a87d31dc2719b513ef806da4519b6271411bfe9afc5b8f7b1b6a0cb0ff02895ef908066ef2609a9730be939a87ce91cbb273e7c442f724593e24b06a9ed26d1ab4a009e67cb218ca5798f35c26ca5b71a2b065c7f52070d5f5f6ce7389f3654b49e888bc081df70334bf20e2c7b2276c07dfc2dd78e0fe6f260f2205c60f882f14180ff33400f5b9badac39d18f13ae12cb7654028ba0d88209d560d02dece6ca161f31249b7282b149b84d973de88b45044d236c23861fd6bc3884989f8a667dd7226a65b7419a1be57b9f50d40c73006ea32745945deaa4a7cd2cbbcddfe101ca46c72129a295db4c91f21895fd63dd4bb9cdaabecd500475633b252144fc64b93ccd6815bbfa47e73833511ac69fd38559a9a08fe6bf67e6197f2fffe35d51b0dca43059e8e54d206b7ff5fed050e71462428f233764f9cd883067ff7477984140b0acdcabc8ed97b6c001a6bb506571f5989e750145cd7182f8217b1e786469987e171b8dfb6007d39873a0c2088b278a1957d20d06073cf723b09c01008c52f118d5886749f0625dd612e5681f8ffe209a0124e6d0df07a9aca39029feb3de5840e3e61754e319a7628628ecc7312b19ab64cba12aa665c25348be574315432a751907eee057ccb1655b97718795713db1a76ae05bbeccb77395c9318e8fb539bc6790098a7190775ebfeec78ad4fca06954db4a18275fda419023f85bfd0a2fa705d335333ade35d661170fc0898a8f0759d3b2bd097a2080119db3d99493a626e3d0c5e23e797225824442b5935c28e2223020639764006eef088eb8f57a9d129859025f2e1d5cf16ecb8a6bc6141866192d813765ec3c215f2cad6c0de3cf190d94da301551af1847db2e0796aad32049ac830c25a10fe15fabe4fc74af39f9285fc19d6be8a76e55b190609581c8d070d0f708b8230bd269ea6c1f2d7e9681009511c0c9d4394a90b6548963b35399633bbb9b054a6b36c44f28cbb1860b1fcf65998b991c981b528b27147e7000001ef66a784360cf301a1bea9274bd7ca70baa9ecd245bf84fc825de6e579c629aee8f7ec0e867b30f742cdc2e45a9edc8c890b5075a8bb4e7c2df6c7e4a4159c989d941d59451bb67695a00dc60474134656936efaeaff697739af4a57f9272a9a6aeb2507b4b536be4643ec2189681bde910fe99dca4479c6681937a77e4f1432261a064efdde8819d950b5b00a4bcb1a4eb5b1a696ea43aca006ae917eb0ff5922430eb1f772f6b97ca30a578b4ec97585ba188025fa12ada180e563e3387a2e2d875e6db425555f31b79dccb1475a24fed96d52316aaf6a5cd932f85cb107c7f9824835859b396ce9302b104951c9c736befb0704ce8f5947894f4bd204065d4faa47f212dedf21149a602d261954d7cc52a896e81d7b578b381f9c0bd7694ccc7bbe1806537cd04354c002680976308d4f637af2d4d988beee962611a905c8319e3d360445f3741e7977eda96c0678465a7e08f367be9924f75bfbdafcf078b89221532a0bf145e6b5b9454498d4b35c2f993a346b39bfe603c57969a17083a49d724b09b6e2b92adf050c6e40aa8f90d38b5bfe7a3385764c05096cec3adb24e6e29fed5199b2966911bb70dfd6801ba3288ad9728f00ebc8aa431ee24fcde9f0457780e88a57a7872734befd65c282c5385c13cf1b7e20dea9f92ea843e015f2553c27a8697e0de286f011d7de2e5f185bba452553ee65bf820a04309bd75dcfd79eae5366060f09a9836a0723c4e9beaafd9f59ef4c2adcafaf8d0446cb7f84699a7efff1d32411d807e771e2e36b7156613f36246b20cc94ab67013d613b6b38cc7799445b435f1f8c0ad3e8d2a051575de7f44e10f00f320e664aeff8d9fc5f4ef2eac3b64a6db536b18d5e135d0dcd30746fd57fbbfd3c5c26fd1062e76e9594cb2dcc424cc8145025b79eff727ddfc86b24e3bce3161eb5a3471a1a60a12333c7c49496ea072ebee09659f78f7ad3dcc29bb7dabd0b1a4233f623519f32b6604c9feb7391181b2f6d304024dab983b833dccafd795e83f1817a87d00618d12008456ff77f440214ba82fc88143e5ff403c07a82a3fb39ddc2544d7d45ed2ffc267034b3a60291be53480a266152a8a30c16789d4f90217a19f7e5b4fcbbed992bc6b064bf494888e01b2b91d04d362478b4f6a653f4b7bba916655cbbebc8bac47745b9a16e34e4c709b8b05ecc39eadb585c847a02bcc593d964e63c423e414ead3113cada04b6fd6db9fec86f951f3a7b51193ffd63c8f81dc27106535c05c26c0efa52303114f43ac43a16f757a8a9e67f4d85f1f5cddbc190dc4f58f6f6333e0fc847ae275addf512e75c638f9bbef4461a0be4eece9566d315e9aca6265c8ae288fdfcf474c3e4fe3023cf1d4fb04e1222aabb1920cc118b7f489da1a1994649d644482b00764d04064ba7d23f054957b666d8012eae22e413485bc2a8d3ee75fe0a8bb80582f50ddd3f5d6751d44c63f76344f6d220aa133df4de18d86b5df2fe00c6a2fdd0233b1849b5a644dd3fd3b3d137f1a4597402c6faa9fac072a9f9c55106cfa8f4a36d3be334585445be77da1e8c072b20d8da1d464ec5053cd0b562f183cc8d8f1a1363aac40acef5dac70985f2842507870bf9dda91dced1a5c2c9a74eb0be67ae46e4ef49945208933da97b2a177ba5525859524f4c394295cf25fde937e1b4c02441d128a4345dfc4eab765004af4a97e88343dfd3e93521815972bacb25ca5b7226feaa98986cb2a1d4fa6634f04232adfc92cebb9f66b7bd5373c4a37c323f3301fd88708c52a01201ea30e6194ff2109128b318dae1af48bf420f4afa8e5b18236acd8717fbb265a7a72bfe1c631906c4b794e707b5ba2f94d243709a599da6e28724bf5a080b193315f9bb3f268f3f0a2980aadeceb715d091d83b5f048556b8c65adebea09ce19c6a526c00f44f18cd92a7ddb288bde3c681a513c099031b9af5da8f94388e36d31097f1dd3c128b3a88d941841c5afeb9cd295752766d3e85353ca02e3fada6f6c785d63f715bbc51cf480b4861a3feb90280b8b1276aab953290e8c30654f6fd3d11a6dcd1891dc51e6a51e5859a49c7e1fff56aa0fe80d9eb4d97cfca6490ba583f388702a3a41b23787d1b4d6aa81546e6eff9cb013a3fcbcb115e3fe7e068d8b21c420dd364283e4f1a36bc68e9139476546dfda5982cf3aa138181aaeb04f7d2b2c49276e90ed4d438214bd8d471df05f61c706ceae72ce548023919a98f7fa3169d0d467f982154a0f714c1f7eb547a58e98b57f43c4c5f33f6ca381024499232988d1b58b565ab2435e6cb9c35f25b1209669968f2f587d4a73aad5eb9144dcce87c224f6e78cc906b9525cb50775048c6a36263452d3af46260b8f72a15036431a1e6830fec2f8393935609f21f119798baa429fc4a201fd789dbc597fdc1691e8114849d2451cf3772b9178fe2712b59c9745ea4b8cb103924d3b7db400e3d9ca1bfb912daa478008c21c2345ef9aface9f66000388bfadf97ac2bdd523d7da6f48f88e828bd30a5bf9e5751a096e5de821a194d30a48c430c34da648eaa5bcd34ea197d40854be0e927de87d5e3a93a8519f5b56e7a978271d207eca08f90e0197bff84adb1db5c48c1c899540f2066795462ab2d86a01870eebea1f67cf280b03ba5ba14b0ef7cc42ee7083aa1f373386abc9160c50262d10f93556daca5a180bd1213564d6bac95973d0c9519c0d8559b38a2b334645a554f2d563069e7b72e3d3bb89a89ddda15b31c30c07c373e39b5e674863b72ee4e1fdb42265febc6c16a9df5f2f8819fbf7666f967007effc78408f46fe50f619187349984d3f59c7ed3b46f27bce1d9711ce83e43a6f657d05a47f3f5f4ca39da20a6a947ebeae524270ef6fa44fa952dce8f527eb6bc8818319e73b05a063723d673108e2820b30285d8f83eb689e2eccf6ebcf2ddd63e313bcfb3e9497f814993a251420e79efef3004cd65f44cd16ee16c4777dd44abd9eb8301342b3d53ff223973471d2ec5d2720810eb5e1da51ff9d583e1deac8d97aa84da47e315f31942480d10b8e3f7aecbd0b160a11084df7b12259a0d99ddb6e606f1439551202b33c5bec2016815ed70de6b3009901855c7a3e90c515a8662bdf4827a25ee665ca178c151ab0ef90f464e42b9cfc00fe404e2629087cdb0b57210d77238fbba36f7d53bf5d302580c34805f77a32ffaaa06df248fcd36edf08567e5c99286b0ada10138bb8db9ec1e7917e5303eac1d3b7165aac99d97095718f43d1e1e21f961c8604360639657878cb8d2a988cc6fe14b4838471e93d9b5f4000d6bd16096b047656f0a3c4a6fca24b4ecfc37a1e300fa3b13b437eb3db4112ae99913a82eb91ef2dcebc719aaefc0e0301a1d18c76b31ac25d20d8837c504df01834f6a7a03d248e4bef6deb4e409a82fdbf2cc780073f4c748503d9a881cec4005eac9951d46c53b792d3c6c732168496899510370765aaa9ab611210a35bd7bfe0938d4a685ed62e1ac8a09346973a91a5a8c939eb7243388edb0db00673a351b1733beaef82776b4b567812666fe0114ee0617e2340b0d4f0d4358080c7a09a961f25cfdcc539ef61621ad90036cc9e15c009aeb6b252452f3e5d3f5d3094ef5c23e793a22fe130e3898f7632c0278ad9cf005ac99510a95d48a03afdc33be9ff03cc32c40af01b2832ea1f51d181c14b186f5d155afefd093e31f94be008be92bc005260751aa4d83009b20357749053ec65d5aaf98f595c1f185807ea0ef0ae10572e683284cf7f4dbd88b4def0249eb4f946a578153bd4866ff0ffd085d7d6768c37c65732b9355e67356034f17a9079541f243c462b031951cae285944be967cb6148781a62b03fa70a7d4dbc7a1a755c2b4d1e90b0d47d97c14c3272af5edfa3a6fa87f3c0a80879883c2a4cdc96c406b3e461c7281a6c26a1ea040428e70d2e74caa11eebbac4639f8decc0edcb82ce7b68c590a9b4dda57744bde3d7cdc9e3c274ec5b73db9642d10e3f47cccb4614017154daaa39991191e2f27352180cb10faf3cceab4dcfb10e5234038d9f61c4e06106ec690af1cec6921170f0c623e4e04337a7be0ef7a0ee1230da2734211c5da6a171237cee84686c0ce14fc6553531cacd0e40bf13ab6a12841f6833d39481fde961702522b84588f44be52b874fe68e5fbb461d716d7a9b49a923f02208ab0f55920afcede5c53f3ee39e083c9e01b997d9a6e0f04021e8678dc8f6a3648f8783e7734c6cdc9b8d7dd10a4e79435b3fe402733bdbd137db27667a7266538da8747be52d6c9909721f9b9a13bbeae1c7b014423a14f18913403b0b1bbd2ec02f1485641a9286ebafd37018471432318e0871b29d78683042d07c6bac0a083c06014dee087606b92c2e9219759d7bf85673c7a398e72682dcf681f29cb410db429081be670285e91eb4ac28c70d5a9504eb9a502f6382b9f6f77c250808b97d1f5071b1015d55002acf2f9f3a09681050c58f9b70deefb7addfc0d6b02057f60426e21f6236cedf3d9f54eba4a743f5e29d1139ea8ab6681c02bc728848c03e290bbca49dd959b82ad7defebb7c9d789696dc215215cd533684f108c8d24b2016cf0f39e0636645258475393cad28f784371b83c5c3f7772a4a9f7dab0d241694cafde3a086230b668b27391220a6af86bd93c4264d9a1b676c320626ab14187f51caf9a374a9961ad5064400834365d01f6f43405128d12353200506d6d3c3bcbc184c7defe8346c67f45a8fb83b1b679cec59a613f762c992583b577be8082fca01b3b230b4546301e02e3b389326ca9eac9abcec968451540b68171a2ec2b6751f8218e2063df99b88ef45c76447dc1c6a6bdc886ee0fb7322578d10acb78ed89f2a9a06890b80ad54e0b48a6dc8ac41c04c35019f06a57bda24a7866e461ccf5055832ca556880bd87a418065eabbd111f1f6006dce20aa55efcda4387ba4ab633d31679eed833ea693f82c6c6fb7a9b826fea1b3d3d1655b442cc4fc08eed39567688d5a10178a766d115b21a1f2e59dd32e0f7c6a0d7c4f06de1659aa683b09962e31a863dc582b2946a1de2fbf5c5aa4d01df379e4a7b78ada380cdd52ada2fd737e043546c941d1407e156953a217cf7f7711aee380bf4a8c6bdd176efec9010a614074131beec2b52718696f623212a6c01d18ed0e23c6b8bbd3fd63e531999baf804e971e1de1e4dbb439446c59f9da1b097a2a95ee30bd0b2c7bde9a7d03c46d8e6ab01d7a59e5267704fe8d4668b5c82fac7192d91a60d547b123dc8a8255ab43672412f15b0f1db95f0479fc2297017f4336fcbd9faf54bc5495a22de5b0d359c6c33e872ce0fac226d0a1fd042d0c6448282955b92cbefe9844d7cca12b4a19167461109b20552387d25d3a7ade56ebb79441d50497b923651be1551c5eac20100e88492a54bbcf211861b0e41204c5336671b5123d2317e45489b45abc79fe55e0b5b9972d21f0199994d979e8111caf33ae07d13a15853f88aee26a0460522a3f9615954e35aa7a3d9fd064951b960a9a15914e2965286d56639043f5d4dd29a364dd73414d0643a9550dbdc940e351ede8c5bb304db3158c28dec2445cb016896227985d7588fb225afad8707771f0d78967d2eb09f6efe21c8c648cc8867914ce68e5590d396c74bfdfd20fe8aa53cffa8b14b3091d466139a97c82b6caefc0ff078818a18f8ec208c20c84fb214b2fae3a80d2ca189b181d6f2a9850b5d79920069086930a0298df90a71ab052d52fb2507164f3c1b7518c71fbaf4ed5e12d4dfdbee5b0199f4b7d0cf1e237352891439c9aab3852ddd268f52ce00464f03b6443aa40e4fef5838f2f5e90f3dc05d52d8a9e2d7d279615e5eb321260fd19105023763005ca06728d2bbb5620abdd05a5cf0cc8c0c24d8ff86d5ad0223b3b243bb50ca3fab25bcdc39760c04d8f2a0bf814f19c68119b5c8f0fdaa0bf7aa75274cfc30b1672c1810a7c42a0f9ecb7c8db58786ee6a34b91f792ae2f7a19085890aa653f182c844819aeb445b387341bfeb21129731307fafed2e5177b3664611e9b805e242207a2090498f8d3b41f7b4f03083e21dcb35713fc0759fa9ff6f67319c2f6377a7a95895e2fa699737cc390bf02d15be435e2ef4eb4678aec76e69264b880090eb241c04488c94ee9beaaa43e3f6c40d6a8d637a048477170818d598394c88540d07c155a3b1baed30fd878edf0828862e5dfc9147aebb178beaedc8e3919e2b33e5493cfb79f8c39267c8a8ed757a6bbdf93bd0d2ba6e643d076fe1fbb5746bdbe755cb2a665cdfad65fc150f7058cb38e7190095fa859f9d51abddc858cd2c86330b585d53f80d717af937454e00f735ecadfc0ceff89c2a0d9e196ce794d25e8d72a55f18bdde7fc8ce1943b08721bf63789929805d48a3ab52276c320006f6ac1e0db86b8703ba61986ee8950a2ed1be38a44defb2db55393de7aa1486a1e02cfacec5d1465a63007fffc92c5af01fab2c09451eee72fdea689806842475a2a518a982df3aa8fe691cab893add33330d7e8a17e1f3223a4b0c414303b7415d90fcad51693565eb4b3fe26812a25befeef5f5b73fbdfe182f12bd73c77061949c82517d30cc1e22a49dc6198c4211af38838ea5b622e5515568b297eb1eeb2639e09582b1a3704b2d636335d85e916e08a53b1f8f175155a098cc6330e6307c7466f8e790833be31ad2bda23d935b7fa5f68d74062a8f1a18c9fb7b0f80392ad1f78cb5b40f61a7220fb79caf4b80eee42b0f6c17df375e0b4fc9a7100af0c9c976cd33a37189c9ae39d853e4e9603537be8c69a6eeff1522f4238208c0beb20ff3d474a47196b0433ff0bbe60ec47e1157bda2b753de0dd8e0784761f146a80949dd0bbf526b87879ad9320635b3bd9df280018b3dc1c65f7c848dde78b2eb20e7981a9ae7ff7a91f2a8f5ba347680408afa6b659749bb26c9c48f72665d097445d2e7e4dff201c0ff010f48fdc207837713eea25af7f158f73eb610e53462024c2c9fbe75ccea90d13bc7f1e448c4b36cfdea86c11641f7e1922d00f2f9e1d4864c91d40607c97ac8e2d8031ebc7f5ba288f5e1337dfcfeaf0d3d5a12019c0fe4c76371811ca54069801aba595d32d7538ae73707f3612655ff26c88d4cb4d8831d5afc0833563d4ac2039d2ea97363434801717a8769013c11ac0ed6ae54b034d4eb059503c60106a7e21fc60c36b599fc90ef24603d84dafd0c4176e38c3ce392f7fc0060960cda47953c2990e57ae671ee8378368294ee13b3d59439897668c106385d9decae81d59278fad64d85ca62f08228ceecdb38bdb70f3f1197f809e9a9a30a6234447e6526f07bb7d535471cc348e7012623b308df1ac4816a19b529cc81bbba2c438872b0da2afca4d3496a304c56ad403a6070ffbad1d02dca4c3b05d90f54f1d82f20c09a1e05c7bb094bbe282e06ff6fb91bd5801229eaba3c1d71676d787b026f485785e9c17993d7ee3a27d53736e86c814a754cd144ffe2283c1359bdbb09422b45c6d29f592cb46da5285927d6546b4554da13cc65ee1fa22740161bdfedea00c7466b2643f0c3005eaa968856b49ad193fdd639bfa7d1e3674c91c92b9aac2bb01bb26b0a6225e6da9ee4f4ba6dd4d75d593ce761abf0998d6bd6cd2d9d54eaced69b7423d572862cb204970875912faaf2350f53e0a0d36e159c77a6f91603a4902b2519dd0d93b259571604dbf3d55765335dc752fc94b23599b08b050c2ae0b5448f0f97dba61425e89fe7d4f692c3e57d0838fca8777e9b514e9af1ea5b4e804608a616539000d469c7d6b33ae34f0f729c360f204f912944639c82ad312c4f31eedbfee0e00b7834297eed56e23388fe37b328d8ae927b4a8efe216611d8d97d8b835619f899c9581c2e427ec6915b2d2a4ebcfeeb0bfe9f9801f4c0275d10144548d8bd19c13e712d93349e3141c881a715d76259441ce4a2195ef70f99707f86991fe35b0a36561d9b11ca3fc497f68c613581ac83b8cdcc3dd9d1bc6eeffe13dddf0f6b95c135c8fbae10b46ba6fd8b91b427cbf79dce92b382b5142dc4469d28a65ec97e83913bea81ead74abf065ad254eb6d3bebeef60a89f5a25cf5d00bbd09ad583fdd17e7a6f186f8179df9d91919469b5c82e9045c8dcc59aca244253ace5f99963aa04ec1b91588041aa28566a89a220a3da54eeaeb5f889d87c1d75796bd00f5437b901c80da7cceefa3254802e8e2d62050984cf78fad896c8178049d84be4b4e1d6a1960795bec6df3e9be32b2c7ae6d80041627b398600d9eb6b7d3a25f718d40b5f18f5384d27782b4de90bc418b5c232b1614e4520b9fa6b47f5700806530b95a170921e1a53c4fdcba30f9aad59ac8b28710208d5860a529e1a1ae1208dac52ccc0dacdba22230d71b63b32c857fb1ebfe939d5fad572ae0828836a8d9fbfee7b880cd3a4278e5a3463b394849e731c6ddc8387ab43e443f6beac6971730dc49f700632d089cdc7e00deb0593caf0ec76d05df7b192f73f23184d42b4f7ecff851adc419d75c077eeac863014de8a58f9fb325ca546421fbad6c62aeebb8959f51e7a1ac9d29b9910ada085c85d5f1837e1b57ae24b4b93f5df9997cc73e04aa36d6a07e0d550ae270cdb3be37da01e4af63c3931343b912cb7debbabadb7b522d5541c335ef0a5d0c712d1e5d38de53f40df5585322467df7845f810c68c76dda9da9fb5a6b7d92fd5b00e9019dd88f5579c552ff95aa491df6dd2fc09cad9ee085f17ec652a4a385ee91732c0557620bde0b8b1a71d7e6103a8e90330d7f82aa9872d9202a630e76ae9c1737d1b658b124a124bb19e866afe9ccc25ee99b0e00a8214fc37ddd4600b27354bb58b332c9d6d78e690052955f4abb8cd7492714c59e1f1a848db44fc601834a812196c18189c36c1fa60299c464e1b246264be61436c4dbe08be8f782c1d1383b32b84e6fdcb922d348c2f6273c4c8ee0524989d1646388fabdbdc56fda910ed365a5cc8694d6bb314956ae4b39dbf999381cd7623de15b9becbede367f99c1db1d373769d30db38909b162e4339603e18e8fbb08d1b416463454ba419d9045a350749ce859abc5cfa94364b688a6939f88b325fb96301319cdaf405354b9cd62f8dd2c2fb9b90189a60bf9ab11f3108cdb9bf0fb5d7537f67aeead166028662ca07aac57fb86704e0d83217d64bd7fad12acf24dfecd197e25ac6bf9cbf0cc65c9bf148ec0cf7fbfd71dd6ab89358a7510a4f014879568fbc7aa6c6391c19f026879578348a59c7d35786fccac19f0bcc5a7d790080459e0b63d50606a551bce726cbcae2c01949aa3d35d47a5aa461d5301fd0b5069c03439c8304e5e76258283ffaa5b01f32505105f740db868ff561dbb0a45b2e2b72362250481d05083b10862da728fb926bb0b8ddc35de8cf87d4169562febd1a524e9b533ad75b41e59e1c8a7c1cba1c9fdcd16eada51cd5d86769b9073a9c442e7acff625a7dd10ade5c05fd17f1079c86334459d97ef4ba29007a5b4a64d804ce84b38bdcd8e02c61d1f793d50c60c7578cdcef582ae4dcca74625ab6eba6a2828937c2f9e6ea9a56ada503ae4d900b0d4ff84f7b01c51972891285f8676c659227ae3861b0efac63ca07668524c3264ca2d3ae502a0a342f60856bdc840d4a0d81f4018378b36c0cf7805f6b52405f25a29b75417622f25eff1ea2337f286acbae0bfe368d0c4580b941eb97328ad4623d743de60613f6cc48f248905479e7467abc63b1d0d232c3cbdd3cc0b05a7d93b49cb47e1bc20b05e4be2c807df9dcc11ce60e8f85c6d8b2cad1e9fd424b5e65078c778c41de4972bb1136dd8acd57fcc7f5f62d57585eb39d43d807705ddf6e0b25bbbf0ad35e417c713aaa90d1e75a3e9e411b583137f019b9453bf00d948ec7e9b88bf6e193e0dd3f8286bec8f32ef8ac2c8588858bab1c984295b7a44a0f43be0a3bdd44cca25f2c6e344304047e94ca94bef7d4567f71e1cf7660284223276374c01ac173b543217e095f77ed05cacff9b88752b540c300f6ab1612f8c8009e470f8e2b7f3853244fe9342640b5705949f58279d57d5a41e2b73ed2942981cbd13e6aaedcb0cb56dfdac427700bfabe36698f757af72b8ad9ba5a25eed143c1bfddaf0f0a1ad613d3857212e6a152a0bd13934a7f9fd567a5230516468f2deb78fac82a90909ce81073f2ec935291c3f09b3279609283f490fc758819e09d92de5f3ebce545a35d564e576f67f45158da1d4646f8701bca2063db25cb02a087817da464a2a48102e3877e02aeea535fd4da1651a1dd565618dbda9c8de4c4fd77c41818a9050688b2578ccfd1b4e23c17de61ac40ed2d61167afcbae548a807fb67c010eb26b9fbb4ce3791f228e70e06b48e8bb44086dc5f4072352bdcd1456582f206bb3c078d09787ab047ef547eb688f07e30c7dc30870156bbe07a2cb6f716758274632606f0089d4ecf3d73658cb392a0528a80f19779e538d600323ecab97a0e33e9a25d1817902306e131759c315b6857453287c0c46930b4e80f0a7fe4ee082359b21a222a1bc1d4566762e9dec8f5dae24eec8ce4ae9b51d492a20e4f923aeec1b74660d4b5afa370eeadd288e63943c6c25806f60a77137546ffba9091b0ccaf2093b6ea353abbb5cd03c56ca06b08a4743232cebe01817d8f75aba377972b0c7386814b35c940b5b1243e75dbe67d8f434ec204223092f4630adc1ebce4f276c2604c0b9785106138d63df3fe69681d790d1a054d1c18d4ecc2583cf7fcb087d5311404e5a8a51613f932174ff93e1bce5580b80abc9a025281091d46340a90c63a0ae926344f531487a6dcd78a6df4dd7fb8b419a6c9d2ca3031aa8c28b5d30ccba9a0ec5922617dcc1ebb501475a21a6bc70491b98de1303dedf668a235f05dc25451a34654439ef38be72d3c3d1e6cea9a2f3a7aa3040a48afb45665745254483e64dd3bf0f21a021ef8af767beef6fd2dade7b6fb9b794324919670867084508159ce241391f8a15cce82573d99e4721215b0e69f32116492f872d7b82b1e7130e23ec1d8a6c5761cfa71cc4d0c721fdf555917376396f38e47c05a91b08220404bba6b0ebcd3b8edbf88d0d39a72b67a753994e4d3913131393eaad16325f2b538dd5e9baf47495313131c9549ccd76739bdf820809827f88030df156557df97d9021df97f3f6e921425c3349fa97ced70f5299aa4e22e71f80ccd720383f3ecda87134b665dbbfdb6c1accd7f82017e69036af43dedc5811799099f7b75a8c968b5aa53a3950c5189732ba36d197ffcca9413a362f833ada88be74727490ea2269527551261a5d8e32bac4b54a91677454ce5fd6589783973dc3ecf944a508ce133991d3245a8489ced3292f60a638207b782bcc2115e044b3ba847e7e5aadff71ccb97e2ee70d290781726f8abb6a1512fa11125acaf4b9a319cf01e3e75a2232d7653ae21163cc43a61b7f0d32027feaefbcc7737e9f66e1b0ff8d7bead2e777d8b1483211bfc683c4af9f45b2c75d78f44e63f14642f0e78526267470ba56561a0511b267ed7ee62df339dd6920d3b6e72cf2965bcd04ffc45fe441d8b1952157ad80f1ea3ce6398e35dc98c70935720005f53eb814972e5251f2a42f4f33c98125792b47d3189d51fd64cf9f547bcbee40d2d122cd9921cb38214f5697e9aa22fe39ef794e0aeef0f01dcd2ae2f99de7016f686e6e6e685c2c0ae1b5f3532ce2f91d6dc4d22c9adf791e2328453ccf7a239da74639cfa3270d196408c9d344a6bb88e76368232834cf13e38f5e34ba88f53bbfa3ffe8455af03b3f027ded3c110bf45797b3a6ce4011eb6368a30de60b5797ebdc6258f05acfea22f5cfbfe6d14444a014fdf3b09ec86b9e8fa17d54d78e26b2f33c12d8d19345b2a69e3734f3e666ded0cc247b3e157948223188fc5bc062c578124a510ccda32d2089b0b4479f8764d17c8c9faf1d9245a3591aec3ceb79f07c0ccdd2af2745f67cfa379466521a1a4a3b3a6f665ee88d66d2190d79c81d92488c67e9fcce4b20e7799ec863901a5717cdb348223abfa369e88d2e799e88cec77831e7795e7422a6b5e753932e36bdd5a0185fb67462b030d68941d2a51f37dd79fa19c88393a44b3436714c2239cffa1d92f544747ee7a994148ed40d95da8941ea3c0f99f3536469a0f33bcf43e777348f9c67fda4d134a665c89c8369ce5325a7b11c927271973f5905cce2d0db796fb5bc2585e3230da494c65458d08fd14af3294c1b3594066b01be699ea563ee3987687e262fd190b5c8f4a15f436dd414260dfa744697350434d3a7359cc77ffab331975c75d618095c69a8a555afb5d65a6bad4cc250e7ea129fc5037cf1411edf8f19c4efb94ed0ddedc67a02196f501a9235dc55b1cba02293d60aa91a214170e74136220265e6dd841944542f3083beba6acab905de4e65a02eac204e2f5e359ab56386e6c397919973cefcf44b9a65e67c99cf794e994c43ffc7ff0f22c4c8c78cd498a5b254760e09aa770c31761e78cf3d11d5ab5eb45b728e4934876ab63f03e690b7c73999f0a5cd73439e7bbe549ab5237c9f2a529470c4fc11e44021777b4fc1a713739cc8fd383a753a6e6f15f520f248407ec99c95166a6cde62e17f244b0310d4b3ba42fdbdf72c1edf7bffe9210ca82ec7f97ecfe25ef5472f4fb32e0f56f7e37bd5177dafc29d2e12fffb4f1b893a08a82f77b923a77dc31d44e5ac95dcd37d1fecc8f287d57d24abd33c42cdc21f3eab7bf18f5e1e8b8766618d9fd5e9a2f0456d04a57ba30ed447af8f7ef0b3af2e77f4e81de09da20ed6dcf66a16fd72d6e8d482fecfa169abd17e708cb9734f054a5d8f53e720f27c23a55b7da54c1f865cce5a8f1e07b0f9b2c70e4bb78dced555675ceefb9cc39f9a6c2197bf417f7fa10c727e19199907694d4d4d4dcd1fed1a7286863cdaf4ee194d004a23d778aba7ccf8f14f31973d1867f0bd05eaef896a06d2336d8fbbfcfd26230579bed338e7654ed81caa2d6ff5a81c9e400298600c24597cd5ff84b5a6227790020075eba706f9f8eabcfdfcfcd4e3fc580522c6d179297871dc79a794cd49085b4af0e18a06e8a65fedfb73d0cd2f69be317dfc9843d5fd68535dd20c4c1acd8714752a66d55bf365a871a0f11de87bef6b70e06e0f480edc8d835f4562ee31891f879c791539f3204896cf7a500764913a640e39a74b66becdd3901eccb77970d2d8d0d0d0dc7d43f33536244d8d98f34a8be2ab4abcc3f99ffe911cc99ed68c1a42b46cab8c29b91cc739c739de382e019c3f7b621ea3b573a649ce9ded4fbb4c707eaffb3c4f5928b6dd976ad26cc81cf222ef3feff1732c0dc0ff5e02a09680a785b86f85dce99f96c692e7972d1c5626cb0586a6249854d75a16955cfefc30115fd4f993a2b69ad0aa7c9a55b40d0ed9355c7df82a92a5c1eac3950e593c444a021977ad1f8c1bd4e58e0d64dc5de7e9ec2debdb3748c351fcbeea12c8b824cf5de6397acbdb75531aa30375da03efe9db0781fcd8ded34969800f9640c6fd7df71fdda08f93d2a8ef7df7def4967f4c545fe341aaef6ab8cbe61a845ff6c7834106152239bd14402e5d6c5ba06a332c539c644f9230c59468d294182f37292e5136da6ccf396d92284e2f66d25470d3443c6923793e408a0c14e61bc9656b0aa1e5219583214186ccdb10212121a1214184dc820819626b90213ecac965bb73e9600a5187c900ce9eee098b11d410eae004f9870f4c6f4a18e7dc026343cd98261f64c4f063e70e358c7bbed39eb40c310224ea8fa48f15b9be9d35deca795e1921c8f4e73741f10ceafe665fe5eaa2df91a3eb31d32c3cc9db3be77c3badb5f6ae6ec77d3727be42ba7d6fc79153dc2f338932c05bb5ce5ae7acf34e3be79c13055b6bcdd95b638db7eaf8f3738d07e15725725d9b75d639c588961662a081d6724d87f1e8f3bb3927ee640c81a95bd1b39221b79eb4e2c7176cc894882cc3c8c4fe018de145a64bb116688c2679e09772d9836589d326632b4c1a2cd86c537559186c069b59d8ccc26616366b22d3a99bb764907053ed404377bd12b99cb01ed56dfb615b9876a5f6a9f745f7056e194d7269c19e2419e791abd5a095e6a654535c4d9ce26ae11457fba6b8da9411d989da2e51b9be6572a0259b85b1a5551f32dd5cbc55bb484d9fca79315dd56a6e0a964beb54dbdcd4ae5c6d3b3950978a85ab511bb689d2a8514c1b1d501af5837e385057a5e610f7775251a718b7e428efc2843113a5b3aa5845f705fedc4cc06d39240e26666afad8bc55bf036ae37a3169d4af5bdc755740c5ae17cce865d7e7b22b4db25daaab3ebdddacd3cd3addacd3cd3add5ce64cd68969774c9cf8476fad2e52a95e0cc53ff2de282c0a8f9ea8c2c96892cb7a67170bd4add52099b7b65ddf3a554bab41aa9fd9da76a95b0dfabeb6987e698ce524298c731ec77f0ec95bb5e438981279979cffd1e66033651e3919b5b134673427cb7a756ddcb57132991179cee6d75dd65b9d554e565df53137e33e094e46c1e92d3b9bb1e8ab9e65ad18beea45ad7a2222c521cbfb30b47615eaf9b29a45f59c3ef44b9f85abaff9c51aab41add68f63ceadd6ff38ca623333dae803afef3fbae5ce2e964b232f945f6bcba49591d689b4b4a66d6dbd55579daa4cada58f8d49bb3e0ce39cc7f16b9d7948642a65f3960c156c5cadf39514f58605164eb3d96c369b952e639a61ecb719bdcde8cd6b22d74a4295aa37f0e7f392e99e52f5bb881b8cb01a3366cc181ef665b5d1075eb53e91db29de72a95d7acd69d5e518e73c8e4bbee42191ad936df296bf0c156c939d551a387b26b561bf14aa957e65a25f659b665b6bd3a60f54ad2e511a54575d0a3975ea692157cfa272d6d65a39ae723adb8c33ce18678ec6808ceb679cbdf5b80616ca00d32c0d6f418328eae1ada794524a73b05f605c6606549c39cb71d776ff5383ba9f5151c85f98c277b2eb2182a00782df78f366f8148681873bfa8f45b6df3d7d20de83e39ceb541ffe286c485211a50e7e08f93c1c9233dcf579b88b6cfd430e7c70e01fd698607ad8aebbbb5f5b0f9bb5e500ce1e5b6f489caf64f717e4549d4af5e148a9be8eeb4221e28d215ef27df1c3f70fe242fcc12eab9e95f3ea698c6e0cb627f1f126c47f08927f5ea998e03ce87ddd6c776fb5c01dfcea5578ab5ea5cb957ebd77e28dcee66b74996b3eab9e136fa85636dd156f745e87f3385ff3e5940b7a5651ceeb60b104ccec959375f6911cc9eff90d828f7d71c89f19def2bf194c1f7f2297e55b3b20eef27a83780b4847d627aa371e791dd7dae5c774f95b5bf30c360fda58a82120f84bb9fb297aff1b74a321b025d9932948494aa0f55fcadc7758b2f7436ebee36ede717e14ed88f3f6e7fc71fb569348320e79430e7120f0e983460e3491863890ccd33772a0fcf4296cf5d4ea00bfe671805fa3774de99f679ee68866c65b2b585efd78ab355d572586de83159c02998c86d050197d42a750249a4495c0ea59b0bdcf14e73c8e38eff842c89e0d91db904614667443da10551b4cf66c8e9c1a3284088aef518daf9cc0492bb520644a0477bb373724ce0be15485c1781b57c8be3343e2663dd7e49d913aab1625a34dac69a9537aef0d0a83cb65655df5bfbdb07bcaaa7f854f5f2b4bf3d5caeb05b32390ea8bfeca3aad766ddf03b5c5813820de739ef5dccee37c0f9d1f9fc82f4b039ccf791ee3b334119d1f3f47138152a4f3a376223b8fa367d5e58ebd7a276985cda119384f593c5fe218ef896f693528869ea00ec9b279d61fbd7648968d6669b0f3395fb4f3396f63a38b749ea58d705ee78dc6dff9a3978d4c4d6263e3394c55a66b4f4a28bd0c8dcd8ddd25072a2f9102aed24d427fd6d97c5961369a01f4d26a9095c9b0954d1ffa443e3ece4f7107d2f8384f6b8ca624b0d826270762fdd4a035879f0c84223082e390d7e62f17072aadcc81eca67fa11c683e1d9164d3bf3507cae9726f5436fd3b75c5781012387b3ac2894d9f43f2200b6637ca81e653d4d4a67f6d35887bd1a7b1b19c549303952ec6c9814abb64e640e58dd1689c9403b176143d7120aeb669cd61534e0b962807e28ad8f471988ca903eaf6bf4b3568d4383fab0b07e779d02f548680e16818cee3e80fb09e48901fb50f0dc57ece8f5f4e2928464a694eb39ae7894c7ffc9c37c27919231aab2efaf9f3e3905df2ac2e1afd95ca1c9279fa76c981689efe172b6f2c77311b2edea22fc5066fac065d8cc7f1ffc67c767963565f30a60fd78593f2168da64f38313b2b12c86772c76d2ca7ef359ce791f3e3f3c0799636ba800c45886961d444a014e16896e76896eb1d398ff3b24f72c891ac49d5451f87f4c0c8b6c9ca2a8c3e7943f6a79756832617382449a18b2d7ca952993e14ca8322df9a7e21e72faf8d78634647fed5e3c8bffaa36d146e9ab7214bba6d7e454e9fa2dbd4c8bc2569c8b267cb4cd7add9ba4f9f1317d0da20186dd583dd8ab55a55195285d5a4ca549ba6d42ab5484db2b2dea9de82adda5161d5b54556ddfc7d7b4356a4ebb72679ab223d0e79539d36fd90bc01c91268979706e4d1c7974683705d6115e6f75eec15565dd32515c67947362e002720931927f1cf880f6230dea6cc271bc46cfbf84bbaa452894856eae9862a9b520c367dea54836848e0cd061836c5917a9a12934da1af12718c2fd972308740a03bffe775b853ad38ac9736fe6d2d7e2297799aa791c9e48aecd103f45820f87d0ffa3528cda6bfc34707f48178902a03fa440da00f7e5ec5f11b8421db3e91ab2cd8f38efe434bb69a49d2bf66de897c86ac71ab500d2b43de0c6a58fde32d2a02ede77afda9d57fc22f403c5b38f006c1687b886badb5d65a23300218a72a3e052cc24c728f1d38640ce8272b70a9a21e357aece851eb9173ce3d7614d57614f5b876470f216fd11d0ed48383a639a3d4a9d42541869111b8121a62d304304c774ab3830e5ee825a4160cc8c129a54e67b0369b0d2ac80bb974a6ed4c381f26a4b0810a909cb0c194131352174b4b92a49e9cb04198272b389cb04117b35188bbe7930964bbcc2f83821fff01402dcfecf954430e4872def3a9862700ec90ed9e4f3530d16252c30930b89271f67caa610a0cb8c8377b3ed5f005064932b7e753939809983e882376d9da4118f1f3d4e4896df77c0a22cb2effc72211c2fe8d6e416f357e684de6533f326a432693c96432994c269b426cfb348a6ec102de2aeab8dc17725c48e61a2e871c076ad61742d1eebd31bac51cba975cedcff3eea55b68b227f7094b8a9555d9cf8fec3ec634aaa3356a1b41d4dfafb26bf316a63525b9fcd9f6e7caa2b2f7fe6595714f3c8846d9264ed31ad6b449466bd40ba5516b5fac179096a907f8c1efc41cf8efddab2c32f7fed88696cb9ffd8910d0811ffc4f977401f8131d007e1962f2febda4ebf89e7b1c9fd6e57d0ed08d3f141fff10f086d8032f28d6f01f070aeb1377d9fd5383ec4bacb24f844c65a0906f8da38597546dcfd21a9555998ccb94d04daac3b4265bf27e6e8cb36c2cab7d8c7f7e644b41e66d6aea66696dde682d28e7f5bd87dfc3182fc59498c61d5a1bdf5bf6b7a53177d55fc232d90f77d5bfe1f903ab3f4e5e1559a65ee89615d4cae742d16899e63d7eec698ae57b0c7edf7bdf73ef69968efd7d9a45e49f8f92ec3dfe3cefaff7f83d7ddfbb98c5d95a17f97e496b58bc55033ffa6546a35e6acd05067df095a0bbdc4235c87b8abb77a1246a63ca31c65dcedc385eed49d3870a2565406dcca7424d55897d1afad21cca40d51cc7dd0feac05df62decde3fda97e671a636a6aeb6193d6748dc7f1f57bf7a5939be520412fc05e5fe07f7ce9996dabea44f92cc913c4f644ee7b195efbd77ca5bd6ae7e7a6f6b49dd9747ae7e5457fd624e306bbdc7d883e9a0df7d9df2d6b4b86e6135551bfeb2da7c78ec8703d9c718df171f3f381590c59fa28efb62102bd47c78cb86399bb6e9be242bc7fdeeaf76240c2359de6dbc7b64c873a685a9fe7b5f6dd8615ee891d5b38fbfa55c4e29cf61db83d5a095d6512191579fdfbfac369b03ddb78e64ab5230aca914b539aca43fdcc81ca298f3481c7acb72da6132b070da5e68f394a907f7bfefc41cf7f183dfd1ac412b30c4a2f844fe7da28ec9e56e100c6d9e72a981a3fdbd0881fbf8a9a8e33ed6e2026e0e6ecbbca72120fef7a07843f51e693748c57b498f043db2a45946836086035446fc4b8a1f79ffc7c6ef91e5b83d2aaab4e7912009641499e417c9efc03359b7b8cb3ede3e6a107e85d5e642f6245d4596b97924b8b915595f1ea9da5ecbc95671b54d1ffb9f44c67fdf6e9b44436de88420b5648bcd1f35e847a806e159fe1ab3dfb5843cfbfd2f91ab6ddb47807d960eeef1c330fe74b5551bd374d9c738e7d1be85652772e96050cecb3e2659dfe3cb912cee3bf10698b3bdc061298b124eb25011c5cbcea72a4fb6ad71e40f3773577d1aae65dbe8f597dc559f09cb72d3e8447ad9f57b68c81ea334be8d1d40c5ecea91de86c1e61006495ec4811c68d33fda251583e9944c88c3ede202e866e5c07fff6a0a06a4625e3dd645f9655e461be53f7aad7e54d74c4bd39ee20d16d644afd5e7bf1ac80cf3020a609b95c36efc7663cdd241a996dabe02fb2939932b301e2b8703e87b9a95833bdaa0b8017dfdd08dddc8f4194012d89edebada6394467d0b033d00571ce6489e54679ee4451ce6b0fb778b035d2ae5405cbcd6a25d5a752ad77f3a356d2dda6ad1a9d61cb25ce89649a5f6dc6293e026f0290d0acbcd974c706ebeefb857fdd7618efbef31c73ddd9c7deebf27a737ad0762fc16bff79da8c33ed656b3ec7bbf7aef891c7b7777f0c3813e6ff5f777d4a05c5d36e5b4edfb7bda68511a57e61be040f9ef9713887dff670ef9ecfb42431910cda1f0a7456dcca8d1337cd34c99e11bffcccbc8e819a51fa6192b34cd4aa1cdc29739343708923e4a72f8f8c507c3f0c110fc50b374ec30fc4007a859e0afb417053e7e9508be07fe07824f37087a9e66853f37793189c36421fde3adabbbc8dc7f24ad79ab7b16dd5ed73dc61df54269d06f927151497775e8fa56037463fae007a0d8179f7b20d6f34992bd0faa4f926c27deb9e3c8f34466d9b7f9a317cedb7c11cedb682328f68d6c6eb4d1cd8fac1cb583a37df7557220d5dff1ef5359cddf2f2993cd25aa2e990761dae821c481c4eeef1b7d39b9d818ecfb3fe690b53113640e797f7f86f418a5e1e37ed09c5b5cc5c53dd277d7819c7843fc2b36e0886e8fa43ba434fa3e6a1c94f4874d5f6a5fbf403cb12f9d4d1fea4630893fe78f5e2c5c84f339361ae7b12e1a6ff4f8472f1cfd63247fd8903e4a32cf13f95fadeabadd83fa4afefbde5ba129b92626eae0bec43177900f381fdeb24fa5541e328194feec1e634d044a91c703130175d6ef1d49ceeab2d406f63ecffbc00982a27e0f5561a87aac33febe7b173ff171f7de73f841a29f5951f75e0b3f58ce19f73d66e9a2efb1ce2208740c8bfbf74816a73350e4fde769efe70b7b9df6e93345d007d0079606dd7bcff2c7f8e3f19e03651d8a1070cdcae16fdf6e513adaac1d451cf4b01ab841a78f156ff8f4b15fc5397dacb621fd942c9313cda93ab5e122581da6ab5aa71ea65c72b53974041735c5944b677272a6ebe4f489495cc935683aae39bcb7de516881426f81d3a77ed9ed59bfbc78bbb73440434f674b52f04aee3607e806627549b707f641a863c64c4ac3f334b65ef747bbd3737bdace21ea85d38ec95032379dd2b0356ec67536fc219716466f30ff0a951f67cd894bf7062edddb126c093687a610484df5a32a54857258ccdf22b92d525d04a424d8f4a9e1835f86f75683426d911cd4585bd86d5b98087259a796a6e6d017d446ddc22d714b4a21207912ae23389dd93974c31e11e492dee88dda006361b0593dfc341310cc5d7299bc75932c29792b367d02fe2ab29b2ddffe73d2f007a56a10385dfe17cc8266fbe3f8dd89053092bbf7bfa26692f42f03fcfd02a0904b260678efbda73a039656010510720e4a5597006c752a80ab0a352b87dde1db1dea92c89ef2d6fd21d2c5b8ebfee7449dbc75df0024ade2aefbb8bbe0ad063d2875bf8252fbeeaa2b92b7eed7f70fc37a54c369094b407f70b5e78d1a5bcc9e9e16a5e0ea468d2db2f59608d62099caa4b6cba0613a08e298f3fd0390867bcea8135c89392ed8ab8a63ce39e7cc60cf05503de7a474ce39ab1017b470410b75bb2e8d4400674f896f168c07e125eef2b762ac1824a4224536bd4a5769d3db2eeb33b164cf2b7b3ed9a43678410bb509492e31d4f6c7500e549b1c33d5251f6e870ab515e32d5f926d937bc923b67a1e554a4df8be7e5fbfafa0934cbf76b5ab5df7714fff821af205dfbbaeebba0f042b58a93bfeeebdeefbeec16f00bb7bf0ebc00ffcbefff48c06e85abf0026f4743c20d9b2c17724501b7c47e26583efcf3de824d39f18e76c671096c9d9b30024e4fb17d490edf7e0b76a1087f3c61bfc48b2bcdec23fb14c8fb7bee79eee398740a0377fd101fee0ddf4afce7101cde10f3e48410a6a0ed00dea06685b0013aaeee1ee131c0c91448230823852041058182145f45b1533850eb31d5e68f2058a2ec9085937ed0e6f29ed700205296870d2430f598410a22b2106ef488f274640a2c5114d767842c2b64f63bac0965841142f4628cd89050c2b4788e08624685c3a101851041fb1e285d203591246872637dca0e48a0ea966457ea56cff61c8fe5697970b058630010f5d58a01dd1a41ba126e5dd0bc05050124b0285a8147422d46c58cbec06a428aec49a88a10ba196053c62830d2928a288305844d0a183d576a0a1476a0f15a69890984a32c6c68da94de198e4a815ac0842052b5d48490aa31685b3b956259a8070fbe2851794623a7814b518564990a00b1451b4c46ee0c0f0e891da0bb7c9044249102980e1e94b1556c4d490d85a922a27a93e4e8044851121d030821b56501be132a9553bc50aaec4906a21c4f0851630d65afb46f28eb1ba8ce45aa9d0ca83521213145844b0a289175abe702e7b1b8a5411831329a418a946b4508195b4446103432e47ccc930048e0d159640291155c44a186e4acbecbb4942a0a549971f6eb089208c161cbe7b24532d33d0e4249e444b0ba1529416116c8ae06265e566518497ceb3057ab86551c11547c2e8418a1364594060c20aa618020bd74511537858977e6b0a9e84cd051b0951bc38c20ba78222b6747ea4c90b51b531379cb083162338304520e1719574627b62427241072e382e94ace005081f76f832858a6fe96e96215172052d0460a2102326054530e52bf32506206e43d41053b205e74b59e856d17a1223c4174d285061845b1125a86ef55202272a2588218c089c1663b02b390b3cf4c0c50909214449ca62e64802bef80085890995159c705fa400b9903282929426b65ca14316599210a960295964b952801e9414e1f4830a9880e15464a1225ac942823c44eb10173c48d990c20f27c8e2258b920c9309446df1c4c6b43404150e6a0c9e4018148288d5848872e3ae80020372d34a1434ae64950081ec3df244834c0aa72b2a4ca9370c111ea1800e26e410a50a132454b1026aca4a890424a258c941845b9410705da0986aee110a85e403b27e641a51220cd314314f5e64a9022ac67147fede7baf9523271494e0e10729da123a380aa0eebd7763d764cdf4f1b7b73c87ae8bf92c3f846003942861603b7054101106c621635cab942423584871e10a264b8480438117d78fd401200166892c4e8cc0040e5c88d862ccd3c7c6841a5875a18b2b218922060726aaf8a2045db829a0f08e14e96207134819610a14332998e8c00c332c524ed084165d4411757d3a81029715580821ea85239c1411b4d06a21e20a771d8718931980b08202a530382888a8c2390d242c9488e24452d416dc13449400ac4cb630c97828e10712e08965b6f260d10483ad8a2a49ccc09d40866dddda975f212289c68a063688a0092648c022b6026e0b11307ca9fb8c0bf188148d5b6a654631d101d97be413620431b0c005942c60a858640939772b26e894acb5d6e71347381183a2e9052a489c280178a402575491c2298523312e4d2c11876841c458487001092e464040e3981822d6b9d2bdf37ebe3fdeff5b45b02f09dfbdf7823268c073885e24c0ccb09e5c266b7d66a1457d7757cade840acfe7e47499afb676de5c75b02a7cc102172938114105596c4fe0287984791de167937a6489ceda24e53273bf4302b660e2842b5d84601ab344ad6b22e2e7a8290c122eac70c10a09342580105725c83e5f2da8d5cc5aa11a84adb5b26de8c49624820f25f060c5cb72496cfbd4c3b65fc381eeb6ba0432330bb9c4e37629e0cc1864e1436b86002c11802f0090426b842727d70bd99312002926188491710c00a892710b4764156a7882b9a2a4208a36050094c8aa3d9f68494cd17ab8e04bb6d9f38956c3055eb2b7e7138d89b62484ecaab0f29f3dd9b7df696387d2a0efd5bebfbfcf397d7be9e307d874cef93bd4460694067d9ae9fc0ce8d379c3891c4fdd8e727eabb575fe4cbc13a3d571f7bd960e28dee8eecd1cd97117efe018db6d0f95ecf70904573dac7a08c1cfc3d539bfe00ff7feb8add53bceddbde3bcd65abdd66a2bb5ee6ea79d6228aa9c521a1c9deeee95d269c15a6badd6ef9c40f54bbc7184506a963cdddd67786b3e56d27577da8eebf0c59ef5be0a86d37edf773f50bc4f2c8ded8fc505d8aa050c7113f3fbf9de5d3a5b5dc6a1f50f745eede52e77b9ce76b8ce983fc36e5a71f8f8b10801bb3d2ff41e04c3190ee4aeba4419e41aa48090da30402b4a559d70b57abb7aa562ae4106982e7f4fa62b69585d6b9986331ca8c39d9d1ef550208e16dfde67163fa420b3fdc71f9670cec7ec72e5cb9e60268df98c12c1fd73eab4e79411255d3869f20313a957d41662d3a84d8308c116df3a90d0161f146f882a104cdae18be2e73065faa26a47fc4fbcb152893a0376871ac89cdaa01e91f87e9635fbbb32667fdf13104aec0f0b94fd3d166f7ce3f6be136f7806c0f80a958da5367e4ebc8127d00092c00cf083086a96d96c5b5cf36dafa8b7432b0a12c25851e40606edd2d0848f4000c60e2e3c4d75310b02091fb6503a6bcab3f594a504b1fbc41bdd986d1f639ff2230863892b6ea0e104501c314495afc3d16996945cfeb7ae053b3ac4b6fd6c9f7c90b22dce6073dce7a80d04051412dca0786284941767c4e6fec781b8afc1bd02e6e68e0ccddd75dba78722db5a2156d7ca0c3be9e8e704166d267c2a98855114f1ba9802b338018371fac29410ab12c6065cdc02a103a8942df6553d0b11d90800000023150000201008054462a160349846caae7614000c7f9e487c54968ac324c861148490310410420801000000034668688a036d8f710c200871e6e8a3c2fd99197feb07902cce524cafefd92f2272bcd65401e29fd44a851cbb690287d35105a34ced90c269de87d3e0be909d91bb5fa76f679e3117fbba73089e70420eb9c6e748c104ff861eb8ca2b4f51f3746c329ef600837f76a8b554fa6763110b7f4471eb75b4a8843c73b2372d6fdd865942867896a2d7345abc89abcce20d52a29b6128bcd81db8c86442338ec234cbcb83b6365398fedf854fbe56c2e36f1919cbee65ed49651a84b2d2021950d80245c84933fb059f494e33b854c2b17733857119ffdc11fbc0a82805171c16ef79e67f9e508bcab21dab9bd39fdd34e89117ceffcda36a55d60a51af47ead2570ff91d6970548457d049f538d49fe984f55a7448217630bbba23ee863dafa605f916929aa8c9556831477fd2d67fdf87a78a645e24d71f83fecb1ac1c4fba479b8a441b2ac63d25686ba86877030a0368225201cc865e5de05230a1a5068326f85ae1db86da83a1b84dd5ac66478224ce7c46b31354232fc493dd4a20283fbc2611d6b827ceac5992aaec1f014a6f3c4fac1a279c44aa76864b811808fe53ba7669060cb5a591fdaa5d1593f25a4afaa50e077acc90d1386c54e71e81d4c865a2e3e2766196e6a177c2e6d2aaf5f70402d7349561510db41f2151cf10e2a10b00f33e25c212184dd76d121bf4b8884e12590f16df0aefe8a6304f006d9693b9f6a73f5e80ae38a013717e144eefb77d3705dc29d984dc27a6cec0ee48796056bfceaedec36043ca5fb045d17d472061b98c4feb21138944c98a089c2cbababfa11c4827a16999e6a3b28b1b1342e0f87680392c503abef768825b451e818765757622b81ab5e217f49e4da8db92182f14121fd66bca5ac8726f3ef89b8b271097bb930e24d9eef729921c195378342661f36e92d849eecd130e7c7bc327653beaeae6f6845db752730f65a72a78fc49768ce0112f6225a100578128f489e79d1885b9f7bb00c1b0dd565cc633936e97440197f426c243ffb76c482e9826d733c0e3646f34fc6c67222cd93bfca368aac23def846c5728ec3b129774bec3e2e4d0b649c49368dda9644eb1b9b48bab135c1de477c18ee7221620335ab8a53350ca6867735764d98a5c238056f043fb133de1817074fa4834fa1297161212ad602aa122bd622b67531cce05f4db869de9249d103eff160a216b67be296351a73c72c2a1db5fd7291fd89b5a4b3db780b28a22dd354c8dd48c5db792cd964413b400e6d521bedb08fa8aaa006b988ed2eeb0ce3d13c48f88270cdf57794d4a4a5b0d35288332432c4e6de9dd37e9323f52637ea01d43b4b4eb213b224211288d915d5192c82341d15eb23c94591665a3b6007d41f901e3af918fd4be2e548e833b5c30ab5d456b8b90d58a1b11e01e170cbf870024d1e774975734acc1670c4f50496653161b7488c5c799244005f420b4e0585e7466a0e51aa980f59e468eb3f42eb36006b50aa93726482f5569b95312cd5489087d340e3b00d339839f8f88fdad053e7ea13d8c9031b388dc5256f34874541a37b04672d2944331b4eb190e0f665ffe24aba897b774ab1170dd37eb49c12b83ebee61887d905bca2fee42a7b5dd869d9725bc5f8cb96d3af5258c4e73e9759806f80bfeb254a4e61cac8551876fba88335ab9cac5c2ff0bf3d0910cb132763f313fe432b2d06c76b958cc9398e9a4694c911cb32c6168567e2874c415115d534da8e3d836bf9cfd92f7521fbe09297a3dea4465612352a76cbabc51d4e78925eda8a98a86291416b539ad401209a7864744a5a3013003c65e2ff738b6528d7b8c404ff0637ab0bb45f3b8a9e4cc9f0593981256370007c416025a8ca3f3a329754d015ea4ddc946922488b0ad28efa94a8f453a8f6657241b86640952350a862d412d01c35369833306f0889643f44a46a468659483a5d84ef7f2aa297eb72a8aa46c5f7b63215e395ed2948e3d05cd5e3f2a5ef6bc28208d2186b29fe9fd4dc77494f40476dfa33314401025e02da5111fe31baf7155acc08219680ddb1a54409f1b2510cc6ee9d202e3322841bf706824106fd43652eb3dcb47c204d3ec8b905d7b1b2f2031b13439eb7f887acf40d21a70fb149fa59c93cdf295a897643186806b32be00f7cf31ce2bc369c9d4f35356bb187f51c289e4b6474b5e2062c6114f8d95e69919c89b352f09514d282bc828404c2ca8e753cc7b705dc7b2471c693b62e9420a6b981402c1aba62eaf8b115d1f53d468bfafb6d517d1d9d6a2501e571d509a3eff881e11de5b7463775a0002d7093b55b24ca71acdc3be4b8f474a6fa64bd24b98a5aaf99027aec3e0ef6c4b7833c81ab30b7edea79ecc071c2ea37038870a228971b9311b9ea2ee7910f26f5bcf29655e4b85e89031b5f81381fb279dcaf80242a0bee71db5506125d5285062f242725ef1e2c30c78abdd8e7ee8b2d374a91e0243d59c7acd54f46d2be44c0b7b27cdf1ac684158ab40c58e6df6a2a3ead8469e3163be4178ecfbb53a6a43b7a4c895246d9109f0e0e58dbb7e596217ab5804742e86c292728964f7de04dacde186db7f09d2522751f7e021596fb0d4f8da8e5df75449f170178618fb34b60a24c43586d6217183e275d9325f509aa248e94c9cdfd6c1c2bd2cd3ed692ff0da7f923146fdb2b39ed7a835aa9d174a672adec0d8936cd7222935e0cf19db4465f0c99efc30418fe5b15f8eaee5f9021154af5e8e330ee0c2983fb1c0d811c7a2bf6f744ba0d54b9108a13630dac02bab1af867a87a5d53402da985c12b9dc7c25b8eb96024a864b3988bd2f87b917d19737f8f2a2ef98a492d7085fcb34a90e9e09657061d901522b85e4c391ed0c8f083c7774841bf96ef6b9fbd4aa248e42c3b4cc206d5d55040124989029dfa364c8432141044e462f9f74329e06031bc263f792c4d88203bb0841ddbe2c6815fe09d01c2ddc6de133771c4a536bb97abc1efe29c7b970dbeb30e7e6d6a9d2a88b8419afa7c9d33be8092e32fbe897cb11a2308360a465724d24b35cb3e7cc167193fd0383b9144214092eb5964e8ab220d5c4385d6a15620befc840c3f1b6035aba29d32d11e33a14a7dff61bb931429c3931f29a994b444999a4e25a0114ae58f5e406f947acf1e494796846c1c816dda64d6729874de08856120e43a2db6120af832ead6bc970323e358fa5358b5cd50e8f194f9e7af149fa7be620ed466a74607c66621292f0adfe88aa038abad0086538bc9038ac66c41fd1fa31be8901988b219a5bbe18615a36fd6940097221161d7a7175c87f99b85e48026aa096c8454404da8972d8bacc0ca388c5d64e5ebfc9d16b448c68be0e1d2ba9ba2e3080a23f41623edfe3af551659af70b9524380efdce306a16f46e3c409195f195e23ed018fada946f30f6e871461c0b732d16f356898f072022ead6b864ec4b721944d809c6ad3728e469e0f375b4ebe0d1ac2e1f8b82f02de4f023fb37ca2466ebb0a0c5c7da2603bb893e566dfd6dfdc1d79dc6d2f4e07e197703dc5501e476e68ce57bf2a323faf2f08a6f86933d638ade6fd8b8b7e6e78b81f78169ed0ce8a3578a6676e518006674c169481a8b30be9c541519ae1972961e2bd8b729810dcafab18b580cccde253f6bf5386fc86c44e95071b47f632f19fda19f2e805858b8973bb426539dabc414195394169b693549c9c2074ac903f0245e0da0ccbe553bf07821208bd1f823940bb08e175d42a68ab2e4faa8588291332694c31cd210ee6e3a96ddd2c4d5ab7384009e6ad5a6c93ac577593037626fa88e7cf92672d52d324c5d6c96088c37a6f5fb5bf00b9543cbcced90e4f84904da2de0d46f60ed4415fcd54b8fdcd0435a8d16d5d4010808fafaf9cccbb657014bdfd651e5adc7c5cd75d514c1ef36529c6844ae9b31ccf9a7c4b6efb3670e11f2b53307f0923963de024dd8fb8180deead008069c27b10d299a84d9ed1be6d545e560681688a0bfa8a030a1995f838ad76724519024bb1c4a5f9af344f037cc6f48859c9c2f44d5925e65f0d48aadede6812dd5f3b77e6f90d6a38c5fd0cf474da55c7b768a6b0673454eb32731f17f4f8140ca2846a640c6d2855876d4fcf9b4df27197b167e251837b7e175aeb37d945980bcbcfbb3ab07b350ee533fa234d0c4bb22ba140fd9458b1fb63029c5ea1f7a37416250e553d6b7eac8f53d4c79154134c91088c5c19ea7276df25e519326bcbcff9c10e93a2a7ae5d11b3d7a2bfed0ab03cbd130a10391f87b1e8562519ef4f5a46be5e5f2ec1af93ecd8ec786104230bf4db371927ab3b0323c7cc853adbdd7bdc025f08887230ad5144f855e8afa121cf0a919b6ed61a1ca4d66ee6ad03a9374ae0b46a0d7932b700191a815394efcebea5e5ab7b783845ed7a72fd88c9d95d35b9fecb0080d36a5f92c8102a6182c0380aa1d61f3d956818174caf9f764c8d22b1e5039bf27844b9d4ae4d8a808e08a984a384dd3c99ab9a21b4bb9ca29dbd2fb3aefaf0ed3e4117221cb8d9a42c72da1640e6a6667c0195d92b54d14b802c961e4f31e7b3138245b85f9872d36624cc29f254d617616ffb5dc348850184f162305622343c7b1061ca69db8baaba312471aa376df5d78327dc650704987df93577c0fe832e32dd2a6cd5b60208433173a7d41bfc98947a727c0c726d2d70278b9899ca3be51271d4a9eea132d2b7be91693bf8d17347ca2a34ce481958b9c06589e7329b3192160634a420ae91a14d62b01c01622994da47ac829b4159762d5a45c456d9f5984fe08070a2136323d20831b3f76c492176975158148989f1064b25d2e6c660a7f8d6fc1c8d2cf8986483a2963671cf3b628752e265acbd42669eecbb6217dc5acc344920aeae4ebcaf63252835efca55c6054d883699aab499087d42c14f46c96f0f94825e0519e47aa38d7816db244346fd4cff28e9ddf5fcdd81cb525e7457deb5f4de4af15bf410d113111ac6b87b493ea43948c2422d4417143680a5f56073cec1b177d12aef3381a84079785f35c8b02da768ef2673233a18baf719a00f6b6049e897a377604f01b510a3d668df8e7ee6952464396a451223ca0429eaf7efa3d25e267ca04e83dcf350563cac94046e59a8e3679fab9f16b02813ae0d4e98d5f65743389611621f6051afdec4f697f6fae3367c7fdce313fa19100c6d596c33937d06ad2a875b2a60d3bcc90433ee06e44162ac5ac41c02f6f96e2ca1e12958893104793125b10c0d891577ff0c18c6c4a21573dc159cb788c67d8862f73604cb5d50e75421a14a4147d62f6e2f0f92bf7051aa4721a58e208e31c49037979472d1557514b7483534a21550498bcc95d88d3f813d5127d82d786263e77939904e550d76f72e8b74aab3607942d9eed3e7317b1e98e5ab5cc178e1f1d01757f49bc3c20cb1ebc546d66004f303a981333ab505889b7320a029cc63fc3a337750a876c65bac26e82976778493a943deec4bc73c1ebec2c284e57a6ac0cddfa6c3c5ea55ac1c7dfcce9b7a5780e535be8331b323dd7286d8ee090ba4c6c9cde7d2996a38a0698cfe9813f3cab6610d4f974c964e41d85233a6c8b8c05b673fe67eb04fc31f19fb36f503d51f3679933c137fa0d0290590c18b32620155b1023c388808b9de48df91d1dd87780b6c70426da691d7834550a2016158e3256354f58a082b0afa78671a0423808744059d32990555fa91b6b6cb80be5d9a7b599c764450ac90a4608ab145f80308809adf3dbec8c2d6146286d9c7dcbaf1b07da8e11384f603eba4859326d156ff6ece92da8c6e406bd3456bfb315eeb386146708298679951248c8caa31dc0370559407c32e899673b52922a7dce31d52d7d35f0291768461d326722c9074c9b64618b4f26f1c57f17bc0a5607e0294850ce26dad78e7820a866f2973e5852f79bf3cc5d1449a39beba67408b5a42c50c91d054e8ac9df40b01e2d20e212a97d4259f0a88808cd0defa879ef11c3e4ec28e9acdf3667fdb86658a08cd11da9e81610f86ec02125e81c733a6b3491dbc0eae111b6050e594da4dc28310bc0875902ec4e1b692ad73e984bbe83a601910115b6cb3a4ac1dcd080d3951b941d55914e9293b33aa02730b2c232694da072e341105a699575cf523ab14044927cc8c714c0e0c26da6352e627c76670cb35b876cdb04c24ab7584d07cf6041830cd0578f380df3d9e0e0586d2fa8a1c029703d6429317e6cf0dd08ebba8cf243c9646fb3b6969c97a233816686b72088732ab2044209b1550a309dce7722289f3bf8aef8a248de09c7fbacc20e7fb775ec535b86bc58565426e5df5ecefd09d29564aa41a5f707f28be0d1531fa17c41e87dbe76a74b2ce9627eb190a5a8a62f6bc2c3aedb778378f18b5593477a45942b6da568eb2615c47f417cd0a954b3bcd884f680e96754dd20e0b0577dbdf039682875c0c6ebe801c5821a776197d26f9f5337b4a9c217155afe6708ac80d55f9c155915b68ab8730983025824f3d712fb8d787780d6b4f7219c21b77e2e5e32579e63026066d29e68d3baf8e919e54e1800edbcd8e104662f69437f217d768c58e7d09e35a09c23748251392646e1b56183cedf2b3a44ed73d74c160e6f473f2f002757b0d4a79527641cf89fac7b4202e9c9b4ef1f1e0cfc59b3ce9d87cb3fddb6c8be1ee52c5b2166d063fa64b8913abe39e4e27288cece83d183dd9fc8a1c6150dc0045f2eef76a206b60c154580e39f4c5ae5bed93c282a60795905a2aab3c9fad55e4960a30db96ab82d4d91c3f93a36168d8b5c703c2abfc37c69a455de463d2c31596cdbd768bab16d060810665c9df288da236319d763910b5cbc549f4a88e04ba39041d55be33d1490bec296e9bd74f3d27f90f8c8a7e595693367a8ab7cd19bafa03a9e0b1b1072df9014ff2d91874516160e8035439da747e4e3a1de180509e3660d077dba87dfc185a2a0d8d4b01d84ffc279123ee7fd619cd553baeb6348341f391c6431515367cbfba8a4f9abfe1d345a283880dd26cc29bfb4e76e2fa68c3eca4518f1d4594a1e6d2edd7c8245ca90735dfac80dbacf99f58d063a23f884913f47516a157106a122cc9de5d63460ecf0f6565380e9610da6117378590ac4ae726d276a69beaf2fde81b8b0c2326492769a6fa57af0a62ab5105bdbe3a765b8dfdde93f5f89c762a933463b412497cb0c4659c673050e12bbea44ddc5e50432b690c37801dba76c973f096484723726ea2c1d3e1730f2ce7a06631a4b0f7083a5261888fc691d3843f29f631781f6d4e475490e8111fa08a3c28963a52ced91484441c16a5a5c1e1abd0a7254b621fc7c7c847e975947de3318d52667add960d7c1a659e347eddcf6d36a3c27edc22a853d734311198959d471b20d6ac00148c48828c90ea6cd7142b83a520e522fb7f72c89722581cc1de63af0b058ff6dcb86ee09f0237fffd486cdbd1e4ee818f93c1f8c99b44632beb11f998a9d16e79930cba43d691729bee0379dbaa8058d4dbcf45eb7500e267dd3e88bc696bbfb1e2feb6c60a022a1d7826ed24ea77de0038578e82809238578e88b5a93720dca22235a9134919e0ea949a0f3db03283b7b0bd468f07b143f56f1e0073ea7fdba5d85088ba210db497ab80fd7c68dbe409c4c1853467d0acbb5cc21a442d49cfd634d1118a251884becd7c27f63b002b979b1939cd9ca0937248ca431020190e2fe7b3d10090ec1a88b3117c7a1b0ea28bb3a391fd641c980ca5d0fe5c4c90ad02a7915a9758d28d42538e3fccbe117adc740e3acad8caeba6a4a6d3414a39850c749b4d2703bc6b244b5d830c4ac647e4b6ad74d7a785acc28ae0d5d85e1e90d589e64755ba6b9c6ede53ab4a89b84b358cb82a794bc2f8faed871e0a7685e059ecf1618de400afa4526b43ed5de41d767c6b827cca2792d3112f5b5481cf86527919ff69b064935feede3e023882b2361c2548e8a9c66ba34e0975bbdf2a5285366762239fc725335b4cbc2412d1018e336c0a484834e7598d1eb147cd7c46257178b34012aa80f1a9c306c6d63d4ab613357f47090fd42844e596a824340b3680489457bf366085cae375733d30b61e4c64f4ec6d833d1050e120badd0259df9f1154de9865955b733738c8996aaa1cbe091966e68cbf13be8d9ca71ce17606a9738bffebd651c38ba6b23410425d1bb2b8eb91db957a96409c33729636345d9281c1b320651f8427e4a8a97282cdc9d57a2d5ad34e1e579622e9e48504aced3c1bb9c804e5d513cceebf69c67b6e6efb63c9ab0bde412b46a6e884a53f98cc2d817215302c7f5e804bbb9d7434f551f287c419635faec5497de2bb7fd319265ea31cf8bcac5f4b9fc52d5c4c60dbac2cc244045cad802b64d0310881ae4b811c7d70e70a167a31275e12185fb901f18dd254b79863a352ed85dc4a1dada9c7143b189710bf845c32f5685f872cc34921775abfb74f17a32f85fa7ad99a78e0d9f502dc5b479043d531d84060c454ee33697f3fb87785225091e6460b48997a89bde974e202e57caf7a6e4d84b555de206508655deaecb02956bc52a50b9dbd102b73a2818ce8d5b24fe28e77c10969539505d5c5a9571139882a2d2b9697496914335120c26fc917c3ccbdb1d4fa08a19f9755be20e44409fd7fa6a699198aae6314c2be68c8d17bfcd156043347c335804541a288e0ed573177f9fe336755b2394de9bd9a6046ad8fffc825de8b6507774001fa222dc46ca404ee0f9ee05b032bd900183d587158c4aa81c80c5be47099911e36dd6e1ff21e6cb36c258895fd616744426461f9c441e03bc8920a1df2034eff5de2a8f6b554c61a437f4cdb552a04d6f62b2672f23dfec82c71e57c5c2ac5d60812d353b92df92b41877bc289423a6485b3cfdad755210248ab7324ecffae6f0a30feb9b26d0a4f1749dbe10464de05c20fe8e58861585010b50c6ef69d84438265a80005aa960ea610d425c433f4fe86dafa281860e27b5921346eef35596eed0a3372324e98a3620e684096b49b32cfddddd03423b14ec50847c12480153070b4923fedebe2e9e74e29af29fab189b643ddd67b3af9915286c13e69bd5c8da852425db90ef02af3eff628d3513b8b90203de9c28b7e4a2f191b4bfafc65efa0db26fe78dc60ed5a95403f28f231fb05006b75ceac5f1cdde6d47c73058480bb8dd6ea5d0527854994cb35d99842b634249b01e9360aad971fb54123f267a2cb78c90bc9394f516543d0fe79d5bcb447dee6d13ceee72470dff088ec66e67981b40b50bd90f499452480d9be1220c53d80eae6d5b1c362f4bb8e3efcfecedb5fd621671e7c32dadc987abc3a51eeeff0b86c8097eedc06210d4177a959c6aabaf0ade1332c7abc33e267d1f9cdf0af150d87347b4804e15fee3bde26bb4760f58f5efd6733b47b7e21b781886eda52f2d20914c871bc9aed6842218a47ecaad0932cdc6f4a71a44166db01f873b5db97ec511448ae13d7a18bea9c14ba4a004400d9b9f4bcd59110ed1b8ce6c0ecd195dab4ec9fa98da84adc0c37dcd0ed9cf2f82625d90449a78d34d09bc7346f579e981ba7d21c29aa748f7815a5aa8c7ff6a16fd90ea4169237690982119dffdc63bc501fa4095650e8f6590e6c34fdded79eabf797beaa983ad183515369235cae4312ca01e3920db2a510c17c298fee689afb94f7f54fd79f05a8a46f8ff3364549f1a21af4224c9bad5faee050c4fbcccb16b4c832243f7a493e8a71c5c26e910bfe08dd322572a85ea26b5efa2d630fcabc8b54bbe817a72fc6981e0ba285f55524ba2113cb19a009b68905cfbcd6757fb75f569f14f297cb6ead4c7402c301262282a644081a97b35e0305febc42eb70e132c9c7e2c6e9fe1db2865f796e8c4fab8062c16a3e8ac69a2749359f68c465a1a42dd3de2de2af20e473c0d85f6df729b69cda455f6784f4eeda12e1f8008b436405e5877b2d2b2cc2f71e1822049cd117660f86032783d892b040bc52111dee68b8fd05950adb710b8dacf4b0f3a732622a22d18eb841f0df15a70365c4242142dd0670cf257db043cd878cfb6898d3a49bc27fe859db052d47840f8e4f406bd7ecc599a93533928910dbcd45f871475cf839fc643b470fc8b1c89805e226b100ac2fa986710e1720266d7148d2a55bdc0e70f8a2f10c19320f05a9ece04d13631599749bd954b9813ab11960385a9e55e04090c57b4a4a0e4318aed26a947aeee94e360a72ed4eecee06e7b04b24722d5c4808e647bc6e8e1dbeb3d5c5b7a4d842c4b7c2e0ec7ebe99137fb0c238238fd34aee8b21c45a280055da9204c670a5df10901c8fb228b38ec71427dabc1e54c8b2601ca0d9e4fb6198b08385011c97e4f74d6f9811b17237cf0d2db135a188c99ad81736fbcfffccfefe6771f2a60e98ee426292b92543abb636b1a2a8244106f2ad7721fcd19ca66171c6ed70322bf162a705ce8eb7a95a2d0494881ce5907cc328df0a155cfc453c0057f405c10240ed393e898e8e507e2e443f663fb4508a9679e70984d6dc598c4f1d603b1e5e8605d70a05849059e6dd6caeedcd5dbb051008a81fac4513f74891331e5bb94150bd0dc55a87e6d5f33f7740e051604109564b8b49c4b9c518b726aa45f460c9aa33efc2335ac8573edeb3ddceab85a4a604684ea15248d4ac273359b83f45032c7ebfc7d0d568557d261ac2ff01a42f0f3467583837a6011a62634323b59b107957daf7f68fe3fe947fa2ce34e591dd3491890c1ee75aebb9ba3d90c1674814bf8a5af169e4bf4e00f1e732a78c9b0cbe05bd01b8a704d76777bee7c267219ecc7b5affe90b02bc7e09dac7f4d1975c9a8e7f6e66351112cd80bf16e44ba13011d2a0f5d011badb03789366574cc8f0e60d29ad93cc40f58360eaaf619adb6df42c4d4e0e6639b429647c9f0c4672a5ddcf7c7204dbb1b0d568e08ca0dee4b5acf3ad746a0a13f6f1600d64216c34e69a920616891de81e515d884b80f49f9f44aca97859e79b42d3535a1f2007e83cb70d247be91eb3aab89ca9b357b0ee84f90c9fe3717480185bfb7da6c27256c1fef6607b6346257df31eb705155d27bd341647421e26667dc98482ecaa88ec4c50c84451a0e4952df50c7c540a09bb490ed13b0fd6686bc1e92833c1806c67007f1fba87f10c49a20604eb996cf479a8543bb003111baf87b8c4316620f360d492dc26f11c4101cc274653dc155cb045f9f9bb90f17b9bdc54aa84ede78f9837e4816ba654c213634e5c55b8e5a0538baa4a51584f98b4b14186a70563ae4965a812a6d290fe2d6b02b933d012e6e06d53a259777a86a5c8d40c496c8b6851db7a7be7505d74193d4e86cfde7b5b4b147634eacbd96f0ecf8373e702119357b6dbe10e43a51887a52d75007cf1ac203c162f802f77465d6ff9257339231577b7e4388390b6a2bcd42aa2a7b27d1462df3dffd00f92cb372ee8592cde9fc4db6ab044308a4709dd38d85bf319b090fb53011ddea6dd4d703322f8014f7dfd7c9e42de6a98490dc36919be84b09625ff99593a81607a21ff99d80ac5de1086828d5e10a45d500f5de27d91c041e03dd348c7adeb04aa11efa968eebae1012c79cea5ea6de996c4f8b2038dd579f4afc71873c4fd9dc4302854a26e5557b5e2cbc0047f9249f269fdfae83388af2e5909f79b1b2df13b2f104f998009dd206140519f8267f284c80fb535634f289f81a81d49e7c2713afdbbc5ecee769c2e26919a5142cee8669879c467d6fee0089960d84af82489f0878742b61a9ecf9de3201609bf453f482a6171d10d7516f0e4c93aa75d629435b71a352f47e9f08e2d6c29838e9e23ffcae87cd3b70886581210558242de111134bb7584a2ab3f9d168f18af167059eb2a2af2a461f300c7518b33c56159d0d978a51a1a096389fda3df65dfaf59488c862d2be5762e1a34bbd652ef43a7355b50fa7e47f5b306c6c6816d98fe1b0f0c6f2e12f981850268419ed92ae5ef29308c7377ebb7d1c9ccc2cac28edd3cebed585c3fdffaad14f085b43e78ec5b1274e910dd72e11720a054e4c117d8c4954d120703aab5f42ec2c8fa5ae455e170f61d2e59e288d21721822ba9a6d0684f015e36a60cdf80ec50d28b6dde4d572dcc6263cdf015e40d50374952f8f8adcb41e8760b9de7213825123db2978483f9d22c1106894c9e850c4759a8dd4d592cf8e3d2b964b1ae1a2caf9571701cc2eac65e1130bea9d9dabec0c4498f4300c721491b3aaf95f3d54cd2a2342750c8beb5c35c289d96e61ecdf84d482237a4c233eb4c9bdc5005b92afd41fe9d2bbf6fafbf3b38cce7250f592fbc52c90adfedd5fc4a2ad5d734c3858a0a06d553a0de4f8586b8655321dd980652a9bfb8f1586fa61d3332d3948e1b5738ec7a2a73542aeb36efd8ce806025c2a29fc21db88138ab40109526f1514ff1ab0d35d9f323265f4bb09d59769acaa6288da21b3f188e0c62f4c7307ab466a6daa1518cf375a9b037de6743700142c23d9f1f11a01a78ed735104ce10a45f78ded08cee6d4e0cfe7d5d8af32e258b43c82de6ec22cb43aaf3ec33ba4b19752d4f8e5c04245623e415e17b55149b63f5db00889d8a451e158ba3e867290d6816f33ea5f10d54bbfdce0a6cef939db5c694646f85b0752aa6428a2d05d2ed8395e3d3d476692809a7b044f0d4fc417fa741c5f837c609934722c0bdf518599a7509ca75b4ab4539c6cafe484a9e9610bcaee2d9c17fb872aa0c23d26b1fce5c043a0d174a5c90c33e3e50fcbc34438f15fe7c3b95b637922d2cd4448680ba54a3407d3827765301f7a00b8b15280a3a4fe5327a6579c31b81c737b192c0d0eed19486bbdf532d4adc63d10e6e79683d98583213522c0c08c1528b88f51dc9529eaa5fc2e1959a28385a5d6a48d25e891d8b033f378695c0eb15523f02267cdd728b3fd08bb42fa3d8f07df9cb5aefceca2cdd1a106ec25185b75891e00761a78160dddbe03e88d7597fe0613a6e3486c341343f789d68f7f2e372aa7688e9bae12136183f6f7a92bdeb67e881bcc38582ae26fac4f8a9329fd751e93331d5fec6c7ac725098341daaf34b37480f8e9cec1f59c9095d9fd1354461578aaccf2843249973c4c9ddc9bafb33ce3e0c4d098bd079ea8861a7f15a019aebe7c62b0d4e242679592eafc949b84f04d7e16b89b3da40c83d607c218d2c374e74023a7f44bea6810e14126926710e5929b84f8cac7fd6b59fe2c936915d7f633cab9d400fe0cb3d2a1b57a5b34e332395453172e9e05708d5e5b5bcc39c1321df7f071236380fde011dd26270500aa519b2731c398a384696c81d06a3022a6293b5f7587d5ef3112ecd748bb950237f4937be3b3eb206aff085485e5dba38446925ef4ba835a196b0cc0126f1aabd4b4c07823a12ce845452d334582f6bfcb6a1ba5ba612b9175990eef9606d6f47ae4661e97868a89b4c845f1bf950d4f98fbb51b1ce3305a5f893dffb315c4cf95900a0c2567a19913708405c0042e8dff254dfa600fd76c4a242dbdfd08cc06eee27fc3a2f10048996755b18b67ff419c1fdc04abe3c3341c06922e83da7997058857f7e79cc50b16018f309056fb7118caf53fa5061bffd8bfb35e9dc2ee93e73f235c1ed48742350619c3e99fe321c4f96731288234f801a076e7ad65a7944519f70dd3d4314b5a5c41c1113889da04f23db4c87915e0124e066ff9ece35104f7217cd2ae131abd9d335ee583b9abd66b0b56719e0bfc242c98ce6cb8ec78bbea43f6a8667b20ec84037fc787dfadc9c0d986f8d9c4d4339d0ed4bf86fe7e543297569c08a71e928705bee168d2412a016dad6c2b5345a51df60f9288080b07b844ffd9cd41998a9c7c7ee05d5e44d0807880acab4b39cfaa44157fac4a0e6ed29938a01fc586b3cb3a32de53117aaf55b650441a8b4bc2eb179fcc87e1f50105c177cacd33b9751a96315a4869ea779257f4cc9a4865b53ae60249db0242ac9d83e408940675e22347357426d14a74b68d1a18c788e30f35c0706a322bda97f2069b571e51f28e3c3c59588d3dd24a8de4c11af3a939e9a0e60248eb9b323fd064f08e88cec5647d2b14dbf99473c914cf2952982388d60b3dec2124b78d2119210d326fae7e2e4988ee40ea7f138925e3e3ae884849fa290f00b62965ae31db3c2bf13d05daf792a7f51302da1e2719613bee873331678720367c6ef152b7b34243a406848074f16ec6a3eb40a7588a6c8e1f4de399b899eb807402fcda1fff38b1580eed0f5fc0b47da9d526e8a4031939f4801d10a3ae242a67e66c24116065849233e116d74c9d8033354908aae13a73cf137c6ec0b40fe464836345c17628dd7f586bdb45a4d6c2c86e67286234e548e46628595d2e87ea12ede97cf2c652e54d99da85b20c150309211c38717f31e3517a0ed4f294d9055bd3459e755e2bd1bbc1cc462fe1198a287a27165ba3c6c10a59050f91b319454f80e72f39cde84183979a6102333f9c403b698f9d3fc01c2449bc8a46d3a469210553b227898ae1036e5ce814b4cc73c8a0d6b412a79d769b31f7a1fc869570f75c4212e5dbb6be6b4dee99c5b4b656376f925d079fcb70605cb936096d0beb93639e115ee4810b271ca59cd55edd4737e761eaa7ed90a1118621542011abbd9e36ff4a9964eee76ce62b6b17f7b1dff4eec31a7bbcb40c497ec175a81dce25e7008932facbd713030ce1f75030ddf17db37a56af37c0ff28ca8c1503f526384ee4a2e04fb1081efa6fa34d1586de26c6d6f43a99b08e0737523f9d47a0bbe20070cb23cf04eff3294f8c88df955c18ea2cc91b263a9fc7026c568a586b4c1ae78e6482ee154d1d10c95170db63f19dae95cf08871d959dc56f2837cfa66a9c8b1d61f012480822d831165960c4ff9b9681c566472bc60f5fa520199de14d2bdedb624cca0a9c8d24ea21c26832b9353a48729affc205c5fe039b9b1ef52f305038bd97bd4b13cd7b3a247be40148927f1ed4c194408965c0927b7a2966d17a4a178459b16c01ebfc4fd4ae043cf7754bba6a131c080c9a2151799a1870da1b79da09a2583f4b3147255ee66c6e23ff9454b20ea6726b97f6614c139a376a49cb8fee32ed2441c0b4154da16ad885eeb4e2631b5da6c40d44ad475baeac7f2ace1e7901f2c465957f8fd929f2df134c6ec3b0b7e953e5d0ca45a1a2a43480033b8811c3bee2f2b29f62ba5f36f4c293299c9bedf24fde4b11b4ea9e83001976ddf4b760a07f4097bebe0a562f666018eecc31bf67823dce1c02d7ac28096283a0d6342a8f4a237a3e154bc52d98c381082ebe1fc17aa6169ebe3af05d0aa35b2cfb4efbc6a88c006471847dd72bc4c3057498b1c79f5da2db6386586ea2451bcd500983385aa7233440fb126f352068b06e1b50b477579e7e81743a56f2398a65494fbfe15409f4bdb829b69e255c26102675c3ddb8c3d1cf0805ce6f86251602252c366eb4d3397767b4a0a2279118b4a1e9b34336dd679666ae3ad9f98ce959b3ee4180904ee9a40c511b808025b18f71c55d43457b8340358e3e8aeaf2a28093633020d404780d89b28eb12bb999098cd4091f2cc2dca0bbc39e5bb07be190c7bb2889264dba7bd013601dca77ed76debcb6039a9be329c2257d709fa004095c8666ba67aafc0e63f8e0f0efea3718ce2a1c7255f20f8e4bbb7459f480e4b1c9e7e910f99625da242c64180a8a3c153519882b1b836ba19244e1170eb94c5b3145507bbef996412b10a206c648b716e1fe9c085d9f7e660f2e21b1d1fb58ecdf8721cc9bb318067f9468a91efaeed88462584c340ccfbd9608ff46fe2ce7f6b39030bb6ab2f1ed2dd3fb61794d48131a17e09b664753e3f60bfe441597d0125773e75ebcde6f526b98c0e0ec3d59a406d51da3d1222ddb3940f674c98bece6fc8d38531f23f876e598b65307b66eb3fc1d23f21eaf406b6467dedc07dfd10ff36d0849b4262dbb95a172c39251b2c00ba2d109e0e603eb0addaa1a21dcbec670d05917ebb2ac95195d35d0008fffbbc0047fdf8cec334e9df575d3ce6cda5ead503da56e489d90255e0e872d8b0db0635adec800fbcef58138c39c353144012007337fc63f38dfe4e82723ed0b09287ea2ba6bedbe05ddd4257429aa3304fd764c3b47282fe00bdcadf3f37b730193c343da06c80b9015536be084d3e341ce2b225e037c9a0bea2ddb76ef97d57cec9d7f2601802571fcf5b4143aa35183cab80c6b7ce62fa25c557e61009e72ce9fa5898c6578572fbbeb6591cdf5de9bbbd48ce89f1d0389d5ae22d465b6759d17258453577aeaafb9c6750bc155a29f144b6cb68d014c39ec1e4099d201726271e95ef2e811eb047bb971c1688fa4e8d6eae1350c50dd60c3e296c1a2287e4aa14e3de4c5de840284a9638806f3d0206871856b14f8bd48747bf1ebb7cd5283b09c94208b37a71c4cd38144230744ff9d15054e5484f795c05c7d25774bcc89fee821d095070db7592ddf18a84aded3b59169696daf60c997a2a8ad2847cf72bbdbd0232f73882f8ccabe44aa102d2fc61efda093fd21e7b57180796032d3c35e0d684fa1b1e0bf83fe84eab8d3f865ca56b54128c8328f77cc936bcb65cef8ae279fa62085d34877578e0c5837b374dd106fbfa35f955c40bb5a5f87ac93d3c1ede77b8ed85368e9c14ada827a898b2b900ccb1c7876884e3d3f5186c5f31ddb8d2e9393e277034bff8a0f91dccdb00047d80aa1feacccf1e1749e5940c5c99f85eb4ac1c0256abbfb4264d07a77bb1f7f3d7ec6a6883b937fdee1f027cbaeb4220d814e06b66373768c580f988796132ff93b7e9f2f318133d286e78773f058d0a8d5b46fab4ce94720adc581fde2927fe0ce443577c50a7aedf8fe75e21d98eeed93567833bf8c878b5b088131128a7456b593c21c7f0b8c80dd0012cd65dbbcf6d3f132e097081f1cb04c9385e1444cdd836e2f019702fc856a3ed1ad0188af8637f830320670f0b331342fead9091f1edc33c5128bd259d9a8ba89b95afd984e6411f7a2ff19440657edf17c8fd071a119901de9faccd44b07bc9197b5e8d72bf587a583cbcfc096054f0f78f0f43686ff9e7e95457fded4ae03359cf0db5a98844e7a5b563096f92f0c96c463209a51cde59c5ad4e3180628b7a2912e50362801433629dea3d3a9e41438301fecdb9150bed31b03751d5861f604f33697378c396867988f925953a2994b93cad955f42f8f07048a81f58d47f3ed931cdccd80ae8ad54d063ea0a0c5d3d19edfc72d777276cb652d90b307f2d1021edf9212542e54b1dd7c3d2efd90f81831d8801b68850b3471536298481492ed68d2940a140f8a2b4796cf91d151eef277e2eb0302c64212eba6fa5c0b38a1570f309a2f79e4372d09dff4ca193339f9686c635a7cac4929764d1fbd1a1d09b29416b72a7d3bd0e82567842730562cdc7e6ea759d79eed85b0ef9591761af20ca076700e276985e25fb12ec662f0db86c6e801504857202d6b50facb149a6f445449ce14f62480ae455eafac6bd218873b10daaf77fedf387a71751418bd7a9df80501829ebf41b4edbac835a7a602b1cb334798d0bc7f30eff00acd3502fbf153a91bd66e37a372ed3e58ba073d2a06dd1fb539cffa98ba07cfeee901e1ec28e121069922a5152793c5cf9fc180804a0e726a8a308167989cc9654b3805762c194a693acf66c3c0e34e7dbad11850f1bb6fe1d408364c4cb10f4f3760b686adabb460bf486844bd2e67eb69a10eeed5599f1bfe41e11a59110451a1e914d6dd4e0832ccada086a36bf620eecec50993f63be23304cf04a0cbe725a35afd39abc971d049b65e0c4fb18f285d382256260eccfe056b839b8fdd70b2237f7b060b32932aecfa2600452425b2009bcff687be3814dfee877b012bafcd10b851a9e44fc1fb135408e9b1f9f3a910bd0c1dd88c9496b45fad4dfdd97bc51e86265d863cbc328b8ed8c18e511264f894d4c668d178b5d86811e6bb726677296265f5e494fa9a15fe058628c06f87eaf3bf88e0c2036eac63e0c91ef34f50b0595bbf4072f7224f83664695867ae1bb678015bab4035e2e109b949ecc6d66a341839dc7a25d8fc84bd3c739b90a1be9e3ff519571d624952e46bafff3ef676debc25ecaf377055694cacbfe9acfa7703c946da7a0383ea2eea88cef330c855f7dd8a107b31e45619a4a9c5b15cdadfdd01a5891c289b70372b6837a44517e56066bfaa205928739260e66cd3fa8e6925b1b1fbce097d3e0aa33eab0b7c5ea4c07e422449081da0cf1771b30515bc63cdbe82635e3025713ffc0f56d6d1900748c3244887d7c68d9b94da5cea781599621673046ff43f8ecbb14e53ea300921b16e5b03deec222193f52b3b325dd9ad631c6e933cb147d83cbb355ced395242260f66e87059cb03568922dd0c4d4b20ddd90f3594e823af705800bc4b4ca4b46ed4544e9f3ec5dd01fcf74e28426042237b53c373fb7ab2ba08d7784b2ee8dd6548c3a4f1234ae6b8e3d630b52e61ab4f8b031c349f124caea74ad91ba16e1ce341bda6abde7b1ddddcbad2762666762cca329da72292876967ee170366736cda2a40e9e3c2b3cb523d29a7c4bdab1b8e130d5b493ec3d7dea6a920dbbeb0e51a5c55a6605b7125c8d0ce45db87ed89582803e338efff9c748e30ba310384fcfe1af1f7268c5fc5f7d3cc280d6c903cfeed9d66110a02af41a2661128815f02498b1d48b0d8a9eea79a54ddea152b552b4e566889b5003f6069e273e49ae9437ae5d59ec71ec0cb865a135693202bc8c646a88256a0cf712a8b1d3bd57345b148cd4e53171af122dcda5d0af1529621a0edb20baad2accbde7b45ed1f02433195802c0af09bd866e6fa8fdf9e2ad2690dac35c5dda13f24f37e2b91a3b890bb53814b40e32a963771978f5264235dc7f63fa82be5645ec084dfd211f57c5693ddd32ef309ce0526e2d226a56f498962c4b7bbc054e8170d8f8855dcff4ac4245d64811a2e580dd662575bb33a2d72973736a41bf55830ad71148335787eec433525e068093e8cfb2bafc5b9691c3ce2397dec4b1402682a8103b420be13475ad71ba9f8a9aed8d94f7f7f5061dcf987eb2d3c592253378fc14d0a3aa0d10ca2cbc59fc1345ede6b5e8b9aec74194974712a33a46c853cdb52d61c6343c784ac5e6f77be5263de5ee219e9bc670346edf8677756635c386ab22913393c9fc2ee7916b130897a55e2b9d322a1185212556c16b92e45ca748e0eb0b0422e27503822524a7c9d23db635a49ddca2b07864f2ab00c0cc0c97e212e2d35db65102fb97fbfbf135a6cd391078f7fb81c85cf2b7f7c9e36b0d39161ce7f4b5ec9a63392126d2f3b1085a10500c2cc860c8b24ab5c14b996467aa3c1a45cb8f48e3d9935ec51df6973fbbeae3ff0bd2bd1f2d42386d183c2ae4d966796a6773e4da07b73b34881c627ecac67a7bf3ed229ed927582558d1c75fbe91588ab00b2c160de0a456df45981f73dc98e95be68899d8d13c7acf6017f02802fcb034e168560d1404c5ff9eec40adcd935180b9c33ffce7eadbf6e571d741dfd3c0e92403a109ff6ec9b7f70535c6df2c1e60537fb3fafe6c99ca6c8b0acd6c2b6756b410630d3b060b3a58d0937a9b042b6daace8bc39a0f87d122c38209d96553ca6c745d74c6ea889b7dfc20508033b81c9aa083a0c93874038905878fbd84463427651a32acda86d16cd58f92e2bdd0d97a46866ebd28cf428accd2463049144cff229dbf3368a6867c3c2b90efd2dd5199fa10f547bbbe1e50e0951c1bfd086d5947976d04c2fe4977fe644319cfea2112622176327f4e129714d5dbe33cf8bcb95237a7e510e1668fb7f5c51023ae3db2b8ba49ddf9f0eca1efec402cda3c2d054fd682187693578281022468b3a6a604adfcb66b6a718344fd0d5a1ae03173449ab78a1cc829980e0f6dc5d91f8a07d1ea32c31b1ad785205e776638523f788c314347c11957bbbd80b374ef397e5d3a31a105daf920493b9bb3beb701ac738bf906b4fd03ccdbe4b09f923e5551f7241f43381cb5a27602af570624c14db3774dbf9747fd800249c192e67e9e63aac9cac9e48057fdf155a577fc35bf9134317099b64b85a8a5744ba9b440872ef8e6d7abf35acbd04861c2d59b53496632119b0007a89312cfb97cff6d4f57b2fe35793677261abe12b459edeb996f74c30650a0792119ef9700adf973c00b3537aaafe3c9b448707c100b30a24d3f012d414f36cc291b6af2ff94cdb0f76cb6ea6b129f466b702ccad0fd6d8b99835ed8e6cb3b481426c2bb11e57e117fe590091c4229924c34ef030c1144dacab32ef4fa807afda534eafe958be8892b6e843f0deeba39d2f711851a4aa693feea33fc437744459e105712a2160bc5eb054c35c35b424fe6c8760c4bc8f925ff452b7913b4e416749ee48386d36e3e6e9af29d9feafe3ccf9cf42194b2d24774e9da182a59e14268bc9eb81cc2dc0cfc232d5362afd0da1862d12b0264a62c0a9ccce61648967759e0359ca7f0ddc99e25682de13876c551f23cf4336f5d88716008f9526af3f14a99e1514872ca14569d290c9d9f36f655040820b1255fa0e97b3f80e17417959aac383f8ff197638a47624a058f704e1439c13fdab94e900836fa3911a13328a2347507b0cb4ff63c686a122e23b8ba0ee8cc21966aa22db1b92d58c913aa876ca8a9dd60853a4dcfb760ccc9e50e710b4339eb01bdd9344f2a30cefa95317b017965bf447100b703a07451085657c8df483679788121d675c2820ae1070248b46284036925edb7a06132ce2a943e111b585123be604d8ecc0b1777af93a540bc5f9e1e7cdc5799c65d7423fc518a862fdc698c5be32bac20fbb1d0f2dc41d011d034319fe02c2154e064cbd204fc0860cfed60aae55a8ba9230780f31f8a9631c9acf94ee20730242f7b695fca20b002086a4e04a300166947cb6d7812f754e5a83d5c76faff07a0072b7500c7b125e2e2ef15f6bf2498f4b7812d2e83149ea24a50185e09ffe5078f9da944a60a391365c0ffa96e6055388fdcda03eba851ac03e5d736651ade4aa54529d0612cbadc5c4351d28a5b7dcdd890d0dcaeb5ad2d8b048e1cc8a4466c149b577aaed0a357792bb1c26419fc750c681e2b5024b1392ddbbc84b1c501fa5c622ca68a4ecbd62740e5f96c65387846bee10b14382e177af167c12bbd6756a15e64826bcd3df531406022af9e179ac496343dbedd3cb7532cd23c6f3f429a5ed1d0400f42eafddcd34a6776372416486b5009cba5ff45a70c3104aa7eb6a54d66ac272bb83c786e4e3364e1e786f57083013d89721fa7e3a192e1b8633c40cdde621615498ff3c5f1793b704a27bc6f36580e6a2a5c1799ecf3b2fb1c6a516ac4a12c45c7ef87f19bfc750cfffea3b64c34e9d7fa75c8b7219b70d92c6cab6c13311850d18eefceae8df35d00642f3a7f79a8de06605c93fc23a9ac45a419e4308a89382675c9e79aa7833d9f52f895b26b0309938a7af24520e061c984d3276a136b5d094532d36d452537325942e7e7ff4c6ceaafa25ffebdcfe1b5b0cd7e1fa084ab3d18713cc8295edb83c64abe890725728f5459c01f9d46595013c41fa752db2c6aa6653bdcd0552384ccf118ab95d9d232c06df5ef249132161791026c1500853755faf0fa6caaf099d90526e7859863de08dcca5a5139b1ee568ae9d9e7f0093971d883122b9900b382b612094d05ab9746b332212b5aa40d02003f66694b1a77f52af97420a43f2df22bb29a4111a4912bac8fc8bbc4251de925f96561df87e38875e6b9fe69c1053c7c3019993f1ee0ee11504cc0f19810b0a43ab4fc2b76e71bd1fac498cec8a12509e856d6011e9881304cb23cbae4f84b5aab03de24141a7fea7da0389e61e37497a878addc42b5c8dfff061727bf557c580472b3351ace57e162b1d731f1125c5ffef82e93bf7bf6b7b4de5491f39cf1de74aae13d6e1f1fe30235a49080046aef913925db858efa3012f9244bac90106393713e26cb871b5f27171c1dea719074323faa6a5d900409e28500b0f057a3b576d045196118a634446f23802d29acb8dba93922543e846f905a3e5b1470d30c9d95b808c913a6ae0178d0cf0d8481e2cc478250ca4b44e333e3d6c0dfd7bb8cdbf49be5833198708041afa67e2bab4ab2779fe9c34c4b5f5f3be759a5eb9d9ba8d50671bb81231317858daf82ded9663245d1dfcb4164ce8d738f02ac146cc7d008c1fdb7f54c0f4803a0dbe5f8c3e605f2c547b89fe3339864ed1b2da0bd991ced317c40376c5f2a354e4627881315db417eb20a85c08d1bd5c4c6955273084307a62b9e42af0f55262e54c5981a6e110df34e8e1fa0b9904628adecf83e4fbb2866f491c85f8106aa1030aa96146296543ec21e02945003fba134e46f6e25f393dd0a6612aa102cc58965e9550e48c389c1c04a326470cebedb427e442f8b848df82a8c5d55eed0d1446c6e5d6e0ccdfa2d219019ad3d400fde350d690cf04d083844adefe5069c7066b0ea24854ef3f5853328d7bb2ea735b370eccec5f0f777a467c98f040c423fc4c3df237ee8b1e9cee6c859c860c0297667809ffc0b73af9815b01384834fcb56d3e782ce11ac9124345a3d34fc22ff7e0c3149d66f7bc8feb9743bb54405ea88902011cfd4ed07ee19c6b8e6de6dcb08e2e86427e5e675dff052652af14d7af936f032bbbe508c54fd4dfbd16921e7b1c1471e96f3a521b911e32a5888b5a4083be97a3ab843a1dacc19e60f161fd84c10fe94c9952829da6979a83ff25faea14df6f6d5c876f3103a8a93deb51a3834c9da185355a8b189585f7c71ca082295ba29e326e60b9d08ec5386deca533a03b903541380cdf616135e348c6b09a5cd4a074d7c2e3d794e44a0c4ab8537f3f53b12ad2c2a996c5ec0a1b6d9a25d920a782bbf2120262a71f816a66ffdfedf5e5dbb868d37517607e880d697720a0119077b19df4e9e8709a177bd25508b00c6c79d4b1c1ca7f607aa7b18e6f93e40c8ac9d8705bd9deec9626cd4aa06491416430f1e204177b62d1bd18e9fefa0da4d6e032f785851dcfdd3e2a2058b1811aaa976c30a067d9accbe4504abb7c2a39492889fe518dc529cfb481320dc05a785cdac3fd225936716b149620ce252d079b0f14a947bd7efa17868935b6483516f7653fe108e5c1da91db5a58a3aaf920ecfacdaec9cb997d80860e966fbc4c2cdc52f41fd3dcf8bfd70fc4a28f99128b1b5e0d412c91fd59a9deea1d9b5170e92e1ba12064847d72f9ed9a58874ce906252c6679851b735cdd5f3f17e35e0ec6117e83b9718e85bcfb608428bf03df02e2950a07e80844403f21b8b0e6ce349c5ca2c260aaa780949050d2d9fb90f890e0d33b4a8263b0f3ff72d06ad34072f3567c85a6e301d5b374d9a78a94e5a3523735e3f9c2db0734aa7c7c5787879687b485f1fce35966c742b896aee8f0361d98ff221b58f0746a0bb4ff1443b1f21eb26e1503187f52903a842a278d3cccffe3328876cada9acb5f109f1679265c39ff58a2f5f63162117f63556389d00b7ddb9cfe0346c62344ac0c9f130294d0178425920cf8c5623e09bd387d8f1d1bc4a7df18f8f38f20680ce2734505fccf2d7e13a0fa68ae5f7f949346bce6896c992cff605197740913534fc38ab50d679c92bdd04e6682ffb8581c3de476b13bed9e72cc7807e6ae6a0f0fca5cd9a03086c1a5971991a7e0a074c128727a4fb8e63240df8d4e87ba2077b50ca0c1de5ca6b4a09fd2d16022aad1342b0dfcdf706d13d433db3f592bb467f911fdd09969d1fcb4fbe4ac156a4227dfba8999642bbb7239cc6bc02d4e1cc5ffa47642171b9807bc2e62027befda4cf5d0b994e36b110580f40ae0b8505bac989738219bc3deefb4fb85037482687f8f196ceed78ef556907987d952b042016046c57e36e47e9d5e4c71d5fb7bd2327809e4663d75a402c9b6d89857d2d07375273e3142dbfbd1c4c658fc64e2436ad5d8a714d9a626b8c6a26c3ca5cd8b7bc75162e5ea63a1644e4365ed6b16107b8462e7186586b0b2c43f526f0656c544b70f5e59e809462b1e00853cae8bb57e39c55abe0e2435c53bf68c0dd39e3bcf6da3250f4ad1d47f1e9813b22b109c9f2ca6b06b362f8a0c11774cd90321561ea5633ae94828698a5b87a338a0a1ee58aa9e3759a68ebce835ab5bffab1cb564a704c220e8f451d02ca511d3a61071e59d7a638c6eba218fd186a9abe7144e21dc862d71cc14fbe19898710ec7321917cb26df10994c2d4980eae0c9c512cfaa4068fed52d0c57c9dc3fe75b51f333210839a37ff90e8508bbe215d7fd50cc4c90daa00e10194fb660fb38b9a85be80afd5232edba10ab7c98dd8e5ca4eaa6fb7828b529711682b92e5c980bc877a83b9d7f0b848181110e370bee7ad434463f90c954705032d56c0b86305b83f61642daec190941c8b687f46d70c0c0cb4d627c0af930844189d3df40c1ac2c5e0f19e598bea0d6405cbb41e35fd850f26bec7aae8873c883ba0fe69c268839681796ad11c090e891f6cedb944fb4118092d8b4397dce87fb4755b1ac74217d12597496c41370c4653df24c3df308c2c9605efcaa3e8fb55250eef97ba85bac046d6aa82d249fdd348bae7b1f6e658b8072a2aae3dc22920e419e656810cf8f80398bd4dbabc4df89b4b46328524ca43edc03677156dc05a215d2c504db8b28e876a1797ae0b57de85f634151a8bde6002948ae1f540fe4d5f53186fd979992d4bd95c2fffdaa0d02596e17b439ab392ae0f50e6bec0af1ca9668890801d5dd1c9fa69c06ef9fb04b9b0260e8279bf93f1fb0de27d60b0c0d07329f986aa78e6660a8d0785903e7bd71fa74fa1ad87a952a22ca0c215d035817ef038624b5445a326d84ca96a7486058add15801596906b1d78381b9092f504db0008628d32fbca6471359d445a248c0019ff3b8f6157b7b45c14c76ef673a927ac5e425c0a2cb71cabda5b2f323aa037543ffe1c84c1833ac61c016bbcda50b219bca8b2d210914e2e6aaf5483c943fd4e7c68228b26bf751cb466667a66529cc4c19812a8306a25776f5ceb24a601baca327cbaf470a61955474f3d9ae0aa8fedef83fd62d1d1e843a835c3b993a00f09faeadf015cb28d01b01fe5ca49864b667ba0cf0ceea8439d39cb2a9ce71f7b3a5a9b2774141bfd68baacae775d48ba40cfdeb1d1018f77ec090a44ca5f4672f8a1b6110421edbf5014dac6469e980d3e207f43e25353c1a7d4d010974e145a7cb8a5e05d7d79c7f4eeaacd410dab582adff9b9ef8ffadda3682651dbd8ee69d60464070908bec020c622cc00cee15aed981698ca7d413b83b78fc1a2e6c85bc11787374342b243093d26301476c94e671d7008c7f076dfc7d5ea5d765cc4e82b0fc85ffc8c6637909142f4f3fc943170002ee6e4ffb8a3807970aad74a2aa0faa7a3bdfe4c925757497aee9bd3c1ed174e3aa9ef62d6c8df963d0272545e3a19aca824d7ebb9e22d1818f67e98d5dc3e1b3c45fbbaf8a5e053db3fa77af51d975a22ab70321bfc40af2e3828542f4236adb4755552c9437ce84d39332588d33eae8fe5119eccca99d74962a3c9f09ee67eea15f24e58fdeb5536db348f335c67ddcf19dfe848cb1bf5f2be87f5641032816376f9dd3a983822463898a9ac4fa1c88294747715251561bed2933c08be3c006f05a7b3fce71c179e9fc1bb1de53392ba96d0080179c058c441b9e370714526fe5a01dd1ceb43fdbd75efa6324d799955a4cf9441f50c25e456c6436f95fb183851782552a4e3ba51d2597225b8f2b84dbd01ab4bebb18a49712ea84e86297c4be4e394a3d88646bc8da23d09373a2534fdec05540253bb9435ce0f9c1ee444de9557f880d3bc81ae16dee47085dec4022057b0d3cba15569f542939f58609cdacadf9d5055a9b123be4fdde7985a8a4eee0d37032769527587fa1e09cc7122c8323d1c7ca23a98dd63e970031d8545288d6224c9cc034e60731a9212a89fc6704e67f4ff3638366168abe7c5300fa1dc6b95f56e079cc9b97595750031d8d346244a5619031e924c5eaa8ab82200032737621f4e5684fa19c40de1ac18cc6d416ca42dc59e52b07e1a69f3dca3ce63ba55a4c1a3cc761148f83808c62b840b9252ec3fbb2060b9e7c75f6d94891722056d24771bdc8806d3c5124153b2e07ccbb16b02987c0e0ad70a29b48ddba6a3201ed15f4c055ce2b9e3feb5a7ff082215587c9d891c9c02c2eae1c5efd8625c6535ec57be13465f5d4b5acff1945f0a7a11b0e41546b1e8f3a3ae85fff4ec1c89c2dd44398d04e7689464ce2c631929b4652c9e7645684a0857d6c2cbbe2363496c88a5d05050fc76d488ba7f953959cccb5ce8e062c203df001a542cd5e3ec4fe97eb15619a9149022c9ad71b9de36a3a5d257a0d3ccca684666a703ded560df69a53ba546dbade63093831c306d04bf0ab91ef00f96e22edc0e9745ee374693ea38e7c9a66f766d395be678036af3520d65e817f05c7a9e4b5ee15decfdd2c40e6a75789c112a2cd02da7e7aaa27b57b50626a8f989630b47550d39efbdf17d08da5e066039e2be80c51a0221853d0d840fea4e5d0a818de468b455d1a99b98b69ba89c118ff0bdcb250fbfaef760e3eb3098b92512e0cbf2cd32052281727ce17a1d55824fe953029190dab087eb179c5981c1e785a2400bcacfb5fd63025983d3841b2123e21b529bcae8f9162068db42e1280053dae8de583b3b713f2f78738df67188b7a01f40f0918fa1e51ddf85757ce251e903bb996d87ae4c845a420e6333e0a3c292521190d1318d4840446166d1241f4a837b47179ea554e144991857037225cbcb44e782a9c08d58f166da0e7dddd3b05ff2f7cb5ca53e445a3e6c06a1e3e03c7912619a8418606b4b5a6d8df274ce2aad313d5ac4305024352e9219046a0ec8ff68f6d7ce075490b9bd41fc9940f8a73fadf6577a4742f08d0524f72500d944e950ec1a7b45d2bdd46df4bedae251dbfd53c97a4d3c746de80214c46675522ca77fcbb13500597ad629d5625f9c2ea4c38d1334225b00ec20b9127dc4a15d65f129f4f95668768b51b02341df16c8430c163878ea13ed24b683b993732cc35b987c78e2bd25f1fc6ee4e152bd489baebe997a247076d380c092acecb79c91213a29ab370776cd2c3b3871204cd156e2ce3ff091fd31b65cfb824f14f400f6d9bea7894b8e2744e60b68cc0c05084c024e1cf64867a132f7429c9411fd0c9e225f4828bd9f523bdf3f5a8c21b09dbb8f4770bde3a488928ebdf0ff3d2c300bf6f4eccc94c5b1e4551ef25d144cdf78fbab3fbf37f01160ecaf91b153e6a9322575c082c4eefcfcb41f606eacbc87e9ad7022a0916ca782ba8a2bf4f408d135a1605c85ba1e211a78747ffbd1ba7c36589bb7cd801166efcf55a8e2e9e24bc6cbcfbf1ede191a777fb4a6a67a39bb92498b8d06b287882c859d668a7757716572334aa19f4624fbd7dfb3cd42a34f6f12da60c850a21a2e9998bf4256b961200e57621dff71ff89860ab8f1388b889e6836fd22f120d9f42e08f4999454c0523038e056404d989a3dbee88cb59a57efd7c5bd3827bc85a0bc8c02953ed0d7dcaa108c115a48ebe00c19ac6a0b7daac1b1468d6d8252e93f061bc381523fbea0f248d4de1945c704fd01510d54aceebfe791ff1a44852613dbeddecf2e7fdff1e981cfad3c615f65ec413546c787497f2dadcb2022a6a2aa463bdef07ce1f303b06c8413357261f8d662a71d344737504ba69b8be1ea8252e6838ca8936dcd7041dfd6a646d1cc0b12436f3c89a7feaf8f57fcd34f860017798b1cfb22395d2f2836dd02988ac37178f82e5c543a98b8982e59a0729168c866526ce53173da0b9300e6c17ce85a74032f052a82142b290911a0edb93bade04baa6e061678107143823fbfdbf3c06c0dd0de671ab6567cc3ee3a657e7ecf6d10acfe4ecb89f9698307623643468e0ecb86d9d9b18db9ebd3272d674b43d42784367f2454b3759ca6bfdb30a9001d8b0ec48ed1378d40a33524c3a81de9f331833c8a3e9cee970f651dbfce88b26ed8f6a4240fa2907529e11a44d4b35483310d25e3c006f2d7d51432acc216d43a4de48db275262f925ac1669a7e6e9317fac48f5a8c60620767062e78bc4d93c3fbd5dd47a332512d2fda7447f76a7badc77f862f290ee4b89804280f591a6badc290d3e128c46b681e69d71c3ed2a3b6cc4c530e0479309d6287b692e08529de31d830126afb4a4652a8aeb3303d3547d00b93b661edc1b226d6d79a7761fd1e43264a090a0d8e9cca3454ff74b8257714e299ed3c6f5b6648b9c26bc78ff09121b9a485282e4c5c2b240129ac0819c8532b0b9cca4472c180836f7285d09386581375779cb546d4c8ac6043b3255ab1035c1d6e07647f453130bbe2aaf04e5b7bf49d0cd6474c25a75c67901a23870ae77c32e61af3ffea207f8749100649c3cc054c36691d4127bfc7ad18e1f018ed75f0609001dd83e41d6e2ac66964c248eccb2802c378c9252146c8674ac23b81fc13b0089add0152a1141a6472370df94ae57e54ab1c3a26c55f24a1dd0ccd360e794f0a63987a08d50ffb84a76d3689ac1211ea5d8917dedd6abf81476dd0ac1c7017aee6abc9ee1a41e6f5edd0b89b9d99983857dc32914abc1e20c29c2c2882c21923c947c980e43393500716ba97ec56ce33fd4d01240988636baaf5aca649f87fe606606fecb888b6a7c62dc99688774d648982ce1cbaaa3282467050963b31d95c29f55d427d4166b142f767a695ee5be116bfc9455f405c12a1c3e7dbb14564f94c73dc0a7af0aba2b89c172b2fe5f9c059c0a51fa792481ba1fb6f97faed51fa1e1857eafa818290875f34d876e2a17e5adcc7bebc7b01b941b9934c2e4942e9064d836f976444ebff2dd6c52f44fd9132f4a4a0ab659f052f5b80e6696d217568dea33b7a90302d011384961f7809b0238ed7e26a28492676e4368ee5548a3f5be6b7c3f4342ade03db48e82bb247dc95b52638fc38802881d0c2691f2801d0be3a66700ca06e22070d3987ff4d44db8f952832f0a74e43f77b7874bb68fa67435fffb3a5d98b034ae7766999e8c9563366a70d86110deff01dc7cfae0391be8ebad2fe2d816a06daa82ad16587e43c91dcad74b672541420d12c50f82f737de005ad7235436f404e87ae5b3ac732a92a34bfa3c20f267fd4c7ab07947232044ed716b52a0eee6bbd8388d7e4d15c904a4ac17bc8a7c57032a9e8e8a5c30ceba4a078e335cf0db5a938e3233d9e16a503d741755da53cb2b848c86c25199e1245000f93043ed0b8ca80200a4d1cd64118869789d5e90f2b393c38faf9492f91051c29563e737b8d7c5c704dd199696ecbdf796524a299394015b080f081b083dddfbbb0e92e54cac171d082fc24500c43d3192e533573280171d8acfb0e33fc3cc2ba48f17e79700bc38bdd079718ab17b78f8e26c5abd38b570f0e2740200fef30889f313080d369831481685caef5a062fcea0a9e47b518a91645422baa2362f4ad98e17e5171e456408b2077fcd8b52a900dbc50e7436cd8b9f6366bba86dff1cc9aa4168760028e60680a22e0104c59bad251901c5cc0050d40b004700c51b8d480450cc0a00455dc4a5116dfa2180e2cdce50208062fe0014b50730a84d3f01a078b3f3880050cc4440516f10146f68363a0028660380a22e402b1b6dfa4240f106cf7c4031f780a226c06bb6e9077961261628661e50d41d30316dfa406694857f80621e00286a01f88cfe8ecf70cb0728e60080a2d631c2ad4dbf87d175ba30baa20f0050cc1c80a25e81a2ca69d30fc7bc012866ad0128ea1c5054c1367d1c50bcb92ebaa26f3300c51b15088a2afd81a2a6ff44f90614b3e6018a7a0798b46d40f16657998cb26c0d28dea87480a24ae70045adaa59e300e9cd162d28de6c51dbe055ba1615499d99a40227a67136b3e19bd31a5112b09766d4d42475269426457369ad198cc2742a8f5dc49c9868100d923ad9680924d86ba63edf5c37cb3564a1ecca2d2525a9c314862ce6e4464652c777b7e1177e022761240c0b1386c32d5c05136121ec72fa7c6f4e6540c96257264c8a3109690ae5ebba3f5ca32b044605a9336363665032398620757cdfcf375791ac601a93449c2d933a54db5c446c2fbccc10238707fbf9ae9f6f4d4657f445215949636df91d8d4d8fa40eb67c20b2c73f67b1ba7b752315f46e7bce0eda5fb6a9267b2d49007b326dad71b66912d4a63ff67c516362e747142005d8b283098a40f6fc1f76fec654c294404ca94bd3d6db9f7ef69c2a5a7a983d147776a84a2582ccf6f7917252ea5cabe420875486568656665b9e200fb1b0b267ce13a6e7d3393fb9bb3d6d0e91aef9405461026da74892ec49bd6c31f7b03939e80955ab5beab9d30f7e53eae1299cc4113ba16def4bf92738cb47bf50d65aa5fa705321fa725aedc559dbb8ce4bc9e899ba6bd2e66cd0dcc081812a878e1a9b1d3c6efec3ff9bcba0cbc02b92b327160f2d0e4e475f3467ad73cc3407e3ae38a741e7f3714c74e57405e6a17d24586ca645cec5b99c27c8593e6f61b287522ec63ddd7baf067f2f0777f5f7de7bc3bf37c8fdbff7de7bf3f7b22ef8f7de7bbfbf97e7dafcbdf7de9abfb783cbe3efbdf7eef87b815cd5df7befc5e0effd7175fcbdf7de1c7fef002ecddf7befb5f1f70ae0e2f87befbd37fede9d5be3efbdf76e7faf8ffbf3cabd7706e0de7befd5b95368e6affe7befbd3deebdf75eeeeffd1000f7de8b736feaefbdf73e8de7c1cd206783202c9e0e80fc188000767c0440a7070034c0d10087831b2b1dc20d34c8c1c9c0c6df70cfdd703540efdbb8edb79b8d9bb1e96ab66db3d96ab64df3e0766cdb66b3d56c9b8c6ac360db3ea523874c25c340e6d1641be3138d8d0e870e372e8d8d17a7c376d452b9361db455c964797399ccc7a7f18e3e6ee08ca6b5f6cbe59a1dd49f6f0ee394cdeedd14f7b6e7eddf896526f9d898eca1201c398bd26a85d62b58b687f3de572ad2a702ad5eac55b6f7b548f684ef7d6d39ab6697e76d6086f4a9473c2f5234b677f35e7dbd9e5e605e514ecec3a30ae953953a78915ad1247b3e2467d5714c1ac791e98af37c11d2a73e0179911a01933d35ef3d1d725695c968d191f754c87974bcf7148af4b1403f5ea452b6b703ca59d6356b79ef609cc7e6bd772fa48f3d7ad1c1d81e064bceb2af57d3cbcbeb69741e1c4e481fab248017fd0925d993e3e52c3b8eb011c953bdf7ae83f4b14f3b2f3a0fdbb3f19e9579900f156d2fbff7538cf4b940d3879d63c2c89e1b31675d974be68272cdb6477385f4b94701f0debbafd7547a2dbd9ab647dffb7984f4b94ad387d5797126b1bd1aeffd2472d61dc76934bebc991e2fce29dbbb4fb23000785186b1bdcf80f4c140f3bddf80f36cefbd0ab207bb64ae984882b3b0cbfb22d2071f4d1ff6a5922702d9de6b04e7d1defb10644f7def43e749bd062f6eb0bd773c7ae08b747b9f237db0128eec71161ee9cabee7fd943ef869fab0ef79af81e78197b4ab8bb2b8eaca711d4d1fce0acf1165715cd5ae97d2f4e15e1d286dbbc964a36c94d5a7e9c30101a94fdb7e9551d6368e553656d9586540d3677bfa01e4a2acedf572bd5c2fd7d1f4d9940670f4a2accdf57abd94a6cf762400a56d35996c948db2a7e9b301edd8a76ddfca284b1b472b1bad6cb432a0e9a33df900725196f67ab95eae97eb68fa684a01387a5196e67abd5e4ad3473bd2511a292bcb64a36c948ddbfe7d9a3e1a508ffbb4ed5f1965e571bcb2f1cac62b039a3ef90900402ecacaaf97ebe57ab98ea64f56e2e0e84559d9e57abdb2ebb5ed63a5e9938fa6064a948573d65886c76d1fe7e39e9ea64f069a3e641508c8b7889ff653d9531995ad40fb3494d98083715634c801713200410ec659d9f6736e523c38ee75f3dc6bdbc7f9bc97714037321e321907b4ed6750d3e9189f6a461de3f8b4ed833b389beda554b3bd746c2fa56dffc360c3b1b9b6230c36178ecde56daeed68dbff1c9a4ab6016120c321f3641bd0b67f6323e7f1c9c6e88d797cdaf679dcc034da4ba96ba954faa5b4edefb8976aae23cda5b934d7d1b66f53c3ce649906d4b564b22cd380b6fd1a239dc7a73c8ee3530d9ed68b872fa5acc197d2b6cf693a2a9d4cbeb3ebc8b52d78b4eda738a11c3e95641968fa6c2328aa545a63d9ce40db2ae98f7b926de3f4e1be481ff66d4bc5c5b4903a761bb77d95f7816f1930a78aae9b6cbb93f3881369c79c47ecfcf3ef590478fb53698e7329ecaa8baeecbb5c1f3817fbb8274ee6a22c0e8cafec87d996737151dbbab898d4b13ba78a1637d9b6bfc99c07cc06c5c168ce5a4b0ec90d50b995742e666dd6aae7643e2ac3e2dc323f559a0c78019c1054903deeeeeebec3f3c0531f0a1e62145cd91c6c990505aecde974f373ceba757fcf885377b73216dbf5f3a79d6ea79b1e50fb1944e1c62b32c116e6b6e005a48cba165fb88eb65402e8aa3fc5acd0b10279c57568e31ab4f15331d2474a1fdbe3a761644ff7acc9346663c7130a8cea098bb429f519ff6cd2a09851e0e1d2fbe0c88f15ea7419e5219612fcd1cd8fee681af7daa6713bb6d7669ba79b1fcd5aab7e0cf7dfdc600acae7e119a9ef3b3c112a131393b7349d4c934903b9209d134dcc06e3c73b4c745535d734cdb70f3450771ee6fc6108c4cbc60fa429c706cd01e92efe1adffcaa5d8105bd2b2075f05340fac05545592af80abf93e8318fd9e0094e210cbc22149c4473c83d83f7834c1fb9e3e1bcdbf4a9efb258de728c93e1f08a5cb07a78856cb3baedfa2777cd5da76d910034dcf950f594898eae83c81eb977360d695efc1b3830f091db878ebec2ab1b9a46e5ab95d672784634217494d19ebe9812e9c8b4f1774f71784552600b73cb8062eabbd75ee519d1de035b981ef3108b1e63fad1ea400decb4ea7d0b75e74722b3f3dfe764073e7d8e7e3a609a82f0f45e58464270b8f3a1ca5b9476ef19a1413ce4412226991327041584ae38cd30464a2e0b8235d1592daae17970f347e319c9e01c0245ff4964348de88bf7690b48c82b72535c900e7ff8af52693de60ca1ef4feeb989bf7b7102b16b7846f2fbcf18394f77f49af144c8294febf09b4393a8a3e338e6ef5e14f2c022fe4da26f0ee550c18f82d4c1eeae4e88b350a02bac04b524674d58ca1fc0182d4e214b97a40e7efad151882f31fc9f23c7cc0c550167d7b450b73f1299edf9b387ce231ae1c04ef4d745b6f7231c38893238877c0a4d21222e7bceb30905ffa43c6a26a78c02a5ed15f1dec116e607f953ef9e7f4e7d2ccced81297846dd0764fbc40eb60bf18cbc4f9c401c89418c266c638c9fc39db79c07c85d1a7822e4f7bf224773d65a2ce4be14e877812d878aa64b7404e188068f70e0053cc4cfc2dc1b98c28f17f0a3e03cdb63cca47ddcf6e579c5c6184856d24baa9f4c94557de5df650d631ce2e778ecd3af7e8d4f888c64eefc3b94e54fbec20f66e3a8240fb33106daf88336fe1f4fb4e87f57a8fee4f8bd22146c61ee0c6ab0fb68cd15c6390b37701247ac42bbfefd797fbed350d09eef5836fd1c22cd45a9e09df781ddf9a5f529377c737cd022654d222faa26bd9484ecc9811e217dbce88acf5c70e127e8338a44dff31630ffda22f3535e91f917949bc23aafc8b49bca7bc11e1e52b08e30412959142657f591b4a45de98823750059813ee2ffbb3ae82fe93fc41dcc41e8191235729ea35a93f66d39cc75643ed2f695fbfaee84ece9be7e37df03c5e9b2bd790b98bf7945e63b9483f1996c86690c6afa741a8bf5a0459fedd8b3524f531f7df21585499a7a5f39d59aaae87f28f34b1ff19887f55998dbbd7828ba93c3809c4774a75dab4bf6c8fa4960c6a830bbfe0f18b4e84eeee43c1e73e9d291a8bb23d125aa44b160f19c4daf7858fdb9499f3cac150884e915c8c34a6352a7be10fa087d16a62355094495c89eedb9dfb6bf9fc881e274d9e6b0e8ef3207e361fd9c1e747d975587c252a9087675905e79ba3f63333663dda657a897c7b111298cc2fcc859da8d5ce25abffead4857a44ea558bc68fad023a48ffa957af926d592a64a49489dfaa2e7b0eb733f5c5aa43198f388f4efd72fb2c78f50ff90c8587fa7a1a23ddf7d3ea5e01cba9da8556eae503757bd4e596d8a7a719e1e3416be4ad39f4f9f648fa493562ed5f99e9e8775856a77f6d01271a0ed3b149c3c48ee0fd164687c04c9058f50f07ead427f86eab306ab874c3879438b9656cb3af3429cc77e0c170ce11b2104e7a9b1e007b66efb41926d2b0d61841c9f5c51f76ad4ae4f6badb2d65a6b7561df2c575cd9a21ce5df0fc179ee8fa0a239abaefc6ab0fe21839e2d0fa5644a638271cf33342e4a29e5e74c8f3e2769473f107ce30fa2895cad0e4a991227845215826c0d04d96208fb88fc4e0c617bd769da431b5fe34f903df9ad9e2f93f26eec39ffbe8d1a9fd42627f3a53e51a5f70557989f0a415436dc092dd0b267befdd944f638cf7dfb53c8ce2b2205c50f6c79c54e20e731c1431baa54f2e7bb6690ec9992fbb7765224e9c3bea863b59c55f3d321849e20d878686d9289f4f22d9d394fed0312a5f3d39f4f73e6e867bf15ac7d77495fcd7befbdf7de9ad4791ff8bef7de7b6ff579e9bda9fb61ce5a7b185e9bc569698ba1d427482badb4f2f39772b6b4f33895f1192dd55a6babadb5d61c1974adb5d65aadad44b22db35811dbf6a5d7df62be9fdcd509cb96599cae6cf7a6b8ed59634f1d53f64c4daeecdb6cc73c45db97dbbf8ad98413ee0ff10bde90e9743138b9e5146999c50a2b5b66b1e26873dea9bce8a6a524d1a7a391d9bc907c2041640f1a6364687fe44abcb1e9933da93742d40ccac3a54d43038af5b52bd0ae11db63173127262c5b6b50a4443bca630a4316734aa540d199f6eb8924249895dd75a0e8aeed5406942cf6b461528c4948dbc6e1d89819942c67242b98c6a42b9bb625dad93b5b4be36850dba62f725bbe4f9e3ee8ac51482964382b1572456b8c8c8a85d64d4f0149f6bd56a98e7bd22dbd9a4445b28238e0c5da43035eac4294f0623d8204aff1fed40cc942c1c88bf50506bc589b2ce0c51ac3086ea30ac99a2e115ea42950c08b748b222f521684e0ba08c99a30105ea422f8e0456a020f5ea45912f02285512892359d10f0229d81c88b94ca7e91f630c4535e4896b70ef0a28b618017dd8c02bc485f1022e38464f9cbe745d7d2f3a2574180173d05415ef42725193209c7599208be3a68d0f225b883657b9c33d775dc10cfa2de19c43f846e1e601ad504a7f6947e62b735aa499f6e339d765ad5d1e049aba6b1d91857156caad56854a1a6654da3d99a06567b6f9d9fa837e6b4ac69793e0627c6396bda764268a9bdd652fa73ce3927a53f2db5d75a6bafb5d7da69a7b5d65ad05f033bfb48926ed68871d2d68a55e8c40e23a163bad79b820e4ed061462bd44de3e10d2d7a6aa973bf86ff2a95be5ef40929489d8b8287f77384d0a2def763f7fe910d50d6101530207d24307ddcbf7f5fcf21b13dafd8f367128b9b4ff82183963d74df9f462fd0dfee6f1c0625dd91308d9fa6e0f7526b41fc9c6704532a653b9b42e5e94634d28b1bdb8dcfc627e5782754eeb49c2ad5dc4013385054a924b881db089a90672c386b8cb2868c4e20fd46e0e40f710a66106824db390f96c9f9358953923d9e13b22725f3a91428cefaf2b8fa929d95ef7747cd987bb31b38db665af5219ded189d51564542ca39d248cee37bfe48c791ce2315e6e1b45291ea8bce26fe5918a82807b3e7ff8041d797f36cf4079a1fe22c1af071e813f5329b3c9c4b37b468fa1cfd56a8938629da602df270cea4ce3c729f85b96945aa583aea3cb282a92c903d5eeabdedbd979f98023d707b2a6e4f917eeefb5cf7fdc61487c1b2ed3737fe56f02d526a86ec997b3e3d63b26a8caee6cb6098d5c99e55863d5bf8452057f34db0e767d9136a4f2e629dedf99c5791a4cefc9c299a22c5f6fcf91628569f8a64aeb9fde63c582e6da24e1e4eca654fba14c659f3e9cc79f03f8eca662676f3e992cfa7239d383634b469be3365cf033ac58abf89e59b41334916c6de2966e447328ac8cac67fb7ed3e12996d04ff055b98437cfb8ed0df6610c8c29c51b2a788b3985a8ae9a455fe10a775d3bf20dd860ce930eec08b69e8af02de2dd01e73ccaef4936e7ff6f0d07bbafdfc193567d307c8f4d1e56c247828e5061bbf9633b246eee654fd9c01458d6303c59f3efa3529545f8e5c6dafa596bd3d069f137b7b1c05d8dbdfe8607b379201c59c02b78de6dbecdbf87e6c3ccd097b1349d81b68e3e5a64988d8b06103c4913a1b48f372d31f9a772109119ab79686e6b7ef7aa0b5294d0992880d319c2158c1eefb8979cb9ff4ab88b3e55b210090b187b0fce9729e2b7fb65c30611b412a09d9b549ea95c8a46472a8294b6b194957a9d4cb4c29864bcf820553f5c019811f28394ad1b4ebcb3ae794b5f370669a5b3fda39f6c22581edfa72f7d8f291d81739b03d10891cb37fb0f162fdfca1f31cf13ef450a652a9542a053ee8396947322b985f4ad943aca037f39904afbef74368fdf29e013d1089f6168362b69e0732bf713232325aa60192c8e55effc63da765b4d6325afb8ef33eb1f380842593c88dbff1338f648ed95ab6f748e698a5ed3da62fa33f2d23da2da3c1f7d0f33c24f6c5d4b740f70f1dc0f172d71a8fe3fb99791792903003fe2469251909b9806078a145e4c7850f8c59420561948186983144665e49122233a0129abf910291d8f7b81f66de7e343640570e22336093999f81ed0cce7c3333df05e8ca312801a9e3afe399408b322684fd99b742ea27765063066ca222a264e66b804d32112599aee42b513203bab055d1e1081b6658220a23221f904e2f314a9a9eaa4843082292aee42ba9f14a667e03945503d47425df41155dc997719926ae8a2a3bdd25655df79a4384ae4fc2f431926082ac596bf7604a1d9f2931498d8273ed39b779f9dccd6bda8df69b767301674d28bac23f299eb3e6757c8e573d063c387edea0791b357ece6821431210c20824384f9680b3fee7a7e03c746aee19d1344d48065050380370c240700a7da0e6f1353cbea6be6351b4555b66c1026873b5dbf1dd3cfdb4ffeffbfafdf0f6ef979ffbee771ff7ded77dead3fa6bd4781a9ac7f1dd507d187c8e4ff53abe1cef9f8eaff9fc6d3eb96f7e884f580db6d9f1e1afde0778dffc64a2fff8e70ed0a6061473ed6abe9b9f3b87082d4ea809f5a263d9f8455762e3175d48083fb7e39b9b47cddb7cf58cf0f89aa73cbee639ef7688c0e36b7e88efa8f95a987bc7cfa8300e14f443fcc6774dfd0bc8953f940cc5d9b2e1f1edf8b2873b3ebb6d3e0fb4afc1afe39b613cc49fe3f39687f8559f0379881f83cf5d9f077988ffc6e79fdbf89cc88b3ed79fcb7cfec2ef7d0ef32b8e743fc792e44a1e8efff9927b53f61975721eed77fdaeee5aed27b5cd1e11623577affed683ec5aa767a4babbdb26772ffee4b328143c6d99a5cb95dde5685b6b6f68d1d803c1e737a3b0bfcf3c0cc63b34e7bc71536e5cbf9a9c358c71ee7276d0339d87136a688a21595a9ab131c638632fc8e59e833b7586fb09e53cf9797c267bccf846b0a0c433aa89640322d84c318de5f01d408420a58a27050900e931e29e160eb0852440f2e0dfbc6eeff0fb9187dc73dcbddeb4b7f7b6efb64f4db1b2e4bd8cf6a7d3fbd4adb53a6ded3ded53e3ce4fff62b132b494df6508b33508abe831d163a2c75a942ed5d73b897414a2ae1e3836236da21e1803c18c93e331ee7307e278453658d5caa55efcce73ca4459381ed3590d6d882a1ca03f81220d0a6f809906f428edab0ef41507e617f3c679de7beab74d6fdb96da5e664b6daa6ddb3ec8b66ddbb66ddb96e319d9ba6ddb64b6ef3aaf03c189e319d9c0143cc45ffe21ce851dfdb66f6e0dcc86e99c4c9db75c4dbed7a14a148baf9cbe90ee47a9481ff8c8431c16491dfcda4789fcc96555360633141415a39449f6d0ad514da323dd9af653fad071fac0afbd967a24323bf5be395013b2a54880edfd8e8cf7da93f1bcd17b21cec3bde7b3bd2780f43e88ece9def33ccf7bcff3641ef48c78329ee7698fcd3c967951bfcc8d5764060cad56eb094d4113aebce5091213bef6de7b2f045c509a26fbb95694ac3c011440464b3c26d65a6b9178f295041365021261804c482208ef689a1a3f4b96905ba8c0b0d87105587111490912ca4c7ea680090a98c8518a1f7cedbdf7de8b63df7befd52266b6efbd59b4e82c29a8416ef1824836114608cacb154ecc96f0e0f262975c5faacca62934686826f304370dc99e5cb9f7de19165f49a5a526ed01332f610d1dc0884571c117504d88dc1df67dfd65df961833049530c43873d7f5a2a8cac507345cd5015c185da24a45174552b80294305151f282285230a94c38456152b493f1c516638ccf10a22b99f3cf0d32dae414443023308808dab6018c600c125f9c44b0022074706d3238e9321be221bee00756748318980f485ca1a105dc1623c238d9a10902a8254304c929c080c26310e957d1146ce402261915d43003bef6de7baf962186f6bdf706cd24b0d8333a202bc5ce40492042a889097624c3740415453a218b714eb0b04e8860ad566b0a26da320a588bc849511dfaf071feef903bd18c4411bb4e6890c517638c3186a2096a639cc31014add2345adf5087cea801430e5880d1058a9f31c65011c20816dc07ec300baaa207275c15474f3efc4802821611484cbc10b1c5cf84c2618c1fba128ee0a18624ae1841144ae6932e320419618c711090af649091a021adea7e5250c49210c8926a80a24395a11b4034f9f071fea160cce42e859f31c61896e42b393239d905c062a110205c3c18e1258b2b58680f5d8af0ba94c0a5559a46eba5314362965c308c31660213b431eea1cb82461951b41f262e6ac03180382f78428b2d404c61e50b26921859c0822c323198145d2c90c08c20ca920ce30e328da32516482d58985c18635ce5c3c7f9b7415aba5cb10d6d0da0220811784d00e921a78d68cc9596eb0b580e38074b74022a122a87555e2b4843a9e80730309528f785289632e00a59138ca5d8bb64ee501c7c1e91341fe7c3c7f9af42450bed89b5d63e31f2957c6598465225fd183ee009d34e102fb90aa127202a85dd42d3b8269a2685144d4dbeb811205e55a986a46ee9873a8009d7bdf732f1d68e945454996d8cb355420b0d8c1d722ca850c2894b8a6108638c9d6839c00917187ff2f4848a1374618124c61833f9f0713ea84b0a0aa32219c688fa82a50c5c44654c92a6699af653e42b7964e50a16a5127e9670184230f1e104569c0cc1840c430a1745d65abb84155fc92b198b56522dbd91259ac29d2ad689fe9a74efbd5a64f0b2ef3dc2044a206901c58c9f228c83982c9a946c0892df5a6bc388f94acaa08a84316bb98a4009e12064c87eb44ad3688d6fd0966d015ddc34848238e8d1c245d40ba2a2c002862e36fc28a1699aa66521e42b4964f482212519c9624ceac249ebe2cb931fe20e5cc64c7162cc099e98627471e24a54f5408c28ad20664c5c60a96734a518d074efbdef23048d9a664ad012941d6ed0678c3176f94a0a11d9225b18fd1845c8b0a488a84b1337bc649210d22a4da3f505bf20995165a8082943d8862dc61a59b640810e5f77982e8b2f166ab55a31608c31aeb131c618bbb6dc2283d0c6d8b593c060a225017df83817e3ba25cb0d395ca37ad444ca3d62ce643269c8702706891d8b2fc618638c316e32c2cac6d80a4d0ba4705ca0c829622fbc6028081fc4bc8892b840c92243030e5aa4f03065054a44f105d7d02445152f0a0d5cb23c63a4186717bcc08698983fc6788c2669204dbc61fb846b63998d31187a581b20c62593f029484c1c146f26c5698b202fb27851a362c0d7de7bef55c0102d4dd3d2c3089a3811c2e8c7059806241f2a52102e269911cc7849914c235dc96cbb9c819dcc2636bc144394b404132a4ba4ac00cb11627cc1642597a525268c317e828bf6908d1248100514315aa0d81002a3218c5a60b92c1947284a10dba161009391d5b20570400206298a20818bc98aa19264c91353d3981fbe98155130b6502e387cf838ff4d59c420858849c489549c1882660b4b2d529c5ab70a30568c2a3b425b6a88a2822f4870c49319943c29f1a24a9221588b0a0e60ca408a61280bce0b4d0372460f49d0e0c44a165e10c153367e5db497e8a00417b2041e8ceebd178acc86dc321446b68778b652f45333a8035e18b5ec4d4fb49c8a1f2daec75c98e84ae6265aa569b4963286a6699a56e42b7964e50a16a5a5052cd19414dbf7feb8039a8062b2538788f94a0e21cb4340e921662a225a4f842bf42efb4ef184114245f98bcc842f505a0b0b70d0863e7c9c7f210fdf7bef76b7eb5234dd1054a150b282a12a6ff1c518638ca950a2b531c63570d1fd6895a6d11a1301652230553af8c08f1645428c71c4c513938c222b5eb884a317141c143f0049e1d2c36c630c055f7b535130ba925bbb4b2d8021480a1aed892c964cd932cbe2880722a2789112810a2334ae931ff287f7091a829aa2e81283c18910d5034baf2d34887105891db00c398c51daa116162be2e1c3c7f9bf181812a30727c0b852051522b7a6b12f0e44eec5185b0d4fa182102c696202511469e143154fb4cc10021aa6e4f0650fedc841e34806335e512ef8c20823820033b524b19480a21ec000d3da320b8356d1524516a9a0d1e28b855aad56138c31c63936c618e32d474c1be36cc7259a949d291cb64f348d8a29464f90f8ac598c313ec3e52b299489f403ce3052bd6be609eed2e2a29950303ea93c542e4442331d232ccab862044c284144858b0e2e4e8a1aa880e2046bb55a4fae6482b2e2c485c9101eea92a4699a06f395444a1a999c620f1843e62bb9c52049617297178a6820818c66354dd3b4fb9ab7354dd3b42366be922d971091d16d00122f8ac3fdd162888240f518638c957c2597624dbe9256ab2110415aa569b4c68106dc84039525fa6b0c3a1830851394fd7b31de72451a1bdf8dc128c4c4ec96518a14a37ad444886dcb134948f91d7c826af1c594a9d56a51c118638c319eb22d9bc288da188b2562d8b62d4cd0821ae38b26a204e1189ad208639bc64499819e41b110143f685439da4952e4840f3f28e170839527a6174c70d102a858abd58a6225153324410521021fa298587c31c61863df18638cb36c1ac18f56691a4d0375103e4041b1a40b204d9f08f239676cadcdf9adb5d6da28a85c42d4ace51222ca259061a47d9a267fce5a105cd62a1a560933d8943a672e64bc76cef96d9ca7dbf91f27eb336625a0d17a2c72b6399909d56ab5a4dc2bb534d1b4ef6c37b9768d2c6440fd7815a3195e4489bd60c51437c81dc408e386fb2f7b780e60c6921b6078418b491573563486071b3235b2e4a22b99996427185ba9513c11e48442b9f77eb7afdf7b6b2d4307269e68594195344a40e46229fb76a1b20315306b5dc539bfdbb8fe9481914559ed7b1cbff2c5108d0e3f186f50687124b3c86634bc38bf7d7db981bf2ffe8ca1f8e2858d9f461546c9c66fe3aca0c5a864cc184a7b9aa1a90100000000c3160000380c0a064442599ea6499cf5f614800e6596526c50369d86b224485214c510a3000000000000208800829073b4a3001789589a955a9b67b75d52f2f90cb9b4157bcdd2c16ce3e00a990a31292226c739bbbd9835c20adcc6afa81012339a8037382fdd96c7f08b065c974661e27fbe4b6b2600cee951ed6d1c1c96205aba8556c83643ff8511e10c604d7a368661f77c56de01b4617dc87331da1eb9a09829d58134a28a237f74e4ca32aae8855cf3505a7cdce072f6b98838a5d6a375f2bcd63d2c995f60756cdabdf3d30f62ae806482f2e47fd2d0745d633cb442a43114e0ec4bcc81e0860d4f474b978ff8c71f480d3364e88b3bd2e3bab5e32faf69da18b2cec5c44bcde9d49c5e95099b68a5a701e4e6baa1272bbd14fd1e7692dd4b3bc99b8fba5a9c3c8ef5ec7a01abc045be1013800ec5369816f763a72e882d5cfc32bef807ff526d70d39601b99b926465357582a9a4acccd80c1d7c0992d1a68bfeae692239d12300edae46f6ab7ca0bb8d1ee94cc9925dc131abc92cd9dec37e20944b2766e17a123882e69f99e7e34aec1c67275835854084012c2b051d2f3360ef867c98be957e8668364aea0a8a4054494ac64b56fa0f73e6a633ffda7d13a6344c142b028d257aab535d8cb8d4842da4457587a87159ef481344ed96963c519c67e13addafd15397b633a8a08a34b8f0ee2193806ba69aa9f7974550bfd34c867623b14251abaf7165845690ee8d4aafecc1a9c3d4cd2b5efef7c82a8e9adb37d6935613b7d97c1ec4c8d7f0a486aca200fb12e3a03bdf243d0cdf6b57e274dfbed096f8dcbef9150e58292f0d7dbc28fd5854239db3400c10d241b4e16e47881bf28b7815201a36e38c706f89ee09557e7df2edca497860a1da903fe008c478d59a620c59a6ba01f05cdb7e18c0433643bd3feed737260631c9e07d006b5bf63808adbc7b45b7ef99aa0e5083a693e85183120e430db11e3e40907ea4618c467097b8074336ebf41d69d1874b8927312a54df0b10ad126090f2f62175a70ecad31d6ac2c30535e3e16a8ddc8948978012eaa875417b41318f703dd749607b67573e026a9e06665b282c4fcf8e299fcdc5c45993af3108d9f7046db141719d84240fcfdd6f09f3a1a9efe7603bb0744354e9c20019d4e9f5e7bbd596b9fc885e9e5e36f9fc8a9ab77be6c6a20d05a692df0b1253154b6dd6d245696b2afc72accb89cbd07d6ff1f4797a35be9f69ef5debc61b848a4c37341738aa729631219d35f0b839edb3b0d2e07523ea99bcfbd208cffd0ea2b9bbc9596451aa0dfebd42dc888495b4cf1db9a9ad6a0e38963ac28bc74e88861bd68a7ff8fdefaa4de013b5af3d5f2a02ba7e43255b2022065fa05515dbfce106f54db4f28bb7552e39881a4cd65865cf8fb0c5a1b38338633248e159842ba32e12268214f8a898b87fe3865ee5ce60ae80503f560080caf3abfc94ba346cc56d73435b2a66abcc7a44d1a1cead361b9838097d26b0ae0d8c8740f7ee85655c34356d631faccad21663422484ed4a4f5fde07582a2273f61178228dcaaca68055963f8e756ca37296d4b64cd06f6f05d172a7ed8de872a3081d11de94aa91798c980f1db1d6cada53246d0cfb194a6f62a0241bc0ed903f193288c7ca587c734b5be99d57619649cbe0f4c3333ece7b34b58c9b4e27f03f5b974ab95e9c89218d10b1ec4939bd4884953396d851d368ddfb7f13f340bf227dfd1741bb8fe5af4f3ff34e5bc49884ab6eabc5254af84399184029c3e5f463426b2c7c695e5542f3876a1597d79e0ffdff15a0a423cfd07b6eaa2756eb4bff2e7696b6fcd01092b9f5ecfa9e43cfed87ea1b0cacaf0b63910f719b5b5424e60ef026281698ffadf90c95bd336d7509676ee0250887152e543fdf4d0ce9b2835c2d8cd087e5b6e6f6c4aec81e1da1d356a58ede46d3f906226a0e856db6ae22c73f686e3f4bef09d476619aa291edf112a6db9eee92f22dd96cbfd36e35c315f161f0b46d324b0f879bcf98adfd8eafdeedccf22c164249ad8ac917983e181f9f3915ee441bfb6ad680c9b45468589bec364fc56c0eba51a864602bb0cc7161784c4224ae9089b7914eac4ac63d78e58190f1d462b80638e0bda7f4b5021af785c2d7805526776e6f60c979ce3d52ab4432dd815e35e4a0c4f94a25c16741d6911b6896fa3168042e74e8193560fbee3803a5716ef90d40c94fa423e994f9704d4563e9c484af9c5410bd89c4d94e3b1fb3f4e0493d562533e9b8a33f7032a42b646c56afb7b85d5e98267d4435a07e53b1f84a77321bca95925b94017437c005b39a486aa3415ab3194553288c478e017678604c213751d05da19359bc4f7ace368bbda50b60392e5b505e63b35aa39bd0d7fb811f2ee6a0c232cabdff2f178969e5c7fb3bcc63d0a5266cc2af47b925b1fb997088f34e21bfdd7ad8fbe7c0d518a52d68a54158b8e57d8d853c9d7b41062a71f60a10af8796db6cf4f0a7be6c8f36d4c199cdead3c01f747b2f2b830947dd087a8940e63b820f4ce65f5fc8b2e2d0bee4bdf30ab550cee9425a937136018405d5ff245d7ad8c077f4018cddfffab03b49e78750b570a49f50eafc38f9a12d526bcc88b46059a4c234ad28fdc13291b2e6cc106f6b4f5aaab4a50201a6842fb2bb6ded57dd6ee06b5567a8dcec04917816a71c1be608e44bc836ebe3958ce016c3f9857777952765a778f18874585ff4b64e6cd430e319939db0887f30c11ff5528158b08e1792ea4cca196046a792fddd925973b6012e7c3441355007fdabc21890579fc706e18737901ff960b62c22d05b65ccaba1d3d969ead8a4af0cb4bf12d6815562c66d6f3e13f2c54fb4b6ed0eb74c3e5a099abf3f3833b79d176563c9530bb040f2cc04db2c351e6f998d0e69b4396c79639d498a5b2dd351e306d8dc62280b9547fb6615e3cd399f5be9f2f5b9f7dacaa9699a7068a0361a48466a4c4cb17476da2f5f47ea44a089e4849c94e3d0d3597d7afce5193179f4ebbbb45296fb3e1e059b747c7340866b8e310673e1d5fb4ba63b2911115dbfdc595574b2fe99dd5e26680acdceb8e799a95c836ab0d95ad4b2b908c03427d96985045c49a4cab93d0f609765b4210d4aac2933e935c8d6fdefbff8a8f753c03b457ea60173cf748bafc448e1b4ebc7fd64d839dd7e7d5143dd05c1b32ee9e004b6c6aa99d00dab977667a1bbfb1ea856257b7c49ebf00824f1aaaabdf5c31433ff30f503f9635521c3bb9f506bac5431512b0520d378e0aaf4d90fd8022f72d806b13fb283189e59191a3e6c091c75543cd6cc87466b42842c45c1c1e8d0e71e93536a3fdb4d1b8b998dba6df603ce243cf117eeb6817d587d830e262b6721cd541856c8a0347fd4edc940436c308b33634fb4e99ac15d2d5f6931fd3c1c26026f0389838850355c373e04e41188ef2f9f49cbb6951ebca41ed52f8cccb902750158c937424795facc0867281b3268eea29f3f3addad0ebbc8840512141a9eeead73452003ab6759f4d68225221076ec90ec1668c69650907f7fd8ee3af136ebf9e2b6681b7dc42191c1b33dc6e669eaff2a3ed0897a3808ae34541d35f771594ed5b8ee6fb618a21cd6c3ea4006d6783b9f9a58fe76802bc45df94f7f5b16767e193a3a9af43cd6f0968d75e8a554bc605cb00399ff6365158bfead1b489b280ebcd5ed20869684e1de3128354aea070461f9c7c2c9634ce70001e97bce1f355eaf9948ac0330701751cbe76efb18859098b1b79ed39d974a016a58dde34f0e0c39ddf12b8ecbf8d7b40d7697e1a5424b94d7f062f46e184889e7d4be6b0fcf064bceb37c45909a679d3826a0cb8936ac8b26a0e45bfb0a4d22689f3ba237fdc72e41bfa32b6346ee399f6e9bc1350b6a9ab827f80fd3cb6f2004a13f6e02d567ced5c13344306bbdc43686c24447436d390603ebdac40a0a44c8f375e1f30a5d02be287f97b02fddc2aaf64b879c398ed31eac6f900ba8ab2528816cc480fb4799602d3fdd8caad6684898ecd63211cbee13733b51ce5fa9c21b97bcbf4ab59b7497cc855e666d904deab169136a81c1b34a455218a8a74388eaa106eb05050d23cd599c0b1b91e4e39464527a120f8fe91a612f693794c90321131a6bd42e4f0c08955e7f4d9a2db9112b83faa8317cd39fac2cb94910b282f74cb23dce4143925841abad3ca5f1dfc098e2165c3b5abd46d07339e8b1737cd4f7ab84d3250058e04982db947a6231d2ba7698b342020aac7fae284ddbffd43d9e816a87a3de6dcd0aff6ce0db0546392b5fa8b0e9542b6e5fd3c944ef5eb794f6aaa5a3589b13d059de1d2c71b6ac6cf0c0c5d72449d795f81883f62dd32c97bd8ee704a7d4367a014b589bed95bab6110b91a8cf39d23635d994c7c8780437ffbd4de259f678358f3e0e2738adeb753e3396dafd4ae5a3b16f2f30894027dff081cbe640300bf93240ec925b0bf86a6efac326311762adb8167f316cc358293a39821bfe952bbd81b4b6c2dbb51619cd0d6106261c7323a41ca0dd5667c1d9c7f535caab2da27f06787de384f4ecfba96b6fdf15f4ab0e08eac7fa3f6cc713b323c7361bac2e96280bec301cea58518c880e4db1cb61e9ab1488abf04ca7c0920c8aa3bd7984ce1587e6660f2b0dfa42bb0c5fb48eb78037d22bf0aece3dbd3f15c8e073605e04e427f4de09dea961ea93b2a98966c2607436d0a554619bc09bd9de262669ced06e1a2b0cc061ee782dd2e0f851c74df6467246127020c73703a1ea980fef963cbb9048867fd464892f49cec9a1f5ff783117af870030c73c4c37f5d99daae862c3cfa322734c74e760c8ee0c65b4ea7fa5e74934166754317c63ea0746c6d434b585eebf15dc4697ed53f178dbdc65a672853f4a6ac12e7745b94e53429f3bfae444d989a450304f4a46ebc9c491fe7c812dd6c941342b3196dc54fdcc9385e2939da9fd842a90cdd0fbd9348eece2503f9592ab468a8f864f6d41ef735e0380ac00e84e11d9ffc7ccbb16b35a83b6cf030a042873c97dea4a22394a1ea657ccff9d20b2515e133c75741df6091256d2c206b8510ac14ede483a066513e26213128eb84d4a4ca4d9442134063bdfeb22e64e774ed8f77b9be1d70e9bf37454037eeb53ad91c6bc1df58342348ce0ded737d76df5a3976edf231b2df75e38dd26e397f2634bd9acec8cad7dfdb84fe4ba971430111f13619fcc9344e55fcd7619dcfb4b427a1da24e10cab86da1785560eb19d8fee95ea9766f3e71c0b87c4b20ecc1f8e572973cb560d5d3920b951670218f17694b82b30506aa73890abcc8b7300384bf6b258932d1f9205c1494e44d981b7922db02a1742397cd3d8f66379bca28a990a2f9e387fb25e16daebe96fed5a79e729851c9eec0ddb79f4b673b6a9f4ad2239a17ffb39897185b4c266d39778f7bfd4d4ca694d5c2c3b4fc2dad44465aea4297525e633446c6a57e5f781983ee1021776ae690926950c4d6095ab7620b78ebc894d4f8a1339f109a79956ea64caa05acfddfd52c5b2af1488ecdcb0b9982297219c97846e9c14f7c6b2d561059da05febffc313935ab09b6e3d3e6fa69bfd06cb36ca4add2df7e66cd8d5bcb0a6f1801d39b5eae9b1bb218558193518f763a38c698a702df231f8ead8bc9d6ac55cb495488b18386c6ae39b58433ab9114de31ff5d1f4b7a727aa9979e19c75de1cd68f2e01e3e4f3f3fcc104e5361fb654c0c2c0aae4c202f308f370da17e580750c075e1c2cbcaf86101a7eeb99380aca3a15c0465b9375b20b912bf46c4ce9dc691f34cb057d28f458be7b3b25956b8b0669d234d2497ed1122ec3cb84aca600a4111ddd0d13073647b901ffa5becb4a8e354435a900668c127176ca3d40301cfbef411a268e7218f7cf23e50af1e0e4e3a2b2c323d3a4312265cae7a124d426a09dfc6099eb50a25099703c7da69b261dea18cbb6455e2a6cb76d283ddaab5328afa244588b52ad98df7ae3200e1558b00b1cc95fe3fd5ea8b94ac8b1f98ddc17581c780394bd45db415e705914c22efecce660f107bdb2ddbe618168781ddd0142890026c3ce6f55278c0c5911d3e6f9a371e5332f3c5d8c707217a9529d742266b51f8cf069f3471b78feb66cd8cd56ad1e78a873e44ebacae533e0ebbdd7e118d785a67286133ca6023264953a19ad6a215bb961b7b1350058e43a35e6b22619893a16e45c8e0575ecc3cdc1aff031900e37c9b8fca8b1265fe15bddfdeaca365ace8cf540189f30de1ac62cf4688007a52a0ca3199eb76b6180ec718053d6cf00b116c20b9203de1ad8cec04d0b8dffd63b28aa32f945bf6703b0140272cf50939a40f93d342d2cf143c3c1d38d573d0599cf963fafafbe1672d7587ab6cd9b7ee641f038dd12cb9b93f94cf7541290d1ddb0258159ec7105697facfea65202212d3f4c6549731712c6186ddd32888562aae5a3aabc151fdb64ca73b84b9180b1a753e9da5ae2eec31adc1440d814ac76b75d0510f7251a633234d0801f812dfb00b73bf1608c6471e0a127edb5fd6cc403d0c30cccb13f2a7918a6428428e11f40c90b3bd7121d717a5032e5791c714fa966e258c99c8c529489ff5606aa729cbd7f865836680a8edcd0ff887766e65ebaf81f215009b466ca1295afd3626468d7bddff5af49e8840da54e7901691308b91e6619afbac60f621595c6c7ac3ec7ddb00343c1e4824653b9c6aab38b30c052236b0a39910517957c391bc801fbbd8505b9294fc0c9682c53537112b056537dbf7bf2e6d752d349a679f0a021585863183dc88d5f02faed84cfeeda1fcbbe2899e2cb38098b5d815d408bb03d3b8b5a6052841f0eac59b9914e783ad42ca8577caed35c3eb485be09b41c43d08fe53acc92b763a1fed1f8a453de2556860c3b521adf769252364068ed6b730789fa7a0a66fdc475a61e1a93c0b8046e4b6bd11aa54726faa50ad02f00936eea76063a81c2a22e2350dea6d6d595fa30916d7f1e80ab7fe82c21336cbc289e3c5e08a6c3f2e0d7426ab58e2b6b953040a60bd8376710b639f5408dcbcdd1ecdb3501a3564ff3beee3a5d7ba0a6758bca2dc81231e0233217306e6283071a93875903b49955ecead296480b233d18fd9e90dc1c06dc621c1e1e37c8f6d7bea717f5a48cebeec09a7cf974ad3eebdf259f9731ffcfc732855afe4217b9190d7473185ec11bcb2e56a42cf4d57932b7a5fbe4fe0900e4e1c0afd7ddd3886e4564d801d9bc023ac63181ee9f913a0c6e013c317474340e8fce98d6e10837a197e636f782fed760c1d21bcbc473f8a18e12243a15aa9bc69124080c97095f74544a121e55fcf38c4de25e97d7f9ac047f3927910d770dcf00d0df614e5d3aa0537dc4b695525805eb702025228c0cadd5f7bec55e0aa4b6b64d4ab14c6e41ed9771f07b6fa135764ab2585988bcee7ff00f6d4451ff7f4ea4578244f5a848d496cd4ee1dc9d14d4b6109be34551b7d781d92058c43b8f700ce53611df569fcc1f615479b6b31dac4a62899897dbd3d066095a32aefaea928bbd9ba5e367406dd8359b9ed0c1a8c15ace934c229b0e8f0281671b316184261549211124506650e851c03036b1ea8c858c428de10ae205115a1cee0a593d4e37ef14eef1582caf7a8a96c52291772ba28a51b5df6ed897527aa45ee514a6641fd3afeb29a390247d9ff9a3b79599ec9b38301b50ca505f8e5bc9db5a69397e36a663db6524bfe555e9ee726bffce6352a8877ee90a17ed44da4f4028892ddb5b9ac9073635a79c7a04a62ba8d3a196654e07ee37fecd2d94a4bcc10c81923b420d8bb30aa0cab28f384d2e4433214219d123c72474c1e8cf8203d9ae303a22a5d0c7c8a29cccd9e357e8711dce9d01628d59a5f1019a24c518c02865ae754996d5877c66ee5b9b8128314485706ce39a8a59f62198088ff674c9db5304feadefddc6a53ff5753855e1743124bae4215dc1df5786896e80330cd8205ba3921a1f7800b16049dd546ba937b7b1b06e0d92f4e496c2e5cfe16eb2de57032cdaa0c92840d04e98c5c58a05821d4d29b6370000bc76c7bc9a303d4aa336b6798b0dd11480d6916f8c164502c38a598bec0a4560a6b7ed4dd5fe37343951320dced3e2af9c44665ab358d9dd4466d9abc90e06b32119e3ef818a82536be931c2c1bee502b4ec8d0293c78c5e78707d370b2495f52c60149a5de65c05897e1db3aa52fae888a47bea337539644803957c5ecc7969473270fe7ca7022678b75e6447e7753b296166e8c0c0288aa5dcbae9718ef1003f5b850bc0e09af26ace3b98d6c94e5e6c3b31724f87091d8f9ff2d1892afdcf6f28f44b0a4fb1cb96e8f9671c840c20a00eabf249c1b2e4719f03d3ff9216616e617eee4eeea27dad466666b181fbd87a26a0b9acfb943b803a80ca30125506721cabfe288e8defa16688228a8e977273afbeb419d400ce206614c5052b257976b522809d31aad04771a44ef1235c3eb4022135ba7393fb944ee74f767f899b392605a93a7b2c1d6ed32ab85699afa22194e6c840b680acd09170a72357f7716cd9ea73dfe565a6146de9384834c24d60a176df7ff0e7b1fd2a2d7272a7bbb47936f108cf377e0c157eb8ae1a27278d613ae701dca901e1a567bbf152845744d0c5df4e370013e3dff3c91aa8d91088d25a3adff19d341e0423d33117bacd8ac2d3b7c5ec8576c8e6008227ca1bc9c645bfb190970d69b54b11993041dfefeaaba69ef6f988e71f4512502626b07201d364c84d56c90fc3f619a9b24b00f2d19eef175fb6c7c9db3703019e000c10c5ea0be93c3699fc5b94a283ba89e13f2b5a8afb2a3af5853d5070ffe843a1e9caabd8f2e3509da9316711ce0d398dcc19c3ad271ad5cc3475b5c11107f739ef604550391d957d662fe4a50e34726a73fbe47120a1e247b545e8def59e39976046985750e79abf9b4c5477cd508286e1011c309539850ba6c9520bc109b265b6302a0b170a0bc35f4f59ac0244cd82370abafd888d4ec14f56e502d53ef24c03f30793c010daaada864dc5aa204bd4a30b7b243ff1152533a945bc4836f89cf813e10fef31c07b5b7d0dacd43ccbea61880c8bc35c5f0b4f5e59630a8f1aeb822febd9320285119d72f15ffbaeb11a4324331e2ce0a9347af1e9101209f680e00fabaa0b4645a4e04ceab5e373e54acaff45d57717d929c69cc0c14fa55abbbe0312b563e829e464aaf3d6635ca1cd3b2d2de4a39e79efe3f55b847fd947c36a13447afd162213f1edc32e61caed08ba90a20b5e6da074b74a2621a0eb29e6541db16ab48534b772cad16738898bdfd3e842b890a6369c79b399f730a6507b4087d1c5eaffa76078fa59623b9aa813db321c290032deab6718561743f2eeb1853ed0315344a00ab4a423c8cecd8d146b1535ed25c0a9ac2d15cc31142e7ed4cb4151a6dee7a89c36cdc3dda901a771b5d23654f2fb767d2819d72d20c37795e493fbef4f9add9c6aaaf9103a6c179633a0c10d7b176b265ad039a53e0e4cc37057a2aec74f6061e2b3ec963f18aa9b0c74327c9c80a1afbf5cc133c2e890ade8ec574fe1001752d77b49e83ae1982e88f0516961b742e0d5044a4aa62db5eee43b47da06be9839efbb397d0bdd8a174e4ddd364e5a42d54b15dab354199c7058f06817686f30a907385fbb0ae55d72e44564ae994bf3d9782d1483d2180633772d4bc2d742488b5eaaa7fba0027c3460ad5b487be964988395d633cc33a7f3f94eeefb22db89413618f0502b875abe51a563b8950aefb3f57c4bd270ef316d762b7d7ab329e93a19a5dfd506ec63d200ae5a63d6e02d985611481c64ba2613238deddfe28f1eb0b2956934395b06c5a61c1bdfeb857736a3fefab01756d581a4cd30b136f763f6cdf2569456f4e04439f20fe90c1485031132a9552fcad82a3899445923a5edee0307867e96ec2e7541d3b5897b0de141b01703a312e0c2a543d9e50df7434fde4857117dd54a436845d57a7ead81f89e54ed113903277db3bdc2a233deda93ad255f118748b2ff4c9b8e190aeec224a0b0ec9c8e3aca01beca1f3435584fcb9dc421c808410f17601c3c4622cc40e481dcbedd3a18f464794159791bfd98168fcf5e7c9a2fe2a88cd955f853d0a690e4b53095c1b83fe1f72d918431b218f9f94f900bc624bf65f6e2a5180f95bc259802aabbf352c83a2a2cf586b3d4cd2a5282cbc2c96aa5f402954d7db7224c611a442429c39d33b0b6c4f57f077afb388b46d666d8a9290cddf9df890856b65c71ef967e03d316ba7301edeb98276a745b202e45e1eecc6ca12e68804626431a4de55328eae00dc317887a8d28a234beb74a7cd19650fd06da3ae4d006c0e850f09eec6d2d5549e46f0180a21e6ce0c8d997e327787723caf2e3e346b23a9d309f0f16e370ff47e43580429d0888ba247ea44a034f1a7a9588982170130c0c03edc250f928f669734fb7c1e90bebab943662ee26c2344357632e7aacd0cfa5d47c512edbdfb70cdd173aac1e70427c81f74970889e79110b91d80c3d6440f49bae8b98afa20a27ca8fefa46baa837ff42a94f952f15342798e8ff3f9fc773899dc29a00336144d71bf7854ba10142ee4060303af38e77a3e5d3b0832ee792228e2c707b03edb572382678c336979426834a5d1b55298f91296e9cdec3e6cefecd6c0f43d9308b54ab9c5719fc0d9062eca721844d4f6eb6fea7e959d720a06d48100c4620a3274615178b1b4a4d7b53d713f0139b51a02cb46c1488b587051cbcd70cad1674047382e9234828ff8b460d5e15e194498abe6e51143f6516eb11859e6c8e8e8dbee3c976ec28e408d81c9a5d390a75e5a5e2b06fbfee77d4d380ece5015ff9e0d4b9154d3160f627fe2bd847fd1298ec42eefb6d029e91cd7f2060f08270a56b6c04bcac807ea68e3537b2c4d0f1d4ae41d0370089554c840b586e59cadc9594dfe893119d0acaf1bfc1f65b83392ccdf8f1b847644c04b4d6ad7fd5d4ce17989dac28253b6e2f3232883f2d8ccc30581a68a5c21c1b10bb1c93a8936a55fbea790fb8aa7a1b8a5f31c1e39e040d2c5b457b67c3bf7e4870f4677f4a19c58fdd3a6c82da9929b4ad5484d34d8219db0c9a4cbf5a606232c40a137fb50e0c2c85488b1430c5b39f72674c12276e356a270cdfbec9fa705fa874653a611ed8e245c7ccf69f9d1454faa1c3dd1d6a94397de4c79d2f0902f3a5262a16274edffcc87b631b3948cd4cc2947542cae2104d86ac5f896115c782a00ee4a89177da304ea6ee50ba0aad21c80c5c34f787ca23e1003fba884d2625b3a4bee767a0f10b2747ca10dc81777d797312079718ec227476d6550449152b3daa840d252f6f5b10e82f25bc9c17ed61e1bce605eb46ce8758abe9f0dd3911b66b212f1390d0506d2c11857bab27525b5272a5a4b95a0357ae5f0d2c4a8350b2e8042d740519fbc09de395c010ee6b4e22755e694ad5df71b09b033b765aa3b22d527eecec48cfb47e39097770a09141e36e45d12736344e32ad630361134448d3b126e990337d485f2279f0fca461c0fad128f530fc15f8b923ce006407785fdfe2a06d5f4194e016d6f3c57cd5ac661ec10a9a6a8f7ed9f69272d136376b182fdf60abc24f497116f4d572a1b636f9eb7e026ef184484e35a07eab254173a83fbe147312c6106a646d9ece9d448e440045e1def6f90b74466721029b409240a849e98ae9646342e3ad809641e74ff6c92eab02023255043d1f0e0e67168acb766272c1506bc14e2164b4ca7101ca09d33b6c3361ce6c2592526bd50990ee93235853096f573040e6daa11fe543f02558e453fee17af8c669890778e7b2c887b3ca9af3f419347050bdd07088063703ba12c100239ed2e9d56c1ee7d00a832a0b5713e5c0f2f45fd227757aafdd15938fde3bc5b417880b7e49c89eeb35a46a68d94468f7249077eb55d1b9a39db78d86de774aed3e3e7b574e61363daffb5bbfcc7dbb1f049b3aa9e1949dd566bf9d31c9ebfecf8b1c2fd5a66253f62d554c874cddf04a4e879f30f0428b6b9990b36d68f1314dbf3d1070c1ea71745330e60fbeb19ce7f9583de72b7cbb76d79b00991072505162a4c4eb6d70444ca030b88416de653057f9f1c6e1df800e13ef3d456c6ce9eaf825faaad51d7031f2a06f51d23f475e89a6621ed9c2d6a9c38998ac10d1fe344e90a106e41843d1176883a62d35dd119102fc7428eb9baccfe4a786dc0364c5920501a97e176d7316969f876f6739c4cbfab26e1251cf021cb1dc48bfaebc7c2a1661e27221c05315d1f41220f8c2835dd4bcc4b78567bea10c8ba4090021bc650db5232ac295337e7d40d43896e5d733f5fd8d95117c707a8d5c662681f4f3bb9bfc143d06a2d248108fef9506536d4cd3980881ca12035c8604f2f32161027ce85c4f7507f0873e2e7ae53bef9467828504d4e3675b22909502c79bc87394d48cb7bb209d60dfa89234ebd8eb3772631f80f01c85790db234ef58808313f398ae307c6f045a3f1ebab74bc9d09339e7770b569e744937bc2763cc4d6636d3bc682573ef2b996d96fd699dc7cda1c7c6ee590c6366666636cca774c5156e6813420e5816906a7a41701fa0dca1419b42d543b2695d649ff95f67ba61807f370200635939b47dd3c23f4ce54b1e5c2e155e9496418e240f31c7b2462efbb7579e897432e4a1664e357374a246216ab4426f97827616306dff2c7153692b3a8f433e40dd47ac317836e98ab48158b0daf241273c5b1998eff9c2728ba6575a8de0d4e5506ed77fa35c0cb61e4f899c3888eb247b615ef28ad104820a97474f8d5b2c430c2560f68b9e27b8411fe0fb85496d3c5b508c7828d3c3a536412607372ee4ff630671c31047b250640e72ed825d012aacabc7950998774a54156f78dafe42781fb9a8ba666fb8c4ae8a4f6de0e43508321dbb0e0a243669528246c8cfe34f41c9e1f11295c46ed444e1825b8a076b0ef8376b6d321ae0bae95d83ee51f95336304fe008fd93f82b58b36cbd5f822dff0c78d63cf1eb2d40e9d4aa7f365aa688f6072bb28f2643fa25816012b3d328a1f24e638e4c016f43e31856744d88586d60ab2c6072f897fdc64f9f3bb1850bf400f4a378dc6bc46833dc661b1e586a0a869c826b54d5dfb1d7c2c9f2a21bdc44792ae0dbfd8ac8095f69b919d4f58060a2e88f988ab14871c0cd63f0efd42403d717cdac51f26443a69e1933386744ec296d79562831dddbcfa541b5726ce8eb1b64cf3ad9b35cce735e90ee36865fd75c97e4abe6aec350fd9e043835ab4b026857d392d8b09cb41d5a4cc9a35346f52abd1d989a9bb0d62829e6cc4ae43ad77095de51a73fdb46afae55203c86bc182cf1e1f22981e93851ee4e88e1b9a7ca2ca8d1faf6a9576bf6547b6e63d40f188b1c52c48ac51d7c215ba3fc77c5070790c41a409a2541979493c9320b851a44767df89a11912e661a85acc95f226283ae522b6ae63592fb868b6b74a622d80e80e96d4d9663eb78ed2a40b2d824a4acd9540db9a81c3831b0a06aaef679994d5f2e10c4d71264b7d41e3d9c67035789034f91c479d5410df09ac25deab0238987124a67770e26ce4a54e42352334fb10c9ccf3a7d0b00c34f3a2e75fcf1e00e52678fc3210c6228fb8e510a0318075a6c0082fa8b8ce72ed2a54fd8904734f199c77ec18d217a34d1a225c2e8c682a60599f0aa0af2649974306992da04e251559a4e7382f1fd3d8a4ac6370e46c20abaf6099d2d84016e9f2e7ad6b5cff332fbf7abeed81798cfefdf44f2cc700e6f62ccd5a2006922ff8461dd0d892630f3709aae03f3b36daa95e53b4b196ceb21ad33f81ef200c2e57b83664e44279bc9f4fdfeb5e6fc92f408298ebfc144551ef4304019ba7b583111f9c30ec66082de8bc081b90ac28d273857f285e61aa311ee13b676c4961a28d3f102b41be004d188ebbd6ff37feafa90bec272ceb2e1ec33a0099770c744416d9e5341c1ccfc1a588b6a8ed54fa65e78466ec6995df8db07a0d1e44a801adf1a85fb14b19d30befa0cd0bda14357ce81536c29445604f3775831e43504717de0ae52972832c8820d74611b1a2bf0ea6483dcad463f2d0adb56d6a45b6c4281e32c715e9709edbfa7089629dc2dcf70b4949632ef32dd77f1245a60c9c48b161fad4c855ede1c7ac0604324da651c362a776bde28fabcdbd30c5108855420f776d40b10c9d5dae25c1ba3889f8cdcd54dac626df8064bdf56e765519d82faf2bd9124f804a58b2fb0fec80bda3bc0ec798848dae2621a1339a1bc2802a628f5259cf00ac225f6ab086b6786278532562970502f380d49b3954da170581d96b3bd1f79d34afe3886eb49d9ff2287f1b5f94691089d46fa9587799e8718ee1789515ea918f42f8b11bbed6a10451ebda1d12be87cc40b3582971c9596df7827b1a32fd45f3d479967ddc34d3370f8e12b0c43f5e6d49a87b2596c20a6f47a4612bee31ac43da2f96ec073ac1da3bc56b731fd774d3f822008ed3969df670b48d7223108c3451d193ff1dfc9de0cb000642a8f188b5550118ea17c95b21f68507e705d6d125a078929fbccef65f63d16e3516e1cbc4e80aa894dd00c2afd388199ab9de1d1e7352d889c8b6d3a637453d0ed844ee3a01ba52fa16a147783217a2029cbe4680d14fa0b5ed0d8058073c18ae9851a603d9fd02b8912ccee92526e75f0c42d89309de25c7a3dcf6c3801de6550e908c58537a9e41864310661c61e94672375efcee09389dcdc5f66717c86c744ee8d50940f54c85f2fc9a8ee2824d22b362c507ca4e9b7dbaeb0c80864c58a0d3358310b769153eb580d47913127db0287d75c1e84dda7f1e8adb3c457e010231e23be631a2b806724ca20ed9581920fd857b32ecaeb0a1006774e1816b983bbb29cd0351c6d1373aa10e8923ae9fc94ed108a52fabc4b0c5f1544c59c2e0d4447e50e5db7d8d07024d204d597e0e7ff9a4fc7a9e5b64c171939c21005819fd344ed80529addbcd97083213b8783a0d35328a51954c085bd1fb7416e21e4ec2218a2423634bdcd969cf5a593beb36ce4cb7b0354c6c42d0e4a870332fb0a4b6da29f5fc4bb5ff2a6c355ba6825addfeb60bc0c287e97e6c951cb19be1371a419e5bac0b9bfc3f28690afc62aefd0e9f18b04dfad528291efee35fb8b4c66fb9bf954b9118f2ce1e1276385855ae0a2267e9f8e665b2c6cee23a5d7b4b9a7d82409c1b1cd2fb1af8f0ca03442e0761c8f4e3ea25e86a46174ee1ebbe84613534f50e4e1ad2b01645d9122082cf84d589198c717c228fff447c95be7b5e558a85e52a2e94c55eea20ead7fb64e565d32b50b7c110bf4b8505bc2f1e07d76b363472db05391359fb902cb97dc265c6cd52727704e6134297bcd346f58d4218dda55f9da213796d347867a569c5105a40ec6f7ccf046aee230a361082874e115264bc25a270cfde7a198052a3c24a6e8e4f40cdfa66e9cc0abc9410fe492b4cf60af66437d5897896d8e5592e86cfc651ba058f8c87d90d4cbf6270f1e46aeeb1c4a3e77847b169b27c339a87b91d66507156f3e87a6331ad5e4e22bc89e3b6416739dff4813680a8d0fd9bf9ff9b52191dd985754f271d4cd9f21becb512408d8531304d380c80da54ab02291326d27c6defc6aa9ed1cbdc51c05cce30238fe112e2f3cc326877d6aeb472b3bea01b9909edf4fc2c16a54d9bde746590652bc643185dc07f3f15347bb2acda8dfe1cae8b9c914d4a3c8e767840c7ffbf0381df9c55ede8ab9298aa18428d5feb46410f388b846ab63da3c946309471f5b0a982686a5988502d6e8f1dc74c08e7ff1bd320bb46e1780776109c2208eb1417dffb95a487597740497726180bbda7dbb831979ea8a51b44d70800022a8b4223fc942327e7c5754739388a7f76d4c397805dd72887c8738756ad7ee74939376a8d49d7cacf858bf0a08a5aa64ca0caf348114b309066c67a6868255465d31554efb2bc42748dd9e69484573a032d9a0c880a90e3e12ad2dcef8ad970d8b04e3eb8bd48e347a658a892c73dca1c9748488ad029173fb7d58b753ba7dc33005f4e8d3e5f3e9e442da81be733bebc9733b95d55ece240f71e891c79a64bb23a8647f0778a845858ff85ea61aa4a926cd5bbbb9d924e76017843c0e35186f0aeb8ae12098c4caf06b2a5331d83006b47d39f6bb84f5add049e7b46c744ead670ffd58a2ccf22a618671783c387bb810662f1957d4e079e2de68f1c421a6ee779019008a2e39814b144a6578d579e121819799201ae4679499b01213c686037a6c28c35d5a1b686f1a623c89191a19358ec71bef62f6a04c4fb52b9e1399aeca00d993a5677e3d460200cc2372ef0dfb911543e44165453f1f23f6b787dd77772c9734a80443aee6a300da711e271c9d70960df3ba5f5817321da3d434d6c1313365f709340946ebd6b458a061b6eb73eb91459b00ffdc300bcbca89a16068d22d3e910624543c395fa9b28416518f4acb060ecf8cda51427c5f15b8a63f1c0262cee1e8a7ed95d7264b5f43170ada9ef062fa6a3f3bbe428ac9b42bab5bb8c6fdff66310611422fb262f6c5e1c9bea9a2b3a45c6b1dd8ebaab36ccca1a99d75f82fe1d1bce7c1c283ccc3db84842ccaa34245d895d7f67fb379cfd6613226ee557a368cd37974f8eed68e8be29321ec737d5b524c1e73a25f64f1589679b2ad1318d6dd2d825d27e5abf1dfb89b8587bc288d5015315f5a54e28041e73749d522a92db017d75e1475979b91da947d821b21723f3db9295671fae647e0309611ebea3620bb31d7f0aebd4655df43ac39515daa521dc14f926a59a5177e338b6f2a38a4459581af11b73f58b9cb2e7b05797343ed813bab7d56b4576d41f3bde6e27f6b9ebcbad079f650b66dda0518f4b2c86db180d81e8b5eaac61da76509846def8b79d8b64b12a4e735c16af521cec3ad27b15cf44e82c46012ead88bf4485c5b60fa94110f14b54f12c21c3ad3e7114782a589e79025562d2ef3a5d33cdaf40ced8c094d900824663e18ae84263c07840536c220a17d5c43a6e85fd2cc1462bf1bc690f48c273bb01b4505a8da50464523e594c34734edd07e31e8f93163955c7ca056a1f223d174272c59725bf2a6ca33084abbb765355a19f9839c3d6d87f7ff2acc55a79552b52211d1acc5017429875516336307e3fa8fbbe2cee7a817f2c1aae411eeef09ac0a4ef27b4ffa4cf3a58ddf9037fe984af5d78ada657a779e3eb3ee20aa910e1ab38681b03e1ec76e7613af7ef9ba47350265158fb494687f2cc55bb6a2d67e0b53a334bf585243e13af5c2452c5e0d2eb6aea38cd91c4275ac567f8ac729d47c61335cdb6bbc4317e9679436e5bba709654e49d96763063ffc58282a4fe1883e4a7046913bd508344e2e4a2bf6f6b62f6ab44c099d8948988d3c214179389f9bf2d43a42c5ac20ebba0d56865a292f1ff3c93d178df2ad6b311021af1c2d871aeaf2ea40b1768c0ff3cab3da038b08a45e1019ff77699096470c044a48d727bcb7182193401574558fe58b61b56c7ba3585a3f4400c4720206ab3b0570e881637a0ecb05885458c5cfd7929e13ca5a14951b18982e92945e1579a6ae36884547c38e0ce353195ec03e374e07f65dbde85b2e8f174a0603a579e2132496c52466d1125b30e68afe2d96b546135cfedb8adf98e8e882f2d5245939ca446df3985394ef080dc324ab9eb061d30873734f572e922d3abb2faa370f4fa27d59b1362fe09a9494d1c1f015120e0219a610c8a582b160178c142eda3d49e2f3e44eda428ffdb546b7af3b13aae2e80822c3752c041a3932aa0bf2e94492939a6cf95961328a6450beae94aa1bf0b5effb754c98cc1cf492edca4859c5f4b26fea5cabc9692c8dab6308091691426542c378737db809e28da8cc34a699b75427a76e2f2e6493c1958a35fb75665b9efa57297b107468c987c12031b34fd6b47084b59f553e9833bd42c957faa1125fd1981e644fb2e738d30dad10c473949dcbfe1d3855c3f0a32a2268b990c7443ce0c3817ffe1d0df8c74428ef154f0f904af5799954bcf60d85137fccf076e31124610f80cfc1131cf42225945f469c878573509c0702920cbd0e1ee56ea69a7d490580e0aee677ef78eb05020282e97c7b2548856e825c67f0c35fb6185c23da3777acc48636401519f28c93c93b875e8c09ca28d092315189624c1deebe190746df0fe88082551b308c6303a3417ed682c9f1716b94adc72b80787f0697a4062e6f891b0701a7a1ea5e5bd66c9baeac354de33ac65e0d995e98d91fc98d79c350e29659dd93c7c1ffaa83c0dd5e70312da0137d228abc1f074fdc606caea84071a0d1cb0869d705137135746e68c05260471ee501b31bdb490e6cb7d6a170a87274cf30003d1262642c2372fde55b048486d2dcacaecf8cb280fcb530a3074bfba8b8e823ba41600428cf91605641879aa3d1622b5be95b98751166a27011f6debb0803dda2305dc5c3120986da95839ed014d2fbbbc92466991ab207ffea54f17231cb2fac40d9682c2e1df2f48417e11feb2679f20465b474202cba751a60afe8651da7f84d118e50b4d38f275aecdf2ef7fd89022e3968074dbd00d14e23ac3c533a82c1daeec2ad0a729c0ab65c5c0375c0234fa9d0cfe4b4a89c8e3e20cc522b18c73c56d62638b19cbc7f3a0b5d03b108fd1b912e0c5458b14f3cb6bc49cf6158a035a77cd38af323618f5c08311d77298ea4324f08266a6c561c0a0188136c4f47b16ea3603648432f45764eec0b090b0ba6fe03bdb057e1474e6cb369fa78a2ee484a13aa2bcb88452d7977b4fdca0d28829ed07f09d3177fba494240d11bf0433cbaded6ace02fd2d0e7303f0634a00ed92a6377e48b14a0483d560bb94ab55a4adaf5a34e2338483cb14440e9f8c9b172d52d59f31aee3f7b73f1f714048fe511e496c8550e06a700ade3b983a0b426d5cf4f6e29746893c8717946c88f5249005a271637ead003df1b2cd41f41b08dae54c00d2d4d8f42a3b100aed136485b260844d9927126265f7a1f05d301499df38d4a003d27a22e4ab0f382b559f66a87624ded8aa84e7e623730f26da39f20075f6231852f8f1004b1cc032395bfc362aa9c067209ff305ef02d2c6644579a9664781a903c2a45621d8ed70839ab84f3e9a952293fa5e82915dabf83f07de1ce2652e0b5506cfb20f1d0648ea33180f477c69e451a7b58856312409bea0f6e2274e65dae8420d8bdc060adceb745251edc9fa068ae23006276eb161b7098a5432fc9d81e81b0ca498b24820e5b53704462a4a655c0146540ca16009db6b9c5af9b52d23b05752d548596c60834878fe92e070fbb5daac7ada19a6564d4fcde160b013f20ab5786d29ccb5d05ec4d1a10368c2ca362b935d5b2aeb19ca10120f34403efbf78b6f425070ecfe16ddbb993dcb5519adc999da7da9a7e3dde8c2cb9dea2fe843377c538dac473e6c06f812ec5314376ce44fd69b872ce849ae27273c392a5965a03674da7580a229b73263d4b7f48bbff652cbb78b6e69cf9e0ccc71363af5a23a084c6effd28e59ed35dd98ecca00e2c3f866a7a692665d3f89899d95e8ec7657a7955f4498dc06e62a4687655cd99c119b468e804b0307ac311e44aa3b007e680098e1f1f24d4c8dd9fafb3676a45212d7986a5e2cd3310c09ec7daaccac3590c8a3677ce9c10e20801d47294dc0d74da03b6fc0bf6bc22e6cf576d1ce6d25c9cff9c2369dcbc99732c72dfbeb7fe361fbfe4b2c4a11f8fc51ff74f4e4cb51c428c0133020a005bc4e94807c27f921a0c8e82b8154fb2df29c56aa6ced8abfa6439b8d02d55d3fb5b4f381eba5f3f536573c7060849301f96ab71dd6cb24f59ee5103ecb2c426803595d3ede6979f9161a9d7c2aee61463857b7f79da891926eda4b73b87d794c9c6be9f449ff19141cf65b29d4e93b39c77cd4358dbc4cf6b4d517cc52b61382f91ab660195aa7a87a4a28926b3237ac437c7b9502c91e17bcde2a847e4d19b0a63f603da66dbd57ac7c11c74ae130db409f89e336cc4d86bfcb63bb3f062b255c54cd7d6356656dbb3c77997c32b36b126343eebcf0ebe2762ddcbfa9ed03166a55144d630970207dbacdc3d072172b9feac02046e8ee44ad24d3caccd7fe2491cf998c16061c78819e45952a040e1d1a17e56e8661cdd292a7b6ca1c27a475d1e0850512388f29063d46ac41f2347ad28ca1f4129104685b2703c07dbe18553a8225655971bf1fa2185b414fd12ab568ea40af9831639ac47532a31c62e9f2c967eeb4290c44de9ceb868fac83a15e4b8e5125163c4bcf6fb7ef57554d65dac7da1c15a03a4a981c476086c201919aadb3931f35609cafd067ca20fbf98879713a0c87fcb299d710060c274cd3da7f0a4f16611cfd6873c429e504474b25c65cee202c2779de260b7c42d202609125f4a9b6ffff35b97f2c3c21fc08ad1523dbdf64bbf65a937ae8729371c039b59a97c0ece0c438c2efecfcfaa941f96e0802a464ab1f4fa931d03ce0c07040e0c03f33da93132116f6ecc5dfb9fdf9a94272ce8802a9414324f47e6c14617fea724e5cad009c310fa03073f5e46c3d218a9c7cd5f5c94adf2d12f26023c70f70131e2c2be3e2a3b8f73a62123ff1f9871f9e7be742747d5f8825d5c29868c6a5745ba28a55d7aba30fe2caab02f4ab7638107e4cd629aca00a87abe0b5b81a86ee00b7f5d577a38b2581b1ef34ab46c47e3c62a4fef2cc02977549bb691b55619ea0d80c6ec46814a159aae992d400ad34ca3f5d719ce9b97f61a0186be9ac02700494bf4e0acb11ab2cb4d833b76060475e49600c3a30df85d221107f8c3ab0e485e02f41907a1be6cc627e90974060c54c7928dc3b5b07c040823864549c52d100acd95263c0f78405389802256be0f66d36d0a78a608d909b4236a5f59ff1382fbd2b7fd5c5bb6d1586dd9399ec46b415f6330b2bd9b83c2ee55dc045759223f394a1974dcca9bf72ce36ab44f7f0671f894c47b836c4819b6fc47916d9d20de9a727d8342682d80d22e2ec2ef56afef612ccd31eaff59cb6c451c5c2985c50e836b65d1e22e05513bcf83be4f9d9cb44fa54859d38007174068f305513f2e00d43cab5abfb108c16e39c41f6cd19d2ac91970867433db8e17be369ee72671a052ae556f8466aae55ae132d5b939b7c2848a6c884fc50cba5ff01a7e942355f825d8340bf000b202c2be17de0cf0bebac8b3f6dedd69c0640a7a8118a823210440739526302cb9c47706f50dce50934dcf4e5cff93c5e8b9043c6d9d9c18ee15e8431b4f12753f2557882fa29fb4e80d72d8db86877e4e17bb135f62fbb3fcf9539b0307ba32d1fdb14d561a464dde926e626261c9c63608303157b68143136213dbb413fb2d347e396f2f048c2be045b059c60dbb255171dce29e764bf8e961d12c4efd4d83365eeee69ca83635d7bdf185ca86af01fe972df4ee0ebf7fe2c84a98cd2d52994131ffbd34b39d8e5beb60312312743946e10dbfbd44c0aec1412fe265fd0a65743c52366c4989bdde2dba576777ce939bd132a6128cba211076a45c070b5f918942b7d5e0b9cfec2695eb6f8ef4cb36f98ffc4faef6a661a64787d9a9f2299d0f4003d375a29d527259a539292337adf7e389415ba9f73135e8416c589ce0477dd9bc5bfa92d3808fb5bcef1284ee3082c53efd4b3bfd2feeb99817637b8857f14a80dab7840ed30ab4584c087887806940d1e3d8e86201e9e97112cc9c7c110ccfda590bd825742733f437b9888f068a70fc23efbdb950930ab81f9992c341c47b73638827e0ee4cece8e3a1ad1a63414e0e854143102ea69dfd75ca1741496ef2bc9408541e1ad6f6e58b93217a3ca8541dbf4585e282b4b277e7154b9b805c43b33bee0468a650914f324feffca65063107d770b5f3e87fc931550b2918af665cc91d180b2f51910b969b2ac50562c16996c9fa0a160c22a19ad734759747afe6cce98b9ce9807b07601fd8fb05c51f4c55f46f2fc31bff122e712e51f4d5e25cf58b52d07e6a9e51cf1c1c28803d4a330bbc883a08d3840fbedbad55a1f0e4a89c25f42cdc8cf3a4a862eda5c0cdea2ba741e00c31f218c94231c64d475ff24038b85a09dbab0692342cb30685a5618a3eb5fa322e613b896aa3b90c9a57ac0ed2adcf4ac64a71132223222e5904a8cb391f1e1f297da3287cc276a054a4fa0cb2e24a1166f2be2ead1d03a55b84e49dd283c387f91c0528166dacc5231263173c48c6ddadc01f0e8aaa79dd00a2ac9c05ba432c2057ca72b9d51fda11038fbaf546d558ef17465bd32fa4dc1484e63006ae48b113c60c6a5f0a440af934349506a7b57e6c002493214713ef762b9b0c4dbe15f63115aaef3af893abb55591063996f41fce58167b74a303b0d5df7780d12d558ddd0ea7696b8bcb509b78e1bd8fa9302a5ba3943fa28d9ed46234e8c621174829e22c835e3fd34515e5e55d2b65a4075235543d58028c4c74a64f28491cb38ee45617fee85984c42776829f537c0be85b234974f6a3e8e7d613c0015b817eabf2ba2fdb93262bcd16f443c0ede0078550b362e849f31c4d7a3fe6420b6182177634c1dd57f3aa998a01651bfe33b0b81fc7a18c48515870c1a1ae88b4158b41b5244f89dd9b5159237a8123be905a36e8b40e5a1705ce35fb74df9f8919e1132b2fcef2458f05171082a0327818affad2fa20d0bce082b0305728a008c03a5990a1ba9b6bcea0792889c1d62c2890f4042330bc71a81c19be930b9faae1356287928f2351867c811ec40c82fcfe44ab8e5f94901edab3889cdeea6c9aeecfd5506af9e849d2f79cc765952fd6cbe79d9588ae3bb33b1ad6df653e0e9086d6a3dcb84fb6f2dc9a8637996684518f43e2672995b6424c0936a95b3e3dde2669353de7a2d140923018a452efc8e2f4c1fb4b6bfbea0150c701788c07600cc1442f73586dda14054a97bc2fa5b881d9014d8aa4971fa487da281e617020c0b68d4e2c48bb381965b63c5e0a695d5c58d0671cc496e430c787104e6fba2fe6f29d34f3b1fde236579f52ff44ce57f7149d8bdb7ed3f7870428ada5055c921dbb3b466adb907ec6a1b6a990aab0d7ac04e6e6ce6df49eabdaf7ca43b7b1913ca94e8dd1b9401205aa90c4b36822b391329320c9539478c1e071d77e8d011071c3becd8a10e1c39e668393038d7adef08be63c71d39748443c71d3be8808372e0d6a1fc3bccf22a388987f307072ede4a5f8e4df8e2cf5ee527baad4a855f9b59b98f7a82d4cf1756ae2955f16756096d056c75e1f012c1cb93e7d6e271044171d4e2a96d09c04545d23084a3152c267480532930ccaeac78766da09b0aa9159733ed4c092e7bc4e6c2054a1d9f2aca981eee39afa134596875af74774bb8d4ce720b594e5a73d6ac07eeca4a08adcd9a61915b49bb949519663cf0165b85b26ad61963ccd6d451d69d31cb8cbbb1325a2bb366bae456d22e656586190fbcc556a1ac9a75c618b33575947567cc32e36eac8cd6caac992eb95525a83c1a7048b33a1bcc50f975c53ea2710484f4fac26b5b69d5943d2a3f105ecc467fb9e913c3669e39254a7be09664257a951e954720ca3c00de277ae9b976411645e567df59ff5acd045eda356aacd8969bedb64b6c9a756dc5b4ee968bb56cd1ac552bd6fa719451d959f12542f0dae8d7a73b4ae59b87b22701e66a075f90242c2ec653ae791a9d224235fa72ca738273ee7261339b12c2afd6d63092bc9806aee44e00356d86b3772f6569b2e05219310f0872115a38928b10d4dae0e17ef053494dc4c5886c94901ec8213a50ba90a0b39afb1aca722edb1c801b9daa513fce47ab708f90c2aed1380f51b362a19c408cef9e9874b45376036ec1a2f11288c07ebde8948b57a4d2de8c5c019e18db290e1cd28e50123eb0fc2364b962b8745071da645ccc002b69a070c48e080d49601f1cefeff5fac933fcef1073cbb7b33b9a77ed0a83d1eaa8b6316622d4bde0cb1f03153adb0b1f4cf6cfc55d3e9c019112e55b38ac7e79ad21a95f930bcb651c0bbb24528c474aeb49eb00b2ec22fa981d676968a07b14c55cb54728d31e6d130142b838df9ffe0773354ea5816e40c96f5bddb6d0eacab6daa465ec3e911d378ef8d33a746ba2439badbf72dc0dfd020e980ef23496df2a0345b899921f73fe8cd7604be6751d89ece9a2f97bc57929c985633c7c3203f1b5fa81a056f8b952d0cfa80fb73c93a50e626335b61c70c40fc813ac5c1b1b8e68552e05e2e974b36c32add18447b2d2e177b1d14f05f3ed31042e8eb8dd186027b4ac3e2e4edf0d7bb2b2b84f45a5b51d9d1b0f0511bdecb33a88fca40ccf9bd601d2772319555e43858ae9794786a41c85f1ace26db60e4a73da45eca6d70ec50188855603818ee005100c3cef92308b8db5b70f11eb1e0f0ca0dc758992a783c8119affe8b87871040649c5902be2e2e4c860ff47b3f0e1e63bd38d9c40720139bcde1ded593f2bff48333edd8895abc437d7825be87b1976c0d15a813d4f22055293035db3e895038c1c31e143361404714eb59e27aa7813d3d2085f61e18c174c2260689f317ab3d912e5f0dda6e9bbd8985d3401a4059e4e5ba0f496c36008773ef3e4d3e2d298947882372b6b5cba7ee2a2709ee1b1a3672fb4a5a1bb124d4240fc64afbaaca3f0365acc1f8b03ffb723ddf4431bf3e7430b97092c2f7dc31876c101f114c3abc90f4d2f6252ce98149ecc5ed8acd140defa71dd636ca1455be13cb5e9cababc4def79878e231e33ff1d7fa33cdf18befab12f3191839a49dc568e4f3883ebf7b90d9b0b1d63a8b95c5b5b20afb6fa3b0cec9e160773cad9030412343bfb00b5ef33206a03e5d03b661e7ed88613431b2040eed0aefc126997e7336ee124fcdc86cd858e31d45caeadd590575bfd5d0b764fcb8839e56c0c02099a9dcdc16e83f6c40b35061946a6290149643b4578388b4ecfcba63701696bd947ea762ee6861bde1a765ad8f5272463887f756cb8b3e67dd97a5715df29a0e0c5d339a223f3d9d26af0b3b6bdfc5cf5be095eba5a84dd27928140ca026cfdb1065040138038fcc890b0cfb159dff8d76385cef2e880b7091d06da2810da3b9d68e30f4be18b8deb236b5d16918c458422d83c68bd878e9410a2fe3a4a76ca4709e7c62febdd8608748864c5e6a8c87f49e25193061881e7701527d99d4083633f1749b4a6d86baa84ce8bb79a48577b58b8f866b283c566230a3840b26a7150ace4181b8320e06c07bfc1b181cc8439aa33ab0cb9a890238d60a96bab9e0a1d157a152a09f17e4ea331a96ed1e031046450025809b16a26ec3c780a4eb9485aee49549e7a9d2bc505cd06de08b3dd0ee7d9a474bbead9791b69b68b64d0a23dde3b17d9a16bacf56ba96d857b561310c53ac43dae331958f2b2476ba0e0428ce6f3417c19b8258a512175b58fe9c75f79909bbd4ecbf0033479461f63dd19fe943dc395a0d6e5ca99c2b98f5ce3ce4f9f3a60da3ac0696bc84f04634c159501c5515f4eb2b7ec8b0e3091a739a0b8259673959de6cced29d11c561575e34588dba84c7a76665f90decdbc1f9d8d841705ff4a688e0d231ad4ecd6a1e8466744b1b4240a1c2f1fc4cb86e19a0ee2943d448a0a297ea7b27a9e96da16edb608246a4d5d3c1fc8a7a5349aa46163423eb0e15fa8554454d60846a3cf767a340fcd2f0b35b456c44282894150461685fea1cef0ea0f316fdadb6373b7e882e835b7025a236544b84e753d6a8c1abf1a60940dbf970be16f8cf7b5a67139d8adec08bf3dc1d4afdcce654b21a3ddc8fc4a9741cf9c29322507b176991554ef53a71ba7c6068f1acad74da87a6a47856174631ed7e5a20bb122055ba38eaf43fd69856bbe98d2fba8cb8cf45e649a08c3f767101cc014c46aceb07561c4c04a67a4017995aba4c3790325af2b52cddb4fd990aed8464981ccbe9c4483ffc9f121c579047ae82c9282ab67f83394ca0b2b013c5d010af4dc355770ce61750acc7240ae50e5c6eed0e64552951712ddec19e28f9907ee30612477136af386f61118d7dfb570de7c4c681f1a17cbcbe442e5640ae7627934cce10ecae6a60ee50db66f3adb8ae077af16e826774a726fff1d310353034603bbd91abffc38f9013491ad3faddd27ebb42e0a815ab25104e6c8c69b1841e3436badaf84d45b4a84c494f20daea8dca3b05a62389b43522d3ea7e8c72edbeceeee454bf596369d4f280845d13751c939e77c216eb5eb2cdcbae49c732e06d55b3a241a8fc8f7504cfeeb160114632a525e623a322358a5206f51e99218d7dbbfd8b1ddb54dab893df7fe5ddbb45a4b654282836539f671ec9680792cbb1a42d13ccf6ac2076868beef8e919022393c2e4f366b46f1e60d14026e7c26b97d77f7a757bda5c121d108e2e9f84074adebb60994b4ee09aead75dbaf623173aa4ac22c2feb68df5f4d0a526fa9101152fe208959b2b4c64d388e3c5e3d40215b8df242415b3846476f06a7d06050573713ac8cdad0ca2006f3ffbf4b918434501865e6bddb3e0b93c403bb9510dd21c32b47a7a9882964f4a5e4a4fa78d7366def7ffd9b2ddf61fcd4bebfceffff1fa0cd9cdb2521c396bd01f5c13313beaa6214a198f8ca5131817ccfeeee6e347c71eebcb603b1a123693161a59c734671aab7f409fd0f28d1dc1bfc0f29c3e4c7bc20cbf250396041e15ddbb4bd8bf07b767777a42c249c7b4fe7eebe33a1213a24472867e3c50b628e0b0a510dbe6727e672391c77777777f7202e45a2f1c4b907714076e7f9406f79efd96b3877770722aab7d4a839001db5f6271c9c3bace52ac6d58f7a25963688745f6cd88d301d399ad1e5ee633f50398ee4cca880445afa1191437d91c15ddbb4bd995eb6e9459a59bbd62517311185a42a2c9f2a1f8f9755c60739b2e433f4734b5c9beb2ae97a9a58aca666347d718506a31f2490e5a91f8447166fd9658097845112381fedd004dd4d582da26b83dd12d7e6ba0e5cd15a6b2049f5962a974de7f30408d42b70cf2f7067edc0427304deb54ddbfb573282918f530b41bc1c434b30a6b2dcfcfeffffcc1d1edc7fd631710861884168bdce05efdaa6edbdc232a237e3e07b76b5c5dddddddd3d884b959ac4e02f75bab2345592daad2e40b28ebc5ddbb49deeffbc5c89b95c4e664d9734904b66d48b5fce90231f4515d8e8124b2fbb62964400843a939503ab36b304cd8a22b49195861d58402c79027ee1220691e97892e1f3b58b8699392504b24d5b62ef481ccdf07bee6469ebdaa22accc2ad8fdd1a6e11b78c5bc72de456d24ddc8133eeee24c434ce4ee3c01a27d6383425232e30d6955b3ac4c6c7552583a9b5d33484daf9704319c673e7fdb825aecd759943ddcb4fadb5f6edd45b0ac734451e10bea09c73ce334cf5964a5165759dcc889dd0ec5ae5114f1844e697ecc17a1159660c3073d0d3c00a9c94183c3830ef4e366ab1b5c23291c31eafdfb3bbbb3ff5732765815dd05299624083d05411244c4d5490cce869986293dfffffff6f2cc5b890915b41d972c29b8246997fe55aa429168b3cc5a0a25091a88854646a560928eb55aa9135dbd1b0f1003272411f71244e73ec4312791ec1c4258466bc51878ff7eceeee4c285e9c7bf03dbbbbbbd18c13e7ce33519fef7a4bdb15b7c4b5b9ee9531c32c1c81abec98e80549015271e532637be0947307823005757757712084ef7d72090af311c3062a2689e297fdff3fb9ded20c9c7573ce43e0213bdffb493e7c21592e930b38764ca86b6b63e085e6d18326b2851d764b5c9beb12d9620f98bec1f596b659a78265310192e20aa9eae7ad1a3e65bc8899c96514a2ac788ebef0aa6924516e4c315b286dc9744f392ec664f411926819ffabbef5c4c9b80e69261ed30a0cd06ddf3f5725d55baa5c660e554dd7b9e00c9390fd40babbf3dc6cb5536f291ceb132b1aad81447cc35313fefff7b9998318d0dcfef37c81102dc6863a44468071d9d440aeb04a61ec040f32c566e728c4696cd8d5530ca291330386870ab6e20945e5e55f07f724393c1e8ec35ff332a5ab088bd34d915a109d56bf3361c38eac6b6bc788ebbfecdf2d716d25399bb43d77f7a41a1a9c3b2cab81758ddc32153b7ef944249d6822a1313d323306486fa6f4815f1519083da22dd39d791585553c4392a8de5263e6903cd60280ea322cd3911bea04800a0bf2518304588f1d3771115186020d4ec0e44a70d960690153ae40116080686c5ac134d9fc40be2c19309bd1110ad205f463e1844b8b1b0818f05a19723c423da990fd789249326aad354b53bda5ce27d4034b34e701f8aeed0666d2bdf5e9a6640a366af6fbffefad37c6a06cd8cd1ab6407ae4e55cf9cdb8d0ca11c118cd84181ab934c1a69c463f6c58cb2b513d97ee3f7548f4dd5f49885c386106754b9cedf45a1ea9c771a8b523f366b311ddc731eb04a3f9822175aa01cf02459c197ebb756678d7366d6fd7efd95b9d5b92ea2d55b61d5a96bb16c248840550aa0b860dd205fe2970fe42585860435081e637b10e25730f28c011fc6cd7a312523e7777f7b8c697c117ad91c5c1f596b62f3976b76b9bb61d8ed16affff4f51aab774d9747e90f2f4921b37d3188b6ac75a66c2ac20502df4cceccc3499c68c18728c6e896b735d1d31b3fcffbf2a12a45e51ad183b6ac4dc58a135c3bc514fa6920afc98a4bcb4442075df33d5e399a6ac66b4d65af7bcde13f49ea1f710bdc7e83d47ef417a4f32c984738f73ebeefe434abda554595d1d7e88ed3a54c15fc10a6cddf663fdcb56eb0bf4c05ddbb4bd31ac00b0ccf994002061c7468526a08f538c98b8c5c56d75feff0fa2516f699127731014e4debc0ea9e248584700f4065207e44a41e8e05ddbb4bde1155c7777e5abded2e0507fa0246a1d858348486444c72b16d1b2820aa8a753cc8a698d94a8962bbbb6697bc7231d4c0c77aa663a1440129dd24e13834ec693526f29555617089e18887717ab42761d08817db4708a95814b24b0495334e9da7819feb9b2a45c87a477fb1e4e617f20dd3cd98e3094268aac64ec70295dd860b1462c60a5bb3b8f8010402eaa601848979ca1e342e28576f4d3f56c555fee9085d46dfea924274bc6ffff1ed3d38e16ce3de21bbbdefbff07aecc2fa432e92b6c967da0146559d98b09d22763cf2f6719e6d3028d4c0c7725aa9bb66b9b5693edfd2b091203014530203a3e2b462ec213575f31173cd08d207aabb0686c5878666830069deeeeb323142b091316954284104aa68965450015cdf32034eeee4094989669c8e9be6bdf1febc50a6ea74eb3ac36dca25f1a172e71906a5e1362553f532b869e47096a6473584efcff2fd930e2fe338fe5a9649885d906a7d74bc3221ca524c1403183a973f4a29725fbffb96877241ca872ea0f1ff9c99261bd8481129f2d0f832e25a70b9c17e371a5015de6b480493acbd199cbe55ed4232e352221750c03ba25aecd75571ebc382ebe50311383d34c8704616c0af0a0e9d803babb2fed1071eebed4a38cdbf7d7f9ff7fb9ded256657bff40adb536a2516f6991274808841191bb3bef3dbbbb7b8ee77a4b5bf6cbab60a092fb3c1c5945474bae1b37b61e05ebdc1ded162c2a63d3966dd7a089caa45c6f01adbb7b902cf596767d0822b683e30c7e84e4eb5d5b12a77b5cdfa3891584172873f88efc766dd3f6ce3f150709a2a88c651485081d9c98c705ef02f72fc40264bde00b3c7ce01da11a3122d6236b66246548887ae755ed150b295750e7b925aecd7575bcff7f9f32c33107e36628e377241bf13462e7844c0ac2c5b8c2ed8861924437a42899c2ffff41f70e46a83becb2cb215459c3eeb8c6cc96505fce395329d55bba6c3a9fd00da8a239126954acec11ab2073a28627a6451126299e8f4ccc8acc8e64d218f62ca2a43453d48f180e50345b9ed25b2533072be5762e38c32939e79c6984d45b4a84c494a2cada40d38562b66b9bb6b78f75e69fce9945a2e085988ddde9ce5b89ab556ec5d7dbb54ddb7b85317410b582cc9325684515c49a31a26cd95d31c3da646d7a01bbb65d5e6979b1c97b4871746df091c8c26e896b737d85b58e987a4b77704c53f413238fbb5e79afd65ab740546fa9f1884c9eb4a074770756d07ece39db20a9b794294595d505828dd8575044f8ffaf9273ce5f39f596bec121d178f4f08564c36e9e96d4647c75199e81f550656042dac84e988830861eeba64caf67be20d9a35733f6a3455cabd81234bbb6697b8f2d6742d7bfde0ebe829bc54ce8738189e853b3719622f524d51d0a115b2a502d18797e85d602ebad0fa452503174f0f8111183215b412648cc1fb690d1e77f001b2e7d252f7cceaba98feeeebe96242aa6ded21ddc012cceee6e8d3578f0d414ba2619a880089d1c3b7ec2c246a4d0a79b212c95f79edddd1deb897307aaaf6b6389818ac26f23e9aea991109adc340d64793430674eef6c802e6bccffbf12972a091571ff4a9c056a9bb36fd7366d6f1a361e324052d21328b97b81ba7e5804edc080250cd103244aa80495a36a840a6631035385d09d64ace4ae6351d82e8851c70fa8488015b7c4b5b9ee53f0c52d716d6ed4f94e09470c39edfc8f58002f5b6eba444cc6bbb6697b67e07b76777727a025cebdc689c84aa70ed912aa3ac4a54ba1e7cf4ce5bde02a0b6c05a99899a13fc2c8604442a849e83e29022c5feecacbab97e37d6c6624651b881cddf3d1901808804a1e42b2b0cc6617785cbf614909b7bef7ecad9635b5866bd820789221634a450c142c1b303f6a52b462ffff19dec761e2d803b61d8ca2be357d6a0d7b5390f2a8342d9e46c5009d00331a041c41c3401cca12b9a6031480070d8890bc7888d02c1286c6c180480c0086024100180c0602018140202c8a817096ca62b805e646dbf3bd2e64f64fe4f004eb23ff0e699e3247d24b954b5088a40ecaa685d8258c2a3eb4ecfe165df5168aaf83b3641af522ff11f7da40c0a2cca02c46d2efcdcc6a1175a1daa9d70e2a750166303407f0b645b3fc83a82b1e4899184fb508d9357cefb368f6496662150a6f7e785018b411225e0e15f5890e2d8d344d1149d7f438da024305fadde9c440f6f31737f3568755bb2fe44eb98682b9ed86ba66f98ab4db8a862750ed262b4417862278d552ef5a1ee7874ac9ff53c3143d4951a8845e4981874b338fdb6644167f70da9070c9695afbc2886b3fb9fd8c545bb6e2da3c96ac914c53d3127a343d6fafc05c2dd69c4ce918a410957a367bd3c9241d7c1218cba1ccb4637b47115544336634360960ff0568b26be93a44a1a2d9f59b24d4d66695674084fdbd875a244b6e018a06c2095e2dd4ab8dc170c6fe37ba6bdbdbc1e8b152458909ab6d0d8a7ecbca1261aef5c8f04b1c3068a2b35b45a74db7b089e3dd78d2b48c6259262ccc5d1dad46da316394643eedd95a6410cd1e4fcd54fca74e1f6da5b8bb3250970d8d5cf4a4a195d4643556a2188b7bfd5559311193eef6871797c02bc2de8bc8834292b0731e924411129b9ca537a6ceae2e270dec2c56a22b96e463f562dd90156539a401cfda7ebb33e130c2b32ef4653f2413e0940f5b53b2c237b31677e5fd1a5ba367da9a8f52f3ba211cd0a86acd14aa4534574928ada454c5c91726a7a4cca5c9e68a194a25bdd2e1ff64f5ce58c21b4eaffe332f7dd0630929ead5abf96f88b98f4712bb4d25861070fa396f6c3f228aa769d1bef21e9e5f3ddee813d442ae61f6e8103da1331e1fa9e78d1736369bc1bb1251fb2176cbdf28b32e55ade7e471266c81a4dd06282c44d1aff58c1627dfb68302d90a51f44d311893b313a8307cd6fb1475788acc3457c7b4fd399f0880683d5c650b11cd9d249aff68132935cc4ed966f320996adad48ae4546194780947df9a4e180080b6741118468028346c2867ff5c8cb30a14e029c09e75d282ea573c268928293a1f81872649162790292cfc5167a458b89fc6f0fd6686b2a058e8390076939b60b212624324df61daca31cfee89ab31cb4570f2e01b2296c28f8a721385c653b853610477395dfa84c8bd4a47210579b988cb39a3a2c755a18cc1bd73f346275a053857a265e82b441021e8be4a6224d4d03359ca241f3d7c14887a47646ca2c411139ff02fd8d3318ad02125e321b6237dee5811d423c8a9a8510786e2f6c731a10a01da3d9a5796898a7ca49222908098242196da2adf276c85713d91c840af479be33dd44a5eb0e00c6ea0f66ace750ee1db88d1ed6f050d177a8d4d6c6088a44ce2b2a490949a94b4b2a527de01514f2f3a3301a46b8f2609de770961ca6bc649fd8aa25cdac6883f60893904bfeddb91fe918bdfef655f3c8e517069c457ef5e66a650f89c7757ddf4bd252eb8bdd1c0613bdade3b21caf239f0030c93d7aa99a04305b4a17589908f2b2fac28b7981b3ae9e762258d3f881e1aec599b58884cf5cc63bdb190a6736247b98d5cb9fcd2610614e180a3298dde507fbebd8deb27dc403ec12cd41cf3fd70695f9192f71dfbf654235c6e90353490315fd6c832bde9802d0853ba985356e9db8af0566a27858c95138b2db3035d7c7a3a75dba3b647d4c995ce53d2c5b4d91dc8ada94cac2660ae2d76e22ba90317ed99b94c64fd6e32287beb800bfca12f1d2a2218ad7d1db5ca5d3b15a28269a39f7cad6b19a4b66f7e239af7f89607a8a796e0afd971daf7767d82898e207218b3bc828092d7b227d770933e0ce683636435391513bab68dad1389cd709cfd3c40e78d02454f3c51050c97d335cb8a9278364abbbcaba81e076ad8261218b934eccc8c43dff240fab4aabaa8d5c6efdba7c461f7be65bb39cdccadab8549a5b52571d0cb81fd05257f52bc54670ca95a3f890155712e5ed711a3a30a6ddb7ff721dc7d60c33917ccde9916c22a0b4b04d0af2cf4d33c4e6e10b9e3dce44cc35e553ab56df458700e79afb0220d95858da2acac25d9fec14943b4a5a1fff0bfb26a4dd03fd1d0b18b36fe593955a56e6c0b044fb29e7ae1b62415fe0edb3738f03ddadf16285f195300a2f2ee76deb793c71105df2539ba939f5340d31ede2c94a4d025862142884f01f8b598b61adddd5408ab29283531086f384921340b5dd1eb61b37b68394340723ded2dae6516f96f14f7a417ab1907ef8f3d8d002807e59119c18490349de164614cf2a4d018c482df8a54fadff007d1eb27bd59e53fb0f0af55089995afded158869ab33264e0d9ec7bf7a2abfb5b2d0686615895ea0b03f339048da25177b97eb715f87d1b76e542097067eb609b821735cd01863e577b6046e6f6ab46eeb5e81bd192f6d9586dbe510289c53f0e68887b0360b42f22b057fc969c9d4526900a413ef5d1d03f08bfb46d36078b080c9db4de95ca92f557d53820708327b4cadc8b2892f67e0abd2f158e8c14f38877a6bc6b9c4f3276af85a56859bc1a55a67fd2bec14f8b438d341d5082006a530ba240c0df3f9c5422ddddca3933d61c22138dde9184ceb36a9cbf6fb9b5fef5e3ad28aea8c716ac000560b91113db931cc3057892624067762b3a6a9b0941a5a9c4c7ef8dc2f56ac24df912b4161ccd44b5ed0e896a88f89219c826ce8f87bde318ea29d098ca286bce340d0a3ea2b03a4dc786543814d0d7e91bbd61729a3651746d1fa26c0c61c4f34605d342b5c3ac9f66ac3c78bad3d11a88b7ddb2cd19c17b8dce701d600e729e31978ed283e17bd13975471a3cc41380f61b06e6398572c969e0a97c8f0e0e1ffc1e75de3e8ad321dc86edf9aa0ae222941c5ad99472e7b497fce170223b142e1d9d710f84883ec8f038cf50403ac8bfa5be213df902c8c309038fd2b8b108378a2f35bfbd9111e646f33569271d6b03fb15ccd2e646434a6bd7d12267fb3cff5d27d2e98334a71d985bcbabddebd1423a96cd10e7887b26343f81de4cabc0c072afa62e8c7cb05c6aeed6bd1769bf89179a93f1a6cc33976e5b49095f86a79dc57f7cd358d583071d03968b122cb8d09a05fc47adec2af778011f7c542ec21fc2ac4299c316b9b112b064e15331e6cac305901a167eefdd1defcaf6816b685ba73f8b3cbecee1f82bdd2b89654323073de92f0279361ddc40b851462f2bef68bf7c6c788e0b05565c089e13c681f12679ab7ef9ba9ff896d673ef47529ac26095eec0fe4123407ab6faa661484aebaa842b7201eb6dfb528c06d760a637fbae62f1d3bc14d90c54b814df5806b6921652d24ab8e6143eada637b0cd72fa85511925f5d25b5019bc983960a35c72aef5d1235a162eea205db3afa039ad0d2e604bf6e5f0aa5b5d8b602d54635bd41d408a472636a64855314e8282d9b4bbf573350423b6d42693728633f2df5fdea4fc962764d5f80192fe48a89bfd148273cb239add4821e82f9643abd542ec7632e379c8cea7bebd05e38fb9e072b7da4c52bf436734d31fba1ec750e77db919b597124bdfa5214b2c8ecdf37ee72fc8b79da76f87306ec947a989a549238b1e6af86b9577b39aa4d7f14d3acf0d74b922082611b0eba19c2f31d3580b2505c2c15283ef06b9132264df40f716c2c541561bac5bf141f24d724920545cceede2df3f42b39d5aa37946d4b5ed98f05e1fb0e30bee5a504e93f4498f0e111d342b496ad2f4e1f4ff849c982949182dbad8a5fa4c9801369e0f9fc5680685ac05030ad4c4241faf9eb0a0e17b0b25f92004ccf3f3f5ac6bc5d61ab9e36c80a5b3397a18d538253934ee2c38bc13353534c1106bfafb9dd6d6cb96c74f050444df427c6c0ae8fd0b2952172f5f981c4cd6d23cbd4789c704e0d6f09bc12e080065c7516174ac9d4a35b5035767f959234c16fa345d631204cd16fc04323b557bc95c8ccc5953e3abab2b23c449f7f2660da91a9d322a49ce4fb65751590f6623eef1398865d64680c9156e7910a949b7f4048c7010441292de7129ce5036b030541da3d701c3fce1c711ef2e44b0e8046bca4094dea630ed38264db66adaafdbbaa81a47cc44616ce544e1419ac089e82c1be936dd76769eece46f515713c1f02649320b810a4062230def881095b3f4937fe3b0e8c6dbe3ca7818253db8ed10c6d2eedaeeb1e1ab8f3be1ff8f77209a1a6e5c21860d572e8f0300173fc6c2a2347e456ba045efc66b1abf12b2d76760aba0ec363e19c1a04e44733a3ea7bc8ad605d8e9725d0d49fc0c25d494e0344c50b616f398b342edb8a1894229c75ecd67eb20a2d7687cae4c330d13435ee91c21c74aa81054cfd8170ac3306e3fb097327717c6a0cbdc5de3d921fd7ef7a56c2e839d01a4b883fe558446cf79df45115ae624eb16c1960813dd326f3cbf8594aa969d497a53f2030e1964eae09908068ffb047e7ffa76a9d4564c424e87b4d7e412f2dad17699342f204022683428ec9295c3ca27e0ddb0c2f6e11701e9cd20969fd2f6c41a10902704f0ac8769bd1a50d1832c23d4aa888bf3c5d6bcda86761f92709fcb0c60c26f20e1ab9a0955c7a446dc5a28e9e1e371b81126b7c9588b349d0642927c3c733ce462d4b41fa86eddb5f655e5ae883ce7799b4156466c33b15f4e0f4cdd142eae599fabe121b1cd09c5fbf759726074cb015a22dc7dd33f7e1dd1ee44b9b9999cf6b7afe8b95e1331cbc12822a14a6b76411b37f65ffbff06f45ad9a19d4f7b3dc8c2ab945aed68f4d6a80bdddb98040e8fabf9ea2e33939ed1f67f68f7711d1ba6b4090d8e1ad131584f88aa1b87b0d1794ae4e9eeffae272335d065c65885e150a41a0983350131a91f648dd8ed9750e39c62b72e532def6ea17e0bffd88aaa70451cede72200c471d3a5002c5e0f6fa24180d1471824492dbdde688bfa41fb4029e138da56dfeb755a3dc949d459cbbc5a31c0aaebfade577cb36c49acf1af887f6679dee08e0e36bfa2d64938bd418cebe8c1067b011ea30f7dbd88d884d65e340493895c03c835bc0ba48e1c402839721a7e20a414691b12ef4ca1ba04fa31f71ea6a357967a29919bc7e7fe5edb61ba0eb613ccec12d7779d4cf61a6380d3dec324e84529b72deeb6bf2ae9b31323744956ab86e8d7bc0a41493c245c0ca0ad88cfea98bf6a97582645ff908de9a238ceb9c1415b68eadeb2f8ab10624f72c6559612ba7fc1323dfeb15bea4a857a0f56ec1353ced24deb1172eefe871e56575a0bc12c3d50b90bca175f125b9a3da0bf442cd46a68e06a86a547ffe5c17cfa11b977d968e4a02fbd41d07ff9e4d54d866965af5736f497b826c02f6d9d3e1e9cbd13fab1286ad5c4965502d99cf32622d97a200ac8f446cd0a477a938c0c13c9703a4dd57eecbcbc742fa1944608a93744ce7051996ee05a4239cfda769080fa6744df4ff541f1d08e784b07876778caeb692bb9e788673d9b17bf49fc5dac918d70377f1c6c587b8ba233cc12320a303b55b31d2b34a115e96a5eafc5da000152a60c3294c4817b3077df6cf4f3b60db39983e05f13e7c66e084105d287db7ba5328224be105f81cf482361c6d34632366b58484e8d25ec257da93ff08871708b6dd9ea121730964a1b8ca3e88d1063efb192853e840942130a0669a653da7d2df75522648aa574bd3a29257594a111c53b7421b60b088916063356ccf5d84fd6432eebe295c3552803800da55593b9f378fc8ffe76e2371bd072d3193c91b24adf9ec7b751630309762c578eec13a747e353128e64daa4a423933ef1e90a451973330c923cdfee5d7712d0ac9426173e69ed3e21c4b2cbc82d5fda3292b2d9a5799380030ab75cc9f823bcabdfd466e66a4f8ef611c1c7583d93470ed5c1d64217769222423cf278a34bffe5e1c513f0fcd84146f85880f415c520cab65967690184994116c5216fc10793b5c5c415896083570e317e7d7ddeb3719e333f36ca82805985976c9e4b50f355f9f194840ac79abd232f7d7d32f9a6efbedbc36b661bb782ecabbfd9ce877b745b38e77ce3e681d601763490bacf0a99d8c177aee097ed7eec233aea98077c7ac2b979e385d474805fab5aa88bcd8a964ecd4957841b07361c04408e03909bdb6cf698070725ba56209131b194cb54404694c68f6c36a071ecc559dc54e5b87c7c05264aa022c965107a3ae4cb2f0c72bd56eb113534f7590d4dcfb928264ebfa28f548becd638e42fdd4cd72429abde6d3bf20c95220a5c6a481da5ea48ed54da96b1e8577c332d98bc5a6b6d73267ca80bce40cd021d4447ae98300aa46b93c2d31a2d2246d8c45411993f7cf9215b7624817d8779a3c2db8328d10db2204bbc787500fdbc5ebc9bcd71e28038a7da15324eedd453fb6a54e921c908e3694405019695788ecca1f3b46b20bf381b859732ddd868edd1a7237ade96a05a5cf12e093438f1ef7f3b33b5cc7436835a6db765cbb14643b682b0ff9dcd4e4ef8dbf1af4097881b93880b6456dad962ab116944774b732b3f1c45a0520ab8514a0e5700cf36510c31584b061f1836b699c521ffdce1e99c0e89b5dcfea76c532f34f0f92d811440128a9bdfe03e2f4d24683d7fe8f183977ea8f2d944bf544358e0918041d55223dc07b43685381e118c6a3ba1a4fa713d1c2a4a3a97839c994f20c3013ebdddb59b65bb0011f6051f586c24eaf547bac67197cbfb47e939d5e9b7dcde3c5d4ea20b1f7c060741c76b732e4bda7ff60d96ed4821e2b971b86bba909b6939b71f8608eb662e62914c0d4b538c147a086beee2d3dafe979001300568cf821027573870356c330c6e036badeb53df3d357b97f1c7f9d7d370119e77913b12bcd79dd62c0785216292327e3a6880af7b6d7807929cd3342eba9283427020456e980d1d643f21d73522a0cb0ad4482931688409d813baeeb6ee34f654c2cf8cbe81eab8dfbae134ec60deb1b3ead5e5eecfc8cf8c804c49a988d5bffa77054d3b6fbe58bd941948de3e200e1fc316a70edbb85925d469c5e2897465d7c3e5c010646c36e09f1593e3f51735adc6bee6f9fa557169481a8695dbadd30c6f2dee99e6513c54376ede961d573c1f3cb16db9bb8185c3b908e91bb54be0225aa6d51efe24857de5891a7709bc9eee680c756461af9753bbfb475daf342e6ebcc6fb748536c58fd5b7dae3d2d8abdae2af7f8a116bdad5cb00d4a8215a349bd917ff1d450cae6d3b975f40630270d820fb983a30d602c66dad4f0c1cad0ec3e58a3315bfe59bba5018e46b956bbba8c77281aa25360bc431f499e549e8f928ba59527ac5cdcf39c07d3042e86e39d6a6ae8ef0f70a08d1fde3f7ec1bf6f66b9dad0cf8ae90428b8444168a90c0580156220318e5bf2e8b5e70e2bc6ece9cb04fa0bbfae26f607b804aa5736168509658c609c86a0cce70ae5daa08b14feab81e48c9bb3c59c1b0f62ddf690d91db364ea3286cf219e29f0f005579897d1bd9a8a1c97a41b800825c44be6c736fe3bd7047d0a2bf3124d921b7254bfb9d5993a440c0954d4c6ec53301b96e1735344e1c425a189ef90c7293dca0312772189f5c57ca07e950dd954a766d5779a191922e19966174075facb6308c5726174b9510075770f7915f3b06f658ce2a5c7b60d86ebd88574fc55cc1c02b4ac3b4320748eeea6132dca3dc6f5ac179fe71d6bec523be767cd55a9f31f6289966041c98313d957871d67fd236e24cb549ee258f7fe3171f1b09ce4b8f4d696fea15fcd087c75248bc919c76e974643797a90056c9b6398a340bacebab26a790fac76ceec942170938318fd9cc51d85817315db8580f5e34d1a00c1af6d05a5cf14e76f8e84477425ec910a3dac1e6c098c1f147c127e95b3f4bad2e01dec8c35931dce2c7bee53598b6bde7973071a0a6955d9cb9972566a80cec26f0e8ed81e7951a4efbb575ad6610a864e58422045f40d1f252564ec548b5546695e831bfa1fde8b6c5f919eeb6c8ac9e52753d0a6c678609984a35f7b19cad9d965d343a2b71f34dc84040834cc3d4e2fcce21788c995a6662684ed2a4be0e04f9acac09651a0754727b7dbd694d2a53536b13af58c89bc8f73397012d16edaf370a3bdcf4a5328e898a1626611c9f10af07b53c1deda04033e1b81101daadf8ff6df92ee534e5c8c3bbaa20b44253fabea55b28d22d2391346911816d0d8cc248a2140fbfcd8f2d0fe273d0e462acfff6244408d2c5b54e63afe35b07bf388cf2d7daa7fdc18785549b578d659486d0fb1a18d1809526af40485a1a19d2139346285d54edaf80860de4d4ccaf17529a48a69c4e4122edc0994dcfb1a90fc88ee511332d5337d4508933a67a95d0dd4a23250ba18c0c1235783de853b9011daf25daaafb7eb80b34e1f5a26cc4d3512b453fa11825a5bebc5a20d0910fe038ad381bcfdd14243566610fb1b5a3352cfa6b5be72c1704e45c9c956ee598be33456ae20458f125abc95b84b80240f89842a3138b5ccc9822bf3179799844872390fb597743cd1aa9d2b44d4759fd48e2d162ed7fb41c0bc62122f892364cd6b72927fc6061d4cf26958e1ce168a1919b6d894173dc8d85412268b0d379eba4528ce085e30955786f12d57962fe451c2d523d51cb9baca878322bb7e297b4bd87e43b7f6801cc12245a7bb8d7cfd9ac8ccc44795035eed38ad0ed080afb4c3c5485a52ee4f5e620ba11240addda1868e97c3bdcd8a83282330f2597b97030d425ff6092396afb002591b82fd07892c47c68bf3f62e4081783b7a4d67486693a735b34f2eee3b1746714ed4125aceacc82d19c9b343f54535b23619509c2cd0420c1cb025183376bac82afa30eea09ab0c9ed51a644b4ae5e5a863a63f7654adb046b295240b0e88616e53cf40aa602bb033d908a5444e5a8b78adc19930591c01946db369fc3f6850c874119197ed6d45624fb2a56890498be906d1ce405ab12ff4ac82ce1e23002c7a366128a2f758c59bb3d6bd306e7f4e8efbbd3d244b555c0a5192564390d69a9711fafb7b379ee72889f1f74cf58806bdfde655bc93d6b07831bf75cb4c71033198f2e8058f188a297a486a32835104968cf14f3d755d9bdecec0f94035c8679618a245f22d81a0461ad0e024054dbe3016f1fcf2a879ac891fd5106608ffbdcf3d11f45ccee091dda2cb13f2aa44f20f1ab83914b7b0aa2ba97b88d928a4b8cc0290f25af77e643422aae968415e4bce91a313487745c8d3c0505cef3be10c1f036a336c9eecdb3d4a6cc3d0e51cc8d0cd274f0e7242fe5f3139b383ff3f9515d9c97c000128f1522679070c725ee9fc00736a3c7441915bbe9c3c6ea7bc38e42b1d2d6f17717519c1b81961ffe69773e700549e494b90ff1e010340a9d813f2eb6df8887acda12fb90000e0e505db744670a3208f4c0e7e920f7ce35834657f4ab8c0184cab5bf9f0232a88ac0051e5798174988806eeea46858b5ed68cae539ea970199c98b3207671c4c270452761cfdc2c7119139629d19215776be4531642195195a6abfe50b50abe36bd26ac4e9b72536890598f4ccea5b5bb026c21ba3eef3f14875f10b37d783f7120bfae425dce01f2323a04515a6c9ee957f91dea4811d11b7f188ff5a272d89bc507bc2eee213e03917cd2c8c8fc27cf6ac5fc6c89dd8b629ece1f6a754feb15d595bf71bd6efc3947040427ae02fdada3d6579900ad5d668c16804ea9309ec56a54bd70502cd7a8a787833923604a3565d7b5fe2ff4e17e53cae04ec8f7a783b4fff7744826a42f38d87fc31c88239e828ea71d96cec115c0fd62a611daf325c5b310ee38c6d306358bfd6c1c6943b37aa6463083c843acf5a56c29e8ad8a2b92972d33d2ad507858986e49f9d4b578d2d02bfd5bdf320bb32fca19adcfdf3a1ceb49f3b1066b5af0165e8d449fe64a3e206270fbea7495ee99a4abc3eed2d591e4067a1a5a47655eadf13388bdf7305abf9385585130b1136a61b853b6e18118905c18629862ef04ce1f9139aeec31c2b763aacea6371067789a8f58c305fef29f4f6f8cdc789e5d7755120169e858363d8ea82ed17da2381a03ba9a4d94a8ec3bad452f278bfffb40a2879205aef144deaaebe4bcf2ca13d15911cc682f0a0cbe43c023f742dad5ea478ab83d98aeb6ec983b57c0011f22db7a8cb99f2782e7d055ec5ee8288f62d240627c95521277bfe3d2e121ceb296baed42a2fbc8819e343492a39730a110977e7d1d8054f6fad40ed6dac8c31eddda1205b087243335b323b969591237811282f7e83e6639672f9ad9fc553c37d93d946de542851b058b3020664141533e76557d75ca8fc5b0ef810ec596079e81d1460f3091bbda7a7c1efa3aed6003185ca144617f87e3a7ede9f743e6e977786f6fe53b4fea9a3619261d783f946a13c3fb9114856aa06f18b8c3be73ed7e2866370ab06f7979a58c16f7af20ed76d2d6f91b0af738cc5264d6f2c6a786aafc1c01d598bb8fa84f6a7e454d0348b8bcd41f3ae1f7b028337faf664209272fc7ec0611a8172dcc269acd9f607e26acfa24ff16d8e772dfda4283a63a73a372ef55226ad58d19144a526ecbc8419646485e042106076b482d87c9648963d2368ade1b834caa97552b417043cb900136df1c242e3f7eb56d79ebaf56bdeb6e235090f971905b7f2e182548929e025697e2edb295f3bc57b63a16f9efa707c277dccbe9ba94087596c46f533dbbd05ce3a6d605f37f1d3358776ffa50d7228d4a5237d2ed02d77a834fcfa7fc44c1102aad4e244a6cf26724aeb15dda5981cf8177623f249b8b763ba4edad621d119c4b017ada842f58708e25a503f6a3b75858eda21f429f7aa0d80f9444ec0bf5ab0cac03d0c682caa3257748598db2963fb767ee8393d7c5f631bbd4b858b236b4ce4599c576b9d8801cc9dff2af3ee5d67be05e4a5137c263b04d64f6278490f802c202f70230305157835e2d6174702ea87ecc213b267e7070ca091e77e6726d5951d6937555e6f6ff3bb8c59c9f73ce990712a59949a5071e4b9b07a42e674ae95cb0544f6722bdc59c1e8e471d4986c04cced04526e48825672ccb4430a78fffff4d2ebe953f97b541d6065a98a7aaaaaaaaed8ffaaaae1106d0e6eb05aa295befc88f891210a6745865536c5cac54244229692549abb2964c2477944a301972b960cdb411c2216c8a563645f5c99868533389a46555d814b635eae3ff3f972e83e0eaad3f9a6be0040fae9a96872786232aa3a3af1ac618bfb428cd7c717a8084bad60e4d702bca7ab2ae555b582d0d8d20451897f91ad2605eee91f9d329019cf1d8da8367b0bbbb3dd1bec88a61e179c191fa6c01ecf88211c312e300ab0cc74156db5b51d693751dfbd1fdf021d5c2939c2140d61b74621372a222a25122e1c2ebe3c6a6a6f6bbbbbb3ba010629cfea829943526f115326b5dd30865d5b2a2ac27ebfab076002a143a70eb122f898b369b6dc5995c318b5043c9169d5bd489546fac0a9bc2b2972003ab13461ea28c32ae13c8140d63580153dddd352bca7ab2aeed29b5b505c4465c3f13292ea09e8fe3865b7777d48aa42e2b63570dae271ab8da08a9c4058e4b77b7cb6229182d3696dc9278dceec32e5ab66c5ddbffbb2af84ed830fd9284c0d29a5e52841d2fe5ad47940f175dd45392f4c678ac7954ddeef64c8110774337f6ffb18e28cd44263d60298b584b9c333fb843b537e79d4bce39b6d6387d0504f3ce30012e3039f4aa0ce994450301de8ab29eac2b0f2de608012128bbaaa1a94645950c4de4d443b49112e0032a9d4bb76b8ac061bb9935c3929715653d5957fc12d6c7ffff9e77e57fa744f0007d88ab592308930ddf970d163234323864f87f14c39c7d5a5c162e276fd99aa41bcc38b6c0a2cd669b494da72041e0180faebbdb4ddf0c052676400b30785cb07462109da8ce14c12dafeeee0f3d1dc61b5a93b6ff33862494663e19ad368861eb1f72b1f2e7bc588c802220b960ed9011290a6a1933b8009821769ab090d8de7f96ccb53bac509ab9d5e56187d82c67360d4d76dddd6d18aa4c69a6fabf10d562fbff4c4294660e3308a662ce6fc953b2f7df4ca621b6a47a6b8d6cb8f16289dd97354f0e8ec063d0e45804b3a2ac27ebca7b9b73ce594594661e91496587aca5ad8396eea58fffff3860702bbf0e1b2d8b8cd40c59fa4b793897125d379272c920998f1b215217f15694f5645d77217cb6a6b6e4a5bbbbc99029cd549f32fd60e175bfacf8733ea91411e3f0ff8150261ac4feff0dc00986d588592e07dd750c09142f70090d21239a351853b06c77f7900fa5993f6088a160568f6aae45edbe6aa4436966cff7fb6004bc0ac618639c5bbabbd95a46a1f63be3ee6e2b94666ee10e325d286ce35815368565310c4ecdb1350cb41a5be3bbb229dffd4a5ab56555d81496c5ed77523d9f6d5d328258b2c26b7ef9ffe70280e9f6ec51eeb8c4136d58fdffcbb91473d3b7b19aff1fcb86d24c5d4f032cdf8f76769e865c923bd2610fb2fb6079fbf8ff0f2534b4f2b7b8d6ddad944c69a69abee4803cb37703c09b84ec171b390caf16c22ba89996a797946606cf30ee8131c637cabe59368ead71748dd36b1c5fe3fc1a0728ecf7ee09fc727158f7d41dc7b52a97aed89d7b61cf20dd7ad2cbba36f310b6a42d8ec8e7f032e7bf55f3ff2be9509ad9f3fd3c5002fe3f6f841a5b6245239c747c332335f5cffdff3d6c28cdd4f57cbf103d805db37a8b31c61877dbf296addd880132ba8e242ec618d718a234b378442695226a2c557c9382e2c17b51067892b62bca7ab2aebc921b43160c94d01325b613b2947104caf7bb3141614609163bac5e7e3ace760ad8fbea1b3b4598c7aab0292c5b03005e77378ec40b39dc4995245b7c97430a9cab1897c5fdeeee6ea916dd4a37c61d6731631fbe106be707a29e9a33bb73e6f1ed8992b1f4f1ff9f461289e4089b9e8eb6d7474b12a511bba99c730e16519a794426952182cb1aa7deeec52da705590b8104494f46ab7bf06efd3d4f91c32c901b784f8b218e9a8c68a05c0cd13a8f3b7eb83a154c62329634f4248f43ad087684305ce398f0f471146488cd022bc8f811923b2292c3e3a846850efbff6f3184d24ce1f0438be2ff322b9ab44769113c76e1fcffc16a5cdc92654a33d5d95bb25c4f36e89eeabc227470569fab730855da6cb69a99596c912872dd66deff77e8c043aaeb5f1e6753532f898a2bc8c66206f9b1e85249810848d68b209e196228fa884ecc540437f0d2d5e9e888712372bb3efeff5f97338e8cad29221a6c36ba860d163d97a5006ecc38ba526c94f08731cf3d41f410b6d8a4694811efc61e308dfc5a862472445a384ee494d0f755c345219b825d5cd50659dc11917839a71042af8e28cd4482b84afe38ae942b3760e5baf45dced852300f0613cd6870bb181508993671ec97ec7e79250930206408955717d111e70c4eb930f2faffaa224a338f1eaa9039dc345ce668055f1ebeb12a6c0acb0a91f4b4d7dad16f7a8325af407a5891347700cdaaa189d1825a6e93156528cdc4b52f4e4f0816406d8117071a8c31c638aa09001a7528aba5458f251c48bd4444aa5154342d3ad478a4fd7f18d44be97be9eec6f86d0b3f2576ba96c8ae545c8105d970c09df8cd7a5cb09afbff9584509a5994f464eca0648577aaaaaaaa8a337bdf5a95daff1f86446966324cb9862d51c46cac984e45ac57b3402522449e488f9501820792373d2db723c1125a472d406ee648ea5815368565956adb4ef0eed4d0b8015b21c319b60454b26abfbbbb7b92509af96414d16385c2b6dd3e3b2990a2ce8ab29eac6b1490b21cd54562e66c81a7d301f3824caba8c914d21b3143c0d6d4955113d412a8e753c4cb811398b2b46010f278f05801416163fe08fe3fcf645194c143bedc691221bbe15b427edd30b6d2afd8c7477d39c77004df6e47621cb16952ca51559574238a2498d24cf56f4dafa4f9012a996b915d581536856571cbaab029ecdb4c5d6663d1c7ffff1cb61c22872e6723e4520c1d442f1518bc69acdc7835e49d36ec9e2716d030a88fffff01ef8fcecc06d23d4368853c3e4470158cbb0257e002a6c88b5b8fedc724e34176cd7a39d7c7ffffa82572e5ffdbffff3bf5509ae9fb013308a7a0caff12e0e4c379f14ceec9399b90455ecbaab029acfae69cb38f10a59943b5b81e51902c083e49959a8bae2ca6254b6e68d316f5e043974b956a50ef58153685655b75c74077edbcf08562c44c52d4901f27b058b28bc2b12a6c0acbe217dd993986b86555d814961debd66505807a594f742bca7ab29a6bdb8404d4ddad43820bb025b29b2043390da51563657adf740b57c3d5fad121ca41e4f6c562654a33d5decdff5fc48d62ce3fbefdbf4c12a5994a0f64966f115343195239bcd8755dbabbdd54f9b7c45bb0375bc21155228eea85ffffff15302436214a3387c52332790f6cca9fe4869f7ae07e1cd0bcf58aff8c4ca78fffffc5b0b295ffdd4035030fd44c6f85f24d81f5758e7530b662d724fd09d6201fe3a2635a35e6fc254df00e05feae0257316163238af8308a0103ceab86fa529aa97eb744db59dbc7ff7f61cea80957336e37398ad408eaa7e12e9733054d3e2762f070a167c609d70425263c7182f39bf5b8bcb5d4f8432cd5b5efb74f27889baf1baf28ebc9bace786b075e60415c42e38e19352a88cbb3bb73a8cb8b0b7c90a674c4909161a49b8080b93881bf9b09d9ef37c36abf33eeeefe4262115fc995ac8acc07b79393d14cfd55d653dec0dadb060e54b5fdff1fb72c0df81e9596924f3227118d12274a4b48079f8527231f1c28ca48109934f460d0c1579ffbff91921ae9a9918c8d64d5485b8dd4d548628d54968998ec54555555754bdda563099408c20092540449662868464cc786d5ddff3f0a08a5994220a28a5694af92165e50f514b946388854a72ea6c80cfa04b595ba6ef75b53fb9d7177b71630a599eadbeeee96b7cfee99931cc298d8e8b101b4aa6deb1a65a4ca5bce2df43ae59c734e12a599ca10394b9baee7fbff16530a08885b1c331bb639e79c5f21946616059020a8946ddee6c40079131a68040d0371248cd31863001400070c6a94b4787808311687c5c1a0480c0484026130180c040040a140182c0a82d068aeaad17800a9362d9b755087dcf8d252e1468564365bc5a23186ea284aae53a43daa469d13895e5178dc5b2b30f6db8c5b8ee015ec4a8f461befdb5090b46549080152a5f5c6c1719314fdc262e01b2f7cb846499bac1e5a5c8b5520cd8497002e3e611b62c8d6356057eee490bdaea48a573a2d93e28830caef4f278d631235b561e51fce0ed32674e53f5140a552cb7c0d081c6388e0e53a5effafcadb1e9bb7b2e6da0865e6d8d3fa48fdd8523785e51f71ea1a27128cee1c5d7b313a04ba1da2b55f9be41aedc5ca165f290751cf0590cd0d4fda27e79761ae35b87b26687011cf31c28ad9d213cb6344da3e3f74b2b3537c3c235bd069f7683ed20d21d4b088ed678cb5fa2a8b5490f1b7bf61818323e03ed030f223019ad1775bb4d2eb1c7b0de8168040063925f1d163b92332dc60a11e8fa243ab93c61fa4c3ddd46864a2d2308e8fc72fba05207a5cff261d3ce57fd7f153a8add024690786bf3c69bd9e960280f148bfdd347b2c4e8917a4c69317fbdbe47b65fe1897ca90aaf0343c7295c6066ae25db25a775eb1efc34f746a1c8bcbd876ca1a2cda61554b1aa040360a9311f60f9eb859eb6db7cc115a2a1a8a6941cbebcaf6f168f51d1ad31f04589a44a940b87979d0107e60ec29246a8ccc420d8fcb4e3ea5c9ad027bd880c3948e6b7159b4a8a37f4cd55e4911a95427b5d31f4d2e256e27bced380dd8d246cc8829b585e8f429a07f12dd81c90e4aef2cc53877cd856996c1478ea4231f03dbb9cde6d8de7297ec59b50b45e032049ebd53d24e41279dbfbc974d67b9938564044581bd86a8ef7d6cdc08a29870510420372809173a9fafcedcec4568d34eab4f895b5024e18176a716b453bba8d17c4aa98641e0ade052f9272f7b879a028af2df79c3a056ba73b0dcc0ab1dbfbb3ecf2a45e574a9214208b332241ef642a9b3a700c8f059c4882a07b51c53c0c4c948530ddf491f68f199e39d885c90506d27e3097393314eaf300cd5dc2bdd5d2f3e57a48999a80f83cbf9c362786b75587cc2c110b6df4957d4e698db840b57f3990871489c67d1bb9709db69cb1d53706044b9c4beb1b1adb6a704c44f90b01ba8672f30afb5ce0a199edd47bcb8e111e93344e453b4d2244f262a824b6193cf528a7639103ac8b8f2a9bf48c2343523120f50b2cd953e8adc09dcbbc14975bd51999a584ada2ca8feb61edad30207495f2dceb01a900e462e6039dc910c907c662c6d15f58cd2e8df6e596b650c42f533dd0d81d1c710855ed25db4128e89420b34545bcd5aa3e8d1c07cf9370547599d25c9fc3535068d70d49bf3178596ab1957e640d3c1c9ec30ab08cf814acf3bb05ca64ff945703c097977487372036f25de21d993cf004ee36e30c75fe07c8e237a9a01dbb35788df885ddc18fa956f48bfe02d9850367135038276ad7ac5cfdd5aeaa97facc69751b681d13c3fcf0f0452f8018b861cc8eb837bdb995d8d04681627cc7ad38588b3024e671d9ad1941ac2b52ff4a94ff9ec9119c77e26f4f16b2da84947bae7c04807e6d7896a4eb000169b8967d635e87bccbb421fdf28d726084833494e7f3dd1f6aa5243fb3ac63ed839d08a4bcdc162b3595e9d5ebf4459d602799f8bfbd5586690b47ed354eab043c80b429f3b4ca1c0e42edb66179c066fac66bde8536217815d0c77fee1a07f688191d7f3b54a0584cb0b21db23e415fe7ad635084a5e405de7c966d880a6746f69be38a57145cbc3f38f131b5b21e5bdf0498a9e2bb907d5aa73183bbd5e33089b4311958b675a65fc285b577710993c27a5231644a4e96ae90a487ee4b5f25548fd8b6d66f546e5ebf31b5b22d90630e8e9505e9479a09a0b589aeb9267946fb14fe12e4b5bf927e8662b339ca794bcebe7924a432b6b215078fc811dd261095648c9f765445061abd52791a68bd1ae7496b0272b2185476bc1989a6dba82cd1e6595ba632c3c2539e2cc4490fddc1983701b68a2790f7ff8a7b6f3504497669a34a6b5df26ac7103b1be2d273be43d06cfe8503da2511ac3b9093abf2e5a23c034eb8629158e83605bf704cea275cba29d285a1868e5d6848115adca25851956892766d702a8f8df05f238a80c2a402072804596d9116cd5da5f2fe3f834001ac6bb2609735f829a9729c75aace0d836b8065dbf5c8df4e036076bdbc0eec5596eb839aa9f283ab945c837d4e89aec18423f40e74d8cf50c31ff70db8457a528c77a3e540551713c65e776e3272224a12720a9b9e434ddd663f81bf7a6ee289d5fc5c00297698a96aba2e380fea4cb7fcbfc438db3b037c9112df4f081eff2c5bf86c1c8ca5e279d4970ce10ac5b53260a9c2fefd849d37021d84db480268086fe18e2e5b029c72a3852341224da2635397b4231b8fbd5efb58bf18e9920bae9463a4980e06a20cf274249c6005bbcfe7ce8dd18c24732cdb4ac1bf83d11b657c55bf551d7b85cc81352d7a7c53e89bb842e069f8b2c124a6af601f9b69bcef5e6740a0ce981c6c7714b376ac1ed6ca411b2609a0d4efddf50162a9a18c4213803c0ed22e26c04dce7b9032a2229a2c083b04df26a7f4c657e471792b80fb7e08dcdd5298ea718e1805344b41e197f95e6edea21c20a06b24c5f28922d3d784a3db550c565354db5df30631d0935751bcf76da87e0e9a011f121f4da51412404c9d533ea8f1b47c2a766ba97b8751079d3abc46d9e1afb396038767c27d5737cd76cfd19027c2517ace2a75d1f2d7da2387c4a568d9c5904311c9fef21808ab53b5830728ccff0c1a15829d66e8dc39a93d514b76b89e25e9d555cb043cb9d3a0e67a77c8ef637ae9e59c1be788c702cc609d62950454a5d9c578b09ceda25e6bf646822edea84c8e59816c400a69df0178f8bda50a373bfb87b442a100764cf27fa86762ddb6f1c5aa225543fb481039a155063cef8bb3ff2e592becc16f12b8f93d10ca7bd85a644beaf8ce26b7b20a3ca57a6780188e2f69f9d7eab8449aa11e447e81c35a2a2c7771cdb03c1d4f793c81db60088efa7525a972757d5d2eb1776feba731f8830be46903f5f1411464cfc60e10d96c79d2503bd6befe426afa55f50d91c298ecb41f2cc0f06dd7fb4a868b05a8a9ef77b074e8fba84274b104ce035f24e70b17b13a5dddc4b3ae4afb24ae106e84657b1ff6c49fa936154f1752f996f6ea52be089cb271a71c6f783c5997e91a0552fac57f96413a7df75af1f4f8a66abe2e4135ccbc3d8d8d6fca963f9f533e50307e01cc56d5bdf4feacc7a481144a30d3c7c55c6ab2a5c9ac38d13b0cb04ecc556f816d52db834b498546e7824764d532fc61e67023e4d178d2707147b0092326e06550ccb01985b2a541513973be2ddf77c2c98099f8990cf5b973b5286c9544566989fb38bc5247f2d5a1236d6beb0cb0f494e67b19d4dac0e73700df4781b55eaba76e47bf70066d446295b25417f50d0814e4b3530c7024fddb0944d737fced13c0d7468f2a1cae92ba079f3a212f1c0875d95c9f86399f8bc530c36c8a3da191668369fd1b569cb210f73b09820cf233bbe24d37d370caad446009b2e668b8ebf147e6fee3cac7025d0a2ead12c4e9e4d048658313f79ad5a630264c542096ffffcafc920a94d3ded10ef4a19a576f6e80444ec71712de5894aaf9d467b4a712365766e2347beb00c4b98017a2fd4955a3ab7285639dd392b77110c9c1c1b2d12b20a6db882c00473798ffe2d7b3ab67acdf9581ac9484a5000817f0b57a48b9ece8473f75d62ed4be91653391c90280e4be7b125992693464a0a244222174232851f3db684db69d822b1b8c75f36af99cd6babc646e9796a2a2e1551f9862c5df57abbcc8b6873a900b24ce7abea3c9078941bc4807f073d624a9514c8b2146fb8ed92221633ea1b5444cd927035792ae8e2c22a206cac941f7da4616aa0e32cb533bcfc704b421a5a676a2e93b0505c95b550d4c544e00267dbb6f72c08576e2350e1f469f3e98483749111862081de8772d4b56e7a49e96a234abe8eeea3e116b5c24746bdaef6b7d3493275a86ddaff53e254618fb4a19fb07b06e30ae735850e508df75c9f19de0ef29821309f3215956c124129bf0e4098b807229ce8086074b272accd3281655a57a501733a1da0399981da2ec635447792f9e548724a19f09c3fdbb2b78e747385b38d78a995c203d80254b4994420fdd4e01a32d812921ecc8b9c7d183ddad7d23d1f49477977a961f6ed52ee658fc49db2bead3b00d4445d8cb97b6af667936aac950647d04f7dec399d5bb2afa1d386b5c29a41583892242fac073acee0c7740470225faea9d56a87c6215b60c2c7ca9734afe6bf501ef2b16a25b8c64276475862d9a795aa5e5e334442f9a253d1aa5a930b88a83970585559b7ee75ca8a2fe119d85d7b8249c9ca40a079b1b873568e1b5551ca752b629be3e06ff7eb0faa4b490e11f169d15fc97c4dfa13f10fa031ae24e8080137e5b3690ed6ab8a7ecf87c7577fc2d8ad055c8214e103cc8920ec43fadb5e332b4e05261adaa0a2413b37b1ff24c2b81ef63b9bdad754cd1737d28904bb5670779d624f5bc1068cd0801e6001b8f0306d27a5957f15f60d1f3b443ec1b2d9802710178009518133e01a4fa23257e2302ff1ddff9750f6fc024a837c6af43b46a17aecf7bcc0a5d980bf7e91c36b631cab928e7652a3e5395289179e82399b02c978398c4e4796c2efa5a6cf4fd704ede56334970e33d447d6146bdbcdfeef36d319c0d40d3cadfe267a4bc688acbc30c9fc52689aaf22b132504da6328d3d259c692c8614c6f114c2136c651b2849ed57681cbce5d7ec868975d13f3b22e2bcb18c369a150158f43c588f848518a1c3503f525491444e881a8696f16b519af71ccdd9780c76e973e452fa293057a143030a0b4e6bd895823cf05a6dc82cb945740fa2e2e85dd61fcea1f0fa746c15674086a9839964f7382b9a0ffe83fa03816808fe035a21d6a7ca3675d7b1bb7c16eadd24b159d2d42ac8cfdc552389d1980bfda9ecf64ea08426a51851b7d24f05511f813af01fb2d15ec806d423e72ed88249a22b5c3428e0e51b9d1d6b3b180430513c2b90157403a533edc59300a243854217afd93138c291a9d91c861a66597f1c0a75708ce831bfe516e8a23f9eead92a0086d518d7da90b5e096652efffb956a443fa022a07dfd5aca652255b4bbfa4d6e7bb38778a0ecf9441718c9fd6e352c12b38112bb9575bfd5bafbfcc2bee0b8d36cbdaf4d8a279fb2f2c4688d7900602553a9d939afb7bded4c3c37a5d2fb7bd02ea964bd9a69a5c263234759936adf5f51f07cd2cdaeb75dd5ff76b4902adfc34dfa2ba87d1eb5bf0bb7d3aa9ea8308dc0156b5ee68c85c67cb39352aa13391e126a2308ca6a4d75e5110b0e9ae17cb0c50de55f41dc61f0cd5ca6e79715841d7bc10692cd9881858bc51c94e9229bf1992361e2e2bf02015ba3a9b1cb2f04f2ec93a44956c4af931d28f597f0c6ca20278ea4d5888d53971a147aea2cfa9aba84a0e82fed663cc3f65ee777e3e125eddc757ae872a6b7dc2560d07201882badc1fd2affe4b7775ef80d45ff2feb7cb12a9121ddd54807c1587bea92c8ec3bb40d154828071b6e417fbd5511957577aacf68db03863d4776bac2cafffeb84b7b9182131aabddc536355432bcf0f696a9aa126619489e1c2f837e56090a568740e2d036e1ad58ddc669f3eaeb25d781b0ca4a2309e5ffb034be64faccff6797b8a4fc845ba4f183033f1ab983220670ffc2231999ae83ffadb834c048dbb4d7fa5ccc3bd941084927cabb0c7ae5e10f7fdcd441232723b42a53c91c716cfd60bd1371d858f58b717353649911cd818916db570b2c071169ebb7653c9c590d438783eaab595ea2702f0ce7b618fb342fd2e44324ab75a30a4e6d5d41dd8d926328e96f99d871e4a368dbdd0b747bb8532b48be47f39a153c69b843532a8e93d7af5d643312d8e5b5a0c4a25f42219acb58f2a70185476e6e08384c5c6f49b77819579789c11ad80cc72568b6c9e9ca2dce874dabd6bba4de1b94886a49fec7cc5493534bee914bb968949d4e9831174104147cb09ecb22bc02aa12f5f38d0b5f26f0053046901c43f244c279943ba89b11e1f1c79b935d56d06f6bef29bb9aceaebb31884f5044cf3a013a91e663af156b02a26eb6f83c8cfabb0ba9646523a610d6fc98009973a394195fe11da460de87f866fe5573402d801d4f263ff9965a7280e28bbac1fb3a91532b116666f1014580a361bcd554368c3ca907f8255487d14c049ee329f36d1c965f0fb871c65390ce44bb2842a5678922df7aadef656b933226b0e5f49f1a87934e662483344f5b90192273be59a78d50521104002e0bb4d70665d566e48f7448cc15fea67bc89905dd64d560c9edc3772d7fd0fe79f04e1e16e153b4c198788d4958a48c5bf6907e77553abddebc4d936111042d296b4a8cc2094514829e441437056cd6627d8e24d3402595c750e0d6bdaccf61142b9eb40d792fc1263427c75c4804ff7a085386eb563553020d5a2d91f2b938c451d0e1e46a5e477f6fdf6230c4eafbddeb1e129692601de45a6c59a2902133e5f6a230745579e1ee33275b7949954beb877d6213b8f9e936bb6029697b62096eca3b90903a67767f7171721fad61db7398a629fc90e9e847224950390feb0d01424edb4a4e35b638e838aa595cb525d25225e5b021ec60f55019655ea536c72983be55d13bd4e96587c7ed40f3b4f505f0768d27f3233e3826a779b6da96ea128905ab30ae2dd9a9274f0d2b6d99e1d25bba5b08dce4414451e17b3fa4c6859ba8c4afc647dbedc69b6fc8b76d45f0224eba4fd5c40dba0b542bf719df330757f504b21a1aad7f1d401e2a5f83d2c6d2def10155855e5956be4409a483234b7c34f32756ffc36f090c50992fe760a384fe8b8b759e16c0e65b8ce2469aad7cc75aa3126b186eb7be7f494dac0d612e66872435f5ae50ab6971f21e6e8e22a4029135a61b7984c9f5f7c4e18a0410c3badf31e95fac7cfa3d154312c3a4682813c11462febbe9dab5402b434a4f05e49f052ff85a0d4f45bb7192106f45466f5b20c3c70847587331ac70b6d0f4bb56230fa6e66c50038cfb4624fac635162f6fb87cc1cec3726c00722b670a1efea68938df478446285c70505ffceb73aa508ecd914b96c4918556a269d38f495a8251b2b0be5adb91bfec46f849b060967363139e2d45f127b22b0f8439cea55ae51766bb3b92cfca3f4180bc8a1ef7f548bd86c4cc348b8544cb3db6ee5cffaf1929356d9288cb80407e847082711ea1d233184ae64a78a6a46ae59a4510ca760ab19d7d4e0ca3059ec005c0e864e5589b654150b015d2d314b519eafcc0b80c768df4e54836a95ea3ba878b035b0a05ac8826c5306e3659bd8126f5a261dae5b3851472b3cb8e118dab83603a556232584de2ab5d5cfac6d967120e469e0a249c2a84e7c2aa22391db067a3a275dc2a092b81d30f0fdcbc34faaf08bda5adca3346ec6454a80d366e899c2f7cadb8f4033ef6801f4ce7505fb9f5e9297932d4b73ff34b69074d344473edea2d1c4925f5c2b53c8436839466313c99b431c4a191275219dcca464842fd4a8352f4bc28ca6816e5564428a218d1396eb5f4fb77fd978bb38af36fb6e95a205e34cd60cfdc31d8d3139427e3707d7c278e09dc9b8a779e465269b1a008776d0858f259f86cb188578370b958c4bb8b76a169daeffc32533e6dd1c2de30d379e0bfb66a448b0f3060859cf1e061ee028af35bf19db4166d67846564c600ee1b32ed8ce2f2804d5646aad46f6f8777af521c4dd6a0bb77abcdb88c74ed3e9aa987517d220108b1a922ebe9bdd0598967c5d22003d678dfb92172a40a02c641e9346e75e2312cd96e7ac7691062d74ed5b2011007f14b9d6efae4e95b3ac039efac873f07191ce29a3a77aac664ae8246c66268b102f78c60330563d7a56c026214a8af6f2dab6207bcfa4f7edba740107d51fc2eb52afa264c2ddfe1827d1a1d7748cb4445b2f45b4bf953239bf7e60864399f74f5d24c1561c1176b8b564bfe086fe44fe158da0ec3a66ebcda0345bf73b5dc84a4698bc1c3b5bf5181f49cf3c818972d1d5b58802a4b7314b83be9d99ec89bb4015c386d96e87e99b3ced7eee25b9a7a22986e0843d77aef9caca912b5d0c88f55061380ea1529cdf84a222eff2e5864596c8cd9124646384f0cff8ce257aa2eee2dea3c3845c968e7b1c794963ab7e0908141a0d262886a99bb5fb9cc2ecd67c5574ffb4e7cef3e257c8aacc503f343ca9f02380b6e2726d982d1591818417dfa0ecca45fde0ed31a94b84e858415e52e22f5b9766a6daa8ec656da88c25c5c79700a6b9a107647fbfc45bd95232a2bdf60db1fb6bdf309bdb0ccccad1f11efb5dc1711d7cc3edc0caf0ca1909cc8283cf2a0042aec2a386cf7460c95d20944ab34213b702d777f31df7d266c3b12e63de1627802154a13eca949db37729d8d5ea9638b3e2706bcfdc5f20f2f822940ccc657083040464a9f93aba30924406880913b6f50cc7c28ca331d8d1d02f0e1def8a485517c0419fc11c39e23914fad2699e57923472d7145fd0f06afc16b379d8bb8a69cd0273254d470cf70030ce3fa02f1baa7213f2c34953515ac2e0ec98348f36fca03d91e8697cfd74614cfccd74c7e4798cb3d28bfc961136e2ac71ea2aebacb81bbb0829a0c07f672be14b67c03d8d9f31f0e2f079bc71de86b8b96a0d04e057fda6d35a7bdb49db820fd89817a7a9a28a5521eaa2d59858b96cb65a380b589ad04836f715661cd76a7eb5fa6c9f6d0a2d59634a960fc11538d24812af0cd6afc0d4b093f1801b6d001c24ce443e21590c524d303000805b45bdbb0e03447da1360ac21ad213a6027bc06c3e10587b4e26967b33564b96b530a58e6a5a8051ca179fbb5547e2e57a0d43287cd018565b6b75ee05ae07b8016948de2c4ca919a920991e025149b093a8c2fdc9ff78c7cc9406c25da988d7193b2bbe45cd379fed3a6ca7c322b05e4bbe017f1f2fdd3b2dff9d641e99a3d566d6134550196467e4326a20f8d1b090b8009c3633d80e776b2179d52854d461e1a8929d1e5096dc8743cdd1cfe7ca31ae14ad046ca127e58a3097e81c1dc164bf8e17d4829cd8de665a551a0b1de6c4d5e094ea71ee568863068de987841de2327e4b70d7b87d846fc1e05d1939bca72c93146344659f71332aa2166e1ff3417077cb28429b10d1c22da1a2ffe7c673ce6ce8fa1e66f22b1e28fbe63a915a507b095a8aab9bd16244cd369d39451dbb5db4145a583f48c2d2a7365424c4e77ad4999163905a029b4ae74f9a8720f310a7d4012a44aec6af7f92c71f53f5e9a9d92bb8329157068338468af607b2e87c5e3a455459dc62ecd7a00fc3a18cfc04b5e46c352bd863720b26a9369ca080274574e2766041555b8cc21515907e700c78a89e0f619a757e999b034773ba04951e3f7b70ddb668d91c8c0698815e16abb03d03ca9813aabf069f6ea2a1583eb4ef5288d43257e704ae86f80404db7822f605e894c5997382d6adf78ad1d86fec29589e76e887142ca7caf53df09fd1390b84365b0ba89bebaa1aca0fc5510538954961b137296bcfa152db73535223a74a4ebbf9d25eb30c726e450229ec2bf5a7d06026856c6281c0a62e534a486ea8f80fd2ccf5356a8e50f54fd2677db304d5220fbfcd29548d41b91a9971e84594ee5bef6577bec7127915eb0d24ac0c82b0d207e565d5b130d4bf2f1b50230b381934c79ef5cea9f8ec62c7344b17c91b3fbbf0f85753f70ebdd44d7629623304549ba870cb87bac1b9343d114855e38c4d9ada3d145541990aeb857eab77e2f70e400ff1a8bb12a429b3647749339e20a044d26bd685974d10be43e38266dc96e9c543670040e9443eda9b180d4a8a7d95f7d05ead92a4ac3d23723de7658e57e3d5693a945dac2d5962852c65fe9eb597ea9b06b3395f5d1132bc756c03a1b5da16d1e87705053bd9ce85a9d73412ee9aab365298c5cc7b0dc456282424934ed9746e084c088c62ce9467c5b0b06338b6dd9215b763372b481fafbabba955234d57fb24d9e93bd9e06afca8855a6b057f998b3e58f3d5902dd95cca4b81591a7bd3c8ce56b2915d27dcd51679cf75d43925efb841a040bf357f0d0cc86abcafe2456937483f7d5b58ddd0dac538fa3fe2342ae65669f760a288f9f523bbfd1e24dbc76b196aa82164a287a63a2970b881454a346aaa0dec14f963cc01bf266e801828d44584e73d3b94320fcaa79691c947539aca8a24bf6d9c9c693876e5f9cf7cc807051bb4d4c21b53bd5da722bf7f58a36b964d03786e4f165e04faf96b68a74e0f09a628f297cd9c348275c32d1dfe014aedbd76714faef4d670835d13d71bc14a868a5249d5c94c8f9a698afdca73b3a0b8808c4ed165f9a5552a9774963112457136bc5be16f2c70510dacccbe8a8dae3b917518f6af4a772d573e18b947a8af60a601823eb85ca0d83d429d7ef7cd186b6f555203a9729c067e422178ac293c12158962c6c03842f021ac12960562090d1930e50943f6b202ede345de177ed4ed3b36f485cc931ca5eb7bb0efe1be5bfa857a41381c089f7c31ab085328e55aaff6455cd76bdf74cec0ad2a706c47222ff2aaa7de08e034f88fdb6c9265b4a29a59452060f064f05e8056fe9929f4ff23cb951a8526506cdb77ea32d50a8e2350d30dfd61da62ebc4e6eb2a432f6d8715dc1376b49e5eba796c7d66bcfadaed88e55d08d22ac42d349a0c736271980c342bbea6cad5334dfac3fef37eb37fdeb60db21ea53fca9befb767e4c807dfa1011ccc62113037aede8fa0875db05e091c8f49f3a6680e9c8fa10127c18e2c310128c48301f307d82286c1c8eeed8b4b3761405c2911d7958a2322a53b59487274e4960c4a06f735d8ad7a4d2086b243e3b0ce86bff94e8db98f08baaa331e85f578200d37ba309f37712d276eb49d5f1f873c276eb2e36055d40a03abee3766fbe0c76bbddf62bc6a027d0d7fee3f9f5f99e6f9f3fde68c2f6ebb5ea288c18291ee79194c18cbf30e6d66ef7495777dd5eaf1e23e98e3f4a736b0783578192086b6b558cf17d0d773a9fafa3752c924915063d12104186e973249201a62318d62740ffdb19323d86b5adb5adddee2b1d79b0c9a0153fcd39270913ac3e4511767392f0ed38518281528abf5efdc784f9b583bd734ad5ed18e38e247debdfce6ece4942f50e6e9500d46f55013c6ab09b9384e954ed2f65e1ef18c3c4d7516b521b7c2c4c9f63d57427a4d2d26eb77bd2a25d8f419fc4fea3a4a9ff589faf02d3579faf441f8fa41d2140abbd38574defaedbbba1edbb51706e551d7a77ea2675e10d476ce709c9b945e2276047d269cfdcc20ea356af7834c13a75183a9f9f801d61d09fec30ee6e97f4934713b05787f143fdb6dbed7e97f809e01146dded766fc71feab8dd6ef7e16eb7fb3a9223d8ed76afa34ffed011c9d365afab4f479d12fd3b924c33fec77a0c134f3da9baf730ee6eb75b7bdd8f1d91ee6e8e2aa04e794cb79a3e7d822e9474da6eb77b3a6a65ea79a14a7053880b7bc2f0525532bc33be513c69664aa03ca7f9d9c0565a6b6dc38dbe23377e7829a648c1a1e6879427301a3b8ae8e0338315192bb12d3562778ee7799e1785a40a4d1db4a2744520ea4bc8961874e4889385871a58a21c3132b342738351394dd92f1b5821f6c2b2318354a13903121c7632c49adb9c1ee004e3032d8d0b61d6c4a0e5c0522bd346cc6c5d34ba72be72846c25192a6709c207f69ef09495f6d219e79c73c6b203c9e76c85735416d09c78a05f727659da861cb6160491fa9a210c980db46e121b1ee440eed54a6b1cd3ca87d5102bac2dc46bba57ceb060396d3569af1abb26298a95f31496016d870796730e2ffbb53515f62009db4c59e51ea2c072ce5987a5b185c5c985fc14e2c29e708642e4d01e58df7703dfd05c36ec9448648e95225934cc98c1e2a4c79490106c8cf1d8820108a719dcbc91e2c3cd072288e3a508950f1fd28cdca0851b865c2a62419a3cc881dca93cc881bccae9172cb2b04748539c1c3abc6e13d61286858700a283e389d5cd063872ce19890ecfcb996a4e7d4d894d8d4d954d9d4da5e170ca0ab03a6269c8c25b6bad776455a1b9c585e5c50eb01c84f7de7bef1d984ae692cab173e50712ec39799003b9df9cd6749855c656396e6c9db5d65aeb2f3055689299e10c7ca179d72d87f94e799ee7a1d1aa42334ad797d818129ab29c6f50ac0de5fb0a2cecd13da692d868c0f2c2ce9a929c73b6a17b6435e51db308980f6b15e2c29e30d4509e3170669f51f3a4425cd813864fb58a191f39e79c438be79c330e1daad0d48ae2bdc0d1e520543583f2eaaaf185c52c3b612a32990a4f210085302d64de10b1b1a6254d142968b059ce535e235a588295c52a889919179048299b52662fa4d0bc6c28d953daa3d20526c4ca856bb5ad9688588098f51045446dcdeac992303435ed2b2aecb1c156b69293af88e11757c6c23651c07ec0e94aeb41447b29e1f182f274b5d65aefc0aad004436676811d5a0ec218638cb1a8d010c5a13144091324374c512f4faed8b8e0799e6725aa0a4d1d3e866029c9ca19b0b2b51583b132ca0e0d8d0894a3acaf7cc656b87a54b3a979430e0f7220c7e15b67adb5d63e7455a1f9855ff820860b71614f185a5d1e39e73cc40acd9d33946faf365f61cf5c43c32c076160a69cb9b141a8a992b3508554716ab86b1ae7d9b5eb8aead2f1f365ea862e555e806839d124376429bb6d74641bb6daf03ccff3920ca942134b49d6169705926091e2f9408b0c8e140e4da684d1209f3d0ce41d75f5ef08f28497f0eff2b8bf8bb3847ff4e6e23cba5f0924eb493dbe9d82483dbe470bbe5081e98d88befd13fd8ea4ad033109e7b89194f1382fe15714a3fc48bc263cca8f4437218e4b23584186fbac215c17dde623d82b562775fc7a093149c9fe2091257cc745d1667331898fff884a1d8ce4895157bfc7af9b709b97487ee867a965f7624fdfc7c7250fdcdd472499dec74571e90317dd821d9081c293f8b8530a177d042b8a4f7ee45e41f71e9164fa1eff7c4423a2bbb8820c0f5c1c771eb8e8e2e89404b799dec5a524db93e0760a1fbf8e134d8ce4f5126f93d1236adf587cf2230fc62437e711939464bc55a2494936075d474c02475dd55510c484369f7f9de66c5e08a4aede4692c9366d22dee24cb28ee9cbc84cb8aad3e6b3bba7064d1ffa219c4fde7e7efed56fd4d5cf9f4f1029467decd99132fe3ce72ae2cff3a8ab3bfee9781ec9251df1c98f76becc32bd9e5d0b923ff1b3fcd2f2dffc6c37193b62f6273f5a41860374c61de83ba3d3ac21507ff2a31d9f479febaaf6efbbe988f3288b641593643d2e25a5907dfb1e5d909d8e3094ac2efca414b26bd7a30bb2ef11468cf0a92e7c3a82a54bffadade9eacf1a34f7d6596bd1a2e0a6aec1f036ab8a15412b705668c807ea4655450e22fa6e5a67d7d1c93fd6ab1d9a12e2b04854837c070d4109f5a894e2b5ef3197dd8eb80d4d09adcd37ef8f7e2ac8a3cd75f5ef6d86b7f91fcfed5655648cb348a9125dfbc93e9f29b7b5bbd8a31e993e8be4d267d72299fdf6e59b8bebd86d48b7ce4db36f6dc2fc3cdee8cf1984abcfb086b5d65a6b69a5420ce5a0eabed65df53beae8db71522f59ca1e849f6596acf7448d5d5749ecd5f55d7a6facd61393741583fe2dd9e6f644281156f0a044b0ad306b089e7b62f5db6f9deff883649dcaa84cbbd6b16fd4d5ab49fa4e3576edd397e8d2d31208aea75e7dfbd6d37c5bd259cf2fd0e9acdb3c46f53ccae0698ceab6915cca696f73bc455db535ebea6b9cd3da27282655a78e41a48ce9d674c4baaac017d709d66cc23c81aedda7a01e93aae7d18278d7a01f3cce5183f926d0f4eb79c612b02f62d4c7a3b52246ca4bd8b5679164fa3c7f89f41c8fba6ab361512242e8ddee0f21f6bb2f98cb9ec5189e5f18d975da2df644a5f95a544af176d4d5af172ca12255c7e30573d9b32761d7d5cfe3985d571ffb1ec9ea7be9eb579c382425ac0ebea83d385bebf883547dfcc17e6fd97707209ce59b45cf27b8f1c6f72798a95ff10af200f8595ea97aadb7f92dbd90bcf5ebdfce0ffd10da2add493afbd775f5c9eda0ef7182255ca4ebb691b479f5adab6ff36f484a9874c78b048a4950d8595b5b5bc339bb4dc4f7e623ec55242fb9f4365b92aeeaea83180841ffaa67723bde23597fbb57a3fc0824ef7f1ee547d701e0b8346b08365f9a3584ea37af3e82ad22769b98dd139564bc9d3f95c4a9777cd30066429bd5818b5e502e2d67470146418e0b6fd43eb2d38d58bfe3dd7fefbd3731d6628c2fa698e28bf1a423a65c18638c31c634bfd9b1d65a6b6dc5855f3dc6feea2754b7e35093903ecf4f33326d8ad0a8b1153c61da396647d2da91720de120fc7e9657a27e3a53a5b71cbe09e4d488d953aeb20a98a75c4fd1beb4a2e4c96dc5aca472f6d689e8eeff05e5fae9942ad13525a0a74e9d9e5ed15987b2c2595ad1a4a6547ebaf59b751c96b78ec2ab8a59768179eb406fb73c9559a4442d28012ae5afd73bd67a6bf5112a9d32595c914e9945601d95f653b7930575ccc23781b8688b4a43389d1a992c54a04e4f8dcca2e92c54a05366d1747a5576ed9e725d3de59a2c5498b3684af93b2a5d9172cda239d4249ccfc34565b2983f47af348474050a55b24c21aa02852a5c66d07cb2443f4b32459e0ca7e0286e4d787f966488fc0b7808cdfd2213e47159645ad0f2659f40b4524b2bad14db4aebc5bbde6a2badd4d24a2bfd284833ddd4a3975e5ae9a596567aa9a5955a5a69a5d8565a2fdef5aee096c5695500e66c0ac0dc5cc19caf259c787bcbb9bd53800230972911270073db04604e8f71a19edb24a802fded2498b3360198f35a94a08e718d4004604ed7b1253c2200735e084ebc70020463521f70d3e38131617a3ae0c5c381314e466c80c4cf72cc11129ea701132898f8598eb132918131347830b07381bdd366a72ab7b0402de1a54405c05c1633a5870245ec1056e5cd981a54da1ccd29b4ab5e7c5759c504ae18279f04c05cae62b04a44404c90db096272801e04c09cb63c7378906e6b6e1e3601cc691f311f17602ed7305478aa4ac881396db5741e400298cb340c92f0280c91efc3f4b079de083a57228491d2a9724003be2b068039af0518c209ab588039afc502324f199e2a05b0b02bb6f7c5236d2ac09ca76d08604e7bde170f84045c30595870002330a72f98ad112c30402d401198cb3e477c88866e7845000d064810cf95e709008c140fa90390d33784131e01c008e6740827bc126d0827243da7c9f4785ed61f8039ed0198cb148c44f103e6b415a2cab6b967f34e8039af0af1e46301e8f916e96b1325c09cae42e0f020096a16b807869e9e1c2484d8f1d8353b79841d03c32f60b71d9d9fe5172a3a399d45ca93c57305f2fc2cbf64f1dc2e7804ac9a5305b6d9b6ed67f98588cdfba263c4fe3263a785ae56cd56a9c837a3e52b15f866b47c47941961c190a0ae6739fc4892033956a094399a5368d35ba5955a5a6da5957e14a4996eead14b2fadf4524b2bbdb4e8467b80436442ec57af303ac28e9b2cf06ba2a220be7a5151d50f2222fdb3f4d2f57a0f81391d6a855a679de990171bb6b641606e5b2f572ee8bda900c0dca640800ca06616f20bdad620fbd9f8de3aad12a2ebd7165e6ab8c06f9de2aa21604ed32d04e6b4cf522c2dbff53a03055dd41643d54bf3be14b616f583efbbddbecf368bf22cca0e7af0ad9847da5180df9a2fff5c151de4b107abe63ec102b7efd58fbdb5ceb3487b9e45791669c7b328cfa2ec9e0952bf76b7534509d0451e730394313f67d0fde1d303e6b405261b1cb85c59d2a6c6d8d9d19c42db00604eff6774805b058180b9ed731655d0057d17d6d6eab9972fb5950073b69c776f60b75b09f8a9d7122d7c6ac8155ef580b94d02cce9902be41971afc29cb61f0f5fd501c19caea012f08ade28a8048401cccda2ecf7bb4734053df75e679db5cf599447bbb5beaab3287b9d457a1665a7b328fb9c457ab4d9abb61f90efa330dcc03c6e16dd3cfecf52ccc757c73f4bb12a1a0474819f7a16e70b600e8435e1ed672906f533df9eba531f6bbe17d605eda12092756c2faeb859441d378ba6634ad388cd781223e769ff2cc3da8461664d62c29cc48499691213d6252c882c61c2a4a6be84b130f5258c888d2f6147a4bedc301e5e07a91b0bb69f651891c79561476a7801ea92c5a52bec8bd70416c407e6a50bd7ee82a509acece2e6757e965dca3ce946f889cb962d624358b0167bbc25eda98aa5a23df8597249c24506babf608489ddb834e9b02a3a5c747e965c5830c285446e7b5c452969e28252a48b930b45ea7a9003b933c1ee41976aa77af47ba9950b632ebca1f1264d7339a27180727707b23f4b2e3c9e74231c85b9e8a0c1858a06d63f4b2e505a3603669415fba8dc5256966a4358f0254be811e40895314ca444d16052394790148c703831c61ed2788c4bb0a7c74d47f88e55762ec1d6bcf7b30423b36686accc6d8354e0b2f9da7bed9b28cbc6a986383acb9e565c7aefed962599bf77a82b9ca11df3cecfb22cdff6b32cbb7096212a5f52004291b5660c884a0a463e346839928291d84d6bbf9e97b35d6d133ded83745d7b76d6a09bf6fc529c8fe3dcc7e636dbbdf4ba09b789267c489be3fc2ee96a7d1f138e73138e53e1a3a5ebe95f2d5baec7b7b82392f7775c4724975ec74391a42a489453412848823ce15e0e020c10609ff6db7bb494bdcd7b2ee882e9716e13afcf6bc9d0b7dbdc8adfc5b93b6e0cd96755412fd5d9b75e7dee7105ed19037a9c56c80a51eab75e2919ec2d3390d82d631f080a7806ec50ef06fa8e488fbe0956a082db77443aadd075901e55318b7e459be79b45ed37f18a3de3d4592c5b763e2470bf7c73c6b85c732ac0569a53bbd3715352ae613d39c5f0b55bc7dbbf4058fdbb4048ddfaa66ef6d55c830098945d19fb414a199b1c46787864d4a2e6b8409416465504d60f31305c3655a9e6e3ef258a23809fa5da1335264ee4c08173f3195182e7629c091d520f4ee40e7676b5811fa4f8f974ac93f0504c5b7b6830a76a3787aac6d69c1d95cba91116e1b4d3ce9aae579a9a1a358d0cca2b2dcceb428b2a02088e0808341f3888aecc1e7eccc131258e952c376c1c695d706940e0f8a8d1dc1ac104fc00132210e44035688407a469a5657d0e923c693425f4668892064395b42a1fa8421ca449ed90e694b5c624ce12375c663a1041c31054c2d42096c3161c80e8c1ca13ae1bf8a0c4890d9868e98065c30d34fc10e222368478089220497c34b1dad2c1c3d4912828729ca4c8d975a53d6944e4240edacf6aadb571cede5a3b9f9c5b2b6e1dbd1de28c11051152a15cf587195fa3ccf8ea1fbe5dbf275010c484d6ad6b3047b30e9b3c59648c9da4d41bafabc0f4d7317d4ae10c29e3383db9b3d0b6beda6aadcef4aa6489b2d8fc6d60cedb1ef69c8e6412f6ebf9d314c479dcb388fabcde2c7a018b152b40568cea0aac2535d850264c0d607b6ac43d6dbd600398dd0b6bcedce00104b5e3e7aa488d16d09c9419b3c58685001421bcdcdc20062e3548dd70e81143181c9c68b88216150000881b6ac7d5e981c90e438c64e192b59f7a44e07186eccc17133332ec1aba0612235fa4685185d94e24ce3491e18c5a94263a84d84d3ce8931f3eb2667003856ac8a6915d20a64717acb118ca7cd93376806ca95135264a8d72ef78ec10e04401b91a0325e4c99a138979099b51840d5f566a1e600992034c4790afb1393c3e48116707355b7478128395b41461b45a984104d85a0c7276a000f2c4860f1d48ba1479128707cfd65690355a3b9098ed008747070d086288ac356072680305ad040a2e4dc2d8a80147899c227cde802468c264cc4a0e6590b81971f6a19064ca922142e03809d2c684561a1498304b98e4c06687b766876d6681c34406316084f8f2658699587821082a24438ad090a5e644106b80f08222c30d333748c3234cd3c30b674d5ac072068d0e9117998eb4af1b67dea8e932a22b4195cbd75a271065b26d88737c31c645583dbe3d38b28a7111548f2fc618bbc9222a52c4eebe41b3d68d9bc73f4b37664f863e2767a218c29c513833f33c22ced0c0d24d0d1c4432e833448c8800c10043d566ce72d04424c428c4b90715a0c9bd2900110539d33ad3218a5e7b56c313d190eb40672c9cdd78d28d6adc13fe555ab3ac01332b239a5aa39bf4106bc8f29a34529b524aa9d2b54e73e02caa3e8baa4fb1cdee6910ce928dd9d7323f59cc59e267c926cbe38a588326c566061b29363b9ed8f48022b2c126091b18b2d7b7066dc6962ad9ecd03f4b363d2e9ee19b75d61e280be41ac1b71cbe9f659b27f98631c6e2cc5d2bb6016b436593f859b621a36de46c9d1fa4fdd6ebdb919cc1dfa68fa8ca66d1c5b4379e9f659a1920ee6799a64a47fc59a639b293a6eb71651a227c843f4b35509ee7d93e355b267e966ab04010d4d9517306809fa51a2c5fcf8d8afeb334737adc8d8a297e966633f4dc48902041a2c7a73413c34d16277e96663e3cce6ff3fbdebe1d4915be7a6abe59777e6e21b3f138141f02ba6e10451901114519a1f1a25243d3c44a0d8d112b35ff59a2817af0675916a70c08b5322a6a6550d4ca70a05686835a190d6a65576a287e966536ca769ad2595429d2dded763b8cabcd741a00dfb7f43f7cbb31ea67a46b2bb53adaf588ddd65a9f1819ed8c88661035116146040d22a7b5126564b839738ce600cda13866bec8ccc0b9beefbdf7cd073fcb3354fefe2ccffcc0e5242fc1676a88ba6ece5c455937e31918a2dc9c6921cacd191e4e6e7269268d99312b381c1aae88331ceeececccec86eb41650ee4d8882dc847960324ab01e776ef55632b23d3579aeebd60ca64b995f172a30c9781722b73a5ac24f3fafcb3249bf2a41b8140d839555427edb573ce592b8cfabafab5c5bdf5ad935557bf7eb55043656988208208a3216ae08166082238d00c71e3bf9fe5103b3321ca6895917143e68ccc1632568e944132c496d9c5f7de2f7fc9b4fede92cc87bf40d59691d1e17702949ba8c4eb9a2a6a1022c50810000000c3170000200c0608244194244110835cf8011400095a924e543228a10444a130140c8581280a621808821004621004a3108603599e4379006f08f625a52f948835d9a91cf4e87e805b4d6f4df601d52d4ec33bcf3d2d3cb2ef4fa9b91f13e453a7286cfd7e8fdac537da566343a7491b1cc373e4b609d88932d64caf92684f9c1034e1d0a249b244afb01cd0faaf5e890543d89466a24a107bf452882f2f7655c21e63184f5a1211b5b7854fde71975188f7dfe82e7626de93b73ab7205a3e88db850b9ed2700fe052e8227d43892d0f9e0a890df5a8292dfcdd9c319a368becad0b221fe3d33c420a543c767b20ddfe5c764e092255a42feed35312f4bf3144d892cb770951a74d32648585e0da50e8ab43760ca2e7ce409b4da4706f4b8b06731862c939f45b5a5aa71b3e8867c6f5ac641db00cd6ce4e1b222e12dfebf302f45ee3e2d9ac0cc6ad6d7d4ab823b4b06a5fdef9ad22c8adee66d72d36d8ad786c782661414b245898c148db51440d011450f010ee8398131faff942ec5208f7e5ef2d1ccc21a262a20cb37a500841a3031097ad9f31483a2882124a7d18101198160045036a53e505710e7a3168e594c5dd7f64d1398afcdb0fdc23f5ba786357702997c9c5ddcd6d5dcffdded81ddeca7bbaf9bbbd6df7bfdf1bbb83b7724f377f376eeb7ef77b63eef0566e626a3f0e16c337fbaf1ffa39f18cee60f6c5246bbd2b22f01f85bfecebee5079eafebd571fff9aad298321a14848d670ec65890022d8cf7d4f62be8c0b3618661945fbb2a405c71d2c938fe25d95ba286e9d4f2331374906c68f5be2daa789e8528d054e053941107c14d5c678e05c3ead5a18ec07b3ec040230766313faa8069b20c3fa51d5e9eb27931cdba7796860e2f58cbbe8ecf560470f7310e3cdeb508a3d87de9a87aeca0e102834ab3e11b9296e0a3a9b298010e095f65f4ba53c2c2cf8600b69d2458dc159b07a96aba364a935308e1d0268d2e6f9bf189eb43cb4d61926a1c0073c3823cb6b7d376abd199cb3532de9876240c4c7401d9f8193c9b93ddd927f3807637c0cb07eb8e2639ddfd99c5bd22df986b29663626a20a30ec9ce7826e278953010f7f2300f5556f619473fcf97638470f9d64532c1b2e142876991e660667e5105037cfacab5670b835c418e009bd1fea3aadbc60b0118995b0b90fcd06d804e1eaa2005c4baa5e0ec0a7ea697e289f063f44252ae61e92d5069a44c3f3c0f2c192f8fa8edb0c10b20be72a73b5ef8c765af2c9941fc0a8db7d2d321d8214fe2c548ba653ec3cf7c25dba3ce1155eb54748f790bec9e87d2d11f41e83414c1a35d1a17c99e47ac3bac0a1b3757a0258a3aad9b1f0551b16ddf8498b0eb2715daee53d45e4772fb3dd9fee4368de2ea00fd45bf955bd2b4dca24bbd71975b113df686187fad43635358bf0fe976cb36f3cf86a3de28fc03cc35f141da38c9e6450a1f4081578f3f04301d68b7d5a2800960bb15471668714417bdb2039d7b2d2789f11ef588a2381ec7f122d7eebb1c3157087cf1e884ef48f14b7a032a4e607fb04706330273e0dabb033e68fa6725ebf0962426a4d04df6f55eab0db04f1c406dfefe849aba0c61ea22ffb307c79d75940ece2f8cea004b9826b80a72533d1a795a3244c3fcfe326120233d650a87a3b4900d8ee18e7b59a8f7ad35e513acafcdf96cc1a5283cea440c46a326f85bc4d489b05d0de1db35b54b76e4b31bc76b159c3f7ff51e1660e9e326cfea4e88e5e376b2152df47b7386967e694e57f1775a680f416f8bb63f83ae6219b423a1f5739e91e0f645fb4b84a2fba1039459fea0e70a618044bd52f66be2a7c6b2e2f8b9adf6b2a3fe8a3f2f3a7ed93d59eb3fa9eb137a246f69f18415f05ff76397fecb955367a248a54519099e6bbd81a0b21fa5270b0b85ff6e7d993e6f75b7f67aabd8f9ed41485f237278ade530d445bff18c75b85ff7fc2f9de27be68f78e665fae71601be0dccdb7ee91117f18fc46ee142690239f18177ad42eb53847210a930bff3a0d56d72547cd9fc03a30dbfb49dabf82fc7bed842ea0f92e9d0f90d41b320c2e329d4690cf682e8ae47866d63c0c00bcb07237ebe1a216ed20cd2e9570d3efa86ff968e2f962fa923e2b15671157ab70c8fdbaf07bb229e33c2d132922d035f529dfe292dfb8956c26c632bbc66fcb21e435e7409d3d27da04ed2aa043ab300a267fedcf7a96ee874bdf6ab1125ef22a33c8a36cdfaee5bc0305c94604e52f2a4da592a6a59c1f4ca2c583f0c87459c07c344b4a48de1dcfd77d0f08c464f42ae4e62002637cf83a0eccf104d644ec545c9582047d19b027738d00f2ed5510b93c27be604146f3d95e207f8dca8eed6cee43786779a57831fd86de207a99c683182ee11bb6e1acff97e521abdf913497f063ca2e616dddb6a2bfac013dc1a982ee576bf4565af01f4cefe7412c19ad9dd912fe737913110040c4de2d85ab80db42ccab34779d582a09e8522a70104c8d88d12751c020224d481dc7651f0bec65e745638835c539c06a90165d6def00526e1a641277fe3d17aad37c3229f345c2deee09107fd449ff066d17201a95e194cfcbed970359ecbd949f8a39a83fcebfc10b75d046603bbf8b83f6dade6e002116f63d82f71f9c3784abc1c3f2a252faeff43631d7818bfc486e057c117587713b4b5b11c6989e10ae4f565520ef49d5811721a5e2dc8033c90f31299b78b83721a3a39dff6dd94a441374635b66b3ca41fa23fc105447415c0e561e45bc2755ea714402b7e2e1bb4dd55a6866781b6dcf21d705221bc764621fdc95844111d660191010ae80eb3170c3a47aefae9de817d421010892f9af0af0086fe30884891fce2f9f14f4f8cea0edc00bc96bf4a3e32704131b6aba03055e1135c25687890a19cca4b8b63f20e7842048daa4534863b80e3d39a73c03d12f49e8f265262a256f36651730e8c4872ff782a1200097d92203e24e1156ff35937922443dfac89d4b6ec80164959c4373830417aaf5db1ad5df4b2561695b89b5dae157857c1f0b69635107800919e869959546152853edc074579282773d03043e8f9ae5d1e5f4163700e5441bb6fe4c9de9a663dd70d03e7b0915db4a6fa5c582c71db6b0a0948c4ab3b4bdf01d249a5cb5b38dec3da6f88c9e2186f95c3ad0425ffece3e04e380fcc166865285e67d20f4c6e4c4addf7c05fc1061f13841a2982ea494a8354d27827790d5589d111516ae393bd6087192577c8d57dc9969cb9825debdfdb12fe70b5134ea01b85b7f14ac0bdacc11adfefd5baa661de989898fc06e6592c00e29700e0b32ed9bde950fc166dda832ad7ba4331239a281e25a61337fd5feb61900e036470920aca9e2d67c2aad8cf4727f4e613dd3f02c7f802c19318df719d543fe6d3517ac181a6a347b4ebb2f9507367149ff3895d96740aedadbdbd2f44066c564a8036f731457f571b4c0fc706b476c29b772ab2aba1e8f62f9d43a716fc497b602f17cb4708555721f80ca5a46a001f17dde0fdb01c7b771e1f02d3cb73b833f601f8d5d108c43fc9479017dcf36f242a7c4ff8639b13585c9cff49e3d24fab2e47253d7f39cc9a57ad2546d5c53fc6f9516a2b14f1c31f832dee4196f1edc98d6402c949e3a1e7cee8bde2880bce3a582f209ff609c7f1e285ba2c60c6886b82d9b8558c6120451aeb7bc254adc7afa8ea87ac48a52f2b949173130f1eb32d208a10671872194d3cfd8d79fec66015f1ac3f384426c6396eb9eef3144e459c539b68e9fe79d8f0295c504e78d58a5e0377d513000b0d28dc92b67c765a906168544ce77bcdc3b5ccf06758c27c1641103c5b86f0f5483424d44cf614894a71e02801eb2fa757bbd5c0a661d40047c8752ad9087c3aa2e42ea5990d41a63efe3f40e15f44b2258e3adca0c7beb74b35873a70395eebb7b138ceef7e8c02f9e26536f1c4ee7234bf51034ce338f65c04fdc1c57f08f0a72a884b225e09833430f5d2565566edbf0f28f8d7a16097e31711f9859e7c9815c63f17e6f5e4c8b3ba1ffa74e64f602ce27fd408967b8d11264c8b0f283fbcaf3a4751981e45d2ede514808974f1599df6516e71ad2c8a0ede32a0350d1abdd6d238d537594124f384f6dc7bad8172ea026a376b5d4ce47b144f6b861249c80af9949c9807850ac769d6c7d57bb00960185c899fb79acd3dcd896756d5842fbd2937c437d3413d517f06d79df13d9d0a82a310577f76115cb7ce8f183a0488c29acfbb2270c5dbb873d63e651fc08a0a2ea50b9300430fa204f4d527c93bc13a78f8b181254304aec9919c15a1b27cf16e80fb954c301857b01e7f438effe7bd7d9f1d9b77dc9d3fe6ff58269d59e5df21f3bcf57f2cdbc4cc43bba61feaec9b6e5e360ecd3baec94f689ca7ff694bae5b1042127e91897e3842438bfb517b16cb48c9194b7d7785cd6354bc336d879323a2355751bf1d66eff21d7393752a040f2103d5635c1a8ae0c790ac8de30878b64ef22a5bbdc5fe652e9668de6c7744b258d21e2e7e9bcd199effd4858c2956fb182175e66c579809dc0b0abeac765d1b637818b6f4f32510c672220788b7a25b4e2bdd2e430f69d893881d4ca51d274e36514a3550436939f2a9c0bd90ec3c53fc63664a4c3038714a5ef0667cbf5b318b15ca28eca3c3c5cf206da3273f211cbf2e9f8dbf5bfc651ef5021145594a72cda05965ba0d5800692a8b220f104db55839af75c0ceaf16f4d499025f029762a8276271c3413a21ced80f784aed850c286ed166c69744c0bec04b0088202dd3f3cbe6a7ddab11bd9e4919eb08510d48d32638a3c97d01eccf7aff0d902d7935616a35392fd9ff1ff6c3d0b05bc362c63d466f0f087015abe01b838d07bb5ccda1a6c653a6d3d912098b8414c63a9bc263260a889259724a895f4623008181bee3bb060e97fb40e9a1c45f92876d28281e855352949800f2f41410638338aed668bff597401d05a4b7132d88b4494adea600b8e511fa8103bc62143fffc39ba50b69a32f1811fd4f05c3fb3f45e312e8aa374494acbdd5ebed202d3e5ad841e35568e081091c1ecca26a4fe73c74c644301117a3faf662b3dd8dd49055d05b1691958eef1a7cb3e95455d8712745743d274070b67654a0f242ba1e3c5b7d94333aeb1886256290e8b0383326fac8cf4d4f6855316046979c9c705c4f6d8f85dcae983952f8a5a37466220985a8db6c9c79c81308fb1603f8afa5f631d01bb6b1ed0910498fe369f44cfad48fa7338dbecfff4aacf5b4af05bb3ab2bd779c46c139175c39b00d03844580f37bbd0c3974170a42ff3a77781003b754ffcd2c21e82f7461f0522396e0d3592ed83ab75a7ddabd88ed66f08e5b48c6124963897a829c8792771e13b8ae9eb53f7d2d3b05188705678a5f4a432cb55a7674f5cf23d34994b377aea71cb9c5b570cdb2c60fd22103c79908875410eda70aa732f0b9f997feb18761c70c9362f0d8ba5294b580f534d3925f35b0e7d3d9a1250d7f05830894ef2e45d06db64355b1fe17b0a388429ad61e864c93b72a1ee94bb5c48c02941a578ef17a81c0c965375f333dce1d7af1b58a1899265dfd8d866268ed80ddb500f320475d38a06459d4879be976e8fda7f657846a8e822293dedb4e89a93c7a965e48e21b58df6d4f019480120112204db01082eadea8d3587279845f21e9fca1ff6ce0425adda94afe106f2b3089ef95e088eff329b3d69b1e68ae5c78836af78e2af38f7bf3cebbffc7ec138bb4cba69fb5fc3354438a394d721b5b2bb9218d98409ca79adeb7a8ad271abdc95e036a34de06410d5187e480ef7719a17902fdcc970e27903b58d10171efdb31067d98f72605021ca9ba6fe8316d59588e410edc4e21a5fd58687113823b94f49b6f8e67d06391640dde45ece52890794aeef96927d9c6f826c584b880d8b25c0702b888558a8896dbad6135035c70c2826bdce0f8aaee34beba7df23a229628c9487c9b814fbb34384bc14e0f9d1a8b25519c376017ea0522201a9002ec2f0ba8b1d98903c7ce8387106e0485fc0bf9a25dc0c3028ee35e65d53e7a0348892393e599761292b3b4589d231998ce01d7d70813711dd4e8543bdd9c631aa84d51462dd4c85dece81a6baf4791c0f0c74fd7673827b6e8068f4313b96f4006b7061fbd7e7bba679b3c6cf1a3984d9d318b2faeadc4db92dbda621a0f8fec3b8887fb4332ab5dc64aac7d0e9521cd3a3370c6867b3cc5846a21a1649a76734af2ba22a2852ce15b0ab53b6022d3f6f5c2c5d52f6d20299302e737ab6aa4f788b785c19fdf6284ab9bdec3d55ca22c9039e83a809b2cae9ca098013dbf489fc3b7e8a3fd68ad92a2a47ba26e478d49f9c55c0427a9e2bc970e8c80465b30ae794be41c338289ab6102a4d108059e03500fc88a65b5307f4efff528134fc3bf3ed0b3f6dda14faa9a5218e194d6d2beeef229795c8534313b9be8a29e56f3d0363cef8814a31a13b873615f56cc4c4ca0cca8013ea56a1632e52de396aa9dab565b15538221aeabdd3094e22f9554fb6d84e3e2d39fbefd30adc835b8d0b9b7b96ac0ae194b4e2612a466f1078bcc59e50bf17330882382284735daf404e55a5e710cb2f92e8e21269efacbfc9171798ed1a39ad5bc23a59613ede5be283750d64b3eb62cc2b49e8201a62a2a3f255668d4f75585913144c832becdccf64a1dba7494d94716e6f695e73185f0529457e7c967493cfa6fb365c50df115c33aef0eee52c07ffe50384a208a9662347cce083e28c48bd4ba36a9f185f4ef91a3bd85fbf97b6e1c96b10f9f59ce03468035899bd61f9753503a4d74105935ea8c2cbd206ddb97d5a1fc1f4d4558041f427a0c8219aef47a1e05109dceb79e3eccf4090d4520f599ed31346247c5aee8e09fcfdf8b4d84cbce98bf32def5a5c2c455c672ce30c1f31f2d3fdc21e5be3bd85555052d991f125e4509826ab9ff190ed51c7b959d636456f20111a569fa29075d44c58df552227a5bc2815abbca36f535b5ef380d14ac95826688542774e5b7bdd7f8675e6a0e4e9ba85368164a4f508023811c835df08c85fdf908c4f5f5c099ea6225c7a1380914a33c65c5287e392993afc3eab4a91baf82c4947ce631d09648998f534f2d2780d4f4e8b2464cdabdc7a5ad5995735a44b080ab6b82ddab0f4f36466665929a9ff34565ff06159becd0f696d7ac246c750e36d7a6f7854b9df58ca295dad97a2066af1ca4c706b341b8cd5d90c5c5dd3f85042707b66e47405c19ec9a37a7e9fce015207a761c932f11cc6aad441341f29dd6b6833d490d4c6437cd36947fabf40cf55ca5888498d774033adab5d92e766807896948cb1dd4029d3278370a24e8e28c8884117195254238d531f6ddf04d634f8239745707938c581eb95658582266563928be82482a1f22c86c4994a14c3c12a01d70d827703e090b0caabe13f34cee6e1bf6ce3747ed3835589e7b1a0e4d0207e3bf03baee1a4f88b1cd9b9f229ba0f47be70e85258a6759d36da31e27c1f017480295217f2a5f6af7b026246696c99a7f8bf49122ceaed3c258514ee00fba085f6a2bee10d69f2574c27be352b5389b1f7e1232c055d8fc5ecba40e36785dba784f59696f39dfaeb18fe6e738f2896b3849a3122cf36292fb9ffa108ee0a140b0a5ed177c06939de4ef1db3b6708707d16b094ef7ec3059a454d8d443da37d1ab0fee2bf4c0cd2c31cc6a667840df26d690dc65c78e14d956605ba29beef803b87e2bd550e101b0706cacf77832b56674d5bc429d5b9fea85a919e12f74d64ab2851f54821b9f84789b187dafcd813a4d73f9bb7a869ae048d031eacb48bee13485b910d88268bf068d753ed9b9bf62d2d2bbe9229186e82b3a24a3aa10cdf4045484ba4fd0b0c96119535c5835fbe17d821fa3e76e016d5a67755f9cf9d98010b50c95ebda505f2754c3ee2d7b38bc398dfa81e9d4b0dbb3a38c0cf2659db4ac786a216fabb604639ca7833e7d39011c742a12c7dee8cc14a3faf8b43d2a29a69c6bc3e1eeba9ac3469e4dc672b360dab155c84db6df08ef16b263f2ef264bc56092583431252e1bcd0c7e4b8b689535d6cfebadd0eb04998ab505d93e3c2713d4f74ba7fa12f429b674c3f3fd2b11369df79667840c09d0c53259edb1b9e99ed7c9da418b9ce3346b03b80d8d5ed68d36745c12339eb03bfa0f9f47581dcc67393091525429b08842a16d53c57211e606cfc9d2c64923932bb2560885f8ed8149b09ffc2837ac7f654ea49ea2a03fc457fa3c98e78cb4113763aa6cf85a6559f4842269fa96b19026a33e0a93f7fc4f42405eaae74f2f9b3de7582af42db3ad747c5ee6a72b28e36ad50bdb5ce98d2f9043b6e42de9954e15c8f4f1686ee2652273b9ec7527b800e4b2279dc242d4c653b7b8934d6bad3cb56fedfe5ff560f2328160d4ea4f30704026f3974125939392d595cc7624476ae9f66ee1997cf0d3e395e67d5baa43af7dbf596bb3380341314081a3d82a0726006ccc1f4c5ab85f70585d7eb402f2a13535776807fde8cec59141882cb347633c198cd31e6a60664c4e749f18443fcfcdbedd0e52c4d1276440c47d8ab9dfba245bce3681f83f552db95d4e9e95883d007032b2638ac1cc972e6a796f4852c5f3b69b7eaa6ebb26ca62b54bb181533fd6ee5ad331cdb711227589ad63b43254284f79fe478acdef813cd26b0f86b3b093325f2412e1bf68589c401080d833fb97113e741d0e427dda0af9721742e2ee89badd512d9effdb9cf8bbccc1db77103974f07ac4512ff07e39473de93d8593be55cdf78c88fc91575aca8e387dd5c46f152ea3fd14ca040e65e1d7e48e74716ec3a4df6ea7604b5dba0eabf15017cf221eb846a7e9545953906e3d868f366017f08f76d53dbdc550363c6ac6f57e19cb34d19acaa6e8adf510967a1ecfcfc00bfa2667a78103d3be1fccef7d0a61a66ebe4294c7563633f99eb50c38c4dee1f1fb9558e67478e072efbc257a454a716cb1fb7bb1b9905c2c55a9ce7e0f0110fd853793a1c8082feed4e65462e3b9e49eec511e0da82171b0baec5ec8073600c5abec0d3e1d482a71f73c42cfafa8f1dd0d63fa3ed483dc1b8a87698eee95e6b9323dbdb1f2bbde05f48d0d9c7e4e596e30da07422f458b3cdb8827b41d9c9d3089bd1cf1e9dcfa429c6dd5c2f8fe5f20d151761a73267e07ae3df15aa6ec951b0f65d69db94139fb9c76ac6ca00db0893dc880b8fe81e8e1f900787f90596aa97dd72acdcb00ef67438046e38096398c53349fb95a6919efac8d03d14c41b183205d5568cf86f7e36ad2ae17ebdd3abe6ddb00ab775047d3cc8807c21cff016025ff9f145ea3b2352e975cddd8bae00f08a0c123ec9cf2f31ac75f45d30ffcf9b5d65d7e7e338ff5f400e80b71ba45eda3f60be08d71c484c8268b26ebeef92ffb3baeccbbdbe0355bd5fab1220f29c08eaa40c96a8aeb53fcdf4ac84585dc372e95eb1e6060ab8c6730b4ec04d05690966679167e79862304a8fb717f4d05432a9ab6082f7d35e8646cdb3eb69a31bba7868870b7871ed44826d4fe400f1c5c43537f80173a49a1088f8abdbf171f16e41368d3dfbb8c7b1cce0a85232440e33dbae5f61fd7ddd17ebaafef2e5e06617880c0054e000b2030fbb5ba4a02073aca13eab276c1e874c376e2a2b76dc7d4923d6905b65245297165d41a55e95c30e623c0b2d8815b5c9986bcd801706f6b9261fa9b0d26c1ccdb8e283639600a9d283cc8e4bbc4b9564ef7df332bc4f9905797a26e05e5cd7af38fd655260c32ff83a26ef1746433d23dc61259ec835af1322767f06703f2e6548d858321e4ac4939f8c2c77bba97c91677b3607b231d0c774fcaeb9394dfdf96c9a899341421c90f4e14758c8a9a048d125aff20669fed7b0d474bd44caf74b52a336a671c493db06c7c92a8c1f379fbe2a8382bfac44d244fec0e84cc0d61a7c30798093b78c538158017f884aa3347092aa17ea04a0e3151fc40fa48543b01e00b85d8a71f6aefba7a299a49827fbe147f9ade3a0f052cec21a0b5de196599f4fda1f050e6633fbf267be3c63d997e12c00f9c84e322d22c6b94a226a31dff4823267a748cc81eb9ed25589685e524f629c5c69ea8a3fde99e60f68bc92739b5c6e76c6dc1adb3bbd7ecab4897e753241a8098f1c2b97dba8bdb0adca96f9ea5e608509c4d44dfcb60eb73f40254aa577c1bcec7eb270f9d07b4e5dde04b9cfb41df49120dac2efeddf431725c44bcabc887a98bc5d5bfb7e873e442bb1dee089a00b955970bcec608d2851637fa5d0c11c88b5727c11fd2becd04cbd493c666b77eef24949390b5df72ce0fadc30eccd3027f67a2363fecbd4285becabbba57688e361fc1822ab6d1046d67ec5c44ee785a1eeac309296fcfe39b33c275e7e502372bea67d7e4b8899a573198e0194ff835b19bdfc91ed42687dff87fcce6997338d735b1c019194e72f9efc8aa4a2141f45371790d2a6a4c9b5b9dfddd693f556cf28ebf758ea235268d712fd9a9f1ee0e7efbc51f7ea49e15ff3cc3a138c00ddd0559e6c9d93f649937516b4d630667a2fdc345c1bb1c1d218e5bb96f924271bfc2c359e6089f136c68330eec2d46c3afdea2ef18aaf9c35f5b12281635f88c8a6ba24b62dba60682027f826b3117365b3ac7b37da680a707a9f955f98fa417fdb1589e36a471c4b7c7f66f9cf73a619885618466a4db06782bacf095a564ee030959ea4a0c4e18f861e0a61c657c2afa8ee3a97b98e67bcca8bff16d76769cfddc16d37d163f74691e65e79b790ba4d3624cd1f3afa601b50cd72a52067077d31a24145638b9269ffae4ff9564d2388d3f63f917a95d3407850b3cc464737060a4bc6bd79937ce2498fc21a0f56963bcc95b34e578621b9246604a6eab683367bde78ecb4edb56aff1e3f11b71cc3d5bc75279babf9bf726c96ee469eb290793d075066e2142fe4d03c09f9e4da606077404f91b0382baebe1513a7c9e78fbdc9fe4d53bdd50ba2e3d8e2ad7039e61d23928247b29ed788c7fbbbf2748197c4dd173c5576c6443d630ba44f702429924ff2751666fe2d34e266eb3234fe3e9714c66aa2bfc16cd54bf02b827a6f16e41a67bb87c8a87ffe9233faaf8c79274eb1ba74fe85fbeb8c2619975e415e60df508bfe7e8c8f4cc26e34f0367aa1070505f414fd9897f828378f7993f380e0f7b2d672dd2fc5df4cf200607f63d5a4b0caf05a001a9932a53b00a8370802fa03830a95e4ce2578f304746103c5d9b605f0d6bc60793165b214dc65e507c31dee160af1f207ca541d98cc67776368152f50ca6fb84ab326283d00f220a93e7c931e615feff41bdc56f73a73be4ee12531407f25887fbe693b0a4b6aab279ee25858e139838c1ab0404cd9407597d45c833aefaa2771760946c16f1e3879a9b4f29dd8c95d8e713f11a3a49406bbd7d6d828e0bfc98bd62cf1d1bf8e36c4725fe19941dc9937e89e32f0cdba3b8946c7da54063260ed9df879c827c92a529796c412ab0c889999c50729d28f042e0112978e7811e2a5c42fffec9c68668d577d89fb78229fdd5d97238cb33259b33c700f8ca52a25209ec3e10c742618e219105eb9bb6735cf6f1fddbab1bfd0c8b05c6e9484ce5599a819779a6b81c386730a87e39ff12023df3427bb02522f80456bb8e2c7bb6d948b8810d8a80acba3a34ccfeff4e31bd1c2671b0e555abbe6b498deb0a0d7d07ea096fef8ce84e4986eb8b7004141642c85faae28193616c2fe7b76b9de48db86600b8981c5f6ef747df083382c2f47aef577cb4346547b7f43ac0f41a7372332f2f3234289daea64c95c769769895c7340c38596cc9f5e31bdb5526d9bb24917b5ce6d354c4186632a9d6299e0c8618b5a2fe36eec5e37f2801fd6d84e7ca462385a1ac58f486fc1c9d1832ebbbadc41a3fd0f82503eccf798388548c348210cf69f4dabcb6f3e70c332acdf7a5b54a022e98a81fadca535bc7440f4a6e2aa361d68e3cfc733f679cfb2120f07f63cdadf67f5bf748a71d19d664e555f76a3c7e4614c97555f232439625ab73c0d8feab4f534fa91354acc90dccfa886b3e71e3454a0ad183c0a486c219122dad0c7488d17c88f88f53d65ceab9834eaf8166a982539b69b8bb82bf0c3b30e9a2e61ca91202752277e207319a35691a4f347bf1d6fc56190a3e43cb59e447c41e2aaa2054d3fffcff323a42789e3f6218a4c4162bd1e574121b69294acb375c5da3b70b8b010bd8a629ae64054ed83d63802813bc8af9782146efca9565d7d32ef466cce972964afc1b6e1190708292ed48ba12085844f6b3a9d5a31b0b2641271378b5e5d216568db0e19c735932d15ddf7ec63e91a59de4e3797dcc628ddbbffa20af29563e64e78313e4f2656c6f57ac414730df464ff451e603e5bd2d2b8bc6ba62eb3b2e1e710f20faf2a0c232f4f4c2053dafdb14bd6e4fac6b212e81d23f510a4755e8dab7e8f543303a1494be1ed505b366f28eb0a93c476f02605e0ca082c928a91057112c11d02a602c7a37623cbd4d599da03434f1884fba8701b9323c642f0dcf983e39b5f682e014eca3ab06d1734aeb415a714dca15188dd88b473b5b06c985cc481f4e96ffc4d54f1774d75ffa9a7d58fa7bc53d5bc7fc4e465a9d8e105900ad074a46ad711521a3d4d5bf278acea9a887ef789d962b17d91dc082783d0314f67e4952dc5e0cd507af0d98cc92ad91f6e2d1b14b395c70f22494713ae3cb38ed9e6028e859bb379fddde512295d8220cd7d16968dc3d7db1e81f6575a7a63988839cca6ad3857f1198b2054c4a775f756d2c3fd60b922ab2b34fd3065cb487ca5b0f19a0ec198a45fb2b4b9efaf8dc82a260a741c148f22acb2aa7b6ef0909eed5f7292bdba20195ed81014e2582511b88c7c30b7a0334216555d712149fa73c7cf034a6363c3fe1e18687ccc22fa64160ea2165933a4a7a09033a2a4f71945ac18e70aa68be25493f37e19d9e2adbda64a9b3db6314c47461ef63c69d024d5d1c9bf5ed32a350ef6787b722bd483e131a1eee097f49508e45fc519b2c0780bc95f0caab77379de21097aeab9e2cfc5720f47fca642370e17de94b0830632b1ad3a28c98c76776a019d3708d0a6cf276777330385716cc014e04894fdf4c0b52cee7d30bda21a1dd22d4756847447b57975ad120205f30ccc1900a5a0b9b439e46428b168c2c05350ee1c4061e7c4de9284aaca9b0e2ad5f19fa3314c26ee93a79b560a91645ed7a6774a2af802865dcd6eb6ed4621f96ede841c6434803764c3bcd27cbf92ff7ea5b76d77a40246c274cd83f37d7f3ed70481a387e1fd6deb790004dea14dcb062f3f5975943ea801e12887f364a76a8a0ece689b2c1d589ad60fbf6b1e3105bcf3b111cbfa39f6b01af73e4cc51f2162631e79202452c805423938ff5c1685e26ba5e0882f6d9e1eff0c465a5f571f3a181a20dcaacb49078dfdb9bc9aaf63d25d46c9cc683c352e40d1e19a929bccdc4a6b5125d2a7929477d57756cbdc1e9a3e72655b5029aede61c395a29f566ee33bbe66b0217b04c2597e4cd0218b436abbbe6d024238d08e4cecda778d6e3e50a5754689d3bb4aa8668f1bfa0a101dcec9edbeb730c6dbc1e83264ab96b6ee75f7ca748c876f72e3bb75f053c879497bde09092dd653237a79515b4d856563482a13e969ccc9d37a8627d7227fa78a7f8a17939bf92574aede9e7658a80dae2439228f95b2e3e2d26e29583da6b80d3cdd3d23f025729a2322dcea557d531583ba9112dc0e061bda12a9dc07b420d6f7d9ed44e0f2eb8eef8fe34a96180e4ff7a3d51a365a2cdf8add5a7569f0e01a2398c1413d3bce43134b0a43db1dc09133ca6b7b4813b7bbe553aee80265f375a0e8b0219bc710255e9c52199b9de6547aa4da874aea2d5ed1552e3cd13102ec625861fd9c0d25c9b7908440c582613b4a061d8b19611b0b25eb7f1623a2584ee9f5a64fb9165047756f7edfdefb841b41844546f918e694e2c46b278f30801e370da56434239909ede42d6f5b61276759949c9f9ba347ac972de480de83d49d55b2c10749f41da528f1750508b263a956a5d3d3b35417881bd9044a97dbca8c956d3719e38f34a9767082a2eb3a299381ee90cb65485f76c76848bf3f47ba156fb9f9f2f0c869f163b54f84583fc84e74c1df5f0e5c708afaf324d24dc20ab3f8d0516f30df92f869c4a4100e318abba7540d5ca3bac2424cca56c053f0a5837810712f9462fa8ae765a5139f4005d0b460f318aabff72a651fd6b4700946804265eac12461b7703386c04fc3e4904925df87d8d7e35e9bebd192d8fc1c04854d81f9b94d4c3d2196e4498f85067fb1f97fe7030262991fbefd912909e6041cb7def18c7e8ae85aece40418ccee42cb1f1843327d60f1ff419316584a2a67771480e89334cbd1a6b33fafe419f10d55dc34c597003f2ba75043be6a725f83aed41ca91c8d709fe780145f4201a76a54bda0cbd22030350e89a3116da16a6a6ea7b763eee767206d057dd10216c39bc1a51dba4d007b23dbf2cd6325c8ad3aa82d6cae6a5287806447dc143273f500998b85400cc27b350c27c262e0e38f0a50033e5e4a9cc95587d6098fb1d2bcc104df3f1f5e8989c8dae1a48540532045e742987591e2bad48df05036d30f35ef3aee01c10d983dbeaa944ce5f3406a141ed59d5fcb1561397129c48323a965dcabd89127ee444b01ecc83aef5a2466dd2fdc4b59a5ca3abe50477f42bd881bb9abef562a7761f9eab54c04f6af33eeef4bf240d158b0488c4c19376ddad59c4c01e8d59bb022824539e7a00c67a8ebc97a3aa9f582c3ddfede0fb47db07f297a6340f0a8e9651bf416fd3ccabfc12f69ffa81ab0cb04817cb566ea7c6f2e98109d278cc6552492bbc8b6aa67b885e9f38694f970f7504cc35091f20a97ec324b8e912aa3af3d03701c0137826aac74c548dd55a05c75323a0f950efd6d29717d2ee7414725c5da0660791248fee222cd0b0c02dfb61597e0ee9e51b809586e01c1390c60564554f1b9d0f1ac86a74fa59834d0ccbf386a0cc6cf644fd97b4e795990e53a5cca75f7a86dff1ef33b8deb8be9290a7da49805921d3ad50db89d1a7b3ad1c7ae03e2ce9642f69993c144cd8e5965c9ada5c5360098dcb008d84bfb33e10002b73616e34cfc076ec826d8cc02879b42f6fc94e501723797dbb816627ad5c48f7e352794feda0cf77fc1c65e4dd6e4010efa061c09d56e7ed6e8e114676b50a14abbad14cf2a664127b9199d42c543e5ef4692b9ff5821da9f9b6891bc74880d07a0953d504ea3b5d27fcf6d062d1ecd58f495a60458a4061ee440dfb8713b34cb5065eb18392851c69c52420a5b0615ec80c0ad1e54b7297504273aae6a4c434b2b83ebca82f80870862959315e11292a5a8414c99d6b1bdbc7ae66ac0468a39ac90342357159307b1580b2883b6ff98b4e0caf6f8816f94e94a0390493629de113ee80cc56670866aba0ff70c43057b0921eaaa3a313cd090d8862b60ac688c16f2731051c1844eaa168335b6e884fbe093f1ddc0c707b714d750aa4909a91523a8cd9504a2e3a20c0bbffb753ba4212cbd3c3e0e0ebdb6a6be818a149e114c5fbaa9831ed830d80196a00c4be9ab8d4e2f3c75266288936cfd0b27fe1adfcf500f4d2cd736165e80b765598297a57f28ae75e54480c96d3b4a39206f9f900f993909c28697b553601a150d33fd921d36425483618e00d07b953ca7a5eec7b9e0cbf187b6be811a159d0d30bf94e3e03f209d3066dabc90a71c92ab37bf6c8b1726ebf32adaa58b8a9ec1ae9d3b0d5df3a504f2df55f72c2c4c7d24405b55f81430a339b74e40e4ba5adb599ac60b1934a785ddd2b7a8140896571ad23c2038464c8f087d4d3c81902a14b282695f3027ca72add8388c5d21b8257243d666eee44ddb1b36afb76c05361bbba9087ec58f3a9f5a993fe467d2b8fd674a66cf05264c09a52ed99342145c9615b3b6e2eb85a6e2ef96fbff37f0286fe2189325627e8d9338f4805d089edf52626d7be864964406fbd39ac2ba5e3125592a7a338d4a5808e9b3961de474701222ed554ad18bea31b4286b9d2f2f2a19e34f0f71ce6136cfa5849f05032660014660e830cd012dc1445ffe19ff4c158de1216496446ded1793c296578baebe6c4d2e07faf117cb0a52250589914f2da356311186b53bb6bc2a36f2e43cdbec8114489f9e1e128f0eaeed7b59a531fd45e91f423b7a26e3960ce64cdff14e48898f806366b1ffb6a00468e6095034103464d86b589ff2bca59d92467f245fdfc69b034df08ef5f56445abd9f50cbdc19e80f0e55c6dcfc6d19ac5bb598e5183ec69d7767f5666599eb295c1ac3bdf2e735d86f094955746592928aad4b2ef59cf815107248a3cb00d62141aaae8f9c3a84322e25f1802030ad5114f6b4c7f20ae4d70e1ca57b2725e2ea060e5a49fca82bad1a209e6508bbfe56607cd1ea35ceba58d02c45c036ab4ae8e5710400b398d01e149323e741ce94282775c1cbe664cd0cf78bc3d3e3038041707c220e96dc40f08e2196ce00e3a9c734bb965461c169cfc91795d7063c9ad56944c24484b530c129166c027bda4edbdf7de7b4b29a59401be0976083808ac9353cd9e9740ed11037f37087ed23e38a1f688859f341d4faa3d62e2ef1663e2276d76729eb1573e727cdea8f6b0f7d159a07a778e3c69201557b7b97570cbac0320ffb02ecb3f9975200bde9083fcf31d1dd6330e1c30182c76e3062c0683e1c071a29a33396e1c7ae7ac4c26dd9df31da24a61e10db7cf5d2e3dabcc759ac970bb7c5cb7d9e7f52a16b9ceba158b62076db893797ec5a29d83532c729da8c6ec9c7356ba52d9f890509c89e26c0bc5ccfa4c0c75e48c0306c3913fc5a29c43aa830bc3ccba8ed0d20c7e9073ce3860301c19fc3399e40330b3fe41fef9160efe65d669fe60b00ff67ddf7798e5e0cbac73907f7e7078457b9bb778f0d3e79c33ec200c070c8623e74c2679107a99750fb2d65cb805688bec9e58c4fd070cc5a22d003828166dffb1c71d2091615907aa1067d63bc0f63f99836fc9b1bacdb1caace7c85ae726a918ece02a1c6b0f1c27ed66c57cceb3a393734a4feb653528ca681f168002a954e32880cdadb3f278904e4ac18f7aad95ea8626996c1bda27cf99e78c757bbef29c2e9d3d653cf94746ea107aed613faeb85015ce5d69f5e34f0d975e6350e0ac330093a513b0b4e795bccc4f9a5417327016c648bffa9cb3e452250a971780a85d239aea140e58a26d57e2eec46927416c192597a62d658ce145470f863e51b1b0ac3d4b2c2eb858cec04e9b0cdc0e9d6a082f54e28b022c431688aa3d4b1cc850b5b09a325e61853eb488c81197d031b353f278d153e61003570e3678814eb0a8180d3e586cf070830b8e4d887360f297847e224727c50f7705076b3ad8ba0000f8464606101a1ee810e703271d51661b0c415c0d3bbe1c84b804a0fb22002ecc00c6f0d89e00c14c8f2a7c64f183734300170c6d6200c16414603bc30059d608c1298814224e866d032dcb01b61f10e079293242842d09214c8c5066081509e0b020c28502362f16805fc0806d8c226518d9c106475c20817bd28028231a1cb0617980c743095d906c4440e00813c444800909909980190aa0a9c01516d0e2026d30f045065ea0013cc606c8e0001a1de021ce094e1e8842c2705443920d870ff48002e60202292525588204d298149e4832130215a8508a60e362052f580869ee61043d8841821ed4e8818cae5645ca55f2a20564e28416319b3e5c4ac3e446dcb3d402a7052d3770e173d2c483a1e9b3c1c9d3f224e5c40828259e744f4091224a29650553c0a062c60b3eac11e504860f86186e90c1d352456a06303424514315ae89ce4a1457bc2a6cd8e2062fb0747b963f8081c30f64e4f0031a3a401967a9c5cd9ee50f37e8b2dc273b6c5378d8828593a187eb458b962a5f36a53ed8227eb8466ca94870b967800869a64fc6596e11b3c970d72d68367d1844b9e58a2e21cd5bd4d02e34080a04e542b7d01fa80f540bed81f24077a059a80e34078a03c5426fa036d02bd40aad81d24067a055a80c34060a038da22f502a740a9542a35028f40985a24ee81375a24db4097581b64099969828d5483002165610810a21484a0169891210a0f0812447a4074ee8000736a0810c60e00216a800052620810898000124253cc001460d20e18891220c588002882460c80842442842c001689b284808062800902102fcf0d103041e03104000847604cd747ce001908c7ae1e1059c75f686da4a3fc51e33d35d457a2a7a818728b168993f188b0ba071e88efa5b430a640b412eecb20a75c80debcc8bf16e3224aa219e43ddab8cdcce11118990606fc799c443ee3eda6e0f762156a1ee6e88bdd4aa30d64becee463bd61280d4623dafee7acc5927903a91e81eaaefe69c75d634f0efbd07f1ad9a5cdad75e9188266dfd148be6d0b5b4d2004e2a83fd5662a9b2377c70ac3db66bbf7dd364bd1e527f74496ae935d3e6c7062a6e6c90e2829b2b6b5ca141b7512d464bc616639581b5026705576220b45d79c10ee32fe3eaf1c5f89663b86779858b2cae5841668a1d5dae33ee4721acd4cba8ac041ab88ce5952c54289c999a2b51b212ae4071569e5869e25aa8426f996ddb368ee3b819a2700933581967e08267909a82c50c59f00c3e34c1a2099e5d51420d6f3a2c35c0296ba001951916698466694a19d29431b86056451a5f182a2aba1b64f8029732bc6046c5ce9e659518ca2a4d68b629a680e14dd40da228226c6226862e3786219a988941871007331886336270010733314811c312294881d099281bb80045d40c9e405146a9894243e687bc67f608c65946899965d4112fa0a1d2c5940b9a28f1829b5bbef0c54c89d59e651497282d4d4b44e5f0b4448e3dcb176cb0c73dcb17c0a863c488f91123342ba2a4c2460b9b4549c58a8dca1927a0d4134ebe259c7861ba22382fdb0f984a96a74bc586272a559ea85079a2d2c2940e0d318a31a24c61c113a9295c40494db1028a14b76739e54c9d22834ba3a9062e70cad2a40627dc7456baf8c270b20418181833c41a6160d0c50c42d4104319058fb809d700d54df9d24319a58c32ca9319988e8627700aa6e012b426103540e9f095529e3c990921658d2dee594ea161fb01bc1dbdb7c746ea78fa88fb778bf591fd7634bf4ca4de9b9b7ea9a3f489d9974a67523321b66a032f332f5e84bc04f113a5890da0b0186f9cbc3650d438e902a58aa72e50cc38e952425162df3d4b284868f9d12234fb014a540950ac64114b285252663ef4f024ea095409e504ca05a129a2c062b6eb02ca666bc289a7c56dc249699b70c255819b70e2546736a431830e0a0264bc18a18316694c896206275f6ca5131840cd6ed061fcf62c9d14b1c96719597b964e76d8e438db611cf72c9dc0d093c6c66620b15a40fdbcaec92c90fdb474d746210b641f8b19e14ec2a43560d2b8739ac802d96fd6dace02cd1891796d2fa5df178469f12908f668fede7655f6c5fd7473e380f6a5145cf66bcfd2ccd49c7a0b1313a918fd3c08f3415f8c731fdd237a3c841eeb9008fdd535b479fbbcdeb269265228cc4b5da1d8fcdcb121b7f4a1ae22117a1bda9c635b6246dbe79ea209760d18555aa06d5a69b440f3320b546f81de8c732bb92cd06c02aa8fc58c6c2761d236dd8049dbbee96981e683da4c9a1bdce68ad0951fa1d1f5cbf0b57736c30c66348c76cff22906fff9f62c9f58507d289fb4944e47ccaadcfb11cc0ed33483a17c9262877b964f4ccc62289fc438cd6098c9308bfa89aa325b69207419bef85219b93d4ba72f9bfc65253871f9716ab2f19e65d31a9bbcd0396e0665e4b8321568a229a149cd78abbce9a87432b8b965d3174db328a3d093262eb4000b16512e3811830b61a4b890830d38f62c5b88b3557b962dc8c00550dc38712a5b58d33473ead9b36ce189eded59b6204605b3a69f0a52f108f7edf786650b58c0883922617ba76bdd9ca25d1dadeb1ed3bad7365a775288a375277f4cd188a3795bb6dbbc853b087ebab644fbdee51aed4e8d7cba0947eb6a4e4b340e09f77a63f2aa71c47326db66d26efc4ae90de396b137af88771dee1b99549f54ad97c9ba79e0ec8d966ec62ca60a764ece324a28c7594c0fd2a9a9da23e73c94a3534aee47b0d336932fede9efdc3724d6078d7a3da6c91e982647f1ae1ead8647df05e05b4d0ec1c7b714883dd59eb524ec1bf73a1ed9f37c251609373ee5a2c6bf34d9b3d2a2ee71e9284bef82e915be4a14427fe469f122c523eef44bdbbb7af48ada8b21ceb2c1106fa1b5cff67787d9de7e3c6108c1675d27733959759ab7d71efb23aac7bb73a86bbd63fd870d7f58efc7eed9e48fa8f0944671e948a1ed79da1bb577f26e6f0c0a8414dab85672bae101c27888814f4feb022e3dbe97c9a4290b747b7ac6118ef72d098f1d9e4cc2638f5f9d14da5c7832a9b2b26bcee83b5148f8a35193747b07cf8945c21dbe262d816ebd3cb6f79516f51d8302093599c2d2f60e7e78db1d0b1b1f9cb4623c04dc9cbe63d01d9b5e72d17341c20b12511b5c81734271c76f1229081e6311c4182b31d97e1f625dfb8e7f2f88cfc4fbbde045503f714a4cbe5fcdf43d7ca89b9eb8dfc7eca1ba8334226bb311fc2f7bb9c9aac39f342e370942c3bf796efa096b16ee2d65f2d11a46100e73da16f62ca90ebfa1b3377416c71c42c281e3c61c42ba71c3c61c42b261c3670e21f9f8c4e610522c069b434830d86b0e21bd5eae39abef9943483d3d3c73088967ce26d2ce8ece1c42d299b339849493d39a4348ad166b0e21b190c639ab5fcd21a4d54a358790542a710e218962388790c2212410fce610d2f7797308c9f3ba39abdfcecd21248edbe610d2b6e1398484e76c22dd399b48d6d6398454e7acbeced91c42a273ceeab7d85b3d972c135a2f1990f6501adbb40c23a53c224b50963065182c5041584a1388d977cff2082c6ae89a103b6dca54bb9174ed490b9f73257c235a6dfb146b58d76ad3027137028fb7df1b8ddffe4d7d17f5953252bde36e24fe1ee37f376a1d1ffcb273f0463adf3e6a1ae57d3c4b8fbab675bac6b9f97eefc11b71bf1775cd5e4aa5299a9a94d178d55bbac6b4bdf51d4dbfe0e7e85a4bd754ba268affde690bd4a48cba83e7748dbbea2c4db35820fb51ff7ea56baa4fd76a9f91dab4405246dd435d0375add3a3127b0bc46481acb54016ce54944bc8cd97f11d1a8e66d9e074a3cb0da74734347c995a4bb4764d5c3f46a130b2ae9b6166ad79c86d7aa2d56eba6bb69bc8d24cf72b3709427b95814dc50e956fc38656a25fda75b777b0c87b2b9374b7be4cae003ba973925a391232b7f7bbc57b393956ef02e77e8864f4c76ea4e32f5d938addc675bc6643d79ad0383429fc987efdfb0d55dfe1519de7b121aa87573d3c19d3aebb32a94335c904c9e8f51b37fa5f52484636fefaf5d44a2f5d7bdd86a66a5e474b82ec7c09dd54c78680e739781eddfaf89dbc84b28680d7d1b24dc5a2159c39be79e99abd05b24216c88e87d16c82a6af9b60e33cda8c9306804f1accd69e4e833df65786caf1d89b6c5091083d08c66207ab88a4c9462cf69812130e0efb8d14f05eda266042f2d2359fbf0ecbb5251aec20169134bdcea483c360afacc4c4e730cde4f31bbfa19b9e72fcf598911c87fa39ec93168bdd464c3fe5386c72f0bbab26b98b26e8e72cd1a658046faa49d53d4d2f8e5a05bb49d93eaa43b62dfe836cc402d97b909158207ba06c010b642fcb2758207b00acb0c90e72931507fa29c7f57f72932034a51c9a05ad270dcc643da23ac96eee5527596ac58a15fa653fe5c75eb7b0db5328ebe3c6ed6fafcae48d5cbbf1a77c92aad9b406fb537eedf5a77c1baf0cf5bacf6119ea751bbf91a15e875dcc47cf50af4f0bf43c693e36b2a7c9240bd32a6c9bfe95a5ae5e1264537dd47d4e6daac6fa88b9b946d0a8b0ed7ab049109acf6d1c6bf0b0dff807e5a39570fce1b43e9e9a04a1e1b88f37e79c739ae08c09ae6cf086b73e9458a0d1fed833688791a46194582ce46e4f937649907dfd84e3361e821aa9eefa271c879df44e52355b3fe1f8eb9f263d9d6477d52a6cbbd35b7068166e5c93dde8d22a6ce44403b393898d87607da48fb6c07eb7bc8ef1abbe2ad3066f9e531b9659989985d7412a1a79e94e24616a4fb1c8c84b57a65d7596782a2c0a905ee602b3eb7dd4d8f53f3a8ed8f561ddc048bab6cb045e76bd8fcc882abb5ec79d4dc0596957e3f515895dbf6202d273f182a67a7963a5a0ae141a2c55c6568513d309f1c6abf20d21a682437c117e613262d75fcca22ab3fa0267acc222224ccb4d0e1167e858d929228c104f11687a8a28c38505cccb8912c08ad8f58f95e04c47c4aebf4f09c2a835f4e9421b3f6a0f72b442c75a6537ca6c602465bb04f366d7eba8a51729bbe6791e26b8d689ea14774e547b6253f43951c5b1e553b1e8a7a27ef7916635f9b32b185234c1449b4cfbf5a0a89174fdbcdee6f8eb53467afb23fbf0a7f6f8d1640e9d446853fd7ad594295f8b5a8d4d93aaacca6ed8c011e28073239f60238c18cce7f3d1590255460fcb6ebcfdfa2b1bf5f0b83a179a9e3c02cf199d9c1d6e47ebe49ccc1a5b5b4b68e4a1125778a563d31f51067ee10d35fd7c3aceb3455e38e293f786db8eb3cb41555e8461776b10942028425a64e0ac207532762fb08b19651735e6ec83336fc410420f82b5522b82dd5593b2a2dae96b6fc539a76d0a620d4ae9bd58b62ad65a8bf1ec02a68b178a8f29bddd5c24e8e244e57400679d73d24fd102f1660d1067765dc2da0fcc998228c38c2f3679d7ec3341a02008306a04a125082c4148d9358816bc33d000c128206e00820b07486a054a0a65a24db5246befbdae15949cc0711cd759dbdd7bb9241aa8b2eedafbce765df729165924dd08f75a6befbd5cc6c70aa8b28a801f171299cc474703fbfa24f1193b34ac74a3eb32a11f96c88e60c422b11a489254abb4494a558d098261245dbbf688e1df8df127ad8393e3f6bb37009cf4d931ee7773dc274d567bc4badfdd019de4b163deeff6bc4f9a071fa1f6887dbffbfb3e691c042a9fd5b1988f5c958d7cf46bf57195c4354e98365a693289cbba88f6bc975e3af2d49c12a441900983cc1764d69464d4b852261921c818b15d5546a689edaa32b1c85a7b2f1932656243ec26992ccdaff1043ece4beea990797baa91867c46363ed212da66e38b30db10d96a4fd28d978cd9b0bda4c3be22cc36334c2e3d41c6cbd681e76da6db6791abc95a4c84f94d54afb8648526175a60fad1bcd54b6a9bb47bda1e829c18a3904481c1519b4e61242b6c1c45a144d1a8bb46a98413a5182e3c6e18bbde314a3258ca27a22e1c7a4b409b435caaf0eb36a702d44981602057870c757e18bd93a110581098f1de2704a8d36a08f5aeeff8e0b66d0fa8174f42bda897b6973fef987ba7667b79d6183cc1b4b977f4c87e567104a23d750a74177520f8caf6ae6c9f936fde41b3b9c788dc73bf9af41e3b5704e3e9ba91bcf79c80b3b95b27dcecf017f69b7b6ef34a2ce285178570dfb99777deca4721197e7c4e0cf6b95d1deb5d8ec1fefa3c7830c788848f3d7c4cc7605a84a5adf31891d7592cfbed3ef73cefafac7357d6794f2655f7ce938f5a9fdc773419de7b8efef169e523eff9cb3fc2107bfa7b9753a0db1efcee0782ffe07c48df93b60dbaf9bc10b87692eb66701ba3c3fb262ea03b772b825095ddcfa9ee0a38c1dfed6e9be5acb55673f4cecae3c7be97ead4dfe625d4356773da30f15d749b4353cabbb5dafbf42ac5f976d786f0dde25ff6203123f93d29f528f5b890e46e3f02026a8feef63aacb5a30b88917e7a5d9559fb201fc6b9ef9c33341c131a384ab0eec2a9156a0f4ad636f7a9497b255c469a5465f5e1deb24e95e12b49f2a1da5565415323793457034ea2f10b51982f15e3cd23d41e56d7eef3642b1079199520203c3d39d11059fb638739d4138dcb5569d78dae5fb68530bef435c90f5a65ceea83881875aaac5231922ed797129cf48571962880736febb69dfb100410cd213a87e8a6dc11d7e31289454b689ceb537be053fced604eeede7ab77db1f16344ba6fd779eb5b26bb93db5597ecbed3d444191b0c37b1a8f52e8ff7597d3b9d7346ce59158b6c45c0779a5c0a7f445184a5cdba4fed71bbdf1355f137c75acff9d4f94efe740e5e47c75a8f11112fd2a0e60c00d9dd9e2727b3deca222c6dd6988f56faaa7c24ea4d35a867956ddbc34dc7865c2626bbbb734328d3eee8c6224c279898c02e2fa17190964c384c4c3ba9b5bfdba4707f4a7687b424c84edab687e43d692b6281dd1dc792209b8a0958d2c16972bbdd0e7ae208447b4e1de417525184edf76ee19cd15f1e73ce48d52e1a3267f44ce8924eed986e410f0c2d78ee734f8fbcf7265dfc39758380b43a317e155e0cedb55693dcf157994719e3eade571f3fc5d57857f7aeaeaa0b37f86111b8d77349b8d6a515b55c942870a3ea3ad5491d7cef05bf5d95799431aa1e923faaab4ab27baaf4e78c3eecf2b418d3d1b600ac32da755dd7755cd775f73ecf3b97bd9fcd6df73c6fdbb67b9bee964cf0cb28fce08cc24fd0970dcacf4f10f7feb85c5d5c231365302106136b9a687ae1327166cb6a8f0e0926c4f8a8341b54c558c97ba918708a609c251352f62ca7b26c01ec598e19635b4003dd2d0aaa629c5546492a72b4e6a02de3fded829a18f161468c6a8f4b373ebd32268c7d5f05382b7ee7bd83733749adb5f66a926a926e22916f7376ee3bc7b845b4cb0a1861eb98b36a64e69187919c6fc8a9a6ebc6f122b993562a543fef18368b9a33f6f72c91107382375b68cff20447ec316bf6077b964ba0d92092da63e277dd3924f748a2ba3c7af7529d1e46fa2934d74c09d41e36ebd833828cab7707df913e36fe23d341f270ed1177e1a827d7a9ee6a65ad95816098b9306fdbc3fbb56dde0eebc422efa0e775a0d779777361b661ae9b2a1106d9a031e3fdc765cfda5a67fd06054f2541bd7d77c73a3cdd778e431d34c448ca36d639c639cf39fe8f90475fb14887874727e11dde8a444810274e1c347bdcc93af9ee9cf0adf0ac1c7ecc2178fb2ed424f80d1cab6cb4e1528bda34c0ef344f3a3339dd6cfab3a9fdbe8368d22c99710eea2f1f71ef4e43f2d3a4d0feeaf45d587d8c3e58b2fa31cfbcaa3a1eea805f69f23b47bac60dea2fcf4d392d748500ed838c18c77b9ff60ad9b9432b1689a08eeb6777dbb98fe3b88dd3dd9220e3eebafcd34d9ab78d9261789ac9ef902e0972ebbd7462d5f689d0ed4de669f267671f8ed3a40edde8ddbe713f8fef62c662d1d6d11fe4ea0ebf1fd60785a25142412818e7c711bad1e5e2b237c5bbe81673901023495baff5ad30d41d9875aa6cc35e4ee2dadb7de80873733ae9120912274e9ced537bdc5d6b5556c7aeca683767219971aca2111c0d1262acf73e394c8ff8d1d212850c3f5c497eb424e19b8483b4586a6d9b5b83b4586a2bbddba7a236b80255d9674feba3155ec79539906afbed765b47df6da758f2d177269b66d2ee0da476bb1dbb23d0de6f47e03f91ac7583a326936ad781dbbdf86a122fd536ba6d14cb26f1bb7c64cf64df7c91d07724adb249bc7145c8baadcef656e049efdba6491a3541bd6992d3db266ef6dda59bce57c786d0df22f4f74828140572bf697b49d6712764fb15b7eeb2f4d86d611e3539d708e93eb1c803c13cf7ddc07cafddc11db72ee67095bd1359ba21494aaa6412ed3e7d74c9ac43a15020780d39d71cdd6fa7dfde515c414a528dbbe3cf7b2b4f0b744cce351b7f03bb7fc7502810aac9ef9eb7e1cd6df7debbb94d53287407be4ce892aa8e2640b3c34d4f8fb388b1b241d8b34cc24d125fb66ccf3209a89dc4d4067778fa338758dc75f66c82b067013a0ea60ff0cbf5f54862309705c1d0f33c2fcc47dfec3c2f0c5fa75f62f751f8af087da7c9babf8727aa96ce2cacb53f569aee8fb4567bfa2824bd935693176f4b35262b6cbc052c30e24c9318b65c41850aa2a8ae6c19d326aa0d531a4be8a06123031b19b059019b2deebd3b76c0dacc0e1a54e082cb1316fc0046091a3a2a90ec1a356bdc4cb1a9114cdc7174d924467aed9a3454054e382976c884146c9a9cac0973860b35d600b1c11cf6bc55765411da820b7c31be343466b0823245b0f1024a67868d102d3653556ce0650d2d35f0618935d6e852c0e6068e0d0f52ba30b808830ba61d3e44c1268d931d336cb1c69a1748b005182da0d831650b279aec88d2dab3dcc2cc1650ec90b203ca0e2818632c05638ca1f0ec596a41841634dc90051a38642186942cd66481e60325c66ffa510b5b4ab1e73f5862ac65137bfe0331e5127b7e0e81dc86b76ddbb66ddbb66d4bb3831b1a7cd12587285eca8889aa200c4e64740146142d5aa03853c375bcb8811733dabc81c1541764ca266219258506db0a153da8c1e50657b0a07b028b3328166840b14135c801c6932e6caca81203369d1358783143100d9ac61a039d2d60d8d1640cf72cd350b1c3290d133b9ed29c200d1120ad61677de0d1de90ce3bbbe9cd29ce1f0f4ca0fa273218b6d0aef5549f80c6483fc27d9d3540cc780e11374e614f7b2bb52a72697f01ebd7b4b36799064b53cf9e651a2718c400c60e4e51bcf083161460d1c5c3020cd4fd7f8ebb26ac7c3c3ce1eeb550601175b1a8d2744518ab2b6c3083156058b105973328b5e18a356964a046898506563c61c598d91560e4809ced79f2677b9003888ceea827b3d783f4117f58a07a12ef793a8118a13bea4998b38a4fde15c8790653b7da24655a9190c3364281502cdd28f3e06eb25b6d72b4fa225183825bbac5943161a140e814dd515fdba841ad78a18939ab27690ebb0a608d917e09bd00d61845a05e689b393465b95aeb69166b7b90581f9f40f6554d0f8ea9c3fee620538725daf653db32794d6698f16346694596b20a2382c8b0e2cb0b3228abb0a18a2a33801304a78a261ce26af18558bdb43359497a7f846f871c71f7fee17f07bf4ce3eced1fdd2038456b6b772ea9ba6ad326d58da92882e0e7ed4f18aa549fafaa9cc71849a14d647d048931f250a9c2f0f334488cff541f736aae3e7e3eac218c9ff3a178f04eaad811f1e08d446da4a2713658c322234da29126279553a8418dc6ab1d0cc02ff6f6895590666fc74b58c80d0fce1ac2ea24f74d2cb27d92f6e2b7af32d4694b35b216c24ad76aab33991584fa5941507de299c32e5bf1f75ec81d4caa966e5cee5ec5a2ee134f1d23b22f96520565ec1558ef9e3cca18aba55badf5081fbfca2024c4a6eb84c04e889b29352bbaea446e953b0be4ddb31b05d7de7412d70ec573a73a488b91fcc1719947191dd771b6be8a4482bcb12a166b6419b13ebe356aaa5b44c273b1d811d77b1ee3deddf66425969411eb3a571a5f93325a5d47d75a5fbd9673d57b726c7b4f6cd3b123e3ed1fc07a8f566a29f5dc7ed2d46cf19c5256ea79ec48cec79bd0eac95259c9953b0be4fde6696f6cb2a302873dbb14c447815ca8d2b5255a4d8aae9668abe9810ef62cd164d968ca6c3176c47ebc093d67bdb33e4656cc84d65937caf99863d43a4bd728ad4524dc44234daaaf94d493747347ec5937a1e7741cb7d7723e6a23d6afaeb5ced25624121ad9f9dc463cd7e9b119dfb36e643f3e288b31545a29f55ce52adaa4c0abb292ea3b42c4779abc9be3b873bb23855c737a625e42396f87ef9680d968751dae735920bc6d22110fae08e20a9ee7c87890314e1a8f96aadfd14a5246aaafae94f3d675b492eaab9332234d4e393ad6b5748c7352e9d8f758a78d8c629f3ec2fa65fdc61e30de7ebc655d95c757d15b8dbac611d9952ae9824b5e650d31c5384193b7674945952e69446931861a4c6a58d03101a6c9146fa6704393b2076b56aa9f349b4948816eac5370c0a435717772128456cf9da8727702c598fdf6bd1a71ffea3d13ea3d5da3b4dad43d8c1df13414a5c58e78ba064569debb1b7d6288892cd07d988dcc32e211a11ad4867b585f754d2a76a49ebb513da76b52f635ababeef4b440429b6bca75db0dd27a410c8149030f52bc55cede493b9513fd6afd1ac0e518be9320340feb23f49e56a29fb42526daa7d8804933526feb9644c5720488c65a29a6aa684489c93df7cdbaf0d138cd74bfbd8e31fa983edaa69598e0dfd18ed955335d3d2d90c5126693e3cd6ca9519aa7c4a4bbf70028136a5094d6bd09a57577a13b372f53a7a5ee39cd8426556b914d934b8e92e0578d023ebd127c7a229b56825f7f330a98da59af6a098d8302be1a85fa7a2676c9d6aa86d01938e0f77df105f7867b33a788b271e61451db942cdb942c47490cd034b5efed99333a4abe8d82019aa6b635f3e628c9ed42aa33b366571a7669146e17524c5b8893c14c83022e87a926db9ea51456ca28b49465c204855146b1840b416bca3371ce9c31069c3f9df5517f4fba40fa39c1b97acd3529a31004b591ea56d7a858f538f220e3fed34d55d7a48c787acef3daceeb29fdbd11fdbda7f7b491eb56d7ec5dda8805e24e754dc802713cba46a46bb740dc7534f855a86b52de6be1bf7bda687515f7d5e9a90e754d8905aaba46413d2d10ada7f5352923faaa6b4c54d72cf0da78d6d428c4faa44d375ceb9346395ab8cac9352923f02d5da334f0abb3b252f8ef635692320a35cd6295c2f368b3d29a7eb1403cc818b5524d8a8449c3df3e699f56c237d2544f53c0250553fb0fa0344c9b3fdc6ac9560e88a02dd86cb185150f82f7de7befbda0787aef1559e238de0b8aa2a8fa15c14f111441711445d678a20a8ee3388ee338b258add63bebe3f5d6c156265da35095b56eebf82f5d65e32852718e5a3cce2c16164f1031c6d8a51297c2f054960f2af1b67e652bacc9d541bccae291ead4b5319e26c05658a54ae2529565b8ecfb9db28c15d74ed8c3b3dae8576519a8bd7a584271c6bedf61a9be8a81ab71c43ac6d23150c7b491cf61f778cca408ae34fec6fa8db10eae56ac1b815ad4e409fb7e458ae756392a955e81fa28fcea44555cfd86e1d5a46ba7876747b55aa956ab202edebc11bf3a61b36e3beb03f6f1e098b15ea9ce3acea1e8da57f599335bfaa56577257189b48442cd06bf7a3de7ad1c4d8e2f55a71abf164bcce40946ad7c04a65de3a793b8c4d545708a4531f1ac079cf4a8542cb7953d4d32a56844000080048315002028140c88c40181482c4dc32c647e14800c8b904c6244154a22418ee32088814806a1184388318600630840082169ca46001418201158a2d577ecb846043cf14c7c438620918a066b84dc99b810adb5b4fd522608dab7562a9c3434482543684e2ae184f7720053e0fa25bbb099c630e86ea9e253d24e22cf2a5520fb06205a3b3072bea38bdff101383d761ce609962d3c15cb319fbe29163cfd34a72b841244ec1567e48281e58e78dedd6962e25c31f5d174f9984e107ef44b6d9597dfa579430bb81e119fd5e5ca611fb0048bdd20c01136cd6520cd1d5d2f7680965d00fc0dfb2ea7be4641e0fde1537a128c00e5a801cf37a823355a3366cfdfa1373c326ca6440f74b9ecdb7a7fa4cff0adf64c808f8d8e820dea28595f6a786a5019bdef8f85b0dd0b91d8ad6f2c15b117104d2e9800f1e4f54331d4ee7fb973f5dc16bb608988c721082dcb6c09157725a4d5ada288a1613cfad6864e2b49e5e6d61884974da39bb45d670f293140fde30e14e353c9c228dc34b30adb9e86469172b7108f28f01d92d6ad27832cf6c4bd1e7f026f380318cfa1f1ea6857111a25e84f96a5eb799640d1836f89bda1c3b99c4b4a188072fd52e4225eb2eebb54dba0bb4e5771a738717151e011e3e7822503212650da0f504e75b55b6d0672bf9b9e38684aa5d5780923fc4ffda11e942e141755b0d4c3db57c73aff42cbf65bddf4d9ea6226e14a93d5401862af123730a1d581ab5ab4540e6fa0a46e2ba4cf3e1ae5568aef82369a1505e04df7939b6f3a3a9ddcf5bba07370867aabb44bf228e799f37739456c8c5472c455441d03e73192f4679c9155d22dbad5bdc11690208bc3a31a55c2672d0bda8157957f8dbb8e178c961c6e803e4b1fa72f35a52243dfba9e6142873785c9643631bd9acd931d0598658d2f025e1ae4e36e6c6bf4afe3e3c0b4654e3361da24632834b6c04764095429bbad47d91ab1e92b163266d15577fb439948d46f0e6b55dce9a6c32dcde79c6521aed209409fe2bcdefc98b4cbdbc5b23c4cdadc6d1c3b8faa7ba3e387c6b1bf7f1193d675f9479417aca3d35c84145139815c5943950309f8b5767069cf5a6c828a2cfe29f5dec48261ed07d416bbb18931b4a70c3b98aa20924623461b92225dc71330e809ec9e420a6cc45abab3d36c9055b31d17ce2e59a1ec4f3fef3fdcddfbe8e784dc7a03318a3bc16f6965cebcabadc0f45734ba6c0a7828239a31d0d5e29b2c83ca48cbdf03a5c1c0dcc573cb47f073baec4a8579203466d78788264cdb333e353061ef40b0976bcf502fc2a95a18cd877b695c574000df50501315e9905e2a0e0d0eea9d868795231005a79b337d7e4c7bfc50de8315579b2ef2cf93c9feea000cf22632f0a3bdd2f7e7db25ac11a9f2b9520e7561eb6794217968bd43d754cae53266c9ba7a84cbe3e823e2d4ef9df0afa1d6b7fc9dc719a6933bc89a3ea6075dd69131473f3a15c54f8a59726ac4cd86ab6833b4c77f4a57ddd59ccacd97f8e81f52dae0a6feb685684bd4f798dd99eb0b492d364b22304da8f2fd6a6f342a3ee8cf2ce8959f6078cc9615537dae85888671579d11596cd552a32ee40982e86110cdbbd534333e5b4b0d4dd821d83fdb99434342e0d6a4220a5d991cd6ed3f1bd32355552cf0455d48161ec5eca4394e0d91c76b41c0f5e86cc5cc808471854f70a0e83bbc80176579824aaa1c05a121d56bbc80abfd80d42829f246270492f334d6590c0213fc29e1630bb7ae9d2169dca6a4e62624281c0c7cf88ab8d0c95b4e12ddcf76474c59a4cd54918fd262a38a67a4ff30278d39a4cc396b0773f2845a70d8dc884a7a4e94ab1f1699e044458b466b8f7926b6762e5cd44647bc7977d9600407386f4764cdd8d3fc5a6141246a6c1916c75713d117a8088d5c0911d5589e13a9f905d9691728878f3716430500992e97c55ecf3aaf48426eadf3816bd7015f66d469fc836fa6dbc8bc9763f9b34929ee790370359082575303bedae2ef7100ea15307c9124af2b487f4c36988dce6dc4c1110ff6cae36a44dfab582f39bae77ed0bffda5875a43d70b39df6e266c190b6664732cd8a59dd5cf99af8d22c50550ded7e01e467aec7174e46f0eb511706ec5bbc1dda545b963ae2be154d4867522a3ff6c4bde7ef707051ab4777b96d2e3796cc529c578f57007023492e112defce4105e17836e5dd9faf2392c9e152b364d24f29196bb3eadb04e26c8b120eb458e02d5570e745c8989a860cf2bae2d7c527fcd78fffa2a0ae4a0cbcc3e5dd689b4b15e4395bc90a990fe72c06c49d8d57a74a838c16f50a422c023201350c8e2eac4c65ee0b6ea579a611859be6da66b3a8ebe99366857c2cac83d6303b83a1beb989b578e79c505a0896315688a114a406c372fd4a36d40ad32c24d29f665b90db211a8b7311484049be543d6035c27f10754b1bfe2ef3dcc57923dab2819ce3c2de0002208ccce3a89c81f3ee8d88645bc2c3bfaefddb1c286269d6aaba2966de2f305a97b90c64bb67ac0e0933cc4cdd861d27f8c54df2e4d775d8d5ab7e48b825ac5aed491819c0a74168230109b7220a1ce231a59dc2c77149997806544932a2f59d4eeaeb15bbb1d4f064949f863e4ee640babec0d969ed3c9f51a1721015759d104e9b6f83bdd3f2f4eb557ccb8e9ed8afa8e211a48defde0c42e55bc44ad102611e5104370eca4a2b28bd1216debc0a0bb659fe6a8d4b40f2813c9aea27cf7c006386f049395bd50c77a0a83fcafbfc79600953a9626dd3ddf0e30ae36e7827ce8aa93aec9a146e04ce289177cb2acd8d38aa80d2e7da2f6e6bc688c46ff53b5494260bc9ac10ae3b9ad4bbdc0c2ee156e737dbead3861741e58f12b03402c1bda38ac4b9ae58b312b468cf7e03e7a3d0769724fd7a24c2b6c37026158e80ff0fcb65a31cb1031f471dce4f2719bd4cb56773b013326b18cc40e1b982a374ecf29673c75364da7445a747e6e2bdf2428c8e7137bc5ee923c60526eaac1d7d89e77c983a9469a43299272fa4662f8786957720f988e1e49071002f79c4536547ab25f50cd969ff643cb502b64b0a7e70668926d1b86d0193416498134febbeb97d571d89e79fcaf044908a129f82e9b0e8911ec39bb08061abe4e224f8487ff0394b22f2f46de9619bcb45042bdcd3396b0be0d337dfd1433444775e6c17be52892cd9d65428db381c5879bbcd9699cc0f16190c1ecdf217d3761136ca413878bb2a874f2c5a5ede8c4c1940aaa66946eac4789163c02dfa94e3245aad9b124897c8a9098e444e66e1aa93990f1437d62b2d95c62fbaca8615e7c0ee5ac76887f2eb9865b3dd9b837adf70c69bc516efa27db985e04bfc04944d5f1d81d6b270ad73cd80b2a72c4f96c243ad7c57014fced287e3055560118a88f8c4f07c266528686030f458f58dad06d2e6e5040b411213eaccd3a820bf7d82fb109b8af28b7b86361445f0488940b6f7ca48fb0fe93c716b6c3eb253888830e42681674514552f80242fb5d08dd0752374e9eae6ac68387d7296c62ad4340909c900f0c25bc84b6fa74884b502787256d75a6a74d780ea423fe456ae079f0da730ab43b0970d0e55514f9acadb6596ce46841effc8a0494421cd83d84da3d50952ddb4e9f3dd2cd4f7d13def6a6960b3948dfad36577137c589cf2240a95f60928676ac26b6f03c1a0771839728595c2bcd42e0c4b0d205f38d120e534a69e4dc4df04eab0a3160a6b81b598f620b8313bd4c660ca0480f4a5313b02c324a169b45a5bbf506fbd36b269bccfca182c9edd56139f1bb574c15569ffee7097b54de6cd526308db0392cdb9dcbe6586a013d4d54b0d800c1143cda812d4014206724322e23089c2cbb3dae362557b0d5fbe0db21a4b8cd069a6bb435313c514b6cf1bc984758b9054a5b741be6a67da1e3f13d3b2657633b216297ee20db866a7ca34ad6c9a011286b180d5e89d450854d21e6e26f06008ed6b486bd635e50f6a71a04467871806996965195405b05586ca45337cc5245210597b0770d6c9fb087f0841c896650604d4a5be54db55b682d726e0045e34888c6cb3f44ed21b78e5b7583dfabcf1ebc46138f6b59a30f816ce2ec9288f7d129591f422e1264018696828b2e5498d2738403ed8f280b071c74dafeb0ab27a5bc22b70c1214301cd0abe059225c572581aebe581c7b71ecf2cc7481f0acbdcd3e8ca0f02c829f2a9312c5bbf4573783cdee6df8aa512db5e418c11b9840b975859a9ac3bb962c74f92abac648af97556b435159b6f83a4cd98651fcf45633b749aaefe26ad15ba565d3b922c927538524f2e0686e6be7e3879f6a88436a4b798bdebaf461c335563335d7ec4d4ef810b524d4c883cddd8c1656fe480be8f63bb03569ddddfaf0c2880dc1d17530d9a832a5bef9ff729aa5cbe59c75372846a79ba3102d47cba719215c25652ee3ac264fc1b496ae668d85cb7083d4ddd77c79280f4f5cbc19c5c1dd39b1f92d3acb8d83d865927e873aea288941e04f51946ccce313c62eee9cfc26130ee18bfcc5a02f4ea19eb3c0f2f4f740366abb1fc199d0a603c90fef13c3b3ede3d4422b714dbc150ca278f50a2f7132e0b6c3d68dabcb3af5e2bd93ddd8c013ccb24e3e36cb483ab1f5fad65ae8a24a135aeb4516cc29349de02b2334fc42e92ad9e106674ce3d4d0287d80293b2897382b954f8f040e67279e4c1f116b6b5b777b51e2a0bc80438dd2406c2da00cb04dbaa2c3e9ea9cb7315022fe5bb03025fc85e4b853e5fd49f7ae0f83f83addf427630dafd03c5ab391734f255510e166c3adec2325989a51810d715e031979de12e289ec574c04536aa56cac1a1bbab7de94b918738cf103b427c5751e95da33b2a760d41148c411674cf6a0542954a44307ebd4bdc65a653af4f80165e60df92850dec7a84588959b929f99fc9432ea48df5a593fce625d3e2ef433243ece4230cc3d015d578b41f183e8d07f1e999aa09e8beaf6827df7cd003e430b11a8a89b2097b84662b77b1a24840537f1906c183a34f7e997689597db11e924fbe94c22e443fafcdf2050040fad4d9d8ff043643a136fadb908f8edede1bd265b7cfbd621eb9676d934917726cbad248a53a33caa5bcbede8cc2901136bcd575940e08b076b0ce328b516f9d496a21ec416c93249275e8db92d267eddf462c26b36caff620ec9ca86b48fdb624a6fa65c2b86b59345be98ef171ddc0927b6c6e009c42d0a32b06721b798e82b8ae916435f93fd95bcee28a8b64cbf8602d11f48bb5bf78f10e331701629ec2117bf278912667d8c628fbde47f0ded3068d6a5c4c575e7b581e920ab8341bd7c0d6c424059a490321185c70336757bdfe1df9c4ff85f4e2d9cc6dcd82c54375667da9f20bac3464386d65da88e5a709231f7115be4eec5059ae911adb158b5084448aa5fe3426e4a2e492af50ab050a146e7b89ded71c1d5938fe3fef170b84c08ddf2648905bd214df6dd94398980d2c6ef7ca0e8f35a3b4d2c78dd6b95fa31a7d9fabb35f215dfadcdef395905b1389aa782d163e49626fcbb8b8187ad981b3800d331f2a384198b98d4c6e095db5e76c31e0949667014c98efdc882d184551cc1af8f608d2c18aab8063491f0aa27206ddc796aa0891218c583e67588164e6ab23f3c18160c143ff67638d85bdfca873ea2b7a95262648cdb8a3b2cf64c0db22fb8c848d455c6f575d2e9af63795b44b10eb773e293757b14c4ed552517f9baacfe780932df19c18251201ef67d5a56666e4fe7e06c3d622fcf2c6331fbbe5790353ad622191c3145436e43e8b33b8c45c09db93f80b77b23ec31f25f6148c466f41e4d270b04d4c0beba7f6a7788f79c9e7f1b4ebcb06634dbdb20ca283ca8a8596b28053e56bdd4723943562e542c2c88d73689e50b096d78c74f04390e3eb10f54097a91ec29928a9207902b73b037408594195ae0b9658f3cac217002e5ab71e5b448a32175e4cd164e355f11ccd26441964dbc3db7eccfb27bbb65679789a10ec109edbc60a2e8793c842d7b0c0a2219ec550c8d9d04381a431a41e1d4e5c7f9f9f192be4b2f188a223bf0f9f109396eaf57f0c55a5e063b34114cc9df22d8ae2ddb49e0c360079a10bcbe59624c96bb6202a50bf6428c4363d516ca8b33e750614ca58e1bb72717060220fa2d2cf3a2d4e72de9173a9eab61f8f464a1e56edc1e1d0280a2f7594edd1abe3c6ee2c8ed41938d4feb4d50574d49b1168e2bff7d74d76e790016faba103c30900278d58d5ec2327bd980dca03c7211585f13d78f06df3a7f54beac95a8fed34d49db5a080ef5d4242236ef2208d0fa9e731b29c10e500972d776aa751db54ed50a79e232b253bc4652656eb74386e08c5931e016adbb3d46d735d1172eeec6ce23b15a4de1c318861f5621cefd514f798118b52766f7245f93bf269f7a6eb501837f38134c470a4fc591c54d0fcaad7984f767351bafcf222cc1916d1dec2bfa0f188b2e62586309ee71268d6e4a2c8307f44485419bd5e3e36a4737425d4ffa2078ec0366bc60bfa4e0d5179b05de949651af3ff17f593a07442d2f407353f0dea9154f620deb7927b5854cacb40566bf67c592d5896012f2b8395ee4cee2f65a723ed0c776a90c2c24ca457be678511ec67cd7a19410112c472848eac9d020e5bf6c0d88b2606806722dafcb323325703efb9b44ce6045132c3a5cf93b355d1d4762dd8cfb590df85e192b8d675d8e54b99446e915ab480321634036277003cbe49fe2606f5366955787a23ab085a59306b1f3d3aff61b5ea80a2095ba25936e8b6822253b0155ae797262ebbbf49253568035cf625925c07087d8494088f983d8a3b5ce31749d8e42ea0a01b4892c48a6224a17904ca21798c4ccb9f12b3cc39b9d8f756701c0d66aba6c60043a012b81f6bfe850ed993211a5df900b6a8f473d762b778680b7a049ff91ab97d520cf4924d5b01d6bb42c4466d4d2c63725f83ade648f3bea9aab74f96b58812ba31876f8d054f32d07ceb63c4127955087ed1b53b5f6b4d753d274d1790d3795b994a860002f97f369ce6042a8c434111caf0ec191b8b171e505abe32883419ca136ed99d77e3429cab897d5b2a46f77dddcf15e81e4c292fb8130e094a1b13158b4d315fac1cb56784f8bfa8cc4bac21793adfeaf43e3b72f3b458d8d81066fd9d636d490f4b733ef160cadc8d890592727e5fa6a393977b0c57696511bcb776ebd7f976f322db442186ce6fdded6097697a686535d09cd98c0f6a95f6885d761fc7f1f105d377f85584261f750591f1f94249139367836d1387dd25ec235c1d700ecfe4fadf44e911faf1df6bc5e12eae2961050a609f99fa4c3f66239bb980a2a492b5a64eae164324b5d7761b49aea69c8adb37d832e7032d0a041d402201e718e29fbfe3eb633185995e1e848da250b7686500c132733b40c41605077dece7c5fcebf10c1b83976f9dc912cba624a08b64cecf20df211a3490bed2f093edde5fc6d7e4957d9c74f09dc88626a6136bc3cc55f607909a1e9c5af38d4d9ef16ed6d92e2600ee55d130872db418fcbbe23a8d37bd4bac0e688f2d669858b4f5c258a5af97b26e5440b13f7ce517a9eedb4d6ad897403979644596a1d306f02a277e1c9c76d89e9353c1d7045ab90ab6197a0647a433a6c21218795b57bd0d2427962d057c1b013c2b03772ed100242fe40818444c4398293ffd87422fa2c9f83548d9169e9e7b578569a05c89b245e22f59f4c55758e942fee57c42db33d874993d496263fdd146162674343e5852e65136b23b98a46ab0c7a907e3c8d175e76fadf384bc60993bdd784fe919f585f6d105c39b299b80f39cf4a4b44decc421371c1db23d7cc5ba70043f73b4501a47e6e43e9cdd6853c182e69d57b657a370a80ce30ec4d81dba877bf005bade09d84f4e4ce24c3d47d180b4a1551b4eadab3ca8c0bcd111501c5ef9ffceb915adf368f364c0f4abc48e0e32325eda3e139b904a2b01293a88c8bf8da8b50b2bfe4da64433c66b50a7ba47d56882b81ebb733b8a4aa5d16ae8de623485ada78d5c87b2e001c783b8b84cb4b0c2b8964e985f04e0218c4e8da8fd5576ad25735fe70371e065101982f061e9197b75a5fb87bcf7871479166c1eb420f96985aec42e9f56c01acb10d7c091a188caaa7758449fef068c420ab9fa7299618899fc4d3a0dcd00b8d7537f400839e8e28408d55f9a99fe6d0050a5de6dcba337544c108e2ae71e883e3aee780b812f88edddf472073c377c5452969952a537e5de6372da1c2689c18fe038a472ab5e742ad61c7d4606b30d98d7ed0843d7ad4690f489d901fc333a893a3e8fa676dfb51494a94665d6e2f3f213b8c04f516704a216dd47c6cf2162085dacf9c06376fe60f9e688d35e4c97c8d20386185cc48f556f1cd395c7f3a492cc2e136959a4f05cb0be84708ac56e1aba75129f1456d874b74f1788db8c8d1da72183a5b24519d0264eb7a8ea863d96b2603c76e592c25a71cc0d22b7d0c142d047a867e43d4fe21b39216dd2a2d4ca4c8cba9f5a6bffb1799bcfbe3e6e5e41dab005d285e6a744d39e0425250b4528244b80eda2ddc4d2686dcdf4120d9027b14bb70ea2e03c32a68d71cb586feb421fb806ff089b90a9eb5a809b96ad9aa8ece3166c7f415c2dad714fa14c6f344155b567ebfeba835b82bbb06578a17959ec13189e44807354fd6eac811dc674ac748c28b3b6b20eec3a97d42d948f8456814512f440eb16344d79c5dacc02f9e5859afe90e051e8cfaca03218c6695845968181991f5869fd9d57fe7ecd53f5cb2c7141dd5ce9d9646954306d07efea29fce502535de8953d5ed681b1872241eb7589ca5c79f0d42ceb08794c56b7ddb869f75fcc8a28245ce3198d4875b4739b02ad28384c65b8c2740e43914d591d6eb064ce622f95feb007592082472c02a5b44ac2da580f5a4ca73485803f4e814ce40b65b71586231de1829694535980c02ba85566b9e54bfc34a81277f0bbef96e4df60546382f8a1dad379549136133da853646684e36bd9993cb6692668313700ebdedd683a65babf356e9436bcc67e513221dcafe34a092d113bb55223644eca266129da8990c3140bae2af9f6a452e28b04298d988139225646683112c64be939c2f7e5335eb328e265744103723aa3f30c0c4e1e1c929a6c96290177cd4e06d2b44a671c0d8b45357cd1134d57d81acd39bd0ebf62f3765038bf621448d10b0bdbd858b1073cab64a6c1bf7c39ed10ec1ad36c946bb09c71a66fae7a9fb5a013aa2f45e4c18d3a3e76d9ca9c381eac3325ec67f2eaadff6c01ce2fc0ee08744a34d447fd0a52467a8382d2ec745f8bc75cc57ccf53196000aa4f6da565cd8faa726d0f6dee6264bbe46400bdfd2f6ec23f1972ecdafe860d76f397bd135d3a74349767d5d7155dba54c409c15e6e3c71212225a1b0f2039acbaf8883a7d6bc0e09903a2b2bf518ea391e897e4426c454dc570946fa7440bb3ccb62e9225eed0ba25b35508f137627d46114fe3afb1091d85f7e5c1a2d50ea3d4993aeaeee101d7289e74b8b40716756b27ae4c9aa5e3519d059e303878a9cf7054222af30afdbe743ad99f53058152c24586b06133f836c6e16c0cadcb9ef41fe50ad84f7829f216e08a0aa25a3828c992d92da3c72a1eac348f9a136935711fc83913dbef91e4121f4037749868819045d4c97e9c8df1b348e8ad724dc0f160f7e9ac50b7546b45fe6d72cd91b88b1180b80e7e87b261c17cb4c3fd172dbf078f71cf1cd60114342dae02810f2c390f9cb920451438b811c93b68fb0d8dc2878833930d27172ab53ed1f6176e1bb20513727b5ae557f3adc57edf1b7800238aa988699de524570809d18397ba7ce4b30944a91490846d550d0ae8a762cdce2df65f7915191bd2f275245026867150a18a51223585513afafcf13481921fb3f61dddc35b4e5454d6d11762f2306e4c7e0838f05542207a1254bba376137115c24bb7a4399ee50e2f7dcc668fb888ae82f37e2d594ed567387abdaf284d7ae0e4e1c56fd75d8f5b24eadd3a94f107b02f02d37c226f679348cf3d3c0d7a42491d21d3f98171e75e0c208a47ab4b4a32050c3317757a4cca29fd0d8c7c672e94eb02c85696f8d985d79c8b21f624c31febab3153aabe275b1729248435e6438b9f7a8e2e424d5754d69b44fc73afa6b1d23a7f19617c1b5a7130a902a267740a5f7e5da973969ca48afa4516e34ce2e1ad9b4f52a6ef197030bf27663a34d673fa6ced37fc82a044af5f214149c2dcf99b10834866512b16db42ea2f93ed44376f88b0844583791ca04057545e66cbad13d2384b5ee738c47546b64c9c765ac6cbb626e52401da95f315a172a284a8e4eca5aaab700d9fbe90101144068ca09940837a1a5ab9f3f494801776bf5a9750230c98be899d98b6d8587f7e5e2915a161287170c9689b7da15d99a01a9a3eee6422deaefdc265cd65504531114fd30d800225efd3311195d0975b448cbf4928931ff70f1fc1fbfffb33f8937e2c85c0a241868329d434182959e123b420dc5004580d120fcd3c8eda29a1e98ce03e780881d06124c559fe0ba64058d82ebb831732dca707e54ee41bedf0d2f02823877d015d998818a3a63cc845f6afc6c82023ed95d8b90925c6f7a18edd906da0a5cab62c85ae9c04c209225948b3c4bcc5c53ebbd872fb3bf281e5b00721f9dd2344f0c0b5a344f0916d02e4ed0ce40a38e6af79f156083b35e1116223d5eadc98ccc9b3816b88257e6187a0372709f26f9f2256fe744b7a49885e41b434e0264b441aa1a98f0e4d915d89856d1af9179298a7654851da3b642d9cc4131c9a52efba9e1683e772a793e4d2edea95b20eeb2883d212fa42b4795be85e1580f71ee2eff8458e3ff2a1b49fcc1a0b4da76e04ea6ca9b90507104d5bcbcf62318b2877c62c24cc11eda5c1dc9c1179412a4054b4f2028193a67096d2095256e9589791fbe1edd128ecb805beb82a37639c6b0c243b351f93b0fb0a892061eeaace2fc0256c84ef0032e3a8951d27d1550897b07a21f5e2ed31e671fa198c76d5bf12ce1ff6f109c79cc48f8015af107f77f2b862a9a3a12e48e4a6b4bcb74968be534688958bf6cbf2f694aba2c0e50068d2dbc9978acaf21e33c2534a48ed044735b1a57fb75a2abc68a317f0beb8e799e3aecccc5198f7b39cfc1f330c66583ffa7c3f66122d40c11cdbe53818a97856daa051e6e2b03d221f9fec210822bc8705fe26e20c0433a41ea1082d8dcd79e0adb1b623c78257aeeb6c79abdfa428b436ed940c64f0e40ce61e20dcf14895f1c0cdd80a7ee22a09d3fa91316219b1ac3725c7559b18873be6c730d65e7e2ac1c2ea6c228920531adcd85e66daa411384fc76f780ed06837b331607c8d0d1e18d6363e6e5075eeba2212e985b6af168ecd439794c183d38cfa6b4142e04a877886f80a578642a1a55ee1573d5ffd61d682ab2cc57dbfeb234915dcd13bd5ed6a2d50a8022a2eabfb118135086a627c27016b1ca17475ec31fab5c73188e67bd9c1b540984bd4a70e46a62917a4500f0b5d058c995c74d5ff2676f897d837e0cfc11fa8a408061feac5a8724dce74cc41c91eab62a48e2be25195d66a7f841ab135a56a5bc9e64ce161c3c156cd9bf707055bde6cb889c28afab349a93832303c08b6f82b7a7572d80a0c0efb6edf9123a3c5a9513b53b13eebc8bfa5da07b2a5a72f7391849e472820bae446d0808d5bbe4613d4d8b1c98adc4e6206d90840ee460170a9cd28ebf41cc126b54227adda5dd26adba8fd874dde316852a6f27d7441a2a3221fe46ebd5f780f21d77abe0916a086e4968c964efa937f2f2486e014c3094dfaf186054babc7864af938623ed3c0be3602dd20e37b11bf5ec588c1e1e82707d9bdc922baab90d8ba78c96e0e45556a40425d639e3e4550ef3c0698e541046c47b85917b521ebc18c8398516c0da2ad35f0ffda6fb9abaf0b8b6f5ff2636e5b5086537a6f512a2137c5b209bb94f7b092102067e52426d02d87622c3a86d81fdcaa9b571fae25c5f50aa7f2111859b9bb6b200f838fe36486b935eaf20611f27381665a97afa43920ce3013b62f0160dbb52e64dc9bd31675567b4c8b97419fbcc1bbd80e342847de462911897583dc57898ddf4fe3f9d2fe6fb75187b1021ac35c2c10e4dcb3a5cc2b15911e1812b921d79b3e9d1f39d5833c9de929d0d06ac6c9b71bb0caea6ba90cec9f5b3977d83fcd0412289c800703161cf40b7c89740f7fe1f03e226d97a30474f851d402a88cbad3e16de4079f22e0baef28003cd11a8a82b8f489fd9df0c9c713fbc348202e48f3e24bfd4e8094701159a97f35d378c4f926f535a11c251c7372b0bc6b527fded5c4f3de11d6a120bc44f0525858d99ee036aa3062ef140ab6355000098c37c14e167713f485c28ed1be2e35df98fccc84805f15b74c262beb35c9c148656086a540e2b027f491b6e08ba409b070ca0386940c1cace44f2b4e4a81e4d38b404506adc094402b6beb329c24e578844e0b0913398bfa3741f64e371abf3bc30b737e6cdf1da88eae298f859b5d5937d55cd680bda55811f9f24731b4997168de5e896c1dc83032712044ce90294a54a5d703d40ba73523021214e29292fe4217c53ef313c286c0861ad0b424b76606c183cbfb0af1cfe945b0d117e58ad30bde837887171dd11801ec082574f8331e29ca3bd752582cf4e6559644af3808580304f0c2fd5343b69c9807705fc98db600d52c9cee43af5de176495ac7ee9abb7886f31a1ec5ee60321c4096bd7fa513d82d4de573ad6d91fb1dc8a57ca4d24509d20997618879a585f0a06ee639ca66ffa8a78e5fabed09cfc2042f5ab71e2960df79936d1346a4a1631ce44993bcc6fb53bd2efd5770853b081dfa6944879d822abc8984a6bf1d8b4b190663a001dfbb4dbd2379ec5c21a0b1309713c0a63ce8e0db91079c46525d0f27434e3be2dd52b9dbac8d9dbc5a0dd613d5a3fbf8bd279679fb019ba519fc7704766bc44d997eb98efce58bf02a2481eb83ddd23259b14a9a92bcfa0af23e4739264df77238e2c25a0a26c3fb564b2a6aafdbb514917559c7376c07c62c5aa3da013b9a001b7f19b0db3e6d8fc0727cfcd26be6929f721f204e40dbddfa2ffa45797b08f870f6a3f0ca2738507d98be8a80c2ffe0b8a07cfd80dabbb48b9b9ff9b7eb8ef113973307e8e2c5a50f261097d54c0e435f6418148c733281cc31bfc9ea53484ead400d4462927cc812c5bf2aa664bee315ee6b409900cc7e71baa640079768b7aeed6f41f22efed0792493dba054f7e43088ee9332c1887af7d4e2f5edb9511294f70c4a1f4ff82e3b5fdd0bb3666d92fb93b65590c7b068cfa378dfe5e653f8be329e0f86d60775bbe4fb665c6a20be4d0c995f0e1fa060d1328802fb0846baaaa88fc736bc6d73986c94f9234ec521ddf2fd9fc32aa851b38adcb575cca8b61bede1e81bc531ef2f194972bd712e8a3b807bda5175799b2f9693261316525a824f99b7b0bb95483213ad8c153ed0da04c353399c26f23cf90aaa2c0da4db07c1272c4db047acb8e39636a9dc0d61e5d2bb3b4ce8321146e823a6692c3609fc0b23ad060024c7c8301d99a05f7c418fd2202aeb1724ad969fa5ac66761b1a4e0dc0bdca8d5133f2a5275c4f6fa6362f428a18149a8e551fd49a90263665d82c88363c201e451f79906f5047ecdd1409f959c288f19a5170cd15a8265ae0e43a8c27f52811da31f5a4292ae01acb9e990e333976597e3324061ae3c258069a8bc1696b102014b27dc607222621c7c2c37d3a0185c555903dfcd69c12cf7768ca6643a59887417ff0cd9bf90fe8d3cdf14ae074e56cec4eabc51e723c51a35008124d0a4234a4240003701b3ea2d9639847f2b468a3324650f5a537071f70f05c3ade0bb071beb12c6cb7ca73b24bf4d5e6f4910a8225e62eafe155730cede643cd362247d42b5a200e23f7b6fe46492f911b01f910c05456c0b210c0e697e4a4ad432094599e1268a7088cc5ba9a6ef48b039e418ae512d86e96e86e7e50608d3bda774984e2faa22e2703fb2d1991c2a48c4da7b80dc28d722d83c3369a57ebd8a96c5d88deb65e40812872d43cdbc2707d0f70c67063f06c878010e11b7bb58f863cf545b81818dcb14d6171edb7e4a2f48ebc81d9d1113d95ac78be7aa964b53b0630e680307c42bc2c1fefe16b8e0e748685d9719368dd1b7ae53774e14bc11cb22e6152ceff88ec343e56462344d79785e60bad0a081ff058caac14814e8596b977c7f924260b502170e58d0a3c387b50861e4c615735f69da69301e48159cc60fb238ee2b378e51c2537781bc32d492a0f57aed8e12f296e20da5a001e9094b0e312dec8d0bcba0a60a0efe6044ad3a94553266559d86c1a3a8e4b451fc065aa24995ae40c5ee381ed82a580d983d865d83b9997bdd02c570f0a9879d1158ec059c0010569831e78eb3c482a77f2c1c8fcf227f0d7128a0ac460fa1c634e4e1d84cea337ae915392ca23d252d320cb611511d0c9febd06795c54e744f2c00227959a67029f340f8e8bc51837478f2c4aa5503a03774e03926419530cc3c372fb8249a7a2e5370b22cef2110712c2ba151dd6279a91a8386cbb435bd9392f22c508304b79fc0ee10b5497b4a28594bb697f01c4caedb62fc3f3be271b1c092dab0a4b8a3d9ef890bae7284a0a562b115c5ae8d86bb508878059ab170ac245ac291c1406a79c1edc7d233d20298fba9837868a42848540f6ebd8a06b04a1e91b07f4900a619d8012c4d1145edad88f1c07d49214dc5b75b516aff81fb237d2849890b5b3a711bc7c661e9635d44cb550ea8b883289ae737bcdc871e76dce438d2c415080d4eb8841c9ea3d72ba0d5a493f81574e256bffa7ae6848ac0e75aa0e0248ff4a28af4b49396290600a29a8dc88f4f47ebe2cfe06a2e2049a02f4e45dc4bb1801dc005347cb83ee469e32bd301f2144978a5a9018a0b6494e7cb6bc4918437cc82fdbde1139989cf7856ffa11e400901b009f45d150d020f5e74c15a2fd1a4f830e650225c31604b74afe17d662a568173590ba710edf45edd4769a5f42a709901a0d9132789c77a19069ae3f5e19aa37ab47cb5ee3a3047a6c36059a88e5012621737dd004639218ebb134c45bcf09da211e6dd592972bf3f44894be9ce4607014e4536dfb343898762436cc712947905cd7e8e725151bad273cc7e134bb53544855bd903e19b4e200cfbe4527594d5733937b02e171e311b2e2cdb5bc0989af370095f9cd03221dd0bbbc9933ac862f377dda023ebbe4d1e940875814da93074d84437018cad2abc1a484a26a187d5c126c2fdfe460b46c89976b02857e086aea2e61fba5eed0e4c4c0f1e843524aad3723f5d55180701bb94b87229e9753fee6d56b03e8966697e69b605b941574ecf0a733941d86861c16cf935a2a514f88ef40a870088789e811a43462a81e5c85208021086f6ca5fda9837051ecf0a337cb68ea3c136762b654279c8c54e590041f968e371b802038e36d8c5df3570141671b5cfeadbaffd7fb269b428db56d31174064b119508b971e7917ce6fb5497195a05ce5ac8975bdc266732b280638fe83968a65c7e88e62e97e0a9a17fa728824ca35084c55d88da80d7872caa71d091774707b2a8d3e93a2292db0151f5734402f0008db4a08b7c2d8be43859c006a62f0e7fb6537f6ac8fc43d09b88f122d7c5432d06460b30c2001e340fbb4a0f323c02b8b412a447181a116844e1e24e11887971cfba6638ed6d1bb13062e85f8623e6f6936415eea6fd264d9a8e3551712ef325d48560567a96c6ffe962d00f5a059d7bf33da7fe2279eeebde8433b00ad5f810d7fb625e6b8ff205ecc732434406f51a5b86a62a33b3c35a974df0d0e128f47e5d49c0d2b856718bc9a30451d148c5f51e77425fd6a1c37b0d797cd6cc029a8ddedc020518f7c2c102a34a8b416dd85aa7bfeeea400ec3eb47405c0d611547925780f6a67cf6ec26464b70d8927a20d1078cdc01909d1be1d52a77707355b61ade20b1177861d8ccd01c435d3910b85906c78e6879c02288d5921ee560d7906f18223ac797160110207082dbf5ba5faa0203332d3eac7534ef46162a25742a440b13a882838b091e2ef1eaa0ec1c6286eb15f18c57b346dcb058d93a085ca04d7b24460d148395efeb08993bb5a67c800752d4f2067a00798f67453a921e5672101ac6f0b3dcc15e6cbd97f3dbfefbe76e5e2768d2272ce7782ed67188bb5158f769771b323e4fe838e566a508e3f8bdc84d1475b449da6266a665c098e195ed38c7d54408c954e59b78ae1c0f2528d779380f6a502cac503f89c02f5d1f46a8c56867e5526b0e604dbc1a2195c980d61831ff9831b8647e20130c5f3c900259e15d1da5695fc89aa2a0b1f3302c3adb87f068f868465af72d2c264a28dea23538cbfdacae66038d525c9e6f5b4b1dcae87ae93635308431adb0f887b8494c650b89f5b33d25ce5f5604dcd87cfc4448ec077ce6a152d0c954489c8be4909575b0052fd516c5305cdd9e01d9294878a4e01ed1cc185dcd43f318c79cbce8d09f47e57e1da7fb1741035de0dd0e2f4fe8dcc184da5b4977dcb84f94bf6e3c5c1ad2850e413d075c1f59b376cb0bf9c3ba1aad0fb4870945c70a4f376f67e24b04a640d0c4504fe5f13a292a32e54df1e396046768c641766cd5bff9ba508fec52e54ae1b05a46090004a69995b01d1a754d3c2e4a5b686f413b5a92e2b62130f37f1dff12d29e9861366a1d379a08bcafe3b7665457c56508e642bce2c202256dcf200cd7488f3348fddfd88529b0ab754fa9dc12a5b545355fbfbc65dd206635f5f44009a1a6a4bfb99b0d5990f33dd67207c2f14b220012cebec72616ae02f60420ca6a6b861e9613d4413977f618590e4f5849a82a09657ecb51477076b1826a6861c21755b9e25111417c13aff1d109f3611102f514487b92700d19115c9d0a24593dea658c53a061cdebcc2f93445565d83a1eb2d8fb8e5a300a98af15b30618237416ea8f41902f6f9b496d31e8d6c24cd8f5e9e305e0141dba80c835802e8fd4a86ce0517b2b90ead1103ddf455a75e664aa3c13046eb53eae20d1f0ec2171e531245e571c25da123dc77e1b06063bc2d890c870fb227839556505a418331498820de7f84d0a7eadfc689f63095fcd0a9b96d80e20a96e04d79f109f59daa0dc831b4f31667a84feca68d2c9bcd0ec2df902f0232e05dfd8f80668f0d8863105171586d83e878d3ae9e87562e2e0be0df4a7540bb1f62d22b28975dcb143384c9ffb7051a7377fa848816a1a6165216f299ac9f0eb3c13379a9a65a37c29a08f7b5ca60e703388040ab2e0f9f9edecac72f4450fa95024c13532a6b7679e1444e62fff8a9f4382d198aa1c0e4e7d0913fd01dcaaeacec8411fe98e9772d2690ea211e8733b68e596295fe0bd30851e067f3d5df139d10e04f95182923dbc7a04d6c17de6a5f6c18103cb4ba19d0a5262f85faba3e9aca6cb5fd9b4d3ffb29ab2b45afad0a6d0124b57629d0c0b1e2b71e859fe745e9254dc898a282beed28c409adc68705812561e10ff93b62177f3a71620b2aebec38c32ef21cc0a76591b5d1a22674d002a87203ea46e237119404ed6ce8ae1b39b961bb33f6eea42d498ace063f1a1f2bc32a123d865c1ba36d0234e472b9a5f7bc7d37d40cd10b08742de7d0923ddad89ea3a503b838009acc9561881044293aae5cbbd4a19190f23c064e97eed720669da61f7c0752ac2a2cc7886e6ab17453299409a888059330ee742b6322734b89791f550bb40bb6cd9998ad51508bf2f47e660dc2b3f922d45e58b98c0528ede4515d416b711c7f4a12d30532aab07aed285075441aca0b029060f93b363fdd34e704ff392c5d88ebbdd9c93f34a06842252d65b63b1ec5ae10c3b6d76c35bd25596fe83515d2423c979cb01c199d2c657ffa60acd52b6dbbb5b5cd6a560155c79efee534d6b158c0a41811e292878cb2f01e257b200730a05c943054e2ae1726ab063ea6780f3838782f41d8cae302566cfe669a47ee88af71320e551e06332a6bd73038e08f24f55b0a01425b1a2ef917f3217846ef50b2dfc6ebfbd9f105c66568c5e5c7551da47065e5d659cd92415b739257a668c958701491ec3bb4266a9061dfbe8be448852f25d525debec0316cba2cb325d1fe09dadcbed33122953fed9b0fed4bf6319f810f45f6b1f58a5ab2dee38b6e777161af5b8ea60008d75154d7d7354ecbbb6b7d4de39877797def1affd8b7ed4d9f0fbf43e43c7bfb116b76ac33932fc27d4107fbc987e42fb8597d8c4bf8cb26af6418f2102cb245a9792760bbdecab359e43905034e646a4affada4f844e4536d3c411e9623ab415aee61f215922b004d98c18e71b74ec2cd92d58433287efbb9700ad523cf24aece6b30d8965c4aef6cc41972859d0be6473f5ed05f476295ee252b5ce5fceb6c932d3e2bf695ba16716b8507a87db37545359747b77426a969d7f10f2ca4d06fbc73bd752949be25b6a56f1829087827b2d715ae272b90d5bc20adf6475fe1aaec9cd74790df01e540f8fd3e93ed9441a09eaeb52c73dff7b71b3849b84ff893a0391c9f0085702b11f16aaba8ff0e3604fb50835b140af2a742b352179c89bfc0d4e013a98bc0d816f7d9c93f37b40b68d3b12835b3d1a759f50c8fece6258b5b11e2bf0bd0f9cf160c5d162b51755ee79d26218120c03909aee1633c3757a3eb91cb3a401a387ff8b24c18f6d31f6c92abff1b7969bbc4ad2d5b7d45c2cea1cfa1e622935c00539f6475204b12173b017887401e4be0ae67061c874d90b05495e68ea178adfcd1328ff7c08f01d61e4c389f1efbb1b462ff8e205bfe74f3c75362fdb5626e9f389455ae4caf39b00088fed13b1c3d43644eeb04f070d57e6b620a6c7cfebb6016c0897f4bd7568dc50cf105fbc9311391ed6bc3f9a93467a151c353986e030228e5d69068b9111dec876a91f4afc5c1c13ad3b90537f38bd235e915eb0b85168199f58b4c6474504bc562771f0833b41a632658b5bee28f371ca848f1636b73fd8dbe0fa1bcd66814b7843ed042d6743ebdd707dcdcd39bcb330774a616614f698a01f2617d236e2c8891d4860373f1917d3d4de40dbaa2076d69394033d8dfdb6caf37d1f53a030955cec1be6fc131cbe153cae0df6cc8646e5cf289d96c4e7f07bf035d10702e39742cb724f55299ab3509009c42934188929030682a837e984135e84bb8b08a481a948e63016477d93a377adc2a804cb3278fac40387bd6677205f9b3221b2ae8cbbd43ea3965b58c78be4f09c71ebaffc76e524aff609021074ef9b09a274b7ba62d601d05a50c31869fb23315d6c5d195aeee1171e15d20454eb4da390970222290fe81b0c9c795ab15a48da09ec80edf7067dcd1e488677b3546db280fac43a7d1cf00af8e7ba02538e711329d1623d925bff89b63829990a1e878c38994d687d46700e2417f18d087ea7ea9698c432e3101b16a0a4377a356ff10838e9c358a38ffae21e36865b199a215b9b2332bd7c920603e27367724c6c2df1292a9b13160282cfdda2518838b1098ab036b4f3b0b1a2fedb939fb6f3e4e5f01317da779f0e780538334fca2ea1bac5821f8385ec1f2ec32b19140c1c6b02860fdde082e5e446c2c08060bda3223c2e8b8d5d2648744dc435d2287c97e31d4ecc088fc2ce16bf4c05a8acd1d59071494793b80ee41d44432de6b8480b664df153a8020e6c140d182561b8dff0edae34acd750c18336bf9edbabff981c2ab4ef9b67d6e16ec5975b93575221e1a8054c811da5dda424dcb9a37c873d6d48c7b3c885fb395892390fb84e3a38fa142fe24f0ac0d434ab14c25072d2de9cad4943718fe1b228592bdd69964c789abf7390c69c1842ae08ec325b6422017d5d23bc69484b70815219f3077b966253dcf87cb17250b4ef00c621b25e1f5cd123c30f04a99516a831e3ade53cb3f224cefcb900d5207e26797d4a44844451c0d9b067485f68ac6fcc03db623dc99bd6395cde143f0d2a3744eeb1597435ff1ad5bd2b50e8a5ed591b170b35415414ce271129aabfe8fa9558876ee508f92e94eabcd2d755986d5793dbe36ef83b1117a7264cc4d741aa6135894c5f5cf751d4965fd55e3b2e17060d33f45a91583d9f08278e4adb71e0e26e864e4e079a064d3583d96871cb60053f611c0284eea9bbaae7202df7cb3bb10e8565aa827c05b307209c890f73dcb4ea156dce923d578fa16fd5db779597454264772701fe9e9f858758750102f7da75791a8a1294e206e0658efd6c26e8965652d4892b7514c70ac83f0b998d7024ea34d515ab93f85c82ee17e43d01f5b7c48cb13b687d1ca54b1640141200800a2f56911a8b8aa82853069ddaf66012cc3f6c1f8a340bff67ecccf45bfd6a9f031f6f37f87d6d963e7f2e93c557fd3f7b3b28f4a672c4ea00829584abfacc4efc1c1ff78574e5b02a8bf9ff229bf1e50bcdde0603e3cafdddb374f19a5dbf4cdc7ec994745951d71ef4f39946dedf04b483c4e8d9e39da357bfef40ee0914dafe5369b2ebef0cf18d4535cf0ee296ee3bfc6bbe9040f71cc361bb368b68e1f3b38a5d0f35b357d1f3e7a54792d9b1af5a84f94d3616e5b9c577d42072adf36e96d8ce1f56151f7845991e93cd2a5f023c42e254cad1be990a36396d0200a21116a7afbf10c308dcb202fe115a264f12084b31b32e1988e892556aa14b68c83d657cb9fd74d80fac6266c19b17aeccd579c48551421065f59f90b0eed6e51a8d381e3ebd2a5fac1e93edcc52ba959fe687dd0bf15a62d271691236bfa5614a2d4bd80a91900b91bce59b227ef8b8fbc2bb3c221b1c9d4afe1926d7fcb90a5193671d2c0bc7f0f9fade4a8c742d8e9a8252056f937a771d53cc75ae83824c404fdefb0dd6dd4ba93acb1c6fcce3b7e0770705d6cbf30c9cdd9a02a6158afa4d92043ac6a2b05dae97856fd0008e417d6345036829d8cd37be6322a20bca1cff5ae6fd08c525c8fda31a151fb1661080cdea5858a99f3a5e25552b194d025048441370bfd12bd187aea4f08d8d340512e61a7823723b48770c7fda02cd45101b1c276799180bc375a6910383f93b60e62789c3407e587322ff0258d8c25b5ca3800a59d5d61655c919dc3ec1d2cc3de6da90a483b23c0587dd8060f586c72d02525b67f6d3857eae8e80ff881660026376734314003ea52e3a3654ea6b3c8b0877266d6239421926fbd2d53dd87ab40df0c19e466c623534acfcdd593eb5f72af43b400712ab7799aadb6f6da7e95c97310aa43d9451097f077dd6cb601b6a4724410864696511d90ae181b71b23af5bb7a2d0129da6d43ab643a93748c6768b5f5e91128106a363e5e020342a7661e8455dacf528d5b876b59a711597cd26110a0175b8daecfc4c646b395342debe32b4028e4567b4d7533b4a5bd22a7eb48187b1257b53e49356e85058dbe0f02a1d4fd1508319bf588ad3e4bc77a04565a3e27353784a3469f0752ed1bc76b49bae667e9d6edc955c53ddca6e9bae21e56dd0f4128f38ce76875ebe3238044eb5668d0e0f730a5b9e1bc2ea5d57e226dba3dbbaedd866cb4ae57aec32633d5fd150cb1ddb84aa5b77d4a686f0a071abf1ea6b5b74e579274ed0fcf408150d359f55be735298df6b3274069c3edd1752e7d732bad8f8f808110b3d94fe1aae62789d6edc95522bdede3293020746ab6eef674ad7219d6738b9e31a7cfe01564f314eda535a6bd02c2d161d4a8d18df93344becfbec845f89fd4a3acb91f32e5f7ebdc5e2709f29f0cadf0bc7dfc0759f5707a7bf03fd90a0cd1dfdef8db5bcfff255bd090fee84dd827c9da6ed737f704e010c4e42ec41f7b77e82f320b1ea2d33fc92a70487f7ba7fff4be1f8028cdbe30b103431fbaa0ab7fbd88c6004fb9fd4af5e0c1be917cc85d73fc4163f909542ba244883507167566c96021699e0754e8d9fc0f5edac2c2d4046b4a192a2681e1430b18d11d2454965df7dbebe52e9c90fa5e0de7efa61f5576fc316a36a17166d84f674080348781eae1d840772156751734d28d90cfd8bdc2cc791f874dfd7afcb572f7bfa39b94fefa9aacbeb2e6d8b11fed667f56b07329463e306c5efff263ac4fe08deb47c963970032bb1160c1d422119b9ad2497ed8a37e040fb983ff5af2b1fb7f80bfabed6dc251e13015dd984f99769bbaed1ec83c941d7e880834c29eee585be12f8bab6978e8f5ee0ea216f27e9daff5079901da399756d327c192f6a48365d869880322e18c572370fe3a0f724bf22fb7abc157fefada15473cf55fca1653a56a0464150784821d6fba4b0b0cad77b38815423bde72eaa24b5eb38a67eb1549061309d134405e7b9fd1d8a27af697beebc6dd580c624a21d7acc42a5624a22ce972f16a4a7c9c401b73501a611e07f285f42747c157ae801b8a2de289924794f86779ce4725a62d91aead5948dccbdd752219682119b45bba2d0c6854b04919639c40074ab1907f894662c258b4c6268f2ce49acc42c9cd23a5c674591dcb8bf0476481d205f8dcc8e8d0f3c89f0c2b5fd1619be27f8accff0745c3f9525a6865b10885b359a4d42f1ad2ad821a1a64818cd3109047398d50be4a96e37b6f5e9262853ee67371d1f8fbfa4e4d0ea4c31cfe6bc85dee47fc7439fa2b78ce2803172d9c5b5962665b162b28422cb943cf1b5b9e78b5baef3a517a9a7dfb372b6a7b8685c5ef8fbfbb21e8000d7be14c738ccb66a631ef7584aaaf4860d0740bfe0fc21dde115d4374e8d5da5d58e96d319179a91168d93c79f1d621bae6d1b792bd9f90812053ca4ed4a90502cc2536cb80008f171fddf736df8a7a62986899c8fd7cad17028b0ba10d08dab614602261ae2b98f31d3f4c47d68de2abc3eb6a4656437eca6b205bea11d53e8142ae95be95b3da8cd18ef76ddec7cb851b7622d506a87aee324bf452277d932e4b7f795e41d434ef7058459d3d0eb7ec64ee8d4954ea0c4ac23a448a20d5794dc2c380d9bb3cd28561104a0bffa92c15436b516a7d459e265472d9540c1c849657fea4b25db5f08d377f8b0a1dda891a8f582d5a585bac33aef7026b17b73e43d8e1f540d990ebb9fdaa4399a9aa65fd4b406bef88025aa7a191dd2554c88ab39a93b696307d3656fa01474cdaa63fa00e04ef19ca1d428e60e2daaafec19b7b505fef43dc6731a6c9e3b8bde6953f40b7678c6970b825e62efd77987ac940706b21f5bc8b4e69a19b717a4bfc659f88d2579cf97781dbb9134bb82dd5ff48752606c331234c1a71bf3adb953b59c563fc752e0fb1e3982f83d01845e654fca040e700e69b193ec82fe3e38eb87f456078e88d5390f0b20cdee94b3ec55c343ff114e57efe2fc35ef73a7d62848ff7dd405f6c6b769349df166b12aea1338054674c358903cf8d8b48bf737394b7f744544d2feac34c37e72c9f5a59bc2d557d23962623bc62fd3efb72b6140e3abf81fb865ca7368ed6d46a7a85f224ee5e9f6884aa0d9164302b3f80510360bf169168ec1a5d8b38bcf19e32d84fcea3be09d1bfc7d701b3fb9ed1d0fd27d9286928501bfca543ef61ed20a1d4bb7631c925b9ac320c5830d2cd81df5f8e8e0bedbcee622a6ffd305a70de82a53b876859b3abebc5c901de69fea666d7e609a0891b7ff40f467483b87bd967f0c6cdab30795e5d715d559c9fb8fd95b789651ab5318a1b92cdd0db88b63736c3f12e009631799c125d08ea60d12ea03e806a438a3557d2fecc8dd28524555f863638676a8df56ec46e602e7122d517ab4cc876155f1fd07a70f50f71cf09a230f5c8864f3f8cd2325a822734953e5bd85aa3ed48d4772516d543e691a7c759ffbbc39d0375e4972e4a8173d7edb990a66e54fc1212888ba79c1581d7bd47e255084917dbf56f8d26058f929534ffb48ac8c558bfa9a8b9db2722c52df3085e1ac2a87660af55c4d5685d8c849c8634ea0cffda4d91ee1674e2018cab89a554a6f8a7d974ecb45ac30513631651af6660f9f45c7b1919bdcbe29fe62980ea659c28e58ef0f6440d2a59b764c30901cbf4afa9d72b9ed69d275310f02fecc99548619ba50de5d1252ceae54035be7437774dbeb7799901171b54ad0d6540098b1667e450fff2ab2e125998ee843e44e9a6ccbaf69aa42a7108ca0ad3db02fd1ce0ee376ed3d0300b7fcb421f11af3330032b4d9a7f22415f3cfc5761776e880566d7ebb32956d0d9a33534d1c3e326b9faa744da12c1a491fcaa50fb5271250a65ea70eb7a5d67523797dc0ac05b7593602a46634c29781b6325e36949c508e8af3e76d84f534a897ab4ec3c124abaa0e367cdf1d06b97780efac5528e477e88ba1b87ff8cc8901babf44e0b19d6f2f0e551212d12a7c995638ed8f86457e555586b1d89ded3506731853815a27fe195ab9dd25788de93121aeed1eb4bf8172ee91990d8b7c9b3dcc48e6ae6456b68386e3c91761d6bd0d43371515b4134bd8a59886633ffac12576c5f3a09d7424de3ffbbbf4793efc90446aaf3684ce09a50e73430aab60a5e6b588c99da6fbe825c7c9ff45449df600b20bf77ee9d039497d61e2d8ab6ed6ba045828635d4907ec5c7f580701c3049b80284817bcca4506eb12cc7b54e97e483c21ebacd67e2ca1b565e119d49c6e84813ffe9da21faddc3c4099a151cbc04f76f22472703e6ec03f218c3e5722c66d3e0988b2f49108a13f32f5445de7e68b10373eba433ddda86816c6bf2acdd40bc07d9cc31f4fb93e4f2c4c0c41d57daaa55b40b8eda685bfa3be43ef755d875e4150870f48268eeffa84e9f725ac38360fe6c036d711cd0d67cbf85522a2c3788fa84d802e485ecf7b241858c48097f055432227d19ad9b1d8a0046ff16f668c50a9961e4d69fe24f2eb0f0d8a215c99e104c785c4f26970e14a788c8ae84f3b3cf111f016610b17805e6bfc7509dbe5111a3f69f7281235e1e91ec8acd47d273ceb0b05740cde61c2c8120f0f110808bd24ac59d11dc3821aca83849cbf868118bf0d7d3f98633f4a407cc4ed7a43d3ead57bdaff4eb2e5bfeb932fba6af2f7bdd0bd4c60deb887a738fcc0dca647b4959d1ec76ed97f1e0b72edd5a63924e0119a1e0bda7706e1122d0d72c3b7e0802876cfca8714a0dd5fde04bdc655a8b8a984e063bb256ea33c6caf8017a2d3b6193a868f6494b506c944c51740c6e1fbc69be9c859daf3f16d2584e374f35fe6b8521828f6023f939c68842198291ec47d82d13c9355a837cb49d75475a6af0c81b1bdeb81c42ddd4b186ccea18a89ee699bf8c0bf77c626501dadd9e59c4ed5aa4d9b03b8e89121bc67dd8dd84ba0f3c18014b75d6a7d5f0eb0981546063bceb4fce36e1d4a869a4d35e10d9cf3b03a7ffce7e8dd94c45f83688e1fe1a4f8f0b3712865e2ebf17064cdc3dec5709d3a1a1b2b2426f4846fe4c19e7791b9b3116a2cdc3cd84cafc528a3bdd167a63b372f9721a46aef15663c7e7615d6023ec6f3a368c1c24661a128d0fb5f5ef0a34fb7a68339d0ad5a78bd3a1fcf0561291ada4fd1269709e02076abe9eb848fffce711b73ddd557f01aab18e773dd45825174035165107bdaba788abae04bd3b2bd56fe1b4107deff3e2e1eea6bfbbfac25e1a277c02d4eaa3f9788a02750468e6b09a77083a6a047e7945c50f979a82f21c49b4c537359682549599251ce618b011554411cfb1b244d6980da2a69a45ef3d1c0a708003e96e4de7e4796bc52ab1ea4a2104a50955d5cb989469db0f2d83230a7024c2be5108e72a04fdeefeddf883ebd6abbd52f757d6d7f25e51b7bf181ed348a838d86c4a54d208a2944326018cbb01fa3b254459404c31930e92f708f42ca7254892a7b48a3d650cda9c609b016bd8103ecf350f35795247f6966aa65ff1929d68ec07e65df15ee9a609331e46676e78508e2bf29a6564abb910a462d88c01fb43d329d436d964efbda59432c9e20370049f04f603021aca40426d32bede257ec8f48ab60a81aa4157d2ccdd0d10cb4ceff566b5e6b9905716cad83dc0e0d21ad9839858a2bf436640a637cf6a0d93600bf996dbeb02ac4405742d234975e5402412c50464504480cc5a6b2d50ad592f7119888307d50e90fb8e186480ec430681206dc82fa0404005f88024401e12db5af08548ab2e0d13bae60908b556fd839229dfe8960a7c7001103ac0554bca21df9c3dafcec16bb797dd25d28a446b06b6edec1b570f6cb01561db85a264ebe11066b6b62052a135b97a259feab4d43c2500fec1ed5e85cc64ece02c6b00aaf7822ea2d60a921c3292946f690ae2fa976908fae1af59e2065204c1592e69e41bf8a0830efa0c04414b53d15e10ec85e400f2e74852d8735fb200638c31c618037170dbf75a7b814a24510014cc8081174a5a59df2f94958562c837bfcdca0ae2b6c13718d61e5435e811fdb7a1efa5ea1544b523093b8ec837f06df50ac2da0dd5a94e6bf7f42fcdda06e1738c3fecded841f7f97dd8bf8afdd6b63e0bafab9318804c6f05d885dc640d35087f4023e4a96e8bea3178aadb92915dc8f549be799341ac576f1200f9067ead20da0b05d666da4276a8d6acd76acd0a69c9e550adb5bbde0cb97a45412cd19f33fdc412fd3fd95620529f8c2485c9183e02a86660cba50c456c2e324f7568bc7ee8a90e0dd5d3f184f74563165169108d8038d3695175104559a64e3d3104aad72b8ba73d05b22003183ef5b61d54b7ee8d2558fcf55bab5bc763071b209ff644d7eb4ff5c1edd55adbc482f6f5c8ca245f5a85aaf20c8492db6fa05fcf17935c2298e905bfc51f13f4afd3a00dd7e96f28d17fc90bbe4978d0cafdb70bbec1bf8086d000742f19e47311155ffb915f4692aa640c1f416b0637f0bb56514abdec81d8b5efaed59a50967cabd5a8b5f65e8bb3d50bf16624297b9d00e2aca621f25497060a83270106d5da750e252e3b10870aa2faad59c1187b4c53d1df1ec473ab1848ba3456df34aae3f27a3a5692b41949aa5a37d1dfe51ef770a5b49a91a4aec7f01152d891a4c09a81e79e974b39c8a3217646926a135da29f66fa095d095d39096146bfa4f0252a84995013dc2b70184c82de0a21279e8cb434835e07fefab58d2ff83cd208ff256f69895c8b73a5dd80fedeea1863bf98620dbe1066d62a5fb71a84e2e4b6d6f6f5be77f6445f3fb982f06eb55ab93a7decb5d6ea4454441a7433dc5a9b0999c94f240a29c9ed336befe7e16bab9610bf21e857129156db7d868b16d2ebce84fd6df6f5ccd6d75ab5745a37bc445aa5f840d2e5caaa2b57c78b935c560a4ecef4c89a5241770296d41a158ebc11d3e58c1126a9ac5c162e86317cabdd2ed06d696eadc5350bb0a4990293142142c40319c4636a6510ac54e30585cb26c34c149d39c296d284174a2d28a6aeea6f6e53a273e46f6559eae810512acb058cd1a93107690e4ec69c11c2847861533170d812dc0d9382b3615c706594b892c2bc4018be5e589a7d61cd10bfccc890993ab2b9954b1232ee4165c303abb284bd345d1b52eeac031b9351c360e0c8b026187276883aaef7f585f565c65a7bf157d8979a6fe6799ef7816036c090c2300c65229810b01e198c0aac0a98979f9f9f9f9cc1bcc0d0808dc1d0a04183860a464adb86e9086b12755f3f92bea270412878aafb52c266cd1bdb13dc8604dc068f0fdc26076e03f5c2060449f925c3502e99626392e304cb41222748154521ded49299941997b032615c1efeb4441b95af1f5f510f546b12f8baf1851bfb1b18f65427078d9c3272ba7cfbac922410c3e8cc419a830b81ad6a8a4d08d5234629cf17374ecc4c098788e001cdd5e71b449f398b111b3e18dd8782e0504dd0af510f35eaa1c120d9c7212888839d7d08b3f73c030db924914762cba5ab0a98fc817cab0501790909faf1d5f38826623fbdb42bab6bd745064806441b946c6b926f05b8304010e95714ba2e23d6b69567344457ab37f26c9c2ffade888271f6edb55b7c5104dec8fb69916948445addaf83f5da10883626b97d66abb61f41a5add65a35bcf55aed07272c6a42d040c66b3d14eb060b55cee6d14d74535a67ae0d9493ba99727572907b01038f4a8e474e890c3b27d8f9e5ac9c2470b016c02a1255c74a8f330e948f25a7184e30e70372755e9c7abaebca19811c97ad3337766e39c99cb95c97b37339b293f8e4a29c5f7250289e3a6387c971a08d0b4d6294f92145eca90d1593932cd725b40e387dd4545184349533399aa74d2873684ecac6022f098a4e812125e5f4713a97b301b90cb9761246bfb8fa044aa795a8988db38d20c06a03a60db927670b66fa85b3079133b73586926918b4502f37627a085503e6dc71622585c8751634e700725761de50aede42d784625f504c60319090ece82221e754e46c3a676ec9d94072d4ca996b1c58ce3267063406addd99cb79d13bfd8467860a678e3e69ab14ec60da0585734c379d39386067aeb3c6ce386797e91044a95c600024272dcc7d9d09c869c9d19d9cce33078637540addd3317427fdd24b754c8f8c335752acb042a72e1b3bba8a9e51e3e53c72fe6893739c233820c849bb7214a4f172774e30c7845ea15927f5b2878d99d30590294cce496cce49ab206970d234f77e3afe63932729cca163e3d52442209783a2d12ed66439c3a8983387651627eacc39e1ce38556270985c4c9933c2c3f19ee73645de9b31c2db21a7458d156c4128141b9053a4ae9433945983f554b726ca8f4adaaf9a286974e50d3b1998e2844c580dd6a8e60c53995b03e4c7a7ba354ed5b6ad55e55936954d69aadcbb01351580dd76c0c2097df29708e3ae569e7a74f0a07a49f5d587a27c78fe8d627d6dcf6f50ad559f40b68e1b9344d7f189ebd80357670f63a9b57660bdbaadb492ade5d75dbcddd7fb3a514731c1370dc4175f4cded103f286ffda296289fef60c3654d043105c41677fbdd28a0278b4c88ee8e08c5b688a02ee9ab01cd1d9d938c106d49c393638f8032fbabaec50129ba366840d97bcdd7a20fb74c794f5796a58d1c082038569c9c834e5851bcc0404000e2822c606cc489a1f7242aaa75b421213d3d10c0b4e06a61647f7de3434dc5c11588d45dd71fa121287ea6a6c097735c2d0b0b9710fda3181799fa73ba62a7ff35274022956a8844a035a98e244513903c74992375e5ebba5b1dd52938d4d8804a703e378e06c06e2ca1a720e8fe07078876b4ab271ed70562f80a73bdc1010bced374afd5a15d501df5ffdf12561bb9ba4fd2c6e5737698ea041a3956fb91a5df022b0d0a0dbc988b3938164cb1af2435503638cf1ed70ea94f1c0b5f8763392703632bb195ffee7e96ec694a4322cd8c6d8c6ec94bcc031afafcea12d50e37e754aeb0fdfda1fa291ad1be991d65a6dd0c7ba881abe25e9102e5bbb530af3e2d39d52162b0fa8c96262430718205be10a6d90feb651f29eee94aadceeeeeeeeeea63a6a8d3e25bbd80a6206d415a8167d6fbd679f375a073fafe14802246bed4d4713f5ad8bdfccd2ec539b01032e7a3cdd291d79513692189293c3d184b54e7a60146cf28215db7bdb12b5c57e6ba7b576f3a8607baddd293d398db0d65a6bed968c9fee9470947894722b28c9f091f7fcc5bb24342f7bba4b129382dbb2dc005b0ecaa15d1294b74f77494efe56ba90e46fa5ed04a932861f729ecca35c799524c3b694d4428d18d51b130757a9848c102fb61956d23ce14155fa50a19c03048a470a37cc183196cc3c315e64b1c3244e0a6aca2e664a295faeb0983daeecb460735ac1dc09f92ac17684a3ac8241030e0ca43978ca3a5f43d8985c593274e52e0b10296617931f53259714be4c305fd0b10389a9dc428a619a90472aac44a16b4c2b29cc912d245009d3c47603898985c8181fb67387c9e6a849c99152a9678f39858e0dca4d0b68ca27634aac2e495e306f58915162a351c47c8342c906aadc72be98612be1858b72471d17e0b84893a38c090396c9c295f20428659e25a610236282bc4082798e50da71812bb5b838ba72078a9c2f6bcca918cc2c30b61830d8784429a5aa4c24165018d2a3470c39b0d43099762d605c19b3f5009b6a23e74c29b6339b6831974c797281c891b284a812cc092f9c6cb83d364cab3d493ef4849993c5ab44b265961163eee11255a58472528a49a2470acc0fb127734dce84a1474639a6a785ad8598e9e4cd132e3364a47809b3624679526651c551c13403a424c3c336c20d332acf525925cf0b5b0e3b5de2984e6a82982959f8f294432c5e7278651aa932674c955ea24a273e969e909c34c696cc2263472ae0090266f2e82acf6cd99ec6bcf0a2bb6233e1aa6c5255de99ba1365d2f16112792a879c65f02cd5c073545ae1319bc06c4d5d65922daf315abc9463ae985e57260955361c53e59e28b3ca8789e7a954e1b4b9b8b364cbdd392aade03901ccacd2d5c25679648cb98217dc9512cd559baa335368a24c2c1f2d9e6c36ce387696ca37768ecc1c1e9b0e302a5d495b25d718938917b3ce95d2cd559b2a38536ba24c2b3ecaaea71a67589d251b8c3a475478cc12c04c2e5d2590ad126c8c69c38ba974a5c85549a76aca1495a812061f604fa69bd34c23b654fe103b3212ed9e5bdae798835aabe5bf0736509d12580d3a005aa7510fd5ab530fd53fccc822ec065f39f8aa0297b556bbc90e94be1d010d61bd7a394443d0c7b7471b4c82bcbae184e71774a72d4f773ad63c039eee743071acf7a7bb1d475ebc333be219fe661eed5e0ad0f71cf44b43d06f4f71ab8ba8200e7aef44fdea462060f1f445d4149e57cfbda741f6e2f0edba672f066b2de8b1cc2fedfb482b0b41ecd73dff2ee897e679d05f32c85aaa3abbbf5eabfcf5ddd31a11cf9a7641152b8a3eeb4645df5b3ca2c0d6abd75eff76704c7167753c71ab4822530fedf4b675f2b9f7f50718d93a55cad741bfde3444e8177c9987b4a29f6fda4d067afd79f8b6980e281db86ff7c6beddf37afa2c76fcf8023cdded40fa158d45b0bd968d24ba7be620f8854dde46bf79ee5303123978947a18fda3c93c9016f41f088e34702cd16e5d846d1c1a5ddc0dfa6d44e1b9d7f5236ab7fe91e2877b3cd1ee919e75fa91e8d0e4adc353a71f60e4a29f6feaa1dbc11c93173d0791a72f6281c23d7d1c632ff3d0739079d143bff9f82d8721a9211465b4998fa1e8216de6e38c06bdcc43da8d05d8e1cdfb79a3fb335f711f03cd380061fc83431f1f692038a290b948fed06e78863d4f45d1087e74a3eb9ee823f369998ba3e8230d4d84a4e83ea2288e331765b4cf7de8480b7a198dbacf38862842b0d6c21926c70e2e7bc1040791a7cfe28b3ace53fc2376a03416df23099ae74d54bdfd03699edfebb74a3159d46f9d08457bb56c70407d88a7bb11b27ee714e694f51d3aa8e8dbe79ed7cfbb794ec7122568d1a2858bf7c8d9075ceea7ee7d14d3a0ef403d50f77639afbf4ec35aefb8c147269bb94fb563079ecf3ae4b16d588915fd9f7f7091653ec296ff5c7683cc5ff1861ddc121b464a650ecedce83ea52e8e764421238dfa3b45ff8cbcb5254bb47b200d6560fd3c046927bc15fdb3b65cd7ed05afcfb07b8e6d4561dd5e9a11ee6641b463ef89e0f5d89b4c1396af1e3279bb3b897cf5d0c51fd0fb1b4d84dd32df50d44fdde87e7bd1cf37e9e2471a759346fd94bc591abd61577122bf08d543ff42af5eff0b7d457fe8962422896827784abb854e43af2e86e058f4f32250eae1665358f2d63145f5108734a3fefa3d82e486131f1149547d453f2eeabf41441a74fdc3f5757077425d10cc65592b55dcbf95290ef04d0e0de0c38d6cade592df62aa00a7d4baf776f616c4758f8487e997a2c5ea15df4a5e3a14f68d1eb0f803807e1d743c9e188bdaa81a358aea449804bd2c22ad208aaedf0bfe54500687d935cdb94d5d1f3edd35698979156a674349d3111b53029023a804cc983162e8146d800093160000180c08060422912446a250dba90f1480076ba22a604026a74a0261280a83180662188461000040300060100041188ac11854fc696ae111e10cd10d4adfbc73855d6c5157cacdaeffab8fd83d5225acdcdc68de077071832af5d2cdfabc90ca8e2f7f8c1279d154a6e33d9d7558cb590c132fc61a6a10901aa598ce0cc1f20c0ccb2640a9b6728ea42ba70bcbbf03fe651d285140cc105c091dacb07029941d5b2f1e33e25c8b669a1dfc76c6e6ac9840555cf00274f7292556e0b781ee185bca54e5e5559c2475ee2120161b6c648dd381deb760b75ee8d7b9eb6ad3e9a0d46f6f4b2f1cdee79429846ae5f5beaf9532df5bc74d7d3181fd89326ed2c0238d99ba2300cf3b1c8729d8563f61c925b8630918259a2b756a1069717ea2177a486599dad36d5b4743f8d45b02eccf814f269d4916990b8615c0150c1805a6a9cbe9367557b336dc615b3773ee07ec408d282987cdd98a249f89508a3bed15e2d030f1b7c65196289326d671f83f4c878ac08855dd3d15145450e449dcc2e46af93e83280e881ac1020d2cc3a45c96ef1714c1c9b4ce3e988238eb9141308294b8486afc40e39761217f810a6ce77e0eb6bd62d73bb0bb5e9de13343551cfaf0293203fc8ed9a3d3179c0fceae403a7d1ed6aba382889dd9c365da81c119667005bb2a6264678abb08f9c4f86c8377f47c0c10759f5adbf434f2d7a12ac4ba24b2c88528832468a6dd6d7603127a32bc643541a8053100f150193110540072110aa43d4d604e40eb86f280a677056eea8d98a8091b66bf68ac3d5bbfce958c2bc68ddf448399cb0e2736b27cbf2c090e7c3447f81609b8fa5236dd012b3b2e7092ec10984d1d100d3e4cbdfacc0a81f6b55b82fa622ad9fc8283971daacc47ac8a602cd2167804472ce35b200b78f860d56d07c8bf43cc5c36226dfe2e8603a3e007e1fd3ddf6f00b8a51595b6d6bcc8f6586c39f7f950014c6acf1d7ee5dfc5b21e7639f2faca85c490d85232a757185e1379443f4766b451b3978dcf28afe121259f5a428cfb9b8a05fd9dfa241b6f91df05bff4a848e24d692ed71484f1d701dbb6240c88174a71a434aad0b97aa508af2a69839902773466c15aa40a7e8ca38ec26fb4e9a88d3ef3543582d0950342440f1d07de537c36772a18692039a61e08724eca09b2e20a6bfe040f4c0cd8cc82f0e68cb5b8cb10f300857a0de483f3e358fafb7ca02f03c68657034be02aaf97dc25cbe11021142143908d6ff1517bbb0380726303058f17ea7a30baba110dafee98c9a78d0289b6ab0c425e5b131539ea8010898a0ccfda467de2acc708de1b9305bed8fee4859cc9b998872d7c3d40427dc96ccc69cd5f37ea15ab0c19ba41203c47439b7dca07b3e5849fd63221580870aa7f1b82d297dd3be103b97117fe3305da99aaa26500d855c84a1bd93cf9264cf7434dea47152942bc4684482632cc0d2a8da1d03804eb8638036b6985d590f6dc058877b64e9487a434499188dbbc8fcb1a8e226da167e70e075fbdf7c048916f998a9f18a96f32da0bf692e218396ae83dc27fa11a79077bb774e01c0526fdeb10ac2d3c9d01d230d23de224ab256f81d95cae2704eb805268241aef58b49834cfce937034b68750c284ef428d3655ebf60466ff44253edeae876ef04a7308533c65f3a2191604fe675815ef8ad254ae12403751020103a396798a16f409de6c177c113fb874b652893761f5aa8c06d4372431fc9c64b4394024a02263f7e842c4a28b36ec22ea43c877f561526c6d4223e0ccaaf6eab4b6d5a12e11af82674ebcdb3e5889b5ee4eb65b828ceb40c77c219825f6613dcff4ea2a0e0d16d1664db8be1aac149300db70f56bd3b7d8406a156b11107e30d626d10ad5fbb75bcca7bcd41f140fb3421d85e5103ea54945bd62d5749a7a8423c7360205160497a5d01cf00bbbb96cf0a03812aefa0931a6d6917321ea4591dd0b0511ecbff0c3d2f7b4c230ffb2ffff626608b94c6fa52a698bdb39feb55787a42fef2ae9f537adb7d501c308a5bdb9b989a9fe6b57f3b49ae23be0e1cf1cb01ddfce3921218a2dc91280dbd7b89357640a411a0b9f52a181364e7790298afa9213bde4ea2c53f71d4bec974d3e234dc72a791404ec71b1136e8c7613bdad0a6905f138d70b201d85633374c3f9731ef882e7a96f0939c5238d25c881cd8050ea74cf1a34c6df452c976e59fd4e40d99066c1ae90d6dd1352bc401759f0e42a8abf4adf5b6a0631ad27b030c6507a22a05c8971705026832d817aac4ea137775eebf5199d576358929b989bd6673f3287903d8509ff64299b3ef273ef634a9e55c20e7dc0bc7199779071513d208746ea4342d61b51297f052a79c589f141f6b48fb5885a62609d4de4aba808de60b2bea5497b2599df07bd949890766321d1fd058489cf8c6007b19694f57d25fcdb1a1742cb12875d87a381db63700d6f236b9dc7a2cee5c5e7f93ff13bb92852ce48c39ae53f3c1440ce67f81a7744082950d5d7e2a51a26fc946437189e0e40de978a6ab75ee422d02036efbb1b301b35b071867907547f39288f674ea7a324062ae8cd21a2f510d52a46d6ffa945b3991c109be2ec2d87bf52471c8f25b4c44964ac3864e66c12b6cc4b21198f8ddf31b33da55434e883a41ac67fa30a872049cd9cd3d8845b4de12aa4f25ff08c414f9e142d4bf7ccb32ec6b4830a392ee26f58b33cfd46426017271918797bed8d8f4bdd09569ce95cd8224c843345b67e4d1bc6643d39e1813bfeb1d249249c56e445d599ba67895a07c43fa7164723078dd1d15c1e9a6bdb2759666c06d0a48b9cd36ebcc7aaf844dbe2783cbcbaf3826f36b7bd63331829a9e5a261044adf67f1cc81a01331cc06ee82b106540203e234cc3e20d36c6c69d5ac98c930b87f633efcf8945b08d4a0c9a8a43c37d30eb00a4dbd7b61a925a5ac77bd835c4cd7e3ed79bf85bafc44ec9d609af201db1c6bccc60ce906ad489d9e9674a526cab6d1c23321b4c097054f62f65244e6c0c7b559d85a45a8030ea72505a4fdb5ad856177eaa9005d99a8b42a9885af4d202eb0bd029488a5019b0f31abac32b9376389d784f8d4375dec91a61cba3fda995a65e3d32adacb5ad33e1819f843c288e2cbc0dda463c69b0653cd530da60a1c59792b1ecf899bfa7a9d8fedbca79893e047a31e925855e70ef875be3d1eb4294eefcc6d1b38b092d854eb75036bc24bb5475a066ae517b0c869eb91caa8a24442f68899ac572c3a81c16eb4921d276afb4ce383f741f8086f2210e3f8797928702898b743a53c5b4d59d8141c420e221db033f651634ecf23cd438eddd1b3d9517f1ad3301b7d514b68d7876e6fb230092a1b5eab1f8c9dc942364eee66e1732b188514d13dfde661ae15713916075a818e245c694e46fbad8a73e80f074caee4ec23398a30f83b0e76731f2524a8e1893fbbb38cee05a0f159ff844817bb5e22801c6eb222bdd7b528476a6c1920008cdabace58c39f5035be4f5afcd1a294a801a6f74d42b20aea1440aad492cfe492a60c503f4eff54473b9a1bc1aededc5249cdc72c7d5bfa1440ab67ca8f334ea48c93f7616a9d4b9514357a2e55b32c4f63e698d22d754b10bfb81c97966f138222445ae6959923db6693ccd474dfa64767cdc863f20f2cd1682b1a82f03e652a9c5f080e660ff75e4549610143e1e35dfa75d5bdb1c1bd982873057734dbb6530894b52e6c9912c8b9d45182d89d03208974d0b8749a1099cd4a3c3317a5c8bed30eebaedb7dac9ef639f070642bd6013df7b5cd1e3b71685bb1297cc5853610912173779da50f3f5dc400d1b30f55208ef98e7e401fc5044421fefff76913d8779e11e93bfa38059a96cb755ef7878214bfa9d04526be9866ec0d1c136fdad2da0d20b60e4d5c5d73f35dd8684354afb2b4a44994f63846f3a0d3b5222caa64010772638ce33f271a7f03b649bd8ae339b5a2c18fa4f87398839c87ec7cb41dcda1fece1a80ef23c340593706486b07b1e18d80f827ceda83351477e8ed76d2375135df7626abda085130034f22880e054d6f84f18528d81c5adb32cd85275d11758c30ae049c7225ee1e0311d04db57dd4af396edd1bbd36be9ed649f12c82e1065393afe5f314c8db69cc2b4f8811ca4e63115843018ebdd64a6879c86fd4db45b5e452dd8c3b58490081cd7b08c9d02482c9c20c3d9bcdd15723bdef419732b5c417dbb7f9f63d471a287a80b8563e2c19692e596e5038abe631affae8b8866e02085530f33dc65ef6031ba69c318ee631cbc0515c723d82113835ef1d998c264b4909698caf265a53630897a2a495c5c716d5d8c542e4233ad5d542eb18eb04f0d00791e082b988b574bc3f128f9704ead41cd77a9426844103a98167d44d97ace544a52243e87c04e2d94d18cb89f0754e6b9a69b19b7c7bf4c58b3a37589bae0e8c8ac3e927a4b25190d030b0bed72c0ba734409e3b68097504ae3b1f8a48ae31e323b0fe4e2a4d7027d0ac60acda63a2df71d58b61c418ba08b0ae987e774c204c8ec405126d35e30b300a838fb01444b75f7fda0e2838a3c749c6b9c8cf04dd644420a278bd85a41d38b81376fd08300f263e09622509dde9e1d751835efe0d7d56559986d160d432021dd8df83f3e41e32a9058c54e60994f8cb24978289123316b9679a738c056994a4ca0b0aef3fac7013f7057a4bcedc14765d0ef7dc85013dec130b174e3c13e266cfe592d74496f1decd8598c8db4763abcf863c878c6cf804f4642f306171163a8ee22ac2d1ccbc1474467f20f508bdd7098f732c60c8f41b303fc6113cc74afdb0d8a8af79ca06ded9c1497f6b439bef2e08d0d36a6a03fc0888bd6574017c5c9bb845aa2723878d0857f7ad68bb4a9695c7ad8f94695d6d7e4a38e520ac37b7c7c1862419144a37df5c014bf1a6af88d38b2293b0b2792c52a82f7c90081a0dc47cb1760521b1e52259aa8452a46de052d92140987b1349d1c58dd979e0254d7f54ce0c772c3dc9f5364f3fdb2c89de47b390fe3c268438b06a516647b3aba8e9959401ed982bb16b901f496afa453e5d6b32bf9171c93f48cbb3a2acb7c85c2ff7989c71b011db0e9b6d61b62acf96b3f08619e84fb1a0a5cc13ce9aac1bbddef4f8ce4f285c1b975271cb9c422f93cd869019817d34a5eaa920faf2d4b24df84e4a0bfa8670911c6f3a2c42d6d46c198a021dbbde9d046e1451c5dd60c5b5bd27344f4a80799f54c7526c7f4b2746ce44bd45cbeeac757c26fb9660a3587353c0aad0633aee0e4964d08e25def8072bfe54b420b050d282a0c3aa32fb2b721e96d09bd1f9c48d66cf325de169cda579b32f3ce64c525c773d0f79d54b7e17e0b17eeb4ab505d72114f250d61c5645b96e7f612524deeeab54c6a0bd71bd661864fb08baa6e2a078df09d9c683f13249f2655f4d018a83bdf4562e57874e1e34323d47a49e67cfd546deda6ff61d1130b1da5694c65723f416081d3b6d89f2a7cfb4b0adcb46f6e4fff19877ae73cad32226ed0458479ac746d41a3c22b45f1dd622856eb457ea1e4a0d283276fa9d91131b4e4e02072a17cf9c2b6e5d4953de16e98e34052b61c3edc5efdd4a22989aef84692c3eec2171efac1a43d46c4804b506a4cc3f20efd2e1a8383cd313bdecb2840899b0c49d74f753eacd82fc3f1cb1ee71cc385a84837be940b9a5b16da816af903ffcece73d13f6e993c40d7e9b9190d917046adddec151a39315bc2f9550c75f0c34d67d42321da1b751fcdac4c4de99b907358a19584069f280ed63ae55f3dc88eb41bc1a75abc9490c5a8227dbd6a79ee2d481c4fdc1989d3c4f751a0ae5e14b9dbf4ed15de08ef136c73e517c36a28ff34f6b5e3a4c940e6f5c07990eaab578b23c8faf347eb4acc01177534c20596a8792fa5661ee71b96d0dc71419a2fa94b71f0641058859fc6273452ecaaae827f53be886484806f7d5764fe0c38ced1bec1763a8c6390b2563ab10bd05a245b66c9af386e6ca65d23ca45d8f8ace2fd12423e62e9152fee9079d7cae11ee0c46404c63f16ba36d3269c5da10f215e23e5cc3bb1bc26bedc6c97e77903caa6f4933c07629f00943aa6f11a79c443bef83a0bb521de7439a2e061cc09ba5d8739a15a5196e7d58c9a45f178c59dd9162efa08e0837dd0d3ffdb3f8dc0755158a8ebd9e7d482e1221b461966a1536855eb9333e1abc4a5ad08e5771fbab8389c10e5d13fe08f5502abc93735d579031df138cfd4655067855640cd072c7ac4b62673cfed9288feaa01a539c6e1c2d0783946eae08666b6efcf5ec235a83213855303ca62777f8a70dbd9588bd7b2c55f4702e113a1442f600ebf58410a41a685c4d8a99dcf81693aeb1d7fe9647aac1cc74fcd4f9d3a40047c4d99f562a720041283d6325943605fd7c171ddfa2bc8c82cb737beeb172c02b4ceb2bc618e63a86bd1c3d95cfc93ace95110ba10286d1830410fd85efc91f18a9cad9363b419e3a28f62fbedd09c648f5bd30095a7ac99ec7fe4e9ff83502a40a6581eedcf45a2d591bb0bfdba27f6b2f27486ce5a095102841bca9e1c09043f23b71d2aaec20dff05c63c222536acb6efa65c672062b23fb3f3f334108f6d36e2ec5fe0df601ebc87ec3a22a4944b6e0f34256bd081cb00673e0c6fbb9f47ef25965bb915629560cad0a42028f607b5905aff98c05a7e2ae8f57249a5040da96205f343ce035a89809c780b81e47aa17243d11083460aef2f99e399fca13aca616b53b2f895e37aa65efbf75a30277b8834fc5e873149fd7c666d2a6fa281806736265093ef5ee44c3ac18a198bd0e7b582d253388ec7a630ec1ee924b60721f0b48eec1851c2826900b68815eda050274b4f6dcc7c6dfd4f1e0cea735a12bddbab9a9b3d977907889782200a117f75b1b8778b816075e543571dbe5c96d11384bce3f971772bab81c616dbee9f29a78acfa3c5848b5837bad7bf192660a403dc88ac997c4e941c812dd4889402a349e02ee3f56ad1108e8c824c58f2b8ec01582ec8239e720f0ad16f10b5e14249364631e181e626ab5b04dfba6caec86a3f05f5027171c62acf2e1c2246e4487d39655f218faf1519a4b6aac9eeb5a2b1de13c2a8591c234a89fe2e04891ede138eb07296704451920370205497dab2db1055167210c6345eee3aef8045d2997921ef2a240d9fa8540b8c183c1ca36f44d5e8dee48a79a20a5a314609e767159808b47a4c2e2c0389ac983be28ada68a5be3db009d2e233058a0e9eb887203061f5b0b1a567ae91bebb30cd7a3dcc9b86782b838fc2509ad9ad6cec539bacb0970f19ee0d66d95ff0a3e7de0ac74037b8f9e73046e59f95bdb146499a176687bbc6f582dcfa49013d47a66a0a1a393c10cc2efe68854a1e66d3a25c4cf8854409dac16c0d82a44de006faf8133b9c1bf2ac77aacc6809707416b037a94ace98895a81e7f3b815a2d03bf08f6be3cb2a5799fe1d46fea7c61dbf9f74fd86549e24c686199fef9275c49ecae94726cc59238b2ada8beca99b882ed9c6b0b6ae9829ff8401b8d28edc4d3996bb17f209fb07f446e0821b00f1dd3b00c78c214c09d2aa3d769ee8539a846b1dce63d83e93ff6ef37b4e932b9fbdf5c5c807d02bb9f9e26ce61c44a3184f2754d61a5e791cf609813e68d498541ccac3e5a4fdc134e8fd5062fc075cecfead1b846be30f65e15a95619fdd85a11fff33eb5866150176209bb004aa0070190cb867409e6b01e969569b10aa9d9846f32209423de08368ec038fdd46d29217c11b408c08b003499c526c21eb776ae72370830e2c7ca05178141f819de12234413218bdf0fb2ede2e903ee0610af440143f41b30411f18e7609abf9dcdbec32dfaeed8cced654efe54bb2e828a2330709f3d3816703eab66bd880b27ac724df5108de342f9d13936c40a84de311a120854373bc648049c15579f3dbaf3e13ebcd62e703e6de78f8816e64f1a9712e2fd08ca699f1a6a17899f9a438b78ef5b01c1672e762ef253aa0e43f7332c07ade707610e2808fd8b66c29c115f81fa6a47418e0effaef627bf0e43fc33b5250594d6bb759fdde53eab960702882158e43f747456e07faedc73417faeedeadde2fcc039822196112f840888310501c1a7b97370d11fc372d02e458c7c2ca89bdd92d667b0bd25e8020d2ef19e789ff5ad0f4231021f041b44244255841e842322c5113f0df3cf9a2d0dcad266854014e4f35e0e63f629ddce20d4053a8ebb6875e9afbafbb2959bb2deb13039ee79d52811bb11e088c0207c76e05820f8d49aa54400fd7f5cdb2e9e3e076b2c849fa4db59c43bc4388269884d107f10e940203e0283fdd96c592128a09a7411a6407022d409c102e1134327b4f8437351237e1055bb5e7e6a49ebd6880b7d29979b870bdf02cbe7c78d22744238431c8b3081d08cf823d485c00f016c0486c8cf789d15621f89a344ac4e88a0cf4f7b4b4704a04f3e436f17a84f96ab4680475c422884f808210e61265c248dcfbf8b17741c250cc048264bd21dc6c2874edbf6574b3446a74892fd915f8731fa99de9e0262d16d5c68ffb88f352df89f8a70319da245d6c7f706a31118bacf263a16909f55e383501881f808b598fd17ec2673f70e2de957be63c06e932b281f8c5383c010e88a37ed6c8422e21191e35f3721fce4c2816a7fbeb462207420441719e14054a1502c84b70d32a2c5c347e39e42d4e9074dc999136707f904ba154658f14aff68b140cbb5ef2bfcd06e2915d1e2ff09b6abe2f919b7092116205e208e20cc204c1b01d4f7c96afb84a0c2f4415a3739ea936d6d1174b1baabd20bfbc7eb680c4a1f49bb5b5fe573afc98b70401446e023b622a0405040ec8350cf8816a34fcc5608840294d4900db0df68a55fbafc8c65cc02f5e43cc54d5b118213f14e0446d18706ce0a854fad43477c10aa362268fe73e0e221c48df093f823b841019416a6b9e1c4533e99561501200816970f953a6a9d3e15d92e923f2bd70da13804e0d715c924b9f94598223623a6b7be0844f976408d98a1dd828db8618c9cdfd743e1db1d73004ead119cc5fad16eac880ac4dd0807083128be19027a4b71258e1ff68759f0d66c994b3d18a323dcd18cd3fd406a67b04d11f9a6ba33f81fe1004676014597d65c88155df8aa582d9ccbe104f904bbc208e5106e448a44b460fad41c6a08f17db5444ceec813217e562e078218818f48d60f8a7db20ea351f273e5ba1157fc73551fef001839445f18f8bcd0e4a3d14d5431848ef013f80fd7883081ce1ad144b06810c67adc093bca4985829345bda9710f90e7d9e0b721cb61c9668aeb3366c6c2656071dfc0de396942d496aa8534524d91816a37785ea7b69e1632d42c2a8082f6c12f6023922e74ba70508c6c3d8dad4b0feabbd3855e720de3e7c033df67e219269e088187828f76292525dba9f2f02273c4fa3e72acaeb1f17d5d06ac51f942519e752883cc8c104a31ca6dbfb0d0ad27056cce2c74281dbabf04b164849eea78bb0d563a40e03af63efddf22790ec5ae19baeae5f51c9ac1cae8a9668937d4fa622593724a7cb20ba44965d7a2e73f0a75174dc61806c13c60756e02f90537bc085b4b5bc2f02329b9850037f6e4f22f9af210dde652fa91af1d5f35a972d2c2f29b3ff152ca6208cd670a662f7f9ce18c40877aab9f5a23f04a4b4e3013263b42d0be41490b6735c105bb62f59e221a3f7835e5a12cf6781d742643e8c94c4581d6ed1df6022d46aa8a570c44372f61d8473c759e464480cca582c34cab1a7341215aa45f418e9bd52486a3e347a6ead63944e7dac11010cc17783a52b2d843d0c56cc17d75cbf045e3773eb550c54a4d7b3ce7ca5f0c3b308e821abed32e312b104f1977cb2ae372e25ac8bb2bab65c1bfb128b14497321398e3de11c120044641a31b42fef43dff86cfe76fd9cebd7f39cb4d455496019d4b289f5da96e04d061397a11243a1cef3080f5e1a9c1e15da744691101c4795341f017cbe057837d3978085c2387a53d0c06528895e1e428fbea0f59518a7c0d26fb2674c41453445fe7e7beff06ea43a92e791cf61584c5adecaae6922ff22125a0eefe3fd6b102809473f59ee10b63178a7b177b358d86db064f65b867ca6e8bb5002a921841ead9742607aa4d03f7a8aa58b66c18066cb0e22572294f6ee02d45289e277b0ec81e36d3d36863c9566473e18689a202f15a576003f8ac00f240d1b0fdb6bcd0857a6e7b86eaa8d277b99e50c9399fd48a1cdaa10b63c57506a039eef84e4e922c267376159c66abaaffdbb186b6d4f691e88e01096f081af7add35a6ab5d5bd259549e9672d48f7b1c8be26f6de0cd6fd3eba1220dac1b416752d3a4b46ac7713fa55b3ee3f300c2df0f08eb5992ed682098e77128e86de69978032b80a0f26b909b04c3b546eef6e727836a12daea981ff85d0f6d3e385c7668be1d2e422a859ec0e921e7dd6bccf144ec4fa805fdd037905708732b7f5560810661d6678496bbdc706201ecd62c2b1a02302605dad60517727a20679aadc708d1023db52dac037851174654d5aee99c8c1c633e150c39a0cf06aa4dc5e2cb630f4d492616b288f3ba90cb38dbae6ccbdf9e038dee09d196ee63df81b309f644277cac67154cf54da4eb71fcd3c1f5789e73a8f9eb08d579e2b5bef842f0330ccaf29662ffa74787ce4fd8f1e29dc46133088960ec5cc62528f4dd0109f5720d5fb88d13a3415c1be9241085cc1bbb6c5e7e13cbcc1d5e340e91037b99f62001dc4288ca577e6586e5fc4861e3290fbc9baf51d78ef7f46720e16bd840c451e99ddcf172f27a7b35c6fef2e3c82535c9aa6f9d92384ecd130a49f6454c16060525529f68ee21c439ea9b1193f8a5cf7af1d0a09f4516a905b138283c05ec1c03aa4ed05d274155bbf5d5b7fad5b1ad1218788d6646543b7cf5d2b85cd366c53ce0e4fd7287047c7b2bf1d2a79e956f0af1d99ae73c92dbdee061f71e4f661646b1c8003c4cb356b5f25524ea1fe5ea07196b40c2221dd2abc4158059b9122be16b618c64d05a763106bc07882ddd768ce7bc0650ae0baacdb227a7514bffb8336b7783c048603927abc8201cc87214e24a7b0cffba678726b8d4dbbd590124811b1427c05fc205d37730a9914140ddf0cbf8573b05753da8b48dff27b6f7c7dd5679db2f1dddae9c7af267c218c62fb9a7729c846e2cf29a0f11140ecd658b5ac6e36b8ae8490ddb84a07214e22824bc1da031cb9fe4549ea348434b81c43c153a70ce1cbd08a8bab1c8cfe4b0c052d17ea21f209e1118525c287ae01a8dda41e658d16e8f4c015ba3fe94002a376311e901a18d15a199ab6e16c874089284775ce7594970a56836ca23ce68963c9fec58e96590a81b41b37f17486065e0e3f472549d33683d2ed59d6f968e08e311ed075b19590760400b20c23aca3d19ce1aeb9e844a68602b4515855e5f1b24ecb1c2d9aba5dae071fe50b4863e3e9723be9fcdcb60da082c68f3d7758b48333eff20fa89bc0aa46db3fe58df6a19f7d1d46ed781522c7cc0abfeed35736572dbb640fdb980e604b4ae5c6aedd02051adae4d77c9e3ee6985cd7542c50bed2aa89658e9f3522d7f47baa55e9f13ef23cd98b79447f27f1192ef038aa2bd2cbb70ff4c05e27dd8c645dea92bd070675cda7d7ad8bc0c2e3ce6193428815ebd698c6700de565f4ce8adb9812373582755924d124f5a8dcb9d81b2f44eb2acbb6d73c2b272bf310bb9e67acbdc84f8a6c260a85344ae80e3850c9a0cd28d2225f0bee6bb3023adf19fe1c224c16d3ad0c238b5472fe0cd50963c0140e592e9a25ae7489ac89c109492c885595f80b538264b2b04b96e74b57b9fade342c1c9b6b18c9149665edd7698c8e446493459060e618d80a9b8d6619a0b3c8b2d621f75c598de46004895960b53f09fa9d8cfc9d3d110f0deb8ec5521d51953ef6f5be2b1a2dcda9a5c4cd3452bf3f13190916eb4a5e1d104f1506bdc8e8cf770ae7a2bc2d6ac5b79eacbf4c6c05c45bae4f447058d4e1fc6e79769f0624ce03b8d267841ac2d2fa3bc7c7c62e1a634660ca15eacf306932c5462a6005e08aaacdb4fa24818b911629ce0294f3d5026c1f53a640ce2ecf177011235d0b119c3f957e07f1b41189a265c89d11c904ea69bf9c3ca62ad86a17d9ca1adac34d2da70756712e90dad7a4a66fd6bebd694088b53e77b6ac51a9396af2356a77c5e67a6c53abec0a6f8a0526332dd61942a4cad5bf7a9a8ab88aa5e5fdd9bec59f9a216d90162e1d64b5742ecff9ec71695a1ce4067978eecdfbe9e02a47137370bf21b931963b21002dcd74eb6d227419154b8ef69a70eaf013eeda25eae5e2137cb7e56337b32615bea5c5745d20da9013f264ee084af59f841b34cd65228fd7226611f2827be14ed1b0f5c84c56f3af448be1e6facb0a9dbfe1dd1c8160d56824dc12f5177861c7496cf06868e4106d7e14eedad125f216b6712818fe4ce48606fcb79d6f31a56606384d57d5429394dcde3da5c62259d35262b5c5e6f89c7694e03dff1adbd75687d829a46809679488135536786406d6dc269d4c0734f04f1478fbb1cf39facdc42bf87cb10450acd1c9fed1f5a10e56be65eeb4ccb19f4036de83023047dcc2de521a38ab690c6499c113c0751a8b09c73539c16030e9689d52bdbd0cd8c4e96cef17b8b7fbfed1f6bcbf61f9384aa415394febcc05b1522051710e4647fc027e8be625a2133c691e48a309e6f03fd81af657d13a0b243f5a37715b31d9af8d0e45d98122c0d1cc3f5371bcf25ab655a3ba0aafe770f0ea8d463f18220a522b0827f52685695ffb9d470335e896d8501313ed174b78bf98b3ca6bf0a0f1bd34a814c4153ecbc4db6f4835aa1302b2e41f15cf1d5604b730cc687f502f73dd15a84d490b298c8e9d77cf0d3e78199f63084760959e1ec7fe0158ce978e22e99714840f1f425ca2e3fadcd58b268eba294b89f5a6e799b71dc4a42b47376527678ec25558a98ce88fa1d0db7341bfcfcbb94e1c520e5c608e6417a4ac1dd03d6c6143097460de87e9c5a3d880b770a294140ccd9b4fd4ab73b3b4b31833a4350974b438378614420676ed08f09d0db01b8360f6d51a721ceb74d91bbadccd14c122612c3388942f7272515262179a08aa4d9ce0353c46ea7aa09c4609b7d4704106941a5687148bba795e1ffb2cf3e922ac1f3fcc448131cf3f9cb21b157d88fd6bdb633b8e216e4b3f3e6680d689f11124a8fdf78506f78682978c367354e234dc8dba6ac475e7ee6fb3c9878e62f9bf09bed28b7899423c99758fa49ef322b0851fbe24ebfd2314095c9ef755895b25439a5f7db90a99521d1e7947db30efe84c51b5983329e62f99dfac60327fea0790031d69e1f3fcbbd2b0598b9c6f2d318f26476e15627e26b0d6b27ad027a50a832a892f1abb7cf21d4bf9a6fcfa05a62fd4da6aad5ded61ddddf405196a55fc552a782d2ed840a065d0a925a1b626cc83f3d737e9d09f6af0f678609f301efd750755af7efdf383003f0d10df0322547aaa1cd2c0c19598951da7d35d1abeb3ad4b720f1dac250075b6fa5010573fb8efd79ce826e9c97cd73d78f088f4a13efca13751095d35d816235ac5ec0a324277032bc9034422e354cfb62c12218546c9896316b456f2473f0647aeb29aed0463389d1d98c92518d3081c49116005ed6d9011d45049c448fd8bcb6fdcdf94545df8683984a5c762654b391d629b68ab236b62d1c3a00e42eb673a2ffb48b0b36bba70dd2b1789431130b0bf3837e302d1dcc45c5bab0aac1204fa193ba45410380b4d3a958292b819245d14f8bac8c1917fc8f55059c341d6c367a511eee873a983b4bf2a3ed17923ad32d6439de64465637772e31287f89281863798f56d40659be0800f7dd3d79b10b9e5de726f296592329909670ac40937dba261d3d9a871dbdaf463fa7ed51fb5404a80e39c9a0a95e63eca79fa33cb856439389ee6e070a19c108643c7d400c7c775e792b0bf5973a1d152ed32d7856e48ef175e172d154887a8a492baaaeb615a6e1ced3beb51c93796f6c1b723576553ae0acd48f92dc65866abef77a16743997db9c71fe21be771f4bcd13734a8c72633aeca0bfff74fcb3876b1ab5cf66ef7d5a6a676f797d3b2ee3babf1d55ed85d3b2ae1b2749c032fb0fcec72bdcc433c39dd75e5b58069f4fa4e00ef9c57ca4efeb679dfcdb0e3244fd7fd94fa765dd8fda5434a1d97e4f518d49cbe2e7aafa79267be9cdfcddf5b379299aba352959f8bdecbdc79b7bbf7c7bb3fdfb230b54a2ec27200e923c92453503b842d6b59d66cec1fb54ab6b72114fb5b28af8b339425a994f2503a36896dfaf82505cc7621ce7b99658a6b997d0eb69549d9f7bd135bd68e58b3b3d0b6fc62cb9a14135b695f7de9f75866297dc251dc7648f7f73f5d44bfb189b8dddd9dda9724fa729571cfbd7beeee491c4f8b85116be6951bf1d453a5d0b55472e4fae34de2deea3185238a084ae26e085a0d8b02fd79eccfc3f982d18e76958523a02240ae6ee0b6dbc6e3658c87de997d12e028ad8aa82b1c7fb6cb8ff8228791fc9c1cdf2d6d8cf3321fc14ec04fea66521f078efbdee3f81aeaf891d2211e5248cf04627300ed6b0f6bdf56ac4039394d71266772da9a356ace9c3143864cd69831565bb64c59b102e5e43465324da64953523ac104139628519204638c43115ca445d2470810fc187e8b35d00fe06b6323aecd0487a00892c867cf2417381bdfb81096443e42a08b509268680ab94c336b9a914478d31d379bfe5ce342f8a9cfa6ef4c2e347bfa3e85be4349229c4d71a8f3de4b99d6f94ee31d7aa6af8b5d8ed7d1b2c739f04bb13e0f7d25cf9440ead7d7d1b3e994da5f28a54ff534ce773ae7b117a4c726df0f0e7e9806f1fbe3e8cf458cb5f7327bb77ab5de2d7313d7b6619023c0515a1d7121efe90dcceb91eb73817af4a94dffa547579edea6672e6e3a08c8082af777e40757bc53eb48c2c65ff147edc45f7bb0be17e4a005506e22225025bb3e09bb86586afcd3d34d7ef6fd9824badbb669201dc0ad7abf69ece9b1674cb26baddb05e201dc9eabffd551c9c63e5b126ddb5699cf86c02f7fc7f8af27a1c0b93d97f52bcd37942ee2f00ea15dbcafe0ed019c7b0e000fe0bb726f38d2edddafc3b3da1b5ec18fc318e5a143d208080bb83dbd1fb5c2dddb755dd775f75eaeebbadbddaeab33ee76dde5e4b66db7ebae54aab5c9acca29a59cdf757a84edae0b9dd039b76ddb6ed7dd6dab72e3b83be6a36e0451f472c582e50ea516fb47abb848ab1938366a6b9b61cbbbc3964584d9f793b90817e2efb3fab571feac9e3a838da9576aeb66b9ed726fa7784526c6e9c938c40fe7f85c39477ef0f1ec9bde6f3bdfd41fd6f9808800a5e8e6429ede42a4ba9dcc36738a0daff4f164432892f77263f19b1a96419e6fead92b16f3f14dbdf33c3f32d2f7d5c551a9aed9536fb0373dd6bdbd72527e309481cfc4beeb651bf77c5617b1a16ce328f97472d1a56fe4a31c7a6175d1f33104785dfcf14d1d04fbc13ff473f2910d83f4641b4e282b59407f11007065cb9c645db4e19c62c322cffbedc73905cc36248239f8a65602802418c8373509f9c88623d44c70912e01ba027a930c3030b5d28e137000bea9a1b8487f837c64c314c40db0074c216d0a7df4779aae80738f730aeef931978e8436f87c88b988ef219eef878f259f7ca423c88faf271ff5841ce8f80048073f40be00007d2b74908bf806e1e7f3f2277dbcc701f8bc2ccb49de6fa1ccfb9c2d807ce4e120200fbe39c585f2910df1feac96b522cad838d90bab6be3a16f4e11ca453ca33cc4f7379fe81be5232f9c4f2ed6a2a6eca9736c1ce483b2c7a27c64c3f9f461cff3ba7cefbd2e6eb337ea0d0e85e1f01c311d3ab2f9c18ed9ec0339a55c5b28a54f372a39256d3f43d9f6397be72967cb8ca4fbcfc52bb95bef379d7400e586dd0db65724833d36996d5b6d682483edf5f3e873ba0bc79fb16773494625db86b231ec579bc1a65af6499ffab216b5c496fbb5a996b5a82eb675b18636c97e8eac1151266733813fafdbbfbafe74004309e0323b8ab69d8816ec9752ddf5939c86b2ed9fb3e9d109e1092ed207c12631919ef084e65f7e1550ca70e3a8d4512ff67ece106807d0e5d2b15d86e30cd39ce459eff364cedbdfb8017e4cfadc07f5cbf5f77efaf3eccbbc05491f294baf69d57cdf7d1bbfc077bf7428632a298fddb8db79f8cbae1778e30607862327474c878e6cb6a3c7eb10003b1f978106df75218efbc73df9e8761f11b9bbf0473632dbb46953e41e4fdd7803f1e3348f8f1fdfa6710f8fb8810619ec0020d4dfd3c36d3db6d29e1e9fb2a7a703977db9c61e93a4fc15e692e75d15419c01222a0832fb67cb5a10426c22b0f68f2d6b4358ed4aa368a896a5965a6aa9a569aca5340dd572217a75110896ba58b508404080a3acb9bb13b9aa56abeac90ad3f660cb9a1058423c6d71cb5a106bb610521bef4f6be317de91b01b2fbfc78774bc0b71372fed4bbb727264fa755dd7510976ddf7e1f8d98121930fa46946f052ad3ddf8ef2ea7b6b434b6d38564aada59b7dca86e65f615b6ae948d5d8d1777e3a522dcefbd1c30f36a433431a8e124be7836c33e7b7e1927b414bd350ab471c618e5c84bea568a6106badd61e73502dfb99fee4be28165a5d2b1ca19ddde7e40871507a63c9a537cc09c710c78d90a6a94fd65a6badb539a4692690ede96fda7e1185e91b389a7bfbb582e04534cd8759a25813699a2c5114459aa6880e2da13cf563348d28ce5c9caf43bff32c916662a2199a86a6a15a340d0ed7314505c22116fb99b9bb3b9d651ce642561508876a95ea17f5b19444cf66cf9768b6dcb20675b5e57355f6ac01d1b4e78fdcf7c409b767524e09640338fedeef42236c4774a17dbf3a827ae4be43c23df732042592a64a6f3b241989fc2d23a13fff0b6b0d61341fc90956fbd3e624fa3017a23f5f3cef3bcffb8e8aca0a4b92d9f275bacb5926dd7b45bad0b3dd7f437c6fdbb99fb9c8e52e0ef7b9396673dbe6c2a03520f76e2b13ee6f112ebca18ccb479c6f6ba3ecdf2a5137d0e770b8dadcdf1a7dfb03d5b6bfe16cddd6c1703a9c9b0a62b910dd32270f99569b0bc7efd6fb7e7383c97dfb37b2915ce4de2bb77411fbfef417dbf901818892254d52609af214e5bb3ece61f317f5753776df9fc97dceb7ff26960bd56c64d67ea8dd5ce4825f918d7a9d925ad7b47a5599f2016acb5a0f637aa8b2ab13285c9b366dd66c7f2272bb162ceb102c1dcdf61f97760f4ddbff89cd7623f2e73be1b6943e54c909b7bbcd3db513c9f61e72db943f7fc2c07bb276ae7cabba03399807529a10a6cdc659898d4327af36fbca073dded21ff57b68199e5f0ffddfa34708f5df8308fde043207abc0cc77ad41e3ab1f04b1554b024152ba2bcb2658a45318abdcc0890463a51ae0bb1904a4ec223c849d8564145159f638d2063abf3bb15d8aff81c8b4cc2ec672f33093b7e470826ff949c646dc8491667e160430d5938d54083163748f7e123d320a50454a4f80c4ea6ea471650ba0ffbf6addea26ac76730339a9492006168b31f4880b39f99843034991f10022d480d58440218275537f0f8d9f3d060709e879ee160d72f6daecd0eed248dc81dbfe3f10e4d250c4d4a0250e1f13ba8ecf8998f2410e677682a3c2210829492003cc21b763c952aa49404a062444a49801da14ccaec67dfc6c63cf4ec77e85908267361b513fb1d58da198cfd6a3f87b222b2cd76fd93d1dbf997b62b63133871bd077a6cfb733a11c196d7f0678c35dda2d1b0c676db77854fb0abc853a0d16834fb3a44dc477d223323b28d8d671a8cb5386cec0a9fe4d8f604d73de882a33c3e831732cc204399186488e18ba6189ac080a10986305e80e105332ebce082184c2e30e5246cf318519cc9a3d88c8216d044692127657c06c7340bd3d34c775dd179aceb8e6969a413429946ce42b664d0622f298fb3e0b49c9471194bb1d7797b060296684b46b12f721dac6b2ccc4ecbd8a66085366da05161b6c1861950d8d84a23823342a005822d47432a85ad355c05521f58430d5f81d4133562e06aa43c100336ce022925363068810b3048c3054c69bc604d9417acb1f90527a8b1066317e4a46c711aaecf2ecd819b972e6e4d778d73dfe04c1758db829c84b385c1065c9fed962bbc925b7057c06ca43490df6e99915258dad98575dd32e7f08aa43c210b7252b63929631b831524e5c9af66056aa8b00215ac01c31bbdf04650548086ddca001b18f0362e205d44c3db54000d2d9a05fe7b54e0c31ea1a43fb472923d232759cc0205ce48d3820969cc8852821968982620e98ffc92fe40930217249082325ef8644b76fcec6558864309ec0867a1741f2e970be1327292252327590c0304c838d314813328888104148c21c303a4fbc82fddc71862cce00031cc48698099306818210c306a6000185fd8b0802fca4c5140192f46a0c48b2ea824a08b13dc808013d49c0e20290fe5a99900872492f2982087241370a18301b8d8a20a922dc890e0089912ec60a4045af050002db2782a9245560f44b2b0f001098b2b7e18225d0cafb0c24261399a5600414410578488b212d3d583ec635ac410f6b1cb155abdb4b17f33898b5c4ee262953792b8583f3f969e8b888bf57318640338b3c84778661181e509b847daa6cdb67f84cc45f0cc9a581c1185c511565c215584155255606131a20a24b0b2646b8ff86a7051918f6eb25c4d8184540d381f7531b3f1e3e029e4141629a6a28022892c502431e6092590b84f28e18418a025c0515e0de990479ccc540d60ddae2b464b2e62df158eaeb7a1554eca3fdfa56b189cbc25090fc2e423bb05cc124a80c94776892f390967259af8c2449516aaaa26bce4249ca996e8c00b972e3929632e4cfc74e9c2252765cc0490172ef9e8a60b5513df9d01a832c02472640ae926101da101260d47c9c5ae9ffde64e2154f9e8c64b133909e72a2e1d34f185899c9431123924529efa92a80322457d44fad4072285a414698844f2d42e57fecc3dde2b8998c049782e919332ee126609305bbc7860b5258c962aca23e6d69f5aac94f8e2123de8eb111b1209a201ac5b9c4a88c945ece770cc8f13ce2472120693434cc37c3a74acc8330637ae7141b3658dcbcf96352e519b880bd95dff48123a54d5d068b42b46b54af2c831170b242379e4bec20bc923f7d863d39f4ae423bac19619ebf81cfa4a8c0b9badc196352a339b4b95edd4a963225ba2327d22d3c79aa34bf9a955c66fb5efa598c662635aca5e17f3c774900f4486985319091124f21056b224b1fc9d452227d9c7e1a8c2c63fb34c2c5336768242f1053d05fd008ee2ae37378f6f6ebec8a16c8c839e408bb5d537373fd68d83c3e69ddf7600a9ee1c7ed207f64875db10c7fe9c19c97503f637b42ce7717cce37a166ef6c596b628a7d5d283fd012201d123de7cfd13623c1be1f2fd6370bcee320995bae8b593e9f8b29d68735ed410178e3c3cdd7b7f928e79b89251f49e558943dc2da27827c005f145db48fc371ee6f1e9191e0178dc8491c11172a221fe530c4633eabed7e72f71756176995d207052570d3ef2410fad3888cc4ed22425991fcf4732829a51308293eab7d06f181fa4aec5fb1cf3199b18ee9ab6ca372127e1b32718d4bdb85e9148fafe424fc396492dffe242227616bb3ae547c56fb967428f6ddc7f2db70d6a8a030cdfab0e6f6cc45ece330874cb6d436912d59bbfe91fa236c41b3b7ffbe9f511909fd2f1c71759ac5949b9d572af519e552aa45946a7b39bd7d150a5581ae50976075ae20065886a1dab2f6456b6f59fb5266d620a0a67489d6aacaec9b2d6b5557bb56455535a5a5caf6a3a5cd05cbd98ec82389ec960db1db7fe3426b61dbfbab412fa007023501facf5bb70fc93c8c19e1b7fafb5c8cb9582b8db65ddf4ecd8b43eefbdd9eb761e15e8a73595db57b8abda7f4066dfaa6b0c7ed95e81eb9f7be53a2bbf33617c445a0312067eff6e4f442ee6efaeb026a27773f99edab9da4b0bde7f413babdedfd7571ebac68b4cde94ba3ed4ddffd4387ae91bd4c8e65e3fe93443226f37dcf876d39cebacd761b4b1fefaaae9bfede76a48f2d22bb33dc913e1ee4a27fa7f78f2b70bcdd7cfaf631ddec36b739e76c739e73dd7bd76dd37a0145b5767d92e1d844d4a25a55d48698aa597112291a9aa6a6a5a996c416d5a25a5ab82ca022c0ed81b4803a404180e38c7dcee7bc0e3438723cfdb94676adec1817ea1e470eec6b3ef26ecd431cf6f6efbdcf7d3afefe876327e771fc38db76ecd9361cbde7381d1d9d7abf3ed2fd1a5a3dd6d9cb8c64ff5bda9e92ef998ea635176948cbb8e8e1c08123680d98f3f5bb2e27279cdbd373e7a836775716def8aa618fb7afd356eb6c998ddc8761acc70aa4051c41a70ac79f8df3e07f2106bf778c3d1fe5d70b17d1ac713cd6399f8b1f0dc7d9867d125a5354ec211374100c5f5f445f300b1ba2f3301b8ebfeda8e4f53daf8eb36d4358ce17b98e7d986b79ff3dd6361f61dc853223dc778fc47df74bfb8af9f3b7bfaf7adcc11ac77ff5084966d55c04847deda7759ac0b685ed1b8e4db6cd099bc070be623ba630e2502a0e6c00c759b3db47abaaa8a4a4a29e9eaa5029540a6ddada62a3a585a64c991a16d6555515959454d4d3531597e252bc696b8b8d96169a32d686b34c6de642937b202be0c855e1aa38f7e442e0d3e7a05ce8f5f4392b2e14c549f9d08ea7cf6d71aeca85acb8312e247bfadc1587e5423a4fffdeb7d6eb3acf52ab54b74c532c2b058d8bb4aaa96bea194f5b9a65b2525ca48fa3ed14eba46d156d9fb485d2d68ab65156ca4e511e5ab35476ca46d9a91b3b65a5ac0e930b8df639269db1fb6dcb458ec907d07ef73a9e4917724cb4b9e51c937352c66c66e88666d35243e96f6c249113a5592e44b35cb45496ca5a55b9500efbf629968b54774fb35cc866bde895d534cb458a44b13ab9eda5575859b6b3d862706ab9d06d92443852aaf8539453f995a37136be459ba8942af48946512a498463775c0ca0ff5d402d0c3261a009238c23aa6a5848dd1a16524e566a5838cd1c2cb91ba08b332b5844050d415f5a3b6b5830edda021a3a0c7c7a16f5c349a3dffd5e6e8519acac8dadadf2256baed7ebf57aab9dd03b34b73b739ab5da61ae2d9c5b538d9a352019e7a91fc6983d4edafdda69b1c3a8daf527533e723dc2c0dd645ba7ae5f7fb5cb0b5fa112359cf6a68a4fd87604f3169e3102c7993545d6aeb0b287a851a5bb3e91aa242ed465b1eb2b39c1ae3fcd58b9c806f4e6a472201880f42f1d22522489fcc798f8b3a590696602a93f694276f8ba726d210ec71f3353881751858cb1ebbbf628e953a79a1f57388aff0a69369c520ebd201a45996d8cb070415580726fdc1a1c7e21d32b1c63e36fe12882e1f853db4cb5a16a63d5e6ca6ad74b27d977e9fb8552896e1cd2bba51ac923ad607369924736491ee9ffb968b9ac8dc071aa715aad6d31edfa738d0fb9118dc9df3fc7d992726a8f5bd6b0ac6c9d1080b286e5b41d8b861a16d38e6d55b165cbda14517b0cb2eb1455f608ee3973af428bc27adc6546eccfa5cf6b54646d599b226b0aaa8d5fdf77b511388a9bca5a154f43d4883e08b4d61a7e77cbedefb63d2ce643f7b77fdfd95617b9589fe621419840b9e70701c185ec66b939e75f0bfe136c848282762af5f7e2a12cc0192c1d6389a574f7395f4ae91ece2c5f414fe058eb9cd405c614b425352cab3b9d56bb71f7ebe494f73a4d9973765d54b54229a59e67a9acb516e3acefe3388efbbe8d8bfc755dd7e56ccbb83e8c3176b9ae18af2fe79c5fafda9519afd70b046b5756b5ab346ee7f2170bae685bd6a4b032b4652d0aad8d5ff2af5700ac4541668f5f83c114ef9cd86e345f7e10bb85a00dafd89f3a0853d31bd970c779fc03c179fc7d0c326100e957bda38348008e4182b87b6d02120314e6fbc25550068dac7966bbd33403f40538cea63d2ad15d5fbefb9979668c33f30c972a141403388a206c2db0cf19fe7d5bb775e307acd8b4eb2cedbe7694d6bdc56d928edaabc5dabc7da79bdea8fb4d2fe0d5c58a28cd493a7bb56cfa553bf1dd81a57da5690046f73b2da3f7a3bcda307a611add67ba51b8f04b9ba512b828befaf241d8cc797e5c4cb3ebff0405b9d2f446f7cafd2d518c19b3062881ac00679248a604bc4f7feefbfe600dc7d8f62dc4740efdfc70027c62b713dac6cc9e396c10e6b37eb1988d7d92886e0973ebb9c8cc61d7a7da89ef273c7607969ee4d8f49d706ddab4b195e6a68f42a561559b072cbdcc24cc9fef5b14dc753da514767fdbb6bad5eae0cc1d080b1cc59f2049c4fdac2ff6d46a7d73f73bf7fcd86ff6b9cce51acaea2f6da4397fec21449440e68f3baa3f28615b76bfbe33f1eeca9a5f5e6e47fa6c9bbd57ec09b29bb538a410bfe36b6ff7b7c7d4e3aaacbb6a99fdedeb6452dff7116cd372dbdfd76df58ef4d9dccbbc50d43d4175c666dfcf07619228ffec7e736baf75ab5d2e5babb4dea7e7acc6661e7e0745d49834dbfb3eff700204bd2f3ba0d2c097f9e8fa3bf7d51f77daead82ff2a3ee6dd697bb1bf7f6feacefdfe9edafcecfe9fbdee7eebdef5d7bf937ddbdebfa786edbf6485ce8bf415142ba9ff3ff1803e6f979168b6dddcfffe12eb75dfc713636abb7ded8ec9f009df4d8575e7fa5c91abdbee7c7a9f72f50cb94bcfe755f19ca12a3d7cf4c41ad02f85830205dcc21942546e0cfec7f5d1a757afcc2d07bcf3dbf9e87c1ba3b5d77d01aef7bbff7f3ffb6cafdccfe557a2d0a2b1bdcb20605d5c6fe79cc4519c39b8fdf96b1ed5560100b402547ba1eba9c471658ee602969bd2ed211047dfb21e667d69d0f7fceeb2e0491793fb7bd3f2ee49bf7d4eb3acfebbcce9b92a86e32fc7333b1ef9f93b9f187d508feedc96b7f8939d7f7957c63efbbcf7fe622fe4b7b7ad37f8c01f1df4fd7a357de5e7e9288e32a955523db738fb47d0d47285fb5b908c65daef5b1add4529713baeb7363de4e5d36fca4cffc4ffa383ed38d9956b3d2799f60da9452f167df1e637b661b561ab0dca9d1f98db5c89da87242ca2e722149eba54377da5cebf4af19c9d29ebae62217fdc56c51316b36a55fca88d932375be9f41eae710321dd02cb2ac64a90f9b9e3ce29a55dd7751ded3a988b414f200a75dbcf5ad84be8c7c5faf25f624cccd39cbbfecc56ead405ba58ab0c226b566a86dca8fe111772d0b6b1c3ecf1ab5f3f4912dce5234abd7c4429ce479466bc6d5c7e24b97328733d931cc402902eed51696357e7d1a58d75936f7be11c832949fd0ffb7da2b6bdd6c07cb1a75fdac5bb74a1944efaa4c7eec0d2ddf32f165de817b098569a26e8f2055017d8bc617bfa056bd33bdee77ebc746f5eaf745456570da7d432f9db1f3901de97db6545c227a3127d3752e48677055fdadcc9c0f8e5e3a01ec0b1eeca84993d6bd8b2b685cdde9ed2bff47195d6c68fe3ea9edea7f46fa6d8d3f9257e9c70ecc01275590abed2ddafc79c4fc9ad808293d9667faf74f78dc7292022bd2ac80c084686f3f6f38391e184b58c04c80d7f0952011846963ff63a1f46e7eb62ffc2b139e76c6dce16678cb1cd365b6bede36cbd4c11e369cb9a99293355b6179a1a8b93858333b6cab8cbd4d660cb5a97a68d7f83dd54fb22b5ede32f4fdb7e96b2edbbd850d176065bd69ab0b263574e4ca8d9221a34b52f5b1bcb28282d5adbd2aaad9da9b2367efba5ca6ae3cf531bbfc501bb954f63fc1e95876cfb3106f595181157a28a30c28b741f477491e222290f16aa2c4d4817916042d21f534b24b145521e25b4685142bac8c316aa2a2e5c7838420a4b961f9000337dca9503ebd20587892e436cce63ea60e4a4d585f3765b2d613739385ebcb876c8593e243e15745e1a61397d4ae743269da598c69ec467b502965cef3e6424dff9259e5f7e25745c3ada6aba16595db0776b5d39195655758343e501972e60c48409e3250c145658803dac26d0e36f70aa5cd92a1f59d88d0d9580b09d93f3312ddd0358cc9f90d3ab0be775b434b25ac26e7270c488717db9e9dec5e423d71739d6d13257a8048412d32ac87eba4c014b46b247802c64922ded9856c092512cacee817d9a91dcf390b9f3c7ea7477e96c9996ee8195696984a54b31abac2ed74b23aced0e02421de18804172b4c1f49a295489ffa405bee85015d01ceb0deb6cc0f98dde0389820128459920990463a0a582241152e545c3eef522527611d7212b631adf3ee057bd5e75f72093dfeffc3303ab8870ee33ae4e0841039e0f0441038388d0142d21f3fb2d30d5040f90d4e258a0f7e4c8192fe90e2ff6325488944f645fe2309b0c7cf5c421835324f20043541628045b2843051be00a1b5d63d5ee6231d5991bf0e424a22f4837fa8306af43f54086a663eaa40987f0da5ff5f66134230a343203e94edd0e37b7c91b761a4a3230b7bfcebab305162efc29291ce13a11f40219d90244aec75429912ae8d91ec9ba064239d5f3292329d708afc61d404fe1e8e75bb7b38e7f436f0fc9f17631fbb41412e607777f79d9e0f8c92b57b827e071673ecee2478232c71f1e8494a915b6badb5d6a7136d322961c0c5265068d4cc336e45e4c80ee0085e38ceb6f759793e9a735a2f66f3519d765aaf42d1683423b46a5a66b4d00819414b8d04729565b1f5e1c393d9291380df0c7b5b5a4ea0d6534c8b494b4a9bfb094d2c52f4979edda6d068b422d068010d19d0a04234021a3b481fb94751ab055a6a481eb9399e3d33cff65c25a536d3b96d8865e7b6e196e88564382bcee30e05e55330169ee246bc9f4ebe23d2cf0a8fd70eb97ebc9e8fd9a69d52f9c80b4f00facc50f4846ba7f62b1fe3ad61e546bc87e2a27b3e6545a1fa6ccc7d77737ee5629a315b5e6d5933c3873464368f2d6b66d036fe3e97669a3fb5008d3389ed3fb148b712f233ac7462dc6fe68f227948e83fa19b89fd8c94df4ece1bbf90fb201d402617b0ff5bda198e998100fec044cff3685704841446d8534f2bd1ed791b80ed26b0ddbdd5f94bb3c6a6d9b26730d93362c860db4f73c6a6d1923cd2676357d46bcf252490d7e77aeb0a7d0ae509a758a1e16e755535c6cc1ebfed55533e45737733cdd2c52d33aa064a1771b76409a766842556b5ed242c51c3850e5506e8fdfc51a281ca5ce8563e46cb6ace3d4e2d2b9f34b5340a75e70f77958e4a3292b5f6b367ea0e2561560922c58726564f0f0dcdd0dc02bb7704c31915f533f18e985f31900235e5d12268115e28a5cfe7539268066d012671d15fa96a2ef4e69c33045d7a4a398ffb7bd46ef2cd4d697b3fe73767c6a15bb9e86fe4542e84b587dcc87dbb4f8d0ee5504d5c68eec7e1940b4df7749369bd30888b6eed2cd2b6ce992409c544927c01bd1fe5d591efb116c5fc9ee7fd8b5380dedf1dd145ff3078c10f9ccd84c6ebc16658a0f75d6ce66fa3820459017aef85452e42d9f6c799883dabe9ecf909fa71d1843ddf5a1be4a2f778fa0407aa021ce7cf2817921a251a6b59b027d6533799f9d4389c9eae7b84fdcf1e61890b49179241c41fe95947326c596accd4d04c810ad22148871a1a5a2d055653413904e11054058a4a5a535881f3524bc194329acaa8613f399dc97232d85032d46c4a51b0b5291952bbfed46345e228a594ba4615b6529d61a5563018e953ca29ba65ad0c2c9bb3e252ce329c8ef02d6b655839ad428e81e5639469e26063bad96f62ac2579e49a2bc616c814932279e4185434d8755a33341a2d8b917c9b8f26077bf470b4ef36dcdcbe2f06bccfc43ecd48740d9540a1fa371bf1df68341acde650060b4b8951b5b777a92d6b669a6c186cb4dca37fe6be0ea003c1796c102d37b2db7eec8d4017b228a8b2ed1ff1a16a44b7fd98b51f34b3f63d23b9e1f6b022efffb9906ff14f6efb757ff5eb827800ef57ed142b5502c980f49164fd5bad24b25512552a89a84b22aff5c8927c77a79bc317c6188763936f672028c0b933d52f7757f8737bf5c35f6c02f1ffbeef8b4d21b319def63b0912e19a91e8c63fbb8ee7f7481f7fa035c0ed69917b7abc3edb9fd317e62edfb66cdba6e461918f1ede6aa5a5096c4d1318f6a7be54270a58eecc2fe809b41873e198c2fe0b8e31eb2485cd8d2bece984dbdcb67163fd5a819e00e757f965297db52bce34f92e8dd66ddbb6edb73265f6b66dffdb6f1fb4d5f6c664fc1932b15f5fd8c9acf4058fbbde538ee3386e72f3bfc97d94523ddf6afad16f7ebb8eb0c96d8ee3b86ddb40342ca5da7e2b18d097f6f69b06b29a77537d7bc0f3fd3fd8fc7009969503e36ad39f4d341a7403385429f79de6ae7451d226b00f89d79cbeb052466b8b6d6cbfea4274e24e02d938fab8bae4b63d92dc8ad89f219322f3392ebc2bec51896e2e8d335bd6d638eded83b6aca531b5a50bc9dfe8f66c48916c3849369e646cab4d60347db1820d5650c8c64e2551ec2deea4101d1248fd106c01942e521ffa55fa50243982520a906e7a933e4b9b7e5b248fac926324962423cbc82fce482934c217670c7153341acd8b9114b265b6954a81c1a80206141851604c491ec964fecc74d2bf014ba01580b2e6c5d31ec52dfa9549840f41ad54216c101b101cd4fda1f3c1eb013f7d3ce41d5c2478550175b891c30d0e384eb01b7050c919418e29311b74d4a043834cca6c861d32f088a147d3c3a05f085d0000d34e940c5ad060b2b0c1a4896d78daf0c1c68fad9e357cd4e0200640d8fcc0a0833402f002a035412ef0a005422c18521364051fa880080d215a209c21803403302304344529d865189141803322a0e0688c2162209921124611300af085913247bc40d285014e90544b6282037081802d124046490914a0c502b26040d6085834e00a0758f1002c12aa80001511984202574ba49840142540418131263c5101272c802f6085811032308051004c4068224403441bf88003414e1872228482071d085202f240009e74f0819f14808080835d1f87c067d7c722e881f243051fbbfe0f5e816749dcb40d360b1ab49041941d2600b810bea061f8a61e31f09061c70c3329321a746ad061436c4a8e11e450c17103cc0907879b1c6ee800567991c06577701ebeb99f640fd9872f88cab77fc0501e107606918fb60f62012cb28209f105d1bedeb007a80d38deda15185bd6b8300387a53976fd118888ef471275df105d6c15c5ba58b3ebf704a92f42ad9dc069d75aaf50fbf381da502fa4587ae5036aa3678b3d3f364a04da026908c406387f02bd001cc51e203640a02d10280d50ea88202a178b67a9486c53d7fb6c46a2405be07c117ce886d579b65742895a6dcb176c59db62cdc69e91eaa661934fa422901ae0267d828c00fdcca7e59b5abebb059979b5658d8c947de9508fbbf291e8a2ddf26d81f948144ba02575d8b2a605995d14debac45767be5214a108680d90fb1da02cc051dc3bd37ead61b5e18e0b855a8cd9b2a6c5963db5d8b2966566772085dc90407a7e2491c51bef0f943e1f13f9888614480d900958133954312e3a5d66db66a9171e55559f8f6c28f6c400b4f38bf82504b353c36860258af1e144cf131c8cf9812200510449217415640a222a40a86200584556185d21021643b2886451002d8e94c00064926c8180cb8512132ca036c2091cd00509d38b08dc324bbe28010c13c2b080190c88318ed104051b387302192894a1948227685230230469a09cb182160d8d1654c0b48217d434b14086164871410d6ba6bc804a1a4e30c8814d9518eca0c6d31a3e6c41b111441b56661b2268512c18d18254942c4c532e28f1c216189868a28aa18b0c5533809162458313358cb1218a295723a0820ad60d573865e1a0450e6474e0a24a8d045dec508607309eccf430860f677e28030a0d106982d012420556d40cd10222d65c49238a4d116a18b175c46c438a86a5852c4c48bc30d594840c4a48d152c396294b5061c2a9891ca8aa70d9a1cb93171faaa0be0401c64a1822aca2c418e184d41359c64c41a144145ba460e28a6a8a2e5454550106cbca0a27ae1883451459575950a1055609ae2093b585165c90e9e1221fd1508c02e93bad76e36ee7e12fbb5ee08d1b1c188e9cd90e1e3d5e8700d8c940830d441e1f3f7a7c3800f2d3410080823c101a0af201911010043080108ab6110144381a8244a448018c1c416280a42407404002942860010c18a1010e78000910888004964ca0040a9850010b5c000319189934d1c00638708213143aa0e481271f480104211001141556589ab4c9c26c6146994cd385f9c2846136cd18a60c73862965d2306b9836cc29730493cabc613a4d1c660e538759659260ee3079984fb387e9c3fc61424d206610538869650e3189985766d42c621a21e71153cae5c40719fb0b03f2024a3046a9ad3e04969f9535b140b3e79c73ca39017caf5b05a4eca854ecd8e992562a9a110000001a5315000020140c088542a1509806622ee61e14800d86963e6644950844511aa3389261209a310600838c013023403052c200e2bc81b72899f9e7cd6fd94238a6202ef7316b79e56720c2df59f15d4193a3422d7f5c7fd6e72626066d5eae68c65d70846f165ad570db2644f984d2952ba1f4e0e586ca8c371cdb51c4f6f77d77b6616085a60f624cdc9e0dc6c06f929dc35e5b3213203a3748268a061ebb5924a00487d941f763060fc7d3ba613e0a555fbdfda1f2bd8633d15304cf0398122568d56bd3afce8293915f1dd891b9ec8eb639b13be4a9e945db66fa17a9b3bf4a9e6e04f2513a4d8b368716b6dc3fe600652f29387dbfab43bdd8c698d5a0cb29b303139af69d500d30ed69d5a0f3cc21a78306b43c8ee9eb42301d35d3f111b422b84340c03e52ce0800c03c5d1aadd1103ca840326ad89d14edae928aeddf06655fd8054580bf7fab038a354b85f296a9918481b5f28945d9dffa1c53f85bee953d5863a4601803ee49643661d45e041ff98531af7f5613b878f8d5d52e46a3e2865da20efa1102ca37fa4a4e02cec7d743f9475a8dcaf0e14e6fc3f4db09727d561b4b742c5a77bbacda1dc07866b5a3a32988de12b71c0b9b48dea7830b802e65f00dfc029ad1f82f5f7feda24371e01287d1db568c0255e39d00983baff1e7269ddd2618c5bb79c63a748679a82debd2c32c79b9ac3f2f755277b8fc2ef4a11311a5c8c0e2a0560a138217524d607c503ee1a4d9efd70ebc87c96655eb7040837e8ab04919e28a6c623b96b0b54313a53227d26357a8ceeaf5450a9699dc13a7d5bc691205c0716e5b6d42ba580d86ab6232670c5c8d1a06b48a0d346af5be24a4a5440b3e93278e1f1e152bdd4b198efd6f8cf45f53ad1aa69852b31c8d4881c38146c0b028b21603bf50a8f0cab564026c09f369ab3b91f7c962e517675f7c23f9f3c44b7c1574b2e6799a58d462330eab8c25dc34d6a9b2698575f9c379eccea95d9b3ee5c14cc0d3cdc078604a30c0aa075d0437c5c5d3c50504ef991ea190c5ee833435e538c176c606662cd193aacf527ee6cf4fe6a2852ff3d025d218a75801f149a5484cc8d703f25ccad9a19947fc4b56dc33cc3a60a2d88f42a0375cb49e7f4a18c5f6ddcde3c3b479fb9832bbde149554f6f0d7f1ebe1f3a32f3d722c90bfbfc9f25d95ee9fae61af2f68cf847731a078558e5f9858d84fc4628356dab389a8d38cb6d26c8fcf6311a43a8de227c46dba0d34b1daec67cb564618ecf124c93eff025b4955a2d3f738915c805796a65e3a6e0a7674ea6a89bcadd5a89b3be58fcd3d69de8f59370814fb7ea02cf7f1b00694e9b31fd00fa807b07d10fa4e9f0447df7e93033f2e0c3c36365993e1da49fba9173ab4eec947c54e6f0f2c184d855e9725ebf48be60afa19053011a43a0353fabd99c4b43676c5610a55ea1bfa35ba5325a750f315f2f13d06b113cc67a18a0d547a5e85b02a76b01b1da7c35eb0871af840d7b91f2c60b1ad80e5351a6a526f49115c3726f0ede861559fc900d65b5c675bd0e548220760d68d41e127c26a11e1aebe2c9628fb2735676dcd6e423d1303d46a2bcee761964ca712c3ef1b58f8b12b74fe0bbec74da5bfeef9416f90c34d028ddbef4c31a6a5a39e36fc311c9eebc68dc756398c1eac625070c1acfa8dfbd737ca4d600064b03ade029a51040f6d7efb1ad94241d662dca5776f80f9518c19b154c8b064b1b87fba8981f0bb3ba40fae8dd4c0c74c2c4c2baccd0d9c97446dc773b4d53cc9a60d72383a78acc78d4e598702bccc80dbe41e740e60ade3c209b57cfcee2a097d661a57f9788353118e2e6944f81a68a750c34635025b81047c3433d011b8ff9a7c262bc1f383761486ba3ad7cee4ffbac6ce04e405e454e9695045dcf28706c5fbfca4e6948cf41cb353b9d15b983130a1099f708e693f8e1add347df153023559984cee54ec537866262c8088731f39283370ef6c9cc245d2e4962e3f09646518c53bc3b61188f5c044e45e91260fcf9b7bcf6a06df0c35902601bbbcba0a0da24986afbd612de7f7720a8f1cd5145cc91358ddb0bef95df19f6dbeb02135836a1f405dcf40b85aa04e6ed39e907429dec5e1cdea3472e0b7ce4938b47012a8d0755857b8e80ad7632944e3f322ab2a7fb2d56160a9f3e1358f8584c399bdd8b103afc04ef958704f4eb73bc1ff53b89a2782dcf13efebe0ca17bf3957df2466148761880605472c82f24f3dc662575c9cd8dca3e65f68a713321d67177de77e55a965644712ee600d17a760e724c5da0da5d41a5a799449b9370c1281ff496e14dde1f5069be1799405be2554b72d4bbb836a9e5b06d31288b464ebc5a6c76569269ff06e52a409b6dca59a37fc7a102e8d9c359d447614a880409e8c5fbc5bc7c3c46536103e650ea0e0856a5aac4a5e1147c4fa46e9d7eec862e76ba00664cd79aa1944130162196065f914d019bcd1b55a00d5cc12efc0b9f1fbcbf48790ecd4c5ac4ebe89ad469c4bfa4479794b8114f1cd04db45ac61aece26bd43c51e1156b4c3c499faecec5349a97c9304edb9dfb44140dce5b07cbdfa8abe5fa7869ff93e38e09b24467a9970d43c77e62aa7d2020c6e613183d3ef7a630ef56446851267735e272af9fee95ec17c39b3e589b41ae20461847f342c8d22c4b3c28d6d1d723fc7d3c8d9ea04365266ca2f6dfaeeba9662e91c82d820bc157e222f70abe265dd3ffbb236990c8fe485e66860d81286a402ab310950e700f60b1f4ac262a068b292b3e3cd558bdf128a0643590b7aee983c538408edc7dccb1a8ca5791f9ba5212e63b6a3bf20e51151184497ada94a07f3c1c2b4d0aaa2422b4217cc9e1cf4eaa66a8bce14cd267bd6e60d13fc343f221852206855b9f71d7428936b37c0411d29eb12fe61da96cc93b5c4bfee701c875e6e79f4629f42ed817c38abfdeb87d6be6d82af3a342e3ed8b8b341776b23c5edc42fc1e9db4de12ce3d93c9159b9f6b6465e2de74a3d496662d0290d8d11efbc0a94a7da4b84d63838671389ae4aee356740782152d9565383ea3a22288649ef2b7045c9c5db760e1b05e9e112b6e4b50e0e9fdfa2cb9e79d7204a42778af7b0fbc061e16aa4ff9ec28dd39a248feb2d4dea6e84cb2b5c6d4ce19a453c1dc51d0f40c3065f7913f7323b0e79122243e8f6e481cc5058fbcaad7960870327cf722ff0947a260c8e5f71c7f72670f7883d64ec1a2fc45c88a2199f84e7c5f49be80d1c1392259b7580268f38fd5c41b06d0202454ba5e79d5f6a98bb412b6639ff57020da4b30d7a13a7b6d0d86685a55a629e10c940a8d2f58ba06403abafdb4e916c697dec40ad9b6c2c336a1676e88c0f00c65e445ba53614c3064658fe9c261781e36afccd7884808c97604bf4d485be8198d19e4ba3134092864bcaeb80f29cea2973c17e3d7873cdbfe54dd48ad7d311002e1c9365e0cd7bf4ed9d94620f6528c4c2cf3ffdc6dc82efc1a9a1cedcdfc230ca473f5fd7e83ff62834d36791115cba1e96a503af9d223eeca1c8ecc9f830348963098ab221fadf84c87c2a765a45570d4eb50d7f830a65ba0157e842a23a8f9abd0c9ff73348735d3ec253cac949a5eb40bb5ff23568191d0b6c02e2c8925eb976758de3e6fa4d73c2b409207bdcd096c1f76a6e06b30217eb22772b8ad39bcc819f97f91124240384ed84733141a4b54d5b96759bc4e90b3312c9b7771e8f535c8986d931a0a9b365b101920956af64c19f449ebcd678bcc7efc5c73a92197f5fa5629227d883c4dced4b2fbeb1ae49de71f6d6ff052c815d537f8b087b7c6b0cdd914b88cc104a10355ac69f383d3e3d0456c1cb22d3772a750b3c1626011eb3e36191baf8de2c459599cefecf5b8602917f15c8eb3596847b2f1f21b58b882995023a5e7cac2767dce1a8f9f16a5e8d95b8445b4e949ba84932f0b90cd15320fe3d237dfde415e6ab17d9f3a3afce9cca17b5ae3a2e706c0faecee3750f125cc104d5e95a16e6e481da1c7991cb9127801e43c3e0ee0280ed0e1f276d93da76783df2d360f54962d0ca421812e4269b2fe3b43f86debc6bbda8179326201011e62e6fc5fcf48ff268e83ec4cb3b1f44a6e0e4080bb7c3f1bea8720e7620f45f87cf35dd3e05e80f357f87f70db8b095b917b38df685a4bcf59a4686a3847828a571d019550116edcb2812f7e9a04f0d6267380542503804048a6ffd2b3b8f38c05db4ae9f462cc0da1a963ba847b0df8a0ec775f7817b3a7a24b86c7e57a0a4a10f19d9509415089557846623d1ddf938e1d72242743114aeb0e4c23afe0d7e56638747dea688a4431ae834284bda82f6cd161c620f6601ddff296d6c65c4a754e09f5ca02692d57705c944924b46aef351ee4bc2ca11bfae85e06c1dc4c59de534875e42a14c499a5a0a55f213adf2d4da62c1ecd55e0dafe9756133e86b3a038b7ecd0db0f32de7e3af94eeaa0d57653adf62e131b085c757585a7e0ba0be4a25a8a23df3de50d8dad786cef7142b2bdfb24d4b1fc205f8a450ed9e858d3f8240ae1972f3e906080f852a926bf25315031950d0f1f66720499f819ff31da02143f676a5318a04470038a9f3288bbadff3e00e028cbc9d1077b201bbe547be96ff810736205ce889171f2749ad182003d0ec8c8ee2a82b395a41b3e8c90b48a937605a0d90a3b8da2b575fc5496e2a24e04a4c2c8465d34c99ee11cd1c7d09b3b97dc65837547222c25eb5f8a9b87095da22870a2b1475c9306f7134a6a23e3893a42f69249cbdd3bbf97a0cd4bda7b64a8366971b6c215494d6fb841a4116a5b0f9c7c68cea28f1c973ff276566544fef557c389b13846d89d572094f8786e6d19858c4538697eed2dd0be18d2a14d581137ac04a21fef59a7697c6b37abdfd733a1c7f5c9aaa69d9e1e69b6b494ed95eb4f1a577683e94b9bb1631cb101284c2c4c9bc394824e1c3354a8215b9f512147e5bfdb71c723a7bdc60361c0aa41c676d00a2b7db66e93eaedc344839167dcbae76bb076d3d1beb383d8b5406233dcf0439af87f7e86bd73d42bd63bd86d47c2c4d8c7eb223f86c400b902ec0d55e3bb744eb2fbf8da782a49dced8137292f34623b034ed6c9da3588b1ec938cdd0b894407e1f811d5ad5d61b84ce5f9bdb8007cfb3520d857f9765f62d8ddda5f0973a9ac2cd0839190a434e5a62c7f67ac52560c47e2a2edbe56f6fa0660d8652691841966f69d88856ac048b93d1538e7ec7012eaf9d3af9cb716a1c13c9e20caf1c152ca5465a1be6df36b7b05d738c009f4dd60d720526d772375b058457cee3825413b021663aeb17fcc26b7759bd0f5e1f1022d7623bc47ef50c86ea07c5453cc44fb9452deb8c11ee8c535b52901513b031101c28efa7dd0fe62b3d53bb53f5a6a8a5ed680413c2e722bea9e935c6919fdbda6d5ed4bb8f9b891f8f045b60e77ad31dce4fd096011ec46a95f1ac1b7ffcf39184ddd4eb7bd82e49af45c054f568bc5f22626c512e397ddc93e023e7379d357ceb73a6447e5bea952f206553409643bc7bf357ff60860de76e6716306127e580df9e25ce2524115b0681bb4344bbeb76f49f7591f842b1ed698e26b480a78f6f0c5eee593ff2c5a8114018755abcfc5bbd4f11b3bbc5590882f8cb82c1e00f614db9e6b7773ffe1cb84d0141a6fcb85cd7101dddf7c211de38c05756ebd0b378884e28de1ee3101cf398010e5242a1f2d58fc81bdb937e76c28689e0c743ed976bf23de71ecdd6f501adf74ba9f0e4f00849b98371b3e330e49506bc13a37c5520a5bd2c3b78c3c9ff1ece4dbb7c87c99747627de3941dd0703a1c4c19c42503ecf6edabe189d8f2ba864fa9f052585fbd82fb9d863217421de006d2200b4377880232a199ba26e7c39627cb2fd2d1e16c81f96a5b044878a8319ec215b2182df011612e3bd1e3283997fd82725181bad0e48d7867d3ebf3312aaffc0fc9b8d48f61afbb590b197aec69df6c0968b90ccd11e45a560ec4aec522bd5440cd43d3542b37aac71db94355e8cea6583edeb465684b99178d30e2de6de19a45224584c49cd531e2d81d3bb95fa97569d2a56c39e38c9e89e46ce130e6de1867ffb2e5803f9e8805734a705a699666bcc0ade326b6236cbbb056289950494bdd34f0d2f6ec26f88ad67fcfe028954557a8a939c42484bfde452b644e63fd2dd404e6e172088810431525f89f7026e8f6bea92a27af34032955d78060083fd40e44bdd507c011c4e68eecf9a13ff40031b102d60a7abee8bba18a57076e3a3c9b070b03a6ca59684ef810ade6638bde1bb863bedc0a1da6a8278429f41e138a6766ae122f2ff014864d3d6ca0e17293d5baf400209a633227e9e824737576cace05089c6daba68a0600d23d4d72150bcedd66a158e2265a85445830b5532a67e9f000436edf6ec90a8d2a3554a1426c38ffc750418dcdcb5db40c1241bab2a1181c2b5cc243f4740e146aba55d3856f2a44a050928486596fa3f0a0ed9b058b242e1a54eab6b910102148cc87f67d0d0ed55ab050444d2bcae8e142a58c948f07100176f5bdb5a8522250e2aead060c1744689df83c0c0369b9d351c5ae2b0b212092344638cbedfe67840e0551151c5ee111b76faca9262327e697e398f59fe54fe1c3e196f39bf24df2cef2cff0c9f14bf9ca7bcf0c709e9d4a03d30f960487ac69389d2e20bb9cb21c9f288f2346fc273096c34f946438d861c0d3f183e26cc20b47168e390034347c38f84180a371c6e18e260f8d8f0815046a18d430d861c0d7f53031fbb670c01afa0760822d2aae28824b125904b23b04874faa18979ddf2aa5a31b7b392c7c9f1d406517e9ed0ca538ed43bd82b53a4e23010c6a8ed15ac7b5abdd874b0f7fa61cf9a1d267dc9025c633c5bc5855a93cb13c5bfbed84e9eb51c0ebb85fcb41ba980c40457629d764d09904b9800ddd7060ec6456c11384b3c06f4d4da0a22b942d551fabc8ebb6e6d0e7accd4168b6449114bfcab358eecdb0c0ab0a07af0e4c840a755152d8af1cc9fa9fafbe5040d191a1d04ee13664c132867aa8f079898dcfdc1db1e0f60d73aa542b75e860d72dc2df1020cd8652a6ec310cb6f143ee63b848df5ab40b254ffad4f3f2a33bfe7d88a3251630d93be51cb333c6ddf6edcc6a862c3e450da8ac972a306e23b74e8275117fad9d89b00420337c66ad01104f15bbb5824a4c4c608089730b4b0c9228075365139fcd0b9bedb38704fe1c7c28c4e80c7965d3751e6746038fc9409cbf32ee2f0d3fc911bc6da33ed04c7155800a800929c3763ea3f2deed7fc97fdd3f61686b14126a995f074949e622156fca4c88333ae414d1fc8e6b0ef9b1cafa978458d0174dadb79805743ad61ae0c068c5d1e7ed40f1767232ed7067f004ea14575b20ca0f04898a73b789e1301394b4b8b91989f38d36f6bf33725890bae0ee3994de5f87c60b6b68fc5df2999055468af7e00003c1a99682e2bf05b6ebb6815f67f27ad51976159dadeb8de690cf2635a9f8ea67d5ce848369a1941e00e2f815c8bc6199effc3c70b000b79917fb1a6107ee7e2489cf11d8446fa1ce223eb29698b484d47468e3f4a828ef49aa9277dbde84b6f0fe436f6d95bffaf40d592a58887b1c746a660df8a694d0ac050a9d01e1b38cc73e80b7ddf7aceac7c0139de9883ffbd9ed2ed57bcd4b91e6f24b0aaf15a6dc124b271a91371c862575ab3fe10f4b963211fbe877e7f6f09ee3d72fc000ee43370d138c5291ed3cbe4c73a4c3acb9c75145916cc3fa9ae775443c177584949c0c7940090525dda2343e937ddda34467563d703d0e30d8ee3a0b80e8af320380c80d360dc0dc671a0b8078a7b001c0cc06d70dc06e274509c07c539001c06e16e304e03e33a50dc03e2a807556c9ee940dead9fbb2b051206fc950220a85b2067c91b5b9d3e5fd100384de83a9aab7509608f2a5b54479e5d0aa28d47495720adc03482d00844151c5da0b402290aa6100c45306ac1a805a4149032055cf4c2921dab2f2af9fb202f833649ceaa9749ff7cc89351331927b5c5e4bf3df264a899d079cd12a97f8fb655fd42c9ff4ff9996849e4a8ba90f4e7b3fcac9a9338525924f9eb915f56ed449dab2c90fcf4c88b5d6b52c7b58b257e3ce0c5d42ed969d565a9bf0f7860684aeeacbea8ecef87bc0c342438575f26fdf7515e468d091cd42d93fff6cc2ba306d20a26e0a4b298fcb7679e0c35933aaf5920f5ef313fa686099deb2e4bfcf2c41b5b534287b5cb657f1fe1c3a42dd1a1ea52b9ff0f79b36892e4a87291fcdfa7bc4cb51371525948faef395f46cd491dd72c90f8f5cc1f5b63a2ce5597b5b487f05f3957a2e2bc3a19115fb4094434904e5513d1fcc07e9720f58bce8c56f56f9a127a3291a103a03fa19da6a481d1b667639227cb94274dcc3f9200ff85a5f316e5e2547fc8d7a281cadb2300401732b8b42a4f28d77d30731258b5b647e1639700835fd4683b59d99a50a28e5a8506e2133753073b8654689ed0dddd208f95f159f51caf8abda5cbad49180528bb7ff87bbe4df882a563ce084310b3b3e8b85d559ae817785064dfb9bee6ccc6f8b3965aac4f4fc5ffacc6b04bf82d5949d24ddc836a211d4a8bc5d6aefb50f9e3c058a910a429a5a5ebee014e60014fd62ca0e52b2657c051464d83270715eff06f62ed35be36f0d5b534eea3217368f4729b88ab505f70d821e26754b37f5e46241b30bceed67a401bacd48bbb2eab814d5601040e0123b3b23009e84f17a6931a59688cc6b20992d08210e88561646c34968f540c471894321444c60e53ff66f4caee184ed262684ae6ecb0bb45065b056c77c16eba925a13b11b582562521fbf94873d619eeab70531e24714acbe94356bb91915c0fac77c542a93b488724726e8d6fd9e1a49216a7631e54a89d4da83b200cc283bd4d5731180441606e3d7cc53ed285a6580eb22dc7c814bb801b0fd45c3a95f1d881aeb23c85cbb818bdc1267304b300fa1931a04c97265ced83100e11f14e58db4695f7c1c8f9154906181106d9835d501370c59e9948660ad847152050f176cf790761b770943a707586b658461134187b090bc5d141d0b490e01861f715c3c5723190abfe31685d8a2f60e098b82359419927ef08cfa9f1257c6a0c43e8a1e375b7a460c2084c5c8c69dc9315dc12a80a46e5eafe083b67a826015c0ad9d26a66fbdbc2035ae9cfb0c37387c1bf329c9827c7fe557029b6add91d76d70298e123ac84fcb22ea6ba6504c237bb872d875024238bcaffdc7da628e79d15d5b93620315093de0b9da45ab349c77125e0025d3e14192ffdddbd78c992ea16c449f177c70db36dc6ba90540e44ad7eaec08310b4eed30a3df91ac1d72625c5f80f1e1c68b700c63bc1472d7fac01e7b1e1e1d5cab15ea14c89bb6cd3f14a7e2074df41270dad480aecb3004e0041681fd598297d441085ee3104b634c22c2b123744afdcc0a9ad4e782f5e7edf042f138c6300dbcac674bcb1c1aea0445cdeaf7af129f5d9a11807c3999068be878336933957d889cd239c8a5d84869ac317676cb639f552d1ce6872a78a7c307e1282e4992e07d906961041e389fb11d767dc59235451f269a33781a175ca40d697112c4019f772636dbc157e396be82e5d36fd8ce34036fc3d0e34f1824c5206f6c0f7ad4623cff513d1ae8b997598678ee300ce48f30125de34e5ec7ffe71ad0a71b18c0b9a297fe0db5c3cd66c66b940823ca88e66194138a1c93d979f5c5497187c71a826d3789886a1e6723ba6f82a1c11cef5893ca3373868fe4625ca454c482d179f2d961b4724a0d372e84e8e47f24c2c08c32569dc1d69dc6e9f000d4939d93d25b814ed3b709af4f6e2132bbf7ee55157c27c9fe51f9bc8efea51a8bb93aec27ab903a9c277db20b8dde60a96d149e539fade01961f450c9521889251468649401d99e3538308dcd721a4092ff426d1dc4e52de7a05a902bb29c8e6cb4c6b400021a4be749c5117954894d4bc38d041c2e025eb89df769703c125d2fb449d3b9f825e20e0aa4cf309d77cbdef8d99d7d19fc8be3c44b942beab9e2dacc55fe5dcaa3cbe4402a6a29edeb54433a59c542172be559018c2b2cb972441f3078cf0f478c4b3ea98573cc54b9d39c7a69c7eb702ecd5ba52deaa59da39c4e6db914b92693c743facf9cab8481815aac13f7d9bd8cd655aaccf55654a1fa188a5167a1dd5c7da4214970dd09aeb67dbd7e6de7b9cc72a491c6d0e443f655c03fb3c9d27585162f326ca2bea75cba0676aaa1f7ec5661c3f898862cba4d0d6390992b98d475930ad4219128f516753fdec5e9f9a3261f88c3d61bf3ad11795fa5fd8d13bbed798f3ae5c2ab572aade07c861c7199fe5de3e246d6bcd7685c0c16cbee624bf8358efe934a0443d68be4c9be174e730b76c0261e92439a23dd8562f1e627c3a72067ace8fcc744fa54ffcf29a98ac765225a52e5c64f165bd3171e2256103ea07815e661cafc66621aafb037eb88be171d14db7b3fbf322f2ee8ccfc69e40cbb637fa6716fa5601922da82231017411fd955f291ff5b60f9e6aca056464fbc8ec546f582eca333af1de4f8be44004f5f49e37d8629824a304d5736822ee25d045c4a955c42cc154e267ae73830f73fb4400ca8662a96ccac90561a3651a6c19723c0b279ec9a6b10c600ffcf6f08802846d2358ec19624f369fe6c05a4f5c5fc70f1737911e444edfa7d1b5c79630f852ee8593381c1572ce2a01bfcca1b7d0d2760d39e25463f917a216217f95b7480f8c35d1ea78fcf2399c6e8cc74486bd29a4ec7aab838a5ddd2da8336f85dcdca54ef3e71ad737f8dfb02eb7cd92a0bd07e861bf766d8a1f898cfba50b5f9da3215224b78b2073b94e35e81557b6a420bec86ac754f18d25a279c6753a20e9cd8619cec2ed7c5e40f3fd0d91deb6d5b695c30839cef5afe5694ee893bd8c98ee16837e97ff8619d76678fae59038a343171f6e48881a14ded0777b8f31d467ddf88c7396e3c28b5a0c0b1130bdd357d4f57543cd76bce087367ddb90aac059bb9f7ad5b7b7864e05dcc0912e5e001fbb32cdae097e6f7dcb8f8ee8abc40d111d336e43d78600ceb1654c6ee7a2cf58a117111ee599ca301f8e51d390694c6852b1258436e3b04ae4dc61b19948414e7769919d74d76466c0c5f085272b4aa891b5615a2158fe04e2c0bcf9947c9d22d1e7c08a194ed6516285f5b22743f1b3219755b0ef53d2de56c62207b9865319c97aa71205eb1a538f1dcc31bf7d1acd549d4316199187d44f553d8f4ca4b7b37148ab57383e182e2fb1df4660fc5acf0218b81df436baee404be7a864e0456bec5e71e16de4a6da1e46a3db9692ae2cf9b3eef3be15c99c5d270273c2822b3fa32a769a55b1bcfe708df6e2bbf6b0da0711953c2b8f0c994d21a2b6a0141ecbdb3461eed3f8ec0d40fc4cd5f41728ed510676822062f80bd7b6b3303fc0b6abd4c540ebe99cbf3cae1c2406285d4d2d8e196fe5e32471e96ad92874b4617179ffb70175fc3faab89ba677b890e7b54eecd7b940de69829815257d0d18828705ecee8d1e1ada10e3c4ca96662d1987e879c69c5fa8ea3006da4a3acc9ad13b02cf6c9d79cb094ebcfd47826f4afcdbc443e6cba6e952acd52dcb85b5600fed6f06139ad32680b4552d272c4125d6f87e8d6a10aa2aeaaf64b83f21fbd4bf11b7135ae9e7160db71e7c092d171641ddd2210aeb44428167e1b1f474942481d646991391424788d606f8a12e0544bb11edf5e53413b556bda8acf173b43bf0a80d59a65678c5435a356746fe56990bdab94a57142e3d472623cfc1d71cbf21da931ac49dc89c53c667928155a945770d529bf1335a7869bc80588461ff00e7a4b7be008851b841f29c2050a0aed7bf5d9c8fafcc42baa72df290ad1460150a57c55699ea612977c7200c375657df1acdef3a79437858f541ac3d2dc8702ede5f19fab9913ab0983f77e0f4c5c0a7842fe316c6094f303cc84707f018ddb5fab080a201762fe80d824b7be5e314a8c0d071e20ea23f470162765fb29875637c24725d919eb3c9748025432e9d100f2ff89c44757c2511ec3fa40c4f2fd3f78bb6640696eddff515e7e79e9d2d2877505dc676e6d8f20375f7c126739b5d634082f53d68a29b1929f526bf701604dca66981f86a23af3e80e264f2750cb38731807453791178c54456fca431418662feddc54784cc29a18e5942485f609b4250c7a439553b91b4ac79397712b8c711e8dce38a6243495c741de7f4ee93b3022dd89e03c0ea25463854c1c6c11c6be59a07833e5b21d671838420c4a23d66dec9149024d0425e86718e431fa799261669ae56685a03c2b8c21199162637f1effbd81bc538df7cb13e204bd2470b042f2371b542231ff1db1437efbb1a7fa53dcb25a1213c96ce28db42568cca10984c75a1a8a2c27176572da05cf340fff011c729c307ce33bfdbde6d7b315393024c2282bc5ddfc46814a12d41760ec5f96df39c397d54adac182132eb666aa8766ae9f5f680128105f99410ec7f50859c95f61c5269a63cde2bdd02361958a9f1ba3bbdbe5197113579560252aff0a57119a638af448cdc2ea2fb021e9dd586c6b519b73d974044fc3d1619f30f3e28219e3efa78f54990ab470b95bb035c8e01a31421766157e5544f5c5d615890fa801adda41379d19b1c5a3cfcbe92128644abd19ba41779d93590e6492c8e906e7454805da0cd2679ebeaff1f941a278e3e34cd2cb76918dd238faf48b943d4eec898381394a41bc3328518124d8b3a954089d52c9088ae045065fd54058d9bb60516b11a76bc3c24389a0901f80747210278c631e381384edd8308b1c7f866b30852a49bcb74411cf8fb2c1901729206b55b077c3ea573a6ff8d26e6c808942ccb88c0222670bf09b3df601cd76e344a20d53feb9f016cd34d9394412dabbd1bd7fecc750dc6aef2a40230633318f76019b0e4c89b19a17d3c63b6c73b3ef5532f67942bb4a7f4a16c16a0d60c412b311501d0d51f3a5a0aa8d692539b87eceaded56ac132e2acf2d9738ec4944a45a44c40a1eabf38f1149be81277190664186be65eb12f61b027c3d3a0c842819830d212ab7635d58c976c14784e414aae792c9d283302a792809b2c02e5db13afd385c2e6625d9f79c07d58f6093bb4653d3d0c172a51c94a49c0756a9b7f8533499bbf3384a925b153d06169c6e02367f8d4ae0facbc659ffd89c3121efbee219445f61dd6eb9a057e199a973627288034013206dafa58b194eaf76090d801219e77cd01df6a1504d5f57ea58d351fdc20be8a9ad5ed4f2ec78320c47a754ee8b0ec4617a3935ac5139d188a575c3fc01f52334350e14d65891dfdd2615658da107bb3b5ef1bd177828c96c3d9df2cafd10487eca304507ef4ef022b157d4e2830eaab088f6e5151082f7f43b0dd0a983acd8d50862058db0c3fcc3fd5863bd0c7578144eb4e42431c2c4d6f435ce6f795adf34e919c367bae02b5241a32e451c8db62e7a1bf275780b85e7e0b8996a0127d920398a6ba60531d7ce9cab62e3d12c634f9cfb015cf027364827718d40891abec56e83e4ab53bcdd1da577583d8b2ead4380bba0ac41e8b817b310254a56957e14255320257693c97fa87266b1aaca70d561cb397bfda00dee61f0488c7e01295375aec4fa7483532aef4c6d1750f8b9e2f56d1816fb3aa83ec428485c02f2170249b52d0c24bd5854c8e3a46a92ba5410b709952e55c3673f58c7d166d5bc0bd547b7a17347ae9cae38e121b5c4f182a955e286be5ffec09f1032a063c7d48784518df844fbf46cda52aa51b1591514f4ebc0e1260219c372d5cde8c922ef99c5e5f5517c62d73d0591626287b34cd1ccaa6d35159c0ffa71b16e8eb13bc702168e33ba90185c946dde7a7a08c46f79d731d7a6a0ed0c1201094fba0f53faa6155be8053aa1b1a7dd85cf350332a20084b86c4482af597e17e3b3920fa2cce942185c9721636dec466f6f93660b7464c04f861d9aeea848617792ccaa7c5d520381bb1d360d38b2794b1ec9d9aaa44094ca90593e9ef3d7f15a0601477cb852a8294bcd4545727e98fa5d138ecf05f86c6f8723e886985c09fa9d6491975fa00577529f7b638f6d086ad051e3d952f215771cb4abab01758fa1711ee5313270165c8bcfdeb63c8317068d9268b0f7f6f22108a16bf38f02697b873309489b038c6c40280bd28bbaca0486a5adfc90dd0017ae736ab3bb0bdd306b8003c5d413fa2809168bc451b6b61c310af53f64b4d784bb43c532ee440d5409dd25c0303b4402ed7b67b94231a0a1d86afbf5398a48a2c024ce33238e93e27673f3526e87da6bcf9a16e991ad0d13c81611f4d5650d77366a17de0462de76d02b82db9357e23171c269c65dc92b215864b5b4e91ae6dc23e0bc3643a90103b06dc0c450083bf1767b2875fa0c7c3e264b91e3a5c0bd58727282493c2f87f4af126172e39992b8c331ed13e5048e8fb5eaa3efb74032fdd44e007273274d3662ab306bf8bebdff987815ab0156a6b8ffa0da1c7b79b86ab5192fd30972b1c2032eb2db38e0809c44c76538fe910e1cd1a4e785ac2f5150a0752d584b2bc658c8a01b524d339a4bb970bb5b6ed43e82e986a1fc048f9e2a491cd9bf2c78b08ef486aa02e3917217c8b671c7b45f8c8ba700299ed127c3d0fd3f12e8bffb7c03647876fa96552241c9eed3782df6315a43252a4508f12aa200cc080c7e3bb8ee8b8810b8def132f395fecee287250f6e7bef415ff10119afcbfa5ecd1be4add1ab234fa30b8fe5350c13d8c17908e6728bae1ba4fc1e1c072b8c94f42faf58efbbee59de4348271fac73e1dfe7d33ee46b7558f5c4d20bdfbcee3e82cb9f1618256d501a2e0e9a81b8d8f0d23c04dd23fb6990c884b9e026590f985b7b1d31d6cad366394c811a88fc52544147dafcf8a57bc068a26949fc0c26256b9fbc7c3f503fb9630a2dad9f2802495eb3b898cdc6aaf95c1c70bf3630edd9352a5faafdd8b59c78aa4de6a33af874ed960854ddad1495940564679810673f13cae7f9cf014664823e5d40ffd8fd6cf0f053f6d4fdb8a938c9b6784c72659ae660422036e822910a608c50087de16aa0243f3dc44511681a42bb82d9d608ec7b59f56da555af749f0f1a524d28e4610ecc15817b9f4da8370a5f98e3ae3911b0fb12bb3fb1ceb70323214537a74f0516aa8726468636e5302645dbec7b1fbec1f0006efc71af65f4c54d84bcf7b33f71ce6e233ee13c743f169279595000270ca94757f4f6a3f2f23f636b40bd317fecec2243fbad6db8ffb3dbf1a50eaba69872cfe5c2e5eeb6c29d2637faaf37aed8639fd19f8bdc51f9b1341b98ea34baeab3ea9689dbb02572dcfefea6efe9eba3ef0eee9d9c569472deca19cd46b1040753a4967e43b4e22243ace19a2c03e5d295f28df8435253d1f85abfd4dee5736a31ab10e155d39544596d82845fdf3aff5fd01e9a4ab2d3409ee730406192df3f389f53caed958614f1bc1e69361012689030b0ee149b52d508ffd7c21905d1a9050709f6efb9c53884318428c4858d1e84bfd64d10f1d6a601f320ef75dc27ef429e329a90884e58fba1f772fc0f5dd7c210f3bbdc3ef860851841fb59f2a26d249150129dffdcc5ba1fefeb7fa19dbc64b08bd8e4410b456ddc15b59862bfec4086dcafdf66f97f538585d9ade8b4735f8d084c9407525491555cc01a798c5cfd8d6915b653ba1421e095f9f36d36d9d54314e842dfd3e4845af1670a8b444320281f2100b47dcaa3cd6e88f414716585a23bcabe91afdc83aa9fbb4d781f7cf4a93931f424cf7ad41d3f7e9f84dc064ce7c3166bee18272e8d234196161b5f3700aa67c2cfc2473bf94adbbaca9a9a5e6d2768fa521fb6359db929bbe74eff0906b27e5654c0aa82ce381dfde34df49cb993be982fd633df33106db0ea409144e9d8af5099a657d6b3e7048111ef0a8856b7028255e375a118f55aa4c75ac2b912aa09fc79e8ffc4b9ec686b2b7c5022ba457fb392bab81e9ddf9cf7919a07dbda1f41c7ee671f4473deafdcfb01f24ec3d74992d38883508a31784d8eb87d995275d791bf8975626935584fb06f55c3fee2769115e970228f6b7f4d1c2c6428dcdee9083a82026346f49d6f21927895cdea9b7d85d8e79b9e044d38d72e1c925f6e1fbd26958299c4a6c2c84205cbd03a12a57526383052cc0c24c90f62dbacbcad10c44de686572c99702552f8b1b37a9bee72d7f2e7e20aecdd73046c95c818e66b66e6142a8523679822434c4221076fb208746202dc2f8abe131d096881c366668de033d150164ad7ba27ba1a3ae5eaaff0b994323413ab7198536fcbedf2ff627a7cac37bc1dbf624eae3f8b7e8a8805fd163144ff5b9356c87e379eec00102d365a4fe0fbfa650f0708340a39020d484505342dddb0f04658d637f106642c9b55fc6f26933468a51049b8ad3e59b05efe56c047357d553e9f428c4b44dac044f4485e5c85f42a394f96532c795071021e297290f51724e578b741882ca0d4832bbb48dc05ff6f542601d9414462538b97e3df592c901a4e754b7e4a4a76ffce0dfefcff0d54264302a83fff43d7ebade7d0930f5fb038945503c360d5bc206ff5ee18369bc7aed8c57d61fd12f04fe29c8a97c14bf6b434223105a7694cc71d795c315f3e37c936a20cfcc42600d05e0d0b936a2059ad9eab76815c6a938bba286fad6544e463b660065cf476d600ff0fe641cf3e1ecab36ab16e30892ee8ad8c18a724b8759a7b718ce9ae94728b2dbdad7198cc3ad36fbd4eeb8a1855e14d989888b6d65b34be223d6a152d3757723621886ba44e380f2ed0082086126310996e82ec742d3d52045bea78dbd8dc37c5303e583f18db09f8e075586237f08860662393fadc0fbc06afc49a57ad50a7fe9e7e9163566ff93850b988f75a1294bc1ac150be1f449883bc9590124193dd51410463aa68afe6c1b29f4509c660f86e75dffdaacb14f93188543f695f0ac49d11380853c84e2edf88bd83ed99dbf9012f91cc251a6856a240eabc5755dedbb71e30b8330b80b41a75f5c40bbf3929b7e99a8ed341cbe01bc1f824b8c0701e3c00795581cfc9bfd4b5f7de1ce533f9e60106009a1748f5e1798be5b3184dfd696dbd4249aa32e6846cb5817da8280d221e03288b93eadeafd768f4b0d2055ef2a32369e6f71eff7d8db951a88c2c2cec294842de1a62ac0a7c47ecc6f3c1f9eb1337935dab2fbb8e63637cfe067084ef586d862e2e9a48d1875f9b2df6bafa846d10810d6ed6422d8e3f3115f8168597f6f0d7d87bdbc378da3db6a32d2d162502a0f9eb7940ddcf532ab6182f57b7bb62317ec7cdb6ec463d6c802747482951a55bb7842247aa2e847af215ea81e93afb1095cd315b839e4073a97f717f9cf251374fc192ac190390c66451f1769f2b895a63fe6092ef8f8d9ec09a793857ac85684e0df92bfcb6a8fe11b69577b23b0addf2a6cb3806c7c643397de7228e16ff1b4fd8f3722d5450027b652fc7c48804c71ed239b773c48b72594db00576172d345b50f287abc1284ab52c28b818b1906429594439344c6a4e5585a229b40c51565751d52e659851fa1ab908d237e649808be24ea99b0405e8ababe1ca765307343531db4187335b096c689d668d582edac7047878825840ed90a00f8ef6681dd759f34462992265498c09e99f4f779829895e02041b45d43b525bcafaf8e600b33fa5b4f8012059284992b1bc86bbbea350597a498abdf3effd8d31ec6852fed4bde085665bef81ba98b8c9777450c473bc033efc8b7ce275868d1ab9517abbd105b9fc2504db4476eb44203a62aa451ff06f8c38697b7aebc416cf000bf6c17772f27122ab280afed2a2a81705c7fa12754d087973f7011c960e17fa3cf4df062a10882a923b035edc3893ba9d2a77126bf1ceab18b383c53e3f0f81b0caca25b0ec797312a8d57c1e02c096979b40d9e7e625a06c2b6884f990776698c2a391b8cdc50feb8773050fe4c8112f919d25b08647e972010000d2fe751f230b254e1c2e7162f552154ee96b0376523227ae1e8f3602405e3d0d0769043b35c76ec6ca95d9603ba2f8214038b98df3d3e65502f5f3105616d003b5d22e35a91563fd0b2630fbe67a14cc1c130240859c88d04e194c0db43c3cf40cb408ac76ee7e8a761c38c3e90272c712d1254a4f63d9dbb663c7e4b6b7c6ddcb6f9b45779f73fb6b748f1469e55c5970d2fe586e601b75ade37bebdae9fcde5cff7ed381d00f5c40d1876f5b79051c8c040aca7324ca7f83646348f48c1467e15e19cc18e4470b2d4c73acf9d72df9e3c8a329b951ae0da3d18da13229b40197f94e5aac6a58577c7be682b66955bec4f2a0c8aafa07ddf5efcdaec4f35b793f17395d791780630cbf6fc5fa5f1e5d15bc7baacac304111f49b7140c2733d98166e027945feae464ab690e085f60a729981d8975e68c2cdd5fec1ce27e964d8f7b5d8a0a9c23eea98c323b36287297a4bf55a67a6133a7ca4dfdb90d42c8b54f4a11f9e76e4ab3858a3828a9bddcdaa6552b7b64c2571f0464898c05b6f6a6b747b4b5d30c156e5abf1f956f6e26914dd8bb0f42cd8eee6e9c5f2529d9e66e27a61d76e4e0ed4a0196af29ba99ea099453bc7f5529d9676ed2d80f9f270feffd5505c99fbb99627f78de6cf8f75728257fd66d9ab2878c7c52597a1a983d52152027aabe702fde2ee6f65f1539d9e5b7a5da9dabb705fe7c1489e497bf9568f7bc9e1d78f3a12493bffc4652fb734d6fd84d8111480a44b634bf8ba2c214061c08c5c742db378beef95f8636321fff326c5b249c0efa1d682aff0dd9557bfac0739484e920afce4f1c01147ed3661e81413e6fc4c584a48ac7a54e9d3986cc87a81ae2edde442ea4632ce4d0a6929f5856a6af0f56eddbcd9ae7b8a668129fcd2d23a8c9bb8da47d4d16ae987099d1db582c719f7b87d02c20cce0ee19113ca715f61e08b0510174da6ff7d18f7956db67fb09d7987d98aad837189535117a8637c0f15d67009477cb2d6ae2c22e01c5d8d892456885dd30340a6e327eb032138d28c4fe50594e6c164419638a1d74c7afd4132b53b7772d8aeea61ce16159c97867544ace78921f2c1b4168eaf6506cd9514622a98eed4cd1ed3ad55269e2382448742a1c7689484db4c011bafad42dc73d5d64f93b03097a0f9ae5886745283616a789d2f1e5e0d88852acdfbb920581066f3d28336ba02dd0887a79f7ef3b2b055f9bada3d5541f4fc7cb708a3a03c112c19c3d868c525e4f9063946c7740195b7ca0a9e2ae213f4d720ea413b9a2e3abaae397ab33b06eaace27b8c3dadd840cbf5ba6d0dd6f19d8038ca627b818e3fb9d4951c7da80ed3bcfbc046910776a87389f367dfcf3b24c0c1312f8973796161ee298349cd2b5175cbab35f89372a179fcf2ddb5b798ec6f9f4f6f389c69bfe99a1394020321916afa277a4bbdf2486bd5f17d1babf8ebd59f4f2f8bb3bb7719ea973d7edf2d2871e6c796df39fa54cb17aa50e6a6872d4eb9eb8e8e8be4a6a24cb590ab1c5e517c7b18625a022387c174d22b6618d2f582ba289852224c9fc69cc3207ea084305cf5fc1301672e2a809331fa7ffefa04523a67b6fc43bd5b5319c4ec73d10cf44d74efacaf7939a755aa0a683a1aa5db6388174242194fb1bbc69602a23241a81cfe574e5245c556dbda03eac64ece5a5b19461225e3006aed1ea401a5137c07a50dde03604889e7880917cd7da84df57e9e70b41bb5e2007180489fa8bc11e4e8b5a407ed72ae35b15c0df7a0d3ae4a532504696e61ba6f9bda0166b2b8d7fa49ffdde1eb2414418e1df07ccba396dca45d2cbdcfd72ad66c54a74f9c87d2d8fa006e1ced177a8645d7b171f1ca95789a8413de4536d70eaa16e1c24cb1066947de1f78a3bc61c60d43a7a259c3fac2c88ab1acd05b89d7fca604c872103ecd34120ade48c48ec79b0f934c07e47b167163ea3fd0e07587cac6b01923b6ab899ad380eef4221f5b25d736e590f5e6754b8b526b3f3ef2b0f3607c3ff3e8ce465b32826e98132d27039d605b9dd9879f12692667763020c2f10976797c03cd1d17181f0966b1c28e3ecc02f21e5ed3c5e06af70544eb89ad87c4528a41142a17f64ebf53c37b596fe249c24c05a82089e627cfd0833878b6f0e42fa30154bad0e8e60d86d917d300a5813967eede2371672ac81cecfedb7fb665c905b4b82749747712bae563e28afd0464039f17d232d581f42e2d11d6fbb86ecd97e88c260eed466455c4509de45dff9b147036af7b13f2224bc02d95d399279ac5e4be329a76bbef6cacf5135988aad925d772a87af5a5edb0b4afd1250ad4a816ddfb33502d620cdf8af3cd12a99bac594440b70b449a5b9cc554a2d346a41f6a66573fddd506da59e98bcda9f3fdfa4f2e0f296c427f320db8f664ea695a14c39e5fc6ac557e06d6082f62a185e6b46028ca4cd3f5bfead0113ad9f5c5481ded52605c2253d698e7ea006260b63377ee59c46c62e8f88c628c09bbe306fe2d2976946b51eb0c6ff710e08db721f1385101ac163a52149970892eea45666c2b78e941ee62e6ec7d9a66828620fe053b607fb5bb1634a5f4a4890028f14b8b4a835ab988ccf2159ce73eea956810dcc221f6c88cc43f70a8724c6c748123940cc95ab39ad8d70e47aed04d303f3aa07d87e83528fa008618157ef03ed4dda648927cadc3ffcc0407f0b8d66c80a6b158115659586a5ecd8b68814d246a9fc4674578da4299a27eb1618fdb5bd4fa8d188b84116d4e4df7fad24b449f54d696d5344f4a3230b29e5db91af1d6f2c6249146b1f09444db30add7f8e88ff56644e834ca313fb7cb25e394af3bce32102f9b362d73aaa16b9cde0d4357fb3e5161b0b4ddb7c351321cd904626be85561da98739397c20339ec68289b5e58b83e0467a0ce8274e6832eb6e43650224bd2974c867ffcdad9440dca8c9fddbdc8b6fa701206ae776e55908691fd9a2842dd136482f139e1afbb4272de27e0b43df896a91e0fe088a4b2c2bf2d33f11c30c68a19e196cd3ca97331f742249d85e8a35c6fd685f28fa3e66afd842b8e28865035e071ccb12f62dc7100ef6952c032e1178f8db0958fd2b20fdce1b5ad8c04d65410646bef32a6b28709b5d8166e302a6e8e97742e158b353e26b0e9adbd6c951dcb4fb6155f24c93f5eccc17bf9f20b8751ada81f2a1d1d2489ecc3df5e8bb7c288fe91be75c22d6a4b3a33e58de84f6bc2b01a637ce05cab51484ed0a166bb966cc23ee56431200c1366c6f18f4fe64a382aeb357c7c9647c9340881f6ad95b6fb66b2d3e33e6aa1cb041ae66024b0e03ddb2fb17ee287be38977d06c267ec9025bdfcf9f347bb9f1490f2e492c788910cbf486a1b5e87588f4b4d6c31d4f140be49b8d0c689adb3adee6a82e89e9ef1b96b3f00a4b3a81853186140aa4cc599f61882a55ab5cb8a818acdb15a6e6037f85eb0e411a85ab26da0f994c16cacddbd562dd5d9c11b64e4d297bc70cf39c32c39e5b514f30442637573a2d5d5bc45367c74168e68a45e830e72b165b66288af8e19d8d2465a255c7d966a3ae693f92f20269ca9588f4ee5130c91f8cdb4820d022723fdf40b916b2d1c06cb2c9e5708e35c726644dfa2b90fe627befbb83b30a5a59cb119d0f6c663d7b69dd5b4bc410ce5050685387610f70f983f45e5d798b0bc6845c6998d7888412bf77967103b6e399099a41feb3166a887ae81b1b4e649341c9c9e51e6d6108f3bf4ad754598ff0821673ab777f87f861a09fa27096be0ee0b098377719fc331bce8bbfe02ce9e2b24f767a56402ab456f37e0eb21200575135286288306fc9c9dd4a10ef4572a7341cbeabf61d6d5ddaad70eaee1a23ddab6ef09b9c4d1d61807439282c37c798894d692030d16e8e98b9e18e1e7a28934b626b4d105e22494ce31642600badea37e18b34866762aba2c8f9dc4fe641e99c38045b426d6e40069e08378cdeb32d0abdaebe8851edf018661d4da4f875ba70ca42fe75b48cb0edb58e8952f04d181e5ab76413902e26fd1a0e93382b2e87da7a5aa1402b94ff02cc9d2a13d9b56b65feca5f5089f74598e42a5c91869c25c432482fa14f218b60dabb5f6bdfdec9cd2df10ad2d750570728fb69e244ef6734612630215ea29ae0c0c02fade927e1fd177ef2892b95fe9392f13550ffbe0900c9a6f7603e2cb13a77f70ff1fed2b4f4efc2396cd00dcc344809d8ac9f9b0517ef6b9839430a1ee307687a72e588fe8a926da4aff893636ca2f8ce337c7d8e30e7650868e440edf1e1f1a0efa9810626673372228e1350ab8179ea03b9dfa94e9995b3a3b6121418b48af77a4a2c087fdb014601fe736ae80cc26181978f466b221967a2ef7351d60c7878c2353c8141a334c6ce5521b8efc5a15a0b31e6152ebffb9dd5c3ccd35a5cc4d39979a1db6c296a171b5b4e62a97000ddc05b6f0a9e93590eaf8d09468900a2ba254a9dc21c8579009c427b485e96406b5ec6fe0d6ddfb165eb5714aa64036b1d99db667b8e66cc196c64827d6d967c693c8bbc9015506b93b05b317b76ec0eed64889fe618dff9aecbda004915fe88aaea7d9d06b4332245e660571f4fafe4da9e84d32261fb3216bf3c2355cfb18396844186eb8f55827beec0530812aed470a68ab3fb9442c9de9ef26b3a405bca2ad5e97e4c352b7c45cb32e890c498bf870804eb68013a0b3f8ee810182e4aad47d1d65213d3ce905b966726392ce69cf3955198bada521cdaebd77d538b3659c6ea428ad96d7918ee5b3d5d50289add16e33378f28653fda087a527ea08f33e8a1b7241a3e6770f32f0d9b78acab098f8eb1529553e88daa6d68619337a1651ec27659ee9683f36db19086fa73be70e04548dc10235a9a29c18c0fa48d6c04dc134dede492089619a1824587f1a9526397483f13dabae8f2b2172496b66b8c5d860d940216313742f3323a9e3c2b03e59dc7ececc679c49407b056d6c3806b9c8d0123913b6510314e2de36953533ae63e76a5d125dea4da9c5ea42e9f3a9e25599d958b216c2e035c13f04b2615aec119dcc812a6b17b1ee4a09340acb1846521fd056a366c9c7479b49c20731f886a56c21e0796d5ee19c0b6fa4547fd89d653c56e0cb5f3847c15b29eb1b9863982d94f20be6507823e57ac3e92ce3b10a5f7ec1398200a1fb9555ac267625f9868d5301a25969ae2a8d7bc0d19fe4fd8730eb7923e30c06e8fdacf345d2bfda7adfa2cc5652b8abd4ebef29f3190c3dc36f85248876fa2a3387d544ff00f64df30534458aa0381028baed1fda57a5b329ca2a628a30e834c6f7e09af9178fa2eaf2fc49348dceed4f9417717142be3019b94ea5a9feb4b2fd082e1b099ff8350ccbb653b8370b4f9ea4ee77cc01a4c9f4894453645944cd7019e4a09f647024e843e4a0a06f1b639470944c3e9b5f40e28d49858f86dbebc5db762bea9cddafd721e09b8762adbc1eb3f8c0a026636e1a943874b406804ade017f5fdf223a380321c5c98618afb3364209ac28d130f3471e4628473d2a3b23d6329bb11e2da10068d1d6b8374bb4f740919bd7f8cfd9a5de82236dd38332acc8e4440060f8be477c7209a745a4665b8bef4d7629a18813d7bd24ccbfdfed9021c0227a7fd1ac755f644eb46bc9d18c8ee4da56d2abe4595594fa68b54c09502fd59694cbae8dd33929c59fdf546020954bc63472b26f28b3e321f306c91256be8c02a7cdc99e6b43d350fba9d24df29fc8a93030f93776590a357e49ae0d03c40b5b300e499e90a2022cb8743b9e1af3834b633c8a8a6320f34c5d9ca0f298c6a17738ced89c2b4a1f826a3aaa76fa93303a979e3a04250ae7b211cebd2d262fb4533c9796e56d465e1a4f4db56c5027ecfec255186b21e31b5991f615164b2682d3706374d6caa680423159fea37b475770ec849f0534c9a516922989aeb2e61bd965ded4210a2b28e7fb21effe49ce119ac426e181f848bdf3fe6435bcdc9e114b5a6b0576adc87231ba064798107f311f292bde1e62a0f6f79c33bc7f61820d90d4ad01180a4a7096845f8ac9c2dd09c941843688cf3168216ea6e8bd5203853f6f6b5ab978950258a90b2bcb637ec844f9a96e8a0dc4ef08e4327e8e4a2ad493e1560b2da6645792b08d316c40bcc6c2f442727679eefd8fad4c19adb18e07f8bd74537f06eb9530330c0b992a91e0d95d6e62b3acb7be3bfa50ea9d83ad1d00a0b594a813ff505bd01f55381d386c0978bc589cb4028ecd7519d91144ca24b8b7e699c1975c5d5193d697d0240a382051943c2444c1a58f5867f364cb8927cb55b475c0b445f5a91821b175456bad3a4617d4e09ef4ef756179c06611eb4a49cdc0be82efeaaf5cdac56d3fa1507e285155d40212bb8af207b8bfde03c4956795f187a121cef8ae1750865d4e1914bca7710927441933b80c68ed16cd388ec6c8a132573a1e7abba1ad17e9f8e0b9a93c9d0db11e406c7983c42e394f500bf20bed9cfd781c9d57c2c3798e3b52722cbf8e603cd82c3b7692b38a02f42ad838a2ff4930ca63b8fe6cf37a56d9a48cf5878d23ef04178bab4855283bde449035a147bb4d108017f1aa777a72272aa7c389fc5a8db2170fd820991d8c5070834a17edf818828da398614b6aafc9629e4bab6c1547801a826dccdb79f78ccb38b8eec2872c5bc7d6a605831bb2c67a8c8052a65a19eb049a63606a0c1c2b67d82685dbfa6a9b3ab76dacf611c516c62fcfc8de84825393a6fb9d42ee38d3fc3c53da8557769b5a98c6528c5a50146c61927cea5089e9c4d596b529e74ddd3d9d13cee41bb744db68b753894486c6e897c2f5392e1baf303290dd72a530b8192e81c25c66cce8dbb0ba02196aa855bab08ab92774f8cd8262c3ef04f0658f30bf56142999d0f75997a18ace4045b5d1da4716ec64a3b3725e6f252df4134b2e405b41a06d669ed010ad204fb250861bddffe08f5486b81a01d95c5e5dbb01022cb05094c981e73a5c9cb5e9e5d03df8d04cb8129731b93d2f8f9916c2303010f75a17ba8f54f05a5508380159ff21084cda8d5a55e31ea9784b666c4306e82a2115d19f9ed4979b3774acdabfe5bfaff6874fb5c24e1053b42fd5892a9bffe38901c8ba110319cfeb39a03f769b67aca52710c7e88fd75738e1aaf37ed04b2b295326cadaaa6dd7346e530ef88484b1bfa769f50f672b3b82feb7d11e946dbe8c050cecb6ae9a441109ea7a17d7ca98694e4dd149d1e292123e28b31055f320b0f4dfee8d3e6e2520ff74245e1bfe344a8572c5b441172adc12a8f33b393bbeed8c0f7e2624b7bcb57b7da8a1f53fa5c8b599b7778bd85cb1e8b90cd987dea1170cc900c5e80db6450acc99fa4c8dabb159ceb1140a9d2aac75468400494e733781294e93b38273324cd3b9260fc7053b0ba0c69d78bcd230467a9a4ddc5d8c06fba4da7e2e4983aa63498dd69c04a5feae7a93f49c8d25bf83205a2cc0f6fd176d32656387f33c83ce4eb96275f532358b9e45bf6a2acfedf0147f17a310f8549884c3bfd80eb110ec8ce29cf41272220fe960ab2c59964e20a9d4d2186b84b560c40167412c0758c51503fd0ba4d3ba864308742c75b05dde782ef0432ac37deb30add13dac0e6021705649e82d2cb8e30b23143e04c643738ac69cdda9cd97f97cbfa1baae2b076fa78c3feccd32962bf2e9339893301b94f30fcb31e8564afb067320608bf2fc177624ceb4a1612a5ded969beec3a10e00b84db5e8180579da0abd40dcace57de8705d80ba468a365ccd0c8c29397fc10a58101a0b71c4524f8b8e3e85d6b720f08507542e71b29501daea58601a2f8c9ec9971cd07b38a18f3f2bc68ff3b6c7532d9de6c7f0a9a69637f427f2bc787eb8ff8e40bdcc9bf18ffad53c3610eba57a53abff388e44db0da5db1367e80b51fa709a30323c59ea2e0c4bb7c9b4ab335648d49149bd827e9d13fc7e7c977aa5d38dda79c7b9cb600b73a115989527e80f9759ce975fc544bf5e00454763bdbe29c47f2cc7d97aea1368fc44c3fc5d9115372a9e429188985911900c62fb737308e290cec5dd26a37a1d835414d620f17167cd15dfaf2c91c911c26ad604b79195bf96023745a32cff21320bd862cd4b8c382d92e8d1bd75e120e27905ee7e1748507fcd0fbd8cc395c46c641b4d881e1f4a7380a7abf9d64528ae1a0bd256c41baab928948172a5ea1c50862454782b70148575c771211488a495cc77e969c74b4fafe09711c6d7093ce993e1f190e4bc9645352354517c34bb8ca173ac6b7f6e91e56d16a6ed899020cdf524af9e93dd333b09b48764117ce6eceafa4a4a13702538e667f8b04e99ada0b28902161f7edd4f0aa5d13be4582d4553e409425091f71ea261820277a1f3b392e5e7bf6857c3aa5ea07f07211f31203572012654e67223fa74f351475492bfca950119b4a456c0d9a1938a56181b6ece68e5cb76509a6ff4ed0a797d5b55536190baab4be3855014104c153e9e00853e9596f5ba6e5fb6ba70a6c279c878609faa35744aeffcbcf3e230a0f945db6c042ca2fec4ba59e8eec387f50a2dbf815c10a229a659ec44b63b3f866979d17c97ab4d34f0e0819ae8f627bc5a03216b7c1738513aa8905c8763ea82fbf15d4a5b2e543a30a913880f81702e8531d9f9e3ba5a2aba1cc21a1c1201f9d6d3984d6be271c24567791a708e638ec311843eaa32c93b89971d0d0b948d414899597b7808d7360cd5cb10eac20be53dbfa3ccf25984240e3accb26ef25a55a3d4e40f3f83b978032d24a33a07c78b3973eb5ef8f7dd4c63c8c2fcad8cead4589323cdd8ad1a4ad21b9d087f2154d954c959ecf3377c2e3665e9adda15310fc12d38cc20ab519f7ae365737c9b6ff33512a8f82efc44c9b171fa73f85b7fb8241ad0a4d545ddd6c606cc18e70006e4e0d534815d66d7911161ba83add966935550e28e1d90841a64e494143b21c5ce32e664a6487df95e2aa585fc49fb8cbf32bc2be86957dab37855bd4c99c45799a1d39835a02f47f4bacb97aaaf3b6f19a82816636a2f80bea9e4942e18087dbe52b1ec92a8663ac03fecb21747e7b0d2da2cd2e9bb80cb5840c0c27960a577b4cda60e26dd948b112d9ae621d81e2a56f2ee0aae1a270146179a6593246baad2a5fe5e65d097c66e90eef4d04a0c2d4ca9f9863fcc54ac54d9065758b8609d958a5c65b7c49de60847170dce5e6edd6590943189853c27ea5d049dbb21ec523d46b5e0d14a8f528ad5c750ce35580c3a61b4a6e6ff68a6326b9677178fa67e84c60b15998e339492af73ad20005e7b0ae34c7e1146d7ecaf4874fa4ce97dc541b26aac593349b32020a8a6ba57cf188cf3607170fb101f86b4310221b0c20fa290d96e9c42111a286e64490c3dc45f2e8dbe1546fbede92aef6a51fa8480fa5b21785f59571792ad4ca1d7d6b3a5117b5d20c728eaf627ddaa20034a08e10b6538096375847427270c646ea1a797ba6880a0dd36e5d00490904022f9643f0b8fffb53ccc01546726428cfde3313d66d98468914c75230fbd51e112d38cc50a9c27e6da079282c651f9eacf760e907890bdd26f1838a9ff1915e20fd357008b0a166934f8bc4f83d8a71adb96ec23c6c25d95812a28d8924e8981bad767ae1e8e426b1af0dcb24f7306a4617d25598e3188525caef981c4dada077696cb01c2d3edaa301844ab3270a22addf3e2a8b59927e4faefe39db21ea7c8973ffe32ccfa1a245895c513d8f329c6a5d25126eb5e215f53554dfe601e5032be3b7725907d4c5b9c3f96995f5970c6a2e353535626c7e3d8a60b4f402efd6183a6cfee9139c5724dfe2bd5ea8e9c70c3f52b2e91a23bdea04675ff7651c06dcbc35215e797ab1df2a2ca2fd6f0c9aeed0700e01f5127578e807c3cc1d86d41f79f355b0124e0af71bef97f0b3bcbd17cb0078548b656eee0daa5cff37c2298827e7bd3b03050798b2517c069ca36c644bc8816d6c0875cab47d22fe0549d0bf73fbcfc44bd25020e502b0ddd32022b065a4b9f7daf4964d86fd3d8584856001e6c480cbb400da434149dc4b71f6b0d234497f840b36ff8c1da4638dad478c276773ce83ec65074ffc67ff750c22b449b4c40c040cb4966e9b7e56456f3cff643a34a5a135f976773473fdc3e159be69b6b87604e4b04385f9abe759f4b7a5859ce79531880c78018b2277113bec70c9fe48693c53402fd4c1f8cb8c4a371be0c46cb074312b2a2a1f601608bc56d09eb47c9010a0a0cb428865d521ff17b757f6c9cd25a9cfb45d0cd751bb4676869d73aced65105a1606d94c9a023731cf4c01e9dcfabb27a059678697ffd48937d81dad0bfa98590f977e248b39d17aa2d9fe2edabf51a2283f8583e17bdb0241992fd89a9007f0a923ba675320a45daf41b7f0b00490a107115362aa16f1570b9acefbf06645a41a3c868774c7249ae2b77375c94e93c4e9e2a29d8c43a60af2c1f9c3dfaa6a234810105db3795ede906dfc19b7e9eda26225e4eed4ce43e4a4e9d41a71556f507e78b55c018e6a6f6997e3051bda142d4b84c530181b93920c8e258c4991ecbcc8a06eea8408184b88def4fa906f59d2eb096532ea2ebac20f4cb79efae1814086516486f35de3459bdeeb8d9f12d5e95a08141638128c063bf2b52d044773427ef5dee7360270b4a507bc36d37c8881f5a86a99ef3abf51594c9bf079f391b59464c96fc2319644a5be30a1c009ef9c205b86ac903c21c11092daba944714d2d997e18b2e3502a7ab56661501c4c7cd210678f42b6ede3005168d7b55e3c5e70f8770243f9e1be5d489b090f30d9ec24a31eba25be0524fbe5b710306395bb930f7bd3ed4ffe0e2091be6495f4a40ed063bb2bd5ee21193836273069e9a82744d37c9d31b8d10d8b9eb4a87d6c8fa47b579519c85ff500f592df69984d18d40ecf2f3f593aae4493f84c69a6f3b6f09b4dd9bd81d3ea079234cf6ee08281cb5de7c6f1894c5d35757d598535a83aacf5352f447abbb3ed109c1d3601122ef7f6645bee1426f1039aebefb95737363a73999fde4655c093872dbfded9053c4752d364edc0a1be8668eb8278004bc7fada6e1f286512219da67f59ed3ee4562b4c3ebeed8c9522d32db4374feeb79dd4f9256ab82104d13267d0d5d05ad4de6c21ee569f310158116189063624cf8f687d8da80d2ecfcfb5390b568c8c941bd30b7d7d2ff1899dd792138601cda5046576ce52b82a112745d6948cde41b28493571dfa3b80b0ee792468bb009e9c9ea63c6397242dce0cc71666c25deb59e1b4f54ce16c610670b4343bdc5acf74c36b32b5a06f3e6cee020e8493935cadda985761b567cd3b394ea7a1a9c19cc3aa64fcf817e4a96a7e7fb7c81f6860d66213cf187bbc0dcacb429deaafdda5757a41d02918a122103cdaf0aa6558747fa4c32569e9ae490913828e10be0e6956c7e1317ce5e46823f9df6f275cd7eddde90f2ecc1ad638928e4f89d38beb5d7d661d44c3c099e22d5af1cacb7ceb3584d095a579600af5e8dcbe0aa166024377debdf49cc82cf03e2b786fea659f3e58c55917ee649b530caa93a3dc78abca9d0addce4d17bf5e74f34719e58249863107751ab8e964acc9749b568e811bc71c35d67faa6e904397d57165c09491ffb2bc69f7394c9923e83cd39337bdf7982a9ddb7adc1603da7e9b98b91a98d0f960386fe0dee54f01f3e8ff3af17690af8728ecbf7ad2baff247d9c9cedb8e07e04c7663cebdfe8f47d200e119d7a1b43d2e482ea8d9425f27fa32746a3a5cdf86fdb034d182e5ed8d6de535a8a16f27f361ffc852287fc1f8ea312737d35a0dac8ffbdd4b044ca5b84f3299c900854576290dbc266c830baa9966ae14b4f81260163ca8e9d0020bae9b32ee93aa93fbbb7a628e23782bc002c1846b87ccee32199a208c6bd33bc004c92a42a56640fafb6ddd2f34567dc5d606f117c5a6895aaa5708cc2909a761bf988c6e033be00accc897f2f0000c5a326d0771ec4008c649b4f25501305f7e2e6312c142ee4b47615bbd649479bc2be7d8572f091acf1358309109d61e47651738a4ff4d5d619cf0e6ae30989833ef2377ef907159caf89663eff8703c112fe00f10e93fcfe834addce21061a032aee988c762ecf6cc2a1014b9bdda2f7739425e0bc25a0818b2860b16ea7377aef064ad52e85f7ea3398ab808374d3e4efd9028028085ab7be4002b38a09266691bd868718505c36c11e13478ddc35c7b5691b09300c92ba25368fbe11030a2bb832adc916840d5069d92514c3cf50ca1b6083100c88e92b7cbf84051a7877033a754c4391a4d0316dc0f41308a79af4606db8bfa7aa8b00ee274b2b149cae04722bb7e0c701a088bff2d44399191901c69a394b2988f32b7e0e20fd1d0fa8c3772ea557c39c9e8fb553327e8bda430fa2aa3be8334156dbdddf01ad0ea21eb0b9a107e84070f1be01080394058be145811efe5a5d1502fd37c9082b369c40dccae3244282c08241d092872f204ae3aaf7b21fec48530f7b981f29875cf7d4a0ad91ed091ccd8266c4e45b93acfc37d34e81965d356ed50aa22bc7de55b26f49642248bdb744605deb38162d30fc2a0b24502df0c95d031fb3455f60964987088fc992d80bcc52f55c66421d3603ff9eb1555ee0e9ca4117ebff8adea3c2959c1ced5f0cb049613168fedb8aeead139b57284a1e5a62b56fa88ccdc54ca34fe7675d0bafb6831fac4f96869a717b688fe82f71f4117b846d1fd80eb692cff378cd599ddd4a3445fb898502a00abca687187461f2d34d8fc08ab5449785e395947e2ea5d6a817860afba6cfbf0723d100163adac3282cbbddde96d95cfeff4e85da9b4b6965bccdc1ce203c10f64a5fe6dc33a09439cbc5eafaf7d104c26d36912fbe55a7eb02aa0f260e9dd0f763d44753836033309bff29aab095be0fc70d944f494f170621abf4184f908d78fd945d44df28171fe43d50bbfc9cbfe7a7b45478e3d8c0712c9e6f8e509a5610cda471e6dbc1ebda75aa44ba0821262b16f9fe71f2a616940556b7d116ec7c0bbcb560be6c24add594b559094e0234e9302a6cfe8e38954615a3195ea7cdea8b36929506b793e50df0d3b98a89a6d823d0ea8123815e8f297250d33ac85ce0df2e55f01c338c547450abd85542382cec31a165241a29098ddae78129196488981e1b5e9995df3699f264e3470feab7656598ca52ae1ea71c6cd1c3f60491026bc4dc2bab9bd929fa5bfd00c1c893f6b7b4f04bcdcd808a619776144c89e308fd88681cfb309bd2dd7203da1ddeb6c08abdc051ad34e3adfc86539bee35d5a423ae301396736da34189d96982adbad2b031ece7ce3939af8dc4de689fd2aeb2e8a9ac6a2230034d6bacac920588eaad65a4ec5eb0e39891bec00a59b7cb957a0a49cfd0e2cb21fa43bf2ed23174592a41d33667ef5ddef028e86f899cbcd5b78873cfa6cf27c1a918cde36ff40d0ddf646c9f7d339e1a0ac0040ec096e5a64adad5b347fe40038bfcdf95d9a99d003dd8eb5185e0d9a7b31dd4decc53af4d2856649e62ea74e2f2ef373aee9d7cc15889473d724d809b2bbd45f7ae7a179ff682f29aafee556925d1c3080bb65f3db3388195d04958d674fef3b5528284231c95991735aa5d1b64f9300c8980c749d1cab0dee9f89b621299be67cc407da1e058d21e7df217ac41e2a559de995930b10342bcac95d02c7c2f981011cf505592aa2f9f4bcd1cb3028d1b2a82a79215daef167014ca99949638b3ca5903dc073ea50f486c695a35b43b98b6600a7cea88aa6ead88248013b7a48320c1bb1fbaadf40177dbfa50d2f32ac8f04bb85c2942e50f9a6a0e43d208616f32c26b98bed6a34ed8da24071facf8e199ca173602a6c233a40268bf9c9b4db9ac16d0580789f42cbd13331945f54bfb092aa2279e4f032e92cfabd04805a670ba89eb29349e015f36d34d3c9aff267f90f45db44489d070f39fc787de66dda5e6c32f371451af3c6a68417f6de7a4ff622ab3367dc64acf039266559628ea6a73935560b439d2750418678b18588647ec1c7a3cc4307c32f55ebf73480f7b5c43fb56d8c49871374d85a4f38c0fa2df8234b5056efb854814551030ed6a3a0c581bee38d40832fccd155c40f303b5048c0ca7d3e988fb81d36345d58afe29c46e29194d64174fa891b4bb45f88b4f249bce8df5e3f3b0b70b13abdff33aa42b5203fbcd31b4fd40c2ba096db2770a1216e814f9125e91b7f27c3c1b2fc7f3bc27de05dfcdcae5bd40eff33c98e7b52cf87a78e0e7b140cfc987e3adbe0bbcd5eafbc00ff49c7c9f17e4bbf16cbc17f8799e07f3887c37ae9507be40cff38aa8f703c90bca6a0396b7f26c3cf087676303c3f922e402af08e87d5feb73bd1756308463c5f33eeff33c2fc85d9ef30fc8786abca8e1d44b0f6778e185870c1174a96328b1458c303c8a47030ed5c3041eaa4ac09f7aa04287271e9c454b0f61d43855a229587ab8a00456ea9021273dfc107252751c5124868e91229e1baf89181e0a9accd6ecd084a6c0c7991c1704cd88f880c2100203d121241bf000b40606339a8301f5b1e33cf000e333560c4ec132bec17d5386b72c77ca8c6a7b8bbb23f98b9b1e87a1741eebaea5ac65e626832daa5c362e1b50c7ab89cb66452427ca84a69e974febe66504e6ecf0c09c960cd4ad74562298a6cc0d552d1d9fcb0604d22162a444d50d979c1204d261c2472484b505f45a50185015054b9258e6036f402c3f27a802c10948bc30c163c1440ca698f081415641398f470a6b832faa5a2d0c9ccc54b0e30885551513005005c4a64b4e8f9c1e2250a920f7d2376e5441d936556632842e9b950e4b0a54a105135ea08e16116fc71213ccf0c106c905ccbcde18808e0f873545743901affc17264ee0c1f2b9a172a3410b041089cbc90952f450e504235eb0201c32a3436259e18a2a9cb38643191d253b3c2e43564f5c409a9870e372d2ba79e958152d555911b9a1e246d58d6b4907ea65458812951b1b2b3950251429aa7c80404d6e5a301e3aad1b1ca59e1084a8ba7959b980c642156b15b2bc9696d60deb490b8994239cd3e6c8cb4aebc6054427c9c608d864e3a3c7100d825880e4b5c195270d4cb8798dae253a4b8a969c5c39a02b080bb66a6293031ea1535c36ae1b50887505349ae2b184ac7858160cd9bcc89513a5273f5e3716d8149980d48443f4f2018d80465a465421d10126b136605d6063041cb223c98ac80955a390b7aaad82c0156b849e10046005be4b28e1051a269630028815c89040a5a56a4fce4200e1030fb86c8172c2d2811598d1121f0d322842412c1cb0660d1198c181940c7a820071f110012e8610428b1207302215e4e0b4aea0220149103104103ff4c0830e5b7c8e088d38dc1005b5660e13d03e58430d05c8b028c30bb626e5c98d8b88186028b2c9409a2288803969e2a307cecdcb35440802a000e1cb2c4d1d2c5151da21002a0060270c26552ca1841164ba70296af2a30738012f4ac0454a942636ae56132924c0091f6a10000b231460871d5ec8d224e5c9911c4f8e551cdf1ba01aaac6770668c627062b0c4f031f06be0bd87c9163816f029f043e2abe26564b7c526018cf8887c18b086b880e90cfc75781d743e4c1daf9442f04757c38ac9bcfe6f5fa5c2ed6077a2bcf6bb9ce8e9590951555a00b5520961612eab9da302114a28ac5ca7169a00113c01e92803e728038a2b5421588c5c6829b213fca54d978013f585d80b35b392f2a2fa3d6cdeac98f1bd61655af28aa7a8060824dd14a073672c0a862ada962e504b94055ceeeb1a2cae6878ecff58425c49ae14c053840067002d842d50e9e1d3cab2051e8f5435c73026b8397910bca6ac70aca0b88aa155312a1d64d0b89aa154e2b0808849364e5813920d00d15d6062e2fad20ad9b56989c1e393d6c7ed858e0f2b242c109ad202b264e60655195411810476519100161393b5a22e8ad825648a0538e8fd6e7eae212e26a6255a0c36be1ac5860ce6ab5fa56aed56b657333045cb9b6b8767638dd88ae96cb5bb940225008f45e4056424cb0c1807544950e244c105ba09057d209201827f4c8a8af498119194833012f2090c569838a0106a5230ea214e1bb861a4247c21d2fd7970fb234ade9c20214c0e085211b0630e50630302081072800014b0c21346a50c3b95fd0b90d12a8e1c0171670c001c8941002081f7890a5a90a150c2ef061011553905942891248901119822f063ac0f080185cd59a149cc00d10bef8b040c4c003b0588002100045132f04400559085eba64695a9240175844a00a1bac6c4003127880031460851040b080421912a8c1c0170ab0820a27cc547db9a424eaa829830c3020e0802912f0441131b8f0a52c0410be7459527a02fb117524d0050474c02106335f86d0c11215a527301d3aa097418604bad0028b2912f0441345c8100033603a588af204564494e46747047d4d196478400b0860e1802912d0441132c4100017cc8c210303020742e31c7260b9b243470786c0d0020b1e7419f2c10516765449d8ac59a5e043014b8e2f8ed711a0115f11df109e922fc96ac81b7182561baca805187c433c21ae202b20de0fd08767810d8f9d9d5508eec8d111ea04c9018233e446b471bd5aaeafd562b1569e0771bf09739870779dc73769755f9b73425f62d2de9388bbe7ca31e32d0f73b884394d618ecf0ff5a1f44babafa5dad26de9935daeb9de485a2dc57103878d10870cf719b55dfb371dfda151a0509f2850e8b5b6a7e13c11e214e13ea3354cb5a57b4703338ee397252bad2043eeac273dac23ee8e818738465ce7f1e6dfbbe684f20641100457abefdbc0431b316cb8b876eb2f29ddf852fdb8a43f3e4fe613ebd046091b1bbcbcbf2bd5a1873654e5fdd0868a0d1135690d539a712dd7ade9db6ecd371b50e731df48dce3849eb4a6b639c1dd2f70b719e185e6b5596b7fe61f77f771f7235e194e92502934e79344e2c489919322274d9c307142e4648913254e92381972e2c4c8c8a8c8a88911132322a325464a8c92180d193929322a2a2a6a52c4a488a868499192a2244543454e9a1835296ad2a4099326444d963451d2244993a1264e9818312962d284091326444c963051c224099321264e888c888a889a10312122225a42a4842809d110919325464b8a963459c26409d192254b942c49b26468891325464a8a943451c244099192254a942849a2644889932446498a923449c2240951922549942449926428899321a3a1a2a126434c868886960c29194a323434441ba21a7a7717e2a10b059d47dc798536aef6199360dc5d03f0cb0d90cf8d0f0994043a02a54037403723504a2975f70cdcdd88bb17717790c7354461ae9c1908c29606b27077201eb69698cd28ec066836a3b05d7b93d29bd9cfbed96ca674d7def4995158f9a6ad355da34489c2a3ff46ee8aebe1095b3b2a0a74e408dd95962f45da5b732d2777582bc8dda9872d1da7daee9346a9b67fdbfb64d2e19cf151c83ac37d1cbb70779787ac07b072f01f0a050a4de243ff34eb149dfdc54d335ae9c574f6e393ab59774f18ec62bb735966b47cd3ac240cee3e86e01cac9355bafff8e4b735bbef974b9bfc30b42c0270f72e1e8273b8cd82977bf9b88c6b66c5d1a4a52c45ee2ee4ee50dcdd030fc1289d474de6ea641c0a2a2d0edafa62d2dd7b90b9923966b3471847913966a424c9eb7ae4ee3cdccd7a6eb296bfc9cf51296d6bb349b76dbb8f45933976b39df82a6ddcb47192ed5ad3d61cb5db399cd2cdb2317eda5f65dfdfdaea8bc9bbe4ee629871ce4a9ff1862a7fe7ce9c3192fea9fa584a6bd6a9bb9431951ac6d9e97e95ecee501eae80e83cd2acb933a65577dfe1ee3a3cc7dd71dcfdc693c1ddb778f899e177fb16e0ee14a6cb7b621aad61ba4f4cf196e93c0e8d49c62441faf78e26b4448911f94e68a513274a9a90e42709c26172a49db76d6dbbbcb5b57d16c2b65cc951a84a89a02d4ee871f82644a340a1fe7a1955e0e1477d5b33a7e96cd7d98e879e09dccd1a840f0fbd27dcbd87871e0f1e25bfbed6dd75dc5963bcadf358629c10f953a1e7c191bb5be0a107e4eef74d0a853e8d96e6896f9afe506d7d28d597d7d29fc2b8cfb25cd56977b771ff4a77ffe1a107ea3c6e5cade5ee9e679cf3d35b69f9379ffb33bdd8eebaefe3decce12cddb6e64d6dd7ee5d7119d768fd5aee3ec443a77277d1439fc1dd75d8ace59fc274b72d597395d479247f4aa6ab5988cc5a88c4a6598576b9669a35dd9db502ddfde3c0cc17073840151b1f6890f8410004c63875c08aa89a0488d0c831957c784060e4050fdd6b8cc3061134992a006163d4f35380245ef000b2c2b8cae924231c843983c20faf0a00a98a02c7d15455c57c05c48c0d38384467bcfc4b013473c6a3291085600d2b72de3e622c1ac63525c5a25e071e134355d5b3955a3d521db4284b0a4b6b4bb5a817fb5c3ddb8bd9ec10426506779c1d3478d4eb99c1a3cef3ad78563c5b8a45bd954dec6bf56c2f06ae89b1c01e2a7c7bb1af870a6f35021c213492080defcc19907ed4e3317306ec49420c07522b2ac6d174c159519c55cf151c5f8959992f332798e07df403bd038020084a7dd4061c33f55156cf5e51d62ae6d1970be49162f5881913b3e9916a51d69415eba32fa957cf981808ae562b70058220b85a510ff43ceaac2270dcf3bc559817b5b1a1ceca1ba4ada98fb6280be411f32326f5f578cce31163c58bbdc4ac3cda23664cccd52305d28fb65a3d62563129a71ea3ae7365471538424000234408e9f5c011a265b5e3078f7a3d3e780a30b3a26652203a62d13154ad332dea3a5bfc8845cb90a9aa02573cad9e174f1488b3c307779ccfd3f1c0a945573cad568be2b8ce961665f5ac7870583a4e2e123ebaead2a2df9702092dea1d7d2e176db97a52c869b5563c600a24b0a87704521c9c1565f18c2173c43a5af5a4907304d2291f4bc989453d58d1564f0aded18e35472cb0a70aef49c13bfa7aaaf04a687d200e38ab2216d107429042c1a1be2ad2e1f9705639383cded1475f3d551ff5e88bc78f7272a88deb06a4371ffdcc8034877a3c24d850efb3d1a17e94c343a6aaaa8a27050e8e56f486c7cc19ef684553e0e008a4ae23440b487568d4ea0887474787dee0d033ded10df5e88bc74c0ec5f17848b8a19e8d4749c0a15f4ec8a323848a8bb6a45c3d43ec3edaea1962b7a21cbccce0d033d48c0e4d811edd504fa7a76a453deaf59859d19b9e2a3329d0231dbad2f940878784125614a7a76a4575b4e844ade877c363c373c63bb2a1383c6652e0e00887e27c3c3a2b1d25215a40aa433f58d11cfae23163d385cc914e0f0994841b4a020eebc686278524c470106b51ef88888d508caf89b57aa486d87d74889d102d20fd68d48a7af4e5b4a274f5b5a4c0214a23fca84789ca086d70848000867aaf55d19831257c74454bf02848c72411e5a22d3ac6cc197a14654359b48417bda13e26057ac4ea1953428bdef49ca1472b6ad353c2ab87455d3d25b43ccaea29d3f26e06aa8858c3c31a1b5060460df0f33ed002de1c4f78ab700e1318f17e2001fe00636172629f8ff7792b2f470e325e46af550370d05cc941220e35719cc1c6cf8e385a8863863872880388389088e309c7f158211c73b88ee741ab1d8671a461f580ab1c560e1c5a787050c08343031e1c6378dee781ac9507470e7000010712703c010715703000fc5a28a0f15eafd70f9082a0d11b676220f8860dde8a7e3a5756d4a3204501e7fbc21ef405d27ae0f84794055116a0e7795e16edad413dd08d39dc308197e6042dc4da30b3a24f629ea6046956ab96c33cf6a238613eeaf2c0d8176bf57c445d84ad9694778515868c7f06d820063aac0d11ecf8d183c562adbc1ed08d1871d88f188b4533f0271e63d1230ef3d80cfee36de4f06a0388b00d247eb4f1046d638a232c26aaaaaa8e38720aea286d10c3017df5e908332616c67b85f9562c23282cb0e5020816b96898bd22dac24c122b6a26057ad4ea49e33908e6803daf2f8ad6ebd57ab53c25cf080a96b0c7aac56ab58c5a2ed7b76ad196165e822c3e1c56192008b672a07c3facb0022c232deab2f96c40b0f5d2c971b9e84b47e7f4540163383d2c0f02691530e6eab90163208e0dbde159c16c28ebd371b128c8638487d2d0c5fa7c86582c106c5110a42d90b66e22f0b2f93e9beffba80d0fd0f7b32a8aad98b810ebfbc0d647592da0cf670512f9a409d18055d8785ecf8fefb55af5f8b4284be7f54d59794e73404f07a43d3c90b27ae440f3796872c0f93e96fbc4b4cbf5ad58ac6fc5ea01f2201608aebef0c2c603592005592c10044116c862816a8a7c7c7c5e2478c3f5234c8f21b1154841230e6319b91c06d2211f209f17359263c40b968d0dcb8605d2cf676504054b0fb0e56ab568185713578b7a8cc562fde09902335005c3ca87e903af7c14a42c5087e5e2a161fcf359c57af8be8f8705027d31acbcd56a459b4cf97c5661c80611abd54b07908d19b13044b195b7c3615e0f140f5a515087c3be1ea75032107ab18fbedef83e8ac3e209c3a11378432c4a8d7846565febd3f97ac2901a617d4394d230fcc162b1a6f8a0184531f2fdb0582c168b0d13c4582c8ae5e5c35a7d3e465f8fd1e7c3a25f0fb562c4a250b084445f93152513db1ff5629f7b01c6c7a24ebf8f05ae562003beeff3becffb28a53f28b85a7dabefbb22c4f1becf410aead06a79200be4a2f5b558dff7b1be6fd5fabeaff57d9f1cacef6bb1582c568b25c4cae359ad56463cf40182e2b55a2d6aa4b55ab5807c82a8cfe7e3d35ac901ba3e10044110044190822008822005bfeffb7ad0ac84f0224aa91b3c0c7d4386b0f156dfe7f91a3455aed60742f1a0d52a8afb185d11be62af1e9607b97a7a8c7c3ee12aa4d4c8ea034d80b302f220162bc87d5854c7a31e0f088a7a7c3f2cca3a0ac3f8c45814e88302bebcd52a67f5d1950b9ee785a18a85d92b4fe7079c149c112312f33428382386f3e540f97e563a4a203562a4275c03430812690152d0e7c7eaeb6179d0e7638445874e80650804b1d547575f48519066e5a373586fe01039200c12c359812b6781617c629ed7628134e61ae2412bfa83e54d88b8cf7745e831d0d56a40f8d12ff662391112e147411e9607b128cecb49c00409a220011a17f298072420c27f5ce90b12033d88f5d9bc1810b25e37397ef4830436c45674489832622b8a839383b3001d1c34e1ab47478e8e520ece0e1d0a087758118a6115e18e4845c863678a1e3c1250410f292ca8208ad0870508087ff870203f5e41807c3150489055ec3544089121de054430b8c0631fc580877a3d3c457a3e234532300245e8c5400d32008f68f0f239f2c5c01f9f55ec85e4c7db0089c73ea00dbc20a06f0c3a40e8c5c098d0f8443824648030c9902b49e22d51f2112d71225c31216aa20993a22646454e8c604e9ec0a03c8902454a140ea4f8140e9a884d398a211d252129255151aa42c54a95252b1d2c79573ac07285094b13539626a72c9f16a7272d504f51505ba2b86c61225c75e1e241172f1e7ce0e5cb07207c01034208606421cc647546ab24ad24bfacbdad76b3b9bd85b152619630a570e6c5e19bc36272598cce5b9f7bead44d51e9765422ecbc114418330209634a20814c0955644ca83ac18432279829838299145000400a6700f0a9706605155858a105165c6821002ebc10802560782106186488410032cc20001a66a8810625c2d5006af06c1800016cf86e20000e37ac72c041871c7c071d0ab0c3c743017ae0c1871e7ef0c181f82108203c2182580d210411437811441851847784112b248ef0d89704125e6ca544125fcc975022897015f3623945433e6f091d252442228e083feac57c3e9f1f5f8f9107093124844e15108cb55820cb83be1e222342cf0b42e7eb212a22043d26dcf38cf08ef090f092f09af098f868921a38fe799fe7b570c6f3bcef5b83873572f82e80e31f0e0f26741a6081173b40b0461b62190b66f011f3346a8c50b3001e70887e48a3c61b3e9e6d0905c230ce819847b178e1feada07c3e1e1aa02120cf89ce84de43c641f0cbf11ea0c762008ee779dff7b97b40e0e0b80750f0267f8ad69f9bae5660b028baa3d1f2f77dfd39f7d98792368737adf4feebf6d3a8edda5cae32d1716b6bd299942828331cce358afbdba6da34edd6f42f7e1cd6f47525e9b574eb334c0d07d9e8c6970a1fd1719731ee7141d7d2b7e56a562ed8897e356bd7d2d75697ffb63149f712cdf46934ffd45ffa19d73eff6d97b7d27b526d29eeb78529456569a263f925d574a4589b95026dfd369b44c7dcecf7493ed5cfe88e46f743d1b17cad9fc439476dd73e8dfe6c4bf1d64774aee27c68ddb5a49a8efaf1a63a579980f2dff6dbf0a6fbcc99f547ffded1e8b52399716de3283a262de56a9ea4ddb9e668bd96ee7b6292acd434cf1afd5b147d5c6d223f07f5ba7e26ef128ed2e57f1395128e7a1c46dae6596b9f7471d3be2746aafd13ceffc1c54da6a5629a158965dd1d8b874dd870f7809cb9e97a7b7d52bc29fd1237a13005d3665398a64c99e264cad0142153804cf9e1394c7f32f0a1302a447f32a01428030acb610a9401f5a1140644c17cf912931c8c117290c58f4f95c1a8b62deac98baf0c06d3175b2dfb8c492d2b7feb33ef7bca7027ce5e8b334ffd7947deb7e5c7bd6cbfde16473bb5145969a6596b325b5050d0eb7acbc9ec364f9c4c26cb057d142ca25c41f1a67f96b4527a4f4a0d308002a8a1608a7c09a354b9e3bb7b29ba7b29d9a6fa1b46c1e2ee3f40bb97f259dd70d3d5ca0d06236dfefbb6fc657d2bdaeabf5f85fc1cd49317375d6c757e2e545152e4df90b4bb7ff1d06805771f8f9268ad96a5fc8cb73e738e7eaef4a7bcd527ffbd16484bd5cf694c5e4c526d6f9bfe131393fe9bae56e8f8e3f3b72d82d574dfcff944a2e3c6f8893e3131d1ad7f572cb4525d6f95eef24f298d74eba7d1bfedfcdaca68f9a59dbab6dec86be9d37de4e6bf45651c6eb4a3c6fdb61953fd53f5d26ba9ae375ac3389bb8aaadac56dfa465593fef5e4af6b65b6f24cee69c2cd737495892bbfff01006e44e6174574af1a6bb975aade1c4012ec3597cca82aeadfb9e1817f4a6547e5cc6e1642b94c18510c5c3221e34ce2f02b55dbb332fa6657d93e24df5b634baef5bd2d66aa7a6e5ef9abd69af8bbb971e36190a8baa0c2d094109bdf5b6a9d66fee6ea5fa71b9ea13dba9cf4ebb3e6de7fa379d475a509322dc71145f8a420e6348795cbd34474f283a8fe49231c9b82488fc1293413f65779db2f94b99aea65965baca6ee4ae34d99319d77010ce864cc6b853d89798a46fd2ea8dac9fef49cbcfbfef5398596ffe7dad69da9a7e5bcdc972f56fb2fd5a4b917f2365fbc45f6272bfa6b2b5cf3999695aa97d7fea65b76d7532a9ec01c0ddab42a14c0aee1e0965aaaacca040c68cbb37a68cbb7782bb47668c092578644a70f748f0c6d8b48a0cb183851934eeee1d8800cb147fd99866452a2de692df342bd2b5369bb3ecfb534a2f55b7be5bb6ae26762a5fead6276d62ec84c34d17db8d999ebcd59a666c6b6bfeb6b72eb66b37e662a72e4692ca15f74fb5bc9fbff64fa5696f4836cbf43647fdae1b6a6b8b25ffc6a7187bb76cd356d9e5df1b63c93826ad73364abfddf7c44736abdf5671f6b3537ef32cff4642d9b8fcd36ebf2531d46ee7ac49e5a74c8ca4f55f1c2e6f7d322b6933deda5ad14fdeafd5b2ecf24f6152dba4ddb67fad79b3e096707942e94dd6bc2f46dae553d7cf513557de9aab3c0df74cfa7f6f8bc361a41bf951a625ef89917664cd24c67d92dde6c94415b55febd8be8fdb55a728ad9fb4e55dcad99bcef8b6cf580e57b7a6d5a3ddb6a6dd5ba05aee1e0b74f756eedee7ee9ebbb7668e14b83b0ae658b366cd9a356bd6ac51e3811d41d07490f3317a18a2e6cb1743fec5131e8a5c98809167c1030748d8a20a0f9c8a2b2e807326e70c6f22072a649600c37d882132f8788115ba0e4faab0010d32ee0250535ac00010b0e22c2469428a32f3e0279c004a04d504463e8213aa31608059c0b59a2b72222079c271162c6dc1ba800baffd60860d178dfa4c86a812c86069c13fe04009ba0000f9866f21a10d1548f0a83be5a4e87abcb8c2af2ce14060e072e15598406181230120e1484e85788c0039073750a0044172e44f9caa8457c4c086177571802a3868428d139da06404272035e0496c38a091a901f27184391e20440a667c032a5e90522543e93f1a4041e29e1eae0102e698a3042430c28d5c1eab2f4178c07ba86c81238384294ea704e141024202fc020fc439c2a8220a1fd2c2075cfe00250fc281344e24b1011138102a1ec482a478c07d3c008c27b528a15b30fb3e1d01c2f00a74c24c816abe701e5d5c4089129070f8ce0f3e2230fb32858b2a8469962815e021990330a143180df88e146e74745140e83a70a0330001c305ae630510358cbcc0798e1a45e028536081aa1c243b6f728348154e0e618e38be38c36f1ca0c119392d3e54ddf400f5883aaa729b33150880074b44f8eb0d165a0841115ff82ba705193d607155b94810a2f000244bd0b8a83ee019c00808d0b85c5ef870ca41cd94960e26151376e4d0b49c3cd933709929ac0d14e172058f31ce3a018513725ab8d0b0848c24d1c1ce195560184dc810430b4f54813588a1c38e1826d0805a2e0f4e4a48e26068010d60304064ca8a0238802047192e61ac6c6040991fb43853b5a26db9917a5a4357421828e9e18703f44b811a2c3ab88d876f0237a87066800c0f9f106c48e0cc000c345f095ec430c48c32fcf3a2230401d040c1ec6392c20f09b373f6f5f8f184c36ecd14cf04407851c314aaf23090e3816c2799e24d41b48117b10d26bc1ebc0f5c5314a8f2ce7c30479014270c79627e7cd08d71a5cafbd265ca122c47428f8a042cf000a80683b784840278f174c6cce3712ae10c1a95175ed8442a031c68000f9e636004cc8d4995ab910304264dc8aa7c0c2a940082891639ff620b0c0930a2829167214512d59305d4a9d800174e78651879134d883184a7a5ca87180241075128e0e43a3479000910350b9fe1234de004151f67e18887324cdcc08497711d893064051e7c042b535ea43ce1e33a056084b89d271c572400739041430e5e63c283924106239fedc0438d15de08fd83333c2a2a6aa2f02d67beac41abf0c29d44708df0050b16f02b5130a9c1880788bc8a94595e8304261ce9450501243471c63910cdc05de08a0e7fd2a584264c200081177d41c68925e220c389ced470e4869b1c3c096e07270b8ce1858f2600f1443411c2375880181d3cd57082ff6c808010c4f18305ae01154e5c51039a13dc4836c1cc65c108efe9c00d0fa080c790d3a4d66e882e0bbfe00b03dc2813a5880f81010423527c013d481844620fe8d1c0812c4981104769ba0f2d1ae04511111db78096002f661b08f10a76c4c143842058701e13e08085a33796f84e1020284981dd719105256bbc1a21f0d0040490b141d7c37700600425eca0a1e33a7230233785180db88e021c608610379e3c670d288268c30584e76c500230644fe538ba015356d834f11b2ca6b2448004a5df14b111b1c11983dba83087084a700002fe82c30711e05c89c25f622680a68808d6b88b0d170604504214eeda6df1441ab013b8eb75844d50ad89b776805541f24410de82f58862c464c7591bc8c0136b5838c1596592fc80033480b384b0c0608ae6c241319676590c2b1c1c404e052b601839a8a50d204168910107431a84a4b921f45505766e5d2c5184af08a0040514e078e02b9a15b80700b1c65742277c51f2a307ffd630d930841948f8370136b42461060eff8650b23519f1c23f3217541942c60dfe79e172850f4e49f8c7448b36c41cac7f3dbce814c1f1807b2610634a097e28710f034a413ca00136f7a6085341014258e25e0f443d7007d8c1bd332b40a14651927b62b8ac50822139ee7d31c104213ca8dca3e20606d248d9b9b7e407d7132ad8dce3d14ca0f161cabdb08b0a42ca18c33d9782c50c104bdc49f00309317a38701f230d921305d871ff029b2957f0e29ec5049608634607ee54b08145911cda706fe20164f0e8c47d0825286e7c2b771d685ef8a2729fa1c72b19e1e1ce02540c60b2acdccbf85072021408e13e4297d3070514e1be73e4b0dd10c51d37f40517ae22dc6b54907152821ddc674558808b5c18f70f4a108ad0e4343194c6b9a66fe6ee4e1e1e4912439f949f4f9bad5d4c525ae94fd51bd594d58618fe73f34aa0e1f6e4062ddc2b4107a327554adcbc12361005ec880b508fcc4f1a2713f821c22303001b8ce038c0cd2333471646432870c6ab72c1a9484a4f149e09517e349931208d77828f344cc8a489c22bc34345c4030ad47866ac0d4bd07031f25090438d1230aca01e00cea049d6fcf0f25688319184522b9e0b47c218e240c9140f06285e42217441e3d1b0c3692c41270bef865a55900eb8303c1ed8b00244c5088c3c22e60863030ee8f0c273228d131239a060f0ac20c11b4882e03cf022a0059a1f27ba2a0f8c149ce1e3010f67786e6c21e288ce89303eb10a2b1ad470459a6fc9076832388006a2f840a02167c4026fdcbe17901051c4043aac7c1170322bc2834e5901f142448f122546ab290578c1a305ca6c8506541a9aa372063cc930c2e0052726583d51682e50e28334ac36c4f048a09aa2777fe562abf543d9f2ac17e3ecd32aedd66cb35d2b75f34fe12af96bfad61c7571d3eec6a4aed5f76fe4b6529fdb45eda87076fa421f23ee9ee3ee373e3d7c42164280c14f664139c2dd3d0f244001267e80f1450ceefe79c93d1df1458f352570f78f081f8a70e231451645eeee0dc101047a7a9082e2e6ee1e07327cc902830a3a50e1ee1e0356642ad0810544b8b9fb0780223d0af0810cb4d8c2dd3d032841731d2a84f0e1eeab3646108213483880002370f70f8b120765b070848513b8fbaa8217bc50630036504101776fdd40c31b9e05602998e2ee1e196dc430668e017ca0c8dd411c662e02dcb6080386fb97f8067d89afbbbb77640677271281f727376871b331ce3a8f34a12ff115ba96e6ee42a8c119552fafaaca84aa9b2af7aa2affaa7c55e52a54390b2cb8dfb88dbb9f715fa1ca6daaaa4ca8aa62a1cabdaa6a85aa133c03203cf0bcd048933baedda52f6bb6e5b66c5db1d86def9208d6acd75251da99b95c4cd79b53d4932ca71f57ef266b0e87916030f24b4c4e2959724a91e5cf51559c14894d5a36ebc65b4655715415475a7d6dde542f7b5d6952942c39a1e477a2aa387ca3703d61f23b69184c8ac4e69194f273399bb786e174d541c9e2218f936ff273c624ddf86a4a6b96526de9dfa2e893992c63d9acfc9bb6d7d668fed2b4e791cea3de16674ddc6fbd73f79e7c6bec846b776997f1aee5ad4c66cd9fcb62565cc64de5ae3ae9f7829b16e0ee57dc1decc06d75531b8662d179dcd7e2dc9271282809f9608ce813a3f38b14287a579dfe6b32bdab39adab89742377cd699ba47535c92efb66b3afabc2dd3ff010031a4c7bd2928c49462541b8766dd09b95d4d766b5beedeaa4f36856b382e0e105398ce37864bf09b4eb671bddb8898e9a9ab59a27695692deb6d551dbb5e53de9e74abf0bccfca9376555df9a374ce7f1a6ebeda6eb8dc81bee3be39ba618ef9bae370a7b9d7fea33752f7f2abffea7ff4c85d4160783e9fb5278c3605a9fbb6ea8276f35ebd1c556e7e702e5ee4b56623c5eb9b4df34ab130e43fdc54d51ee4ea99090d0ef9ab7a69d5a88bc3b1d94cb5517b4ffbea5e1b008414c868476dbe69a2bffa6ebed9e30d8ce38973bb5ec7135d7de5633de1a067b9cddf7cce1101e9cee4a7fd7ada9bb2be94479380448e7b1bcbfa9fe89bb87e0a1102afcb7fe2bcbbfad0c87734d467e4e0b913f25b4847c1a49d6222325342743b4a2225a7d2323263f4454abfdd00f91b526444e6aff4542e4d6671612c283bbc7dc5d5f6c37f9a692c6b926779fc241fed24ee1ec54774d72f72858e8f772f7206b0441836ac8c756a39a624a58b264397a52aaa214d5b4b47454a569e9290a8a4629452165c182654bd393d21295a5a826a5a4251a85a4d4c151162c31a5a724a5a8d89312d3962625232a515b94909a94b66851828a5282226d7edcd9e4c424b6f4381b8514b5e57136aa7c11ac59f3dfaff226cd6acbc5766dde504e4c47417ab8fb17da9465292a86b484c5c92906e40cf72f146989ca12929213545094074a514d59908044e08af23779e69fb2dbe26cce012102481021901cdcfdc78782f94295a2625c969e9c1e67a37ed7242af74dd97d53f6bfdfcce1307997cc4ada8b6f252f6e622a6d16772f2a2d2e6d16dbb5f9cb9c653f5496fc5359f297f59fbec44cb61af534dcd964ab51eedee4dd9dc9ef1dedeaf095ba5b6c35ca76edb515f7d9dd85ca2f31f965ddd5dd898c6a7b8bbb8fb6baff342b17775f72b1dd56e39cbb2b49e2eee5b5523f427717bab8c9ddc7a0c761285f4d0940081b511039c8c5b54309a50deec2401537ac983272af0cbe19c0121470971b3c2c8d300a59e36b44e0ac1a58285aa2c600f7a810d70ea008ff704f96e860e7e3ac1a560d58a20113677d6044d20898a8fb8f0b090b1b487197e2428b2d6a80e15e03c8c0e044cb8cbb801c81450f736471d0660133c81630e5ae14b280018438d6784b0b4e8d92c51a7757fd36151ef817022b63970a38714781115560a6a4c1a24dba18038a35ee728205c90394299c65860f330fcd8f7b44f83ca9e056e12b262d7878a1fac1bf29381d1c805be32dddc203a6ec74be9240129a55d593af9c9ca6907440046fe13083064e90c08b7f5128b102ce41c45d28d0204415961ddcb546083954913373ff2288395ef8a183b7841ce940070f4c38d0b559b3be0856ef13ef2a160ec29dedaea66ae62e9ccb4107a378eee2c12b59a2e7f21d1ecb024f87f7520216f96a06f002d7f77ab1c095e7b98f6ff4cf3d2d20079ebb9eb07c47cb73cff3582ca20fe773cff3569f15cf73799fe7ad5a227cdee7b93e0b9e3cafe5b9fcf374c6d5d76af9dc500ffc3e10060ff4bcefc66be3f36c9ce581dfea3d2fcce779df6bcb27e4f3be16f87921f83caff5795a3c1f9eb7fa5e0d60ad5c3a3c0b3caf82d7cad3c1fbbcd6e779df4ae67de08d0dd197e34979792c23ab289eebfbc024ab9beff37e7634f1460093e05059397d0efa178407ae7c40d6e7ad9c45833786e79f8761e89e7ba0f7796a78af0f89e77dacef5b79de124fc87b7939dff77d2d24efc8f7819f37b41a7180bc34f07476827c03f0581f100ff4569e7f4e1fbdf140ff6ccbe9cc7361e53c0df07c0a16dfca6b79a0cbd3f156367cdf0bb6f28c56def781f4cbb1f1f1589ee71a02936030e47d37add7e7f23c98f77d1b58b53c9b0f5c4d793ddfe979ab20cf06e7f35e2eef9bf25df05df01159f9cabd1d5eebfb3c1d305c811f90effbbc9607d63c1b231e0eebf3589e8e2221df920bc7e6f368af1cd7e769f15e9eb7fa3cd0b3e211f99c7c433e9ccff5b1bc95f7791fcee702bd156be50543421f3a3a3d425146868bb212b8285be3e26c878bb31f2ece885c9c39b9389bb938d3b9380b808bb302b83863c2c5191a1767127071c60117676a5c9ca5c0c56a818bb5888b55898b758a8bf58a8bb58b8b9574b16a176b0a2ed6195cac44b8589970b1a2213244489070274890ef0499e23b41b804a9b9fbcb46c78d8e17d0452f392e7af9e1a297222e7a0172d10bcc452f4a2e7a6972d18b072e7aa9b9e885ca452f29b8e8e50517bd10c0452f45b8e8050acfd90152e53b4074be03a405df013283ef00e9c1778024e1ee3a383b3b7038e3210e34788803101ee280000f7170000e5e7888431a0f7108818739b88739ec789843110f7320f230072477b7e0a54347c7cd6b473cc377c414f8ce8e10dfd929e23b3b3fbeb353e43b3b567c67678befecd07c67e7face4e09beb3d382efece0e03b3b41f8cece12beb32385efec2cc077762010eee84143141ed2e0000f69c88087348ce1210d6b7848031c1ed6c0f2b0061e1ed650c4c31a843cace1098e0d8f9d1c23dfc9a9e23b394fbe93637d2727fb4e8e19dfc91980efe420b1c3fdc78d0e1e54f4e10a226a4972510b948b5a4c17b59871518b005cd4a2838b5a9a70518b025cd4420117b594e1a296375c7ceae1e213918b4f4a2e3e7171f1e9baf884828b4f33b8f834848b4f50b8f874858b4f5db8f8f4858b4f1e70f129042e42b180fca88085325c64210e175bd871b105212eb630e4ee366278d3bac9e942878b5dfc70b18b222e7641e46217555ceca28b8b5d8071b10b9b8b5d8871b18b115cece28c8b5d04c0c52e04e062173ab8d8c5102e76f1848b5d38c0dd71c257053b3b3a628e4e8886150fd180f2100dd24334b68768a0e0211a347888c60e1ea2818487683ce1211a5a788806181ea231020fd158e3611a403c4c63030fd328f2308d240fd370f2308d99876988f1300d321ea6c1828769d8e0611a41789846123737e08e1cf10411b87842095c3c01052e9671b95886878b658ab85826c8c532442e963172b10c928b659e5c2c535d2c835d2ca373b14c1917cbb4e0621902b858c687968f17a8f0f0050778f8c2161ebe90c6c317d670771d3d6e76585e7c8765f31d96f61d16007c872583efb076f01d16112f177a78e802110f5df0f1d085200f5d60e212b7b8e2e216d5c52d762e6e11838b5bd8e0e21641b8b845133a3737ad1c7104352e8e00878b633e17c7ec70718c0f17c7f0b83806c8c5314d5c1c93e4e2982617c740b938c68b8b63662e8e315d1c73bae3d8bc76a060e03b5090f80e1426be0325e63b503af01d285b7c070a18df81f2ee9ec3c383c4a07818b3e261ac8b87b1301ec600e061ac079b1cb101402e3680898b0d90e26203aab8d8002d2e36008cbbbf5eee363a44295070510a175c9462002e4a510017a510c245299670518a2a5c94620b77efe13f2a403dac00918715e8c0c30ad05e2b8400063a81266a8490a8d2dc3059c08f9a963339f8f0717777cd016483bbfb8e009039e3ee3e840511d2ac59f317ffd7644a5e15544c910029bc6789300ad77934cd271100841705029e78e2092928b2701b28c078d0dbbc83b874a1a3edce92b22c3d2939c994aac49eb24441c9a2b06c8951514a82c1727a0645df56a5ee792369f974dcd12815a48d9bcad7fdfda7ba6bd2efba93cadfb8a98673c58271d4a6fa7d3152598f5c8c15039c711f67abf9960bd25e020c50827b5036cd7a84136fb048276208aa4eff547070e215549af646864d04e167d0d6b5f6fba4d9bc77accab479e8ee3226d494f8dec0040c486552f91b731162d49a56690d676ca7eaed69f4379eda3a67fe6dfcd9d17cca5c6b146baae968bb16db2ea6e34dd75b8c8eb7df980bc6517a772b1314b08912403ce58b60931841120a4802091f7f7ce88f0fd57d936f20092cf507210f930091c000121170172a4205891328d535a764c9d2eb5a0ddb5e23f1b27da6478441614fd69c3ec201eef4c17ca1528228982ff4733bbce9085ccd1141c4d027f74d992c4a141a8587de376532234e30a274f73781a8b6541bf1b9eb46fd9a6a7be2923eade633661bffbea675679a95ea53dfbfaff18da4f9c45ee8a8f5b96baeb95c4582a4eafe888e9a8a036d8b10f1fa4244263384156f8c33caef04429c719caeba7de456a41b1d6d9646f1aeb67c1cce527de44d5a8dca475493d8bc5f969696718d6a4bafc566ad7c3deafcfb7135d71cdddd8ad35b6c43667dadaf7d7dca64667d0dd31ac774e44869beadd1bf6d5cc6356d561a366db47c6d29dd991796c3597a71d67d6eb7ebc5b7f699ea2bdd6133f7a5ae369dc7cf35f7390783e9f0b087325f62a4f16963a67f23a9e829e69f70ed2ee174d5c1606f9e2566c2e9dac5490b1e8c0c50001378a9c10ca7ae9fb7b7410188dc33093b5c2067964a36ab754f5599469df1262b95aa6449794f9a3f77a464c9eea5663f3f148802f9f8d4f006944867d6b2acf4568ac9f29bb45963b849f754308eca5fe62cb52cfbcca2df66bceb52fef23e958d9b1e67a374180bc6510b88000e2f57c2d96a22c51e57c93f0af34fbba5376d0d0349e58abb91f78fe898df29a9ee9a34669cb33b7fee5a264a55cdaa318e665cabb4fc769c5d3ba3aa4c33fd3a6ce6cfe54e6a566cbf466d75df27f3e7e8ae4ed726e56878d35dae96b4b5bf4fc3367f8eeeaa3992d534fff6b7a829c6f2cbdfd18d6f4977369374fcb2e234dd35d1ec74972ed6f59fee16a47f7a2a4e4e9fcf5d719f9d76d54ae9706c9a066848a26599818c7a8ae12242d10c4453ae8305dcbd04016cffa41040e841210313ee3a94e18cbb8fe6b87ba90de8ac5cfa2b33fab7dd4b5d1dae7a26bb78762373fd6bf5a92dad371d2d77eea57e4aef5e4a1fd15d5e53dbadb79bdda4c5e18bc937f3974bbfab25b1d631dcb4fb2b7af75770d391f085ecb69b6f32a7e285efbe08f83315aa2fef520070eeeec2085c9861bc27ce9d52189bf46f51b18d9bf25f5d968d9b5e6fb94b1b37edfbb7e2f23bf5f0705a00c2dd6b184f27ca9701c0177a9f4f28d3ac485a7f2ecb98cbe1b3f37d2e2fa80a095fc28211cf8a15b058817a73783f4c48e107ef042e0498c0a4822f881745dc9dc943326276e009cfa8f11d15ceb91d6766d079a491e0eebbbf62cbb12b4e001881cee3eea58478f67ddcc50e819cced92d02a0072e4fed1545e1a6b5091d200510dc69d50be241e122582d82d594fe94dd41543b482827a3da55a6fbfb39056688c0e9aa23c778688647ccc657f7170663b2b979f2b4f1cdb3c43819add63ee746f2a97eeabe8c6a07bd2dd71b12aedd258d9d6edb76c93867a5ac24954529eae97fe3a9d2c432b36a5bca64af710ee7dc3d339695b9eaea2edb1cd5cb76b2d28410689bd54964b25c95e92a339fbc95a495517e69a768eefec3dde570f72cee1dc0ddbdf2e9cebc5d4ba38672756b9cddbb97ca670e67ab49fee75afeda8bf09f6bdae284486d7125249570848434db0b220c770aa871b754ee4454b80709c15d47c8033d9c2f4410a3830d170fc7784182061437e93c925fe26bf3f642afc7aec434fd4487cda751d9b57a6b6c45ffb53b87fb6b83e89fd7ee8b49fa64b773b820bacbfb3ecd616cd28bddc930c3dd87689428b403236cd179cc7fef99938c433058fefd391725ca58335fbb7b30fc7801f40260d2ea3e71ee9e0b345a4b0884225819afcd591d9a703747a5b82a76402cb14b9231fdfc53621c257d28addc36eb38e04e3ca4327f9f544b5419bc08f65a9c2e8cddb6a6d54de1ee473cd4cd4033aee9a0cf3937743aa478380543fe6b71e114964c472ae114f8fbcce130199e599c30c0f699dbe76ddbf0c41285d2b1fc6c4f3164a5b5b367cf41cb3769f53ea53b8c4dc5487321ec5b19f43947a376583fb35208676148c9994217a1612029108549a114262b479ba5e9253da4fc325752db9202510e804c327320cc298cb66b6fba9a9a0295f7c435aaf3088389a180bb0f7928c6875dcde69fa278973785c9caf277ae1bca842abf0c736ae8d717e7f4677a6d7e27aaca14f526ad72b15daaca346afa5275eff6b5414f5e0ca4f7f91b4f51dbddbba0fc4e6599abee88eaa7af51f356fb7c5e5b6d957ea678c360b32ff4fe943e546f186cf685d69668d55495a96add5fa02cbabf663dc53ccd585baaef53d9d6274e464fbc3be98977b4b644476db505ba4b74d457874baa3759f359526d6fa5c553555345e5bf96e969d44772b8dffb75ae9a4f3513ba757db33e0e88c99b395ca5aa7f8b2a4d7cd39f6f514723544ffebd9fd64375bdb6f6e514ce395c7d5d6f495f947136a3d54ed1fd1a898e6fd2acae5f2be9d36cddfbc891fc37f235dd996625ed2d57b30defdc2e93b4ee23f7c926bf56ab3463bac9cfe19b5f9f41789f95de5cc5ed5e0af61b5f4a85755174bcf8a4b66bdfb4371d9de959141df5dd42c75d29ce34cb5bc35f31b9ab398a3f1f79dd6f7b8ad15074ac7457d376ada6f5efec5a3a9b7d9efd0001f9cc806274fcfcb7b2fed677898e3a6c6a9bab4c3aff14a6dbeeaae9cecce1acde96026d5d73f4c97e4dcbaf541fd9f5b681663f3ef7cd71465f9ffb48173a0e01dd2c74dcf5c949abb634f7a4b65d8bc39b3e8de24df5e53df1d3ec0bd5968299cdbee89d79b3bc2dd75d7eb6fa934cb392b4bc95a4e3c5b9f3fc530c05ca1848cf28ae7ede3a77d25be9aeff64263f3f8eb45be36babb6a4362013e34d6b65d097e6597b7de65fa23b3357a52eb68bb354fd2e9f9d4cf3a4f2e79f5a9276d569e37b2b92d67fb7ed72234f268ca3a06a56b25d9cbb986645d2911bdf74ae5e28dbb55a5b268ba39de5ebb069c6366e32cd4a6586048ed27d9502c0c26cc954107931ed6ec9556762ec443ba1f643e5306eca65d16fe2271363a7fcf72e99183b955fe6aafba7ff4ca5bcf82848489b18e7645756c4dd7375e3ab7154b9a4dfc64c249d5faa6e285db352b984a3cad7b5cf4eba66a55a96adef92be18a966a5bb74d3d584cab896e5499b9d70bf9732a6a243305f5c6b96f54b0a547ea61bd3fc5219ebb014894da120770ff2108c096688decf61301f086c80c001770aabbb96753f8e0251204f05af052077cf04ad71eeca721aea6302fb86dcdd8b8720d8b8eb208d735748ef70b833a944dafd95fdfa9f742e577550faa9fcb2fc1975cd5220f2b9d0f281cafad98c6ddca4f56fcc0587f7ad3727d94fe92a1ba01ce10708f88008779fe2432fb696eed8aec4347acf1a0dbab8c9abc20f2c70f29e3526e3505090c5e9aafbf1d9ed1cee65da8e5264dde3a62af5e36a9396959fe57118aac4b88a69c6ca9fb24ffe53e885ee6836363637e5d32ff46f5136363637509cb68c5a9b39a08c6bdb6aac6b19db9c8b518fc9582bd578974b5c6652a432d6ed6f2abfbc273e82f2a7989acb923f97abb9cb8ce27ddb676c46cb5bebeb2850c654e858e9eb59fe5d8bcd3e9f24599fa65fe3dba6ba52a0197eda54df34fb5d7176eba75a7fb6e19cab74bf8de24d4d5b6bb4a4ed72d5fac98d2fcdbfab49ffb6819e3c4b9c73b6ea28ad5fdad22c4b8bdb9937db896ba7d5f47537b2daaebdd7da3e46475aded7146f2a85a93eb22dbd91f6a6a3f9776df757ac94bf2b69cddc9984e361d400a27451d89dc27c288551dbb54f140c857d110a1acb2fff2f7d1add55dcd66798b2d2181defeea5e8678cd3b66b6fae5dbec44d4bb67a0475a604a81c42dda066545bdd5f0a446d9546f1be96525a3e982f3487180aa0868271f75a70f758f054f0ce3ccde1ee545b2cda568fe8135ba595b6746f044f51dc7d2c5f0c1d6d954677556756baf589bb3f656d5b5baaff12d37490b6559ab6260cb6b53565da5669b2500b07dcb4b5b4f8a6a395da2e696dd8a4ee4ee5a11610f49f5adb1bf99beefababe99a34fee3fedf33965f5fdda97b4326182d5d21264ccb852a730ac1494131a77ff1a7d6262ca389c530e7ed3678e3e313189c185061e308ef93535eb7971497514e3306ed76ca92dd04c8ad109857c2e359cb1a69feb0e67b159ebef9a1f775e253a6e6c6afa38bb6979ad548c8e7a679cfbbc7b29aacb8cc9cf949626bee593ee72c5d99cb35d6bd66a1836654f310f7b5aa555006480bb931e4a796ac279c8e484dbd8d8dc8c363636373f423a484893b80cbab6e284b01d474de2524808a6737bdf7cc0e82f1487b73e916c6c6c6e64b251976f9a1569772b13c6519576ea5dce2c31ce44da412643132770318be2b5a23796c0506584a2260f9dc8b0883263de00983061019fa6ffbc946f9af68aee9bcadfb5cc6df9122369fd2479425dc9c07dec000519e7acb4e4610740b8fbb8a3d1a7d15b499a3f47f7ad36d729fa1723996645723262020535da4ab754c551bc69fe32637aed896995eaf095da965eaceb3fd191fc9cae26f925ddedfc399c73b467575cc6548c9868dd435633f7595b6ac4040a8a96bfebb559fde5a88fecaf426949e34be1a96be9ad24d575d712df74b5b275b6b5adbf34b10fcdfd4be128131d7127ce5255dca8b5ae340ad31ad02b7ca4175bfab7d9e7dbc6b5bb14dbf8d29aa53fa50f7d6d562a749c295972cea8b67436a3bbde36c59a96678ea263f9f773b97aa3e7d6b586e96c369b7dc61b8a8e5b63933e0d47f579db369bcd9b3e8d9aa6d5515bb31b5f8aa9feee8bc99abd7fdb74f6faa4afa3354b5f9f957c1a9dfd507d79978060b0289f19fddc6ed37adbfaf36f6bdec8fdb51ac6694b6dd74a9135efb77953fdb6fb536f5a930cda379b35a9d661d3ac54db5b141df17d129bf46d95b45bdb6b71f9f797a6190b578765b8fa5bb65fcb642fc3e5a9c5ec828725b744312110438628a614f3843940613f35a5bf335e1f10718ebb2ba1484a13e72a798af95246fe9490f65ef8bce4bc38e2fe49e02ab96f8b532a31d2d23be17e5b3a56303318ac66fe43d1516b4bf749a3d79eb65cb1e05dee44a8e498b3b129af54cd6fbb18cbb63636f8a62b6f2d1f77dad0efa269362a574ab1aeafabcddbb4b5963bf5b6f6da6de96c47abd1ad31d216b6eadd54fddb94121dcb92ea4a6b56a73f8916d1389395de1387c364d54d615aa51b5f3a96bb343fef4c2b423569f9fbcdba2b2d2fd171091de9a8848e48744c4261356c4d13933f4f5e7c295069653e375d6f96becd9b522448487bf1c617e39020a1556fa01d8dfe6d9bf55a9bb555b35631cd8a83aad5cea37de66e3bf749a65962a42f31924e2aa3f69bf6d625632afbccdd25a827d2e67094d2b5f586849b4cf3a4929431d25d2aa38ca84431d94eda27956fef273d796bdef7cf7aa352da1667b1ecfc53ff7497c6a0cf3224d76314121a4537a0982ee1ad31be91b4ac345a4fa09d69c713ef6805dae7111d3d8831c1604d929cf5f3b64d929c545b1caed666651d957c316eaba9d051ef74c6f93fd0549569e3a6376975e7f26fe4894dd36ea81d15cee52795d7e20e76a619d37d13aedc0ff5e6f9a4fba62e11e8c2c4c58d25d3ac485495699c5155a6d99b38e7cf69aaca649ab111cbd3165aa919baba6bb6d18bafc6fd97678ddedf516aa3f8a6fbdc6ee39deddff47d1cddddfae689f74f05fdc5d4acb67e50fedcb9f357f26be69969d2121285a2e2b4b4dfcbc64d3bd37cb25d5b2ad55d7395ab63e56f6db16cdca471bf97ccbcc5767f5b4dfb2ee58dedaa99d336a9c4b84a979bae56dea455bc9fcbc64db17a64bbf6fe94adb27153d393ce4f83884e1470c2c2c90ad1e9004e41884e40388d426140b4e695e194e41fbeaec99f326d4def6b6b5632eb59da29bba54cfa7878728011b35bf29e98fee2268c9f9c3c3756529e54053c046207aba52786942859a2ab4fe512d59757ebc72200bcdf5e5bde4ad3b67cf3dcf771b7caaec56176a65965bfebd49bffa4ddf8caf67d9ceca7acedb3dd52a4952acb2ad32736cfdc99497dcfb26233777e8949d3aca4aee5ef1b79e2299cade50b097959f0c690103b7811820086b20c93c8c8156478f192c6dd573a579c33775f5d40e5f396086854a102549859d02447142d2531a85a491c54dd88415e8460c498c921012bb45c85850e0cee5e1099fb1702980f0423d18a189d472128f2a764e5c3609f3129cb69a95c10ee06d5f29458850cf7efcb0b5e9a0fbc78f075f9b8b8fbce7a678854ae70779dc71c2e7285ea8b4d133b5524291263d9d6cc4195b996b76ea8df780a069371d992a4757512937444241744a4a224aaca34eeee9333faaff3efccfc5398de4a81b0366374acd5b08931d2182445d61cb575a5328e3b73df273fd37aa3d5762d05caddaac36128bc2feec4587e632ea369ebbe4f75b6625e5ff3ac690d54c33be3dbd36af8b18c6535ebcfaee17d1fb7c97a95c68a4dbcabfaa7ccd7b8bfed29bccdbdad492b7ddad20446f3d4a6b9edcfb63e7a8ae21cce4e4e331a4433a64f6633255dbb945b572c331a4461fb7158b775f97febb67fd3edcc52b7b3d570c6a4d604a81a233f7931b9b48fdc99121d69f7a4f71655ab54a540f43fd7be56f5eea528d0d7ea54141def163afef8e830962326282bb8a97cbc9f0beefc8b9b366ec24ddf943f97db62bb387779d24ea5d04b551a853d65797a52a2484b55b260d1e57d9ba938e1b5c0840c77a7957a669830e1f92032a1721f77884ca08ca5a5e9884473e0fcb9dc8fb8484445d21a221094b84844dd475bcee0640cdee2c5c50d606711387c8002359ec64712fb16a21206f82c6a466b67eee24e5d6ad3d6fd49356f2a25b39a6f052a3feed41723e576aff5934acf830ae28fa954774dc2b51b8583192949a2c3d72693ddf6cbf096555d92ffb6aaf5e364b693f6a59192244a5eaa9a34a94a922fd584891299927ad3b29baeb7276f95edd732bc652ffb8bb7a6e1f0d6e1f2b36cd7de94e96afbafc9f096ed9bcdbeae6299b632d9d5e19bae3799b6d9acaff799bbf677ddd56ed3ac3625667d9dc4acab28442053e7f149f9629ee81367b2e2e80cccd47dd99722b39b9cfe9d619f7341bb52b6db7667cc24139150e12fdb6d9b71988a93c9b6ae35b3de8cf74fe1cedfd5f6e697f7d45b5b538aac264de6791f8ffbb883e0e29137968c4a928c4341578733eda6ebcd027b3582149aaba44cf7d71b722f26664085bb5746ce4a337a8f84a399eb538ca340206ac085fb78b1d5a7495ebb6ded4247ba2bdd57d4c0080d78a074a741d5b559adc1cc5dd4c0c8dd450d76dc8dc62441e44f9966c569318359064614c8dd5b2e66e043cc20c7c81cee0e44a94a0ba39534e3702e178d84e114a6716f7ef95f9ad8caae8fcb8fcb1fa5fb262e195f9bee9e99aa32514d475cfea8f14b4caf05c2f94530cd9a7ba99adba273a76cc4fbc7a7bcf8c876edc65c46fd1b4f9176df6ab3365a77b4ba77ddd5f2e223a47147ea237f73a73e127480714675a54a546250b9f33449aaa740e5c5e443d1b1e24ead2bdd99db92f76f2533a6650efa916dfd3459c5b92d74fcd9da874add9a736790a634466177898ee5ffc65c70d3ee5626fd1b73d1612cd509476dc9475b9f4cb92d4f4875d7a4df98cbb54fe2902cc4214cb88f60be50994c1c8254fe99b740fd99a5b4d5a9441282852b45e97ded587e06434eee9b95866daef7494da1e89804a6ab619db18e3ead029d5a5bd95012ba35c6d1bd8792e0bda3d53069f7e36edbe659fe9959f5adb3fb393ca3b7da5d7310de417a2c2d3d62620c4ad9f2a76cfeb2b4d45a4b8fc44cb3e69f52a29d9afe8d02d5dc89b38ddec8aa44c7dc897395af3d0e9354dbfa64cdbafc396cea2fcf7b8e26c63d8fab3629dd436bf8cc659c4d8c73380cde26363176c251da76b1f9473bd33ca9ec6e0c1f4969fbb471d3c64db66b77386ffd49394bdeb8e97e2ecbc64d5a5355a6b7dd7a2bd24f552b1b37e9c7494a493b53eb37f33b55bb7375422abf2c632355652233fe146e5756243a8e74e3a6b734729ce9f09dcd92d00da89e0599f54baa93222b8db630eaba504d9d5edf6cd60ac651e597a749be49de2d4f92a73e731aa8fcfc3977d7f1c8f880eb74eeaee4ee11f1395ac3f4f5e7b28cd9ae2d317995caa5fcef4413738c728af889ffe29c9576db9af5d4a2c3587ed7a412e32a5787ef953769758b8e5155266d2bcf0ea82ad3c576d7a76d71164b69bea50283ed70ed2e5dc0bde8b1637f3ee428815781cf480aa23802538457c3cd8a1e2b7820031e2b42308128f643957fe57629bffc9c549a59ca2f6d75aa59497c69e1ee321955c56da1aa4cf9a576b72ad1f1a7ea0dcc175a67b66b67d91ac95ffba4fb53dbde13d37d62a09d59b37488e20db4a3d15d6ff868fc9a95f23be951876f9ace76eeccb42ab35d4b9ee5e719fd4a9f6649a819f95cca9ffd6c9631ae6adbadfdbe35d7d336bbeddc97b2202a85cec61f97aaf9e54ccbca1ff3dbcac70235a34033aa2fcdba7194ded7c2664034887e99594c858e3b7aed98f1e7988c3f3324549569e6437f664832a632f3a1fabeeeefd03834164d69bbefefcc7a2bb5edda7246e2fbd987eadca969add5309899ee2f0c96df566f6522ef4ed36b75a59d9896b6e66ee489d3959ae6ebea4d3fd151df9ad374ac396ffd379bbdd5fc407a06863e91d9ae7dd9971985697d32d18262f59e3f3e54e34e325bb2ccb8ee68b4ea6ebaceccf2d65b26f363a6a1a1da121d1f97bb7de4d6ac54f3436121fba3675787674d3e74d4d966697496df29e3a81998d9ec4b352dce6a3ae6af2d95745baa976efabef92595324f1ad561d3dcd12ad53847a544c719989a95806810ad59e9cb8ce6ff817dcd4f6756a29c9492645e9eb244412d59998d60661a067bb2d6f2ef2ff9e9583e59f3e7ba2d05ca785b0da5c337a09a9f966fd6fc3b303318cc342bd2eccbce2c7f77ebcedcba62a1637e5cc6545b186c46afc59f31131d731547b59dfdf88c3f3e7af75230d8cc9a399ceeb30dfa4c77401bdf5aed4b4ccb16e86737dbbd946c36f536efcfda666b3fd75c5a3033aafab76dd26ad0c537577137bd3381b22df76b8bc3e4c89cfb795abdb7ea7cae74a16399abed33c5b56b7be84ff9a70fbe14a8b65471b61587c3e4d32ea6e99e1e5abe6956bdff6efda4cd5b7fa6f9c4359d0f35eb8d3e79f3e77ea7ebd3cf47767fdb9a92cf65898e527467d22c494bbdbb313ae2ecc524d5fbd69c1d6fba6ea88d9b8eb2ad4e171fe9cf98093749ddf386244562f36ec14d547054cd4ab52ce58d416ddc74dbb94fdae95b7350b66b97be1e95f5c834ed0d496ba41da2c13ae38d6b29d57f061a7a4655d6569f0175869433a09861821faa2d50f93ef43735a30a3372a035bf19db8c29666c60061133723405d259e3dca5b4fc0d822940d082ebf0a59a4661b319bd5689cb1254931215a5a4b17e2e57631778088271acf9a16a7ed96b58195a5051861265cc8037fda1d7d26b6906e60f0fcb3075191c543347a3902187b364cc408600dc69143214400d05f3e5068b6fc903bed50616a020021068a08a3044f02b7a946002d896d21381980fc75c838b18b450830b2118101ae2bd207073772c4b3bb2da1e8bf6606e029dc7a0a08b4d0fc5f02f314e3ffed24e6d2757e3815b7805b4d8c0e3e113f0882ef00037c3cbc019303ace4330a090dd6ae66460fc70778f7a4b55996a98aa32d1c7d9a8f167b773b8af9bce481a4493cc7ce88c9cd16dbfd27476cae66d5a5aa5e1a7291dc58eea789652a4cd34ac292e631ae776e6d6d5047a9cdd77fc793d9b51bc4fbcf301ba38bf083b6d6f7f6aa1e3c5f4d637cb5b6bdef7b7a53a6c858eb9936e7c81a4347dda8d7cf25a283afee84cc378d3abebf8a3f5a1e553d91ad5554777399cf73531ee326b4a12d434a33b13a87c2dbb78f69a6afb43e5890bad741fb9b8f431cd1cdde55a5e4cbea65abf794ffaa479e6708e3e4ddbfb9f3f476b96ce1e87a16654ffec72cd3887fb283aeeaa14b6fdbeb6cea066411e64e91245c7d9d08ce27dab69d68bf5dfc8faf966a1e3cc4a549526252cb2a82625a62a4a50b2a62c4b51485b9ea2a09ab220c99e94929ab6e44e5ac3d706e52fefd9656b5babe1a02f6bdeb4d297aab88b2d6d22eb7daaad3573b94a475dbea9c3572ae85a4c06557a234f4df56b9ccb676e97abce3f55566d2b694dda99a3fa27e862fadabced97b2a60fd5f6b3aed476b1997fea75f84681b48949bc71ced16bbdc49870f937dd19dfb43eb125ad5971b492f74fb376aded5a9386ab369a712d2a4b138d82dac274920f458bd01109926cda7d4f3a54feced479d7abcbf2c5f01d61e9cc34add48c664c672f55f7ec46e29cd24780717fadea9bae99a4444d4e5ab3f4c95f4cd4e4bc9138f72ba92caa9800cf6c637363535fa5a7d5239d475aa5790165bc56e8d20c6e0850e1ae67d44966bb7647d6d296b792b227ef89efe729d997b25bdf24711859696526c639d9ef3771969517d3eac5b4f24f99aee6f2b6adeeff7f5773b2fd78bfb63299aef965f8ea376935ff35cfa96b65fbb5ace697e9fecacacff96b5fcaca8b699f6fba6e2dcbd5cf52a495d2329969da1b89c3a4ec5a9c6c67e672350246221024022fba7ba9f2a730131721e0228b17c1227151e5eeb66bafc597c2fe9e19c685c94554adbe49f16ee2a2888b0cdc9dee5e6a579aeb9b483a8f19870bb798dac26e11e5f4a6eb4db6efe79aa354e31c85edd7b98a93d9aebd67ce651caeac32fd26794fd97e9dc5e97ea58d33677c60c226c783591a16a248410a6e3e8454d0c3bae361a51ed6261e56260f2b081e56ec612de36125808795080feb023cac1c0022a651e4621a486980e0621a615c4c63bbfb4db86347f8c4ccc327c278f804091e3e0183874f14c0c3278cf0f0890478f8c21a1e3e8185874f7ce1e1136578f884093c3c802706c1710de1808b43d47071c81a1789ec7091088f8b4490b84824c945224f2e1209c14522d8452227b848c4051789e4e02211215c249200178960e1229108ecd0218e61c6c5316470718c1c5c1c430817d30071710c03b83846152e8e81c5cb25fee02efef072f1071e2efed0e3e20f485cfca1c8c51facb8f8c316177fa8fd70baf80309eeae73a4021dae1c20e2ceccc51d9c8b3b542eee14c0c51d225cdca9c2c51d0ab8b8f301177748e0e20e1c2ef270177954e0220f1e17798c2ef280b9c8e38a8b3c40709107ce451e23b8c86306177900e1220f285ce491051031bce262287331a472771d56887cc7ca91ef5861f21d2b5c7cc74ae93b56c4b8bb8ef08b91875fa878f8258bbbf31095d81e2a01000f95b8c143258cf05009273c54e20a0f959880874a6cc04325d2f0500939dcfd95138a3aca7051c7085cdce1b9b843c7c51d405cdca1818b3b9ab8bb053f441cb68b38ace0220e3bb88803142ee2e0007767f9d849dabe93b4f39d24169272707642f0c07742a8be1302ce7742d0f94e0825f84e082af84e0835f84e083cf84e0840f84e0848f84e0850dcd8bc5ca22836b9808b4dca70b189085c6c22878b45372e16edb85854c4c5a220178b602e165d71b10804178b6e2e16e55c2c1ac1c5a2165c2c22808b453fb858a4848b450a70b188022e167dc0c522365c34f27604a8c4a804f06da5999a744c213333321009000000931200304024180bc70312c16c9e86ab0314800372a67290521d8aa32849415219c20c0100000000000020981a02a5295a29c7c8d19282f33e01009b2b0265b1c6599152c7f19b177053c43555c0be14b1bf9c5fad8f1a6dea9b6020874aa802915f6811ad2cc131fe698eb2978a280d50a1ef92c4c70a46efe9525d1ac4e81034e235d5337003df3edf50b9ecdfb7fc52a17fd7f4086af45247e6af2f529cfe8e3149cd0db26bd903b6e488f4226b19e01250a3e9a2110a17132954b2729741f1642cb47251420a7add4522169a8e46a998080f4d3c70dbf53a0f36dd9ed1c8f0df14b9ebe397d2791b889d13924dd5ccfa3023e766edd6e5f676fa397900b4def30b070fc2477525eed178d3873c083c285cff25a8309d66ea8a70a0cda27360f908165e7a25aea728e39205ebc3182a9f66d740cdc774053a8fc169e04bd9730ba7ae045646414bb46fa4aab1c482844d99f544e36a4259f867339763fe05898bb9a20a5658329e25a8d15c75f9d01add8f8653879714a8aad6362c8b67c86edf38147d9b817573d83271a1192d830a836cba0e6fdba0230b64a236790111a66f81a5c10025160bf3b1c71baafe84642c27f24d5aa5b18e4a0d42349f848a78a8c5202d01ccbbc8193300d990b5dc5ef3a30dc7d2f8c94a8fb15806e435a5310fe768b2f226898bc334e1510b7a2d8832e01c3ad6a8577600183ffc3dc1aea0c6f80a6ea843ac6c2739af045a022eb631c4714cee200558fa4f71291f4ddc0f7c327e2b8899b4e1cdb3329b898df6cd3ab645eba7a92d95ec51ede37df57e99b801ed5c31978614f484bdf085cf2f9379c6af1120197c6cb5b66bd50fa4cc28e8bc48e48d19411a1545469298215a4902f6e8280b71a16f6ca743e3034371caff99d6ba142902ea7ea1086f52c049b0fc08ee310b25951c59f3b14f485ccc16fa5ff90fd808deeb3a1a08e59eac455db4ab051a1e400c887887a0bfb39a36a4e01da402a3c3a68f6a2efb681b4cecb44ec43a9ebffccc0595e83e47958328886dd0ee15aacd5d04cdba3deaab3a039a5dc52f0f519ce93515b2dc2513e911cc68f85a50fbc8fbb01215320a1f629f5a82146128b840010e72d8235bf803c66df8c2769a9b6728b807c3c830ccbce0954bc0b7a6c81a5479db1e6b6a1c1ab2054f8ddc9786ef7c608c6aac64feca2dc8299441eac3ec4006dee5b87a887605520c18f44abb9208536d5ff3a004775f8087e46a35398e9c9bd99239b8dd985493b305d7bc1dfc36a84680bb83712ea93ac6e77dc19b02843dc5658d2a48c3656cdee3e633a8652e69e51d218c104c913ba5229253f3b5f86fe348a62ac219d79ee8eb07221073e3671eb8a0e38b5b1be86b644f52ea8aede9db96da275c18687ce2625a8eaca81e37b2c1ea06d007a0eb32feb6e9ee7fa8ca87d8a12286ba76c42793dcb7842e72b0161d36b22fad1f79c893a5cfee9a3e5bdf39de13c96632e5a4dfa92d310fe400b42884e1bf8bc7d66877da31a00477e4e039009220603780f1dde98ee7f890819d0022e88a8ae4203cc01a21c1e19541288e058e01e7a016e78c7dd60600bce0e888096c3a436ff7ebe513b3f3a7cb90bd6b244751329e56b5e45f5930781b959a41239a2796118cb91708a260dafb8158d5bc416e3d8ad1a2e8eb9a4695851d5583db437d32eea0098e4efff1c8538d7b75b7b179ec8909901f5c4bd627463240404c14ac09ebb49dfa20f840094e90038886fcde1a7fcc3dc8ba721a727db6f1d62f32803a81673d13991381179cc736790a9155f57f35e2266486d9f7b1bca38de118a5c8eb9098f3c9de038e6af2da766307d48efae1b6e13f86d6ab2585d86dc3276cc781c28cf08a2ec7501620d10b0e2bd1bda1f7c9ec93531806e46d096a4521a3ef7fb00b084a6549150e5f2463db5db0e6da1a1c2d439b35f1c7b7062be2c5a844adeace61be787c05ebca890a291224cf00fbb807edcb6cb25f99ee38d82d40af621a3611f1685c7b2af18bb111591b4158ef6f0f334cb1e205439a8a88f00483b1421695df54f7fe4cb310dbc651faf56b3c6089113f87bc71e8011b0eb24cfeaa13e71c87319ac45469861e8ef0c66dd44eba1cdf368ef2a4a7fb53fee63260d5f839034786a9388b3d635b10174966d94df2d14686954b5e877c1bc53e2f96db90f8712979933cd632179ffc90b229d0bea9c5472297da974a00976f8de68b1da90c550fa7f98ae401e0ad26dfc0612ffaa83cd97de3432c98f8e8840dacedcd49d146b2de82944d8bb8ba11a581bc28573335f946148b0fd5aa7bb9162d183911dadefa20fdbb894b5578203e7524ca6d1869e0296931f0cce558f1431c54de2ce131f31149e4445db510120612a2a2ff227d3811547ca8f1aa21936d55b39b3ce73b42347802869f2287c36e9bd5e58c0b13e5473b2f08361a2e82357501170d42d7b3ad97a92ccde36342c70b4b442b8d351931650afa7340eb4088a34907604de457bc0bd4e77e585d152591cf9b366dc3dd46ba6b64777e2fdfc3e35e71e1b7cecf0730156c9c5c9ab70412c47c1be40be0da9e5dd53f4e357538d3d62570ada641da09a5f071f27c4aa9ee8f295d61b1aa2025a69a62468270ceb18b6def77924bdd6e97ee68d29cddea60a01cf9f529e77fa3498499ccc9dc7059a0bfa99d54fbb93fd9316266891df4f2429432624cb5530787f41792c433c1f2100fa8165b49d4ae8fe60fde9ed641140538a16078310cd2bfc96f5447273741d92b0eba157fccc94a8c22483acc34d222f5df2324e2dea7fb0367e354e8d76565969d2cb84dc91aee3a58d28ecdba617dddd6fe34f64deb4455192ec92b02fc8d757f90caed2538567840a37ab042fd0f91d221e0c22ee41025aa123f5a0a6703855edf03e4ec821f2a06ad04872b03046f0edc776d0035040448dcc7f29277cbb9ad186731b0ef6556859b9da7b5ae7651af672ec568a241597883a16f9a553d031a5426d87534edd71fc0d8c1de4be2c5630cb4781a1f40c770a345bc2e9d3cd23cc154028cf0f34efb0e84beebae9ff904d60ef88098bb49138caf8d30e15e2e8cbf035939a9ca1c1607bb793ad8efb3221f86c5a0e80f85e9ce1b5b36f69acfcb5890cee7b7043de4cd954f378b5c218a1a5cbd28585f7f7b527d303f92c92a5e2b7ca3496ff9cd2fa7fe91b3db65acdcc4df634e483fd35507818e0848bf0c69dde68d580e176f59aa23de20f1021f2eede580327e2963e955e0b57ee1b1bdf42cd74bba8149927cc17d43a69e12d0ae8ae63b550780397835ddaa317434d1eb604918909ad781231636d1140c1b3cfa67530fe761ef9b2a98ea0cde1c51f1769845824feccf0f9fd54f12871cfd878f0780fbf1d60f4ef606df7e0d4e16a36d6439c62a20a8a5cd7014a828e69af6a1800089a0671460b23438acd3796f99864be1b682eb30f5d50e90922a99a35049934a92238c8dce91cff51de3dfd934b783d8ccd7be13bd319551841047369a7d41671cedac2ff1c6da4b0f8922d4a394d442de5fa35c64cc6f8fcd322245a92cfe6a7b5b7fb10e81ef4e587994876fc98b3a2fb7c02863ec020dcd82ecde9650599cf0ff767e152b40d0b1cfd91b5007911aa8834467ab8048eae88771918c100245fb8d2c3a0e110169673a9b96c3fde2ffb930d2019db13224023e8a27f168e14d59166c8183710ead7229bc7a3e6b3f780111488e81897b0aae6c6116883ffc1192c84e6890a92148352b2c5d35466abe150e5bae7c34ccf91726ca13cb2e3f1e1c13af06f3aa7260736b08ef9fec83988549592c14a872ec98e69e05c11ef3e9564a6d90516ad899bd304b88d8b75a480ccd2e1c7a1cfaddc05a3f5ae3427d6079b01ffe349e67495e128abcf630ba66324532bacd578adb9cd99086dc15994f4d1f79a4bd85eb9359e6b0df118198f55d99d841e54f7fca270b7f48e927acf9a7daf36a5cac2ea0974045d4811f97e21a61c4d30177074876aad26316a95eaa476beaad9678bb64a326752da93c346c878c071edbd15f39636dc7da9621a8a6ca71973297c94afa2e5580bb27f5a3e5794f6be7c5dfa2a1f71477a0c5b8da0461d4183de6800c3724a4f023fbdfd1c70b9b7acee58d28cc2ec9c81996e13ad4e09c771ed94503fbe24b97f30215c7f1cc25315cc01b6d1e7bb2b28b8c6994561c4ba5fa605b35f358a0518b14159140c06934cfe69cbf0b86730630812fa559818e81608a55a02af318528ae8fe3d5c405708c9329bd78c36b00e3a2b45b31c4982513dedd629875a026822fc2e54697ac53b636ddb016519463e1924ba9640b02c1e42eace837c8b3892a7c0200d97d54de3ea9cf1c38d6e8b5695142abdafca574dce53086fdaaeb4bbf67690fe105df6319a1aa8d3acacf51c58a8b279faa6e7688613f822b87717733da453eb9ca6b52861d13699bc35d3a4de762515c1f0098218d6b8c82793f899343cde6823fa06f12a2bafe42185f8897a7b8e0f944cd0e510f3486504eb821cebbc22068640a3160d34c41f0976cbb3e710bf957012a322cf32e4e8ce574d1e4a2a404484d2f3ab355d144a703781422113c92238adfef0f48c356e9017455a77464921212c1cf496a528c66333d3c7804435da3d4b6fd8dc197fdb3b2f43908700d5f619ed33ae395a9925361f82a7df1bd1e8b154139c61cd3e8651d57b2cc48ea71a1411f29084c65ca89fff7661d0d2ad61a6de140e82448ca7997c066fec0eaa7b58387d7108a8c1bfafbf54e8bd1299e2608764891abf95f6eb6f7d5c31bff1a49c216b7ce8aa00773547cb592c57ed96ef8320ea846810ca8a5ef45e64ce028663af4fb2586f22cd354a86750cd9bee1b345ecb213e36ca183b3b538b928a54cddf5484742e46e920ccc42438580f71cb8cc9410e884c1e95191796b0ff55f07024941630d6ed2450a90c5cb8d3dbfc41b8e38126148635e3460901c2e9d2e3dcf22f3029c1b01a6fa8305524dbc8b9f52c3a87ceaeb3ed09a74221ecbd19fcc6e4c21d92855e936a902aa6a724cc817c08e5668ac0c7c10c2bc4278d8e57ab0c28094ba3ac20bb5692f4b7fb35c30aad25a952ebac0fd084cdc29a499d1b74dc2472f23089ea343465a12094566a9ae347fd5f38a78b31b62ad89ead323a884983d1bcd97328fc3d08081662bcbf0c021e7594624140058de19c854f9fc248aa069123e25218884fa4905dc1018f523c8e05c9ccc241f143a17b214d4a7099d7cd4b381c603b9cc94895d58970422c182626dc44197544388cd6b92a9b0612f683084a53b114c91094b2e5dedb992f2bf4de0005bf6deb0f0bdc143b9757f720778c692b474cb985d1022d2d5e7c9b639911bec47134fb36a3160449ff29823dec41d34c035476cc4406363d480de3e12220242b653421a15a5ed521f3d89e95da810e47e87a356a9c0837f19d72c092b2912b33a7bbfef0c6064828675706d9994ab3ae7dc235d9cafb852356300e951c8b662b1719382a78dd900856fb9d6b6a59557f38f7516ad15465e469e3ebb1707c97bfb060e48e71b39e2f5173985b27242d4c12a00d755a50f7336bd665bc125e8a756faede236086949c3d5ec911ea6a0b6dfd16e4fb2e4050686c38764a35275a0506f65a920254c173243675610d5b5e36404ec005e93e43a3482972e500fc9ffe124a0133690f08182e830069ca1310c66bf2dd407e8160034ec5098caab0c84a1297dd45d59d388093e9710b6fef01ec03556c745ebb103c72a805f058bad4de22772743a34a6d4c4d3b8a1116c7d4c06229ff4a5fb9d7e28dae5b4915c2268c0b9e8632a5bbe78913f569325ad9b329b6410a3cac52b8927548bdc64d00652796ede21570f3f2fc5c0cee8c0a2c2a3f90b051a11d7812b1d30b1bf8d544e381978b903f008cdbf3a0d13008bd1d80b0bc40cca00ee27d2fdf56a677b1bb9e757483e09a2df3de737c18286dd7813efba4d9525309b54d313ca9fc01779acf153291250225212a284eb69e5b521a11fa2ac38458338725ba40ba2dd9d7b7ecaf0efedeed42c03007458ca80f6185db70bf1d59b0faf906fd07a821fdddd4189a1cd360cf76fe4d8a46823d16726e2715b68c6c74f826cbec7b893f2ea5f48abf73109c2dd111cedb1816510885154d17d0935d62bde262898d45c5c1265a7bca14ac19d5d1a5ea251592828a246d17f9d90cb99ab4626480cc614a8812004f88ebe8849a830f6c29d754bfa2c732f14f3557f4060c2a4308b93536304d19626656af1622784cf0e78ee96bef16c465465c3d315e9055dfd49497c12f6228da394f56d95bc0f0644260eabdc14bf0a7ea4142b713113541880880405656484c378b00ea9bce23bfe17c4116ac23c0d8be3ae81138d83a533d45f311d0a10f8df7813dd3ddedae798d7243deb938ff57541e3625036effd654d855f8e459b31b83bcd6b08a6f3946899e113c9bd1f119318063906d6e2f0b3ae2bc9246e436073a20b3061e223cba9c51d8d7f7ef76e02e01e14faed7d77e2cc5652496d850520e96f86ccd3df7a03a946416e15e72de9fd83dc605516721de3767af2f9e518067105f4f87bb4572a7bf328fd390f1ed2b3ee51894deddc090188a1bcc2f363b2bb2f3d307254c0d8243056c789c395dcb1562c8b4addb53942970d4da5fae223045644c5fc6dd31697d648f048362059b5da8dfc6f652754ada18af960e30de9ca989bbd83c97d301256b37c92ee23bec863d9a7f9b07e28fc754c189a50bada349e56f95e326d75066dde76b855e16f792ed8c0178aa992cbbf7d0b14494d7e85ee60e9d05615d92c0e4b16f6ec8d9afdf610bf311c0a31f23db028c46296de47355db2653b57562f35a8e905c19c9e126a43a0e07adf810a5d66a12c9623ebec70a1d69a5ece3edab920b6360099a9df2f2088a1dbd2c8e0dcc9d0fd5e5949ad024d0d82c402a506ab8fc4d25290c5f20548818bf6683d12761d566adc07b26a6231f39ec1c5b1e26af7d594b17313101fa188fe718b009677dae0c8d53ae3e04142da5f6d3bd4076c54f3775c792d073cd84da7d7025903c5b908cac3456dc8c4a7c60a16af90159fd6ea02f0744b2bc702f1ea05646683a67648c7981da39354f4d258abc3aaee0abb458e39352c0e449282c57033d189305ab766fe04f79c35e02dba19dfb56fc3e6a75b3315c59430baa303324c0ccd8317482ca5842d23251bcbff6fe5b585b8762c5b906cbd60b16e0ca0ad2a837b7fdd86047b63e1b239fe2267bd4b61eddd6bd0da6d5c830a82d1035d1a30d9fe73cac1120e86f1fe8948764b9e73985de4b542c8ba75b98b275ca4878ca9025d8a3b40299849f41b7f01dd3f456c11fc919721b9c06c0dde4b6d9a22ad7abd2da1e99729bb383bef075e74ee91e41f76695a467f1596ca92900b6d3064edd5d3f33a7805935c02d98ea99efc922966d0d2d7bd6bf87fda18937316d5e5b7c73ef4978c34e4ad41b96fd4beba2507296ead3a778bfef7e1b4e1be6dc856dc3d9102304dfe139a2fa8680e5de887d3cac6418ab65f51f03b3e7c47f57320e3ea2a16d5b660270189cd275fea9d6386a7d5bf491c161bc28ec2f3663446fd0e4601e832257b976a08b631a4df8c9c4e6278c44038ab781e02ab1a43a91bfc2e6760464cea889a51f1970bbc07588a9908a7af5807963306ad4a57cbe6864d5d85e2598b9c8e5223e1ca1a1522f338edd78842ebc824699e8697f1f708252b028dfc4c7165e8a56b0f31da73ab71eb160569f8a5b71d8c101e79754d5d26230d80ab5d7a005ecdfdcca1c203b7f977dac8744901efc6069cb10674d2884baf10111157f76a10c3f623bff044a0d7f271b4d4e12c3590628806a43f3c2a88a87f84e9949369ccdbaf68a879740cf6f38e18b8e5247558f734a9ac52ae94d6fa159bcf5a3d193898c4349298146b8ade3cee785f7691027815cfa0690f7751e856517e1ad27ecb6fc44c4f48ccb1e6fe45b00b556f1f8170afddc15f31bca3cf78a23d8569ec74f8b2022f0700f7a62328a11945163121b79decdc5156ddb05e50e01c3aef189b61d1157386d4049098b5b94f04cb4046038145a6ac3fc1d144bf9877d9da82955461304ef72d9cc75ed5d81013f92461907c8979e11cb2f301250e0d1a05dbd317312b6711f344571ec461a3f7455af61413600390b751107c90c1f1affb88c68d3481071dec063cbca549223b6d34a1631fe1d2ee644cde5af17a06352bfe0fde4d7b2da0e3daf5ee2fa07f196c15974897bff81d61e435d489b27d2af986be6e297564e520c167617d323e94d1c6de1e859962a4b32074a63d8c8046fba8e3eccbde89c8c65a8fce93abf3db8bf2dd82a68f38744cd98c663a6c1e643b47b8ced4e8382f4f9232ef24801e6f0be047252cda4abb5d78bbba4145b2c6dd810fba1ebdd891ac38ecb7441ef62625bc5c86ef723965af821210f2ac7783e20ccff44fc0d60b258be4f3078499040b033918504eccfd647ca4f410a1c7eddc080e3421f4711933928d5af62f489dc09087393bdff1431ae54943b3d88a8882e9b1292ccbc506384b963915fc1610a1ecd41d36504b7cb8a14cd5ddbcedc487fc7600ee88249eea728ac6b8b78fe187aa05e8ed8216f9d107452a1cc0f05c0483074c5ff949301f9fe3c3942b6b80cd55ae5e1c7e18401809a5ce6b1ff47737540aadb96f106f7691e931709ebda44839852ef403659d1583f5390e5cf83280e0be6ee837d6b7566c919c95696ad77aeb91301587bab76b564f3088cea47caa69794445f5c2f74e4d1a034c3661a32ec8270d2d45b7d9bccc53204e57eb8874b932d0c4933535106e0e10593c95e13bbf42342209fe73ada9948470098aedf8ed810e607adfa7a7b37a25a17ec5dacf3fa4525d3f1a029b7ac08b64068cbcded6d7266ee2a550e8df04a1561e3ea2b1d9c0e7f1782f3838bb49441119ed74bfa7702e54a88354999ddd77af9325e073465fd0628a627dc0159a7391da9c322a6b15d802af107069d5ef217338767259adb17310c4cdaf9913d82d395dc7e827fcd0d27c493887247a9cc9a157c373f8ad9d76adfb503c03e44a795f499b823f7ff69b9c479c23a7f11f776436915cf735b96f07b2d63a52d7bc834f581db62c36a43346d7d4218025550935872da447019bc06232b34c1f710005988010cdec2eea65df145025e2c6b55c50b77a467b91901ad36056b203372be10fc682d64d7bc7fef30cfc0c0f9d20dbc14aef366739e3f9677c6e3c00c371de4e70dfff9369a230c530db6293c4fdfabd16895bfd64b44f703e9eefd42f8d3f165140316b529244787d0f11e321e4d840af54b0e2de66df5ed6eeff61b9825894d7dab9e9ef31b2a5b3afdbbd81e9ea7517154725317107ae2b530838061a34f0c546a1325cda3658f00fd7858e0c3a476796434d16f057d1188cc3dcc9b0341b253a19a2e8965e3f06f61ca9d3e8c9ee6c084ff5180536f3052eb38543076843e08fee0d3f62bb2d7bd3baeb27528bda8f39c927b2b2bfffcb9df83c96302ed5e82c4342e42cd9f734b8318aa69be2e9e201d47d78779840c179c8ec37a76d750e09dfe7093674021b4f55b708cff85a11388254d88830d4e6d1e8f63ac43b2610f483ad4bf95309d47e3583825bd10104a1ba3b5ce830e8c5808930ea274284c0941304ab6509c64e90f9aa8d8382d3c3bdc88ea2fd9486e38c93772665d353d2426e32e69778abbe50a342174d4b25ec58bfe550f375ca786e6c8f3d5661a1339ad41c227f8ca18f476bc457257d6ad6b6a9fcc564c6dd50aab81b2962ff5e3d034e1447059d00c4fa5d4936ca004aedec2fa03259317e05daa1e5d04b1f77063a4b314a937c0d04426cd991dc05f68dc37f99f151c6cd4ff7fab42ada690df2332724dc168ce9c5d33b6ef201b358b764b37c51f6ffaf884695caca94f556087d26e82fff1ba2434af893b9052aea6fd1d37f9cc490268535e6064f07b7682dc8f709b5bbab8867e940df8fadd940a8865de41ed839a63290e35dd577dc2a89ac58824e8cb9ce37a64243fe5447b68ec3a56a96202232e77196bee9f3a8db17f7b3854dcb871440b43855bce9d6e1fdc9485f59b2b33f8a8e1f8a8706aba83fc199317b8fbacb1f8b278c6a92558ab7b3c005a71c22fcdc766d71416c50e7e5905a02b4b90ed6350f22cd012007738df16b0d473c31b4676dc1f4a837d15993193be17cded6e673922f043bd2b455ce4807ee8e2ad64cbc45693182239433a83d44a8648120c66247c7a530c23b4c478600878b14c74686193f5382e921ed7c1d5b97d1bda96c1e2e852b5be654df1ff2a3ea0a84efee9c70b20909697a2e2a6ebb2200de5e82e8600b5b39261e9ac22b41706a02b0d371c344ed7e665bcf55dbfba1a78df805f1431059b499fcc9bbe0d835470bcc224458a89bdaefb2592531535f31b61ae10904f533be9890e0995d93590fbb4cf5dad08d3c16cf2a8c5b3eaf51b19e3b66331f55a2321e1158f985955991b794ce182d52a4fc450bf54ef735eb7c7d84f256979b6cb24b527877cc01ed758ae28850e3c514fbd9848f15135ae7feb59470336d008348c7b7f293611f6d3c439060297ae29016f12085057487388e8dc333b500d59a0cff3f2f3cf5ebcd07ab7414cabdf15406dd99e22c629cea505742622f121a21d679a40b559143edd23041c6866d33df1a1460b79853ee318666455ca8abe60c2a606b3a13f3be46d15d59ccbe4db48fbcd19ba517b3e9dec272fa6b200154117274da09a43d9ccc93730626ef9a6a40b89449660c03f8285bd03f16652884116e02b876ed62e183f5789a580763efd60fa8feb4aa6ada391b93c868089b4658c8a795fca8e4df7c20a5ec6bce3e63953df8a0a5b2593690d0f061fb9b0e8a13d4626ba5ce5f5a2a5a120c4e9f601762068c31295ac0c2206e6090f3758f163171fef3f1842c8e48ad21118ed83fca30a53388987fd77bfbf0461ca7be92fe4c77ddd27d3e381a87a8b3f93258be15e43481f43975df687af40b743d6c5e87766cec57a0d946a6f46fe9118f6cdeb68fd1650bc74948325fdb5de23901345b6d7958747c262e79249b88b3c423d5eabf767a3fcd6ed80060c1759707d24323f41fab51405edac29ed4ee103bf90c494c6ea381954a2f0c268f69aa394808472e0f5c64bccdecc7b87e8fc34a6cb81ea685140ace3d0eb36cb8f4692786da468aa84572b06655b1d5d488f4c35c958def19a31f7a3aea1fe5e3376f8238b79656b54a668808c7f043e42d4209f85a9d95029702e5ddc9f5ec38e4b09f8baa002809855e6c21c15883c8da6b95acbb99023ed0276975052022109844d216872252b3bf3a2dbac0b2d46deb08fad4fbde0d980c740147fa22b8dc88c8ac26ea98bae55e6215caad98a84646105982c15b879c83c5b6b6a8faaa4010f0e11244c8125e10aa0d6aa80d2b0c5bed83b554f813bf95ed2e54e6fd845ac6106b32c1921e06274280897936a262bf86f8634b023982f166a00a54fb4c3a23609327e2c02c00021fc19350fed96e111fa48912fb2a250b2f0f6c850fd698ef14c7ee9e764451e50ffdf2e17cf86cb1d4bfd56929639387e1459e3f3e4dcf0c2e0f7af233b0c90ce49f0a3d8b26b8ae43c4e2ddc4e59e3f9f27c759afc68c58956d3172c0967a3413a231430834807f85f734459b8552b33b45096803bcad2a1e04079fff6984667d0581ba0221032500c173da12f621606b564b00e5f5f57fa64cf0ed0c350b1357aacff45c35925f29476bb652b8fb606104c07245fa575a5fd00801a03361673721af9f2a0031cc4510a6488b910d985fe560062a65f8833277ecd0a9baeddec616cc5dd8334fd1778dcf4f9b66e71e69c96510f3cf0ee848dbd73d327092640187220e451df2da4c531a1022848296cedf69fcd50f6bab042bab36c68ddd0843d2612ee7c92fb517ac3b1ab37fb99c57d4bcc02d743d985380921cd4d8b0a78063026c720af59e05192c973d36463a5561db939423df2fc5999e89e863538df06fdd8a42fba346be291ba10b16b35a14ca539db0b4a0317a9527aafc05c147bf80f0f39387bd40b950c6b94e84216867f98e2c59e5b53e8c42141a0eb32016e1cb866a25451a0e33444f390a87babfbbc1784f54092a41685c0e78eb9d8413eacc21ffda28365bab4dc0023aa64e725a35d1698995aab2f268dc0f870650701717151bd860b4f962273e50936f6f2bc733a8091e4583d93da75b194b724b78146057eacac9c35f93df546c7e14bf3dde6464f85859d046faa98a437e8a136e10d0df5b95365939fe61038ca788038162c12053a60223e8cec033d986c11e02b17a56e5ed2d9cd7e6d0b45fefefe86a21af0a9f0e50e7afc8ecbafbf25c53f88264ceb4650790abc7b6a5f7cfdc8ed53643e16586f4125ca3cf7af1c88a9acc19e2951c78d72f2af47020c5b600cd8fac92f8a22cf9a270caadc88d1663a63e3289f304f3dffc26f1ee79af36ee4d6d5a5f05fe6d75ff65473d26386727715ca204da7eecc2453a25101afc33901258cea2a825223368c13db01a4135105899ee2a4a0c0b41b70cf2e4cc974c380401f49c30ea7b270aa0d922db7c72ef27ffd4c8bf2a10c9958422f7cbc2a7b94d0439d6a17157284c1e6725a338d38c1ffa4f6ceaba03c1774dbe7a3e0bc283c9b2e44c94ca1d16f1b7ed85cb1abb280b6bd82efb3020671b682e071e8cff8f38afdc68ed8470712fea2b908eab5433159f53314f28869f8751afb970bee9bb769db23d8f3b06a392e7bf5050adcf841c8ac1f702fe0ffc97e3a8ea77879e991765c2a20d19628dc69f6782c1d23ccd5f75ce1c8d81b4694894d56f30613ede0cb37262ffd109043945b9e6facc2238a5cc47f61ffa5ccd73988fa83629c6cac00cc7fb35728253405745c91a11380e476bd01618540e8443c3301ce825ee418ddcef67f09d70bc24f44b826f41db1c6698cfd4b8a046bea4450f0891565ec3b7efc550d01cbc8f300cd2dd9ce388b43a3fe94b0e85816c4b92f8c33f2b762a8521d962dece5df34e99a3ae686aea1f168d201c65c5cd273962ef517ad83c8cf6ea259c75b28299f3d9e9088847dd365240d0c0734b6bd91231d00b3f5776475ce9265a86ca4c13d747597ccc9dd0da897b14a3c5e46227d697a7ec1597d018b325e8fc93e14d1a2de9f4ff22066d7ebb8318713e3f4fd977f9ffe94b8c5305c8a2014fa309fa3f7e410d48b954e88fcff301ae85e1ba3e855458789d3b197495d069dcbe936324c46a5cf12507e2bebfcb98329c3f8f941bd2d8878f47438c00d5f879db370569e0f13740d3e1d798fde52a9a633af5e5168ffc88013dd2af1d397cc8408672a1ada8905a9d0d8f43412eff5a893fdb6a653d768199ff98020dda889ee9081c043db59e09e789622ac08b99c87d03407fa4bb6de3a7579a5d756014a710d591b516df34501135fa3195bcc6d6b198c86e44f54ba4738af34003c85ea49be5f70bc3f1c95296b6e049b8b88b7650b11665de106ceb6fb48ba77e81f07e0bd69a1a30f4d12278900db6d4cbed0a950addbfed611966407a91e0b7461c88332bb0225c2905ea7d2552b2727ac332268ad8038afd2d9685fa15bc6257f25c9423e3aa1c4b4b05db0f7b122599f2d4aa430957accbbe8a243246c78082da2211fa9073155e6e3e1bbd688058941d131c0e71cca84b24d41a9ce4476a2e290b02bb835e86f4cebe786a56429d71619dee7a0c04930af14e4bc4bf45dbb8b19e0a057e0d17469b566f450afb6dad06ad08cde0dd414c67b49bdd490925af05e1d5c08ca5d518957ce39354cfe2975a2803b6e949bd61ab16cd77db6a76c1579dac5e7a0c17165f7641277bf11b86ed5705bb66f1d53b2f40fbce1f4b3e55f8b0817c7125e4618c93b9469e8609fa82ae220e50c32b4322f0ace8bc800167498234a4633da9a717111f984f0719b405b6fe8a3ea66b181591baf4e6dd4187ee0555fddb0100484252ea8c8711728073c74dd47b45748edd9c0cb6ba028f79cab38d5c97d478745e73ee64b9a52c52ab1657a56c75cd312a9df548e5fb084b7db3585e0f0756415cae17b10c3060eb91889d66d84eb365c658c16d856991a33b2d26cae66a0e1367528297d40c93e77ec10425463c878289141df2661ad374005698e2544870302e0655a32f45007fa69cb3499964240c02658fe3735d4907a8cbfd17daa80e3afd991cad35748cd248ed4a973d3c74e716215833df7f4d130283269a48c9e662669c56e964be558c0d2d7bdddbd4734880e341acc2a2a2fc26f1bff619414ece0b6c247799d31bc6ad8cd7af42013d99eaf4cf7341580c909502559ebeed4463233df5606c6e8e169c3edf2a5410cbb0d13b5ebf02ddb823d7abf05e932e93dbee65c6aebef06db71442b8c1c4b0f1ac6098d32d017a05d3cdd837f7ffb335020fe2db8d0fd4073af82a3e40213b5421f9700fa50f747603a8e5fb7f82da1ed61cdf3d6a57bf1efe4e01f40ced79ba5426ce7ab5bd84aa783ff5623453afbf19028615c9610b09e4813b39bc662dde8d5f5f504cf7cf2b459a7f30c2ac81272904cd1ebe600ab92c0bd12b2883eb7164b4d505b2f27838b1d66398d9a10eeb9bd212736d555abae41bb441885f7a070a6ec6b68a951b37bc7f63eada6ffe696e460ced8d05e2bd6ec8a8186409e63b762c2f236e9e9c2b717e319d33a5c6c172d0e36b2baf0c677b868039bef68558d0ea381006215d09174a586def6f309a5d7d209f3ffe1685938043bcc2ca972ec7d4a1e418e706da36a1dbafdd4cbbc0b187b936af694f44962c38d8ffb3a8386dd50b44ac7dc2c7298cbf2219d94cd18019df32477eeb8f7b62dfe99f268b8616e7e7577db0c83b93f2771025280e86ecdd9ac94e940e99141778a53deeef584b99a7eda0e0def498a4bb9670fe149a97305e9c804055025720ca0821082141bec4589030148c093200d5ccd98e49409ce910b29b1821af64a1d473c42e17fa713576cb7a620ee32b3fdcfe3c3bb38c93090c77370547a5e330f368bcbe8d46e54918085506bd7c6ec03db423a7d60fe0db740796d211ecb51d640aaf1da43a753c7ba4d14666da9bdccee1b4379881776473bd994f762fcb4f211d0af5a3599f657408536ffafe15f666b3a4db544744e70f22fd63f446d3a375a77782aa2fae9c93db612bbf508e0212dc1025fd5b93f5865bdfb7fc48b7193399ce21dc97e1b3e839f39cb72d824337b1c926643e87ce835b1cff22dceb4a87874dc790df12b5bbd334f5a471b3ed70c9d44fc673156b727256c3ee0b961977936f068878fde313fb0e1e54bce3085ce62ab3cb4037bb3d57f51def027acc4c8ec5a2863d1fcededb5b38b2d94c322176edb135fbbc966f13fe2aa3e4eb4497df8684f75affc4765eb386969828de234775d3d9f203c60f81829f41cd66a1f1e523f53c702a5fe2e4d9ca33d022fd2bc09d2a517772cf978f3edb8b107ce37a00cd5fa31b67e7bc7a6a6fc1cf48fed7470b5d70d4c68fe4dde08dd4533bbfbc28bd725c3176663e1319e90792078e6b7b6672cf569f8bcd5603749053dec3b0c60ba9861f38cef523974018f38c52f7d7c3e2fae39151f5eedc5efc1b78916ff651cff13cce3da58b657774e2408ee20a74431bcd75ada8c51236e86e0c89f600d62fc1c0d81e6b983b8147fb5592c3401f0ec6a17be3969ba705785e6890c735dda9791b9d3115ebdbb77e13f13e5cd81345aed5d5d9a75ddf41ee8e17c48f9ef3c7e98c8ea57e24983283b868b6d44683ca8bc3bb347f4f6964887dbaf1aad183f2038ea4f6972ef2db371a470c8f40700ba284ed93dc75b7541c299694cdc976beab9b422a9b147a1cdeb716a26bead34ffaa7655379532637ce0aa6ef5905f9a5b229947a10c60d5efe6b51c0a5913cd40376036200da732f84f50952d1b507adbbfa489f58d49275e084cc165a62d3e3f7753a1dd2baab16536116cf8d9a73be3957498c471f407656b3e80a730a3ce280b2fe5f88242cf636e176dab073e0fae4e3e0eff8cc41b097b8225706a2ed68b355626c1c26f2f16bee2dd8f55080fdbfcab60d43d0a5683984e2d05eb88a773ec27d18bdaf3606f1d6eb9bfaf4ed973b40ce05236283cc90e50c98f0f94ce62675f0bef5d522441e03c0633a3e59aa681778b8c14672e7714886313a55ffd32dd99f9b9e7155d99a052b48b7441117581af151929d5c380ae0fa916596c716889514e6925ca2c2d739df4d4d8186d4daefef2d5add409eb980ff670166d286ffbcedff087ef85a2971f3bbf96ba315f9d50bac0c7fee089107e0cfa54abcfd8bd2092baff6ed93b621204b8edf9f3b39adde28cfca3bdcf40b2d06de1b1efe726a4d878171acd11f96c5f4d46ab9da20ec2040fc42a6d3d8ed1a7fe9821dedf2929e3c10f5590510699a2328a046d545c71d1b8aa9a953c046a8bca0115c3daf4707caaaede9c552515ecfb40e7690a7bcd10d70b435545248b87b957a74d8c4f1320c7bfdba0453ee320ad832b2a9b3d9da7215b584ad709469a89ad272663efb4b54c9b1ede8cd8977e7d9e3f581caac677e4189f441ea59f96bea003f8f7a5b22838e38786d7fab8b2a40c8ea29801637f7915ee6731535eee47acf4a88646274d3280edbb8e27706b9c92550e848662ec0daff0b1c5b274765223d376061f2328c817b6bc51c1115e809ed41e1edcd1e63c2c2a14dade148688a15b881ce83df9b4ab7d0149a3c8e2305f02fa4f8ef2e1b5492a8f97a0f82728a0c7bbf0cbfa8dcb4882658b950fda246fd78f77bbe7f1e626492f60ab6da1a02192bd4c814121cdf169af1247bcb0e4eb57280993ffad34213398eef69e547ce6a5fbb643fc658b618eabf3898b37d7a729168068c786049b9ababbbd4d964eb22adc3db0c78c514eb6360402687ac02ad42644b14d07da89f1d07f101f3a42ef5f5e02025ee41e4bbf0031ef283323d2257b3ef8eb6ab03c2eac79a2387126d5b9f4b1c8448131c169cbf3d9f814e5881991d6981750d7dbb5df57ed15da96d5b333a8a1f44d56b0b4325556c44f56111a95e193b7c713f21de7bf791cd82f09e0118b0d22132ff9a6ab406a27c82afc57678c33f41a36c019c952e4a8e0696a769bc0416667b7a839d7501864fa622639e645c764a1b9609f371cb2e18e59fbcbfe1f94b2c1dd66e62038a4188247a2d3d999fc99414b307c83d8121a80364597fb125187484e676fd793e69f9b9f93b480353b8335d7f7d8d3af8319e5ec694568e83799b2ffa553f2b8dd2ba1606a53bbab07a16b2d99431355320e81004f18c73d851504a19764c0fb9e00d860ef5ba38051f6cf9c5e3a9155b5e5fd240463cec544eeaa23f5a3b033faf9c05f2efe42f78ca17c3d63ee769c74b0dbcc8cbb10b199d4b250dcb15e1a6aa0f0772da15690f08097ef239b7492d8a1f698debb94e03cdb3c28369afa037149f8ef4bbba748bf3c47542a97cc6bee1f9182dc959e4a1d1f6cad492c8ea5a8509a0360984b01ccdd6650f8e56328c6b3ffc0c0da123e321fa79e017fd1ed75d84c446df576aa241e70dfaf73dcf8708e62bfb84ae18661daad9d9689e9c2aaf5c341b8a861072cd961f8024576615767c78f70bc63139d4f19f86e7adc0ec0c2339821441b74b9af4de5c1a93056140e5c3bac990e692a75b941b36a33404a069ef2a30db953041beed4c08f4da8046696574d7e16ec20792e87c885034ebc1c272bf7f70b5b3dbf0b6f4aec9b742f9ff569765300c9489192f01a9236798e51abeac7c5cc7aaccf4cfd142ccfdfb37ee800330ab03fe8e5df92b2c2ebf768a463040f8d234759f75f0f96b6555e161be384229cd65450961bcbc5f3ba0196283b1a2b7bc33312d396ef2466b515fdd3ae713bc7a5ea1a7b3f7e8657112109210fec788e5fd705799f8fa0b286c401ac754392d14e3eada14edf87ec881d5fc1e90e3b097a272a56001773c1b111003232aa31d44491e80d1424dc182998d79c3387b1d98e63fb804d8ac59a41b97261b2ca373ca784ab9186e9ac0cb6cffef6e283384d810e68afa646a1d528ded0da549e686940755a125b2f6488ef2a3a1d16628a31ba48a9d2788c519956598e695a983fc583011f136f64794719e7e11407e40d0c7362048550f8f2c49e4130373a2016ebda8eade3804f73c874fcd4d53a686ac7e2545c803340477034d120ef7b369b245221e924194d7f587bf62db6767f45df9613ff3363510db929f8aad83befc91e50335bb13dc8c3bc3baed84e10eed5e8d20c8d099ea33e7a79819e237ea46cb6c090cb120e8c62a59a9bafc45c69843d3f0e7cd6e22779455f2fef10f2a367abc72631e57084d20956a8217c0e0a97792105d830b85038883b0ed2d4886650afa0582e16b677c4267ba46bc3571ed7491a2ccb28621892af552c4425ad933d443e878ceaa7d1b70e16e0ddb0c78c10c63602d804ca208e3b348a987e44d36aae5f02c0a4a505ee5ca9d8c8bd5c631ba0ef37f4383aac774b6031d0fc0baac33b83e95b1854fdd261e0c45cf297ad9c931e4c04100a25b4289dc5959fd48ccbd4f426e0f8f7abbe16d32399f0a1c6325d3b6cda2ce53c73bb7f641542b0ef8bd7cbcb39c4c81831c987d7ab380b40e91813c83c561f098c6fcf7f0e97614476c763f0950a7448324e155e76d4c6f4b685583befd23575fb8684434e26c0edc04eedbfe6a8bf2e9a3b1307f29230005559742689b1aa1d6414d5b422e0c86332a9c5a857c6f1a8c5b911c85018d6b36ec6b5c83aa75f9a90c6c7c025e88d7081adceca07ab1613cb4611869e1d622f3b33d0a5d166fc4c3b4f7b42ec46b76c1e34305359f33268d43b3db5ff2800889d8f43b90380b22f19c07c7c38f199d859f41e470d4501c5e29c51dc9153b76964a2cf7c054d360e472260a363f5dc859ef68eddd7e9ec5c1cb127396a517be0b18370ee509558817a622035347efdb1935ea02cb9e654e1c1ecb08eafa78e2287c60c9f4a946be43f7d14adf8c303315983a86d7f4e4c1588a48064eb030cc05c2b66eaa3af6aa51b8f32e92f2e6b5fc55a2ead9fa72138e2c547cc18ab96ddf1794fd0bfe13306123fe54476b906d5423cd05f0dd72b90841afaa149861801cd2cfc0895d1bf2d0a2e65453a2d2ced8682e78e3d8a76255da354846227be9eb18a98b346ad7266fad0b70c9a1f7cca00484c79cbc383ae39c3c4aa1ea7992ae0e40b0c94718b95171c0c9c00273eaa24f81aa11a341e6210048bcaccb07b8c73b735ee8dbd0796706df803e2a5bb8b825991cc2dd4da543c110b6ddce16dcd2b81411f4f1a3b5f5dd1e5f7e8613e14dccdb32c215230d72a949b41e5eed74c1e2f330bc812cdb81211a5bc16b02d97a547bb3d5dc3b1521f1c308cc071144d6d6195c460c0080c54f561fdf70a5607f8a7090edab11e2dbdc60dad6d8ba940bd975438dbc1b6c0b595d1538ebae52b3860f569ea786b75cb7e4067754b2479d1ccbf9886dc2da6cfa6080d14efa3dd4a952d6fef83643ec807b383a9d65540e7f0252f8456e1095527ce440565152fdc2bae1bf1da201a4d2905021e33ac0692e300ce5acdc4cd316cf9296506fc0c3d1d9d1d0c9f936d9c0bbe7515309ce20411ef4ab77dfad988c38d96c74b1f0efab33fcabf7eba317c929b71704171e13a108714b4f45e09cc02406f961697747667d5db00adf870a115ad4366c96bd72bd009f6a1a194d205efe8adabda68d96a526d1d242856f28d6ba70b9fb7142f2a15ca1201ba572d6f61da6836c2071535accc9ffbbff37b71e5ee5e5edee8c941ec8482ce04f4c7fdafab9978fd0763d32888e9803641e18e78dafc0f89791dd08f4764140ddd6cf2855cd408c6dbbff117ecd2e82c05444805e57f703ac8222720321cbb4743efe56a76ccecfc226e4b287f75a0e58209f974a5da6a4e5d0eac8c74957dac09960ebb102b2b05ed6738adb4c24c14b24ecc2da436df960103bdc5d2d39e5d032fe162d205b7761cd49e966b83118f74bbf010cef8286790db3396ee24ade17720f2e2670b2083e1a069941b48de58a1872ab0116929b5bf1fcc9cbdfcb1d61f22a0634d91f48c056184f9c99a92d47c840469d32dca7c0bae9572c9d082604c761f0af30c1a45689de4dd4482653162324454e0d226407e1b8ec08d57ea9abe7eb3af3d5768c1967e091af01da1edb98c8ee581a6a2d3434328b5aecb9c66bff89b60d988ff9fbc9488e514e828fa6fcf1cf219f3d49ccf2805c09be8fe3a3da368f5319d4d16725733f812ee8b187621449b8a1ddacd7039d180022692aa95ada864c78994f97fc7220eb1ee1c762dc9e4910859c5d5fe7e133bab771740a063f9f71ac03d32c138b13d2872d569b58393b6cc5734201ca4a6820739df66ff041944444f4bee59ac051a33610f49f9ec1e857b61eea2ef39eb73425aaa73a69ff871be0d795f9efa9d52b7a8d40dd1cb2609f1e3b718c531f416de2d142ebede5edeedf53586e907aef3a54b333579c6b677ee1f6ea111aa616ac05d6892c9234c4f348de55abe4633f1ffd9fe1b55b59599d2f0eadef785cb0d419779b2e652d1ed6bdef3a9d57e2f4b98672ad88a3583a936e38580fc2dcd0ef8311f79ebf607c8d611d9554674dad6c27e3c05d8d318a1ce1f73188d9d327b10fce1a709c2368b6e1049d0bed51e2913dbc2de7d348a777449a5256cd1158d40ffbdbacd222073591f572df5f1ef1239254b17e50f0b7b0e88fef73a091f732733cc95d69d319241a70422e1a6525239ec872f0bf670b7337f5f785c8efad9636a666cc0046902eae8eb0e95d6e40f2c023d5a405726a77d1a7ad3ee9d6344ab4b48c2bd441c1b83410bcbf7da3a89fe3a26bdb079c9199a4067c9616c411af9cd97309b7122ef1e1fc7590268bda4837bff7b4e4d9a403b0cf78bd09ea63d5ae74df5954ea57d6d403cde7415d33cf365f921354f7243645b9de900480f177f983df3e6949b79668679552d1870c5968ab79bf751b1337c6eae8089ba8262367c4867d8ebcbfc3dc470f673408da133b67ea51bb93ea11abccd5f9e7735312454f604c2a692578ad619e8ba324dc5e849a3c8ab93c8466f0ff22caf67bb8b03f743af0e5830747c67be40c9c28ea584d52f69a869dc0dc14516a9a2b679244b5b70c1f186443f3257b6d146be78958decf68aa1b9d2de88bc908746c2d65a31a02dfa4ce02af64e38a295d83ecc49834e2f22df173c107213cd41f95e3e0453a6d536599b52f11941ef547b181e6136390ea8e8d4824321dac7fe143211af79e4903846767ee2f2d6a78433fb2af5ae29c8c930d2f16616d569d7824dbec08bb7108e9c621d364af3dd3f56bc7afaa03ecc232c0371532dc033fdda996a5d51069875623798dc94b4273ce6192e3a60bedbb3c0c7f2d487656edde1a2cad5a8ff7d34b27dfc579c8de7448bd2621ee1e47ac6d82d6b8eb90576477c209541c4f6067e7a0aafc1ac90035032d82dafe55f29264b4863ca5ccfd383357acc6b9a4c69792b4e14e30aa08f03854509e9040e5b1fc12e42ac6fa66c32324352195138f0880d86dd83d12b0852c75b5249b91bc339a5ed86f98330d064e11b449be44439a0529b556b76ad7c3405388971cbb083eeadd1b07b67c9fc660e852260e7c6bb686a2c095cd023a630a5bcf38a51cc86ac7920d3adbaf9c99a44b61033fb25e53366c67f1856aa6bd5c574c1b55f43f0df311df44b9e567a0350bc32fd8699f1ec5d2fc03600a2dce51917278f94f71e429fa273662ab5fc250af96b6854d99075458e225c1cc0d2fd5435e2126fca7aa6ba7ebf8e1a74f628ef71b98487bc11d4a3810492a14f09a113e6d191630d1eb4d44ba4d8380844e851e4881f208d21176c3d91509148958c6b5187b140afe3a8ce1380ad66c40f17b1b82a876c7d71cccf2b04b588de6fda296e84a71bad0c228d08ddd778a89bf075ed3326795343d7e0c046479c779d8013d217e559709f2d51a02024be9d861ef1bb072e973c62274c02aa6b6a49502537e90913c0e17c504fd6e6a586209b0452e6fb48ba97ff8cb162aade0f0d8542de017ad79d37979ca42e03c8ae5bc556faf2510661216cd6338e474481656d039c04d48eab98a09f7ab2c479718bbb6624236832defbe44cc122f5c36c1a178c1245b09c7bbe06ac468f18b085fd9fe21ab917d72c92f31e4a5be48bd2490750084eb4ed06a9a9d07ec6bcb4e34a903f013e7f429f25f71451659edd2f975ad0de32e05ae3364bc0979a6aafcba2692a36c79ea44041ec40d0059d5cf73466e174610de40335c9ad48167a0f7512d97a2b6cb335ee992d83b639c01d9a8fb01a9cb9598629172829f8989f70a365bddbb97d44aa990c5947a9ac07e671eefe3c8682017850d75f460afda209e387084ad8e11ed5cac5ec3eea25bd24443ae1869b030d6f41a6ff573048a19f45c463c7d122ec16bd7e32631af79e16359464da9380e800373dd4e5e844a5634bfa129e015663540ddfd8b4da3c5b9ca7f01131e151dba39a208cc56adad9cc70182205ceb56b9046ace1e2d6a244d548cfac5aece3a0077990b9915d3778b7f2441380f9509fcd89f0af3dfe54d44d05a31198716265637d75b4c5088be49930b08333469253f64dc15ccb9b995e15433d0087eb869b9e8d4dedd2bde5d1bb4eecea9b20c740f8c190f076dfafea718a3667afd9d8d9e2b2ce668ff6d346685a307d44584684982ba84cc3e8a213e005922b7777c50d8d3720fcc5649d9219d065e98d212ed5e989d10f96a7aa5921a5ca3f362c30c89d805e81f96922686377e4bcc5435b82ca75f3587758440af27687a408a0b6a15625424a9ed21c1ef58c7162d7a703bf5e36c061111adfee4c099351537b5d2a355cf4be00cb17832a03893de4543931d1f6d3ebcef84ef61f5f609ff7fb9f85d2793a787df83604b88b2ff7c6ad2f6598abd4d39596271b930005e23f602d042e4fdfbcef9174fe0c2b061f35472db3e97f10ab09a1f4dc3565231b48d39e51e002e5cd644a08e18db7a3be901b6f52571dfea13e6c7cfe179b52f8ef6423e3919905bd5e04daf08827c9bd13f6e1488cd0a04cfcd850443d5389c4ba251a3c06365e48cdc1ea5c2af27d262eab393745d1592c211b8dac952a930c3a2e24707537033da6f8d6c2e8fb07f3b0b0e6caf8aea09c8a105a8b99c2575ad3a1a4d7667e7344c1e6bc1d247c65f8e9770fe0c7a9951b645167c9cd1604abce2fcfb9b30dc15cd9993d5ece2203dc7a0a8666ce3dfe87c2ac8a6fa67a684e012f0a9bcc5ff25cb334f4fa9a76ad3514ff5114664557a32bc55643851f21ef644b0992d4f28e533b3ca43f8758cb88ea7f989d96dd91b965ef639ba60f14b892ab6de99bfba5c437dee44a6b5c485be7cc82d4a8ca08bb0de5c7987122a566589bc661e62792fdfc168c0fcbdacee2add9789f2e5ebc0ae92d0a235ecc7873ce1b40bcd74d1c3b6d5598aa0ed5b5f5007e293e395f2c2921a6e7f446a836155e4cafd075b2f3cfc60ea07893ef8eb40b9d59309b0601e3df57c2909340ce8089e9ed2325deffa7b310cab43ece4e4d0d27c773c10075228ab59e7f8182965abd0dcb6b652050b2d365e7b1d05f649b19ce7b62f47ff95a31d052ad4ee397b2cca64e292c6cb37dacb1aeb0f547ef44c998b4b1d7980441e01b7446e164fc643aee74afe9a6c5a8e69a0a34f1829750167641f1749da69f44809109a2a4c5d0312929049f38f9929fb7191ad69eb2da3e357757973d86362bc6c9511a347ce88106bce57e35c4dfe9a33d5d76a1a6d7cb74766356456b7a15a66b7d2e483647cb594768c48402704e09206985cd644a3e61a51bdf1c1f451a55910932e37e1d11e7e3d60929d96a29f93c7c382870d29deaf4666f9c6498becb1dca7a0f03a63998377b82d587aead568928700b483b71483f53a2543c1eed3b9b4bafaf2d45e10ff99da3943aa77ee5c2e1a84a6f0578654ed576171308d00096ab25c93f244ba3104662f94298bcb6a7fc1bbd7f3bcac219b574146ef64bcf0cd1feac4b74bc276102781f62ca04eb2c6d085012e0d06a2c2412ab1be32698f304d73b0a533c64920d8b33530b65e16fce14b4d615f1bfb236fab226c9c90b9448490db19bfe5d529963885ff0938a175e112d72c6c4327cef3f44702cdd7f83ba63ddea8565b001d6a23fe51eef3471f828f5568faed064ab3e2390c86882b5a6ee8782f0ec6c37d98acf968e5bd613da46c36bbcf9f9f0707590a19c28a509b27a8bfbdfb730032a64bbba14471ebea2c398a506612b785922597ee76139034cee2ff3e74a4d1eeb471cdd7f43068bad806a26c8d86412362793c7823e1e500fc4495399b0011a6988eb76f3be8047a849951eb253ab9bc2767db88e5cad1100b1fe331b68968198a2e033211de0c804009f95c409a4e13210a30cf12d725bae62b6f6ca513b8e7d9ca8eb0cb9b646bb178847fbd01b44b4fe1e6b15b0ab7c2962874d5fdf70a455f03d2e4454163e89b20e6a1d8033870e1e177cc6d856457c3624dd76227bf6b5d4f0c2243dadbc11235dd58a95a272903af1ee6671b636d8f47e90bc36d5c6e070d9067e7d81d504f566d040c3f193aee5b48195fc5910ecc4926d1ebb121c2d451d3e99a2386a69104bb5c15171ddad5caf8e09d7a051b33c1db342cc4ec3d81e59ff6f19983a44ca609a48d86a053d635ea49fd90b0bbe55be786c28205cbdaee73e6ed957f8e93b8f2a9209555609d3346a1b044750221bf76b3d1c10504ab8aabb28c0aeb89fbacce4dbc40afc27e0b3b9e86a3913cbcc9bdd343045e0ce24e72c6f52b6852683fd9a61533e5994c107ca65a0d81d4ee5322c0f7168e4c2b32eba8a7fd783eec9ef68d7f20950595988bf1f857bbd3e184aca1ee2e7f5f71fd30a1075e59ef1103345a8835806dfc6a8a246dd79b7551c26a9b16a7628dc65ea8c930abfc7a7cf04f1e475664e1373cfe6ca0396d4c750d114081f22d33d7981eb536e60ed2d3ea5fa72cd046c5fb110fddfb14466f0d8c35b2658eb69742505e7d1d4161f1d4c1b9af6e373fc984baa35f81392bbfb56c201ae31e2b6fe2a22680802d51d9ef98e7ea830eefa07667879bc93921d4bf4f117fe0d328d1586ad150b58685eaaf61e704a2fc6ec854d19ac27a9d236d88a1fc310c23255187c88a5e2f7684a02098fa671d68a592e2096466c5b87191efc3163193123feeaaac57b4fbb7d78352b01f5ddf29563946a45c325c74c70e2af45167619af91d10088f0699695decdea4b41d43be14e0b0fc95c150e122d56dcb90ced5efa1ec926bcb5eb55287c855f215bf7dd0159a7cfffab8b8f897ecef49764928f3792c5e100c8a3fa3044361276a2b987f57624a509b2a119c12a678d25791101d182af43f1d44749055116496fd0ad78598cfd78bb185d0a5b02fa302f3559a5f952b9ca6e639da088792470e04ce9d76c431d94f0633b7c9893c3a72e01289b8a7573e60cec814bd2e2a553eb1728a9f629cc9324f93f7e440a11a39a437bf3ed1ed4ae684904cdc4fa3546e583adcd55d48a8d0ad228e4eca534dfa0cfe35dddc7b817f9a01d9da79ea45cc49915a2935d6226b7e0b99417c55e29c070eca6c394f3994026fdffe5382a05ef7e348dfa260c790b9549d5ee560c7a83c1ef7f413a46885df2a15f14d81d83d4fa51c709d5ddd62a34b6a8d531e04c48920e525e98875cf188e8c800876a3186d081472c3e3c5180eb3f8b1dfe1b2bd18f271262211601f7b0a7ed0620c5dfdfcb981ba7a33b8b10af6995bf36b19889b9938a460659e2454ab63e1e0d423ad0d984d4d3c0874aba21623d301d12f606fc3296c427dd4aa1bd6dce71c0f8b31b1c2be774382b8db3f518ffa883b97da0dadd6dfee0a647ffaf1e89515ca8a6adeee729e35a3a3b43cbd4826397b4b7b627e41ca18eede322eada538090e4b924104dfa67909d1a4d4941ac4448d911e21c6068c8d094fe3359bc8a26ed66962bf618c6c93f9177d5f93527789b89ba3d68a9e1b467d3616e26af40dcf7e8e71e6fd1b88aa1340ebea1c0e8ed4400f13904be8e90cb4af01bb7be6b8843da9f878948cd705f2db20ff131ed1cfa4695d6352b78a2d9bee47e45f19a30cbfeeb561853cbb0ccd307a5c95c9824001f9e74ca4cbe5ea9448f3ad32cba1087603c3627ec1c11ce2d2a8692240d650735dd67199fcf92bfac80b38d535d4c40063632bb63ce185a3c5aa992b7a28b761f0683010d3a3c058a07d8dfcdf7e9714c9c639cfb4de8a8ee7bf4efff8c5fa8ded4d8d5bf9e00efe6edc2ffc87b886a071b6e65465192361c76ef37897f7eeb2d13fc3ed6fb02bf2b9b7dc973d4a5239cef90bf5e60fbf5d6fe601963d3d39fc92451d5fccfe61d8873bb2ec8e386d2752f7d3d64f3f01b90f6a8b13ec9fdef7842f7d7efeabb2e6dc7a2279860fb434b71fb32eb73f0f199ed35e4832a03f1409b38eb0b76df9f885aa7d741f777b24feac604b4dee56aa9412461c5784182c78129ade4459596463f7f53eac7e8eb8b15c2747a3dd1a848c6a5ce7974a54d6ded7b739ada83925ab0a1c7cf2cd2a1871513c77fc80f8ac1c8b12ee425bbbeaad522e8670902a42a597f04db17ce3394e0a1423ec869dc9de9f790da539d84cdf51c4b98c5803a02c6141d1b42c2fd896e4cdc9b9fc2854f5d67da69304f70bc3c4dbafa5354a0b896c60de031a0fceb8d8c1c2bebb7ebf1feb0d549dcaac1ed75ab7e4e6ca0842ba63a95fb17ec222dc836f37171981b6b15f6680a67bbead684b46ab654d35843f036b0a51c24a73d0ad34104b473c59cd7f6083cf94079024b5f18d50b9515dcfb63b4440189659718bd1e288348ecc7df7d80a9e8f65a8611049fd9d8ce67e831283a524fa8893c9d0d907c05fb8ea777c015a1b707008dc17fd1c2646fe9e85df960eb1e8c00e6dec6603ad15190860e1f1cf1f61a332f2df442b7a48e59fb5914ac307fcccd938ab4eceafd708bf0fde6d8017ac1d2e00cdc3c240978173f357d0f80847edc43d1498c1368e8251fe4ad885606a0078415e17dd3dd3ffd23d1385c5a02fea1688941bd1dd7e547001ae785bed2b7d02b117b4b665ce3306a37af2017009b41e56ea7b23e8a7c0f8ec0766a690f0d8dfb105156ef8042413af70ae21d1e75bbc6cf8df1017a144d736241c745774935344ee98b7c964c2e522ef4d2f71f7560704a505b14fb90e5b1fabe63b43a17c3c242dd49c46135d9cc8e1e118d401b64410fdb89d04b851870846e68db8351733ae52d52bac06fdb52efc13c8ff37187a755dabfc3018f6efc4fa1fd06aaf544f0f2333083af3dc6f335a957824187d3988ba57e605e43f68deca71724add64be8cfb852099ef7382343ffc9fd367e881f3b0aaf60f7c4d7d5c7b38f687be5027a7d675b827e4aab8856986bf77858fb039a83dc9cc4b10d281a01b026aa81cfd5ba674039c9cc6301ea3a7f32a4f28bfb059bc530d5ffaf4192a0a9eb0fd1137380a195ee1f3ffe308843862a6bf97e4a071f00791d7e7ad63f83ec2b22e3ddf41437fe96f1f32068481d3108e6b47849641eb7dc8e969a596fa374e1919517129d9d0d6d78056508c39e0df6b9eeb2982c2d98033193aeea3ebb47d7ca0663caddb4dcbd63fa8f6fe4e64427bf2ffdafdf4b89bc2625f4e9fb31e01e894321a337e3cd977aa1dc8fc5fe3fba2d504dff188d77e898ab92cf566377ff837fb106b8bf986c903053ec44f263acd65661423d30c33821061f32e594110ff80588f33315b06f6bb1893c25fc0a031cd0cbd3370f532c5572e06dd70ce7f3e9a1f0595c6ec10f5de3b2de433dd9c99e5cf1c6ee3762f30dca011f14be2629f56322724fb5f885e3785914a1bcbd017bef734471916ea0fc99cf8fe21fd6120ba7fcc1466ed1d7d570ae0e4e5dbc7602331de15d9ecdc821d65d79da065a8744cd47f37eec88287f9a1f3e8db1fcc7c88913afafdc66298b6f126fd1bee2fc3b0735baaaba2a324d607ba179b396e830e238d8d884e8d7bc018e1d731170dd447bca53a2b5a7bbaa8fbcee62bfaac97eaa96156d67395cd5140e54c2d2a2af27a7e2441758528d65e5ec7de319fcdab11ed2500de72962e81ea3d297683045dfcd54856393162bd9fd2a25313003e10d822011f3d30df0994a752c692c6233f60b2c8b3c0529bfcc878685bdfd1aeb6028971a0b16b86dfd40f6f34943cb19d1230e2ee8be4b346748377b4dab8de3a2456c22e06e0c0c72a54207fb0896fd02538d305e53d20b0ec8b7c8d506cfbace3c43a778f9e60b076ee3f6769cb070ddb077bce84044b24d69a8bdfd91738f48b62d1cdac43f20f7f56ec55794515eed0367dbac7d45f2afb47c04491455d41c5be1b78c410bdf11d4ad2a53b4c854f9b111babb072697727aa0ce0fb907f1d500f8436b57fae4511fb63eb9f84bb327cbdc939476cc577c11e6b4fb6c02f5c122e541003e2feef34b763424b3f66b9600dccd931e38d2475b0edb929f1288515b644abc3327e2136944d835814498caf7553c3f724d4c102922a772db3536562766d0b06b8453ad78d139d426ea5f882d11d24bdd728e1432ed77c77f3fd55b740c29187dd6f2a12d94a1a9f096f5cdbd00d754f24a23efa621338ff70c9aca84e4c8673e6c20c630d3e315c223fdf15ec03d1968a67b7593d1fd6676c5b586a40352270eef173badbc307a6be314255c84414134650469a960f0978dd09b711ad5d1dfedadfe916503e9c7d2b31b170012a7192916e54d541ac5ca57a4571c5aecdb0894084d0b95fd4673c630f7b5d55681174526928b8a9159fecd90c6d8e50c5f2285c1a10de52e5a3b8d273e075bdf8eeaceb75da6ad8120a90e252d9880271d9b61469d08c8fa02b4ce64a3379c1bbfe1fba817488ae9373e425e0f1974a9147efa9ead2d4105662eda3737edea4c9a63d17a8e567aac50897a0ecd72906c28dfc2e41a5df5dd61c17d7f6a60604fad402c8cab492d26f551585c095ce39c17e0fc598a3140f34aaeb6e486b2ac5d458a2f1cd1c54b503d34623dee4b93c9dc02fcfbab72f621cb0e90256ad537da4a4afdb38ef218922723d1551b8bd581027ac79c5578695975b096d0200d48b0ff1aa6548badd57fadbc6b60648a4f8f4ac2699d98343e7dd3d0632c2a0cf7a6b3813a0e21e8eccab9cda6a91dc71c3c42f3c2f564d9a998b107b93211ba01ef7abe7bd8e991bb15daa16745427db628ce4cb393599bde748c1731260609985c0e1b3dfa512a42f051a7510dc3e26a387ecdf236569ea6cb1b469a72336489fa5e9576c3d93fbb9d7e4b44216865aa75afd9c27c3fa497910acb90d1e36d3e958fad04fc2a4f33e25148ae183579c210fa8bed9aed5661943f52dbb362e25b036aee90ea2a23918228e466e645d878670c81e4b1f2669c1cacb0585afb9db3b64b7ca2f948a48d8204fbfdb2994e1e87a7d2a8a7bc49e553f844b86cefb2a414972f2a95b6b7dd650b18298de4122a258414464a5df39e162e4cd4d4de5aa5340605813ebe403367d7f157a93793f595f53aca8e2a4d7ee4074012a02cb5323a417d8eeb494eb0cc17033de1d08d65c4a4f9ddde4cbf28698699cc94163a910f1de124935da8a45019f05898fd4fc183863573b1f0d67572e29f8b97d6f2472f8b711b7cf173ad7f50d3a810e506a2ff93e270281a5ef40dde744ca6ca4b71e811c76d801457935455bdcd5f855c3d29d2a7d3b9d78b5c48b88df16362af28d795643c440b4be67229f7ba80c4bb4881cd168195b3a196bf2e5531c60d60dc6793fcf3866d691cf8cae131be330ac3c01830c027ccb88d1527d6425fc37f48b27e8afc958e277c4113910103c7d274b61f22b4a04f7b0c975385979fb794c20dc9b2ca5f8cd90be81aafc8448fe77ab128f429740b51918408ce4b4f3c05423e52a0347bf44ef670812a7a9c1a9bb93ad9854f1a5af49d0bff294229004042f513808a35fdc15d07533ec9f551ab32623d2dbfbe12029110a141e179e4d2efbbbd6e4212fa114b78ee6ad47d68534d195204d625040354bcfc573e98073d8bdf549a6d3485c382716bcfe1ac369898258ab299ab2c1d1ec2f3d79482903038841b46663e68ca4d6a4789f0ba25598530bdafd0783c2bbcff336a54a995f8f67d092546acc1150fcdc49b036bda364c1042cd0a88a19b9aa890001178a8b63edc7b773707e26ffca4bebd34c8cde6362a4afdf31eefb46bd79db3f49ade0b7a5a9e134ec2c5d0104d3848607b04818f2d42c7f07749c4d571d550c5023442af41bbb78512eab19f8f7674a126fd20467509033cd228564d178596f90d0c55260a20e153a6f5c6da7e1cdcdbc5a192200bfb1715311b7ce8f379c802673459710d3d2682b1ace45be05d605fed6552f7f77a6de7f6eeab7da6e7ce8f78a69d67a3fc478bfe9d7fece3df9f8a13e95e0cd73cbd49b3e371230cde67bf52a34799f978baf0b5ab12e5ffe67c2f027a8cb8d59e610e749a61eafd76f165cfc1649ef71f48647b7061e1669de833b89d8b5cf95e3384ec121a1b741b13b7430ed13e5307ac34fa1fdde82ed4f34bb3164292f40a57dba8d8a34fb76816e746a2c1b85197dc3081273fa7d23c6d296ab2218b76353f59388064cca506d4d95e486ebadab684e182f53a84d851e0facac28a7863c485c039e862ef22a152e74c17b250a9a10db26196755c0938a193ffbcc80e62d93468ea1998481dc5062a3d89ec69a2ebd7e3cc9d739145bad5a421896eb7db228eba4d5869885a212a382dec9184fb2bb12f43d4a175414e6eaf22f5c77ddb3488e539a920284462ead356142bcf3041cddcbeb22cf6a8f9c5261f769f22b5cee8f77b3a0580b44a8f0a72ffdf1251abc5ed4926ffc98851e150de81ff441238c21a8bae46611d933c3fbb94fc198502fc0d639b45bb04137fee531b1cf9ea4898b52fe3ac9f0ef9004831cd34490ba5b957070f302c8fcb117076f67ae27d846de2ebf9bd1ac7aba319d39f3b362c774a666225f58652f7dbede7de62e5d5d0858dbd5c90be6aa5dda51889584019af8a9ffdf3023f686ce85acf977a6e2cae426bfbc516c432f6cfe1bcaae638808e992e1bb47b3fcab9b00c75a8173c74f589730f38f4d6087b5440f413f12ca5612e095125ac4b300e424008c16f6fe99898d129bf596bd25b17060ffb061b3b00d5c43454bb21f063c7b03d062cbcd6be4ea4a86b8deab28c7bfeb87be73c8a8959890216864a6e34a58ee9ce02d5999ffc9decef9cfffefba7afaf3d92b490efd4a83c3483591a2748b66228cbdd1e7420fd46f1d26b0d8dbd83601e15a5d76087b89fddd684d211da4fc42a611ddac22dcb3cf6d6fea51dfc20f0cd3c3eba248ea9967fd84c248ef6b434b16e0b50447329e1ed4ad799b1a0e1e89dd434cecae57d6949670520c67c9398ec2220a77efa2e1893420bfd9afb9d50b2d8e5173236941285a45670292538054ee4fdc9effbad56206d54a78ff9d12916ea0f1a44f8169e209a0a3ee0fa71fa1153ab5ac683770a1d48e59da4ff59a8feb9c364f7a99d25aa57cbfa45b76a010cede3ec6219965f0550bc1443f8c6010a8298339343a0da30712d740cbc81d24fd937674451a1993bbd75aea251f0b43e76a4333aff96ac2b34df28ec2a9fcba1d5a87884ee61645558b3074812f4f53b0884ec568f5d8517cd01cade1e903f784c6e78869bce9e2093253f6407452ec3ecd9657efd68191d648124c2392f0597022c91ff866a946a2a1fe2cf37d61b99ec177a85efc6cda315b1b3050bd70186123a8d1695e5d927ac39733d84024910da51c09a72aaf082471980db826fa885d6aafad98aa269a65cab6b0b2f992940c0fc6fc1fb6ba1e1d79ca2bb15c0580bff044d6076722dcf7f8cf5fba79411e6319ac2686fa8d19298074af70b8bf8a241076ce88b093cdc27699b66127a3031be25b6d82f0543a5006033d02d5678a3870635f651351448ad649e90092cbbca12fa80262b42a9c2903454e30d56a1aa586d20f2494347a5738cbb5aecca0d6b226a7be8a595337738b70ffbf523f47c815732b0c02682e417c3bd3f3d5984cc04daee30c98b5d497234c12f598c79040054874b3ea8e01d91b50080a498c2025cb49d590dd207a6ccc7fe26321814095f28518458d7016925b4b39413882ea1fb1b2580e58fa7e69bd549e1b0a1648440ede71cca2d68f0fba44283f498c3c5acbbd885a187888050677f87728a62493270134ee7ab158ea1da10e82f243908e25e8908885a2746b8e448d3a02c9c3d0026f36780c81cf052efd83b1c9ffff815fad11688a308ce38e52c632eb9e4cb59c26e22e8a01d8cba3148c1f7af3ba17597cd95a3c9b78865fdff3ad553d340782be52f929d83f6f4d6044ae82731e51ddc9ef43bab1e4ae9a22bdae4e98c7bd3de47efaf2dfb54719408e404da99e5c834b5f3b8183fa553fefccb5f2bfaca3a4e5338a7810b4fc1d0f97a13403c7599a607bc7bd121beb627c83fd37283487df756ea7d38b8db9fe57ba7f9ebcc6cab3ecc7d70127a0f0e80a111b4309ee7a6118085cd548e8b797bfe2c4570a9ebdbfc2c44cc8852f45d3f7a7e6778b553f42a24c6c299b5fd959a111cb9c97b73c23a13dd7e22b980c645e40cdbe23d0ed56dbc18b95d03ae0e698162182c9f6ba881a4849681c3ada9fb6c906e7eecfa39e3d43780852e42121622f84235255fb3f7db690db4c3d1fb8d86e8b8c4eed38e05864fac37d926c0a29c4aaee6f316e37bdedaf8eb1fd3d957b9d0a24197a3539bc9bc76bb314bcff9e84db94bfded0c195e28254e6042e6a563e8bd12793134a919d48d012fce325c9ba590aaef758e70bd43757a60dc65a6a9138987008bc14718be687ba42bdb10654a00bc4a644f65e00a61238e892a70ee5d56d89b1345789a6f7e5000c82e5f9763385e62e1cb0864e1a2e89a7be3073adf92c4e8854a1b336c8c5414a768f3ab4a9eba29eeaefc1f221ef954297e597ba3615d3e3792a332ac892a0899fb259039fba984484cd435c1d8bb01d4bd3e63581dc277440eb28be7f1966315312ed1500e9b07a39ba5e6ad63ffc146f1fcda7aecb8645d2a29a7a4128243041bc1bef1618de2f9746160f47c28f6852e466e2558ec0f27607e9ace220347b6ee85d443c8865c1c782c88f2cee8556f6d37b7a1de249d3a3c52ad60b4c7fc83fb3124a6c7da2a1ecc2e9a1f0a17a5568287e0404c60c9b108cb381325606fc88043352579b5e3c11e84478e8ee72d9cd989e4ff6e3aa1234f7d01b6cdc03fc7c7e1ce17bee16878301c8d2de0f64de9bedddfa953e85570aabc00df6c5e8844c4ae92b82b2001c16a60d582f960e73514e19a1d7d97fb1cc82ebeb0acac2c1960c8144a571076c28caaed6cbf89f803a96254ee3588fb6c5169025046de87a04460be98b2f22da176a460464229239549091ff904654dac96fee466eccb16247b4bf75b0e4fd1feac1a67548d055705e75f82921562f76c5d3fe9823c76702c33a8b0dde91b4e9de9541882b6dccb1d4bc1fc8bca7d7bbf5e930f94caca5a7d455be1ff3a05b3d3b61d6c5736b9ee8451623d443bf977f558f425bd6b9ffd58cabef15e5f6e491df483d4e1fa493d5415ddfe79e1de7b0a0030038ce77a30822d93ff8605625319f6d363f81d237836a2ea2eef526c53c92d7a43100f0184195fe42e0636c0d9e7dcba9f69d905094cf23510a63003a30d874f7aa670566d89ecfadfd4622987d5e4ba5223828cbb662ec7c2fbc881f427c354261d028688879378dd18a404fd82784e63b983968f3a8af2d76ac10c66f8c8cf336bcb4292ae1bcf565d0ac5760f324bf0a78084515c034b32c8d71fa53f670d0cd479c43f16aabce9febb19edab9b60eed8de41cd5989a2ffbb5bbf1e32936f805e0e3845abeadb68c05ab6b8205c860b73f76572c45da3cccf247d89249ba60d3c72cde0ab3ff9ee1b025b3948adbc6e02179905eb6365be80ee3954ef3a69bdebee464ad0f1a49584dbc88c496ce703b18436259bee9eeba3596a13ffbdc222103788ab1d322749016a8879f4840f52841f018f87f09efa5dcecd0e34932d73fb92ba4b9580261d82c63eca0c56b0f1a6d25d01b70f661fc0f7d7ddc84f14d0addddb46d8cda3aaf5c2a47152135280cdc9bc45dcaccd52714e209f848bf84d1a43c37b8fdf9f834334f65e4ffd1f6f18bd3a0479d008bd179c9ef18c8baca0a2dd1e4d79d85858304dd3b61aa7d5a69b3910780cb355f8d01f33e13f4335a95a21a6729857bf1b2397d9e2ad270739354cf8c06a3137d6fb74b872ec25ed45534881cd5818e044ebf5b540210913abd90a0b29c28b69d1856f01e01eaea889ac3f67e058ea8d83d5395e3ca98a89da33eec58ef9ae016956c3c913a647632e87bc54810966d85442c0050325cc681b9122a2fc5b842860491fec9eb277a0dd3ad7958d2ecf91bca76bc0374bea8a1caef412040258e846f2ae86aae6edf2c96c7f6df29b9bbf1fe39249cc791304b4b8a886adcf68af96bf853c6df5a1c3d48289ea36041113896880178dcfaf39f10422de08a79af3272a95621dbe26231e5e5e9101d632291231d127fcc4481f6238640038bd525ba5dc0e18b57661569bee11712711cd0bc4a70394f55207e7464c7caad5888e680baffcb2810c7d1e95314e322b2dea7e024132565c788b293162ed4b586cf327b7c1f3684161d21186f0e3b87f160517884e9f2c9340a8f485ffef92129024c15cfc82226102e74560bd567fe2559b679526acf95f6b8a75a0601b81a91dc6382f59f912bb40211609d5d8cc201b177e7695dd2a8b5bc5fa7c19cd92c024107dce6a004d031f217d68d86fe4685c850abc2fd0f34a6b6bcc654317b0b125be78b863494ddbf6519b245f927a4673869f7213c1458717c6fda6b884862e74b6523de7af15634197513fa2b4706da848ab6bf8280de1fcf7dca7d7b127075bea38de190a33d7812ad6bb09f05dd500f75fa9a1d3eb76a31262f690d359d82e437d4b752c4c904872144c847f0c7cec02ceef18bbcffea4f7b79a966c6b566bd0d5278d48ba69a2e8e286422d8df8647a78755e743e06bbc19cec962033237b3134de52fbdb470be8c6f2de7fbcb0619fd679b4cffd9c6f830bf0f2fbe19fbedf0d8f9ce85187fe26d90b3af33de3c6b7d269c1a6b474088596834cedd819c29566442d925481809a5c6b4177062179634d4c22ae52cf659f28ce0b52d79ead2b242e74c2d7e4e30ed7839639a4222cd41b90e166592ca0659449e6a6634cdd459b24487757dd2c21c77f6df3ec3bf3ec2e2d387b0f9f7115e3e834e4b58fb3143e564a689acb3926e42062ad3d4a4e6b0a455dd81427059aeb8977ce9f16e3f1b51cca924d96924abacd385d081cc1435d724ac695957a0094ad3d1b2ab3ee3d0bace40117453a2998db18a357bca834bb394230b9b63192b760725a0399956ba348d452cd889640fe592d9a7794a91810db18c25bb831c109c4c539ac94ad6e92454a033859a6b0c2b5ad725d004d954b4540293ccf7109555739550b61be7fe4f4eba0919a84c53939ac3925675070a4137194d6c8e9558b333a880e69434a791acb24e17424750e3bc1aae00be0f86ccf0699a5264b349ac63c9ba5aa0074dcd764f39ded9f7248184fbc73575917b750977d619b7d44d6eaa8722a0a8ad3148bbdcdf5cafebdcab4bb8b3ceb8a56e7253dde1ca2a742c21ee650c6ecc1c6e9299b89629b83393887f64ade69b7fd83bc9e214912771c7ffc63f1eafe0086b5bc28f082e5ec50dff10d7e8bc8fdbfd092eb178074f585b126e05b0b615f7fe437ca3f33aeefb27e147a3e5a5f873c6c4fbb8ed5ff089897770cb7fe10743dee166c6ecd51490eddb390e4ace73c4fc1f6b8b8cf9827d49277cf18a93cdd959fde0010f925ded112bd606cf3044294d4948489649e5bb3486bd5ab11fa6877828302ed88ef0f3ea1012a9c89bf504ec3ac41e20554768931d9f4d430457f5ee328c897c4a044650281a3c60d1a0effd447f59460569a605c6fde96aa58ba462391e6281c55872fa8c1e5ea89deb10c3b21e8a41a09d52a1cb95c9bbc2b30fef0a0cde320669cee13566186bed2ec1385ac7208d6cdfebe27d0fee09dfa9e73bd6594a84a343f41b6369736d6285a7da9cb5c97bd1a77b56ddfeea0293658c6a7ab8a822d0d928237b5376fcb37fbec6101e2be50f2ce0dc4e9a390a62ec6793e8a3ddb5a52f6a04e5a24611d3526c86af495d23553a16564e4c47e0896825eff448b00616d7d47323d4cd928b92ca942754a2e3fa3e0025dc855e2cf29b51aba72f549d44c1f737bb9c2c5594a073c1673a9dc41777b3bea2e5b7e01f8cffc4dc2344dd65b5ee655a95a741f750c53c74b722e582528b03d3637f78f320a84c0eea6dfabc1b095776570d3546aa9f695138ee05aaac3ef8427320ea2d225e279fd407b68ba4e017de3b4957a877b1080c2f051a1c6ba5551048cb481dc419bc348900023f1a70d2ce4fdf84b8eb9df6510e60c22b079c4043120119812f49dc52926d915c2b2169114b646ed29e0609211eccead0076a416c002b2fa01770a7fa0615ac3aaa63748516f17f0adb09130a980a3838aeca18bc5dd77954a53e9a51be0a3df0aebace697fbfda8fe68b65ccbacddefdcf601da65de797beb5423e9a2f5d12d2757eed2c530fbcf9ffcc5b2bd4986cf0458d243576d4f8d11da57ddc9ae961c6872e70edd264ac65ecb3df0c2b8d308d6fbcb75b9155cc26b355893443a58b31a7f3a75599fb99e50db65579976c55da23a4afb6a85a6aab12098d1b62d2194d74b7b3a60b86c12a366798babdd9ea9756b42a9192eec3eeed06fbf0bdddcca042c50c0194e18332c69421a68c31baa3cfac4b57e1f06dfed9ec3ebf024ae424d10f61cf6bcd6a7f6cd17b20d2acf6a7525b43a544d622fdb5b224a5f740a42246943c8c2fd1bf50cefdbf507873ad94087bb652229c2dcad67befa3f7655f53de2532fb2db942352c3dfae3ca9268a88665139c9344951261fc9277c9d1e37fa1cfe10fbd4747f86d32fac2e13b9917dba39cfba29cfba2f09de0fc4993626c33d89add274a193fce0edd3fb22f2cef926cbd24fc7368ca6f72add03c4ac2e13bc9b92fc24119cb218cbf7e964393063d96b5a30c1acdbfd1bf59223bab2e9b4c5e5aa593ca3e4868565d299b31a234be343dc2bcd336627889a1274615e3bb6f6ee8cdf5fde6c669955aa14fe9055e3aea2cc16c86e52c4d01d304992e3bc4a0bd048004448aa040aed140fb73fbecca9f245bf993e623e54fba7d76c5f09dc4f06dd70a11a28ab7cfb7cfaed8c2dfbf13bf471eebf44be7579cc5940747acb2455569be4d6687f287def7dd3ebb3c9974abfc921e83eefaa4ee3d5ca64386b8cfac0bc98f85e0a77456892b4539ee1ebcb9f3786d4c4d95272b8d6294b31c83f2e806e247aad62659fb82b1f0537ce34cdaa4200d13001105036cd077809d04e80691d66b2608d513021d700446741b33ad0292259e4075d37ce145172a480117345b74d3a0a09b468b6e9a2c684e1047b5b30faa61d9048661f6fe1518be478ac49c556cce07fae8eba32fdc17b93efa8a2f843ffa8a1fcd9686b3f3a3af88ef7f1fcdbef4b42693f53f2b3f5ca9a4b53cca2c27bef199f7387bb1f7bf5dcad670ae4275f39344f8a32fffe86b562a44530023badba34cb24799cc479af4e768d21f2c148045cda4b14963b02b76982efa933dca247b9489962068a2e0497f729228d664927a3497feb119efe370a6b59fb53cdad9ec2988f112ae56a852a248672beb37f9615b338dc63e866996f28abd334cbdb791c6eced66675428769dad46422e2197f8c8eb0fe524518cb7af9428563b9b579542799486278d75391daed6c3980a7761ecda8c3f0fbdc7577ed867f6976492c7db673af384132350a17193fe5cfae596645bf4f466d86799edfdb2bdfdf43cfbc13e10663328619e857d36cb608fedfd037cf46fb5b7cf343f9616e67d1f8865f47eb0fc2118bb59fc38f9d10cfb8bfb0afb68fe6886658fd29e1863bee7655b675eb0712237be11e360ef8fc49cd50d4bdc8a0600432278234b1a5d9233b11fb8af3d941450a7a8544a7c94782a37292acf7e88c5ba4679f643eeee754a023c3729cc0727c0a287133a28f199bdd7c3014a7a9c086c7ad64b05783c691f61643c651713f9f06841135dfaa7ad364de41e22a0e32b25f169f38148691b1080b9e1e5026a1db580bcc7739336089e0d088874cb1b0e1675b4f083046614e008160d267cd122c7e647005f0837365b70c084b0e504590a5bba1b8709299070d1dd3925a460730c2055595c701b264ac0305aa5b78ba6b100cd966e1a22ba692ad0365e9eb0f1d28566886e1a217ed050a0bb939e38f9e40df67f73ec9344fff7f533dfc6cb0f9a0948404b10516880c8d29386668a8d07c8687ce377cbc9dbcdc603583acaa4cc03f3fe9267f1916e1b0ff858628d25ccb0b7bf36cb2a78b3ab70ae7f731a5fc2a73d4fcaf08d5dc2609b2e46d41061d3c547171edd3518982140960b588002361d38e24193a569f5d2257abf9f1fbe6dca58b6d5d2283163eae59957ad27417bffcaaadafa184bcf28ff0d53fe244182eeeed136493c914406922022891cba553e74f4721f7af272157695d2276f3e7fda6e9a1fba697ce8a6e981c70e56a620510211708056e5e5d1f11586f114a1cd87cdef217600432e3cd02aad34276f2e7f89cef8e89623061b24b2c81fd84356c59cd4d0028d378de7d96c4cba6964d348a16e9a8ea6a3194233e48e3b66ea98a923d2c0984b4bf3a4774b867e5a4d805a4b908a94b098a167ae68a1674a3053848117bef131b06383012246f4002f790a158d80626344ca8801747b9e04a2c99beb3d2a976455f23c095495b22dc22e4f0281718110ba3d49b34f4fb3c0025eb28d05ac74871ead66d95f1a14e463b3050536450c4002a12e79fe937830c5f773efb323f452eab1d9d2753b2be64be6d36832f648f7eb7ea8f32ca15099ff4ecf7e2aec2e7894e577954e11558e8e5feb39ee954a8cd155465c55c4553a523ac73b478a449dd0cbe5e4142982e9928d5d70becce7774790384dc63c2f85ca4f63b1304dfeac1ccb661da6c9d80a77f73fef6bb6ae4be938919cbcc5146c885341b912254e45c789b84d4a8755f865f4e6bfd9a7b9ccb79b95fd7579b514c85df06871b95a8bc32ae5833c5d94165152e7337bffa3defdafca5c65be5f6e89bbe091266319fcfad96796055bd1db6398df57cda75e71a6f826674c93d42b8d5641b779ba3068e9954b8f1dc3e2cc7b8fca8c3b9afce96832469331a79e57fad3d616ce49222966b2348bf58a81b8a6052e4d0071c40608158008a1fb87357e28e3872b9c855fe52c95b3f04c1126f460b32442f704faa186279512c5ae739bbd028e8b704e12e516ce0ee57e5617bec92b8f28ac064c0f45b8c70e363c84a184fba2595d93c6aa92cd606bd29f1a356c32571750c436991dca49a218b1e3ccfa5f52fce8ebfe0cf2585f56a98dde9c52c96b515e2d0dfa4993622871d7ca68fede869dfefc5969cc257e3a6325ced4c7424984729f955f9f954b998a27e6d743cfe3a4313086278da9306ad298e39b9c7bdcf288dd7966754c3df0b63c1e4df993946d912d9af68856e9a43fd916dd97df24dba21e3c39393aee13c3ed630a9a7b1f533cadbee7c99aac7da030df8af3dc3e671eac4489cfacebc4af16e623063ea414c9968c295048531540492fbb5628683e4ed65ef36ff25ff3ff8218bb80b0007145cfc66e21bec91a715f73046de8367b9c2fa34b5caa0a72f9b5b90b65337b7f26a3332afb0f4fcfd6bc3ace0e29d5bf62af90bd7f004ab4642f0dc2b6a85ef0677aa085a204ca0844402a105298a94112e166670e9b8f88951e423e5cf727bfc62ac015dc2cf2c4be9ea8c8128bb50a4960135e0943c77110c98300c346038a40e3072c68f01044b541b865279834e90493725fe494e86e3bc1242c617682303b416c27886d722f2cdd17d809da092675c4b15902c35953fed03c66a15736d9d780b08cfd9d5958aef6ce6095c232f8d1d8a4b10a56f0b35d9a15fcfc6110c39e36c12a39992bbdd50bc696a82761dfbf0d276b19276b394676565d33a3991146ba5608e36ae9fd59959e26f1cce893447866942b7efc1403fd3dc232cba099d1acd449f8836b5836c1ffa13cb2b1d6edd259b541322664ab980bbafb15b127976e577aad385f56d0339551efcb2df1886f3878cabf1ff83689cb5582367806eddfe82be2c7587e61ac52da0eb1cbc91b8bd5e1ce67f3bd866593297f3c0f149af2c706d9972daa4a3c623550f090000f20a850d12828b589ca2b7cdb6781800089b406fa570b622c73ef3b3a0e8379cc347604c9ec2f52473149c1d2f8c6088038df558332e078d5ba4d37a0d1dd9efde48dc562b16ef0a1bbc3b7b13e4b0f577973f7096e40e1da283ef8f4ec105170ba6f368946abfc759e1c0cd66082e2a5bb3114af4d5088f4943f4d4f74e81e8a0003e2928d659ccfa7343dd8bca691297de9e6a1bb7fd4ecd0d77e4a44aaa5d8a3b61b58270cf6d59a5e4768495ce01b33786b05212347072963420729734337120bdd311060862071e4749038987490388ae8207184d141e2f0410721a342072103d441c8c43a0899b08390e1d241c8c0e0841d4e50e60520657c20c34577f78905091c7577cfac208709a94b371bdd3c4052f57c7af38f0d5658ca03e887470f8f1d1e383c5ae0d1c3061e4348613ad28126073caa697c230e903146471adfd83e42cf65cd50778d931a665e5034c50d13d11bbdfa51d3240662d8877fe65f7bef1213518d690807d350adbbdb5947aaeebd9965ac1e7a354c3f21b92664e66bf8a1060538eb6f569641eb2a9f954aba8469f78c0b78504dbc709171d5c01586fdfbb96a7ecfa4a08689104f7525b9869ce50ad2a48d2667b8ca95a8f09b9a2ca0490e98fafd0f66330ccbfbb6080826466c214573400b031020f4c5fd25a3d09b42551a87358a889f1e59729b91c85064f57364c97d566e6429dab01cf258adcf8f859eb13caa2e5bf4483533f0aed29323a69878a2e8eec7e050d1ec322c18acc8c89584b4e4098cb56488204c3c4033409a0ed30c3998173cfa015b70b48ed841d2d5b06cd2b9aa4a243afe8519e59df4bafa1bcd4f73339b42c5ffc20cebaecd3229d4d1e80cacbdbceb7c663d3a69d30c5cba632a7c1bcac39cbca96cf689abd2ac4a33ef936c110c06833d71721f6662195d0a7ef56f13c66306043128306104129c2146890148e8ee26a10914ec8c5087aaf66303b2813811471620345657c1e5fc280304c48d12ccd8c93b2fdb4ece4e096d4aa2834e12268915d9da0bbbb71b976e8cdf839992f81026c9dda624af243da624deddb0ff599210baedac5258994ea3c3f49b9064e179d24b7723d9d2f829121dbcee4672d4b09acc7e4876ba1b89b70c74846f83c9904577c3bc744faaa5730d93618a0c418d6132a01acb4042f791326d3a32e648982360ba1b049a235b1a85361df1da6d9ef2a77b660440aebdd787139311312623b51e130c5a4c4654353324311999b2d35d93a4bb064977cd901a196a33b12504a2bbe6484e4ebebf54adecfb3a10ae9874dec03762d8fd0f859a15e8fc2fe4e972f2f682f7782a276f2fe0584179f4658ee356ba2f3362ac718236e56409ab94535a2ff43c82d276d718e9ae2952b30202681c60abcd1a0659acf91567f4d3167552d65da3d35d9353b3020d269c283d2606b18c68648a44daffb332ec1566938f930f85860634ab15cc8c11868a0a26a0d04256c159a6339f71c244a4892e6284fa1a3338009165a6015f835313bbbbeb98d4c033dffb98f45a33249850748861425d81da407763eaff85d883504add5d429b502d136ac7934b30130a05d3cd0f6ec62ce9ae5975d7a84c37b91a22606682689a134c336e74175d9051230210244c3144c9d7621a23189248a1ba6b8644dbb5b3b6810986ee5ead5635a91d7f9cab5ae1948f849348dd3528a1992a6880e8aeb999b688c55a329b19d51f2c6b4add9dff8ec3e057de7cfe632c7576925c480db1751454d44262626ac1089bc9c3e8d6c00c2a7423a04d0ed44d5cb7cfaef7645509bb8432b64df21d3c985800405b9af464ba323d2a6a12667a41138da9b1a4cdb4615ac1d5b44a6158d2ee2f59cfb348b95ef08756a9490535babb67f4e8a9a4d1bfbfa4bae04fbc602c85fa2b3f7c14b1ff1205f151b4c9646c7efebee5319625cecfb628d779a3fe5ece8f3178c516cdb7d9a5478a8149f395804ca09da5d32a55455a7c57e56e3949e431e7bf791ae1b8acc7209757e93d8d4fef7fab188823c6a0f739ad3732398b81385219c5f247ca6287531e9555d0ca3c59cb56455b1eebcdcce538532131100bf186c082863b31b299e66c8b5ec816853619cd493130e85a21a4a934b11dca180c9a8fb3b32e71e52451adff592d8a14799c55aa92bcae73f993e2ce31add2d9cc76dd0d0a70f7f1e9915906b9ca553e3d3d375a4bfa5c89bb7b029cc5727f8f7e372bb3b5eb3ac7995610574b1f29cc7452d00afd25eab5be7f27b44ae50761dba6005c117f263118fbd05501f0e96e619bcc0eb9db6432cb20a41e21f868757748e7675b27fda9c940fba4522793fef43099806820aec29bdd6b62e8ae81a1bb7fd4bcd05de342778d90a7f73e36fd48c3f4434c37f1e79c248aa177a9b4510ff765fb6149636e3d70da5b4d8637e36237a31eca6aff71e7f829feeb441eefcd4c1db9ab1ce5d1654d76c14fc96375cd9f7549c69e87e9129df2e6821936c4d4800e1edd261e6faab181a9264b4fe08c3156b0032d32d0404031470a4c8ce916c8d1ad563830d8473ffaaaff199966b484d79a663ad34c4e77e70fdd3523c2aca09ddd6861f3e7fcd8ed592cd887733636ab343592a96d30750ddd5d73c95af2a62680a97fd8dc5183ee2cbfbf77c880ba03053bcab4b3e67dcb627df8654a76987ae98232d0ae6677a9d2d5ec2e09213da961d94408e9c9acffe5c79e2761303a96ba8215fc8109dd1736a78c81ffb0fc55603110c3e694b1fa3110c33205adc84147cfc7a00b06ebaef1ee1a166a56e8eea0dab291e34877c7db67174c8e0c0bc118f63c09837d36db94a1dddd3d58404607dd99e2ccd01ca9834c945e7a2f16a320ac200e3a6ce2e002840d1c62e048011c5c781873ef32818e0247149b37c6d8bce145775fa11856c359c3d94d33821ace6e9a1674370f1a30fab3d9bede4801cba1ee4ed9b80fbc9ca8b3cad1dbea671247a08bb638d2dd5fa957a91b5984a159018f14ca0d2c1550c2c68d26ce7a18cc0d1368957ef1af6ca34c1b61b8bd6d08c10adf066b0347168bd5060bed4a3c7c1becb3d9bfef41998edf835c0fbebbdb59e13bc9580ed9d7910dcb97cd608b8d31366c4051f36a69fda1f09de424910f8eecbb2b499756ab95151c9c9b95457a85de98cc15276b38e270382124331c41e22c6751e956ce7a59d491c103a5c47469cad5fd259b3d59ff734ffeede6674f36e95c7a3e458e20d1d1c1e97156b543808e907c88bf52e851ea819fe5ac9f69ec7e92a8a893429318fc2bab367cdb12a2169290db5cde689cefd8560cda5a845d46b3bc59f7d9cd6db6f869357c2753fe446c33fea84ccac775df0d8cb9ca2679ccf5b1771fcdb8eb3ae74911711e1fe244fc7f0643b912ff6886793ca98f6694cc93329812cfef05b2e658d65a37a875772833fe25ba74418cbb01aa5b0d31dd1dd5006352234babd175c720d74b8d02d8000536f8bae36ae63db66e031ad22813d3e09246678bd2d8498384ee1abca03b66fc93c57a4d178bf59a140d2bd028020d20344ae8e28c069cd1a4fb263fe31be954761ec6fe2f36430733aa98d113432fa9a8e8f3ecbd32ae28434b370dc6a08107688044031766d0c50c8e98419319b4c860838c1b9021c4adb34a79a3cd64182143003220a33b7615c459cf6bc94028063fe81203a518dcc480070cbec0e00a0ca674c72e7f52b53486de4dd6ce57f1bd4bd5f762fc9bac281fe244fc314b7ae0edda99981b88d932eb1864c6d0c018750c14b410c38a5183182fbc00062ff0d21df14f1cc69818861017d8e18211b800e602a216906941981674a005575ad0d3dd75b250de640dd358579562e881a10318303062981c84f1120601617aba3bce2cadd24a6fb95222167cc10213b0a0b6c3821f2f1bab5bb522be76b602225680c30a4e5f50f1c5952fba2f72ba6705595dbd600c96a5175478a14377ec028e2e9ee822d645933854a0c4ec3a0f63f86bf95a9f5915ac5240c7ac52958214c890821e5c8ce1820a131755b828c0166d6c91832db66c81650b225bc8ce579d12c79dafba148e2b8f187f55e2b2ce572ce944fc73222e9335cf37e9995679f31bce411b82b3cffb9acb0367df85f86bd9ad2c625a05673eb3d251d04201102da2d0226b21d3c294451d597c208b2759d49c004c77c7d0fb259cc398bd559c8dff379bbf0fcf5c33eb5dbe16e75d8797c47ce5b7ba3f3b410a587081851558502c6cae40e38a1eae306245195680b1225b81002b7e7477e4e1f9190dbd5ca3516f5639b35765894c5001135013d06002ef8eddfc2bdf9385b55502232588a18a31aa6041153854714345185460a142670a1a4ce1c4143e4c219b42680aefee88333ff7a95ac6d94b7bcf6619b4c4abc4602dbfac93996669bd18abc39fcc94ba32066f61959daf705f3b5fddce579dd792628a9b36492184149f143048f123768f71dff92a1a01918008cc1d603e00468299218a39a24041146114a88eab0378c6f6f318fcef91f3ac32b647cec23f2d51f6308d753ff826bcd91bfbf953fe6cfd60896716090a16406105144140f103858f66c58ece269db4f3afe5fc18cb59c10bce1cd3a0fb572abd557a9b128669e8d303c3f46fb2ee80d893372afbe9c957adef7da55e75cd87fd05bf6b9f10d3fd04982770e82cc312f704932748e858cbb8af2d27c2b49ce812e67c4ee951aec526277e447c932b6d89c0daacf23c1164114127829d10a4417b8f2ed12b65f83d09e4c362bd90e8809e040a4100be60f1654b47fcc5a6892f9ac02156fb8519d6ddafb6891540c00508bc74c77ac1f94ca0c104154cd4989031410213ed65092f4a5e927c208d0f68f9c0079078604cab5498e68f41f198315805b4a177f706b4a12b794c752c5606bbbf494c5561eebdd92f61fbb5fb3356c37f672ebde2e497e481214b9cb1c40596b86189205dbce8027639d279f2afdb7a1fcb9faef3997d7545d1debff2d11aae76fe2cfe0533385bc90e88a0036007541c0883035dbafb63b055942914be3435511c686103606c4089fe9f3ea361ac2a2951a6af28d17a43031dd000150d0809230908242193084006ecc88017549b32a083acfd05bfdb79540ae5bef355adf3d52ba793208dc66e12d3e9f3bddbf92ae20b7e5d18f358e990213163ebd9d69021ce6252e42a426a418917fce487b9c4c1e5082e52b81c718981cb09486cd11d59ab18e66432f749ceea609dafa2c73a8a298cc2b1eb280da5f7352c6b9efc6b67d585c40e1226f4116558dd1161aad1115f3e893b02cb6c1d71a46593ca28988401336618d0a11d031d064830c2099311b9eeba6b8196c4dc1bb113bb9fbf7cc2b7791e8ddd3f9a5616be932348409f77d223fb271790e2025cbabb94ce055edf4dae7fabf6d2a5d8ed316ec51e8a05e6b0c0062cd000a13659a0c723b6b30815148183a9889dee8ea197a3e1db6220063d0f193264487c1bdeb2c496275b86b6f46c4161cb08dd6d439b88a882082b2622a274f4bc1bde0cc6727d1abb1410caa873d94f2bd3f1554cfd12c595c5b214f6e10ee55d2a49c7575d95b2cebba4eea795012539110742194d2b23e2c7ac550133ba3b7a1e755281fc49157040a6b7bf6f93444b7c5e8f65edc3f8de252cd62b8336acc13e9a8730a3bb7b882fdd1d6d6b88af3b0e41430f4142377e1a0dc42d21c07816220bceaca09d499c10b58f662148c0996fa280151d3f9a294081ee6e1f97ab6a58d62630c50488304de0278044026848c0879b1b9f59a44abbae8bf597b494400b125a685a9e680940104f04d10501640a0208103e00c20820baee9066b686e4eeac95cf6c87e4441ce9a379fe95ade21092d26a6725f45272e93c1fcd3e5d75edcc57b1be4d667c63abf3e0befadf2c931f3cf003961f8e7ca0c387287ce0a28afe61eb01f52066043d2ca0075b0f4d786883071af000040f3c3cf0d8e14b775d90afdcbb944e902ba6ba6c6b18fb68065d915669b7fa68f66b69961964b9c294e5872c48225046048488404f0472202006021a80c01104801ea0830708f180dc035ed0a14c77f833bd506241beeab08a85a77ca45890af62a7b37a75917a38d3eea3af2af35c255375afce67b6eb522f9451e7acd057b2ced67095f6368a3ffad12057d77d20ad6159eb7c15f363ef64a5511ca40314930e26981c40c6015238408b036c1dbb178bf5ea3c097aec5e9d7bec96c48c1fc4b8c562bd3a49143f9a5755d6b06ce283fa68f6ac8df9e0994f0f6c7ab6015da84c9132c5a3cdda56038e7832c5612a53eedb09622953fc6baf06c4d0dd3e2c960fcdb1f4574f4fcefe789e9455068460c262069621b034e978bd550c6dfe5aced622e9b46901255840071640846901411d73727254393a4ec493b2cea1f82aa6507eb3b7eb72c0410e3030e570450e52e4f0c59483027208731082d3e32efc04f957235f455fc5940ecac8573e3dee4284c1c2b7d909a63adcd70ee5b996c1d674bd600ad0a2805a6d29c08454f6280de513871e74475c0b073034f6c2414b96d3438943cd16e1e009a0a39b4902b848008d558ab39e5b9b31f5982901347cb5a62b7774479f57cfcca88811f04a92e98a90e98a4d38453833852818e47ac8f5e44ce88ea99cbca1a848c12b9a8b5da7137f62597339fe3ac7d9a3b43a3df4268df14c1aabd4840b010e02381bae8437565de7333be94a4ed312104b499608005e017a31af62f628cd56e9ade1eca53da67e671ec154764186c274f304bace57b1abf4365b5d5ccdacdb1a8e564bf3f568ae14b472ff684c0b6fe9ee9609d3206bcb8483442aafcdb92ff2f161b15e3d336b7b72f6a767d6b258af6b80394c564670adcc4c565c307d68983e2e114b5a938138d5a13c530fbd6ae3f43c8aa357be4f2bb321a6379c307f55be124cd60a4b3bcada376d2dff4d16258dcebaae5aff9877e473bf47f64f303662b1eeb5f72e995557c6f6a392536452296224f7b39aea923beea0a9b2a68a88dfb5428d89c796377c10be0dd642cd1d4a4b92d400d15df3c38f0661e8dafbd3d6f8d05dd3c30e5e6c65ba25ee8b90b051f1c4649bb1d5335376305549e3892a5d5a70531559054a15a52a475568f09945b9a9ca0f13f582461163a62dd8ea59fbd5d430d558505b8195dfb54238578a69f227633a24677d5a6b6684636052f8d1179e19e17fa1fa776674ff0393aafcae15c26096d70ad95975cd02b10afacc118fe9e98158e2686de12fddd486bb8c2f99abc4fd3aaa4229e912c694ca149594291e5b7707532ff2fbc38a98eef82d2b56b0745bc9e9c6d40a09dd31ffed6693be32f10b135ddf97eef881b64c77fc9bc5368b68bb3e591ababbadc7a46a46fd124ff5ab4e6e6522a6556a8b3730b1bb69e9be4589d35d372f4c4789ab96b63c2f318fc86687ad4b77bc56565b29980a63d6b6d45502cdfe7e458c803e3e3e9e47633e3d30d80dacf4a32fd4d0a8fd5073d57e9c685bd0be8ef16fde7558ba2a762c56a5d403679947e2c752f68a5e77adc7229176518765eb32066747713c6fa6c40cca2c8607e3c33732679065c6a60859c812203b8a5385bdcffee73659c436c7f94b3c761e3f36b33e640828cbc9592d0c56e9adf321d1b152ec8cd817f914c786ba5b4e40da709249240c9d19dd0aba06743bf16b39e71a8de29ae4a924949187d54eb759e2d0c3f8c30a23a33baa42ef334c0758d7ed081083001f2a6c5031e244c501548ca880709a42c51423a604650c4ec7d2f3d31e3683c1baff507edfa11c5bdc4fd0dfdacb5791a8eb62a68ee3ccfa077a0dfbeb24650a293e48497280340e20e60058ba63175699aa602765561b4351e966b5b14e8ad2077673b66e98e30631372871bac1deb0a372168eaba1d410ca08e9069b28248852eb686b38e950ea800206142f1eb5b9cd2ea3352cbd2416eb0514fd890e9ec8e0c9104f983c01a234859255a2e1c5c6ab03afdaeb3f2976b453d54fcd28956a531dea97ecad73cf935ffd512c963c253520099624c209490d24213a7bb6aac0d47cd9b5286fb9bc6fc318365c4002363cc08604d87073b281c7f48c705fa472564a07657474e5c87674c4480d232e464418796d8b7c151fcb5c88a1f799568afb7a8b70d10aa7a21188a42092111960684888a125a7a11f273f383961c3c91627312721505183d7ddf1710d37a337cfb6e2fb9fe36a7f2af5d5575bc39e9337efbce54358d7c80e61e5bfe1cef3680dbfadf2ab0d61d662f9d5d0f1da2c9333294b723dd11d5d374dd4e86e277d6a72812651dcfef82aa670b514e52f17916b88c56a6599cc52962a42659abb89f86d762d9838c164034c8c60626322c4440421129c847c6867392b7c9b1773b5d22848bbf26775f92aa630c558a23cf452ab47422d096249cf92108272109446d0114114089205bd10040290088066402afc74f19325623b31c5adee7ff26b47ee3185f2bfd253b44a510e942a4219396bbaaf52a8228c3262dde8cb5771465d55a58ca7d6c9fbdd953815be56deff501efd985a55b47e68b14e34a841030db918daecf8bb1139cbd62b71ab866596f7bd9f451a086080384e06f0a2bb23954e26c56c2dd24feaf2a1f2be8f8f8f0fae96e2f91f88e55d5229cc47f64f7c70765298cfbc4aca9c947451f275b712a39e32dded3d61bae74bf76cf57c7dffb6ea53cf4e0f093c5cdc2ccf96ce8fa94cc9c99b94293c94a784ee8ee04d4d965bac2d5897d259a507b91cdfbc268db1765077b6582674f70c635a3370d19156e90c5c66f8669801b553a63b565a74dad9d9a911edd0b0e3dd3149991693248916ac94e48bf3948486a64bd5d6561215e2949f93b78f666cbf8be408121264104386214e3230408624477870440547b074a78c3e85a967bb1667248d93112f46964e466a30c2a373f29693b7979111124ca7969344119f8ad08a149d8ac4a0b3860e17295fcd54ad3772aa38e53020474999138e08706e3845701cbf07ded96a76dfca5ac6740ac524e203a2778a1f495849715a6d49e95cd00ae1292deef5d57ab5b39bf29b74b56c631e58eb4995864a081592eae644040d22491099272241447a9c8684b1be9ad56dc67578d29faec3f6fb4963d77a0e7f2ebd4306302675c40e29a0532ac829d5a82650b7136aa85340734a2020a0506256f7f91483173160200629a7184e80410630100183100c51062f2c717a819e5e18800b57b8705d4841081742721d23b61983acbf85a00d6bb8d847f387b3074e6ab3ad97d230665b48727239dc8c938fe15abc8a13b90a2cb880852a58c8e1c402664185130b21ac208315905881ae50e4a44299930a635410e2a482014e2af038a510c529052c93c67c858d7c15696c0524023911ff4101d9225fbd8a948c806041ae1f589416d18ce2e0dc6f347f96651464f44279ea076584fb4a8432024afda08cdcf3242b0534692b56c1ce278d5589420e28c8503889713ac18b13ae9c4e507242905301d028c00f0590a7020831010c139030a1869309dda99f1f6cc46d264aa11ca3dc71a655fa9eb5316ff9cabbb04a15add2e92aa992b44a63b5140fa088d3001230801f804e10344e415e700ad24310a5ee1ea14f41989c4a80a3041594a0815309b8127c4e25fc3865713a8de0a4c3c97512c134839309042713ccc46363039b246c8a4e36454e2490712241cb4fac208dfdf8ca5771e20c5a8bcb11488a28d6f26330dbef6b407c15511e4595c293c67eae5d79b77258b514c368d2d2669593c66a93c662fe389aabfedad9941d15c0152701e4208029027861041d9c465062040498fa34c2d0083f4e22e440042544304284a153087474a7a238113f72224e44b39e1371229451ea0865e4310acac8a3e749998ee7c9d4518ac869d6431911a18c5247ae4a619413392b7c2711678ac336e34c6f3e3db3525b085d8a42c062429f42e86208a8b645a7008411becd6f96a8f74e70005800401a27004cd1dd51fa0400d909003e27206b9c8050e004c4e7042484c6ff85299d94a7308892d19b20975f2b3f96547f84a71f379c7ee89c4088e3044218107c388110e50402cac719271f5dba5993fae79dabba99d1745d8bc293c2c2b7b158387c2791669b6387c3b775298c0adf96947b1f47f9b1e7a1ea635b3bf9e858ebd4434c0bf34f3db8749f7ae45ee8538f26ddddaf530f7ae251a61b9f787ce9eea6a0bde1c4034b6ec9fec9a9a6cca9a689534ded54f34204fa19cdf2963fe9447381eeb6a14f34359c66e838cdbc4089cef2874439eb0f8919bcd663759d0f8956362476b74e9f664e38351ba7fec0a96ba7ee4ebdc21d34b8838a076de8aa2cfbfcd3edcb3d8a551f9db922ce14cb1a823f77cc3b64b0238eeeaee0fd3c7365f9df5f3bc0d881a5630ae51fe8f3df8e9d2057cb8e3ac2d4d1a58e1a4e1d293a78e8a8f9c11a3fc8c00ff00f52c8f5e947657f577f319da3ce3134470b73f890e38b1c5de488d2bdaab64a582d0b95b1658a9489a1cc0f3260c848323b644088e38b3872dd9d42a95878e56e957c1559dd6757b63aabc37d6af51705cbd622dd4c2f18bb51ef6b705c01c703e0288203d5ddb9cbfdacd2dfc06f746fbcdee87963006f88e0031df860091fbcdca8c30d319dc28e33e523b98eff04f92a56231df0f619676bebff0ab9c1a5adc56eb11b51badd50a10d32ba636afe12f5da48a20d0474c7d412f550f331283fcf37f5faf8b8aa86650f8ae881941eacc00619dd5fcbcec6b371840767f0c0071eecece08c1d04b183243a2843075a3a666b6f8d783aee2b6c66fcb10ef7b5bee761a69fe57de5e4e4e8d895ecda9f495ca3d1da4b9b5d95a53f6d4a9a7f2d873e3d19d3a1d0a7681665099b486428d2440724748fe99883ae65ca010362a5d6e69bbdb31cece4e0c71a62566b6869adf175afd1e4263fdfd648a12785753878a34b9cbfd461896be1e02885c201ea961913a67b4c97a431b93eeaee380635e6479c4937b0a23baf79a8e413d7fba0756a4600002028931000003020140bc62332b16c3ee9fd14800162b856b05ea1cae33cc821648c21c400000000000000461b004c9b09795e5624098c79f82d8f62a2db4da8cb9481beb753c7d4fbcc0011a86a0442ea728843db6e9ea28405b06369186c3adf84313ee780fc84c70dd954eafb8e16a8e4389d4f1da75f9f31a087b47002345f0c1bbfd168222388e873103723ea63ca1e609a996a569696e0a3f60d3a08c7bed33fe313dbb6cab83436bbd4b8b9952d20984220b5d43340e31c519134d91a32b30f0eb627444280abb4106955136c0a1596c7216f454370f684804fcbee4ac7a7682ffe0d3458cc1405c2943dbd27b3325f10f50d2f5aaea27f2d3b72e4adc5bd847ac9a6dfdc7c27041afe45d39257f942171e1a335331236d26797a7863c63e830af8a3e51cb410fa0ac629fd6f4a50cbcc48f437a1c08bf086cf3f58163f9cb40e3945e635adbc8350628b3b7b34966a4b2e01bf64ec1854e4a8e051e4bfe512fcdcced905a14b317ac6a40f5b2cbc00f80c190bd944b6bb630ba7f03118c8a4273cbd22cc8f9e6087bddb30ebf7a6b6ffc12d590f83dab58de83b9a3782789ca57a4e0fcc97bf2ede6fe54c018879a7dbac20827cd0cd8d97e935d4be20f409bf7581c2daa8bb29a1107bf20d7880db2d0f844e075c715f4eb36a621ebe4123aa00c065e400bfb096963198a776e239c4eb1efe551a5c82b0586a3f708b58a917a50281ed99a5f7e1e5e2939348ff6fafd01272f01f80fb315c175e3f219e0aa4f88ee3094e8e263e282c9b577ecb4e8a2d9d0496310523ed58a01061e5acee370cf5a07ae2c32029e430d5fa0cccd63b5089984902d232b511ff0eaf841fa90869876aab058e62c0870d821609caac5541eabbb8e42da37086971958920080bab497b46cb2b4b68a49260ff7573c5c9d89804227f2851aecad918ffea473d6ccc8985ab2d3797b4b868f9e5d6af03906a6027d77b8d71126b606831de9d2036ef4ddb4d2f4ffb2f3f5b5226bc027741a26d284f4251ada6b49e69f9378b523f9c12ad2b5288de3218940d0866c2fdf16cc6fae6b6c14deb20bab4735188e10b5dd66fba11123e901c016571bc6568980c9d96d06a1d3181a3a6ccff54eb129946118158fd231f2becaa3123e968f6fdf47ba0de7d2268d9c0903346c1cfa6df49ba212a7a520e919f5ba354cdf68a17b40caccfa6e7e030248d47b152b4c69a91594906cfc4e562844088dc11cdc1e242e82275d6da4b42adad609c6b36451a54abf7dcaf966c0c7a723f476e66e78f61e497f9bc700caf7dba1933ad0f604b6da4287284346d1e129fabafdbdd33bbb7a329a50bd8a029ca7472185f82b83e1e5e16d4a754b7fa3b3ce5f9761c0c7563518d204319a113d57f10c8c30d5714727695f60e7b8e66bf57a61b0b7b0f366c1791d5fbf3ee4fff9cb26c000aff73799c37f20ff7f192b7afd4edf03f814d57e358a5c53422421669ca69ce5550840b8475b1044c1d1c204a61b61af3ea82cf487e90bb4684b045599e9afb1bd551b2f6f1571255d2bea727d2cdeb2bc96045e717d3c866a2afe57b57e43f018e35c37a231220d8c2e3b74a2fd2bae8cc5cdf5f295a3ed21bbdb415af746739cd5a5afc47932751450118c85348455d352f8d61138536c4f6eac0829a3d7c85ae1dce77e8477a2180176e6dff21007ec543ba808a8ee9014fcc8953ae3228ded0297b856cb8babf4bccbcc238e5646c06c88061f154331648b9e51a5db10e04805b189393d592bf228a6764f3fc123a1f6bcb6a5c7a0b6aa078491fd3a65b78381de1687be99254ec0937347f9568980e70652b0fef6901549db3442fda73af177c3e07d5a6beee297f16a4fd0f942a58447b84fd2f8c1d8f721c126c6815bc626cb88eb2d44e92f2cb828aeb9b5f82120e6f7c5ac12ca49461ae18b69806e75305cddd443ebc832826b65fcbbc911366466fd5b8621399cadf3f5e59c04d0bb89475b7ef43ff753e0867516c47ccd4881d1921591c9c102a82371eec375745867e51916fa99dc2ef666257c8d665e05d9098a59788388babe2adf32103ec6661d728f40c7aecc52defd20a2a640107d9963c0abfe1497f9ddebf50b0fb74a79d9f683d5b094760ca50883e0b9f6ac473e7b17535ffd1b6f0e1991841f89a8253278c4953d68994ffff131bc4d17f5f3db01e74df94e0bbb7a21b7821b5d8ab51ce288be1a8cb9a6b6943d252bdc6535a151e6693030f5faecccc008e18042b78f14b4b082db325c21f58a5c85e18248ea611059641e32f41414727278122948112a198d05d14091e53d46074dc24c7ff3b3e3ef8246c8067eb55505655ce1ed4c27ba980a17d52fb6f41352802a9bb3c69248706bbc8f96cc7b5fa03c1686a9b24f82ca13a9491cb727baa70f123f5fe141e90cedd2b2e3c112cf6c86699d24c829ab3ccbe3a4d93b891e8bb57e3dab70076e508882aba4b2e0a0235922f89926e5a59bd352b65343e8c3e2682fab57b36cc73b18141ad8d69ac1149820456831eabc3dd96f787b163b4c5c1e7c5c4e4219c14760a74eddce611a3a7be33fd005236b1242c368becff57eaee707e31740bd999bc1afeabf6508294894d57b3eb7aac9f5222ab1b1b314731cbc2b38a914c266d9ac507850da4109eae721ae79ee1b2c222c20306ab08e04d7af322ee1382f3520da815a522ba98b7a3b82eb643363bfbbb2d4492da5980923f37153be92be0074007448856a67883d0044b52c135dd7ec6804f2777ab7eb848773adafab7f2eb8b143ea30cc60c772ed3d6c97f38ac89cecf23fc41b975080550e7b8bcfb0937643968804a77d67a1757e6d004bf122554b31cfae2e3e7afcd5226e5487be980deeb679523c47f5b715ff96c69ec96f56c5cf357b06ba36c2afc30df38c1f57417ec03ed40913d6c490e4cc3f70e21b20913007c888aa63a7b39bd732ca1be9c8482b151b7c2ccd78c1db6c7483d6c10f7bff1dfe091db70b4b1903695e0f56dcbadf44e072d3dd6262732ab6d0f75264f3d6c7e05533f3988b9599cbe3c4638ff120ee6d0859ad23d1295689043680d7892691fd6444ccea62717e8e11849571c493b2dab75e7b62c3cab656430ec5b6bdbc1363b7a5cefa14ce5a4abc73a2ba451b333158e906ce1129bd9bcdd1e5b524a8d35d43c6f44c633564bd7a2ec710cbe008e89f9baaf3cdd27b83306d68ff1f85598f4139212a1daf97a94d0c12b4d0a4fdfffdcb86cb3a4dfdc78911fdf2d661057422739c62781c2d0985d66a70e40df538c2566ad29af2c75c90aab6aa4f1b2244e2bd1ac5f9f17f857f34fa692e8a921e8bd5762c74db758e23555ffcd8c17acb49e3f6fa41d3ed2bc42b8b2711fc59d0f4b787416f30f18b05db9edd3faad4db22f21e400818c6ac4ff389c9acbf67242b0da4652ac9968d101d96e2a158fcfb819c7d6a0a44607448150a16d1b5a7c3d4f53b09f2174d7f1978512d3f7b1bbb8d3d73c28d627108b76cc98403cf6e52374c0b976c54001eb770d821c59586c4c3829a9bdc765c410316401df09282195f8e2cfa066a3bd912201e8423121ce11b38fcd9853d39991269b63d2d0920cbc629603b68639c8175808f3244162b5fbce135e046104264f16a336f290bf9b339e6ea99f0e9176d0c3eeb11635cab78bb81d04db82ccf3ceef2fc97ddefb3b8ea30bcff557f003c8a464687bac1ed9e4d251cdea62dfd71a2151bca4a6bad751afd2e36fb60d4f8f69409acb329b5e58a8418242130bcc76cd4ef2eca071dd23d1c053a50a6594057e1567f4ada5be2ada1f1e206c39f7b7f80402e3da83c594d87ccce9f0fb74a39f900aaf5d8c2db75db186d4a3f6a4394f80193d7139710b50a59bf463d213963afcdb5058605e454f6891ba1d6c6a3e1d1046b47b83537a0c44f3405e81cada1bd7dace161a3ed676abcfc717ce3ea444b70c194899ccc8d3854d2d2f9445f1b2d4b0aa98da0b0c6236c8a88d1e7b0d38222057aa45e223f3927064629209da4cea3e7c5c1478817588b20202c5d1bed513a0af75aab15e24d40c8ade1cc8c066517a460d5c65d137eedfca6f9a86449a200ec12cd4ca441a724e24eed47e21c414093faae6a9c8b6ad50eb7f297d646637a810cf7f92c0d3f2cf7e8a0df0b1aa7bf03aed13bae12fe6a58bf1947ece4c780918b3b7a926125b1610b56ffa57dca835baf1b3f54c82f33aebdb9f1f0c9840c83e52b87304bda75842a3f11007bef835e8c4fa3358910e54d7c1208fc2c750bdad7e36d0bb3d2a8d60a5defedfee6fa28ccf95d430085705e03f890b5b2aa871387b1e1ec19123a6fdb1e0d3c319625fb7829b804d957a0fbb5f7f926de6ac6ba994a8e857e5e8cadc3885a4a0f57d32e040511fc3dbd86a160765cc251aa9188b267a5225cf23b20ab391cf41a126d70b0867016a3122e3f971308aa40eb913be0750d3522f03e6f0642f503202a4706f973392abeb9f161b5da47a2d82eb47ba57f4110ff5fe78366feeec71fc9fb21195d8ff39228cf55f4c0c2fafc778e1ed5e6151ca79d71ef52ae0a87f77015615658d9f4915d35a5f28d2778bf43ced6c6415981bdaae586ad182137c92b1b65ddfc9cc0ca2fcce039fa81e6e5c9adaa7dee49f4996d696204042871355126cf3d6c6cbda28c33d91fc311d9b870b6ebacca7a96d6d9467e0d4b366a03c535c1b76c11418917969af3d5040807b4588f90868a4b018feeaf743cccf0e72001013396fd42102340639c8353a9381b9a2797224dc589ab87e6d184386814651341e8aa616742e8972eb20194156d2c6a0001100648761083c26fd712a3c8e0a9167a70c6b8da4bb00f1b7ec03d352d2a3ef1399cd5cf3e9d24f970f773aab39edd1e9f6f572203d272b2a361977c81856a0291e106a298399c6b6c342f1d661690a3fd7a4bb6d46c180a99ef183c254330c2e1b0398110e7f797ff868dc323c632afd0924f195c86965285315e907e92c7603535db1ef2a7ebbe6b31266df92478a7d9547246af57067757511f6340dc8e2819414add8970566ef7b231e9a860fece979579836775f3f27af5b0a106eed61c579fe37cf4e40fe09e5d1b3b9dc9dd8a344b3baf93b51b6622b4b94309f6710c0fa7a756a2aa4d90102e4cb31b21b89e5a24a8bc4a5b73bec3a56bdfb82101f80263a25b70f83068dd8d1e64cc98e63b3aeeccb78d6c9e3878b62a9c41abda9f32e3164453e971e6acdf7f29f55818e7dc5cf8d5c1a7bdb1896fba395692a30dee4dfdc509a42c658e854c1bdba8dddd1aec59e43b8a2c0a6d0fb8865c98d269cd04b978eefcf844f76d99251a999e2df85daa8352343c13bb49a0d681ea4c513829e8131c939ffa81a34aec3aae07773adadb9660b79ee1f063b8783e5f4a833a405deb1f5a7991f87d0bd131d8f8168600ddbd0058c3eb0017b83c1b05588996f8ca7ce0562878a9a8266d889a03b5cf0f2fb63be78735f9544ab4cec7ac59c16dda5e488b185b62bd528e9e19ffd4a52e5530df56d0f0a407be88f4de93a16986c0ed4e3e6433a8158e71c20d23c0bbfc107c79526e4557e05e681754b0571f8e8a5f7b03bdcad40d29fffbd6ea56a614b41cea3942dd73d6ba7c347ea9471caa6ebf7d7ab348fcb822b808929cf9dad5741f9556a6c73af196d4bf904222325a45a9e906976e93fe647b8d8adf09e5861e510a821b54adc469d9d3eac678229742a0312da848336eb6db59955c445d3f376f6874057af80d7dec8bcd18ccf140fd6b0831148c775656fd9fdea9c539f62adbfb21f3bd978e3926f4e64fdfc806779260b650e6d6cd0a0d534449e428a18620c98e070876f9a3daa5e5c5c8363ef1b6f4bacd049ae85b09707c1a5eccb2b26e5deb424523ca53d307b01855b4b62f416e2513eb84ef45f6a4f2f4d6d03edbbba4b05b8501561907c58cf8b106d6e2ef3b4bc1605a2ab601c36be51116a617b2c2eeed06e44027bc7b1f4cb023e3aa5de92803782256b75c5a0c7e9e30ae6c0812ece56e00b160d1a47562fbfd22db64204ea2657f713ff995cfec26972b056dd41671e17bd693c81feafbad81f73022d5f5e955f13a1de1a6b2f4fc4b975d0b1b21b4a213e4c67850abd75569df51a3c516d11577f2ba23d320b1b2e852469f02d762ef1684d514a8de7c7c7c4068f2475c52d2058964a6fe272491712c254e183cc293667605b9afe4c7151d6b79d3c4eb2f493e2fcb1afe4753e212fea6daf32293597b00035c4a0d08268ed71fb9deb84b5e5dceb2680026cedff5902994a259c44373cf7b15ec29e0893994772278f74280f5068023a0ee7b7b03393f0ef95f6acf13b6f4f3d3543124c867e5ea070a4fd85fdb7ff604b8ed13bc6a747abb9843f55de90478b66a21861d86efae0a8e53d0fb17fa9d055afe7a9e2c8c3f007c874fb6814077fc863f66f4141a48600ff7236b7602666a599ada2d22e6e0a968c803153acc98959906c20e6aab31be32554f4719a89b1a2680d12e9dbec0255699f3ea87214c999ce0c86fb1a23d7dd6d40c225bd449265bf500f6d6a01d7b50883eb7e4d32e0e657b50e39e36e1118274435dbbd6b30ce624509cd7894cb910836478f7fb2a15611ca792178d57f78984459496e97894409337b6fba4fa1d807f21a1d930801ec10608091e3fd4768f5f4b513906c11c750b15e72d4e6c55ecc9f87ce9f4100a29ed52fc29d936356e72a82f24966ea33213db9ed55439f90e7fc720c516a68e6a740d0c08cbc83f5aca4259cba5b2adce4b1fb689ebfab5ac149ca9957a6c801dd93b64fc75b4fa8f9ac3930145710c63f3e78ca0fbffd058d447b941815fc38ae182c1ae539b253bdf1d3b43829bce332157d12743c76e2a30826cb9de44a8415097f876b6822c22d094d35618045444bc515aa0ca28f3f14c24f0fdc1e2d3e0f6d1410f37c88e1057c35d679908e8f50e40c91e350472d468d34590ebd05a11b88587b8da6c8a2be46370a9bef2b2d42cb30e87904b5f6e345d335336bdac3f37781f8abfe29f85b9a4cb8d450a78cdda1be4a18b3f31908f2ce85805a0365dc7677793ab8d68b8c7af6438afbd211ff9109f0d322ed630f462f2f954b63d2408c0b2847113a23af6d434d0e746ff24299f9eeb1647e1fa4da63849f01379673dcec6875d470d284a24f9db9ff890a47b1fe0b55755fa998a6b32b88102dbc84f4c5796e7fd2334b6f15335baced92ff0a4cf253a6676c71983cf893eaabd3e93cfefadf56fa4da19a0bedcc46fc5b479fa7180307071475cc03d73cb686f2de4c9fcfb87d14d1cc2bf4d99fcca7b2a3127d1d0738579b8651cc32e3778afd3c698c10c4c1bf2d64a1e41fd4445b1cd10ad427cfd91d0630578aeab84ab548d00ad4a03d85d04edc9f4e8def432ad47ec3ef7ac9d20a44623a4aa3b87cc3a07b14fb0c07d313d02d1bfc704e01999139813ef1586549aabc0c1f984d3cf7df11b3e19ce06f67e36d4093110303fbf0f4668d8dce7a512ad94bc7f6008c98c3b6c036a0c7cb68d983a3c39a7e0d0d63c8a0ee75c70da24dd1d3484904804ad6e1755c92148c51b8d9e90cb9289cfad2180275a015408d83bc7ce12207bc48a61d1b9519839e081390850d51319855e220c5df296c52f1fdb01e25db2d048866b58de962590ce337cf77f986eac751857f1392a64f79707a3ad42bf6f1186414c7514cc5a5e2394c4ce8ecafa598f4f0740b7e06c982da5f7f6c866e4f12b07db104ff3f264504643826048cf83355b0323765b9330293837056746fa9cfbfc423e7eb7e96d0b784e53679e557bd2e24199f122a1c849de09a72aac58c58a18d1f44e116fa914c129b325f1c2e01cd00a4462d68f2d5765cd794064c37e278b90f351057fc2beec202c946bab29efd3693ca8fc6904c81a8ef85de40e3c3811ac6442ded8051ec73b2c8660982b8b271145b8d68477764362962880474e9765358c39295a8fbbfaa0c74cc2a2081888d02b6f094f9d72a9f722fb1ed0731a00ae9d41937ce9a420b850066b515d6a96e209c03433857fce0c51bed1a1cc8e8aadb4a60c999b8a894e7e351f5d470c74a5ce15c1617dacf4cd5ad97d738365df496fcabcf37998b52604ac87304a0ad52b5ed19b720b66216f59c48e8ecf3dbe906b1b271826f2c5872c55778ba6cd9a6ea1a42fab8ab515d39f6c23ad107179594ed09078d4ba3c8c7e104adc9881fce03190c68cad30b398d88c24f4f801f46252b6f12343084f844ada05d13e1b33c220904e913a2dc63d3dee26f15c4cf27533a8fa7f8e30d3da3950f93229f4da06748b773c07c24bd0d59a0ea502741418a980389a52ae296a3380219457e9493b46400291732e3fe7ca259a25e8c58aa173ef66abf170eeb4bf1f2e591b4952182315a9860a117c97c3ea7fce33a1a9334d1b7d7862fefdff14f68c0f1606f2c51524bfec7d4297fcb2d3100d1a7aedae7e05333a16448d3a7f0b4829c60b330e672dcb38c356804b8790c478ef74f61fb96e3c90cd01c19f0ae0a6094b7c3089c6e1cc396573d8c0783d561b072a6a3bac71d8a391e69be35442737055691335886d5bf2b264b7771892920140ab9c1ba4d7fd81c6f561e8e1344662c1769566d87101806eb9e1b9e5eb21a7b92c2e5ddc85d98b758e8935a37dc86dfb6ec9f460f80feb6ec7c2c5b929fd6faa2d7d692377f3b8e4bb33c898942c2c23e3a332f2796e88e22f720af86f8650e7710ecaccdc5879bad1d5e46c41ff96ede80bc0b69e64d3dd167915d149ae8e7c3bf8cb5fb0911f2794ce0bc68237a881231990eb324cbddb9b575f86cda0678d39c0aa054a20b2521396f363198fd1acffcff81585cc255115c2fbff2e3bc218afc2b4da254ae2d337c4e1faefb532ee53d8065161495441ac587cfd391717979bfc274924a39e4dcd2554ba1533a888da1cb52a47ea8e082b4a18b86e48cfe3acc54d2f4c64c82d22429eba88b1e9e663304b95df3e22509666551bf971dd3cb5fc054a82b2e0212600e549b476e726010037c6615cab92849bd247046008e9dca88207ddc5cc36310cc88bb284d0836a66cd231340f36f3ff6fce1e5bbd74991ae4364442d04635e6a9d8fcfa52a4425ae7c82df238a8be7e63217ffd6ac3104c988e2894caf1a12450da86b29599c4fb17097e4f9a8e7ee167d164d1990ad117a08469aedaabac3c919c301b5babc1fef4e135382f3849deb3aba67a045319c5b2d61d8427f138d741b8179bd8f6d36e73e4baabfef963e208ff419e65143c7a028394e227c53502eec93591522dae8726ecc0d5baa77e73f5ac39707c27fb1004ae16bf10fc565d31d4eb381c6cbeaea0e4f3b99ab9f6e30cb455a017996c0fa7ae1eace7dd644f8f6ed2e9d9171461403977559dea507539d8157e52a698a82dc88ff53678c3d0af010a441bb0107dfbdf19ba403412bb3a41bfb7468b6258a77f2d1e18434b97e09385bb74e90b03abf7a9a029d780ba2cf0efa68700a99343152dfa6adad5123f70c3d9eb4c85e3ecff798e54045b3dfe0fffe428bf31c611ab08257d3a75b296d2da6d7b94c2af28ebe1fa78b4cfa6a24762cee53b29b85cf10f3c42b401846fa1d800e6e549afc70e9884237f520da7a68a0bbf765872b57f26bf29425e10c0770dd192a94944d50d6a0654bd62e3513bcfa1648e339abcda083f8a522e3ddb0b4113c5b8e955f267a5065b64eed0c24c983cedf3a36e101afa0ddec9e7a2c607abab235b13f794d2bbe88e585dcd959693a93cb0118f8392a649b26f16ef1f93232a1fd95c522c740393310ec318d5a37dc382fc3ad1fe3fdb64cf44a71053f0ee0cb60b57efb47a683eec6ef4abff5fd41d8b055abc79364e2b960376d26ac7300ee4ea583dbfad6f2784362e8a9489aef24c4ab262b63df667dda2ae6d9c3eed0ff5a445d4f031369dabc861db4a74b0c5124f082e864e3531d483c780c009c2a66de1d0be999ad2deaa746500c2ba2e4c797ed4f57376ab2d2ba017af1ccdc1ff343105e4450dc9172bcaf03966a065669982f443f3cc572154758637eb7b02f3c396249699b59a461a74df339b3f967b1269d1f5551e78c8a40bcea004cd0fd216664868867f29524eb75efd9bb71e0f08f9f21314803697c583e9384ff5da01b7692606cb6c51356ab399e3a41130e782422102cfc5a095c3a918b06b1e2869730590f408d5d478367f5721e368d54e75d727594a778ac4a3e188a44305f0c611cf1c7ba90b0f284f52a245ac0e5667b3bfe9bfa32d077124189fca04c8fb7fecdb48c99d96d497c1fff7945c48c2a13a9c4ff0885a25d5fb843e7f80e21b7234335141d008ea78c3df60959c8467398beb19c997128ed67b122def88facf5c52f86f7aa1c65ef017ee387344a35c6e2bafccd256f35d5ca195cc43e88deec202bce1fcde419fd59d3abf12067be1d67d06c07adc87eff05ef3ebed3fa5b9621f0f3cba6b19d26009952968f7596f313dcdcc0ca6a423578720a1d430582ac2908a7bd295c8992353bb14a092dbddc4a2b9c6264a4dfcbf26f0e8fa4bd8d64e97081c7d1477365f97f79f950df70e9aae1224462120cb029c635b8cfb39b3653f13f795e3f2094937cfeffca4ccc8c09b8334ffaa1ae8750024ad9fb89fdded472fbc6ab425f20e96dd2aea6acb4f2d15830889a0531cf9dde2bcd713eacc09648bb7609be257521d59f2532de6198ee98cdecefde9a1751916c76494ad36020b95c6b8e0a83680eb4f44297ce15fdb21c6be70a170f6b3813f63e1eb0ddf1b239e80e95c1fc49f25672cfc0d90f849fdde9c3bf090e6da84e30e999500ee7337e691d71eff4df09e30c3bb222a55c1850df266e1f74c2af02c69bfc06c2f46d8656ab10151600a57737588e18e3ddaf228643cbcbe77487e3b9b5f14d4c8464e7e980d406efb926d465f5cd51d1c1dbbf12fc3d8cd4e43cc8eb91bb477679b47d7288e8f0c3ecbc2e52df50d882682b8911f6c5a05b27bae01988015d59ce3c3e032ba4ef2d7c2d9514318021404a9cb6475c559344fb1450b148bd8de464b2ac2e2b89cbb4b7ef079424a5b4705817ec876363262181dda41d8001a071411987a54eee566b1608ba445bad5ea61eb6fcfbb219dbc2c5ddb90a2c502cc9370288ac84e3e6d54ed60c690f1198778c213f9466fe8dfd7037a13744da90bca11633cb1e4c23776b90383b5ec52abac49558aa2e7c74d1bdbfc58e39531fb0c312705d4ead7e6f1ecf709a7173a8ab4e97cfe5ebf2644cd4738a9dba58f948316fc4dfa301186144c8a801ca7f889ef6091c811d108ddb5721b4684acad063fbf0a28c1a1b467ead6d45d7077af719219078843f3885a8e711b4be17123ace7a5f845b8fcb4da74ae5c847ca4dd3e49b65eb28877f1c89731902bef392605724ae61300a5f573f53a74f6bd9ee47ba098e2656df384a4a1a1d9b04df1d000a89ab229448d7bc6e62f9a399e30c89476593f5116b67484c6396dbfa9c863342f2af43cb0ed016852c07a1a6e94290fd82a901d2f25d0940a4df13a90a82d156a0c6db95e7ac70e622b829da16f6aa1e3d6d50d491d735a308de22af118d610934a3aa71189c5c3579f7d256755cc6379cabc02e5941225aa76a406fd3bfff7040381c01ba0fdd52395cc6567860ae2c47b31d62e9637471072611c886201253897644fbafbeee42b7512381d3bcb76d63bb465cf8b52c0bb3138ec68f3da34ef533edee7fd38877fe1dab45308da756d0a0d4dcf636d6cd5c09c61114a4cc28548121e9775b72e9fbc6ea6baf2ebf2e11a650ace454382e9ee75185a79e4e1e8cccb83f9987b3ffd946391d1724dee56532b60fc5e9c304dcffc8fd6d7c2638e87b8e0c89f227f28962fa9aba2ec7daeb5fc9a309d00ab4e8e0c4ab70bef20077f5d47794cef872f463a70f1c2cd99f50c6a176febcc741c9c1751e9892c73bf40be3b5471fb7d01fcb22397aae5dc2eb5f86bfb5d1ae5c85a384c362d1f9e58ad5840321e911bee8c449bd489bd07ff9c7442defde6ab9827fe8b20c4b105750d5be9fef585193b761faffb2a82ce4b535f8fe30c77b2ebf178dde7f0e484a4be4231e00a31dd514806505c1c46b3e6882fc31305073cf71b490a1e6eca614fee30c70485a97d470e1711e7759fedae6a25efc99d7a2c7dffe2fc7ffcd17be07d5ed178b2611152c82c69181fc751cf77d3b7fe8a93c7a9c04df6d7f1dd3d3e7fb2da6077bc637cf9b7c880e21e1cca517f0817da785997eb97c99bc08adccfa5610b78653c20a12888404470bfc896d4d03d2d9cf6396434126dd326a97733998f11e82ba88c456a1a897bf512aad9fca3500dcb2528128101a395e63b5bc6ffd24c069b8f5efc7de3710f5f458f48e279e9daf8011b60936c982df8733c5c275fec22222a7101f5c22c985ad1b890ba73a82fbaa697952833745d871d710b49bc5730a4189c90c14dbdcc1a0a49c3535a6cba9d394480ab004d2eed7acac25ec33c0eb3cecd59e98d8db11a1d84c15b03779ec0bcaabfbe04939211e48fc40244dd0499c3e075753e6159e0df8b6cdcdf595fde2531b193e435fe0fea9aec993d7f0b6d492c656904fc509f847516510e3109bef7f93e5c441845250ab4cb3b3d2cafb7c0d1ddc6990f33f94abd402c1755ea57a2996e1b774e5ab144b454742140c7243f8fbcaac21a2308baaf947f5971ded9372e0203b26b53c379d6fcc30e86de854320554b32e889bac7396b40561e7276de5c79d3c871f33878f984af500d76cc73229b39f2f6604cd5035d96dc396174d9d854461042fd80edd7ba511eb84f5bce64f05efebe22d3d274f4947b5a12a2002174ca5ccdcfbfff1064f612a49116e17d06b2332b310899e8e04c2ebc55e15523d411f7bc3249eab2d3d0ebb311dd86f9fcc5fe81ea109f8bdd57aa0030de1cfb89eb916cf9bd81e786e29bf627709d335a20bdfcb332a7bac7b5bed134b90e9e094ab1c2c654c7898a5ead3c352b313095b55ec91cde6aec6ba0d4643a65266cb22668dd9b8cd8bb333c8765ecad3a86bca291deeca48a15d7b24ebfa96954f699d41d1b624b03f55322c605b0d3f8f3066b79e53d2c43315e5cd14b0d8411a5378a7afc745c5974799a74e13c5500e2831a0e7353d91b0fb64a2e4f7cc3ca6d29f06f489827243b0299d19665a3fbc1e1a4e3922a7b83177e5cf012601c6c4bc460676ef8dbcc47ce367e4dcb2efd596f0ba98d688e198fdcf488c94f6fef27d368a419684b3aa1024f7c7c0d884aeae60f66996b998fa8b29dd71e46d7a2c6944426dcba89e9447d30afe444f69924c9cbf9986577d0b9929710928da1cff9a8b85cefdb79c1b21bb12c513119bf9694884c8eaefba81dd4893c93e0d97bb8b70ab0843e0d36a24d17747a7e7dc26db9bb61316f94113af354b21e46b608e7d6a57b3aaadb3402f68b8151cc740aa0eb10ee8da1e3003bfb004cf0132ed0289fe784d7c8af65ebce7d86ce1e12d438219b85389e7c67d727c9be6683a12871975e3785ed7ea43f3275a3b78b08c8ff8bd2cf4c2d3dbec2f39544dc726493ab3ef2536f313e6a77bb6d623d8e8e1b925035b53a66b429ef77111b22d3f9db082c9e24d5953a28d818bd47ff27b602ff680bf42f98461e12166a841f4e1227f83a97d0ba85f057257243dfec59ff6e8a16238188228f8d416be52ed655cb0f5b8d7ac508023a981cf238d385a66eb102647e6e2185bae0c4568c1efb09af0cea464cc2673eb0dd5263e473529a6b66e643a68bcbd5a15a0d817ca9a10997debfbc8bcd4bd0ccece7fed8b3d5ef0492dfe676c7bfbea2b52e792204566c96c39154b4a62f2c031cd0761a21ac84a8a9c694d53251b544315675a40e9b407f4807b8dcb229be9a54fdb4eb0a8e58ef6e83f64e60c5397ff2e62448ca933009c111b85c53b247456a8e0cfeb56f9f0f31db62cfddcb24cf35a54951a7724a5dea6139df116a6102239d2d6b2734e0b9762b3e0d11cbdb7ecdf3ddc8262504ac39e0fc33de223abea3e3bffff553220fd7c449afe7c0d88a5218d28b0ae7c597da4638503d427903917faaf9df0df0b526bbef8ca7427706644f8fa3e83610206378234a5605d68ab44f7549f7bc04bd3786f33948b60d25225c619da3fad7b76b38cde5bb24ffbc6f36eee4d57117037851707b10fd5b2345c786340c2156fb785fd1a24277bfb9a82f52be0c448104281cdf1dd4fc44bbc0ea535b918cebccba708f78637e2fc23e67849ca2da7055977fa38c8fbf2420b3d68df73d47f10afa87dcbe4315d8fca16bc62ec365f7ef8584d43be3cbadba65bbd11889596c90d8765e5f632487329acfd2192b74c4bbce73869f68da7e364b1d87cdeccc48547ee376fd39bfed6791e9df7fb7618b71342c74d4cf9706f9a4cc4c7daf4c59e5159eabde73f4db0c164ad5b5986d614bf8263ac728375e2a722c1db8ea82cb74aa312b5d85b66ea1fdf6bf2a6c8e781303f51d0d89995364e86d46b70f72baff39b3e822933376bfd511ff4fbd877ded65a629cb433e8cb1b313333bc0336ea17069d8c460c9dd54fbe16ecb198563e4aca3f98ed055befe295a58bfe05018819cb973a327ddc44c0536c1a8aa511ca8694549dcce404661bdbd14f915df2c6ebe782e73ef988a31b96a025608d021882b68244c841ef86217ed97146e3d59e84dbc61290cb312d4c20271f55f2a8931a4b1491113401ab6cbbb94e8a0151282eaf34eb423b31bff23745a752e1aed2fc57568ce222b8efec217ab499146b3741eb9433107137326b8c5d3411ce467fcb4fbad9971f5cab0334025f33a6d5eac4baf8caa953fd20418f3a08296ed1e9c69ad84f9f726c98465cfc0c440a3ea6b57fc0f8daf160dc557219709cab043432a9dc01de9f8bf4f551a1ab22d802d66793c887da0c079b3a2daf731cbaeb58cb648c6e350b3118bcb80b5be4fd7f2dee182271e7935c0466aad2d31a12f339c0d52029b5108d0702b9ee9aad2c1d0cda345408f90cdd2d60ae9bccceff4f921a8a323d3d5ac6af26e61db8cf7e8a0d8f00c907cedd730ed13a3182ed2871c1c9a2e49d40f5454eb101e9cd94b7a805120bd0e948d34bacac14f96d8e3dc6a262f3278cf3fdcb0e460618db29ce2df78e39e83d9c7773b3ee3f8e24f4e985e78ba3e307972d9fc277b0687365208ea4c1d38285bf1b1ebd6c386055c20145d8e6060d297c67962d049aca38828fcfe5bc8786c74cc5c2c21c0424839984708b7170cb78577aed3690e62041bd03748448f749d169cac92db3e24de44a5bf5f108c379599d42cd898235c907357437c2367167ca841ca4652ef32556f590475586821270b2cbded67fc0786905064d14c580608bce0255d33f21d2949fcf1de07eeb63ac3ecf8b9e8d632fe5baa3997d7c2233a9c37bce1c3052990fe6ec4f1a84fb037fb17a2f0ff6e90efdb52eaf07a0aedb8f3facda4d59fc12611e01a90f71f3657abdc33b0f7d3d02e772f32cc8037ee3935d6b32935830d69c034a1877bb73da3844a5e4a9f5fc6cc12692ba6eecae7c89bccdb462dc7c81edb0a65a97ab965777f8dd6bbed9d734cb36d2493d64012589bd6f529b157c893c866343f17bc87021110dac1ccdc560f257483b5a9f42ce5645f4b773fa84462d7227c85334834764c2e65d0c410a134b5c82e0aa4b35ebcd80987d907ed47ddc5fc9a3552e80bd0ab51a1201e2468e1455f3e7b1ca9b63c6f2dc1641065dfbfbda817b65e6553d74a42479739426c495dd81ad0ece43abd657f564f1ad5360222c8da00d1da0abd66c88176dd4e9ccfa113630606d7817883765665dd308e3ffb5a44a99f0561c2842e3b4e0cefb64b6b01a23f18e5f6b55c04d5b2202091eb47bf66bf19093e0392c6b0c16868cb8e698554ea7683c516a9e6ca7848de0018b77e31d86dd3f06256d0dac0312ab5bdcda836ab8e7cf663a01a2a1a2fd0cb7d5c5f1a8e462519e58642d1f4ceeb9afb76f59f7635fb051e116f555b1378a4432a0633ecf57368b993ffd94e14407e35f9711aa62fef293e824035ddfc3cd5354e21fc9576326ea79121ddd05e12a268064e07d0e023828f16fdb72920c5749765a32afe788067d0a16f8d9c09ae624b065d6cef8e79bcc44c02675fe54964a8236fce226ff020aa951bd64826571ea289017e424a53997be347341abfd865baab5c76fd44475f885329fc7457d2cd24c4bef6163c0b0d294905ca9f3569945a2bf191f72519a05948d7a60937c73628493b0afcb56e30bc0cb43a7eaf02f564dcc00b87a6f18d3372cf3d795b5082e9151e0854d067ecb439a02b17b352ec0374c31177da92308e8a294a00f2b70876d962f6fa30472e909aa6ca540627c651e453e8a3dc8be31fc86b78a76d527596768d9dc328ab584ba9c3a838b71683ccf914184f02c9b86595b556edc67e27d003ece8525105a4497b75b2afa1729b6b3cc5fbe8f03bc7adf08bea68d4f1d1f0691b3dccbc1dc52b44e9247326ac61ad3034e66d3cf1f648d0e1cb3cd89df5fa1dd0d1703be6c78093da98bad0c6f1a5632415cadb8ee7e146804d37f48136a81efe221432bde0a79a0b524c56db635c5dfe6220524a5e2028cd055397a26f85545c7eca12b78ca10faa0b2d88717032d7e816bfea16f0f16b589770f19b8fc850cd2e4e84f8717dfe2433fd774ff40c53f428eb7b89e4d52010334c1f9d27944070c42c64b59251c2eb6117f574bab20ae84404836b346d8391b25bf4236dad98b1b63a7e68ec0aef40502d4f8fc7261d7f63444b7622a10816899e8b8c770db00027133d1cf56716172b3f639b59a701b37af34dc76a7de4776ca77cf504ced0257c27a57e77f274532f4b217177aa9cf28b6bb5523adaea03985391a34f67f06edb10f13e83e7a38279b893db6647c8845a4c0259883577a83e4d3e1c945f044f3d1cf1e687369c3ad036ddddca3b6eeb42dab8ee7b9b81ac8f13750324d9583a1b8b5322b47cd4a040cc5d9f823fc517cc2e3e405aea619c281d02727987a7b134a15de2ff0b560c1d0791daf024011b7340df5da612c44e5eed676debec01f2080390883290a1ca257e103f15a8288c2db9e230f0b004600f6fcbc0b1755ceb073cafe3745497d4f8867d2d109856a73e8d16ed037e07fdeee6e3ab7c67e6a59713e8197ba7a7e8282b82e7a0f9d5ddb34e82c20a3bca7d42a3386c233825b5ecae0800d821066169f955c3effc34f0badefaca5cb16723644d00e4c3e3c564ee266c9c53a66a9d9c05dc2106b15f0e4876d42e342641401e4b8730f323aefc626b4af118df949e027c187f312f8240545fe6f7f14f15fb70388da8805f16d27abfae51cdc10071cbb678b26f6f4299ac1fc26a500c0e9c5827c737070880462100695918d3560ef30a3a41df5f9b433da349de06762e0507e14ddbbd0962c245dcc2b9a060bddd3f41aea6824e2a160b4ce4983e04ff88a1e524c56677d71305ebbea4387e46b28dcffbc20fc7db41a85ecb305fd5f204320f0182fe34bc02ff9100ffbac7e0a6a969b621b1486b9787d4e4ad0543bda6c5e43debc84408268df2b1828d14d0bcfcdab1bf52051ae32df0baef37ea77a0e311b0dc817146643c1b5eeffbe85ad49c757291895b08b65ddb39dae54bb1e0639fdc948440e1a792e7d12cc48bdc7f5bca4cc98f8ebf778de000e92bc5e805a709cd9cae0f9830be3597d545561d3ec418e3a8122188d250cccc578600b39b542ea3e1059c2b563486c897842a89b5196a1c35c480847eaea307fc1ea0ec38d904cb0224d2cb8f5d53afd32b917a4c7fea376030e6da56750540dcf6cb23d760149f7c16344a42f7607e097a3cd985e2b35fd77afe22e04fdc5b0f1c2e483e6b7a05b675c9f6035e29723934d60f050c43d381d328247a17829cf025431b8e7c803561508ebb35091b790b72fa5539927a21ad090e2df510662b897307a424cd380cd252f3f231326bcef276adb13f3d52e461ecfefa94ee89fb3473afbb62b0969f73ffb99d67b21444b644e207839278c6598a96dd5fbc1a185e1abb6395ff4927d14b707a2f1d3faf58f85ddf6ecf5329d8561f814c51de8f6c1f19e07f32bf9323ac5fe6f5bace5b476c4ae403085110bd2ad0585b891208a40b54c1fcb84d33d8cc3d9c47cdce5ae1595c4f80007cf4b1df3b644a123076d9adfe65f2d6a1b22393e3d01733a7185b04cc5f8b6204973269affa3494a963efb2dd603e7950d6056610685079e5d95db507a5c935cd306f02398d1564103613cfafc2a0ecdf7f793f0c21113d2686b6362a6e40f22773b24009ab6e91ab26964612cda4a36bd20cc1e9615cd0f73422a2148ab3116537ecb468e4371b3b65c2042d5b8778946d00c8ed0f8ec2bf70e329b66bf0fd1679d88e35d1c72361e3a30495efc0ee9712edfc27f0b6d6fe539bdecd1d2ed3f40e74792e74ef74ee3c8704ca4347af6e0f44d7a622aa6c1bba98f4d14643754156300cb84fff44f40b36835090dd16e719fc99e694b982988d8f24e9c3a8dcc088d95a7862d863c426fa48724bb0b90f8f78096b59735d7ffd708754e825fe405d3a71c2dc42eebd6099e514dccbdc75ac613c194ac9f0602280a83f98a7563bdb7ac498ea6d024d28719dc3ba132f4a5087a1b8d5d0dfb10d837a17150d1877b87eb3689fb6bd60d373111ddfc6a434983b6a5c0533ad4195359510df316f64046c7117e19b31685e6c60d4d875ce1f216280b00a546b19307ad0e381d007783e58b793a3b5b0e6406c992d0801d0df6c99ea6d6d771d9256ef949b507887a923bde54b2eef110861d33c1558870321d30100af179b872abb3c207d311b7759c32ad6d06daeef3280264afd14814569eb10fa9a18a25b78ef0e2aabfe2660403075a0c9a1c6fe3cf9fe82d8dad96ffd3f407cebc7ed4704c8092e5a8d95cc2e438cc606ac1e092d6ef72758c2d60017803caf0ad413bebd45eda701de08717c768da7b440b433d42d04dd0f6f973df16506a246b2032cf24e01e0826a0262da609b87914d4368bb16ab0c35c16c8cfe3a3cc738ef4e3a56a810c8c62cdc40bb121da1aae6c911907e75f42cd5e0a756212135650e0ead81f63ac5f8c521e522d86f0ce45eb8485f9281bb138b93430395f5e5e7db556b46dabfd0b15a9a47f75d65264f5123ab95422c8e5f8ccfbb55d481f8532eeacedc4f45d86da88a31ae93a0230cd3e45ea2e91624eaa5bc3b63d74f868be2fdedd83c1fdcd24f5c9407e7eecf780c5bc74701b792c788a146dd1107348c8f4cb69a39a93081361854d99546261afa9f2e7cdcea7e3e361063ec8f54e47bfb5cb382690b5036d20e8127437e17053ae7dd9ef5f302e3ac9dadcc197e37a346b3845d95e50e2f023fb184c9948a2bd441d02d840b3baa551082bc50f6c2f5591eb2f94ccf04e2e92aa970d2a53ec382f09c3841f15452f331062e3a5041d89eaca6464d24171c394f3f568962cb119a292da9d6d0ebc0836bc6a791260feedd878947863fc2f30bdb908a479091a50f70cb363740add9b19a26056101634e84226c971caab804dda3fc9475774245ba63453bfc01d3a1ea4771003fbac56a7d9ed25c1032ad0a72d71490e9c0f1eb888c04ca2446af89f6debaa211f1cba467c66f9b6a7f4f541587414fa11df2593eaec07e4ff0702e3716b723e172a41a4e58738019e2c0c22bb8b0daa92370a6c2533899dcda7685b4878e452d22c3a679a60e4e8be9e9c57eacd51d914a3dcd28aacc2b79b2e19173d3bfbc47347ad9f79b704e82b4bb1790546763ebcc0e79965aa6b207b86922d1b24279c28ba44742bee3892b74bad562fef0477547190f8af031c33a1a2a32dc4de3cbd3ba7fa0141ec0d55fe0ddc5f23d423488e13811d9b7b03356a9ee70d1e919252d542f4534ad0836817c53a76ed9dc4d45980654952305b73a36ee7964e7f94c7f33c22ae2e9d385505ea0b89fde8015c7a687840029af9eda6b109a4890a5a8ee18842210ba13602811fbaed726eea2d95cdd7834bc9df1db190db964d058b1f985ceb10b50f94fe1a7e65747bbd457b9dff8f80eb00539a7336d2b681619eedf33a09e5f4f96ed3fe12c6e93a7e259386865e6bb8d0778ede5c08c95939e6958adc40eafd8189cfffb2c65f99f4c9344bd7b29e470f32c874fd102b3dccd6bcca3e9c191ba38e3d2c91a0801a2032907f7c2c920085ba8a71b7b9939a0961dc9f796c0187cdbd07919eee538f47a6bddc982cd49c4ffd129e76933de8e158f44e1353c704c26e42891897f58cc8b2349a67859289c30e9852c974c4030d398932ff5a1cda80abaabba6ce93ef20d8d8392d4a0a3e6c7121c9cc24190ab68dcc762df4015eef827acccf11f554ceb6594ac7c2cb6e51ec7c03c3e163b942a750bfc7f4f1539c33073c142f0b1be9a69965399411dd3f6c4df9f5d9912eb3ed09e1191e3093dc1496e88ecd03654e65bc1ecb14ed14a60ebbc913cef32bff7f8f063f43a242e4b3402afca766719d56fd5325b3f1788d49b7fa3742d5e3d1b0c8c7a1ad9ef0100035f7d10a50ae442e4d2d9c6c8417fdd3cb3919b9a2bed815238e33b1161a69aec9ca393a875fd823e8ce9221a276e2b6c13b3427167c99f768b31db70f8f56648071e73e257eaed4756bcf9ef34286b3661a23f93f41eaff6e00b6070257eb736ef34aca3e06002ff8ebfe27ef0f3d65411087707822f40139e3223cc1cad7af9dd21afc0a6632e0e87e838fc3c112a695e1634eccf67dea9e761fcb4c24f0a7ffdf576b1b1c1d5c6734a50b3621a1768330275714d8ee24e91dc05f7e6871fbf2a20b1a7346fbcffb614e251bfd8fef687dfff77d06dea4d1e09ef2fcdbeebe6ffd56f4f9c84ea71e97255f819a5ce34d406435f24d75a1e1f2454410768a5a780d6cda24647a5f968b418c5739aea413e21c8739680824e1cb4f2e23feb5c30abe397e0e0da979fe79918f4bbecee5ebde3df7ec169ff1001f6c8a8410eb5c146d2caa3d36e11c7ae20a651ff4c49999c0c76e19991ef4ebb247fe84970837c9fef1752cf4da64df791adee734ccd1703b1967cda82c63dac5979609062423bac67a1707e7dee077330c40e557b5dfedcc785a3621cc2fd423cce8928a314575b0e3c4765335e778be730f55decab94424099b482cfc29def59c8a7dd88d6799a77390c2fa3af9a6d7d60461a26be36525d32ea93333af46bcd989f50878685f61081e87d42ef12d8c8572eac67ec459d29fdcb1c19ce4429163f726b4d86de1cea274d0084dad4b33d7b1c09541fc568b5444593207912ee3023feffecf97234473aba21b7232e6a497f003be931e5542ab8932dbb9450515ce2daee75b64cdc541981cc18baf1dfeedb6d3c76b00d84f9aaefab307b02334e24f24124432ba8ca8d32b6a51e62bcdaf707689bf170571f2e647c8e020d5a7b0584127a37f91bd0577dee6cd8ce19ca30d65a629937811977d423b849c5be4b3871194d13d1c0030bffd4091944b0a488022c9de8898e1aef743643b1f9913d2c2ab610e470fc6bb314b7a80763ed6ee8f8a585721fb1405f6d0c6472c96c81ed766bd466729178dbd1808002445f9ada8057f9a205ff6d03c2abc99b34f9afec32d14342f6343a02656981d58fb747a3b75b15ad7eb40ddf5d366e548869d231f900e85fd774feafe173e23977d2211692c3a9b67112808758cb1c5a6003548a0d1dfca9781e5a9086e9c53be47ae49a18d2bd0ca12306c2ace63d73dc5b9c2948992d06b900df6206930ba312049a632877b351eb4d9846f5de4c543aea061be8bc207885324a38547e7f3d59349d1ec99162d72b78372230daf2a88bd5458272240a729c737d4da7e4779e26221f1b77df5a7cec0b8b205dbff86f71732eab9423b990f2900a7f1d7420bcc7ad82fed3c1b131fac61c6aff72897c9d01cbc8e3e298a00e480e129cc344a236a38bc6e2616df6abae7c1523bc294e4853441792d57728aa18e234c195082b140f8b73d751f18e209a04b2d246df6e50e78c19e752146d54174a780414bfcd8ac2722d1b642df67df3126720a5e47f9f3749f790db51967dd570d05a50559f8f2308532720ed24d2da0840cdf964b575daf006cb5ed43f0f4d53c03f0962c7ee926d6dc18308d79b6956489fa64f7ecf84e123eeecd35f91fe55b3d8a62828db98ac44a27d72186deeee284d268d951fb1a5413bba5d9885737b54b19fb039a29b2e493bd6177cb8b8b6cffb5d130b4c9653f1ee3046de38b05db5966be41298d0179713bd666bdc720a4892d6656f8abf3d8b0f072d070649f09080f687f63c1ed34b7384c3e6b0bf6c18807109f1cf2fa67f3bef9d16c1ea1c6bff3498f6492b1267170f56c789b957ae4561f3d123af3600beafe857d945e7c8433463dc1e965b03ae85109ce253d331dfa4e3332bbf5d443c29d1936e7fd37c0bf41226c40c0d4c3f8d923f16cb9c57db5f1ebdcefcade110f8b40406d8e4f63d89b86ef0a199d8e21b224d3394322833c95ce1c12c20c08dfe018b4c1e5dd42c29f953a1f6734af19240f4632d01bd12c897ab7af67a58e7f75430a8a4fe6ecab10b4e8bf556e4c82f1bbfbf875fb5986293f516c9fecc4cec5bc439ebfd7e16eb935f111e5eb20012fd5b9f0f9033421c1b6836560065d44084758f3bebf9a3db94e3922fd9a1e4d3fe7f334225864bb23f7b9a8597bc0e627669a8e7a748c09b83ee7b26b630eebf43485b984f6fd7865ce6359f7623d119bf6e645d34e58e2fc7dfc1c1d4baf8c543a57ead500ce6d6a38657585975d34cdd9bfea4ea6b2b46243545f914f8f08d8c1e1e15d3b0a6884813e0947ce2a3a53c628b9fe87e509a0150f32cbe9d2e8b056c2429538326e4bfb499ddc79dbc203f1fff4492d53b02eeb9320ef3195dd7994e1f8c1f293c23a76a3fb13fce83dab58ec091e667b16cc1c557abfba1adbc852abdb1960476099d3b01adadcb883c1023492aae49404338730b75e4834e12c3a3573219da09d93a296ae4f6b7f5b127dcd245cf2549c714a24ba6f411373e1ed0be7516296514a96c6ee3c3ef0a4de11b38ba7c6cf9af282cc9c45b69803e45252a35c5c4cc950bdb4b1764a371a103a0454c7d43a1f60a2ae90b246f9023a2b642382bed9b0c17342974c85778f0fc67fe577bf8d1f944fb70d7fdbc589547c5ca4221772a83e7636c87e29b9445d1186e9b8ad585f1df53b2c92f788251689fe36e5564806ee450c36f1280720d6147c027f2fcc715ebc7ddacd1a016730b03f637d519b31a17d691d0470eae8bd36f944f21317e1bd2cf1c27a8b00bd7b9040b88341dcab28c085564b7a37b6f9e9faa9416db9d1e45f25056c49b8f81520f0382ba1ff8b564f2b0163221e13b54bbdb745c8081cbf9d5a6d94961862696e973f84a009a309e5b6c4dde339dca1df35a2d7d09273e32b59fab9863c03685cbd98454817f395cb899b8e4a0650990d3bd7585807853f12c26e50e1d04168efe08843b49fe8331c15fcb0b7df197be691182aab05bd0de73f9b45fe874654213e93079b68b5515a7db956066df092ecbdb50856aa976e3434e7e0c6f93b478202574555744ad7a67412f8205e6fb1fa7001d2b8a78fdfd01455303b797b450d895829a4d5a2ba62b02a1699a8853e8ceff64576084917b0b9bd90a708d8c22a469a245c03c9c4e8b4d608535eec1c0a8d28c9d379f8908c7a87c2e3792c55a697ceaa1530f66e05aacb55abd2c5e8c4ece658bcbc22a63e6378c3b129887dca929ae39155d9d2a9085ecd049f5514f8eaee2a50215fd10ad34070b4698b316dc88a65f651acaa023288aaf4644f456c886a896ad93a369334ca22e6370f1ed929d48417e0aad3612bc022e0ffb52a21d1fde6602e1f59da088ee4558519551150a59fb4baa4c05bc67222bea465a8cda8e81f897d27dd35dc091c96972e69f0e0744932bfa36816796d83262378ba47ceb4e25915c68eb21d1d56840d6fccc3c681035d0a16d31e1581e10ac338f0db408aa5b29fd4b0ad1b31536c5a0995a976bb165d6ac0f90be033ba95716b36a7482315a9cc79e97827b1abc28dd232c2156f70c4d1a3f1e7b18b5ed02ebffaf7073bb015020725a9e26fd291d43a3a18f2800f2e61b1f38e9b76f9f062a093674dc951eea14732d2d2ac93fe0ebbf79f5882a7aca7ba57e0290a1ff0a15c5a1cacaa78d6b2a56bae3b79a1becf7f837d8e4cf9ab559e08fd3c8ec1f34e48ff4376525defefbf46a85f2325c913adedc433e2e7a4078bc5e2fe9d90b6f62f781a914127744444b7ba0bd67e38b03f38eb4c50fd659e75f6c0983368ffece99a2392fc42e23e8f3b173d7922ef3c1eace06bb8748c0aa13adfc19b2953e196aab2b7834dfdd04f0520c03550bcf6df4ff5bdfb7ce30adbb27adfa0ccd0e1d6895745a21682d5fbe0ad39f5689ececa7d1bdfc8c1b1adb9286a6f0e9793671841244b76e723e94216e9a4ee6f8d2f42843eadcddf36912504bde40e683a38cbf970af2d4183f1c78f49d92b364324dc35b0c75c8cc00bcd02b8f818ec91e1f89df735f933e4ff81fd7c2cdbafdbdfefcb6d2467b0b5910aaa84a051780cbddf3d5fd52910d31be47256e5be39e40fbac5965af40d199210a9f1b7e81ce6c47a4f3b6427ded880db6007a2bedcf66b1ba6a7710dfcd079f5176a00fccc25b12c2a66c371a271710c3dc70cef254c0c341daccc062dc7800570be1c12b082bd63d4c1f2ad7cdb1f08b5a30e1b8973ff18040cbf1320f0d0e95b564fcc94dd68d97a455e464e69c1062b85679623266e3183c94e06eabfc4332d634e727a0038e59109ba347ddee28c068d74134992420d2caacc2c1bb8cf0d8f14dcf8c930d851b08ef59fd13e3ca3c2466cd912a0091d2bceae98f102f065a8566b5068b2b1f5da2edc7406d58ef240f780b45448d432d8c780d68f6d3e0b11a2c07fd6859804c8e28ad5342c666102510082c025e0238991920be52b21a3356aca954bd6eb9e39318701395325c5930271206a7b6871de2a5c37037e45e07ad5c55624f14416063c160012a0817da1134829299e3e370e3181a17c6054ffc56ccf902c36a8dae8d5c0fb6e9ce87d395963012805995e43275268ea440accf2617620e7f14573de637b27ecfd117cc1e1541bc859cbab0158238c5b54da9561aaba7d1875a62264b7650de83b32e588c3f0d0716acb3a1ce6e6cae2a080bbbd4b3e5b3609234c41de6681ccf7f04eef61c9030cb22f65473feb7fc878a5f7fd83475dd2f4b3ed77815ac595867cdcf9a9060b71672024ae3609cadd62d5cdc24483325c58e1ad90f42f012adeb74eacdc1e8021c7470fbf122618bad4c88876ecabe808d531a85de449a8271581be4de728f73f02db9adc53e64d674b90ad61994a4dc4eb16d5e3eb8c20e997247413a366156a7a4edafe662c3c3c0801fca05799c4f878301ab0e9c9fa6cd40b3e092b26788189c625e59e2f69273501502c1a886cb454180812a93f269addf13657a67e282b59e06c27a0618c129497386c99379edd48c6b8a8a8ffbe982ed66f201184e1fa0d8141168211ef4568c4c4720404c893fffe02f92879edc8ceca3bcc7fb6bd62cc4368fd2aeeee7f88f248694e8e7afc4a5c0f5bf8d61625ed227a1b1a0b9e9358b1dcf92f2138fd483127ea5046888b389201555cee98439f08df19745a69e9792057a21b1f4e75e447569916d1301505644f0a8510e970fcf3427cf22ce6f28471d88cd6bce768ca7f4d0d449316b9581221ba501aa5d9fb58fe4d84bb068c8f5f20af2e6fe3c0a3046199a5ec2ef5d6486d7355a76cb5f8790b3415c0931ca7b32ca065e36174280a6ce2ddc919951a7464ac6a4db61ff61de1f8e6c89eb23ded61bf7ddcd32a4fc7db45d0d9891684cb414f759961ad5a41ad3bb14186261fced6feda0479b05bd99a78d639a3066df1f5b08dbeb0c9c27da8f7744e3d98b9d4082b17b10a5f0593119e0cc63c3cb48e253636ee70b3a84faf0876ef0b387670e641b5fd2577fe838c920e2e9b9cb98ac698c832c9fd54f5fef3fff77c06c41cd73346751d4a7c70fe5a4e41a05cbf9bf8fa4edebe16a52c4c11b2416d30537691bfeac03b28c85341cff57c7fdb21bb1858d14aea4e4a0ebd69f1df88770e2dcfa40450ecf8fa3951eebbfec871d043295c0173ce751af4e0650e9842a69f58b0a1a0a1e795cace27e05a821cf4dcef531d31d0ad20f14c75352f6c4e1af3d57ad52fd4f57d52992e2ca6bedf1a7d7a8e97ce59fccfc40976264c844f881b0cfa9c107f351ef2968e53f8c84ec5db6e40adce48a63ea09bcdced80cdd57427f643e15e8f862bb02adf726031fa2653ddfa1a30f9af08abff25da4b45bb8a122dd3cde29cdbe1f6b0c24b32a94fe483420c91e8c130fffcef401fe8f9ef0451036638f6650a337da5bf11d1237f8216be2b09f3c233672c1f87a57ee27fbccd3e828b72172c5f2872dc487665538c96e1dd72ff394598f69e5896dd3b81946ccbd295032d9815f83a0d026cab3c541a1594bdd3e7818b743047817e7dc11d50b0d01751be0525324fe270d7e917acb042f3a35ccdcf27b9497a9a4218908c3ba264e88b02cd43e6b8938f3c13f03b02047125f5f327d0c6e2125eef895aa3d7e66013556a4c56cf3494f20a5a6160048de5ff8e33f605367c062c23f17ce7f489e6d517ece617e1883cac7730f69baba2760b71484a2723a5cf6aedbe68a33ddc3ef7791279d16b785e094d6ffbedb998f54fc060699a373c7dedaeccbaff5c696ee854b6556e04505bfa761079b2c0cad0ab2cafbac49774a7050348adce7584e07df446ee95aa46ef26a6138641b099895f97c90120d3320d098259e62c2ece5025322272071f92a95161fccba3b73d18f0485d3ac91bec90df3b30dbfa6410bf50aa7e74364bc4f71797cfbc681886eaa0621159c0707262a705c8f42cbbd165fe83d4aa3ef8686dc3a603e7c4d192587fa809a7c19cedf30cb51ee58875b508918bc411dc98ff163c9d7ab2f12403f440f876fc5d14ae2cb624a2e7f11c15fa9f49105af3694bc88fe1b3e49997df81e58fb997d339fbbad324e626a583282279cdb5daf409bbeccbc080f91cfb4c576722fed3bf574d918f7846d857245fc73457e6532a1cf991f0c9a41429c3cd33696396a092f4f5aa84ee710d89e9020cc064c670ec4186b427f2c1e6cb6555d4822578236e48d70ac0ac04ef7bdd330ace409a38843ea2e4ace31979df7eba9fc74c35c149c7c6a88b357b92c1b75d59d512013741b45969c54bfefb89f7cff1c35d858f0f1c2a2519b46e33937f56263f6b9ea349760dadf7993966e557cde75b29ee0cfba9d3d7bdc41aa9cf9541695808b3c7833d3aab16352fd8b749e9bd5c457edbac0f92d4cf71a8d96b47682a78edaa0d467ebb9f355e6ba5e65f9c7ae668e30b29dd089ded68f6b2df10fbbe472617596fdda6c8e00e664348a25d8ae7cc4af4c7fb7ff7368f3b1ec0cce33201ad74a300c39067802f3a7669db71d875bc3afe73d429f74eb2cde3d2029fc82e867610dcb487ad1df03d3a876e38c496bed99c4bfb9eb321ee7ca7c8590839b66fc3a4ec78c335bd79153afc23b0a0978f052beb25d714aa11caacf44d80d0b8b97741b5bb84406b7a69c8d57acb06f0f064f9aecc4de8a2c2b95f1d8b8b508e9da3ef637028582f5baa7411be43cd8b143887693c4d2b0c7ca28b3efbf27bcbdcf19be83a27921ad519a6e411e9970957d04374d9d60f8f65774d1a760a9c1eef61ae07a425e66ca735c7cd0ba663982e23600c8f8e287586cd41f1a886d5c21b03a283976332da9781a3ff87885cd539b0077701406a6d62e6515da9e2a048491f05c48a49f0d0436c6a10b36708bcfe0e2df91f851d7343b05ead9dcceefab81dc74432b84687ffcade5b3a5d3ba8744fa58d2fdcb4a366191ad292ae840b9a71855db2c1c3fc2a88ca0cffbcf11cc12ff71192b37b5ac15cb02a1b8247516c52ec9e7e1a0bb82aea480619518057c8ac85799c60c7ac8fd8ec3eb611a467c273ecd9108a56d6029db0420107618de084edc93d09c83b6232f5434949898ae9f826433eb3fbbed52b1509bb48cc084c5acad143b0d62c03953bb0f0a17b7e5f7e7c63e538cb505172b98fff2e166ceb5fcc525a9866879c87dae3be5ab65e3d8d5779da23cabe64ccdeec47d382475412552e0541d460bb19a65a2356f27acc394d441341416ffbf8572018183ac46cd1280022115bb1d51b776c61e005559738821c67226b73beccbdd4b6ef9eaa10df43f76d1d4489c59eac32c2c6977ef2157f84ff7a1d719fb681090cac6702e9d914d36aa8d6b5f0cd2e6378bd83d943bbe8376575b3cd78a7ff63b4424e9a1f7ae415048ecb6202aeb020011108fbebde7cf001c03300ca0135a56044f35a84502ad4e68082de90e6006ef0f5e8f0d1e6480d4025696375cc8dc4e9fed3799e21edd5138d627152ccf01e411dca1f8a83deac5df4ae736aedeb315b8cff43add3ebc97408300ef9c59d20277f77a5b023b79f6979c1f13f8090f613de7b6869cf0366d9cc7fa621b1ea57a83fd090ef76c3daea76c43dea3c9f91b78f84da99882f6db30dc984856055eabcc486a2a92919bf9c9e261a2ae020f53d35c8397e8b5d7fc5d3534f5aa68ce4de91dc068d8fee3898c95bf568b4eb06445d9e806805570ddf189d08211827e90559cb7d4d2dd2b9ed79a2363cc42c151f3077a339b3e2b5512316f6f3e4a30921af1d37ef4c42e1b9888b700fba6ebd4c7483dcbd6ff67fd50fecce49f1158149a069dbf459618efb2d401fa8109bc8a305dae68341ecd47146d2345df8f70dade6e8ac94f78d7b746e660a1f93fc6bd68b288970c507fec3cf080a66f8b7e45ce19bb579a6cd4ecbf97976770074c45be6f7b3c9fd32caff7bca21d921ea418cf19fecfd45d2ec28f8dd8bf4a4485e4e16f07635cc1ff84a0a0baf69aff2f6df0e27aaa28e13add852b72f69979171b47ecc62669807c24689ef34caa5e960c56b802be3338cd6f81b781918f17d670d4ed66358fcc0bf4341f8ac9327f340e67e400886ef9ba03330546d586b71068bcd17241d7270886caecdd8db48b953c1a2a9d4e25bc696684801413a57993883018f478c4838160f4b193bbb62b401cc4f9b35e8388aace39f82be8a9cd704033a7c68c657bb1034802ec60969e1c3f11963c37473c68a6eff74dbddb4e5bcd8bcd8b00f8b0f0e4b8feacbcf7b51bc5ab13675e636dfaacd39606b38f1c24cae8765a027b26dd44da7ef872c20bd0d36e8559f372c6dce3ad666c805258f92336b79cbd96340710e6b1916d0f391804c9846b8860eace1a39cde73784533ccddc1be5700c608f21165eff24fcafe7069f08fdaa371fa84508bc1ce1d89c1c2beeed807e77603e7716dd0cc9824d07c00c829d82eb0da413666f2e1b0eca2ec4ae1a36c2dc6672f0b2ef442e5c0b18ffaa917fdc17d56ceb3512cca352d659dbf9b8629d292cc1a7a630c2648b0998e1b3c3b9bc169a521a614138d89f579f4e7c2714a4f57f57e38730707ef9516f753130d44403af3a277cf413dc3f762aeadb0c918fb1896acfb4c189cec9c36b4671d8803c5be4f1cc12d1c6983e95d8f10509c1f9a61b491ae689195987e856931eb384db3e9688029d3229f7fdb2f27e092a098805cb6e1a2323a63ff6c58f370fbcaac70a1daaadde1c5bc1eb3feb0fd6e68e44fa0280a9897cda9798235bc188622bddeaa401af18f60e2e9525250db8c7e56dc54cf00f4abdbb9a71e00cec93505a1285fdbbc5187567f5acfd81e5cf8173532db56da124a29938b7a60aff8fed7f4bdff67148cb38c6ce416e21c36d0398a1455cd037f537fcae49fa79de829905732728bb1ce510cefc1cd6cb389fb3e35627ad3767e89c03bd2ab8da14c69f08d76e7ce7bb97d941dfdef5061746b857d9993f835f9e96075ef911d65d05cd3cd09419c0f2efb7d9f05ee94528b1cf6006f30158e70a751bac1fc0e9c60c03c231ca8f8f24e438d3a3f3e2b39e6795a452b6d870c0b1f114ed9f5c61c267c4a377600b301b50cd29d29c585b386f9f7439b375e6876d44814710c1e2961aea3e2d23f6bee6077d02b6494e67003cde03953666a98f259340f20c7bbda9d183eca7e0eccba974474b59f00fda4dc586bdf7c3f330fa1a60464adcf296a057e58d090a406253483762ffc07996fb9ac58672030d46deea411067d60afa0aa30082949d64497def516a58d0e490c5cbc86f11d3042938f47f85cbc7ab6fbdffb418fef709f5e52a25cd0ebc5552b1ee1fbc81d0dc764b3f87d06b02e49043395e7ce3fd95393038f3334b41dc55e0ccd7cbcd4d9af5932f58ca0c3ef9d34a670956596bfc06fa066b0a1f2514c4d2f8c228a17c7ae2001c967b200d1ad2dd1f96cffa2edd21836bb2d4a7effba7c99557e14e589f79d6679eca9682f1ad1d2a502b85e6a682f3baaf030bc79814dd5cfb23a65a6cf76895f992fbd935f4d3832a668799d9c55ff087c8f07cb4faa8446f164ba5868164d647f95818287bc120077f3704d6a92257ab6947f809c13bf407ea1f26423f41dd980630610e391b6463c8076c1474e267688f1dd068b5a8563bf7b465d39d8ec1ff8f3a04e0ffdb4fe1612ade3cf00abd10010af1570a6c690eefbfaf256ee7fe32d5c6489f9796bdc46ef0d5cbe7728e204a234d273060f61c74b0219cbe5f3d8da244412230276db2585e4839d71f58c2d0ae270c02b9503a1ddd54aded0afb711f866c0f46a4e62f184104eafa95e47872f3b482b3d35beb1f62fb1a83d35440b05395d0bed173b63fbe4b554f8ae7dedfaf9b0c4a415520446e8a6d93b55ec9c418a45dcc9ac5850b2105d813b8cb335e6419e2b2e1b70cb20c928cafe61c73da6d28ac82316c43db0cb004c52a833b51e6fac2a23c4f88ec53fbe0a4ad71e6e6729aad5070fdc393ed6058b627b4b42f407c07ecf72ab91c237b6345136849661a57ae89b3ca933c68dcb8c5bd0a549ed900c49c0086bd60c3ab7f5379ff5df1148f98e64ae1ad1c24cf0e6fae5ffd9eb852a718df05ee56dac13c675092d7c664d98641c83d45c39c913f9b063670b5dcc9c5adda2103bca43e3b2e36db3d3034056e672c5fd5325e193acd69dc82c58b366769484d6fc2efefa31733418de6b12c725d15277a975623540f84d409405441ceb02a3f84108e8b17712871e22c16243300b42462384f391027f3e03955f4cfd2dcdbad39464a647a90755dcca10644858434f2a12fba3855200a6d8ddee54fe960e70195f3b20f5107e4a1be91eb88f996167dc6e232031b7bcbc85aea537d5907c2c2ac0fb13037b96baae283f6e3577dec72e23adf2de724ac59f52d44ecddc1b6fdac900cfa7528c8371e88296364d2a02c585638f1c759d942493072717e875bd3accd7c5b431045a9ea9900b9db2f06d2a04bda0088f73817ed04b7be29370439d2da35708e2898bc5d1e8434a8b4b012d971087269393e6fd0945ba1ebcd4c687c8ca50eed0767707f7c8b979ec26d2eb1f05620381cc40c537248f49b2785f133cb86d397b8257640dffc276e9462cfd1dd4233f7a95cf01293460543bbb6342ae6c798b95c94838a0bf01ea961453bb899edb63f59e6aaccaadcd2bc98bc9fb30166786921e809f45be7fdded8f031efaf70caa77b06b6882868ae0474c4ffdf190f3b364e3ac4a6fd9f9c1bc2274bd7232c10e004bc03247390412130923c92e5c3dbbd13cd8f8d4598ea616448e8dd4f8195027c241ad34a23ce720e740fd702af0cab783832304b91f2c2ddd14d68cb07c56eb1384768cdf40fc68b55a8eda7e4c05d89475419402b1c3faa212fcb3dcaf9705f55717b88629d5bc7dc7ec3b4b82a734fb62eae974ea7ec1e939372d3fd6843bf3ae60c6fddcc7953a769f7c28766dd1a9039caa2b6fbc75d40b75d87c5c1fb91bbdb8db5000978ce03f7c78aea767600cdc74ea6ae8bb8899979a6b513ef5add17b2c4aef417bf8ef80527fb0cccfd8173f562c66603f99857a2d572bf5b38b7615900ff334b8c9f717c05a30a041b31bfacb9008957f44679bdf2e8de7a12c28739e0114fd40ba21db041860f5686f40a2817b86984f6095d4c63e513550fe0610ea3be5880c43d8c48740ec34b0389a0aa9507f10c7c5640a1e85c852ee202a3dc9546ea9531e90b25c14e3e0b16709497e9ecf5888ca573b30f9f4e5a4f4405fd47fd3a6cfe3410ce724d1baf3117a5b6c8ccee50aa282b8e1b745dfa940e07fc8a8af4d2107f3d808309822774a502a8c774d0ae71b19a077bd704211756babcda608e0d080da536d642428221ed66d949b4d390b44eecb73a7ddb30c66a11f7717f70800fbd11bda5db75cffd68c001d2e7b14fcbae6475142fb33ed76a699ae0c5c2ae54f8c2b25a125d1936e9d707b0c24dfbd62579750d0d1d3c0a92c991892c88caf91ee918e458fb27e1e2fe6b462c873d84e37983fb810cd76204e8d328759a1327456b38336c22e0f34b468807ca5fc79946337fafcb87b06ae8dd93f44bd37771d3eb805d997e9e66cffad20ec9390d31c7d9335c652fb9c195d8f7708b7d3c0f394f828e25f5a653f6ef00d3eac410f65523a9448c30b9f7c8a7752a078ea248be98036769a119fc97909180385d6dd0b431add4d463816ffbc5b72cc680d2b859491499cc680474ad490b7e030ad92e20bfa2003d6f2e5614304cbd4acff73a3565a6afc5e832f9c654a53c645eb08a7ef13a635d5402fc780ac0dc541f1c593a3ce01e5b09cf93d664215400d3fa3f153c44f47e50ef988c73b4abde12e46d3b7b9197b6353204f19d91a309444a528c9937361dbf0f4df64a1e2fbd65ee327cdf5a9bec94996d30700aa5ffb25d664569f736d85cedff8d52c01f623a3f08b6160a3c6ae77734a1a098aee24e2741c28e010788f0042dec0653dadf42e945ae4ad1a18a5b44eb0335deaab18c19d04060dc417ce632aec07f8c665d8c7f40cb0398b2ad685483051c50fd7c580003130af0f687528f83cad622f55ee82d20de0f0121d0eef55d3cf194d91c074fce47e1e9395e4741021b2218996ac9ff71d463a0f083d3a013d61fcc7eb3efb5f915caf4e7af380fa968448f2f00841d904ef2422db4794771c33aae3105f6c9c4176480313f6083cc9357d424af6e74cc213b8186314a3c6020ad52a825ce16027342e446f59e58c7055633d468e1c6d4d578af479390d9c4bb7707ff4cefe279125a3613fed160f8dcff7aa44776fcc6d3323e38842910ea3497af7e54884712f4fecdc356f63752ecb27aa6be4a6ec6380a2e659be18d4f68d4d9fed9e5a8789413c52171b4512be72c62b9d7ecffce452a63ce3dbb6ffe7274b4ac0732cd900e281cdcd95b5410f126a3f6b0bf1fac1661da073b5d55c5423b6f855ff562ce88c0e48b523dcae35f47ec573b5f4d9a168bd469eb9c5eacf9f6b05743ffc6d643082cccf52cc3a94a793a844fe40da8a768c240b82f78310b1a03c5bbf230ffe3646378690d4687e4f30fc06f5310a1027e570be311b8669987c9257ef5eb7e7bc6850fe0295315275e6a37aafa8b1e2e5f93dfb46dd10b43f4bbf9141b116275f01556668f6c3000d3456f49cec0d7fe65a1e113d5893f0848b0da91b3f1208608d0452362081c5dce062d3e7c303b0b40b26c67c1a64304e8e56e1b921f7557650bad38e59faa5c9d741ae8e1fbf504c067f8b1a4071169c77a23e610dee5d87e52e3f7f2cdc9889b928ef06e4e2a78a1785ce1c3d4fae09febdec70c1fde4bc45c1530a4d106cf83b7c7b31d8b7e1f318520ffab2d78b3a68d7f0d28721c373606be86b8ed81b8e7b0dc0b3d5e51bd3b9a10f1947e31ce1514c95753893f7dff997e8f1087993118763012ee3fbca81edb1d72c413a856f65eb13d7613b2be67efd60bee9022b52cbef3bfcfa3539c987d7232770f142df7bfc557b977dfc157cc3be421948cbd6c91fbff204404172481d9d8837f127e7b7da2eda72fb9fbc224b3f841aa948e2d07989b3035c12451be793239f192bd7718137cf4a065c5e3603687393704326dd4abce59986f9c74c59aa6524f6fb490549e8e9e9dec42894d4e5d7ec5de75a538d320461be86979a201264f33f251c39ed65ffa74c57f7bdc803f0fd7b09250c61be7796b41c5e17231fdd706fc5adab8eaca494cc5f06b205c105ea8fe923273db5bbdfea62c3babffe72e5f49b7939be7a9910c55c8e32dc7987ceaad2c40001d5d458728e6a3d676a4aef296d7c3c255ed79a7e56ac50e9c0a376210be388a8676e121a7bb7da61d5ef0c6fab88afed2bf02e33854c43e8f14f1b7811021777bef2cd3f5d965979040b6e09d9fe5501c1612892933f30d23d529de17ff9d4b4718b645eae623f96833ed5452c8ed039a50779bcc665439e7db8f59fbd1325b36fa741d0079c431c1c1db25530e8cba3a7ce0e1bf48776260e1425014cf9a86ae30fe6c5a3fd0144817d8066da3b393514d49d025afca0c356f3e2bebbf8599632b4df74e8e8c52350edc41cd72687ef939269764f6c45a45a3fdd73483778f22053a1d9fd82fcf549d308a201d8dd126347e405a63851cf5554dd6459b412b3e0abd19f9fc9bb42614f1ef7d328e919991d3dcbc8c62bf7971ac9c82ee101a7eaec4e40398b264f35109cab8514d18ec1add6e04f127ecbdb0e8f34014ea340b18302538d95b8a95566678bdfd03213b0138676c67693367012f0b520bb3113645b62502929a944445cb53b08d1915a850e0b18a2d05679cc5c2c80e6274b638d80bee3f1c67572ac9d4b3e6c6ea95606d4c3bb83ba1e4945c240f5a1913ec683e8e9cb4209e3108ebe46ad5b055274bba1752fc606c2bac2b0c6128ca910499571d3a0b6e4800e42404b5d8ce49128d14f5d402f7a25bf298bd6ded4f8cc1d17bbae658bb05a8b69d3fabc7ccf20e173e5b5fe41d3b55dee8ddccb15e65b40126fe786f84eb4b036acfb74311f884548179b0d88dd246306ee42df5ea5913dbac269594b8fe1a0d8f0c4a39cc402846ce941393a7e4e45b0e2173dc1495cbea2913c46467068f06516dafbc78653be054e8d772793582e80e5573e00339041e4788185530b4fa7747d1b236c25581ab3462a235f4c7ada43f5c032e1d63651a3c81bb45f3c7fdf2311e56fd6f2b2f5eba59daf453d338ef5024141ea92b94ae2e79043088880a099a45209e52dd812415c90debe3f1eaa2a3ee8accfd405b0c06c7057ac396f2f92381b338893405fd2b4be98a37a1a9d89c5df54c54e3e049c2b1f8a42af8a58f0cbc272d887e89816b21fbaf5898b8e2dddc58f0974c68f3248ed9f7bd30b566b478d5a96f127eee13c13b787673953e0713a76005fcaf35ea7d3da343da225496a3634f65c6b6a4c8b8a393c9425af20fed69df27f6650ceb5040cff7d997c3d7e722792722472af730b8f55791ee78de29414a1deeea4462be62f9022771d1c61d30739f6db1bd0ef78f0aba2db2131d4714f7f1760a5193b1ea823aba146ebbd1f88d43f90471e5278526966f79bf03a676a11839f4a83cd80eee6c2604723eeb1b4d4b95538c6fa0067993d4bf8d0e6168c414112698bd7b3a35ec98144f245a99aa827d9121c92745ed7ae8b61475f5dcf69bd21ca4bc90c0038b53d5d2bcac6dc8225a182c671c7a3efec9b7e1387aa14f56bc9561feb09a804797f08a42dee6dbb652e90878330701cab614b1efecc9a69204ab859be2826aacd9a27d579634ab888333cfd319354c7f58c6856b583c536a5f09638506b864146241246f2dcc884cb61fe0463229d78f6f0af3857d09c022a59f30b4beeaecccc0bff4f6663a0e48d7dedcc8ead42ec383557f91d86f1e08b3d42fe10605b22e0c7280c69c4ae670eb61c3cc5e7f6f15c5f9f03a07a71ae2511c7cbe54675926f6b96c06b1f8aed70724122b720203d6b18c6af7442ac29f87d33b666743521c1bf3fd36b5d0ff730aea22e5d664280116832f8e16fd4096f24ff6624571cce426066098d5af78d06da04050bca5b4a060faa42e0bd156557f1600ad9978f52c3cd8e4a879910e7c320b971e61b755a2b930f2f150d9f548377769808a5afee0b2051a677b8b0d4d0daec9bbb78cdbc4d623bee1e224585077c7eeb458aceb118ce1bd49e43c2c578c11e2d0c6421f57380d496442893077cc7f0db3b5421d784c86c45f4ade46ff8a008467e4681126f6e4c912778e0d10f9b7dc4bbc4bbe4a0674b1dd0fc83705171cbd12a9f6467806d10a03b7c887c943237333891c99b03d6eeb0466d608ddc9ba7792cfcdf5062f06be7b6191a6572e1a8195aa1bea7abb550969534f05b369a4e882898b79accf58443d5e62c476898c2dcb768f4f348d6cb36b9aacef65658d2aa0a1297b734990108d0ff144c06ea1e9d3a7a79ed58fa3e1745da88a00b4adf3da41ed247e8d61dd98dff68352a157fae7efa20c175eec2344b088a00e030cd14225b4a4c4fee992c1fa7c64647977ae93e2474945178c9765a649f8f8549305e0196068661061032a37093f304c80e11d44eff503e3473bb1ced4d820253f109972ea4794bd0c6bc76410c1be9429d62d360b8ca2b525bb573c591988ca65452ba3b249a03c7d5199ebcc3ba3f79f0306841bdccc34623b5ec71737d06ae1ad642ec13ee393f4741a33a667dab704be3c037fd20a512b11862a897a33813738693e7920a2484f0294ec43eeda8812b5af0b4418387c53144cdc4d9198b803e933dbf23f6355e9d372589108e12f4e6c3c32155469f5eb601fe8537a67dbff3b3a24155ec66c103aa2979cd852421ecd6da2468c03729fe06b587d949835d7a8d5020d62144657cbe1e8db1162206f1790d898a8946f5535820074afc2ae6d3e81c7c7de63ab55ce460c56c2fd3bd29a366f3979e4c6c1910e9d9c9e4931240f6e8873a63c786aea91d678cd96e2d2400d72dab983c2da1170bdeda68bd359dc2f098479a449a62ac3799fdfc188afd96f8cb74f4edc6ee227c0152dae700c436082842c265fdbe48dd5d43f0e99e8b0ac4c6ac640ff3b931a5db2705a3a1f4ba6efb1a15c649eac8230930abae799eb8e2044df54f474a6165c47953d5e9a0dbdec4aba69671f15c776902794dc8557fa7513a33751b3dfb4499342edea0e97d422d196afac73e35e03dc38e2652961dc4dd1d46273574ca5c4b3d00f5b4c71ff7471e4626673f8cb59a27b9c6c8292c5606f7333a539b7eeca3a7ef2a938220315bfa5bb8f5b882723fb7ccfc19250b8391d431f4d1778dadfa3666e65db2bc5deae4a2e02e28f07aad2764d272efe0a6fdc3c0a3cf3808810eeffb207bbac00b5c0870a07283065e6fbdffd7f7fae1ef12cc9fc1eabbef49f286c28cb2cbb3025e866de0448b8454b7e744648750ca065e95579cc1ba156891bd3cd3e8059d2b861f9485e25c186263956337ce10619aaf48aec5e20a5a43524d1971b6200718c18f9a73b25e56ef73f3fceeaea66a0d3c22260f4886714feea12b51e23995dbdde924e184f8d5544a613e2bf43b1ee263a594f70ca88b33059a1d04df485e573b6f37bce6f62adae609afba7c489b67436e5cf91b6936cfe350441439e074e6a7acb27fcf33bb7bece54650d601d3f3f7fe6637504e5ea989001eeede4d6bb988ae749aebab31a933df7bcf6fe32f450b11b76813c2785ca84399329697a06aba3a4d5c69ce27d3985ed318e51908dec231aa343afca754caa305b714f8df450381e2e9ef5d8a11329228775d7cfa59c5b065f36fb4cbad2c0e7282e0db0891ff35367f512b39308b5d25f4804487e40dd9a00cfd71d9c3bccd5597287ec39405dead1d50d6904ee96629b0a3756f30af27d9ecaa8c937f99a1d70391834e10317d8e00e6cc09b4a253eca8fe42e68e1098d4ec9eca411e015aff630791ba73035858b2d043246f0139fe535fb1baf51180d553939dcc56ff930e39c2bcf6abe5ed7cb15b4c6a13fc95b0475ce69896fe20c6ad987d89e5562804f1abb452f2d9dcd16b5b7a87eaf54411ee2c48058d08073a67b21a935840adaf02496c1ca2c3b618c2432f4ae1bbd3e66b47a516281cba014abd6f58cdb590238beb88544b8c21c8b6b6a0cbccb34715fc85cda581604ac8822a1ed680ba9a5f922850f12b2a6e51ec2da7d557e14d729322db62739129624d114ea15c16027bd9248cd706d73b984cc59be405b25677b91f60d61c3aab7867078390c6a0c7165e6cf1cae47f9a68046ec85d10748fe4cacc3662f60397e856042c68f391de94d02cf0b62b2af4eff67bcef61dbfe0b62f061dfaf74ac383ac6713b4c1657abcdf52467fc4bb1b8bfdc25af84f6286864e1f695fc433d2d40d7adf5fe5f55572304c16a20eac4aa45ed8dc1410f65464b82d20b8587e0eb023324cc7709cd39bfef1f9458ce0a4127fb441ae3a7dcadb5c41e834e2c50b49297bab7df75aa39a17ae37d7441915c82783ad0d8fed51ff672f2c54e77b0da6200ed46cd4bf377248a505066426a17eac38ccafbbd40603a88e4a48bc596858dca7631d4aaa02fcc964f60c46a72e9a9f649e90926a4738292fd77f27696de0eece6ea6e89075843613fd5c5d2a413795c6b646eb9ad866303c9e953a89712ec529a41abd9d105cb0e77fd951a7257d5f668546204b2f128799dc7e662c73138deda8e5dc53358a67044e256092a5445f23be2e7c9dfd856439861cdbfc25c1993d861cc0aa05a2bd1e1a924407d85fbdac9d6eab266aa4082a751bcab26887d146e5ed381fae7f7cea4eef8c619138d470dc2c6faff92a762bc1d3465f041e1ff32e1611b303b2f4e49ebdb04744f8c96793e69ae0d27a915a4d966e7977d33af21b425132ad6743f6657d4cd6a786a7b902bfa01c038af536dbb3b7f0e5dd210b29b3b0d3364d57446d131de5510c0fad9987c8d6e0e1d81ed2a46128d778eca411b49539eb548024a13e7477d9a6f1a6cc3dd879f3cb2c89211594b0645fab966b05188b2d34a5319682b1dfe544a9453dbf4d31f6cdf9c4c2ecc27ffadba746cc892f7d2d2080ed858629abce0ef50d4771b8570b79ac764a3ba03b81436a25f4ff4a9b8bc928855c63fed5cd8679a68268751cddfd823cb78f65d74373b2a70334760bee2748c3d55a0a683e00f7f263924afb67dad80156710d28527310609baccd156f6c99629ebd3006aa8559f63448908188386caf629a05306aad3a0fdfc5135858413a3b296a1f1a75a70e1873618bb23f639d267a00c0363046d1d0f6391499d4d8f03503c4debc0e6225a40f20747ce70d8f2b00ce6cb04bec57233433ac958a570759f7c43842bd0c8ba9fa4e798d373331108f074f319f2b5f2771cea7907e9b5a8d4469b9f8966c2b803b47f080fcb5318abe4a0050d08941f0fbf5e0a20ca4cf4731f7263a1a8b7ed32281303242694f007e9846c5fb368421272e06a4af0da5c452f21f9c10acff627e0f106cf1328030aee69789010b87f1db4796e57f69118c9e062d80ad3f06d65c1b6729f6eef17017521956af10e77d6cd26985e5c00ddd29db6cafbb6669199dafb158af4e34b1a46736994323c3e2c09ae7f9340f955494e2758e5e1098967b15cbd9f46058f3ada060ee40d7191ff0930371c6c8d9fa95d593f07f1c5fe1612cb11d00d4b26d343b5fc63548d41007f961f1434dcbb0b6b9562e67deb7b13e40cfe5f2df99c26f7ea7882cf71bbd092c9022231e52feca39781e50e03c8e08e760ff9d9a8efd41f82637e7f93dcf41ffaa7276dc09a91f4ff23c0fe2c1ed4bb5b387ec18809fe5908b283064db48a392f60e03b7eea7f0e12a6dcb5c38689a8b24fcb7eea8407b8aa97afd455cc1a4b9ddfd30dde064cf35ccfef77e8034d494847b305d9598337baf0a386c909e182e67f75bc9f57c58398201a794c4817d3837b580fd4101767ab197e8484e8875ced2d2373bfc30c1a1081cfb74b6dc68046d9cd784d688894cc8d5113b9d1196afa6cb8a28df82361c53300a003000a001600d000202a00800316e91e0f0a564ffd00da939301c9295966a752d0822ff881f14a664ac5b74fdd6f1ad272e38b9576c0b4bcb3f4fa1715eb7f21ef2e4bd77cc0ec89d302fde0a587e1ff9cd07a11de95afdb1b9acdfccce99f743c7765aaad2061437e72fec1559fbf84997b9d05a31708f52d674c775fc479f78485597be3d64d87668f771ea4f2ea9ed6e36783b110b3134f1e12c4bee6e186aaddd9509c5ae859f7affc40c4161df2678c50a5f8a3b43b5586aaea1200dff9e224c42442a9edd96b1302e7ea5f1284ba70357eb185c25963fa94823fc17609e66266a5707ae96df9025570d34c88cc0fcaf6abaef588bded6f29d3f22e03b579db8e1aa0bb317896db3c237893a0323d9c7d69d6f232e807bff04590be0a8fbd74486dd8be2468966ef68ae1117ae4003cff53facbea2eb97aed4c0dcf57b225ed0c3356be957983021d41c14bba73a785a8ca7ab3fe8f0c3889fb2c7a1c96cddced5e6040f2bedcfe41e98442a4683cd01550f49939b4048b432009d36ae8b4997b2bc783546bbc569d8ce64c761937b151fac08ca1a091da6e21a3ea69940c891facb6d6e7ecde2b55a439a56290e2efe33ad89a10dfc97197486f74e900861d0caa6e747a47f9224d33b9d6492d87f4bc42ffd9759247add2f39080e72e8e01ec567dbf83b708d59a351ebec73433a1a19b79e3f3662f3b8ba729afc4a57007e80f044bc4349a880616e71f1c16002b6eb08f9f01a61793b8c133e1f72f1195f30a8a7db4c037cdd850fa1f5014edbb0331863d1692d65bb4039d29d812373d4896f70420bc6a3744cb43d0aa2d5f4f643997ad4fd98cf81081545c2cbfbe90635dae8e75eef2b695d77578390b350fa1fa4b64f226b4be7c54b066db735e4bb027b6e95900091be946d33e0f37ce0337a01e0b001e202d80c8e6bd3d47d89f7585f0b668d5fcdb66a48c0ec63a76ed0766d576f695e1aa12725a40ba549b1bca02a5a9db5038407ecbfa2f05aa8e62f37bbec4ba2c60b43b29d5c3fed2c8ed617cd6165afb60f3696f04baa98647eed8efbb8687523deb0abbb48a85fc20047d12f629d84826dae0a30c7bbcb3bf3787d186d86d9c518718dfcb49cba91be9ce48fda10fec5a78d40037fc7078a23c59e32c8f5cdea85e02e24d989370ff2070ca087a1617fc81867bf855c986b26163deca5bc745f4a25295a061db6d4819d8047cd5545dc66e67ecc24af55fd00deca200ff46dd0c43aa9383ca05e924dff743af420182621c34a3b465cb7b5557d3cef8caa1a8827b1795c1267ada3f2f37a0ec884daccdeb1ee61d61edeb3677d2ebe59f502e99ce9ae652883786c1fe657887824aed13fa852c1e0ee5c4706d583a0d884b1b2ee26a030eb44e9863b5375823f4c12b980dae77dd7c448a0228aea726f4e5a8e11759554f8e6f72e7592acd47a1620dc3883d4af230ca975ca87f03ea13a7569f4aa63687eac28d6dcf83966a546487797c452aaf7d9915a649d01f690bafd8d8558566bad9abfed313e293023d1490207ce971d6d85742566568e1f08a802d70f4f2070acd5e2e8f691b955fce22b59fe94d49bf9817a29c58c74b91a16c5ee50ce7bcff5dd5be05bf250698626f290b9d943fe319d563bdfc712fab57ea2aac38ad57236ccfedc378eae9046b09527d02b5aa5ce8ea38b6b3586e6efa2d7224ab0de5b2f36cdc05d3bf5e6f9ad6921d1671918b8653033828fea71a9bdd92a4175f42c9f634055cc4a89d950e6809350dfe8940b137b3c832672ad4e5664f9ce7213e3848e3f7d5ee88be2e9fc17aed09feda48a3a3a1dc94c9ca45ba0e500f9dbe231e90bec78f91b89336eaf70a90adcca493b67b44c37f8fd6a7f21afd06d6164c8e8af28c726460fd46ef795727b8fb030e5230ba72312dd9abf5ffa5099c1d3d156e1ff43ee649857417fd628c53ee78aa6b8f7fe23fba21da1bebaeaf183803f4dbc7e4cbd9ac0f34a9fc1aa37ea20bf8e78348beadc665d08a469d3d40ed5c307a17140c418ece6fcfb70aa1e43feec6a49762c3504c7769f27679e5fc682a5ecc6749acc043fda3674956f67f1eedaf65b29da8bc899db6d48decb44278c3c0fe17de1b663f4dec396d5d5d1fd352ffdd5426bd2cfd4fe38a026c32314c11deaad8548ab284a6c20abc53952dff633f99fc6163e15778f72314984d5417106034b0a671ceca2ce9a2dba12559014c2039c19c399cc55a4849ab99c565b14b74c0564d2c49f04b910054af2c500516ec8f22538f1456e06a3f88e7ad5f3675bd422fefc03405d594171ed4f9684958f092a8d16c987c84c3862b900a46b92444dfcc108ea44e249a6568dd0b4567ea70f375a5d98c25f4b9ed900bd76eccaebd9c376ea35bd0e073ffb2b7260509f3fbdaa26dfc1c1ca92c0b6f581078d86ada9f1a539a5f36e7f587534fd73078eef37bcc1baa69253fc724d6336c7e261369ba076b2930f708615e32e6e52ee8258a0390d242506cb011c85766f1111b00eeb07a6900b9c6b44f1eed594386cc0301d223a919cec928f18de709dc7906cc6cd4ddda0bafc40e6147381413d96932e97f607c9067754bf0ba9578bb21363e445626ded6c67766f33deae67cdcdc97571deb4eaf1901deeb8f8460ce4e1830b6bd58035c1869862e5e3a55ae10387e61541eaea8d4d6b861e3d4d4b8aadaff30ced160074544f941648e41b72c165d3160538113e7d031de33d89c4aac68c714c13b32c5ac1a8673028090762cc6bb893853f5e2c5dfa13e9ecdd6cf990fad7067c60194b585a11a5e68a767bc8e2c0f0da692d2703e6bf1044a329210dc9335291db43d619a9f94589665dfaf5b59adfefe88004575dc67276a00cd40574ce6c608f0b963d53801030f0323bbef84767988951bf0075d5ae995f86c8affe0bc9898e33bf4496d10e00528e30d669095d0c0bb68ce281ff04fb968bdb2263e8458ed215dc3bb682c916b70531fc9c1e0c157859f4f8bfe18d65ca7676299d2a06a3aeb1e9829a67c904902eca0183f5aaacb1a14ee40898651aab968ef6b3a3a94a6b3e86b8ba60318c08721993225d72840d7e651f5f014d87d6d96e3817a3f9cf899a8a6f40fb39287c8802825df1d0e0cee488399646f1f78a266c8226a73111a6d60b32de2cbf0cba142a640496f90a72b44df20bb41a179ad6011af9bfad62f4f5681104eb31393280558fed38752617d6d43eb2b7a02eb3f50261f4262225a1c49b4bf6ff3f6ebd6abf3457862c8369ed1506f1715d2a901c633af4cf378f757747ed57ddf2c17c445b910d7f6cbf789cb609754c21beedc871aa5ded75ab19f994949d93d06b880788353d908854c21f7607480384b0878fe0d2d4bccfb9ac9d7f65d318f71d4524aa5adc74b49306d200cea4952d60af73b817151bb5119effb0c3bf9429b77c11b19087e89165a951b743e7a9688a7c5a04d813d414c90c78dbdc0425c0bfe9f1293052ae88df1b9a60bab5f7b883ba0c312e234eb026fc0c9869898d982a3ffb2a98da8be4b5308e94e1cf72938a5a7ca0034cf14833731a4959cd18aabb95177cf4c8a092609044b4dd5ccbd49760b6aac03edb8379d53283e0e47e5719b7596db74f6d946d72a6b2b523ad5162aab117132d50ba338c69be3ef4a1f62f50702c18eb62971b8fe5a746beec7b0582c8c127ae69b07f7e6a1f8f4621fb8c1b43b0d157d47f948c1a7b1250c776649ccc9b3310f26110ace85c76a04db80604b6dd06e40000bb691e6a3890966dc50301df01ef9b2c3d2fc4f419f7d72d711bfb9d68963a972859b7972e1a0db3e392b576ca6e23147a232284ecd9494a75bd0e3cdccf63bfc7bec32404e22524557ac751b2dc6aa33cc3929397ec75a8d290c2e0a82527eac5b62c43e3b384ce3eb5dfebeaf86b55fd457161df2004d4c8419a4b3d24becc1f17aa2e288db63b55a96b3416d4a3b2bfc9a6c6bb8c7c1f1cc0a94273161888d07a91227387c33d240b17fb27c8a8071ade1f11b4073e6e869efe27347e52aef54cd3d482767a30b846f6863c0ce6d6c026d835300db594635392134032552511f85b82150d57ab3ceb49c803916248c1ac1cff59c1cc29504c1017d1d7b6789eb8858c545c2f43f8493a4bfd3d9ee9894a5d6cf8e5400f8f97a69414e680891cb32823e8113adb154ad77f02ec3174456121aeb04d15046018c376791155f2e45f02f1c3aedcdb5dc9d3582a3487ccd9a4cc71ed0e22b41079b1b70cc380e5f47cd0d2e627368287346d0efc433084183be92fef49e0cfea93d7ad341f119dd2feec3d19156250b7a31133e812511f34dd00019c5205934c22527f2ada2e0f99d875e3a90a0ca489fa42ccbd732aa3c99939183dc541223fd1839c6601ef004f51495ce73e86b17cd991086d7969f2b2768c1bd5d72c79476d491067443438ec60548737cf538081a99ca9338353b5600db9d4a3ec8b9d0c568965908e8d44f3467aaf654f592c9b10ed32b65e690172fe34828afe285e994f115291396530f30c82e8c283dd8a8f1b60427a928fa3a756c19a676a519c079f0a573d58551edc3dcd2fe69c78cb735dab07decb3b2781e6c41feb573e1f823ee2c13dae7e46444e892cc49ab1808c3867bbd6ca0746be316138a0b7ce661a87d183b083b75b922006caa161c5c08dabc0da06a64a4edc96c4ebd47545f378e40831468b4dc659a272ea6ad15b7e891c090933ef3371d9166b7dd71b0c4281671ae24bce535ddfdb13e43d64d500b1c1ca476a362e189d34ac6ba856c5e6832fd003e6783fed439026c0d2eed3e0df85fed9bc6a4b7f1647f30047706e58dfeadae31d0ba81d5db7c2354bdb3dd4f4dc8c6448a9c3a054a93268f4e1010f08a3ae782dc87c35491ce8f784e11da89c83a80c5d90e3aa1a20cd9e38d46ecdefebd25838864d442d26409117168fc07a14d71813ca0313502a8f3f9935d3c0017e56a77edbd19147296020709ba08fc083f94c955b36539bb7bacb187167b80792442496a923d747b00fdbfa5bb9d3b7bd5e38b1e4ef45092071a792891072e8fa20f96ba8cfb69f2ed636eede3227367a7585b8bc7173c4cc0c3c42368cb8ead345bc02da557cf3d585e7ecf2b9deaec73d19e8414940321241588fa5026fa438788866a0734a6776672d5cc0cec3d5f2edb3b9d65747cc99cd0b1778e4d3303cdf2f27099c3c0325f1f9615e9cc7f1cf378e6ce5c46c7d7352f121daf79915c0900faff7a479cff577247d6d21d64eeb863c97fbd77d0ff9ae560fdbf1c2fff55ced4ffefe424fd57b2cb11b297ecd0c20eabff5bb5a3ea2b931dbf7f3b68a6ba3a12f0f55647ae0e10eac8311bc5af0fd37155e938a2038239103047d57fed73fcc431234e135f75712c90030f39ccc831460edbff5f5d1c69c471260eb2da0b871a38bafce01082838237aa78c3ea1fef468c7778c7bbba07b41456f91e73d58d2c37a6dcd0a00d30da30a18d0dd810830d16d8386283c87f25733f9dc6bc5c6692e293dcdae7eb3db4e7f25549dccfdcedd945eb14cfc0fd3b6919cc6d1228cf3d074d1d058e01e05c8143548d7047b27e6252ef9c797127896bc2916b94fff5b5c61035b27e4113d79d1a55bfa3064e0d9dbe4b6a9e9bea91a601e783b9591a61ea2b0daa3480bebefa0536bdd9fa7f73555fdb74d1a6375c7e466f92fe0d7d34e2fc1f41e38aa28146d2ffde261a05fcffe3805863cc773820d667d470c6ec8c0ecc78f335783985555377a798986165860a5f6fb51a53c5ba9c1913b8d17243839b10dc7c196dbe5a736f6e69cfd645310f962f6b5df456a332b294b15406080878a30e297d66afd2982f9b1b78e0c185b26420800c27c858818c236db4da00d1864a1b2063dc31069c31c08c011c2303366cd818c18604362f31ecf8af3e6c8444b7aed1a8e005c2f4595eb39f48b1d8cd325dbd63b1255deb144669b02471faea7031a64aa7348dc26ad944352eaf2e9b99eb74e5dbda915b2b064e0c08b4cad0eaa245b4c6cd9aab355cd64cad317280ac034c1da0270c337e08a5d5ec3c1b199dd0173eb9e9a22f17ce5d1d1d69595e1cacd67307c7cb474b751f3b0e97b94ba3741b0ac63b5dcf3e8cf92e5896b7e3feffc9ef8401465613ba4d30ac4a30a66660b8bed8fae2ea79367b5fd88efb1117ed5f50f3dc6ad0d06825d550a971a901e285d6bf17545e3cfdd71d2f78febf6661bdce9b84acaaac5e9652175b5f499ca37c971878bbb8aab60baa97eb76d105fdca05b9378f7281f55c503d142e92ec6c01e7ff2bd98d6c81f5ff556a8baaef37975b24556bb7e0f94f03e7d360a569e1abb532998c56b4ab15e9b053afdf1e59d68265794f4ee6232da6ba163c5968fda6ac3d77308b25b2b05f75a6dbe4bc2c807c182361610725710e8b3075ebe0a51a0baaaf583cfdff6f2c8ca071534ddca55434366041834343bfd64ef2bb737ad3717685d68cee4a7c8597285d7e7245ef8a0bac00e3bf623ca356dc6085b642c87f1d476b2d76aa028c2aa8fe2bdff49298ac42c97fede4ace451aaf8af5055a854a17a4685182a6cfaacba29d89822ccff578ec9dcf53ed2f593da296c53e85ce04c0a3752c4f0bf779a16852e8a09b0f2c052022b0b16396ba2e3d010144d401100282e140a3cd1e68584fa130738a184134027ac13449a98a309ad87a242c76ac926e8993767ae3843c3192c678aec1860ebffe9489b68ac7724744442ea2b65800898d062020526624cb8aec6b8c2ba0ae2aab6441f4b44b1b384124be09608a2841925a0fe5f08f338fea12f9779713566855e38a11ae47a9a29591ab34a3d738f98a7338f635fb7424196ee68fa1c7137a374bbecf962a9ab53827b26a9f1d8318f6325252a78592c762b9ada4637895c1240ae7e717ba769b1d8cd8c16334264202103124596a4658931797d348b7ba6be74ece9cc1b553b62ea88a32388bcf93b79df298059000facdeec58dd600582d50e01b42040553d3a72d52ceed72816bbbf608ef69e7b3717ad7c739d5dd4c6a8b975b9b9cfb74d23dc30228d115346d022ba28224c114f8a08abc5fd5aa1201f1b2f771b840b72535fe0b983e70e565cb38bee1eecd22eaf06f5264fdc7f9ad4b8a9e30ec4ba4c56193265a6ca2c512a83001158b59b3b445461222c113a4368e9f41056bf330497ff1f62082021dcfc5fed08c1e5ab105688255508325aff64ccfc3f991ac824fd7fbdc11c19d74e105a40bc1404d54e1049fe7f4c9cffdfe7183463c8e43154ff558f791ae31a03e4ff81c8faaf647680a07a2034c6393176ece0d4f5c962b11b8ec4411c259391b458ec46d27cd8a4c562371f36f300fe872d7e70e107a31f787e681047b94cdce4030b3e3cf940c364852153751800f4c0460f34f470f64079d88287137818daa18d1da8f87ffbca26ad1a197d3a20ee75cc77dd8773b02cc9cb31df1466764cf28e9976180213074c1260b28041327193ee0bdff982bf4ca043153ae8a0c3eddf87cd0cc47a27073239ec7278e500e49f6ed3d2a0e9c5031cf6c081091c64c041041cc627cf5cf0cce932effddae80d40dc3075c3941b10b0818d0d3fecd8e042b52f17f6ed8eebb9027db8675a8bb3e1470d65d400a686df7fb5380a47f14d69808306313450d150c00c59cce065062019f2e842063132ec6428ba3f5d2673ce52580d9e395cde7e06cf1cdd669510552d544955415545a90a12039a188c88414a0c406f7d96c2acb61416f3d11faa712e667bc71a0643171892bce0e685245ed02f8c6fed6e53174c178ab4a0a6053228b430a585a11682b0f086ef1d16645de2e8f244972532f89d2e5e9ecb175cb47009dae14264cb165bacfebb111f36f316ba821d2b58b1020b2b7cb002102d2c6861d2e2da518105159a54e84923052f290420052b296880821d2850f15f2d7f5d9792de0d0507042080140420446507950f54552a8969d5874d9c3b61eb8434279c7042d25f18660a809a9d009c09802e000fec98b08709624cb0b5f2d2ad29edf9eef26ed39789bb8b9ab8290b145978960c4a18a3041e4a482aa1032c6760c1fa7ccdab71b9db5876825004b30461c121536d4c113175c314d554d15712e782d707abbaeec3666ca6c4fab0992dc53025b0d8ee08a8052c03840262f0ff3158b5b6779c0f9b198731dfc9e898e49499e7c691f9fe2ec73829a0ffff73ebf4f2ffffeafd8c72fe2b812931b199f55f7914f36be4668e316d5f03663007c41a87cd608ea4e1cc6f64c6e1cccd7e4da86242583335b3c091254c35739991b29cd546963b4b922c40be92b8842d96c212aa4a48fa2f81ab81c5eaff93b0f0d059504d904bb0289cdafaaf98df5e96d77769309c9af2f23f65a78404734031802c84c0df3fd055cbf2fa3adddba4d966525a7c2b498579a9258ffb792475c05712632cb949e7738b93eabf9e40d59cc2d96cb3dba1994d093a9cb093397b972a77c7fc5696e7ae93df25e07038d6bb5bfef45f494c7b374eaff4ccac6d57b45c09fab9c9a56e9b94c4e5ee7aebb6e6b34a86bf2a0ed35bf378b7dc456d29fd4bf235092c5bca3b73bf7047b17f9df274e69b735c37d04c6bd59da69ae9f17d6c7c29f8824a389803758eaa1dd998e8cd5294ef5e3bc7529787250fe5d37f2d79f6521496e5dd7217d54394ad5abacd282015eb4d827944c209ffff34db8c9ae5ed32fc0bde623159bf49b25b51afdf244ceea3dc940be839d19ba147ebf1f0e4e0e9c0a3c20bdac5f9d1e2acb975596e3df21ca9716ef4a9758647a51d98ffdf25c16ce01db00e47109259ffbdeb8bb38f0fb526dff5ab336de4944e8ace486e8d9c0d39107249ee19d789f05eb943f787edc262b11ce0ce0871070871617022e08258d9c38a15cc0677f98399fcfa6ea71877fe7cb7d77b758cf57e6985b27ae3283466cdf276e0e554679f4ad22324e6714b7d6abf3c9ea53e40ec4387d47dea3649833a1fa94f235aa1ec0f85b2b7d7793a5b91b242046a0d9497af3f6cfab02e77a8a1ff7f4b75de65cc7f18a94a5905032a5c5099a24205c99433a6bc306584294323c019a1cc085446d879d2aa50169fdcf45d12fbf0ad665c4d9de92eeb4b2994d5653316b354f0e9828ac52c151d27b7a9bb519e76788222a58fffeaa27c5639d6c0ddb30fc9d7b30c93fb88c453b7c44c25e65b174ab1752914f0947a86e224c67f9d39dd9c8e38f544c9238a9830cacff24b61bb5cdb6d4ad238b6349334da8d707c7323bc8d71eb12de8cc29baca98da61a6aa7dceabddb556fbd7937172c390e9663c799efdba33d9316c7bb39730a6b29cc7fb1d88dbcb857e66bbe9ae8e8e42269a43e374fe291678ee3b2be92215398df6da6a9af4c400fdc5a0ad37f15818cc63f8ea5b69226119644789a8900544500f2a1cd46c35732e36c08d4d8d4ac086b586a4098ded3b684c412d5925e02fa587f0529bd51a2416904a520509480c2a5c248de84e39d6db216eb274b3cd13d59e0ff13f8f0c9014ece70428493149c3439095ea0595eba7b79c78a6b1e6dcf2151589fd919ee86b41e6859425aa6edfc7f0c86ebbb4cba4a7a4ad2811202560821b83e98e3bbc95613344daa824d9af03071f353d7c7c40bf63149fa0f320182e4e6bf6a1cb5790ec9cb77a4a719920e3dd23afaf2ff7db7cdbecb232323378cc2184d31d2998151cf1da43498d39bc463e79bc4313258f6d059389332a3397797785912b524b6040310b4fe6b4f4fcfad5663022129048101d91ab21e42991559051f50f1726d4ac30f46f80082a233455bc2a2a8a29ea2204a7aceb775bbb414d6d343af92590c8f308615cb12c66e1506f3000b0f82a107503c3820c913611215ea8be2dcc5598a73b90ee074504407be0e8088d80889b2422217be9eba7bea3ae6d61acd3808830314420ea6381832b4c5d0008644181a82440d922d2192a0ffeffdfe28ce71939e3b6871bb8d1b427da8b5f487da20ae772138a110d6bf9097ff1a0a3d09b978fc066585415e8292aed9cd73cf80f8d81a076f2800c180747e041e39e2083f82a4ee51771b977c9bd7d21ded0ceb0b35090cced7cef386e9de83fac25008614d962ecd926eb4898912ed469930d594e8528d22318102657644991835d1924899109293a7334fe711ebffe48d5575b43fd2ff89f3b5bf30df3e170deafb1366b77f7a0fc4bbf087672f853e702ae953f53ff3b17df5e1f97f655d20c7e42c7c51e5a8694467aa8486afa7af7c53a1dbebff9f977bcd850574bd50cd9e4b59d1d4f515d152c4a988920dead8a08c7003321b3411e183c812447e4490febfe3123635654a595efa439bec58e6a89a0db223ee6714dde39dfb0e29c09030e110010c5132a4811e37c21e227aaa843d409ef6b3b4514a8fa6d01f3ac555ab18766948efa057140c2d814285148130833032a0fa7f4a474b61c172f3607ad311030f3058e002362e18407881ed8208849021c4082150421c1823b4404d688196d002a6d0820bc20ab0082be8153c5500840224420ac6841448a180011e2e7882b3232a31ea437ff02e97b49b3956edaba9a976a4c9ba8a58ababb4c955b3e3d854962e9a7b367f2f17ed14c6b7edb69fe58f8ed6065118b5bb7cf99e1569dc03ea7c7de1046e3e9cc08bc98d7c38416f827e811f7c28419cff0f253042825e28c14cdc0ac5abffff99c8e57f168abf2ada44a09ba813c609432d8c9b8464be29b4ffe3a74eb7c390e73fa82fad4ae1ced6ffbf041fee68853b56e14ed5d71d9beb77be2902381170f155262b9ada463257eeecb9b343f0e667101ca0f326d429a383756ea18e90ce030fe8f1c098f0812af505d38d30cb64e469a781588fa10354a103b6d0010dc206daf87f007cd8401a0d50d1400b0d9cd04053d8001006900819a8aa2f1bc451b8586c577335bd6c94beba111285d50e8391e5a6d66673d55e40ac5db41b099a3d77769be33cdea541dd1788024cb840090b38850b1c102a7044a80009a102b250019d8741d9bdd3342ae4f599b6dac2203b0c32250c127ac0411092da010e81680981140199204c008e300123c204aa9ec952582e4c20294c80e7bfd69e3b7b8880508840901001044200688500480300600800a010003e0784718055b52f26fa439f5c354b71101dedab89c95a8bf1aed697cbc4bcfa72f5186c9be7a53897ef0fe3dd2ef3bd9bddd0003d20f8d080364203aa080d20131ad0141a208605c829404c580094f0c71e5f7b13fd9d662c76b33e6b4baac4c992fa863f7ae18f26e18f22e10f0ac28f23fc1dc2ef127e511f73fa78f34fbc3e7afaf83957735298639bb3644e057320e0e3007c70a99dfed0266b852c85551826b70e669f6024bfbd9e3b3bb54da40bc62d138c52db4403fcfae868fb2cce56128d8305d3671ca93849ffb5cab1f535cb81f5726cf9c7c921c611a7963b0e20e29012c70f38848083eaabe5b1d8367376b769af3c0783e5b9437a63cd1b27bce17a230337b2dc38c18d1f371668c34c1bbb366e6cf4c1061998f34c831948ea4b06e99847dfa8738977b4dab9c6baa7cb3b1aad5b6fbbcd5186b1e4a658ec46c7974c26bb15f1749eba4ae62e9bcc5d768ec98b7b38d90b4ed6c3a98263fbafc00ebcc1f935b4fed7a046746d8daaa5dfaf71fb7ff2aad1871a6dfe5f8dad46086af0fc63a9edfb5d60532c7623c96bd338401a574f92b358ec66e2591ab4341a78a3554d7dcd29bc4d9b0de228fabbc03755e11ba537ae8e0619684c8186feafb6fb2cedddc45b771c44c3e88c38ff729dd1cff0c08c2d1c745d9ece52179739ea3203cb0cfb66e8287193e5c6ea9fcc6e7a5fbbedbb7db91b9b797d3d2bb90152fb2ed19441a68c5e19495f06fd100173fc63c90878820010c868830c2c3254f851a23c9d6d647c1b356d826883dbdc360d8c71660c2fff97e6ce265a6f6cccb0d1c286890d0562a0214612627431686234a0e546cb072d520b8916903575ac19c01a14d620bd92d1aed63f60aa313149bad198c48c90826ccff66585e80732a1207d79eec5f7cb0ad122eaa2353c009230f608638e30be84f114c61130f800c30a306000e30a1844d27c31c517515f846a9a08d574351a7841871761bc7812666d3d45027bd9209b750951a35dcdba68474261f4655f41364b47fb52a231eba25d88c2846c76b7836c19ef603d93678d846cf48706d11f6ac44f3b443ff880be5cb1d86ee376e7b1d8cd5294d69ffa53492c952f90e29cee76bd33e6b9cb37a96f173c74a1d445045d24c005125cbc10858b0bb808c2c56fb1660b14b6b8a59993c68e304d99344f698ed21cd1420c2d7cd0c2a605d0ff636dad92ab666db6bc9472a099b9ab66e9685f4a945a1b106b6a97ac925da23fd4a6041b5279575f5fcfcc409d0e7613f3ca7387f9d541d96ea95033e39ec9bbdad2213558624ebbb6487a5792e29c35c546f4977b1d4b658143165ab258ca22812c7e6041c4ffaed669cca7fbf4a9ebb3d95c351af3a1584ce98cc592ffaf4634163c51d0c4f90fd160fda321533b1a9d06628dc656fb4e86e68a2bf20a2ef55783ed25aae48a5e7805fdaf405c2c760bada8590142156b54f1a58a5d154e55204085175464a18257ad893b8ee3f245a3ae198b59badb2e5a5f354bb3c1dc1dc912fb7254bfb7a87e4d199410122a781eeba6d8fa29acc229aa483c4592ff1bd5bb146ebe02b18eead794428aaaaf522491590a200fd35b875184717f19fbee5254bf375914bfbf611421d60b2b0b8bcc7f25b1a8b096604960a9d0a8ee0beaad6732ecbb4b396866992c16d365287e2114c127e0fcbf9ec07aa2ea770f183ef1abb42792c462b7279cb8aa79e704d557276c5f9d7055276e1356df9bf8fdd7739b4d2cf926787a3e03a7d228ddd2992b7e86ea4cd21903a0b906e08275ee66802524135b4c50e193d1e8c8040357695ca1f9aff6cabcfae08a678937d5363d29cbdc97a05aa20325e850828750092c4a24a94a5e58eff2528e8178079c254146125e92302109a1248a98c93223e6ab6dc2516b668a191090d8fa4ade1aad7d4b9133247a40a206246648547044968fe9887dc4ee88080ad04601c014e0cafed19ee9ad1b89d2f96cb2978bdff2cacaf21ef528dde5264e675911f6e59b6ca4a302231d473a8e244d26e36637bb912226dfbfdfd9713afb703afba4f879a4b38fa7b38fcb64b7225cfece5b910e3b9134dc35228ede4658fdcc88a96a499a35e2a9067194b9978c20229b6231d9ef37eb9792b422cc22ac14a153268d32539479a10c07968ea31d6db794c911264f9eb86ab632a92e6a7b103fb14f98d01ffac455b3380546d998e4ec5846c724671199711ce31fc744e8f4c221dcfcff0f613544d5104f43f07c0d85d8aa24e6098146882a2184709181f35fc9585532543adc69bf3d324f644232f4fa82082308aaaf63994d7de61ec4d3fff374ee4100d97a0c1add49eabdf518aaaf24dfbbdd1d637f0c2d331070f0145e02e2ea4320aa2a1053ff0fc4d3ff3b01e17a3170423157525ec4f4fe5f2726898ad991117120945496f7680a939af6dbdc3680cac60f667ea8e187da0faeaf967c59ebf281071f62f001c90707c2b8e1d4e9e5e472da2676da26760aa31406d6431ba49b73301896d23cb8e101061ea2f4b183103b60d9e1680720601000060d982b606c602cf8d2e6cbd5971cbe00bf98ff3e3e58aa0c5edfe5586ac3603152df1d4ddf5ab1b9a5b636cbb3c328df74dcd1be00d5ae83153a78d161b799e84b9b394891430e403958e0058d971fbc287929000702843854f5dbbb4cb72da56467bee948626b39c661c80d5aff7fc3ee06211be8b0c1cd5b5c2c26bb15c5629d7e407fbfd0869c0d3a358c514398b0862e350c551286f90f47031b210d6668508186dfff101a1a98018b19bacc50e5eb8839efd25e5ecdcb4d333020835628830ea10c31c850f4d5be8236d0d4550d5195a5ca15c318313011432e860d609803862560c0c1c0c0e5bb499020e5ed3d9ece96eece1cd69bc4658e5f1d0c162c83e50b48bc90e505272f087121cbdc3bbacf2b5bc9c6c18bebb962734bd9ede482052dc4d1c20d2d3461610e16c2b050020b1bb000a44b01c22e2774f1e1d2e675366229ac1bb13dd3b4a7a5e696c2fd2e792468660da3946faa2487b90b898b932d7a6c59638b9a2d02d8e264853a56c0aabbcc7167b2244fdf6a07ee1586b4bcd1c2464b172d4fb4e8a870c70f2a2c852a8090421cf54561fade9ee9a2f6f573d52cced158497176ec7987b9e5e97ca9de3b5a95c2e6b9353fcd8e83b707afc6e6760a96e535352eaf997f578724ebd8dc4eae221d7632b7d491ec6a1cbcb25b51efb25bd10e67f6dd1b22ca587267e7616ce24e5c96389eeb3e5cea868832df53434439c84d8d8590e4b31c22cafdf4613e44943970731edf4344d9d4badffe0d11e5ce7326ee57f01051c65a9bbc21a2dc4fb31c22ca389eeb9c24ef10513e8788f2ef72a010923c44944ddc71a5b9f91051c662ea8688f22e0fe1424872278788868832ae3c7d4344b93ca5323944944fdeeb4344b963de105136310f87f5ee976796b7e338fe01b7c6e1a86be27c9bd49793e5c63cde71e5d56133981bc27197eb2c15cc54a16c2c86cdcb75960ae5beb393fa52286ba990d804ce64b7a2a87e6f51fd9abf6dca8af4ce26c6923bc692bb4c96a4f3d89535aee47025caeff71be10764a3b165d84ab41b567a048d812fce9b66e6408ea536b6b493c1d2de0b84b2b15854bf375f50dfdc2fb0d3f166caf73571184be636aadfdbedb8c7cb308c77b01d895d514633e35c39a375ebdac4c489765b6272b444a32330cd6e4c966a4ab4b6d4ed91af26fa8a945c94c1b2272aceff88cb5fd6e9cc7fbb97f7776a5add3d58eadd336d6c46ab99e92f47f5cb6fcfccc09c33a770bf3a9d9b4499f9a8a7a82424504102d557acf78c840c721699cb07f57d41599b92a5e2a21c2be5a7cfaeef6d7deda1f9ef55fd7ab6b35f1dce057baedef3f8cdfa7f1e99caa3faffcab3ff95b7e4bf8a3c9dff17776f7ed7b41b773d580d9e0143f90a041494548d90783ae736ff515a7905527eb1ce5076bb475f2e2b927890498864183289fcff6a84448325cedcecd9c5dba58f1ebba575ea2ad99ec72051e7842e8c4ed44d904b53cddb67d602b1ee3adf7acdbb73622ace776adfa9c5dbe526b93f360c6b8275e1bec059e19e7042ac6461e58c951e30bfa8505a6969de71d439868456116a0050b52a7d8855e254d1a14a09558a50f182ca1154aa7cddbcebebb4badb8db8974ce8c94d6cc79e477d72ccad796e71ca11e21415c42948532818018dbeb8d4970c8eb080f894c49395a71f296048a9bf0e8542599cf93be98e4999f91e8fe0deed37ab525e4e7a38b989e2459420a230450921ca04e2ad0af12680db78b340bc01694aa2c98ad85484290b97386c6e1c2e868496a54f4aed3cfbf8dc6a4b3e3e4386d40d3429edb9ee97ab48879d38362fee4c404498238255b9f9a637dfdd4c04aaff1ad4358940e4ff83b960cebcb8d3992d8eed8bcd494d4e4dccd79e9981dbc49ad43bb779335aef14a6789b1788758d4b2d49b5966fba1467a9ccd20baa0a952a2e1fc7becd77afbdb4c4f3d55a7a2989315752bafaffaaf4fbda332731b72d51d2f9af50b2a090f99f9308a50765498502646b2d7d323d21f364ea959e24119fd0cab1b99da2f4e54eacb6e8848b139f131e7b2f2ea948eb342f2fd27e220db869409292acfe6b52af2cf72f842842582184104200a1091c4da2109bb8f05f5ffa02b18bdad7d4f5b96a96d298bd348a4da6262f2672884cb4b699b7be3491c91626529814bda2f4e5389d7d4858482820e99018f8af51faf2bc39c612a5af7991c423258eaa8eecefb652946874c68804233a93f3ff412fcea818ed2b88627ee998631607afa5b05b734a1d072f0ef39b9bd987aa32ee1e904a153ae35982f55f73bf4becff9913972cd9b6253a48342a82c0e6ff65b2de6f7924db42d68228db1fc08ade145151e4138b9a8afed25e9677ecf82a794154b24509d0ffd77d448c85896931e6daa2075b3c30c1830d92b4e1bb031fc40e70073a446210392112e54054428ea8894804fbdfbfda2d7596c26a59ee18a9effed5b2dc3f3af67bc4d3481c407971688c212e434890e481240b24412444840e206445ebf5e532854ea10cc4a03541565f839a7a262dcf6210d5ff2cc8f6ff391168ebdf5e8ead080444f55fe91581aa1c89e3089afffad219783919e4d7d467b9a5ee91a96d1e713a52b134ce2d8995cb57a0ad1689b03e6056db0ceaeb824dfdd77e05935784b96ab97754cf9c8ae31a2394ceb3d11c5db573acdbe2cfd6bf5c74f663f5ffe20f95167f6cfd3cf2e3f249f37a5d26a20f113e4fff7afb344f8b3e406ff3f9e7fbf562f28a4074a1a93c4d45579877f5a0acc65044174f2d6f9f1981639a7bf75f0d887591208a9c453610379043dca0890db46c30f424d67993a0f1af168b592a3e35d31f4a49736bead371cf14897041248b480436248c2154ffb5a7a7e3a82e45af7939e517d75766aab9781687040d59a027eb2b25b3a53ebb6dc92cf61cd1404b832fa20651a20656340842dff8ffba4dfac2e11c6e9bb8a89c897d9857a1b1dcfb578362d8bca645caa04d062f881910612007063a88184c61b0c3a047c4c0820bacf8ff0f5ebca0cb05572ea0a2103942d87411b2a3512c79dc3bf6c2bd3ca4f2285d8ea2243633def1bdbbd8d7bb49a3b51bb14214b0c08c68410dffb5dc9b52d102a50af0a8c0870a441029d8a35a8b710772dccf600efb76a74714740a9c8814bc441e3e78c21079b2441eaa0a65b1addcfbd7cbbd6d531737757d306aeecd34c19c09d64ca0459c60e8ffcbd24742594b652483b8b7f53612253842022ba20440a2688688a5b099cf2b9d16659769751cc7308e182a218655621882b8a3c70e13e24e0ce2ce0a3b48c41d0d2248f32486e1da35597d8ee890fa1a39d6510e411f22044188105481800251e78da86346d4b1a2ce4dd4f9213e50467cc0870754b0b81fae64d4b40a65a94f858ac52c15da7daaef42a13ebbd3dd7de810f10110c4079644076a70a0141db0406ca08fff11caf672ef1f2df7fe755c2779bfa54c762bba9c49cfcc527ab965b7a2cb316e6b8e4b1e6f9b38736f2e2b2a37c7e6353bc7220329880cc082b911e31dcd7626932d90c5f3e20256e20253ffe20274b6801515b8caa2025bea2d881931c896204d82182002c1128178f9aab798801e62024d245042024e0944202220c78c8840504420c97f0fd5992cd28f68de4bf580350e10e200de01444403f830e08c015844034ad100971a05882940271640452c80e7ff672ffe58f3238cf843ff18c57f437c23c4078acf81f83a5f3766d273fd9dc192674aea2b85f671c11c3ce6383107cb9c2a73329813f2a1c587152af061850f217b68fdbf6e6c528bd03eda6c2dbfb406617b04d1830c3d5808f540410f233d84e441471e0408f3a8210fa63c20c0830d1e5ff050c19cc23d3ddba419caeab214ce45a96327f5b9e34568b0dc5ab395668bcb5693ad5702da4840990470a9346629df774c71c70d77ac7007d21d3f42397bc8b9928345ce939c0be4e8d8f1851d63fe6bd05218ed99f5d06de619ad3db3a7278a6f60b6ed7293a0295360a4632c265ba2635291ec725c47b00ed7ffd77be940d32fc7744c753a9efee9006e4dc93a879939707324fd575a350eb135a8349545d458aa19000000500053100000181c24140dc8a462c1644cde3e14000051b47468dd9836d1649d54c81863600600004000400002775171a3e24156cadb10d96309df5fbd43f80c71507817fd707ca2c8e3c1d2c485cc87081f139026bb817ed313d887db583c563a9ebaeb5bb7465f92774d263f8d759f1c612a3d75c6e395969eef524e684d403039fded06032b9b8b89b1ad7039aab78d2d2f47692ba1e789b1137e6601a9be07bc8d895542b0971e36218b2f75be69489b84c1fe475eb70f9ee2f68d428f3f249d366b89df4583a6d4774b7559d03c9bdb48ed737f74ed6c625826a0006c7c21caf0724b86ad3fb229fceec5e1ccf3fd0df78cdd3e6eee6eedee483f8216b7e4a2dd6eeaaed2f7bd3bebe526a482e5357980d1cfe321c504e645716361f4761349d1818a174b657cc657a067877a3280ac2c82cf37b81a2e08cc74e7f20c4ebb55bda8aa05e39fb1f2864b60b424dfe96a000b7f94d84597095048a0101dd28cf37f4742b1717e4d0aa7bb14e47820446962155d27e3b9561af6014400add1ce74c2806852823a07782bd282522c52989188714c5fb60f17be64700c3be4e71ad3e92bd352738e569f5248fde93fbd02fbb45553ea760903b68a5da9b11740df2c9d7b33225a60b18279bc82351f7f7f974a1683920d4c981b42fe32395ec054b2949f6a39a3ace33cd21b2e356352a0a25343403a9037cc39166fedfce56c18b2b50eb9f6b8dbda5265a0e0bf4ce92e6aa0aa908736a8a57602b8a15f037d8171cc42a87db3094f7166539737a90b43a84344dc96d1377cfbc4f181761ebf30d4837fed1d28f2f0b81a23b59bce23fb8fa34a3fc048d61b171cf93ca840a4c69395ac7b4fad4e17b519e9ef94c1f3936f56fdff8441122b00ac6e16696e10909e7aa894156852d1bb91404fde7f1cd93c394617050641433236c309b9e31659f93dbaf9c143e3626036d248dc84a010620012796412a8d6661c6ca4a8a81a74b82e95e32a80f3d7694369ece556fe2148be8bcb1f3e2d4ee2f78501e83e229e331eae567489bfc48ead1b6133be1b837cc62c0e0de3a38a284ae8509a241e0ea0ca3d65b2d287c6e38d0ff6c5cfcba3375cd7cfc2f82f6f26596c900524ef851710d66d278b03d4903f76b00ddaa26ef7fcb507a889d598e915baa8ed2bd0fc63e68aa2cc46d96b8fb92625caa608a42be71154f9808222a06d62f4941b4907235e5e0cb6fc428297fa84e3914fcb8aa21f35eb1f4e3efa48d33287e4b1c525426070d5ecbf09e71ddd2051dd77b7b0d7dedda1b2cbcbb55ab504970ea21c04635b7f6d536c203f3d8a4cbead514548e382222dfd9723479271b35cf7887374495ba6a099ee386472ff770698215588c601b4dba6a8c981967ffbda66cc348bb3639bb1bc38bc1bdd7048808057c1bf480403ad0644329cec5701f92c861dc4ceae7755e8b3596465cfcc913fdfda9e5c348a921d980833cb0aabf0d0af2d233ac23c7f743e86033314c91709ba6756b364ed92bdc9d52003e54953eb85354500b251666f971fad0521fd20812e405fccd99035add92a61782ae43bb93141232aad6cfd8ad71087158ccae296b54447278c839e8536f0e86a55e2ad13e7c86df20524abe12cdccd9d45b144ef69afb4d6b1e0d50b99ddbd7187b808395f77aeb60e6f042c8fd21e501147273969bc6b4abc81744d90005d96c48a4b57bf18b91fe7c1d7a5258fa78b2879d15b9c6491b336d8b5b549573ee5c65930f4049f751bb77edb9bbf836980e34317c2314a1abcec9b11beb4209ee15943d8bff61b0b6ade42d640bd7ebe44ad29394855fc3fe6b19ac91b4d55002d62887bfe83fc7f431fbc3b5354f67e420a455fae7b4f572cd23e2d8a22cdce13765a36c309f4356977becf04e0cd9ebe9644c939131b62502b0676e4b20201db11e5fa8758c84a2f739c6ac1da4462c11ea5d729b9e3a3109166e6da97a247816fd0dfbc9a49a4f8996cb12f007c272c1dfe870ed836a4bf793e00ec2728fc7f1ed814d35f9384dbb6fcad0cb8eb2adfcc713b22b5b6f167a81ec187402bdb1ba080fe264942221a2b9067714f6e71dc0067b42e36b36ca7fb45cccb6739f75c0773b45bfcc395d0435eb8f8a125d7f1cdd1897982fb7c2b5a18919b3ee6e490276fcfee9631ed40c5ce0d822c663d996d823da258e0405d234af66b570e482f394e9590dc7a45afaff02e5bb4531429ab89aff67d69a376a83b935a9ca5b8157b7549994e1a09b8ab34bc5f63f2414f08829a599f4578deee8e044d68354970f442b13b9614a4ae3b7781411e13ad77fd496a91b72490e754019a7c78aa39782a073d3cb5efefa9d2f2d5905dc7873499e343c3e61aed628795593bbb4facec798bc7a4496508809e61e024b2b314f4fb35136312fad3a05e615c1b9eb706361f10d2bd919d7f1ba457288068e3db68386d44569b480dea4d8cb86702440cef39b136f09491398c313d2d8696d268582cadc5ad2df883eaec5d9a6c72eecac5fa2358745988923db4f7d585aec6ecafd99015b41fd0c2e393d81f081665b89158d5f39410969ae340685babfbfc2049d2fae3a3e76fcad774217616dc9d659dd46ea19b43661991db2d885eeca836e411f7ff34c034102160019910e831b48f54bc834c59e19962e952f6fc48077fcedcd2695dd280a687bfd30200ee1aa37c8448a0c56592691e48d459834139723e0c74c8bcb420a655a3e8d01f27b54ca76e627b8df283d809da70153c5483cb63e9801cad5057d7d1e846b512f6efcf1fd9b8a00210dd8cfb2af26287610d0e7096d6229e759c87545c77429723e4b9b1cdba6d30f74b67e46d8d73ecb0640e483c4007b1cca60ce7618a8bcfd7ca907090b16dd427fcfc114f471bfa1d20c8faa9c1d37bc9d01bc9e746a58ea6304698e5c5cc9faaefdb5e0af3de64831f63bf00451cc1bc4b68fcabfe1c62e029ccf3f9d82edafed7b461a2adfd28594cdc9a18e47af01d18fc6c6154cbf9acecec1d4d94be7769cc7f00cb771f49cf6463ce00169763628784172b58858c64f2ae55561ac55372d9c8ed559df71f0d0449495c81f12b77fb3391c31cc647d091c59c437387d3e0c54b4a1d3cc93572d6f4b942e41c83f67f8ef69f30fbf3216acf155facbed553df092374dd21211adf1331561c033774120c487b4f8880993e186ceb209eb0f2ac68b47612e1b83851d7c0ce61f90e669b2e3e364659c236871ff0ff5ac45d51904d0bb8515b40d6cd2c2f9acd54917957ac0dfbe845c9e9c915a753c5c33ce3b6ca9297faf3d6c8f896c91c1a58492b36934b3ad9d0e29898e4353a958e67a98c8c5a5d29c5db1f9f28ad797380010600a83d13176b3800a36f1776b94916e4d9b2b86448587a40c896b1e266c4648e2ba99176ba86e42b251df4d19ac48921d7283c834d02be558bf76b9c06ea22fcfaf6a8f7a3540c46f73a7c2d19dbde919c49c1f6f5ffb217fa421fe838393009cda0d358f2bc242293f1c0268eb2cc6a534196bdcee5c5358662e5ab1db400c9441768d050bd24ecbaa0f426f437e03b94ace7124ac2d667106dc9df2e05923249cd50e949efa52ce557ad99edef7ddc48831be8926dbb9d63299e09a350d4acdcf7034745fb19310180b52485c68306ef97d896f010ddc39012ed162bc5c07e5b47d2fa307974227a5cd3ea77b1351e0913563034fea7429e3f0aafe13a349e4ea1412db71df8200fd5fb4db617c34b842bc1b500a60c53153893bc8c74039ba79115da275b0d949c9f4c90521b9337972eaccc7b2c007aa5416e163665b51d3b22c405e61bbeb2465196277331caef2092e6f155e8b4ca1a8fcab8415f3d73096f305cc4502bbab3503cd0e90acebbffee6f1b5d5cb12c8c37cabe37e2ed497a4c9ca3475bb2a4c285638979b04adc41ea3405475cbfd9afb140bd7f899c855547b425dee813824694dde1038c6f22ab98cf4ae5923ec5709428eb27eaa863dbe40fc4ff665edfad82effbb1e811a7fd2141a9c46849f63063689aae5ade2d51bcdda66e335856cce2e66b1385d372393463290cc4e9a9490bf7843ab38953d2ff9437eb9d27690c0cc955b9ba451ca57a628ccf47709ae496133c905cd751494ee9a4e68ac14618c51c11cb1e6e0b83a90547542073e137bffb261c59008a99f9ed693070adebacb8409c5c4bdbd3d27303f4477e9e2f4a1cd4671b03836165a42d5a18b7855600ce7183eababb78327e1b097d06df400a421d9cb6afc5d5c9766e943f4f2c867d4761d840f4b4e09d6cbd0ee7ff11a93d81a7b4103dbcb8639c4e2bbc198667a3af4413f0fecf1b029d757b60d9da83476a2ae7d4a688b5c1b249e3b0ac94f3b97d71b690398ee64a46bda2edcb2981d1dcd227cf429693721c9efa560e9fea303ae39671d1df9132ad776aabecfb7866319c38cc495ae9568c30100ec09e02cc67353e868ae452f3f8683fb73a630ab79ae08dabb7ff4f65b683e4423ba5fa1abd67126c0346e2c80c77f0f634ac16539f8a994cce7ea77e7f3d21cf518b871277fe1923105b6bb9191e50595aa81c0604eb3c57bc109927363ee99f2c4db9ddb7af2e2bb166aeacd4857962b18ec4e1af6c5398b7e2c97edcd1853dd1798e86900a7406967194318f950c7115b2277443e2daa6d1c028af35fb91d7268857122687b0fe6a8b21c962fb1e371d6406b390313748dffac8394ef2be8e7a8a5409de1790880aba4d90b33f9974800c05cda41e21d43ac572d5d9dc1d3d301064d20acf204e6d44d8a6217b63a8c7b095cfb5088f12e2821d6d61719d13a82374022551b8f6bcc56c1b502b84eb9fa0deb0814eedc76308e83c3d2e493c2cbe96d7ebde5269f457f3511e7efe6aba1db8e6b1a106ef1f64c5845d9d7cf099e5872bfae2c9fb752a057057997ca3a0a203e12308d67fbfd4ae34dd9bd03c9fbc1184e3e866f7101569c4357808242985f5d793e9ad5cf91b69be5817c2f2d4c8f01757861d62f4bbef7bdd043f8f8fe9ee1fa8477ac2d2da62ee0cad16e9aa10ea8a989c909c7c5e48dfd7d5e500721d07a527f4f860ea3c92b3a65223646357bde4d1d111ac009c065ff50e68d6974e32227193e0c0dedad1e35853ef3761b1e029babd9cca9af399e0061643c11a65c42af84f2f8e3f38aa69d045a7f38cb18302b5817eabe5248a8b8a0d5d8a3950abe3ff237c4de42d16d2c614fafe6f3007bdca9ec0d2e57a4e82870a06bb56bbf3c1329535beb2c1773e0f347607daf93c2771108fe77073d8abf04379c17bdd89f3fa896df8890853ead950a3b40b1d200d72ae57b999796a75e3aea310c8a78e7533ce3b9467b9b0ccdef0c506464d5d1c46b7ea7a4d48d721375d5eb1b055dcd6c676562305f499efe83791985f600f54dc91ea511b0a93baa7e73b856ed206e6321a3df0386b1367e058292818868e4bea19f844bd6f6eaf38896e568190de16a487086bf3ac279e482b0913d5a2b4c7d0641bc48ce918d1ba6bb1c7e9c0d58a0eabad985efa2cfe7b04bb23f5d800d0de0ffa4c6c5e5061c192d4673fb5dcbee650739aecc817c64792f6ed9a97705d75d475b0a908aade2948910662f85acba260d617191717bd2f8326d92fb1728e93198d130b6006c25fda320d32351f912f832869a9a6c31af5d04a038160b194a0480f692195dd948f07b848ff42b3c378898d22b7e33d4f8e8f29a083ba70a5ba7be9372ae7acf753e42f5ab88762d25e0810f847d7b84e5f73506562bb5c6d815c74b84de897e8989dfef4330a7c0d06ab5a52fa8fad16913d2df9cea779553a35c2e7f41c6177108fb31fb5bf953128530674d1d37c8ad88b7c60a051af84d8437a9491fc8ca0311e78646af93fd18521f3e609387b117d4c0207c35d0efcdea697cc0ef4c96bc7cd639c9fd21619209f11cf635a92e17fe39df11cd2a0f68d87eacd8967e5a0feda6e7a7b18ebeebbd82e5521f98aa9f50763b981c3551b22762ae161805a1223a55c5e919f2f36b4272c0bc229fe64781a91a46e0e96256754f077e090855b316b7c336060cdea31c33433a5b1c6ca7fb66a2ed8ab44a8c6e5196458403d36aa07d1c7f0d678c632fa7993b20b0880d58e611b801154ded240fe3e649f264bfb04bf377d89d5da43e14b07e113b3770fbe69a3ffcc863133f826537c62f555f0ce22ffc9d84326de3592ff116399453711b6978da7dfa4105a5c2e7518740990d91f297002b88718ec311988a157922a7407476925ff325bffea886fe94e54bf5a993d0d9ea1c02c81682ee1d388a08579d75de603b53f57e78d5d53bf0c5927ad7891c9921482b5bf6892c995e6810109197b42db6f3e2e72f8563c989a865370f050b332209c40aa0b273d0c923bc440dd7c1708ddb98e1f1a3174e25ca082a96607728e86c97b666696c4e776430f37f5a754ea6f5a73648f2462bebaa5167c23ba80065d244cdb18b10fef334d91d1969d8ca27721b25e90b1233e8b44b8e4894912bb698b6d680d5f77dd81c4c02065586147f1be5384c36824d550cce5194cbf1c42d3925fd0cd2e816ea209b06bccbfa55dac3e78ca5a4be0e3f33181e3c6fd9300d9031608c73927e06285bb8075bd946a51785dd4a9c6d5d7e7e32768070797707b9a70d45d5d2c74f1f708d0a69eb50c231a501c6702639cca7f5c09da976f8d914230ab5c5ff788fc1e4a39481a49d737408d115a534c344c763d94b459879174a05bc8240b439153b372f0d516f89da1a804df2b65a78611da9d1ff922afccab36b82f6eb30e6f850998fd335afb9d29e4ece7709b55c7f7bf8f5413a0cd236e3edd0187dbcdc9455eb35bf0bc69d785d5141e92c219ca33d09d64b4c14ed0d58d9f02233dd4ced9a379993c0c8541c35c79c1af4e6c60982dd8cb55899a787534a69c72c00822bd0df36734805a65419fa87c7103fad03264e11307d06e614c1a34aa0884ad300dd5e5308000caa68e812df133ca6f14a8abaa185ede3ebb59041f6c566af611c46d5fb7d2b24b1e0b92d9ac577007b8489e6f41927a38fbd5b8690328c73b8a4e65b65c3c01c205eabdc3207c167e07b08b88a2b7b26b01fd1725cff7774df0920f5b76275d8fa2e0d9272494260db19a2304c01aa9ecbf699a21e7c3f6532cbd6ce926fbd4ba2c3a58be347304dc97f99783cd174f42e53eb8a9e2fee9dd2a995ba554d7d4e8ea475725390888cbb95119d9012b2eeb8e64f749d9783c902ea548d2bb17160b0e9c34ed05e1af04ae9403d7cba9588b0f8eb7684796e4b04883fb5580f6142338d970303248f4af43fcefeaa420f86b4630fcda9d6bef478c15dfc0fb2e733f16cc0848d3660bffc3443543c2c15ddd13e7202260bf07e6070f035cf4de1bc80a33ac174f870f8c009c64a57c4d4e34a3a62f5af16289c8a69550c1bbc7ece2631cac9a2001bc1400549b4138a051ce3c0f654e360fd2c0dabcd50b0b7da3bdc421fd7434b0f43cacc242138f5486a040a41b465cdee75ee1b27733260234e164e529d10e187ab413793dbc35b3a1979ecaf13528bc6e65e358dcb53c725de6e3d370aa58e04f6993298b87adb167187715659b2e85f755dd0648a3f3f5f009cffd81647764e134f8f32cbafdd79b00764ec24b02dc02c582b23fad89c39ac54d531bece98929bbfbce8c08f4adfc8ebc0911c5988cb0df10d8feb99ae89fa8f77e0fad3a8228d2299db807a695632a047f8457efb1e535990aeac15be2d6573cdaf0f0cea54c7f0baf0d5280815c605470119add45f0ba2cfe6af5c18ac63c75377891f458381eb3a14cb4ba9ccc397c67584e41a7ec17ee2207d48dfff7060125a1006fb1a2096e20e94d75eaaa0771c567ce85aec684b405ce200cf429c702508b899c74eecdc95ee08005d0fe2feee3b15b07728535421f9ca401a27336aec80bfceb6872f72865b07b0f343909ee7457d4a96142dceeb161a727d23811c0b71b986bcd54d17977f1996eb6b293b896232303aa8200c3f277cc5a79a465e127647e49134bd2b47b7c6fd1e2ff863dcd29d77363deb15f098ba98d8ab34060ee7b3ee1e16edb09f83953dc9d3202763e673a0653aae4a5006e39edc963045ecdbab1495c2e44b36dcab62694f35b99f3552ad5d3af077dc0f040ad48206eaaaaf22020dce7f33153a31f1f1e2cd3d6a85973b15f320ea047616cf67d2007e6d0e8b924fb660fef00f2451bcedaf860e5389474abdd8f06e40c1a7ffdeb8dc6c189c1fb6c74ee7a0c726b4f86cbc39ff1cdb88584be247c17e4bee8a1baeb82fff42c1fccc3efc857047e721870338954cc167473ecec22a7552e3b16b7d7da5b82189fdff58b3598b892907ffb496f919a471590b04106454b22e490a7027e449ae3379193e4670891575e9dc661796a7063ff789883ffe7b9962bb92f4ed55520a14acdfe49ee9c563fcb1cbc006097f2a2da17edc7a04e07d17137f3e483d29f0ea420143c9c43ed173f52a292aa941c611f9f579e0282501e701c5fdee386bfa7e5b12ed140bd15be54913c94d358d95405402762f0c4eab6e2f2c21baba3bb722887ef0ad7eb5157ff07b865ee2525f27263101adcfd8e7c9369304c8c2bfb4de777bff0387e31361c5e28a65ebd86ab835e89b22c67afab7c76e7be5fa8cc787e40348607c3e0b3cc394e1453d098fb14c9e8973f5501d72077cb3aa1f82178b461a087430fc62f06163ff6411eabd8d7dd19f4c6ba6c274b1b1b016edad5c87f6fd16ed7267d70777ef19b19d8d40ad560d5e1739eab8cae4792a7b5d89812ad88e7c475a8459d69262be10ec1f91c3af1d67fe77a6fbf7f0d4ebe6ef0bd166de7dee03761812e2b1858fb944d7cd5a22edb8fa5ff83fa1be9c5ba8b8e549cec2505023d195758713388d22c7035dcd4354d7aa33767aebb2a2c587b7f42f70e337791afd9547af8fc8c4bbb3f80d2f36a96502ed3e965fdcb566fea2c8a2253690b9f5a3801996887af6e44c10340469a7e4149407de51ee2e9eab83fc854b5612c13d0140c2e4d01afa309a353d007e0442283e07ad6fbbdf2507d9cf056ab1de56c919c71823a43ad718a1e45221dc2ebc43873db969d036e0950df683d9d3273c08647089cabac97e551e043fc87ee82edca133daf03c00070603a4fa91280d6c0366f347795597334fb68ea882d87ee1f87f4d1a9f638429c3a75637d78262143b10903ac4123bb1e8e36a56473c15d490fa19066d17e9c45aac5c838cf4c8ec5ca20208553c672184ab065802d4c959d3c778ab4c5d1bd93f5fab5fb0e5cd2d12dd21cffa1c1bee77e29327577669c64f005ef8fd06d8c3a44e0f032b233c7fa3fecc6bf2ecaaf87948e82476a97ff2ed5a830af9df585ce74a097dbf04e306ddda7926c2217eea6c8daaa92a33f95799daace88acc0b9aebf0f85cde627d9a58c003821ceaaa52245c59670bf8de4190600af0283af4d86cfe59a8c7f90edddfbd9ae15ea04021f3c0b8bf9259f6cb9a454847708755e370094511e715aea178c5d3ce2fb3afeb3456f891cebce1ea3e768a49afc4a7f6828d8036513cd1bbb5d07a327af24af4c7d8daa816a3c1a9be94ed60f70235f30ae3f3df0e469eddcce81bd2c8473c1f8d3ef02ee93f93367e53ecd005cf440cabf0203c08b06cc135c0e892ea47e571af10615223522013ea483b35137b6c8eb492810c6fc6d2c2dede45c22ffde58a3902cc5be61cd95100c3ac9ccebce100a3ec1c315640abbddae20eecdcb04ffbc9c58b7be1c60a40ddb15cd640b1b048b6cb462bb1c0b055d29a27d1391f7edb4264bcf52c7c9a9d4ee00e8da32a0b6876e82b11f41430552363e3eae4c4435218d95a09deb2f576df0efd71b34410df5a81ab656d6508814cb4702e1b0ede6fd08c03d1f1499ad31e046632a0472d03297d86444c3c6bfda8a4b8bdb748c683edd71551b1e28135637e064f00dd2720206e471813d9908fc5303d37916a54fe4509790419baebc00d33afa6aa037eee719b95f8eafe38f0f1267393fe60c9c8a1ed911a1443522edef65e21a9f4d90068a878b7855c1d50fad3ad9881bfc14ca70c4602352e27fc991ece95b7be797939d6f2e79e94c41bb70c2cc7e7433d907dd7ef882f38ceec0a43e648b072b19efafb84e60be3f5ee478c235385ee3fa59a1d6a324781a1b39fc67c9d1a956163e20c2fb873e057ca0703f6e1dde9acb60bcd2668b9b4a21763feac09557918ffc4f4eea0a4f0d9cc44eed83429381337c8712718eb9a927ce6cc0293bf836cae45d535a45159196d4839700f6cc604f3d2d8c584c0155e30cda8c8c01717fa0c7e5d9984c4c14856f7767a6f730538e669de833de781c1b271fb9a232d15700145b955f363550b57452a63da8dcbe91e46a1216106cbd184e90eee6ff0d15acc2b25ec79a74aa4f71d6b3a5005fedac263db7ec10f5071ab64bca6b59eeab8e7e035c4ee68396e79c28f6cd911798ed0d31fe99f342178078322a49077089b0b03864874150a5c689190c20ff20d2022679d1fa1c6d34f62e26ce115cdf2599e9cee7c1793f4dff71a43a40a56effee4d863233d7a6241d1fa82146042cca02ea20d2d1602c6eae8f158c5a0a60be1360dcfee05a38f682a99749ef3ddbacad74a9d813a1248a4bfca18e199e164b58a4e919862a287aa91a63fc07f7a07e88d0bee25109f496f98955ca29a89738fb5b3c33a96f1d3ad6b2ee027dc4170a339cc9b6e0713b9bd628f098fbbfbcb1a3ddb9436628998e592f72548ca331cc564ef923f4d834cccecf4595071a8c235c1fde16ed8e6823b9824be2b7f030fbe256b0dc35f76eabea2e804fee81c82dc47e262610a7697e2a5a4bce754320d4d44c30859d1f49b848b0403ac81841b9c660718ca144d3a039da6e17c39375be90011f2099cefaa288f46623856d77f6587688b8e38a1a8f5c204ae9c2d88ad622e89ba77061484eb283625d18aee09a88d852db82dec238b5803ba6a9309297e2a37ec457b29273b2be5218752f5f77c2b86e755a05613055ea2625b407018b5d088328b92e49408263f8bc8fe4ff2ac70b06d4006baf4c7afb1f389453574bd72162b12cc8e7f173226d165af8735e024371b730f4674135335e63f0b25d131294b529d9db250a9fb84b16c7373a116b8c16efc1ef63525e89a9063e09d8547781d7a24126d23bf138049d621daed9bf5b70e522760cf5816f23b2031adadd6ed6378beb1d596f3f7b6c509eb57dec36c6f78decc1c7b4c1eec68941ecf57ea3d5881ceb14220d00d948b310348ffdc03557fb6184df31324ff5504c56f22f8c056410f922c32bc1990d1ada45aea152e8a52aa58d591da4c0562c8aee15182408f5172f8f5a35675a6776610ea051930b52b39d65da2d341b02fbcd7e84508cfd7e0dcbb5b4054b936d41c91948b89c00194ac8f23d087ecdb4a508ac1265422edfdaae7bd768cc67fd19fe75b43f70a8bbd913895cd59899e4f020a1c64ef2ac2cbe46064637873425782790c2e5ced53bbe8e83ac5f56f15de66ece8a748f15402bb7d32bd70246106f97f728e36baeba596034846168b81921bf21f90e3ade509bf411c9576281979e61851f85e5afbb1b5f591b0269582223dd51b073ae5106852a4dfac27e953fbb4fb873668aa015113c7613d56bc3524fcf02918f95fbba16661198676028f3a0229a68883a6ac6c8d8c77e878f73fbf84f54c5ec37bfb9f25ff0aa00f76f9a96217d21a23a3d627edeff01e39000f644e6bfffd25fd1cee1f1bdc3de6bfd0010708781f28d2bb777de718c22a6c5e4c6189a11719d2f24a18b55fbd02b3db45270d4488aec686b5f6a7afdc2d132832f6b947cb6250a0e82204d31e3933ea780b8e90b4238a3ceb483b0ffe4760b0abb85931f74f3211c33cf486ad7c7b8cd71d6662479c8487b6b92bcbd9c81b3236b497911f132d8566d0a07de0f8e6cb0ee0c80bbce90dd211bd0439d123506de95391bdf26379c641d8e577281d7719aea805e5a0661576ab69740fdb5b5f578eb5ffa614b586c7bbacd7269afa70ee2abeb92ba1587c5c923aac7b87512589eb92d1bb1404c9d1bd2b4c20da610242f4043a7628c21827249f6ad51ec799c2018f0a6c3c0b501008f14ee6942152f843569b1ed03d866d0945e3b9fb819e4438006513695915a3035e1158dda51a6393f7be1ad08ef88673315be260c55a88e24a89dda96c308afa221e0a10d08d933006272088972d2dda687f27a873311c30a3de6573ae3561e996e4b0b688e29e6f40b32f9481d70fc4074c975633cfc71a966f0eae175e2e74e3026fe4c9bdb1ad0734061de6d7e0c52af17648faff0b7b861f19a8c50e6fee04514f4e4d2095157f5366ab71a00495ac353a5ac6f6b0b0c56baf80080356e16786042c5e72dd5e29da871dec73e6a1f68148c7117a84bf6cd00116143fc865b4d431edd449b5a2963e9748e6d88908f7909318cd48fbaa201dc64b87d518596ec00372cd3638f7fc326b623a1922db1a59d77be8148428281aeb063b60dc8e0a91df3f2a49d2304575a5f6d9c2cb8e7baaecbf6f5961d3117436a829a43620b859a8ac4de1f2e79f72e30d08122fd0ae2e3447e3ce626d4c71f1a7a7c126a4f55ad6fd380ba9e99cca42a759bae5304d26f4cf1b53d88cb112269b547d035d482990125688a3082401a8f1ce8e3d20ebc5517888c4d180d44c5108ab013f55106fe1c8eeb4f4ad70964ae6dcae3b82c73fcbddefe80dd4280ee3818bd4ae4bde751b8a3a0747d921577ad0f7936019f23378bf850a6501e50b19344e7734cbc462e0f492c2d36343c13785988e617429b96166108c12920791a3ef18b7f5e252631831a9bb7664391a998455aa7d742fa6b49fc52c7c759d63e36152ca18c6ab846148dcb351b07606333ad7668a6ed69f1d6acc9a6ecfaa8515845469a426d64dc7483d4d90b1e35e14386036d680bca3632e9403f385c2b463dca9799a3e57cc31fe40b633744bf5f7cb818c5af7a8f27c9a4d88b7daea99ba1db01bba02002d2bec3075796991db30ec1dc2f98929c0ef031b7446206c9454ad111226f19614f391eccad26ca805f039f6d3a4d712528a00408045172bf502b5a5c90488c4f2c6356061f01ef33fc04763c086600e37b65f581bd24a27c9b39a7f0c71b9cea5430e36e091998b19afed0741a66bc5c06089689e8111aefcece76e8a5c3ae27d1913ded3d60f17c989d019146871c37bfe619287d227453baae9b2020f46910b821c276fe3266707a64679050650a22e2133aa7a0f16b34345144c4ae87134dacd0e1ce3abfeab8a55a7f9827b2d0892a369d4051bb0c3cbac10d04f254f0215cd1cb4438293c497cd186130cf701ab42e94ff165ffc43310fcdcbbbe5fc60a25a8546e4274199d30d213708a60f739f2cad37ee467e370a3d517bd96ff405cfe44406081334a00ac618c80a681892d6c77852a57ea8ea3a0184b8891f25277d80e941b4fad9b3959fd37e1b4af560bc46c08c868fad56c0d58baf73e6466d959e7fa4047aac032ef09550d0c748b045fd1799dd0d5a3274c272c7291af54c621c1d35379f8b17b5ee8ccfbbe94e88ce136c3d990b9c0e2e7b2372080532e836a6340f730e95dfe9d74f031fde53835a19943bce7b52baeba50b8a2111fa65be1e97b5b46c3c0f2d16105a191dbb0ee22cd5820c28e8020bdc2cc92b0021f5bbb78e8d5b1045b43c482107b6cdf2d0dbf8f9ba124e761136e84a1ce9b0094d484fa620957fee615abcf8441348e477fcc64bb493316b0984de66e4d773e620a22dc8919621606c78ffe63b4d3db468688a05d2c5060305e203ce78059c49118577d4548c462680702fb76910eaff70e27419cdfc7b1054d1da93677efd4ca53a0becfea6f2d33880c4c117e2d057e322a7608f7ae3323eff09622bbe1430ae4eb25f090470ed5684ad9d119235ebcdb3e3c2724f2acb589d57fd55feb38c51f5ec2343e1305a75e0660c875c17f820675af3a382e2c3e47e5347f4172610855131b863296a1f0b887fea519a57bc76aa6df23d7fa723d3a749679d5f599c76d130c9f97a66f8d83313ee7c0083fdf5caa5fd459a72ccd671c3d54cdc681cc82f6982ae84989e663caa45ae7346adeb36bb7abcc2736b763c7d827a97c2f701992f11b90791307ea793daf7b20d0b57aee07b39270aa754d980a0b600946fda80db8432f6dd1b420ac08242ca0196960d12c2a00719c1ae439b94d43082d2624046a2fcdb36a93826956b827e1c2e6ee8aef4a5c5c2d5442252e5fded5a2fdb1715943b656dc2e84643bbd1d7e85a66d55d6678c1314461a71ec7635e8f94acf22c15f903c2fe3df71203d07a2bcb2b58f76d9b74f5ee302abd2a0cac12ae0abb0ad118db49ee5632a6e3afae38cb07831e5fd6243aba101d532e58c70c5f5c4e6f9a30a7600e75254ffd463fe55f947ca6d2af283cb5f3c4e7cf1afff93c707c4d037723a2be99b4bc39e9940d1247c9f48752772e23344cba813cc76b9ef7dadf50b7f51e76744be74741017857c9357cd9c09910f34ac55caa1b5a768163a6ebe8b289e315c090769dff8c983ec2d66e65a8b3131cc81812d8336c5170671867990015d7d66d12ef26c17c48d40d686fdd8bc8c7f07e87d4dbc7583a7c3fc85ad396adedb961bce0d497c2384fc8432ef0ae40df9b45d5b09e811a1aa5152035b26d4f396c54cfa6661389b37ec2a48711c33dc258a1f53ae0281633a98083bb118a7508d114fd003156cfab92284225f7c9f2c46db167386f730d7ed1e99508baa14c300e337013a6633fea98b4a52602153186d869acc0b44461b8face84c3be8e1856d51b71f38908bb1e57b09aabadc53ea2445fdca47913840bfcaf2d2854a0f6a18adcfdf0167d4ccf450e4a891e3485f6c58837e983a25d310392a5ba70acf99ad481f1f830a3b256ccbaee8b8227a35e8a58b28dc0d1da29a6be70ff16734d580b26606c1bdf3afbc7d2bc21ffa79928e43bbfe1ed7fb481db9d1b1cf91c7d7abda83ff750db30fc7e8bec7cbfb369cb36fa021e943b6b47ca28c9c56765e9f7c61e5d5110d898b05918bc778c726a64ccf68a60a4d446e104a32af659fe3eab134fbb3193f83b3a9fd39ccb32f2e2dea2da23cf9abbdc8f15f224983506056f87469511bff2f01b18f25c9228f152fc2310529a28c5553eb71a7a6801aab79a472f5800c4608be08b59f9e7152e3687309383a2d174abc57ba9e7267c834e657d741e73709fd77f76c0289d568a7adce14331bfad9a0f33a4ca976804efe23db5ced0182e968224ce30c924bcd082e995de57faf2573d4fda0ed66eb3ae0d759865d4b7741dedd3c69981fa17dcf3b8ba773bfbf75cd2445f642225fce3203d24f965ddda233fa41d66710b6f154cd4958f3a32a819881fc2ff1ca757d3386d408db447a20b68774b0820074fb97481611ec3bf3e264b01481fd107025c770081994c532457386e1dde683397b8f28d8307af81e240eacf4ca8a513044dee4ab9ae80e89c23cddde6ad871345553c3cf5a80cb29106d71839d1085a4b710fbdc5bc82c37f033d2be65661c56f33cb905bf0c12b4bd18c8e6f786430357e35daa5693099d67aa69c036416c37519b933c37ffd02a5f63e7090771abcd90f7d9e01bb9a3ec919a7cfa5fe38c82a80a59f5ad1ada62613959a2c1f3a7a0b7dcc2e5a2a32fee6e3a8f58eacd2d840b624199f7d1c640bacbf639708e3c9025d19c9bfc6794b5c0bd33aea9a67d79897e8c0e48f2854e44a3f0f6a9928c3ae400e01afc26acbd75282f76e5024b7af66fbd3097f6081cc020d62773e03438bf0d1dcff01f272f36ce1de013cd8e10b1279a375dcfc95bdb1fc8361cbe102636390cea7808793be4b2a13744110a504731e6dd06f0b740d556ef5891368763ffa4126389fcc256ab8cb9fe69d47493a615559a3cfbb059f7eb8e1d77859acee4b6c48a401b60123d4ef0296a888fb67afacb9cc5da7f09a912beca4a62b023f10b3b64bf9e28138d9c01f87c3757cc8b3cfbaac6358feb11cf8fcea8515b6268c34f672a3e83de3ddef7f2c5b5488546d26108b28e01074f50f180133bf2ab757ce0aaed3793727f2e987fca522f29e8ca35ae335544a7b9cde7b8013cb9992d660560b5e3a603f48907773a405e70f56685b9c36504e30181c096a0386a98a03aec70705033154efa3aace2c4f39474751e3d34b084f692fe2b0069179f0446d012fa9ad591608cd8da48a7d9c3eb06721fdd00e020618ca20c2e9ac66c59777c38088cd9ede70eec1ecf8ceda63d73edc792cd4414360d684bf57241b5d2dc6b81b5ee4956a6313fdbd41ad6d5e8edd070a21e755d6528af5865961676dd9f5940749f36c41fb8fd8e51b83e8af26d88358526b2ca4e1a2e1bdb7f9d361e6b33dc095d18ed43be423d466d004be044083623d22633eec7af79711f9bf9b8b18b47c4924fa9aed721ce2663a7dfa4bb13f9138e28f91c9d05cd88c698a00e34a80d0cbc402a7abd1f00457f2807404e5fea8e51103140ae88a2fa49d76bd4f72d6152104376652bbda6fa30dbab2c25a0e3417f61c985d7c90af74313fd1da67ce86adcee4955ff4fc502d24b0bc33cbce06ce002b7e5b367d9de5ad44f6b676cf27db35901071670afe22d54c9b1233db73836c4e6ac1cac0090b5c3a7f4b51db9de5d1734c631f49c18ded45dc2652548a659f19baa99a63d62f5cd9608b8661cf7fc88ec0ade0d13568d8cc4091e07c7d9d8544b4b521e616ef141187ddcb9f4caaec7be8d90cb66ec8ac2f78a19c48f7d18b55d596b7e6aeec7c3ec1222fad3d5bea16033b6ea9ff30f94e97d661e922ed23bfb9557fb1742bc36dca6b202f9218b2ff870b64c7aff4acd74513fcb8b1d456c917adcc57a88b77c978093edbdf8a5d4cbca0319f731c8b61253a77077ac2d575cc29c65290174ab6bf04860b8168737dfc9102903df24368f1f7b2e178eb3a0867537fbf301dd75b00070e5715cbbbef5f1164c30a0acaf78ea75b958af893f4cf76def228bc6ab77bb89d7977d26dd07a957c35321ebeeeb8e8b784947a4c5c44c85ee3dfbbcf8cd429f2cdc161c5203aab4b572b63f2e40759197311856661a94e1cc9cd9aca266af0489cfcbdd653a6ca84cd1b70175bd6ce932840f5f9dfba39dcca3b15b8bcc9d7a077cf38b4e43c2d0579de4186a7db488367c2afd8cc8732d7b3dde96a334335804c0bba48fd0465286160129e4481274a79aa46b54e93c2e6b557fb2d2e72de5f0f92079de6b46cbe80af70ddc05dbf944d01ef405129b75cfae13b113425d8444715edfb667ef8228415d7cecb2402405401583d9a714aaa3b8afb9b9b1626e82f85bd8d23c1677f9be212935ca19d341b726495f50d178a17db767ee7b105b922361938e6ef2420cf5572ab2cde3a05894170bb10df9a35a2e5a0d9d5a9078f169825924259a9ddd8cf0b7284105c4ac8453aea54056c6ace84413998ee6af9e2d8cdfe06af335164e90275613a357765f1c55c718d037941820d837b766264d093bbfdc7b703e589a9db324df79612fcef727e912acd2fbc12c395e98c7d8b1278d5a3facfb2093ba0a2cda2da673c300c8747da11574389142f859a588005ddb716964efe42cab10f97dd4a04a3260a5a6026825e1129294e92e7f63388d2923e31d8fc74a34a0a42857e41f811d3c74131ab73ceeba63417c3b902d4b962a476d8c8323527f6af03dd7aa2add82d9e5d21d4bd3b63f8d5508cc8ccd55c07a3e10328ba0c51bcbb616b001141ad6ccff3f3a52ae6bd1fd4ca26c6d2c219c7bf9e79d7a2e3c7ba9257c7b5092002ecd22082564eb9dc786681fe513752b2064882ce7dd52c19c32984ee445399c00e09bd31682a5f0d7b8268c65436ba0d4356018998a8dc55b108c85c25e42587866757b4341222cb7008dfdcfb23e80fe0352dff5687b3b98ef8289650de50556b045ccd304befccdb98564b82a096291f8cdf2760984f3a5290a44e3871e8295d4ce30812799d74142d12bd245dcf315f4b211384f454e489e87a80855f5edc06f7ba2ebd1219103f1ae4c0ece8e9e7b86b196566358b05cc4df733a2ca3e5cab2fdc14807f1aee61f8988252b09f975d591c82c0db757b294e16594f050824badd4fdc72bda7cc0988fd65817435a9cfc5ecf0ae843a427087ab7c2fe99ff5d4f65861a8bb8355a059593c638fecbf1e3a826ecba88b6706a738c63869960964139c3d0270f6aeb4a99ebbb0167d39f4efcbc8d84c7b0935899900a22b627eb81ea21dabe8162c59ef159e27d7df1fc13d46305e063c08e38fa1a2f902cf4a1ef9a9283f950a2b9ce2ef5120a77f313e7e5b123c64f0262a11e2327d243d216cc9c58fb1ef7b3994793308c3bd16c10a0d18170e663db168a09583b91ff6e79fed89629b3d856c6602382e5409d99925aa9c119ed429896044003f6012d99094afd538de684beba6b7652791a8a5cf3cc39ca1b042183b72a4339e9ae4c3196da559cc8660297bf7c499e329fb91e7279aa905c9257458f8b6d393ccb510c8b509b941841e1961a04bd5ae7bdad1b7132039f8d7582d268021d3a9ed91be2b17950d7a099dfe963834521e13ec9a009ef037c908b8fd40e854dd14a69eb2352ff34b3fc44cdd4cfdc9b2068c69794998649b60252d9ec53ce26c30323a7be0a1d9d2e8dcc9241d66c4f8baa1878a66b4c3d20318f7cb8119a5a146e839291b1a2dfb1c458b63f01f802ebb396276b7631605d285d631b0245bbb3efd7c7e23feb5c8456d6cee8430299591b9e3b0aafeae5fb0349ee5408ea192cbb605ca9957d1edeb73c077b7f08c421c4156c966017978faa5301bfeb8174e71731e1e08101ae94f23449880823d054c3666ee2df0d44641641d218e3c297868bb7b60d9d0a92abf6f012d403850546b74f4f85c1a0b4216084a12aee858dcb42edffbac874d5913fc4c19c893c06c9afb179fea443106df3a19bee90a03da1acb91ce8bb69102d4fa1c5c32eb3bbc478b459ab40428ea0d9c4381b988e037b5714621a2c733015a3240eb88844075a1807ab8be0318244ee29076f71d9f8a70c88e30f36c992efc24cf97666adf3d19bea51ee0ec446856ea36020bab08b7a543c33ac54794be993443b9eb60dfd9e55a112f64bd2ea993a220a46dca03c0d79634f6c63396940b1e7b052747d1651306971e7ef68338af2c5dddbcb20bab86bba3c2b43348c31284d9b759c7a62251a47203ade31ce59a9ad379f21f9b8279d35140f3b8c1b02a0fb61d1c10f7f5f8cf8fd72dbf29fe5c51026a557d536d2eeb105b53aea8897aa7a6f0670429f948c44e550a0d914072b73a8014b2010a6188e915f83981895bd3f5a0a3493aa1dc054fbd7f9d990dbefee196519f2ca6883d1118b85ebf42c4c50b655a7201d13516671a134d50284bff0ad0bdb09a642f3c149d889eb587d73424b1a32debfac2e237cc88176630518141aa95eff800710bbe87ba9ddfbb24defd95f2b706d96acb173bdb27c42d9b5a0198b2eabbc80641676ba36470a070db368460d3923af702771e00ec74270081b3a0bd4e043147b9479bab7ffc6c287bb0f5995a3a23f49393ee0dc99d4f9c6368b10a22322cc73741c13e90ad22260bb6e01ca9849e002338e225d1603c0f31949bc406f8a9f5594225739d39227158c362c3708b0ae5132b2224e2d300ee728f9917ced6901cac10590fedea57360968d08e0134e50abe98d3a12acfd393e93a526b6d6cdd88673aabfe7bdec8abd88bd6d07db79c2025e19661fbf91cfaf830f763b38f52a7448f1398926105ba8e4df2ec3e8b5089a60e6be3b649181c949eb2f9852670ad6ab8a9b538aa4b69d0ef48b3b10b06dbc8723b837ccb1d522a7ae506a04b72f50cfa0d8029744da6d3633f95df991d2dfe04842c66a06639cd166f741b5d9d5c794fe3761022f13ccda325af6e7a574a012bc766bd3f88ff20248afee366c2787572fd475d9f2a9ece7994603213016e52f93b13429d82d26d13b2bc0b584a4b19a5a664cc0bc5772d40f77cb956666e67125ffa396f8927a77bd2512bfec6ce210515b81ed8f56b4be8b677895b7e98d3ce2eb7959aceeb05926b0b2cf7c47c32c93cdd464445b4983eaab69ced1c1e33e60aebf28cec6e2f957aa635516e881ee6ef78862e828859161a6f2cedba7422d1f6b35d7c0e6be66e29510698b73d202c52dd1e043800fc32ef58e5b08312f240765450dec88fec10d5131b04d83cad60f921ebd85b7379cc879a4f33ff23ccedbc7787005f55e0cf19c39af55315289af8ae296630e85ffb7b3df5583ef8616a39011bf9e3008e02148d589c904ab567674b2c46ab30be054f9ae23201323e58848f789ee48d6d5f335941c3bc54de838887327dbd702d2bf7fa861dc1421bf8e76bbb4adf1207a43a155ed98cfbcee1cd6cebaf351d124c1bc1179d3eadcfde0f22a88c8989aa9db91cb79d54171d796877822c3bc2e1562a2443edb6ab0a2a7f37a14e76b028a6590d4eb80c30ccfb5bc114b4c4153b94e122fe565db7be43655d8b88053aec5eb9e2f65bdb00574971e4b59cfbe40db65204821fc04df783278f6e99e77e3888ea5591bbce12810546d759d278f5c90ff46e33d3f2ca3651533e0122c5e4135590d486ba75d4c6c8013cbeae0786b06c4aac200f828c8a6961c6cd8b538a82717996fe49da94f8233ad294faf9c3b24ac6737ac755b44be07c2fc96f6b688663dde191507238f2bceac46760f726fae51697c06e7ed9b5ce2cdb499388067a40388f59f7d87e37cb9053921ca5a26ac03b1f533367da375c4a86d21d7249a66257a9f6bfe3ddc0c35af0d945d7863fef070007f71c151e1e22bdfd4494841a7f405a87fe6214276c71bac5a6f959e7439650973e4072467a063cd51174a4373ee278e1eedc3b0525b8ba74abbe0a51bd950ee7a0b7f58503537e2931561179fd81f6620d96d05a1ce12a9588bd09bcbd0adba6a3b836432dd3950c29c582df42872e21225f9ac6c24cc0cc81add0518f518b0745207957b9fd8d4f974dbf1367bdfe6a757b33d6a5507c9ae0bd8483e4a5333d164d88fb4bba5d5280b4fed5edaeefcb198ff614ce7a3cb765dfd6a339b1d1a97f9a3e030d8c540eb64322bdfd77ab8493c5b1804716a94e973faa764e88fc59f9557ff259c8cdcebc62c6630904b0baab372ed174ebc92128aa5f1a316defeeb9768d8953f195a8a08e29185c56dd5624f975ba1c500d9e21e82ba46343579b241998baecd1d9d840bd48f094573a6064612bb4cf730c76199051b14fa2d882af6c2bccfc70d068deb1c24dc1fc5ced0c4f967b5b58408d1e0475d7cfec7395c6db77ef08abb88f7bf2aba975dd7f733362a3b61a1dd84d0af2fc069d688b404d460a4661767b7c6e6ba056ab141ffd59e5a39bb96a6adb350989016f8c6d3dbcabffc3958cd035aeedafbb0f1e6976eaf42cbd8110a3dd8b6871779a9b4d39618158b0876567b3306c12a1027ef9a5c4cf74f486c6e4d4f808d4656625e7c05754a54b499ff679b9a9e37d376f67b15f10001fe2faf3fd9f89a8df44ac7bfa64a7901fefc5a4232201eaf8d61ffd33814e7012e51a7bb1847a35849f522a00889dfb618038d4a35bca21f6a1292a921e0e7c6b87b77a73d00585df2a559aa3061a851f40c4d2d9af5e398a792f09bdd8b72dc03b4f648cd2b31ddc8610fda382040e8a8262ef3100d158888fbb2aca235482c1fd05fbf5f15ed8ee0e39bd643f3fd0963e77669a72f86f04157134a56a59404fccb4f288cdb5dd6182523db42524102b46662d011f34240237a017dfa56f857e732c8071e6ed4d9abf67ecee7a78162ad46393da94945bb9e91291b15d63871848a79122f652cd1311b5fb1d6e0d80b47c27e9179e7fc00651a8a4573a71ec348fa120d90f27041cfac1a3c3df5ca7fadd77b0c1f64f6bc62af40f5e47eabe93e4cbe0e25442b0043e3f55b12fbbef210827b03518f8401cf9f7d2090fe9c889bacf0c3b35bdcdda4e22a0c098a72fe06fada48220109f57d30a56a498c6b5060629f5c0859d98a5a6735067cca06c44e9351d531a26362006264bfc8c1bceec9111b157d582abcef55cb9be5241628dd22bbb92931ab09409f9d5e04f90250f9b4f16c648781d4abdc988716255429a068798c64497d20b22d0e380afe29ba2ffe570c9f2509c434964869e4800366b89bbd3950233276fb561e940276338d5f485953b494c32509e14b7b584002c889fc6cc68a92f262498fe9ec3288d2eea7a4288377af78e6f29a8e2f68501a57d0d9cdb246eaf32240cea76f93145b24a11289e0a143346f4f09285e8cb6d64799a83b307f8ff50d83c2de70e4d73ec80fa8bd6f689e53e57a6f6e5dad847d0c0a1168eaa546215fc45ecc8662427a15e44c356809791542719226eb21977f46c680c0bdef68f167b67af47b7d8bc8128e0d5b1a28e854d252f5b20b081af2a86369a710518a754092d1a3330205341c31279a96fe04a60c9abe2b97d9b953978cc7a12f30d2a0226f8898f7807285da2268f78cab075cba6b367af136caf5024d717a5cbd15f99e441c3afeed3c6f92130c2960ba487250a1538e7e1aeff17ae4451a27d51bc6943a6b1f56f41b27a56c8914944ea48cab098496f35ea1b8d44aa81615db4328fd9aafd9488c5fee59d2046401312dd60b3efebfd18f8f156168025c9a1bd64bd79303716913f754b8f8ed156f617c0bb6c28e83998f2414b0a0daee0f4ee3b0ca936616c638f3022ca543508ab108d4bbd342cc4845def43cb89beea0106eb8d748b6cf4c95c017e4c4a3ac25d17df8f525dcf903650e8eddf931554b6de7544e8f751ed159c2e2f5b82ac46240f60867cf508df4a693813f89ca9d0dc54851e27491527c16f83e5249e4b3f22c2433080ef379b5bcfdd5cbf44648dd9559b52a95dbf395aaec5ab17a56f213c2c69c2bed246f161dc1cda431d606573ddd67de005b2c9dd71c9d1a8f2da9bb7d928d76431b95f3e60fffc6c8a52f4c534489db616f207aef8ace4b05e8267287cc63357e603e2c377b98e2470a7f23c7fe7e86e80df2c4768e64ea4952c696606c15cb24cbc32a69866c524166c55d0f81e3e46fca39bd4e5651eb01c90935ab000ffad5d6735e85005b80a4cd24214a5d6018ea4b858a2e745c7552d999ee40dee0df7ef9a01208c0094b1794871dfb90ae984ab469038802991a76687e68800a764ff3123b3f0da7a4fca4540b379c45a779a0aa9f935336a453f87ec801d8b00063867ba8be5487ba668bc881a6a704154756625499248912dd347e642bfc949f7e801b158a3444cd9f06473cdc06faa139a002c3551667f22136dde5ea14fd273509d0ea69e2a14712b6f151357c87d1c558c75586f548c7b871d780a425c14ef869e8816993695663e226573700d9006aa4f4535aa75505f2a144e2ed4134376485125184b1f73a9da58a34b12226c12265a0ee0b4ccf682c1b3779af32bae8be28c10822e4a027948ac60f2b20d974c32afcafe314563a939ad2d1a6bdd1553685e0ea359defa12224e5eac09504edc2f99e3290860633f9e4b63bd8f6e6aadc1ef4cba681aaf996ec242c3519e4a2fd64d78c9c8de488e96853f347dbe9ccd45899765898c7b2e59ad29ce60d2b43c5309fb2a70446e1c0e13ce58bd58ec20a69911d7655e984ae43f120684b0f702d870c6a92c349d949e9b39fde5c9b62978d4eb8a43f6bd41a996b60af63218ae4403cf764210cbef154efdcf6df34debd58f1b66ea750079f0a97b9368e0a360d92df70e09365714acf2114971e912dd5777d1ccbf2d2a83d5c038001846bb18837b74ce525150e30bc0b079a353eb1b27183372b1ac0be01fa3e7cabd34f92318d3fb5d33e6e8936787da645c29c41fb3cc03a235a85dc4bcfd6b4e98073ba2d51f14a70b65f5e62bc007e76d90b3eb086e91b6bde38fdbe70fde2dde1272cc665b4677ff6f5b6da432aa221ae4217aa11be315f9391895f8c17ffacef7630d64537896d79abe4731db3dc2af978b478f43bc7bae44e06b61f9a528035598837062f7807e51108822fce16e1727566768a157565b7369c6151113804459f7495c46648bcebab6d8e187149d98a2e3360a0ecbfc0b607ac48160418bbcc1864f2845f26712844c931945e73fd3c819ddb145163bc851ce598770d4fc1f1f298d2f32d76709df7142bf3f29c5697e7c421b0baa043de67baa9e14043062b53ac425091b395a975447678fd136746f08f592427478487c1e99e52e9c75c2d362938bb478333b6a3a60d518f8f15222cc17690396145d0d6f8cff859aeb94371b12cbc0dbafe8e7be138020143c1444d0211f3aea1f861ef1922d8a15380ba9b46e141255c15e9e4aa08238d9039812855e3ac7bc5e9bb84dbd3016c94430de1a0d53ca5ce8c135db3fffe2a53e44e1b0f29b629bb4f52fea7c0ad3dcb59a72b569a43bfa804e05d07c20b7813f1902fd2b07983cf9a13fa8655fcfd937344779f21d62651b891d95ec9520a409d2eac6d3d22466c8be96b65512de6fa4f6bc0b50b6e6c48394bfbc4362d3334812f328ab4fb6b372949f6a89a23f8b2cf6a1e5447f9e9a8854f462853215981056e5ac11ad9384ee58cc6e3b0c79b72c800288a01ec4a0172092cba8cdf5df0787ebbb0830296ceb513f491f2cee7e01c5744800d66a7436f01106966c5d9ae21142efa1c065c260d18fafb302f3d46fd7a010c6c546318021e1ea4167b89c43689bb7ecd0e6f6cab5fc5fdc489233b6ca24a210eca212d9245d1edb0b80df7ea805d6564a3ba0271283dc611e72cabadc61848cbbedacfc66a08d84716c35080f97988d217223aca933289717ac1cb605a80f7e692225504f8951b3bb4bd4cb2a7f62459bf2b7c976f4044fcce3a76ac1f7d4bdc5bb0b6c5c2976fc84b5e1047cc41ba48093ccd7b6b23b43ab8812d90dad273891877f558444037165d04f67b00027340f337e0ffd68836ef72be029b6b089f8ac86f46f9403b40cc267b7edc5e2ddb7815bb72bc220bb09cf91bd00828a0c3cb79d11b50e9dfed861d15e38b6341957f32f5f19222a18435d9d02bd3eea26b622a74bea261164a8130d977000d9f7b855c4ac05f6d50d43b79336d5bf7ebccbc5fc42f9d5049035f92e095fef308da00045dd39c8ff63005e488b29f6f7683210412896e631445f1d7fced33075cd402215a67d31767fb5c0eb2edf1df30dfdf6b73c85b3ce93cab4ca9be8c67d9214073e821d9ba578f059ea87c4f921e4fb7e69110ecad840ea011e9bef87ad8de6eea178256ba846b0916e1eb12b724e04014598780899cad7fadd7505c3e55d10919c0e0613af22f526e42ffe9b8d149ed9b1b003587d2f46038100cb3f93b4f2eb618df9f49af6e4f322183db85644a1bd13f333c94d7b4a05745cbdd8ca45a613c6f6708a0d7d0ed603b03f98e95f33a923d2909804c77dbce2aad0e329603fb034ae7ecca9e006104d4650b3cd5f81886f219344af5d823712042a726a88b301d5784d40c67f20f8b1b2a8e4c93dfd5496581505204cb7fabc772f393bb4c25117b5f322247d585cad46044c9c3069904cf25f91af792840dc898a0e8c83df7039bb17c433d929a5919a80b974c4b1823d9140094c82cdc17a800ab6c1c85127f9b7b9accab494194f216763c21c1e1297dacf22fc8f2f8154a9acbb2f662d032964aad0c98de9320da00a936efcba3c934657f2903ba410718864d78d13fc9014307a74d05cdd6d77ca055831f94905073b51dcf0b571360728311f78ea3cdd3ac35dcbe453e28906f9dea726dc6181ef81eb513c993ac531138935a3c10856c9418accfb0314997413689337e22407cd0a4a188778d25a5b557e141cfd5cbd13f5d9dd114be4df070bb01dd30377ef16675defaa5b2634d0f9f97987d9a33c5167e3cf8226c9c2f57baa730d3ea8b3be75ff9c7f51929643a770c87150365b7a15bdad94f72a526ead36c52e26fff75dbb967b9eaa1161746e80c62192cec76a7d5538b65f15af7580513134284d11eaebc2c83f319e5475980b605d152f8b5c0a34be43317ef664f4f00841135a93f1336bc9240fe752d4564ab1d83bdb21aa396d925df00975963088900745b080a8f6ac7217839cc4c8bd65e9e862160a12dc36bed1a7e0191399839c92099c85cc943a8474c0e4f0bf8ea04a10b36bb9e65460cd9306dd48258cd62805136a6dd0b5cbb9def29852689e3b7aaccb20cc32d14225f67be7ec94a1b739ea941455cf04b96931dd1d410387b557f9949b18da4ca7531d311c75b5551b744f20181513e250034d67b528ef99023d58a2431a8e0ac195c3b38c6731b279eab0bda61e37c29974c14ef036c25629c674eededc587df5bbd40529f3ef9b98b7f889ff056904943b07b805479bb1c6714dc8fa83c87a16091107cc1f4a3cb187f15c074e071d96b3f5fac79af477aa3b8b1a8691cfce9784a0bd73eb8bbf9d8b881e44fcf9e8a86f1167a97bc54d2a7f7b447398e33be97fd2ece3f8ced7c835f2aa344dd2a74f6ec88b2b6e177875c74562ab6567182bfa4abeac052b6afd7ab7bdd2fc8d364a87afb6efefd2d7eb26227de664942bb6b6f0191c4df8ed93d3e5d5c1932b08f6234e3a62e1ed49ff07ab498e3417b7920e17eaddf159a7417e6ff63cb6f39eff3d4ff5ca89a21120611c5677c2c0efa2b78ed6b35a444797dcaae8539c45a2c83c843dcfc35f833f10091418bced14e3eb7fe4c7d2baec7ade52b2ea1ed93f351bfe02d4389f51ffede91f5c33f66eb2693d0e98bb59581da7cbe951747105682d232e78f46f578303436c2c6c078afcab31957af13d60c4c31155cc97894273366230e0bedf8963a423d48313e250b80270d828ffa5cc9b50a708a4be5bc2f0318b80d5fb5de2d8425d5de2dd5b90eb5127a8c2c9956388391387954b1047aa056b6c94b13bffced9075ab059ee96ab4614bdf341e80abd4efc7d122f28787ca53ccec0011deaaa704ccd2c4215347cc34da525b4f937188dbdd137df599754d246648e0bc791d0cb215ed9e88f70246779b7db2985270a09812a0c40d4fb92522b8b2155ef3f5fd4678bbd58767fb7d7a5a7b39bbbc7be735d04f61887bdda5492d3a9d645ad176b47cea41a26b120bf9e2c9f79c5d0faa7a164d383852d3fb7ae5171d8eb4f77898f1c82d1a244a3e2aedf7932d4588f267d9b10b85fa06dcc4473a8ddf1614b88445a2aca1cf7e9e9706bd5aeb9b000a0434fc835404421a97a938dd017a82c1826410b590f457b284bc1fe4de550c692b20a31223dcaf1447f70528630b14a19b85d4fb48458f75ca34b478435fb83e13edd79c1eec1de17313c867bf4e00b61b56f633540552c6f0b9ed45230eeccc4921719c470768c45e48c209bc6fb6bd4c38afad91fdbe308fdb24a5df4b28d739902a4a7094286fc968438657e99b1d7b621f0c7affddaf1c1938f18db5ab59907114e60c06a24b861be315bd0d15f5292d0d9ef43215a895f00bdb1caef75b614839221d5445966ac0d030d9a4233b4156d8f0e83aa7860ac7967e167b21bbd7586e4965ac9e6a4e650b0d9aedb944d9862afffc270b5c6792c84761ff155047291402ebfb7d26b906b65c371e07a4a065cca6f8bb7f1d4183244c0c606bdc9ce633cded1cceb6347b3670433a942f2c18a877c536f775072677e25ba9cb2dfe0642d7cf8a9db7d628a69e15d4c15a28e034c8a3f734046b3d09c57e364b0ec4b2ad7bc36dda91f0ae51b0545a1a8efc67d5c13936358bfa6971c14239db16d21aef2944785371bf53c47669fa39a30ab98865b0b007c6eb1095dbedc267a820ba9e56cc3b9ef24f7a440ea970e0899b57ea5258c43b2b4dc02ae620ff65f0c48cf0c044bd330fe86e80089976599c3d91aca0a6a08f5f33df86c8e10abd7ecc1850b3e7fb7946f2dc763d6fb362db58a970cb7dd82e9aa6b81f0fc2f873a204bd35b6d1fb8bd43cb79cce8c6590e1c19e14154b2becb426cb685a6b0b98ef9e56167374979120fc4493a4275863c52bc41033175cf4e94aaa6944722114712cf0f6a571e31cd8144866aa2602879659a307b675f0e5793877b32b6d6db7a2db3058b1471cd270fd99ac88cfc09996f18dda4f9bd73d08cc72d39d8e54bbef4509a2f758cff232611f0474e336a6c42ef9779de2adf6c8361048a39cff98ac3eb37ffddfff2e68d8f1387678d839be716c4af8abc66012702f504edd87b227dfcd4dad71c1edc236beb3308d4a237c990697e194a0aed0f8ec71c140e90540bada5e1c19629d76126b2c858ab6370914598e68c71b026865df9d6043d2c591a2fafa927212b69666cf539a47b3906747d9feac5fc6e91621454b08c0fdb43ed0c0899268e16597986216fc83c79e1b266cad42b32d324a0fbfcd501ec044b6fd181f3e7142969996d0b7f93e6149955e0b9309fbc3f0a4d70a1ae6389c6688453b4c4f2a85e85bd0130ffc169b8583d694d565e58330d125b22d0d961c8638919991084f6d9e96fad1cd844977596160083fe7814ea6d4456389982b24a0ce6a39e5df2c53d1f7162c93d8335bad25b36898ead329848e9b6c5325d4a8583bb3ff00495d4f138f7733816b208edbcabf7a5543fa1764a27995129494895d02de29a10f12db1a7c950de8d31c2a86149c1e0396430a1658ca220a6755333f9178b21af295fcc8f5474e081d83e47975d77374b325f68d8e276672783ef168238e7683c8222e1aa601108ac7edf415980faa1e9f9820dba28d4403e2d78767564a3231241206ca6d12496f30314253b19a1a477e314a16dc8c0223b60ed823606d2a0638b19178a8ae690bdae60c403c76e46d8c97b1e010a485c9f062f0cc4b88deaeacde714e84306296eb837140a8785f9dc6acbb879de001f2517801d7e0ece131774fbb692932c2c92be824928adf23c24a68e7240bad554aa12a44fd5d4efed2d96b4766b4902bb57ec0afe0fab1a2ee770b191efe87395fee284ed376ca7aab68ab2370a6b52e49e10614dea151465a99fd761f89f31392da2d55ee5675918b0c1b0493a83970e6238965149d3bf6d3c16bc093863db6e293f31678f18073938584531608ed6e5a1b11c3b00228af7def4593494e9b00bdb3390c955554a6874267852b4b3d5eb5547fea55f2f77f868bae4ff4b505913147da4f4aa125540f128f9cc9b2e557583e0b1511cd3d8d1a96ad4b6c5d90629780f618e6503356159ea1121702eacddf6094079bef8e1c792cf95fa2822cc46909bc4e6c2c70d4c0b1075e4d9aeaca18d2422c1bc5033c84a2f2911dd956b7298c26f1f17f41b0ec0ffdfa1b8dbde474d647b59ea60903f00c33b44a6d190f388bea577c344c753b47766327b9f7bcdb80bbdfd5b309ec5ae66917998478a3c116f60c389e00b380f9b6a80ba3ab5982be8ccef39e30c396517050890d877c72f816e541d00a7d7c070bdda59408ffd23875ec2a0ab036e8bb7090b7c7e08e83d32924d33d4ead57010e4024df5fe4b02961ca44117c246cb442071c95f664ce7692e4be280d625adc9d3ff73b846a6bd0c8f73ae0a417ee7204433b5f92bda4c93902e46d6349945a86ce54c2b3b96f3ece4d505d971c0d73bae610f82c6f3d7d61a3fb468b8386299edf0f5c7ff3bd3766bcbbc8ab09195a66ec34c41c251ebe3460aa3c1eda404d33d5e910ca065b363b8e5de961ba3ba00d74dd0d5943f23b1c55d2a45e657e9c63833c2ac3e5e80591770503957c9e2ecf8dea6bd3d2c56515a273ec8994cfea9b2a9cc8c27b764d3d230c9af37f03d5ab0a57fec6cf4913418d66a8a92629d34183be83f700749106a22c193416030072c9cd52656c8a15dce2bd12ad638d1d9148861aa9df8aa1b57996af1bd945e52379a333d1702b3ee9bd5e73e993ea99ca998aef496b4b1d2297d329490ad0773e89f5ab38c9f31ebd7d136ddc87f4183374e182d6dc633f9f28de847ba364213c905f323dc221ee8f060e99fb33be1d767afdaf25b084b012850a0c6117e2ad7dc803806a5d2a983bbd3b2a23c0199cca25af2b66dd9f4780f617aed3e8fd8f1b9d73ac8f59415db5e97f14c204f710ca44e42139bd39eb3971e13e9de3f48772220b2f1cc517abe155643f8ddce3bf437dbd5184655cd8f737047e88301ce1587d069dd7f0521e476f29a9856def84c282c3f87103e0a51b9dc997cda9e24890a496869e1c444626470ddef2dadc6a5a2bada4ad2b7d2cfaa7d539c6c738ccf82df2b1627c28e9d729e49ab071459e1fdc2cff09cf47bb8a77c2d7375ba2ca98aac738f18a55b372b122eb19dc42d29aa356fe18e0ece19ad052083ead5f1a17e996a40ecad1a68e683fc9b419b27d8c00439a1448d8482e1029e6302b525070b7b67b4e7aaf3cc6b9ce703c04671c52c98689b35ffeba2aefbb6d6279cd0b6dcc88b9180d2a8e0a663e451ce733850a38dbb278ba4fe9482b2508d9eb164fd37ef25964e9ea7fbc8446b6c4346d51eb234b08cc5fb4e57d49f737b9b6119e051c1b0ba3d6c19c40ce64b68ac04fc9f8a97ef972ebaa0ccf017399af2e0815d518b8ecb4d19ed7db30e99dd62064b136f2d96e66edfc55fa20f1cb3cb70a12868ee1e5c17722654c15e74da7641728005b2a138e9f4b930668ab5163d05081f18290e766d24a4e34609d8b235a4d420dd1b54bb58d90e3b8f4682250b8f4f66c1ddd8dad6cd992f6bf1854a8bfc3a72207c95dcdaccbd2a971d28ff0cf690387235f7203a1ed4febc7e8a69e4e73b58bb264b7c010139df84c80f6c8b63dd277d0ecbcfd8ff93d66d66583d29f778b81aed1c11092868a1bc72e4634889b65040830362cd2773fd2efc38bc9457c8c75bbd110a079130f38d0057fba390e750dbdcaa18ab8fcc679664cfb0345eeda3b2f90f2655e8592b95426e1a91c2a00b1e91e1478d618c3a75343489e00789b311aafd4989291a0f95b05b6c642e42eceb6be82e3df95e1b1725db9c3dc5d4206686cf390f1875bcca454b5118277196222cdf04c5d8cb1c8a23f35844aa329ac10753d02dda2ec5f2b0b6283c4c91125f2b64c9ccc000ed29f756128551caf52368aeca6465afa203550640fad21c79714a3d0704a13e2bec7a89efb63c57664343a3192d43caa2f04e49ee2022e85bce5bd810358fbf90487e8d4011227c199a9c483066e4fb317dd8af46c6187e55b70762e63bdae226802d20f3ba3f6055e197465aefa6537acd2c0dc78c0aebbdb2d4e8b34ff00070e12ffca9748dfc6764482b1f0937080e4111de8b9a400e03590c3ba718e1fb7568d627b16bb52603751f80af05a79024ffeadcb24879fa013d7210ec6b5985e63ece346c5e7ce9713fc40bba189d7cff44e5e228a01952785593b31469b3269f483e48a30f1d0ef2ca75aa2fc2b4ccf56fbc90df8ea4cde65494e49aa01748521a6763926ac71b1ec8c26f66b06fbda6e8b43e43bb8368588bc61ed09c5efa72b309ba37076c0a0a4e1b04ae2fa4c2140eebbf19953639284b67cfe6ee3e0ef1c82f154431071650620dfef846d2bad030e6624b8392fb2e55cb192c43d2f0e373f7c694d1416a3350ad63f58858e5935823efb44ec484c5db24c452080a90cb24c7bc9ec20851b4c1ab90edee04e973809be5f748cef2f0758cf95ba89a71ba13d27f13f2f1db1885a56447fb79e260c56b8131905e9cc36ca676df6b4f7ed31b0f3f7413da720b83161994d5137459b0a6d6f2193ef3717cd14bd349f8c9c873fd594e7c03543139071053086089904502e0e9a41eb1f7f5daea68212ea0d6e9e42e04c0542ec969c7631ba49f3e443aa5c7ea96c40c60bc2b175abbed4e0ceca35945210f22d773b15009d9f5a616dd92946eda518b4ea9094c22157bbe71d4b0371c88e8e9dc0a79fcd14e4ca484f1eb7521c0aee2053d83f0b47864252ee1e983dc92bf798490fb7f2149d5733ce3db3fea3c905ceda983833cc07f319e20eadc69351407965adeb381ba45d80d414d21fdef32d062233d4b1cea905ce29676e99cc79dcc002e70d380e60f388d51acad0c5f778107c23e500d47371c9ca5e596ecd715ec4baf0d630a23a4153af80891a4e3b4cea2342969a125457135710796961fbec09a93075171ca2a98ce2391f02d5c4bbecb530930aa5671ff732d6d330d42eb82dba70d7bd5799b888026d53c5ab0a5d63c97ebe2ee2ac6a7bf3d85c8bb84d481306364d7401f76ed5e040500b462780616bfeb441ede9055bab0e410d2f676e68d346a4e5297b8d3ed0d239ab155728d5e67fe5d722154bc1cdc60f8597d7799987c0b1021a4c82c9f826b7a7e0586079f36d3c184be6796956aeeeafc66a0e99fedf0b6fb5de52c42de6fdc1e6d5c013a43ed71be613ff6fcfbb2164dd16d0c0765cfa9319d7fd0382792d3eaa2f2fe778e949d62a8a1c9aecdfdee82baaffa125b5522a0ed833d06b20aaed71f446628125747db601d03c7314140f8aa2005e64314f522ac6d7c82e36f2a6265467827e2935ed017e610229c13b575f42b2866658a6c36374b975135a37e9fbe7db4404ebf810ef7066f7c62ac1cd8c8ff3c15805370bf3510f2fbc87b34b4c557b11db1804422f332fccbecf0c39fe8571a2be6f35692121d960c8d8bd8b76e2b2430c9990b4f818fdd60b00337ca18d4138dabc61a40d575ef55510215882ab47bcaa44d5a993a16da446173d044a06e9511c83c2dcb63fe08db0127759b4cdb011cf1cc5d68f902cad88424948ab067009ac9bc3ebb62151e3b9a5ef92c99243f1d795d8407f7de18354da2b8c9b7349cda0487e7118927ff53b2dcc54a776222d502092cf93c12ca50910cae16bc8d57bd42b489d87865961a7f769bd325c4a068c36be9505e65500e453d827ec9b6effe16901479d78b74a816df89abc9ca93ce477c3af117fb5975bb11deaf0fec06cef16b86b68ca3f13f7a60b1e4929178d35f5e645def10791c560c8f064e3b8c3bc01ca74bd809ea5b74dc685b42cd0bc8b3994778cd912511cd0850069afa8d23162dc8609c82743ffcec06969408df0452437deb35614db518556999ffdaa311586cf7173c55ab77db58570168c273b829072819ba2c2ae355484aa6fbcdf5a553bcaaf183d194fd8c6ce51df58e0e7746272561ab3478b01145c5dd6a3746551e69a5cb75361dbd184a6fe3b65f92bbba6988cacf130407e37c99c6d57fc276eff14c40b3045862e63e63b5b9fe81f583f58d03d02ea1ba19c849d429aa79787a56ce6e7a86322535aff634a644d359889f0475f8e6b79800471304cbab32f0f3ebb733b325f5edb8da95df78ef6ceed92377486a88ec81b0c37257ca3cd9fc769f23088c3ba4cd3605f77ba308e97f7fa6766dd4603c7738c356e1d7b36f56d41f3c25a083e72dfd969a852fc190891a74214349fb69562ffb68b36aa231915512658c3ac9f2a2c1377712b50cbcbfe52403268c1f401a565a0641c7bb1ced2b6fdc09e4cc722ad83a687eb995598f8af59720d3fa01bc85b4833563f096a0caa683741f4cbfde885dd89fb7b20aa2d7024987bd188e5416825301d86123bc0ef39135c7a3f0e28dad8de98f4e02f0240554d25b5ca6bd76bb6225fa5a08e49244dc9988be5d1965fbef9e94495a6747298d7f33b9b8a84e2a4c9ef6af4b802acac18526987619e09ce86e900b64e83d96ddc3ff6cd375ffdc58c9f346cfe26d2f7b48563c37796df6593b274ffa3dc35a4dba545f20ecd6b2e4874bc55bcda23ef12f39c2d1e7ae8015193df44460618157465b60f6c1c2c0fa5046920504bdc10ed654508c4bee9e00bbd325f6d5deed02c32a53f3296e5654372cee007721f13b916e43657b06bfa66ea1eec0e2afdbe0707a064bb731f5e5802ce3900d8c0603d1eb5ca11bebcafa0bdfd3ce04ddae776707f916b27e8224557f806e17745ae9df26b413d83013ca511e96027fec11412de148d4b673ceb0c5df0d8812c13890d2e3cb10ebd460f9c620e1a354d58a36fa9dd6218ed939b02cb23cc04b087a7d4aa6d601d36f2e6e1a03e5f497c969e1744af136b51761eb3423f91c20b35b9f02bfe6d0fc2af37f68aa7a494d86118295b40236dddfa892dae337cdd2bf1cb1e085deee0d256d723d979fc74fbb7bfd8eb2a2eb4364ce95c63f5b742fb20ff7992cef6f2a22defb1f747959718a0269faea870ab64408df838c4c3edc618e18af691445f64fc382f84bee2f8b46b6285669de8a5178fcbeae44cde5affd52197f54c8ccfcc8468a53f1d66024a870b6c71664584f600e83029839cb8284bb774019a173665ed29f11cebaa0b387c074d6803c6e52bf083a5d2a0715f7f2d370baff7b35de4f753582daf8c247962b1c85ffad6c891ad7d2d0e22daea491500a4cd5a0cb525ac656598dc4c18f8e27eb90f719f8c3f6e7844d2a477767f7b869ff1045f0e6e938810d02a1bc4103d7d8cc204e075e65c47881b10398a570b50961b4cfdac2769c6ac3d388ed4cfacfe9587e5c4e209549684760b9f7d78afd8fcf98ec27b63885ffd7bd74a329919a57a104109562df538d05bdc067cb4ba46ea178ecef47babf30677fbf34d273537726702d37a0f97fae6d17443908af94a4ea457002e89d9d1888a254bba1eb5b364f4c80da30050484b15bb7935a06056143f32895225ac77119d25b735c1cf6d71a71f101a0e0856443170c834b344c18ddf5323e305d9db55f7ec5939c711334dce1d64f44787aac03a04cdbb0156729b40b64ee7e3e570a709b175cc5b8a7078bdf6257a4d434fc332df57ae191e7239899fd77cd598ec0fdf31460d4b49885a68c97a1933aede95cca5614d5e34c4cbd26c372d82f883ae3cea8a31789941f696edfbd6c7525db9858e0f82de4d019ab06c2c7d89a52db13867b6723966029b6dccc12ecdba90843093845bfd5b4a5d859788fd1d7ce6e28cbe9a5b40a8c3d508cccf6361512f47878637af8a7810fe61f306dbcfbf6bb88ea8d7f16d2ed48133c8600660207f4525fa236fd107983127afc36dc24bec5649912fe65fec13941415b07ec3ad859b05a695e7b2791caef5e49d0f508bcfe4783cc251d8e1af023c236c10456058439025a342962b3ea7e763610cdfc6b3a7c96a2b945cf1ff2cd2c835485bff97672439f2a9fcedfced9f106c32b09b59bc60703f6470087f62dac55e77ef457b53cf326127491e571f026c2f8cde2d3604c52e2a45832eb7647a5e2039d0d1f509834ec6e9d60e26ec5f37a2f7053fa29f1de51e47d130e5169de4fd461cfb4b76b8f8595c36b7bfaa07a0896a5b6f466a79f6c5b4974750c7762a8c2213ec2176ecf59ab0cc2effa63b113caf753d405f610b415435aaa3da48d75b2da2bc2d1dc3dc3c7e9a63e3cd6375da722ac5a73c4dbb05ae8fb602e85c67ae8d393b3ef70b5f8eda7eb93ae4aa0f824d540de5e91a2fbc4d25bd07d721e5e629084f71a04f1d67416b7d7185c53fe39dd436ceef9d01241b4cca952c3cb46bc2e88744d153f34c0b591fece10640a87211a2785892114c0f1daa26e722b7ee39cdcfc1c147f76efa76a07a855f3c3f0955ff9cd65fce8e24e9c973db5887632ae7afec037a50e17b02a799f2bff9685c3f5ffeee702e99c4dfc984bb58f51d1658103acee5873bf82cc3bd516e2e85dfd7d3d755988223f79699b9eb3125c3fa95ff5fed1500ed2b8b0cad571dde47fd5feac1b9f776d5c9414ed8d26ec04b2651e1e1f0b10e48119f9d59ce38dac16b6b3a80fed6fee2cc7e474400abc0e5875da4d4c40277101ff9cb3d6564ca8f6f6b5d4dbc93eb17f586283a6c2c33f036bbeae61e8008c62e7fadd92d151a50697c1f23c697d7a8ef38a1809ce5a69f39ba69f017272e7d34e2ad7b7620fa1baaa9e764079928bfcecd5c4af617d4ce317d562ea232a23b1b19d479d083cd57e87f55053c4120317557b4ccda8e3b19f815b119226dfd7865bd680644aaf2cf33a47da526a0e81c78c20910fcb669efe452401c53b57356afd1229afccbb99c9331148439c93c643d72b861838efc8adf50006e88cc8be415b64739d55786d83f641c97b685426640deb180c454e1372228c6fc6167e80e01777b975a22e3c48356b74ccbb399994a6f8e4fc32bd91d26d8f0e78c91d4c853c6b6ff35c18ed93a3b40b71789d0b045299b29f37828daf43d3d1ae705526f0c3d3b42083e847471f66de3cb018c3f50489aed65ea2dda7f8e2511eb6aa12388fe80b68d897db7277644888d8f7e84e39ff78e03bed918b727ad35269335e68555d822eab7c7b38639a4139645f8205fe88349326c8faf2e7737b74c5d60de2aebffbccbcbacbb58df7a5a74cdcbb5ef90aaf1eaafd862cc67f42dab73855011c043c78873f3af0216ce1b2b8032b5c23b0a43e3160f9f0e6e3e8cdc07457c6fa3628dd72b5a150cf3fead105bbe9b841bd72c9d801227a29e7fcb7288f12289c730bc2a1ee4a6878e56c9f4bdf2516239026b88d4a5ab0817411aed08b12dfadbc76e53ddbea7b615b9d87a4cfba4f9ce62f594aff1a30721dc374c2299f390fd4e3e9108bdc4281f85f068b8a832fa9bd64e712544b2315b42d81c3e335f8e5759ca5865a1b45ea466a2a7efa82d7f4d421960fa6c53b11215839e20d65ac47468cfb7fb1f333b25292d54f7842290e8ab22c8363d3212f0b0a165237294ab91c6f58bfc88300d1b0baecea2cf5babc3b6ef0f973a234ec80a7a2f5b559b7d91c99f82e45252e7a7b63f69cb0d278269bc523e16ef2d7dec10883f6a2220b1c849dc731d13abb920d59fa4bfdbb18d8a9abe71e2a31f3ee7175388785d1e44a69fee27a820e5e7785031a05333878183a4168480256406890125fed87ca77a1fab4ef6583b4cbecf1e7b2ff2b604e3860bb679a11e2ddec7f993abf2905e2ffd5ecd9b5711f0ee042f22240af2101b5e29e62985b1a2ac0c51c7cef44b62476410e3976b326db1fae13c4ab4b5f5fa6bc1e20d14d2c83943386dfc4040db1bec83fdf3e7ba7e1840ba74738355ef57a8aaa2712822247c9e3aff77bf59425458445e4a0a92d6992a7d0c22b97564f83ee6ca33931389186f759faa395b644086654bb9affa5301604f708e5f0af2441b269131eaa518572a2272d148d9ad32f56b5ace8dc96093c4def4d2a91c33998e0b18e09cdb1c2a228946655f69277224fbffe10881dc344261664ab005d0224308ad77b84c5e9e7ee7b71cc40cabc7a201086572bdbdb6d7a5b60fd90e4daf25778c7da75408336e93e00dd5f206a2e2de0c24284fc1b0a5ffebb36b766c8298ce231601677bd04476a86efe144fe6e580f904020ac9d228061f22136a093a343c3cd442a54428f0e345849345af104f6c0a83cb44f1bf76dda9ec758a4623a120612097c74aead060778dd39629b6c4d772116b48bbc5c7ed4986eec15465201aff25ec63332beaefbf9235e2162e9cccd5c9ad9a08e58c96d4075488d5e383086d58f1c2dc002ca94e09339fb901c3fd6cb747486cb37fe1f20041f9c6b2ee6cc746d28590a2bcd01fe04a3a801f081d6d00769255e584d7af5b1a043e4d700b7560d405557c3af67f1838427c01648847cb29d05c1693d5ea04f4ec3bffcd8fa938cd6de857a49193dea3a1050ecf5a0bb94213abce7934f31bf644900e9465cf865868edffa4ef92bdba5a16dfd48a997cc6c4b2b6c4d616b4d074c74e166dec166c9a4af99ed5692aa419485cd3d7953e18698e139ec7307b74d8b84c9f94d86fac73a5dcf407a2b6456f4a7a111001d3a48b06a881e15f171e6f7eaf519c813a9264a86dc2a7d7d45c702101366752bf26ac066cd33a337c65c76c93f4e1ad7fc9bb0f0ca43a83ed7cf35fe9ad932d7bbfd79340c3fd8d61f84b8ad4c2cb605086ed891c5fc3da0381183866a179fc955b0cf88f1460e620b492de69d53a151c8d44e35c3d65bdc527f1855f13b07d45bc49a48362a2d64512432c362492671ab74b91337fa6590b739483e3a3484a2c8eeffca75b0461628471c25da07ccd4db3909b85e5a20df09d85ac01fb545625dc9cbdf78806796b5a38e21b812851dbbecd92e3b3594c4bd8f39e59085cc642e6b5a1b2356ae15f4a00ff9cba9e7c3ec742e760e0e4520d9c3c014b677cf5aac74c1c9500b94b02a98a106d0e8357ecc2f2ab363ae0d8c270c9a543bb257f33469b02384bf1a4843890ab329943bb10c43aae35e5d358f97d5a2a8f2ab8c36b86dba276f9fa4e607b04afdcc308850fff9c3eb46bde66026c08c89dedc7b6d96e91bf5fb3eb550182b39d5c89ac7554bb8fda0037d29f89f9392a2fb35c35b50efac2064f9f540fa8b78307c3d7db0a0d292c602f23f873220bbc5a34c2d3b6dad603b50b0934c05a6db27e46c0f85ce7493d98bb7ac56b24c54e94675d5517a5c73616e178eb40d5833d1f021fa8baa4e86160f1bdc8ce0d0ca102dc2e36008b27493dc0436c97d6e2976212f229713a2d33ccbd13921ce0decc6adc61bd398c989b4b37208cca4d57c9e524bb6976d7042811595439f4d58a85d98a36dad3f4112aa44b13601d13e0e97de50d4922c7d6f3508147c93e620cccd4225c750a539c3e482707112e5f8a79a89980a3ac6f993f7926f7ea959970a7c94d8a3b11e52658019ca09c0e7d8a0aadc2f322cff6707a65bae011430323053e7d3807a01f0cf0a1dfe6b2641a0d3e2e63111e29805f95cc3475ef3115dde93d3b0933b2de91a73d8df686730cebc7942549476e81a42bbad9c89a9e21a23c975f09d64bbf2f92fa5db19f2945f723c5e6d825ddbbd6ad9b96dfd7d510f3092755dfc7b759d08f8c37aeb1ab8bd445af960d8296961397e063418a41c36275670e65e10332b7a43088218bd836d5d3b702575a052f31d340034f64a2941f261e537a311c2c56ef4fd539915c0068d7f1ad0145acb88af7daf1c6ff510b76a405644c84babd7931bf1c09855705f2985beab880d6a30bc9e29317e3321726d4e10220cc70747369c4cf71a2fb6fe4c4c8efae276959a4ab33cb909a1ab307e6639cc65641a55badf6eb734199213c440289a37a1d936d0ec9c870e7514c6eb1cc3130ac659382816f6dbfdcda1bacb3b0799a61feae3be4ee21dded12048e4d5766a3ad9237d2aa62cc636a761a28868d1be495206466d1a99266bf9ba226ece9e8484b8c5676f1e1cc2986284aebb60c94b19c531931e2d0c23f09a471755ea49d3d53c4e3e4125db8cfdd7a8a09ee1ef9a7b61db2fe122cdcdfa9b750dedc7c2f329b574ff42d0934dd58db76f6796fe59b7312545fad99b929f4e29f4adf3f5c68827b446a87e28398789b9c98125baecbfbfac1b74a0103bae63d9ada8bd72c8291c22432db0935301e7cc2cecde1ca47b27e80f8677238210fc86a624c34042b68e1589c71df730c42a3bdfe2ac27d7ea7d15ab1249d07c6829bd2a9bfe710f3df6a8621675d990677b2f3381fe1bb132cf352a36b557b608bbb0bc13adaa04eb7c196393fc09f5339afbdc647e8b6de66672fcf9a9983191de3ba96133dc3bc2cdfe9c73e3e8c8cf133f7f46e7c3f2adb80197dc272ec44f95176580b6eabf159b6cf45776244f3e96c8c64825a6eadbd29e3851ee3ae106dfb0ea304b973cd4a136ccbd70dec7a5a6234fba70b1ed1b5a676b78fa5e187d8ffdcdbf9ef083fbf5f0d1e07028fc955efee2d7d1fb0f94716cada0a610c98e68ccf903a4ef5ac467173e8e0771d39e1a2267898171d47365f2c2000e6d93930dcade2c56d3cbfc620cdc2fa9fd29b960c2aca0295fb176b1618cc8352a9b6f160f80d29dc29a3c1a5138d39c97c36c9f0b59a1a5769ca450cbc24067dd65000898b6ff3dc41b19bb9a17548f2c9cfe2b30e4c8b2a1eda017e22f884e5697aa8d89640f0ce10dabb4132c001baf860f070dd2581e1b286c89fa8eb84563483ce08372c6cf1310218027c28e2272e927f46be9c444dbf78e27846f97bece201152380c2bf774aaf6d50f68721f1044f3e7837d864233c4db90b40163171986b574b2b258070b6e8b1284763613d792c257a12f5ccba391b6e26d06e7c5ca7009ec4837cc0f98192a9875cde1ac1d229e59a765260e8fa4807629311d01c4fb0316ba857fe05f70ebf8e0f260177d9168c8c03ba732f4214178f0f8df92a3f0fa73962e6ed2525dcb49768f51dbb442768824163d6fc7ffb059a75f8b8ca49eaab4a2aa3e03bf66f4ffd91307d75c6f1b09b53b29f2f2773c4641e4323296414a83d773913d15f593cc07c0c1bc4abe486aec3a48c1de23164f2e229ecc48a24cf20581ec64dccef38491511f79c852ac2d5457bf003e89662a48cb5dd23871aefe21f155fc9ed8bf6fffb6c9e613f7289c68b3dca1b0ba294ff6b0b1aebfbb05fdd8a65424cbcab8e11736776ca3b3aabd27044f949b970509b732cdfd4c9419e22f18c266172026148d51f6cba006608e035fa1b5cd74ad4666e463c87ffd0d58c173d02c2c9da43bd751415925df6cc2ba6f68d1894cd38e44d079e7f596d3a42d135b5f700188dbefb8e25dd83441e75d385006d239978968ee3c0d183bf9a60efee98fb78d1a50347d084674944f78781216ce77ea4f52a0cf0aa6c264507f34cfc54517b4e07a13197e3c6438a96d76571c93f0e040591e4d1ffed0f1c2807d2138269246da0cfde522f38edf7b370e03fe1885db5d3539aeb0444a6176f4f24f9e4c482aae8fc4546870b12f1b9e418abb48c41e71528a4474f881496cfa32d968522ac9acfbf35d9104338a2b2ac0387d6f44677dcd5d3453f318d89ae0abf4c88a724eb73a803aad84b3dbb4a355ddd1eca51e3968df81ac779318bfa61585f3c38c30c026a08e033c06955f1e4b743b38466b6b7200f8c9252de85ca491888fb5d8195e7d11d8596e4b583a4e63b576443f446b9f46d8f5bb4949c756164730496240a54f85e416a5552c9a93f38b5929706e2903f52604077f9623bc7927081cb9722a66b81389462b8acd7781e10a9880b41a3882060036acc5a371ee26f7e29f71857d73a257ae7b90c09ededd1044da2dbb2576052ab6a51dc44f00a6982a7b38a061c59ffd588498bdcba05853faa5d50cf4d03960c9344be7fdf68b44b56f65328e90972c10f748a35251b4812bc1b904d68e9d055a6d913860a1e2ab4a0e87cdf0bb89c67893cb8203784e2771183a3da68a319a39e15347b13af0b8d0392dbce9dcb6903a4f25b359131cd9e956c935b0494966438932bbbcaed34b374730e0050b5ca3f1dd82e8db25ae72db57d744c1741f18b7377e17c6e9186b6c71a9d46313fcfaa0026b0fb62b601f708e860742e567df188f44c1597ad8ea2fb0060346cebbcd0387c1f17b4711abb03f3ae1afaf0f59df867a4fb5767efd9f8cfa9259dd29f5bbc90cd7873cc076ec1f6c3540bfeb9d723929c4aeefc02f265d40f2ab9c35692d6cb3ad954cc7021cdc2cf875084e3dc548db3a0c774dbeb2315f3a9aa3221c33923fbad00b692bb984f67a437dcc4802d6e93a801442f5a13234f487b20bc40c5edb0d280878305bfb8370dbd5b170adfbc6392bc396106b3920bec0d3a63e2c2033c9fc41cd79282087d46019bd0bb17bee52c833d998db6b18100a551887b080b3ed9442ba30af4382a5406abd472328602b9f5bfdb65ddc37b6eb419bea9d9d3756f8d384820af18ffa02e32de964e0a5d3b1b75fd048da067390b5fdffed94e5a53099495c3d5d728d05cff30658ab80eb752a323b4b3d1f06677e858183d0a433c031451d9401a9afbb0bfa563ecf11cd2922513b52f79f0852a07daa5fe6941863a300160bbe07cfc5ea23d438fad2e4aef262ff687dfc376e850290e472ff55ee8107d4e8466d68c8654c9b9fa35e1fbf31e1865c5d1a5ed887d13b32076d49b83099286c420ab69043b9db3ed1810d97d372869ccb53d4e0458170aa6376c4126be983e4f3211e049619299c475e2852ac42daf960112153a46dab256f426463c17629a436362b00088a953ce04566d900a2a0cb62634d9bc22a05c84791fe1af05493bfe59243d8024ca91d7b0be5440343dca336a71fe205e02b3ca39b5efa0979f162addf292e995229142f627437e5882d92fb9d541538fdf9cf9f5ca790272e12f691da14ff1c3b5a63d44f8e3bc9c693e68c0cde53ebcb17b9e30fe44f4866f60e23632bdc692ee9cd6a8e4e0a00db836e89acc0e44aee9197261569cbb3766c6c619d376df36fec7a77f083e6343de3121c4276efed0c43340559604083e7e68d21b07f1349483918cb0e8c651e1711406e492e567cbc09e3b8ff7eb25de7f14cd2e20d1aa2ed42eccf34610a64d2fe3fe11b723a8e36e3a95036bbbd5b8ca76bf44764f657add728d678a598299e53ca7736ab1c1a39fca0b72c3f40fd74c6739f5caabfa60afa45f463d5ed7fe4b88fd92bb5a411de657efa3312b001f2edff252677969e19f3b19fc41eaf9951efff7144160968b7334f93241b6074ca902f16d780a143c294ecf0017b86d03a9bca96822c93b9dd085038196fb82e81bb4393c175cb2a559c92545c48d346b5974816a67c3017688439f9c1c6d1263b7481eb83ac581a88005559d73ccf6f68382cc7800ebfb65fb879b4b0334235195ad3e7c9c3c7f45bec6d044c54b3cd50e8512ca2bf71c10888baf14f4223d7455ee945b431e23b01ae22af99b58422731fe1cc4dbfe75a36da9b44c0cd1082e941580fcc7b6df20cea445ec9d5c8ff0f318f03c0506fd330d5db6cfbba23c73d296a4e49ed8b9226b631b7e5d8fed080cf5139a1f8842d25c35c5a5c23e34329fee4e64a12d79ad01697ae68596979b1016bd13d6cd40803c147a5224d2cbffda67902751a154ea2dc10ebc20df068d429472e697b60b67ac023d8ce6723f457c78e93ef87be2421df03fcb841f8d2ad5a5bb9e2ccf9d3032537fc9db16e1b27df119aa30713ea5962850213164d32c4175e934c56c5a00613488375c4e39ae1176606bf79e1733750fcd8aff65983642ac60d1271a9c4365af7d48b59bdc1e062eabf4904e181646d49eaca52d071d65c4bc436d00a7b94237404953b8b444933c3c5ee9b4d0e18de4813b507a58ae86a037aa94e81f4e02b6b5e01972ee68d6a711c85dca653a5799247a10471d5b0fb48dffd0f3caf5c90201262df96240f0848c02f5ce82dea42eacaf96882c58dcb4999c35753b733d6009ac80e9e49f00cbe633b7f4249e947bfd5618130e150d292b12e36c6b3b3fe8a0b8159cb5a2f160e3ea9ec271daf9d3ce3f82055384b3bfa081b78486cb6846601341db24867505cebc9a508214e07167bcf6877ea901102ff99b0a21f58c92aab856ee4e5bd579a34b026cdc24d09807177580afc0f5d5c210ed795707c6101d119c5e7ca334b4b3d7e7cf664464994f7d44e74ebd8d1d6e0166e75cf61df8a3bfeb605b059bccc8b0ca65a20a6cd62f9c9017e62a24bbc887753fab15f5198b1318c4318b57ff4f6ef39f8c622fd3491829350fd765e3268684d40510eaf26bf68b3e1da64e26e60dc1f402dac64f6e3517ef51b37073c321db4fb956c14adcd5f5620d565dd8e7ec916dd14ba60cb51ce861c55b7d31892a79a8e0c42ca9c32e0bb82a239ec55ed3113aaecf5172492f65d26c135b977a4f5c3bb396c4a2c33355918da88d80b852c39614db94a9a3b95d4d7b16c813911f5710c38fafb709966baa9ab6b2da64b8e83ca4dffb33ef12e818405686cbf32597c04e114191fea64c5b398c0901a17d0d540cdb23df83ce0d94cb8d2c1f3a24df6af2d18776114d16cd48a60bb674fafc53bab6ba2f75e1325f3148ac83c0c91d02d02bf81f86fc01ce554e7126966a937cc7597ce63f86ec46cecedc21f1e08d3f7992d834505bd0f1f9ef2c2e03b063feac80bb57da9b4650ba5eff7759df73f074a0a5f3b54630b080448845e4a90df898c4ff53d3c02b91e5dfa4d67acf9f589cfba25d377407b79b49cf7c787da3caa93f42cba758a78a42797f387394a118f87d9efccf2c19be11653275633fa849eba096c8886c845fe5f922a2001add80ac2d6bf306b55a8b15db4d0c1b1c39ff25ee7b8407aef21772e783e3bff3f20be2f7441c6e1bf1dc012cae1873f57389863dd240c335372605a187f05f0b51dd69678d452714e151eeb2dce75c330186ea3e0c9eaa87c632218457c4cd1cf2316e70717d81cf5df97421f6d3a41cff1916b89dc4f50668c665ff0e873254b417eef95a88066b2b0a1f1a2801890b5a78e117d3ae1450981454ae09c7c8b8fbfd1c8f92f839bbfa2f89d816ac57d12c97a677d8dbdacb261310099b5c319b00c49ca4d73afae45c12e30dc4d9dd39f0e5c5c7aecb3df1b9db88a07577d01ef7cd9ba172eb0bbe82cc97b1dfafc8d216984c7e24c3bd6ff2eaa7f3003b4abb3b689b43c81d423a1d80468ce64115487d9fb35098cfc4fc6547664a582bfe94a28a0b97c97a839b7f49f4fa3aba2e6adf8e38de90e46a7ae1f7a791cbdb318777264646f27cce7f8fe9c0c73bbef402bfc7234238dee234bb1d1119828359a5665cc715b511f9aad8d3810a925fff520615a6f687d68e20a7bf56cade375f389b700adc6ded373abc4a979fd23f54663213c91026245d1d814a9bd63888e3c78d0a44d00f6fcd0837f651e3cb3760ba021e151cf9825bb0608a637bc47663e06bf29bc3cdcfcd8b0f1ddef13f684cb859cd9af580b17b0c4485e82202d43e92cf8ad3116ac168562507a57c0d5789e525dc108160f8f20c43bae08fdae24594b8351f0705162d86ab3ae44d511eb11052db378c42b1df8c22ba92315d217cbfb95188d58bccdd13d62deeab55def673caae5271cbe55f020fb7993320054d2b4d27ac59334efd384de0c953f08be8d05d437a831aeaeadb1cfd02d49371000a8af56253f53877b1b353163a020c3f84a68218cbb6c23150b6bdd57da061720e3b70d26efa31884a5b627aec0fed84cbeae4ef97cde04cb5a207a96b6dd9c7fdc06e54ffaa9f737306dc943173f3d601c58fbf0f6d49152e4a6f346b67487bf6665c3104efa6ef4830ac353a9ae0bd9bc3f38e96cb60dccc99ef8efa64d43418736e5a54304b9f54eaef8c625cd8f5d46dca98fa81178cbd12eb52a2b74f4c9993bcaca369af876fdf36f64c717b0fb0364f27f3fefec4d9e44fa666209d5e21f24bb1bea1ff16d4d776fb35f9b731d8a5a981f0cd0a413ca41fb8f77479faa48d542889368251969951ba302a8883b511d3b5e37dbf8d713e579e4dc836781d3b9ef11f707b708e7839720fbb0b96d48b57fae034fdc875bc5f6682fee2cb87cda41c214b60ee573e9240071bd34b6817729c7ece5122ed824131b1c5b3f25a879c3aaed700addccbba69b3cc1c830462733d7e2f489d511766038c2a30b982c46676153b1d7d6e2470c8b7e90748f9fec97379f5b4e37f9bd3444f7e9565246f3ebf72e2cc45166ec2b4afa3b94fbe0edbae7e6cc19c5eb13112f864a28da29760e7831779b4af8c9f0e44d6dbec2368c3d1e3fb6a7cb31e3c3246fca7a6671080f355fa489f2b7a1e9c9e9e9ef17b909b3b7573e3c089bfcfe43395f5e35ceb1bd5e99a1c7226db1edb4ab89e450c49a29ce64707b2edf45123baa59ca9f9f95988bc289e3b8f549617321f055105a6d94f6faaf2164517b99c001dc9a1504aee55acfacfe4848951e81af6adb30bcf3d80aadaf1f17337df4aba7560f0787fcbf823c9bf9bb8b761f16df481d6a36e574c28a5786c7acc41ad994eb74584188f57290d01c1db457e4f49ffdf56acec90fb95737722fdc70cbf6e286b37c985f63e04bc1786f2793a929fe4ba9b7344cd1f47a61bfe4b8419884a42084c2bc6adac46ffe216ea2cc2b487ecec9c9caa2c4cb35b5dbc3b29882886452736b6536e9e973ef4d4bfce1ea3229f9442034d148be8b1d00099b505b74cec877a6d39082da9a35b96982d5d2d894388b42d4ecd0cc66bb03daddef08ecdfe4fe53eda98d70ae0a236c2038ff39e4bbef85a79fd1a75dc4aec1527484d31abc09829951d01876d9c777abce7dba14e04df89b3da386516e674b95bbedc8a48b6276476dcdce623da8fffa36dc95bb6d22b621f017d544404265c8a9d81912a6ace036db7d5ec43347005beb8097a434662f5f56aef1a6c717a9d98fd0d4ff958a8bb2ec7517b715901d4a9e22c66b150451682f3f1f52743eed71290ad60b41daccec84abfad4971c5a0a91b2d39ffdd199cc32f16161ba7978f447360257ed3fa6f01fb61836dcf9ddefebaebf003890d54173a07a2dd1d9d28d1a8fe2fbb1936e63687ed46a6cceb1610cc57006e48b58db5ca9d1e6df1259098702b692f7bc04b1e357f78920405a181f95f726e017849b17939a7ec6f494f288fd003ac2f430612e4fe0fa86cdf358228fc0c9cef4cd07759a54721c673c14fc220aa51a3ef9943422c88e7919580f75b6eb4dad912cda9781cc3f549caecb61c387d2cbacbc842c13a8a6a3cfa8f16c86cbecd3fe9a238992301a8c42024690b88ab85da58a1d5ac5861a7d7bfe786f3b8c190b202c3893c2a1f8d53606984964fa073d6731a241e7729d37bf301b063674fde91b5007dabe42e897041081184c4026feec0313873514d6a218d6df6c6f09356ac950f237a65bbf48c47d73a038f210a1f15ef1214f4accc5fdbc8bf1449c390697b12a9e3d9b99db6621a356ea273d833057ac2c58ae0ded3678c378eba5e4885b4266441fe9f82e3c119ad0118bb940082701f7dc057ebd9385a42cf58cda71d1266ddfae9a1d2e185274c7cc8c006ab160a9cc5d8a77e263bd8d98703daa52ec1080cf71251f70cd91efb74ed4c439721d8d7b0504ce0e221f2c98f6bd60e3d5a3f002f91c7588b5d20aa8d9f7f6fe25680c3563279d903ac8a27f69de517bd162a07ea64dc775940d1594c7fb642f8e258c62eb9ab176a8760c1511e67df24267084f1165c137aca9150b5adb093275d9a5978904f79eb638219568df090c4167dd67cabadc2a432625d5032648b2d7a225dd36a031612326cd45cad626255d2e6b66dcaa4204f8521b54ff25a91d29e5b64bf1400fe25f98fdf1476e1275ca024f811947886ba212108f63403151e4f5e6484c3230868390c45833821890c36432197a253c51918d26e4a3af8659abe29b807034a2fea248ee37db7dc064ba3295e4b626021fa79a16f124e16affa3be43d057ff8042da38d59258e50db158bc553707ddef8fd270a0d8fb431992203e768a174c81b58f96c9a61cf8eab72544ba42bfb0be70b8e93c0ef131315b12d0893d3982dfef0df5e80ec8c231546eb1c066a830840c7237097f307b3bafc85cc1a4fc92491f601af9eb9c3ed07d767b92c98ec53ee9f0f0e15698c05d985d06d3c022ff0a8a8f17a9b14747da009c1838901b2ca8aa4938baa8c8b037e6644150d4410a0b5491bc3300c268688858a0aa6e8608e02b668392d8b1f5b631b8d9a8da5db4aae6ceb002fa27907dfba4d782bbe000f8aecdeb4339254de1dbac0bbbdfc5687fd24eb0f9e0cf40b27b08d139806494279d00c8aad3a5c9c401e9c402128d5e4fc4099aaea6bf5f12112f31eb922faac502f1a3834831084a8a2b63011e232e19c70e288609ffa2071299274d2d438695438693a3871429c38cb89af13f62389ed54d01f585c1c0d93054ffa0b4f883ad6c409fbe184c120a1301038065c86c704d3b448304d2440a1003b610938d69a9ba1288f50441c8250c3f2801ffcb0871611c5a2a1c415419024141e705ce1c58b66103d7898cf0c555b68261045753279608200ca8ce763c5264eac70e3c40a2a7cde43c50e1ef645d5858d2124e1a48a227cf1a3d0cb5dd9802811e599a128204a745205c70d921bd5733fb40849b2c4668a0cb02469faf0c614202a64bf9811816250088045057a51e5630a4754a1e9640a3948523592240d1f2449e3461b7b58430f92468d3c744213094a4c07e573324514275340713285025078509101314e9e473a799474f242d2c91b4992c60e92a4a983544d219d48b106a90627526c7122451927527c21492c28410a20e210070d1d2449330749d2c8210e1faa23d2c0419224cd1b4033f422499a34dc20aaa82d4e30c0058d1b346d90240d1b2449b3068d1a502a7081345688b2271710802445218828d488020c2751f4800349664c9219731285e8240a21ede1c0c49e1c1440f9745072447182b206499242a00f553f1d29c78989154e50c43841f1e2048a1440bcc1861a7690431a6b38031a50cc2a34d5cf48e53d749e40f14ea0d88024492b404149018a67164922d1605f860a8528fa441c9e08c2133778c206663c918227a82772fc139a930a2441b20f060a16d5dce20b97203980f00372949828c2119a3224a20f6a98d0c1640e6e300943124ca660c203144c000092244d5fd8cf7f811213fa509dd9f2269c1309404992649c44401392f41272c14904825085a659759470128129aa1308b4a00a4d473e238ee8c867347d94884e1eb0054962142b8ed455f93839e18124893e584c4e12dbd9545888a88f2864ff379bca332b556931252b40312314847c3c68e6658a4fd5794bb180a80f16270db0815485a62433e68ad057f652568846d40903129172c2800e9c28208d0cfc60499258208303b420018628590423dc2841a3840c2709f080a4714333831304a821499f190d19d080a20331384180002449bac401ec19064822499a31942000094728421124c90c498a410c66408624955146a8c7013a1d901a450a94cf7bda09013c484a1620090e5042ba42152e70841f42c8010ea42152910e50e064001ac9ce0fb91b09400492d448363c78542702c81180499c04000e2a50785c8a0a7d4c47b4b91fdaf122430101557054bf48d501f9a83aa0e901c5740010872405917a9c00a0049274292af4c412de529f138d0f4e341e49a2b6902aeb99eff2a12133f43c78d4ce0cc9d65a6badb9bbbbbbbb33c618638c31d6ddddddddcdccccccccbc7af5ead5ab57af5ebd7a758c31c618638c104208218410bef7de7befbde79c73ce39e75c6badb5d65a6beeeeeeeeee8c31c618638c757777777733333333afb5d65a6badc531c618638c31420821841042f8de7befbdf79e73ce39e79c73adb5d65a6badb9bbbbbbbb33c618638c31d6ddddddddcdcccccccc8b237cae396be62266451a01269a2049d20cfd15b5633f44a8d01b99f9a105c5224379fe878609a1e78844d4e7a3c1424b45b1549a2b4892c60a92a4a98267cad0cf4c21148b2469a820499a29485290a459d92a2515a0cfca8746a2d1ed4c8a220a7528caf4f18caaa9fa0a0b4aec9024cd1992a4818224699e20e9a084e40449d2304192344b508224699220491a244892e60846308134b2e2b2d1426ad1051016b969e9a2a5456ea410225a74c1c5c60b1f5cf8f08c2cc5051cf58879d10a0ce5e901472bffe9c07c241049b44092248d0f7a603731a3ea3d33121c2a764892541201a9e40c48a8a00a4d3374535513a49141621f0c142c449ff9e9c4744231a3cf3f220d49b222029a91e4197926b505cca7230a51d407ca147a84171a2f44204992a429a221f2224992678aa68a23b4901a8105fba11e709445fd2226f0e69c113ad0c1082f6c872ab2f220a8cdb8a84494a772375a841792f474fe506929623f3e66423386f2c82402119224c95c217ff8f8214af2a32e3e2b2a2d459ece1f9588f2b8d8a7c2dd08a50a77a31df552d40d21516929b2b92124a1078d2a44b8808ba8b414516929f2e94ccf10974a543dcc10106856a3ea7308151068f2e0b1015552891f2428c40089219214620cb09988008c20499209241d847843920a1137f693746e10e2708424491e8f6322a11fc283c7065411c223499214253ae288e30d499274c43102a90b38dad0a1b079535d5143d515b523fa1836723c8223d83c723772d781636510660091248d073a20499e5048564d0f0ef0a7f2418940332120a24f871a8281900f04310641481a0ae808440fa27080243d118427cc084403a44a93058fd04bd20c208af007454892540249072056159a38a209ba62468485864715fa4e0b0a473441281e8f0f1e3c74fc21057e8843871f5c241d6fbc21bd91224992157cc8826bbd850034259274828d1b3d9024c944d2c1072aa4246b4dcdd3b2c20ae7064842e181d2c5152b6e0c91dc409124e93d9d3b61664c1b9a9024e943a40d38d440d1b186019ad0860aa436bc90daf000cc075aa1f242c48a0fc582d286244928f6d339c286212410c5c61924141e5c8409483ad84832a4191b3b24c91dca870d014892f459d983225078d88e1c244972d1b18726ec218924edd88310499276a07cdd438a24ed40d1b1870668828a1d6bb081c223f4301d6ac5435923079224893e6b8024141e6b7821556baccaae610022920e3dbc21e9d0c31f241d7a1084a4430f71d4cf4865e6e38362599124cd8e25499a2ba4c98a07cdbc4892a60a49d240f11e3ac3e854df22499a0d5492a4d140cc7bfe41332f92a4a16214b3a93a92a4d93185243d6846f4a099299a97925334b5d0a1468a068a0c4892a491423445530b22208a054451422449937257bef248fb91a11f7725f443923418780f9d2fa11f9fd04824aa1f0251212d5c8288dec5332b25e4ff25886752ca1344f42e2a2a2e10ba40e842c4b10b9166765242dcada8a8c0662bd0b1bb15cd05242e64a8501049d24481b222491a2844d547923416a88024aac20043365b7916214244414441840869b6e242e483345b09030ce96ee5598408110511051122c4dd8a0b910fe26e050cd94c4524a4998a2848339517d24ce58334530143ba5311e24e4514c49dca0b71a7f241dca984e101d2ac59b39595951517222b2e4462ecc747b3955017cd56429417cd563c2ecd563ccd56c2f00071b712860888bb9521ee565656565c88acb81089b11f1fee56425db85b09515eb85bf1b81009715cdcad784222aac5dd4a457d346bd6ac994ab366cd9a356bd6ac59457db85381f1741e883b9510457954dca9a888aa0fcd6771a7220a81e1e24ec55a1fee54e8c8c59d8a67c4853b15241d2ddca97c3a5cb8534932b970a7f281e9543320d00c89a059339715222e2a445cdca910a99f51e8c5dd8a8a16cd549aadb8ac107171b74204c810772acd5456dca9ac346ba6e26e45f421d0b7b85301b284396041b21398c3169224e99803cf410159a0a0f0f80284c24556111ff6635eb412a2427280220e3fe320461cd6e4c0a18283186cb3111c5400872924a99a28554c33ffe30d492469d38353cd2d50aa8992451a37e022312fea4892460211903e8c4e15f3a24eb3d187d1a9dc504992c4bc38c2e79ab3221f1fffa1649e45a5ba1f1ae2a1286abf873b2af4617ca8cf045513e4c28621fc70598321d63004697a149967594305663649dcadd84fd2510951a23aafa53aa1ca7efed38179eae97c0d5194e77244309f0f813af55b5ee4121a0199992c3fe3230d6974a1230d4310511e978fe9bcd84f0704f6d339928646431c68d041094494a7aac27e3a47485082890a2beca7736487fd748e5c6ac60382cfcad70972b1ff79501792a46180660167c8e20c28d2190a80c22326c60c1f141e9beac87cd006049a3c78446ead435519a620bda8806086783a33468aa84e0b7d117826cc0b7911757eb8d64766ad0f02d77a725c5c6b4ae6a599cc6c6126335b1693992db165660b6c99d9f25a66b6b896992dad65668bb7cc6c612d335bba6566cb6a99d9125966b64096992d8f65668b6399d9d25866b638cbcc16c632b3a55966b630cbcc9628335ba0cc6c7932b3c5c9cc9626335b5c66b63099d9d232b3856566cb929946c8e0802a34a181051d687840071a5248d218a820d98f1955a339a4fa8e8e31144092c4700669b262d8c124aa3a42445f8961b2341b8188e488e34554910f513294108a7aa97218a21092247dba683602c30a2429471c3e3e44e0a83e3464109294431081908e544a8865f91025aa428fc443b9f0e0f13c4413a5d90845542728e66d17782049d28b2824ae39eb242ce43f140b17c2f080debe67f36174aaea61266853553d9a8d389b23758ab6108298da114d198f6756fb9bcd666dd6a68baccdda7091ea5b3c1e1fb5ea70f1af22aa3a9ed07790c0cc1f1f335d3e2b228a85a5d9880a7d7079b11d205c641569c6a92687534d4e911e3da0cba2191177a3b754eda1630a389024984f67c6e3f141b550a224a5240a0a40a0128ad8c2195638a20a4d1faa138514e83843ea3863c8342945015285263aaa2469650a1d5090c3ed702a8903137540c1495568ba42f4e98c603a54f4e9c074a81531a34f35d7c44850b8d0c113b220bda07c3592410e9327c427a048f6613e2820aa330249059c8d740227882449ea694d8c44fee8a2e5c5e58b12a9e48c922a343da542a2aaadf8743ca18f59430f00804d384392a42fde43911ce984ac98f9238f279f9615309427871a9294230f9294030f928e2688710749929078286a088b085a26912042beaa7c803a2f9d992454a80865472e40aa17899ece1f445cb208514078f02080ed504578f0d86c389b0e686e4055d58335379bf6139a1155dc3df8916c1c3333f3e2089f6bce9ab5c86233b3983fb2783a29f5928252cd2c8aa05401820d920f81cab084244d2865a0a1a38c468624c870021949282af428a03ac880128a8e17c02149d214eabca0063a5e9044aa4414cba4e3053b2617a4f1a1444f47d7053990241d2ef8a2ba940be01896f850a11f238d313e44cd9719832349938e31c650c0141fdb411103109224e910430b301f2a242302205d7c18a11e3d7af4e8228b2c92503f363233546d92cc98169ca0058f0570b0e0062c60010ba658011e56f082158460053b2469a258a62355473402cd78aa98993228339f593b9f09f2783a321fd3114d199499cf7c99a8a876a06840031ad08087a240339ece8ce7fe87faa8600d1590a1024b89503ed6043c787c353943be2001ca4b0a38a1230569e8484111244a3483f29c2f5270002fe808630961804047180f987184247d159b8dcb0c0f663a90a410497ea023892889053e9d19125d41a1cc7c6638a2102523aa461765a68a992f3ef6333955f8c8a272a95ca8f8fc40a9c2435174478f1e2f59802811109922320298bef8e20b2aaa0051a21d4190b071a49a2324399024c98a1085c40b898241b29084466c48f3c7080cd38fd18f0020ea822846644575081d151a3c78d8f6565e2e4ee765bbf282992f5d94b8415af66e2fd6eae8fd67bf0d92e3747ce3a48fba4b091b9e2ffa6ebb3e1f7df72d1494ac414edb8eb60b19fab58e3afbe98000aa213216a35b2e3277ee3984ce756cb7b9da1546cb6ea64136aeac513bafc7dbde9a25689077756dbc286d4a2b7d7b06591fba7a6ba3fed331ea7ca5c40c3246e896ede6aa776dff6590933ebba6d768db65bf22192475d335b3e5a8bbf442ca7930f3659a60a6689a426f210b89406848469fad85cf698d77353a06c990c51bdfd106a97b3dc52097d7ee56effae6ebdf711e83f11b516d292f4152c0901fd37999a6f788e8a89aa669822c4636a39230c4e55c8bafdd5b33d36b9bf2b2b539eec7791ca2904ccfddc0743c9e779da4040cf241cadcf47adb85d0310a5d48c917647d4799473a632fbab8398fdfae1620912991e843a2aa138a2f255e90eddafa59bf1bc736db7bbec3f248a8d09069e2caf3968ad9346fa2a40b925dbfdd26b79f9cc7d64e6b7d7c3ad41039d97f420917e4b3f6b167df5e6f8c31dc826cef3d76ee55e8d6c6398a619e1117d304f150a205d92ab5f1d5d78feb43879cc7475a8602b52c48b7de366ef4beea4d9f711e77362130aa9ea67783122cc8cb6ea9f37a70c549a95322c8cd239d04255790cbdb9db596ddc62eab97f3787137e86ec4dcf3a2c40a72b6af715a5b5fb3ed68398f8fd409f2364dd3e46e344d9ed9097d354df6f347eaa4d3e4af648c922a48f8d5c6d870d6f88c4de63c7671a1e999b57247de33ed23098daa6316239b1e255490f1ba696f2fd666b3ed6f0ab2b276bfa953c6d7be8342a6490af2d2bb608d6f756bebc209af88484854b96331b231414914e4ebafb459c7d67dcbb4e40c16978d913176b4a785c2bc7632abed1032af469f10695bf79cb9eb6ea55de204595d43b69e9b9fb6d6604913a4dfc996564ae9b3bcde723762825cf37fbdb858ec5fffbe53b20439e17458bfbfceebbeee4809d22d8495ff45b7d6b976dc664912bee37af146e670f1bd8ff3d8dd03c574181224c7492b638f526699d796e4b708bd0c25a44f507204d99885d727bd9479d53a61e747094a8c2027bbed59c7f9f3fe6a91c8344d53cce8e3588c6c684911e45bfd1fd9b6ae0d3ad8bc8408d2b9e172d4dac7b859ee583204e9b8b1061f5dd5edba0d398f65fec342ef1212b930bf90a862254290d7d5fa2bae7819df662fe731bca251ac60485431561204c9ec91ef751c2be5c83c66f379cfe31910559b6da3949714da4629b1bf0408727d5df4daf92cbdb1236d404a7e20fb56a66d5fa41432ffd91e28f181bc77ce06a9e3c990d1c8af07f25f84cdb117df9a3c5db49ff71f253c90f72d7d1effc5d0260629d981ac4fd9eb59613773bbfc79cfa69b16253a90be7c460a99df3d2f6e939303c9d6d25ae9bd1cdd2e4a398f1d8744150ea4c3e8d0b6bab8365a5be3bc4dd5698e253790ce46c673c567c8ec98721ebb8ff9c6cd6fa9daf98cde074a6c2029f5eacbb1b3175a873124aacc90bf9cd6d6e0bbccbdd8d44351748b921a48e75864af51fad1b1edd53490aed93aed5ccb456b9b35b72e99818ccdadb9536e0ed7bc8bf3986d363023fad6b50c24bb9fd45b5cafad5d6c82d854120339db71f7e2777456e8cd79dc2a2530906fc61b9fc2f916b56b3dcee38ab2ce2d24aa5c4919d25a16abab75fd5defee9221636d7d2d6d2cd2551fbf921748c7b5f65ab0a3b3b3d92e71819cf6db3facf6ff17f7978c21ef7b5debfdcb1c63daae084ac490b741d89aba836f396cc779ec992198177d3a1b3b41cda1174551cc65b005eeb11dadbe2a33ea9cf318368f36a2980b250b2a8bcb276d934d7addfc7436ee461be798d18709598163754eafecf69d3777cee3e6a202e91c8cccdd9eb35ddb6a5d2990acadcfe82cf79b963dc679dc5c98a128e6b22cc2907efd51fbaca3fdda99398fed6f9c5d8b3392521629dbd6377ab3d4f9b073c83455143a16231b9824325af85c7de83ad6c9e064ec3e44d59691357e7bee2de60b23a32e3616231b2f9044760eeb7af4d535db659b91640fe16af5c5791bf2f5888548c6e5ffdc8496357bec17e77105b9923ca17b6cebf5ca666dcf79bc61dc42f2fdc256237deb9cd1c89cc7ad0a3024f7a3b76f8490b9b6064110bae7acdab5ea4706d9a4a4f78c7f67846ed95bb582623a8c7e248c77bdbf8c3efe5be9c7c8e6f7da2ef66f6aafb7158f7431b2b5b05d643c672fea7e566ae733874cd36331b2b9472473ccbafb4e069945c6603e9d2371a140b63867b7566db4b42ba48c29d71df93d59c3aebf5cfcd79a3916239b1270e4336ef7b95557a3d72d384d1ecfd769fa108c74b6eb55f6eb32e89e3ae7b1ed6c1e34237a1f1fd334f3998cc5c8465ee97445ff45ddd1e66c9df3b889626e065e72858f3257e383d3195bcd5609acacf7fa7adc7ad2ebd3b2247605e6335ba6e9612a10b5e1c76264632b7b6c113ad8cd1d8b8cdb6f33cbef4e4ae36ce6cb79fc222425f4a29569fa109069b2df0151759aaad08b40d3cea9178744a0122550099fd97b778deef176fd50f1eba78b8f8a831588e231253f7b93a17b945d74479d6331b2d97cc19c37165fec059941e8fe9c57637451e775b1a61fd98c3b8b914ddd480b1985cfc2a60e42fb28e7f14c4804ab1af2e1550d4d8f2c46367e02c79039e6e6cd7163e6a037c3d8683b1bf95deaed1c13c86fabbbfda573f27a7e4b20ff3d3285b63d7576d049201bd7faec3ae8aab769dd76a88d6331b2198111f9e89cacad5a997afbdb11c8f8b6314abb1d737a1715e285f479eb57766f74ccb4af08e4aaf7c5c87e9bb1d58ebdb4b318d904292299766cecececb3aebd4d53880a857e9adc6331b2e91071ad57ece7e05b8b6133638fddebf2e833c2c7cc3072de344d93f3900884821779a3d3396375adc6089d398fab23f3411bd1c344b7d9bce748e86336f4486dcd626403c4455ac8de7270dd672b6cdb388f31d022adc717fd3686cfb5785d0824e3d5b6a1bdb4bae7f035f3907f0f176d96d77cf53b86a00bdb5e7cddacae56af375b4bb5b02c06eb738b42beacc245570b1792553759b3fe8f596ad9e43c4ef5d80979104e7eeb7174cbc276efa113c4ed0202796773b4f536befdde6d9cc7202a64797d405e861fbb317e0621dfc979fc1fca5337cdbc22df3adae2bbfcdef557e63c863fb6801c39bef5da41f61673b39b6290783c9364bb38cee66efddddb9585d1a94621ea7a40319d6e31a30f13c55c9920b2ae8efcacdde9566bffeea53651888a7c11bac3d791c2f51cab52327b993a870dc6bf6d4db7a285b4d32b64ebae5b61b376711e6f18b3e3fa48581740e46448adbdbed8f3d3d99cc79b66278ab9ccfd903e9f8b753ddb45db5f1585a0077cc8666f3df36963a4efadc579bc79d003d21d3ebbfedad93e1d759cc7905f072483b3ced5ebde1827e4c9792c438560b87bc837eb73cbe6536eb0c5cb791c12551c90ebbbf56dcdb173cc59e43c16c5dc48240b79dd5cded0b98eedfa659cc71bfb991bca72bf116021a7d7472b37eb687b66c879cca946a04d88ba1be7230548ca4bca8b9094fa45ea23d9c8ccd06b2c46364278c87fb345c8a8e5efb72ce43c0e4d4eddac491473a7e9435415816814b3598dc5c846045142b771d186937a3be793f3e02845a52525e54548cae6d3791d1281d887a8ea2c46361c80b23e6be37d675ef9bab9388f43ff79922e08e7746fb5c5ed59ca795cd9ff6a237a98c6292f41aa99b27a94e2324d33e54548cac6238b914d890c5c6ba0d9d780f3142c02dd14159200531a5812b8c2025304aca04015bc6303ddb91f025d400313a082023ba498428a0c5c408a2b1aa5f0e6391b0a60c05d052e9084921159200a0ba040e15a5b80613307a502cce3e91c5914986202f3433b2430f347aa88c01410d850f10051688aa638690ce880e954513880ab993fb2d9d1002918d03154dd6cf8886b0daa5fbd056c7628000309d86ca440c026c98c81e20030946703f3e9c0c0509e081820c60205e0cd87ee2644892605083000dec44c118a00a80880fdaf36170040ca13950666478e8dfdcc8d9bf0460325bca93a9b8d28c96340f249b0195028f998f9d1b0197d304001a4365ee0081fd20e7490031cdcc00666d480063390410c605006192f70c11862b480052b50410ac298495285c000519f18cf1114743830f76da5f38bcd094c500212181981a4a30966483a9aa0891c602880d4861860f02179200090e8801d24a96a44079248928402820e3c213d128a7aa8da630d3d9a207a981e64f4b05af448e9e1000e48e2840376c082c4811c70400c69118a901c6892cce2115920e2d3a158baf359c902491643b2a0408924652161f1862461e1052ccec02208120a0f2c7220cd7c7c4892261188a82e92260c27583880872624942a78acc1c30c28222a08ca34adf048398421a4dae1804254cc8c87026d409468f347664c54c34934038507caa72324824ea2094ea2072449a26207ca099aa2a2024ea02002af979d8bcdb7f84d19c8da8b5a56d946763dd218c8c9f8dde7bd60b35f87815cad39cea6abf172ccbe0c19977bfc98838d23fc66c9901de17d089d6defb5f802c9eebbceefcdf68db2ea02492b6c18977d7863f71c4376743a2b74d4325ff7e51043daf6bede8790a3b3d16b27a475b4c2656f9bbcba3527248bf1cec88d2dbe90996e42b2c5fe99efbba76fba2664e4ebe65cb523a3f4ae9909c9973e65b7b7c18e7e3121ddaf576b74d3c2d96d5e423ef7cbfdb3eff64dee6809c9ff0c5a0717f51befad847c37ce76935aafedce2125249d8e272fea209b4cdf2464d759f9dfa22daefa4d1292f6578ed6c5b6bf6024e45d8db2e59a29bbafad07095923bceece603b65661f21a765cf7fbeb8e0a5d61192d5be7fd9e4c9b339d808f92cb3f1da767667d76b8c90d1bd3dda8f7b3d48d91721fd397be7cf672b5f5a1521dd178dabf93367b3c144c8cacdaeb5ec22651e9b2142b69bb536b798ad6ca33d8464af56dbcc3c9b568786906d1d5aefe6f6d9dbba101246d6737e74e8cd1242b2c81ddfe30b59838b3b0ef9b87937bef7d1d5ecc22163bc4ddfed7d2f3e1d846cc8b7c5b6e074ccad1784a4cf5ebfceceedeae61c0819db9b2c5e7ee88dad0a0849ed83af419e75c23be31f24f3361f7f74b4b9c86d711ea7bc04892c46362c30f1839cedb2f5b1ad7b591fa4c74b1bad9332b6be46ee37e46d9451f73042e66ed15a01f11d98f0c1dfd1775a1983f4d5673898b821979b96dee66e7d5f5d534f790992c20d0993362adf5ad9fe7dea1a3664c3ba76ddb9afbb6e03fb0c267b90ec8cd558638bd0aba56bc89f8b3e9cf3d2ba685d1c4df420dbc15f347a9bafad852f4a1335e465bcaaebc7deadea6e1cd20224c5ae4cd3102129ce358b918dc919267990af59e85875f6dea06d95f3382482292f4152aa0f202922aac8e763545a5266422faca182091e24eb55fbf1a4eed141fa9cc77e0749996de62284ce1ca59529133b48bed4ad66f0ef7ae89cd641ceaecc7e2f76fb68ad7490ef6e4f7e6ea616421add03267390fd60843edf84d6a77b4b0ed2a34fe66b9f3d52bf1e0709d74fdadc2f16ffd566e120e36cc6ccdab61a69ac363233b4ba0b9337488f90b6f8e6ab2f360b997f98a421edacbce663c691d947a90b17dd5b98b841faabd1328b3e277bf33658039336c858a3ffa38dcdd896b187619b206c901056c8bcdc5b5edb83eb6e8ed4190292029b47292f42a6a95a839cd5a37dcf986b0fdbbd1640305183e479eb6c0f2bb5d6d1c7d2209bbad66ebb471a29f5478364d5e37acc395a5985ebb9c919e4740cb6eb7a5adbbaf96e4ccc205fa5b6b93fc75665ee1e91212665903c394e37a9b3962f7ded8c98904132c71afb572dfcf518da24d48f69b29f84a2f0814cd0e0dbeeaf1fd20b6f739cc7ac81613206d7fcd88b8d357d7ecc793c93840a8136949da6bbb1764e5367865e9849224cc4305fb5b45f5bac3de77d6854519e3a4d53e83d9e182aa4b21e17c2240cef3a5e70ae581fb4d13d189c7d733ab53d2b6cfef00b72b1757d7673fd66a5de9cc72ee525488aa7a33245c1c40bdc5c65cdd256a985b1b92e3c1bdbd23abd4dca1ce33c4eb16f9412d3e154139214fa4629cb45265cf8371facb71db37651cb792c1ac540d1888b8f4adb026c6ef56aedb9c6dd1a64fce69bd746e79abb4e3d9e59fda3d22030d1826ccb1a3ac8fc9f7d6fb61504932c4867eae6643a2b6d079b731eb766662c46362e265890cdba069d4dcbcf98f6e43c66579071c2bb38be7bef627f3d04132bc8ffa737fae4e8f7f97cce635705f911367ae15f375d7beeaad935c82c46362a26549073567693f2c3087f7af4782610b8e13805792dc765dd84cdcd27749cc76b39becdb118d9a4984801f2eaf62284efc1d51a3bf77dcf2d8fb53637635b6d1205e96e8b7771bfb7cbac3e108b918d8cc91972b1e5a08dfe1e3e9bd78251b90f1328c8cb3f5b651446fec93a4ea59f201d65dc3d2f53187d42a6448e7a6113274886f6e73bfb8cb5fa2ae53c8636860aa938c1a40992bdcba67dac27b747df5db498a669f2314dffe9dc3b231bc184097245a78b31857cdfb4fe388f3715ce783cf34e936b7d642d41da67b638ce18e37cd52fe7b112a43b07aff3ba2abc0bc69504e93f9fddc5fc39caacd6161324c8f962534b5dacd4f9b109f31f47c4e408b24e678f56efbecdb6d08701999a1841b2b35add63336be6fa721e7f189de8854911e49dbf9a6bcfd1c5a87d8b08d2fdb2d141fa66753152e63ceec7ae932cde5c5eec5a1f7116231b6b3204e9bc5ccfe9edf2377bbd0c132148e766ff73778cf673b03d4803932048369fb2d71c8b6d326ceeabc919f2363c630204f99cbdaf6db40d726bb5b24cd334b118d9844c7e20abfbaf7eb698e3846f721e3b2f9a890fa45b3a9973ae9741d87f7b205b7cd545fb2e65d6c1f64c30e181b4363ed61ada7676f19dc90ee47aba28eb782174d7ec7520dd9dd3b665cf368ff152931c48777b2783eb31bb22e3e7e2c28184ce5f63ef39dbeab3fb8603931b48fad839d28ebe9ef5d9e00e4c6c20eb8c2ebef9dcc15ae77aedb118d9704ccc90efbeb7dada0bdfe4781b6e4c6a20df3167a753da9c451b8398d04052d88cddd2599ff31856cdae99c5c80688c90c6074ce9c6b7f10765cabad685babf1aee5fe276b9cc7d3544d5343622203596f7d75dd8ff73d378c233089819c7f9bf9c6c9e8746c2d0c644fc60ee374ad52669d97d1984318dd45778e5f5bcc316ef1cdf687acb137a7bb266448baeec3ba38b63ae37bd85108262f901c63cfc50dd6875cdda10f4c5c202f75edbbe7bafda86537fec0640c392b6dd4b67737da7cb69939649a360c6d6022863be7b55c73ed357c9039b8daba8d5aa72f42cee3fa5564b5a413322ee7b35576ca9abdbf9c57411e259c90ce36666e578d1f9aa3209e394dd32446c926243f1a1bf2b51f1dfb47ab91688aa6695abce15a7562dc394d48ea169deeba7b4e48d933212fbdb1cec66e7d7ed15ac79890942dac7fffc218ed9b7665c3979014d2e50e2ea74e7b5d670969af853e9d9dcdbe52d69590df78be77a947cbeebc8b12f2c50b639d8bd955198d91eb570d48ca8b9094990701e4c59bda11813a1ecffb24e4ac8bbd236b6c424948e7e9ecff47d79e832ffe480192e223e545488a5b33288984ecf6565df48ece7dba2889f4e1a20510394dd3344d90c5c8268c1248c855175cb0dd9ef436b695f338446d440fe30c1fe347445f0df9f973065fb7b51c33c7d5f4428ed4fab5f03942ae76b7e79ad3679bac9df398ba9fc842d983665e5e63414923248db0b1fb63f3dd1779aec0c808591b65f4d9e95eb7858e721ec7182aa4521fe4b2796c11b2d969335bb718b5cfa822646cebd9fbcf5bf516991b414922e465cf1d72bf35bf794f4448f7e5fc6f63361947f74a0eb19c47e8abf98aaef16bcc1e650cd665dfbdfd9ffe40506208f9d37943d86075866f7e2124acec99bfc5bad967e12384847f1dfeab1edb743ae390f317736eb96773f6b21eea8628d154490192b292f222240534b99826d08ce9324ae090fdeee9a3cb32c83aaee83fa41907258390fe587baf7d9dcc7fc21b75502208c93f21b4f7576366cee683665e88501208c95ffd7f51870d99afc8bca9420920249c175a667eaef7f99b4c09257f90b5698dceaeed175f73c779fc1eca42d4104af45999a699d0342d1794f841be65b66e9b8fceda16bb73913ec8ca13de1559a3b732636f2624fa4817672a94bc215d64fdf74e36d763cb66737c908de965efda581d8cad35b8dc90b5fa7dbfdab1c6ff1c4e9333926962deb03312e656286943ce0a61bfbf8bcd7e3d1925fa6c28d1a7232a61433eba383a6646e9622fd23dc8dad6dfadaf1f46d8ba398f535e82a480a89016d304a242769aaa69aa8f6495ac21efe2ff77bfac46dace2ede70e56644bd84123dc8051775d6ef5ecabed52f324dd334239aa6b678c3a2cf9b1135753f9d2794a8216d63f1babecc2a3f742b461894e441de6bd9a3ff36ceaef7effd16519dcb8c123cc8562be5fae0ba6e417fb889d3b4d9cc696290c5c80649c91d2483d646da5f27eb1669b483bc953ebfeb75ba66b7da3a48171964b8ae57ea3532ff50d304598c6cc028a1434718577bee45065d2f876f45c6b6319dccbd2ea8d292c24222d01c64335fac358badeb7cb0c941aec8d7c26e8bcde96f31ce6318070929bb93f6b4bc22abfd70906dd6196d8bebbdbeb0716331b20941c91ba4a55eb9b11aebbc0c574d43062f4252364d038d23649ddf3e46c7ae1fda081b21a3ede9bcfd2dbb191a46c8c8eea3b4c50b2df5e7e822a4ab8e99f7b20e6173c740a3084967b5fdeeb17395e1738990eeba375dadad5dbbd5102161eb0bafed09b9aec9da2124ff7dd3f5c7387dd96a08e922e5b7babeb5dc72ad0b21ad63466f7b3769a5712d186808e1bdea8bdcdc1ce1f78cc3c5d68dc1c8adb1e7eeb56efad6a5ee3dd8e87c4e82060ee9ea5bec5a7737725bf7721e6faa8dfd7cd556a019847c666dc1e7bebecd5717e7f1a713f3a4a011847c3376376bb0d90addb46ff10d348190ec56fabe3d63ffd673721e57b5534dda0c9da0018484b75ad7ec6c43e6f15dcee3c647429408182f012841f307f9f8adf8a2c3469dcfc63e0fa2366f0a1a3f48db9a2db7dceb56576bd5e480b81d15347d90adb2e50aadff7d96b5c9dd469a37e48b7ff9b6bbfe3d5d35721e579bc62548d0f081a7a57143bef59e1bb4f645ce63c647d0b4215bc3778fb6ab76cef63c76e5d3c5345547288ae3adb5d6dcdddddddd19638c31c618ebeeeeeeee66666666e6089f6bce9a81a4acf780462f294384a42c6631b211800e346c48f7f6359bf0d9e9cfd5f620e3e2bfcfd56b3d46ebb8d9e84dcd1a92ad2fee3a6f63ad3646f520ad3b9f163e74ecae7b5ba3c6f2e570b1079b7384f1c566462773eaaea3f63e7e1102aaf8bd409307d9d3be6e3cd9ecea98313c48c69eb7fb6bf6838e69c71f9a3bc837db337e34fea26ddd0eb23a735e8fe9a477cdf60e68ea20ed73cfc566975d66f05a3ac8fa3ddd5747e6bfdeb47390f15e66d4c27add5bfea61c66f3652cbaa6d4c541def637c2e53436beed3138c89eec208cb3ddf6e3c741346f906cfb7eecf726cfc830529f4d1af2b5b61c6cf3ad7aafabd70dd2adffd7cd93da36c87f7d216dcc3247a78b970d32b668a79bf4bed77adb5d8384cf2efbfcded76c9dedaa4146660bf6856cb548df6f1ae45d0c23a4ccbae69af58b06f996bb95ae696b3357d73d83a4b4f65b77c1cbf0f6bf19a4c7199b7de7e5e674fa6590917d652dda66f6b9854f06f96ebd75dac9dcc70ae1a3212b5cdffcf15d47eefe31c8f90e63abebc1d8dcdf8a4142eabca67f43ead1551b06d95c5c3fdfa37ea1756ac120affde6da8d6fbe38e9d72fc84b678c76c667de62acd50b923ecbb4f2ec1b99fd58bb206d6d8cb5eacb7573ec552ec88e76b1b5d3f67df55ddd82ac8f29336fac6a41b265c8bee9ab1f6d8c340b92cee83ef247cb20a38e6241ba1aa15738bf3d63cbd12b48f7e2bdf0557bd77b736a0549ed62a6edec73dbdecf2a4846db32ebd6b3d7cc7d5241be5358df7c5fac7ae3390519d775eea96b8fe9ec35a5209fadd459bcd4b5e7ed4641cef91d6775bde0d7f6ce9035fa85f0d508e1bbd7452848c8ce27bb6af92db72d3e41c6b710d6bf3dffb2d8a213a4bbcc42a6def4459e2b3641da47e97ad0ae09978b8f09d2eb8490f56d0f2e415a7f73ad1721bbf3de0695202fe409d9196de7983b4c82646eb3ce7ed6dfcfcb201264b3f9bcd9fa864790d1c5b68d56462773fd4690ce1bbbf894de7efab408d2dfb608e3c70799ad4904d9b53edbaaa5add9f8e21064b53ee76b8ed54b2f83429097b63b57d7b7af36c320c816ad5bfd2e7f9bec1d10e4ac90f9b6b37bcc20fb81bc6e3d325ff7e9a48bf94032e89ec1f72e75ffdc3d90f52bafb69c756c35ca8f07d2b5f6eeceb7dd4819bf1dc8f64ddf23adf6efbcebe9404ec636c6c9de0bfebd3990b679edba66a50d69b338900debb2eead577703d9ee3eb76d5a6add84cfd940fabb5f6ffd67f75b73ce8cda6fd1afd0b9d740c29fb0b27a978dec6f391ac8f6ae5f9fbf9beed29f81a4f02b6bcfb1177b95817c7ddfd7357945b89c8d8174cbd8ec4921bfad0e0319ebfc6f6fc50927645a86f4b71c4f47a3c775a92343fe5fbaa24f1a6d6d97db0b6465cdda36cbfc2d57ad0b248dee35bcfdcc3563c8bbd8aaae27ab1ce784ae1143fa5ddc225bff1af4e8bc13f231d6e072d6debcce35e7847cede8dbda70bd5ed57d1312b6ed78617f378cd35d1332b6d7ec3ad8d5bd789967423e6be3ebf6d31b42cb1c13f21d73f5fbcef64bc86967bd7e2f83cc685f4b4867e17ff7476baddf5a09f9f7bdbeeb21656e394a09b9dc3abd0e7a7bc70a27216f3fdb9a316ffd6d1f9384642e3a73cae6eafb5cb348c8fbb73e67f359e7e6650609e9bafb3aeb1f6b3767f608f9fffd6ddd9d73b62de608d9dc3f658d6ffb657b1b212d85ebed5a333257fa8c9090619dff6b45d61eed22e4735b8b5abecc5fe354846cfada6d77e337a77176222465eb229df0355eb3672342ae49ab6dd0a77de65cec43c8c5abf6834d27fbc9b00d215f5bd6d969d95b685f77212474b4ba181fe3f5e6432684b46db6dff65ab3f5b28f43d246dbbdccad166be387433eb62c9b0e5aff87d10e42366dad5d6bad20e473eef2f4e8de318d3110f2efdbaf8fa3f5c72820e48c6eba7f0b36cb6dc23fc876aeedaacd9b3af3e60759e16567ecf274f7f0f39efa48369173f441322f8f6ebab518f305b90b39de9073725f9eab3666bb32c879cc2c0d39f8209f3d5ede7aaee777bdc779bcfa0b39dc9097327bed2edb7541db57c8d1867c2eda6efc6fcd79a333a79a5b8462b828401672b021d7b42ed6d77cb97563b59cc7cc43c8b107e97f9fe1b4eded5ad5ddb5de629aaa14205ca4ea6ecc626463801de458433ea73f2bbbcfcf1b7cce79dcfc1239f4206bd7e598ffdb4ba9c3c979ccbac83475403e9ecea7936eeaeb3672a821e18dee28ad2bde08b945cee3694a22da7cfdfaa13e33a24e10d1344d53354d4080cc70e1a323aaaa8f21326d804cd334d5ce34b9223f3621ea6e3cf5ed34857ec30800478e3c48e71832ff1bdfbc8e617540c88107196df51a1f8b34b267ebba83b4de0e3aeaac33c86b393bc8e5ee9dbb8bd55e16610721471de4bc17d267635cfcdcbf4a07e9ef5683973d5cd6798b73905c9f33b57e7fdd385ddf20871c64ac77ddff07637d74d6fb221172c441fe6cb7cfaf9baf3ebf8ef378f3e01839e020ed8ab3e19dac2b85eb43a056418e3748d7adcddb207ddc2b726f380db95ae40bd7a4d429576b398fe1e3400e37c8656b75932f5dd4c55579866eba3f44a6c9c275841c6d9097c1fb1c63af45ebd41fe7c9e460836c7575f3e8b1b24a1b6d1bd1c33c167d9098630db2f1737e6b756bcec5feaa417eabefebfb6c0e7fd99b06b9a83b5ae3a37da1adeea241526e7459fe37fffff93d83e4659fa374da7663f4f56690cdb3f931b33ce7b3d396415a0bab63abebaa707a5b32485ef3dbd5699fa50ed9a221eb9ad3ad6d95f6dbbe750c92b5f77c7dde39fd2dad6290b12fdb7fb4b938b9d21a0669179bcb2984ccd6d6af8241ae3aadc73add3bceeaf50bd2b2ef091757e610ba55bd20ed74d4b2f7ac1bb37e6917a483b6ce7f2dde8e943ee582b45da3ffe2c5fafeb2740b32aec8625cf6368dd629d582b4afed6b5a5f73cbb549b320a38bfe91f2adac9f6b140bd27eeb369f3b579f2da35790fd2d7a5dde627c0b32b5825c6bba8eafddd51cfd45ab20179bb53e66deef61a4930a9299bf76e7699db519e714246d6daec6fe4ed6e6d32805b95e83d456d74ffd7bc628481a1d5b67bd315cb1bd78866cf76c2d7ece277db52314e43f87d7adc77139641c9f2027d308fbbd06676d6b4527488793c6f7decd9fa50f9b20e743f8d8f3e89c65944226483b6765cff432537e0f2e414ef7165f7b87b335e7500992bddeeb7132d88bdb7d49909399478e70fa74bdfa2141be175d656c99df11a4d3a68b3238e9f5690469d7a2ad394bfbc6d56811648c8c3a868d3173ab3a11243386cc9e5617d7a3ed86202fadd0b6a5d3df53674d0832bae560bb752dc3176310a48ddc6bc1bf0f3a770804d996a3cc2ba476adc6dc7f20fdf662d3ef5bee6f6b1fc8fbccd66b117275372ed6037919474bb93a7b7651ca03795f73436bdde78b0d7b07b21973e5c8e2ac1e2bd581846c9b356df3bde5eb9c0319efbd8e3fb275f7d98a0309e1f467b13d7803e993ffd6cbae8dbf9e17e7f1c7cc8faf20870de474c7663fb61665d3a319b2df556be7d7e991d25703f9dec5c9fc60b3fb5cbb349090adfa1de15fe89abd33901e9788a864f0aa959196a22086310010425949150063130030302c1e8d86a3f178a2287af203140004597e6a9a422e124983c1500ca3208a82180662100008208410628cf14a116e00c03ef6a440347b8ef61d6168e8db8d0df74bf5611d510b68ad2dc4e0fd4d8a705a5d0d20b5810f42cc59fd9f4544d406b19c83a5727210ac88d8bc7a22b7f22c74413e376766d43f788a5fac2fdf055a20aaed78093242b7db8e7c7791f20bbdc6d4e1d1c0af715c1647479b78593ce764b6f93fdf909a5f5470cd7fea27029f280eab52b3137df15661e3323b8ff7015830f651a7273da49283635c46bc941e5f330b5c53695aa4c414c740ac11cc8cf434f43e3b88e4e300cbcf1b5855b61443e3b7cf3ae2f58cbe3a857309bbf341814fac97189f5c7dbbd563afe96028de3f4d559c637775ef79a3917c321f061cf708f244ab71818e38d3693729bbadf51eb454afaaa0d78a3f4d96679d2e21ac2a4724c040e4260cf2b64988d8840a4f118c18df8bb57c4b12d0f1378c3da0aaf7845d991ff3d2e20506a60f0aa374a0c8efa7fca2a0a21527897b47f660b144cda256ae37b42d3e55cd014e24343b0245cc00d7683431844a4d024634b43b04256600d928b43186524d014344b43a0635a600ad515aa79145472ba4a62af3940685bac813d562c2a15454487a9b188e64b508086641d025fc6b50cfeb6ff590124f46d0febcbdae95a0e40be251b52f6d3c1b83e9328941be548d995566b1a4bacbc4fb17900195418442a82bab0fe602070a2030b4eed4f5c941dd598cb823f387efd4d4632b82e965e5d48ddeaf1cb73606e2728a1388010a05ff86fe03848fab7cf105a2e4006f4b5c860909ce6cb43b4223b61ad1179b067e396222d21b4b2fb206a21d49117b35622ed207421dbb22a26e4e92315b2af3bd8e0d743812230636e22eb60c9c3ab2a2440bdbb494cb10a390de587a252ed413d3d1fe6ff0381dd8e5b83a72928c8a309d4fe6985bc7bfc47c0397c5f1dbe276fa2f2b5ff4b24dac5c183104e9264bedc585d4cb8a6f1d058ca38db8ce6e276d68cbd03a55b24bd0f5d2245eb95cd7fc4bcf0aad93978332a153c81bf241fd5a11d38da48bbd066e1cb1474aeaa8c08413c8ccb8a5ff1bcd97b5b4daf0a490ab1173b17d4c28bf2cb7e87f9bb272156230d209961ab214a29b2415dbcb2d9a5f38cb4feb8525bd6b510ddf74b7417f656659966b0d9b666a9e068e85db46721620ba2f4a001204182f961cef46f5396b295ef6f0725dcc37df84e951d1da2c706a31db74f290f1fde9e2a18c31dc6c1ca3fd8cd71ea7da9dbbdcddb6d970c5a861734295122e6558f85afbaa0ced3d0e494ddca948262bb01a15bd7ba69d12db681ba49b30cbdb7d19f28eb2710b7b85237b6b0e9d4bde82f1c80913ca03e9e787d9c605cec4ea6c6783853117b6c7ce70855075dd0ab7eca674514177509eea1601f155d06c868f7e9ac0a2bb4a93744b2c62e552a7df82c7c80e9410c6568f1a106f5926ebb53c43f68cca8287dd6264cde7ba3e28ed5506c217ce7c270e662b2b5907a87fe8cbf965efb3b7b4b5c7729ea531371476482df40841102bfaf61c052b0f0f36752491b2b48b4d352190a2dbc7847ac805d697dac9d4db56be954d37ef10cef6614f290e60e834e594ac79483a807ecc9167e8b4e7fc17e64d6a7197a7ffb60324d2c0f265701d05829a8c5336af89c889c2e384a5052572bc0366cc4b3f92f636866a4a0ba2bb4e41041b08b68d12286dc13911d2ed884c9befd5c8c24c76df134c28b0aefdbe99986f8071a010630bccc416981aba14c7171b16bdf4baa4b93303585488bca03c33f1fe37cec4ed5e7db1cd7835346c12ffd18a84c2146237de06cdcdc199f64778ebcd2534020bf1c675f868d73e0457b31e2ec063f3fb0a85487dd6f5fb2fd7689e767eed5744420be03cd8cc05d25fc961271803032f9c728593fcde6332a54317018b5a471ad5e0677b35288e62d90ee373d126c2e93a29f3d340ac41f68f323ae6e2f80e81b27bcb68aada9e470c4716f437ef848369151d5cf6d460e9a38c27532573379c0dfc3517c428f52d4c94ae18c3bc42254650002d2c6493ba240c163a89265f3d0fe4f44eb282f3933c701949a201f1c217b46b28d8f5f9340f6559debd6f3a3d304a6926664c1c7740d4ebe62c7e155015dcba450bd716f65abdc3fadd02458bd856f5b550c362b9c58c56695bf06b51864573ab2e5ad8b6b8d7e28755e416315ae8b650d7ea1a16d32d68b4e06db55c8b362c9c5bd868f5b6c55f0b342ca25b55475d0368f1440ef9b59d3bde22f31d0369abd85d6897557dec455c4cc6a0f8559e314a7dd11cc36957b5cb6c70c7015b75b281a61ea2d4062f8d92666d82865b3a2cbf715deb6b0cd46144d7a1ffad2adf582b639a0c6ab5f23da3b046c3335cbed52e8d6b32de6aa03d6be437b4d3509f63115927af415d07ff1a85606d26c3d91b16695c36eb171bc86dc4df0d3dbdaa93b17e8d9977d0a5959b8c626fd8908db0ce78dfdc349ff6e9ba2abdbc22ab74781919c3ce111c1ef12dfe652bec7b42cb849dc1fa7340d3d0f77f6d6337f7df82cc9804a31b7468715d4016c709787d4f16e4065c7fdb19eaa279bfa83073765a6739bf1351e54f40e22a2ed8f7640d0d477fa262f489c1ae543fa3dad1213ec7a51a841cd666717e315c756d879077f10f392723212f29cee423df9a0c0bc3faca117b65bf562bac05247f0d95d89e1da5722ffc705194fa79afadfc08b0004faca5e3497d63ae05195f38e2262756700962671bde531c050685e24b445c7a0a995f26d17990d010f188d9b926e1d70e778b0f1e1411ccbe087cbf73c6a8274169ba76a8ed86ea20f28f3d7f27e94f2ec26f5cc5086c13f48d54e9f2bb5f0e7aac40cdc85e5c5522d0d07c8f135a0d67d9ef80b87cb7c8ef882c1dfd379e4b1ca17ff286936d98fb4fcbfd43a428c3b888510f14cef3f8a1228446e62f3ebfbf801a18e91203712601f84ebdd7b4c8d53ee143988c3ba2e7cf07f0de2e122141d06a40c9bdaea3c5d667edada6624e0edd34b520922ba36ff7db796b15cd379c03b7eb0cb5923ea410a9d47b0e2f223fa4fbd6e450354e7f2504f4df5cf4e1ac89b8eb197ca51d44e6c78fe0d066e627ec8ba4549b6f0a72cd04ebbfe59cf1eebb1e294fc75bedce8f02c3c5ce6769e661f1af1366453ffaea09e3e2c3dfb8dcfbb9def19990f05124a4d3bd87cfa9959ca9249122ee17e94c077ba424750a2a93e1fbaeada94959aab5b77616f436a9c6f788db4ad2b58c1a6d0e684530461ea6ec69e43b661f939b7b3cb02792844409aee219971f726fc7e7d87c8991a18a7adac404bb843238f551c28e41c55f69e772ac4eb54eb212708e75e70f176c0addba40d31567ed46f177816bc26d2282a95b7ef80148e8d3b689cc47ce52f679a1435fca2503b85ef17607876b7f92923f06f74b9908c0cc0730b031422c631b3e7a26ad511bbebfe0a908d334737b839333df9933a4b779edcf934dc68fd7432a623579ebe5cd3188f5d1aab6bf1ce093dd198020139c92dba6a4850e0596c1f317978aa487884803257c71fb8e8bbfcb2566fc88572d71082992bff27a380da0e51382d7f438f4070dd56fa239e89f7e4888d5c9ed7685e2290dcdf23aa6a8c02fde2cd94903d347eb7033a77246c998f064b19f922b17855903e69d553d04a0f6713a78de139d6d1ceb4694ce727a5c27ea06a3249a2e2a559a6da78357142b20e0089356cc31a9083ae55380fa68403147bd78ece1123224cc9f5dbfa4b07e09f8bd21a114249896b4df49dae845a4cb3cbecef597936000d8be25cd19e5b88bef4a557c398606e21965771450f4a5aa10597598a6fd4bf570190c308bc353d738c6f7891c4f12ca7b93a81fbc00505211291fffb4fef73b01f66eaac5a1bd1756c0818ea8abdee109d333e504cfa007d240142d0039dc1dfde81437d3e7add96ce88716644aaa3e275acd46d28fd9dc73f345f6b3f66ab40446a8c05e06ddd0845d07bc27f6b7cad87d00408eae632c5022bc42de5f160def1dc433bb5fe55d7b31e80aaa249219f58926c5970b2ab480bb6f8faf43ca4d833d97708dd997e0897c4ffe2efcb8f305b23c2015a9f70502c42bc0e5242403c3c90272dba7f8fd2538604a5e6221148eba4566f9af324ef844bee428366f32b279beabe6d0ab7e9c63c7dfc2e59e9281e8305eb71f0391a8aab77a1fb73db179e58d100ad2b09be65dddae58f344dca000f71200e27b63e0e7f9563481aa3dd2143e80d118a5aca32c02782db66e6439c9cd38c4fba064de9bc0de147522bc701f2e00f04212ef34ed702e017b623e53f9e48fd659da91e073b3ae75d2861cb3b41a77770d3627fb83aa75a2e88907482fd8586f69c8acce86d35a3b515a06c59c3e1e16c5944bf4e1718d6261d46e2fec908b569dbee34e195b6d751e188d3c60822849889cde55ad4c92d74111e0ac2b65a50683789c797e0d99f3b8b9398b744d2cc17c366868104f1b9f9db742325431149ff2546b7a51514829021be68331d8dd47b31d3799476ea3020419016cdb2c37e6a0a96dd19bc7e99a554f2a2ca1227f5db47b7e749526c9d65fee40e3fa2d6c0a6311e014c430a0f3220de787861ea4478eae17993b2ed31ec8fdd1ca7884d399f2e31fc8c9fe12c6c38890fd6b190bfa1341e63dd6f167abe9986a0853e59c434b30c1582a5385524445e2d7beb7176add1b8ff3d1a26b790c03697bc14646b4429f71eb20ae4db9a8e6b2d5d05e33fdb4e71caa9d35f692746242f49b6ccf5d44df5fd1011df591a66e3b9ce474156ac66113d8332499af1a49a1bea188fed2952c70de93d1b7779edbcb4c5e51b5c3816a728bf0308616e637cef76fa6d26ce824c5930dcb0dc1782df32613e8c29dd89461967585c0073f204507682b1cfee09e7cd246e0259b780afbf3fb8e297b2df2898245b5ff37a816a148cb1c185a76798c4209ea1a6cb3bb71fedf267553e622a49767e724aa594ffe57652577ca2036b1429cc9e7a528185d4302b9dd17fb3ef69c66a59620a9ead454d36ba99a88a8b94b1ed22a5677ae3fba95d37a179571f3d4ff693c1de9a1a36bba217ac15f026aca5ec0e28188eaf2cc243f89bb9591c44da6b52e9d773d17112fd1eb4b9df655206a6b87a074a0c55fdf375e319590e62e4969c93b0e254a792ee253a25c9dcff4d506ed53961066aaa304f2b18d2b4f965137a6f668f9e2914cb8b78f8590d852023ef7afb80f030d5659ea1613b2dbecb41277da0def3deba0051b1f5e71c93259b7dedb64d844c61cedd5a8c377739bcf408afc50546cab65551eb3d8615e6f1a500fa5bad569a772507b12a557abbfef016b4e869298811cee56683b7be466088f2050cfbed4cd922dc70c3753a04dc841acbf06d11da42057d57e45f57fc304edf0d22a84a55d982864e8c754e09c40aa1fc9e134d83b965702b8a48bd9075ee7108fe36a68d18034e3f5bf1997d1bf273880807d32fcd6487bac28315d286ed401814f921de50198bc57604ef4674175d442492f921d0630d261ab364cb8057aaae69a6b334aa85d99754146b59264b6cf27be1b87cf894fa7fec72f3d4be3dba0344647c0dcd4fad9a0dae4e20a12947f02c2f33c9ee5110e8a83a04871538980d9dca4b797ecdc32a735a53528123741455be5d05e27968fdfdd2cb8f81e75d2d902be426a9ce9e718a14bf41134e6e93b4e3e0ae32dd9e1bd8cc355dc6c58095a4e90d8b3169fb0ca5cf2c76dd4b0cc5bc19b54665370d63e51191cf0c7863d68ebbc1f22335fbd4247b004a43ff3e5e398e32b2b5b00fe91668af55a94639d340bb836564cc5503e18b7423fbeb9204554b9b41987bbcd82afff1362d666b76baaa3beebd58451579bfe256c66c5291132383fe50a489c041394b6fa2501b98b8d9ad5cfdc79a3a7172817c0be07f91154af6125638cdfa772e5390a4014952440686d30e572d1242c68d4fa8e1e4c381e1c461badaeb023523944d8d49a3599240faa8fa8462137b89c17a6117f2b3a9114421b9a1df747148b22681bbe9617c0a6647584499be813f8474cb31fbcdca8572c269770c1fb721ed75c3be1d0bf36bccc99d533b007ba7f80ea2035f5c5587f28bc08da9185a7e80d62ae65e90440ea2df604b2fd2b747feb45eee25eeedff5ff7228f4823e108e7506d4b0b8a864065686a2fda4f6b056480ad750c41e436abef1444eb1201061109633e14a99f081d0df7ae3ed84a69f8ff8095191e9f35e7a936588e3bb6e518b1c8dd5520ad87c6662381c920a44b1368709cc922e0763574ad0f8a5e106b4ddf2cf90331013318ce0698922771336c3e778b6f92f8298132ed5519b82bc9354544ccc3d8413997b4e641973c296e87ace7f9d26cd58a13461fe902626f4972106d7c1d4b87e6d33ef76f8a840572bd0762a0273f4beb07e74e48e481c7d61f3c6c54e758dab93d8525966583625153c95e472d537b64b9a4f532a830b43043700aaa39c8a7f6e54bb1f3185200f12e9e24e31a827493a4bd3e44849844d0a617b77304829c986729ec4b6c0b0fd58e2703e6fe4d990328d6c30f0ca073a0c8da671939601005ce50221ba2c4a5375e525649a12d86d8d6b67dd4dae83d82f2d4e519410a4b7285480feb5919d995fe3bd95752841aad49190b4d809316bc0b658fc75b9979931c9eae19279e5eb6fdfca417fb9a9f6ea5efe4ef1a370e67c68f2e98a3695be1d099f8731f5aa5f5a14b534368a4c2b4c7b5b6b542709b4becfcafbb8e73e6ce0f7e61edaeed2dd28736ebedf03e8132c3cb8f3c917e0f95cb08c28b3c93fa4e1a468a4e967e8058ed173fff9bc1135503c50e7f6aa0b6a80cf1941a4bb1216db06d8a5d9387c8451f889420a5b9d78485512e496d262e2c170c11a5fb88abfe294daae3615c6234a3b443ce6b7ccf98abe848e7cde138095329f9bf2f591a577b1954dd07d5a278048dc3eb1a1ede406bb26b7b8def94b67fa1e91a49291c11225936b163cb38a1b24b1b2504ae35ed4afd2010d96493f0a2e8c791a596fad4dba977ade6be75e6b32d8592363b0936cd8f9e47c9e3a6addcfa17fce0df7b885d27a64dfd6d8b2ab779470afb259403799c9e50a4e2024d09b92b43ce18776002c5799925932a561ea3512179400436170d10ef6866a5f2cc22b97c81cb495ee77379ab21e4c2c4b5d150fe7c5327dd6bb1ddb9275bd95cbfbd760462a798f00a2787c4366d2942fa8c2a779441dfa3a40387e1b5831698a9b4148380d157dc25f9186455146cd767dbbf4b858576b03dae235e5e9bd54039e34f55a7e26c60b1ce8a51b4de9c0d82fc766a2d032de07011ea0732a90431bac4dd5abed3e11979e3ec6614d12041bdfbcbe16e01f370e9e2c3887385e0ea7f50cbc3cf6e4f2dad01c243cb7bc6267e100b6c01ab62b2f0f0367287fee581ccde8adf52ef81fa2a5eadebbdbc21888550bbbf25b110b3e8f17720570f2421e5ccb58b3c687f050a20eb9f853c9d23bc9e2a2c6a79994de238040d1dc7a0f266158d08a800eacef02346932bc301f712801f068d24a095192310014fb0d1723eff46c802169607eb100908fc48247546758569e9f109b1ef79c5c4a72cce6c4e8c841a88e3b278426c307c76872285f3a058df5271786c874c2afb1b2f8b1fc73bf7d72d1b341c6585f8f9fade1b6e5d6bdf442ae84a7de9d14c82a49bcaa16aa217dd2a1b625812c352cc0ad60a958382702c2f6903eba36872d22582cffec8d4885a1f7ea2a8c21083effbad3cf83d14b75e746c67a69c74fbe61d8c6be7e5455a24f92c671b98117011c1ac04dd9afb756cf440606a1ac349509f3bdc171f51fd526b06fa21d41a74176fc92029899cbdd311876cb419644facd1d5765fe24e06926bf1c2a3c5549383c287d49bb9340eafd09642634eef18504e04ddf0ccf62b06bfc0455f1c52e2978cbc105507d43c5d391fd6e60e243005886e9082a488c80f09564067f9329d546ce0b47435484e53bfb8a3010bdd463c8d4901bee7d2d21222f618e5714580eacbffe81fbef2739c0713a880e8ba7111650da432a158a6ce78f77644c1ecba2cf34915f50ce62d35dbc9103e0aede0442700e43935d1732f89e9816ddf920a10589d0502ff690d3e25663d2e84f49ed758909865c01fc44c568d0b8bba6e1f9bf59e56a146f1dcdf4e4d458e841d5836a6a57c2ae2e04f2f195093c09372dadf73ec1ef940daa4603f770d4ac65338e0f90cd03d758184879c4d17767de5108b0d4f22db99048f10f46f0d321284058a158a716c077093ca5215b380644d1d922e1145a7dddf716015dfd7499a381be17f4ab2ab9fae43d5db30973aaafcc5223883940d0d3b0a7833903c90904293c4b7b88c7e6a8fd734f5428f0a29c4648c418a6e0357f2ee9c883daa3135e28eca0a75e06b18b51f8081c452114027f1b64006c59047e96c200505405f048f82d108130e593f0190a0241d0178123e0b64200c7a9f2fb40a87ccf1755ebcbb25c509d595394aaae116e3932d53b538c88877f023f9863bf09f61898f179bc670cc5efec43c1f319c1ec5d8d737aac1a2286c1787242140145936f5397db79dc31f8626dfedff3101993725363c3246bbb538d2c454bd0a25cdb69cffb77f6130391dc204e6d7f6fd2bd7aaf37f649bcb48f6ebfb5533becf4bef2e5e4530a49a088f88fb1581d153fb0200621229d9f3b6f87b6d007c589f3e4b8241b5549fdeca443fbf6fdb5f3ca34f45abf8368f47e269ce28e1091d392f91a755e647abcedaf931fc270206837028b605727b0649f35f92ff79edfef7f31971628892ded4412ffe68702577d8c0a008cca2b21dbbdf19ab264a423fe5105c80880bfefb1b04635a45ceed05040a342edb74ab7298c817ec3a69fce4c638ef407b43a4c022839aa1542ef34c57aaa6f86ed755e9199adc08ec0cca900b9f9055148b23d931eb70a9594e72389e1e639be4641befb49b6283b53a6fa2b48a27bbc90dce3cb532319a6fbfbb9c132e1ed0e52ebd1d627472098d895c0fa10cebf8d7f3a3911e0e5def01884ceed6d2bd854ab07808e83942d3b37b0feeaef0f36f0a87abde0620696634cbc1466917b0d2ed67e70bfe1e5e0512cfcb27c80e8d7537cda2a9d93649fa61e2fc705df0b6ad3f520bd8faa12140f6b52398b8b0c503f11a6eda3977e60cbcbb8fa55b389668d5f6e258d8123608a591d9cd52dc24a7f7f8debf662dfe958de04526bd4a9c8c37b8c44b1b7ca7bbfff6357afdf6edf047f13988dbc4cb4641bb9003658e1c763c8fd206b96821d1281d2fee0be074c3b4b56a48850e09a8eb9c165631d805d85f6d238b847a676428dc9b04b3b742021d7dd890972be0a32abbc913558a4f417fbfcfb396dd189dde5623fecf9af4dda686518cbd2db55081fe335ad8081db398c83421cdcf230ffd96721e7d8d921092d617cac5a8bf4dc3380c0d83ae6f739318fe3936f4f021b45bf1a112c9167a48a04079b8422ab4e70bece405eed0cc0626fc4bb1e5a1cfedd31c74abfc41b64ec5b6a9419a002fd88959e72a605ed59206ae936b79ec0a9743f981e128e05f709a83521d048c3fc2fd7f9607042476c06ef5fabc2332c583f68de3c4bd884da90996ff53012dbd7e66ed4ae4ca24c7e5461b4221fc0e77752678ee914ec852658452bac7c7320bcd5c11f32b09bdcfa49f714cacb9a2076eaed96c46b1b95806c65e154516a08832d769fea12ed0504340d1f8799d77757b00f3a568fc137fd06346bde0d06ae1f50856b6c0d79c1ae930ae85c9b9ce4d3d83f6bed66187a6a6703346b27bfd6bbcb0daa3801ea1cec5af7b85a76c7ba94a3752ff3d6083e5f4ced826068453092c869d74847ed76ff96f6b8258b2f752d1041431af1d6847f51ad9911ced22d2c5ba38aa970f63c7bc28aa647caacf1c0db3a612a35d5fa9b74efc917b9cd8d727ecda576f0fcd0f92fe45e0be1fbcdeebf68f460d09511647b6448a2a791fe7dd2a392defcb3d7e461f68b0b42ad999d645549e2411ffba6f120fbac7af9c24e72d818e96a8884a75b72eff36d0e081ae6b030de0c3037d1fa22e8a99b29616cc7924b0319346d756f3ce9eb78f62d9fb0a6319845546cff6f395d16e19e0f370241eabb1cc453170fdeafbe019f0130e28814890900510e15cc9d3bf124b28bd4eb0018a8aad49acc320cf08d58f7d32f486ca56ffaa2c83b4b394cd1d5d9e39cb303ea2de75b2a3f5c7e3261a345f2a3919d2ebb0e1a873e9a76d568bcf8eee7649b5973acf71bfea9e1be04c6e36f387bdbcfb65e5efe2d1a73c70e79c9569724cc3fcbd7ced46ca039b2140a46307f86a172b558eac56da7922d72378db41c14ba8b0d02f70c436c623a01828d724342d000c5d6dc9e70f40013035e4d1c9a5559ef39bea42c5cdc001c6e735390bb9370ec05e99fd364b6b5068be035e66edbaa08b38db961fa35dbd2ab754f1f8dae74c8d07cd36520447eb6d52e78981a22dde389761af78e72d7bfa7ede68cc5cd4f175b5b6817119e9db4c71f2d4298bcd5223f37d85d72e5dedd8466ce5c0679e85ec930bc8da509be3654062107f0dbd5789fed93a1e2ff2398ad48317786135b7b10d3b8081bf62b3bf4e26f338bc7a38b8727e083d4ab3839bf8427135efd0d82895bbc9f9e5397b117beabcbdd403fc0c9f13006e2a699819352b73a9627ece9df07df6b4e93e8f8a3bb9ed5baff4915f9987dacf7a409549f77ba0f8e58b5354921994b0bf061a32ed41e3dfcf4d534caac4356eccae07c98a338af9245ae7e1addd5dd6c0c534431875f09cb334c344966eb19066d6b150b8198f40a6d66afe827fcf8cef3f3c3b2f3a31c992e11fc1fab3f4d802e4071ff7f1dda64cf41867347a4d25d98fd5557a34bfd07b77efd1796d92ffbf28bcdfbd3b8ebb38ae393879a8c44d60b8de1095c7462fdf67077bacc80117e78ad2c4cc86081f24fcfd1238d23d1d018e194e50f287ed4bcbc51aa836cff51729b9a019fba6ebdf979dfb7656ac33a5ebf12f9524af9d68ee00f30a1500ab688edcf2e495afaf7504a8e340e5bd8f9de33878933691f04c72feced32bbe92e301d7550b2217708cffbbe632094beb5a9bf23cfdbf5aff71d9d8556ecfefbd326ded2d331e1ad67f25f966e604c89445dd307500817c9c5f9d5fab86d44fa7ed2737c43d3782e759da40ad9e8418cbcfe50cf36ce4de3e479a4ac5e23c690b73b69f0d27c5983ba79f37d4d97ac3dcca5ed0dfcf65f11b6a7862decce17ed67689dda38a4df71563a9329991b1db0887b720a30f28a74ece4e1a96ccac07988f462854e67f9380c242ef09a8efe95a6be4c02706f8a767765b67a7bad4e8bb479482e163264db6521dbaf70ed6bff9820e3c1f850a06e9b37b2eb3ef95956ca3677c0c84ff827c61cd492197eb3d2e0f8910ffc73639e9fcc2978aacdbf453d307f5788445cd48e339a0bcd69e4693bbb078598b3370fc9a99ebcf8217dcbaf1e6df993c58d2450c4747bc637db8d7d6fda1a3beccc7b28ebc28e5638da8f94a997f6aae02aee6953dac94fe83a89800394ca57f00c68c63dadfc0476428cd7ae79ae796f362a21dacbeafe232d827ea9b47b8d88cb18f9ce661148c2dcb03e7aa80730bbf4b12c9b38e77db696593c1b9916ef633bd1bf164a9e70353d5d73bf6d4ba405b24700917aaa4076f11d10e9ef21268077620b0c9fd4075feb4d4c298bd85913b18d854e909371b241a2b4cb7b6bade9fb7fbc8dcb67f631955134197d30f13b7a8fae12b7307426f55ffe6c477d4bf90aa352da52402608ad4e91f14d414b0fda2cb9567643c8f6994a6a0d1704e7bbb38e9007cb4c52748e7b575960bd572b1cd338a900d8dc2f4b95a2029c99579767e666e17b98f2ae3e438f99c46a420404039b0d0cc2f151fd5359a1ce6290169a330b9f5c73b7fc705ec9831fe2b949869b74ec5e83adc3101a7a6886a72fe89a748eee48d4f270dd00f1e982fbe3da37c00062b8bccfef710dc6a81764d66f5d05906166d02da05b041e7fd4e890bd5fb63d717f5e03f6f8271f8e32fa46e753c073c878a0fc3d2041f4b1233e3f077e6e22b99265becd40641939794df96b46c6c78810fc45949b6054245f53ca2f71e2dc14f97b32007710852f07930f0b2cd3403c85cfb83e58e073719f05728cedd3bb2b3d194f96d3f0bdaac5fc67f3d782be3c84c7fba177c6ca61f307addeaf3931510fc45d31b9504ecb6baa7c2dcfe637eebd6d6203863f3fe95d91a5010dae7950ff0b6c14675dd77f8e2bd9b37f727af36be013e00dfcec11044c80db44288f783507e69878ce26e0a9c6e29ad5c8e0a181ee9ed023824f12035680596bb80758461dd835597f05605ef5756d2edfb8f1ede05351ffbc2752e1f3b016ad321a362abcd28e251fcbb663d246d1402f1e10990faf604733ddf1ecae3a66649f9dd3a1b9ffbd132d4bb1af11ccc174106ba9df3dff558c03489ec2446776e2e52190492e3677fbc865a4dec930d5a14d185ab7bc0284581a4b32fae82e1b384cce3317d7e8409fcc7201be49c10488e2288694d029070641f57a0f8142b559a5622366c4f91f8f41f315b905711d18a3fb5b310107d5d000dcd57a641e325a7aaa283301becbaee001fd693f2626aed0ddd517d39048fc4abb656841ed2e669be012e160271bb44479cd8dfc83ab08427e845060c849ad94db01bd5156a8de42c76f236cf1920e56b8f7798c61d1fef9a4588147b4dad0d3ddff7afc5bb02f4157ca808cfff53b0dd86a760db56cac048ee18e3b6d0887aec975dcf9c1aed39ba265ed82ae74101403e46784fc96f9a7af9444a96897f7a73e2d8718abfd497ec01215e841d0055022443f0d9ad14a05e097e12380a508e89c760496aa059c03ef8104419aa3f0292f801b06e1fe6c81832d45054316c108901d5428463b35885f8a87009726a1b3da1078ea367016ac071a0c6b8ec45154b369f48538087e65089ea88a4147eed153813ae0dca8722812429f1ac56f4503e04bf3d041650468761b3a8b56ab3bec12c0960d73d3631b9cb6c664d30b1b886b0d58535a0d22d42a2890e4319a7e519017c1c320f662000729470184aac04f835c000b8bd09f0518a0141500be123e0562210c7c927e0640a012f420f00ab85408c571e0097a9900c0cba003402be2d02329c68025ea6107c2780a84746a541044e419b9839fe63a538285e0e1ce0686965d0606c5e0fa05f9317632c0ec2a7f75871c9b7ff2569e640323df9a8af16a107e6382da6bfc5e59533c6f14cf03a726b0ff07358e2aa814a3fc686a78aef0fcaed790115fa9eb3264d024e82abd80d0f7a74acc55c46a8cdb3c593cf95fd08a08b6a659bf02883543418f71d2607bae5fed5207952f5efb13ee73cf597cb8c58306bb16d4c7f59d25c23ced72a6bd04b0ed87e2534233e2aaacdb04e9c0c77ff20235d952b1d9e69c8c7abbcad49ee595ead1070fbc4a5938bc1bb1b4ed431185dcd7b92dfb8d04d4fd0ebfc0aff2f17faee4309abdd8b1e6f2a995208112a5ba83d4fda2cd1491bc9e199bdca4223522bb30dbe198844c06cac52414a4b7f46c8bb4e74c9d4fc90483b53c348ffcf9ed89ff800ac23b2957a711031638dd9b21751184fb3b7c3924499647a200cf88888c0ecda7d14584a7eb5dbc02d64bcfc80eaa3d826c087a67e6c4885939f74f23cd37808172a3ae9b79134c040da756d6da5372617d339c8b5fcece04e71cd32cf605d7cb84fd98a3f5e10c6c844207c88f2ed27e838d0d243af92d9e7aae63909863d5493ce0e0ef45560a0eb9ae0243cbc74da16d171fdd1bee46a23f07c300cb726c60dfc23e271b623f185f69049fcd4921e50defe37c4ca777bccc8174fe80797015468743fa65c57f7937ed54214694d69028287e7c7552e976a23bd5c7c46f7f52d1b3473333e136048abd60f26d47fb65d7ed16814a7eeec98e44274b5229637ab96295fe0a579da178f26631d94cb012e0e1fa37facc309a51be243292a89d42412680d2329ec4b901747be18fbbb520f9a4f6e6c181881ddc5bd3f773658c9a160475b9b520a8cc5fc6c470c55e364bfe6263a07d44c8a7ed0a045456992116ba411c0caca952377d9b58b27d6758c597cc89ee5835f0848af387dbc8de13765e2dadce1fc03fec394a6d5b747e8040e08010ecb31ca4db31c7d985e7d054823549a65cee90d3d9afd64ff61b97eb7c079fc453a55c4d97379bc2bea3b92c6496a265b012a3d3f35ab0fb09ba21d3422896065612374eaa805ccc417c6c2f8673b9c33c8b5717b042d9e0db14b067ca06c4ad2f42c00ca7ee9faf87c7b6ec446f8243a85f218f4fbf77410c8d741d3b0463046684fb8e1af3991fa593d1693ac60d1ad5ab4e6b0982a20abb6796f9acd62ddc323d76d24f03bd37cec28fbda6430494361afd74eb3dac0c9bb227509b51b0cd5e4a4303844c641e091976e1bdf707114ecfcf919b0688038a73a1cfa39c050a4a4fe8c1403fefde5d778714353f6dc412f727c54a2c4a9180944588883af17b55f6644e906f7c5de55da56464604c647175a2e28a290ce1b284090410b8f990650c1da1771adf39d831f2cede93121b745fcb95b8a20d428103ff73d7578cd646f65c869b86b44f0b2be734b387fcb464ba2c3fc7b59f8cb0eff2c6e92e05f6cf5dcb173df2c5084ee3ca5606abf07222b057178d722d3fbe2e4f20e277b6f9fb3b4de253680b48adb05a8bde23242d1270b66989e17f365d2d3cbf7c22a1b11b52d023f1ea4119fb2aeefebe5bf7b7d949e8abd0e57048dee8979fa8f9a923689f5399e2691e91dfda84737a3957358218f174566e5a07857b28656c36f624bf23d917ecdb60b68fa859d0b0fcaf511b0deb591e137131542ccb16436dbbf1a3aacd7008e7237e8d58f9d026932331668169d0ddf7ab3a9c8d73c1fd305e7513bc7f12f2182f9b58bfdc36a56c6a6679f3ad8875b493b2c5bec3aa380788a6d35c4ce754139e74f2627efcba8b838ac86085f3ef65b12df9145656a71bef88ecca6ee97a02b79e2691e0e9036be9d6a3b10441186b426bd7338ce79e806733087a7b8f37e22bfb3247ba09399f6d696c85bea41b139e723c22f918fab56ac96075961f4b787ac1d0a70bee3736d882b95246ed29075db870b758b8e07e7e87e6c4852e3d9b45ead8383c59a08ac2851b403557dbc3b2237556e211e8f50affd7bd30c6203da89b9f022e4b267c037bbd31ca665aed9eb1ac7dc62769928695cf1556b17d16ed57ecf342bd483fff7f4e80db65973fda918844498c6fd469154941a01bb734d950e6b590129eb34626b0e3b2f6079ab3c41d6ce99f330d782e76499e23e6fdc18535eb0889759789ddd6b3a7af0a74a96a5fb37bd9a3c6c040ab2441f66a4d0ed1f14d1dedfc59af3f68d8fc3c98596a859033d7bd3c167e4313fb2d12dfbcc7067cd2308f02e73bbed98e412059b129f5a73fc6f8785c1708654789d09d28b46c747021d65f592833b9a7768bf3e2df0a397128f9f090b3011f5b5eedf548c04acca020192319d4c3f77d95bfd5f82ef1b2f96b37471c2fa0dc4a5a7c1cfa211e378e223b495d0f9cab91d85a2614bd1d6614dee8a37d496ab68538f788d73d28c9cc3cb1eed4a5b76b0f335c9fca8e68f37ea8d85783e7a935248f05bea224f1522797347a3ce77445a3434d5dde8e119f4fda400cbb37d91e6fd6bdbb6cbd441afaa21c1149b5fd04fedc83bcd6caf7b9421462761a29187c126ec80c68bf04de83339e9ab521fa28750d5bd8add669ba83d2fdec9a1e0cd0823f263e7fa25a3ae301731c4aa98bdea0d95bd4eae0e0630b73f315007b71ef4ef344d7ad62ff171abaaef55dfc82abf1d53f136cb859108cfab933036d3372c1e5b90d022737efe30c27f2e1c833fa655ee2ad5fa0cbfcf895e60dab807e3fcd3861b0467e3fb6f007658af778aa47a66a5b18ef77897989756c0c99461874aea86bce804951f47f86cc8e33da5f59f5565806f18066aff4ceeeccadb52e530849838132516863e7c44c6138f4f428cefd85952202805b7df9cff2fc7a9d502ffa304763b8ff578efc5ab580dc98b4b99fe5f090ec1c58983e340075253120916f10e6e496142b1f4d6627434094f714a40fcf3f8524de0ad21584b982bc3d74b3982e3c0647d59b471906934a7820f8e65a48214948b4b3f818b5af0b451b610cfac76ca0c2d301aa7eb92000a894793a057eb8020883764718075e0e2761cb025eb0b91f5387eb73c44c800038c182604cc096949dd392206804592ece1bf5ce6f195d83aeff758142cb7a8d19bccc43b4366ab5834638b1db7c2ba783db2722bc811b1ca4c61d0b14deb70fc48d8ab896aa50a18581f37c38dd83254d6510694daa145052c84b78a53020b2117168deaf9663b72d18e6adc5306662f1005a338e0a04020598bdf848894e1687f356fad082532d63e4fda3f5c796c836a1f2441b498767a52cae94b92207349714b4a7d3693e8b6f0bf7fab665db7ddb0fdab158c4141a7781c8a4c672f57838789925b812de7aee0f053ca88232ad582e98af92bac36f3943110cf07f96c288d3df98d8c515a29777ecc10c7aa2b976b2490df83365a5ddbf1994991e9ce856958325024411c9f7f78d02b50bfd9e73038af47bb1480d10c2729cea20cf4df1979f3535f3ba04f0b63c352d62230ee4e14c7032078026815295d3f8014b0bd366f2bbf5f91101fb2388f7217b072e05b41f270739d5bef78bb8a304265a9f32b153feb9dbf16be6046a15c917445ee7eb310b12b2871e156e0fc5d0c9c26b6e571caf9618b819e42c33a82b583fbb44c150ff333737b1439479f12b51352983688060b7c29cc260962432318a955ef92b2e811b2e89f6e75f20e1708b2022414f8aa5995ea3a15b13c25c6d4fe327aa2654b2798670ea8752c07fb5a47c6592fc2bf5a9a52487afcf7a2051d3bd53ff175527a0015553335aca6c03c55c177d9f94c88dbcfd3efee47bee84d36bb7c282354c7c0f84716084b9e754c3ebee02f4d027df4b08131311d05504f5c426d961a24e72e3b8bc0d717f6c3dd9a3991bfa53f4f2c448a18701cef19701eef285d252a85edbdb9b502b196ea77c5a95567de216097a34ceae75aef3c1360a84a8244381cdf0edfa73b0fc76958cbc2394c54c11417bf479dd86577dd4a8cf4bb52848bb9997263cca7bc9dd599ccee7d0aec1adfad55aae38cd38c5eb40dec8ae2518f48851129d3d7e38bd9d767b43158c59e3bdceec2fb327857ca6780227ff3937d393272989a76592999db2ac03af9261a0ae45b6627872a0e528b6ce6921c0e974678d446887821ae38a8798bcba3706348f6f0ab780b6c77f50f2dfb0ffdd2874a30b7a3ea6cfe38b75105bb34a7fbf39b482e9fb1eeeb700bd1a9316f6acdcd3ebaf6349460924e130856920974aa020d9c6295f11a6b1ed8dedfade8653233aebe4e2c0399aeef49169b6da154cc2471694a613ef60bf7cfbfd636dd1da0b5bb05b259715543710af6126a5242a6f7d4d7e324887a08578eaea5c8938cab7c5e3e4317122e7d08aade36614c01a1f5d36a54ba51abb90a433add9247384874e7d2e001d86c6600b85b2343b0f690e310b825873f91141921d9ca266afe4c63a244023150a57accce96947b3bcd3ac39125d4ee472e75bc831becc3c7c651aba627976598f72bb75834ab83ec878012c8355abe7ad876a2ef96c630fad84c96f710c1ae2f59613d3c52d38f054667c0d2a9259ba576ca828c9fd632178973386afb6e845c8a2e1e3194de0af1a16a4b04349c9d154a4ca39a3f8d8c4f138249e41d77179a99da09f9e4a73b64041ac16073472fdfa89d1ce7c15946595f0db3f9972484f290a9a91fdffbc3c114eeea4106dd91b89bb5f5f99d01323385ed83d1b5693733a5140b06d832977036e2d03721c7002425845bdff156c3f519d064e1df2873fe72a8375a50c6d5bf290249fa7a4dea6b840f0a6fd5a8536ab3238eea474bf74ced4771158a8c7ba1f32401cb8481bb0fe5d259a16abffea8f8ff1d15b0542122741c32088b7a705e96178daf28379ee9bc3df3ebf3e624962493f6750cf6e82009636c24f15cfdaa8620dbd945875664ce01688cbf318c2500003e9246495a6cbe91a0e0a41399b4d9d6c26509ace35442075ccf188d29dae494da195ae388e3a6c8bb29a1dba574a1130845468714d97f91b879ee28d2768960740bd49d43c94b0c002e93a52e3d07e0a447b26193ebffe2a10ebe0cd518d0221a2b118b3f6c170b0f185780880d7a2f324ae4e207539dbeb167b6b840281de93191ddc5d9afd9ea50838d8c3c64671047c4fad289d5b887889ab42e50731d16cdc1e630742bb263bffa6a56cd445766b26d1f7640f296a4bbac8404307cca0176f0a51f0d8983a0a7560f38095ae39b4f588d0de5ab01f419454c424064854ca8845cd36464300e277180bc74933ff8b15e0d4d47344e9dac182d686a1b4390bbb68b10ad57394f83cd480c4c50510e3c9038f56bd4d061e82b60681ee5fcf9a1c722a4e39c7c01d7ace184b9f2c38c8bfd5bd99682ffe893650c6c0f83178d0064a1bc2ee449e3ef2e71490b473eb80ec1efb95d5c3ccbf35fc755932528351aa6c50b38c9ae5eb58e8fa009b47be9279b5c3fd1bad68b95960841197d52ae062e0c4c865701f26f59ffb419571fc3c056cc86dc3607e4caf2406fd5154c064118a3482dca517d7dc6f6aca2acbeca999a3e5ad0df9cde74b1e9e728791ac3180d9fbe230c5ce73ebc309d457532e1d519a20b491f3c8282cfe2ca6765117c4c92de8c08ff9fd11abd2e5e1b186dcec0372c8ef3d1542a7cfc6a5344b15a56d13b06fbbcf2a8f9d416c98ddfe04d96a5d9f90d8c8e9e575d51b772302c41b3b16b9bc2ee9f198863f8f5ba4cd7603135dbc961cebfb34b473ed4a367666adf2b07e44ab1fcb10d4217441fbabea1eb428bc7045f6f1ea9e8aff9db94971de26ff960e4226aa964e21b8804d5536cdb05ba46acf8689183624aa0ef0465c2b963d1ee809379cbfd6a98831af3dd9d6629e3de56a084277f132b67c17717f385cda1566f9dd9a1daa4def780d35d5827dc0f6ac2639ab78f7f08a480cf18bef0e69e34ffe825884ea2a015fa5c5ad34d1f623f0822e9a15450cc367dd8078bd75b71002969a06734dbc47bf613a4c744006e8aa37e01eae1070041b5a119fc7e0d822e04660b21a16af8c077c59ec97d98f75350bcdbeaa548c3006da4ef08918ab26f16e1f8bb5bb88638a899514e0009573196ffbf510dd0981f02c61c569aafba7f025602aaaf5cbe2c517cef47a219feb00eb44119ba8b2df1109b655f1eeba3c4e84b80acbb2c7b5df040c303f311758e22928fa2ade189f1eb232d4940ac1361d17645ddee7fd893a1095d866e0d461201c08d3562b32ec556b2bbc2fb01db08c671fd1ff9a64d33d082889a0ad53af4d7ac0f02e01fc703a1baa7145e2e9123f903c5a185fe094233cf3bf18521960b11932b412bde418e556843bab311212ae173b6f0c1e11e2192d86b89ebe484df2f7c56215151f96afee4eef2eb1f225af644dc578821727cb4f28e19046c0a0d1be5c1bfa490fccb8ae8478d2bc424df6d34d6dc9ed8387d41702720df1c382c0d44bc3fd423cd4be54281e88a6da4192870c43c1f2eb7fa711fa4442a66543ac4f81e90483fc3b1bc5351c11557552732ebb7ef0f4022ac4d17ad720b3975029daf394684242fe4a03e94421608fecd0e51a0ecaa5d6e82e08485352503305ac470adc8bc90cae9820008abd270a8368871721f487a6c518603b7a5adf1d1111b2fb34196d35286003d19dd652f979e137d79ac4932d541ab2a0fc05855515bf0a132f6d5b1a3d2a21bdba1e6732c65f9d5304853839942e90184c5993db5c4a4a22a86cd323a89becb26a4a6de39b09ee77b798957db5a105c1212514d3470fe412d64979222d99c49e6114b1b7bbcf2a2531f5cded156292d56923e7e673d475040bdfc54c4b6b95bbeff75c686dc8f57d2cb7d496686e896635a38627e83c8de3abc2787f0b4e801ffbfbcf33628e816baed975bf2c60987ea3c6babc4c723c0f9c8cb91514deee9e6947246f573e4c7d773901e0ef79f91796abd65e0d5e732a3dff06a842fb4d2c9d8b8a7629190936c3fcf779fcf36f1451d55ca24194ce40fb5472cfb10cd51c69dd9a17dbb6ea4e1ed34f668e20ddb50a1142bfe01bba81df274a3855aaac96101f9ca0ddff95549483c6ff9abf6960f94b206c1caca4d548acd3f97588806bbf432f73147ea954bbd07f457292bca089de8040a0e69277e07e69a1cc9af124c1ec0318372cb8045ec7a52953c346eb8728acb1e2117f7c85401f322834281cfb982f24af2431b447f5f27ee579185f6e7c6e34579bb27d13f53b894f9fd9933ed8d1318bb06ccda1221af2236f9ef573e7ad68d6309f988a028ff863c275386c425812a24e18a80b07df91b9a316228a92e2da39a3e9f48213cadf61dc25647a16a2141a996a69d755cc458c321aba0c748f666112400d473d4c11617e70765e82832b0869b98528a33ef8ace312d96f3f4d25be8f2c1c66d07dbebfede4169174be0153cbfd9568eaac4f9ba065095786a87e5004f07fc71c085e2f5740698113dcef8f07738ebfed0dd736530d3931dccadcb8b772f68be37aac959a3ce9dff6180941f5ce55665c13324a037185720764f3737eb0030294b91ce519c05f3467e76f8164cb9dbd287e034b6b012f93816d221ad8f9cd68a03c2e3a8ca14bd40d79bdb1842e52e7cd094c7f329efe79e02981def22f01d1117b0650b0e04a2be79ff942c6bc751309fe40f7b7fbade6585f772c617e3c890c2ec07f980b16027a68b46c926bc8f205613c4f1acd35dc9158a4a6b136f745cda0901ea9624cfec022b8f034c55ce20a3b1a3badaefdd5e2602731221807a2ef05c68dfca3c88caeaeced8f973ea59828fc9b50b997d27caab83936ffac0de02e87b25b9e1133f12a90341c7df3917d21fa7ad18eb89f7b300c75f10fd712e6fb217bf36d3be4d8cab614ea644c026ec29e7f087a1e93e19bfd371fc035c519289a1004ba914541b5ff63d786680f7da09139a6397226c705bc6279239afba6c7f53a6416556abe8680eefddefe3795158054039e9c1095d23da86022bc49b07d2abfd97a94574d6626026768b21148068095d7669e8031e242a81582f8597aaf31325312bc2b8c975020743d0e22c9c47846e3c42d65d4bc26580d1ce392f629568d11d74456aa8609ddb3af0d9f72be147300a636c97b0aff027282e449361fb3c3d5f8f26978d09eaddcfd37327684eedda2970b8bc13608a547a473fefa09a2b242cfe106b75ce3c64e6c34cf1c6ca183c19e4fb92e146f50496a4764c443b8e7b2365b7a912454b50b02015d7244a0f66c5bbaa9a50377524a0b11e4a349f3720c2f4ad2e64a749d66aa9ba0eda7194e4bcd391ebc9977855fe2c9cdf41bc630180861a18f308727dcbd0d39b976d37a1dfdf904f77a6a40ed06dcd94738374389027d9018b1943c5b713325dc8b5de53e34db7cf819a55ea2fa52b11b05b2f06f31084fc2a47a1f72d6098df6e66181ceb8d40135120f055587a63e793dc731c3439b83d9ad34d6c234c11b5e368983e17679ed558a5ea7a3ad33d5b9ebe300778ef8b8f578f6e30d7363c82cd9f03e1d780087c4c182d72e0319acec822f2de2a32f24733f57413f6d2e693c7de3ded77e48fed03176d03e7629c68662b9410a68580f98cd4c0ade2e5d113f8d72379e78ac6038525b81ef549b934f85e4714425e6990805ea4f011f7e62088d86b11de93ae990135dfda335ba4d6899d2cecc2c7cd8497f5226b3c59af0264c537de2ee237fdaa594788747be37d35c4755475ddb9647ceb63b2066cd4ffd3500d1c8e023e5a04220b3760b46439330f0f0f0f0f0f0f0f6f4337426a6b9f908494a454aa976679010b644a29c99492d81dbc0b9c99f87466e2d31546ea6e34e301030b400bd30a89305b754ea153cc4f17311a1a68000d2d6854c0c3c3c3c38bbc0c801a6220c214d28388d6a39e7fa625c4388441e5edce5e2284ea63058d011b39ba7880214c3a9430d9298b440b63214c21c78b914df249fe104218b465c813f91f15620cc21871e5d6434b9e902208e3440b19a91e545479a2102310264f59952647c8881a157284188030a5e777f438191b6b016084187f30968e74f988efb9a75363edc3c647c12d4b31fc6076b7083243e465059386161e1e5588d1077357fef6f47137b6f3c1246eb35ebf9237ddefa26b68c06fd898c0923d186de28afa0e1d3d18e5524823aa3a7f3a711ecc5f174b955267a972120f8697a4b4aca5548086062440e3430b1ced12c891000b2851438c3b986ad27c74ad38f91b362002e50a31ec60be0c7df524667bb5af83792dced6c4fa09da6e3a986e5baf64752ef5e139183ce54ccb19a24a29530e26a13e57b8a89e9519d6588b83f14a456cb56ec2292538184ef6d8c9d0918488a637e8337975ebd52f23c70d068ba6bba5847e25f3b4c1782a629b087a7ad5c26c3089f59c82129d3c8851d7b09af89d69d3fbfb5d0dc6d1f62762470e252d4d83316757528ea8f360123418f542e3924e6a44fcc81990e79e7592d8f0dd88194c9fafebc329b7951896c134e23e23f4d998fa6430bd560e39a29ab0a4d9180cf2246987284292490cc69ff9d4ad94264cbe6aac1962848131b7d9ae20536c3430587a3cfe09791771fc4272a23de2880929cfc70bac96e87069d927e98241e9d349674cdc0575e242a272ac3d2f919152bd05decf52e447e9f4c1d58229e72454dae4f24ad5c982c94212972fe88d05632491b3d1174a4551b942fa4b5e9f1a1d4f3c620593aafcdb1dea296787ab7067cb13dbd46a6255a86052e6de267ddd4444740c31a660c48e14d192429784670d0f69267f4761d7125365924b5ff250307b2425df15c2ab3e9e438c2798cebc4dc6e52427182d8f7c87f2fc155d9b9078710fa1cc4c2618c4b6044942924b583ca565c7d2217fca9460b6317defb0d57f214930f68dca496adb87f00e09c6f8ddf3aaba54b61ec1d319b135ce74881ac1b8af27c1be6e2c9f72885104e34a34a14f45869e1e11c1f41971d72dd4ef538660505921e5e715e517662198aeb346eaa80ad2471b0483e855f79c4a6dafac4030999950b9206db573f20786f7efec4e7af744f6d00d317c9068a6965ddd0373b6c41c939397fb82789007af3e53a24f9c24edc024277c56ba206f92b6bbd8a26f241d982aabd675f47091d29203c385e7eb087bed220eec0992b642527cd9788353fc38ba446f820ef2183630ba6e8b6e0fdb298aceb521460d887f49f4d7280f950662d0c02ce6e13cae598ae4a1b121c60c8c5e3aa5a81246eeb8be8618323069cefde76f856889c5ba9f53d8cfb8d2aec1c254276ef73aebe597e91546fdb4edca31b57923572073ca9369bf4a2b0ce7a3d4bdc8c6fdafac30dba7baec905ff2bd5d85c1e444e5e6fcc83cb9c69aab1960a8a2ce761792852429684f2accf196653997fa4d1f15261d523855d7317e3a790a5418cd4ea2744c5863ad057e820fbe1b3672743185b13b6591f11c23966534b4a0d1821c5ea0c07451011a5ab4e0867f71011a5ad0f02fb8680ed0d082c69db5c02340430b1a76c39d8bf3850d2df3a251f05186c3bd68418e2c85414f7a0f8b2426297b5218d56cd4a8f4f1f6b98fc26c71d2cf88c5eed35714c6d1e965fdc36fe49ba130cfbc8f288f7b8b2c0185617f3b4be7fe2cefdf270c2e4946d0155a3ea25d066078c2a04694e5ed59d7fabf138614f22c56a8958afbd4d80d745181b3829c30870d911e72e6dfb29cb809e39c271d99a142de4713c60a7af1223444ae8533611049c5fbe69e4bae0f26cc79c5de7b74ec10a2a55cc214b45c4d9f92aa22644b98d46595136182ead866f2004625d491cfcfbb1682caa2008312e6a0ad2797ee5b93e1f8c8f3008c49186553c4055d59e46449560086244c1529ec8e55d808ebdcb8617608302261aaca9ef8b521b2eef187106040c21ce36e73278b47109700c6234c6d415f0e42bba9578405301c61d8b7aa2ecfb7b0145463edc373d8e8e24e05301a81d0191e3e6444790306238c713f62d1e43efdeb35d63e10522f602cc2544ae26e9b84a4425a6aacdd5084a954764cf86c3fe67101231126b566592e665c46b4cb4c000311066d912da851fe41a4d3210c7f61db43caa5b9681bc29ce467e498a51121a51026e5392e9f449810061d134a790ae141982508f5385721447a2c087329ebef2f5526e60f8439ce6ea464656af2640161b69446be8d8a21e4db3f987d62593c6bedec52fac164f7df69fb631f4c29ee6e65adff50b3f1c16049eb6666df8331458ed029b2249f5735d672b4e0468eb5ced10bf0e223c905400c30f460bcb4f1faa542ce53aac6da471d0d0d34600b30f2600a6982a4b82e5539b45c808107f3e81e93b318dec1a4646858588a4e96658db5b230ec608e26579b3ee26bfe5263ed830d07a30047af200130ea60103bc23f8556eef5c3737c617e18061dcca924a54fd2f75ba489e760d64939b722bf65cfa68f3b030c399844d8a9a0ff63df851e0783a58689a7541bfe4170308e507955fa6358f5fd06931033ea6bb47583f1d37376b8d5aff8691b0c1adace3e87f8b922369882fa4cf652daf4e49035183f2d98fb051d6f92d460887339fc7327b17f8d8b56810d143806baa8000d2d380dc6d02222d553f5ee99ae00030da60cfbf57af7703eca3318b7be26ee8752224c806106f359678b37eea9457b30ca60f2cad24946844f8da700830c067517ed83b4fe1ba53406e35ad871cbd7e3b29be50186188c5a5b37bbb67d9d3d6130a7883fda42ae99f6d100030ca6b3b00b914275ea60d6ad01c6174c9d5444af9b8100c30b86f43b97bffd9e7459140230ba60ead4157ac7cc264b8ad987a11c6070c16cdd162752f27a1bf9ecc3181030b6609049317a1e52d809920f3336c0d08229291d26ce8fc9979033fb30b5d2038c2c98f7e2f3558a8afee75830a8591ecb3d59bd3aba82f9564b7b5cefaaf3b582e9b7a3e413d23e29bd55c1f4c9b28856bb5890142a9854e764a53fbedbea3b05534d2c7d77aae2e7775230a9a06137d2ac24465214cc7d1a298d2c75d9520e0a062d93b297d095ad84fb0473cdbfa5abb658eed209c6d5b4504ae57cf6779a601a6d61ff45878ffa2513cc6992b07fff8ba054b40453ec0bd3d6ad3fd7394a30789add480bffd22d4a8239e8a860fb5fc94bad483089bb9f117942749b0fc6114c49d99a488bb011cc11840a2a87d1cfdeba08e6ad6c6a3f4b53438f4430682f11b211f3b22f3f028c21984bece28afc8a259df6f0281f8607430826ed4eb1743e136f97140473bea978d6ecd68d05046377f5886b7a7779f903c3488ab964a13a9f181d0e183e30d75d075d6e32ebb33d30a8b9a43d7479903d2e0fcc155ad41d988358499ae02af945d68131e4c73ebb49c2c4e57360743b717eee57a16aa3a1c58729da62cb60e0c03c16225cccc98c8ad40dcc1f44880525f46f5ad60626fd172d47dc9aeceed6c0702a3e8a4eb942be80410393b4483fc2d7e4251d9d81712b23a7bbd58fd41d18323005a97dff932a8ec9321646d3f2380f23a2bb25b0305df06afbbbecc9f4fb0ac39f4732f3d167b1a72b4c62a284dc5e893551d28286161690000d6d81005a6148fadada644c92159b5ab10b08801546133af5abd492d72cf00f1b393ef05620805598c2da6ee7d3a810376320005518e4e7be3ecd5f68130502488529ed2911adb40987aba09d8b0f1514c31b282801a0c294ee84ae4bcb97eb2fd2028f403985c9c427ff298b98c26057396e9696ecd1430194c2204566e6ff7bc8be202408801426f7bc6769a476d2e6e8628b1a450b0f8f519852f8879265f7a62ca6111e672887243dfc2e5f7c7461833b8ad0610643d075973fa67a8f9a40e828c32a2a3ce928a24e7e51e82003ee5f5e9d25954612133ac65072bb2f31cdd0b30b5c4287188ebb9611cf7f346ec1f9280b833945131efaf24608dae90083214938713af79c599a5f3086e917ada2aae7c4e4dbb9282fe8f082e15bc4bd54e42e186f74ce695ebac73fc905d3e4169973514af6f45174d0b105939294f522df4d9cc65a3098ce2945c991d4a0230ba634f12a4b92e4ce6663c114f428a56c47f44b7e35d6cc6868a0010ea0a10109d0f0f09041c7158c3a493c699153b357a264830225d9e8a2eca4a500083e0cd0610573a4ac9491a89d26710f0f5e0a80e003004ee8a8824175ca972e6fc99354d5584bbbe139fc861766aa800e2a18640979f398e421775330a470175b17b4e335cd8f0e29184777ac185636f3f9d482060768584002343aa260f41c6f25c5fd8ad599066868416303342c20011a1d502874864861fccc3f5d634d058e010f0f15f80db41b39bcc043c7138cdf5f51527f36d52d7e31812e18e0e1e1e18163071d4e309c502297969610c4af8e269844926a0f777e6a7eac4da18309e6642a590ea1b53721a9c6dadbf8e0251872a86441f95a12d26a724a30ce4fda14f14f27d54c82797420c1f82bea25071d9f4ec5fad071044350cf11092a4a90df8d604ed1a5478f96fbe6a4a308a6ce26259d8aa076f5c2367410c1e861c4e517216774ea5e740cc11442cea3152d76ca2d4bd02104934a95e6d564769c488d0e1d4130c7121533b2e59ce3b36573e80082b12ac6071ff57ac2439258213a7e608a9d8492d9fe8a7caad436b8f0f020f6611b880e1f18d447f47fc7fa5356730f0ce2a942a57c499bafc63c3047c822c67284a9b2c80ecc29fbe46025569e832e9fd0a103b3e7fc1232faa774e7e4c01cf793f3466a383084dcc93a25f5ff0df50d4ca9ca7476dc49133a6c60b29bd1f7afb14b538aa1a306660f22f9626db8458e7ea18306e6206b92a3ed857ee5ac858e1918420a7bd723c553493a6460d0f5c1f452ca1efb7d2c0cefb13be446fc8bc8c2c214b73d6ae7707e2987bcc27841ee5225a929617b579872aa3d15272e88e7a915e6d6cf9654e58ffb5cb3c21037437755ffa2e4945598ca3ebf8f885615a6cd946839e59c0f6aa258c82215a6cbbcb99c13ef0a59a0c274ebf6e154485b3e39a730c7ca4a4a23ec1b3958604c61f0109552ca1f254afea5308ff04ff18d70fe1eaab19611c88214a6109479ce3e7d7a71bf1b4116a330e58e7b1a4134925b4a8d355118c54f951eb57f2af13d01b2c1c586c270e2262d9bb4acd0528db58f0485215e4acac38ea8c6da65208b4f18546d3dcd495acff2d558bb40169e3065ae97764f1225bcacb1c614c8a21346fd9113ec52a6fd7d1865c1095359fc4fe2d69ddb6235d69c8bd37622c86213a65431d789fb6ec9ae1aab09e3ed44f5b62dd3fba61a6ba90b1ba78b2f361326bf8a1f275d5f5ca45a70234762c26041a50b2b571344446aacb5e0460eb2812c2e61fa9c3e2e2ad5d60879324b98455987b058c23ec4a2812c2a6108b2697fa6b273ccd696035950c22074ec7394093126ea933086850bd1ba6a24ae92306beaa591266143422261bcb738a2539daac41224cca2428c70df0f6a52e711a6ab18177cf257bec91106d331e4771aedf183dd0893f214e18410c16cd28c30e78f9dae5f21f5b96511e65329fb9cc9274f9e2ac238ee3da3edb7f2fc441862a7a0ec65e554658908c366cdac8dc9da499243982cce9ccd07194bdd19c2b0ef49cbe6c2e4d9ad1006d51ac22d564ce6a93c3c70b8172dc8714701107c0400085910c214a367e4d6764b8a21b40fbb2c0661bc783d31fa395996bc200c49de09f123b1cc4e0d8461ce65948e8a1ff40f0863a898dc172d79c59559fcc1fc1366accc52fe3c310b3f185fd2986f044bd9c9f7c1105b2f2595a4d3635e0f0f3164c107b3af873455d11e4c41c8d1f1e446bf4bab078369dddffd8fe855963c184eb52b5be8feed13c18361bbf3fa95f60ee6ca932d9cecb0371766610753aa121242aace33f70c1059d4c1d439e88837fbe5a9743a1826c6554ab24d5cead11c8c6f66a3abd255e4242407d39aa5aca7a7d42774e2605c0f7796173a7030ae99d9870bf274c4ce1b4c25cbb446abf55da5dd602c714b4145a9ba384b1b0c1bdb299dc50a1bcced3b22ffd55e94145d83b14ee48aa74feab35435183f452a593339c8b7d360cc095ff91192a48b241a4cf9447eca10e6198c6ddaaf636c9abf04cd608aee22eb352c9a50aa2a64510693ba1b212f7e4f0653ccb17062d26ca6c8c76036212df34b2589c17429a87e1ded15742585c190d3d6efa4ead494243098b33e77309bcf174cd9c4a28a27715e757bc190824a3255933f7ba574c1ec7f9def42902729cb5c30968e6f2642b21ecf780b86a81f2584b0ea13e3d582694dad72fcceaa77370b463951a5f379b29b5ab1601cd5599613a24d4af30aa6b0fd59478d6905934cf68f3b4a8ee79454c1b835794d7627557d122a98ceab3f2b9a369192640aa63d75bd5f4ac63d77523056866817f92267b68bc2b1c32585d1eba0603cad94ee53e8cc0bb227183e4e9e30fa932cf79813b4b2cf394284ad09c66d131e572a74d29d09269d3e2c89c6e5d32fc1b027df4dbd64cd1229c12446477f3ea1524c4b12cca9a76a5fb3c2642498365436cbda826b5716904216473075e990f354e794e36a239846082d22d4cbcd7f8a60d056ada0e324f5e7b03040430b1a75011a1690000d2ebc40c1166a4430afa7d8b6cfebaa1492c30607ee3e90c5108c3732d64dc7ee3295f5f01082498e65af74a3ab1e4e48c82208c68cd1d9a16a9ea51d0f0f0058210b2018eed273ec4bf331e12106b2f881219ad6aca4e2f4f42a3e30778970abafb6d037d758c3f1e1c517391cc771163d3077deceb58dce4ab68d1c669b050f4ce13f7f6d9b8b0ed9da813925fd6b5e39393e6f4ac84207a6246e23f3126543c63930e851973c6f527d4bd60b59e0c064f5a542b05c69a7a31b18b4424f87da883a216f210b1b98438e962bfa05a5b4493c90450dccdf9d45c4cef7d1b28d42163430880ba7d353d6f0ad9c8442163330c44b5de92da84f56a2608b1b5e98690bb2908131c3b5d4d743462ad5be102316a620d1935cb45426b65b2ec480854925c7d3f5ab6b4ac5f415860b2a26bab64711f95d61cacd4a4a08f1126df256182396f8925e49cd66b816831506959c4e091d4ebfa4508d3557c1163752a22ebe78d2858d2db640018e5e0189b10ab3255dd3adf5d5afcb3eec0f315461ba3c2b39ba92f2a7570b1a34b4a0a1050d2d68380a9a021e1e681f568718a930867c864ef19239f10dff40157cd8c8f171e3867f78d12858bb618018a8307f2775dac6235e7ec8294ca2d627a414e6bd448708314c618813d383e4b7fc214f928518a530a88dacc84ff13c7c0e298ceb4195cf8fdd859895e9284cfea984509d5fc4a5105198a49afe05a11e4e3ccf408c50985c4b948c999d94da9a82c21c44d0cad974fc42d0ca270cda542cff7896212fa29e30c514d33457b7c61a0bbee80f1c5be017313a71c8a6ad478f87306d08313861cc104965dc566aacbd9f0b000e626cc23cbaaccf36de1aeb802e2ae0e161ae88a10963eca7c8eecec494adc69a2f51c19503c4c88429eb7b4ae1930af3c13a25c4c084b13be7e87ac1930c317b78e4c0b105171e1e1f312e61d4f6bb0a8babae33046258c2786f229ef77fc66a8f5109b39a9a4e5ac3ccbc932861d0e72762446848b10b8e2d100bdc930d0a4cc210627f98999af02177bab0b1c547310ec4908461562b89bc7d593ad901312261300db38ed725499bb68504562161160f13df7212de1344ec1e508256805a0e1c5b70413a10e311a6bc2345655bc8b11c2a00f010c311c61f75df31ae5de72a1f311a6150dfeb104ae9deab1703311861fe523e267f2b4a387b11a6ee7c29fdc65c6dcd0f1c5b281b6228c2a49f133f8450d7d93e0163b06b542449d1830c311823a41c429a2d7d1f2936920d1961309d460e22d7c608e1078e2dccc820030ce6141d11f4b94ef81a71f105938c116df11452e507820c2f18fbeed674f67f4f3b5d156474c138f21e724bbbc3f7cc05639cf7288b2d5241c6164c414372f658bb5acb6ac1706739548a3769cb436464c1b43d49697dcfb7a17a1958308f34ede929ea46907105e39c1c5da645a78ecd56307c96be28afff6cc184b6c8d1393290041955c827b5d5cdfc766190410563ffc80e1d65259ca59ce046a3c06f988c2998d74cf252302421dac3bccf838a7714cc637fb1f6c2733e8f0d20030a86744a6a990433e1697f8239ccc5eb15a1ca3b742798723aa19d3dcb92ce5213cc7d715c46a911b1549860b48ab5adeb4b1eb46709c6ff5db7121f3c5ebc4a30e7d332d5ac78398ff20b2f92606ecf2d39c6073569511948309e8e246549e49bbf1a20e308a68b37799b2ef2846f04e36f4bfe2c7f8b6711ccffb13e92ea49189d08269d3121f2c63f04839c5d8a13a24230574e9ffbd485ad6406c1a0276a9927395a8940306d9747f8c85eeafc812927a1b4cec49095d8fbc06413a4a48b1727e1ef81219dcd5dbe9ede34f1c0785abd25f72ca47c7660d8fdfe55af9589b60e0c96a735442cadbf951c18e4ab465c9771604a29172e37b981a9cf45b72d5be77236305a4842a5ebce6b60aabbb3b3f78ff697cba081e9f63c47ca5f19e272193330859a9d9e58c182da65c8c06842627c7e512c0a69a74aecd30916862065724e69a7571873d5b63582d29bbf2b8cabd7a9b5a6e4b8a91506a5ea2fc590eb131756989359a7ca4dd6d3d9559824971e95f2f9a4e0aac294525a8b7ab721ac4d8551542f5c695d2935418539dae81021a354c7083a85c9545a5c9e780c292253985b2624a16c4f98cea15298f2670f2aa69228f9218571ad757f3b72eedca3309f49cb232f8bc2581d3af2e321556c4361bed355ca666ebfce939fc87e9e13b3f309c3856cb933e2d7f9c713a620d16f27db9d30f78ccae1479eb4b339611c3f933549ba095376bf2d9de029775213a648e17c6e24ebca9809b3cc5c7a8753553a870973d4eaa4bb737d0973c8a7ce5a2679b4ad2d61ce96ee44c5889c9b75254c7b41b99d122bb25953829cd47d98e92761cafe9096462d4f58256110d671a2e935ad279648182bc951dbda175b59818441ebe8d121afe7cbfe11e638aa6639976fbec511e6942645e5c4c8e26a238c9246a5b1b29326228c305f2e616245a87b087911865827743eed5811e68bebd039f57d3e281106af78ed517911612e4bfd126631b6c73d8439480c15a1d22d4eb88630453c3121d9a38414dc42984c77c87b77a5d7c32584a9e4984ad162e5e4dc0ec2143a65975feb69782b08e3e7efa7916d0361cad0102994a97aef0161d0b19444134a5abdfe07e3cec4cb0e29723ec90f66391d7eef7592eeba0fc60b25d5bc2f760a5a3e187e2e74a5e0374a64750f6611a52d29554e4f52d583c1c7bc52ce97e6c16012827e7d13d5764a3c18fd4556843e1d3f72f20ee61aa5ef2ccd6907e3e98513b93baad696753097ee7ca53da659793a18b4a50a573274b2d8cfc1ac716159576ff1477230d7249b5119119205c5c168a64ca8fcb1a363070e86fbb871153335b6bec1f8c1e3578a923b65d50da65c7a674ae9ae0a4ad20643caf993bd7472b6246c30ad5bb8e59b4ee126640de69a942729495e0de65441271db75fe43f9206530e42a913d16bdb7244835135d3eb3ad8095bf10c8637a1bbbd3da2f58666309bb4d116452b8341a8532989d1cb7e2a2483c1cbd446b8f14aed8fc1bcd75eb27ff296c4c560d24baea5544da91c0a83b92be8d23679bd94c0601ad393e2cdb466eb2f9845ad83c872ab1cd50be62de91ff183e75eba601053ad8b13b96098a0a4e54bb9db82415bdcee24cf23f93a2d18f5ec27dd5e9705d3e44fada15d39873c164c5db2464e5e8d35f915cc296f217dac3d9492158cfa15b154073597ee2a98e6d449b5f8ad242e5430b7685321f2650a06bd9552ca69a1cf220573300f3337d9a260b0f568d95c8382d962786544b9f330da134c41c48f7d2a6d04cb9913ccde25545b5049c653d60443d637cfbf9ebd6f6782c97eb4ab5eec4e3f5982e9edcb7427794ac98812cc27d62992b44f72912418336d6fd5ec73f61009261521a84d2b1dc13c5acc549424a22719c16ca67eafcbdd4254044390977366d224c98c08061d41ac7efcda11a91a8239e6c4ea24a2e71195178221659985e510776196060c2008e6fdcea346628dfd2801c15c39e4fa32747ed07d095d42dfd828aff8c0246fe16ff969db43ac0703e8814196840927c663a97d82ce417630001eb8225a3d5ef54d773430801d68413582ba3ef5531778662e18800ecc152c7f0ab2b4f7d44bc630801c1854687c9e5c153d49968401e0c060276458fefd907be1220ce006a5a553594e8c906766060660039365b913ff3c9e44258930801a18238e4cb83c5e0106400383b6163f378b1eb4245be011c0f5a251d00511c2006660f814b157d953ae08fb00646098d892b3e85d64b13716e652da7c929cbd4ab1030b738510c2bbea5252b3fc6f91f6bae315e6385b11827b52f1f3b7f3b000d0a0c315469dd176399c9599b66ed8c0f131015c0f74b4c2a04ce850b245e67b973a58619e1ba533f12ec9885b598549479f12c24e52d05176a14315a66842c768951f9dac4d854962a90baf734ad829e585a10315e42c3eda6ada276d5c1a10011a5ad0708087470bfc0486868e5318d2861a5f516df9c46f0a73e84fe91e762d8579cf65ec53ae3c499f5ce8208561a4f5a5edbc7aa98238bcd822070e2fb6c8310ab3e9edeb1055e31f3f36d217386ca42f7088c2f09f3b848e3bcac1c51625c8c1c516250885d9b3529061a7ce521a14a65425b98298c849253f61dcb1742aa9cb4a2192c40a1d9e30ae6556d76aa5147fd40953ecee70499b862ccb55a18313a64b6da9fb713d04d111063c3cd00d12746cc22827a731c2df83ce1a0f0fe42cf0227468c2149a963aeced99484c18ae3ae4ab8aa2924aacb1f6710963f5966ecd975029a325cca6e47ad2a66b47e95f09730cd36952ca497815d558434a943aaec4728667cb4551cb4fea63b44e5de77f564e051d93309879b614725ee949649230e812b2fa431821b1bb8c844977c88927c47dd01ff6a00312c611b1b3b7a542627798071d5af8cd9fb7c311c6399d45ed9aaf97bd1d8d30fb8cc821653f31c290e298bc93ba16473bad60e8588421a94b48563271f72b1d8a30c7b3fc20b612ce4247228c1d45f4e6a868a3bbef408471648a3839d96bd9e24a42c7210c3f5252929b9763fa39011a5a78785c87210c9ee22eff25154eda1d8530bf5e24ed22272f84141a5a94a183100629a3a346ec5bcad5a20047afc0c30305387a056410c69c18395cfecaa7a60bc22841b74cfef4d1d080046804c2ace2b936449dd5870410a6ce1dd15ab1c6d5f407d3c8fe68932bc70fe61479da4542fa60ec0fdda253ed7c307827a184b49c4e5edb7b30c90cdd2e916b7e62ebc174f9913b87388d3cca3c184fdcc9951362c2e50c0fe6dc503a6cab750753a40bea2145b285f8d9c1ec21ea46f588141d3b753005a9262aa2891d7430d8c955cea542e660d4d3d972b59a6e179283219e69b7bf98f99cd7389827ce5d7b4a952d7fdc0107a3f587d0e9fbeb7883d15484f82f67ca725248e87083a9b3b9c90921049316521d6d306b4891756a724e1c42071b8c23f4b9a4fecdfd0ad0b10673be7b48296adea7c4c343081d6a30da450e56b9fbc34b5a63cd16e0e19106537ebdcf16561ae72b1acc957209f510cf3f6ed6582b868b2f7038063c024320c0118c1dce577eb535ac7335d60a4d312010c008e6740bd1907d93f6322305018a70acdf9b134135d66a060420827962c65c14496241da359653172671f1858d1a19f0f050f3d3c7120438a4d1129773dcf25e40002130d97ce7b2778a1408100453c4c9aaa7957b963c35d63e706c0104536ddaa6c80b277bb25c70f1c59fa96941801f3cfa6dd573f09c6404475a00f5cb81003e58b4859121ba3dc90e6d81a38b2d6e786a77400e82003d30083d96a654fdae530a1608c003e3a57e1aa154ce65fadf81c94d52c8d949d781396c7c85b86f93accd81d192d01b42c6a4981207c648f941282182b211961b18dd2dc6842023cdc93420800dcc791d22972c754ab849011e1e384a170850037396c7fbe42b42bf9b6860b0da89faa193e9f119025120c00c8cd9a7eb525b3dbe3402c8c09456d2c5504ad5079dcd8885416b4cb58734a977e219b028686f31939fa4bbaf4862c7965ac4b4f60a2965862b4c25f94cac3a74098b7e71c38b3b2d683c400b0f8f1b284001eb0f66b4c2f82571acebc4f6c7ae3061062bcc15752429d5a37b3f5aab30e5709e52b2bce7742f0933546130ad8ff73948b7a4c244c28c5498f75dc38490ab919e438419a830887deed02927a475afc6da47b261a3041f38ba066f91805232cc3885299b8821c26e5e3efd1a6be8c3b9485d740db4a1811c5b24bfa18587070540f0118055cc3085b94d564e720a95752a2508334a61906b5a5a1f7e56749881308314062df1bf54e5745d4af72fb8680e8cc2e0b1bb4327468a284cf1f65772b04fa1e357426150e2f4e99fb662300314a63065a1174f277ebe19f88451c6434fcd44519d843c61566f730d99e3cee884a93c5aa4582a48eaf2ac31274c17c73fd207314956ca26cc9dc27c5d8eb6260c3f6e41e57abd9f0433615a7f397539ed56ce1f264ca523a83c9d439f50e94b9854c6b8664d48726fb18429a730e51bebae61d14a183e68d16e71d348caabb1f6c10517fdb11f357278e18905332861b034361e33cf547d28d38c4918c485e420fcd4b6fe481286b5fa8c74fa481845a724f14cc84bd69119903049ed097f2ab47a9a6bc6238c59fa51aebb43f423331c611e376634228dab8f90bd749fb6c61ad96206238e9e949794d1293fc48b22331661d2f0d1c82ade9e29a24b6a62673b2dcab22bcc48844124c49b0da12d9de820c224fa41c49ed8ea0ef321cc21c4eab54a13dc3f8630c4cbfec82ba33aa46c214c6ace62d5fb87ff132184494e777bc8f191a3c8660cc210d4098f587922fea28d98210853e8f5f8c17357ce1c91dbc38c4098b48ce714237eefc68285198030e77fd3d5bc325d769236ccf883e95a457c7ffc770b397e30a62761f1473c7f64990d33fa60d6dd970f337a3e98c7a45c9e442d0d33f66010aea53c6bdbde776f01175e78d1650333f4606e13af1fff5973d619c18c3c9c2b54e9cb18dfc030030fa694ee1e543813415dbc83b1b453e70e9f676a5a543b98e5834417651e4f82e4f20e33ea609891d5ad20f3437b8c0ec64fe95325516225a56c0ea69ce3277a2521621e948339bcf7a99b7822c8ea92e461461c8cfefb123cd672bfc739cc80834967ad9cbbbbc68bf4e30c33de6090ba1ecdde34bb196e30674b2929a5f4a53af56a6983c1e44d8f7eaf173d6283a9e3e547ec3416ee396b30f5e82aaf48a5238d5a0d268b1fd352750d6d350d06b127d4d5040d0d660fb338a9973f652d04cc38c30c3318923e09162b46cee69d32185b82969482d0ea53693298743cb9fa57650ce6d8ad11f546e66973c56050ad7c51e24388d96130a5759ff0b62518f0ed9359f51232e30be6f7d98a97e45dde0fa9c20c2f98438ee36d2945081eda195d309a1097c9e15752fde68249bc24b595976405af6cc130b952c5113bd24ab45d70266668c160a2257e4e938967264f624616cc9b577e73dab31f52f81133b060b6d2f37e21be2e9a0d1b37881633ae7045b2deaaad9067d5580fd7c2bf7174b1013531ccb082d9459e4ade39fe96622412985105c3d749f556b1e449785430078b71b361af12664cc160da258267b887ba902fcc90825154e5d55139a419a5ce8882e146aa8d6da90e95d70c2898f7edf4c7c64497bf673cc174419fe9a0ea7f37c6194e308c9ae751e1cc53ec74130ceb26f6d7a2a9347799607ed32df12f397ef2dc8c2598cf530e167b7a12523843090613d367128c3aea3c7f98f03f2b418229ce4d90f5249a71046368b5af390bd2427f8c60ace4d9a9ae7253f45904f38f989f50a7afa31f36127f31830886e855317b524b3afd0fc1204baa8948faa6d46f2118a4e4594f25bb73c26843051f36d2e69811049376f80f6159cbb72540306957123331e5a5c4f603c38b49d28bab3835a98fd445670e66f8c028294e6be59ce6b39e7a60d059462387d1f4d12e0f0cd73a314bed8a4e4ed948773698b103f39f8e45d62b91b4bd3a3049d9bdd0c9ddea7fcd81415d794ed73d75ea331c184e828c982af777756f6010bb11271baa849cd00606f3db53e9f35ba5e86aac7dd8486506336a60320b0f6926b95a142d0d4c6aae22da08f5fce799310383eeb0ac9c77a13b5f3364601259fd2c87285af9cc5818bc732e1fd7de6ef5790d3260610e336184901ecb40c62b4cb51a6af53f25774bb36980d440862bcce1d923495e6798c4c8b6c2f4162dc952ff64a6a2066e68218315a6decbf5679ea6626833a0058d08d4c0d10ee0f3a25180850220f878808c5518649f24990f931a6bfa0719aa307eb07c75a227e1625f63ad0aa981a36b905418dcde372ec70e16b373c3c6ef7d51010f8f1a38da013570740d09f8163734208174c3e3865742062acca2557a45c9ca2c55d758ebc286c93885d9920841a514bf7462de43c830852958b63f616b6ed9ef52987bb393474ba9d4682e831406e9177ca2ac6d895491310a43eaa0b46acd9808f9230219a23028eb683149e8b32482a130dfc5ea4f3c29aab2ffa10419a030041b4941ded7d3e4e41326eded53ffd6371bb9278c92fd846a9b14d13ea9138611caca7276b9cb71e38449e4544984d39d4d94d3bd7388b264d5adba0c4d182fe4c497efece51241cd8439f6e9a03bdba6cb24e5c9c084b92ce7afec98923c65370d322e61f034d244551239794e3901f21a5ae04186250c415b2bcb8b76391369250c7a4f9ed74bb4d0e651c298a15ea2a85c8892a449983bdeaafd841589b949c2a4567e31c5437b1991309fc895b311ae23d117820c48184b5cc9d1e6e31e43081f619c147bbb43a538c21467fc83887b712bc55690d108a3e58ab6f9113a5e486284a93a8c2ab91c3ac8b86f0a321661c86ef292ac07f3b858086428c2242c94fc7c0a41fd53321261b820395775fa3071224106228c1727e976bcec9e2dafb156ba90710893c5d0115e2d5d3ccb8d761c1f072d20c310c64e592f7a59b6c46cb990510873c81d2689d029abc70961f8339dd5889eab84103918c81884b1439cd50fe5b1c2bd9a2a9021088396edcbba957e3ccc390619813029b1772d3934d34c650908a3e8ac9dd35a589c5f760b32fe604a26f258a7dbfc60aa0f594aff6ca873530b32fa60c8dad1d2980ef3c1202c8eea76d0f649d92bc8d883e1e36513225c8a5631f221430f26257f2e6c6e555b8c0332f260cef693e38308614cecd9041978305ed6f3964b09a2fdc30419773029bbbf102c9a0aca4576300839313546e6a9520b7274f1059aae40461d4c215a58cde94ff16cd3c12444ecadea8fde1964ccc1a0bba154a7c98a8fca0153461ccc167496cfeddde229d37c830c38987b25560ad59fb3dcf806e3b9beaec7d3718351444e7a4433de93966d30d74f7a75ef9c9316b1c041061bcca2f4baa9f5f7e764ca32c858833174e4cfe78e3ce2924e95c544728f3a4a83597d3f9dbd550e6a3b1a8c9a753a9728ff0cbdcf600a71d1d76fa10bc8308339766ad3dff1fdf288cb601a3917226ad4ba332383e1e4255987ec1faedf1a6b1f3612a640468d87a8449165d2581c0a8542a130280c8360f97514c3130000000c1e144763f1589e29bbb20114000442343056343c1a261e141c180d04e3703014068403623028100883c1a04028748ea6700c8b0f2515e935d557e99e1353aeb200d9fcc6754ce80c44c8119e6eca14f2955f0f1c331dc4d506d130fd1664da9c86913a19b432400ec18bb911457805b235891c4adeb651768091eab5d77e70eb293d81c4e3c2663444d433d431c64abd4c5e2ac4d1c74d6a65fd83cc3375796e80d929b7b27a360695d2efaa2e71a4927e3b85bf4b25079595fbd2e12d5ce34315756e9604bdbcf2447447949e31e3d015327d4ce6ff8eec4b19a3a68e3a2824240fec1a0c4a29cd8fb6e60e69df702c238fdf5a221c2e4854653009cfbb492309094f03eaf9fe9a44aef6c32dd154193276cd51fd88a713bc8bbb72614d62280f0dcb61821b33646137b0ed5c93179a1cec5d49039ba3d9b0fda804b3e9f375fff67495c531f413d2479b2969aceb4e308b44c3595f73e813bb039d68c5d33d15d074468af96cdc2007853353c5e872a516d2328d89ebea6ff34492bfb54746e9263e4f46a88595c6eb656166e4b4ff48995183760f133699db9bd3f91713e84bb02dc6f0280d3e028b4cb443aae45f1c59f868e386af9883444a0c3313163316ca65789f5ea051f15275dba98b19f039901ed51a26979dcee3cc0057f7ce0115f98c7c50561c4c70dd3a131d688e4dc0c8dbf95b9318d566b8c1a7f13a1820aad3e997bddc246f0501819d6dbe2124d360abe4e6f8b9d368b0e6c9650340fa75193d3f6165c390a5645f63a4630ccf23d0e988b646e2c50832237d45d706f09fd133460c2820c85317b4b310e3f2236f200911d6195baf9b946e95aec8046f4bc1f070cb369f9d994f47d747526de2682ce100b47127ff8a3d2a827fdb6947e9232edde09dc9d118655613024789b870a8c4c4a9023cfda92f006b7e5c2e9d26fce8d3531917d86936c09666eeb5d85105f5d96a1285d0cdc6088b5a9ce6545550fc62a55a82a94c5285fea0553886d36acb8394807da585bc695904589de91399533c582c41d09282f086e43284ed66f127a2d58407d58c66b9c3921c44d3fcd24a15ae568a5ebe6f550257005784a41641645c8feea284388cb28047a9670165e2f8fb11a03a18ace39a114bd716a330bd6276af016d6933466fd716a0dcb83e56b4553be0fa08563cc701c9322b365491d6fe6e067f4ba7832e5027bb66a42fbf982ccc6768fc7dc748ef8e74372037cd9c2e33969a5a8ba4340cca6fee1aac57efee90f26fbc8d5fed521609bde34a2c38edbe02fea1995c710f46cd8926f3ee054665cdef666013642696a1346dce3d9b935fa5dd876d522b5059bc58d8f7019d0b133494c18577e1ade092c4b7e1b12250b93e882fcc097e2ae27503b3d2c0545f0c15adc5328f93e951e631230d6579f7ee5aa358ed8e6ebb9f50ef288a543c45723ff414f08891a6362b4a7c585477a951373813a589b3513eb6ddff4d1dc76fbea8e4b03563d4f4bf6943bedc84aeb862c66254a72fc70a4f997d631840619285488e43d4e4b0618555bf6ff7993cd9c8e83d4507d42df8ac79ecbe7cf2cd1c8d51ef005c319d1b591c3dcaedeee1909129f14831e8e934bd575423155c6daca0b333ac0a6288eff7190aa94d26df0fdcf706f610be82a7eb81c69d36165f0f97435d6808c0b1cb38c91ef6680f65f2e8219ef2f12c2412c80db41909203cb5da2bf76d21f0a6edf92ef1be0a0dc7415ae763989a43686280f82c90a64bafda406d829e67911fbce7e50f8c9d9e4886e2a7f0ae954326d3c32b98d18ea3780d645642a76850a5eb633d09e8062181b846d2463553631a11bde2cb0b24489d5c41f0e67fb1e1e37159e99ea2a66f93fdec382ed9b60121641223d50946ac1edcf085e577a3607d2305510bc6127b38b6ce897021a09a554ad83c3d3d47a05f281ba95037af91c7229f145b624c8e36600b5adef16bcfb3e1760774c91ec83d9675d492ff9d7f424f813ec8f343d935f6c7aa7cfc9c9ad4a26408f147452bee24bf1154bc1421e669da917700f30d08c8414dc3d346bba0a73dd70d13a03c2c17d109ed09a71b79f24fdb04b7e9f589a33452ea6200b3c60c75e108fb01d33f2326022f2babacee5cdd3a9dcd48a8142f5dbb74c2bae7f146779f26c070527dadc04e5142a12d06ac44d69c68bf20ab902b3411ca990c250ab4a8295f5cc92e01c46c6f8313e0730889f94103c04a271a1a9668810665cbd920688daa2ab0ac9089d20193eca01b8c49e910e2df46f68e6512ad5385b1363d016da0c30f6def5453d35149ea2f30c5454043b06f36702f4f07841ed2c652a2d80f84f250e051e9685d1b9bf4710af4ddd3b1d58fa546fbb26549d5cff4339a3fe2537e46cd1a727a1f3f31cace2767cf447b6a6c2b2cd19c2803d01efa9f731c22a779f5235b4e70027e715161c209e23408ee15fe61c60367185730afa1e881b4be630e3034af70f8f12a7a902977fa47676b95d68889364acb145d639177c06c402624e91f0de01b5dc7d81f6f3157d71c7eaa54ed09b7247420260af12fa8d1892c80b00edbbf50cff96ad8f070f160ba02ccb6cdc5422419fe282f4a314fc05b20ce8d96f4f17d56882b6ebf66059e8d107135521051db202c099b7307e57c67fdc9b27b44e03c49d1c0c37b7104c0a645017d4c3bbf39d81951e3fd03ba90de3ac1ec34e460461009e16a010e9b2fbf61e8843fea3b97269bd44ddcfcef2e4f50978aede1bcb4735261489dcb44ede40c69ab926d5ab441563a5cb5cd513c0f480d8247ae1b730a9ca315ebd32be660f6efd4c762259ef8d71dd7b3c4ccd7b401479be91147834f9d154b8f4bfd1783a4174d4dbe951736a5e4549c86cf4313a4b6b52a8645720a692995df1f2ddafc3fca341e4ef76ba08b57f15a397087c02db6ab1caa3c75426fd433828c9d4dff765c57a22196fac2487ea9d1ec49c876ce273a353ff85278af8ab87510bd80ccd5a2a3672c6a1cb965cc4b0ace8757a1d06370430b48829dc1d645c47c30e91d02628f193ebaaaeedfc51f1bda6474eadade3e208cee33da6295565679256c4d188b64fd6f31b0614a508f9efe35e025317eac65e6f1b12ff2ace24a92b0a39e8e280de735f5e47a8ea2a9cd582c7c9f913def21a62c0d9708ac19216f7f90ec15018c5730f95e1f3b416bff1787514842ab6e6242c89073f69b261dd381c169785b0928962393eb211141e728da5a1147b02fdc6cf000f60b8adde605862ca16e03b1bf6e64e4f14ce7584274415967a248abb91498aad5e26818ae60c8a3985822946614154bf53ec087e4a9f42de02d4853b0b5020a2650ef0c9a8866091ddb41163b0f292e0dfa48426251b06f839e40f4b681606e5e4991057489c916c23a1a10f111120ab4a0eea4af2f70dddbfec18ac75d8058ad40d59ef704ab045c8e0506e67794163844b9efd8016364da9804ac9febbadd75aff27748af82661223f915301a21dcc370238d0a602024bd1fd430247b53534b3682fc35b9613ebe0830be262ba420825ba247918cb8c481a0ee359042660b38e7d2380f61c534dd182473045b738b3bd88d0f7cee823bf926103a40ecf63ea4bd14bba392e0725d3e2de186a6ed7d2dd18c0184147882d7d74f20a07f02b5e7c63e49b7d6586fc4b740f60a502dc94fd264c5691ed44e71655069eaa4c6a162a7f9d272abc898c52f2ad1c7f8a443fa2a18d66d8e95035cab372cb177a34618be41c976fec7648352223915586f21a5d968298ae628298b34cc729542169ad6216c156184b117d152582cd571ac306c5c6660a165f72e05a864c8b45e53dd71d6e8f2ead82e65944f5b7e0a3d16f1b608bb280a4b308d129e041a9c05d1260d01661bba70b3bd1596006a0c0e61dce18377031308211085a10ce0fff7f2d175e34669d839a773b2ee70f4e5ac544f1096d2479c1c3d1e8a42363e4511da8a34528dcd5a5986636ac1f1e55b5597d2fb1c7e13d4884e80a663246dba34bad54f32c81aa4d1a664651e8ab850c73c754189b59218b021d5a99db2c9cfd4eda91acac26cab18ad5c587f90ea981b8b1105e91d4b568ba85fbeee8fa609f2542566d22726436032c6f448b381725f00d7f6da63a51e2e5bb3f2080587eb64acd05a38f7b5faa830ccf81e6d83f6050098080b0a6e49c80709e02b988b6e97c2361c40a28eb5bc1f3cc321f7b2dcfd0d10510144060a3d04a1375e0e0825c87bfc2fc3cad2be668e87590abb907db333a2fc263766775c14e4c38ac3f41d5effc1410dcf315b1eece3416c9780ee738e6d0855aeffe1097e9329fc55d3e9ca9087c6df6b80a17e541c786e827099ce4b58a149e602dc906d8922365610ddb843ae98151c14a236db415ee677135d1b7075275f7097a2c7db3723e3d758d21e5462c54bf262b17e835eb50eb854909cddb05de2a3a42e75a28776ce6f754706652b4c3cefe11a91deb97fe26dd998a738d10a1fcfa3090139df3e1792db3d3792fa1a799d5734fe19a0ed81c15a46af7498e80f9e7f4dc8631d6f358b4fb7ce6d8ef496d391fab6b460156a256ac6030b05a1b43bfa89002589276a70e0e265de40dc84a84e5c84865a088ac1bee1ec06abf228b313a4ebfbbf9dcf8943699c0804b3d9fd09db19451f95616d378139a8d9e406c494208525791223aeb81cf08efd360eae8862706d403ae2817bbfe4490fc935d1bb4936a7d0c9544246d4d18beb20606739bb92e84044a44f27a1510d425446305293c1ae2b314d6feffc1b34a3638c94be379af27d12542d4045a5dfb6c7b559947740d5a75e6c831d8220cd4cf8a7e00e3812dd86d3fffdd6d5fe91cdcc08177ebd8e7c15948781be697d412d29e519ede69afd26dbe7d7d40ab6ba565eea80e62448f634b9b4d3ec6d36086214007381ce5e45158e66f6c7617970635580749fbe6003ee96cc3aa74de57ea131aca128ed9258365d8c49e1ee9bebad8baea4ea045a1dd445eb9aa551bff1f35282303aaab55f3159c040cf6999ccc99b2c93d965f3a952315162c2efaeb5d8ba5ab5142e77a35ed59e91f440cfe965d6baa7c729cf219e87ddcea44aab19f5662da7aea85642e55cae1cac810e8ce49c94c99ccc2dc588be5b20033a670bad09ea292df6aed65a28001fb8419a0bfa913f9782bba69d9c96ee5889373a889929155af5a87cd6e6dc1f13309c0064880edea01dda712c0691a2bcdc7a8dd32fd9d35ca9da2a44f5592f67f7b44a519e663a2d9c5b17032bd5cdbeaa0d0a7d36e035512c2eb62b309c35cd4b9408d1eb36395c47f42b69baa83781988d9f9af68c9693d0a2cfb19685467f9358aec464b1a400e3e90b4d15b63f6c618fb20b0e7bfca8b3d223538cbe49551a50f524d8696eaa54bdecccda325b59721ad7040b6dbd9576c28307109f07c6a45f02ada4021f4c27c70ad3fdd457f540fcd71ed041b90b96e85629e021e26b91fb357836a29e1b315ff8a662ceaa88cbc2dae08ab4cab5781264a89cf863656dd54a781afef003aff17b00b649223c61b3fc4ed93210d4083df7f2054ad5f8916a11250776bb474afcde8070a03ac3ab4642a82fd0d8b21d44f9e76c5f7b4306a0afba43828c8f86006948b2a39793e2c5fb67cd36e357a3ffaa4b5257f13d519c84c7e16c014db804ae7b16153b2ab5159a22ee0a8e47d2fcdc0c58a6f5bf55b235a4d367064e0e4dc820982ec17c53e9e09d18cea18a9b89ed4cc921459958cc60da9cd53225ff0e63ed03076fc4a041e6dc7b4e4a14fac99986f362dd8951d8eb7b95d7a28611de36663c2ebd3653358ca005f881c3d9897f0a16e74072eacd5f118d9b2a5efdb9b7b9e891cc2303021a86e3a6c8a1e43f0838d29c226cf57ff04dec33e016d6a36252c36ea35849c8b21a9763f5cfa7921011dab0f91be0ad109e2b39683674bf07674f3dad160c776503f680490ccbce93eb4cfde05655613ba1a611f364a06e2c4a0adef6d9cb79d12ba577a44d7295a8af828c9cc08b0db413592262d83227468524b572695a32bb50bb6910c25f221d1e459e6ed04a760fa838d2590b68433940f58691bdd1f17e25022389e0ea0ca70c8f94b603dae629bccf5a3dd7fafa071d093a0b6d97fc204a4c3ff45e90b1cab00874ad7d756880c480951be64e1ebaca40f0d107a5da0f1d81d059d59379131bb2288c1dcc769827490f4395a5248b4d40e0a1738c6c7df960866c8818bf2f167307a65a474d0e4e7f121d42dae258bd8e368c5f2520a4508a530495d3ac908ef6073ff0c535069c532deb887e8605b2867889a39b28730467b1df045fe000e47e3989990ba1981973806ad4085165a4bc1593924bf2b67ee49a022238f35b57b614c78c50f3931289fbcca9cdcb914d25302c994c1975870e2564a21ce049701d4afadc798e713ade09bd7411a40a316586aa3726e33c138cac22a532ee7c0a93fc9aff14bd712bc8ac13544d8efdfef2e7843779aae61ce72de0f97e7088bb782d4c6e9896a9a7632a536222338323a231b66e690cf92f64e8bbb466abee417ee2713178169814ce3f3cab878fa7828da4eb68c204976587778f0215358ff93d86c9f1da7f5c1a562049cc6a3435ba8543f69b84b781a58a98b04a45c9bf1f81e90db6a5a88153d7df27f23b4aa50662c433b04c5b20103079344120d91c52b119c1bb22f9100ef26cc7d746f92798e276ff8e7ca09fd068f4be423fbf992c0f99d10f7766b89b22c683c64dc34cc33b35d65871eb3f821d063403ed749c9bc0d400fea5c9ac30075cf431c69a462b1a7b219f68ba782255c7e683e988dea42343b4deada812efc2515b95025b3c5dfbd1e36217cb6fd280f0ea49fc22e81368b2a4fc6950ca1ead6c41c756b5cae6fda17481f4cd02a363b2c0518ccb650065be36a855cfb91c4d72196970e151c9429e25dae3d601bcbdea7a8468b85b3b2dfcd06e1a4d8f62a5f9ba3c8de9dd1429530265b37467ac74b3bd920d6b3e86f06b758f4fdc869a213da35b2971ae65609c05d6d6084e0d06e1c838a1dfeb6e0e9981011a7c0e427f88380cc0c2cacdd5752df7ad611a0f182d975ce17712a9cc292b30aa502c2ee3732fa41b2645d9eb76b7d081b0a24508b99c398440d7745229514a28e27a06002167b822982287535039c5f900163da00abc06453a610cbc71752de78db24f47e2841492a81119999032364964a5acf9aec81ee548df6ab3843717447163c286d6a084cfcd2b9f4dc1449111b2b9368afbc09e623171271f8f9ae165710844a9f0f6990e8a43c38f90d9b11560ca380ffe0eb9b59b411e0f65e1c8c6e28f2a1e8049692e181536899aa314129127804e3cbcbb56df21fd5be2c03c036039669bb355c3162a2d55eb00a0c9ee55fdc4e397f151504888d76721fb5d70e156d8a1258c6b39e6bf19bfb5130b57122f4b3b31b9d227e542b7e08768b3ddfc906067efb8909062ae0341bb0bad6e9bba5ed97ed8236beb408a1c2934f37a12f3feb891a1600f14ce07c2e6a83553293ff1441a2ad5e526a9a1cc1bfaa2e0a0097797cc20903967660c36109c602819029fc977350b10d505799971085720cb2c3d0cbb9cd37ba15ebeed57a3444fb18a2c4a10f80bd3b80240124d00086ba8f8576700a84c17239c5732c7a5725b5a22133aa23f7a9d9de905924c9c82c19adb4ea2c5575e61bc497c11f0c04cc23a32fa9a003cecc551d9ea042384a5f201ad5cadcae108a6f41aa960b032dbbaa1a7911ac62da0d819b7e744fa4ae22652b694bcd044772a323281d90205c5d5ee210a6b82251577c6ae0d70c99148ada5170d36751954b0bca23d7de4e8d8a033919278656d6e21f25c700041b0d6296e629f5bb8405c4ff6710ee00e56c1f7a4763b50ca5f061362ceef80e1904b2c69529064cc6b7c5c548fb3b64f259dacf03b36d9ddf5429993ae44100a51d35c2596505a5c040501a0f17751d00d8588369aac0cb8094d3e8b7ae995e87a88d9a3154c393762ef11323a406759431b868e3836867b8756c5dfefc509d8b75ba9614bb62e242becc15a7e25a13b623c0906d6a7a563835424a72c5f0f24e9e428b113c6901459832a3faa68543122575a27282e598e4acb2094be296b260f68461de88f59a22f600c0d4faaef59df66ba38876544c45fbcba2a6fca748dea1c57eb3c297f76d2004cd7a6d2b1001d19559189f29df22407539e9d4a396221bde703d8a83f2aa3c7650da8986bf9018711c782343210861750e0a1ba40ff641ee85635ca4642a6950fe3542eaa1fe3fd05ebee38f56d829c4bb9774623c4aaa54368ddc6509a01ed3334701e80e6774965fd7ab1199de4f99261b602e0d6549df6895d56053b1a492eefe45a0f23c9e58b5eb4af03fa7d6d9ef477a23754125a9b0a8e48f0253de535443e94eb0d9603118d0079697ab395ca1f16c9160c73600dc4bce18130aa31073abbcc1853ebabd656e8d6b432b42cd0597b70f674ca63111b6a2ce57ce8a60fe24597b02aa58fed7bdb80f5343cdfc92a225e8b02fb39eab7c6ef4e5f3cfbbef25b67bf053f58fa5fdab7c4ef565f2c7d4ffaa6a45f91a57df278f53447bbd75979c211925976126a1b251a27ffafa7fb836955d0e6f734b63f4ee894414c595b994e62f69f5dfc09093d7a5a1b410e66c398bc6f4b47a5a07eb14f0cef5a8ecc660f3f7dbc9226d7409b5368f9eff0b0b0c6bc9ccccb0347cf5c992bb49e631458b127ef44c6eb62acd7b203d62621f2d79834a481646816d50cf5669330dbb8d911dff6730373b8ff0674dbd82b6d95485bbf93ae338754ac7d72adc3897e2c41f29bc42a124704c92725e30bc7044937127d24963712a3a2929a8442e22bc9d625924d8c4625518955ca5383447c24aa2bed158073893be9c9b8b4a6a3edb07970af3dde535c082d078f661e3eeec771f892a7c89c475d1e2d3d08f5f8eb61d543aa87411eee95c77615349bc7c523a687821e1e3decf410cee3fd75b7ab207afcec71d68fed4d21c73a7b1fcb800ced88ae215601f185c8a9718ca8e8fea2304402136852e773ef5cc6dc38154709d11ba8328f2ef69ba23cd8f38e0917f7fa4d3b17ab02d6d936067d42722c0d223844530d6951c4dbaf4996653eef3684b379659624809d510afd6d024c57b6b4c4f39aa96ab5c3f991a6838adcf05bd98c7e00db019324c72d133e925ecab8105380e606e7c17f6d8a48295206ef1a84518b7de68e2e209810874e1c2343320a40f1b4dbc21222d3592f062ed80ae8c9a5e8611c534ddf0bacc3d815371278144dc15602ca81bca77d12b599654bb48d3530dfa0894c2a0cec0a33f31ce4b295491e9a716dd2b44043f846b544cc29aa5b420353b830475b0ad4b1d921f2742b8475a9a468637eb2c9724e430dd83247386e389c7a2d01701a0b6127b160a955e938c289cf05c7b3e2973a37ce871adbbdce2e1ab2114a9165a43179437663c6b010db77abcc2786499a1254e337a76a58360c54210ac9fc503d6965dd62437cf0db39b438b5e38219f22413635d0cd2dad7ebb4f8f680eafc362daa48e534991ee59ff25e409cc2097a5bccfdbdd82d9a0af8053c796d80d2482e28b3e47db119aaf2e005942160600ade7379ecacbb61b786d23e501ce9966c9715392a9d0c443b8730c07e787bab84968c58414d7026386141914f631fdbf871078f5baf3e6d6c3d48e16f255407b8e434084640a7c4716e1215323c2666ff88b68b6bd9b11a482cec660cb8586519420036266ed50e4a46870e6a49be064bb1b2fe617a189964cc13a7b6f55350c9e47a48efd563925ba6b746bf34499f85b1ff15f89f6e9148fd39c4839b8f5635a0226184a7aa63ee8d26ee9b4522bf0612846a6fa71cf5a4e7e95cb70bb944e8f0a2083ceed422ca8bf291d12eadd76a283194730311534b83d63c31940547b61049726078751186f9f6808515936e46c375436d78272173d80a20eb96efe242572ba38394724d3b7affe1894e34c4a46804be6ae3a2ab85007f400f4d00ab092d0c802ee0f9f1936b154aa37814cfa7de1542c0e2e67328d7387b3b7615ac044b68e4871e358000f4eeb2736a2abbb01501f26812c729f5cfc034b281e89c10709c5000e29e3ac5c4e65a59f09e34a7257560d1493dc1669ed86e005e7c7c2eed258ffa9cca61f7ae1d1cdb600b5bdb86d501c78206f056b279093c4bf34f53a9f7b40f8065ac623c7389285355f30ae06b429715bbe542a81fb1db278e316c68bd5818da16cd9d2ef063ba5026008fe0acc34c156710c480da7fb0e34668e5876c504a10e8fb7c4e6f07238189ee2d273f5b785ef929d876f94422645f08290457f9b1233676e2b6d51c6525448b06c9988d009923c72398bf297d971300f41a14f2951fdb95a06c4961c8ada0df257e68371bd16c010e43fdc3789c5f671e770f36a86440c45758b44034ff1b16454adf482ba65c0f93c26af075296796c02ff744904ef533db4090cd329522b2053bc24489a4ce527f9c783c227482d9110368caf03081ed464811e98626af381b718793196e6a3439e036c48d52360bec0432f046263ca3e706345dd7c283151ac431b06a5d9bb21278077bb5be32ad756c55b166646b427c3b6a6adad3b7dd5225b3b9af5a103a7d6e99d328fa5b986427b6484f5c5b1a92390a2607ae0a540a68a1f5e8d9193a4fd969267aa04b919c53642753ffe937704d27d1237467a8bb68d66c881de86f74dab694b0cc64ca809fe4a20bb3b4433a4e6be4a3e31d41d3fcac39078512da528f71927d7dc0494c51c15a490fdb2b8eb667cf9e5898d82f57384295f5aa0d761a55f0915048f53ada6d1515c04f93a579fa1d761a47a3639708c398914f465a8e4c3061367ad1368a6cb4da48f46070460b041ff58eb43d232355da918aeb9cc26f9cab1ccee9352a83eafc84869b782abf711c145aff6ce44d10b77ec1ef51193420ced8dfc141387e2c201fda4046f30455b2ab0ddb4036c4541a4a690e27247c29e9e5bd67e90c1627d3e7302ada05801bc118252935b9d6fd729c58552b9d376586f1308bfcccef22092febbd8ed82b390135e3154ea3e7e0fae5fb6a088f70c5c0f2f1d711ed60598fb8e9f5bd388644d7b493591821bcda8165c9ca8d95185676b71ace0a438e9585b482291764a89f3a65e8d499d080b48c851b94e44a410f8d8c0407daa6485209474185cb1711ee3a1cf3ea0dfc4645478157512e0433e4256a180698ce52c6e88255648aff76ee29943c60257aed1187b9a5be03a71ad645440c5c22a8a4542ea834f2f1362820b55135788acba4ba50956084a7ef114a81f87eea84e022f79cb9e30175a4804c444969a55df25710177434ea8a4fb48337c90f0dd289c71f3d0f00214229f0e9a381ce1d38bdef8056cd6e2a67e19850308a02b5743f285e818c56861ea407b2313bf1e9cdf8ab7193622de702fa0e09ee882b84e3c2c085d42f326fc4c423f783fb2a93b223540823bdf4f3762589803485210cdc40243ca219683c6a0a372b6b32ad5fcc174375c931adb1a6d58574d697e45a66fb79181559c8b71f816a90eaad50be42f3f741fdc7057f5e9544c8b8e4d94acda85b543398d3038c13f3de1697219b3407b3519b8d266024ecbcca858d4c3d2788c22b0ddb80641b18ed807b5081df10982f55b10c4cc49ea976c3cff91c73449f665d5134702930e091782ff2f88d7e5ad6582a0d0492edc0f9c3a52f57c00fb20f08e607104f2d0b7b96e92f97211632e90998c85d0fe722d2adb6524728f97f6802c85ea002f3b884379fdf4f23f8dadf5c0582ddce2ef23de637d3bcf6fe6e7b6b495e266b758f847d9d83dd179e38705a9ab87fd8fefb850bb4038a460987e2e52746597357b121ba6ece14ad9c14dcc082aa3d8a5320ec01bca340dc06cd1269c3bbf151efff71bd48901bed4d84905f411f3baf9166d0ab7cd4fb7fd40b20f4cac7bdf161bda88f355d7706d8eb7d4ceff8b8f11a2fb87a852037dce3d5c5bb25d156d5c92020d886c6b87290b213a4308548b3ba0cf6de6190751fc72032ad26acdd500fc1a720eaa4a762a274048c70c3b8cc2c3ed7b7deeeeffd78ffca3dbeb3f8ab9ab7579653a85aac3ff87e421a62fb19b6d99adf42cf146c9967a0e52381cd40bc2d0b75b7098c37d644725581eb609e8cc5c044ec81dd044c49389bf0a85165ff8a24e593f4fff04477fc0c5bb2de8c423ea20969dfc5d95a4db48b8a18bdcb601bc2a6d66c0700d63790155d884e9b4fbad5242e16906233635d2d8d453fef428faffac90deeb00840d88de0dc270024710739a621fc6ac206054925b84a81d3e89f10961b21482f37482a0fe20d0842ef222aca9c29825469a7d5bdf6bff881e13124dc0c6e5402750450015da19672fcc76340c634d8037cccb65a58caedaf501b047c3c69b794a256b5857c0881648784ef3e1517033a6d15e33111774898956608481597398027af7cab65075a5ea87f8909b13ee98a0cf1a40c443a51fa3c0bdb119a11815c7ca9f7ef86f13a1c6fb4c8038c7961c2320aeeb4e758895cab3cddece684873ad1cba72cd9aa3a40283c117722a0d197dfc71833ba3b1bb164a52f4fc7a1266b8a840937a33eb338f33360d475859b1d0dfff8dc3f88190fc4a014cb31b55748203c6ab6fca35a1b1e64c1a3eb2217454abf630c48495fadcf049f13e3306f652bfd225de84581b01bbee778bec44af16e551a87014bf6a1037c61f558233492dd320cabd87ea73802b3237cc792d2e520fd46380fc17e089cab21a84e3aec1e561646071b01731ed38f298e59c784c6a4625ac65c1123505716eb5e22e8ce81d03a7019465d22849273208a9b5b722f77bd37353bb48349da92b91bae90a610fa435d58f7b4ada1e16909c43de3fc97e094c3de8843355c5c101c60a0767679c823b7d6b3b7bde87ac1f262c0196de7c755e705b049e05096ca9a6cdeb141029844fe645fe976a0553c32ece269c82370576322f4ab1d4d8858dcdbef59f6e2ec0370d2ba9f39b8ae1e30766c2cae199eefd86c44759c75f43a2eeafc5fa4092f909c967278f689a8384cf8b0dd3e040fe03c2598811955d1301ebf2c6985e70ed978b83e131afa13c6af2b5cc25ec6e97733292be305b9a537430c2a6ccffcee4904c813933dfa228373af89f71aa0d6d216dc6d2ffff748a2bc0c527ddf106149a52584fbf05a780b8f179782300377280716d916ac67813ac52964e22bf1f453b7595487f3fc078e24c4f35cfac6c27ad708ccdab1bf84a8969bcb8243482399106f3b0a3d280e4187136b8e65811cf974eb94ab2fcd433aac47ddcb36e61d4c0f79f2cf17269290f1f3159e2f75b1f0dee813eca4021e89848e0b3660b46439330f0f0f0f0f0f0f0f8f3121b5b54f48424a524a4aabd75247e420a524a54c2989b7483b7a3a33f129a6c9de6498f8040402c20bc70b970ba529194ac5532a28a5c7a80127ee5f214f5a8e783a3168c07a4a297878ca32d5b663164c8ed729a9f85bf27ae3396c6c60c60ccf614305336698a143166c66448d9d4468e4d7c4823fedaff9a34760c189ee1077731c9d745baf489ecac9cdb74757703a42ca15730a19947dad605f82662425ace3dbc70acecdc3d44790ef216dabe0934a4a664a4e1e3cffaae0a444492b62a954b09a76a742aca8bd6799252a785bcb1d59a994498c769c82ffa484d211377595af29f83af9a33f9b8f1252540a6ee2a65df797284953527016f4925c3f4fdb3419052f2612c54f6645c1f9c5dc94dbaf34e8e0e1e80805abab13420e25bede9b147480824d136356ebd99fe0d4fd57f637992df6da800b68514ed0e1095ebb2477ddc43bc1c41c925f98162dbe419c603d922e696b494d66cf2698e469a1e67e5737d2046fcaf467d7f6c7c8e94c70494fd9e40ea57dbfc504aba5c77b83ada714d24b30392c55292d1ef27f8a25f8ad0c169e1daa76639560547559b885790a756180c60942072598bc41529c1c3ad4e23e6346c724b8b5f8e31b31eb3eac1a6934eaa6d021094ef848c8e1679d69523f414f60c60c2f3a22c1d786082a9a6b4ec999ea80049783526d2288fe11bc8ed021c7ecd31bb2c8118cd60ccbef49d4434f7e8398024e021d8de034e4dff43da943ca0d6211e86004abc12b8bcceb9e47c72c82efec5082418722d8efec7927294b29c9b023119cea94dd4bc6122ef22e0e175d74d1ef051765800e44f01526d3c4cfd095cf6c41c721ceebcba2eb4e372ae83004fb1ad2b43f3c2479ea1bdc51082e67e57491a5ec20042ba23db5ad8e490a5dc0050e1a9e6c98391737726cc720f00b49a530e5a2a26e0c3a04c1994ab595f54d67aadf11085627e5b2720b992de21d8060628d797b55a9945448c71f38a1ffa305b788ada1593fb06fb62629546366d3fbc05fafb7794bb0ccb4f9c07e8c6cb2d4b4072eaa78aa4efa3cbd5c3d30da79a2e7f4f595369a072ebf267597206944060f5c063d12ef2f596a767760b4268d3177ec16f5abc30e33e8a8c349765042c7545a0ac90e3af03958c88a215f4ea2b21d73b0191d72603fc9d131258fef9713904003a0868e38701b2c8d5c1711b225b57ff1451b1278c1c50d0a748e66c0052420811933686400ced00107f672f2159d624cea94ae60a1e30d8caba958a752c8775d631b3adcc0d7c7e049d3db36f023838aa0a116717b3674b081754b225685a05e035b6eaf6ea2a63ffda506d663cea1be7e3f8f9b062684a42fee6890adf92fde810636e7e5a4824cb3b45981a0e30cecae8ae6bd3bbfb69c02860e337071623ecd1c3aa59c45eb858e32707f994d591695e4c46fd0485e943b420719b84b4dc143b2181c5c181f748c814d31668b90f24bed88e4b0a182d221063ef2fa8dd96ec4be48018d30b041481229e4244fe434707071050c5c98fa4d41a62b499e44838e2fb09147d4d94775f111aa91c44a0076d0e10526ad28d15841684613e902a7b5b784a4bb50a1830b8cb6eefc93906369e8d802a74bea5f67ffeef4592d30aafbb3d783e7deb4d0d09105ce72d04188125a648c3916b811faaf6a21bd4d4cf10aec5a0c1dc945a9521347d46105365db2fe0ec2bf62765805f6ddf4e7385eeb163aa8c0bf7d324b093a22f7d33105c6826e0da9e33987d0b09156061d52e0af920ceaed453fa64a0abe880257a36e528aa8a3aff324b0fb4107143ccf5fb5fa136dd0501e743c81f7495a993a7a9ac72cdde81518740263df1aa4c5b1bca63d4d60438f6bf64d4a3d05bf461adea083099c1cfba469540c9a7a61435b80bca0000ae00e1d4b6092d6e49a827e97b549097cad779654913faba808858e24702ad47b2d54590ee16f193a90c0e71044c8bdb1f65dcd11b864392d57cc15b91742860e23f0b529c4226e4811f8c937713787e7583a18860e2270c94a9d48d14e770c818d1fb1b5e4256971371a2dd00f740881fb4fc24e488aa03cfb0e7404815359a966f235d79368aed001045e34770a399ba44e3a2b56e8f80117fc3d04b52153238d469d0e3a7cc076a4944a074fdd7b658db416acf5800d21966bcc53513dc303fe92f6ca1b32d4b10326e6a6354f162fa7d420a043077c090922ea256f8624e580af983daee4b30bcf260eb8bca8a34fc449bd7f75dc805352d3fe7609ad4ad7068c52e33b4144936be91b1d35e03c09fd697f6b9dc65423cd4632d322030ec841070d18b7affeffb190aacf8213622a88adbe27adb194051bb7bf2bc62ad3696e0660c4824d69539e64ab1efd9297b0e0bdd7df630c39e60418afe043bcb451ff25e84b2379d1e45cc16669ab6822061932556d048c56f0371e36415465d18c16197080b10183158c655325a3dadd5b560b2360ac821dbd92ae2fa7a42a7acf8dee95ed2e239b0418a96054a4c9c9f2078931a660a082d5089e9d95a2ed22458b2db4d8420bf30818a7e093d2eb2d49957809cd14bc4f4e5bfae40499925a0abe45e69d2521318690cad17e72dc80410a368b7efd90745809114f41c01805ebd9eb7df1828aba9fc11005fbaf41dfeb4b67356d8d2c2c1a80110a2ec4fbced39b2b928ae2e8030c50f0ad31c7d4aaaf9553e4e200e3137caea67753be9a2fe8a400c31368cf76b24dda453db5000010303a91a7eeed0ac13c5e3f80c109f6433669e5c1e2a9bce826b86c3a98ca21f754a4cf8dbe40299a6033fe691f9591f2f51f061899e0da6fbf52abe4fbab6082d3bfa395426b525a62b904ef19724c97a24e12ffa025f810b47defc40ede2eaa042754c794bc36e9a98a53820932fe645162b973266b128cf726a96ff142352b0926ae7ebeedbcf4b596014624f85361a75b7df6714220c1a5b6f4a4b324791e458f60f3ed72cc19b9bf73c411e40fc1bd73f746b0a63ba3a6902445513a23d82a4b5dea679d37ca4570327da9a4529922d8a094f64f113dc97037115c5e6f48c132e76bf8886025e62b7dd63985db7b08ae93e98ca9534ba5983704db9382f9067d39f7ad8560ef93daf2b28d105c3013135372b389b006c187875022b778cafb7bc31004bf195ff3dd0895589a0ec0080497f306cf3c75a1f29a040b3000c1e48ea5cc2649f78ca32bc0f803fb9927e9896b69681f0330fcc06898876c17327ddabc0f9ca5b6564ca67225e52f1060f0810b9195d734e7db905335d26ca4f4018c3df0b962e6deca9962d10327a964f2daf423b7926aa4a5d4346c24d30318796062aac98a936e6cadad9176c34990bc0bd4010c3cd89ff95fb91e52793968b4e0468e25598071076e82d4d518d592aeb809fa0476605c84ceb7119279bc8fe100461dd8d2a419aa555474a7d448ab1bc0a0032b1a24a49cb2eaea8e36ca66ccc0d145172968c0161478038c39f071640ae197b264f2a01a69280032c090c3b61be32565eabb730088028c3870494d44dfa4a275f90b07f6b3a62447ff7f48ad1a09da8b968041018801c61bb8f83d312ff807bd34ddb08132100b186ee0b754a760992f681c2260b481d32f4fb596db647c370301830de5a997875f673c598db4b741e3d0c05803a7329e92372a4e022fb830247f80a1063ec4cfb94d6ee6268ba681ab89f599a496d22112c3051868e0feb285b28d24e35ab600e30c9c45aad211a692d000c30c8cfd071962d41ad174712307a2d18243a30cfc7b99672b4d3949ca910c30c8c0e6fb243379cebf51df301b03373ad2bd2e26494a4462e044040f7d15d1a46a65038c30f09541c8b6104769a81b0c7c753279426e48a9319906185f60fb5fbc62975a47fc6b24046078e11113c9fef9ffaa3287d105b6d428d51f5754d0ae6aa4599a4ee003341200830b8c48d7a98269ee18ca13dcb8a10005cc98817c035d74d127c0c08c195be03d87de9e28e1e96987a105f64cc7d041ec3e30c0c802e721079545971a4d8f1d16d81c796326216f185740e74c1db28bfd56e02a66f68a0ec96973ea0930aac06bce6221a6f206993354e0aa468b0aadf89a9d62028c297039a4d32a414bff27111a0f6048814b49640ed31b31e8e93900230a9c087a2fc4d39ca43d9f000c28f06a6a44ccc94d5d502a3304184fe02ba69096f49350e67921c070022342321d794253232d078c2630f9c72af37ba8a568aca1000613187915d4af36a95cf5daf8c2d1043096c08e96fa9873df35d26ac050029faf3fad093d31a5bbd448c3190148f068059bf52d66ef901923bf1eace06aaf764210b9c72a188f9ff4c5948c9a6378e0a10ac62a77084a4491f719d3399a0137f04805e321b2c6b0efaed31954b06dea962789a6b47c993123070e270117094fc16a8af92586a89a6448c1c0c3144cce7275f3a8ae79548f52f06ada31a4d51f7539b413f8000d16789082bffd0e3dd31e09ccf01805eb39da26ed639d5b4913f8008d2f3c44c1a68bf729df42279d6a90808b1b34be7037c1bd4728f8ecde762a4ba06072e61a75f22d9fe0f45bea88dc9954d248199e073c3cc165ab77d027833c61f94eb0773a832cab0921c939c1b8baa88852f24df0b9e2080daa214df0216c7754b724ef0c658293a63ab2a6ce23f53e98e04ab9e48b1ad44ab29c4bb02151c342ecd38b765b82c9a92a497ecaa2c6dd4a30394d7e68087aeddba504374a2d26097253fc5d27c17f8dd08ea0a5e67f4a82cfa8adf7613196dc4d24b88ffeff9699ef7e3190e0e4782c31cf1174102a8f60d7f3a71ba5c4930c298e6035d46628651db61d6c04971db7da649fe7df8e119c4a4149b3d32f82ff68317ca32711324811dc774e7921672d119c8e57e90c4ac8eab210c1a9a484d4f862a534bc1a695e3c0dcfd13772e038880bf03804aba1f7c1c79432dd202f52d080b3f430041b736f8e9c4699f6da0bc1e656cb1d25d64ab6122118f91d6f7d62e6cfb11e04eb112be9d19f20b80c49738f504b1de225106c929982b0af511b6904045f7921f7e9789327e80f8c6adb68c7eab7d1cec30fbc67045922aa059dd85d7af4e13cf8e0b1079b31060f3d9c7aa33fa5e47469c005b420c7068f3c9c071e583d3df244526d2a6f907fe1450abe01382640812db4d8a2015a64200236328064021fa021804a78dc81bf0d6e5b25a2259196871dd8fdd7f50e0f41e3df1e7560cb5377ba9c3f5552e2c276e0410746e926d55deabf23a95c0088e03107ded42c4ecc7d3284ea75f09003ab6a31d364c7a0db937160d399507949b5396c64408b2de0c05bcee94ba998ea2f21273cdec0e7ce23fc94d64d88f90624e1e1063eb5e670ef5c9a438ab581bd931f6a4c4653a173b4d8821cc2830d5c9a103fe4f4e59f7d6468f0580397b32521c57cf2070f35b0d92e53f576877c927273f048039323270d41b99fb7bf72f04003939406952f23581eef68b4c1e30cbc66cb6baa63c94b9d3703139210adf71d595a82cac0ae07e193840613912032f09d95425afd6360f2e4cd21aae7564c550c9c309df933b7835fb084810bb5b2d21002031b9a2f495745be53ff17d8531aa4b5e6eceb96e405ee5255b6d6dcd0340f011e5de0367b68470f1616e20227d2eddc37d85b6074eedc9c72b25a60ec46d5e999ba9c72cd0223ccf46de5a6e9742616f80f5a91b3d66fced75c811f11f57e5267d660b202a355edfd29248f6d972a7059416d95ec8c1a3c4205ced6f2b628d3794c810f3993f6bc9162324f57800a1e52e04b480b3d5513a4f5ed110576f3e514c735a45d4e99c0030a7c861063984930eb9026e4c2e3099c9b4e22688eceaafa3b81dba429a7984a9dab83155080210ef36802579b635df44d954ce916e1c1043ea46c9aa563e6b10446dfaaa6bf4a15aca246f050023b4282dede5df90725d982471258f7fe2816af3ddd5624703bdea7bfedf4678c68c1e3089cd064fb7d2d2286c9088c29c91a52d4eb0a1e45e0236e6886c7495a821c041e4460834c49176c73fe7beb31044ea60a91738a71250979088111312747b5adcc23084c122aa44cf22a0f20f02121c7b6cf4954f7a6465a0b6ee45063c3e307ec7dda34fe39a66e30053ee0dd83728baf21dd644b8db413a4007909bce0225be0d1035e350615834e212c49be465a5981070f98aca24b34da6ae51e3be07a5dff4ab958238d460b6ee428393c74c0bd8f10aab27257ea9f032e5db598a794e57a4133669475c10307bcc6fe2e3d6ec07e5433559bf2353da7461a0d1b393c6cc0267d6f955c9e46b68b9c056e47c3a306dc45ec51a5ac2d66b088c08306fcf7a6a74ee9e324b8d135d02c181d3529ffa859324991460e1c292841eaca400c59b0f9a2b3a59be853da353162c1c64cd66964ff38a41003169c46ba9c41ad826e88f10a2627156a375fd4158cf4aaec20820ac973e7857371a3015a6cd182193368588c56c46005e36b1152455256a95b05d7d93dfb3e6570f71055704aa64bb13685f869cc18a960c7dc3666f7a9fd9ca382dd08c94e6737113b055f6661f984c590738818c314b9aa55e52c8dd1d42ca34ed618d26dd6766aa499c0868d1a34ba485cdce1214629b8bebc3751ea79498514c4f4be979a6246c19b50eaf52b8735d2708b1a39b8e0008e2eba5080165b68a1c5165a68b1851618d0220311d0824999ab808b220a46a407b5cba6a2878c8682cf2721265332573140c1e51845e5ec4d9a945e7d88f10946342519ef3bd4b37ec4137c0ac9b736d6a89887189de064ce75fa3ce48f5613ac430c4eb07e9e3668d9654e21493818b07088b1093ed3636a11a62e52e50a1b626882d7789692a9a568b14506228003c71a62648295e456ee27caf276d4628b2e1a139caa84549a218f5ec9b900a315625c828d25d4a5b78cf55a1e4b1435a9d363414670e4701c38ba125cb692b13b6f55de2053236d8d023128c176fab84954526692a449b0976152d46411de16920497432af9313b4511033122c1a9bb2074eea0b682ed376cd0b03b400c4870d952ac8b56e3997edc0208311ec1a70f96a643e893f96b4770324cae5725a9d9444412a3114c6c537aad47a6f4d931825127db2f4af61c82ed050d37bb8bb10836e91c159328fd0e221e85188a60cc738a693fe2798960f74d88a4d01ef48b880836289d79b2e8e468216bc1a1c145dd03ee109c8a95b7c4daab9166086e4da84ea9757c73eac210a310dca53549323b48fa3d1182f114abb64f445cd42fc41804af6bde71b437444e108c972a59225e786bcc6ba4adc0861781e0be53d49ecaa2e91ebf91022fc40004bb9e556ff1b56bf207fec2bbd2c8bdb30c215088e1074e864ed0aa8c90009f10a30f5caab547d172ad97748d5c420c3e303a6811e11b74759a7a0facb85568868c9ea3c50fc4d003a3217bd6504d4b22796083f0902e3f2fe95c1762e081dfd35c53c29412ca3bf09691ded36f8e88fad8e18b22aa73fdf31a69756077e455363b9d0e5c5fd4117aae29a84cb939f0f6197244cfb9dc532907ee2a6dc516370b1762c48133f5a733f7a4706064ceafb42b421be30ddcc4cefe65b981bbe0be9e326d884fbe0d7c1c25b24ab610830d7cee0a524f6de7b57e6aa4ad81fffbecff4ce376e5500397634bae1d93c68d1b9e062e9d4efa13cfa0611349f7ca83e40c7c9410724e976fd4c5941a696660e4e94b2252ccad0c6cbcbe9c734ceb924a9aa3b9487e821b9ea39c200619585189227d6d53236d0c671e59694a2d0656638ab9c9ae114134b00431c2c089b098f64352cc3e18f88f16169479ab4d8e91408c2f302aef87d2ccb92d6e9404de8517f80aa9dee3b9f1235d606c94e609e5f5e29ae4029b73cd6d4cd828114f13630bdca9f10c95a216626881510b651d923784329d2cb0164310125c628658e0748a3997a8a0235ffd735760b29fda6ef2743926252b701f2aed2c998a355e57818da59134354becd1392a303a07d3f9da3b2429b11a6953e0c2c7ff3a6a6ecaa954234d0a9c950c49a7ccbc4446a2c0059d114385b4af13d51a696b218801052ed365ccb81e47984fe0b2b86aba31218244538e14d810410c27703a66a769319926b0a33d3f54d289099c6b6b277dea2cc325303176895e9126253022b609ed96df22799e04fe235b4e503b2652be91c0a5da65151162e63ca523f0f6499d5263954da79206621881cd74559335bc7b3f5223cdb010a3086c5ace7fb7691a3452fb8d3b33821844e04352a9e933aa246b085c4a7731e9979043525c084cfed1e29152a74d9fad915670e4c061e30c023182c06afddff5be8554c2d222030ec84004baf8e2040f68c08c19ef89860abc701578c176851840e02387b5c6d5fed1efb161e302c609317ec0a59b6c95b4e9bc9bef183ee0eabff7278d27460f38d339692d57a8a044bb80183ce04d73e59113a4694b290d2b7a88b103463d3b2fc92b0fbb910ef84c32e68831b988a63a07fc6bce5477fb49e4d662e080338f9c5493f73760e409adced33f1862d880039c08cf9b25e97bec3e158cecf15477f5a5af4605233f6ad67442648af6145c060dd994b6ce501353b01edbc264d2e9631d96825196ddad4a65fff6470a3e68d2ae4e3712832419551b05ef31d7c79052ca8f1aab91562307172b30d645a30c5170a9628c1d42893a335d8db44caa38b6033242c1574a224529710d3223a0e03ca449572363b02ffd27f810ddd5d77c927d9072514c8b0c38c0bbf8220519b8fb820c4fb0994b748a87529f773a199d6092f0fba821d489dcd5066470821beda5bdffe287fd65a12063138cfab497fd2fc752d76568824d21fd6eb5780e299a8c4cb041bbc44bb2490626f8bf20e4e4d23b694bc4041997e0fc3b8752d7cfb5ce58a212ec45d7915ae973ccdfcba0047b27c4d742f2c89804fbaa27d126e73224c17f8dbd28cfcf2163908c48305a2a5f8f4e823e2a03125cacf348224ddc2ec87804bb7efb5927e9e4b9ef0826fa9b66cbbe89a7f346706bd9e79a274670275f456d1cb9d79d5d04f717ab4aa915c16529a5cc3b79ca5ad944f049e93a11dbdc537244f05555715b63a52c113d04679f4fd4784ac92b260dc19e7a89ff1d3b3db68560624413797dc44ea247083e272539550461f69a41702129e5a9b7b1bf4e10bc650a2a684fd5039c2023105c7894689faaad363f37640082af3e15f33af687468e147c91e60f6cd75a249d5367b3f2981fb8cc1941c4d5f4411fa5566b5bf36b5c1c4f34bef01b5fe05824c8e0039f2b55ae05197b40aded84f25e53da480603197a60edc5f4b49d87a4cf3379487b9bb4ef3c92aea3810c3c305a53e4a9ac216e6db0469a17ed5d2075818c3bf096d3856429febb586d59906107f66a74529d3585a424c70b1975e03ce4f3b428f21a8932e8c0765f2a33515a3f9ad648f3c2067216b8c998039719d6d9e46a726074f342551c292a6e70780964c48153aa72678e1fd93c66ec0a32e0c09a0875a5335310163926e374c173bdafe3062e89147c9372977c226d603de22515c911e375cf062ec8f83942eef1d0a0b30626f88e760941d6e566d5c09d4649232ff4594cc934f05d2aa297ba0822f468e05cd2441749f2abd233b0e9af36f456e4aa57ccc0e7a9feab495f414e481978d33962b628f53e3224039b33e62c495a8b0ce518380d316ed5e8ee754a254186183820230cec6d8b16111fa920030c9cd20d79a695a1fd5f20c8f80217f2b95712ea933686d0f0027b1a3e3182b264e0ae0b8c12215510dae45c60359dc817af94b6c0e8a79c1bb5d4f77aa405de5cdb74446ada484159e0765fc732af57e70e6181bbfb492b5a934e10cf15d8d4ea262ae5ea50aab502174be68d21a8282ae25a054e0615d5be4f757fe7cc9821830a7ca84fc1c44598104a3a05b65b35f6a4cea14d4c2970e3253b8ddb8b484a13053642b45819dc4424cb4081dfcc1e2a8ebb2425234fb82f67ee04eead83762a4fd9bc824d6024e75869344529e5392694efb3658d29a42c81db10aa4fb608b5053294c0d6ededa72f51d1b93256909104fe5350a1a35208a9420709ac67b869485abaceeb2338d691d35ea669047ed4ffc9319d9c31e32c0e328ac0b85f36ddd490085c7f705bdfdd5279913104fee45e0e35bdb0b31b0d3284c069845c55d922230849ad749dec723287175c68e0466f607b200308ecc4aca53f758a3925f90363704b63e6dd1753b620c30736c368c8e841c9e0017bf162d555b56ffea406942063079c576b281d7453788f3366b4e0460e2f3c083274c06a66cc3984a0e1a6fa1164e4a0dc7e3175ff8e051938b0b345634e704d31fb1b6c29659b670649deaeb962c84f8b20c49b820c1bf09ab531638990242765041935e0b209194b8aa56c70c181e43366e0281cc8a001972a7808edaca79de41fb3e084243522869cee8490f990056b23729b50e1971c7cc482512958127d13359b5748830f58a0ef6a820aaa57d493b49a3ccb1e4d57b062a7720a3ab5db0a45957a48c242061964057b3a66cc1fdfa4986a6f7cc102fec286aee224355228212fbeaf0a540a75de49fb099954e03f298f28212accb415c93ae8ebd66e9080d8ad59093e4ec1a78ed0a31282d0112153707b766934c54e29188f144b7e1c99b4a73429b80dcb2958688ba697320a46e9fc60f92a9ed3591fa2e094c79f9433fb72d3130a56744e4a59e6a0d1e20414dc79a83e0fda8f4f1462b28db1fcdbdaac91863a840f4fdcd9ad734d35937a1df8e8c47d7082ed3ed11925d5fbbbffb10956c5f24788e62e2ab626d89cda749490d68f4cf031a78da619417aeeeb295070021fa021801b7c6082d3a172723b9d3ab1342e6ed820c11962fab804671da3c6eca492363dd6489b3163c68c0e68b1851612c08002dc1b90fc4af161092e5432f5ddd6a07f3c3492175cbcb1c0d3096cdc6840f2828b06ac81e2a3124c3aaf9843997f8e9bfda0046ff6edfaabd19304f524f8714dfde9dd2aa693241811c5837787de3d8f44824d31b9566ae7cfbaf003126c2ea5520ee54978883e8271cf9e2cd3bf594efa8723b832fff8fed9f4d108f6745a8d765c8b91941f8ce07227b73f09f93a7ef063119c8668ca4c89a24ead0f45b031f55b5626a5f9d6fc48041b64c829e59cb4acaf43b6f0810846e555d08fa1ea53c80fc16e4e272187e8c3106cade68e8a26f4c4d41f85e0b3a6ca9244559b90dd072158cd49f976f613fa921f8360b527dae9d54b3db9fa1004db16d4494c8baffdf98f40f0e1c9e4269deb0720186dadbd1d524c117ddb2f3efec0a80d322c5e103d513f303e29650e1d7699bcac83c1471fb8b8d7975797e927311a7ea38fe10337d69de4988a8468e11e78afa0df752ff8a107ae23951069554bfde9e0f8c8036f1f2b92f094f4c64e1b5d9032047ce081efca6b394dcfc23bfd710756cb4d6f527f69418ee6c30e5c52634adde8e8764ca903636d52cf723a912fda0f3af0312499f39afe1f7360443a2d3f21ed36c6fc871cf8afa064b2ace79dcef2110776829d483929992a09990f38302a26a1e3e8c9b13ac67cbc8151dd793ae712a279ff0f37f021ae96c689e2973c79818f36b062ff914c722af92967cb123ed8c0fe27fd1b542acb7c9f123ed6c0c9d8a984d20c491c5cac171f6ae0fa4d997e0abdcf7da6c166d4f840032f9a9521585ac82dffe30cdcc99824050fd10f33701e296f44cdf6471958eda02455068f9653f0830caca4d8c9d5c61f037e8881099af268efcd787dfb4718d89c967b9f2fb5ed8a3ec0c0e7a0524a8a9b4654ce7d7c81cfec761df32e5161faf0026feafea22eb21f5d60cc3f075315838841eb35d2f04a0d3eb890a6a45649e70d8eae912ff8d802efef9a4ce87e2c65f91a6938b8282df8d00267e95e35d384605b1678ddcb11fa29c898597917366ed0c002ab959b4b42eeed3ca181830bc2828f2b7039989652d32935d2f0c30a8cb0cbfadb552724c96ba4e1e81af751052e26f389969ade23bd393ea8c0a99c838be7f4a9c24a16828f295c7d4881539ffe63786f28f01105c6b5cefb92e9943bfe8002e7aba669924ccbf59c65c2c713780972926f50c92685c8096ca520d4468914dc6296081f4de0ececedcc474a0e8f0be183097ce50b3afd268b153f3880f0b1044e54b99907e996dbb4317c288153f25ce28d6b08258307868f24f01394298d6216eb24db850f24704974344fc1f25d2afbe3089c9d7b56a8a7f248b9113849933798e5ca471118a51db47eae8e296e0c143e88c0462e2d42771aad1ffd6bc2c7103895835d8ed61b5397324008fcf7557592a3a2dc844a193e82c0e8ed52f23d8af85b3a0c1f40606f54cec1e266d3d3e7fd80310f26477f1041552f1f70935f538af8d9470f88de1953cd552cab32b6c7f01c644a2aad91f67ee3cee40a3e78c0beb678a50ea6c55fb4032e551295830c2a4a2cb50ed8108fa2b565c9d19e02143803906f60c68c1933707861e32307bc85a45719f69124c4940b1f386063d6179d379fcc6a9d0ca4143e6ec0fa96fe98a23fb796f861035ea4a80fe22afaa8011f16aae3ba994c42947af8a0011b928520ae51fc63d299055fe7aa5e2a043bb1943b78c88211a637c87a3b8b6beaf400128b42a98d31e8178f153c60c177e8535afe1921063d7905a752b44eca21befe8ece156c0e52fbce621c25540c034660b246ea4d3ddfd6eb8bc0d9e438923de514ab9e08dc55bceb9359a6213f04467b7fc8dcf974d0bb10124a973e08bcd65f32ede974aa4060358a12aad631acfc01db5bd9da366cb3877cc0dd081935633c1573ba075c44d752625a76223c60bbdb2bfba885d276c0be08116c475d94d4ea8037e91fff4348b12d25079c1275e341e898f7c5019baafdb5d2ed4e94dc80094a8688faa7367fd006fc8e8b0879a38abed48051a35bd9399632b402d080514987fc591b29f7b3e072c71169b34f845616acd768659094c782334d4987da0e0bde4d4f92a04fc96bd32bd8db20fb3a23858b5cc1c65115720e21d3d256306e4944922521c81c6205ff12ad5acf4c4d735661b2e0aaa9fe2655f09e7f6df487a454b0112fa994dd3c882c49a86054cc1e32675db749d22998ece1a7b326b72c319982f5b8a9a28fe54bafa352302a640549dbe2dd3a22053fcaf49b0a32e42073340aced33f9b3ca5ee4b098982b3e0b14a864877a38442c149d09031e974b92642a0e0c736c5fc63a15f1ff409eed426a6679ac674234f70597db5bcfb62451a3bc185a8ee649ba29e082758f3ee64ff7b3a68bd092ee55431b5e8e4f94d4db019fdd3645e6a4f4d2638f59758ba2ca9fd10136c0e6e962aa86a3ad9253879273f830a5132a7902538b7aae41f9a45f44ab09f16646fc85322bd9634b7ae3e097ee3faebe9cffb133f9260527e3a2d6a234acc23c175d61c2dcfb4165a487015761f43c8a052c4a047f0174476915b11a3ba8e6037e6760d2286598c368293f43ee249533a9711ac9e5a456c11a96d2e82ff4a4205957e2ad75404a74ac6dd74ffa85f2682913104d1a33aa2990c22f8daa04ee792f9c6c2738833ea7bc7102891b1f772af5308c6ef53e9484944ca09c1760c4aa8d1f126c02018a55df42475775abd092008cee4673a61fe23e4a809100836bf490d299dd4baa0260020b83eef0d162d2c784e13e00f9c68eec578e9cb33dd04f00313f226dfa46356fa7a1d40803e70fdaae555793d8a960f7ca89c83c8a7ddbfee1ed8533a2664ff27c9ab1e182b8d225cbf4d4c9a07269e59b020647b87140f8c502a478a3596fdd33bb0218ae6ffdcf4aba71df87fdb10849e75607469124ae7ad9c7d3af0a92798a64f4977690e5cd0294ab6502b21c6c8811bdb507a648d3e691cf851b5a3e3a83c2584032333d3a95fe40d6c599239ed836ee054ccf27b450c53b10d8c46cfa4bb535e8e1f1bf8f4c9a37e1b9244afd7c0ad5e4e509e1af8b48dbdbb9252779706ae425c2de88b896b8d06fef365c59c381e72aacfc086dc78d994a87863b51958fd98eb4fbf5344be0c9c9b4e4fe6fd92813753e331df6fde7d770c8ce7a9241649589eec8a81c99fe65a22dd30f07e2295debed62475c1c07632f97f7fba5d93fb052e6e9eaea02c45af5c2f70be25bf53ba0ddd97ed026fa6f7d2225ab0bb2c17b8b4e69daa73251d25bb0526b59b97855467fead16b8cccc9723699294b4cd02af31fa885930192fb558e073e8eb9ca87fbafd15b8ac29079dc5ad2e7b2b30229e43b036e9fdf12af0df1dec6490ac224a546033849482f9a46c6a4a3d8d9b72ab921478d39bb3461b09ea465160db4fd53ed8a649395060b37c54f0c8392ba69fc089144aec4bc809ecba68f8abfdff649bc09d90e857f1e4df4799c0a88adfbde5934a2f4be0fc42e5de88d257224a606cd773b0d34147962481cb4f2aa2aa4dc5844860f4a5dff020fcb67447e0f45a963693a4533d3502e7172632fb7cb3e6b4084cd0542d2aaffba54d89f07b4abca0623f0436598aa2eb34a488bb10b8917ac1f4aa53043d089c85a85dc27320b0eb5b17cd6bb3b9e807ecaaa94b0cdeff29f201df22a3c9c8d9267fa807bc5e92d57f5726f38707ac8a4e9a4209ff08393be0f488a42dd557c8bf75c004616aa7195295da39e0324b1635ca2cb969098003d6c6a4e8e9ec66eb12e0066c90b4b6b6173b882c016cc056b0983ea5a8854509500376cc2f5945ca909f24000df824c382e6537b92ca59709ddfa53b424a7e1759b076a6b641c60c522bb160537373b5a5dab44ac28271ef60b28469935992af602bfa75bafd75c82d5dc19767325532877c3995ade064a41cfa3cd5534a252bd82832e56e92af828ff77f27732d784852056726fdad3e948e3f4a05639bf756648aa71ea182cde5162258c58b203a059f47f209a5644a326f53b057693de7c71cdee952b041e5181e942865272505ab19644753fb9c951c05ab9e7b629be40e188028f813e969292d9a90985070f9b369b3112aba33a0605df3080de9ad82b27c820d9ea2acbcc4ed2a9ee044e3998a1576824ba52767df585fae71823b4def29a538b6fb26386df17b4f838d95ca6882179d420a3287ce142d93894e49ddf7cd31c18810fd4bfee8a5892ec14634f330f75882d5887942eeb7128c58048fda796b2f4b09d64b42889663b77b26c1f6ada5e7ae24f5488251da368904275cafa4e45ff59c16487035bad56b928f607f37a7183db9a4be388213b2bbc472d48c498de0f2ef5a2df3525c0923389d2ac4f4b499b4bd4570a579d3798cd1f46e8ae0bf2fc6cfd024a94f04134f5d4cc92cf305218249e199cba2e6113987e0437f4fcadbcf905531047f52624816c5358d5e08c69274fdcf55999a44083e95a70f593364af67105ce6da82e0b296ce9cd492403021e8da8b360920d820f9435dfa482195e40fac961a651994702d11e2076e74aa3269e5153b47fac08a12cacf54be897d113e70faea6a748708d1f13d70da293394e4e49a263d70d9572b4d06397ea53cf0ba397a7b42dea04a78e0255be5a6e5fd7fe80e4c7c5f4d13f3b8396407fef692a759882d1eaa03ab55c2237be8c046fdfb1c648890b4670e5cfaece6e37127e7550e5c921d446853d58b6b1cb8c929489cb89722513870912708cd19a2e4ade01bf894e9bfb265ee0626a8a50b12b462d0126c03972a752911dcad830ed9c0af7f3c0f31e5f59ce11ab8ec987b29c343c8ba1a38fdb739bf47358ba932810fd020c100d2c09659ba9037d9b77fd0c0a88c1c84ec4dc163e70c6cbacba944e47676d70c4cfcfc94acc192d4b60c5cbccdf849cc92a62819d8bdec185449ddbb730c6c4a691e1273c8184d31704a2b881034ab4ac78481ddea949426ffd5b380810b1e3d8bc48e6842f805be4b822a617b810d6d3a5a43e78917ec029bd449cd1e6348ae8f0b6cc564a62fb40546a50b6943c94f0b40184016d858395c6428a1165387055eaf45555cd7d45777052697c7ee4f1983bb6f0546a89b8a14325ee8be0a5c341d4beaca2df26e546034d9d88754973aee53e0b54308b9a69b774752e03c6ccbe2e6f5e09e28f0d1ca74a6fa483a7aa0603372004fe0b3ed56d079438a41ea047e937abcba4e96f45e9ac04f2e254547caa55e6502e7d9efd746dbac93b6047e4350358f9272168b2981c9196a2f51f34a12b124dc5929a8a44c6848602c990613f61ad2373b029fafd6f92a42cc296404f63b6e124ae494497e8ac05f87b2e021a6a63d4418c0106c86090620044647b030192369d6741058fb1e151d2d6e9206022f4a74fc983b6e08fb078c48e2f53d9a6f93d6075cfe911ab3d268d5b607bc9a0c5db595079caa0afe41f6968cef809131bcdd2c7e854cea80ed986e25541c5d269303de2f8ffe18623a6d161cb039fde37a5ad0a32637e0f7b73f834a9d43fa6cc0c9f7cd394ac6b425ab01b79b7a5574a6d8e901d08011ebb4ff2131df320b269d5abf0c9a6a4177a11690210b26554822a5309142751f0bb6ededaa72c5b0711d169cdf7755f06841a8ca79057ba2927e4ac2e30a3e7de6f2fe2b916de956b063aa6962bcb4b7cab082f532939e2d5d7bcaaf82932cc1335a44ffdb8a2a028daea8b4b065e2481c0e0643c150300c86e193d305f31308001838268e4582c188a0c9c27c140005462c344e3c2c121c2222101a87832261181c08048461302818080302c140201c0c0fcb0a3d0f70ba8f5f491016d864f976f89f9f6cc6117429941c168278c0b9b07d0815e404de0c45821520e670e1e5139aceb8b6510afd64fcfb39e4ce9fbb2013ec291e18f7c24987cb2b154ec964de2daae97b54239ed0ad7351dc81fbde55ba856e92bb72ffbb4b17c79a275646910142c82f341eaa41b97b68e27ac682828f1c8ed83a29f60620933f7c98077ff8c5c23660953125fc191e84fbe020fecf5a5be93f0b2486d02df86a78cc77b6b8e483bdd94b2bd69876c18ea9c3e9b8bfba31ecae906f3034c80c7a060782f402fb1d7c662be5a09df06fa80eac0bcd3aae9906d46562c1d45d0c3f2365681b6c0181b3efa37c48116e0115b0e65eb8022fc6863fe4a0d763f8b5de50f777e8caca8096f7719c8de7cc137b751e9237f21e3cb55f4d48255409658606a28d3c6a5412880d5143821c3e4bbafbc486aec342c3dd306a78126e0943c014bfdf2fd9ffbc768945ee80761076b837d7b9864e17dc05fc42e2a17a082bb419ea09417942cfc88b78ac3db41025e402cd790bef83b7f570dd4f45ca0b35c1c20e81b9503d647a987a15f4198c099742e804a3b7063ce5b68c772b397239073d8303417a81d3ce2f0b9484a6c08f50cbb5f9557c4a2e5edb70cee08a250e1e1d374c4933347bc6402890220472ac522af9fdd060527b71f1474ca16e3143847d0023a34a28333400f989c245b4c8f72f13320909325cc1b101a820efbc43c2d5a4655adf62fdfc53d0f5b676af1c79cfd00bfe584299a141e82fa41eaa87cc1aeccf08436b9da1e03067d8273c02a7287f9a631cf4bf3f725e3cf5cfc5a076eaac93f035292c16b610ca441f2f119c84a661ab00cc102774121209354308a15dc876c2bf01dc48c5f7512f285ee09a81af08882f2eb120a570cf3f5ac4e9a94703e96d4c5ff2c32cec270550797e4294904b8893a0065426c1af2b1c83ec1fb8460349ff27e0a12b72a9f95304a5fbc2d961f4a20629415cc068e654e214fdb546c9c891cee1cca69d54c4a07118669813ce09e1de0915941c0ce00fc382eba0d3a06cb01a44014e82766a5c03693bfcd7112c0272d12f62eea86ff4ba7b6fbec6b15e309a31356a6562f1ae8badfb56acadcd8aacd5cc747f2f97081490c712fa1c5f8a39ee7d7220591a2265feb4b715eb5f0e2ab1021add3c48f29fa4b4f451ff77bb3c8e8c08701c73b9772e720a97b8b690712a86b69c3875324825807cf72b681be8888ad73b25e053ec152aa72a4f20447dd9e25f5c4f910f5f588d9d391373a491bd0f4807514725378a640fb1cd88b9917cf0329a302a1ba8b535dba013232201cf5a5b87e2974edb1eed80a2aad8f699e8aee1773c94cf5df2063acc00c022b9b900db54fb2fb96be32f8bc82d66c77e572182a8c777095db6e84879f0c1c4b91fe6443a4ad5e4722d66fce13534d8d5ca091de539a65b59985e316c2a8cae81fbcd2ab326f80100310aafd155cb3bdcb99ad4ed9a9cc445b593f849c592be9de4ad3ae91a3ce030e74ad4a5e55c39d6b5faf9597614b79322e58f91828ee657da92d9531ffd93648bbd4a812cbfe527ba142e6b4ed819d968642400a1d9e8150b031e7653e983d2209e94f8ca91f889e33ff6f624ae3989c830eeed45ef2dba9d90422194841513e6a2d06942a515724111cab1d812ff6057560d02cf3f4a90b1ec6bb134bf5bd0732520061c29e3113b1bc40f61607a7a08c1848c4aa153b27c708c8aba0d9dbc9f713e81d7ca9032d8af3396d032ac59ec61a1340280c58d192117ea89176d1b7b498168928e093ce7eba743e3ddbadb95acadfb5ed98da9af6ef7a3db279ce88a6a7e6af10cc06cdd5f2c32456c144ece54c0cc9190028d80926471a24623796b91389ed04f6c6f566d0e16ddcc8959a5fe8e509032ed539b38d83c9c803d6dd24db586f08fa8f2eafdacc79eae9d06860c42e295e0d05bae40b3e46b314daf094539bf80180c0ba573ba1835ce2964cac961a85e3c580c5feda6dbcaa94b5ef2850c357302fc11dcffec3860800fca504e407b72fd923b7cb1da25148ac503fc90d4b3b4e0464ff9ea0dcfd58dce9ee043c6f49b1ee0c1e9239c8c5a547805f3d4504601493944bcf9307907d60182d40802b9a1feb9638a14165650c081d046848e0811270465a18a423908f9115236217d0a9cde4f16ff327c68710f33dcbbd31c94af58edd4686cefffe637aefe4b6a405483c7499cc2e07035820a26473d083cee6b561c953d1a211529e8d3ebe7407ad73fd316328e48918d144de870ac3221ba37b63165834b3125ffeef762e3434340140c7273b808311b62dd835191475fcf0f3aa7c5aef663dbf6b955b3308e298e85e3acea2ec7bd46a2f949d805b6492bfc63818d05a83342614185ae81061a9a299a2851a5aa490088d80cae64deaffe05217fe3b47893f8664bb16c2835e803e8e9d1f3927aa60a5aae012d3c5751a50295019481192141219ca4ae09b6469bcb85f67ade63210000e10b4c56ad48c66aec4a5b1575b37196a23dceccd8811d41571ec328ae81eca57a7dabe1a4f635b5a10905ac8b32611af6ec7c027d574a090559633b95de2ece656234bf422f2f9621e535a6e3940b322791f5f99c4ada6ea2e1ec3e5b4e715a660a646a68faf9cdb92f5b36dd7d602bcbe6cf4390bd87626a1618c7d9751a3f40a926835c23d525905d5d5be3b9ad2c6d8d02256d755f6692f0f710c054064598e0df5d47e94192eda34b7c1603c8732d6deeed3e9efc0ffbaea61e78ecfd22a2214e25ce8150096d90ca5296849ab31629926554339c101dd6f88160be726314416170260887ee0f4834dd18684c104d2fdaaa53e351d64c034a730af7c3d3c8ba64a11d6c121aaab4919fa90994ae1d7443dc4b69dbd7daa9054592532b53c10e36207650e0630c1776d9fde6ed60a97a248e40f4a42ee555341d860e64a3d13955da00c5b9eb23d732a908474ad49d80f2b0d767f813add37042b30ce9dcf8eaac7d7f82f1100cbc123cc06206fd97e78d155decae172ae58a8f6decc3103587d4d0cdbc87722ad7f9129bb66ba0954f4649f4e224c362b9e31fa9f88538d8c39d3051d2b68475da531fc0094ebd60c52ac2e38170526fc4464d64cd387fcbd677f3ad0cf71031c179b0a5a1ca049b86bdfc1b55b8d926340e1e42c7e6d3f9c345f84ea7e75d7f9247f8e116d9099db5cb9d53ad727af78fe0347643149152c5e665b8b402a76cb87ece60107201bcccfea7e5df35d6ae7f075186a3531c667295af6ed3fad1e528325c56f5dab99cbb470d78c502bc7c43a63199b0b8c573ba3a3b6669dd25074bfd4e3e6b6241135cf710f0a496b9d9fa1f89d68504cf65da483262183aa10a9080a7f95c62ab7743b55754495ca2361141f35b27d13b898d4fe498819789574301584fff2be37d434f7dbe30ab11d8f603c4648e2a1c5e36ba86d0252a504ce2408cba2e9338bf0791b6d2c2a9af4da5d051c906d5b2f9e86cfe91abdb7ff281adf8f188dc48c15624d70f908f33d9d7e288797b41b5846f0dafa65b4bc8d81653346ebfa19f3cfec6e3c743c8306255eb6b4addecd55feb25392f55597f20db544e1dfd3260d71cb5d44563c657a365e580bf8df1f9fb3383ff4d1923012272d67427be0d275922c2da74581c7ca846600397a2e58ac1548343cb0b75d07a946ce2ca9f2cd5fcb7d3c642b1bbc4a9890a6e16093d3cc641443b7464584612baf3bc824341458ad8e02dab48a833d4b6bc32822a4c17e03ed5c4b0fc9cbb95968acadf06880ac2c6b14492faefa1769b704c89b202b27f93d3d2c675951c6f32f07d9f96718d55285f25be7973aa2adc73aa46587cd51353b1f17b3f2f5279aa86210b5a9c3b18bd4fc878020f0d2ded14f6011188453b857bff2161ba5a6c73040350dcac56f6a0611917619bd9ad03a4ab53ac8e737b327a2fcb86e38ada87f115058f64b4fcf2798fc10e690bdb636c2adcf0355b28b9b09110c19455d8aa6d7121b28d76797d2cc6ea797dab4b87c376127b7167d51d2dea67d7f288b4d10442a9a817140106ae9e3ad25041c94e40cabd467172548b8e5190b67346aaae4ab45253f2aa68cf3104d3982c2912e086d4681bc55984be9b8d2e578e69a8b2364dc8c56a038cc7d7783b5f67493afa521eaea6092d4b764854f9946100ddf67b775b42cc84245dfd1152893d2d11a3a28c42d52a72fcb1a833654a8a548d5854e725d4c09611b9f77b0356fbf4cd4aabe061134a0247667b231855219b21d394e66a3a8fc3b8d330aa1c60fab3379f1a93d3c2323c2369da8493e746af60547391ad642ca084c4cf179cadf35ea3495c2694ddb220395bfda006f6e31119c7e02d0d66cada4dade822b09ee8601c3a8d0867b09b7a3155749df05fa874d12ce557e3c9f9fb2518c31a1e86686e597e20a72b5a3931883fe62671244b3ebba5f291dbefb72fc9190ccb37016c40dcb635ceb0587a3758a6a3cd6543d5182f1982f0347fc3da6c69bde2b636f27cea1a4fe6d8cca77e0a54e961bb4a01164223862dd4181010e353d3ac76c414c3d2ba574f8a12e4d0da148bc0fbdf07f41f85b2cb699ea24c5ce5e8e9d0ec10cdcefae347e3c4f2dc7e1d36e182f5c3539a68c01c94a2d2616c626236b221ff9280f9840b299b1dbddfce77080029fccecdc0ca27826ecf4a2d2463ba44f33e3ab6069f4420ef133784a51e4c966cc107274824dd62d0caccb80b936b01dc483035a216c6c4a3c88274d5a2179f93c3c06b42c1a44249a90c60de23bc4314f3b316a0b0fa55568f668a8aecf609d501e29e9277aec0df93c809f9638c40d766a7efa69528bc9d140d52a9b453c939f6571c095113098ac0f2001c41968da1529510d14f915c25bb1a416e5de4fc818d5769f94a55746ce3b499e2199309f965543ea3a25cc87d35d8aa2e8528e878f0ab7bf9eb488947eb87551dee5515f45554a98d2edca78186a4127ff35ffe5b4650e75d940c2efa3f9da2572afac1bd884f1a87a6ca08cef4d44a065392a0264612ff45c229b3818c49a86d28f9ed3acc37400a2aa010450f186d58b103029dfc21d456be086c0f4d8aa5c8f75d79209c419c3a92dba7af37604205779f82885c043791c7ab58cfc4e5686fe831e62cc821d84a7a992d3dfd1f5528c0be028cc66a8d13b58b59a959639e428cf79b244e13b0143ca6c568e55000a3eab6220ae32552799f898ba569dafbfca371507e0799f2a873f1b8590dbfe9104d72f481b53e1264eaf7d617691560a823feb120806f0c38bd6f81d6b029e9fb0fcf1be4c6e8cb494f8ee4894ae4de48857a17a64ef09a06160b6a3cfd373f8b0564f6e364625a9f698e29c4770d7e58aca888c1d351af4496ecfb33ce83a385656ab9cfd8250d6171474f91b92a3a9f57312493ee2f895f6d2b591cb849ca9c4ddd2ea73e29dfc7a3cd7e70a9b08a601ca7f4efc11b1ee83965cfd819e3323459c45ee23bfb0914bf361928412b0956a130d3faff8a0a135eb985c1f0c2847f1a0dc1160072b506076f8c347a7381852e0083ae2989217dc6b735946d5e6bc029041e780d9d72b757e506cd4e08f5c7640c65c997ff331ca9a0585f63b76c38715f5dd4f15c82ad2e68e1e450d5ce7ac2df7d175fc65a0158dcd02dff4565d8ac24ceeaf885458782c7cdbe78407d742c099b77d4c3a3405b58223959807db53f9a3e62d9c1ecbe31fad605cfdd4778bddf4a4a8cc8eb5b4bfcd18880d8407bc56ed43367b6e37332ec8b9b293d5abd92aed8ecb341c526874dfb6d3ada44b409caa6924df96d72daa46893cfa61d9b3cec66cc096d72e42e2721e7ccc2ab7d88e336333af546f03374c357f152153c391abc353c518c94055d0fa1c072bc965cefc95e1c6471578def335f1a371d63f62217f7423ffa45e36d678c97c265598ee00701a19636308103c6bfb6bd220e5d7b71bcf61d3e83f1efc7cf9169ba9330c7a6330cfdc88404af186a05be6e90e38524a116786b4585acbd4026c64ccd092acdcad81640469df7fb0c38d690a107e1cf7a305e41fbfda779e4aa5a3cf11d3f0cf208d4a2d4676e2d123be85a9b62dfc6205ee359cc382ab5dde4ed6dc08fd39666181df734747610c207b2d71158fe8e75b64ac8de9528ef107d27ee5bdb83d88d6c328de948c0d92b9949b6c8e4b0ddd6662041da419b333240515dd66718226336a9728fb205414515bacda8e0e8888833465108b42a7da409b4faa1f4da78b611c31ea4d42fcb76736363e651c0ec1a097d47561b581ac3f580378ac39db31f9eb50cc7978e8a95c76dc702a4f83032a80f3721119e1a5c15aaac7379272073e52cc7079aa5638e3b0eb673c46c6031a58323be060cc195b388f0e45b1afc45e0df96f3ea6e2a955d97a47343e62ad193f6391301541db3ba6301b3faa16466351582d9444e695a5d178ce842a6bd6f7a92507c2f9243a3425df218082be8ec18f288384d2e073ecb93a87212bcacc7f4bd470f2ff7a4aa70597f52b4812cdb4ce79298246b2a6ac9b1114db1674b65f44012c6e204b51476eeb1879683190667d6e73a00158102033024595516da4def680cc36dda08f18113e6abf6124ca84915a7a810125d4bd0b78316ce44c95200b0f154699820411dcaf534c49b214ba6a218b991be40ab3b5e383db51972fa382deb818902d46f16ccaa034dbd26601fc97e33b5b536570db41eb00dea66509be6dbf65fddccb36194bf20b4cc371e0a080969f0fd65060bf0e64ffa3928e36ef5fd246cbce35539384836efd3d5ca23c473ebcdae16a36878f3cb06abe378975d565e0390c76bb50065d890dbd386d07a044f6354f9272812b4eca08bd9365b47b1be49de0e3b3886f16cf314641ffc15fc508f46efa923a094f3a8bc375bef412450298879b4d748677208e45769e5c8992e75a1f5642b2aad4d544bf02a72efd5d55e7ddd022f8b0909962a9b16600607cb0edfdbaa4b005b6a2468d51549d2cc3ae5764747baf8fa223eefb5e73fb886bb6b4137f7368b34a78fd16ac34eea55d574c339c0b9b48e37acb522f50dd37859a2573afffdd9664864ad496e8bdba7da1b36bfc3b626c5d212210360872760727ef30da783335fe8b1737c41017bb00ee45401ca59b5cc4eb9e92153326314b4469b3556eab840fd0c21e8ed94afc1585c2b84d973d007ac707ccfa198b0e02a4f1858a10a54a08fe0c67c9d61c280cb6a0b72649f15b6ba258e1b2ca093042dea9c5f46394541633b2ec86a17014d230bc6ecd105b753cbb8cbee3c07b59bb7c800fc0ebaa46f9dc0335ab5c13546de116806b87a2bddac8e24c609c0b6f5f9304197a0db82d6a3a4eb675212685b89d1a64972b656dc9c6b691f30713708628147ecddefc1a18aa860a8adae579c01463f9a362976d069aba9ef7580866639c7481b9ca9933445abfcdc445678839157645b6f9949b0dbedf07447f3b78b9352915dcbdf74ad882ef2c6054bf4d017e90383a1817fe7c9c5bbeb3c7a1976b22874570436d64332500b67a511d6308ccf9f1230493dfd1cd4cd03d3a6cc3ac93e14145b7e368d87ad4fa8b21436071b910215b571658a16647bc7b64e2758ac084821ed9f00122b45dcf4bac0039020299be99987d90443e68be7def628975479732951dcc4ad6b315e19519b3f7eeb329adb56f0af64168e669a8d7ffbf51d49a5e20c3a1abd676e73ea6c0ea9ac04f7cbe3efbc8007f219f69d05deb114d617d0ad815833ba716b12c16467222189bd1102ff13ffc759ead670b5b18868dbdac8a85750fde785e1a23def49794d5621f06f9826b78c9de596cacbffa02fc41a3e0797a160bcac175a710e61ef9e5fa8e3df44590bb2951fe048140cc9afc38a1db64005f3c8bf8006694eb8abaaea883a72ec2b002eb82d5d394c87e29754bd29403913b45c39169d5817400a1f924614cf8573904e5185fb575d2f4ced6d452fb7e8d5086676cb48efac17063a740666f0a2993ae9a816535792355a989eeb3265a1c62dc22de1a4a7648672edff76dac6724b005471ab3f62cb282f46b975eb4097ec61a16b15491a77c17fbd01163f5f219c1df6b953e4ea807edfb3813c1fb4ce69caaebd4693e26089392e6ba5b6ce4c8173220bdb8762ca36d53170f2f1ebc4cea5e71a82a1ae95f4ad34e81d1b01d1484fc24f4e9df436d0c73a204297ec1f716922e77e7d8769c61e94cf51c2ec5da082290d98c83304fb0060bbf7b33abc96cab0ab3117b1bf6b125671e7bf5a6bdcc532752be94c66d0c0090750151f90bdeb24ee63c26f540fe6020cdfc12fe2f9eae2af22a68d70b15ebdc4fe626a6a0de792d8a375e826f45a848181888b855b1b73b213ee52e0843550179e1c0a68c6b44b0ff3c07f309406e75fbe33d904d2c3c940c24281a6a46aced01dff8ff905128a46165688380e0c2d209a4a109b1bda1614a5fe380d4101eaa14780a43602c14358b6567ad16b58007a1a23d433124b0d888c6ca6fb8fb083f403010f3911c06a034c033b82162f797a4f99b7ea3b6a41c00053b4df0b803d0d99132ca704882dd4d20ee014e0de7e708f83e974657f0f6da0f8c8adc6455792fd900e69ecb115f9185c626d200a45851c6ee269deef68858dc0f5309ca795fd5806d6aa533e1d03383b27e1d6b300040f2be852349237d1ac4fe182cd00eb1a5c73155c35ee949e4846f8d95a89c7d556d082427b686b4fa1e5ee01da1a961ea52b7588836b10e6101145db80d327d0584393592bff00c37d0c7b0f6cd9805d1ce70bbdaaaf68c1753477dc7a175ae0a0254471ea334755e8f07104d2733614802d63b2772c7727e22a3d2e369b53f5a8eaff865a68f90844a65f474e0ffed6b9848286a93331f8b57a515b1aac94f4b1c4b75e99a7c5140efdfb2e82d2a4a08adc40b01779ccdedda1a5fe6a4727829a79a5d082742a0771ec88b82813559635d0e758ffe82c80991473f724bc61ab29665c8480e53e4d4bb24ec1da62984b4b7799a3c10a2c9bab4d2be89bd0b971d8af469aacd0673280eab61fef85d8119337f68795f02571822c5606e764a197534e24140636ee8299a2c66b4bc1f019f9aef0a91619cf8258f972182f4f0032c9dbf71834c41905879c655c06dbdc0b4f166f62b38f711c86952943947da12603096f5c51573db48947358515143519087ba37c1c07d6be56312e29414379b8c4e1882f82fc2da19e509e400167febf68daf17409795f045f1b7aa9a09a5c25f7f21e0074921f1fd0d0f7a35dcb91a0e1640aac10c004c131175f4e93fe877897378ee476b417b1d9a682edb8b454f803d681e7df350bf4bd9e082b48ad60e02a032df1586a11a4b4916e19803ac6a0e9b2f2ec24a1e0010f0b3e12d8cc7a97ac360c586bfda0b4487e1ac1f08601acffbc4f291016d0f510368a51eba8b8574ec2184e4eec92c311c486bc1188fce8027434708a46c2c3f21e23c47e5d5a49e9c20448ffe258c98258ca7895d89905580a01ab089161b1942121c3d2d154492e6500c30032b7f1f0734b2f007f97e089e18f657d045c830b8c63b159a62c0e2360a3081bf0668c8ad6004dd9ace0c15601571b14e954c64e65133f07cc87497d7548b2f2f0e484e2e7f795cd067c464686548668f8d81723b8427d8cf85d74ade7e3a1a36cc6d140f73cfba4fa88c2c7df0548762eca7ec398889d69e9440bfd278419e7bf81350c4ccf000f2e83a5e069e2839a6fae4f8faf1f1f24be217e5438456928a1835a9f5d02df7973421512e1c3a6f7712b583ebaf2c02764d7faab2971645037b17731bb2f3d408e4cbe348a730714c7942f01ea9e8187ac4b320e20c24199ed9b549900952562fbd7434579645c1788b96ee5ed4be32339a3135f52b209c90ec0fff9e1e26a908642c74a17b79081190970517153859d2029c148c457c04fe99d3dd1bac1961faf4316f2f30c221a26846cd1b0486802e63df3143f6144555c09349abe3b8521638cc37993c48555ea5f60de1f857bc366d711f17f6890ca5a22fd6ac4f332cbb5ff5ca6a9c1e77c98c06741a34499f44d8c6ae074715a0909283a28637c1f24f5e7381a1293fa8e753d36ed198e9ea70023c3cb8be0e7f7046382b1d38d61b4bbade954f907d3c420066a9cc37c5906bc702693d6f7e9d0666e00cf7d66aaa58d5097c1b63b20e192e11214076b048b7b23c765f3b379a00b0471a5a260aab879057cd630cf0acdaac222a53a9866da61c97841ea67050addf463d95efb1b46b06a21c717624864a23aa2c512c1087530c60549623a53df694afa694df24e9ad93fb6a2b5637a187d9bea30ea90cc0a245215d26bf8cce53497bd00441e1970918924562eaf68b547b0ab63d760205927ba5451acd96d80c51edfc163247c3f0d7fe939c793bcc06601dfa1ddb2274448c3a6279076df8b779753685122d2794a99a2598b14bf2c65b7a1645aaa157a8d002eb3304a59e0412cf8d3f8a08c283ffd9ed82409897e26f5c4828772659ab347e22d7e921a3237b51b16ea134909f332474f7cbb3658a9f57bd4f5e45812aa9767b7683102993db0616192740fab0809566d6fbeec361733b792e475d96b7b26bd2553d603da20f78400fcdb5965fd0505473174ef239cf39407c7fabae2f6662ac2e3ed5f07184584dd223bc8fe908a4ef10182ed367f32da45153e78851d45175cd954598b5263540bc9bc4dd2c14ff169b1d5aab148f0d0777c1c321776f0d5dea17437a111371e9e61bad0aac889c7a93f09693fb519c96b452a7e486fe9184ea4e906a35619ac5fa45ec82e07870f7090cc049ecc624f37516cd9107920635d45641b65b45b4a1ef581807774a49f31104e6971d4c71413156b29b14f39d5fac2180d2e6de38004296f63410232d95ca1c11dc9f5b546423f6e9dd8c6e4bb659b254bcc2482ad9328d1c44384237390af69c2b65413d703c9c9e78d588adc82415b55933a0d42d1dc4e4232039f2d369bb16ab214b2869ef1ff231d7f26ce8456fde1e559af494db7d3df30e3beeca0eee54c180e6c9397894c6afe93330ba25821e23aa9edb29aa939cf10eca3754da50d4c6038edb04adbc05d7638680318f5183cbed609baaf7e3c5bed654fb335ecfd76482a56b98005c10206fd665ab4407a525087a29b3d42e122a45c9e3f743ba6ceedc466a3e86305a39808ca56c04cae69a7a205ee907b72092d4fd889c33e105ed56e485e14bea958ba6f6cecc7cee673cbc84bccddc662c2bdd334752d9d5b1f0ecd19f8e3a01e69f44a27a7ea05e16ca234905d243840303498212a83f9615a984abb1309bc07eb64ca98943818b9de52ecdba481e46d4b64f61d471af7e0c7b0e054be389a8b1b7635c284000085d81684e831b977f0a18532dec98d1883d7561293bb43949408d057815d420fa1462d3b16f417dbd0d94474016c3187d406a14dd9cf2700f21ce0c4dc7d44e8ba2d66c911484b059e29392c845c795f5e319ae10bd6fe2815d6f15787f08118fd6047ce993441f85648e3e44fb802848429e33eb08096d46aaab8807f48ef8e3f79d602445b4c5816b9942fd7075b7336709e2232cda8415e9e224dd891441bf4849f9678362744983b0e2348669bda4206986721d6649afb7817dcc1f6a50f7a411a2241984425887dcc03b83ae5f7ee320f4844dbab088553f4058b2771226037ce7faf4073f0f6800ef4a8d69f73256cb707b152bba4e470d57ce9c142d9f288fecb1e41418f2ddcd5e9e5e4d3bab4a23833d5086bcb4d97e6b549e465cf603643e3a523b48e83b7ea2f3a2d1fa015f2779fe271c6e7efd34ff100048dd842571ab924add6256e142d5ff9f192349151ad215129946e8ac62263165f27cb58d0fce9771b92fac71305d48e56a627c91dd530e6dd2d8dcd4c2a8ce0ffdb1038e75d33e7cfaf85ee3fe31e21ccd5789d53c9c9c8ac0e58456e81ef08203088b04656a2f6c1772158a21602fb5ea06f5b9a85e3d033d9e616343ce928487d5fbb87aacebc0323bcac3b41faadb610aec92a3777686a4f7e9b72d358e7c388055975afdf31f59935d8f17d9019d41cd52a4da3755bcd07dee3829ad370808726e96a7689b34f59f2b93b0331bb068990770b5b7a74abcf79241788ae04de0a3b1225763ceb094535841f5e22a9f26efe845601e7f0fedf8c0fc8c4dcaba9c98a06b8369132df4254de30e5e641ba45ea43acf7c410001e92a8dd1017c4ce3bc09fc4f7ac11769b14e0a86626c7106ec6c498ea7bf3e975eb3d090bea00ea65dd7c91808b0af15221fe364a398b81bc02c4fa6c5976088717eb70603163870be2e2010359a1b18472194128c47782a80255c8b1eb3486a8122aa1a2c80a870b1d24842ed7367245a1177a0a670dc2e9195354056fce67b608ac6dcd930e007c873bd9a3b950b9cb0b634b7fd8ebf2027fbb1e8eece5b82580edc5fe1fb5be43fad4d1c4c235f6b8376124423c2b2ada5cbc80b0a23a3f571d6e9f1dc132c3a6f0c5bf03c5be074ca18c266c9ebcc9da170bbcdbeab38ae09d061c7060f1886d5c6fd292ab2ff6b0724683b17211393e8832ba08d6544a4094ddabffd05cae4206813246f5c6c20d134680dd3a46285810fde053033d8eec23708a709b17218338e15af105d5dc938c2d4c52bcdd903815630bd56ab09e79a1c0b437343d4dab09e282a56f8ca297a8fb409e3eb22c561ca4b9a30e5aa490f90811c5b2718c290d9b4f040df8a3d01e70d4d8a0581103cb713db0d670efbe41ae8dacb2408d2d1987938651a2c2e850f523a642df26a789abe881ae21d07fb17059c355cb0a945840866309e783c5b7590829ebb1363f7d38d0cee8f05c27e102e268d47c7b52f737e0a8f942846c1f1abc1a9ef4a099dc2893f1ca01a0458735765c8c3f08970e59a4a33c3f41b870d23d9d772956e00aac8276152022d503d578927b9a4d0618425d3de94bb6ff87601e68630b21ac07eef95c708b0ce07d90a80dfca2ddf3c7213140cc1568a30596d1bb093fc64f85ee6e68ea7292d435e11ee041e13407c11015a6a07386ff668ef2bc26a7af9467f672845016982dbf37d55f368487ec60853ae288ec3037bbde789fd0102a4b25d120210fee66d60370fa2c5cb6b03832094ca8b7c5db58695a0f55a0e8b80dd9cf61ad05abe543af922d094e8f9bbace9a66b18e8185a2717ba8f94cb303dced1e55cd0ce2740a822a44a71fb5625ed980872cd5af1f126f16f7dee4d591b142ecfc77ee26d8f89b7aa5eb9794dc1b98c7e3e473a04ca094ddc8f92abf9147b9dfc9939a32441ddb816c551eff16163beb5ac283990d0eaede71a5b27803c4e21a3fa87c633242ec80af7d21883296180f29751338d08a21072cf812ad73e699ec72b1f5d7e2c62d44ebd65a7540a0da1c514da27e5ac6d3cf13ff5499c161d86876f49659e7c90043b2324730db637430337939a52f5fc28fa2b870066e3b1053fcc6b80dea7b5a179233b810443514a2bf0b5eeb1f533ce1c9c3397cee5b0f5a3cde27d6db953bdf87a7c99d10d165ebe381fe6829f61f2c60890eb7956218a0d0d6922033f802638d5076bb9489a376b6aa8ac67f25c4280922dcad9819583756eb7714b40b86bb8adfc21bc4268a4f8a1cdf12708080b7b98456eea30a55a6ff8bc5097b9e586382c47db412e438de5bfad90266ee2639c3dc2bedb3a94f9a84dc0b8859014486015382105ae040fc2514ec7802fe4044df0a3760b46439330f0f0f0f0f0f0f0f6f706ba4b6d6368024a49424a9adf153f8ee9029a594648a8433d417ce4cdc86362184d1863fda080d02010bf40ac50ac9f499f2b5ab325cc1873eb19c2fda07c868051b529a92123cf3a59820b00219ac6064bd6b472a993a476d6ce001362820011b5bd880c0183256c1a43e4f3166e855c1c61acb9f53da53c19f680d31c8fc7ef9265430f92ce750ff21afa77b0a268e8a96c73bd8b6ada6e07a77f46be99c25eb2d059362481a6aea99de1e29b8ed9027e4cadd28f8205a9265d09e29658b28f88faf7fb6d9d3a67c2818d3f8666a440c146ceee8b952b0de0b1df904bf25748af61bd2a8c83dc1260b59c53f923e25f24ef0f9647a8db69fa4fecd093ed8a866ad64294a3a6d825162c9dfe228799a9334c197902c5a24277bf55226b88a215a44537f25e208136ce4d0f71f73e275e55c82495a21e85e907973722cc1badec678997542094d25d81d913975ca5ea276a504b739a9c99e96d6f58293e034b7492b957eefc59304a373d25ff59e48f06d25421242de9f881448705192529f839074df23189521287d9e2a6d8a992378492a85a44935b6ed8d606c5c536806d5604284119c34d3bd2d79a47fde8be0840a26b2e45c5322a22a824f1354aede4ba52e272611ec560a22654919e97b47049b738a0abefb15aed14370c13268bbff6032a225c3109c14d1993d665536e11582cfcb9f9d2ea7641082dd2cfa73cca064705707c155f610e99a5434b5a80c41302a7b6be39f84a4ab77b1c3e8588055faa2053bee003202c1081193fbf9aa3db72203106cfa9317539ac4913193f107ee4a4726c30f4c12eb517a55374ef4f481534ae8535dcf49883ac4088380a12351061fbe14f5141a5e3a4765ece1f275d3b496255af0764d20430f2729fa2495b6cf6a870e301cf0001c376e84c1011d1798808dcb01cc41461e4e061e4c9b335a1aef0e8c48cbaf1284251d499b63c781c0160c68c08d1ba87164f941861d72edba183a090bfabd066edcd8a1038c3176dcb8b163c78d1b3a5c0c2efc04376e7419c3860d6263d84036c6172d6807e0d0e16274c18518a70b07dcb8f1858b21c6e9e24b11400c32eac06fd22554acab15931ecf72d482430162635879e15e14d70146ea800c3a3041dae44f8d7539863e073ed6c64b6152f3c80fc981f59c444c1b458e4c37f9e313e8a28b311c1007d6439d44cf312c37e370e0369ed2759d296508a63770c2bf4f3cb6ae471cc97003b7f77f9db263ee48a78c36b0c17c63f9a70f2d1dae2081a12090c1067662b59f8c41d449f30332d6c026e9d95c443019fd35db21430d69cdc135a5e995430b87abe0ec28c5011969606c4dfb6e64730c32d0c05d4a2633a325b520e30c8c9af2717dcde61b649881cb9644fd5f1acbc0c9143f5bfecccb5d2237c820039beede4698f24befa731f039a434e919ba83369535c81003e3be9e3f8fba06adc130f07d26ec5e82fbc43791db820c30f0d69fb55792f294542c878c2ff0232baff6f208870c2f30c1d4b485f4503131c8e802bb49a8532143e9a867c220830b5cf4283107a53c684b627761811b374c05376ee028db838c2df0d9f71b3d564add6b818f29f7c40a53da3cd959e0e249cd8c604158d0278b50be279e2bb0fa95449f2e09c9feb50297525636f7f414f42a70f1541236ba1a29c5a9c0aea9905e9ffadd53700a8cf29ca2c4b558c890023f4a5f27939f4d57d089b1838b09686087efe080b9848c28705e22483b9d37275a1e0aac5b9ff6e54cda4dc99fc0e62611c72d74c6de9dc087bc632da2e926b0aa96eb25242526302a3285ab9bcee8c9b40446869434428852c93fa4045652c81bed6d97174349e02b67b4b43e993de206097cbc48e3e621e608fc85749aa2c734b333023978deb6089c58a848a9b359f24e128111a6eec992a8f5dcfd10f820737da759c960260aa1282a276da7c552818c2070f6616363397dcc07029b2b22ed86d2b92ffb03c6f622e5ec5bdd26293ee0c23f72fc1b0f41a67bc0e7f8554a1649a23b3ce04df379695bab8f15db01373af39bdde4a4a242142043074b126f2d99262707bcfb6637355183034e729217e468ac0e326ec06b72b7aab497954d9561032ea5bc9a9625dd0695caa841b6412b92d438914103aec7473b0b4e7eedc8d49bf290052bde954f23668dec522c18bffc94549f62400a1eb0e0a44790f69af335ad690b1bc40236b6b0412a60630b1b840236b6b0412660630b1b4402362e30011b71f078059354c8316b4816cb84af06011eae60bcb5caf2ae294f9e6d05a739ad24d3525975b783218616f560c517e25b5269d15d8f55f02571729694d23278a8825dcf6717d306a5673b20031db871a30b47810e1d607c9123edb871e375a800061ea9e082ce6f2a29e615edcc0e555470ff1949b54474d4a46a233c4ec1abee6866f28e872918ebd4fbf020ed8292799482bf0a0dba5ba204bdfc48c1c90e161a3125798c82cfd5a33e652d3d9aa31ea2e0f562a5fa1c52a964268f507032db574590b955bdf40005a78334117358baefec797c820d795355ec8b1e4ac9c313ec8590d247f1d31325280f101e9d605490da994da8bcb93225ede0c109369552d1941d3d356463f0d804bb492413dbfc1f3bed9a6025d9e59dd8a273867960f0c804eb6bc18205d1a14665c5e081095427a9f157c97e31868e9580c725f88c3e22c326059d7181c723e47d06cb4be5183a2af15bd8bd9f679b128c8d92b9baae3777d4bf1843076ac063127c0e91458a5bbfee3872ec18230cc22848470c0d6c2567815f053c24c1061f69226ccd4830ae39a4a037dc8404a3e2263565ccce27fcfd82c7231889c1435bef7604b71f6a6b6ff75386c9a3119c4efdaefba57a30820beeda9b97443ce0b108268888a87f168c828722d8a4f4c42da12af7c41c143c12c17d9b56e9b859a445cb0311ac046d77cfdf158eca83c721b890f2cba2ffb628bffa0d1e86e0a4d999f87757082e87c6ce924e242f21941e8460d5d3a59844dac9fb111b049ba2c6cf79d46c33d382e094509bc54ac4f2897904824f4127a154f4e7c8db01c1d7a63a9d628e1172c5a6e0f1072e0909aef9727f52e843e0e107ae3704d11b5f1bf5ad471fd8a0db69d48be9b4343df8c04b0ed3bccb252478ec81cd173be8d254e5d0c2d17d881d142430bab00b00103cf4c0468e6629b45f27ab5efce09107fe93c633bb94c9e2c8f0c0597253bfd1be6c7d2167048f3bf0716d2d2d640e4916ca2d78d881cf509d2ce5300d95d781d321655656cb972548b4e04107ce7474bd749df4e50dcd811f75dde65532d6b8eb21073eaf280bb2627c8fe92e81471cb8bc9e665f59d4697239e001073ebf9a8e1435291e6fe06356341942f28d091e6ee05bbd72fe0db24c9989a305270c331978b481cb394951cfbfb1aa325f78183bc6d871e5c10626c9ec5e4a94aa1ceabec0630d8ca757f430b563297335f03149fb8e96df64d27f0b113cd2c0f765fecffb3d61d2c62c78a081c9299a9e2382d23a4967606db227a146d89ec528163cccc0b82921e26e2c9f1cdb32b0c92f467190819139e93791e4e7381a2a24f018039b338410d67b31256d1bf01003fbaa498a5d503a3b84b6048f3070a66c930c1d47b55f0a0cc7943456d25d2bc1e30b6cdde8cde9b1cb74ee385aa0430cbd828717380f6a7dbfcad3877ebbc085d7a9884c4a7bd0e102a3694925e854b7c0f9980e52e2297f53d10a1e5ac0721e0d2ae446aae091053e6fa8648d1d1ad444565df0c08297aa479859fc0abc84a851cb46895edb0a7c90dfde2e32fea9a90adc066d7df24ab8fa54e03e43f57966bacb4e81f7493172aacc4ba18ba5722995321f055e3325896aa5172bf350e04db3f376d929a1db7f02a73a7947c545855cdf09ac5eea076dcda263f49bc004cf5144aaccd39f3e133855f12c4b0aa1f2cc5f0223dcf472c9cddf48be12b8142237affe78d6f093c0968e65bdc89b62d23d1238b9e329c935f99ef547603f256bf650933ea57e47a5c949d34a70e71d84ca9643095633b86bc8ec24f88c9a63e79f940497512d491db7d4798491e083ccd9d245de8ed53e0d4864aade848aa351748f821d670336091a8f60848c5b413c54e7c71dc195345de7666a04bbaee7495e75868a0a23f8d0ab20624417c1e7a9ba20661d73f614c1e54d0db6b9f636b49208b6d2e9688f31b6f588d84c6434134a7608c6538a489fc97208779b8b2d0c0d43f0d9b549ff540aca275508464e4a8e11062118cf214cc5d1bdafef0f824fbdfb510b7241b01e96dd3546dc1f650a04772a846c49f99eb6090204ebc14699aa49273de9fc81f3bd1391ef3c7ee07774e3d5fb875cbbe9032f31644a9bc6bccc357ce0fd5753cb93660f5cec8951ebdf54e8bb7ae0aba2a8542a836ef6681e8cdc12cfd7e28907ce92103d31787ee91eefc0c6ad1c4c5abed8818b39cc3e3de705cfd78157cf9f8489c6b4392b3af04175ca7819a4258d990397530a49454c264a47090b68c8819598c13e84150736554a4ab27a8d5b88c3814daf9cfbe1f71bb84b4ae78edcddc089decda0cbbaf74edd0636a6ca2fbe9577da64d8c075ea5222d89fda5e740dacc8f6d49b37a806de7f84083958c839669706ae2496d03946fe247434f09b4262d299fb5eac7206ae84f6cf6f1e4a249399810f22e554d9eb32b06e19926d940e19f8902c54ee8da977947a0cac78796bce9253a5b41818bb3ae175a623e78ce068810e31c2c0ae47fbcd29497eb01218b8cd67a9fd93f70556f32af57684c5909917d83ae59d25a9c9415845031a5d602ba5a6cf6a4ae988991d6870818f9c45e8df36dd10475e70b181a5b105ce6dd369519a94e8a4a3052ee5e7fdd5dc1d92a259603746caa0eea7e244110b9c5b6acfea96bf026312526aaa7117216334acc048099ef267a5142f48a30a5ca5bfdbafbdf5b594a5025fb16c83690795ad73f431ba382ac017d098c2e291228aa8a454d19002b71f4443d787a8161b1b78c016c50b34a2c0a9260bd1b41e9e46690c1b1798800d30d08002175fad339b526a39b883c613381135bff42e7a8aa71750aa8481861358df4f0bdaf55354d57194c181461318b5cde7fe1a732c956101183ac240030d2670da83c48c6e4a62eab30c3496c029ef13eaa9367b4990d15002a7dff25f3bd2e4895d0e2d1c6178914a79b145175f58804612b8d4eb4a492b8a042e289534ea0633a55febe31928a510a071043676964ef622358268530a348cc0adc44b7a22e6b459544da051044e5409cf215b9e38a944042ec35a74d774567c1110680c81afca49bf52c4abcc7aa9020d217039ba74090b324fe62a08ec290926c1454408518106109890e495e89646aaa0fe80afd69c534b8714ffb328d0f001574aa594f4ea95e9b422a0d103ae57af92a6d2ec3b960cd0e001db63a3b761c98249d61c81c60e78136197ee62e80fa937020d1d70e2ff3175ac0b3adf99432b0c2ec45893018d1c70390691d73dd3f512061762e0d811061762744103078cf63bcdba1464a040e3068c77648d314516c976db804f4b216b9b29dfb7c91368d480dfb6d23ebf4d3d7dd1a0011fa459fc6c153263169cdd9bb6dadf376139b2e0a4de8e48f2cf34cc8805ffaa9236d7f2657fdb033360c1495131534fa65598f18a728b4dcad2d9aec00c57b063dfa52b2c58cc21cb21cc68059be49769d0bfe725439615ac66b4ccd851447432550366ac824f5971efb23e6dda76862ab8a483074bd974275d71093352c1be86fa4dffb9fd928f0a46435747e750b9b5834ec16d52da1d4d57bcccd514769e1434799fc508334ac189ec7699b71bc2724a0ade54667c932034e576678c82db6891fed385cc1005a73972758a9332a599a8302314dcc8bc4d2a5eefa5e08282179dd926a9ef6b62ceccf80497530eb641095d5a3ff7049784befc38d2e4a77d3ac15f5bf747b335c78e0381d3199ce0b46565fe379dbced83a3ca143163137c648dfc9eb7ffda6a08d8d8c2c603b6b0c136b6b0d1802d34c1675226f72f7dbe3023135cda10845ee650113bba0516666082b56c11746307675c820b41648af9f653841cb28019966062daaeafa0aeda2cb4b1c5186654824f7192501339c434da86125ccaf190439b9981044617ae6312dc067da6a794d6955f39b4ba0b303e083324c196de0d495e3a1b21ea48b0935da2e64c419060b2281d31974ee2a6848f6025fe577a9852e121770413728aa5f8e9d35a4b663482d31bd916538f8e3083117c74cdd74e593daa25bdf02202691b8043cc58045bd1ef2aa9529e79438ae03557f2aec816edb42711fc5a0ed9d6e2410463216ed01f2166d6c839041f84c4cc546117ed5a43703e7a3a53e45821b8d0e3993cab4fd54d08ae8450bde412f39f84e81003479587d1820d2462c62098a4b1d2d5f34316e90b82abd49bd9ed8329b33b10dcdf6e0ebab29724150182fd78edede611f278f40f8c69ab3f75b671d32a40c1e62366f881f5ebeb11d2ea2c5abe0ffc55c7cafece5515743eb0669182f0f4901df2b3072ee5a818214e1296ffd3039b4c3f72929a5ef3a57268a9000538fe781738ae3a2001731580e185eb08402066e481d39a1154d2a022a6d5f1c05d06559363d21a9edf81ffdb20313ceae474db0e7c2cf1d7b2cb1dbda375e03705b5187445f5e9920e6cbabe9873fbd69412e7c0279945e65dcf4cc927a6fd8b15580000aa98210776426e491294478ec98f0327b2e385507582039bd386beab3db7d1ef1b1855c942afc8f7b6f204ed08c60c37f0b59752c5bcb95deb6f0393763d5f48b55945c6b0819359b2fea8fd2079b26b60b744e8babaae8d9b570372848c41e8e86f1a1899befdf2539e986488063ef6e556aefc9693b2cfc08714da64c87631490d320397829222476b4f2caa6560944ad31084480c79f46460cdabb35e8292a5427e0c6cfb65a618835c0c8c25193a657dc8b1b31e0636a7dad0621a4212afc1c09eeddda8d2a72ff079eaa3a36e4a2add78814d7709a61642aebaa60bbc78784efda6e102a37394741fbf32627e0b6c0c4942c98c76fad1d50223536df69f8e27c966814fea937ecd251618cd88a9be976f17b91c5a27f8828b1d3ac648ae03479da0991414665c81314f2999e5106b7df3de0596cfb002a736a7ca88a12be860e238c1175ca0209d40877b5186821955e0728e223d847ecf2552ba382ec60e1c28e8620c946563030f6080316f30beb89f41056e83dc8865a332ef1de98b8303477f7170b0808baff2850e0bfcf109883106056edcd0e128d071bc281670f10503c0831953e04678091169d3bfa2648614b8b4416dc40b966d6b93436bfbc60d0e9828b0af395993ccd2983a0a057e948aa62a3fbf3c98f1044e099154b9b27437955608339cc0bbea086d79a46e507130a3095c08491e6b27fead884ce0a3ed77e7cededb9212011da7033798b1042645ae98aa4c6707515202e79f747d103a1dcc48023b69b494bedc9954f410099c52724379d01dcaab37338ec086c474ee1743974660527a8a418847af084c5caffe4a3146df9815e30b2e3870e346210263fd357a3b9dffc5b0cc60c61038916b4cc4d19f35e9940b6608818b7d2e4a853ecf82c0a6aafa87851ac78e436ac7026a3003086c28c949691fd359321983193fe03e65f41cfc7447440f0b66f880519372fabc37cd49e66c1166f4804fca247aba8a179ec61d3ce0c7bba36fe48ad88e2f8e0e318a0161c60e184f6a21aaae9f04e1660e66984eaa246da9949e03be72c774e1a9ce269970c097dd56ff58325def8a0d66dc80112965b1a0aeed554b1b705a7931e36a8ec9d3ad01e76a75f913626d0ce50c1ab09ade5a33a485560b0319b3b0c3b36f5398c9dac5f8e2a4d3012bb2d08245b5bb78569b2423167cde18740e1a3b5870a79dbf6486e0173b5d84e185eb0b64bc828fb12f0184e025c5531a565223bac6c60626604307c1ba9f106db59932725210e64caa83d0fb2924ff77081f81e053df5396a067396777820f40f0f9bde6e33105b533b1e1e30f9c773495f75250093efcc0c7902fa5595bd9c79429193efac0a7d7575aabe8aea0c307c6fddc4a3d85e41e58d3b4906741add6d71f7ae0cc3a06f724624a4247ff9107c6266ba747dcc9a22d1f78604c44fecf154d738595430b8cff820ba2838f3b70aaeee65e5ffa473d36b610400e3eecf0f9a638d16dc4b31c5a2b383a70b8bfd58193c147a452f1e4093dd1814d2e6abb746ce7c0244d49f7a27b7268e506bc0b14e8700a9c073ee4c0a8512f21670b922cf42ffc04a6031f71e084ce6bff4da1b36f0a072e2328ab0a96477aec38f0f1066efbdbdb424e11512c6ee0bddb46787814d16fdcb831838f36f0e6c9d2fac95117526e470e1d384e7050290a6480021420a6c30b2f8a083ed8c0e68a14a93dfff4d28f3570b5d9be59faa5e5fb871ab8d6f02c916b64d221fa9106bef7bf9392b42f42d51f6860474566919474d37bf6e30cbc89a6cc6a29a6f4261f666063652d4d32bd9652df4719d8a4845f977a503a499e434b4df041065efbcc1c03dfab66427e4e36494d7268a1e08ba303c78718d84b217ed9b985d8df8ae1230c6c6b2e4fc1c3b4cfd361f80003b7a75f728ed61633828f2f90f369ce21626e8ba60221c0d11f5ee02bac56c453e66f497268e1c8808d2dc84717b8d2bd110b1d65ee1d2e702a9ab698d47e47af6c0c1f5be0a2a5b8a9152adfb82106185decd80f2df07ea3465e8be6230b6ca51c44b4ba5ae4a4fdc0022337d3b78eaedaef908f2bf0315f658ba57b52d2b815f809b2cb3dfbf85105c63ce43abbbdd2967e50810b5a2c988f58f89e3ea6c075468f9e3a434a7c488193626a9d7a2df2c75013cf131f51f880427e31eea952761727c761e0e309fcf9dba64ebaf7e39999171f4e602d87aadcdf4a11d9a2253e9ac0240b21656b089120a41f4ce04784452dd31c423c1502bb858f3bc894d2561c9d600ce48de304607461f0001f4ae0aea35958974aba52b4c24712dc16d3bb112a6e60023992188701376e4ce103094cd011a39a7dae12253f026b2e4994c80db5592123f09573cab896828e6b8ac0a9acf02836e61584ba880f22f06d2a78d6d05be1ba6b213e86c08798be1f2a3c4d16c78381c330c013172ad0e11a2895237d7174a0cc0d7c08c13d7d6abef7dba1a4021d636c91868f20703ab3b957a94060af445bd03b293d7d82838f1f305a216d52952e59d5ee0336a88a646eb71d64090350838f1ef0f93de7dcc9d6d5d7c4032604f53cff705bf1b1032e8390a20e387d4164c93622fb8765630b1b5bd8e8557ce4809718ed3bb73c53c50f1c70c2f4a4511d947e52495ff8b8019354445f93b89fab83884de0c306ac4d7a2d21847077cd7ed480fd125943ca8bf9e18306dce8186a84ccd8c13212851ab3e0a2272931c82c416551d240b1430d59702986d6abfcf70c41e9c51874a8110b4e459219a9d75cf72758a8010b6e75344c52a6e41eabc62b38e1f527b45e7ccb9e0b430d5770414da9c896bf2b06b7157c6f1659fa9e55f28face0e257084144ea5bf09c55b03569432c846de88b2ab8eca0294216eba81b4a051b64c648769a6dfc34d77109811aa8e0f5b44e8ac1cff2f9478c8370eca9710a7645c6cd8ba233342e7c8c1494aa610a3e7752dee57c8b399dc610354ac1e6502a8927350bcac73cd42005df159a6388aea87aba35d41805efaeea2198f47cf92d68a8210a26ed56a5e5e46d691dd60805e3aaa6f9d53e3540c166f178d27cdcdda2c62798bce973507ad74ba9c7136c9e7cd283dcd4e804e71233aa44bfd0a12ca8c109fe6d3c27fdfb20121cc46a6c828de6f76d3aed4454870b1d61580d4db07dffb9419b094e78d69ea9742931b939b42a063530c17a301df3c70fea4daf4bb021d8764848a633420d4b70aaae9e63142537422cb750a312bca8f98ba81af364419460ac430ea62fae5aa831092ea4cb9433955fccadd790047b4ae8f04832640bc2ab1109c673ed8b9ca06cd4cf1c5acb831a90e0afbb228f0e41dd9258e311bcd9b8aa988b0993780d47f0d94386beccd22c4ad70836dc4f07651d32a10623b8fc20ef42d59563c721e6801a8be03ae7c5494a868fba48166a2882cdcf5a9b58969e16fc070347f72916811a89602c2421d2d4acaf236e705003115cd22023c70c22631138e3a2c621f8ce7b4994d68a212b65085e23778f2cddd933a61405d42884f9cd27082183493381d15b83108cdc284ae4f4bb210779d526a0c62018c929df7e754a923e6b420d41f029c2bef2b90969a5d608049b3428a549281b108c5ac664b5ead6f803dfa731dbe990fbc1ec5e55bb27cb1a7de0b49bee7ade4e1042abc10746b48894d56a4165f76aec81b37613ab7f6b7d8d1c126ae881ad4a6f13cfa6b684d40535f2c0a778a523a2f7d608ef0635f0c0ad69932631ff8d3af91dd8eecc3156d96d07264b0eddcfd014a1461dd8607282bc92acf59dcba1656450830e7cd6c5a45d42e4dc9e9f0397eb94ac499e9d9bcb814b9b344aee7890691407b6ec4dd7f78dfa2c7138b051d34949195266c4dfc095e63d91e2686d44ddc06778528d1ce936f8b731d69a8f121bd86a1d393a5f7bbd92d6c049c8912bc4a44d7c4b6ae0e32569a93508a1cb4a6960359d8bf6efe7cb104203b7eb163347d252223f67602c47d2bfdb1c3330e66e5b1dd275828897812b2522932599f44b78c8c0776513ca3f6dfc0d9931b0daf9b2978f0eb14e2306565f5d6f57fc523313064e2591d7bf3ed7791c0c9ccabbe165ba52b4e80b4cfc1b61315a1ce99ff50297d466536eb92ef0a7dff6c13ec7acd4728193d183f9a515a13f64b7c086eda5c62879d2a6b5c0698aa2524fa259e0b76b6d62c8799983140b6c348f9f4765afc07af6fc31c7d3a52cb4029fd3f44893a0a24d50abc004212ca7ec954ac94da9c0bec88d39a81016c934054e66bc1249e74b152229f0e51a4183c8a54382320aac9b8514445fb9a832a1c06da860aa2c9d89d69fc09932adaba43b81df51ba62cce1e9d3a8097c85901acd6702a3a642be3caafde359021b2fc6603906d9b7a612f811b58ff9fa25940476336af85eccff202430a24c9608d9edb45a47606d2f7e0eeaa1e349d008dca60da57ff222b0317f478e9913811f573f9554fa29350e813555710f293c21307a27679f9c267b8c5d1058d5ca9072b4030267ef218b12964564d00fd898e29d2afb33a7d0075c6ecf65b2ca2fa3567ac0e9602a7fe2a4f080c9a93b9a49ba3c95db0ef818546dd7064df144a603c6bec2444595d4ebb11cb095cb4a72f6ce66711c7041cf7c736faddda56bdc805327b2a434211bf09fa7314f87906fda1ab0935b47ecd574f4b4060d38f513aa2f79c5b59c053b6a21efddc9a8db952c180f12e26de6c7b87e2c1811d2858a9be9939081052f31497c2f9d4235f90a36bbb3baafe94a52bd2bd8a0932e765d48a14c6b059393ca9a83b5ac60fd4cbd0a3e4b08376d49a7cca2a30a4ec5dc935372489b924d055b7d49988e39890a36861092734eedac693c051ba92208d19ef89f33145c0b6898820fd26209095ae3dbc74bc1fee668427207d34c2229f8d2f9d1cc64879c9a8d8253dd88792354be4314fc6810c9724d3779c943c18b44fd4e32dea0e0a2c5db20ba235d2bfd092e7708393c8614c26ae409763be4ce58163a69e67482ab144bef7258999887138c6a93d9e4ae4896acd9049b2fa6ee3e32a5c78c26f85839ebb3c61e69419960a4efe51482f4d2d7c18449249172df622ec1c9143cb3a6a5aaac5a821149a925510a82e07d726b5ef2afa0f94070266408f393f963ed80e02f89a0a1f4d286eefc819164eba15ba134c8f88109f69e3a338d7eae7de0542da7de562b9129c6074eb4a63d95bb228910db03233fc7de4fdaf4938e1eb84c5a73c84fefa0993cb02ad613634af1c069c72da59eb9acbf3bb0f97c82767fc60eec06491b5ca3d8491201831675e03a8a75e79c2157254d07c63206a5936c9115f4670e8ca7ca206388460eecd686cc263c64d17be3c0dfa8e6e63af9164385031b24e80f2a47c9667dbe81b549b9574fd44c65ee88e106f3fb6fe7f70b2e8e18ae23dbc06ae44c3ea2d3a7feb46003934efb95fefabf3f79166bb1063e8b07f3ed77b38fab811321e58a1213d1917e1a98e42243772cb9a7bfa381b7092149db889a75e93370417bd0d4694f3b7333b041a8bc1a2f8bd44b3965e064875b2acd8999364306fe4ec99222bdbbbcdb31f0b931ad7c6442a08518388f563fc294302d790d037b22af629b0c4174a7e4d04a2dc0905a7c818d18a225a8e4926397fa85165ec01468d1852b560c92cb2aa5985482a50517d2a5ca936184716e145a6c814dba6b9fbe628f086e0e2d1c8866630313b0b1636c60021cb05068a185d3220ba605160a2981165760b466cfdaeaea6b8bb50019066861054ed6d85dee5e5125ea2ab0de952e89f85a323df4002da8c0569508caebf2efd42b052da6c0ebfb69a5dfd96b74a5c008b541837e8f16b4a951e0b3e429b5dd5947d4f5042da0c0572af51aba792d9ec009a54330a1326f94667368556d2079181ab891650c5a3881b1caeda7164f4de49bc07a0c399e3909372162029bdd2445123a889ae812b8512926124f25707d2bb12cc34f021b39078bb1d4048fda2381efcf9e11d7fa2370595a7a1f9407f5593702ffaf49e974bf6b99ee2270359aca6dbcb75a6b22f0515f84a5ec8b7eff10f8d29f6ba38a84c0c6b21d592f9a93dc04812b619bd12a757e3281c09d4c3a7b24d30f98a0397ff04a412b7dc9077c8e7977cf54520fb8f748f5fd67a1829e079c1e57b318f1be436807fc4911ef5c121d305a2cde955273c06e0a1952c896d702075cf95edc4b934ce710a4c50df8ab7c93b694bc95dcd1c2065cfef71ffd8a17f276b4a80193269824cd7ac9bb375ad0800bc1268594de654a6d66c107ab7849c8989105dfd1ba946c9360e9df587097b935686adefebdb0604f8b8b77d03b4f7b5fc1267da3b39ff0cb5b5a57b01a74db238af58ad0b682cda3fa94d0e21f27baac60b3630e65c164ac28d255b0e1a643f2dc54f1185505576ba7b3aa8d7e8d9a0a36e29dae1ed724ed525470273db55fe490ad969e82b118628c94276a0a2ead56cfbb735ff452701e528a112dc7cbf9430a2e4dd4d39eb37b8898a3e02a2fe535756ab52b290a2ea58f299d122ae2d6a1e0ae4774c49c82f60c0205234a63f013fc089946a8969e94a3e8095682870ca242ec049b3f2775a2e3a7d61c7282cb7173b668fa4e63ea36c1778908955384741e2f9a50d2c84efe37964cf06b9d930c15b1eaf498e0db43ec4b37e61fb376093e76c8912442fccaad5982d1c8ba5582df929a9ac3cc7d45a3042742c42cd974c658a29a04a34aa62043ed2da8b52451b220e3a75e5224b8d6984bcb74a9535a48f059e47be8603e828f29b2950cd13cfae8087e35457d75e27b758de0933c53afdd63ed298c60a4879c91b2bc736364116cac521a74288b7944882238cf9932af3289cade26825395af6a3bc9a415728a08ce377656804330c9e42695f431c5c43704972ea69cbadb7527e71482136b112253660eb23d842863b0b89a9b6206c146755d13a1a729a95410fce994d74d9d8e869d81e08465aee6d1699f441010ac59778cf92b850afdfec07936d7bffb2a15acf30393d44573d3362de84b1f3899f4f5f8ed5e755af8c0b5bad5e40bd97e54ca1e38bfd431b5edb607ade881310bd3e6eb77af21250f7cda969cf8e9747a53e181abde9cce844a4d975377e06ceb742b857765b4ecc09a4850d1939cd4b2aa0337d1dd4a3bdd4a448a0e6cb699aefd909a03a327eb5637269996037feda6e63147f41ac5817135dfcd6295f47be0c009fd953d6955eccbbe814f4a081f0b4ae77817379823c970cbd136f01d5b37828a101014800dbc29fd418479148976af81b111af0a3ae389f4d4c08a0c7da79a9a543594063ef44ee6cd29b134b268e0f55465ce9ef9b7ef33b03af2ba479decae1833b0d53157363dd2b72b65e02b68d357593793c4c8c07846091e54ea1bbf740c5c9fea335da23fec1403a7424ffe5c4a448b2ac3c046cd1959ccfe4566c0c068d0567b4104bfc07586e0f182bcc02599428a88f9eb02bf751593d2f47181b3a4fbb2ea2d85e5650b5c65fd20d3a4ef85a4a205bee295d41331bb4c2959e083e5f62fb10d8b55c102232c8ba5ce26bb0227b3d4fdd52651619a15384d1fcbdcb2d9e8d1aac08d4833952fc92a591915d8da167df7a4a64c3d054e7f571231674b0afcb6bd8898c98927ad28f0f9233306f118a3490b0a9c485c09b9d3e94bb39ec0f5c79c325dccf3f5ca09ec579b664b3781b5d12d66723386f299c0a9f79026ba2a33be043ef8a4281a456c728e12b898ff944e891f1e9249e0a3889853c7cb413f8804b637447e5fff09ea1d813b5da739067d79296604764c453ce6a0725e844ca000456037d4c9899e2775d7446093d0bdf5214534290e8191e32124a4f6244d6542e0b373d404d3d0be292e70b818a71e508020a0955a52ca2ac1c3ddd328fdace06b4105000277a2471c42017ec096674ada92bf55aed1d1a0003ee04e64d0a1f35e6efd0d0705e801e7a22663c7f1b8800b0dbca0003c602cc80c936f1253e5ba450e0ab0034e9dc64b29b5c69c357643074cbc8b41df69ddf353b7a00039e02e549b524205c001ff1d430711537c741670e1050e34c60e6501175ee0f03f0628c00db88b1eb3fb4325e8e5779c85c059060a6003ee227e964eeb9492fd05a8011be2e94f5a2359f20d0b4003aead455e8a36d3eb3139b494371815b8fd9805db29e6383abd6e0ed5f9172b00030718626091057cc8828b933d66f4ca3e69f7c1b1e3c610e368a0051fb1b0ac7478081e3432f880051f4b6b8a93ce7292267a059f49a72821c6f6c3157ca5c66c6923ed06f9b582bf2b1d2a241f3f58c1e6a86f4274b86afed22af88f3c42574cf1c775f4a10afefa46a78e54f57ffb2315ecb95d7896d2ec6b3f2a18ddac9b60ca7d349a4e510ea6378a6ade146ca90f1643bacd91d4a8146c5b881ba6695dba37a4e026b5f9dec56e14fc8d9dcedd561105973ce8cce9db534c950a056f6a5f5782bec9a0ef0728182147fe5f0eea4f70797793fc623e3fa1798289924d4bc7ddceecaa13dc7a2475f31141098f7c7082cd223429996983d2b13e36f1a109bca13a3e32513e30c1c5a08386c4bc5832dac5c725b864ba7372fb6b89d1cba159a47c5882bbfa90548a64f5163f8756a9faa8045721b46b497dfba0e91c5aa4b6bcc1f8e21af04109ce638c28d174ee9849e863129cde04914d968e24d88a112346bf10178f5d043e22c1eaa411adb316f7ff3e20c195da7595eca08f47f0df1b838cf963b6baa00f47b031e45831a51311a34a1bc1bafb687dbc5c9bc6c2850f46b0934c5dbca4758c41868be02ce4adb4bd493fdfae08fe43ab55501ac2e123119ce6fc1ad48990d32d09116c12c1f7538d8cd4f71e828dd949dbfd53cc0e1f86e0b4585a2abb0d19ca367c1482495ebebe6fbba5806fdc08c38b84868f8c7da8a4f024e25824100883a1703810808102e603e3130000000c201486429160248db465fc1480034b2824443e2c16281c2014161a8744c24028140608038160180c0884c2e15048201ccf84bcfc23fccdd9b69cdbc999e79ce7382bda9ccdcd90cd990f73c6dcce96250f9f0356c899d94abb0c693383abc7709596ce29ca2e9d82b9731b616f895c47837bfccc3d8f7b0ed169fade7f1c99303dde814deb1166c45d17335dcd2866080662750208a22d4acfbd8604ee0af7cbdeac53946a23355256678910c3f65c9854a1168be89b326a1661224fd6afd2d834fa7f6ba163cc780669085c05be215e24f785c3c2091c82a5b011009d7eb9d6810d19965687ffc01b79050cb0f5b5b7672bd90d49735ed176c4c29d8d26ff6656b1e3c5e68d6ccf32d42c88053d878cb4d89b356121c6e908fcc0d1bd5cad382fb3b985f4189e1093ff24a0eae6b9fdfaa5c7a996959b0743986eb3e77bfe4605f12f85557bcef57a853fb8c2e504163bad26ee3c3ea29dc52ec3ff66161d54e2d4b1c5b3e2b1d8a8fa2dc1c74d655e42884f4d4810f3bc45686720a124b49317bc4b00dd21d03b6a1336613f500a90229a4311fc3d17d50eb0280a5da010519193d28dfbc28a775be808433e704c21984d39b0c669aad8aca0c5806e182d8d867bbadb9df3cc3f86b525e4119e3efb0c8d706a78dfc143abb1fe5c0be0c2c521203af53ca677c9ba39e3cbeca9f2bebc27be75013e16e90f2092a199c3f5820ba5d5bac5913d05fd3d76a36e59f99f62c3158687dd53c9fd0d0f09e2b431be040f1436264a3ab96e5837d71dee86d59bb134156ffae571f766bcf11e8cf7cbbbf24c79a93c40de9537d1bdcf1cfd78a3c48f9d5008e8e819fc591a6ada7061db859d298fb06cbd5afe4de88881a8bb791ade8ab79f6fc28c1d2a15f31502527a13e44de07ae7b742f73c0bb357ef11f662e12d4432e6e2d6e105279c8059942ec486ca86b68539070ff4f306dbbcfb8c7f6469779a9ad6d6e460e0f52feb163274ec32f5c5b8c9815381b6604c5444de1d710bba30f9860b3a6929b90bcd9de75673efdc656e3f37b43bd4ad706fdde56e6f37843bc48d7add0ade9271a6ee3e7ea8e28d8a169d272a257e744752c67b9c5f0aee9cdb39a6a5d6a90aa9876c593a757dfb6dfecde67b6c4b5627db17d51a7852e9d76d7a612591324a962f1a4ac820d435cb2b47c6a3885148b1210d1152344927471f21a5202279479bd1ecae196a8e968b5c85bba4161d4103d0b8457b982332b1d19553c8189acb7927775e74317ac0cea48f51a9c552f9a8b1e799c1364f4e29153cc4d252a0a897a4a537a33a6f15869f05fb91614864694b76b2e641ce1cb30551477508c0e4932148e488940265835ca018c424be145e26d16c32e43082fb265165683c125a0171f9de345d0d14722bf73ccf4b5eef8122d7d0dd48bb5130da3845b20b0ce1fa21a9263f386e59ae48006dbd0dd2fb4101030163b313ad0e806b7b9135c8d4e8b36d2784b8b4ecba2f7e6fbcccb7bc7e71d0cb1288cf4d76b2f0555c40df0435082727b1ed7296cd0a83ba6c4df8d4210763e4ffece9e133f723b60a90efc57503079ee3f01ea559081746cad4dca70c00ea7d8b58dd8bb06ee401d05e25a05eb73dd78d934ea15db7a1745097603af90d5070b4aea9f052948fb361c7552134e496f19f0c34dbb77ce8c0d557251e7cf83215a122f935e5bc50db6d668269bcaab06e8297114998b432c92ce1d823e6783c1aae200af5ef57218fa4fdbf9dcbb015d3dec5fa2e8ab104889334ca906cf1b43a385ea9c07b2c09dfba501a262c88e36d4460cf7c4c3d4c0552c389c1010e92b78295a6b1e5d9495c0afa9a342b588eddf8989866462f8b5b2440cd9061b5c69132b7c48b483c7767d28780369438019d780586ca75b854e7d910baa21e6ba3e173eea11140c9b570b904fd41ecc560a217958c710becbd45d5389aded202876af974244a67c73952ad23619c2359f59b6dcfe3bf27b20851dad1a8b476a1b437443670d596c9630e547ff648a3749d2e00722ef2c6299394c8e993409bcd1d51553acfe093925723dea2900c7a55f6702e5f1f0a5cb3a2e8c8da7eaf2b330320861109db08ddc8add9f8b2359bb21ad000cf634ac2f598b19572b5d7708f19919632f6ae6ee4c0193252aba1ef3f8d4c441fb35297b165a611137747194e85e0883819076371a71099cc6adf9bdf4987f02ef182fae849bcddee61fa210009f1bcf999142eb03226982cee916ab5b02d44c8638000b246e30d3df95dbfa1be68858ae49e3fd0867190ea866edc860df2691ead54994a8555a2810f9e03a87b8adb40b4b81bb791cf86d3baad762f010aeed10190c80f89f19d2021873ef935831249264f3377a1dc9c5696c5c95484ec51fae7c0ed7a521bd037d182153ddbb0943d6f5440c1bd0ceca4fa4256974d0162b8b551462b1798ef7f3d5d5f44ca9d8686cc723e80a2c24496afa0f1d15133b6cc24fe824cfcb0e117cfea3abf962e31cb05af36e1be6dda2c07ec38d240c0761465fa1274c1a449b078c7b17401a5866d7a3468687e756852de462442d1c01cffab5d7f9e8b21c98e0b29fb214d56d44b4e6d41485d8d840ea2496a5dd51c30814c6f83c87ada6c8dd6980db039807197050b388d3433f6c9168949cd2d6bd8e0a70f29b7535694a600fee9b95fe98d8f1a6058cf8907852b3ef7ce25afaf81217188683c5459a21db11b15543cfeb47038fe752987062bd70956d0fa79660bfe538c4d10506ce825ca1ec9f18ecfa36c6a13045040410b2442bd5599307717502e0e697eb016517d8b090b497808392dc5c5a9bc8bb9d83fbe2f26606ab7520f9aa8cab5345cef62ea4796f45b325e6350c351528a86e3341311be125464182f4c566fbee8a3685c6452dec82941eb71c65412a74d56baadff13ab9b36d9c4a1ee4ab0575c83e8b488d15d9d3da1728f98bf1c840d621ffefdc294422da4424ba5e55013bcca5d07a3841724605c56df971d060567a16871405fcd63ae10619c3b8a9cc4f2eb4f6cd9182de961267e1278c9d59e06d00f5ad3a38fc3f19846635b4ac57707981c1b374094bb306cd73a02b7ed97a5d36822429e2c784579fda9809789b0e06ae0114ffd2da224e36f20126057b42f015905e4e28c09a4c915f4e2cd73f5ae06e0c45fe7bfd04b68f4267c235863e814c442c77631c9f9a34274e0b1655836d63fd7febf448e5ecb4e9aa1f103b0aa1bd456b3727e60278f5587faeec1aef32fe58362324bd29f6e4d061b7a9535998d0965b54089746c243fc63d7214d999f9a7f864c94e08ad517a298a654263eca4912262adee08a1b85a85cee0b35e8b67ab9c8e60216e5a5b67aef7004410477468d6126bbc8a81240518a7332a8a205f5dada0225f270174a03284325868ff7e2e03d05ba1b6f23533bf0a2aa8b73ed36dcc197ef27d2842010caa5538c60eaa81338aa1a559043f5658963ee5da999ab2847181ec470666b9ddc796797f29e3ab2270833f833991556e4b030611163d0ec60baac74a6faa4fcc27c226b87b2700c9e5a6cb4379bd3aa6b8cc9254b43eddb05e61c43ee4a91a1311891fe33f358e8da3178d6b49eed1ce3ca810fc8f4675039a7e6af4340a0e8440a270e14efdde9276a19776a26df890ee0ae41030858a7bbb4db02d4ea274cd846b7151ba7449874a4c410dfd89112d21f9cd127049c80c59dbdc98e8a95e8d72bfed25cac77c01ffb338001e970f2beb1e1a1c812977ff27238001b4d8522051521641e1e23e3480896fcfe198f6855ba8f995bf1a80e8bad7f4adc6143967bb1806abcf8e590abf26801b2244ed42b22fc25a3f248712961bece57c951a7e6485e4e4553c6ca8e61dabaf409bab6bb65cccf867e69054d0f621b84066e0f219d3f34702d9aa420139d0e421509e577c275e59fcf874c6acdbe1a741a6102e9f9464c478da4f748e9e83c6c3853edbcddaadc405b6e3a0bb8cc7f1d1dea915fc142bb8868bd9366b852fd7918f263e359a32d118704358481daf2149749c8e0003034d731cc498f0963b52301352e8d97f3528518e120c98f967812fdb5e7f95c63f57ee74bcf85af6a46e4d019e8a4b4318db5023c221cc603934afb720f8d4dd6fb2ed54700339a87fdf43379ddb237eb207ae32695bfdd68bfbc8fddec44cb117b95a286d37e49eb5ae809417641b0e7ca3fcfe6c6eb8ff424da114e99c39f4674c7c55376e0864a7e7ed14fec299d727f223e655b7caec63ab0535a3d14e349cd31247c70b4f472f4577851691f627052e77b25932965753d54abbb43e051ee0082c9026c74c450ae42203b2b47bd9c6880c284a0530edba2796dc8962b62155ad3dd2d6f16cd0e7036dbf80976396180a58f54e25c63a46b57cea14db74d96ab12d3c5e754a7e3991a0f3081a5105e3ded0cc4f3e83e9522a11daf3d8876f3b1eb4da137463fac6b2858bdfc14b1dcb80d0cc2dc3ea1e6c4c21fb0db448df5116580b6e05c40590d9240cf3521a4e8c2352f837302892e1a94c834369f51057c6bd385d786d3c97cfa524254632d407bf81cab69648308f9bb6c81c8b1daffecdcbc1a04c040d53b12e167491343c9244bd10ff11e5f2049c6a3621a5dae536c88de633c4556d5253f9d170516d98e0d5b654e72527d520aa0f16ad7903bfd25a5b1837c20d7ee24bb6e640e5cf09d0f98883787fb0cae54ca35f87d3bceb2f08857d634e990ff8b2a32daff820fda3a9423459f74c0e662ec0ec29b68fd39ea8c840160a94ce98cf1dcb405cceccea4317f8c473c0ea007198e6880ed9a8fcf4a83c2fab7ebc7be473aa0136eec07269d701849a0563825409352a3b0104a167275254581b92f503b8c2ea8518f386c8b19623ac78d146d58447b1d32fc08a355c93a9e77e16e99a9ccbff2593a2afcd7911958e9c2a3aee748522a3927e5e8712f11214ee84a11aa37e3a19365e9fe1746c86a377a96207a4615932a55eb100ef6ecde046f73e6a2a5b309e53ddcef26ebc6eff80d1e1935d93590974c0f1464dadf78ac48c95ed67f996f064bb784496ccc348cbf448aa313222be76bf78f292e4b81c1759dce6bb36adc3548e6825e20dee8fa622b0991e17915b8f8c1fdac02257dccc73dd8f002ad3061af9497b795b4d80b0084f9db04fe7247c9c0ffa97804feea0a05bd04ef0a0d7a6287c003033e40aab411300e60405b63ce460cbb452481bbc0e7c4461c193649fcab96ccb365aec8185e03c7c7cd79c094ca87856ea12ddc224fe4a8652c8a4b7126d55c0a6b7d70d25dd3b9e0711489252245dc9bda42d29c1290e7d5744b9225d4b01246aa98074f3b4c08a8adad3d23eae3cb180425d25d24e5ba7fa1392e3c45e92c7298e5a96ca3a719510ea523a78bab45a4c5d484f9ce679f5c7e26339f24ab053759973a37cce2bfecacb5361c0c0bd66a9fd3105b61f8e6837a87f8a2254a290ea10a9fe2d1aa7f228595dd2fe6f670b2389c9baea04359da53f024271ef25fb93fa9aa5be2662a96fff3e7696a2686435b2fa4a152f89a0e49a7cada4b30ad8c48fb003fc8158cfe90d24b314a0efee034d51f831a85f8c61e2a596954d4d70803ab3f3ec1b4d73a4bf8e55ceff43120e5c184d88d16054f6790590ff38ebf95f2201ec106305819f1beec2b43288995be639f3cd3cdcece819ead019ed9c7ef93eb51cd0d6f8f755420932c72769ce1c4fe8f14356b5973fc67714335cb4f3ec88ec299de90970f5dd73418865d253dada3aed3f96b829bf2284bc8cebe52c673a8f426b1888e493ff4cca36103a1009f3ee2c537e14fbb89d81313347fe8370035d514c86d40bcd159683b6053302ff9c96d679a30d68f33e669c78a1dccb4f0320df894e9a9b54f462d27ec08834efe3e400d221869df9cd1c220c1d7e235636327b4cdcc1d085beaf1c2113c30cd4e495f32e2bc5cc99d1bc637da41ebacdb543a2660bc70f20e9df33a1ad3566dd64a21b5475efa082e88b0bdf3721601ecee0025e3dc4deb67907de0c53efef0de38b020d7a42e71d4c8898673d0e1125f36859e1f51c1c6c185c7eca1c289c5848350a435c048cafb790486545e2c1e61d0c5e7071b13e7363184aba2434849911e806b327f01c4b58117ad9a256c56112184b25ff1187f54210d93ce74256f0f48ef5393044dfafb6751e71d80bd8822b506472b54caa1199a8817f15dcb0165e31a1a9039a00f9797536944cfbffb99801671d38f2e91e39a4efd422a11d0d8715c17562f42613a7461f90e6c42f9a74d86309d63c1c4e4877bf145f5a7a25256d64268cedbaf2c7661ff060d8207405e31db6c642717a6316b8cc16c27e944218dfabdcff02df4ebe2e7e7165934937e983215e16314a0a8d79cdcc05286cb6cb894de0d24c0069a9d852e14bcbffc6077234a2366823ffecb7f598eeb98c6ee7039c5a890baab20df2a49e4b2a59766d26480ac8330726356198778953cdd4b3eabb5400e8ba341271c30578f3f7a18a7a7d6dc6837beb0659bbf598dc4109112b7251148c97a06ec0dc844dc50f234e5258b828d78a6f364ac3261e2d2a60ba478c32af82743548901490f42eead5dd515a1f97d7a11704265f15fb8b7af19608aa9fe8509069d66c172e09f8291af272c3effcbcab6ab9fca97076e60628f93afe921a0b7e52b3748f14d5e1e3491281a5621d096f04a066f9fc2e306481aa260acdbf4067db93ca7a3f06be8e6a61deb5a681befc1d310b60a86c2c443a03c720aae06a260ab51bae780a53bd0222ba3cb4f927769fc084178f13aef04b12f5d1f74e43c118a49a0d519508a115f5541c00fc904813f3300135cb35c21c806ae3ee9111634d7f9d8f3c5750c4f84a06b5f3c9e8744444e590137f527afc65c7a02750d0a08028c3321594737515e0235dc67f10339f949467c24a7c3d7e21eb99a524dc37867bfc1af616ae3613652010d5cd4d05b67e0b2165a472b8e07e0f35a4914234747f81c67fb88684cd24e66ef858f545da8249b63525d37ffa641c20c5d6bc0c7b14e0d3155cb7ac6c0c5bd7955de2430101f3daed09c603d7350df9f4c09a813579cf234f9feb00117b9507bffa46135451bd260b384aef457b1bfc377943099bf87753ba518e0a2795d583b017f217ad58e18ab08ef3c2757d81348959b1630a97cac9c233790d84ddcbd94a404001295a34115cd63ee9b6201c79d720014110c08f40664d240566c2bda1b5c7bfd148953a56a4f16fe1fad1a26eae501b49962a50157555bcced0460fe98e3ec22c20ad98b7c8aeee7c284df811bd5e36d021a8defa91af1177e25391ebd5e27a6946184ecb8845aaa2951f2370586cd6cfa5fb55a6b6f9539fec900388af9224beda6a9c2c8bd12d56f7431dbf5a701948eee12f1a36fee9997f7d1067ef4accef88a92088a254f5a39287927a0af24c43f9d9d54bd043c404182d8a7eb26a7d6c5406cb700b7b47ee9d0f21d5bb3fea7dabd72a92a41f5b877318f729aac74abe9160a25d123c13af47541a53479e17158cbccdab65970878ced3a0ec1bea7c997ba7e9f174d73bede04133368b3719b3da7b199f52df3696e6f7498992c79b6561aef1ca30198f2338862f1df0a60a61c10156025dc54297d3ce78d848d3209c8f49b24dd8a036f7e6f96b1755a8a19802e735a6fcac53c7fb899137b083b22e5edfcf46521b0e6530995ee7ae497010c462ac6d2ebb119a04487be53dba42083180fea1454b32bf2dc165dd439301729c7d0761e49dea2717f64673411f439057300b270c39fb61596b13d0c10ac48a4cbaad4a80c7ce6e4f80ecfb72a8504071bff29f75dba42709c43424583f4f57a6390c7ff28c4dd06b91eda67e497bfe01a8edce4f93f612149436c2368c82bdf9b7426716ac4fa1cc5e176126f9a76516720f119d6637f51bf27e1efe978aee0b513920d151fa2928031df16644c42b622dd6158f8274e2512872bbfd6feec1e0f4215e0995db5c179d4924bd25543a7bf9906fca12504fa3a394d413a56ea2c47a4d492c343f1e5b2f90241e66455d70d44a01b214061f6f862689c75bf0d80b1ed54b150fd5be1ef1757fddffc72716ba1fcce9a4f62872cbda99d3a80cb7f213ca5356ee6f36c016c52259fffd302f28b13cb23173f0aa0030abd1412f6d972ff5590f8d67e45fc7bdbb6ef9850e9b93b40caffdf968b97165dcf725c360df884d2810084e85584c8374c4b5c6f59b75c4362bd01d2ce02d2e8c9d662b640b0c0bf76641ea4d0b637b0a97b2e958f0160bdb7b17062151805156602f7013067b7541e85119467240c9124e239861246fc75108cc77596c5d5e63b143916f5e221175ee1295ceda8ba483f321bc5c275aed647182b655a0311b7fc4da579f939bb29e154340e7468adc46f198c96c64ba9e3914954704dfd6f831cdc13da1f1281a46879db31a3a5a9afcd38ab73d52521ed4a191a7df8d845c3b2b4fbc06585c322c4e4e0a2c48fe3833cdc6818b6f02ea9cadb61619c8525302055b594db7de4db4ded5b1e8442bdbe73a756c65d56d089c9535301867813d5c8efce87f78eb745981415a0963208730d204e2b912d1627c7a48e4163aec994d160e678a7bdaa9ea4e8659b924114cc5d9270d57a6e4ed1f34dc5889846260fb2b16420688ecd0408268014ebe2600eab0f03a790612183687b195f9f6975fec47c3146a7f816d1d1b23dd610a23acbbdf419c90f19c8f7028fb0f3b1c9a64a25cc2a7944d9bfd29f76aa05473cdb075de04f6a1ef2b809d816080d885c6036c25f7d26f9e903e1c18d9a2c690f2648d8bb050da8c4a2e310a61b3e61f9cb08f7fc46528ee248d68174c490fe837129014ca4e0ec3506b9f0efbdc38cd5b39be743d4a8e65d5063c1a880685899f465b4784a730b496863443775f0351153267d71300d5c79013346b800889fba4d8ee1512c6f92b317e50d753d76e4c373c4cc2e10cca8ea7c2c120471e93a32de5842ed50479e062816ac6769f781a2a47fd5d25b9dd7fed580f473052298b8770e50d566d2f9c0c8ff2aa036f7d6a48a1a538a6258e581a5f0e2cbd3fa9a0249c8d6122b60b6aebc811d2797b44cb80ff27825e2120ceb43e045140449c346dceedfd4f5ccfbc488d65ed8e282522b6b2946f00fb59979609db58ea6d03c2569ef1a1340719cf51190368b557ba40fe7e21711349b696b1dc0012241c428b9420b7c8811f71c35648c9da23ae92f952f8226a848ed611deeb90a5e209ec843d614df82dbc0a3fc2acf05fb8164e0837c2c21ba24cad43042d08b6824f43da41fe44ce9a6bd66a111c7ecc8a84100c0990f481cfb0b0754382a2fee9bdae163e7f2c24072fa4ce9450782f33fa58c63eb75bf7e2c420476291243c88091a2908a405e1bb17f54f675d08ba7c96204fb097dc26bae259b41ae333a5ecb4be0415020b24eaa09301498f69898642326b1d2aec9755f26846ee8cd210e5bd491d26f8cd808656e44eca690ae33e9b6882188fb299327dc88753a326de4eec2913dc8e5095d7dcd963872dd4e95cd56468a83bf42586b56803cb0063cef42b41c5c863e691d22102acb329ea2d47f5018fff59caf96ef219e525abd6a29599aec65dc650b04c327c1f454af352beda3a5e22ba32eb0fd7e44d34fd07b5d2b311def030f7caeede5acc3eb5536a2242406faa2ef235099680394da385e27887c3265959f760f80980c611fd3a9566627a32ebbe6a165d2c00d84aba57944f1ea4cef4d592179623fad97d2880e600e635311233b973952902bb62b658a7c5184a9b21b370b8fe60d56c3236b2a00327f4dc556746a4323b0d17559d6fa49878230f58eb4d01f3faf44d67e5009c7f33dc416c018a58c551848797444988cfc275a8bd2da85a363b0a366d9a52086722cfec3b418f8d4702f636938caaa574259fea6148382440c79c528fc09190b0edbb0b9cd02c8dec1fa66797405aba8d05a58328e3ce3b37804b24300a9f3b875a2d8345be2d0c30d9e2e40a55a5e0760de9f02a66299116412797f21adc770ee9c3e5edea62d19306284a0b9fb72c65f5c1d14b54ec9cfc9a5080a5c162be5c52eb15930cb3faae303323fdc3ed1780bab1721fa05c9b72dc1e01a1c55dc7bf16a804b31c75b800dd1c6df8ca914b40022f0b26130c1dd8083c79fc546fd6f8eec49113e4ace29fe1dd1b40a255c412c0986827e8ead4a25d0b36f993f9e187574e9167adc002ccb28fdbf0f1643a3a91621fdfc0d7e7de909600e8d9cea1b92abde5460f34b0d313c219a13d62137338ce96cf2c3dd6c07601270d178d1d95e15d042d8ac35a5f2f0aa294aecf4c2a681fcd1e92da2e6b5081f766f281bfc4d27af3152b82f1b1427a608da3dd2751b35b1c6f9ec44bd57036974ca64ea777ca0e7c14fcdb91942455d7dd46300c973166ce03631fe6bc8cb7b801a0a171ea0c086b474bf6786d7462ce501a4161b1cfec274839c29599c99eb10b2542a10f52fbecb082e9ad4b52657afdd8670043a599568836db4903b1f1b225dac8686c7fcaec5c47dfdbacf94954e506fb6013f8decf2620b111829b3902b0b1b5035b2d77c3d79ec9661378b51b25d8016c670a4cd0e68813d9933f8d024e4d4eec4ea895fdd6966ab3817a726cbaadd321f029015a4f65bf482190de98a213feb9815a65caec141e687189d56712608243c6982c7eb0109894967865003a63b1f83f84f39fb1031a1662b3dcee42e2162940d082a25bd3b3513a31b20c2530e9477a4fe9c056a49f9f5ef36461daaa946f289485470061560fc4b7bc110253332e90621105bca9d8d9b386a7ad1a675b15206daaa00a2887a7558d5e9e3656bbe83bf25e8964558dbdd2344a0d7c7ac3ce03750bd054a46fc29e8bc11d97c13cc71aae8cf9fcd03d8c784aaf62f39f438689035ef0f96ff406b4e4b98473cce6b9579eb16ec327bca6bfbb6499da22364a10312ca2bdc5b08344e0e1838797d282b8043aefdf2611f84e3d717e06bbe1f6a6357fa453852d4a6407f4f52ddd4537c6982a9e2af7c5901d2c43b1092f0b3819ef564f37a6a04a8d4d81a1fa7a346187a5ce904d719ffc6efb74deea9ff6106e4907577022cb1868ee833b23c5cb608cd7b0fd308f207e4b9491538069991c3d1e00861801efa834f6a89de69b647fcb9e648c231ae80cc31147fadb619e1b480dcdcb43b58c1cdd65e0f8a25cb4e25cea6123bd5ca4b60eca7b0a56a92c4bce58463ce48223e21de84747f308097df3686e91605f7971e1e108eb7b974b29e48a93d903d65bfca9557523a3140b35d7e12bb234064d7dd704e9e6df68785545f580356d1cbc54e2e53ada37445e24b173370a360ade6dd16cb994b1cc358c9eae0e1a2b26361b66ca45216dd374f8f9d13f6b8f871bdbb9de2445afb3b04104b479fad1779449a092b9f154d4302cdc0b02ac5f660fde041baa3162988bdbcc002de380e0bedc3323d07050045dd3c6beb68208850196fa08e75719335321bef6d8bd7a22b784f4e1712167cee0e471223c23a5c776ddc9249a5bcf4a71090dd04e188f7949481e21f33ef96cbc8c2b96db23b55f6f6358347108e185d2e4f93f0f1120aaaad6664dc4079e945f02553df450e07a40e5f8ce3ddca2ac00b6fef4e44e6a805d241a167ec797b702a0880220491597fff8dc17b098f00bbd13516c9469b39182610e92e02899852cbff53c19325697d34d573cfc48c76771155b178a3cc8e56de086fdb830923674d9707a3186b617b29e04466c919a8e40dff20c41baf878c79bb1b11c7ad855de0864a0d5b7200fddc769a6364a32d9c922c56242609419430db85a12518c273ae4f42d96cde2c90d7ce90f47b92d44821743f443ebcda91c62048588b59c67db69e7d45355e3727cf0e42ee7a87382c09f94631427b910681c5330aa82c01cdc0767ae4c9cfae5467371bdd3aeb85b2ad2ce4f864a9db95ce6d71ce22d22188cbe5b4132374ff52f40495c1e914d66e03ab65cf49f79dae419102e5c47305c04e98ca4da7c03ad1adc0ef4e3f841068dc861f24aeddb62b85bb83884f1aae70fa0d6100b6a087a25ae0098821562d46db8bac21b4c62a9d093abeaa546543429f02ef404f1a7d32a343cf94f468bc9798a594756c889aaa314beeff83a9a44de5efcf9ec528b738c7ff559be327244aadb8b67bf8868ea7a808a9767929634c99556563cbf7a72813e570ddcca3b8b6ae791702e38d793270b2426dabf358627e4d78f777969adbe8af345a845d211b3a44fb070cd139ca575ddf27f2d25f23b67d48444357ff888f60008015f90336a8d59969c005e0cbff7686203a95207121f3ec5f691dae75e29a5fb83a82d9fce81cc6e1f641d445380deb97657089c741218ddaf56d3b1c91493041bd1aa3386feef390d8f724f0c070da501787f361ea0be9914f7b08de820ce6d645199cd232cfdfd5df43f76d37ded55b4c512dead744f18755f300aa1676cf627a08ebb10e0b5645493d57ff93381ee7efa7eabca6410d49666e884f89ddb65ce67eae91725133a9cba5ccae5f4ff8c3ddd9374e14e9be46e510c54cd9abe842384b8973010117474ea30c673f0e0d6928b5ab803de511a18d851dfe4253c6ba6182d9398c2443fd5d26954fc1c60ef59aac3f7b9ba9bab19796e229b00dd517d61ba51a1ec230af124a97fd046ab2e9282a8d14915145020663b0634bb8f8b29c0a0e86c23145514597781bea48cf03f300daa13dc0c5256806f8beb40b65fa3f8503a59af32ba7fe79939ecbc315fce4f73ae7d539fc51df5c81f208094012c89023e1bc4920a3150b46439fcffffffffffffffc2836884b6196b5f2699a4d43fb65e9f93292599524aea8a507fdb7bb1adce6bb700705002370ab70a2a0b6783f633402006064ec07808a3a48a09795f762b7b3b7018c25829438599f9948102331e8d11b081a310e628ae57faf7251fe28430560a3955f2e8312999580d1c8330b9a85c29994ed23e98046112426bde9d754e218a0261d07d7969a132cd4407104693e521f7d357d7e40fe60ba2e53fb473d4b2f8c1a0f7df345674b793d70763e86041041737efed2c1f0c6bd97abda71bd6e93d184497ae9efc5c8c9f9881430f063993f263296112dd1603471e100d0e3c1872492a49b12d6b2a5d068e3b20871d8c132f3b826ea7856a1403001638ea6078ad98aedfd9a225a7834955a4eb9a373122c77d1b9cbe2570ccc12c794be95eb864acd982430e5d8bfa49b2f3ccf19a0c573150b0813478607860666046197130fe7552e3a1974fdfaf070e389842ee11d52945d7f7eb0e1c6f306e8dbe9896f466a204898101316c6c1b38dc60125f5ab6e106071bcc7d7593ef53487a13101070acc1bc9ae57741d7a5d21b047567dc020e3598d5c45354f6e3ed48c958ab71e36f50461a36520d1b67a41a957fa38c1dbc7f192420f63ab091032788230de61093bb64954b86771a69f49a064ca08292010e3498b387c52461225f83be41195380e30c061dfe9e2fa4b012a5b4c1e9b7810dfa0635920d1db0251b3ac0097098c17055f24d25a70b950f9571018e3218ff928509db5056bb93c13022fe95bca4c492c818cca9bbb2b7544c072c050e3198a3e536e1f14708cb3a0c869c336554cd4704638ca154e00083e16db4d5271d9f274f38be60f894945f9dd6923eb91a26070e2f985267c7e40f2a2718630ce50347170cbbebefa72b574fff655c000b1c5c3057906a7f41733150000213ac81630b465739bf1b09deb5d7c0cf000187160c2178fac64d9e4923e1c8827135ecc297b84ce0c082c12ec7df8591db298538ae604a5a44856eed2748638c31ac803c930bf1c55392048e2a18c73e575e388d3d1351c1246fb174ef6939a6604a634244106627cb13a0148c56aa74a9724f0d237044c16416f1da547fc4fd13148c21737f36436f434d4f3007a1baa7f3236278de09c6ebeba4d7e72618f29d0863ea7cc276ce04d35dfce533a14e657909a67abdaf0f2b17613d4a302515d45e5e11d2c328098657fb71fb2072b86023c1d43eb69eb49e490e3a828d911c46e02882f9b292522907217663250229824ee710cce152cbbe49eef0d86e091c423059ecfb750ed7dd49b5040504c3a419174f9d4812820c0cc35f28ebd2ff22ed41c55cd0fac258226fe4dd30f5c2242b2cee93887861eaf91369e3ad257476615041d72bf2a90b53c8ad203ba48d94839d0bb27857c8d6a6ed1e63d973f4c5195b3109e38db791831a4b06a100bc26cc7b5d8d7c0b835249453ce7d71686fc513c4c8749a6c5ad85717f84cc979b1626d9ff9d90d35c3ca9b33059c8b8f0105516c6f8adc94959c82657120b73b00ea33fe8242c0c3ff163c40e93d542f015a60e5a34b55baebfe40a536e919ebf9f43c9cab5c260c9266dc6dd5cd28a025861d0cabe52d12ec53dab30a8d9114ac7fe51492e551844a6bd455c3f1559292d3fe975428521dfa7a97e855c21994e610a23fb22a27fa776c9146657b3acbb5ca6564ba530a5ad0cd1331e24a94f0a43f851ba4cedcd24ef4761f2944d5d52e5a5f14561cab75a290579288c7212dd84b8bd8bb183c2e435c2528c2c132be29f30bdec7dee2f1d2996ee09d37e6f558ca4d309e3a5668d50677db23c9c30c7a9d23fcf3e56a9b30993d25b39450a61f683ad09739a8a093a6974084225135ad70861c23023f1b2043ba9e1954b98c56554f6c92c215ac268651523e71257c20c5921e694982961708965563a65ad09f224cc7e966c7410af2a2749984f6915356b3d267a244c324ab456f81bbfc842c22897bccff28ac7fff61166d1eea0ac3ea7a4e408e3248addd908437e4f759e57216c4698e4979658f2751127a1bc3c8408524598724a1059eceee74b4d84513f449c7017f4e85111611eb9172e589ce8f9218730cebd5d9e53223f7c8821ea1b359284b4904298e25fd8ab6f5d8e242184d145dac5f828a195e7208c25f47da49935152a8230d998aa88b6a022693110a6549e4ad47f29b32002c21841cc6bffff07c3ae78ab5ebeaf1ff9a130eda7f4b3de0793e88fd65fdac34b870fc6d221f7e2a9f76048fe313c62877f5b4f0fa65879a62f25793089ffb7d3e21659abc38321d7e4ce509d456e7f07838ef2cc0e66754f2289b7eb60f4a03da4b42cdd4ae12328800ea6ec10dffad91ead3207b387d6940fa2a5c4dca2003998fbf24452c943e26048dedba17f3412a4a100381872342de35b6fb9737a83f9822ef5f0e979544e6e30ac6ec9a888ccf5d1b7c1a443bcefbd9899be3e1b0c56c235363cc6f885d660c8b9f9e94ca538b1e36a308d4895eb2fea6930aee47cf1a9ffd3480e1a4c419c9ff9aa256db13e83d9a468c93035aa92d56630ccc752132929cb099532982607bb6b13e299a3420663878430a6372a5a5dc660f4dc29463c93c560f211b978fd881bb286c1385b51422a3d35b925188ea12a1b694f5f3077aa7fb76a7fc88f17cc4976bd85a958296dec82b992fab64acf3f9ec305a35795aa0bf5313ebd05e38d57e70fb95c49755a305e3a799eb3ea3afd62331490057387e4b69792d2e94fc282b1ce3ac9f8f824e2e8af609219aaa532defcceb702e2773c96fe1155c17013f594d4ff3c21712a9884d6c4b4d27fe94b5330e80af627642b05937cedd25e9d4c27d95130bb752cb3ef0a14be74332f215ee509865b8f717146b632632798f774cc12fd9eac83b609667935ed977a32c12cd721844b30b5b2e112cce925d6de3a68195109061d52e6bcd905e1d725c170fed1c727f9aa9690604ad53152f8ed9e9c1752c01130533119c170a942d07d9db37d9e8a6048c27a72ca257be3f40a208241a28ca88a91ec29e7153004a3a96895537f4a59880284604a9e7a3ec5d472134ac13088a50b297e47c0305d4af2c182d07809fe2f0cd739d4e979331dfefac224b353a530b7f6c278313232744f5e9842faecc5d83995f3db85715de5e6f279498c5917866c15c53a56f8503a940b53ef4e8aee2192880be2c214645e97e81423a8945b983dd6fb920ed726c01606196d73f772511e24a016c66eddbae461e634946861f0cefb984bf75039cdc2a04c58ce963c5bca7564611cabfa4c11722c0c631fe729fc75953861619411ca530435aff6ed1506f9f3a554541235b62bcc2dc122a41ccd3071b5c290a3479a5821ebfb618549fddbdd53bb7fd87e1506cdb8930f2a5bfa5d15c64c4d0941881cfa74a93045319d5efc42a830e9b85fa9273f8541f25cc85cd85870dd14a618e1d44ebf530a8350572e661b290cd1f6dd763dcde8708fc2144edc4589708bfdb6284c7a31bba183426190dfa1e6d2749e561914e9c4cbded922fc09935dce8e16b395728a3d614efd6a3bf2e2f5aed2099356779ccbe179d3b39c3049d4ce92266fc298b7d6313ff5cb6435618aa73aaf6d24874f66c294a447b1d4b09c53b5983025b30ed94a5bf457f412c6dc52625da3a3a65ac2e09f442e91c4f38e48254c395da570e96927344209e37dd09fb2e53909e34bfe78a6e22909d32789332af983a57889846946470d4f199e119c10f7d596c118caf4f2ba875fa64a06c3ac794839e1ef434cc760fe9338b23ea204f5a71850296c961695c530983774de5fe5c748f20383d1d2b8cee7ff0be62496e339a8a4eb6e73720ae2b36c85e5d105a3c950932ea9d86c2b3db860b6d149c731d3cdf46f0bd97552ab164cb26eaa652b5ee66264aca14fc306b2db814716d0f1f3224c23076714d3838207164c65256e94e7b42d3cae602e65639ea2468ab896580d53567858c194f74a4df8ab2c964c457854c1f8d1ffe2ab04ddce122a98cbd2c80efba78318a76010b2ffca76c7837b09111e52307e89119b76f9fcab838228182325fd9b955216f0808239c78b9e9f72f48f952798e5ddb479d0179961999d8387130c3329cae51cd63bc96f341924f06842422fcf621c030f26982485cacf7b48a3a3843c96607a5753b31234069f87124c51547c3cddbc637cc85813030362dce06d604c108210f095f64882073c9060be8e707b3a3df668c97dc1e308c6fc7cdb17ebb81c3f848711ccd142463df582ae24d2078f2218dcf334846bac6f8ef2e0410453e7aa4a975b1a824988bb4e6ff11082e1a4ee894a21f4c54e308c7dbb9643b9db48f081618a37b12e59857e61cc53162d5b12b71c725f186b3ed552c3fc92e5bc0614111dbd30ca8b0e49bd041d7288f0c2fcb7b26f21780a964cbb30d90911b4a4a02da8ef7591e75cd92b9872a1e5647fb612c7854105b311b9c27912b2dfa21c31f2a70eb3a0c316e6be9c5417fc24574a1203033d18630c5344472dcc9d35dbce9456684f6961d02968a8b78549299a85c15625260b53ce49a7d873652c4c3ae5ca93ccbaed14c2c2e069da74ce64e5f4b98e5718bbdacf7792fe77571dae30699af4371d2a3ce7dad10a434cffb8dc69647f7d32f6d3384304638cd1c10ad3f864356bdb5c0997d3b10aa3e5fba0eea49e19e85085e174e8f939c041a331023c0f74a4c2e4329f7b2c8ad0b1827fe84085a923567708ba7c63c5e544c7290c9ee6f24254ccc841aa91c68d33c8404d7498c29436fa417c45aacf3db071c6096eec253a4a614ec173e62d78e578925d1f3a4861eebf35f959234ffe2cd101d1c1758cc2a4c39d48e695547aa92c0af328e195b2495d0c1da130689c27bbcff2f711ae403b40610a955eecf3488aa1b78e4f1824071d545937de0639b041b6c3132695b835264f85d1a771e34590fa848e4e985e23453f51fe196798e0d4071d9c305dcbaec7db0f196bc4522a2303d9b10983f6a94b8a569d674732d68e8d336e9cd6343e043b681390232de8d08439f27ff220642713863989f712a29fd26562c2f4c94eb2dae9507fed1206dd79424a8f9c3aaab584aa23e62b4db850072a61d2da2ed692844cd94dad83128618579683b02c49e19540c7244c62419c4823e37fca27634d67604619356ef40cce6a7448c224af575db2bb3fde8f84e1841ed562112b749f206188233ebea894479867c4430425b28e30c6964e12b2cc8d3027dd2108310bf3fa3123cc5d2b41ae04a1e5aa2dc2a4de2ddc27e6841cd48a30b6c77f92e93a237212619ee41255b54584b94aa5646f7934d0061d87304dfe9027e6892779ad210cca2f0511b9301b3b29842959ff7e8ed157f33c210c9ee3e792131984399a668c87b06d7d16411864e4a598b33810a653eff944673e7c5e0161bc4e3aac94bef422437f30be75886a79b0cde81bd4b071460d2074f8c13cd79ff695ef1d731f4c3a7ae3734c5d7c9b3af8601eb153224da7875adfd0b10793698951e93f7e435ec618a30c1d7a30bb8952ba9245ca65e7c110d79385c8e94e2733e1c1bcf93d16376542cc10093aee602eab8a15254f7630e959f96c48899192b6a30e86a0b23fc71ef5cb693a982559306de95547a890be3107d365f5f021e7b782fa7230460e21fff563bca6280ea6b9601eb7930eda3c380231306028820e3898fbb44d77fa88625f7983b9e3267c7b753adc604aeaed6404a196efe28e3618741cf16f3a5eacc975b0c15c322a5b6a0f95f8411d6b305d57c8cbc147fb5dd5a106534e1777429851c971471acc29b376245af09c67d4810693b89265f1e2d67106731e0f3ab23aad7b3a7598a1a30ce6da8e961ef9e62fcf64302755af9274cb8ba5948e319894a5d457d9573d9a5087184ca6e25e59f2bebeb07784c17cc97b84ea297580c1dc9e6309d9d1449e24ecf8823154dab0681ee75e6387170c42f99ce890e30a7474c12caa62c988ab7570c16ce15497752a756cc124776fbc453fc2850e2d18af5ef74d05fb3897ecc882d9c4086175fa43b0bc93b156b2091d583078593ce541e92041d664dc681bdc48cb29745cc120b664bd8fb0a07492c6df60247458c1249e9752be824856e111dbbe362263ed460dfc8c8b4207154c4ae7f34a7491ef9b2103c10180091d5330c9deee284b21edd26a850e2998d2547ab31ca794fe3f0a86ddf2c841c72c31f291a1030a26a12a28efef70161d4f30d6571e7d227a6adc103a9c60f6d4a347848409b9e464ac1513424713ccee275e4b54aa850992b176b68b0e26984daaff4eb0cba3bb97e139406f63cd3a96607cf5908210da11a14309e692ffd68cdd8f5a0d6446d748c3df868d331c2f0523400108c6188334a22309df46d01e420551714400f0840e249842fc3ec9ed18255f54888e2398c37b12570949449f91fdd0610493d23616ef2f8fd277923d7414c194ac2e2bfdd9b67ae8120f1d44308b4851b27c5e8e4a7a1d3a8660f8d7c8edd194086b4f87108c592167f4ffb94bce81812318c6eb30c2e2538255489bc0010c773e8ee46f512612387e61b60a539dd86eca26cbe10b47cb9caab16ad4c0cb40a30c397a61baadf06217c6a485928c355e9894f6961c612732d65e0767d84083ecc2fc966cb764f9cea582347270460f1a0417c8c097610305638c91460e6e705217e6fd78b23d89989eefb3326ca060066694a183336c90a0ae56c0910bb3e849cbeef87061f25c953c67d3e9d3ad5b98635bf0cbbfda41cdcd610ba3951ed39da487ad7a6a610acbf38e60e1bb744c0bf3b55e165521b48fa924143866610ec26b525239fd39aae39085d9de544bf4b2da4a411cb130e8b855faf6179f4212072ccc398654911b59626285e315a612ad4ed656b6256b0e5798f4a7f411b4b3f5c511472b0c2ff973be37915cf671b0c26c2f42eca8a45444876315e66d13fa626dd35694f4c68d37430f8d326c906abc0eca4011b8a0060018c1a10ad3b6c9a7f6df6eddd2e04885f127d68358c5b67d97a83064b94f9f2646d0959392e31486590f49e280c314e6f46b4a59104ff1692e85397ad22108f70bf9107c3446200606cc18811818e8c018637090c2f8f964a8a8898ec214d4d57a5f885887958619efa2c83cd6fe509834b6d4723c670f7080c2587ad243d076291f1232d6d0b6031c9f307b780c612d2f7a47ed9e30a5bb1c1fbd7119a70c393a618e3197191ec2bde3be64a0208b15383861ba60e931c7b38854934d18437877140fe1ff276263e0d084b9e4e64f503365c2144786b22bd3bfc08109c32753b1d2449aabc0710963aa9ff097fc1de32e352c6132a1449f0877f996304725cc5f9574ce7f2ea38451ee2eb6fb6dd44426b1fa9998ee08faf693b1468ac02109e388ddd115f73f1a9130868cb8723a1f27fdcd0109a3e9f0ccfa0d353a35ce40c6f10843d2ce12ea16ff53ce7a60e3735002fc0087238cf1d9b2875ce2137034c27c65daa5df7eeafcba4119c8c1089350a224690ba14347ed171c8b30c8336d51fab4894990220c23f52585ca3825a3cd011ac57024c274255b95c389c958eb341a751a9d81b3438439c4d39c471fc958db47b7349694868d336ed80dc26883594250dbe1c43ae80f1b4c6147aa4593abf1c1b20653f64b951f5613c7623518bee3dce28abc9d531a4c924288cad0a2c198163d480b5b9fc12022e6b283f97d4a9ac110abd2fd7bd3329854dda4d86d12321852f27ca3151e4f98c6600e537fcdcf5a621783b9de47fe23c9ffcd1806f37cfe9f705142550583d1de4b46f768651208e30ba6204743ab68ef05c3c758b270739bbf6417b0ce26d404317a4789b96012c9ea2b56ae101e4f1b67e409630be6533284058fe4215ed1824988faf82d162b744a66c11027cb4e106e95ddf5c0461a663c89411858305e5b95eafa3afbabac208c2b983a3c5e88e65ba1d5b182f1f397d896ac963ba5aa60aa160b299274cba57c2a1854851439cfc147dd3305d3dd7b1493659182f9530a2e63428d82e9f4d9aa7cdfc51625148cb17f925372fb1df5134cbdd96155c24b92f085e104539ae7f5b0939d208c2618648616e126526ecb1e0cc26002f6de273bff787f7210c612b09453c4f7ca49fd26c377108612cc7d236e7e157ebc2c1784910493fca9d3eb9d173f289d9186191d20411848205dd6da35753a0c8871c836d240037b10c611380c23a8f9e93a240f855104d34e6e65ec056da4814618443098dac9a93a23faff52e36d80c60dca40038d36e30c33126da481068631041286104c31a2f5f3920e1f3a45c69a06c6182318a6687d6e23929c6c42fc018c740827dc7d2f4670f0f10b435061ed93529523a4f6c317c6f413c9d94ea6ff5b7a61ceb7f0218f5e0f0b3f2fcc25ce639998eff0b6efc25421897cdd7186c3872e4cb32729ffc80e2f415d7261f6eb38aa53e592f4d4bee10317862826afec736b753bb730974549410715a4a6986c61aad634fdf079265abcd4c2ec914ad6a79fe546190b820f5a9874d8b8dc7df92c0c2a7fbf1fe7e9e2c8edf0210bf37cd995ca444b2cccb61e210513172c4c25b994b6607dbcc2b415f9b5a4e7ae305ef0fce941eb34444a2b8c559b16174197a710b3c21455a26bcf9fac45c9c72a8cb2f19fb2a8bea99c25636d35f0a10a735f9a9790162d7a0eb1c0472a0ceed9f49da77b8d7f64a4518619638c199851061d3e5061a7305d4e397448994fe2ae0f5318258e38f9a92b87b7df818f52900f529852860a9d6db370d9761406d7d1511db449a9f0210a539e3d95f2b89e1825e64728cc215c298b1eb2a030b75558fb089553840a0d1f9f30ad87917849a924af2f9e309b6993eda4e2de32a265f8e884794543355efb635cee8313660f3e3a8470f98f4d98ba93c8ac905532d66a70a3d3a8516ae34313261d43cbeba578e1b3f6e02313e63d19c1d2363624e8c607264cba7d9dc289741f3e87c6c7254c29e5cb49930ddecde81b669c618605c618037530c618a800c0c587250cf249a9eb590f495755ad84c96425bba4bf38418614111f9430ede8a5511d2d859c3a0e1f933024cf8ff6f24149bc21b14f99928cad8183bf71fc1109d3c70f22debb95c6dfb861010c70400c0c8821821168a007e4111f903048cf8e2621761e611295b91a164e7bb54a8b0f4718ed3bd88e078f7a154d679c6183046cbbf868842145f21073f11da45a186110f727721e7b89f7e5224c4129ad7f31354518feab5a23774c909927c2a4cbe646cfafb347bef081088367f7202c99de05391dc2982ad142fe4ba4da785cf830c47d14c2a4a56321f444de9e9d091f84307fae3c158bba222ae4c2f0310853b84bb5753da7eaf282308a7653e13c53d72a1bc147204c2d9e1fc94b8aecf00c3e00610a6d12dc428c94feb7910334ce061f7f30ab8974fa6247c6a9948cb51ef0a08c5484061f7e3045494269fe763efa60922c626fe9bc2284341fccaaa6246509eb88f51e0c1f64549c9fb01ecc67b222f2e7c98339c99e252d953db6bc2a7ce0c174f59323c7506175d28f3b98b3a5eb10dba10f3b1896e245855d4cc6da1563c1471d8c15cf4c7c96243a986c52994d1a1532d66e2033fa0c4f061f73302595836f9c0e231ac21ea45106213ee4600eae5931b392ce103a7571c074459cffb87e95ac81c68d3a7cc0e1f5eb9873667d51926f3042ce7c3593967a4fe30469860f376479e27ba54c64d369433733f14f48bc78c992870f3620ff392c8d1cf93da99e1a3ed690b2a85a97730a4a203ed4905645f0f865aa19c23490beb6f78325870f34a0426cbce362e9ec1952a1ef74e912bd916f0d1f6628ccb9fccb778847e7f0518666b7829ad193c2a8c4c08018221003052010030377f82043aa6a219e923de1630ce82efdb394b23664031b29e0c387183c73dd0b27bb33d20b43aa2f1792b42fbe3330986639463b2baa46cc8ad9ed21044be1e1e30b065162559e23e9875fcaf80037e1c30b0695b3e4eaca5df615ea8239a8357517a16142ee5c307ae9f270a65aa9287c6cc19cba2d651bedf92ab5160c9264f68d05350be63c31dfca7a7bed2c5830298df89aee6123c6750573be8e2ea2a276df3d2b186c4bad2aac5527cf84955f86f041059350495dcea65bef43ff988229e74a9db746968241626b8a897a11d1520b10a2828f28782962425a8da806cc28a36d6440a16008ba744cbace4eec0b0a1f4f309dae382295b897f0e104939abd0c611e84c930d9f86882c707136ef4e06b50238c8f2530e0430908f84842033e9090808f23dce00602f830c28d1b6f038e8f2214e08308370881013e86501f42b0810d1a0310f00886033c8051a30c342c40820f8f5ff8e2d1195e2307bd3880072f6c6083f60178ec82c3431765a06181303c72413c702186c72d08e0618b5a24c08316350ce0318b1a65a061811b3638e30c122cc043160ef088057bc0a2461a08f078c58d2fa30c342cb0810e0f57d428030d0bd8f81ad83863056178b402fd0c66d0288880072b6eace2c3431509f048450d0578a062001ea73080872908e0518a007890c21c2ce6e7be2c29d6ef0a048f51182f646ea5e4c87fe692b1766383e0210ac34910d533b146e68743612efd1a4943e5010a939795bea825f4f8842188fd91952304356a2a62a06003c80c0b8ca145f0f08441447a4bdd0a69545f88e0d10973ed6b856fcf17365f74c605dc8c1c68608c1f7870c29055b4e38ea4cf61271e9b30d7759ce84e5ae5c08d31c6f0d084a95b2e4fe4f4f1eb7c076760608c3170e0910983b25d55cb63c00313864b52dc7c3b889f1cbe81c7250c49dec48a914535f0b08431aec4884e1da37b66b5107854c298a5433db59f2861aa39cfa5b233099387081e1f4aa83cc2968479c4c4c68275f49461240ce7f9644e529ed35307097358f12e91bbec3995c7234c62f27eec43ac7a3db081027f1d98230cf9449a96f9eed108c35c3c7d532fad6e71469894322daa1ed4a5057711a6bb0fbeef29238ff03c1461b2e8e2315f65e75d7924c2b4399ea59727951ccd0311e6e46e2a4832a14584ef3d018f439836e5c3488d943394da109efaa8daee17c274263f8f28bbbd9315214c725ff9fa3482463f195c1e83f0f36c49ed3c046188752a0e84498a560c08737b96f18963c2e61a68dcfdc1a43b82be9b14fea94a7e30e8181f6fd4c99cfbc4a30f06655afcd26ae8755ba306fd364eda7af0c17cbd22136b2f1278ec616d78e881a453120b0f313e66f8028f3cb89664a747ad8ebefd0a3cf0606338c2e30ee6203ee94f6ea2ab82871d4c7bb22fb6f809cdcfa981460e6ad4e08c336cb0251003036280400c1480a0e8c0a30ee630d76e6b13a2e731d1c17c67d7af1e3c8f39182f088ba24c720a49a1871c4cf2f9ab3a2996a59c338f38a4071ccc39b669b57791c71bcc7daf6e2a2fe8f627b3031e6e387d8affb63b95b6e191a4d54b2663cd6dd4e881196d34f06003713f69d3b6ce93dca0460fcce81a37ba3230c618376cd448e346bb193b3803a1c71a4c6fb9748732a9c1aca743ce97143cbae9a4c13c729d2a4c84892829683097aa8f92e44b1471ee194caab2ddd26a78bfb966305f4dae907a30a9bcf72123e6e1bab0248456c933e1c19c435b78cf967758558488d2d9c15cb2ab73964f12ecc63a98828758212b6685db74308baabf8e16f2dce53998e279793cc92feeaf1cb8582faa447fe26090951622fad4a8b41d1c4c4905d7fbfe10cd4c6f400303dc601cbd922d0989b5c1f4e5397c2fc60643983753d3f521a4656b30ae88ce3ad594d3613598dbd4bec47f7acf621a18800693d07be94756673044cd0d8b55fb494290016678bf52366de16bff736528cf579678f82af7c9603c393975f544977cfa184c97ef3987cac8adff88c1c9f1b63dd49f9b1e065318e97a39444f0c910306639d99327f516ae4ec2fa47223e547574b222fbca572178c3e422871cb664a81015c684f655d4656ce16ecf3a0f447bab72d5d0ba5f39c6654d6d6fecdc2215bd6c8cd8b61420103b080a7d71c193978fa5ca1ec17747c39252b14d143845827a2df2a5c1e7794120b217fa860921842bd6be9cebdff144e7edfdad1df3a2978c1647b4a416707191085435ab38a58595a3b28607f3259d4e49ff8099f095f1d8fd59d7342365676a31d235e450c6802327475989409e414ecd4bcbdc29b4b40bde3ed56deecaa90014af0d2884a27843a71332009a59633292a0c4002f2e3c595fa08c6d1972c45eca4b4b2114cd1f524c50929025a548a949245b1141b110c42c9f814bd7df259870143b83d82bccecb16b34d0c10824107d321b32b899fddc140e959f809d3253960984388da294bf40b436eed911dd717e6f41c948efc25556a2f8c1bdaa176262fcc1f734df4574ef1bbdd85af615226e88aab31e922bdf1a32d5a59bab97023e9911b5e41f85db8f092ef9f0a8d6fe155ce3cb3493b3a5b90e7f5926ab530d8a828c172e4f7f8d0223b1d2a84d12c0c415285121e4c59a43a480b1553fa7b2c529193fe38963b395868a63eec45ae3a855f61d2397c8ed45859dd15caa46829e47a044b2bf8be5049c9911c2b5afb4e6a3f8818afc289a9754a45d57454e1f75bfee55829ea5498c2e6a4921d0b3d294385c14743a7687f293f7d0a934a21757eb1cb7e2f0a0b30853959c69c8dd2fb29924a610e93e396fd8c07ad3f298c7edf4994b83841c43f0ab3950896c34b4dc4f84551bec88c89cb6b288c236eb3a22561541228cc412b451555a14f1892cab7b9e81f12f5e3098350d9bbde743e7afa74c214cf6d5bf2af085d36278ea434bfbf4cc90d954d18cd752d9c12b226cca73b2cb4d794fe8b33618871134e998e1f36c5c47a1d2c7c76a77bb92f61d44d3d6521a7a4476a0bb0844949cb4105f949859754c2146a65f2c84b29615e8b2264a77021494a27815097f36479fa699230473bcf22e6bafd4a9130e48e94cc2f04a57d26244cd5e7c1eb7de7477f8471c259289323c62b4447742179b776c5d04a23383bcb95ad14762246182ea2c7bcd32dc29c6d5bde4f8a307f9555b8f6dd5b3711a63f53df9e3e879e1043c42bf1b4f34e0e6a3b4431a9bb5f24ba7c0c61f48a704a843f1d6654089334bb4f2a2949f22d5563c1b0004218c2e85c219b31263b6510c64ba373d2058f2823fdc2020491cea8c9d9de06820f12a2e7ea7ad30362dbeb2c1ee1dcc72e7f5075745ec9048ffac12054bc4f1f9e758f9b741525870f86a0e452b22e8fd41dc28505ec61ad2d9110947a3858d03e696363ed3c984f279d922aad9d85090fe80c2dfe3d498864f13b20d2da32353b989386fa89abd317aeaf83a9374f74a8d27fca79d405cdc188223b25650d9197433237794b88fba97148a86ca9f0fb210d07934edb177c674d5aed6f604288a6748aee92f2c80da653428a9c644adb5cde0663a968699122365c2aaa04b9db1accf9469efad8cb97ac06c39f48a583103969b83a42b85cf30a42868682cf758844abaad319ca67deb1b47274a66d06a3e5b0f859d75b6997c154414b87d2ebc89029b12be93194b52fa6a9899dcec2627075c6b32aa4340a83414e6acba9d34c4f70c1706c91ffa6fe73aaacbef004b112c7d2f45e30e55877e99d4a871d912e6031c4ca88a813ff5f2e9c75733f29fdf3d942e761f611625eda73b5902e2fbfb2c05fee4fdee69d16164c61299994246bd7737905254553a3c368d10d1d2b982d455d2e76a4492b56613797943ae8a95088262c23a94e5f9a42e2af33e3ea2c2d05d3e94b252feb8b422259758ab8bd408124bb4edba40fea53fe09a674314b926c277095527487f0f14b13cc2656742cd6ae5a9609860b1aaa4f65848fb3b6b0802598c3cb271de4eb93ec4a30bee59b28426c88d1a62474399ea1e90290505297bc69c9439ab5802318f3928909cfed93928c6038b3f8cff98b6048dda5eb927b2298820a226b5c12b1da1e8249567cc9e593ead287162004931e35af95b907031193456e74c0309d9874e661ffc220bc4e47febca4ea7c61b6cb23ed428d900b61f4c29cce4a5744cdca5e7861ee8bd61d17f35df8f15794c812d68549a84baa77252717a60b49b2246dc28529277b95ba5ecea2ea5b9892127fded52962a98a2dccab7a9a922b5c0bb34dec54c14dbc63480b438e53114b446761d2799de593c3b996b228ba08eb148e852a13643c448717c1c2bc13b322aec809dbf815a60f4946da89743922ea0a5365bb9c9cf89c2bc55a61aa5211b34e1d46c594156978bc8c972454d7ab30e54ed172c98dc892a20a9398e0ed274723473415c6f6cad3a67f54186b52fa58e74e61b214bd6db9f4fd2a628af7de53bcc25218e5ef629e5d69e47c92c2789f5ac9e36514e6ec14bd7f3d8ac294963f8c94a82a59140a7d4ba48fe381c268ee6945825be8b57c828b5f732967957cf27ae21e2d173d24ffaaf0e984499f595b291155173d4e1884458be623b409936e957a50353bdfad268c575244c676eadc936782ff2a516d499830a9bb49f95a5498fc12bf889b0ec94410a9f49628ae47bddd5abba412c6f932955a8424fdcc28717cd3218e9787f52661d05177bbe32e6f7e4920ae3e4685302281c93ecb275de6d49030fba85239151fdd6e91b1f60843bec8a62e7e658c46df00c370049eea6147dcad2935824932e691bdab2a8597a0a1e24f55901f7ee5a61d86c10893a7702742bc24f36a2fc2e83977989a7db310175b43188a30277d229e68b1a04350224cc9f3bc696d57080311064f41a9e77ab50baf1cc2f4621e57c3574318249d909594c8dd33b24218b3439dc97a09cbde12c2242c5bbb6ea73cb9a04198b2754f6586ba76d205611256a35f94481372cc0361943c4997d5a5957705100639a264d49af40fc6d1b553f14ca77799f8c1f8b9f6e1aa651f4c91e25f25f93a1f4c49a848496c3c5c2e59187b305ce94e6a4bdc30f470505be16ae4e9f82935100d61e4c1702ef36f957e9382e4cbb081827c4018783068939fcc4324a5aa5abf096e9c51469211c61d0cb1f77cf34cbb8248dbc1a0643c3b9c97e585b80e26ebed1cba5e9e1cdc58d4811f844107931239e9fc217ba553a13998fb23cb049192eef33a0c399874df53437785187799a9851107a3e6884923adee924e8283713635df82ee1094fc6f3024cb101e1e73371843a7f0ba038d5ea8f4af6652612012070402711c045248f51e00c3130010404078441a8bc462d13c0e85e1071480035228245836301a241e18161808842351201404844382502010088541814028240a27e196ec03ab41f74a5cbda0cf38737cb323ed8a86cfd25657810116da0600aa70ce296e6ae67566a0e70b7654604720f737c5c02e0d64724730741c6dd034c8fc50bdd6880191268b4923507cf74d766582231df89f0599770a1a4c373db28b2b0e747984ad00cdafcf08c0997b5e6e6eea267b805f181beeb6aac9539bb444f24f37fc683c9ca949faf447fea535fe479cd290c5f455fae73b6e1d5cb06d98220fc824eb376fd0c1de1d4480b743ac6e74a47b0f15e183e4091e968a808de6f2541c8e584911c341ca0bb86b6c938d8b7c3c2b5b544b4461523983f31de5922592fc69c79a4524c8671d92de4c7e09eead39f5d4bfe1a94df4278e6c79a33ca999541f6dbce7ee7fb86a418d54ffd00120f8140dbc9d22f28d7ebb9f1dee3f4a15f72cbe0681c61d3aeb4ed422a08aff1d39bc1c530481076fad49d9cbd92fe58118611efcd5e88ef6c36e3b08c946c14b908e148a6dc8692dcdeb6d7b5af9ff140f940d20c69f84ff2d9748fc199f7c0bb77bbf8d53bdbeaf305628eb7dd3512db1809933c2bbff7a5fda6e21c36a472e0fb4d899ab41175cdde6bf844c934671899fafe9b6045225aa6d60af4015ccc7662a87ee9f1d9487cfe553ed082d1c63fd550089f109f0a6476ec7a7ad90111def3be9d273a26aa725beb92225aeee3fdc6b4808250dcc5ef550e2b79094d8a6a18a5a039dc6d8357c3774190f03370365a7a63c1c251171ae9748682c174f23718da31b7e8203a5cb808e5808638d4d6dcc72b807b6a18fc51b26e5a233c7511c35f57d8d463b36ca40ebd4c484661f9c80837d1b25c6513ac446e73ed07f0e9d13fd339a4114886b7d702ba65328781a479cb5bf8ce1ec300d47a91f363af189a59d4e56ea9f7b9ab99c439bd905f5c0513afead53f1b3046c811da319a4ac96a56eb9ed2007c14672098d6710e0e0debf6e209b3fad0c9146ff7e6189d501df8bdd8147ca7b8f21e8e05ea2633757f4e6f3966859bab60e8bb5c1be05cd7c762000b61b38b6124703725a8808cc2d040efdcba015185262701af9e67ad7d2d63104284feb64d6eb5f0993002109aaaac1112dd71c4e6e0b4bb5e4d97cd9d90ceb3f0e98260ce2bae69033045f53409dfbba11a06654e95522090e53da0559ce056640975de35c9600f50932ddd94450109a84a94701587bffa21592dfb9e65012a0fa4773ae11140ebaafebe8fd28132685d21eca13d6a10f9ae18ec94421dc56084c35c66e1d1eca59547ad0fc0ec170bca1abe70d078bd5c17ed7772e7effbd63e4f37c520dc8aa5b2a5dd5887f3a93080e6504827ece1014f80622f0586fd0d16ab76c4055f7ffbba49c96edef3a47c98e35851308cc6ac01b602cc3fa2f23a0a7e6a87f02ed28826339280daa37f1d8ef6e28012ac3b7992e2db11c3c4767b0fcd54f9a2def88673a7a85ad3d44afb14ac087e5771d3c87903115f818a8250e062f6d1ad0383886173cf08a56cfa2c142da31174c58dd48e3914fd2ed80b49b531898070f7670907e822dc10d19421bb4d67440104da63b2a891a3ca4d51acf651f3c71e361870a357836b71da9ee74a069a5b6fe107877373c9b81ac41405283634e106755661a13990f1ee43a58befc278558c50436c5fdb45d569720729a7cd112c1206b628641d3171a19641d5baabba99dff00902c5ce031d27cee7732841421211974f0002e3e1cb08387e50c1a123dd7dc2192f560b40032b1c1f30413780ae0e0715db9d5c76af008ef83c6ed0f548e6a0d9ee7a387811d6507cb7d0d40fdab60c7a3f11fc20d9ec428864318099b40e6b307b4583b067722f1f9925eb156d5cb4058ea76f8be871624460c1a0669aa32683c0155cc4212c68ee001f6e97a29fa702c27bb2822a855719d837524ec18bb7678848d649a3dfd5dbbb5ff0073e0de55a38c9edb7b04a6dd12d71b34ae2dde6aac54b5f57a3d1efb775e284666143f458a510dce73dfbbec702304ab4c344334181886046dc4a1c66408a01c8b2d70ae21424e16835246a5346d0dae1894169478c33b565351cc4ca7e176a8e929d2614cc0e98350313f9e1584987a8375820e80054cd8f0c08b0e06505803113633f98021e3e088628c88c30ad93daa20163c484fc40afd50a4bb448f3255450e5a401a0ccca1b83c4e32bd7500e94f16a58d3b472e6c8135694c26de69913c7710d4a8ca034d91f673434fd44fb3e5691d2add2003467379045a5d75f175d3db4231ae012afab4ff57c033658c6d6d4f6eb167658f7e374eeff55ed2110f629d4a028503cb647c662edf598abc8f49fe9b384c8d9fd8c05cd5af0d549d3c550297945fd5da01e83faf6967c602eef7ba0baa36279709254d0da59235a64a31b69feddba8ab7b6a2354f20fc11ebab08f3e441faf066b10ad9b25ac15ca5516837a0861300f507c4e244389afa32cdffd7e37eb3294eedd42b1644ccbc68a20f37635b74cb661cf4e9445865d99cbe342c009b91a06000b63ff24116ce487b11a992c81c9b9db81761434f949930bdaba7bbd6c038d55283df3271dd4e7520c73008b4737df2c31aa1888f3b0e1878b1cf0b921327884844bee5a714bccac1ea25bd7f0f11e1b6e82f1d96dbe6a0d516fe8d1912c35f05a0e75b787ed813de8600d653d9c6b17aef7d2fbf5809de265ff366719869ee80311899639a26019e509f8151c866ae27e19840b2463f1408e11784a253050c4c141771070e9670e5cadc8b03d1c743106f610bc51c4fb0a2262485030b4fe61fa81a9fcdffce8654d55a8bf96213db4db24e8f92428c50414d5f7ea1db0927440a7dc31df51da2554386a7a54a906b88bc36eae965fdd8d8657d007f771fb405e35798557e9a6009aef56e2fa71caa281d2d71190a7f09990632fd0a90bd39bf0d50cf8b1a02981f8f9c18c838a061083a9012486c106702d84a56ae81d3e989721f1561cb282b4b0546640a1ea5e6d8e9deb6e2e06331afcc76b697620892e0bbe5e4b2457166de73ab573f8611a1f80b5d6c422c073900b3116aad24de0f3a0acbf719c3ea3988b7180b8014c160535c3871bc6433615e2ece25ae9c9197d090c624b1fd1c0c0dc0a8286d070801706b12c6e587ff95a8150da4896b50d079916720ae98d2bef454ed81c969944bc4257c8bc372dd3d215fca33f816fbabd579cd2d0d56a60667ef624413aa08a31415638ea0526713b34d30661cb537620f9b9eca9e0ca09059b34e11691a16421408d55bfd206f0b868ebbe6e9524a87530e7eac8c8f0a3b3d3c0bb8ec320c000eb4b950a0f5a89df0e3def45b0507e33fc65716c7f25654279a5fc2bbb791669c662cd9ee4aa39ce62389a39c175a76af872761a0d7d6ba436037aa1d7973c62eda5b1aba73eda03bc29ad35bc4e73cd0d34fcc2344ae4f6ea2aa4ceae9b1271ca760f1dbc0a03bcb7fcf552b02ae762167f9c545a6a41dc9e7235f35e42152451c14d5d2e2473e2bb1a7663b038cf79f831fbf1a41399f39950df4cfe176f8f416ac5a09f7c098a38c98b3c927aa2fbb697f0b31de0df2935f1839ad316e184e6e2be53b26e8ecdd88875969f73193c263885ec0f809f6c4fb0f29ccddc163e0a369d4e211774edd66eca0ba7a4c3ed95a8ae40cb70c1c693aca14c43ed386b24c54a524893515afc1fe2048b2c806b04fe8bb54d320e34542fd88ba4066eb37e8d2dc3d1c5c0eb4aac5923d9a76f3f610fbace67f550b5203e31a6e93cf4aa2ceb2eb429338628bb8c8d74bde9079364008916d853126280f980d9dd74e40d3449a65c58bb6e46b691fb52791582cfc56098ab40016e046131a182c29043533120706c40423b3d7a72b4dd417623d49548ae078f503e39425e044db78c0b65a8d5c12b5968e9c4897ce33b75f273e1bcb07ba86b3680161be25abeb05cb2cc30ea5db9a3ae57f41bbe72e94f6d8cc3bab49f93700c6dee1444990c542a8153af88f10494ee60e068957e8b5f945f483b67ebadbff389931e049939a0f6dca66cdbcc92fc7af95ad9d400f09e415a5ddfaa0ab5b495c9848644c8e68e964b84bcd453f28e142b58ac7795d12f3f0f47f20d966f0252cbe851e5e4eb152a546cb880600923287414314b9bc651bf76675cb6ad8129fb192e57bd2a386935e1352ee250d3c45bc5b02d53f201f0dd3199001ac0c98be3486af99261294008cbf83dfcf5f828e8867b750a5a3f6199b715c2a3b2e9fc78cf446b11896e53a15d74145014079aef2c1db5058166d1039dae12685e5f4e9caa0f973d08ff0af43e3310cc9a5e573052ff7610ee045b505e49106ee9dba0a4070bb03f007f417c967e3c455356bbfadf7ec49e47a40c2852004a5ddb1ca97bdc04e43cf650f8ea68bacfd829b8c90f0c9b24186e76fae090eb90a0007ce265734afa1281e43bc97fd59f05333e36138d5b1e2f802f83d18091015291935b2a23e02553970a05e55fa032c6cd4580f27fbe48db17a7788e5ee6f4074a331de655c63453a71d691f68a42db119e9c977de2b076dea2d63df8373c0090794bc017fd689b3bd7bb3205c9c8b9b60ae44a9c961ecb7a156be601ea334a873a870dd16fde4c2239bb8ee4788ca3b839c18cefa2c59b21f019f0b37e30471098be5daf339f81e07688ebea1e0a691e6851d422d3b74aac8d33de2ec6894006daddeb1b0448d6165971ee04a4bbbb7465093ab6950bcf93a930e7c00f8356e9d1bc67da851e07b79e39a579b39caddf4bda6333dd9c46c2a72cb2b034b261e209c301231cdf434b7e828f2c7f4464fd6cde242445cfc43c77ffb02800603bbe3c6fa133f04203b8a7d5bd1cec0efee9dd082435a3fc13bda89336040fa736b11e51fe7aa5ccfc20a6507c42bdf69fab2221e1e382593c02adcbf45b5add7a506c92e9ac02f51e620d37209ad315b59ef012ad22d3b3bb85ae67a4ed1f1a4a12c901c2549273db085365ce1f769958c7b0f1bc64a66dbe8318deabdb8986dda60f4b6e648a3dbc21263225b8b325402b39f406b7d23937360fa309a5bb68c60d1beeb67800a3100047ab552c63c5f777bcb8160ed2d0bcf74bd604723d4fa42f45b13874e9e95186c43835b3b80b5b1028acec69d0f71325de08d5327e9d8e0009896f340190fc7232b2991e1bfd1ff4133eed2cb74ee46c98f7b2a170847355a911f9cdd4c6c13ce38cddf9f9da12caac149f750c72238ede31641f0183f2e2bdc266a4f1823b01a888fa2f31316897220b27bc7461daa80cf6fb489f53d9f93ff6482e016258325523d4ea4d421566ed4384a3db5f5d987aa9401250734f5b7352f0d87befc1dbe41c92a4101e73a0b485923ccf99520071d634a14a8ae50d44d118de7a11743a78e936444da33f07ce3fe6a5bac02c14ee24de0752df349db8d0b2c2ac6960b8c58d3338be231e3a0a641c3a8326240b4593cde9804adafed63a74f0fd12b1a9ebefe57a445a814301addd9afe8522aa3f6f7206153ab1e480d043dbf52f9057adc890c5942f3801b6852d1c845a1a404a83efa945e3860990f826ed5a85574fe5182748320a55046810e52e0494a23c9f83c18c71a462c071b3903cd222be6baa84c8b9e44de1be90a54b6ddec20ee637e4e31337b734f05942b1e473d587bf3a711b1ef22391f2f6601cc8ebc6a92d684e72b04a1c99113ba37d665d60d8969bc13a5ab1da250b79960f23c0eaeb799deb659c22b917ec462a4f3b1a2b332cb16885033f106b17d04d12d2821d354305e6d04ad0b3bd3fe31488089727e858e118a5882e59628975ef7ad0529ad1d58b22b32c00a852d7d66b26225fae6fd03791dbe0992d2079d71b5e93972423cc1c3b2c4750307e12b136b6826583a11450877eae119c3ca6d26d6660276bb2a2d51445e14743b1465846471ebc9a8820750ecdd4133e7956a89034b7b6b427c53840f5ba764501366f91bf26cfcd4f040c261466dbbdf1880781125f3c2a946a936a61697763341490cd65e0ebd9c712e71224408a6210b7762fafd5faef3a9a5871585a6e94033c199d77f8e7989771fee7191990da6b5afacf4c3f5c67e0fa39af96315f44d15a02fd8e7cfdb37831e87e930a81e882b293284689ba1a5c3e7126bcdb4498c5b045ea120e4abbff1b4eb03c1799ab56e1155ae0fbad636244d1a9323b50fbe84836e19a98e52b5a490432a88d2a294441f4d16d1ced6ac6e02040fc82a20cd1b63b2a87f13c12441a199da27b8da08a9822f645096078ab13d8ba83e78a970596418829f786a24274aaac14ce13bb6909a26a42ef5ca50e4af0810e51f85df0ae9e7e0f9a9e749fca9f2a7cf816abced80cb722490ce22b75e441342ef96ca933641dd02cb38aacf8820ddfd85b9385822e5bba7ae972a817df8a66f96db2666e915ae768423ec88f188968a321d62a8178964af08cd2e104d774a34a87c4d4c00fbbb3834cd3a8b2626b0a015b393137efc39fd82249d0b67ad09043473ed2316bc27c142f254b0edde9f1805ccfb2986eacb51f67499b124b08405fe7f824b6b39651a4f9d9ba8753a5b525b5a8ac00b4ee70f035ccd38751480f8833a71680278183e8aec9d776283fdcf445b71abbbd05a6896653bc7d651ba5c680841eedc27a3266ccc67411c0b458d67f63d5a6daa13f31b62eb8b55f5c155ac30873801bcda2c0c6726a64f54527511838329578edde956aa40ca0d8db018d20f5a86401b8f2f8d5daaf7edad1667e97da463b3451f9e66606912225bf228fdc820ea3db5d6baad7c2905e8c22a22ab237645cdaef6db8b36dc9dab536a4edb4b8fdb24f3f250daa0e47cf7924e1a51b890ba5d81fba2d363dfefd2e90bc52a74320796f53465c2683f8be470ab5b2739c76cd445a8f2004b672115ecb8a44c7e29e2a04b4b5c07a8201c512357b4297056ba1eb08f706e259408c3fe2778bfe47e5cfdb356dbee57a0b07a26938e43e3c81147328375778c26e7706c74920e3f8c416dc7fe525b4b781f7de7cdcfd38649ffc9e71914596cc2a1a8a9b1ca11d31346982a5e898880c5dc092585f19bd2d171811440a85995b8fde6b4b1646a1e6557e3f4c95479690c1357fda02fc43e872074bdde2f020ab9647e6c9210bd745e1fd1f98974459fbd8cf1eacef6fa9b5513f524b8e203631c4d520f7da9f0f27153f976a125374edcabb5ee2b6024c33b19fc9fe2bdde45f3619a50912b174cb0603c186e61e065092a62f25757e7a7512276899aeea41c12eae45a019dcf612222d2c1b0d273a91d172cb93288c354e1c76293fcc7d6058169a804abd08557db0a5ab1086082fc9a4b7a74bc324dc109486c8778003825dc43babf0f8f04e2df4c69863747907ce3acf49944c82032de235bdb5a32fd364e9f13812a59aa92c1471b97eb3374791cce52a1e011231eda1f1b87bfd4b192eee36f40b89ac4525f0803108f2738964fd711cc844025c304b5d48020616223bdf31aa4dd557ca1931068551223374dbe4f2668037d05c35847884055e3ab5c152ce466865d15a01d3d5c7b02f2b1c42db858cb49d39143c96426b9a6551b5b90949f2eb87631757679534d21a64ddc36db3dd172c3ab28e378646efab7b6562cb76fe7e54c62ad2d6f12e008c49df8e2525a89169d3f409075e6221e99a93a6a7f463960fd47524e9954df4f609c1ecbf7f23e546e6c04dc4144778635ba1794c04b00af52d6d32684898e9317bf3b460627abab17cd42a055b28fd6e2d58f5a9c6df5b70d09596a29272329197c07b0433454bdfc25c02934e00115eddbd462e4577f2ceb67c44982d2c2b84eca7652f46466548bcd9fb28a60eb0f2941fbb67b2bbfc6d21be3379eb37bcf56c6b44ef24f50861b00de64cb3d6b0c060d955a50f5582222eb2802b3ed1de51bb8af2867d5989c45a92e7c7ddaca24fa404690d4bf5dfacfac2a22c0b7252f2e57fa74e02eea5a1b9797490ce100e487ba3bb892dc693cc60c27720aabc9e8057dd093b5d4d20505918635a1af736eada7b781254afbbd4a94c720f1f73e786d85e86d327affc96c1ceec4e1b28c70b113a61d5a5d15cf859471f435ec632113db6421abb55c6dc95fc8740acdfbaca88f5f52cb5bc31314b791509b1598e3773dae0ed3df6e13fbb43d6b91a1609c5d2447dfd4c8032d083b921e4939953e954a1c63393416d3a1d83708a9cabdd1e34b7bc53c4983f97742da9345aeccf5ee4f454e77c883d2314b1c6c65c2a926b63776e5f2b2c95f4d47ffba37c9b6f722cce51252cb2db3d87c35d2e5d25f778fbd950aa35a99f94556eeeabe5e60212c8484b072b5881cf2791bb6e618d4a407ac5841d1d84ea0053f32eb4d4e4abcf8dd8adb4b8f7d8e4122b4ded650b64245d8363663f109ed85315872e1c3c94dd2fbc6841a0845564b617d80697d51267c3827b588a48754838bd51abb13825cd36b931d0aac8503dc661e99c20946f185361dddab351e32385fa2ceee6c618b20a4d58cac8efd71478dc3821f1b44ad685a1a1d05bfe0087ca31db53adb69e9a4373a72901da6b761b2d5b04a470d90d312607eaf6189a71e1bcf7f79b9a58cd4a763a225197c3578f2f79646cc8b05c435740658e9065bc7343a21c4accf676c40cee25ac331941db3d2b6e27b3a44f56a9019e9e3586225ddd1bc29dd9b1a29a384e151a30ead38fb03236ca6dce87d46081ac9c54ae9254f70d22773c86f2b8a151e89f9c1fcd37dae479dac3207c03324a6dd0a65bbbbd76482a02eba30b02f58699f2cae7246e94b5e2a98c206435dc03cbd31989c0a83292745c8b5c57ff0749402fc3ca04d964d99a6fd5797b90ad30eb9b7b31f30b9fe80e2e666475596f17709dbbfdb54212d0d1a99f1209dbf446610e7b7f15370c45d8af465fd70c690045e0540c0500a3b81f489fa60bc869957c5f51f10e2e3d38beb1f8cce010c5b01ba2422421045219cd85c8ff667c460c49a519b94da79332ae6af53c562859499f8be6ed3353721e334b5087eb2ebe2c1114d9180e9779a9d3f1ca20477a6ec856c423be0232afd67689ba661cc549e08f75ffbf24fc42d234994e66470d1ccf7c48f86a1b48a81c4d61181019518afefcc281180f5d19c45e3f59d138f45c6ad546715851dfb6b8def5c350c277d8af1b072bba022bf1b1f7e1f8806df8ed2d6f6dcc4b30fb6e1700ffea230b5874bc89e9102d1629c0056438c1dd1e08c00abe1c62cd1e48c001535326ec0727683cf4b60bdfaaa56b9f5ba5064c2973f1fc833b148588970712a192edd4ee483f698fbf81a6fac471423c4b97aac52119ae5af7846a74f314cf587c0d12466d756890513df5c7fa9fc18330832df9f8473bd3ad7c1bfb6e6207ed183e4d015c58b5fdccdcdaa1fe1e0dc8b9792fe1c8c5933d91811967c0fbb31678d3fc578f5546f90389e232861b30088774d8a459628238c8554700599994923bbcdb7137eedcb76244b70f044c59f7e105a3822bfbd42e8e8b73b93f2c54cda5835738b51af0782c0b50fd6464177b85e414aa2b50071e2949954e43b0d24711abf56d6e800ae6cf8231d20a8e9ef672128b1fd670cede931905f65c8840b4c0c99d70ddef68663272021b8bb387ff5a0d7ae1b24ba65ab0783ea0235f20b54bff568acf1ec016e7f6e4cf6babb5914c03d55299e6c6b84bba1e92d4fe9254b982bc3f76b53c2bf3a007a6be2e3d18c0b3c860392acbbfdeba93aae1d1957a59f1a809784e3a791f428a3fdf6183f99039506c64624ed6e74f263aa7c19e14d1dccd51635f5e004343aef20ac11ec979936715701a820f9b34733b456e29e0aa83e6d540ccd037f7eb10c9620686ff5a27ac04f2a71271908e01c6f6a07bdb7cb16d84d8c1c7a18dbed310c2610bf5695c3e95dcdda912cacc075c44714d4bd0a775f65d6a69ffca7a7e3977890c910ed3f27fdb2cc51605f7446d9fe5a7e13c48c921b2f34d70f8e84469e6d9b43b4ab2854a1caccd81ff6c2e0d963dea992902e5144288d16d0f8188d01ebf147849a7b1e9b2ebb155f8f2902cf5a7f4cadd768c25fb907b97319fd7e897ae89caa42d9b6a8c066fa17e3b3235587a0376fbdc7bac3afc35c8e16cc58e5311ac5beae69e8ca7e94100268553f4f76a5619f0c8fdfa18eb468af8d51b8928dd351ae37813c47afe73c7cbcf928c808df3ed395a0e7e0cafe003dce4eb74dd71cee51574eaeda133b1fb0a3442e710a6f06ab29e7f33c0b31ca3e3b41094bd4c48548b8cc1b4259c8330dc00a3dcd8ae70d0a77a6669348ca8638c116ba91e9658d3e85866f77bcc16400438b68a58707ab1fd4b02e53814a3c7e2ad4542224d5c597e5842224290b9ea7a9edd8978a8c8fb94f85f837ed90d075b7c04992a167b3fd3e1795b97d87c3a225961b1f4de9d41b6b81f11ee6963a14bc8c048e9e54260adbef3537cbadc8df12b7441ae6e1aa85a58130094f186aaea06607c1cc3d4bfa06ce304b5c268977b03d6416a6748ad3a5d9d4ec8fe94ded80c0a2f0d0cd3d052a69b9129b217819fc2c4150192bc729b5edc0f7609d31a936365ad1f306a6aef0d892ec27834b9ab217dcab7b3a82fbb2dc5c530dd7018b2e102b7ea288afd850f1aca3927042afb6c69937ba552121f5b2c9a78fa21321eb629054e83eccbcfa490ab27717d435126ef5c9eead9964cc3376221e000aebeba8c9d3b3b041be98e9073aa21758b5ea04d0832f04fb99377872248c54a67ee7bcbe82db24a0edf465d8654d0c3ab5c41aca66a2533c05496426e11d3c658e0a773ef5358348c3526acf586ed06d857a2b2b19044522f2811db6f5e35f22f0a1edca8c8d49ddb32fd47443d2394f556ac9710c510ba4d793013f3063c7e78973dd0681cd02a6209a0b4202b596720e93945e4ed1ccdfd9490327a9a90d7fbc23832472af6e420b18759fced10ab618baf16c4043e94d84e296d3e5295fdeb09fc8ccba2dcb41274cc62b9af00f95a0885d51521fd9727c9a24ced543ab38e436ae80ccf88c4fd2ab1f58046132470bb8058387e098aba5b9361a140c824c8ef3ff12dbb787c9d6b612eae4c248319c3c865dc3c913a47efddb5d202d61f45f921ec60513803fc70afb50bd64777b10f7d649554eec1335b980054a1beb72416d78a871fc323589a6aa87e89d07b6f282de5190cc753336c96126820326dc6755b92e70ec41ffc6a47856c204223924c42f7d67ffd792fcc3889e63f5c600258311b93510ee600a2636b2579357ddb745b8b6489dc1ef29703ea877eb23994ce8afcd7f6e66999f30a06431f46e14e3e5c1417918ed5464d2b723fd0c527ae1e8b04e8e6f1dcf5e2b03cc89088f7271ff5317d2239d87f25df731f2c829d2c8c5e57912ebb159b72827ee8389b35f75f29a6ad16fe6e16c44b555aa9944dbc96ae0b1604d59038216957ef4fa29f452b5b27657431526f66125cbb6c2a03610ec9b82d0147c6cc12643f1143a270b9dd52d57335adf404945093315295d7f489ff562949a17b3bf97e1c08ea044dc581cf06d94c156f831e137e0c928ec018772da783813678286d8a0089c0a3317bc723dbe8bd8610a045cf614309e0257014c5b4cfc82688b70127d68400c8a3305523bf276903dd471a6a6da0faefaf07f25d0d97c713c8c1770ff55602d7dac5ab097b26206133af8bb155783333144b45dcbfc574900268996e2477bb7d7fc3b8171a2ea12d04a465af84e82a42f53a555cfecdb13fe2526bffaac5de2197c3a5dc993ebd7c9c77f14b3e86bca1579f2eb38a490b700e7db049e685b4bf6ec9e23fe9910db357521408aa0978d43b66ad8d80d075f49f89147287d0c3089df397e27dcf21f70f82567237c0dcfce6b85f3e3333d4eeef15f53931641e927830e7a0cc89c5d11008edbe92f904218d371beeb1b4f9136828205f1cb710e29b8115da70396a815cd9112791a240742ceaea4caa9a962e5cdc1a7f753c20cc7e89026850a342758d04ee47b4814b43ceb5236fffd5cf328758afbb723f92557fdf70bc16b3cea036f2deca4f4aa2bf7a1576b33d79b110a09f6b292885bccf7c6805e21b0748488ab60025184a53a47bbee1fda045ce314cef2e9067044434ef088a12b3d6c1ce270f2b378ce9436736e21b38c92ca8244ef3ac14a3af6e5803cc8d4c81b0f3fd412f3ef668e34ed585b62603322cef5bd8fa79aba174a447c8f9498ebb8a951545a2a735e0662bdf7fd29cac541eaffde43b21c429ffa4b86ec1725d6e832116c3f6d979641778a698848cb70ae22b03b26abee697fea238f8f6c61649aaf73a199e9d72fd3e4d4f126a17c802a286803884131fc5d0b14e93fe56586d542ab511f6d0e762e83560a930361e55fd88e1a18a7cd2120fb875bdd120b73f3161908119fa0d709f304f9d87efc53a2ecab3f9055bba5a70524a91cd3e0ee610e55bf8be531d90db4d7d949ad615151ae345f0fa522bc393c02a9796d7bcab3fedf26f1e1662e319c12173b200c6f72cfec3913c7cfc58c395d3b025a6ae4a8135baddcacb538e195a2b5750f1cf7e90227273684425e01d8fc67c35dfc8ea2f3d768c3122bff90187d207738ee4d758b776e53cd68da3118d063a1d0f5bf2a2234969fe0d76416fb69693b1e6badc9160d6b36dc69121fe2661911e704be85a8ee1c6d30bed5ddc3398bd76e0180674c9aac92531dc4ccc3c3c1ae721c152258507a92cb3dce4c6668fca56ccc6348c7cd6dac295010453725ee9694c2ed040525f66690b823115f13838bf5031d7827480bba37a936e151d4a45215c147655c01b5ea6b2cc3928c21dea76594baf491c37ab402416b2a244c99b8ca18046c01d22a03828946c15246708e70106ad758347c2f6728d04028a278c5bb2fa491b30737aa950fb2482bba68b5c12a7435a515a8e890088c4aa2a615a804cb91d968af8a7a82ca2c455794fc53b357193a46b1ea1adfd640a53250b7255d2eeaba76095e6744c7463c031de7330c3d83434d8553522cf484a1c3a19750c5a17a5147a51e88f5c49183cd373afa0afd1ceaa9a3b094f7afcb701488a8655431d4b9a827ee08ed15531e869fca16a84cb08cff9f241f4ba8f0285f65c42f346ba943ab6fab32d1a244b1652b6c987374c8dc11c732ec5ad6f2fea1b02efb1dd8cbd1cad184519ce80fd09c1b9db7ef07ea3f7432a999aa46d44d422bf2c4f9ade8553db582f75f8fb2e47566af15f565b95b560d37a9a72e109848ac3633f5bb2a63d00c882c1a059c18ca30c54ba7284465a04e75cb4a8c8e4695416dcc018d169f8a942168a6d486701d30f79b58279cb5db3c09a632c18b06369a218be336273cad4b0fa10a9dc27d41bc0386ace2214127f248d3a4f32149e19d6e89dc6af5f07cb95bec3cdcf3b884982df87ad8609e354a6c08ca6bc63dc526c36e88adc6c68645d2d8ea6192838fc62780eb764ee5cdf44f346d2f41cf5ed6b0dbf0b46dc734563e5d6730a2d92ce4bb2a5c2a8e601923ae4604a3e05c13e81eeb227c5a918498e897caae8a611a735141f7b59ca22138fce786949d91d9c831b418506c1ca03fc8bc5c0c63da50c17a462d56fd724401c0d66e5c85d05a5e48ca310c2b4ff902402288e3a3f6030b26694086c9ff4c1f0d4e066ec3024aa10591d94008b37af412a40d7a0c9814b8095871b0d817a845a4831f3af5dd66be611c05b01d7977c159a1431f0dc1763b774f348c8326176d47460d8c9014bfc7263c1f32a0284e12c6a2b17e64a36932d79cecbdb41a4feb715524f2011b14790be7073739ccc10e38335c4566fc709bb14a447a85e0444b9b597196626524361376c9ef1038ba6cae039b315e6ca9711067e837c3661bfe0a721bd86d2cb61191d80cb6c5d5b9bd91136c399ee3d8b691d98d65e51887534f6c6677d6be0b9dd88cc9a128cdae8d7af166dc144cc86ae5c8c6b46caa02beb045f90d3660b0a4900330333333333333333333e3ca4bfde37ddc1ff7de8d60c232aa45279a9292921209ac35aebce01de7e01dbc8377f0d67401ed0da10d1f0e4d52abe0757486b10e62c41ca48223a94327bb321b1fa7e055a63ce1d2e660724e0a6e8ebfe737785c565f141c4b1e13738c50991e149c94426d5585f6a5ee098ea47c5b29c7098edda4077297396c821f2ed492e698473a98e0b57d479bedef79094e698ae918f197b1129ccd6695ebd2243829e68b15296548706a3e6bf050691b2d3b821f3ebb9d49eab09fcc08cec713724cc9f4712c5911fcee30daf6690c11bc4f93de1ee45552ce109c24b143ffe8393cfe08c10f6311d467d6233d4170e3fb6e36eb2b3b0304d7b3cac52c5de59a1fb831ba6a5f7ce085cba91a626726b7f4c0b188eed1d5b47a5978e0a4c6e6cb13d9819344ea6732248f611db8793a3e87b4505a7e0ebcf6d0217ad8e3c0cb4813d66e3c546ee06d9eb7cb1f04b081ab5d9eaed2b33adab5f082d87f94ef83acb569e1b6c725211d3c0baf652e4731480eb46659781b24180b2779e6c95154d58c312cbc489a7f2bb2fb8faff09225c9a1f9871c6deb0abfe3284a9fc754af6d2b1cf97854438ea7565b56f81a3de4f918415388aec2bf64112d4398e081aa0ae762aeb8acfee1a334156e69baef49bf7df944859f3a948ea297a7f02579a648ee5c1fc4148e678f9e2d867cab580a2ad4c986258f144e942011fd330a5f2ddfa71ccdc7cc88c2df509a156982c71d0a377687f7e8e0592d28dccc21dada625dea3ee1f49d947ac8924b9927fc8ea12558b020695727fca05eb3a74cc509672285e718de849325a7d4d392ae929af0439248513535d57932e1a71c4ff89c35740e0f263cf7499b263269adb984f763ee36d1e953ca58c2dfd80c7fdf1e5fa412fe86ac1e49ce9a630f4a38496ab2cf5c26e1ada698aa6221ea2b92f067b3860f5f8984ebc9936d65b5ed0f020947cee6db72103d6df2083f847f2c094f911e71847329dc86d481a7a46984532187240b33c2bff0d03767c851c72ec20b29592ffb304554116e064dcfaf19bacf4f841f7bf0a0437920c217b90b73c1e3104e6a5bd6beb74a1343787fa163f3cb66e1e342f8d32621dd29ff84f0c2079d6254f6993708af3abe93f1141fa515841b358636cf5aaa3981f0ca3c27bff1f3ce00c233ff20d774567cf40fce775027a942747cfac1f50fa66346abd14efbe0fde5caefb1458b1c3ef871920d8f7b0f5eb7e414ba23f5e0556bd01a3bf3e066a4d57469ed2d9c787043dc6f23fcc776c13bf81f77297898e2b6038d29d9071d07621dfc4f39cec17d460acdd1c1f19caa3e883707377c10739a433e084f0e7eaa34ed992da5b7581c9c34ab9eb482e58b191c9ccf9c2db25f8c31526f707cb2ed322d37b83982abfbaa4fcc698333f39f4288f6d92d1b3cbf98c2aaf755e6881220630d6efb848fc963560d4e48993e30b7ec3fcd64a4c19b481552485ff5c6340c178421030d4ef504dfd8b0ac40c619fced38168fdfcdbd449366011966f0524e89acd441a357b803168601a30c4ea4cc1f59c425bd5eac066490212f937073e943c618bcb4b8decc95a1ff3b2eb6bef0a28b2d3220430c95e6b0fea3142eb68c8c30f8e21ea4b4a9089721cc850c3010c3fb2455fd525f30a656c6e688be1788e497e6735e0b97404617dc0e1b724c4939d892b8e057e7cae361477af1e82df8ad193faf355ae1046468c1ffb19c3286adc6908f0c0332b2e08cb77a78cd1d7e230b032fb20232b0e08590c1be821ba92e68f274d1257fc8b08293c26a32976da4bb8e2fbcd8c2aca08b14aca00ba4808c2a781f89a7d45e953cbe80046450c1df4e9273e8925ce00432a650351620430a2d230ace5cd0147a26c3c5568d1a99749001053fe23f3e5189b858be31c87882d31756db2d212d4b8e2623c87042d540818c26f89299cf238fc2cc4dc6c542c074f1850714d72083094e6dee4de7d31a1daf8c25f821cdfc440c2a5143274309e590638979a2e3586720230947e6f6c163acb83a073290e06dfe9c25a40d1f117304c773f81023a6c4b88a11a86ed5f4f4be087ea8b6cf1fcfa9559808debb89440ec9330427cf769c329a840bb1230427b84b47f3b17e529d20b895dded953d40f03d677498f0d19c477ee04555e9fc99c423f73ef05faa8349ead1d7647be0bd664fd61ee450226878e0a4c8a5327b074e86f71073c4e69a4a077e900d39c8a164fb2293037f656cc35598780f0ebcaa8c0d9afd22e3065e4a15edfd4b82e71c45860d1c8d1e5f4ff239f8e8520b377264c4bcb1ce63b2d0c2b9f6d68aba6916cec9c7b45923a1a52bb2f07290104453864f6d2516de7c8e3b280d8fa25705168efdff6726af8e1e79857f96a5239f9493d4872bbc1e4d4dfb186a3d6e8567993e9ccfd979b4125678eddee5a1a9526125abf003adcc9a93d554481255f8697d36e498c35a8224155ebbc75a1d9ed9c1ffa8f04c730c7b4df6e6fe9fc25b93e41d95b973646f0a7f2cdbecc77394c20fb12395f0b1a884b449e19ca71ca588ee8d3b7b14defd871134ea3ffc220a3f720eed22c77328fc10ed339c87b1fb9941711c99c7c19f70433e881e8ba6d58678c28df6618794365c6ad209d7cc2549ce0ed207ff72c28b5531df99d4a3fcbb09d74396ca13a2ab09a7ec2a64dd0489566d26fca0fe3ce68f35cb6a30e1d9bb745f889472b0f5126e1e0d9fa36bb58417251ecbc420e991a795f0dfaade3e085f29524a09a723db7d32fa78949293f0dca26886895312fe69ae0c1e1d44a66846c215d90ed70e2b64c925249c1829ddbb33a5922e1fe1a51c87312186565c948e70a23e78e9c923252936c271cd718a5ad4a41c898cf07d653a74e416633b5c843749b3e414b25d21a1225c4b216ca203a99839897025367ddc610e39db7388f02a5d468a9eaab4ce1dc2ebb40e54428721bc1c237d20e139469314c29b4a3f214751199226841fd65fab669f2c293908af2e0495a0412a624e10defdcf0709afd61e7781702b4d88b163f848313a40782672f75761d2a4cc1fbcdf902b85c5f62d8b1f5c8ddc954f34d607ff438a629b35ab6ccef8e0c6584915d6d91efc389e1cba87b3ec74991e9c98825d5a87fec9c195073f84e8108b1dc777b6f0e0e794356f26bf15c6ba83ebf669726059b3a65776702d6cc2255955072ff769c7b9a347e242073fd688ec40dad7d3630e5eceee961e678b62b71cbc4a1a25a925264b8c83f3f663f963ea8bebe0e04cdf5f86fb4fd5aa4911e30d6e05cfa8e571109f330911c30d8ebce6ded0b8b4c19f2ca99307f5fd5f151bbe10ce53071d522cb9585d839ba14722db5c4c88a106bf7c443ab6b7480d49831fe608319a79ec65f5e130c44083a795455624bf60887106e72fa9484bcc47b61dc30cde799aa7e89872989ac528831f2d7325cdfeb125916290c10f324d6fad3706bf277ffa24993e77c7108317a1e53c36c86676334618bcf940ae03cd124cd3c4781c31bee066180b2ea576c966e20557d5524564bef34f7e17dccc79429c489ca70c73b1759683185cf0da5375852017184c83185bf02ace3f36cdac11fed1829bb53abedab6919c3fb64819c4c8821fa2e2be3d858ea7432c3897f264df1837358f71b1750557d42c64a4325bcbf62186159c1c6677dfacf6f5e657c1dbd8398e3368baf78de162cb84e1c50b900831a8e0df98faddfb7de0999c8217db248449a99e66f2c59182638b300c181d460c29f8fd3972d49c3c59c48882575953d7696da9fd5070d26a44e592cfeb63f182055b1ce58a184fe8b25648bbe49ce0d5f747e9552fd61a89d104275eed82cfa4907e7ba18156c46082779b43878f30cff0314bf0a254f5775039281b318612fc3084075feef9c24d6c8f102309fe4fba0ade59eab23b48f0d6fe55a5031569d31cc17f995eef0c8911344611300611fca822fb3f6a6d086eb7c79184c41cb9c4b5841842e8da73bfa46304c18f4655e5644323463e06100c125307296ac80fbcdc71322dedf8e08e37a6c5b85c7a40e6efcec14cf43cf02a25252ace63077edcdf9922bad681a329f2479be53843c639f0b3e6385eadf78eeb4371e057faa0b6de73032f8b86908378897677c6b0814925e7ca746731520ba746e2dd2c2b5af8173dad66e224327766e1d4473ff389b62c6e93bc19258e85f7e95aaeb18485571da444b779b5c89157b831d53be6945f336c5ce1a470999c337bc8f05be1c7d6d829bade53dacf0a37a510555931ab36c7b10ab7831c72982c5bc9660f55f83163f9b6844db726a7c29c474af2c72e7563a2c2f73c1fd541d3fc3f7b0a377dac1e3d336b8a536ed55c653e61624729fc6c39bf5d7497983325851762dea8f48e2c878f1c459646f2460ea273bc280c8b312387394a6ff443e1791023e4b01550381b3165a3867cc2c9f1519e34d2e4709527fc888f91d6f368ca612736fb73959c533bc6092fee4f5bc262ea33da8411368410c4e4628b0c03d08413d22f7d1061fd539e4c381f7afa1c652dd9670c261295d26097bf84f3398a9d27ceea52d2125ed234c135bbd587a152096f43fa8fde424ca97228e1e7d618553e3aae8f3209e73aad87906f3b7f1c92f0b27d881ac3a5657723e18739bd234374dc390909673407a17a62e411841b4d6e12e308d77ebd3e8a4eef5d69849f2ba78df0b072dc3d23fc8bd5dae571ec5c2ec24f7f4babab15f1796ccca525c2d97c215b9e17d91c8a08ef3f6b4c1faf5fe6104e84b7dca14c5b6df20de16be5cc8a9d42782a1d45d4ea3808e1f6dc6f068d109db3c7208e209e839298d22505e15fae79fbab74200a89946eeb3e8e2640387193ed347bf41fbc8f43e71cc9a3fd4084f475b91493c7edf5c1b5e47f29a7cd714735f3e178fb38b6700fae87afee20c5d5839f83d89a87b3bb8418427454f93e78f0ef53761c5479e41e7707bf2c2c7c799437c729b583339a3bb68cf920eaa30e7c8c8a31e530c71da3832ff6ff9dbeedd5b49c83511573dc217b8614b61c3c2fadd70a9e38781f793c34724f761e0e84a87cc125f75418dfe0cabd44ccb176f5c92c089552f02ca4bacc32a131c22878193af41c778c1de51c14fc8ce91d85f4b149774ff0c3d08aec0e7382975324f6f6868ba135c1174d299364d487d162821b7294a3e4b496e049fba87c903257564af05245c8d2ecefb72a097e10527aba8b69ec4307129cba0f59f5417290d271042faf5fba8c7418c10d1da607ddf3299d53043745998c670fa34d0e11bc645d15dc21b81e955d730826590bc1cd1965b662d9cc1b0427be83ba9f9b6513089eac445947da4af0fcc0f95c1f7da776b3cf077e84a76fca6678cbf4c077b94f159172ff8407de5f8e63794739c00efca8e3ad4992538c8e72001d385ed6215d8b79b8ca0172e0845039ccd9c73f29e40038f03dca41c2a6567b0939c00dbc288fa255d286f2200938800d7cd91c2b74476ae1d846b9ca10ecc3e769e19dd684c7f9cd3d3c66e14713424c394e9bdab42c9c9e0876962b7786742c9cc91bf75148f9c9372c9c35efe0ad738ae9ef573817c3c71b7c57f8693ac5a887a487dd0a279d44e720e5ce97352bbcdb8ad6395ac50a5985f31f4a6d6c8d4aad0a37668aa7cc4a332ea7c2f76023a36999dfcaa87063b6edaccf1fc7fa148ea57bc8a19885aa4de18d67a57043fbdcb3fca3284941858cc20df691d78c2b0ab7deb447c35068bf390812ab8282abb168159a7ec2f598bbaa247b2a0f4f381a835cf8d8eaf46527bc28293ec55776f992137ee8f7d6482321addc849b3caadf9837849b50135e8478554e294cf62f139e4d5d761c478bd51b269ca834d9a1b2be8413a2dd87d1375eea6a4bf8513a97927b9f94a7ae84eb2396ae634a53c20f52ca42e6ca2c1bf524fcd414434e1d95fa7b24e1a5d4603967ef38b427126e0e326f4bf44f8b1e4838993654f6795f34cf233cc93efed31ec5fa8e23bc10b52e6a348494368df02bb52a4c76480b1b46b8151a953ea3c2ad6611aef4864647b5390c1945f82942fecd914984137a2a6787c84abe20c273b7b69aced4f09743f861b0581fc28518b518c20fe672fc9bb3570a2185f0ad627658dfa7f21342f8311a72c60aa61d4c06e10762ad599f20fcee50bff271a1251208afde526c594b5c0f083f8e393a8f473a4dfd07a7cc3ca60a17c362ef07afdc36c264fae065c8c79afae083a7c9c6638cedc1f114317f242322293d38f741d24abfec6a1d79f0623c6aba089ac3e8c08397af4e43dbb22ce60ebec4beede0fb658ec3b5c73373d781d90ea483db95b263344799369e831f74bc695210e5e0c6d439fabcc6c1dfa4b943f1150eae654e92f9dc342a7d839721d9f12de5414abac10d1d87d9632b5cfb6c83671a39c741d2d431996cf0ac5243541fd7e07465956c1ec658caa9c10fdb614e558fe9bc4b83ff7190c3b8d5d67cd0e087f07392dd3378bdedd1a5ac0e0f33381bdd7bc3bc6570bd83f5b05346062f25e6495932ba778cc17b4bb9376214afaec4e09d057b0f6518bcecc8476390180ccefdbf77c871bee0877e29671b8f17bc145273f061da2c962ef85a23bd31fabbf35cf06354262651f1efb7e0a5ec142cc3460b4e6bc654a9e262684d16885e1d7c482958f0b5dd6247989bf82857d8ae6445836a0527749810217c7b1456c14bde6973850a61b64205e754623a4cade1a932055742beec41ecaceb102938a15fbd3af351705cbeec3f780ebee3a1e07b0e3b753a9fe05cd01056511b6639c10f2ebae5ac9247e99be06594778f3f8c0e1a2678b933640a1faf5b64095e84d09b11568267f769f1ef9104a73e7f1c7ae88104e7fa7344f5f4b1cfe3084e0e3a42bc4c99dd6d044722653bb06c566a17c10f513307496622f82769a93ea423cdd921f892751fe628c71c9b2b0437e58e62f28c06c1f730735467962e4305821f27c96129da64f8c81ff822b612c2f47a10a50f1c33fbc91b246687600fbc4c3158a69b8f5b451ef87d1a6fb9fb8314b20327d9c7a1e7f9dbf6381db831776ba596f9162f075eb4ec100f217b640c07aeab4fe6685bb63206b8819b5fca26967d5c6f001b781df97a35c7e553d7c20bda21244d7972eecaf058c93ccc5acdc2f98aa134e7cd70175938123d3bfe2894e68b36165e7ce8133d473e2cdcb056a1736d7988cf2b9c303194cb755ce16a85bef4c85208dfb4c28ff6917fda9e70b16185d71f555cfe2c4a8e55f8d7b1c74345b0e05154e1ab767c3908396ab44a2a9c9e994b97b7a35454b8f5a9c25a8edc29494ee1e49bdc418839c8111253f8ef963c8e42be147e8c9ddd36ea34073d298a985635cb1fa370bd3ecc3c7fc4ce1ea2f073ecb952ce23147ed0724b33d11dc530289c1ccea3f9c935a7f127fc1017347bc7ed61c69e703e481eb6aadc0937b9698e6cd2478d2c27fc568f327290183ede4de09303a9f50fd584dbe9cd639294cc5ccd8493e67148ee9a63d78909ff35c2574a6dbd6dea25bc99bb54b163094f428eeea38e2cf66325fc28b6e3d764172585126ebabece7c7196fd49f8c1d29b6f4f648c92f0d652847f0f6be922e1479914113465c57490f043aca6f031e5e0ed23dcbca5da97426f089a23bc28a61d474937b3aa11fe878c9d3c3a9ec830c2f30e3e9c644c49c3a48b7025b2cfa25fc44c114ee694e1eb2b89f02d3a8ec73c06117e0c3955d33c840e630ee14a6ad792397b558d219c7416ca3fe410b92b85702b7518c27f74ccac10c20da95f4f7910aea5cc9c42737f50124178919e6adff1658e914038e3b1fa67f324361140f871d47879349dfff3073f6c9c5ffe2d898e1fdc10cd41a3c61c65f4fbe0c72c6ad71d84d2f0f9e0e5a9081297ce93f57bf07269d80e2b7f90cf430fde86ca520dc9fb3f79f093bf44a494c6833f371e9d64b21bb3efe0aaa7e710edae1df51f695e8f3267b90e6eb7664df1618e89321dfcbba43ed391de4a9e83172cfbfc6a2c073fd2ae58173193e5c4c10be396fe29c2fa0f073fb4ed896e1e43a76f7025888a7bfe4e9aad1b9c546fed39d536f86e1ee788930d6e6cb986e6c91b9daec18f3247fd1e199d326af0a312ef8e47ab7325d3e0fbe5b0535a5b0f3e687025ddc392cd61a9e50c8e4d6a0e22df9ce4308367f159b56337ff0ecbe0498cc86f6bca9a0c9eca4756f48cc14d93261e3a2ec570598ebd30b8b93e0a9ed181c18f88ff5af7dc51e60b7e468de778096abf17fcb0a93f66c4f4a1ed821bf37b5cfa7555d2b8e07768161beb3129b305af42a37cc428b5e0474c512aeec982df9192da771c2cf861e63c76472186d4b9829fa3beebb11cbaf35638086fabe0a73877f31012fba6829f72ec9b704ec189704b69a191829f3b9889cb11053f7b700b4bf93ca40b147cad309adda33cc1cfc93d4c158ba810e204a7530869823716b3b2e4ac262d61825b2949aae6ef9827bf045f353a7b234b18f195e066f449bb764bc93992e07de68f526c4ac99303097eb2aeb5f18ad27e1fc17f9ff6a8e41d7dd846f0c27806499ddbaec345703bd88e93c6f441083311dc9a8ab89b5893cf1d82f3eed2df9999735e85e05884c672d70e490d829fb286c98a09047f237bfa851ca4cff2077e58e40c8b613eaef481272947c991e981abed9653a2689685077ed0d1367fb13f0eb2033f567c681b3d126975e0ffe63953150b90032f6cfec366bfb2fc1500077e249d9d255d3e89ae0037f023bf5c3612726d8a15c0067ed8d7f93cad3286ad165e6cb41c2a365af8519a986d9259a7c92c9cbc621d694bcef943167e858995e314652bb1f0d45f2be7e8520561e1b84792263d5fe5fa157ef0dfd3ada66d63b9c2d9f48186fe68ec2aadf0d62b47b0b14829cb0ab7630f2b7d24e12adc8c728b2947a80abfdea227582c9b8e3015be5fd545e5303a8e0851e104fb0efaaa62adc7398537f641ba2bc7b1bcc7145e6dc4d4ea94c2ed305ad424e37711527895434f72f5d1dd3c0a3f4fca986286cdde8ac271f30b17257d6a86c2eb3a3593cd80c29fa9d7f8cc7cc20fedb183af142a2d9ef05288b38b3df127e984177f412c956685ac70c2ebb1f338a6ca26fc186e42c2868c29af09dffeb2df8924136e6a8851e22398f0256d5427e98ea27309cf434b59f5bf25fcf451c75399551ec757c2491f6d78743c259c143cca3a940dd932092f3c580a9e9364f99084ff31855812b6634a1f91f082a58b1e3cb49608094fb3624e533fc289fefb0f153bc24d1edb46f8514cc5a7d258b95e4638eea369c5738e83f02ec29f0ed3be43c7b1ab5584efa16a089dd22a443411ae660e55d4a453f78a0827c4b4f92b26a3c27a083fea682bb93cb5c7aa21dc786bf5ac4d9e2f2d8497aa766df3b9ce4d42f8a9b9d36b3a085f543d8a09f2d6a320bc694ddd51bb2731108eb8e4b8de83b4660908c77fe5d4a492471effe074a8e17fd38c4f871f9c4a135bfbc32746fbe0044f95cc32ed933c3e387ee1de7bed324bf6e078b40ea2a64eafad1efc73efeee8687bcd3cb81edfe6af110f7e0cefce76d91d0ca9af52f6783b90e6b73ab81e5ad6e0db35b92a3ab81d8748afcc1d2e85c8c12b8b2995dd2671703d54ef8f573a38781fcaebfa63c8aa746f703a7a0e2ef391f345e70657d2628769a80f2ca60dce46878e1e877414346c7072868f6369bf64cb1a7ceb0f79de72f5fd6a703d7be4a04572be701a5ccb7739c75f4183bf2134a4671a0b5e398313a33d9121a6ceaa98c18fead0d724a40c8e89a7c5ecfe4af927836f39ce399aabf1a8ff3178926e2ec4f42858ff6270c2fc6d75dcbacc1f066f2a849ef09863c607839f525ef320390cf71c5ff04337d5140f29217d78c18f3653b8ea4bd1bfa30b6e48b19c2485b372990bce59f684a40f72d0f1161ca91cbedfbde318b35af08367faccc741d566b3e046bb1cabc574d074b1e0d55b78c755dd26ed153c099b434d9f90c9572b3861fba543e47ca779f1b0a3b4c20d99a952adfb2353cb0a672efdba8ac52cac5556c5baff63ac3437d31db3a10a2ff664ffcf9b6e1e7ede48859f2de95108d73aef3750e1c5ca1aa9627b8698be53f827d33d99f2fba5e698c28bbba41eb2f3c4985429fca0f597a23b59be5092c299bed8162dd9a370a3e40fda91dce5ba4c149c654578b95876677cc7a1ba22caebe650b829ddff7564c7b61cb2010abf446c638aea486df9849b428ed581470a911896c28627fc8f5bcd42a8eb550b373ae19c78960e82b1c50a0e521d48c20627fc2862c71d346724e0c5c6265c0f1bce43e227c7686bd4d8a270b0a109b7f307edd8983f7a8f63055e8071180e6c511b99f083905c6d5372112d4c50e92932965d1313193652f89770babb2445788dd259870146172940b584bfb221b572b08401461717d8a8847fd9f5b17b4e295157b4997d887a7a109d7b42cbbbfc4938eefeb9225473f6201e614312cef976678e241d093e4e2675f9e28684973aec3a5d5269afec1187f1b87338c29678abb0b70ef70a79aff1289bd036c2550be92b98472184ba1b8cf0e37c1693a6cfb1087f725853eb137b091b8af0673d7c18d357527f4d02612311fe9a7af9c7f9d307416344d84084af6934c2a52c1b61e310ce8c4c276d172f4def8621908fb78314a23c0b001b6c14c2db681e2ce6d01d734cae0e3608e17b1c678cae0c51a9a941f821a4b76c99b3e5941e82f0831c66cc71777ebd06a292abcdaaacaeac7c5e51228df87ff600e1af44358b31440c6697fdc10feeda2b751cf7e4982fb65081f9628b177451aa0a3b60c30f4e4ecb24b12f52c7aa45b0d1072f870813d9fbaa2ae40d3e2053a7eeb61aa6d26de961f4506334dfaefed88d3d781163aaec9f8fb1adc2c596bd0bc0c0aa056ce8c1ff402cb43a0cbfc8835f21e4683347cfc596a5800b30b6b00ae374c10518c9800d3cf871b9a475de1cc3a4f9c25841171f3841170fa851a3460dde2d54e08215d0c61dbe08030c177cb1c51602d8b083a7f59623dfd47182159814a4e0e08264d5c129b79c3938952437aa0ba81eb0410727786be6f76b71f54e7080018651c1165812d8988313527ef3205c7a6ffa2a0c1674f1052939f076112f2257259135356f96b3db448c1e0bbce00d6cc4c12fd390d992c1a3a6145b75a0cd7bf1451860e80aba48c11746058a81116c711b70f0f387db0c39763ce98336dee07faab75f8c1eb9e106ada32eee4ecb23d4253eaf8a791c39ecb68f8160a30dbe7a6c99f6d1c63cd9dba20b161c5b18166cb1050646b0458d0d36f89f39a5c89363b61e8b8b2d2ec070410a4e5a60630d6ea6314f79324586ac1729b80d3538d61dfc88bc5e5ce02eb091062dadd3ba34c35633cdb6e66290b953b58f49738213787101167881811a354ee0450af2be0883051b68702c9ac6a0622f7e1ee4622b055d187206ef425b7cf6278fe09a2f5a00066e6c98c1f7d850219fd4d25c9e8bad93822e0c29832713730af3fa4bea09e38b1680915c8471a80055f05da4003130822d686c90c1dba4314721746757c7e08ac66cfa7d58a11d31f8315b8e223950cb09831f7f0ea2b6e251ee3060f06cc6265708ff3959bee05784201ff786f178c10f7334ef318dfb8574c149e96f51e9a639940b6ece9ec1453ad58c640b4eca665b16ee344cb4e08b5d6a0a92d2a5f6f70e26fbdd7b2c389d992ed9edea9d2b38b235bfa1d6a3d86105e72a778ef139b09c1d557033648d930ace9b7cb470e9297819fee73cdb43b1b414fc9118b2759028b8b6a93f8378471681821f89c6a658988fb59fe07ab86fada8589ced044f52da48f1f19a857013fcd0c346abc87124394cf02d36422563489163096e481fc12347555a2bc10bd1c166869cd2c649f03227b3489535d521c1f5207fdcae1259b53d82e3a5213ab5467053e5e8e314db577711b4cb9ed006113c3b931ca6979cd9d3b3310427a70c95b4729c3aa4674308ceca7fe4f164f74fc9b3110437f465cae1a291f3793680e06d0e391ef994424ef36cfcc08b6079e22323692acf860ffce875de4198e46dc1b3d1833f7bdc23d1e581131e9f63348c45b703e762b4f7adeaa0a203bf62088dd530078e7814e9adbe0d1c789fea714ef213a6be8d1b782aee5d975ed299b7610327b79a4711e9e31baf165e8a0923293b8ed26b87167e471b169ebd269c7666e1857d1c449ab2f02a3c76670a1b2967b1f0259a8ca51c62d607165e0e136b3ec7ce9257f817f239ca945aa9e50a27e714d3e5dd61c76985b72efd59c3c692301d56b85146e3fa833a4f59859bb54d3ac5b8146355f84126c5d87452e15f7d6b06f3a0c20f16730aafc7dd6352f630a9620a5f632bd67df4518a29851bf31e2ba490c2b3f0968c12320abf26b4c207d1ef3f88289c4d3d69fa0c853715bd4dd3dfc620289cb6912c62295f0a924f7829115390a858a9239e707ab3739035b30c914eb81aae1e568c8e909f134e5a86ec3064aba0fe26fc38720fb1f3cd4bea356125bf9cda1f4726fc54291fa61ef1f83c30e1a6ed914b96dcc2765cc2e94b1f65d7b425dc0e72b678f88e1ea42be1db7d18d971e71c7253c2d39c695b622b33d793f07360725922857f9925e149c664f69fce718c23e1c61434e7ce3239430c09275e24856675966b1f4184fbf3924d1de17d14c226767dd49a36c215f54f6da119c62319e1a8c744d5ca1e4de722fc8f467324e36d174e45f841d2491eef12e16f4c1aa53ffa87194484f7e92d857d203165f0107e040b734136fca268083723e51842f028c28485f0936407a9912384ff39b3cd86078f633708df0397bbedc958a320bc8f2aaad53eacc50a849783b07eb36eeb6105083f9c995fd6fcc1fba01a2ac37399871f9ca416aa434da60f7e289363f48997d0c8f0c10932397d58397bf0a37a771817a207ffe8c129cb9d3a79270f9ec6589f6c62f0bae0c1afdcd9730cffe023e60e5e7b7cb183539a3b2454eae0873972f4317d70c1a583ef992a31690ae123998363f9a3935c297db372f03de54aee7d1c9c742ba6ea3d1c9c90439979a455abbcc153f5a0b28accb4ef063774fac852eed82dc7d106ef5d3eb00ff9f38d071bbc8f4e6a9dd3327af41afc8ee73ebe540d4eda8a9d95638f2ac569702673e821cd46839f912c26979cc149e7a3d616dac3bc197cb3dff064d3e797c1495531f75493c1b3b33149511d8393c94672faa468a38ac1491be722a1d3a34bc3e0c9e4e06d29f64a8e04832bee41ff57a4aa07bfe0f95a88d029e8052f7b9691986ace65ec829f6ae1e319f34873b8e0e7cd9888892db2b92d78b93fb5848a18fd3a2d78136361426c89e7c8826f79f278967df96b58f0d275fc5a26623969577022222bf67c58e295150ec248feee5855c1894924a6145eb93a54f083c9db1e3705254f8e9143450a5e6a5289e935240a6e482ef2713c1628b8c96da225a67f7c79821fc6c58ccb92db3e27b8e1710ed5e2728cd56982bf39ce379b63cd39c304bf54ec249c4bc8d6c743865109558ccffa7c26094e8e2a4729a305099e851ca61c5cf9d7468ee0bb472166e690b152c4085e08398e6899c2f5e58be0a73c29c7131e4470f37d184663de48d13104b743c81d875e087e5c21c79572e430dd41f0e3102ec7dbea1db440702d8450267f3167f3074eea891dc5ec286dd83ef07e26bc6358c90c750fd61c2a5a2c0d0ffcb2b90e3a8ea6fb8377e0e6aaeb491e1df8a6ea1f07570edc8eab3ca590c581f315be56ed0dfc1c269329f769481060033f3e0a59f2abb570724c4134a6ce725269e1c76130d114d159f8df79629ab01256230b3ff020f7e6138bbac4c20d19636bbab78f21b0f027d8b5759a0c96bdc2f1d86453b694ef2a5de15a8a11e71f6c851fa6ac3c6b6485133bf038b29854307115dee638248f1682670855e19bc731a46473ee38970abf5a3e920f2544a643856b1e473139fa3cfad829fcaebc21a5c542d29829bc4a2e5b29973f47560a6fc42f420ab7ad4b7286ef706a915178122b872963f7077922a2f0abb327c4431f0adfc3467b8efe79c20714be450a0bb93d5e8d9e4fb89a3656e4303a5a763ce1dc8da758673ef1309df0443458b0bc2177a4e1842fd9999673d4ea39b309b77275889af346b2144df8914afa8e3a997574c9846fffd92c5b65e5ab60c27331b32c0f3999e6124e4ae7ccad29470cb18413738c1243ae849761fad206cfd9b194f0d64cb352ead6ecc824bcf4edb61d7e49f869528cc9b28f849f72ba9c3e9258110f48b81d2654943693db8e47f89e82aa457438c20d29738e432c6af67423fc38fa2883947b349a66846b729eb2868ae93e7a11ae67d9e09f61430ab5229cea286bca5227c28b219484b31c45af20c2b394fca14b88d6371fc22d93ec3996cdaa8a21bc0ff5d01f47918b6c219c1c4426757c84f06bdc73902a1d8493d7c3741b9ded422a08ffdd53e64eed953b32108e66ef9421de2ad70908cf23654df0f30f5bfec1d7709f29b2e32d1ffde0888ba528967a7cbe3e78a9352b92d1dfb6e3831ba135dd6a5f9c670fde64694bada93175f4e098650ec5c62f36260f4e5cdd5a0ea3078f030f5ea61c6bee204436b63b7875de1f840caff0cc0e5eb40a390ec283c831ab83df1263989842072f4a4a39889123c65b3f072f7d98e39e88c90aebe5e04627390e6e4e6917f5beeecc818393c7db3f9387cfe50d4e270b6e91376ef0ede5235aa749744d1bbccb1c25a2648397c390cf18d5e39e5983e3817f320feb715d8a1a1c1b19f1acb1b672d2e0fa892509963b98074183932ae7e6317557cc193ce94e131e7d33a02165703c89aac5e8f155f964706ce63c8cc1f2e6c818dc48313c3226710d8bc10bf9d80e3eabc5360cbe44c8299face4283bc0e085c9e123491e31a45ff03fec0e2486da94587bc195902991a84f92d3053f4afa63c2528ec25cf02a7d18973d795bdd2d38e9fd2b47f7214b460b5e856745084133250bfea754b9b3ad58f0b4cfa34a41bd8297572b86902243f2482bf8d27188ce548b746615bc8e9db3974905ef3a96d95c15ea564ec1cfa27541baa30b0335d6e04fce29a79c3e31c73fd5508313323b7a98bd37c7d2a7c14b52eba1e71c26b9bfa0c17bcb29575a98902c6c6a9cc10fd45c2c977c7e50c30c4eb5a492d58eb5366519dc4c1a1d7358ab99f385b9e200c7e00bae4106ef3dc8df352b1d440f1a83ff95917cb3e5387fe41083ffb16dff88ca61f0cb6d523078b162eedb58096a577dc1691993bce0c714d27f7c1c540cf9d305b727d347b221d6e0829f43b68fffac3b47c6d4d80256eda66a9fb121993a72ca9152430b4e287f0f5972eef5ecb2e07dc584a5a5160029d4c082d71e76567d566feae4158c2dd917b493a68615fc1cc40edb516d35aae0dda58739f8daa648550d2a781d9322f685cad86b4dc133f1b39f4b661f41ab21854a225cbdc4b3db3f45c761f25ca79428f81efc6f76924f179f5f64208c2e9e6a40c189317956091ead553abb45d1a0c613bc0c691f9a48ac66ab38c195892cff0c25175b2970810ab01650a3095eead452dede71b155bc50c1162fe8a2aca67d00b7c81a4cc0446d6525cd3d6ea4da530ea15e61420ebd1a4bc0c3ab3a66a4bd1a4af0a3e418d523bf6b24c1ff782e33410d2478c95cca23357bb8ce41358ee07cd011933a0acdea670d23b839cdb6f2dc45bf0b1d1f6a14c1cdad31720ec254938670c0053588e044f5285ba7ef188217a3d4f26d9ba7206b0d21789b377e7387641070950bad2f0f0f912daf48d95463f0fce7670d20b8f943baa5af508d1f78317d1c8597dc686c54c3075eb28a3c217610f56bf4c08b1dd39e03ffe0f3b13578e0d6467d798efe0ebc4ff2d7b93e7fecb8d6812f2556fea1c8f9a6a9460efc157b8f21fca4f848db410d1c78221f85b49023dd6adca069cb3ad5f07899f56ad8c0e9f4183643566ae157a7e4db964fe7a9a685174d93254b9b5938d1cc276f92ee78a3280b37326bc5dbe5dbbdf3a20b1ab1f0b5bd43f4f54fb1013460e17c14ab932f890abcf8420229f0e29c8374e0cd0a345ee10a67a4a245394b5be1c874960929fa8b4a8815a0c10a3707d6410aef1e1e73ce2afca02124e4281d55f82d39e88b1239346f4c2a9c50cb7d11613c5f5950e17cb04a1a73189e39f23885e313293964ba47e9834de19da4cb5c67bf1e79b0145e5aaa0b69aa228597f2f45cc8d1cf7ab246e1895864b5dbf049461285e7bd1d9235191de51e0323d8a20b1aa120bcbb2ea6e6ccba5c3a68a59453d88e06289c641d2264dfe827f6ac4ef35a8f9334f3ce41e5f65852746c3ce1b4af64acfc49245cccd3e8841f29a7f021f6458f5f2a3438e15ae80ed3d6e6686cc2f18f5972e4f46868c2bb0966131fb287d9c74cb895d583a68eee474303c384118307c48006263009198d93b4cf6040e312cec73fd541ce1c96a024625cc2e34443e6b633ca448e9b5425dc4822f9bd2e4c0947aa7e23c3497e406312ae6a76da761b25e175745e1725e6bca69a48f8a1e55053884820e1a58491508f5a2585f8115e24f7ff984c39d2d83ac2f7d0d73c8e36a68fc735c2cf41960d29d46784f7b92ba5c71d5c4461e6716791f1e63dc9c358af082f04092a398eee72611a89f043aa7b54f76977c88108673de6f83dc474eeef1cc2d99088507eb51ed6c410ce673b0fcb3b3afdef42e4b6a22a59ef6521de5539a8ca1e2ca5c8488f107e1c7b5699746d15680cc2f3bb10fe628809c297ae18a5a7c3e88f628158a542522542d6ace63ebe903420fc384b984e9321c337f8072f49769c2b578c4f1de407277fce2629c4e8e9238f3e34652d27ef51976a5e26d197eda5154172f0c1fb38233eaeb2ecc1b1b4f133db512fa0a107d73bb67e992a4d1eb677061a7970ad2622bbe51c68a08107278878184248be71e3d1b883375152d49e790fddb71dbc8be930b2265407ff553ec8418e2a74f0a34d26edb183e409cfc192ad16abd6146f49096b8d918a395a0ece07a13f556d44230e7ed2ec5959b4c39472c0c1ab8fb6159115491de40b2f24805b031a6ff0b2e5ec9d3199774cef063f98921c42da1c297ae6f8c2ab0d7e1ccb79ccae90d35684061bdc482a41c634668af28a69acc1cf1e39b45384d5e05ca808b229d633a6541af2940fb9cbe9a3c1cd39a38f7a449be990c6191c09e571ec2853766c9bc15b7ff140727f06b9b60c7e871c7a90c10fb2cdf585bf1c61b531705fa2219231657116eb115b44424aa798187c390ffad42a0b4356b1769e325612369f11338520f6c126248a60f03587f8ccb3e182b8c00b10f080c617dc54b38f1eede8b56337a0e1053ff9df588748a769ac9d018d2ef8bd1e7c5bce2c122b840b4eff871ea22593c61614abaea9913497d4d8b6df88f513a9a6a105377518bdcef3a65c9366c18f5268cf97333b738ea48105bf2d6a7aceafb973ecb98213ca254be890ade0a5a70eb36c39c8c6a80a6e5db8e49155f0cec1a854f0e353796c6c7aceb1e262eb042bd805d098829fcddd33cdc4b8d88ac1910253321540430aaed445394b9675952e5170c58309e91edd52b98602776b5b25325257e3a7bd91557c825f79c343a8faa8734e2f136838c1ed28933be6b553f9c409349ae06a872d1afdeb3bf630c19199edde90f925f8e9f279f4b14b3494e067ea4ce96147a6393322a09104ff25bb47c1e3be889e41829b7b735839a87d84466dd553bc624decbb3607afacb9e6e3a36104b7d3ed338fa56814c1cff1f44732398a06117c8fe9e3991ccf07991c34a03104ec3e4aa6ee89da808610bc770d5e1ec60cb1262708defc4848fe7cf141f00061ab1b95956c2dab8de84afe33c973c77624971f387296d2c5687e631e4cc3075e0ee222a5b1e84d6147a00b347ae04a38891e476a8e83845790041a3cf0d64224a4740bc933b883c2d42a3ac6cb5536694c7a69e860cbccb8cb2e29bbcce8aa8c14c22b648ec3252eb668e4c0f9d06f1d7ab686988368e0c0b9f671f1ec48534e1b1a3770fdfbc4a3d9102eff84860d1ceb9cd13e6ebeac4f2eb6bc08630b3050701816a05560462dbc943752c59c6bb2f7dc8119b4702d3349aa68698d1a555f80b13366e1a5cdd41dbc86b270227c74f5314962e1a47c9329c33278871558d4a215dbd52255ee362f390e8f36f2fb0a3fb4d0719a438e2bbcfa9446f36d8c291fd30a6f4a63ca9d31acf05346d8a8b461269255f89dee293586c7fc5155781333bf59678af4b1920a673aecd248539f6c54385d696424b8f97d4d4ee106af0991a9d9716a4ce19987ac3158cab210520a3fc8ca07673e299cdad05bb79d517877122dbb32224f8828dc1c07eb21797684c2f758631e73ea008553214a92b3530f72e8f8849f2f8f6f867464966a4ff8416ffed0622abadf9d70343dc6b2c709bfc62b4fb466e4ab78139ea598796e6e4d38e79fae836c33416b68ef50fe03137e0a2657de1ea690f5125e4a0f35f96b7dea534bb8e13dc8c16f07aa15530967d5633bda9794f03ab68fcba1949370726945cf1463dab428093f8c65f9bd031ff1c922e105f7b0963fbe20e1fd47e4d4563fc2e98e93da54d48e2b48331ce17534b39e7e723ca311be79d49683f530a964b88cf03b70e9e8e55e04d9a723781ca33314e18b847ccb895ae78c6724c2c951da76d0b1bb72cc20c2894f95b3d2d9f57bee105e0eeff5ca1355529a0ce107b7f12ab318f3854e219cba0b3174744f88b32c4dcb3be32ea55bac374d06f3c8caa4c283f03b44f1118bc8917546108e66fed01dc2a7e5c01208af62d68890feb2ab2a80f0eb62b68f273a3089fcc1f5c966b13d9ef8c1c9e01fa3f45dfab0923e38a5d1b3797ff0c18fd44335cdc27bfa7f0fde8f45cb79fcdbbf7d3df851a4bf27f67fc5c89107ef3d0e9d2b4bee8c4be3c1eb309447d25cdfc1ad30f93e779ebef1d90e07d9265b07e7435d75103ff2331ddc181ea6e093d2d46673703cba972441e33f2296831fc4b4f153afc9cddc3878722fe629f7a4dc3170f06efb93f4ff779027fa066f2d438ee4a7e330f36ef0ff7d6dc2e5c891c56df063dfc810739633d8e047464ab9af424ed98233d6e0686c984b31c786f7c0196a288b787cb2b5310dbe475f479d91ef230dd1e084b449a288f765ca9fc1cf72c93c58c80c8e7daa9ca9528644580667d663c911aadc543a32f89d345888cb6163f0358568c65c89c1f14054b335fb6c0e5918bcaeebacbee4e69a0383ebae5e31878acb53d517fc943c0a1d741879c1cdd453c9c3aa762fcb8c2e78ee1b62b5fa9f7a79580833b8e0c7305ff9349b2db82eb2c12635a5091e99a10537cc7868a5edde285f169ca9c98e3e87cb2fdb61e1b2aa78cd4e891a29ab37b96e91f20aae45becc71b48c153c559f8f3fa70b39e5ac0a4db47c4aa5c7cac7bbf95f7d67474a05cfd3d7490efb7328dd14bc34bbd9f00831a637430a9e7b581dbb07761f75a4e1408d1a4e9811052755858d51161dcf57a0e047592343d966b7cf3cc1bfd41922d3d638cc70829783ce1f623af72c95ecc0173498d104472c46df768f8a89640613fc38b630591fc7db12aa194bd02b2eb6eab2264e666653c7a8b4fe511382194af0725dfada0cd28c24f4b35951ca2f8404cf2ab8a85a08d6a8b10500dc30e308acc86c744ad6c59667a894657694a24db2314930c308cea44a9875190bb57946115ca9243ed9fb23bfed10c14f512de5b29bc71e3d660cc1b35c29b7577d9c334709c1cda1c3346bbad4586d10bc105d913768464bf00082ef71f420da27e9f3b366fca0ecb2aff77439f5d841d4af48ca9fc2337ce0c7fa383b6bf7356a7c61460ffc9aa88f1d59c87970171566f0c01b9f0fe5993eca5d31e2c18c1d3839fd85e4b4195386ac03bf2ea4106be55353c766e4c00f36513296c77bcc51b89881033f4d4ae49f1ce5067e2c19daba932c821936f02c4c6c6b8e8a149d530ba7430ef28dc84f0bacbcd2eba3a3dc453c347314a29d2db3f0e3e389d948933b458981116cc1820d5938dd414cb5a33f547446868d58381d33425c7f59f48e030bd7facffb7e62c45ce52b7cbbf2f90f993762785ce1755de8988ad8a874e903e3e10182c161c16824128642c1cd7e23006315080010541a0c45721c0792381c7e1480015d1e1428281c1010120e101210080a120a060806060008060606000006080685414276608e65301f113ffb4f02b53e38081a6d1e2e448eefe4e0fb5cc5a118bde5a418ef40a7a3ff30dfdc617d9b34ffd7f073d12f7e1bb37969b31c27467445e227f755a721f8aaf4ed82f77e9665f5bdba1d93731f72fa089045db88560ebb5199a4d834c95ed3e0c3d8e404d1a98cdaa2134f16942e68ba9fba41b2ba300222fd6a06b1c1ca6a896b6ccfdc63360f18c3951a5ac915597f4aedadcef6e00fc63a94a3a3b4606bbf1e2970253b672a21a18e88f40dbbad6a3435a3816bde8308bdcfcb169b680e54db13f5408b1acb24ca84317ee7365b9dbc93794b5579120d7a4ae5240048fbc521b26c423e8706e73d5f85f5ac1c5afa60d3a589fa8152aa14171dd0cfd013d14c91443aa1ce2f0943e1a836035a3a983c7980437517be3861a1f8f79b8c1b1f927fafd06f66e40a472275af5edc8473ad22bf37e0afda5492f7681368876d3003b81786e5f64530fec6c8e0351b39ae5ce166f2c92c2e4f8d4fd982f223b601fc623f544a3904486588ffa2f4609c33ecec7c0752a2af78c9e50cae72365db4ffd4d9d5f034c4951e28cf8a206bc3158b8034ff1d147bd080f7bb7c5215e1bf86aa9ef40ebca6dc46c27dcf35d31a2dfed9e13d1ce94590fa7dea84d510c01c78a5e7e03ea7262b79991f097b16d45de0bc047f6bf565f0d5bd5466c0150d689bd21e2d4b011cf4ce4d925ee8b33a8c9d29b4da52c74554706903e0f8fc281d6b396f1f8c7a4b0b1c7cfe80e15baf1acb1670945e9f36ab648e2ae2c6d954997c2cc80ddee4ee6cb41a4e12ede533a4097a029fa4a4ec773ec05976c55a48b8f09349043b5b4a28a671479ba5b3069e22dc94788a66345e7fb8cad240ac505a4a328a82ff007dccce8d4ab68283ef9412e3b125435a8180fa0a4a56afb162ed4be7443bd5c403962e29574c00cb41c01e849dbb75a9b68cf96f89d63dd92d6eed27aaeca953f48c9963ea2c04db3bbe3d7f183d25a25d32a480d55f84827834a980560455393d3e25adda443cc509046da84f6a044407c91208f7a3f80a52b9c0cca6f2890cdd31822bc35c105bcbce2f53bf4d765625b1393ed2d44b9268cd2bc06ea4e09b5bcd5bac084fed0034fb21abf6115ab06e62168ddbf0feb95e4f7a4ce9cde2074d78a9d21c6d57f7b5cafbd44dfc3f328e2e5b5ee76589391d0fd824bbd2c3b7d43c9e8a2ad048888d77a5745e48aa7f2d7e3a12101ba7a136ec898891e432fcdabccf66ea0f52ae4d4dcc70754345454b8a8052b684ffff4a5f26add98134ee9460064916abf75c718583de2c9ceb02e2b4e15afca12711fe70cba5fb1bc39e9e95e39764a8cbcc907b0dc5c5486c44c9ca42be1102f402ba5b95234f000fe40158a79905ffbc14f40d2525f74f40a85166555322f1f70d2f4c06fb2b339a1b2af326ab74f181a4ebcce5d6e6b32fb9051a7e9cc2341be933e18cdf05087ece950e94975163b55431635214680eb1e45e63900ed1901c956df73349cc845b2a216ab50ef40049e2a0fc6b9bb803e146d5aedb7e4fdc789983c9ed8817ce44849c0ca78be6c68b159b3b8a97609dc37edcd8158226241d48b004d8f039933a65a25fa0236cb4cd74d06c94966ecad561f4a198f8487c8518669a09c76cc6ab824819b89d942325ca44e8dd2f9795174188ccc62a4d2ea26b5656cf15d7b2eae7a0bca35a67ae7e83d26ef945f036f900b1030d8f107ec1700caa943234993983d18a22a49650d76d20897aecbc70e29c154e2578275b2af301cd9257af42bda9126b6a1b51d3cc92457abbf8a38e9985799d8b2d951ba41710f283d174e059d883163a0ba2b624bc6ed34d99ce504e31b2c173a342ffb6f102b49e09585ad229b0cb2bed38bff2f439d37a65995dbae0abbc1048961f62ee362f04b4d213c22eb7ac8b7342784be7ad77a30a41233bf7b46ecb290f83833f9bc307696ea4777580c982a941c4f715fc34589d90f834a4adbccef9fe469290344b86a7dbbea28281f0561a5fbca2408e420ea552337eac8227057a935e8a52d892e0334c9ce596c635652108f790a16cbd412e96f3a9631fa5b76cdcd1d096178a1bca5a55a454cef8f0f51949590312af52fd24695dab7da521e9811855046b01d728180095e577b1c659665fd3208243b8f42903c07959e8901640a990bb89bc9cf2b1b4b0a014182183ea944e1013da0aa376dedf002b4136c0533c1ba5ef98054da57ff75b7a8ba7f0905690241fbebabec72460bbe53b34434e4158a7a4c3bf7172ab95a54de9030704f411f2e3560e193d60d7a90b8a68fe143a8300f0acaa5600cb64c89291f98d8fee99156c19c26cb4a4c86c005c5b4c74286f9e05416ed8adc9b0443dabcd45031a54a44c719b5c5a3f1d93b47208fd96a81c9eeec29d02c5bfb7d31cc52c95b380ce2b6ba652f96cdbd52d64d609064a090f33b5bf85ac07c2019eaee010202013b6c352bb2ada2e5dbe4661697ff80a0678af24fda14cada154ad109d768a34502f1ba57b035dd4df1e3662e40725b987da53ee41685d6fde29cc4b342adc9b43efd6690cfa5860dedef1a4361a948e62504cde6d35ba2d5a49d758aa21ec1439e477e9424faf023dda2409af5aec88c2b99ef188836c7cc52ba3de648ab5b38515a91687abe5cbc924935d37f1407150cd2345a7b90f4f2e6af4e259950ee6a07676a7f2301b1c4df9ebf65ec7e7ad5133889599596d0595e355e213ea6e7bf67101aceae57912a7985c82d11e8475c5e4aac4c3f01d09cb25441a6adb32a478309590a6e8a47d3a1c16a3c61608f78e70e7b7dc2dc45af4983f1c94cccf2669dd08f98f5563319a15505053770e6f11298d706013bcf3c60e3c727feaf918fe988819a1a215ecaf25eecb1cfe29232477c21f97a611945678d33728766099f9a14ab62dd78cc888b346b0709f917598638607ca9305263612d850c308be4401402ec908f0454546af35427ec40a97580069739498b124c803d968a10f1b8a7afa46ab84ddeb2511df72a696ca1b55be0bd0ecd58ec06909711c7b5a46a28d5547ee7cf1daaffc286401a45201e09ad4cec8b8c0513b6d0f097de3e6358420431f80bba358630827fa5459c551b535731f80e59c2cde40c25e39b763f82009b4f293383d5ea81074fda72bbc32106e688a10450914041825764d7fe7f58f2e0081c24e56152e6e8e475250be06c6d984c32752011dbcc593b5fdffbfeeaf99c5022f40395dbe3bec2e11dc014c3c3a2311c13d063a2f0fbad1447b00f87c80490824da5260aa5c85ca450b745158e263cab2ce3196d4056012db99b102a3100c6a3f99e76a64bac0e628ae133b3aa59006bd2d43959391a90cdacc87ac62a02ee4288121dc11159330b63de8a333fc1d77968bb7faa4b0166a25258b4e4310767b7a0ae651928a396b91d6d7048fc6fc437a0ef7237ccd4d4e66b00dd59f29ab01b4c9373985b515a7d989d8d5c8afad9b9b72a3054e9f8e195ca45e01c234ecb5d4994779a860d15374497bdee5f84618095df991e2744ae8a492ae497b846f48d88e4b58ac7ab46dd8912832d97873e79925ef0151a2d5a415c4b0de7a664f6a342d0ee6b501e22044b6513ca105ee3ca45117bee4e33cb01d461e78ed9c4204f99127636cd27ad2995adfe6206925d63354a8ce1679490e0f7895f46a9384f28f8c4a9cea12b48b675492948cd1c96aa7a9bfd9cb71adf730b7d83b4d41c28781d44e55213cfca21db544ed4b01a96fa24c8bc80f16b34abd5dd1b6899832e75082d3261a560aef9aee4651f5a150498e30e4fa30acb318fe21e917892ff3621c4646ad88b2cfa491a410c4a19df7c6091657125e3f49297b7a29809c2f7812f1e64a04c27dc801b6248c043de9bd5094749de19cd6007d97af0837aa29414e5148890be1f44c0550d3c8259770c19462f8b426bc3daa66ec46d72955555e0daf4245bc289eb0c5213e4353d5014c141575761f954003e3d0381c8e60a9a3fbe47607feab92f4dc8c66a6edad89ef52645c7d3f5570a112f49ec6a26e92761f6242c5ff7634567ca4fc4754e64e5dc591501639fd3c03633e8a2c63ede1316ff31e4988257ef77ffbcdf7a1690f58f47c9c42d73bbde0e289a73074cea6149252022552b3fdb1f9229034ea5747a56744e6707b8d03ec9245596b9a45173a2e48c1e24a0e1c0a6c41201584a458099c7f64a85d894fd7c98d51e352810e725f2a163144a8d3750888740a5e9439186063ba8a88209cd34aa2f4e11e91e0eb79f4ddba3e334eb5128b6cc825536940f9114ab0de49509212767c01867d7b918bd325894adfa7fab8669db630a03f7f3ea91182dc083cee7c83b1e644a082ebb1ad0b8ce949f2a433e7986f08c20120b1651fdc53667b0d20fb9a07bd532eae5700d443a401ba89f34502ed9f5477b62a52c0c666ae6daa0a4c659fdca3d28aa184d1994b09d9ed5661c919d488dd708f5cb11803e6132da66803d121633adb0b90039cf3170e0b37e65862bfca93611503c61074734b1535dabe239326746a2902cd32a92a0ad1aa9dab303e5c74bb4b2713989cee1cdaca26c402c1c868eaa0249d7ad4af0d6795e3d3680d09b79dfae20410ca217cda3c1760ff686ac454c08548961c5996541617154f0b87333c72a254de1e097bb386516a314600e041c444a7699478e5b34b5385e3f226ae00461af8b234efbf4b22d1e89710095321397a22a98179e92936eb336ba64d1bd35f7f30d84d07f344595035b30978e9b6c9311cd1f7723ed5346591f1188be49540c62932a08be7228441999a9d7a9075efd56ce0034a8c000928ca8416f91dec4a7433f24562e75db5632be999334f2a6726b557845a773768d8c9b8495dcdd4e474c6913676198968f139478a3f7e4da5a1821e8d25c52de7dfb4358ab744c8e44ed8a2e70a3a749341c53b230937dfde8cade31f4db385b80239c1e65f29b74681c5d8f5e876f113aac87ddaeaf0da31c1ef83695c3253864d4d8329a37741aba91c3e8a664a83f0b7eaf34b87b879b1757469a62410d51059f44711276347a1c5a3c7c7678d2f3a75368ba8c0174a1f834c1dce04c7c4fb5455f438e008cc656046e1ce7ff5c44b86bb6ac6fb3438021ecfa34b8e70ae7718788987121100e52f5b6300cba7ae0f7e0aa7d9326479bd643658ffd181b0c1f01042f5029cdc15d051113fd001a253c10c78b3f10357907dc7407ce136c8ce71052a0370a826f2a24443da59a7a38c2807410f999029f05be30586edd3b7c76dcdb8cf23e5c88df94e1ef26c93f972c6cc04283f90b5cc8f3afe258b0f4f9c19d1791ae707eaf9df318fdbf526fa68cdb9756d9f0ff85c2b923ef549a5ec073d4ad22f2904404ec439f7fb5898e27ac347a2b0b1a1500eb7f6f5635118d18852ac24ebeb50868c9efa0ae0cc5d007a401778f2e11cc6877d98036bf02fec3dfaeb801338993300e53cdb670634730fc83c9e28b1e80f620745123475ea5a4252ff5d807aa8542fb0c6f03bdb04e8525d45e9e91a3ec93c55016a322d8a7f02e8aad2b2be3d708ddd5d779dd63b89385111d5d8367e74d0f44be72d9280c1cc985debc2eced4503d3f7878fcc9b1bd1904df9d9f7eea4bd11db68b4f84df69ec13e23c66896b206517b34ebb6a6faeb6aba287327fb50c167388ca8f4cbb17044f47e952efcd10cb1e9d56c017fc51dc959d88c5bd7fdaf374f10fc9dfa2b812aa11ff6a9280e32e91b4a558c522727a8faee1a7ed56d7f00d2debcbbd3d9f15524c4491ce740c818957da3f17700e6f4d2deb0a37628284503368c8ad4b4a753eae0a4d637eb130700519400d800ea3c0c686825aef012d8b8fd9c8ed0b896918621602d239a05e24b81cbf602b9d0fd0b50000d3c38c7af7b035c6b9d8b56f782f5957386eb766d713d478c5f23e3e2507444eb57a78817369d02eed898104002d7ab2bf811f05f0bf1ada8770030925b691310db3640f63a41718a91e4b5d5a811222daf022e668e0cf15b5f4c1f40f4a14d36c3c7a7cc897444652ea15844500d1bda8c6fdb8c9946f094d1a96906f6970711a21cd58598c5d391bbfa0da0d26207503a85844ef6c57bf8683cc2400b9cb0df71e41fcd2ee2263fe17adaa5ef808f106af4cbb2a01c25b09da9e166c64c1749a1a04edecb6ee4285d50607d1a546040e8f2671d9a63500dc6a8577bdae4e8dbb37371dd292589c2163477b47401eacbb169348e6f2f1d141bc0ca8d7d2aa6246e56a4949c6e45f2ea7a064eb745193fd209a9c2fa0f38a01437e719a862ad0dcf6e347ad359e0685f6c6f138a069fd5dcc685f5d50031d0f9607636e61910b61e9e17ddc846dcc89508ad55a9045e1b13b70a17097c4022216d2102e80c3c17b6772cdd19298762b73ebbade239b2146a8db532eaf6d378ff39acc89550a640a46bf1fc8d04f7105280a6858c3e9100aa50b2f32b205fda164ed2faa9613b8b34b6ac1f1fb26e684c67f17ab955bc686244bd6d2e4124e669db06470e9c2f1a9804ce35a3eb54d1b3137bad0f8cb6d1140f8c235c56955be911004ca25d810472a90df4b6d1d0cc026440b77f83d2da8f0a17e009b6286dfb5d3f32e22bbce92081572c018b5839740794c965b8586434577dd6b4ddb3b36c6a77ef30745dbad89608b3ffd70f06d442ec0da09164087dba36f038c2820d3e6088079a6821e09bbea05c14801a2e787160dd9db28b0e2414990c6affd7ad95ee64fda22f1e1c8d6134e2054b4a7956ac8d46f5bf2813e45ecba3690cc10991684333e92900dd4fc9aa2980a385e63174ff12f998cdb4b39dd3cd4a9aa56d61e93c5113eb3473ec4d9a4c3b55d865d770c1dc69a5b6a8810e91c955d32f3208a86098500cbeb1628c9a93aa33a9b4eb22af1f7e33e77822d73b0fc3059bf9ba5f0f0726fdc4f4b639dd30a748eb8ea9e93e55cc35969d6d4b6c70345c5d16588c8233799272522d2725a20f106f60950a3eac8fc60dacbbf0e0e270a38f44f1820697be78ff8630b20a7386fb94a5ea3c5d11a0cdb9b79a743bf6f7f7de689ce18a6eabc4cfdbc4062011cb263a198ad9f06dc8364a2997469db87f15c8814167893b3c7b649e7c27ec59825a18a57a6c71852b23968563e12e22de09ac620a5db2036cb0f2706a4b579c523cf402a5b41fba1bb72953e281c457604453293ea7001e1b9147763d2a8ec587c2563f7ffb65c8f217c7395b56d648a779bbd6170c0e9b99337bbecd9ac8a82ec1b880eb4b33a5ee01484550b3a2456a02715a5b77c2c3207c6c158a69c578a549a82c495e5aabd192f10566b7a9c85941d39c1c580a6883081eb744b320304d88213f5fe64b0012f0e665dd7d62d9be9c345334a2fa71305ce4e2964071a768b7506f17b670a94ece1ecdf2e17691168d6c3ac277e2347525738196b25356f602a42400e3682b33f497062515a4bf4fed6db51d3933d5f4643451866922918cb67fef684d5022948a3515f854ae1d8e0530e84e7f274041d60005b25faa0f7b9e6137c68ac301c8dd56771048f7a4ab331d60a333053a139c4e21eb48a94dbd80872461441c324a515d0e0fa6c52e5d70e7d7e1ff1bbf41ab3d5b778e0e8c355e323b6fcec0eef53063b366676e23a35971d3510999cd83d27721f01e6ad1bb7b26d37ab5f8826089200e8fbb587294f18deb220b75a1b437dc747e26912ec11934b95e1551ff8b22e060eac8c09ae15d0b4b6be9afc75dda0deaae5e190305338f758410ce49ad9b9b75787b61a42e5dc2cb6a147a351df04e35d38c992bf985dc1cb8e87808ad4e54012de7ba0d2a593f142807ca71dbd6c5706194d3be79c0c6c11e99a2190391dd1970c88e76ed7dba93a5913e8bee33e0b6b32af9ba6f62399a6649ab915e1d6381083dea087d142d8171496ca623808337a0e0ebde307554e19b96ec224d0e9fdbc74834bd0a4a5f8dd8d93582a7634660a9a11252200046da4066c5bd4298b9669ee185d029c790179a43fc08b2ee170beecb6d3f57b19ef4e9e14720867500f83ece013679e5bc5ed613b8cbbbc4d5c9664aa790984b227b2d8df330200f0cc0a16c167a0225d6e1c1bbf3623e19077a6fb8fd20941a0b9309196968477e8c9a12e6cdf7c8ab8498509b2e7baab63fa76c25c4a5cd06b5069e952157203c83654f51f5a2b2ad1a434ed5ba2842e875d78d06dc8f595d91cb28b81a0bdff4da939462c9e045f8e914be8d359d3eed869d42da1694bc64ca56acf6000486c8e844982ca2f8ef43139f6e93d76016772d40177d16d7c457651ae4ae45dd2cd16a30f8b8f2dbf30e942c9011d8a2ae5d2a2dcf237e24e84445b37dd8435f4eeca89af80e7f6c0386824180445586f6ec821d866ac93da463624e075f1772cec40b134eb44786f78a96fff28e09468c81594d4c71260676f3110589e879aa0731a888f3b14428a4d5422d63f4076c15a77c2862b420ab1fae43b6e5f0c2f831379bf3af7fe9748aac1842d262487139e3550d54e1801c63445ce6602a56b4998b828a0c49a5485a24d2fe624e86b88d66051cc1a01b960f1cbdbe3cfdb50290400132a07819de3ae92c500584fa09beff22efd3cc9f6d7db49e5516f0d70b15b4168441806c818284fa3b031d5c5251a70e21e28e4a6ab554bed883d617c2418cab0310a7e6aabe1ff60e9ef71c54cf7c51e99d4ebdd9b48744321d5d1bbaa2ed6e2f6de673a1d97bec65d8abc57b7a749727fb5fa28cdf46bc475dd2fcb79e907491f6b935b90eeae631bb3f9576722ca14b48b7be2ee3aeb1d7bed76e5e5ddd6fba1f5dde7441754de9fa55bacb8751de8913bab1ba82bb94d37b5e0c1d5cc7baf6d3ede5bc2a0b435a4e2bf2eeb0372daf015d36b5bbfc43963ac8d635dcade75d23bacbdf7895d9ab6e48dd1ababf5c776b650691c7e9c2d415ac4b52d74e177a5d64dd8abaca5d8d783dea8ab3dd42e87011d2eeddf4d6f476e9f5f0f2d405ed9aeaf5ddbde744cfe0f9583720d17dada1678d5974ebe93ed4fdd7fdd55d10bbaff990675408ede6f4727a7d7a817a35ebadfbeaafe2a66b9be1facc689bf8c930abca77684f8956c0b8e719c67893cbcf07acd96a53f5706355fe36225188880a23fa090a0983b42efd80622050158e645920a3a3e79efacc0535e24664cb277d86a2b1fef7660e7f141ad76eb950045eb3a80522ad1dc22b8ab5b73c6c58ac4cbf9b9b927bb5045957a867ff01ed2017181711feca5a8f8696be0879c9662ba0fd6f2b3215cbedb600ebce62638facd876494f9e84ed5107e8e6d857f580f4dda4797c5757f5cc8de220280f2e4dda454c90ad1cb649e5d9b0d7d09af97b2e89b99a867dbb64a904208b51fca950279fd0046d09cd38f5ee40d794bdca940b38025a5181532d6c071840baabd90215e000569667e851533f098d91226053424ecc8565812c46ba5997b570300abb2970f659d5a6d528fa2578736588e78d00ed9a2555573bf7ac19bae4736776cebb85ef1df6f67cccd87173c51671ffeb0b2a98163707103cb76c5f70a4a6f42e04897f5d591c2bfc5ede80097d1e43b30ee56f59ff5a4fcab15fdd6cd74f8927b0eea5398ef55fe7d3f44d6bd641fff3c20beecee4ec0903f129e187add46db60bbd1da525e3033eec967aabcf936b6c2e49fa8003dd1574f501219874cedb2632f573b05c430c4b21e2471ff5086a4e74c6934d3f9b8368e66a687fb288eca34891b8448e8e2cc1b5c8e438694800864e62d8bb3d1cdd1b9f2ee83b8a2798a4a75dae39b5d0fdb0f59b374aa7e72ff32137519b284623602b02a7755a09f82ee10b290d1be4ad3d814fa6db0ccc198eda902a1181439a20f48686f5f016d9334c4c375937569b7ffd5523c106436c2fd8c75bb943e57a0c54429001ab84a78230814c789c1732e94046e8c4c017a30399598114fa5581e2126808ea8e405601b80c6418e6bff97423c83457052f37c1effc7dacfedd74108147102fd5fa380bf3ed070668e82ba913204d78e6272d5ffab557d7347489406e20b7e00a411a0532ed422048bfc0af00a0b1a80be0815509bd41ba5ee0270aa55ec546810cbf0722e39a7fd5ffc005aea5af11c90288bc48f03209ebf526023c0f64b247505134a600e5d7a8e7194f18a3d485c363d1b58e491b807a3bfc3748fc143b25120b08c5999247fcef837a74fc149423b1c2485860e00632697ac8ab9eb3c1aa39f64b0b029001c102d902b6026481a4106432498381eb0f049169b06924441db2e7ec6b6ac12881c31a647cae7bb34108826c1f85c3707edc54d8f600ad48d08d505c0632f9a6f40035952023490215d22cd0eb60a01e373c18580c2ebb02610f4d0913f8410135124ab856bbd78c8f1a972a8155098d446776e00d44a7a92750511cb095f42fd205d9ab573352e50bd60dac46cdfbf659e1d2c7807d94fb0ef2360932c11d28838bc08f1235000187ab2ba806eaadba654f65ef868daa2029c195d1347b68a1c87aeaad0b028ab53b972f4074904207f003fc003fc00f20db0889adb5de499429c9f2a95e21e722534a29a59412c3d7751fce38df70a4d134079709030935092849abb65d984491a3fee424a6e2a73fd8564f1746d50dbd3b9fb4051d2acb8569cee2bca8a43f8ee75de8c00597d4c6926c49cadda2f0b4af6ab999afc3166693740853f7512dcc277ff20875afca26b409c0600436669420081f1011392cf01a20e03043072dba55adbba8662db216c654740a22f24255981db3308aee1953e2d9202965094420821a23344af0e8a4ea90c58c1a353c7410e2e181808e5898836753caf4336ad4400974c0c268723ed9548b5f613a59a7962b2a115718bba40e2f4abea9e9a81506b93f71fb16962459b3c268b296ebe8f419f1d32acc419930419892df249d9781d44e154e03e407346e38a02315954e6a54ad96f11e21353c6c9c19666a830e54e8f2d9a6b16919e3a5599f3f5e44ce969119a9e314a652f9920a6d4ba2b63264809c8083c314a610a679b2c80f35cbf9606b187494c220bedddc454cd0771529cc7ae55f41f4543d3474002272a330a6dc29b92d1fd5ea1685d94de9c99f243b140695a49473d4149d3a897fb0257a07288c2e6245895ad3232ffa602b9f30594a1f269dd88e12c4f484a99389df9315d64f8c3ed8d63a612eeba4dd7992d6a5241f6c8513a6b53bef52ea3927c71f6c3a3661ca3b2a558a73fdea8cd584c92efe255325ac8e124a5948d09109f3ff870902e19d0688475a0a3a30619244d733bdbea47b4c973069359ddb36276809e21f7458c224b99f08ed163b23229530a7493a8a50514c5aac3ed8da2861ba50a92f9ea75caaf5c1662be89884d154c7bc18714ad8820e49984e662f947685f3794522615272ca387d79623d27618384593fdd95595ee41e61d0caf124b784913dd20fb6e208636f9a6625a1a4dc973fd8ce4464d89801f27b35403c6c887434c29cbda2ab6ea92ff7920e4698edaea477d30f223b7e4de85884a9c4f1f867e1977c4c14613ad1392de82ceae78e44986cc484e9a65a07718208533a5954f81cb7435cf77176b9adab62a525cf8ea13f091ac27c27ae5fe5523a9e2d84693e9c924d90760721cc5616b4bd9f18b24feb1884c184ba98af5d259bccd621089312ba3a84b0a04018554b892245ff75923f40184b527be6268a8fdd3312aa20082724e4e81f0ab36929c7cd9c5bae5c8c396b3bfc6012dd52a85a1377f4c1e4256a46f498d09d8422aa821a78c4a0830f26f13e42cdc9792fe5eb83bb6f64c8888d8e3d98b34bc9b65e930439793d98af32cb3a85f3141ec22c74e421f5c935b4db1380c1086ac08083e30735424254d0810783ca89a73b18b6949ae06f723c39be7630db6a9f60a5e44fcb50471dd00c2b4bd72a97b36c2ce4f88f2a41caec4e07f3dde75d0e6929f44c47c4d1eb113ae6605e7d0df5bfe35e6b92834909ea5f64b8dd5f34fde360f44ee2cd3e880d07e3096af4fb83e90dc650928e39a69d6e2fd5e106d37d3c21f465bb0de64bef954ac5b4adc36c30fe8d09195f4b0d5f91d0b10663854b265a54e6684b01e149c0c10184ffe85083f9d6f32fc813e75d4f3ad2601a17bdcc4b9ec3554783712c8993cb44cb9a1b9dc1d42d26754bbcd196630683ca9757fff94cee313bca604a2f222da7920e3298540e65c9dc741a135f0d19cce81883297fe7fc8d0e3118467aa83269fd92d8274e4247180c3aad5ce5e9f99ca7c4c376091dde9c86cee9c4afbf600af1966eeef582f9c58210e7e9a4527717ae7ab313b7994dad98756fd17392439570c1a44dc53cb1e537efa28e2d984d7afb8fa6e374bdd81d5a30ed7d527ae6dd3fef25c4fd7cc8143ab280a990915dead21d583049a635cf4787c99620918e2b98326d2d3ea592d74e4ac60b38389a091d5630763895b3b37c324c4a47158c1754c5d7621d543029c9566684c7765653c714f28ef3ba9495d7935f171f1374523ba460cab1f4e7a81b2a5ce88882c953b0f6b8b5143aa060b279cf13f3781e9c196a19e8788271942499605234f931718269b404dd1e4c124ac95213cc3177fceeb3f466e799604e41899730af6309e6a09e942cda2525983a9cb8f87e9a76720a868e249884db074f7e695b4307124c723577e4ee925462551b388e619254924cad9cfc388c61b439658276ecb929f972068e6298b4f4092bb292fbe89318a6f333311fbd3bfe05710cc334b7a2ba392ac9deaa55814318a693175efc4d46048e60184c67c9057d9ae3b10103d31d3c484be62f4ce2e2d45ce9926f2ff4456ec9526d56854b8b7535f2b282f7961ca6ed854910f9568fa6b2534962c3c6c13b0e5e98cf3e872d41d8c6077b17297da5dd84fd521766f99225d989df0825cec59ae95ad1dbce62c75b5792df4f52427333345c98bce5c63ea5a758da988170057de6020e8e5b984ee85293db45877f12c400872d4c7262e1653f6ab8273fd86c80848c88c858ae85b18332d554911686cff6ea9372b8291316c72c4c26e7e027a87d979c9418b42cccd9a4a44b905ac99249e2e00003472c4c9296539694c8115a270fffdc12b4b980031606a54774897657c2c0f10a634813b30f0e5798cbedb35af34c5a61bbdaca96b6654b75cf3ccdeece25439f943870b0c23c6641fbd4662e5c3ee158857176f4a792649978b104324315264d0f4ad250f231482e70a4c2b4ed39c4ce84bac0810aa307cf3ed87c00e21882d2672f23b951c34b1a9ec224dc67c9ab25c94a6599c2ec1dbef2f7e875f1bc14c6b724e50b7d5143059b145bae2eabb4bb751d9e3da51c1e85d1475b4e59beb38e2a0a8385eb9653ff3842612e25fe277f89bb711d14a6ca72594cbcb44bd18280e313be8f4eda4c505d042e9880274c27b7569cf8160c383a61545d51d144ab50ed45e0820924270cfa4d7bd28fe979d2de84f16af446b343cb9e18248980b489c80019b9a109639d0927c73b7b763765c22cfb6796e34149e0c084a95285ef94175fc2f4a6cade74ee78be74b1c16109c3e79874262c8921c408a4122629dbaf99f820b231250c26464428256f1abf4dc2b4b26179b115d44d2a09d348936276e364ad9f6bc9038e48987a2c6c54ec29c9b40477c00109c359b0923fc1843c1765d4a891c8e07884415e520aa9e15102b6906f157038c224267928f996653fe97cb089fc071a39333c6680848c74c88848238c96529ef49dd6f296bc0c3818611e7195f7d361fa10bc8d20c0c0071c8b30474fea55d7ab83072545184b94a45b4f8e2311a68c7867a87aa8572f5372124ed7111019365ec08108639e24fa872d9d43986a4457f024491bc29c946423f3528927d7c85108e37bed5a901bba73bf1c84307a0c7593d5ef20cce339f24e0ce5f971148449a92027ad053d9167b22aa881c7e1088479d4847eccabd97ad00d191f62839b0310a6d8d9d3e7fc273d6a7d8c1c16e4c7c8b1914118b9e4f80356b1ec6a634cbd5bb37cac73107e69a2fe317258c0c1f13132c2c1a17e305f366972beae9bc5f203ac0a93f6492ac928413ebfa930bd68115969c162afa830d8a7480b699652509ec2a0e24f990a52f468690a83dcc53b154f5c44a530e5ae20eaba39290c361f74bcaaae52988cc21cd6a669aa4b4461f435dd925e234a6a4928cc967368adb1d4410a0a63c5d2f1e3efafcaf409835dda2755923c6192c4c4ce897fe9a64e182f48d1b024cf0983c79ccfeb1f59d9df84b9a468116abce25aaf09d3499fb9519e4c18f6b26e9c7c4225318409839e494ae91111a7722e61b293827a7ac5e7e558c2e4392a8ad2719ea25c09838a0aafcb2f254c6fb735df97c4f1741226f5f9fbbe939230a53f490811ad2261bedd5d4be13a90308993d352546d8ab6ce23cc335b7ada29b47a92234caf7b4932370b96fd469894f849a8934c18614e25c9b13bd48a5ece224c175774db3d5bd88b220c625e45ceec449872927e6f225dc562441877f4ca2cff9e68da4318845736c9f7358441e4986c117ee9e52c84494a55c1e5469f1426218c6d3909ba94386f826c10a67c26eaa912cca365451026d94356c6c711e656098439fb870061b6bffe2cffa46256fe80074f1955dd0fe6fa792b15b7b5d3ee83c92e8e0e9bd712223e984e3a0be1fe274c76f760d029087562c57ac57a305f8b1e1d6b1ecc2e7ad4f9a5783099ec15bff6bb8339c7495a449576305556f2ce72296bb93a183fc95972796c74481042c8f3cf5acfc1f84969a8d5fa3442d57230c9a8feea8dd697521ccc696d9f544576551c0e462f9d4bd408bdc130ef234225533d4ae406937dbc29b96b0f0fb5c17019fa3f8657149d840d2651c7732baf3598048f3e7b6aab4e76d4605092da2739c53b7785d3609273eace1f677f5e643498a4554ad94f9413d9f1198c9fcc44d39db1190ca7f38c302fd9affc32984ed465a98eb7e1276430783c75d24236bb4dc6603a7949145d256230e5d35af154faf76c87c1204b67f3e3c67ad082c15c2697d2299a4c4ba25f30765730c94b5e30ca999e57f4e4ffc92e18ed635fb7ecc5ff920b66bf4ae2762ab7600e7d1d4a27cfa99d168ca2738e995fa7f27559308a2ad9e7795b2c9884efe027bbed15cc2ba78458e8c5d69315cc41df8ba59baa6052ded9d3b253d03351c19caaa37988eea8ea4fc1d427e90bbd242779232918ece4caae2ec9841645c1dc37faf7f6de2a28818271ee5a4d499a6ae9f20483bafaebce75ae753bc19c3c44aa5eba09a6607f1f3d9f5bd033138c6a32c593bb4b30d78f4a09a61b694a2979b424985c2d0927f2c63d8a86048392d23e8eeef079bd631877cf4ae82842c6620ca3afa969db8a613e41cd7897f061b4a6c43088948f32ae0dc36c5eda73ca63e8662a0c734e1f2b6997eb9e4a83612a532a0973a6835e1230cc298791a7f3bf308d6c8c7a2f6194ecfb829d7dcffff47b613ae195f37249d0d6f3c218ab5aa12e8db9eabb30fdffeb29f9dd924e7461d86ded24654f2ecc23f37bdbcbc4380f2e4c2a9e3b4e7dd2fa975b18fc527c7f4ecac2a5d8c264e94185c9762d4c6a61f2c930a13e575a18d552f6f924ad5baeb33096bc54a7722a0b9370e287fd598a99672c8cff7ad2c68dde37818559c5da4d5d2e5f613893f2f44f922b18b968af1ea65698479aa5ed9c7e84fbac3097a68a7dc719b39c5518ce7e2df4e4ad68a20a93a47167b25352618e514f4a33541843c9d36bda97baa44f915222fc047db229cc39a6e9f025a514e6901e3474b2f029aea4305f92426d864661364918dd1f11da9e8ac2dca33b4ee8bc1439148651da4de78a7cba101486731925cf7d8a957cc22016432825c7d013a68bdbc104a5c24e184fce29e72f53c1c7424e98e3bd5cbabf8739a54d98d5e4fd88993ea9e49a30c82bdd75c29e09839fbd27956f553909268c71a5f774782e618a919febbea48f53b184397e99c99dfaab84f9bfe4fcaf4b09f39e64e296ba9c525027618e3f5acdd3f98f1825615215524f4c353bc945c298f2a9c4c95d694d3b481854904f9d5a2b9cccee1126d5f93d7ad6aaef758e30e82c3541da9b6c5e5d234cf9f49274ae7e57d531c2e426a7ff1599351b5a84b9b2945cea278a307c8ad7e9de245549893056aa4ef52375748a0883c9a57b74c58a501ec2a0a4943f076d6782aa18c29c93bd5ab6ba10a6de17b724ec57384b7ff1c38330d7985c2e72bfab654198f2a4104a4e6a5a9403613e91f1e649de2f95058429f8772595a42f53d23f982d4992a0e412f4c48ffac1bcf9bb21d45c929df6c124d42939db9412cc523e184f8af638a54a1247b907a3a9f423dea2be45d3f460ce4fb597d3cc83d96d47b6bec9fb56e2c16079754dafab787f7607934ecfad346d3da9991d0c3bea92f4252c8a685607835a4bb24952d492974407c3bb9fa0533acdc1242e49a1bfe29efe921ccc9adb41e9949224d57130557b9f54c2c16469fed2c28434417f83e164f9fc2eba1bcc7e552a4ec5d0d1416d30578d8e2174101b8c57733d622d073fd11a8c9f4b2853f293ba6851832997905d49fec84a953498b37db455caa2c19c4cea6798588207f70c86ef4a65a7543318e4fa49eb6b49977019cce9aa372cc5899592c1fcd94c6754f2b4dc8dc1a0c45f0c79366bb75589c1247f0c154d8979f5255961307dca5652f894625fcad7402f984281c1b836d23a97dcbf605dc6bbbd785ac8c5eaf86c51f289ac4982ffc1565e30499d8332fb924baeb5aa0be6926925593e8f6122545c48aaa7aff821ac2d187dc6e74eb9a985bdb2775da6c6abd7ebc5d3f569a9da56160c2346794ef9ce55410d3c6a5058306a48efe05a5fc154826acddeee18ff90154c67294ec6e560150cead57639c2945052904851c114dac376baf2d3693b3505c35eae79de393fd8a4600e1b65926c4af688b61f6c782021231905c3b5883a412e37c6836c302828982bcd9224c90a5a6e4e912718f54a3a4ff2f555e96bd47082b93dc6a68d58dca86e06d504c3253968cb6ef557ca144131c19cf27a4b92a4be874e9ba09690a4c52a2c2518c3ed7c734dbe888e6f25c1dce7a6e494d57bb70b09c66cebb174c24d10fa3e3b86495909fd1e5c94bc26c518265982bef0dd9e2d86717b33440cd3a9ecbadb6d7ec8304cc2e30459329e1fc46cc230ca49f15db9aea4124f1f6c3ed0609843094af283add3c88d326098e4fb13c424fffc5c930fb682444066e42f8ca162414bd6764b612e41872f4c62e1b405ab245b762fcc76268a67bf796198bdb45f8613afe3a81ecf56124901e2217d1684ec5bd73ed8fcef5806780793a4bc4a76bcdbb8bc201a37928709d00ee6b0aff77bb2223550d7c1b0196332342f1b403a982dcc7f4e594bbe2e3938076349fa4e89e19e1fb3837230d7971c95837e1de360f0a482d041ac2465c3c124a527a9f49c341584928d1a6f307792f44dc5995cd51c037483418f29a57298c90949aa65886d305b3ca9233f55de6ba0e7410d1fd0280107870818816c30aa992c39467e7efa6b0d66d39ef4a8c5a806b34793b55cb2c8fe5b300d064fdafddf4af2d1602a9db486e797eeec9c3318deabeae7e33efea56630088f23f65bff83924f1a60194cdadc73d6de3edd514206939ce3def3d7640ca69cf3c8d28ffd95223198fc3b89bde25fa353270c0659420a06a3b598b0a1bfc42f98dd84aa28fb9f7126e805c3c45ec3c552b06daf14b4546fb6dc74494bd205f3dcbbe9d91dd11d6711b151c3a3900b66ad68d5237fadde1d8d238305885b3076f05379f1839ed3e1c7a1164c999697fb3e6300b39055d66856cc5bbaac7026a79cdf4b59c482c9d34e094ab89c2b18be6409bae72dade2bf080216a040042e98809a26d00a7cb977785d6d886c85d1258daead94c42a2c77a544f9091da9603cf9ea94ec789eaf94e0140c4add892daae45c4b270d11d0484f402998c410b95ee27a2b58ea83cd460d8f432460140c3aacadb3cefbc14603a1602aebf58a71293f07133ec1d8714d977f3d22726494ed009d60fc142cdef67e12bd0f0ac22698ca2413cd32edb4ad432f036482410997bd8ff9f62f7a1f888c849c11912598367dafa42474b76cab1aa804a3f89f244c8c8b93ea43a3c68c1935108660124cea5795df7f1dd038211e6a238804e3a86579f224aaaeab814064bc40051c1cf908448688d9cb4812101a770c63a95c6277d06fd501a146e2c103746424e5658c243744560535f0a8c0196359ed12844a7e128262182fdd9e891a9d2742ec32561084238651de2c98ba4f0dc33c6362c9134bc7eca84e1826614de5557ad4b5985f304c96f2626aa2c5c1c1c131850386490e7d27c99b17edabe417c6fc53dbf9a2993b8dbb3ab116eff255d3f13b7e9e9ccdbb5e1876adde4b12345e183cfdbbdededc85712d49e275094a5d1894d29f4d10a57d827a2f1706d5d034b58f7f4a3e8b0b732c3ff1e27b720b83e7ac7897bee6399dd8c2942eeff5d80515cb502d38d178f9acbaa07a5bb93c7a4f0be3e7f50adb4fa5fe4274b859983edb28397d9770b230f889a6ae73f0b8658a85d1cf47ffc84fbb9d5f5898ce4407b7bbec15461bebca15a6f30da9a2f7d30ac42e2cca8ce5504b277a95b4b2fbb7362b0cb282ca13254fee746815d65636bb9b4ba3f19d756fe1ec842c13cfa20a838c097f429c1c97479c0ae3792a49e7d36e264e438559dcae4b924c7a8a4259123f5318ecb7cc47c7afc4b74b61ce65ee152f67cb49795214b5bb3aee2bd7a76dad658892b398d5a33075da553979432913af1385295dd8863eb19d47edd9830b85c153570afaea2bea754440e1ba5b8a5a49ad4f982fe9bf699fd21f4dda13065b3dbd2b4149272849d7097357b8a09fa4ead239bf5e384e18d46bc7b84ba10f3619c7ecdce881b94d98d2b7a5aa9cdb7388f35d5034613aadfde741492f13c6aaffa417ec04214a4988e1e038210f72983098a5d56c0f51f273b62f61f4b10f4afea44a091a42219c258c9f4227259c9c4feeb815e12a61f8b060a9c3dc892fdaad0a6ae06183a384a9848659c951547616651c25dc24cc2f4ac57512164a9c931cc249c26c52c5933f6ab288ae46b848942b5cca974ebcc141c2a04baf07a5fd5dcdef7b8441eb99de7aadf4f88f239284d59ff8a88db811e5fa12b9ee107b7b59cd3ce11a77a58212de3946982ddde52aed27d494d8224c9e54f80a72564ded451179892faac43bf3126152feaf972daf890afa21c2f425871357f62fa9b97708c355db7fceb69e214cdb77ba5784acfcd10049f60a61ec38d144b124e57ac9470873e6b789bf3519fbfe06612e3be526990ef5d3f69f208c26331fd5e402618e3ab25f8210f5b59d0e0e10a9a552b1512bfb0aed4e69f13c07d3ae87bc0e745043c62d10ee0f6ec8b9bff6d12b91c1f9c1fce147e4ca8c2cf1751f148bb714626e25df16d54a506a3c4e759658f1f8603c133de588aab894f3116e0fa63ad94ecb98d827057170e8800648c88888c78dd343fa29492d0b7342270f57b2bf92d5925f94c6e121edb157d24299279d34031b77874cc35a5ebbb3dae325b19e46bff4ea23221e36446670eee0ec603ab7ec7152086509ae0ee6ea4f82b613db5309277430aa7b8e65793ee751627330b7c94a9e2773474c2707f3f625f18adac5c1249ed2d5c1c1e849e9e93149c91b4c49861026ba17dd3de706838652fa96a349137f5d1bcef8545bb939ab4b66d244ad6851d7e4d860165929cec7d21a8c76764950693f4689abc1a4be453c76c54e17940663ef2549c9374283a99327c9c4efcae549ce603a25bdc74fd946891e3318e647c7d22e6530ec08919e7193c1d41a97b28dc1fc39aec991264a3ea518ccd7e361e6bc8292c63018cdb4fcdb6779972e81c1204dbb2f1844ebe44ef67bc1b027ac855c3bbfbb0b26a5d484e90b71c11cd482103b275b309d64668210134f44470b06b9962a3c56b260d0f9d35b5d8d05a3e737256cc65730fa5bba7072ba24955ac124447a6ead4fd258f2ab60ec92fa79a194b426f6543048b91735da340583b070c19485f2517a2918f6635ce7fb5130eaa8d86f224ab47728983ba885dc18f917fd09269d24bd52b932490e39c1e8490aed67254d304965951e6b4cae799860104ab4a52429f7a02f4b30a7a6aaf6f77c4a3089b85df83709a696d71a1d91f2be1e124c49990996963c865174cc536951725bd08d61b494214edbb675febc18c613f6c4b3b29c180635af1794cacfdaf961182f9a7af219cf345d18c633f5f3e8a76098ff656c642bc030a8feeb906f3a55aafcc214dae49c4bb6a074dabe30a8d0e14e16a1f2a8b917c68bd6a2836b658d14f1c2a4ca42dd785dca268a7661146149ed6249b2a514e9c26c99a7848b622ecce19df359958f38e1c2b4fde14d56ad3a93bb85592dd693203d4e3c6d618e596257b9a96ecd502d4cf5be7ae2b9cc2749b4302729c5ca836cd7d02c4ce13c78ee139dbd735998449ed83f268a85295b49f23142b030456dcf35695ea94a5e6110aad54a1631492eed0a63bf9eacdeba15464be993480baf92c40a838725f511b29d6f5e85b184d01f5a7c76b316d8ba80d905eeea22f0a103101a17280e5e0ea34001021084e402fe22228f6a84d858000046446eb8800001781d9c1b3aa0716420400022218f6e788d101b09880100020000000040000b00000000a080f71a342e20d2ef35683480012b0262e32c20008900808848c24100019c91e31c0508c019395e2384e300001800041210f21e0c0040001e708020d8e005828cf800c477812023323e448e87470252173666a05c24af3123152071615cf53c13363d086dd25b00e1cc4804485b1c206b812023211f22323c3c1290b430c5afe8a973bdb3307d2749127a61f2a7bd6561aa3e0b2ab7eccd95508d19337e06cff8199bb1c8aa64f9bb1cb38166fc8c9df1335013168906c88c54807c050d90198900e90a933039efe53fce2e5e6346fa1839337203d90a0419f11a336e7878242059617259339959b26398f083fbecc69987bf1040641c10f436448a8dd00041111a202332406e241e212dc8558cbcc88c9f61805485d798910890a94840383352011215083222e3c60c0f0f04e4294c996b623fc8c714e67eef20634adaf81db314064f5be2fdb32895a693a41885716c8ac2943a7b10f2f4e85bf364288c9e2dc8bbd7b7fe17144611622354e446e315e4274cd2579f9f245e8ff484493095bf53fc2a41cb101b40f84e9892bc8e4f52d65f7a13274cbda6b43de8b44f3a64426ec2e8a62b3c090fa6e2b7d4c4952aa558a92e7d651bcd36794866c258f964dc73ce0942942270c1041213e664b2c7eedb4a55335ec264f52727597c63d52a6909e3765ae94f59a98451fdc4932ecdfd9f7a29611c4fd13357ee244c954f98d60f3296ed9384e1d35c0a3e62dedeb48c44f2f5ae2297d6522be4b28dd07ba71adad9848439bfcfc4550ba33dc224687a16154a6bfae97070a4238c955f6ed1ac64bb20fe60f3b05163cf04d908f3a8df761125c60873caa8ee9ce453d7cf2fc2f4ab57823a71f74b5a146192f784caa23d904c8449ae54ce9ba1eb732d8c08539e7ac9a3a64b16cfa143983aa7e792f25677bc3b6908e30533adabb2562a540883ca1bdba5122184f94bdb9b0e2ad7c120cc7f5549befdb5fc1c09c270f2e93022fe48e3200361d6bea43b7a98db5c8e0e006170cb5b51a2a585ca655243860e3c465ea4d81f8c6392e82728a52ecc637e309ca04a92f298c925057d1fccf94f2a4916bdd926a7201f4c3a66265f540e22eb0f6a84e8600fe6dd3693c3789204bbfd834d0fa62ccb97041f59e447b4069907a3c55392924eec9c04b58c0fc183c984efb2587ba972971b7807b358e9854e2e27fd441a20891d4c1e4caf6ea7e8880f505a1d4c9220ed9467e9d7ce061d0c7736d25b3cb6ce723f0793a404d9498e92fb602b72304949dd79cebb566a486226838c8371b6f333c7a46839367e4424657088c68d942a483898f20815d3c193f20daaa8979c87a757fecfbd56da04991d0e0e37184bca33f7bf62b6e19465477f967daacc68241b4cd963625e0304366c9c909155410d3c6e906b3065c4c2dd67cc254ba5de56f24dd492d4e239483598d693f89877d134985d3cefa9ac9dd4c8190da60c75722c693c4b797f06c37a9c1394ecde0cc63329995c921cce949c530673573ce9697d2383612ffcd8889534f623442e30432167390663f52561f721db90111b2906d3e7effc24491eb530988338c94b54f23269a604832673c962ddad5adec5ed5a56944eda7112e4174c3254099e37cdf482c13bb848f5f4c92e98db243769bba28dff13a8a0061e2e482e98542c754bc7452fc73fd86cac6dc1a467ba3d94ec95fd93c8d91101c1d4827188c0059d055350c2633cde050ba6a454a509f369547f2eaf60b090a3f27cc765f52aad6036314ae6b3831ac82a982ca6c71331f53962ccc54052a1b94aa55ea72d6259ede5144ca17aefe24af61c264f2998af3ca5d352b28a783ca360ce3115fcb2bb75be100aa69caff760a97c82c9478967f1b2934e30951244454d5213d7441f6c2320890648c88708da07b209869393eeb3133da88f950e24138ceb2979c96df15c82179eabe7243d359e0f360fa3412ac1e8a59f6295ee83d13c904930894b7fba6e3a5b094a9e4622c1bc2545ff1e773fd8f818a61b517aa55f9d52461f6c42e8c17b84241e232033decc18e6fb64d9d1c35a9f30fee0699462a0426c8ab4301a0f6880bc203d80c43056ffc9e1243fdb123e1f6cc330d8a7cf262bba73e3000ac3a43fa4cbfb97efbafec1e6f13e001939323ea42e18d6ac59b433710fb54ad1732895a4e4e2df0829d6c030f8a8784e2a5b481715d1b8210210fcc2e47174cae7259ed2657c726478388d2f6f230830f819274404692f03847d61d269eb63ae27a47fb017869357c4ecaeafa8517961be8ba6d2a9b57117a6feb292e2093a8a757461182594b01667920bd3769f24fb4fb034b9425c187c2feba756d589ad6ec1c69bab5a0adfa51dd75ef25e50137eb0d53822201c1c323e3928e0e07819203666d4401c1c2c40c1a22d0ce22bf7c2dce42446570bc3d5c591abf849848ed1c29cfec4ec5de66fba6916e6184b4a897f0e29a69785399824a8fc21be047142b1306a7ce509164d4ed21f58184c5578b4e4c19368e32b4c9dd4ce6d4cec0a53692dc93636bcdeeeda56186dacc489134dada88f082b4c925ab14f4ae9e0a75d5c853989e96c71848926070668daa80a9368e6a2ae63d2dabfa9309992b257befc537e212acc16a746cfe675d78d33c0536061561d6fb39d366aa77da0298cfd5be779f6a4507e82a530b577f04b625ddf4ea79014e620c65198c3a5d47759944461300bf5ef24e93db92ca130697a0963a269e75853c9fdb48f50e169003ff103f44410b013e911a7656aefe43349c809c3b48285db8ba5ec953a4775f1e0260cdb167af5834c13c6ad784947e4a5f5e83013869d5382dcd88c983086502a7e5749f2323b9730ffecd58e7f32a5e7ab21a3aca025ccf296e3f2f9c70e0faa0496bf4af5c196dc10c112e880064872e3053b05a484d1eca4a9f211da4eca380993b0f8d1c46e64953c3ed0c899718792304d89956a374c3ed8426c00e13d641c1f7c62244c76af5fb515e4724148ce1ed1382322344a900609b369114ff3a21f7e1f3e42b170e9dd6d2e887a59c54fb2ffef9ca90374844168d7b21cd637c274c19364d7297950254698e452be2df33f96b4651186932d5b8a3028d3237af47789308baa8b735751829039228c95e4bcfc5582fcf2d0210cbab492fca8723f416c08a3aa0725cb4e8cebfd0a6174cfa1795a374218439ab60f2dd5208ecfda56595171d30ad71022ae65dcca4f4198468bd82dd11d1716d141c8f1b00b84c1646a494a673f893c68dc08f1a8e108085332d1d3abb5ac05ff60fc2d495e4ada154ae68a7e30e9132e9fe8174fa50941807d30f6de9d9ede356444d33c66dca071c807f3788f2511d332a2f4b80783b0b21cc6b41bf22325b002eac1246fa851f2a8fc1425f6c126e2a1c6031a373e46540598878951a8642c858342d27030168c44025130105236cb0100e312080020601c8ac502c2509ecab9aa071400037044263e3c242220180705428138200a06c3602028100604018140301004851e12b5466aec6dd202d642c7d1043a3303790457422b52b1483765c50ec603e390758149ef1a47ccd51a256ad7a2e30d23725ebd5c390a40dda5cabbb9717f88fa83d8b896bc0928eac4fa97dd102efab30dfb58fa3bded1b9d10e8546d76a118e1c7db2e8731f9f7d1d4d1ccaa4110e4e65f18d10bd829455e32ffae1b30f91a700bc1ca8a529d8343d6a8c7151890a723baa76852b405a0c5136421b3b0652fa88f6dfc192d60c7b43bffdebbab681df7f89f73aea123ce3b6576a6073f0fc6250e4f2cb84ccc00f8aced3ac643766987c360ba84482a1b0f5c1aa89f0bf35e10272e09a962168652212740c44ce96238fbd12658eda8941beef21a08cd2a481450f73a0818bc4417dd0255067cf95fa01007124cea80f88831e7652235a0a50afb1d7e731cf341e044ae71b71316280a05e5c349e3fa2d75c7f7a3f2d8db63885800b15fbad77d2f0671046049a64c10145aa098011d16299e65000abd35f9542496231ea457845d2a067cad9e46a030ccbbbb8ed374887fe5c083bd8fc8e6cc4ebccc5cb17862b9da243a72582a8118a599d8b36ba711a87d89898b4002a655995ca2be404f2a23bdf430e88093b2a0690be06977f38b56e30d0fab96c7ea6cc82c62cff16440f2171544c2d025c61f1925ad00fb72917faa9302493f43b14ee2a6f4e310a7bbcef9458daa0e7863a7c43752e0fe720907224f53870c716e0a3225ffb68efb1cd035717e80f26283493f19f6d3b39b8414abe59f047bc24ef9d6d088edc2de906c7843cdd04319a535bfd982e4459fd26ca2b9b1228e28e41497eeedbaf08a387f5a87a5e51bfa44cb2b9465972c196215d675b0f2e6260dcd11756f37f755e2c86b95d9a01d8102b782d16da29d22b8ae7b4e6f8883ad1f322e26fa57c80bcae8b747476d411b7adac62c233c2619ed943a4b876ea232ad1861471462392ef62494bf68e048d312d54568079b57794281c91f827e3c0a18f157c5b0e1c65d24a58a827e17c1a5378c930ffd84f3238cd837c11b905fcd88eb61f864b6079f339f45faddd987b29f6f8072eaaec4800ddb11689b7ecd78fb5204973113050a121e0fac233b40a106490989d6fff2515f0da8486682c5b705cf471df6279ec4965f206ca8896e32b9c34d589a659f18aa264672d106e0e19b5d3b1c66f6390c4519a8cd6d17f805b2f8677b6a7a8bb647356f9bf3effacac6914789ef01a39d5d775d634ec2c8921437e56501c775ea6f98e4ef902b0adf5ee88f9aa49c5f7010e6b16e6efebe134896b0c5d3c43afdfc09ae7f0588987216b055276cabb102522c103b7badfc9c42befd4e2deef1f42548e55c7de9985927e5a47be46ce1ddece4bd331a29b5a9d035deab7216ddc26c9261fe9920ea204740d41889a950cc5561d63b0070a4f8848e66172d69fb4f4a9ef5ad9a29ac9fb3ac05e14932e6ecae241ff586980da5d5d4a733f2f2a57d089ef538953137aa0883dbbd042f48f1de869728dcb57129f478199153eb1a7fd9760b4d585c6c808a537107d605516310bec2e7388d483190439d129e099ad6b04d5548a42ce1982aba0223972b107efb78e2568732db94ee9bee544b10f31adb6b1f9d8867460ac1bb5c450e40a5985c0c316ff80aa34138a361bfb291b466255a3210c72f296335e37c5073a314e7775f146eaf05ee224dc4393f28a7e8ca114448643bc0083899467574d3303e26854d5aa238a4786530804fb26961674882cf1a3f164063260b83eaa32e434b781cfd15f4a93c3bf8358b63dee87d00e9828574a92a5d539b45c37f24bd7a8c5d683da32b2f45e6859b6bca23221cb529d871ad042bda4cadf28ea4ba5bf07521e0cb0089868bbac1be6d46010ff54b331c81164211d7baa4711a898b9b49a27257f7e4017886c659e9aa19e4f9bc9bdda25c66d0fecde1dd224c7b9eab77faf1fc35dddf7aac41fb3b8102a30b9442c76cb10dd6b614bf1e3e692041d902e9b4e035a1d82665a484b778bd1bbebfb73897f9e8e0f23423eacc2d750314760364849fc49bfe1496c7f5671daec006a8f4b8305a75c00b937b20c78b4a94605cb0ae9324c8529847636b603f7ad512d5e02c681621a52f767082127b737acebb3b5b11fd93d8039027f1a47afda0ee071645304ce4bd77e458ee384159e6b5b587efef9df2066adc1e2932155486c8ab88e3a39f5616307c6ecaa44b573ebc61c2081d89d8428e997d17d016ef43d30b788b71182ab1e471588c1cced97288a4640029a6f51a74a070490db2c59403c751c0aafbe6102aa00dc361b6bdec27aee50f94a7be8695ece5ec5dcb98a80a8e18d4dd63c68bfd2bc9e14d42ff2ceefa39cef1e11084f0f1a99495a9d4c9f412748abb5e2fd1e0f45c9bd0608118b0a4460278b3723903530dd94d965419d70ee3a751e3e04a9e15008f8e51223fd921cd8a55f2ca5702231a0f64920d6b8679e79eb2c9ae29045d1bb37d4905abbafa59cbd9c5b197790ba6fce4a497be58a6a2f7a1cf12591b29226dfb22d392429adb9abc66b59f03ee64fd6d081af2197e63f971f24841804c03b129090293e14dc23bdf2f50bcd29f3e25e29e31f0b9ea46ef955319c7d788e140e97cca1ad466a0785adee2a000653f7b5b09b13463c8368dcefebbb4e761c2941bf36b6dc215e57731fd5c6633297dd722db240eacc4c98632c89e6a23d3e925db23fa3c0d4b176cd1cbc307bd7b22f6081302011e1eed53f45c63cd3d845e220701a9600d2670f78b802e9fc65c602827741b57fa7653382338de1e8f7d485d20a0bcc46f2472c9fa2bebf602c1e04ccc41210268a32699e42e3b906e50bcfba8837ca9235d17958ce868c2615f02ef8e811ae58cd7ddb196f550b521519713a543e5f8a62024e558258d37082aa6938d7e701d01b83d938945a8c84b4d1cd167b00ba7dd9edfe07c50e653f2844167133d42fd970dfacb889930514cc0581bc948ef89fcf0bd66b7968021791b468518ab65870c72a1ba2ce420d3bb897c5a55d275278d0fa7f67e638e742e83e872b2302b4b5f7bbe0a70d290cac1ac56c52d24fe589f3e1d3afcb49127ddae7004546bff062c62ca2dd8885450a3219cfd50fd84e4da6fe0fac56bcf6f9c6bcf64278b465a209adfed5c614a057ededcb7bff2c0088965aa85afcfc4d04273366da26af227c9971d84092bebdbffd14a074121d1ba617910216d1bf8edb6371c10b601340450413381867dc080cc733a50fffefebfafb7f80b51b00fdb7cdd170e0f13237e0679bac452723101dc83234b5bb1196f5165dc2aabc208994c186295fbf700b7d18e255965977a86f0eef1a2fca416265cdc114473f318f992231e0982fc26a1f35c3f8f7f5a43736b3dbddb3d1056673b6da7f83a3b609a38a86d8abb86a566bdda4413ffadaa1d6551aa6a0317812f3fc1c7769a3b8417da10e8a08cad44af99a7a8b45329702d65d234dc41b0d419d5e12c5abbb88b95e9f8161b439610ea18a474f62c40284c81380bcdf8c038a89ae78c34098f036c5047fa69d3dd1b878c53dfe695b5f8864d32d390a5d7ac2f38cb4d087e5984056ea6afcfa9ee0234576a10a784af94d92fdc6f56543da896a18e9d798f36a8506ea22f48f3eb5c22052a76de41527395f18b92e0b41ce1e4f41026061715a73fd0ec0eed3ffc31e1fc66525340bae443a40628a57f349ed51beda8ae2359c5f76249fe3f9f8429858fa18208315a9a298333d2380014232466f68e3d545191ccb7ab62e2a2984d5bc7ea28cf47c366a6218b6e0a8f67ec25ed86fb8b580b2cc49d5d9fa7647a0ad14fdb25e430260a5c28218c6e48745e3c70a16aacb1e4f074503a254cceb27b9cc0fe3cc191a1c72d1771522c51ec0a18d9cd7b6d9991028474346be9c31ccc2cf988bd23c0ee7c4cc1f4f6ab499061df36abf8824cd42b292014f9be97db9a9331eeef10ee40cc8561cfcbe8e4d364cf0cd954ff8d7ef613bb4be68fc195bc2ef2477dc962cc25551bb74b22d0477100727b0964eb70bbc1ac0baae647db86ddc9b4ab7cc4d0e12f150e764f73ab808b767bf438e3a5d42f9fa298dc7abaa9639303301689d189b64235f0eb415965d1ab3d466d6c6d1b07d4baf6075793f83dc77e41e28cfb80885827f8a506d32265c5918d036c3b23798a08f4b8268671e8435a73d7d9b09eaf040dba1459bb5d3375286baa334784e1864f848bcaeaca8607d2d18571c48938125c65eb8dfec2fd33904df9d443641eea5c250f71caddca2882c2824851a965b2751e525cef9efdddc11c54158d7dcf74f83f29fd681d17852d9d57f3948befa84fbec052cfb8109234973ca65d8d9e6bcef4f9854e5803b3aba0f2e8abad37568cc5464bde14ca3c5e76839ae278c151449cf0bb104080756b907292fe9ca1f72a631ad64e02e3066e31aa73d1b795b1c0ac4939a7314e94416dad496d5fb159fe49f9a1e5eb428c573b8aa35b47385f21441503d741872fd1730b2cbe066093f3d511c0dbe264f381361cb6f93e62da6e55c6445320de65a10040c8cfba98f908752c813f049a27450466a0517d21ce714b064cff6992cb05c330ad441f9b7862a904439ac5ecbc22b8e72375c6fe8d7c955391cdb338bff23904a681f7176fc53f05aaa07bf301b23ee5bbae34a9354369c25aafb7a39a7767509f09f5a364eb3ef5918d91ec179b9b594392f67a8fa435de527bc133ad6b489b2cc523252e7101ef287191f1f1b9854e4d2b16034c533418f616e6c3a96d426c1e246a90e70b8edb2bcd8e6e21fba0dbf250ba4d465dc788d6b750c00cbfba7e2477bf29fc19015786a729b9e3058c35d4a87b0236f7c74341f05766b4a6c51b7f990ce6736332bb7fa53b9e2882e5ee4ed3cdd0379cc9711b47fb751849d1f75f8bc1b060da4c1fadce78177c2f5c4daa6ff1c6d23eb9d9aa9b6e71369f96e243fb31702478756c77a7bebb81d6d48d478dcc6f9b44f43f9b8f29626f7d994b2fbfdb7c55d4f231dda56dcb0a04bfae52a949e6222815543d7c8a555e8241b5bb7173f9dadb2bf16c6d359273bda357b1ad603dc39140a0c02de290e0ab967f7d379854037bb712fee010c1b6e6b09d8e791fa9f9cb3bc5e60486070ab8986d4b3c480dde0e139601c63c3db6e80381975661f74cf32d8af7b38a2c15aa16710675ffa66547743fedadcdad5306fd14dd7813f249c0ecd44af802d327629e3f81be6b1e6010e004cf56a4faf4880a5e88267aa3a6143b4023ba0ed8f2d6bae6b3be370c09e5b89816926aa207db24e6c87cc073a506722c5a2d12d164a4fc0b025df68d9a52341d4142cf498c1505cbd386eea446a0dc7d8882e70b3adaac404fb45050d1eafc23d4576b21188fec0d7a55ccfc5c0b11104abb3bef167a6e10db4168d7bcd61d62c2df5106c33f57ce2cd51f9c26a0010e084986ec05be05b01c67d8e24fa75201be42b8ad29d07e5531891819b74cb2e78aa619632a0569c3b08210530dca661705a0b594a0f7b21cf172b7ae737aa68d87521b74265216d15274714d8592723b617e08ac5b7080ff010818583fa4619a6327d301130e484633028ec95fdb9c1e4906da575af185d373bdb36a85b4544b350418102531123f04398b8476dea4aa34d8c916dc5766f20dc60760d6fa2cd0aa41b9241ce69291ae44cb7ff4c2570c5b68a30001c1dd0fa442f211b1033453a6a1d3dde5b2298cc981ef9156de0659c54ab5fe378236de6c201e347b168210166de6508e669563220711a4702d104c0553efbb62bed3c724155ee6b7833365d579124d058ef11269c5f0f9eeee6ee19ed91bd1bd456d8ee55ef52f6673fc3bdc53f5d15d61e617c144c35d3752333791a4327592d30f0bb0da70f402e6e2790a3fbf842fdaf8da4b15611049a6b1f4a10f5446041f13edc03c0ffdb413a5ffde64d99e149fd68d044bc15b2c549f6ca4ebb5a80e1a4f9123eee4d989aaf079c113557af7f72a2af066bb5f58bb64e75792814005e2040221f6560e26ba7f67e8f86d98916a0442bc6a16464423454616b05976c11325b58510740ab5b4e222030173489cd49ebc29db438166d9a4dc29c8dd41a9c909833e22a67e56fdd3ea909ec3134f92edd68f6fa546e32e9803d93be02884671a1bea34854efde78ec6ecbc2487b5e2e6e48ab7731f0463cebb7bb9f6705b7651e911ab10027e22a19c9dfa324bf79f58f9550a965bda60f8fa030a6b25d7066f22df78ab82c01273d5ef08059ac93da83b522fc007601385e234f9207022f1bf4d96ca922b3d0fbf056b0aa5917e05a89962c79944fa505135c0339cb9c0a628096b65abb3fe79304a144fb142a8e0eddbbd63220c0f5420e1245927826e4124f7c2df0c75c9d6bc512680fb4bb91bdb0ef343ca5ff242152ab8f9c9d92af3b9913036e290d36d60ed53254d15ab979b5a2069914a0bc11fae5477c133419a3f144dd01704a3e7394026ec52d8f0dac21633949149988a4313cf04aa59ab45a70e03cbd269034fa25297cd3f4cf0185e94cf02cf8def2d91642c560bb061377f9ac56471eb2e908e0717acf103b1987701ba470dcba4c3147be0a26cc1915c99eefc75186ff1252abec10e15a52c67179ec0a4ba586ea31b0642303260191e6e2d1d19deda9d37e4cacde5ca9526068caaf02b6233613aa1d21b1473d9ce2e5d95ce5fae69681356248550d7eb45ce136b8028cbe1df541cad7953c25b197ed3adf32d3f9dd3442552f7767fc5c25f445c1a7ea7461007a2e3c30d76123307ac379982cd193ec6cb1d2a109ec509f0588a1b70a4fb0def95285a750f55987fd7460a90a46fc30c4dce33ff4b000f0e63bb1298c4681830dcdaf23c8a67db30e028f07db816a5ea9606b94f235838a5aed97c9fd322b9d37e887aa7596c4d79b6c5ef6715f28c44bbc4abfa191fed1d3e4527f0e0ca7865daba8858234f57140e3cb1e754f5c78370c587dff4c6e5d8f2418142ab553573f18979b05f95c489377cfa275a50118d20c6a33bcb519bb26b5e2c495b9a3a6749b6b4f921db042f860729ba77af44107b6a1d676c4a7c99b86565d489f1b302186761f4bbb386773373ad5839b53dc23655a6bb4d20cdce7d4dd7c0ab8e90211b3cc0cf6a2308ebfc83fc0c1e834d6dde20581862b576c5179b4ecb5f6a04a3f784bb73543a44b59408ebdc6a1ac8031710cf5c31171493c14ac4c3f9abb283cadb04a5adafc9bedd363e5fbeba67692caa69abe260c0d791cfa6d37e1055381dec62006db84d9f47421ef5e7268e5f2a85b3cded468531775db7d6c33763add8c7f2b89682527c30070e44b4d54102b476757c037d26d21613222918291bd762089bfe886d8172676723bd8c176f67a69663d59d06d2ca0babc54bcabf570a740b848f8987c959eed4a236bbc73ab7ca7138cd3962e80565749aff806cebe8bb2168c44b8d2d3c1c2c7fe26078956a5e887925ec48289f394a19ad789321abd6205972db2e6144671c9ad757a31db7fd97091db7e875762db7c01b601e4862242eea8ba4d980107701b795616499789361055ea7da88d4b1ff4c0455740b9cb2290e2d6c69268f7596bd5889b86f0b92823b0e43c4955236ef6f26c6dcd4adb9917de652216aa62b551a55af86dab96f4263fed1278db316990c2ffc914b2fe6f424254cfde29d37699582021d6708ff2ab76f21ed6a39b13054b6b3fa60e9ed2b681b050dd4b0af3efaa0ec45a912e549b4b682d289b1df507464d66ff2ba8f2e45e9d3bb6ec63c10fbd82dd9a6e49c945233587e82da87eaaee4490390263344fa1660982dc1959f12574ffde37845983cca07922fc0f75319ab217e664ebdc79b194e02ac958ab816519587e1acca4fecb0bd963aba110cc0a754e3b1413448113ce9cc9dec2b2c9880ab7fb3fc4098a8d445926786c6669651713894f8ba69b0698d636d372b785030a76773c2ba0a11dadacb9cc33f18f76e9134898c88705e007f12d45c3f696de4481a13c4486fcd568b47437371ceaeb5c3bbb211b4f9aaef4c1e3a0f96683ef45aec90f51bf23e2dc2dfb9ed2d2cb7fb80c7520b9dca4032174de30e58bc7f9d9eaf40e869664e87d170c6953c16d12b4758d79324d47c9c34f97aad2aae7eb61c798f9af34c2b96625e0536c5b0931fdceedec387b929fb164a0d5715f16f3d2de3bdd5f7d282223f65dc46e093632d9e08cedb10ed5d3554c263aecdea0540a43a5d83c29314bad4497d3e7f1c1edde729ec51d853d29c15977801fd36064ec15ac8fbbd59c7114f4dde54835c9ecedef3255a250cbbbbcc45151c92a692a04141c321052343bd200faea101ee8c72d9e605146904c45061c7a3acf1d34627048a871c6deba7dd1a8e9801162eb2b0540608481cb0e7bee262d2b89f93e462ce078802405eb63f2695d4edc9d3cd5c02a22b6c7bd95d37407b29e2a113da40679f1304aaa5ca92aec08acdc985f77f232a0b0f9de32c0fed3bb13b859e65913248b6bc2b71c186f5ac48375fd05bf7f45ceece8ca65b4ce327e75264d1d12486b1b6e709726058d8a0068a1107ac1e01a1b6cba60b1ca0054543059e9b5da1ba58686329ec3245355cf99e2d04e27d07f2446e8fab54a0ee41cd453004aae1b66c5d69e7a2a8a9f87dd546f7321d027a2c7aa358d0405fec0eb110622567ce455278607f05c1b032c04f3f1220deb220e2fd5f5552769bcde517a988ce1354fc0425935c8d220ea3c853bef1109994bebc66f2c26c29614bd832f0d890382d35814224e0c173d2e83b37cc3d8c8779e6a272c324ff5297d09e2f234b3f3c256219690a43d4c2d585a94460249e5c0c09d9448e457cdd9921bcef82f63ff8c0c8ca4b410345011c01f28db20a6d39865840299fa90757222b5f0da0331ec443241d43b115a342ef2a6c5c3395ee0b243d2bb52c3b9a82fda19439d382d48894b31eb3a24fa1cd85f42983a9c3dc992a52230a8d91e0e4badd33f5fe7471d01ba4b7ae89b7ee66e220b4288403e51640a34a984a3367834bb2ac8db6bce2341b144808087bf0cc3de51b9b0abb71f75d34f1b124c4a6b5b1c95897b20d828842804c2141cda623d4a2ca134e219d7dfd0f2754e25900a3dd8a30f1fdc87e27f58958cd7af7d8446a7fb3d96ade5e1bcb3f015de47e3d24db8508579347befe9324125afada274e2981d0358d5248a18122e124b615985a6c0eaeb99689270c2626c2868649c5ba7f6f17a0c7438e648f89d0cc57e7463b43a9262f489b0e650b9fa04306300b20632a90e1b6f4e3d69b3a4417cead386a6ad8bac776f04447afe5c4d6868fdaa95000ad5e1ba60af4460e710147baf586fb7a8816adfc98bd6d43932cd16b56e1d04d9d5d8bb032f57e89cca12d3cbf259ce0a8b4e00f8341494a94aeae4915a8f8bf7a202a3ca1291fc211451a6326810a12e25b1e4f9b2b41b44eac41bb016ac6c0d8c19cb8558052632c3892187a008f60b18d9471c356e8082187c6c16af703249cb6ada558ae264398b686694036bfd2e64d93506574dfac010bda8652fa7792b4a1032fa3b77e7db3e9a9a9d665b50ec1491e483b6b93959870cfb8b9a3e2c5d724ab616f69b970a425ac3aba6fe3677558506eae0262bc934d8a1ebde696c56230e5b55ba283e9c44c117a9e745f38e26cf98c39a435e1254db2813ed291394a19e866139934a3623652fc44808d60891689b3d2a35be87ad5ebd891bdf0c03d1bdf495c5604e5461b57736aa4b802a43d9b406ca00adcd9f337f13b8c64a7e58700aece3d08afe38918b9e9bacbcc02e67a94d16abba965ec0c53090747b6e93864c03897375fbb6ed9cce93bf84511dbab07a8cbd75abfdcadd7b0e099b19bf371dfd0a",
+        "0x3a65787472696e7369635f696e646578": "0x00000000",
+        "0x3a6772616e6470615f617574686f726974696573": "0x010888dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0ee0100000000000000d17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae690100000000000000",
+        "0x3db7a24cfdc9de785974746c14a99df94e7b9012096b41c4eb3aaf947f6ea429": "0x0300",
+        "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000",
+        "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x426e15054d267946093858132eb537f105fe52c2045750c3c492ccdcf62e2b9c": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x426e15054d267946093858132eb537f14e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x426e15054d267946093858132eb537f195999521c6c89cd80b677e53ce20f98c": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x426e15054d267946093858132eb537f1a47a9ff5cd5bf4d848a80a0b1a947dc3": "0x00000000000000000000000000000000",
+        "0x426e15054d267946093858132eb537f1ba7fb8745735dc3be2a2c61a72c39e78": "0x181cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc208eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27de659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e",
+        "0x426e15054d267946093858132eb537f1d0b4a3f7631f0c0e761898fe198211de": "0xe7030000",
+        "0x4342193e496fab7ec59d615ed0dc55304e7b9012096b41c4eb3aaf947f6ea429": "0x0900",
+        "0x4a83351006488ef6369cb758091f878c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x4ff3897794d496d78686afcfe760a1144e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5c0d1176a568c1f92944340dbfed9e9c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x5e8a19e3cd1b7c148b33880c479c02814e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f27b51b5ec208ee9cb25b55d8728243308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0x5f27b51b5ec208ee9cb25b55d87282434e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca0b6a45321efae92aea15e0740ec7afe7": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedca138e71612491192d68deab7e6f563fe1": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedca28dccb559b95c40168a1b2696581b5a7": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca308ce9615de0775a82f8a94dc3d285a1": "0x06",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe700e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0x5f3e4907f716ac89b6347d15ececedca3ed14b45ed20d054f05e37e2542cfe70e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc44f9aea1afa791265fae359272badc1cf8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e13000064a7b3b6e00d13000064a7b3b6e00d0000",
+        "0x5f3e4907f716ac89b6347d15ececedca422adb579f1dbf4f3886c5cfa3bb8cc4de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f13000064a7b3b6e00d13000064a7b3b6e00d0000",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca42982b9d6c7acc99faa9094c912372c2b4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca487df464e44a534ba6b0cbb32407b587": "0x0000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca5579297f4dfb9609e7e4c2ebab9ce40a": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca666fdcbb473985b3ac933d13f4acff8d": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca682db92dde20a10d96d00ff0e9e221c0b4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca6ddc7809c6da9bb6093ee22e0fda4ba8": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e169030e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca88dcde934c658227ee1dfafcd6e16903e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x0000",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a000000000e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca8bde0a0ea8864605e3b68ed9cb2da01bb4def25cfda6ef3a00000000e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x13d4fe63a7b3b6e00d13d4fe63a7b3b6e00d00",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade980e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedca9220e172bed316605f73f1ff7b4ade98e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x00",
+        "0x5f3e4907f716ac89b6347d15ececedcaa141c4fe67c2d11f4a10c6aca7a79a04b4def25cfda6ef3a00000000": "0xa8fdc74e676dc11b0000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaad811cd65a470ddc5f1d628ff0550982b4def25cfda6ef3a00000000": "0x00000000",
+        "0x5f3e4907f716ac89b6347d15ececedcab49a2738eeb30896aacb8b3fb46471bd": "0x02000000",
+        "0x5f3e4907f716ac89b6347d15ececedcac0d39ff577af2cc6b67ac3641fa9c4e7": "0x01000000",
+        "0x5f3e4907f716ac89b6347d15ececedcac29a0310e1bb45d20cace77ccb62c97d": "0x00e1f505",
+        "0x5f3e4907f716ac89b6347d15ececedcaea07de2b8f010516dca3f7ef52f7ac5a": "0x040000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaed441ceb81326c56263efbb60c95c2e4": "0x00000000000000000000000000000000",
+        "0x5f3e4907f716ac89b6347d15ececedcaf7dad0317324aecae8744b87fc95f2f3": "0x00",
+        "0x5f9cc45b7a00c5899361e1c6099678dc4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x5f9cc45b7a00c5899361e1c6099678dc8a2d09463effcc78a22d75b9cb87dffc": "0x0000000000000000",
+        "0x5f9cc45b7a00c5899361e1c6099678dcd47cb8f5328af743ddfb361e7180e7fcbb1bdbcacd6ac9340000000000000000": "0x00000000",
+        "0x6441fb391296410bd2f14381bb7494334e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x6786c4cec8d628b6598d7a70ace7acd44e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x682a59d51ab9e48a8c8cc418ff9708d24e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x6c63e84bfc5a0d62149aaab70897685c4ba24bcd9ac206424105f255ae95a355": "0xb104000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "0x6c63e84bfc5a0d62149aaab70897685c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x7474449cca95dc5d0c00e71735a6d17d4e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0x74dd702da46f77d7acf77f5a48d4af7d4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x74dd702da46f77d7acf77f5a48d4af7d62556a85fcb7c61b2c6c750924846b150e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e01be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f00b304f91831830500622780fd38770500",
+        "0x74dd702da46f77d7acf77f5a48d4af7d62556a85fcb7c61b2c6c750924846b15e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f0001fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860eb304f91831830500622780fd38770500",
+        "0x74dd702da46f77d7acf77f5a48d4af7d7a6dc62e324093ba1331bf49fdb2f24a": "0x02000000",
+        "0x74dd702da46f77d7acf77f5a48d4af7de5c03730c8f59f00941607850b6633d81fad1867486365c5b304f91831830500": "0x01be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f01fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0x7a6d38deaa01cb6e76ee69889f1696272be9a4e88368a2188d2b9100a9f3cd43": "0x00407a10f35a00000000000000000000",
+        "0x7a6d38deaa01cb6e76ee69889f16962730256ea2c545a3e5e3744665ffb2ed28": "0x00020000",
+        "0x7a6d38deaa01cb6e76ee69889f1696273f0d64e1907361c689834a9c1cb0fbe0": "0x20000000",
+        "0x7a6d38deaa01cb6e76ee69889f16962749d67997de33812a1cc37310f765b82e": "0x0080c6a47e8d03000000000000000000",
+        "0x7a6d38deaa01cb6e76ee69889f1696274e7b9012096b41c4eb3aaf947f6ea429": "0x0300",
+        "0x7a6d38deaa01cb6e76ee69889f169627ba93302f3b868c50785e6ade45c6a1d8": "0x10000000",
+        "0x7cda3cfa86b349fdafce4979b197118f4e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a8910c174c55fd2c633e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e": "0x04e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a893e73123ebcdee9161cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c": "0x041cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a894f58b588ac077bd5306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20": "0x04306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89518366b5b1bc7c99d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0x04d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89a647e755c30521d38eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0x048eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118f71cd3068e6118bfb392b798317f63a89dd4e3f25f5378a6d90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22": "0x0490b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x7cda3cfa86b349fdafce4979b197118fba7fb8745735dc3be2a2c61a72c39e78": "0x181cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c000064a7b3b6e00d000000000000000000000000000000000000000000000000306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20000064a7b3b6e00d0000000000000000000000000000000000000000000000008eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48000064a7b3b6e00d00000000000000000000000000000000000000000000000090b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22000064a7b3b6e00d000000000000000000000000000000000000000000000000d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d000064a7b3b6e00d000000000000000000000000000000000000000000000000e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e000064a7b3b6e00d000000000000000000000000000000000000000000000000",
+        "0x89d139e01a5eb2256f222e5fc5dbe6b34e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0x913b40454eb582a66ab74c86f6137db94e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xa0eb495036d368196a2b6c51d9d788814e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa2ce73642c549ae79c14f0a671cf45f94e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa37f719efab16103103a0c8c2c784ce14e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xa42f90c8b47838c3a5332d85ee9aa5c34e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xa8c65209d47ee80f56b0011e8fd91f504e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xaebd463ed9925c488c112434d61debc04e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xaebd463ed9925c488c112434d61debc0ba7fb8745735dc3be2a2c61a72c39e78": "0x18d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c",
+        "0xbd2a529379475088d3e29a918cd478724e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc632a5935f6edc617ae178fef9eb1e211fbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x047374616b696e6720000064a7b3b6e00d000000000000000002",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f218f26c73add634897550b4003b26bc66f2e33376834a63c86a195bcf685aebbfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0x047374616b696e6720000064a7b3b6e00d000000000000000002",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f308ce9615de0775a82f8a94dc3d285a1": "0x01",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x0040fa7f398074858a02000000000000",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb30e5be00fbc2e15b5fe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e": "0xd17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae698eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3e535263148daaf49be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f": "0x88dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0eed43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d",
+        "0xcec5070d609dd3497f72bde07fc96ba04e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19500e3a507571a62417696d6f6e808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19505905fe216cc5924c6772616e80d17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae69": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195066b8d48da86b869b6261626580d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19509d4a4cfe1c2ef0b961756469808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950c9b0c13125732d276175646980d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950d62c40514b41f31962616265808eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48": "0xfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950ed43a85541921049696d6f6e80d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950f5537bdb2a1f626b6772616e8088dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0ee": "0xbe5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f",
+        "0xcec5070d609dd3497f72bde07fc96ba088dcde934c658227ee1dfafcd6e16903": "0x08be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25ffe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860e",
+        "0xcec5070d609dd3497f72bde07fc96ba0e0cdd062e6eaf24295ad4ccfc41d4609": "0x08be5ddb1579b72e84524fc29e78609e3caf42e85aa118ebfe0b0ad404b5bdd25f88dc3417d5058ec4b4503e0c12ea1a0a89be200fe98922423d4334014fa6b0eed43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27dfe65717dad0447d715f660a0a58411de509b42e6efb8375f562f58a554d5860ed17c2d7823ebf260fd138f2d7e27d114c0145d968b5ff5006125f2414fadae698eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a488eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48",
+        "0xd57bce545fb382c34570e5dfbf338f5e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd5c41b52a371aa36c9254ce34324f2a54e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd5e1a2fa16732ce6906189438c0a82c64e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xd8f314b7f4e6b095f0f8ee4656a448254e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xed25f63942de25ac5253ba64b5eb64d14e7b9012096b41c4eb3aaf947f6ea429": "0x0400",
+        "0xed25f63942de25ac5253ba64b5eb64d1ba7fb8745735dc3be2a2c61a72c39e78": "0x18d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a4890b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22306721211d5404bd9da88e0204360a1a9ab8b87c66c1bc2fcdd37f3c2222cc20e659a7a1628cdd93febc04a4e0646ea20e9f5f0ce097d9a05290d4a9e054df4e1cbd2d43530a44705ad088af313e18f80b53ef16b36177cd4b77b846f2a5f07c",
+        "0xede8e4fdc3c8b556f0ce2f77fc2575e34e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xedfb05b766f199ce00df85317e33050e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000",
+        "0xf2794c22e353e9a839f12faab03a911b4e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xf2794c22e353e9a839f12faab03a911b7f17cdfbfa73331856cca0acddd7842e": "0x00000000",
+        "0xf2794c22e353e9a839f12faab03a911bbdcb0c5143a8617ed38ae3810dd45bc6": "0x00000000",
+        "0xf2794c22e353e9a839f12faab03a911be2f6cb0456905c189bcb0458f9440f13": "0x00000000",
+        "0xf5a4963e4efb097983d7a693b0c1ee454e7b9012096b41c4eb3aaf947f6ea429": "0x0100",
+        "0xfbc9f53700f75f681f234e70fb7241eb4e7b9012096b41c4eb3aaf947f6ea429": "0x0000"
+      },
+      "childrenDefault": {}
+    }
+  }
+}
\ No newline at end of file
diff --git a/substrate/zombienet/0003-block-building-warp-sync/test-block-building-warp-sync.toml b/substrate/zombienet/0003-block-building-warp-sync/test-block-building-warp-sync.toml
new file mode 100644
index 0000000000000000000000000000000000000000..5119c919c70c4b42271ed9ae9ce2417de0b55c88
--- /dev/null
+++ b/substrate/zombienet/0003-block-building-warp-sync/test-block-building-warp-sync.toml
@@ -0,0 +1,30 @@
+[settings]
+enable_tracing = false
+
+[relaychain]
+default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}"
+default_command = "substrate"
+
+chain = "gen-db"
+chain_spec_path = "zombienet/0003-block-building-warp-sync/chain-spec.json"
+
+  #we need at least 3 nodes for warp sync
+  [[relaychain.nodes]]
+  name = "alice"
+  validator = true
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  [[relaychain.nodes]]
+  name = "bob"
+  validator = true
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  [[relaychain.nodes]]
+  name = "charlie"
+  validator = false
+  db_snapshot="https://storage.googleapis.com/zombienet-db-snaps/substrate/0001-basic-warp-sync/chains-a233bbacff650aac6bcb56b4e4ef7db7dc143cfb.tgz"
+
+  [[relaychain.nodes]]
+  name = "dave"
+  validator = false
+  args = ["--sync warp"]
diff --git a/substrate/zombienet/0003-block-building-warp-sync/test-block-building-warp-sync.zndsl b/substrate/zombienet/0003-block-building-warp-sync/test-block-building-warp-sync.zndsl
new file mode 100644
index 0000000000000000000000000000000000000000..a4ba46017a3f737aea6effcdb5b9d85e9a8196cb
--- /dev/null
+++ b/substrate/zombienet/0003-block-building-warp-sync/test-block-building-warp-sync.zndsl
@@ -0,0 +1,30 @@
+Description: Warp sync
+Network: ./test-block-building-warp-sync.toml
+Creds: config
+
+alice: reports node_roles is 4
+bob: reports node_roles is 4
+charlie: reports node_roles is 1
+dave: reports node_roles is 1
+
+alice: reports peers count is at least 3 within 60 seconds
+bob: reports peers count is at least 3 within 60 seconds
+charlie: reports peers count is at least 3 within 60 seconds
+dave: reports peers count is at least 3 within 60 seconds
+
+
+# db snapshot has 12133 blocks
+dave: reports block height is at least 1 within 60 seconds
+dave: reports block height is at least 12132 within 60 seconds
+dave: reports block height is at least 12133 within 60 seconds
+
+alice: reports block height is at least 12133 within 60 seconds
+bob: reports block height is at least 12133 within 60 seconds
+charlie: reports block height is at least 12133 within 60 seconds
+
+dave: log line matches "Warp sync is complete" within 60 seconds
+# workaround for: https://github.com/paritytech/zombienet/issues/580
+dave: count of log lines containing  "Block history download is complete" is 1 within 10 seconds
+
+dave: count of log lines containing "error" is 0 within 10 seconds
+dave: count of log lines containing "verification failed" is 0 within 10 seconds